diff --git a/docs/notebooks/fasttext-position-weights.ipynb b/docs/notebooks/fasttext-position-weights.ipynb new file mode 100644 index 0000000000..b4c0d769c2 --- /dev/null +++ b/docs/notebooks/fasttext-position-weights.ipynb @@ -0,0 +1,1038 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Position-Dependent Weighting in Gensim's FastText\n", + "## Introduction\n", + "\n", + "[Mikolov et al. (2017, Section 2.2)][mikolov17advances-sec-2-2] introduced a position-dependent weighting to the context vector computation in the fastText CBOW language model. They reported that this extension has led to **5 point improvement in total accuracy** on the English word analogy task when a larger context window has been used:\n", + "\n", + "> | Model | Semantic | Syntactic | Total |\n", + "> |:------|:---------|:----------|:------|\n", + "> | cbow + uniq | 79 % | 73 % | 76 % |\n", + "> | cbow + uniq + phrases | 82 % | 78 % | 80 % |\n", + "> | cbow + uniq + phrases + weighting | 87 % | 82 % | 85 % |\n", + "\n", + "\n", + "Despite the usefulness of the position-dependent weighting extension, it has [not been implemented to Facebook's fastText yet][facebookresearch/fastText#445].\n", + "\n", + "In this Jupyter notebook, we are going to answer the following three research questions (RQ):\n", + "\n", + "1. Are the results of Mikolov et al. (2017) reproducible in Gensim?\n", + "2. Can position-dependent weight vectors be replaced with position-dependent scalar weights with no loss of accuracy?\n", + "3. Is the speed of position-dependent weight vectors sufficient to be practically useful?\n", + "\n", + "## Methods\n", + "\n", + "The CBOW fastText models use the default parameters described by [Bojanowski et al. (2017, Section 4.3)][bojanowski17enriching] with the exception of the number of negative samples, the sampling threshold, and the window size described by [Mikolov et al. (2017, Section 4)][mikolov17advances-sec-4]. To our knowledge, these parameters are the SOTA on the English word analogy task.\n", + "\n", + "- hash table bucket size $2\\times10^6$,\n", + "- $300$ vector dimensions,\n", + "- negative sampling loss with $10$ negative samples,\n", + "- initial learning rate $0.05$,\n", + "- sampling threshold $10^{-5}$,\n", + "- $n$-gram sizes $\\{3, 4, 5, 6\\}$, and\n", + "- minimum word count $5$,\n", + "- window size $15$ with position-dependent weighting and $5$ without position-dependent weighting.\n", + "\n", + " [bojanowski17enriching]: https://arxiv.org/pdf/1607.04606.pdf#page=4 (Enriching Word Vectors with Subword Information)\n", + " [mikolov17advances-sec-2-2]: https://arxiv.org/pdf/1712.09405.pdf#page=2 (Advances in Pre-Training Distributed Word Representations)\n", + " [mikolov17advances-sec-4]: https://arxiv.org/pdf/1712.09405.pdf#page=3 (Advances in Pre-Training Distributed Word Representations)\n", + " [grave18learning]: https://arxiv.org/pdf/1802.06893.pdf#page=4 (Learning Word Vectors for 157 Languages)\n", + " [facebookresearch/fastText#445]: https://github.com/facebookresearch/fastText/issues/445 (Learn words representation with CBOW plus position-weights)\n", + " [#2698]: https://github.com/RaRe-Technologies/gensim/pull/2698 (KeyedVectors improvements)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "FASTTEXT_PARAMETERS = {\n", + " 'sg': 0,\n", + " 'bucket': 2 * 10**6,\n", + " 'negative': 10,\n", + " 'alpha': 0.05,\n", + " 'min_alpha': 0,\n", + " 'sample': 10**-5,\n", + " 'min_n': 3,\n", + " 'max_n': 6,\n", + " 'min_count': 5,\n", + " 'workers': 32,\n", + "}" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To answer **RQ1**, we are going to measure speed and word analogy task accuracies four times:\n", + "\n", + "1. with the `develop` branch (before [#2698][] has been merged),\n", + "2. with the `develop` branch (after [#2698][] has been merged),\n", + "3. with position-dependent weighting implemented on top of `develop` and switched off, and\n", + "4. with position-dependent weighting implemented on top of `develop` and switched on.\n", + "\n", + "The expected scenario is that the first three tests yield the same results with insignificant differences in both accuracy and speed (otherwise, our implementation or [#2698][] are incorrect), and that the fourth test reproduces the accuracies reported by Mikolov et al. with insignificant speed loss.\n", + "\n", + "To answer **RQ2**, we are going to test both position-dependent weight vectors and position-dependent scalar weights and compare them in terms of speed and accuracy.\n", + "\n", + "To answer **RQ3**, we are going to train fastText without position-dependent weighting for an additional number of epochs that corresponds to the slow-down caused by position-dependent weighting. If fastText without position-dependent weighting can achieve the same of higher accuracy, we will conclude that position-dependent weighting is not practically useful.\n", + "\n", + " [bojanowski17enriching]: https://arxiv.org/pdf/1607.04606.pdf#page=4 (Enriching Word Vectors with Subword Information)\n", + " [mikolov17advances]: https://arxiv.org/pdf/1712.09405.pdf#page=2 (Advances in Pre-Training Distributed Word Representations)\n", + " [grave18learning]: https://arxiv.org/pdf/1802.06893.pdf#page=4 (Learning Word Vectors for 157 Languages)\n", + " [facebookresearch/fastText#445]: https://github.com/facebookresearch/fastText/issues/445 (Learn words representation with CBOW plus position-weights)\n", + " [#2698]: https://github.com/RaRe-Technologies/gensim/pull/2698 (KeyedVectors improvements)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "RARE_URL = 'https://github.com/RaRe-Technologies/gensim.git'\n", + "WITIKO_URL = 'https://github.com/Witiko/gensim.git'\n", + "\n", + "BEFORE_2698_REF = '2360459'\n", + "AFTER_2698_REF = 'c0e0169'\n", + "VECTOR_PDW_REF = '0c9a8be3'\n", + "SCALAR_PDW_REF = 'bd2596aa'\n", + "\n", + "BEFORE_2698_PARAMETERS = {'iter': 1, 'size': 300}\n", + "AFTER_2698_PARAMETERS = {'epochs': 1, 'vector_size': 300}\n", + "\n", + "REPOSITORIES = {\n", + " 'Branch develop, before #2698 has been merged': (RARE_URL, BEFORE_2698_REF, BEFORE_2698_PARAMETERS),\n", + " 'Branch develop, after #2698 has been merged': (RARE_URL, AFTER_2698_REF, AFTER_2698_PARAMETERS),\n", + " 'Branch positional-dependent-scalars': (WITIKO_URL, SCALAR_PDW_REF, AFTER_2698_PARAMETERS),\n", + " 'Branch positional-dependent-vectors': (WITIKO_URL, VECTOR_PDW_REF, AFTER_2698_PARAMETERS),\n", + "}\n", + "\n", + "CONFIGURATIONS = {\n", + " 'CBOW+NS': {},\n", + " 'CBOW+NS+PDW': {'position_dependent_weights': 1},\n", + "}\n", + "\n", + "VARIANTS = {\n", + " 'Window size 5': {'window': 5},\n", + " 'Window size 15': {'window': 15},\n", + "}" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "For our experiments, we are using a machine with 252G RAM, 32 Intel Xeon X7560 2.26 GHz CPU cores, and OpenBLAS.\n", + "\n", + " [#2698]: https://github.com/RaRe-Technologies/gensim/pull/2698 (KeyedVectors improvements)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "blas_mkl_info:\n", + " NOT AVAILABLE\n", + "blis_info:\n", + " NOT AVAILABLE\n", + "openblas_info:\n", + " libraries = ['openblas', 'openblas']\n", + " library_dirs = ['/usr/local/lib']\n", + " language = c\n", + " define_macros = [('HAVE_CBLAS', None)]\n", + "blas_opt_info:\n", + " libraries = ['openblas', 'openblas']\n", + " library_dirs = ['/usr/local/lib']\n", + " language = c\n", + " define_macros = [('HAVE_CBLAS', None)]\n", + "lapack_mkl_info:\n", + " NOT AVAILABLE\n", + "openblas_lapack_info:\n", + " libraries = ['openblas', 'openblas']\n", + " library_dirs = ['/usr/local/lib']\n", + " language = c\n", + " define_macros = [('HAVE_CBLAS', None)]\n", + "lapack_opt_info:\n", + " libraries = ['openblas', 'openblas']\n", + " library_dirs = ['/usr/local/lib']\n", + " language = c\n", + " define_macros = [('HAVE_CBLAS', None)]\n" + ] + } + ], + "source": [ + "import numpy as np\n", + "\n", + "np.show_config()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To select the optimal parameters of fastText with and without position-dependent weighting, we train on the 2017 English Wikipedia dataset (2.4B tokens) and evaluate on the English Word Analogy Task first introduced in the [2013 “Distributed Representations of Words and Phrases and their Compositionality” paper by Milolov et al.][distributed]\n", + "\n", + " [distributed]: https://papers.nips.cc/paper/5021-distributed-representations-of-words-and-phrases-and-their-compositionality.pdf" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "WORD_ANALOGY_DATASET_FILENAME = 'data/word-analogies/questions-words.txt'" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "%%bash -e -c 'LC_ALL=C bash'\n", + "set -e\n", + "if ! [ -e data/word-analogies ]\n", + "then\n", + " mkdir -p data/word-analogies\n", + " cd data/word-analogies\n", + " wget https://raw.githubusercontent.com/tmikolov/word2vec/master/questions-words.txt\n", + "fi" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [], + "source": [ + "from itertools import chain\n", + "\n", + "CORPUS_NAME = 'wiki-english-20171001'\n", + "CORPUS_NUM_ARTICLES = 4924894\n", + "\n", + "def _read_sentences_helper(article):\n", + " from gensim.utils import simple_preprocess\n", + " all_sentences = []\n", + " for section_title, section_text in zip(article['section_titles'], article['section_texts']):\n", + " sentences = section_text.splitlines()\n", + " sentences = map(str.strip, sentences)\n", + " sentences = (sentence for sentence in sentences if sentence)\n", + " sentences = chain([section_title], sentences)\n", + " sentences = map(simple_preprocess, sentences)\n", + " all_sentences.extend(sentences)\n", + " return all_sentences\n", + "\n", + "class CorpusSentenceIterator(object):\n", + " \"\"\"Reads tokenized sentences from a downloaded Wikipedia corpus.\n", + "\n", + " Parameters\n", + " ----------\n", + " language : str\n", + " The language of the Wikipedia corpus.\n", + "\n", + " \"\"\"\n", + " def __init__(self):\n", + " self.iterable = None\n", + "\n", + " def __iter__(self):\n", + " self.__init__()\n", + " return self\n", + "\n", + " def _read_sentences(self, percentage=1.0):\n", + " assert CURRENT_GENSIM_URL_AND_REF is not None # _reinstall_gensim has been called prior to importing gensim\n", + " import gensim.downloader\n", + " from tqdm import tqdm\n", + " num_articles = int(CORPUS_NUM_ARTICLES * percentage)\n", + " articles = gensim.downloader.load(CORPUS_NAME)\n", + " articles = (article for article, _ in zip(articles, range(num_articles)))\n", + " articles = tqdm(articles, desc='Reading articles from the {} corpus'.format(CORPUS_NAME), total=num_articles)\n", + " from multiprocessing import Pool\n", + " with Pool(None) as pool:\n", + " for sentences in pool.imap_unordered(_read_sentences_helper, articles):\n", + " for sentence in sentences:\n", + " yield sentence \n", + "\n", + " def __next__(self):\n", + " if self.iterable is None:\n", + " self.iterable = self._read_sentences()\n", + " corpus_sentence = next(self.iterable)\n", + " return corpus_sentence" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "For performance estimation, we train on the [deduplicated Common Crawl][] (???B tokens) and evaluate on ??? in addition to the English analogy task.\n", + "\n", + " [deduplicated common crawl]: http://statmt.org/ngrams/deduped/ (Deduplicated CommonCrawl Text)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# TODO" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Results" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [], + "source": [ + "CURRENT_GENSIM_URL_AND_REF = None\n", + "\n", + "from itertools import product\n", + "\n", + "def _reinstall_gensim(url, ref):\n", + " global CURRENT_GENSIM_URL_AND_REF\n", + " if CURRENT_GENSIM_URL_AND_REF == (url, ref):\n", + " return # only reinstall when necessary\n", + " ! pip uninstall gensim -y\n", + " ! cd /var/tmp && \\\n", + " rm -rf gensim && \\\n", + " git clone {url} && \\\n", + " cd gensim && \\\n", + " git checkout {ref} && \\\n", + " TMPDIR=/var/tmp pip install . && \\\n", + " python setup.py build_ext --inplace && \\\n", + " python -c 'from gensim.models import FastText' && \\\n", + " cd .. && \\\n", + " rm -rf gensim\n", + " from sys import modules\n", + " if 'gensim' in modules:\n", + " raise RuntimeError('Restart the kernel and rerun the Jupyter notebook')\n", + " import gensim.downloader\n", + " gensim.downloader.load(CORPUS_NAME)\n", + " CURRENT_GENSIM_URL_AND_REF = (url, ref)\n", + "\n", + "def _stringify_parameters(parameters):\n", + " parameters = sorted(parameters.items())\n", + " import re\n", + " def stringify(obj): return re.sub('_', '-', str(obj))\n", + " parameters = ('{}={}'.format(stringify(key), stringify(value)) for key, value in parameters if key != 'url')\n", + " parameters = '_'.join(parameters)\n", + " return parameters\n", + "\n", + "def _format_duration(duration):\n", + " hours = int(duration // 3600)\n", + " minutes = int((duration % 3600) // 60)\n", + " seconds = int(round((duration % 60)))\n", + " return '{:2d}h {:02d}m {:02d}s'.format(hours, minutes, seconds)\n", + "\n", + "def _format_accuracy(accuracy):\n", + " return '{:.2f}%'.format(100.0 * accuracy)\n", + "\n", + "def _train(fasttext_model_filename, fasttext_parameters, only_load=False):\n", + " training_duration_filename = '{}.duration'.format(fasttext_model_filename)\n", + " try:\n", + " with open(training_duration_filename, 'rt') as f:\n", + " training_duration = float(f.read())\n", + " except IOError as e:\n", + " if only_load:\n", + " raise e\n", + " from datetime import datetime\n", + " assert CURRENT_GENSIM_URL_AND_REF is not None # # _reinstall_gensim has been called prior to importing gensim\n", + " from gensim.models.fasttext import FastText\n", + " training_start_time = datetime.now()\n", + " corpus_sentences = CorpusSentenceIterator()\n", + " fasttext_model = FastText(corpus_sentences, **fasttext_parameters)\n", + " training_finish_time = datetime.now()\n", + " training_duration = (training_finish_time - training_start_time).total_seconds()\n", + " ! mkdir -p data/models\n", + " fasttext_model.save(fasttext_model_filename)\n", + " with open(training_duration_filename, 'wt') as f:\n", + " print(training_duration, file=f)\n", + " return training_duration\n", + "\n", + "def _evaluate(fasttext_model_filename, word_analogy_dataset_filename, only_load=False):\n", + " word_analogy_accuracy_filename = '{}.accuracy'.format(fasttext_model_filename)\n", + " try:\n", + " with open(word_analogy_accuracy_filename, 'rt') as f:\n", + " word_analogy_accuracy = float(f.read())\n", + " except IOError:\n", + " if only_load:\n", + " raise e\n", + " assert CURRENT_GENSIM_URL_AND_REF is not None # # _reinstall_gensim has been called prior to importing gensim\n", + " from gensim.models.fasttext import FastText\n", + " fasttext_model = FastText.load(fasttext_model_filename)\n", + " def evaluate(*args, **kwargs): return fasttext_model.wv.evaluate_word_analogies(*args, **kwargs)\n", + " word_analogy_accuracy, _ = evaluate(word_analogy_dataset_filename, restrict_vocab=200000)\n", + " with open(word_analogy_accuracy_filename, 'wt') as f:\n", + " print(word_analogy_accuracy, file=f)\n", + " return word_analogy_accuracy\n", + "\n", + "def _train_fasttext_model(install_parameters, fasttext_parameters, fasttext_model_filename):\n", + " train_parameters = (fasttext_model_filename, fasttext_parameters)\n", + " evaluate_parameters = (fasttext_model_filename, WORD_ANALOGY_DATASET_FILENAME)\n", + " \n", + " try:\n", + " training_duration = _train(*train_parameters, only_load=True)\n", + " except IOError:\n", + " _reinstall_gensim(**install_parameters)\n", + " training_duration = _train(*train_parameters)\n", + " word_analogy_accuracy = _evaluate(*evaluate_parameters)\n", + " else:\n", + " try:\n", + " word_analogy_accuracy = _evaluate(*evaluate_parameters, only_load=True)\n", + " except IOError:\n", + " _reinstall_gensim(**install_parameters)\n", + " word_analogy_accuracy = _evaluate(*evaluate_parameters)\n", + " \n", + " return (training_duration, word_analogy_accuracy)\n", + "\n", + "def _plot_positional_weights(install_parameters, fasttext_parameters, fasttext_model_filename):\n", + " vector_filename = '{}.vectors_positions.npy'.format(fasttext_model_filename)\n", + " try:\n", + " vectors = np.load(vector_filename)\n", + " except IOError:\n", + " _reinstall_gensim(**install_parameters)\n", + " from gensim.models.fasttext import FastText\n", + " fasttext_model = FastText.load(fasttext_model_filename)\n", + " vectors = fasttext_model.wv.vectors_positions\n", + " np.save(vector_filename, vectors)\n", + "\n", + " if len(vectors.shape) == 1:\n", + " _plot_positional_scalar_weights(vectors)\n", + " else:\n", + " _plot_positional_weight_vectors(vectors)\n", + "\n", + "def _plot_positional_scalar_weights(vectors):\n", + " import matplotlib.pyplot as plt\n", + " fig = plt.figure(figsize=(15, 4))\n", + " ax = plt.axes()\n", + " X = np.arange(vectors.shape[0]) + 1\n", + " Y = vectors\n", + " ax.plot(X, Y)\n", + " ax.grid()\n", + " ax.set_title('Positional scalar weights')\n", + " ax.set_xlim(1, vectors.shape[0])\n", + " ax.set_xlabel('position')\n", + " ax.set_ylabel('weight')\n", + "\n", + "def _plot_varying_parameters(parameter_name, parameter_values, training_durations, word_analogy_accuracies,\n", + " labels, legend_loc, xscale):\n", + " from itertools import cycle\n", + " import matplotlib.pyplot as plt\n", + " from matplotlib.ticker import FuncFormatter\n", + " from scipy.interpolate import interp1d\n", + " fig = plt.figure(figsize=(15, 4))\n", + " ax1 = plt.axes()\n", + " ax2 = ax1.twinx()\n", + " ax1.set_xscale(xscale)\n", + " ax2.set_xscale(xscale)\n", + " color1 = 'tab:red'\n", + " color2 = 'tab:blue'\n", + " lines = [\"-\",\"--\",\"-.\",\":\"]\n", + " lines = cycle(lines)\n", + " X = parameter_values\n", + " yformatter1 = FuncFormatter(lambda x, _: _format_accuracy(x))\n", + " yformatter2 = FuncFormatter(lambda x, _: _format_duration(x))\n", + " axes = ((ax1, color1, 'Accuracy', yformatter1), (ax2, color2, 'Training duration', yformatter2))\n", + " for ax, color, ylabel, yformatter in axes:\n", + " ax.grid(color=color, alpha=0.3)\n", + " ax.set_xlim(min(X), max(X))\n", + " ax.set_xlabel('Parameter “{}”'.format(parameter_name))\n", + " ax.set_ylabel(ylabel, color=color)\n", + " ax.tick_params(axis='y', labelcolor=color)\n", + " ax.yaxis.set_major_formatter(yformatter)\n", + " if xscale == 'log':\n", + " X = np.log(parameter_values)\n", + " X_ = np.linspace(min(X), max(X), num=500, endpoint=True)\n", + " for Y1, Y2, label, line in zip(word_analogy_accuracies, training_durations, labels, lines):\n", + " if xscale == 'log':\n", + " ax1.scatter(np.exp(X), Y1, marker='o', color=color1)\n", + " ax2.scatter(np.exp(X), Y2, marker='o', color=color2)\n", + " else:\n", + " ax1.scatter(X, Y1, marker='o', color=color1)\n", + " ax2.scatter(X, Y2, marker='o', color=color2)\n", + " F1 = interp1d(X, Y1, kind='quadratic')\n", + " F2 = interp1d(X, Y2, kind='quadratic')\n", + " Y1_ = F1(X_)\n", + " Y2_ = F2(X_)\n", + " if xscale == 'log':\n", + " ax1.plot(np.exp(X_), Y1_, line, color=color1)\n", + " ax2.plot(np.exp(X_), Y2_, line, color=color2)\n", + " else:\n", + " ax1.plot(X_, Y1_, line, color=color1)\n", + " ax2.plot(X_, Y2_, line, color=color2)\n", + " if label:\n", + " ax1.plot([], [], line, color='k', label=label)\n", + " if any(labels):\n", + " ax1.legend(loc=legend_loc)\n", + "\n", + "def _plot_positional_weight_vectors(vectors):\n", + " from mpl_toolkits import mplot3d\n", + " import matplotlib.pyplot as plt\n", + " from matplotlib import cm\n", + " fig = plt.figure(figsize=(30, 15))\n", + " ax = plt.axes(projection='3d')\n", + " X, Y = np.arange(vectors.shape[0]) + 1, np.arange(vectors.shape[1]) + 1\n", + " X, Y = np.meshgrid(X, Y)\n", + " Z = vectors[X - 1, Y - 1]\n", + " ax.plot_surface(X, Y, Z, rstride=1, cstride=1, cmap='viridis', edgecolor='none')\n", + " ax.set_title('Positional weight vectors')\n", + " ax.set_xlim(1, vectors.shape[0])\n", + " ax.set_ylim(1, vectors.shape[1])\n", + " ax.set_xlabel('position')\n", + " ax.set_ylabel('feature')\n", + " ax.set_zlabel('weight')\n", + "\n", + "def _resolve_text_specification(repository, configuration, variant, **call_fasttext_parameters):\n", + " configuration_fasttext_parameters = CONFIGURATIONS[configuration]\n", + " url, ref, repository_fasttext_parameters = REPOSITORIES[repository]\n", + " variant_fasttext_parameters = VARIANTS[variant]\n", + " fasttext_parameters = {\n", + " **FASTTEXT_PARAMETERS,\n", + " **configuration_fasttext_parameters,\n", + " **repository_fasttext_parameters,\n", + " **variant_fasttext_parameters,\n", + " **call_fasttext_parameters,\n", + " }\n", + " install_parameters = {'url': url, 'ref': ref}\n", + " parameter_string = _stringify_parameters({**fasttext_parameters, **install_parameters})\n", + " fasttext_model_filename = 'data/models/fasttext-model_{}'.format(parameter_string)\n", + " return (install_parameters, fasttext_parameters, fasttext_model_filename)\n", + "\n", + "def plot_positional_weights(*args, **kwargs):\n", + " _plot_positional_weights(*_resolve_text_specification(*args, **kwargs))\n", + "\n", + "def train_fasttext_model(*args, **kwargs):\n", + " training_duration, word_analogy_accuracy = _train_fasttext_model(*_resolve_text_specification(*args, **kwargs))\n", + " print('Training duration: {}'.format(_format_duration(training_duration)))\n", + " print('English word analogy task, total accuracy: {}'.format(_format_accuracy(word_analogy_accuracy)))\n", + "\n", + "def plot_varying_parameter(*args, **kwargs):\n", + " plot_varying_parameters(args, **kwargs)\n", + "\n", + "def plot_varying_parameters(*args_list, labels=None, legend_loc='right', xscale='linear', **kwargs):\n", + " from itertools import repeat\n", + " assert len(kwargs) == 1\n", + " parameter_name, parameter_values = next(iter(kwargs.items()))\n", + " training_durations_list, word_analogy_accuracies_list = [], []\n", + " if labels is None:\n", + " labels = list(repeat(None, len(args_list)))\n", + " for args in args_list:\n", + " training_durations, word_analogy_accuracies = zip(*(\n", + " _train_fasttext_model(*_resolve_text_specification(*args, **{parameter_name: parameter_value}))\n", + " for parameter_value in parameter_values\n", + " ))\n", + " training_durations_list.append(training_durations)\n", + " word_analogy_accuracies_list.append(word_analogy_accuracies)\n", + " args = (parameter_name, parameter_values, training_durations_list, word_analogy_accuracies_list)\n", + " _plot_varying_parameters(*args, labels=labels, legend_loc=legend_loc, xscale=xscale)\n", + "\n", + "def _plot_results(result_number, format_result):\n", + " import pandas as pd\n", + " from IPython.display import display, HTML\n", + " tuples = list(product(REPOSITORIES, CONFIGURATIONS, VARIANTS))\n", + " filtered_tuples = []\n", + " results = []\n", + " for args in tuples:\n", + " repository, configuration, variant = args\n", + " if 'Branch develop' in repository and '+PDW' in configuration:\n", + " continue\n", + " filtered_tuples.append(args)\n", + " result = _train_fasttext_model(*_resolve_text_specification(*args))[result_number]\n", + " result = format_result(result)\n", + " results.append(result)\n", + " index = pd.MultiIndex.from_tuples(filtered_tuples, names=['repository', 'configuration', 'variant'])\n", + " df = pd.Series(results, index=index).unstack(level=2)\n", + " df = df[VARIANTS]\n", + " df = df.T[REPOSITORIES].T\n", + " display(HTML(df.T.to_html()))\n", + "\n", + "def plot_durations():\n", + " _plot_results(0, _format_duration)\n", + "\n", + "def plot_accuracies():\n", + " _plot_results(1, _format_accuracy)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Parameter Optimization" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plot_varying_parameter('Branch positional-dependent-vectors', 'CBOW+NS+PDW', 'Window size 15',\n", + " position_dependent_vector_size=range(0, 301, 5))" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plot_varying_parameters(('Branch positional-dependent-vectors', 'CBOW+NS', 'Window size 5'),\n", + " ('Branch positional-dependent-vectors', 'CBOW+NS+PDW', 'Window size 15'),\n", + " vector_size=range(100, 801, 100), labels=['pdw=0, window=5', 'pdw=1, window=15'])" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plot_varying_parameters(('Branch positional-dependent-vectors', 'CBOW+NS', 'Window size 5'),\n", + " ('Branch positional-dependent-vectors', 'CBOW+NS+PDW', 'Window size 15'),\n", + " window=(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 15, 20, 25, 30, 40, 50),\n", + " labels=['pdw=0', 'pdw=1'], legend_loc='center')" + ] + }, + { + "cell_type": "code", + "execution_count": 53, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plot_varying_parameters(('Branch positional-dependent-vectors', 'CBOW+NS', 'Window size 5'),\n", + " ('Branch positional-dependent-vectors', 'CBOW+NS+PDW', 'Window size 15'),\n", + " sample=(10**-3, 10**-4, 10**-5, 10**-6), xscale='log',\n", + " labels=['pdw=0, window=5', 'pdw=1, window=15'], legend_loc='upper left')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Performance Estimation\n", + "Below are the training durations of the fastText models:" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
repositoryBranch develop, before #2698 has been mergedBranch develop, after #2698 has been mergedBranch positional-dependent-scalarsBranch positional-dependent-vectors
configurationCBOW+NSCBOW+NSCBOW+NSCBOW+NS+PDWCBOW+NSCBOW+NS+PDW
variant
Window size 52h 05m 55s1h 58m 32s1h 59m 51s2h 03m 11s2h 00m 57s3h 10m 22s
Window size 152h 26m 22s2h 23m 56s2h 23m 56s2h 35m 46s2h 24m 14s4h 59m 53s
" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot_durations()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Below are the English word analogy task total accuracies of the resulting word vectors:" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
repositoryBranch develop, before #2698 has been mergedBranch develop, after #2698 has been mergedBranch positional-dependent-scalarsBranch positional-dependent-vectors
configurationCBOW+NSCBOW+NSCBOW+NSCBOW+NS+PDWCBOW+NSCBOW+NS+PDW
variant
Window size 565.63%65.40%66.27%64.95%65.18%70.69%
Window size 1531.88%60.98%61.67%62.22%61.05%71.14%
" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot_accuracies()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Columns one, two, three and five from the left are a successful sanity check: both accuracy and speed seem comparable between branch `develop` before and after #2698, and with our implementations of the position-dependent weight vectors and positional-dependent scalar weights when position-dependent weighting is switched off. The sixth column shows that our implementation of position-dependent weight vectors is correct, since it leads to a 5 point improvement in accuracy as reported in [the 2017 “Advances in Pre-Training Distributed Word Representations” paper by Mikolov et al.][mikolov17advances]. This gives a positive answer to **RQ1**: The results of Mikolov et al. (2017) are reproducible.\n", + "\n", + "Without positional weight vectors, using window size 15 consistently decreases the accuracy compared to window size 5. With positional weight vectors, accuracy is still improved by ca 3% when using window size 5. This gives a negative answer to **RQ2**: The improvement in accuracy is not only due to the larger context window.\n", + "\n", + "Using positional scalar weights does not seem to improve the accuracy. This gives a negative answer to **RQ3**: position-dependent scalar weights cannot substitute position-dependent weight vectors.\n", + "\n", + "Training without positional weight vectors for three epochs outperforms training with positional weight vectors for one epoch:\n", + "\n", + " [mikolov17advances]: https://arxiv.org/pdf/1712.09405.pdf (Advances in Pre-Training Distributed Word Representations)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Training duration: 4h 59m 53s\n", + "English word analogy task, total accuracy: 71.14%\n" + ] + } + ], + "source": [ + "train_fasttext_model('Branch positional-dependent-vectors', 'CBOW+NS+PDW', 'Window size 15')" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Training duration: 4h 41m 17s\n", + "English word analogy task, total accuracy: 70.94%\n" + ] + } + ], + "source": [ + "train_fasttext_model('Branch positional-dependent-vectors', 'CBOW+NS', 'Window size 5', epochs=3)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This gives a negative answer to **RQ4**: position-dependent weighting is not practically useful." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Positional Scalar Weights and Weight Vectors" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [], + "source": [ + "%matplotlib inline" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Below is a plot of the trained positional scalar weights:" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plot_positional_weights('Branch positional-dependent-scalars', 'CBOW+NS+PDW', 'Window size 5')" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA34AAAEWCAYAAAA5EUUKAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy86wFpkAAAACXBIWXMAAAsTAAALEwEAmpwYAABA8UlEQVR4nO3deXhc5X33//d3Fu0aSZZsbbbxhrFkYzZjYgKJE5qFQENCaLZmoSGl2Vqy9Nc0/fV5kjZpm7TN1jQJIQkhG2QlG5CELAhIwAFswJZtsI0X7JG8yJZGuzSauZ8/5owsy7IlWxodzejzui5dM3PmzDlfSbdH/sy9HHPOISIiIiIiIrkr4HcBIiIiIiIiklkKfiIiIiIiIjlOwU9ERERERCTHKfiJiIiIiIjkOAU/ERERERGRHKfgJyIiIiIikuMU/EREJGPM7J/M7Gunef4vzez+aajjDjP7RKbPM+J8zsyWTdf5JsLMus1syQT3nXH1i4jI5Cj4iYjIMDPba2Z9Xkg45AWmkrM9nnPu351z7/SOvcgLFKERz3/XOffyqahdTs85V+Kc2z3Z45jZjWb2h6moSUREpo+Cn4iIjPbnzrkS4GJgDfDPPtcza4wMxSIiIlNJwU9ERMbknIsCvwRWAZjZq81sq5l1mFmTmTWk9zWzD5tZ1My6zOxZM7vK2/4xM/uOt9tD3m2H16O4bnTvkZldbmaPm1nMu718xHNNZvZxM/ujd577zaxqxPM/NLOD3msfMrOVE/k+zWyZmT3ova7NzL4/4rmVZvYbMzvm9YD+k7d9rZk96v0sWs3sf80s7xTHv8bMnjSzTjPbb2YfG/Fcuhf0JjN7Hvj9GK9/0Mxe591/obf/Nd7jq8zsqRH7vsPMtptZu5n92szOGfHc8PBNM6s0s194NT1uZp8Yoxfvz8xsp/c9ftFSGoBbgXXe77DDO96rzGyb93uJmtnfT+RnLyIi00fBT0RExmRmC4BXAU+a2XLgLuD9wFzgPuAXZpZnZucB7wMudc6VAq8A9o5xyBd5t+XesMNHR51vDnAv8D9AJfAZ4F4zqxyx25uBvwLmAXnAyIDxS+Bc77lNwHcn+K1+HLgfqADmA1/w6ikFfgv8CqgDlgG/816TAD4AVAHrgKuA95zi+D3A24By4Brg3Wb2mlH7vBhoIPWzG+1BYP2I/XZz/Gf5Yu95zOw64J+A60n9jh4m9Tsbyxe9umqAt3tfo10LXAqsBl4PvMI5tx14F/Co9zss9/b9OvA33u9/FWMEWBER8ZeCn4iIjPZTryfnD6RCxb8DbwDudc79xjkXB/4bKAQuJxWC8oFGMws75/Y65547i/NeA+x0zn3bOTfknLsLeAb48xH7fMM5t8M51wf8ALgw/YRz7nbnXJdzbgD4GHCBmZVN4Lxx4BygzjnX75xL93xdCxx0zn3a297lnPuTd66NzrkNXp17ga+QCmEncc41Oee2OOeSzrnNpMLY6H0/5pzr8b6v0R4csf+LgP8Y8Xg4+JEKZP/hnNvunBsi9Xu7cGSvH4CZBYHXAR91zvU657YB3xzjvJ90znU4554HHmDEz3oMcVK//4hzrt05t+k0+4qIiA8U/EREZLTXOOfKnXPnOOfe44WROmBfegfnXBLYD9Q753aR6gn8GHDYzL5nZnVncd4TzuHZB9SPeHxwxP1eoARSYcbMPmlmz5lZJ8d7HKsY3z8ABjzmDWV9h7d9ATBmgDWz5WZ2jze0tJNUyBrzXGZ2mZk9YGZHzCxGKqCN3nf/aep7FFhuZtWkwte3gAXeMNe1HB9Cew7weW9oZgdwzPu+6kcdby4QGnXOsc4/5s/6FF5Hqnd4nzc0dd1p9hURER8o+ImIyES0kAoWAJiZkQpGUQDn3J3OuSu8fRzwqTGO4c7kHJ6F6XOM483AdcCfAWXAonSp473QOXfQOffXzrk64G+AL3lz4fYDp7r8wZdJ9Uae65yLkBpieapz3Qn8HFjgnCsjNUdu9L6n/Nk453qBjcAtQLNzbhB4BPgg8Jxzrs3bdT+p4ZblI74KnXOPjDrkEWCI1LDWtAWnOv9YJY1R4+POuetIDbP9KaneWBERmUEU/EREZCJ+AFzjLSYSBj4EDACPmNl5ZvZSM8sH+oE+IDnGMY54208Vpu4j1bP1ZjMLmdkbgEbgngnUV+rVcxQoItUDNyFm9hdmlg5B7aSCTdI7b62Zvd/M8s2s1MwuG3G+TqDbzFYA7x6ntmPOuX4zW0sqpJ6pB0nNo0wP62wa9RhSgfIj6UVtzKzMzP5i9IGccwngbuBjZlbk1f+2M6jlEDA/vZiNN8/zL82szBsG3MnYv38REfGRgp+IiIzLOfcs8BZSC5+0kZp39+de71M+8Elv+0FSvT4fGeMYvcC/AX/0hiO+YNTzR0nNq/sQqQD3D8C1I3q0TudbpIaFRoFtwIYz+PYuBf5kZt2keuZucc7tds51AS/zvteDwE7gJd5r/p5UgOsCvgp8/6SjHvce4F/NrAv4v5xdb9iDpALkQ6d4jHPuJ6R6Wr/nDT9tBq4+xfHeR6pn9CDwbVLzDgcmWMvvga3AQTNL/27eCuz1zvsu4C8neCwREZkm5tx4I29EREQkl5nZp4Aa59xYq3uKiEgOUI+fiIjILGNmK8xstXdtvrXATcBP/K5LREQyJ+R3ASIiIjLtSkkN76wjNWfv08DPfK1IREQySkM9RUREREREcpyGeoqIiIiIiOS4rBvqWVVV5RYtWuR3GTJFenp6KC4u9rsMyVJqPzIZaj8yWWpDMhlqPzIZGzdubHPOzT2T12Rd8Fu0aBFPPPGE32XIFGlqamL9+vV+lyFZSu1HJkPtRyZLbUgmQ+1HJsPM9p3pazTUU0REREREJMcp+ImIiIiIiOQ4BT8REREREZEcp+AnIiIiIiKS4xT8REREREREcpyCn4iIiIiISI5T8BMREREREclxWXcdPxERkZkqnkjS2Rcn1hens38odTv8OM551aVc1VDtd5kiIjILKfiJiIh4nHN0D6QD2xCd/fFR4W2IzlFhLr1vrC9OXzxx2uOXFoTY/NGXY2bT9B2JiIikKPiJiMiss721ky891c9Xd20YDm2d/alAl3Snf21pQYiywjCRgjBlhWEWVxWf8DhSmL49cb/7trTysV9s40B7HwvmFE3PNyoiIuJR8BMRkVnnrseeZ+OhBBfkJagqyWPJ3NHh7XhoGw5yBWFKCkIEA2fXW3fBgnIAtrV2KviJiMi0U/ATEZFZpzkaY2l5gLvf88JpO+d5NaWYpXobX7GyZtrOKyIiAhlc1dPMFpjZA2a2zcy2mtktY+xjZvY/ZrbLzDab2cWZqkdERARgKJFkW2sn50Smd2HrorwQi6uK2dbSOa3nFRERgcxezmEI+JBzrhF4AfBeM2sctc/VwLne183AlzNYj4iICLvbeuiPJ1k0zcEPoKE2wvaDCn4iIjL9MvZXzznX6pzb5N3vArYD9aN2uw74lkvZAJSbWW2mahIREWmOxgBYFAlO+7kbayPsP9ZHZ3982s8tIiKz27R83Glmi4CLgD+Neqoe2D/i8QFODociIiJTpjnaSUE4QE3x9F9SobEuAsAzrV3Tfm4REZndMr64i5mVAD8G3u+cO6vxLWZ2M6mhoFRXV9PU1DR1BYqvuru79fuUs6b2I2fjD9v6qC+Cvt6eaW8/Hf1JAH720EZ694Wn9dwy9fQeJJOh9iPTLaPBz8zCpELfd51zd4+xSxRYMOLxfG/bCZxztwG3AaxZs8atX79+6osVXzQ1NaHfp5wttR85U8mk472//zWvu2Q+JSVt095+nHN84vHfMlRczfr1q6f13DL19B4kk6H2I9Mtk6t6GvB1YLtz7jOn2O3nwNu81T1fAMScc62ZqklERGa3vUd76BlMsKquzJfzmxkNtRG2tWqBFxERmV6ZnOP3QuCtwEvN7Cnv61Vm9i4ze5e3z33AbmAX8FXgPRmsR0REZrkt3sIuK+sjvtXQWBfh2UNdDCWSvtUgIiKzT8aGejrn/gCcdua8c84B781UDSIiIiNtbekkLxhgeXUpR3b4U0NDbSmDQ0l2t/WwvLrUnyJERGTWmf6LGImIiPikORpjRW0p4aB/f/4aa1PDTLdruKeIiEwjBT8REZkVnHM0R2Os9Gl+X9qSucXkBQNsa1HwExGR6aPgJyIis0LqwulDnF/vb/ALBwMsrynRAi8iIjKtFPxERGRWaG5JLeyyyseFXdIaaiJsa+kkNdVdREQk8xT8RERkVtgSjREK2IxYUKWxLsLRnkGOdA34XYqIiMwSCn4iIjIrNEdjLK8upSAc9LsUGmpTvY4a7ikiItNFwU9ERHKec46tLZ0zYpgnKPiJiMj0U/ATEZGc1xrr51jPIKt8XtglrawwTH15Idtbu/wuRUREZgkFPxERyXlboqmFXfy+lMNIjXURtnkLzoiIiGSagp+IiOS8rdEYAYPG2pkx1BNSwz33tPXQN5jwuxQREZkFFPxERCTnNbd0smxeCYV5/i/sktZYGyHp4NlDGu4pIiKZp+AnIiI5b0s0xqoZNMwTjvc+btcCLyIiMg0U/EREJKcd7uznSNfAjFnYJW1+RSGl+SG2tSj4iYhI5in4iYhITmv2FlCZacEvEDAaaiPq8RMRkWmh4CciIjlty4FOzFKraM40DbWlbG/tJJl0fpciIiI5TsFPRERyWnNLjMVVxZTkh/wu5SSNdRF6BhPsb+/1uxQREclxCn4iIpLTts7AhV3SGrwFXjTPT0REMk3BT0REctbR7gFaYv2sqp95wzwBlleXEgyY5vmJiEjGKfiJiEjOavZ60mZqj19BOMiSqmK2KfiJiEiGKfiJiEjOao6mVvRcOcNW9BypsS7C9lZdxF1ERDJLwU9ERHLW1pYYC+cUUVYY9ruUU2qojRDt6KOjd9DvUkREJIcp+ImISM7aEo3N2Pl9aY3pBV403FNERDJIwU9ERHJSrDfO/mN9M+7C7aOlV/bUcE8REckkBT8REclJW1tS8/tm6sIuaXNL85lbmq9LOoiISEYp+ImISE7a4i3sMtN7/CDV66dLOoiISCYp+ImISE5qbumkvryQOcV5fpcyrsbaCDsPdzE4lPS7FBERyVEKfiIikpO2RmOsrJvZC7ukNdSWEk84njvS7XcpIiKSoxT8REQk53T1x9nd1pMVwzyB4YCqeX4iIpIpCn4iIpJz0gHq/CwJfosqi8kPBTTPT0REMkbBT0REck6zF/xWzvBr+KWFggFW1JTqWn4iIpIxCn4iIpJztkZjzCvNZ15pgd+lTFh6ZU/nnN+liIhIDlLwExGRnLMlGsua+X1pjXUR2nvjHOzs97sUERHJQQp+IiKSU3oHh3juSHf2Bb/a1LBUzfMTEZFMUPATEZGcsr21i6SDVVlyKYe0FbVa2VNERDJHwU9ERHJKczQGkHU9fiX5Ic6pLGJ7a5ffpYiISA5S8BMRkZzSHI1RWZxHbVn2LOyS1lAT0cqeIiKSERkLfmZ2u5kdNrPmUzxfZma/MLOnzWyrmf1VpmoREZHZo7mlk5X1ZZiZ36Wcsca6CHuP9tAzMOR3KSIikmMy2eN3B/DK0zz/XmCbc+4CYD3waTPLy2A9IiKS4/rjCXYe6sq6+X1pDbURnINnDmq4p4iITK2MBT/n3EPAsdPtApRa6iPZEm9ffcQpIiJn7dmDXQwlHedn2fy+tEYvsGq4p4iITLWQj+f+X+DnQAtQCrzBOZcca0czuxm4GaC6upqmpqbpqlEyrLu7W79POWtqPzLaA8/HAejev52mo8+edt+Z2H6ccxSF4Hcbn2FB/x6/y5FxzMQ2JNlD7Uemm5/B7xXAU8BLgaXAb8zsYefcSR9zOuduA24DWLNmjVu/fv00limZ1NTUhH6fcrbUfmS0X9+9mbLCg9xw9UvGneM3U9vP6p2P0hFPsn79C/0uRcYxU9uQZAe1H5lufq7q+VfA3S5lF7AHWOFjPSIikuWao52sqo9k5cIuaQ21EZ492EUi6fwuRUREcoifwe954CoAM6sGzgN2+1iPiIhkscGhJM8e7GJVXXbO70trrI3QF0+w92iP36WIiEgOydhQTzO7i9RqnVVmdgD4KBAGcM7dCnwcuMPMtgAGfNg515apekREJLftPNzFYCLJyixd2CWtoTa1wMv21k6Wzi3xuRoREckVGQt+zrk3jfN8C/DyTJ1fRERml+ZoDCBrL+WQdm51CaGAsa2lk2tX1/ldjoiI5Ag/h3qKiIhMmeZoJyX5IRZVFvtdyqTkh4Ism1fCdl3SQUREppCCn4iI5ITmlhiNdRECgexd2CWtsTaia/mJiMiUUvATEZGsN5RIsr21M+sXdklrqI1wqHOAo90DfpciIiI5QsFPRESy3nNHeuiPJzl/fnbP70trrEsv8NLlcyUiIpIrFPxERCTrHV/YJXd6/ADN8xMRkSmj4CciIllvSzRGYTjIkhy5/MGc4jxqIgWa5yciIlNGwU9ERLLeVm9hl2AOLOyS1lgXUY+fiIhMGQU/ERHJasmkY2tLZ9Zfv2+0htpSdh3upj+e8LsUERHJAQp+IiKS1fYc7aF3MMHK+tyY35fWWFvGUNKx63C336WIiEgOUPATEZGsll7Y5fwcC34NtaUAmucnIiJTQsFPRESyWnM0Rl4owLJ5ubGwS9o5lcUU5QXZ1qLgJyIik6fgJyIiWa052klDTSnhYG79SQsGjPNqSrXAi4iITInc+ispIiKzinOO5pZYzs3vS2usjbCttRPnnN+liIhIllPwExGRrPX8sV66+odybn5fWkNthK7+IaIdfX6XIiIiWU7BT0REslZzNDUMclVdbga/Ru8SFZrnJyIik6XgJyIiWWtLNEY4aCyvya2FXdJW1JRiBttbu/wuRUREspyCn4iIZK2tLTGWV5eSHwr6XUpGFOWFWFxZzLbWmN+liIhIllPwExGRrOScozkay9lhnmkNtRH1+ImIyKQp+ImISFaKdvTR3htnVX3E71IyqrEu4i1iE/e7FBERyWIKfiIikpWGF3bJ0RU90xpqSwF45qB6/URE5Owp+ImISFba2hIjGDAaanO8x682FWy1sqeIiEyGgp+IiGSl5miMZXNLKAjn5sIuadWRfCqKwmxvVfATEZGzp+AnIiJZxznHlmgnK3N8fh+AmdFYF2Gbgp+IiEyCgp+IiGSdw10DtHUPcH6Oz+9La6iJ8MzBLoYSSb9LERGRLKXgJyIiWac5mrquXa4v7JLWWBdhcCjJnrYev0sREZEspeAnIiJZZ0s0hhk05vjCLmmNdanvU8M9RUTkbCn4iYhI1mmOdrKkqpji/JDfpUyLpXNLyAsGFPxEROSsTSj4mdktE9kmIiIyHba2xGbNME+AcDDAudUluqSDiIictYn2+L19jG03TmEdIiIiE9LWPUBrrJ9VdbMn+AE01EbY3qqLuIuIyNk57RgZM3sT8GZgsZn9fMRTpcCxTBYmIiIyltm2sEtaY22EH208wOGufuaVFvhdjoiIZJnxJkc8ArQCVcCnR2zvAjZnqigREZFT2eoNd0wveDJbNHgL2Wxv7VLwExGRM3ba4Oec2wfsA9ZNTzkiIiKn1xyNcU5lEWWFYb9LmVbpFUy3tXTy4uVzfa5GRESyzUQXd7nezHaaWczMOs2sy8w0w1xERKbdlujsWtglrawoTH15Idu1sqeIiJyFiS7u8p/Aq51zZc65iHOu1Dk3u8bYiIiI7zp6BznQ3jfrFnZJa6iN6JIOIiJyViYa/A4557ZntBIREZFxpOf3raqfnZ89NtaWsvtIN/3xhN+liIhIlhlvVc/rvbtPmNn3gZ8CA+nnnXN3Z640ERGRE21Jr+g5S3v8GusiJB08e7CLCxaU+12OiIhkkfFW9fzzEfd7gZePeOyAUwY/M7sduBY47JxbdYp91gOfA8JAm3PuxeNWLCIis1ZzNEZ9eSEVxXl+l+KL4yt7dir4iYjIGRlvVc+/msSx7wD+F/jWWE+aWTnwJeCVzrnnzWzeJM4lIiKzwNaWzlk7zBNgQUURJfkhzfMTEZEzNl6PHwBm9j9jbI4BTzjnfjbWa5xzD5nZotMc9s3A3c655739D0+kFhERmZ06++Psaevh+ovq/S7FN4GAsaKmVCt7iojIGZtQ8AMKgBXAD73HrwP2ABeY2Uucc+8/i3MvB8Jm1gSUAp93zp2qd/Bm4GaA6upqmpqazuJ0MhN1d3fr9ylnTe1ndnnmWGpBE3dsH01N0UkfL1vbT5kb4I8Hhvj9Aw8QMPO7nFktW9uQzAxqPzLdJhr8VgMvdM4lAMzsy8DDwBXAlkmc+xLgKqAQeNTMNjjndoze0Tl3G3AbwJo1a9z69evP8pQy0zQ1NaHfp5wttZ/ZZdfDu4HtvOmVVzK3NH/Sx8vW9tNa9Dy/e34LS1ev5ZzKYr/LmdWytQ3JzKD2I9NtopdzqABKRjwuBuZ4QXBg7JeM6wDwa+dcj3OuDXgIuOAsjyUiIjmuORqjOpI/JaEvmzWOWOBFRERkos7kAu5Pmdk3zOwO4Engv8ysGPjtWZ77Z8AVZhYysyLgMkDXChQRkTE1t3Ryfv3svIzDSOfVlBIw2Nai4CciIhM3oaGezrmvm9l9wFpv0z8551q8+//fWK8xs7uA9UCVmR0APkrqsg045251zm03s18Bm4Ek8DXnXPNZfyciIpKzegeHeO5IN9ecX+t3Kb4rCAdZMreEba1dfpciIiJZZLwLuK9wzj1jZhd7m/Z7tzVmVuOc23Sq1zrn3jTeyZ1z/wX814SrFRGRWWl7ayfOwSr1+AGp4Z4b97X7XYaIiGSR8Xr8PkhqNc1Pj/GcA1465RWJiIiMsuVADEBDPT0NtRF+/nQLsd44ZUVhv8sREZEsMN4F3G/2bl8yPeWIiIicrLmlk6qSPKojs3thl7TGutQCL9taO1m3tNLnakREJBtMaHEXMysys382s9u8x+ea2bWZLU1ERCSlORpjZV0ZpuvWAdBQWwpoZU8REZm4ia7q+Q1gELjcexwFPpGRikREREbojyfYebibVfURv0uZMeaVFlBVks82BT8REZmgiQa/pc65/wTiAM65XkAfu4qISMY9c7CLRNJpft8oDbWl6vETEZEJm2jwGzSzQlILumBmSzn7C7eLiIhMWHM0tbDLyjoFv5Ea6yLsPNRNPJH0uxQREckCEw1+HwV+BSwws+8CvwP+IWNViYiIeJqjMcoKw8yvKPS7lBmlsTbCYCLJc0e6/S5FRESywIQu4A68HbgX+BGwG7jFOdeWsapEREQ8zS0xzq/Xwi6jNdZ6K3u2dLKiRvMfRUTk9Cba4/d1oAB4NfAF4CtmdkvGqhIREQEGh5I8e7CLlVrY5SSLq4rJCwU0z09ERCZkQj1+zrkHzOwh4FLgJcC7gJXA5zNYm4iIzHI7DnURTzhWaX7fSULBACtqSrWyp4iITMiEgp+Z/Q4oBh4FHgYudc4dzmRhIiIi6YVdtKLn2BpqIty/7SDOOQ2FFRGR05roUM/NpK7jtwpYDazyVvkUERHJmOaWGKX5IRbOKfK7lBmpsS5Ce2+cQ51aaFtERE5vQsHPOfcB59yLgOuBo6Qu6N6RwbpERERojnbSWBchEFBv1lga0gu8tMZ8rkRERGa6CQU/M3ufmX0feBK4DrgduDqThYmIyOw2lEiyvbVTwzxPY0VtKQDbW7t8rkRERGa6iV7OoQD4DLDROTeUwXpEREQA2HWkm4GhJKsU/E4pUhBmwZxCtrVogRcRETm9ia7q+d+ZLkRERGSk5mgqzKzSpRxOq7E2oks6iIjIuCa6uIuIiMi0ao7GKMoLsriqxO9SZrTG2jL2HO2hd1ADckRE5NQU/EREZEZqjsZorI0Q1MIup9VQW4pz8MxBzfMTEZFTU/ATEZEZJ5F0bGvt1Py+CWis81b21Dw/ERE5DQU/ERGZcfa0ddM7mGBlneb3jae+vJBIQUjz/ERE5LQU/EREZMZJL+xy/nz1+I3HzGiojbBNwU9ERE5DwU9ERGac5miM/FCAZXO1sMtENNRGePZgF4mk87sUERGZoRT8RERkxmluibGiNkIoqD9TE9FYF6F3MMG+oz1+lyIiIjOU/qKKiMiMkkw6tkY7OV/X75uwxtrUz2p7q1b2FBGRsSn4iYjIjPL8sV66BoZYVaf5fRO1bF4JoYCxrTXmdykiIjJDKfiJiMiM0tySCi+6lMPEFYSDLJ1boh4/ERE5JQU/ERGZUbZEY4SDxrnVWtjlTDTWRXQtPxEROSUFPxERmVG2Rjs5r6aU/FDQ71KySkNtKQc7+znWM+h3KSIiMgMp+ImIyIzhnKO5Jab5fWehsTb1M9OF3EVEZCwKfiIiMmMcaO+jozfOSs3vO2MNtaUAGu4pIiJjUvATEZEZY6u3sMv5Cn5nrLIkn+pIvnr8RERkTAp+IiIyYzRHOwkGjBU1pX6XkpUaaiNsU/ATEZExKPiJiMiMsSUa49x5JRSEtbDL2WisjbDrcDcDQwm/SxERkRlGwU9ERGYE5xzN0Ziu3zcJDbURhpKOnYe6/S5FRERmGAU/ERGZEQ51DnC0Z5BVdRG/S8lajd7PTvP8RERktIwFPzO73cwOm1nzOPtdamZDZnZDpmoREZGZrzmaWthFPX5nb1FlMYXhoOb5iYjISTLZ43cH8MrT7WBmQeBTwP0ZrENERLLAlmgMs+O9VnLmggHjvJpS9fiJiMhJMhb8nHMPAcfG2e1vgR8DhzNVh4iIZIetLTGWzi2hKC/kdylZrbEuwraWTpxzfpciIiIziG9/Xc2sHngt8BLg0nH2vRm4GaC6upqmpqaM1yfTo7u7W79POWtqP7ll4+5eVswJTNvvNFfbT6grTmf/EHf/6gEqCzWVP5NytQ3J9FD7kenm58eqnwM+7JxLmtlpd3TO3QbcBrBmzRq3fv36jBcn06OpqQn9PuVsqf3kjiNdA7T/6rdcdfFy1l+5ZFrOmavtp3RfO9/a9giRc1ayvrHa73JyWq62IZkeaj8y3fz8KHAN8D0z2wvcAHzJzF7jYz0iIuKT5hYt7DJVVtSUYqaVPUVE5ES+9fg55xan75vZHcA9zrmf+lWPiIj4Z6u3oqcWdpm84vwQiyqL2dai4CciIsdlLPiZ2V3AeqDKzA4AHwXCAM65WzN1XhERyT5bojEWVRYRKQj7XUpOaKgtpTmq4CciIsdlLPg55950BvvemKk6RERk5muOdnLRwnK/y8gZjbUR7ttykK7+OKUK0yIigr9z/ERERGjvGSTa0af5fVOooTY1ZPaZg10+VyIiIjOFgp+IiPjq11sPArCqTsFvqqTnSmqBFxERSdNVckVExBeDQ0k+9atn+Pof9rCqPsKaRRV+l5QzaiIFlBeFtcCLiIgMU/ATEZFpt+9oD39715NsPhDj7evO4SOvaqAgHPS7rJxhZjTWRtTjJyIiwxT8RERkWv3i6RY+cvcWAga3vuUSXrmqxu+SclJDbYTvbNjHUCJJKKiZHSIis52Cn4iITIu+wQT/es9W7npsPxctLOcLb7qI+RVFfpeVsxprIwwMJdl7tIdl80r9LkdERHym4CciIhm381AX771zEzsOdfOuFy/lQy9fTli9UBmVXtlza0ungp+IiCj4iYhI5jjn+OETB/i/P2+mOC/EN9+xlhcvn+t3WbPCsnklhIPG9tYurrvQ72pERMRv+rhVREQyontgiPd//yn+4cebuXhhBb+85UqFvmmUFwqwvLqUX289yJGuAb/LERERnyn4iYjIlGuOxrj2fx7mF0+38KGXLefbN13GvEiB32XNOh+5uoGDsX5uuPUR9h3t8bscERHxkYKfiIhMGecc3/jjHq7/0iP0x5N87+Z1/O1V5xIMmN+lzUpXnFvFnX99GZ19cV735Udpjsb8LklERHyi4CciIlOio3eQm7+9kX/5xTauPLeK+265krWL5/hd1qx30cIKfviuy8kLGm+8bQOPPNfmd0kiIuIDBT8REZm0jfuO8arPP0zTs4f552sa+Nrb1zCnOM/vssSzbF4JP37P5dSWFXDj7Y9z35ZWv0sSEZFppuAnIiJnLZl0fPGBXbz+KxsIBQP8+N2X884rl2CmoZ0zTW1ZIT981zrOn1/Ge+/cxHc27PO7JBERmUa6nIOIiJyVI10DfPAHT/HwzjauXV3Lv19/PpGCsN9lyWmUF+XxnZsu4313buKff9rMka4B3v9n5yqoi4jMAgp+IiJyxv6ws433f/8puvrj/Mf15/PGSxcoPGSJwrwgt771Ej5y9xY+/7udHO0Z4F9evUoL8IiI5DgFPxERmbChRJLP/nYHX2p6jmVzS/juOy/jvJpSv8uSMxQOBvivG1ZTVZLPrQ8+x9HuQT77hgspCAf9Lk1ERDJEwU9ERCakpaOPv7vrSZ7Y184b1izgo69upChPf0aylZnxj1evoKokj0/cu5323sf46tvWUKrhuiIiOUmLu4iIyLh+s+0QV3/+Yba3dvL5N17Ip25YrdCXI9555RI+94YLeWJvO2/4ygYOd/X7XZKIiGSAgp+IiJzSwFCCf/nFVv76W0+wYE4h9/zdlVx3Yb3fZckUe81F9Xzt7WvY09bDDV9+lH1He/wuSUREppiCn4iIjGlvWw+v+/IjfOOPe7nx8kX8+N2Xs7iq2O+yJEPWnzePO//6Mrr647zuy4/QHI35XZKIiEwhBT8RETnJz56Kcu0X/sD+Y33c9tZL+NirV5If0sIfue6ihRX88F2Xkx8K8sbbNvDIrja/SxIRkSmi4CciIsPaewb58I82c8v3nuK8mlLuu+VKXr6yxu+yZBotm1fCj999OXXlBdz4jce5b0ur3yWJiMgUUPATERFifXE+85sdXPmfD/CDjft5z/qlfO/mF1BfXuh3aeKDmrICfvg3l7N6fhnvvXMT396wz++SRERkkrQkm4jILNY9MMQdf9zDbQ/tprN/iFeurOEDL1uua/MJZUVhvn3TZfztXZv4Pz9tpq1rgPf/2bmY6ULvIiLZSMFPRGQW6htM8O0Ne7n1wd0c6xnkqhXz+MDLlrOqvszv0mQGKcwLcutbLuGffrKFz/9uJ23dA/zrdasIBhT+RESyjYKfiMgs0h9PcNdjz/Olpuc40jXAledW8cGXLeeihRV+lyYzVCgY4FOvW01lST5fbnqOo92DfO6NF1IQ1mI/IiLZRMFPRGQWGBxK8oMn9vPFB3bRGuvnssVz+OKbL2bt4jl+lyZZwMz48CtXUFWSz8fv2caN33iM2962hkhB2O/SRERkgrIu+O041MWvmlt5xcoazTMQERnHUCLJ3Zui/M/vd3KgvY+LF5bz339xAZcvrdR7qJyxm65YTFVJHh/6wdO88SsbuOMdlzKvtMDvskREZAKyLvgBvOs7m1hZF+GDL1vOS1fM039eRERGSSQdv3i6hc//bid72npYPb+Mj79mFeuXz9V7pkzKdRfWU1GUx7u+s5Ebvvwo33rHWhZVFftdloiIjCPrLuewvLqUz7z+Arr6h7jpm0/w2i89wsM7j+Cc87s0ERHfJZOOeze38srPPcT7v/8U+aEAt731En723hfykvP0QZlMjRctn8udf/0Cuvrj3HDrIzRHY36XJCIi48i64Adw/cXz+d2HXswnrz+fI10DvPXrj/GGr2zgT7uP+l2aiIgvnHPcv/Ug13zhD7z3zk044Itvvpj7/i51AXYFPplqFy4o50fvvpz8UJA33raBR3a1+V2SiEjOc86d9YdtWTnUEyAcDPDGtQt57cX1fP/x/fzv73fxhts2cMWyKj748uVcrBXqRGQWcM7RtOMIn/3NDjYfiLGosojPvuECXn1BvZbcl4xbOreEH7/7ct5++2Pc+I3H+ewbLuSa1bV+lyUiklOcc2xv7eKezS3cu6WVfUd7z+o4WRv80vJDQd62bhGvX7OA72zYx5ebnuP6Lz3CS1fM44O6JpWI5LBHdrXx6d/sYOO+durLC/nP163m+ovrCQWzcjCHZKmasgJ+8DfreOe3Hud9d23iWM9K3rpukd9liYhkvR2Hurjn6Rbu2dLK7iM9BAPG5Usrec/6pbzxU2d+vKwPfmkF4SDvvHIJb1q7kG8+upevPLiba7/wB16xspoPvGw5K2oifpcoIjIlHt97jE/f/ywbdh+jJlLAJ16zitevWUBeSIFP/FFWFObbN13G++58kv/zs61s2HOM169ZwBXLqtTzLCJyBp470s09T7dy75YWdhzqJmDwgiWV3HTFYl65sobKknwA3ngWx86Z4JdWnB/iPeuX8ZYXnMPtf9jD1x/ew/3bHuba1XW8/8/OZencEr9LPK3WWB8bdh/lWE+cUMAIBIxQwAiecBs4/jg4ejsEA4GxXxM8+VjBUccUkZnrqf0dfPr+Z3l4ZxtVJfn832sbefNlC3UhbZkRCsJBbn3Lxfz3/Tu480/7uHdzK/NK87nuwjpee9F8Guv0AayIyFj2tvVw75ZWfvF0C88c7MIMLl00h49ft5JXrKqZssvmZCz4mdntwLXAYefcqjGe/0vgw4ABXcC7nXNPT9X5IwVh3v9ny7nx8kXc9tBu7nhkL/dubuG1F83nlqvOZWFl0VSdalIOd/WzYfcxHn2ujUefO8resxyzOxUWVRaxdvEcLl00h7WL57BwTpEWhBCZAZqjMT77mx387pnDVBSF+cjVK3jbukUU5inwycwSCgb4x6tX8IGXncvvtx/m7iej3PHIXr768B5W1JRy/cX1XHdhPdURXftPRGa3/cd6uXdLK/dsbqE52gnAJedU8NE/b+RV59dm5H0ykz1+dwD/C3zrFM/vAV7snGs3s6uB24DLprqI8qI8/uGVK3jHFYv5yoPP8a1H9/Gzp6L8xZr5vO+l51JfXjjVpzytYz2D/Gn3UR7dfZRHnjvKrsPdAJTmh1i7eA5vecE5rFtayfzyIhLOMZRMkkg6hhIudZtM3yaHHydP2O5IJJNj7D9yv+So/R0DQ0m2t3Zy/7ZD/OCJAwDMK81n7eI5w2HwvOpSAuoVlBzmnKNnMEGsL06sN5667YvT2Reno2+Qzr4hBhNJnHM4Bw5wDpLe5WSccydsS98Hd3zbiNc5Ug9G7uvSx/Gej/XF+eOuo0QKQvz9y5dz4wsXU5Kfc4M1JMfkh4JcfX4tV59fy7GeQe7Z3MLdm6L8+33P8MlfPsMLl1Vx/cX1vGJlDUV5as8iMju0dPRx7+ZW7tnSytP7OwC4YEE5/3xNA1efX5vxXJKxd1vn3ENmtug0zz8y4uEGYH6magGoKsnn/7+mkXdeuYQvPbCLux7bz483RnnT2gW89yXLmJehTx9jfXEe23OMR587yiPPtfHMwS4AivKCrFk0hxsumc+6JZWsrIvMiAUZkknHriPdPLbnGI/vPcZje45xz+ZWACIFIS5dNIdLvSB4fn2Z5hTJjOOcoy+eGA5t6QDX4QW42Iivjt7jwS69bSh56muCBgzyQgEMwyw1XCHg3THA7MTtqQ7zk7el9wUwO3m7edvNUsOy/+6ly7jpyiWUFYYz/NMTmXpzivN427pFvG3dInYf6eYnT0b5yZNRPvD9pynKa+aVq2q4/qL5rFtaqSkHInLGOvvjRNv7ONDex4H2Xo50DVBRlMe8SD7VkQKqIwXMK82n2KcPTQ919qfC3uYWNj3fAcD59WX849UruOb8WhbMmb5RiJbJC597we+esYZ6jtrv74EVzrl3nuL5m4GbAaqrqy/53ve+N+najvYl+flzcf4QHSJgcNXCEK9akkckb3J/dPqGHDvbE2w/lmT70QT7OpM4IByAZeUBGiqDNMwJsrgsNQ9vpnPO0dbn2NGe4Nn2JDvaExzsSbWZvAAsLQ+wvCLI8oogy8oD5IfO7Hvq7u6mpGRmz7ucKknnGEpCPAnxhEvdJiGeTN0fGrV9yNseTxzfZ+T+8cSIfbztQ952M6gsNCoLAlQVGpWFRlVhgMoCoyg889vdaEnn6BxwHOt3HO1P3R7rT3KsJ84AIXrjjp64oycOvXHH0Gne1gwoCkNx2CgO2fH73ldRGG97etvx5wuCaPhzDplN7z8zTdI5drYn+WPLEI8fHKJvCCryjXV1IS6vCzG/NDs+VFQbkslQ+5mY3rijrS9JW5/zvk683zt04v5GavTMaIUhKMs3KvKN8nyjvCBAefpxgbct38gLTv7vfMdAkicOJnjs4BA721NZYEFpgLU1QdbWhKgunvx73Ete8pKNzrk1Z/Ia34Ofmb0E+BJwhXNu3Cuwr1mzxj3xxBNTVuO+oz18/nc7+emTUQrCQW68fBE3v2gJ5UV5E3p932CCjfvaeXR3ao7e0wdiJJKOcNC4aEEF65ZWsm5pJRcuKM+ZBRjaugd4Yu8x/uT1Cm5r6STpIBQwVtaXsXZRRapncNEcKopP/3Nsampi/fr1U1qfc47O/iGOdg9wtGeQo90DtHUPcrR7kPbeQeKJZCqEJRwJlxoCm3CQ8IbPJpKp/5QkkiO+hvc7cXsqzB1/Lpnk+NDaEfsODCWIJyb/by0YMPJDAe8rSF76fjhAXjC1LT8cYCjhaOno40BHH4NDyROOUVoQor68kPkVhdSXF1JfUUh9eRH1FaltlcV50xpunEsNZ4x29NHa0U9rrI+WWD+tHanblo4+DnX2n/TzKwwHKQklqZ5TSnlhHmWFYSKFYcpGfJUXnfg4UhimND+kIcsCZOb9R85cfzzBb7cf4iebojTtOEIi6VhZF+G1F9Xz6gvrpmxRg0xQG5LJyHT7SSYdR7oH2H+slwPtfUQ7+jBLTS8qKQhRkh+mJD9EaUGI4vzQ8P38UGBa/x/Q2R/nwLFUb92BET136dvO/hOTXWE4yII5hd7/ZYqYXzHytpA5xXl09g9xuLOfQ50DHO5K3R7q7D/xfucAg4nkSfVECkLHewrTvYal+d7jAqoj+cwtzSc/dOL/6492D/DL5oPcu7mVP+05StLB8uoSrl1dxzWra6d8gUkzy67gZ2argZ8AVzvndkzkmFMd/NJ2He7mc7/dwT2bWynND3HTlYt5xxWLiRScOLRqYCjBk8938OhzqXl6Tz3fwWAiSTBgrJ5fxuVLK1m3pIpLzqmYNQsvdPXH2fR8B4/tOcrje9p56kDHcNhYXl0yvFjM2sVzqC07cezyRN/0+uOJ4RB3tHuQthGh7mj3IG0j7h/tGThlyCotCJEXDAyvlhqwE1c3DVpqJdVgAIIjnjvlfpZaWTW9b8AbmnfiMVLBLD8U8IJacDi8DT8OB04IdKcKdmc6HDiZdLT1DBD13vDHuu0aOPENtSAcoK688JThsLo0/4zq6BkYSoW5dKjrSIW51lg/LbFU2OuLJ054TThoVEcKqCsrpK68gNryQurKCqgtK6S2vID68kLKCsM8+OCD+k+XnDX9p33maese4BdPt/CTJ6NsPhAjGDCuPLeK115Uz8sba2bc31W1IZmMybYf5xxt3YPsHxGS9o8IUNH2vjGDzXhCAfOC4YivguPBMLUt7G0Ljrg/4vmCEMV5IYIBI9YXHzPURU8R7IrygieFuZEBr6IoPCXBNP3BczoIpoLhifcPe8FxrP9XVhSFh8NgfCjJY3uPkUg6lswt5trVdVy7upbl1aWTrvNUsir4mdlC4PfA20bN9zutTAW/tGcOdvLZ3+zg11sPUVYY5m9evIRLF80ZXpDlib3tDAwlCRisrEsFvRcsreTSRXO04IKnP55gSzTGY3tScwQ37mun2wsX8ysKWevNE7zknAoee+xxljSsPim4pXro0uFucPj1oxWEA1SV5FNZkk9VcR6VJXlUluRTWZznbc+jsjifqpI8KorzCM+AeZQzTawvPiII9qZuO/qG35SP9gyesH8wYNREClI9hMOhsJC8UCAV5tKhrqOPlo6+k97QzVILB9WmQ11ZIbVlqTCXDnhVJfkT6pXTf7pkMtR+ZrZdh7u4e1OUnz4ZpSXWT0l+iKtX1fDai+t5weLKGdFzrzaUWckRI2iGkqNG4qRH4STSo3GSJJIwlEyS9G5H7ztyobsTjp1whIJGSf7xnq+RYSdTPWDjtR/nHO298RMC3f5RAao/fmKwqyzOOx6U5qRuF3iP68sLMYPugSG6+4foHhiiy7vtHoh72xLD97tG7Df85T3uHUycouoT5YUCJ408KsoLsqDi+EijTAW7qZJMOtp7B1MBsaufw15v4SGv9/BwZz8DQ0muapjHtavrWFFTOi31z6jgZ2Z3AeuBKuAQ8FEgDOCcu9XMvga8DtjnvWRoIsVnOvilbTkQ4zO/eZYHnj0yvG1FTSmXL61i3dJK1i6eo4UWJiiRdGxv7RxeMObxvcdo6x4cc99gwJhTnHdScKssyaPqhPupW60Gl3l9g4nhMJgKiL0n9Bge7Oxn5HooFUXhE0JdXfmJAa86UjBliwLpP10yGWo/2SGZdGzYc5SfbIryy+aDdA8MUVdWwGsuquf6i+tZNi9zn6iPR21o8tKLym3a187Gfe1sfL6d/cd6GUo6Mtg3cUZCATshEBbnBykpCHu9XamwWJoOjQUj9zt9iGxqauKitS/0wtzxQJcemnmgvZeeUQGrrDDMgjmFzC8vSt16gWnBnFSwm64FTIYSSXoGEyeEweP348OBsm8wQVVJ/gnhrnyGBbtsNaOCX6ZMV/BLe3p/B62xftYunsOccearycQ459jT1sNT+zvYteMZXrT2ouFQV1YYnhGf4srExRNJDsb6GUwkqSsrnNahWPpPl0yG2k/26RtMcP+2g/zkySgP7ThC0qVWx3vtRfVctLCc+vLCCY8YmApqQ2eue2CIp/d3pELevnaefL59eGRIRVGYS86pYNm8UvKCdnxaxojpGaHhaReB1JSKkbcjpmWc9Lrg6NefOH1jKJmkeyBBj9cL1jNwYk9Xz4hg0zN4YtjpGUiccmTSaMGADYfBY9199I16WWl+iPlzjg9xXDByDtucwpOmIMnsdTbBT90l47hgQTkXLPC7itxiZiyZW8KSuSU0de7iBUsq/S5JJiEcDEzrUsQiMnsV5gW57sLUReAPd/Xz86dS8wH/9Z5tw/vkBQPUlqfnCKeHoxcMz12uKy/MmcXWZjrnHM8f62XT815v3r4Onj2YWhDODJbPK+Wa1XVcck4FFy8sZ3FVcdb2BCWTjt54YjgQ9owaHtkzeHKgjLUd4gWrzh3uuVtQUUSkMJS1PwOZ+RT8REREJOvMKy3gnVcu4Z1XLmFPWw+7j3QPr2acXkTqj7vaONTVf9KQwcriPOorCk8ZDudM8+rGuSI9xz89bHPT8+3DUztK8kNctLCcl7/0XC45p4ILF5bnVO9VYERP3kQ1NTWx/kVLMliVyIkU/ERERCSrLa4qZnFV8ZjPpYejR70Fp1rSc5Y7+tl1pJsHdxw5aWXh/FBgeEXjkeGwzltVuLascMrmKmezg7H+4YC3cV87W1tiw6sfLqos4kXL53q9eRUsry4lqKkcIr5S8BMREZGclR6Ofqoh6c45Onrjw4tYjQ6Hzxw8zJGugRNeYwZVJfnku0Hqn32U8qIw5YV5qdsi77YwTNmI7RVFeRSEp/f6aFMpnkiyvbUz1Zv3fAeb9rUT7egDUkH5gvnl3HTFEi45p4KLFpZTVZLvc8UiMpqCn4iIiMxaZkZFceqSP6vqy8bcpz+e4KB3mZoDXjBs7ehnx/MtOAd72nro6O2gozd+2uum5YUClBeGh4NimRcQK4rzKBuxvbwoTJm3vbwwTFFecEKBMZF0xBNJ78sxlEgymEgylHDD20Y+H08kGUomGRxyDCVHbfdu27oHefL5dp4+0DF86YDasgIuPqeCm65YzMXnVNBYG1EPqEgWUPATEREROY2CcJBFVcUsGjWctKnpGOvXrxt+7JyjP56ko2+Q9p44HX2DxHrjdPTF6eg9/ri9d5CO3jj7j/Wyxds++npsI4WDRllhHpGCEAnniA8lGUx4YW0oSdwLfJlYqD0UMFbWRXjT2oXDwzbrygun/kQiknEKfiIiIiJTwMwozAtSmJeaB3gm+uMJYn3HQ2FHb5xYn3ffC45d/XGCASMcDBAOpm5DgQDhkJE34n44kHo+FAyQF0xtCwUCJ7zuhGMEvdd720beLwgHCQfVmyeSCxT8RERERHxWEA5SEA5SHSnwuxQRyVH6CEdERERERCTHKfiJiIiIiIjkOAU/ERERERGRHKfgJyIiIiIikuMU/ERERERERHKcgp+IiIiIiEiOU/ATERERERHJcQp+IiIiIiIiOc6cc37XcEbM7Aiwz+86ZMpUAW1+FyFZS+1HJkPtRyZLbUgmQ+1HJuM851zpmbwglKlKMsU5N9fvGmTqmNkTzrk1ftch2UntRyZD7UcmS21IJkPtRybDzJ4409doqKeIiIiIiEiOU/ATERERERHJcQp+4rfb/C5Aspraj0yG2o9MltqQTIbaj0zGGbefrFvcRURERERERM6MevxERERERERynIKfiIiIiIhIjlPwE1+Y2V4z22JmT53NcrQy+5jZ7WZ22MyaR2ybY2a/MbOd3m2FnzXKzHWK9vMxM4t670NPmdmr/KxRZi4zW2BmD5jZNjPbama3eNv1HiTjOk370XuQTIiZFZjZY2b2tNeG/sXbvtjM/mRmu8zs+2aWd9rjaI6f+MHM9gJrnHO6cKlMiJm9COgGvuWcW+Vt+0/gmHPuk2b2j0CFc+7DftYpM9Mp2s/HgG7n3H/7WZvMfGZWC9Q65zaZWSmwEXgNcCN6D5JxnKb9vB69B8kEmJkBxc65bjMLA38AbgE+CNztnPuemd0KPO2c+/KpjqMePxHJCs65h4BjozZfB3zTu/9NUn9IRU5yivYjMiHOuVbn3CbvfhewHahH70EyAadpPyIT4lK6vYdh78sBLwV+5G0f9z1IwU/84oD7zWyjmd3sdzGStaqdc63e/YNAtZ/FSFZ6n5lt9oaCapiejMvMFgEXAX9C70Fyhka1H9B7kEyQmQXN7CngMPAb4Dmgwzk35O1ygHE+UFDwE79c4Zy7GLgaeK83DEvkrLnUuHWNXZcz8WVgKXAh0Ap82tdqZMYzsxLgx8D7nXOdI5/Te5CMZ4z2o/cgmTDnXMI5dyEwH1gLrDjTYyj4iS+cc1Hv9jDwE1INWORMHfLmTqTnUBz2uR7JIs65Q94f0iTwVfQ+JKfhzav5MfBd59zd3ma9B8mEjNV+9B4kZ8M51wE8AKwDys0s5D01H4ie7rUKfjLtzKzYm9yMmRUDLweaT/8qkTH9HHi7d//twM98rEWyTPo/7J7XovchOQVvYYWvA9udc58Z8ZTeg2Rcp2o/eg+SiTKzuWZW7t0vBF5Gaq7oA8AN3m7jvgdpVU+Zdma2hFQvH0AIuNM5928+liRZwMzuAtYDVcAh4KPAT4EfAAuBfcDrnXNawENOcor2s57UECsH7AX+ZsR8LZFhZnYF8DCwBUh6m/+J1DwtvQfJaZ2m/bwJvQfJBJjZalKLtwRJddz9wDn3r97/qb8HzAGeBN7inBs45XEU/ERERERERHKbhnqKiIiIiIjkOAU/ERERERGRHKfgJyIiIiIikuMU/ERERERERHKcgp+IiIiIiEiOU/ATERGZIDN7l5m9zbt/o5nVjXjua2bW6F91IiIip6bLOYiIiJwFM2sC/t4594TftYiIiIxHPX4iIjIrmNkiM3vGzL5rZtvN7EdmVmRmV5nZk2a2xcxuN7N8b/9Pmtk2M9tsZv/tbfuYmf29md0ArAG+a2ZPmVmhmTWZ2Rpvvzd5x2s2s0+NqKHbzP7NzJ42sw1mVu3Hz0JERGYfBT8REZlNzgO+5JxrADqBDwJ3AG9wzp0PhIB3m1kl8FpgpXNuNfCJkQdxzv0IeAL4S+fchc65vvRz3vDPTwEvBS4ELjWz13hPFwMbnHMXAA8Bf52h71NEROQECn4iIjKb7HfO/dG7/x3gKmCPc26Ht+2bwIuAGNAPfN3Mrgd6z+AclwJNzrkjzrkh4LveMQEGgXu8+xuBRWf7jYiIiJwJBT8REZlNRk9s7xhzp1RgWwv8CLgW+NUUnT/ujk+uT5DqYRQREck4BT8REZlNFprZOu/+m0kN11xkZsu8bW8FHjSzEqDMOXcf8AHggjGO1QWUjrH9MeDFZlZlZkHgTcCDU/lNiIiInCl90igiIrPJs8B7zex2YBvwd8AG4IdmFgIeB24F5gA/M7MCwEjNBRztDuBWM+sD0mES51yrmf0j8ID32nudcz/L3LckIiIyPl3OQUREZgUzWwTc45xb5XctIiIi001DPUVERERERHKcevxERERERERynHr8REREREREcpyCn4iIiIiISI5T8BMREREREclxCn4iIiIiIiI5TsFPREREREQkx/0/sJl9jx0eGXQAAAAASUVORK5CYII=\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plot_positional_weights('Branch positional-dependent-scalars', 'CBOW+NS+PDW', 'Window size 15')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Below is a plot of the trained positional weight vectors:" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAz8AAANNCAYAAAC5v8CJAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy86wFpkAAAACXBIWXMAAAsTAAALEwEAmpwYAAEAAElEQVR4nOz9eXRjaX7f97+fey92ENxrY61T1V1d3dXd013LzGhGs89IGkl2NJLsWHJsR070c2T7OMnPx3acnMjOT7ETnchOpCRWtHiJpJFGGo0kSxrNjGbXrL1Os/Z9JavIIgku2O76/P4AgQJRIAmAAAiA39c5fbqbJIB7gYuL+8HzPN+v0lojhBBCCCGEEP3O2O4NEEIIIYQQQohOkPAjhBBCCCGE2BEk/AghhBBCCCF2BAk/QgghhBBCiB1Bwo8QQgghhBBiR5DwI4QQQgghhNgRJPwIIUQXU0r9U6XUr23w+59USn2+A9vx75VSP9fG+z+olMoopcw6/vawUkorpax2bY8QQoj+JOFHCCFaSCl1WymVX72Qn1kNDclm709r/S+01v/F6n0/cdGvtf4trfVHW7Ht20lrfVdrndRa+1u9L6XUP1NK/WYrtqvBx72tlPpwpx9XCCFE/ST8CCFE6/2w1joJvAycBv6Hbd4e0eVkFEsIITpDwo8QQrSJ1noK+DPgJIBS6i8ppS4opRaVUl9RSp0o/a1S6h8rpaaUUitKqStKqQ+t/rxyFONrq/9eXB1ZepdS6m8ppb5ecT/fo5R6VSm1tPrv76n43VeUUv8/pdQ3Vh/n80qpsYrf/55S6uHqbb+mlHqunv1USt1RSp1a/e+fXB2dem71//+2UuoPV//bUEr9E6XUDaXUvFLqd5VSI6u/WzOqpZQ6sroNK0qpLyil/q8aozk/qZS6q5SaU0r996u3+37gnwJ/dfU5eqvG9v5jpdSnqn72fyilfnH1vweVUr+ulHqw+pr8XOV0PKXUf6mUurS6bReVUi8rpX4DOAj88erj/qPVv93oNb+9ui2TQFYpZa13HAghhGgNCT9CCNEmSqkDwMeAN5VSTwO/DfzXwDjwGYoXymGl1HHg7wFntNYDwPcBt2vc5XtX/z20OkXsW1WPNwL8KfCLwCjwr4A/VUqNVvzZTwD/ObALCAP/sOJ3fwY8tfq7N4DfqnNXvwq8f/W/3wfcrNjW963+HuDvA//J6s/2AWng/1rnPj8BvLK6H/8M+M9q/M17gOPAh4D/USl1Qmv9WeBfAJ9cfY5erHG73wE+ppQaAFgNNn9l9TEB/j3gAceAl4CPAqWphz++uj1/A0gBfwmY11r/Z8BdVkf9tNY/v9FrXrEtfw34QWAIOEp9x4EQQogmSfgRQojW+0Ol1CLwdYoX/v8C+KvAn2qt/1xr7QL/GxADvgfwgQjwrFIqpLW+rbW+0cTj/iBwTWv9G1prT2v928Bl4Icr/ubfaa2vaq3zwO8Cby/9Qmv9b7XWK1prm+IF/otKqcE6HverFAMNwPcC/7Li/yvDz98B/nut9f2Kx/ix6ilfSqmDwBngf9RaO1rrrwP/scbj/nOtdV5r/RbwFlAr6DxBa32HYrj7kdUffRDIaa2/rZTaTTGw/tda66zWehb418B/uvq3/wXw81rrV3XR9dX7q2Wj17zkF7XW91Zfj1YdB0IIIdYh4UcIIVrvP9FaD2mtD2mtf2b1wnYfUL5I1loHwD1gQmt9neLowD8DZpVSv6OU2tfE4655jFV3gImK/39Y8d85IAnF0Q+l1P+yOiVtmccjDmNs7qvA9yql9gImxVD1bqXUYWAQ+O7q3x0C/mB1CtgicIniBf/uGvuxoLXOVfzsXo3HrbkvdfoExVEXKI6GlUZ9DgEh4EHFdv4/FEfDAA4A9QaSdV/zir+5V/H7Vh0HQggh1iHhRwghOmOa4oU1AEopRfFCegpAa/0JrfV7Vv9GA/9rjfvQjTzGqoOlx9jETwB/GfgwxcByuLSpm91w9aI9R3Fa29e01ssUg8lPA19fveiH4oX+D6wGw9I/0dW1UZUeACNKqXjFzw7UsQ/lTarjb34PeL9Saj/FEaBS+LkH2MBYxTamtNbPVfz+aJ2Pu+FrXus2dR4HQgghmiThRwghOuN3gR9USn1IKRUC/r8UL7K/qZQ6rpT6oFIqAhSAPBDUuI9Hqz9/2zqP8RngaaXUT6wunv+rwLPAn9SxfQOr2zMPxClO1WvEVymuVylNcftK1f8D/DLwPyulDgEopcaVUn+5+o5Wp5G9Bvyz1TVR72Lt1L3NzACHlVLrfsZprR+tbuO/A25prS+t/vwB8HngF5RSqdUiDUeVUqVpfL8G/EOl1ClVdKy0P6uPW/narPua19qmBo4DIYQQTZLwI4QQHaC1vgL8deCXgDmKF/M/rLV2KK7z+F9Wf/6Q4hSr/67GfeSA/xn4xuqUrHdW/X4e+CGKF9nzwD8CfkhrPVfHJv6/FKdoTQEXgW83uItfpRigvrbO/wP8HxTX7nxeKbWy+hjvWOf+fhJ4F8X9+DngkxSDQz1+b/Xf80qpNzb4u09QHOn6RNXP/wbFYhAXKRZl+BSwF0Br/XsUX4NPACvAHwIjq7f7l8D/sPra/MNNXvNa6joOhBBCNE9pXc/sACGEEGL7KKU+CVzWWv/sdm+LEEKI3iUjP0IIIbqOUurM6nQzY7V3z1+mOMoihBBCNE06SgshhOhGe4BPU+zzcx/4r7TWb27vJgkhhOh1Mu1NCCGEEEIIsSPItDchhBBCCCHEjrDZtDcZFhJCCCGEEEL0ig3708nIjxBCCCGEEGJHkPAjhBBCCCGE2BEk/AghhBBCCCF2BAk/QgghhBBCiB1Bwo8QQgghhBBiR5DwI4QQQgghhNgRJPwIIYQQQgghdgQJP0IIIYQQQogdQcKPEEIIIYQQYkeQ8COEEEIIIYTYEST8CCGEEEIIIXYECT9CCCGEEEKIHUHCjxBCCCGEEGJHkPAjhBBCCCGE2BEk/AghhBBCCCF2BAk/QgghhBBCiB1Bwo8QQgghhBBiR5DwI4QQQgghhNgRJPwIIYQQQgghdgQJP0IIIYQQQogdQcKPEEIIIYQQYkeQ8COEEEIIIYTYEST8CCGEEEIIIXYECT9CCCGEEEKIHUHCjxBCCCGEEGJHkPAjhBBCCCGE2BEk/AghhBBCCCF2BAk/QgghhBBCiB1Bwo8QQgghhBBiR5DwI4QQQgghhNgRJPwIIYQQQgghdgQJP0IIIYQQQogdQcKPEEIIIYQQYkeQ8COEEEIIIYTYEST8CCGEEEIIIXYECT9CCCGEEEKIHUHCjxBCCCGEEGJHkPAjhBBCCCGE2BEk/AghhBBCCCF2BAk/QgghhBBCiB1Bwo8QQgghhBBiR5DwI4QQQgghhNgRJPwIIYQQQgghdgQJP0IIIYQQQogdQcKPEEIIIYQQYkeQ8COEEEIIIYTYEST8CCGEEEIIIXYECT9CCCGEEEKIHUHCjxBCCCGEEGJHkPAjhBBCCCGE2BEk/AghhBBCCCF2BAk/QgghhBBCiB1Bwo8QQgghhBBiR5DwI4QQQgghhNgRJPwIIYQQQgghdgQJP0IIIYQQQogdQcKPEEIIIYQQYkeQ8COEEEIIIYTYEST8CCGEEEIIIXYECT9CCCGEEEKIHUHCjxBCCCGEEGJHkPAjhBBCCCGE2BGs7d4AIYToFVprPM8jn89jmiahUAjTNDEMA6XUdm+eEEIIITahtNYb/X7DXwohxE6htcZxHIIgwHEcKs+dSilCoRCWZUkYEkIIIbbXhh/AEn6EEGITvu/jui5aa5RSOI6zJtxorQmCoPz7fD5PLBYjHo9jWRZKKQlDQgghRGds+IEr096EEGIdpWlunuehlMIwDGp9YaSUwjTN8v/PzMwwMDBQDkOlkaHSNDkJQ0IIIcT2kPAjhBA1BEHA/Pw8S0tL7N+/v6GwUpr2ZllWOSw5joPjOOXfW5a1Zs2QEEIIIdpPwo8QQlTQWpenudm2TTab3dIoTem2pZEhCUNCCCHE9pHwI4QQq7TWuK6L7/sbTnPbjFJq3dvVG4aqCygIIYQQYusk/AghBKyp4lZak9PsiM9G4afW38LaMKS1xrZtbNsGJAwJIYQQrSLhRwixo1VOcyuN9pQ0EmIqbXWaXHUlueowVNljqFRNTgghhBCbk/AjhNixKnv31BrpaTb8lO67FWqFoSAIKBQK5Z+VwlBpZEjCkBBCCFGbhB8hxI5Ua5pbta2M/LQq/NS6bwlDQgghRHMk/AghdpRavXvWs16I2SxMdDJsSBgSQggh6ifhRwixYwRBgOu6605zq9YN094atV4Yyufza4orSBgSQgixE0n4EUL0vcqiBvBkQFhPN057a1RpX0sjXLXCkGVZ5X8kDAkhhOhnEn6EEH2teppboxf2vR5+qtUKQ6VguLi4iFKKsbGxcjU5CUNCCCH6iYQfIUTfanSaW7X1/r5UJGEj3Rp+qlWGoUKhgFIK3/fxPK/8N5ZllafJGYYhYUgIIUTPkvAjhOg7G/XuaUQ/THtrRPWoEDx+LkthSCm1ZpqchCEhhBC9RMKPEKKvaK1xXRff95sa7am0HU1Ot1v1/tYqoOB53pr1UxKGhBBC9AoJP0KIvlFP755GbBR+Npv61osjP/WoFYZc15UwJIQQoidI+BFC9LxGevc0olb4KV38bxRuenXaWzOUUpimWf7/WmGosqy2hCEhhBDbScKPEKKnaa1xHKfpogYb2YlrfoIg2PJ9VIchx3Gwbbv8+pTCkGVZLX/NhBBCiI1I+BFC9KzqtSetvoiWi/Kt2ygMARiGQSgUKpfWljAkhBCinST8CCF6zlZ799Sr2ZGQXh356YTKMFR6jhzHwXEcoBiGSqW1S9PkhBBCiFaR8COE6Clb7d3TCb0afjq93aXXTsKQEEKITpHwI4ToCZW9e4COXAT3aojpVRKGhBBCtJuEHyFE12tl755G7LSCB92mVhgqrRmqDEPV1eSEEEKI9cinhBCiqwVBgG3bHQ8+IOGn25TKmJumWQ46Wmts2+a1115jeXmZlZUVCoUCruvKayCEEOIJMvIjhOhK7erd04huXE/UTr0W2irDcD6fxzAMgiCgUCiU/8Y0zTUjQzvtNRVCCLGWhB8hRNdpZ++eTui1ENEvqo8VrbWEISGEEGtI+BFCdJVSUQOtdU8GH5Dw0y0kDAkhhKgm4UcI0RW6YZpbvTYLN716Ad3voW29MJTP59cUV5AwJIQQ/UvCjxBi2/VC755G9XOI6BelY60UtCUMCSFE/5PwI4TYNtW9e/ol+PTqCEo/PPdbUU8Ysiyr/I+EISGE6D0SfoQQ22K7evd0Qq+GH5ARq0q1wpDv+3ieV/6bUsNVy7IwDKOvjmMhhOhHEn6EEB0XBAGO4/R0UQOx89RaM1QZhpRSa0aGJAwJIUT3kfAjhOiY0sXirVu3ME2TiYmJ7d6ktujlkR9Rv1phyPO8NdM4JQwJIUR3kfAjhOiIyt49QPnf/ahXw0+vbne3kDAkhBDdT8KPEKLtak1zk4ts0e9qhSHXdZ8IQ6FQCNM0JQwJIUQHSPgRQrTNer17DMNYs2i830i4E7UopTBNs/z/pTD01ltvcfz48TXFEyzLkvVwQgjRBhJ+hBBtsVHvHqWUTHvrQr263b2qFIZc1y2XzXYcB9u2geKXBKFQqDwyJGFICCG2TsKPEKKl6und08sX2YVCgQsXLqCUYnh4mOHhYWKxmFyUiqaV3gu1RoZKYag0clo9TU4IIURjJPwIIVqmeprbeoGgV8PP3NwcV65c4amnnsKyLNLpNNevXyefzzMwMFAOQ726f2L71HqvVIah0vHkOA6O4wBIGBJCiCZI+BFCtMRG09yqGYbRU+EgCAKuX7/O0tISp0+fxjRNfN8nmUxy4MABtNasrKyQTqe5fPkytm3jeR4zMzMMDw8TDoe3exdEF6vnvVB6P0kYEkKIrZHwI4TYksppbpVFDTbSS2t+giDg1VdfZWxsjNOnT6OUeqJYg1KKVCpFKpXi0KFDFAoFzp8/Ty6XY2pqCt/3GRwcZHh4mKGhIUKh0DbtzcZkxKp31ApDpWlylWGoVEBBwpAQQhRJ+BFCNK1Urcr3/YYWY/fKRfbs7Cy5XI6XX36ZsbGxum9X+gb+yJEjHDlyBN/3WVpaIp1Oc/fuXbTWDA0NlcNQ5ToPsfOUSsBvRa2y2lprbNt+ooBCZTU5IYTYaST8CCGaUqt3T726PfwEQcDVq1fJZrMkEglGRkae+JuNLlir9880TUZGRsr343kei4uLLCwscPPmTUzTLK8XSqVS8g292LJ6wpBpmuUpchKGhBA7hYQfIURD1uvd04huXvOTy+U4d+4cu3bt4vjx43znO99peFs3C3eWZTE2NlYeTXIch8XFRWZmZrh69SrhcLgchpLJZMfCULeH0n7W7uBRKwwFQUChUCj/rBSGStPkJAwJIfqRhB8hRN1KawrqKWqwkW5d8/Pw4UNu3LjBc889x9DQENCZQBAOh9m1axe7du0CwLZt0uk09+/fJ5PJEI1Gy2EokUjIRanYMglDQoidSsKPEKIunudt2LunEd02wuD7PleuXMG2bc6ePbumIEEz27rV/YtEIuzZs4c9e/agtSafz5NOp7l9+3Z5Kp70GBKtJGFICLFTSPgRQmyo3t49jeimaW/ZbJbJyUn27dvHiRMnWtKQtZXhTilFPB4nHo8zMTGB1ppsNrtuj6FoNLqlx+qW10Vsr/XCUD6fX1NpTsKQEKLXSPgRQqyrkd49jeiWi+wHDx5w69YtnnvuOQYHB2v+Tbdsa4lSimQyuW6PIcdxSKVS5TAkPYZEK5Te/6X1Z6UwtLCwwMzMDEeOHClXkZMwJIToZhJ+hBBPqOzdA7R8wf12r/nxfZ9Lly7heR5nz57FstY/FdYKP5td1HUyMFX3GAqCgOXlZdLpdE/1GBK9pRSGlFI4joNhGGv6fQHlhquWZWEYhoQhIURXkPAjhFij2d49jdjO0ZRMJsO5c+fYv38/+/fvb0uQ2c6LPMMwGBoaYmhoSHoMibarLHVfPTLk+365IbBSas00OQlDQojtIuFHCFG2ld49jdiuNT9TU1PcuXOH559/noGBgbpu023T3hpVT4+hUhgq9YIRol7r9buqtWaoOgxVTpOTMCSE6BQJP0KIlvTuaUSnA4XneVy8eBFg02lu/W69HkOzs7MsLCwQBAGRSKTjPYZEb9qo2W+lWmGouoKkhCEhRCfs3CsAIQTQut49jejkmp+VlRXOnTvHoUOHmJiYaPj2vT7ys5nKHkNLS0tMT08TiUSYmppiZWVFegyJDdUbfqrVCkOu6z4RhkKhEKZpShgSQrSMhB8hdrDSAuV2T3Or1olAobXm/v373L9/nxdeeIFkMtnU/fR7+KlmGMaaHkOFQkF6DIl1tbKke+X6s1phqLKstoQhIUSzJPwIsQN1eppbtXav+fE8j/Pnz2NZFmfPnt3Sov6dFn4qKaWIxWLEYjH27dvX1h5Done1qyhKdRhyHAfbtoHiOaQUhizL6uiXN0KI3ibhR4gdpl29exrRzmlvS0tLXLhwgcOHD7Nv374t399ODj/VpMeQqNbstLdGbRSGSuexUChUniYnYUgIsR4JP0LsENW9e7bz4qAdgUJrzd27d5menubFF18kkUi05H53UvhpdF+lx5DoVPipVhmGSses4zg4jgMUR4aq1wwJIQRI+BFiR+hE755GtPrxXdfl/PnzRCIR3vGOd7T0QmcnhZ+tkh5DO892hZ9KpceXMCSEqIeEHyH6XKd692yXxcVFLly4wNGjR9mzZ0/L71/CT/Ma6TE0ODgoF6Q9qBvCT7VaYag0Ta4yDFUXUBBC7AwSfoToU5XT3LajqEG7aa25ffs2s7OzvPTSS8Tj8Y49drdd7LVKu4PeRj2Grl27RigUYmRkRHoM9ZBuDD/VapXV1lpj2za5XI7p6WkOHTokYUiIHULCjxB9aDt693SS4zicO3eORCLBmTNn2nqhIiM/7VPZYwjAtu3yeiHpMdQbevG9UXlO9H2fdDrNwYMHsW27XE3ONM3yFLlSNTkhRH+Q8CNEn+n3aW4LCwtcunSJp556qnzR3E4SfjonEolIj6Ee0wsjPxvRWmMYxpovULTWBEFAoVAo718pDJVGhnp5n4XY6ST8CNEntrt3T7tprbl58yZzc3OcOnWqYz1ldlL46aZ9bbTHkNg+vRwEaoW3WtPkSmGoRMKQEL1Lwo8QfSAIAmZmZsqLxvvtg9i2bSYnJxkcHGz7NLdq3RQIdrLNegxls1kuX74sPYY6rB9GfjbbfglDQvQXCT9C9LDKogZXr17l9OnTffehOz8/z+XLlzl+/Hh5oXwnSfjpTtU9hr7zne+wZ88e6THUYb0efkrrIhuxXhjK5/NrKs1JGBKiO0n4EaJHVU9zM02zry7SgyDgxo0bLC4udnSaWzUJP71BKSU9hrZBr4ef0pqfrSiFodL91ApDlmWV/5EwJMT2kvAjRA8KggDXdddUc1NKEQTBdm9aSxQKBSYnJxkZGdn20aydFH56eV+rjxHpMdQZrQgP26kd4a1WGKpsOwCUG65altWXU5WF6GYSfoToIRv17jEMo2cvXCs9evSIq1ev8swzzzA6OrrdmyP6RD09hoaHhxkZGZEeQw3oh5Gfdm//emHI87zy7yunyUkYEqK9JPwI0SO01riui+/7NUtYG4bRcyM/lRceQRBw7do1VlZWOHPmTNcsWF9vNKSei5NevzDsZ9JjqDV6/QuXIAg6HnRrrRmqDkOV0+QkDAnRWhJ+hOgB9fTu6bVpb6VQoZQin88zOTnJ+Pg4p06d6qoP+l6eCtaonbSv1dbrMXTnzh0ymYz0GNpALz8X3fAFRa0w5HkeruuWfy9hSIjWkfAjRBdrpHdPr017K23vzMwM169f59lnn+3Kfi3NBoLKcCd6S60eQ7lcbt0eQ9tVjKMb9Pox3o3bXysMua77RBgKhUKYpilhSIgGSfgRoktprXEcZ01Rg4302sgPwOXLl7Ftu6umuVXbavgRvU8pRSKRIJFIsH///id6DDmOQyqVaqrHUK8fI90YHhrRTKnrTiutCSqpDkOFQoFwOEwymZQwJEQdJPwI0YWqpzzU80HWS2t+crkcKysrjI2N8eyzz3b1B/V6IabXL/pqkcBWn+oeQ0EQsLy83HSPoV4+jnr9fdCL1eqqw9Dc3ByhUGhN5c9S8QTLsur+DBFip5DwI0QXqZ7m1sgHVq+EnwcPHnDr1i2SyST79+/v+g/lZgseSJDYOQzDaLrHUK8fI/0Qfnp5+6G4D6WgU/p/x3GwbXtNGCpNk5MwJHY6CT9CdIlavXsa0e0X277vc/nyZVzX5cyZM5w7d66rt7ek1nTCel6bbn89RPs00mNoYGCgpy9Eez089MK0t81UV6yrHBkqnYMcx8FxHKAY1qvXDAmxk0j4EWKbVfbuAZr+IOrmkZ9MJsO5c+eYmJjgwIEDPdeUVUKM2IrNegwVCgVu377dkz2Gej389OK0t2obvQaln0sYEuIxCT9CbKPNevc0olurvU1NTXHnzh1OnjxJKpUq/7xXRkaafU16Zf8q9eI296LKHkO+7/PGG28QjUZ7ssdQrx8vvR7eoLFeRfWGodKaIQlDoh9J+BFim9TTu6cR3Tby43kely5dQmvN2bNny/PRS7o1rFWTam+inbTWmKbZ0z2Gum17GrHTwk+1WmFIa41t29i2DUgYEv1Hwo8QHdZI755GdNM0spWVFc6dO8fBgweZmJhYtylrL4SDrYSfXtOL29xveq3HUK+Hh36f9taoWj2GqsOQaZrlKXKlanJC9BIJP0J0UKO9exrRDSMpWmvu37/P/fv3eeGFF0gmk+v+bTeFtY1sJaRt9+vRjF7c5l622YVrO3sMtUKvh58gCNZU3+tFWxn52UytMBQEAYVCofyzUhgqjQz18vEgdgYJP0J0SKmoQaumuVXb7mlvnudx4cIFTNPk7Nmzm15Q9PLIj+d5zM3NbdjDpVf2T/SWVvcY2qpeDz/9MPLTzvBTTcKQ6AcSfoRos3ZNc6u2nSMpy8vLnD9/nsOHD7Nv3766btMNI1X1qA4xpX1NpVIb9nCR8CPqsdXwsJUeQ63QD+Gnl7cftncfJAyJXiThR4g22mrvnkZsR5jQWnP37l2mp6d58cUXSSQSdd+216a9VU/pK3VUr9XDZXh4uPy69xIJbL1vox5Dt27dKoel4eFhBgcHt/xlTK+Hh37s87Od1gtD+Xx+TXEFCUNiO0n4EaINqnv3dKKjdqfDhOu6nD9/nkgkUtc0t2q9dKHt+z7nzp3DMAzOnj2LYRjlsrC1erik02kePnzI+fPnicVijIyM9ETZYrE92nlMbNZjKBQKMTw83HSPoV4PPzLtrb1Kn32l7asVhizLKv8jYUh0goQfIVqslb17GtHJNT+Li4tcuHCBo0ePsmfPnqbuo1fCT6FQ4MGDBxw/fpyJiQlg46IA4XCY3bt3Mz8/z8GDBzFNk4WFBW7fvk02myWZTK4pWyx2tk6/Byp7DAHYtl1eL9RMj6FeeA9vpNfDG/RWgKsVhnzf59GjR+RyOSYmJtY0XJUwJNpBwo8QLdTq3j2N6MS0N601t2/fZmZmhpdeeol4PN70ffXCmp/p6Wlu3brF2NhYOfg0KhaLMTExwcTEBFprMpkM6XSaq1evYts2qVSKkZERhoaGOl6pq1qvBNJ+s50Xd5FIZMs9hnr54rQfwk8vT90rfU6WQpBhGPi+j+d55b8phSHLsjAMo2f3VXQPCT9CtEDlNLd2FjXYSLunvTmOw7lz50gkEuWpX1vRzWt+fN/n0qVL+L7PiRMnmJuba/g+agUJpRQDAwMMDAxw8ODBcqWuhYUF7t+/TxAEbV2cLrpPN4XNjXoM3bhxg3w+v2bkMhqN9nx46OYpY/Xq9dcAiufc0ihP9ZqhyjCklFozTU7CkGiGhB8htqidvXsa0c5pb+l0mosXL/LUU0+Vp8tsVbeOMmSzWSYnJ5mYmODAgQMsLi423eR0s9tVVuoC1i2eMDIywsDAQM9fpIkndfOFa60eQ6WRy1KPIc/zmJ+fZ9euXds+ctmMbn7+G9Hr+7BeCK0VhjzPW7OeVsKQaJSEHyG2YDunuVVrxzQyrTU3b95kbm6Ol19+uaVrVLox/Dx8+JCbN29y8uRJUqkU0Px2NnMsrFc84cGDB1y5coVIJNLW4gnd+JqI7lFr5PKNN96gUChw/vz5jvcYaoV+CT+9rt4ROAlDohUk/AjRhE717mlEq0d+bNvm3LlzpFIpzpw50/J97KY1P0EQcPnyZWzb5syZM2su2rYSCLa6f6XiCbt37wYgn8+TTqeleEKf6dWLM8MwsCyLgwcPEg6HO95jqBV6eb1MPwmCAMtq/JK0VhhyXXdNGKosqy1hSICEHyEa1snePY1o5Rqa+fl5Ll++zNNPP834+HhL7rNat6z5yeVyTE5OsmfPHk6cOPHE69ns69uOUZTq9RjZbJaFhYU1xRNKYagXpyDtRN3yBUCzKkdOOt1jqBV6qVJaP2vV2iul1JqQXZqWXmpNUBmGLMvqqs9w0TkSfoSo03b07mlEK0ZStNZcv36dxcVFTp06RTQabdHWPakbpliVep0899xz5XU31ZoNae3eP6UUyWSSZDK5pnhCqWxxEAQMDg6WK8l147fuoqibziON2mjaWLt7DLWCTHvrDu0qPLFeGLJtGyh+boZCoXJp7W77XBftIeFHiDpUT3PrxpPjVqe9FQoFJicnGRkZ4fTp033XlLVSEARcvXqVbDbLmTNn+mKUpLJ4wpEjR/A8j6WlpSeKJwwPD5NKpdZdXLzdgXSn6fXnu5Htb3WPoVaQ8NMdOlV1rzIMlY7dypGh0lTOUhiSUcH+JOFHiE106zS3alsJE48ePeLq1as888wzjI6OtnjLajMMY00vh04pFAq89dZbjI+Pc/z48U1fz60UPNjOC1vLshgdHS2/nqXiCQ8fPuTq1atEIpHyt+6dutAU/anZY6cVPYa2SsJPd9iOkuOV0zVBwtBOIuFHiHV0Q++eRjQz7S0IAq5du8bKygqnT58mEom0aeuetB0jP6WQ9+yzzzI8PFzXbXo1/FTbrHhCIpFgaGioK9Zh7SS9fvHdqu1vpsdQK/R6n59uOsdsRanB6XaSMLRzSPgRooZSxRjf97t6tKdSo2Ein88zOTnJ+Pg4p06d6vg+djIclNYyLS0tNRzy1tvOXjgmNlKreML8/Dz5fJ5XXnlFiieIurQrvG3UY+jKlSstK/DR6+Gz18NbSTfuR60wVF1AobRmqLKanOh+En6EqBIEAdPT0ziOw759+3rmg7GRNT+lBceNjIC0WqdKXdu2zeTkJMPDw02FvH4Z+dlIqXhCPB7n0aNHvPzyy2uKJ/i+z9DQECMjIwwODjZVklbU1usX353a/lo9hlZWVlhYWCgfo830GOr1578bQ0MzgiDo+qIstcpqa62xbbtcQMG2bRKJBJFIpFxNTnQf+QQTYlVlUQPP8ygUCj114qrnYjsIAq5cuUI+n9/2hf6dCAelkt1bWcu0E8JPteriCb7vP1GyeLPiCUK0k2EYDA4OMjg4WD5Gm+kx1Ot9fno9vJX0YoirFYZu377Nvn37GBgYAIqjRpUjQ/3wWvUDCT9C8Lj8ZemD0DTNnlv7sNlJtbKfzTPPPLPtJ+F2rvnRWnPz5k3m5+fbXrK7n6wX2EzTlOIJbdLrF6/dsu2b9RhSSpUDe3WPoW7Zh2b0YmiopR/2o3T+LK0H0loTBAGFQqH8NxKGuoOEH7HjeZ73RO+erZaN7jYPHz7kxo0bG/az6bR2jYw4jsPk5CSpVIrTp09v+QN1vel5m1209vLIz2bWK55QWaVrZGSkXKVLiE7bqMfQ9evXsSyL4eFhfN/v6QDaD6EB+mc/fN8vjzLWGhmSMNQdJPyIHWuj3j39En583+fy5cs4jsPZs2frngffCe1Y85NOp7l48SJPP/004+PjLbvfnTbtrVG1iiek02muXr3asoXp/UwueNpvvR5Druvy2muvbUuPoVbo5eBWqV/Cz0b7sV4Yyufza4orSBhqPwk/YkfarHdPP4SfbDbL5OQkExMTHDhwoOtOoq0MB6W51rOzs7z88sstHW3YSWt+WlWyOJlMkkwmOXDgQM2F6ZVrMXZ68YReO0b6RanH0L179zh9+vS29BhqhX4JDdAfXwJUjvxspnKmCUgY6qSd/akjdpzK3j3Auh8avR5+pqenuX37NidPniSVSm335tTUqjU/ruty7tw54vE4Z86cafmFwEYhpl++dW2nWgvTFxcXyz2GSsUVRkZGdmzxBDmGttdmPYZyuRwDAwMt7zHUCv0SfvrlS4CtvB71hCHLssr/SBhqnoQfsWM00rvHMAx83+/g1rWG1ppz584RBAFnz57t6m/VWzHtbWlpifPnz3Ps2LHy+pNWCoLiMVC9naXjZ6Pt78WRn06oVTxhcXHxieIJw8PDJJPJvv9wl2Ok+3Sqx1AryBcw3adVr0etMOT7Pp7nlf+m1HDVsiwMw5BjoU7de2UkRAsFQYDjOOUPis1OEJ3qQdNKKysrZLNZDh06xMTERNefBLcSDrTW3L17lwcPHvDSSy8Rj8dbvHVFd/PT/Nb9f4KKHiCctnhpqP4+QRJ+6lO9FqNUPOHu3btrph+NjIz0ZfEEuXjtfu3qMdQK/TLyI++BzdVaM1QZhkqVaiUMbU7Cj+hr1UUN6v2Q6KVS11prpqamuHv3LrFYjP3792/3JtWl2Wlvnudx/vx5wuEwZ86caWtjvJCKEzJsjOQ1vjT/L/nMbJxh6yTvHf0Bjsefadvj7mSbFU8YGBgoV5KT4gliO7Sqx1Ar9Ev46Red/MKrnjBUOU1OwtBjEn5E36ru3dPIm75Xpr15nseFCxcwDIOzZ8/y6quv9sw3yc2MjCwvL3P+/HmOHDnC3r17N/37+/lbTEQPN/98KIXtm8Ss4odJ1MyR16/wublX+CMvyUjoJO8b+RhPJZ6qcVMZ+dmqRoon9PJz3Qvv137ViuNmKz2GtqpXzvei/WqFoepWHhKGiiT8iL5UKmpQ7zS3ar1Q8KAUBA4fPsy+ffuAx6Mp7fymsVUaCQdaa+7fv8/9+/d54YUXSCaTdd3uV+/+c0AzHJrgRPJl3jn8IQZDw3Vvo9YaOwgRw3vid1ErQ05/mz+b/zZ/MJNiPPQiHxj9GIfjh4H2NnHdqTYqnpDL5Xj99dfLU+R6pXhCL4c26P3tb4d6ewyNjIyQTCa3dJz2w8hP6QvKXtdt74VaYch13SfCUKkp604KQxJ+RF9pdppbtW4OP1pr7t27x9TU1BNBoJfWKtW7rZ7ncfHixfLoViPBTmuFUi5p9w7fTN/hGwt/QMgYYH/0KV4efA8vpM5ueLLXaGx/89Nk1FpmRf8F/3HuLyh4w+wNv53ng7OMGWN1b6toXGXxhHQ6zQsvvEA6ne654gndul39rlOjJuv1GJqammJlZWVLPYb6Jfz0+j5A8Xjq5v0orQkqqRWGSuuFLMtq6ovjXiHhR/SNzXr3NKJb3/Cu65bXu9QKAt0c2qrVMzKSyWSYnJwsF3Fo4lGqHhM8vcLt/Bvczr/B7z8wSIV281Ti7bx7+COMRdZWjAu0xg4aO01GrTTp4Mt8VX+ZfGGYg1Nn+PDYx9gVaX01OvGY1ppQKNRzxRN65cuK9XTrubIe2zVlrNRjaM+ePWitt9RjqNsvuOvRL+GnkR4/3aBWGHIcB9u2yWQyaK0ZGxsrjwz1UxiS8CN6XnXvnn56g1YqlXV+29vetu56l16aarXZtLepqSnu3LnD888/z8DAQLOPssk2BKx4D3hj6QGvL/4ZpoqxJ/I2Xky9i9ND70FDXSM/te8b4uE0c/7n+cTDz+P6uzgULQahkfBIU/cpGrNe8YRr165RKBSkeMIO1w3rZbbaY6gfgkM/7AP0/n5UhqFcLofv+6RSKWzbLs+kqZ4m16sk/Iie1kjvnl6ltebOnTs8fPhw07LOvTbyUyv8+L7PpUuX8H2/Bb2K6j8elIKAPNP2BaYfXeAzs79OxBgmYnm4gUHIaP55NRRErFkeen/K//vgM7j+bo7G3smHxr6fwdBg0/crHtvsvd9I8YShoaGO9cjqhgvwZvX6qFU3PveN9hgKgqCr+7nVo9dDQ0mvjfxsxPf9ciNVePxedxwHx3GA4vXGb/zGb/AzP/MzXfc+2kxvv2PEjtZo755e5DgO58+fJxaLcfbs2U0/IHptzU91UMtms0xOTrJ//37279+/5ddUoxqIP2sppXH0AsMRKOgwWU8BmpDyiSmXZj+rDaWJWA+57/4h/3b6j/CDCZ6Ov4sPjnyUZKi+Qg5i6zYqnnD79u22VujqFnnPJmZFmr59N4aHRvTCQvuNegxNT0+Ty+VIJpOYptnxHkOt0i/hp1/2A4rhJxJ5fG4ovU+qw9Cv/dqv8TM/8zOd38AtkvAjek7lNLetFDXodul0mosXL3Ls2DF2765vvUgvT3t7+PAhN2/e5OTJk6RSqVY9SovuB0xV3NYAk0xg4vsKU2kiyiFsBDRzDWUqjWne57b9e/zK1O+DPsAziXfzwdGPEDWjm9+BaJnK4glQXF+XTqeZnZ3l2rVrhMPh8hS5VhZP2K4A4Qc+/+Tir/OvTv4dzCbPoette69cBPbiepnK0A5w48YNDMNgeXm54z2GWqVXjpfN9NvIz0b7Uvn53e1fINQi4Uf0lK307ukVWmtu3brFo0ePePnllxtamN1r096g+MF3+fJlbNvmzJkzPfHNpVJgrYYhhzB5X4GGkOETVQ5mE5/jlhEAd7heuMOle5/E0Id4Lvm9vH/0g4QNWY/SadXFEwqFAgsLC08UT6hnUXo3+r/v/b9M5dN8buYKH9t7oqn7WG+U+auPXuOF4QSj4ee2solt1+sjVyWpVKoc2jvZY6hV+in89MN+QP1BrldmmlST8CN6xnZMc+v0h6Nt25w7d46BgQHOnDnT8Im0l6a9QfE1feWVV9izZw8nTpyo+Vxv5TXQLRz52YipNCgIMMgGUXxfYaAJGy5Rw294VChk+MBNLudvcu7ub2HpI7yYeh/vGX4/ltEf3yz2mmg0yr59+54onnD9+vVy8YRSJblGiidsxwX460vnuZx9C80uPjN9qenwA7W/9f3szAWi4Tu8q8vDTy9Me9tM9ehVJ3sMtUq/hJ9e6bFXj3rCj+M4PVsoRsKP6Hqt6t3TqNKwbqc+HOfn57l8+TJPP/004+PjTd1HL017m52dJZfLcfbsWYaGhtb9u7eWLvFb936J3ZETfGDsg7w8/FwDr0nnL2wqR4U8Qiz7IQKtsJRPzHCxjMbCacjwgGtMZq/x2vJ/IKKO8VLqA3zP0PdgSBDaFusVT0in05w/f37biifUI+8V+PdTv1EO5BeWHzZ9X+udH6+sPOCR81bT99spvTjtrdpmAa6dPYZapZ/CTz/sB9QXfrLZLIlEokNb1Frdc0YWooZW9u5pVGkKWbtPZlprbty4wcLCAqdOnXqilGkjemHkJwgCrl69Wj5xbhR8ACyliIZWWApe4Q9nX+F3pmMMW0/z7tH38t6xTZqUarYj/6xhqGKRAzDIBRECX6GUJqQ8osprqHBC2HTRXOKNzCW+tfRrxI3jnBn8EGcGN34eRHtVrsM4fPhwQ8UTOj3y86/u/Apa2cXHRpHxbObtLKORxi9iam37t+ZuYQcuns6x6N5gKHS0JdvdDv0w7a3Rz6jKHkPwuBdWMz2GWqVfQkM/rfmpZxSrdLz0Igk/oit1Q+8e0zTbPopSKBQ4d+4cQ0NDnD59essfAN2+5qdQKPDWW28xPj7O8ePH+da3vrXpbSy19jmJWnnyvMUX5t/iT2fCJIy3cXb43Xxo1/cSNtee0jo17a1eSj0unOBjsRJYBL7CUgFRw22onHbEdPA5x7eXz/HVdJSk8QzvGvooL6be3vMXdL2ukeIJnfyy4s/nvs60ffPxNMzVh/79+5P89NF3NXx/tcLD795/E7V6jF/JfpJ3DP3TrWxyW+3E8FNtKz2GWqVfQkM/rfnxPK+ukZ9ksjcrlEr4EV2neprbdn04GYaB7/ttu/+5uTmuXLnCM888U75I2qpunvb26NEjrl69yrPPPsvw8HDdt7M2+DCJWA4el/nm0mW+uvAfCHGAF1Pv5Af2fJBEKMa2D/ts4vGokFpTTtvCJ27UX047YhZw+S5fW/oun5+PkzLP8q7h9/BiqrvXXOwUtYonpNNp7t69y+LiIqFQqLwWo13fts87i/zh7B/UXH/21Uc3WhZ+vrs4RWL1ymLWfr2ZTe2YfhhxaGWAa7THUKvWe/TD6wDF/ejVNTDV6nlNZNqbEC2yndPcqrVrFCUIAq5fv87S0hKnT59eU0t/q7px2ltpf5eXl5va35Cq70MxZHrALd7K3uL1a59EBftIu4rhqCLU4Dqb7VIaFXKCEK5vEXiKsOGRMJy6g1DUynEje4354Nv8/kycsdAzvH/kQ7yQeraNWy4aEY1G2bt3L3v37uXBgwdks9ny+2QrxRM28gu3/m+UWvtlTulUcSsz39R9Vl9438jMkfMdBkLF86arM6x49xmw9je30W0mIz8b26zHkOd5DA4Olte2NVupsx8atUL/jGBBfevhZORHiC3qxt497Qg/+XyeyclJxsbGOH36dMs/eLtt2ltpWt/w8DCnTp1qan/NJhb1W0YAxn3GLPADxUI+SoBiIFQgYnXP87OR0qhQgMmSHyPwDEKrQcjcJMz5q8dAxMqxot/gj+ff4FMzccZCJ/jAyId4PtV8dS/RepFIhAMHDjxRPOHChQvlC8yRkZGmiyd88sEfsxzM1vhN8f3o6oDzSw85ObinofutDg+/dfc1oDSaWXQl8zucHvqHDW9zJ0j4aUx1jyHf91laWiqPYjbbY6ifRn76YT/qJWt+hNgCrTWu6+L7/raP9lRqdZAozfc/ceIEIyMjLbvfSt007a1UvW6r0/rMLR4PpqEZihYACDSkC1G8wCQRsomHvC3dd7toraDiArIYhAI0Bit+FN8zsJRPwrRrVo/z9ZPTNYtB6HX+4/zr/N5MgvHQM3xw9CM8N3C8rfsiGlOreMLS0hILCwubFk+o5XZ+iq+lv1RzulvlmrhP33urqfBT6Vvzt4r7UHHsPrRfaeg+O6lfSl1v1z6YpsnIyEj586zZHkP9Ehr6ac1PPWTkR4gmbUfvnnq1KvxUVjc7c+ZMW+cEd8PIj9aamzdvMj8/v+XqdQCa1k1ZMxQMRuzy/y/ZUWzfJGa5JENOw/142mWjPS6W0g4ARWY1CBkqIG7YRMziax8Q4Adq3RGiiJVlWb/OH869zicfJtgVOsEHRj8sQWgbbHbxWn2BWat4QmXflsr78gOfX7zzy+UCBE88dsV/v7Jwr6ntLz1e2smx4OSK26wen4McvUTWmyFh7W7q/ttJRn5aq9keQ920D1vRT31+6pHL5ST8CNGI7erd04hWBIlcLsfk5CS7d+/m+PHjbf+g3e6RH8dxmJycJJVKtaR6XVH71usMhG0GVv8744bJeyGipsdA2N7WIFRvlbrHQQgKOkLGKTZXNdAU/BAJw9n0PiJWliX9Gn849xqffJgkGp4guTLIiYGnt7QPoj02Kp6QyWSIx+PlSnL/7tGncPTKuvel9ePjbNZewQ8CzAbes5Xh4bdXp7wBmFXv2avZ3+GlwX9Q9/12Sr/0+enWfai3x1ChUOj5EAr9s+an3nXDmUyG3bu770uNekj4ER2ntcZxnK4oarCRrYafhw8fcuPGDZ577rlNe9m0imEY5fLgnZZOp7l48WLDTVo3+/a1U6UKEiGXRKj43OW8EDk3jGX6DIYLGB0+RJutWVGaAjcWz+EFBgXfxFQBltJ1hbmIlUGnrvDpuX+J/TDJ7tCzfGj0IzwzcKy5DRJ12co5sLJ4QqlU8cLCAp+79hUuht6oO8Rr4HMzV/jY3vrXg1W+d780e638c6NqpGna/hYv0Z3hp1s/f+rVS/uwXo+h5eVllpeX15TV7lSPoVbq5iDaiHpDnEx7E6JOnudta++eRjQbfnzfL5cFPXv2bNMVcJqxHdPetNbcvn2b2dlZXn75ZWKxWN23VUpt/uG9DdXrYpZHzCquB3J8i4wTxlCawUhh02IDrdCK/kRWRc8gTxv4QXF6nKWCusJcxMqwqF/h9+dewX6YZE/4OT408mGOSxBqqVZWZyyVKjZjFl/KfHXTo6j6kT8zfamp8OMGPvfzi+WfG2rtOcgO0hT8NFGz/hL3ndAPa35ga+F5O5V6DC0uLrJ//35M0yz3GMrn8ySTybb3GGqlfhn5kfAjRIt0S++eRjQTJLLZLJOTk+zbt48TJ050fD87XeradV3OnTtHPB7nzJkzDX/rVc/2tnLNTzPCps9ILA+AGxik88VS3YORfE+V0DZXyxwH2sAJFAoIGX7dQSgdfIdPzX0H++EAe8LP8uHRj/J08m3t3fAdotXniX9961fR2Jv+ne+tPX4vLj9s6HFK4eePpifXvEvNGmuMrmY/yQupv9PQ/bdbP0x76weltTLb0WOolXbayI+s+RFiA93Uu6cRjYaf6elpbt++zXPPPVcuBdppnVzzs7S0xPnz5zl27FjT835LIz+9ImQEjESLQahdJbS1bs3Iz3oMpQmvXpwGWuEERoNBaIV08B1+79F3sB8MsCf8HB8Z/QhPSRBqSqunLX15/lvct6/XNd1NVV2orXg2kzeucHh8LwMDA5tuV2nb/2T6wpqfV4/8AEwVvt6V4adXPo/6Wa1CAZ3qMdRK/VLtrZGRHyl1LUQVrTWFQoGVlRUGBgZ67qRQb/jxfZ9Lly7heR5nz57d1mZtnRj50Vpz9+5dHjx4wEsvvUQ8Hm/6vuoJa9s98rOedpbQ7tQeGwrCqxeqWivswEAD4YaC0Lf53Uffxn6QYl/4OT48+lGOJQ+3dbtFbWlniU/N/H5D63yqfSFzl++3fVZWVtYUT6i1BqN0rrmWebTm57VGfvLBI5xghbAx8MTvWumNpavMFVb46O5Tm/6thJ/uUM+ISbt6DLVar13n1CLT3oRoUql3z9LSElNTU5w8eXK7N6lhhmHgeRtfxGYyGc6dO8f+/fvZv3//tn+QtnvNj+d5nD9/nnA4zJkzZ7b8AdPpaXrtUquEdsEziIc8BsKbV1zrBkpBqEYQChlBzYvZahFrmfngW3zy0bdWg9BJPjL2EY4mDrd3w3tcKy/A/7fb/walGgneTz7u6/kZ/tsXP1IunpBOp7l+/TqFQmHNgvRIJILWmjfzM3h67Tmn1sgPwNXs73Fy4Kca2aWG/dr93yMIwnWFn51WmrhbNTNdrFU9hlqpHz7LoP7wk8lkGBho75cZ7SLhR7RcZe8e0zS3ve9Ms0zTXLdymtaaqakp7t69y/PPP981J4B2TntbXl7m/PnzHDlyhL1797bkPuuZ9tatIz8bGQjbhJSJMhVz+TiOb5EMFUhF6gtClSWIt0NlEAJwfJOAYlntWk1VqxWD0Df5ndlvYnspJsLP85Hxj/K2+ME2bvXO9qmHn2HJb3TNzpM/u5WZBx4XTyitwQiCgEwmw8LCAhcvXsTzPCKRCJ9duv7EfawXlu/nv9rW8POns18n4y+jteK7izd5+9DGUzFlzU93aMVameoeQ9X9sEKhUDkM9eJMlE6SNT9CNKBW7x7Lsno2/BiGge/7T/zc8zwuXryIUmrbp7lVa8dIitaa+/fvc//+fV544YWWnuzqCmu9+m3aan5JhF0SFEP0XCGO45kkQ866vYQ0nZv2Vq/KynGObxCg6i6hHbGWmQu+wW/PfAPbG2Qi/DwfHf8IRyQIAa0Z+bmXf8CXF77QcG+qWseZqwMuLD3kucE9a35uGAapVIpUKsXhw4fxfZ979+5x/dHiE/dRXeq6JBc8xAvyWEb9FSHr5QcBvz/zOaAY3v/D1J/y9qG/v+FtZNpbd2jH61DdD6vUY2h6epqVlRUikUi54WoikWjJ4/fLsdRI+NnKtPft1D1XbaKnrde7Z70A0QtqTSErjX4cOnSIiYmJbdqy9bV62lsp6BmGwdmzZ1s+RaS+kZ/+UdlLaMGOY3sWiZBNqioItbPgwVYVR36Kr0qjJbQj1hJzwdf5xMzXsb1B9kee5/vGPsqh+IH2b3if0lrzr+/8G9Q6U802vm3tn//+/cknwk810zSZMWwcnnxcc4NtuZb7NCeSP9nQdtbj1+//EQGPR1YfeVNMFxbYFx1Z9za9Xuq6X6ZZQfuDw3o9hu7cuUMmkyGRSPR0j6FWqjf8lGb39CIJP2LLfN/Hdd3ytzeVJ41envZWGSS01ty7d4+pqamWj360UiunvWUyGSYnJ9sa9OobqerVD/iNPzzjIZd4dRCyHJLhQic2riUqS2j72mDFtQgbAVHTq2NEaIlH/tf5zZmvY3tDHIg8z0fHPrLjgtBWv/X+lXufwNHLzT32Osfoq/N367r9px9dqPlzY4P37N3sF3gm8RNN7fMXH73OB8defuK2y26Oby6+svqWW/3iTcGv3vljfvb431z3/np92luvb/92KvUY2rdv35r1bTdu3CCXy61Z31ZPj6FeD9KVgiDYdEZLr4+aSvgRTas1za1aP4z8uK7LhQsXCIVCbRn9aKVWTXubmprizp07bV/P1K9rfqAY2er9aKgMQktOnIwbxg8pBsOFhqcybRdTaXxtEqBYdi0UEDNtQmY9a4QWmfX/gv/j9ncJmWEmwsf54Nj7OTnwVPs3vIedW7nKZObVpo+R9V6ZGXsFPwgwN7mwfnNluubPNxr5yQbTfPuVbzA4MFKuJBeJRDbfVq353QdfpqBX+MFd71/zu1+689tQLtZB+fm4lr9KzisQt2pfvPb6BVw/XXBvp+r1bc30GOqXHj9QnPFRz3S2Xn7/SPgRTam3d0+7q4+1k2EYFAoFXn311ZYu8m+nrY78lMp2+77fkfVMnexL1GnNZtBYyCVWDkJR8l6IuOU8MTWuGwWrhRpKRRHsIEzWNwgZPjHDYbNrA6V8QuYys/6r/M7Mq7jTMcasY7xn5D28c+jtPftBu5FmLyCcwOFX7//bLR0T6x2jGvjczBU+tvfEuredszMs+bUbqa635gcABaPPPWRP8MKa4gmlni3Dw8M1zzufnz1PxsvzmUdfXhN+bucecDV3tfw8VH7pYBg+//be5/h7R/5y7f3s4Ys36K8L7m6yUY+hqakpfN9/osdQvVPFekE9x1WvT7mU8CMaorUuT3MDNm1a2qsfLFprHj58SDqd5p3vfGfPNPLaStjMZrNMTk52tGx3P4/8tEIs5BFb7Rm07EbJuSFipksqXNg0SGwHjQE8Hul9XDVOkfWj+B7ETJeIWXs0WFOsLBde/X3IzLOkz/Gn8+f4w9kwKfMQZwbfyftH30nY2P6mhtvpX9/+NQK2NkVyo7Vlf/bg0obh5xN3X1v3dxuN/ADcLfw5T4/92JriCaWeLXfu3EEpxdDQECMjI+iIwUh8kN+8922UqbB1ji/OfYsPjb0LgP/zzm9vGABfWXoDrf9SzfNZr4+cyLS3zqjsMXTkyJGaPYaSySSe5/VFCKpnH2zbrms6YLeS8CPqVurd4/v+pqGnlzmOw/nz57Esq1wJplc0G34ePHjArVu3OHnyJKlUqg1bVls94adXq70VLyxbt+1RyyNqFYPQihcl74aImC6DXRSENgqqhtIYCjxtUXBCGEoTNx3MitLZgVYUfKscfiqFTIc81/ja0jW+lP4EUSZ4YeA03z/+PuJW66uHdUozow9fXfgOdwtXtzwSuNFb68LSxmWzvzz7ZInrkg1HfoBl7w5B4GMYxQus6p4truuyuLjI7Ows/1fm0/ywfg/38vPsTxbPbX84+3k+NPYuvpO+wCN3Zs3zEARgVF63GTa//+Dr/Ni+731iO3o9PPR6eIPeHEGo1WPo4cOHLC4u8uabb2IYRrnhaqd6DLVSPeEnm8321LVRNQk/oi6VvXv6Ofik02kuXrzIsWPHSKVSXLp0abs3qSGNrvkJgoDLly9j2zZnzpwhFOrst+n1hLXe+2gsaudnevcGofrOC6VpcXk/jOcZhA2PqOGiURT8EClqT6d6fHsfj7u8kb3Lqyt/gMluRsx9vM15itHw0FZ3oqstuSv87sPfa8kUyI0O0RXPJu3kGA4/Ofe/4Lk8KCyte9v1mpxWPvKt/Gc4mvjhmr8NhUKMj4/zqj9DwS7wJ+rbUKCYbIB8kOGPr3+BP8l/84nnodbT8meP/mLd8NPLn2X9MO2tH/bBsixSqRRDQ0M888wza3oMXb9+HcuyeqrHUD3hp1Qhr1dJ+BEbqpzmtl5Rg36gtebWrVs8evSIl156iXg8jm3bPbcepZE1NLlcjsnJSfbu3cuJEye25SKgrpGfHo0/rR75WU9lEMp4EXJumIjhMRjJdzwINbq3pWlxGoOMH0Upjes32Ond0MBDFlIP+YU7b6CDUd4WPclHd32AQ7F9DW5R5zV6Af6/3f43KOW16LE3/v2n7r3Ff3n0XU/8/A+m39rwtV6vyWml2/k/Wzf8lPzm3e+QjEJg3QP2YJmPj40/zn8FhyebUNd637lqmW8vXOKdI2un8Un42X79sA+wNjBsR4+hVqp35Kdbq97WQ8KPWNd6vXv6jeM4nDt3jmQyyZkzZ8on4l4s1lDva1Tqev3cc88xNDTU3o3agKz5aa2I5ROx8sDjIBQ2PQbDecxOXF9s4aUylSZuecTMDAXfAjRhw9+0d1AlQwHmPHfcr/Ir97+KF6TYH36GD429j2f7oHLcHzz8HGmvdoW1Zmz2cn3l0Y2a4eczDzYeEd985AeWvVsbho8FJ8u9/DxPRXwGTY+RSB6lHo9M+9hoXf/n0m9Nf+6J8NPr08Z6PbxB/4Sfjfaj13oM1RN+crmcjPyI/tPKaW6lC9ztfkPXsrCwwKVLl3j66acZHx9f87te7lG0niAIuHr1KtlsljNnztQs2dlJ9Y389Catt/d4rwxCOT9CNh8mZHoMtTEIteKVVArCqxfPgTbIeRYGATFr895B1fcTMpeZ8V/hEzOv4EzHGO/SynH1bMtUfoYvLHyupRX/Nnvr3cos1LiN5kb20Ya3M+s4EjQBdwpf4HDsIzV//29ufg0UOEFx/dfexDI5d7j8e6Wg5gDTOs/Pov+QGyvTHB14PBrYD2t+enn7oT/2AepvDAob9xjK5/Mkk8mGegy1Wj2viUx7E32lnt49jSr1+ml32eRGaK25efMm8/PznDp1quYJpt/KMBcKBd566y3Gx8c5fvx4V1z81bfmpzfDUTdtddj0CcfWBqHw6tS41gah1h5ThoL46pQ+O7DIuGHQmqFIobxuqF7hGpXjzg6+iw+MvgvL2L7qTPWEf601//rOv0HVMaLSiM3uzdU+F5Ye8tzgnvLPvvzoGv4m27xZwYOSW7k/WTf8fGXuSnEbVx8rbrnkXGfN35hK42ow1pzLak83VQp+8fLv8res95WnHPX6yE8/BId+2Acohp9m9qMVPYbaYbP3RSaTkWlvoj/U27unUd02gmLbNpOTkwwNDXH69Ol1T1i9/KFY7dGjR1y9epVnn32W4eHhzW/QIXVNe+vTkaHtsjYIhcnmI4QMj6FIYU3ltWa085UKGwEjkQJaQ9aLkLajaA1DkUKx9HcDb9dS5bivLl3ji+nfIqr282LyFN+3TZXjNjvX/Nr9T1LQiy1/3HreWr9/f3JN+Pn0/e9uepvNSl2XLLrXas4K+Nqj6xSC1aBT8at4KIsdPL74qzX6s1Humg/Nsv/YYbyVAvfv3y9fYI6NjTE8PEw8Hu+p8363zqhoRL+EnyAIWlLiupkeQ9tB1vyIntdo755GlUZ+usHc3BxXrlzh+PHjjI2NbffmtF0QBFy/fp3l5WVOnz5dVyf1Wh4VVhiPDrR46/q74EEvCJtBOQjl/RCZfATL8BmO5LcchNpFKUiGHJIhB18r0naMc/P7MJRmOJJjKJInGXI2v6NVxcpxd3g9e4dXVivHnUi8ne8f/2BHKsdtdvxfzFznuyvfbkuD23pe4a/OXofnPlr+/3NLDza9Tb0jPxqfqcJfsD/23jU//7d3vlHz7+OWS6EQQlUkXeuJ0Z/1nyjDCPiNmS/w3x79cfbu3cubb77J4cOHyWQy3Lx5k1wux8DAQHlkqNnzZaf0Q3Doh32A4n60Y3ZLPT2GSmW1h4aGOtZjSMKP6GnV09za8S2SaZrbHn5KIWBpaWlLIaCXFAoFzp07x/DwMKdOndrSa/tffefT3FiZ49nB3fzowRf4ywdOYrbgA6u+gge9aaMGkt0oZAYMrwahG4tjWIbPWCxDKlJ/kOj0PptKMxbNMRbNUfBNHuWTvDW3D0PBUCTPcCTHcCS3blPVJ+5vtXLcpfxnuXDns+hglKOxk3zf+Ac5ENvb3p2pwQlcfvner7cl+EB9Iz/Lno0fBJiGwaWlhxSCzSvN1TvyA3Aj90drwk/Ws7mRnVk3w0RMF0dvPPqzkTdXJvGDHy2fvxKJBENDQ+UpRysrK+WWB57ndcW37Ovph+DQD/sAxWlvnbiuqNVjaHFxkYWFBW7durXlHkP1zrTIZrNMTEw0vP3dQsLPDtauaW7VtrtqWqFQYHJyktHRUU6fPt3z0wTqMT8/z+XLl3nmmWcYHR3d8v1ZysANAt5KP+Ct9AP+2Vuf53BymB/cf4K/fuQUiVBzJ/36+hL1Zvzp6dl6CgbiDgUdZn55gKjhsCu+svn6oG3c56jpcyC5xERiiYwb4UFugCuL44AiZrkMh3MMR/IMRfJYxubno1LluNvOV/nlNlaO22jq0i/e+XUC8i17rGpBnWH1f73yRf7piY/wm3dfq+vv6x35AUi7V9b8/6/c/Pqa4FN9T4mQS8EOrVnn8+Toz/qU4fLb01/mr+//0BPPvVKKVCpFKpXi0KFD+L7P8vIyCwsL3L17F2DNhWWnvmVfj0x76x7NrvnZKsuyGBsbK89k2WqPoXpfD6n2JnpOp3v3bOfIT2mty4kTJ8rflPQzrTW2bXPjxo11Czk0w6z6gA3Q3Mws8EuXv8EvXf4Ge2JJPrDnGH/76DvYE0/Vfb/1FJXo1YIHrV7830nlCUQKktFiw9Hp/BC+Z7AnvkQ01B3TWGsxFKTCNqmwzdHUAgt2nHsrg0znhpjODQGaVKhQHhmqZ71Qrcpxu6yneM/Iu3lHmyrHfX3hNW7lL7dt1AdK3/Ju/gB/On2Bf3riI7yavlPX/TYy8hPg8rDwCnuiZwH4/KOLa35fa+vChoenH4/CrBn9qeP5+uL8N/nr+z+0acED0zTLF45QvLBcXFxkbm6OGzdulC8sR0ZGGBgY6HgQ6Yfg0A/7AK1b87NV9fYYGh4eJplMPnHM1lu1LpPJMDDQ+qnwnSLhZ4fRWuO6Lr7vd6x3z3aM/HRbSedOcByHyclJtNacOnWqpSfi0CbVsB7mM/z2re/y27e+y1AoyjvHD/G3jp7h5PDGU4X6raJepV6NbEVPbn005EEIFv04uVyYwVCe0Xiu6lbdFfgsI2BXLMN4NEPeDzGbSzKdTbHsxlh2Y9zNjGCogKFwvqH1QmEzz6Ke5E/mJ/mD2TAp8zDvGHyJidhu9kX2Mxgaqnsba317v+xl+J2Hn2xr8IH6Xy8nCPjUvTdYcgt1/X0jIz8A13KfZk/0LK8v3CXjrx3pqrWNScthwbGeGP3xNKg69slXWb706C0GGix1HQqFGB8fL7dFKF1Y3r9/n5WVFeLxePnCshPFE/ohODRSIrqbdUv4qbZej6G7d++SyWTKx+zIyAixWKzu10NGfkTPaGXvnkZ0utpbLpfj3Llz7Nq1qyUlnXthakFpjvrTTz/NjRs3Wr69lqr/A3bRLfDZ6St8dvoyMTPE24cn+Gtve4kP7D72xHYZhoHnbbyGQKq9dZ7a4OLVNDQDMZsAg9srI1j47IkvY5nd+zopVVwsfziV5uBAmiUnxnQ2xYIdJ9AGC3aCBbv4QR4yPIYbWC9UrBx3la+kp0ll5wAItCLQYQwVJawSxIwUSWuYYWuc0fA4u8MT7ItMEDVjq9u39n3xC7d+GZTbhmfisUbfVv/n9a/V/behBk8/805xtOdXbv/Fk7+ssZ1KQcjw8bW15meNfOPwqYdf4D/nvVs6V1ZeWGqtyefzLCwsdKx4Qi98Nm2mHwIcbN+0t0Zt1GMol8sRjUZxXZdCobDhzBEpeCC6Xjt69zSik9XeZmZmuH79estKOpdGrbrxGx0ovra3b99mdnaWl19+mVgsxs2bN1v+gdJcHxRF3vf41twdvjV3B0sZHE+N858cfJ4fO/QCIcOss+BB915U96t6L6cSq8UQZu0BbDcEKoAuH2Q1FKvhJo/jG8wVEtzLDOEExWlUbmAxmx9gNj8AaGKmuxqENl4vVAgMUuXH0BjKBmw8llgJpllx4IEDVAyW+dogMMOY8zGiiwPEjUHSrsu8N9vOpwBodJROkQ886j0yImZjF+QBNtOFN7iUma7x29rv/6Rlk3bMGqM/9Z0vVoJH3NdpzjS0petTShGPx4nH4zWLJ7iuy+DgICMjIy0rntAPwaEf9gF6J/xUqtVjaGZmhvv37z/RYyiVShGLPW4DkM1mZdqb6F5aaxzHaXtRg410YuQnCAIuX75MoVBo6TS3bg4/juNw/vx54vE4Z86cKZ942zHNsJGRn/V4OuDC0gwXzs3wL859gYOJYd4zOMEPDBze+HabjAx1K617+BvZBjc9ZAWELJtAw4PMACHDZySao9uvBcJmwL7ECnvjK+Q9C6U0GTfCshNh0Y6T88Pk/TD5XLi8XmggZJdHhSrXC+X8xkO6qQJMswAUcHSavKd4YA8C7X/igoY2N6Chg0I3/mXXV+d+Hc2hJ3+xzmeWocBSAQHmmj81jfoeWyn4gjrHj/DRzf+4CZsVT9Bal6fINVs8oR+CQ7tKRHdat14nNEIpRTgcZmhoiGPHjq3pMfRLv/RLfPazn+Wll17i/e9/P/l8fssjP4VCgfe+973Yto3nefzYj/0Y//yf//MW7c3Gev+IE+sqjfZ0eppbtXaP/GSzWc6dO8eePXs4ceJEy3sUdeOalMXFRS5cuMCxY8fYvXv3mt/VV0GtMZut+WmUBu5k09zJpvktzjN+58u8b9dRfurYWQ4mH4/YpdNprl27BvXXUBAtoJocbTMUDMSKBRLm7TieZzISzxIxu+89VKk0LS4RchiLPh6aCTQ4gYnth8i6YVbcCEtOjPuZoTXrhYYieWKWgRsYhOqoJFeL1rDgJAg6EHyKj9e+zwOfxr+wMIxbUCP8bHQkJkM2S05szTnfMnzcwKjrc2ApNMe8vcxopP0nmOriCZ7nkU6nt1Q8Qaa9dY9+WrtU+UVqqcfQz/3cz/FP/sk/4Stf+Qpf+tKXuHDhAj/8wz/MBz7wAT74wQ/ynve8p+EwFIlE+NKXvkQymcR1Xd7znvfwAz/wA7zzne9sx66tIeGnD233NLdqpmmWG6i22oMHD7h16xbPPfccg4ODLb//bgs/Wmvu3r3LgwcPeOmll4jH40/8TTu2OdTmY+hRIcun7k7yqbuTDIQinB09wEcTBxhd8XjbU0d481FbH74tdvpkvVjYg7BHIQgxn4uQCNkMrlaO60a1Xi9DFUtoR02fwfDjxf5ag6cNnMAi5xWDkafhemYMy9BEDK/4j+mW/3uzinJZP0w+6Nycwcppb8lQgbwXwte1L94avb42Gyx4AMU1PLsiS8zaa8/jG92VqTSGCtAVoz+Gqn+MyjA0v3L3T/nvnvprDW/vVlmWtWHxhFgsxsjIyIbFE/ohOPTDPkD/7MdGIS6ZTPJDP/RD/NAP/RCvvvoqf/7nf843v/lNvvCFL/CzP/uzRCIR3v/+9/PBD36Qd77znZtWm1VKlQOT67rlCsSdIOGnz3Sqd08j2nEx7vs+ly5dwvM8zpw507bmc90UfjzP4/z584TDYc6ePbvuibYdFdQs1blvtFZcmy8+vM4XuU7EsDjqJIjHBtmfXGp79StR1Mrn2TQ0qXgxODzMJjHQjEZzmF1cIGEzSkFIBYQMh4TlMB7Nln8XaPC0WRwxCiyW3SgF3yLQiogZrIYhl4hZDEUhI8ALDNJuZysnVQ4O70kuc2xonmvpMW4sjrE2PuiGjwejgVLXlc4M3+FPH76wdjs3uU3SsllyY2vX/hhB3aM/F7IXcHyPsLm9l0PNFE/ohwvuftgH6J/9aGQEa3BwkI997GN87GMfA4r9Bb/61a/yqU99ildeeYV/9I/+UV2Pd+rUKa5fv87f/bt/l3e84x1b2v56SfjpE5W9e4CuehO2us9PJpPh3LlzTExMcODAgbYGvG4JP8vLy5w/f54jR46wd+/G5aPbM+1te44nO/C4uLgEi4d5HU0qkufAQJq3Dc1t3nBzm3Vb2edukIwWCyQseVEKuRBD0RzxUHes6WrVO8ZQEFY+4aq1J1oXCxy42sAJTJa8KLYXouAbRK0Ay+hsGKw8Pt3AxDICTozOcmgwzblHe3iUS5X/slHNjPwAHEosPLmVm7yNLENjspXRH4/fuP/n/O1DP9DQtrbTRsUTLl26hOM4DA4Oks/nu+LzaSv6JTT0C9/3N12Dtd50y9HRUT7+8Y/z8Y9/vO7HM02T7373uywuLvIjP/IjnD9/npMnTza83Y2S8NMHtqN3TyNaGSCmpqa4c+cOzz//fEcqjWx3+NFac//+fe7fv88LL7xQ15zadoz8tHrNTzM0iiU7zpId5/zcPhIhm33JJY4NzxK1uvACoHcHNjYsdd0KYcsnbPl42mA6M0DE8BiJ5bd5ZK+9D65WF+hbBMRMD7BhtfpxoBWeVvjaxAsMPG3gahNfK9pV/KDy+5GgYt/jlsvZPfdI2zG+OzNB3m98VL3RPj8lYcNnOLRC2n18bq/nS4REyGHFjVat/al/9Odr6Vf4qYPf33WfnSXVxROCIGBpaYlr165x/fp1DMPYcvGE7dIv4adbj51G+b5fV1n2Vq83Gxoa4gMf+ACf/exnJfyIzW1X755GtGLkx/M8Ll4s9oI4e/Zsx6rDdLpHUaXSPhuGwdmzZ+v+QGvPmp9u+zBVZN0o19JRrqV3ETE9dieWeWp4llRk8yaVHdHmANEPDAWp1QIJc4UEnmcwGs8S3oYCCdv5ahlKE1YaCKgYwCiPFpWCkRsYxX9rA73FUFQdKgJNeV2SUjASzfP+g9f53O1nGh7FNJuc9qYUvHPkNn8283xDtwsZwWqRjsfbudkaq0rayPNns6/xsd2tKnzdXqWwk0gkOHz4MJFIhMXFxS0VT9guvVgiup/VM+2tVTNLHj16RCgUYmhoiHw+z5//+Z/zj//xP27JfW9Gwk+P6raiBhvZ6sX4ysoK586d49ChQ0xMTLRwyzbXyR5FlTKZDJOTk03tcz9Ne6uPwvZD3F0e5e7yCJYRMBbLcHToEbsS2c1v3sbtEvWLhV0IQ84P8SgXIRUqMBDtkiC7TR6PFgGsPQ/5WuFrhadNXF/haQtH1z9KU1ntzTQ0gTaeWKuzZEebmr7Z7LQ3gMPJBfTD1S/zqL8Za8JyyHiRNRf6oQZGf/5w5ks9E35KtNYYhoFlWYyNjTE2NgY8Lp4wNTXFysoK0Wi0HIbWK56wXfqhRDT0TzPuesJPPp+vWWypUQ8ePOBv/s2/ie/7BEHAX/krf4Uf+qEf2vL91kPCTw/qht49jWh29KSZKV+tth3T3rY6ta8t095Ur5wqFF5g8jA7yMPsIJZyGQg7vG1ojgOpxY5Oq+rlz8LtPKNYpmawskCC1ozGs129xssPNGYjQw0tYCqNqTRhAnwFShWDYt4PsexF2Wy6XGWfH1NpfK2euCC4tTTa8HYpvbVzT8TwGDWzLASNne/Dpg/ek6M/9b4qeZ3mraWbvDj4toYedzuVrgGq1SqekE6ny8UTkslkuZLcZhW52q0fpr31Q8nxknrCTzabbUn4eeGFF3jzzTe3fD/N6JUrGrGqVNSgm6e5VWtm9KRU2cyyrIamfLVaJ8NPqYKd7/tbmtrXjm0O9+g3c15gMZ+LMJ8b4LUHAYORPAcHF3qiYMK26pIpe6UCCYtuDNsJMRzNEeuSAgklWkNUuTg6tM3n4+Jjx0yPmLmCrw2W3ei6o0GVIzqGEZD1I4BNxHx8rp4vNF6BrtkpbyVKwffsuckfTz2ParAIRNxyyPsRKiOPuVpNb7PXRin49/c/w78e/HvNbPa2qCc4VBZPmJiYQGtNJpNhYWGBy5cvl4snlNYMtaty6nr6Ifz0S48fqG9fMpnMtnwZ3UoSfnpEL01zq9boyM/S0hIXLlzg8OHD7Nu3r41btrlOhZ9sNsvk5CT79+9n//79W7qIasu0tw6Wum6lymdBa4PFQoLFQoLJmf0kwwX2pxZ5aniWcFsKJnT/FxPr6bYtj1g+EcvH1QbpzABRw2O4xQUS6n3HBAFUnn5zfoiElQcULo8vHFXgozu1Vu6J50FhKs1wuNiwteCHWKoaDdJaETZsnCCCqQLswMIOLEwvIG46oDVu0PjnTLPFDirtj6WJ6AAPRSNHY9T0yXlrv4U3FXW3XH3kTfGwsMCe6EhjG7xNmgkOSikGBgYYGBhYUzwhnU5z7949tNYMDQ0xMjLSkeIJ/RB++mEfSuod+UkkOluav9Uk/PSAbuzd04h6R35KDTynp6d58cUXu+LN1YnwU2rUevLkSVKprXcab8u0t74bJlFknBiX52JcnttDLOSwd2CJp4dnSIRbM7LQHWMn/aWyQMKjQoLANxiNZQm1pEDC5udVP4B7uSEOJR5Pocx6EcYsRcrMM++H8Dx45KY4lbqFqTT3nBHaVbFt8y0v/iZqekTNFXytWHGj2DqMBk6MznBjcXzNGh1fG6x4Ue4tpTa85/W0IvxEDY/dyUXu54Yafh/FTJdCsLZalWVovEBtGpYNpfl/7vwJP3v8bzT4qNujFdOtKivFQXHWRa3iCcPDwwwMDLT8Ir8fgsNOG/kpTZ3sZRJ+ulipd8+dO3ewLIvdu3f3XPCB+qq9ua7L+fPniUQi2zrNrVo7w08QBFy+fBnbtlvaqLUd22yp3v5w2pgi70a4ubCLmwvjhEyfPcklnhqZZTha2O6N2x49cJqJh4s9zbJ+mFwuzEC4wECbK/09sAdxtcW8E2csUhxVcXXxXDVsZZmyB7kwM0E86aKAiOFzNPKIaWeIvN68fGx7KUwFQ+ECkMcKHHwMXhidJsOT6z6W7FhTj7LVaW9QnIL2wtA0s9nBhm8bszzydrhq9EfjVVWDW8+1/BXyvkPMDDf82J3WjuCwXvGE6enpthVP6MXrmkr9EOBK6p321g1fTm+FhJ8uVdm7pzTy06snCKXUhtOwFhcXuXDhAkePHmXPnj0d3LLNGYZRbhzbSrlcjsnJSfbu3cuJEyda+tq2Y9qb0dfhp5LC9S3uLY1yb2kEwwgYjWU4PjrL7kRmuzeuY3rpTGOZAal4Aa3hQXYAS3uMJ/MN389mb5k5O1EuL512E4xFcti+SenZihg+jm/huCGcpTAUrx1RCiYiaZa9KLPeUEPb5HgQbsuntMLDIqQ83jY4z/XMKHZFAPICcP3mvoDaSqW3SvtjaQbiBZqpnxA1XexgbXixlMbTdYz+GD7/9u5n+btH/lLjD7wN2n1d0EvFE7ZLP438wObHVDablZEf0XrVvXtM02zLBXinrPdG0lpz+/ZtZmdneemll1pSPaTV2jGKMjMzw/Xr13nuuecYGhpq6X1De6a9GT11OdwqiiAweZQd5FF2EKUCkmGbY8OzHBla2OaGnO3We5P2lIKBqM3dR8OYnsHIUKNlztd/QbNeiJwfLr/mWiuyboh8sHa0diK6xHkOsLhU/a2oImXZxI1Z7jmj+Gx+oXRlcZx8EOLF4ek6jrX6RjVKgqBYCACtCBs+gyGbkJkn74dYdGPM5QYbur9K1eWymxUzXBIhm5V84xfUcculYK8tQGEaGs+v73n6ztLr/Iz+4Z79wrFdur14wnbpp5GfekjBA9FSpWlupVGe0pvJNE0Khf6afuM4DufOnSORSHDmzJmuPXG0MvwEQcDVq1fJZrOcOXOGcLg90yoMw+Cby2/x21f+iFPDp/jesdOEja19CMlFQLFgwood482Hh3jz4UEilsvegSWeG5sm2paCCdunl1/uQBvcWBpnMJnDtOoPcev9pR/AvJN8/Jyslk+etQfKldH81Z45u8NLoANyhUjNS2zL0ByJPGLGTbESrP9lz4X0bjJ+FEv53M0OcSi5WPd+1GPJjRI2A1yvuJVDoTwZP7JaKW6ZK3O7mr7vVqz5geIxeCL5gDe8Q2sasNYrbHi4VZXuTKUJ6gl1hs0fPPgGH9/3nsYedIfptuIJ26XfRn42k8vlZNqbaI2NevfUs2amlywsLHDp0iWeeuopdu1q/kO2E1oVfvL5PJOTk+zatYvjx4+3NUwYhsGCv8wcr/G5udf409lfRekx9kef4p3Dpzk78gJmg1WojF6+Gm4Lhe2FuZ0e53Z6DNP0GY7meHp0ll2xDGaDJXq7TS+/2hogHnDx3gTPH7lf321qDAiUvs19YA+uDYOrf+tqg5AO1vwuYvgcSKW5O7PBeU0pdoeXSfl5ptxh1lZgg8mFvRT04y9GHtkD7IsvEdrwmGrsFbODEHHTLZe7TlgOi26MkKlXR7WaX5/UijU/JQejad4yD5LxoqRCjX0BmLAc0o615lxrGRrbr69IwGfmvibhp0HrFU+Yn5/nxo0bmKZZniLXjuIJ22Wnjfxks1lGRxvvAdZNJPx0geppbtUn5n4JP1prbt68yfz8PC+//DKxWHMLajupmR5F1R49esTVq1d59tlnyx8K7aSUwgzClGbWWEYAzPLAneUPZr/B7z60COldHI4f592j7+CFwWIY++Fv/iz7omO8a+QEf2nvO/j0ndfYFxvmB/a/uEOnvdVL4fsWc9kUc9kBlNLEwzajsQymSjMQsbd7AxvXJX1+mqFXR2HyCYPp2WH27UrXecO1x7gbmCw58fI6n2ohozL4PL7tU0OzfEM9gx8o1p/dpoiZHm8zHjFlj2ATIgjgrfQEjrYq/wwF3FgZ55nB2fr2YxOObxC1VqdRV7zMcdPBJcRUJrWmB1CjWjXyU9omC49FJ0rSKjQ0+qMUhJSHR3OjP7Ze5tvpy7xz+JlGN1usqi6e4DgOCwsLa4onOI5TXkDfqzMM+mXkZ72mudWk1LXYknp79/RD+AmCgNdee43BwUFOnz7dM9+SbKV4QBAEXL9+neXl5bZOc6tmGAamXv+xQoYHTHPbnub29Jf59/dCRNRewkaGe/kCd6Ye8Nv3vwQYaAJ+6dbvM27uwTR8/KD3T/DtpYrfnNsxsnaUu4tjWKbH7uQyB1JLjMSyDU/f2Q49sInrKl24KwX37RTD9gqxyObly9f0hAo0McNnUa//TKy3sH9/PI0iIKijR46h4EB0ngU3zufnnl13LVDGi5BxQyRDW1/7uejGiFrFz5PKPRgO55nKh7m7srUeN2YL14spBc8kH3I+s59lJ8pQpLHRn2TIIW1bKKPx0R+l4LemPivhp4XC4fCa4gm5XI633nqL27dvlxfRlyrJ9VLxhH4Z+al3P7LZLAMDAx3YovaR8LNNGund0+vhZ35+nlwux9NPP93109yqNdqgtaRQKHDu3DmGh4c5depUR7/RMgwDq4GyuiHTJeAuR1dbDOXcEEtOlKwXJu+H0CbM6Cl2D0IQKDJ2hGwhuqVvh3eG4vPj+SGmlkaYWq0eNxzLcnBwkfF4hrDZne/rXn5lKy+9VURzaWqCl47cqXsdk9aa3aFlZp0kA1aBea/WerkAo+KRKh8zYng8u3tq0+pxFVvJSCjP9++6wOdnn8Wt8bGsFNzMjPHC8IN677Qmrdeu56rexJDyWXS2NiJvGq1d/3YotsD5zH7STpyBUIFGWo4pBZbh41c9p/WO/iz6D7mTm+VQvLc+t3qBUopIJEI0GuXkyZPl4gnpdLrniif4vo9l9f7ldL0jWDLyIxpWWdQAqKtpaa+GH601169fZ3FxkVQqxchIb3TNrtTMtLf5+XkuX77MM888sy3zYpVSGNp64kKnXvGQS7ziG+aME2bZiZLxwxR8i6FEgVS8QBAY5O0QS/m1neNFLcUXIghM5rMp5lenxyUiBQ4MLLI7uUIy3N4eNY1QvTztreqi1h/Q3JjazbH9M3XdLoJHwnLQDqRCNvNucs0bKUARwt/wvfX2vXcb3u6hcIEfnXiDr809xbT95PRYJ7CYLSTYFW20it1jK26kXKQBnnyuRiNZIqZH3mt+lFq1uFJg0rQx8MEwub8ywqHBhcZuH7JZdKw1r5epNH5Q3+jPr979Y37umb/dzKa3VavbGWyHypGGyuIJBw8eXLd4wvDwMENDQ101zcz3/Y7N7GinRsKPVHsTdaue5lbvaEAvhp9CocDk5CQjIyOcPn2a119/vSe/HWmk4EHlmqZTp05t27C9YRgoXVyz0IqRhWTYKV+YBxoyToRltzgyZBk+yZhNoBW2a5G1w9iuhYShzRSnx2UKcS4VYlye20PYctmXXGLPwArD0VxPTI/rRrUuCRfMKEvLMQZTtfv/lG4TBJq90cXV/1MopYkYLvaaaaRq04IWhwfmyDiNFw0wFXxg7Cq3cqN8M310ze+Ugvu5YcYj2aar8eX8MHFj/alzptKcHJnm1dnDzT0ArS14AMX9Pp6Y4VJ2H75SpAvRhpoPGwpM5RNUTClUqrg2qZ7R69uFG2TcHMlQd7ViKK0R7mUbTbNar3jCwsICN2/exDTN8hS57S6eEARBV4WxZjUSfmTam6hLI9PcqvVa+Ckt8K8c+ei1fSipN/w4jsPk5CSpVGrb1zSVHtsLjJZPqzIUpCI2qdVF/IFWLDsRlp0oOTNELOxQbBRqUnAtsoUwfiCnmY0Vg5DtRriVHuf24hiG4bM7scKe5Arj8Qwhs7OltPtp5AdAWZqrC7t5OXGb9T7bA60ZszLl0FksnKAZtArMupXhRz+xrqX6MaOmx5JqcvqYUhxJLLAnuswXHz1DNnj8JYpGcSc7zOFknUUcKri+ImqtXfuka6xpeir1iNcfHSDQzV3MtbLgQcnh2DyXsvswTc3U8jBRa46YVf/6p2TIZsmJra38pjROHaM/hhHwq/c+w3/zth9revvboR/WmTSyD7WKJ6TT6TXFE0phqdPFE/rhtYD6w4+UuhabWq93TyPa0WizHYIg4Nq1a6ysrHD69GkikcfffPbKPlSrZ7vT6TQXL17k6aefZnx8vENbtj6lFAQaNzCB9jbHNZRmKFIoL0T2AsWyE2PFjZC1QiQjBTQGjmdRcEJk7RAyKrSRYhDyfYMHmRSz+QF0AIORPHsHVtgVz5DowPS4Xh51WvfSOxFw+e4Ezx2ZqvnrYTPHYEU55VIuSIYcHjkBWq32XUPXNfKy1bUvMdPjB3ef582lA1zL7S7/fM5OMhFfItTg/S+6cSLW2i9DagXFqOlxfGiWS+m9TW13q0d+AFJWAUWAxiAedbizMsTRwfm6nwNT6SdGehoZ/Xlj+S384OOYXXSB2+8jP5sJh8Ps3r2b3bt3o7Umn8+TTqe3pXhCv1R7q3c/MpmMjPyI9WmtcV0X3/cbHu2p1AsnuFIfm/Hx8ZoL/Ptx5Edrze3bt5mdne2q0t2GYYAGt45qU61mGZqRaI6RaA4A1zdYWg1DubDFUMLEC0xs1yJvh7E9i95eXt8+CjBNDSZk/ChXF2JcnttN1HLZO7DMrniGoTZMj/N77zuKNTa6mM3GTR7ODbJnbGnNz5UOOJKYq7qjx/cTNVzyq0VErFoX3DUSV8oqEOjmz/tQvEB/eeguB2ILfGX+OAEGSsH1lTFONFj6utbzsl5QPDH0kEvpPTTz3jRavOYHis/Dsfgs13J7ME2Nmw9xLzvM4eR83cd/0rJZdqNPjP7Ygd60j5kyXD45/RV+Yv8Ht7IbLdUPow2t2gelFPF4nHg8zsTExJriCVeuXMG27bYWT/B9v+dfC6g//Ni2vebL7V4k4adNNuvd009mZma4fv36hn1s+m3kx3Eczp8/Tzwe58yZM1114lNKodB4XVCWOmQGjMWyjMWKi7Rtz2TRiZHxwuSjITxt4nomBTdEzg5LKe0KleuZlQJlagxT42FyZ3mEW4ujmATsSqywO5lhLNaa6XG1pkL1ut2RNDP2MMqAu/lhEoU8yYiDUsXneU94Gatqulbl0zAYKpCzIyhV/8hG2PBJezHi5uZltjemGI9k+ZE9b/KV+aeZdwfIehGW3TCpUH2jgCtu+Ikpb8C6FemGwgX2J9PczzRepGa9EuBb9bb4HNdyewBIxGxyTojp3CD7E0ub3LLIMoLVYgxrR39MtcFoYYXPzv2FhJ8Wa9c+1CqesLy8zMLCQluKJ+y0NT9Azx97En5arN7ePf0gCAKuXLlCPp/ftI9Nr478KKWeqKqzuLjIhQsXOHbsGLt3717nltvHMAx0AK7qvpNxxPLZbWUoPWs5N8SyGyXjhsnHimHI8SzyToicTJFbl2FojNVF9zP5AR5kU6BhOJpjTzLDrsTKmop9jej1EuZrL2+L3j96jT96+HYKQRgVDbgytY8DE/OEDJ8Ra5nxSKbGHT2+l7jlYjoBvlY1j8j1Lp5bGSQtQ/PhsctcyezmuysHuZUZ48Xh6bpum/UitY+HDbbv5PCDpsKP0YZpbwCDVh4IAKM4Ipo3WHZjPCp4jNdZAS8Zsll5YvQnwAmMzb+gNPL8wYNv8CN73938TrTQTp/21gjDMBgaGmJoaAhoffGEnRR++qHKIEj4aSmtNY7jNFXUoNfkcjkmJyfZs2cPzzzzTB2LRntz5Kdyv7TW3L17lwcPHvDSSy8Rj3dX9Z+SYmPWALfJBcud9ERZbTfMw1wSOxzCjRv4eidPkatvXw2DchBadmMszse5OLebRMguB6GhSL7uCmFBr3+2Ve2npYqlq989dIMvLpwAQKcC5mZT7Bpf4KnBRzXvpvppiBkOWT+yzvNY+8lNmvaWp76tfRjF8YFZJmKLfOHRCWbySXbHagS3Cn6giKwz+rTRS703tsxQOMei09h5rl0jP4aCt8XmuZkvrquMx4ujP48KSSKGRypsb3ofxTVCT47+GHWO/nxi6nN8/67TxMztn/IjIz/N26x4QiQSYWRkpO7iCf007a3eKYG9fn0r4adFSqM97ZrmppTqmpPdgwcPuHnzJidPnmRwcLCu2/TqyE+J67qcP3+eSCTC2bNnu+J1WE+p1LWnu3cb15MMOQyFbQYiy8UpcnaMrBkmEbHRqPIUuawdJpApck9QBphGsRqZrUPcWhrhZnoUy/DZncywK77CWDxbe93Kql4f+ane/LFYFjScHrxTDj8AWcvk6eQsEaP2ean6FD4YKpD1G7vobd3Ut7WSlsNf2vMW3144TBCwYU5OOzHC1jrrFje4oVLw/Og0f/HgWEPb1o5qbyVH47Pl8GMaGjwFJkzlBgmbC0TreJ4TlkPWizQ1+hMNOfzdyf+bX3/7f73tF3/dcj2wFd2yD5XFE6C4hnlhYeGJ4gnDw8M11/b2U/jZbOSn9OV+r5Pws0WdmuZWGjnZzjeY7/tcvnwZ13U5e/ZsQ4sGe3XkB4r7/eqrr3LkyBH27m2uAlInqdWFDG6PhgN/dSpOaYocgOMbLNoxMipC2PJIxYqLyW3PIpMP43h92Ftoi9eQSpUKJmi0VkxnUkwtD6IIGI3n2ZUoVo+LVU2H6vnwU2U4nEejOBSdx8THX+33cmL0ARPRJTy/2M/H3OTwsZS/7jOz0ey2dq2hMhR8z+gtZu0ki0GC9RKQj0FxutiTgk1e6yPJeV4xDmEHDZzr2zTtDWA4lGMolGXZjRJgkog7ZJ0QhmlwLzPMkYH5DYM9QMT0yVZlJKXqawitFKS9NP/i+u/w3z/117awJ1unte75C+5urZIWi8WYmJh4onjC1atXsW273LR9aGiIcDi87ddmrVLP65HP53u+zDVI+NmSrfTuaZRlWdvaJDSTyXDu3DkmJiY4cOBAw/vaiyM/Wmvu379PPp/n3e9+d8+84Sv7/PQiv8Z2h82AXfEsu8jiBgaLhRgZL4KpipdvyrBxPJO8HcLtk+lxrfz+fG0QgoVCnLl8ggu62LdpV3yFXYkVBiOF4sV6Lz99a7ZdE7McNBBSAWeGbvPtxaMkrRwvDt4H4J49TMTy2RdeYtZOsCtSe/3Ikhdrqrloy6e+raHYFckyqrPcLYzisjak5LwQsRqFDso2OcgsI+DZkQe8OXew7i1q17Q3KAa+pxMzpL0kbmCS9UPMeilyhHC1yb3sEIeTC5u+TnHLIe+HqTxYQnWO/sRDLt9OX+YTU1/mJyY+0IK9ak4/fAPfC6Fho+IJ9+/fJwgCbNtmYWGhJcUTtlM94SeTyXTtlP9GSPhpQmXvHuhM1QvDMLYtPExPT3P79m1OnjxJKpVq6j4Mwyg/X73A8zwuXryIYRgkEomeCT6wejwGvTzys/H7KWQEjMezjJPFCxSLhRhLbow8IaIhnyAA27PI2SE8rzefg3YqV45bvfLNeiFuLI5yPT1G2PIZjmQZihUYjBYIW731hUW1gVBhtZpX8SLxnYO3eGXxCKdH7hI3XRbdGHPuALvNFWzf5NzyBN8zcoOY6VOdDHLe+gVdNgoR7Zr6VslUcCQ2x5yTZMF/3H9jxY0+MbJXqZ5RvuODs3x3bj+6zpHVdvT5qbQrvMKinyRs+oRNn+HRAn6gyPphlpwoD/NJ9sY3XgcVNT1yXnhNSFJ1Zn7TKPYM+p3pr3I0vpd3DD+ztR1qUi8Eh80EQbBtX+g2q1bxhFdffbVlxRO2Uz3hpzQNsNf11lHXBVrVu6dR2zFy4nkely5dIggCzp49u6WTlGmaFAqFzf+wC6ysrHDu3DkOHTrExMQE3/zmN7d7kxpSnPZGD4ef+t9TlqEZi+cYI4cfKBbtGEtOFNMIEwt7+IHCdiyy+TB+IKe7Wh4XTNAEgWI2l2J6YZjAg2TUZTiZYySRZTCeL66z6HYVh89YVRWwt8Ue8fTgQw7HFvC0wbXcbhQBhoIZbxAnsHhz6SDfM3JrzYVxEICnzaZGfqBT5cMVY+EMA0GBu/YofmAQMjf+zKjn1YxbLscG57i2tKuurWjnmh+AuOFQXbTANDQpwyYVstGr5z5d+qt1XrSo6WIHawOtZQS49Yz+WB4ZN8Qv3Px9/tWzP83+WOebW/dL+On1fbAsC9M0eeqpp4DHxRMePHjAlStXGi6esJ3qHfmR8LPDbGfvnk6Hn1IAOHjwIBMTE1ve115Z8zM1NcWdO3d4/vnnyx2Mu6nYRL2U6uHw0+R0PdPQjMZyjMZyBBqW7BhLdpSMESYWcVeDUIhsIULQA1MCt6OiqDKKF4BWMkBrcDyD6aVB7s0NoxQMxvIMJ7MMJ3IMxAotb7C6VX6wdu3GQGhtBbCY4fHuwRsEyuRmbhxbh0iYxS9lFJCwbO7nh9H61ppRgBU/umHw2WwEpb1T3yopIobPsegs5zITm65/CeoMZc8NP2gg/LT3PG8oGDRzLPm1R+OVgnBF6PO1wtdGuYph6TWIWy75Qgij4iA2VLFJa/FP139uQmaA4SoKgcsv3Pw0/+KZv9XxCnBS6ro71SqekE6n6y6esJ3qCT+5XE6mve0U3dC7p1PhR2vN1NQU9+7dWxMAtqrb1/z4vs+lS5fwff+JUa5uKDbRKIXC8w0c3yDcgsaXnbTZtLd6GAqGo3mGo3m0hiUnypIdI2OGiUcdvMCgYIfI5sP0XaGEFlEKrFCAFSoGocBXrLhhFh/FuDVrYBoeQ4k8I4ksw8kciUh9DTfbqfJi3sQnvFrJrTJH7o8s8mbuILNOcQpvafqfUrAvvsx0YYgb2TEq22SteBtf2KpNxlA6MfVtzfao4siG429cqGCzggclI5Ece+JLPMxtXt2znWt+SsZDK+uGn2qm0phq9ThYrYIZ6OIrFjVdHL129Mc0NAofVCk0KWoFoajlcShylNuFB/wv13+XH9p9ljNDx7e6a3Xrtc+kWvphHzYLobFYjFgsxr59+9Bak81mWVhYWLd4wnaqp2qdjPzsEN3Su6cT4cHzPC5cuIBpmpw9e7alC/e6eeQnm80yOTnJ/v372b9//xOvcTdv+3oUEGDwF1PHGI7k2BVfYTyeIbLJNJhu0Mi0t3ooBUORAkORAlrDihNh0Y6xYkZIxmw83yBnh8gXJAitRykwLY1peeioR+ArfM9gIZNgfqX4BUnYcsujQsOJHNFQZy70K1UG5/FYpjxaUzkyM2JmuZ57PIpROVIRNX32xxa5uLKX54cfFG+ri1PeNlLP5X5npr4VOYHJsr/5t8qNbNPzI9N1hZ92j/xAcSStGUoVCxuUhIwCBd/D9kM42gQMDAXLdpSMGyEZtomaHoYKUKp0bipVo/SYXL5PxIhR8AP+6MF3+OLcW/x/Dv0Aw6HWfGm4kX4IDjttH5RSJJNJksnkmuIJ6XS6XDxhaGiI4eHhbSmeUE8FQVnzswOUihpsxzS3au0OP8vLy5w/f57Dhw+zb9++lt9/t478PHjwgFu3bm1YzKHV4eeXb36G08NPcXr4qZbdZ7XSkapRLNgJFuwEl9OaoUi+WNkrliG6URWobRQE7XufKVWsbpaKFC+eVpxwsYS2FcGNFyvGFewQeTuEBKHaHgchH6I+ga/wXAPXNZlZHGRmcQiAWNhmJFkcFRqK5wh1YASycsrkUCT/eJsr/iZuuIxYGWbc4nYaVdFlf2KR6VyqPJqT9UNsvhR+82O2c1PfYM5N1rVNjZQ1n4gvMhDKs+JuHKo6MfJjKBgw8qwEW5s2ZCpNwnJJWC7B6lqhQhCCsE/ajpEuPB5dChke8ZCDZQSYKsBQmkTIYdkxeWNxClMpkpbJK+lf5KcPfR/fN36qra+1THvrDlvp8VNZPOHIkSN4nsfS0tITxROGh4dJpVIdea42O6Yk/PSxbpjmVq1d4UFrzb1795iamuLFF19sW1Wzbhs9CYKAy5cvY9s2Z86c2bBnUau3/Yuzr/MfH/4FFiGeTR3hr0x8Ly8PN9ZIcDOq5kWNYtGOs2jHuZreRSpcKAaheIa41T2V+Fox7a1eA2GHgXBxulbWDbFox1gORXESJo5nkS+EsZ16Ln53LsPUxTUW0WKlPd8z8R0T1zOYWhhhamEECBiIFRhO5BhJ5kjF2lM8oTL8VB7TquqC/IX4FH++NFTc/qrfWUrz1OBcedRoxYu2ZNs6NfVNa5hz6xt5aOQVMBScHJnmWzNHN/67dXoKtdp4aJkVu3VrJgxV7AEUMX1SFoxGciw7UeYKCRadGG5gsWQ/vmQy8bFMHwN/dVTIYMkNiFge/+ftP+ETU1/jf3r6Jzic2NOybazUi5XSqvVD+AmCoGUjNJZlMTo6yujoKPC4eMLDhw+5evUqkUikXEluu4onZLPZnqp+u57efue0QSd79zSiHeHHdV3Onz9PJBJp+TS3at008pPL5ZicnGTv3r2cOHFi09e41eHHUKt9eHCZXL7K5PJVQirMcwNH+Cv738vbh9625cfY/KhVLDsxlp0Y1xfHGQjZ5SCUCG3v2o12jvxsJBFySYRcJlgmVwpC4Qi2b+F4xfVBrld/s8et6o4zT2MMA4ywTyjs8/ee+QqBVuS9EHkvvPrv4n8XciFsbcBq/6FQyCdQgKFWQ0dze19a85OwCmtGIKrv7Uh0DpZWt7lGBBgLZ/F0sYR0PQ0+6w0RnZj6tuxHcX1V18Blo9tzLDXHq7OH8PT6lw6dGPkBSFo2NDf7bVOl6XGj0Ryj0RyBVuS8EGk7zqN8Eldb+Jj4/upnptaEDQ/D0Ku9xzRpd4m/d+GX2R/ZxT8//tfYHR1u6Tb2Q3Do1ianjWjnPmxWPCGRSJQryXWqeEI2my1vTy+T8LOqundPNwUfKIYHx2ndReni4iIXLlzg6NGj7NnTnm+mKnXLyM/MzAzXr1/nueeeK9fp30zrw8+Tx5WrHb67fIXvXrxCSIU5mXob/+nE+3h+6HBzj9HQxaNixY2yshTlxtIYiZDDrlgxCA2E23R1sQG/C6abxUMu8ZDLPqDgWaQLMZYjUXJeCMe1yOYjHSidrdC6vs7z3UbrYhAJGQGhsE2qgeMo0IqCb1HwQ8XgGVg4gYkbmHjaKC5YL37fjlbFf5QClCJYHTUcj67t81J9OT5k5hkysyz6iZrFCpQCrU1sX6O1atlr0ImpbzN2irjh4hLgsHFwa7SiYMgIeHbkIZPz+9f9m3aXui6xlCZKgQKtGZnbiKE0yZBDMuSwP7FYXFPlRJkrJFl2o4DCCUIUB72KI6Fxy8E0AtL+ff7OuX/FeGgX/83RH+HEwPrPXSNk2lt36OQ+1FM8oTRNrtHiCbrOk4FMe+sj29W7pxGtGjnRWnPnzh0ePnzISy+91LGShds98hMEAVevXiWbzXLmzJmGTgytDj+m2vhE6WqHN5cu8+bSZUIqzPOpo/zV/e/l+cHDdd2/7/vYdrOhRZF1I9xyI9xaHiNmOeU1QoORzvRp8rdp5Gc9Uctjb3KFvRQbYaYLMZZjUbJeGNsNkc1HCHq0rHg71VtGuZqhNHHLbXgqpu2b5CMhCn6Y2WDt+r1a2/JC4j5fWz6+7sV62PB5WEi2NHy2e+qbGxj4ujiWtS+yyG17jFaPIT4zOMPk/D7WG1pqd5PTSmOhLPfd9oefSmp1etx4LMt4LIuvFStOmIf5QZadKBoDx7dw/OLlVcjwSYRsCuoe//LmLxIEUc4MvcB/ceAHSVjNf1svwaE7bNfo1UbFE6ampgiCgMHBQUZGRhgcHNx0imS9r0Uul5Npb/1gO3v3NKIV4cFxHM6dO0c8Hufs2bMdPels58hPPp9ncnKSXbt2cfz48YZf43ZNe6uHqx3eWLrEG0uXCKsIL6SO8p8eeB/Ppg7W/PtcLsdbb72FZbTmZJz3wtxZHuXO8ihR012dGrfCUBuDULMXzZ0QMX32JDLsSWRwfYN0Ic5SLELGjZJ3Q+RyEXQXjFxtlaU9PLW1j4fiKEzrvvAouIpoaP1vJ0vrNbzA5lFubfiptbD/aHSWry0fZ9mPErWyT/we6pvy1qh2Tn27bw8xHsnwIJ9iOJTnge1is/4XPUETx2oy5HBkYIFbK2M1f9+pkR+AkVCOu/YoLfso0wGW9lj0B3ADg4jhEbPcDQNwsWiCw55Eht3xDLZvkvPCLDtRbD+EG5jltZam8kmEHF5ffpULV75FEEQ4FD3I88mTnB0+wb7oaN2b2g/BQfahdaqLJ/i+z+LiIgsLC9y6dQvDMDYsnlBviJNS1z2ucppbtxQ12MhWw086nebixYs89dRT7NpVX7O6VjIMo+5h1VZ69OgRV69e5dlnn2V4uLk51y0f+Wnym1hH27y2dJFXFy8SMSK8OHiMv7b/fTyTOgDA7Ows165d4+TJk8xdeANavHSn4Ie4uzLC3ZURwqZXnho3HMm19NvxTpYE3oqQGbArkWFXIoMXGKQLMeZjcXJumIITJtujpbMVAePJLA+ym5c13kgrQ+yD3ABvpg/ysYkLm/7tnDfwxPFY68wzamaJq8K6x5sXFANcPcd2I1XTak19C4LSl291380TggD0aqlmf3V79kWWuLXB6E+zZ+TnRh6sG34so3Mj/JYR4AWKcAuKZ4RwORZ/xHQhhaMejzrafoiCb2Eqn3jIrbmmqXQMKQVRyydq5RmJ5vGC4pq3jBthxYnga7O81tJQAXHLwQ5u8+r8DJ9NfxrPDxFXw+yLTnAyeZR3DZ9kNFK7CqlMe+sO3bpuyTTNhoon1LsfMu2th3VL755GNBt+tNbcvHmTubk5Xn755a7rKNwuQRBw/fp1lpeXG57mVm07R35qUaoYhF5dvMAr6QtEjShHzT28h6N87Mx7CYfDbf9AcXyL+5lh7meGCRke47EMu+IrjERzGFt9OymFFyisNlQDaxfLCBiPZ0HBgdQiS3aMFSdCxomQd8LkC02WztZ0vPLBSDiPZQVYhoe3hXVNrQo/fqC4kdvNnJsg71nENinRvuQ9OZW3VjgxFLyQmGIyP7Hu/dT70bBZk9NKtaa+Xc/u4mAiTVQ1Px3unj3MUKg4IluqmDgUyhO1XQo1Rn+K30U19xrtimYYjy7zqPDkhXm4w73EDkYXmHaGmx790VozaOY4GitW+Ktu/Bo2/fI++dog44ZAQ8xyyg2ktVI1k6Rl6HJFyT3xFWzfIuuGWXYiOEGIjBsl40ZZzoXIuRapSAEvuoDjzHJ74U3+eP5TBEGEhDHCgcgEJ1NP8a7hZ0mFEn0RHCTAdc56xRPu3LlDJpMhEongeR75fH7D68RsNsvAQPv7WLXbjgs/vTLNrVoz4ce2bc6dO8fAwABnzpzpiTdoKxQKBc6dO8fw8DCnTm2910Kn1/w0QimwdYGL3m0u6Nv8h9e/wduHjnFIb+1b+0a4gcV0dojp7BCW8hmPZ9gVW2Eklmu68pMfGB39BrlVAl0MbaOxHKOxHF6gWCzEit/82hFydqSh0tmdzj5aa/amlllyo6SiNgu5LYSfFm356wuHSEQd/GWDNxcP8D1jtzb8eyew6g4tx2IznF8n/OT89nVbrx5tupUb5VhyrumLQT9QmBWnlQATLzCwjICJyCLXC+NP3K+m8YIHlZ4ffcBfPIwX+94YGtMIsIyAUIfft+PhDJdy+xgO5zf/42o64FBkgbHw42mPeoNS+6bSDKxWw9QaMm4YLzBQaAI0xgbf/BRHhTyilsdoLIcbGOS9ECtOhGVCLNsxlu0YLEPY9EhFCqQiBQYiNgX1gGvOA67NvcanH0EQRIl4Axx+eJDT7nO8c/gEUTPS+P53gV65BltPt478bKa6eMLMzAxTU1NPFE9IpVJrwpCs+ekx3di7pxGNhp/5+XkuX77M008/zfj4eBu3rLuU9vuZZ54pD/dulWmaXRt+KpWC0HfS5/m2hrGkwnZD5JwQ/iYd6lvF0yYPsoM8yA5iqoCx1RGhsWi2ob4unjaItHC9SKdU9pmB4je/Y/EcYzwOQituhJVClGwhsnHp7G24JkhZNomIw5ITJRbaWu+noAX9mqazgxjh4nETYHArO7Zh+FnxIjWDz3pH3m5rhRBP7mcQgBeYDUxDa+zFSpo2aTdG2AjIeRZuYBIxPDJehEgTxRDu2cOkKkrUB1rhahOLgFSoQNxxyOu1F8fF0bDmD7IDiTQTqSXcqrLXnVzzA2CpgBBew5URQ9rlqfgs0arnu94zvVIQrxiFdHyDnBfGx8A0/JpVPdc8fkUlxL2JZfJeiMVClLlsEtsPMZdLMpdLAppk2FkNQgUSYRfTLOCZBa77j7g++zqfmAGCOIPmGIdjB3l58Dinhp4mbHSuNP9O1SsjPxtRShEOhxkcHOTYsWMEQcDKygoLCwv8wi/8Al/+8pc5ffo0H/rQh8jn81se+bl37x5/42/8DWZmZlBK8dM//dP8g3/wD1q0N/XZEeGnW3v3NKLe8KO15saNG6TTaU6dOkU02tlKONultN8LCwst32/DMFpaqW6zD8VWUKpYCtaKOMTDDr5WFNwQ+Q4GIV8bzORSzORSGCpgNJplV3yF8VgWy9j4EqM6RPSKjaZ6rQlCAwaLhWhxVMiJYLshbMfiyalxiuZXZjRuT3Kl/N8hI6B4Kdjca7HVaW+er7hVGCMeKYYTrYsFCJacKIPh2gU3Zpza6yPWYyrNU7FZZoOhNT9f8WuHqPU0+gqFDR9XWwRa8driwfIUz5DhsehGCBsBEeWuGc1ZT96znqgeVwo/sdVgNxFZ5Fp+19rPPr21I8tUmn3hRe7YY2itCQIwTVWzb1I7KQVHE4+4kt3D0DrHxRpaM2xmORKfX+fXzR23YTMgbBYfP9CKrBvCCSwMFbDZwIChKvqMDazg+AYrToSFfJx0vniOyDgRWBnEMnwGInZ5ZChkBsWpxmaOFe5yLn+Xc/mv8+8eKFSQYNga52jsEKeGTvBi6m2YLSqGI4p839+wSXqvqBzBMgyDwcFBBgcH+fmf/3mWl5f5whe+wJe+9CVu3brF933f9/GBD3yAD3/4w7zjHe9oeP8ty+IXfuEXePnll1lZWeHUqVN85CMf4dlnn23HrtXeho490jbo9t49jagn/JSmew0NDXH69Omu3Nd2zPF1HIfJyUlSqRSnT59u+bcw9YafSyvXCBshjiYOb/h37Rr5WU8pCCUjDomwgx8YFDyLnBMi6FAQCrTBo/wAj/IDKIrNA4tBKEPIXBuEFBqvR8OPX+eFk2UExSAUz5WLJazYETJuGMcrBiHf7+xzEFEuI8lc+f/V6gVZ1m1uOk29z8V6Xl84RDxWPHe7vkKjUErzxuJBPrDr6hN/rzWs+FFCNUcY19+Wo9FHzOaG1vws47X/S6OI8nB1iLSbYDy8XPzZ6ohBQUfIBxH06mnHUBoTn5DynwhFD91BBkNrS9sHKNyK99CAZZMwbHL68X41UqRhPUcG5rmxPIoRLpbIj2i34yM/AOOhDJNBCK0LG4ZWpX0ORRcYCeXW/ZtWPC+GKq71KVWdyXsWeT+E1grL9Df9DAybAaOxPKOxPIGGnBtmsRDlUTaBG4RI5+Ok83FAE7NcUlGbgUiBZNgur7k0lAYzw6LO8HruFq/nvoJ/X2HqAUZDuzgWP8yZoWd5buBQV14r9Ip+GPmBjafvpVIpPv7xj/Pxj3+c9773vXzqU5/iK1/5Cr/5m7/J3//7f5+9e/fy4Q9/mA996EM8//zzmz4fe/fuZe/evQAMDAxw4sQJpqamJPy0QvU0t15/c2+2/aWqZq2c7tVqpbUzrZwfW6pi14rpfYtOlqHwk3NZDcMoB+iNvJG+ysXcJ/H8AQ7EnuOj49/H0wNHn7y/DoefSkqBZQYkze0LQhqDuUKSuUIShWY4mmNXbIXxeIZIxcLiXhQ0EdpKxRLG41lc3yhPjcu5IfxSY09f0e7KcbvjjxuDli5fkxG76fCzlZGf+5khrMjji+iC+/ibxfu52lUb7+SGsda58N7ocnxPaBlVXLFR/pnbgffCoJXnlaVdoFgzEpoyC8x7ieLnVvmnCh8LX1trQpGvFZ42yXhhYubjSmSBNp7Yh4nIIlfzu8ufJZqtjylGTJ/xSI5HfhKtIedGWnCvjQspn4Rls+JFSIVq9ziL4PBUYpbwJmuSWhF+qsUsr1yoww0Msm4YXxsYRrDp6J6hIBl2SIYdJgaWcQKTFTvCfC7Okh0l74XJZ8LMZAYwVEAybJOK2KSiBaJVxUGKU4+XmQ+Wmc9c5zuZLxTXV5Ji3NrD8cRh3jH8HEcT+3r+mqlTenXNT7V69kNrjdaasbExfvzHf5wf//EfB+DOnTt88Ytf5Od//ud53/vex0//9E/X/bi3b9/mzTff5B3veMeWtr9RfRl++mGaW72CIODatWusrKxw+vRpIpHuXfRYWjvTihOF1prbt28zOzvbsip2//D8/4BGMWxO8NzAM3x49xkOJHbVXfAgYY4WFxmbKzxwvs1/mPo2rp9kf/RZPjL+UU6kngaaL3XdatVByAsMbM8i54Rbsl6jHhrFQiHBQiHB5bRmKJLHCUwcvzc/TLY62hEyA8YTWcapCEJOhLwfItAGXqBwfXPDRdnNMPHZlXo85a20FxGr+emezYYfz1fcsUfL092gWGa9/HtMZvJJdsceh7VCYHHLHmV8vf5TG1yPh1TAXmuRaW8EgJxXf0GKOu5+XWHDx11tjhuqWN8WMoojPN46H89KPd66QmARNovBLReEcXyTQCvswGTZjbEn8vg1TVoOScMmuzr6U5zetfVz0TMjM1y9uYtwxN3iKqLmKQVHonOcz0w8EX60Dhi3MhyMpeu6r1YV6lhPyAjKfdICDVmv+LoVz8cbH0mlBquR1VFjXytyTojFQoxHuQReYG1YOKHWukvTCNAsMhssMrtymb9Y+Sx+YBJmkN3hvZxIvI13jTzP/ljt0ubN2o7WF+3QTyM/9VbFrb6mPnToED/1Uz/FT/3UTzX0mJlMhh/90R/lf//f/3dSqcamLG9VX4Wf6mlu/XBAbqTUvHN8fLwlVc3arTR9bKvzYx3H4fz588Tj8ZZWsVNKYZk5MlzjO5lrfHvlj/H8GIlgFwfUBD+WSXAkuWeD2xssOVFGo4+nVITMDDPuK/zm9Cu49xLsi57A01tbSN4OShUvvENVQShrhzvYtFOxaMcJArieHudhNsVYLMtoLEsy3OKmRW3SyrVK5SCUqAxCUQqBhUbh+QZe0JpRobFIruaFkaE0hvKbGhVsNkC/tnC4PN2txPasNQHjzcUDfH/sUvn/z6/sI7FhoYCNz40Hwgvl8LPcgSlvJYdiae7kx59YAzdo5Zl3kxuu4He1gU/l66Iel15GcTm7l0fOAM8NTDMUKlZCm4imuZLbg1KqJSM/AKlQgYnBRR7ZSdAaU21PM+td4RVMQ5NxwyRXiz8Y2udIdI7BUCNNmTv3OWooitXjVj8SS9PjAoohabPPdFNpBiIOAxGH/aklbN9kxY4yl4+zYkdxfGtN4YTEauGEVKRAPLR+81bT8PFZYNpbYHrpAl9c+mM8P0RMDbE3spdnk8d498hJxiNDTe97P4WGnTLy4/t+y14z13X50R/9UX7yJ3+Sj3/84y25z0b0VfgB+maa22ZKDS230ryz01pRMnpxcZELFy5w7Nixcr36VlFVH3pKQcjK43CHG9zhf735Tdz/P3t/HiRZtt91gp9z7u67x5p7VtaSte+V+dDTkwQtCYEYnrUAmxb9B4aBbBizgTbAGOtpY8ymZ8bgr4HG2sYAsxY909NiB6GmBQi0og29p9fSq1xqycqq3DMjM1bf/S7nnPnjuke4R7hHuHvs8fJrVu9Vebhfv/f6vfec7/l9f99v4lOQp3kt/yr/2dxHvJI/17eF5TBLyWsNtHh2rAaL8XfIeXBZOqxGAWuRT2yOVrPkICLUTmyaB0yE6pFPPfK5W5nGt2KmgwbTmQYlr7Wnoap7if0KaN1MhFY7RCjUNjgCpcXkVSFjOF2s9r/U+X8hoOiHnf6C8aAR/OrCZf7g/K2Rf68H9TKOt7XaFKn+oWohLPb8e4HH7SIXs2tDt2t26EOZt2t0jcXberz7MV3Bnux3P+uvItDYov+YbaFxRELM4H1JzR+GD9/dqttynOPXV17hvL/Ka7knZK2YvGxTN51K+R4tvr9eXODRk9fIONGBGx504YoEl5i68sg5IT4Rl7PPdjRX2YzDoW4pNsvjmrFDbGTHSnz7z24ErKbPiUQLmrHLaitgqZlFGYtG5NGIPJ7UilhSUXBTeVzea68T52GwrZiYRe7Hi9xfvdYJZXXJijLnvPO8U7jE16bepuSMFoB5UsjPSTmOUYjNXtlcG2P483/+z/P666/zV//qX9319ibBiSI/XQvrk1JOHQSlFLdu3aLZbO46vPOgMWlQK6Q3y/3793ny5Anvv/8+mcz4k7GdIEeYwDh2mxZ3+P3GHX7/zi8QJx45eYrL2cvYMstiO8dKmGHGbzDn1yi4g/XnXWefc9kqzcRhNQxYiwMibXE4wpHB6CVCOTeildjEyqIdO3suvdoObeXwqF7iUT3NEpoKmkwHDaaCxpEKQz2IXiXH0sxlG8xlG0Q9FaFQ2/iO7tg0j14VKrktPGdz1WTDZS7jRhORnzu1GRaTHF/UZ7mcX9zx/YkS3A+n+uRuXWyWQRokd+tTnM2s8XH1LEV78ILDBra/p3yZMGPVeByXMEYcGLn2pOKsvzpwgl60WyzG9sCFvMhY2y5E9PetCB60p3jcLvJSdpGz/hq3W/6eyd4ATgU1Sm6TahwciuEBpM+qFzJLfNGYY9aqcX5Emdtm7EfPzyRwpKbopeOHNtBMXEJlISQjPfNsadLeHy/kQnGNtrKphh5LjRyN2ENpi9V2htV2apzg2x2JnN9vnLDtd1gRIU+50Vziifpt/v0qJNonENOc8c7xRu4yXyu/SWEAITpJpOEkVH601tj29pSgXq/vCfn5rd/6Lf7n//l/5u233+a9994D4G/+zb/Jj//4j+9626PiRJEfSAnQSSU/xhh+93d/l/n5eV577bVjV92atPITxzE3btzA8zyuXr26bw/MrhRkHDh2SMg9rrfuAfBCzk5D69oez5oZXEszH9SYCzaa+TcjY8dk7JizpERoJQyoxp1V/SMyEEOnR0gaHCshcBK0EUSJRRjbB2afDWmW0LNmnmfNPAJDyW92QkUbWxp8Dxq77fkZF24fEbLWzRJCZePaGmPYtipkDJzJV4dsPUVqeT1edUOiaUoPDNysnhmJ/AySuwEkGtqJvYXDXa+cpap9DGJ9tXw3uOgu82nz9ETEZzcT5pcyy6zFW3sWLWHwZExk+he4tIHIbD90D+q3UljcapziXmuaOLQoZ+t7WqN5vbjAf1p86dDID8CU3eAPFO+QtwcvOh1XSAE5JyLXKQS2E5umSuWv9gjyOCE2qkrznapQPfJYbQcsNbIYJO3EoZ04PGvkEUKT7xoneG38LYsj/TBGEioL31Y4VpuER9yPH3F/9Vv8uxVIVEBGTnPGO8+b+Ve4UnoTR8sTQ36+V46j0WiQy41W2dsO3/jGNw59nn7iyM9JxcLCAs1mk/fff5+Zmb1tPDwoTFL5qVar3Lhxg0uXLq1bI+4XpJC7jtX0naQzUKSJ4WGSarBvNuexO0RoJmgOXaXuEiGo0kpsVsIMlSNKhCxhCNyEwE1QWhArSZg4JEpyUPtqEKy2s6y2s9xenSHnhExnGswcUp/QbrNtdgPXUsxl68xRJ1JWKo2LPSJsbEsMrArlrJh8sP1EUQgInIjWGK5v89kGjq0hgkocEGvZIVGDcb9exvG33n0SzWozx3IzSzHX37exFOVQDc2UH+Hs4OAF7BiCecqp0lITVtJ3MY6f8VepxYO/t2C1WYqdvh0Pzc7Pgu2uw1A7WJbiRWeZhtg7g5yL2RV+b/kC8hCFY4GMRqpYbAdjxFF61A6EbyfrCz2JFjQSl1hbWCO4x0G6iFXy25T8Ni8UV2klNmstn5V2lmbsYozcME4gNU7Ie20KXmqpvbnypIwgVA7+AIOUrnw85iH34ofcW/lP/JvllBA5usClr67zVv4yV8pvkrV3b1x00NhrB9vDwigVrHq9vifk5yjgOfk54lBK8fnnnxOGIeVyeU9KjoeFcSo/xhgePnzIw4cPeffddw/kuCVi1+RnMzxb4dkNunQ1TCxur02jtaToNTmdrQ+dkAV2wlm7ytkOEVqNMqxFR48IAR1NusJ3FNpArCyiuOvadoB9QrFPveJzrzKN1+kTmsk0KHqtXU+KRoHSR+N3cS3FfLbOfC8RijwikVaEXNKq0LxbG7yBTZP5vDc6+clYEdOdvCBByjg+XjvHR1P3B74/UpKH0RSB21/1kWhcqXjWKKT5KGj6rnshwFhIoYdaXK+/lZ1rV1kZMWtXeZqUdjzGvYQnFRlnMFHvVn/CTvWna22tNWy3SLtTJUpJi8Uwzx8+8xmJkYTGRu/yPrWl4dXiwg7yw/2FIw1LUZYZtzHxNo6K7G1U2NJQ7MirjYFG4tBOLIyQOJbaMVRbCMg4CZZocKZQ7/QKOVRDn5VmlrZyiJTNcjPH8hDjBG1SgxxG5NJdQoTd4k78lDsrv83/sgxKZcjJGc76F3grf5mrpTcJ7KPrYAvfW/K9RqOxLy0Hh4Hn5OcIo9FocO3aNc6ePcvrr7/OtWvXJu6ZOQoYtfKTJAmffPIJUkquXr16YKsqOw0Se4GUDG24wS208jRjB4vU/rTgtgdOalLJQpUzmSptZbMSBlQiv9OcfbQGaym6x6kwBmIliRKbMDlIIgShcnhcL/G4XsLq9AnNBA2mgubYTdCj4qAswsfBOhHK1gkTi7Uw7RFKtGAqN9okcVQ5oURzttc8oXNpftmYHUh+tE7DTINNcjcL1XG7AoSh4LeIlcTZZAXcSlxm3ac7m4aI7v9sPzF/J/uIX6yUtt/WAOx2ur+dTKtgtVjsVH9C7bAW+TxslnmjsDCUAI1SgbwflXlNLeBaCouIGIvI2Lua/L9SWEQbsA7xkbRfpiPHAUJAzomxhCLrJOsBqW3loDq9bM6QkNW0h0x1eoUiCl7EuUK1k0vkUG0HLDczxNruN04QimlfIGSdrBMSOPFEC01SgLSbhNznq+g+Xy3/Jj+3BEplyVsznPMv8E7+NT4svYZvHS1CdNxaEAZhVPLzvPJzRHESLkKAx48fc/fuXd566611//PdGAYcBXRzfrZDrVbj+vXrXLx4kbNnzx7QnqWQQh54Pp9rK9yOVEAheRbmaMc2EkPOiSh5rS0THN9KOJOpcSZTI1QWK2FaEWop58hd/0KQVhrsiKxJJVfdPqGDc44DZSwWm3kW1/uEWql73B73CR2m7G0UeLZi3k6J0EotM7TqKDat3kthkOhOdUCnbmSWwpUKx1JpNo1UGGOtX8+wMRFtKpdr1TNknBiJwRKpJbJC4AcJvQTeFgm2MOv7ZkuNEhKtBA79v1VLOSMFku5Me1Jc8pegMsIb9xhlu4kxZuD9K0Uq56qqgLa2uV2fQwrDncY0L+WXB25vlKwaLS0+WT3NezMP0/sUhYMiNDYxkxmvBFbCo7A8cqbOpNhOwlh00vybyStQR/seHgXdRZj1gFQ2KouJFh3zBBttJFIabKmH3h9pLlFIyQs5X1gj1pJ67LHW9lltZlDGYqmtceyAsO6AMbgywbcSgo6MO+NMJkdMCVGDNg1uh/e4Hf4G/2JRoFWGvDXHOf8C7xZe44Pia3jW4bimHnbvyl5hVPKTz+cPaI/2FyeO/Bx3KKX49NNPUUpx9erVPveN405+ujk/w/Do0SPu3bvH22+/fSg3mDzAyfgwdJ3VIJVfLHbIkACyTpjaaPfspmcpTmdqnO4QodUwYC0KaB5RIpQenybjxigtiJRFO7YxB2iYkPYJpS5HaZ9QxHSmznTQIL/LPqGjTn66SJSgkNnoobGFwmiDEunzZrNdsRDw4an7nMtUsIUeOPH8am2alvQ2fc6sf/5Rq8R7weP1vxkDK3GG3smmIxKsHuIDHYKjbXJ2m80TUyEEylgjTHRNp6Kx/ftKVouS1WBNHay82JWKqvLJWYOvv7zVZjnO8En1VEfuZ6grn2rsDQj1hFEn8A/jMq8nT9bDbIUAXyS4JiVBCePflwq5Y3/VbtBWNv9p7RLvFR5S7uQX9cKVmuUow7TbHPDpnXESprJ6m4Owpem4kG5cN7GSoF2iOK38WVIPDFwVIjVZmbJaTPktTHGVUFk0Ypda5KZGHEISGYcocagmXUt1g9MhRJldEyKDtBu0uMMX4R2+WPyP/LNnAq2yFKw5LgQXeafwKu8XX8WVRytG4qhjpzlDs9l8Lnt7jr1HvV7n+vXrnD9/nrNnz265EI87+RlW+dmO8B0kpBBHbuSzLd0zIRIsRVnakZOSITui5DfXyZBnKU5l6pzKpH0eK1EqjWsk7pEkQrZlsAc4x+kJJly72BPqsUe94vX3CQUNiv74fUKGNHNnUGDoUUKtFVDObUwOX/Sf8SQsUetkx6Skpf/g60mAIwev6Ddjm6oOtpga9F52i+3+BY268npcAtPV4kFyqVaSTmAG8UpPRiOt8I9a+QF4J/uQX6++OuK7e79hd1BaMuzSFwKKdpu44/JmOq/daUzzduFxX3V4lKrP+nul5ObqGT6YfdD3uhSGQMQkJiE0zlj9QDkn4lmUZ94b0k+2CzwN8/zW6ou0tUe+GfJRcXAf2UFYzh9ljCv9cyxN2eo3FAkTi2bHSMGQPq83P9c2soVaTAetNH9KWbSUQyP2aCY2IEEIYuMQJw61AYQosBKyTrRLQlSnSZ3P2l/xWftX+ccLAqNzFOw5LvoXebfwOu8XL2PLvR1fjtrYup+o1+vrSqTjjhNHfo7jhWiM4dGjR9y/f3/bqsdxJz9SSuK4X9vf7Ws6d+4c586dO9TfT4qjP2Da0pDzN1aHl6MsrdgBnWY6FDs9Q66lOBXUORXUiZRcN0vYLRHaj59nq3NcapjQjmxidbDmDnvRJ6S0xBrBfeywYAwEPRUuRyS86C3SUD61qOu2tPWct7U9dEX/s7XTeAPCSXuhkSy1M8z4TSJt0Vh3VtN4Ug2c9CRaEHcIWTN2yVn9qfRzwaiN7aOT0Zf8Z2OTn72gulkrHCp9g1QaN++u8TQqrb8mhOCrxgwv55fWXxu3+vg4KfJG8mSg/NMWBouIBElonJH7gWrKZ569Iz/awM3aGa7Xz9DtG7zbnOH9woOB5Ldgt9CGiSbSx83wYBD24hjSvs3+ylortjuV2JRA2Fa/u9wGGVKUvTbaQKhsmolDPXYJVU+Pah8hIi1EGYMrFZ6VEFhpdSjrxBPZp1vSgKzRpMan7S/5tP0r/MMFgdF5ivYcL/gXea/4Bu8WXsaakBCdFMnbqGg0GgfejrBfOHHk57ih29wvhNix6nESyE9v5efJkyfcuXOnr6/pMGEdA/KzGZY05LyIdmyjZdozFCY2jlBMeU18R3WyhurMB3ViLTtmCQH1I1gRArAkPc5xIXFi0U5sovhgDRM29wkVvRYzmZ36hERn1fno3qfVpk8xu7HK+6K/iCM1BafN40hv04slWIsDym7/hOhOZWoo8dl8dX1Zm2Hau08l8Tt/HU58IO0Rk0KhO6GesZK49sYzpOBulT0N249RJ4TTVoOMaNM0/kjv3yvsJH0TAt4rPOTfL5X6JHwN5VGJfIpu+puOS360tLixeoaPZgdXUYQAB41NSNQxRdhpQaLgtKkmHoU9yNtpJg6/vfYSz6L+MSIyNg9aZV7IrGz5jG8pVqIMUxNK34479kt+GzhppX7je9LKbDtxSIzsVPQ3HOak2MgXmvZbHUtsm2bsUItdYr1JliYEkbGJEpta4kOYEgxXKjyZrMvlMnY8UXU9JURVGlS52b7NzfYv8/97IkHnKNqneD37Mn+g/C4vZEeb4Gu9c8bSScJzw4Pn2BN0M2xGbe4/7uSnu/9aaz777DPCMOTKlSs4ztHQ5Von4CHW2zNU1x6LdQdtBFkrouw3caRmPmgwHzSItVzvEWok7o5lnQnyaXcNKcBzFJ6jMH6qTQ9jm3bckVMcEAyCtTDDWpj2CWWdiJmgwXSmQd4Ne994ZOyuh0H2TBockXDJTwNIpTBkZERD+0NtoRfDXB/5aSU2FZVJM30Gon+CshZnqCZduZvGl2roZae04GGzyKXSCl+uzgJpRXCD/Gh8a3SzCjNiTqsU8Hb2Ed+qvzTytvcK20nfAMpOi3P+Cg9b5fXXhIC7zWneth8h5WSr/k9UkWbskHG2hsz2fo/XMUWIdjBFEAKeRQUK9s7httvhXmOKb1Uvkgxx87vdnBtIfgDi72Hp20E9gaSArBOT7blulEmtssOOw5wUBttKSYIlzHrPz0zQJNGCtrJpxi712CMZ0PsphCA2qQqgrvoJkS8T/M72sk40ISHSIKvUqfKba/e51vrXRMojI+Z5IXiZr5U/5I3ciwNJzknJ+BmVxDWbzWMdt9KLE0d+jgMLN8bw4MEDHj16xDvvvDMyk7YsizA8vsnVUkra7Tbf/va3OX36NK+//vqR+r2Og+xtGAY98oWATE92ylKUpR07WEJTdFvk3Zi5oMFc0OBurYQUUO+4AO1bt/Iu0Oscl/MjEi0JY4t25ByocxwIGrFHI/a4V51a7xOaDhoYjna/Qb3l9oWavuQ/wxEa1eETRbtFIxpe8agn/YYGn64OlrtpzZCoS8GDRomZoLEt8WknFrdq82SskBibgtukGmVQWqzLmaa85siyJiHMWKTgleDZWORnr8QvO0nfAN7JP+RBs9z3mhDwZWOGV/JLE636GyG5uXqWK3N3d3yv7JgiOB1TBDWErWXsiEhJXGv8VRNlBN9ZvciX7blt3/csylNLvIFW4QW7Pbbxguk2Ux1zHKYYyxKGvBuR73OYS+2yI2WjER2HufSfnIzJOTFzpAty7cSmkbjUI3do/2cvIaqprRWiYEJC1E5sCh64VkjCfW6H97m98CvEysZllnP+S3xUfJcPim9gSevEkJ9RnN7geeXnOXaBOI65efMmjuOMnWFz3Cs/lUqFxcVFPvzwQ0ql0mHvzhYcR9nbOLA7EjmACIdHjYBES3yZECvJfLZJyWujjaAeu9Rjl7ayMUfwvPQ6x2W9jnNcYtOO7J4m+oNBb5+Q0oIH1RLtpEHJb667aB0VJHrj3LgiSa2d2WiSLzptHod66OwpMRaxljhSbyt3A1htZfAGyAMX23nOZatD5piGauRxt5HGAouOS9upfJ3qcuoMl3Skb1P+eJKmcSaE83YVh5iYUavSezNh3kn6BlCwQy5llngcTfW93lQea5E/cYbVE52nEbtkhwSuboYlDBkRk3RI0GZTBEdqHoVlLmUG23EPQzX2+dXFyzQYRXYo+LI5y3uFh1v+ElgJq3Ew0BFuGMYxi3iO0WFLTdHrd5iLlEUzdoi0te4w51gax43IuxEmgFhLWsrpVIbcbRe5hlWIHKnWTRUydrQtIWomg8cOx0owPOFB/IQHS7/JP39mIc0Uc/Z5Tpk5XlWvH5rV9l5gVPJTr9efk5/nGB+VSoWbN29y6dIlTp8+Pfbnjyv50Vpz69YtKpUKMzMzYxOf76x8zlJY4cdOXdnXStFJJz+b4fdot0t2yGrbR2uBbyfknZCCG2IMKRFKXBraYVtNziFhwzkuJnDjdee4duyQqIPf30o7Q6WdAQyBE1P2m5T8FkW/PVHj7l4hjC0KwcZE8CX/GbZIJ8obuSCGjLWN9Al42s4z7Ta2lbsJAc3EHUh+QmWjDNhbbmXDcjvLo1apbzsYaGmX2UyNxWZ+XfqWs0e3JRc9/zsKLGF4M/uY7zYujvyZvcJO0jeAtwuPebxUolf6KQTca07zQrA09HPbQkhurJ7hayNUf3phCz00JFVKg9YMDWPdjK8aM/zmykvExsYSPUG32+BOc4Z38g8HVgEjPd79f1ys6nfG0T8O11K4Vv98pp2k5giJtjCiQ5rckGJnLIq0RStxqMcOzcRlJ+mzEILE2NQTm3rHVGGdEElFYEVknK7ttqE14nhhSwUssmQWWcrAx7f/PZgSs84F3sq9yTemPiTnHB952Kjkp9lsPic/RxVHSUbVhTGGe/fusbCwwHvvvTexT/pxJD+tVotr164xNzfHm2++ye3bt8fexo3ql/za6r/jHz76J5zxXuSbp36I7599e8/39XuN/PRCio2qEKRNxu3EQaLJdVbiABqxQy32qSUOyhy9x8cw57gwsonUwRomgKAVu7Ril8e1ElJoCl47JUNBa9v+iv1AM/TW7a1dEfOC3+MQ1jNZym+yvN2M1SjDs3oBzx/+LDKkvSeJ3nq+hRA8rJd5obDa94nHjQJLUb/Tpeip12S8GNHUKC1xiNeJ22gwY0uBXvWfHgr5GUX6lrUiXsws8VWzXxYmBDwKSxN/91OVpxZ5/X1sI6A3JDUyNlGnHyhjx/zGysv80Mz2z/1ES35n9RKfN06tv6aMhVYS10q2lTe2tMvjdolzwdqWv+Wt8Y7jxFR+DnGRZTfw7aTPTGaxmSFrRTQTl6TjolnyVEehAJGyaSY2jdijpUbrA10nRMqmrjxSdZ7BRhMmFs+aWcpeC2cMuWZaSVplRa/y69WP+bXKP0KpAlP2OV7Lvc4PTH3EjFfecTuHheeyt+fYc0RRxI0bNwiCgKtXryJHXQIbgONGfhYXF7l16xZvvPEG5XKZdrs9MOdnJwRWaolrWTFPk8/5Hx5+zt+/53MpuMyfOvsjvFO6tKv9/GT5Cf+X3/9HXJxZO9i58Z5ibwdt11a4HcmWMbAWeigtcaViNqhxSqTN7tXYox67nfyRozdx6HWOSxKBIQ1WDQ9BHqeNZK2dYa2dgTXwrJiS36IUpJUhex+zgZSGnL8xEXy5p+oD/ZO+ktMk7dgZfDO0tUPG39looFv9GXRZLIU5XqBLfgx361NU42DL+3o/qpFMZVssN7JMB42xWjPGcXvr4oy7hkBhRqh27uUvN4r0DeDVzAJfNWfY/DvF2p7Y5hmZVn++b/7OBB/umCKIBKeTD5QgmQ/q/OvHb/PNM9cHfmY1CvjV5VdZjbeulBtSdzBXqm17N243ZweSn4wdU4l9is72hH7j+47tANAHcahdP3sHg0j7h3qs+ZtxapudaAtLKspewpSfkqG2smnEDq3Epd1rq70jBJG2iLTNo3aJh60igZVQcNqU3fEXqqQAaVep8Qm/W/+Eb9f+JbHOUJBneCX7Kt+Y+ojzwfjqn/3Cc/LzHHuK1dVVPvnkE15++WXm5+d3vb3jQn601ty+fZtqtcqVK1dw3ZS8SCkn2v9BKc2W1eZ+dI2/fecaRmV5NfcG/8W5H+Wl3PgPlKzl0fDWqKgqmZMx9u0phIBsj3FCpOw0W4i0R2Q+aBAqi2rkUY892to+khXYNJ1c4dmKvBehtCBWMu0Viu0Dn/iEyuFpw+Fpo4DAkPPCdYlczg33tO+62gwo51LJm7ep6gP9oYi2NEz7TVaTYYOcINFgj3C60gnKVulSrC1aiU1gxdyqzdBW3uANbFrBDpwY14ope6P3caR7PD5BcYTm1eApn7XOjPnJ3SMZQfoWWAmvZp/yeaP/mSdEWslNm/3Hv4iemRzV0KfgjUYYBkEKCESMMgLLq3FDnOZnH77LT5z9uO9auFE5zb+9+waFfNiRUA7aX0GkbSwzXAb3JCzRVM5AyWZbOxQZ7VhOiuztZBzF4ONIZWobv3M7sVMypGwcqck7IbNBaz1jqNXJGNqJDPUujgghaGuHdujwLMxji4SCHVJyWxQmeDanY0+TNre53rzN9ea/IVIeWXGKS5lX+AOlD3k198KhjZtKqZEW5pMkWZ/PHXecOPJzFCZdxhju3LnD4uIiH3zwAUGwdUVzEhwH8tNut7l+/TrlcpkPP/yw7/ewLGtXlZ9hEFaDW63f5f9x63eRpsDb+Xf40+d/hNPB9Ejbz9geRh2uQ85uMb6oZ3LYlu6Tk1QjlyixcaTifG4Ng6AaedRij5ZyjsQ9CWyZSFvSrFeF8n6IMiKVyCU24QFnChkEtdCnFvrcr6Sa8pLfouQ3KQetLdr4sbZtwOvp73o5eLolGHJzs/qcX2O1PnyFLzEW9rZZRp0umyE/vRBwv1ZGd5qUh2+lfwNCwFS2QcYeVzI4os/1JrwePNmR/Iju5vcQOSsk0gJ3h2rgy5lnfNGY2+KKZUtDpOREk2AhJNfXzvL9819O8Ol+pKYIEd9f+pJffvYq/+LR+/yps79PbCx+bfEVPqmcwfZhcaWAlAlzU42h/UHbyeAMgq+as7yVf7zlc9kdZJz933FEnlW7xERVv2OKzVK5SFnUIo9YWVhCU/aaTPnjk6FeJMZmJbZZibOIhiJvRxSdNmWvNZG9NqSOcjH3uNW+x62FXyJWDp6Y47z3Ih+V3uO9wmsTh6+Oi5PiWjcOThz5OWxEUcT169fJ5XJcuXJlVzK3zZiUPBwUlpeX+eyzz3jttdeYnt5KPDZXftoqxLeGrPj2IBjRRUUIMKLKtcZv8t1PfxOXKT4qfsCfPv/DFN3hEzlbSnRy3Es+hzfa9QbfJVqmVSEDs14dz1LUkpQINUfIEtpPbCeDFyJNs7dleizGT48lUhZhbBEfcL9Qoi2WmjmWmjnAkHEiyh2JXMFrjzW5qbU8CpmUrHoi5qK31X1rc6/DjNfg8/pw6dtOK+S9wefGCMSAk78SZfoqioMwSL5TGvP4B+3TqDjvrjIKcZokW2c7uFLxKCox59S2ENVeeFLxem6Bm/WtOXGO1MRaTnSulk2WtXZAyR+vwjYMZa/FT5z9mGvL5/gn9z9ACYu6CvDshFhLMrmQejXg0VOHYqFFPjN4dX07GdyXzZmB5CdnxyMHrp6Unp9B99txxCTH4VqK6WDDCTLRklrk0VY2FprSEDJUH1Z93gSDRTUJqCYBD5olMlZE0Q0pe028XSxSOVaM5hH34kfcW/wN/ulTC8tMc9q9xPvFd/ha+Z2BKpi9wCiyN9N5gB6Zxcxd4kSSHyHE+g91kFhZWeHTTz/l8uXLzM7O7vn2LcsiSUYP9TsoGGP48ssvWVlZ4cMPP8T3B1uUbr5p/t+3/y4r8S3O+O/yR0/9OC/lLgz83E6Vn0GQAhJW+J3qL/Hb13+ZjJzj+6eu8CfP/BAZp3//bKtLfk7GTX2YsGS/cUI7sdFakLdDTvk1WtqhFns0ku1tS/cF4/SI9FppuzHaQKIsQmURxjZqTBep3UHQjD2ascejjnFC0WtRClqU/WZf4vqwz3fxyoCqD/TL3iCdfJecFmsD+jAgnYSO6uJlYGDeihCCWAkca7xn9aBMl50gxGQExZcJL3hL3A33/nm+ExwSlpMcM3ZtWwLzYrDI5/VTJJuqP13zDz2J/E0Ibqyd4Rundl/96cKShvdnH/BqvMB3Fi9Siz2ETHOALGEwuTb1mk+lmqXR8JiZqg9xExwsg2son4WwwCmvuuUTLeWORH6e9/wcLezFiGxLTbmHxCstqMceTeWkZMhtrZOhtrIJVZozFI6y4CUETe3RbHs8aefxROqUWnJbfX1Kk+23Ap6xoJ7x71a+xc8vSTAl5pwLvJ1/i6+XPyDnTGaetRmj9vycJJxI8nPQGHXyv1scFqnbDlEUce3aNQqFAh999NFYlS5b+PjOGivqP/IPH/1H2nGZ88H7/PipP8rF7Ln1901CfnohpaHNU3555ef5D0v/lqJ1hj80831888zXcaSNLSXmuFd+jtZlsQ7PVutZN9qAUYJAJBT9FgaoJwGNxBkalHhUIMWGCUTaL5S6yB1Gv5A2ktV2ltV2ljukxgnlIJXIlfx+GUYzdMgHqezHFxEXBlR9YHAg6axbH0p+BJAYiTskynTzu4dFjMbaxtnGWnsQAmv8BSCxC2HoW5nHh0J+SnaLp0mBFZVl2hpu8OBIzZv5R3xc27p4ZEmDmlD+tkyWlVaGqWC8PKWdkHFifvDMbd5sPeHbyxdZSIpY0pD1U7vhajUgUTYLi0XyuRbFXHvgsacyOIFrqXVy+GVjdiD5ycjRCPNJ6fk5TEv9vYTch4HNkoai16bY6WnThpQMJQ42GtduU153k7NoKWdEMiQIjUMYOSxFOSwS8nZEyW1T9Fq7liJaUgMrLOsVfq3yXX5l7R+iVZ4p+zyv517nG9MfMe2WJtq2UgrH2b6qlCQJtn1yKMPJOZJDQhiGXLt2jVKpNPbkf1wctXJj19Bh0kqXLYK+SbvvrLKY/Ar/3we/QphM80LwAT9++sdx5d5dppbU1M1D/tfFf87PPf1ZZpyL/OjM11HJfjxmn6MXUkC2ZzUsVhJPx7hOhGspmmqfLbT38AfudZHL+2GaLaQs2lHXDKL/OeBbISWrxUJU2rud6CBUDgt1h4V6apyQ99rrErk4tsh4KbkYVvWBwVWRGa/OF405hq2/JkYwbFli87cYIwbqDo3ZvoK0+Zst1JgW17vHBXczYeweh1j/r/14drgyXTSIjMOqylC2mkMJ0MVgmU/rp4nM1gnMpPI3IQQ3Kmf4wWD8eIJRMB00+KPnPuFedYrvrF6gJgIyfoxjK9YqGZSyqNUzNJoeM+U6nrtVUmSQhEqsy+AetMuE2sKT/e/NOxH1xCO3Q/XnpMjeTgz52UcHzPXvEFBw01w7SKvUjdilqRykMeSdcCIypLBZS2zWkgyiqclaG31C49hoD99vg7SrVLnJt+o3+Z3avyBRWUr2Wf76K391rG2NUvlpNBoTx7QcRZxI8nNQFZKlpSU+//zzoT0uJxXGGO7evcuzZ892ZejgSH/gkrMQ4DvLLCS/yE/f/0XayRRCgRICuYednJZUrKqv+GdPv+LiWYtW7CAxB56/8r2KVFYWstwIyLgKRyvmvAhHpn1C9cQl1ntoob1P85r1bKFOv1DJtNN+oSS9pqLE4o+fu871xfMs7E4JsSMMgmoYUA0DHlaKXDl3H4BARpz3VoZ+btCKt28l5O02tWTw/T2ujGyw9G37CtLmp3jRbU3UNjaJ1XUXOSti3lnjaVxaf00KcyBVAo+YCJe2calqTXFI874tDF8v3+Y3Vl5BbRrWdyN/WyXDUjPLTKYx8THshIuFFc7nV/h05TTX6mfBdpiZqlNr+DSbLlpbPFsukg3alArNAUS5VwaXhp6+lnu65XsaytmZ/Dyv/BwpHMZxCAE5NyK3yV67kbhYxpC3Q0puG0NKhtrKoZE4tLfJGTJI6sqnrvx+G22vNYF5y/D9duwGDW6RmARbjD69H4X81Ov1E2NzDSeU/Ow3ulbOlUqFjz76CM8brVHuJKCbW5TJZHZt6OCInUmTFJBxVrjkpOXplTBLLfbQQiD2kAj1yrMqoU+iJVkn6nOReY59gujvFYqUhYXhjF9DSnPkLbQ3o69fyIs5667wXvkhn6ycw7ZiEnUwmUhzQX1dAveKP7zqA8OJwaxbH0p+BAKl0yrYoL9u/u+U/Gzdh0RbuENWQje/PzvxRGF3fojvZB7xi5VS32v9Yr79+T1T6VvqmNjQPhaG3JDgzpLd4kr5Ll81Z3kWFvv+Nqn8TQjBzeoZfijzxYRHMBqkgDenn/BK6Rm/v3SBz1qzFHJtfC/uyOAsGi2fZttlulzHd5MtJLgrg/uiMTuQ/Phy52f5ZtfD44qTomM4KiRuq722RT32sBBk7ZCi21rPkNuJDO21jfYgRDrEtvaW/JykjB94Tn7GRrvd5tq1a0xPT/PRRx8di8nYXmFtbY2bN2/uOreom17uyfFKqFLAjN9gxm+gjWC5naGWeJj9IEIoQLDWDtAmlWvtxsnlOYZj8y/nWmrd2rkZuVgYzuXWYJcW2odxpzoi5odnP0v/Q8KM2wLXdFzkbNqRsy9hq8YYzpQqAAQy3LbqA8PlPjNena+awyWtkZYEcitxGTRlGWZ8sJ30zWz6L2+ECewg7KbyA3DJX4JK/xZFJ0tnP+Fukm9VtY8UmozcSgKlgIIV8mJ2iTmvxifV030W2I7UxEqOZFLRizUCnjXzzGVqEx3DOHAtxdfm7/BG+JhvL73APV1meqpOveHRaHoYI1laKRB4IeVSc4vjm0HyLCywGOaY9ep9fys6bRrKIbtNj9nzys/RgnXAEtdR4dsK397ohYuUpB77aARZK6LgtmBEMtRroy0bitwe2GhHOiRjDe7XHIRRyU82O/o2jzpOJPnZL0Ly7NkzvvjiC15//XWmpqb25Tt2ghACrfW+9hZthjGG+/fv8+TJE95///1d6T67dt2WZY1NfnohhWE2aDBLA6UFy2GGeuKjhRh7cN8OfsdJSxvJSttFADkn3BPN7nOk2M6ZKNOxQo512kvjyIQL2U6WUHw0LLS3w9dLX5F30pV6iUEmAjzTGTwVhd5+oQ4Z2gvzhGmvuX7tvuI/3XEyNIwYZO2IwAppDbGBTfd11HshpSBbXhVp6OnmPo30Exv7lbGiiZuGd3t5lKwWJavBmuod/AWW0CRmf9fZPZFK37rfuaYyWDQGEsGsDKlrj5wd8VH5Hl/WZ1mO8+knOxXWceVvafXn9IGQny7yXsgPn/2cv3PzD4ER2JaiVGhQbwYkiUUr9Gg9dZgqNsgE8abfV/BZ/RSz3tZepXrib09+nvf8HCkcl+NwLc2U1WuvLahFKRnKWBF5JzXt6JKhZuLQGkCG9GYbbTui6Ixvox3q8QKKR5W9PSc/32PQWnPr1i0ajQZXrlw51ITbbtDpQZGfOI65ceMGnudx9erVXX9vN+vHsix8a2+a5yxpmAsazNEg0YLldpaGcjFS7BkRFgIynclkbCxqrXQFNueE2GNa9e4HDn8PdoERfqJeWVw9SQPsMk5E2WtTaXskSFrKpaVslDkatuVn3RXeKm7kjghhcJ2EqGfA29wvZII2iRapi1ziTBS2agycLaRliswIVR/Yvioy69a53xpGfgRKGSxrS+rkkH0bnPmjtIQBoamLjRy+l953BWe8AR3oVJTS76sqv2+CMi7eyT7k16uv9r1mEPtuK1yyNqRvKQQrKsuMqOFsWhkXAvJWm4rKIAW8kn/GfFzl09ppDHJi+VtNBCw0CpzKbnVS208IAcIyaCShltiOwrI0USjTBalKnnozYrrc6HsOf9Wc4Wvlr3A3VSW9ARWzXpyEyo8y4JwM9d6RrfzsBFuafnttI1gKM+uLXqUeA4WhZEgImsqjqfpttMtuq68faRAiM14cwHPZ23NsQbPZ5Pr168zNzfHqq68eusytS352siXcC1SrVW7cuMGlS5c4ffr0nmyzN6jVE/5AGcxuYEvDfCaVOyRastTO0FQeRu5dRVCKjYpEqB0qkY0tFDk3HNL/8BzbYdzFvW5/ljGwGgZESnQaVDtVIiVpJC5tZdNObIyQk33RLtAnd+tAYAiyEWHoDZVppv1CBscKyXoxxqTHEykbG0U99Ij09vd+zg4pZFKi8ErwdKRqybbkx6txvzXY0EUACRbWiNWfodK3If1DvZPRSSyuK80A10ogB89UgdO6MrDCNApe8p9tIT8gkHJ/5W+bpW+Qnq9uBpC96brOiIg6Xsc+XlBwQq6U7/JFfY7VODex/O2rcPrAyU/vZSkECDv11gtcjdagYkmS2DxbzjJVbuHZqmOiYfFVc2vvT8lp01IOwZDqz0no+TkJBK6L7foUjxVMfxUb0nnE6GRos422WjdeGGSjHenn5GcnPCc/22BhYYEvv/ySN998k1KpdNi7A2yQn/2EMYaHDx/y8OFD3n333T0tdXYrPwCOZRNra72/Y69hS82pTB2oE2u5XhFiD4mQJc16Sn1LuYShjSMVOSfcU/ndScakY3VajYvJOGlwXS10kCJ16yt1MhxMJ7iuGTu0EofEyANZwPh66ct1uVsXEoO0DCa0EMFwsjDt1Ym1oBpnEQJcW+PaEa8UFhEiXUVMB8k0nbwZudQjj1rooYzFmfxG1eecu3PVB9LzNIz/5O0QT0aEenDFe9Bka/iUZXDmTyoJsQmG9PRManFtjKAW+p19EjxKyrzoLo29HYBpq0FGtGmazVWwA3B965O+pdBIVpIcM3a9Tx7Urf70SvSkgFfzT1mLanxWn8eSYmz521JcYDnKMO3ube7PpJASpKdxPI0xUG0ESAy+F5PxIj6vzw80Pqgl3nDycwKIw+bA4uMMa0A/4XFEouWOi7ybydBSO0MlGmw2o7BYSzJDbbTHJT/GmB1VPc1m87ns7ahjt5MbpRSff/45YRhy9erVA6myjIr9Jj9JkvDJJ58gpeTq1at7nvrbW/lxpLWv5KcXjtSc6mjWIyVZDrM095gI2dJgd4hQI/GIlIUnU5eY50RoOPZicc+ShnxHFhcmFmFi49kxnq0J7ITAToAWSot0VS1xCJXV1xC+VzjnLfNW8cmW17uXmW3MNnUSzZlMhWdhjuoQhY4lzPoxlb02dMYjY6AeurhuSiAuBwsj98hs1+sgBMy4dR61B/c5GtKJ9KjfNSzzR5vhN0nBHRx0OQryuQ35yaLKcVpXCHaQPw2CFPB29hHfqr+45W+7MVMYBVulbykSrE4Iar3v/AQipo4i6bu+BSW3xZXyPT6vzbMU5sbe60/rp/nG1JcTH8c4UFqM/JsLAZadXlOhcmjXHVZqWUQI35j/gqkeCZLc9u47/sThJBA4SN1dT4p8L9nm2TYMesRxcbON9mnPoan2/sTV6/UTFelyIsnPbtBoNLh+/TqnT5/m9ddfP3SZ22bsJ/mp1Wpcv36dixcvcvbs2X35jr7Kj5DEeu8nnzvBtTSnO0QoVBbLYZaWcvaUCHWtjiG159ZGkHfaBM7eWmc3Ww6Plqc5M7s5iPEYYY+lDb2yuEbkoI0g40SdYFJD3o3IdzTToUqzeFrKJlL2rjWYroj54ZnPB/6t2xbv+TGtIY/ei9lVZKcPSKLXZTipQ+L23y0EtGMH30vIyjZn3dWh720kLsEYBgKz3nDyAwKlDbKv72e7DYuBxyMExErgWP1VDEiNFyaB1mLTMQoeJiVecRcn2t4rwbNDIT+uVEMlwpGxt4SgCgEFq8WK2ipTsYThjcITVqIs19dOYY2xMrMS53gW5pjb5KS2H5hkwthFV+n6WeMUn355CtsoTvtV3i4/5PXSk6HSt5NAHE4CgYPUNMA7+OnBviDtaRwPk1TwhBAsRAn/1bd+iRl5nQ+mT/Pj5y7z0cyZXc9tGo0GFy9e3NU2jhKek58ePHnyhDt37vDmm29SLBZ3/sAhYL/Iz6NHj7h37x5vv/02+Xx+z7ffRR/5kRbxBA+FvYRnKc5kUh17qCyW21laem+JkG1ppEiT2utNH4Gm6LX3xDHOaEEUCOQxHiQ2a6H3bLuCdUmi0oJq6GALQ+BsuEN5lsKzFCXSykkrSfXW7cSeSCL39dKX5JzBkgPRWXH2MzGNuoO0+0mfJyOKbrvzXsi7bSrR6KYgsZLkgvS7L+/Q69NQHgthkZeyKQnQRmzLV0pOC1skJGbwkGGQGKPXz9dOdHaY8UGsbZyeSWlqJmBGymgZBGW2OsytqCwNXSErxydU83YVhxjFZjXA/k84XaFIhgzZbeNS0YaStVHh8GWCoxPigb+ZYMpt8v0zd7hZOU1NjX6dfVI7zZy3v7k/kEqF9gJCgBIWD6MyD5+W+XdP3iYjIy7nn3J19i6lnqrQSej5OYB89wNBWgk+GfESiZFjPyJ2s6Ci0NxprHCnscK/vH8TgWDWzfLNC6/xX735Byba5nOr62OAcScsSik+/fRTkiTh6tWr2PbRPS17TX66x66UOpBj75W92dIiVkdn1u5ZijOdht52YrMcZmlre8+IkBDgOelv11AeUWjhSEXBbU1slGAdQNbIvuMAFiotaSgMkcWt74boD7NLtKAZu6lETls7WlCf95Z5c4DcrYu+voxQwCbycym/0reyn3FiKp35+SinqNIMKOZa5Hao+kBKdq5Vzq6Tn52+oSt9WwhLA/+eGItTTpVq4pNsIQZbMXLmj2CsClX/tlIL7a23ruBBXOY1b2s/yE6whOHN7BOuNS+Mv0O7RNlu8CQuYg+5DJvaw0KT7wlBLcg2ywOqP13Y0vBu6RHPwjy36vOMcqVVVYbHrQJngv01P1C7qPxsCwlNXL5bO8/vV89vVIWmHtKIPRLXwrPUUXXP3xH7XYU8KJyEKlwXSkvGVVjvZe+WwfAsqvNLj7/cQn7MiBOIZrP53PDgJKFer3P9+nXOnTvHuXPnjpzMbTP2kvw0Gg2uXbt2oMfeu/+HJXsbBb6dcNZOG8dbPUQorbDs/jxJAX6HCFXiDHEiyTgROScaa9AV0mDU0b5mjxq2k8X1wpaGghdS8NLJZDuxaCYuYWITaatv5u6KiP9sk7vbZvSmwTiWpreWMe3V+3IcDClZskSCMvbAKkkvtAG3U+W6HCzseA0Z4PP6KcJOvs4ow9+sN5z8GASxtvihqS+oK58nYZ5qO7VpHYytFRlIT2mirXWHMwEUhlTSdkKavzPYirqiA2rK6yMKo+JVf2EL+TmIBQhPKhqJR9Edvs817WP1hKB6MsHVMZHZhpAKwZxfp+w2uVE5Q0P5O+7LZ/VTx5f89KCvKrRQRmvQicSzY07nq8xl6xTc9sT5UoeB474W1sWJIj9GjN1duh9WD561dco/anTKc7e3E4SDknrtJfaK/HQlfm+99RaFQmEP9mw0SCn7Kj/RESU/vQjshHMdItSMHVbCDG2zd0QoNUpQGNL+I6MFeae1To62gxBgkv1OGjmZ6JXFJVpQDV0socg4yUDykDrxpBIZbdJroaUcQmXz/eUvye3Ql9Jb+fEzEXXtkF4/qcnBgD2k6IashDs/pivNgFwmJG+1OOOu7fh+bQSJsfi0dpr3ig87JGF7lN0mFqpjobx5T2FNZagkASWnRd5u80pmkVri86BV5mblNC3l9MnmhknfUuM5nVbahBnqzLUdjIHIWNusngoeJGXesBbG3vYZt4IgvV8PGgWrTajtbey60xBUSWNdKliQbZbUztU4R2reLz3gSbvIl41Ztnu21XUawng+szb+QYyI+ADIz2ZICdLVKCwe1Mvcr0whMZSCBucLa0wFraNvv3xCSMNJcq1TRo4cB7CBvT9+ESesrKxQLBbXzay01iMpfur1+nPyc9SxUwWj62gGHHmZ22ZYlkUcjz8Z6EJrzWeffUYYhly5cuXAnew2u70lx4D89CKVRVUIlUVdeVRDn8hYWJZG7kHlzLU0WBAal2rTwhKagtvqawLvhRAGsw/OLt9r6FZ5IK3wRMrGt+P09xgAKSDnxuSIydHkjcLOk2jZY9XsuApd8ZCeWTc56Ef6gm8nEMJO67ndecIoVZ90a+mbrlfOjUx+LGGYchssRoMXS2Jl8TgsUXJSgihEGkz6pvOEN/JPaGubuvJ4FuZYCEs8beYJtbNlfxNtcSazREu5rDb9LUGeo6Bb9TFm+BSipgPWVNDXJzMKHKG57D/l8/aZsfdrt5h3q3yreolL2e0szAWrKsu0qOMKhSsVvo5omxHCuYXgdFBl2q1zvXKWlh5WuYPP6/OcC9b2TR52EJWf7bCRKwRrcZbVxXRhKuOEnC+scipXxzmCVsxHnJqNjJNi3ABpz+m42M3vOEwpkHF8lpaW+PLLL7Ftm6mpKTKZzEiqn+eyt2OOg3A0209YlkW7PX7SOaQX77Vr1w7VyW6z4cFxqPwMgi01rlHMZ7uBqoJKGNBWaY9Qn4RqmwyVYRA9sriG8glDG1cmW/uDOpWf4z3iHa2d72YtGAP1yMEYQdYd3Hcijeaj0t2Rtis3HadMBF4Qrpsc9CO9aIQwuDLetvm73nbIB2nV57QzqIK0FV1Jyb3WFJXYH/kXmPXqQ8mPRrAY54h6ZGtdCJGGlAZWwqzb4OXsEo2ix1oSsBpnWQ0DFtsbZGixledsrkrRGd/iulv1Sf99sOytiwdxeWzyA/B6sNBHfg6qz8KVCk8k1BKPvD1c/mYQrCRZZuw6ttDkrTbtpFtpHOF7LM0H5Qc8bBa515od+J6m8bnfLHMxu31/2aSYxCFrPyFkKjNuG5dba/N8vnwKRyhmszUulZYJRqjUP8c4ODnkZyLzhn2ofDWUonjuLJcvXyYMQ1ZWVnj8+DGVSoUbN24wNTVFuVwmCLbmCzUajWOjkBoF3zPkpze485133jm2DHZS2dvTp0+5ffv2oQe29lau7CPc87MTJIbESKzOA82WhulgI/yvGnrUE7fjHjQB++n9LsG6RXYlzpAoSWB3+4OeV372C6JT3YGU3NYjB1umuUHdCfnL3sKOcrcurE0VDNdJtpgcDNgLCm7IWuiRelGZTi+QxhYaW2os4dHWDq+OWPWB3sm64Hr1LPPZ2kifm3YbG5K0AduMteRJWORisH24qicVnmwy5TSJvDUagUddeTS0Sz3xWQt9QGNPIDHqVn3SfdoeTeOxojJMWeMFd55zV9ntfT0pTnsVbrVOcTn7dNvfWyNZ7hAgR2gCEdMapfrTgRBwPlthzq/z8doZoi3hrnCrOc/5zKDK5e6RmKM7NnSrQgrJQrvI48dFpIaC2+LS1BLTwWQLlM9xMqEmIDL7sST46coSf/U3/gP/8Md+As/zOH36NJlMhidPnnDu3DlWVla4desWYRhy48YNXNflj/yRP8LMzMyeuL39uT/35/j5n/955ubmuHHjxh4d1WQ4keRnSxBcknDjxg1s296X4M6DxLjkR2vNrVu3aDabXLlyBdcdffDbD2yxuj5Cbm/jIG3Mln1N6r3ob5S306qQtkCKXVXcbGmwZac/qJ1Nc0yOvR3o0V/hs3vc4tqJTaQkp5w1Luefjb6NTeQnyEZDdeC9l4hvJ3yYWxo40VVG0NY2BavJqRGrPtDfTHy9eo657Kcjfc6WmrLTZCXeungkgFjZPI5KXPB3InUbcKXClU3KTpNYSxrao+F5NJVDVoa0EpeW2LkJH/qrPim6iw/D8TAuU5bNsSpMvky46C1xLxxcFdlPzLtVrjfOshTlmN0hb0f1hKDmrTatMao/XXiW4srUAx40S9xrTvc9v1ra415zagcZ3mTYTc7PQUNKQEJVB3x38TxGCXwr5kyuwgullQMNuT76T9PRcOxdTHtw0BK+7b6t5PY/S5VS2LZNLpcjl8tx4cIFtNaEYcjP/dzP8Xf/7t9dd4T7rd/6Lb7+9a9PPI/8s3/2z/IX/+Jf5M/8mT8z0ef3EieS/PSiUqlw8+ZNLl26xOnTpw97d3aNcchPq9Xi2rVrzM3N8eqrrx4JJ7t+tzfr2FZ+YPQcCt9O8O10ZV1pwVoY0EhctBDIXSyZuh2b5hcuLlGLfVqJQ9FtYQ/pDzqyOGa769sJgaX42ohyty4suUn2ZhmWqwXmy9uTFoOgpWwy9tasm5ZKJ7PjVH2gfzBejnI0Qo9iMJrz2axXH0h+IJ2whtphOc4x444fhOlIzZyskPdCMjLEEZr/6fH3UR5x33qrPpBOoHZqnG4ZlyWVY9Yeb3/fDB4fCvlxpWLGrvM0LFB2mtg79J3ExmZVZZmyGmRkRHObPp5hEAIuZNeY8+tcWztNqN318eSLxhwXMyt7Xv05TuSnF92qUITN3cY0t5bmsKVmLlfj8vRTfGef+4SOuiHDiDgC05U9wyTmDc3QIcFKq/tSj3c+hr3XQMnbSn42FwSklPzAD/wAP/ADPwDAs2fP+OY3v8k//af/lL/yV/4Kp0+f5kd/9Ef5kR/5Ed56662R55Y/+IM/yN27d8c4kP3DiSY/9+7d48mTJ7z77rsnJpyp1zBgOywuLnLr1i3eeOMNyuXyAezZaOh1ezsKIae7wSSadKsjj5smldlUQ49a7BEba2L3ONEji6srnzBM7YsLbutAVxwnxXEcql/xnpIdUe7WhS2SLQdbDz3mR/hsLfHJbJqcG5OSn6LV5JQ7nu3w5sG4FgYjk58Zr87ndQ0DpG8aidbwKCyNRX4cYhwTM+02txgcrMRZHFuRc7YPOt1a9en+Yefvf5SUmLbqY03gL7gb1Y6DvoZPexWWkgJPwiLng517bkLjUFEBeatNU7tMWh/wraRTBSrzoFVGG0EbjzuNGV7KLU20zWE4bMODvYIxghiLR/USD2slLAzloMmr0wsUg/GDdnfCCeIMJwaTyN4SbREqJ/W76cidbSslQuk/2z11BrhoGsDIkcjPZszOzuI4Dn/v7/09IJ1b/+Iv/iJ/42/8DW7evMm7777LX/7Lf5mPPvporGM8TJxI8mOM4bvf/S6u63L16tWRPMyPC3plY4Ogteb27dtUq9UjIXPbjL7KjzzulZ/d7/sWeVzk01bOxMGqaX9Qen7XogyxlmTtiOyY+UEHiSO6W0ORpzmW3K0LW+gtY5IZ8QkcG5tpWUULSWIkCRbNxEGgeTUY3655c4N+S4zu+uhKRdFuU0kyW/4mSC2KV5MMTeWQ2cam2iahYLXIyghHKH5j8RVOzX4xcF+ftQvknO2lVZurPtAheSMwk9A4LKo88/ZovU8AOSti3lnjaVwa+TN7hVT6plmNM0y79W3PcxdN42FpTVaGNPRoMsJBSKtAK8x4dT6pniLUDl80ZrmUXe6zc98tTgr56YUQadV1uZ3ltx6+hMCQdyJenFrkTGH0a2/b79iTrRw+TspxwGSVn/5nmUAbQZTInlcMVocMba4O2Y5iWE9iyeuv/I5Cfjbj4sWL/NRP/RQ/9VM/hdaajz/+mGKxONY2DhsnkvwIIbh8+TKZzNbB+bjDtu2h5KfdbnP9+nXK5TIffvjhkZC5bUZv5UcKgdLH9xJM9tiNJZXHpavlSgvWooBm4qKYTB5nWwbbUmgslts5jDEU3Daefdx7hA4PQis+Kt+d6LO21FuS69xMQrPtkPH7J6+bI0BNx7PsFf9p3/uqscdn4VkexFMIY2gkHrZUHYvjBFckuELhdP9dKlyRbK24jnl5zXr1geQH0r4fz9I8Dku8nFns+5tNQt5qk5Uhrui/Dis6w1I7y4zf6N+gAS0EiRbYQ1Y7jdkuF2a0g3sUl5ix6mPluLyVecTTSmnk79grdKVvS0mBR60SL2cXR1rcqOmAvGwhMLt0qBNk7JgPyw+415ziaVjkP668zNdLXw3tgxwXo8qKjzyGnOb09xLUEo+Pn53j4wXw7ZhzhVVenFreEro88tedGNnbyTgOmKwyvFPPk0GQKItEWevVIXR6uSklGHbhDar87LRIHkXR0FgUKSXvv//+9jt7BHF8Z547IJfLjSQPO24YVvlZXl7ms88+47XXXmN6evoQ9mw0bO1ZOlqVqXGwn1asljRM+xvyuFrkUY08YqxUUz4msXU7hKetXSqd/KBj2R90yLgcjC9360IOyatZruXJ+Ds3jN9pz/Jy0E8mfvbR+5wvVcjaEc/CPPGIpaR23L/Sp7RgpZEh64cjTV5nvDq3hwRhdvuJFqIil4IlXJFWeDIyxEUNnaQrLflu9SI/4n/S97oBLAELrTznsoPlfYmRHWfFfqQ9PzseDgAxNk+TAmfGMI645C0D0NY2lSSgaI9vmz0putK3lvZYjjLMeKM51tW0jyPUyNfKdhACXsguM+vV+bR2ml9ZeZ0Zp8Y7hQd4u8zAOSmVn+2ypvogoa0dbq/N8cXqHK5QzGVrvDrzDG8MG+2TEnm9ORrgOGPQs2knjL84IUiUpN0aMqfqnM5JZG974fR21HAyni7fQ9hMHowx3L59my+//JIPP/zwSBMf6K/8ADjSPrZ9PwfZkJt3Q87mqryQW+WUV8Ujwiiz7sIyKrr5QY5tqCc+T5t51to+J3CdYM+Rp8ErufHlbl0Mc3Zrq60raoN+1aoKSHrC8n7j6Ss0jM+DRonlKLeryWzOjjiTq1Cw2sRKUotd2ts4MQZWTNYa3CNkEAS0+Ch3h3POChecZcpWE08MJz6Qkh/fT2jEg1cYm8odSmS2rfqMcYs8SYpjVXRLVoui1cAguVY/T3iAlex5t0q3lPgsKhKN/BwVxMZat+nfPQRZO+KD0j1m3BrLSZ5fWX6D361cHGOftuLEVH4mgBCkfUKNEr989zL//ovX+PaDC6w2dzar2Evp4WHiJFV+Jiv9TPCREZ5dk5Cfer2+J/Ewf/pP/2m+7/u+j88//5xz587xD/7BP9j1NifFia38nFT0rvhHUcS1a9coFAp89NFHx6K3aTN5c6QkVtaRTMreCYcVwufZivkeeVwlDGgoB4UcSx4nJQQyAQSrURal0vTybrbNgeHoqTO3IJW73dvdNoYcp+XrdHV4x/Mg+Lx1mjezj1lpB9xon8UATeXRTOJdmVt0q1JCQN4OyXeEFI3EpaUdLJHmG/Vizqtxp7kxkGZliw8L93g5WCRvjR9OmmiJayu+s3aJH5q9tfGHziTAloaVMGDa76+uJEYMXVkd1y43weJJUuS8szbyZ97JPOQ3aq8SGoeP6+f5MH93LOncpOiVviXG4n5zihdH7rsRuEIRmdQOey8gBbyUW6RdsakmActxjl9efoNZt8o7+Ye4Yz7j4yOc83OQWO8TCrMsPXoRYSDvtrlUXuZMobrlPjsp5OekHIc2TGRdN4ksddvnXYcYTVr52Qvy84//8T/e9Tb2CieW/BzFfpe9xOrqKp988gmXL19mdvbg7VYnxebKj71ud33AE+49gN6HBOZxYUnDVNBkqvPftcilFvlExkoTyUe8DxxL41igsVlqec/7g/pguBwsTCx360KKwefSdhWVeoZSfmfZ0v1wmjcyj/kXj65g+5oktBDCUE88Cu5obm2wdVFx2EQja0dkSY+7qRyaykUKQ2BFzHh1FtqFDuF5RtFq7cpUo7uYYBxJosS6JLN3z1ai7BbyE+1gPDIuAVpIipyyq1tc54bhRX+R36i9CkBVZfikcZa3cw/H+9IJ0ZW+ATSUz63aDJfziyO51rWNw5RVZ1VlJ5LlDIYg0jZlr02kJO3E4WlY4Jej15l1a7ybfzjyQldrQEX0ex2i08pRS3yuLZ7l2rOz+FbM2cIaL5aXsS1zYuRim0OhjyuUlhMRuTCSSIuxFrVGq/yMb3jQbDZPXA/9iSU/JxXGGMIw5NatW3zwwQcEQXDYuzQWtpAfKY+t49thVX62Q96NyLvpZDVUFmthQKhstJAjP0R7+4NWGnYabOk296U/6P7CNI4bk/f23vJ1r1CgySu5xZ3fuAO2qwasNrMjkZ+mdvn5R++wnvnZ2WRb2RQYnfywaZAcZcKUsWIyVoxAkRMhRbfF17O398xFsCtzyrgx/9vaJb42/VXnLxv2D1IYWom9XoXaruoD3dXT8XZQI3kcl7jo7tyHBTBtNciINk2T/ihP4yK5VptLwd5aPw9C1/UNJEJAUwfcaczwYnZwKG4vDIKWcZmyGiyr3C4NEHq227m2XEvjdqSRkbJYDPP8h/brzPujkaBmMn4e0fccRNon9OXaLLdXZ3GEYi5T49XZZ2QOuoK/xxhmbnLcEGtroj6ssOWitEAAlqOxHYVt6+3H8UiCgkHF3O4i0KCQ04OSvR0lPCc/xwhRFHHjxg2MMVy5cuVYyNwAVsMmv7f4iB8+98qWSsRxDjqdxLv/IOFZivlMKo/TRrAW+jRiDzViuKoQ6YTdIFkKc2gtCOyY4h7mB9VDj1z26K7wyV24u23GdmGUiRi9X6NqB3TbNcw6MRC0Ewt/wkrdTiuTAk1BtihYLQIR74ttem+PR41gXQrYu2eiY3xwKZ9m2+xU9cEwkXb+qcpzSlfw5M7nUwp4K/uIb9dfWn/ty/YcWStkzt0b++Jh6JW+QXqNLUV5AivmTLCzcUNTu+TskLLVYEVl2QsN6qA0e9dSuB0jjZoK+KWl1yjYLa6W7g0lQTv+tscFBzRMCJHKNh83Szy6W0IaQ94NeXFqkbPF8XLAjgKGGcQcNyRmssqPsNMJuooFKrZRsU2IQQiDtIeQobYFNQdsA8V4S1e/Ly2cTUTnOfk5YThpsre1tTVu3rzJyy+/TLvdPlbHt9xu8H++8S9wrrl8rfwi3x9t3ETHOetHHyM3IikMU36LqY5kaLERkGATaQsjBXLI9SREaokrBUjLEBubp60CxkDODck74e4mwnqzqfNRQip3y9h7s4JqDZG9AThB0if12g6epWh2yU/P2+uxh2+P5vg1iuytS3jyVptARGMFgE4C1fMcKARtblTO8nbp0RbZWmIslAYjtq/6QOc4J2kcRvIoKfGiuzzS+1/2n/WRHxDcbJwlkHfI22NU5CZAr/QNwLMS7jan8a2YKXen60FQUz5lu0mRFhUVsNvZ+k5yYM9SHUdBi99YfYVG5JKVbd4tPWTa25A0nhS3t8OAEOn9UU18vvvsPL+/kBLl2WyVF6eWKXi7fG7vM4wxOCfEiTSZUPY2GAJjBCqWqNgmsRMyuY3xySiBQEAyoNZkBFlnqxPc96rb24klPycFxhju3bvHwsIC77//PplMhrt376KUwraPx88XdPzhYxnxm5VP+U0Df/cXPuVH598AI46t29tR6PmZFL6dkO+ZaDRih3rsEWobbSTSGhyQBqwnS7eVSz32kBiKbovASQa+fzsc5Z7WAk1e3gO5WxfbyXykZViuFpgv77xaL4RBkuY39UIZidajacQ3S5zkuhOdpiDbnQrP/hOeXmx293ocl3mbR2xOPbKkYaGVp+yPYCu9i3t0SeU5oyv4cufret6uYZuYpCcsVmHxceMCV/Nf4Y5QQZoUvdI3SImsIxWf1eZ5t/hox161lnHIGUlWRmgjqOndSanHCXT0bYXfsQf/bv0i1WUPreFSZplEHd/n61GDkKl73ONGmUe1MgLIuW3OFleZyTYpuO0Dvdd3QmIk7p65ER4uEi3Hdq5LF3wmMDzQ238mOyCrR2u9o4qo2Ww+r/w8x8EhjmNu3LiB53lcvXp1/QLtOqYdF/Jj991YAoShKav868XfQWvBK8fkODZjktTmowJr00Q868RknY0VpHZiU4s8DA6hsTGIgdXGri67lgSshBJHJpS8Fq41mmRBjNuNfkCQRvFR6e6ebnPzOd+MeugxP9KW0oDJemJhkBijO9lPaehpyRuh0tBz3gWa094aZ5wKGREdmstSsslau5xtcac+M7Bw00g8iiP0OO3mSAyCh0mZl92dCbAlDG9kn/Bx4wKwYe7U1i7XGuf5IHdv387rZulb97VEW1yvnOH90oMdspvS6s+U3SRvhSgkTT15v82kcuDATtZ7uVaTHFk/JhYt2omL1t2V7GO4UHbEhomuwrae+Hy2dBoWQUrNVKbBXLZByW9SdNvri1yHAa0lnBjyY4197488t9j8tl7yM2AT+QGVH9hZKVWv15mfH210Oi44nrPOEXCcZGGDUK1WuXHjBpcuXeL06dN9f9saFLp/eNxa5n+4+/P8qTM/xJvFF/Zoq2Jd4iIwHFdH00Ha9uMCKQTaMHS1z7cT/B5r40hJqpFPM3aJjI0aQIYcK119Xg2zJFriWTFlr7XtIHo0Zd2Gy/7eyd262E72BjBOTM+wKlKoHBjJ+MBwpfQVV8t3OeutHYg1804YVAG+1Tw1cCJgW4Za5K6bewyFEbuq/iyrLGf0Ghm587Xwqv+U7zYuAmaddQkBa0mWz5qneSP7eOL92AmbpW9CgGslhMrhRvUs75YeYG/zG7eNQ6QtXKkoyhbKSEIzmdvaXsiBAzshyNU5navTim3WooC1tk+kbLQRKC04lkToiKHrHmeQLDXyLNXzCMC2E0qZJlN+i7Lfoui1DjSO4jiPrZuRaDm24cGo79683W0rPwZy7mSLGntldX2UcGLJz3GFMYaHDx/y8OFD3n333YE6y4MkP4lJ+NbqZ3xr9TM86fBm/iI/ceYH+LB8eU+2bxA8a+aZ8+vMBI092eZBQevDnzBOCiFMmqsyYoXGtTQzQROCtIdAaUE18qnHLqG2Uch1MiRESoQ0FovtrlFCRNFtb5VkjZp+foDYa7lbFztZJ7uZhGbbIePH7HRWhABHJGDcLa83Y5vMQAmi4ZK/yGV/gVmntu1k+DCQDOj9K2baOPU0i2ozapG/I/nZ/REKHsRlXvV2Drc9464hUBgs1k26OzvwOCqTs9pc8EdzkBsXm6VvALbQxGhC7fBp9TRvFh5vI20S1LTPtGwgBJQ7DnCTBOfutRw4cBICp8bpbI1m7FAJfSpRlwilVYL0UfycDO0GXSIEkGibxWqBpWoBKTXSVhT9kLLXpOS3KHutdQOL/YDeQb51nJBoSV27GCFwpcKRaseqWu+Cj5AGjElfW/9Y+nezaQHSdIYYM2RgLQyp/OyEZrP5vOfnOfYPSZJw8+ZNLMvi6tWrQ5vQDpL8+HLjZgl1zO9VbvN7ldtYSN4oXOSbp77O16ff3FWlbS3K8JsLL+FbEeeyFc7m1ih7I+j5Dxlih+rJUYag21A82WqeJQ3lzqogpEFutchL+4aUQ4IE0WuU4PC05YIx5NyQnBMhBBw1N9P9kLt1YY3Q97Fcy5MZcYLsW4N7URqJ20N+DBfcJV7LLDDn1LCPZqkNgERtnbxKaTjjV3mqilv+ZklDpHYg8JM6HvRgTWeoa4+c3L6i5gjNq8FTPmud6bwi+kjQreYpMlbEjFPf1f4MwiDpmxCp+UFLOdSSgC/rs7ycWxza6B4am1BbeFIhBUxZDZaS3NghqPu5ap9xYjJOzGk2iNBa5BMrG9AoLdBGdFSdz8nQbtCVx2kkKpYshQ7LModlKYTU5L2Istei5Dcpe60+pcBucaIqP0YiECTGSqW9KnWyc6TClQpb6C33ZJqLqjFGpkO0SEmQEKli2XSGki1nqYc06lCmxMnqEiFBYVPGjxlRdv688vMc+4Zarcb169e5ePEiZ8+e3fa9B0l+5BALXoXmevUO16t3kAgyIoc0ef7iiz/ON0691PdeMeKDrK1cbldnuV2dJWuHnMutcTa7NlZ440FCinS1ej9XwPYLAkOibWBvBiwpoOiFFHv6TeqRSy32aCmHRFtYnUuppTxqsZ9my4xYeToYGF71n+y53K2L7ayuu2iPEezoSDUwwVMbSaKhHrr8ny782shhnYeBz5rzvBo8TW16h7g+XsivslTJb3H/EgJW2hlOZYeTCYPYg/JPWv153VvY8Z2vB096yM/G57uO2x/Xz3M1/yX5XQbmDsJm6RukBNHWmsRYLEYF/FbM+czakC2kZgeeTM+nJQzTdkqAxglBPaj8sy4ROmVqNJNORSj0SYydThDRaN2VyI2f97QX0Joj7ao2KoTo9OEISBKJMbASeqyKLNLSSEuTcVMyVPZblL0mGWfy5+hx7qfdjERbKQnpgTaSUMmOTNmsEyGns/AA6cKPUkBiYeJ0odLYXTKTmsD0Pv7Tqk9vz0/qDEdCOk4IKDhbyc8oC9fPyc8xwnHq+Xn06BH37t3j7bffJp/P7/j+gyQ/vedRonGtpDNB61lhwFA3NaDG3/jyp9FfWFzwLvB/fe1PcrEwPdH3NhKPz9fm+XxtjoLTXidC2V08UPcaKYGQx5L8IOhMCvYPOTci1yNLasUO1dijmTiADRIKZxpEymKpmUl15Ydob1oUTV7K7V8w5SiOX5av0aNyFSHI+iHxpse4ELDcytKMHOwJK3sHgaZy+Lh+gWqS4WrhDrEaTH4cSzPvVXncLm35m2EHh7s9upyqOqCifIpWe9v3nXdX6eYubYVAGYvfqb7Mq8ETzvmre1o1HiR9g7T3J0kkIHjQmiawYma8wRLjyNi0tb3ucGcLzZTdYDkZPQT1oPPPhNgwbDmd7RKhgErokQgb20onicak+6af9wtNhv55NZDef0pJkgSi0KVSz3JfaixL4btJKpPzWpT95nq1fxQcMUHArpBoibXtIp8g1jaxtgFDK3SIlYXaUgmXKZERCqy0EiR7xkuzndlB58SXvPEDTuG51fVz7DGUUnz66acopbh69erI7m0HSn567iLPSpgNGmgDrcShpVxaidM3KAoBlqV4lNzh/3j9/wXG5mX/BYxRCDGJs4GgGgd8shrwyeopyl6Tc9k1zmYre1pmnwTdvpnjCIEhOeAcjcCJCXrIa6is1EQhcYi0zWoYoIyFZ8Udt6GD2zdpFB8V7+7rd3QlC9tNAGxXUWlkYMS+1IIfstze+twwQmAJPXQafhTwreqLGCO41jjPe7l7295Lp/0KT9rFLRNwSxrWwoCpYLBMdg9Ub+t4EJcpWk+2fY8vE17wlrgbzg59j0HyWess98IZXgoWOeWu7QkJGiR9g7Qq60pFpNPr5FZ9Hk8+Iu8MrqhXlY8vN6pprlAjh6Aqs9VG/SDRT4SgEbvrPULKWEgMRhpAH0i/0BE1s9xzbDzTBFpbKGURRS61esADabBshWsnTPktSl6Tst8iv5299omq/MgxFqEEzdjlaaVH5rv5GuqcGssy+P7GHGgnm2uAojs5+RllYf444Tn5OSQ0Gg2uXbvGuXPnOHfu3FiVqgOVvfUMZN0Kh+wZYIxJpTrNxKGVOH3yiLSBMuHL6DanCmmloRm6NBMbxtSRd7bIaphlNcxyfeUMM36Dc7k1zmQqh1J9kcea/AyXGR0UPEsx22NykWhJNfRoJC5r7YBIW2SdmJwTjpRdMzlSuVuwT3K3vm/agfwArDUz5L3tKwxd2FIPXFiQIu0JMpsyco4K1uKAm42zzLg1NJJfXntz27Bjz1JMu3WWoq0DcKRtzrirPIvyJFuGtFFFtzujYXxWVIYpa/vg0Lcyj7clP120tMeNxjm+as3yUvCMU25l1xKpQdI3SCWSsbY614PgZvUM75UeDOwbS7BpaYegx+HOlwklmqypDNsRIGXkkZEsCbFRfT5jqluIkCVS+/leiVxqqb2HErkjci4OGr1kyBhBEkviyKHZCHgkS1i2wrIUU0GrI5VLs4bWjQBO0GlLtIUQo48teqc5RefcbMkO6iE/QgncBRsVGM6dzvGoVSMxmrL/nPx0cWLJz1GWvT158oQ7d+7w1ltvUShsHah2wsHK3jb+3R0Q9icEBHZMYKdEKFQ2TeXQStw+jb4QqT1tIROSNyFKC1qRTSP2mGzVTbDUzrHUzvExZ5gL6pzLrXE6Ux2pt2IvkFZPjqdPtxDmwLT5o8KWmqmgxRRdEwVBNUxNFFrKxrMUOW/vCUqRxr7K3Xph9M4uD8lYFVJBzkloDpCMZZzoyJKf366+jO5ZWnkQTmHbikSL9eyozTgbVFiKcmyeGUmZ9lY4saaVWGAbHCd9Bhizt0f/MC5Tls1tScoFd3msbTa1x/XG+XUSNO9WJyZBw6RvXfODbk+ZRnYygB4OfF5WlY8v4r79yMgYZdrbhqAqPa6p78FgMxGq9xAhjYUgNWahRyL33FJ7b9Frq50kkjh2eNzyeSJLSKmx7Zhy0KbktfDlzjEJxwWp1fXo2N4tsSefbdO5MZtuY6EE2cTh3/yx/xKAz1eXOJXt79sZlfy0Wi0ymcyO7ztIrKysIISgXC6v9y7FcYxlWTuGtsIJJj9HEVprPvvsM8Iw5MqVKzgD0nYHYXNTmmVZRNHeN8wOQu+6aawtXD3cplGInnwYr0WoLFqJQzNx+0hClwjlg5icH6O0oB3bNCIPM8FAY5A8bRV42ipgCc18psq57Brzmdq+5pekhgfHc2DccHs7upDCUPLblPy0CmIM1GOPWuShDGTseKyK0CD1gG0UV6bu7tUuj7AT/WTEISam/zngBMlIFaIuMnZMI3EH5C4dzV60hbDA7dbmwDzBmfkKibKwByyyAGTtiKLTohJvHYQ/rZ3mlF3jTLGC0oLFep6ka72+h/veMi7LKsuMPdyWP2dFzNmrPEvKY227oX2uNS6QbbdTEuSMT4KGSd8gXVywtF6/72Pj8En1FG8Vn2wJYVRYNI1LVvSPMzuFoOojVPkZBiEg70bk+ypCAZXIQxtrPTBYYjr9QpNL5L5XZG+TYMNaO5XKhaHFQujzlCJaCa49PMOFuTXmM3XmMrVOjtzxQ6LFWPfxjouSGrDYcs/23XedP+XdDbfeV8szW79rRPKjtR7pfQeJX/iFXyCXy/HNb35zfez7hV/4BVzX5cd+7McQQgizjZ3diSY/QoiRrfz2G81mk2vXrnH69Glef/31sSpTf+36f8Ose57/4txPcCl35tB6ftaiDGtRgCsVGTsisONtg888S+FZipLXJtaSZuLSTJxOY19n+x0ilLNisl6MNtCOHRqhN5bDUBfKSB43SjxulHCk4nSmwtnsGnNBfc9dd1LDg6P1QBgV4hgSt3TSEpLvuP85OuZsprKLLRqmrMZ6c/eBYNPj6P9w+tcRGGrKZynJ8TgscTecoam9kYm7lAYhOiNiD2xhDrX/Yhh+s/LK+r/31glcR/G4XuTF8vDKyVm/MpD8hMYh7sg+LGk4VahiDNjajGQxPg4eJmWmrMa2fTof5e/zC6vFiZ5hDeVzrX6BnNXipeAZc05trGfXMOkbpNWf1HAk3WBdBXxRn+Vy7tmW76grn4zY2qRelC20EbTN1swQZeSxsimWfUQI6pFHJfKpdogQdPpYh0rkYFsydMSJ4FFCr1RO2mCwubs8w73lGYTQFIMWF4ornM7VduUkd9AYd5FxsxFR3yigBbLm4J+tIzaTwc09PwJy3va5PqOQn6Myh+5iYWGBhYUF/tE/+kdcvnyZd999l0qlwuXLl/lX/+pf8eGHH/JjP/ZjwPayhxNNfo4Knj59yu3bt3nzzTcplUpjfz4xIWvm2/y9+9/GJGf5MPg67yYv7fzBPcBWkiaItE0U2axFqZY8sFIi5G2z0uxITdFtU3TbJFqu9wiF2qY7EHcHmawXk3FTIhQmNvVwYyAaB7G2uF+f4n59ClcmnM2ucS63xrS/vWZ/VAhhBqbSHxckxzxIbreuUoGI8OXBDqKbxxEDeFIxLRtMOw1eDZ4Cn5MYSUO7rCVZnsV5HoZlniYFBk+0BHk7phrL/gpxx/DgKOFOa4bH0eCKiBBQMRnqUa3PJbAXJbdFxgppqv7KgxTwLC4wzUavlBBwqlgF4H44xZTdICvDXS+ChMZhUeWZt2tD33PeXeWUX2U1ytBUzkQy7LoK+Lh+kXyHBM2OSILm3CoMkL5Bulqc9v9sDP3LUZ77zZgLmdW+7SvSazBn9f8WaQhqk2UliTaFoG5k7Bw/SAEFL6TghcQaKmGGepS6U6oeIrRZIqe16rgObu0XOqanYjAOYbjodZVba2VZbWb5GHBkwnSmziszi8xm9mY83y+MS370du/vXFAmFMhN5mu9hgfdWX9+D8jP+jaPSCvJ6uoq/+bf/Bu++93v8uzZMx4/fkyr1Vr/58/+2T870naek599hNaaW7du0Ww2uXLlCq47WbpuN8VdCsB5xHeTf87vRD4XPv+IP33hP+d0sHNz7aTYSa0aa4tYB1TjAEtoAjsisGJ8Kxk6UNtSU3BDCm6n90el0ri22kqEMm5C4KQyoDCxqUcuSo9/2Uba5k5thju1GQIr4mxujXPZNUojNpYPwnE2PICjL3vbCbvZf4mmaB1GkO7mVb3BN4ktNEWrTdFqc9Fb5kruLtoIWtqhogIWkzyPwjKPojIKC89OEHE/IUjJz9EYsCANwv2tyst9r21ZWpHw6fIprpy+P3Q7Z4IKt+tzW16PhT3U9rqtXR5HLq5IKNsNClZrVyToUVxi1qpvkZ50UbTa5GQL4UGgbFajzESSXoCaCvhu/SIFq8lLwTNmnO2r2J5UFGWTih6cy+FKRbJuftA5nvYUGTtm1uvPTKprn4yMtlS5hNgIQU16Ko6JkUfqmpsUAkneTYkQQDu2qUWpGUs7sdcngkKk15uUPT1mHYmcMqIzWT3ez9mjhO51nxibp40SC/USAnCtmNlsjcszzyj5RysXsJ3YPFwpkfUiMm6I52xfid42gqLzuIke5nDqBqYSKCXIXNLv9tax+cx729uGHsfKz0svvcRf+2t/jZmZGd577z0+/PBDlpaWMMZw+vTp9fcZs7kLqh8nmvwcpuyt1Wpx7do15ubmePXVV3fFmsUA31vfbfNM/yZ/+6vfwtIX+ZHZP8IPz/+BvWfnY2xPGUk99qnHPgJNYMdk7BjfiodKRCxpyMmInBOtW2inRGjDQrurwQ7cBN9JMECUWNRDrxPUOR5ayuV2ZY7blTlyTpuz2QrnsmvrcqpRIeBYV372O+dnvzE5+TGUrObQieu+YkDlZ1RIYchaEVkr4oxb4d3Mw9Rt0djUVMCTsMid1jS3W/Md2dzR0sh/2jzDSrJ5Qr71DFiB4dbSLJdnFgduZ8atc19OrVs3r39OGp60CpzNVofuQ2RsnsZFluMcJbtByW5NdB3E2DxN8px2hn/Xi94S19vnCawEr1MFak1YBQKoqgy/X3+BYocETW9Dgs76azyulMg6g01qXCvpBCxu4Iv6HJ6MKfRYYGskDe2Rt7Y+G6UwTNl1lpL8uryvEvtHvudnFGgj+mzifScde2ZpoLRIiVDk0kxc1Kaoh5QQaWzAtRXaJJ0sHEmcSJ6Tob1D9/qPtMOj2hQPq1MITBrLka1zsbTCbHbvJe+jItECoyWrywGrGHA1rq/I+hEZLyI7gAxtW/npwoBIJOKZi1l0ibOGJNgqOC2MUPnZKWIliiK8HUjUQaJbRPgLf+Ev8Hu/93v8yq/8CqVSiUKhQL1e54UXXhipn/5Ek5/DwuLiIrdu3eKNN96gXB6v6XUQhBl+4VnSgLzLL63+fX7+2c/wcnCV//LiTzDlju8iNwjj+ZRswCBpJh7NxAMMvpWkfUJWPNQwoddCW3cstFubLLS7sgPfUfhOE20g7hCheAIiVI99Pl/z+XxtjqLbXpfGZXpsj1uxTTBwEmFIhgQzHgd8r1Z+DkPuto7N5GeXE0UhIBAJgawx59R4N/cQgEhbNLSHZRSKjlTnEOekiZH8TvXFLa8P2iUp4FlU4FxUITNA/iZFmvtzr7k1QHk5ym5Lftb3B4ulpMBKkqNoNynbTewxyeLjpMScPdxU5ayzyvX2+fV9nvaatBKHtTiYqBeoi4rK8Hv1FyjZDV4KnjFlN7ZM7k57FZSW1CKX/IBzaAtNjN60H4Ib1TO8X3pA0GOBXdceWRkNJIm2MEx3CJBBECkHZQS316bJO2l/XmDHhzb5nBRd8sOAY7ZkvxFLM3Koxy6N2CXSVh+5TRUMad+Z66h1FzmtBHFiPSdDewzRMVAItcPDWpmHtTKYlOxP+Q1OFyqcK65iH9ApX+8J9rp6NUm0ZhNpnzVbg6Ox/YRcEJFxI7JeuO2ipOiOF6b/2WlEWq3cjFEqPzsRm3q9fqQCTrvVqv/+v//v+bmf+zmWlpZotVokScK9e/f4zne+wwcffPC9bXhw0NBac/v2barV6u5kbptgMdp2fKfOw+RX+Jtf/BqeeYn/3ak/zvfNvLsn+7A7CNrK6disGjypUnncNoYJUqQuVpkdLLSlAM9ReE4TY9KKUCNyidRoTnq9+1iJAipRGqY61QlTPZOr8ItfvU6sLWa9BniK6aDJpfwykueyt8PEJPt/eHK3wdiv5nBXKlzZr4VXRpAYiUauczCBORAt9+/XLtBQ/pbXh311NhPx7YcX+YMvfjHw7/NelYet8pZrQAqoRB7FEau4GslqkmMtyVKwWpTtBu6IBgkJFk+SIuectYF/L1tNXCKinud32hsZ77oKBLCWZPnfapcod0mQs+FA50nFGb/Co3aZtba/PlHvomt93VIb5gcpJDcqZ3mv9GD92WyQ1LVHwRosEXaEZrGaYy3OkEgJCCJls6xslttZLKHJuSF5JyTnDiZRRw0bdsM772vGTXtUoUGsZFoVip2OemGr5XhKhlI79q5MTilJrCRxbHEUyZDRY4lAjhZEKntfaBZZaBb5vScX+MMvfbIvsQmbsWV+IMBYBqzOwldsEUc2q6s+qxmFsAxCGsSwS8Bs+v+e7W6B2Juen3q9Ti43WEJ7GOju70//9E/zMz/zM7zzzjsD37cd8YETTn4OskGr3W5z7do1pqen+fDDD/f0u20xPFdh4PulRvEF/8vi3+afPS7yZvb7+ckLf5ycM75Pu9zzcygItU04hmFCr4W2cVtE2qLVcY7bbKGdEqEWxrTSgajtEuvNA/zO+7gSZlnphKnGysbY8DTJQWJYDbM8bJSwhCJjHR/Xmc3Qx132Nvb+G0pW43AnX1tkbwf3G1jCYAkFbNxn2qSTeGXEhsx0jwlRSzn8b7WLY31GCPByCV8uz/LS9Fb5my0N816Vx+3Sls89apYouk/H+j6DoKIyVFRAToZMOfWRXAAXkiLzdhVnQNVICrjkLfF5eGbL69Nek2bisBb7mIkCnzewmmT5Tu0SZbvOy8Ezyk5Kei8EyzwOywgBq+2Aotvq64eypMHWektWWWxsblbP8Hbx0XpVq6E9sjIcWuV6WCvxrScvkcu0CLL9z0RlZGolHQYIDBknSl0bnfDI2hdrIwZWfXaCY3WyyoIWxkAjdqlHvWNV/33VK5NzHI3x0v5WpbsyOQtzzBepjhqEgN9+9AJnCjXmMzWmgua+RWIkWm41AOn1xOhc/kKDTiQmgW5ZR1gGqUCEAjQYm/XxY8vjZvPjeoDV9SAopXbMxGk0Gkeq8vPkyRMKhQIffvghCwsLnD9/HikljuMgpcT3ty6yDcKJJj8HheXlZT777DNee+01pqe3SjF2C1v4TGrG6zkVbkf/lv/b5/+enHiVnzjzn/Ne+dUt79ucJdTF3uWjD8Ygw4SMFeMNMUxIVywVntWi5LWIlKSlBltou7YmF8QYk5BoQRg5nRT50Y/JIFBG9K2VR4lNlKRPIhkMz/s46kiO+aCqxlwhTeVuB2hrPQBDxqhDgxTgovp2zBhIkH22xbshRL9bu0RkhlVih58B3024+fQUZ4uraXbYJpz2KzxpF7cQSEW6ij7ZxFpQ1z710CeQYeoQZw3PVFNIniRFLjirA/9+3l3dQn66yNjpc241yvS5Xk6K1STH79ZyTNl1Xg6ectqrINAYJJY0rEUpAbJ6bhvXSkgSueW7m8rjVm2e1/ILCJE+B+vaH1o11TrVI6cT/OELQgZBI/ZoxB4LHTl0zu3K4w733uyFNrsf+XqDVQHCxKLeUxUaNMD1kSFbE5CkGUNKkChJnNjoY6w2OAowJiX4dytl7lbKOFIzm6kzn6kxl6nvKSEfOMYOurC0gJ45BgZMIhArdsqVFKjMxn5t5mrD1NOjVH526vlpNptHivz8/b//92m327iuy3/73/63/KE/9IeYmZnB8zyMMfzUT/3USD1Kz8nPLmCM4csvv2RlZYUPP/xwZMY5LmwRTEx+unAsRcgn/JOFT/ifHkzzQeEH+d+f/3E8K705/t2T6/w/b/xbLmTLfGP2Jf7kuQ85kynvO/npxSSGCa6lca3hFtqCNC3SsQxOEKUTOy1oR87oZglDT4GgFbsoI/Y1THW/sH2S9NHHOFbXqdztCFiibloGPIrN4UKAg95SzUjMBiHSjNZHVEl8rtXPDf+uHfbjzGyFbz+8yA++8OWWv3uWYsarsxjm+16XAu43SrxUWNl+53ZAS3s8ijw8EVO2G+St9sAFmadJgVN2FVdsrVzPWHVsVJ8jWi8sYZjxGjQSh0ocTOwI14uVJMe3azmmnRozxcpHtAABAABJREFUbo3FqAik1bJKFJC32zh2J6FGpBLJzeYRAKtxlnvNKS5mVhACGtolK9vYA5513WeJGOs52JFDtxyWWjlsqch1+oSyzlaHuYOENmLPv9+zFZ7dZJq04lqPvLQqpJxtoxykAGkbbFvhe6pTGRIkiSRJrE4o5tF7jhxlWJbZsNE2goVGgSf1AmCYDprMZ1MytNs8oURbI2U9DXh0dHaOdd/qvrnY5ttscALCjj0/WusdKz9HTfb2+uuvU6lU8DyPr33ta6ysrFCr1VhcXKRare54PF2caPKzn7K3KIq4du0ahUKBjz76aOQTPgk8GTC5IfOA7TnL3Gz9K/6bT36eKetN/tS5nyBvB8RG82V9mS/ry/xPd75FYDm8nJ+lGdn4djLQQna/sNUwISVC2xkmDLLQftbK9vUFCEEPEYpIlKQd29sSoe2uombi8otfvZquHGVrzGXruNvkHR0l7JgkfcQx+v535W77ujsb32Y0Yohoe2vl5/hMWmyht5gCKCOoKRcjLIIBJhK/U3lpV839tmUIhcNylGHa3Upez/hrLIY5Np/ZhvIxZm/6FELjsBCXWEoSynaTotXsu5Y0kkdxiUvu1nBWSxguuMt8FW215u5F1k7jAVaiTIeI7H7Hl+M8CAisiHZiY4TEloZa4uObmEzHxCXN/bEGXouP22V8K+aUXwMENeVTtrdWf9YNaXaxv4m2WAszrIUZBIacE65Xhewhz/z9gjYCsY9Osb2ZQrBhpd1MHNrK3nbu0g0Gty0FHTKkdbcyJFFqP0wUjs9zahT0nl4hUjLUxWqYYaWd5ebSPDkn5HSuxny2NlEsRqLl9tX9YTK23r+LrWdf9kq+xQB+1ZW9ncCen5/8yZ8E4N69e+RyOaSUuK6L7/tYljWyw/OJJj/7hdXVVT755BMuX77M7Oz+Zex04cnxe3VGgWvH1Pku/5+H36UdzVB2fVbCTOfBK2iphOtrT4CAemiQIn3g+naCax0kGRK0lUtbuYxqmNC10K5EPs0kvcxtoTpl6O4qJTi2xrF3IEI7PPeVsVhoFFloFBEYpoIm89kq89mjnUR93Cs/o5oFHKTczRioxx55d7Tf/TiRn0GwhCHBZlnlyek2ZdlYfy48i/J83jq16++YKTb4qj5FodTecr9n7ZiS02It7n9GWtKw0MpxOtOfW7MbJMZmMS6wsm6TvdErsKjynNaVgdfZBWdn8gPpuZz1GtQTl0rkM7zreTwEdkJgJ7QSm3ZiY0tJpB2S0Fo3IPCspGNIsxVfNWYJrJii06ZlXHIm3FoV1F03zr0hDAZBLfapxT5PGobAjjuGCSG+vf+LS0rLA+0N7Fppp9/dsdKO3T6n02HoTt4tS+G5G2RIaUkcS5K9IEO9vt/HHTv8rOnzK+3EC43LV5Vpbq/N4IiE+WyNM7nR+4RGNkQaNI0xXe2K6d9nM+AYhsneRuj52Yn8HDXZmzGGJEn4r//r/5qnT59y4cIFAGq1GhcvXuTKlSv85E/+5I4FiefkZwwYY7h79y7Pnj3jgw8+IAjGMyKYFL4M9rU5QAgIvCU+PAXN2OFBtcRCs0Dcl94t0EYQJZIoSV3bLKFxbIVvxziWPiA3mPEME3rXXab9JrbUNBOHZuIQbgpVHU6ERj/5BsFyK8tyK8snS6fIuyHz2SqnsjWK/l7W73aPkfIEjjBG2f+Dlrvda5S5nH1GjDVQwrR5NflotnuPB93p4K2bgLZymKOKI3Un0HT3D4W0D0JytzHNK/mt5gdn/MoW8gOwFOb3lPx0oZAsJ3lWkizFjkOcIzWPkhIvuUtb3j/n1NZ7b0ZBrhMJsBJmiMzeVIFggwTdrZZQRhJYEYn2yLoxrlRYQg9xUBTcrJ7m/dJDAiumpnym7M1OgrL71n2AoJW4tBKXZ608jkzIuxE5J5XH7ce4YxCHtjAxjpX2IPSSoV577edZQxtohzZSGqTQ6f9vczqkTOcRBosnzRKPGyUASl6Tc7k1TmWH9wmlsred92cgj9pMeHrfr3v/ZIbed7kTWPkRQqCUQmvNlStX+IN/8A9SrVb52Z/9WVZWVvjZn/1ZvvOd7/C3//bf3nY7J5r87KXsLYoibty4QSaT4cqVK/sqc9sMTwbo5GByOjJOzKvTi7wytchCvcCjepFKHLD17hIoY6Fii3acVmRsqXGshMCJsa2DWTXb0TBBdPfW4EiVNqE6aahqogXNJA2qi3W/a1wvEYoci0bokqhxbxdBLfKpRT63V+fw7Xi9IjQdHJwMa5vdQ2kxVEZ4FFAJXYre4IZztePk5GDlbgCfVs/wWu4pHgntARb1W9QJx7z6Bv2W4wk2T1QZEWsehDubv4gRFxYsYViKMsxEAWW3X3ZVcltkrZCG6te3CwH1yF1vON9rGCRrKsuaypC32oS2xWm7QmaT/M8RmrP2Kg+T0c1wLGGY9RvUY5dKvHdVIIBI2cTapp2kz+2VtiLrxBS9Jv1WVL2QXFs7wwflByAdImP19Th180xG/T13g1jbrLRtVtoZpNDkOu5xOSfcs2eZ0uLAsmB2wjhW2oMwKGtoXHvtvZKQHhUYI1BKrJvmCEyHBG1PhrqGFADVOMPNlQzXl2DKH9wnFG/Xj9VzqZpBxcztLuURL/Oden6MMSO5vZ09e3a0LzwgrK6ucuvWLf7ZP/tn66/9iT/xJ/iRH/kRfvVXf5V339054uVEk5+9wtraGjdv3uTll19mfn7+wL/ft23i0MI7gHJ/F1LAmXyVM/kq9cjlQbXMQiuPGtqYKUi0RaItWrGHIJXIuXaCb8d9DkP7hUGGCV1pl9shPr2wpVnvEYqUXCdCm3uEPFfhua31QNVGexIiBO3E4V5lmnuVaWypmM3UOZWtMrvHDjPjIDESi6PZoxQrybNWgYK7NHDg3cn1KHMI7m73GlMYA55MaBubzZOKjohhHcdd9gZskeUYBEZa/Oj0TX5t5TLxUKc3GLVUkLo8ar5szPKe/WBLD8iZoMIX9bktn3nQKvG6+2yk75gcgpoKqKmAtSTD1cxdTjn9QasveMtjkZ8uck6Eb8WsRNlNlfi9gkAZm2pkU438VAIn08m2Z/U/MxU2NypneKf0iJrymbY3nC43ZG/7sIvbQBtJNfKpRj5gyNhxaqPthrvqvTSIfcvg2g3GtdIehO3stdHQjp2T7ShnwEQC7I08HYNAdaSC3Vcs2UuIBm8qrbLBcjvLcjvHJ8unyLtt5jM1TmVrg62uez+PAD1kob4302fTn/sqRQJESJodtKmol9uDrMmjJnvrolwu86//9b/mlVdewfd9vvOd7+B5HvV6nUKhsOPnn5OfbWCM4d69eywsLPD++++TyexP781OcKVNpOwDJT+9yLkRr8885bJ+xuN6gUf1EvXEY7sHrUEQK5tY2TRCDyEMjtS4dnwg5gldw4RYpfuojKAeuwR2PFCr2+saFyq7I41z+yanG4GqKRGKEotmyx3dNa4HibZ4Ui/ypF5EoDsOM1Xmc7UDs3wVmPRhfyQNGlJZZWwkS+0sswMsxbfrWbLQFA7B3W0lymJInaI8owi3kJ9t1QzHEsmQVeOMHfNHZ2/ycfUc99ozu/4eKSBWgrvNaV7O9cvLZtw692WZUPcTrXRBRhxYw3xFZfnF2ptMWzXeCh5z3kmd0ubtKpM2TtjSMOfXqcUetdjD7GEVqB+ptLmlPFqt1GjGlh3XTSfElqkD3ue1eV7LPyHUFl4nEHbdLe5QXS83KvlPmzlcS5F3ujba8VjETGmx7aT1KGASK+1h20n/UXieJhvEaANKCeLEIoztjtT9ZMAAlpf+uCYWmK51pW16TlmXDAFY0KkMWUPIkEokshNOuq72WJtl4BO+dxDQIMMBjgbQ91HR7fMRG5/r3aA0QJLOWTfULuDswapzo9E4UrI3gFOnTvFX/spf4W/9rb/FG2+8wcLCAktLS/ydv/N3WFtb44/9sT+24zZONPnZjewtjmNu3LiB53lcvXr1QGVum+FJq1M+PVxY0nC+UOF8oUKl7fOwVuJpKz+Cm5PAGEGkJJGy180THEvh2TGupfadDCXGYjXMsBqmzb2BFRPY8ZZJUW+gatm0aCmHZuxsSUKXAnxH4XeJUGzRbE9GhAySpVaOpVaOm0uGgtfmVLbGfLa67ga0HxCCIRr/w0ekLbJWjAAWh5Cf4Tk/huIBy90AYi06FuspPBETmn5JiRSmb0X5JFR+truGhID3ig8476/wW2svb5HpjDu/dC3NszDHjNug1CN/EyLN/bnb7CdZUsKDRplL+d3ZXo+LZZXnP9ZfpSBbvOE/5kVvkTm7yrOkOPE2805IYMUsRxmSXVSBRj/naTW/FlnUonQBy5WKlmPjyQQvp5iVaU9V1KmEHx1plCBSNsvKZrmdxRI6dY5zQrJutGOzujaH1/MzKYZZabcSG8V4+XZde23HTsj4CSbX7thrp2QojLZWtY8jhLPxKxsDJAKjBUiN6LvFBFoL9AAyJIRBJ5IosRFCIy2D43VzCnc456JDfgb9qbu4Z0AkAncRVADa7b8ye9cAe+e81h7djEeN/HT7lL75zW/yYz/2Y3znO9+hXC7zxhtvrL/nr//1v77jdk40+ZkU1WqVGzdukDsf8Nq515D7ttI2GlzLJla7SwHfaxT9NkV/gcvqGY/rRR7VizTVzsFSKdIVxjCRhF3zBKlxrQTPTnDtvZOAiTShr++7Q+UQKoe1KB3MAzse6BwnRLp6nbFjlBG0Eodm7BJuCkqVAnxX4btdImTTaDuoCYgQCKphQDUMuLUyR2BHzGdrnMpWKQfNPZ3QC8ZwozlAGGPW3aSESO3EB2FY5ecw5G4An1VPQU+jtBTgGkXUM0lIDQ86Ukyik9HzMyTDZgOCaa/JH5u9zm+vvcRKPPlAKgQ4UvNlY4b3nId9k9h5v8aDVnmLNLeW7E/+2iio6oDfab7Ex63zFEWDKJG7er7ZUjPv16l2qkAT9QJNdM2lC1ihkoTKYaWd4ZPVU1zOPeWD0v0N8nNEa5nKSCphQCUMEBgynT6hvBMOlBxrI471vdlrpZ2oNIeuGafyuJayaSdbK0PbHe2GvXaC35HJaZNmDUWxTTscrf/oKEMIwEmtLnS0uUa/5d3rZEi3LLQS4IAxEpWAZSusTpbW5gqiiDvytO5/RwLjDviurg12931G4DSARv8v9dHZU/yJ91/jl27d5uazJRbbIQkGKQSNRoNMJjOwEDCqJfRRIj+fffYZn376Kd/4xjf47/67/46zZ89SLBZ58uQJ165d46WXXuLKlSsjbes5+emBMYaHDx/y8OFD3n33Xf7Wo/87P3vrZ3gz/x5vF97n5cyr2PLgy7+eTBtUjyIcS3OxuMrF4iorrYCHtTKLreyY0gyB0hatTr9QKrdQuLbCd6J9bDwVRNomimwqUYAtVJol1KlG9cISZotRQiNx1xt9u0iJUILnJBi6RMhF6cnIaytxuVuZ5m5lGkcmzGXTPKHZTB17iM336DBHkvwk2iJjp02jaY+MoBk7W2zDBz26D0vuBnCrlvYD9o4pnkiIeqo/XftcYwwv5RZJjvEEC9IV5lFzfCxp+IGpL7jXnOa7tdSedJLVdVsYWsriXnOKF7Mb2TqWMJzyajxql7Z877NWlrkB1cODQsu4tEwqo12o5CkELTLu5AS90KkCreyyCjQ50viBa5XzXKucQ+Q0+biJkAZtDsacZ1IYBI3YoxF7LJAqAbp9Ql3JcUp+DnlH9wjGCBxbUbTaFDuJgcZAK3HW7bRbiU0yxr24bqLgpvbauUyYBogrSZxYtMNJF//2H3t9aaYkuZ8sGS2h20sbS4jTHiMEuCsWVtMisTQ6A0INoVmadJs7XIc5z+MPv/4yf/j1l9dfu/N0kd++fYevvvqKVqtFPp9namqKqakpHCedw47i9AZHi/zYtk2xWKTVavHs2TOUUiwvL9NsNlleXuaHfuiHuHLlykjhrUfz6jwEJEnCzZs3sSyLq1evYlkWgZXhcfsBv736a/z26q/hSZ/Xc2/zVv493si/Q2AdTA+Qa1lER6zyMwjdRsxIWTysFXlcL9LWkzTcCRJtk0Q2zchN5biWwuuYJ+yXRC4xFtXYohr7WGKjIuRtMksY1ShB0EOEDIRJSoT0hEQo1jaPaiUe1UpIoZkOGpzK1pjL1vAn6BM6irI3Y1JXvp5XEAKetPK85PRLlwxi00TrcORuXTxqldb3qwtLGByjiXtchSANDA2smJo5vKrEXqCpPITRYyx2CC5mVpj3Kvz6yuWJvlMIcKVmoV1g2m1QdDYs5E8HFR63i1tI1bN24VDJTxeOpZkr1FFa8LSaJ+OG5P3J3OicThWoEnnUE39kzdnez+lFWpFzdWf7AmU2rvWjTITWlQAth6VWDlsocm5IqGwyHN2MtnEwaIFBiNTZtc+ZTMmUDCmn4wgox+4bcqXGddK+oXVHucQijGyiZGdXuYPAKNe/5SqkSvd/W78WAC2QtkI4Bq1S2ZzuCSEVkUQ2bQwGGaf/DSCNRHaUu2aADFNogRX1nP8hO54Pts6xLs3Pcmk+zaDUWlOr1VhZWeHhw4cYYyiXy+Tz+ZHaOY4S+Xn55Zd5+eWU5P30T/80i4uLA7M2RzmuE01+Ru35qdVqXL9+nYsXL/ZZ+gWbwkVD3ea71d/lu9XfRWLxUvYyb+Xf5+38e5Td8Zx8fn35f+WdwtcpOTt/zpPWkZO9bQfXUrxYWuHF0gqLzSxfrk5TS/wJe7DSIbRrnlAPvQMJW1XGoh5b1GMf2ZmoBp0U9t7DGMUooTswBG4aZGcMhLFNI5ycCGkjWWzmWWzmYdFQ8lrMd5Ko8+5ofULiCFZ+Ym2TtTcmg91KSTUelKklUEYiOxK5w5K7dVGJ0ufF5jHKFzFxx4mpezyuVGgEekfJ2NGGMoLfW7nA+9MPx/qcbyn+8Mwn3G+VWU7yY3+vJVJ5ypf1Wd4tbcjfXKmY9eo8CzdtU0Ajtsk6h3d99MKShtl8HW1gsZbDlopytrXzBweg6IZk7JiVMEsywvW0/70soud7DGpdvnP0yVBiLNbCDPXIpRF5rLYC8l6nKuSMZ5pwFKDNVtnVMDiWpmS1KXWqQ9pAK3bSypBKpfdajP68EgJsW2PbmsCP18NX48RKpXJHuW9IgPQ1piV2jlQwaa6S7aXPltRKfCtpEQhEIkAP2t4g8jParu4UZCqlpFgsUiwWuXTpEnEcs7a2xtOnT6lWq3z88cfrVaFBErlGo0E+P/4zej/QregsLCzw8z//8/zMz/wMf/JP/kn+0l/6S/zLf/kvmZ+f5xvf+MZI2zrR5AdSArSdtvHRo0fcu3ePt99+e8sPHFjDQ0w1ii8an/JF41P+1cI/4qx/gbfy7/F2/n3O+Od3nOj/p5Wf5XdX/0ekmOFS5go/MPWfM+0NTgF3Lbsvh+Y4YTbToBr6vOCtslArsNIOxnqAbsXgsFXXTonFflhGayNpJB6NJLXw7laEfCteH8h7jRJKpkVbpZKCdk+Qavd9aahsgu/2EiFvF/aigrUww1qY4fPleTJO2DFMqFH2m3zrziXmcjVemFnqI4pC0GPtefgwJrXZ7UX3zCkjUZotlumJtnCkxkIdmtwNoBa7JJ0q2ubJpSUMtlEk2Eg0dKQ2xggCGVNTHnlr/4wt/v/s/WmwZEl6ngc+7n6WOLHeNfPmWpVV1dVdvaKX6gUgQIBookEAAw5FEsBQwogCMRLMNBpI+jEkZkyyGZnpz5CQGTk0ozSkxoY0kQApiG0kBQMaaIggtkY3Gr1UV1dXZ625b3eN7azuPj9ORNyIeyNuRNwbd4nMfM2qMjPinBN+Nnd//Xu/9ztOaCRf2b7Gx5dvTix/60EIrha3WHAjvrxzbSoimFtfayLtcrO9yLXSblTwYmGbh3GZve/d7fYi763tL5J6mpAClst5RGqjVcRawXKpNfUk25WG80GD6zur0OmLJqlAf/zYa+5h5yMqZMEKQTMp0EwK3IPcNKFDhMp+fKho+0njKMYNUkDJSyl5u31yolXuJpe5xFqR2vFFV7vYLb6a5w1VbE6wskyRZA5x7J5M4e1pXgstGNct2T1kJh/j93hRj/ltkYlcJddXFmhi8lOYTl3jui6rq6sUCgWUUjzzzDNsbW31JHLf/OY3cRyHH/uxH+P8+fOEYUgQjJ4LT4rf/M3f5Bd/8RfRWvPzP//z/K2/9bcOfax/8S/+BTdu3OB973sf6+u58+fXv/51rLX8mT/zZyaS9D325GcUtNa89tprGGP45Cc/iePsvxRFNbm3+Z3oJneim3zh0b9m0V3uEaHnSu9Bif3H1raIK7exrPN2+zd4q/UbCLHEs8En+IHl/z0r/oXett6cRX72QltJwc14dmmTK0bwsFHhUVgiGRtPngR5sdXUQJY4WAtS5OYJxzE42T47VdGZxBadZGCyIYcYJXSrc09EhCL/SINAO/V5e9vn7e0VPJURxS6PshLf3lyj4CX4TsaV6hZY25uwnwXsjfpAXlkb8uv0IKxysbRbP0VAp/2WBTVbM4hpYAx8a/sivRXvIQNcQWQ0rYMUeV6Sknm9HyHgbrbAe9WDE23zrNA1nbCGQy7iCqpuxA8vf4ev16+yno6vz9BFfi0196IaK16LipsTyKKTsuCGbKd7I/fuUAJ9VrBYzCM/rz66iCc1a6UdakE0Zq9BGAQlN19lb2VuXnNKZbh9rpanm8vSHxUC3WnM2SND+xuirWQnCtiJ8omgKzMqftwjRKdVq+0gGCtnatzgKd3Jh92NDrU7eUNR5pBYNbHxQZ43xG7eUBD3pHJJpogTl0xP51I36e8KYbCdvK6DyJvV44wPGGsgMvC+9dtV9+2mYolzV6I9Q1YxmML4XJ8uqsHhpNNdglAsFikWi1y6dAljDMYYPv/5z/OP/tE/QmuNEII/+IM/4DOf+QzeIesGaa35T//T/5Tf/u3f5vLly7z88sv85E/+5IBD2yToBjLeeustfviHf5idnR3u37/f+42lpaWJj/VEkp9ms8m3vvUtLl++zOXLl0c+/AV5uJyerXSD39/8HX5/83cIZJH3Vz7MByvfw/vKH6TQiSYZBo+dN2GTd8Pf4p1bv4UQC1wtfIw/s/yX8GVxLnJ+RqFf/6qk5UKtzoVana12wMNWhXrqH8mWHHYrUOfmbpJYe0QdgiI6ttqOmu2obxFEulNTIe4SoZRApb1K40ONElKvU5BuF3uJUO4a59IK3SNJoxLt7Pa3EqIsvy712MdzNOaMZPUaaymoYRr73fZtxMUB8oPIyU9RJvinJHczBn5j40Pc2F7sfTZspdURBmU1AtPLaepuJ4Q405Pyg9DNGdNW4qIncH4bDing47Ub3I+qfLN5lUknPJ4yhFryZmuVj9Ru9ybPl4LtfeRHScvt9gLPlLcP1caTglIWr6DZ0GXubCzii5RLlW0KE0j2tO0+UwzUCwszB23Fnny6s4D9ErmzQIQmqciUGofN0GEzLAGWgpPldtp+TNmLe2PAaSKP/BwfpBisNQQQZYp25uVkSDukVk40vu8tvjqQN6QlceyQZLORyuUKCNs5/n4C1P1nHtUZfQWtPfDrzkZ7/jxgM5lJvO2ugsAOfDnqClYLk7rsDmJYdERKyac//Wk+/elPA/Do0SN+4id+gl/91V/lF3/xF7ly5Qo/8iM/wo/8yI/w4osvTjxv+8pXvsILL7zAc889B8DP/MzP8K/+1b+amvx0c3k+9alP8fDhQ377t3+bl156idu3b3Pz5k0+/OEPA5OlvDz25Gev7O3evXu88847fPCDHxxbBfYg2dukCE2bP935Y/50549RwuHF0kt8sPI9aOOPDKfm922bm9H/xj+9/b9hqPLeJX93hj9nGCXnWiyGLBZDwsTlfqPCVlKcXjpzALo++5a8xlCc5eFoJfMJ6GxzhXYttLcYbqE9aJSgaGcurczbF+XprogFforr5PKoVCvasXvoHKG9sFYRp4rNVoVmqTkweJ0GMqPwnf3kp//K7C1gCRZhDVV5OnI3a+G3Nj9AhsNmUur7fMRiikhRwuArO7CdIwx3skWuelvH3+gZoxv5yaykLGLa9miS1rVCg2XvO/zx9vO0zfhBPbe+1oTa41Z7kWdK+TWsuRElFdPaY7+/kxaB7SO08QTQJ6UNCvk7cSdaJN5xKDsRFyvbIxdyRslY+wtkP7ewSSPxaST5iv3ZybuYl6jQMAiiLJeDrbfL0LXT7kSFil5yKu0/DcvugqMpOLv5a9rkbp1h5hJpZ8D9chwG8oa6FtsmHw+T5Oh5Q+OmU3slbfs3ABAHM+W+6y8mqPsz8bYd1IYYHkwCrfVYY4CVlRU8z+Mf/IN/AOQRl9/+7d/ml37pl3jrrbd4+eWX+S/+i/+CD3zgAwce586dO1y5cqX378uXL/PlL3/5UO2G3Pjgv//v/3veeOMNPM/jZ37mZ/irf/Wv8lM/9VPAU8ODARhjeP3114njmJdffrln93cQZu3mpm3Gd5rf4jvNbwHQMlWKKiGQCY4wQ19EIUBR58WF/N9hJ9KQWjU3RMiMWfEIvJRry5tcMVsdSVyZ9BjsW7tkSBvVCafnErnZR4UGLbRdqQmchECleB1pRFc+0DVKaGUu4R6jhLx9FisEvtQd1zhBmkmixCXVE16jAx6Th+0KD9+tUHJjzpcanC/XWZpxPaFx0BaCoVEfEH2rp0LATuxT6xZ+tZbLhe1TmxR9ceMlErzckKOPlI56klxhOFfa5pFcAAaLdLdsAMwf+ekWmtVW5ta39vDRny5cafj+xeu82TrHW9H5sds7wpJiuBstsOy3KHekk5eCba43B/dX0rIRFVkunF5+2DiIIbk6UlqCIEWjeLu5ik4US0GDc6XmwDAwiYzVU5rloM1y0CYzgmbi00h8Wql3xmq1jI4KiTHzzdOHoJ36tFOfB+TjTMnr1Bbyc/OEk4AZN3k/AShpqfgJFb8/OuR0CJFDYhyyKaJDvbwhL88byi22FUmqiBJvbO7sVNOmcddvkus7JPIzy9lGrXB42duwdI9+7M2Xf/7553n++ef5hV/4BbIs40/+5E9OxQzhq1/9KsvLy/z0T/80Sin+1t/6W7znPe+ZyLq7iyeC/LTbbV555RUuXLjASy+9NHGo7ritrFPrsJM57FDEEZpAdibIIhv5ggYq7U0UQ+0QGTevAXSGidCkK0+OtFys1blYq7PZKvKwVaaRTSaJm7Yz6YW1kcceFUqNIk0C6gSo/lpCHQvtrlGCsSFRJxq01yih0+rcTtQ1eG6MtXkBuyh1SdJh20+OVl+ekCM150oN1soNzhUbx65lN0YineFyHLnnzj4Iq9T8PGn92cIGVWe6nIhZ4d9uvpeQfNAJ91z7gxKMP7Z0ky/UF/Zt58uM7SxgwTmc49dpoRv56crffJHRtn1Zu4eFELxQfshaYYc/3n4OfcBQ1bXYTYzDm81VPly7kxsJeC18me6LGN4Pq2ea/MgxRgWuY3AdQ5sC390uITS9/KBp3RsdaVkoRCwUIowVNBOPRuLRTH3MkaJ4s8ZgVMjaXLIkyPvtsx0VynNvGnGBRlyABjhSD0jk/BH939F/d9L4wcmiO+Z1kRnRyx2KOzbbk9jn71psazxXUwoSLBDFLs32eOWO7UZuRkAnCkKQrkY4+9/LieY2tjfZ2NP4/m06BgcpoMB2U50mCDyVDyl7m6QWThRFI80OHMfhM5/5zES/denSJW7dutX79+3btweclSdFdy74H//H/zFf+9rX+PznP89v/uZv8g//4T/kwx/+ML/8y7/M1atXJzrWY09+Hjx4wPXr1/nABz7AwsLCVPvutbo+TmRW0dABDR0g6VgrywRfpiM79kBlBCrvQCLtEBqP1ErOjoyhg0MscyyV2iyV2rQTlweNKptJcPCq5BGXUk4qKqStopEqGn0W2kUnxVdZbpTQqb3QNUrYigoja/EIAa5jcZ0EW0gwRhAlDlF6NClAZhR3GwvcbSwgsCwGbdbKdc6XGjOXx2kjRkZ9YP8qeCPLO3prLN+3/PZM2zIpfn/rBRpmt2/Yigb7iYOelpoTsug02Moq+wbO+7o2d+SnP+cHus52ZiLL5fEQlJ2EH15+nW/Wr/AgrY3cUolcAtnWPnfCBa4UtxECLhR2eLe9MrCtFYJIKwrqrOW/5BgW+RkF38vPoZsfZBJFlkkcZ/oFCyksVT+m6sdY26CduR15nE925gpWChB2t9/uRADmhQxlRrEdFdnu9B1ep9Bq2c8J0dELWOc4q+RnLxy5++xBfi+jzOnlDsVGdSTxB59NNyLoHPhuT/Z+WQNkAhsqdNjpzzyN9A3C6Sh1JrhN06TVSgtk+X8GQHaI0AEo+4czjtJajzUwaDablEqTG3+Nwssvv8wbb7zBO++8w6VLl/jVX/1V/tk/+2eHPt7Xv/51AP69f+/f4+WXX+ZXfuVX+PrXv06rlTtnWmvHLpqftR5t5pBS8vLLLx/KpaJ4QkVM98IgaWmfls6tlX2Z9qJCo+xLCyqj0CFCsXYIjTuVtvY4cZSgVNFLuba8wRUteNiosh6VSIZI4maZt39SUaFBC21D4GQETkJBZT2jhChzaKb5+QrsyKhCVw5QClJKQYI2kiTN84TGenUeAItgMyyxGZZ47dEFim7EhXIuj1sshEeeZBgrDnw+9qbrWgRxJnjBf9RxHTpZfGn7Obb0YJi/mQyuvB20GigEfLx4gy/WPzhU4pgZgXMGEqUnhenlZ+y+FJ7IOvKr2Uy7hIDvqd3kUVzha41nhh5XiLxOSaQlt8NFlrw2JSfhfKHB7XBxwGBECLjVXOI9Z8z2uotpyM/uPnl+UFBIMUay3SwgMJSL0aGMNISAkptSclPWSk2izOkRoXhoVPp00Y0AdP51JDJkzMkLKRLtsBE6bHTMEwIn7bnIlbzk0OYJpq8O2jxBCAjcjKDP5CPRipvNxYn2d5RhqdokSZ28yGp/dH7Se6s7TKr//UkVJnVy4u2ayXjUhIYHL55f5kKxxOv311lvtnMiZBhLsCr+7AwP9qLZbM6kwKnjOPz9v//3+dznPofWmp/7uZ8bmyc0DN1o1d/+23+bX//1X+fjH/84f+Wv/BX+h//hfxhwentqeACcO3cOrQ83STpu2dsksAgi4xEZj63M4omsFxVyR6wO+SrD7xIhowh1x2ZZTBBHPRYcfTLnKMvFhR0ussNmq8iDVpnmgCROzOR3huEkokIWOWChXegUVe3vOc8Xm4DNHeYyh1g7I8iQQElL4GcEfooxgjh1aMfj9dDj0E4LvLVV4K2tVRyZcb7cYK1cZyVo9fKZJkU2JuoD+2VvQsB6u8wPLV6fuu1HxVd3nuFhWts3MYqywW50XN7FktOiItv7CLsjLLezJZ71NmbR3BPB3sgPzDr604Vg1W/yw+5rfHnnOZp6vxTDkZYskRhJT/6mhOV8oc6dcHDSFBoXYziWAslHxVEXFKS0lIv5CnqSuYSxi6cySkFy6El9V6a0WmyRaEkj8WkmPu1TNEw46FRmSYZOHoIw8wgzj0etCgJLsS9fqOhOfh/zyM+ZPtmJ4UzhVGiMwCB678H6drk3dk8Km8n9D1nXBtAKbDLh8boOjCNK/3TxnnNL/D9+9M/mu1jLN28/4Le+8xbfuHmf21t14mz/+QvAcw7Xz05CftrtNsXibObBP/ZjP8aP/diPHekYXZnef/af/Wd83/d9H1tbW+zs7PArv/IrfPSjH+XTn/70RGYH8ASQn6PgJGVvk0GQWJckc/fkCSV4Qg/tEH2p8WUupUmMon0KRGjvBPao6EniYpf7zSpbSXCsdp79OImokEUQao9Qe5iOW4QrDQKLkpayzK2zrc2jfJF2iDJnn312p8VISY8IWStIUkk79sgmNUwYgcw43Kkvcqe+CBhWSk3OlxucC1oTy+PGDeJC7Dc5bOrDJXgeBd+oX+ZOsrSvvdayT5ZoxujAhYCPlW7wSnh533ehPdwq3mmh3+2tH/6Moz9dONLyfYtv8k57hevtC/u+r/ox99slMlPiTrjA5eI2Fwp17oa1AdmskpY7YY0rpZ2Ztm8WOEzkZxTy/KB8AtiKfZJUUfQSCv7hreE9ZVgOQpaD8FQNE6YxP52GDJ21uKtF0Ep8WonP/Wa+8NafLxQcYIFurDjjRO94YBGkWlJwu4YIHftoO0jVRylGTCIR8ZBneRIP9GH79P85Yv9ynzpJCMH3XFnje66s9T5bb7b5jW+/wZfeus2bjzbZacdHilBOQn5ardZMIj+zxksvvcT58+dZX1/nd3/3d/l7f+/v8cYbb7C+vj5xrZ/HnvwcpX7MWYj8HIT9eUIJgUwpyHToS+FJjddHhELtkhgHe8xEaFwC72FR9FOe8zfItORBs8xmXMSIk03SPe6oUDeykxrFvXYVV+pOVCjL/95NHPXzSErUsRMdHhXKJWa+Z/C9KC9yqiWtKCfUR3sGJOutKuutKt/GUvFD1soNVovNofK4VAuKExShHTZwN3ThRF3fX2te4Ea8OvT36rHP3us2SUX1c24dL9x//r7M2MyKLDlnNyG/H13it5fwyWOJ/nQhuFbc4Lxf54+3niNlV/MuBdTchJ004Lv1cyx5LYpOyqrf5GE8WNpgKymeOfKj9cEy0KOg4O0WU663CmgjqQTRofKDuhg0TIBW6vWiQvpMGSYMYhQZilseSaxwy2czHwxyKVs9DqjHefTTkbpnqV324wE5sLYCdcJW18eFac7Csnt/c/v3vr0nOJDOFKbl7t/UiuEEaAZznIp/cGrGSrnIz37qI/zspz4CQKo137h1/9C/d5Kyt1nj7/29v8etW7e4efMmzzzzDH/zb/5NPvnJTz4tcjoreNJHdDItzjryPKECLV3IZVMypSATiiodSj5yIpR3kqmRtLVPYhQGceSCo3shRb7y4hyTa5ijDJdqdS7aOlvtIuthidAedTI/PY4jKiT2ZL2kRpEaRSPNSVZBZRSclILKcKTNC84xYVRICBzHUisnQNwxTFC0Io+j5AmBoBEXacRF3tg4R8FJOF9uslJsshK08ZQ+0mqkEPB6c42XKofv+CfF9dYq18O1ke3difdHocwEz50U8L7g/tACtg+z6tyQn2E5P10cV/Sni6JK+XPLr/Ot5iXuxruDXtFNqac+sXF5Zfsin1q+wcXCDg/jykBblITtuMCCfzqOgcOQncBEVQgoBrncdBb5QV1IARUvoeIlPcOEblQoPQbDhFkOU70i05WEoEKvnow2Aq3lGbMAH0RmFFthka2wCOTFtrvGCdpI7JkrbHs4THW/+2zRu1GfgS8n+T1LbmWd2d2Z8pRTwX43OZEJRDb6GJXCdHnprlK8/Oz0jmldTBr5mYXhwazx0z/901y5cmVsrc6D8JT8HAApJIEKaOv5mIh0YRGEJrdLvhd7lFRMxcmL/g2bxLnSUOtEhHIi5JEYZ2ZESEpLZo6P/HQhxK4krhV7PavsSSwzj6s9w6JCjtK4M4gKGbubJ9Qd9AoqI3AyHGn2RIUkUeYcGBWSEooFTbHQBgtpJqm3PYw9nJtM97hR5nNj2+fG9hKOk/Hi0kPet7g+4d526ELbq42Lx05+3mkv81r78oFEba/ZQY7J3plzbp37usbenAklLYmReDNyfDpOdEnPsDwnKSyu1aTHOcwIwYcqd7jkb/Mn9WcBmfcDhTYbUZnNpMy7rSWulTdZdNtspYMD+Z2wdqbIj55REeNJcRz5QTBomHC+Z5jg0Ux8In3yC1PTYreejAXXzBEZ6hTbbrtstMtYayk4GalWVDsyucOaJ5wNTKY7yyM/Q8jPnt1HmdPY3v/Ioz291NQpc4v7NhUauimuw1Jvy4cw5ToK5ln2dhizhL147MnPUSfvBVmcO/LThRA5EWrqAk3dWd3rEaHhg1tOhPLJQNYhQrFVmAmLkA2DFJZUKwoHaJNnjZKfcM3fJNWSR80Km0lw5OKLR0F/VCjVkmTmuUKdQU+77CTgiFwS160n5EgzRVQod7lxXctyLQIijBG0IkWc+EcY+AVZ5nC1cnSp0cPk8Cs+k+BWuMg3W1fHRqjiIXlT43J+upACKiKiYQfltUpY7qRLXPMnI4inib11fvbCE1lekPlYJ7uCJa/NZ5e+w1frz7CdlfGkwZUZqXH4buM85wpN1gp1NpPSQL9nOlHaac06jgujruNJYF9+UKIo+kfLD+pi1zChTdoxTGicsmHCNJh3MvSg5fKgBWApucmuTG7uydBo6EwRWkGaDvbRE09j+vvxfs4TC1AWJlkT7DvGOGVcecrIz1Exz+RnFnjsyc9RUVQlNtOzPwkZBr1nEmaRAzlCZScnQkU5nAg50lDdQ4QSq9BTEiEpzNROK7OCqwwXaztcsDtstkqshyUiTt+qdW9UyNj8evtONhPThMwqmqmimeZ26V1pXMHJbbRHRYX2F1fN/y4lVIoZlWIet09SSRj7JNl0durPLz6i6Exe3Tw3PBD7Rg5tJetxiRW/NXJfa+Hfbr7IDy1dn2oV+35U4auNa2MnBdoMJzrTTCVKMqGhC+y9htFEI+vpY5jbWz+k4PijPx0oafnUwjvcCpd4rXWJRT/kYVjBWMm3ti/y6ZV3UWgyq3qkVgq42VrkherZcNjTk1SMPwH05wfttAJSLakVQ9wj5Ad14SrDUhCyFIRoI2j28oQ87MQLVHamsrdpMc9kqJX6tFKf++SR9eJjRoa6UrNUK1rh4c1xhOlwF7v/c8RgOsTIR9GO+PsQHNay+rCYpMhpq9VieXn5hFp0snhKfsYgUOOrBJ9VJAforA2SehZQzwIUukeEghFmCQNEyArWkzJYgRDji0lJYYlPifx0IQQsl1ssl1u0Yo8HrQqNzINTksTtbZvVgsS4JJmTy4WcbGZ1bGyfdSqxxesYJQQqxVVmiqiQ6P3puRbPjZDCoLUkSh2i2CUzB63yG967PJvaKkLA13au8iPnvjNym9/bfpE78QJ/vHmNzyy/M/BdaiRt4xFqt2Ml7xIbh3oW8CCtkhPT3e2vBJs0M5/1OEB3ZIA70X6zA5jM8KALKSwlEdOyg/2MLzWP0jKrbnPiY50GDAeTHzip6E8XgivBFue8Bl/afo7A8Qgzn82kxLutJZ4pbfGNrcuU3KRXSLKt/RM10DgIpxn5GQYhoBTkzo3GSNbrAZmRlIttSu5wh9FpoKSl5sfU/LhnmNBMfOqRhxHzMz2ZVzJkDyRDEeUj1Bg6DkwjOhsqabMT7m/pk8h18n76ujA7oWzdjiI/Q5pWHmN4cBwYN3drtVozs7o+a5if3uWQOKrs7ezZXc8eGsVOVmQny+2zKyqi4kT4MhtOhETelZfdfMCKjNvR/FvkkB2ksKQnrGU/CCU/4Tl/g1RLHjYrbMbBibvEjYbAWEGcesSp7TjHGRxlZjQ5EyTGIUkc6hRQwlBQaR4JUvn9niwqlP9prEJ0rLSLforEkGpFlOb5A6aPPL208rBXiHdyjB5k3mmvcCdaIDQukXFJrJOfm3HYzgJS6yCF4BvNq9zLFkGIPjOC6S5moDIClbHitcisJNQef9rcb1V9cIuHoyxjWtpnb/Rn3VRY5WyTH92TvY2+nicZ/enCVxk/uPRdXmuu8eXNa4Dku/Vz/JnVtyiolGbqUVApvtIoabnVWuBqefvE2jcKxg6pLXJGIKVloZwvgKWZ5MFOicRIgkJCyU0pOOmRjEz6DROqnosjDY3Epx4XiM3pR+unweNBhqo9MlT1Yyp+RMk9W2ToIAyzsbYITCYx0iKVPbg4el9+kEDsKtgEk4sdzK473Lhas+Pc3k4DrVaLSqUyfsM5xGNPfo6Ks253fRDE1NOwXC61lZXYykq4IqPiRFScGE8MEqG0k7EnRe66BHlnExmHzCisoE9aYk9N9nYQXGW4VNvhot1ho1ViPSoR27M0yAqMVcSZIs5yIuQ5syusCvlKcyvzaWW5PM7vuMcFKkNJOzIqFGbOHitbgUWgkUhlKamESpCT4yRzSBLJC4vTR30OWumLrcsfbr8HKXMJWqoFBddirEX21e4QAnbSgMqEtYf2o0/eIMAVBldGxNnw7nNUEu0oKGEpioS2HZRouMIQG4V/CLemdubwlZ1n+cHlN6fedxqYMbK3Lk42+tOBELy/cp8Lfp1/c+/DaKv49s5FrpU2eK1+gUh7aJtRdFLut6skscO1pQ3UMVnzTwJtxNGMFk8IrmNYqeaS0zB22GyUaBsH38uvZ9FNCI5AhlKjqPkxJTdlrdQk0ZJ6UujZaJ+ZLnpCHEyGxBRyv5NFPxm618zJUMlLqHhRp85QcmylLI6Kkf2wyK+97I6jwzwUbNdpNd9GugZZSdBtBxyLcHIS1ceOhkImAu+uwBSBMeTnNCI/4/A05+cJxnyTn6MhtQ6baZnNtIzXI0IRntRDrZOFyFfI6azux1qRWIWv0iF2k2cHQsBKucVKuUUz8nOXOO2fqA5mvFQqJ0JRqiDtGCU4Gc4ML6tFEGmXSLtsw76aQv1RoQU/J8D9DnL9USHbqZ0BlmdrW1TdEPew7mXDhNfkt6eZ+lS8mFbmEaYOvtPKF+YGLqclzBzKU1RGH/idEZ+H2fC8nMNMBcoypq0HZXRSWG6nSzzvT08a//G976Wui3ykeodFNzxEiyaD7rR3mNtbP6QAz2qSEx9yBIteyL9/5St88eH7uBsvsuo3cEVGah1S49BIJUU34Vs3L3P93hqfuPYu50qnE3EzZ0z2NgnyAsoNrIVm6FMPC2yERej0F0UnoeikBG46MbFM9iyWecqwErRZCdpoK2gmHvVuPaEzShwOQj8ZMsriyAxtBJnODXHOqgmEJS9q20x87jU5cTKU05GDO/GeSduwZlhAWKwVve+zHQ+nlgwq4Pfm+bgGp5zhlHeVC9aAjh10csDzZ0EiEBOsX50k+bEHhrx2cVatrmeBx578PNGyNzGpwHU8EuuwkZbZSMv4MiWxKrevPmBC6yuNj6ZSSzhfbhCZfKKcccIrwFOgXIgpF2KSTHF/u8pmEiDc42/rdAaauVGCTiQCi1Imr50z4/HyoJpCUuTOgK6XUCHB7MkV2o0KCaSwLHqHm4CPuy5t7SJTg6cMO7FDrBXFPldBa8ERhkxKWqlL2ZvcbGEX+1vQzpyR9XwOM4F1hKEgEiI7mPSa4kydj/Ld5jluxcuUnZh//uCT/MLlfzd1eybFpJEfyKM/yUlHfzpQ0vK5tdd4q7nCH20+z/lCgzvhIpCfQzP1Obdc5/a9Ff7ta+/n8vIG33PlJiX3MM/L4XGQfPCsQwioFGMqxbxm2L2tCtYKtuMiGzLPDy2ojKKbEnQI0SgJVXKATFqJ3TwhgHbqUu+4x82bPK4LIcBRFkdpfKuxNpccZ1p2TDDmiQzl5gmVjrX2UaSQh2xU/seId8lxDUJaBmrw7Lm8ov8ZEsAQN0ghwQkynOAAKfeQ6ZEAvu/aZV6994idOH+GC47CmfUAfgAmMTsAaLfbT2VvTyqe5MjPKMQmX/G+n1TxREag8mKqB63qFTo1aHC7tYQ6eRpGzbyo6izgOZqrK1tctlvcXa/xcLtGjKJQTWZOMoAR1WzGIY+wZFqSaYXA4jgaV5qZt3F/TaHdqJAjDVJA4OQ1htgTFaq64eGlRGP201b0JlAC2IyKFN06kBMfKXJXKF9o2tnhyM+wu3K7uTjim8OvN1RkRKQHyY8nNV9qPc+as8NVbwNHWoxh5P21Fv75w092XPJgS5d4tXGBD1buHbJVB0OPsbruhzi16E+vBTxf3uBSsMO/W38BiekZNoAAD5YKTTbDErc3lrmzscgHr97mxdWHBy7yzBLTSibPKqS0eI5msZoveiRpXjw5TF220oBNuVuQM5fJ5YTI6bzLuYvkZCi6+f5deVwjKeQ1hdKTjd7PCt2Cq540eE4ukdNGoI0kzSbLFzIZyFN4zXIyVKCZFAbIULXjJlc6KhmaapVw9A8NPBbDCLgd+ANxWJdDI/Y1w5GSv/uXfhSA7VbE51/9DlF6cmVAILe5noT8PJW9zTmEEBOH+fZinsmPnFXY5wAk1iHJHHYyiy8zApkSjCFCeS2hmBox2gra2iPUeaL6WRuspIBaOWRpMSJKHNY3KjzaqmAl+OUEtzjcFGJaiENlaA0ewSJIM0mKRQiLq/L6PrMna4K4I3XrrynUTSAXfVGhKhEL7uGLSI4b66SAREt8x4CA1Dhok38uhEWJfIUvcFNio2imLuUZrOY/bI8eECat87MXrjB4pCR7bK4LKuNGdo530nMkWrCZlPiB2htccrf23dt/9fAjxH1FaYWA39j8MB8o3zuWV2uayA+cbvSni4LK+Ny57/CnW1d4pXF14Lvi+Qh3R7O+VUELybduXuWNe2t8/Ll3uFTZOfbuyVg5h3GL4eif5HquxnNDFsnJUBi7tGOPKFVspgFbcU6GPKkpugmxyaO4/pSOl54yLAdtloM2xtKrJ9RI/T05imcH+eLf6F5uICrkakyXDB0gkYubBYQBf/F0C/j2kyEgrzXo7VprT0uGJtm0K4sbKXvbe8xh5GcP1zk8+YGPXVnjsx94jv/1W9e5/mgT1XcWC6UC/9GnPnq4Yx8BWmscZ/z0v9lsPo38PKmYZ/JzshDExiU2LtsdIlTsEKGDNMBKWCpOTMXJk+PDDhGKjYM9AzbUAI4yWBQFL+PyhS0urW1RbwY83KywdbOCUOAWUvxqguMdrpOcLU0VWCtIMklCxyhBaZQ6ntoYB9UUWvHDo2vAx5CJULv4TpwnqQp4FJY5V2wSqLyyuUXgyHxi1T4E+RFD2r+TjLbAP8rqfUWGbJhB8lNVITtZgBSSB+kCjjR8rf0s152LYC1V1eaSu0WBhD9pXNu1Y+1QRy0Uv77+IX5i9VuHbtcodHN+JiU/QoBHRmJPuY6REHx86RbvKT/i1+98kBAP0ZmFubWU84VtNu9XiHCJUo8//O57Wa3u8PFnb1Dzj29CeZj471nFsPemi8BPCfxdo5x25NFOPKJMsZEGIBSvb55HCkPgpPl/XVfKCY0UpGCPPM7Jo0KpT5g5Z0dxMGX3KAVIlS9u+VZjrOjlC2kjsB3HQOucbi2kYbB0I3M5GZLC9BVdjSh5yUxkcrtagOHf9hMjmyiyHYn0NMLXAxI4tyGwl0PEIcd1rKAa+Pzlj7+fv/zx92Ot5bv3T79u5KSytziO8U+4/tBJ4Sn5GYN5zvkRIk/KO/kOcJcIbWWWgswoqoSCPHjQkgJKTkLJyZ3FQuMSapdYO5hTJEJKWCItcTq6XyGgVgmpVUKyS5L17TKPNqrU71ZBWBxX45ZS/Ep8LBK56dAxSsgUZMdjlNCP/ppChSzmudLR6vpMEg/TRhJnqpeD0049gq4DIbsrgIGTkRhFK3WnyuUY9sjmtt+5v53d042OygWaBJ7QOKRkfdEfKSBQaV5bqxMjbGmPihMjJDRtke8mRf7g0bXBl73v0n2rfYXvT69Tc+NDt20YdiM/k5+zR257PU09pOOBoOrF/Myzf8or9Uu81TxHK/XIrET6huUrOzTulqjrAiB4VK/xm698iBcv3uf9a3enjkpMggW/TZ35HXP6MXRFfdh2Iq8l1K0npI2gFfq0U5fIODQTj1a6OwHrulJ2SVGh86cz5veKbkbRbXKeJqmWeZ5Q2nWPO8Vn8QhrQ0Lk45OSdkAipyqWsH32p3fG9pOh2gRkaIKL1a3RM/SrXD4o9oSFbKzQoUJai1UG0defOaWMQ1fCMINGBkII3ndh9ZAHmx201ig12UlNQpLmEWf/7ZgBjiZ7m98ip2dj1UcQdeqwCCwFmVJUKYURxVR7e4ncQrtrox1plUeFjIM5YXcfISxZH/nph+MY1lbqrK3UaYUejzarbGyWCbcDwq0AIQ1OOcUPEtzC0YsCHg1dowQF5DbWnpMdG0F7rrI5w1W80RACNsMC3b5cSngUljhXzK14u2TElQZXmqnJz15sRflkuOTFXClt8frW2mB7jxD5EQKqMmJzT/SnpkK+naz1SKunDFtpwFLHSOJ2u0aovYHnK0PioHvH/dWHn+LnLv4BEovAzuTeTJPz00U3+hOfdvSnAyHgI7XbXPC3eaV1BYugERVoJR6VS028jYyNZhkrBCC4fvcCbz9Y4aPXbvLswsZME7orXkQ9eTzIz2EjvkpaqqWIKrs1hXpkyCqslD1Xyq0el7e4UnfyDncJ0SiC6irDchCyHIQYS15YNc0lcmdVHjcJehK5UkKxmGChFxXKzrCLXBejyFDVj6j6EVmW19vp9nNTj6e9R3LIIpEgL9weq57hgbAcnvgAGEG5cPYsrCchP4edM88LngjycxQ8lb3NDhZBaDxC4yGwnfyghMKIYqr9KChNQYUskjsBtTuDX2rlscsXhAA9gVV3KUgoXVrn6oV1tuplHm1U2GkEpJlD2nKgkYf5XS/DLyY47ml2LoLMKLKOY5yjDO4MHeNKTsSS157NwcYgn5MO6uY3o13yA/Qc0wKVkhpFK3UouZMlme6NPt1uLQBQKcS8t/aQN7ZXByZMR4n8APgiQ6EHLHx9mXHOa7KZ7eqvE+uQ6Twy9Hr9/L53aC8J28zK/C/rH+fZ4gZVEfK/PPgo1kp8meHLtPNnRqH395SCzPDE4Gf5NhmezPI8PaYjPwAuufHB6Ud/uhCUO8/sThxQ9iJqQYixgqbrUwrbPLi/SGTyiUymXf7kzee5XlzjE8+9y0rQGnP8yXDUZ+cs4SDZ2zRwHcNCJWShky8UJw6tyKOducRWdZKLBKlxSBOHerJbL2tANteRzvlONkBYpYCqnyflA4RpfoxG6hFm7tmRx00J0cm170rkbJ9ELs1UJzfxbJ9bPxm604DoQQHH13hBhuOnOF5epFiIXYlfHu2f0XkdlQebs1m/Z9LIj7V2bp//cXhKfsYgUI+nx/lpwyJoG4+28ZAYApUSdCZW4941T2o8qcGNyDrOceExOsd1Iz+TQkpYXmiyvNAkThSPtiusN8vEuBgkceoRb3tgQUmNV8iQ3vFFYA5GxyhBS1KtECJPrD2qY9zzlY3ZGEGIyQayvavMFkEj6Q46opdL4SmDk2laqTcF+RnEelRGCo2nNL7K+MDyfV5ZvzTw20dBHv0J2TKDpgoXvB02s0rv6K40bGRliirhuco6d9u13uR81HHfaa9yrtCiTYGPL92mngZsxEUexpWhtbvGwZr8ut+NFvj99ef59NI7E9VzOmvRHwCswFeac8W8xk+YuewkBUpeQjWIubhYpxEWuLm+QBz5xInDTrvE77z6AZ5ZfcSHL9+m6Bw+ovhuY5Eo8QgOss6dIxxXvRffy/C9jCXyRY0wdmnFHlHmkKAGnBaMlb0inV3slc11I0Vd2VzgZgRuk/PkrpWNOJfHNRJvvyfyHGGURC7ruMid9ahQDknadkjb/XkoBlXI8IIMt5CgPH3gmGG3XGxJIzyTj1EHdVdHzleFSuHs5cxMQn6MMY8t8YEnhPwc5QZ6wkOiMMxe330SUKLfzvVswiBpaZ+W9pEYiiqPCHlivEzMkYaqjKn2nOPyiFA8Q+c4ISxaH24JyPc0l89tc/ncNjvNAo/qFTZbxdzMQYBGEUYKQh9sXrPHLWQ43mlI5HKjhK5jnBQGR5mpHeNqXpuaN6uk8MkGH0cZMi1677oQcL9V5XypkR/Fit5AFjgZmVW0U2egJtBI7BkAG4nPQhD17s8L1Ue8tnGezObd6WHd3vpREGknn2j3uVt02ngi3XdFHGG4UtzhcrCDtpJ65vMwKrMe7nekEwLeaq7wQmWdQGUEqsH5QoOX7ANC4/JOfYm7Ua2X/D8eu7K3L289x3caF/jB1eu8WH44ds8zF/0RYqCmUndiDNBMPBqpT6kQUS3HFM810EYQRS5h5POwWeHXv/khPnT1Di8sPxybfzIMxkoi4RDweJCfSXN+jvQbAoqFlGIhv0/GQDvyaSW51DpF7Bv/+4s575fNpQPSOV9ploKQpa48riONayT+oRYLhp/EbA4z9c/2u8g5eW0hbfOo0JmtLTSUjEh05BFGHiFF5FI8euy0oB652LqHxWADgwxzkZsJhhmOHNGDdY5lb2EYPrYFTuEJIT9HgRCCQAW09OlU/D4qzsi0YmIYJE3t09Q+CoNDbqNcUuMtMXPnuISKk3Sc4zqGCUd0jpOCqSI/o1ArR9TKEZmWbOyUeNSo0Eo8oKNPEAJt88RLWjnpchyNW0hRJy6Ry40SkkwNOMY5zrB2GBbdNltpPtm+Vt6YYSsmQ/5sDG6dWUWiRaeFAtUZyHylaWeGZuZNRH76j2pMvhpc7KsX5EnDh1bu8fVHV3p7TFuYdN9vCqjJkO2+6I8QcNHb5m6y0PvMkZbtNGDFb+eTGWFY8kKWvJAvRcMlu4+SMlf0Jn5fDls3x04aWC20WG+XwJn+BOpZwL++9xGeLa7z51a/e6D08axFf4wVGCuG2vSXvYSylyfkl2TCVlKkZV1KRUupmHT2h824yO/ffIHlYpMXFh5R9CYnMo7Uc9dfH4Tjivwc+JsSysWYcjFnNVoLmpFPmHhERpEJOeK97JfN9R1viGzuQqnOpTKEmUO9ExU6ijxuVvLAo6BbW0hicVWGtfn7kGlBps+QRK6YQWYhFfl/+wjaGIc728kBBwQSwo61vLH7TBAAZFNS/GKJ7EJGdjHFLE7p+magckbJzzir62az+ZT8POkIVHFuyQ/CztpH+cSgkbQyj3txHhGqODEVN6LiRGOlNblzXErJSbEWIuPQ1h6xcQ4VCZsF+enCUYbzSw3OLzVoRx6Ptsust8pk/VXNJR05mkPadMCClAbHzXCDk5bIHewY9/7aA+6ENay1rBRaVNzk4MNNicM+vkLAVlTGd/W+mg+Bk5IlueVt4Bw8Qe0fS++HFQI3GyisCvBcZYNvb66R6NlN5AORsoMZKGp4zqtzN6kObOdIQ6Il3h5DjlERFSngtfoFPrp4Z993Aovvai7V6mw2i7StO0bpM/zuvNte4R/fXOLjCzf4zNLbI9/XsxT9MVYMkORRWChELBQijIXtOGArKRJqBykkQSElKKRoFK8318gyiWMNFS/mXFCnVhjttudJfSYmwrPCaZCfvVDKUitF1Ep5JLpbbLWdecRWjl0Um0Q2t1Zs4khNO/NoJD7N1JuoEOlZRr9Eznf7JHIH1BY6CXjFlCw1aMeBAtDY045x3cioR1Lsfi/6DiIMyLbEe8vDe8vDFM10RMiIM5vzM87CutVqPSU/Tzrm2u76tBtwRHQHUINkJwvYyXL3vUAlVJ2cCAVqvHNcLvHJJ7mxVuykPinuxJMubY6nsy8WEp5Z2+SK2WS7UeJhvcxOGAyGDTqLbgZJknokiXeKErmuY1x+Pd6z8JAlv83t9gIWeLa8OeNfY2ydny6UtPskZ5lVuEbvu8++1LSloZF4Y8lP/4h5r1WjWtgv6XOl4cPL9/jqw6szW2sQAioiom53+x9fahadNk2z+5kUecRlRU2edB8bl404YNkPB3+T3bNdKrcpp4r1dgk7Igp00J3RVvKVrWt8p7HGD61c58XKfincWYr+GKZLlJYClgohS4UQbQSbcZHtpEBsXBAiL/br5hOkJj7NcJWsIRHGUnISVoImK0Gr9+4+bpGfk5C9TYu9xVaj2KEV54sgMXKinJ5xsrlFP0QbSWpzC379GEyzBiRyNl9Myozs1RY6STLkOAaddp4tY3uqCQAOeOasZfRYMurjPfymnwhdfE+Fe7UdGtUQyiOIkGVuZW+tVotyeXQx73nH/L+VE+CoSVtPHd9OD6PqvOTFUD0exFUcoak4EVU3ouzEQ2Ur/fCVxtWWihOSGEmsHRJz8MA3idvbUSAlLNVaLNVaJKlifafMw3qFeFgk4UxI5AQrhTrPVzc6rkIWV5ojJXwP/xk7MZlQ0qKzQXcaISDKHKre4Ip7V+bVMD5hpgic0Tl9/b3HZlxgobQb2ervWp4tb/DqxqDt9VFRlHGnzszu83fea9DcI2lzpd4XxTqI2AsB1xvn+bT37iDP3hMi81zNxW4UyDgINX1f2sgC/vX9j/BMfYMfXn19nxQuj/6oU18ttx3Z22GgpGU1aLEatEiNZDMqspMWiM1gMU2nUyk+wuV2vMiN9hJWCwoqpagS5jZMvwfaMlML8ONCwc8o+Pk7019sNdQOCdM4ie7K5vphjcF1TCdVJZdk6T0WYnNwmQbQlch50vSME3KJXB4VslM6P04DYyRppHqviaBTxkR0snUmuJjTvOLygFTvv/F9L/NDH3ueV965z6987ev8aXib7XJrkAgZQeUMFgmdlPw8jfw84Zhn8jNJkcizjHSCpNLMKrbSEltpCYGlpHJ5XNWJDihEmHdQnjR4Mp/MJloRGYfUiH1EyOiTG6I8V3NxZYeLKzvUWz4bjTLr9RJmVMGBU5DIFZyEj52701dvwWIRxJnCP4BITItZXHVt5dBJbS/3J/EJnANsuft2dQ7w0XCk5cMrd4FhibOHg+xEfxp90Z+qivBEStIXLRECmtofJD9jRnkp4atbV/hg7S5B5z2R5JL6vee4VG5TzhTrrcEo0DS9y432Mv/45mf2SeGEAJ+MyJ7uCulRyE8/XGk4X8yLacZasRGVqKc+GYq9T4VSFpQlQ1EnwBi41ygjLfhORtmPcdT89eHWyDOZL38Q9hZbNUbkErnYo60dtByVLzQaxqqBZ0pYixS5G5nokKHTLOA9C+xK5DSuo2lFxzzZ7+YfDVvkHCe1HFn8dAQOULYFft7/fvjaGh++9hcAeOPuBr/ytW/wx80brBcaYODN179NeG6V5eVlqtXqmSgaOgn5aTabTyM/TzrmmfzMO6adjFgETV2gqQvcAzyZ5fI4NxowTZCwLyndU7l9MeTSuNgoMpPrwo9L9jYO1VJMtRRzdXWTrWaRjUaRnbA4epX8RCRyhs+svTsQYVMitw19t7XEe2uPjvoDh4bskLB+KJm7de01NxAid35rph5RpiiMIG3dBYREDxodDCsC90x5i1mbdRVlQqMv+iMErLhN7iaLA9v5StPMPMpO0mnf+GOnxuF64zwrfouLhR0gz29znf2jvufkUaCtZkDLulM4wu1iVwp3gR9cuc57Kw8AyDPxTteZ0nRs32cJX2kulupcJE+Q34hKNDJ/3+p/F1LmDpHd9uykBdJQgclzgkp+jO9OmXR9CjCGU7Lunx2ktFSKMZViTL3t4zqaRlgg1MNd5IZjvwW/trvTrh4ZMnnXLYXtkKF5iwedDPb3aYMfHMgj+wJE+zBK9nbAOl6xsF+V8Z6Ly/zXF38YgNvrO3zx1bf41Mc/yM72Nvfv3+f69esUCgWWl5dZWloiCIIDGnx8eBr5eULIz5Flb09zfk4NR21/YhzWkzLrSRmJoezEVN0IsEhrcfaKejvwlcZXubY5MYrnzj861cmZUpaVWouVWoswdtluBWy1AtqJjzYHdGLHIJH71NoNCmpwhq8613FrxtXp+3NQJoGSllTvL8zWzjxgf3SnoDLamUsj9SmMiP50j/RmfaVndDDy94XFOt3Jy2xW7JWwlERCy+4Wb1x2mtxNauxdXo+0S0kleX2kCd4eJS2tzMdRUG8GCAyZUbgHLHkulkPKWcyjVhl7yL61kRX4N/c/zDd3Nvjhc6+z7LXxTjn6Y0ZECGeFwMm4XM4JZjPx2IiLtLSHOaCSohB5JLiLlvHZbkqMkbhCU/QSAm98bbSThrECOeeqg35IkRuB+G6eV5dmknpYIMzcKeVxg9hLhrAWhQZrO1237ZgynLEbPAKTLLgcHWLoX/N/j4v8jLmOe3YfMT0AoDjGyODySo2//oMfA+DcuXOcO3cOay3tdpvNzU2uX79OHMcsLCywtLTE4uLiRIVHZ4GnOT9PCPk5KuY68jPHbm8wW9meQVLPAuod0wRXZlScmJKTjCyuKkROhJ5d2sRaiI1DO/MItXtqRCjwUwI/ZW2xTr0VsBN71KMCSeKRpupgj+UjSuReWrzH0p4kedjV92sraaYuZXdU7o/FExkVFVGUMb5MkcD16DzDdTJ2KpH2qFMXgqF1fYTI6xIlmTxAspc/g3UdTCRB0iKXTxbV7PKfSjKipX26o70rDQsqZFsPrsx5SlPPCtTcaOI3RwrbcYsD60mEtmOtul3H5FGgVkCcOthDJnjcDJf5xzc+w8cXb/LppbdPdYHBMBvZ2yTot87eiQtsxQEt7U1kyZ+bKOzmDjVDH51JlDAEbkrJS0496pLnfcxnbbxhkHsWPVzHsFzJF0syLWmEPu3UI0HueXGmXQTZT4YcDLZHhsxckaFZY998oHt5DT3Vw4EY6fY2/IuDIj9d2ds0EEJQKpUolUpcuXIFYwzb29tsbm7yzjvv4DgOS0tLLC0tUS6Xj63I6FPy85T8TIRAnU5o8ik4VuvX1DhsJg6bSQklDCUVU3QSik461DRBiDxSUOjUQYh6RMg7FateIaBWDqmVQ9KsyXarQCtziVKPOHGJ4zFudlNK5C6WtnmmsjWiLbbXphutJT6w8KDzjcUXKWUVU5IxgUoHom2ZgQtenQWnxbfbl2mZwr5jT/sEjCKxG1GRolvf992K32aTIutRgWUVsjenXwCpEfuiPgfYCXA3XeQFNb7Q56RwhCUQCaHd1dOvuM195AcgsxJjJr9uQkA7c/FUXhzQcwzaSiRmbNL6Yimk7Mfcb1SJh+S0TAKD5E+2nuU7jTV+bO1bLPqzKpA7HWaV8zMtan5Ezd+1zt5OAtranch5DHLrfKdjc56i2IiLZKlCYil08obUCecNmbOvzJsKB9l2O8qwWM4d5LQRNEOfVuIR28O9D4MQg8VUbV5y3dqcCMizRoaswGQCObQe3AwOv+889+jYDorMd7+aVPZmx0R+hsjepoWUskd2AOI4ZnNzkxs3btBqtahUKr3vPW92UXGt9djco1arxblz52b2m2cNTwT5eSp7m1+clJxD2/6okCVQKSUnoeQkeEMsX/rts61tE2mXts4jQqdBhFxHs1prsQo0wzwSFFckaeYSRy5x4hwsj4PhEjksvpdwYXGLDy3fHR1Z6Ztq15OAZacxlOwM+0mAokz5eOld3o2XuZms9L45zP1XwqKHTGKNlaRa4PZNBH2R5DJAaSgoTTtVBJ18FyU6BfME3GovTtWWdV3lstmiIGcX/SnLiFDvkp+qE+GLhHiPVMyVhu0smMq22ZGWVupS6kTspMhX7zObF3o8iAS5juHK4jbbrYD1KDh0skczK/Avbr/MX7v6FSru6Ho4xwVjZ5/zMw0GrLOtyB3jkgJRxzp7UihpUR0HM41gKy2QtXOHLE9pKn48NKdrljgNEnmckGPqynWh5G5dIWOgGfm0u0RoJvZ3ef/che6QIdMhQ+qUyZC1gvhhCeEYpJ+hfI30j55n2otEd7tuC6LpgBGdBN7O5wf8jkWMNjwYsd9Bt714iMjPOPi+z4ULF7hw4QLWWhqNBhsbG7z66qsYY1hcXGRpaYlarXZk44Rx+7fb7aeRnycdcy17m2fNG6flVid6VtrrMbgi6xGhYTWF8sT5vOCdsfSIUHRKRKgcJJSDBG0EO62AluNilCBLFVGcR4TGyuOgJ5HzVcLHLtw5cOzuXxm1QpBmkkpxggms2B3YpLA8V1hn2Wnx7fYlElwEk1td99oiLWlmkXvOTwhYD0tcKHcLFluKbkL3Kat4EetRGU9FONJgyB2fjLFsJqUhA+sBNSUQ3EqWeE/hwchtpoUrDD4xMYPRnzvJ0tDthZ1ugpsZOZConluY56SRCaJAC6WQciHmfr1ChMNhJ2B/tPEcn1v7zqH2PQosZ2fSrsQQ6+wkILZq6sU8KcDzdhdw6plPGimMthQcTclL8d3ZSdQadZ8odQiCGTt/nCL2yt4m2weqxZhqMcZaaEUercQnMrMiQtBPhvLnV6Ks6fWaSuQy0uOST+1FN+fHZhKdeegWICzS0x0ilCEPkWeaxgpjxC5LsSAShZWWPt/r8UqRKbMARq3bSSHwveOdPgshqFarVKtVrl27RpZlbG1t8eDBA9544w0KhQJLS0ssLy8fi3HCU9nbU1CcY/JzNobyw+MstD+1Dtupw3ZaRJDXsik5CSUV4+wZFKWAopNS7BChULsdIuVy0mejpGWp0mYJqDd8IuHiBppyOcYYQRw5A/K4fcmqndoUn3k2d3br/3rvmexNbv76zhWuFLcnaKXAIFB9+9eckE9W3uZ6dJ56cn66wgwj2tdFbBy0tkgJJSfpbWmBkpuyFWu0FQgrkVhcaXMThyGTh3GtWtcVLplNijOM/lRURNwX/Vl2W9xNFva5/znScqlcp6EnHxSVtDRSn5o/SFqniQI5ynB5cYeddoHNuHCoAo/vtlZ4FJdY9Scv2joLGDvkHTgD6FlnF3etsxupT3pImWHXRCGxEsezxDg0Qw+t87yhopdScA5volCvl1CLyfgN5wTGHJ2rCLG7KGUthLFLM/aJzOHz5Ub80oCToOlFhk6GDA2NNluBiR1M7AA+Qhmkr1F+lkeFJglgGIHN1O7jPuo9Parb297jjiA/x018hsFxHFZXV1ldXcVaSxiGbGxs7DNOWFhYwHGO3r6nVtePAY78oidz7tk5zzjGnJ/DwCJpZT6tzAcq+HJXHrfXNEEKKDkppR4R8mhnHpE5/Kr4JDAGMp3bdGstybSiHbkoZZAZtBouceaSIbBGIqzFGnbrJ/ThM8+9RbUQd869+73tKK1H35sHcXVs0nwXdkhSsCMM7w/usaRafP3RpWlOH8hXaocNxFJAK/O5WNru1JnpkJ/OthUvZjsusliIcgmHFsTGOeTtEtxKlnlv4f5hdh4KTxg8UhJyyYUjDItOm81s/yC1GrRotTzMBLWyupDCkmqJqwZH/WmjQLViRMmPWW+WCa2DttNJcf5k8xl+7MJrE28/C5hTyvmZBl3rbJjMOvsg9J+q65ieFC5FEcYuWSaRwuZRbTedXM2ojzdX86RhjEDO0IRLCCgWUoqFfFEkjJ2cCGkHLaavJTTm1/aRIYnBmg4ZkhYzsW33bGC1RLcluu0CFuntSuSEa4bnbLYcaCvwLXh7Ehr7t5/guesVQ7DsDlBT5vwUToH89EMIQbFYpFgsHptxwlOr6yccDx484M233oLaabfkcBA9oezZHtRH4azbpcbGJU7csaYJORHKSZK2glC7tDMvn1gPuTfW5i5C2uTkJdOy85/qfNb3eWcb3dnGzKjC9ovn73NlYZjBQTdasrtcdj5odiIHBRqdgo7Xm+d4b2V80r+xYuTjuebV+b+++Fv864cf5p1w8uRLJSyp2W95DbAVF3mmssmwH624Me3EIctsXtC0kwdy2LdnU5dpaY+Smt1KeEWGbJhdvfmK2xxKfqSwLHlt1uPKxMcWAlqZy4IaLlmcLgpkWas1qLd9GplHah0yMxkJutVe5kFU4XyhMXHbjwqLONU6Q9Nir3X2ZlykOcY6ewAHdK39Jgoamdcb6pgo+E5G0UtQoy6VEXN0FccjJz/HNw4FfkbQydGKU0Uz8gkzl0wcBykR+fPROayxNndYNHlvLqXNbcoPGY2aPnIqMInCJIqsAaqQ4i0N6XusQCIhBuJ+A4h9hxvTQIEtWDprOKAtwozeadQ3wSmTn70YZZxw8+ZNms3mgHHCpFGhdrtNpTL52DFvOFt38BghhBhalHAUjDG88cYbNJtNPvOxz/Drb/3qMbbuKUbhdHJ+DodRpgm+SElSl0Qrkszp/ZlqRZw5hKlLlLmk2umRnLHmBMeMlXKdj1y6NeEqpMBThovFBpBPVsPM4VFWZTVrUZIxnhgto8knnKNzDgKV8lNrf8qrzUv8+qMPMknp+IPa7cnRuQhSwEIhJnAytBFsZ4UjrsQKbqYrvKTuHuUgA/CExiEj63TfZRVTkDGR2V9ZveZG7CQBqZ28q3ekHWoL3kU3CmRtx5h6zPWpFmNKJmGjWSJzIdHuRCToTzaf4Scuvjpxu4+KPPJzYj83UwxaZ/s8CCtkVmG6jh1DME0+Yr+JgkXQSAukmQQr8FVOhro28FaLxyvyc4K23XktodxCO81kXlQ1c0jFcUnVdslQnjMEEoPW+f3rRtCnIUN5LOmQ9HfEz4xNX+yGcg5qZl96EJAPI7KrY8jhbYNxwPgHq60PY3N9khhmnLC5ucmrr76K1pokSdja2jrQOOFpzs8TiDiOeeWVV1haWuJjH8uLVCnhoO18JnDuFxXND+YzXgX9pgmtpscbd9dOu0ETo+Ak/MB73jiSzj1wMgIn6yXjK3QeFZMJJRlTkEnv+GaCuywEfKhyh6vBBr927+M8SqsT7TMMz1Y32Ptk9U8EXWkQWDxlc9Iw4jiTzkW2dYmGLlBRs7FwFgKqMmTT7K7KrTpNbiX7yY8QsOy3uB9NF7pOjcKYg+s+iSmiQEpazlWbNEKflgXrCBKtSPXovJU74SL3wioXgv325MeBPO9tfnucLmp+TD0OuFDeIsoU9aRAK/NI9uaXHGFQkNLi95koNLVHGqncLtw3j5XV9WkRYtcxLPXVEmqGPu3MJd1XS2i2MMjeK6n3kCEhxMF9grSU1lqYVJJGLlnbQUyjRBhFmid8L8deljEimMImuB0/nIPWH2dhc31S6DdOePbZZ2m1Wrz22ms8fPhwwDihUqlQq+2OE487+XmcotMzwdbWFl/96le5du0azz//PKITei7I+a31M0/Rk73IO9r5bT/Mm/7d8NmXvtPJh5kdNIq6LnI/XeCt+DyvhZd4O1rlYVplMy2RTjhA1pyIv375j/i+xTfGbqukoaxCRF/WalHFFJ39BgT9QWFHGsLMJcrUzNz6biXLMzlOF77I8krwHSy5LeSI1emym+DL6WR3XfODcchd+jpRoAkmKJUgZrXUQmlLwUkp+zGuyhj1jn9l89mp2n0UzEPOz6ToTtgLjuZcscW16hbvXXjE1WCLBdXGIx14L44KKcD3NAU/Y2Gthe9qtsMCG62AnbZPks3vVMPOSEZ8FDjKsFAOubhQ53J1hwUnxLNZL3fnOGGQWKHQKNrJwbVmtJa0tgOi0EO4hmAlpLDawq1FoMZHz0aaH4yQplnsSFOC/dsekN/T/f2+Yw2pcNFD4M+u5s5JQwhBEAS8973v5eWXX+aFF17AWssv//Iv89GPfpS/8Tf+Bv/8n/9zsizD98ePAZPif/6f/2c+8IEPIKXkq1/96syOe1g8MZGfcbI3ay03btzgwYMHfOxjH9tnHViQAS19cvrzp9iF2E1RnEscVCDvrOHPvucNSt7xOzVZJC1ToGUKrGdVrscXKMmYBdWm5rRZUO2RNXKUsHz/4pu8p/iQf3Hv47SHFEaFTp6Vl3LRb2BtLkssOTGTxBOFsGwnwZiVxMnv644psqMDaiqceJ+DIESe+7Nt8pU5JSyLTpuNbLhGe8VvcSecznEwNz8YrIt0UHusFWRWTBwFaoYeTe0RuBm+k/Ukof1tvB/VuB0ucDnYnrjdh4WxcqIo5DxgVH9ZdFOK7u571Ug8Gmk32V4gJiysOg5dR7kuMhRh5JJpiRKWgpviO0ev/3ISOGsOgL1aQuS1hFpRX1HVmTrH7cEkCwMCEBZrJGmUR3/AIpXFKadkO4ID19xHWIqPvgf9+aLjba7HbSImVDeWgvmJ/OyF1hql8rBWv3HCf/Pf/Df80i/9Er/zO7/Db/3Wb3H79m0++9nP8iM/8iN87nOf4yMf+ciRagt98IMf5F/+y3/Jf/Kf/CezOpUj4YkhPwchyzJeffVVPM/j5ZdfHnqD/bmO/Mw35lm2B/MT+fngxVucr5yMxGg/RI8M3UlzqZwvUmqqzYLTpqbalGU0MFla8+v8wtXf4wvr7+fbzctDj1rvWDcLAQWZdojoEIOJPZ/5Suer5wetEk55hreSZWrB7Sn3Go1ApOygsZ0E91W3OZL8BE5GUcW09XCiOAy5+YE30vxg2PbdXCCNHTD8GIZykFA0KevNIsKBQpcEdXLiuvfkT9af4fKV7YnbfVicpTo/R8Wk8r2Kl1DpLHYYC42kQDP1iI3CiNnKq/od5QySRuyQ6txRzncyCs7BMsvTwlmWQkoJlWJM5VhrCeWYZBQT0lBaijCZJEskaeSAlRjdiTOWNGgDsRwqhxs5Vo40JbA5KZvVqU4YRSoV5jfy009+9iIIAn7iJ36CH//xH+frX/86//Sf/lO++MUv8su//Mu88sorfOQjH+FHf/RH+fN//s9z7tzkBkQAL7300iyaPzM88eSn0WjwrW99i2vXrnHhwoWR280z+UFMWdnrjEHMefuPczFuVri0sMn71+6fqZXY2Lo8zGo8zHIdskJTU21qTsiCalFVIZ7U/MTqt3ipfJ/P3/+efXVlUtP9t8WTesChrn/EHLayWHJTmtnsjCcaJmArK7LotGdyPCGgKiJ2bG5HWlQJRRmNjISt+G1utj2mUTuPMz8Y1a5Jo0BSWs5VW7Qij0bqIR3wHY2ndI8EPUyqvNtc4tny5sRtOAzyOj9n6AU4Ag7TXUoBNT+i5ue5adoI6kmBZidfyIgZlI3og+MYHKc72xS0Uo80U4DFV5rAm8Je+xgxL0PPcdcSsmP8BPrboVyDcg06UZi+aIqQgLRYR2PbIMzgDRajismO+FgoYCnObbAnuFHjphKTR34eT/KzFxcuXOBnf/Zn+dmf/VmMMXzjG9/gC1/4Aj/zMz/Df/Vf/Vf80A/90DG39vjwxJCfYZ323bt3effdd/nwhz88NrHLl5OvmJ41zPtwPu/tt2c88lP2Ij5z7e0zRXyGQaPY1BU2dR7dEFjKMswjQ26b/9PVP+DXH36IW9Fufo0QEGlF1YkGojt/oXKbP2ytUu8QhWEyoZKT0MymIwvjcCtdnhn5AQhkQl0HvSKnK26Tm/HwvspTmqobU0+nW8iZxPxgL6aNApUKCYGXsNEsY5zcorxLglKt+PKjazxT2jzWZ/SxyvmZQa+ppGWxELJILtVMjaQed8wTrOq8FrO7XkpZlNol2a2sQ4YsuEpTdFPUMVpOj8QcPhPHU0vo4J2GLSAZ3bdP/1/FCCnbkD7GWqCosYmETOwrPCAlUJ6QtXR/c5SJzRMe+enfZq8CSkrJxz72MT72sY/xS7/0S0P3++xnP8v9+/vr2v23/+1/y1/8i3/x8I0+Bjwx5Kcfxhhef/11kiThk5/85ES+556Y48jPnGOeDRsA7BlmFRLDD7/0HdSoFbczDIugYYo0kiK3Op89V9nkmfIWrzfO08wKRNphO/ZZ9Nr0j3gfDzZ5wa/z/15/P6NGQiEgkBmhGT7QHeautkyBzazEktM6xN77IQWURUTDFgFYdNrcifXIopdLXptG6vfI0iRQ0tJMPar+9Llg+aMvyMwkUSBYrTZpRR71xEe5Ns8dcTTaSt5pLPNcdWPqNkyK3OPv7L6r0+A4IliuNCwHbZbJyXvccZJra5fEKsSMQ9xKWpS3S4ZC45DGDsbmbem31z4u3L27SFCcTPZ5ltFfS2ijXqRpp09ktza33w4jB98btRiy+wzkjn8jjAq6BUb33L6hsjcjEJlAFDMoGGwmIFQ5GZpm3LKgIqhch2QBkhpkZehVATBMXNFtntze9mIS8tNutw9V4PSLX/ziYZt14njiyE8YhrzyyiucP3+el156aeIwvjvXkZ/5m9j2o1endU5xlnN+/tz7vkPBmU8L92EIO4P6c5W8OGtq8iKwUli0FRgEJZmy5kRcFPCD5bv8bvPSyOer7Ma0I3emcp+byTKLqjWzKEZJJjR0AciTyZfc1kgrcEcaFryQrWTKgU1ApsWhJ5tdR7iJo0B+wqNGGSNBqbwPeC28wLOVjWOTkT5OkR97QOHGWcF3NKt9JL6dujTSboHO2dsx545yu31VbBwaicJogaMMgZvgObPta40RqOBkavycFA5L8G1ncSBKPdwJ8rOsOUTEfBiZMUCo8v+wCM+CrxG1FLwp77cFaQSFzdzW2gJZ0ZIsQFac/DCB93iTn2azeSjyM084A4rak4EQgkePHvG1r32NF198kWeffXaqCY03x+Rn3jHv5E2e0ajKx6++w3JpdhKsswhXGgInw1eaopNRUikFoVnXOUn6i5U7rKhw5BOmpD2gKOrh7mtofTb07OonSGEpi93V6RWnyUFtW/RC5KTi9t5v0JEAHh65FE6QGTm2dooUcL7apOomtKI8Mb6eBtwIZ2sZ3o9J7brnAadRZqfoppwvNnm2usULlQ3WvDolESONPpZiOULkRUGDQobrGkDSSlx2Qp9G5JHqGUxvzONVsBVyQnco9F2GSaZOA5K3A47Vj2E5P4NEXkAioeHCIx/u+bDlQCgPfOi7Ejuxp00CcNuC0l1B7c3Jr0vwmEd+Wq3WzMnP5z//eS5fvsyXvvQlfvzHf5zPfe5zMz3+tHhiyM+dO3d49913+cQnPsHi4uLU+3tifsnPvA/n8z74yEmFxCeIayuPeH5l/bSbceIQAnaMx99df5E3kwBfWn5u+Y2BKt97UXETZh16vJUsz9RCtyRjuqN/oFJKcnRBVSksy970pNeRljA9uligFwUyYuw1KPkJzy5so7RlJ/T56vozx0ZQDI9R5OcMnEfZS7hQavBcdYvnKhusug0CEqQxM/ePttbmhVcdTclPCbwMIaDdT4YOUWvImvlffNuLwz7j/VdhGPnZe5UGSYudgDCNcFQ4iKwZAW0HNr2cCD1yoaEgHbaPmDinZxyK/uNPfmZd4PQv/aW/xO3bt4njmAcPHvCFL3xhpsefFk8M+Tl//jyf+MQnDl20yRGzK/Z00ojNfKsbT38YPxrEGdPtLRSbfOLqjTNvcHBc0FYSWoffaK/y++ECV5yQn129PnJ7T+mBgqJdHOX6RdbjUTZcmnYYKGEpit2cnNVumfIRqLoRrphe7pgY1dHyHw2i4xym7fgokBCwVmtwuVynnhR4vT6dxeqkMPbxyfk5ayQud5KLuVSu81x1k2ulTZadFgVShDEH1uCbBKN29/rJkOwnQ5MVXrVGPHb95KHJj90TgRl2bJ1bXFszJsI0rA1iRJ868aMhIFFQd7EPPcyGh2k4eY5Qd4sZKRgf95yfJ0H2Nt+z4ingOA5ZdvjcBneOIz/Wzlx+faKY95U3IfLV9rMwIXFkxg+9eP1QhVfnvdgs5Oob25fY/o24yoPM47OV+3w7XuTdZDghKTkp9WywuzzqU3k7XWLFqc8sh6UsI9raBwQLThsVZ/usv7sQApb9Fvej2lS/cRTzg2HoRoEym+cCHdRPFf2UZ7wtXt+5wAuVR3hythFVw9kjDYfFWS/WOtpJziW1DnZKJ7lJ75vnaDxndwbcThwynU8EfTfFdwafKavl3I8/e2GMZIQfytGPrSVxy2di3+m+ezzS5vqwMj0jIFL57m7nvs6oywiegMjP405+npjIz1ETlq8WL5Om000UzgoOM9E9S5hn4taFnPFE7XCw/PmXvoOnHq8E3mmQdQrr9a9i3tMFfq15ns9Vb+IMifBAns8gZpxJ0a1jNCs4whJ0oj9SwLJ7sKNc2U3w5SFITMf8YFbIFwcmjwLVyjF/uPUetqe07B6H9aT82JCfsyB7mwZdJ7mrlR2er25wJdimJkNcmzFRqPGQ5+s5hqKfUvRTlIQwcaiHPvXQI04lxoi5qNM2DQ4f+Rn3/d7I0HCb63zjIQcYMU+ZjUIyb8DMZG9zHvnZa2O9F+12m0pleMHsxwVPDPk5Kl6qXuPvf89/x89f/r9TMC8R6fkJms09+XkMVt7OgunB9z7/JtXC6FyQJwG6Q372royHVvGVuMpFf4dRq5aBSgf+PYvn8k66ONMJd7kv12fFbTJuqXPFbzFtDGsW5gejjmutnMgQwQjJnzae4XrrHHpG1y/SHo/CMl++9ww36ovE+piWx08A807ifKVZLbZ4prLNstfiarDJomrhkwyVyc0q0uX2yFCGUrB2bYM4dWhEHnGqZp2qdCo4rPfELKL+NhXYjKFdzshFzkNGfobV15uZ7M2f3zo/xpinkR+eINnbrPCB2nP89Wd/hv/zN/8BBZWx4IXUvBD3TKzsD4fCYOaa587/iDPO3ve48d7zd7lc2z7VNpw2rKU3UR42ibEIltwm3+PX+e3GZUI72D2W3Zh25s00FJlYl/tZjYvu9kyO5wqDR0KCR0FmVFRMQ4+OkARORlHFtPV0st7c/EARuLONInaLoxorgYPrAoHgVrzMelrhpdI9Ft2jOReazmr1ThKwkwRc3zrHYqHNhVKdc8XGme7j92LeyU8/jBUUnGzAkl8bQSP1aaUesXFJj+nWuI7BdXajo4lWJFk+cXSVxnf03CkTMiNRdty7NQSzGMIsoOXQmaeJFOmtIqKYIYsZomDya3sY8iOAssYaBqJOckbd1TzL3rIsmyjnp1qdXU7qWcQTQ35mWaej5BQAQaRd7ocu98MKJSdhwQupetGpT3T3Qgo71/xh3gaXYRCn6Ph2rrLDhy/deSyu41Fg+qQYI1cxheCRlfzNc9/if9x8D7fSXccbKcBXGbGZ7cB3N1nkvLMzs36jqiLWdb4yueI2DiQ/ACt+mxstDyGmWyCJjYNv9Nh6H4fBbi4QY4ujhsbja41nuORv8kLxIc4hr+NewmARbEYlNqMSr22cZyVocaFUZzVonvmiwMbO82LXIIZJ+JS0LPgRC/5upLOdujRTn0g7eYRXznbcB3CVwVW7fXnaIUMW8KTGdfWZl8klmYON8qLDShqUsihpxo4P4yI/E70RlpH5RsKCTRU2UZhtH6TFcbJDRZyEFlS/4ZAuWNKaQZct1oMRqubpjg147hxHhSeM/Fy8ePGEWnQ6eGLIzyxRcfZOJgStzKeV+dxtWypuxIIXUnbjM9ERSgkm40y05TB4HGRvTmfAlELz7PIGO2HAThiQHbMTX8FN+P4X3pzbez9LZH1F9w6SyYQIvhlX+b+d+xb/09Zz/GH7fO+7shsTRc5MJ1UpDvfSBS57WzM5nic0LikpLgsqRNoMI0Y/Z57SVNyYZjZdDo0jLc3Mo+rNxvxgL6aLAsGdeImNtMxLpXssTRgF+v27z6Ot5OOrNw6cZFkkj8IKj8IKSmjOFZusFessB60z+W4dQ1mdU8Okp1J0U4rurjQ1M5JG4tPumigAYsY3y1Gm17cDZFrm5AJwpcY7g2TIWNF7r4yWpBrAoqTtkCGDHGI+Monkb+Q2Wcf6uj8VaNx1MQLxyEV4wBQFSLtwmwJ/R9DN7sh8y8iSbVNAHcdqzwnCGDNRzs+sra7PGp6Sn0Og7IyWiFgE9TSgngYoYah2iFDJPZ4JwqQwVsx97s88o7tS7KuM7332bSAfKAwiXz3Uiih1aacezbhAPSqw0w7YCgOMPexravjs+17DmSO5znFib27IQS6I72iXt5IyP7f8Js/7Df7Z1nNkSFxpcKUms85M/bTupousuTs4M4oQVmXEhnERAioq5mZUpupGI893xW+znRRwpnTZgtz8wFHH17f0O8JJYQ+cTEbG4+uNZ1hVO9REyDPVgwnlg50a606Z795aw2iBIzXayAOJkLaKe60a91o1XJlxvthgrVRnqRAe9hRnjscq8nPIN82RZsBRzlpopR6t1CMyDgaJOMTzfuBvKoujBglYkjpY8mfLd7NTJ0PGCNQ+SinQRqCNhAzA4qg8MuSo8VGhcXBaCtkUmAB0YLDeEDXKiC7ksI/y3q7UiWdz4ZU6Y2z2EBi3eHccdX7OGp4Y8jPLlVolFO/3n+V6dIdMpCO301aylRTZSoq4QlPzQha8cEC7fFLIpQPzSX7mvcgp7Mre+gdyIUBhUR09e9WP9+23lyCFqUu4lyC1S0Nzun7wxeuUvNHP55OE7nXcRW53PTqqKPi9sMoVt82fLT/gGa/JP1h/H+u6QNlJ2J5Bsc9+aBR30wWuepszOZ4nMhS51fXlwhZfr1+hnhZY9lsUnf3PhCMNy37IZlzsEPXJ+suu+cGC2v/szhJ5FEhgrcDQXU0f3cZbzSV+r72CvGO57G/z6bW3OFfMax/dadX4wu0P8FzlEW3tsdkMcF2D72W4Xm6FbGw+EcyMPNA5LTUOt5uL3G4u4quUtVKdC8X60Hf5JKHPuNX1NJiVc50QeeHVsjeYw9NIfELtklmFFbOdKzjS4vi775s2knbmYI3AUSdPhnLjvEnmAoJMKzItcVTSieiMkb0ddJ8MSCQyBCfMx6q0YDD9EZ1RTToM+bEHHO+IcOY88jMJnhoePMVI3PzjIrejZVjSeMUEr5jgl1LcwnBik1rFelxmPS7jq5SFDhE6qSTas1734SA8DrK3buRn2nF1YoJkBalRJNohTB0cZSj7cUf+klOuWevf5wl51Gfw/A0Hj6uJkHyhtcpfrt7jWa/Ff33+m/yjzffwSrSETGdvF34/XeCCu407g+iPEFCVIVumgi81zwYbvBuucj+qUVQxy35rX9+z7LdZjwNEL0o82fOihCXKFAXn+C3UhQBrFbcaFXyVUfPb+M7+/qGbv2McwU29yI3bn8DVhmeLG1wub/AoqvAoyq1cpQsaSTvxIMkXKjxX4zqagpuCzVfwtZGd4w6/LrF2uVFf5kZ9maITc6FUZ63UOJWo/4EFJucMx2ne4CnNcrArkTQWmolPK/NIjINBzFQqp6Sl6A2SoTBzMBaUNBSOmQxpM/3EPX/njva7Ysg9FBMuyB4m8iOAS4sV7m83MTO26HPU409+ms3m08jP4wQhxJErSXexUi7yZrhFFjtksUN7K1/CEMrgd8iQV0rxism+hOBYuzwIXR6EFYodo4SaGx1rEu08W3Q+DsN4V3J4HFEsIfIJqJJdgrR/G9sp7tlf5HOwJY83QcqGjKDWipG1Jbq4a1y+Fi7ysWCLksr4xdXv8G92LvNP0xdIZmyFnEd/FnnG25jJ8QoiQ6HRKJ4rrvNuuApAW/uEbY+aG7LgtXuTLSksa0GLO60qvjKdZ3X88yAERNrBk8djfjDs92LtEGuXduZSUBpjLZXOqr4QYKwakDUKAZkjeTNZ5Y2NVTypyVKJHpIUb60kTiRx4gIW2SNDBinzYsVay6GEuot25vPWzipv7axQ8WIuFOusleonFvXXT2Vvh4IUUPXjgUWmKHNoJD6RccisghlGh5S0BPvIkMJYQaUwe9JsjMRogTQwib9Jd9yafP4w4roMWc/Zu+XQrtgejvw4SvI//T9/Bmstf/r6bX7ry2/wylv3ebTTOvJSquvMr9nBpPPfJ6HOzxNFfmaJ1UoJHu3/3GpJ1CgQNbp5QRY3SPGLKV4pJ0WO1+0JBO3Mp5353MNSdmMWvJCKG8189Wfeit71Ix9oJl+JPovo1vk5rShWLhvq5kuMLiY3jiDN6y0YNhmcdFL15bjENbfJYkcu9r+r3eY5r8H/696HZ9pG6ER/nG28GXiyCgEVGbJtyiw6bSoq7Dm/WQTbaZFG5rPstSh3ohMLbsi6KhFph8DpFuQYf50caWllHpVjMj8YBVcaFoLc8SvRkkdhiTSTCGuxxiKG6POFALeQ4RbAGkhjhyyTmA4R6p/XWiswVhEliigBMDjK4rm5PA7YzZUYep0EjaRAIylwfXuVRT9krVTnfLFxrMWGH6fIjz3lcxlqs534tLvRIZkX6Z0FcjKUESXHMzXTRmBSRaoVCIt0DEJZpDJDyVD3tCbpK23vf0OOM+xzzdjwu+Dg70dBdU5GCMEnXrrCJ166kv+kNvzRt27wxa+8wWvvPmSjOX2e3jyTn0nMDuBpzs9THIDVSnFCTakgDT3S0IONXEOp3I5UrpTgF1PcIAUhaKQFGmkBiaHqdYwSnGQmFsVzHPgBJlMpn2VI0XV7O7tnMY4gGQtpx6e0JCMcoWmZQr4aeobRJXP7Pp+Q/GRIfqN1jr9Wu9P77APBDr989Sv8m+Yad6Z0STuwrUjupEtc84esrBwCgUjZIV/mfalyj69uPzuQH6at4mFcpZ6mLPtNfKVZCxrcaC0RZg6Byjozl8kmP9qIE7WB7v8tTxk8lYCft8P3DGHmECYuGZJhsyghwQsyPMBoQRY7pEZ0NhX7+l5rJZmGrBf1M7hOHhUSwuaLByMNEwRbcZGtuMjrm+dZLrRYK9U5V2zO3JTkccr50Wesy1TSslCIWOD4bLaPS6ZujNx9lW1OhEhBYxHS5kTIMUhnj1LhqPdgCIEVBlQssMJi1fDfqAUF/ruf/Bz/5Juv8OU7d6inyUQLcEpAmqa47mBZAqUk3/891/j+77kGQJpp/u2fvsW//dO3eP3mI3ba43P1/DkmP1rrsTbX8JT8PHaYqeytUjp096RTRbgTEO4EnXYZvF5kKMUvJmxTZDsp4vQZJQRHkEzMc+QH8kn5ScofZg1xyJyfswpPZiw6bZZpERuHlvZpGZ/00M50x4dREqBp3okNq/jD1jLfV9qVpK04MT9bu8EXW+f4arTIrMJiD7IqF90t/Bn4sgoBFRFStyUueDsseG3aOp+k9bc3Mi53wgUqTsSS3+4UPvUJM5eCk04kgZMCGqnHwgkm+6sR+VFKWkpeSslLsUFIlDlEmUOYuiSm63U1+FxIZfN+GNBZToS0Fdi+MPxgVCg/RppJ0qz7fS6Rk9IgsBiGGyZYBOtRmfWojNw0rAZN1kp1VoPWTBZIrJUHuhnOE+bBuW6vzXZqJM2uzbZxciOFKeQcxyVTH53zI7BGYE0eaZOduUaX/Owde6O2wi9opBq0xB5pH3MAtxdWIEZ0dZWCx4fWzvG31z4LwM3tHf5/33iF37t5g/UwHNklSQSvvPIKAEtLSywvL1OpVPYRUtdR/MinXuRHPvUiAGGc8ttffoPf+8Y7XL+9TjPcT7bmucbPpOQnyzI8zzuBFp0ezt5MZU6wWinNLBRhrSRu+cStbrKGxfEzvFJOhMKix0ahjC9Tap2I0HFKJs4ixJwXau3l/MzzSfSh/zx8meHLjCVaJEbRMj4t7ZPYs1EFe1i+D0yfS/CNpMjzXos1d3fF1xHwo+WHXHFD/tfGBdJDWRPtbZfkdrrE8/7DIx8LoCgT6jrAlXDB3+FesoivMtqZR2r6B0JBIwtoZT6Bk9LWLkJKwswlmJAAnYT5wa5j1WSRVCEgcDMCN2MxiEi0JMoc2qlLnKlOJGzwvinHojoyR51I0kTl0ZQRRAg6stFOvlDnE5QyeVRnID1oj/GGlTxoV3nQruIIzbligwulOkuF9qHJi7Hj3AznB/O4cOceYLMdahfGJM0fl8mDnlJCKEbk/LTvVmlrCVLjVlO8Skw79mBUu4c8hpNw/HJhcAJ+daHGf/2D3w98P5vtkH/yjVf44jvvcKfZGPjpguvy8Y9/nCRJ2Nzc5Pbt2zQaDcrlMsvLyywtLQ2d3Ae+y0/+wPv5yR94PwCNVsRvfOm7/MErN3jrzjphovHc+Z02T0p+ngTM7108ZaxWDlF1a2IIstgli13am/nvSGXwigmPSgl+MWGh2mLBD6l5Ic4kMpM5HED6Md+t78v5OcOyt3EQI/7eD09qPNlm0WmT9hGh+JSIkLX76/t0Ma3QyAjBF1rL/Pu1uzh77uMH/AbnVMyvNS6xoYc4TkyJR1mVS+4WBXl0q3IpoCIiGrbIRX+be8kiSlgqbkyiJe3MG5DCGSSh9lkrNGl0ijfnBCgbS4C65ge+0scWdei/8oeR2HXlcVU/QRtB2I0K9eRxg0YGyjOoTp5mFkvSVGGE2Md+9keFBFordJ9ETsmOvKhTRHLvSnRmFXdbC9xtLeDJjPOlOhdKdRb8iGmQ5yrNb2HrfsyzU2kX/Tbb9dhnMztYUnRchE+5mqASkSUOWTJCCtrXt419fowi3Vak2z7WM1jXgrsnN/QIttOVwui+dKkY8J9/76f4z7/3U0RZxq++8m1+/Y03eGtnG7dDLj3PY21tjbW1Nay1NJtNNjY2ePXVVzHGDESFhuXCVEoFfuqzH+GnPvsR7t27x6OtJl6xdriTOQOYhPxYa2emkDrLeKLIzyydrFbKs4v8TAKzx0jhkVjGLaQUyjGrKzus1hrUvHBkZ2XnfAUwNXKuJRy7OT+n3JAZYZIVZVdqFmSbBadNaiVt7dPsEaGTuRBmz0S2H4eZYNRR/G5rlc+W90dlVp2Ev7HwLv+mcYHvJNWpjz3QNgS3kiXeU3hwpON0UZQJDV2g5kSUZETL5P2IpwyujIi0k69I912rtnZ5trRJPS1wP6wSpi4FN82tMA54GR1pqSceNf94zA/679so2dukUNJS9lLKXooJQuIOEWqnLplRHYK8OylyfIPjG6yFLFZkqUIPkTQNiwqBRBv6WLdFyg4hErlGrX+/xDjcaixxq7FE4CSsdYqpVrzxskLTMSyZ63B5B8dpdX1WcVxzTysEnq/xfE0SKaLWkILtov+v3chPz/lgOIxAtRyssBjHYgOdFzKFvMZPKvK8nn5+McE5Vv3JpFcFx+Gvf+wj/PWPfQRtDG9u7i9uLISgUqlQqVR49tlnSdOUra0t7t69S71ep1Qq9ciQ7+8nXcYYlmtFLl06N1GbziKmifw8rs6vXTxR5GeWWKkUT3c9yu4aKTQeVXgbi1eIuXhlk7XFbWqF0dXc5xHGCua5sHLPcvcxmIzA9BEsVxhqTkjNCcms7OUIReZ4idCoqA8c3kL3O6nPC0mJZ73Wvu88YfnL1bt8OQz5nda5I61ar+sKl8wmxRlEf5SwlERMywZcKWzyevti7zshIHAyPKV7OQoAmXXYTgos+hEVN+JRVOZhWMZ3NMaMU+4I3txYolqIWAnaM7XA7n/yZmkgIvvkcQuFiNQowrSTJ6Q7sje6LlLgFjRuQfcc47SWOREa0vHujwoBCIxRHRmfRcncSlvKfKmq/zhh5vFOfZl36suU3Zi1Up21Yn0gz6QL04k6zaNcbBgeO/IzwekcV35r/7Uc+Xz0k59ezs/kEAhELNFOLvcUBpyocwwBVuX/GQneFugAtM/Q61INpo+iKyl578ry2O1c1+XcuXOcO3cOay2tVovNzU1ee+01sixjcXGR5eVlarUaUkq01nOfBzMJ+cmyDMd5/KnB43+Gx4SS7+Erh4STqdswHoIkKvDuGxd5l4t4fsKFS+tcWt2iWoixhyhudpYw78Of7Lg5zbPsrR9HuR9OlwgRoq3oEaHQeEc88n5kBzz3h55UCcHvtBf5D5wQf4RL16eCLS46Ef+ycZGGOazkT3ArWea9hfuH3H8QZRnT0gXOeQ2utzWGwUEwl8IlJDqjrT2MlWynATUvt94/HzRZ9EPuNqskQpFkCs8ZbThQ9FM2wjIbYQlfZSwV2tQK8ZEXZXYnhvbYnOWEyAtgekpTK8RkRhBlbu4elzoYK3umCV3HOOhYZ0cOmZGYCYgQ9EnkjMojQ1gcZZAdMkTHfr57rGbq8+b2Km9ur1DzopwIler4nTzQ7qT2cVGuPHbkZwIcF3E1/c/GiLHIURolDdr0RSLHPUt7vi/cl8hUkpUsxreIFFDkZMgCGajOe6xSsMKiC6BdMH3BqMohyM9hIISgXC5TLpe5evUqWZaxvb3Nw4cPeeONNygU8kYtLS2dSHuOC5OQn1arRalUOqEWnR6eKPIz6zBeLSjQoDnTY84KSexx4+2L3Hj7IsVSm8XVOmp1m6J/9FXkU8Gcj3/HWeT0NDCrCJYSlqoTUSVCW0HbeLR0gdB4R179tPbgfIGjHL+N5IutVX68MlqWdsUN+fmFd/l84yLvpocbTDZ1mZb2KKmjS8iUsAQiJqTABX+HO/HwgXyvFG4jLrFayKNcntQ8W92imXisxyXqSYGiN3wBqOLFtBKPzChi7XKvVeNey1J0E1aLLYru4RaOupN6AbQSF09pXDVbq+i9cKTt5WwYC3HmdIiQmxOdTlRISPCKu9bZaeSQWdGzzh6GYblCmVbQyRVS0uA6GYJ8Jd2YjpmBEOwkATtJwHe3zrFUaLNWqrPUuVePQ64MnGyR07OC4xol+onkqCKnrqPx/WzALXDcPeh92303LUgt8HYEwnbc3rJc8WmdPPLTr0gWVuCEsLQu+c//w+/n//u1b/JmY4uFwhBZ3gnAcRxWVlZYWVnBWksYhnz3u9/l3r173Lt3j4WFBZaWllhYWJgrAwGt9dg6P81m8yn5eYqDsVD0uR2fTfLTj3arSLtV5M675ylV25xb3WZ1uTFQWfqsQ8x9kdP8z/k9g85AmC8ZHot8TwlLRcVUVIzpESGftvGwh3BRyyVvB5Gfo+Ft7fF6VOF9hcbIbUpS89eqt/jd9ip/FC4d2J7hENxKl3mfunektnZRkTGhLnDR2x5JfmCPFC51SLUcIBhlL6HkJmwnAe9sL1EJ9tcjEwIWg5BHrRK75y1opz43dnwkhoofs1Js4U1BXrqTeotgK+oYwgiDrzSeyvCdDFeaY5P99svj7Eh5nEAq8EspPqBTkSeZW3Fg4t+wqJA2Ep14vfPs1RXCoo3MJ7RCsBmV2IxK2FxHx6N2mQul+rETw+OGeYxsu2GyHuC4itT2R5RGXc9hZRnGRhH3fj/ikZMAGYNEqC8wXvQ8/sJL7+EvvPQedqKIVJ/+syuEoFgsUi6XWVlZoVqtsr29zcbGBm+99Ra+7/dyhYrF4zTCOjqMMWMlbU9CjR94Sn6OhKViACdX0mIGELTqJd7dKnF/A7xnWixf3mJ1qUHhkKuwJ4V5Jz9iDoqcToPjnohIYSmrmLKKMRbCDhFqGX9iIjSqvk8XR5fTCH4vrHHFbVM6wHpeCvhzpUdcdtv868ZFoimLwm7pMg3tU1FH72wcYSgQgwNVFVLXBxdoVcJS8VK2syIVIgpqt58QAhb9kMrqXd7eXEE7sLf+X8HJCJyUMNuvlTdIduKAnbiAIw01P5woP2jYRMxYSZjlttzEeX+REyGNr3ISdxzP7Eh5XJpHhqyVGEC5EuXmRChLJFnq5MU7xzig7J2AGiuJU0mc5ufouhrPyesKZTqPPqWdfvI7G2u8vnGehULIuWKD1WKT0pAcobOO3LZ7nnv/6RGlLm9vLlJyU4peQtFNZyLxTFOJNfk1zUnO/ivb2imQFTLcQorjdhcROgsORkA2/k4M+JCMaLYkt63v/7ro7TKh2ilFfUahKxlTSrG8vMzycp5XFIYhm5ubvPnmm0RRRK1WY3l5mcXFxTMXFcqybKiZQz+ekp/HELOWvS0VA9hvKnLmYTsSjNZGiUajxDsYqsttVs5vs7pUxz/GGh2HhRDz7VvUMzx4XMjPCd4NKaCkEkoqwdpGToQ6FtrmACI0qr5PF7OQ08RC8putc/zl6vjIzItei7+x8C6/Vr/EAz3dwH4rWeH9wZ3DNnMAFRURaZ/LhU1ea12aaB9XGkLt0dYeNSccmIg50vLiyiPqoc/d1gKOP7hauxCERA33gOstyIyaOD9okvtmEcTaJdZu75MuSfE7pOg4FiL2yuP6i6tqI9EIHA8cL5cxZrEiTfPPxxXB3B8VEmSbHpkF42hkAYJiQsnPECIhzRSZVmxHBbaiIt/dPE/RjTlXbLJazPO35iGa8vjl/Ix/7owVpMZhWztsRwFg8Z2sR4YCNz2Uc2i7HhC/WwRHYBwLi9k+VmkyRdh0iCIX6Rr8INmNtqYCux7kYZt+Yt5/XpYDi5oehKBwNmrDDYMxZqhkLAgCLl26xKVLlzDGsLOzw8bGBu+88w6O4/SIUrFYPHUHNWPMWEL2VPb2FGOxXDrbIc6DYNktGiqQNDbKNDbKvI2httJi9fw2K4sNvDNChMScm3X36vzM9Vns4rS6cCGgqBKKKmHFaRAZt0eEdF8Cv5mgJu6sciLuGpevhwt8NNgeu+2iSvmPFm7wm83zfCNemPg3dkyRHR1QU+HhG9qBKwweKatuA4UeuG4HQYj8vu9kAY7QVJxBclINYqrBA+5t12haD9EZXRxpqfoRO/HBUabOr+zmBzUtCstKqcVisDtRP1wyuCDRDol2aOIDFkeaHhHyVDZZvbQpIAUU3YxiRx6XaNUjQolRGCs61tly1zo7UyMd4/adkQChLLacLwFYS15oshMgdFQeFSp4eYHaTCtSLbmxs8g728t4SrNSbHIuaLJSbOXFWM8gctlbN1N+/jGR7G3fMy6IM5c4c9kMiwgsBTftkaGCk01EZLWRCJtHf8QYWTAif9fSTCE7XYRMwHkAxs0XUU0BjAM4nYhs9xZNeKv2/nrJP7vkZxKzACkli4uLLC4uAhDHMRsbG7z99tu0221qtRpLS0ssLS2diqPaU8ODXTwlP0fASnlOH5BcHTHiK0l9vUJ9vcKbwrC42mDl/A4rC41T1Y5LYTsWrvOJruxtHlZaJ8FZIHFCQKBSApWy7DSJrJtL47RPOkEtoVk6Kn0pLnPNa7GgxsuKHGH5icp9Lrshv9k83ymsOR63kmVqwe2jNhWAsoxIjMslf4ub8cpU+0oBBsVmUqKkYgrOoGT2wsIOmZbc2VkgcWReX8OPaaW5+cGksAhaiUcr8bmxlU/2loKQwJ2F1jiPNmVG0ercMiUMfifPyVfZTPs7IcgleM6uPC5MXVqJQ2rdPKelYHDZtc7O9GjHuC5sH2Hbu5k2inasBsiQqzSVIEZKS5pJNqIiD1oVjBEsB21Wiw3OFZsEZ0gG/fhFfsZj3MKMRRCmHmHqQbuEFIagjwyNUm/oaXKJemRT0GUzwgicRGCTPF+HEIy0xOfYNTAweVboRNgzjJQKZ9dKepKoyV74vs/Fixe5ePEixhjq9Tqbm5vcvHkTKWUvV6hcLp9IVGgS8tNut5/K3p7iYKxW5jjyM8F8S1jJ9sMa2w9rvCk0i+c6RKjWxDlhInQWJttHQd6x2cdH9nbGzkMICERKIFNW3CaRcWhkBbbSIpEdPqDO0kVKI/mN5ir/h9rdiff5nsIOa07Er9UvsW3GD/oNE7CVFVl02kdpKgC+yLgXVXCE5rDZ5EpaQuPRToZI4ZThmaVNWpHH/VYVPFgohKy3+80PpoEgSj3uph5gkcLiKI3vZjOrIaStpJ16tDtkSAozIJNz5ezyhhxpqfgJgZPyoO2CAF9mGCPIpMRRGm0FRiuiposRAtSQ4rJjzr1/c21yGVzYMQ7susiVCzkZijPFO/Vlrm+tEqiU86VcHrdQiGZz0oeEmfvefw8meIaMEWPv7cD2VtJKfFqJDy1QUnOltrOPBBkjURZG80mLcGye2zNsm2HkaU87D1132NozTX4mcUo7CFJKFhYWWFhY4LnnniNJkh4RajabVCoVlpeXWVpawnWPJwI2aeTnKfl5zDBrZn11sTYsX3AuYHcXcybcQbH1YIGtBwu8ITVL5+usntthudY8tlob/RBiAh3TGYYQ+WRx3ofx7mNz1h/5gswoeE1WvSaxUT0iFNrdWkKzpu/r1uGPWst8b2lj4n3WnJifX3iXf9W8wBtJZez2t9LlmZAfIeD5wiP+qPUi7w3usZWWeJSVsWK6lc1+KZwShqozWFy5VEh4vrDOeqOEFYKCkxFlRx3YBcYKkkySZA5C5HVxPJXhOLN7v4yVRJnM29szUdh1lPOUPlTeRT/6W1vzIspeQqolkXZ6dYWcak6EkkShEyePCnSJ0JRzsf57k5sneERJRwwgDY6jKfkJjjI8jMvcadcQ1rBUaHOu2GIlaJ1If98P05NnzXffOQ3SRJFqB6UMytFIZaci3too1JAFKm3kwSJXKxDGIjw9fEFkSKe5byF1789OcduKZ1j2Nirn57DwPI+1tTXW1taw1tJoNNjY2OD27Ty635XHVavVmc1dJyE/zWZz7usZTYInivzMGh+6uMZv/rX/gL/z7/6Af3f7BukJDwpHwSSRn5Ewis17i2zeW0QozdL5HVbP77BUOb6BcVhHPm+Qwjw+bm9zNBHxpcb3Wqx4LRKjaOgC22nxWAoJfj0p8rzX4rw7+Wp5QRp+unqHP2wv87vtlQMjUi1TYDMrseS0jtzWmgopy5AdHfDB6l0So3invcz9tIaecmiQAiySzaREUcUEe6RwK5UWS6ZFYSfjnXQRPQHJmuwJE528BEmaORDnESHXyWv/zHK9KzdRcIi1QyPJP3GlHnCUm77/222gI/NVelcZXJVQ6ZgiJFoSaZcodYh0XkA1TRVRO3eTww6JCE3Tgs6uxkqSVBInbq5gkiYnlY6lbTzeqgdc31qh7CWsFFqsFlv7JI/HAWPFY1OwdVIYK7BGkpncGRAsysmJkFJmZI2eLqyFmw8WWay1qRRiHGWwtq8A7qjHxYDYcXEaAqUNyZJBpBJRNNiqQUZDfnjPsfYOcVZ2jju0oYN/P8uGB9bamZKffgghqFarVKtVrl27RpqmbG5ucufOHV5//XXK5XJPIud5h4+OTRr5uXr16qF/Y17wlPwcERdKAf/HS+f4v3zgRf5ou8k/eeUV7kbNs780LmfTRKsVG3eX2Li7hHQyltfqrJzbZqnSOvKqaD8eB9Ig5XSrd2cTx1fn5yTgSc2ybLHstkiNZNYvqhGCL7SX+ferd1BTHvr7ihtcdEI+37hI247umm8lyyyq1pGfJSHgA8Ed/rj5PIlReFLz3vJDXrCPuBkucSdeIGG6gVZJS2Q8wsSj6oQDJgJSwpXFLVbLDd5YP8ejbIz70aEeMUGmHTLtEGJzaVeHDM1+3pI7cqXJXhOF3ejQOBOF/m/dEYYDnjJ4KqbqxVgLqekYJxTz6FCmJUnsECcSHHHkVeJdYwm5SyptHn1XytBMBbF1uNWq4UvNoh+yHLSo+cdT9yG3up77jrOHwxoe6EyhMwVYpLQoR+N4w6WY1gi2GyW262XAUi5FLFQ6EeMJ3itpBU5L4bQmWKTY+17teYy7il6RgdQH+1ac5cjPScJ1Xc6fP8/58+ex1tJsNtnc3OTVV1/FGMPi4iLLy8tUq9WpCNnTnJ9dPFHkZ9ayt52dHV599VVefPFFVldXeQ/wH778Ua4/3ODv/P4f8qX7t8nO6KT9OMxzTObw6PYSj24vodyM5QvbrK7usFhuH3miJmcuUjp5KPn4qNcfh6mIEmZip7NpsGMV/7a1ymfLj6be95rX5ucX3uVfNi5yOxueU9i2Phu6zIpz9ALLS6pFIBPuRAtcK+ZyPSUs14obPBtscDeucStaomUKE7/DXSlcvSOFq6hogHgU3IwPXbjLv/nGhxECXD/FKQ7L3TnqUybQRqGNIkqPJ09o7+/tmijkMz4lTK/ekKf2F1/trsRLYSaKGvXXFar6ORlKumQoy6NDaaaIY0WGRIwLEUx+algEmc7zhnITBUtbGpppgftRBU9k1LyYxUKbpUI4swWrx8/wYAwh7ovQDIfAGIFJJI433NjAGIGQYA1gBc1WQLMV9B9ixI93me+BTRzcZW/Oz7B9RV7MVDuA6ZAg3WlGn476KfnZDyEElUqFSqXCM888Q5ZlbG1tcf/+fa5fv04QBL1cocIEtZHGzYOf5vw8phBCYGcQQ799+za3bt3iox/96L6qvi+eW+b/85d/klRr/sevfI1fefVVHibtMzVjtDLvfI4LOnV4eHOFhzdXUF7KyoVtVlfrLJQOR4QeB9mbQdBOPW5sLrFabQyxlu3aYe+H2PcXu/+7YdvvGcVGXfrp7snjEME6XryeFngxKXLVmz4/p6oyfrZ2ky+2zvEn0SLD7tqtZJll1ZxZ9OdrzWeHfnepsMOlwg7rSYl3w2V29OS1KrpSuK10uBTOIjASdOrBlofE4ngZXjHtWevODiPyhJx0X2HWWUJbSZh5hFm3FXbAUa47sR8V9RkHIcBXGl9pah0yFGvVk8mFqUOaOUSZwk5ZXHeCX8/JZaKIEhewbLVL3FYL+G7Coh+y6IcsFUK8A4oAj8OTJnsz4yyo+6AzgXL298cHkqeDrmX3uykeRxXu2l5bNeb4AlBgOtsNzEHOuOztrMBxHFZXV1ldXcVaS7vdZmNjg9dff500TVlcXGRpaYmFhYVDyfSeWl0/xVAYY3jttdcwxvDJT37ywBCiqxS/8JmX+YXPvMy37t3n7/z+l/jTh/fQZyE3SAInVMJHJy4Pbqzy4MYqjp+wenGb1ZU6tdLkNUukPLQp1ZnCg0aNB40a3/ueN6gVT9dFaS8SLdhJAxpJAd1ZzhOdpbnuZb9W3qTqRdxNFijKhEAmeGKyGhNnDcfZZCsEv9Va4j90Q9xDEHcl4HPlh1x2Q369uUayZ+IaWY9HWZVzbv3IbV11ciL+KC6x6g/PJVrp5Ew1Mp+32ytsZGXGJh50z6UjhXtQL+MJw4Vyff/zIvPFgSRzSXZchAWlNHjmWIjQbp5QfvDjyhPaC4sgytw+04d84totiOqro71LQkDB0RQcDT4dMuT0IkPtxCHViiR1sNO6JYz/9QGC2QiL3CSPti0HbZaDFkuFNiV3vB18Px472duYU5kmFzFp+yA6+UCuRjn582vHWVqPjPx0vp6iy1KJwI3yXY1r98vgRq64deyy+zZ7GvmZDkIISqUSpVKJq1evorVma2uL9fV13nzzTQqFQi9XKAgmqbP2NPLzFEMQhiGvvPIKa2trXL16dSoZ3YcurPGPf+ovEaYp/+BLf8Kvfec7bGXRqUWDpnZ7mxGy2OPeO+e498453ELC6sUtVlfqVCcgAsYIlDoDxPGQEH2kd5p6J8cJYwT3d6rc3lxio1nq6PotUhqUNLm2XJnOvy1Xi9uAIDIeUUfMrTAEMiZQCUWZPBZRulkgFJLfaa7yo5WHhz7GB/wG51XMrzUusa79ge9up0usOPUj59ZJAe8P7vB6uDaS/HRRcWI+Ur1DpB3eCVd4kFQxE5gXCAE7UZGW8Xm7sUxBZjheSqoV+71y8/4pswoilctkpEX6GjlDN7fej8H+PCEnr/NzTPnN+34/NQ4P2pU8MqQyCk5KwcnwjmivnZOhjIKTsUCE6ZGh3EmuGxmK0yH3YSbIc7AeNKs8aFYBS8mNOV9usBK0qPnR2Of38ZO9HYypz9dKdCrRaa4pk8rsEqghzmui3zlvr3XnlEVKYZcoCUClR7tXRf9sWl0bY06kDs9RoZRiZWWFlZW8dlu73WZzc5Pr168Tx3Gv6OrCwsLIhftWq0WlMt55dN7xxJGfw8reumHF97///b3qvYdB4Lr8lz/wvfyXP/C9/PGN2/zdP/pjXtl4gDn2QXYQR3J7mxHSyOPu2+e5+/Z5vGKcR4SWd6gEwxNntZH5avCcol8Dr/Xp3oBG6HNrc4m7WwukercbsFaQZcCIXBi9tr/dGknTBDRNAFg8keVRIZVQEOlcRoVmhTe0z3uTgGve5FHOvVhxEn5u4V1+vXGBbyfV3uexdXmY1Vhzd47czjV3h2+1LxFph4Ia7+BVUBkvle/zHvOQd8Ml7iaLZGOGk27hRikhwWFhKcQYQZw4xJFDOmwC3pXJIDCJA2FO1qSfId3jINl9Uq5uPSFH4zvHlSc0CPv/Z++94yNLzzrf73tSZZWkUmp1DtM9nfOMZ+x1wplgZrHNGAPDvYZdjH33wmLWG7yXdL3Astd3YWEvC2ts8C5rs8ZgYMHYYxvjbM94utXq3K0O6pbUylLlOuG9f1RQSSqpTkWVws+fdvdUnfCeOun5vb/n+T2IbMqanbXXVnBy5MXEW4fGq4oAn2bh0yw6yCtOOikrqw4lTJ2MpeYUscaQobjpZWjGy9BMN5pi0+WL0RuMkZnXsW2V7T3T6PoC6csqP5sHlaS9LYeCYyurSjcyy4CyiKmgS1Bzf3KkqW7zV5UchgR/i6a91dvmulnw+/34/X527NiBaZq8+OKLTE9PMzQ0hK7rRCIRAoHAohS5LeVnC0DW3vDu3btMTExw7tw5PB5P+ZVc4mW7d/Cy3W8jns7wW1/9Jp+5eZ15J1O37a+KFruPMwkPD2/18vBWL55Akp7+OboicwS9C7+HU0l36hZEMfmxms12ActWGJkN82Cqk7mkj2pesE7Zl6IgI3Uyts6sHUDg4FNMfEoGv5KuurZh/ULwhUQn79JG8dVw7IaQPNM2wo5kgs/HewtE4qHZQY82X3NxuSokh32jjJttbFfdkylNcTgQmGSff5LPjh5hNNVOTyBGwFie2lRqzklRJD6vic9rLhChtIaZWSH4zgpBOKYGqayyoeg2itGIdLVcGpepkDGL6oR0E61Jt6+DQsIySFgLBgpezcSXI0O1thZQBPh1E38uFc12snbeyVyaXNLUyZgqlq3QiJeG5aiMxcOMxcOIqEC2SW4MR2j3JjE8JtIWeHVrM7X4aex7bsnvKBBgCbDyX8uSy1WyzVrga9G0N8dxyrqkrQcYhsFjjz0GQCqVYmpqit///d/nk5/8JKdOneL1r389qVSqrjU/v/ALv8Bf/dVfYRgG+/fv56Mf/Sjt7e112361EGVUkA33yDFNE8dxF4RYlsXg4CAej4dDhw41hfn//a07/Kdvfourc1OrdGGuAxzQo2C3eF2bL5Sga9ssPZF5ppMB/L7K8sVbCUOjEeaj2R/86PaH7Oqabsp+Z+J+Hkx3MDobxq4x3e4fHbpBXzBa9fpaXhVSMvgUc00tzKUEqwFub6XwmBbnTUH3zU9XwwPTy6ej25l3soHCbmOCfn225u1aUvC12GMc8E64JhKmrXBpbjs7fNN84dEhRlK55ngym77V4U3QHYihKXB7qpM07oKbLBFSSaf1lYnQohWys9UiR4Qa+6jOXrOaamNoNlqNdUK1rKsrdkEV8mpmXdsLQJYMpew8EdJyZEjDboBNPDEFQtl3syKcrDGElnXKO9Y5gmcdq/7FSFoaj9LhFb+PpQyGHnWXr9uBnDHB0uVyyo4jkLZYtrxnTMPOeTQ5uly2ujDBO66grvKqlSzU6yiZ1a8ExyWfEabkU//sh+nvaiu/cJORTCa5desWx48fX+uhVI10Os3169c5ceJEye++9KUv8dnPfpa/+qu/4vjx47zxjW/kTW96E8ePH68p5e9zn/scr33ta9E0jQ984AMA/MZv/EbV26sAqw56S/lZAbFYjIGBAfbs2UN/f3/T9vvqA3t59YG9zCSSfPgrX+dvh24Rlw1oJCfWh3lAMupnOOpnmG14OxL075nG512fBKiZyk/GUnk4086DqU5i6fL2l26RztT2yLCkxrytMW/7AYlXMde9cYIb3LT87M8keKyG9Lc8dugp3t1+l7+I9nPHDDCS6aBXm6u51koTkh36DHHHQ1B117MlbWtcS23jWmobtiZo9yawLBXTUbClwqN4iNF4G6qQSAcUVaK66HeVVYQsfF4Lx4FMRiO1GhFScgGZo+Ik1CwRUh0Ub2P6+8BCnRBNrxNagOmomBmV7HSExKPaeNVsvVCt5gmQNasIKGbWpMAHliMKaXJJSyORMciYGk498qiLrl9HKiRNg2TOMvzriX30Bufp9sfo8CRLOGWuI5StcarHb7nC524eEbKCtLcyy1X6RGrVtDc3/XFaHZZlrTiB7/F4eNOb3sQb3/hGXnzxRT7+8Y/z+c9/nl/7tV/j8uXLnD9/nje96U28/vWvr1i1ecMb3lD498te9jI+9alP1XIYdcOmIz9uGOyjR4+4ffs2x48fX7PCrw6/j1994/fwq3wP/+vKDX7vOy9wKzZTv8k2AaoQWOtG3BOkZgLcnvHRsWOe3v5ZtBrz35sNpShFxW4Q+ZmMBhme6mB8vq0+L9ElSKXqWZC61DjBzipCG9I4QfD3yQ76tTSBOgRuAcXmR9qG+XKii68mI4yZ7Ww3Zmre7i7PFN9N7HFNfsg5lSkiGyj7DAuMxZM1tiMwLRXTzqZPmbaSI/8SQytPFhQFvF4Lb54ImRrplE6mHBFCwUkqWcMEVWbrhBoSv6xtnVDxONK2RtrWmMss2Gr7cmRIr9E8AUBTJEEjQ9DIpiNbjrKICCUzKqal41STIrfK2FK2zr25CPfmIoCk0xenL5A1TQjoTUoVbxIabvDgZvOVGB5UPZDl22lVt7f1WvNTDLepe1JK+vv7ee6553juueewbZvvfOc7fPazn+W3fuu3+Hf/7t/xyle+sqox/OEf/iE//MM/XNW69camIz+rQUrJzZs3iUajnD9/Hl1vjRvxe48c5HuPHORRNMZ/+Iev8/y9IVJ18KlWlDWyfKsBAoXZB+3E7weJHJyms6v2XifNQjH5sez6RWGpjMaD6U4ezHSQzDTWLaeRL2YbtanGCVlL2OYpoCmp8Q/JMG8O1E5SIDvuVwcm+Vayk2GzE49i0qHGayKNunAIq3FMR3FVn2VLJZues4oLo6pIVMPCy2JS5DgiW1xvq5i2kqt1kAh15UkqRQGvx8LrsXBkVhFKp3Uy6RWIULFhQkrPEiEhs4pQ3Z3jsjtcWiekqw56E+uE8lhkq53OppLl0+N8mlUX9URTnAUy5E8wFg9iSxOQ2LYgkfG4d5Jz/fsIppNBppPZomyPatIXmKcnEKPDk6i5DqrRKPe4qVfNT8lfQbp746/FvJNAYOitGZJuFOWnmmNQVZWXvexlvOxlL+OXfumXSi7zute9jrGxsWWff+hDH+Ktb31r4d+apvGud72r4jE0Aq15pa0BMpkMAwMDtLe3c+bMmZa0NewNBfnN730DUko+NXCFj3z3u9xLzFc99aIqChV1M2shOBmNyYs9zPS10bdviqDf5Uz1GqKeaW+OhPG5Nh5MdzARDdEsz/Tm2c6WNk7IpsjVzzhhqdNro3HLDHE9k+CQUb/rNa9y3ExvQ8EhrCboUOO0q3E8SuWTJHuMKa6n++lWytd2OTIb7KtVTKIoisRbkhRBxtKwbAXbUbBz15wUi0mRIkoRIY1MWqMsESp2jjMsFKMxREgW+t5kg461So+DbDpVsXmCJuxFTnL1Ig3ZxqsW/W3zpG2NuKWTMA3m0waptIHlrBB2VHkjpm2de/MR7s1HUHDo8MXp9cfoDsTwa62XIl3uV27kM1YU/q/MMi4vhaPbu3nm5OP8/vMvMBVPLn+gVnAoar0L1uqIzaL8ZDIZDKPyCdTnn39+1e8/9rGP8dd//dd84QtfaJnYetORn1I//NzcHIODgxw8eJDu7u41GFVlEELw9pNHefvJowzPzPGb//A1/n74LmaFL69WuQirgRTZ52o66uXexX5CvVG27ZxB11u3KFYRCwF7teQnljJ4MN3Jw5l2Mlbzlcm16rkhUUg4HhKOBwjV0Tih+ernFxNd9GsjhOoUbCpF43dQmLGDzNjZWfGAkqJdjdOhxgkqaVcql1exGE2FUByLiGf1GiVHKnW/JhQFvMbyOkdHgmmpWLaK5WT36+TOnyJEgQhJma8RWoUIwYJznKVBOnslKIaN0BtFTBanx+Xd4zyahdYQFWp1WFIlZqrETA8g0RUbX44MeVSrJvOEfIpdvsdQxJvECgiSlkHc1IllsvU8qXRRilwdLiMHhalkiKlkCKbAr6Xp9sfoDUTp8CbqbgjRCDhSNO6RVKdanjzL8Xt0vu/sIb7v7CGklPznz36bP/vOFdKWXfHMktrC5GIjKD9ujiEej9fV6Q3gs5/9LP/+3/97vvzlL+P3++u67Vqw6cjPUjx48IDh4WFOnz7dUifGLXZ2hPntt76Fixcv8q1oik9ev8ZIKubuobMOXgQrQiz+j+ijNmITAbr2zNDVPd/0WVU3WFTzU0GfH9sRjM6GeTDdyUzcz1qeuEbVKlWKxcYJDoEcEfIqJkYFasdaJMhYqPyvaC/vaBurSzC2WvZq3PESd7w8NCPoWLRr8ZwqlFg1PW7e9pPMeLmeEngVkx59nn5jdtl9lVd+mgFFgEe38SyZ4JA5UmTmSRECQzcxDBNCoqAIpcsQIQnYtgpmzjBBs1E8jSNCUgpMS8G0FkwTNM1Zg1qh7HhMR8PMaMxnvFBotpqtGTLUyuqFSimzmiIJGWlCRhrph5StkciRoYRpkFY1Us4q56gKJCwP9+Y93JuPoAqHiC9Gtz9Gjz+KV2vNiTJZ6/1UbnUXmy+3iGJDh+5hT0f7wjpC8N43P8l73/wkF++M8v/+zTe4MeHe0VRrxZd2DhtB+XFDfmKxWN3Jz/ve9z7S6TSvf/3rgazpwe/93u/VdR/VYNOSH8dxuHLlCo7j8MQTT6x7Vq9pGu84doh/8oonuTUxxW/+w9f5+tgw1moz4uuY/JR6P0hHZWKoi9nRbCpcW1vtzlr1RHFaieXCcnou4eVBrhGpm+Wbgdbsti5IS520rYOdbQzpU0y8OTK0WpAv10D5AZiQBl+KdfM9oYmat+U25cxEY8IKM2GFEUjalAQdWpwONYFXWZweZEsFHQdVkZhoPDQ7Gc50ouIQ0WLs9E5jKE62AeUaE2IhwNBtjJVIkWpiebIpdKalkEgZmBkduZIhSN4wQao4SRXh5JzjPHaDDBOgWBVKZ7K1QqriYOg2eo1W2tWOJ21n76k5fAjkIkttYwWzmfyVqJeZgBBFzVYj3qwSnrB0EqZOzDTI5Ky1s7WR9Tl4WyqMJ9oYT7RxmSwR6/ZH6fHHaPckW6Z21JECbLKHXdOYqkzqdekId65/Gz//lqdLfn1y7zY+9t5/zEwsyW//zTf5wrUhzDLqvKa2LrnYLMpPIpGoe4PTW7du1XV79cKmIz9CCFKpFBcvXqSvr49du3at6/SvPFRVxbazL5wD3RH+yw99P7Nzc/zm332Bf5iZYdJKLXsOyvXsprVKzGomDYYvb8MfibFt9zReTwOswquAKE57W0H5MW2FkZl2Hkx3Mp/0NWtortGKjWaVJReCg0Lc8RB3cuk8wi6oQp4ldtqy2UU/RbhqedmXDrDXE69pO6pwWcVcBIlgzgkwlwlwF/CJNB1aVhFqU5KYUmGpQboisumHk3YbE7FsLw5dWqiiNWfQVyZF8azJgpU1JUilddIZjYylLSdEAqSac45L5ZzjlJxzXMPenllVyLKVgpW2IiS6ZqPrVtONEyB7vSQtg6RlQHqh2WqeDGmFiZ3szVSO/CyFpji0GWnajDRSLlaFUpZOxsr2GHLqRrQF0YyXaMbL0Gw3umLR7Y/T7YvS5Y9jrGFPIccRiIQGaQU0iTQc0CWUSI2UFgskKde+QspVTFzy+eKrweWzJNJWPlOmI+jjF9/xGn7gpXYG5yR/+u2rTKaSJcegtzD5cRwHTVvf4bJt22VNvBqR9taqWN9nswrMz8/z3e9+lyNHjtDR0bHWw6kbiskPwOjoKHfu3OFfveUNfCgY5NLoGP/PV77BCxOj2DnSs46pj6uANTEV5Pa0n86dc/Rsm11zF6DVlJ/pWIDh6Q7GZsMNsaiuF1pxbGLVK1lgSg3T1pi3QeDgVSy8uVohuYbypxSC5xMRntOTGDUYOFRjNrAUSekhaXoYMTtRsekxokihkHZUZIk0pHxwZQmNw5FHZByVhGUQswwyjkYry8pCgKFlG5QGvCaEsgqxlGCbCmlTJ5b0EEt5FrsyFhsmpPWcYYLMKkJ6I58t2dTCtKmQNrOvbFVxMDQL3YVVeCNgS4W46SFuegDQlGx/ofybpVLyU4ylqpBZUIUMEpaOaaukTY2UWb8UOdPRGImFGYmFAUm7J1lIj2vzNNdMJ6+uCynAFAgze4zSayODS35XR+RnJQCZ+/1zT8QVbsFFV6oD1fZ5Ts5Pc/v2bTo7OwmHw6umhUkpeecrTvBjrz7DS0Mj/M7ffYurE4sbueta6yortm3j8XjWehg1Ya3S3loVm478+P1+zp49i9dbv8aPrYA8+ZFScuPGDeLx+CK77uPb+vjYO54hbVr85298h09dvULKbD0nHLdwnX0lFabvdzA3FqRn3zSdHbXNstcCWRTf2nY2kHk4087wVCeJzPp4sLZe2ltlQadEIekYJB2DGUDDJKSm8aprow6mBPxdrJfvbxutehv17odkoxLWswGflGBKlbSjkZYallRYGlVl3b1sPGqSDk8S01FIWjoxy0PSrm8NRyORJ0Vt/jTd4RiQtZHPE6FY0oNp516ZxUTI1GBeRSjZ1DjRkMaqhVECYDsqyYxKMlNsnGCjaWvj3mk5KjFHRVMshBCMxMPZmqFCj6Hqx6UrDmEjTdhI48hsz5+EpRM3DTK2hmlnCWvWUa8ezyfBbNrPbNrPzZkevKpJlz9Gjz9GxBcrUrkagxUnmEocmjalgQaOR+J4nMVEptQwlyjdwbsC2wdWAGyPJCeWu8Lxwwdoa2vj0aNH3Lx5E5/PRyQSIRKJLCMKxTUzp/f185H3PMN0NMFv/+03+dL1u2RwMFo4rWwz1fzUO+2tVbHpyI+u60i5rjWPklBVlXQ6zYsvvkh7ezunT58umc7n0TV+7pVP8XOvfIoX7z/goy9c5MXREeatTCtP1i5HhWO1Mzqj13qZCSfZtncKv6/5jfGKDQ8ytsqXrjy+pspDNbBbjPwIauvTY6Fzab6TkJbhQHACTTQ/eLzraNxIBznoiVW1vtZAu3ohwBA2hmITIo0lRZYIOToZWTrY1BUHPZfCZMtsr5mYZRC3jJIqUithabG517DwGhZd4eykSdrUiCY9BUKUNSvIrYuCnVYgpSOQCN1G8TeqsWoerWackEXG0cg4GlEzO8lY6DGkZp3kqnWTUwT4NRO/ZtLlTWDaeftunaSlYzlZW/Fsilx9fviUrfMg2sGDaEfOSjtBjz9rnNCIBquOFDkbQhZuL1E6TV0IgTAFigmWBCew+rNg6U+uICADwgF9ToAjkS6jwp6OEN3d3XR3dyOlJB6PMz09zZUrV7Btm46ODiKRCG1tbUgpl8UjnSE/v/SO1/KLUvInXxlgfK66518zsFXzs/Gw6cjPRoVpmgwPD3P06FF6enpcrXN21w7O7toBwOhclD9+4SJ/f+cOw/F598rKWkFUF/Sm5nwMXeinvT9K7/YZ9CbOlKqLZj9XT9ZqVdQv574+qMevqAjB5fl+bsUiPNV1l04t0eTiZ8E/JMPs1BP4qpgh15tYu6cJiaaaBFQz21tHajkypC1YFhdBFZKAniGgZxbVckQtA9ttlNVElFM2PbqFR7foasuTITVLhGI+YnEPGVMHIZAIpKXhzGkgQVFtFK+N8DTavGBl4wRNaXSK3PIAN4+lPYZA4lFsPLm6IY9anTqkqw5hNUXYk8KRkLR0kjkylHHUrMJuqSQzOvVQILNW2kGmkkGuToFfT9OTc5Dr9MXr4t7oSLHQZDRfzufG/MDN4ZWocczvShMiO43iUgSPhBdqfoQQBINBgsEgu3btwrIsZmZmGBsb4/r166TTacbGxohEIsv6yAgheNcrT7rb6Rphsyg/8Xh8i/xsYf1gdHSUhw8fsm3bNtfEZym2hUN84HtewQd4BaZt8xeXrvGXV65xZXKCFK1Z0KyI6py6BApzI2HmxwN075mhqyvalGBXXcEhaT2h1dLe6kN+stvIODrDqQjjIsQO7ywhrXm5/klUno938/2hRxWvq62RcYkiwCssvEo2WjIdhZSjr5oeV6jlIEHGVonnFKF0i9QJVWoznLXeThBpSwCQyZOhuJdY3Es6kyVDTs45jjgIpUgVamg81XrGCcVjSzsa6YzGfO4TVdgFIpT/u5LnsiIgoJsE9Gw6d8ZWs7VClkHSo2UVMlslZWq5FLnaf4CE6eGu6eHufARV2ER88YIq5NVWYhGrH9SKpjJlfouqDYxy2/3hp4/x5sMH+OTXLvGt2w+ZTJY2JsijaxXDA03TFqlC3/rWt8hkMgwODuI4Dp2dnQVVaD0YTm0W5ScWi1UdQ643bJGfdYzi+p6DBw8Si9VHNtZVlbefOsrbTx0F4NLIGP/tuwN8c/gBk5nVH4jNhKiS/OQhLY3xW90Fa+xQMFW/wZWAVkMRcKugtciPrAtpzTefzacgpqXB7WQPbWqC7d5ZPE06b3dtg8vpEEc90YrW09cgVa8UdMVBV9KEyKa75RWhjNRKpncaqo2RqxOyHJF197IMEnZ9ZumrgVMjjzR0m049QWeODJmWSizhIZrIkaG0nlWFTA1nVgMpUTQHxWehGI0msa1nnFAMW6rELZW4la8XkQUilCVDZkX1Ntnry6bdk8KRgqSlFVLkLEfFdnJkKKNhObWHQrZUC1baIAnpaXr8UboDlVlpr/iMLUduqlR+8gh5PBzoj/Bv3v5qAKKJFH/6tct88fIQ92bmKOZkihAE/e7qVIUQqKrK7t272b17N5ZlMT09zcjICNeuXSMYDBbI0FJVqFWwWZSfrbS3DYz1MMvgBplMhoGBgUJ9z/T09CK3t3rieH8fv9HfB8BcMsWffHeAz928ze25mYJz3FpA1Klddybu4f6lbQR7YvTtnMZjNOZ3VFWqbr3QKrBbyO2tXomDS62y85i3/czHvfQYUXqNaN2NBZZD8NVkmJ1akrYKDBj0Btb8VAtVSPyqiV81kRIyUiXt6KQdDbtElKYpsmB1nE9fitsGcdPAqdaOqgrU3GByCXTNpqMtQUeBDCkLylDCSyqVrU1x4ipEaZJpArSqccJiFPcaykITdqH5qlfNNjR280pXhFykCqVtlWROFUoZWkEhq1+K3IKV9u28lXYgTl9gDr+xep2QI0XpOb1yQ3JJDOWyf2QR9C4mHiG/l3e//izvfv1ZbMfh+Qu3+KsXb3BldKLgK1cNNE2jp6eHnp4epJTEYjGmpqZaWhXaLMrPVtrbBocQYl2bHkSjUS5dusSBAwcKEuVSq+tGIezz8p6XP8F7Xv4EUkqevzHEpwYuc+HRGDHbbG5gX9d9CWLjIW5N+unaNUd379wig4K67KE1nuM1oZX6/NSL/CyQGlGiR4bCeCbMZCbIdu9sw+uBMih8LtHF20Jjrtepx6x1IyEEeIRdUNBMRyGdqxUyS5gmFKcvSU+ctKMRtwxipoHVwDohKRuvbOqaQ0coSUfOXtuyFWIJD7GcMpRM6dhpfcE0QbOzqtDq7TnqgOXGCYrioKsOHn3tjBOWwpIqVpE6JIrUIY+arR9y09Ig606YVYVsKXJEKFsvFPBkCbtpqyTSel3ur7yV9oP5MD7NZF/39IrLZq/BEtdhubQ3l8qPMQeOkf0DC86pQc/KqouqKLzxzEHeeOYgAKPT8ysuWwmEEIRCIUKhEHv27ME0Taanp3n48GFBFYpEInR2dq6pKrQRlJ9SphNLsdXnZwsti7GxMYaGhjhx4sQiht4s8lMMIQSvP7Sf1x/aD8DdqRk+/uJFvnLvHiOJWOubJpSCozJ5t5PZsRC9+6ZoDyfqu/1VO9C1Plon7a1+PnlKUaG1RJQkVQ5qoR5op3eWYAPrgUZtgxeS7Zzzzbpafq1qfqqFrjjoZAiqmWwaVs5GO+0sT48TgkLaU8STIGMrJGyDmOmpe52QpP7KTzloqkN7KEl7gQwJ4smsKhSNe0gmDZyoN2ea4KB4rSaYJgAIHEcl7WR76ggBqmKvapywFk8GiSBl66RsHcg2hc72HFpwliunDqlCEtQzBPUMUsYLPasSlo4jJbFUfcOkVNpgajZAwJ/Goy9vurziNbjKfS6Rrk+AlhQoJTo+hLzuycW2zjbXy1Yy0azrOr29vfT29i5ShS5dugRQUIVCoVBTVaGNoPxA+cynLeVnCy2Hlfr35LEW5Gcp9kQ6+LdveDUASdPk0wNX+OurN7g2PUWmEaYJDXz2WSmdh1f6mO6Ms233ND5vfXoi1ValtPZolSanpq3ULTWnuElozDQI6ekVg6W0NLjVhHqgb6WC7NETdGnlrXQ9LVLzUw0UIfGpJj6ys+0J2yDqrNyDzVAdDDVFu5HCdgQJO9vvJWHXwUZbijUn95oqCQeThINZMmQ7Ipsml/ASi3lJJA2IKwghEUZOFWp4TJZVRC1bKxgn6FrWqlpTHdSGu8hVhnzPoZiZV4ecBSMFLfv3SimsS3tW9fkFKUtjKh5gNBZ2P4iVHvJSYDuCkVu9AKiGRag7SjCcImBkcnWhK6S9rd7L2d37UJbgULn1AqsoP7WgWtVkJVXowYMHRKNRQqFQQRVaGg/VG25Uk42ArZqfDY71lvaWr+8Jh8Mr9u9pBfJTDJ+u866zJ3nX2ayF5Qv3H/InLw3w7YcjzJipuhCXWvKO3SI5HeD2tI/OHfP09M+gqbXtc/2Tn9Z4ATyItePTTbb752qeBVeKooGJVIiZtJ+wkaTNSC/6rhiNrgdyhMLn4hGebRsta58bVJrfs6oRyKsLbkuYVEUSUjKE9Eyh+WU+Pa6aOqFVZ93XCKoiCQdShAMp6M6SoXieDMU9JOY9WI5oomkCZI0TFBwpsJxsIaMga57g0U10tbXIkEQhaRskbQMy2U90ZbGznL6COqTmaoXUYJS01IimihrdVgslOwYQ2BmN2ZkQc3ZWtdJL1PoJstem9sBAlRI75GAHHaRHLtlmeYj8rnMovloqUX4qQb1SxpaqQtFolKmpKR48eABkVaGuri6CwWBDiMpmID+xWIxQKLTWw2gKNiX5WU/I1/fs37+f3t7eFZdrNfKzFOd2befcru0ATMUSfPzFizx/e4h787NU2zqmWSRCoDDzoJ25R0F69k7T2RmrPuCW69vxoFWanEZNg0eZNhK2zoHQZE39NVSx+L6xpMpUOshM2k+bkSJsJFdwmVqoB9rhnaWjzvVAU1Ln68lOXuFfuT4AwKe4N0dodVRbx7Wo+aUnTjqXuhQzPZgu64Qka6/8lIOqSNoCKdpyZMhxBPGUUagZik97QIBi2Ahfo00T8sieNctRsdJ5MiRRVQddtfFozRqHWwhMR8N0NKI5QV8h2xR2gRCZi54ppqMS8qZJZzQyGQ1Rg9omRK7OZqHUcGE/eWK19DaQ2YakWkKgphScOXCExNFZsQFqSZS6vl3U/NSCRtTLCCFoa2ujra2NvXv3kslkmJ6e5v79+4UAvquri46OjoarQusBbif7t9LettASWKm+pxQURWlp8lOMSNDP+15+nle1eTE8Hm7bgj/+xre5l06RcCzX3KDqvgZVwjE1xm70MBNqY9u+KQL+yus+1vvkUSukvVmOwlzah6LBeKqNlK1zJDxWkQ1uMdQVAm4HhdmMn9mMj5Cept1IYqjL7zEHlfupCI9EiJ2+GYJq/ZSYC+kA+/QE/frKNuzeKppDbmRk64RsvGqSTk+SWMZACJklQ7aBI1eIXFtQ+SkHRZGE/GlC/jR0zeE4EE95svbaUS/JpAGqQPGZTTBNyCPb5DXfXyiZyd5fquJgqHZLGSjk4aCQtAySRU1YDcUmoKXx62bOmEPiAJru4FgCaSlIRSKqiaKEXCAiFb7H8ksrUizMpVXwe650hS91e6sXmmEWYBgGfX199PX1IaVkfn6eqakp7t+/j6IohVqhRqlCrQ635yCRSOD3r9y/aSNhi/y0IMrV95TCenIiSSQSXLx4kd27d9Pf389RoCs6w9NPP82N8Sn+24sX+Or9YR6l4qsSIWeNEsjSUS93L/YT6ouybccMuu6edCrIFm0Z6w6t4PY2k/IRzXjwYeEzLOZNHy9N7+BExwieEuSkHFZKbVuAIGp6iZoe/JpJu5HAV6KBYVoa3Er0ElYT9NepHkgKwefinbwrPIq+wji967jmZykaRT7ajWydkJRkC9rtbEF73FpIkZO0xvVdCxSFAhnqCMUI+9Ik0zqxpJdowkM85SFtawhfM0wT8iiy1XZUkmb2faYqWWXIWPOGq6UgyDgawpJIsTA4O5emoGgSNBs7ne9f4A6FJRUW0jsrPQ8llnc9J7VkqJoicKREitar+akWQgjC4TDhcJh9+/aRyWQKRCgWi9HW1laoFdK0zRECuzVskFJumt9kcxzlErQy83dT37OeMTU1xbVr1zh27Bjh8PIC0oM9EX7lzd8DQDyd4ZMXBvnb6ze5OTONuSTIW9tJWkF0rI3YeICuPTN0dc+7ms1c76fTaYGUvdm0F1BImRrenFtS2tF5cWoHJztHCGiVmVMoRTn4q0PkXKAMPIpJuydJQMssO6dztp+5uJdeI0pPHeqBomh8OR7hdcHJkt97N0Dz3DxW6rlUC4qv2UUF7UYSKSHtaCQsnXnhJUFrNlmsBlIIhAC/18TvNenpyDbPLaTKJT3E0h4StoolKnHOcypYthQWyJDtqKRMA5AoQqLl0uQ0tZnkbGUsvRptR1l86NXe28UqdSnF2u1mF2QgV4svHe7e7g7+v5/6fv7ypesud1g51tom2jAMtm3bxrZt20qqQpFIhEgkQiAQKBlvraf68JXghvxIKTfEsbrFpiQ/rQq39T3rEVJK7t+/z9jYGGfPnsXrXdnRKY+Ax+B/f/IM//uTZ5BS8rU79/nkhUFeHB1lzkq3RGtH6ahMDHUxO9pG3/4p2nKWtStBrDNb4uUQOI6oew+kSvAonk0BlVLBdkTBhMJB5aXp7RwOPyLiWf081Iq0o/MoqaMJm3ZPkpCeWlJ3pPCoqD9QrfVAVy0f+zJ+9hnLrde9YuOQn0bcH5pik3+nLz0HxVbanZ4ku4IzWettWydlZ+231+sE1Er1U4tS5XKwbIVYykMsbZA0s80/rZXSAxuCbL1VxlLIWDrFZMjQVrbXbiakI3JW+EWo9NKY07P2EMUKY8ltrNLnZ8mqkgomApdcErqq4vPo/PDLjrncQOVYa/JTjKWqUDqdZnp6mrt37xKPxwmHw0QiETo6OgoKSCuNv1pUYtW9Xp93lWKL/LQIKqnvWW9wHIcrV64gpeT8+fNV216+Yt9uXrFvNwBj81H+2wsD/P3duwzH5rDW2EPNTBoMD24j0BVj265pPJ7SReiNmNluNhwp1uw4UpbGvOkr/HfGUtEWOSQpXJ3bxp7gJNt98w2fPbakymQqyHTaT1jPmiMUN1m0c/VA47l6oEDV9UCCLyY66NdSy2p8fBtK+ak//JqFRTY9SZEyV5FSWoVVBPhUC1/umsq7yKUdjZStk3HUdRQcuB+npjq0B5K0BxYmDdKmmlWGMgbxTDZNsGY7cddYToaEkGiKg6FZTXGUW9qSzSnxyBPIijqOSVOBzJIgtIbLSdi52leXM/Z+XaMr4GUylgQButr489nK5MHj8RRUIcdxCqrQvXv3UFW10FOoVcfvFm6Vn/XzbKsdm5L8tNIJrqa+p9z2Wun40uk0Fy5coK+vj127dtVtbH1tId7/2pfzfl4OwIvDI/z55at858FDRuIxnDVSWOKTQW5N+encOUfPttll3caFIl1b+bYqsmrL2ux7MumnOFpImxo+w1oWyN6NdZG0dPaHpmpygnMLRyrM5MwRgiXMEVLS4Gail7CWYLtnFqMKwpJE5fl4F98XGl/0eWAjKT8NJdWiKAVOImQ2lBfIFUlywUUOE0hiS5FVhHLKUJZUtc7zthhZO2qqvv49uo1HTxAhqzZKCcmMTjxtkDB1kpZBytaalMsrkFJg2krOEa35jnIlnQArPfRSl3epd1W5nj45KBakeyyky7ChI+DjL/7lj/BoNsYffekCYb/H3Yo1oJXJTzEURaG9vZ329nYgG7vkidD8/DzXrl1bpgqtF7ghP5lMBo+n8ddDq2B9ncENhnrX9yiKguM4LdOJeG5ujsHBQR5//HEikUjZ5Wshbmd39nN2Z39hO18ZusdfXrnOd0dHGU/Gm1sfJBWm73cwNxakZ980nR0L7bTLF9e3PrKOb2sTcE8kFquiEgXLUdDV5YzyUSqcdYJrf1S27qZe/ZfkInOEDO1GcpE5wpzlZ86qvh7oju3hSjrEEU90Yexi+Sz1ekUzi/AlIncVS4TMfpJXNFcahyokAc0s1JXZjiDp6KTtrDJk5+hUK0DKLGGoui5lCYQAv8fE71moqXMccsqQh4SpkzCbpY6VdpTTciYKjXCUK2nGUTH5qXIbK/TmkUIiKyjXMtRsyNfbHuRfPPMKdyvViPVCfpbC4/HQ399POBzmzp079Pb2MjU1xd27d9E0rVAr5Pf7W2rCuRTckJ9YLLZpnN5gi/ysGRpR35Pv9dMK5GdkZIR79+5x+vRpVzdUvvFsPR4iQgheuX8Pr9y/BwDLcfjctVv8zfWbDDx6xFQ62ZT4xM7ojF7rZSacZNveKfy+DMoGcOZaS0esyVRg2WcZUy1JfgDmTD8vTW3nROcIxqqW0PXuvyRIWB4SlgePatJuFJsj1FIPJPhKMsxOLUmoREPE9Y61IXJZvUkicqJs+fS4PFRFElQyBLVsOqPlKCRtjbSjk7J1nKaliS2HJB+wN27CRVEg6M0Q9C6kc1q2IJ5Ll8sqRDpWw0lhdtuWo2LV0VEukdFxHIGh2gWnt0WQWQKouH3llmwXVqnhQdGzSqGiXFFPE9LclqJVYpJqkZ9Q7ujooKOjA4BUKsX09DRDQ0Mkk8lFtUKteKxuyc9GK7lYDZuS/Kw1S29UfU8rNDrNp/ElEgnOnz/vWh7Oj70RM0SaovCWIwd5y5GDACRNk7+6fJ3P3bzNlYkJ5sx0Q9/LqTkfQxf6ae+PrrVFXV2wVo0g59JeTGf59ZS2VPzSXDFITTkGL07u5MQqTnCNDBHTdtYcQVdswsaCOUK19UAZFD4X7+KH2sYWjX8L9ULl6XF5aIpDSMkQInsuTUchaeuFNLli2+RGQ+b7wDQZmioJ+1OE/Qu9qTKWSixtFAhR44lhfRzlTEcjGvNiO/nAcckPqkikpWKmBbrHxbu3ZNpb+dWKF0n3WoiMgpao/K7X1eaHfOtV+cmjFHHwer309/fT39+P4zjMzc0xNTXFnTt30HW9oAr5fL41jzfBHflJJBJb5GcLjUG963uWYq3Jj2mahTS+U6dOVXTT58fejG7MPl3nHaeO8Y5TWYebuWSKPx+8yhdv3eHa1CRx26x7NClQmBsJZ9vkRda3+uOUmgFtAiYSy1WfLBRMW8HQVv5d7ZwT3JH2R3QapZzgGh8lmk7WHGEm7afNSBLWU6iKLNQDtWtx+j1zruqBRhyDF5PtnPXNZj9Y+/dr3VBvDa42VJcel4euOOhKGvSss1rGVkkWucnRQDIk5dpNVCyFodl0akk6iwwVkhktqxCZBglLI2XpDZb8VnaU8xrmisqQK0MD19bULtPelm6vOO1NBSfsYC/vFFEWnjVQJTYi+SmGoijLVKGpqSlu3bpFKpWivb2dzs7ONVWFbNvGMFa38Y/H4wQCK71jNx62yE+T0Iz+PWtJfmKxGAMDA+zbt4++vr6K18/XK60Fwj4vP3H+ND9x/jQAj6Ix/mzgMn8/dI+bM1NkpFO3aEygoMYldmD91v7YaxRQTSZXfjBnTHVV8pOFwpXZbewLTrJtiRNcM4/Ilgoz6QCzaT8hPUW7J4muOMxaAWYtn+t6oG+lguzRE0S0TMWuU62NxqZqVY/q0+PyMFQ7a4ShpwsNV/PKUNqpr3mAlKKlrwmfkW1SDNmaSEdCIp1zljN1kqZBuqH1QwtkSBESbQWHTjeQ9uIxOg6la46WXdbl1cSl8I4rZDqqe4esFflZbwYBxaiUvHm9XrZv38727dtxHIfZ2dmSqlAz62vcpr1tkZ8NjmbLkM3q37NW5Gd8fJybN29y4sQJQqFQVdtYa9WqGL2hIO8+d4pzuqC390mcYIg/u3SVr927z925WTI12rWJpAKB1jjWarAWNT+2I5hJ+1b8PmOrONJ05Ww1FOsiaevsDS44wYk1iLclgnnTx7zpJaBlaPck8apWoR6ozzNHlx5fMTiyhcLnEhF+ODTK2llQ1B+1OJQ1F9Wnx0Fxw1UbSBUarqbq1GOoYHiwTqCI5fVDtiOIp42cw5xB3NZxGtB/aOX+UnLV50L+9Mglz0Q7o2E5AkW30fQcVZawbJqlitPjG1Hxj4CjScw2iRl2yIQl0kV/Xu8akJCNrvysBkVR6OzspLOzE4BkMrlMFYpEIrS3tzdUFdqq+VmOTUl+molm9u9pNoGQUnLnzh2mpqY4f/58WVl1Nayl8rMU0WiUgYEBDh06RFdXFwDvf/WCrfaVsXH+bOAKX7l7l7FkArtCNyUhBGpcrFv1J+v21lxMp/xleowomLaKR3N3/Y8mwyQtjcPt4zmFZS3PhSBueYhbBl7Vot1IENBhOBXh8uw2Tnc8IKynSq456eh8I9mJgsRu4Vn+SrA+HRFrS4/LL5NvuApZEpi2NVI584RKXdSyhgcVH0hLQVUkbb40bb5s2uC9qXZmMvWfnRar3DvlvAekZPnMQ47oSFsBw8mdjBLrr2B2sKyZatF3+c8VS+CZFnimFSQS2wvJbQ5WUOJ4ZEkjBM8W+akY9Ry/z+djx44d7NixA9u2C7VCt2/fxuPxLKoVqie2an6WY4v8NAiNru8phWaSH9u2uXTpEh6Ph7Nnz9b8cFBVtSXIz6NHj7h9+zanTp1aUQI+0tfDkb4eHjx4gG3bjAuVP798jRcePGQ0EcONMLKe1Z+1qCNYud5nAWlTc01+AGbNABem+zneMdrg/jJuIUjZOmPJMHraot1IYqLx/Phh9vgnORYewVOiHuildABLKq1UKLPJsTg9LmOrKMJBEw6qcFyrWooAn2bhwwKSOLkeQ0lbw5QaGUdlNasvKUXL1PzUC41K2pA13P92armTXSHdMP+xoHR/txWOR5sDO5QrESp2K19hmAKBlgR9TkWPZS2wba/E9kkIgJVLCfZuGR5UDNu2G5K2p6pqSVXoxo0bpNNpOjo6CqpQrb+fG/KzVfOzCdDotLdm1PeUQrPITzKZ5MKFC+zcuZMdO3bUZZuKoqxp2puUkqGhIWZmZlyTVUVRME2T83t3c37XjsJ2/v7WXf7q6jVeGh1jIpUoXeO6jtUfmW7+i2yqhMX1Uli2snKu/QpI2h5enNyJuqoNdvNhOhoTqRACSbuR4H6ik3uJTo6HR9gXmFxUDySF4MpcNz7dYodvDq3FjmWzw0FgSw0zd8oUskQoT4bcvh4UIfFrJgqSsBHFloKkrZO0DRKWTmZJw5f1lvbmCg06nNU9B8rtNMtQFlm0y/w3xU4F7s0OVFMg4tlVpJBIlZXVoxLbE1KgJbOE6GdPPsHhXd382c1rnOvbVmYD9cd6Jz/NGv9SVWh2dpbJyUlu3bqF1+slEonQ2dlZlSrkxkk3FovR399f7fDXHTYl+WkkmlXfUwrNID/T09NcvXqVI0eOFNxN6oG1VH5s22ZwcBDDMDhz5ozrB12pVD0hBK95bC+veWwvAKZt89nrt/jba9keQzOZ1MILap2qP9JqbkCVtlTmMx4XQaLIpr65cEsrho2as7J1X7jeLEgEHtVid2iG+YyHK/PbuBHt5WzHfXo9C6YNEU+Ce8kIJhqdepwOPbFO6mY2PpbGqw4KGamQ7cspUYuIkOqiXiif3qgKSVDL9RjygOUUkSFbR0q58ciPKSqe4CiP1RnFqqmDgtXbFxR/VdLmunTamwAUG3BAKTJTcPEIXAafoXOsq5ujkWwKt2maBRWgGUH9eic/a9GnSFXVQgocZFPSpqamuH79OqZpLqoVcvPbujGdSCaTW2lvmwH5ppr1RDPre0pBVVXS6XTDtj88PMzDhw85e/YsXq+3rtteK+UnlUpx4cIFtm/fzs6dOyta102dkq6qfP+RQ3z/kUMAJDIZ/jLXY+jqxAQzZhJHX1/qT7NrfiaSAdfqaSqj4dGrvY6ynmnmvIYeslqGBM1lfAT1DO2eFGEjRcwy+M7MboJqirMdw7TpKbo9UYZTnTgoTJoh5iwf3UaMkNa458EW3MGWyirOfQJbqthyoY9MsSqklCBD9gr3n6bIbI8hPWsYsMM3R8LSMaVGylFzfXVa5KKuEppuI+ZVUgkVRQctkEGpR0a5y5/FSmo4GRXVY6F67JLpbCWNDWCFmp8Sn632OnCp/BTD7/Hg8XhwHKfwJ/+uzSsCQoiGEZR8k9D1ilYgb36/H7/fz86dO7Ftm5mZmWWqUCQSWTEusyzLlfKzRX62UBHWor6nFBql/DiOw9WrV7Ftm/PnzzfkQbYW5Gdubo7BwUEOHz5cyLutBNWYNPgNg2dPH+fZ08cB+PMrl/nAS89XvO+1RLPd3qZWsbheCluq2I5ALVVI7AqC5KMAsSseQsem0QJrT4JStk7aVvGoNkJASM8GuAlL52vT++kx5jnaNrLIKMCUGiPpdvxmmh5PtGI1bAtrBYElVawcGRJINGEvqhdaifwshaY4tBlpIEuALUchlTNQSDtag5uMNgaGYRPpjSIlmKZKOqmTjuqYpobqs1C9dsPvVyej4SQ1TOkgggv3lR3XULw2ovjZs0j5KZX2Vvo5taKYVE6FKgGvng3zFEUpBMCO4yClXEaE8iSonsF+K5CHWrAWys9qUFWVrq4uurq6kFIWaoWuXbuGaZqFWqFwOLzofG/V/CzGFvmpEWtV31MKjSA/mUyGCxcu0N3dzZ49exp2fM1OexsdHeXu3bucPn26ar/9ejjUPXPkKP/Pd7/BuIjXtJ1motnkZ7X+PqWQsdRc/5DqIBSJk9CY+3YPRneS4OOzKGuszs1lfPT4Yos+82smfs0kbat8ZeoAGVvFloKAnimkvCUcD3eTBu1aki4jVrZ30BZaCxKBuaReCCDtqOjCrii1UVMcgkqGIFllyHSUrK22o5G2NWQDG67WC7ZDobbGMGwMwyYUztqEZ9Ia6ZROOqHhCIEasCpIj1vth1xJxVFwih4zdkLDSWngW3gHL675cbnb1ay1V/lupa882vKgNx8Uq6qKrusFEiSlxLbtQhxRD1VovZOfVh6/EKKkKpRvP+Lz+YhEIgViuxri8fiW8rMZUI+0t7Ws7ymFepOf+fl5Ll26xMGDB+nu7q7bdkuh0Sl7eUgpuXXrFtFolPPnz9fk4lIve+5/cfblvP+7n6t5O81CMx2komkPaacyJTVlanj16hWb4pnbzISP6Qkv/gPz+HbEWav4MGp66PTE0UooWh7VptuXwHIU7s23MzwfJuxJEfakCegZhBDMWn6ilpeIEaNdS665mrWpIKlbtpmDgqpI5i0f+RQ5Q7EwcupQJedVVxx0JU0opwxlcmQo3cJkSCKYT3oQEtoCC+8LIcDjtfB4LWiH2Wk/8fEAQkhUr4Uezqy8UepkCV7YRunuySXrr8qRn6XjqkL5cWNvXUoVsm278H6rRRVyU2zfymg15Wc1LFWF8rVC6XSa73znOwV3uWJVKI9EIlF1n8b1iE1LfmrFWtf3lEI9yU/++FazfK4nmtHnx7IsLl26hN/vr4tKV68x/8Dhw/zGi19lQiRq3lYz4Dbtph6YqFD1AZBSwXYEmlplRLOMYAgSt8Ik7oZoOz6N3p5ZA/IgmDe9dHqSKy6RT3OaS/uZSQWYSQVQhZ0jQin8usl4po1Z00ePJ0pANZs4/i3UH7kUOVslQVZl0IWNrtgYwq7ISQ7AUBwMZSFNLuOouTQ5jUwLkSFFAcde/cCEIkGRSJmt0ylHflyj2M1t6c9R7rd2a3iAWHFbqwq3K6xzb+gW3cKiq6vLVZZDsSoElFSFpJSoqupKFWpl5cQN1uv4hRAEAgECgQCPHj3i9OnTzMzM8OjRI27cuMHQ0BCTk5P8wA/8ALt37yYWi9U11vu3//bf8pnPfAZFUejp6eFjH/tYS7nJbZGfCtEq9T2lUI+6GSklN2/eLCgjzTq+RjvV5e25d+/eXbcbsJ6E7RfOvJx/8dLn67KtRqOZaW+VprzlkbFUNLW61LcVA0ZLYf6lLrS2DMFjM2je5tbRzGd8tBvJVVOdljYItaXKdCrAdCqAKizavVlFKO1ohLQ03UYUY8sae0NAIsjILFGJk02RyxMhXbErTnk0FBtDsWkjnU0rc9RsilxOGVoLGVQs+8cKy6kSfE7WjMAWmHEN1Wuh1DiBX/bJt+QnFqJM2luJn3DV07Ra2tsKgzt04AACm+vXrxf6x3R1ddHR0eEqqC+nCuWL6VdShdYrechjPSk/q0HTNLq7u+nu7kZKSTgc5pOf/CTPPfcciUQCr9fL5cuX6enpqUtfo1/4hV/gV3/1VwH47d/+bX7lV36F3/u936t5u/XCpiU/1cz6t1J9TylomlYTgbAsi4GBAYLBIGfOnGnq8TVS+ZmZmeHKlSscPXqU9vb2um23XmOWUvK9jz3Gv3/xq0wqK8/stwqa5fbmSJhOVdfpOm1q+IwqU9/KmCVY8wazX+/FuyOGf/98zQGVW9hSIWZ6ckXspbFas1Zbakwlg0wlg2iKRbsnxaQnQL9/nogeX0ac1gqt9VRdv3BQSDsKaXSwQSWbIqcrdsX1QkJk0ys9qg3FZChXM5RxtOZ4xBd2sfq1WhiKAigSy9GQSYERbKDaWS690a3hQbVubyvsOxwMsKMjvKgmZGJighs3buD3+wtpUh6PZ5WNZ7GSKpT/e6VaoVaLlSrBeidvjuMs+/2FEDz++OP84i/+Ir/4i7/I9PQ03//9388nP/lJfv7nf54jR47w5je/mTe96U1Vl3S0tbUV/h2Px1vuGti05KdStFp9TynUEozH43EuXrzI3r172bat+Y3QGmV48PDhQ4aHhzlz5kxVzcFWQ63kJ++2k384/fPTT/OvL36hjiNsDOwm1fzMpPw4VMcsJAo+20tKS1W8rtsJ7dSDIKmHfoKHZ/H0ppoS+81lfKuSH7cExnI0JpNBJpNB7s130OOPcrBtgk6j9cn3FqqDjULSMUg6UKgXEja6YqFXmCJXTIbCZGtm0o5Gys4qQ40iQ3lyX7btaKn7YJWVHLlQ91N22BIEArnU4zr33Yr7zPXtWaT2rFTzU2hWumRzVcxP5N3eoHRNyMTEBIODg9i2TWdnJ11dXYTDYVfB6lJVqPiPlLJQW72eCcR6Hju4U646OztRFIU/+IM/AGBwcJC/+Zu/4dlnnyWVSvG6172On/qpn2LXrl0V7fvf/Jt/wx//8R8TDof50pe+VPUxNAJb5McFWrG+pxQ0TcOyKk/1mZyc5Pr16xw/fnwRW28m6m11LaXk+vXrpFIpzp07VxcZdylqIT9LiY8QgmcOH+bDL3295dWfZqW9TSSqzz/WhMKbd5zmz8e+VvnKlaSBSYXYlU4SQxah49NowcZaY2ccjaSl4dNK3+fV7Nt0NB7GOngY66DXN8fJzlFC+lZ/oI2NIkttxwBkIT2umnohIcCrWnhzqabFZCivDNVj5tftJkpNAjhSkEmrqJrN0lgwkfKQThkYhonXsFAUFy4VjoAMoEryLZSEqaAoGaQqcCxl0SYUS6DGBVJI7IiF1HLrVoIq0t5WMjworgnZs2cPlmUxNTXFw4cPuXr1KqFQiEgkQldXl6v096VECGBkZARd1xepQqqqrjsy0WqqRSVwQ36yDZFzEwtCcPz4cY4fP84HPvAB5ubmeP755zHN5arp6173OsbGxpZ9/qEPfYi3vvWtfOhDH+JDH/oQv/Zrv8bv/M7v8Mu//Mv1Oag6YIv8rIJWru8phUod7KSU3L17l4mJCc6dO+dK9m4U6lnzY1kWFy9eJBwOc/LkyZaz5y5FfPL4uVNP8W8GvljPYdYdzUp7q7beB6DbE+RdO1/Bn49+reI8qmpKGZyUxtx3etAjSUJHGmuNPZvx4dOiJb9bLe3NDR4lw3zuYYg9wRmOdoziVZvfH2j9hhml4SBQazwvjcfieiGBg5FLjzOqqBdaSoacHBlK2zppRyVdJzK08gBKfyalgmUqWKbMOsMVIW3qpE2dWNzB4zMxtBWu/bxChEDYAmyQuf8BKJpE6A4YS9bPvSqEFNmapNDq2wcQdu5YxPLvSh1fKbhxe4Ps5Glvby+9vb1IKYlGo0xOTnLhwgWAgmIUDAbLnjtFURgZGSkU2gshFqXG1dNKewuro5KapVLnNRwO80M/9EMll3/+eXc9Ct/1rnfxlre8ZYv8tALK3bytXt9TCpWM0bZtLl++jKqqnDt3bs0fPvWqn0kkEoX0vb6+vjqMbGVUM+Z8sWg+JWDpOfvHR47w4QvfYKqF1Z9mWF2btsJ8xlt1JHy4rY823UefJ8JYZqqidUXVDVLBnPIx/RUvvn1R/LtiDakJT1gGpqOgl1Co6lO3o3A3FuFBPMzh9nH2t002uT9QHb2hWwDr8UhkiXohXbEKhKiSeiEARYBPtfAtIkN6IU3OlG5DEXfXYdn7YJWvnbRGIuohZdgouo1qOFmysmwbsiBFidz/gJXVnGLFvNxh5DeVAjUDtif7p+KSIsAo0eenHIQQtLW10dbWxr59+8hkMkxNTXHnzh3i8TjhcJiuri46OztLZlU8ePCA8fFxTp06VQi8FUVB07SmNljdgnvlp94x7s2bN3nssccA+MxnPsPjjz9e1+3Xik1LflbDeqjvqQWpVIoLFy7Q399fcQ5no1AP5Sff5fjYsWOEw+E6jWxlVKO05dMSV3vA/9zJp/jgpdZVf5pBfiaTgZpqBp7u2gvAm3vP8NHhCl30ag70BcmhNpL3goSOzWB0puucCieYy/jo8i5vjFuy1qFKWFLj0kw/Q9FOTnaOsM1fWm3awupodc3HDWwUbMcglasX6tLjNV3TWTJk4lNNpIQHqXbc0ES3+6zlPpC2AEfgpDWctIaFRKgSRbcXp7G1mQjFwYnrSFPJDk6sohwXKzpJBRmwS0dgS/r8CAlaKkuEKoVWp9kXwzDYtm0b27Ztw3Ec5ubmmJyc5M6dO+i6XlCF/H4/w8PDTE5OcvLkyZJBt5sGq5VYaW9hdbghP6lUCq/XW9f9/st/+S+5fv06iqKwe/fulnJ6gy3yswzrpb6nWszOznL58mUOHz5MZ2fnWg+ngFqVn/v37zM6Orrm6XsrIe+IU0rtWYoffPwQ//7FrzBvtGYflmYYHtRS7wPwPb2HAHjb9pfx0eHnqSgErde71laIXoygBjOEjs+g+erYgDjjodOTWDbD3YgzE7e8fH18H73eeU50jqxquLCF5VDFRrMSr+9VluUMEumG/LgcQlnys9RIoPjfjkCaLKSbCYGUAttWFq8rQPE7KP7s/eCkFZzEKkFmkfKjTmuokyrS5yBDDk7IRvpyG5alFaKyv06JBbQGZKwoikJHRwcdHR1ANnCenJzkxo0bzM/PoygKhw4dcq0kNLLBaq2oZHKzVeGG/NS7xw/An/3Zn9V1e/XGpiU/S2/M9VbfUw0ePHjQMOezWlGt8uM4DteuXcOyLM6dO9dyfvyr1feUQiqVYmBggJ/cf4wPD7/UpFFWhmbU/Eylqn8QexWNkJ6dxdIVlb2+Pu4kR12vr9SQ9lYKdsxg9hu9ePrjBB6bR6m2+WoRJArzGQ/tnsXTwY20q36UauP5kSD72yY5HB7HaFA9kBAbQy3ZyLAcBV2tH6lThcSq40kvF3evSrRkUXwgs3+kLRfIUMEVbvGAFY+D4lnlN1mq6CAQKRVSKuqEjtQcnIAD2sKCldzOpeak6qX8rAav18uOHTswTRMhBP39/UxNTXH79m28Xm9BFXKjLLhpsJpfrhmq0Hp3eoMs+Sl3DLFYbENO9q+GTUt+irEe63tWQr6wsPhidxyn0ODs/PnzDXE+qxXV9l26ePEikUiEvXv3ttx5q5T4zM3NceXKFR5//HGe6OjgY39ylWmlilyHBqPRaW/xjE7Srn7yod+3OOXxmW1P8uGhv3C/gQY1/UyPBEiP+Ag8Pod3W7LmVLi5jI+wsdhiu55pb6UgUbg138P9WAdH28fYG5pugLvdxqr52Yh4kGpHFw7eXOqaTzVrIt6KkO4Yr1j018qLVaj8LPrPEm6Wi8jQkrG4RtFjRbHAmAapZ2t5HB2QCupcDYH2GpEfgKGhIeLxOMePH0dRFLq7u4FsC43JyUkuX76MZVkF97hqrbRLNVhtZHrcRiE/5WK+RCJRd+Wn1dF6UXCTsdHqe/IKSv6GzROEzs5OHn/88ZYjCNUiFosxMDDAgQMH6OnpWevhLEM5Y4OlePToEXfv3uXkyZP4/X4A/tmJl/FLg3/fhNFWhkanvU0mg9QS/B5v71/032/sPcl/HPorHFwqFQ191ynEr3WQGArRdmIGLWRWTR4sqZKwDAJ6pmjrzdFMMo7OS9M7GYpGOBkZobtE/VG1KJpc3xDYGE/cpRCYUsO0NKKWD5B4FQufmsGnmhhKZZbvaqmeOSX3mr0ypFzkN7B8uQqImJ1WwFFw4hpCc5COy3NW6Yld8txUAExQc9nNDlnX8fwfqdau/OgNDtyllNy+fZtUKsWxY8eWvefyVtq7d+/Gsiymp6cZGRnh6tWrBINBurq6iEQiGIZRdl+rNVgtNk8oNlioFZU4pbUq3BxDPB7fIj+bBUKIDVnfkyc/uq4XiF2rEoRqMTExwc2bNzl+/DihUGith7MMbo0N8svevXuXmZkZzpw5syjd8oePHeO3Br7JTIupP3aD094ma6z3eVX3gUX/LYTgcHAnl2N3Xa1f77S3UpAZjbkXutE6UoSOzqIa1alNsxnvIvLTaOVnKeZMP/8wtp/t/jmOd44Q0OpRp7aRqM9mgSDl6KQcnRkTFLKqkD9HhrQyamqlqpGUgtGxDnTDwmOYeAwLw1ggXKsRr3wZR548ZeZ85JmMTCu45GGVG6MssrBerm4qgJIh2zsI98NY2Ojyj9QGTnZKKbl58yaWZXH06NGyE3yaptHT00NPTw9SSmKxGJOTk1y8eBGgoAqFQqGaGqwWTzrWmh63UZSfcnXQW2lvmwipVIqxsbENV9+TJz+PHj3i9u3bG4rYSSm5d+8e4+PjnDt3ztVsUTNQbBNZibGB4zhcuXIFTdM4depUyYfsPzv+JL98+csNGXe1aGT5tpQwlfDXpL481bVv2Wfv3PEKPnjtrrsNNIH85GHNeJn5ai++PVH8eyq3xk7ZBmlbxZOrv1kbYVfwMNHOaDLEwbYJDoUnyga7q29tC+sdDgoJ20PC9gASXdj4VLOQJreU7FRjCiERZDI6mYxOlKwqpBsWHt3E0MupvAtXmTar4OjgeGWhFscVKk57K9pn0iH0wMb0K5h+Bdu7/Mav+BFYSvlpUNpbvkZaSsnhw4crzigRQhAKhQiFQuzdu7dgpX3v3j1isVhZK+2lKJUet5QQVWOasFGUn3LHnEgkNkyc6Bablvx4vV5OnTq11sOoOxRF4e7duySTyQ1F7PJEAWiJvkR5FNtdV1Lfk09H7OvrY+fOnSsu9+zx4/zWwDeZVVvHYauRhgezCR+WrVVNQEKaB11Z/rJ6ovMAujAwZabEWovRfAIhSN5tI3k/Z40dqcwaey7jo8cXA5qX9lYKjlS5NtfH3VgnxztG2RWcXbOxbKGVsJAiN79Cipxb5WfVPjd5MpTQUaY16LGWfL94/cyMB1WRCEdBTWXtpC2/g9uWQyItoIL5t9CQhaVDOqyg2BI1I1EzNt5ZG0elQIQsn0LFjZRYwfCgAe9JKSXXrl2r2NVtNRRbaUspF1lpa5q2yErbTYNVKJ0eV6lpguM46578uDmGLeVnE2Gj1L4Uw7IsZmZmaG9v5+zZs+vyGEs128pkMly4cIHe3l527drVUselKEphZiX/d7nxxWIxBgcHeeyxx4hEImX38b7jT/B/X/lKvYZcMxpZ8zM13lZT1tOewMr27afD+/j27LXyG2mi8rMIjkJ0IILiz2TrgfzuapSipodOTxxNkTnStLaGASnb4DuTu7kdjXCqc4QOT2UNe01bpQR/XbfYsm9YisUpcmlLwVAsdM3FfSeW/F0JlmzekQpEFRZdahVs17juRSBxwnb2T5sN3pWPwTMnCY9bpYaCYoMn6uCJOkgBlk8pkCGpuRxUiRi+3oYHUkquXLmCYRgcOHCgIe9iIQTt7e20t7dz4MCBgpX2zZs3SaVStLe309XVRUdHhytispIq5KbBqhvVpNWRN4VYDVs1P1tYt0gkEly8eJFgMMj27dtbiiC4Rb7XT/GNmq9bOnjwIF1dXWs4utJQFAXTNNF13RXxmZyc5NatWxw7dsz1TMu7Tpzkdy59u2XUH6eB19b03Xboq3790x0rq2jP7Xw135q5VlZVycYLaxeyOgmD2W/2YvTFCR6cRykbFArmTS+dOZLhtmdKozGdDvLF0QPsDs5wrGMMr2qVX4ksuV5LBaveWPsz0dowpUba0ujUypNk4ea6kCKburb0FjYVHFOC6oACwgKRXNLyopKBOyBsBXVSQZ3MZlhIj5MjQhZOuw1FiReiaC5jtWtCSNATDnrCQQK2ITADCpZfwfasEog3OO1NSsnly5fx+Xzs27evaTFG3kp7x44dOI7DzMxM4T3q8Xjo7u6uykq7VIPVfK1u3kFuI9T8uFF+4vH4qhkoGxGbmvwUpyytZ0xNTXHt2jWOHTvGxMREVf1yWgH5eqX8jZqvWzp58mRLzkpIKQkEAly6dKlQyLnSA1hKyfDwMOPj45w5c6bieqX3HnuCD11tDfWnUWlvlqMwf7cNehJUK/+8LtfctBQeC/URUH0knNWDLCHIzqKucW/KzFiA6TEfgYPzeLcnViVt8xkfHUbWPlsRYLfMY03hXizCw3iYx9vHOdA2iVomxWmLLGwuZJ3b6njWV7q8pABTRUkKRM6XQ3GWPMsqGEapy1ikFdRxBc8dDf8DE7vTIbkX0tucwj4rgQC0jETL2DCTTY+jw4A+L/OJxZNhjUx7cxyHwcFBgsEg+/Ytr6lsFhRFIRKJFDImEokEk5OTXLlyBdM06ezsLFhpuyEt5ay00+n0uidBbuqWtqyut7CuIKXk/v37jI2NcfbsWbxeL9PT0+uW/OSVHyklQ0NDzMzMtGzdUv4BefDgQVKpFBMTE1y+fBnbtolEIvT09BAMBgsPzuvXr+M4DmfOnKnqIfqjJ0/yO4PfZq4F1B+7QeHp1FwQbLXqtDcFwZHwtlWXearzcb4w6aJ5rGiVZCWF+I12Enez9UB6uLQ1ti0VYqaHkJHOOr61DPnJwpIagzP93Il2crJzhG3+6IrLuprd38KaImlpgEBVHDQcaokLZb3PeJmNCQcUe4UBV3LLl9mPisAzIvCPZP+rHlBs6FW9fORDP8HkfII//fuLfOGl2zyajdNmK8wr9qKiRa0O6ozjOFy6dIlwOMyePXtq3l494ff72bVrF7t27cK2baamphgdHeXatWsEAoFCrVA1VtrxeJyHDx9y8ODBNWmwWi+4IT9bNT9bWDfIGwBIKTl//vyiG3e9kh9VVclkMly/fh3DMKomCo1EqcalPp+v8AA2TZOpqSnu3r1bcK2Zn5+nt7eXPXv21JQq8N6jT/Dvrq29+tOomp/p0TYgG5xUEwx1Gv6yy/zErlfx/MRL5Q0FFHDbFqgZkBmN+e92o7XnrLFLdJKfzfgIGemWThmLW16+Pr6PHu88JztHaDOWk/l1mLG76aApMneVCTJSxbGyJ00VWWe3Sh7bUkLSNLgaDREw0vS3zaLVwk3KXf4lmphmV5PuyY8EsdpzULoYR5XwGNmwravNz8/8wFP8zA88hWnZaKrC5TtjfOz5F/n26CgJ3UEXtZEux3EYGBigs7OTXbt21WP4DYOqqnWz0k4mk1y6dIkjR44QDodLqkLFNb6tFqcUw22fny3ys4mwXtPe0uk0Fy5coK+vb5kBgKqqmGY9em00H1JKBgcH2blzZ0vmn5YiPkuh6zp9fX309fURi8W4cOECfr+fsbExYrEY3d3dRCKRqtSsHz15gt+9vPbqj9OgLqDTd9pzO6gu+j0Q6i67TK+3nQ69jVlrftXlhJAtSSGsWS8zX+vDuytKYF90kTV2xtFIWlrTe/1Ug/FUG8+PBNkXmuJI+yMMdYFpKlsWAesKiljcp8eUKnaODClIDGV1MiQRCCGxUZjP+Og0EwQ95V0ZV0K5K2dFV+06XnKNVC8NY3nYpmvZ4PbYvm38h3/yfQB85eIQsWT1v6Nt2wwMDNDV1dWS7+PVsNRKOz8pef/+faLRKG1tbYUGq0uttJPJJBcvXuTw4cOEw2FgbRqs1gtuUva2yM8WWh5zc3MMDg7y+OOPl3QKU1WVVKq1mmK6wdzcHNPT0zz22GMt+aDNz/rk3ejKzRxNT09z/fp1Tpw4QVtbW2Emanx8nPv376NpGt3d3XR3d7sq1ITsA/09R8/z69e+Wo9DqhqNeK0nTY3kaKCmHTzRucfVcq/tOs6nx762+kKt8+4qidT9EKkHAYJHZvF0pwpqyVzGt26UE4nC7Wg3w/F2jrY/Yk9oCqVEnfoW1heEAK2IDDmsbmCxdP5x1QlJN8S+rPKz0rbLb9r1Phqo/BiGOzXnH52svjbHtm0uXrxIb28v27dvr3o7rYLiScliK+179+6hqmpBFVIUhYGBgUXEpxRWa7AKraUKuck2SSQSLdkwvpHYIj/rCCMjI9y7d4/Tp0/j95dO8VmPaW+jo6PcvXuX7u7ulpx9qJT4PHz4kJGREc6cOVPorFw8E7V//36SyWShUNOyrGV1Qivhx0+e5D9f/jbzavUzerVDYNsCVa3f231yqo1C9FGl0cAbtj3uarkf2fkKPj36tVWDHaG0pvKzCI5CbLCThN8idGwaLWARt4yWq/cph4yj89L0DoaiEU5GHmLaCkYdr60trC3KqSB55QeyROjKg37a/Uk6gwk6Agk0deGBIIrWWnmDq9zYzspNTCvK5nXlyt2Ya7iU8lNPWJbFxYsX2bZtG/39/Q3d11qg2Eobspk0k5OT3Lhxg5mZGbq6ujBN03WD01qstFsFW1bXmwzrxQ463005kUhw/vz5VTse5/vNrAdIKbl16xbRaJTz588zNDTUcmMvzvEt9+CSUhZ6EZw5c2bVB6fP5yuk9y2tE+ro6KC7u5uOjo5l+xRC8NNHzvPvr5dRLhoMx1ZQ1fqdq+mHRbNsVaS96UKlz9vmatk23UefJ8JYZmrlhdbHowEAJ6Ex9+0ejJ4EwUNz2CsVc7c45kwf/zC2n04jRn8oStiz9uYeW2g85JJSG0cqTMeCTMeCCCRt/iSdwTiRUNzlBov+Xnofl5tYqZfs2EDlR3ep/FQDy7K4cOEC27dvZ9u21c1jNgo8Hg+dnZ0MDw9z9uxZHMdZZKWdN03w+Xxlt7WSlXY1DVabiVgstqX8bKG1YJomFy9epL29nVOnTpUlbJqmtRyBKAXLsrh06RJ+v5/Tp08XHgR5orHWcFPfUwzLsgpWoMePH6+IWBdL8vk+BhMTE9y4cYNAIEBPT8+iOqGfOHWK37vynTVVf5wq63JWwuytjoX/qCJo6PVW9uB+c+8ZPjr8+RW/F2vV6LQGZMb9TI/70HfGSPsUVL+N6rGoc5/DBkMwnQkxPRXCr6bZHpyjyx+vpuH9FhoIyxYIRaK4eM6VWySr/GT/tdTyWiKYS/iZS/gZmW8jGKiBEMtV6n0ALSHwTIPlA9sncQyQWVO7ZSiXfdfIy9XQGxO2mabJhQsX2LVrF729vQ3ZRysiX+Nz5MgR2tqyE2idndlm2Xkr7atXr5LJZApW2u3t7XWx0m60KuS2pj2dTrtOv98o2CI/LYxYLMbAwAD79u2jr89d58dWIhArIZlMFh6yxfnErZKyVynxSaVSDAwMsHPnzppny4r7GCytE1JVtVAn9E8Pn+M3b3y9pn3VgnqSn7mEFzO6YEUqnMoTRg63VdYZ9W3bX8ZHh59nRaa1rghDMQTmcAipSlJhieORKIaN5rFRvRaq10JZJyllCdvDjalehuMZenwxev3zGGprP9s2CwKGiZSCmKmj13g9LV57tVxUgem4CFlWGI6wxbKmpkvXU2yBEQNi2eUcJI4XLD84Homjk302rGnNT/3DNtM0eemll9izZw89PT11336rohTxKcZSK+3p6WkePXrE9evXC1bakUikkN6+GlYyTcgTovy/8w1W60GG3KbuSSlbRoVqFjY1+WnltLfx8XFu3rzJiRMnKpIjW4VArISZmRmuXLnC0aNHCzm3ebQCcauU+MzNzXHlyhUOHz687HhqxdI6oXw/oatXr3LUNAmYGnHdqus+3cJZ2hywBkxNLHnpVHEJvLyrsuJeXVHZ6+vjTnK05PfrUfkphmoL1GmB5ZGYbYJMRoOoB5AIzUHzWqh5QqS3MKGQ2YD3YbydkXiYTm+cbf55gsZa1rxtAbKKjkRQLspfbZnsxHT2GSsK/10jVtyGRFmFXJVScxQESgq0FOTHaes5ElQGjYou3BoeuEUmk+HChQvs27ePrq6uum67lVGO+CxF8eSjlJJ4PM7k5CSXLl3CcZyCaUJbW5ur2LKcKmRZVmGZaomJG/KzHh2P64FNTX5aEVJK7ty5w9TUFOfPn3fVnKsYrUx+Hj58yPDwMGfOnCmZP7vWY6/U2GBsbIx79+5x6tQpV/nAtcLr9S6qE/rRVJL/MjrY8P2WQj2Vn6n7S1x1qngWf0/vwYrXeWbbk3x46C9Kf9m68yIVQU0LmAfHC7ZXgiKQlooZUzFj2WWE4mRJkMdG81ooht2SjnESwVQqyFQqSFBP0+ufJ+Jt/ZS4Fh9eTViaplbx+kX/LmfR7vqaLNd/p5rviqCaAtVNN4lGKT91THvLt804cOBASffYjYpEIsHAwIBr4rMUQgiCwSDBYJA9e/YU6naHh4eJRqOEQqGCKuSmrcVqVtq11Aq5VX7yx7SZsEV+Wgi2bXPp0iU8Hg9nz56tiu2vNYEohbxhQzKZ5Ny5cysaNiiKsmY9iqSUWJZVGEe5ZYeGhpifn+fs2bOrGlA0Crqu83++8lX89z+5QWwNan/qpfzYjmD+dvuSjVf2EPapOj6tskkCgDf2nuQ/Dv0VToluputd+SmGEAI1DUo6V8vgYVFELh0FK2FgJSANICSqZ4EMrWnd0AqnIWZ6iM11cz/aQa8/So8vupUStwao9S4pJk+CcmRqYW+rPiGqJDh1bY8lyw2kehie+rxvUqkUFy5c4ODBg4Ual82AWolPKSy10p6fn2dycpL79++jKErBNCEQCFSlChX/AfdW2vnlVoObPkAbEZua/LQS083XwezcuZMdO3ZUvZ1WIz9528xwOMzJkydX/c3XYuyVprnZts2VK1cwDMOVAUUjIYTgnzx+lg/f/EbT9y3rpPxMRwNIa8nMVIUxww5fe1X7FkJwOLiTy7G7Jb6rapMtDYFASwqctMQOyGwxdylIgZ3SsVM6mTmAXN1QUapcq9QNmY7Gg1gHD2PtRLxx+gLzBPWtlLhmwalZ+Slav07KT1UjEiDryJ1z/g0NgaHXnvaWT/l6/PHH656u3cpoBPFZCiEE4XCYcDjM/v37SafTTE1NMTQ0RDwep729na6uLjo7O6uy0oYFF9qlDVaXkhjHccpOziaTyaZkrrQaNjX5aRVMT09z9epVjhw5QkdHR/kVVkErEbpEIsHFixfZu3evK8OGZtf8VEp80uk0AwMDbNu2rSaCWk/85Jkz/P61F4i5ysOoH+qV9jY1VuIFVOElcKK9+l4U79zxCj547e6yzzeM8lOqjsERiHlwPFklqLy5g8DJaNm6odxGFW0hVa6RdUNuz4JEMJkKMpkKENTT9PmjdLZKSpzYuG1b3ZyfaNKDodn4dHMZgbEchWRGR8vZ5te15scUoC++vlfq8QONUH4ag1qtrvPEp1wjz42GZhCfUvB4PPT399Pf34/jOMzOzjI5Ocnt27cxDIOuri66u7srstJeqgrlU+OWpsfl64ZWQywW23Q9fmCL/Kw5hoeHefjwIWfPnt1QVoNTU1Ncu3aNY8eOuX7ANlP5qZT4RKNRLl++3HIpAkIIfvLQGf7jrW81db92ndLepu+0L/+wQmL1mp7K633yeKLzAIYwyMglasEGzwIQQqBmQMlka4EcLxXE5wLHUnGK64ZUZ1Gq3NrVDQlippdbc170XEpcry+KvoYpcRlLw9BaR42vJ9wowLGEj9GpdlTVorMtTjiYJORNoSkSy1FImAbk5m4kgpX9EYo+dJMdZypgy6zFtZ0jN6vx0DoTlrqSqSJ4anB7WysCsNZoleNWFIXOzs5CDJFvdn7t2jXS6XTVVtqappVssJpOpxFCrJralkgkWrK5fKOxRX7WCI7jcPXqVWzb5vz5866L0tYD7t+/z+joKOfOnXNlAZlHs5SfSo0NJiYmuH37NsePH2/JGZJ/cvYc//X6d5uq/tQj7S1tqcQfBJfFIpUGDU9G9tQ0jtPh/Xxr9uqSTzeI8lMGAoGWEjgZie2XSBcuVqUg7dJ1Q4VUuWrrhmpIq1pIiQsT8SbWLCXOkgpGibqyjQDHBWMWSj5VR2NiJszETBhwCPpT+PxLzsdqNTmuDQ8WrQUSfKNK1vwDcBSwvWT7+CgUyNC6UX6qNDyIx+MMDAxw7NixTdXQMp+BcvTo0ZYjfMXNzm3bZmZmhvHxca5fv47f7y/UClVqpa3rOvF4nAcPHnDo0KFVrbS3lJ9NiLVKEctbS3Z3d7Nnz56WSlWrBY7jcO3aNSzL4ty5cxUTumYoP5UaG9y/f5/JyUnOnj3ryrVlLSCE4N2HzvBbTVR/bFm7NDI5E0KUklgq4L9h3Vvz/fPjO1/FN2euLgquxMaZi3AFxREoUYFtyGwqXK3HX1Q3lPugyrqh2qNIibLGKXEbk0gX21SvBqUkq1CIJfykbR1vcIEA1cUnoBRhLtqm4oCSABLZjx0tS4aqsdhffRx13l4O1Vhdx2IxLl26xPHjxzfVLH9e8VkPhE9V1QLZKbbSHhwcxLZtOjs76e7udmWlnUqluHTpEkeOHCEcDq/aYDUajW6Rny00HvPz81y6dImDBw/S3d3dsP3kVY1mId8dOhKJsHfv3qr23Ujlp9I0tzyRAzh9+nTLu6H805z6E2+S+lOPmp/phyukQ1aw7b2B2u1ZHwv1EVB9JJxk4bMNU/NTCUTWxreQCuejjqUqq9QNeS00j41Ssm6ons+w1kuJW89wpCCaMXCkwK+bGGrpiavS5CeHpadXCoTIPV+kXKQW1vI6W2kIAlAtUGPVb7uS/dUDlTY5jUajDA4OcuLEiU0V5OaJz9GjR1ue+CxFKSvt6elpHjx4wPz8/KpW2nkXv8cff7xQcrBag9Xnn3+eW7duNfcAWwBb5KeJGBsbY2hoiFOnTjX0IZRXUJplwRyLxRgYGODAgQM1dYdulPJTKfExTZOBgQG6urrYtWvXulDmhBD87wdP859uf7sp+6sL+bnVXvqLCgKHs527ah6H4zgcVvp40blT+GzNrJ1bAEIItLRAZiSWXyIrdxF3s5eiuqFsSkehbihPhgy7YbPnS1PitgXmCTQoJa71nx7VwUFgOypzaY25tA9NsfFrJj49g0ddqPlSVplIWNrbRxY+B2kLWLSuy4uh1GLNnsuQsmHnvRLlZ35+nsuXL3Py5En8fn+DRtR6yKe6rQfFxw10Xae3t5fe3l6klESjUSYmJhgeHkYIUWiwqus6Fy5c4NChQ6u6+OVrhf7yL/+Sr33ta3zmM59p3sG0CDY1+WlWUCul5ObNm0SjUZ544omGk5Jmkp+JiQlu3rzJ8ePHa37INEL5qZT4xONxLl26xP79+xuqzDUC7zl3nj+88VJT1B+nxrS3aMqDObuCu00FxOp1vYdqGodlWVy6dIkf6jjDC+N3CgHbRlF+apmBFlKgx7PW2Ja/DqlwZbBQN2QU6oYMaSHDGbR2syH22ktT4rb55+n0Jjak1Xm94UiRvcByaWaWozKfUZnPeFGETbs3hSLzLgOlsayxae4/S7q+VVXzkx+sy3XXAdzW/MzNzXH16tWmNeFuFaynVLdqIISgra2NtrY29u/fTyaTKbjHTU1N0dnZiWmaZRuc/u3f/i3/8T/+R/7mb/6mpUycmoVNTX4geyHJuvhrlka+z00oFAUNo/UAAMJOSURBVOLMmTNNIVzNqp25d+8e4+PjnDt3DsOofXq43uOu1NhgenqaGzdurEuZHLLX8k88dorfHfpOw/dVq/IzNbnK7+syUFGF4LFQ9UpjOp3m4sWL7Ny5k23bttE583lmrPnsl43MW2km6vC4USyBPgeON5sO1zQnPClw5nWscYNkWKIFTPS2DHrIRNSdCGVT4m7OeTGiVrZxqj+KrmygqLnOWK0hqSMVMo5GNOkhmVylVnLJJiQi22/HJkeqFs6zbSuoK6TWLdnI8t00Xflp3KbdKD+zs7Ncu3aNkydPbjris5EUHzfI22U/ePCAkydPoqoqk5OT3LlzB13XkVLi8Xg4duxYYZ3nn3+e3/iN39i0xAe2yE9DEY/HC31utm3b1rT9Npr8OI7DlStXADh37lzd6mHqqfxUYmwA8ODBA0ZHRzl9+nRFDnWthveef4KP3nyJhGo1dD+1NjecGm5f+UuXgUPEqD51NBaLMTg4uMi6/DVdx/n02NeAjZP2Vq95HSEEahqUNNh+idOsW0Qs/MOKG1hxg+RYjgiFGkOEMo7GcKyDB7EwXb44ff55Anpz+2itB6z2DMgrOlIKVnOWKKX8CEtBWsqSlDdIxT2kkxJdt9CMFd5vcoVePhuK/KwetuUn8U6dOrWh2meUQz5rYzMRH1iot967dy9dXV0AhX6RyWSSL3/5y3z4wx/m0aNHPPHEExw5coRPfepTfPazny0svxmxQV7xrYfJyUkuXLjAsWPHmkp8oLHkJ5PJ8MILLxAMBjl69GhdjQDqpYrZto1lWYvsHFeClJLr168zMzPDmTNn1jXxgQX1p9Gwa1B+HAlzt1fu/SRcbvtglarP9PQ0g4ODHDt2bNGs14/u+kcLQcsGSXurd+GBQKAlFLR5gWgsvwYWWxEvfCiwYgbJ0SDzN9uJDwfJzBnIOj/yJAoTyRCXpvq5PNXHVMpfNzK5EbAq+cn9LWUJglO83DLlZ3VIRyGTNkhEK1MzVmtu2gisleHB1NQUN2/e5PTp05uO+KxXc4NaUEx8SqXp+3w+3vSmN/G5z32Or3/96xw+fJg//uM/JpPJ8NM//dP81//6XxkZGVmDka89tpSfOkNKyd27d5mYmKi4z0290CjyE41GGRgY4NChQy05Y1BpfU++3qOtrY2DBw+uC2MDN3jf+Sf52I0LJLTGRae11PzMxAI4qVVSYVyKfy/r2lvxvkdHRxkeHi6p8AU1L32eCGOZqQ2j/DQKii0Q8+B4yFpjN+r3KndL5oiQFTNIiqLUuGCmjnblgqjpJTrrxVAqT4nbGE+VxRBkDQ+kFDmCs+T7vPJD1r1NGCbSUcAWOYaTvWBMS8kaXahygVgWqX2ltr0qNgE5NfTSF/bk5CRDQ0OcPn26Lmno6wWbtX+RZVlcuHCBXbt2uapPHhwc5FOf+hTPP/88O3bs4MaNG/yv//W/eO6555ifn+f1r3893/u938sTTzyxofpOroRNT37qWfNj2zaXL19GVdW6poNVikaQn/HxcW7dusXJkydbsk9AcWdjRVHKEplkMsnAwAC7d++mr6+vSaNsDoQQ/Phjp/i9Oy80bB+11PxMPSrTaM7l7fj6CswO8pMSs7OznDlzZkUzkDf3nuGjw5/fOMpPAw9DCIGaIWuN7culwtU70hcVbHMpEQrmU+MydSOz1aTEORvkUloKRwocR2DZKkJIdG2BDBYrP5BNIxWKRKoSmVEK16UjBemMjhAOmubk1pSgOlR1MbWC0xsgGigRllJ+xsfHuXv3LqdOndoiPpsAtm1z4cIFdu7cSW9vb9nlX3zxRX72Z3+Wz3zmM+zcuROAQ4cOcejQIf75P//nzM/P84UvfIGPfOQjJJNJXvva1zb6ENYcm5781At5b/X+/n527ardfrcW1JP8SCkZGhpiZmaG8+fPt2Sjz2JjAzfEZ3Z2lqtXrxYagG1E/LMnnuSPbl4g2SD1pxblZ/pue5mNlw96DEUl4nFHwot7Np08eXLVSYm3bX8ZHx1+ftVUnXWFJsgOAoGWzLrC2X6JrOMjQipVxq5SYEUNrGgREcorQnUgQvmUuIlkkJCepi8wT6entEtcrfVxrYri41oa6y+q+SleRlLgN8WQUsE0F06M0GSJ3LEKf8e1vIWbaHjw6NEj7t+/z+nTp1vy/dwobHbis337dlcTtxcvXuS9730vn/70p9mzZ0/JZdra2njmmWd45pln6jza1sUW+akDZmdnuXz5MocPH24J5wxFUepCfmzbZnBwEMMwOHPmTEs2+lxKfMohn/a00e0/hRD8+IGT/Je7LzZk+9UGdKatELtX5kXlIptom7eMepRDPrWxvb2dPXv2lCXGuqKy19fHTWXW1fa3sADFEShRgW3IbCpcPTIn6sEblhAhPZhBb8ugBc06EKGlKXHz9Phji1LiNir5kXLlSpqC8pP/byGRTs7JrZjUVPPTOKycZtkicxaNnDvRitLeRkdHefjwIadPn25aX79WwGYmPhcvXmTbtm2uaskvX77MP/2n/5T/+T//JwcOHGjCCNcPNs/dsgJqrfN48OABw8PDnDlzpmWCaU3TaiY/qVSKixcv0t/fX5BJm4W8NXU52LZdqO9xY2xw+/ZtYrHYqmlPGwn/xxNP8se3LjZE/bGrDOimZkO5KvZV4GLbR8LlH/xLrazd4pltT/KbI591vfwWiiBANcVCKpyXmgiMrCTtzeUGzagHM+oBIQtpcfUgQtmUuE4extqJFKXEOU7rTRrVA0vT+YrrcwrKjyNA5D6XAiyVBYayAkMoc871SQVhCzIRG9xkeK0FIWrgPi+89CIdHe0oikIsFuPUqVOb4n2Wx2YlPo7jMDAwQE9PD/39/WWXv3btGu9+97v5H//jf3DoUG398DYiNuZTuQlwHIerV68yOTnJ+fPnW4b4QO2W0XNzc7z44os89thjTSc+blL28mqPW2MD27a5dOkSjuNw8uTJTfOiUBWFH+zd15BtV1vzMzXiIs3QxaX7ZNvq12UsFuOll17iwIEDFbstvrH3JD51Y+TNixIpRs3Zr0BLKehzApGpZUN1G9JySIE57yHxMMT8zQ4SDwOYUT2rTtQAp8gl7sp0Lwlb35B1P9kmp/n/WnyiBFkylJo3SMc17LSCtMSyZUs+usucc+EItKiK/46BcU9DxMTCM6NVVLYGnW8BPP30U+i6zsTEBJZlMTAwwP3790kmk43ZaQshT3zq0VR9PcFxHC5evEhXVxc7duwou/zNmzf5iZ/4CT7+8Y9z9OjRJoxw/WFzRIF1RiaT4eLFi3R2dvL444+3nEuYpmnE4/Gq1h0dHeXu3bucPn0av99f55GVRzniVqmjWzqdZmBggP7+frZv317v4bYspJTcunWL7+/u4S8eDdVd/XGqjEqnb7eXXcZNykjXRJpvjX2Lrq4uuru7CYVChWsh3+fi2LFjVZlzCCE4FtrFGFMVr1sS+aLv3LYVQBECRQhURUHN/a0V/dFVBV1V0VUFQ1Ozf1QVj67hUVU8hoZX0/DqGj5dw2toeBSFR6MjbOvuYlf/NvwejYDHw8O5eb5xZ5jB0XHuzc4xk0phN4kRCSnQ49l6IMtfeSpcSavrRsDJEiFz3gNKUWpcoBZFSDCf8QE+JpMB2owM3f4oAWNj9Axa/gzIF/QU21uryFUePU5aQagyW+OTh1jYTkkULaqmFMSkgoOD1e4g9XxvVIkws2ZGYgP1qVVVwYMHD4jFYjz99NOoqkoymWRycpKrV6+SyWSIRCJ0dXURDodbMlW9WhQTn1Y0XWoUHMfh0qVLRCIRV5PRd+/e5cd+7Mf46Ec/ysmTJ5swwvWJTU9+KiUu0WiUS5cuceDAAXp6qu8u30hUo/zkg+X5+XnOnz+/ZurIaspPcX2PG+ITjUYZHBzk0KFDLVGL1SzkXQd9Ph+nTp7kR5Nx/uDeS3XdRzWpPPG0TnrShUJaRlUKqAYvO/cEpmkyNTXFvXv3iMVidHR0oKoq09PTNTer/ZG9TzNz44UC8fBoGh5NxatrePQF0uEzdLyGRkDX8Xl0/IZOwGMQ8GT/DnoN1CYEIPk01Vc8fXqZ7emOzjae3Lt4tnBkZp4v37rLdx+McWtimkfxOEnbahjRUCyBPgeON2eN7XY/azGvtIgIOeghcyE1rsrxSKEyZ/qYmfTj82bo8CZo9yTxqI1rRt1ISLm8lsnOKHi9Vi7NTS4zQSi5HQTSFmDJrCW25uK9VULdUVBQ0iLb60kBEAgJ/nuifp1+K0Cjan4UIZiamlpk3OLz+di5cyc7d+7Etm2mpqYYHR3l2rVrBINBuru7iUQi69oMYTMTn8HBQcLhsCsjreHhYd75znfyB3/wB5w9e7YJI1y/2PTkpxI8evSI27dvc+LEiZa+ASt1e8sXhfv9fs6cObOmStZKxK1S4jM+Ps7Q0BAnT55cEwVrrZBXJbdt21aQx//PJ5/i47cvkaqj+mNXEZVOTbXhKpotE//s9Ge7V+u6Tl9fH319fdi2zbVr15iYmEBVVa5fv053dzddXV1VvfRP9PfzX/63H6h4vbVALBZjcHCQxx9/nPb2dlfr9He08c7zJ3jn+ROFz9KWxTeHHvDNuw+4PDbBg7l55tIpN+Z7riCEQE2Dkgbbn7PGLrvSGmcyOQrmnAdzrogI5RWhasYls7VBjxJtPEqE8Gsm7Z4sEdLWkb36cCxMxi6u34F4zEd0VkVRbYKhFB6jgueNEEhAWkqxgFR60eLnQ5lz0HkljceRzEd0zJCC5ROgNOGCahDhEgJOnDixoqKjqio9PT309PQgpSQajTIxMcH9+/dRFIWuri66uroIBAItl7GyEjYr8ZFScvnyZUKh0IoubcUYGRnh2Wef5Xd/93d58sknGz/AdY4t8uMC+WL52dnZlrV7LkYl5CeZTBYaZbVCWlipsVdqbHDv3j2mp6c5e/Zsy5+reiIfBD/22GNEIpHC56qi8K59x/nI/fqpP9U4WE09cGkrXiZuONWx+Dp1HIcbN24ghODlL385QghisRjj4+O89NJLqKpKd3c33d3dLVWbVw/kU/yOHz9OIBCoaVseTeNVB/fwqoN7Fn0+NDnNl2/e48KDMW5PzTCZSJB27KpVGYFASxRZY5d7C7VKjFZEhITioNVKhBAkLIOEZTAaDxMyUnR4koSMVFPi81rgSIFcUjKcT3VzbJX52UDVv0n5xraLFy/57xwUB3wJiWPZ8MjGEZBpU8i0KZhBBcdozA/dKOXH0DXXqWxCCNra2mhra2P//v2k02kmJye5ffs2iUSCjo4Ouru76ejoaNn0uM1OfPx+P3v3lm/mPTY2xjve8Q4+/OEP84pXvKIJI1z/2PTkp9zsR14V8fl8nD17dl3MlrglPzMzM1y5coWjR4+6njFuNFRVLSg/ldb35E0oFEXh1KlTLftAbwTK1bn83Mue4r8P1U/9sSvs8yMlzLmo9wHKpr29tvdg4d8rWVmHQiFCoRD79+8nlUoxMTHB1atXMU2zZJ3QesSjR4+4d+9ezSl+5bCvq5N9XYvTRuOpDF+9fZ9v3XvA1UeTjMxHiZqZilQaxRaIeXA8uVS4lS6pFjxFspgIqQ5a3jUuYK0e9K/wA8lcfdB8xocqHMJGkg5vkoBei1tEc1F83K5uq2rPqyz5z5JzJsJePBZFgnfOwTuXfcdYBqTDKmZIwfQLUOt0sTWI/Gha9e80j8fD9u3b2b59O47jMDMzw8TEBDdu3MDv9xdUoUY+SyrBZiY+V69exev1sm9fecOi8fFx3v72t/Prv/7rvOY1r2nCCDcGNj35WQ2JRIKLFy+ye/duV9aCrQI35Ofhw4fcv3+/pSy6YaFHUaXEJ5PJFGwgd+7cua6D2krx8OFDRkZGVg2CVUXhnXuP8dHhC3XZZ6WGB7MJH1bcpYPaKmlvAjjdni36dGtl7fV6CznxpeqEWn32sxTu37/P5OTkmtm2B7wGbzx6gDceXegdIaXk8sg4Xx26z8DDR9yZnmUqmcSUzoqBrhACNcOCNbaHZcu2ejKYtBXMWS/mrLdAhIy2DKq/DBFaAbZUmE4HmE4H0BWLDk+SDk8Cj9Z69UEyo2T7/ahFTUkdELZAaqsQ2hogKlB+silyK58ELQPahA0TNg5ghgSZNhUzqGB7cMniSqBR5EetR/Os7Hs2EokQiUSQUhKPx5mcnCy4ouaJ0FpNEG1m4nPt2jV0XWf//v1lf/upqSne/va386u/+qu84Q1vaNIoNwa2yM8KmJqa4tq1axw7doxw2GW6TougnGnAjRs3SCQSa2pssBLy5KeS+p58uteBAwfo6upq0kjXHvl0zHg8zpkzZ1DLvBh//qmn+ZM7l0jXIYiqtM/P1Li7pqTAqoFDu+ErpLUNDg5y8ODBiswsiuuEls5+BgKBmuqEmoG8MUkqlWo5dVMIwbHtvRzb3rvo8+l4gn+4eY8X7o9wfWKK0WiMuGUuikkFAi1ZlApX/POvo3mMpURID2Vd4/JEqNKY2HQ0xpMhxpNBfJpJhyeZqw9qDQszmVbJjASR7ZnCORM2qPMqkqy7n9Rl4U9dyFDu2eMo5evBhI3r60cBPFGJJ5pVx201pwq1KZgBgdTcX4iNSnurRflZCUIIgsEgwWCQPXv2YJomk5OThQmicDhMV1cXkUik7DumHojFYly6dGlTEp/r16+jKAoHDhwoG/fMzs7y9re/nQ9+8IO85S1vqXq/qVSKV77ylaTTaSzL4m1vexu//Mu/zJ07d3j22WeZmpri7NmzfPzjH8cwDNLpND/+4z/Oiy++SCQS4ZOf/KSrmqRWQ2tFvmuApReYlJL79+8zNjbG2bNn8Xq9azSy6rES+bEsi4sXLxIOhzl16lRLqiOKopBKpVwTn6mpKW7evFm1rfF6RbGj24kTJ1ydy6z6c5yP1UH9qbTmZ/puu+tlV+4bD/sCXczMzHDt2rWaX45LZz9bvU7IcRyuXLmCYRgcO3asJe/fUugM+PnBU4f5wVOHC5/ZjsOL90f4+tBiC24cEFFwjKwpwnruRCdthcysl0yeCLVl0AwTR3NQtEqjY0HSMkhaBiPxNkJ6mg5vgra1rg8S2f9z0hoyH/Hnng0CAXZWBSKV+0rJkiDH60C1ylCO90mVxesv/R0cWRNvVm3wT9swnTWGN/0iWyuUN05Y7f5bR+RnKXRdZ9u2bWzbtg3HcZibm2NycpKhoSEMwyhMEDXiubiZic+NGzcAOHjwYNln+/z8PG9/+9t5//vfz1vf+taa9u3xePjiF79IMBjENE1e8YpX8OY3v5kPf/jD/NzP/RzPPvssP/3TP81HPvIR3vOe9/CRj3yEjo4Obt26xSc+8Qk+8IEP8MlPfrKmMawFNj35KUY+uJBScv78+ZaaVa0EiqIgl7jN5FP49u7dS19f3xqNbHVIKens7OT27ds8ePCArq4uenp6CAaDJR8Gw8PDjI2NcebMGQxjYzSldINSjm5u8c+ffIr/UQf1pxK3N9tR8E5tYz4fAbmAgsApEUE8bnRy8+ZNTp8+XdeJCSFES9cJ5ZsZRiIRdu/e3fT91xuqovDEnh08sWdlC+5r45PcT8+vK+VnJUhbITPjRc56yegSp91B9VmoPgvNm/3bfT8hQdT0EjW9KMIhbKTo8CQI6Jmqs7RqRvF+V0tbdQQiLdCnFaxOG7u98ueQW1Ul7wpXj/tVAEZCYiRsGLNxlCLjhMBy4wTRILc3vQnKSzEURaGjo4OOjg4ee+wxksnkoudiZ2cn3d3dhMPhmn/nzUx8bt26hW3bHD582FWmyzve8Q7e97738ba3va3m/eeVPwDTNDFNEyEEX/ziF/mTP/kTAJ577jl+6Zd+ife85z185jOf4Zd+6ZcAeNvb3sb73ve+wmT1esIW+ckhnU5z4cIF+vr62LVr17o7kauh1VP4iut72traOHPmTEF6v3PnDvF4nM7OTnp6emhvby/MkliW5SrdayMhHo9z6dKlZY5ubqFrKs/uOcYfPbhY0zicCgwPbLuL97zhKX75T7/kep2s+lOC/GQCTalzaaU6oXxt065du1p24qJeWGrBPTo6ypcGr/AXY1Ncn5/BWUd20CUhQAqBY6o4pprtJQSARPHYaD4LNUeGVK9dlsw4UmEm7Wcm7UdXbNo9CTo8Sbx1bmpcFsUpjC5PkVSrPJclVpMs7x2VJz+yAe9yxQHvrIN3Nmec4MmmyGWCClagivxGl9D0tX3X+Xw+du3axa5du7Asi+npaR4+fMjVq1cJhUKF9LhK04Y3K/EBGBoaIpPJcOTIkbJxZzwe59lnn+Xd734373znO+s2Btu2OXv2LLdu3eK9730v+/fvp729vfCe3bFjBw8fPgSyNcb5ZquaphEOh5mamlp3JQdb5AeYm5sr9MmoJqBsZQwPDzMyMtKyKXwrGRsUS++2bTM9Pc3o6ChXr17Fsiw6Ozt5/PHHNxXxKefo5hY//7Kn+cQnBmtSfypJe9vuOcQbjxzk//3LrzOfSrtap9TWFQRvPPt00xXZpXVCs7OzjI+PN6VOKE92K61t2gjImzq84zWv4kc0DSkl//PiZT5+8RJ343PrUxFacczZ1LFMuuiVLGSWCHmtLCny2aiele9Z01GZSIaYSAbxqlahkareyPqgUsfjtjFUtbdxCWIhJAhLLq7LyS3XjMtES4M2bhMYt+vWF6sUdL11slE0TVvUU2h+fp7JyclFPYW6u7vx+/2rBvWbnfgkk0mOHj1alvgkk0l+5Ed+hHe+850899xzdR2HqqpcuHCB2dlZnnnmGa5du1bX7bciNj35sW2bGzducPr06Q3VDFNKyZUrV7Asi3PnzrUkSXDr6JavvwgGg1y8eJEdO3ZgWRYvvPACPp+Pnp6eli5SrwdGRkZ4+PBhXWyNdU3lHbuP8vGHA1Vvo5K0t6c6sg3Xfuw1p/jdv/2Wq3VK1f30eENrnoqqKAqdnZ10dnYW6oQmJiYaUic0NzfHlStXOHbsGKFQqA6jXx/IG3kkEolFpg5CCN5x6hjvOHWMqXiC3/36d/i7odvM25l1Q4SkwP1YpcBO6thJncxM7jPFQfPai1LmFGMpuRGkbJ3ReJjReBtBPU2HJ0nYk0JpVCV+NcpPtSpentTIBR6kZGDX32dI9igk+xRSEQVnjV55jRQnDa313uOQvTfD4TDhcHhRT6GbN2+SSqXo6Oigq6trmVq+mYnPnTt3iMViHD9+vCzxSafT/OiP/ig/+IM/yE/+5E82bEzt7e285jWv4Rvf+Aazs7NYloWmaTx48KDQB3L79u0MDw8X4rC5ubl1KRpsevKjaRrnz59f62HUFaZpkkgk6Ovrc5VDuhaQUlbk6JYvcj9y5EghdS9v0VlcpN7T00N3d3dLqlzVoFJHN7f4hadezp9+4nLV6o/bPj8ZS+dsxxEAfuRVJ/nI518kZZVPyRFyebPDx0O9pRdeIxTXCe3bt6+udUITExMMDQ1x6tSpljFcaAYcx+HatWsoirJqUBAJ+Pm/Xv8q/i9exXfuP+Q/f+sFXpoYw25UcN8qcBSshIKVWJjoEWq2fkjz5dPlrCJDBUHM9BIzvTyMObR5so1Ug3q6pvogUfi7xO/tVmiq5lEmS0+MCCfbcjUw7hAYzw7Azm+/9V5/VWOt097corinkG3by3oK5SeIrl27xokTJ2pu0LzecO/ePaLRqCvjmkwmw3PPPccb3vAGfuZnfqbu8dzExAS6rtPe3k4ymeTzn/88H/jAB3jNa17Dpz71KZ599ln+6I/+qGCs8AM/8AP80R/9EU899RSf+tSneO1rX9uSMWY5bHryA9kgZqlBwHpFLBZjYGAAr9e7qOljK0FKiZULgN3M5I+MjPDgwYNlRe7FFp379u0rFGNevnwZ27YLs/CBQKAlf4dysG2bK1eu4PF4XDu6uYWuqbx99xH+28NLVa3vts+PzvbCuIUQPPPkEf7H16pTnJ7qKt/pei1RXCdkWdYiu9j29nZ6enpc1Qk9fPiQ0dFRzpw5s6HVzKWwbZvBwUFCoRB79+51fb2f37Wdj+7ajmnb/LfvDvCng1d4kIy2ZtArytszVwppK1gxAyuWN32RKPpyQwVHUZhN+5lN+9EUm/Zc/yBfLfVBuWORxaTTzQGKCpUfk2y0ssIqogThUm33w1kvMIz1F7KpqlroG5SfsMzXCQUCAR49elTI7FiP7+lKcf/+fWZmZjhx4kTZd4Fpmrz73e/m5S9/OT/7sz/bkN9ndHSU5557Dtu2cRyHd7zjHXzf930fR44c4dlnn+WDH/wgp0+f5t3vfjcA7373u/mxH/sxDhw4QGdnJ5/4xCfqPqZmQJQJ+jcGIyiDTCazIcjPxMQEN2/e5Pjx41y7do2TJ0+2lAtapY1L8y4oiUSCY8eOVaR6mKbJxMQEExMTJJNJIpFI3VxpmoF809a+vr6KHd3cwrRszn3i98lUqf687cx3EWVm2vcb38tzuxccaUzL5nv+7R9iOatPD8tXxTCXjOuLr/4/aDPWnwpSXCc0MzOzYp2QlJI7d+4wPz/P8ePHWzJVtVEwTZOBgQF6e3vrcr2Pzkf57a99iy/du0dcmnUYYX2gxcFRwWm6MJ0zVMibKRQZKnhVk3ZPknZPAkN1J9tcm+4h42iYUZ34cBtYIHUHxydR40pWuV0FagLSuzOu635+eNdx/vGuw/zrL32B6P00MdtEqhRS27bpPg4OSu49nMFa8nwPaIKYu920PF799AHe/4Hqe7q0AvKpbidOnEDXdaamppiYmCAejxMOh+nu7qazs3NDPv+Gh4eZnJzk5MmTZYmPZVn81E/9FMeOHeODH/zguohbWgyr/mDrbxqhAVjvyo+Uknv37jE+Ps65c+cwDGPVRqdrgUqJT34W2O/3V6V66LpOf38//f392LbN1NRUYbYpHA7T09NDZ2fnmteQlEK+yL3RTVt1TeVtuw7zJyODVa0vpYIQq19jr+l++bJ9vv7Efv72ws1V11MVBZOFbXsUbV0SH3BXJ9TV1cW9e/cAOHny5KZ60eXd7Hbv3k1vb31SG7e1hfi1N78OgC/fvsd/+c4LXJ6eaGgxuhtIWCNFqshQYS7/kUT1WCR8NvO+IA99GdoCKTq8CcJGCrUCZUaxQUmpqFOQaSvfv0cKKjI80BWF4319/NU73wVAKmMxMjvP+GyML125Q3uHj/f8n08A8NK3h/jbz1xg8Moo0bRJa0qA1cGzDpWfYhQTn3yq29KeQhMTE9y+fRuPx1NIHd4IaewPHz5kYmLCFfGxbZv3vve9PPbYY1vEp0FY33fSFgq9iQDOnTtXuKlaifxUSnxSqRQDAwPs2LGD/v7+mvefrwXq6ekpzMLnVbJAIFAwTGi0fbIb5B3djh492pQi93/x9Cv41CeukNEqd4SSZWZ3U2aAXf5tyz7/58+8gr+7cKtkH588lub19/taz6K9GpSqE3r06BHf/va3URSF/v5+otHomvUTajYSiQQDAwMNdbN71f7dvGr/blKmyR9+5wKfvnqNR+n42sTErXRKpcBO6dipBUOFqOLwyGuj+9NEuqN0tUUJGavUB5X63M0xVjjnpC1pguQ1NPb1dLKvp5OXHdy16LvTT+zj9BP7AJiamOdzfz3At749xPDoHGnHWb05aYtDN9avGlKK+BSjuKcQZJ8Nk5OTXL58GcuyiEQidHV1rZvsjWKMjIwwNjbGqVOnyipajuPwsz/7s2zbto1f+ZVfWXfHul6w9tHeFqpGJpPhwoUL9PT0sHv37kU3SauQn0qNDebn57l8+TKPP/544SFYT5SahR8fH+fevXvoul4wTKjVUa0aFNc2NWv/Hk3jh3Ye4X+MVq7+yDIRTFjdU/LzgNfgycd28I2bwyuuuzSb7lh4OYnaCFBVlYmJCR577DF6e3urrhNaj4hGowwODnL06FHa2toavj+vrvMzT5/nZ54+z52pGX7769/mqw/uk6KJz8lK3N7WAkWGCg8mgzxgG4Y/Te+OaXo65gl4MqXXk/m/lvfbKbl4hcYUWpXXf6S7jXf+b6/gnf/bKwCYGJvn+c9e4sUX73Lv4QxJy15XZMhjrM8awHLEpxT8fv+inkLF2RuhUKiQHtfqdZGjo6OMjo66Jj7vf//7CQaD/Pqv//qGfO63CrZqfsjmmztlahBaDdFotND/o1Rq1NWrV+nt7V3T3iCVGhs8evSIu3fvcvz48TWxHU8kEoU6ISnlIsOERkJKydDQENFodE1qPdKWxROf+P2K1Z9nTl5G01Irfn828C7e2v+6kt9NzMV567/7byuuq70qRUJb6An0myd/kNf0HqxofK2OZDLJwMAA+/bto7u7e9F3buuE1ivyCueJEyfWtMWAlJLPXrvFH373Ja7PTTe8OF5JgVRAtk4pZkXwhZL0bptmbKQTWygIRZKZ86KkQLEEiikxXYi0wpaY/e5rsd5z4An+j1Mvq2HkpTEzHeeLfzfId749xJ3708RNq6XJ0Dv/8Vne9dzLyy/YQqiG+KyG4p5CU1NTiwwVWs017tGjRwwPD3Pq1KmymSWO4/Cv//W/xjRNfvd3f3eL+NSOrZqfclhvsuL4+Di3bt3ixIkTK3rjK4qypspP3jnErbHB3bt3mZmZWVOHK7/fz+7du9m9ezeZTKZgzZlOpwu5x21tbXW9XhzH4fLly3g8njWr9fBoGs/sPMwnRy9XtJ5cxe7akYLXdq8crHSHAxzd3s3lhxMlv186MfyK7v0Vja3VkVc9iq3bi9HMfkLNxvj4OHfv3m2qwrkShBC8+fBjvPnwY8TTGf6/b77AX9+4wZSZapxCs75eN4uQjPq4G92+8gJuj80h6+Dm8lFfrfJTDh2dAX7onU/yQ+/M9iKLx9J88e8G+dY3b3P77mS2ZqiF4gOPZ32FbPnnXD3trJf2FEqlUst6CnV3d9Pe3r6mBGJ8fJz79+9z+vRpV8Tnl3/5l4nH4/zBH/zBFvFpAtbXnbTJkXeDmp6e5vz586uSBE3T1oT8VFrfk69Z0jRtUUPDtYZhGIU+BXnJfXh4mGg0Wni41pqOlHd06+3tZefOnXUcfeX4Vy//R3z6E1cxK1B/nFWmyU2rk5C+ctO6eDzOWw51cPnBROmAqWjbIc2DrqzfXPelKFY93AQEjewn1Gw8ePCAsbExTp8+3XIKVsBj8P5XPc37X/U0V8Ym+J1vfJtvjj7ELOWjXC1a+/TUDLepIsIWGKMeHN3B8Wf/oK+8tiaac/8Hgh6+/4fO8v0/dBaAZDLDV75wla9/7Sa3hiaYTWRAWbuT6PG01j2zGhpBfErB6/WyY8cOduzYUegp9OjRI65fv04gECioQs10vp2YmChM8JQjPlJKfu3Xfo2xsTE+9rGPtUwMtNGxRX7WCfLuZ4ZhcObMmbI3iKIoTU/lq5T4tFLwvxo0TaO3t5fe3l4cx1nUsC2fexyJRCoyTGiWo5tbeDSNZ3Yc5k/H3Ks/0ln5Guw1Dqz4Xb5h7euePsenLk1wZ2Jm2TLFV87uwNqlbtYbY2NjhdnAalWPevUTaiby6u7c3BynT59ueRvbI33d/OdnvhcpJX926SofvzDAndhs7WlxrV7zUw2KGo8ejHTS2eHhhfFHpFbpdqoIgSNBMRWUOQXmKBAh6XOQxmIi1Cjlpxx8PoM3fN9J3vB9JwHIpC2+/g/X+do/3OD6rUfMxNLIJpKh9aL8NIv4LMXSnkKxWIzJyUkuXrwIUPiukT2FJicnuXPnjqsJHikl/+E//AeGhob4+Mc/3vLPxY2E9XEnNRitPluaSqW4ePEi/f39rkmCqqqFeptmoFJjg1gsxuDgII899hiRSKRJo6wdiqIQiUSIRCKF3OOJiQnu3LmDx+MpGCasNsuUD/6PHTvWFEc3t/hXL/9H/Pkn3as/q6W9Pdn+RMnPi4N/r9fLz//gy3nf7//18oCwKPY53d6YPkfNxr1795iamuLMmTN1cxbUNI2+vj76+voW1QnduHGjZeqEpJTcuHEDy7JcNfZrJQgheNuJI7ztxBFmEkl+9+vf4bNDt5mz0lWRmI3UcLMUIsEAv/v27wXgq7fv8J++/DVuJuJYS/JYX3twL7/4ulfxuWu3+drQMFfHJ5lIxLFyREhqOSIUcHB02TLKr+HRePXrj/Lq1x8FwLYdvv21m3zl769z9foYU/NJnAaSIY+39ZWftSI+S1GsmO/du5dMJsPU1BR37twhHo/T3t5OV1dXXXsKTU1Ncfv2bdfE57d/+7cZGBjgE5/4REu4zW4mbP3aLY65uTkGBwc5fPhwReYFqqpims1p7lepscHk5CS3bt3i2LFjK9YsrQcU5x4fOHCAeDzOxMQEFy9eRAhRqMsoLugeHR1leHi4EPy3Ery6xg/uOMT/HLvqavmVrK4ztsbLOk8uWTbbi2p6enpR8H/mwHZ6w0EezS9uQ1jcJPG1vYcqOYyWg5SSmzdvkslkGpra2Yp1QvmaNq/Xy5EjR1p+omk1dPh9fPB1r+SDvJIXh0f4z996ge+Ojy4L7MthwxIgAf6cG1kmk8GYmuA/fd8b6O7u5u+u3+KjL7zE9dlpHAHx+TlmJ8Z5y6G9/NCpI4VN3JqY4nNXb/Od4RGGpmd5PBjhuadO0utvzfeEqio89cpDPPXK7DNKSsk3vnqNv/6LbzP2KMXUfAq7jte8t8XJT6sQn1IwDGNRT6HZ2VkmJycLPYXyE0XVvpenp6e5desWp0+fLptiJ6Xk937v9/jGN77Bpz71qZZLAd4M2HJ7I5tS1kyVxC3Gxsa4c+cOJ0+erNgRaWxsjHg8zv79jS0Ur9TYYHh4mPHxcU6cONHUHNxmI51OMzExwfj4OKZpEolEyGQypNNpTpw40bLydtI0efKTf+BK/Xnz43cIBqaXfW6bO/jQkV8t/LeUkuvXr2PbNocPH14W/H/+pVv84ie+sOgzz1MZov4kCoJvvf796zZoLg7+Dxw4sGbHka8TmpiYaFqdkG3bXLx4kUgkwu7duxuyj7WG7Tj89+9e4hODgwwnomXVIGFl3d4q7XPT0pCgpgXChrceOsi/esPTXLhwgQMHDixT9W3H4RMXBmkzdE62BZicnCw8HxthKNNs5PtWHT58mHA4jJSSK5ce8MXPXWbw8kMeTcWxaji8//v/+gFOnd1Tt/HWE61MfMohHo8zOTnJ5ORkoadQJdfjzMwM169fd5XOLKXkIx/5CJ/97Gf59Kc/3XKToBsIq564LfJDNkBplkriBlJKbt26xfz8PCdPnqxKDp2YmGBmZoaDBxtjD1yNscH169dxHKdkALyRkclkuHjxIplMpjA73wpuNCvhg1/6An/2qLz688ZD92gLTi77fJf2Bn5y7zuBbAB86dIl2tra2Lt374rXyZt/6WPMJResrT0vyxANJIkYAf7u1e+t8kjWFpZlcfHiRbq7u/n/2bvvwKjKtG3gV3rvyYQSUiAhpE4CKmADCyoYMgEEBBXXrquLu7ZddVXQby3vrojdXSuulSQ0E6woKioqmp6QBNLrzGQmbZJp55zvj+w5hgjkJJl+7t8/77sYkmeGycxzPeW+Y2Njx/8LNsIX8FAqlVa7J8S/5mNiYjB9umv2aBqru38Az3//M75oaoSOO/nniRvzv50fx/u1nzwW8DCOhJ+185JxYaQvkpOTRfdp41+PKpUKAwMDCAkJEXq4OOoi0cnodDqUl5ePe5y5/mgnvvysCuXlrehQDWAiM49/PX4F5qVNvfG3pTlz8BmLfz2q1Wr09/cjODgYkZGRp7zX29vbi6NHjyIrK0tUkHn77bdRWFiIffv2OWW1TidCpa6didlsRkVFBfz9/TF//vxJr4JZs8kpH3wYhoG7u/u4YzSZTKioqEB4ePjvmrG6Or6ow7Rp0zBr1iywLAuNRiNUowkODhYKJjjKB/2D556PfR/Wjrv7w7En/3dcEnk2gN8mwDNnzsSMGaf/wL72gmw8t//wb3/wv+89J9D+xSAmw2AwoKysDHFxcYiOjrb3cE4wtoCHpe8J8XcU58yZ4xDFPGwlOjgIDy5ZjJxQf2j9A/FedT3KNUqwo47Fca5Y8GCUgV4tUs678KTl209l9OuR47iTHkeyV+NpsfheNhkZGeMe5U6aNx1J835bEGhtUuOLjytQUtqC9u5+GFj2lOW1ff0c73gUH3wmc0LFEY19PfL3epuamuDp6Sm8P/r7+6Ovr29Cwee9997Dhx9+iKKiIgo+dkbhx4EMDw+jtLQUsbGxmDnzNL0URLBW+Bld2EBM8OGPAcyePRsymczi43FkfEW3OXPmCE0s3d3dT6hG09fXB5VKhYaGBvj6+kImk9m8LOdYfl5eWDljLnYpj572605W6lpv8kNSUJzw2MUWtFh/fiZe/fwIhk3/O376v/niWRHOd1yKf+wTWf22F0vfE+IngSkpKQgNDbXu4B0M/9jT0tIQHByM5ZnpMJjNeOvnUhTW1KBTr7P3EK0udsa0CQWfsdzc3BAWFoawsDAkJSUJjacrKirAsqxwXNOa1bomip/8iwk+JzMrPhLX3XYBrvvf/+7s6MWBjyvw66/NaOnQQs/8FoYc7c7PwMAAqqqqXCb4jDX2Xi/fU6i2thZDQ0MwmUxITk4W9XldUFCA//73vygqKnL63TFXQMfeMDKhNxqNdh2DVqtFdXU1UlNTLTJhGhwcxPHjxyGXy8f/YpEmWtFNo9GgtrZWmAxIyWQquvETT5VKZfdGlsMmI8768DWYT7P7c+HsdkSEdZ3wZx5MMu6cditqamomXM3uxaIf8O635QAAnzNMGAgZwkfn3orp/s7z2uGPQDh7MQ9g4veE+vr6UF1dPelJoDPjH/vpjv20aPvw3Hc/4lBb6ymPxTml/x17AwP8bcnZuPLMDKv8GJPJBLVaDZVKJVTr4o/H2ev4cH9/P6qqqqx63KtHNYADn1biyE+NePgfqxEY5Bh3RFxtx2ciBgYGUFFRgdjYWAwMDKC3t1fYNQ8JCfnd87Fv3z48//zzKC4ultyikB3RnZ/x2Dv8tLe3o6WlBVlZWRab6A4PD6Ompgbz58+3yPebSGEDYOQxdXR0ICMjQ3IX+viKbpmZmZN+7PzEU6lUgmEYREZGQiaTISAgwGYrng8c+AK7Vafe/Vma0IGo8M4T/mw2ezlSemdBLpdP+LEzDIsL//46TCwLn/kmDIfrcXjZPZMauz0olUqhQImrveZPdk9o9MSTr+Aol8sld5yDb1o7kcf+c0s7Xv+5BEeUnTDA9s2oLYoBPEwj4WfrxUugyJpn9R/JH9fk77b6+fkJx5FstWve19eHmpoaZGZmSnLyz4c+qT12fod3dOAd3VPowQcfRFNTEy688EIoFAqoVCo8/fTTKC4unlDFXjJlFH7GY6/ww/e/GBoaQkZGhkXrvPP3Lc4888wpfZ+JFjbgy/rq9XqkpaU5zD0WW+A4Dg0NDRgYGEB6errF/j35FU+lUomhoSGhEk1oaKhVg9B4uz/nx3UhOrJd+N8sByzrvwHnZC2a9GP/xwdfobikDj5ZJgTHeGHvebdM6vvYWltbG7q6uiCXy12+bOnoe0JarRbu7u4wm83IysqS3HEOpVKJpqYmyOXySd9JOVDfiLd/LUN5jxJmN9s2praIUeHnX5dfjItTrFthdCyO44RqXSqVCgCEXUprLRbxO7xSDPv8bpcUd3z4ohbj7fR1dHRg9+7d2LNnD6qqqrBmzRqsXbsWS5cudbmFMQdGBQ/GY4+zw3wlqODgYGRlZVl8DJa48zPR4GM2m1FZWYnAwEBkZGQ4zJlsW2BZFtXV1fDy8oJcLrfoY/fy8hL6EzAMA41Gg87OThw9etSqlZH8vLxx+fQk7FXVnvS/j73zozcE47z5Z0/pCMqf887BxyX14FggJXjapL+PrfCBd3BwENnZ2ZII+6PvCTU3N6O7uxvR0dGoqqqy+3FNW+ro6EBHR4eohoanc1FSAi5KSgDHcdhXVYv3yytR09tzQqEEZ8H3+bElNzc3BAYGIjAwEPHx8TAajULBhKGhIYSHhyMyMtJi1Qz5ssZiL7m7kv7+flRXV0s6+GRkZIy7yDNjxgykpaXhww8/RGVlJerr61FUVIQHHngAsbGxyMnJwYoVK8YtBESsh8KPHQwNDaGsrAwJCQmYNs06Ezx3d3ew7ORXESd6v0ev16O8vByzZs2STGlbnslkQnl5uU1KGo+eXPKVkVQqFY4dO2aRSl1jPXL+EhR/WAez5+8nYuyYam/RPklTnlwE+HpjcfIs/Mw24OzI2VP6XtbGsiyOHj0Kd3d3ZGZmSirscxyH48ePY3h4GGeccYbw784f16ypqRH6t8hkMqv2E7KHlpYWqNVqiwZeNzc3KNLnQZE+DyaGwYelVSisqsHxQa1DN0Z1G/X/2CP8jOXt7Y0ZM2ZgxowZYFkWWq0WKpXKItUMe3p6hEaWjlx9zhqkvOPDF24Se5fz0KFD+Pvf/46ioiLMmDEDMTExuOCCCwAAdXV1KC4uxqZNmzA4OIjPPvtMcneiHQEde/sfo9GIcZ4Li+jp6REuRE+lKo4Y33//Pc4+++wJ/72JBh/+sq8UKzzxb4qjK7rZw+hKXWq1WijJGRUVNeXVyb9+8Tn2qX+/+7Nwpgqx01qE/7005GZcKFs8pZ8FAKo+HTbu/S/2bLwOAZ6OOcFgGAbl5eUIDQ1FfHy8S03sxzM69CUnJ5/ysY93T8gZ8Tt9Op0O6enpNnkcepMJO46UYe/RWrQOj99I1dbczIC72Q1ggZ1XX4G50eNXd7SHse+RfOVN/njcePjdpOzsbJdu0H0y/I6PFO/4DA8Po6ysDKmpqaJCyuHDh3HXXXfho48+wqxZs077tXwfIWIVdOdHDFuEn9bWVnR0dNjsQvRkwg9f2ACAqA/2rq4uNDc3IzMz0+WPuYzV29s7qapmtjA8PCxU6mIYBlFRUULBhInSGYxYVPAqzB4n/n7MlykxZ1YrAMDMemBr0svwcrfMyu/rh3/CDYvOssj3srSJ9C9yNQzDoLKyEkFBQadtWjvW6AvqGo3GKruU1sbf0WQYBikpKXYJvH3Derz+Uwn2HzuGboPOIYLQ6PBTdP2ViAmz7qKepRgMBuGekF6vF5pPh4SE/O6zT6VSobGxEVlZWRR8JESv16O0tBQpKSmiFqt/+eUX3HHHHdi7dy/i4+OtP0ByOhR+xLBm+OFXSs1ms02LAEwk/EymsEFjYyP6+vosXqzBGViioput8GfglUol9Hq9UDAhJCRE9ATuvi8+w0fquhP+LDu6B4kxTQAAk2k6nkh93NJDdzj8KmBiYqKkGngCvx3vjI6ORkxMzKS/z9gVeGe4J8SyLGpqauDt7Y3ExESH2OnrHtThPz8cwRdNjdCY9HYLQqPDz5e3bkJ4gGP+G54Of5dSpVKhr68PQUFBiIyMREREBLRaLZqbm5GVleU0Qd1SKPiUYt68eaJOtJSVleGWW27Brl27kJiYaP0BkvFQ+BHDZDJN6Y7M6b5vWVkZwsPDJ7RSagliw89Egw/DMKiuroa3tzfmzp3rEBMBW3H20McwDHp6eqBSqdDf3y/6KNLJdn+yZFokzWoAAEz3uAC3zd5k9fHbE3/mXYp9qwwGA8rKyhAXF4fo6GiLfu+x/YQc7Z4Qv9sVHByMhIQEew/npJo1Wrxy+Bd809qCfsZo0yA0Ovwc3nw9fJ08IHAch4GBAahUKnR2dsJkMiE+Ph7Tpk1z2HBuDVIOPgaDASUlJaIbVVdWVuLGG29Efn4+kpOTbTBCIgJVe7OXwcFBlJeXIzExETKZzOY/383NDSzLnnZSO9HgYzAYUF5ejunTp09p9dcZ8RXdPD09rVKhzxY8PDwgk8kgk8lOOIpUX1+PwMBA4SjS2FAX4OON8wJn4Kvh30pbM6MKHpwbschmj8Eeenp6UF9fL+nLvnPnzrVKnwpfX1/MmjULs2bNEu4JNTc3O8Q9Ib4qp0wmG/f8vj3FhYfhiRUXAwCqupT4z4+/4nBnG4Y4s/V/+KglUmcPPsDI52ZwcDB0Oh18fX2RlZUFrVaLmpoaGI3GSe2cO5vRVd2kFPiAkZMSpaWlmDt3rqjgc/ToUdx44414//33Kfg4Edr5+R9L7/yo1WrU1dUhIyPDbvdBfvrpp9OWYZ1oYQO+sVlSUhIiIhzzUqu12LKimz2MXu1Uq9Xw9vYWjiJ5e3ujtrYWfcN63FD9HZj/7f6kRfQhNf4YDGYfPDnvZZedCHR2dqKtrQ1yuVyS5/3ttdtl73tCJpMJpaWlmDVrltWqclrb4aY2vPFLCX5VdlmtmaqbCXBn3ODGASV3OUdfrvG0t7ejq6sLWVlZJxxTN5vNwvE4/rI6H86d7RTAqUg9+JSUlCAxMVHUHKe+vh7XXHMN/vvf/0Iul9tghGQCaOdHDEtN3DiOQ3NzM5RKJc444wy7Tpb4Xj8nmyhwHAezeWRVUMyKqkqlwvHjx0XVuHc1jlLRzZr41c7g4GDMmTMHQ0NDUKlUKC8vh06nQ1BQENLnzcNl6i4U9xwDAJj/t/PjixiXDD7877JWq8X8+fMl0cNnNI1Gg7q6Orvtdo3uJzT6nlBJSYnV7wkZDAaUlpZi9uzZTv07vyg+BoviY8Bx3Egz1ZIyVPQoYbZgD6FbFs7HDL8g/NTcYbHvaU9tbW1QKpW/Cz4A4OnpKeyccxyHvr4+oRiCl5eXxSps2ktfXx9qamokGXz4xY45c+aICj5NTU245ppr8NZbb1HwcUK08/M/ZrN5yk1B+WNRAJCammr3cq6lpaVISko6IaxMprAB39MiIyNDcivffEU3Kd7z4KuayWQyeHp6QqlUQqvTYXNTGRhPDokh/chOrMc83zxsnKWw93Atiq/sZTabkZKSYvffZVtTKpVoamqCXC53yH4m1rwnxC92iD3v72w4jsOeyqN4v7wStX2aKTdT/fNZZ+GGBfMtNDr7amlpQU9PDzIzMye82DG2wmZERAQiIyMRHBzsFItDFHxKER8fL2qxo7W1FevWrcN//vMfLFy40AYjJJNAOz+2wJ8TlclkiIuLc4g3Ow8PjxOO8k00+PBV6gAgOztbchPArq4utLS0IDs722lX8iZLp9OhoqLihCOOM2fOhNlsxvkaNb4aaoPJDHAckO2ZNu7dMmfCMAyqqqrg7+8vuYIewMjKd3d392mPzNqbte4JDQ4OoqKiwqUXO9zc3LAqIwWrMlJgYhi8X1KJwuoaNA72TqqZqqeba+yINjU1oa+vD3K5fFLvZX5+foiNjUVsbCxMJhN6enrQ2tqKgYEBhISECK9JR9xBlnLwMZvNKC0tRVxcnKjg09HRgfXr1+PFF1+k4OPEaOfnf6ay8zMwMICKigrMnTvXocrfVldXY/r06QgLC5tw8OHvuERGRiI2NlZSE0CO49DU1ITe3l6nrOg2VeP1LxowGLC44DXMDBlEZkI7bvD4I7RaLYKCgoQ7GY74AS8G/7p39Avu1sC/7vlKhs74bziVe0L8BFCKR3vNZjN+/OVXfNc7iK86OtE2gWaqf118Nq7OyrTuAK2ssbERAwMDVmlcy7KscDxOo9HA19dXaK7qCLuqFHxKERMTI+peX1dXF6644gps27YNS5cutf4AyVTQzo8Yk53cK5VKHDt2DJmZmQgMDLTwqKaG3/mZaGEDftXfle+4nArfz8PDw2PSK4DOrLu7G01NTafd7Qry8cGyqNmoMJQj3HM25iXPA8dx6O/vF86/+/r6nlAwwRno9XqUlZUhISHBLtUZ7YnjONTW1oJhGGRmZjrt636y94RGV/OT2gSQP/KTGB+Hc6KjcR+A3uFhvPpjCT49fgzdhqHTTiM8HKHT6iRxHIeGhgYMDw9bJfgAI6/JsLAw4QilTqeDSqVCRUUFWJYVglBgYKDNFxmlHHwYhhGaVYsJPkqlEmvXrsVTTz1FwccF0M7P/zAMIxQAEIPv96LRaCCXyx3yeEh9fT2Cg4OF8rRi3tj5S85paWl2q1JnL6Mrus2aNUtSu10A0NzcDLVajczMzPFXyfV6rP/sJdx51gIsn7bkd/+d/4BXqVRwc3NDVFQUZDKZw37ADg4OorKyUnRDO1fCsiyqqqrg5+eHOXPmuOzr/mT3hKKioqDX64Umls4S1C2F79+UkJBwyoWu7v4BvPLjL/iysQka8++bqT509nlYJ0+zwWgti+M4HD9+HAaDAampqXZ53ZtMJqjVaqhUKuh0OoSFhSEyMtImpd0p+JRh2rRpmDFjxrhf39PTg9WrV2Pr1q1YsWLFlH52a2srNm3ahO7ubri5ueHmm2/GnXfeiS1btuDVV18Vfg8ff/xx4Wc98cQTeP311+Hh4YHnnnsOl1566ZTGIBHU5FSMiYQf/k6Al5cXkpOTHXKVdPSKVkJCgqg7K21tbejs7ERmZqZDbMfb0tDQECoqKiS76l9XVweTyTShQh3bfv0Et8mXws/j9K8tg8EAlUoFpVIJk8mEyMhIyGQyu6x0noxWq0VtbS3S09MdbvfW2vhJQEREBOLi4uw9HJsZe08oOjoa0dHRdusnZA98B/uJ9G9q6NHi3z8ewbetrRj4XzPVLeecjzWZqVYerWVxHIf6+nqhoIkjvA+xLAutVgu1Wg2NRgN/f3/hyKalQzkFn5FCPmJ6FWq1WqxZswb3338/FIqpF/bp7OxEZ2cn5s+fj4GBASxYsAB79uzBzp07ERgYiHvuueeEr6+ursaGDRvw008/oaOjAxdffDHq6uqc8liyjdGxNzHEvvnxR2NmzJjhsHcC+Ps906dPR1dXFyorK8FxnLD6PrZsLT/5NRqNkizpK+WKbnz3+sDAwAlf7v9z1iWiJoo+Pj6IiYlBTEwMzGYz1Go1GhsbodPpEB4ejqioKISGhtpl0slXNcvKypJcUQu+ml9MTAymT59u7+HYlKenJwwGA7y8vHDeeecJPa7q6+tt3k/IHviKdhPd6ZwdEYanViwDAFR0duPVn37FzBDnOiHAH/EE4DDBBxg5mREREYGIiAhwHCfsnpeVlQGAcDwuICBgSmOWcvBhWVY43SEm+PT19WHdunW45557LBJ8AGD69OnC+21QUBBSUlLQ3t5+yq/fu3cvrrzySvj4+CAhIQGJiYn46aefsHjxYouMR6po5+d/WJaFyWQ67df09fUJR2MctcnnqQobnGz1PTo6Gj4+PqisrERwcDBmz57tMB8EttLV1YXm5mbI5XLJTn5nzJiBmTNn2vznsywLjUYDpVKJvr4+oWFgRESETQJ4a2srlEqlqGN+rmZ4eBhlZWVITEx0qCIttsDviut0ut/d8xh9T0itVlu9n5A96HQ6lJeXS3Kxh+M41NTUwNPTE0lJSU7zeWc0GoXjccPDwwgLC5vUopHUg09FRQXCwsJENSofGBjA2rVrcdttt2HDhg1WGVNTUxPOP/98VFZWYtu2bXjrrbcQHByMM844A08//TTCwsJwxx13YNGiRbj66qsBADfccAOWL1+OK664wipjciG082MJXV1daGxsRHZ2tl0a/olxusIGo1ff+XPGdXV10Gq1CA8Pl+QEiK/otmDBAslVdONXfu05+XV3d0dkZCQiIyNPaBjY0NAAPz8/YdJp6WDCn/UfGhqSZAl3vpxzSkqK5O438av+LMsiIyPjd5NfNzc3BAUFISgoCLNnzxbuCdXU1JxwT8hZereMNTAwgMrKSmRkZEjuiCfHcaiuroa3tzcSExOd6t/P29sbM2bMwIwZM8AwDLRaLbq7u1FbWyt6p1LqwaeyshKhoaGigo9Op8OGDRtw4403Wi34DA4OYs2aNdi+fTuCg4Nx22234aGHHoKbmxseeugh3H333XjjjTes8rMJhR/Bqd4IOY7DsWPH0N/fjzPPPNNhJ8kcxwl3lsabzHl5ecHPzw8GgwHZ2dkwm81CP4KwsDDIZDK7HUOyBb6im7u7uyQruo1Xytoe3NzcEBoaitDQUCQmJgpHPkZX6ZLJZFPeneP/7T09PU86+XV1/L+9FCe/fBNqHx8fJCcni/q3P1k/If69cir9hOxh9OTXURfwrIX/t/fz83P6Ew4eHh4nLBqNrWjI/7fR5dqlHHw4jkNVVRWCgoJE3WscHh7Gxo0bsXHjRmzatMkqYzKZTFizZg2uuuoqrF69GgAQHR0t/PebbroJOTk5AEb667W2tgr/ra2tzS4nNVwNHXv7H47jYDQaT/gzs9mMiooKh292yDCM6P49wMiFu9bWVmRkZJzwRshfuFQqlejt7UVwcDBkMpnDNmabDCn3LwJG7rg0NjYiMzPTaT4E+dV3pVIJhmGEggkTPfvO/z6HhYUhPj7eegN2UGq1GsePH5fkEU+GYVBRUYHQ0FCL/NtPpZ+QPfBVPKU4+eVX/YOCgpCQkGDv4VgVf7xdpVLBYDAgPDwcfn5+aGtrQ1ZWluT+7fng4+/vj9mzZ4/79QaDARs3bsTKlStx2223WWV+wHEcrr32WoSHh2P79u3Cn3d2dgp3gZ555hn8+OOP+OCDD1BVVYWNGzcKBQ8uuugi1NfXu8yczIqo2psYY8MPfyZ+1qxZDpuyJ9q4lD/rzjdzO90uFn8MSalUoqenBwEBAZDJZIiMjHTY3a/xDA8Po7y8XJIV3QCgpaUFKpXKqe+48Ec2lUolhoeHER4eDplMhpCQkNO+/qV8uR8Y+WBta2uDXC6XXDlns9mMsrIyREdHi7rkPFGOfk+ID71ZWVmSq+LJ3/MICQmR3IIHwzBobW1FU1MTvLy8EBISItypdNbP8Ingjzn6+PggMTFx3K83Go245pprcNFFF+HOO++02sLooUOHcN555yEjI0PYMX788cfx/vvvo7S0FG5uboiPj8e///1v4bPqH//4B9544w14enpi+/btWL58uVXG5mIo/IhlMBgAjBwNqaqqQmpqqtCYzNHwwYdhGLi7u4/7i8qX5/b19Z3wRU/+w727uxs9PT3w9vaGTCZzqgaWfX19qK6uRmpqKkJCQuw9HJuabClrR8cwjFAwob+//4QP99GPkb/flJSU5LCFSqyppaVF6N8khUnPaHzonTVrlqhGhpZwqn5C9rgn1N3dLdkeRgzDoLy8HBEREaLuebia3t5eHD16VAi9fBPqnp4eeHl5CdXjHCGgWxrHcTh69Cg8PT1F3e8ymUy47rrrsGjRItx7772SOxHioij8iGUwGNDe3o6WlhaH3iI+XWGDkzEYDCgvL7dYVS+dTgelUgmVSmXR+xjW0t3djaamJqc66mUpfCnrgIAAl25gyXEcent7oVQqTziG5O3tjbq6Ooe632Qr/H1FvV6PtLQ0lwm9YvFtCebMmWO3oh78PSGVSmXze0KdnZ1ob2932Cbc1jTRXi6uZnTwOdnn8vDwsFA9zt4B3dL4oiZubm6iriuYzWbcdNNNSE9Px9///nenf/xEQOFHDI7jUFlZCZ1Oh4yMDIddIR0dfMR8ePLVfZKTk0U3spsIvV4vBCGGYYQdodGXLe2F4zg0NzdDo9FIetV7+vTpkpoA8DuVTU1NUCqVCA4OxrRp0xAVFeWwAd3S+MIOHh4eoi/3uxJ+ty85Odlhdu9teU+ora0NSqUScrlccncDGIZBaWkppk2b5rBH1q1pvOAzFh/Q1Wo1+vv7bd5ywJL4Uw4cx4l632MYBrfddhsSEhLw6KOPSu590sVR+BGD4zi0tLQgOjraYX8BJlrYQKlUoqGhAZmZmTap7mM0GoWL6QaDQdgRCgwMtPlzyrIsjh49CgCYN2+e5Fa9HaGUtT11dHQIq94MwwivS5ZlhdelIwR0a+Av9/P3HBz1/cxa+AUfR97ts+Y9oebmZmi1WmRkZDjd5HWqzGYzSktLMXPmTEne7Zto8BlrdMuBnp4e+Pj4CMfjHH3hiN/pNpvNmDdv3rjveyzLYvPmzYiMjMSTTz4puTmCBFD4EctoNGKc58MuJlPYoLm5GT09PXa73G42m4WL6TqdDhEREaIupluCyWRCRUUFwsPDERcXJ7nJH3+/SapNDJuamtDX13fSyR/fLFCpVEKv1wuvS1c47gGMvPbLysowbdo0Se328fjJX0ZGhlOFW0vcE+I4Do2NjRgcHPxd81YpMJlMKC0tten9Lkcy1eBzMkNDQ8LxOIZhhNdlUFCQw71fHjt2DAaDAampqaKCz9133w0/Pz9s27ZNcr8rEkHhRyyTyQSWZe09jBNMNPiM7mGTnJzsEL/UYy+mh4aGQiaTISwszOLjk3pFN2csZW0poxtYitntYxgGPT09UCqVwn0Ma70ubcFgMKCsrAzx8fGSfO339PSgvr7eopM/e5jMPSF+1dtoNIqa/LkaPvjExsae0C9FKqwRfMYymUzC63JwcFAoMOMIrTAaGhowNDSEtLQ0UXOk+++/HwzD4IUXXnDK93oiCoUfsRwt/Ey0sIHRaERFRQWioqIwa9Ysh/wA5M+9K5VKaLVaBAUFQSaTWeR8sZQrugGuUcp6svjCDoGBgZNqYjj2dRkYGCi8Lp3hrhh/zHHu3LlWudvn6Fy1qpmYe0J86AcgyftdRqMRpaWlSEhIQFRUlL2HY3O2CD5j8a9LtVoNjUYDX19f4XVp63Lqo3c7xQSfLVu2oLe3F//5z38o+Lg2Cj9iOVL4mWjw0el0qKiocKo7HmN7Cfn7+wsFEyY64ZRyRTdXLWUtlqWPenEch4GBAeF16e3tLdzHcMQ+Kf39/aiqqnLoOy7W1N7ejs7OTpevanaye0IRERHo6+uDv7+/qJK+rsZoNKKkpMSuFf3syR7B52R0Op3wuuQ4TjgeZ+37vs3Nzejr6xN1zJPjOPzjH/9AW1sb3nzzTbvvVhGro/AjltlsBsMw9h7GhAsb8Mc90tPTERgYaIMRWh7/wa5UKqFWq4UJp0wmO+1K7uiKbhkZGS49+TkZvn+Tv7+/S5eyPhW+nPHs2bOttuo7NDQkVDQEILwubVFEZDwajQZ1dXU2K2riaEZXc5TaZIbf7WMYBp6eni5VrlgMg8GA0tJSJCYmSrJ/l6MEn7GMRqNwPE6n0yEsLAxRUVEWP07c0tIiFPYQE3z++c9/ora2Fv/973+dYjefTBmFH7HsHX4mer8HAFpbW9HV1eVyndtHTzjd3Nwgk8l+10tI6hXdjEYjysvLJXu5fXBwEBUVFUhJSUFoaKhNfqbBYBAuphsMBkRGRkImk9nlAjB/1EsulzvkjpQ1cRyH48ePY3h4WJI9jPgGnnxRF3v2E7IHvV6P0tJSyR7z1Gq1qK2tdbjgMxbLstBqtVCpVNBqtfD39xeOx01lvtLa2gq1Wg25XC4q+Dz33HP45Zdf8P7770tugVTCKPyIZc/wM5nCBnV1dTCbzUhJSXHpVU++EpJSqQTDMMKH+vHjxyVb0U3qpaz5HQ97VvXiJ5xKpRKDg4MICwuDTCZDaGio1SecbW1t6O7uluT9Lv6OC8dxokrauhqz2YyysjJER0efdNHDlv2E7GF4eBhlZWWYN2+ezRY9HImzBJ+xOI474XgcAOE4sb+/v+jfY76HVVZWlqjg88orr+Drr79GQUGBSy0Qk3FR+BGLYRiYzWab/9yJ3u8xmUyorKxESEgIEhISJPXhbzQa0dHRgcbGRnh5eWHatGl2W3m3FymXsgYcc8eDX+FUKpXo7e21aCGP0fhyxgMDA0hPT3fpRY+TYVkW1dXV8PX1leQxT76qWUxMjKg+Nie7J8TvVjrj3Uh+0SclJUWSRW2cNficDN8XUKVSQa/XC8fjTrd41NHRIZx0Ge+9j+M4vP766/jkk0+wa9cup3++yIRR+BHLHuFnosGHL+UcHx8vyZKeoyu6BQQEnLDyHh4eLqy8u+qkSMqlrIGRc95qtRqZmZkOe26b4zj09/cLBRN8fX0hk8mmfNRjoqW8XQ3fvDU0NBTx8fH2Ho7N8VXNplLK3BL9hOxFp9OhvLxcsos+rhR8xmIYRjge19vbi8DAQERFRSEiIkLYrezs7ERHRweysrJELfrs2LEDu3fvxt69eyX5WUko/Ihm6/DDcRzMZrPo+z29vb2oqamRbCnn0038WZYVglB/fz9CQkIgk8lc6sy7lEtZ831M9Hq9093x0Ol0QiEP/v5aVFTUhD6QWZZFVVUV/Pz8JLnjMd5RL1fHX+63ZFUzZ7onxN/vk2pFQ1cOPmPx1TZVKhV6enrg4eEBHx8f6HQ6LFiwQNSi13vvvYf33nsPH330kVM1OyYWReFHLJZlYTKZrP5zJlPYoKOjA21tbcjMzHT5N7+xJlrRzZq9hOyB4zjU19fDYDA43cTfEvijTt7e3khKSnLqif/YlXf+CNLpSsKazWaUl5cjMjISsbGxNh6x/RmNRpSVlUm2gSV/xyU5ORlhYWFW+Rlj7wnxbQcc4Z4QH3wyMjKctprpVEgp+JxMe3s7Ghsb4e/vD6PRKOxWhoSEnPQ9s6CgAK+//jqKi4sl+XohAgo/Ytki/Ew0+PBVjXQ6nWTP+E+lotvYI0h+fn4O86EuhtRLWfMT/4iICMTFxdl7OBZlMpmgVquFkrAnO7bJT/zF3vFwNXwpc6n2ceH7t9nyjgt/MZ3frbTnPaGBgQFUVlYiMzNTkiv4fPDJzs52mPuNtqRSqdDY2Ijs7Gx4eXmBYRhht7KxsRFvv/02VqxYAYVCgbCwMOzduxcvvvgiiouLJXk6hpyAwo9Y1g4/Ew0+fNd6qTaw4ye+lqroNvpDXaVSwcvLSziC5IgfLFIvZW0wGIQV/2nTptl7OFbFsiw0Gg2USiX6+voQHByMkJAQtLW1SbaiH3+5XapVvRzlqJder4darYZSqbTpPaG+vj7U1NRItoeV1IOPWq1GQ0ODEHzGYhgG3377Lfbs2YNvvvkGfn5+6Ovrw549e5CZmWmHERMHQ+FHLGuGn4kWNtDr9SgvL0dMTAxmzJhhlTE5MlsUdhgeHoZSqYRSqQQAoZeQI1yO5Cd+c+bMsVrzTkfGr3hLsY8Hx3Ho6upCbW0tvLy8EBgY6FS7lZbAr/jbe+JvL/39/aiqqnK4HQ9b3RPiG3jK5XKHeD+2NakHn56eHhw7dgzZ2dmiisR8/vnnePLJJ5GXl4evvvoKGo0Gl156KVauXIkzzjhDckfFCQAKP+JxHAej0WiV78sXUhDzS8h/8M2bN89qZ7wdGV/RzR7NK5VKJcxm8wl3MWxN6qWs+ccv1YkvX9iE72E09ggSv1vpquf/+YmvPXs42ZOzTPytdU9I6ndcpB58NBoN6uvrRQefgwcP4uGHH8b+/fuFKogDAwP47LPPsG/fPpSUlGDhwoW44oorcOmll1p7+MRxUPgRy9LhZzKFDbq7u9HU1ISMjAxJbvU7Qilnk8kkXEofHh5GREQEZDKZTcrBOsLjtyeVSoWGhgbJPn61Wo1jx46dcuKn1+uFY5t8w9+oqCgEBAS4xLFYfsVXLpdLcuLrrI9/7D0hd3d3REVFTXgnnW9eLNXgwz9+qQafiQa/b7/9Fvfffz+Ki4tPeSeSYRgcPnwYDQ0NuOaaayw9ZOK4KPyIZcnwM5nCBk1NTdBqtaIqmrkajuNO6OHiKI+fYRjhvDvfSygqKgphYWEWn2y2trZCqVQ61OO3pfb2dnR2dkIul0vy8Xd2dqKtrQ1yuVzUiufYkM4XTDhVFSRHxzevzcrKkmQndv4Stys8/sncE+KDX1ZWliQn/vyOh1QfP7/jKTb4Hj58GHfddReKiookeSeWjIvCz0QYDIYpf4+JBh++lK+npyfmzp0rufOpLMsKzRtTUlIc9vGPvZRuqV5CUi9lzXEcGhsbMTAwIMmKhgDQ3NyMnp4eUZ3LT4ZhGOG16Yx9rtrb24XO7Y7avNaaurq60NraiqysLJcL/mLuCblS8JsMqe/48MUtxAafI0eO4E9/+hP27dvnclVAicVQ+JmIqYafiRY24Ct6RUdHY9asWVP62c7IbDaf0LXdWVasOY4TeglpNBrhUnpERMSEJm98KWs/Pz9JVvTjOA41NTVwc3PDvHnzJPn4Ld28lWVZ9PX1Ca/NgIAA4bXpiBPrpqYm9Pb2IiMjQ5LBV0rB72T3hHx9faHVarFgwQKHfH1am9R3fPr7+1FdXS36jltpaSluvfVW7Nq1C4mJiTYYIXFSFH4mwmg0Ypzn5JQmWthgcHAQlZWVSEpKQkRExKR+pjPje3jExcU5dSljviM1f97d19dXuJR+ug9zk8mEsrIyyZayZhgGFRUVCA4ORkJCguSCD8uyqKmpEXZ8rfH4OY7D4OCg8Np0pPLufA+z4eFhSe54AkBLSwt6enqQmZkpueDHH3VuaWmBt7c3PD097dZPyF6kHnz4qo5yuVzUHefKykrceOONyM/PR3Jysg1GSJwYhZ+JmGz4YRhmQoUN+IvN6enpkuxCzFe0s2VFN1sZHBwU7mLw1blkMtkJH25813aplrLmdzynT5+OmTNn2ns4NscHv5CQEJvuePLl3VUqFTiOO6Fggi1xHIejR4/Czc0NycnJkgu+ANDY2Ij+/n5kZGRIMvh1dnaivb0dWVlZ8PT0tFs/IXuRevDh+1iJLedeU1OD6667Du+//z7S0tJsMELi5Cj8TMREw89kKrq1tLQIF9uleL6Zr2gmhYp2w8PDQgltfrLp5+eHhoYGpKamSrILNd/Dac6cOZJs3mkymYSjrvbc8TMajUJI1+v1NqtqyLKscNRzzpw5LjmxPR1+x0uv1yM1NVWSwaejo0MobnKyo35j7wk52x228Ug9+Oh0OpSXl4sOPnV1ddi0aRPeeecdamBKxKLwMxEmkwksy4r62skUNnCGi/3WwnEcWltboVKpJFnRzGAwoLGxEZ2dncLRuOjoaJcpUywGf8xBqsHPYDCgrKwM8fHxQk8KR8BXNRx9KV0mkyEsLMyi71MMw6C8vBzh4eGSvKjMcRzq6urAMAxSUlIk83s/WltbG5RKpejiHie7J8TvWDrjZwgFn5Hgk5GRIerUS2NjIzZs2IC33noL8+fPt8EIiYug8DMRYsPPRAsbmEwmVFRUCB/6UvvQY1n2hA99qQU/YKSUdXd3N+RyOQAIRzxs3UvIXviKRpmZmS6/43cyQ0NDKC8vx9y5cxEeHm7v4ZwSP9lUKpXQarWTLuYxltlsFu64SfGoI1/cw8PDw2p3vBxda2ur0M5gMnecxvYT8vDwcKp7QlIPPkNDQygrKxPdwLqlpQXr16/Hq6++irPOOssGIyQuhMLPRIgJPxMtbMBPembPnu1Qq7224qwV3SyFr+g1PDyM9PT0371mGIZBT08PlEolBgYGEBYWBplMhtDQUJcJiV1dXWhpaYFcLpfkhz5/x03sh76jGF3Mo6enB97e3kLBhIkc2TUajSgtLUVcXByio6OtOGLHxB/18/f3x+zZsyX3HgiMlHPXarXIzMy02PuaM90T4vsYZWdnS/K4O3/PNTU1FcHBweN+fXt7O9atW4cXXngB55xzjg1GSFwMhZ+JMJvNYBjmlP99ooUNtFotjh49irS0NFG/8K5Gr9ejvLwcsbGxTl3RbbJYlkVlZaXoUtYsy0Kr1UKpVKK3txfBwcHCWXdnrQbF97DJzMx0+VK+J+NKO146nU64JwRACEKne1x8VcfExERJVrVkWfaE4hZSNLqPl7UWdBz5npDUg49er0dpaSlSUlJEHXfu6urCFVdcgW3btmHp0qXWHyBxRRR+JuJU4WcyhQ06OjrQ1taGzMxMUY27XI0rV3QTgy9lPdkeThzHCf1aenp6hH4tkZGRThEi+PsNJpNJshe7u7u70dzc7JI7XgaDQQhCRqNROLoZFBQkvD/qdDpUVFRg3rx5knwPYBgGZWVliIqKkmQfNwBoaGiATqezaTlzR7onRMFnJPiIfQ9QKpVYs2YNnnzySSxbtmxKP7u1tRWbNm1Cd3c33NzccPPNN+POO++ERqPB+vXr0dTUhPj4eOzcuRNhYWHgOA533nkn9u/fD39/f7pn5Nwo/EzEycIPH3wYhoG7u/u4wYc/5jQ0NCTZjvUqlQrHjx93idXuybB0KWu+X0t3d/eUjh/ZCn/Mx9fXV5LNW4GRi93d3d2SKO5hNpuFggmDg4MICwtDYGAgWlpakJGR4VRH/SyFv+M0ffp0zJgxw97DsbnRVe3S0tLs9h7A3xPig7q7u7sQhKz92ST14GMwGFBSUoLk5GSEhYWN+/U9PT1YvXo1tm7dihUrVkz553d2dqKzsxPz58/HwMAAFixYgD179uCtt95CeHg4/va3v+HJJ5+EVqvFU089hf379+P555/H/v378eOPP+LOO+/Ejz/+OOVxELug8DMRDMMI93mAiRc2MJvNqKysRGBgoCTLuAIjlxSlWtENAPr6+lBdXW3Vimb8pd/RvYSioqIcYoeRn/RFRUUhNjbW3sOxOY7jTjjmI7XFD5Zl0draisbGRnh5eQnHjyIiIiTzXJhMJpSWliI2NlaSd5w4jkN9fT3MZrPDVbXj7wmN3rG0xj0hqQcfo9GIkpISJCUliSrwotVqsXr1ajz44IPIzc21ypgUCgXuuOMO3HHHHTh48CCmT5+Ozs5OLF26FLW1tbjllluwdOlSbNiwAQCQnJwsfB1xOqf9ZXb8szN2NNHgw99vmTVrliR/WTiOQ21tLcxmM7KzsyV5zInf8crKyrJq9aGAgAAkJCQgISEBer0eSqUSVVVVYBhGaKpqjx03vpSzVC+2878DLMsiMzPToSZ9tqLRaNDV1YVFixbBx8cH/f39UCqVaGhoEEq8R0ZGuuyEkC/ukJCQIMkGxvxxV76lg6P9Dvj6+iImJgYxMTHCPaHW1laL3hOi4DMSfBITE0UFn76+Pqxduxb33Xef1YJPU1MTSkpKsHDhQnR3dwtztGnTpqG7uxvASJGF0cdTY2Ji0N7eLsn5nKuj8HMKowsbiHkT5Ff7pXq/ha/oFhISItmO7Xwp6wULFth0x8vX1xexsbGIjY0VGlfW1tbCaDQKZWADAwOt/m/C3+8Qe8TB1Ui9eScwclG5tbX1hElfSEgIQkJCkJSUJOxYlpWVnXD8yBnKFIvB329w9HLm1sJxHI4ePQp3d3fMmzfP4X8HPD09ER0djejo6BPuCdXX10/6npDUgw+/6zlnzhxRBU4GBgawfv16/OlPf8KaNWusMqbBwUGsWbMG27dv/13hKbF3uIlrofBzEhOt6NbV1YXm5marr/Y7Ktrx+q2UdXZ2tl2P9nh7e2PmzJmYOXOmcA+jsbEROp1OuJAeEhJi8Tf73t5e1NTUiG5c52rMZjPKy8sRGRkpyaN+wG93nLKzs09ZkGPsjqVKpUJNTQ3MZjMiIyMRFRVlk6BuDXxLA6kWd+A4DtXV1fD29nbKe37u7u4IDw9HeHj4CfeESkpKRN8TouBjQklJCRISEhAZGTnu1+t0Olx55ZW48cYbhaNm1hjTmjVrcNVVV2H16tUAgOjoaHR2dgrH3vgWJDNnzkRra6vwd9va2iTZk0wK6M7PGM888wwMBgPy8vIwa9as076B82f7+/r6kJGR4RQVuCxtYGAAlZWVkt3xcpaL/QzDQKPRQKlUor+/H6GhoZDJZAgLC5vy8USlUonGxkbI5XKHuHNka0ajEWVlZYiJiZFk+AdGjpT09vYiIyNjUuHfZDIJ9zB0Oh3Cw8OFXleO+js1Gt+1XqotDTiOE94HXXHXU8w9IakHH7PZjJKSEsTFxYnqZzg8PIz169cL4ccaOI7Dtddei/DwcGzfvl3483vvvRcRERFCwQONRoP/+7//Q3FxMV544QWh4MHmzZvx008/WWVsxOqo4MFEdHR0YNeuXdi1axeGhoaQk5MDhULxu8Z0Op0Of/jDH3DzzTfj4osvdrk3ezGkXtHNZDKhvLwcMpnMqcrY8sc7lEoltFotgoKCJn0hXUoVzU6Gr+qXmJgoaqXT1fC7ngaDwWLlzPmgrlKp0NfX5/C9rvgFIKnuevK9zAIDAzF79mx7D8fqTtZPyNfXF0qlEvPnz5ds8CktLcWsWbNE3fXU6/XYuHEjcnNzcdttt1lt/nTo0CGcd955yMjIEN6bHn/8cSxcuBDr1q1DS0sL4uLisHPnTmHH74477sAnn3wCf39/vPnmmzjjjDOsMjZidRR+JkupVGL37t0oLCyEVqvFihUroFAo4O/vjyuvvBJr1qzB3Xffbe9h2oXUK7oNDw+jvLwcs2fPdupLzaN7CWk0Gvj5+QmV4063k8lxHBoaGjA4OCjJimbAyDnyiooKq1b1c2T8/Q43Nzer3fMb2+vK399fKJjgCO87fX19qKmpkewCkNQbuLIsi5aWFjQ3N8PLywsBAQF26ydkLwzDoLS0FDNmzBC18200GnHNNdfg4osvxubNmyW5cExsgsKPJfT09GDv3r146623UFNTA4VCgZtvvllyzRupceVvzVtdbdLL9xJSKpVQq9Wn7CXEsqxwqVmqxS16e3tx9OhRpKenS3q1PyAg4He74tbC38PgX5/2LvGu0WhQV1cHuVwuybueLMuivLwcYWFhiIuLs/dw7EKtVqOhoQFZWVnw8vKyWz8he+GDj9heViaTCddddx0WL16Me+65R5KfHcRmKPxYSnFxMR5++GG88sorOHr0KHbt2oXGxkYsW7YMeXl5kMvlLh0G+B5GwcHBSEhIkOQbl5SO+g0NDQm9hNzc3ISjcXV1dcKER4qvAbVajePHj0v2jhPDMCgvL0d4eLhdJ73Dw8PCRJNhGGGiGRAQYPXXJf8ayMrKgo+Pj1V/liPiXwORkZFOdeTXkkYHn5MddbNVPyF7YRgGZWVliI6OFlUUwGw246abbkJGRgYefPBBl3gOiEOj8DNVHMdh+/bt2L9/Pz788MMTSpgODAxg//79KCgoQG1tLS688ELk5eXhjDPOcKkgJPWKbsDI/Zauri5kZmZK7ly3Xq9HZ2cnmpqa4OXlhZkzZ0ImkyEgIMDeQ7Opzs5OtLW1QS6XS+41AIys3JaVlWHGjBmiVnptxWg0ChPN4eFhYaJpjcqGSqUSTU1Np5z0ujp+0iuTyRATE2Pv4djFeMFnrJPdE+ILzjjjkWGWZVFWViY6/DIMg9tuuw0JCQl49NFHKfgQW6DwMxUmkwm33347OI7Diy++eNo3uuHhYXz88ccoLCxEWVkZlixZgry8PCxatMgp3+B4AwMDqKqqkmz/ltGlrNPS0pz633Ky+Iv9SUlJCAoKglqthlKphF6vF3oJBQUFufSHWnNzM3p6eiCXyyX5GuCbd8bHx4uq5mQvDMMIE83+/n6LNa4ERsJve3s75HK5ZO50jGY2m1FWVib6mJMrmmjwGWt0PyGNRjPpfkL2wh93DA8PF1XWn2VZbN68GVFRUXjiiSdcalGYODQKP1Nx//33IyoqCn/5y18mNLEzGAz4/PPPkZ+fj19++QVnn302Vq1ahXPOOcepSmLzx7wyMjIkt8oP/FbK2sfHB0lJSS49uT8V/o7Tycr48iua3d3dTlmiWAw+/Or1eqSlpUnyw3t0+BXTuNBRjJ1oBgQECAUTJvo+3NbWBqVSKdnwy1f0mjlzpmR3/6cafMYa3U/IGe4J8QUuQkNDRR15ZVkWd999N/z8/LBt2zZJvncSu6HwMxUMw0z5g85oNOKrr75CQUEBfvjhB5x11llQKBRYsmSJQx+baG1tFcoYO/I4rcVZS1lbUk9PD+rr60XdcWJZFj09PUIvoZCQEERHR1ukl5C9sCyLmpoaeHp6Yu7cuS4T6CZCp9OhoqICKSkpTl3gY2xBDy8vL6Fgwnj3dpqbm6HVaifdx8jZmUwmlJaWIjY2VlQpY1dk6eBzMo58T4jjOKGkeUJCwrhfz7Is7r//fjAMgxdeeMFpPwOI06Lw40jMZjO++eYbFBQU4JtvvkF2djYUCgUuvPBCh7k8zVd0MxqNkl7pLi8vR0JCgkMf8bGmqdxvsWQvIXthGOaEMr72nnzYA7/r54o9bIaGhoQVd47jTiiYwOMbWfMl3aX4XmgymVBSUuLwxx2tyRbBZ6yT3ROKioqyS78rvomtv7+/qF5OLMvikUceQV9fH/7zn/9I8veG2B2FH0fFMAy+++47FBYW4ssvv0Rqairy8vKwbNkyu2158xO+oKAgm5WwdTSuWspaLI7jhJXuzMzMKX/QchyH/v5+oVcL30vIUXq1nAx/sX/atGmSvdSt1WpRW1sricqGRqMRKpUKSqUSBoMBkZGRiIqKQnd3t1DWX4rvhfw9r4SEBKfuZzYVKpUKjY2Ndi1wMfr4plarhZ+fH6KiohAZGWn1MXEch+rqavj4+CAxMVHU1/+///f/0N7ejjfffNNpFruIy6Hw4wxYlsXPP/+M/Px8fPbZZ0hKSkJeXh4uueQSBAUF2WQMVNFtZIXv2LFjkpjwnQy/62c2m5GSkmLxFbuxvVo8PT1FHz2yFYPBgLKyMkmvdKtUKjQ0NEiynLfZbBZKWZtMJkRHRwuVuaS0gm0wGFBaWorExESnuudlSXzwyc7OdpiFGlveE+I4DjU1NfDy8kJiYuK4CwAcx+Gf//wn6urq8PbbbzvV/Wbicij8OBuWZVFaWor8/Hx8/PHHiI2NhUKhwIoVK6y2EyH1im6AtEtZAyO7fvzRhjlz5thkpXt4eBhKpRJKpRJubm6IioqCTCazW9PIoaEhlJeXY+7cuSeUtJeSrq4utLa2SracN7/S7e3tjdmzZ5+w4h4UFCSsuLvyirZer0dpaamkfw8cMficjMFgEILQ6F3Lqd4T4jgOtbW1cHd3F1Xsh+M4PPvssygpKcF7773n0M8ZkQQKP86Mv2SYn5+P/fv3IyoqCgqFAjk5ORb7UOJ3O6Ra0Y3jOBw/fhxDQ0OSLWXNF3eIjo622zEv/kNcqVTCbDYLJbRtddeEP+6Ynp5us91WR9PW1obu7m7I5XJJrtqyLIvKykoEBQX97lI3f3xTpVJBrVbDx8dH2LV0pZDIV/abN28eQkND7T0cu3CW4DOWpe4J8ScAOI5DcnKyqODz8ssv49tvv0V+fr5L/T4Qp0Xhx1VwHIejR4+ioKAARUVFCA4ORm5uLlauXImoqKhJrfJIvaIblbIeWeUtKytzqOIOJpNJWM3km1bKZDKrVT3SaDSoq6uT7HFHAGhsbER/fz/S09MluQDAMIzQv0RMGd/RR48cYdfSEvjg4+yV/abCWYPPWJO9J8SX9jebzZg3b56o4PP666/jk08+we7dux3m+DKRPAo/rojfrSgsLMTevXvh4+ODlStXQqFQYNq0aaLesKRe0Y3f7YiKihLVrM0VDQ4OorKy0qFXeRmGEZqqDg4OWryXUHd3N5qbmyGXyyX5wc1PdgwGA1JTUyX5XsA375zszufoXUuTyXTCrqWzLKjwRz5TU1N/189LKlwl+Iw1+p6QWq0WwvrJ7gkdO3YMRqMRKSkpol67O3bswO7du7F3716nDv7E5VD4cXUcx6GlpQWFhYXYvXs3ACAnJwd5eXmIiYn53RtYf38/Hn30Udx66602u9vhaKiU9W/VvNLT052mjDHLstBoNFAqlejr60NISAhkMhnCw8MnNWnnj3llZma61GRHLP5Cs4eHh2T7GPE9bGJiYixS6IUvmKBUKoXGv1FRUQgNDXXYYKnT6VBeXi7pI5+uGnxO5lT3hFQqldDMWcx7wbvvvov3338fRUVFkt0xJw6Lwo+UcByHzs5OFBYWYteuXdDr9cjJyYFCoUBCQgJaWlqwdu1aXHvttbj99tvtPVy7kHopawBQKpVoampCZmam01bz4jhO6CWk0WgQGBgolNAe79gW379lYGBAsse8+PstAQEBki1rz5dytlZlv7FhPTg4GFFRUQ7V72pwcBAVFRUu2ctJLCkFn7H4e0KNjY0YHh5GdHS0qHtC+fn5eOONN1BcXCzZ1w1xaBR+pIrjOCiVSuzevRu7du1CZ2cn+vv7cd999+EPf/iDJCc7Ui9lDYzc81IqlS6128FxHAYGBoQS2r6+vsJl9LGPka9ixLKs6KMdroa/3xIRESHZI598Kec5c+YgMjLS6j+P4zj09fVBpVIJ/a74o0f2+j0cGBhAZWUlMjMzJVnsBpB28OE1NTWhv78fqampwvuoRqOBv78/+vr6MHfuXEybNk34+j179uCll15CcXGxZBcQicOj8EOATz/9FPfeey/Wr1+P77//Hl1dXbjsssuQl5dnlX4ujqitrQ2dnZ2SLuHLV7Vz9W71g4ODwrEODw8PyGQyyGQyeHl5obKy0qblvB0N38B1xowZmDFjhr2HYxf8xX57lfYf26vFw8NDCEK2ujfB74DL5XLJLgTxO+BSDj4tLS3QarXIyMg44TOBf43u2LFD6NlzySWXICYmBu+99x6Ki4slWwadOAUKPxNx/fXXo6ioCDKZDJWVlfYejkX8+9//xvvvv4/8/HyhS3dvby/27duHXbt2obm5GRdffDFWrVqFzMxMl5sU85N+nU4n6SNONTU18PT0lNzdjuHhYahUKnR3d2NwcBBhYWGYO3euJCd81MB15H5LRUWFQ1U00+v1QsEEhmGEggkBAQFW+V3t6+tDTU0N5HK5ZC+pU/AZOQXQ09Mj6nO/ubkZzz//PPbu3YuoqChcfvnlyM3NxZlnnulycwbiEij8TMQ333yDwMBAbNq0yenDD8uy+Otf/4q2tja8+eabp7zbMTAwgOLiYhQWFqKurg4XXngh8vLysGDBAqd/U2NZFtXV1fDy8pLcpJ9nNptRUVGBsLAwxMfH23s4dmE0GlFWViZUQhxdlSs6Otpqk0xHwu92SLlxJX+/xZEv9ptMJqFgwtDQkFDmPSQkxCKvUb7QidSDT3NzM7KysiQbfNra2qBSqSCXy0V9zn/11Vd45JFHsH//fvj7++Ozzz7D3r178euvv+Lss8+GQqHAhRde6LR3SInLofAzUU1NTcjJyXHq8MNxHNavX4/k5GRs3bpVdIgZGhrCxx9/jMLCQlRUVGDJkiXIy8vDwoULnW7HhEpZ/3ahe9asWRapZOWM+El/YmLiCXc7Rk8ybdFLyJ4ccbfD1vhjXs50v4VhGKFgQn9//6SbVvL4flZZWVmSnaTSjg/Q0dGBrq4uyOVyUa+jb7/9Fvfffz+Ki4t/9zliNpvx/fffY+/evThw4AAeeeQRrFq1ylpDJ0QsCj8T5QrhBwBqamqQkpIy6b+v1+vx+eefIz8/H7/++ivOOeccrFq1CmeffbbDd393xMadtsb37UhKSkJERIS9h2MX/Er/eJX9GIZBT08PlEolBgYGEBYWJvQScvbdT37SL+VqXr29vTh69KhT73aMrW4YEBAgNK0UM4nv6enBsWPHkJWVJcl+VgDt+ABAZ2cnOjo6kJWVJSr4/PDDD7jnnnvw0UcfjdsDi+M4mM1myT63xKFQ+JkoVwk/lmQ0GvHll1+ioKAAhw8fxsKFC6FQKHD++ec7XPEAvoJRSkqKwzbutLa+vj5UV1c79PEea+vt7UVNTc2EJ/0sy0Kr1UKpVKK3txfBwcFCLyFn2/2kI04jk/76+nqX2u3gOA6Dg4NQKpXo6emBp6enUDDhZI9RrVajoaEBWVlZDvd+bSsUfICuri60tbUhKytL1ALmkSNH8Kc//Qn79u1DXFycDUZIiMVQ+JkoCj+nZzab8fXXX6OgoADffvst5s+fL5z3tfeKIpWy/u05kPKEV61W4/jx45DL5VOa8PLliflJZkBAgNBLyNF3P1UqlTDhtffvpb3wZYxdfdLPF/VQqVRgWfaEggn8MS9Xfw5Oh4IP0N3djZaWFmRnZ4t67yotLcWtt96K3bt3Y86cOTYYISEWReFnoij8iMcwDL777jsUFBTgq6++QlpaGvLy8nDxxRfbPHy0t7ejo6NDsqWsgZGz3O3t7ZJ+Djo7O9HW1mbx54Bfbe/u7kZPTw+8vb0RHR2NyMhIh3uu+edAypO9rq4utLa2Su45MBqNwl22gYEBcByHtLQ0hIeHu9xdNjEo+IwsAvABWMxzUFlZiRtvvBH5+flITk62wQgJsTgKPxOxYcMGHDx4EGq1GtHR0di6dStuuOEGew/LKbAsi59++gn5+fn4/PPPkZSUhFWrVuGSSy6x6l0DKmU98hw0NTWhr68PGRkZknwOgJFyrBqNBpmZmVZ/DnQ6HZRK5Qm9hE517MiWWltboVKpkJmZ6fC7U9bS3t4uXOiW6nPAB+CYmBj09PRgYGAAoaGhkMlkCAsLc/q7bGJQ8PntyKPYAg81NTW47rrr8MEHHyA1NdUGIyTEKij8ENtjWRYlJSXIz8/HJ598gri4OOTm5mLFihUWrTZFpaxHgs/Ro0fBcRzmzZsniUnNWBzH4dixYzAYDEhNTbX5c6DX64UgxLIsoqKiIJPJbLr7yQfg/v7+3zUslJLW1lao1WqbBGBH1dHRITR05sMfy7JCwQStVovAwEChYIIrBkQKPr8VucjOzha1O11XV4dNmzbhnXfeQWZmpg1GSIjVUPgh9sWyLCorK5Gfn4/9+/cjOjoaCoUCl19++ZT6jVAp65Fjh5WVlQgMDMTs2bMlGf4crYGr0WgUGlYajUbh/kVgYKDVxsZxHOrr62EymZCSkiLZ4NPY2Cj58Nfe3o7u7u7TljHmOA4DAwPCXTZvb2+hYIIr3A/j77dIOfhoNBrU19eLDj6NjY3YsGED3nrrLcyfP98GIyTEqij8EMfBcRxqampQUFCAoqIihIaGIjc3FytXrkRUVJTo78OXso6Pj0d0dLQVR+y4TCaT0LhzvBKkrophGFRUVCAkJATx8fF2Dz5jmc3mExpWhoeHW7RhJfDb75SHh4dDhD974I++6vV6u+z8OYrJ7noNDQ0JBRM4jrPLzqWlUPD5rcpjdna2qDDb0tKC9evX49VXX8VZZ51lgxESYnUUfohj4o8qFRYWYt++ffD19cXKlSuhUCgQHR19yklcfX091Gq1pEtZ8+Fv9uzZEwqNroQPf9OnT8fMmTPtPZxxjW1YaYn7F/yuamBgIBISEiQbfOrq6sAwDFJSUiT5HAAjE1j+vttUwt/YnUu++W9QUJDDP7cUfH7raSW2tHt7ezvWrl2LF198Eeecc44NRkiITVD4IY6P4zg0NzejsLAQe/bsAQCsXLkSeXl5mDlzpvChu3v3bmzZsgUff/wxZsyYYccR2w/fuFPK4c9gMAg7f87YxHbs/YugoCDIZDJERESIXrFnGAZlZWWIjIyU7LFP2vUaMbrYiSV3vcxms9D8d3Bw0KGb/060lLMr6uvrQ01Njejg09XVhTVr1uCZZ57B0qVLrT9AQmyHwg9xLhzHoaOjA4WFhdi9ezcMBgNycnKg0+lQVFSEwsJCyQYfjUaDuro6ZGRkICAgwN7DsQudToeKigokJycjLCzM3sOZstG9hDQaDfz9/cftJcTves2cORPTp0+38YgdA8uyqKqqgr+/v2TvuwFAQ0MDBgcHkZ6ebtVAMrb5b1BQkFAwwd6FJSj4AP39/aiurhbd302pVGLNmjV46qmncPHFF9tghITYFIUf4rw4jkN3dzduuOEGVFVVITo6GitWrIBCoUBSUpKkJjzd3d1obm6GXC53iUvJk9Hf34+qqiqkp6cjKCjI3sOxOL6XkFKphFqthre3t1BCm7+07Oy7XpbAsuwJd72kaPQ9p7S0NJu+F3Ich/7+fqFggq+vr1AwwdY9ryj4AAMDA6isrIRcLhd1T0utVmPNmjV49NFHsXz58in//Ouvvx5FRUWQyWRCf8QtW7bg1VdfFY5lP/7441ixYgUA4IknnsDrr78ODw8PPPfcc7j00ksn/bM5joObm5vwfwn5Hwo/UtDa2opNmzahu7sbbm5uuPnmm3HnnXfae1hTZjQacfPNNyM0NBRPP/00tFot9uzZg127dkGpVGL58uVQKBQuf9a/paVFuMgs1Q94ftcrMzPTKS9iT8bQ0JBQQtvNzQ1hYWHo7u7GvHnzplQp0Znxx/2ioqIwa9Ysew/HLvj7kkajEampqXZ/7+N7XqnVari5uQkFE8TsQEwFBZ/fjkGLDT5arRarV6/Ggw8+iNzcXIuM4ZtvvkFgYCA2bdp0QvgJDAzEPffcc8LXVldXY8OGDfjpp5/Q0dGBiy++GHV1dRPePWRZFu7u7jCZTCfc76IQRP6Hwo8UdHZ2orOzE/Pnz8fAwAAWLFiAPXv2OHWTsr6+Pqxbtw7Lly/Hn//859/9d61Wi48++giFhYVoaWnBsmXLsGrVKpcqc8tPcvjVXVd5XBNFu14jPTuqqqrg4+NzwgRTSscfzWazUORCqkdf+QIPLMti3rx5DjfRMxgMQsEEk8lktVLvFHx+Cz6ZmZmi3gf6+vqwZs0a3H333VizZo1Fx9LU1IScnJxxw88TTzwBALj//vsBAJdeeim2bNmCxYsXi/5ZfPBpbW3F1q1bkZmZiaioKKxdu1ayrwXyO6d9s5HmTMoFTZ8+XajNHxQUhJSUFLS3t9t5VJPX1taGSy65BDfffPNJgw8AhIWFYdOmTdi7dy++/vprZGdn4+mnn8Y555yDv//97zhy5AhYlrXtwC2Iv9PAcZzVz/M7sra2NrS1tYku2+qK+vr6UFdXh/nz52PhwoXIysqCj48P6uvrcfjwYRw7dgz9/f0YZzHLqZlMJpSUlCAmJkbSwae2thYAHDL4AICPjw9iYmIwf/58zJ8/HwEBAWhsbMThw4dRW1sLrVY75dcpBZ/f7j6Kvf85MDCAdevWYfPmzRYPPqfywgsvIDMzE9dffz20Wi2Akepyo3dsY2JiJjxXcXd3R09PD1asWIELL7wQZWVleOutt6DRaCw6fuK6pDmbcnFNTU0oKSnBwoUL7T2USfvggw/wzDPPiH6TDg4OxoYNG1BQUIAffvgBZ599Nl566SUsXrwYf/3rX/H999+DYRgrj9pyzGYzSktLERwcLNkqVhzHoaGhAT09PZIuXavRaIQKToGBgQAAb29vzJgxA1lZWTjjjDMQFBSEpqYmYYLZ29vrUkHIaDSipKRE0n29+Mp27u7uTvOe4OXlhWnTpiEzMxMLFy5EREQEOjs7cfjwYVRVVUGpVE74fbmrqwutra2SDj5DQ0MoLy9Henq68J5wOjqdDldeeSVuuukmXHnllTYYIXDbbbfh+PHjKC0txfTp03H33XdP+XvyrxWz2Yyff/4Zt9xyC9avX49ff/0Vd911F2QyGVpaWqb8c4jro2NvLmZwcBBLlizBgw8+iNWrV9t7OHan1+vx2WefIT8/HyUlJTj33HORl5eHs88+22E/OPkL7bGxsZg2bZq9h2MX/Ao3y7Iuf5/rdFQqFRoaGoSdnvGwLCuUJu7v70dISAiio6On1EvI3vR6PUpLS5GUlISIiAh7D8cuOI5DVVUVfH19MWfOHKf/fRhb4dDPz08omHC6RY6uri60tbUhKyvLYd+/rW14eBhlZWVITU1FcHCwqK9fv349NmzYgBtuuMFq4xp77O1U/22yx94YhoGHhwf6+vrw6quvYv78+XjggQfQ09OD5557DsuXL8exY8fw2muv4W9/+5tk20AQwWnfJKX57uGiTCYT1qxZg6uuuoqCz//4+voiNzcXubm5MBqNOHDgAPLz83H33Xdj8eLFUCgUOP/88x1mV4E/yjB37lzJXmjnG3f6+/u7xERvsjo7O9HW1ob58+eLfn26u7sLk8jRvYTq6uom1UvI3viJ3rx58yQ7meGPvwYEBGD27Nn2Ho5FuLm5ITQ0FKGhoeA4TiiYUFJSAg8PD+E+2+heNRR8fmtunZKSIir46PV6XHXVVVizZg2uv/56G4zwN52dnUIZ/t27dyM9PR0AkJubi40bN+Kuu+5CR0cH6uvrcdZZZ437/Tw8PDA0NIQXXngBHMfhwgsvxMKFC6HT6ZCWlga9Xo/rrrsOy5cvl+x7BRGPdn5cBMdxuPbaaxEeHo7t27fbezgOz2Qy4euvv0ZBQQEOHTqEBQsWQKFQ4IILLrDbvRK+QV1aWppLlnEWw2w2o7y8XNKNO4GR6o0qlQpyudwiQWVsaWI/Pz+hl5CjBP+xdDodysvLkZaWJmqi54r4hYCgoCAkJCTYezg2odfrhYIJDMMgMjIS7u7uUKlUkj7qxu+Ail0IMBqNuPrqq7Fs2TJs3rzZqotIGzZswMGDB6FWqxEdHY2tW7fi4MGDKC0thZubG+Lj4/Hvf/9bCEP/+Mc/8MYbb8DT0xPbt28/bbnt0dXbrr32Wuzbtw9HjhzBnDlzcODAAfz00094++23kZiYiOzsbDz66KNWe5zEqVC1Nyk4dOgQzjvvvBMqnY2uq09OjWEYHDp0CAUFBfjqq6+QkZGBvLw8XHzxxVYv1crjjzdlZmba7Gc6GqPRiLKyMsTExEi2cSfHcWhsbMTAwIDVqhaOXmlXq9Xw9PQUegk5SkEJvm9JRkaGqDsNrohlWZSXlyMsLAxxcXH2Ho5dmEwmHDt2DN3d3fDx8UFERARkMhlCQkIktSNsMBhQUlIiurGzyWTCddddh8WLF+Oee+5x+ueK4ziYzWZwHIeFCxciNjYWe/fuBTDye9Ld3Q13d3fJ3gckJ0XhhxCxWJbF4cOHUVBQgC+++AJz587FqlWrsGzZMqtNwtrb29HZ2Qm5XO6wq/DWxh9vkvq9jvr6ephMJpv2bhkeHoZSqYRSqbRpj5ZT4XdApdTPaSyGYYQdUKn2MgJOPOrm5uYGjUZzwn02mUyG8PBwp73PJgZf7CMpKUnUUWiz2Ywbb7wRcrkcDzzwgFMHH37X58EHH8TQ0BCefPJJeHp6YsGCBUhKSkJ+fr69h0gcF4UfQiaDZVn8+uuvyM/Px6effor4+Hjk5uZixYoVFjmGM3qVPz093WnuYVga36siNTUVISEh9h6OXXAch+rqanh5eSEpKcluE5bRPVrMZvMJPVpsgW9kK5fLJbsDyjdxlclkiImJsfdw7OZ0d3w4jhPus2k0GgQEBCAqKsqhj3FOBh98EhMTRS0KMQyD2267DbNnz8bWrVudNviMbVRaXV2NLVu2YO7cuXjggQfg7++PhQsXwtfXF19//bUdR0ocGIUfQqaKZVlUVFQgPz8fH3/8MaZNm4bc3Fzk5OSIOoYwFl+21s3NzWH7ddhCb28vjh49KrpXhSviX1vBwcGIj493mNeCyWQSgpBerxeCUFBQkFXGqFarcfz4cdGV7VwRwzBCaWCp9jICRi7Lt7e3iypuwHEcBgcHhWOcXl5eQtGP0QUTnA3f12r27NmIjIwc9+sZhsHmzZshk8nwxBNPOO1u2Ojg8+qrr+KSSy5BXFwcGhoa8MADD0Amk+Ff//oXvL29sW3bNtx11112HjFxUBR+CLEkPrgUFBSgqKgIYWFhQhCKiooa9+8zDIOKigqEhIQ41GTX1vh7TnK53KknKVPBr/JHRUU59PEmhmGgVquhVCoxODiI8PBwyGQyhIaGWuT1q1Qq0dTUhKysLHh7e1tgxM6H7+01c+ZMyd55AyYWfE5meHhYCO0cxwmh3ZkWV/jgk5CQIOozhWVZ3HXXXQgICMDTTz/ttMGnp6dH2OH6+uuvsWfPHnh5eeGOO+5AbGwsmpqasHjxYuTk5OCZZ56R7H1AIgqFH0KsheM4HDt2DAUFBdi3bx/8/PyE0trR0dG/mxh2dXXhqaeewr333ivpld2Ojg5hguNKx1QmwmQyobS01OkKPLAsK9y96Ovrm/LdC36yK+U7b/xrITY2VtKXtqcafMYyGo1CaNfr9ULBhODgYIdddDKbzSgpKUFcXBxkMtm4X8+yLP72t7+B4zg8//zzTht81Go13nnnHSQlJeGrr77CokWLMHPmTHz00UfCrtbMmTNxzTXXIDMzE/fee6+9h0wcG4UfQmyB4zg0NTWhsLAQe/bsgbu7O1auXIm8vDzMmDEDdXV1uPLKK/HAAw9g7dq19h6u3TQ3N0Oj0SAzM1Oy95wMBgNKS0sxe/ZsUSu7jmrs3YvAwEChhLaYf9u2tjYolUqLlfR2Rvwqf3x8vKjJrquydPAZi2EYoQHwwMAAQkNDIZPJHKoBML/7N2vWLFEhmGVZPPLII+jv78e///1vh3kck2E2m1FUVIRbbrkFiYmJ+O677wAA3333HT7++GMcOnQIHh4emDt3Ll5++WU7j5Y4AQo/hNgax3Fob29HYWEhdu/ejd7eXvT29uKxxx7D6tWrHXbV0Zr4XTKDwYDU1FSn/qCeCr6ynas1suU4DgMDA8LdC19fX6GE9sl2dJqbm6HVapGRkSHZ4GM0GlFaWir6eJOr6uzsREdHB+RyuU36+IxuAKzVaoXQHhERYbc+QgzDoKSkRPSxR47j8P/+3/9DR0cH3njjDaf9HWJZVvgs+Oqrr/DYY48hMDAQmzZtwhVXXAFg5MREVVUVampqcMcdd9hzuMR5UPghxJ4OHDiAP//5z1izZg0OHTqE/v5+XH755cjLy0NiYqIkghDLsqipqYGnpyfmzp0ricd8MnxlOyk07hwcHIRKpYJKpYKHhwdkMhlkMhm8vb3R2NiIwcFBpKenSzYE87t/Yit5uSo++GRlZdllAj86tPf09MDb21so926r+2cTLXTBcRz+7//+D/X19Xj77bedtvHr6ODT29uLwMBAeHp6oqioCK+88go2bNiAq666Cu+++y7y8vKc6t4WsTsKP8Tx6fV6nH/++TAYDDCbzbjiiiuwdetWew9ryt5//3288MIL2LVrl3CMQaVSYc+ePdi1axdUKhWWL18OhUKBlJQUlwwFVOBhBN+/Jj09XXIXdUdfQh8aGoKPjw/S09MlO5nR6/VCXytX2v2bKHsHn5MZGhqCUqmESqUCACEIWavnFF/0JDo6GjNnzhz36zmOw/bt21FSUoL333/fae/Jja7qdv3118PNzQ1lZWXYtm0bzj//fOzevRsvvvgient7kZqairffftvOIyZOhsIPcXx81/nAwECYTCace+65ePbZZ7Fo0SJ7D23Snn76aXzxxRfIz88/5WRXq9Vi3759KCwsRFtbG5YtW4ZVq1a5zIq4yWRCWVkZpk+fLuqD3VVR/5qR3/Ha2lowDIOQkBAolUqYTCZhchkQECCJYKzX61FaWork5ORJlcl3FY4YfMbi+16pVCoYjUahYIKlyr2zLCtUexTT04njOLz00ks4dOgQ8vPzXaIy4p133on+/n68+eabyMrKQk1NDT744AOsWrUKdXV1+PTTT/GnP/3J3sMkzofCD3EuQ0NDOPfcc/Hyyy9j4cKF9h7OhHEch3vuuQdqtRqvvfaa6JW5/v5+FBUVobCwEMePH8dFF12EvLw8ZGdnO2UQ4o/1JCQkSPoiN1/GWS6XS7Z/Dd/E1dvb+4SjniaTSajGNTw87BTVuKaCv+81b948hIaG2ns4duMMwWcss9ksFEwYHBxEWFiYUO59Mu/PLMuivLwcERERosrccxyH119/HZ9++il27drltO8lo3d8TCYT3nnnHVx11VX44x//iLi4OGRlZWHVqlXYsWMHrrrqKjuPljgxCj/EOTAMgwULFuDYsWO4/fbb8dRTT9l7SJN28OBBLFmyZNITuMHBQXz88ccoKChAdXU1LrjgAigUCpx11llOMVnQ6XSoqKiQ/Op2R0eHcJHbWY+nTBXLsqisrERgYCBmz559yq8bW41rqpNLRzM0NITy8nKkpKQgJCTE3sOxm46ODnR2djpV8BmLZVlotVoolUr09vYiKChIKJgg5jHxjY1DQ0MRFxcn6me+9dZb2Lt3L/bs2eO0u8cMwwjPj9FoFHauqqqqcNddd+HTTz8FAFx44YVwd3fHF198YbexEqdH4Yc4l97eXqxatQrPP/880tPT7T0cu9Pr9fj0009RUFCAkpISnHfeeVAoFDj77LMd8qJrf38/qqqqkJ6ejqCgIHsPx25aWlqgVqslXcaZv+8VFhYmepIH/H5yGRwcLEwunTEI6XQ6lJeXS6LQxem4QvAZi+M49Pf3CwUT+CqHkZGRJz2Wxi8GBAcHIz4+XtTPePfdd/HBBx/go48+strdI2szGAzCbtVDDz2EwcFBqNVqPPXUU2AYBn//+9+hUCjwzTffICQkBA8//LDLvEaIXVD4Ic7n0Ucfhb+/P+655x57D8WhGAwGHDhwAAUFBfjxxx+xePFi5OXl4bzzznOInQX+bktmZqbTfkhPFcdxVM0Mv13klslkou4znArHcejr6xMmlwEBAcLk0hHD/1h8hT+pLwa4YvA5GZ1OJxRMcHd3F8q9+/n5geM4VFVVwd/f/7S7oKPl5+fjjTfeQHFxsdMWSvnggw9QUlKCp556Cs8//zy++OILfPjhh4iKisJTTz2FP/7xj/jXv/6F1tZWVFRUoLi42Gl3t4jDoPBDHJ9KpYKXlxdCQ0MxPDyMSy65BH/961+Rk5Nj76E5LJPJhIMHD6KwsBDffvstzjjjDOTl5WHp0qV2OQ/e3d2N5uZmyd9tqaurA8MwLlu9Twy+0IXYniVicRyHwcFBdHd3C2WJo6OjT7nKbm8DAwOorKxERkaG005cLUEqwWcsvV4vFEwwmUzgOA7BwcGi3xv27NmDl156CcXFxU57VLK9vR3r1q3DBx98gOHhYTz//PP44x//iJ07dwrFDUaXvDabzU6xqEEcHoUf4vjKy8tx7bXXgmEYsCyLdevW4eGHH7b3sJyG2WzGoUOHUFBQgIMHDyIzMxN5eXm46KKLbLKC1traCqVSabMmhY6I72Xk5eWFpKQkyQYfvnFnfHy81QtdjF5l53sJRUVFwdfX16o/Vwz++GdmZqZkS3oD0g0+o/E7PiaTCR4eHtDpdAgPDxfutJ3svaK4uBjbtm3D/v37nfreZHd3N9auXYvk5GQMDQ0hJiYGP//8M2bNmoUdO3YAAO644w4kJCTg7rvvtvNoiQuh8EOIlDAMg8OHD6OgoAAHDhxAcnIy8vLycMkll1h8EsYf8RoYGEB6erpkJzf8Bebg4GAkJCTYezh2w1f4mzNnDiIjI236s/V6vRCEWJa1en+W0+F7Okn5+CdAwQf4rcS7u7u7sCjCMAw0Gg1UKhXKy8uxd+9eKBQKrFy5EgEBAfjss8/w+OOPY//+/Tb/PbKG++67Dy+88AJeeuklnHfeebjkkkuwbds2zJ8/H3v27MG7776LoqIil3isxGFQ+CFEqliWxS+//IL8/Hx89tlnSEhIQG5uLpYvXz7li9f8hzrLspI+4mU2m1FeXo6oqChRJWtdFV/G2REq/BmNRqGpqtFoRGRkJGQyGQIDA63+Ou3t7cXRo0cl3dMJoOAD/HYMFgDmzp170tee2WzGV199hV27duG7775DdHQ0Ojs78cknn2Du3Lm2HrJVVFRUoKamBg888ACeffZZeHp64s033wQwsmjx8ssvW/R4LCGg8EMIAX7rK5Gfn4+PP/4YM2bMQG5uLi6//PIJT1b5ikX+/v6YM2eOZIOPyWRCaWkpYmJiJP3hzZc2d8QyzmazWeglNDQ0JBw3CgkJsfjrVqvVora2FllZWQ5x9M5eKPiMBJ/6+nowDIN58+aJeq19/fXX2LJlC5YuXYpvvvkGgYGByMvLg0KhmFLREEdx4MAB3HTTTdi2bRsUCgUYhoHRaJT07iixGgo/hJAT8U0nCwoKUFRUhPDwcCgUCuTk5Ix79IDf6YiMjERsbKyNRux4+CNes2fPRlRUlL2HYzfOVM2MP26kVCrR39+P0NBQyGQyhIWFTbkqX09PD44dO4asrCzJFvwARi64d3d3S7rEO8dxOH78OIxGo+hd8R9++AH33HMPPvroIyHotLS0YO/evdi7dy+GhoaQk5ODvLw8p95p/+GHH7BixQr885//xI033mjv4RDXReGHEHJq/AplQUEBPvroI/j5+Qnnz6Ojo0/4kO3o6MDVV1+N//znP0hMTLTjqO2Lb1jpCEe87MmZL/WzLIve3l4olUpotVoEBwcjKipKdKPK0dRqNY4fP47s7GyHrDpnKxR8Rhw/fhx6vR6pqamiQsqRI0ewefNm7N2795T9sDQaDYqLi/Htt9/i3//+t9OGHwAoLS2dcO8vQiaIwg8hRBy+gEFhYSH27NkDT09PrFy5Enl5eRgYGMCVV16Jhx9+GKtWrbL3UO2G3+mQesNKV7rbMrqXkEajgb+/v+heQiqVCo2NjcjKyqLgQ8HnhB5fYgJKaWkpbr31VuzZs0d07x9CyLgo/BBCJo7jOLS1taGwsBDvvPMOWltbsXHjRtx0002Ii4tz6pXHyeKreGVkZDjdTocl9fT0oL6+3iXvtvC9hJRKJdRqNby9vYUS2mPDjVKpRHNzM7KyshyiybC9UPAZ0dTUhP7+ftHNjSsrK3HjjTeioKDAZYobEOIgKPwQQibv+++/x+23345nn30WFRUV2LVrFwYHB3H55ZdDoVAgMTFREkGIn/C7wk7HVEhtp2NoaEgooe3m5gaZTAaZTIbe3l60trZS8KHgA2Dkfo5Wq0VGRoao4FNTU4PrrrsOH3zwAVJTU20wQkIkhcIPIbbAMAzOOOMMzJw5E0VFRfYejkXs378fW7Zswa5du06oNqRSqbB7927s2rULPT09WL58ORQKheiqRs5GqVSiqalJMhP+U+nq6pL0hF+v10OlUqG1tRV6vR5xcXGYNm2aZHcBKfiMaG1tRU9PDzIzM0UFn7q6OmzatAnvvPMOMjMzbTBCQiSHwg8htrBt2zYcOXIE/f39LhF+/vvf/+LVV1/Fnj17EB4efsqv02g02LdvHwoLC9He3o5LLrkEq1atQlpa2pQraDmCjo4OdHR0QC6XS3LCz+PLF8vl8nHvwbiy9vZ2dHV1IS0tTagcp9frhV5CQUFBLrkAMBYFnxFtbW1QqVSQy+Wi3u8aGxuxYcMGvPXWW5g/f74NRkiIJFH4IcTa2tracO211+LBBx/Etm3bnD78vP3229i5cyc+/PDDCa1q9/X1oaioCIWFhWhoaMDFF1+MvLw8ZGVlOWUQamlpEVZ0pTzBa21thVqtlvzz0NbWBqVS+bsJv9lsRk9PD7q7u6HT6RAeHo7o6Gir9BJyBKd6HqSmo6MDXV1dop+HlpYWrF+/Hq+99hrOPPNMG4yQEMmi8EOItV1xxRW4//77MTAwgH/9619OH35UKhVCQ0OntNMxODiI/fv3o6CgAEePHsUFF1wAhUKBM8880+EnTBzHoaGhATqdTvTlZVfV1NSEvr4+0XcZXJXYIMyyLHp6eqzSS8gRUPAZ0dnZiY6ODtGNXNvb27F27Vq8+OKLOOecc2wwQkIkjcIPIdZUVFSE/fv346WXXsLBgwddIvxY2vDwMD799FMUFBSgtLQU559/PhQKBRYvXuxwR6g4jkNtbS1YlnXqZoJTxTdq5PuVuMLEfbImGwDH9hIKCgqCTCabVC8hR0DBZ0RXVxfa2tqQnZ0t6nno6urCmjVrsH37dixZssQGIyRE8ij8EGJN999/P/773//C09MTer0e/f39WL16Nd555x17D80hGQwGfPHFFygoKMDPP/+MxYsXIy8vD+eee67d79SwLIvq6mr4+PhIpordyXAch7q6OjAMI+kACIzc0RgYGJjyDiDHcejv74dSqURPTw/8/PyEXkL2ft2LQcFnRHd3N1paWpCdnS1q4UapVGL16tX4v//7P1x88cU2GCEhBBR+CLEd2vmZGJPJhK+++gqFhYU4dOgQzjzzTOTl5WHp0qU2r6rGMAwqKioQEhKChIQEm/5sR8JxHGpqauDh4YG5c+dKNvjwRx+HhoYsXryD4zjodDqhl5Cnp6dQQtsRqwnyl/qlfudron2d1Go11qxZg8ceewyXXXaZDUZICPkfCj+E2AqFn8kzm804dOgQ8vPz8fXXX0MulyMvLw8XXXSR1Rtpms1mlJWVITo6+oSS3lLD73z5+flh9uzZkg4+x48fh8FgQGpqqtWfh+HhYSiVSiiVSri5uSEqKgoymcwh+klR8BnB97fKzs4WFXy0Wi1Wr16Nv//971i5cqUNRkgIGYXCDyHEuTAMgx9++AEFBQU4cOAAUlJSkJeXh2XLllm8p4rRaERZWRlmzZqFadOmWfR7OxOWZYWdr/j4eHsPx244jkN9fT3MZrNdjvwZDAaoVCoolUqYzWZERUUhKioKgYGBNh0HQMGH19PTg+PHj4sOPn19fVizZg3uuecerF69eso///rrr0dRURFkMhkqKysBjLQYWL9+PZqamhAfH4+dO3ciLCwMHMfhzjvvxP79++Hv708ltYlUUfghhDgvlmVx5MgR5Ofn47PPPsOcOXOQm5uL5cuXIygoaErfW6/Xo6ysDHPmzEFkZKSFRux8GIZBeXk5IiMjMWvWLHsPx274YhcAkJycbPedL5PJJAQhW/cSovLmIzQaDerr65GdnS3qSOLAwACuuOIK3H777bjyyistMoZvvvkGgYGB2LRpkxB+7rvvPoSHh+Nvf/sbnnzySWi1Wjz11FPYv38/nn/+eezfvx8//vgj7rzzTvz4448WGQchToTCDyHENbAsi7KyMuTn5+OTTz7BzJkzkZubi8svvxyhoaET+l5DQ0MoLy9HcnIywsLCrDNgJ8Af+Zs+fTpmzJhh7+HYjaPfdWIYBmq1GkqlEoODgwgPD4dMJkNoaKjFx0rBZ4RWq0VtbS2ys7Ph4+Mz7tfrdDqsW7cO1113HTZt2mTRsTQ1NSEnJ0cIP8nJyTh48CCmT5+Ozs5OLF26FLW1tbjllluwdOlSbNiw4XdfR4iEnPZN0bFqzBJCyGm4u7sjOzsb2dnZ+Mc//oGqqioUFBQgNzcXERERyMvLQ05ODiIiIk77ffr7+1FVVYW0tDQEBwfbaPSOx2QyobS0FLGxsYiOjrb3cOyG4zhUV1fD29vbYav8eXh4IDo6GtHR0WBZFhqNBp2dnTh69ChCQkIgk8kQHh4+5cIMfPCRy+WSLm/e29s7oeAzPDyMK6+8EldffbXFg8/JdHd3C4Fm2rRp6O7uBjDST2j07m1MTAza29sp/BAyCoUfQohTcnNzQ3p6OtLT0/HII4+grq4OBQUFWLt2LQICAqBQKLBy5UrIZLITJrMHDhzAP/7xD+zbt88u9ygchdFoRGlpKRISEhAVFWXv4dgNy7KoqqqCv7+/0xR5cHd3R2RkJCIjI8FxnNBLqL6+HoGBgUIJ7Ynu2lDwGdHX14ejR48iKytLVPDR6/W46qqrcMUVV+D666+3wQhP5Obm5hSvW0IcBYUfQojTc3NzQ3JyMh588EE88MADaGhoQGFhIa666ip4eXkhNzcXCoUCP/30E7Zu3YqCggJJBx/+rlNiYuK4u2SujGVZVFZWIigoyGnLm7u5uSEsLEy47D4wMAClUonGxkb4+vpCJpMhKipq3Iv6FHxG9Pf3o6amBnK5XFSVSYPBgE2bNmH58uW49dZbbRZCoqOj0dnZKRx7k8lkAICZM2eitbVV+Lq2tjbMnDnTJmMixFlI9x2OEOKS3NzcMGfOHNx333347rvv8M4778Dd3R0KhQJ//etfceWVV8LLywvj3Hd0WcPDwygtLUVycrLkg09FRQWCg4OdNviM5ebmhuDgYCQmJmLRokVITEyEwWBASUkJfv31V7S2tsJgMPzu71HwGTEwMICqqirI5XJRZcZNJhOuv/56LFmyBJs3b7bp7ktubi527NgBANixYwcUCoXw52+//TY4jsPhw4cREhJCR94IGYMKHhBCAADx8fEICgqCh4cHPD09ceTIEXsPyWLeeustvP3223jppZfwxRdfYPfu3dDpdLj88suhUCgwZ84cSRwb0el0qKioQGpqqqTvOvHV7SIiIhAbG2vv4djE8PCwUDmO4zihqaparabgA2BwcBAVFRWQy+Xw9/cf9+vNZjNuuOEGZGVl4YEHHrDq+8eGDRtw8OBBqNVqREdHY+vWrcjLy8O6devQ0tKCuLg47Ny5E+Hh4eA4DnfccQc++eQT+Pv7480338QZZ5xhtbER4qCo2hshZHzx8fE4cuSIy5V83r59Ow4cOIAPP/zwhEmNUqnE7t27sWvXLmg0GqxYsQIKhcIhShxbw8DAACorK5GRkSHpI38Mw6CsrAxRUVGSLevN9xJqaWmBwWAQCl4EBAS45Gt/PHzwyczMFNVHjGEY3HrrrUhMTMSWLVsk+ZwR4uAo/BBCxudq4YfjODzyyCM4duwYduzYcdo7DxqNBnv37kVhYSE6Ojpw6aWXYtWqVUhNTXWJ1fC+vj7U1NQgMzNT1Kq2q2IYBqWlpZg2bZrk70G0traip6cHqamp6OnpgVKpxPDwMCIiIiCTyRAcHCyJSb1Op0N5ebnoRQGGYbB582ZER0fjiSeekMRzRIgTovBDCBlfQkICwsLC4ObmhltuuQU333yzvYc0JVu2bEF3dzdeeOGFCVW96uvrw0cffYTCwkI0NjZi2bJlyMvLc9pjQXyvErH3GFyV2WxGaWkpZs6cKfk7EHzwyczMPOE1zTCMEIQGBgYQFhYm9BJyxtf+eIaGhlBWVob09HRRDZNZlsVdd92FwMBA/Otf/3LJ54QQF0HhhxAyvvb2dsycORNKpRLLli3D888/j/PPP9/ew5q0rq4uREdHT2lldmBgAPv370dBQQFqa2tx4YUXQqFQ4Mwzz3SKiY9arcbx48dFl+x1VXw/o1mzZmHatGn2Ho5dtbS0QKPR/C74jMWyLLRaLZRKJXp7exEcHAyZTIaIiAineO2Phy/8MZHg87e//Q0A8Nxzz7nEc0CIC6PwQwiZmC1btiAwMBD33HOPvYfiMIaHh/HJJ5+gsLAQpaWlWLJkCRQKBRYvXjzhfiq2oFQq0dTUhKysLHh7e9t7OHZDjVx/Izb4jMVxHPr6+tDd3Q2NRoOAgABER0cjIiICnp7O1zFjeHgYZWVlogt/sCyLhx9+GAMDA/j3v/9NwYcQx0fhhxByejqdDizLIigoCDqdDsuWLcPDDz+Myy67zN5Dc0gGgwGff/45CgoKcOTIESxevBirVq3COeecM24/FVvo7OxEe3s75HK5Q4zHXqiR628mG3zG4jgOg4OD6O7uhlqtho+PD6KjoxEZGekUIVuv16O0tBQpKSkICQkZ9+s5jsNjjz2Gzs5OvPHGGw650EEI+R0KP4SQ02toaMCqVasAjNyN2LhxIx588EE7j8o5GI1GfPXVVygsLMR3332Hs846C3l5eViyZIldJoNtbW1QKpWQy+WSnqgZjUaUlJRgzpw5LlPEY7IsFXxORqfTQalUQqVSwcPDQ2iqKqZBqK3xPY/mzZuH0NDQcb+e4zg89dRTOH78OHbs2OGUu1yESBSFH0IIsQWz2Yxvv/0W+fn5+Prrr5GdnY28vDxceOGFNpkMNjc3C5NcKQcfg8GA0tJSJCYmSrqRK2Dd4DOWXq+HUqkUeglFRUVBJpM5RIVB/jWRlJSE8PDwcb+e4zhs374dpaWleO+99yS9g0qIE6LwQwghtsYwDL7//nsUFBTgyy+/RGpqKvLy8rBs2TKLTwY5jkNjYyMGBweRnp4u6TsJ/LGmuXPniprkujJbBp+xjEaj0FTVaDQiMjISMpkMgYGBNi8Pze8Cig3DHMfhpZdewnfffYedO3c6xXE+QsgJKPwQQog9sSyLn3/+Gfn5+fj888+RmJgIhUKBSy+9VFSlqdPhOA7Hjh2D0WhEamqqpPuO8BfZxR5rcmX2DD5jmc1mqNVqKJVKDA0NITw8HDKZDCEhIVZ/vZpMJpSUlGD27Nmijj9yHIfXXnsNn332GXbt2iXpKomEODEKP4QQ4ihYlkVpaSkKCgrw8ccfY9asWcjNzcWKFSsmPGHnOA61tbUAgOTkZEkHn6GhIZSXl4u+yO7Kmpub0dvbi4yMDLsHn7EYhoFGo4FSqUR/fz9CQ0Mhk8kQFhZm8bHywWciBS/eeust7N27F3v37nXIe0uEEFEo/BBCiCPiOA6VlZUoKChAcXExIiMjkZeXh8svv3zc4zkcx6G6uhre3t5ITEyUdPDR6XQoLy9HWlqaqNLFrsyRg89YLMuit7cXSqUSWq1W6CUUHh4+5TtrZrMZJSUliIuLg0wmE/V33n33XXzwwQf46KOPHOKeEiFk0ij8EEKIo+N3cQoKCvDRRx8hODgYubm5WLlyJaKiok4IN3q9Hhs3bsTmzZuxZMkSSQefwcFBVFRUiG5W6cqcKfiMxfcSUiqV0Gg08Pf3h0wmQ2Rk5ISrrPHBZyK9nXbu3Ik333wTxcXFCAwMnMxDIIQ4Dgo/hBDiTDiOw/Hjx1FYWIi9e/fC29sbubm5UCgUCAoKwurVq3HeeefhoYcesvdQ7YoPPhkZGZKfsDpz8BmL7yWkVCqhVqvh7e0tlNAer/gAwzAoKSlBTEwMpk2bJurn7dmzBy+//DKKiookf2SSEBdB4YcQQpwVx3FoaWlBYWEhCgsL0draivPPPx8PPfQQYmJiJLvrMzAwgMrKSmRmZiIgIMDew7ErVwo+JzM0NCT0EnJzc4NMJoNMJvvdnRyGYVBaWooZM2Zg+vTpor53cXExnnnmGRQXFyMsLMwawyeE2B6FH0IIcXZ9fX1QKBS44oorwHEcdu/ejaGhIeTk5EChUGD27NmSCUJ9fX2oqalBZmam5O9mNDU1oa+vz2WDz1h6vV4ooc0wjNBLyNfXF2VlZYiOjsbMmTNFfa/PPvsMTzzxBPbv3y/5flCEuBgKP4QQ8ViWBQCnm0j19vbixhtvRGVlJdzc3PDGG29g8eLF9h6WRajVauTm5uLee+/FqlWrhD/v7u7G7t27sWvXLmi1WqxYsQJ5eXmYO3euywah3t5eHD16FHK5HH5+fvYejl1JLfiMZTQaoVar0d3djd7eXoSGhiIxMVFUL6Evv/wSW7Zswf79+0UXRCCEOA0KP4SQ8Wk0GoSGhjrtJOraa6/FeeedhxtvvBFGoxFDQ0Mu0eulq6sLubm5eOyxx3DppZee8ut6enqwd+9eFBYWoqurC5deeilWrVqFlJQUp/03HUur1aK2thZZWVmSL0Ms9eDDY1kW5eXlCAsLg6+vL7q7u6HT6RAeHo7o6GgEBwf/7vn55ptv8OCDD6K4uFj0vSBCiFOh8EMIGd9NN92E8vJynH/++Vi0aBFWrVoFNzc3YQWVZdkT/rcj6evrQ1ZWFhoaGhxyfJPV3t6O3NxcbNu2DUuWLBH993p7e/HRRx+hsLAQTU1NWLZsGfLy8iCXy512oqzRaFBXV0fBBxR8eCzLoqKiAqGhoYiLizvhz3t6etDR0YE//OEPSE9Px+rVq7F8+XKUlJTgnnvuQVFRkejjcYQQp0PhhxByenq9HvHx8bj99tuRnZ2Nhx56CM8//zzOPfdc/Prrr0hOTv7dpXKWZR1m4lVaWoqbb74ZqampKCsrw4IFC/Dss886/UX4wcFBHDt2DFlZWZP+HgMDAyguLkZhYSFqa2tx0UUXQaFQ4IwzznCYf7/x9PT0CM+Dj4+PvYdjV01NTejv70d6errT/PtZA8uyqKysRHBwMOLj40/5dUajEZ9//jl27dqFH374AUajEVu3bsVVV10l+ftihLgwCj+EkNM7cOAA/vKXv6C8vBwA8MgjjyA4OBiHDx+G0WhEbW0tcnNzsWXLlt9NGBiGgYeHB4xG47hlaK3lyJEjWLRoEb777jssXLgQd955J4KDg/HYY4/ZZTyOamhoCJ988gkKCwtRXl6OJUuWQKFQYNGiRVNuKmktKpUKjY2NyMrKstvry1FQ8BnBcRyqqqoQEBCAhIQEUX+npKQEt956Kx599FH89NNP+OSTTzB79mysXr0al19+uUsckSWECCj8EEJO78Ybb4SbmxteffVV9Pb2ori4GP/85z8RERGBAwcOoK+vDxs3bsT27duRlJSE3bt3Q6PRQKFQIDIyEgBw6NAh/PTTT7j66qsRFhYGLy8vm42/q6sLixYtQlNTEwDg22+/xZNPPoni4mKbjcHZ6PV6fP755ygoKMAvv/yCs88+G6tWrcI555wz4aaS1qJUKtHU1ITs7Gybvp4cEQWfERzHobq6Gr6+vpgzZ46ov1NRUYGbbroJBQUFmDt37gnfZ9euXSgqKkJYWBhWr16NtWvXUslrQpzfacOPdN9BCSEAgOHhYXzzzTeYMWMGAKCmpgY1NTUwmUy45ZZbAIwcMZkzZw5KS0tx8OBBPPfccygrK8Nll12G7du3AwDOPvts3HrrrZDJZHj77bdRXV0No9Fok8cwbdo0zJo1C7W1tQBGdrJSU1Nt8rOdla+vL1auXIkdO3bg119/xerVq7Fr1y4sXrwYd9xxB7744gub/fudTHd3N5qbmyn4gIIPj+M41NTUwMfHB7Nnzxb1d6qrq3HTTTfhgw8+EIIPALi5uSEtLQ0PPfQQfvzxR7z88ssYHByESqWy1vAJIQ7CMZb3CCF2U1JSgoCAADQ3N+Oyyy4DwzBYuXIllEol5HI5gJF7I729vZg5cyZ+/PFHcByH5557DoODg9BoNGhra8MTTzyBnJwcuLu74+WXX0ZOTo5wTOn222/HH//4R6SlpVntcTz//PO46qqrYDQaMXv2bLz55ptW+1muxtvbG5dddhkuu+wymM1mfPPNN8jPz8f999+P+fPnIy8vDxdccIHNCg10dnaivb0d2dnZDrMLZS+NjY0YGBig4MNxOHr0KDw9PTFnzhxRhU3q6upw/fXX49133x13MSQhIQF33XWXpYZLCHFgdOyNEIm79dZb4eXlheeffx5FRUVgWRa5ubnYunUrPD09cdVVV2Hbtm0wGo14+umnwXEcnnzySXAch3vvvRehoaHYu3cvvvjiC9x0001477338MILLyA5ORmPPvooLr/8chgMBrAsK/RlYRgG7u7uLlWZzRUxDIPvvvsOBQUF+Oqrr5CWlgaFQoFly5ZZ7bJ4R0cHOjs7IZfLKfhQ8AEwEnzq6uoAQHQPq4aGBmzcuBE7duxAdna2tYdICHEsdOeHEHJqhYWFmD179u8mCMePH8fDDz+MlpYWLF26FLfccgsCAwOFi8H33XcfWlpa8MEHH+DJJ5+EXq/Hli1bcOONN+Lcc8/FjBkzkJ6ejjfffBP+/v74y1/+YodHRyyFZVn89NNPyM/Px+eff46kpCTk5eXh0ksvRWBgoEV+Rltbm7Dj6KgFGGyFgs8IjuNQX18PhmEwb948UcGnubkZV155JV577TWceeaZNhglIcTBnPaNQtrLaoQQrFmzRvj/R5evnjNnDt59910AgMFggI+PD5544gkUFhbij3/8IwIDAzE4OAiWZdHe3o4lS5ZAq9Wivr4ef/7zn5Geng4A+O6773DDDTcAAIqLi7Fz507IZDJs3rwZs2bNEqrFASMTHY7jJD3Zc1Tu7u5YtGgRFi1aBJZlUVJSgoKCAmzbtg2xsbHIzc3FihUrEBISMqnv39raCrVaTcEHFHx4HMfh+PHjMJvNSElJERV82tvbsWHDBrzyyisUfAghJyXdd1VCyO+MnmixLAuGYQBA6K1y//3349lnn8Xhw4fh7e2NHTt24Msvv8TQ0BDOPPNMfPbZZ4iLi8P06dMBAL/++is4jsP8+fPx5Zdf4vbbb8emTZvg4eGBBx54AEajER4eHjh27BiAkUvIUp7sOQt3d3csWLAATzzxBH755Rc89thjaG5uRk5ODtasWYO3334bGo1G9Pdrbm5GT08PBR9Q8BmtoaEBBoNBdPDp7OzEunXr8Oyzz2Lx4sU2GCEhxBnRzg8h5KRONfE655xzcM455wj/28PDA6mpqZDJZNDpdIiNjUVERASAkZ2erKws6PV6fP311/jzn/+Miy66CBkZGbjyyiuhVCrh5uaGuXPn4oknnoBWq8XVV18t7BoRx+fu7o7MzExkZmZi69atOHr0KAoKCrBmzRqEhIQgNzcXOTk5iIqKOukE9p///CcWLVqEc845R/KTfQo+v2lsbMTw8DDS0tJEBZ/u7m6sXbsW//rXv7BkyRIbjJAQ4qyk/e5KCJkwlmXBsqzwvy+44ALcfffd8PPzw+LFi/Hpp59i0aJF4DgOBw8exFlnnQWZTIaSkhIhNKnVaqSmpmJ4eFi4c3TZZZehr68Pf//73+310MgUubm5ISUlBQ899BAOHz6Ml156CYODg9i4cSNycnLwyiuvoLOzE/xd03vvvRfff/89Fi5cSJP9xkYMDg5S8MFIae+BgQGkpqaKCj5qtRpr167F448/josuusgGIySEODMqeEAImZLR94R4ra2tCA4Oxh133IFHH30UERERWLJkCQ4dOoSAgABs27YNdXV1ePnll7FgwQLcf//9WLt2LSorK/HMM8/gzjvvRGZmpp0eEbE0juPQ3NyMwsJC7NmzBxzHITg4GCzL4sMPP5R8H5+GhgbodDqkpaVJPvg0Nzejt7cXGRkZop4LjUaD1atX46GHHsLKlSttMEJCiBOgam+EENs4WRDiPffcc3j55Zdx1llnobu7G4899hiSkpIwe/Zs4X7Ip59+ivfffx9PPPGEcG+IuBaWZXH77bejvLwcXl5eMBgMyMnJgUKhQEJCguTKn1Pw+U1rayt6enqQmZkp6rno6+vD6tWrce+992L16tU2GCEhxElQtTdCiG2MLZgw+n9v3rwZy5cvx5EjRyCXy5GamoqHHnoI8+bNAwBotVrU1tYiIiJCssGntrYW69evF/53Q0MDHn30Ufz5z3+236AsiOM43HXXXfDw8MC3334LNzc3KJVK7N69G3/5y1/Q19eHFStWQKFQiO7n4swo+Pymra1NqPYn5rkYGBjAunXr8Oc//5mCDyFkQmjnhxBiExzH/W4y+/bbbyM6OhqXXnopysvL8eyzz+Liiy/Ghg0b7DRKx8EwDGbOnIkff/wRcXFx9h7OlLEsizvuuAO+vr54+umnTxps1Go19u7di8LCQnR3d+Oyyy7DqlWrRFf7ciZ88ElPT3e5xzZR7e3t6O7uFl3tT6fTYe3atbjhhhtwzTXX2GCEhBAnQ8feCCGOgX+/Odlkr7W1FW+88Qauu+46xMbG2npoDuezzz7D1q1b8d1339l7KFPGMAxuueUWREZG4oknnhA12e/t7cW+fftQWFiIlpYWLFu2DHl5eaKPRDkyCj6/6ezsREdHB7KyskQFn+HhYaxbtw5XXXUVrr/+eouPJz4+HkFBQfDw8ICnpyeOHDkCjUaD9evXo6mpCfHx8di5cyfCwsIs/rMJIRZD4YcQ4phOd0dI6q6//nrMnz8fd9xxh72HMmW1tbUoKCjAAw88MKnJfn9/P4qLi1FYWIj6+npceOGFyMvLw4IFC5zu9UPB5zddXV1oa2tDdna2qOCj1+uxYcMGrFq1CrfccotVnr/4+HgcOXIEkZGRwp/dd999CA8Px9/+9jc8+eST0Gq1eOqppyz+swkhFkPhhxDi+CgI/cZoNGLGjBmoqqpCdHS0vYfjUIaGhrB//37s2rULFRUVWLJkCfLy8rBw4UKHb5B6/PjxCfWucWXd3d1obW1FVlYWPD3Hv35sMBhwzTXX4JJLLsGf/vQnqz1/Jws/ycnJOHjwIKZPn47Ozk4sXboUtbW1Vvn5hBCLoPBDCCHOZO/evXjxxRfx2Wef2XsoDk2v1+Ozzz5DQUEBfv31V5xzzjlYtWoVzj77bFETalui4PMbpVKJ5uZmZGdni/p3MplMuPbaa3Huuefi7rvvturzl5CQgLCwMLi5ueGWW27BzTffjNDQUPT29gIYObobFhYm/G9CiEOiam+EEOJM3n//fSr6IIKvry9yc3ORm5sLo9GIAwcOoKCgAHfffTcWLVqEvLw8nHfeefD29rbrOCn4/EalUqGpqUl08DGbzbjhhhtw1llnWT34AMChQ4cwc+ZMKJVKLFu2TKhGyXNzc5P8vyEhzo52fgghxIHodDrExsaioaEBISEh9h6OUzKZTPjmm2+Qn5+Pb7/9FgsWLIBCocCFF14IHx8fm46Fgs9v1Go1GhoakJ2dLaqxLV8oIykpCVu2bLH587dlyxYEBgbi1VdfpWNvhDgXOvZGCCFEmhiGwaFDh1BQUICDBw8iPT0dCoUCF198Mfz9/a36syn4/KanpwfHjh1Ddna2qJ04hmHwpz/9CdOnT8fjjz9uk+dPp9OBZVkEBQVBp9Nh2bJlePjhh3HgwAFEREQIBQ80Gg3+7//+z+rjIYRMGoUfQgghhGVZ/Pjjj8jPz8cXX3yBpKQkrFq1CpdccgkCAwMt+rMo+PxGo9Ggvr5edPBhWRZ/+ctfEBQUhH/96182K4TS0NCAVatWARg5brdx40Y8+OCD6Onpwbp169DS0oK4uDjs3LkT4eHhNhkTIWRSKPwQQggho7Esi19//RUFBQX45JNPEBcXB4VCgeXLl0/5uCEFn9/09vbi6NGjyM7OFnXkkGVZ/PWvf4Wbmxuee+45qgBJCJkMCj+EEELIqbAsi4qKChQUFGD//v2Ijo6GQqHA5ZdfPqEVfo7j0NDQQMHnf/jgk5WVBV9f33G/nmVZPPzww9DpdHj55Zcp+BBCJovCDyGEECIGx3GoqalBQUEBioqKEBoaCoVCgZycHERGRp4y0LAsi6qqKri7uyM1NVXywaevrw81NTWQy+Xw8/Mb9+s5jsNjjz2Grq4uvP766w7fs4kQ4tAo/BBCCCETxXEcjh07hoKCAuzbtw9+fn5YuXIlFAoFoqOjhYDDsizuuecemEwmPPfcc5IPPv39/aiqqkJWVpbo4PPUU0/h+PHjePvttyn4EEKmisIPIYQQMhUcx6GpqQmFhYXYs2cP3N3dkZOTg9zcXDzzzDPo6OjAu+++63DNVW1tYGAAlZWVkMvloqrpcRyHZ555BmVlZXjvvfdElcAmhJBxUPghhBBCLIXjOHR0dKCgoADPPvssAgICsH79eqxatQrx8fGS3fkZHBxERUUFMjMzERAQMO7XcxyHF198Ed9//z127txp92a0hBCXcdo3YbpNSAghxOKeeeYZpKWlIT09HRs2bIBer7f3kCzGzc0NM2bMgFqtxpIlS/Dpp58iIiICd955Jy644AL885//RF1dHcZZXHQpOp0OFRUVyMjIEB18Xn31VXzzzTf48MMPKfgQQmyGdn4IIYRYVHt7O84991xUV1fDz88P69atw4oVK/CHP/zB3kOzCI7j8PDDD6O9vR2vvfbaCVXJ1Go19uzZg8LCQqhUKixfvhwKhQIpKSkuuyM0NDSEsrIyZGRkiO6X9Oabb2Lfvn3Yu3evqEpwhBAyAbTzQwghxLbMZjOGh4dhNpsxNDSEGTNm2HtIFsFxHB566CF0dHT8LvgAQGRkJG688UZ8/PHH+Pzzz5GYmIhHH30U5557LrZu3YqysjKwLGun0Vve8PAwysrKkJ6eLjr4vPPOO9i1axd2795NwYcQYnO080MIIcTinn32WTz44IPw8/PDJZdcgnfffdfeQ7KI//f//h8aGxvx6quvTqgPTX9/P4qKilBYWIhjx47hoosuQl5eHubPn++0/Wz44JOamorg4GBRf2fnzp148803UVxcLDosEULIBFHBA0IIIbaj1WqxZs0afPjhhwgNDcXatWtxxRVX4Oqrr7b30Kasvr4ec+bMmVJg0el02L9/PwoLC1FVVYWlS5ciLy8PZ511ltOUedbr9SgtLUVKSgpCQkJE/Z3du3fjlVdeQXFxseiwRAghk0DhhxBCiO3k5+fjk08+weuvvw4AePvtt3H48GG89NJLdh6Z49Hr9fj0009RUFCAX3/9Feeddx7y8vJw9tlnO2zZbIPBgJKSEsybNw+hoaGi/k5RURG2b9+O4uJihIWFWXeAhBCpozs/hBBCbCc2NhaHDx/G0NAQOI7DgQMHkJKSYu9hOSRfX18oFAr897//xa+//orc3Fzk5+dj8eLF2Lx5M7788kuYTCZ7D1PAB5/k5GTRwefTTz/F008/jY8++oiCDyHE7mjnhxBCiMU98sgj+PDDD+Hp6Yns7Gy89tpr8PHxsfewnIbJZMLXX3+NgoICfPvttzjjjDOgUChwwQUX2O15NBqNKCkpQVJSEsLDw0X9nS+//BJbt25FcXExZDKZlUdICCEA6NgbIYQQ4rzMZjMOHTqEgoICHDx4EJmZmVAoFLj44ovh5+dnkzGYTCaUlJRgzpw5iIiIEPV3vvnmGzz44IMoLi7GtGnTrDxCQggRUPghhBBCXAHDMDh8+DAKCwvxxRdfYO7cuVi1ahUuueQSUc1FJ4MPPgkJCYiKihL1d77//nvce++9KCoqwsyZM60yLkIIOQUKP4QQQoirYVkWv/zyCwoKCvDpp58iPj4eCoUCy5cvt1g1NZPJhNLSUsTFxYk+tvbzzz/jzjvvxL59+xAbG2uRcRBCyARQ+CGEEEJcGcuyqKioQH5+Pvbv34/p06dDoVDg8ssvn3SRAbPZjJKSEsTGxiI6OlrU3ykpKcEf//hH7NmzBwkJCZP6uYQQMkUUfgghhBCp4DgO1dXVKCgoQFFREcLDw6FQKJCTk4PIyEhR34NhGJSUlCAmJkb0fZ2KigrcdNNNKCgowNy5c6fyEAghZCoo/BBCCCFSxHEc6uvrUVBQgH379sHf3x+5ubnIzc1FdHQ03Nx+P0cYGBjAO++8g7y8PEyfPl3Uz6mursb111+PDz/8kMqaE0LsjcIPIYQQInUcx6GxsRGFhYXYs2cPPDw8sHLlSuTl5WHGjBlwc3ODTqdDTk4OVq1ahc2bN4v6vrW1tbj22mvx7rvvIiMjw8qPghBCxkXhhxBCCCG/4TgO7e3tKCwsxK5du2AymbB8+XIUFxcjJycHd911l6jv09DQgI0bN2LHjh3Izs628qgJIUQUCj+EEEIIOTmO49Da2oqcnBz4+PjA3d0dl19+ORQKBRITE096NA4AmpubceWVV+K1117DmWeeaeNRE0LIKZ02/LjbahSEEEKIs3n22WeRnp6OtLQ0bN++3d7DsQqz2Yy//OUvuOGGG/Dzzz+jqKgI06dPx1//+lcsXboUTz75JKqrqzF6sbStrQ0bNmzAK6+8QsGHEOJUaOeHEEIIOYnKykpceeWV+Omnn+Dt7Y3LLrsMr7zyChITE+09NIsxm8246qqrcOaZZ+Kee+753X/XaDTYt28fCgsL0dbWhksvvRTnnnsuHnroITz77LM4//zz7TBqQgg5Ldr5IYQQQiaqpqYGCxcuhL+/Pzw9PbFkyRLs2rXL3sOyGIZh8Ic//AFZWVknDT4AEB4ejj/84Q/46KOPcPDgQWRkZOD+++/H5s2bKfgQQpwS7fwQQgghJ1FTUwOFQoEffvgBfn5+uOiii3DGGWfg+eeft/fQLGL79u3o7+/Hww8/bO+hEEKIJVHBA0IIIWQyXn/9dbz00ksICAhAWloafHx8XObuj9lshoeHxykLGhBCiJOi8EMIIYRM1QMPPICYmBj88Y9/tPdQCCGEnNppw4+nrUZBCCGEOBulUgmZTIaWlhbs2rULhw8ftveQCCGETAGFH0IIIeQU1qxZg56eHnh5eeHFF19EaGiovYdECCFkCujYGyGEEEIIIcRVUKlrQgghhBBCCKHwQwghhBBCCJEECj+EEEIIIYQQSaDwQwghhBBCCJEECj+EEEIIIYQQSaDwQwghhBBCCJEECj+EEEIIIYQQSaDwQwghhBBCCJEECj+EEEKIi7r++ushk8mQnp4u/JlGo8GyZcuQlJSEZcuWQavV2nGEhBBiWxR+CCGEEBf1hz/8AZ988skJf/bkk0/ioosuQn19PS666CI8+eSTdhodIYTYnhvHcaf776f9j4QQQghxbE1NTcjJyUFlZSUAIDk5GQcPHsT06dPR2dmJpUuXora21s6jJIQQi3E73X+knR9CCCFEQrq7uzF9+nQAwLRp09Dd3W3nERFCiO1Q+CGEEEIkys3NDW5up10kJYQQl0LhhxBCCJGQ6OhodHZ2AgA6Ozshk8nsPCJCCLEdCj+EEEKIhOTm5mLHjh0AgB07dkChUNh5RIQQYjtU8IAQQghxURs2bMDBgwehVqsRHR2NrVu3Ii8vD+vWrUNLSwvi4uKwc+dOhIeH23uohBBiKac9y0vhhxBCCCGEEOIqqNobIYQQQgghhFD4IYQQQgghhEgChR9CCCGEEEKIJFD4IYQQQgghhEgChR9CCCGEEEKIJFD4IYQQQgghhEgChR9CCCGEEEKIJFD4IYQQQgghhEgChR9CCCGEEEKIJFD4IYQQQgghhEgChR9CCCGEEEKIJFD4IYQQQgghhEgChR9CCCGEEEKIJFD4IYQQQgghhEgChR9CCCGEEEKIJFD4IYQQQgghhEgChR9CCCGEEEKIJFD4IYQQQgghhEgChR9CCCGEEEKIJFD4IYQQQgghhEjC/2/PDm0AgGEgiKlS9p+5IxQ15Gz6JPQU8QMAACSIHwAAIEH8AAAACeIHAABIED8AAECC+AEAABLEDwAAkCB+AACAhHnsZ+UKAACAz3x+AACABPEDAAAkiB8AACBB/AAAAAniBwAASBA/AABAwgVTT5c8UA6tPwAAAABJRU5ErkJggg==\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plot_positional_weights('Branch positional-dependent-vectors', 'CBOW+NS+PDW', 'Window size 5')" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plot_positional_weights('Branch positional-dependent-vectors', 'CBOW+NS+PDW', 'Window size 15')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "As expected, the magnitude of both positional scalar weights and positional weight vectors increases around the center word, placing more emphasis at short-term dependencies." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.7.3" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/gensim/models/fasttext.py b/gensim/models/fasttext.py index 5c07a0b540..f4538b07fd 100644 --- a/gensim/models/fasttext.py +++ b/gensim/models/fasttext.py @@ -275,6 +275,7 @@ """ +from math import sqrt import logging import os @@ -312,7 +313,7 @@ def __init__(self, sentences=None, corpus_file=None, sg=0, hs=0, vector_size=100 max_vocab_size=None, word_ngrams=1, sample=1e-3, seed=1, workers=3, min_alpha=0.0001, negative=5, ns_exponent=0.75, cbow_mean=1, hashfxn=hash, epochs=5, null_word=0, min_n=3, max_n=6, sorted_vocab=1, bucket=2000000, trim_rule=None, batch_words=MAX_WORDS_IN_BATCH, callbacks=(), - max_final_vocab=None): + max_final_vocab=None, position_dependent_weights=0, position_dependent_vector_size=None): """Train, use and evaluate word representations learned using the method described in `Enriching Word Vectors with Subword Information `_, aka FastText. @@ -421,6 +422,18 @@ def __init__(self, sentences=None, corpus_file=None, sg=0, hs=0, vector_size=100 ``min_count```. If the specified ``min_count`` is more than the automatically calculated ``min_count``, the former will be used. Set to ``None`` if not required. + position_dependent_weights : {1,0}, optional + If position vectors should be computed beside word and n-gram vectors, and used to weight the + context words during the training (1), or if all context words should be uniformly weighted (0). + position_dependent_vector_size : int or None, optional + How many features of the trained vector features should be position-dependent. Decreasing the + number of position-dependent features speeds up the training and may benefit task performance. + If None, then all features will be position-dependent. + + Notes + ----- + Positional vectors are only implemented for CBOW with negative sampling, not SG or hierarchical softmax. + Locking positional vectors is not supported. BLAS primitives are not used by the implementation. Examples -------- @@ -451,12 +464,28 @@ def __init__(self, sentences=None, corpus_file=None, sg=0, hs=0, vector_size=100 self.callbacks = callbacks if word_ngrams != 1: raise NotImplementedError("Gensim's FastText implementation does not yet support word_ngrams != 1.") + if position_dependent_weights and (sg or hs): + raise NotImplementedError("Gensim's FastText implementation does not yet support position-dependent " + "weighting with SG or hierarchical softmax") + if position_dependent_vector_size is None: + position_dependent_vector_size = vector_size + if position_dependent_vector_size > vector_size: + raise ValueError('Number of position-dependent features may not exceed the total number of features') + if position_dependent_vector_size < 0: + raise ValueError('Number of position-dependent features must be positive') + if not position_dependent_vector_size: + logger.warning('Switched off position-dependent weighting: zero position-dependent features were requested') + self.position_dependent_weights = False # fka pdw + else: + self.position_dependent_weights = position_dependent_weights # fka pdw self.word_ngrams = word_ngrams if max_n < min_n: # with no eligible char-ngram lengths, no buckets need be allocated bucket = 0 - self.wv = FastTextKeyedVectors(vector_size, min_n, max_n, bucket) + self.wv = FastTextKeyedVectors( + vector_size, self.position_dependent_weights, position_dependent_vector_size, + min_n, max_n, bucket) self.wv.bucket = bucket super(FastText, self).__init__( @@ -468,7 +497,8 @@ def __init__(self, sentences=None, corpus_file=None, sg=0, hs=0, vector_size=100 seed=seed, hs=hs, negative=negative, cbow_mean=cbow_mean, min_alpha=min_alpha) def prepare_weights(self, update=False): - """In addition to superclass allocations, compute ngrams of all words present in vocabulary. + """In addition to superclass allocations, compute ngrams of all words present in vocabulary + and initialize positional vectors. Parameters ---------- @@ -478,7 +508,7 @@ def prepare_weights(self, update=False): """ super(FastText, self).prepare_weights(update=update) if not update: - self.wv.init_ngrams_weights(self.seed) + self.wv.init_ngrams_weights(self.seed, self.window) # EXPERIMENTAL lockf feature; create minimal no-op lockf arrays (1 element of 1.0) # advanced users should directly resize/adjust as necessary self.wv.vectors_vocab_lockf = ones(1, dtype=REAL) @@ -569,7 +599,7 @@ def build_vocab(self, corpus_iterable=None, corpus_file=None, update=False, prog """ if not update: - self.wv.init_ngrams_weights(self.seed) + self.wv.init_ngrams_weights(self.seed, self.window) elif not len(self.wv): raise RuntimeError( "You cannot do an online vocabulary-update of a model which has no prior vocabulary. " @@ -1141,7 +1171,7 @@ def save_facebook_model(model, path, encoding="utf-8", lr_update_rate=100, word_ class FastTextKeyedVectors(KeyedVectors): - def __init__(self, vector_size, min_n, max_n, bucket): + def __init__(self, vector_size, position_dependent_weights, position_dependent_vector_size, min_n, max_n, bucket): """Vectors and vocab for :class:`~gensim.models.fasttext.FastText`. Implements significant parts of the FastText algorithm. For example, @@ -1157,6 +1187,12 @@ def __init__(self, vector_size, min_n, max_n, bucket): ---------- vector_size : int The dimensionality of all vectors. + position_dependent_weights : bool + Whether position-dependent weight vectors will also be stored. + position_dependent_vector_size : int + How many features of the trained vector features should be + position-dependent. Decreasing the number of position-dependent + features speeds up the training and may benefit task performance. min_n : int The minimum number of characters in an ngram max_n : int @@ -1187,8 +1223,11 @@ def __init__(self, vector_size, min_n, max_n, bucket): """ super(FastTextKeyedVectors, self).__init__(vector_size=vector_size) + self.position_dependent_weights = position_dependent_weights + self.position_dependent_vector_size = position_dependent_vector_size # fka pdw_size self.vectors_vocab = None # fka syn0_vocab self.vectors_ngrams = None # fka syn0_ngrams + self.vectors_positions = None # fka syn0_positions self.buckets_word = None self.min_n = min_n self.max_n = max_n @@ -1306,7 +1345,7 @@ def get_vector(self, word, use_norm=False): else: return word_vec - def init_ngrams_weights(self, seed): + def init_ngrams_weights(self, seed, window): """Initialize the vocabulary and ngrams weights prior to training. Creates the weight matrices and initializes them with uniform random values. @@ -1315,6 +1354,8 @@ def init_ngrams_weights(self, seed): ---------- seed : float The seed for the PRNG. + window : int + The size of the window used during the training. Note ---- @@ -1325,12 +1366,6 @@ def init_ngrams_weights(self, seed): rand_obj = np.random.default_rng(seed=seed) # use new instance of numpy's recommended generator/algorithm - lo, hi = -1.0 / self.vector_size, 1.0 / self.vector_size - vocab_shape = (len(self), self.vector_size) - ngrams_shape = (self.bucket, self.vector_size) - self.vectors_vocab = rand_obj.uniform(lo, hi, vocab_shape).astype(REAL) - - # # We could have initialized vectors_ngrams at construction time, but we # do it here for two reasons: # @@ -1339,7 +1374,39 @@ def init_ngrams_weights(self, seed): # vectors_ngrams, and vectors_vocab cannot happen at construction # time because the vocab is not initialized at that stage. # - self.vectors_ngrams = rand_obj.uniform(lo, hi, ngrams_shape).astype(REAL) + if self.position_dependent_weights: + vocab_shape = (len(self), self.position_dependent_vector_size) + ngrams_shape = (self.bucket, self.position_dependent_vector_size) + positions_shape = (2 * window, self.position_dependent_vector_size) + hi = sqrt(sqrt(3.0) / self.vector_size) + lo = -hi + self.vectors_positions = rand_obj.uniform(lo, hi, positions_shape).astype(REAL) + self.vectors_vocab = rand_obj.uniform(lo, hi, vocab_shape).astype(REAL) + self.vectors_ngrams = rand_obj.uniform(lo, hi, ngrams_shape).astype(REAL) + if self.vector_size > self.position_dependent_vector_size: + vocab_shape = (len(self), self.vector_size - self.position_dependent_vector_size) + ngrams_shape = (self.bucket, self.vector_size - self.position_dependent_vector_size) + lo, hi = -1.0 / self.vector_size, 1.0 / self.vector_size + self.vectors_vocab = np.concatenate( + ( + self.vectors_vocab, + rand_obj.uniform(lo, hi, vocab_shape).astype(REAL), + ), + axis=-1, + ) + self.vectors_ngrams = np.concatenate( + ( + self.vectors_ngrams, + rand_obj.uniform(lo, hi, ngrams_shape).astype(REAL), + ), + axis=-1, + ) + else: + vocab_shape = (len(self), self.vector_size) + ngrams_shape = (self.bucket, self.vector_size) + lo, hi = -1.0 / self.vector_size, 1.0 / self.vector_size + self.vectors_vocab = rand_obj.uniform(lo, hi, vocab_shape).astype(REAL) + self.vectors_ngrams = rand_obj.uniform(lo, hi, ngrams_shape).astype(REAL) def update_ngrams_weights(self, seed, old_vocab_len): """Update the vocabulary weights for training continuation. @@ -1362,7 +1429,13 @@ def update_ngrams_weights(self, seed, old_vocab_len): rand_obj.seed(seed) new_vocab = len(self) - old_vocab_len - self.vectors_vocab = _pad_random(self.vectors_vocab, new_vocab, rand_obj) + self.vectors_vocab = _pad_random( + self.vectors_vocab, + new_vocab, + rand_obj, + position_dependent_weights=self.position_dependent_weights, + position_dependent_vector_size=self.position_dependent_vector_size, + ) def init_post_load(self, fb_vectors): """Perform initialization after loading a native Facebook model. @@ -1429,11 +1502,25 @@ def recalc_char_ngram_buckets(self): ) -def _pad_random(m, new_rows, rand): +def _pad_random(m, new_rows, rand, position_dependent_weights=False, position_dependent_vector_size=0): """Pad a matrix with additional rows filled with random values.""" _, columns = m.shape - low, high = -1.0 / columns, 1.0 / columns - suffix = rand.uniform(low, high, (new_rows, columns)).astype(REAL) + if position_dependent_weights: + shape = (new_rows, position_dependent_vector_size) + high = sqrt(sqrt(3.0) / columns) + low = -high + suffix = rand.uniform(low, high, shape).astype(REAL) + if columns > position_dependent_vector_size: + shape = (new_rows, columns - position_dependent_vector_size) + low, high = -1.0 / columns, 1.0 / columns + suffix = np.concatenate( + (suffix, rand.uniform(low, high, shape).astype(REAL)), + axis=-1, + ) + else: + shape = (new_rows, columns) + low, high = -1.0 / columns, 1.0 / columns + suffix = rand.uniform(low, high, shape).astype(REAL) return vstack([m, suffix]) diff --git a/gensim/models/fasttext_inner.pxd b/gensim/models/fasttext_inner.pxd index 31a1b1d35f..64924ef76b 100644 --- a/gensim/models/fasttext_inner.pxd +++ b/gensim/models/fasttext_inner.pxd @@ -46,17 +46,18 @@ cdef struct FastTextConfig: # # Model parameters. These get copied as-is from the Python model. # - int sg, hs, negative, sample, size, window, cbow_mean, workers + int sg, hs, pdw, pdw_size, negative, sample, size, window, cbow_mean, workers REAL_t alpha # - # The syn0_vocab and syn0_ngrams arrays store vectors for vocabulary terms - # and ngrams, respectively, as 1D arrays in scanline order. For example, - # syn0_vocab[i * size : (i + 1) * size] contains the elements for the ith - # vocab term. + # The syn0_vocab, syn0_ngrams, and syn0_positions arrays store vectors for + # vocabulary terms, ngrams, and positions, respectively, as 1D arrays in + # scanline order. For example, syn0_vocab[i * size : (i + 1) * size] + # contains the elements for the ith vocab term. # REAL_t *syn0_vocab REAL_t *syn0_ngrams + REAL_t *syn0_positions # # EXPERIMENTAL @@ -143,6 +144,9 @@ cdef void fasttext_fast_sentence_sg_hs(FastTextConfig *c, int i, int j) nogil cdef void fasttext_fast_sentence_cbow_neg(FastTextConfig *c, int i, int j, int k) nogil +cdef void fasttext_fast_sentence_cbow_neg_pdw(FastTextConfig *c, int i, int j, int k) nogil + + cdef void fasttext_fast_sentence_cbow_hs(FastTextConfig *c, int i, int j, int k) nogil diff --git a/gensim/models/fasttext_inner.pyx b/gensim/models/fasttext_inner.pyx index e71ed6f31d..fb775d547c 100644 --- a/gensim/models/fasttext_inner.pyx +++ b/gensim/models/fasttext_inner.pyx @@ -34,7 +34,7 @@ cimport numpy as np from libc.math cimport exp from libc.math cimport log -from libc.string cimport memset +from libc.string cimport memcpy, memset # @@ -71,6 +71,12 @@ cdef int ONE = 1 cdef REAL_t ONEF = 1.0 +cdef inline void our_hadamard_product(const int N, const float alpha, const float *X, const float *Y, float *Z) nogil: + cdef int i + for i from 0 <= i < N by 1: + Z[i] += alpha * X[i] * Y[i] + + cdef void fasttext_fast_sentence_sg_neg(FastTextConfig *c, int i, int j) nogil: """Perform skipgram training with negative sampling. @@ -222,7 +228,6 @@ cdef void fasttext_fast_sentence_sg_hs(FastTextConfig *c, int i, int j) nogil: cdef void fasttext_fast_sentence_cbow_neg(FastTextConfig *c, int i, int j, int k) nogil: """Perform CBOW training with negative sampling. - Parameters ---------- c : FastTextConfig * @@ -233,11 +238,9 @@ cdef void fasttext_fast_sentence_cbow_neg(FastTextConfig *c, int i, int j, int k The start of the current window. k : int The end of the current window. Essentially, j <= i < k. - Notes ----- Modifies c.next_random as a side-effect. - """ cdef long long row2 @@ -305,6 +308,143 @@ cdef void fasttext_fast_sentence_cbow_neg(FastTextConfig *c, int i, int j, int k &c.syn0_ngrams[c.subwords_idx[m][d]*c.size], &ONE) +cdef void fasttext_fast_sentence_cbow_neg_pdw(FastTextConfig *c, int i, int j, int k) nogil: + """Perform CBOW training with negative sampling and position-dependent weighting. + + Parameters + ---------- + c : FastTextConfig * + A pointer to a fully initialized and populated struct. + i : int + The index of a word inside the current window. + j : int + The start of the current window. + k : int + The end of the current window. Essentially, j <= i < k. + + Notes + ----- + Modifies c.next_random as a side-effect. + + """ + + cdef long long row2 + cdef unsigned long long modulo = 281474976710655ULL + cdef REAL_t f, g, count, inv_count = 1.0, label, f_dot + cdef np.uint32_t target_index, word_index + cdef int d, m, n, o, nonpositional_size + + word_index = c.indexes[i] + nonpositional_size = c.size - c.pdw_size + + memset(c.neu1, 0, c.size * cython.sizeof(REAL_t)) + count = 0.0 + n = j - i + c.window + for m in range(j, k): + if m == i: + continue + count += ONEF + our_hadamard_product( + c.pdw_size, ONEF, + &c.syn0_positions[n * c.pdw_size], + &c.syn0_vocab[c.indexes[m] * c.size], + c.neu1) + if nonpositional_size: + our_saxpy( + &nonpositional_size, &ONEF, + &c.syn0_vocab[c.indexes[m] * c.size + c.pdw_size], &ONE, + &c.neu1[c.pdw_size], &ONE) + for o in range(c.subwords_idx_len[m]): + count += ONEF + our_hadamard_product( + c.pdw_size, ONEF, + &c.syn0_positions[n * c.pdw_size], + &c.syn0_ngrams[c.subwords_idx[m][o] * c.size], + c.neu1) + if nonpositional_size: + our_saxpy( + &nonpositional_size, &ONEF, + &c.syn0_ngrams[c.subwords_idx[m][o] * c.size + c.pdw_size], &ONE, + &c.neu1[c.pdw_size], &ONE) + n += 1 + + if count > (0.5): + inv_count = ONEF / count + if c.cbow_mean: + sscal(&c.size, &inv_count, c.neu1, &ONE) + + memset(c.work, 0, c.size * cython.sizeof(REAL_t)) + + for d in range(c.negative + 1): + if d == 0: + target_index = word_index + label = ONEF + else: + target_index = bisect_left(c.cum_table, (c.next_random >> 16) % c.cum_table[c.cum_table_len-1], 0, c.cum_table_len) + c.next_random = (c.next_random * 25214903917ULL + 11) & modulo + if target_index == word_index: + continue + label = 0.0 + + row2 = target_index * c.size + f_dot = our_dot(&c.size, c.neu1, &ONE, &c.syn1neg[row2], &ONE) + if f_dot <= -MAX_EXP: + f = 0.0 + elif f_dot >= MAX_EXP: + f = 1.0 + else: + f = EXP_TABLE[((f_dot + MAX_EXP) * (EXP_TABLE_SIZE / MAX_EXP / 2))] + g = (label - f) * c.alpha + + our_saxpy(&c.size, &g, &c.syn1neg[row2], &ONE, c.work, &ONE) + our_saxpy(&c.size, &g, c.neu1, &ONE, &c.syn1neg[row2], &ONE) + + if not c.cbow_mean: # divide error over summed window vectors + sscal(&c.size, &inv_count, c.work, &ONE) + + n = j - i + c.window + for m in range(j, k): + if m == i: + continue + count = ONEF + memset(c.neu1, 0, c.pdw_size * cython.sizeof(REAL_t)) + our_hadamard_product( + c.pdw_size, ONEF, + &c.syn0_vocab[c.indexes[m] * c.size], + c.work, + c.neu1) + our_hadamard_product( + c.pdw_size, c.vocab_lockf[c.indexes[m] % c.vocab_lockf_len], + &c.syn0_positions[n * c.pdw_size], + c.work, + &c.syn0_vocab[c.indexes[m] * c.size]) + if nonpositional_size: + our_saxpy( + &nonpositional_size, &c.vocab_lockf[c.indexes[m] % c.vocab_lockf_len], + &c.work[c.pdw_size], &ONE, + &c.syn0_vocab[c.indexes[m] * c.size + c.pdw_size], &ONE) + for o in range(c.subwords_idx_len[m]): + count += ONEF + our_hadamard_product( + c.pdw_size, ONEF, + &c.syn0_ngrams[c.subwords_idx[m][o] * c.size], + c.work, + c.neu1) + our_hadamard_product( + c.pdw_size, c.ngrams_lockf[c.subwords_idx[m][o] % c.ngrams_lockf_len], + &c.syn0_positions[n * c.pdw_size], + c.work, + &c.syn0_ngrams[c.subwords_idx[m][o] * c.size]) + if nonpositional_size: + our_saxpy( + &nonpositional_size, &c.ngrams_lockf[c.subwords_idx[m][o] % c.ngrams_lockf_len], + &c.work[c.pdw_size], &ONE, + &c.syn0_ngrams[c.subwords_idx[m][o] * c.size + c.pdw_size], &ONE) + inv_count = ONEF / count # divide position vector update by the number of summed gradients + our_saxpy(&c.pdw_size, &inv_count, c.neu1, &ONE, &c.syn0_positions[n * c.pdw_size], &ONE) + n += 1 + + cdef void fasttext_fast_sentence_cbow_hs(FastTextConfig *c, int i, int j, int k) nogil: """Perform CBOW training with hierarchical sampling. @@ -398,9 +538,12 @@ cdef void init_ft_config(FastTextConfig *c, model, alpha, _work, _neu1): c.cbow_mean = model.cbow_mean c.window = model.window c.workers = model.workers + c.pdw = model.position_dependent_weights c.syn0_vocab = (np.PyArray_DATA(model.wv.vectors_vocab)) c.syn0_ngrams = (np.PyArray_DATA(model.wv.vectors_ngrams)) + if c.pdw: + c.syn0_positions = (np.PyArray_DATA(model.wv.vectors_positions)) # EXPERIMENTAL lockf scaled suppression/enablement of training c.vocab_lockf = (np.PyArray_DATA(model.wv.vectors_vocab_lockf)) @@ -410,6 +553,7 @@ cdef void init_ft_config(FastTextConfig *c, model, alpha, _work, _neu1): c.alpha = alpha c.size = model.wv.vector_size + c.pdw_size = model.wv.position_dependent_vector_size if c.hs: c.syn1 = (np.PyArray_DATA(model.syn1)) @@ -554,7 +698,10 @@ cdef void fasttext_train_any(FastTextConfig *c, int num_sentences) nogil: if c.hs: fasttext_fast_sentence_cbow_hs(c, i, window_start, window_end) if c.negative: - fasttext_fast_sentence_cbow_neg(c, i, window_start, window_end) + if c.pdw: + fasttext_fast_sentence_cbow_neg_pdw(c, i, window_start, window_end) + else: + fasttext_fast_sentence_cbow_neg(c, i, window_start, window_end) else: for j in range(window_start, window_end): if j == i: