diff --git a/Survey name of programmes BSW & MEE (for staff)(1-36).xlsx b/Survey name of programmes BSW & MEE (for staff)(1-36).xlsx new file mode 100644 index 0000000000000000000000000000000000000000..042cdcd82238a429e1d802449c2d49c5d6bf8498 Binary files /dev/null and b/Survey name of programmes BSW & MEE (for staff)(1-36).xlsx differ diff --git a/Survey name of programmes BSW & MEE(1-178).xlsx b/Survey name of programmes BSW & MEE(1-178).xlsx new file mode 100644 index 0000000000000000000000000000000000000000..2749403b8b82cd6e481099bbc58baed602eebcdb Binary files /dev/null and b/Survey name of programmes BSW & MEE(1-178).xlsx differ diff --git a/programme_name_analysis.ipynb b/programme_name_analysis.ipynb new file mode 100644 index 0000000000000000000000000000000000000000..9dbad9c117eb98cd35c4af403f3ff15b6b9981f8 --- /dev/null +++ b/programme_name_analysis.ipynb @@ -0,0 +1,495 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Analysis of survey about name of current programmes BSW and MEE" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + " <script>\n", + " function code_toggle() {\n", + " if ($('div.cell.code_cell.rendered.selected div.input').css('display')!='none'){\n", + " $('div.cell.code_cell.rendered.selected div.input').hide();\n", + " } else {\n", + " $('div.cell.code_cell.rendered.selected div.input').show();\n", + " }\n", + " }\n", + " </script>\n", + "\n", + "\n", + "<form action=\"javascript:code_toggle()\"><input type=\"submit\" id=\"toggleButton\" value=\"Hide code\"></form>\n" + ], + "text/plain": [ + "<IPython.core.display.HTML object>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import pandas as pd\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "from toggle_cell import toggle_code as hide_code\n", + "%matplotlib inline" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + "<form action=\"javascript:code_toggle()\"><input type=\"submit\" id=\"toggleButton\" value=\"Hide code\"></form>\n" + ], + "text/plain": [ + "<IPython.core.display.HTML object>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Get the data from file and define short-hand names for columns\n", + "fname='Survey name of programmes BSW & MEE(1-178).xlsx'\n", + "df = pd.read_excel(fname)\n", + "\n", + "hide_code()\n", + "q_number = {'curr_prog': 7,\n", + " 'did_BSW': 10,\n", + " 'attract_name_BSc': 13,\n", + " 'year_BSW': 16,\n", + " 'year_MEE': 19,\n", + " 'year_MEE2': 22,\n", + " 'attract_name_BSW': 28,\n", + " 'attract_name_MEE': 31,\n", + " 'attract_name_MEE2': 34,\n", + " 'miss_name_BSW': 37,\n", + " 'miss_name_BSW2': 40,\n", + " 'miss_name_MEE': 43,\n", + " 'miss_name_MEE2': 46,\n", + " 'public_words': 49,\n", + " 'recgnize_unique': 54,\n", + " 'broad_specific': 59,\n", + " 'order_synonym': 62,\n", + " 'order_environment': 65,\n", + " 'order_earth': 68,\n", + " 'which_order': 71,\n", + " 'prefix': 74,\n", + " 'comment_name': 77,\n", + " 'comment_survey': 80}\n", + "q_name = {'curr_prog': 'Programme',\n", + " 'did_BSW': 'Studied BSW before MEE',\n", + " 'attract_name_BSc': 13,\n", + " 'year_BSW': 'Year in BSW',\n", + " 'year_MEE': 'Year in MEE',\n", + " 'year_MEE2': 'Year in MEE',\n", + " 'attract_name_BSW': 28,\n", + " 'attract_name_MEE': 31,\n", + " 'attract_name_MEE2': 34,\n", + " 'miss_name_BSW': 37,\n", + " 'miss_name_BSW2': 40,\n", + " 'miss_name_MEE': 43,\n", + " 'miss_name_MEE2': 46,\n", + " 'public_words': 49,\n", + " 'recgnize_unique': 'Recognizable or unique',\n", + " 'broad_specific': 'Broad or specific',\n", + " 'order_synonym': 62,\n", + " 'order_environment': 65,\n", + " 'order_earth': 68,\n", + " 'which_order': 'Which order preferred',\n", + " 'prefix': 'Which prefix',\n", + " 'comment_name': 77,\n", + " 'comment_survey': 80}\n", + "\n", + "# Combine some columns\n", + "def combine_cols(mydf, ser1_name, ser2_name, sernew_name, my_qnumber, my_qname, description):\n", + " # Add new column\n", + " mydf[sernew_name] = pd.np.NaN\n", + " # Update info dictionaries\n", + " ncols = len(mydf.columns) - 1 # series was added to last column\n", + " q_number.update({sernew_name: ncols})\n", + " q_name.update({sernew_name: description})\n", + " \n", + " ser1 = mydf.iloc[:,q_number[ser1_name]]\n", + " ser2 = mydf.iloc[:,q_number[ser2_name]]\n", + " ser1d = ser1[ser1.notna()]\n", + " ser2d = ser2[ser2.notna()]\n", + " for i in ser1d.index.values:\n", + " mydf.iloc[i, q_number[sernew_name]] = ser1[i]\n", + " for i in ser2d.index.values:\n", + " mydf.iloc[i, q_number[sernew_name]] = ser2[i]\n", + " return mydf, my_qnumber, my_qname\n", + "\n", + "def plot_pies(vars):\n", + " fig, ax = plt.subplots(1, len(vars))\n", + " for i, var in enumerate(vars):\n", + " num_sample = df.iloc[:,q_number[var]].count()\n", + " counts = df.iloc[:,q_number[var]].value_counts(sort=True)\n", + " counts.sort_index(inplace=True, ascending=False)\n", + " counts.plot(\"pie\", ax=ax[i], label=\"\", figsize=(15,15))\n", + " ax[i].set_title(q_name[var]+\" (N=%i)\"%(num_sample))\n", + " \n", + "def plot_bar(mydf, split_by, vars, pref_middle=None, include_all = True):\n", + " split_options = mydf.iloc[:,q_number[split_by]]\n", + " counts = split_options.value_counts()\n", + " split_options = counts.keys().tolist()\n", + " if (include_all):\n", + " split_options.insert(0,'all') \n", + "\n", + " fig, ax = plt.subplots(1, len(vars),figsize=(5*len(vars),5))\n", + " if (len(vars) == 1):\n", + " ax=[ax]\n", + " width = 1/(len(split_options)+1)\n", + " for i, var in enumerate(vars):\n", + " for j, prog in enumerate(split_options):\n", + " if (prog == 'all'):\n", + " series = mydf.iloc[:,q_number[var]]\n", + " n_sample = mydf.iloc[:,q_number[split_by]].notna().sum()\n", + " else:\n", + " series = mydf.iloc[:,q_number[var]][df.iloc[:,q_number[split_by]] == prog]\n", + " n_sample = len(series)\n", + "\n", + " counts = series.value_counts()\n", + " if (prog == 'all'):\n", + " counts.sort_index(inplace=True)\n", + " all_keys = counts.keys().tolist()\n", + " if (pref_middle):\n", + " # Where is the middle one now ?\n", + " if (len(all_keys) % 2 == 0):\n", + " print('There is no middle in a list with even number of items')\n", + " if (pref_middle in all_keys):\n", + " cur_loc = all_keys.index(pref_middle)\n", + " mid_loc = int(len(all_keys)/2-0.5)\n", + " tmp = all_keys[mid_loc]\n", + " all_keys[mid_loc] = pref_middle\n", + " all_keys[cur_loc] = tmp\n", + " else:\n", + " print('Requested %s not in keys'%(pref_middle))\n", + " mylist = ['a', 'b', 'c', 'd', 'e']\n", + " myorder = [3, 2, 0, 1, 4]\n", + " mylist = [mylist[i] for i in myorder]\n", + " x = np.arange(len(all_keys))\n", + " y = np.zeros(len(all_keys))\n", + " y = y*0\n", + " for k, key in enumerate(all_keys):\n", + " if (key in counts.keys()):\n", + " y[k] = counts[key]\n", + " n_sample = y.sum()\n", + " ax[i].barh(x + width - j*width, y/n_sample, width, label = prog+' (N=%i)'%(n_sample))\n", + " if (j == len(split_options)-1):\n", + " ax[i].set_yticks(x)\n", + " ax[i].set_yticklabels(all_keys)\n", + " ax[i].set_xlabel('frequency')\n", + "\n", + " ax[i].legend(bbox_to_anchor=(1, 1), loc='upper left', title=q_name[split_by])\n", + " if (len(vars) > 1):\n", + " fig.tight_layout()\n", + " \n", + "def plot_ranking(mydf, split_by, orders, include_all = True, transpose=False):\n", + " if (transpose and (len(orders)> 1)):\n", + " print(\"Can not use transpose when more than one ordering should be plotted\")\n", + " return\n", + " split_options = mydf.iloc[:,q_number[split_by]]\n", + " counts = split_options.value_counts()\n", + " split_options = counts.keys().tolist()\n", + " if (include_all):\n", + " split_options.insert(0,'all') \n", + " if (transpose):\n", + " plt.figure(figsize=(6*len(split_options),5))\n", + " for k, prog in enumerate(split_options):\n", + " if (not transpose):\n", + " plt.figure(figsize=(6*len(orders),5))\n", + " if (transpose):\n", + " plt.subplot(1,len(split_options),k+1)\n", + " for i, order in enumerate(orders):\n", + " if (not transpose):\n", + " plt.subplot(1,len(orders),i+1)\n", + " # Get the series for this ordering\n", + " if (prog == 'all'):\n", + " set = mydf.iloc[:,q_number[order]]\n", + " n_sample = mydf.iloc[:,q_number[split_by]].notna().sum()\n", + " else:\n", + " set = mydf.iloc[:,q_number[order]][df.iloc[:,q_number[split_by]] == prog]\n", + " n_sample = set.shape[0]\n", + " # Split into a series for each option\n", + " set = set.str.split(';',expand=True)\n", + " options = set.iloc[0,:]\n", + " # Drop the empty one (after the last semi colon)\n", + " options.drop(options.index[options==''], inplace=True)\n", + " # Sort so that we always have the same order\n", + " options.sort_index(inplace=True)\n", + "\n", + " for j, opt in enumerate(options):\n", + " set[opt] = 0\n", + " dummy = pd.np.zeros(set.shape[0], dtype=pd.np.int8)\n", + " for m in range(len(options)):\n", + " this_rank = (set.iloc[:,m] == options[j])\n", + " dummy[this_rank] = m+1\n", + " set.iloc[:, set.columns.get_loc(opt)] = dummy\n", + "\n", + " for j, opt in enumerate(options):\n", + " counts = ((set[options] == j+1).sum())/n_sample\n", + " counts.sort_index(inplace=True, ascending=False)\n", + " if (j == 0):\n", + " prev_counts = 0*counts\n", + " plt.barh(counts.keys(), counts.values, left = prev_counts.values, label=\"%i\"%(j+1))\n", + " prev_counts += counts\n", + " plt.legend(bbox_to_anchor=(1, 1), loc='upper left', title='Rank', labelspacing=0.3)\n", + " plt.xlim(0,1)\n", + " plt.xlabel('fraction of respondents')\n", + " plt.tight_layout()\n", + " plt.title('%s: %s'%(q_name[split_by],prog))\n", + " \n", + "df, q_number, q_name = combine_cols(df, 'year_MEE', 'year_MEE2', 'year_in_MEE_total', \n", + " q_number, q_name, 'Year in MEE')\n", + "df, q_number, q_name = combine_cols(df, 'attract_name_MEE', 'attract_name_MEE2', 'attract_name_MEE_total', \n", + " q_number, q_name, 'Attractive in name MEE')\n", + "df, q_number, q_name = combine_cols(df, 'miss_name_BSW', 'miss_name_BSW2', 'miss_name_BSW_total', \n", + " q_number, q_name, 'Missed in name BSW')\n", + "df, q_number, q_name = combine_cols(df, 'miss_name_MEE', 'miss_name_MEE2', 'miss_name_MEE_total', \n", + " q_number, q_name, 'Missed in name MEE')\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Summary of population\n", + "First we determine who filled out the survey\n", + "* What is your current programme?\n", + "* In which year of your programme are you?\n", + "* As an student in MEE: did you study BSW before MEE" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "<Figure size 1080x1080 with 4 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "vars = [\"curr_prog\",\"year_BSW\",\"year_in_MEE_total\", \"did_BSW\"] \n", + "plot_pies(vars)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Preferred type of name\n", + "Now let's look at the preferred type of name\n", + "\n", + "The study programmes BSW and MEE differ in composition from more standard programmes - for example, it is not common to combine meteorology and soil biology in one programme. \n", + "* We can choose to emphasize this special composition in the name (a unique name). However, this may lead to a name that is not known in the Netherlands and abroad, which may reduce **recognizability** and **findability**. Which aspect do you find more important?\n", + "* Names of study programmes can be either broad or specific. **Broad** names encompass all topics treated in the study programmes in a global manner and are typically short (the name is the ‘common denominator’). **Specific** names mention all disciplines separately and are typically longer. Which would you prefer?" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "<Figure size 720x360 with 2 Axes>" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Which variables to look at \n", + "vars = [\"recgnize_unique\",\"broad_specific\"]\n", + "# Split data by current programma and include the total number (and put 'neutral' nicely in the middle)\n", + "plot_bar(df, 'curr_prog', vars, pref_middle='neutral')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Ranking of various options within categories\n", + "\n", + "In the following three questions you have to rank possible names for our programme. The three questions differ in the way the alternative names are constructed. Based on your experience in BSW/MEE/BSW+MEE so far and your perception and feeling of the names, indicate which name summarizes the programme best. Put the names in order of your preference with your most preferred on top. This enumeration are based on:\n", + "* synonyms\n", + "* names with 'environment'\n", + "* names with 'earth'" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABQgAAAFgCAYAAAD3iJRKAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4zLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvnQurowAAIABJREFUeJzs3Xm8VVX9//HX+4IyiEIqOeAAKooIiILmGE5fK0csEdNKKjWb/Fo/p983K/JbSuVQTt9Cf6VpOWaF+nUKxBRxVkAZHJIUcSIRQSbvvZ/fH3sd3RzOuRPnci73vp+Px33cs/dee63P3tb9sNdZey1FBGZmZmZmZmZmZtYx1VQ7ADMzMzMzMzMzM6sedxCamZmZmZmZmZl1YO4gNDMzMzMzMzMz68DcQWhmZmZmZmZmZtaBuYPQzMzMzMzMzMysA3MHoZmZmZmZmZmZWQfmDkIzqzhJfSWFpM5pe7Kkk6sdl5mZWaU415mZWUfgfNdxuIPQOjxJcyUtk7RE0luSfi+pR7XjMjMzqxTnOjMz6wic78xazh2EZpkjI6IHsDuwB3BecQFlKvb/mcI3MGZmZmuJc52ZmXUEzndmLeAOQrOciHgduBsYBB8Nn/6ZpCnAUmA7SVtKmiDpXUkvSTqlcL6kbpKuk7RQ0ixJZ0ualzs+V9I5kqYDH0jqLOlcSS9LWixppqRjcuXHSJoi6VJJ70n6p6R90v7XJL0t6aRc+WslXSXp7vSt2RRJm0v6VYpptqTdcuW3lPRnSe9IekXS6U29V5IOl/SMpPdTLGNbdtfNzGxtcq5zrjMz6wic75zvrHncQWiWI2lr4DDgmdzuLwOnAhsC/wJuBOYBWwLHAhdIOjiV/THQF9gO+A/gSyWa+SJwONArImqBl4H9gZ7AT4AbJG2RK/8pYDqwCfAn4Cayb8J2SPVfoVWHzR9H9i3ZpsAKYCrwdNq+DbgkXWsNcAcwDegDHAycIekz6fh+kt5r4HZ9AHwF6JWu55uSRjZQ3szM2gDnOuc6M7OOwPnO+c6axx2EZpm/pj+YDwMPAhfkjl0bEc+nP/ibA/sB50TE8oh4FriGLNFA9gf8gohYGBHzgMtKtHVZRLwWEcsAIuLWiJgfEfURcTPwIrBnrvwrEfH7iKgDbga2Bs6PiBURcR+wkiyhFPwlIp6KiOXAX4DlEfGH3PmFb5n2AHpHxPkRsTIi/glcDRyf4no4InqVu2ERMTkiZqS4p5Ml1xHlypuZWdU51znXmZl1BM53znfWAn5P3iwzMiL+XubYa7nPWwLvRsTi3L5/AcNzx/Pl859L7pP0FeD7ZN9OAfQg+0ao4K3c50LiKd7Xo4Hy5cpuC2xZ9E1SJ+ChEjGvRtKngHFkQ/bXB7oAtzblXDMzqwrnuoxznZlZ++Z8l3G+s2bxCEKzxkXu83xgY0kb5vZtA7yePr8BbJU7tnVD9Unaluybne8Am6RvdZ4DVIG4G/Ma2TdYvXI/G0bEYU08/0/ABGDriOgJ/Ia1E7eZmVWec11pznVmZu2L811pznfmDkKz5oiI14BHgAsldZU0BPg68MdU5Bbg/0r6hKQ+ZMmhIRuQJZV3ACR9lTSJ7lrwOPB+mli3m6ROkgZJ2qOJ529I9o3bckl7Aie0XqhmZra2ONetwrnOzKydcr5bhfOduYPQrAW+SDZkfD7ZPBA/joj707HzySa5fQX4O9nEsSvKVRQRM4GLySabfQsYDExprcCL2q4DjgSGksW7gGzOjZ4AkvaXtKSBKr4FnC9pMfAjsgRqZmbtg3NdxrnOzKx9c77LON8ZiojGS5lZi0j6JnB8RHiCVzMza5ec68zMrCNwvrP2ziMIzSpI0haS9pVUI2kn4P+QfRNlZmbWLjjXmZlZR+B8Zx2NVzE2q6z1gd8C/YD3gJuAq6oakZmZWWU515mZWUfgfGcdil8xNjMzMzMzMzMz68D8irGZmZmZmZmZmVkH5leMraxNN900+vbtW+0wzNY5Tz311IKI6F3tOMysaZzvzJrPuc5s3eJcZ9Z8HS3XuYPQyurbty9PPvlktcMwW+dI+le1YzCzpnO+M2s+5zqzdYtznVnzdbRc51eMzczMzMzMzMzMOjB3EJqZmZmZmZmZmXVg7iA0MzMzMzMzMzPrwDwHoZnZWvDUU099snPnztcAg2ibX87UA8/V1taePGzYsLerHYyZma17nOvMzKy9WwdyXUMazIPuIDQzWws6d+58zeabb75z7969F9bU1ES14ylWX1+vd955Z+Cbb755DXBUteMxM7N1j3OdmZm1d2091zWksTy4rvV2mpmtqwb17t37/baaRGpqaqJ3796LyL4JMzMzawnnOjMza+/adK5rSGN50B2EZmZrR01bTyIpPucFMzNrKec6MzNr79p8rmtIQ3nQydHMzMzMzMzMzKwDcwehmVkb0alTp2EDBgwY2L9//10OOuigHRYsWNCppXXtueeeO/3jH//oXsn4zMzM1pRznZmZdTTrSu5zB6GZWRvRpUuX+tmzZ8988cUXn+/Vq1ftL3/5y97VjsnMzKySnOvMzKyjWVdynzsIzczaoL322uuD119/fX2ARYsW1ey99947Dhw4cOcdd9xx4A033NALYM6cOetvt912uxx//PHb7rDDDrvsu+++/ZcsWaJ8PXV1dXz+85/ve/rpp29ZjeswMzMrx7nOzMw6mrac+9xBaGbWxtTW1vLAAw9sOHLkyPcAunfvXn/XXXe9NHPmzFkPPvjgC//1X/+1VX19PQCvvvpq19NPP/3tl1566fmePXvW/eEPf/hEoZ4PP/xQI0eO7Ne/f//ll1122fwqXY6ZmdlqnOvMzKyjaeu5r3OlKrL2Z8bri+h77l2r7Jvb9YQmnz+43zar7bvlwtomnTvpgCub3E7B8oWXNPuc5hrd75xWq/uarhNbre41tf+nr692CB3CihUragYMGDDw9ddfX3/QoEFLR44c+T5AfX29zjjjjK0effTRHjU1Nbz99tvrz5s3rzNAnz59Vuyzzz7LAHbbbbelc+fO7VKo71vf+ta2I0eOfPfnP//5m9W5IrN1Q6l8Z41rzr8J1gWl/t3S1jT131FroiX/BmsO5zqz6mhprqvE3/pK/H1tjb9/rf33rmBtPKcWtObzarFKPL9W+jnzRP25ovVVyrqS+zyC0MysjSjMTTF37twZK1eu1Lhx4z4J8Nvf/nbjf//7351nzJgxa/bs2TM32WSTD5ctW1YDsP7660fh/E6dOkVtbe1HQ8+HDx++5KGHHtpo6dKlWr01MzOztc+5zszMOpp1Jfe5g9DMrI3ZZJNN6i677LJXr7zyys1WrFihRYsWddp0000/7NKlS9xxxx0bzp8/f/2m1PONb3xjwaGHHrroiCOO2P7DDz9s7bDNzMyazLnOzMw6mrae+9xBaGbWBu27777Ldt5552XXXHPNJ04++eR3p02btsGgQYN2vuGGGzbu16/f8qbWM3bs2Ld23XXXpZ///Of71dXVtWbIZmZmzeJcZ2ZmHU1bzn2eg9DMrI1YunTpM/ntSZMmvVT4/Oyzz84udc6LL774fOHz+eef/1bh8+OPPz6n8PnSSy/1pO1mZtYmONeZmVlHs67kPo8gNDMzMzMzMzMz68DcQWhmZmZmZmZmZtaBuYPQzMzMzMzM2jRJdZKezf2c28zzR0oamNueLGl4I+fUSLpM0nOSZkh6QlK/Bsof1dy4zMzainY3B6GkOmAGIKAO+E5EPCJpS+CyiDi2qgGWIOmRiNin2nGYmZmZmZm1UcsiYmhLTpTUGRgJ3AnMbMapo4EtgSERUS9pK+CDcoUjYgIwoSUxmplVW7vrICSXOCR9BrgQGBER84E21zkI4M5Bs46n77l3DatkfXPHHf5UY2VGjRrVd+LEiT032WST2vykt2ZmZq3Buc7WBkk/Ao4EugGPAN+IiJA0OW3vC9wHHAWMkHQe8IV0+ihJVwG9gK9HxENF1W8BvBER9QARMS/X7meBC4BOwIKIOFjSGGB4RHxHUm/gN8A26ZQzImKKpLFp33bp968i4rJU51eAM4EApkfElxuoZwTw67QvgE9HxOKW3UUza6n2lOva+yvGGwELAST1lfRc+txV0u/TMPFnJB2Y9neXdIuk6ZJulvRYYdi5pEMlTZX0tKRbJfVI+w9OdcyQ9DtJXdL+cZJmprouSvs2k/QXSdPSzz5p/5JCwJLOSkPXp0v6SS72WZKulvS8pPskdUvHdpD091Tf05K2b6CeDSTdlco+J2n0WvhvYGZtxNe+9rUFEyZMeLHacZiZmbUW57p2rVvRK8aFZ5krImKPiBhE1kl4RO6cXhExIiJ+Rjay76yIGBoRL6fjnSNiT+AM4Mcl2rwFODK1d7Gk3QBSp93VwBciYldgVIlzfw1cGhF7kHVIXpM7NgD4DLAn8GNJ60naBfgBcFCq8z8bqedM4NtpcMz+wLLiACSdKulJSU/WLV1UIkQzWxe1Vq5rjyMIu0l6FuhK9o3PQSXKfBsgIgZLGgDcJ2lH4FvAwogYImkQ8CyApE2B84BDIuIDSecA35f0C+Ba4OCIeEHSH4Bvpt/HAAPSt1e9UruXAQ9GxDGSOgE98kFJOhToT5YoBEyQ9Gng1bT/ixFxiqRbyJLDDcAfgXER8RdJXYGaBurpDcyPiMNTez1bepPNbN3zuc99bsmcOXPWr3YcZmZmrcW5rl0r94rxgZLOBroDGwPPA3ekYzc3Uuft6fdTQN/igxExT9JOZM+UBwETJY1Kbf0jIl5J5d4tUfchwEBJhe2NJG2YPt8VESuAFZLeBjZL9d8WEQuK6ixXzxTgEkl/BG7Pj27MxT8eGA/QZYv+0ci9MLN1RGvluvbYQZh/xXhv4A+psy9vP+BygIiYLelfwI5p/6/T/uckTU/l9wIGAlPSH+b1ganATsArEfFCKncdWefjFcBy4BpJd5HNdQHZH/2vpPrrgOKvcQ5NP8+k7R5kHX2vpnaeTfufAvqmxNAnIv6S6lyerrtcPQ8BF0n6OXBniSH0SDoVOBWg00a9iw+bmZmZmZm1CWmAxFVkr/W+ll7f7ZorUna+wGRF+l1HmWfj1JF3N3C3pLfI5jK8n+y13obUAHtHxCoj+9Lz5IrcrkLbKlNnyXqAcelZ8zDgUUmHRMTsRmIyMyurXb9iHBFTgU3JRs7lqUTxxvbfn4ajD42IgRHx9XLlI6KWbPTen8kSyD1NDFnAhbl2doiI/5eOlUsiTa4ndWQOI1vE5cI0X0dx7OMjYnhEDO/U3QMMzczMzMyszSp0Bi5IU0A1NOf8YmDDBo6vRtLuyha7RFINMAT4F9lgkRFKKxpL2rjE6fcB38nV1dgCKxOB4yRtUlRnyXokbR8RMyLi58CTZK8tm5m1WLvuIEyvD3cC/l106B/AianMjmQTvs4BHgaOS/sHAoNT+UeBfSXtkI51T+fNJhvJt0Mq92XgwZScekbE/5LNZ1FIBhOBb6Y6OknaqCiue4Gv5eY37CPpk+WuLyLeB+ZJGpnKd5HUvVw9KbktjYgbgIuA3Ru+g2ZmZmZmZm1C8RyE4yLiPbK5AGcAfwWeaOD8m4CzlM0fv30T2/wkcIeyueynA7Vkcx6+Q/bW1e2SplH6VebTgeFpTviZwGkNNRQRzwM/I3uenAZc0kg9Z6R55aeRzT94dxOvycyspPb4inFhDkLIRtKdFBF1uTkbIBuG/htJM8j+yI+JiBXKVrC6Lr1a/AxZElgUEe8oW5HqRqVFSIDz0ryDXwVuldSZLCH9hmzui7+lIe8CvpfO+U9gvKSvk40C/CbZt08ARMR9knYGpqZ4lwBfSmXL+TLwW0nnAx8CoxqoZwfgl5LqU9lvNumOmpmZmZmZVVFEdCqz/zyy+eKL9x9QtD2FbNqoggNyxxZQeg7CeyjzNlhE3E1Rp1xEXEs2R32hztUWhYyIsUXbg3KfryObtip/vFw93y0Vl5lZS7W7DsIGEsdcYFD6vBwYU6LYcuBLEbE8fas0kWwIORExCdijRL0Tgd2Kdr9B9opxcdm3gKNL7O+R+/xrPl6uPi+fOC7KfX6REguxlKnnZbLRhWZWZU1Zvr7SjjzyyH6PPvrohgsXLuy82WabDTn33HPnf+9731uwtuMwM7OOwbnOzMzau/aU69pdB+Ea6g48IGk9spF/34yIlVWOycysIu64445Xqh2DmZlZa3KuMzOz9q61cp07CHMiYjEwvNpxmJmZmZmZmZmZrS3tepESMzOzNSGprmhC9HObef7ItOhVYXuypFb9IkpS3zSZeqn9y4qu5ystbON8SYesebStJ13vCdWOw8zMzMxsXeARhGZmZuUti4ihjRdbXVq8aiRwJzCzolG13MstvZ68iPhRqf2SOkVEQwtrrU19gROAP1U5DjMzMzOzNs8dhGZmZs0k6UfAkUA34BHgGxERkian7X2B+4CjgBGSzgO+kE4fJekqoBfw9Yh4qKjuHsDfgE8A6wHnRcTfJPUlWy3xYWAf4HXg6IhYJmkY8DtgaTre3OtZQraw1RHAMrIFtZYD04DtIqJeUndgDrAdcDVwZ0TcJmluavtQ4ApJs4HfkM3r+zLwtYhYmO7NY8CB+WuXNIasI7UT2YJcFwPrA18GVgCHRcS7afGwK4He6TpPiYjZkq4F3iebImRz4OyIuA0YB+ws6Vnguoi4tLn3xczMrL0Y3KcnT447vAVnLlrjtmescQ3ASZWoZFU7V77KMlZbU7RdGMv+Famlkt6saG3ZwhQdiTsIzcyqYWzPYZWtb1GDq2e99NJL65144on93nnnnfVqamo46aST3vnhD3/4dkVjaJ+6pQ6mggsj4mbgiog4H0DS9WQda3ekMr0iYkQ61p/UkZa2ATpHxJ6SDgN+DBS/qrscOCYi3pe0KfCopAnpWH/gixFxiqRbyDodbwB+D3w3Ih6U9MsGrmf7ouv5buqg3AB4NCJ+IOkXZJ1vP5U0DRgBPEDWIXpvRHyYrmOVmCNiv3SN03OxnJ+u8YxUrty1DwJ2A7oCLwHnRMRuki4FvgL8ChgPnBYRL0r6FHAVH/+LewtgP2AAMAG4DTgXODMijih1IySdCpwK0Gmj3g3cMjNrsbWc68D5zszM1rJ2lOvcQWhm1gGst956XHzxxfP222+/pQsXLqzZbbfdBh522GHvDxs2bHm1Y2vjyr1ifKCks8lGyW0MPM/HHYQ3N1Ln7en3U2SvwRYTcIGkTwP1QB9gs3TslYgodPA9BfSV1JOsU/LBtP964HNl2i73ivFKslehC/X+R+5aRpN1EB5P1ilXys0AJWK5Drg1V67ctT+QFgpbLGkRH9/LGcCQNKpyH+DWXOdkl9z5f42IemCmpM1ogogYT9bpSJct+kdTzjGzts/5zszM2rvWynXuILSySg9Db/oQ85JDyZs4NLxlw73X7aHblRmi3VrGVjuAdUzbG4y+7bbbfrjtttt+CPCJT3yifvvtt1/26quvru8HpuaT1JWso2x4RLwmaSzZyLeCDxqpYkX6XUfpPHwi2Wu0w9Jovbm5+lfkytWRveIsYE07uD6MiEId+bgmABdK2hgYBkwqc35j11xQ7trz11Wf265P5WqA9xqYPzF/ftv7P6CZrTXOd2Zm1t61Vq7zKsZmZh3MnDlz1p85c2b3ESNGLKl2LOuoQmfdgjSy7dgGyi4GNmxm/T2Bt1Pn4IHAtg0Vjoj3gEWS9ku7Tmxmew3VvQR4nGx+wjsbW4AkIhYBCyUVvvH4MvBgA6c0NY73gVckjQJQZtdGTmvJvTezdsT5zszM2rtK5jp3EJqZdSCLFi2q+fznP7/9uHHjXtt4443rqx3POqCbpGdzP+NSh9zVZAOl/wo80cD5NwFnSXomLbLRFH8Ehkt6kqyzb3YTzvkqcKWkqWSLjJSzfdH1nN6Eum8GvkTjr04XnAT8Ms1FOBQ4v4nnNeZE4OtpXsTnyRZSach0oFbSNEnfq1AMZraOcL4zM7P2rtK5zq8Ym5l1ECtWrNDhhx++/ahRo9496aST3qt2POuCiOhUZv95wHkl9h9QtD0FGJjbdUDu2AJKzEGY9u9dJqRBuXIX5T4/BeRH1I0tUe9csleSVxMRPXKfbyNb5CO/raLyY3Kf+xYdexbYq0QbB+Q+f3TtEXEtcG2p+vLHIuIV4LMl6h1TtN0j/f4QOLi4vJm1f853Zqub8foi+p57V5PKzu16QrPqHtxvm5aEtJpbLqytSD2TDriyIvUsX3hJReppqtH9zlmr7RVc03XiWm1v/09fX7G6TtSfK1bXuqY1cp1HEJqZdQD19fUcf/zx2+64447Lx44d+1a14zEzM2sNzndmZtbetVau8whCM7NqaMLy9ZV0//339/jrX/+6Sf/+/ZcNGDBgIMBPfvKT10ePHt30lYfMzMyaYy3nOnC+MzOztawd5Tp3EFpZzRmG3pjmDlNvSKWGsFdapYbEV0KlhtW31Noajl+JYfjNHVJfySHxa9NnPvOZJek1VDMzs3bL+c7MzNq71sp1fsXYzMzMzMzMzMysA3MHoZmZmZmZmZmZWQfmDkIzMzMzMzMzM7MOzB2EZmZmZmZmHYCkOknP5n7Obeb5IyUNzG1PljS8kXNqJF0m6TlJMyQ9IalfM9vtIunvKebRzTm3GW3MTfHNkDRT0k8ldWmNtpoQy5aSbqtG22bWcXmREjOzKhh83eBhlaxvxkkzGpykdunSpfrUpz41YOXKlaqrq9ORRx658NJLL51fyRjMzMzy1nauA+e7JlgWEUNbcqKkzsBI4E5gZjNOHQ1sCQyJiHpJWwEfNLPd3YD1Whp7MxwYEQsk9QDGp5+TWrnN1UTEfODYtd2umTVfe8p1HkFoZtYBdO3aNR5++OE5c+bMmfn888/PnDhx4kYTJ07coNpxmZmZVZLzXctI+lEa2fecpPGSlPZPlnSBpAeBc4CjgF+mkXzbp9NHSXpc0guS9i9R/RbAGxFRDxAR8yJiYap/SS6GYyVdmz5fK+kSSQ8AVwM3AEML7TYQ7w5ppOE0SU8XYpR0Vio/XdJPGrsfEbEEOA0YKWljSddLOjoX6x8lHSVpjKTbJd0j6UVJv8iV+R9JT0p6Pt9mGql4gaSp6fjuku6V9LKk01KZvpKeS587SboojWycLum7af+4NNJxuqSLGrsmM2s/WivXuYPQzKwDqKmpoWfPnvUAK1euVG1tbeHf0mZmZu2G812juhW9Ylx4XfeKiNgjIgYB3YAjcuf0iogREfEzYAJwVkQMjYiX0/HOEbEncAbw4xJt3gIcmdq7WNJuTYx1R+CQiPgqcDLwUK7dcvH+EbgyInYF9gHekHQo0B/YExgKDJP06cYaj4j3gVfSudcAXwWQ1DPV/b+p6FCyUZKDgdGStk77fxARw4EhwAhJQ3LVvxYRewMPAdeSjRbcCzi/RCinAv2A3SJiCPBHSRsDxwC7pH0/LXUNkk5NnZBP1i1d1Nglm9k6orVynTsIzcw6iNraWgYMGDBws80223XEiBHvH3TQQU1+vcfMzGxd4XzXoGWpk63wc3Paf6CkxyTNAA4Cdsmdc/Pq1azi9vT7KaBv8cGImAfsBPxfoB6YKOngJsR6a0TUlTm2WrySNgT6RMRfUrvLI2IpcGj6eQZ4GhhA1unXFEp1PQjsIOmTwBeBP0dEbSozMSIWRcRyslevt037j5P0dGp3F2Bgrt4J6fcM4LGIWBwR7wDLJfUqiuEQ4DeF9iLiXeB9YDlwjaTPA0tLBR8R4yNieEQM79S9ZxMv2czWBa2R69p9B6HWgYl40/D0ZsVlZtZcnTt3Zvbs2TNfffXV6U8//fQGTzzxRNdqx2RmZlZpznfNI6krcBVwbEQMJnulN3/PGnvoXJF+11FmjvuIWBERd0fEWcAFZHMZAkSuWPF/p5LtNhBvueEzAi7MdYruEBH/r5FrInU49gVeSLuuB04kG0n4+1zRFbnPdUDn9Ox3JnBwGuF3V9H1Fc6pLzq/ntXvoVj1PpE6C/cE/kx2L+9p7HrMrH1pjVzX7jsIWf1bsnFNPVEfT8Q7sLGyRfIT8Q4mG/79XrnCETGhOXGZma2JTTfdtG6//fZbfMcdd/irZDMza7ec75qs8FBZWJyjocUxFgMbNqfyNMfelulzDdkrt/9Kh9+StHPaf8yaxJteCZ4naWRqq4uk7sC9wNdSWST1SSMBG4q5B1kn5F8L8yWSvQp8Rmrr+UZi3Iisg3ORpM2AzzXx2kq5DzgtPZuS5kTsAfSMiP9NMbX24i1m1kZVMtd1hA7CkhqY2La1J+L9bJowd5qkiWnfGElXpM+9Jf05xfaEpH3T/rGSfpfi+6ek03PX8pU0Oe00Sdc3Us+I3GjKZ9I3Y2bWzs2fP7/zggULOgEsWbJEkydP3mjnnXdeXu24zMzMKsn5rlHFcxCOi4j3yEbhzQD+CjzRwPk3AWel54jtGyiX90ngDmWLbkwHaoEr0rFzyVZFngS80ZTKGon3y8DpkqYDjwCbR8R9wJ+AqemV5Nso38n5QIrzceBV4Bu5dt8CZrHq6MFyMU4je7X4eeB3wJSmXFsZ16RYpkuaBpyQ4r8zXeeDwPfWoH4zW8e0Vq4rOQS8nekm6dnc9oVpro0rIuJ8gNSpdgRwRyrTKyJGpGP9gTsj4ra0DWkiXkmHkU3Ee0hRm7cAD6fOw4nADRHxjKTeZMns0xHxSppcttivgUsj4mFJ25B947VzOjYAOJAsIcyR9D9kk/f+ANg3Ihbk6ixXz5nAtyNiSvrmaZX/EUk6lWwiXDpt1LvBG2tmLdeU5esr6bXXXltvzJgx/erq6ogIHX300e9+8Ytf9GzVZmbWatZ2rgPnu8ZERKcy+88Dziux/4Ci7Sms+nbVAbljCyg9B+E9lHkFNj1j3VZi/5ii7cnA5CbE+yLZnITF+39N9nxUVkSsFnteGo3YH7gxd861ZCMLC9tH5D6vcg2l2ilxfuHYAmBQ2lcLfD/95O3ZULxmtna0p1zXEToIl0VEqSHXB0o6G+gObEz27U6hg3CNJ+KVtBNZcjqIbCLeUamtf0TEK6ncuyXqPgQYmFuBZqPcKL+7ImIFsELS28Bmqf7bUkLO11muninAJZL+CNyeJg3Oxz5S6D41AAAgAElEQVQeGA/QZYv+q8x1YWbrrk996lPLZs2aNbPacZiZmbUm5ztrDZIOIRsJeElEuMPZzKqqtXJdR+ggXE1uYtvhEfGapLG0wkS8wN3A3ZLeIpvL8H6KJpgtoQbYOyKWFcWcbzff9mqT1jZUDzBO0l3AYcCjkg6JiNmNxGRmZtZuDe7TkyfHHV7tMNZB7esZeUa1A2iKk1q/iZ0bLwLAd37bqmGYtSkR8Xdgm2rHYWbWmjrqHITVmoh3KjCisKJxmVeM7wO+k6ursQlnJwLHSdqkqM6S9UjaPiJmRMTPgSfJXls2MzMzMzMzM7MOqiN0ELaZiXgj4h2y+f1uTxPMlnqV+XRgeFp0ZCZwWkMNpRW0fgY8mOq8pJF6zkgLs0wDlpGNcjQzMzMzMzMzsw6q3b9i3AYn4r2bok65/OS0qc7RJc4bW7Q9KPf5OuC6ouPl6vluqbjMzMzMzMzMzKxjavcdhGZmbdGsATsPq2R9O8+e1aTVs2praxk8ePDAzTfffOUDDzzwUiVjMDMzy3OuM2s7mjffbvPmmK3YHK4Vmme1qXOpNm61BbHbpbHsv9ZbrJQ3K1ZTaWq8SLvKdR3hFWMzM0t++tOfbrbDDjsUL15kZmbWbjjXmZlZe9cauc4dhGZmHcTLL7+83r333tvzlFNOWVDtWMzMzFqDc52ZmbV3rZXr3EFoZtZBfPvb3976F7/4xbyaGv/pNzOz9sm5zszM2rvWynXOnGZmHcCNN97Yc9NNN63df//9l1Y7FjMzs9bgXGdmZu1da+Y6L1JiZtYBPPzwwz3uv//+Xn369Om5YsWKmg8++KDm6KOP7ve3v/3tlWrHZmZmVgnOdWZm1t61Zq5zB6GV1byVrhrTvJWwGlKxVbIqrUKrblVC5Vbuaql1Z8Wv5q/aNbYJZZqy3tXadeWVV75+5ZVXvg5w5513bnjxxRdv5gcmMzNrT5zrzMqb8foi+p57V1Xantv1hKq025jB/bapdgiNuuXC2lZvY9IBV1asruULL1mj80f3O6dCkXzsmq4TV9ne/9PXly17ov5c8fYrrTVznTsIzcyqoKnL15tZ62vth6a28GC0th6C1saDTEtU8uHHms65zszM2rv2lOs8B6GZWQdzxBFHLH7ggQdeqnYcZmZmrcW5zszM2rtK5zp3EJqZmZmZmZmZmXVg7iA0MzMzMzMzMzPrwNxBaGZmZmZmZmZm1oF5kRIrq5orXVVDW5hEvqmqteJWW518Hlo+AX1jK201ZSWtwspYDa2IZWZmZmZmZtZWuYPQzKwKrjxt0rBK1vft3xzU6OpZffr0GbzBBhvU1dTU0Llz53juuedmVTIGMzOzvGrkOnC+a4ykOmBGbtdNETGuGeePBF6IiJlpezJwZkQ82cA5NcCvgIOAAJYDx0XEK82M/QxgfEQsbc55Tay7cF/WA2qB64BfRUR9pdtqQizDga9ExOlru20za572lOvcQWhm1oE8+OCDL2yxxRZtdyiomZlZBTjfNWhZRAxtyYmSOgMjgTuBmc04dTSwJTAkIuolbQV80IIQzgBuACreQUjuvkj6JPAnoCfw41Zoq0Gps7Vsh6uZGVQ+13kOQjMzMzMzsw5O0o8kPSHpOUnjJSntnyzpAkkPAucARwG/lPSspO3T6aMkPS7pBUn7l6h+C+CNwmi8iJgXEQslfV3SpbkYTpF0iaQNJN0laVqKZ7Sk08k6GR+Q9EAqf6ikqZKelnSrpB5p/9wU81RJT0raXdK9kl6WdFpj9yIi3gZOBb6jzEOSPupUlTRF0hBJYyX9Lt2jf6YYC2X+KukpSc9LOjW3f4mkn6djf5e0Z+78o1KZAyTdmT73kPR7STMkTZf0BUmdJF2b7s0MSd9r/L+wmVnD3EFoZtaBHHzwwf132WWXnS+66KJNqx2LmZlZa3G+a1C31LlX+Bmd9l8REXtExCCgG3BE7pxeETEiIn4GTADOioihEfFyOt45IvYkG+FXasTdLcCRqb2LJe2W9t8EHCVpvbT9VeD3wGeB+RGxa4rnnoi4DJgPHBgRB0raFDgPOCQidicbcff9XJuvRcTewEPAtcCxwF7A+U25SRHxT7Ln5U8C1wBjACTtCHSJiOmp6ADgM8CewI9z1/K1iBgGDAdOl7RJ2r8BMDkdWwz8FPgP4Jgysf0QWBQRgyNiCDAJGAr0iYhBETE43TMz62Aqnev8irGZWQcxZcqU2X379v3w9ddf73zQQQftuMsuuyz/3Oc+t6TacZmZmVWS812jyr1ifKCks4HuwMbA88Ad6djNjdR5e/r9FNC3+GBEzJO0E9kchAcBEyWNioiJkiYBR0iaBawXETMkrQAukvRz4M6IeKhEm3sBA4EpabDj+sDU3PEJ6fcMoEdELAYWS1ouqVdEvNfINQEo/b4V+KGks4CvkXU4FtwVESuAFZLeBjYD5pF1Ch6TymwN9Af+DawE7snFtiIiPpQ0gxL3DjgEOL6wkUZe/hPYTtLlwF3AfSWDz0YungrQaaPeTbhcM1tXtEau8whCM7MOom/fvh8C9OnTp/bwww9/b+rUqRtUOyYzM7NKc75rPkldgauAY9OItKuBrrkijc0XuCL9rqPMIJSIWBERd0fEWcAFZHMZwsej8wqjB4mIF4BhZB1oF0r6UamwgfvTSMahETEwIr5eIqb63OfCdqMDZSRtl67n7bQoyv3A0cBxZPMTFrdDKt9Z0gFkHXt7R8SuwDN8fD8/jIgoji29fl0qLpEt7PKRiFgI7ApMBr5Ndg9XExHjI2J4RAzv1L1nY5dsZuuQ1sh17iA0M+sA3n///ZqFCxfWFD4/8MADGw0ZMmRZteMyMzOrJOe7Fit0Xi1I8/gd20DZxcCGzak8zQG4ZfpcAwwB/gUQEY+RjbA7AbgxldkSWBoRNwAXAbuXaPtRYF9JO6RzuqfXf9eYpN7Ab8heuy50zl0DXAY8ERHvNlJFT2BhRCyVNIBstGNL3Qd8JxfbJ9Lr1TUR8WeyV5B3L3eymbU/rZXr/IqxmVkVNHX5+kqZN29e52OOOWYHgLq6On3hC1/497HHHvv+2ozBzMw6lrWd68D5rom6SXo2t31PRJwr6WqyEXtzgScaOP8m4Oq0IEdDHYl5n0zndEnbjwNX5I7fAgxNI+MABpMthFIPfAh8M+0fD9wt6Y00D+EY4MZcvecBLzQxpmKF+7IeUAtcD1xSOBgRT0l6n6bN93cPcJqk6cAcss7MlvopcKWk58hGKP4EeBn4fepsBfi/a1C/ma2B9pTr1qiDUFIdWRIpuCkixjXj/JHACxExM21PBs5My7qXO6cG+BXZ3BUBLAeOi4hXmhn7GcD4NFy8oiT9gOwbsDqyYePfSN+MlSo7HPhKRJxe6riZWSUMHDhw5Zw5c2ZWOw4zM7PW5HzXuIjoVGb/eWQdbMX7DyjankI291/BAbljCyg9B+E9fDzvXin7AR+tZhwR9wL3lqjncuDy3PYkYI8S5frmPl9Lbs7A/LGic0rel4I0qrGG3Hx/ETG2qI5Buc3PlWmnRwPn90i/J5O9PkxELAFOKlGVRw2adVCtlevWdARhuQluGyWpM9m8E3cCzbmw0WTL2w+JiHpJW9H4nBilnAHcAFS0g1DS3mQrfu0eESvS8O/1y5VPnaFlO0TNzMzMzMzaI0m9yEYTTouIidWOpxxJXwF+Bnw/zRVoZtbutMochJJ+JOkJSc9JGq+0rJSkyZIukPQgcA5wFNnQ8WclbZ9OHyXpcUkvSNq/RPVbAG8U/jBHxLy0ktPXJX30rZOkUyRdImkDSXdJmpbiGZ2Gw28JPCDpgVT+UElTJT0t6dY09waS5qaYp0p6Ms2fca+klyWdVia+BWklKyJiQUTMT3XtIemRFMvjkjaUdICkO9PxDST9Lt27ZyQdnfaPkXS7pHskvSjpF7nr/GyKeZqkiY3Us0tq91lJ0yX1b8l/XzMzMzMzszUVEe9FxI4RMarasTQkIv4QEVtHxK3VjsXMrLWsaQdht9TZVPgZnfZfERF7pCHW3chG1BX0iogREfEzsqXnz0qrTr2cjneOiD3JRvj9uESbtwBHpvYulrRb2n8TcJSk9dJ2YRWszwLzI2LXFM89EXEZMB84MM1dsSnZcPpDImJ3shF938+1+VpE7A08RDY8/ViyiWbPLxHffcDWqYPzKkkjACStD9wM/GdayeoQoHgSyR8AkyJiD+BAss7Twko0Q8lGTw4GRkvaOk2eezXwhVTnqEbqOQ34dRr1ORyYVxy8pFNTR+iTdUsXlbg8MzMzM7OS6uvr61XtIBqS4vMIMDMzsyKt9YrxgZLOBroDGwPPA3ekYzc3Uuft6fdTlJ6/Yp6kncjmIDwImChpVERMlDQJOELSLGC9iJghaQVwkaSfA3dGxEMl2tyLbB6NKWmw4/rA1NzxCen3DKBHRCwGFktaLqlXRLyXi2+JpGHA/mSdczdLOjddzxsR8UQq9z5Aaq/gULJOzjPTdldgm/R5YkQsSufMBLYFPgH8ozD/Ym41rXL1TAV+kF7Lvj0iXixxf8eTTf5Lly36R/FxMzMzM7MynnvnnXcG9u7de1FNTU2b+3dkfX293nnnnZ7Ac9WOxczMrK2p+CrGkroCVwHDI+I1SWPJOqgKGpsvcEX6XVcuvvT67t1kK1i9RTaX4USypef/C5hNWl0qIl5IHXaHARdKui8iikf+Cbg/Ir7YSEz1uc+F7dVijIg6skllJ0uaQTap7NNki6o0RGSjAeesslP6VFG7hXujMnWWrAeYJekx4HDgXkknp4l9zWwtu3j0EcMqWd//ufnORlfPWrBgQacvfelL286ZM6ebJMaPHz/3kEMOackcrm2S1nDhrFw9pwFLI+IPFQuuwtKcTSdExFVNKLskPyF6bn9F7leq65GI2Kcl5zajjaOAgS2N0cxaX21t7clvvvnmNW+++eYgWmkqozVUDzxXW1t7crUDMTOz9qEaz3XQOs92Fe8g5OPOwAVpHr9jgdvKlF0MbNicyiXtDrwZEfOVrWg8BJgOEBGPSdqabEWnIan8lsC7EXGDpCXAmKK2F5AtO3+lpB0i4iVJ3YGtIuKF5sSW2tsJqM+NzhsK/Ius03JLSXtExBOSNmT1V4zvBb4r6bsREZJ2i4hnGmhuaoq7X0S8ImnjNIqwZD2StgP+GRGXpc9DAHcQmnUQp5566taHHnro+/fcc88/ly9friVLlrTFh7c10eKFs/Ii4jel9kvqHBG1a1p/hfQCvkX2hVxLVeR+AayFzsHOETGBj0f0m1kbNGzYsLfJ5hg3szZmcJ+ePDnu8Cq13janrprReJHqK7V+dYXtXNHaDqpobZUwluKlLcaWLftm0XZbnjOjNZ7t1rSDsJukZ3Pb90TEuZKuJvv/21zgiQbOvwm4Oi0acmwT2/xkOqdL2n4cuCJ3/BZgaEQsTNuDyebgqwc+BL6Z9o8nG4H4RpqHcAxwY67e84BmdxACPYDL0+iOWuAl4NSIWJnmaLxcUjeyzsFDis79b+BXwHRl7x7PZdX5G1cREe9IOhW4PXWWvg38RwP1jAa+JOlDsv/tl5pD0czaoXfffbfmscce2/C2226bC9C1a9fo2rVrXZXDWiskzQWuA44E1iObr/UF4J9k+eK9VO4lYF+yPLEkIi6SNBl4JO2fIOk24HdAb+Ad4KsR8aqka4H3yeZ33Rw4OyJuk3QA8BPgLbIvjG4ny4//STZH78iIeDnNKfsbPp5W4oyImJJG4W8DbJd+/yrNozsO2D7l4PtTG38jm3piPeC8iPhbpe5XRMxOMf4J2IQst38WGBYRCwqjFNP1jiX78m0Q2fQaX0pfVg0DLiHLkwuAMRHxhrJFyq5M93QpcEpq71rgXWA34Ok0In94RHyngftdQ/ZvghHAK2QjmH4XEeW+qDQzMzMzW6e01rPdGnUQRkSnMvvPI+tgK95/QNH2FLK5/woOyB1bQOk5CO8B7mkgrP2Aj1Yzjoh7yUbUFddzOXB5bnsSsEeJcn1zn68lW6RktWO5fU8BJUdSpPkH9yraPTn9EBHLgG+UOK+43SNyn+8me906X75cPRcCF5aKzczat9mzZ3fZeOONa0eNGtV35syZ3YcMGfLB1Vdf/dpGG23UniZqL/7S6sKIKMx7uyAidpf0LeDMiDhZ0t+AY4Dfp6kc5kbEW0Vzw0JaXAtA0h3AHyLiOklfAy4jm+YCslXs9wMGkI10K3RK7Ur25ey7ZJ2S10TEnpL+E/gu2aJcvwYujYiHJW1DlrcKX+gOIJvTdkNgjqT/Ac4FBhVGAErqDBwTEe+nhbcelTQhIhqa2qLJ9ws4mWzhsEkRcaGkzwKnlql3N2AXssXApgD7puktLgeOTl9ujQZ+BnyN7Au70yLixfTf4So+/vp5R7IFxOrSF3l5pe7358n+7TCY7AvFWWQduqtJX7CdCtBpo97l75KZmZmZWRvSWs927eb1Mkm9JL1A9srUxGrHY2bWltTW1mrWrFndv/3tb78za9asmd27d6//4Q9/uHm146qwZRExNPeTXxSr1AJYN5ONrAY4nvKLaOX37002ig7gerIOqoK/RkR9RMwENsvtfyIi3kjz575Mtto9ZCMJC7EcAlyROuwmABulqSgA7oqIFemLs7eL6i4QcIGk6cDfgT5lyuU1937tRzbyv/Bl3UJKezwi5kVEPfBsOn8nshGF96drPA/YKk1Fsg9wa9r/W7KOv4Jb07y+pZS63/ulc+oj4k3ggXIXHxHjI2J4RAzv1L1nuWJmZmZmZm1Kaz3btcYchFWRXhHbsdpxmJm1RX379l252WabrTzooIM+ABg9evTCcePGtbcOwoaUWgBrKrBDenV2JPDTMuc2NNlvfoRefjEpldmfX+wqv9BVDbB3GgH+cSXZaMZSi1QVO5HsFd1hEfFhek24a4lyTVXqfjV1GpZyi2o9HxF75wtK2gh4r4G5EBu696Xud1ueKsbMzMzMbI211rNduxlBaGZm5W2zzTa1m2+++cpp06Z1Abjvvvs22mmnnZZXO65qSq/f/oVsXrxZEfHvJpz2CNloQ8g65R6uUDj3Ad8pbEhqbPGQ4kW+egJvp87BA4FtKxRX3sPAcSm+Q8nmO2yqOUBvSXun89eTtEtEvA+8ImlU2i9Ju65hjF+QVCNpM3JTl5iZmZmZtQet9WzXbkYQmpmtS5q6fH0lXX755a+eeOKJ261cuVLbbLPNihtvvHHu2o6hlZVcOKuRc24mW3BjTBPbOB34naSzSIuUNDvK8vVemV4R7gz8AzitXOGI+LekKZKeI5uH9ufAHZKeJHutd3YT2mzu/foJ2WJeo4EHgTfIOioblRbqOha4TFJPsmv8FfA8WUfr/0g6j2xRlJuAaU2pt4Q/AwcDz5EtRPMYbXXpRDMzs7VoxuuL6HvuXdUOY62Y2/WEaofQqMH9tmm80Fp0y4W1a62tSQdc2aLzli+85KPPo/ud02j5a7o2b+a5/T99/SrbJ+rPTTqvGs910DrPdu4gNDPrIPbZZ59lzz333Kxqx9FaGlg4q2/u85OsuiDWkxS9lhoRY3OfDyg6NpePF9DI7x9TtN0j/Z5MWoiquL78sTS/4GiK5GNJ24Nyn4v/9bs3JRRiKbG/ufdrEfCZiKhNIwEPTPMqNnS938l9fhb4dIn2XiFbEbl4/5ii7WtJC3Y1cL/rJZ0ZEUskbQI8TjbXo5mZmZlZu9Eaz3buIDQzM7Om2Aa4RVINsBI4pcrxlHOnpF7A+sB/p8VKzMzMzMysAe4gtLIG9+nJk+MOr3YYa9G68xZa1YbDnFSthhu3c4vPXG0wWLONZf+PPmW8ToK1PxHxIrBbteNoTPGoTzMzMzMza5wXKTEzMzMzMzMzM+vA3EFoZmZmZmZmZmbWgfkVYzOzKph37kPDKlnfVuP2b3D1rGnTpnUZPXr09h+1P29el7PPPvv1H/3oR29XMg4zMzMzM7OOYm0/10HrPdu5g9DMrAPYddddV8yePXsmQG1tLZtvvvmuxx9//HvVjsvMzMzaBkl1rDrV9U0RMa4Z548EXoiImWl7MnBmRDzZwDk1wK/IJoUOYDlwXFrhvjmxnwGMj4ilzTmviXX/ADgBqAPqgW9ExGNlyg4HvhIRp1c6DjOzgtZ6tnMHoZlZBzNhwoSNttlmmxU77rjjymrHYmZmZm3GsogY2pITJXUGRgJ3AjObcepoYEtgSETUS9oK+KAFIZwB3ABUtINQ0t7AEcDuEbFC0qbA+uXKp87Qsh2iZmaVVslnO3cQWlkzXl9E33Pvqlh9c7ueULG6WtvgfttUO4SSbrmwttohfGTSAVeutbaWL7ykReeN7ndOs8pf03Vik8vu/+nrmxtOm3HjjTdufOyxx/672nGYmZlZ2yfpR8CRQDfgEbIRdJFGCD4C7AvcBxwFjJB0HvCFdPooSVcBvYCvR8RDRdVvAbwREfUAETEvtfl1YFBEfC9tnwLsDPwQuAXYCugE/DewGVkn4wOSFkTEgZIOBX4CdAFeBr4aEUskzQX+BBwIrAecClwI7AD8MiJ+UyK+BRGxIsW3IHdf9gB+DWwArAAOBoaRjZo8QtIGwOXAYLLn7rER8TdJY9K96g5sD/wlIs5OdX4WuCBd24KIOLiBenYBfk/WYVkDfCEiXiz139DM2q9KPtt5kRIzsw5k+fLl+vvf/97zy1/+8sJqx2JmZmZtSjdJz+Z+Rqf9V0TEHhExiKyT8IjcOb0iYkRE/AyYAJwVEUMj4uV0vHNE7Ek2wu/HJdq8BTgytXexpN3S/puAoyStl7a/StYZ9llgfkTsmuK5JyIuA+YDB6bOwU2B84BDImJ3shF938+1+VpE7A08BFwLHAvsBZxfIr77gK0lvSDpKkkjACStD9wM/GdE7AocAiwrOvcHwKSI2IOsQ/KXqbMPYCjZ6MnBwGhJW0vqDVxN1tG3KzCqkXpOA36dRn0OB+aViN/M2rFKP9t5BKGZWQdy22239Rw4cODSrbfeuu0MRzUzM7O2oNwrxgdKOptsxNvGwPPAHenYzY3UeXv6/RTQt/hgRMyTtBPZHIQHARMljYqIiZImAUdImgWsFxEzJK0ALpL0c+DOEiMSIevsGwhMkQTZCLupueMT0u8ZQI+IWAwslrRcUq+I+GgerzTqcBiwP1nn3M2Szk3X80ZEPJHKvQ+Q2is4lKyT88y03RUovKY0MSIWpXNmAtsCnwD+UZh/MSLebaSeqcAP0mvZt5caPSjpVLJRknTaqHeJW2Vm67JKP9u5g9DMrAO56aabNj7uuOPebbykmZmZdXSSugJXAcMj4jVJY8k6qAoamy9wRfpdR5lnz/T67t3A3ZLeIpvLcCJwDfBfwGyy0YNExAupw+4w4EJJ90VE8cg/AfdHxBcbiak+97mwvVqMEVEHTAYmS5oBnAQ8TbaoSkNENhpwzio7pU8VtVu4NypTZ8l6gFmSHgMOB+6VdHJETCqKfTwwHqDLFv0bi9fM1jGVfrZzB6GZWRU0Zfn6Slu8eHHNww8/vNF11133r7XdtpmZma2TCp2BCyT1IHsd97YyZRcDGzanckm7A29GxPy0ovEQYDpARDwmaWtg97QfSVsC70bEDZKWAGOK2l4APApcKWmHiHhJUndgq4h4oTmxpfZ2Aupzo/OGAv8i67TcUtIeEfGEpA1Z/RXje4HvSvpumrNxt4h4poHmpqa4+0XEK5I2TqMIS9YjaTvgnxFxWfo8BJjUQP1m1gqq8VwHrfNs5w5CM7MOYsMNN6x/7733nq12HGZmZtYmdZOU/3fCPRFxrqSryV7HnQs80cD5NwFXSzqdrCOxKT6ZzumSth8HrsgdvwUYGhGF+bUGk83BVw98CHwz7R9PNgLxjTQP4Rjgxly95wHN7iAEegCXS+oF1AIvAadGxMo0R+PlkrqRdQ4eUnTufwO/AqYre/d4LqvO37iKiHgnvRJ8e+osfRv4jwbqGQ18SdKHwJuUnkPRzNqp1ni2cwehmZmZmZlZBxcRncrsP4+sg614/wFF21PI5v4rOCB3bAGl5yC8B7ingbD2Ay7Nlb+XbERdcT2Xk630W9ieBOxRolzf3OdryRYpWe1Ybt9TwD6lAkvzD+5VtHty+iEilgHfKHFecbtH5D7fTfa6db58uXouJFuB2cysIryKsZmZmZmZmbUZknpJeoFs4ZSJ1Y7H7P+zd+fhVpf1/v+fL8AYQiGMOEpHIMKcQBLwZIoMWVmOlB5KSrFS6zhllya/6qtkqZQlpWKGnELJEudUjkMHFCdQBoENmJqCp0wUC8kBENjv3x+fe8mHxVp77ZENe78e17Wv/Vn3577f931/lhfLde97MGsNPIPQzMzMzMzMdhjpJOG9m7sdZmatSb0HCCVtJtuLouDmiJhQh/LHA89FxPL0+mHg/IiYX9821aLO3sC9EXFAifRngPzJUFdGxI31qOMSsuPp/7feDW1iqb+fjIjfN3NTzMzMml3/nl2YP+GoJqxhbRPGrp2qylkaxynbq6K62be5G9ACnfXr5m6BmZmZNaaGzCBcFxED61NQUjuy4+vvBZY3oA2N6YX69icvIi4qlS6pbURsbmj8RtIbOAnwAKFZMxk/fvygRo5X8fSsH/7whx+aNm1ad0nss88+70yfPn1lp06dojHbYWZmZmZm1lo0x/c6aJrvdo2+B6GkiyTNk7RU0uR00hKSHpZ0maTZwIXAsWQnUC2S1DcVP1HSU5KekzS0ROzOkmZKWiipStJxKb23pGckXS9pmaQH02lSSBokabGkOcCZ9ejPW5IuTTHmSuohqYuklel0KSR1kvRXSbtImirphJS+Mj2Px1LfBqYYSyTdKekDuWfzk+K+Sxor6S5J90haIeksSd+R9HSK0y3l6yvpfkkLJD0qaZ+UPlXSVZKekPRioV3ABGBoevbn1fWZmNnOZ8WKFbtMnjy5x6JFi5Y///zzyzZv3koavKAAACAASURBVKwpU6Z0a+52mZmZmZmZWe011Xe7hswg7Cgpf6Ty5RExHbgmIi4BkDSN7Aj2e1KerhExLN3rR7bc97b0GqBdRBws6fPAxWx7VPx6YFRE/EvSB4G5ku5O9/oBX46I0yTdAnwR+B3wW+DsiJgt6Yoa+tO3qD9nR8SjwPuBuRHxfUk/BU6LiB9LWgwMAx4CjgEeiIiNqR9btTkiDkt9XJJryyWpj99O+cr1/QDg40AH4C/AhRHxcUkTgZPJjryfDHwzIp6X9B/AtcDIVH4PstO/9gHuBm4DxpEt537vxKwCSacDpwO03a17DY/LzHY2mzdv1ttvv92mffv2m9etW9fmwx/+8MbmbpOZmZmZNb2m305jR9L8W3tUst22/qit7bhFSP23/RhZOUvOeLaZc1axRN4qYJvRnR1IU3y3a4olxiMkfRfoBHQDlrFlgHB6hZh3pN8LyJbBFhNwmaTDgWqgJ9Aj3VsREYUBvgVAb0ldyAYlZ6f0acDnytRdbonxu2RLoQtxP53ry2iyAcIvkQ3KlTIdoERbbgBuzeUr1/eHIuJN4E1Ja9nyLKuAAZI6A58Ebs0NTrbPlb8rIqqB5ZJ6UEFETCYbcKT9Hv289NCshejTp8/GM888c1WfPn0GtG/fvnro0KH/+sIXvvCv5m6XmZmZmZmZ1V5Tfbdr1CXGkjqQDZSdEBH9gevJZr4VvF0hxIb0ezOlBy/HAN2BQWkw79Vc/A25fIXyAho6yLUxIgox8u26G/hcWuY7CJhVpnylPheU63u+X9W519UpXxvgjYgYmPvZt0z5HXkA3Mya0OrVq9vOmDGj61/+8peqVatWLXnnnXfaXHvttV5ibGZmZmZmthNpqu92jb0HYWGw7vU0s+2EGvK+Cexax/hdgNfSUt4RQK+aMkfEG8BaSYelpDF1rK+m2G8BTwG/JFsqXeMBJBGxFliT21vxq8DsGorUth3/AlZIOhFAmQMrFKvPszezndg999yz21577bVhzz333NS+ffs4/vjj33jiiSc6N3e7zMzMzMzMrPaa6rtdQwYIO6ZDLgo/E9KA3PVky1/vAubVUP5m4IJ04EbfGvLl3QQMljSfbLDvz7UocyowKR1Ssq6GfH2L+nNOLWJPB75C5aXTBaeQHcyyBBgIXFLLcpWMAb6e9kVcBhxXIf8SYFM6eMWHlJi1Ar1793534cKFnd9888021dXVzJo1a9d99913fXO3y8zMzMzMzGqvqb7b1XsPwohoWyb9B8APSqQPL3r9OLBfLml47t7rlNiDMKUfUqZJB+Ty/Sx3vQDIz6gbXyLuSqBjqaAR0Tl3fRvZIR/51yrKPzZ33bvo3iLgEyXqGJ67fq/vETEVmFoqXv5eRKwAjiwRd2zR687p90bgU8X5zWz7qe3x9Y1l5MiRbx9zzDFrBgwYsG+7du3Yf//93/nOd76zenu2wczMzMzMrCXZ3t/roOm+2zXkkBIzM9uJTJw48e8TJ078e3O3w8zMzMy2r6qX19J73IwGx1nZ4aR6levfZ696lbvl8k31Kjdr+KR6lStn/ZorGzVe3ug+FzZZ7LwpHWZul3qGHj5tu9RTW2N0e3M3oUk0xXe7xt6D0MzMzMzMzMzMzHYinkFoZmZmrVpjzaqoq/rOwmgM9Z3J0dzqO5NkR9PYM1vMzMzMGsozCM3MzMzMzMzMzFoxDxCamZmZmZmZmZm1Yl5ibGbWDGbO6juoMeN9auQLFU/P+tGPfvShG2+8sXtEcPLJJ6++6KKLXmvMNpiZmZmZmbUmzfG9Dprmu50HCK2s/j27MH/CUY0YcW0jxmpaVc3dgHJOae4GbLHvdq1t5HapZTxD65S7PDWwJY1v3rx5HW688cbuCxcufKZDhw7Vw4YN23vUqFFr+/fvv6G522ZmZmZmZma101Tf7bzE2MysFaiqqup40EEHvbXrrrtW77LLLhx66KFvTp8+vWtzt8vMzKylkLRZ0qLcz7g6lj9e0n651w9LGtz4Ld2qzt6SltZw/zxJ6yV1yaUNlPT5pmxXDe0ZK+maBsa4RNIRtczbRtJVkpZKqpI0T1KfGvIfW9f33cysrprqu50HCM3MWoGBAweue/LJJ3ddtWpV2zfffLPNn/70py5//etf39fc7TIzM2tB1kXEwNzPhNoWlNQOOB7Yr1Le7ezLwDxgVC5tINAsA4QNJaltRFwUEf9byyKjgT2BARHRn+w5vFEuc0TcXZf33cysPprqu50HCM3MWoGDDjpo/bnnnrtq5MiRe48YMaLffvvt9067dt5lwszMrKlJuijNPFsqabIkpfSHJV0maTZwIXAscEWafdg3FT9R0lOSnpO0zV4okjpLmilpYZrhdlxK7y3pGUnXS1om6UFJHdO9QZIWS5oDnFlDu/sCnYEfkA0UIul9wCXA6NTO0ZLGS7oh1bFS0hck/TS1535Ju6Syn5L0dEr/jaT2KX2CpOWSlkj6WUqbKuk6SY+mvh+da9qeKe7zkn6aa+9nJM1Jz+JWSZ1T+sr0HjyWnudUSSeke0MkPZGex1OSdi16DHsAr0RENUBE/C0i1qSyR6a6FkuamdLem+Eoqbuk29N7P0/SoSl9fOr/w5JelHROrg8np+ewWNK0CnGG5WarPl2i7WbWQjXVdzsPEJqZtRLnnXfe68uXL39m/vz5z3br1m1zv3791jd3m8zMzFqQjtp6ifHolH5NRAyJiAOAjkB+sKtrRAyLiEuBu4EL0uzDF9L9dhFxMPBt4OISda4HRkXEQcAI4OeFAUigHzApIvYnm/X2xZT+W+CciDikQn++DPwBeBT4mKQPRcS7wEXA9NTO6SlvX+Ao4Djgd8BDacbdOuAoSR2AqcDolN4O+JakbmSz8vaPiAHAj3P19waGpbjXpRiQzWAcDfQnG6j8d0kfJBvIPCI9i/nAd/LPKSIOi4ibCwlpsHM6cG5EHAgckdqbdwtwTHo/fy7p46lsd+B64Iup7Iklnt8vgYkRMYTs2U/J3dsH+CxwMHCxpF0k7Q98HxiZYp5bIc75wJkRMRAYWqLtZtaCNcV3O08fMTNrJV5++eV2PXv23PT888+/b8aMGV2feuqpPzd3m8zMzFqQdWmwptgISd8FOgHdgGXAPene9BL58+5IvxeQDZgVE3CZpMOBaqAn0CPdWxERi/Llle0l2DUiZqf0acDnytT9JbLBx2pJd5ANgk0qk/e+iNgoqQpoC9yf0qtSuz+W2vNcSr+BbPbiNWSDnFMkzQDuzcW8Jc3ce17Si2SDagAzI2ItgKTlQC+gK9ny7MfT+Oj7gDm5WKWe88fIZgfOA4iIfxVniIi/SfoY2Yl5I4GZkk4key8fiYgVKd8/S8Q/Athvy3gtu+Vm+c2IiA3ABkmvkb1nI4HbIuL1opjl4jwOXCnpJuCOiPhbcQMknQ6cDtB2t+4lmmhmO6um+G7nAUIrq+rltfQeN6NWeVd2OKnO8fv32avOZW65fFOd8s8aXu7/YRrX+jVXNknc0X0ubJK4UzrMbJK49TH08GnN3YRmUdvj6xvTscce2/eNN95o165du/jFL37xf927d9+8vdtgZmbWmqRZb9cCgyPir5LGAx1yWd6uEKJwIuVmSn93GwN0BwalAbqVufj50yw3k81eFBC1aPcAshmIf8oNuL1I+QHCDQBpMHFjRBTqqE7tVqlCEbFJ0sHAp8gGJM8iGyijRDsLr4v7VYj/p4j4cpn2lXrOtXoWaSDvPuA+Sa+S7RX5p1qUbQMcEhFbzexLz7NcH0rFLBkHmJAGVT8PzJV0RERsNUAQEZOByQDt9+hXsa9mVnfN8b0Omua7nQcIzcxaiQULFjzb3G0wMzNrZQqDda+nPfFOAG4rk/dNoK77yHUBXkuDgyPIZtOVFRFvSFor6bCIeIxsgLGULwPjI+LyQoKkFZJ61bOdfyabwfjRiPgL8FVgdnomnSLifyTNBf6SK3OipBuAPsBHgGeBj5eJPxeYVIgvqRPw4dyMxXJt2lPSkIiYl2blrYuI92YkSDoIWBURf5fUBhgALCGbnThJUp+IWCGpW4lZhA+SDXhekWINzM3oLGUmcKekiRHxj1zMknEk9Y2IKqBK0iFkMyy9OsSslWiK73beg9DMzMzMzKzhivcgnBARb5DtVVcF3EV2InA5NwMXpAMn+taQL+8mYLCk+WSDfbUZIDqVbHBrDuX3rfsScGdR2p0p/SGyJa/5fRZrFBHrU723pmXI1cB1ZAON90paAswGzssVezal3Qd8M8UoF381MBb4Q4o1ly1LksuVeZdsL8OrJS0mmxXYoSjbh4B7JC0lGxjcRLan5Gqypbt3pLKlljCfQ/beLElLob9ZoT3LgEvJBk4XA4UlSuXifFvZwTeLyd7H+2qKb2ZWiWcQmpmZmZmZNVBEtC2T/gOyAzSK04cXvX6cbB+9guG5e69TYg/ClF7usJEDcvl+lrteAByYyze+RNw+JdLyh34MKVMnEdE5dz0+dz2TbWcAvkJ2UEcpj0dEfsCQiJhKdthJ4fXRuetZpdoVEb2LXo/NXc8DPlGmfiLifrbsp1h87z6KBuXy7UvvzTYDqPlnkl7n36cbyPZnzN8vF+fscu02M6sPzyA0M9s+qqurq0vuv7OjSO2rbu52mJmZmZmZ2fblAUIzs+1j6erVq7vsqIOE1dXVWr16dRdgaXO3xczMzFq3iBgbEeX2ajQzsybgJcZmZtvBpk2bvrFq1aopq1atOoAd848z1cDSTZs2faO5G2JmZmZmZrYz+LeHFg1qzHirRgyseCryiSee2HvmzJlddt99903PP//8MoBXX3217ahRoz7y8ssvt+/Zs+eGP/7xjy/W9WRjDxCamW0HgwYNeg04trnbYWZmZmZmZjuvr33ta6+fe+65r5166qnv7Rd78cUX7zF8+PA3L7vssue/973v/dtFF130b7/61a9erktcDxCamZmZmZmZmZntBD73uc+99eyzz74vn3b//fd3nT179rMAZ5xxxj+GDRv2MaDxBwglbQaqckk3R8SEulSU4nwTeCcibqxr2e1FUlfgpIi4thZ538qf0pVL/z5wErCZbNneGRHxZJkYg4GTI+KchrXczMxK8WdY2bzlPsN6ABPJTnVcA7wL/DQi7mzs9jaEpLHA4Ig4q7nbYmZmtqPr37ML8ycc1QiR1tarVFXlLKWdUr9i+9a3vrJGNnrE7W08Q7dbTTuSVQ0ou0NuHl/GP/7xj3a9evXaCNCrV6+N//znP+s8IbC2BdZFxMC6Bi8WEdeVSpfULiI2NTR+I+kK/BdQ8ctVKZIOAY4GDoqIDZI+CLyvXP6ImA/Mr09dZmZWK/4MqyVJAu4CboiIk1JaL5p4ebykthFRpz1SzMzMzMys8TRoo3xJKyX9UNJCSVWS9pHUJqV3zeX7i6QeksZLOj+lPSzpMkmzgXMl9ZI0U9KS9HuvlG+qpKskPSHpRUknpPThkmZLukXSc5ImSBoj6anUlr4pX3dJt0ual34OTenjJf0mteNFSYUZfBOAvpIWSbpCUufUnkIfj6vwWPYAXo+IDQAR8XpE/D3VOST1Y3Fq566pH/em++9PbZon6elCXZLGSrpD0v2Snpf009yzPTK1bbGkmRXi7J/qXZSec78GvP1mZjs1f4aVNBJ4Nz8YGhEvRcTVqd62Ke681NczUrpS+tJUz+iU3kbStZKWSbpX0v/knsFKSRdJegw4UdJpKe7i1OdOuWd4naRH07M6OtfePYs/GyV9XdLE3Pt3mqQr6/CfhpmZmZnZTmX33Xff9NJLL+0C8NJLL+3SrVu3Ok9gqO0AYcf0ZaPwMzp37/WIOAj4FXB+RFQDfwRGAUj6D2BlRLxaIm7XiBgWET8HrgFujIgBwE3AVbl8ewCHkc3Myy8LOxA4F+gPfBXYOyIOBqYAZ6c8vwQmRsQQ4IvpXsE+wGeBg4GLJe0CjANeiIiBEXEBsB4Ylfo4Avi5pJpmmj4I/Hv6EnOtpGHpObwPmA6cGxEHAkcA64rKfh+Yldo6ArhC0vvTvYHA6NTX0ZL+XVJ34HrgiynmiRXifBP4ZZpJMxj4W3HjJZ0uab6k+Zvfqd/0cTOzHYw/w2r/GbY/sLCG+18H1qb2DAFOk9QH+ALZ51Th8+0KSXuk9N6pj98ADimKtz4iDouIm4E7ImJI+jx7JtVV0BsYBhwFXCepQ0rf5rMRuBk4Nj0PgFOB3xZ3xJ93ZmZmZtZSfPazn33j17/+9e4Av/71r3c/8sgj36hrjMZYYnxH+r2A7IsAZANhF5H9D/mX0utS8umH5MpPA36au3dX+tK2XNneSAXzIuIVAEkvkA3OQbbFwYh0fQSwX+770G6Sdk3XM9JMvw2SXgPysQsEXCbpcLL9BHumfCWXskfEW5IGAUNTG6ZLGkf2fF6JiHkp379Su/PFP0P2peb89LoDsFe6nhkRa1OZ5UAv4APAIxGxIsX8Z4U4c4DvS/ow2Rex50u0fzIwGaD9Hv2iVB/NzHYy/gyr5WfYNoWlSWSDm++mQcHPAAMKswCBLkC/lOcPaZnwq8pmVg5J6bem/q+S9FBRFflneICkH5Mtk+4MPJC7d0uK8bykF8kGR6HEZ2NE/FXSLOBoSc8Au0TENlsf+fPOzMzMzBpq1YiBC7Z3ncccc0yfuXPn7rpmzZp2PXr0GDBu3Li///CHP3xl1KhRfXv16vXBPffc89277rrrhbrGbYxTjDek35tz8eYAH00z3I4Hflym7Ns1xM3/z/qG3LXKpFfnXlfn2tIGOCQitpqtl75s5cvn2583BugODIqIjZJWkg24lW949gXpYeBhSVVkW6suLOpTKSKbDfhsUVv/o0xbVSZmyTjAM5KeJJuB8YCkb0TErAptMjNryfwZtrVlZDMVs05EnKlsL93CXrkCzo6I/OAdkj5fJl6lvZ3zz3AqcHxELFZ2AMnw3L3iz7rC63LPYArwPeDPlJg9aGZmZma2s7rnnntWlEqfM2fOcw2J2xgDhNuIiJB0J3Al8ExE/KMWxZ4gm6kxjewLzWON1JwHgbOAKwAkDYyIRTXkfxPYNfe6C/Ba+mI1gmzmXlmSPgZU52bnDQReIvuSsqekIRExL80AKV5i/ABwtqSz0zP8eEQ8XUN1c4BJkvpExApJ3dIswpJxJH0EeDEirkrXAwAPEJqZ5bTmzzCyz4TLJH0rIn6V0jrl7j8AfEvSrBRzb+Bl4BHgDEk3AN2Aw4ELgPbAKSm9O9mg3+/L1L0r8EpaGjwmxS04McXoA3wEeBb4eLlORMSTabnxQWSfdWZmZq1a1ctr6T1uRoPjrOxwUiO0prL+ffaqnKmWbrm88c+SmzV8UqPHrGT9mu27pfLoPhfWu+yUDjMbsSVbG3r4tHqVG6PbG7klLU9tBwg7Ssp/Ibk/IsZVKDMdmAeMrWUd5wC/kXQBsJpsz6DGcA7ZINoSsv4+QrYXX0kR8Q9Jj0taCtwH/AS4R9J8YBHZQF9NOgNXK9vgfhPwF+D0iHg37Xt1taSOZIODRxSV/RHwC2BJ2iNqJdmeVeXaulrS6cAdktoArwGfriHOaOArkjaSLS+7pEJfzMxaAn+G1fIzLA2OHg9MlPRdsr68DRT+D3EK2X6AC9Pny2qyWZZ3ki2zXkw2u++7EbFK0u3Ap4ClwHPAk0C5Df/+X7r/Etky6/xA57PAbLLl0d+MiPU1b6UIwC3AwIhYUymjmZmZmVlrV6sBwohoWya9d+56PrnlQOm1ivKPz10PL7q3kuz0xOI6xha97px+P0y2jHebePl7EfE62cBYcdzxRa8PyF0X/1mkeFP1rdpSlLYA+GSZ/POATxQl59u6DjijRLmpZEuvCq+Pzl3fR/YlMJ+/XJzLgctLtc3MrKXyZ1jtP8NS+itksyFL3asmW7r7vRK3L0g/W+WXdH7an3d34Cmywb+tnn96/Suyw2JKeTwizivKP5Uyn43JYcBEzMzMzMwaT3V1dbXatGmzU+5hXV1dLbItjbZR21OMzczMzOrj3jSD81HgRxFRqwNS6ktSV0nPkR1O03TrW8zMzMysNVq6evXqLmmgbadSXV2t1atXdyFb3bONJtmD0MzMzAy2nW1Zj/Jj65j/DWDvhtRpZmZmZlbKpk2bvrFq1aopq1atOoCdb9JdNbB006ZN3yh10wOEZmZmZmZmZmZmFQwaNOg14NjmbkdT2NlGO83MzMzMzMzMzKwReYDQzMzMzMxsBydps6RFuZ9xdSx/vKT9cq8fljS48Vu6VZ29JZXc60rS3pL+R9JfJD0j6RZJPSQNl3RvynNsXftZQ1u+LalTHct8QtKT6Xk/I2l8hfz/I6lrgxpqZtZMvMTYzMzMzMxsx7cuIgbWp6CkdsDxwL3A8kZtVT1I6gDMAL4TEfektBFA93y+iLgbuLuRqv028DvgnTqUuQH4z4hYLKkt8LGaMkfE5xvQPjOzZuUBQiurf88uzJ9wVC1zr61z/Ko6lwBOqVv2fetTR72M3G41NYbxDG3uJuSMb+4GNIGd7kArMzMz20lJugg4BugIPAGcEREh6eH0+lDgQbI9s4ZJ+gHwxVT8REnXAl2Br0fEo0WxOwN/BD4A7AL8ICL+KKk3cB/wGPBJ4GXguIhYJ2kQ8BuygbjHyjT7JGBOYXAQICIeSnUOz9U/FhgcEWdJmgqsA/YBegGnkn07OAR4snColaRfAUPS87gtIi6WdA6wJ/CQpNcjYoSkzwA/BNoDLwCnRsRbRe38EPBKat9m0uBqei5XA4OBAH4YEbdLWpna+7qkrwDnAO8DngT+KyI2S3oL+CVwdOrPcRHxqqQewHXAR1Ld34qIJ0rFSff/O1f/byJiYplnbWZWK15ibGZmZmZmtuPrWLTEeHRKvyYihkTEAWSDYkfnynSNiGERcSnZTLwLImJgRLyQ7reLiIPJZtddXKLO9cCoiDgIGAH8XFLhL6H9gEkRsT/wBlsGHX8LnBMRh9TQlwOABXXqfeYDZH+ZPw+4B5gI7A/0l1SYXfn9iBgMDCAbEB0QEVcBfwdGpMHBDwI/AI5IfZsPfKdEfROBZyXdKemMNPMR4P8BayOif0QMAGblC0naFxgNHJpmfW4GxqTb7wfmRsSBwCPAaSn9KmB2Sj8IWFZDnIFAz4g4ICL6kz1zM7MG8QxCMzMzMzOzHV+5JcYjJH0X6AR0A5aRDZ4BTK8Q8470ewHQu8R9AZdJOhyoBnoCPdK9FRGxKF9eUheyQcnZKX0a8LkKbaiLe9LsyCrg1YioApC0LLV/EfCfkk4n+667B7AfsKQozidS+uNpvPN9wJziyiLiEkk3AZ8hm/X4ZWA4cATwpVy+NUVFPwUMAual+B2B19K9d8mWekP23D6drkcCJ6d4m4G1kr5aJs49wEckXU22VPvBUg8rPYfTAdru1r1UFjOz93iA0MzMzMzMbCeUZrRdS7as9a/pEI0OuSxvVwixIf3eTOnvhmPI9gUcFBEb0xLaDkVlC+U7kg0oRi2avgwYVot85dpbXVR/NdBOUh/gfGBIRKxJy5I7sC0Bf4qIL1eqMM22/JWk64HVknancj8F3BAR/1+JexsjolC23HOvGEfSgcBngTOB/wS+VqLtk4HJAO336Feb98XMWjEvMTYzMzMzM9s5FQa/Xk/74p1QQ943gV3rGL8L8FoaHBxBtvdfWRHxBtnMt8NS0pgyWX8PfFLSexueSzpSUv86tq/YbmSDomvTnn752Yv5/s8FDpX00VR3J0l7FweTdFTRkurNZMupHwTOyuX7QFHRmcAJkj6U7neTVOOzS2W+lfK3lbRbuThpiXSbiLidbLnzQRVim5lV5AFCMzMzMzOzHV/xHoQT0oDc9WTn/90FzKuh/M3ABZKeltS3lnXeBAyWNJ9ssO/PtShzKjBJ0hyyQzi2ERHryPZKPFvS85KWA2PZsgy3XiJiMfA02QzF3wCP525PBu6T9FBErE71/UHSErIBw31KhPwq2R6Ei8iWS49Jy39/DHxA0lJJi8n2Z8y3YznZHocPpvh/IlvuXJNzyZaLV5EtPd6/hjg9gYdTu6YCpWYqmpnViZcYW1lVL6+l97gZFfOt7HBSreL177NXQ5v0nlsu31TnMrOGT2pQnevXXNmg8k1ldJ8Lm7sJNZrSYWZzN2ErQw+f1txNMDMzM6uziGhbJv0HZINIxenDi14/TrbvXsHw3L3XKbEHYUovd9jIAbl8P8tdLwAOzOUbX6bdfwaOLHHrVeDhlGcq2QAYhVOK0/XKovrHlrouqu9qspOHC69nkZ12XFZEfKlM+ltkJygXp/fOXU+nxB6QEdE5d30bcFu6fhU4rkT+knHwrEEza2SeQWhmZmZmZmZmZtaKeYDQzMzMzMzMzMysFfMAoZmZmZmZmZmZWSvmPQjNzMysVevfswvzJxxVOWOjW9sMdWaqmq3mBtpmx6+d077N3YBGcNavm7sFZmZm1pg8g9DMzMzMzMzMzKwV8wxCMzMzMzMzsxas8WbLb5/Z7406070JZp83z0zwkc1Sa32MZ2iTRq+PVfUoo3rVtPPyDEIzMzMzMzMzM7NWzAOEZmZmZmZmZmZmrZgHCGtBUg9Jv5f0oqQFkuZIGtXIdbzVCDGOlTSuMdpjZmZmZmZmZmatg/cgrECSgLuAGyLipJTWCzi2WRtWQkTcDdzd3O0wMzMzMzMzM7Odh2cQVjYSeDciriskRMRLEXG1pLaSrpA0T9ISSWdANqiY0pdKqpI0OqUPl/SIpDslLZd0naT33gNJl0paLGlumrW4q6QVknZJ93eTtFLSLpLOSTGWSLo53R8r6Zp03SPVszj9fFLS+yXNSK+XFtplZmZmZmZmZmatl2cQVrY/sLDMva8DayNiiKT2wOOSHgQOAgYCBwIfBOZJeiSVORjYD3gJuB/4AnAb8H5gbkR8X9JPgdMi4seSHgaOIpvF+CXg9ojYmJYS94mIDZK6rn7EGgAAIABJREFUlmjbVcDsiBglqS3QGTgS+HtEHAUgqUtxIUmnA6cDtN2te+2fkpmZmZmZme2Qql5eS+9xM5ok9soOJzVJ3HL699lru9Z3y+Wbmiz2rOGTmix23vo1V26XegBG97mw0WNO6TCzYp6hh0+rc9wxur0+zWmxPIOwjiRNSjPw5gGfAU6WtAh4Etgd6AccBvwhIjZHxKvAbGBICvFURLwYEZuBP6S8AO8C96brBUDvdD0FODVdnwr8Nl0vAW6S9BWg1L9YI4FfAaR2rCU7Lf4IST+RNDSlbSUiJkfE4IgY3LbTNuOHZmZmZmZmZmbWwniAsLJlZDMCAYiIM4FPAd0BAWdHxMD00yciHkzp5USZ1xsjonC9mTS7MyIeB3pLGga0jYilKc9RwCRgELBAUsXZoBHxXMpfBVwu6aJKZczMzMzMzMzMrGXzEuPKZgGXSfpWRPwqpXVKvx8AviVpVlr2uzfwMvAIcIakG4BuwOHABcA+wMGS+pAtMR4NTK5FG24km234I4C0b+G/R8RDkh4DTiJbQpw3E/gW8Iu0xPj9Kc8/I+J36dTksXV8FmZmZi1OUy67akrbe0nX9rK9l45tD025PK2xba/lbmZmZrZj8QBhBRERko4HJkr6LrAaeBu4ELiVbCnwwnTa8WrgeOBO4BBgMdkMwe9GxCpJ+wBzgAlAf7KBxDtr0YybgB+TDRICtAV+l/YQFDAxIt7ImvCec4HJkr5ONiPxW8BuwBWSqoGNKc3MzMzMzMzMzFoxDxDWQkS8QnZASCnfSz/FLkg/xd6JiG1OD46Izrnr28gOLik4DLgtIt5I9zeyZe/CfIypwNR0/SpwXIn6HyjTDzMzMzMzMzMza4U8QLiDk3Q18Dng883dFjMzMzMzMzMza3l8SMl2FBEPR8TRdSxzdkR8NB0wYmZmZmZm1mgkbZa0KPczro7lj5e0X+71w5IGN35Lt6qzt6SlZdLXFfXn5HrWcYmkIxre2qaT+tsyN6Q1s+3OMwjNzMzMzMxar3URMbA+BSW1I9uD/V5geaO2qv5eqG9/8iLiolLpktpGxOaGxm8kvckOrPx9M7fDzFoAzyA0MzMzMzOzrUi6SNI8SUslTU6HMhZmCF4maTbZwY3Hkh2EuEhS31T8RElPSXpO0tASsTtLmilpoaQqScel9N6SnpF0vaRlkh6U1DHdGyRpsaQ5wJn16M9bki5NMeZK6iGpi6SVktqkPJ0k/VXSLpKmSjohpa9Mz+Ox1LeBKcYSSXdK+kDu2fykuO+Sxkq6S9I9klZIOkvSdyQ9neJ0S/n6Srpf0gJJj6ZDLkltuUrSE5JeLLSL7PDLoenZn1fXZ2JmlucBQjMzMzMzs9arY9GS3MKBitdExJCIOADoCOS3SuoaEcMi4lLgbuCCiBgYES+k++0i4mDg28DFJepcD4yKiIOAEcDPCwOQQD9gUkTsD7wBfDGl/xY4JyIOqdCfvkX9KQxQvh+YGxEHAo8Ap0XEWmAxMCzlOQZ4IB0KuU2bI+KwiLgZuBG4MCIGAFVFfSzX9wPIZvsdDFxKdnjlx4E5QGEZ9GTg7IgYBJwPXJsrvwfZQZVHkw0MAowDHk3PfmKF52JmViMvMTYzMzMzM2u9yi0xHiHpu0AnoBuwDLgn3ZteIeYd6fcCsmWwxQRcJulwoBroCfRI91ZExKJ8eUldyAYlZ6f0aWQHOZZSbonxu2RLoQtxP53ry2jgIeBLbD0olzcdoERbbgBuzeUr1/eHIuJN4E1Ja9nyLKuAAZI6A58Ebt0yVkr7XPm7IqIaWC6pB7Ug6XTgdIC2u3WvTREza8U8QGhl9e/ZhfkTjqpFzrW1ilfVsOZs7ZS6F9m3wZWObHCE1mg826wqaWbjt0MdqpzFzMzMbAclqQPZQNngiPirpPFAh1yWtyuE2JB+b6b0d84xQHdgUERslLQyF39DLt9mstmLAqIufShhY0QUYuTbdTdweVrmOwiYVaZ8pT4XlOt7vl/VudfVKV8b4I0a9k/Ml6/V/2xGxGSyWYm036NfQ5+fmbVwXmJsZmZmZmZmeYXButfTzLYTasj7JrBrHeN3AV5Lg4MjgF41ZY6IN4C1kg5LSWPqWF9Nsd8CngJ+Cdxb6QCStCx5TW7p8leB2TUUqW07/gWskHQigDIHVihWn2dvZlaSBwjNzMzMzMxar+I9CCekAbnryRYB3QXMq6H8zcAF6cCNvjXky7sJGCxpPtlg359rUeZUYFI6pGRdDfmK9yA8pxaxpwNfofLS6YJTyA5mWQIMBC6pZblKxgBfl7SYbEn3cRXyLwE2pYNXfEiJmTWIlxibmZmZmZm1UhHRtkz6D4AflEgfXvT6cWC/XNLw3L3XKbEHYUovd9jIAbl8P8tdLwDyM+rGl4i7kmxJ8jYionPu+jbgtqLXKso/Nnfdu+jeIuATJeoYnrt+r+8RMRWYWipe/l5ErACOLBF3bNHrzun3RuBTxfnNzOrDMwjNzMzMzMzMzMxaMQ8QmpmZmZmZmZmZtWJeYmxlVb28lt7jZmyTvrLDSY0Sv3+fvSrmueXyTY1SVyWzhk/aLvXUZP2aK5u7CYzuc2FzN6FWpnSYud3qGnr4tO1Wl5mZmZmZmVlz8AxCMzMzMzMzMzOzVswDhGZmZmZmZmZmZq2YlxibmZmZmZmZtWD9e3Zh/oSjmij62iaKW1rVdq0NOKXpQu/bdKGLjNxuNTWF8QytVa66WlXhvircb2k8g9DMzFocSZslLcr9jKtnnG9KOrmx29eYJHWV9F+1zPtWmfQekn4v6UVJCyTNkTSqcVtast5j6/vemJmZmZlZ4/EMQjMza4nWRcTAhgaJiOtKpUtqFxHb5xSlyroC/wVcW5/CkgTcBdwQESeltF7AsY3WwjIi4m7g7qaux8zMzMzMauYZhGZm1mpIWinph5IWSqqStI+kNim9ay7fX9KsuvGSzk9pD0u6TNJs4FxJvSTNlLQk/d4r5Zsq6SpJT6QZeSek9OGSZku6RdJzkiZIGiPpqdSWvilfd0m3S5qXfg5N6eMl/Sa140VJ56TmTgD6ppmSV0jqnNpT6ONxFR7LSODd/GBoRLwUEVenetumuPNSX89I6UrpS1M9o1P6HpIeSe1ZKmloSj8ytWmxpJkpbayka+rZbySdnNq0WNK0muKYmZmZmVl5nkFoZmYtUUdJi3KvL4+I6en69Yg4KC3LPT8iviHpj8Ao4LeS/gNYGRGvZpPrttI1IoYBSLoHuDEibpD0NeAq4PiUbw/gMGAfshlyt6X0A8m2m/kn8CIwJSIOlnQucDbwbeCXwMSIeCwNOj7Ali1q9gFGALsCz0r6FTAOOKAwY1JSO2BURPxL0geBuZLujogo86z2BxbW8Cy/DqyNiCGS2gOPS3oQOAgYmPr0QWCepEeAk4AHIuJSSW2BTpK6A9cDh0fECkndStRT137vDXwfODQiXs/FrCnOeySdDpwO0Ha37jV038zMzMys5fMAoZmZtUQ1LTG+I/1eAHwhXU8HLgJ+C3wpvS4ln35Irvw04Ke5e3dFRDWwXFKPXPq8iHgFQNILwIMpvYpsAAzgCGC/3ODkbpJ2TdczImIDsEHSa0A+doGAyyQdDlQDPVO+Svswk9o1iWxw892IGAJ8BhhQmAkJdAH6pTx/iIjNwKtpZuUQYB7wG0m7pOewSNJw4JGIWAEQEf8sUXVd+z0SuC0iXi+KWTJORLyZrywiJgOTAdrv0a/c4KmZmZmZWavgAcKc9CVuIvAJYA3wLvDTiLizCes8FtgvIiY0VR1mZraVDen3ZrZ8Ds4BPppmuh0P/LhM2bdriJsfZNqQu1aZ9Orc6+pcW9oAh0TEunzwNOCVL59vf94YoDswKCI2SloJdKih3cuAL77XiYgz08zD+bn2nx0RDxS15/OlgkXEI2lw8ihgmqQrgDfY+vmUUtd+q0zMknHMzMxas6qX19J73IxGj7uyw0mNHhOgf5+9Gj3mLZfvKNtHZ2YNn7Td61y/5somjT+6z4V1yj+lw8xa5Rt6+LT6NGcrY3R7g2O0dN6DMJHe26T9kYj4SEQMIptF8uGmrDci7vbgoJlZ80rLb+8ErgSeiYh/1KLYE2SfE5ANyj3WSM15EDir8EJSpcNW3iRbelvQBXgtDQ6OAHpVKD8L6CDpW7m0TrnrB4BvpRmBSNpb0vuBR4DRaY/C7sDhwFPKDjh5LSKuB/6bbCnyHGCYpD4pRqklxnXt90zgPyXtXhSzrnHMzMzMzFo9DxBuUXaT9payQbukYalNiyQ9nVu6ZWbW0nTM/Xu3SFJt/hAzHfgK5ZcXFzsHOFXSEuCrwLn1bGupuIPTv+3LgW/WlDkNZj6ePm+uAG5K5eeTDVz+uUL5IJs1OUzSCklPATcAhT8BTwGWAwslLQV+TTaD705gCbCYbJDxuxGxChgOLJL0NNnMxF9GxGqy/f7ukLSY0s+4rv1eBlwKzE4xC38Sr1McMzMzMzPzEuO8mjZpbykbtJ8PnBkRj0vqDKwvboA3bTezliAi2pZJ7527nk82mJV/raL843PXw4vurST741JxHWOLXndOvx8GHi4VL38v7ak3ukTc8UWvD8hdF6/vOaS4fL4tJdJfYctsyOJ71cD30k+xC9JPPv8NZAOMxXHuA+4rSpsKTE3X9en3NnWVi2NmZmZmZuV5gLCM/CbtwEu0gA3agceBKyXdBNwREX8rboA3bTczMzMzMzMza108QLhFTZu0/x8tY4P2CZJmAJ8H5ko6IiJqXHpmZmZmZmZmZmYtm/cg3KKmTdpbxAbtkvpGRFVE/IRs4HOfCvHNzMzMzMzMzKyF8wBhUmGT9payQfu30yb2i4F1FO0FZWZmZmZmW5O0uejgq3F1LH+8pP1yrx+WNLjxW7pVnb3T95ZS6euK+nNyPeu4RNIRDW9t00n9Ld6nt1y+Us+rjaSrtOVQynmFCR9l4hxb1/8+zMx2FF5inFPTJu20gA3aI+LsEu03MzMzM7Py1kVEpZU9JUlqRzYJ4V6yCQc7ghfq25+8iLioVLqktmmP9h1Bb7IDJH9fz/KjgT2BARFRLenDwNvlMkfE3cDd9azLzKxZeQahmZmZmZlZHUm6KM0oWyppstLG4WmG4GXpAMMLgWOBK9Jsvb6p+ImSnpL0nKShJWJ3ljRT0sI0c+24lN5b0jOSrpe0TNKDkjqme4MkLZY0BzizHv15S9KlKcZcST0kdZG0UlKblKeTpL9K2kXS1MIhjinPRZIeS30bmGIskXSnpA/kns1PivsuaaykuyTdk1ZznSXpO5KeTnG6pXx9Jd0vaYGkRyXtk9Knppl+T0h6UVsOl5wADE3P/rz0/B5Nz3WhpE9WeCx7AK9ERDVARPwtItakOo9MMRZLmpnrxzXpuruk29N/I/MkHZrSx0v6TXoWL0o6J/cenJye2WJJ0yrEGZabBfq0thxuaWZWLx4gNDMzMzMzK6+jtl6SW1ipc01EDEmrezoCR+fKdI2IYRFxKdmMsgsiYmBEvJDut4uIg4FvAxeXqHM9MCoiDgJGAD8vDEAC/YBJEbE/2UGIhYMWfwucExGHVOhP36L+FAYo3w/MjYgDyfZaPy0i1pJtpzQs5TkGeCAiNpZqc0QcFhE3AzcCF0bEAKCqqI/l+n4A2Wy/g8m2UXonIj5Otpd7YRn0ZLLDIwcB5wPX5srvARxG9j5MSGnjgEfTs58IvAZ8Oj3X0cBVFZ7VLcAx6Tn9XNLHIRu0A64Hvpie14klyv4SmBgRQ8jeoym5e/sAn019vTgNuO4PfB8YmWKeWyHO+cCZaTboULItpMzM6s1LjM3MzMzMzMort8R4hKTvkh1s2A1YBtyT7pXabzzvjvR7Adky2GICLpN0OFAN9AR6pHsrImJRvrykLmSDkrNT+jTgc2XqLrfE+F2ypdCFuJ/O9WU08BDZdkzXblv0vXyUaMsNwK25fOX6/lBEvAm8KWktW55lFTBAUmfgk8CtW8ZKaZ8rf1ea6bdcUg9K2wW4RtkhjpuBvcvkA7IZg5I+BoxMPzMlnUj2nj8SEStSvn+WKH4EsF+urbvlZvnNiIgNwAZJr5G9tyOB29J2UfmY5eI8Dlwp6Sbgjoj4W3EDJJ1Otg8+bXfrXlNXzcw8QGhmZmZmZlYXkjqQDZQNjoi/ShoPdMhlKbtPXbIh/d5M6e9kY4DuwKCI2ChpZS7+hly+zWSzFwVEXfpQwsZ0cGNxu+4GLk/LfAeRHc5YSqU+F5Tre75f1bnX1SlfG+CNGvZPzJdXmTznAa8CB6Z46ys1Ng3k3QfcJ+lVsj0l/0Tl590GOCQitprZlwb6it/DdpR/D0vGASZImgF8Hpgr6YiI+HNR2yeTzbqk/R79Gvrfh5m1cF5ibGZmZmZmVjeFwbrX08y2E2rI+yZQ1/3hugCvpcHBEUCvmjJHxBvAWkmHpaQxdayvpthvAU+RLXW9t9IBJGlZ8prc0uWvArNrKFLbdvwLWJFm8KHMgRWKFT/7LmzZU/CrQNuaCks6SNKe6boNMAB4iWzZ8zClE40LeyQWeRA4Kxer0sEwM4H/lLR7UcyScST1jYiqiPgJMJ9s2bKZWb15gNDMzMzMzKy84j0IJ6QBuevJlr/eBcyrofzNwAXpIIm+NeTLuwkYLGk+2WDfnyvkBzgVmKTskJKa9qMr3oPwnBryFkwHvkLlpdMFp5AdzLIEGAhcUstylYwBvi5pMdmS7uMq5F8CbEqHfpxHNuvzFElzyZYXV5r1+CHgHklLC7HI9p5cTbZ0947UllLP5Ryy93CJpOXAN2uqKCKWke29ODvFvLJCnG8rOyBnMdn7fV+FvpiZ1UhbZpGbbW3w4MExf/785m6G2U5H0oKIGNzc7TCz2mm/R7/Y45RfNHcz6mxlh5OauwlNon+fvZq7CY3ulss3NXcTam3W8Em1ynfWrz/lzzqznUhTfdY11WdRU3wW7Gj/Ftf239vGtH7NlZUzNcDoPhfWKf+UDjNrlW/o4dPq05ytjNHtdS7z6siPt6rPOs8gNDMzMzMzMzMza8U8QGhmZmZmZmZmZtaKeYDQzMzMzMzMzMysFfMAoZmZmZmZmZmZWSvWrrkbYGZmZtac+vfswvwJRzV3M+phbXM3oElUNXcDmsIpzd2A2tu3lvnO+nWTNsPMzMy2Mw8QWllVL6+l97gZDYrRGKda7cgnWG2Pk6ea4qSpup4u1RRqe2LV9tAYp2KZmZmZme2omu6PYU3zx6om+WPRDvbHmtr+QaZxjWyWWssZz9Ba52yoVfUoowbXunPxEmMzMzMzMzMzM7NWzAOEZmZmZmZmZmZmrZgHCM3MzMzMzMzMzFoxDxCamZmZmZmZmZm1Yh4gNDMzMzMzMzMza8V8irGZmZmZmZlZC1b18lp6j5sBwMoOJ9WYt3+fvbZ6fcvlm+pU16zhk2qdd/2aK+sUO290nwvrXbYxTOkws1nrbyxDD5/W3E1oVGN0e3M3YaflGYRmZmZmZmZmZmatmAcIzczMzMzMzMzMWrFmGyCUtFnSIklLJd0qqZOk3pKWNkLsb0o6uZ5l3yqT3kPS7yW9KGmBpDmSRjWspY1P0lhJ1zR3O8zMzMzMzMzMbOfQnHsQrouIgQCSbgK+CdzRGIEj4rrGiFMgScBdwA0RcVJK6wUc25j1lKi3bURsbso6zMzMWrv8vkxNqdKeT82heJ+pHUld97zaUdVlLy4zMzOz5rKjLDF+FPhoum4r6XpJyyQ9KKmjpL6SFhYyS+onaUG6niBpuaQlkn6W0sZLOj9df1TS/0paLGlhitVZ0sz0ukrScRXaNxJ4Nz/wGBEvRcTVqY62kq6QNC+144yUrpS+NNUzOqW3kXRt6uO9kv5H0gnp3kpJF0l6DDhR0mkp7mJJt0vqlPJNlXSdpEclPSfp6Fx795R0v6TnJf005f+6pIm5Z3iapPrvCGtmZmZmZmZmZi1Cs59iLKkd8Dng/pTUD/hyRJwm6RbgixHxO0lrJQ2MiEXAqcBUSd2AUcA+ERGSupao4iZgQkTcKakD2aDou8CoiPiXpA8CcyXdHRFRppn7AwvL3AP4OrA2IoZIag88LulB4CBgIHAg8EFgnqRHgEOB3kB/4EPAM8BvcvHWR8Rh6fnsHhHXp+sfp7quTvl6A8OAvsBDkgqDrAOBjwMbgGclXQ3cDCyR9N2I2Jie4RnFHZF0OnA6QNvdutfQZTMzMzMzMzMzawmacwZhR0mLgPnA/wH/ndJXpEFAgAVkg2AAU4BTJbUFRgO/B/4FrAemSPoC8E6+Akm7Aj0j4k6AiFgfEe8AAi6TtAT4X6An0KO2DZc0Kc3om5eSPgOcnPrzJLA72UDnYcAfImJzRLwKzAaGpPRbI6I6IlYBDxVVMT13fUCaJVgFjCEbrCy4JcV4HngR2Celz4yItRGxHlgO9IqIt4FZwNGS9gF2iYiq4r5FxOSIGBwRg9t26lLbR2JmZmZmZmZmZjup5hwgXBcRA9PP2RHxbkrfkMuzmS2zHG8nm2l4NLAgIv4REZuAg9O949kyC7FAZeoeA3QHBqV9EF8FOtTQ1mVkswEBiIgzgU+lGIV6zs71p09EPFhD/eXSC97OXU8FzoqI/sAPi9pZPOOx8LrcM5wCjCWbPfjbCm0wMzMzM7OdSO4gyMLPuDqWP17SfrnXD0sa3Pgt3arOkgdVSrpT0vG5189K+kHu9e1pkkhNcRu8+aukr6XtopakraPKbk8laU9JtzW0TjOz/7+9Ow+Xo6rzP/7+QFhNCCLLAAphR0QMEJA1BGH44TKAChMRlLgxoIjggOLAaNRRojgw7BgQWUSIsgYUEwwkQBaSkI1NFklQhowQl7AvSb6/P85pUun0dm86fW+nP6/nqedWnTp16luV3HuePn2WntBb5iCsK/eGGwNcSm7cktQX6B8RvwVOIQ2tLV7zIvBsqWKRtFaew68/8HxEvCXpQGDLOre/G1hb0omFtHUL+2OAEyWtke+zvaR3APcCQ/MchRsBg4GpwP3AJ/NchJsAQ2rcux8wP5d9TNm5o3IZ2wBbA4/XeoiIeAB4D/Bp4PqaT2xmZmZmZu2m2AljYESMaPTCPPXTEcBO9fK2yCRgH0jTLgEvA3sXzu+d81QzgPS5p2F5tFrx+N3AmcB+EbELsBcwp9r1EfFcRBzZlXuamfUWbdNAmF1H6iU3Nh/3A+7IQ4UnAKdWuOYzwMk5zyTgn3I5gyRNJzW6/aHWTfPchEcAB0iaK2kqcDXwzZzlCtJQ3hn526+fknrt3UKqQGaTGhm/kYcU3wQ8C5TyPgAsrHL7/8zn76oQ5+P5ue8ETsiNqPX8CpgYEX9vIK+ZmZmZmbW5vAjitNwDbqQk5fTxkn4oaQLps81hwDm59+E2+fKjJE3NCyPuX6HsigtA5h58j6lsAcp8bvc8ZdNk4CtVwp5IbiDMP+8ANlKyFakx9P/yfe7L958hqXTNCGD//CynqvrCkkMk3SPpl0D5FEwbAy+RGieJiJcjYm6+rtJimG/3hqxzv/GSbpT0B0nXFf499pA0KZc5VVK/GuVsKune/HwPV/q3MTPrih5bpCQi+lZImwfsXDj+SVmW/YArI2JxPj+fNMS4vJzhhf0nSasQl9u7QlrFuAr3+lSVc0uA/8hbudPztkx+SadFxMv527Cp5MooIgaU5b2U1GuykokRcWpZ/qtIw5JLxx8ru2Y/4DzMzMzMzGxVU5rnveTsiBgFXBQR3wOQdC1p2qbbc571I+KAfG474I6IuDEfA/SJiD0lfQT4DnBw2T1fp8ICkPnccgtQAr8gjQj7akRMkHROlWd5kDQf+5qkBsIJpFFT7yUtyDgx53se+OeIeD3Hfz0wCDgDOK30eUhpMcZKC0tC+ky5c6nxr2A2aTqquZLGATdHROm9VVoMc+PCtdUWsiTH/z7gufwc++ZOKKOAoRExTdJ6wGs1yvkEMCYifpB7PhZHuFF4Zi9AaWYN6fFVjBsl6RbSar2VGvva0R1Kqy6vCXw/9yxcafK9pgKzI2LcyryXmZmZmZn1iNfyHOvlDpT0DVIj0gakOdZLDV2jKuQvujn/LC4gWVRaAHIwsIRlF4BcbgFKSf1JjZITcvq1pLnmlxERb0gqzQW/F/BjUgPhPqQGttLw4jWAiyQNJM2/vn2V5zgE2EVSaQhwf1ID5pvA1AqNg0TEYkmHkhaaPAg4T9LuwH9TthgmvN2g2uj9ns3XzCK914XA/IiYlst8MZ+vVs404EqlqahuLbznYvwjgZEAa226Xfn89WZmy2ibBsKI+HhPx9BMETFkBa8f1sX8/6B6ZWlmZmZmZqug3LvtEmBQRPxZ0nCWXfjwlYoXLlVaALG4+GFRcQHItyTNK5RfvnjiOqQGxUYbqyaR5nHvFxF/lzQFOInUQHhZznMqqZffB0i9+KpNu1RaWHLMMonSEGq8gzzd1FRgqqS7SL0fz20g9lr3q7SoZLX3UrGcXNZg4KPAtZLOiYhrGojLzKyidpuD0MzMzMzMzBpXaqxboLTIY61FNF4izfPeFV1aADJ3XFgoab+cVL4QY9FE4N9IQ30hze++F7AFqRdk6f7z87RPnwFKC42UP0u1hSWrUlqVeLdC0kDgmRqLYRZ19X5/ADaTtEfO309p4ZiK5UjakvTeLwd+RuppaWbWbW3Tg9DMzMzMzMxqKp+D8HcRcYaky0lzns8jDU2t5gbgckknU7shseg64HalBSBnUWcByOxzpOGxr5IawKqZRBpWfDZARCyS9Dzw59wgCKl35E2SjgLuYWlvwDnAIkmzSXO0n08ayjsjLwryAmkhylrWAH4iaTNSz8QXgBPyuc8AP5X0PeAt4CjSEOuSK7pyv4h4U9JQ4EKlxVxeI833WK2cIcDpkt4iLaLy2TrPYmZWkxsIzczMzMzMVgERsXqV9LOAsyqkDyk7ngjsVEgaUji3gApzEOb0igtAUmUByogCV6EXAAAbGklEQVR4kDQkuGR4lbifJw2xrRXzk8AuhaRv5fS3SPMGFlVaWHJ83ird/xmqzIFfYzHMnfP5agtZLnO/iDipsD+N1EOyXKVyrs6bmVlTeIixmZmZmZmZmZlZB3MPQqvq/Zv3Z/qIj65gKQtXOI6HVriECo5rTjHvbU4xdawqC3cvazj793QIBcObXJ7qZzEzMzMzMzPrJdyD0MzMzMzMzMzMrIO5gdDMzMzMzMzMzKyDuYHQzMzMzMzMzMysg3kOQjMzMzMzM7NV2LLzy9eeJ365OeC7OH971+Zpb9/51nvXnOorYnhPB9BU/9fEsjptZnn3IDQzM8skLZY0q7Cd0c1yTpD02WbH10yS1pf05Qbzvlwl/UxJj0iak9/XB2uUMUjSBd2N18zMzMzMVh73ILSqHvrfhQw44zc9HUbLzVv70z0dAu/faosevf+vzl7U1PLuHnJx08p6/e/nrnAZQ7f6ZkP5rlh7XN08+w++dkXDsd7ltYgYuKKFRMRlldIl9YmI5v6Cdd/6wJeBS7pzsaS9gY8Bu0XEG5I2BNaslj8ipgPTu3MvMzMzMzNbudyD0MzMrA5J8yR9V9IMSQ9J2lHSajl9/UK+pyRtImm4pNNy2nhJP5Q0AfiapC0ljcu97sZJ2iLnu0rSBZImSXpa0pE5fYikCZJ+JekJSSMkHSNpao5lm5xvI0k3SZqWt31z+nBJV+Y4npZ0cg53BLBN7vl3jqS+OZ7SMx5e57VsCiyIiDcAImJBRDyX77lHfo7ZOc5++TnuyOffkWOaJmlm6V6Shkm6WdLvJD0p6ceFd3tojm22pHF1ynlfvu+s/J63W4F/fjMzMzOzVZ57EJqZmS21jqRZheOzI2JU3l8QEbvlYbmnRcQXJd0GfBz4eR5eOy8i/iItN2PJ+hFxAICk24FrIuJqSZ8HLgCOyPk2BfYDdgRGAzfm9A+QpvT5G/A0cEVE7Cnpa8BXgVOA84HzIuL+3Og4hqXTAO0IHAj0Ax6XdClwBrBzqcekpD7AxyPixdwbcIqk0RERVd7VWODbkp4Afg+MiogJktYERgFDI2KapPWA18quPRO4OyI+nxtYp0r6fT43ENgVeCPHeiHwOnA5MDgi5kraoE45JwDnR8R1OZ7Vy4OXdDxwPMDq621U5RHNzMzMzDqDGwjNzMyWqjXE+Ob880HgE3l/FPBt4OfAp/JxJcX0vQvXXwv8uHDu1ohYAjwqaZNC+rSImA8g6Y+kxjlI84gfmPcPBnYqNE6uJ6lf3v9N7un3hqTngWLZJQJ+KGkwsATYPOerONdzRLwsaXdg/xzDKKU5Gx8E5kfEtJzvxRx38fJDgMNKvSyBtYHS3ArjImJhvuZRYEvgncC9ETE3l/m3OuVMBs6U9G7g5oh4skL8I4GRAGttul21RlAzM7NVQnH6qHlrf7rhKY0amXqou9MJrcjUQY1OGVSukSmEmmFlT0N0jG5aqeVbZ3IDoZmZWWPeyD8Xs7T+nAxsK2kjUi/A/6py7Ss1yi02Tr1R2FeV9CWF4yWFWFYD9o6IZXrr5Ya54vXF+IuOATYCdo+ItyTNIzW4VQ88YjEwHhgv6SHSOoczyp6pEgGfjIjHy2L9YJVYVaXMiuUAj0l6APgoMEbSFyPi7joxmZmZmZl1LM9BaGZm1k15+O0twLnAYxHx1wYum0TqbQipUe7+JoUzFjipdCCp3mIrL5GGHJf0B57PjYMHknruVSVph7K5/QYCzwB/ADaTtEfO1y8PXy4aA3xVufVS0q51Yp0MHCBpq5y/NMS4YjmStgaejogLSEO1d6lTvpmZmZlZR3MPQjMzs6XK5yD8XUScUeeaUcA0YFiD9zgZuFLS6cALwOe6HGX1ci+WNIdUv99Lmouvooj4q6SJkh4G7gR+BNwuaTowi9TQV0tf4MI8998i4Cng+Ih4U9LQfG4d0vyDB5dd+33gf4A5uXFvHmlF5GqxvpDnDLxZ0mrA88A/1yhnKHCspLdIQ6S/V+dZzMzMzMw6mhsIzczMsohYbjGLnD6gsD8dGFJ2rLL8wwv7Q8rOzQM+VOEew8qO++af40nDeJcrr3guIhaQGsbKyx1edrxzYf/TZdn3Lr++GEtZ2oPAPlXyTwP2Kksuxvoa8G8VrrsKuKpw/LHC/p2khsxi/mrlnA2cXSk2MzMzMzNbnocYm5mZmZmZmZmZdbC6DYSSzpT0iKQ5kmblCcRr5b9C0k55f56kDWvkPVzSrYXjb0l6qnD8L5JG17nfKZLWrfccXSXpNkmTy9KOKD1bq0m6StKRPXFvMzMzMzMzMzNbddVsIJS0N2kun90iYhfSHEJ/rnVNRHwxIh5t8P6TWHY4097Ai5I2zsf7ABPrlHEK0KUGQkkVh5AVzq8P7AasX5oQPTsC6JEGwhWhxL1FzczMzMzMzMxsOfUajTYFFkTEG5DmN4qI5wAkHSRppqSHJF0paa2cPl7SoEZuHhEvAAslbZuTNgduYumcRvuQGhGRdKmk6bk343dz2snAZsA9ku7JaYdImixphqRfS+qb0+dJ+rak+4Gj6oT2SeB24AbySpOS9gEOA87JPSm3yc96nqR7JT0maQ9JN0t6UtJ/lQqT9HVJD+ftlJz2Dkm/kTQ7pw8txPkjSVPztm0hrsGSJkl6utibUNLpkqblXp6ldzMgx3QJMAN4T7V3Y2ZmZmZmqw5Ji/NnltJWb8Gt8uuXGTnVlc94hWu6NBKtShnX5+tP7eq1rVDpvfTmUXJmZrXUayAcS2pYekLSJZIOAJC0NmkS8aER8X7SYicndjOGScA+knYAngSm5OM+wC6klSEBzoyIQTntAEm7RMQFwHPAgRFxYB7OfBZwcETsBkwHvl641+sRsV9E3FAnpqOB6/N2NEBETAJGA6dHxMCI+GPO+2ZEDAYuA24DvgLsDAyT9C5Ju5NWqPwgacL2L0naFTgUeC4iPpAnjP9d4f4vRsSewEWk1RlLNgX2I/XqHAGpQRTYDtgTGAjsLmlwzr8DcE1E7Aq8UufdmJmZmZnZquG1/JmltI1o9ML8OWyFRk51ZyRaeQyS/gnYJyJ2iYjzuhtLD+iVo+TMzOqp2UAYES8DuwPHAy8AoyQNIzU8zY2IJ3LWq4HBFQupbyLpj+Q+wGRgKqkxbVfg8Yh4Pef7V0kzgJnA+6hcYe2V0ydKmgUcB2xZOD+qXjCSNgG2Be7Pz7dI0s41Lil9+/MQ8EhEzM89Lp8G3kNq0LslIl7J7/NmYP+c/+DcW3D/iFhYKPP6ws9i5XJrRCzJQ7g3yWmH5G0mqafgjqQGQ4BnImJK3q/3bkrPf3zuqTl98asLy0+bmZmZmVmbyiOqpuURTCMlKaePl/RDSROAb1I2cipfflQe4fSEpP3r3KrWSLS356mXNEjS+Lw/PMc0FriG1Fll4xzD/pK+lGOfLemmUg87SZtIuiWnz1Ya+YWkY3O8syT9tFIDWp33URrV9fbzSlpH0g25V+MoYJ3yMnvxKDkzs5rqzksXEYsjYnxEfAc4iTT8Vk2MYRKFBsKIeAlYGxhC/mZFaR7A04CD8jdQv8l5ygm4q/BN2U4R8YXC+VcaiGco8E5grqR5wADyMOMq3sg/lxT2S8d9qPKucuPj7qSGwrMlfbt4usp+sXwVfp5deOZtI+Jn+dwrZflrvZtSXCMjYlBEDFp93f4VH9jMzMzMzHq1dcqGGA/N6RdFxB55BNM6pF5+JetHxAER8QMqj5zqk0c5nQJ8p879K45Ea8DuwOER8WlSI+Ufcwz3ATfn2D8APAaUPstcAEzI6bsBj0h6L+lz3b4RMRBYDBxT4X613kel5z0ReDV/Jv1BjreSXjFKzp0/zKwr6i1SsoOk7QpJA4FngD8AAwrfinwGmFCnrHGSNq9w6lHSNyT7k3rBAcwCTiB/swKsR2rsWph7+H24cP1LQL+8PwXYtxSXpHUlbV8lnpMknVTh1NHAoRExICIGkP7olxoIi/dq1L3AETmWdwAfB+6TtBmpcvkF8BNSZVYytPBzmZWUKxgDfL7wLdLmhe7rRQ2/GzMzMzMza2vlQ4xLI6kOlPSApIeAD5FGZpXUG211c/75IKkTRVU1RqLVMzoiXqtybmdJ9+XYj2Fp7B8CLs33XZxHZh2U7z8tj546CNi6Qpm13kel5x0M/CLfaw4wp0qsvWKUnDt/mFlX9Klzvi9wodKqvouAp4DjI+J1SZ8Dfp2/BZlGmoOvIqUVdLcF/lZ+LiJC0gNA/4h4KydPJlUmk3Ke2ZJmAo+Qhu4W52wYCdwpaX7+hmUYcL3yoimkb1ueYHk7lpWDpAHAFqTGtFJ8cyW9qDSp7g3A5bnb95E0ICJmSLqKVCkAXBERMyX9P1K3/SXAWyw7h+Na+Z2sRp4DsUb5Y/M3ZJNzj/iXgWNJ35IV873QhXdjZmZmZmarEKV55C8BBkXEnyUNZ9lRWfVGW5VGMy2m/udIImIxMB4YnxvgjiPNY7+IpR1VykeF1YrhKuCI/NlwGGnEWTUCro6Ib1XNUP99VHve4givaiYBXwVWBy6PiJfy/Yaw/Ci5PSLi7/kzY61RctU+FzYySs7MrK6af9gj4kGWzpVQfm4c6RuQ8vQhhf0BAEpz+N1U7dugiPho2fFVpAqgmDasyrUXAhcWju8G9qiQb0BZ0gDKFumIiHmkOSLKry327it+qzOkkGc8qQIsHRfPnQucW1bmGFLvv0oujojvluUfVnbct7B/PnB+hXKWmTux2rsxMzMzM7NVXqnxaUEefXQkcGOVvA2NnMojxK6JiIPK0ncAlkTEkzmpNBINYB6pd9+dpOmrGtUPmC9pDVIPwv/N6eNInS3+J88z+I6cdpuk8yLieUkbAP0i4plCeV15HyX35nvfkz/j7lIlX3GU3JdzWmmU3DfycaVRcuPzudL7X0DqvHKxpG0j4imluRffXVgPwMysKerOQdgMEfFwRPSqFXMj4mMR8WZPx2FmZmZmZtZk5XMQjoiIfwCXk+ZAv5Wl8+BVcgNwuqSZWrpISSWbknoElusLXC3pUUlzSJ0shudz3wXOl3QfZaOe6vhP4AHgLtKUVyVfIw0Vfog0HPh9eVHHs4Cx+f535Vjf1sX3UXIp0DeX+Q2WjhJbRkREjnVB2Si5rSmMkiMNLX4EuJLKo+TuyYueDCONBJtDajDcsYFYzcy6pG7XcGutCj0dzczMzMzMGhYRy63Ym9PPIjWclacPKTueSPWRUwtYOiffXsDFFcqrNRLtPmC5udAjYnjZ8TwKI6Ii4lLyXINl+f4CHF4hfRR15lVs5H0UnzePiKu1gGWxjJ4YJWdm1m1uIDQzMzMzM7Mui4iLejoGMzNrjpYMMTYzMzMzMzMzM7PeyQ2EZmZmZmZmZmZmHcwNhGZmZmZmZmZmZh3MDYRmZmZmZmZmZmYdTGkFdrPlDRo0KKZPn97TYZi1HUkPRsSgno7DzBrj+s6s61zXmbUX13VmXddpdZ17EJqZmZmZmZmZmXUwNxCamZmZmZmZmZl1MDcQmpmZmZmZmZmZdTA3EJqZmZmZmZmZmXUwNxCamZmZmZmZmZl1MDcQmpmZmZmZmZmZdTA3EJqZmZmZmZmZmXUwNxCamZmZmZmZmZl1MDcQmpmZmZmZmZmZdTA3EJqZmZmZmZmZmXUwNxCamZmZmZmZmZl1MDcQmpmZmZmZmZmZdTBFRE/HYL2UpJeAx3s6jgZsCCzo6SDqcIzN0Q4xAuwQEf16Oggza0yb1Hft8PfPMTZPO8Tpus6sjbiua5p2iBHaI852iLGj6ro+PR2A9WqPR8Sgng6iHknTe3ucjrE52iFGSHH2dAxm1iW9vr5rh79/jrF52iFO13Vmbcd1XRO0Q4zQHnG2S4w9HUMreYixmZmZmZmZmZlZB3MDoZmZmZmZmZmZWQdzA6HVMrKnA2hQO8TpGJujHWKE9onTzJJ2+J11jM3RDjFCe8TZDjGa2VLt8DvrGJunHeJ0jL2MFykxMzMzMzMzMzPrYO5BaGZmZmZmZmZm1sHcQGhmZmZmZmZmZtbB3EBoSDpU0uOSnpJ0RoXza0kalc8/IGlAL4zx65IelTRH0jhJW7Y6xkbiLOQ7UlJIavmy7o3EKOlf8/t8RNIve1uMkraQdI+kmfnf/CM9EOOVkp6X9HCV85J0QX6GOZJ2a3WMZrZUO9R1OY5eX9+5rmtNjK7rzKw72qG+c13XHK7rmhaj67qSiPDWwRuwOvBHYGtgTWA2sFNZni8Dl+X9TwGjemGMBwLr5v0TWx1jo3HmfP2Ae4EpwKDeFiOwHTATeGc+3rgXxjgSODHv7wTM64F/78HAbsDDVc5/BLgTELAX8ECrY/TmzVva2qGu60KcPVrfua5raYyu67x589alrR3qO9d1LX2Prusai9N1Xd7cg9D2BJ6KiKcj4k3gBuDwsjyHA1fn/RuBgySpN8UYEfdExKv5cArw7hbGV9LIuwT4PvBj4PVWBpc1EuOXgIsj4u8AEfF8L4wxgPXyfn/guRbGlwKIuBf4W40shwPXRDIFWF/Spq2JzszKtENdB+1R37mua12MruvMrKvaob5zXdccruuaxHXdUm4gtM2BPxeOn81pFfNExCJgIfCulkRXdv+sUoxFXyC18Lda3Tgl7Qq8JyLuaGVgBY28y+2B7SVNlDRF0qEtiy5pJMbhwLGSngV+C3y1NaF1SVf/35rZytMOdd0yMWS9sb5zXdccruvMbGVoh/rOdV1zuK5rnY6p6/r0dADW4yp9WxTdyLMyNXx/SccCg4ADVmpEldWMU9JqwHnAsFYFVEEj77IPqTv6ENK3dfdJ2jki/rGSYytpJMajgasi4r8l7Q1cm2NcsvLDa1hP/96Y2VLtUNd1KYYerO9c1zWH6zozWxnaob5zXdccrutap6d/Z1rGPQjtWeA9heN3s3y33rfzSOpD6vpbqwtuszUSI5IOBs4EDouIN1oUW1G9OPsBOwPjJc0jzV8wusUT2jb6731bRLwVEXOBx0kVS6s0EuMXgF8BRMRkYG1gw5ZE17iG/t+aWUu0Q123TAxZb6zvXNc1h+s6M1sZ2qG+c13XHK7rWqdj6jo3ENo0YDtJW0lakzRR7eiyPKOB4/L+kcDdEdHKFvO6MeYu3j8lVSCtnluhpGacEbEwIjaMiAERMYA0n8ZhETG9t8SY3UqaGBhJG5K6pj/dy2L8E3BQjvG9pIrkhRbG2IjRwGfzqld7AQsjYn5PB2XWodqhroP2qO9c17UuRtd1ZtZV7VDfua5rQYyZ67rm6Ji6zkOMO1xELJJ0EjCGtMrQlRHxiKTvAdMjYjTwM1JX36dI3y59qhfGeA7QF/h1nmP3TxFxWC+Ms0c1GOMY4BBJjwKLgdMj4q+9LMZ/By6XdCqpe/ewVn+Ql3Q9qbv+hnnOjO8Aa+RnuIw0h8ZHgKeAV4HPtTI+M1uqHeq6LsTZo/Wd67qWxui6zsy6pB3qO9d1zeG6rnlc1y2l1n85bmZmZmZmZmZmZr2FhxibmZmZmZmZmZl1MDcQmpmZmZmZmZmZdTA3EJqZmZmZmZmZmXUwNxCamZmZmZmZmZl1MDcQmpmZmZmZmZmZdTA3ENoqR9LJkh6TdF0TyhomabPC8RWSdlrRcmvcby1Jv5c0S9LQlXWfZpL08gpcu8z7NTOzxriuay3XdWZmPcP1XWu5vutsfXo6ALOV4MvAhyNibjFRUp+IWNTFsoYBDwPPAUTEF5sSYXW7AmtExMBambr5LL3RMArv18zMGua6rn0Mw3WdmVl3ub5rH8NwfdfW3IPQVimSLgO2BkZLOlXScEkjJY0FrpE0QNJ9kmbkbZ/Ctd+Q9JCk2ZJGSDoSGARcl7/1WUfSeEmDcv6jc/6HJf2oUM7Lkn6Qy5kiaZMKcW4g6VZJc3KeXSRtDPwCGJjvt03ZNeMl/VDSBOBrkjaSdJOkaXnbN+c7IF8/S9JMSf0kDZF0r6RbJD0q6TJJq3XnOSRtJWlyvuf3y2I8PafPkfTdnDYgf+t3uaRHJI3N77LS+x2R45sj6Sfd/59gZrbqcl3nus7MrBO4vnN9Zy0WEd68rVIbMA/YMO8PBx4E1snH6wJr5/3tgOl5/8PAJGDdfLxB/jkeGFQoezzpD99mwJ+AjUg9ce8Gjsh5AviXvP9j4KwKMV4IfCfvfwiYlfeHAHdUea7xwCWF418C++X9LYDH8v7twL55v2+ObwjwOqmCXR24CziyO88BjAY+m/e/Aryc9w8BRgIifflwBzAYGAAsAgbmfL8Cji1/v8AGwOOA8vH6Pf1/yZs3b9566+a6znWdN2/evHXC5vrO9Z231m3uQWidYHREvJb31wAul/QQ8GugNOfEwcDPI+JVgIj4W50y9wDGR8QLkbqDX0f6gwnwJukPKKQKbECF6/cDrs33uht4l6T+DTzLqML+wcBFkmaR/rCvJ6kfMBE4V9LJpD/Epe7qUyPi6YhYDFyfY+jOc+ybr6f0DNkheZsJzAB2JFXUAHMjYlaFsopeJFV0V0j6BPBq/ddhZmaZ67rEdZ2Z2arN9V3i+s6aznMQWid4pbB/KvAX4AOkb0Jez+kifavSKNU491ZElMpaTOXfs0rXN3L/4rOsBuxdqCBLRkj6DfARYIqkg6uUH1XiKKn1HJViFXB2RPx0mURpAPBGIWkxsE75xRGxSNKewEHAp4CTSN/AmZlZfa7rKpfvus7MbNXi+q5y+a7vbIW5B6F1mv7A/IhYAnyG1CUbYCzweUnrQppHIqe/BPSrUM4DwAGSNpS0OnA0MKELcdwLHJPvNQRYEBEvdvFZxpL+0JLLGZh/bhMRD0XEj4DppG97APbMc0ysBgwF7u/mc0wk/ZGn9AzZGNI77Jvj2DzPvVHL2+83X9c/In4LnALUnMzXzMyqcl3nus7MrBO4vnN9Z03kBkLrNJcAx0maAmxP/tYmIn5H6so9PXfrPi3nvwq4rDTRaqmQiJgPfAu4B5gNzIiI27oQx3BgkKQ5wAjguG48y8mlMiQ9CpyQ00/Jk9LOBl4D7szpk/O9HgbmArd08zm+BnxF0jRSpQxARIwlzZ0xOXfzv5HKFXDRVeT3m/Pekd/JBNI3gmZm1nWu61zXmZl1Atd3ru+siUoTRprZKix/k3VaRHysp2MxMzNbGVzXmZlZJ3B9ZyuLexCamZmZmZmZmZl1MPcgNDMzMzMzMzMz62DuQWhmZmZmZmZmZtbB3EBoZmZmZmZmZmbWwdxAaGZmZmZmZmZm1sHcQGhmZmZmZmZmZtbB3EBoZmZmZmZmZmbWwf4/6ykw/zVcKGQAAAAASUVORK5CYII=\n", + "text/plain": [ + "<Figure size 1296x360 with 3 Axes>" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "<Figure size 1296x360 with 3 Axes>" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABQgAAAFgCAYAAAD3iJRKAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4zLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvnQurowAAIABJREFUeJzs3Xm8VWXZ//HP94AyiEIqOeAAKooIiILmGE6PDU5YIpalNGg2+Vg/NX9PZuhTSuVQTk+hv9K0HDNDfZwCMUWcFVAGhyRFnEhEkPGcc/3+WPfW5WbvM3E2+3DO9/16ndfZa7rXtZZ1Lta973XdigjMzMzMzMzMzMysY6qpdgBmZmZmZmZmZmZWPe4gNDMzMzMzMzMz68DcQWhmZmZmZmZmZtaBuYPQzMzMzMzMzMysA3MHoZmZmZmZmZmZWQfmDkIzMzMzMzMzM7MOzB2EZmZmZmZmZmZmHZg7CK1DkTRX0jJJSyS9JekPknpUO662TtI1kkLSkUXrf53Wj0nLYyTVpfub/9kybc/f/8LP5VW4JDOzdsu5rmWc68zM1h3OdS3jXGcNcQehdURHREQPYHdgD+Ds4h2UabX/f0jq3FptVdELwImFhXRNo4CXi/abGhE9in7m57YfUbTte2shdjOzjsa5rmWc68zM1h3OdS3jXGcluYPQOqyIeB24GxgEIGmypJ9LmgIsBbaTtKWkCZLelfSSpJMKx0vqJulaSQslzZJ0pqR5ue1zJf1I0nTgA0mdJZ0l6WVJiyXNlHR0bv8xkqZIukTSe5L+KWmftP41SW9Lyv8hv0bSlZLuTt/YTJG0efr2Z6Gk2ZJ2y+2/paS/SHpH0iuSTm3mLbsD2FfSJ9LyZ4HpwJvNbMfMzNYS5zrnOjOz9s65zrnOWoc7CK3DkrQ18HngmdzqrwInAxsC/wJuAOYBWwLHAOdLOjjt+1OgL7Ad8B/AV0qc5kvAYUCviKgl+1Zmf6AncC5wvaQtcvt/iuyP8ybAn4Ebyb4N2yG1f7k+PnT+WLJvyjYFVgBTgafT8q3Axelaa8gSwTSgD3AwcJqkz6Tt+0l6r5FbthyYAByXlk8A/tjIMWZmVkXOdc51ZmbtnXOdc521DncQWkd0e/qj+TDwIHB+bts1EfF8+qO/ObAf8KOIWB4RzwJXkyUbyP6Inx8RCyNiHnBpiXNdGhGvRcQygIi4JSLmR0R9RNwEvAjsmdv/lYj4Q0TUATcBWwPnRcSKiLgPWEmWVAr+GhFPRcRy4K/A8oj4Y+74wjdNewC9I+K8iFgZEf8EriIlhYh4OCJ6NeHe/RE4QVJPYARwe4l99krflBV+ioeq3160/aQSbZiZ2ZpxrnOuMzNr75zrnOusFbWH9+fNmmtkRPy9zLbXcp+3BN6NiMW5df8Chue25/fPfy65TtIJwA/JvqEC6EH2rVDBW7nPheRTvK5HA/uX23dbYMuib5M6AQ+ViLmsiHhYUm+yb7fujIhlkop3ezQi9mugmYbuv5mZtQ7nuoxznZlZ++Vcl3Gus1bhDkKzj4vc5/nAxpI2zCWTbYDX0+c3gK2AmWl564bak7Qt2bc7B5MVfK2T9Cyw2l/iCniN7Fus/q3Q1vXAOcCBrdCWmZmtfc51jXOuMzNbtznXNc65zj7GrxiblRERrwGPABdI6ippCPAN4E9pl5uB/yvpE5L6AI3N2rQBWWJ5B0DS10iFdNeCx4H3U3HdbpI6SRokaY8WtHUpWW2Of7RuiGZmtrY515XlXGdm1k4415XlXGcf4w5Cs4Z9iWzY+HyyWhA/jYj707bzyArdvgL8nax47IpyDUXETOAisoKzbwGDgSmVCrzo3HXAEcBQsngXkNXd6AkgaX9JS5rY1rsRMTEioswue6fZt/I/+YR1R9G2v7b8yszMrBU4163elnOdmVn74ly3elvOdfYxKv+/BTNrDknfBo6LiBHVjsXMzKwSnOvMzKy9c66zjsojCM1aSNIWkvaVVCNpJ+D/kH0bZWZm1i4415mZWXvnXGeW8SQlZi23PvA7oB/wHnAjcGVVIzIzM2tdznVmZtbeOdeZ4VeMzczMzMzMzMzMOjS/YmxmZmZmZmZmZtaB+RVjK2vTTTeNvn37VjsMs3XOU089tSAielc7DjNrGuc7s+ZzrjNbtzjXmTVfR8t17iC0svr27cuTTz5Z7TDM1jmS/lXtGMys6ZzvzJrPuc5s3eJcZ9Z8HS3X+RVjMzMzMzMzMzOzDswdhGZmZmZmZmZmZh2YOwjNzMzMzMzMzMw6MNcgNDNbC5566qlPdu7c+WpgEG3zy5l64Lna2tpvDhs27O1qB2NmZuse5zozM2vv1oFc15AG86A7CM3M1oLOnTtfvfnmm+/cu3fvhTU1NVHteIrV19frnXfeGfjmm29eDRxZ7XjMzGzd41xnZmbtXVvPdQ1pLA+ua72dZmbrqkG9e/d+v60mkZqamujdu/cism/CzMzMWsK5zszM2rs2nesa0lgedAehmdnaUdPWk0iKz3nBzMxayrnOzMzauzaf6xrSUB50cjQzMzMzMzMzM+vA3EFoZtZGdOrUadiAAQMG9u/ff5eDDjpohwULFnRqaVt77rnnTv/4xz+6t2Z8ZmZma8q5zszMOpp1Jfe5g9DMrI3o0qVL/ezZs2e++OKLz/fq1av2V7/6Ve9qx2RmZtaanOvMzKyjWVdynzsIzczaoL322uuD119/fX2ARYsW1ey99947Dhw4cOcdd9xx4PXXX98LYM6cOetvt912uxx33HHb7rDDDrvsu+++/ZcsWaJ8O3V1dXzhC1/oe+qpp25ZjeswMzMrx7nOzMw6mrac+9xBaGbWxtTW1vLAAw9sOHLkyPcAunfvXn/XXXe9NHPmzFkPPvjgC//1X/+1VX19PQCvvvpq11NPPfXtl1566fmePXvW/fGPf/xEoZ1Vq1Zp5MiR/fr377/80ksvnV+lyzEzM1uNc52ZmXU0bT33dW6thqz9mfH6IvqedVfJbXO7frnR4wf326bRfW6+oLZZMU064Ipm7V/O8oUXt0o7a2J0vx+1WltXd53Yam2tLft/+rpqh9DmrFixombAgAEDX3/99fUHDRq0dOTIke8D1NfX67TTTtvq0Ucf7VFTU8Pbb7+9/rx58zoD9OnTZ8U+++yzDGC33XZbOnfu3C6F9r7zne9sO3LkyHd/8YtfvFmdKzJbNzSU7zqSpuT29qAp/z5pa5r776XW1Fr/9ipwrjOrjnK5bk3+9jf372ml/5a19t+r1lCJ587WfI4spVLPls19/jtef6lIHNWwruQ+jyA0M2sjCrUp5s6dO2PlypUaN27cJwF+97vfbfzvf/+784wZM2bNnj175iabbLJq2bJlNQDrr79+FI7v1KlT1NbWfjj0fPjw4UseeuihjZYuXarVz2ZmZrb2OdeZmVlHs67kPncQmpm1MZtsskndpZde+uoVV1yx2YoVK7Ro0aJOm2666aouXbrEHXfcseH8+fPXb0o73/rWtxYceuihiw4//PDtV61aVemwzczMmsy5zszMOpq2nvvcQWhm1gbtu+++y3beeedlV1999Se++c1vvjtt2rQNBg0atPP111+/cb9+/ZY3tZ2xY8e+teuuuy79whe+0K+urq6SIZuZmTWLc52ZmXU0bTn3uQahmVkbsXTp0mfyy5MmTXqp8PnZZ5+dXeqYF1988fnC5/POO++twufHH398TuHzJZdc4qLtZmbWJjjXmZlZR7Ou5D6PIDQzMzMzMzMzM+vA3EFoZmZmZmZmZmbWgbmD0MzMzMzMzNo0SXWSns39nNXM40dKGphbnixpeCPH1Ei6VNJzkmZIekJSvwb2P7K5cZmZtRXtrgahpDpgBiCgDvheRDwiaUvg0og4pqoBliDpkYjYp9pxmJmZmZmZtVHLImJoSw6U1BkYCdwJzGzGoaOBLYEhEVEvaSvgg3I7R8QEYEJLYjQzq7Z210FILnFI+gxwATAiIuYDba5zEMCdg2YdT9+z7hrWmu3NHXfYU43tM2rUqL4TJ07suckmm9Tmi96amZlVgnOdrQ2SzgGOALoBjwDfioiQNDkt7wvcBxwJjJB0NvDFdPgoSVcCvYBvRMRDRc1vAbwREfUAETEvd97PAucDnYAFEXGwpDHA8Ij4nqTewG+BbdIhp0XEFElj07rt0u9fR8Slqc0TgNOBAKZHxFcbaGcE8Ju0LoBPR8Tilt1FM2up9pTr2vsrxhsBCwEk9ZX0XPrcVdIf0jDxZyQdmNZ3l3SzpOmSbpL0WGHYuaRDJU2V9LSkWyT1SOsPTm3MkPR7SV3S+nGSZqa2LkzrNpP0V0nT0s8+af2SQsCSzkhD16dLOjcX+yxJV0l6XtJ9krqlbTtI+ntq72lJ2zfQzgaS7kr7Pidp9Fr4b2BmbcTXv/71BRMmTHix2nGYmZlVinNdu9at6BXjwrPM5RGxR0QMIuskPDx3TK+IGBERPycb2XdGRAyNiJfT9s4RsSdwGvDTEue8GTgine8iSbsBpE67q4AvRsSuwKgSx/4GuCQi9iDrkLw6t20A8BlgT+CnktaTtAvwY+Cg1OZ/NtLO6cB30+CY/YFlxQFIOlnSk5KerFu6qESIZrYuqlSua48jCLtJehboSvaNz0El9vkuQEQMljQAuE/SjsB3gIURMUTSIOBZAEmbAmcDh0TEB5J+BPxQ0i+Ba4CDI+IFSX8Evp1+Hw0MSN9e9UrnvRR4MCKOltQJ6JEPStKhQH+yRCFggqRPA6+m9V+KiJMk3UyWHK4H/gSMi4i/SuoK1DTQTm9gfkQcls7Xs6U32czWPZ/73OeWzJkzZ/1qx2FmZlYpznXtWrlXjA+UdCbQHdgYeB64I227qZE2b0u/nwL6Fm+MiHmSdiJ7pjwImChpVDrXPyLilbTfuyXaPgQYKKmwvJGkDdPnuyJiBbBC0tvAZqn9WyNiQVGb5dqZAlws6U/AbfnRjbn4xwPjAbps0T8auRdmto6oVK5rjx2E+VeM9wb+mDr78vYDLgOIiNmS/gXsmNb/Jq1/TtL0tP9ewEBgSvrDvD4wFdgJeCUiXkj7XUvW+Xg5sBy4WtJdZLUuIPujf0Jqvw4o/hrn0PTzTFruQdbR92o6z7Np/VNA35QY+kTEX1Oby9N1l2vnIeBCSb8A7iwxhB5JJwMnA3TaqHfxZjMzMzMzszYhDZC4kuy13tfS67tdc7uUrReYrEi/6yjzbJw68u4G7pb0Flktw/vJXuttSA2wd0R8bGRfep5ckVtVOLfKtFmyHWBcetb8PPCopEMiYnYjMZmZldWuXzGOiKnApmQj5/JUYvfG1t+fhqMPjYiBEfGNcvtHRC3Z6L2/kCWQe5oYsoALcufZISL+X9pWLok0uZ3UkTmMbBKXC1K9juLYx0fE8IgY3qm7BxiamZmZmVmbVegMXJBKQDVUc34xsGED21cjaXdlk10iqQYYAvyLbLDICKUZjSVtXOLw+4Dv5dpqbIKVicCxkjYparNkO5K2j4gZEfEL4Emy15bNzFqsXXcQpteHOwH/Ltr0D+D4tM+OZAVf5wAPA8em9QOBwWn/R4F9Je2QtnVPx80mG8m3Q9rvq8CDKTn1jIj/JatnUUgGE4FvpzY6SdqoKK57ga/n6hv2kfTJctcXEe8D8ySNTPt3kdS9XDspuS2NiOuBC4HdG76DZmZmZmZmbUJxDcJxEfEeWS3AGcDtwBMNHH8jcIay+vHbN/GcnwTuUFbLfjpQS1bz8B2yt65ukzSN0q8ynwoMTzXhZwKnNHSiiHge+DnZ8+Q04OJG2jkt1ZWfRlZ/8O4mXpOZWUnt8RXjQg1CyEbSnRgRdbmaDZANQ/+tpBlkf+THRMQKZTNYXZteLX6GLAksioh3lM1IdYPSJCTA2anu4NeAWyR1JktIvyWrffG3NORdwA/SMf8JjJf0DbJRgN8m+/YJgIi4T9LOwNQU7xLgK2nfcr4K/E7SecAqYFQD7ewA/EpSfdr32026o2ZmZmZmZlUUEZ3KrD+brF588foDipankJWNKjggt20BpWsQ3kOZt8Ei4m6KOuUi4hqyGvWFNlebFDIixhYtD8p9vpasbFV+e7l2vl8qLjOzlmp3HYQNJI65wKD0eTkwpsRuy4GvRMTy9K3SRLIh5ETEJGCPEu1OBHYrWv0G2SvGxfu+BRxVYn2P3Off8NF09Xn5xHFh7vOLlJiIpUw7L5ONLjSzKmvK9PWt7Ygjjuj36KOPbrhw4cLOm2222ZCzzjpr/g9+8IMFazsOMzPrGJzrzMysvWtPua7ddRCuoe7AA5LWIxv59+2IWFnlmMzMWsUdd9zxSrVjMDMzqyTnOjMza+8qlevcQZgTEYuB4dWOw8zMzMzMzMzMbG1p15OUmJmZrQlJdUUF0c9q5vEj06RXheXJkir6RZSkvqmYeqn1y4qu54QWnuM8SYesebSVk673y9WOw8zMzMxsXeARhGZmZuUti4ihje+2ujR51UjgTmBmq0bVci+39HryIuKcUusldYqIhibWWpv6Al8G/lzlOMzMzMzM2jx3EJqZmTWTpHOAI4BuwCPAtyIiJE1Oy/sC9wFHAiMknQ18MR0+StKVQC/gGxHxUFHbPYC/AZ8A1gPOjoi/SepLNlviw8A+wOvAURGxTNIw4PfA0rS9udezhGxiq8OBZWQTai0HpgHbRUS9pO7AHGA74Crgzoi4VdLcdO5DgcslzQZ+S1bX92Xg6xGxMN2bx4AD89cuaQxZR2onsgm5LgLWB74KrAA+HxHvpsnDrgB6p+s8KSJmS7oGeJ+sRMjmwJkRcSswDthZ0rPAtRFxSXPvi5mZWXsxuE9Pnhx3WIkti1rc5ozmHnBii0/VJDtXtvkWWm0+0TZvLPtXrOXmeLMyQTSLqh3AWuYOQjOzahjbc1jrtreowdmzXnrppfWOP/74fu+88856NTU1nHjiie/85Cc/ebtVY2ifuqUOpoILIuIm4PKIOA9A0nVkHWt3pH16RcSItK0/qSMtLQN0jog9JX0e+ClQ/KrucuDoiHhf0qbAo5ImpG39gS9FxEmSbibrdLwe+APw/Yh4UNKvGrie7Yuu5/upg3ID4NGI+LGkX5J1vv1M0jRgBPAAWYfovRGxKl3Hx2KOiP3SNU7PxXJeusbT0n7lrn0QsBvQFXgJ+FFE7CbpEuAE4NfAeOCUiHhR0qeAK/noX91bAPsBA4AJwK3AWcDpEXF4qRsh6WTgZIBOG/Vu4JaZWYut5VwHzndmZraWtaNc5w5CM7MOYL311uOiiy6at99++y1duHBhzW677Tbw85///PvDhg1bXu3Y2rhyrxgfKOlMslFyGwPP81EH4U2NtHlb+v0U2WuwxQScL+nTQD3QB9gsbXslIgodfE8BfSX1JOuUfDCtvw74XJlzl3vFeCXZq9CFdv8jdy2jyToIjyPrlCvlJoASsVwL3JLbr9y1P5AmClssaREf3csZwJA0qnIf4JZc52SX3PG3R0Q9MFPSZjRBRIwn63Skyxb9oynHmFnb53xnZmbtXaVynTsIrazyw9ChKUPRmzTkvJnDzFtv2Pi6N9S7IZUbBl5JY6sdQAW1vcHo22677aptt912FcAnPvGJ+u23337Zq6++ur4fmJpPUleyjrLhEfGapLFkI98KPmikiRXpdx2l8/DxZK/RDkuj9ebm2l+R26+O7BVnAWvawbUqIgpt5OOaAFwgaWNgGDCpzPGNXXNBuWvPX1d9brk+7VcDvNdA/cT88W3v/4BmttY435mZWXtXqVznWYzNzDqYOXPmrD9z5szuI0aMWFLtWNZRhc66BWlk2zEN7LsY2LCZ7fcE3k6dgwcC2za0c0S8ByyStF9adXwzz9dQ20uAx8nqE97Z2AQkEbEIWCip8K3FV4EHGzikqXG8D7wiaRSAMrs2clhL7r2ZtSPOd2Zm1t61Zq5zB6GZWQeyaNGimi984Qvbjxs37rWNN964vtrxrAO6SXo29zMudchdRTZQ+nbgiQaOvxE4Q9IzaZKNpvgTMFzSk2SdfbObcMzXgCskTSWbZKSc7Yuu59QmtH0T8BUaf3W64ETgV6kW4VDgvCYe15jjgW+kuojPk02k0pDpQK2kaZJ+0EoxmNk6wvnOzMzau9bOdX7F2Mysg1ixYoUOO+yw7UeNGvXuiSee+F6141kXRESnMuvPBs4usf6AouUpwMDcqgNy2xZQogZhWr93mZAG5fa7MPf5KSA/om5siXbnkr2SvJqI6JH7fCvZJB/5ZRXtPyb3uW/RtmeBvUqc44Dc5w+vPSKuAa4p1V5+W0S8Any2RLtjipZ7pN+rgIOL9zez9s/5zmx1M15fRN+z7mry/nO7frnRfQb326bF8dx8QW2Ljy1n0gFXtFpbyxde3GpttYbR/X5U0fav7jqxou0X2//T1zVr/+P1lwpFsu6qRK7zCEIzsw6gvr6e4447btsdd9xx+dixY9+qdjxmZmaV4HxnZmbtXaVynUcQmplVQxOmr29N999/f4/bb799k/79+y8bMGDAQIBzzz339dGjRzc+45CZmVlLrOVcB853Zma2lrWjXOcOQiurucPQm6opw9Wba02Gt7eWSgyTX1OtOcy+pSo9PH9Nhts3dyh9c4fCtyWf+cxnlqTXUM3MzNot5zszM2vvKpXr/IqxmZmZmZmZmZlZB+YOQjMzMzMzMzMzsw7MHYRmZmZmZmZmZmYdmDsIzczMzMzMOgBJdZKezf2c1czjR0oamFueLGl4I8fUSLpU0nOSZkh6QlK/Zp63i6S/p5hHN+fYZpxjbopvhqSZkn4mqUslztWEWLaUdGs1zm1mHZcnKTEzq4LB1w4e1prtzThxRoNFapcuXapPfepTA1auXKm6ujodccQRCy+55JL5rRmDmZlZ3trOdeB81wTLImJoSw6U1BkYCdwJzGzGoaOBLYEhEVEvaSvgg2aedzdgvZbG3gwHRsQCST2A8ennxAqfczURMR84Zm2f18yarz3lOo8gNDPrALp27RoPP/zwnDlz5sx8/vnnZ06cOHGjiRMnblDtuMzMzFqT813LSDonjex7TtJ4SUrrJ0s6X9KDwI+AI4FfpZF826fDR0l6XNILkvYv0fwWwBsRUQ8QEfMiYmFqf0kuhmMkXZM+XyPpYkkPAFcB1wNDC+dtIN4d0kjDaZKeLsQo6Yy0/3RJ5zZ2PyJiCXAKMFLSxpKuk3RULtY/STpS0hhJt0m6R9KLkn6Z2+d/JD0p6fn8OdNIxfMlTU3bd5d0r6SXJZ2S9ukr6bn0uZOkC9PIxumSvp/Wj0sjHadLurCxazKz9qNSuc4dhGZmHUBNTQ09e/asB1i5cqVqa2sL/5Y2MzNrN5zvGtWt6BXjwuu6l0fEHhExCOgGHJ47pldEjIiInwMTgDMiYmhEvJy2d46IPYHTgJ+WOOfNwBHpfBdJ2q2Jse4IHBIRXwO+CTyUO2+5eP8EXBERuwL7AG9IOhToD+wJDAWGSfp0YyePiPeBV9KxVwNfA5DUM7X9v2nXoWSjJAcDoyVtndb/OCKGA0OAEZKG5Jp/LSL2Bh4CriEbLbgXcF6JUE4G+gG7RcQQ4E+SNgaOBnZJ635W6hoknZw6IZ+sW7qosUs2s3VEpXKdOwjNzDqI2tpaBgwYMHCzzTbbdcSIEe8fdNBBTX69x8zMbF3hfNegZamTrfBzU1p/oKTHJM0ADgJ2yR1z0+rNfMxt6fdTQN/ijRExD9gJ+L9APTBR0sFNiPWWiKgrs221eCVtCPSJiL+m8y6PiKXAoennGeBpYABZp19TKLX1ILCDpE8CXwL+EhG1aZ+JEbEoIpaTvXq9bVp/rKSn03l3AQbm2p2Qfs8AHouIxRHxDrBcUq+iGA4Bfls4X0S8C7wPLAeulvQFYGmp4CNifEQMj4jhnbr3bOIlm9m6oBK5rt13EGodKMSbhqc3Ky4zs+bq3Lkzs2fPnvnqq69Of/rppzd44oknulY7JjMzs9bmfNc8kroCVwLHRMRgsld68/essYfOFel3HWVq3EfEioi4OyLOAM4nq2UIELndiv87lTxvA/GWGz4j4IJcp+gOEfH/GrkmUodjX+CFtOo64HiykYR/yO26Ive5Duicnv1OBw5OI/zuKrq+wjH1RcfXs/o9FB+/T6TOwj2Bv5Ddy3saux4za18qkevafQchq39LNq6pB+qjQrwDG9u3SL4Q72Cy4d/vlds5IiY0Jy4zszWx6aab1u23336L77jjDn+VbGZm7ZbzXZMVHioLk3M0NDnGYmDD5jSeauxtmT7XkL1y+6+0+S1JO6f1R69JvOmV4HmSRqZzdZHUHbgX+HraF0l90kjAhmLuQdYJeXuhXiLZq8CnpXM930iMG5F1cC6StBnwuSZeWyn3AaekZ1NSTcQeQM+I+N8UU6UnbzGzNqo1c11H6CAsqYHCtpUuxPvZVDB3mqSJad0YSZenz70l/SXF9oSkfdP6sZJ+n+L7p6RTc9dyQipOO03SdY20MyI3mvKZ9M2YmbVz8+fP77xgwYJOAEuWLNHkyZM32nnnnZdXOy4zM7PW5HzXqOIahOMi4j2yUXgzgNuBJxo4/kbgjPQcsX0D++V9ErhD2aQb04Fa4PK07SyyWZEnAW80pbFG4v0qcKqk6cAjwOYRcR/wZ2BqeiX5Vsp3cj6Q4nwceBX4Vu68bwGz+PjowXIxTiN7tfh54PfAlKZcWxlXp1imS5oGfDnFf2e6zgeBH6xB+2a2jqlUris5BLyd6Sbp2dzyBanWxuURcR5A6lQ7HLgj7dMrIkakbf2BOyPi1rQMqRCvpM+TFeI9pOicNwMPp87DicD1EfGMpN5kyezTEfFKKi5b7DfAJRHxsKRtyL7x2jltGwAcSJYQ5kj6H7LivT8G9o2IBbk2y7VzOvDdiJiSvnn62P+IJJ1MVgiXThv1bvDGmlnLNWX6+tb02muvrTdmzJh+dXV1RISOOuqod7/0pS+5WrWZmVXM2s514HzXmIjoVGb92cDZJdYfULQ8hY+/XXVAbtsCStcgvIcyr8CmZ6xbS6wfU7Q8GZjchHhfJKtJWLz+N2TPR2VFxGqx56XRiP2BG3LHXEM2srCwfHju88euodR5Shxf2LYAGJTW1QI/TD95ezYUr5mKRIE/AAAgAElEQVStHe0p13WEDsJlEVFqyPWBks4EugMbk327U+ggXONCvJJ2IktOB5EV4h2VzvWPiHgl7fduibYPAQbmZqDZKDfK766IWAGskPQ2sFlq/9aUkPNtlmtnCnCxpD8Bt6WiwfnYxwPjAbps0f9jtS7MbN31qU99atmsWbNmVjsOMzOzSnK+s0qQdAjZSMCLI8IdzmZWVZXKdR2hg3A1ucK2wyPiNUljqUAhXuBu4G5Jb5HVMryfogKzJdQAe0fEsqKY8+fNn3u1orUNtQOMk3QX8HngUUmHRMTsRmIyMzNrtwb36cmT4w6rdhhtQMd45p1R7QBa4sTqnXrnMuu/97u1GoZZVUXE34Ftqh2HmVklddQahNUqxDsVGFGY0bjMK8b3Ad/LtdVYwdmJwLGSNilqs2Q7kraPiBkR8QvgSbLXls3MzMzMzMzMrIPqCB2EbaYQb0S8Q1bf77ZUYLbUq8ynAsPTpCMzgVMaOlGaQevnwIOpzYsbaee0NDHLNGAZ2ShHMzMzMzMzMzProNr9K8ZtsBDv3RR1yuWL06Y2R5c4bmzR8qDc52uBa4u2l2vn+6XiMjMzMzMzMzOzjqnddxCambVFswbsPKw129t59qwmzZ5VW1vL4MGDB26++eYrH3jggZdaMwYzM7M85zqztqP59XYbr0u7RjVdK1BbtVzN1JZZbTLsdm0s+6/1MzbHm5UJolFqfJd2les6wivGZmaW/OxnP9tshx12KJ68yMzMrN1wrjMzs/auErnOHYRmZh3Eyy+/vN69997b86STTlpQ7VjMzMwqwbnOzMzau0rlOncQmpl1EN/97ne3/uUvfzmvpsZ/+s3MrH1yrjMzs/auUrnOmdPMrAO44YYbem666aa1+++//9Jqx2JmZlYJznVmZtbeVTLXeZISM7MO4OGHH+5x//339+rTp0/PFStW1HzwwQc1Rx11VL+//e1vr1Q7NjMzs9bgXGdmZu1dJXOdOwitrObPdNVUjc+I1VxrNINWa6nATFxrqnVn8mqptjsDWPNn6xrbxP2aMt/V2nXFFVe8fsUVV7wOcOedd2540UUXbeYHJjMza0+c68zKm/H6IvqedVe1wyhpbtcvVzuENTa43zbVDqGsmy+orXYIAEw64IoPPy9feHGL2xnd70eN7nN114kl1+//6etafN62opK5zh2EZmZV0NTp682s8irx0FTph51KP4i0lYeJpsg/cFjb4lxnZmbtXXvKda5BaGbWwRx++OGLH3jggZeqHYeZmVmlONeZmVl719q5zh2EZmZmZmZmZmZmHZg7CM3MzMzMzMzMzDowdxCamZmZmZmZmZl1YJ6kxMpqyzNdrW1rc2attjID1rpUoL6UckXrmztjVlNmyYLyM2WZmZmZmZmZtXXuIDQzq4IrTpk0rDXb++5vD2p09qw+ffoM3mCDDepqamro3LlzPPfcc7NaMwYzM7O8auQ6cL5rjKQ6YEZu1Y0RMa4Zx48EXoiImWl5MnB6RDzZwDE1wK+Bg4AAlgPHRsQrzYz9NGB8RCxtznFNbLtwX9YDaoFrgV9HRH1rn6sJsQwHToiIU9f2uc2sedpTrnMHoZlZB/Lggw++sMUWW6zbw0PNzMwa4XzXoGURMbQlB0rqDIwE7gRmNuPQ0cCWwJCIqJe0FfBBC0I4DbgeaPUOQnL3RdIngT8DPYGfVuBcDUqdrWU7XM3MoPVznWsQmpmZmZmZdXCSzpH0hKTnJI2XpLR+sqTzJT0I/Ag4EviVpGclbZ8OHyXpcUkvSNq/RPNbAG8URuNFxLyIWCjpG5IuycVwkqSLJW0g6S5J01I8oyWdStbJ+ICkB9L+h0qaKulpSbdI6pHWz00xT5X0pKTdJd0r6WVJpzR2LyLibeBk4HvKPCTpw05VSVMkDZE0VtLv0z36Z4qxsM/tkp6S9Lykk3Prl0j6Rdr2d0l75o4/Mu1zgKQ70+cekv4gaYak6ZK+KKmTpGvSvZkh6QeN/xc2M2uYOwjNzDqQgw8+uP8uu+yy84UXXrhptWMxMzOrFOe7BnVLnXuFn9Fp/eURsUdEDAK6AYfnjukVESMi4ufABOCMiBgaES+n7Z0jYk+yEX6lRtzdDByRzneRpN3S+huBIyWtl5a/BvwB+CwwPyJ2TfHcExGXAvOBAyPiQEmbAmcDh0TE7mQj7n6YO+drEbE38BBwDXAMsBdwXlNuUkT8k+x5+ZPA1cAYAEk7Al0iYnradQDwGWBP4Ke5a/l6RAwDhgOnStokrd8AmJy2LQZ+BvwHcHSZ2H4CLIqIwRExBJgEDAX6RMSgiBic7pmZdTCtnev8irGZWQcxZcqU2X379l31+uuvdz7ooIN23GWXXZZ/7nOfW1LtuMzMzFqT812jyr1ifKCkM4HuwMbA88AdadtNjbR5W/r9FNC3eGNEzJO0E1kNwoOAiZJGRcRESZOAwyXNAtaLiBmSVgAXSvoFcGdEPFTinHsBA4EpabDj+sDU3PYJ6fcMoEdELAYWS1ouqVdEvNfINQEo/b4F+ImkM4Cvk3U4FtwVESuAFZLeBjYD5pF1Ch6d9tka6A/8G1gJ3JOLbUVErJI0gxL3DjgEOK6wkEZe/hPYTtJlwF3AfSWDz0YungzQaaPeTbhcM1tXVCLXeQShmVkH0bdv31UAffr0qT3ssMPemzp16gbVjsnMzKy1Od81n6SuwJXAMWlE2lVA19wujdULXJF+11FmEEpErIiIuyPiDOB8slqG8NHovMLoQSLiBWAYWQfaBZLOKRU2cH8ayTg0IgZGxDdKxFSf+1xYbnSgjKTt0vW8nSZFuR84CjiWrD5h8XlI+3eWdABZx97eEbEr8Awf3c9VERHFsaXXr0vFJbKJXT4UEQuBXYHJwHfJ7uFqImJ8RAyPiOGduvds7JLNbB1SiVznDkIzsw7g/fffr1m4cGFN4fMDDzyw0ZAhQ5ZVOy4zM7PW5HzXYoXOqwWpjt8xDey7GNiwOY2nGoBbps81wBDgXwAR8RjZCLsvAzekfbYElkbE9cCFwO4lzv0osK+kHdIx3dPrv2tMUm/gt2SvXRc6564GLgWeiIh3G2miJ7AwIpZKGkA22rGl7gO+l4vtE+n16pqI+AvZK8i7lzvYzNqfSuU6v2JsZlYFTZ2+vrXMmzev89FHH70DQF1dnb74xS/++5hjjnl/bcZgZmYdy9rOdeB810TdJD2bW74nIs6SdBXZiL25wBMNHH8jcFWakKOhjsS8T6ZjuqTlx4HLc9tvBoamkXEAg8kmQqkHVgHfTuvHA3dLeiPVIRwD3JBr92zghSbGVKxwX9YDaoHrgIsLGyPiKUnv07R6f/cAp0iaDswh68xsqZ8BV0h6jmyE4rnAy8AfUmcrwP9dg/bNbA20p1y3Rh2EkurIkkjBjRExrhnHjwReiIiZaXkycHqa1r3cMTXAr8lqVwSwHDg2Il5pZuynAePTcPFWJenHZN+A1ZENG/9W+mas1L7DgRMi4tRS283MWsPAgQNXzpkzZ2a14zAzM6sk57vGRUSnMuvPJutgK15/QNHyFLLafwUH5LYtoHQNwnv4qO5eKfsBH85mHBH3AveWaOcy4LLc8iRgjxL79c19voZczcD8tqJjSt6XgjSqsYZcvb+IGFvUxqDc4ufKnKdHA8f3SL8nk70+TEQsAU4s0ZRHDZp1UJXKdWs6grBcgdtGSepMVnfiTqA5FzaabHr7IRFRL2krGq+JUcppwPVAq3YQStqbbMav3SNiRRr+vX65/VNnaNkOUTMzMzMzs/ZIUi+y0YTTImJiteMpR9IJwM+BH6ZagWZm7U5FahBKOkfSE5KekzReaVopSZMlnS/pQeBHwJFkQ8eflbR9OnyUpMclvSBp/xLNbwG8UfjDHBHz0kxO35D04bdOkk6SdLGkDSTdJWlaimd0Gg6/JfCApAfS/odKmirpaUm3pNobSJqbYp4q6clUP+NeSS9LOqVMfAvSTFZExIKImJ/a2kPSIymWxyVtKOkASXem7RtI+n26d89IOiqtHyPpNkn3SHpR0i9z1/nZFPM0SRMbaWeXdN5nJU2X1L8l/33NzMzMzMzWVES8FxE7RsSoasfSkIj4Y0RsHRG3VDsWM7NKWdMOwm6ps6nwMzqtvzwi9khDrLuRjagr6BURIyLi52RTz5+RZp16OW3vHBF7ko3w+2mJc94MHJHOd5Gk3dL6G4EjJa2XlguzYH0WmB8Ru6Z47omIS4H5wIGpdsWmZMPpD4mI3clG9P0wd87XImJv4CGy4enHkBWaPa9EfPcBW6cOzisljQCQtD5wE/CfaSarQ4DiIpI/BiZFxB7AgWSdp4WZaIaSjZ4cDIyWtHUqnnsV8MXU5qhG2jkF+E0a9TkcmFccvKSTU0fok3VLF5W4PDMzMzOzkurr6+tV7SAakuLzCDAzM7MilXrF+EBJZwLdgY2B54E70rabGmnztvT7KUrXr5gnaSeyGoQHARMljYqIiZImAYdLmgWsFxEzJK0ALpT0C+DOiHioxDn3IqujMSUNdlwfmJrbPiH9ngH0iIjFwGJJyyX1ioj3cvEtkTQM2J+sc+4mSWel63kjIp5I+70PkM5XcChZJ+fpabkrsE36PDEiFqVjZgLbAp8A/lGov5ibTatcO1OBH6fXsm+LiBdL3N/xZMV/6bJF/yjebmZmZmZWxnPvvPPOwN69ey+qqalpc/+OrK+v1zvvvNMTeK7asZiZmbU1rT6LsaSuwJXA8Ih4TdJYsg6qgsbqBa5Iv+vKxZde372bbAart8hqGU4km3r+v4DZpNmlIuKF1GH3eeACSfdFRPHIPwH3R8SXGompPve5sLxajBFRR1ZUdrKkGWRFZZ8mm1SlISIbDTjnYyulTxWdt3BvVKbNku0AsyQ9BhwG3Cvpm6mwr5mtZReNPnxYa7b3f266s9HZsxYsWNDpK1/5yrZz5szpJonx48fPPeSQQ1pSw7VN0hpOnJVr5xRgaUT8sdWCa2WpZtOXI+LKJuy7JF8QPbe+Ve5XauuRiNinJcc24xxHAgNbGqOZVV5tbe0333zzzavffPPNQVSolNEaqgeeq62t/Wa1AzEzs/ahGs91UJlnu1bvIOSjzsAFqY7fMcCtZfZdDGzYnMYl7Q68GRHzlc1oPASYDhARj0nammxGpyFp/y2BdyPieklLgDFF515ANu38FZJ2iIiXJHUHtoqIF5oTWzrfTkB9bnTeUOBfZJ2WW0raIyKekLQhq79ifC/wfUnfj4iQtFtEPNPA6aamuPtFxCuSNk6jCEu2I2k74J8RcWn6PARwB6FZB3HyySdvfeihh75/zz33/HP58uVasmRJW3x4WxMtnjgrLyJ+W2q9pM4RUbum7beSXsB3yL6Qa6lWuV8Aa6FzsHNETOCjEf1m1gYNGzbsbbIa42bWxgzu05Mnxx1W7TDKWPdLW81ofJfqKTUHdhXs/LGlgyp6rrGUms4i29I8bbdqRiWe7da0g7CbpGdzy/dExFmSriL7/8hc4IkGjr8RuCpNGnJME8/5yXRMl7T8OHB5bvvNwNCIWJiWB5PV4KsHVgHfTuvHk41AfCPVIRwD3JBr92yg2R2EQA/gsjS6oxZ4CTg5IlamGo2XSepG1jl4SNGx/w38Gpiu7N3juXy8fuPHRMQ7kk4GbkudpW8D/9FAO6OBr0haBbxJ6RqKZtYOvfvuuzWPPfbYhrfeeutcgK5du0bXrl3rqhzWWiFpLnAtcASwHlm91heAf5Lli/fSfi8B+5LliSURcaGkycAjaf0ESbcCvwd6A+8AX4uIVyVdA7xPVt91c+DMiLhV0gHAucBbZF8Y3UaWH/+TrEbvyIh4OdWU/S0flZU4LSKmpFH42wDbpd+/TnV0xwHbpxx8fzrH38hKT6wHnB0Rf2ut+xURs1OMfwY2IcvtnwWGRcSCwijFdL1jyb58G0RWXuMr6cuqYcDFZHlyATAmIt5QNknZFemeLgVOSue7BngX2A14Oo3IHx4R32vgfteQ/ZtgBPAK2Qim30dEuS8qzczMzMzWKZV6tlujDsKI6FRm/dlkHWzF6w8oWp5CVvuv4IDctgWUrkF4D3BPA2HtB3w4m3FE3Es2oq64ncuAy3LLk4A9SuzXN/f5GrJJSlbbllv3FFByJEWqP7hX0erJ6YeIWAZ8q8Rxxec9PPf5brLXrfP7l2vnAuCCUrGZWfs2e/bsLhtvvHHtqFGj+s6cObP7kCFDPrjqqqte22ijjdpTofbiL60uiIhC3dsFEbG7pO8Ap0fENyX9DTga+EMq5TA3It4qqg0LaXItAEl3AH+MiGslfR24lKzMBWSz2O8HDCAb6VbolNqV7EvTd8k6Ja+OiD0l/SfwfbJJuX4DXBIRD0vahixvFb5oHUBW03ZDYI6k/wHOAgYVRgBK6gwcHRHvp4m3HpU0ISIaKm3R5PsFfJNs4rBJEXGBpM8CJ5dpdzdgF7LJwKYA+6byFpcBR6Uvt0YDPwe+TvaF3SkR8WL673AlH32tvCPZBGJ16Yu8vFL3+wtk/3YYTPaF4iyyDt3VpC/YTgbotFHv8nfJzMzMzKwNqdSzXbt5vUxSL0kvkL0yNbHa8ZiZtSW1tbWaNWtW9+9+97vvzJo1a2b37t3rf/KTn2xe7bha2bKIGJr7yU+KVWoCrJvIRlYDHEf5SbTy6/cmG0UHcB1ZB1XB7RFRHxEzgc1y65+IiDdS/dyXyWa7h2wkYSGWQ4DLU4fdBGCjVIoC4K6IWJG+OHu7qO0CAedLmg78HehTZr+85t6v/chG/he+rFtIaY9HxLyIqAeeTcfvRDai8P50jWcDW6VSJPsAt6T1vyPr+Cu4JdX1LaXU/d4vHVMfEW8CD5S7+IgYHxHDI2J4p+49y+1mZmZmZtamVOrZrhI1CKsivSK2Y7XjMDNri/r27btys802W3nQQQd9ADB69OiF48aNa28dhA0pNQHWVGCH9OrsSOBnZY5tqNhvfoRefjIplVmfn+wqP9FVDbB3GgH+USPZaMZSk1QVO57sFd1hEbEqvSbctcR+TVXqfjW1CEu5SbWej4i98ztK2gh4r4FaiA3d+1L3u+0WijEzMzMzawWVerZrNyMIzcysvG222aZ28803Xzlt2rQuAPfdd99GO+200/Jqx1VN6fXbv5LVxZsVEf9uwmGPkI02hKxT7uFWCuc+4HuFBUmNTR5SPMlXT+Dt1Dl4ILBtK8WV9zBwbIrvULJ6h001B+gtae90/HqSdomI94FXJI1K6yVp1zWM8YuSaiRtRq50iZmZmZlZe1CpZ7t2M4LQzGxd0tTp61vTZZdd9urxxx+/3cqVK7XNNtusuOGGG+au7RgqrOTEWY0ccxPZhBtjmniOU4HfSzqDNElJs6Ms3+4V6RXhzsA/gFPK7RwR/5Y0RdJzZHVofwHcIelJstd6ZzfhnM29X+eSTeY1GngQeIOso7JRaaKuY4BLJfUku8ZfA8+TdbT+j6SzySZFuRGY1pR2S/gLcDDwHNlENI/RHqZGNDMzW0MzXl9E37PuqnYYVTG365erHUKTDe63TeM7VcnNF9RW/ByTDriixcce1Wu9Zu1/ddePKtPt/+nrPvx8vP7SrHaq8VwHlXm2cwehmVkHsc8++yx77rnnZlU7jkppYOKsvrnPT/LxCbGepOi11IgYm/t8QNG2uXw0gUZ+/Zii5R7p92TSRFTF7eW3pfqCoymSjyUtD8p9Lv7X7t6UUIilxPrm3q9FwGciojaNBDww1VVs6Hq/l/v8LPDpEud7hWxG5OL1Y4qWryFN2NXA/a6XdHpELJG0CfA4Wa1HMzMzM7N2oxLPdu4gNDMzs6bYBrhZUg2wEjipyvGUc6ekXsD6wH+nyUrMzMzMzKwB7iC0sgb36cmT4w6rdhhtxNp7Q63NDHU5sdoBrJmdy25ZbfBXqxjL/h9+PvfccytyDrNqiogXgd2qHUdjikd9mpmZmZlZ4zxJiZmZmZmZmZmZWQfmDkIzMzMzMzMzM7MOzK8Ym5lVwbyzHhrWmu1tNW7/BmfPmjZtWpfRo0dv/+H5583rcuaZZ75+zjnnvN2acZiZmZmZmXUUa/u5Dir3bOcOQjOzDmDXXXddMXv27JkAtbW1bL755rsed9xx71U7LjMzM2sbJNXx8XLYN0bEuGYcPxJ4ISJmpuXJwOkR8WQDx9QAvyYrEh3AcuDYNMN9c2I/DRgfEUubc1wT2/4x8GWgDqgHvhURj5XZdzhwQkSc2tpxmJkVVOrZzh2EZmYdzIQJEzbaZpttVuy4444rqx2LmZmZtRnLImJoSw6U1BkYCdwJzGzGoaOBLYEhEVEvaSvggxaEcBpwPdCqHYSS9gYOB3aPiBWSNgXWL7d/6gwt2yFqZtbaWvPZzh2EVtaM1xfR96y7WqWtuV2/3CrtVNrgfttUO4Qmu/mC2qqcd9IBV1TlvE2xfOHFLT52dL8flVx/ddeJTTp+/09f1+Jzr2033HDDxsccc8y/qx2HmZmZtX2SzgGOALoBj5CNoIs0QvARYF/gPuBIYISks4EvpsNHSboS6AV8IyIeKmp+C+CNiKgHiIh56ZzfAAZFxA/S8knAzsBPgJuBrYBOwH8Dm5F1Mj4gaUFEHCjpUOBcoAvwMvC1iFgiaS7wZ+BAYD3gZOACYAfgVxHx2xLxLYiIFSm+Bbn7sgfwG2ADYAVwMDCMbNTk4ZI2AC4DBpM9d4+NiL9JGpPuVXdge+CvEXFmavOzwPnp2hZExMENtLML8AeyDssa4IsR8WKp/4Zm1n615rOdJykxM+tAli9frr///e89v/rVry6sdixmZmbWpnST9GzuZ3Raf3lE7BERg8g6CQ/PHdMrIkZExM+BCcAZETE0Il5O2ztHxJ5kI/x+WuKcNwNHpPNdJGm3tP5G4EhJ66Xlr5F1hn0WmB8Ru6Z47omIS4H5wIGpc3BT4GzgkIjYnWxE3w9z53wtIvYGHgKuAY4B9gLOKxHffcDWkl6QdKWkEQCS1gduAv4zInYFDgGWFR37Y2BSROxB1iH5q9TZBzCUbPTkYGC0pK0l9QauIuvo2xUY1Ug7pwC/SaM+hwPzSsRvZu1Yaz/beQShmVkHcuutt/YcOHDg0q233ro6Q1DNzMysrSr3ivGBks4kG/G2MfA8cEfadlMjbd6Wfj8F9C3eGBHzJO1EVoPwIGCipFERMVHSJOBwSbOA9SJihqQVwIWSfgHcWWJEImSdfQOBKZIgG2E3Nbd9Qvo9A+gREYuBxZKWS+oVER/W8UqjDocB+5N1zt0k6ax0PW9ExBNpv/cB0vkKDiXr5Dw9LXcFCq8rTYyIRemYmcC2wCeAfxTqL0bEu420MxX4cXot+7ZSowclnUw2SpJOG/UucavMbF3W2s927iA0M+tAbrzxxo2PPfbYdxvf08zMzDo6SV2BK4HhEfGapLFkHVQFjdULXJF+11Hm2TO9vns3cLekt8hqGU4Ergb+C5hNNnqQiHghddh9HrhA0n0RUTzyT8D9EfGlRmKqz30uLK8WY0TUAZOByZJmACcCT5NNqtIQkY0GnPOxldKnis5buDcq02bJdoBZkh4DDgPulfTNiJhUFPt4YDxAly36Nxavma1jWvvZzh2EZmZV0JTp61vb4sWLax5++OGNrr322n+t7XObmZnZOqnQGbhAUg+y13FvLbPvYmDD5jQuaXfgzYiYn2Y0HgJMB4iIxyRtDeye1iNpS+DdiLhe0hJgTNG5FwCPAldI2iEiXpLUHdgqIl5oTmzpfDsB9bnReUOBf5F1Wm4paY+IeELShqz+ivG9wPclfT/VbNwtIp5p4HRTU9z9IuIVSRunUYQl25G0HfDPiLg0fR4CTGqgfTOrgGo810Flnu3cQWhm1kFsuOGG9e+9996z1Y7DzMzM2qRukvL/TrgnIs6SdBXZ67hzgScaOP5G4CpJp5J1JDbFJ9MxXdLy48Dlue03A0MjolBfazBZDb56YBXw7bR+PNkIxDdSHcIxwA25ds8Gmt1BCPQALpPUC6gFXgJOjoiVqUbjZZK6kXUOHlJ07H8DvwamK3v3eC4fr9/4MRHxTnol+LbUWfo28B8NtDMa+IqkVcCblK6haGbtVCWe7dxBaGZmZmZm1sFFRKcy688m62ArXn9A0fIUstp/BQfkti2gdA3Ce4B7GghrP+CS3P73ko2oK27nMrKZfgvLk4A9SuzXN/f5GrJJSlbbllv3FLBPqcBS/cG9ilZPTj9ExDLgWyWOKz7v4bnPd5O9bp3fv1w7F/D/2bv3MKvLev//zxdgHEIhjNhKWyDCPIEk4M4UOWRleaQ0Skpxl1rbU3Zp8qu+SpZKWVIqZsgulCzxnMr20AbFEygHgQFMTcFdJoqF5AEQmPfvj8+95MNirVkzwxoGmNfjuuaaz7o/9/2+7/uzvFiue+5DdgKzmVlV+BRjMzMzMzMz225I6izpObKDU6Y3d3vMzFoCzyA0MzMzMzOz7UY6SXjv5m6HmVlL0ugBQkkbyfaiKLg5IsY1oPzxwHMRsTS9fhg4PyLmNrZN9aizJ3BvRBxQIv0ZIH8y1JURcWMj6riE7Hj6/210Q5tY6u8nI+L3zdwUMzOzZte3eyfmjjuqylFXVzne5moqZ9k6pzR1BdWzb3M3oIU669fN3QIzMzOrpq2ZQbgmIvo3pqCkNmTH198LLN2KNlTTC43tT15EXFQqXVLriNi4tfGrpCdwEuABQrNmMnbs2AFVjlfx9Kwf/vCHH5oyZUpXSeyzzz7vTJ06dXmHDh2imu0wMzMzMzNrKZrjex00zXe7qu9BKOkiSXMkLZY0MZ20hKSHJV0maSZwIXAs2QlUCyT1TsVPlPSUpOckDS4Ru6Ok6ZLmS6qRdFxK7ynpGUnXS1oi6cF0mhSSBkhaKGkWcGYj+vOWpEtTjNmSuknqJGl5Ol0KSR0k/VXSLpImSzohpS9Pz+Ox1Lf+KcYiSXdK+kDu2fykuO+SRm9Cg+0AACAASURBVEu6S9I9kpZJOkvSdyQ9neJ0Sfl6S7pf0jxJj0raJ6VPlnSVpCckvVhoFzAOGJye/XkNfSZmtuNZtmzZLhMnTuy2YMGCpc8///ySjRs3atKkSV2au11mZmZmZmZWf0313W5rZhC2l5Q/UvnyiJgKXBMRlwBImkJ2BPs9KU/niBiS7vUhW+57W3oN0CYiDpb0eeBitjwqfi0wIiL+JemDwGxJd6d7fYCvRMRpkm4Bvgj8DvgtcHZEzJR0RR396V3Un7Mj4lHg/cDsiPi+pJ8Cp0XEjyUtBIYADwHHAA9ExPrUj83aHBGHpT4uyrXlktTHb6d85fp+APBxoB3wF+DCiPi4pPHAyWRH3k8EvhkRz0v6D+BaYHgqvwfZ6V/7AHcDtwFjyJZzv3diVoGk04HTAVrv1rWOx2VmO5qNGzfq7bffbtW2bduNa9asafXhD394fXO3yczMzMyaXtNsp7GjaNptP6qpybcQ2RrbYPuRbbltyFgGb/aqYEUudYvRne1IU3y3a4olxsMkfRfoAHQBlrBpgHBqhZh3pN/zyJbBFhNwmaTDgVqgO9At3VsWEYUBvnlAT0mdyAYlZ6b0KcDnytRdbonxu2RLoQtxP53ry0iyAcIvkw3KlTIVoERbbgBuzeUr1/eHIuJN4E1Jq9n0LGuAfpI6Ap8Ebs0NTrbNlb8rImqBpZK6UUFETCQbcKTtHn289NBsJ9GrV6/1Z5555opevXr1a9u2be3gwYP/9YUvfOFfzd0uMzMzMzMzq7+m+m5X1SXGktqRDZSdEBF9gevJZr4VvF0hxLr0eyOlBy9HAV2BAWkw79Vc/HW5fIXyArZ2kGt9RBRi5Nt1N/C5tMx3ADCjTPlKfS4o1/d8v2pzr2tTvlbAGxHRP/ezb5ny2/MAuJk1oZUrV7aeNm1a57/85S81K1asWPTOO++0uvbaa73E2MzMzMzMbAfSVN/tqr0HYWGw7vU0s+2EOvK+CezawPidgNfSUt5hQI+6MkfEG8BqSYelpFENrK+u2G8BTwG/JFsqXecBJBGxGliV21vxa8DMOorUtx3/ApZJOhFAmQMrFGvMszezHdg999yz21577bVuzz333NC2bds4/vjj33jiiSc6Nne7zMzMzMzMrP6a6rvd1gwQtk+HXBR+xqUBuevJlr/eBcypo/zNwAXpwI3edeTLuwkYKGku2WDfn+tR5lRgQjqkZE0d+XoX9eecesSeCnyVykunC04hO5hlEdAfuKSe5SoZBXw97Yu4BDiuQv5FwIZ08IoPKTFrAXr27Pnu/PnzO7755putamtrmTFjxq777rvv2uZul5mZmZmZmdVfU323a/QehBHRukz6D4AflEgfWvT6cWC/XNLQ3L3XKbEHYUo/pEyTDsjl+1nueh6Qn1E3tkTc5UD7UkEjomPu+jayQz7yr1WUf3TuumfRvQXAJ0rUMTR3/V7fI2IyMLlUvPy9iFgGHFki7uii1x3T7/XAp4rzm9m2U9/j66tl+PDhbx9zzDGr+vXrt2+bNm3Yf//93/nOd76zclu2wczMzMzMbGeyrb/XQdN9t9uaQ0rMzGwHMn78+L+PHz/+783dDjMzMzPbtmpeXk3PMdPqnX95u5NKpvfttVeD6r3l8g0Nyp83Y+iERpfNW7vqyqrEKTay14VNErchJrWbXvWYgw+fUvWY28Io3d7cTdimmuK7XbX3IDQzMzMzMzMzM7MdiGcQmpmZWYvW0FkV25tyszzqo6EzQbaFrZltsj2o1owXMzMzs23JMwjNzMzMzMzMzMxaMA8QmpmZmZmZmZmZtWBeYmxm1gymz+g9oJrxPjX8hYqnZ/3oRz/60I033tg1Ijj55JNXXnTRRa9Vsw1mZmZmZmYtSXN8r4Om+W7nAUIrq2/3Tswdd1SVoq2uUpymVdPcDWiIU5qn2n2bp9p6Gl71iGMZXO+cm6jq7dhac+bMaXfjjTd2nT9//jPt2rWrHTJkyN4jRoxY3bdv33XN3TYzMzMzMzOrn6b6buclxmZmLUBNTU37gw466K1dd921dpddduHQQw99c+rUqZ2bu11mZmY7C0kbJS3I/YxpYPnjJe2Xe/2wpIHVb+lmdfaUtLiO++dJWiupUy6tv6TPN2W76mjPaEnXbGWMSyQdUc+8rSRdJWmxpBpJcyT1qiP/sQ19383MGqqpvtt5gNDMrAXo37//mieffHLXFStWtH7zzTdb/elPf+r017/+9X3N3S4zM7OdyJqI6J/7GVffgpLaAMcD+1XKu419BZgDjMil9QeaZYBwa0lqHREXRcT/1rPISGBPoF9E9CV7Dm+UyxwRdzfkfTcza4ym+m7nAUIzsxbgoIMOWnvuueeuGD58+N7Dhg3rs99++73Tpo13mTAzM2tqki5KM88WS5ooSSn9YUmXSZoJXAgcC1yRZh/2TsVPlPSUpOckbbHviaSOkqZLmp9muB2X0ntKekbS9ZKWSHpQUvt0b4CkhZJmAWfW0e7eQEfgB2QDhUh6H3AJMDK1c6SksZJuSHUsl/QFST9N7blf0i6p7KckPZ3SfyOpbUofJ2mppEWSfpbSJku6TtKjqe9H55q2Z4r7vKSf5tr7GUmz0rO4VVLHlL48vQePpec5WdIJ6d4gSU+k5/GUpF2LHsMewCsRUQsQEX+LiFWp7JGproWSpqe092Y4Suoq6fb03s+RdGhKH5v6/7CkFyWdk+vDyek5LJQ0pUKcIbnZqk+XaLuZ7aSa6rudBwjNzFqI88477/WlS5c+M3fu3Ge7dOmysU+fPmubu01mZmY7kfbafInxyJR+TUQMiogDgPZAfrCrc0QMiYhLgbuBC9LswxfS/TYRcTDwbeDiEnWuBUZExEHAMODnhQFIoA8wISL2J5v19sWU/lvgnIg4pEJ/vgL8AXgU+JikD0XEu8BFwNTUzqkpb2/gKOA44HfAQ2nG3RrgKEntgMnAyJTeBviWpC5ks/L2j4h+wI9z9fcEhqS416UYkM1gHAn0JRuo/HdJHyQbyDwiPYu5wHfyzykiDouImwsJabBzKnBuRBwIHJHam3cLcEx6P38u6eOpbFfgeuCLqeyJJZ7fL4HxETGI7NlPyt3bB/gscDBwsaRdJO0PfB8YnmKeWyHO+cCZEdEfGFyi7Wa2E2uK73aePmJm1kK8/PLLbbp3777h+eeff9+0adM6P/XUU39u7jaZmZntRNakwZpiwyR9F+gAdAGWAPeke1NL5M+7I/2eRzZgVkzAZZIOB2qB7kC3dG9ZRCzIl1e2l2DniJiZ0qcAnytT95fJBh9rJd1BNgg2oUze+yJivaQaoDVwf0qvSe3+WGrPcyn9BrLZi9eQDXJOkjQNuDcX85Y0c+95SS+SDaoBTI+I1QCSlgI9gM5ky7MfT+Oj7wNm5WKVes4fI5sdOAcgIv5VnCEi/ibpY2Qn4Q0Hpks6key9fCQilqV8/ywR/whgv03jteyWm+U3LSLWAeskvUb2ng0HbouI14tilovzOHClpJuAOyLib8UNkHQ6cDpA6926lmiime2omuK7nQcIrayal1fTc8y0Rpdf3u6kKrYm07fXXiXTb7l8Q4PizBha7v9tmtbaVVdWLdbIXhdWLVZjTWo3veoxBx8+peoxt0f1Pb6+mo499tjeb7zxRps2bdrEL37xi//r2rXrxm3dBjMzs5YkzXq7FhgYEX+VNBZol8vydoUQhRMpN1L6u9sooCswIA3QLc/Fz59muZFs9qKAqEe7+5HNQPxTbsDtRcoPEK4DSIOJ6yOiUEdtardKFYqIDZIOBj5FNiB5FtlAGSXaWXhd3K9C/D9FxFfKtK/Uc67Xs0gDefcB90l6lWyvyD/Vo2wr4JCI2GxmX3qe5fpQKmbJOMC4NKj6eWC2pCMiYrMBgoiYCEwEaLtHn4p9NbOGa47vddA03+08QGhm1kLMmzfv2eZug5mZWQtTGKx7Pe2JdwJwW5m8bwIN3UeuE/BaGhwcRjabrqyIeEPSakmHRcRjZAOMpXwFGBsRlxcSJC2T1KOR7fwz2QzGj0bEX4CvATPTM+kQEf8jaTbwl1yZEyXdAPQCPgI8C3y8TPzZwIRCfEkdgA/nZiyWa9OekgZFxJw0K29NRLw380DSQcCKiPi7pFZAP2AR2ezECZJ6RcQySV1KzCJ8kGzA84oUq39uRmcp04E7JY2PiH/kYpaMI6l3RNQANZIOIZth6dUhZi1EU3y38x6EZmZmZmZmW694D8JxEfEG2V51NcBdZCcCl3MzcEE6cKJ3HfnybgIGSppLNthXnwGiU8kGt2ZRft+6LwN3FqXdmdIfIlvymt9nsU4RsTbVe2tahlwLXEc20HivpEXATOC8XLFnU9p9wDdTjHLxVwKjgT+kWLPZtCS5XJl3yfYyvFrSQrJZge2Ksn0IuEfSYrKBwQ1ke0quJFu6e0cqW2oJ8zlk782itBT6mxXaswS4lGzgdCFQWHpULs63lR18s5DsfbyvrvhmZpV4BqGZmZmZmdlWiojWZdJ/QHaARnH60KLXj5Pto1cwNHfvdUrsQZjSyx02ckAu389y1/OAA3P5xpaI26tEWv7Qj0Fl6iQiOuaux+aup7PlDMBXyA7qKOXxiMgPGBIRk8kOOym8Pjp3PaNUuyKiZ9Hr0bnrOcAnytRPRNzPpv0Ui+/dR9GgXL596b3ZYgA1/0zS6/z7dAPZ/oz5++XinF2u3WZmjeEZhGZm20ZtbW1tyf13thepfbXN3Q4zMzMzMzPbtjxAaGa2bSxeuXJlp+11kLC2tlYrV67sBCxu7raYmZlZyxYRoyOi3F6NZmbWBLzE2MxsG9iwYcM3VqxYMWnFihUHsH3+caYWWLxhw4ZvNHdDzMzMzMzMdgT/9tCCAdWMt2JY/4qnIp944ok9p0+f3mn33Xff8Pzzzy8BePXVV1uPGDHiIy+//HLb7t27r/vjH//4YkNPNvYAoZnZNjBgwIDXgGObux1mZmZmZma24/rP//zP188999zXTj311Pf2i7344ov3GDp06JuXXXbZ89/73vf+7aKLLvq3X/3qVy83JK4HCM3MzMzMzMzMzHYAn/vc59569tln35dPu//++zvPnDnzWYAzzjjjH0OGDPkYUP0BQkkbgZpc0s0RMa4hFaU43wTeiYgbG1p2W5HUGTgpIq6tR9638qd05dK/D5wEbCRbtndGRDxZJsZA4OSIOGfrWm5mZqX4M6xs3nKfYd2A8WSnOq4C3gV+GhF3Vru9W0PSaGBgRJzV3G0xMzPb3vXt3om5445qQInVJVNrSqbW4ZSGFthk38YXLTK8apG2N2MZ3CRRd0QrmiDmdrl5fBn/+Mc/2vTo0WM9QI8ePdb/85//bPCEwPoWWBMR/RsavFhEXFcqXVKbiNiwtfGrpDPwX0DFL1elSDoEOBo4KCLWSfog8L5y+SNiLjC3MXWZmVm9+DOsniQJuAu4ISJOSmk9aOLl8ZJaR0SD9kgxMzMzM7Pq2aqN8iUtl/RDSfMl1UjaR1KrlN45l+8vkrpJGivp/JT2sKTLJM0EzpXUQ9J0SYvS771SvsmSrpL0hKQXJZ2Q0odKminpFknPSRonaZSkp1Jbeqd8XSXdLmlO+jk0pY+V9JvUjhclFWbwjQN6S1og6QpJHVN7Cn08rsJj2QN4PSLWAUTE6xHx91TnoNSPhamdu6Z+3Jvuvz+1aY6kpwt1SRot6Q5J90t6XtJPc8/2yNS2hZKmV4izf6p3QXrOfbbi7Tcz26H5M6yk4cC7+cHQiHgpIq5O9bZOceekvp6R0pXSF6d6Rqb0VpKulbRE0r2S/if3DJZLukjSY8CJkk5LcRemPnfIPcPrJD2antXRufbuWfzZKOnrksbn3r/TJF3ZgP80zMzMzMx2KLvvvvuGl156aReAl156aZcuXbo0eAJDfQcI26cvG4Wfkbl7r0fEQcCvgPMjohb4IzACQNJ/AMsj4tUScTtHxJCI+DlwDXBjRPQDbgKuyuXbAziMbGZeflnYgcC5QF/ga8DeEXEwMAk4O+X5JTA+IgYBX0z3CvYBPgscDFwsaRdgDPBCRPSPiAuAtcCI1MdhwM8l1TXT9EHg39OXmGslDUnP4X3AVODciDgQOAJYU1T2+8CM1NZhwBWS3p/u9QdGpr6OlPTvkroC1wNfTDFPrBDnm8Av00yagcDfihsv6XRJcyXN3fhO6WnlZmY7GH+G1f8zbH9gfh33vw6sTu0ZBJwmqRfwBbLPqcLn2xWS9kjpPVMfvwEcUhRvbUQcFhE3A3dExKD0efZMqqugJzAEOAq4TlK7lL7FZyNwM3Bseh4ApwK/Le6IP+/MzMzMbGfx2c9+9o1f//rXuwP8+te/3v3II498o6ExqrHE+I70ex7ZFwHIBsIuIvsf8i+n16Xk0w/JlZ8C/DR37670pW2psr2RCuZExCsAkl4gG5yDbGuEYen6CGC/3Peh3STtmq6npZl+6yS9BuRjFwi4TNLhZPsJdk/5Si5xj4i3JA0ABqc2TJU0huz5vBIRc1K+f6V254t/huxLzfnpdTtgr3Q9PSJWpzJLgR7AB4BHImJZivnPCnFmAd+X9GGyL2LPl2j/RGAiQNs9+kSpPpqZ7WD8GVbPz7AtCksTyAY3302Dgp8B+hVmAQKdgD4pzx/SMuFXlc2sHJTSb039XyHpoaIq8s/wAEk/Jlsm3RF4IHfvlhTjeUkvkg2OQonPxoj4q6QZwNGSngF2iYgttkzy552ZmZmZba0Vw/rP29Z1HnPMMb1mz56966pVq9p069at35gxY/7+wx/+8JURI0b07tGjxwf33HPPd++6664XGhq3GqcYr0u/N+bizQI+mma4HQ/8uEzZt+uIm/+f9XW5a5VJr829rs21pRVwSERsNlsvfdnKl8+3P28U0BUYEBHrJS0nG3Ar3/DsC9LDwMOSasi2Zp1f1KdSRDYb8Nmitv5HmbaqTMyScYBnJD1JNgPjAUnfiIgZFdpkZrYz82fY5paQzVTMOhFxprK9dAt75Qo4OyLyg3dI+nyZeJX2ds4/w8nA8RGxUNkBJENz94o/6wqvyz2DScD3gD9TYvagmZmZmdmO6p577llWKn3WrFnPbU3cagwQbiEiQtKdwJXAMxHxj3oUe4JspsYUsi80j1WpOQ8CZwFXAEjqHxEL6sj/JrBr7nUn4LX0xWoY2cy9siR9DKjNzc7rD7xE9iVlT0mDImJOmgFSvMT4AeBsSWenZ/jxiHi6jupmARMk9YqIZZK6pFmEJeNI+gjwYkRcla77AR4gNDPLacmfYWSfCZdJ+lZE/CqldcjdfwD4lqQZKebewMvAI8AZkm4AugCHAxcAbYFTUnpXskG/35epe1fglbQ0eFSKW3BiitEL+AjwLPDxcp2IiCfTcuODyD7rzMzMWrSal1fTc8w0AJa3O6kqMfv22qtypjJuubz657vNGDqh6jGLrV217bY1Htnrwgbln9RuehO1pHEGHz6lyesYpdubvI6WpL4DhO0l5b+Q3B8RYyqUmQrMAUbXs45zgN9IugBYSbZnUDWcQzaItoisv4+Q7cVXUkT8Q9LjkhYD9wE/Ae6RNBdYQDbQV5eOwNXKNrjfAPwFOD0i3k37Xl0tqT3Z4OARRWV/BPwCWJT2iFpOtmdVubaulHQ6cIekVsBrwKfriDMS+Kqk9WTLyy6p0Bczs52BP8Pq+RmWBkePB8ZL+i5ZX94GCv+HOolsP8D56fNlJdksyzvJllkvJJvd992IWCHpduBTwGLgOeBJoNyGf/8v3X+JbJl1fqDzWWAm2fLob0bE2rq3UgTgFqB/RKyqlNHMzMzMrKWr1wBhRLQuk94zdz2X3HKg9FpF+cfmrocW3VtOdnpicR2ji153TL8fJlvGu0W8/L2IeJ1sYKw47tii1wfkrov/pFK8qfpmbSlKmwd8skz+OcAnipLzbV0DnFGi3GSypVeF10fnru8j+xKYz18uzuXA5aXaZma2s/JnWP0/w1L6K2SzIUvdqyVbuvu9ErcvSD+b5Zd0ftqfd3fgKbLBv82ef3r9K7LDYkp5PCLOK8o/mTKfjclhwHjMzMzMzKqntra2Vq1atdoh97Cura0V2ZZGW6jvKcZmZmZmjXFvmsH5KPCjiKjXASmNJamzpOfIDqfZvtbamJmZmdmObvHKlSs7pYG2HUptba1WrlzZiWx1zxaaZA9CMzMzM9hytmUjyo9uYP43gL23pk4zMzMzs1I2bNjwjRUrVkxasWLFAex4k+5qgcUbNmz4RqmbHiA0MzMzMzMzMzOrYMCAAa8BxzZ3O5rCjjbaaWZmZmZmZmZmZlXkAUIzMzMzM7PtnKSNkhbkfsY0sPzxkvbLvX5Y0sDqt3SzOntKKrnXlaS9Jf2PpL9IekbSLZK6SRoq6d6U59iG9rOOtnxbUocGlvmEpCfT835G0tgK+f9HUuetaqiZWTPxEmMzMzMzM7Pt35qI6N+YgpLaAMcD9wJLq9qqRpDUDpgGfCci7klpw4Cu+XwRcTdwd5Wq/TbwO+CdBpS5AfhSRCyU1Br4WF2ZI+LzW9E+M7Nm5QFCK6tv907MHXfUVkRYXbW2FNSUu3FKw+Lsu7UNabThzVZzUxjL4CaJuuPb4Q60MjMzsx2UpIuAY4D2wBPAGRERkh5Orw8FHiTbM2uIpB8AX0zFT5R0LdAZ+HpEPFoUuyPwR+ADwC7ADyLij5J6AvcBjwGfBF4GjouINZIGAL8hG4h7rEyzTwJmFQYHASLioVTn0Fz9o4GBEXGWpMnAGmAfoAdwKtm3gEOAJwuHWkn6FTAoPY/bIuJiSecAewIPSXo9IoZJ+gzwQ6At8AJwakS8VdTODwGvpPZtJA2upudyNTAQCOCHEXG7pOWpva9L+ipwDvA+4EngvyJio6S3gF8CR6f+HBcRr0rqBlwHfCTV/a2IeKJUnHT/v3P1/yYixpd51mZm9eIlxmZmZmZmZtu/9kVLjEem9GsiYlBEHEA2KHZ0rkzniBgSEZeSzcS7ICL6R8QL6X6biDiYbHbdxSXqXAuMiIiDgGHAzyUV/hLaB5gQEfsDb7Bp0PG3wDkRcUgdfTkAmNeg3mc+QPYX9/OAe4DxwP5AX0mF2ZXfj4iBQD+yAdF+EXEV8HdgWBoc/CDwA+CI1Le5wHdK1DceeFbSnZLOSDMfAf4fsDoi+kZEP2BGvpCkfYGRwKFp1udGYFS6/X5gdkQcCDwCnJbSrwJmpvSDgCV1xOkPdI+IAyKiL9kzNzPbKp5BaGZmZmZmtv0rt8R4mKTvAh2ALsASssEzgKkVYt6Rfs8Depa4L+AySYcDtUB3oFu6tywiFuTLS+pENig5M6VPAT5XoQ0NcU+aHVkDvBoRNQCSlqT2LwC+JOl0su+6ewD7AYuK4nwipT+exjvfB8wqriwiLpF0E/AZslmPXwGGAkcAX87lW1VU9FPAAGBOit8eeC3de5dsqTdkz+3T6Xo4cHKKtxFYLelrZeLcA3xE0tVkS7UfLPWw0nM4HaD1bl1LZTEze48HCM3MzMzMzHZAaUbbtWTLWv+aDtFol8vydoUQ69LvjZT+bjiKbF/AARGxPi2hbVdUtlC+PdmAYtSj6UuAIfXIV669tUX11wJtJPUCzgcGRcSqtCy5HVsS8KeI+EqlCtNsy19Juh5YKWl3KvdTwA0R8f+VuLc+Igplyz33inEkHQh8FjgT+BLwnyXaPhGYCNB2jz71eV/MrAXzEmMzMzMzM7MdU2Hw6/W0L94JdeR9E9i1gfE7Aa+lwcFhZHv/lRURb5DNfDssJY0qk/X3wCclvbfhuaQjJfVtYPuK7UY2KLo67emXn72Y7/9s4FBJH011d5C0d3EwSUcVLaneSLac+kHgrFy+DxQVnQ6cIOlD6X4XSXU+u1TmWyl/a0m7lYuTlki3iojbyZY7H1QhtplZRR4gNDMzMzMz2/4V70E4Lg3IXU92lt9dwJw6yt8MXCDpaUm961nnTcBASXPJBvv+XI8ypwITJM0iO4RjCxGxhmyvxLMlPS9pKTCaTctwGyUiFgJPk81Q/A3weO72ROA+SQ9FxMpU3x8kLSIbMNynRMivke1BuIBsufSotPz3x8AHJC2WtJBsf8Z8O5aS7XH4YIr/J7LlznU5l2y5eA3Z0uP964jTHXg4tWsyUGqmoplZg3iJsZVV8/Jqeo6Z1qAyy9ud1Oj6+vbaq9Fl8265fEOD8s8YOqFB+deuurJB+etjZK8Lqx6zqUxqN725m1Avgw+f0txNMDMzM6uaiGhdJv0HZINIxelDi14/TrbvXsHQ3L3XKbEHYUovd9jIAbl8P8tdzwMOzOUbW6bdfwaOLHHrVeDhlGcy2QAYhVOK0/XyovpHl7ouqu9qspOHC69nkJ12XFZEfLlM+ltkJygXp/fMXU+lxB6QEdExd30bcFu6fhU4rkT+knHwrEEzqzLPIDQzMzMzMzMzM2vBPEBoZmZmZmZmZmbWgnmA0MzMzMzMzMzMrAXzHoRmZmbWovXt3om5446qnHG7tbrRJWuq2Iqq2WJXrx3Lvs3dgG3krF83dwvMzMysmjyD0MzMzMzMzMzMrAXzDEIzMzMzMzOzndjms+UbP/M8b6tmoTfBbPFtM4N7+DappTHGMri5m1BkbJPXsKKJ46uJ429vPIPQzMzMzMzMzMysBfMAoZmZmZmZmZmZWQvmAcJ6kNRN0u8lvShpnqRZkkZUuY63qhDjWEljqtEeMzMzMzMzMzNrGbwHYQWSBNwF3BARJ6W0HsCxzdqwEiLibuDu5m6HmZmZmZmZmZntODyDsLLhwLsRcV0hISJeioirJbWWdIWkOZIWSToDskHFlL5YUo2kkSl9qKRHJN0paamk6yS99x5IulTSQkmz06zFXSUtk7RLur+bpOWSdpF0ToqxSNLN6f5oSdek626pnoXp55OS3i9pWnq9uNAuMzMzMzMzMzNruTyDsLL9gfll7n0dWB0RIYxniwAAIABJREFUgyS1BR6X9CBwENAfOBD4IDBH0iOpzMHAfsBLwP3AF4DbgPcDsyPi+5J+CpwWET+W9DBwFNksxi8Dt0fE+rSUuFdErJPUuUTbrgJmRsQISa2BjsCRwN8j4igASZ2KC0k6HTgdoPVuXev/lMzMzMzMzGy7VPPyanqOmbbVcZa3O6kKrWm4vr32apZ66+uWyzdUPeaMoROqEmftqiurEidvZK8Lqx6z2KR20xtddvDhUxqUf5Rub3RdOxPPIGwgSRPSDLw5wGeAkyUtAJ4Edgf6AIcBf4iIjRHxKjATGJRCPBURL0bERuAPKS/Au8C96Xoe0DNdTwJOTdenAr9N14uAmyR9FSj1r9Fw4FcAqR2ryU6iP0LSTyQNTmmbiYiJETEwIga27rDF+KGZmZmZmZmZme1kPEBY2RKyGYEARMSZwKeAroCAsyOif/rpFREPpvRyoszr9RFRuN5Imt0ZEY8DPSUNAVpHxOKU5yhgAjAAmCep4mzQiHgu5a8BLpd0UaUyZmZmZmZmZma2c/MS48pmAJdJ+lZE/CqldUi/HwC+JWlGWva7N/Ay8AhwhqQbgC7A4cAFwD7AwZJ6kS0xHglMrEcbbiSbbfgjgLRv4b9HxEOSHgNOIltCnDcd+Bbwi7TE+P0pzz8j4nfp1OTRDXwWZmZmO51qLbtqCs21lGt7t70vNWusplii1hjVWtZmZmZmOw4PEFYQESHpeGC8pO8CK4G3gQuBW8mWAs9Ppx2vBI4H7gQOARaSzRD8bkSskLQPMAsYB/QlG0i8sx7NuAn4MdkgIUBr4HdpD0EB4yPijawJ7zkXmCjp62QzEr8F7AZcIakWWJ/SzMzMzMzMzMysBfMAYT1ExCtkB4SU8r30U+yC9FPsnYjY4vTgiOiYu76N7OCSgsOA2yLijXR/PZv2LszHmAxMTtevAseVqP+BMv0wMzMzMzMzM7MWyAOE2zlJVwOfAz7f3G0xMzMzMzMzM7Odjw8p2YYi4uGIOLqBZc6OiI+mA0bMzMzMzMyqRtJGSQtyP2MaWP54SfvlXj8saWD1W7pZnT0lLS6TvqaoPyc3so5LJB2x9a1tOqm/3qzWzKrCMwjNzMzMzMxarjUR0b8xBSW1IduD/V5gaVVb1XgvNLY/eRFxUal0Sa0jYuPWxq+SnmQHVv6+mdthZjsBzyA0MzMzMzOzzUi6SNIcSYslTUyHMhZmCF4maSbZwY3Hkh2EuEBS71T8RElPSXpO0uASsTtKmi5pvqQaScel9J6SnpF0vaQlkh6U1D7dGyBpoaRZwJmN6M9bki5NMWZL6iapk6TlklqlPB0k/VXSLpImSzohpS9Pz+Ox1Lf+KcYiSXdK+kDu2fykuO+SRku6S9I9kpZJOkvSdyQ9neJ0Sfl6S7pf0jxJj6ZDLkltuUrSE5JeLLSL7PDLwenZn9fQZ2JmlucBQjMzMzMzs5arfdGS3MKBitdExKCIOABoD+S3SuocEUMi4lLgbuCCiOgfES+k+20i4mDg28DFJepcC4yIiIOAYcDPCwOQQB9gQkTsD7wBfDGl/xY4JyIOqdCf3kX9KQxQvh+YHREHAo8Ap0XEamAhMCTlOQZ4IB0KuUWbI+KwiLgZuBG4MCL6ATVFfSzX9wPIZvsdDFxKdnjlx4FZQGEZ9ETg7IgYAJwPXJsrvwfZQZVHkw0MAowBHk3PfnyF52JmVicvMTYzMzMzM2u5yi0xHibpu0AHoAuwBLgn3ZtaIeYd6fc8smWwxQRcJulwoBboDnRL95ZFxIJ8eUmdyAYlZ6b0KWQHOZZSbonxu2RLoQtxP53ry0jgIeDLbD4olzcVoERbbgBuzeUr1/eHIuJN4E1Jq9n0LGuAfpI6Ap8Ebt00VkrbXPm7IqIWWCqpG/Ug6XTgdIDWu3WtTxEza8E8QGhl9e3eibnjjmpgqdWNrq+m0SWLnNKw7Ps2uILhDS6xMxnLFqtEtlNjm7FuVc5iZmZmtp2S1I5soGxgRPxV0ligXS7L2xVCrEu/N1L6O+cooCswICLWS1qei78ul28j2exFAdGQPpSwPiIKMfLtuhu4PC3zHQDMKFO+Up8LyvU936/a3OvalK8V8EYd+yfmy9frfzYjYiLZrETa7tFna5+fme3kvMTYzMzMzMzM8gqDda+nmW0n1JH3TWDXBsbvBLyWBgeHAT3qyhwRbwCrJR2WkkY1sL66Yr8FPAX8Eri30gEkaVnyqtzS5a8BM+soUt92/AtYJulEAGUOrFCsMc/ezKwkDxCamZmZmZm1XMV7EI5LA3LXky3yuQuYU0f5m4EL0oEbvevIl3cTMFDSXLLBvj/Xo8ypwIR0SMmaOvIV70F4Tj1iTwW+SuWl0wWnkB3MsgjoD1xSz3KVjAK+Lmkh2ZLu4yrkXwRsSAev+JASM9sqXmJsZmZmZmbWQkVE6zLpPwB+UCJ9aNHrx4H9cklDc/dep8QehCm93GEjB+Ty/Sx3PQ/Iz6gbWyLucrIlyVuIiI6569uA24peqyj/6Nx1z6J7C4BPlKhjaO76vb5HxGRgcql4+XsRsQw4skTc0UWvO6bf64FPFec3M2sMzyA0MzMzMzMzMzNrwTxAaGZmZmZmZmZm1oJ5ibGVVfPyanqOmQbA8nYnNXl9fXvtVTL9lss3VCX+jKETqhKnnLWrrmzS+I0xsteFzd2Esia1m97cTWDw4VOauwlmZmZmZmZmzc4zCM3MzMzMzMzMzFowDxCamZmZmZmZmZm1YF5ibGZmZmZmZrYT69u9E3PHHVWFSKurEKPhapql1gY4pfoh961apOFVi7QtjWXwVpVuiBVl0lUmfWflGYRmZrbTkbRR0oLcz5hGxvmmpJOr3b5qktRZ0n/VM+9bZdK7Sfq9pBclzZM0S9KI6ra0ZL3HNva9MTMzMzOz6vEMQjMz2xmtiYj+WxskIq4rlS6pTURU5wSlrdcZ+C/g2sYUliTgLuCGiDgppfUAjq1aC8uIiLuBu5u6HjMzMzMzq5tnEJqZWYshabmkH0qaL6lG0j6SWqX0zrl8f0mz6sZKOj+lPSzpMkkzgXMl9ZA0XdKi9HuvlG+ypKskPZFm5J2Q0odKminpFknPSRonaZSkp1Jbeqd8XSXdLmlO+jk0pY+V9JvUjhclnZOaOw7onWZKXiGpY2pPoY/HVXgsw4F384OhEfFSRFyd6m2d4s5JfT0jpSulL071jEzpe0h6JLVnsaTBKf3I1KaFkqantNGSrmlkv5F0cmrTQklT6opjZmZmZmbleQahmZntjNpLWpB7fXlETE3Xr0fEQWlZ7vkR8Q1JfwRGAL+V9B/A8oh4NZtct5nOETEEQNI9wI0RcYOk/wSuAo5P+fYADgP2IZshd1tKP5BsS5l/Ai8CkyLiYEnnAmcD3wZ+CYyPiMfSoOMDbNqGZh9gGLAr8KykXwFjgAMKMyYltQFGRMS/JH0QmC3p7oiIMs9qf2B+Hc/y68DqiBgkqS3wuKQHgYOA/qlPHwTmSHoEOAl4ICIuldQa6CCpK3A9cHhELJPUpUQ9De333sD3gUMj4vVczLrivEfS6cDpAK1361pH983MzMzMdn4eIDQzs51RXUuM70i/5wFfSNdTgYuA3wJfTq9Lyacfkis/Bfhp7t5dEVELLJXULZc+JyJeAZD0AvBgSq8hGwADOALYLzc4uZukXdP1tIhYB6yT9BqQj10g4DJJhwO1QPeUr9z+y5sXliaQDW6+GxGDgM8A/QozIYFOQJ+U5w8RsRF4Nc2sHATMAX4jaZf0HBZIGgo8EhHLACLinyWqbmi/hwO3RcTrRTFLxomIN/OVRcREYCJA2z36lBs8NTMzMzNrETxAmJO+xI0HPgGsAt4FfhoRdzZhnccC+0XEuKaqw8zMNrMu/d7Ips/BWcBH00y344Eflyn7dh1x84NM63LXKpNem3tdm2tLK+CQiFiTD54GvPLl8+3PGwV0BQZExHpJy4F2dbR7CfDF9zoRcWaaeTg31/6zI+KBovZ8vlSwiHgkDU4eBUyRdAXwBps/n1Ia2m+ViVkyjpmZWUtW8/Jqeo6Z1tzNKGl5u5Oare6+vfaqesxbLq/+NtUzhk6oesy8tauubHTZkb0uLJk+qd30epUffPiURtddH6N0e5PG35l4D8JEem+T9kci4iMRMYBsFsmHm7LeiLjbg4NmZs0rLb+9E7gSeCYi/lGPYk+QfU5ANij3WJWa8yBwVuGFpEqHrbxJtvS2oBPwWhocHAb0qFB+BtBO0rdyaR1y1w8A30ozApG0t6T3A48AI9MehV2Bw4GnlB1w8lpEXA/8N9lS5FnAEEm9UoxSS4wb2u/pwJck7V4Us6FxzMzMzMxaPA8QblJ2k/adZYN2SUNSmxZIejq3dMvMbGfTPvfv3QJJ9flDzFTgq5RfXlzsHOBUSYuArwHnNrKtpeIOTP+2LwW+WVfmNJj5ePq8uQK4KZWfSzZw+ecK5YNs1uQQScskPQXcABT+HDwJWArMl7QY+DXZDL47gUXAQrJBxu9GxApgKLBA0tNkMxN/GREryfb7u0PSQko/44b2ewlwKTAzxSz86btBcczMzMzMzEuM8+rapH1n2aD9fODMiHhcUkdgbXEDvGm7me0MIqJ1mfSeueu5ZINZ+dcqyj82dz206N5ysj8uFdcxuuh1x/T7YeDhUvHy99KeeiNLxB1b9PqA3HXx2pxDisvn21Ii/RU2zYYsvlcLfC/9FLsg/eTz30A2wFgc5z7gvqK0ycDkdN2Yfm9RV7k4ZmZmZmZWngcIy8hv0g68xE6wQTvwOHClpJuAOyLib8UN8KbtZmZmZmZmZmYtiwcIN6lrk/b/Y+fYoH2cpGnA54HZko6IiDqXnpmZmZmZmZmZ2c7NexBuUtcm7TvFBu2SekdETUT8hGzgc58K8c3MzMzMzMzMbCfnAcKkwibtO8sG7d9Om9gvBNZQtBeUmZmZmZltTtLGooOvxjSw/PGS9su9fljSwOq3dLM6e6bvLaXS1xT15+RG1nGJpCO2vrVNJ/W3eJ/ecvlKPa9Wkq7SpkMp5xQmfJSJc2xD//swM9teeIlxTl2btLMTbNAeEWeXaL+ZmZmZmZW3JiIqrewpSVIbskkI95JNONgevNDY/uRFxEWl0iW1Tnu0bw96kh0g+ftGlh8J7An0i4haSR8G3i6XOSLuBu5uZF1mZs3KMwjNzMzMzMwaSNJFaUbZYkkTlTYOTzMEL0sHGF4IHAtckWbr9U7FT5T0lKTnJA0uEbujpOmS5qeZa8el9J6SnpF0vaQlkh6U1D7dGyBpoaRZwJmN6M9bki5NMWZL6iapk6TlklqlPB0k/VXSLpImFw5xTHkukvRY6lv/FGORpDslfSD3bH5S3HdJoyXdJemetJrrLEnfkfR0itMl5est6X5J8yQ9KmmflD45zfR7QtKL2nS45DhgcHr256Xn92h6rvMlfbLCY9kDeCUiagEi4m8RsSrVeWSKsVDS9Fw/rknXXSXdnv4bmSPp0JQ+VtJv0rN4UdI5uffg5PTMFkqaUiHOkNws0Ke16XBLM7NG8QChmZmZmZlZee21+ZLcwkqdayJiUFrd0x44Olemc0QMiYhLyWaUXRAR/SPihXS/TUQcDHwbuLhEnWuBERFxEDAM+HlhABLoA0yIiP3JDkIsHLT4W+CciDikQn96F/WnMED5fmB2RBxIttf6aRGxmmw7pSEpzzHAAxGxvlSbI+KwiLgZuBG4MCL6ATVFfSzX9wPIZvsdTLaN0jsR8XGyvdwLy6Ankh0eOQA4H7g2V34P4DCy92FcShsDPJqe/XjgNeDT6bmOBK6q8KxuAY5Jz+nnkj4O2aAdcD3wxfS8TixR9pfA+IgYRPYeTcrd2wf4bOrrxWnAdX/g+8DwFPPcCnHOB85Ms0EHk20hZWbWaF5ibGZmZmZmVl65JcbDJH2X7GDDLsAS4J50r9R+43l3pN/zyJbBFhNwmaTDgVqgO9At3VsWEQvy5SV1IhuUnJnSpwCfK1N3uSXG75IthS7E/XSuLyOBh8i2Y7p2y6Lv5aNEW24Abs3lK9f3hyLiTeBNSavZ9CxrgH6SOgKfBG7dNFZK21z5u9JMv6WSulHaLsA1yg5x3AjsXSYfkM0YlPQxYHj6mS7pRLL3/JGIWJby/bNE8SOA/XJt3S03y29aRKwD1kl6jey9HQ7clraLyscsF+dx4EpJNwF3RMTfihsg6XSyffBpvVvXurpqZuYBQjMzMzMzs4aQ1I5soGxgRPxV0ligXS5L2X3qknXp90ZKfycbBXQFBkTEeknLc/HX5fJtJJu9KCAa0ocS1qeDG4vbdTdweVrmO4DscMZSKvW5oFzf8/2qzb2uTflaAW/UsX9ivrzK5DkPeBU4MMVbW6mxaSDvPuA+Sa+S7Sn5Jyo/71bAIRGx2cy+NNBX/B62ofx7WDIOME7SNODzwGxJR0TEn4vaPpFs1iVt9+iztf99mNlOzkuMzczMzMzMGqYwWPd6mtl2Qh153wQauj9cJ+C1NDg4DOhRV+aIeANYLemwlDSqgfXVFfst4Cmypa73VjqAJC1LXpVbuvw1YGYdRerbjn8By9IMPpQ5sEKx4mffiU17Cn4NaF1XYUkHSdozXbcC+gEvkS17HqJ0onFhj8QiDwJn5WJVOhhmOvAlSbsXxSwZR1LviKiJiJ8Ac8mWLZuZNZoHCM3MzMzMzMor3oNwXBqQu55s+etdwJw6yt8MXJAOkuhdR768m4CBkuaSDfb9uUJ+gFOBCcoOKalrP7riPQjPqSNvwVTgq1ReOl1wCtnBLIuA/sAl9SxXySjg65IWki3pPq5C/kXAhnTox3lksz5PkTSbbHlxpVmPHwLukbS4EIts78mVZEt370htKfVcziF7DxdJWgp8s66KImIJ2d6LM1PMKyvE+bayA3IWkr3f91Xoi5lZnbRpFrnZ5gYOHBhz585t7maY7XAkzYuIgc3dDjOrn7Z79Ik9TvlFczejpOXtTmruJmyX+vbaq7mb0CRuuXxDczcBgBlDJ1TMc9avP+XPOrMdiD/rSmuKz5Om+Le8Pv8ub421q66snKmMkb0uLJk+qd30epUffPiURtddH6N0e6PLvjr84y3qs84zCM3MzMzMzMzMzFowDxCamZmZmZmZmZm1YB4gNDMzMzMzMzMza8E8QGhmZmZmZmZmZtaCtWnuBpiZmZk1p77dOzF33FHN3YwyVjd3A7ZLNc3dgKZySnM3ILNvPfKc9esmb4aZmZltQx4gtLJqXl5NzzHTqhKroSdTNfXphFtzslRTnCC1NadG1Ve506WaS31PtaqGpj4Zy8zMzMxse+Y/hpXWJH9waoI/9tTnDzdbZ3jVI45lcL1zNqUVW1FWVWvFjsFLjM3MzMzMzMzMzFowDxCamZmZmZmZmZm1YB4gNDMzMzMzMzMza8E8QGhmZmZmZmZmZtaCeYDQzMzMzMzMzMysBfMpxmZmZmZmZmY7sZqXV9NzzLQt0pe3O+m967699nrv+pbLN5SMM2PohOo3LmftqiurHnNkrwurHnNbmNRuenM3oV4GHz6luZtQp1G6vbmbsMPwDEIzMzMzMzMzM7MWzAOEZmZmZmZmZmZmLVizDRBK2ihpgaTFkm6V1EFST0mLqxD7m5JObmTZt8qkd5P0e0kvSponaZakEVvX0uqTNFrSNc3dDjMzMzMzMzMz2zE05x6EayKiP4Ckm4BvAndUI3BEXFeNOAWSBNwF3BARJ6W0HsCx1aynRL2tI2JjU9ZhZmbW0pXbl6mp5fd92t7k96HakZTbM2tH1NT7fJmZmZnlbS9LjB8FPpquW0u6XtISSQ9Kai+pt6T5hcyS+kial67HSVoqaZGkn6W0sZLOT9cflfS/khZKmp9idZQ0Pb2ukXRchfYNB97NDzxGxEsRcXWqo7WkKyTNSe04I6UrpS9O9YxM6a0kXZv6eK+k/5F0Qrq3XNJFkh4DTpR0Woq7UNLtkjqkfJMlXSfpUUnPSTo61949Jd0v6XlJP035vy5pfO4Zniap+jvAmpmZmZmZmZnZDqXZTzGW1Ab4HHB/SuoDfCUiTpN0C/DFiPidpNWS+kfEAuBUYLKkLsAIYJ+ICEmdS1RxEzAuIu6U1I5sUPRdYERE/EvSB4HZku6OiCjTzP2B+WXuAXwdWB0RgyS1BR6X9CBwENAfOBD4IDBH0iPAoUBPoC/wIeAZ4De5eGsj4rD0fHaPiOvT9Y9TXVenfD2BIUBv4CFJhUHW/sDHgXXAs5KuBm4GFkn6bkSsT8/wjOKOSDodOB2g9W5d6+iymZmZmZmZmZntDJpzBmF7SQuAucD/Af+d0pelQUCAeWSDYACTgFMltQZGAr8H/gWsBSZJ+gLwTr4CSbsC3SPiToCIWBsR7wACLpO0CPhfoDvQrb4NlzQhzeibk5I+A5yc+vMksDvZQOdhwB8iYmNEvArMBAal9FsjojYiVgAPFVUxNXd9QJolWAOMIhusLLglxXgeeBHYJ6VPj4jVEbEWWAr0iIi3gRnA0ZL2AXaJiJrivkXExIgYGBEDW3foVN9HYmZmZmZmZmZmO6jmHCBcExH908/ZEfFuSl+Xy7ORTbMcbyebaXg0MC8i/hERG4CD073j2TQLsUBl6h4FdAUGpH0QXwXa1dHWJWSzAQGIiDOBT6UYhXrOzvWnV0Q8WEf95dIL3s5dTwbOioi+wA+L2lk847HwutwznASMJps9+NsKbTAzMzMzsx1I7iDIws+YBpY/XtJ+udcPSxpY/ZZuVmfJgyol3Snp+Nzr/7+9O4+/qqr3P/56K46BmDlctRRnMzNUNEfE9Pqz4aqVXjItafJqmWlXy67eorolZVevs6GZQ6aUI1oGhgLKICACTjkkWF65KQ04D8Dn98daRzaHM32/HM73ezjv5+OxH9+911577c/e8P2ux1lnDY9LOqtwfFPuJFKr3BWe7FXS5/N0UXPy1FFVp6eStJmkG1f0nmZmPaG3zEFYV+4NNwa4lNy4Jakv0D8ifgucQhpaW7zmReDZUsUiaa08h19/4PmIeEvSgcCWdW5/N7C2pBMLaesW9scAJ0paI99ne0nvACYCQ/MchRsBg4FpwH3AJ/NchJsAQ2rcux8wP5d9TNm5o3IZ2wBbA4/XeoiIuB94D/Bp4PqaT2xmZmZmZu2m2AljYESMaPTCPPXTEcBO9fK2yGRgH0jTLgEvA3sXzu+d81QzgPS5p2F5tFrx+N3AmcB+EbELsBcwp9r1EfFcRBzZlXuamfUWbdNAmF1H6iU3Nh/3A+7IQ4UnAKdWuOYzwMk5z2Tgn3I5gyTNIDW6/aHWTfPchEcAB0iaK2kacDXwzZzlCtJQ3pn526+fknrt3UKqQGaTGhm/kYcU3wQ8C5Ty3g8srHL7/8zn76oQ5+P5ue8ETsiNqPX8CpgUEX9vIK+ZmZmZmbW5vAji9NwDbqQk5fTxkn4oaQLps81hwDm59+E2+fKjJE3LCyPuX6HsigtA5h58j6lsAcp8bvc8ZdMU4CtVwp5EbiDMP+8ANlKyFakx9P/yfe7N958pqXTNCGD//CynqvrCkkMk3SPpl0D5FEwbAy+RGieJiJcjYm6+rtJimG/3hqxzv/GSbpT0B0nXFf499pA0OZc5TVK/GuVsKmlifr6HK/3bmJl1RY8tUhIRfSukzQN2Lhz/pCzLfsCVEbE4n59PGmJcXs7wwv6TpFWIy+1dIa1iXIV7farKuSXAf+St3Ol5Wya/pNMi4uX8bdg0cmUUEQPK8l5K6jVZyaSIOLUs/1WkYcml44+VXbMfcB5mZmZmZraqKc3zXnJ2RIwCLoqI7wFIupY0bdPtOc/6EXFAPrcdcEdE3JiPAfpExJ6SPgJ8Bzi47J6vU2EByHxuuQUogV+QRoR9NSImSDqnyrM8QJqPfU1SA+EE0qip95IWZJyU8z0P/HNEvJ7jvx4YBJwBnFb6PKS0GGOlhSUhfabcudT4VzCbNB3VXEnjgJsjovTeKi2GuXHh2moLWZLjfx/wXH6OfXMnlFHA0IiYLmk94LUa5XwCGBMRP8g9H4sj3Cg8sxegNLOG9Pgqxo2SdAtptd5KjX3t6A6lVZfXBL6fexauNPle04DZETFuZd7LzMzMzMx6xGt5jvVyB0r6BqkRaQPSHOulhq5RFfIX3Zx/FheQLCotADkYWMKyC0AutwClpP6kRskJOf1a0lzzy4iINySV5oLfC/gxqYFwH1IDW2l48RrARZIGkuZf377KcxwC7CKpNAS4P6kB801gWoXGQSJisaRDSQtNHgScJ2l34L8pWwwT3m5QbfR+z+ZrZpHe60JgfkRMz2W+mM9XK2c6cKXSVFS3Ft5zMf6RwEiAtTbdrnz+ejOzZbRNA2FEfLynY2imiBiygtcP62L+f1C9sjQzMzMzs1VQ7t12CTAoIv4saTjLLnz4SsULlyotgFhc/LCouADkW5LmFcovXzxxHVKDYqONVZNJ87j3i4i/S5oKnERqILws5zmV1MvvA6RefNWmXSotLDlmmURpCDXeQZ5uahowTdJdpN6P5zYQe637VVpUstp7qVhOLmsw8FHgWknnRMQ1DcRlZlZRu81BaGZmZmZmZo0rNdYtUFrksdYiGi+R5nnvii4tAJk7LiyUtF9OKl+IsWgS8G+kob6Q5nffC9iC1AuydP/5edqnzwClhUbKn6XawpJVKa1KvFshaSDwTI3FMIu6er8/AJtJ2iPn76e0cEzFciRtSXrvlwM/I/W0NDPrtrbpQWhmZmZmZmY1lc9B+LuIOEPS5aQ5z+eRhqZWcwNwuaSTqd2QWHQdcLvSApCzqLMAZPY50vDYV0kNYNVMJg0rPhsgIhZJeh74c24QhNQ78iZJRwH3sLQ34BxgkaTZpDnazycN5Z2ZFwV5gbQQZS1rAD+RtBmpZ+ILwAn53GeAn0r6HvAWcBRpiHXJFV25X0S8KWkocKHSYi6vkeZ7rFZEsEX4AAAbWklEQVTOEOB0SW+RFlH5bJ1nMTOryQ2EZmZmZmZmq4CIWL1K+lnAWRXSh5QdTwJ2KiQNKZxbQIU5CHN6xQUgqbIAZUQ8QBoSXDK8StzPk4bY1or5SWCXQtK3cvpbpHkDiyotLDk+b5Xu/wxV5sCvsRjmzvl8tYUsl7lfRJxU2J9O6iFZrlI5V+fNzKwpPMTYzMzMzMzMzMysg7kHoVX1/s37M2PER5tU2sIu5X6oSXet6rjuX/re5kVRsKoszt244ezf0ru1lupnMTMzMzMzM+sl3IPQzMzMzMzMzMysg7mB0MzMzMzMzMzMrIO5gdDMzMzMzMzMzKyDeQ5CMzMzMzMzs1VY9fnll84Vv8w88FXmbF8587EXdd7c7NW0ds72FTG8pwOo6f9W4NpOm1nePQjNzMwySYslzSpsZ3SznBMkfbbZ8TWTpPUlfbnBvC9XST9T0iOS5uT39cEaZQySdEF34zUzMzMzs5XHPQitqof+dyEDzvhNT4fRZfPW/nRPh8D7t9qip0MA4FdnL2p6mXcPubjpZb7+93ObXubQrb5ZMf2Ktcd1qZz9B1/bjHCsfbwWEQNXtJCIuKxSuqQ+EdH8X8zuWR/4MnBJdy6WtDfwMWC3iHhD0obAmtXyR8QMYEZ37mVmZmZmZiuXexCamZnVIWmepO9KminpIUk7Slotp69fyPeUpE0kDZd0Wk4bL+mHkiYAX5O0paRxudfdOElb5HxXSbpA0mRJT0s6MqcPkTRB0q8kPSFphKRjJE3LsWyT820k6SZJ0/O2b04fLunKHMfTkk7O4Y4Atsk9/86R1DfHU3rGw+u8lk2BBRHxBkBELIiI5/I998jPMTvH2S8/xx35/DtyTNMlPVi6l6Rhkm6W9DtJT0r6ceHdHppjmy1pXJ1y3pfvOyu/5+1W4J/fzMzMzGyV5x6EZmZmS60jaVbh+OyIGJX3F0TEbnlY7mkR8UVJtwEfB36eh9fOi4i/SMvNWLJ+RBwAIOl24JqIuFrS54ELgCNyvk2B/YAdgdHAjTn9A6Rpf/4GPA1cERF7Svoa8FXgFOB84LyIuC83Oo5h6VRBOwIHAv2AxyVdCpwB7FzqMSmpD/DxiHgx9wacKml0RESVdzUW+LakJ4DfA6MiYoKkNYFRwNCImC5pPeC1smvPBO6OiM/nBtZpkn6fzw0EdgXeyLFeCLwOXA4Mjoi5kjaoU84JwPkRcV2OZ/Xy4CUdDxwPsPp6G1V5RDMzMzOzzuAGQjMzs6VqDTG+Of98APhE3h8FfBv4OfCpfFxJMX3vwvXXAj8unLs1IpYAj0rapJA+PSLmA0j6I6lxDtJ84gfm/YOBnQqNk+tJ6pf3f5N7+r0h6XmgWHaJgB9KGgwsATbP+SrO7RwRL0vaHdg/xzBKac7GB4D5ETE953sxx128/BDgsFIvS2BtoDQ3w7iIWJiveRTYEngnMDEi5uYy/1annCnAmZLeDdwcEU9WiH8kMBJgrU23q9YIamZmtkqoNn1UcXqmRqZJatYURitj2qKilTGFUS3VpjdqRFenQOqqlTFl0jG6qellWs9zA6GZmVlj3sg/F7O0/pwCbCtpI1IvwP+qcu0rNcotNk69UdhXlfQlheMlhVhWA/aOiGV66+WGueL1xfiLjgE2AnaPiLckzSM1uFUPPGIxMB4YL+kh0pqHM8ueqRIBn4yIx8ti/WCVWFWlzIrlAI9Juh/4KDBG0hcj4u46MZmZmZmZdSzPQWhmZtZNefjtLcC5wGMR8dcGLptM6m0IqVHuviaFMxY4qXQgqd5iKy+RhhyX9Aeez42DB5J67lUlaYeyuf0GAs8AfwA2k7RHztcvD18uGgN8Vbn1UtKudWKdAhwgaaucvzTEuGI5krYGno6IC0hDtXepU76ZmZmZWUdzD0IzM7Olyucg/F1EnFHnmlHAdGBYg/c4GbhS0unAC8Dnuhxl9XIvljSHVL9PJM3FV1FE/FXSJEkPA3cCPwJulzQDmEVq6KulL3BhnvtvEfAUcHxEvClpaD63Dmn+wYPLrv0+8D/AnNy4N4+0InK1WF/IcwbeLGk14Hngn2uUMxQ4VtJbpCHS36vzLGZmZmZmHc0NhGZmZllELLeYRU4fUNifAQwpO1ZZ/uGF/SFl5+YBH6pwj2Flx33zz/GkYbzLlVc8FxELSA1j5eUOLzveubD/6bLse5dfX4ylLO0BYJ8q+acDe5UlF2N9Dfi3CtddBVxVOP5YYf9OUkNmMX+1cs4Gzq4Um5mZmZmZLc9DjM3MzMzMzMzMzDpY3QZCSWdKekTSHEmz8gTitfJfIWmnvD9P0oY18h4u6dbC8bckPVU4/hdJo+vc7xRJ69Z7jq6SdJukKWVpR5SerdUkXSXpyJ64t5mZmZmZmZmZrbpqNhBK2ps0l89uEbELaQ6hP9e6JiK+GBGPNnj/ySw7nGlv4EVJG+fjfYBJdco4BehSA6GkikPICufXB3YD1i9NiJ4dAfRIA+GKUOLeomZmZmZmZmZmtpx6jUabAgsi4g1I8xtFxHMAkg6S9KCkhyRdKWmtnD5e0qBGbh4RLwALJW2bkzYHbmLpnEb7kBoRkXSppBm5N+N3c9rJwGbAPZLuyWmHSJoiaaakX0vqm9PnSfq2pPuAo+qE9kngduAG8kqTkvYBDgPOyT0pt8nPep6kiZIek7SHpJslPSnpv0qFSfq6pIfzdkpOe4ek30iandOHFuL8kaRpedu2ENdgSZMlPV3sTSjpdEnTcy/P0rsZkGO6BJgJvKfauzEzMzMzs1WHpMX5M0tpq7fgVvn1y4yc6spnvMI1XRqJVqWM6/P1p3b12lao9F568yg5M7Na6jUQjiU1LD0h6RJJBwBIWps0ifjQiHg/abGTE7sZw2RgH0k7AE8CU/NxH2AX0sqQAGdGxKCcdoCkXSLiAuA54MCIODAPZz4LODgidgNmAF8v3Ov1iNgvIm6oE9PRwPV5OxogIiYDo4HTI2JgRPwx530zIgYDlwG3AV8BdgaGSXqXpN1JK1R+kDRh+5ck7QocCjwXER/IE8b/rnD/FyNiT+Ai0uqMJZsC+5F6dY6A1CAKbAfsCQwEdpc0OOffAbgmInYFXqnzbszMzMzMbNXwWv7MUtpGNHph/hy2QiOnujMSrTwGSf8E7BMRu0TEed2NpQf0ylFyZmb11GwgjIiXgd2B44EXgFGShpEanuZGxBM569XA4IqF1DeJ9EdyH2AKMI3UmLYr8HhEvJ7z/aukmcCDwPuoXGHtldMnSZoFHAdsWTg/ql4wkjYBtgXuy8+3SNLONS4pffvzEPBIRMzPPS6fBt5DatC7JSJeye/zZmD/nP/g3Ftw/4hYWCjz+sLPYuVya0QsyUO4N8lph+TtQVJPwR1JDYYAz0TE1Lxf792Unv/43FNzxuJXF5afNjMzMzOzNpVHVE3PI5hGSlJOHy/ph5ImAN+kbORUvvyoPMLpCUn717lVrZFob89TL2mQpPF5f3iOaSxwDamzysY5hv0lfSnHPlvSTaUedpI2kXRLTp+tNPILScfmeGdJ+mmlBrQ676M0quvt55W0jqQbcq/GUcA65WX24lFyZmY11Z2XLiIWR8T4iPgOcBJp+K2aGMNkCg2EEfESsDYwhPzNitI8gKcBB+VvoH6T85QTcFfhm7KdIuILhfOvNBDPUOCdwFxJ84AB5GHGVbyRfy4p7JeO+1DlXeXGx91JDYVnS/p28XSV/WL5Kvw8u/DM20bEz/K5V8ry13o3pbhGRsSgiBi0+rr9Kz6wmZmZmZn1auuUDTEemtMviog98gimdUi9/ErWj4gDIuIHVB451SePcjoF+E6d+1ccidaA3YHDI+LTpEbKP+YY7gVuzrF/AHgMKH2WuQCYkNN3Ax6R9F7S57p9I2IgsBg4psL9ar2PSs97IvBq/kz6gxxvJb1ilJw7f5hZV9RbpGQHSdsVkgYCzwB/AAYUvhX5DDChTlnjJG1e4dSjpG9I9if1ggOYBZxA/mYFWI/U2LUw9/D7cOH6l4B+eX8qsG8pLknrStq+SjwnSTqpwqmjgUMjYkBEDCD90S81EBbv1aiJwBE5lncAHwfulbQZqXL5BfATUmVWMrTwc5mVlCsYA3y+8C3S5oXu60UNvxszMzMzM2tr5UOMSyOpDpR0v6SHgA+RRmaV1BttdXP++QCpE0VVNUai1TM6Il6rcm5nSffm2I9haewfAi7N912cR2YdlO8/PY+eOgjYukKZtd5HpecdDPwi32sOMKdKrL1ilJw7f5hZV/Spc74vcKHSqr6LgKeA4yPidUmfA36dvwWZTpqDryKlFXS3Bf5Wfi4iQtL9QP+IeCsnTyFVJpNzntmSHgQeIQ3dLc7ZMBK4U9L8/A3LMOB65UVTSN+2PMHydiwrB0kDgC1IjWml+OZKelFpUt0bgMtzt+8jaUBEzJR0FalSALgiIh6U9P9I3faXAG+x7ByOa+V3shp5DsQa5Y/N35BNyT3iXwaOJX1LVsz3QhfejZmZmZmZrUKU5pG/BBgUEX+WNJxlR2XVG21VGs20mPqfI4mIxcB4YHxugDuONI/9IpZ2VCkfFVYrhquAI/Jnw2GkEWfVCLg6Ir5VNUP991HteYsjvKqZDHwVWB24PCJeyvcbwvKj5PaIiL/nz4y1RslV+1zYyCg5M7O6av5hj4gHWDpXQvm5caRvQMrThxT2BwAozeF3U7VvgyLio2XHV5EqgGLasCrXXghcWDi+G9ijQr4BZUkDKFukIyLmkeaIKL+22Luv+K3OkEKe8aQKsHRcPHcucG5ZmWNIvf8quTgivluWf1jZcd/C/vnA+RXKWWbuxGrvxszMzMzMVnmlxqcFefTRkcCNVfI2NHIqjxC7JiIOKkvfAVgSEU/mpNJINIB5pN59d5Kmr2pUP2C+pDVIPQj/N6ePI3W2+J88z+A7ctptks6LiOclbQD0i4hnCuV15X2UTMz3vid/xt2lSr7iKLkv57TSKLlv5ONKo+TG53Ol97+A1HnlYknbRsRTSnMvvruwHoCZWVPUnYOwGSLi4YjoVSvmRsTHIuLNno7DzMzMzMysycrnIBwREf8ALifNgX4rS+fBq+QG4HRJD2rpIiWVbErqEViuL3C1pEclzSF1shiez30XOF/SvZSNeqrjP4H7gbtIU16VfI00VPgh0nDg9+VFHc8Cxub735VjfVsX30fJpUDfXOY3WDpKbBkRETnWBWWj5LamMEqONLT4EeBKKo+SuycvejKMNBJsDqnBcMcGYjUz65K6XcOttSr0dDQzMzMzM2tYRCy3Ym9OP4vUcFaePqTseBLVR04tYOmcfHsBF1cor9ZItHuB5eZCj4jhZcfzKIyIiohLyXMNluX7C3B4hfRR1JlXsZH3UXzePCKu1gKWxTJ6YpScmVm3uYHQzMzMzMzMuiwiLurpGMzMrDlaMsTYzMzMzMzMzMzMeic3EJqZmZmZmZmZmXUwNxCamZmZmZmZmZl1MDcQmpmZmZmZmZmZdTClFdjNljdo0KCYMWNGT4dh1nYkPRARg3o6DjNrjOs7s65zXWfWXlzXmXVdp9V17kFoZmZmZmZmZmbWwdxAaGZmZmZmZmZm1sHcQGhmZmZmZmZmZtbB3EBoZmZmZmZmZmbWwdxAaGZmZmZmZmZm1sHcQGhmZmZmZmZmZtbB3EBoZmZmZmZmZmbWwdxAaGZmZmZmZmZm1sHcQGhmZmZmZmZmZtbB3EBoZmZmZmZmZmbWwdxAaGZmZmZmZmZm1sHcQGhmZmZmZmZmZtbBFBE9HYP1UpJeAh7v6TgasCGwoKeDqMMxNkc7xAiwQ0T06+kgzKwxbVLftcPfP8fYPO0Qp+s6szbiuq5p2iFGaI842yHGjqrr+vR0ANarPR4Rg3o6iHokzejtcTrG5miHGCHF2dMxmFmX9Pr6rh3+/jnG5mmHOF3XmbUd13VN0A4xQnvE2S4x9nQMreQhxmZmZmZmZmZmZh3MDYRmZmZmZmZmZmYdzA2EVsvIng6gQe0Qp2NsjnaIEdonTjNL2uF31jE2RzvECO0RZzvEaGZLtcPvrGNsnnaI0zH2Ml6kxMzMzMzMzMzMrIO5B6GZmZmZmZmZmVkHcwOhmZmZmZmZmZlZB3MDoSHpUEmPS3pK0hkVzq8laVQ+f7+kAb0wxq9LelTSHEnjJG3Z6hgbibOQ70hJIanly7o3EqOkf83v8xFJv+xtMUraQtI9kh7M/+Yf6YEYr5T0vKSHq5yXpAvyM8yRtFurYzSzpdqhrstx9Pr6znVda2J0XWdm3dEO9Z3ruuZwXde0GF3XlUSEtw7egNWBPwJbA2sCs4GdyvJ8Gbgs738KGNULYzwQWDfvn9jqGBuNM+frB0wEpgKDeluMwHbAg8A78/HGvTDGkcCJeX8nYF4P/HsPBnYDHq5y/iPAnYCAvYD7Wx2jN2/e0tYOdV0X4uzR+s51XUtjdF3nzZu3Lm3tUN+5rmvpe3Rd11icruvy5h6EtifwVEQ8HRFvAjcAh5flORy4Ou/fCBwkSb0pxoi4JyJezYdTgXe3ML6SRt4lwPeBHwOvtzK4rJEYvwRcHBF/B4iI53thjAGsl/f7A8+1ML4UQMRE4G81shwOXBPJVGB9SZu2JjozK9MOdR20R33nuq51MbquM7Ouaof6znVdc7iuaxLXdUu5gdA2B/5cOH42p1XMExGLgIXAu1oSXdn9s0oxFn2B1MLfanXjlLQr8J6IuKOVgRU08i63B7aXNEnSVEmHtiy6pJEYhwPHSnoW+C3w1daE1iVd/X9rZitPO9R1y8SQ9cb6znVdc7iuM7OVoR3qO9d1zeG6rnU6pq7r09MBWI+r9G1RdCPPytTw/SUdCwwCDlipEVVWM05JqwHnAcNaFVAFjbzLPqTu6ENI39bdK2nniPjHSo6tpJEYjwauioj/lrQ3cG2OccnKD69hPf17Y2ZLtUNd16UYerC+c13XHK7rzGxlaIf6znVdc7iua52e/p1pGfcgtGeB9xSO383y3XrfziOpD6nrb60uuM3WSIxIOhg4EzgsIt5oUWxF9eLsB+wMjJc0jzR/wegWT2jb6L/3bRHxVkTMBR4nVSyt0kiMXwB+BRARU4C1gQ1bEl3jGvp/a2Yt0Q513TIxZL2xvnNd1xyu68xsZWiH+s51XXO4rmudjqnr3EBo04HtJG0laU3SRLWjy/KMBo7L+0cCd0dEK1vM68aYu3j/lFSBtHpuhZKacUbEwojYMCIGRMQA0nwah0XEjN4SY3YraWJgJG1I6pr+dC+L8U/AQTnG95IqkhdaGGMjRgOfzate7QUsjIj5PR2UWYdqh7oO2qO+c13Xuhhd15lZV7VDfee6rgUxZq7rmqNj6joPMe5wEbFI0knAGNIqQ1dGxCOSvgfMiIjRwM9IXX2fIn279KleGOM5QF/g13mO3T9FxGG9MM4e1WCMY4BDJD0KLAZOj4i/9rIY/x24XNKppO7dw1r9QV7S9aTu+hvmOTO+A6yRn+Ey0hwaHwGeAl4FPtfK+MxsqXao67oQZ4/Wd67rWhqj6zoz65J2qO9c1zWH67rmcV23lFr/5biZmZmZmZmZmZn1Fh5ibGZmZmZmZmZm1sHcQGhmZmZmZmZmZtbB3EBoZmZmZmZmZmbWwdxAaGZmZmZmZmZm1sHcQGhmZmZmZmZmZtbB3EBoqxxJJ0t6TNJ1TShrmKTNCsdXSNppRcutcb+1JP1e0ixJQ1fWfZpJ0ssrcO0y79fMzBrjuq61XNeZmfUM13et5fqus/Xp6QDMVoIvAx+OiLnFREl9ImJRF8saBjwMPAcQEV9sSoTV7QqsEREDa2Xq5rP0RsMovF8zM2uY67r2MQzXdWZm3eX6rn0Mw/VdW3MPQlulSLoM2BoYLelUScMljZQ0FrhG0gBJ90qambd9Ctd+Q9JDkmZLGiHpSGAQcF3+1mcdSeMlDcr5j875H5b0o0I5L0v6QS5nqqRNKsS5gaRbJc3JeXaRtDHwC2Bgvt82ZdeMl/RDSROAr0naSNJNkqbnbd+c74B8/SxJD0rqJ2mIpImSbpH0qKTLJK3WneeQtJWkKfme3y+L8fScPkfSd3PagPyt3+WSHpE0Nr/LSu93RI5vjqSfdP9/gpnZqst1nes6M7NO4PrO9Z21WER487ZKbcA8YMO8Pxx4AFgnH68LrJ33twNm5P0PA5OBdfPxBvnneGBQoezxpD98mwF/AjYi9cS9Gzgi5wngX/L+j4GzKsR4IfCdvP8hYFbeHwLcUeW5xgOXFI5/CeyX97cAHsv7twP75v2+Ob4hwOukCnZ14C7gyO48BzAa+Gze/wrwct4/BBgJiPTlwx3AYGAAsAgYmPP9Cji2/P0CGwCPA8rH6/f0/yVv3rx5662b6zrXdd68efPWCZvrO9d33lq3uQehdYLREfFa3l8DuFzSQ8CvgdKcEwcDP4+IVwEi4m91ytwDGB8RL0TqDn4d6Q8mwJukP6CQKrABFa7fD7g23+tu4F2S+jfwLKMK+wcDF0maRfrDvp6kfsAk4FxJJ5P+EJe6q0+LiKcjYjFwfY6hO8+xb76e0jNkh+TtQWAmsCOpogaYGxGzKpRV9CKportC0ieAV+u/DjMzy1zXJa7rzMxWba7vEtd31nSeg9A6wSuF/VOBvwAfIH0T8npOF+lblUapxrm3IqJU1mIq/55Vur6R+xefZTVg70IFWTJC0m+AjwBTJR1cpfyoEkdJreeoFKuAsyPip8skSgOANwpJi4F1yi+OiEWS9gQOAj4FnET6Bs7MzOpzXVe5fNd1ZmarFtd3lct3fWcrzD0IrdP0B+ZHxBLgM6Qu2QBjgc9LWhfSPBI5/SWgX4Vy7gcOkLShpNWBo4EJXYhjInBMvtcQYEFEvNjFZxlL+kNLLmdg/rlNRDwUET8CZpC+7QHYM88xsRowFLivm88xifRHntIzZGNI77BvjmPzPPdGLW+/33xd/4j4LXAKUHMyXzMzq8p1nes6M7NO4PrO9Z01kRsIrdNcAhwnaSqwPflbm4j4Hakr94zcrfu0nP8q4LLSRKulQiJiPvAt4B5gNjAzIm7rQhzDgUGS5gAjgOO68Swnl8qQ9ChwQk4/JU9KOxt4Dbgzp0/J93oYmAvc0s3n+BrwFUnTSZUyABExljR3xpTczf9GKlfARVeR32/Oe0d+JxNI3wiamVnXua5zXWdm1glc37m+syYqTRhpZquw/E3WaRHxsZ6OxczMbGVwXWdmZp3A9Z2tLO5BaGZmZmZmZmZm1sHcg9DMzMzMzMzMzKyDuQehmZmZmZmZmZlZB3MDoZmZmZmZmZmZWQdzA6GZmZmZmZmZmVkHcwOhmZmZmZmZmZlZB3MDoZmZmZmZmZmZWQf7/85e1qB4hYeSAAAAAElFTkSuQmCC\n", + "text/plain": [ + "<Figure size 1296x360 with 3 Axes>" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Which rankings to look at \n", + "orders = ['order_synonym', 'order_environment', 'order_earth']\n", + "# Split data by current programma and include the total number\n", + "plot_ranking(df, 'curr_prog', orders, include_all=True)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "And which of the orderings did you prefer?" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "scrolled": false + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "<Figure size 1296x360 with 3 Axes>" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Which rankings to look at \n", + "orders = ['which_order']\n", + "# Split data by current programma, include the total number and put the graphs next to each other\n", + "plot_ranking(df, 'curr_prog', orders, include_all=True, transpose=True)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Prefixes?\n", + "The previous names for the programme did not entail any of the prefixes mentioned below. Do you think that any of the following prefixes would have an added value?" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "<Figure size 360x360 with 1 Axes>" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Which variables to look at \n", + "vars = [\"prefix\"] \n", + "# Split data by current programma, include the total numbe\n", + "plot_bar(df, 'curr_prog', vars, include_all=True)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.7.3" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/toggle_cell.py b/toggle_cell.py new file mode 100644 index 0000000000000000000000000000000000000000..5de0132cbbd343cea417bf06db5fcfe18e6e7965 --- /dev/null +++ b/toggle_cell.py @@ -0,0 +1,22 @@ +from IPython.core.display import display, HTML +toggle_code_str = ''' +<form action="javascript:code_toggle()"><input type="submit" id="toggleButton" value="Hide code"></form> +''' + +toggle_code_prepare_str = ''' + <script> + function code_toggle() { + if ($('div.cell.code_cell.rendered.selected div.input').css('display')!='none'){ + $('div.cell.code_cell.rendered.selected div.input').hide(); + } else { + $('div.cell.code_cell.rendered.selected div.input').show(); + } + } + </script> + +''' + +display(HTML(toggle_code_prepare_str + toggle_code_str)) + +def toggle_code(): + display(HTML(toggle_code_str)) \ No newline at end of file