week06_da/homework.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "fEQLNowBwQsg"
   },
   "source": [
    "# Homework: Transfer Learning & Domain Adaptation\n",
    "##  Named Entity Recognition\n",
    "\n",
    "Today we're gonna solve the problem of named entity recognition. Here's what it does in one picture:\n",
    "![img](https://commons.bmstu.wiki/images/0/00/NER1.png)\n",
    "[image source](https://bit.ly/2Pmg7L2)\n",
    "\n",
    "\n",
    "For each word, in a sentence, your model should predict a named entity class: _person, organization, location_ or _miscellaneous_\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Data\n",
    "\n",
    "\n",
    "### Source domain testset\n",
    "\n",
    "Our train set consists from texts from different news sources. Therefore as source-domain testset we will use data from [CoNLL-2003 Shared Task](https://github.com/Franck-Dernoncourt/NeuroNER/blob/master/data/conll2003/en). More information about the task can be found [here](https://www.clips.uantwerpen.be/conll2003/ner/).\n",
    "\n",
    "### Target domain (in-domain) data\n",
    "\n",
    "As target-domain data we will use data from [WNUT17 Emerging and Rare entity recognition task](http://noisy-text.github.io/2017/emerging-rare-entities.html). This shared task focuses on identifying unusual, previously-unseen entities in the context of emerging discussions. The data were mined from mined from Twitter, Reddit,\n",
    "YouTube and StackExchange. Results of different competitors of the task were published [here](https://noisy-text.github.io/2017/pdf/WNUT18.pdf).\n",
    "\n",
    "### Named entity classes\n",
    "\n",
    "* PER - _person_: names of people (e.g. Alexander S. Pushkin)\n",
    "* ORG - _organization_: names of corporations (e.g. Yandex), names of non-profit organizations (e.g. UNICEF)\n",
    "Google).\n",
    "* LOC - _location_ : e.g. Russia\n",
    "* MISC - _miscellaneous_ : other named entities including names of products (e.g. iPhone) and creative works (e.g. Bohemian Rhapsody)\n",
    "\n",
    "### Evaluation metrics\n",
    "\n",
    "As evaluation metrics we will F1 measure on exact matched NEs. It means that partially overlapped enitities of same class are considered as mismatch.\n",
    "For example, LOC entities below is partially overlapped. And it is a mismatch:\n",
    "\n",
    "__O, B-LOC, I-LOC, O__\n",
    "\n",
    "__O, B-LOC, I-LOC, I-LOC__\n",
    "\n",
    "Details can be found in the code of _conlleval.py_\n",
    "\n",
    "### Data format\n",
    "\n",
    "The format of all dataset follows popular [IOB format](https://en.wikipedia.org/wiki/Inside–outside–beginning_(tagging)). The B- prefix before a tag indicates that the tag is the beginning of a chunk, and an I- prefix before a tag indicates that the tag is inside a chunk. The B- tag is used only when a tag is followed by a tag of the same type without O tokens between them. An O tag indicates that a token belongs to no chunk.\n",
    "\n",
    "The named entity labels include:\n",
    "* __B-LOC__ - location - first token\n",
    "* __I-LOC__ - location - subsequent tokens\n",
    "* __B-ORG__ - organization - first token\n",
    "* __O__ - not a named entity"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Part 1: dataset exploration"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To load datasets we will use `huggingface/datasets` library:\n",
    "\n",
    "https://huggingface.co/docs/datasets/"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import datasets\n",
    "import typing as tp"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# reddit = datasets.load_dataset(\"reddit\", cache_dir=\"/home/ubuntu/data2/nlp/\", )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "conll = datasets.load_dataset(\"conll2003\")\n",
    "wnut = datasets.load_dataset(\"wnut_17\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This datasets is a actually `DatasetDict`s.\n",
    "\n",
    "_Hint_ : to see class hierarchy we can use `getmro` function from `inspect` library."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import inspect\n",
    "inspect.getmro(type(conll))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(conll.keys(), wnut.keys())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's have a look at content of test part CONLL dataset:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "conll[\"test\"].features"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "conll[\"test\"].dataset_size, len(conll[\"test\"])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's have a look at single example in the dataset:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "conll[\"test\"][50]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There is a fancy visualizer in `spacy` nlp library we can adapt for custom dataset."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from spacy import displacy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def ner_render(words: tp.Sequence[str], ner: tp.Sequence[str], title: tp.Optional[str] = None, **kwargs):\n",
    "    pos = 0\n",
    "    ents = []\n",
    "    for word, tag in zip(words, ner):\n",
    "        if tag.startswith('B'):\n",
    "            ents.append({\n",
    "                \"start\": pos,\n",
    "                \"end\": pos + len(word),\n",
    "                \"label\": tag.split(\"-\")[1]\n",
    "            })\n",
    "        elif tag.startswith('I'):\n",
    "            ents[-1][\"end\"] = pos + len(word)\n",
    "        pos += (len(word) + 1)\n",
    "    displacy.render({\n",
    "        \"text\": \" \".join(words),\n",
    "        \"ents\": ents,\n",
    "        \"title\": title\n",
    "    }, style=\"ent\", manual=True)\n",
    "            "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Voilà!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ner_render(**conll[\"test\"][50])\n",
    "ner_render(**conll[\"test\"][200])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's compare CONLL and WNUT named entity tags. We need to count each type of tags in both datasets"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from itertools import chain\n",
    "from collections import Counter\n",
    "\n",
    "# Count every type of tag in CONLL and WNUT datasets:\n",
    "\n",
    "conll_tag_counts = Counter()\n",
    "wnut_tag_counts = Counter()\n",
    "\n",
    "# <YOUR CODE HERE>\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "wnut_tag_counts"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "conll_tag_counts"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Thus, WNUT and CONLL have different set of NE tags (labels)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "From WNUT description:\n",
    "\n",
    "**person** –  Names  of  people  (e.g.Virginia Wade).   Don’t mark people that don’t have their own name.  Include punctuation in the middle ofnames.  Fictional people can be included, as long as they’re referred to by name (e.g.Harry Potter).\n",
    "\n",
    "**location** –  Names  that  are  locations  (e.g. France).    Don’t  mark  locations  that  don’t  have their own name.  Include punctuation in the middle of names. Fictional locations can be included, as long as they’re referred to by name (e.g.Hogwarts)\n",
    "\n",
    "**corporation** –  Names  of  corporations  (e.g.Google).   Don’t  mark  locations  that  don’t  have their own name. Include punctuation in the middle of names\n",
    "\n",
    "**product** –  Name  of  products  (e.g. iPhone). Don’t  mark  products  that  don’t  have  their  own name. Include punctuation in the middle of names. Fictional  products  can  be  included,  as  long  as they’re referred to by name (e.g.Everlasting Gobstopper).  It’s got to be something you can touch, and it’s got to be the official name.\n",
    "\n",
    "**creative-work** –  Names  of  creative  works (e.g.Bohemian Rhapsody). Include punctuation inthe middle of names. The work should be created by a human, and referred to by its specific name.\n",
    "\n",
    "**group** – Names of groups (e.g.Nirvana, SanDiego  Padres). Don’t  mark  groups  that  don’t have a specific, unique name, or companies (which should be marked corporation).\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can match CONLL and WNUT labels using next rules:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "label_mapping = {\n",
    "    'O': 'O',\n",
    "    'B-location': 'B-LOC',\n",
    "    'I-location': 'I-LOC',\n",
    "    'B-group': 'B-ORG',\n",
    "    'B-corporation': 'B-ORG',\n",
    "    'B-person': 'B-PER',\n",
    "    'B-creative-work': 'B-MISC',\n",
    "    'B-product': 'B-MISC',\n",
    "    'I-person': 'I-PER',\n",
    "    'I-creative-work': 'I-MISC',\n",
    "    'I-corporation': 'I-ORG',\n",
    "    'I-group': 'I-ORG',\n",
    "    'I-product': 'I-MISC'\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def convert_label_sequence(example: tp.Dict[str, tp.Any], label_mapping: tp.Dict[str, str]) -> tp.Dict[str, tp.Any]:\n",
    "    converted_example = dict(**example)\n",
    "    converted_example[\"ner\"] = [label_mapping[label] for label in example[\"ner\"]]\n",
    "    return converted_example"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "converted_wnut = wnut.map(lambda x: convert_label_sequence(x, label_mapping))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Before:**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ner_render(**wnut[\"train\"][0])\n",
    "ner_render(**wnut[\"train\"][1])\n",
    "ner_render(**wnut[\"train\"][2])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**After label mapping:**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ner_render(**converted_wnut[\"train\"][0])\n",
    "ner_render(**converted_wnut[\"train\"][1])\n",
    "ner_render(**converted_wnut[\"train\"][2])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To visualize lexical differences between WNUT and CONLL let's use `scattertext` library."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from IPython.display import IFrame\n",
    "from IPython.core.display import display, HTML\n",
    "display(HTML(\"<style>.container { width:98% !important; }</style>\"))\n",
    "import matplotlib.pyplot as plt\n",
    "from IPython.display import IFrame\n",
    "%matplotlib inline "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# !pip3 install scattertext"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import scattertext as st\n",
    "import pandas as pd"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "conll_df = pd.DataFrame([{\"text\": \" \".join(example[\"words\"]), \"ner\": example[\"ner\"], \"dataset\": \"conll\"} for example in conll[\"train\"]])\n",
    "wnut_df = pd.DataFrame([{\"text\": \" \".join(example[\"words\"]), \"ner\": example[\"ner\"], \"dataset\": \"wnut\"} for example in converted_wnut[\"train\"]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df = pd.concat([conll_df, wnut_df]).assign(\n",
    "    parse=lambda df: df.text.apply(st.whitespace_nlp_with_sentences)\n",
    ")\n",
    "\n",
    "corpus = st.CorpusFromParsedDocuments(\n",
    "    df, category_col='dataset', parsed_col='parse'\n",
    ").build().get_unigram_corpus().compact(st.AssociationCompactor(2000))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "html = st.produce_scattertext_explorer(\n",
    "    corpus,\n",
    "    category='conll', category_name='CONLL', not_category_name='WNUT',\n",
    "    minimum_term_frequency=0, pmi_threshold_coefficient=0,\n",
    "    width_in_pixels=1000,\n",
    "    transform=st.Scalers.dense_rank\n",
    ")\n",
    "\n",
    "with open(\"difference.html\", \"w\") as outf:\n",
    "    print(html, file=outf)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "IFrame(\"difference.html\", width=1200, height=1000)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Part 2: BERT sequence labeling recap (2 points)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "https://huggingface.co/transformers/task_summary.html#named-entity-recognition"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The sequence labeling task is a degenerate case of the seq2seq task: we need to map a sequence of words to a sequence of labels (tags) of **the same length**.\n",
    "\n",
    "In case of BERT we want to get a vector of probabilities of labels for each input token. The simplest way to make it is just feed output token embeddings to Linear layer.\n",
    "\n",
    "`transformers` class `BertForTokenClassification` works just like this."
   ]
  },
  {
   "attachments": {
    "image.png": {
     "image/png": "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"
    }
   },
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![image.png](attachment:image.png)\n",
    "\n",
    "Image from FastAI article: https://d2l.ai/chapter_natural-language-processing-applications/finetuning-bert.html"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 2.1 Load pre-trained BERT-based sequence tagger"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from transformers import pipeline, AutoModelForTokenClassification, AutoTokenizer\n",
    "\n",
    "# Load pretrained model and tokenizer for English NER task (dslim/bert-base-NER)\n",
    "# <YOUR CODE HERE>\n",
    "# model = ...\n",
    "# tokenizer = ...\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's have a look at `BertForTokenClassification` class hierarchy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "inspect.getmro(type(model))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In `transformers.BertPreTrainedModel` there is an important attribute `config`. Let's have a look. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "model.config"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As mentioned above `BertForTokenClassification` = BERT + linear classifier"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "model.classifier"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "model.bert"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's explore one exmaple from dataset:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ner_render(**conll[\"test\"][10])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Tokenizer call splits sequence of words to sequnce of word pieces (bpe units) and maps it to token ids."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "encoded = tokenizer(conll[\"test\"][10][\"words\"], is_split_into_words=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "encoded"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here:\n",
    "\n",
    "`input_ids` - indices of input sequence tokens in the vocabulary\n",
    "\n",
    "`token_type_ids` - segment token indices to indicate first and second portions of the inputs. Indices are selected in [0, 1]: 0 corresponds to a sentence A token, 1 corresponds to a sentence B token\n",
    "\n",
    "`attention_mask` - mask to avoid performing attention on padding token indices. Mask values selected in [0, 1]:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As we discussed above in sequence labeling task output sequence length should be equal to input sequence length.\n",
    "\n",
    "Tokenizer can split single world to multiple pieces:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(f\"Original sentence:\\n---\\n{' '.join(conll['test'][10]['words'])}\")\n",
    "\n",
    "tokenized = \" \".join([tokenizer.ids_to_tokens[id_] for id_ in encoded[\"input_ids\"]])\n",
    "print(f\"\\nTokenized sentence:\\n---\\n{tokenized}\")\n",
    "\n",
    "# "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For example named entity `Takuya Takagi` transforms into `Ta ##ku ##ya Ta ##ka ##gi`. We need to preserve invariant: input sequence length = output sequence length. So sequence labels (tags) should be tokenized too.\n",
    "\n",
    "\n",
    "```\n",
    "Takuya Takagi -> Ta    ##ku   ##ya   Ta     ##ka    ##gi\n",
    "   |     |        |     |       |     |      |        |\n",
    "B-PER  I-PER    B-PER  I-PER  I-PER  I-PER  I-PER   I-PER \n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's write function for it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def tokenize_and_preserve_tags(example: tp.Dict[str, tp.Any],\n",
    "                               tokenizer: transformers.BertTokenizer,\n",
    "                               label2id: tp.Dict[str, int],\n",
    "                               tokenizer_params={}) -> tp.Dict[str, tp.Any]:\n",
    "    # write your own function to split each pair of word-token to same number of pieces.\n",
    "    encoded = tokenizer(example[\"words\"], is_split_into_words=True, **tokenizer_params)\n",
    "    encoded.update(example)\n",
    "    \n",
    "    # <YOUR CODE HERE>\n",
    "    # encoded['labels'] = ...\n",
    "    # encoded['text_labels'] = ...\n",
    "    \n",
    "    assert len(encoded['labels']) == len(encoded[\"input_ids\"])\n",
    "    return encoded\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_sentence = \"His name is Jerry Abrahamson\"\n",
    "test_example = {\"words\": test_sentence.split(\" \"), \"ner\": [\"O\", \"O\", \"O\", \"B-PER\", \"I-PER\"]}\n",
    "test_result = tokenize_and_preserve_tags(test_example, tokenizer, model.config.label2id)\n",
    "\n",
    "assert tokenizer.decode(test_result['input_ids']) == '[CLS] His name is Jerry Abrahamson [SEP]'\n",
    "\n",
    "                                     #CLS     His  name is    Jerry    Abraham   ##son      SEP\n",
    "assert test_result['text_labels'] == ['O'] + [\"O\", \"O\", \"O\", \"B-PER\", \"I-PER\",  \"I-PER\"] + [\"O\"]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "conll = conll.map(lambda x: tokenize_and_preserve_tags(x, tokenizer, model.config.label2id))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "wnut = converted_wnut\n",
    "wnut = wnut.map(lambda x: tokenize_and_preserve_tags(x, tokenizer, model.config.label2id))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next step is convert all numpy.arrays to torch.tensors:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "conll.set_format(type='torch', columns=['input_ids', 'token_type_ids', 'attention_mask', 'labels'], output_all_columns=True)\n",
    "wnut.set_format(type='torch', columns=['input_ids', 'token_type_ids', 'attention_mask', 'labels'], output_all_columns=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "conll[\"test\"][:1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To use `transformers.Dataset` with `torch.DataLoader` we need a custom function to pad sequences and make batches."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from collections import defaultdict\n",
    "class PadSequence:\n",
    "    def __init__(self, padded_columns, device='cuda'):\n",
    "        self.padded_columns = set(padded_columns)\n",
    "        self.device = device\n",
    "\n",
    "    def __call__(self, batch):\n",
    "        padded_batch = defaultdict(list)\n",
    "        for example in batch:\n",
    "            for key, tensor in example.items():\n",
    "                padded_batch[key].append(tensor)\n",
    "                \n",
    "        for key, val in padded_batch.items():\n",
    "            if key in self.padded_columns:\n",
    "                padded_batch[key] = torch.nn.utils.rnn.pad_sequence(val, batch_first=True).to(self.device)\n",
    "        return padded_batch"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "conll_test_dataloader = torch.utils.data.DataLoader(conll[\"test\"], batch_size=4, collate_fn=PadSequence(['input_ids', 'token_type_ids', 'attention_mask', 'labels']))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's test it:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_batch = next(iter(conll_test_dataloader))\n",
    "model_output = model(input_ids=test_batch[\"input_ids\"],\n",
    "                     token_type_ids=test_batch[\"token_type_ids\"],\n",
    "                     attention_mask=test_batch[\"attention_mask\"],\n",
    "                     labels=test_batch[\"labels\"], return_dict=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "model_output.keys()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Model output contains only `loss` and `logits`. We need to write simple wrapper to convert raw logits to token sequence."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class NamedEntityPredictor:\n",
    "    def __init__(self,\n",
    "                 model: transformers.BertForTokenClassification,\n",
    "                 tokenizer: transformers.BertTokenizer,\n",
    "                 id2label: tp.Optional[tp.Dict[str, int]] = None):\n",
    "        self.model = model\n",
    "        self.tokenizer = tokenizer\n",
    "        self.id2label = model.config.id2label if id2label is None else id2label\n",
    "    \n",
    "    def predict(self, batch: tp.Dict[str, tp.Any]):\n",
    "        self.model.eval()\n",
    "        with torch.no_grad():\n",
    "            model_output = self.model(input_ids=batch[\"input_ids\"],\n",
    "                                      token_type_ids=batch[\"token_type_ids\"],\n",
    "                                      attention_mask=batch[\"attention_mask\"],\n",
    "                                      labels=batch[\"labels\"],\n",
    "                                      return_dict=True)\n",
    "        indices = torch.argmax(model_output.logits, axis=2)\n",
    "        indices = indices.detach().cpu().numpy()\n",
    "        attention_mask = batch[\"attention_mask\"].cpu().numpy()\n",
    "        batch_size = len(batch[\"input_ids\"])\n",
    "        predicted_labels = []\n",
    "        for i in range(batch_size):\n",
    "            predicted_labels.append([self.id2label[id_] for id_ in indices[i][attention_mask[i] == 1]])\n",
    "            \n",
    "        return {\n",
    "            \"predicted_labels\": predicted_labels,\n",
    "            \"loss\": model_output.loss,\n",
    "            \"logits\": model_output.logits\n",
    "        }\n",
    "            \n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ner = NamedEntityPredictor(model, tokenizer)\n",
    "test_prediction = ner.predict(test_batch)\n",
    "assert test_prediction['predicted_labels'][2] == list(test_batch[\"text_labels\"][2])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import tqdm"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's measure quality of NER for in-domain and out-domain testset.\n",
    "\n",
    "To compare models we can use F1 measure. There is a great package `seqeval` to make such quality measurements."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#!pip3 install seqeval"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "conll_test_dataloader = torch.utils.data.DataLoader(conll[\"test\"], batch_size=16, collate_fn=PadSequence(['input_ids', 'token_type_ids', 'attention_mask', 'labels']))\n",
    "wnut_test_dataloader = torch.utils.data.DataLoader(wnut[\"test\"], batch_size=16, collate_fn=PadSequence(['input_ids', 'token_type_ids', 'attention_mask', 'labels']))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ner = NamedEntityPredictor(model, tokenizer)\n",
    "predicted_labels = {\"wnut_test\": [], \"conll_test\": []}\n",
    "\n",
    "for batch in tqdm.tqdm_notebook(conll_test_dataloader):\n",
    "    predicted_labels[\"conll_test\"].extend(ner.predict(batch)[\"predicted_labels\"])\n",
    "    \n",
    "for batch in tqdm.tqdm_notebook(wnut_test_dataloader):\n",
    "    predicted_labels[\"wnut_test\"].extend(ner.predict(batch)[\"predicted_labels\"])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import seqeval"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "conll_report = seqeval.metrics.classification_report(y_true=[list(example[\"text_labels\"]) for example in conll[\"test\"]],\n",
    "                                                     y_pred=predicted_labels[\"conll_test\"])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "wnut_report = seqeval.metrics.classification_report(y_true=[list(example[\"text_labels\"]) for example in wnut[\"test\"]],\n",
    "                                                    y_pred=predicted_labels[\"wnut_test\"])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(f\"CONLL:\\n {conll_report}\")\n",
    "print(f\"WNUT:\\n {wnut_report}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As we can see WNUT model perfomance is poor. Let's test hypothesis that for CONLL-like inputs NER quality will be higher.\n",
    "\n",
    "To make this we will train a simple log-regression to classify sentences between two datasets based on their sentence embeddings.\n",
    "\n",
    "The sentence embeddings can be obtained from [CLS] token embedding.\n",
    "\n",
    "For classification we will train vanilla sklearn log-regression. Just like on picture below, but we will use ordinary BERT for sentence embeddings."
   ]
  },
  {
   "attachments": {
    "image.png": {
     "image/png": "iVBORw0KGgoAAAANSUhEUgAABScAAAMdCAYAAABp/cMhAAAABHNCSVQICAgIfAhkiAAAIABJREFUeF7s3QdgVFX2+PEz6YFQAiT03nvvIE0EUXQVXOxtV13buoq6/uxt1bX3snYs2AtFUIqAdKlK7zWUAOm9zO+eN8xkZjIDAQKZTL73958/zJv37rv380LWnJx7jy0lJcUuNAQQQAABBBBAAAEEEEAAAQQQQAABBBBA4AwLhJzh+3E7BBBAAAEEEEAAAQQQQAABBBBAAAEEEEDAEiA4yRcCAggggAACCCCAAAIIIIAAAggggAACCJSJAMHJMmHnpggggAACCCCAAAIIIIAAAggggAACCCBAcJKvAQQQQAABBBBAAAEEEEAAAQQQQAABBBAoEwGCk2XCzk0RQAABBBBAAAEEEEAAAQQQQAABBBBAgOAkXwMIIIAAAggggAACCCCAAAIIIIAAAgggUCYCBCfLhJ2bIoAAAggggAACCCCAAAIIIIAAAggggADBSb4GEEAAAQQQQAABBBBAAAEEEEAAAQQQQKBMBAhOlgk7N0UAAQQQQAABBBBAAAEEEEAAAQQQQACBMAgQQCB4BfLz8yU0NDR4J3h0ZgUFBRIWxrezoH/QTBABBBBAAAEEEEAAAQQQQCDoBPhpPugeKRNCwCFgt9tlxuxZEhURGfQk2bk5cu45I4J+nkwQAQQQQAABBBBAAAEEEEAAgWATIDgZbE+U+SDgJhARESEDe/QJapOcvFxZvGpZUM+RySGAAAIIIIAAAggggAACCCAQrALsORmsT5Z5IYAAAggggAACCCCAAAIIIIAAAgggEOACBCcD/AExPAQQQAABBBBAAAEEEEAAAQQQQAABBIJVgOBksD5Z5oUAAggggAACCCCAAAIIIIAAAggggECACxCcDPAHxPAQQAABBBBAAAEEEEAAAQQQQAABBBAIVgGCk8H6ZJkXAggggAACCCCAAAIIIIAAAggggAACAS5AcDLAHxDDQwABBBBAAAEEEEAAAQQQQAABBBBAIFgFCE4G65NlXggggAACCCCAAAIIIIAAAggggAACCAS4AMHJAH9ADA8BBBBAAAEEEEAAAQQQQAABBBBAAIFgFSA4GaxPlnkhgAACCCCAAAIIIIAAAggggAACCCAQ4AIEJwP8ATE8BBBAAAEEEEAAAQQQQAABBBBAAAEEglWA4GSwPlnmhQACCCCAAAIIIIAAAggggAACCCCAQIALEJwM8AfE8BBAAAEEEEAAAQQQQAABBBBAAAEEEAhWAYKTwfpkmRcCCCCAAAIIIIAAAggggAACCCCAAAIBLkBwMsAfEMNDAAEEEEAAAQQQQAABBBBAAAEEEEAgWAXCgnVizAsBBBBAAIHSEijIyZNC83JvIRFhEhoV4fMW9sJCyU/P9vwsJETCY6J8nl9aBwuyc6UwN9/qzhYWKmGVIk+66zwdv5mHttDoCAkJP/3/yVBYUCg2mxm7sTrVpn2lbz0gGRv2S0hUuMS0rSuVG9Y81W65HgEEEEAAAQQQQAABBEpZ4PT/pFHKA6Y7BBBA4HQL2O12EyAxERIaAkcFEr5cIrmzZ3t6xDeR5s9e7dMocd5GSfvoa4/P7FHVpcXb//R5fmkd3PvJfMlbMN/RXZ1m0vyZK0+66513viW2vDTr+pgrx0jts9uXqC8NzG69d4LYzJ917rhAKjeuJbve+1Xy1m2X6H4dpd7Ynh795GfmyJ53Z0v+1t1iSztkIpMi9kqxEtWnk9Qb1/uEg6LZiamS8NJkse/faYKrjkCt3jDdvOwhkRLapp00vP0cCYs++cCtN0TW/hRXIDeiRmW/QWvv607H+0Aay+mYH30igAACCCCAAAIIBJ8Awcnge6bMCAEETkJAAxqJPyyX/L2JIkeSTTTGBBjq1ZJqQzpItfb1T6JHLgl6gcRdkpOUIZGxlYtNNWP++mLHKsqB7AOpYju0y5puRGwl68+8NVtFkhPEXtDOgyFtywE58MJXYstK0piko9lNfDI9UXJmzpLtC1dLo2evL3HGaeLcDZL6yWSR/CyP+zjf2ApzpHDdStkxfqfE3zFGqrau6/O8Ez2494G3xVaQY11W/abLpWbfFifaRamdv/eBd8xYHFm71W68TGr1a1lqfdMRAggggAACCCCAAAKnQ+DU102djlHRJwIIBIRATk6O/LFmjc+xZJvPEhMTfb7y84uylZwXazaiXuOvbd22TZKTTfZRGbSshGRJeP5Hyftjo9gPHxG7vVDsaWmSv3G7HPnfT5K0fEcZjIpbBryA+To5PHtdsWEW5hdIwfYtxY5XlAOZOw9bU7WHRkl4VUdwUtJNwN+0yPo1PBgOvPajFZi0ms38J0n1utZ1rpZ5SHY9+6PHNf7epKzdK6kfmmxVt8CkPTpWQlp1FGnUWuzhRUFkW+YROfjsJ5KbkumvO44jgAACCCCAAAIIIIDAGRIgOHmGoLkNAuVRYOr0aXLjrf/wOfT/vf+udOvXSwaPPLvYa8PGja5rNCj53EsvSLtunaRpmxYy5rK/yvYdOzz6TEpKlqv/fp2EhJTNUuoD780UycywxmSLriThHVqKLba69d5eWCDJn8yU/Ayv/QM9ZlD0Ji8vT5574VU5fOSInzPK12F9Nj9Mmiq+As6lMZPfFiyy+i+vLXPR2mJDT/p9uytzrdiHFeBAzp6jX/uVHf+GdNm25DuCgNENi4KTB39dL7aU/ZaIPSRMat19nTR/+QZp+uadEtqlR5HUrk0l+vd36L3p2pPjOluoxFx6kbR463Zpev9F0vzxcdLi3fES1rufq1/NLkwwy81pCCCAAAIIIIAAAgggULYCLOsuW3/ujkDACuxNSJAXX3nJ7/i2bN0q119znTz24MN+z9EP3v3wfdEg5/dffiv16tSR515+Ua676e8yc+p0CQtzfAt64dWX5LqrrpaqVases6/T8WHm3iQpTDT73Gkz46l370USWauK2aquQHY+8Y3YjySZpaj5cmTxNokf5rkk1dd4NNAWExMjNWt4Zoj5OjfQjmVlZcmiJctk6OCBrqElp6TKlJ9+lnNHnO16XqU57p7du8r/PfSEdOzQXpo3a1KaXZ++vkzgy3xRWP3bDu8W3RIgKq7oazd1XlE2pd0WJjZ78Uxi98EdNNmX6fPXSeGBRLHlZom9Wg0Jb1RHal/Wz6Nf92uSVu6UpOkrpXD3Xo2gS2iDBhJ/ZdFz8zf5zN0mY/CbxVKw2wQF00zGYvVaEt6igcRd2EOi61Tzd1mJjif/uVvyjmRI1h9mCbfahIaKLrPOO5jquj598wEpyMyVqm3rSebKba7joa2Ltk8IjQw3c+8vCauXm7lpsNEuqWsTpEavZn7HcXCGyfBOMhZHW9Q5Q6X2SJMx6dUa33y2bD+cKoVbHBnhBWtWSvqOXhLTJE5yjqTL3jd+dl3R+O7RViEgZzu8eKukzFhlvQ2rHSuNbhwqO16ZJoWpmWZ/zaJnnPzdAkmZuVqi2jeWehf3kB0v/ySFaY5l5nVvGCapa/ZK+uxVYk/cL7bK1SS0aX2JH9NbKjUo+p6h2wXsfV2DrY7WaPz5HsWNjiwxmea/rHSMJb66NLppmOx8dboUpGSYsRQVbtKxpM76Q6LaNZJ6Yzz3+nR1zl8QQAABBBBAAAEEEChjAYKTZfwAuD0CgSbwvAkezv1tnixbsVxyc3OlZQvf+5Vt275NrunvuxiI+5y++f47uf/e+6RNq1bW4ccfekR6n9VP/ly7Vrp27mxlUS5YtFAefeChMqFIWVy0/DasaQMrMKktxFQ6ju7RSjJ/WWK9z1puzjtOcHLf/gMyc/ZcefiBe8tkLqd607T0DPn8i689gpP16taRRx68TyIifFelPtV7RkVFydlDB8knn38pjz7471Pt7oxcb4+IMYG3cJNta4LaJnimS7vrj+tj3VszhQu3bHaNI6RxS7Hv8L3/pGbj7vzvDyImM1CbM2/Ydihd8s2ejXtWr5YqY8+V2ud28phXwvfLJGuSCaKZAKnzmsLNSbLv8S1iq13P41z3N3pd5uRfPAJpkpgheYk7JWHZKql5xzip3qGB3+uP98Hhz+aK7C8KOGqwMPXDrzwuS//0W8lo2laqPnKJFB4u2sYhukMjj/Mia8aI3QSBnYFdrbZ9rJaxoui+WvSm9oXd/J5e85K+kvj00e0qTGA31WzboMFJDZratxZlwhbmnesRnMzedcj1eW5iHdP/UMlft0lsOV7bURhPu9m6Ntt8DxHp4Tgn1xGg3f9ppBSagKgGXK1nl5whBSsTZN+fayT25kukRvcm1rgLs7zGkjtSxK3yevGxDJO8tToWx/J5qxPTdO9Pu/kyzTGBYhGCk04X/kQAAQQQQAABBBAILAGWdQfW82A0CJS5wNiLxsh/n3xaZv30iwkWPeJ3PNt3bJcO7Y5fvVeDNc4MSe3MUQXbJoWmkq+2/zz7tNz9r7tOS1ae38G7fZB3oOiH+fCGtTwuiWpU9N49kOKv36nTfpFuXTpL/XqlU2TD333O5PHIyAhp2KDeaa1ePmzIIElOSpEVq1afyamd0r0iehR97WcvLgpoJa80hWDyHFsEaHXu8KYaxPLddr85wxWYtAJxTdpKaPdeYq9S27pAC6ykfzVZ0ky2obOlbztoApPTXJmbeg9dAh3SSgOYJsswwZG16H3HI8u2S9aPPzkCk2ZvR1uTNhLWzdzLXG81M+ZDL06QnMNa0/rkWljDeJG4xhrZtzqwVzb/fsx7e8TRrNIws/+keR/eyJxnWvWL+0mVay6xXtV7N/e4aaIu+XZmI9psEtPScY2/kRUcOJr9bE6wxdXzyDL0vsYqghMW7Tqcu6foWu9zj/c+6qweEtbHLBU3GbLOZmvWzjoW09vxCxn3PgrXrBAxe1+GtO8qIW27mHEc3ZPT7JOZ9NbXZrtM//vyHncsg46O5ai/nu8cS2UfYzlef3yOAAIIIIAAAggggMCZEiBz8kxJcx8EyolAk8YmuHC0bdzsyOjyHvphUzQmPSND4uPiZeLXX8n+/fukQf0G0qdnb2nY0DPzavSo8+Sp/z4tTRs3kbp168rzZv9JzcLr1KGDlZ2pRXXOG3mu9y3O2Hvncku9YViVooCF9T4msmgcxyjmoyelp6fL0t+Xy73j7/AY+67de6xsyksvuVi+nzRF1q3baGWkNm3aWC4fN1aqV/dcSptillF/9+MU2bJ1m2RlZZvAYH254PxzfS55nj3HZLguWyl7EvZJFbOUvF/fXjJi+FB5/8NPZfT5I0WzHp1t2YpVMsuMY98+R6Crfr06cr7pt21rR2bswsVL5bf5i6zTX3zlTYmLqylXXT5Ojphl7Z98/pXccdtNogWS3vrfh3LFZZdIXK2aHvPUN5+ZrMt2bVubjFhHpl+6ycT87ofJstnMRf/eoH49GXXuOa57OjuIioqUvn16yqxZc63gbnloNYd3lH3zTKagNpMhmHUgRaJrV5OUeUWByvAuZhsAP9uopqxLkMK1jiXCelKNWy+XGj2aWt3ZTeB+26Mm41AzKk125IG3p0qVF663Pjv46TxNz3ScZ4KYTf57rSsQl7ppvxx8+n2TbehYcm6dZJr2d+SDqa6hVL12rMQNanP005Gy7YHPxb7XZF2aYOD+rxaLLn0+mdb41nOsy7Zc/5R1rxrXj7IyAbc9/YPYN/4hIa1bS9N7Rru6dmYJet/riMlkTJtYNN7Qzt1NLNHt36L3Bea9LdVRhEc/slU//vYQ9uiqYju61Log4eSDkw2u6G+NZov5t28z2z9oqza8i99q3fbwGKn/n79JdLzj332m2Z9z36PvO4r4mADl/m+XSYMrHX1anZ1Aa3C5Yz/NLb+vMP6OsVQ9uzPVuk/AkFMRQAABBBBAAAEEykaAzMmyceeuCJRrgU1m2WpoaJgMNwGwSVMmyUETYPzm+29l4PDB8sbbb3nM7dabbpb+/frLEFM4RwviLF66RD763/sSHh4uTzz9H3no/x4oUwt7hmMvOB2ELcLz9zUhZu87Z9N9JwvMUkt/bc26DVY2qAbg3JsG5Vb/sUZeePl1K6Py7jtvk2uuusyKLz313xclO7soU+rAwUR54qnnJdIEb/9xw/XywH13SdcuHeWV19+WP/70LLzy8acTZfLUn2XgwL7Wcugb/naNHDTXa/Bw/cZNkplZNC8NPH5qAozDzPLpxx+5T+684xZp3rypvGr61aXo2tq0ailDh5xl/X30eSNl0MAB1t9zTCB13foN1t8jI82SVFMgaMHCxdZ795Z46LDM+22hNGnkWJ6rQc0nn37eMrnh+mvMc75bevXsJu+Y8f2+zGSPebWGDevLlm0mu8/se1keWiVT2MVerShD9rDueWiaLvN1thrDPZdju88rdZlmODqCjBLf2BWY1HNsISESf/UQ1+m2I3ulIMexj6B91w7X8Srn9/PIEKzaqo6ENG/rfhvr7xmmerZWp9ammZLVuzaSPLNPovMVM8xk8B1t+StOLXtV9990ZjxWbuLIPC48ZPa2NC28TqzrPr7+ovu87np3tiS9/qnp4+i/i+r1pIHZT/F47Wi81jrNVpLCWiYb09XcLz7ejU7x88i+3V2BSe1K95kM61oUkM9ZXbTNxCneissRQAABBBBAAAEEECg3AmROlptHxUARCByBlNQUadWypbz83IuuvSR1dHPMXpVXXHuVdOzYUc7q7whuhZq9zrRozsMmCJmZmSlVqjj2dNQiOfHx8dKjW3drYloVOjklWTRz07H0+wzNt6Aoy8wW6vn7GluY5/uC3HyPPejcR7hhwyapERsrmgXo3TJMlull48ZIn149rI9iTSXwFiY4eMf4/5PVf/4pvXs6jn/z3STp0rmDXH7pWFcXg88aIJUrVTLB38mmaEw7y2b3nr0mQLhEHjQBv0ZHM1Vr1IiV6665Qv73/sdWFqd7m2kyEsdcNNpYO4JQWniocaMGsmbtBlm7br3UrVNb9Pr8oxYtWzTznoLr/YD+feVbM84LR4/yeE4asGzXto01N20/Tv7JCoBee/XlrmsHmms1U/Szz782QddOHkv5NahbYO6vWZadTHGc8tCieneQnF/2WUPN/n2tpHRtYgraOPYW1CXNVZrHS/KCjT6nkr/LbEp4tIU1cizjdj+xSovaclCX5+rSZhM8y9hxSDQg6qx6refGtPMMhOuxiMbxkuMV38rcUrQs3JadLLv++bz7rTz/bpZ3a5BQ91w9kZa6YZ+kmLnmHzpa/MZ8nR40e1xaKZTJjszE3C0JsvvDudLwukHFus7YeUj2vfCdyYB0VO/WE0JadRQtBKMFco7XbNVMJu+RPdZphUe89oD0cbEt8+g4zWehdR1BVB+nlfqh6FbFt3yIbttA0n533MpuvrfSEEAAAQQQQAABBBCoaAJkTla0J858ESgFgZHDz5HpZumxs8iNs8vBA8+Sy/46Tj74+MNid9EgpTMwmZ+fL1p45/577rOWCt9yx+3SuXc3GWUCaAPPHmICZkXVjot1VMoHbJWLlnJ7Z0YWZBdlStpMlCXca9m3+1C0qnVdt2XU7p9plqgzMOg8roVgmjdtIrqMW1taWrqsNHsujho5vNgMe/boJkfMUvo9exOsz5YtXyltWrdyBSbdLxh5TvEsMw129jJ9eLeYmMqSnHxiwZAunTpYy803bCqKgOm+ogsXLZUB/Xtbt8jJyRXN1hw10rHM1/2+Hdu3E33+23fs9BhOndrxEmIyBjVIXV5areEmiHo0A8+Wsl8Of+tYFq/jj+zR4ZjTsLtlzNr8BN90H0pny0/LlkITHHdvIV6ZvvqZd/avHstLdc9GtVmFZo71yjWVok+0pa/fK7nmlxOF648uVTdfE7nz51nHbAWO+9t3bpDceQuKdX1w1jrZ99j/igKTZh9G3Yey6f0XlSgwqR2G1C4KMNoT95oYrv+9G1PXm39H+ZmucYQ3iis2Jj1QLKGywLFPrs+TS3jQ1/Nxrwgu+dk+e/Ieiy7VpyGAAAIIIIAAAgggECwCZE4Gy5NkHggEiECvHr3k1TdfP+ZoPvrkY+nft580bdLELO1+SvYf2C9rfl8lVatVlRdffVluuu1mmTfzVytYdbqbrXKU6xaF2Y6ls84DBZlu782S5mMtF01LSzPZpC18Dlf3g3QvCuQ8KdpkRDoLAyWY5dUaxNT9KX21UJPJpnt96h6Uh8yfumekr6ZLx73dNEtTg34rVv0he0zWpS7B3rt3n/nzkAlw1vfVjd9jul9or17dZP6CRa69I9dv3GwFHDt3dATkDhw8aF3va/m3HtfFzDqHli2KiqBov3G1allB2vLSouLM3oa1zDJ2U53Zmte2oqB6zeHHDk6G1q0p+Xs2W9cVJBYPEOelZ1sFcZytssnCjKheWbQStXPJc5ZZrq37XLq3/IPF+6rUNF6cIS97dKy0eOs2j2tK400lk+mZ17Wn5G3ZZfZyPCD2SjUkvHVzKUjJOOpiM8uXTYawV3byvskrJfO7KWafzKNL3Gs3lQb3XiRarftEWuVuzSTtaGDUVpgr+75ZKg2vHuizi0Nfzi86booDVTtaIdv733f2vhSJqHa0YI25It9U1j7VlrvPscTdvZ+c/W4B+UpHn6fX9z4dS2RsZddlBaUwllOdC9cjgAACCCCAAAIIIFBaAqf/J//SGin9IIBAwAh8/tWXsn6DYx9C70FlZ2dLJRN089dSU1Plw08myPh/3mmd8vOMn+Xf4++1ApPa7vrnvyQ1Pc3sP7jNXxelejy0WtEP/HkJjn35nDfISXALJMT4n5Oer8HHvDzP4KazH+9goa8JZGVlmrhNiNQyhWZ8vXQZdXy8I8NLA4H+mmaohpmXe5s0ZZo88PCTsmDBYqlcuZJ079ZZbrvlBunXp5e/bo55fGD/frJy5WrX/pALTKCyT++ergCsZlbqnH3NQ4+dZ4rieO/NqTfMMl87oV7Bq2MOJAA+jO5XfAm67kWpewkeq0W1LFqSXbDVBHe9Mv0OTnUWyzFBT1Pd2RWYqlG0BDx5qlk27dYK8/Il78/1xW5rVbo2QThttuwkydhdVDxGj2mF7u3/nWQK1/wouz/wHRwv1qnXgeodG0rjO86VkJqOfSXD2raw3scMdPhoIRh93/i2Ea4rtRhM5nfTilIU67eQpk9dccKBSe0wXoPBNRq4+s79dY4kfHt0rfTRo4Um83HHC1PFvqPoe1dox64S08Tx7yo81vPfeNpaxzJxZ6d5G7Yfj8H6PN8jU9Xzkozf/izWR+aCNa5jobUdY4nwGkvGur0e1+WtL9lYClLKxx6uxVA4gAACCCCAAAIIIFChBMicrFCPm8kiUDoCM2bNkM8mfiZTv59UrMMZs2Zalbj9tVfeeF0uu2Sca2/C6Oho0T0snS3bLPPONsGt6MiijEZ/fZXG8ZjOTeTIckfGW/6O/R777WVvKApORLZxFHrxd88qVWJMNqJj2bW/c451XLMGtfjMgH69rWrmx2p6rjM70fu8w6YQTa5bkHTzlm2maNE0Gf+v26Rtm1Yep7uf593Psd7rfpW6X+hSU9hGl4uvNBmZDz1wr+sSDUDq/pG9epjAj8kaLUnLyMgUDVw7l/6X5JpAOCfu7Paya9LPJsBWtHdpVO/iAUvvscYNaydpk+aLLf2gyZDMlp33T5Bqfx0skfFVJWXpNsmZMdt1SaXzBrv+Xv3CfpLy/i7rvS6T3v78FKkxqpsUmOBm0jcLXHteut9PtyMI695T8pctsQKB+/7zmUT27izV+rUS3Y8yffoSK9tRW0jzouChex8l/XvhkWRrm8nweo5q7rl7jwb8q3pmeGp/+9+bacbjFmg3e7Nuu/cjn7eqcm5vqW2sj9XibjpXEp95zxHsNPPMmjxNtk6bK7Y69cVuthqwH04wWaduv0AIi5b6Nwx1dWlVBDdBVMlzZO9mm2t3mwzFMJMhmzHLVONOcewv6nMMuj/o0UzXtCkLJc/svRndrHaxqt22Q7tk+5PfSewFPa1ukqYsEz3mbDUv6Wv9VffZ1ICu7ehYsqYfHYv5+sicvdzs43mssZg9Os3XlLa0qWYsR9J8jsV1U/6CAAIIIIAAAggggEAZC5A5WcYPgNsjUB4Frrr8Slm2Yrm8/Pqr1lJjbbo8WZdkL1u5XO68/V8+p7U3IUFmzJ5hqjf/zfX5pSZQ+fDjj8qCxYtky9atZv/J26STKajT8GihF58dleLBqp0aiO1oINSelip7358jKWv3yr4flkv+xqLspOr9PQN73kPQgKEuzT7ZFh9XS6qZAM6S303gwatt2LRZbr7tLms5tjYtjLNmzToTzEvzPlXmznNbsmo+VfP4uLhigUnNvty6tWTZV8VuYg7o/pILTVEeHW/jRg2tojrOVsMUxaltgpeLlnhm9unnO3busuaye49nIDdhnyPYEmfGWp6aBv5s9Zu5DdkmtY6zpFtPDjEZonG3XCD2UBMQ02aCTSn/mygHn3zHFNmZ4Qp22hq0lHp/cRSN0tNqDTRfh+aYsxWuWSGHnn3PVLj+xET7tlnVuH21Bn8bIvYYh60WxcmdO1cSn35XMr6e5ApM2s0S9ToXFt+b1Fd/fo9lOLKNoxo6gpN5+x3vQ2sVzyS1793t2Y0xsB3e4/OVf6j417r3GKq2rivVb77CCuq5mtlb0q7L583Se/fApL1Kban94LXF9pEN79nF41rdM9Nadq6BSbfMTO972+KLCt1ooDdnxixJmVOUEek83x5RVQq3rJHDL35ovQo3FWVShrTvKjoHZ4vo3dVzLGYPTx2LFZg81ljqFG35oMFvHUvqr8XH4j0H3p+YwIH5m2TX10slyfzvBQ0BBBBAAAEEEEDg1AQITp6aH1cjUCEFhg4aLG+/9qZ8+c3X0q5bRxlmlum2795Zpkz7ST79YILZD7F4FWGFeurZZ+SOW/8pkWb/Rme7/ppr5Zorr5Lx/75HLrzkIokygcJ3XnvrjLlqkKjySEcWk940b81mOfz2ZMmaVbQkNLxjK0el5GOgkpI0AAAgAElEQVSMqn27NqJVuU+0wIyzS91v8vzzRohW7F5vKn87mwbxPvn0S7PPY3ezJ6Mj4NO6VQtT7buZvP7mu66COnr+oiVLZfmK1RIeVlTduEnjRma/ySQrKOhsOkat6q2ZmpmZRcs+K0U7slWz3Yq1+JuyVh7ftXuPTP95lvTv38fjNK0ofsHokTLJVOz+48+1rs8S9u2XjyZMNMHnDmbvTM+vkb0J+6xn37xpY3+3DNjjlQcWZQrbazYQay/KErRqptp2g2duFmloAo5uxW+sS81S7ugLRkmzJy8r1lOzx8dJWI/e1v6TrmaWbYd16yVV/jKk2Pl6QIuuNHvpBgnr3c9c55mZq+9DzX6RTZ+8vMQFaHzdJMcU0nHuk1mpkSMYWZjoCE6G1XEs93Zel5dqCtKYyuCl3Wr2aiaNX/iHVelbDb2bPbKahPXqK81e/JtrObf7OfWvGSihHTwDtFo8KGLQIIm9dLB3d6739f91vllb3sRVIMnfiVXGni2h3c12Cm7P2x4aJRGDB0vTe0Z7XFb/6gES2qkoMG19aDI0I0zhseqXDfZ3C6n/z/OOjoX/xPOLVAofJH78k6RO+kmOLPC9xUkp3IIuEEAAAQQQQACBCiNgS0lJOboLfYWZMxNFoEIIaAXl2XPnyKAejmWCp2PSmi25a/dua4lxvTp1j5vtOH/RQunfp68pcKwLP0un5eTlyuJVy2TYkKLlmSfTc+KcDZL2g8k6LChaZmozAZ/wbm1EAxbHG3OuCfTd/e+H5eorx0mP7kUZT+vWb5QJn34hz/znkWLDes0EF1u2aCojzznb9dnc3xbIN9/+aAK4Udb+i0dMYHHggH5yqQncui/31irnGuhbufoPiTNZlxnpGVKrZk256cbr5MFHnpT7/z3eFQCc9vNMmTxlusSb/ezy8wsk11x7yZgLRZfQfz7xG+nevYv8/bqrrDH897mXRSuPa5933XGL7DPZoI8+8Yy888ZLxcb/5jvvy7p1G+SFZ5/0CDg7T1y8dJlM/PJbay/KCBN8PXT4sPQ1+1xePm6sREW5BdbMBe9/9KlVVOemv19b7D4V4UCheS4ZpsBNngnwVW4WJ5E1jr8cXv+Np289KFplvkqrOicUWMzalyxZu45ImNnbsLIJJIZGHXsrgfL6DLJNxmX6BpORGRkmVdvWM6u2S7ZdhJqmbz8kWhW7ahtTZMoUpCpJK8jNk7yj+zxGmAI2et2WG192LbevcuUYiTfL0/W8tI37JcyMp3KTWsf8/pKflSOZOw6L7plZtXUdCQkv2Y48vsZSkjlwzvEFMs2/n233vmydGD1woDS/cdjxL+IMBBBAAAEEEEAAAb8CBCf90vABAuVb4EwEJwNBqLSCkzoXe6FdtEhHtgnaRMRXkUpNakpoRFEW4vHmO3nqdFm1+k956P57jnfqMT/XZ3cw8ZCV1VjbFMGpVCna7/kapNybsN86T4vd6NLv/3vwMXnlhWes986WmZlpAo0HpZopPFSrZtESW82ijDYZk85sVr33zl17rGudmZp+b17CD3RMWs1cl3q7j8l5uVbudgZUT7R6eAmHwGkIlJmAr+BkmQ2GG5eKwKYXpkiu+aWYNoKTpUJKJwgggAACCCBQwQVK9uv3Co7E9BFAoGII2EJsJouspvU6mTZsyCCZ9es8WfXHn9Klk1lWepJNszQ12OivrVm3XqZO/Vnu+tetVlCxmdtS6N/mL5TmzZoWCwJqBfXmzZoU67J6dc9CJXrvJo0bFjvvVA5okPNYgc4pJqir+2gSmDwVZa5FAIEzIbBjwm+uwOSZuB/3QAABBBBAAAEEKoIAGxJVhKfMHBFA4IwIaIbjFZeONXstTj+t92tp9pvMMBXN3zX7e+q+j+lmSfcWU9zm629/kJmz5shfLjT735WTplmVq82+lLrUm4YAAggEokCeWVq/f94G2WgqraebAkM0BBBAAAEEEEAAgdIVIHOydD3pDQEEKrhAzx7dzNLqQ3L4yBGpWaN4heLS4NFsyfvu/qf8NH2mfPDxZ1bF9OrVq0uDenXl//59l9lrsn5p3OaM9LF3b4Jcc9WlEmsqfNMQCEaBxs/faG0ZoS20UnDu7RmMz239vydIQWqqSG62Kd5kCofZC4JxmswJAQQQQAABBBAICAGCkwHxGBgEAggEk8Cokeec9unoMu2xF19gvcpz69L55Je/l+d5M/aKIxBetWjv14oz6/I/0/wDe13V58v/bJgBAggggAACCCAQ2AIEJwP7+TA6BBBAAAEEEEAAgTMs0OTRv5tkyUKfd83ckySH3vvC52ccRAABBBBAAAEEEDhxAYKTJ27GFQgggAACCCCAAAJBLFClif+iZGIKh9EQQAABBBBAAAEESk+AgjilZ0lPCCCAAAIIIIAAAggggAACCCCAAAIIIHACAgQnTwCLUxFAAAEEEEAAAQQQQAABBBBAAAEEEECg9AQITpaeJT0hgAACCCCAAAIVSmD3nt2Sn59foebMZBFAAAEEEEAAAQRKV4DgZOl60hsCCCCAAAIIIFBhBDZt2SK/zp0jW7ZtJUhZYZ46E0UAAQQQQAABBEpXgII4petJbwgggAACCCCAQIUSyM3Lk42bNsn27duladOm0qRRYwkL4z8xK9QXAZNFAAEEEEAAAQROQYD/cjwFPC5FAAEEEEAAAQQQcAgQpOQrAQEEEEAAAQQQQOBkBAhOnowa1yCAAAIIIIAAAgj4FCBI6ZOFgwgggAACCCCAAAJ+BAhO+oHhMAIIIIAAAggggMDJCxCkPHk7rkQAAQQQQAABBCqSAMHJivS0mWuFE7AXFkp6cmpQzzu3II+9zYLoCU+dPi2IZsNUEEBABQhS8nWAAAIIIIAAAgggcCwBgpPH0uEzBMq5gP5AuOzPVeV8FscZvk0kL8R+nJP4GAEEEECgrAUIUpb1E+D+CCCAAAIIIIBAYAoQnAzM58KoECgVgcjwCOmUWa1U+grUTvIiQ2V92JFAHR7jQgABBBDwEtBfJ5nfK9EQQAABBBBAAAEEELAECE7yhYAAAggggAACCCBw2gXCw8OledOm0rhRY7bjOO3a3AABBBBAAAEEECg/AgQny8+zYqQIIIBA0AucN/LcoJ8jE0QgmARmzflVsrOzjzklgpLH5OFDBBBAAAEEEECgwgsQnKzwXwIAIIAAAggggAACpS8QYTIlm5pMySZkSpY+Lj0igAACCCCAAAJBJEBwMogeJlNBAAEEEEAAAQTKWoCgZFk/Ae6PAAIIIIAAAgiULwGCk+XreTFaBBBAAAEEEEAgIAUISgbkY2FQCCCAAAIIIIBAwAsQnAz4R8QAEUAAAQQQQACBwBUgKBm4z4aRIYAAAggggAAC5UGA4GR5eEqMEQEEEEAAAQQQCECBVi1aSN06dam+HYDPhiEhgAACCCCAAALlRYDgZHl5UowTAQQQQAABBBAIMIGGDRoG2IgYDgIIIIAAAggggEB5EwgpbwNmvAgggAACCCCAAAIIIIAAAggggAACCCAQHAJkTgbHc2QWCCCAAAIIIIAAAmdAoGqzeOnwyaNn4E7cAgEEEEAAAQQQqBgCZE5WjOfMLBFAAAEEEEAAAQQQQAABBBBAAAEEEAg4AYKTAfdIGBACCCCAAAIIIIAAAggggAACCCCAAAIVQ4DgZMV4zswSAQQQQAABBBBAAAEEEEAAAQQQQACBgBMgOBlwj4QBIYAAAggggAACCCCAAAIIIIAAAgggUDEECE5WjOfMLBFAAAEEEEAAAQQQQAABBBBAAAEEEAg4AYKTAfdIGBACCCCAAAIIIIAAAggggAACCCCAAAIVQyCsYkyTWSKAAAIlF9j53GQp2JcotogIafrMlSW/kDMRQAABBBBAAAEEEEAAAQQQQOCEBAhOnhAXJyNQMQTs9kLZe+igZOflSMO4uhIZHlFs4rn5uZKWmVnsuB6IjakiISGhHp/Z7XbJK8iTiLDifemJOw7skRpVqkvVSjE++zxTB1PWJUjBrr3W7ezm/2gIIIAAAggggAACCCCAAAIIIHD6BAhOnj5bekagXAr8vOw3eWbiO2Kz2azXkeQk+cvAc+T+K26W8NCibxkf//K9vPL1x1K9WtVi83xv/FPSpmEz67gGJV+f9KlMnDFFktNTpFe7TvLEdXdaQU9nS8lMk5tfeVS+efjVYn2diQOZe5IkLyVT0pdvl9zl60/plnl5efLyq2/J9dddKTVr1Dilvkrj4p9nzJJ2bdtIwwb1/Xa3bsMmSUpKkv59e/s951Q+eOe9j2TwWQOkdasWp9IN1yKAAAIIIIAAAggggAACCAShAMHJIHyoTAmBkxVYsXmt3PfO8/LCrffJ0C59rW627d8tD7z/ojw+4TUrqOhs2/fvlatGXiT/HnfDMW/3ycwfZcayBTLh/melbo04efX7CXLrq4/JD4+94cqufOOHz+SKYRdI5ahKx+zrdHxYmF8g+//7Zal1/cOkqRITExMQgUmd1IyZc6Rq1aqu4OSu3XslOSVZOnVo75rzhg0bZfv2nactONm3d0/5+JOJ8siD90pkZGSpWdMRAggggAACCCCAAAIIIIBA+RegIE75f4bMAIFSE5i0aJYM79XfFZjUjpvVaSjXjRwjs1YutrIgnW37vt3StlHz4957sunzrrHXSYt6ja3g432X3iRZOVmybtdW69rdiftkyYbVcvmQ847bV6CfsG//AZk5e65cMPrcgBnq+Dtvk84diwKR6zdskHm/LfQY37Ahg+Tqqy47bWPuZO5fuXIlmf7LrNN2DzpGAAEEEEAAAQQQQAABBBAonwJkTpbP58aoETgtAqmZGVLd7Bfp3WJjii/d3nVgnwlOOpZue5/v/r6w0C6hbvtPOpaLh0hhYaF12gtffyC3XXhFsT0qj9VnaX4WEhYqTV6+0dVlyurdkvThtJO6xdRpv0i3Lp2lfr2iJesn1VEpXlS3Tu3j9lbNx9L84150gidcOHqU6PLu4cOGSKVK0Sd4NacjgAACCCCAAAIIIIAAAggEqwDByWB9sswLgZMQOKtjT3nthwly+IJkqVm1uquHSQtnSfdW7a09KLUlmb0j0zMypFa1WPl+/gzZn5Qo9WvVkR6tOki9mvEedx7Za6C8+M2H0qROfakdW9P0/6mEh4VJ+yYtZdXW9XI4NUmGdx9wEqMtvUtCQouSyG0hjjmeaO/p6emy9Pflcu/4OzwuTU5OkQ8nfC7/uv0fMuvXuTJv/mJJTkqWenXrSMeO7eTcEWebwKxnEvvehP0yeeo02bFjl+SbZeeNGzeQ4WcPkTatWnr0vd7sFfn78pWyZs060QBj+3ZtpG+fXlI7Ps513sefTpSB/ftKs6ZN5JPPv5QNGzdLZmaWvPjKm9Kndw/pZ87XPg4cOCjnjxohuv/kkiW/y3XXXFGMIDU1Td7/6FP5+3VXSZUqjsJF27bvkJ+mz7DGGmGqmzdr1kTGXnSBVK9ezeP6Du3bSkzlyrJw8RI5e+jgYn1zAAEEEEAAAQQQQAABBBBAoGIKEJysmM+dWSPgU+Av/c+WI2nJ8pdHbpbBnXubLMqqsnrrBgkxQcnX//mI65qte3dJWFiIjHn0NmlRv4kpblNHlm9aI4988JLcPuYauX7kWNe5fxt5iekzVS64/0bJMcViOrdsK6/f/oiVTfn8V+/LPX/9u8+xlLeDa9ZtsLJBG9Sv5zH0vPx8WbtuvUz47AtJT8+Qa6681OxHGStbtm2Xr77+XraZvR5vv6Vo3871Jnj4xpvvytnDBlnBQg34rVu/0Tp26bgxrn0h9byXX3tLLv3rxVaA84gJeM77bYE898Jr8tjD91nLqLVt3rJdOnfqYP190MABViB0z54EGX3eSGsc2hITD8nOXXusvzdu2EBee/1tGTZ0kDQyf3dvi5f+LlkmsOkMTC5fuUo+nvCF/OXCUWYcYyQ7O1sWLFwsTzz9vDx433iJjS0KcGs/DRrUkz/+XEtw0kOVNwgggAACCCCAAAIIIIBAxRYgOFmxnz+zR8BDIK8gX7aZvSTDTOAw1wQSM7IyzT6ThZJssiT3H0m09o3UlpaVIc0bNJan/jbedUyPL1y3Qm549n5rL8q+7bpa52owTIvm3HPJ3yQ7L0cqRTqW9M5YPl/iqsdK5+ZtrPO0YndqRro0MBmYzgxN64Ny0jaYjMMasbESFeW74MuhxMNy179udc2tR7cu0qRxI3no0f9Y2Yrt2rSy9vSc+OW3MnLEMCsw6WzxcbVMUZsYmfDJl9K9a2dzjyhZYQKDWoV7yKCB1mlxtWpKk0YN5P6Hn5TVf66xMiK9W6OG9aVWzRqmMneytGzhe0m+BjW7dO4k8xcslssvLQoya1/zFy6VYUMc98vJyZWJX3wrV185Tnp0dzxrPWfcJReLfjZ1+i9y5WV/9RiCLnf/ecZsa57l8Rl7e/IeAQROv8Dq1aulbt26Eh/vmZV/+u98/DtkmP9tDA8Pt36JdKymv7jKysqyCoKFmZUDp6NlZmbKqlWrpG/fvnx/PR3A9IkAAggggAACp1WAgjinlZfOEShfAg999IoVhPz5vx/If2+4Rx6+6jb55L7n5abzL5XLHr/TCiBqG9Klj3z10KsegUk93q9dNxk7ZJR8PntysYlrkNIZmCwsLJDXf/zMFMq5XjQges//npWBt42TcY/9S85/8EbZuHtbsesD/UBySqr5AbqO32GOMAFH74CcBgo1SKnLwbXt2LlbDh48KEMHn1Wsn64mYBgZGWECj2utz3Tp9s5du0WXjTub/uD75KP3WwHMU2n9+/c2Y1oheSZA7WyaWXnIZFj27tndOvSHCYDq/dwDk85zBw7oJ78vW1lsCJo5qX1qBikNAQQQOJ7AoUOH5KuvvjLZ2sX3Qj7etWfi84ceekjmzp3rcavk5GTzC5ocj2OHDx+W++67TzZu3HjahlWpUiX57bffZPlyx/+enLYb0TECCCCAAAIIIHAaBAhOngZUukSgPApohuT8P3+XO8dcJxFhnlkg5/YaJK0bN5PZKxYfd2rdzb6Tmn15rPb5r1Old5vOZjl4XXn1uwlyMPmQLHzzG1n4+pdyfp8hcudbT1sZm+WppaWlWftI+msN69f3+ZEGNA8fPmJ9dsAEJmuagKWvgjEa2KxdO94swU60zu3Tq4fUNhmV//fQ4/LOux/JXLOkWwOV0dHRVtDwVFp7k5EZEREuq/9Y4+pm/sJF0rNnNytrU5tWJhezPedX3/xQ7LVg0WLRjCLvH9Dr1nEUCko1VjQEEEDgeAKzZs2SwYMHW9/Xykt7+OGHZdGiRWUy3FGjRsnkyZM9frFUJgPhpggggAACCCCAwAkKEJw8QTBORyBYBQ4kHZb9iQelXi3fS+d0CfbmvTus6X9niuA4/+7tkZ2TbTIkHQEs78/0fUZ2pnw2a5Lc+hdHwZVZKxfJHRddIzFRjj0Sbx59uaSbZePb9jv2QPTVRyAe06V67pmG3mPUrEd/rcDsS6lNrw8N9b/kTwOGeXmOc2NiYuTeu+8whXZulri4mrJk6XK578HH5P0PP7H2fjyVpoHQfn17yYJFS13j0v61sI6zWUsUIyKllllO7v2qZ5ZgXn7pJdbybffmHFdoaOipDI9rEUCgAgikpKTIihUrZOBAx1YSgTjlO+64w/zSpudxh1atWjUZP368NG3a9LjnnsoJHTp0sL7vkj15KopciwACCCCAAAJlIeD/p+CyGA33RACBMhOoUyNO6sTFy9INf8iIHp4/DOabpddrtm+SQZ16W+P7ddUi+XruTzLxgZeKjXfOH0ulXWPPqtLuJ709+QsZe9YIqVbJsUwvygS4UjPTXafk5udKdla2REf4D3AWu2kAHNAiMXv3JvgdyX5TDVv3mPRuh48cMcHFWtbhunXqyBGTRelvT8aDZt/KbkeXbOu+juHhYdK6VQvrpU37evGVt6x9HS8cPcr7Vif0vn+/PjLt5yetbMzNW7dZ1cBbNC/6wbpmzZoSEb7LLEEveeAgYd8+awxVA3SJ5gkBcTICCJxWgV9//VWaN2/uytY+rTc7yc4bN3bsw3y8y3VPyiZNmhzvtFP+XH+x1KtXL5k/f7706dPnlPujAwQQQAABBBBA4EwJEJw8U9LcB4FyIHDtORfL0xPfkRpVqknP1p2sEWfmZMkjH78mkeGRMqKnIxD110Gj5Ibn/k/enjJRxg0eJbEx1axl2G9P+UJWblgj3z/5ls/Z6n6Wv65eLN8/9qbr8zEDz5FnvnjH2o8yrnoNefnbj6Rds5ZSr6bvDE6fHQfAwbhatUxlbP97Zc6ZO1+uvfpyj5FqgFH3ZrzqinHWca30rXtzLl+52tqL0r0596Ns1dIRiHzFVNSuX7+uXGEyFJ2tZo0aZk/IbrLFBBNPtWmBnRbNmsqiJUtl46YtMqCfIzDt7Ld1q5by9bc/yEGzD6UW7HFvk6ZMkyVmz0rd/9J9n819+/abKuKVfS5bP9Xxcj0CCASPgG4JoQG2ceMc3xt1Zrof74wZM2TMmDGixV+WLFli7eGo+zk2atRIWrdubWVZeu/tq9dqf7Nnz5Zt27bJ/v37zfYZNUUDi4MGDZIa5vumd9uyZYu1f+OuXbusa2NNsbMePXrIgAEDrAI4zvbFF19Ip06dpE2bNjJx4kTrsP5yadmyZeaXVXut+4wcOVJSU1Ot5dbOJerTpk2T3r17S4sWju/n3vfXjNHt27dbc3U2HdPvv/9uHc832fYauO3SpYu0b9/e4/Ju3brJzz//LAkJCVKvXj3vrnmPAAIIIIAAAggEpADLugPysTAoBMpG4O+j/iqXDxst/3zlcRl2z9Uy9rHbZdAdV4hmM75z5+Mmm9Gxl+HAjj3kxVsfkB8WzJS+t4yVvzx8i/S//TL5+fff5J27nxTNwvTVXjKBx3+cf5mEuy1dvnzoaBPgPE8e/vhlufKpu002XoS8dMv9vi4P6GPt27Wx9ll0L1DjPuBt23fKzNlzXEud9YfrN95+16rw7QxEaqXviy8aLV+Yit16vrNp1uX/3vvIVMo+y6q2ra1P7x4y77eFVuDQuXxafwBetmK1yXBs5tdKiyZkZ3sWa/B38oABfeTXOfNNAGCL9O3tWf27oSlu06VzR3n7fx9aGZvaCgoKrErhP02fIaPPG1EsSJBggpPt2rb2dzuOI4AAApbAzp07raBgfbe9enVf38WLF0tSUpK8+uqrVrCye/fuVgBPg4c//vijvPfee8X2utVg5HPPPWftA6lBzLFjx0q7du2swKYe9y5So4FF7V+DkBdeeKFcdtllVuBz6tSp8uGHH3o8oaVLl1pBSG26XYVzywrn353vdS46di2Wo2PVe86ZM8ejL/c3P/30k8c8FixYIK+//rqowZAhQ+S8886zvu+/8847VtDVvWlAUn8JtGnTJr/98wECCCCAAAIIIBBoAmROBtoTYTwIlLHAjaPGyXUjxsiWvY7gWOPa9VxVtt2HNqr3YDm311my99BBU9DmsBWQPF6248UmS7LX0YxMZ1+a5aL301d5bq1aNpdK0ZWsrEVfFazvHX+7VbhmytRfpGrVKibjMFHatG4l99x1u0cQb/BZ/U32pE1efvUtUwQiyvphNykpWUafP0LOHTHcRXSWqYh95EiSWcb9hlUAp0aNWLMkPMnsf9ZVRo0sOs/btJ0pdvP5xG/kiaeek65dOsn5o0Z4n+J6361LZ/ns82+kQ4e21pi929+vu0q++Po7efCR/1gZQqmmYrnd/N+4Sy6yCva4N91PUyt+XzaufD9nbwPeI4BA6QtohqM2/b7i3TRAeP7551uZjM6mGYSaMfjmm2/KzJkzreCdtsLCQvnggw+s76N33323+T5W1XWNZjF+/PHH8v7778sjjzxiBfS0aVZj3759raCks3Xs2FGaNWtmBQM1sKjBSvemGe+XXnqpdWjhwoXStWtXK0vSV9P/zdMl1zpO3bvXu9jP7t275cCBA67+9uzZI5qhqXPSLExn08CsZmzqHBo0aCCtWrVyfaZ7W2qmpb8x+BoXxxBAAAEEEEAAgbIUIDhZlvrcG4EAFdDMxraNmh93dDZbiDSIq2O9StK0Qnegt+pdGkn11/5xwsPUPcWGnz3Y7NM402dwUgvYjL/zNuuH0X37TeGhurX97qWmgccBZs9HzZjUbEStAu6riMxfLjA/rJ5ztmhGYlhYqOhSbO8fdHVptXuraYKYLz3/lOwx+2PqGLT5C2Zq0PP1V571a6GZRVddPk4uveRiq3q3/oBeOz7OY9mj8+LfFiyWaFPpu/vRPTP9dsoHCCBQ4QU0G1GzvPV7kHfTAKN7YNL5uQYPddn13LlzZejQodb3Qs2C3Gf2uvUOTOo1+j1bA5AamPzll1/koosusoKZhw4d8rlfoxab0WXYmrl5qk2Dk9OnT5eVK1dKv379PLrTMdcy24Q4l3zrUva6psjYOeecU+y26qBLvefNm+cRnIyLi5O1a9cWO58DCCCAAAIIIIBAoAqwrDtQnwzjQgCBcicwbMggs8Q5SVb98affsesPzM2aNvYbmHReqIE+DUo2bFDfZ2DSeZ4uBdf+GjVsUCww6W8Qeo0Wt9Ef/kujaZBS7697Zrrvx+bsW7Mmf5o2Q843S719BVlLYwz0gQACwSOQnp4u1atX9zkhzRj013QfR/0FkO4VqW3dunXWUm5/hWv0l0aacbl+/XrrfP2+q4VrtBjPhg0bit1Gq3OXRqEZ3edSMx01sOjedKm27jep83A2HZsGIXVsvppmda5Zs8a1vYeeo/PSbUZoCCCAAAIIIIBAeREgc7K8PCnGiQACAS9QqVK0KVAzViZNni5dOnUM+PGeqQHONXtj1qtXR/r18dy38kzdn/sggED5EtDAmq8l3ToLXwVsnLPTjENtmv2oS691ebT7vpW+FDQrcfny5VbWpAYAr7rqKmup9BtvvGHtD6kZjJqVqWu2PXcAACAASURBVMHE+PjSK9SmS8f1PpqJqffRtnnzZmtfSq24rU2DtBps1aXkusemr5aSkmJl2Ot+lM5l65oVqvsaa7DTV4EgX/1wDAEEEEAAAQQQKEsBgpNlqc+9EUAg6AR69ugmieYHYy0So9WzrQzICl4xNTs7W665qmj/tqB76EwIAQRKXcB9f0j3zsPC/P+nq36mLy1Ao03/9LU03L2/KLPdhGZ360vP1QDn+PHjrexLXRqt1bF/+OEHq6/OnTtbwcvj9VkSDK3yrdnruox7+HDHPsH695YtW7oCsLm5uVZXmpGuAUdfTZdw68tZGE3P0QCn/m8PgUlfYhxDAAEEEEAAgUAU8P9feIE4WsaEAAIIlAOBUSOL9gbTPR4ff/i+cjDq0zfEYxXdOX13pWcEECivAlqcxhlg9J7DsfZ8TE1Nlfz8fFfWpQbtNIvyWE0/1yXk3gFHXQ6uL20auNTA4ddffy3fffedR7GcY/V9rM804KjLtZ3BSb3H6tWr5eKLL3ZdpuPSIKMGRTXTsqRNjZwFfkp6DechgAACCCCAAAJlKeB7A5uyHBH3RgABBBBAAAEEEKiwArpnoi5p9tV0H0l/zbl3pC7V1qZVrLdu3ep3/0XNNvzzzz9dS7+175dffrlYYFQDiRoc1OI1x7q/v3H5O677VyYkJIgWANJ+dXm2Vh53Ng1M6lJyXe7tr2kBoGeffdYKoDobwUl/WhxHAAEEEEAAgUAVIDgZqE+GcSGAAAIIIIAAAhVQQIOK/vZY1OxCrcDt3TTTcvbs2dK+fXvX3pCDBg2yTtPK2L7akiVLZP/+/TJixAjrY93nUoOZ/ipd6xYVGjg9VtOAonug8Fjn6jz1pdmT+tLApHcG51lnnWUVydFxejfNFJ0yZYo1bvdiZBqc1H5pCCCAAAIIIIBAeREgOFlenhTjRAABBBBAAAEEKoBA8+bNrUIxvpZwDxgwQF555RVrCbRz6bdmHr799tvWXovnn3++S0j3rbzwwgtFswu/+uorOWL2AtamxWNmzZoln3/+uWh/TZs2tY7Xrl1bdC/IL774wgp0OpeE6320grdW1z5ete4qVapYwU0Nrup9jtc0G1MDk3qNe5Vu53V6TMf16quvWuc496HUsU2YMMHaV1Ln6Gy6rF2L5KghDQEEEEAAAQQQKC8C7DlZXp4U40QAAQQQQAABBCqAQOPGjSU6OtrKYtR9Gd2bvteiNRMnTrQqUut5+mfDhg3l7rvvLlZRe+DAgVZmoQYcf/vtNyvzUZeM656Ml1xyiejn7u3KK6+U77//XiZNmmT9Wa1aNdf5F110kTizMf09hpEjR8q3334rTzzxhDWme++919+p1vHu3btb99FAqhbD8W5aCOeuu+6yxv/ee+9ZwUg9phXN1enWW2+1PJxt27Zt1l/btm3r3RXvEUAAAQQQQACBgBWwmd+u2gN2dAwMAQROWkD30pptMj06ZVY76T7Kw4V5kaGyPuyIDBsytDwMlzEigAACCJRA4JtvvpHDhw/LTTfdZJ2tgUrdD1KDfRr00wzCPXv2WAVwdAmzVr4+XtOMQl0SrsE894Cer+s0+JeYmGgFATVAWadOHasSeElaYWGhlTWp55dmYRpdLq7jz8rKsip0x8bGFqvI/f7770toaKhce+21JRkq5yCAAAIIIIAAAgEhULL/ygqIoTIIBBBAAAEEEEAAgYogoMutn3nmGSvIp0ulvZtmDzZr1sz78DHfa5BRXyVpGlQ82cCi7jtZ0vuUZCzOc3RfSWcFcV/X6TJ4LfBzzz33+PqYYwgggAACCCCAQMAKsOdkwD4aBoYAAggggAACCFRMAc1U7Ny5s7VfJK1kAgsWLLCWc9evX79kF3AWAggggAACCCAQIAIEJwPkQTAMBBBAAAEEEEAAgSKB0aNHy/z580WrUtOOLaBLvhctWiTDhw8/9ol8igACCCCAAAIIBKAAe04G4ENhSAiUhgB7TpaGIn0ggAACCJSlwI4dO6wl0rqMe+fOnVZlbS2CQ/MU0H0od+/eLa1atYIGAQQQQAABBBAodwLsOVnuHhkDRqDkAhqgzLYVlPyCcnhmnpmjzpOGAAIIIBB8Ak2aNHFNql27dsE3wVKakQZsCUyWEibdIIAAAggggMAZFyA4ecbJuSECZ07AFmKTXZFZZ+6GZXEnM8cQU5mUhgACCCCAAAIIIIAAAggggAAC5U+AZd3l75kxYgQQQAABBBBAAAEEEEAAAQQQQAABBIJCgII4QfEYmQQCCCCAAAIIIIAAAggggAACCCCAAALlT4DgZPl7ZowYgXIlkJ+fL/qiIYAAAggggAACCCCAAAIIIIAAAt4CBCe9RXiPAAKlKrBz107RFw0BBBBAAAEEEEAAAQQQQAABBBDwFqAgjrcI7xFAoNQENGNy6/btVn+NGzWWsDC+5ZQaLh0hgAACCCCAAAIIIIAAAgggEAQCZE4GwUNkCggEqoBmTObl5VkvsicD9SkxLgQQQAABBBBAAAEEEEAAAQTKToDgZNnZc2cEglrAPWtSJ6oZlOw9GdSPnMkhgAACCCCAAAIIIIAAAgggcMICBCdPmIwLEECgJALOrEnnuZo9uYO9J0tCxzkIIIAAAggggAACCCCAAAIIVBgBgpMV5lEzUQTOnIB31qTzztvJnjxzD4E7IYAAAggggAACCCCAAAIIIFAOBAhOloOHxBARKG8CmiGpmZLeLZfsSW8S3iOAAAIIIIAAAggggAACCCBQoQUITlbox8/kESh9Ac2a1AxJf43sSX8yHEcAAQQQQAABBBBAAAEEEECg4gkQnKx4z5wZI3BaBTRrUjMk/TWyJ/3JcBwBBBBAAAEEEEAAAQQQQACBiidAcLLiPXNmjMBpEzhe1qTzxmRPnrZHQMcIIIAAAggggAACCCCAAAIIlCsBgpPl6nExWAQCW+B4WZPO0ZM9GdjPkdEhgAACCCCAAAIIIIAAAgggcKYECE6eKWnug0CQC5Q0a9LJQPZkkH9BMD0EEEAAAQQQQAABBBBAAAEESiBAcLIESJyCAALHFyhp1qSzJ7Inj2/KGQgggAACCCCAAAIIIIAAAggEuwDByWB/wswPgTMgcKJZk84hkT15Bh4Ot0AAAQQQQAABBBBAAAEEEEAggAXCAnhsDA0BBMqJwL79+yQkNFSizMu9ZWdne7yPiooqNiO9tmGDhsWOcwABBBBAAAEEEEAAAQQQQAABBIJfwJaSkmIP/mkyQwQQKAuBqdOnedz2vJHnlsUwuCcCCCCAAAIIIIAAAggggAACCASoAMu6A/TBMCwEEEAAAQQQQAABBBBAAAEEEEAAAQSCXYDgZLA/YeaHAAIIIIAAAggggAACCCCAAAIIIIBAgAoQnAzQB8OwEEAAAQQQQAABBBBAAAEEEEAAAQQQCHYBgpPB/oSZHwIIIIAAAggggAACCCCAAAIIIIAAAgEqQHAyQB8Mw0IAAQQQQAABBBBAAAEEEEAAAQQQQCDYBQhOBvsTZn4IIIAAAggggAACCCCAAAIIIIAAAggEqADByQB9MAwLAQQQQAABBBBAAAEEEEAAAQQQQACBYBcgOBnsT5j5IYAAAggggAACCCCAAAIIIIAAAgggEKACBCcD9MEwLAQQQAABBBBAAAEEEEAAAQQQQAABBIJdgOBksD9h5ocAAggggAACCCCAAAIIIIAAAggggECAChCcDNAHw7AQQAABBBBAAAEEEEAAAQQQQAABBBAIdgGCk8H+hJkfAggggAACCCCAAAIIIIAAAggggAACASpAcDJAHwzDQgABBBBAAAEEEEAAAQQQQAABBBBAINgFCE4G+xNmfggggAACCCCAAAIIIIAAAggggAACCASoAMHJAH0wDAsBBBBAAAEEEEAAAQQQQAABBBBAAIFgFyA4GexPmPkhgAACCCCAAAIIIIAAAggggAACCCAQoAIEJwP0wTAsBBBAAAEEEEAAAQQQQAABBBBAAAEEgl2A4GSwP2HmhwACCCCAAAIIIIAAAggggAACCCCAQIAKEJwM0AfDsBBAAAEEEEAAAQQQQAABBBBAAAEEEAh2AYKTwf6EmR8CCCCAAAIIIIAAAggggAACCCCAAAIBKkBwMkAfDMNCAAEEEEAAAQQQQAABBBBAAAEEEEAg2AUITgb7E2Z+CCCAAAIIIIAAAggggAACCCCAAAIIBKgAwckAfTAMCwEEEEAAAQQQQAABBBBAAAEEEEAAgWAXIDgZ7E+Y+SGAAAIIIIAAAggggAACCCCAAAIIIBCgAgQnA/TBMCwEEEAAAQQQQAABBBBAAAEEEEAAAQSCXYDgZLA/YeaHAAIIIIAAAggggAACCCCAAAIIIIBAgAoQnAzQB8OwEEAAAQQQQAABBBBAAAEEEEAAAQQQCHYBgpPB/oSZHwIIIIAAAggggAACCCCAAAIIIIAAAgEqQHAyQB8Mw0IAAQQQQAABBBBAAAEEEEAAAQQQQCDYBQhOBvsTZn4IIIAAAggggAACCCCAAAIIIIAAAggEqADByQB9MAwLAQQQQAABBBBAAAEEEEAAAQQQQACBYBcgOBnsT5j5IYAAAggggAACCCCAAAIIIIAAAgggEKACBCcD9MEwLAQQQAABBBBAAAEEEEAAAQQQQAABBIJdwJaSkmIP9kkyPwQQQAABBBBAAAEEEEAAAQQQQAABBBAIPAEyJwPvmTAiBBBAAAEEEEAAAQQQQAABBBBAAAEEKoQAwckK8ZiZJAIIIIAAAggggAACCCCAAAIIIIAAAoEnQHAy8J4JI0IAAQQQQAABBBBAAAEEEEAAAQQQQKBCCIRViFkyyYAQyE9PlLzDmyQ/abcUpO2TwswjYs9KkYKcDJG8bLHn5Yo9P1+ksFCkwLzsZjtU3RFV/9Tm/DMgZsMgEKhAAjabY7L6p/5V/ww1v9sKCRFbWJjYwiNEwqMkNLKy2KKrSUilGhJapa6ExTaU8FqtJaxyrQqExVQRQAABBBBAAAEEEEAAAQRORIDg5IlocW6JBQoL8iRnz1LJ2blE8g9tkYLD+0wgMqfE13MiAggEkICvXxDkF1gDtEuOeZlfMJhmfqXgs9miIyW0pglW1mohkY17S2SDXhISGu7zXA4igAACCCCAAAIIIIAAAghULAGqdVes531aZ2s3GY/ZO+dL5rrJkrdzg8jR4IXzprawUAmrUUXCqsVKWIx5Va4modFVJCSqsoREVDKvKAkx2VeaiRUSYgIXIaFiM5lZ5v8ziVpWupYjY+u0zoLOEUDAQ8AKTNpN4rJmMhea/6evfMfLZDoXmqznwlx9ZUphdoYUZKVJfkaK5KcnSX6KeR1JMxnRjkCmq1/zvSC8cRup1G60RDUe4Ph3DjsCCCCAAAIIIIAAAggggECFFCA4WSEfe+lOujA3Q9JXfylZf0wVe0aWq/Ow6pUlqmEziarTVCLjm0hEtdoEF0uXnt4QCHwBE9TMTTkgOQe3S/b+HZK9e5vkJzsyLXXwtsrREtVplFTpNE5CImMCfz6MEAEEEEAAAQQQQAABBBBAoFQFCE6WKmfF6qwwP0fSVkyQrJVTRHLyrMmHVomSyq07SpU2/RzByIpFwmwRQKAEArkpByVtwwLJ2Pin2X8223FFZJhEdx0tVbpeZWVQ0xBAAAEEEEAAAQQQQAABBCqGAMHJivGcS32WmVtnS9rcN8Wenmn1HR5fXap1GypVmnUnO7LUtekQgSAVMFmVaduWS8qKXyXvYJI1Sc2krDL4VqnUfGiQTpppIYAAAggggAACCCCAAAIIuAsQnOTr4YQECnPSJGnm45K3da11XVhsZYntO0pimnY9oX44GQEEEHAXSN+xSpIWTpX8JMeS7/Dm7SV22ENmT9qqQCGAAAIIIIAAAggggAACCASxAMHJIH64pT217IRVkjLtCWtfSVtYiFTt0U9iu44wxSxCS/tW9IcAAhVQwF5YIEkrf5bUZQtNEZ1CK4uy2rkPSVS9LhVQgykjgAACCCCAAAIIIIAAAhVDgOBkxXjOpzzL9DXfSfrcD0QKCiW8VlWJP+caiYite8r90gECCCDgLZCbvF8O/vyR5B1KNRvZhkjMoOslpsPF3qfxHgEEEEAAAQQQQAABBBBAIAgECE4GwUM83VNIXfK2ZC6ZZN2mctvWEjf4SrIlTzc6/SNQwQXsBfmSOPczyVi/0ZKo1PsCqdr7HxVchekjgAACCCCAAAIIIIAAAsEnQHAy+J5pqc4oed6Lkr1qplXkJrb/YKneeXip9k9nCCCAwLEEklfPkKQFc0RM8ZyoLmdL9bPuOtbpfIYAAggggAACCCCAAAIIIFDOBELK2XgZ7hkU0IxJKzAZYpOaQ0cRmDyD9twKAQQcAvoLEf3+o9+H9PuRfl+iIYAAAggggAACCCCAAAIIBI8AwcngeZalOhPdY9Jaym0yJmsOGSVV2/Qv1f7pDAEEECipgH7/0e9D+v1Ivy/p9ycaAggggAACCCCAAAIIIIBAcAiEBcc0mEVpCmTvXekofmM61aXcFSEwmW8qA+fk5kl0VISEmAytQGi5ufmm/pDdjCm8VIeTlZ1naozYJCKidP/563jz8gv8jrVSdISJLQWGrd9BltEHjmddaH390XwL6PehguwMSTZLvLU4V1iNZlTx9k3FUQQQQAABBBBAAAEEEECgXAmw52S5elynf7CF2amS+Nl1Ys/IsorfxA+95vTfNADu8NuijfLxl/PlyfvHSp34agEwIpFvJv0ui5dvkecfu+ykxpOekaOJZlK5UqTH9fc8MlF6dWsul1zY66T69XfRVz8skV/mrPH3sYSHh0pczSpyVt825tW61IOjfm9cDj745KsFsnnbfnn8vjHlYLRlO8SDsz+2iuTYKkdL3JUfSUhklbIdEHdHAAEEEEAAAQQQQAABBBA4JYHSTZ06paFwcSAIJM183ApMhteqalXlppVfgbc/nCWRJuvy9r+fuSJGGgy9+9bziqHZTTGT5JQMWbNhj3zx/WJZtynBjOtsMimLSXHgeAJxg66Q3MTnJe9Qquj3q5rnPXe8S/gcAQQQQAABBBBAAAEEEEAggAUITgbwwznTQ8vcOlvytq0TW1iIxI+4VmwhoWd6CNzPTWDowLbSq3uzUje5/cZzJKayZzZlad6kdYs6frvr06OFNKpfS776cYn8vnKblcFJEzn37E4yJLstFCUQsIWGSfw510jCV29I3ta1krn1V6nUfEgJruQUBBBAAAEEEEAAAQQQQACBQBSgIE4gPpUyGFNhXrakzXnDunPVHv0korr/AFMZDK9C3rJGbIwJ5NUs9blrnzWqx5R6vyXtcNhZ7STMBMC3bj9Y0kuC/rxaNapIg3o1gn6epTXBiNi61vcpbWlz35DC/JzS6pp+EEAAAQQQQAABBBBAAAEEzrAAmZNnGDxQb5e2coK1nDsstrLEdh0RqMMMuHEdSEyR2fPWyfZdiXIkKUMa1K8hrZrVkeGDO1h7LHq3vLwCmT77D9m09YDs3XdEqlaJln49W8rZg9rL3IUbJNsUq9EsOm3LV2+3Anh//UtvVze6j+Ts39bKqjW7zP3STQZklDRpVEtGj+gqteMce2X+NGO1HDiUIvsOJpvCNyHy4cR51vVXju1vjUn3hmzWJE56dPHMytxi7rVgySYzl4Oi94mrWdWMrYX0792qVIsEhYaGSBUz7oLCQm8eWbxsi6xeu1u27zwolcxemS2b1pYBfVpLQ+Pq3XJMAZ6fZqwyRomScCBJqlerZO1lOahfG/nl1zXWXIcObGddNn/xJlPwKF80MHroSJoxXGf8k+X6ywdKtaqVpNAUHpqzYL2s37RPdpj5a2C4hbn34AFtLAf3pv3MXbBBlq3aZvpKl0hTWKhBvZoyangnadoozuPc1LQsmTl3rfyxbpdZ1p4pVWKipLnp97zhnT36XfT7FtlvntdF5/Uodv3Ps/80YzpkPdM68dWluXl2I4Z2Ei0w5N5038ouHRuZz2vLnPnrZc36PXLwcKrEm/F37tDI+poMlGJPHgM/yTf6fSpjw0rJT86QtBUTpFqvG06yJy5DAAEEEEAAAQQQQAABBBAoSwGCk2WpHyD3LsxJl6yVU6zRxPY7j+XcJXwuK/7YIR9+Pk/q1q4u3Ts3lbhaVWTbjkSZOW+tLDOBxVv/drbUNEEuZzuSnC6vvTtD0tKypV+vljLEBL72HUiW+Us2yjYTjCsosEtmZo4rOLl95yFZapY+O4OTaenZ8uxrU6x9GjXoVrNGjAlQZpqg5np54vkf5YG7LrDGEhYWKmGhoWLT/zN7QOrf3Zsup9Y+3IOTGsz7ZvJS6dC2oQnutZUIE9hbtnqHfPrNAllpAqG3mbmUVmBLA3ZJJlDXsV1D17A0OPjZNwvlt8UbreDimNE9JSMz1wRod8h/X50it5j7t2tVz3W+BoVff2+GaLC3rwnuDj2rrexJOGKCkn/Krj2H5WBiqkSZ4J0zOLnJFJvJMLZdOzWSJ1740Qra1jWBvhDzpwYb3/1kjqwz+2EOGdBO+vRobgUSFy3bbF5b5M5/jHQFR/V+r7z9sySaoN/wwR2lbp1qkp6eY4K6m+WplybJ+FtGSZuWda1xah869sjIcNNvexPwrCSHTTDz1/nrrDE8NP5CV4Byy/YDVkEc9+Dk5m0H5O2PZllL8Ht2bSbDBrWT3XuPWAHcpSu2yS3Xn+0RtF34+2Zzj8rGYK0JXIaboG4rc+8wE3BNkK8nLbUC6P+4dqjH10J5fqPbTsT2GyWJP31tff+q0uVyCYmoXJ6nxNgRQAABBBBAAAEEEEAAgQopQHCyQj52z0mn/fGlSE6+hMfHSkyTLoiUQOCwyVrUgJYGja69dKArcNetUxMZYvaKfOGNn+SDT+fJPbePcvX2+beLJScnT+6/a7THsmoNiL341jQ5YAJqjUwGnr+mASkNbj3/+OUeWXN9TTDtyRd/lG+nLLOCiOcM6WB1ceBgilUQ56q/9vfXpXV8/eZ91h6QF5usvVEmo8/ZNGNy4dLN8oEJwDqDhsfsqAQf5ppA4EdfzJdoM662LYuCjZo1Om/RBvmXCQS2b13f1dOgfq3l8+8Wy+vv/iLPmarlzsrjE75YYAUW77/zPCv7VJvaD+7fVp439hr8bN3CESR0dpafXyj/+3iOjBzSyWQednQ9s69/XCobTADvvn+N9lhGr/d+x5z/mrn3Mw+Ps85ft2mvaKDTu6q7BjRffOtnmfjdInns3xdbt1ywdJNkZOXIo+a9Zlc6W+/uzeXx536QH35aITdcNdh13P0v2ebr5M0PZprgY00ryO28XueoWbYvv/OzvPXhTHni/8aKZqI62wyTpXmuyarU+TmbBs41O/THaStMtmiS1K8b6/Oe5fFgTNOukhxvgtQm6zR99ZdStef15XEajBkBBBBAAAEEEEAAAQQQqNAC7DlZoR+/iN0src3+4ydLoVo3ikqU9MtBAz1RJiPuyrH9imUUarbkZWP6ysat+8xy3t1Wl5q1turPnVZmnPd+j7o8968X9pasrFzRqtb+mi771WXc3st5I0zgS4NyGnw7mfatyZhs2jjOIzDp7EcL2NSrU11W/LGzxF1rFqb3S5cmf/btInngP1/Lvv9n7z7g46qu/IGfaZpR78W2LMm9gSvYYDqm10BCWEoICwtJNrvLBtj8U5ZN/ptssmT/STaEbLKBJISWUEMwvdiAMWAwtnHvkmz1rpE0vfzPuU9vNBqNqkfSzOh389Ha8+a9++79PvH2w+HcexraVRBSxi1NsiYl4/EsXr4dHpiU7yTD8zrOopQl3rI0W9qeA7XK9rqrV4cCk+oLbhKovPaKU6Ja7j1QQ/NmF6vMVD0L1MHmEhSVY5H7e0oG6k1fOJ2XuLt4/lWq/8YmuwoG5uX0z9CTcUomrMxJsivVuRxszuGgYHhgUo6n2lJUdqh+njo5oomH0+XhZednD7heArR/e8PZ1NTSxWM/0O/KTM6ylOXbkU1spR2vbY38KuE/Z6/UskGdO19W7zM0CEAAAhCAAAQgAAEIQAACEEgsAWROJtbzivlonVWb1F6TpkwbZc5eFfP+k7VD2c9P9orUA2yR8zyZl0cX5mfSHj5vKS9fPsxLdGWptGSxRWvz55T0WwIe7RwJrG3kvQRlz8grL1mhglx6k+XL+hLmaNcOdkz2lpT9DG+/6Zyop0gQ79/u/RwHTaN+PeCgnPf2e7sHHOcwI2cz9qggoyyHLi/tyxBt4AzP5tYuunXV3CjXkTJezNmU2zm4KxmBYilByJMWlkY9f+niMr5P//0Y5UQZW3hmqByTpdRO3udTgrDRmuxjOausSN37lOWzeL/IIl5+H+B9PDfRDdee1i84KlmN8qM32S9TMk+f54zWyy9a3i/IeMk6bV/RaPeUY7v492b5SeVqH81oTQLGC+dOV+edd2Zfle/5c6YNCJbL9dKPyWRQS82Trcl7qz3jZfJ3O8lVzVm5s85OtiliPhCAAAQgAAEIQAACEIAABJJaAMHJpH68w0/OuU/bazJ9AS8DlQ0K0YYVkIw22TdxuOWx00pyuShNp+pPAnCyH+BQ+zZKxeahMidXr5xDdQ0dqqDORi7eIoVP5nKwbD4vX5YiPFIBe7RNxiVt+rScQS+VDMKRNvkVuv97fxP1dFnSLRmIskxc9lj8+9vWqfOaWuzqT9k7U5ZCR2vHalp4SbxPfSVjlv02B2tiHL7Xp36eBIvDA7pyvJmzDyUTUjJhB2vtnd2hfzTmVBTRzdetpWd5D0cpWDS7vIifgzyDEt5rcnq/AKTs+ShFiV7nLMi33t1Nc/kZqefFAUQJNIcvx468t+ypefKi6MFX/dxp/Mz2cRZpeJPfocGa7D0arQjRYOcnzHH+pUtfuJTsWz8hx96XEJxMmAeHgUIAAhCAAAQgAAEIQAACENAEEJycwr8JAb+XvNX7lUDmwqH3JZzCTAOmLhW1pdl4xIjyoQAAIABJREFU38Shmo2LkbRwNpc0CZjJHolDNQnsDZeh+LnLVvGegyepJeKy9+HH247QS2/soFzOjLvt5nN5H8f++ywOdT/5zulyq1Nkifp4N8mAlAxFKeoiATsJwEmFcdmHU5o1xTJogHUeB/b06ufKcphAuiyzjmypEdWt5Xu3x6sCj5FLr8OvXcIZmuEZjLKEXuaxc88xOnC4gXZzIR2ZTzovqb6Jl/NLEFmajEGW61/Ce0Bu33WMszTrVSbli69tV1m1t/PzkmBlZJMAtZjYrAOzP8PPtbGnBMrR5P21VgUnvdX7SN5rRtP4/z7DHQIQgAAEIAABCEAAAhCAAARiI4DgZGwcE7IXd83HRD4/mXn/vJTsgUGShJzUBAxaAlWyRFuy7oZqslS5uDBLnSIZbZtbD6r9FQfLnpRgXWG+dv5Q/Ur1ZsnKkx9pUqX6sac3qwIqP/7XL6rqziNtJVyxWppkL0qgMFqTKuFS6bqkKPr30a4Z6tjyk8tVME/2P5R75vdm+8mS7ZHcQ7IipQL1YE2Ce2KfG7EvZLTzpS/Zq/O6q1YPukQ/2nUSzJUgpB6IbGnr4mI4H9HvnniP9+jMpdLpeaHLZAm6FNeRH2nVXE38j3/eRA/+7k1+XtcNyOaUoGZRQZaqCD5UkzkWFcTmmQx1n0T4LiW7WL3HfB09JO+11HL8x5ZEeG4YIwQgAAEIQAACEIAABCAAAREYOpULRkkt4K7eouZnmzk7qecZ68lJ8EiCTzt2Hxu0a6nmfYyDUGUzCtQ5c3kZr4cLpWzdcTTqNXs52CYVpodqP//N6/ThJ4cHnCJjue2ms1URmINcKGY0TYJzklG4gzP7BmtSgfoPvBQ7Vm1asRYQ7erWsjYlICkB2/2HBg84PsLBvIcff1cNYd6cYrWsftc+rdhQ5Lhk6bhYjKRN761cLQV2ojUJJktl7Gdf/ER9LUvSX31r54BTJfj8lVvOU1mYew/UqSD0/3vwVbX0O7LJfpu33nAWdXPQt5L3+4zWSrlq+y4upiT7W0Zrbl4iv4+9ymb0BUGjnTeVjunvMf29NpXmjrlCAAIQgAAEIAABCEAAAhBIZAEEJxP56Z3g2H0tWqDLVhK9SMsJdp/Ul0uBEymmsmN3ddR5vvDKp6qq9tm92XKyL+FC3hvyufWfqOXM4U2KlDz1l48GVICO7FgCVVKdOdq+lK7e/RizuTq03gy8jHyoitByngQFL+Vlx7LXY31jR+QtSTICd+45TsuWlA34bqwH0rlYjQTxehwu1YVkekoGolT0dvUu8Q7ve9+helWpWy+iI8WGyjjAJ4WB2jgIHN4k21DsByskEzlmqdAtS8ZffuOzqIFACQZL8aPZFYXqUjPvTynVvaO5SvBZnlEWF5cSV7fXy+dG30PT6dSWsmdl2CKHpD5fdsEykgD3O5u1bRciT3r1rc9I9vC8iLNN0TQB/T2mv9fgAgEIQAACEIAABCAAAQhAAAKJIYDgZGI8p3EZpb9VyxazFlWMS/+J2KksF5bMu6F+JGtNgnWrllXQbx7ZwIVc9qtlz9JkefTDj7/De0Eepb+55rR+ezl+mbPlbFxh+0f/vZ4ef2YzX3eA/sxByR/+7K901mkLqKKsUO1TOFi79IKlXEimgR567B2STEs9q67yWDP9ju8pFZxncR96y86ycfZmCx2palJVmqMFNeXcC85ZopYi/+cDL6mq1BL0kib9PvDbN1QhHzknVk3mmM5Vu1vbekJdXsHBXicHJn/yy5fVsmfJPJR2uLKJHntqkwpGnrN2Yej8v+P9GuWcH/7sRfrTcx8qS/nzRz9fr/Z4LOHl4kNZhs/lmstXKacHHnqTCw61q6/E6jPeU/LZ9R/TSVyYZgUvRZcmFdE77Q765cNvqsxZ3UoCu7/+/duUmcFVxDl4Ku1Srsi9h/ejlGxL2ZtSn9Mhrjb+xz+/p+YUvvxbXdTbZnJG5EVc1VyyVl96Y7vKFJUmwdhn/vqx2mf06ktWRi38E9bNlPqr/h7T32tTavKYLAQgAAEIQAACEIAABCAAgQQWwJ6TCfzwTmTovu5mCjrdZOBKzLJfG5om8MSzHwxL8cPvfEHtjfjVW89XS3yf5WxICTamccCtp0fbm/Her1+mKjKHNymC8t1vXEUb39+nAn8b39/DwUSp/nwGLT+pjINhx8k6RJGdJQtm0B1fOldlX0rwM1XO5UCfFE9ZysHSW754Rr/9LNedvYSXStfTjzkYKu3B+2+JWvhGCtV8+64rVaD0oUc3ckXnIFm5mI/D4VH93nzd6aPaj3FYQD6hdFo+L3+uVQFWqVotnvfdczX99o8b6Yc/fUGNU4oDSSalBIEl0Cvj1JsEYv+Vz9+waS9VH28lWZYt1ctvv/kcOokL2Eg185wR7Dkp/c2fU0Lf+ucrVYD33/7zeVXYRoKOMjYJGn/+ylNDgU4JJv7DHRepTNcHOUApe4+m8FhlifYCrsL9zX+8PLTn58qlFXTbjWfTX17eqgrh6AV5pG953rdcf+aQVNddvVoFnOX364VXtlEGZ1nKfaT4kVQ6l/7R+gTkPSbvM3mvyfvNnNEXqIcTBCAAAQhAAAIQgAAEIAABCMSvgKGzs1NLUYrfMWJk4yDgrN5MnX/9D7JwQZTS6745DneYOl1Klp1kTLa29/AegPmjKkgTrvSvP3qWFs2fTjd9Ye2QeJKBJ0vDZcm1VLiWPRwzB1keLB11c8A0EJDlxqlD9itfSt+19e3U1eOi6dzvSJdHD9vxKE6QgKQEHCVoWVSQOaJxR3Z/931P0plr5tO1V5wS+dWQnyUDVjI3JTgqxYwkwzNa04vuSFEaEy+fl3Hm8f6d0ZqPi041cfGk1vYuDihbVSB2NEWLpE9Z4t3Q1EkzOMN1Mp5JtHnF47GaZ35C3qYOyr76uyiKE48PCGOCAAQgAAEIQAACEIAABCAQRQCZk1FQpsIhX7tWTMScnTsVpjuuc5Tlw1J1erBq13JzCRB+/yfP0xc5G06v8Bw+KKm4LcGnS9ctG3assp+hBCT1wjLDXTCaQJj0LUuKJ7NJYHDB3JJBhyD7Sv7nL16iL//NWbR0sbaEOvzkg0ca1DLoijKtGNGgHUX5QoKRizlAPFzTK2pLVe3hmpmz+SQDUn7G2qRwkfygDS0g7zMJTqr3m7YSf+gL8C0EIAABCEAAAhCAAAQgAAEITLoA9pyc9EcwOQPwd2n7TZozEJyciCcgAcLigmxe4vupyrIMb7If5KNPva+CT2tWzZ6I4ST0PQrzs1Sm6LMvfjygII5kkz7Je0/OmJYT2icyoSeLwY9KQH+f6e+3UV2MkyEAAQhAAAIQgAAEIAABCEBgUgSQOTkp7JN/04CjTQ3CnJ49+YOZIiP46t+eT7/47et034+f430Op/Ey4DRVFKb6eDNlZ6XS399+AUmWHdrwAv/E+z7+gov1fOc/nuEsy+nKr7W1m6rYspCzGb/y5XUjLogz/N1wRqII6O8z/f2WKOPGOCEAAQhAAAIQgAAEIAABCExlAew5OUWffusL/0TeY4ep4MKrKHP+aVNUYXKmLUVqDh1tUFWfc7loiyzPliIu4QVfJmdkiXVX2fdxDxfVOcrVyGUZd35uJk3jpdMnLZyBIG9iPcqYjbbr4EfU8uaLZCmbS/mfeyBm/aIjCEAAAhCAAAQgAAEIQAACEBg/AWROjp9tXPfsd/eo8Rlt6XE9zmQc3MJ500h+0E5MQPZ9lKCu/KBBQAT095n+foMKBCAAAQhAAAIQgAAEIAABCMS/AIKT8f+MxmeEXpfq15iSNj79o1cIjFDA3mEnr7OTaqsqydlaTyaXnXItPjIHvcTJkfxLaqKugIUcxjRKyS2h0llzyJqZT1k5wxejGeEQcFqSCITeZ73vtySZFqYBAQhAAAIQgAAEIAABCEAgqQUQnEzqxzv45IJej/rSmGIb/CR8A4FxEuiyd1HT0f1k6q4jZ2czpbgclG0hyuZsSIMlSIEAcWBSIpPcAn7KNvopi1wU7Gijrk/2UIs1nVpzSshYMIdK5y4gkwm1vcbpUSVUt/r7TH+/JdTgMVgIQAACEIAABCAAAQhAAAJTVADBySn64MnvUzM3WhCcnKq/ApMx77b649RStZdMLVVEbidZU81k5Rikl+sA+X1BFZDk+KRqvX9IlJL8/r7RmviLnCBn/rZXkaupko7WfEYZs1ZSyax5KIIzGQ81ju6pv8+CPu39FkdDw1AgAAEIQAACEIAABCAAAQhAYBCBcQlOejwe8nq9/W5pNnMQwmqNOowAp0k5nc5+3xmNRkpNTY16fqwOut1u8vX+S+xQ4xvJ/WT8Mg9pKSkpZLFwGtg4N/1+YjXaFvRrYzWYx3+cox0bzk8+gabaGuo4tJVM9lpKMwQ4GZIDkRxldLv7oo4SjNQDk5ECoUAlfyEJlW6Pdp0kTJp7msm163WqrDtAeYvPpJy83MjL8XmKCBj4/8+o1vsuniLTxjQhAAEIQAACEIAABCAAAQgktMC4BCc3bdpEL7zwQj+YhQsX0te//vWoWHv27KHf/va3/b4rKCig733ve1HPj9XBDRs20CuvvKK6W7x4MX3ta18bc9c/+tGPqKOjQ11/++230/Lly0fUlwQYH3zwQRXYvPHGG6moqIheffVVOnDgAJ1yyil05pln9uvH5XKpMR8+fJgaGhrUd4WFhbRmzRo666yzRh4U7Q1OGo3j8iswornjpOQX6GzvoJaDW4nq91OmmTMgObLo5QzJ8GDjiSio5d/8f8wc6DR3VFHLllYKrryQcotnnEi3uDZBBQz6+6z3/Zag08CwIQABCEAAAhCAAAQgAAEITCmBCYtMHTx4kLq7uykjI2MA8I4dOwYcmyoHJKB56NAhNd30dK1y9r59+6iyspJWrlzZj6G+vp4eeugham5u7ne8rq6O/vKXv9CHH35Id99998gyTvX9/LjYCBoExkOg9tBuch3aQla/g3zBAGc7aneJVWBSH7P05+dMTB//2Ex26ti6ntyLzqWS2Qt7l4nH+o7joYU+YyEQCk7q77dYdIo+IAABCEAAAhCAAAQgAAEIQGBcBUa/HniMw5HMwM8++2zA1bKsevfu3QOOT5UDeqBRApN6cLK1tVVNX7JHw9sTTzwRCkyaTCaqqKigtLS+atuSSfnkk0+OjK631ohhDEvCR3YDnDVVBbq7e+joh6+Rd+9GSuXApN8n6Y3jryEhSAlQWv1e8vC9G6sPqz0oQ4V1xn8IuMMkC4TeZxPw+zbJU8XtIQABCEAAAhCAAAQgAAEIJI3AhGVOitinn35KZ5xxRj88WZ7scDiSBnS0E9GDk/n5+epS2QfTbrerv4cHJ3fu3EnV1dXquOxpedddd1FZWRnJ/p7r16+nd955R30nAWDZ/3LY/Tr1zCLDhMWn1fjQklNAK2RjIIe9k+o+foXSnS3k5aW1vVtDTuikPRygNAW9ZN+1kazp2ZRTUDih98fNJlFAf58hc3ISHwJuDQEIQAACEIAABCAAAQhAYHQC4x6clAw/f2+pXQlEdnZ2UnZ2dmiU4Uu6pYhMZCGdyOlI8E2ukaXMEtSU/RZnzpxJ559/fr9+w687evSoWvJcVVWl9nacNWsWXXTRRZFdD/jc0tJC7777Lh0/zhWG+e8lJSXq2rVr11Ju7okV3ZCxdHV1qb0lpYnTrl27QvtWyjGZowQrZX6yLF5vp556qgpMSpNApcxdxikBIvmR8c6fPz90/lB/kcwyNAiciIAemGyuOUZdu9+mDG83ebxawaUT6XfM1/I/Az6ul5NmcFHjzg1kW/s5LsaVgkreYwZNnAvxPkucZ4WRQgACEIAABCAAAQhAAAIQ0AXGPTiZk5OjirTIkmMJYkhw8eyzz1b3l88SkNPbySefTNu2bYv6dCQbUJYsR+5Pqe/ZKMHH66+/nlatWtXv+g8++ICefvrpUIBUvmxqalJLySXQOFiT65577jmVmag3CaxKMFG+u/POO6m8vHywy4c9LkVtZG9Jvckek5FFgX73u9+p+dx6663U1tYWOnfOnDn9+s/MzFTG+lhHVCkcmZPDPiOcMLyAHphsrDpMrr0byOpzk0eWcU9yk5C7l8dhszdSw8HPqGLpauw/OcnPZGJu3/sfW5A5OTHcuAsEIAABCEAAAhCAAAQgAIEYCEzIml6pOq03WdqtN8loDF/CXFpaOuiUXnzxxVBgUoJvUixm3bp1pF8jwcvHHntMZRvqTQKif/7zn0OBSVkmfe6559Jpp52mAhWD7XUpGZ5/+tOfVLBPMhrlXpKdqC+zljE/8MADobEPOughvpBxS3ajHkicNm2a+qxnZErAUT5Pnz5d9SL3v+OOO9TPggUL+vUsAV49MCmZQ/o1Q9weX0HghAX0wGRDdSU597xNKQG3CgjGUzNyrMpzfBfZO+3InIynBzNeY0Em+HjJol8IQAACEIAABCAAAQhAAALjJjDumZMycsn+e+mll9QkJCDZ3t6ugnDhWZByzmBL8mSZ8ubNm9X1cs7XvvY1mjdvnvosy7T/8Ic/qL5k+fgzzzyj9mOU9vrrr4eKYUgwUI7bbDb1nQQpf/rTnw5YRi79SUBTb7fffjtJRqe0a665RmU36sFAWUp95ZVXhs4dzV+uuuoqdfo999yj/vziF79Ic+fOJSl689FHH9GyZctUJqje5LtoTQ+k6t+dc845vITVGu1UHINATAXkn0V7Wws5dr/FRWjc5PIFKd42CZAq3qkGB7VV76OspWuQPRnT3wB0BgEIQAACEIAABCAAAQhAAAIQOHGBCcmclIzD8CXQ27dvVyMPr94duRw7fGqylFqytKRJNqEemJTPRq42fdlll4VOP3LkSCiLMHyfxgsvvDAUmJSTZ8yYQcuXLw9dp/9FCtQ0NjaqjzLu2bNnU09PT+hnzZo1oWskiHgiTZak6xmPRUVFqivZ21JaZKXuyPtIlfNXX32VfvnLX6oCONJkmfoVV1wReSo+Q2BcBOT3rn4HL+X2u7j4zbjc4oQ7Vf/Bg98drroD5HH3bdFwwh2jAwhAAAIQgAAEIAABCEAAAhCAAARiIjAhmZMyUlnarVebln0lJRNQMiilyZJm+dmzZ0/USdXX14eOS3GYyCbX6sV0JIgpe0pKcE9fMi7nR7tOApSffPJJv+7Cl4VLoPBb3/pW5O1Cn6V/CRKazaNjrKmpUUvKJTgpTQIoso+lNH2uYvXGG29ELdwj83vkkUdU4Ru9SdBUsi+lQA4aBMZTQF/OXb/7Y0rvaVJ7TErGZLxlTYqBjNUfMFCK205NdbVUygF8ffzjaYS+J0kAe01OEjxuCwEIQAACEIAABCAAAQhAYOwCo4uqjf0+tGLFCnr++edVYEACbxs3bgz1Fr4nZbRbuFyu0OHBgm8SINQrfUtGlwQNw1u0AGK0wjGSJak3CRpGuy68Xzk/vPp4tPFHHjt27Bi9/PLLocNiEv5ZvpDsUglgRlYVl2zTRx99NJRxmZWVpZZ/L126NPI2Q3/uzSijIO8RaJiQBNqhx4NvE0JAD+w11hynQP1u3kpBC0zG8+BlzGYKkK+tWtKLB90+Ip7ngLGNVEDLsOeHPNILcB4EIAABCEAAAhCAAAQgAAEITLLAhAUnJYAny7H1pdZbt24NTV0KzgzViouLQ1+3trYOOFWCkfrSZvlSMikzMjIoNTU1dFyWa+vFZvQOwitg68fkWr0VFhbSfffdN+B+J3pACtZIgRuxkCxKmd+SJUtUpqe4SFD0vPPOU0vWw9uWLVvUnpQSbJG2aNEiuvnmm0kClGNtWrBprFfjuqkmIL+bXq+POg9x1qQhQN4EyFSTMJWZK+O4u1pUMNXIfx9sf9up9jyTbb76uzHZ5oX5QAACEIAABCAAAQhAAAIQSGaBCU2Zi7avpOxFOdz+iuFVvKUYTXgmpTyc8KXZEgSVwKS08Ovef//9fs9RsixleXlkk+CkVOiWJgFN+QlvEkCUSt5PPvmkKrgzllZRUaGK6+j7TJ500knqs2SXSpM5yOerr7461L0sMX/qqadCgUkp0vPVr3517IFJPbNIMifRIDACAT3w01p3jIyddXFXmXuwKcivupeDks4eO/8HgC4EJgeDSobj+vsMmZPJ8DQxBwhAAAIQgAAEIAABCEBgighMWOakeEoBGqmmHb7kOlrAMtJerpP9IWtra8nhcNCvfvUrVQQnJyeHpFjOX//619All19+eejv69ato0OHDqnPskz66aefptNPP10FN996663Qnpfh90tLS1NZi/K9BGP+53/+R12zePFitR/khg0bVLajtOuuuy780lH/XQ986sHZoYrhrF+/vl9l8a6uLlUMJ1qTit3Riv30O7d31WOQq5MbtFhstK5wDAIDBOyVOymd/7OG12+gIP8v3hfQ6smdRo+TjH7vgPngQPIIyPtMtXj/pUwecswEAhCAAAQgAAEIQAACEIDACQtMaHBSAn8S5Nu5c6cauCyt1LMFh5qJLG++6aabQpWpq6qqVNAwssm+ixJI1JsslZZj+v02bdpE8qM3CQrqAcHwvi655BLau3cvSXEc+V4Cg/IT3mSJ+mmnnRY5hFF91u8dWalblpNHNqlCHt7EYLA2bGBSLtQziwJxWmZ5sMnh+KQJyD+vLVzJ3thVTz7OROS4ZOLEgHisFvKTkVCxe9J+gSbgxsFA717DyJycAG3cAgIQgAAEIAABCEAAAhCAQGwEJnRZtww5PFNyzpw5KvtxJE2qbX/nO9+hZcuWDShSI8ugb7jhBrrjjjsGdHX77bfTBRdcoPaf1Jss25Y9H6+44ooB58sBq9VK9957rypGY7PZ+p0jnyWz8itf+coJVcbu7u4O7Yc5XOakFN3p7OyMOtYxHzRpjz6g/8v8mDvChVNBQF/S7WyqJGvQy1nFiTdrI0dTvR5kTibekxv5iEPByd7328ivxJkQgAAEIAABCEAAAhCAAAQgMFkCBg56JVyYQZaFy5JoCfCVlJRQZmbmsH4SXGloaCC3201SkGawqt/ROpLCOXI/2ctSAokSvEz01vjwNRR0uKn0lnvIkpmf6NOZ0uPXihpp61hb2uzU3G0glzGD3L4g759qpBTyUprBQUVZZsrOSh+TldzDx4VwDr7zHGW7mriwDCdOjmuEMvy1pK/R1Y+Nbc2uZH5mnHol5ZfOGpMBLop/AW9XK9U8+lOiVCuV3PGX+B8wRggBCEAAAhCAAAQgAAEIQAACNKHLumPlbTabVUXu0TQJTIz2Gr3/vLw8kp+kaiZ59G4KeF1JNa2pOJlAIEi7q+y05biZ6nqyye4Ikt9gI3MKZwtzANHj7CKr2UJZaUYqSe+mpcVuWlKWRplpIwuy68HPbnsHpTpbyc/3i1lcUpbfhnemPvM+qBbOWOYtBwyc5RzwuNVjNfDvrMFkoYDb0buefOSJ39JtQO6D5b5J/Y+I/j4z8P+PQIMABCAAAQhAAAIQgAAEIACBxBDAv8ElxnOK+SgNlhRe5NrDgR8EJ2OOO4EdNrQ76YVPvbS/o5BMljTySuCOZD/IAHldPWokBqOJ3H4jtXQbqcM7jfa1+in3QAOdO99Ha2ancCawZUQjbq49xvs2+jjIp50+tvzFsFsF/Rwc96kApAQdg1ysJigpmRxATJ+2kHzODsqoOJ06dr5Ifv49TckoJktWMbnbasjIv78+e4tMbkRjl2imn4OTo8mYHmHHOC2OBPT3mbzf0CAAAQhAAAIQgAAEIAABCEAgMQQQnEyM5xT7UUpmGreAR4JZaIkocKjOSY9ttVJ3oIQDhi4to1CVqJHy6/13azBwUSk55HM71VTbDSX03B4vfXishy6b30Unzxp8awTJOpZmdjRTCgcDPRL8HGEzGg1kMRu4gA5nc/JPqHHw1FpQQellq8ndepi6q7ZReulJZCtZQj1VW8jX00pBn5eMKbIMPUhpZcvI19WojmcvXEemlAxq+fjxEY5CO81vNFPQiKDVqNAS7OTQ+6z3/ZZgw8dwIQABCEAAAhCAAAQgAAEITEmBkaYdTUmcZJ60yartPRjoza5L5rkm49yqm130hy1WsnszyOfhgGNoabQEAPsHJtX81fd9x/1eDjFylmKjM5f+sDWHXvzUPiiTLOv2coZj0NGhzpFQ5XBZkxazkaw2EzV2uOixDVV0uL6b978Mu4oDntknXUWu5gNksGZxoLKMA5BryFm/m9IrTqO0mavIkl2ssimzFl9MlrRcMtkyKXX6cvI52jjIah/xnpdqpTj/z2+xct6nacTXDQqCL+JWQH+f6e+3uB0oBgYBCEAAAhCAAAQgAAEIQAACIQFkTk7RXwZDaraauZ/3I0RLHAEJFDpcHvrzViInZXGA0TPmwRs4C9LHy6UNnE349tEi6vR00nUrDFyhfmB2YWeHnTwcyDb5eT9ICfZFiX/qA5FMyW1H2+mFD2vo3V111NTmpBvXzaXv3XgyZ0/ysm1p3IGzdgelzVhJzsZ9ZM4oIGfDHuqp3k6O2r2UvfgiXpnup5SsaWRKXUzNHz2kPhNXl/d1NXCWKC9Z5+zLkS7rtnBg1GJLp3QuaoWWvAL6+0x/vyXvTDEzCEAAAhCAAAQgAAEIQAACySOAzMnkeZajmokxTSvw4+vpHNV1OHlyBWSJ9Tv7PVTvyCO/VwrFDBElHNFQDSroF+T9H7c3FtIfP/SRxxvol10o9zT43WRQ+5Py+YPcUoKWkh3ZaHfTtx7ZQY+9eYAWl+fRnVcuorpWLbuzd4W42mNSWsee9RygXM5ZkdmUkjODA5GZlLP0cl7OzcV6DCbOkmyhxk0PUM7iy8gsAXVeJi7HjeaBAdTBphvkMcscrBl5an9NfZn6YOfjeOIK6O8z/f2WuDPByCEAAQhAAAIQgAAEIAABCEwdAQQnp86z7jdTU6ZW7dzX3T5FBRJz2naHhz4+ntY7+JEssB7ZPINB3heSg4/72wvp+W2yeZDnAAAgAElEQVScTalHEXsvN5OXLJy1ONRybglaSnDypY9r6dCxVq4GbqY7L51HM4vSyWKSV03f1cGAV33OXXotedqrqevQ++R32ang9NvJa2/g5d17ye9oJ0fdbi5808x7Un6o9p/0tFSSt4v3vsyrGHGAUrJNXZzx6U4rVLORz2jJKaC/z/T3W3LOErOCAAQgAAEIQAACEIAABCCQXAJY1p1cz3PEszHnzlTn+joRnBwxWhyceLDORe0uyXr1xXQ0+lJtPxeh2VqXTYsq22gZF8mRQJ4EKt2OHrJZjOT1DV4MR/rocvpo/ZY6NbZF5QW0YnYOvfFpPRVkcyZkv2bkgOR71HNsa2/F+ADZ92/gAOQHvGSbsyxVcNTAgcomlSnpqNmp/lRLubm1bX9uxEFGI/clxXDyp5dFjAEfk01Af5/p77dkmx/mAwEIQAACEIAABCAAAQhAIBkFkDmZjE91BHOy5M9XZ/naeM9JZJKNQCw+TvnkEBeWMWuBvlhnAOrJkn6y0RsHUsjlluxGrbmdTpLK24M2/kqK4Gw73EYHqlvVaWsXFXImpZEO1HTSyrm5XFE8ImOR97wMSDEftTRdy6wMyNJxPt6XZanfU6qNS2BSC1oGfbzXZmR/EYOTXiWwauKYptOWT9m5eaFga8Sp+JgMAvz7oN5n3CwFC5JhRpgDBCAAAQhAAAIQgAAEIACBKSGA4OSUeMwDJ2nOKCRDqpWCPj95OhsHnoAjcSlQ053GATa/SizUg4mxHqjsZVnTnU07KrtDy7vdHDSU4KIE+6IuiuaDEjp8Y3sDuTw+taT7nKVFtO9YJ1fsdtPq+fnk83HN7LCLJdhp5uClBDD75jIwAGrkt5SZl4vLueHnyRJy+U5v8p2cpx/TeuIx84GcmfPUfdCSV0DeY/I+k/eaOb0geSeKmUEAAhCAAAQgAAEIQAACEEgyAfzbepI90NFMx5Sv7TvpbqoazWU4dxIFnIZ8TiCUgjUyiIGBvFgNzWg00faGVAoEeqOJfMOoQcneG0qgsIGrcn+wt0EdmVGYS4tmZtPjG6rozMWFVJKT2m8ZtjXFRN28BLy6qYfq27Q9LqNlZlqtJnK6/XS0oZuOtzhU9qb8yPWN7S6yO3gfzLBAbXWzQx3TA5Qy/Mp2P1nyStW49L00ZV6NTW3U45AiP1pzON1UdayevN7YLpkP3QB/GVcBd1Ol6l9/r43rzdA5BCAAAQhAAAIQgAAEIAABCMRMAHtOxowy8ToyF8whX00VuRoqKXP+aYk3gSk4Yn/QPOK9Fk+EJ+D307EOK9W3dnGgMWvIFdQSHDRxwHDr4XaqrLOr267gZdyVHEzceqiNfvuPp5KfC9JIkyCmBAwff6eS1n9Uy1mVDhUwPHdpCd19zSKycnajLFeX8yQY+twHNfTUu1UcwOzmZeMmuuHcWXTjeRX0xzcq6ZlN1fS9m06mNfPyVZz2Fy8epOfer+S+ptN9N55ENg5sPs/Xv7rXTc98gSt9c/NwVufPf/U0bdm6l1paO+g3/30vLV5YQS+99iH94tfP0JGjtfTFa8+n//i3O5BpqcQSp7kaqtRgzQVzE2fQGCkEIAABCEAAAhCAAAQgAAEIqI3e0KaogLVcC0i6jh+dogKJN22LUcsUHP+RB8nps1GLI0XdysSBwaHyNCXA+P5eLl7T2xaVZtL/rj9IXzhzJpUVppO/NwPT6w/S95/cRQ+8sJvuuGQu/d+bl1OH3UG/f3U/bdzZQGazLN82qMI633pkB9396w/VfR/5xhnq3MffPko33v8B/eDxbeTjPiU7UzIpN+1ppode2kc1Td0c8HSRxWKiw3Xd9OD6fbR8xRJK5aW+0nbsOkQ/uP/39Mrrm8lqTaEF88roZw8+TX9z6320afN2qqtvoqef30CtbZ2hueAviSGgv8es5WsSY8AYJQQgAAEIQAACEIAABCAAAQgoAQQnp/AvgrV0tWzSR76OHt53si+wNIVJ4n7qtkCb2kNR23txqIXWY5+KZC7KsnEjF96pbHKrjizmFJKq16p6d5SuOxxe3l9Sy5rMTk+ht3Y0quXYXzqvgjxev7oiJcVIP//rfnrirYP0txctpAtXldBcDmLmZqep71vsHlULx80Vwb/76E569t0jNHtGDt1/+wqaU5JBqzgbMy/LRjsOanuknraggLLSLcrila115OCsSGkr5+XR3uoOuvvhbdTU6aFrrjpLHZf21HMbeO9LbTxXXLKWfvLfT9Lrb39M1151Xuic9HRbKJgZOoi/xLWAvL/kPSbvM/VeQ4MABCAAAQhAAAIQgAAEIACBhBFAcDJhHlXsB2o0WchSvkh13LV/c+xvgB5jLlCSxgEY/m8KEjwMLy4T8xvxouoA721Z364tx7al9t8zUr+fvqS7prWHmju4kjgHTjt7PBxodNN3b1iilnvLOGWZ9qe87PuJNw/StMI0umAl73fKFx/ggGZ1vZ1K8tPotIWyPNtAj22opJc/0vYP/MJZFVRRnE4eDlj2cLDT7eldHs73WcPn6/mcPNRQe+XjOrrjF5vps0ONtOyk+bRoQYX6rr2ji955f7v6e1ZmOm3bcZA+3XGAnnj4PppdMT10/bKT5lFaqm1Cls+Hboq/nJCA/v6ylC8kea+hQQACEIAABCAAAQhAAAIQgEDiCCA4mTjPalxGmrb4CtVvz4Fd4x3tGpfxT7VOl1dIlqGWMakXd4m1gQQcVWZmMEBdPm1Zd0pqOlfhlirhA/MmJfB4rNFBja0OVUCntCiDfnzrciovSOO9JrWxStblE+9UUbfLR6UFWSrg+MmBVvrBn3bSDD7/h19eRYtKs6iyvpv+8PYhNaXS4gy6es0M8nkDaql3bauT76FlZ07nAOfSWbnk470sfXyPf756Pi0oy6elc4vostXTqSQ3i5d7G2nduas40Kgv6T5Mx483qDl0dTvoeE2j2nPSYjGr7Elp8t0FfI1WQXzgXGNtjf5iIMDRb/X+4pa6SHufxaBXdAEBCEAAAhCAAAQgAAEIQAACEySA4OQEQcfrbWzlZ5IhPZX8XS7qOvppvA4T4+oVWDQzlWwGzp6U9c/j1iQop6KT5AlqwUmfwUwe/glEpGtqHyVw6FAhU6npvWBmHi2flaOyHCWWKZWzW7s9tKuyXY24jX/XvvW77fT9x3fRBcun06N3n0EXLi/hOxroje31VM8VvKWtmltIRbn8u8nBR6PZSJt2NamMTGkVxTlUmqdVEzdzEZ1DvL9kCu8z+euvr6b5HOQ8UNVChQU5dMmFffsP7tpzlOxdPSojclZFKf3iJ3dRQX42vbf5M9qz77DWb9l0Oues5ervaIkhIO8teX/Jeyy1om8Jf2KMHqOEAAQgAAEIQAACEIAABCAAgfGMcEA3AQRk/8LUpZerkXZu25gAI57aQ8zPstKsfC8XqDEzhJaVOF4iwSBX1uaF05INGTClUCDFqkKWkcmTEpDs6PGGhpHGVbL1sUnwUqpsH+TgYXtntzqnq8dFC8tz6KF/Wk3f/ZslXDAnjby8D6SP12Zv2d8a6mcWZ06mcMakLA1vbHfR+o9reN9L7eslFdmcTWnkgKSRdvL+kvc/u4/+7uI5NL0glSt5H1X7T1aUzaClS+aoC6RK9+YPd4b6vvKytXTyktnq8xucNSnfSztt9RKaVc5LzrkdOlKj/kSLbwH9vWVbepnajxUNAhCAAAQgAAEIQAACEIAABBJLAP8ml1jPa1xGm7HseiKrhbxN7dRdqe3JNy43QqcxEVhd6iRDwMN9afs5xqTTITqRTMPs7Byy8dJuC2cwDmgcMNSrcct3Pbx0W/aAlCXSVg5UbjvaTt97bDtnPXrVUmsv7x+5al4uTctPJRfvI8n5lSpR88dP76VNn9Wqc/RmkOrdXEjnVy8dotb2bu6TiwHx/0o5CGm0SWCyk775ux10zdpS+hz/7OPP2w9pS7dzczPVkm2n003f+NYvaf2rm9SYpLr34gWz1C16HC768JM9oftdfIGWaSlVvW+47f+GjuMv8SnQXbVDvbfIaqbMpfweQ4MABCAAAQhAAAIQgAAEIACBhBOIEmlIuDlgwCcoYExJp9QV2l5t7R++wlsNatWMT7BbXD5OAstnZ1NZZgeZLClR94CM3W15OTWHDiWYl5JiJoM1S3XNiZT9mgQLi7Jt6phkVR6oaaXtVR1qifcLH9XQPQ9tpXNO5srcM3NVkZ32Lg/96E+7afvRDurhfSz31HTSPQ9vp52VHXTKwhJ1jiRIvrm9gaS4zQ+e3M2Zk0665qzZHAQNqH4/2NdKf367igOT2+iSVdPoDs6a5C0y6UinkZweHjcPZPfeo/TL/32OvnTnD2nP/kpauXyRWtJt5kzOkuJcNd6a2iZqbukIzSfVlkIb3ttG/3jvL+hzl2OJcAgmDv8i76n2D15WI0tdcSUZrRlxOEoMCQIQgAAEIAABCEAAAhCAAASGE5C1oWgQoMyVt5Br9+vka++h9u2vU96qy6AShwISXJPsv8uWBOmhLS7y8z6QsS/b3VdwJ8XAe/kZtKCPL6OIN488qgVEw/ae9HEm5NrFBaoKd32zk2qbHPTV/36fbDaLWpL9jWuWcFbjTMrLSKH7n2pTqp/sa6Av399GWXysg/cLXL1oGv3mH06ljw+20if7G1QAdE9lM3315820oDyfHrlnLX2wt7n3iRjolQ8rafNnNXTvF5fRLedXqOPBwllUtoorftObasF7XX0T/ct3H6QrLzuL/vT779E37/s1bd22Vy3hTrVpRXKsnDEsgUy9/f3dP6Wc7Cz69j03083XXxg6jr/En4C8p+R9JXtNZq74UvwNECOCAAQgAAEIQAACEIAABCAAgREJmL797W9/f0Rn4qSkFjAYzWTMKiD3oQ/I01BDaXMWkSk1M6nnnIiTk8CkBCgLslJ4D8dOqu3J5IxBzibsDVrGYk5a3JHzIU0mmpbaQafOSdW6NVrIVbOPDGGBSflCPhbn2CgvM5X21XSQBCtTePn32sXT6N+/tIJOX5hPXq+fls/OIyP3eby1Wy37luI6hbz0+iuXLaR7P7+IMjhQWMGVu528feWBmnbeacBE56+YST+5fQXN4CXgEtzceqSTunkp9qKKAvrhrSvpqjWlKl2zJ72ECldeRDNLizkAeZCaWzv479PoW3ffTD/63p2Uk5NBb23cSp12B8nS7WuvPoeys9IpKzOD6hpaaP+Baq7qbaNzz1pFP/vx1+mi80+NBSX6GCcBT0cDtbz5nErjzbronymlYN443QndQgACEIAABCAAAQhAAAIQgMB4Cxg6OzvHt6rGeM8A/cdUoPXlfyHvkT1kKciiGdf9CxeYkOImaPEo0MN7Kf7PJiPVdueQ3+uJ2RJvPdBp5gI4Z0yvoc+vzlZFcfxctObQxmcoy9PCf+fF1RFBSgvvD9nU4aa6DhcVZ1t5qbeVMyeN5OFgpeQmylaSkqXYzBW367jAjRTOmcFBzYw0C/m4IrfcQ09iPNLYQ1wLh4vlpHOg08D7VAbJxAfauOp3PV9bzntO5nCw0s9BTnfWdA5MXkxZWVqGp73LQfsOVNHc2aWUn9e7FJ37rucgZEZGGgck0/pZ+bkTWfadlmqlObNmxMwxHn9nkmFMspy79pn/Im+LnSxzllD+5f+VDNPCHCAAAQhAAAIQgAAEIAABCExZAQQnp+yjjz7xgLuLmh+/lYI9TkpftICKzv9y9BNxdFIF9ABiPe/F+NvNVurwZpHP445hYE0ChUb60ireB3J2aigzs2bvp+Q/uFlbSR4RnBQQ2Z9SIpGy/2Nk8FIH08+RtddyTpRutH74gsjvJXNUfiQQ6vQEyFy6kEqWnUsp1pRJfR64+cQJNG34I/XsO6CWcxfe9AcujKQFoCduBLgTBCAAAQhAAAIQgAAEIAABCMRSAAVxYqmZBH0ZrZmUfel9xClvKgDQ8dmbSTCr5JuCBOikTctNpb9b66OclG6yWHuXX8dkugaymZxUkuEPBSal29yyheSzcRVsTqjVxxB+O8l+DHAW5GCBSTlXP0f+jBaYDJ0T5Xv+teQMSq6ybUqllJPOp7LVFyEwGZPnnRidyPtI3kvyfpL3FAKTifHcMEoIQAACEIAABCAAAQhAAAJDCSA4OZTOFP3ONn05ZZxzm5p9++Z3yL5/8xSViP9pSxBwRl4K/d1pTpqR2qgqeBtN5iGDgyOZldGcQtOzvDS9IF0FIbUMxiClZ6STuWw5eTk9UpZZy76R492kOI7cy5ZqJmfQTN7CeVR42uepdP5J431r9B9HAvIekveRNHk/yXsKDQIQgAAEIAABCEAAAhCAAAQSXwDLuhP/GY7bDOxbfkOOLS/KRoGUf95llLXwjHG7Fzo+cQEn70H51l4PfXCMi8oEMshoNnMWo49//Gqd9VDZjGq5NG8KKYFNI+8zago66OZlbbR0Fhfc4QBkeJakZDwe27+DfJWfksnrIJuF/xsHn+PnjEnZOzIWzczBSAlI8o3JxXtdBsypFMivoPxZJ1Ne8bRY3AJ9JJCABCZbN76iCuCkrbmKstZ8NYFGj6FCAAIQgAAEIAABCEAAAhCAwFACCE4OpYPvqOO9n5Frx1sqSJR7xrmUs+xCqMS5QCNXw/6gkuhQs5kaO3zkNWSSmZdi68WNtCClHnDUlodLENPvtpONujgTk6tkzw/SyRVagZnBpttl76a2yt3kb6+hrrY2svhdxEXEOXtTS8gOyrJs3nvSL0u9Jf0xSpP9J038w9tb8o82Fp83QF0eIq+Zi9fk5ZEhZzrlli+m7Bxtb8HIYGmUbnEoiQRkKbfKmOQAuG35BZRz9t1JNDtMBQIQgAAEIAABCEAAAhCAAAQQnMTvwLACoQxKPlOK5BSeezOqeA+rNvkn+DjjsLXLTXaXkaobuqihzUXtPQFy+yUSaOKF2X5KNQcpN91A0/LTqLwkgzJT/FSQkzbqwXd22MkU8FBHazM11deTy95GRk8PpQQ4YGkOkCXoHZC5KYFJr8FMdp+J3JRCAWsG2bILqaikhHLyCzhb0haqwD3qAeGChBcIcsC8+d0ntD0meTbImEz4R4oJQAACEIAABCAAAQhAAAIQiCqA4GRUFhyMFOje/Tx1v/t7SYMjS0EWFV18K6XklESehs8QgAAETljA015PTW/8kbwtdlX8RvaYzDjp2hPuFx1AAAIQgAAEIAABCEAAAhCAQPwJIDgZf88kbkfkqt1Ona/9kII9TjKYjZR1ylrKXXExsijj9olhYBBILIFgwE/t218n+9YPKOgLkCE9VVXlRvGbxHqOGC0EIAABCEAAAhCAAAQgAIHRCCA4ORotnEsBl53a3/p38h7dqzTMuemUu/ZyyqhA5Vz8ekAAAmMX6K7cTu0fvkK+9h7ViWXOEsq94N/IaM0ce6e4EgIQgAAEIAABCEAAAhCAAATiXgDBybh/RPE5QMeRDdT1zq9UFqU0S1EuZa88jzJnr1LFc9AgAAEIDCvARW66jn5Knds2kLepQ51uyEijzHP+ntLmnD/s5TgBAhCAAAQgAAEIQAACEIAABBJfAMHJxH+GkzaDgNdFXdsfJef2l4jcPjUOU6aN0hecTJkLz6CU7KJJGxtuDAEIxK+Ap7OJuvZvpp4Du8jf5dIGarVQ6oorKHPlLWQ0W+N38BgZBCAAAQhAAAIQgAAEIAABCMRUAMHJmHJOzc4C7m7q2vkUuXa+EsqkFAlzTjrZZs4mW8ksshZVcLCyGFmVU/NXBLOeygKcHenpbCR3UxW5GirJdfwo+Tq0pdvCIvtKpi7lrSGWXU/GlPSpLIW5QwACEIAABCAAAQhAAAIQmJICCE5Oycc+PpMOBgLkrNpEzn0vkbd6P5HP3+9GBrOJzHmZZM7OJXMG/6Rnkyk1k4y2dA5KpPGPjYwWGxfbsZDRaCYymrjYjpGjF0ZeKc5LxflPNAhAYBIEggEKcpCR5E/+55y4cE0g4OOiNV6SDOqAR34cFHA7yO+wk6+nk3zd7eTr5J+2Lj6v/7uA+F1gKV9EaYuvIFv5mdo/55MwLdwSAhCAAAQgAAEIQAACEIAABCZfAMHJyX8GSTmCgN9L7pqPyV29hXwth8nfWk9Bpzsp54pJQQACQwsYUq1kyp9G5oK5ZC1fQ9bS1fzfHixDX4RvIQABCEAAAhCAAAQgAAEIQGBKCCA4OSUec3xM0tfdTN7Wg1yN9zjvM1dPAUcbByw7ye/mJZ6cfRX0ejjDiveulMwsP/+oTC0eu/wpTf8zPqaDUUBg6gjoRa5UBjNPW/40cSYzZzYbzGYyWFK4KpaNTNZ0MqRmkzEtj/ef5WBk7kyy5M/nTOnCqWOFmUIAAhCAAAQgAAEIQAACEIDAqAQQnBwVF06GAAQgAAEIQAACEIAABCAAAQhAAAIQgAAEYiWATfxiJYl+IAABCEAAAhCAAAQgAAEIQAACEIAABCAAgVEJIDg5Ki6cDAEIjFbAx0v15QcNAhCAAAQgAAEIQAACEIAABCAAAQhECiA4GSmCzxCAQEwFqo9Vk/ygQQACEIAABCAAAQhAAAIQgAAEIACBSAFz5AF8hgAEIBArAcmYPFJZqborLysnMxdPQYMABCAAAQhAAAIQgAAEIAABCEAAAroAMifxuwABCIybgGRMer1e9YPsyXFjRscQgAAEIAABCEAAAhCAAAQgAIGEFUBwMmEfHQYOgfgWCM+alJFKBiX2nozvZ4bRQQACEIAABCAAAQhAAAIQgAAEJloAwcmJFsf9IDBFBPSsSX26kj1Zhb0np8jTxzQhAAEIQAACEIAABCAAAQhAAAIjE0BwcmROOAsCEBiFQGTWpH5pJbInR6GIUyEAAQhAAAIQgAAEIAABCEAAAskvgOBk8j9jzBACEy4gGZKSKRnZPMiejCTBZwhAAAIQgAAEIAABCEAAAhCAwJQWQHBySj9+TB4CsReQrEnJkBysIXtyMBkchwAEIAABCEAAAhCAAAQgAAEITD0BBCen3jPHjCEwrgKSNSkZkoM1ZE8OJoPjEIAABCAAAQhAAAIQgAAEIACBqSeA4OTUe+aYMQTGTWC4rEn9xsieHLdHgI4hAAEIQAACEIAABCAAAQhAAAIJJYDgZEI9LgwWAvEtMFzWpD56ZE/G93PE6CAAAQhAAAIQgAAEIAABCEAAAhMlgODkREnjPhBIcoGRZk3qDMieTPJfCEwPAhCAAAQgAAEIQAACEIAABCAwAgEEJ0eAhFMgAIHhBUaaNan3hOzJ4U1xBgQgAAEIQAACEIAABCAAAQhAINkFEJxM9ieM+UFgAgRGmzWpDwnZkxPwcHALCEAAAhCAAAQgAAEIQAACEIBAHAuY43hsGBoEIJAgAvUN9WQ0mcjGP+HN5XL1+2yz2QbMSK6dWTpzwHEcgAAEIAABCEAAAhCAAAQgAAEIQCD5BQydnZ3B5J8mZggBCEyGwMuvvdrvtpdfculkDAP3hAAEIAABCEAAAhCAAAQgAAEIQCBOBbCsO04fDIYFAQhAAAIQgAAEIAABCEAAAhCAAAQgAIFkF0BwMtmfMOYHAQhAAAIQgAAEIAABCEAAAhCAAAQgAIE4FUBwMk4fDIYFAQhAAAIQgAAEIAABCEAAAhCAAAQgAIFkF0BwMtmfMOYHAQhAAAIQgAAEIAABCEAAAhCAAAQgAIE4FUBwMk4fDIYFAQhAAAIQgAAEIAABCEAAAhCAAAQgAIFkF0BwMtmfMOYHAQhAAAIQgAAEIAABCEAAAhCAAAQgAIE4FUBwMk4fDIYFAQhAAAIQgAAEIAABCEAAAhCAAAQgAIFkF0BwMtmfMOYHAQhAAAIQgAAEIAABCEAAAhCAAAQgAIE4FUBwMk4fDIYFAQhAAAIQgAAEIAABCEAAAhCAAAQgAIFkF0BwMtmfMOYHAQhAAAIQgAAEIAABCEAAAhCAAAQgAIE4FUBwMk4fDIYFAQhAAAIQgAAEIAABCEAAAhCAAAQgAIFkF0BwMtmfMOYHAQhAAAIQgAAEIAABCEAAAhCAAAQgAIE4FUBwMk4fDIYFAQhAAAIQgAAEIAABCEAAAhCAAAQgAIFkF0BwMtmfMOYHAQhAAAIQgAAEIAABCEAAAhCAAAQgAIE4FUBwMk4fDIYFAQhAAAIQgAAEIAABCEAAAhCAAAQgAIFkF0BwMtmfMOYHAQhAAAIQgAAEIAABCEAAAhCAAAQgAIE4FUBwMk4fDIYFAQhAAAIQgAAEIAABCEAAAhCAAAQgAIFkF0BwMtmfMOYHAQhAAAIQgAAEIAABCEAAAhCAAAQgAIE4FUBwMk4fDIYFAQhAAAIQgAAEIAABCEAAAhCAAAQgAIFkF0BwMtmfMOYHAQhAAAIQgAAEIAABCEAAAhCAAAQgAIE4FUBwMk4fDIYFAQhAAAIQgAAEIAABCEAAAhCAAAQgAIFkF0BwMtmfMOYHAQhAAAIQgAAEIAABCEAAAhCAAAQgAIE4FUBwMk4fDIYFAQhAAAIQgAAEIAABCEAAAhCAAAQgAIFkF0BwMtmfMOYHAQhAAAIQgAAEIAABCEAAAhCAAAQgAIE4FUBwMk4fDIYFAQhAAAIQgAAEIAABCEAAAhCAAAQgAIFkF0BwMtmfMOYHAQhAAAIQgAAEIAABCEAAAhCAAAQgAIE4FUBwMk4fDIYFAQhAAAIQgAAEIAABCEAAAhCAAAQgAIFkF0BwMtmfMOYHAQhAAAIQgAAEIAABCEAAAhCAAAQgAIE4FUBwMk4fDIYFAQhAAAIQgAAEIAABCEAAAhCAAAQgAIFkF0BwMtmfMOYHAQhAAAIQgAAEIAABCEAAAhCAAAQgAIE4FUBwMk4fDIYFAQhAAAIQgAAEIAABCEAAAhCAAAQgAIFkF0BwMtmfMOYHAQhAAAIQgAAEIAABCEAAAhCAAAQgAIE4FTDHelweX4A8/mC/bi0cArVaTFFvFQgEyeEN9PvOYDBQesr4xk3dXj/pty7QHIUAACAASURBVDUbDWSTQY6x9XgCFAxqc7aZDWQ2jb2vkQ7BHwiQgf9n5LGPpvn8AXL5+p5PqsVAJuP4j3c0Y8S5EIAABCAAAQhAAAIQgAAEIAABCEAAAlNDwNDZ2dk/kniC835hj5027u7q18uMohT65nmFUXvectxBT37Q3u+7jHQT/ccVJVHPj9XBp3d20uZ93aq70mIr/cu5BWPu+lt/rSenSwuwXn96Lq0tSxtRXxKYvX9jMwc2DfTl1Tk0I8tCMq7DTR5aWZZKl8zP6NePk6OpT++0U1Wzhzq7feq7TLZaWZ5Gly9IH1FQNNL7znPzaUmxbUTjjYeTOpx+8rCbtHQOKI93EDse5owxQAACEIAABCAAAQhAAAIQgAAEIACBZBWIeeZkNKg6Caa5/JRtG5g9ua3GFe2SKXGslQNtDS1eNddsq5a9eLDRTc1tXgrM7B8wrG730EMcxO3qDUrqQB12H23YZadPqxz0fy4oTPpg3W8/aqNaDt5KO3NxBl13cvaU+F3BJCEAAQhAAAIQgAAEIAABCEAAAhCAQDIKTEhwUlY8f3TcSRfP658JKEuMj9ZP3eBkLQcWpaXw0uoMqxa4tff41bHijP6P5tFPOkKBSV71Tvk5FrJzoNLj1bIIO7t89PDHbXTXmWPPAE3GX/BEnRNnNJPT6VTDt9lsvHx/cpbeu91u8vu130mMgyjco7i4mGQLCjQIQAACEIAABCAAAQhAAAIQgAAExi4wIcFJGd62Y44BwcndnAGnB9fGPoXEvbKBA4rSMtO1x+DiZdtut7Y8vCSz79F8xEvfW9q1DEsTxzD/npfIz81PIdnf80+f2Wnb4R7VT2Wtmxy8/2XaOO/XmbjiiTPyqqoq6unRnmvijHpqjTQnJ0cFjtEgAAEIQAACEIAABCAAAQhAAAIQGLvAuAYnJdmL67ao1tjqpTaHj/LS+m75yTEtM0y+l6Bbb4LWoLORIN1WzsBs7vSRm4Nw2ZxdOCPXQlcszOjXb3gHe5tctOmog2plqTQnGc7Is9BVSzIHvYf+RX2Xl14/0EO1HV6y9/C4OVhYnm+hdXMzqLA3mDhsJ4OccKDFzcvcA3SAxyZNitp8XONkHy1DTY5V831dnBU5h4OQ+3ipt94WzUxTgUlpKWYjXb4wnbYf6eF9K4kkh/Jwm4eWlowtYPKrD9pC97mT98Dc3uCm9492UxMHRq0pJirOttAXlmVRUdj8XznQTZWt2jLrs2anUhoXPnp1fxfVs7fZZFDeZ81Oo8VF/cf08Mft5O4tzHMpP7/ZedqcZACN3V56dmffvqVfX5tHr/J9jvJ92nqzTeW83bwlQFOXn3JSjXTTipzQ2PEXCEAAAhCAAAQgAAEIQAACEIAABCAAgcQQGNfgZCrvMSkBKllyrC/tvmyBFhiU6taHw5Z0z5pmo8OD7D8p2YAP8ZLlo5wZGN6cLg/v2eihnZUOumpVNp1dkd7v+zcPddMrOzpDAVL5cj8vhZal5CW9Ab5oj0mue/Wzzn7B0jq+l+ydub3SSbefmU/zC/qCadH6GOrYi7vtVNOoBfTkvGYOKD6xuS8wKMee+rCd5pXa6B/OyKf2sKDlPC4uFN5y2FiCwHpgl2OIY26HOPCrV0d6nYOKb3Hxnd4i5Fzwx0eyv+VP2O7eiwupJMOi7nO42UVHep+LLHA9UuckX1+MVT37fRyEvnR5Fl08vy8ofLDOFcoSXVOeSrPDRt3lDtJBHkt4O8wB3cjfDxmP/GRn8lhWjHnacXmh1WoNZU4W5uSRzTq2gPOJTq6xrYWzm7XfVYyDA+dhHljSfaK/XbgeAhCAAAQgAAEIQAACEIAABCBANK7BSQFeVmaj9/ZoVbG3H3eRHpzc1+wmV+8S5kzOgCzlPRQjg0/6A3qSA4x6YFICcbOn21S23FFeFt7GWZRezsD7C+/JWM6ZfeW5WvDueIeHXt7eGQquyT3mlVjJydmIEkA7xlmB0druRhe9vI2v4y9lO7nZ062Uw9meBziY1s37QcqYf/NOM/3b5SU8hrFFAqfzOHm7TWri7EK/P8jBNTOl2YzUyf07OBBp5eI4eVlmmsbnSbt4QQZ1zdIqgC8osPYb9hYO6OqBSRlvBTvGor3Jy8XFuozNGnic+nJzsX5tfw/desrATMUDHFCUDNh5XMwnk/fQPMTGUsBHApyvbrfTPB57eIbkaMa5cmYqFXBlcsmWlOcgrZgzWWdxkDh7jM9hNPef6HPDlwtPKyyi3KyB3hMxJntPdyg4iXEQZ1H3eUzWPqAT8dxxDwhAAAIQgAAEIAABCEAAAhCAwEQJjHtwcm15Wig42czLclt6vBxkstAnHKjU25IZVhqsrMRhvmY3Z0ZKk3NuOyuPTi5JVZ8DvE77lx+0qsClLB9/4tMO+s4FReq7v+7tCgUm87LN9M11hZRq0YqKVLWl0y/ebu6XUan399RWLTApn2/k5cSrS7V70Uqin73XQtX1UiCE6JUDXXTj8rEFjPQlyHc/W6vGej1nfS4pttH/ciXqvdVOms/B179bnau+kybfRWt7OJD6l60doa9WzEknGy+rjkUr4szSr5+RpwKwsrflT99tCVUWP9a7jDvyPhIcvfOcfFpYqI3Xzdfd/3YLtfISdQn2rt9rH3PBnjPK0kh+ftLeHApOziu2olp35EPAZwhAAAIQgAAEIAABCEAAAhCAAAQgkEAC414CeBovuS3gfSGlSYBqc7UWlNxf27ds94wKLSswmtvuBldoqfE0XtKsByblXNmr8XNLskKXSSaiBNKkHeOsSr2tW5QRCkzKsQre33DejN6gY+gsolo77y/JmX7SJNNycWEKdbv9oZ+1vdmL8v1nVf2XHYd1M6K/tvL+m3rG44wszaeN97aUVpgxdIBRqpw/vbOTHnq3VWWNqmt4Gfb1S4ffS3NEg+OT1vL+kXpmqOxtOZ8DgXpzuMLWbYd1OJPP0QOTctjK1120uK9C+2DZqiMdE86DAAQgAAEIQAACEIAABCAAAQhAAAIQSC6Bcc+cFK7lvCT3rd5q0zu58MsSDmI5nFoQUZY0l+Wk0LbavkzKcOL6sAIoM3qXOYd/L8u4TbyvpSyPluXDNXz+NO5TX4Ys584JK7aiXzsjh5dqH+//MI+F3UuWI3/3hYb+J4R9kv4lSGg2jS6+e5T3l9zGgdl2hzZ/yTZ883C3ygqVJerSqvic53d30rUnZQ+4vwRQH/6gnc/VqnfLCQs5O/X2U7JVgZxYtciiP6Vh9pKxGq3NiLKkPHwZuuxF2cmBzWzeJxMNAhCAAAQgAAEIQAACEIAABCAAAQhAAAITEpw8gwuevL1LK67SwkHK13hJtN6Wlw3MYAx/LK7eTEg5lmKOvvibEyhJz+Xr8fjJ6+8f/Opdzd3vaVs4oBnZusMyAuVbwzCxPjsHKPPShjkp4iZHeEn0pr3aHpzylQRU3w/7LMdkmXp1g2dAcPLDYw56hqtc6xmXsjfltbwk/DSu4B3rZosIdJoFeZiWEsU0NeKZdUuV9YjgZGSoc5DY5zB3x9cQgAAEIAABCEAAAhCAAAQgAAEIQAACiSYwIcHJPC4oU8KFS+q52rW0Q2H7Ta6tGDo4WcTLq6tIK17T2pttGI7cw8EufWmzHJcszCwOflk4KKYfr+vyq30uw1trb1GV8GMzwzL/ZFn3Dy4v7ndNLD6U8RL3lXPTqYoLAkmmZBbfZy4Xneni5ePiIiHAFfx9ZJxvw5FuevHTvgI/M3iJ+52naXtCxmJcseijpXdZenhfjb3L5OWYzK0oTQsch4c6I59FxyDLxmMxRvQBAQhAAAIQgAAEIAABCEAAAhCAAAQgED8Co0v7O4Fxr+Kl3ZFN9qIsyRi6unQ576Wot6NcZdvp1ZZD68ferewJfZ9qM4Sy8vJ52bbeNvKy6fAmy7H3RllGXs6BTVlmLa2LA231XX1Lp+VYh9NPv93SpgrXPMfLrsfSZJnzl1flUG7vvpLzp6Woz6f0+ti4ard8vnllX7Gdhm4vvcTVriXLUlo5X3MPF54Za7XwsYx7JNcc5ormUgQnvL1fpRUzkmMZHIi19GZkWlP6fvWqeK/Q8LZ3kErqkWNweCJzLiPPwGcIQAACEIAABCAAAQhAAAIQgAAEIACBeBaYkMxJAZCq3a/s6OxXIVv2ohyunS77VfKy53beD9LjDdL/29hCl5+USflcRXonB7E27LaHulgXVhznwoWZ9Nj7beo7WSb9MC+HPperWTu9fnptfw85HAOLuqRzwOwUzlr85FCPCgQ+yAVnVnFm5/LpqXSM93h85wCPo3dfyIuXD9wPcri5hH/f3q0F8SQzVFojZ3dKy0ofuB/j0+wme2rqrccVpPs3tIQ+h//l3PkZtJarWk9Gc3Ow8L82tvLzyaBcq4k+5WDyJwf7gsdnzU8PDUuCs51d2h6bB3kf0oc/JlpcYqOPqnpoqMI54Uv79/F1z/HS9gI2O2dWX9+TMXfcEwIQgAAEIAABCEAAAhCAAAQgAAEIQGD0AhMWnJTAXxkvX66q05ZoS4LiWt6LcrhmMhrp5tW59Jt3WtQybdmz8o+btKBj+LUV06104dy+ytCncDXuTdP4fvXa/XZVOkh+9CbLtqXoTWS7bmkWHWp0UwcHQ7t56fe7e7rVT3iTJeoXzDmxAKBkZkqblqU9gubeseRHySStbe2fWSgGg7X2KEHXwc6N9fG0VCO1cDGfR94b+HwkS3bd7D6zc2Rpe++zkcBr+PMpzk+hRt6bM1qTZfGVvb9DTleA3tvTRdlcER7ByWhaOAYBCEAAAhCAAAQgAAEIQAACEIAABOJbYMKWdQvDqWHFb4oLLJTPe1GOpM3lYNW3Ly2iWRyA5FhlvybLoC9fmUXfOKtgQFd3nZlPp85LV/tP6k2Wba/iYxcv6Qtkhl9o5WXH911USGsWpJM5opiLfJb9Iu8+O++EKmNLxWp9P0ypLC6trTdYWdC73FsfUzfvReniIFwitEWlqfS51Tn9vOV5LeKs2f9zfkG/yuYrORv1Es4+lUrrepNnM6/URnednT/odK/kjNjF3J9pYILpoNfgCwhAAAIQgAAEIAABCEAAAhCAAAQgAIH4FDB0dnYm1MZ9sl9kHS8HlgCfFL+JrPwcjTnIa7SPdXjJxRl6s7joTUpEJepo1+jHmjloKPfL5szPaZkmsloQFQv3euD9FjrCy+alSdD3Ft4rU/eW7UEreO9Ps2nwGLj+PLu48vmcvBSyRSutHuUB+QMB6uZl5D4u7Z1hMSTdc6mqqqK6ujo186XzFlJuVt8epFE4xu3QjgN7qbNb2zoB4yAK9zj11FPJYhl6z9xxezDoGAIQgAAEIAABCEAAAhCAAAQgkCQCI0tdjKPJSqBLgpKjaQZOySvPHd01ev+F6WaSH7SRC4zGeyzPU0Yiy/2zbSMfE86EAAQgAAEIQAACEIAABCAAAQhAAAIQiD+BwVPa4m+sGBEEIAABCEAAAhCAAAQgAAEIQAACEIAABCCQRAIITibRw8RUIAABCEAAAhCAAAQgAAEIQAACEIAABCCQSAJYr5xITysOx3rHmjzy8l6e0qwRBYTicLgYEgQgAAEIQAACEIAABCAAAQhAAAIQgEAcCSA4GUcPIxGHksoFbFJREyQRHx3GDAEIQAACEIAABCAAAQhAAAIQgAAEJl0Ay7on/RFgABCAAAQgAAEIQAACEIAABCAAAQhAAAIQmJoCCE5OzeeOWUMAAhCAAAQgAAEIQAACEIAABCAAAQhAYNIFEJyc9EeAAUAAAhCAAAQgAAEIQAACEIAABCAAAQhAYGoKIDg5NZ87Zg0BCEAAAhCAAAQgAAEIQAACEIAABCAAgUkXQHBy0h8BBgABCEAAAhCAAAQgAAEIQAACEIAABCAAgakpEPNq3X63lwL8E96MKWYy2VKiCgcDAfJ1u/p/ZzSSJcMW9fxYHfS7PBTw+FR3BrOJzGnWMXftlfHzPKSZUlPIaIk565jHNpILA/4AdR9ppJ79DWS0WShj0TRKn5k/kktxDgQgAAEIQAACEIAABCAAAQhAAAIQgAAExiwQ8yha3VNbyLNhQ/8BFVXQnJ/cEnWQze8doK5Hnun3XdCWQ3N/809Rz4/VwdrH3ifv5ve17kpm05z/vHnMXVd/49dk8Hap6zNu/jwVX7BkRH1JYPbINx8lA/9ZctdVlF5eQMce3kjevZWUuvZkmv6FUwftp379dnJs3K6+L/6HKyhjdtGg5w72havZTnU/X0/BhmoOrmqBWjm3m3+CRiuZFi6mmf94EZlTxx64jby3s6EzFMhNyUsfNGgded14fI6nsYzH/NAnBCAAAQhAAAIQgAAEIAABCEAAAhCId4GYByejTrj5GLnbe8iamz7g65739w04NlUOuBrtZGg5pqabkpum/vTuPkLUUUdB/+JBGSTTsee1D8nQ06LO8Tk8g5472BfN7+4n+2Pr+WJn1FMMATcF9m6nqnuqqeiuz1PWgmlRzxvtwdrv/oYMfre6LOcrN1L+6XNH20XMzq/97v/yWLSs3ew7b6CCtfNi1jc6ggAEIAABCEAAAhCAAAQgAAEIQAACEBheYGL2nAwGqHXD3gGjCfj85K88POD4VDngqG5VUw2abGTJ0oKT1N2hjlln5EVlcLd1U+X3nwoFJqOeNMzBzj21ZP8DZ6uGBSaDqblknH8yUdkCClr6gsgGRxs1/eQx8nQ6hukVX0MAAhCAAAQgAAEIQAACEIAABCAAAQhAYHQCE5M5yWNyfLiH6PP9lym3f1IZylwb3bCT42x3TZs2kfQc9afPwRmFPi0ImDqzf3Dy6A+fp2AbBy7b6ziaqe1vOVaFlodf40uD2uUGE2VcfxUVX8KBybBW/eu3yLflA3VEsgvreLl5xT2X9zsHHyAAAQhAAAIQgAAEIAABCEAAAhCAAAQgcCIC4xuc5MAXr09W4zO0HifZ49BWmBUar/29vmzKoMFMhmDfvofRJtXE2Zfd7++lQGMzGTxOCmbnkaWshIpvWNuv3/Br27dXU/tr2ylwvFYF9UylpVR081nRuu93zHGcMwaf/Yj8xxuIutp5DXIBWeaWUuHVp1BqSfaw1w91Qseu4+Rt6yHnTl7Czc1gMpEss/Y22UOXdR9qJD8v185aNF0dCxzdz3tTRvcxkGGo2/X7runN3RzgZIveZrvo/AGBSfmq/GsXUGWrnQKH+Xxu/t3bqbtqNWVUFJJkb9b+6vVQH+X3XqkKAemt9aMj1PnmDvXRXJxLZXeeT1W/eJUCdke/OXQ8v5k63/qMbEvKafq1p1DVf79CgS5tmfm0O9aRfXctdW/YQcHmBjKkZ5Np1gwq+vwaSivtC9zKdgG1D0qwVWtl91zRr7hR25aj1PGGtjenuSiHyr6yjqofeI38nT08lr7CTTIW+9s7yba4jKZHBNFDneMvEIAABCAAAQhAAAIQgAAEIAABCEAAAjEVGNfgZDAlgwNvFk6b5L0Rg0G1tHvG9aepCQT5c+DwodBkjOXzKFgVff9JX4+Lqu9/gejYQXW+HooztHSTj/dsrPnsM8r8wqVUfOnSfjh1f9lKzhc5iMYBUv2awKF2qv/3w2Qo1oJ+/S7o/SDXOda/0T8Y2NxD3uZqqtu6g/Lvup5yTiqNdumIjrU+8S5Rw9G+czlYaP/D0/2u7X78OeqZtYiyvneddjynhIK+vuCkwc5B0zG0nm1995WiN8VXrxy0l/zrTqfmH2vBSQns2j+tUsFJCZoGj3AmbG8LeC/tF5x0HWsJfe9pLuGzziff3oNkcHMxnPDGnsFmIhdXSyc6RTvHowVoGx63UoADopLhqZ5dRw/5t9dR/a7dlPu16yhvVYXqKeCMGIvnEqKwyusDx7KOvHtkLNryedUJN9n7M8i/pm4OFBMNXohIPx9/QgACEIAABCAAAQhAAAIQgAAEIAABCJy4wLjvOZlySl/latdHfQGtju1cCMbbo2Yg1bktsySIFb0d/583Q4HJIGdjGioWkWnVagpmFqsLpMBK99PrqYuzDfXWfbSJA5OvhjI35R6m5afwvooSwOQlzXVa1mLkHdu2VpLzr69ogUmDke+1kMwr+V58vWo85pafPUruVqlpPbZmnsmVtQvLiYxabDiYXqA+B1N6s0rNvP8kf7aU9VXgnvuz22juA3eGfsZ2Z86AbNSK6Mj1hsLp/bIMI/tURXDMqaHDnpq+ayPPHe6z7exTyHzaWr5pXzzcMHuxOpaxZv6AywO7txHx3pfGJSvIuGg5j6N3T07eJ7P918/wdplaUZ0BF47ggO2c3rH0+ssl+ljSo4xlBF3iFAhAAAIQgAAEIAABCEAAAhCAAAQgAIExCIxr5qSMJ//Ck6n+Pc4UlMYZgs7GTkotzqbO9/oClZblXJl6kJXJnXvrKLBHWyIsJ+V9/UbKO2WW6i4YCNDR73PGoWRUcnZk429epsyf3qa+a3r8PUnP1M7jIGbF/beGAnH2gw3U9OPf8TJybcm5Oomb9Nf2+5dDQ8m69QtUeM7C3m8voaPffZKCtZx1ycurG57+SC19Hksr//pF6rLDt/1I3SvvtstUJuDRH79AwQM7ybhgAc36lyvH0vWw1xjsWhEeOdGQ07fEfrALg6lZZOhdau2vG3twsvSmM9QtDn/yKQeTtQzQ7AuXD1qtO2jJoBn/cTulFmlL6B28P2f993+nFfHhAGXDc1up9Gatz8HGPtjx0hs5SKrGso39tbFkXbAsrqp1u919wdfGtlbq6hl7MHwwh5Ecd3kwjnCncI8Avy/QIAABCEAAAhCAAAQgAAEIQAACEDgxgXEPTqZxYZdg9jQydNarkbbynocSVFLLfHvHnnfhUurYfCDqTOxbJcOxt3hLUXkoMCknG4xGKrrlPGr6Ye9y77Za8ru9ZLJaKHisKtRf5hVr+2UIZs0voZY5iyjYu5+ifmIPV8+W6tTSJFMyZ0UZeXmfRL1lrFtOXY9q1cV92z7jw2MLTkp/sv+mvodkegVnTnILtLQrE0tJrn7LmP8p8Vrd3WAcJCIcfldD2Dm9wd6YDypKh9bTV4UCk/K17DNpXrGMfJ98pM52f8bPYYzBySi3i7tDLpcrNKbGVl77HgcN4+j/EGRrCjQIQAACEPj/7N0HgJxXee//Z/rsbG/SqlfLtlzk3iu2iW1MJ5h2CYmpwTchAfLPhRDuTQj/JBdyE0K5oQQwoZpiMC4U427jbtmyJdvq0kqr7X13+n2ed3ZWW2bLbJv2PTDW7sxbzvmctTz7m1MQQAABBBBAAAEEEEBgfgKLHk5a9YLnnyrhX6fCyeEnXpCeM9frhjaptQVtSnPlpmVThpOxg8eDGe/a1DTusU2u3LxcWm16rm0Wo2HBwP52sUA0veu1HVuxdfL6kv51yyScyhlHLze4+/i0cNdwtxz8s89NravTuxOxuM7MtjUKZ196dx2VHg1iY+0jm99o+Neqa1w6iWF3amRiZPcROfTN+2XNH18++wvP8khXdb1I52Hn6ETnhDUgM1zDNThST33NsyIVomY4bMGfKtuiU8onlLKTV0vfE6knk70z133i+XyPAAIIIIAAAggggAACCCCAAAIIIJBfAksSTjZcc4o0/+a3Tnjo6mmRjp88OqoQOOfUaUWSw8enlbp0RGSm4qxDOTI9N9Y3LInI8Y1j7Hi3f3IzXRmei/amdopO3cMlSV1zcroS0Z2ix+4+Pt2x6df6dzZL5EGdcp4uahJ5KPV9eoxi8sAuiRzU5HQRwkn38gYNJVPhZLKtWTPc8JTrTvbuPDIu5PWtbczYxEkDyOLzn+6aqX/G7gguseMjC8dWamJdbKp+IZa1a9fKwEBqTdZgMCgeZ6OepS9DQ0OSnr5MPUTGeni9k/9eWfoe4o4IIIAAAggggAACCCCAAAIIFLbAkvx27QR4DWtFdHdmK8m9L46q1V8zfTjpWVEvscOpXb3jbZNHy0X7h50NcdKlXEdh+mvKxXaidiVSzw/pdG1b53JsibVOvlZowzJJR17JslrZ/JWbx52zEN+EdKRn9MxzJbr7oK7leEySoTrxnbhJ4j0DIy4unb58jg5TnD4YnWtdys/aKH07U2t4uhIROfrjx2XNuy/NeLn2Hz50/HkNaqtHdsieOB18+GiP+KtHNqzRM2K6s/Z8S+Ro16RLhFvG7LAdGulPndo/tlhdArXlo0/FF6AukyqyBE/U1taKPXJd8qEOZkA9cv2TwP0RQAABBBBAAAEEEEAAAQQQWByBxUnAMtS17KLju3anX7a1KG0twelK8ITjU7Lje15xRvqNLa13pDfL0dBTd3ceDabqjk8B775Dp02PKYloTKLP75x024oTdHfskdGSruEuGTh0fPMYO9h26N73T7/QjWt+Lof+8/5J58/miZrT1si6P79O3PWp4Ml78mbn+4pLUz62EYx9v+7mP5jN5bI+ZpmFwXWrR8+L3HufHPnJyFzpkWcTOvJx/+fvkOT+XaPHeU47UyrWp0ZO+mqPB5F2QN8LqZGY6YOju/bNql6xcSNVx58y8ODzk64x+PCO4/VZnqqLf0JdBl5sHndedOfs6hLvGTtqdtKteQIBBBBAAAEEEEAAAQQQQAABBBBAYBEElmTkpNW78epT5OAvfqUJ4vEdsoPnTw4sJ7ax8aqt0veLh8TV36ojJIflwCdukeq3XiGBZVXS8/heCf/md6OnhF5zxejXNa+/SHq+cdD53qZJ7/vcL6Xu+rMkruFm148fHl3zcuz9fJVl4j37XIk9+ZgzBf3oP3xXAudvk+qLtoitR9l/92POaEcr7k3zCw8Tnd2pzW9W6hqQWiLNqY14pGr8CM+x9Vuorxs/cJ20/ePXnTbaY+j2u2TPXfeLq2mVJMMRSXYc0VGn0eO385bJqve9avR7b1lAd+2pEImmdpAe1nMP6QhFr46QHbhHd+Me2fwoY31tfdCRka59v3xEorr2ZtnG5ZN24lP41gAAIABJREFU7Xa1H5R9n/mp1L7uXOcyXb98Uuy5dKn/wwudL53Nj7QurpG6DN09Uhf9+Rj83VO6jmdqrdPRE8d+4dZlAvRnykrfHVqXzr6Mdcl4Lk8igAACCCCAAAIIIIAAAggggAACCMxbYMnCSQv+XKs2SnJkirbtANMww5Rua51bpzc3/unrpO3z30lN39awqeer35/UcNfqE2TlG84efb7h0i3S86sTREbul9jxtLTrI11sN27b9GZiWX3TlbJv114NQ9uc1yP33y9t+rAyuiakTlFvev1ZE0/N7vuB1LTl4JpUOBltSX3vaZh+JGl2N8l8dNWJKyT6oXdK19duGw31bAOhdN+M3cM7Wblcmj76JrH+G1t8554h0UdGpn3rubaOZiRtZCMzR9a1nFgD1zLd6KY5tRORBb3h3xyTyImnTwonk/4qSehu6h3/cny0ZPpa7lPOFGtDuvjPP1OiDz2Y+tbqomt4Wl2cMl1dmppEDvU5h1n4Hf7NPRLdMrkuI1fiDwQQQAABBBBAAAEEEEAAAQQQQACBBRZYsmndVu/yS4+vL5msXz3rzWSqdbft1f/4IZE1WzRFmrAxiE7lLnvd9bLxM2+fRLPx724U7znnO+tPjhadtu096zypfMOVk463J2zTlY3/533iPf8iPc8/7hj73qPrRW74zDucEXtzLWHdSCe9TmZobSqMTLSlwklv09KsM1h/3kZZ9/kPinvLaToK8vgajek2JQPV4j3vQtn4LzeNTuce295Vf3SpeE4dH9DaxkT+yy+X2rddMSXNqo/cILJsvfbj2Ah08uGVb7laPGefN66/k56g+K+4QjZ8/LXjTlj17kvEc/rxYNp5UUdo+i+9TGrePk1d/uw1I3VZ0n8NJjeWZxBAAAEEEEAAAQQQQAABBBBAAIESFXD19PTo3N7CKYlYXAZ0g5uoBnzlGxslUKfTi2coSZ263L+nVeJDEanc0pRVsDh0tFuGDnaKV9c2LNcg0RMcH1jOcOuCeXm4vU/6dx0VV8ArVSev1FnbwVnV3Uz797WL7YpdddIKzQRnt6t0PBKV6Mg6j37dwMbO2/3+fx2dbl/5rjfLMl0KwI7re6lFvFqf8vUNmmlOHWrGhsIyuL9DbM3MqhObxO2b3cDgTHWZVeM5CAEEEEAAAQQQQAABBBBAAAEEEEBgXgIFF07Oq7WcnNcCmcLJvK4wlUMAAQQQQAABBBBAAAEEEEAAAQQQmJcA81nnxcfJCCCAAAIIIIAAAggggAACCCCAAAIIIDBXAcLJucpxHgIIIIAAAggggAACCCCAAAIIIIAAAgjMS4Bp3fPi4+SFFIj26o7hidQSqJ6Qbj7kn/umQwtZL66FAAIIIIAAAggggAACCCCAAAIIILA4ArPbMWRx7s1VERgn4KsKIYIAAggggAACCCCAAAIIIIAAAgggUEICTOsuoc6mqQgggAACCCCAAAIIIIAAAggggAACCOSTAOFkPvUGdUEAAQQQQAABBBBAAAEEEEAAAQQQQKCEBAgnS6izaSoCCCCAAAIIIIAAAggggAACCCCAAAL5JEA4mU+9QV0QKEKBWCwm9qAUjgB9Vjh9Nbam9Fvh9Rt9Vnh9ZjWm3+i3whQovFrz71rh9Rl/R9JnhSlArfNBgHAyH3qBOiBQxAIHDh4Qe1AKR8D6az99VjgdNlJT+q3gusz5u5F/1+i3whMozBrz71vh9Rt9Vnh9ZjWm3wqv3+izwuuzYqwxu3UXY6/SJgTyRMA+8d6zb59Tm3Vr14nXy185edI1U1Yj3WcuPWI9fTalU769QL/lW4/MXB/6bGajfDyCfsvHXpm5TvTbzEb5dgR9lm89Mrv60G+zc8qno+izfOqN0q4LIydLu/9pPQKLKmCfwkWjUedhX1PyXyDdZxHtM0Z05X9/pWtIvxVOX9FnhddXY2vMv2uF2X/0W+H1G31WeH1mNabfCq/f6LPC67NirTHhZLH2LO1CIMcC6U/h0tWwEZT2HCV/BSb22T76LH87a0zN6LeC6KZxlaTPCq/PrMb0G/1WmAKFV2v+XSu8PuPvSPqsMAWodT4JEE7mU29QFwSKSCD9KVy6STZ6kpF4+d3BE/uM0ZP53V/p2tFvhdFPY2tJnxVen1mN6Tf6rTAFCq/W/LtWeH3G35H0WWEKUOt8EiCczKfeoC4IFInAxE+8081iJF7+djB9lr99M13N6LfpdPLzNfosP/tlplrRbzMJ5efr9Ft+9st0taLPptPJ39fot/ztm6lqRp9NJcPzuRIgnMyVPPdFoIgFbISkjZScWBiJN1Ekf76nz/KnL7KpCf2WjVZ+HEuf5Uc/ZFsL+i1bsfw4nn7Lj37Iphb0WTZa+XMs/ZY/fTHbmtBns5XiuKUSIJxcKmnug0CJCNincDZCcqrC6MmpZHL3PH2WO/v53Jl+m49ebs6lz3LjPt+70m/zFczN+fRbbtznc1f6bD56uTuXfsud/VzvTJ/NVY7zFlOAcHIxdbk2AiUoYJ/C2QjJqQqjJ6eSyd3z9Fnu7OdzZ/ptPnq5OZc+y437fO9Kv81XMDfn02+5cZ/PXemz+ejl7lz6LXf2c70zfTZXOc5bTAHCycXU5doIlJjATJ/CpTkYPZk/Pxj0Wf70RTY1od+y0cqPY+mz/OiHbGtBv2Urlh/H02/50Q/Z1II+y0Yrf46l3/KnL2ZbE/pstlIct9QChJNLLc79EChigZk+hUs3ndGT+fNDQJ/lT19kUxP6LRut/DiWPsuPfsi2FvRbtmL5cTz9lh/9kE0t6LNstPLnWPotf/pitjWhz2YrxXFLLUA4udTi3A+BIhWY7adw6eYzejL3Pwj0We77YC41oN/mopbbc+iz3PrP9e7021zlcnse/ZZb/7ncnT6bi1ruz6Hfct8H2daAPstWjOOXUoBwcim1uRcCRSww20/h0gSMnsz9DwN9lvs+mEsN6Le5qOX2HPost/5zvTv9Nle53J5Hv+XWfy53p8/mopb7c+i33PdBtjWgz7IV4/ilFCCcXEpt7oVAkQpk+ylcmoHRk7n7gaDPcmc/nzvTb/PRy8259Flu3Od7V/ptvoK5OZ9+y437fO5Kn81HL3fn0m+5s5/rnemzucpx3lIJeJfqRtwHAQSKV+Boy1FxezwS1MfYMjw8PO77YDA4CcHOXbN6zaTneWJxBeizxfVdrKvTb4slu3jXPdZ6jL8fF4930a7Mv2uLRruoF55Pv9m/q6tWrlrU+nHxyQLz6TPeQ072XKpn6Lelkl64+9BnC2fJlRZHwNXT05NcnEtzVQQQKHWBO+6+axzBa669rtRJ8r799Fned1HGCtJvGVny+kn6LK+7Z8rK0W9T0uT1C/RbXndPxsrRZxlZ8v5J+i3vu2hSBemzSSQ8kSMBpnXnCJ7bIoAAAggggAACCCCAAAIIIIAAAgggUOoChJOl/hNA+xFAAAEEEEAAAQQQQAABBBBAAAEEEMiRAOFkjuC5LQIIIIAAAggggAACCCCAAAIIIIAAAqUuQDhZ6j8BtB8BBBBAAAEEEEAAAQQQQAABBBBAAIEcCRBO5gie2yKAAAIIIIAAAggggAACCCCAAAIIIFDqAoSTpf4TQPsRQAABBBBAAAEEEEAAAQQQQAABBBDIkQDhZI7guS0CCCCAAAIIIIAAAggggAACCCCAAAKlLkA4Weo/AbQfAQQQQAABBBBAAAEEEEAAAQQQQACBHAkQTuYIntsigAACCCCAAAIIIIAAAggggAACCCBQ6gKEk6X+E0D7EUAAAQQQQAABBBBAAAEEEEAAAQQQyJEA4WSO4LktAggggAACCCCAAAIIIIAAAggggAACpS5AOFnqPwG0HwEEEEAAAQQQQAABBBBAAAEEEEAAgRwJEE7mCJ7bIoAAAggggAACCCCAAAIIIIAAAgggUOoChJOl/hNA+xFAAAEEEEAAAQQQQAABBBBAAAEEEMiRAOFkjuC5LQIIIIAAAggggAACCCCAAAIIIIAAAqUuQDhZ6j8BtB8BBBBAAAEEEEAAAQQQQAABBBBAAIEcCRBO5gie2yKAAAIIIIAAAggggAACCCCAAAIIIFDqAoSTpf4TQPsRQAABBBBAAAEEEEAAAQQQQAABBBDIkQDhZI7guS0CCCCAAAIIIIAAAggggAACCCCAAAKlLkA4Weo/AbQfAQQQQAABBBBAAAEEEEAAAQQQQACBHAkQTuYIntsigAACCCCAAAIIIIAAAggggAACCCBQ6gKEk6X+E0D7EUAAAQQQQAABBBBAAAEEEEAAAQQQyJEA4WSO4LktAggggAACCCCAAAIIIIAAAggggAACpS5AOFnqPwG0HwEEEEAAAQQQQAABBBBAAAEEEEAAgRwJEE7mCJ7bIoAAAggggAACCCCAAAIIIIAAAgggUOoChJOl/hNA+xFAAAEEEEAAAQQQQAABBBBAAAEEEMiRAOFkjuC5LQIIIIAAAggggAACCCCAAAIIIIAAAqUuQDhZ6j8BtB8BBBBAAAEEEEAAAQQQQAABBBBAAIEcCRBO5gie2yKAAAIIIIAAAggggAACCCCAAAIIIFDqAoSTpf4TQPsRQAABBBBAAAEEEEAAAQQQQAABBBDIkQDhZI7guS0CCCCAAAIIIIAAAggggAACCCCAAAKlLkA4Weo/AbQfAQQQQAABBBBAAAEEEEAAAQQQQACBHAkQTuYIntsigAACCCCAAAIIIIAAAggggAACCCBQ6gKEk6X+E0D7EUAAAQQQQAABBBBAAAEEEEAAAQQQyJEA4WSO4LktAggggAACCCCAAAIIIIAAAggggAACpS5AOFnqPwG0HwEEEEAAAQQQQAABBBBAAAEEEEAAgRwJEE7mCJ7bIoAAAggggAACCCCAAAIIIIAAAgggUOoCrp6enmSpI9B+BApBIBGLSLyvRWL9RyUx0C6JwS5JDHdLMtKvf/ZLMjokydiw/jksEo/p11GRRFyS9ognxJXUf9UTCUk6f9q/9voY+UOfHE8w8ftCAKKOCCCAAAIIIIAAAggggAACuRdwucbXwb63p5yn9R9ul7jsObdbkvqnS/90eTz6vUdcXp+IxysuX1C/DuifIXEFysUdqBR3sFrcoTpxlzeIt2KFeCqbxO3157691GDeAt55X4ELIIDAggpYmBhpe0kiLc9LtG2XxDsPS7y3XWQoomHi3D9LmPuZC9o8LoYAAggggAACCCCAAAIIIFDMAhN/b534vbZ97O+n6TEzWZNYwFnmF09Vg3jqVouv8STxN50m/sYTNfDUsJNSMAKMnCyYrqKixSqQiEcl3PyUhA8+JtHm7RJvb9WRj4nJzdW/eN1lPvGEysRTrp8cBUPiCVboJ0hlztdu+2TJF9A/9dMlj18/QfI5nzq53Pqpk33yZJ9EufQTKfs0ypX6Wr/Q/+vqDs4nWalPt5xPsFIfaY0+N7kyPIMAAggggAACCCCAAAIIIIDAGIHREDKZmrFnL9lz+kgm9Xdc52ubzaez++x7Z5afPXTmn32tswUTOgMwGdc/o2GdFRjWP4d1puCQJMKDEtcZg4lh/XNgQOJD+tygzhbMEHyKxy2exuXiW7VNAmvPl8DKs3RQpo7IpOStAOFk3nYNFStmgUS4TwZ23SmRfQ9LpHmvuCaEkZ6KgH7qs0wCjavFX79K/HUrxVfVyKc/xfxDQdsQQAABBBBAAAEEEEAAAQRmLWCBZrS3TSKdRyTS0Szh1kMSbW+TeH943DWSGlb6V20U/4aLpfyk650p4pT8EiCczK/+oDZFLhA++rwMPPt9iex9btzoSE9NSIKr1knZ6pMktPpkZ0QkBQEEEEAAAQQQQAABBBBAAAEEshOID/fJ4OFdMqSP4eYDEu8ePH4BCyo3ni7lZ7xdAitOy+7CHL1oAoSTi0bLhRE4LjC0/yHpf/zbEm9pTj2pM6f9TfVSvnmblG88S3wVdXAhgAACCCCAAAIIIIAAAggggMACC0T7O2Rg7zMysHu77u3QMbrgpadplVSc90dStv6SBb4jl8tWgHAyWzGORyALgeHmZ6Tv4S9pKHnEOcvl8+gw8pOl+vRXib+mKYsrcSgCCCCAAAIIIIAAAggggAACCMxHINLdIj3P/U6XWdupa1rGnUt5mlZI5cU362zGM+dzac6dhwDh5DzwOBWBqQRiA+3S+8C/SOSVZ51DXAGvVJ5+ttRsu1o8gfKpTuN5BBBAAAEEEEAAAQQQQAABBBBYZAHbYKdr+2+k77mnJBmOOXfzn7BNqi79S/FWNC7y3bn8RAHCyYkifI/APAX6nv+JDDz8bZGI/gXndknladuk9tzXEErO05XTEUAAAQQQQAABBBBAAAEEEFhIgXh4QLqevEP6nh/ZF8LnlfJL/kh/j3/zQt6Ga80gQDg5AxAvIzBbgfhgp3T/+n9K9OBu55TA6mXScPnbmL49W0COQwABBBBAAAEEEEAAAQQQQCAHAjbdu/3+H0j4cKtzd+/aTVL76v8lnhD7QyxFdxBOLoUy9yh6geHDT0n33f8gMjgsLr9Hai+6WqpPubzo200DEUAAAQQQQAABBBBAAAEEECgWgZ4XHpCuR34jyYiuRxkKSM21fyPB1WcXS/Pyth2Ek3nbNVSsUAT6tv9QBh64RXf8SoqvsVqWX/de8VXWF0r1qScCCCCAAAIIIIAAAggggAACCIwIRPs65Nhd35BoW7duIOGS8sveLZXbbsRnEQUIJxcRl0sXv0DXff8s4efucxpafupWabz07eJye4q/4bQQAQQQQAABBBBAAAEEEEAAgSIVSCbi0vbg92Vgx4tOCwOnXyG1V/xVkbY2980inMx9H1CDAhRIJhLS9eu/lcjLTzufpNRceKnUnnltAbaEKiOAAAIIIIAAAggggAACCCCAQCaBrmfulu5HH3RmSvq3nKXrUP6dDkhyZzqU5+YhQDg5DzxOLU0BCyY77/wrie7VT1A8Lqm/8gapOvHC0sSg1QgggAACCCCAAAIIIIAAAggUsUDvS49Kx72/FInrUm6bTpG66/6JgHKB+5u4d4FBuVxxCyT10xIbMWnBpMvnkWXXv51gsri7nNYhgAACCCCAAAIIIIAAAgiUsIANRrLf/S0DiO55wckEKAsrQDi5sJ5crcgFuu//36mp3DpisvHaG6V87alF3mKahwACCCCAAAIIIIAAAggggEBpC9jv/pYB2OxJW97N9p+gLJwA4eTCWXKlIhewXbmdzW90jUmbyk0wWeQdTvMQQAABBBBAAAEEEEAAAQQQGBGwDMCyAMsELBuwjICyMAKEkwvjyFWKXGD48FMy8MAtTitt8xvWmCzyDqd5CCCAAAIIIIAAAggggAACCEwQsCyg5oJLnGctIxhu1k1yKfMWIJycNyEXKHaB+GCndN/9GWd3ropTT2FX7mLvcNqHAAIIIIAAAggggAACCCCAwBQCtWddJ+WnbnUygu67PiPxwa4pjuTp2QqwW/dspTiuZAXab/vvEju4R3yNNbLqLR/VXbk8JWtBwxFAAAEEEDCBv//8bdLbO5QRw+/3yoqmWlnVVCOrV9bJhnWN0lBXmfFYe/JIS7f8n6/cJaefslb+21svnvK4hXohHInJ3/zDrbJqZb185AOvHr3s93/6e3l6+z65+X3XyLrVDaPP/93nbpO+vsxtTR9UVuaXqooyWb6sWi489wTZvGFZxuo+/vReufXnj2V8baYnP/s3bxWfLsQf0fp/Uus/U3G7XVJXWykN9RVy1unr5YxT1+osNNfoaT+5/Qn5/ZO7Z7rMlK8Hgz75+//xlilf5wUEEEAAAQSKWSCZiEvzjz8n0bYe8a3dLPVv+EIxN3fR2+Zd9DtwAwQKWKDv+R87waTL75Hl191EMFnAfUnVEUAAAQQWTqBHg8nunkFZqQGk2318Ik4sFpPOrgE51tYrzz5/wLmhx+OWP7jyNHntH5zphGsTSywely69Vv/A8MSX5vz9vQ/tlD37j8kbrj87YzBq96usLBt3/YHBsFOPWCwx7nlrZ6+GkxPbOvagAa17S2uP7Np9VO5/ZJds1ED2Ix+8VkIaWo4t4XDUuUd5eUBqq8vn1L6knmXXsJxx1Yq6Ka9hfbH/UJu8srdFHn1itx5bKze/92pprK9yzgkEvFqPYMbzh4Yi0tHVLxa61tdWZDwmoCE0BQEEEEAAgVIVsEFLy697rzT/4F8lenC39O/4qc60fFOpcsy73byrmDchFyhWgVh/mww8lFpnsvaia8RXWV+sTaVdCCCAAAIIzEngLz90ndRUhyad29c/LO2dffLiS81y12+3y536ePq5fXLTu66QDWsbJx2/0E+8vKdFnnhmr1x9+akZw8m53O9jH75eqiYEmmOvk0gk5dkdB+Rndzwpew+0yb/9x6/k4ze/RrzeyasonXnqOnnP2y+dSzVGzwn4ffI//+qN014jqdPN9h9qlx/oqNA9+1vli1//rXziL14nFize8OoznUemYnb/8e17ZeuWlfKhP74q0yE8hwACCCCAQMkLWEZQe9HV0nnfr6T/oW9JcMNl4i0/Pvui5IGyAJj8bimLkzkUgWIW6H3wX0SiMQmsXi7Vp1xWzE2lbQgggAACCCyoQGVF0AkhX3PNGfIPn/xDuei8E3RkYa985T/vcaYljy2rdfTfv332XfIn77x8Qesw1cUsmLP7WXC4kMWmUdv0aQtsbWSkhYEWUuay2DRu6wdra9OyKmk+2iX3P7wrl1Xi3ggggAACCBSVQPUpl0tglS7nou9veh/QDIEyJwHCyTmxcVKxC9iOW5FXtutcNLc0XH5jsTeX9iGAAAIIILBoAtVVIfmTd1wmJ52wUjq7B+Q39+8Ydy8L9cpDAWc031IVu1+Zrpm4GKW2plzOO3Ojc+ndOqU6H4qN3rzuqm1OVfYdzG1gmg8e1AEBBBBAAIGFFGi44m0i+n4m8sqzMnzk2YW8dMlci3CyZLqahmYj0Pfwl5zDK087Xfw1TdmcyrEIIIAAAgggkEHgbW8831kn8a7fPues4Zgu8XhCenoHZVDXOcxUbLr0rleOiq0jedudT8l9D+90vrcpy2OLrRVp17FHNBZ3XrJ1LNPPpdeStPPsuf6BcKbbLchzK5bXONfp6hlYkOstxEVWr0otT3OkpXMhLsc1EEAAAQQQQGBEwDKDytNSHwL2PZTKEsDJTmDpPqLOrl4cjUDOBIb2PyjxlqPi0oXia89Z2ClfOWsUN0YAAQQQQCDHArZz93lnbZLHntoj23cclEsvPNGpUXNLl/zd/75Nzt62ftL6ho8/vUdsV+kO3WRnYlmzqk7e9YcXy6b1qZ2xd77SrOs8/nrcYf/6f381+v1ffOhaOeXEVRKJxuWjf/t9Wbu6Xv72Y2+YeNkF+b5LR4haSYeUC3LReV7ENuOxUhEavxHQPC/L6QgggAACCCCgArXnvkb6d+3QLKFZhg48LGXrLsYlCwHCySywOLQ0BPof/7bT0MrTzxZPYG47aZaGFK1EAAEEEEAgO4G1OnrPwsnW9t4ZT7Tjvv5f9zm7Rd+k61GedMIKCQb90tbRKw8/9oozgvILX/u1fOqjr3c2vWlaVi1vvuFc57qPPb1bDh/pkqsu3aob9qT+W768MbVL9Yw3nucBNiLz90/udqaNWxibL+Ul3Uncyro1bPCXL31CPRBAAAEEikfAsgPLEHqfeEz6H/sW4WSWXUs4mSUYhxe3QPjoc/pJxxFx+TxSu+2a4m4srUMAAQQQQGCJBerrKpw7tnf2z3jnu+7ZLrYe5f/3ZzeIreOYLhZwrn1TvRNGfvfHj+jIyiflA390pTTWV8l1V5/uHHawucMJJy/UjXjWr1m6XTNf0N3Jb/3549Kj09bf+67LpUI3xsmHYhvh2K7pHl1L+6rLT8mHKlEHBBBAAAEEik6gZtvV0vfsk87oyfDR5yWw4rSia+NiNYhwcrFkuW5BCgw8+wOn3uUnbRV3IFSQbaDSCCCAAAII5KtAQ32lUzUb/ThdGRqOOjtLr9EgcmwwOfacyy86SYPJx+WVPUuz6cxXvvk7J9zLVPoHhqRDA1er9yknrZa3v+lCOXHz1GtW2yjGr95yb6ZLZXzuhlefISubajO+NtWTtlanjVB9avs+J5iM6/c2AtVGolIQQAABBBBAYOEFbPRk+UknS//zO2Tg2e8TTmZBTDiZBRaHFrdAItwnkb3Piehi/dWnX1ncjaV1CCCAAAII5ECgRnfuttLdMzjt3W3nbp/XI8dae5yNazKNQLRRlX960zUyNBQWC+Ls+8Us+w626oY+me8R1XUs0+WorqH5pAaCq1bUZqy3HdfW0ec8Zlsuu/AkDSfHHz2sa0h+8GPfnPISttGQ7Rnk8bjk/LM3y5WXnCwb1jZOeTwvIIAAAggggMD8BapPf5X079ghkX3PiWUM7kDqg9n5X7m4r0A4Wdz9S+uyEBjYdafosALxr6hnh+4s3DgUAQQQQACB2Qr09qd26a6qnH5TFgsaz9q2wVm78R//7XZ5y+vOk9O3rpkUQG7dsnK2t573cf/86bfJVPWORGLSrTuAHzjULr97cKfc++CL8tyOA/KXf3qdLG+snnTvC8/dLO9480WTnp/qCQtrJxbLSTdvmHp0poWTh492angbkb37W2WVjrwknJyoyPcIIIAAAggsrIDt3O1vqpfI0Q6xjKFy240Le4MivdrkdzpF2lCahcBMApF9DzuHlG/eNtOhvI4AAggggAACcxBoHxktaBvYzFT+21svlnA4Js88v1+++PXfSCjklxM2Nsmmdctky+YVsnFd46SwcqZrLtbrfg0PlzVUOY9zz9woP7rtMfn1fTvkv259VD76p9dOuq3H7XY2zJlPCfh98rEPXzftJZI6dPJgc6fuYv4rufUXj0tf/7AGvalNg6Y9kRcRQAABBBBAYM4ClilEjv5OR09qxkA4OSvHzAvnzOpUDkKgeAQSsYhEmvc6DSrfeFav0RwnAAAgAElEQVTxNIyWIIAAAgggkEcCnV0DTm0aR9aenK5qNlrwwzddJZ/4i9fJ1ZdtlaqKoGzfcVB+eseTzmjKP//kf8kv7n5abNRivhUb6VlbHZKdLzc7a2fmqtg09HWr6+W/vy+1yd89D77gTJOnIIAAAggggMDiCaQzBcsYEvHo4t2oiK7MyMki6kyaMneB8JGnxaXTnzw1IfFV1M39QpyJAAIIIIAAAlMKHNH1GK00Nsw8cjJ9ERshaQ8rA4Nh2b3vmDz3wiFnyvcv7n7GGRn44T+5asr1IKeszCK+YNPSN+gIz67n9ou12dafzGWx6dyrV9bpDuad6tciZ5y6LpfV4d4IIIAAAggUtYBlCpYtxLsHJdz8lJStvaCo27sQjWPk5EIoco2CFwgffMxpQ3AVb9YLvjNpAAIIIIBAXgrYDt2PaqDo9bp1R+tVc6pjeSgg205ZKzbl+///1Ft1k5gaefb5A/Lci4fmdL3FPMk2o7EyrDt450M56YQVTjXa2me/EU8+1Js6IIAAAgggUIgC6WwhnTUUYhuWss6Ek0upzb3yViDavN2pW9nqk/K2jlQMAQQQQACBQha49edPiO1q/apLt+q07qppm3L7r56Rj3/6+/LCS81THmeb01z7qtOd13fvPTblcbl6Yb/u7m2lUdehzIdSX1vhVMNGn1IQQAABBBBAYHEF0tlCOmtY3LsV/tUJJwu/D2nBPAWSibjE21O/QIRWnzzPq3E6AggggAACCIwVsDUhb7vzKXlapzhX6LqRr/2Dmdd2tmnQXT2D8vwMIyITidTwRBtRmamkX8/02mI+99DvX3bqX6nt3bxh2WLeatbXTu80brt3UxBAAAEEEEBgcQVCIwOfLGuwzIEyvQBrTk7vw6slIBBte0nE1pusCIgnmBpVUALNpokIIIAAAggsqkBP76BuCHNEfnL7E6NB3Z+887JZ7VJ9ou7GXVbml3sfelHO3rZBd+lePqmuQzpd+t6HX3Se3zphmnhFeSqsbGvvHV2vctIFFuGJ3r4heeDRXc5amFbe8tpzdRq7ZxHulP0lLRi20qN1pCCAAAIIIIDA4gp4gpVOxhDvD4tlDv7lWxf3hgV+dcLJAu9Aqj9/gXDL885FfI35MbJh/i3iCggggAACCCyNwDe++4CzhmS6xGIJ6erul46ufmcKd7pccM5medsbL5B0aDhT7Wwk5Hvfdbl88eu/kc996Q659IIT5YzT1klDXaUMDUfklT3H5D4NJlt1/cRXX3GqrF1VP+6SK5tSG9D88LbH5Fhbj5SHgrLt1DXO+XMtX/vO/ePaOvY6YQ1Ke/sHpa2jX+L6gaeZvPMtF8vF52/JeLsXdh2Wf/vqrzO+NtWT73jzBTNOh5/qXHu+WqfBW2k+2jndYbyGAAIIIIAAAgskYBlDvP+QWOZAODk9KuHk9D68WgIC0bZdTisDjatLoLU0EQEEEEAAgYUT2Pny5DUhfT6PrFhe4+xQvXpFnWzSac2bN0we+ThTLWzjm4988FpnSvh9D+9yHmPLMt3x+x1vvtBZw3JiuURDQRu1+czz+0dHMTYtr55XOJmpren7lgV9UlMdki2bVshpJ6+WC8/d7EzpnqrYlG97ZFOGXnN2NodPOrZpWbUzGvXosR45cLhd1q1umHQMTyCAAAIIIIDAwglYxjC875COnBz/Hmbh7lA8V3L19PSM7CVYPI2iJQhkI9D2o/dJvKVZGq97i1RsnHkdrGyuzbEIIIAAAgggMH8BG/3Y1tEn3d2DEgr5paG+ctJoyUx3sZGcPX2pELC6MjTlyMdM5/IcAggggAACCCAwH4H+vU9L210/Fk/TKml869fmc6miP5eRk0XfxTRwJoF4b7tziL9u5UyH8joCCCCAAAII5EBgeWO12CPbYtOr07tUZ3suxyOAAAIIIIAAAvMRSGcM6cxhPtcq9nPZrbvYe5j2TSuQiOmOlbZrpcslvqrGaY/lRQQQQAABBBBAAAEEEEAAAQQQQGA2Ak7GoFmDZQ5O9kCZUoBwckoaXigFgXjfUZFkUtwhn7jc+bGbZim400YEEEAAAQQQQAABBBBAAAEEilnAMgZ3mc/JHOJ9LcXc1Hm3jXBy3oRcoJAFYv2pvyA8odQOloXcFuqOAAIIIIAAAggggAACCCCAAAL5I5DOGmL9OjCKMqUA4eSUNLxQCgKJgdR6k55QeSk0lzYigAACCCCAAAIIIIAAAggggMASCXjKU1lDOntYotsW3G0IJwuuy6jwQgokBjudy7mDhJML6cq1EEAAAQQQQAABBBBAAAEEECh1AXcw5BAkBrtKnWLa9hNOTsvDi8UuEB/qdproKSOcLPa+pn0IIIAAAggggAACCCCAAAIILKWAJ1jh3C4xnMoelvLehXQvwslC6i3quuACyUi/c023P/VpxoLfgAsigAACCCCAAAIIIIAAAggggEBJCrgDqf0t0tlDSSLMotGEk7NA4pDiFUiGR8LJIBviFG8v0zIEEEAAAQQQQAABBBBAAAEEll5gdFr3cCp7WPoaFMYdCScLo5+o5SIJJKNDzpXdvuAi3YHLIoAAAggggAACCCCAAAIIIIBAKQqks4Z09lCKBrNpM+HkbJQ4pmgFktFhp20uX6Bo20jDEEAAAQQQQAABBBBAAAEEEEBg6QXSWUMylsoelr4GhXFHwsnC6CdquUgCiWjYubKbcHKRhLksAggggAACCCCAAAIIIIAAAqUpkM4a0gOjSlNh5lYTTs5sxBFFLOCKR53WuTz+Im4lTUMAAQQQQAABBBBAAAEEEEAAgaUWGM0a4rGlvnVB3c9bULWlsggssEBy5C8It49wcoFpuRwCCCCAAAIFLxCJJGRosEv27N4pEj0mjVVhqa4ISyTcI/5ArfQMlUl7j0+CFetl9doN4vdXSSDAZ/8F3/E0AAEEEEAAgQUScHt9zpWSsdTAqAW6bNFdhnCy6LqUBmUlkIg7h7s8qb8wsjqXgxFAAAEEEECgKAV6+yIy3LdPOlq2y/Ladjnj5Ii+WYhLIpqQRCwpZVUukUSr/imyaq1bkvGD0tf1hOzvapC65dskVLVOykO8zS7KHw4ahQACCCCAQBYCrpFwUkayhyxOLalDeddUUt1NYycKJOPpcJJ/FSba8D0CCCCAAAKlKNDWclTCg49IjX+/1G9OaiCZlOhAUik0kNT/2z+SiREZ/dMCS3GFpbw8Iptre6W3U0PN5i0yUHGOLFuxohQJaTMCCCCAAAIIjAi43KmsIUk4Oe3PBInMtDy8WOwC6b8gXG5PsTeV9iGAAAIIIIBABoFkMikul0u6Ovult/UBqQi+KCuXuySuU7pjqX3zNHx0UsnMZSSwTFhQOZyUyuqkVPt2S+exl+XI3nOlrPYcqa0NSfo+mS/CswgggAACCCBQjAIuz0g4GU9/slmMrZx/mwgn52/IFQpYwJVIijMWYuQvjAJuClVHAAEEEEAAgSwE0mGhBZOHDzdLefwhWd5wUDxul0QH5/4LhO21l9B1paprXZJIPi693a1yeOASWb26yQkordg9KQgggAACCCBQ/AIuT2oglGvkPUDxt3huLWTF7rm5cVaxCKT/gnDzr0KxdCntQAABBBBAYCaBdEhoxx0+dECCsV9IRcVBcWt2mIinAsSZrjHd68mkBpO6Kad9CFpTs1/8sZ/LkSOthJLTofEaAggggAACxSiQnqVpUywoUwqQyExJwwulIHB8BAPTukuhv2kjAggggAACY0cvNh/SEZOeu6Ru2ZDY7wyp+RQLZ2SfgdoGOg0N/RLp0YCyORVQJjS0pCCAAAIIIIBA8Qu4XKnYbewHo8Xf6uxbSDiZvRlnFJPAyC8H6b8wiqlptAUBBBBAAAEEJgtYYGjTqg8dOiSVvrt1jUkNDvt1mKNTFmO6tW6oM5SQ1St7xBP9uRw92i5unTpuv6Twi8rk/uEZBBBAAAEEiknA5RoZCMUHk9N2K+HktDy8WOwCo78UjHyaUeztpX0IIIAAAgiUqkA6DLRgsLOzV0KJByQU7HamcU9cAtK+t4et+mKzsdxel3h8Iw+/S7xBfQT0e/3anrfXnYcdO+nddSrwjEeSUq+7ebsGfyNt7X2jU7wJKEv1J5J2I4AAAgiUhMBo1sCsien6mw1xptPhtaIXGB0fQThZ9H1NAxFAAAEEELARk8PDMRnquEca649KTANDl8vZGm80ZLTBk4loUoYH49Kvj0F9DAzFJKy7d9tjSEdBRmIJJ4QsC7glGPRI0O+RMv2zIqSPCq+EKjxOWJm0Hbz1nHjcws6kXjehU7yPSnf3I5Ks+wNxaVBqxQJKNsnh5xMBBBBAAIEiFEhnDWST03Yu4eS0PLxY9AIjf0HwC0HR9zQNRAABBBAoYYH06ET78+ihZ6SharezYY1H3wm7PG5x6+jHSDipu3YPy6GDA/LSy/2y+8CgHDgclqOtYWlpG5KWY4MSiaanf4/F9EjT8qA01IVkdVNANq4NyilbKuTEkypl04YKaar3iQ2mjIcTTggZj8bFH3hejhzeJKvWbta1LpPONG8KAggggAACCBSfwGjWQDg5becSTk7Lw4tFL5DerXvifK6ibzgNRAABBBBAoLQE7JeDnq4OqSt7VCrr9C2w/pJwTMPI+x7pkN8/0yU7X+qT5mPD0tI6LD194Sxw4hpcDjiPHTvTp7mkodYvq1aEZNP6Crnsgnp507XLpWltmUQH4hLS2w/0/k56uhukqrqagDILbQ5FAAEEEECgoATSnz+ms4eCqvzSVZZwcumsuVM+CxBO5nPvUDcEEEAAAQTmJWCjEyORuHS2PijL64blnt92y+33tMkjj3fIkWN90tqm867FHgtVktLeFXYe21/skt8+0CLf/tFBue7qFfKuN66Q1SvKZPnKftl/UIPSqus0nIzr6MmRBfMXqgpcBwEEEEAAAQRyL8AScrPqA8LJWTFxULELMK272HuY9iGAAAIIlKpAPJ4Qj07dbj/2iqxZcUg+/U+vyJe/vU/XnoxLPKGLQk5ZPFJXrWtJ6jqSQd0AJ6jrS1aUlenakm7x+d3ORjrDup6krUc5MDA8uh5lW8fkoLO3PyrP7OjUoLJbvv3D3fKHN6yX979rjaxauUcOH9wva9evd0ZPpjbiYYr3lF3CCwgggAACCCBQlAKEk0XZrTQKAQQQQAABBBBAIL3WZN9AWOIDj4i7KSLnnlUvlT/ZL8OTZm57ZMXygKxYFtLp2D7ZrNOxt2yslHWryjTUDEpdjU/KNaj06fqUYmtE6vQsHfAoQ8MJ6eyO6LqUYdm9f1BefKVPXnipVw41D8nL+wYkFju+TmVSd8g5cjQs//q1l/R8l3zmb8vE3fGUDA6t1PDTR4chgAACCCCAQJEJMBBqdh1KODk7J44qVoHRdR8YpVCsXUy7EEAAAQRKU8CCSfvPvI2aPLLvWVm/ulPCfQm5+rI6OeXEOrnnwRaFcclW/fqCs6r1USNbt1bJutVl0lirb5E1gEzq6MikBpBJHdVoa1Ta9WwHbud7O1vfPoTK3FJeHpS1a8rk/HNqdIMdO0/k4LGwvPhir9z3cIf85sFWefGlntSu3HreSg1B3/yGJnHFXFJTs19aDu2UjVu2Oa+zc3dp/rzSagQQQACBYhUYyRpYc3LaDiacnJaHF0tGgDUnS6araSgCCCCAQPELpEdM2n/eW9t6pa5il7h0CrdLM8XySq+84boVUl3p1z+XyZkaSDY1BqSiypsKFjV4jOvO3TbNeqaS/j3DwkjRIDNVdPdtDSjXrQjoo1GuPL9O3veONfKzu4/Jd396SF7e2ydXXrxCzj6tSpKRpI6YFCnz7ZCBwa06ZVzr4AzKtCnefHA6kz+vI4AAAgggkPcC/Pd8Vl1EODkrJg5CAAEEEEAAAQQQKCQBCw7dOvpxuGe/1Fa3SVxnV3vcujFOf1ze/eaV8u4bV0tAp2jHdd1IGwkZ0+nZqWKh4JhgMqtfKmxopUgipuHmyGxur+5zs0F36f7YzRvk7XrfH/70iFxxaYMelAohEzp6sjx4TKKDHTptvMkJJikIIIAAAggggEApCRBOllJv01YEEEAAAQQQQKDIBY6POtQNa3TTm4rgLinzuyQRTYWB1ny3TucWDRCjUR1NaV97ysVTVqkjJ1eLy+3TYPGwJCI9eky/hoWaIs4moLTRjs61QuL2N4jLu0y/8+i1WiUZ65D4YK806bqVH3n/Bme6uIWizjxxPaW8IikHjmyXypplmm0mxWuJJgUBBBBAAAEEECgRAcLJEulomokAAggggAACCJSCQHo6tP051N+pQeAhZyRjajRkaqq0M3VaR0t6Ak3iq3mzZpNnapi4fFwImYx1SWL4BYn23KkZ5fNOiDj2GuMs7VplK8Rb/Sbxlp8hLt+KcS8nY90SH9ousZ5f6LVeSmWdVgmnIjojPKrTu+VlGRw4X6eXV5dCN9FGBBBAAAEEEEBgVIBwkh8GBBBAAAEEEEAAgaISiMdTU7T7+16WFXU2ajK10YwljE54qWGit+IMCSy7WYPEpoxtd3lrxVNxibhDZ4m7/RYnpLTznZGUqaRS/7Rp3C4NJS+QQMN7p7lWjXgrL9dBlWfq7tzflkj3b/VcW6jSLqX10/ouXxmXPc0vyQlV5+kO33FGT6Z0+CcCCCCAAAIIlICAuwTaSBMRQAABBBBAAAEESkjApnYPD0VkqG+XEyamNrdJBZPOiMmKsyTQ9D+mDBPHUrncIfEve7/46t7irBPpctmU65F1IfUPb/nJElj+8dldy1Ol17pZ/HVvGrmEDcccmQ6ejIkvtl/XxmTNyRL6UaWpCCCAAAIIIKAChJP8GCCAAAIIIIAAAggUjYAFkbZm49BgmzTV9el6j7YxjoaKGlhaMOkONDoBoUvXmRwNGWdsvUv89e8Sd/mpOk08nlpbUv/p9tWIf/lHdZ1K3XLbCSynCxaPTy33179NvGVrnbDTRl7aSMzIUEJWLO+U1vZ2p/7WDjbHmbFjOAABBBBAAAEEikCAcLIIOpEmIIAAAggggAACCKQEbEp0XDecOdr8olTW667ZI7tfJ122DY6GjLU3aqjYqAdbWJhag3J2dm6duv1uDTWDepqOntTr+uvfrdfStSqdlNHKdNdLv6b3dQXE1/BBvYxeR+tl5yc0pHT7B6WrdY9zpeMb+6SuzD8RQAABBBBAAIFiFSCcLNaepV0IIIAAAggggEAJCqR2uk5Khe+YxCI2yjEV9DkjFD1luu7jOWNUjo9OtDDQHnfeeafccMMNcvXVV8s///M/S29vrx6va03q/9yBjXr+yTp6MqYb6FTp9PALRq5la1Gmvty7d69861vfkttuu036+/udJ4+PgEyNkrTnPKFT9Xqr9EXdMVwDSo+uPWmjO6sDh5xz0hv7ON9QEEAAAQQQQACBIhZgQ5wi7lyahgACCCCAAAIIlIpAKly0KdwuaTnWLssb+iQeSYhbQ79UcBjXkYmVujZknTPqMbVlduqPRMICQpfceuutcvPNN0tbW5vD9vDDD8tLL70k//Ef/yEemxvu9os7eKpI79PiCW7UQY8hvVZM4gkdlan3/eEPfiCf/OQnpV2nZvt8PjnjjDPky1/+smzZsmXCSEjbDMej19gm8cGD+ppb3J6ExKIJqa7tkcPNnbJ6VZ0ztTu1qfd0IzJLpYdpJwIIIIAAAggUq8CijJyMRCIyMDAw7hEOh6c0tDeEE48fGhqa8viFesHqlL7vdPWbzf2svulrRaPR2ZzCMQgggAACCCCAAAILJGDhYnqEYvuxwxr8RTQ0TF086azrqNmid73+U7+2xG9MsfeifX19TghpwaTXm/r8fnh4WO6++255/vnnNXx0pyaCO7t76yhHr04N1xGPlnNaIHqk+bD8zd/8jdjISRtt2dXVJffcc4/8/d//vUz13tDlTAkfKS5bE1N37pY+GehNhaPjKsk3CCCAAAIIIIBAkQosysjJBx980JnKMracdNJJ8uEPfzgj4wsvvCBf/epXx73W0NAgn/70pzMev1BP/u53v3Om7ljZunWrfOhDH5rzpT/72c9Kd3e3c/5NN93kfFI+m2Jvhr/4xS/qJ+MJecc73iHLli2Tu+66y/mU/pxzzpFLLrlkyss89thj8uijjzqvv+1tb5OmJnuzTEEAAQQQQAABBEpTID0V2u/qVACdep2a1K1f23qTGv65fBlhPLr2owWIhw6lplSnQ057vrW1dfQ9nkWabr1G0hnOaG+jNUzU4NOj4eSTTz7lBJvBYFAs1LT3dlZ27NghR44ckbVr146Gp+lsVPcNP14fTTlterfPFZdKv9V/UoZ6/Fi+QgABBBBAAAEEikhgUUZOZvJ5+eWXR9fdmfj6s88+O/GpkvneAs1XXnlF9uzZI+XltmukyM6dO53v029qM2HYa/ZpvB1nj/mO/Mx0D55DAAEEEEAAAQQKQSC9XqSNYIxEYlJX0Spu22BmZEq3y0YlakOSsaMZmxOLxZxQ8cwzzxz3elx35t6wYYOsXr3aCRbtGolou11J1520ANECxdQozLq6Oh1B6Ra7lhX72kooFJLKSp1OPjpac8yozXiHc4wVZwSmvhQIuKXMf2Q0yEy9NrKg5ejRfIEAAggggAACCBSPwJKFkxambd++fZKcvYGzT5RLtaTXNLJgMh1OdnSk3qja6NFMxaYd/ed//qccPZr5DXamc3gOAQQQQAABBBAoZoH0hjTHWrvFH+xz1m9M5YO20Yy1XKdgR9s0VBzQr52ocuShqz/qCEkLET/60Y/K2Wef7awXaVO7V65cKR/84Adl06ZNzrE26ToRfdnZYDsZPaDPRZ0p3QkNMc8991y54oorRsNJe+9bX1/vzG6x4DL9oXMqo0y9BY+Hdztd4nLpKEutjr0Wj+nak65e6e4ZcgJLCgIIIIAAAgggUOwCizKteyq0p556Si6++OJxL+/evVsGBwenOqXon0+Hk/bm1YqNgEztCikyMZy85ZZbpLOzU/bv3y/2ST4FAQQQQAABBBBAYLzAQG+PVDVosGdPO+s42uRrS/7ckoj1S2L4RfGUnzvuJBvlaCMjzzvvPPnFL34h3/ve95z3p7Zj90UXXTR6bDJ6RKKdz0hcl1KPDx8Vf/0OvdbZ4tJws6ysTL7ylf/rBJq29I6FnbZkzwc+8AHn2qmRlOlAVAPN8GFJDukH9BpuJp1K2lTxpIaYOjoz0SPhoWFx14TGjaCkrxFAAAEEEEAAgWIUWPRw0j6JTgdpFkT29PRIdXX1qOXYKd32KfVUC4anT7DRl3aOrd1jbxobGxtlzZo18qpXvWrcdcd2li1MbmszWqhnn1rb9JxXv/rVM/an7bR4//33O+sP2de2pqOda29Sa2trZzx/ugOsLjYC0taWtGJOtth6et1Ke87aaGGltc+Ktd02G6IggAACCCCAAAIIZBbweQY079PNCUc2wbGjnDUiddSjLhApsZ47xROytcF1/ckxM6zT064tXPzYxz427uLJRFx6X35Kep/5gQztPyDJsI6i9Lmke/WXpfqs90j1Vg0w9b1cU9Ny+dKXvuR80GwzYuz9nQWTx6d0H79stPtWHXGp62I64aRVRB8aUtqx7kREw8zhzA3kWQQQQAABBBBAoMgEFj2crKmpcabGtLS0OG/OLGC77LLLHEb73gK5dDnttNPk6aefzkhsu2Hbp9gT16dMr9lo4eONN97oTMUZWx555BH50Y9+NG6koS1sblPJLWicqth5P/nJT8aFgRasWphor73//e+XdevWTXX6jM/bRjy2tmS67Nu3b9KmQN/4xjec9rznPe9xDrOQcmx4e/DgwRnvwwEIIIAAAggggECxC6TCv9Qc6ICnU7w2j9sZpGj/GJNA2pqQfU+Jy/9d8Te8J/X66FqQE5TsXH1t+NhBOfy9/yXhfS9LYlBDT9vnZuSS4X0vSN8Tfy3tG7fI8jf8hVRuPN25SFVV1ejFxgWTFkLq/+P9T0q0595UHmmjJp0LpupvW/dUBHXtTM/xmUWZws0JteVbBBBAAAEEEECgYAWWZM1J23U6XWxqd7rYiMaxU5htsfGpik2xSQeTFnaeddZZctVVVzkLlFux8PI73/mOM9owXSwQ/cEPfjAaTNo0aVsL6IILLnCC0anWurQRnt///vedYNI+8bZ72cjM9DRrq/MXvvCF0bpPVefpnrd6b9myxQluraxYscL5Pj0i0xZOt+/t0/t0+chHPiIf//jHRx/TXZ/XEEAAAQQQQACBUhQIBYb0/ZV7zGY4YxUSGgEmJdL5M52e/SN9YYplckaCyb69z8r+L35Ehl54QZKRqIaaGiMG9REYedjbOF1qZ0g/cD70xT+T7h0PpG7mhKIZioam8f7fy3DLv4wEp3bM8fDURlAmdHSnP+SWgf425wJTXSrD1XkKAQQQQAABBBAoSIFFHzlpKjb675e//KUDZIFkV1eXE8KNHQVpx0z1qbBNq3744Yed8+2YD33oQ3LCCSc439s07W9+85vOtWz6+K233ip//ud/7rz2q1/9anSdHgsD7XnbidGKhZSf//znJ00jt+tZoJkuN910k9iITitvfOMbndGNNtrTgkub8v3a17529Nhsvnjd617nHG4Lr1t561vfKps3b5bvfve78vvf/162bdvmjASlIIAAAggggAACCEwtYB84p4vzdbLbWb4xVcaMmnSesJGLdnxCIu3/pWtHviz+uneJ268fdrvGvC22EZOth+Tw1z8lsfY2ncKdOnVkcGP64qN/2qkJXSPyyLc+JZ4P/atUbhq/67cdmIy2SKz7dol036nvT3UEZsYRm1Y3HTupU73jyYi+t7Xv7TGxHZOqwBMIIIAAAggggEDBCizJyEkbcTh2CvQzzzzjgI3dvXvidOyxojaVOv3G00YTpoNJO8YWF7/++utHD9+zZ8/oVOyXX3559PlrrrlmNJi0J1etWiVnnEScc5sAACAASURBVGHrDY0vtkHNsWPHnCet3hs3bpSBgYHRx/nnnz96goWI8yk2JT29huSyZcucS9nallYmboYzn/twLgIIIIAAAgggUOwClksODOra3BokJjTUs+xvbHB5vP2pKdQ2gjLW86gMN39SIq2f1+DwZxLve0xHNj6hoypvl8Pf/5REW1qdtSVnVfSweE9Yjnzv03r+HRIfeFwfT+g97tLrf1GG9D7hjtu0chpMThk2jtRNPyzv62uX4XBkijbMqkYchAACCCCAAAIIFITAkoycNAmb2n3gwAEHxdaVtFGCNoLSik1ptscLOmUmUzl69Ojo0+nNYcYeZ+emN9OxN6G2pqSFe+kp43ZspvMsoHziiSfG3XLstHALCv/6r/86U5Wc5+z6sVhMvN7sGA8fPuxMKU9vfmOjQW0dSyvptprVr3/961lt3DNlBXkBAQQQQAABBBAoIYGBgSGJDXdLeSAVTk41K2c0HNQPuROxHh3N+KAmmQ9ooOnRUZQuaX+kT4Z2DIq7TD/H12nWTjk+QDOzqL5uIywjB1vl6J2fk4aLqvTa+qSzpuRIsV3BM5895lnbsVundvvi406d8TQOQAABBBBAAAEEClQgu1RtHo0888wz5ac//anz6a8Fb/fee+/o1cauSZnpFsPDx3cr9Pt1sZ8MxQLC9GYxtv6khYZjS6YAMb3e49jjbJRkutgb2kznTTx+7O7jGao26SnbyOaOO+4Yfd5Mxn5vL9joUgswZ7Or+KQb8AQCCCCAAAIIIFBiAjZS0uPxa7io60pqHphx1nRGEz3R/u+xUYsJDTeT0v+cvve0+UXpYDLjeRmetORRzxt4ISxVp0TFV67f6P9Tu3FnOH6qp7TykXC/xGNxbUdqffKpDuV5BBBAAAEEEECg0AWWLJy0AM+mY6enWj/55JOjdrbhzHRl+fLloy93dHRMOtTCSHuki42krKiokLKystHnbbp2erOZ9HGdnZ2TrmXnpktjY6N86lOfmnTMfJ+wTW5sgx2zsFGU1r5TTjnFGYlpLhaKXnnllc6UdQoCCCCAAAIIIIDAzAL2/ike1WndYwYqznzW8SMs0PT43dK3Z1ineCd03cdszj5+rA6+1HUqE9K/Oyx155ZLMqyjOJ2AMpvr6aY9kQGdnq7tkdR66dmczbEIIIAAAggggEAhCczxbdfcmphpXUlbi3Km9RXH7uJtm9GMHUlpNRk7NdtCUAsmrYw976GHHhpXaRtladPLJxYLJ22HbisWaNpjbLEA0Xby/t73vudsuDOXsn79emdznfQ6k6eeeqrzvY0utWJtsO9f//rXz+XynIMAAggggAACCJSkQCIW0SnRuqu2DYLMotjxdkpSR0oO7gnPOeAcvaUGkUN7db1IXfvSWfcyy/rYKcGAV9+TLulb9SzEOBQBBBBAAAEEEFg4gSV9x2Mb0EycJp0psJzYPDvP1oe0Mjg4KF/60pdk586dzvqM9913n/zsZz8bPeU1r3nN6NdXXXXV6Nc2TfpHP/qR2M7fr7zyinz9618fXfNy7P1CoZAzatGKvZn88pe/7Kz9aCMcLQT9yle+4qwP+eijjzojM+dT0sFnOpxlM5z5aHIuAggggAACCJS6QEJ3wU4k4nNj0AAx2p+Q8GFdGsjeIWcZKI69qe3eHTkak2i3Tsv26sVmOZrTCUntH3p8dUWZ+P2B1PdzaxFnIYAAAggggAACBSGwZNO6TcOCv61bt8pzzz3n4Nibr/Rowem0bHrzO9/5Tvn3f/93Z5r2/v37ndBwYjn99NPlwgsvHH3apkrbc+n7Pfjgg2KPdLFQMB0Ijr3WtddeKy+++KLY5jj2+u233+48xhabon7BBRdMrEJW36fvPXGnbptOTkEAAQQQQAABBBDITiCpc7PdcwgVbaSiW98VR3viktCA0pnSndU07DH1tPN0/crEYFJ3546Jv87rbIxja1rONLXbGWSp9bc/LWRNJm3NyewMOBoBBBBAAAEEECg0gSUdOWk4Y0dKbtq0SWpqamZlZrttf+ITn5Bt27ZNGn1p06Df/va3y/ve975J17rpppvk6quvHjfK0aZt25qPN9xww6Tj7YlAICAf+9jHnM1ogsHx6/zY9zay8gMf+IB+mp15c56MF53wZH9//+h6mIycnI0YxyCAAAIIIIAAAtMLuDRVnCkAnHiF9JRuSwEtnExG5ppKjrmyBYo6+jHaFctq7cqxQaQzgpJkcmJ38T0CCCCAAAIIFKGAq6enZwHegS2tjO3EbVOiLeBramqSysrKGStgU7RbWlokHA6LbUiTTbBoG+fY/WwtSwsSLbykFIdAyxeudxqy4cOfLY4G0QoEEEAAAQRKTMBZ01GLhXlHDh0Rif9Q6ipizghK2+RmpuLkf7rWpCvgls7H+qXrt4PibJA9n3fINkpSR05WXhSUZVdXSWJYR2POYuRkuq5ur0uOtlZLw6p3STAU1E0SGT45Uz/yOgIIIIAAAvkqsO9Ln3Cq1vRnd+ZrFXNeryWd1r1QrbV1K8fuqj2b69ob1mzPSV+3rq5O7EFBAAEEEEAAAQQQyF8Bt0c/QE7Yxoa6bmQWxZlOrccndGdtJ5S0xDLbIZhj72fXsKUmdRRm9oMf9WQNI7t6BqSyYVgCZfahOOFkFt3JoQgggAACCCBQYAIFGU4WmDHVRQABBBBAAAEEEFhkARtB6dUNZHTBx1SuOIc8bz555KTmjRl5mX1AqXGkW9visqCVggACCCCAAAIIFLfAkq85WdyctA4BBBBAAAEEEEAgFwIWLMbjcYnFXToNOrsapMNDt9/WedRz55tS2jX04fbp9G67XFbVsVGbugZ6WZV4vH6tSnZnZ3UrDkYAAQQQQAABBPJAIMu3bnlQY6qAAAIIIIAAAggggMAEAQsYPV57axt01p+UZDZDJ1PHekJ6/kK9O9ZM0VPuTk3IzjJfTG2G49WQ1Tb4yfJkfjIQQAABBBBAAIECE1iot18F1myqiwACCCCAAAIIIFBMApbhVVWGxCd+cY/Ohp452HOyP3tHHBfx12ogaKMnZz5tejo7X+vgr/c6gzCzW8LSpVO6bfRnlfh8Gm7OZU749LXjVQQQQAABBBBAIK8ECCfzqjuoDAIIIIAAAggggEC2AhbgWYbn93vElQw54V5WxfLIeFJ8NR5xV+hU7PQu31leZvSeei13yCX+Ol3/MpbUQZyzv5DLlUpGQ2UVqfZkcW5WbeZgBBBAAAEEEEAgTwQIJ/OkI6gGAggggAACCCCAQPYC6ZGF6T8j0TKJR5OSSKRCvmxmRdu0bt8y3S/STrU8cY4jKJO6WbhXg0lftV5Lg0rXrN9x6w11OnpCzw+V1TujJt3ZBq3ZE3IGAggggAACCCCQU4FZv1XKaS25OQIIIIAAAggggAAC0wik12YMx+slEkuk8sVZDli0kZKWQ7q9Lglt9qfuMsdgMl3Fso0+cY1siDNNtSe9lNR35/19UZ2aHnJeY1r3JCKeQAABBBBAAIEiEyCcLLIOpTlzFMhmWMUcb8FpCCCAAAIIILA4AhZMpv9TPhQp18GKbkmkF3uc5S2ddSF13cnydQFnSvZ8iqfKLRUnBEdGTY6ZJj7DRVMb4YhEdMHKcCTgHJ1q2zyT0hnuy8sIIIAAAgggsEgCZA2zgiWcnBUTBxWtwOg6TrzpL9o+pmEIIIAAAiUl4PJXaXvLxuySPbv/xju/O+hUcH+1RyrODOpakfr9HKZU23nl2wISXO47vnblbHvAAlIbw+kul4QrxE7ds3XjOAQQQAABBPJWYOR9CGtIT9tDhJPT8vBiqQikp4KVSntpJwIIIIAAAsUmkH7Pv2xZrUhUd+3WKdpZDp5MjVLU9Srrzi0XX1NqM5tUyjk7Lbufp9YtNWfrlGwNOm2tydkPmNBYUqeX+7xu8SQrpba2PItzZ1c/jkIAAQQQQACBpRUga5idN+Hk7Jw4CgEEEEAAAQQQQCBPBVK7dVsYmZTamgrpG6zR0YcaDNpakrrBzOwDQt2MRjew8QRdUn91RWrNSJ3qPWNAOTIL3ALSuis12NSNdRK2S3d61+9Zu9n9NeD0rJBAwOvsQJ5u26wvwYEIIIAAAggggECBCRBOFliHUd1FEpj9by2LVAEuiwACCCCAAALzFYjHU2lgd3+9xDXZs3Uns51F5dKp3EkdPWlrT9a9ulzcZfb99DVzXve4pOaKcqk6qczZbXvmRPP4NdMjPG2D8XA0IVb/dGHExfT2vIoAAggggEBeC5A1zKp7vLM6ioMQKFYBZ/V7/U2AvzCKtYdpFwIIIIBACQmkd7YOVK4Uifk0HwyP7HY9u3Unjcp5S6DvD5KRpNScHpJAg1fa7uqT6LG4M0173CjKkbcQNgW8ToPJik0BSeh52RfnpnrvhIaqIYmJTk0fqUu24Wr29+YMBBBAAAEEEFg0gXTWwH/QpyUmnJyWhxeLXmBkGpb9MjC/fTmLXooGIoAAAgggkPcCHk9qUtCqVatkoCUklTURZ8dst0erPlVmmOkNQPpYPTe00i+rbqyRvj1hGdgVlmhH3AkuXT6XeOvcEtockOqTy8RbmZrKbQFmpks6eNO8kEzo9bSeseFaWbFqeerwKY/P+66ggggggAACCCCgAqMzIPhv+rQ/D4ST0/LwYtELpP+CYORk0Xc1DUQAAQQQyK1APOFxRjHGde6yz2MLOS5OiUZjEvAHZF9PrdQs65WejqgMDMbE79fwcFxAqWtCjnw/9m1AwqU7dmvCGPBoUqivOwMd9BHcWCb+dUFJDCYkEU6IW6/nLfeIW0PKmE4Dj3WMLDCpJ8T0Q8/BeExPc9nSl04Ze6/0LypWH3s+HIlLVaVfauq90nKkQbas1vvYhjp63/Ro0IXUisZc4tEkNB6L6wY8U6W2C3lHroUAAggggECJCowsQM1/bafvf8LJ6X14tegFRtLJ7FesL3oZGogAAggggMB8BSyEs3BN40iJ9u2RWM9L4ipbK96GU/R5Z2HGBS92P7eu/xgs36jXPiwdXQNyyw9bpPlQVENL++9+UuKajVrdLBgc99BgUsdAygXVm2VlWY2zZqVbg8qRfNJpSyowtOf0f/abhr7otuedIFIf+nVPdFie7TkgB2Pterw9m7pXOoy0TXfs1ITmmQMadlbWu+RP379c6pfVSzKwzjFJ6IteG0q50MXll1jvTomGD+poz82SrFiv9Vu8sHihq8/1EEAAAQQQKCiBkaxhMT5sLCiHGSpLODkDEC8XuYAuem8lmeRNeZH3NM1DAAEEEMiRgAVww+3bJd55t6Z4OiV6cIe0tzwiFWteL/7Ket2ZemHHEqQDvaYVm6TtyO9l3dqQvPl1y+QXt7fLPb8aFolqcKmjHuMjQxktbHQCSv1ftTskF604TZYn6iXRnQKbuOG2HWvnWBm5hPO1S5NK2xncXkskQ7I1WS19rXvl0Z494tWAMqmvj5zmhJzDw7qkjC8pV14TkNe9vkFOPrFculsrZc2a9U5wmp6inrrTwvwz0tcrvQd+Jt5kh+4orqM7u56RwPLXSln9FicMTQWv6VouzD25CgIIIIAAAqUsMJo1jGQPpWwxXdsJJ6fT4bWiF0iN5rBfLib+6lH0TaeBCCCAAAIILLhAQtdNtKjRbUGcZlz239mo7j49cPgp/W/tkJTX1ejO12HxJ49J187vSNWJ75JAVcOCTy22Xbs9/nLpja6URt8eOeXECjl5a4Vcc1W3fOsbHdJyyILC1EKUtju3RZMJfTS4grKuvFqnndt7Ax1hOTZ9HNFKB5P27divU9/rSMuR58u9PllTUSXPxXT6t4aTdn17u+Fc0p2Uzad65K1vr5NzzqnRsFA3+9abtg00yZZgUEd2xhd01KTdM9zfJ10v3iKhUL94gn5xeXTjneFuiTc/LcHazeIe80tTPJ4KWd1aTwoCCCCAAAIIzF0gnTUwcnJ6Q8LJ6X14tdgF3CMrQSUYOVnsXU37EEAAAQQWT8DCr3jCLcM9hyQe7pSou1pqGtbrBi+6NqNmf+Fhr0QHolJeo6PzPF5xB+MSiPZJ5ws/0M1kbpSKukbxzDMIi+iISI+tE+mUuAQDbqmrO1miw3ucOri1kuecUSOnfq5SHvx9t9xxe5fsf1nXj4x4tZ52rkibq09+3fqCXNpwolT5gs7ak/Exa0WNLmo/gdKZ7q3POVPK9auIvq94qadFHup92XJPieo07mhMA1F3Qtaf4JJXX18jV19Rp9PM9X2IBpY23TvS55HquhNTgafLJzENCG00o19HV861pOrrcoLJjh3fk/Jgj7gDGky6vZLQ9Sb7O6Pir7ZfB+weFix7ZaD7iJq0iS9YJ8GqVfosH+DO1Z/zEEAAAQQQkHTWkM4eIMkoQDiZkYUnS0UgOTLkIWmLT1EQQAABBBBAYE4CiaRHorqOoejUbVd0UDeTqZSB8CkSWHapbryi4V/9adLXvFOGuvs18Apq4OXS8Mstnr42GdjzM/EF3iGhynJntGK2IwtslJ+NlOxv26nhW0Sv4ZahRK3ULt8ggfK10tsTlNrKYUlqOGjXt0Dwuusb5bJLa+Shh3vkgXt7pHl/Ujo6LERNyLNDzdKqwemmwDJpKquSCm9Qyj0BHU3pEZ8rtamPrSvprFmpWgkNLyP6PiIcj+omOBFdb3JQXtF2vTLYJlF9rSzokfoGkXWbPHLhJbVy8UU1uou4hrV9GoyOvP3wapB6+FiVNG1YK4O9reKJtalQVK9ZIW6dcm0h71yKWUaGwtK16yfijraIu8rn2Cf1xuHeYenviMnyTadqsOzRsDIh4bb7Rfq2ax/0SjgR0FD3DeKr0FGVLt4nzcWfcxBAAAEEEEhnDensAZHMAoSTmV14tkQEXB5dA0rbmtQdNSkIIIAAAgggkL2AjZoc6GqRRPOvRXxRDRor9b+rYZHuR6Wva4/UbX23NGw6TQbaDsixvY/KsnU6qrHKrzdy6YhJnwz3H5WO574tvnPep+f6ZgwoxwaYNlpzqHO/DB/9lQSCQxLVzWWsPv1tOkrT/w4NAVfJYPc23ZX6986IRhumaFPPI71x8esIhquvrNOp3nVyqCUse3b1y/ZnB+SVl2Kyb1+fHOnpE/+AW4I6mrBMN5Epc/ucHby9GlB6dESlFRtVGUnEZFjfRwxpMDmom/wM6LT1QJlL1p7glxNP8stpp4dk00kVsn5VmTOnOx5J6v01bEwv7ah/Dg4kparmLPFG26Xjhf+SyjqvuLw6ZtEYj90voVXXS6BmZdajS+0Xotbt3xa/tOj59rbfgsmEDGsw2XpgWCo3XSH167dqcBuW3pe+K77kEfGENDx2V+j0+4j0771LKja/U0Pe6ux/MDgDAQQQQAABBJwPBK24GDk57U8D4eS0PLxY7AIutycVTuovFhQEEEAAAQQQyF4gNQlBp3QP6UjIWEzXSoyJW6dEWxDm62+RY898TRq3vVdWn3eD7PnNEWk/eEAa1uoIxnKPTjH2SJlOqXb3d8ixZ2+Rlefc5Oy0PV1x1oseGWEZjwxKx67bpLbe7hnS7FEjSF3vMhHp0c1ejom3arUGhxslEHlaAr5hDRVT59rcaQsxLSi03xXWNAWcxwXn1kpPT1QfMTlwaEh27wtLS0tUWtuGZKC/XzoHEhp0av3sZL2GzlCXULlbKirdsrLBK03LArJ5Q5VsXF8mVVVe51FWkZpqHg+nglOnbSNNtIwzqXPOewcqdYOa1ZKMtEt4aECnlC/XQ9ziL9eNcYZ7pX3XT9XvAzo3fea37mkbG0Hasv0WCbiOSaDCwk79QNZGR/aE5ZgGk766k2TlGa82BGl7/tsS0ADTUxnSWwQkEdVRmzoNPxEv12Yuwo7h03UwryGAAAIIIFBEAumBUK7RpWeKqHEL2JSZ3+Es4M24FAJ5J6DhpJVkLJp3VaNCCCCAAAIIFIpARe0y6XKtk2Tb4+LVtSN9GqpZAOcp80og1iltT39BarbeJBte9T7Z/buvSeu+fbJsfUh3iQ7pGpQaVLp02nV3s7Tv+JnUn/pmXf9x5mnM8aRXOvY8KCG/bvBSVq/BpEtiGqrZXOl+HZm4rG6jBmsJWbt+hRzde5JUhJ6XeNSmjduciePFdhNPDKee8+loxcZGvzRqyLjl5HK5WpPLhE4Zj0Z0hORQXAYH47oWZGpjGwtlvXp8WcijozbdOupTw1adkeHSBSQTOoXcAkxbrjI2cu3JfWmvWzopEvScJvWN9bo2ZEBD0IQ06KjFhI3QFJ+4/WUS8nZpWx+QuhOu0SnWsWmnvqemxXulbcdPxB85ID5dU9IJi3Un8fBgv7TsHxJP7cmy6co/lthQp4a739QNefo0yPU5fZbQe8cGh2WoY1inlG/T0FQ3MUpGp73n5LbxDAIIIIAAAgiYQDIWSUGMZA+oZBYY2Q0k84s8i0CxC7h0J00rCcLJYu9q2ocAAgggsEgCqU1XElK36SLp7g5Kb+uQTlvuH/3gz6cjCwO+Iel58as6TblLNl/5fon6mqT14KBOw9bQS0cDunVdyoCOMAy3b5e2536kNbVp35bvjQ8S7bmE7R6jKdpwT7tEW3eKKxBwgre4Tk1ORIeku7VLghUrJea20ZupEvOeIkORMmd9yPTIy//H3nkAtlVdb/yTZHnvEa/snUAIIRAIkLD3ngXKLoVSoIU/dNMCLW0pLaNAS9lllL333hBCICRhZJHtON57Sdb4n3Of5CnHVmLHsvVdUGy9ec/vvvf83vfOaJvZ4RfdnUZfqbiooqJXxEi/S8rEyPaTRGjNyYpD/oh4FOTFIz833nxPluligVlOl/dI3kpdX7cTovsd9iZKoAilza5YtDomm+l+8VpMyRyH6pJqEVKbjU3iLik4YtG0ZQW8LfW9i4T2WJQue0ryR36FGGFvF/dOm4Sktza5USbCJJJHiTB5jmyrGrUr7hH5s048NC2RVD0mdezqy1pQVZOA7En7Cumti6GhOHIaCZAACZAACZCARSCoNWhBQLaeCVCc7JkN50QDgcAFwi8hTWwkQAIkQAIkQALhE1CxTz0UE9IzMXKfs1HTkC75DFWgFLFQKkKrN54z2YmkVB/qVohA2bgO04++Av6ksdiyssYUyREfSxN2nJLthLf2G2xZfLd4K1rFcboKlPrdK16SLQ3V8DVXS2EdSdEi03zuFhH0WlBX7kZywR5ISoq3QrfF83H0mEJsLp2I+BSniJsmIjvspkJjT59wNmaFXWt1cwnZlhybZdV7IC8/24iucVJJOyF3Fuor3RJtLfbIR5ePEa9MV10pmusrTM5MS6C19qrzg4y8Xgnl/uoB+GqWISVLit/EaISI5OWsqUfJ6jr4UyZg2uGXwlO/UcbiP+L16RYv14DHpIyVjln5xhbUtGRj7LxzZF5KOKZxWRIgARIgARIggS4E2rSGgGMUAYUmQHEyNBdOjRICNpMTS0OY1DOBjQRIgARIgARIYFsIqEAZI+HZKbkjMWbeeXA7RmLLxma01EtOZxHT7FLx2pGYLAKlFKtZ+zi89esx5eCL0eJPRfm6BlmuWcK7JYxZRLgU8Uh0uDaievmjaG1V4dNSEjuKlDpFPQLFD1I8FNXV0SVehq3wSF5HDcOOSckSL0krv6RDi9+JgJc7cg8UbZIK1E5dW7e7LZZu/zp2yTGpzSEh4RVlmcgdNbNNbFSnUGdKOlrFDrXFKyHWaptf48MlHMzuEMFRvC079t0Sh4WDhLnXrnoK9sY1SMqJgyNePSYlF2h9CyrWNcqYZGLyQReIMLkZdd//T7xLRRxNkGrgei+kYq+MVYmMmSduPMbPOxdJWXlhF+DZfjrcAgmQAAmQAAkMLwJBrcEm0RFsPROgONkzG86JAgI2eVjS5qc4GQWjTRNJgARIgAQGgoBWzG5qakZdxUbUV6xHQloaJh70YzjSZqBqs9sSKP3iGSnhxo54yTOZYkPt94+gpeIbTD/mN2jypaNSRTEJo3bEZ8gnBQkZcbA1r0XF8ufg0QI0HZqKcXbNaxkrBXCkirZfxEifp9lUofZKOLUzPlPyNCYZsVSbFcYNZGRkiPK3h4h8WjQnUBhnIID0sk3L01H0QClB47bPQVpaohFPVXB0iF2xiRmIT8s1tqgoqaHqfvFqdMYnI0aExKAw2VGs9QvfyhUvwl39LRIyVZhMEaE3XQROPyqlsE+LLRPTjroSrqpVqFn9IBLFIdLuTDBjAlnX1eBFdbEbcSN2w6SDzkVCaop4ppZIpfNiuN3iAStCLxsJkAAJkAAJkED4BIJaQ9AxKvwtRMcaFCejY5xpZQ8EbHJjrs0nYWBsJEACJEACJEAC4RNwN9UCVa/CVvkU4hueQ/P6J+B1lWH8/HNhy5iC6i0uNFfVS9i1RCmI2GZ3OpGQBDRteAat1Uux01G/RpM3VfIhNoinoORIdKaKuJiIuJQYOOqWoWbVsyJQWoKi9s4S96S4i7tZiu+I16Tezcp2/eJ26JViNfGpuXDEWt4J6qWoywe9FdMyd0ZJabrsQ7c0SN6T6mUaZ0dx6VjkFkySPvukAFC7fbEJYntqnniAimBpREHxD1Ub1TvU6xF7rPDyoEepekxWrXwO/sovRFTUAjpScVsYetzimbmhEc3IwE5H/wLuquXitfqEsJcx0NAyFT5lTHRsyouE5YidMW7fM6VITjka1j0Df8lj8JY9Dk/5ayJyNoZ/YHANEiABEiABEiCBNq0hqD0QSWgCFCdDc+HUKCFgi5OnI2m+lqYosZhmkgAJkAAJkED/Eqj69hkpZLPCiGI2CT12+DfAtfa/aCp6BRP2uxDxYw7C5nVNqCmWIi8tKlCKWOi0IzEjBq2lL6Np0wuYdqR4UPrzUfzdJrhqa0Q3FJFNCt3EyzL+uq9R+fU9cDc1wS1elCrkqSdfS1Wx/GxFbLxEQag3peh4PqnGrcKkMyBOqqVBL0kVKVPTEkTAOwIN9SlaJNsIfTuuidgo4xVPawAAIABJREFUO3NIbs36ugwUjD1IckwKr0DYebAfMVIcyOGMsyp+awi3GOYUG21+FRLFZg2Tl2n60+tuRfnSeyTH5BLDyhEvoqywc9VWo2RFEVokvH76Eb9Aw6bX0FL8HJIyJdRb9qeG61jUyphsKWpB2pTDMXruuWjc+Bqa1z0Am2e1cJQwcnmJ6674DtUrX9lxmLgnEiABEiABEhhGBHwtUoxOmi0ueRhZ1f+mUJzsf6bc4hAiYI+zEr37XNYFYwh1nV0lARIgARIggYgg4Gp0SQiwVxz7NArByi8Zmyy3mLULUbfuZYzc9RiM2OUkVGz2oLasSbwqNc+zLCcvCOPSU+FwLxch81VMOeinaHQno2J9uVnGZtf8kLHiReiUAOgtRqCs37gUbqmGXb1pFerXv4H49FiTz1LzVdocliekhnf7tFR2h9bmZSjelTl5+ahq3hd+CWk2db9NxPLAqpRWCLYIirKvRpcTNa59pBhNUsAL1Cr8095d+R7ov/H41FyTYmOC2Fr9/auoL98kxYKAuuIVUtn8bmGzGXFpwkFYKTOf243KDZVo8qRhygEXobn4TfgbliIx0/JIVfbKt16qqpcV+5A381Tk7XSojMFbaK34RMLKZZea9sbmMEWGmiUXpUsqfbORAAmQAAmQAAmET8DnthyhgtpD+FuIjjVYyzw6xplW9kDAHp9u5nhbtFIoGwmQAAmQAAmQQLgE0sYfgvLFD4iGVi8CWrwJGbY5YhGT1IrWus9Q+U2piF9nictgEooXPWwqUGcUJoqXX4IIakmyfKLkQvwStas3In/midjyxUNIE8EzUcK/NTe0XcQ5W0wrEh0NaNryAjaved6EQmflOpEoRVssUVIEPONhKJWpJSzZo0JpckLAM9IS/6zCMfI3X6t3j5uG75eXYUzBV2KuCJkDnFPRCKDSP5cKq417Y9SEyaYIjk4PCqdW3knxCBUPUY+rEnFii0MFV7t6O8YgeUSeMBaRdum9qJI474Qkm+SOlGXiJW+kxKnbNFZdPUqlAE5drQ2j9z0N1aseEPGyGAlZ+TI/XjxLG81HQ+2rKm0Yude5yBk7CVXLHwGaVxghWD0vjcDb2oDmWvGurPAgf8/54R4WXJ4ESIAESIAESEAIeJut1Cj2+DTy2AoBek5uBQ5nDX8Cdkk6r41h3cN/rGkhCZAACZDAwBBIzh+LhIL5UnilVcKJWwK5JUXwE+XNmRKLWGxAxbLbkVGQi9F7X4DyUgeqi0SAa5ZCLxpXLeKbMzUdcfZytGx6FKlZdin8op6QWkRHq1Pru3QRHyUEOinDgcw8B0aMiUdS9ggp+iLpWURMM8vJXa1Tcjm6G0oBdy284qYYFPw6Wq5h1Cpkjp00H6WVOxlvRkskHBg+aqJWzRZNFOU1u4swuVvb/joKk7qc9tndWIXmmk0Sri4Gmb6J/WKj2qo2jxiTgKx8i4UykUB2s4xhoBXPJRw7RW5vGtc9CKe/2FT/FnXXsFDmtcXNKK+Iwdh5FyFtRIZ4pP4bDu8qyfEpIqeC8IsXrOSidNe7UbrRjZQxB4swOmpg4HCrJEACJEACJDDMCfhaAuJkYuYwt3T7zKM4uX38uPYQJ2BPyjYWeBuZ6H2IDyW7TwIkQAIkMEgE4kQQzJ15AJIkh2LpJjcaK6S6s0vCgLX4TYzkf0xJQXxsLepW3oX03EyM2uc8VNXGo2xtuQhgVfCbonQxEpqcgZzRScifmC0efJp2RcVFKXQjH/3dJmHGqkDaJGejCWHWoi4B4U49NW0xDhE1VdATD8XKzcb7L1gIpysa1eDi4x3IHXkgSksLpGB1QAg0C/ZPiLcljIqsKt1slVyY1bWzMXbKgaZPHT0mdY9BkVKnt9aUakFx8ZKU5cQmtU3FSbVVbbY+2l8toiNMunCKT0tB/uRsZBZIzs50USlVmBTGyrpiXQWq6hMwft4FSM5MRu2KexDrrIQzKVkWk3yVwtrb4kZTpQulRW5kTj0CuTvPFw/OrgT5nQRIgARIgARIoC8EvE0BcTKgPfRlnWhchuJkNI46bW4jEJOcb373NjHnJA8LEiABEiABEthWAvEJMSicfRByZp2FLZt9qCl1i5eehkvrFjX0OBGJyT7x0rsNiXE1mHLYVWhw52PLihI0V4tAKVWoVWhzJEqlbfnYnJL40CbCpMclepnMk4rVfvlPvSPVC9FmxDoR7WTbup5NFED1GtQdJiSLZ+bGz9DS7Dain4ZPd23BIjkJiU7kjDkVm0p3k1yWVnc1Ars/mgqM2pqb7ahqnCvC6/6QWjemT0ExUueriKkfFS1bpUhN3aZPEZ+k3pAa0h2wzYiQaryIsMZTVOyWr4aJshFGykqZ2SRM3pEgHOWjHqfKtqmqCiUrS6Vy9yhMPfwqxDlrUPPtHRIWLpXCNcmkbl8w6ZjVlrmlorkdebufK8LkPBF8LTv4LwmQAAmQAAmQQPgEglpDUHsIfwvRsQbFyegYZ1rZAwFHSp4+JcDX3Co39p2T5/ewCieTAAmQAAmQAAmEIBDj8CJnwnRMOOQyNLbkoLLIhdaGRhHN3Cb3o80Rh6S0GLhKXoa78hNMPfQStNjzxYOyHq66BllGRTsVHANuerqSyQcpwpuEGpuNqBhpwpfFizDgNWgplhrWLEKcLJKYEoPmuirxxfS09dIqSNO500GBMlEEypFjJcS74UDJR5kiXplaDTuEgWFMMl6P4o3Z3JyC0vpDkD9mX8TG9ix7GtOk2aT6eF1VqbFB1UIjuBrvUO2Q5T1qbNf8kipWGmHTYmSxCgqxKm5KwR/NQVnbgPL19Wh1FmLyQReipXyhVO5+Hgkpum1dRhG7zVjpmLn8hZhw0CVIGzkJTod6rbKRAAmQAAmQAAlsCwHVGHxNrUZzMNoDW48EtvPWq8ftcgYJDAkC9hh5CEqQj9yZt9aVD4k+s5MkQAIkQAIkEKkE7DYv0nKyMWr++fAmTEfFpmYJEa4L5KGU7Iix8UjMEAGwcSFqVj+ISfv/BL7U6SgvqpdCOSKEmfyS8lM9AeWG3grp7mCtcZ3URIxWOLNx9zMehVbeSXsgn2RsnIR2V6w34pwVRh1aGAx6MGqI94Qps1HrO168BkdBatJIqLNWye47ae1WjOzXmRSDhno/KiomoclxMiZN2UXCooOiYfftWZ6U1nR3jeSIjFFhU21Uz0mrQI2x0dgasN0w6Hwbb0Lg9UWrsDMMhaXX7UVlcQNisncV1hdJgZzH4K/9UAoXqQirYdx+MzYtVfUo29AEW8YsjNn3XKRkZiKGwmT3weIUEiABEiABEgiDgNEY9C2gaA5Ge2DrkQDFyR7RcEa0EHCkWnkn3VXF0WIy7SQBEiABEiCBASHg8YtoaI9DcobmljwD3sRdUCG5CxurmqUCtXoOxMAemwyn5EJMsG1C/Zr7pVDOZKlire57IqiJ56Df1yKhyJqzUkOWNWw7+BGPQSPSaaEc9foLCo5a9Vq/W+HOKuJpWHRD+Qq4vdYywdDp3ozOL8hD1uiTUe8+COXlWXA12RATLx8RHXWXlkDYcSsSji3Tdb5DPnW1QEVlLuo9xyJ77FHIL8gWM6xq4VvbtwqUXp/0uXQV4hPFXrHBIfkmjU1GiA2Im0aw1O/CwLBRD9IAn6AnpbBThspS13O5/cgYOQ2130vlbt8axMnYaJV0HQsdk+bqFpQXu2HP2A2j9zpVQvCTpOh3LFo9oQXdrdnBeSRAAiRAAiRAAu0EghpDUHMgm54JhPE+uOeNcA4JDGUCjsyR8JZslhCzzcD43YayKew7CZAACZAACQwaAb8Iac2lX8HevApuSeDot4/ExP3OkiIsU1G04HFk5fqQXijVu2OSTIh3jFSRTnLXoKX+XRRMTBMRMAa+1gbR09RjMuA1qQKkCp7GU1DFsoA4ZzwsO7xjV4FORDu7eB1qU/2upWY1WppapLiOFbrcpmX2QihB8meOlIraNTXTZclKbCz+Gq7GImQkNSAzR/ehop+GO9vFSTEWNZXiJVknRX8kj3Vm1s6Ii83CiNT4tr10zC/ZddfBcHNdxu0WobDqWzg1/FsdHzU03IiwHX0J1Es0EMJuBEsVdWWaemUoKiPwivdka5MIjFIgKC4G+eNS4at6BYmpwsiZbtibRSQnZ01xE6qrbRg59wwRU8VzdMN7Uul8veTGlNyWSVPhyJ4Bu609PL5r//mdBEiABEiABEigZwJGY5CmmgPb1glQnNw6H86NAgLOnKlwYyFc5UVRYC1NJAESIAESIIH+JaACW6vHDk/jeqD2TYmHjoHTLgVxGtaj5ItvkTPjPMTsfwmKvvgffJtrpGK3H3EpUh1ahDdHXBqSxVNQPQS1cIslTKrAJoVdjCBp3BWl6TKWOGmJdYHfO5oSmK8FcJyxdrhqXHCo2IlMa9WOy/bh9/R0FRgLJTfjSPHsbIbX04CyumrU1lbJ9FbpRizS07KRmpeOMYVJUv07XkLIAx6Ofdh+cBGjK6o57kYRDFsQmyaip040IdyW2Nq+uXYGNhNzruKkLqtiqTZVKLV4kAib5qsDySNGyC/ikerRZSSMWyqpu+obUF9WKx6imRh/wOlIlArfJYtuR5yjFLEpEnom3q/u8rWISciCUwsUaaGdbn2x9sh/SYAESIAESIAEQhMIagyqObBtnQDFya3z4dwoIBCXNwONYmdreVkUWEsTSYAESIAESKB/CVjimk3Ero2Ia9aK0VbhlhgpNJNoq0LZ4puQMvoYTDzgcqz/5D60rt+EzHw34tOlqrTkoDQFcLQKtYQx+72yvreD0BYUJ9u8B3Xb2v+gIBcULwPTjJ6ny0ihGJ9Pwsk3ITlLxcmuIl/fGWi+yMQk7Wc8UkSMLBzV07rhC5NWv6z1WmpLjOej1f9gf7tu0xIYdRkJ/LY46KLqMWkQBNnJ7yL+qpek4SssVMD0Sn5JV614S25phCduLCYdcB489ctR/tU9YqOGsEuOS/FU9WoIfqsbTdWbkRSXK/knQ+ik1h75LwmQAAmQAAmQQA8EghqDag5sWyfAnJNb58O5UUDAmTNF7tvt8Da44G1RDws2EiABEiABEiCBvhLQgjN2EQNTR0wV0csrxVWa5O9ps+hkXhG7HEhJleI0xS+aKt2j554JX8pO2LCyTsK9K8VTsNnsxsqrKGHHjmCORZ2o3pIarh0M4bYEOy1yY0Q4jU3Wat6mord4BnolFFyFzYAzYayEeDdUbTHbD1Wt28yIgBYUTptqStrERb94f6q4qjZZuSODdup3ma4MTNOfAUYBXmaqiLrK0swLCLweGZPK9RKmvroe/vRdMHbvs9C0+RXUr3sOSSmaM1M8NmV/OnbummaUbfSIsDsJsU7JqyljzEYCJEACJEACJNB3At4WKfYnGoNqDUZzYNsqAYqTW8XDmdFAwISVZWvIE9BUtDwaTKaNJEACJEACJNBvBFT4s9t9iBOvwsRxx6BobSNqS11wN7RKCLFXCuDYkZQjRXBsK9G45k4U7jQfI2adhS1bYlCxsQqeFsmP6A/kNVTRTT3+JGTaCJUm52LQWzLYZRXutJq3Sz5a/MUluR9lG95mI655JHzZ67EUSrcrKH5GvrjW6pa+Src90nf9+DwqtopNalsHW9V2s2CgGadQZWQ8JZWZVANVbm0CpscwrhTWZeXxyN/9PBmDeahfdTuc+A6pucmSR1OESRmr1sZW1JW7Uby+GdkzToAtLjWihd1+O4i5IRIgARIgARLoZwJNRSvMFh05kh5F/y6zbZUAxcmt4uHMaCHgLJxpTG0OXECixW7aSQIkQAIkQALbSyAYhmy3eZEzWSo+730+KsscqCySEOJGr4hrViiyPTYRick+NK1/CHFSqbtw9xPQUC9iXItW55bq0gHBLSiyaeEXE5Jscipq05+W6Oj3qqekiHkq2nnES1MLwHhEqPT64W0Vca/VJ1HJWiV7KGUwikGryweP2xJXfSJQGpuMbQFbxWa13WIS4GHQ6O8q5EqxnKCoK1NUuPS1tsAjHqqNDXaM3vNUESQ3omHtf5EgY6FjouKyCqGuJi8qN7ukQE4sCuf+COljZko4N3NNmkOPjQRIgARIgATCJBDUFpwFu4S5ZnQuPpTu2KJzhGj1DiEQN3pPtCx+Ay2bN+yQ/XEnJEACJEACJDAcCahAmT5qMhyHXI5NC59BTclapIhYmJAmGRKlcrTdIQVaMhwiWi4C6mzIyJZpEjasuSZtJixZ1LRAhRgNR/b7VIgL6pPqIqhf1GtSP+pR6ZZpHhHXJDWLywN3i0+qXvtEkPPD5fIjLTV7yGBOFM/TahFU1WTxOYVbhEq7Q77YGiU4W+xFjKDRsG4RXTXU3QivkntSkFjek4HparGZaIWFq9elQ5wpU7Mc8JQ+IwVuPEjSYj8SHu5zNcHn9qC51oOactlX6jRMnHM8YpPEm1LGko0ESIAESIAESGDbCAS1BdUa2HonQHGyd0ZcIgoIxBXOlvzvkneypgmtDVVwJmdGgdU0kQRIgARIgAT6n4BDQrzTs1ORdNiPRKB8FuWbFiOt2YekDJ8IY1qhO16K4aQhLlnEMK0qLYKl/tSmeRZVNLPZJV+iTDICpeSz1GnWMiJkikBnRDrJaamVubXYi3oZumUfLc0SmiwCpUaJu0ToSx0x3tquCnrbURSn/ylZWwzmwtS+JWSOhFdCsT0iSqou6HJKSLwwiJWcmv4Y8Zy0a25JhWKFbEv5mjZuMsOwMowMLgFgpilXyScZG4fMAhU0dXXxlhSPTK/bLWHckiO0zoPaGhuSxuyFMXMklFukUbMRNhIgARIgARIggW0ioJqCaguqMcQV7LZN24i2lRjWHW0jTntDErBLCJSzcJyZ17h2cchlOJEESIAESIAESKDvBJwxPimAczLy9jofXudYlK1vQbMIYV6XhHFLqLFWj4YKj0aglKrSmmcykDfRyjspYpo9TuYliHelfGIS5HdZJhCqbQrgtEqOSREjNSTZpT8bRagUUVL3E5eWi/jM3LYOR2JRnI6CaXxqlgiUhabvaoNbbDE2iW1qo9pqCuQoMRO+HWuYKBtlZFipR2Vb7kkRK03uTq3YraqkqpbKrMWMQVNtKyo2Sch37AQUzrsQBbsdFxAm+z7GXJIESIAESIAESKA7gaCmEFs4Xv5WS/gCW68EKE72iogLRAuBuHH7GlMbv18aLSbTThIgARIgARIYUAIxdg8yRo1D/pwfIrZwH/GidKO+zC3FclQgk0I2bs03KZUsxTvQEtwSRUyLF5FNBDWbipUqTsp3+YgKF/iuAqXdOFNq4RvN06gfE9ItQp5XwrnrajzIm3Yw4uM07NnymoxEz8kgfO2jOpDmTT9UvBilgI3YoKKk2hS0T21Vm9V2I9IqI2US4NOdmbA0Qq6KmhZrZa7s66XoTcVmD+LH7I9Re5+J5JxCxMYwjHtATwZunARIgARIIGoIBDWF2HH7RI3N22soxcntJcj1hw2BpKlHAlKt0l1SCXdNybCxi4aQAAmQAAmQwGAScDok52RyLEbucQRyZ/0QlRVO1BS7xENQitpIsRyfKfrSKMKb5o/UW1P1MNAQZf3od/0pnoImJ6X8Kh6AflXpJKRbBTuPFMHRPJOm+I54HFZXuhGfMwpJhRNlcV1WHAb1nwhvdrEruWAcUkZORH2VsNG8mWKT2qY2mgrkYrOxXb0g1RlSmZjw7o6s9HdlqAKuxVYZ+8TzUkO4lX1VVRxGzj0fI3c7FA6nXQrfRD6fCB8+do8ESIAESIAEDAHVElRTgIR0G42BrU8EKE72CRMXigYC9rgUxI6TSlpyf1677N1oMJk2kgAJkAAJkMAOIxAfa0PWxOmYcMjP0eDLQV2pHzWlkvewSUK93c0intWKmCa5FTXc2zRVIoMt8LtUi/F71NuyFV4j2IkoKXkmVcSzwrvF09AXi4nzT0VCUpzJSalpFyPZazLYNxVQnU4HJs47CS0iLmqIurFJbFMb1Va12VQqFwamco5pITgJQ2WpTJWtR7ww68okjFu8JV0xBZh82BXGo5WiZPsRxt9IgARIgARIoD8I1C57z2gKseN3kYwrKf2xyajYBsXJqBhmGtlXAkm7nm4WbVyx3FSwZCMBEiABEiABEug/Ag67eAdmJGPGcVchZdopKJdAhbJ1kv+wWgq0NNXJ394qEdSqRFiTJPJSZVrrVsPvCghtjTKvwRIyW8SjUAvgiIDnbhDxrl5+l591dT5MPvhsEd5GSjEZv9SQ0YreHcW7/rOlP7ekfdSPXfnk5GL64eejtl49J9U+y0Zjq9jsE9stMbdBeKjHqQi6wkhZKTNlpwyVpTJtFral65tRUeHAiN3OxpTDL0N8soTJs5EACZAACZAACfQrAdUQGld8Z7aZtOtp/brt4b4xVuse7iNM+8IiEJc/A468QnhLNqN66VvImnNcWOtzYRIgARIgARIggd4J2PxuZE+Sv7mJKShd8ha2rP4euWNFmMuulzSKLsmj2CgOgZpPUW5VxaNQq0+bvIlaZdrlMRW51ZvQrdW5RbDTCtf1IkyOmDEfBTvtLAHNUq1aWjDfZO89Gvwlgn3VaucjJk1B7e4HYcOCN5GZFaOFuiWhvuTl1J+itTptal+jTGuVyt6BQjgibvq9Mt0vIqV4V/pa3WioaEXxumYkF+6MsTMOQkpOQRubwbeYPSABEiABEiCB4UVANQQtYOfIK0BcvkRlsvWZAMXJPqPigtFCIHnOOah98S+oX/Yl0mceDEdcUrSYTjtJgARIgARIYIcRcDp8yCwcg9QR56L4689QtOI1jBCvwOQML5wJ4gmo3oSqxEnzS3i25ls0hW8CxW9MwRjxJmwRz8J6+WROm4spBx0n4p0ImUOgCE5X0B09PFVcnTTvCLR6fShZ/A7SNdJdWGhmSE2fGSvh3bGSk9IZJ0Vs7C2dOckCHhFsNW9lZaUNubNPQt7U3aXgjt14ZrKRAAmQAAmQAAn0PwGvq9FoCNpUU2ALjwDFyfB4cekoIJAwdl80yJsOb0kxqhe9gux9T40Cq2kiCZAACZAACex4AprzMEbKVI/ZfR4yRk/F+g/+h4bqUqSIt2BcskNyyYsgpwVwRIPT/JGtIsipl6R6TrqbfGiSytb1DcCImQdg+oFHIyZGci0GhMkdb03/7tEuHpQ7HXA0YuMSsHHBq0iTqtumqU4r4qRHCuQ4pViOCV2XGjg2v83kpNSK5VWSX9KRNAZTjzod8anpwlHVTQqT/TtC3BoJkAAJkAAJtBOo/uIVybLiEa/JfCSMnUc0YRKw1dbW8k4lTGhcfPgTaNn8FWqe+Z3xUig8/TLEpucNf6NpIQmQAAmQAAkMMoFmER1Ll3+OhvWL0FSxCUmpMYhNcsAu4psKlF4RJ1WYbKq1QrvtKSNQsNexGDVdQrlNqPPwa36pxF26Zg02LXgerooixCc4EJ/mgDPeDkeMJUwqGyPWSjXupHyp+D12DvKnibekESXZSIAESIAESIAEBpKAVuje/PgdcqPiQ/pJ1yO+cLeB3N2w3DbFyWE5rDSqPwhUvfZbuFcvQdxIefA57vL+2CS3QQIkQAIkQAIk0AuBVq8DLTU12LJiMSpXfozWhmoRJ6VYjKwX9J6MSc5B9tS9kDt5Z6SNyBURLuBV2Mu2h+psj9eG5toalKz6BpWrF6G5skg8TvUdqk3rcst/NiRk5iF78lwJ4d4VMQnJ0LB5NhIgARIgARIggYEnUPzCP+EqKkXspJnIPOKvA7/DYbgHipPDcFBpUv8Q8DRWoOLh88UVwYPM/Q9D2k779c+GuRUSIAESIAESIIGtEtC8ih7RG2srK1FTJdW75UtCfBwam5ulCIwT6VlZ8skQUTK68ij6fHY01tWirqYaXk8r4pyxEurukSJCDqSkZ4qnaaoIlhQlt3pwcSYJkAAJkAAJ9COB2m8/RNX7r0u1uhhkn3Uf9AUqW/gEKE6Gz4xrRBGB+q+fQeN798EW60DhaZfDmZIVRdbTVBIgARIgARIgARIgARIgARIgARIggVAEWusrJZz7VvjdXiQdcD5SZpwcajFO6wMBjZBhIwES6IFAyoyT4Bw90VxsSl+7T6qFDu+wsR4wcDIJkAAJkAAJkAAJkAAJkAAJkAAJkECAgGoDRiMQrSBm9AQKk9t5ZFCc3E6AXH34E0g/9FogMR6t5TUo/+ix4W8wLSQBEiABEiABEiABEiABEiABEiABEuiRgGoDqhEgMQ4Zh17X43Kc0TcCFCf7xolLRTEBR2Im0g+Xyt2SdL7xm+9Q/ZXkk2AjARIgARIgARIgARIgARIgARIgARKIOgKqCag2oBpB+uFXQzUDtu0jQHFy+/hx7SghED9yNpLmn22srVnwEepWLogSy2kmCZAACZAACZAACZAACZAACZAACZCAEqhftcBoAtpUI1CtgG37CVCc3H6G3EKUEEiZ+QPE7bI/ICVEK997GY0bv4kSy2kmCZAACZAACZAACZAACZAACZAACUQ3AdUAKt592WgCqg2oRsDWPwQoTvYPR24lSgik7/cLxE7eDfD6Uf76ExQoo2TcaSYJkAAJkAAJkAAJkAAJkAAJkED0Emja9K3RAFQLUE1AtQG2/iNgq62t9fff5rglEhj+BPw+H6pe/SVa10qOCYcNWQccjdQpc4e/4bSQBEiABEiABEiABEiABEiABEiABKKMgKZ10+hJFSad46cj88gbYbPT168/DwOKk/1Jk9uKGgIqUFa/+Qe4Vy22kuDOnYeMWYdHjf00lARIgARIgARIgARIgARIgARIgASGOwEtfmNyTEoot3pMZhz6RwqTAzDoFCcHACo3GR0E/HJxqvng73Ate98YnLTzdOTMO10uVI7oAEArSYAESIAESIAESIAESIAESIAESGAYEvD7vCj/6DGrKrfYpzkmM/b/5TC0NDJMojgZGePAXgxhAvVLJffkhw+ZNynOnHS2SHpGAAAgAElEQVTkHvEjOFOyhrBF7DoJkAAJkAAJkAAJkAAJkAAJkAAJRCeB1vpKlL52H1rLa0ykpFblZvGbgT0WKE4OLF9uPUoItBR9iZrXrweaXLDFOpCx9yFI22l+lFhPM0mABEiABEiABEiABEiABEiABEhg6BOo/fZDVH/6FvxuL5AYj/TDf4f4kbOHvmERbgHFyQgfIHZv6BDwNlVJHspr4Nm4xnQ6bmQusvf7AWLT84aOEewpCZAACZAACZAACZAACZAACZAACUQZAXdNCSo+eByuojJjuXP0RKQfei0ciZlRRmJwzKU4OTjcuddhTKD+66fR+LGEebd6pJq3HSkzdkHG7kfBEZc0jK2maSRAAiRAAiRAAiRAAiRAAiRAAiQwtAh4XY2oXvQK6r9ZJtW4fUBsDJL2OUee408aWoYM8d5SnBziA8juRyYBT0M56j66Ge7VS00HbXExSNllNjJmHgJ7XGJkdpq9IgESIAESIAESIAESIAESIAESIIEoIOBzNaF66VuoX/Yl/C5xLJIWO2lXpM7/P8QkZUcBgcgykeJkZI0HezPMCLRsXoz6T/4Fb8kWY5nN6UDS1OlI2+UAhnsPs7GmOSRAAiRAAiRAAiRAAiRAAiRAApFNQMO3a5e9i8YVy+FvlbyS0hx5BUjZ5xLEF86K7M4P495RnBzGg0vTIodA8/qP0PD5gyJSFludsslbmbwsJE3cBUnjZkl1b76ZiZzRYk9IgARIgARIgARIgARIgARIgASGC4HWhio0rvsKjauXwF1SCfgtyxx5hUiecw4Sxu47XEwdsnZQnByyQ8eOD0UCri3L0LjkcbjXBvJZBIyISU9C/KjxSBg5GQkFk+GITxmK5rHPJEACJEACJEACJEACJEACJEACJDCoBLwtDWgqWo7mohVo2bwB3pqm9v5IXYjY8eIktOvpiMufMaj95M7bCVCc5NFAAoNAwOeqFzfyV+Fa9wk8xesAj+VObroiXpWO1ETEjshFbFahfAoQm5FvvCttdscg9Ja7JAESIAESIAESIAESIAESIAESIIHIIuD3edFaVw53VTHclZvhKi9Ca3kZvA2uTh31iyDpLByHuHH7Spq1I6UOBJ2BImskRQapra0NOLRGWtfYHxKIDgI+bytcmxaiZcNn8JR8B29FmVUlrKv5NhvsCU44EhNgT0yEIyHJFNdxxOvPeNidCbDFys+YWNhi4uRnDGwO+d3hkI8TEGHTZrcbgdNmE5HTZpePTf63furv2mzmp3wC37t2g99JgARIgARIgARIgARIgARIgARIICQBv0pMfvjNT/1VfsrHfPdLNWz5+P1e+cjvIi76vfrxyGT56XHD52mV7/Kz1SU5IV3yswW+lib4XM1Qj0j93dvYCG9zM3xNrdb2u3ZExEhH9ggRJGcibvSeiCucLY/D8kzMFrEEKE5G7NCwY9FKQMVKd8nXaC39Dq0Vq8UFfTO8tZIXo8Ud+sIbraBoNwmQAAmQAAmQAAmQAAmQAAmQQPQSUIeahFiJPMyGI3MknDlTEZc3Q35OYdThEDsqKE4OsQFjd6OXgIqW3rot8DSUyBuiCvgaq+TtUS38EiLuczXKW6Um82ZJP5Bl9a0TfPJWyidvobw+2PRNlX43P623WSYRsPkE3moF8Xb9Hr3YaTkJkAAJkAAJkAAJkAAJkAAJkEA4BLpG4el3+V+fOk2knl0j+PSnHX75aRNPR5PCTKP8YsTD0SFRgM54ExFocybCFqfRgimwx6dJFGEm7EnZiEnOhyMlz0QOsg19AhQnh/4Y0gISiFgCr7z+Wqe+HXX4ERHbV3bMIsAxG5pHAsdt6I0bx2zojZn2mOPGcRuaBIZer3muDb0x4zWSYzY0CbDXkUJAks2xkQAJkAAJkAAJkAAJkAAJkAAJkAAJkAAJkAAJkMCOJ0Bxcscz5x5JgARIgARIgARIgARIgARIgARIgARIgARIgASEAMVJHgYkQAIkQAIkQAIkQAIkQAIkQAIkQAIkQAIkQAKDQoDi5KBg505JgARIgARIgARIgARIgARIgARIgARIgARIgAQoTvIYIAESIAESIAESIAESIAESIAESIAESIAESIAESGBQCFCcHBTt3SgIkQAIkQAIkQAIkQAIkQAIkQAIkQAIkQAIkQHGSxwAJkAAJkAAJkAAJkAAJkAAJkAAJkAAJkAAJkMCgEKA4OSjYuVMSIAESIAESIAESIAESIAESIAESIAESIAESIAGKkzwGSIAESIAESIAESIAESIAESIAESIAESIAESIAEBoUAxclBwc6dkgAJkAAJkAAJkAAJkAAJkAAJkAAJkAAJkAAJUJzkMUACJEACJEACJEACJEACJEACJEACJEACJEACJDAoBChODgp27pQESIAESIAESIAESIAESIAESIAESIAESIAESIDiJI8BEiABEiABEiABEiABEiABEiABEiABEiABEiCBQSFAcXJQsHOnJEACJEACJEACJEACJEACJEACJEACJEACJEACFCd5DJAACZAACZAACZAACZAACZAACZAACZAACZAACQwKAYqTg4KdOyUBEiABEiABEiABEiABEiABEiABEiABEiABEqA4yWOABEiABEiABEiABEiABEiABEiABEiABEiABEhgUAhQnBwU7NwpCZAACZAACZAACZAACZAACZAACZAACZAACZAAxUkeAyRAAiRAAiRAAiRAAiRAAiRAAiRAAiRAAiRAAoNCgOLkoGDnTkmABEiABEiABEiABEiABEiABEiABEiABEiABChO8hggARIgARIgARIgARIgARIgARIgARIgARIgARIYFAIUJwcFO3dKAiRAAiRAAiRAAiRAAiRAAiRAAiRAAiRAAiRAcZLHAAmQAAmQAAmQAAmQAAmQAAmQAAmQAAmQAAmQwKAQoDg5KNi5UxIgARIgARIgARIgARIgARIgARIgARIgARIgAYqTPAZIgARIgARIgARIgARIgARIgARIgARIgARIgAQGhQDFyUHBzp2SAAmQAAmQAAmQAAmQAAmQAAmQAAmQAAmQAAlQnOQxQAIkQAIkQAIkQAIkQAIkQAIkQAIkQAIkQAIkMCgEKE4OCnbulARIgARIgARIgARIgARIgARIgARIgARIgARIgOIkjwESIAESIAESIAESIAESIAESIAESIAESIAESIIFBIUBxclCwc6ckQAIkQAIkQAIkQAIkQAIkQAIkQAIkQAIkQAIUJ3kMkAAJkAAJkAAJkAAJkAAJkAAJkAAJkAAJkAAJDAoBipODgp07JQESIAESIAESIAESIAESIAESIAESIAESIAESoDjJY4AESIAESIAESIAESIAESIAESIAESIAESIAESGBQCFCcHBTs3CkJkAAJkAAJkAAJkAAJkAAJkAAJkAAJkAAJkADFSR4DJEACJEACJEACJEACJEACJEACJEACJEACJEACg0KA4uSgYOdOSYAESIAESIAESIAESIAESIAESIAESIAESIAEKE7yGCABEiABEiABEiABEiABEiABEiABEiABEiABEhgUAhQnBwU7d0oCJEACJEACJEACJEACJEACJEACJEACJEACJEBxkscACZAACZAACZAACZAACZAACZAACZAACZAACZDAoBCgODko2LlTEiABEiABEiABEiABEiABEiABEiABEiABEiABipM8BkiABEiABEiABEiABEiABEiABEiABEiABEiABAaFAMXJQcHOnZIACZAACZAACZAACZAACZAACZAACZAACZAACVCc5DFAAiRAAiRAAiRAAiRAAiRAAiRAAiRAAiRAAiQwKAQoTg4Kdu6UBEiABEiABEiABEiABEiABEiABEiABEiABEiA4iSPARIgARIgARIgARIgARIgARIgARIgARIgARIggUEhQHFyULBzpyRAAiRAAiRAAiRAAiRAAiRAAiRAAiRAAiRAAhQneQyQAAmQAAmQAAmQAAmQAAmQAAmQAAmQAAmQAAkMCgGKk4OCnTslARIgARIgARIgARIgARIgARIgARIgARIgARKgOMljgARIgARIgARIgARIgARIgARIgARIgARIgARIYFAIUJwcFOzcKQmQAAmQAAmQAAmQAAmQAAmQAAmQAAmQAAmQAMVJHgMkQAIkQAIkQAIkQAIkQAIkQAIkQAIkQAIkQAKDQoDi5KBg505JgARIgARIgARIgARIgARIgARIgARIgARIgAQoTvIYIAESIAESIAESIAESIAESIAESIAESIAESIAESGBQCttraWv+g7Jk7JQESIAESIAESIAESIAESIAESIAESIAESIAESiGoC9JyM6uGn8SRAAiRAAiRAAiRAAiRAAiRAAiRAAiRAAiQweAQoTg4ee+6ZBEiABEiABEiABEiABEiABEiABEiABEiABKKaAMXJqB5+Gk8CJEACJEACJEACJEACJEACJEACJEACJEACg0eA4uTgseeeSYAESIAESIAESIAESIAESIAESIAESIAESCCqCcREtfU0ngQihIDf74fNZuvWG53OFpkEQo2X9pRjFpnjpb3imEXu2ITqGccrFJXInsYxi+zxCdU7jlkoKpE9jWMW2eMTqnccs1BUIncaxytyx6annvU0Zj0tz+mRSYDiZGSOC3sVZQR6uqD2ND3K8AwpczlmQ2q4TGc5ZkNrzDheQ2u8eI4NvfHimHHMhiaBoddr/j0bWmPG8Rpa48XeDj0CDOseemPGHpMACZAACZAACZAACZAACZAACZAACZAACZDAsCBAcXJYDCONIAESIAESIAESIAESIAESIAESIAESIAESIIGhR4Di5NAbM/aYBEiABEiABEiABEiABEiABEiABEiABEiABIYFAeacHBbDSCOGOoFQBXGaW6vQ3Fo91E0btv2Pd6Yj0ZnVyT6OWWQPN8csssena+84Xl2JRP53jlnkj1HXHnLMuhKJ/O8cs8gfo6495Jh1JRLZ3zlekT0+oXoXasxCLcdpkU2A4mRkjw97F8UEfH4vvH53FBOIcNP9vm4d5Jh1QxJZEzhmkTUevfWG49UbocibzzGLvDHprUccs94IRd58jlnkjUlvPeKY9UYosuZzvCJrPPrSmxBj1pfVuExkEWBYd2SNB3tDAiRAAiRAAiRAAiRAAiRAAiRAAiRAAiRAAlFDgOJk1Aw1DSUBEiABEiABEiABEiABEiABEiABEiABEiCByCJAcTKyxoO9IQESIAESIAESIAESIAESIAESIAESIAESIIGoIUBxMmqGmoaSAAmQAAmQAAmQAAmQAAmQAAmQAAmQAAmQQGQRoDgZWePB3pAACZAACZAACZAACZAACZAACZAACZAACZBA1BCgOBk1Q01DSYAESIAESIAESIAESIAESIAESIAESIAESCCyCFCcjKzxYG9IgARIgARIgARIgARIgARIgARIgARIgARIIGoIUJyMmqGmoSRAAiRAAiRAAiRAAiRAAiRAAiRAAiRAAiQQWQQoTkbWeLA3JEACJEACJEACJEACJEACJEACJEACJEACJBA1BChORs1Q01ASIAESIAESIAESIAESIAESIAESIAESIAESiCwCFCcjazzYGxIgARIgARIgARIgARIgARIgARIgARIgARKIGgIUJ6NmqGkoCZAACZAACZAACZAACZAACZAACZAACZAACUQWAYqTkTUe7A0JkAAJkAAJkAAJkAAJkAAJkAAJkAAJkAAJRA0BipNRM9Q0lARIgARIgARIgARIgARIgARIgARIgARIgAQiiwDFycgaD/aGBEiABEiABEiABEiABEiABEiABEiABEiABKKGAMXJqBlqGkoCJEACJEACJEACJEACJEACJEACJEACJEACkUWA4mRkjQd7QwIkQAIkQAIkQAIkQAIkQAIkQAIkQAIkQAJRQ4DiZNQMNQ0lARIgARIgARIgARIgARIgARIgARIgARIggcgiQHEyssaDvSEBEiABEiABEiABEiABEiABEiABEiABEiCBqCFAcTJqhpqGkgAJkAAJkAAJkAAJkAAJkAAJkAAJkAAJkEBkEaA4GVnjwd6QAAmQAAmQAAmQAAmQAAmQAAmQAAmQAAmQQNQQoDgZNUNNQ0mABEiABEiABEiABEiABEiABEiABEiABEggsgjEDER33B4P3D5vp0077XbExThD7s7n86PJ4+40z26zIdEZG3L5/pro8rSi1eczm4uR/sX30L++7K+p1Q2f328WjXfEIMbh6Mtqg7KMx+tFi9fTtu8Esdsh9rORQF8JbFnixrq3W+D1+DHrvBQk54Y+fpqrfPj68SbUrnXDFmNHxsQYzPxhEmISbCF35Wn2Y/mLTahZ50FqoSx7VlLI5Thx6wQWL1qG559+HW53Ky7/xY+RVzAi5AqVFdW47z+P4qsvv0F8fBx2230GLrj4h0hIjO+0/Juvvo8P3l2AVSvXoaqyGmlpqZg8ZRx+/NMzMWHy2E7L/vHqm1FRXh1yfzpR17v0/87vcf5wn9Hb2Lz75sd4/pk3torht9dc1uOYrl+7CTf/7W6z/jXX/x+ycjLatrVaxu/2m+8Pue2Zs6bjRz85vW1efV0DHnngGSxd8h2KNhbD5XIhvyAX8/ffC2edfzLi5HiJhtbbeIVi8NpL7+K1l99Ddk4m/nD9FW2LlJVU4Ppr/hlqlbZpx590KA48dJ75Xl1ZgxefexMff/A5NheVQG6LMHbcKJxx9vHYZ789Q27HI/df99/1OBZ/8TXWrF6PpOREzJy1E3525Y+Qld1+LIRceZhM7OuY6Tg999Sr2LBhM3Jzs7HLrtPx05+fi8SkhE4kBvL655f7Rj3P3n3rYzPGo8cUYM5eu8l1+AzYHaH/rg6TYepkRm9j5pN79QUfLcLLL7yD7+W4rpa/Q3lyPdpz7iy5bp3RaczCPc/CuS5qp3XMXnzmTbzw7Oso2rTF7Hvq1An4yc/Owdjxo4bj8PRqU1NDE1575X28++ZH2Lhxs7n3GD26EMedeBiOPuGQkOv39f5DV9bxf/DeJ7FwwWJUVtRgppyrPzznRIybODrktkuKy8x18LtvV6GkuBQ5cn7r366Lf35OyOWjcWI4YxbO+RdkuXL5Gtx524NY8/16OOU5c/qMyTjvgh90u2dcufx7PPfka2asSksr5HnUgdFjC3Dq6ce0/S2MxvEJ1+b+fi6rXNOKtW+65PmtFa5GH2LibEgpiMFOZyQiTZ7P2EhgoAgMyNH11vrvsXDV1536nJOZi8v2mh/SjsVlxXhx8aed5iUkJOE3BxwZcvn+mvjqmpX4as1ys7ncrDxcsqf1QLAt27/lwzfl4a3ZrHrUzL2wZ2HfblBUmL194QfmZufUXXZHQXIKnl/1LdZXlGFGwWgcNHZCj935aNN6fLlpnZl/8s6zMTI1tcdlO85YUl7Siffpc/bDtOzQ4kWfNriDF6ptaWkTv5OczgEXsXeweRG9u42furDq+WY0VrW29dNV5wspTjaW+fDhn2rQ2uJDUnYM/CJkFn3WjKqVrdj/ujQ4E9sfvNwNfnz7dBOKFjTD57VEfpcImwDFyXAOiI/e+wz33Pk/fPrxorbVzrvwtJBClj7Anf/DK7B2zQbstfds8zDxz5vuwcLPvsLdD9yIRBE1gu3B+57CcrlxnCwPYFOnT5KHw3V4+smX8eLzb+Leh27C3vP3aFt2+berUSrb7tpaWlwoKy1DZubJXWdFxfe+jk2FCMbfLFsRksnmomJ5EE5ESupvQs7Xidf99iZ89OFnZv5Vv/lJJ3GypqoGr770FnJG5CAhobMAnZ6e0mmb+tB909/uxLjxozFKHjJjYhz44vOl5th647UP8L9n/oXY2NAvHHvs3BCa0dfx6mpSpQjzf/r9LSgrK8ekyZ3/fus50NPY1lTXoK6uHipOBttfrrsNzz39KgoK8jBh0liZ3yDs3zOfy6+6sJvIX1dTj0sv/J2M0ecYM3YUpsj52tDQKALnGzj+5MOGvTgZzpj98+/34PZb7jNjNFeuf2XyUHz3vx/G558twX2P3CTnWHLbOAzk9e/KS68147PLrjth3/3miKC8ATf+5Q4sWfwNbrv7ejnvBuQ2vethO2jf+zpmet6cc/rPES8vziZPmoDxcj589cUyfPbpF3JNexdPvXQ3klOs+4Vwz7NwrosK6q/X3o7773nUXEf3239PFG0uwbNynr7+2vt44vn/YMq0iYPGc7B2fN9dj5n7B2UyYeIY040P31+A9975WH5+hhv/+ftOXQvn/sPn9eGqn11nnSczp5uXZM8+9QreFN73PHyT8O58nf1aXqhddtHvsaW4BNOmT8YUuWcp2VKGh//7DMXJDqMQzpiFc/7pLj77+AtccO5VSElKwjwRhdXh6J03PpSXMJ/gPw/cYF4EBdt7b3+KB+59HNN2mozxE8agWu5T3nv7E7wty1/407Pwy6sv6XTs8EtnAgP1XLbgxlp45XksNt6OxCwHmiq8KF/pwgfXurDHJWnI33VgHcg4ztFLYIfd9VRUl6HO1YLUuM4PRIp+WcnmqB2BypZmVFaXG/tTY60TfV15KaprK+HNG9kjF6++RV67Eg2NdWaZFm+7WNTjSsNkxsNLPkdZVamxZvbE6Thu8k7DxLLINqOpwoev7q+D3W5D/m7xaCjyor6s5+Nu6UMNcDd7MfWEZEw5yvJE+fLeBiNQfvdsM2ae2S48Ln24AcVftiAu2Y5R8xPx/auNkQ0jAntXXlqJ8354uYhRmbjokrOgb63ff7fzS5+O3b7jlvuxYvlq/P3Wa3DCqUeYWbf9417cdvO9ePSh53DBT3/YtvhvxFNv0uRxnbzl3nnjI1x03i9w3e9vxhsfPNa27GPP3RmSzp/FY+yBex5r21fIhYbpxHDG5tQzjoF+uraN6zfj4H1PwUGH7Gu84UK1px97GStXrMHuc3YVIXFJqEXMtIsuORPn/vgHPc7XGSNH5eO19x7DJPF0DTaXiGtX/PQavPn6+3j0wWd73cZWdxDBM8MZr65m/OkPt4iAPxE1NbVdZ4k3SCHeXfBUt+k64cgDzkRychLmHzi3bb6+CPj3vTfgkCP2E69Jy9tcvbxOOfbHRlg76tiDO3kO3XbTfUaY/PmVP8Zl4ikZbCpa2uS6PZxbOGOm59Jd/3pYHoTH4plX7m3zunvwnifxp2tuxmMPP48L5RwJtoG6/i389EsjuOy19+546Inb2jwl/3j1LXjo/ifEC+1jHHrk/sN22MIZM/Xs/+nPzsU54nkV9ABuamzG7355A14ShrfeeA+u/tPlhlW451kQcF+ui1s2lxphcoSIcHouxwde8ui199dXXo9b/34v7rz/hmE7Zj0ZNnJUAW646Wocd9JhcAZeWpUUl+PMk39qhMRjjj8E8w7Yq231cO4/VKTS8+TYEw7Dzf+6zmxDPW1PP/Fi3HDd7Xjg8VvbtquOHr+84s9okWerB/53a6cXp3res7UTCGfMwjn/dA9//eMdaGlqwZPP3SUek1PMTtesWo8jDjwDN/31Ljz4RHsEweFHHYBTxEuyo2e/vuQ79rBzcO9//oeTTzsG43vwkI328RzI57LMybGYfHQisqdYUpFfnKm+e64J37/WhCX31iP/jqxox0/7B4jADosZ0T8YX4QQITXEuEg8J6O1lTTWG9NjYmKRHGuFyTU2W8JMTlL7m/uOfNRz8J7FC9qEyWhlR7t3LAG7OEmN2jsBh/4jC3N+mgJHD6HZ2isNz65a5TZv3ILCpE5vLrfSPRQvbOnU+fTxMdj1vFQcfmsWJuzf/QXGjrV0aO5NvdjUm+qtD57AL353CVLSOnvCdbSqpbkFb73+gfEaCgqTOr9Ywgq1Pf/M650g7LzL1G5hvAcdNk88syaKp886aAjw1pp6Zb7y4jvmzbiGmEZbC2dsemLz5KMvmtC2E08JHVGgIXI333g3LrniPKRnpPW0mT5PV8+xjsKkrqih3Gecc4LZxrdfr+zztobagts6Xiomvf3Wh7j6j+2h3H2xfdGCryRlwvc46riDO3nKaZi9ilNBYVK3pWNy4MH7iEeD14RuB5uegxpmuve+e3QSJnV+qnjFdvQE7Eufhtoy4YzZIvGOdLvdIgru1ikcWMNP7ZLi5sVnO6dVGKjr3ycfWh7u+4sg3TGE+5gTDjb4n33qtaE2DGH1N5wxU6/9//u1eIJ3SE2g4dRnS4oJbYu/7BytFaojPZ1noZbtaZqGqGqbLx6TQWFSvx9xzIHiSR4LTasRjU3vI04+/eg2YVIZ5BXk4JgTLE/wRQvbX5aFe/+hKWq0Xf6LC9vQFheVmmvgJ/IyZrN4+QebXoNXr1yD8y88o5MwqfNVtGZrJxDOmIVz/ulLh2+/WWGiLoLCpO5VUwDNEM/XBZ8s6jRmmgqha8oRTUdz1DEHm3ue4Xyvsb3H40A+l+19ZWqbMKn91Bec045LgsNhg1si4jRtFxsJDASBHSZOaue/Lu7+R/u7ynJ4JPdjtLayRuuhPikxEI4iLNxuS7jJ7SJO3v/VQtz66Xu4+b2XURzFgm60HiuDbXd8mh27nZ+MuNTePXDKvmuFV96ypY1rD/ss+tyFyjVuxDjt4lHpQ0Np+x+2SYclYMw+0ZHDbqDGMS0j1YR5qhDRW/t6yXKUl1dijuTrCjYNw9FQ7ZGjCo1HpeZs2lpTMURDIceNH9Or8PGG5KLSkO7jxPMhGls4YxOKj+YRfOn5t8zN/tx5u4daBH+59p/Iy8/B6WcdH3J+14n6wlA/4bY1qzaYVTRkeLi2bRkvzd+lY3DOeaeE7eXx5GMvGZQnnnpUn5AWFOaZ5TrmRvxQUjpUS2h4x21sy/j2qQMRuFA4Y1a0yXohvvueu3ayRB+Qd54x1Vz/aqutqJSeTO2P65/mmNS2x9zO/dAXOJqvdNlX3/W0+2ExPZwx68ngwsJ8M6trmopQy/flPOvtuqhjo6HlxZLHsGMrFttbu9EAACAASURBVI9KFbxn7jot1K6jdlp+27Wq3ds/3PuPBeJhrPcZQXFRz70b//wvc6+i4pXm5A22tyTliL5gOOW0o82kaLoG9tdBFmrMetp2qPMveH2dNXtGt9X22nuWGbMvF/X+MmHtmvVmfY1EYAtNYCCfy0Lt0S5OlE5xOrHJf5qDko0EBoLAgId122x2+eNgiRCV1RWobm5GRkJ7svElW4ra7LJLElxfl0I6XY1eVFyEZaWbUVlfi1YpQpOSmIzc1AwcOn5yp+12XG+lCKALNq1HaW2V+UOVm56Jwyb2fgNRKsLhu+skf1pdDRqaG5CamIrCjEzsN2YCshNCh9V17W9P31dXV5ow9+8rrBscu3D6UjxLq8UrMtg21dZAi/aMk/5q2yh298QnEPHV0+76PP0+EUCD7exdZmNZeRk+37gWlXXV8lY4DtkpaThmys7ICYipuuxb677HxppKs9peI8ciQfJAviMh5+U11aYwkPKeUzhW8lrmdOrHI8u+hCtQmOeg8VMwNi29bX5ZUyNeWvlN2/cfzdoTb8t+Nsh+agOh7DpzpTC7T8ZJ0wWcMn1mp+3zy+ARaKq0PCQTc6zCUF6pd/W1hHmnj3YiRv6wVaxyobHCI7kqmbNkMEaprMw6X/MDhXLUs/GPv78VRx93KJLEG+WJRzejvKyiW67KRhFgNJ/Xl5J7UL16amvr8JPLek8w//TjLxuvkhN68PobDAZDaZ/vSZ4mzTd52RU/6uRFF7RBixW9JPk/n3j+LvNg1lt74J4nzMOdjvVYeejTwgLHn3x4yNU031djYxM0R9hHHyyU0PwnUDiywHj5sbUT0HBOLYp3yc/PCwuLhly/JWGLu+0+s5unaqgN6T3Mgk++NDlAZ++xS9siJVus9DBjxDvoejmX33/nE3N+aujyz648v8cCOqH2MdynpaVb+bm3SK7Ajk2P9SDHivIqqHjWsfX39S/YD/UC6+hRXl1ZK4XHasxDvL6YGO55J7fneFNRXtvue279/q8v51lfrovqgXz8CUfgycdewBOPvIAjjj4Qm+U4uuOWB5AhHuvqPcjWTiAoHGrhomAL5/5Dz7l6ycW7UyA0WLfx9z//W15yOyXM/xwTSq/narBpvuvc3BzJtduEq391o4hgSxArxVVnSI7D317zMxSOsl7scIx6JhBqzHpaOtT5l5pqvSDXPJ9dW9Em65qrhRW7Nk0b42pxS2qa7+Xv16cmLdH8/ef26e9i123xe3cC/fFcpk4lWhwnLsUOZxLFye6UOaU/CAy4OBkXlyAuwA55uNG30H4sEjHy0PGTTN/1Jntjebs7fuGIfGwqaRcrOxrY1NqKh5eKK3hZ55whWoSmQnI2rty8DgdP3w17j+xcue29DWvx/ndftQmkus11TfW4T/abldZzvgRd74PlSzqJgRUiJmruzOVF63Ha7L0xMaPn9XsbnDek6E1ZZfubV80x+UKXokCvLP0Mo/NG4YLdrDwt6SLCejuIt7UiGPZ327BlY9sm303LwCcrlulImWnq0dnQUIs7hd1F+xyMoGfnuqpyFJVa46aXqk3i1entUA1c82KuLd6A+dNmdSrws07GstXtMtuuLhjVSZxskOkd+wIRJ9fJOHc9PrQ/+klO1oeIrd+cmh2x7RACzdXWCwlnIK3kkgcb4G31Y86lqVj2mJW2oKmSIQE7ZDBC7CR4M58aKPpw5z//Kzny6vB7CUfVHD/aysvab/iDmzjrlEuxbKnlzaOJ75944S6EejvecZca5qZhPAcdOr9TcZYQ3eKkHgg88+QrRnQM5VnXLHmdrv/DrRLufRRmSbX13pp6m+w+ZxdkZmVI4aJyfCTFCq762bX47utV+O11P+u2+mIpOnHaCT9pm37YkQfixluv7jHvZbcNRMGEZVKA4UHJEXjzHdd1KiTVF9Ofl1DshvoGKYTTN6/ih+59Cku/+gaXXH4+RuRlt+2iNCBO/vufD5pquceddLi8wG2VUO83JRftFbjzvr9BUzGwAeMmWPeJCyWc/qLLzm5DoqHBWshImz48T8DYTrj6+/oXrOy88NPFJiw42N6Xlw0qTJp+SGXijuPcqUNR/kVTWdz6j3tM8acfX9yeIzkUlt7Os3Cui9f//VfYU1IC/OqKP+EPv7nRhBfPnLUzXnjjIRSMzA21+6icppW7tQDbMRIx0fFvUzj3H/pSTFtaQPDSomyP/+95/Of+vyE+Pt7MqxQhP9i02nN8QhwuPv9XUpwny4R3F20sxtNPvIyvvvwGL7/9kPzta3eEaFuRvxgCPY1ZKDw9nX+j5AWZehcvWfw1NIQ/mP5AX/5owTFtHQXl4LZvv/l+/OeOB9t29btrLx+2ea1D8Rzoaf3xXPb5P62Ighlnh047N9A2cPvRQWDAxUnFOE2Epy9Wf2uIfleyqU2cXFFZ0RbCnJCQjPyU9G7iU3AYnlm+rE2Y1Ie0whEF4i2XgE0ijNXV15jQ8De+XoSR4tk3Os3Kt1VUV4f3vl0sm7DENd3H2Jw8462nXoglFe3CaMfh/k4qZb/37ZdmkuZ6KhxRiLT4RKwVMa1Z8kGqSPeIVNi+Yv8jZbr1x7Hj+n35PTc13dx8Vok3p3pDJiWlIkE8Extk+y0tTZK3JQ5pMi03pf3N/eV7H9Bp0394NXRi/b7svy/LfLJiqXkgHpGZJ56TVW1CorJWj9LTd25/Exrc3noRN9UDdkz+aCSJDeulMniTiMEqRH/w3WJMEC/KsekZfdl9t2Vm5I5EpnjKrtqyyYyDtsz0bIzKzEZK7LaNQ7edcEK/EPC6rXPOHmND1VoPNn/egknHJCEh0w6dpi24TL/skBsJi4DLJa6s0tT7QJOU33PX/3Dtn64y4qHTaf1ZCC7TccNnSciqvg3/XB7qF362WMJYb8c1f/4/aE62npp6TVq5Eq2iOz0tx+mhCWh4vXrBzd1nD4waU9BtIa06rF4iv/jdT7vN6zphhoQcvvvpU53y26nX1g+laIGKa8dKpeiuY6kP7b+++jIJy6+UyqufSBXNj3G7FF752VUXdAor7rqvaPmunm3X/uYfpqjJtniTPvvkq5IWIQXHnti7OKlVaG+VirizZu+CyySFQ8fWJFEp2r5YtBQffPZsW3qHo447BEcd9EPcIvlIKU5axOZJvsCdZ0yTSs9fSuGZp3CwvDgpLSnDX6W4hh7vRZs2mxDdrq2/r38nSRj/Pf96BG+8+h5mz5mJPcT7b/XKtfjP7Q+29UMFZrbuBPS8+9XlfxKRowL3P3JrW6Xu7ktaU7Z2noV7XVRPdR2j1LRk49mlOQ/1vLtNhNIrf3MxcnK33XGhp/4Pten6d+Xa396E0WNG4drrr+zU/XDuP9wSIafNIVXrdcz/dPXNOFJyER546Dws+uwrM8/VIeKsRX7fuKEI8/bbC/c/ektbpMHI0QUSLXCHjNtD+O213V/CDTW+A9HfrY1Z1/1t7fzTXLJnnHki7r/7UVz3u5txwU/OMKvfe9ejiIuzoqU8rZ6um8T+B81Funi1f/ftKinstgj3SwX49PS0qCyi2A1OP0zY3ueypY80miKoBbMTUDCLUW/9MCTcRA8Edog4uWfB6DZxskrCciubmpCVmIglHbwkJ+f3XJl6bU0VVhetbTPhlNnzsFPOCPPdJ3nttDiMelRq+PizIkYGRbzXv1cPH0skSRXh85K5+yMhxsqBt6F2Eh5Y8E7b2+ngxnV7LxlB02rHzpqL2XmBJMo7zcSdiz7BlvJiIyi+vX41Tprau6dK28Y6/HLKtF3Mt2tff9b8PHanWRL2PAL/XbJIvAzXY6wIomdJWPVgtsz0LJy3295GgHXLTcGdiz5uqyy+WcLSQzUVc8+YMx+TRTDU5pL17vjsfQS9PN9csxwXitfptrS9CkfJaqNwh4SLB8XJccKM1bq3hebArhOfYYVzu+okt8yd9UjKisG0Y610Dp4myyNEhUq2wSGQlW2liqiprsU1v/sH9th917ZwtPp6S/jPFqGyawsWz7n45+dAk56fcdLFuPTHv8N7nz0dMtw4mCsxPz8XBxyyT9fN8XsfCKi46/F4xbPu8G5Lf7NsBf573+P4zR9+3i2hfLeFZULHAg7B+erpc/6Fp+O6q/+BTz/8ops4qUUNgpXb1bPyyUdfwm+v+rPJM6rFd6K93X/X45Kj8Hvxmmr3+OgrE/W4/GbZchx34uG9iivqgXzJBb9FTk6WVPD+a7dQ38xM66XsHpJHsWPe2SnTJohAMNLkUdRcbcO9ME5f2OtL15tuvwa/+Pkf8cerbzIfbYccvj/2kZyu/77tv5K/tbsHXH9f/5KSE3HLv6/Dr6W68BWX/L6t6+f+6DRUVVWjePMWjMht947ti23RsIy+7L76qhtM2Oefb/xNt8InXRn0dp6Fc13Uv3s/PvtK4yn57Kv3tRWKU+9XfcmjL4ruuPcvXbsQVd9rJF/rhedcZf5u3fvITd3SI4Rz/5GdbQm99bX1IuT/z0R03C9VuLUFC/F1LKaixeBUnDzwkH073ZPsd+BeRpzUY4GtO4HexqzjGn05/y6Xl5fqff7U4y+aj7ax4uH8i99ejJ9ffDVyJT9216Y5gIN5gFsl1dAvr7gev7j8OkyaOq7bfUnXdfm9dwLb81y26vVmrH+/CemjnNj9okBIXO+75BIksE0Edog6oOG/aanWw7D2cmGxFTq8rkNRFxUwe2rflbeHP+dkjmgTJnV5u1SPOnLyTm2rqvipQpq2EvGqDLZ9xk9tEyZ12hjJbzhaPPG6ti1SPbsxUEFbPS2niMimIcbBz+6FY9pW0fDu7WlVzU1tYeMFJiwZqG2yCuRkdcjpuD372J51Z48a3+YZGitvLVUIDDZXoGhP1+3nZuW1CZM6L07Wmz+hPb/nlkCOza7r8fvwIpCQYV1aij9zoaXWi9k/bQ8BcNdb4mRipiVgDi/Lh4Y1QeFRhS+thHjNX9o9G6qrao0RwYeCnixS75DjTzrCeBktWdyeH7bj8sFciUccfVA3MaWn7XJ6OwH1ONUKzFlSHOPwozt7zutS77/9qXkAfO3ld3HmyZe2fZZJwSNtV152Hc4/o/fK0ZOkiqY2DQfurZ16xjEoKMjDu29/0tuiUTH/3bc+Rop4UF33u5s6jYEK81u2lJppN9/wn5AsVOjVduIpW/cqVu/ZH599lVn27gf/HtIzK/jAv/se3dOb7LyL9Te4uEuOxZCdipKJWjn2yZfuxosiKt9+11/Eo/gZ3Hn/DVIorMoQyAvk4+0JR39d//Rh/OV3HsZTL92DO+7+Kz5d/DKu/tPlEl5eiby8EZ2qH/fUl2ibrh6uWrztyl9djB+ceVyv5vf1POu6oVDXRT3f9bp8tOTcjYtvL+KnYd6Tp0zEwgWLxes2er1dNUekXqv0WnPb3ddDqzx3beHcf2TISxdNDbZu3Sbc9e+H8X+/uqgtPUx1lRViGrz26X6CL2k6FvvT6doPzQmqRfzYOhPoy5h1XKMv51+ivHj5h7wAevvjp+Rl2g145uX78ObHT7TlxM7Lb3+eDDUeTvG+/NFFp5tZ77zxUahFOC1MAtv6XLbuwxaseLoBSdlO7PubdFO1m40EBpLADvGcVAN2Es/ITyU0WNtyKWIyRYQuDV/WlizhyyNT07Ck1KqgaCZ2aGUBsVAn5YoHZNc2StZtL6bjR7EUSMlNSmoLGdflx4UIJc6TEPD1XSK7N9VZD+a6TrMUwbnxbeuNT9d96ncN7/ZIrhkt+hJOWy+FbpaKrbUiTlrNhvc3rpFfbagLFHspqq3GS6u+wzGTp4ez6X5dNqtL0Z8C4RVsPRXmyetQ1Ca47CQpIhRsmotSCwFpARu24Usgc7zlodzq8mHsfolSCKf9UtNQ4jUvFVLzwjtvhi+tHW/ZpMnjzU2iVkP85W8vlaIo6pVsta+XLjdiWF9yZ+kNpDat4Bwq96TmStR20ml9q0Ic6AJ/BAh8IlVI163diNN+eAISJIdT11Y4Mh/z5ls5iTvOCxZIczjspnBKb60skF80t49eWjru69Zs6G2zUTF/+s5TkNBDeheNJHDKC7pQBU20uvdbb3xgvEnmztujR1ZaGOWCs66EPkA+8Ngtnc7VjisFz+FVK/VeonNbt9Yaq95eOHRdb7h/13GZLoU29KNNvXU+fn8hpk6b1Kecqv11/VPPvY7XT82zt3jRMux34LZFmQzncbtD8tJpuOiPLz4T6sHfW+vreRZqO6Gui/oyT1soj1atsL5q5ffm2jhl2sRQmxzW07SgycXn/xrLl6/CnffcILmNu78oUQDh3H/Y5W+YCovLJdR3n3l7dio49FXgpeikKePauI4dp44un2Ll8jUyBu3CqIYsV0ukyGi53rK1E+jrmAXXCPf8079LHe8v33j1fSM2d00fE2pMnJJ2SNv3q9eHms1pYRLYlueyzV+48M0jDYhPc2C/P6TCwWjuMKlz8W0hsMPESfWM/HTl19JHv4T4VuG9tava+jttK16TupC7Q84dZw8PWvqgHRTMGiVXkKdDRXDdhlOqYXdtMZIbsWtrDOQ3CU7vrfJpveyrY/XxrtsL9X2dhKl/+b2Vg9Oa75fvnUMNtMBMsRSeGUxxUr0eOzZHCIZd7XOGYBrfZTsNMp5dxUkr+L59a1r1lG3oEkjJtyMpMwaNVR6M3Kvdu2DzYhc8bh+yJ8fBEc+3b4M1wio8ao68Tz/+HPtJnp9g0xxOG9Zvwg/OOK7NK0QTmuvp2FUcU88wvdHUNmXa+G6mBHMlavhbx4eEbgtyQo8EnnrcEndPPDW0Z52GmQZDTTtu5Cfn/crk0Lvx1t/Lw1ggLYksoA/q6tHQsWmS+kcfstKL7LpbexRCtYhiGSEKB2j4oh4js6W6NBvwh+tDe6ZOHzvfeL498LgVgtiV1csvvoNK8dI748wT2rxJui7TICkW1AtJCxfd+/BNWxU89pm/h/Fo1Ure6tkVvHfRMFR9sNd5mlOWrWcCd93xsPF2vfSK9nyeO/r6p2N389/uMjkvzzn/5J47G4VzHrz3SSmAczfOOOtE/Or3l/aJQF/Os3Cui8FiSq++9E6nIkaV5dVS7ONLI7yMGds9KqtPnR3CC+n9wM8v/oNhcNt//ox5B3R/aRY0L5z7D13nmOMONdewefvNaSOk10atKq3FkPbapz0F1jEnHGJSnXz43gLJ43to2/ILPv7C/D5pcruQ2TYzSn8JZ8wU0bacfx3R6guXN197H4cctl+n/Nk93Wu88MzrZvUpIbxvo3TItsvscJ/LSr91Y/Hd9YhNtGP/ayUffSKf2bZrALhynwnsMHFSBbzsjGxTWVvbRimME2xzpGDO1lpWcooIddYSNW3ehu1rNImgqEVagm1UaqoUSIkTbwVn23QN19Y8lx1bTcBzs+O0YHi1TktMTMGv9++e56vTRrbhi3qJTh8zCUWBYj5JSSkYk52HBvEoDHLR+XbxpBxqrarJylfXsd/lkmO0Y8sJCMe2DvZVBZL5B5erdVlVvIea/cO9vxs+caFEBEZtTWVe83P5041wJlvH6pxLUtpc/icem4il/63D57fVYeLRCVKtWzzsXmk0XpNTjut8Lup2FkluSp/HLx+zWbgafFh4uxW2k7NzLMYf0N1zzFqS/wYJfPDOp1jwsVXMa/UKK0/vA5pUXMKZtP3y95e0iRbnX/gD8yBx5aXX4ieXng2XeA3969YHTOjTmee1PxRvWL8Z55x2mRSN2M+IjDr/cxExP/lokRGpDjviAMzYtbuH99ZyJUbjiIUzNspHK2G+LZ51U6ZOxG57WDmKt5fbmadeJvkHC8VLa2fk5uVI6GgFnn/6dcnD9S20CnfHB0otoKLh4QdKrtDR8rBdV1ePj95bKGGLX5hj6NJhnm8y3PEKd2yekZQKyvGEU47scdWrf/k3U5l7jz1n4ZUX3jGfjm3O3F1x8OHzzST1AjzjnBPxj7/+G5dJHtgzzj5eqnV7pAjBY2b+hZec1Wnd4fglnDG7U6qaawqL6TMmS0ENl7yo+QKvvPiWySV4/Mnt930Dff37oxT4SJYXBpOnTDCeXRo2/NEHn+FQyX+51767D8dh6mRTX8dMqzT/+dpbzd8fDaf+yzW3ddqO3lf8+prLuvHqy3kWznXxOMn9+8Ddj+MdqUR9xSXXiHB2sOQ4LMbzIqRoig3NFxoqh2W3jg2zCbf9417z92raTpPxxcJl5tOxTRTvRk0JEmx9vf/Q5U/6wVH4n7xA+5fkgo2Rgn2jpTDcg/c9bVLK/EGK7XR0IpkpL9j2nDsbL7/wJkZJERx9abNpwxbcfsv/t3ce8E1VXxw/nbS0hbaUXfbee8iQJQqiiKIgiqD8lSGIyB/BgaiACCqiIAKKiDjwLwgCsmTvUabIhkIpUIaUltJN2/85NyTNbBOahiT9HT750Lzcd9+93/PyXu55Z8wjX19fGvxaPzcjf+/TsUVntn7/9nCxsYU/LuNCfk24cF5hkoic3xYuVwVujHNV93piEInRvzmnuChdtiSdOXWOtrIH+5HDx1iHZdV9DWKZQH6sy2Qdtnd6PD/oZFtIcS86+H2CyQBkHRdcwWFmJJPjY4P7EnDoWVWPPSQ33TVOapFKLkrJSZmTlCsSQuJzKRLNeSqT2RCpLWwj27ZHZ4eX+XLVZq1XXlEOAb9x93g7L0RS3eLZCc4lHPuMXkEe7fGl0reEYknC3yTO/3iFQ8RL6Y0vnivB/XFS8qtlUQjnhexezXRRru3L0v/VQoqRvL7Zv0tVGq/IhsnedRpSRMwlZZwsxFXIn+X3rigXuDBR6p2GKtekVnZfPK/7Wwy+Pl6az3x9fHWh9xe5ajlRdgjGKStzUyaZqajpitxcZczX/k6nK4cNDcc3zmZXNc3KFOOkZjYV2xSiO8lBKlfJsUWaXKrePp7UZEgQhdUwvfRcOZiqClxpRTwstcfK4EPAOJn7WRKx5zAbI342aCi5ubQy6t0huh/y7R9qzUUhPuQF33QacbcYgxTOmDVvCi8wqun2KVq0CFWpWomWLFppUMG2MIcZDxj4HL3Oic+NRZsrUdo8YUUVYuP93fG9LbqR+S/lKs7iPdX9yWzvj7xyEcOkeC7Iwk0roqPBw/rT0BEvGXRfh0Ndd+3YR9M/n2uwXYylb4wemKNnTF7H6Qz726ovW8YsIYf79x2mVm2aGXi2GvchId0iEXsOqpc50Ron5TPtwvu72b/Q2tWbVPPAoEBVbf25/k+a292tttmiM/EEnzHtO901TSqmSw7dCVPGGOQSzO/rnyffMGd/tUBXnFFSarw86HkaPXaoW+nG0mSs1VksP6yR+4oYcL//VmNw1+9T0lcYGyet/Z7Zcl0MZW/yOZz3deJ702jF0rXqpf2eyXV0uJn7oaW5u9P22BualFji4SgvY5FiU/rGSWt/f0g/4vE9/5cv6LVB79LE96eprkNCgtV1rd+AZ4wPRd+yft4cMZFmzZivvuMikj5j7oKpFtNimHRSADbYojNbv3+FC/vzg8yDut8a4lFcv2Ed+vTL90x00IQfvm7h4lYb120zoN6xc1sa8+5Qku8cxDKB/FiXZaazo4jG/4Riz2Wv8fRHUbp5IRgnLasFn+SBgEd8fLzd42dXnjlBe05pzIl+fgH0TkeNZ4CETH+6YYXuR5iMu1WN+tSliibfz5+nj9Pe05rCCv7+AfR2B81+GRLmsn09JdzW3PyCi4ZSp2p1KNTPn45ev0K7eR/50SLSsU4Tal9BE2J4kPM6Lt2fnbS/enhlalW+EiWzN8HmyJN09cYVHTop5DK0RVv1/rejh+mfKM3NVcZRt2xFqleiNF1MuEW7z59SBkWRtrUaUedKVdXfH234k1JTk9Xf3Rq0pBaqsnTO8tm2daqvdrUbU6eKVWgVc9vN3EKDw3QVx3PqYdyqRbqP+7fqSFW4urY1so9zfi4/sFPXtE/zdqpSuIhhn524z+x8kQevxjDP7aqdDxsW3+usSUQuRlYJQ9dKSNFirJ/aVJTzSh5mY/K+09kh7O3rNKaOFTRGyNlc+fwyVz4XkZyhVctUoGphJenApSiuiC7JQLNPzfGPZv8Amb2P97tbTEkMufXLV6ZQ1lPr8Aq6MbjaH2IMF6O4viSmXaekdDdI3s1qvBGZTt4cxl20rKlR0tV0pR1vgE8YFfYt7vI6k3PvzKnz5MfeKOXYI8GSJCel0OWLV3hxGMc/FkMpvHxp9kTQ5ASytI+zbXcXneWFq+QuvHQxhuLjbnGF72JsHCtjNiei9hiS/048LCUfX3i5MmaLseRlPDntC33lRMfyZ/J7SLxPJB1DZfZI0eZGtLyH/T5xJZ3Jd0FyuvqwN1aVahVz/B7k5/VPwhovRF1iD8oAqlytgslvAftpx3xPrqQz8zPI+1Zbr4tyRHl4EM16E88w8ebTL5CT9xHl3IO76Mza3x9aGnI/usFVoCXUV/JR5iSSkuHUyUgqViyEc2iXcvj3ynhs7qIz43lZei9h45FnorjIbBLVYM9w45Qy+vtJepmL0TEcMRLLDjq+KlojMCjAUtcO2e7W+ipA6zKHnCw4iF0JONRSEMAGrVJsBNQapGQmuYV0SxsvDn3qWb8p/bR3qwrTjmMvu9/3GT5hkXZlipfRGSblfaOSZWgPb9Me79TFSJKXVqQatxS9MZYnatShqBtXlTE0OTmRIjg/pLz0JSykOLUrV9F4V5veJ3HfIlrPUW1IdHAunqQ2HcTBjf38CtPN+Bu02Ix+xEv2wfBsZi3ZiLzkrnFS8oXq60cMtLFx5g1zZYuG6IyTYhCOYONnIFc7d2XjpIPV5NjDsc21WBXXMmI5FtD9PZoYxfUTylsajXgaSYVbiGsTCJAQUhtyOJUoFUbygrgOAQlztEXHrjMz+45UvgvWFGaQo+bn9U9yu5rL72rf2aK3nAjYel2UvsSjC15dOVHN/TNrf39oe7LlfiTh9fXNpJzJfVRoNw6m4wAAIABJREFUYQ8CkmrE2vuQGJolP7Z+jmx7jAF9WCCAdZkFMNjsDARyfuyUDyNsoFf8phgboEKNKkJbOmRl9uAb1vZhKluirEF+EWnvyx56HdhjcnCz1ia7D2zSiupWqK7yT2pFboZ1eFv76tnJ//V3lJDkN1p3ogaVa3Jya0P7rbyXfJCD+Fi+RoVeTA6ewwapWK3Nk6kNG4+7m6+xGIeLu6pUKRlOD9drbsBbFkqV2fv0tZbtDCqbN2Rv1AfZ+1S8JrPFg8qXKkevmNGltk2XytVVf4b7uSoxjBsEQAAEQAAEQAAEQAAEQAAEQAAEQAAECi6BfAnrzm+cki9SckFK0ZTwoCJU1C/3QhkSOiBh2SkZd6hCUFGbDItS0OUqF9SRIjulAgI4nyK8wPR1rB/WLUbf3nUaqJyd0bduUXpWhuLtzflGLIlWnwlpqVQpOIT8rOQr4f63OSdbRlYmBfj4uLRe3Dqs25LiXXy7W4d8uLhuLA0fOrNExjm3Q1/OqZecRgWd5UTHOT+DzpxTLzmNCjrLiY5zfgadOadeLI0K+rJExnm3m9OZ844WI7NEwKFh3ZYGYet2MXRJxetwG3YUb8lyvM+9SHGu8i0viPUEhLcUF7JGtPq0pq1+Gwn3t8YwbWu/aA8CIAACIAACIAACIAACIAACIAACIAACIOAYAg4P63bMtHAUEAABEAABEAABEAABEAABEAABEAABEAABEAABZycA46SzawjjAwEQAAEQAAEQAAEQAAEQAAEQAAEQAAEQAAE3JeCSYd1uqguXndYLDZrSnczGavy+BsVtXHZKGDgIgAAIgAAIgAAIgAAIgAAIgAAIgAAIgIADCMA46QDI7n4IfysL2Lg7B8wPBEAABEAABEAABEAABEAABEAABEAABEDANgII67aNF1qDAAiAAAiAAAiAAAiAAAiAAAiAAAiAAAiAAAjYiQCMk3YCiW5AAARAAARAAARAAARAAARAAARAAARAAARAAARsIwDjpG280BoEQAAEQAAEQAAEQAAEQAAEQAAEQAAEQAAEQMBOBGCctBNIdAMCIAACIAACIAACIAACIAACIAACIAACIAACIGAbARgnbeOF1iAAAiAAAiAAAiAAAiAAAiAAAiAAAiAAAiAAAnYiAOOknUCiGxAAARAAARAAARAAARAAARAAARAAARAAARAAAdsIwDhpGy+0BgEQAAEQAAEQAAEQAAEQAAEQAAEQAAEQAAEQsBMBGCftBBLdgAAIgAAIgAAIgAAIgAAIgAAIgAAIgAAIgAAI2EYAxknbeKE1CIAACIAACIAACIAACIAACIAACIAACIAACICAnQjAOGknkOgGBEAABEAABEAABEAABEAABEAABEAABEAABEDANgIwTtrGC61BAARAAARAAARAAARAAARAAARAAARAAARAAATsRADGSTuBRDcgAAIgAAIgAAIgAAIgAAIgAAIgAAIgAAIgAAK2EYBx0jZeaA0CIAACIAACIAACIAACIAACIAACIAACIAACIGAnAjBO2gkkugEBEAABEAABEAABEAABEAABEAABEAABEAABELCNAIyTtvFCaxAAARAAARAAARAAARAAARAAARAAARAAARAAATsRgHHSTiDRDQiAAAiAAAiAAAiAAAiAAAiAAAiAAAiAAAiAgG0EPOLj47Ns2wWtQQAE7E0gKyuLPDw8DLrNzMygLMqw96HQn50IeJAXeXp6QWd24umIbqAzR1C23zGgL/uxdFRP0JmjSNvvONCZ/Vg6qifozFGk7Xcc6Mx+LB3RE/TlCMr2PYY5ndn3COjNEQRgnHQEZRwDBEAABEAABEAABEAABEAABEAABEAABEAABEDAhADCuk2QYAMIgAAIgAAIgAAIgAAIgAAIgAAIgAAIgAAIgIAjCMA46QjKOAYIgAAIgAAIgAAIgAAIgAAIgAAIgAAIgAAIgIAJARgnTZBgAwiAAAiAAAiAAAiAAAiAAAiAAAiAAAiAAAiAgCMIeDviIDgGCIBA7gSkKA4EBEAABEAABEAABEAABEAABEAABEAgbwSMC87mrTfsnd8EYJzMb8LoHwSsJICLp5Wg0AwEQAAEQAAEQAAEQAAEQAAEQAAEQMBtCCCs221UiYmAAAiAAAiAAAiAAAiAAAiAAAiAAAiAAAiAgGsRgHHStfSF0YIACIAACIAACIAACIAACIAACIAACIAACICA2xCAcdJtVImJgAAIgAAIgAAIgAAIgAAIgAAIgAAIgAAIgIBrEYBx0rX0hdGCAAiAAAiAAAiAAAiAAAiAAAiAAAiAAAiAgNsQgHHSbVSJiYAACIAACIAACIAACIAACIAACIAACIAACICAaxGAcdK19IXRggAIgAAIgAAIgAAIgAAIgAAIgAAIgAAIgIDbEIBx0m1UiYmAAAiAAAiAAAiAAAiAAAiAAAiAAAiAAAiAgGsRgHHStfSF0YIACIAACIAACIAACIAACIAACIAACIAACICA2xCAcdJtVImJgAAIgAAIgAAIgAAIgAAIgAAIgAAIgAAIgIBrEYBx0rX0hdGCAAiAAAiAAAiAAAiAAAiAAAiAAAiAAAiAgNsQgHHSbVSJiYAACIAACIAACIAACIAACIAACIAACIAACICAaxGAcdK19IXRggAIgAAIgAAIgAAIgAAIgAAIgAAIgAAIgIDbEIBx0m1UiYmAAAiAAAiAAAiAAAiAAAiAAAiAAAiAAAiAgGsRgHHStfSF0YIACIAACIAACIAACIAACIAACIAACIAACICA2xCAcdJtVImJgAAIgAAIgAAIgAAIgAAIgAAIgAAIgAAIgIBrEfB2reFitCDgvgSysrLcd3KYGQiAAAiAAAiAAAiAAAiAAAiAAAg4kICHh4cDj4ZD5YUAjJN5oYd9QcBOBMQwiQunnWCiGxAAARAAARAAARAAARAAARAAARAAAZchgLBul1EVBgoCIAACIAACIAACIAACIAACIAACIAACIAAC7kUAxkn30idmAwIgAAIgAAIgAAIgAAIgAAIgAAIgAAIgAAIuQwDGSZdRFQYKAiAAAiAAAiAAAiAAAiAAAiAAAiAAAiAAAu5FADkn3UufmI2bEcjMuuNmM3Kf6Uj9Ii9P00sodOa8OobOnFc3lkYGnVki47zboTPn1Y25kUFf5qg49zbozLn1Y2500Jk5Ks69DTpzbv2YG505nUlNBxSdNUfLObeZrqydc5wYFQgUOAIZmWkUm3y2wM3bVSbs5eFLoYWrGAwXOnNu7UFnzq0fc6ODzsxRce5t0Jlz68d4dNCXMRHnfw+dOb+OjEcInRkTcf730Jnz68h4hOZ0lpmZiaKzxqCc+D3Cup1YORgaCIAACIAACIAACIAACIAACIAACIAACIAACLgzARgn3Vm7mBsIgAAIgAAIgAAIgAAIgAAIgAAIgAAIgAAIODEBGCedWDkYGgiAAAiAAAiAAAiAAAiAAAiAAAiAAAiAAAi4MwHknHRn7WJuIGAjgfjoO5SRnr1TaCW+RHjY2IkDmmdynaC4C9nFgnz8PSmoNJ61OAA9DgECIAACIAACIAACIAACIOAAAlibOQAyDuE0BGCcdBpVYCAgcP8J7JwST2kpmbqBdJsRRt7+zmedvHX5Dm2bdFM3zsAwH+o0Ofj+A8QIQECPQEpyCp05fZ5KlAijEqXCnJbNlcvX6Ng/Jw3G16FzG7MJxO/cuUNbN+4yaNugUV0qVjzEaefn7gOTZO/H/jlFISFFqWy50u4+XcwPBEAABEDADgQidh+khFu3dT2VLVeGatQyLPRoh8OgizwSwNosjwCxu0sRgHHSpdSFwYJA/hPwKeRJrUYXVQfy9jNvmLx8KI3Or0+hhEvsaZmWRYWKeFGpZr5Uq3th8rx7VTm/JZWiNqdQpUf8qHzLQrkOPCON6J/fEun6kXRKTcggbx8P8gv1opKNfKlaF3/y8s3uokgZb2r3nsYYsu2juFz7RgMQuB8EzkVGU48uL9KIUQNp2MgB92MIVh1z1/b99OaIDw3anriwnby9TX8i3E5IooEvvmnQdva8T+ihLg9adSxnbnQpOobSUtOpUtXyzjxMk7GlpqSp86xHz6702Yz3TT7HBhBwJQJibE+8nUR+foXIx9fHaYcuD5/u3MmgwKAApx0jBgYCORGYPGEmHT74j67JCy89Q+9/9N+cdsFn94lAbmuzK4fT6eQfSZRyI4MyMrLIp7AnhVb3oUqdClFo5ezr6JHfblPs8QyLswhvU4iqdPJTn2v71DXmJaFfsAcFlvWi6l391TH0BWszi1jxgQ0EEAdpAyw0BYGCQMCDrwrBFbzVy1xI95H/3aZ9M29R7Kk0dWMKKOlNqbcy6MyqREq6ke11GXchneKi0+h2jOWboJZnRkoWrR8dS+c3J1HyzXQK5D59gzwpIYZvtstvU+L17BBu2UcMoLoxFgSlYI4uScDT05NKliqhFtnOLD2e6UJijJTXo493znGowSFFdG0nTx2bY1tX+/C/r31I/Z8d7mrDZg9XUudZ4cL+Ljd2DNi1CRw+eJQidh1Uk4i/eYtWLltPSYnJJpOKvRGnPktNSVWfbdu0m04eP2vSTjacj7xIjWo+REt+W2X28/zaKAZR8SIX46g1MnHcl9S5TS9rmqINCDglgUXLv1H38617lznl+DCobAI5rc3+WZRIe2bEUXx0OnmwHTKwtDdl3smii3uS6dTKJAOM8Wcz1NpM1le3r5i+kv7NXrPdvnpH0/ZyOiXxOiyR31/5O5XOrE6itSNj+W/2KtETrM1wxtqDgKlbhD16RR8gAAJuSeDy/jSKXJdMfoFe9OC4YPIPvft8I4voxMpkA+9GWwAc+jGRUm5nUKn6haj50CLk4aXZW26up9akmDyds6VvtAWB+0VAwqN2HFh+vw5v9XE92Lql9ZIUQ1dukt3Wisa5dYbP80zAz9/PJc6zPE8UHTgdgfFjp1Gz5g2o2QONaN2arfTp5K/pkW7tTca5avkGmjXjB3q0eydloHxt8FiaMHmM2RBSb28vKl+hHBUOKGzST35uWLhgKU2eOIP2HF5tVZqKoCIBVCwsND+HhL5BIF8JeHp5kvyT7xzENQncvppBkX8lkZe3B3WaFJq9LuPp3DidTrcsOIg0HVKUSjWwzjO9VBM/ajowUAGS/JfHlyTR1SOpdGBOAnWdXky3ZnNNghi1sxGAcdLZNILxgIATEzi+WPMErsmQIgY3QPGwrPnYvXvt3Dx9Rzlp1u8baHCT8+SbbV76dWKUTju0zIxM2h9xmHMlRqlcRJUql6O69WtS6bIlnXbM+TUw8aDZu/MAhRQL5kV0VZPDXLl8nb18oqg6fxbKbbQiHkES8qcV8WorVaa4yf7aDadPnqOD+/+h2Bs3Vd7Aeg1qUu16NQzai+dR5JnzVLV6ZRLvRa0ksbfPsaOnqGx4aQMdZWVl0dEjJ+nE0TPcbxznIixFtetUd2jI8h5mV7iwH9VrWNtk7rfiElSeS8lxVa5CGZPP7bEhOSmFNm/YSRKu7e3jTeXKl6EHWjehwoHZRo/oqMv8+WV1uOSkZBWmuXv7Pt3hi7I+atWppnt/7swFunEjlho3q0/iGauVyxev0uVLMVS7bg02qmiuhTeu36TTJ8+q88OvkC9F7D1Mkfy9ql6zErVu18JgipLLc9/uQ1Sc85NWqlKejvx9nA7tO0phJUKpw0OtdX3q73Se0wbEx93SbQoJDabyFcsa9CtvLkVfoeioi1Sf9ZCefof27DrAY71KDRrXpkZN6pm0lw0yn1079lNaWhq1eKAxhZcvTcc5r6WMr0y4e10L5Pt6k797Lds0pfS0dNrPevrn75NUoVI4dejcWme4P3zgKIkh2Dgn2/GjpxWnBo3qKJbifXc+8oK6Zqxbu42COOy3c9cH6WrMv7Rh3TYKDy9FHR9ua5a7K22U+8M/fJ4Off1FNWw5rxo0rGM2HcRePrcbNa6r8tge3HeEbifcppatGpudrpzDG3ctMvuZM20c894wkhfk3gjcTkikfXsO0Vm+ppYqXZwa8vkh9yljkTbiFS73RPmuRvC5FMCG6/adHlD3ZojjCMhvogMRf9Nx/l3hyykX6tSvoX4f6ovcOy6cj+b7ZnUqqvdbRdtGrqMZGRnqHqov8pvpEP8OOnk8kgKLBFKTZvWoIv/+hORM4NqxdOKfe1SmuZ/huox3K1bNR73sKUXLeVOzQUG0engapadmquKkIVI8FQICdiKAs8lOINENCLg7gcRrmXT7errymgyrYd9LR0Z6JvG9ldISM01uru7O1ZnmJwvzds2fomvXrqthiWEpiQ08vr6+NGbsMOr/csEKYRPj0ycffU3/Xo+lzXuWkHgZ6MvUybNo2ZI1HBL1h8H2MW9MVIt2reSUc3LyhzNo3rcLVSihGCZv3oxXu41+dxgNHNpX18f2LXtp5LBxNGPOJOr6eEfd9tOnz9GzTw6m/44ZQkNe76/b3rPby/T3oaPqvVaP8vcrQ/rSf98ebNaAoNvZTn/MnrGADd2HaPu+FVQkOMig1wXzFtEXn31D3//8Rb4YJ//5+wQNeWkMxcRcVeevp7cnpfC5LB5Z+oaPJb+tpBnTvjMYW99e2QaHtu1a0vcLv9B9PvPL7+mP31fTkTObyZ+/H1pZ/OsKmv75XFq+9gedYXnHtgils/cnjqKffvidzp2N0oWM9hvQi8ZNHKnbXwypctynez1GKalp9Oeyv3Sf1a1Xi375faaBUVU+/HzKN7RqxTpdO0s5J/9YvJqmfTqHpk7/kD6ZNJOuX/tXN463x71O/xncR9eH/PHXqs00ZuRH/HAiQbHLzMygN98ZRh+P/5IGvPIcvfOh64W+G0zQ6M30qd/R2lUbaVvEMv4uDaFLFzXGamk2YCDP9wPNfF99+W1+WFOeflr8lUEPH7z9GcVcvkpb92muA2uZ34Rxn5Po7cTxU8rg/Uyf7iS5Xa/EXFHvP/rkberd94mchuW0n8n5kZyUSqdPRSojQ0zMNVq2eC2JAbIeGyrk71p1q/JnmXSKDQ0i8sCrWYuG6rNNG3aoNAQ7t+3jfI2FqdMjGkOtGD1OntC0l32ac/sq1SsacLjx7036c+k6erBDS0pOTqb1bPyVhy8PdmhhYvAV4+nmDbvoyOHjdIuN+OH8cKJp8/rKCK0vci3K4hxtB9hoKvLrT39QYKAmj2TV6hUMHiTIdfp/P2d7w/v6+FDPZ7sZ9Kd9Ix6iSxatppPHzqjUHo3Z2PLwo+0N2sqDg/Xscdq5azu6evUabVq3g27zA6eHmEmrts3M9usOGw/uP0KjXhtPUWzE8uPrqFyb5T41+t3XqO9LPQ2m+PqQcep717BxHZr91Q/qoZDoQa7lP/42w6xB0x0YOdsc5Hs2ilOfbN28S90X5IGa6OHJpx+l8ZNH6+6H8rBP7mXmfvdIH32eGkKd+OGMvnFS7tejX59Ip06K0dNXPewRb84Rbw6iwa/1czYUTjWetERZPfH6KcG6dBT2GLwX1yMoHOZNCdc4LPxaBoyT9oCKPnQE7GthAFgQAAG3JRDPFbJF/MPsH/5RtKI3pRzJoIgZCVT3+UAO7+YnfYgYdfi5JD9xmvDirU/fHuxVVYf82UvoAC8iZk77Xi22q1SrQG2MPL4cPkgHH/DRxzupUL+d2yMM5i5P+bdu2c3eP03ZK7KEwajmL/ySMtgAcfL4Ger37GsWRyweBHPn/ExtH2xJ46eMVkY68YTcunlPnsOsqlevRIOHvaAMAsGhRekEL5DnzVlI3876icqULUUvDHja4rjs9cHTzz5G25jRsiVrDY4nXp0rlq2jihXL8cK/ub0OZ9CPhJteYyPcdz9NUx5aUljjzKlztObPTQbthrDX18tDnlfbXnruDYq5dIXWbFmoa6PvHXmvA50+dS69+e5QerxHZ2Wk+ZgN0j/NX0z9Bjxj4hmyds0W6vJoB4o4sobiOIff1MmzaQ0bzhb9+qfJw4FJn73Fhs+R/AAhmTo88FSuwxNj+viP36TWDzZTRptJH3xJ38z6kZ5lI1nAXW9S8fYczcb14sWLsUH0a+UluIuNrKOGj8+1f1dv8MbQ96nzIw8qY1OxYiHKqHXt2o17nlaHh1rRdz9/Tv/pO5IWLVxOb419jZ7o2YX69R6uzkNXNU7OmDaP5DyJi4tXhgS5P2RkZfC2WDYqpCsj36ChL6jz8sfvF7O3bjo/dIljz8qDtJdf4nksIdtTJn6lqstnGyeP0OqVm5Rh4jh7g4sB19g4KUbgCe9/Ts9HPq0eDFWpWpFOskHjpx8W02fTP6AeT3fR6ev9tz+lv9ZuoRo1qrLHbyht/zlCPRDRNzhLYzEOikfxv9c1ut68cZfu+tsu5QET4+Ri/i6KXGGjbCYbZ80ZJ8WIKnqPPHOOmjRtSLcTk9S1XnL6fjl7vPIgFRFveJlPVNQlNoouVd5mR48cp5/5Ycac7z+h9uw17W4iRtuRQz+gFC7kJfdKMcJevBBDkvP3g3c/VZED8vtDX46yl72fn696gODByffmzFzA59Yi+v6bX2nshBHuhsgp5/Pxh9OVYXI0P6iS3w/yYOLzKXNowbzfVFTC8FEvq3E3bdmQKvC9fQ1/l40LAUp6B/l+y71QK3KfG9jvTfZKL0Q/L57Jv1kaqd+d381eSJ99/DVV498y2muEU4K5z4MqWceHC+EQXT+aRkc53LpaZ3/O2Z/7AipqSzJdP2GYM1KmUpX316XssjC31FtZyllFRDwpISBgTwIoiGNPmugLBNyYwO0rmiTJhYrkftOzFUOjl4LInyt+J8ZyyCEndV4x+Dpt+ZDDWDelUFam5qmgrX2ive0EJExnxjcfUSs2XoixQjwFm3I+sVfuGm82r99le6cuvke3Jx5Snhor+Ue1vmxav1MtxrtxDjVjkbDrYsVDcg05O3PqvNr1sScf1nkPSshxl8c65Ln69eQvxiovHQl7k4WwhCaPeHOgmsuWjTuNh5wv78UbSDyk/vh9jUH/KpSPPT67P/WIQWi0PQcRFRXN4Wa1qF3HB6gQey3JvKvXrKJbQGmPJee8nOvqfPf0UKy07+V/fe/Iex1flWoVqddzj6u+xLgvBm/xODnExmljSbydqEJFRW9SNXzwcI3XiBQeMRapEiznWVhx6/LeNeNFoyzyJDRZzrHWDzZX57AY0bUiRlMJuR05ZpA6Z4SbhKA/0+dx48O73fuq1SopQ4fMu0SpMMWqzws97nmeXR7ryDkJQzh0vq7qQ8734iWLUZ161enixZh77vd+77hi3QLaeWiFMqT14+q+8vebb73K52Io7di/TL3v/0ov5cktf78+6hUqUZI9JQ8up027F1OhQj40ccoY9dmiFd/opvPyq8/T7yvn0pezJuY6xfVrt9JPi75S7bfsWsrGx+Js0FtisN/TvR+jLbuXqjaz2dC3NWIp9e3/NM375hf2bD+ha7uAve8WLp1FvZ/TeLLOnjdFvZeXsdeW5NuV/uTVoZNlw+GcGT+qtBXf/TiNvv/1CzVP8YYXT2fjByQykG1s9FnGXtfS74Ydi8nLy4vnszRXDq7Y4I/Fayj6wiV68T/PqOuhXGMklH/iJ6PVdL75+meTaYkXtxi/JL2MpEiR65MwOnzomElbbLA/gRhOA7Lij7XqYezAYX3VvUzuP2PHj1APGRf+uFQ9mBCRe+gj/NvjxPHT/JDhtMFgxGAp31V9o/vXX8xX0TpDX3+JWrRqovvd+dn0cRxNEkxfT//B/hNyox4lpLpSp8IqtFsKk64ZeYPWvhFLhxZwMVGOeLMkUtgmcl2Syctcjkp5oMzPn0iKl57bmkI7P72ljudXxJOKlLa/w4qlMWN7wSAAc3fB0DNmCQJ5JnAnWWMk9PSxv3FSDJ6dPw2lsxtT6NLOVLp1OY0rxHG175/TKXJtCrUbVwRFcfKsQes7kFCzv/lHv3iGpHKIqXgBioj3S0ETWQy15B/M4mkmYe/igScilWclDE0KPNyrtGrbVC3MflmwhMPWwql+o9p2DbeWECrJnyf5BZPv5sAMCytG8fG373XINu0nhr9ujz/EYeu/qFxh2lx9EuooC8uebDzIL2nWrCH9tWYzL5r+YE9EjZE2v46VW78tjHLraY1V/5rxyqvXoLZBTlHJE1qkSBB7dd3M7TC5fv5Aa8NwVgmTXPTrcrp2Nds78Dh72IqIUVdfxNvy6+nzcz2GKzd49gX7hlkHBWkKCIgHukjgXe9UyZ+XaKaitSuxk3yB4uE39G4qib27D1IDPneNU1/InCL4YYSc82K0EIO8pApp3rJRnqYrHuHaXHdioG/QqBaJJ7q+yEM2fZFr7ZO9uiovy5PHzprkysvTgIx2/nP5emrdprkqFKSVF1/pTd9/+z/lSa6fmkM+b9u+JVWrUUk1FW/Sevxg5QIb8NxRtKH7xl6hkqNVQrXP8IMrYxGDln5uwyDOSViT24uHKiT/CZw6cValo5B0Cvoi3ynxfP3lxyXK+7UyP1ATeaLnI2xk/pH+/OMvXc5mMXDu3X2AevV5QuWr1Mo+jiaQEO7r7Lk8V88wncnWrzL8+0u8qMXwqb9P/s/YtY5Qv08AlW3uy4VxUunG8TRKScigqK3JFL09hRq8GETlWxUymVC954MorLqpGSiguKmx8XJECi3nl774BXlRixGc/9z+S0KTsWJDwSJgelYWrPljtiAAAlYSCCypuWGl3rL8JM7Krsw2kwrdVTv7qZd4S57bwjmtliVS4r/pJNW8JQEzJH8JyNPRD96Zyjm1lqofouLtEqKX0Fzy4hVE6db9IXp39Me0ddNu5U2VyKHX27ft5QVlK5JF0r2KGD7f4JxKCzj0sdcTA1XOSSmq8Qp7EIkHQV5E8j3Omfmjyhso3gclSoap7iQUU794T16OYc2+z7DHoBgnf/91pcpVKOfQxvXbqXXb5vmaK0w8Dq9e/ZfeGzOZ3n/7E6oFSrUOAAAUsklEQVRarTL14JDavi8+ZZK70Zp55KWNLKL1JYDz7IlIKKmxSAibvoixx5+NWRIam1epWcdoHHerIeuPQx5IyPmiLeqjPaYYtd1dKlayb/EFHy7CJKJ9oKH935vzFEq+RFcWCc8Wz5nmXCxJRPJF9nrevHFXCuD8Z9Bzqp0UM6lRk8Os2YM0L9KcvYD1pXyFcM4/uZXHlKULmZack5LKYgtft6/ztSAlJUXlwRS5xdfF/BK5P1zj/JGPsuesvohxJZwNj5I6wljE2KovUowpemuEcTO3eC+h+SIlS5kWiRMvcMnXLJ7lYvjSSmUuEqb/Xrb7+fnRzVhNjma3AOPEk7h0UXPOSroPYyleQrNNck1qjZNiaK5Ttyb9tXorjXrnVfWdlAe6otfHnjB8oCvF2rz5uyFGe3NSga/L8Rz6nddrhrm+3WlbsSpc/GaIxuirKmpzAdOrR1Pp7wUJVLqhj4mDR+FQLypS1jozUECIN4VU16Tb8gv1pODyXlS2CRs8YZh0p1PIaeZi3VnpNMPFQEAABO4XgcBSmh+KafH5H2btweGVlTv4UXAFL9o2KY5i+UkgJP8J/Dx/CYeSLeYfjw/T0BEvcWXoiupHpeQXa9GgqypaVBClKy8yJ3wwjcQbRoyTa1ZuVqGvj3HId15FQh/7c3jbqhUbuVDETtrEhrvNHHb97gcj6KWBz+bavXhzGsuOLXtUrqYWLRvT21zMQ7zvxMglldjbNO2hFvCOEvEGkhxSa1ZupNHvvcqFRzarUOKevc0XkbDXuMTLRkIpJYR8IxeZkON+MonDQBetpDWbf9EZMOx1PG1IW1770+aiy2s/97q/ePklcn48fSOP9JWamnqvXbrMfsYGWWsHns6FIQqK9Os1XBkYrrGxz4fDswdz0aksfn+eC5usYC8peYDzMhdYkpQVkrtRimZcvnyFC8Os4srlWynqXDSJR1Tfp4dxmoXKBkWhbGEYxN7E+uJ5N4ej9ryVa93gF0dzgY2z7N3eWXlulmCDqHggS5EqbTSALce0tu2teI3hs3CAxmNWfz/xmr3xb6xJV0FFNAV4tB+o+TjwOm0yoHzc4MPGeZE0jsowljv8wEaKBxkbIu/3ddF4nAXtveSWFTF3rdM+OPMtpGmjZfMoF+77lH+HSAXuRk3rqXyy4hnb3CiSwLdQIQoJDaHVm0zD+QsaZ3vNV/JAtnyjCG14O07lhvz31B02UBrqx5ZjBXPF7yav3PuDeFuOhbYggJyTOAdAAASsIhBc3oe8OaT79vU7lHwzf7wnjQcSXN5b5YHLLDhrP2MEDn2/a8d+VeBgNBfvEKOSdkGwaf0Oh47D2Q4mlabbsZfk9s27KYnDMdf8uVEVDOnY2XLOMVvmIHkmn+7zGM2cO4nWbfuf8qBcsTS7WrP05c/J4kUk9ElfDu03zUW4g6vgigwf9R8VCqcNtTyw72/l0ZOTFLq7wEiwIvRbEtiLJNxKzKlLktxvYqCQSrTL2TtC8lA+zPkoHSFN2SNp9NihtG77/+iJp7qoXJf72HvLnEio+Z27nlXmPpdtkq9R5LpRSPbfh7Krs1va1xW2SxidFCyQED19iTrvniGmtuhEjCY3bhiGkUoBqxPHDPOq2dKnq7Vt2Li2qposHtkNG9VVf8s9Q/JNtuvwgHofxp5UkkNQ/pYcjRKS27Z9C/WQJCbmqirSJZ9Vq1E536Z/jENB93AIae/ne9CHH49ShXIk/NQao6QYX/Mi4uElYarmQo5jY2/qvNjzcgxX3rfM3QJyly4ZXmPEsHz16nVVsA3iWAJybRMRb2NzUia8pNpszutX0saIiFewvjz+pCan9MplG+jcmQt0+OA/nIuynYnhuXyFsup3jTzIgNiXQFA5TcSbtqK3fXtHbyCQPwRgnMwfrugVBNyOgCf7WZdvzyHX/APy8AJTY0RKbCZp81LaOvlL+1LN7nt2Qyp7aWSRH4cfQPKfgCzK5Aei8Y/Ejeu25//BnfwI4iV582Y8V91dQTs4pLs9F0OQQit5EWPO0lfpMiU552Awe/gYeteULK0JgTsQccTgkLt37jcZgngNiUg1VH3Z8FfuetQuMPZxrsrcJLy8ZjGyn42eOYnk5ZRwvW9n/aLYde3WURfqmtN+9/qZXKOMDQziiVOrdjXVpaUKzDJGMd7KQsqSlLwbHh+xJ5uPhKofOJAzA0v9Odv2h7hatYhUDtaXpez5VtBFwhdPsyeeeJJrRXItijG3oMjItwbToGEvUGxsHL08qA+HbA5hY2QoNWpcV/0tL3kgIsW45O+Q0KJcVK2++rtj51YK03vj31Dv81JsKDfe4p0tIkWw9EVSSliSYH4oJHL6VKSlJlZtF4NszdrVaffOAwbXoUvRMar4VPV8NMpaNcD73EgKc4msWLreYCRb2dP26pVr1Ji97CCOJSAPYOWBq7nCazKSuvVqqgcQa1dtUREYWlEpbrbuocpVKqrfLvoiBs3mHL0hHtPLl2pCtqUomLF06txGPexYtPBP44/Ue3kgDLFM4NalOxQbaWrYFaeOa1z0RiSkItZQlgniE2cjgLBuZ9MIxgMCTkygVvcAuhKRRlePpNDm9zOodPNC5BvgQf+eTKcr+1Opw4RQCvQ3TEISszeNEjj/iTlpMZyTKbOcWp5MB+cmUMkGHMpdmb0l+T565UAaxZ5N5ZQmHlS9u7+53bHNzgRas2fJujWbOU/fJyo3n1SdXrF0HZ09G2XnI7led+IlKcarr6Z9p4wRj/fobHYSp0+eU6GLIhd5MSoSyfzWr9mq/pbQUfHgEfmOjXVSLKIrF42pWr0CxXH+rNV/bqJzkVH03AtPqTZaqV23OodEhXP+tF006f3pXLCkBVd43UvRd4+h37Zt++Y0d87PNO2Tb1ROrkqVy3FBn52cnH4dlWAvppykx9NdafZXC+iDd6fyQuWYygtWuUo5VbHZWOo1qMWLllq05LeVKkRP3ovBVipT64tU9nzk0Y4qZYBIz2fzN6Q7mRcz3R/uz0n5uygPLTmPD0T8QwvmLVLzlwJH5qRl6yZclX0djX5jInXp1oHEEBnGxTZatskuJNO+0wP05dRvafaM+Sq0vwJ7iC2Yt5jKlC7Fej5vrtt82Xb54lVVDVhEilaJSKit9jwTj/OOD7e1+diPdGvPeU/r3s1Xmkh1Wafbt+xlo8F1m/tytx3a8ndg395DNHzwWL4+9uRzPp0N7j9RmTIFy9NL8k2Kl3Gzu0Vt9nO+yef79zRRtzwkOMghnYOGvqA+28P7SYVvKWBjLOKBevbMebX5Ep/bmv9j6MjdasylSpe0KedcXS4oI6Hf87kATbFiRali5fK0mlNnHDmcXaXbeAz1GtZSXl0zp32vwr9Lc1Xo4iXCeN/sXKQX2IM4nvP2itxkA608YNKOUbbVa1hbfTZgYB8VPv7OyEmcQ7gvJSYl0UfjvlSRIAPYqFuQpePDbdQ15qf5i6ho0UBVZCXybDR9PmU2+fG9YtCwfgUZz32b++M9HlH5oSXlQucuD6rvQjd+KCs5qsV42btPd1UUbdgr71Dfl3qqAoGzOLe1PEgd9darZothyf6S9/mn+YvVd79WHc0DQv1Jvjiwt0oJMeG9z0kM+G24kJWEiEfyQ0JJBxMSGkyfcuVuiHkC8Rcz6OC3CVS0nA+F1pI8kj50g9dk149IMcssCubt5nJLnlyeRFFbTJNGBnPuyhrdsOYyTxtbHUEAxklHUMYxQMBNCHiz4bHjpBCKmJlA1zkPZPzS7Hx3AaE+ylBpLJLv5HYu69pSTQvRhQ2ZdHl/Mr+ye/D186Qaz3IVOv4ckv8Enuv/pFogSvXoHdv2qAPWb1CH5v/yBbVtZr7YQf6PyjmOIEa3Dp3aqOrG5cqXZYOVeQPXH4tXKcOOvojXgNZzQH6gr1i3QH1cvmI4/caemGPeGK9rLiGSz/Ai4B3OFakv4o3z/sSRNGbkRLWAmP/dr/RA62ZqW7/erxm0FUPi6HeG0VdfzKVRwz9Qn1Xixfmc+Z/w+wkGbY3fSDjmrHlT6MtP59K8bxYqQ+xTz3Qza5xUC3kORf+QDZlbN+/ivHIrVci2sXFSjtGz96PKOFm/YR2zCxTjceTlvReHVBZnw+KsGT8YeLVJgv6x4183axyR4/V+rjtdYyPcKg7bn/bZHEphj8i27VoaGCfF+PDq8BfVIm3CuM9VxfZ+A3orI+j0z+fmZdg27btzWwS99d+JBvvs3B5B8hKR8+jYeY1B3JaORacL/jedxo6Zwh4v29hYvpEkNP6jz96mHl1e5EWjJl+cLX26S9v+L/fiarOH1LVxz6796lz/6JMxNGv6AtIW+XCXueY0jz07D/L3uDYFcDqK85HRdIELWrRoZVp9+9SJSLrCYdyt7hr3hV3T5g3Mdn2CPQqlKJi+yHdMWyFermcDh/U1u6+5jWIAnThlDE18/0vq3+d11aRO3Ro0beYH9Ez3V8ztQjVqVaEJk8eohxhjR09SVcXlWvzx1Hd07adMnMneYxsN9n/y0QG696eidyojTfenHqZYTgHwxWff0uLfNB5hZcPL0Lc/TDUwdpodiJtvlHQx3y74jN4a+RHN4Id98hKpUq0SfT3343wtlObmaPM0vZFvDeS0Jhkq77Xc20QaNa2rK6A34s2B6qGE/L75ix9ii0gKmvEfj1ZpacyJFIUSo6NEnQwY+Jy5Jir1wy9LZvF39Qv1m2P2Vz/o2tWsVY26PtbJ7H7YqCEg+SXF+HjrUjrFRcuDSo2nqaStLVmvEDV52TA/r5ZbXJR5j/+UuEwYJ3Fy3VcCHvHxDqhucV+niIODgPMTMC4+ICPOyGTPweSzDh386mGc9yUti/yDNc8tOkwMJi9LOZS5pkbchTuUeiuLb4xe5M8V3PIqksvy9tVMykjLpKDSXhQQxi6UpvZObpNBu6dqks4nxqZTYJgPdZocnNfD27S/l4cvhRY2DBm7HzqzadBWNr55I04VOKhQsZxDKztbObx7buasOovhnE1SJVnyPYrBMjDIsDiC/oQlhPgMhx2WLVcmV91IyJUYm0uw90+pu3m+7hleHneUSp2vDxnLxtRR9MKAp63uLS86E2+saK4gmpCQSKXZ80rCzOxVWCGWvyMXue8aHDaa1/B+q2E4uKHclzJ4sSqLRwnzf7bHIJow5a1cw3HzojMHT9HmwwmT6KjLXG07RRV0sdf5ZPNA7LiDO+srhfV0jg2oYWGhNnle2guveFZGnoninMH+JGkw7HW+uIvObvO1+ezp88rQX4o9Vd1Z3EVn4jF5hnXmy4WNKkkVdTbG20u03xf5nSO5R+93hW5n0Zk1a7MMtjUmxNyhJE6x5R/sSUV4DeXlZ2YBZS9lmenHWddm5tbYZoaPTU5CAJ6TTqIIDAMEnIGAhGmn8lMzrXjk9JuD73nBFex7CfEP8SR55SZevh4UFK5pFxReiALZOAqxH4EQDuORF8QxBEpzERJ5WSMSIq0NHcytvXg2iYfT/RbJ/zh/7m/Ky0IKUzhKpNBQjVpV8+VwEuomL3cUWXz6+PooQ4oYJkU2sBeleFWKh2hBFmEi3sUQ1yAgBazMhZI6avTy/THOe+moY7vCceRBXIMCfk1xBT3pj1HuDfn1ncL3xfzZYM3aTBxJZE0WXMF8H47YirWZIyi7/zHsa1lwf16YIQi4NYGG/QJdYn5iwNTmq3SJAWOQIFAACUjOKMlHuZOrh/99+CiNGDWQ88C5xjWmAKpLN+URQ8Ypw6QUrvDgHHmrlm9QuRZ79Oyab4vSgswbcwcBEAABEAABSwSwNrNEBtvdkQCMk+6oVcwJBEAABEAABO4zgcuXYuhPDueWKsej3+WccUOtzxl3n4deoA/fnAudLF28WuWvTLuTTlUqV6BRb79KLw8xnzOsQMPC5EEABEAABEAABEAABOxCAMZJu2BEJyAAAiAAAiAAAvoE2nBhns17fgcUFyPQ/5VeJC8R5GpyMeVhuCAAAiAAAiAAAiDgogRyT+7mohPDsEEABEAABEAABEAABO6dgL0KeNz7CLAnCIAACIAACIAACIBAQSAA42RB0DLmCAIgAAIgAAIgAAIgAAIgAAIgAAIgAAIgAAJOSABh3U6oFAwJBLQEvDzwFXXWs8GSbixtd9Z5FKRxWdKNpe0FiY2zztWSbixtd9Z5FKRxWdKNpe0FiY0zztWSXixtd8Y5FLQxWdKNpe0FjY8zzteSbixtd8Y5FLQxWdKNpe0FjY8zzhe6cUat2DYmj/j4+CzbdkFrEAABexNAXi97E0V/IAACIAACIAACIAACIAACIAACIAACrkAAYd2uoCWMEQRAAARAAARAAARAAARAAARAAARAAARAAATckACMk26oVEwJBEAABEAABEAABEAABEAABEAABEAABEAABFyBAIyTrqAljBEEQAAEQAAEQAAEQAAEQAAEQAAEQAAEQAAE3JAAqm24oVIxJfcgIHkoIc5LwMPDw2Rw0JkJEqfaAJ05lTqsGgx0ZhUmp2oEnTmVOnIdDPSVKyKnawCdOZ1Kch0QdJYrIqdrAJ05nUpyHZA5nck2rM9yRec0DWCcdBpVYCAFmYCli2lBZuKKczenR1ecR0EaM3TmetqGzqAz1yPgWiPGd8y19CWjhc6gM9cj4HojxvfM9XQGw6Rr6Qxh3a6lL4wWBEAABEAABEAABEAABEAABEAABEAABEAABNyGAIyTbqNKTAQEQAAEQAAEQAAEQAAEQAAEQAAEQAAEQAAEXIsAjJOupS+MFgRAAARAAARAAARAAARAAARAAARAAARAAATchgCMk26jSkwEBEAABEAABEAABEAABEAABEAABEAABEAABFyLAIyTrqUvjBYEQAAEQAAEQAAEQAAEQAAEQAAEQAAEQAAE3IYAjJNuo0pMBARAAARAAARAAARAAARAAARAAARAAARAAARciwCMk66lL4wWBEAABEAABEAABEAABEAABEAABEAABEAABNyGAIyTbqNKTAQEQAAEQAAEQAAEQAAEQAAEQAAEQAAEQAAEXIsAjJOupS+MFgRAAARAAARAAARAAARAAARAAARAAARAAATchsD/AewN7LrUmvPcAAAAAElFTkSuQmCC"
    }
   },
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![image.png](attachment:image.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Picture from great [Jay Alammar's blog post](http://jalammar.github.io/a-visual-guide-to-using-bert-for-the-first-time/)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#!pip3 install nltk"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_sentence_embeddings(model, batch):\n",
    "    model.eval()\n",
    "    with torch.no_grad():\n",
    "        return model.bert(input_ids=batch[\"input_ids\"],\n",
    "                          token_type_ids=batch[\"token_type_ids\"],\n",
    "                          attention_mask=batch[\"attention_mask\"],\n",
    "                          return_dict=True)[\"last_hidden_state\"].cpu().numpy()[:,0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "X = []\n",
    "Y = []\n",
    "\n",
    "conll_train_dataloader = torch.utils.data.DataLoader(conll[\"train\"], batch_size=32, collate_fn=PadSequence(['input_ids', 'token_type_ids', 'attention_mask', 'labels']))\n",
    "wnut_train_dataloader = torch.utils.data.DataLoader(wnut[\"train\"], batch_size=32, collate_fn=PadSequence(['input_ids', 'token_type_ids', 'attention_mask', 'labels']))\n",
    "\n",
    "for batch in tqdm.tqdm_notebook(conll_train_dataloader):\n",
    "    X.append(get_sentence_embeddings(model, batch))\n",
    "    Y.extend([0] * len(batch[\"input_ids\"]))\n",
    "    \n",
    "for batch in tqdm.tqdm_notebook(wnut_train_dataloader):\n",
    "    X.append(get_sentence_embeddings(model, batch))\n",
    "    Y.extend([1] * len(batch[\"input_ids\"]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "X = np.concatenate(X)\n",
    "Y = np.array(Y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import sklearn"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dataset_classifier = sklearn.linear_model.LogisticRegression(max_iter=1000)\n",
    "dataset_classifier.fit(X, Y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "wnut_test_scores = []\n",
    "\n",
    "wnut_test_dataloader = torch.utils.data.DataLoader(wnut[\"test\"], batch_size=32, collate_fn=PadSequence(['input_ids', 'token_type_ids', 'attention_mask', 'labels']))\n",
    "for batch in tqdm.tqdm_notebook(wnut_test_dataloader):\n",
    "    x = get_sentence_embeddings(model, batch)\n",
    "    wnut_test_scores.append(dataset_classifier.predict_proba(x)[:,1])\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "wnut_test_scores = np.concatenate(wnut_test_scores)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "%pylab inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.hist(wnut_test_scores)\n",
    "plt.xlabel(\"WNUT score.\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "score_indices = np.argsort(wnut_test_scores)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "wnut_predicted_labels = np.array(predicted_labels[\"wnut_test\"])[np.argsort(wnut_test_scores)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "wnut_true_labels = np.array([list(example[\"text_labels\"]) for example in wnut[\"test\"]])[np.argsort(wnut_test_scores)]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "After sorting true and predicted labels based on WNUT score let split them into 5 chunks and measure F1. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "predicted_splits = np.array_split(wnut_predicted_labels, 5, )\n",
    "true_splits = np.array_split(wnut_true_labels, 5)\n",
    "score_splits = np.array_split(wnut_test_scores[np.argsort(wnut_test_scores)], 5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"score\\tf1\")\n",
    "for scores, true_split, predicted_split in zip(score_splits, true_splits, predicted_splits):\n",
    "    mean_score = np.mean(scores)\n",
    "    f1 = seqeval.metrics.f1_score(true_split, predicted_split)\n",
    "    print(f\"{mean_score:.3f}\\t{f1:.3f}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So:\n",
    "\n",
    "**The bigger domain shift the lower f1 measure**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Part 3: domain adaptation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*HINT:* In this task you will have to run a multiple experiments and compare metric curves between them. While you *could* do everything in pure matplotlib, your notebook will quickly spiral into a hot mess of unordered plots and irreproducible results.\n",
    "\n",
    "In order to manage all your plots and results, we recommend using specialized frameworks. You could use `tensorboardX` or `visdom`(even [in colab](https://stackoverflow.com/questions/47818822/can-i-use-tensorboard-with-google-colab)), but they only work on your local machine and do not let you share your results with colleagues.\n",
    "\n",
    "If you want to show off your awesome learning curves for everyone to envy, you could also use cloud-based services such as [weights and biases](https://www.wandb.com/), [comet.ml](https://www.comet.ml/site/) or [neptune.ai](https://neptune.ai/) (recommended). We encourage you to try them for this homework, but you're still free to use any library you want.\n",
    "\n",
    "If you're interested, here's how to set up your project in Neptune:\n",
    "1. Sign up at [neptune.ai](https://neptune.ai/) and create a public project, e.g. `ysda-hw5`\n",
    "2. Install neptune: `pip install neptune-client`\n",
    "3. Initialize your project:\n",
    "```python\n",
    "import neptune\n",
    "neptune.init(f'{USERNAME}/ysda-hw5',\n",
    "             api_token=API_TOKEN)\n",
    "```\n",
    "3. Set the experiment parameters (any and all values that you want to keep track of)\n",
    "```python\n",
    "\n",
    "PARAMS = {'decay_factor': 0.7,\n",
    "          'n_iterations': 117,\n",
    "          'lr': 0.33,\n",
    "          'training-data': 'wnut',\n",
    "          'tokenizer': 'default'\n",
    "          'additional_info': 'Removed some suspicious training samples'\n",
    "         }\n",
    "\n",
    "neptune.create_experiment(name='my_first_experiment',\n",
    "                          params=PARAMS)\n",
    "```\n",
    "\n",
    "4. Dump your metrics (in training loop):\n",
    "\n",
    "```python\n",
    "# log some metrics\n",
    "for i in range(1, PARAMS['n_iterations']):\n",
    "    neptune.log_metric('iteration', i)\n",
    "    neptune.log_metric('loss', PARAMS['decay_factor'] / i ** 0.5)\n",
    "    neptune.log_text('text_info', 'some value {}'.format(0.95 * i ** 2))\n",
    "\n",
    "# add tag to the experiment\n",
    "neptune.append_tag('quick_start')\n",
    "\n",
    "# log some images\n",
    "for j in range(5):\n",
    "    array = np.random.rand(10, 10, 3)*255\n",
    "    array = np.repeat(array, 30, 0)\n",
    "    array = np.repeat(array, 30, 1)\n",
    "    neptune.log_image('mosaics', array)\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 3.0 Intro"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Your task:**\n",
    "\n",
    "Fine-tune your model on in-domain data, investigate how it affects model quality (both in-domain and out-of-domain). Find out the optimal training strategy.\n",
    "\n",
    "\n",
    "**Evaluation:**\n",
    "\n",
    "The main performance metric for NER is F1-score. You can use the canonic implementation from `seqeval.metrics.f1_score`. For simplicity, please measure F1 score with the same tokenization as used above, i.e. without removing BPE-segments or special tokens ([CLS] and [SEP]).\n",
    "\n",
    "You will need to track validation metrics on both in-domain (WNUT) and out-of-domain (CONLL) test sets. Here's how  you could do that:\n",
    "\n",
    "```python\n",
    "ner = NamedEntityPredictor(model, tokenizer)\n",
    "predicted_labels = {\"wnut_test\": [], \"conll_test\": []}\n",
    "\n",
    "for batch in tqdm.tqdm_notebook(conll_test_dataloader):\n",
    "    predicted_labels[\"conll_test\"].extend(ner.predict(batch)[\"predicted_labels\"])\n",
    "    \n",
    "for batch in tqdm.tqdm_notebook(wnut_test_dataloader):\n",
    "    predicted_labels[\"wnut_test\"].extend(ner.predict(batch)[\"predicted_labels\"])\n",
    "    \n",
    "    \n",
    "conll_f1 = seqeval.metrics.f1_score(y_true=[list(example[\"text_labels\"])\n",
    "                                                             for example in conll[\"test\"]],\n",
    "                                                     y_pred=predicted_labels[\"conll_test\"])\n",
    "\n",
    "wnut_f1 = seqeval.metrics.f1_score(y_true=[list(example[\"text_labels\"])\n",
    "                                                             for example in wnut[\"test\"]],\n",
    "                                                     y_pred=predicted_labels[\"wnut_test\"])\n",
    "\n",
    "```\n",
    "\n",
    "**Models:**\n",
    "\n",
    "Feel free to use any pre-trained transformer of your choosing. However, we recommend that you start with `dslim/bert-base-NER` to avoid potential side effects.\n",
    "\n",
    "\n",
    "**Data:**\n",
    "\n",
    "Use WNUT and CONLL datasets loaded above, as long as any additional data that you see fit.\n",
    "\n",
    "\n",
    "**Grading:**\n",
    "\n",
    "To get the maximum grade, you will need to run several experiments for parameter tuning and summarize your results in a short report."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 3.1 Supervised DA [4 points]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### 3.1.1 In-domain fine-tuning [2 points]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Your task:**\n",
    "\n",
    "1. Fine-tune your entire model (all layers) using `wnut[\"train\"]`\n",
    "2. Fine-tune the model again using only the final layer (`model.classifier`)\n",
    "3. Compare results\n",
    "\n",
    "**Hint:**\n",
    "In order to \"freeze\" some of the model parameters and prevent fine-tuning, you can manually set `requires_grad=False` for all parameters and then manually set it back to True for the ones you want to train (more info [here](https://huggingface.co/transformers/training.html#pytorch)):\n",
    "\n",
    "```python\n",
    "for param in model.bert.parameters():\n",
    "    param.requires_grad = False\n",
    "```\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### 3.1.2  Resampling methods [2 points]\n",
    "\n",
    "1. Train a binary classifier that tells `conll[\"train\"]` apart from `wnut[\"train\"]`.\n",
    "2. Use the classifier probability to select top-25% samples from `conll[\"train\"]` that are most similar to `wnut`.\n",
    "  - note: use leave-one-out predictions: split `conll[\"train\"]+wnut[\"train\"]` into N chunks;\n",
    "  - for each chunk, train a classifier on all other chunks and make predictions for the remaining chunk.\n",
    "3. Try fine-tuning your primary model using 25% best samples;\n",
    "4. Alternative: fine-tune using the entire `conll[\"train\"]` dataset with sample weights. Use $1 + p_i$ weights where $p_i$ is the probability of `wnut` for i-th  according to your classifier."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 3.2 Unsupervised DA [6 points]\n",
    "**Your task:**\n",
    "\n",
    "Train and evaluate domain adaptation using unlabeled data.\n",
    "\n",
    "##### 3.2.1 Proxy-labels methods [2 points]\n",
    "\n",
    "1. Use pre-trained bert to make predictions for all `wnut[\"train\"]` samples,\n",
    "2. Select top-50% training samples where the average probability of the predicted is the highest,\n",
    "3. Fine-tune BERT using the proxy-labelled data\n",
    "\n",
    "##### 3.2.2 Unsupervised pretraining [4 points]\n",
    "\n",
    "1. Download the reddit dataset\n",
    "\n",
    "```python\n",
    "!wget https://ysda-seminars.s3.eu-central-1.amazonaws.com/reddit_sample.json\n",
    "reddit = datasets.load_dataset('json', data_files='/home/ubuntu/data2/nlp/reddit_sample.json')\n",
    "\n",
    "# alternative download link: https://www.dropbox.com/s/zmiv3oq7girdvla/reddit_sample.json?dl=1\n",
    "```\n",
    "2. Use the method from (3.1.2) to select 100,000 best training samples from reddit data (that most resemble `wnut[\"train\"]`)\n",
    "3. Fine-tune the BERT model on those samples using Masked LM objective (see `transformers.BertForMaskedLM`)\n",
    "4. Use the resulting model to classify `wnut[\"train\"]` with the best fine-tuning strategy from previous experiments.\n",
    "\n",
    "Feel free to try any alternative models, fine-tuning methods and datasets. As usual, we will award bonus points for extra experiments and analysis.\n",
    "\n",
    "Good hunting!\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"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# <a whole lot of your code here>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Bonus assignment: Model Compression\n",
    "\n",
    "![img](https://i.imgur.com/yOHM1ZNl.png?1)\n",
    "\n",
    "Imagine you want to deploy your model as a part of your \"smart speaker\" device (such as Amazon Echo / Yandex Alisa / etc). Unfortunately, it currently takes over 400MB of disk (and RAM) space to simply store your model. Can you do something about that?\n",
    "\n",
    "Note: there are multiple ways to solve this assignment with different award scales. For instance, a simple solution with float16 precision will be awarded 3 points. However, if you combine several methods and get a *really* competitive solution, you will get significantly more (e.g. >>10 points).\n",
    "\n",
    "**Your task** is to design a way to *save your model into a checkpoint* and measure two quantities:\n",
    "* The size of the resulting checkpoint (megabytes)\n",
    "* F1 scores on in- and out-of-domain test sets\n",
    "* Model throughput (samples/s) in your CPU configuration\n",
    "\n",
    "The F1 scores must be obtained using only the checkpoint and your de-serialization code (<1MB source, <60s cpu). Loading extra data is off-limits. So, for instance, you *can* implement a custom checkpoint format, but you can *not* fetch a separate pre-trained model unless it is stored inside your checkpoint.\n",
    "\n",
    "\n",
    "Here's what you can try:\n",
    "* __Half precision:__ by far the simplest way of downsizing your model: cast it to float16.\n",
    "* __Quantization:__ pytorch has builtin support for [quantized tensors](https://pytorch.org/docs/stable/quantization.html), but you can write your own implementation to prioritize model size.\n",
    "* __Distillation:__ before fine-tuning your model, you can deliberately change its architecture to use up less disk space.\n",
    "* __Sparsification:__ you can prune off unnecessary weights, units or even layers. Use [this code](https://github.com/moskomule/l0.pytorch/blob/master/l0module.py) for inspiration.\n",
    "* __Imagination:__ there's plenty of other interesting ideas you can try. For instance, you can choose a different BERT model, or train an ensemble of models and distill them into one to improve quality.\n",
    "\n",
    "Sky is the limit.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# <Your completely optional code here>"
   ]
  }
 ],
 "metadata": {
  "accelerator": "GPU",
  "colab": {
   "name": "homework.ipynb",
   "provenance": [],
   "version": "0.3.2"
  },
  "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.6.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}