{ "cells": [ { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [], "source": [ "# Jupyter companion notebook for the paper: \"Distributional analysis of polysemous function words\"\n", "# by Sebastian Pado and Daniel Hole\n", "# (c) Sebastian Pado, IMS, University of Stuttgart, 2019/20/21\n", "#" ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [], "source": [ "from scipy import spatial\n", "import numpy as np\n", "import matplotlib.pyplot as plt\n", "import matplotlib.lines as mlines\n", "import itertools\n", "import statistics\n", "import pickle\n", "from sklearn.decomposition import PCA\n", "from matplotlib.markers import MarkerStyle\n", "from enum import Enum\n", "import torch\n", "from transformers import BertTokenizer, BertModel\n", "import pandas as pd\n", "import types\n", "import pkg_resources\n", "from sklearn.model_selection import cross_val_score, cross_val_predict\n", "from sklearn.svm import SVC" ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [], "source": [ "# software versions:\n", "#jupyter --version\n", "#jupyter core : 4.7.0\n", "#jupyter-notebook : 6.2.0\n", "#qtconsole : 5.0.2\n", "#ipython : 7.19.0\n", "#ipykernel : 5.4.3\n", "#jupyter client : 6.1.11\n", "#jupyter lab : not installed\n", "#nbconvert : 6.0.7\n", "#ipywidgets : 7.6.3\n", "#nbformat : 5.1.2\n", "#traitlets : 5.0.5\n", "#\n", "#python3 --version\n", "#Python 3.9.1\n" ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "transformers==4.2.2\n", "torch==1.7.1\n", "scipy==1.6.0\n", "scikit-learn==0.24.0\n", "pandas==1.2.1\n", "numpy==1.19.5\n", "matplotlib==3.3.3\n" ] } ], "source": [ "# list all versions of packages used here\n", "def get_imports():\n", " for name, val in globals().items():\n", " if isinstance(val, types.ModuleType):\n", " # Split ensures you get root package, \n", " # not just imported function\n", " name = val.__name__.split(\".\")[0]\n", "\n", " elif isinstance(val, type):\n", " name = val.__module__.split(\".\")[0]\n", "\n", " # Some packages are weird and have different\n", " # imported names vs. system/pip names. Unfortunately,\n", " # there is no systematic way to get pip names from\n", " # a package's imported name. You'll have to had\n", " # exceptions to this list manually!\n", " poorly_named_packages = {\n", " \"PIL\": \"Pillow\",\n", " \"sklearn\": \"scikit-learn\"\n", " }\n", " if name in poorly_named_packages.keys():\n", " name = poorly_named_packages[name]\n", "\n", " yield name\n", "imports = list(set(get_imports()))\n", "\n", "# The only way I found to get the version of the root package\n", "# from only the name of the package is to cross-check the names \n", "# of installed packages vs. imported packages\n", "requirements = []\n", "for m in pkg_resources.working_set:\n", " if m.project_name in imports and m.project_name!=\"pip\":\n", " requirements.append((m.project_name, m.version))\n", "\n", "for r in requirements:\n", " print(\"{}=={}\".format(*r))" ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [], "source": [ "# change this to your data directory, if you put the data files in a specific place\n", "data_dir = \"\"" ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [], "source": [ "class Mode(Enum):\n", " phrase = 1\n", " sentence = 2\n", " \n", "## PARAMETERS\n", "\n", "experiments = [\n", "# experiments with other bert models, or 'deep' representation, not pursued / described in paper\n", " {'context': Mode.phrase, 'model': 'bert-base-german-cased', 'deep': 'toplayer'},\n", " {'context': Mode.sentence, 'model': 'bert-base-german-cased', 'deep': 'toplayer'},\n", "]\n", "\n", "anno_files = {\n", " Mode.phrase: data_dir+\"sich-phrase.merged.txt\",\n", " Mode.sentence: data_dir+\"sich-sentence.merged.txt\"\n", "}\n", "\n", "def exp2string(exp_desc):\n", " return exp_desc['context'].name+\"_\"+exp_desc['model']+\"_\"+str(exp_desc['deep'])\n" ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [], "source": [ "# read annotations from file , and check sentences against model version\n", "# returns a dict that maps each idx onto the label for this data point\n", "def read_annotations(filename):\n", " labels = {}\n", " cleartext = {}\n", " idx = 0\n", " with open(filename, \"r\") as infile:\n", " for line in infile:\n", " idx = idx + 1\n", " tokens = line.rstrip().split(\" \")\n", " anno_label = tokens[0]\n", " sent = tokens[1:]\n", " # print str(len(sent)) + \" :: \"+str(len(internal_sent))\n", " # print(tokens)\n", "\n", " labels[idx] = anno_label\n", " cleartext[idx] = sent\n", " return labels, cleartext\n" ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [], "source": [ "# compute embeddings of 'sich' for input sentences\n", "# use final layer (\"shallow embedding\")\n", "\n", "def shallow_embed(hidden_state, index):\n", " return np.array(hidden_state[0][index])\n", "\n", "def compute_embeddings(id2cleartext, tokenizer, model, exp):\n", " expid = exp2string(exp)\n", " id2vectors = {}\n", " for id,cleartext in id2cleartext[expid].items():\n", " bert_tokenized = tokenizer.tokenize(\"[CLS] \" + \" \".join(cleartext)+ \" [SEP]\")\n", "# bert_tokenized = tokenizer.tokenize(\" \".join(cleartext))\n", "# print(bert_tokenized)\n", " if bert_tokenized.count(\"sich\") == 0:\n", " print (\"******* NO SICH in \"+str(id))\n", " elif bert_tokenized.count(\"sich\") > 1:\n", " print (\"******* MULTIPLE SICH in \"+str(id)+\", USING ONLY FIRST ONE\")\n", " sich_index = bert_tokenized.index(\"sich\")\n", "# print(sich_index) \n", " input_ids = torch.tensor(tokenizer.encode(\" \".join(cleartext))).unsqueeze(0)\n", " with torch.no_grad():\n", " outputs = model(input_ids)\n", " last_hidden_state = outputs[0]\n", " sich_embed = shallow_embed(last_hidden_state, sich_index) \n", "# print(sich_embed)\n", " id2vectors[id] = sich_embed\n", " return id2vectors\n" ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [], "source": [ "# compute all pairwise cosine similarities among instances, aggregate and print\n", "\n", "def compute_sims(vectors, annotation, exemplars=False):\n", " label2ids = {label: [] for label in sorted(set(annotation.values()))}\n", " for id, label in annotation.items():\n", " label2ids[label].append(id)\n", " labels = label2ids.keys()\n", " for idx1, label1 in zip(range(len(labels)),labels):\n", " for idx2, label2 in zip(range(len(labels)),labels):\n", " if idx2 >= idx1:\n", " if exemplars:\n", " sims = [1-spatial.distance.cosine(vectors[x],vectors[y])\n", " for x,y in itertools.product(label2ids[label1],label2ids[label2])\n", " if x != y\n", " ]\n", " mean = round(statistics.mean(sims),3)\n", " sdv = round(statistics.stdev(sims),3)\n", " ssize = len(sims)\n", " print(\"Mean pairwise cos for \",label1,\" -- \",label2, \": mean \",mean,\", stdev \",sdv,\" #dp \",ssize)\n", " else:\n", " x_centroid = np.sum([vectors[id] for id in label2ids[label1]], axis=0)\n", " y_centroid = np.sum([vectors[id] for id in label2ids[label2]], axis=0)\n", " sim = 1-spatial.distance.cosine(x_centroid, y_centroid)\n", " print(\"Pairwise cos for \",label1,\" -- \",label2, \": \",sim)\n" ] }, { "cell_type": "code", "execution_count": 10, "metadata": {}, "outputs": [], "source": [ "# plot sich embeddings in various ways, using PCA for reducing them to 2D\n", "# optionally save in PDF\n", "\n", "def plot(vectors, annotation, savefile = False, with_labels = False, drop_classes = [], show = False, extra_labels = \"\"):\n", " # dimensionality reduction\n", " all_vectors = [vectors[idx] for idx in sorted(vectors)] # sort in order of indices!\n", " M = np.array(all_vectors)\n", " reduced = PCA(n_components=2).fit_transform(M)\n", " # define marker styles\n", " labels = sorted(set(annotation.values()))\n", "# print(\"labels: \", labels)\n", " label2marker = {label: markerstyle for (markerstyle, label) in zip(MarkerStyle.filled_markers, labels)}\n", "# print (\"label2marker: \",label2marker)\n", " colors = ['orange', 'green', 'blue', 'grey', 'purple', 'olive', 'magenta', 'red']\n", " label2color = {label: color for label, color in zip(label2marker.keys(), colors)}\n", "# print (\"label2color: \",label2color)\n", " labels = sorted(set(labels) - set(drop_classes)) # skip unwanted labels\n", " fig = plt.figure()\n", " ax = fig.add_subplot(111)\n", " # plot first class 1, then class 2, ....\n", " # purpose: have the rarer classes come out \"on top\"\n", " for label in labels:\n", " for red_vec, idx in zip(reduced, sorted(vectors)):\n", " if label == annotation[idx]:\n", " if with_labels:\n", " ax.annotate(str(idx), xy=(red_vec[0], red_vec[1]),fontsize=3) \n", " plt.scatter(red_vec[0], red_vec[1], marker=label2marker[label], label=label, color=label2color[label]) # s=5: 5 point marker size\n", "\n", " handles = [\n", " mlines.Line2D([], [], marker=label2marker[label], linestyle='None', label=label, color=label2color[label]) for\n", " label in sorted(labels)]\n", " plt.legend(handles=handles)\n", " if savefile:\n", " if len(drop_classes) > 0:\n", " extra_labels = extra_labels + \"-drop\" + \"\".join(drop_classes)\n", " if not with_labels:\n", " extra_labels = extra_labels + \"-nolabels\"\n", " plt.savefig(savefile + \"-\" + extra_labels + \".pdf\")\n", " print(\"Saved figure as \"+savefile + \"-\" + extra_labels + \".pdf\")\n", " if show:\n", " plt.show()\n" ] }, { "cell_type": "code", "execution_count": 11, "metadata": {}, "outputs": [], "source": [ "# pickling & unpickling things (boilerplate)\n", "\n", "def store_obj(obj, filename):\n", " binary_file = open(filename,mode='wb')\n", " pickle.dump(obj, binary_file)\n", " binary_file.close()\n", "\n", "def read_obj(filename):\n", " return pickle.load( open(filename, mode='rb'))" ] }, { "cell_type": "code", "execution_count": 12, "metadata": {}, "outputs": [], "source": [ "# compute or read embeddings\n", "def get_vectors(compute_vectors, exp, id2cleartext):\n", " expid = exp2string(exp)\n", " context = exp['context']\n", " bert_model_name = exp['model']\n", " deep = exp['deep']\n", " if compute_vectors:\n", " tokenizer = BertTokenizer.from_pretrained(bert_model_name, do_lower_case=False)\n", " if deep:\n", " model = BertModel.from_pretrained(bert_model_name, output_hidden_states=True)\n", " else:\n", " model = BertModel.from_pretrained(bert_model_name)\n", " model.eval()\n", " print(\" model \"+bert_model_name+\" initialized\")\n", " id2vectors = compute_embeddings(id2cleartext, tokenizer, model, exp)\n", " store_obj(id2vectors, expid+\".bin\")\n", " print(\" embeddings computed and stored\")\n", " else:\n", " id2vectors = read_obj(expid+\".bin\")\n", " print(\" embeddings read\")\n", " return id2vectors" ] }, { "cell_type": "code", "execution_count": 13, "metadata": {}, "outputs": [], "source": [ "## END OF DEFINITIONS\n", "## START OF MAIN PROGRAM\n", "\n", "# main stateful data structures: a bunch of nested dictionaries\n", "# each has the form: ID of experiment (exp2string) --> ID of observation (sentence) --> information\n", "\n" ] }, { "cell_type": "code", "execution_count": 14, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "reading annos for experiment phrase_bert-base-german-cased_toplayer\n", "reading annos for experiment sentence_bert-base-german-cased_toplayer\n", "finished\n" ] } ], "source": [ "# init data structures, read the manual annotation files\n", "\n", "id2annos = {}\n", "id2cleartext = {}\n", "id2sichvectors = {}\n", "\n", "for exp in experiments:\n", " print(\"reading annos for experiment \"+exp2string(exp))\n", " expid = exp2string(exp)\n", " context = exp['context']\n", " model = exp['model']\n", " deep = exp['deep']\n", " id2annos[expid], id2cleartext[expid] = read_annotations(anno_files[context])\n", "print (\"finished\")" ] }, { "cell_type": "code", "execution_count": 15, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "computing embeddings for experiment phrase_bert-base-german-cased_toplayer\n", " model bert-base-german-cased initialized\n", "******* MULTIPLE SICH in 293, USING ONLY FIRST ONE\n", "******* MULTIPLE SICH in 295, USING ONLY FIRST ONE\n", "******* MULTIPLE SICH in 311, USING ONLY FIRST ONE\n", " embeddings computed and stored\n", "computing embeddings for experiment sentence_bert-base-german-cased_toplayer\n", " model bert-base-german-cased initialized\n", "******* MULTIPLE SICH in 293, USING ONLY FIRST ONE\n", "******* MULTIPLE SICH in 295, USING ONLY FIRST ONE\n", "******* MULTIPLE SICH in 311, USING ONLY FIRST ONE\n", " embeddings computed and stored\n" ] } ], "source": [ "# now read and/or compute the embeddings\n", "# may involve downloading relatively larget BERT models through the Transformer library for local caching\n", "for exp in experiments:\n", " print(\"computing embeddings for experiment \"+exp2string(exp))\n", " expid = exp2string(exp)\n", " context = exp['context']\n", " model = exp['model']\n", " deep = exp['deep']\n", " # Can be changed to \"False\" once the embeddings have been computed once\n", " id2sichvectors[expid] = get_vectors(True, exp, id2cleartext)" ] }, { "cell_type": "code", "execution_count": 17, "metadata": { "scrolled": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "EXPERIMENT phrase_bert-base-german-cased_toplayer\n", "Pairwise cos for 1 -- 1 : 1.0\n", "Pairwise cos for 1 -- 2 : 0.9622329473495483\n", "Pairwise cos for 1 -- 3 : 0.9607804417610168\n", "Pairwise cos for 1 -- 4 : 0.9789835214614868\n", "Pairwise cos for 1 -- 5 : 0.932038426399231\n", "Pairwise cos for 1 -- 6 : 0.8893383741378784\n", "Pairwise cos for 1 -- 7 : 0.9267295598983765\n", "Pairwise cos for 1 -- 8 : 0.9030054807662964\n", "Pairwise cos for 2 -- 2 : 1.0\n", "Pairwise cos for 2 -- 3 : 0.927716076374054\n", "Pairwise cos for 2 -- 4 : 0.9327369928359985\n", "Pairwise cos for 2 -- 5 : 0.8842349052429199\n", "Pairwise cos for 2 -- 6 : 0.8956537842750549\n", "Pairwise cos for 2 -- 7 : 0.9024401903152466\n", "Pairwise cos for 2 -- 8 : 0.8727883696556091\n", "Pairwise cos for 3 -- 3 : 1.0\n", "Pairwise cos for 3 -- 4 : 0.9543179869651794\n", "Pairwise cos for 3 -- 5 : 0.9152016639709473\n", "Pairwise cos for 3 -- 6 : 0.8633499145507812\n", "Pairwise cos for 3 -- 7 : 0.8983333706855774\n", "Pairwise cos for 3 -- 8 : 0.8826298117637634\n", "Pairwise cos for 4 -- 4 : 1.0\n", "Pairwise cos for 4 -- 5 : 0.9465191960334778\n", "Pairwise cos for 4 -- 6 : 0.8635600805282593\n", "Pairwise cos for 4 -- 7 : 0.9103107452392578\n", "Pairwise cos for 4 -- 8 : 0.906157910823822\n", "Pairwise cos for 5 -- 5 : 1.0\n", "Pairwise cos for 5 -- 6 : 0.8188003897666931\n", "Pairwise cos for 5 -- 7 : 0.8775031566619873\n", "Pairwise cos for 5 -- 8 : 0.8753293752670288\n", "Pairwise cos for 6 -- 6 : 1.0\n", "Pairwise cos for 6 -- 7 : 0.9200316071510315\n", "Pairwise cos for 6 -- 8 : 0.7920750379562378\n", "Pairwise cos for 7 -- 7 : 1.0\n", "Pairwise cos for 7 -- 8 : 0.8337368369102478\n", "Pairwise cos for 8 -- 8 : 1.0\n", "Saved figure as sich-phrase-toplayer.pdf\n", "Saved figure as sich-phrase-toplayer-nolabels.pdf\n", "Saved figure as sich-phrase-toplayer-drop1.pdf\n", "Saved figure as sich-phrase-toplayer-drop1-nolabels.pdf\n" ] }, { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXwAAAD4CAYAAADvsV2wAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/Il7ecAAAACXBIWXMAAAsTAAALEwEAmpwYAABpL0lEQVR4nO2dd3xUVfr/32dmMqkTAiQhISGFAAk9ISgiEEBpgg3UtSBKQNF1C7b97XeXzbqu61bFXkCRtYBlxQ5KUQhFlI5Ir2mE9DKpk5nc3x93JpmZ9GRC2nnzmhczt5x77p3Jc899zvN8HqEoChKJRCLp/mg6ugMSiUQiuTxIgy+RSCQ9BGnwJRKJpIcgDb5EIpH0EKTBl0gkkh6CrqM70Bj+/v5KRERER3dDIpFIugz79+/PVRQloL51ndrgR0REsG/fvo7uhkQikXQZhBApDa2TLh2JRCLpIUiDL5FIJD0EafAlEomkh9CpffgSiSuoqqoiPT2dioqKju5Kg3h4eBAaGoqbm1tHd0XSjZEGX9LtSU9Px2AwEBERgRCio7tTB0VRyMvLIz09ncjIyI7ujqQbI106kqY5vwY+i4C1GvX/82s6ukctoqKigr59+3ZKYw8ghKBv376d+glE0j2QI3xJ45xfA3uWgKWM5OOQkptC0J7F5ATsYsys3zB06NCO7mGz6KzG3kZn75+keyANvqRRQt+/l4wqi/rBDBQCJZX47n+drZPv68CeSSSSliJdOpJGudHTgt72YRPwI2gtcHWIQlpaWgf2rGuxaNEiAgMDGTFiREd3RdKDkQa/BxC6PBTxpKjzCl0e2uS+SaEhaGzehmlABLhFwerrQrnpppvas9sdRzvMWSxcuJBvvvmmze1IJG1BunS6MKHLQ8kwZtRZHmIIIf3R9JrPN0bfyKqDqzBZTJACFICul45wbTgVFRV4eHg0eIzgsf8i8eK9rCq0YEoHrQ/cVKUhaOw/2+OUOh67OQsAylLUzwCR81vdbEJCAhcuXGh7/ySSNiBH+F2YG4Njat0tAD+AZhNEn+nFwoULef/99wFISkhCI6xftQHQgQYNj936WNMHiZxP0rTn0QgBQ0A/VvD8PS+2yfh1ag4vqzX2Nixl6nKJpIsjR/hdmCTdCVYLwFaWeCiwEW4gk6T0dby96m3uOnWX407FoNVomRE1g/yMfM6cOVPHr9zQkwNAYvwvCRr2K5efS6ehLLVlyyWSLoQc4XdhgqsukmigZpQvPgffXPCoKGBYyDC07lp1xQXgJyAHiADLMAtfnf+K+7+9n6mvTuXjjz/mwIEDNe3eGH0jeq211WPq/rpzOtz3uPPLYb+8TGfXQXiFtWy5RNKFkAa/K+MVRlJfaiZVPe6F4/+BB28M57OXP8PtamuafhBQBFTZ7WsAbYGW8f3H4+vri0ZT+1NwcAEFAzmqC+iZuc/gq/W9DCfWgYx+GrRejsu0XupyiaSLIw1+V2b00wS7e5FoUL/IRF8IcleNU7AhmMTYRHWkvgc01Ro0Rruvuxi0QVoWXbEIk8mExWKpWeWwbz5o3bVM7DuRiKCI7h+KGTkfrlwJXuGAUP+/cmWb5yzuvPNOxo8fz8mTJwkNDWXVqlWu6a9E0gKEoihNb9VBjB07VpEFUJrg/Boy9/2eiacy2DUkVI2esRqnTGMmA18cSIW5Ak+dJ78Y/gve//l9TBYTeq2e++Lu45U5r9TbrPO+55aeI8gn6HKemcs4fvx4l8gI7ir9lHRuhBD7FUUZW986OcLv6kTOJ/i2dM4uUwi6Lc1hJGobqWuEhsTYRP5x7T9qXDVaoSVpclKDzTrv21WNvUQiqUUa/G5OUkISEX4RJE1OarERt99XIpF0fdoclimEiAY+tFs0EPizoijP220zBfgcOG9d9ImiKH9t67F7Ms1Nugo2BHP2t2drPiclJLHx7MZmGXHnfSUSSdemzSN8RVFOKooSqyhKLBAPlAGf1rPpDtt20ti3HYfQSYALoP1Jy5jyMbz++uvs2rWr3v1sRly6aCSSnoerXTrXAmcVRWmwarrENTiETgIEgcak4faY2ykoKOi4jkkkkk6Lqw3+HcD7DawbL4Q4LIT4WggxvKEGhBBLhBD7hBD7cnJyXNy97oND6CSg3avlyuArCTAE0KdPH6qrqzu4hxKJpLPhsrBMIYQeuAgMVxQly2mdL1CtKEqJEGI28IKiKIObalOGZTZOdwqdbE86Q7hjWloa99xzD1lZWQghWLJkCUuXLnXYpjP0U9L1aSws05VaOtcBB5yNPYCiKMV27zcIIV4VQvgripLrwuP3OGyj/BX7VzQ/dPL8GlUIrCxVlQsY/XT3FUJrBXEr4jh06VCd5bFBsRx84GCr29XpdDz77LOMGTMGo9FIfHw806dPZ9iwYW3orUTSMlzp0rmTBtw5QoggYa3hJoS40nrcPBceu8dSJ3SyMS13m/RvWQrr9ij89b0UNr2xmNf/tojUVCkOBjA+dLzjZDig1+q5OvTqNrUbHBzMmDFjADAYDAwdOpSMjPoF6iSS9sIlBl8I4Q1MBz6xW/agEOJB68dbgZ+FEIeBF4E7lM6c4tuFcIi6sTPooLBuWwpP/yGR45v/zcaNG9m25rEa6d/4SPDzAqW6kgDjl5SXl9d/gC5ewLyl1JkMp+kktZZy4cIFDh48yLhx41zWpkTSHFxi8BVFKVUUpa+iKEV2y15XFOV16/uXFUUZrijKaEVRrlIU5XtXHFfihJOWe3wkaKmi/KfnCAwMpKq01tt2Jgt6eYEA/LS59Y/wnZ4Innw3hS2rFvPOsw/y3XffXYYTuvw4T4brtXqXZhqXlJRwyy238Pzzz+Pr282F6CSdDqmH351w0mw/kwUhvSEt4xIe2dl4GfoBqtGfZi+B7xUO06fXbc/uBhIfCVlFYDJVElD4KampV7XTSXQ8SQlJrD60GnDt6L6qqopbbrmF+fPnM2/ePJe0KZG0BGnwuxNeYVZ3jkqNUfcKh5kzYcizjuX7oHHpX7sbyJksqFZApwFLZTYxMTHtcAKdg1ZNhjeBoigsXryYoUOH8uijj7qglxJJy5EGvzsx+unGDbotGqe5UTp2N5BpI5xuIFd13xE+qKP8ozlHXTa637VrF++++y4jR44kNjYWgL///e/Mnj3bJe1LJM1BGvxOTnM1c4DmGfTI+c0Pw2zqBtKNCTYEk7ww2WXtTZw4ERmnIOlopFpmJ6dezZwdWmaHz2bt2rVs2rTJcYfI+XDzBbirWv2/LTH27VQMRCKRdAyyAEonxz6bFoAKIM36/xkIuDaAt6e9jbe3NwkJCR3Y085LV8lg7Sr9lHRuZAGULoy9hj0Ae1BT1jzUOrNTwqYwfPhw3NzcGm6kh8XSSySS+pEGvwuQlJCEm8Zq0BOAqwANaAdpmd1vNitWrCAgIKD+ne1i6T/dq8bSf/7qImn0JZIeiJy07QIEG4JZFLeI1/a9hgYN1VSjH6LWpF04Z6GqUdoQdrH0aXkgBHhoTerylvji7TR4ks8FUhZyD95R17Nv3z4WLFjQ8A1HIpF0GuQIv4uQlJBEeK9w3LTqSL/ZCUF2sfRDgiHcHypM1EnSahQnyYa4oCyy976AW853BAYGNizLIJFIOhVyhH8ZaVGIpRPBhmAuPHyBh9Y/1LKEILtY+lmjnZY3FyfJhpc2wb7zJv4z8g3yBqwgLS2NsLAWtNcDqaioICEhgcrKSsxmM7feeitPPvlkR3dL0sOQBv8ycmP0jaw6uAqTxQTHgGzQhesI14ZTUVGBh4dHk200VJO2wZuJV2/Sw7zaFkvv9DSw7Gbbu0wGXX9989vpQmRmwh13wIcfQpALZHTc3d357rvv8PHxoaqqiokTJ3LddddxVTdPYJN0LqRL5zLioMQYTE2kzWO3Ptb4jnZRNsHfjufsDX+tM7p3iNdPAQ6B7ryOoVnxHO/zRNti6Rt6GmjJU0IX46mnYOdO9X9XIITAx8cHUDV1qqqqsCqGSySXDWnwLyMOSoz5oPXSMiNqBvkZ+Zw5c6b+nez85ztOKDy9NoWKnffXUax0uJkYAJ16M7nScCXlfae1LRlr9NPqU4E93TjjNjMTVq+G6mr1/0uXXNOuxWIhNjaWwMBApk+fLuWRJZcdafCbQejyUMSTos4rdHloi9uqMcxRoB+j541H3uC+++5jxIgR9e9g5z8P6QPRwYCl3KpYWetqcbiZFINWo95Mxo4aS1paWmtOu5YelnH71FOqsQewWFw3ytdqtRw6dIj09HT27NnDzz//7JqGJZJmIg1+M3Bwl+QBP4HutI6bom9qcVv2iVTNmni185+n50F+qapcST2KlTU3kwjQj1JvJnPnzuWmm1rezzq4UrKhE2Mb3ZtM6meTybWjfAA/Pz+mTp3KN99847pGJZJmIA1+M/j0xKfqRCtAMZAP5gIzn5z4pNH9GqJOWcLGsPOTJwyFJdfAiAFw3dXhdSb8WnwzkdTBfnRvwxWj/JycHAoLCwEoLy9n8+bN3VpiWtI5kQa/GcyNmVvrH0+xvnpDzIUYUlJSGtvVAZtrqP/y/pwrOEfws8FNu4Za6D9v0c1EUofdu2tH9zZMJvi+jTXaMjMzmTp1KqNGjeKKK65g+vTpXN9NI5wknRcZltkMkhKSeOvgW1RaKlVZgxBwH+ROXEVci5KOHMIyLwCFoPPVEF2dy5Y/CqZdGV6/nDE0W8PeVuNW0joOHmyfdkeNGsXB9mpcImkm0uA3A5u0wYr9K6jeU43QC24efzPxfvGkpqY2+9HcvnQeQUAFaJRqpmsqMZkheX8KKZsXETTuCABZB95kwZX5dYy8GnN/d23DF4BC6NuvL38c8kcpdSCRSOrFZQZfCHEBMAIWwOwszynUoOMXgNlAGbBQUZQDrjp+e1Mzyk+oxF3nzvP3Pt9iH7nNx77q4CpMe0xQDaZQ+EMxqtGuBnQmvA//ixdH6Ll2qIl1eyC7OIXhhxYzZf/dKIFAGHAIKASGA0GgzdVyVdBVnUrqwCEZzJpoRij4mf343+L/MW3atI7snkTS43C1D3+qoiixDWgxXwcMtr6WAK+5+Njtim2UrxEaFsUuavWEaE0kTQJop4DbICDO+soGTR6M6AUp2SbCA9Ti4cNDwE1UElBl93V5UxMxxHYgC8IKw/Dz83MIw3RlSGlLcYhusiaa6TQ6RvUehcnZUS6RSNqdyzlpexPwjqLyA+AnhAi+jMdvM66YELWPpLm7tzdaW7JlPhAFuli4Iximj1QXn8mCR96Dvj5wf2A12OrVeABeqPMAY3XMu3sev3/k91x//fVMmDCh5ngORvcYsBfcjG5Ep0ezZcuWVp9Hc3BIBstX+6wRGuaNmodOJ72JEsnlxpUGXwE2CSH2CyGW1LM+BLVWk4106zIHhBBLhBD7hBD7cnJyXNi9tmObEG3R6L6e4iNJEcOIcNOwsbiUCpsBjwLGgSkKnokUTIxWF08bAfufVpUu/zYvnOFjh6srBgBDgOGgKdZwXcB1hIeH1zl8HTmHctCYNUwfML3dR9kOyWBRoI/Xc99t97H0waXMmDGjXY8tkUjq4kqDP1FRlDGorptfCSFaVW9PUZSViqKMVRRlbJefeLSTRfjoB4WXPk0h9auFBB95jLPhZsZlgvYQcBbYBOwHXYqG6PQYdp52d2zLGor53tz3apdFATFgKjOx6M1F9F3clz179jgk9DjLOeiCdMzwn0FQ76DLMsq2v+E0W9JZ0j2QldY6HS4z+IqiZFj/zwY+Ba502iQDdVxqI9S6rHtyfg38cG+NLEK5CQJ9obzSDNXqyPrfo0CYUKe5q4Bc0Cg67p/1Z0ojltYrZRAbHEtvj96OxwoGXaSO4frhlJaW1umKvZyD2zA3Vj68koULF16WUbZMBqvFYrEQFxfXM+Lv7QY7yccV/vpeCt+sXMxHL/+GEydOdHTveiwuMfhCCG8hhMH2HpgBOAuFfAHcI1SuAooURcl0xfE7HbYfu2Jh3R44cRE83NRXal7tZv/7FsbpQacBPEHjrWF2zGzK88vxjrqhQSmDD2/90PF4+cAF+NV1vyItLY3s7GyH1R1tdLtyMpjRaGT9+vWsWLGizW298MILPadIuZ0GVFw4XDEQqK6k9OT7rW9TPjG0GVc90/cDPrXKveqAtYqifCOEeBBAUZTXgQ2oIZlnUMMyE1107A6hIf15jdBQrTjl5l+AkCBIH+i4eNnNsMgMAy+AeRC469x57VevNW6Qz69h+pFl/NIXVhWDCdRyh7ffx+1zbm9wt4Z09C8HXTEZzGg0sn37dg4dOoSiKFgslja1l56ezvr161m2bBnLly93US87MXYaUC9tArMFIgKgqDSP7Oy6OlBNYhtEWcpIPg6FpSn0OrCYA5YNLHj4eZl30kxcYvAVRTkHjK5n+et27xXgV644XmfAIWv2Z8AMul46oq+M5nTOUUwAx4GDIKoh9hpYlwuRgTrGDNTUuHWCdZDYS8uKwuqmR992P/ox5+CNo6jT3hoL18Zf22h/u6LR7QhcbehtPPzww/z73//GaDS6pL1Oj12ltdqCOajuyYRWTO85PTG8shnGDqwksHxjp8k76QpILZ1W4hD9YqZGf37NuLvQ2EIti4BA0A6EuwwwsJ8Gn3H/gHFvOfjnk6Y9T0TvyKZH33Y/+mmDYFwvEMBNQXoMOkP7nGgPY926dezfvx+z2ewyY//VV18RGBhIfHy8S9rrEri6hoLTE4OXu+oi9dPltV3+uwchg6Fbwvk1NZo2wV5hJA6cwKqzOzDpTGirVf350WkrSTRY3S19QaRCWDGYB8Kaolk8cs+dEBLi4JMPBs4O/3XTx7f70Z/JgtsC4KwJ5laXq+UR7frXlOaOpH5uvfVWkpOTXTrC37VrF1988QUbNmygoqKC4uJi7r77bt57772md+6qtFADqkkae2KwyzuRNI5QPS2dk7Fjxyr79u3r6G6o2LlTANbtgWN5bjylr6Yqy4K+v56U5SkEfdGfTLPCwAtQoYCngHMREKQD7mrjtf4souZH74CXVXTNzsd5IQdC/N0pDH6AgePvZcyYMW07dhfm+PHjLZ4sLSkpqWP4n3jiiTb3Zdu2bTzzzDN89dVXLulnj8Hp7w9Qnxi6cSGe1iKE2N+A2oF06TQbO3cKqJIH0wZVMdPTDVEhmDN4jup/9wpT/fIG9eIm+lqNvVfdpKgW09hjspOPs6QCTKZKfHM+QKORX3NL8fHxYc6cOSxdupS4uDiCXFHJXNJ6eljVtfZCunSaoKFonL4XYFVvSPSt4Ie+/twz6h51hXWkndS3jI1lkNSHen2X9u0GAzegfhkajRt/vO8HgoPrGZE39pi8e0HNZi9tAh8P0GrAVJLtMl90T8Rm+F3FlClTmDJlisva61FEzpcGvo1Ig98EDtE4x4BccBsK0fkwczJ4+IUz7+8Xanew/iCDDy/jbGTDvktbu30tJq65AMUVcO4clJRUkXHwambO/AuRkWPqJkc19KNvzMfZkyYLJRJJg8hn/Saoo0UjQGOGx4YBWs/6ow6s9V9DL/VHHE5BvHM3IlEg7hSIewV97u7DpKpJaISGG4ABQZCTA8OHg0YDZnMlx46tokXzK66OipBIJN0OafCbIDj3OxJ76dAD5IPWF66pgvziPpzR3aC6VxrI/HNQqgwCckAndEwYMoG5s+aiFVp0wJ49at1UWzhxRQUcv3iGWe/Nar6MsfRxSiSSJpAuncawRgYk+ZaxOh/QgiiEu2c+xG92vk3+to+gv3XbCynw9t1guBsyIGROCHvv31tb4WoPoAeNm4Z5g+fh4eHBLUNvwfzTOyQkwLFjcOkSxMbC8eNQXgi6QXCTJgM+iyD0dDEZZQV1uhhiCCH90XT1g/RxSiSSRpAj/MY4vIzQ02X0P6+GWBIE5v4wf8erlIpSdMJuWxNwENgHIkU11MHfjidx4AR1lJ8AXAWmUBOLTi1CPCl456d3+BKoBIKDwcPD2pQFzleDMMOEdHj7mxRGnixCr7Heny8AP4Fbnhsj8kbw5ZdfXrZLIpFIui7S4DdGWSo3eoPe9vkrYA9ocmCC3unipVOzodDC6DPg/0kKr236FtMRE1x0avsYsB0yq+C1o7DvNFR5qDpo5/tCpQ6mGWCIH1wqgh9N1Ziqzeq+QUARVFVWsbdgL6mpqdRBCk1JJBInpEunMbzCSOqbwmojanmXa4Ej4BYNayaF8tf09BoBM3SAG3AWYidCWREUHkHVuqlCvSGkAsWo1aoqAYsqmFbqVc2uPlV4DPBAURQqB1XiKeCtCLiYBsF+MM6kSuZXA2wEygEzRIVGUVxc7Nhv5ySxbSlkfJZI71E7cQ+dyqhRo1ouXiVpMxERERgMBrRaLTqdjk6TVCjpMfQog99QTL2DH9ye0U8TvGcJiYYy1bDngy4QZvjEEjT2cZJM97PaWK7eDKx6UJ4C1kfAMx9C32LIHgycQq3kawRKgV5AJWg0Gm4OuJlipZhvsr5hUewiFBRW7HutJmEr6G9FjKnw5R67bhVTzHrdeu698l4enfdoXX18axJW6DnIsIXg66og7XXY/jqB+wPJ+ldWm65ld2VF3ApCx4eSkJSAIdj1+kRbt27F39/f5e1KJM2hR7l0HKJmAI6BdruWuNI4Pvnkk7q+cGvkS1JoiCqIFgVuw91Y+cevIXI+wVe/QWIfHzTAcDfHzNpZo6FfNWiCUAuOg1rgsRI0+Rowgts4N56/93lWPb6KyGGqeFpSQhIRPoEkBXiq+1T41nQnmWTe4R1+y2/5zvwdcUocokJglaWuxaq5U+OOyre+ckAcE4wzjOOjjz6ShSjq4dKhSxxcdZAXB77I+ofWY8zsIeqWnQHphmx3epTBd4ipBwgGjaeGu0behb+/f/2+8Mj5BN+WTmL8L9UCInH310oYR84n6d5TRPQeyJrIICJ01sxa1Fq0r9wDA/cA4UAeMAkW/mMhDyQ9gOYWDYuvXUyQTxDBIcGcXXqWIEMQwb7BnH08i6C7y+A+R2MTRxy96MWd3Mld3MXSuUu5/fbb6yZneYWp59uXmhsVo4EB4DbejRcffLHeylgSFYvJgrnC7HLDL4RgxowZxMfHs3LlShf0tBvhVCHr8+0pbFu9mDf+cR8pKfXoR0laRY8y+A71XQFdkY5JQybR16svGo2GIUOGNLhvQ1WbbDrzo696hrORQtXNsRLSB34zGtWN4666cP4x7R8kJSQxxieYYak7eOWVYaqrx0oyybzO66SSypryzznO8Zp1L/EShziEQJBGGmajuf7OWpOwbJo+tmca7V4NV7hfgTHTSFFRUZ3KWBJHbIZ//4r9rLtjXZvb27lzJwcOHODrr7/mlVdeYfv27S7oZTfBSQvqWAZUVVWSdvBjqXfvQnqUDx9Uw22LjXcb5MaapWuaVfKvwQIi9pLEOGbGjvsZcneiTtD2her8aoKXBDNAMXBLkIVcvwx+/hl8eJsQQpjGNOKII510yiknjTSGUqueuIxljse+h/qx09xRJ50FKAr6qe58vPRjgnyCGDlyZJPn3NPR6rUIrSA2MZbJSZPb3F5ISAgAgYGBzJ07lz179pDQmmIg3REnvXsfD1XvPjqgiNTUVBlk4CJ6nMG3jfJX7F/R9vqu59cQunYBGWZFjY1PBXoDh6HfzTC8GJKvA/yAAtSCKNkQXGmkzBf8/MBshhRSCEAt0fYSL+GDD6mkEk00aaQxhvqljZuchI6cTzCQuP4h15xvD8HZ0PsE+bS5zdLSUqqrqzEYDJSWlrJp0yb+/Oc/u6C33YTGtKCcXZaSVtPjDD64sL7r/qXc6KXwxg9gvojqO0kH4QPX6iHQBDuqrKGU+ailED2hWgfFxdC/P+h00Ite6KxfRZ1RvAEHl4/9cgdhtxSgEnSeOqIN0ezcuZOJEye69nx7AEGxQYReHeoyQ28jKyuLuXPnAmA2m7nrrruYNWuWy9rv8tjVc6hBakG5HFkApbWcXwO77ybTDBEHwbQB8AHcQGuG58ZAHzf4rxm22OQXKoALMEcHVwyqbeqJvzTyHdhW1VPNKtP/Gga+OJAKc4V6Q0kFfaCet2e/TW+P3sycObMdTrzr0VUKi3SVfrYbsmKbS2isAEqbR/hCiAHAO0A/VPO0UlGUF5y2mQJ8Dpy3LvpEUZS/tvXYHcphdSQerIOZFbAhCix9QZsN+hHwW9969tkDVMPuUBgFuFsXV+qLcTfVs4MtDNwukWrHCTifk0LQnsUo0UuZoZnBN9pvMBWbEPsFtyXdRnl+OaGDmym6JpF0FqQWVLvjCpeOGXhMUZQDQggDsF8IsVlRlGNO2+1QFOV6Fxyvc2A3ybRiPAwMBosClkFqEmwNF6yvEKAQcIP8Unj1IAwqUsOk9tzWizf/s7/+oifgEMEQ0gcyC0GpriQw713uHLacTT9vggjweMCDZ+58RvrpJRJJvbQ5LFNRlExFUQ5Y3xuB46jmrdsRujwU8aRQX6cVxGkQp+GK1NqShsP1mtrkrhTgHKr2zVlUDYYAIByKDLA/G/aaIKVkOLt2nePAgQP1H9ju5pKeB4oCAsjOziSkTwiJsYlqjoCclJVIJI3g0klbIUQEEAf8WM/q8UKIw6gyYo8rinK0gTaWAEsAwsLCXNm91nF+DexbyrpdeYScguw4qDoB5KJevfGQAbxmlbM5aqrGqq6jumTyUR1dGlRNnSLUK3AC0AIpMGXcFHx9fRuuPWsXwZBg7+L1CodJkxhkHCQnZSUSSZO4bNJWCOEDJANPK4ryidM6X6BaUZQSIcRs4AVFUQY31WaHT9qeXwM/JIJSxYUc+PAg/KkEzBeAUNQR/FAg2rr9BeAIMATVmOegCqoNQDXyfVCzbm0hmkdAU6qhekq1+tlAjb6+g76PkxgaoEYwyAInzaKrTIZ2lX5KOjftOmlrPYAbsA5Y42zsARRFKbZ7v0EI8aoQwl9RlFxXHN/VOMS3H0c13FXQyxdmhsA3hWApBY1eQ2i/3qSSp24bhKqJXwmaQA3Vohqi1MF9dT+7A+QDW0AzV0N8RTwHqw5ijjbX6tyHuBGeGk5FRQUeHh6NFy+XSCSSZtJmH75QlbtWAccVRVnewDZB1u0QQlxpPW5eW4/tamw+eodkpiIgHLQeMH8aLPADTSAwAHRRgi9iS9GCemPYiHpzOOKO9r1lYOqDQcACHyAFNKeAC6CNEvAALJi+gM+f/xxdpPW+a9W511g0PHbrY46di5yvGnmvMNXoH14mxaW6GIWFhdx6663ExMQwdOhQdu/e3dFdkvQwXDHCnwAsAI4IIQ5Zl/0RCANQFOV14Fbgl0IIM2oQyx1KZ0kAsIv9vVGnZxVgugAcArxQ3S9pgI8qjDa2BKqsLhwTFmIvWPWHi1AFykrB/8eZ5Jb0Qr9rAj9N+xJ3PXzXG8Ivwi4t3N3LjR0WP/5Z9S1BX4aQ2MubVQU6THvMaBUt1/S5hvyMfM6cOcOIESNq+2l16yQfh5RcNTTznNe3zL7nL51jvqObcP78VtaunY3ZXIFO58Fdd20gMnJqm9tdunQps2bN4uOPP8ZkMlFWVtb0ThKJC2mzwVcUZSdq0Ehj27wMvNzWY7kcJ9/4mNOVvHEeVa9eB2QDA0AbDHdFqbLHN3pTW/QkBSgArY8ag08qkKonP80EBGK5GM6Zc32YNiKf97wgcSv4J8CMdBPXm/O4WGGhxBN8vy9BDAUSQK/T89bSt+pG2ziJSxWWqqGZAcYvKS//fd3zOryMddtSOJnrx8gpi9CFTMPb21tqtzTB+fNbef/96zGbKwAwmyt4//3rufPOr9pk9IuKiti+fTv//e9/AdDr9ej1+sZ3kkhcTI9Sy6yDnREFqCqFwbkgfgROo8bNm0Fkwb+tmbE1ksMXUN03GaAVcFsskACRvsvQiAVAMNVKAcs33Aqo0TXf/gGe9IE+WvD1sKARkJYHU6LgHmtYZ4OhlU7iUodS1LusnzbXUdbZTmY2PhImRhaS+v1LDDecws3NzVVXrtuydu1sqqocR95VVWWsXTu7Te2eP3+egIAAEhMTiYuL47777pMS1ZLLTs82+HZGFMDgAZUXQBMKDAMxBsS1sOSRhwi6RwGv8BrJYbcg4CJo/WGGF7wQCGHlQWQcHo+5ugToh6KM5dujt3CpUJ2xPZMF3u6QVQQms5qolVsCKblwpxlVT7+h0EqvWpfNspvhiVtgxii49spwpk+fXrud3U3sTBZsPwFD+lWx4vk/ExAQ4LJL112xjeybu7z57Zo5cOAAv/zlLzl48CDe3t7885//bFObki5MBxV76ZHiaTW49YGq2rnjID9InAQ/9oX1eXBtHzin19UaYesNIqkvvPEV4Av6q+CNCNXdM2dfEqvEJMBmgEdiUioIXp0E1/9a1VIIghAtpA9Ut4iPRJVLSIPXesFnz/+xfp98c8Wl7G5i00aoL4DpI40waBCSxtHpPOo17jqdR5vaDQ0NJTQ0lHHjxgFw6623SoPfU3GajysqS6Fo8yJSPT9n2TMfteuhe+4I//wasKgylOv2wPbj6qh7YCDcZYDIWHg3wZOzd/yXsSvHOmTX9j8P5gRgirWkobs3IPjiwI2YzE6GweIBJ29SJ4FTQbsXRpyFpz+D4xmw56w6EvdwU/OzVJ98PQUfrOUW8QoHhPp/fXH4Xg1M3ja0XOLAXXdtwM3Ny2GZm5sXd921oU3tBgUFMWDAAE6ePAnAt99+y7Bhw9rUpqSL4jQfdzQdEoaYiPdKbvdD91yDf3gZVKsZsfGRcDRD9c338YG5w+FsJAQNXgiR8x1r4V4AtoNbFXgchqnZerhyBQx6kPSXwwh5SsBCATcLSBAwTED8ADUINQO0/eCpEaDVQLkJSisg11grl1DHJ29P5Hy4+QLcVa3+X18cvrXalQNSZrbZREZO5c47v6oZ0et0Hm2esLXx0ksvMX/+fEaNGsWhQ4f44x//2OY2JbUYjUbWr1/P8uX1Rod3Hpzm40xmCA+Ao2ezSUtLa9dD91yXjt1Ft/nWs4vB1xMGpUPGWWDdaxD8mlqxqhwYjBorX6VO1P4/Pby7RUtunyOUmXx4NELhRm94LQg1wsfDF84/CIGvgqEEsiBxOhTlQUhvdcK2qBz69YLbx1s74xUO9j75liKTtNpMZORUli1zfVm92NhYOq3cdxfGaDSyfft2Pv30U0wmE1qtlrVr1+Lv71+33nNnoIFiL4/dFg4DBrTroXuuwbe76DY/t41NWfBmEFSlAcWoMfa9QGQKFBTQg/D15EtLDAV5BWR8tIVZM2bR6y04cQ+8/hUoemDfECh/H753h7AScIcpl2BaXAN9chqJO2T8pqLKM/SDkFF2sgv10ZDMrNQbl3QjbIb+0KFDKIpCQEAAJ06coG/fvvTp08cxBLkz/fY7sNhLjzX4yx+8j+hR+0i46VsMvUsc1tVMylajFjUxgbZciyZKg/tAd6YwmdHEcrboLBcCL5CTk0NqaiqDgKL791JtUmUsXuM13uVdCk2FjD97Ez9Meoubhzt1RGhBqa73R+hQ0cofUEBXreOm6JtafsINTBRZIrYzaPyCmupYEklXYfXq1RQWFmLL4dyzZw8XL15k+vTptbIkUCffZt22FE58kMi8xRkkn/Vl9uzZlzdxsQOfwnuswTdmWTi4LY5DySOJnXSQ3PDvwK2cPj5wwxi4/3prgtVZ0Bk0XB+oJ+t8OTFFdxPWawACDTFDYqgoq6CsrIySkhJCjZBpMmIrt2zAQCWVAFQqlcwN1uGhN9d2ogkBNPuC66QDGtB4aFqniuk0UfTKZrjrahMnCz6jtHRey9uTSDqYRYsWkZycXDPCtx/R33zzzbUbOuXbxEfC6UtVlP/0HAERL9cfJNHedFCxl547aQtYqsBs0nFwx1V88c4sNm+O4VSqOjlbk2AVBW4x1bw2ppzHh8OWrPfJO/k5R48dIe1iGn5+fuTn51NdXY0eyCWXZ3mWCioIIohEEnme53mP9/j1ox80HWVjh63gul6rh8HwyyItuR9pCFrzuTrL2xxs8b5W9xU4ThRlZGbj7e3d6msokXQUPj4+zJkzh6VLlxIXF4dOp0Or1dbd0Cnf5kyWdQ4t4xJ+fn4NB0l0Q7rfCL8VvjqLyYIGLRnngvDNHw43f0KwbxiJgwex4tS3auilDqYNhFk/VDBq4GGyq47zfkoUEwclsPC+hZgrzPxT+zl/2zOKANQEp2nWfwBv8zYbn48hNPQXBAUF8eijjzbrdJISkvh091u88RFMvWDBu8rCjocfpvjNNzH85S/sOHSIZcuW1b+zkxunsFSdlI7pD5HWHKzE68JBunMkXRib4Z88eTLJyck1oa812M3Xgd2cnVc4XHvt5etoJ6B7GXw7A7duDwQYUij7cTHFIT8watqviImJqXc3rV5LrDaW2MRYJidNhqCPAUgyZrLxxf4k9VG3e2kT+Puo0TyHUkz0CjrOu6Twa/0U9mwvQquHVFLZxCY+4RP+xb/YwAYiiSSQQHJzn8TNLcBhRO0wMWuHTQ8/2BDMjk97M+DcJdytOm0hFRWcP3iQPn/4A/H//nfD16MeN87YgWqugbc7MlxT0rlo48SqzfDPmTPHcUUHTpJ2NrqXS8fOwNli66mupPTk+/VurtVr0XnqiLsvjqXnljLnlTn4BPnUrA82BHN2eDhB1tvispvB2wN8POC3M2GmD/SqKOORkA2svXcXGk/Yxz6u53qu4zoEgoEMxAcf/PDD29ud/Px8hz44xPinAKdAl6YjOj2a7777Tu1H/BR01bX7pAOvWSwExMRw9OhR0tLSHMsv2l6HUwg9p+7z0ibwcge9DtbsAm+/EFlA5TJy8uRJYmNja16+vr48//zzHd2tzoOdBhQorNuWwotPJvL2Mw+wdu1aNm3a1Pq2m5u02BY6SCqhpXSvEX49sfVZRVBUmkd2drbDCN8QYiD6pmgmJ012MPKA40iDWsGxdXtgUjSUmdTsuGsHwZ+ja3eb7g9HNUfZWL2RYQwjhBDWsIYYYhiuG05sbGydLjtMzBqAAtD4aFg0cVGNb9E7cQl8th6MamZwArDbYICHHuKxKVMAp4ie00ApaHVw0wS1aft438nx4WrilqQuQUBWPcv7AZda32x0dDSHDh0CwGKxEBISwty5c1vfYHejnonV/oVV9Pddz/E+c9uu8tqek6R2noVdJ+HboylctWcxM+6n0w2oupfBbyi23iscnH4wj6Y7+tBtMb0njx3k0bB/1Hx5+8+b6O0NCyaprpwPf4Bwfzh7CQIMjod/MAjmzVuD+QzsHp7M49e8y9TiBF7bdIQfg3YQysDajc+vgcj5NROzqw6uwlRsQuwX3JZ0G308+9C7f29120mT1P/d3Wv3F6J2OZBkKGW1NXMYLyAbhEZDUoA7atYYhJ6DDAtAChwW6hNFJfj7+fP32L8zY8YMwsPDm325uyX1GfvGlreCb7/9lqioKHmt7alnYvVSIYwffJGD9iGWnRG7m1VMf/j2qCpdzuFl0uC3K63w1RmNRl555RWOHz+Om5sbubm5XFlSxsRo9curViCsr7qtwQNigsHPG45lQLmmL/aFu26IgTH7YG8QzPCBgR4lDPTYgGmYB7uzY9CJAZw6dY6yyirYY/W9R86vHeVHgMcDHjxz5zOOEsk6HWzYAAcP1i6LiwNbRMKehwhOf4dEA6zcDJbTIHwhtNqbXcWJ3BL8uVrgxc+bVQUVmKqtoaEG0BZpSegXQdrm31FetAQGhcuErHbmgw8+4M477+zobnQuGpxYDXMMseyM2N2sfjwL0cHWAiFlnS/6p3sZ/BYkNNhn6ZWXl1NcXEzfvn0xGAyUqqHz/HgWSithktUTFOSn/n/3ROgX0JeAuPtA+5LDDeazO2BiGrwxQHUBnbgI866oQLEcwlxwAu/AMXx7TKvuYx0BBBuC0QrVeJebywl+NlgtmZgFgVcGkvWvLDWSpqFomrMrATWU9M1+YMkAXQzcUmbEK2IWXPeCut6YyeoXB4LN4BdD9d5qHr/6COcCKll/EE5lqglZCx5HGv12wGQy8cUXX/CPf/yjo7vSuejKE6t2N6vZsU7LOxnda9IWmicwhpqlt3//fsxmM7t37+bEiRN4eXlhNBrVCBbUL+82Vc2WzIIgHlh1Bh+P3qzdBb7D72XGPf9UJ3+0tVE3wTqr8JpO9UPaRNL8fWDJmQoeKf2er/x2IE6DOJyCeFIQujyUW4be4tjBItBqtEwJndL0OSuWmmNfWQR4wEQF9p/EoYyeQ1w/oI/S88v/58344ErmT4C5V8DJTFW5j8MNhHpK2sTXX3/NmDFj6NevX9MbdxeaM6F5OSZW24suJFgoOktp2foYO3as0l5iUyUlJQ5ZehaLpWbdE4OfJPm4QlEZFJVBjhGO5/6GbP03lBovUVJkJDRoNA8++gzTorIcRiZqvVk4fQm+OwpD+4ObFkaGwdfusCnYWh4xFbgAumAdS+5cwp8S/sTAFwdSYdNiP406SRgAttRdW6hmHd7XEXrWYvXPO+K8T6Yxs+Y4njpPzg0or4lC2n4cLhXBL64CEOpNsxtw/Phxhg4d2ryNGyvW6YI/lTvuuIOZM2eSmJhYZ12L+tlVcAqVPpoOVw1xZ8b9q7qGMW8u7aDVUzOvePJks/N2AIQQ+xVFGVvfuu43wm8m9WXpmVFdHeK0whQz3HQY7vGA54p80Eetwk1/moxLRs6lw3c/HGbz5k9g/1KwlPHNYfhwt9p2L08wW2B0GEwZpipierjByqut2bugauOEgSgSJE1OqjP6ZjAwCTADh8Atz61hDZ2oJdzoDQ4VUk+DdpsgtjjWYVPbcTRCo5ZT9K2dOEwYajP2dMrH0ctCQwNvFwzIS0tL2bx5M/Pm9SApC6dQaT8vuwnN7kQzPQvNwSbz/MADD7BixQqOHDnCxx9/zIEDB9rcTZcYfCHELCHESSHEGSHE/9Wz3l0I8aF1/Y9CiAhXHNcV2Bt+k/sRiilWV+wBLoH2JwjOEVRUlOHuDhoNBAdDSAicOfIamNRJW3+D6q9fs0utN+vupo5mFAUCemkhcArBvuEkGqyGOR10Wh2zxs2qmaBNSkhCYz+MvACkqf9X/2BuWEPnyldJir+n9mYC4AVCr+XmQTfX2TwpIYkIvwi1vS70OHpZuIQ6knd+tSEk04a3tzd5eXn06tWr7Y11FZxCpXt5dd4JzfamKb1+2/oXX3yRgwcPEhgYSN++fdFqtfj6+qLRtN1ct7kFIYQWeAW4DhgG3CmEcC7lsxgoUBRlEPAc8K+2HtfV+Pj48HD/z3lVWL+MBGAaaAP64OnuRVgYXLoEV14JgYGQlgaBAfDpXvjxDGw6AtH9Yeowtd6smxb6GOCqwfC/oF6szjHz+OFbSS2ew695FIaAeYCZlQ+vrOlDsCGYRD93NMBwvbVubilovCCur67+4ua2fRPeJjH+lzVPCDqdjriAOMIC647Ugw3BnP3tWbW9ruw7lXR+7J4Up42AexPUWsw96QnSecSelpbGs88+S0WFYylN+3lFi8VCfn4+GzduxMvLC5PJ5OB2bi2uiNK5EjijKMo5ACHEB8BNwDG7bW4C/mJ9/zHwshBCKJ1sAkEdgaeoKpmALh/8dl+NYaQaMmML5Y+IALMZDvwEaQoYK2HoAB2jr5rJydJoYDnLbgaj2Yft+VOYWO7J8f3HORpylPMp56kaUKW6CIwQ/Ktg7MPzgzRqMfM1/WDsFiAUdP1hTlkVaWlpDHAqkGDv50u6vzaJyy3EjS/+/UWjN4kaOki5T9IDaCj6pv9sq6hfJ9Cnbyec9foDAwPJysrCbDYTHx9fZ3tn9c+oqCiioqIAuP76613SJ1cY/BBUx4ONdGBcQ9soimIWQhQBfYFc58aEEEuAJcDl1agGGP00SaX3s9pYDgq4DQLNV69x4EA2o0dPRq8v4eef1bB4g0FDSHU1ecUa8qt68dlhN/pdOZLknbs57ubJiIl388X2M0xOGEP/oCKKCorQaDSUlZRx4cIFMMNj2x7Dp9qHkYwknXRGM5opTAGPYljVi/uvhxXFcF8v+Es/LewIr/njMPrfyHPPPUdycjKhoaEMHDiwxj+/Yv8K1T/fHGMvkbQn9YVK958N59+umcjNLk5h+KHFpPt9j/+wmzpnlapW4KzXn5+fT2BgIEVFRZw5cwZ/f39GjKjNEHUWgasvoKStdLo4fEVRVgIrQY3SuawHj5xPMKA9uwBQKFdAu3Qok5nMn/+ejbvJk7d5m0tc4ju+owAdU7QJfD72E4RXORa0eHt7c0lzLf2qAqmqOsHWbdvRarXk5eVRUlKCoiiUl5cTq4eI6ghyyWUnOwkjjP3s5wQnmF0xm2Vb7+S6Xu+zsTeqeJtiIfk4HEy7RK9Db5N8YSNpaRlUV1c7/CCSEpLYeHZj6zTzJZL2wPkJ8rMIh4nc1FxwE5X0yf+YhIRnO6aP7UB9I3Yb9913X4P7Nan+2QZcYfAzAHs/Q6h1WX3bpAshdEAv7FNUOwN2YVW3+HnxTkEpAItYROGFQtaZPsWAAQ88yCefGGIYy1g8LZ707uuPXx+F/Px8Tp06RZ8+fdi2bRvnzp2jT58+mEwmwsPDiY+P5/z58+j1eu4dkca+by5wH/fxCZ9QSCHnOc8BDhBPPDu37CZqDJyN19bE2ceFw6oTk/HLG4SHh4WgoCAuXbqEwVCr8WDzz0sknRanidzfvw8f/gay0rMvj4TCZSp32NYRe4Pqn23AFQZ/LzBYCBGJatjvAO5y2uYL4F5gN3Ar8F2n8t87lUCbmVrK+6lQFQhvBbzF+KDxnOY0/vjzK36FgsIJThBMMFvZCkC/fv04fvw448aNo7i4mMDAQM6dO4eHhwdFRUWcO3eOoUOHcnXC1ejQccfgb7iDZ3iapzFjJoooLnIRX3xJJ52qqip2n3Pn7eRK3LRqFNDeczDCfRsmcwHHi8IZOnw0Q4YMab9r0llqgEpUust34qR5td8aEDZo4GXQFqpH6OzKHxczawntdi3bc8TeUtps8K0++V8DGwEt8JaiKEeFEH8F9imK8gWwCnhXCHEGyEe9KXQenJT6hvhB/EnYD5RQwnd7v2MZyzCpKVN44skxjnEd1+GOO4qiEBQURFVVFQBFRUUcPHgQd3d3PD096d+/P1G9CwgN1HOw+gBjNLWqncuojUfOJZcS1Pq6wcHBeFRnMGUoHL8ICTHW6AZMwF5K3Iwkey1sFz+f/R/FjhOQX5KC74HF5AftIfKqexkzZozrjtVDeO6553jzzTcRQjBy5EhWr17dstGs03dyPieFoD2LKRmwF7fQa7nhhhvar/OupiNlFJyEzr47BlwmobP2GLG3FJf48BVF2QBscFr2Z7v3FcBtrjhWu+AUE6wRsCgC9ucDAdB7si+Tv51cs/5nfmY4w7nEJaKJ5nTf0+zZs4fq6mr8/Pzw9+9LWFgYgwYNqtnnieuy4OLH1pHN1/V241Fqs+le9n2ZMX5qGcKDKeBhn1Wl9cJn7J+YE9lOowa7P4qQPvDDGYgNr2Rgxf/w9vmV647TWbFY4Lnn4J//hD/8AR5+uFaorhVkZGTw4osvcuzYMTw9PfnFL37BBx98wMKFC5vfiNN3klmoJjD553/AkerBre5bh9CBRbydhc7C+qoquD0lL6DTTdp2CE5KfWMi1dfXuzxJPTGM3rm9mMlMpjGN3/E7YojhBCeYwQw2sAGDj5eDXvetkwL5dMdFLDVJVAKufLX2eLZHc49iqPCt051KfSUJCQk8MVgtgHLzWNT4+Hr+ONpl1GD340/Pg1Fh1sIp32byyO3dvP7t6dPwi1+o/5eWwhNPwJo18OGHMLj1htVsNlNeXo6bmxtlZWX079+/ZQ04fSeKoiYwaUxZ7efWa086KhS4CwmdtQfS4EOdR0yj2YfteZOJcAunOO8ker07XsKLgYoaMB9PPDnk8BmfsYWt7L34A2PN8ZgrLWi1Wv544ACDBw8mJSWFoKAgAgICHI9n+7GX1y7KNGYy8eUwNvfz4HhxAoYSu3KMXpe5YIndH0WCnbTL5PhwNcW4OzNhAuTlQbVVR6i0FA4fVpdnZ7eqyZCQEB5//HHCwsLw9PRkxowZLQ89bOA7wSscpk9vVb96JF1ZldMF9FgtHQci50PkvdiUs1anLeKTI/4cOXoKDRqys7M5OeIkXy38CgFEcoZfYuYu0nhLfMOp3BMcO/U9mZmZBAUFodPpqKysxMPDg+uvv54///nPjR4erNE1d/yXgd7VzAncwKMDrRm/HfFj7MlyC8OH1xp7G9XVYBcv3VIKCgr4/PPPOX/+PGlpaRQWFvLyyy+3rJGe/J24kh6eWS5H+KC6WM6uxCaHuGjAW/z1RBS7MyoIDx2Ar68vPj4+REREcPFtwcALUKGgatanwhiPq6Ac8ox57NmzB71eT1FRERUVFQih3kSaKlYOdKxv057O0o+OYPFi2LcPSkpql/n4wKJFrW5yy5YtREREYDabSU1NZcaMGezevZsFCxY0X1enJ38nrqYHZ5ZLg2+LflAs7DgBxeVg8CihIP0wlXkweKSeb4+YmDFdfQQP1kGiAVV+IQe07uDd7yATe40jUxlNaGioQ8SM7dHdoeZsHnAR9LH6ugqYneXH2Fn6cbm54Qb4zW8cl+l06vJWYLFY6N27N7t27cJoNKLRaNi5cyfDhg1zyJ9oFj31O5G4DGnwnaIfzp+EPj5QWAY3joG4PkfwG6qnxJRLZoaRj4p8uCOwhNUCSAC9gHcHVhM0YQklATc1mGDhUKy8GPAArdDKjNjORq9eUFDgsuZyc3MZNmwYc+bM4brrrkOr1TJixAhuv/12l6gfSi4vrdWo7yxIg28XnZOeB69tgXd/CfdOgsOpaonD8VEm3v/hA4aOu5XSgDsJ1Kwm0d3M6/thfDUUelURtPtufDzDmHPsWq577gt+vuMOtkRG1rQdbAgmceAEVp36FlMZaMshMepqqXfTzfH398doNPK73/2Oxx9/vKO7I2kJdoluRrdotpuXsObLvZSUlBAVFcVHH32En59fl9L+6dkG//wa1Ilahbe3Q0QAPDEPBgWprxEDVJ2PNd+Dp5tC5vFv8MzXkd3fTNJg+MIX4rOgwgRvfuPL0bXuLNWs5qMqyFqxgqWTJrExPBx3f3+mhGeQVP29+mTgA5pquP3Ct/A/fxj7QsOP6r6AsZ7lBrBJ90s6L1qtFj8/PwwGA0ajkfLycjpTkrmkAayuXmOlhu15s1nzowc5OV/g6W3g5MmT9O7dGz8/vy73XfZsg394GbaJ2kBfq+m3+/7sdT5OX4Le3kauGlxbZeSLENiYB6l5MOizXnxvOcsGi1qV8BuzmfLtWwk8u5XcxEAYbiFYlJNogNcNEHcJfCywblceGesT6T1qJwsefa1uH+2MfTLJZJCBAQP5xnxCtoQwbdq02g2sI5IdB1I4X9SXoPj78IuZR35+PrNmzXLppZO0DGfD76yFLulkWF29q9N+S6HZj8CgItw9DRw7doyAgAAKCwspKCigd+/eHd3TFtFzDH59OiR2ySx+3rDpJ2uSkxUHnY8grKFc1LiBxkRCsF8QVz2xm18Yl3AFaRxALZZlAJ62gKUCMj/K5sw4KK+Ch66Cz0phUSSk5alqgf0Lq+jv8yVQj8G3I444trENf/wRCEwmk+P5WeOL1UzMPJQTz1Oq00KfSW29el0eRVFqIqY6Epvhd6arjRS7PVbbsGjAWyTnJ/DKbhMZFzPpF9Sf4OBgFEXh9ttv7+BOtpyeYfDtjGHycSgsTaHXgcWk5nsT2quEa4bD+MHqq0E0+tqYZ7vEjac+TSI1z8R6YrmLZG7FxD3AN4CXFvqO1fFtRThb8yO5MWQLvtVw8ZraZrf8DJcKYfzgiw6HWx66nOgbo5lDbQbtS7zEFKZgwkQGGeh0dl+f3eRzTSZmdSVpP66A+Oia9hKSEjAEtzA6pIvj4eFBXl4effv27RRG3xlFUcjLy7s8SpGS5mFNdPPRlTAncANh07x4bnsYSm9/ogaGYemiplN05pHF2LFjlX379rW9oc8iakblxWXwymYYOxDMGgNZ+ZUsnGQ3UhZuaqyl2S4OW98X4u387HsegjOvk1nQj/Clb1NlOYDAzAP8lYcRhCHYoankSyHYFj2E3LxCwiMimBH8IzNHwYToevrolE1bKSpxxx2Adawjgwx605tUUmsF1+y/urUapwU1JwR3VfOkeBKtXovQCGITYykYU0BKVgrz5s3jwIEDjBkzhqFDh9azf9enqqqK9PT0Tu1G8fDwIDQ0FDc3t47uigTUQeLuu2s+bj+uPqGj9cQcMJWT1dd22igdIcR+RVHG1reua96mWoqd6+alTeDjAR5u8M5z04iZMADjFZsweJwEtz5gMdYY+3V74MQlN+Yt/n8c2euG3+lN6oz8xQ2AwlOfJmG2jAU+R0HhYyZT4RbLVUMKGRCawXD/XuRa1PqyOp2OftqfmTDSo6bweQ31ZEzajD1ANtmkk85YxrKHPaSSShhO2h9OekAOy61YTGqY6MFVBylcVUhuXC65Y3NJS0vrtsYewM3NjUi7iKkuTXeRSO7sRM6HfUuhSv1brZWzKAevo8y5eX2Hda0t9IxAYDujt+xmWDoLJsVAaMloyrcG8OKv7mb9zi95b6s7r28ykZoLG3+CKjNoqaL8p+ccZ+TLUsksCGL19kTc9M/Tr98BEhP9yGUhBbNLuXjLAPaOH8f/MrO5dOkSAEIIhiT8Gm7NhfHvtSi124CBvexlBzs4wQne5322e2533KgFqfcWk4VsUzbGPUbeufcdoqOjSUtLq7OdpJNhc02WpQAK67al8NrfEtn+YRJvvPEGKSn13PAlrWfsC91OzqJnjPAbEkzCadRbPZfssM1cGZpOoG8Zh1IgpDekZVyiItRuRt6tD09/9UdGjPorw4bncfKkhpSUH3HT/p7i7JNEaPdykdFMTbjawdc3/Z4n1DctzJgMIog7uIM00riWawn95f/hFhYE55+pbacFqfdavZZobTSxibGc+OQE+s16EpIS6mwn6WQ41W1QywNW4Xb+TdLK7qe8vLzhfeWTQcvphnIWPcPgN/TFcaZmE4vJQjbFmM/F8eZLw7jpgc+4erD6JACQfGIJhWUKG7aaWX8mitJ+P+G/NR1NSRADBvVHeAmqLO7s+xlefes/hIaGtqqs2bp16/D2ViWI97OfZSxjGtPQo8cPP3rTmxX74BZxiaKVi0nz3cqMu5IIDw9v8kai1WsRWtWHPzlpMj5BPux7dR8HVx3k0OpDlCaUwki4ZtY1nDlzhpEjRzJhwoRWXXJJO+Ck2V4bNnyJ6AHRpKamEhMTU3c/p4pu67alEHBoMaXhhynzHUdkZORlK2pz5swZ3nrrLTw8PPDx8bksfvA2Zcd2MzmLnmHwoYEv7smad1q9lmjNIGIn7Wfyzd/h4+e4ZVxIMa9shh+LJ3L+YhF+fqcoryyn/FQ54afDOR1wmgcmGxg30pc1//cUcycFMWfeM0yevJTk5GT2z9/P+qz1NVEyycnJZGSokTYHDhygoKCAZ357NUU/f8zbe808xFLiia85fgK1I/Ahe8/z9d6v6UMkO3mfoj/+j2jPaKreq8LNza3e6keGEAPRN0XXGHp7bE85lVsrOf3dafTH9TAaRo4c2bprLWkf7OZplv/6UaLHnGTb48kYQvoy6OZGjFI9TwZfH64ksvptBs69s2aA0d4YjUb+97//kZGhiggOHDiw3Y/36quvsnfvXnx8fCgtLWXTpk1dKjPW1fQcg98AdUa95Z+r+udlJQ7b2SZ7FwzbxzPpvQgOGsQxzmBWzFQr1QzIHsDPOdXMFL0RPt/y9uZLnExZxJ2PvMWcOfPZV1Q7ko5NjGXw/YP505/+RH5+PqGhoZSVlZH0uiB/VW8Kep1nhVjBOGUc61hHDDE8xmM1fTnDGbzxJptsJjKRHezAs9yTkf4jOXLkSL3n+Wh60yObnKoczJg59/U5KvdUcu1117bt4kpci51r0ljgy8HkOA5tj0U/pZiCnX/kmlnXOCbi2ajnycDbHbJzstmyZg2PPPJIu3bbNsI+dOgQR44cISsrq95chPY4Xl5eHkIILBYLHh4ePT7foUcb/PpHvdYnAacwx2U3q/8//VkFs4ZU8Mh1m5j70ThSSeUIR9ApOgqVQr7cFk2B91WETdxBb0+TQ61M20h6/xv7Wb5iOf0i+uET5kNpeSkWiwWzoiOqPIqQyhDSRBolcSX4B3+E4q+BGVYdlvkK06j9o36ap1nMYkyY0Gg0daofnTlzhi1btlBQUIC7u3ujj7RD9ENqfPv1PQlIOhh71yRgMat/vqXbfPhx64/oj+sZN3xc3TwLpwiuaTZpf69wuPmZ9u41q1evprCwEEVRGDp0aLtHhNkfr8BOCM9erryn0qMNvvOoNzk5mTNnzpCSkkJW2i1M9PiYBU5JqjbDD6WEEIIWLUUUESbCQGNi0vg0Bk/YR2Y5pORSb61MxayQQAJnz53FLcuN4F8Ec/HiRSrKioEA9lTvQY8ewyED2w72Y8bk6zBGjcFw4aE6bdkXQWei4zrbI/TWrVvp379/g6GJ9fn22wVFgZUr4U9/gr/9DZYsgR7+B9hialyTte7IlKoUvPHm3NfnWD1xNb89+1vHfTq4ytOiRYuans9y4aSy/fGioqLqlSvvqbTJ4Ash/gPcAJiAs0CioiiF9Wx3AVUVxgKYG0oK6EiMRiPZ2dmsXbsWLy8vQkJCSBjuATScrBNFFFqNBXchmHJFFoGxe+kfWFGTWBV6Dh48rcCTgr/wl5r9qrXVaISGqDFRMAkwQHh4OI9FPsNvV9+GL7744ENJdQlDGUHf7X1ZfVcRv92ystnnYv8I7e7u3qAUr/1TzsqxK0GhfbJxCwrg7rshOZkdpaUYly5l9hdfwHvvQRfTI+lsDNUPdbhh16GDo01sdZcnT55cv+F3yoRPyU0haM9iLIMP4x11vUO9aJccrwfT1hH+ZuAPiqKYhRD/Av4A/L6BbacqipLbxuO5HHvjuHXrVsLCwrBYLBQWFhI+583aPxK3PqBUOmTgGnoXc2t8IZPnfo+PXwm2Eok2bjRoWVUsMFWbySOPC+ICBmEgaMpAtqU9xP89vo9Tx39AUcCCDh9dCQYMGK2Kad4aL/q5BRC/OF79Q27myNv5Ebox7J9yjmQcYeuKrWxZuQWRINDH6ukf0Z/evXvj5eXVtmiOG26AvXvBZCIEOFBZCVu2qMt37mxdmz2cFj2ZNRZtcplCNp0N8cmTJ9UVdpPKceFQWApKdSXDzWvJcJvr+uP1YNpk8BVF2WT38Qfg1rZ15/JjbxwnTXLy39T3R3J+TU0G3qMvL69drvVS6+Je3FDzh5M07XFWf/Y7qDaT6ZnJuYBzpF2ZxtxeFzn43ce8+GIxv4p/BkPENZwsiSH5OPzMz1QLE1WiiqhRfXlmxS/wufgr1v0zhRM5fszzTCat/BJZZLGABbXHtxuQN+sR2g7bTS+IIIqrizFj5sL2C7jtcMP/Bn/G/GEMJp2pbdEc0dGwezcA6aiqz5jN0I0zfNuTxqKuWoTd6HrdHggwpFD242JmLcHxt+/Cm4LNEM+ZY9WJcsqEN1tUXasV6zNInBrQ+nNr6Hg9GJdp6QghvgQ+VBTlvXrWnQcKUGdBVyiK0qBvQgixBFgCEBYWFt/e2YMlJSUNGscnnniizvYOtWkVWLIfxm2CD4a58eZnp7mUleUgR/zQ+ofU0oY/mdBWapkafSs7X/qAioqv0emO8M6D/+LO8fmAqvNz528mMn5oJSMnHMVj7K+Z6fEyWMq4kAMf7IYZI0Hoe9Fn/JOET1za4nOzPyf7pxtFUdiatBU9egIIoJhiSiihl+jFpIhJpM9L55FHHiEkJKR1F3rrVrjpJjDa6T0bDPDFFzBlSuvalLQdO52pCznw9WGIDIBZ4+20nZzi+N/eDuVmN3qPfoDbf/OSS/vggJO+lKR5tElLRwixBaivLNMyRVE+t26zDDADaxpoZqKiKBlCiEBgsxDihKIo2+vb0HozWAmqeFpT/WsrLfX32WrTepWYWPI2xOXARQtM+NlC+T33UPrYY6DX12xfU9pwOOh1ekLOr6K6GsAPiOHd7bdy53j1/vfSJphx207GRKihc4Mz3oYI9Y/sTJY16zcPvj9dhNee3zHh/CXOVwxkxowZauJVE+fm/Ehr/3QDjrH+Lp/ItT09uddqBCFE7XJJx2A3uq4J1yx2XO4cxx/oCwG+VWzd9x7gAoPfwZPKPYk2j/CFEAuBB4BrFUUpa2JzhBB/AUoURWkyHsxlapktwDYqbigrL9OYycAXB7JpRQUn0yFPgVDAB/DS6ciMjIQ//Yl77rmnZp+H1j/Eiv0rWBD5//hwyT+wF2301Jdz7rlIgvyy6hwr+Thk5IPBE3y8PdmROQKfsEnMMyxnwyGICA3kB/EAd911V/0Zls0815qbXJIFtICAsUvGuj5iZ+dOOHiw9nNcHEyc2PD2kvanOaNrpxDl3adh8xEYFQY3L3eyH611/UjpB5fR2Ai/TQZfCDELWA5MVhQlp4FtvAGNoihG6/vNwF8VRfmmqfY7wuA3h4fWP8QVf16Bx4FqTMC9thUaDSxaBG+84bB9pjGTiasnMumnn3j/XW/s65bo3SzcN+VNXln4YM2y0HOQYQEqQP+Dnv7l/ell6kV0dDTDYoYxofIvnLgIQ4IgZ+R7BAQEtCnczGb49921D2KASfDEM3XdWZJuiJO7BlBH1/aCfs11uTjNB2QXw/Awd/ZV3cKCh58nIKDt/nhJ07SnPPLLgDuqmwbgB0VRHhRC9AfeVBRlNtAP+NS6XgesbY6x78wkJSSxMPZN/vdzNb52xhtvb5hfd1QSbAjm7G/PEhqKg7EHMFVp+fynBbzi9Y+aP6obveGDYh8C9vQnwjOCUkspBcYCTp88jV6n54nrrMkzXuHQWEp9M6lx/WTIaIYeR3NCNpvrcrFz/ajCbuAmKgks3di4sJvkstHWKJ1BDSy/CMy2vj8HjG7LcTobwYZgBt+0CN5bQZWbBjeNtWhFEz7p9PSG1ngBF2oenZP6gr54Eb0S/CjML2Tz5s34+vri7+9f66tvpY/TvvLVoTOH2L59O4899hj//e9/GTlypIxm6Ik0JRDW3Dh+p/kAWz3oPGMeaWlphIU51XCQXHZ6dKZtW1g29Qnue/BL3hzwEG4lpyDjS+hfAF9Gtd7/aE2BD9aB2ectDpQk0Lu4L8XGYqZNm0Z2drZaEckrvNXHMGYYazR9gm4JImyy+kdon4IukdShOaqRdhIODvWgB4aDVF3tFEiD30qCDcF89EKG1W/5dxiiZgmWfZ+C96HF7Cj5nGXPfFTvvsnJyRw8eJBevXpRUFBQOzls9+i8LKCEgaUb6BXRj7irYzl9+jSenp4cOnSI7ya9xTWR19TbdnOwafrs/nA3uR/mUrSlCK94L6rV8CFJG+mx9YNltE2nRxr8NuAQkw9qYOpp8A+o5N2g5Hr3sUk47Nq1i/79+9OnT5/alXaPzj7F+fxWfw1ulSMo6V9CiaEEg8FATk4Oqal19XlawwDzAAYwgPyP8/Hb58ek/ydDJF2B/VOUdqYWv6l+DBo+iPT0dAYNGsTE7hqZ1A0LhnQ3pMFvAzdG38iqfa9hArgAHAQKIHIYfHUhm+FpaQwYMACoK+Hg5uZGQUGBo8GHmkfn1S++iFel6mbJz8unpKSEAQMGkJOT06oQzPpwjrWXuA7bU1T5hnJ2rd9F/Ix4Yu+OpbS0tIN71nwyM9Wo2V27IKi+TJz66GYFQ7ob0uC3gaSEJFbvf11VgQwCIkF/BUwrhDlj+tUYe2hCwqEe7OURhgwZUpMINnjwYK666qo29fuyqWNK2F21Gz16zn19jlN7T/HQJ3UVTzsrTz0FFy5AYuKnTJt2jjlz5rhssCHpGHpGEfN2ItgQTOLga9AD7AFxAm4NgHA/N6oH3u+w7aJFi4iPj0en06HVapts2xYquXTpUuLi4pq9X1MYQgzE3RfH0nNLmfPKnB5n7JeHLmf9Q+sxZhqb3tgFTNVPZaLnRG7/5e2s/Glll3HnZGbC6tVQXQ3ffpvGoEHjOrpLEhfgMi2d9qDTJF41kgWYacxk4AvhVFiq8BRwbmgoQWP/2eBjbVP6Ng3RVAawpHk8KZ5Un3A06hNOwZgCzmacZcKECRQWFjJw4MA213etOUYXfop66CFYtUrNG9HpvmHy5Bwefrg3119/fUd3TdIE7Zl41f1x0uouq1SjcC75/8Coab8iJiaGxLj7WLF/BYnxDxI055U6TTj6Qlsn2eqg+CfT0NuEzb9+cNVBClcVUjaujMKoQnwDfRusG2CPcy7DkSNHuP7662vizF2mZOkiWlrE2za6tyUJms2z+P57tXSBpGsjR/hNYZdWXlwGn+6DIcFwIrcv43+1k5iYmBrphF2LdhHkU3d266GH4PXX13H11en87W+jOXDgAAsWLGhdqrlTKnzycTie6cbshf9hX/aABouYS1SeFE86fD7LWfJEHmH9wpjzxhyCg4OJj49vYO/aNmxPCUG3BKGdqGX81PFER0e3Z9dbjM3Qr1mzhpKSEqKiohg7dixjxoxptE6C/ejehl4P990Hr9Qdz0g6GXKE3xactLr3nYe/3gJFhXlkZ2cTExNTI51QH7bRkqLEs3dvf7KySggMDGx9qrmTcmFcOKTnV1F++N/4j3y/wSLmkrpo9dpW1/C1z2Uwf2QmfWY6S1cu7RRx986y14GBgWRlZWE2m0lLS2uyKM4XX9QjAWKCzz+XBr+rIw1+U9hlD9bWs4WRMeHQjNJrTz2FVQ75DNXVpXzwQR8WL/Zrfaq5U43clzaBjwekpl/Ec3TdIuaSurjSvz7ArEZiVW+orr+erBP27qBN32/ixIkTzJs3jz179hASEsK0adMa3b85OMte5+fnExgYSFFREddccw1paWmNzlM0LAEi6epIg98UbcgedPSFTsNsho0b4bXXWhDX7IzdDQjsbkJe4VJquBm42r/e0lwG+6Ss4FuCMYeZKS8vp7S0FJPzsLqVOFc8i4qKqlk3d27rSwZKuj7S4DdFG7IHa0f3tVgs8NTvTvLKLTNbN+kq09fbhH0N37bQlqcEmztox4c7MAoj5oNmQmaGoNO55s9RFvGWNIQ0+M2hodq2TdwEGvSFbvDhletS2HECistTMBxazDHdt4ycupgJTYlMyfT1DsdVTwkR5ggAxCaB6ZSJGWebX9PA3jV04NQBioqKKCoqQlEUQkNDueaaa2QRb0kdZJROa3AK1dx5Eh67wZMPLi1g0PgFjSfX2EX9nMtW9x0cBNvO+JHw4FdMmDCBs2eN/OlP2xkz5iS/+10ni7mXIaFtwj5KqC1PCfaRQkPmD+Fo4FESH0jk2LFjZGVlsXDhwnbovaQrIKN0XI1dpExcOJRVApZy+pd+RmnpvMb3tZt0Tc+D17bA2w9CH30hJSUl/POf/2Tjxs1otW6sWnUBIap5/PHH2/FkWoBzSOj+FDK+XYRh9AH0A2bg7u7OlDYUJO8pKpOumjS2uYZW/HcFilC4ovAKKiZUSPkDSYNIg98anEI1fTxgQF/IyMxmsLd34/vaTbomDIXdT4LR7ENo3Bz27dtHWVk5ISHBGI1GAgMDyc2tbM8zaRn1hIRuO2bCv/K/XB1/N7m5uW1q3n5CMzYxFs00DSnZKcyePZujR4/i7e1NQjMiozoz7ZGUNcmiajPtX7Efv41+3HL2Fpe0K+l+SIPfEmzuDLuCzvahmiOimxEpU8+k6+r0xRRW9UbBzA8/7Ka6uhqz2UxpaSmbN5fzz3+69jRaTT0hoVOGgcmcT3Z2Nl5eXm0+hH0WbOVblZRPLCd3eC7Dhw8nIyOjib07P66aNLZHqp5Kmos0+M3Fzp3x6V44dQmGhcANtnDm+iJlrDeIddtSSDf2ZtS1vyTffQyRXn9gjOXNGj/4opvjSD7vz8GDh7j66qnodLXRFP/61xNcutSGME5X0lhI6MyZLj2UxWThe75H/52eN4++Se9FvUlMTHTpMbo6XV2vR3L5kQa/udi5M9LyoMIE5bYInPpKDtrdIOIjoX9hASVHn2Xg+CS8h/wChvypZlMfYM4w+PrryaSkJDN69CGEUNDpLGoY51OdJMPxMoaEavVartFeI41ZA3Q2vR5J16BNBl8I8RfgfiDHuuiPiqJsqGe7WcALgBZ4U1GUzuKkaD527owhwZBVBO46AAE3X6i7vd0N4kwWlFaAn3cla978N4+8srDeQ3z2mQ8ZGXPYtm0yCQnJxMSc7Fwp7ZchJFSOWptHe7iGJN2fNoVlWg1+iaIozzSyjRY4BUwH0oG9wJ2Kohxrqv1OFZZpF07pgFd4/QZ/rQZ7X38tAu6StWPrY3nocjlqlUjaSEeHZV4JnFEU5Zy1Mx8ANwFNGvyOwKFObSqQBQRAyLDepId51XFnJFfczZlVq0hJSeHYsWMsX75c1chx8nfX4FVXP6el8rVdFWcdmfT0dEaPHk1qaiqhoaFy1CqRtDOuqHj1ayHET0KIt4QQvetZHwKk2X1Oty6rFyHEEiHEPiHEvpycnIY2azdujL4RvVavfvAHAkDnpuOmYXfClSvVET0CvMIxjniVbO1o1q5dy8GDB9FqtbUqmKOfVv3b9jj5u41GI//5z3+4++672bp1K0bj5anC1FHYwi5fHPgiRZ8WMXzgcKqqqggICHBZYXaJRNIwTY7whRBbUCu2OrMMeA14CtV38RTwLLCoLR1SFGUlsBJUl05b2moNSQlJrD60Wv2QDqSBdqyWpMlJ4BMEkfNr5Wc/UwuSh4WFYbFYEEKQmpqq6qI34u+2l68tLS2luLiYyspKDIbum2xkw15HpuqjKkbOHsmg2wbJZCGJ5DLQpMFXFKVZeq1CiDeAr+pZlQEMsPscal3WKQk2BJMYm8iqg6swDTGhH6pncdxih8ImjRUknz59eu2H+jR4nPZPSUkhNDSUoqIi/P392+28Ohs2HZnKLyvJOJIhk4UkkstAm1w6Qohgu49zgZ/r2WwvMFgIESmE0AN3AF+05bjtTVJCEhqhXhqtsI7u7WhpQXJn7PcfOnQogwYNcpCw7Qlo9Vp0njriH4xn0a42PRRKJJJm0lYf/r+FEEeEED8BU4FHAIQQ/YUQGwAURTEDvwY2AseBjxRFOdrG47YrtlG+RmhIjE2sU7bQpkK4dOlS4uLiWmz427q/jeWhy1n/0HqMmV3H928z9HH3xbH03FLmvDJHRuRIJJcJqZbZAE3VqbWnpKSkRn62NVE2rd3fXjGxNKEUtzFujL16LPn5+S6rnuRKZNilRNL+NBaWKQ1+Z6MF8sP2UrvFbsUUiSLcxrkx+LrBxIyOYfbs2Zer1xKJpJPQmMF3RVimxJnza+CzCM4sF/xjQW9Sd77Q/P32LIGyFHacUHj7mxS2rFqsLm+CnKoczpnOUbazjP3P7XdZ9SSJRNJ9kFbB1dhp6KTlQZhvIeV7/w9C/JuWILCTYwjpA1uPQYBvpbq8iX2H6IcQrY2WkgQSiaRBpMFvK1YXzNvfpJBu9OOWKyAmUDXauSVQUgGp2RVEN8NoOxdHCfIDnYY6ssT2SO0ZiUTSXHqWwXd1eT670XygL4wOKwRz7erbxtlt24jRrsGpOErCULvl9SAVEyUSSUvoOQbfzjiv2wPZxSkMP7SYHSWfs+yZj1rXpp0Lxs8bUvNAIyCmfz3bNmC0HWih/LDUnpFIJC2h5xh8O+McHwmpueAmKon3Sm59m3aj9vGDG9muuZrxDnIMKSC0ap8PL3NcL5FIJK2g50Tp2BnnM1nwyHsQYICjZ7NJS0trZMdGaGjUru/rILLGlSubb6wj59cKrykW1u2Bv7+fwpevLWLTO//Hu+++27q+SiSSHk/PGeHb+cenjYD91gH3Y7eFw4ABjeyokpmplqvdtcuu3GBDLpj4F9o2Gnd6GgkwwJE0E1fnvkP0Lbtb365EIunR9JwRfjPkihvjqafg/PmPWLz4y9qFkfPrSCa3aDTfEE5PI9tPqFW2UtIzCQ8Pb1vbEomkx9JzRvitKc9njerJzDCxetU5FKWczZtxLCregCJmm3B6Gpk2wrZcGnuJRNJ6es4IH1TDfPMFtcTgzReaNvbWrNeFK+ZQZf43cBSLeQNPPFHRvv1s49OIRCKR1EfPMvgtwepHzywIYtvxx7BUTwHCqVYW8s476ii/3WgvV5FEIunR9ByXTkux+tGf+jSJ6upzwAFgHHAGs9mfp54awSuvtOPx28NVJJFIejRyhN8Q1pDLLw7ciLl6NvAnYDpwH2bzCD7/vCM7J7GnK9YFkEg6AjnCbwhryGX6y3Yhm1ov6VrphNiKox9afQj9LD1uV7nx8O8f7uhuSSSdDjnCbwgHPzqOWa/2csVWKWTWatT/myFlLHE9FpMFc4WZgvUFHP3zUTnil0jqQY7w68NeZM2tD2j0UG3iox/AU59Cr0OLSbjXuq2dPs+Jiyk8Zryf/675lpFTFzNhwoQOPY3locuJvjGahKQEDMGGDu3L5SKlKoUooti/Yj9nN57lt2d/29Fdkkg6DdLgO2Mnsgbw0Y48jmfA72+A/Ap3TuXGYPYZSoJN38YuIzanGLCUU3DyU5i6uINOoBZ7V4d2ppaA6QEEhgWi0+nw9vYmISGho7vocobqhzrIRUskklqkwXfGTtYAoNwEEUHuvHXsSt45XM7Zc+e5886EOnLHZ7KgpErPm0fHcaDYnYnV1Y0fx9VSzQ1gMVnU89hQzub1mxkyfgi/efY3FJmLXH6sjkTWBZBImqZNBl8I8SEQbf3oBxQqihJbz3YXACNgAcwN1VvsFNgZcqPZh2Nlg/k5xx+93h0fg555826hb9++tcJpZSkYzT7sN45ky0U9V4ePJ79kD5MmTWr4GE5PEeu2pZD+aSKjZx0j1y2OgQMHMmbMGJee1u6q3YQRRtnOMh6e8TCv7n3Vpe13JLIugETSPNpk8BVFud32XgjxLNDYsHGqoii5bTneZcFO1mB12iK8o/y4MkrD0aNHEWUVFBcX079/fxj9NMYyM9u3fMqhohHkaQrp3TcbC1qCg4MbP4bTU0R8JPTvXUXJyTfxvfpdNBrXz6VP1U/ttiNgWRdAImkeLnHpCCEE8AvgGle016HYKWAuGvAWyfkJHCqOY9TwaCz2lytyPqtffJHCwjgUoKC4lPLycvLz88nJySEtLY0BDalw1uMOKq2APj7ZFJlMWCwWl52OdHVIJBIbrvLhTwKyFEU53cB6BdgkhFCAFYqirGyoISHEEmAJQFhYM6pEuRo7kTWfslTmRBxl8pBfkHzenx/27QYEOnSIJwU++JBAAmMYQ1RUFBEREQD069evrrG399kLDSi1Rt1BHO366112KtLVIZFI7GnS4AshtgBB9axapiiKLd/0TuD9RpqZqChKhhAiENgshDihKMr2+ja03gxWAowdO1Zpqn+uxmg0sv2YHyfP/ZZHH1VdBT7AHM81fH3qJVKKJzKEGNgEJZklbJzwNal5qVw75FoCAgJQFKXuCN3OZ598HDLyLRg8obgcxkTA0BDaRRxNujokEok9TRp8RVGmNbZeCKED5gHxjbSRYf0/WwjxKXAlUK/B7yiMRiOvvPIKu3fvZvDgwZw4cYJbb7219inj8DKW9S1moHEDXykbIBp0RTriqkbjXgj9Ml/gNxNiSLYs4eRFp/uUnc8+Lhy2HQN/AxgrBUP7K+rIvp2idCQSicSGK1w604ATiqKk17dSCOENaBRFMVrfzwD+6oLjtowGwiCNR99m+9avOZQ/iPJyEzqdjsrKSry9vSkvL6/dvyyVYB0kGuCDYh96nwykvKCcimOVWNz0XMiB/T+dQFT9gUcfWOV4bDuf/UubYMowMJmhpEIhbcRnjLnppst0ESQSSU/GFQb/DpzcOUKI/sCbiqLMBvoBn6rzuuiAtYqifOOC4zafhsIgr/qIN74tx8M3hLBwNzZs3ABAVlYWFouFN954g/79+6uuHa8wjMV5TFEm04dYUgankOmZyciRI/Hz86P32QMIoKy8Ur2x2I/W7SJ/lt1s1y+vcJDGXiKRXCbabPAVRVlYz7KLwGzr+3PA6LYep000FAaZ9hW/iNRz2DgSrQhh9sxp/LD3ACNHjmTr1q2cOnWKvLw8Pv74Ywa638fO9FwKq3rhhobKskqEEPj5+QFqCcKtx2D8YOpE4TRY+1YWNJFIJJeRnpFp22AYZDXpeRVcE7SXQaGpLPkgHIvFEz+/XgQFBZGXl0dgYCC+vr5oAq9nUdRhkr/7moP5g4gZHo3W7vLNGq2+gNqkLBstKK/YE/VvJBLJ5aFnGHw7lwrYhUEKLZNi1IiaF8/fztgJfihWAVEhBMePH8ff358f3ryZfqPvIHbZW8wZdi+TS0pITk7m0MH9KJYqx/j8hkbu9RQ0MRqNbN++nZMnT9ZEBNnr35QmlOI30Y/giGBycnJYsGABAQEBrrsuEomkR9Ez5JEbqhEbtaRm+aIBbxHfax86UYUWM7GxscycORNfX1/6eJWTuu9dvnzzMQB8fHyYM2cOSx9+lLjoPhjcSmlJKUKj0cgf//hH7r77brZu3cqPP/7Il19+WbPeJvVbubWSs387i3mTGYPe4DiJLJFIJC2kZ4zwG3OpBEyoTbIK3MDkPttJzk/g+e2lWKoVQkLDUBTIzDdTfvId4NmaZn18fJhzxyPMAeDfTXbDNqI/dOgQlZWVlJSUUFlZiZeXF6mpqXW2z6nKoYQS0tamkb45nWFxwzomGU0ikXQLeobBh4ZrxNov/ywCn7IU1fDf60NyfgInSwKZICDQF9wtbZMCWr16NYWFhSiKQk5ODoGBgRQVFaHT6RgyZEid7Yfoh9TIIjya9KjMlpVIJG2i5xj85mAXTeOjK2FO4AbmBKqhmmMiqa1+1UoWLVqk+v4PHWLIkCEOGbnTp0+veS/1byQSSXsgDb49tpH+/qVgynNc54IwSpvvf/LkyTWG31mKQerfSCSS9kIoymWXq2k2Y8eOVfbt29cxB78MBUpKrNE+9lE6EolE0haEEPsbqjkiDb5EIpF0Ixoz+D0jLFMikUgk0uBLJBJJT0EafIlEIukhSIMvkUgkPQRp8CUSiaSH0KmjdIQQRuBkR/ejk+MPtC0FuHsjr0/jyOvTNF3tGoUrilKvymJnT7w62VB4kURFCLFPXqOGkdenceT1aZrudI2kS0cikUh6CNLgSyQSSQ+hsxv8lR3dgS6AvEaNI69P48jr0zTd5hp16klbiUQikbiOzj7Cl0gkEomLkAZfIpFIegid3uALIf4ihMgQQhyyvmZ3dJ86A0KIWUKIk0KIM0KI/+vo/nRGhBAXhBBHrL+bHi+7KoR4SwiRLYT42W5ZHyHEZiHEaev/vTuyjx1JA9enW9mfTm/wrTynKEqs9bWhozvT0QghtMArwHXAMOBOIcSwju1Vp2Wq9XfTLeKo28h/gVlOy/4P+FZRlMHAt9bPPZX/Uvf6QDeyP13F4EscuRI4oyjKOUVRTMAHwE0d3CdJJ0dRlO1AvtPim4C3re/fBm6+nH3qTDRwfboVXcXg/1oI8ZP1kavHPnLaEQKk2X1Oty6TOKIAm4QQ+4UQSzq6M52UfoqiZFrfXwL6dWRnOindxv50CoMvhNgihPi5ntdNwGtAFBALZALPdmRfJV2KiYqijEF1ff1KCJHQ0R3qzChqjLaM03akW9mfTqGloyjKtOZsJ4R4A/iqnbvTFcgABth9DrUuk9ihKEqG9f9sIcSnqK6w7R3bq05HlhAiWFGUTCFEMJDd0R3qTCiKkmV73x3sT6cY4TeG9UdoYy7wc0Pb9iD2AoOFEJFCCD1wB/BFB/epUyGE8BZCGGzvgRnI3059fAHca31/L/B5B/al09Hd7E+nGOE3wb+FELGoj5oXgAc6tDedAEVRzEKIXwMbAS3wlqIoRzu4W52NfsCnQghQf+drFUX5pmO71LEIId4HpgD+Qoh04Angn8BHQojFQArwi47rYcfSwPWZ0p3sj5RWkEgkkh5Cp3fpSCQSicQ1SIMvkUgkPQRp8CUSiaSHIA2+RCKR9BCkwZdIJJIegjT4EolE0kOQBl8ikUh6CP8ffDTH39f16RYAAAAASUVORK5CYII=\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" }, { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXwAAAD4CAYAAADvsV2wAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/Il7ecAAAACXBIWXMAAAsTAAALEwEAmpwYAABFe0lEQVR4nO2de3xU5bX3v09mMuEyE5CbGYiQYC0KnpJADmqLidZLrVGoSj0qWpuoHEs90tL2vH1Lx0t9Pdq+SistWmgxthYvp7UqR/CGWqjUvhpItFqNyk2CQRFBJgRIZvK8f+yZyVz23DIzmZnM+vqJmdmz97OfDDNrr72etX5Laa0RBEEQBj9F2Z6AIAiCMDCIwRcEQSgQxOALgiAUCGLwBUEQCgQx+IIgCAWCNdsTiMWYMWN0RUVFtqchCIKQN2zevPkTrfVYs9dy2uBXVFTQ3Nyc7WkIgiDkDUqpndFek5COIAhCgSAGXxAEoUAQgy8IglAg5HQMXxDSQU9PD+3t7Rw5ciTbU4nKkCFDKC8vp7i4ONtTEQYxYvCFQU97ezsOh4OKigqUUtmeTgRaa/bt20d7ezuVlZXZno4wiJGQjhCf7avhiQp4qMj4vX11tmeUFEeOHGH06NE5aewBlFKMHj06p+9AhMGBePhCbLavhlcXgLfLeN6103gOUDk/e/NKklw19n5yfX7C4EA8fCEm5Q9fjXqnC/UefT/vdFH+8NXZnpogCEkiBl+IyZyhXmxh22zA3GHebEwnb2lsbGTcuHGcfPLJ2Z6KUMCIwS8AypeWo25VET/lS8vjHusqn0BRWLTBosA1If6xeUsG1iy++c1v8swzz6Q8jiCkgsTw85jypeXsdu+O2D7BMYH2xe2B53OmzGFVyyq6vd2BbTaLjblT5sY9h7PmpzR8eDWrDnjpxvDuG0ZYKKu5Mx1/Qu6RoTWL2tpaduzYkfr8BCEFxMPPY+Y4TzQPt4w/MWSbq9ZFkQr9p7YoC646V/yTVM7HdfYvKPItKlqUwnXOPXm1YJsUry/pM/Z+vF3GdkHIc8TDz2Nc1ndoUkBQW2KLApelLar3D4Z331DVQJm9zPT1WMc2zPwWZVO/nerUc5euD5LbLgh5hHj4eYyz50MaHAS8fBvQUAplPbuZM2UONku4/2/Q7e3m3uZ7o8bxzY61WWw4bI7E7grymWETk9suCHmEGPx8ZthEXKMJLKpaFLhG+babhHHCiRbHjxYCevc/3o16VzBomH47WIaFbrMMM7YLQp4jBj+fmX47zpJhNDiMf8iGUigrMYyT0+Gkoaoh4KkXFxVjUZaQw6PF8cOPjRcCGlRUzodZK2HYJEAZv2etTHnN4vLLL+e0006jra2N8vJyVq1alZ75CkISKK11/L2yRE1NjZYGKHHYvpqO5v/F7Hd3s+nz5Ub2jM84dbg7mLxsMkc8RxhqHcql0y7l4Tcfptvbjc1i49rqa1lev9x02PBjty3alrcG/+233+akk07K9jTiki/zFHIbpdRmrXWN2Wvi4ec7lfNxfr2drUs0ZV/fFeKJ+j31IlVEQ1UDd5x1RyBUEy9LJ/zYfDX2giD0IQZ/kOOqdVExsgJXnStpIx58rCAI+U/KaZlKqSnAo0GbJgM3aa1/EbTPGcCTwHbfpj9rrX+S6rkLmUSLrpwOJ1tv3Bp47qp18ezWZxMy4uHHCoKQ36Rs8LXWbUAVgFLKAuwGHjfZ9a9a6wtSPZ9g0N/qWTHiglC4pDukcxawVWsdtWu6kB5Sqp4VBKEgSbfBvwx4OMprpymlXldKPa2UmhZtAKXUAqVUs1Kqee/evWme3uChoFMnBUHoF2kz+EopGzAH+KPJy1uASVrr6cAvgSeijaO1Xqm1rtFa14wdOzZd0xuUBHv54t3nNrt27eLMM89k6tSpTJs2jXvuuSfbUxIKkHRq6XwV2KK1/ij8Ba31waDH65RS9yqlxmitP0nj+QsOv5e/YvOKxL377asNIbCuDwy5gOm3D14htH5QvaKa1j2tEduryqpo+feWfo9rtVq5++67mTFjBm63m5kzZ3LOOecwderUFGYrCMmRzpDO5UQJ5yilypSvh5tSapbvvPvSeO6CJSJ1MpaWu1/6t2snoPukf/OsR20mOa38NFMdoS+WfzGlcZ1OJzNmzADA4XBw0kknsXu3uUCdIGSKtBh8pdRw4Bzgz0HbrldKXe97Og94Uyn1OrAMuEzncolvHuHPuimzl8U36P2R/s3zBubJMhCL4Tt27KClpYVTTjklbWMKQiKkxeBrrQ9prUdrrT8L2vZrrfWvfY9/pbWeprWerrU+VWv9t3ScVwgjnkFPVvq3AO8IMr0Y3tnZySWXXMIvfvELSktL0zKmICSKVNoOJuIZ9GSlfwu0GUimFsN7enq45JJLmD9/PhdffHFaxhSEZBCDP5iIZ9CTlf4t0GYgmdAR0lpzzTXXcNJJJ7F48eI0zFIQkkcM/mAinkFPVvq3gJuBuGpdzJ44O23e/aZNm3jwwQd58cUXqaqqoqqqinXr1qVlbEFIFGlxmOMkqpkD9BnuWGmXlfMTT8OcfntoQ28omGYgToeTDd/ckLbxZs+ejeQpCNlGDH6Ok7RmTjIGPR6JXEAEQcgbpAFKjhPciMQMU09fCCFfGovkyzyF3EYaoOQxwQuI4SSijgkUXC69IAjmiMHPA1y1LoqLiiO2J5QyWIC59IIgmCMGPw9wOpw0VjcCUOT7J0u4IChdufRylyAIeY8Y/DzBVeti0ohJFFsMTz/hgqB05NLLXYIgDAokS2cASSrFMgynw8mO7+xg4dqFyaljDpvoM9Qm2xMl1l2CZOwkxJEjR6itreXo0aN4PB7mzZvHrbfemu1pCQWGGPwBpL9tCYOJ1pM26sVk2DG0TxyWWi59AVbcdnTAZZfBo49CWRpkdEpKSnjxxRex2+309PQwe/ZsvvrVr3LqqaemPrggJIiEdAaQfisxBsXPnS+cxtYLfxLh3c+ZMsdU1nfu1MuTq641owArbm+7DV5+2fidDpRS2O12wNDU6enpwacYLggDhhj8AaRfSowJxs9jXkwq58PXdsAVvcbvZMMwyWrw5DkdHdDUBL29xu89e9IzrtfrpaqqinHjxnHOOeeIPLIw4IjBT4DypeWoW1XET/nS8qTHSlqJMcEsm4zK+iarwZPn3HabYewBvN70efkWi4XW1lba29t59dVXefPNN9MzsCAkiBj8BIgaLkki9u4naSXGJOLnGe1xm+pdQp7g9+67fcss3d3p9fIBRo4cyZlnnskzzzyTvkEFIQHE4CfA4+88HrLQCtDt7ebP7/w5yhGxiWhLGIsk4ueZkPUtNIK9ez/p8PL37t3LgQMHADh8+DDPP/88J554YmqDCkKSSJZOAlx04kWs2LyCXt1nCYpUERefmFwTi/BMGufdTiBOWmaSipXRsniExHjllT7v3k93N/wtxR5tHR0dXH311Xi9Xnp7e7n00ku54IILUhtUEJJEDH4CuGpd3N9yP0e9RwPbbBZb0kbVNC2zyMpc22dGBWs0OWNIWLHS3+NW6B8tLZkZ9wtf+AItmRpcEBJEDH4C+KUN/F5+kSqisaox6ZCJq9ZFU2tTyDaL9uAq7TSe+DNw/EQx8sadwpUR44typiAIsUibwVdK7QDcgBfwhMtzKiPp+B7gfKAL+KbWeku6zp9pgr38/nj30BdjD/byD2twbg/eq4sJ719F++eG9oVxfBcCy4NX0RtFzrq/i8iZJJXKYkEQ0k+6F23P1FpXRdFi/ipwgu9nAXBfms+dUfxefn+9ez8hmTRAuAamDZg7XJumYp5ks0QdN1pWTjpTSpMlndlNgiCkzkBm6cwFfq8N/g6MVEo5B/D8KZNUdk0UgjNprjxmOJawYkuLAtco82P/MM5jur24qDhqVk42jW6/K4sFQcgI6TT4GnhOKbVZKbXA5PUJwK6g5+2+bSEopRYopZqVUs179+5N4/RSx78gmpR3byIr7KqYSkVxEc8ePMSRsAjNYQ01u8xL7qtGTWLa2GkR261F1qhGNJtGN6PFYIIgJE06Df5srfUMjNDNt5VStf0ZRGu9Umtdo7WuGTt2bBqnlwXMZBH+3oDzH99j6yQPFw03QjjB2IoszD3+y1GlDP5w0R8iTnPYcxjn3U7TME22jW5Gi8GE3EZ6KOQcaTP4Wuvdvt8fA48Ds8J22Q0cF/S83LdtcLJ9Nfz96shYvO6BXmPB1jUaisJDOkU2XBf8IaqUQZWzimOGHBNxulhhmmwaXSkG68Pr9VJdXV0Y+ffSQyEnSYvBV0oNV0o5/I+Bc4FwoZA1wDeUwanAZ1rrjnScP+fwf9i1N+ZuTis0OPq8/BDvO4aUwaPzHo0YK5Yhz7bRTcfaR7Zwu92sXbuWFStWpDzWPffcUzhNytPVaS0YuWNImXSlZR4LPO6Te7UCD2mtn1FKXQ+gtf41sA4jJfN9jLTMhjSdOytESzksUkUhFbl+JligfXLkOK7R0OQGdOJSyef8YwnfKoVVB6GbxMI02azAzcdiMLfbzcaNG2ltbUVrjdcb++Idj/b2dtauXcuSJUtYunRpmmaZw6S7h4LfiQpLVQYGra5TJkiLwddabwOmm2z/ddBjDXw7HefLBaI1Mzlh1Am8t/ctgqvzbcBcu++JKgalAmEdpxUaRlhYcaA3calkb1fohQId15Dno9HNBuk29H6+853v8LOf/Qy3252W8XKedHRaC0a6rqUFEU/rJ9GyX1afckVkXN6faqkscGoTnHJ/SHzedfYvqDimMimpZH84qAhoGFlS0LHxdPLYY4+xefNmPB5P2oz9U089xbhx45g5c2ZaxssL0t1DoQC7rmUCMfjJENZ5qmHylyKyX6bvWhkalwcaSqHMquDU3xneSFh83jnthsTSPcM+3K7RUGGlT5pBYpwpM2/ePGbOnInVasViiV7olgybNm1izZo1VFRUcNlll/Hiiy9y5ZWR0hiDinT3UCjArmuZQOkopfq5QE1NjW5ubs72NAzCY4hAhx7K5O0ejnh7GGodyrZF2yhbM54Oj2byDjiiYaiCbRVQZgWuSPG9fqIiym3ypOiqmoO4UUmivP3220kvlnZ2drJhw4aQ0M7NN9+c8lz+8pe/cNddd/HUU0+lZZ4Fg8n3Tz7f5iilNkdROxAPP2FMYohOdZiGkSWh2S/DJoaGW0p9xn7YpNTnEOs2ORNZEQWM3W6nvr6eRYsWUV1dTVk6OpkL/afAuq5lCvHw4xBVAMyXddPhgdkHJrOpcZNh8H2eSMfRLmbvgk3HQVlJpCcSPK4TuBBjBb2oqJgfXft3nM4Z5hPavtpcRfOhIoxi53CUEToqYPLFc86XeQq5jXj4KWCqRUNf1o2zdFJo/N3niThLJ7G1UlFWau6J+Md1At8ExgPjgDG9PTzwwBl0dEQREo2Wny8xTkEQ4iAGPw7m2Ti+rJtoWQc+o1y+Zzzq9Z2o318ZoVTpH/dCoCTs8O5uN2vWXJfcRNOdFSEIwqBDDH4cnJ+8SMMIa2TWTekkqLzaCK9EyYqJpVTpdDixKEvUQog39mxJTsZYYpyCIMRBOl7FwhePd5V20fQpvmpYcJ37K8rXutj9erCk/054/UrASLeb4JjAa9e9FtnhKqia9pKTLsHzxu9NT+3BFzoq2g1PVFD+3kF2d+2P2C+kmYg/5VMQBMEEMfixeH0J5e91sTuo/uawBucfb2C4Mgxyt8lhfkPtz9VftfWvfR2ufMqWfvwx/OCwzlHgfwgKHXXtZI7NwqojVrp7+zTxpZmIIAjJICGdWHR9wBwzCWNgnj1S6dKP31CXv7mT+959IUR+IZw9KB4APgT2Ah3AA8A+glI6gccPekOMPUC3t5s/v/1n84GlCEsQhDDEw4/FsIm4Ru8MaNb4sSjFncdNYFh7e0DAzE9fZS0cSKAyv8Rawqdas9J7lCHWIWitOeo9ytCwzlcX2WHFQQhOsCyiiItPujhyUBGaykkqKipwOBxYLBasVivZTjkWCo+CMvhJN9WefjvOVxfQ4OjqU6YEGj7/ZcpqGnB1X0eT+3DYxaDPUF9ih993Rg6rUGg0NouNxqpGNJoVm1f0PW6+r8+7v+YzOFLKvcC9QWMctB3kWNex5vo7viKs8m0EhaO64B1jjUGaiEdnRfUKyk8rp9ZVi8PpSPv4L730EmPGjEn7uIKQCAUV0km6v6sv88VVPiEQvrFYio0GJZXzcX7xNzSMslMETCsOq6wF7hxrNCoPxqIsgTn4F3CD9eJdtS4q7ONwjR1qHHCk1HRqpd2lNFZHaabu09wxDUdJ3D8me1r30LKqhWWTl7F24VrcHQWibpkLSBgy4xSUwe9Xf9fK+Ti/3k7DzG8ZEgrV14UUWbmufpeKYyazurLMEDILCsM4rTDfHjrcVV+4isbqxhA5BucEJ1sXbaXMUYaz1MnW739E2ZVdcG1sYxN13r5iK9OOWtJmMC7ebi+eI560G36lFOeeey4zZ85k5cqVaZjpIEI6ZA0IBWXwU+nvGq1rk19nfvqpdxmVtWFBsmAv36Is3HH2HbhqXcywO5n6wV9ZvnwqRLMlh+1RXjCIOm9fEVZER60ia8G3GUwGv+HfvGIzj132WMrjvfzyy2zZsoWnn36a5cuXs3HjxjTMcpAgWlADQkEZfOh/f1e/YY8wlv7b0FeuIlzLpnwbjN8O/jC6V3tx3u3kvF9P5+KjB/nk43/wySdvp/YHmRFUhGV4+YabbykqFu8+CSw2C9ahVmZeP5N5j85LebwJEyYAMG7cOC666CJeffXVlMccNIje/YBQUIu20Oflr9i8InVvd/tqyh+6it2eSNGyCRYjhn7fwcjDTu3aa5q/nyxxF6Er5+MEGtYuTM/fWyBYbBaURVHVUEWdqw57Wew7rUQ4dOgQvb29OBwODh06xHPPPcdNN92UhtkOEtLdIUswpeA8fEhjU+3Ni5gzTJvm6c+1GzF0sxYaxcmcI1qiiCPxReh8biI+0JRVlVF9bTWLti2ifnl9Wow9wEcffcTs2bOZPn06s2bNor6+nvPOOy8tYw8KRAtqQBB55P6yfTW8ciUdHgLNTvwENz25eg/8PixGfz2KsqDwz823xPg38L9kIovcMebLTF42mSOeI33n9jdiEU8+QL7IDufLPDNGNOlvISkyKo+slDpOKfWSUuqfSqm3lFKLTPY5Qyn1mVKq1feT//eyvsWkiIVRjDfVuR3Ue5HGHuBJNEeDnh+1mcR9oM+7j5LB4PzkxX4vQgtCzhFN+ltIG+kI6XiA72mtpwKnAt9WSk012e+vWusq389P0nDe7BK0mBSc/tgNHIpz0+SXT/gQ+Bj4zo9G0vHhFsObD/7xXwdiZDD0dxFaEITCI2WDr7Xu0Fpv8T12A28DE1IdNxcpX1rep2v/nka9Z3jx//pBX0vDabaiiLi6GR3ASozq2cPTvxG9wxXEzGDwL0KHtFkUBEEwIa2LtkqpCqAa+H8mL5+mlHpdKfW0UmpajDEWKKWalVLNe/fuTef0+sf21fDHMfCQYo7aHbFAC4Z8wX0+nZu3untjiqWFY1EW7jz7ztg7xelmJYuygiAkQtrSMpVSduAx4Dta6/Cg9BZgkta6Uyl1PvAEcILZOFrrlRjOLzU1NdldUd6+Gv7eALoHMEI34UJqqWKz2ELkkv2E6N1Mvz1UDA1CMhj8NQKCIAixSIuHr5QqxjD2q7XWEXq9WuuDWutO3+N1QLFSKmcVpAKhm99fiXq3JyJ0E1igtdiY4jAPoVhUX0JmtDfZoixcOu3S+KmV0s1KEIQ0kI4sHQWsAt7WWi+Nsk+Zbz+UUrN8592X6rnTjd/QmxUzBefWB4TU0Dw6+kBErn1Rp5Oh934I7jIcCq6ygyJIYgFjgCu/cCV3nHVHYvo+lfMNj37YRCOm//oS0RnJMw4cOMC8efM48cQTOemkk3jllVeyPSWhwEhHSOdLwFXAP5RSrb5tPwImAmitfw3MA76llPIAh4HLdK4UAATl/s6x2liFeRcrv+xxzQd9OfeHvT1U7eiJ2PeEv/2Ydz8eg+Plm3h34UI08NcjcPoQeLATrhxRzF+9I7mz5wXK/mcCDSOGs2q/0c0qamqlaNwPGNu3v8RDD52Px3MEq3UIV1yxjsrKM1Med9GiRZx33nn86U9/oru7m66urvgHCUIaKezCqzAjalZEBUZl7HUjYPk4WPgREU1PijFyUzVQ5C7DtmwbR3qGMtTWxbafT6Zs5EeB8Wfvgk3HQVlxcWBtIPi8UQunnqiIUno+ychZDv+7pIAlQDIFTdu3v8TDD19AT0+fMS4uHsbllz+VktH/7LPPqKqqYtu2bfhudlOapyBEI6OFV3lNWH57eBGVH2tQUxMzyWGrgnnDjccnvOKiVxs7eHuLuO3xvtCM0wpbK316+bonZLs/rTNqamWi4lIiM5sSDz10foixB+jp6eKhh85Padzt27czduxYGhoaqK6u5tprr+XQoUMpjSkIyVLYBt/EiIbG6I3Ye8PMhZR9Q8OwSaaVtQ2lcM84mHi4jJ2vNdDtGQJAt2cITRsb2HPg2LhTcY3G0NOPo3Efd7vIzKaEJ0imIpHtiY/rYcuWLXzrW9+ipaWF4cOHc+edcdJxhcFLlpq9FLbBLx4VsSnY277SAZU2a58R9l0gQi4KPu/faYX65j7v3s9hbxHOJlcg00e9Z8gmm513a6WibO8L5nNNVFxKZGZTwmodktT2RCkvL6e8vJxTTjkFgHnz5rFly5aUxhTylCzehReuwd++GrzmnUf83vadxw5l62UPULOyJqS6dvz2vjh/QymUlQwHFGu2zAl49wG8Q6CtL8XSn+1jjo7uiSeampnonYBgyhVXrKO4OPTCWlw8jCuuWJfSuGVlZRx33HG0tbUB8MILLzB1qpkCiTDoyeJdeMHp4Qd4fQn0mlfE+mPtfO6bUDmfOVM2saplVUgFrQ0oURi9Z2etgL2baP/VRMq36aDG4ZEENzk3JZYnXjk//uJrnCItITaVlWdy+eVPhWTppLpg6+eXv/wl8+fPp7u7m8mTJ9PU1JSGGQt+3G43GzdupK2tjcWLF2d7OtHJ4l144Rr8GG9u+TZDLoH37oOn7zPdx6Lg3QoYXjSGtX//mLbtdhZX6NCmJ+4yuP9laPwSOIxMneAm56ak6on7LwiSpdNvKivPZMmSw2kft6qqipyV+85j/Ia+tbUVrTVebwyPKxfIYrOXwjX40d50jE5V4amXRRSBgl7dC4BF27l2ex1VVKH4FCvDKd8Gr02ElQd9bQ03uOBAhfH7ghuwEMe7D/PE43a0ika0OwFJ1xQGEUkZ+lz67GfxLrxgDf7S669lyheaqZ37Ao5jOkNeM9PM8csfWL1WzqCO6VShUFiD3sK5dnD++2d4jpSGnqz52xx84xssuqM00rtXFtC9ph/COVPmRIaSTDpaJYQUbgmDjKamJg4cOEDcWqJc++xn8S68YA2++yMvLX+ppnXDv1B1egu1F7+MY+RnQF+mjt/LtxVZaRxpRfd0UnzwRo5hJMpkvds1Cgg39j5Kux3ccexQjEJjH5ZhMTVxXLUumlpD47z91ryPtVAkBl/IQxobG9mwYUN8Dz8XP/uJrMdlgMLN0gG8PeDpttLy11NZtngxax+Yi3u/kUITknqpPbhKO3GNhvWW+5nmaEbTgwdPyHgxY/MAJzyYlACaX+veZrGBhm9ttvDRzzRlq5+ERCuk/fm+UcJXkq4p5Ct2u536+noWLVpEdXU1VqsVi8Wki7SkKgcYfAa/HwUN3m4vnqOazeurabptAaBwlk6i4YSzjOpX30Kr0wpvTe7k62XruOq4e3idLfQEGX71Xuzz3P7guawtXs7SPXcl3MLNVeti1BHF/zwE//cZL46DR+B734MLLoD9++O/F4F83yhIuqaQ54QbfofDEbqDpCoHGFwhnX7G6iw2C8qiqGqoos5VB2V3A+Byd/DssvGmC63HD+mkvHQdyw5u5Fu2WlTPidjiON0jRy6jpSX01jPewqzT4eSvjx/Dcdv2UOI/7NAhWL8eLrwQXn45+gnNbmVD/nBJ1xRyiBQXVv2Gv76+PvQFSVUOMLg8/CQLGiw2C9ahVqqvrWbRtkXUL6/HXtZXFeV0ONk6bVLUUI1rNIy1dvLdCev4VsXSCI2dcKxWT0Sccc6UOXH18J0zz8DaGzaYxwNBQlsh7Rf9P6/vNK3qBURTf4Bpa2ujqqoq8FNaWsovfvGLbE8rd8hk9elA9JPIklRCsgwuDz+JWJ1jgoMpc6dQ56oLMfJAqKdBcdTTOa2KrZV9bn2DAw7aDlLaHblwe9R21HSMRBZmhzcsgCfWgjuoMnj4cJgfJ6OHKFW9ZgqbgkEZ8JHJ9mOBPf0fdsqUKbS2tgLg9XqZMGECF110Uf8HHGxkemE1k4ukuZYFFIPBZfCTKGhY3B5aiReo0vtnC4sn3hH04YvWn1YR3uvQNRqOXTLCkDlW8Ga5nbcP1tJ6sBqtFSFv9/bVUDk/sDDrN9amevinn278LikJOr3q2w64HIdoCqsctliKcY214s8MChSUsRNe77sdiZvXX0iYGftY2/vBCy+8wPHHH8+kSZPSN2i+k88Lq7mYBRSFwWXw+xGrMy3eiBX3DmCoZwZfYPzpnCsOGgu9k4d0MnnIOupGbWTDp32G34s1xAMI9vJN0y6tVli3Dlpa+rZVV4M/I+HVhTjbfx+aSgo0TPg8ZV/8330NXkYOZ9X+I3T39mUX2Sw25o4/0ZfJkwNFKQXAI488wuWXX57taeQWWaw+TZk8ulgNvgYoCS78xKrSu/mEW+KfZ9gk0wtMSJOTsMtpp8fOhk9raes8kcWTl4aEVuz/ZedQT6Q+ekLe98NW0N7QRioKtlUWUXZV39/V4e5g8rLJHAmS+h1qKWZbpZUylXh9QL6RVGORWOswafiqdHd3M378eN566y2OPTZUNrugG6CEh0Ugfz6HyTQnGgAKqwFK5XzjTb6iN2bqY1NTE5s3b8bjiVxINaNjfxnHf/f9Pm17/4Vk1kqwDA/sF9LkJIwTP+jkgs/W8T3vUkMq+fWdqFsV5UvLueSkSyL2T7iqVnsD5w40UimFMkvoSm9IXr9v/IaRJaHGHkQ/P4M8/fTTzJgxI8LYD2oSWdAciIXVTJGodHkOMPgMfoI0NjYyc+bMKMUakW7eHc9dzTlf+zrLdypWfAAd+7YHvZqY6zdneGQ3Lb9Rv/PsOxkSprne7e3m3uZ7A1k35UvLzQdWFsq3GXUA9x2EXuDez3za+2HHuGpdgabpFmXBVdppMiA5eTs6GHj44YcLK5yTTPZNgs5azpGhi5Xb7Wbt2rUsXbo0PfOkgA2+WZVeXwGVDmlY8i9vjMY+bTnO8S1Yh+1hz1F44GkXHR1bYPOiBGP+yrQ9oj9mH+59hxPT2z9+gfnFRBVFHOM/T5EqMhaHS6MsHOZD7DQTRHO80+CQHzp0iOeff56LL7449cHyhULpwJbGi5Xf0C9btoyWlhbcbvO+Hf0hLQZfKXWeUqpNKfW+UuqHJq+XKKUe9b3+/5RSFek4bzoINvzdJf/gIAdDXrcBZ/UMo6Qk1BPu7oU1v58F3fvin8QyDD53vVG9G9weMSwjx1XroijK3YIFHV1DZ9a9uGZ+I/JiYikxPcZV66JiZIXxWh7djg4IezBu2MJ/UkjJ9DN8+HD27dvHiBEjUh8sX8ijBc1ME89jDzf0iYabkyHlLB2llAVYDpwDtAOvKaXWaK3/GbTbNcB+rfXnlFKXAT8F/i3Vc6cTu93Od8Y/yeQdhERoijrL8B4dbnqMJ8F/jBN2HsOUdz7gRObxAe9wA1NYylK6vd0hBtnpcNIwsoQV+3o4yQbvdQdl3IwsMW9u7j+29nc0uIfHTu8MOs/WG7f6/nDRzxcySD5n36SJRGWcE1b/TIF0pGXOAt7XWm8DUEo9AswFgg3+XOAW3+M/Ab9SSimdYylChge+MyS18fhXXPSc/BvT/a1B90duj52N++poOzTFyMDxb/v0DOYfmYlGU0QR1VSHSCo773aGjFlWZLRXXH0snNoOaF+XrCix9uAuP67r4qR3RiNLyn1CARAtVXr8+YM+FTjZxiwJq3+mQDoM/gRgV9DzduCUaPtorT1Kqc+A0cAn4YMppRYACwAmThxgL2D67bgOXUeT+3DA0O775xzWbDuVhoY6bLZgo2tjzrjugKFvdVcFcuw7jhzL43suZm/POBQa5fsPCDH2n/3XZ6ZVuQw5CKtGhOT0lxVbjCwH35fDPWZOxIfJH59fsXlFVO9eEAYUM+338efD9t/lRWVqKiTrsfvDy3V1dRkz/DlXeKW1XgmsBCMPf0BPXjkfJ2DZehWgOazBsugk6qjjpv/6mJLuoRGHHLUdpeVH/8copvKxctf1vkeGuTfjagfmxh7gSCn/+d5iXJVLebbLp7PvS710H9zHxjV/pNW9FU1RxIfBVevi2a3P9k8zXxAyQfgd5BMVeVOZmgr99djDDb+/8X06SIfB3w0cF/S83LfNbJ92pZQVGAEksNo5gAQVbF0ychi/328UQTXSyEhGmhp7gJLukhBjbxBs5DVmaZ53jok9neGUGlo9k4sCxh6gaVcjBzwj0Wh8jRRDCInPC0Iuku2F3AFqd5iqxx5V/TMF0pGl8xpwglKqUillAy4D1oTtswa42vd4HvBiTsXvw3KF7xx5iCE+G30/99NMvGrfWH+K8v3fKILyp37GbZYCxodRh344Go+7n5kjmrGqHvNmD+kiT9T/CorB8m+STX36TKpyRiGuXv8AkrLB11p7gBuAZ4G3gf/WWr+llPqJUmqOb7dVwGil1PvAYiAidTOrhOUK+ytWbUAnnay3rI8zQBxdZGDmiGaGWty8r7YwzHIw7v6A70MZOrbd2kn9uHUsOumx2F1+UiELX4rBzs9//nOmTZvGySefzOWXX86RI0fiHxTMYPo3yWYqcBbrAvyGf/HixfF3zhBpycPXWq/TWn9ea3281vp237abtNZrfI+PaK2/rrX+nNZ6lj+jJ2cwuZUMLpIq1eZpmdHxJ2/3Uf/FSfznyX/i4c+t4weTf57kWOEJ9sOw1/w4c15DoRTLRMPrhbvugjFj4O67jecpsHv3bpYtW0ZzczNvvvkmXq+XRx55JLlBBtO/STZlFLIdTsoyObdomxVMcoWdVrhmuJ0dnXXU9FbFPNxSBN4g2Zp5px/L43/9EC9+z1vBrHv7dvDHEIccNG16Hqmd71fmjIw5ZiLOV9Bfivfeg0svNX4fOgQ33wyrV8Ojj8IJJ/R7WI/Hw+HDhykuLqarq4vx48cnN8Bg+zfJVipwgdcFFKy0Qghht5huj521H9VTdmgRM6hGURy1gYnb0s0rva/ioYeiIuPtfOKVT8FSAijGjh2HUmEeur8M+3Bp4Gag42AHx/9XMdtWOVj/04txBId9/Kp7A6UxUsg9QL/0JXjjDcPYg/H79deN7f1kwoQJfP/732fixIk4nU5GjBjBueeem9wghfxvkk4KvLJcDD74vI2r8YdOmnY1svngTLy6GIvvJujOH93JrbfcivLt5f8pHfYxr7CRHts7gXzb4JLohQsXctNNN8WdgtPhZOtlDzB5eC/149YFirey8mEs5C/FtGnQG9ZPsrcXTj6530Pu37+fJ598ku3bt7Nr1y4OHDjAr371q+QGKeR/k3SSz6qcaUBCOmCEWLauxB93bzzu/siGJT4+/J0KaM77+QY3MrTbnyppTrxm5YB5kUo2KhBzZR7Z4JproLkZOoOK7Ox2aGzs95Dr16+noqKC4uJi9u/fz7nnnstrr72W3CCF/G+Sbgq4slwMvj/7ISj90Z8JE9KpCiterQIZPMHyC17H/dTY6mn97F+i5tma9pw1U8DMlQ9jrsxjoLnwQviP/wjdZrUa2/uB1+vlmGOOYdOmTezbt48hQ4bw8ssvM3369OQHK9R/EyFtSEjHLPvBRyAFsuIeqj8/AscwC9hGh2TwWBQsGXeU+voLQ6SWw1Mlg3Xo/SSldyMMDCNGwP79oHXfz/79xvZ+8MknnzB16lTq6+v5yle+wllnnUVvby/z54vhzkcyoVE/kIiHb7ZiH4bd2kk9P6R+3v3APTj/3kCDo6dP56aoB165EvvQidT/8yy++vM1vHnZZayvrAyM4XQ4aZj8JVa9+0KfAubxXxS9m0HOmDFjcLvd/OAHP+D73/9+tqcjJENQRa67eAobPQto3daVMWGzgaCwDf721RhLrwkU/fZ29+U86x5co+nTuQH27B7H2z+eTB0PUNSt+cIDD/CFujoj9nvMMbB9Na7ev9HkO51Fgav7BfjjGKi5J/qteilg1v/AASRYvyVkD4vFwsiRI3E4HLjdbg4fPpxR+VshTfhCve6jRWzcd75PHPFTExmV/CK/Z58qry8hqc7UQTnP/t61fjpvt/PF7r/1NTA5dAieWwenjoKfToKeTpzqcKgCphXo2RdbKTBasxuz7QOkESIkT7jhT7rSVhhYfKHepl03+rSrBkf0e3D8FYlgpkOSbNHKsIkRec8d+8uYdON2Xj54OlafTk4ALzAeI2zUY2jFuUYbevf+OwNjvzRUTA6m0vsMkCtetd/wl5WFhvJyZX6CD59tCNGuCv9+5yGFYfCjGcPiUXEPDVBkMzzmsHzo2x538cG+iTyor+QQYRIMJdB16hDWflTP0m2Gfob/ziBCPC3s4rO0fClrF65NfH5xSu/947k70tcfM18YMmQI+/bty1mjqrUOZPAIOYLPsQtJ3BixJe8Nf2GEdKIZQ8tQw3gHv6aKjSpZT1Aetm00zAyKs+/dBO//mo79x3L/hgagiA2cAcARStBAifUoXm3lFyXfpfegJX7sL+zO4du7v03JfSWJ/41xSu/du920rGqhtamVqoYqal21OJzZU+0bSMrLy2lvb2fv3r3ZnkpUhgwZQnl5ebanIfiZfju8cmXgaXiqdlvvWVmcXP8pDIMfxRguXXA1U84vp/bLK3EMaTM8fq871NhbhoUae4AP1wGa2x530eMtBsCLlfNZx6m2VzjhhHc5rnw3e8ePpUcFGW3baON3eONzk4rJEpIw9pCQRoi328gsKDTDX1xcTGVQxlReI+s0A0PlfGheFAjF+rFbO6mveIv6ryVx951DFEZIJ4reiHt/KS1/PMSyb1/J2pf/B7d7rJGNE4xZfL3rAzr2l9G0sYFhww9TX7+WxYuXsonZ9FxfwoeXHMdrp53CjkmTQ4+beQ/M+wRO+0Pqpd3hNjqJ0ntvtxfPEQ+bV2ymaXZTcucVsoes0wwsNfcMOjmLwjD40YwhfcavZVULy66/hLX31+Pebw/dN/wOoXgUtz/1I875ynMsWrSM6uoWSkvd2KxH6f2slllj/2ke6/Mbdb94Wn/F0FYr+H1F6Bc9CY0Qi82CdaiVmdfPpKerp2Bj+3lHKhLJg6V5ykAyCHV3CiOkE02HhPcDuxjhjmI2vziTrf84nht/vixoAG3kyytwd3WzcV8tx9R8xph7WlF7gDrAAd2eEh5fX8UvH3iEus7OfjcidrvdOCJc+DDMGj/HKb232Cwoi6KqoYo6Vx32MjvN9zYXXIgnb+mvRLL/ziBHmoa73W42btxIW1vbgDQDSel8g0zOojAMPkT5h7s18Mhis6CKeqk6vZW6r70YebwvlufPy7VavUYufAvQClTBwV85cEwYDQ99gH3YROqn305d3SI2bNjA5vmbWfvR2giDGvxhvO4ro9n40tO0fvo5lvB/ov8t802yTeIUYjkmOJgyd0rA0AdTqLH9vCNonWbpDYuZMqON2os2GJ+5WMS6MxhAY+b/rPfHCcqH8+UDhWPwoxDh9R5+0tA/7+o03T9YSdNDcV8f8RZY9voiqmpbqb1oHw4ML8o+C+rr59P8WagnPeO7M9jy7hZaW1vp7e2lt7eXZY99iueuE2GK4qjtKCXdSSzcxonILG6P79n4Df/mFZvZ+uxWbtx6Y+LnFzLP9NsDnrp7fyktG6pp3VhF1aWjqT3FHf0CneXmKWLoc4eCNvjmXq/vTuChIsyqcIPTs+4mSBvFCx5vWEgozIsKGNTfbKb5N81QDdQSWID16OLAXcOd6k6ogcXXrcIxrqgvA8fMu49Dore04Rc/IccIDk0CXo/x9W354yFaH1sW/c4sy12empqaOHDgwIDVQQz0+fKJwli0jcLi9sXUL68PCXEE1PB2xBa6slvD7gAsGquth5lnNdN48/192028KO3R4AGagaBdrarHeODFeL0Flt3wDdY+txz38Q9ELjzHwf+3LFu2jJaWFtxu89sA/yJu9bXVLNq2KOI9SRtaw4oVMHas8Vu+kMnjX/APIm7WVZabpzQ2NjJz5kxTFdkAaVxUTuh8BUpKHr5S6v8CF2JIw28FGrTWB0z224Hhu3oBj9a6JpXzZoLI28DhkUVZJlisHlSRpqq2hbqLNmIf2XchKN8Gu70ablXcwi2B7b2WXkMqeQZwet9YiyruMb9rWLGZrc+O5Mb1K/v5t0S/pQ2+y1lZsxI0mYnf798PV14JGzYYOkPf+x6sWQN/+IMhLif0m7h3ZllunuLvu1xXV2eeyJDmReW45ytgUg3pPA/8b621Ryn1U+B/A/8ryr5naq0/SfF8aSemcZy1su9LUjwK9NGQoizHMQeZMvOdIEMf2rt2jsPCqoOK7l4jPdNj8aCV5nCd4i+7FvLD7zfz7tt/R2ujcMv0rqG4iKrGmcYXOUGvO5lb2uDYvnu3OxBuqrmuJr2G/8IL4bXXoNtX53DoEKxfb2x/+eX0nKPAMMu6ikqsbJMBKuYKN8RtbW3GCxlaVI56vgImJYOvtX4u6OnfgXmpTWfgiWkczb4k21cHKvAW/3IpvAj8EPi3Yrj2Guh4OvDFcZ39fZqe+AH0ejjoOMg7U97h1bNepf6THbS+NJy//KWen55ymVGq3Xli4BSBu4ZLR1P3H6Owf/hteNH3ZRz+HhwqjpxrkF1ubGxMyrPxX/TAF24iAxk7U6bAK6+EbvN44KSTUhu3QImVdZUUiXrXabwo+A1xfX2975yZXVSOOF8Bo9K1sKGU+h/gUa31H0xe2w7sx1gFXaG1jhqbUEotABYATJw4cebOnfEblKRCZ4x8+Ztvvjlif39v2pGH4cE/wxk7wN4Dh2ww/OzzI0IUC9cuDLQ2tFlsXD5pMY8uuIMjR2DoUNh29wTKRnwY2H/pDYuNu4aLX8Z+3r2hX0Y/4do+SfxtwX9TxN2NK/LCoIoUIytGpp6x89JLMHcuBK8jOBxGWOeMM1IbW+g/T1REWdCd1LdWEH5RACPcma4ipETmICSMUmpztLB5XIOvlFoPmLVlWqK1ftK3zxKgBrhYmwyolJqgtd6tlBqHEQb6D631xngTr6mp0c3NzfF2SwvxjKMfvwFfv7KbWR9CSbCNtNngX/81JETR4e5g8rLJHPEcYah1KJdu38vDDw6nu9vY/dra5SxvuMF8UsMmRe/IlcQXzv+3hWfpLFu2LPTu5pag4ZMJFySCxwOjRvWFdABKSuDTT0EW1rJHlGw0UEYlOGTeIGf6glJgpGTwExj8m8C/A2dprWOvcBr73wJ0aq3virfvQBp8P9GMox+/Af/lY0doaAVL8NtXVGR0uPrNb0KOWbh2ISs2r+Cqyv8MePd+htoOs+3nlZSN/CjmvNweOxv31dF2aAqLJ/v6aab4hYu4yLm8YAEU1CyoSY+hD+bll6Glpe95dTXMnp2+8YXkScSYJ3JR8NPf0I+IwqWNjBl8pdR5wFKgTmttqj2rlBoOFGmt3b7HzwM/0Vo/E2/8bBj8RFi4diHvP/Yb/rTaQ2mw1lqUEEWHu4PZTbM5/Y03At69H1uxl2vP+C3Lv3l9YJuR3WM8tmOnjjqqqEKhsGLl5hNu8e1p8oXrB37D33xFM5wInA433xV5dyMMQhLxrhP18MVTzwliGfxU8/B/hbFc+LxSqlUp9WvfCccrpdb59jkWeFkp9TrwKrA2EWOfy7hqXfytwghDHLGALikxwhNKwemnR+zvdDjZeuNW1j8TauwBunssPPnGVT6BJoM5w+EY7NRTzyIWUU01xRRjDV9jT1PhjH9R63u7v0fNTTU4xoukQsGQiEBYonn8qYi7CQNC2hZtM0GuevhgePlv/vnX3FD8JS6ddqmxMdUQhe/WucMDP91+IyMYSZHJNfnmE27pt+e0tHwpU+ZMEa0cITkSCbkkE/oRMkYmPfyCxVXrYvf0Smrv+iNcMAqOuxs+qE2tStDnsTut4LHfzxaa6aEHT7jMcgoyrf7OV8smLxNZZCFxEpH0jnbHOUASDkJ8xOD3E3+YpmzvC/1qShGQcFi6tG9j0K3zkrGdrFfr+C2/ZT+fhh7cHw39IEJ6AIjhTzsF2z84yxIOQnwKWjwtVfw5+eFMsHTRXmJeJRizsjeoBN5+8FNutH2Z4qMnY1VW8zvlFBF1zMxQsP2DsyzhIMRHDH4KzJkyh1XN9xG8DmsD5tqJqBJMWN/GV93btGwZw47uN7ZlaJlF1DEzx2DoMdDRYSxJbdoEZWaVOGYMsoYhgw0J6aSAq9ZFkQrVz7EocI0iIm7Z1NTE5s2b8Xg8CYk4NTY2UlNTkxHFvwFTxxTyun/wbbfBjh3Gb2FwIAY/BZwOJw0nfBmb77kNaCiFspLIuGWykq3+VMlFixZRXV2dNsPvmOAoaEM/0PH14P7BjZsaB+Sc6aCjA5qaoLfX+L1nT7ZnJKQDMfiJEEOr23XBgxRZDDEziwLXhHLTDJr+GvDw4xyO1EICZj0AComBylLK97uo224zjD2A1yte/mBBDH48/NWDUbJwnA4nDdXXUqSKaJi5kLKv74ow9h0dcPzxhpfUXwPuP27x4sVpbRZRiKSapRTvLiHX7qJMM8Ji4Pfu/UWC3d3i5Q8WpPAqHgmUlfulEzY1bqLMHrm6tXCh0eDp+uth+fIU5yPl6ylxq7o1YluyiqC3qlt9Te9VTi/GmiUKmAkChrNwIaxaFapzZ7PBtdem4fMrZBwpvEqFBLS6Azn5JsY+7bFQKV9PG6nE13O5liG8tWWiiQJ+1qwhUgKkG558Ms0TFQYcMfjxSLF6MO2x0Aw3iygE0hlfTzYLZyAWjZPNCAunvd1oNxz+096egckKA4oY/HikUD2YkViolK+nRLrj68neJQzEorE08RaiIYVX8UihejDYu/fj9cJtP2hj+SVf6V814vTbzWP4Ur6eEME9fFMhlQYxmS7KkibeQjTE4CdCtN62cS4CUWOh6+ws/6pvIThaD9FYcwEpX88i6eonm4q0RSKqp9LEWwhHsnT6QyqZMglk/Wzd6ubHP97IjBlt/OAH6fFI04Z0JkqJ4CyhVO4S8iVTSBh4YmXpiIffH2JlysQzfjEWXf1pdK+91srnPqfp6sqxW/DwC12ydydxKBSt/nT1Cx4Mej3CwCIGvz+kkikzbGKEh+/22Nl4sJ7WZcvo7dUo5cXq+5fZsycJ4apMk8qFLgEKQWUyXeGgYET1VEgUydJJBn+FazT5ykQyZUyyfprar2HzvpPweDz09oZ69TlV0j4AKaG5nN+eDjIhbZGvej3CwCMGP1FCJBZMMMuUMZNAMOkh2vi1ambW1GCxWPF4QtPocqqkfQBTQvNZZXKgyHe9HmHgkZBOopiFM/wMmxS5eBkv3h20rx2onwpPP13Hzp0bmD69FaU0Vqs3UKyVEyXtA5gSKlr9sclEaEgY/KSUpaOUugW4Dtjr2/QjrfU6k/3OA+4BLMBvtdZ3JjJ+TmXpJNugOYFsnHDKy2H3brDbO6mt3cCJJ7axdOliJkzIoSrHDGbpBDJP0rCgKQiFSqazdH6utb4rxsktwHLgHKAdeE0ptUZr/c80nHvgMFlsDWw3ox/x7j6jbgfqgXruvjuJOQ4EGexoJF6rIGSWgQjpzALe11pvA1BKPQLMBXLS4EftUzvsGNonDjMNZ/jTKdva2gz5YkjqAmF6/CAkXtpluqpgBUEwJx2Ltjcopd5QSt2vlDrG5PUJwK6g5+2+baYopRYopZqVUs179+6NtlvGmDNlDjaLLWSbzWJj7tTLIxZb3Sffy9p/jgyoErrdQdkkCWjwhKsahhw/CBmo5iOCIJgT18NXSq0HzDLBlwD3AbdhBLdvA+4GUsoL01qvBFaCEcNPZaz+4Kp10dQamhViURZcdS6wl0Hl/D6d8Sda0XqXuUZJDAmEhBuaD0KkWEgQskdcg6+1PjuRgZRSvwGeMnlpN3Bc0PNy37acxOlw0lDVwKqWVXR7u7FZbDRUNYRo3Tc1NXHgwAHiLnhHiXcnfPwgRoqFBGHgSSmko5RyBj29CHjTZLfXgBOUUpVKKRtwGbAmlfNmGletiyJlvDUB7z6IVOVnRb5WioUEIRukGsP/mVLqH0qpN4Azge8CKKXGK6XWAWitPcANwLPA28B/a63fSvG8GcXv5RepogjvHvrfkDxdx/sZiGYa6UaKhQQhe4haZhTi9akNprOzMyA/258sm/4en2+KiUvLl0rapSBkmFh5+GLwc40kCpsipHbzxPALgpA5pIn5QGOmoZPocQG9Ht0nx5DA8aI9IwhCPMTgp5sUjHZM+eE4yCKoIAjxEPG0VAkPwfR0ZqQ5SjREe0YQhEQpLIOfbuEvM0XMaPSzOUpguwmiPSMIQjIUjsHPRHu+WJLJ4STaHCUJ+WHRnhEEIRkKJ4afQnw8Kol2ekpUMz6kOQqgLH1zTHThVxAEIQqFY/Az0Z4vmtduGx0issaslYnfRVTO7xNe0z6NnWQWfgVBEKJQOAY/xfZ8HR1w/PFh7QajKWLOvMdocnJFr/E72ZBRJu5GBEEoeArH4CcgVxyL226DHTvCmoqb9KdNypuPxgA0CxcEofAorErbZLN0fPt37O5m8uJtHOkewtChsG0blMVWW0iNfrRHFARBAKm07aNyfuKhlqACqtse/zG9vra1Xo831MvPBCnejQiCIJhRWAY/GXxx9I79ZTRtbKDbMwSA7h4LTU1hsfx0k6lQkSAIBU3h5OEniy9eftvjLnq1CnnJ6zVi+cuXZ/D8GWwWLghCYSIefjR82TtrtswJePd+urvhySezMSnBjHzsCyAI2UAMfjR8cfT2Xx2HXq2Mn0eGo7etRmtob8/2BAU/0hxdEBJDDH40Eq167a8UspBW/PLQYvgFIToSwzcjOH2zeBQU2aC323gtWIMH0q/Pk0aWli9lypwpBdUQRZqjC0J0xOCHEy6y1rMv8JLbY2fjvjraDk1hcYmv6rW/UsgDgD/U0drUWjCdsMLlogVB6EMMfjgmsgZ+Q9/qrkJrhReradVryAXha3HOk26p5ij4Pd7BbvilL4AgxCclg6+UehSY4ns6Ejigta4y2W8H4Aa8gCdaFVhOEGTITQ29H78GT9fO2PuZkQmp5jgM5lCH9AUQhMRIyeBrrf/N/1gpdTfwWYzdz9Raf5LK+QaEoCYkTbsaOeAZiTZb255+O+4uDxvXP07rZycnZuj9xBJHy5DBH8yhDukLIAiJkZYsHaWUAi4FHk7HeFklSNag8bj7mTmiGavqwYIndL/K+TS98BmbD1Tj0cWJG3sYUHE0f6/b6murWbRtEfXL68ULFoQCJV0x/NOBj7TW70V5XQPPKaU0sEJrvTLaQEqpBcACgIkTE5MuTit+D/v1Jdi7PqC+4i3qPn8pG7aP4e/NrwAKK1bUrQo7dmqpZQYzKLGU4PV6o48bHLNXRX1a98EkKNWcKBLqEAQhmLgGXym1HjDThlyitfbXm15ObO9+ttZ6t1JqHPC8UuodrfVGsx19F4OVYKhlxptfunG73Wz850jatt3I4sVGqMAO1A9dzdPv/pKdB2fzeU4EoJNO1hc9x+R/mcx5xefR2tqK1jrS8IfH7M2MfQbE0STUIQhCMHENvtb67FivK6WswMXAzBhj7Pb9/lgp9TgwCzA1+NnC7XazcePG6Eb79SUsGX2Qye51PKXXAWDHzpd765j41lDqKy+k7vNT2OBdQNuHOuJY0963ygK6N6NZOoIgCH7SEdI5G3hHa20qNqCUGg4Uaa3dvsfnAj9Jw3mTI0oapPut37Hxpadp/fRzsRdeuz7AaYUGBzxy0M4XqaOKKqwoujxWQGPveYd6y4+pv2hlxLGm6F5DqlkQBGEASIfBv4ywcI5SajzwW631+cCxwOPGui5W4CGt9TNpOG/iREuD3LuJpvU2DvRMMc3EWbt2LW1tbUZoZ9hE3Af3cYauYxRVKF8sPwKzbJugzJ8Q0hyzFwRBiEXKBl9r/U2TbR8C5/sebwOmp3qelIiWBrl1JY3lQ9nwaS2tB6sjPPyWlpa+0M7022l6+DUO9IygOF5yU7hHP/320AsOSEMTQRAGnMIQT4saUvFit3ZSP24d15T/llG2fRgJRUYMPiSOXzmfxq9VM3N0GxbVgzc8TTOYcM89iYYmIvUrCEKmKAxphWghFWUJZMz8d8e/ccAzElCR+/1xDNTcg33q1dRPvZq6zk42bNhAa8tmtLcnNO4fzXM3aWjiXygOhI0oTP0bQRAGhsLw8KP1iD1+QWJFVj37jJCMT/rYbrdTX1/Pou8spnrKKBzFh0imFaHb7Wbt2rUsW7aMlpYW3O5Qb16kfgVByASF4eEHFVNFiJWN/VJfkdW4ddSN2mge0zdZjLXb7dRf9l3qAfhZ3GnETf0MYzDr3wiCMPAUhsGH6D1ig7c/UYG9a2eI4W/rPLFv3xSlD5qamjhw4ABaJ1ZPNpj1bwRBGHgKx+AnQlA2jX8xt37cur7XU0yjbGxsNGL/cTx8kfoVBCETiMEPxu/pb14E3ftCX0tDGqU/9l9XVxfV8Iv+jSAImUIlGl7IBjU1Nbq5uTk7Jx+ABiWdvmyf4CwdQRCEVFBKbY7Wc0QMviAIwiAilsEvjLRMQRAEQQy+IAhCoSAGXxAEoUAQgy8IglAgiMEXBEEoEHI6S0cp5Qbasj2PHGcM8Em2J5HDyPsTG3l/4pNv79EkrfVYsxdyvfCqLVp6kWCglGqW9yg68v7ERt6f+Aym90hCOoIgCAWCGHxBEIQCIdcN/sr4uxQ88h7FRt6f2Mj7E59B8x7l9KKtIAiCkD5y3cMXBEEQ0oQYfEEQhAIh5w2+UuoWpdRupVSr7+f8bM8pF1BKnaeUalNKva+U+mG255OLKKV2KKX+4fvcFLzsqlLqfqXUx0qpN4O2jVJKPa+Ues/3+5hszjGbRHl/BpX9yXmD7+PnWusq38+6+LsPbpRSFmA58FVgKnC5UmpqdmeVs5zp+9wMijzqFHkAOC9s2w+BF7TWJwAv+J4XKg8Q+f7AILI/+WLwhVBmAe9rrbdprbuBR4C5WZ6TkONorTcCn4Ztngv8zvf4d8DXBnJOuUSU92dQkS8G/wal1Bu+W66CveUMYgKwK+h5u2+bEIoGnlNKbVZKLcj2ZHKUY7XWHb7He4BjszmZHGXQ2J+cMPhKqfVKqTdNfuYC9wHHA1VAB3B3Nucq5BWztdYzMEJf31ZK1WZ7QrmMNnK0JU87lEFlf3JCS0drfXYi+ymlfgM8leHp5AO7geOCnpf7tglBaK13+35/rJR6HCMUtjG7s8o5PlJKObXWHUopJ/BxtieUS2itP/I/Hgz2Jyc8/Fj4PoR+LgLejLZvAfEacIJSqlIpZQMuA9ZkeU45hVJquFLK4X8MnIt8dsxYA1zte3w18GQW55JzDDb7kxMefhx+ppSqwrjV3AH8e1ZnkwNorT1KqRuAZwELcL/W+q0sTyvXOBZ4XCkFxuf8Ia31M9mdUnZRSj0MnAGMUUq1AzcDdwL/rZS6BtgJXJq9GWaXKO/PGYPJ/oi0giAIQoGQ8yEdQRAEIT2IwRcEQSgQxOALgiAUCGLwBUEQCgQx+IIgCAWCGHxBEIQCQQy+IAhCgfD/AdNvywpgyKVpAAAAAElFTkSuQmCC\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "# run first experiment (only)\n", "for exp in [experiments[0]]:\n", " expid = exp2string(exp)\n", " print(\"EXPERIMENT \"+expid)\n", " compute_sims(id2sichvectors[expid], id2annos[expid], exemplars = False)\n", " plot(id2sichvectors[expid], id2annos[expid], \"sich\", with_labels = True,\n", " extra_labels = \"phrase-toplayer\")\n", " plot(id2sichvectors[expid], id2annos[expid], \"sich\" , with_labels = False,\n", " extra_labels = \"phrase-toplayer\")\n", " plot(id2sichvectors[expid], id2annos[expid], \"sich\" , with_labels = True,\n", " drop_classes = ['1'], extra_labels = \"phrase-toplayer\")\n", " plot(id2sichvectors[expid], id2annos[expid], \"sich\", with_labels = False,\n", " drop_classes = ['1'], extra_labels = \"phrase-toplayer\")" ] }, { "cell_type": "code", "execution_count": 18, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "EXPERIMENT sentence_bert-base-german-cased_toplayer\n", "Pairwise cos for 1 -- 1 : 1.0\n", "Pairwise cos for 1 -- 2 : 0.9579201936721802\n", "Pairwise cos for 1 -- 3 : 0.9582591652870178\n", "Pairwise cos for 1 -- 4 : 0.9765850901603699\n", "Pairwise cos for 1 -- 5 : 0.9139208197593689\n", "Pairwise cos for 1 -- 6 : 0.843771755695343\n", "Pairwise cos for 1 -- 7 : 0.9187951683998108\n", "Pairwise cos for 1 -- 8 : 0.8934639096260071\n", "Pairwise cos for 2 -- 2 : 1.0\n", "Pairwise cos for 2 -- 3 : 0.927308976650238\n", "Pairwise cos for 2 -- 4 : 0.9274550676345825\n", "Pairwise cos for 2 -- 5 : 0.8612233996391296\n", "Pairwise cos for 2 -- 6 : 0.8683467507362366\n", "Pairwise cos for 2 -- 7 : 0.9005529880523682\n", "Pairwise cos for 2 -- 8 : 0.8593001961708069\n", "Pairwise cos for 3 -- 3 : 1.0\n", "Pairwise cos for 3 -- 4 : 0.9544137716293335\n", "Pairwise cos for 3 -- 5 : 0.8991183042526245\n", "Pairwise cos for 3 -- 6 : 0.824537992477417\n", "Pairwise cos for 3 -- 7 : 0.8955825567245483\n", "Pairwise cos for 3 -- 8 : 0.8827053308486938\n", "Pairwise cos for 4 -- 4 : 1.0\n", "Pairwise cos for 4 -- 5 : 0.93608158826828\n", "Pairwise cos for 4 -- 6 : 0.8123337626457214\n", "Pairwise cos for 4 -- 7 : 0.908499538898468\n", "Pairwise cos for 4 -- 8 : 0.8996173143386841\n", "Pairwise cos for 5 -- 5 : 1.0\n", "Pairwise cos for 5 -- 6 : 0.769067645072937\n", "Pairwise cos for 5 -- 7 : 0.861379861831665\n", "Pairwise cos for 5 -- 8 : 0.867274820804596\n", "Pairwise cos for 6 -- 6 : 1.0\n", "Pairwise cos for 6 -- 7 : 0.8843367695808411\n", "Pairwise cos for 6 -- 8 : 0.7552905082702637\n", "Pairwise cos for 7 -- 7 : 1.0\n", "Pairwise cos for 7 -- 8 : 0.8274378776550293\n", "Pairwise cos for 8 -- 8 : 1.0\n", "Saved figure as sich-sentence-toplayer.pdf\n", "Saved figure as sich-sentence-toplayer-nolabels.pdf\n", "Saved figure as sich-sentence-toplayer-drop1.pdf\n", "Saved figure as sich-sentence-toplayer-drop1-nolabels.pdf\n" ] }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "# run second experiment (only)\n", "for exp in [experiments[1]]:\n", " expid = exp2string(exp)\n", " print(\"EXPERIMENT \"+expid)\n", " compute_sims(id2sichvectors[expid], id2annos[expid], exemplars = False)\n", " plot(id2sichvectors[expid], id2annos[expid], \"sich\", with_labels = True,\n", " extra_labels = \"sentence-toplayer\")\n", " plot(id2sichvectors[expid], id2annos[expid], \"sich\" , with_labels = False,\n", " extra_labels = \"sentence-toplayer\")\n", " plot(id2sichvectors[expid], id2annos[expid], \"sich\" , with_labels = True,\n", " drop_classes = ['1'], extra_labels = \"sentence-toplayer\")\n", " plot(id2sichvectors[expid], id2annos[expid], \"sich\", with_labels = False,\n", " drop_classes = ['1'], extra_labels = \"sentence-toplayer\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# Classification experiments" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Experiment 1: full classification" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "def confusion_matrix(yactu,ypred):\n", " pred = pd.Series(ypred, name = \"Predicted\")\n", " actu = pd.Series(yactu, name = \"Actual\")\n", " df_confusion = pd.crosstab(actu, pred)\n", " print(df_confusion)" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "scrolled": false }, "outputs": [], "source": [ "for exp in experiments:\n", " expid = exp2string(exp)\n", " print(\"EXPERIMENT \" + expid)\n", " X = np.array(list(id2sichvectors[expid].values()))\n", " Y = np.array(list(map(int, id2annos[expid].values())))\n", " clf = SVC(kernel='linear', C=0.1)\n", " scores = cross_val_score(clf, X, Y, cv=5)\n", " preds = cross_val_predict(clf, X, Y, cv=5)\n", " print(\"Freq baseline: \"+str(len([y for y in Y if y==1])/len(Y)))\n", " print(scores)\n", " print(\"Accuracy: \"+str(np.mean(scores)))\n", " print(confusion_matrix(Y, preds))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Experiment 2: and now without Class 1" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "scrolled": false }, "outputs": [], "source": [ "for exp in experiments:\n", " expid = exp2string(exp)\n", " print(\"EXPERIMENT \" + expid)\n", " X = np.array([vector for id, vector in id2sichvectors[expid].items() if id2annos[expid][id] != '1'])\n", " Y = np.array([int(cl) for id, cl in id2annos[expid].items() if cl != '1'])\n", " clf = SVC(kernel='linear', C=0.1)\n", " scores = cross_val_score(clf, X, Y, cv=5)\n", " preds = cross_val_predict(clf, X, Y, cv=5)\n", " print(\"Freq baseline: \"+str(len([y for y in Y if y==2])/len(Y)))\n", " print(scores)\n", " print(\"Accuracy: \"+str(np.mean(scores)))\n", " print(confusion_matrix(Y, preds))\n", " " ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Experiment 3: Prediction of features" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# map class labels onto features; leave out classes for which features are underspecified (+-)\n", "\n", "properties = []\n", "\n", "def add_property(name, membership, exclude_classes):\n", " properties.append({'membership': membership,\n", " 'name': name,\n", " 'excluded_classes': exclude_classes})\n", "\n", "add_property(\"predictable\", lambda x: x in [1, 2, 3, 6, 7], [])\n", "add_property(\"agentive\", lambda x: x in [4,5,7], [1,3,8])\n", "add_property(\"stressable\", lambda x: x in [5], [8])\n", "add_property(\"lassable\", lambda x: x in [6, 7], [])\n", "add_property(\"disposition\", lambda x: x in [6], [1, 2, 8])\n", "\n", "properties" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "scrolled": false }, "outputs": [], "source": [ "def f1(p,r):\n", " return 2*p*r/(p+r)\n", "\n", "for property in properties:\n", " print(\"PROPERTY \"+property[\"name\"])\n", " excluded_classes = property[\"excluded_classes\"]\n", " for exp in experiments:\n", " expid = exp2string(exp)\n", " X = np.array([id2sichvectors[expid][id] for id, cl in id2annos[expid].items() if not(int(cl) in excluded_classes)])\n", " Y = np.array([property[\"membership\"](int(cl)) for id, cl in id2annos[expid].items() if not(int(cl) in excluded_classes)])\n", " \n", " clf = SVC(kernel='linear', C=0.1)\n", "# scores = cross_val_score(clf, X, Y, cv=3, scoring = 'f1')\n", "# print(\" EXPERIMENT \" + expid + \", f1: \"+str(np.mean(scores)))\n", "# print(\" f: \"+str(sum(Y))+\"/\"+str(len(Y))+\", pred-1: \"+str(f1(sum(Y)/len(Y),1)))\n", " scores = cross_val_score(clf, X, Y, cv=3)\n", " print(\" EXPERIMENT \" + expid + \", acc: \"+str(np.mean(scores)))\n", " print(\" f: \"+str(sum(Y))+\"/\"+str(len(Y))+\", freq BL: \"+str(max(sum(Y)/len(Y),1-(sum(Y)/len(Y)))))\n", " " ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] } ], "metadata": { "kernelspec": { "display_name": "Python 3.9", "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.9.1" } }, "nbformat": 4, "nbformat_minor": 2 }