Step1-Topic-extracition.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "6f28b6eb",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Summary of the dataset:\n",
      "         subreddit     author        date  \\\n",
      "count       458144     458144      458144   \n",
      "unique          15     314304         587   \n",
      "top     depression  [deleted]  2020/01/01   \n",
      "freq        117331         29        2056   \n",
      "\n",
      "                                                     post  \n",
      "count                                              458144  \n",
      "unique                                             394431  \n",
      "top     has anyone taken olanzapine/zyprexa or valproa...  \n",
      "freq                                                   12  \n"
     ]
    }
   ],
   "source": [
    "import pandas as pd\n",
    "\n",
    "# Load the CSV file\n",
    "file_path = \"mental_health_support.csv\"\n",
    "data = pd.read_csv(file_path)\n",
    "\n",
    "# Display the summary of the data\n",
    "print(\"Summary of the dataset:\")\n",
    "print(data.describe(include='all'))  # Includes numeric and non-numeric columns\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "f0c79c75",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[nltk_data] Downloading package punkt to /home/gulizhu/nltk_data...\n",
      "[nltk_data]   Package punkt is already up-to-date!\n",
      "[nltk_data] Downloading package stopwords to\n",
      "[nltk_data]     /home/gulizhu/nltk_data...\n",
      "[nltk_data]   Package stopwords is already up-to-date!\n",
      "[nltk_data] Downloading package wordnet to /home/gulizhu/nltk_data...\n",
      "[nltk_data]   Package wordnet is already up-to-date!\n"
     ]
    }
   ],
   "source": [
    "import pandas as pd\n",
    "from sklearn.feature_extraction.text import TfidfVectorizer\n",
    "from sklearn.cluster import KMeans\n",
    "from nltk.corpus import stopwords\n",
    "from nltk.tokenize import word_tokenize\n",
    "from nltk.stem import WordNetLemmatizer\n",
    "import nltk\n",
    "import os\n",
    "\n",
    "# Download NLTK resources\n",
    "nltk.download('punkt')\n",
    "nltk.download('stopwords')\n",
    "nltk.download('wordnet')\n",
    "\n",
    "# Load the dataset\n",
    "file_path = \"mental_health_support.csv\"\n",
    "data = pd.read_csv(file_path)\n",
    "\n",
    "# Get unique subreddits\n",
    "subreddits = data['subreddit'].unique()\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "58f7365d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array(['EDAnonymous', 'addiction', 'alcoholism', 'adhd', 'socialanxiety',\n",
       "       'anxiety', 'healthanxiety', 'autism', 'bipolarreddit', 'bpd',\n",
       "       'depression', 'lonely', 'ptsd', 'schizophrenia', 'suicidewatch'],\n",
       "      dtype=object)"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "subreddits"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "41978611",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Processing subreddit: EDAnonymous\n",
      "  Processing half-year: 2018-2\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_1375796/2662250088.py:29: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  subreddit_data['date'] = pd.to_datetime(subreddit_data['date'], errors='coerce')\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  Saved results to clustering_results/EDAnonymous_2018-2_clusters.csv\n",
      "  Processing half-year: 2019-1\n",
      "  Saved results to clustering_results/EDAnonymous_2019-1_clusters.csv\n",
      "  Processing half-year: 2019-2\n",
      "  Saved results to clustering_results/EDAnonymous_2019-2_clusters.csv\n",
      "  Processing half-year: 2020-1\n",
      "  Saved results to clustering_results/EDAnonymous_2020-1_clusters.csv\n",
      "Processing subreddit: addiction\n",
      "  Processing half-year: 2018-1\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_1375796/2662250088.py:29: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  subreddit_data['date'] = pd.to_datetime(subreddit_data['date'], errors='coerce')\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  Saved results to clustering_results/addiction_2018-1_clusters.csv\n",
      "  Processing half-year: 2018-2\n",
      "  Saved results to clustering_results/addiction_2018-2_clusters.csv\n",
      "  Processing half-year: 2019-1\n",
      "  Saved results to clustering_results/addiction_2019-1_clusters.csv\n",
      "  Processing half-year: 2019-2\n",
      "  Saved results to clustering_results/addiction_2019-2_clusters.csv\n",
      "  Processing half-year: 2020-1\n",
      "  Saved results to clustering_results/addiction_2020-1_clusters.csv\n",
      "Processing subreddit: alcoholism\n",
      "  Processing half-year: 2018-1\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_1375796/2662250088.py:29: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  subreddit_data['date'] = pd.to_datetime(subreddit_data['date'], errors='coerce')\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  Saved results to clustering_results/alcoholism_2018-1_clusters.csv\n",
      "  Processing half-year: 2018-2\n",
      "  Saved results to clustering_results/alcoholism_2018-2_clusters.csv\n",
      "  Processing half-year: 2019-1\n",
      "  Saved results to clustering_results/alcoholism_2019-1_clusters.csv\n",
      "  Processing half-year: 2019-2\n",
      "  Saved results to clustering_results/alcoholism_2019-2_clusters.csv\n",
      "  Processing half-year: 2020-1\n",
      "  Saved results to clustering_results/alcoholism_2020-1_clusters.csv\n",
      "Processing subreddit: adhd\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_1375796/2662250088.py:29: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  subreddit_data['date'] = pd.to_datetime(subreddit_data['date'], errors='coerce')\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  Processing half-year: 2018-1\n",
      "  Saved results to clustering_results/adhd_2018-1_clusters.csv\n",
      "  Processing half-year: 2018-2\n",
      "  Saved results to clustering_results/adhd_2018-2_clusters.csv\n",
      "  Processing half-year: 2019-1\n",
      "  Saved results to clustering_results/adhd_2019-1_clusters.csv\n",
      "  Processing half-year: 2019-2\n",
      "  Saved results to clustering_results/adhd_2019-2_clusters.csv\n",
      "  Processing half-year: 2020-1\n",
      "  Saved results to clustering_results/adhd_2020-1_clusters.csv\n",
      "Processing subreddit: socialanxiety\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_1375796/2662250088.py:29: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  subreddit_data['date'] = pd.to_datetime(subreddit_data['date'], errors='coerce')\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  Processing half-year: 2018-1\n",
      "  Saved results to clustering_results/socialanxiety_2018-1_clusters.csv\n",
      "  Processing half-year: 2018-2\n",
      "  Saved results to clustering_results/socialanxiety_2018-2_clusters.csv\n",
      "  Processing half-year: 2019-1\n",
      "  Saved results to clustering_results/socialanxiety_2019-1_clusters.csv\n",
      "  Processing half-year: 2019-2\n",
      "  Saved results to clustering_results/socialanxiety_2019-2_clusters.csv\n",
      "  Processing half-year: 2020-1\n",
      "  Saved results to clustering_results/socialanxiety_2020-1_clusters.csv\n",
      "Processing subreddit: anxiety\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_1375796/2662250088.py:29: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  subreddit_data['date'] = pd.to_datetime(subreddit_data['date'], errors='coerce')\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  Processing half-year: 2018-1\n",
      "  Saved results to clustering_results/anxiety_2018-1_clusters.csv\n",
      "  Processing half-year: 2018-2\n",
      "  Saved results to clustering_results/anxiety_2018-2_clusters.csv\n",
      "  Processing half-year: 2019-1\n",
      "  Saved results to clustering_results/anxiety_2019-1_clusters.csv\n",
      "  Processing half-year: 2019-2\n",
      "  Saved results to clustering_results/anxiety_2019-2_clusters.csv\n",
      "  Processing half-year: 2020-1\n",
      "  Saved results to clustering_results/anxiety_2020-1_clusters.csv\n",
      "Processing subreddit: healthanxiety\n",
      "  Processing half-year: 2018-1\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_1375796/2662250088.py:29: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  subreddit_data['date'] = pd.to_datetime(subreddit_data['date'], errors='coerce')\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  Saved results to clustering_results/healthanxiety_2018-1_clusters.csv\n",
      "  Processing half-year: 2018-2\n",
      "  Saved results to clustering_results/healthanxiety_2018-2_clusters.csv\n",
      "  Processing half-year: 2019-1\n",
      "  Saved results to clustering_results/healthanxiety_2019-1_clusters.csv\n",
      "  Processing half-year: 2019-2\n",
      "  Saved results to clustering_results/healthanxiety_2019-2_clusters.csv\n",
      "  Processing half-year: 2020-1\n",
      "  Saved results to clustering_results/healthanxiety_2020-1_clusters.csv\n",
      "Processing subreddit: autism\n",
      "  Processing half-year: 2018-1\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_1375796/2662250088.py:29: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  subreddit_data['date'] = pd.to_datetime(subreddit_data['date'], errors='coerce')\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  Saved results to clustering_results/autism_2018-1_clusters.csv\n",
      "  Processing half-year: 2018-2\n",
      "  Saved results to clustering_results/autism_2018-2_clusters.csv\n",
      "  Processing half-year: 2019-1\n",
      "  Saved results to clustering_results/autism_2019-1_clusters.csv\n",
      "  Processing half-year: 2019-2\n",
      "  Saved results to clustering_results/autism_2019-2_clusters.csv\n",
      "  Processing half-year: 2020-1\n",
      "  Saved results to clustering_results/autism_2020-1_clusters.csv\n",
      "Processing subreddit: bipolarreddit\n",
      "  Processing half-year: 2018-1\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_1375796/2662250088.py:29: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  subreddit_data['date'] = pd.to_datetime(subreddit_data['date'], errors='coerce')\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  Saved results to clustering_results/bipolarreddit_2018-1_clusters.csv\n",
      "  Processing half-year: 2018-2\n",
      "  Saved results to clustering_results/bipolarreddit_2018-2_clusters.csv\n",
      "  Processing half-year: 2019-1\n",
      "  Saved results to clustering_results/bipolarreddit_2019-1_clusters.csv\n",
      "  Processing half-year: 2019-2\n",
      "  Saved results to clustering_results/bipolarreddit_2019-2_clusters.csv\n",
      "  Processing half-year: 2020-1\n",
      "  Saved results to clustering_results/bipolarreddit_2020-1_clusters.csv\n",
      "Processing subreddit: bpd\n",
      "  Processing half-year: 2018-1\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_1375796/2662250088.py:29: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  subreddit_data['date'] = pd.to_datetime(subreddit_data['date'], errors='coerce')\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  Saved results to clustering_results/bpd_2018-1_clusters.csv\n",
      "  Processing half-year: 2018-2\n",
      "  Saved results to clustering_results/bpd_2018-2_clusters.csv\n",
      "  Processing half-year: 2019-1\n",
      "  Saved results to clustering_results/bpd_2019-1_clusters.csv\n",
      "  Processing half-year: 2019-2\n",
      "  Saved results to clustering_results/bpd_2019-2_clusters.csv\n",
      "  Processing half-year: 2020-1\n",
      "  Saved results to clustering_results/bpd_2020-1_clusters.csv\n",
      "Processing subreddit: depression\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_1375796/2662250088.py:29: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  subreddit_data['date'] = pd.to_datetime(subreddit_data['date'], errors='coerce')\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  Processing half-year: 2018-1\n",
      "  Saved results to clustering_results/depression_2018-1_clusters.csv\n",
      "  Processing half-year: 2018-2\n",
      "  Saved results to clustering_results/depression_2018-2_clusters.csv\n",
      "  Processing half-year: 2019-1\n",
      "  Saved results to clustering_results/depression_2019-1_clusters.csv\n",
      "  Processing half-year: 2019-2\n",
      "  Saved results to clustering_results/depression_2019-2_clusters.csv\n",
      "  Processing half-year: 2020-1\n",
      "  Saved results to clustering_results/depression_2020-1_clusters.csv\n",
      "Processing subreddit: lonely\n",
      "  Processing half-year: 2018-1\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_1375796/2662250088.py:29: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  subreddit_data['date'] = pd.to_datetime(subreddit_data['date'], errors='coerce')\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  Saved results to clustering_results/lonely_2018-1_clusters.csv\n",
      "  Processing half-year: 2018-2\n",
      "  Saved results to clustering_results/lonely_2018-2_clusters.csv\n",
      "  Processing half-year: 2019-1\n",
      "  Saved results to clustering_results/lonely_2019-1_clusters.csv\n",
      "  Processing half-year: 2019-2\n",
      "  Saved results to clustering_results/lonely_2019-2_clusters.csv\n",
      "  Processing half-year: 2020-1\n",
      "  Saved results to clustering_results/lonely_2020-1_clusters.csv\n",
      "Processing subreddit: ptsd\n",
      "  Processing half-year: 2018-1\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_1375796/2662250088.py:29: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  subreddit_data['date'] = pd.to_datetime(subreddit_data['date'], errors='coerce')\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  Saved results to clustering_results/ptsd_2018-1_clusters.csv\n",
      "  Processing half-year: 2018-2\n",
      "  Saved results to clustering_results/ptsd_2018-2_clusters.csv\n",
      "  Processing half-year: 2019-1\n",
      "  Saved results to clustering_results/ptsd_2019-1_clusters.csv\n",
      "  Processing half-year: 2019-2\n",
      "  Saved results to clustering_results/ptsd_2019-2_clusters.csv\n",
      "  Processing half-year: 2020-1\n",
      "  Saved results to clustering_results/ptsd_2020-1_clusters.csv\n",
      "Processing subreddit: schizophrenia\n",
      "  Processing half-year: 2018-1\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_1375796/2662250088.py:29: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  subreddit_data['date'] = pd.to_datetime(subreddit_data['date'], errors='coerce')\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  Saved results to clustering_results/schizophrenia_2018-1_clusters.csv\n",
      "  Processing half-year: 2018-2\n",
      "  Saved results to clustering_results/schizophrenia_2018-2_clusters.csv\n",
      "  Processing half-year: 2019-1\n",
      "  Saved results to clustering_results/schizophrenia_2019-1_clusters.csv\n",
      "  Processing half-year: 2019-2\n",
      "  Saved results to clustering_results/schizophrenia_2019-2_clusters.csv\n",
      "  Processing half-year: 2020-1\n",
      "  Saved results to clustering_results/schizophrenia_2020-1_clusters.csv\n",
      "Processing subreddit: suicidewatch\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_1375796/2662250088.py:29: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  subreddit_data['date'] = pd.to_datetime(subreddit_data['date'], errors='coerce')\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  Processing half-year: 2018-1\n",
      "  Saved results to clustering_results/suicidewatch_2018-1_clusters.csv\n",
      "  Processing half-year: 2018-2\n",
      "  Saved results to clustering_results/suicidewatch_2018-2_clusters.csv\n",
      "  Processing half-year: 2019-1\n",
      "  Saved results to clustering_results/suicidewatch_2019-1_clusters.csv\n",
      "  Processing half-year: 2019-2\n",
      "  Saved results to clustering_results/suicidewatch_2019-2_clusters.csv\n",
      "  Processing half-year: 2020-1\n",
      "  Saved results to clustering_results/suicidewatch_2020-1_clusters.csv\n"
     ]
    }
   ],
   "source": [
    "# Preprocessing function for text\n",
    "def preprocess_text(text):\n",
    "    stop_words = set(stopwords.words('english'))\n",
    "    lemmatizer = WordNetLemmatizer()\n",
    "    tokens = word_tokenize(text.lower())  # Tokenization\n",
    "    filtered_tokens = [lemmatizer.lemmatize(word) for word in tokens if word.isalnum() and word not in stop_words]\n",
    "    return ' '.join(filtered_tokens)\n",
    "\n",
    "# Function to extract keywords from clusters\n",
    "def extract_keywords(tfidf_matrix, feature_names, cluster_labels, top_n=10):\n",
    "    clusters = {}\n",
    "    for cluster in set(cluster_labels):\n",
    "        cluster_indices = [i for i, label in enumerate(cluster_labels) if label == cluster]\n",
    "        cluster_tfidf = tfidf_matrix[cluster_indices].mean(axis=0).tolist()[0]\n",
    "        top_features = sorted(list(zip(feature_names, cluster_tfidf)), key=lambda x: x[1], reverse=True)\n",
    "        clusters[cluster] = [word for word, score in top_features[:top_n]]\n",
    "    return clusters\n",
    "\n",
    "# Directory to save results\n",
    "output_dir = \"clustering_results\"\n",
    "os.makedirs(output_dir, exist_ok=True)\n",
    "\n",
    "# Process each subreddit\n",
    "for subreddit in subreddits:\n",
    "    print(f\"Processing subreddit: {subreddit}\")\n",
    "    subreddit_data = data[data['subreddit'] == subreddit]\n",
    "\n",
    "    # Convert 'date' to datetime and sort\n",
    "    subreddit_data['date'] = pd.to_datetime(subreddit_data['date'], errors='coerce')\n",
    "    subreddit_data = subreddit_data.dropna(subset=['date']).sort_values('date')\n",
    "\n",
    "    # Group data by half-year\n",
    "    subreddit_data['half_year'] = subreddit_data['date'].apply(lambda x: f\"{x.year}-{(x.month-1)//6 + 1}\")\n",
    "    grouped_data = subreddit_data.groupby('half_year')\n",
    "\n",
    "    # Process each half-year\n",
    "    for half_year, posts in grouped_data:\n",
    "        print(f\"  Processing half-year: {half_year}\")\n",
    "        \n",
    "        # Preprocess the text\n",
    "        posts_text = posts['post'].dropna().apply(preprocess_text).tolist()\n",
    "        \n",
    "        # TF-IDF feature extraction for unigrams\n",
    "        tfidf_vectorizer_unigrams = TfidfVectorizer(max_features=5000, ngram_range=(1, 1))\n",
    "        tfidf_matrix_unigrams = tfidf_vectorizer_unigrams.fit_transform(posts_text)\n",
    "        feature_names_unigrams = tfidf_vectorizer_unigrams.get_feature_names()  # Compatible with older versions\n",
    "\n",
    "        # TF-IDF feature extraction for bigrams\n",
    "        tfidf_vectorizer_bigrams = TfidfVectorizer(max_features=5000, ngram_range=(2, 2))\n",
    "        tfidf_matrix_bigrams = tfidf_vectorizer_bigrams.fit_transform(posts_text)\n",
    "        feature_names_bigrams = tfidf_vectorizer_bigrams.get_feature_names()  # Compatible with older versions\n",
    "\n",
    "        # K-Means clustering\n",
    "        num_clusters = 5  # Number of clusters\n",
    "        kmeans = KMeans(n_clusters=num_clusters, random_state=42)\n",
    "        cluster_labels = kmeans.fit_predict(tfidf_matrix_unigrams)\n",
    "        \n",
    "        # Extract keywords for unigrams\n",
    "        keywords_unigrams = extract_keywords(tfidf_matrix_unigrams, feature_names_unigrams, cluster_labels, top_n=10)\n",
    "        \n",
    "        # Extract keywords for bigrams\n",
    "        keywords_bigrams = extract_keywords(tfidf_matrix_bigrams, feature_names_bigrams, cluster_labels, top_n=10)\n",
    "        \n",
    "        # Save results for this half-year\n",
    "        results = []\n",
    "        for cluster in keywords_unigrams.keys():\n",
    "            results.append({\n",
    "                \"subreddit\": subreddit,\n",
    "                \"half_year\": half_year,\n",
    "                \"cluster\": cluster,\n",
    "                \"top_10_unigrams\": ', '.join(keywords_unigrams[cluster]),\n",
    "                \"top_10_bigrams\": ', '.join(keywords_bigrams[cluster])\n",
    "            })\n",
    "        \n",
    "        # Save results to CSV\n",
    "        output_file = os.path.join(output_dir, f\"{subreddit}_{half_year}_clusters.csv\")\n",
    "        pd.DataFrame(results).to_csv(output_file, index=False)\n",
    "        print(f\"  Saved results to {output_file}\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "b6ef6f6f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Reading file: clustering_results/lonely_2020-1_clusters.csv\n",
      "Reading file: clustering_results/socialanxiety_2018-1_clusters.csv\n",
      "Reading file: clustering_results/healthanxiety_2019-2_clusters.csv\n",
      "Reading file: clustering_results/suicidewatch_2020-1_clusters.csv\n",
      "Reading file: clustering_results/bipolarreddit_2019-1_clusters.csv\n",
      "Reading file: clustering_results/addiction_2018-1_clusters.csv\n",
      "Reading file: clustering_results/ptsd_2019-2_clusters.csv\n",
      "Reading file: clustering_results/anxiety_2020-1_clusters.csv\n",
      "Reading file: clustering_results/lonely_2019-1_clusters.csv\n",
      "Reading file: clustering_results/healthanxiety_2019-1_clusters.csv\n",
      "Reading file: clustering_results/ptsd_2019-1_clusters.csv\n",
      "Reading file: clustering_results/adhd_2018-1_clusters.csv\n",
      "Reading file: clustering_results/depression_2020-1_clusters.csv\n",
      "Reading file: clustering_results/suicidewatch_2019-1_clusters.csv\n",
      "Reading file: clustering_results/healthanxiety_2018-2_clusters.csv\n",
      "Reading file: clustering_results/anxiety_2019-2_clusters.csv\n",
      "Reading file: clustering_results/EDAnonymous_2019-1_clusters.csv\n",
      "Reading file: clustering_results/autism_2019-1_clusters.csv\n",
      "Reading file: clustering_results/ptsd_2020-1_clusters.csv\n",
      "Reading file: clustering_results/ptsd_2018-1_clusters.csv\n",
      "Reading file: clustering_results/addiction_2019-1_clusters.csv\n",
      "Reading file: clustering_results/schizophrenia_2019-2_clusters.csv\n",
      "Reading file: clustering_results/suicidewatch_2018-1_clusters.csv\n",
      "Reading file: clustering_results/autism_2020-1_clusters.csv\n",
      "Reading file: clustering_results/depression_2018-2_clusters.csv\n",
      "Reading file: clustering_results/schizophrenia_2018-1_clusters.csv\n",
      "Reading file: clustering_results/anxiety_2019-1_clusters.csv\n",
      "Reading file: clustering_results/adhd_2019-1_clusters.csv\n",
      "Reading file: clustering_results/lonely_2019-2_clusters.csv\n",
      "Reading file: clustering_results/EDAnonymous_2018-2_clusters.csv\n",
      "Reading file: clustering_results/bipolarreddit_2018-2_clusters.csv\n",
      "Reading file: clustering_results/addiction_2019-2_clusters.csv\n",
      "Reading file: clustering_results/socialanxiety_2020-1_clusters.csv\n",
      "Reading file: clustering_results/alcoholism_2018-1_clusters.csv\n",
      "Reading file: clustering_results/bpd_2018-2_clusters.csv\n",
      "Reading file: clustering_results/socialanxiety_2019-1_clusters.csv\n",
      "Reading file: clustering_results/depression_2018-1_clusters.csv\n",
      "Reading file: clustering_results/socialanxiety_2018-2_clusters.csv\n",
      "Reading file: clustering_results/bipolarreddit_2019-2_clusters.csv\n",
      "Reading file: clustering_results/addiction_2018-2_clusters.csv\n",
      "Reading file: clustering_results/adhd_2018-2_clusters.csv\n",
      "Reading file: clustering_results/bpd_2019-2_clusters.csv\n",
      "Reading file: clustering_results/ptsd_2018-2_clusters.csv\n",
      "Reading file: clustering_results/autism_2018-1_clusters.csv\n",
      "Reading file: clustering_results/schizophrenia_2019-1_clusters.csv\n",
      "Reading file: clustering_results/autism_2018-2_clusters.csv\n",
      "Reading file: clustering_results/schizophrenia_2018-2_clusters.csv\n",
      "Reading file: clustering_results/adhd_2019-2_clusters.csv\n",
      "Reading file: clustering_results/suicidewatch_2019-2_clusters.csv\n",
      "Reading file: clustering_results/alcoholism_2019-2_clusters.csv\n",
      "Reading file: clustering_results/schizophrenia_2020-1_clusters.csv\n",
      "Reading file: clustering_results/socialanxiety_2019-2_clusters.csv\n",
      "Reading file: clustering_results/addiction_2020-1_clusters.csv\n",
      "Reading file: clustering_results/healthanxiety_2018-1_clusters.csv\n",
      "Reading file: clustering_results/anxiety_2018-1_clusters.csv\n",
      "Reading file: clustering_results/depression_2019-2_clusters.csv\n",
      "Reading file: clustering_results/EDAnonymous_2019-2_clusters.csv\n",
      "Reading file: clustering_results/alcoholism_2019-1_clusters.csv\n",
      "Reading file: clustering_results/healthanxiety_2020-1_clusters.csv\n",
      "Reading file: clustering_results/adhd_2020-1_clusters.csv\n",
      "Reading file: clustering_results/EDAnonymous_2020-1_clusters.csv\n",
      "Reading file: clustering_results/bipolarreddit_2018-1_clusters.csv\n",
      "Reading file: clustering_results/autism_2019-2_clusters.csv\n",
      "Reading file: clustering_results/lonely_2018-1_clusters.csv\n",
      "Reading file: clustering_results/bipolarreddit_2020-1_clusters.csv\n",
      "Reading file: clustering_results/bpd_2020-1_clusters.csv\n",
      "Reading file: clustering_results/lonely_2018-2_clusters.csv\n",
      "Reading file: clustering_results/alcoholism_2020-1_clusters.csv\n",
      "Reading file: clustering_results/bpd_2018-1_clusters.csv\n",
      "Reading file: clustering_results/suicidewatch_2018-2_clusters.csv\n",
      "Reading file: clustering_results/anxiety_2018-2_clusters.csv\n",
      "Reading file: clustering_results/bpd_2019-1_clusters.csv\n",
      "Reading file: clustering_results/depression_2019-1_clusters.csv\n",
      "Reading file: clustering_results/alcoholism_2018-2_clusters.csv\n",
      "All files merged into: merged_clusters_output.csv\n"
     ]
    }
   ],
   "source": [
    "import os\n",
    "import pandas as pd\n",
    "\n",
    "\n",
    "output_dir = \"clustering_results\" \n",
    "merged_file_path = \"merged_clusters_output.csv\"  \n",
    "\n",
    "\n",
    "merged_data = pd.DataFrame()\n",
    "\n",
    "\n",
    "for file_name in os.listdir(output_dir):\n",
    "    if file_name.endswith(\".csv\"):  \n",
    "        file_path = os.path.join(output_dir, file_name)\n",
    "        print(f\"Reading file: {file_path}\")\n",
    "        current_data = pd.read_csv(file_path)\n",
    "        merged_data = pd.concat([merged_data, current_data], ignore_index=True)\n",
    "\n",
    "merged_data.to_csv(merged_file_path, index=False)\n",
    "print(f\"All files merged into: {merged_file_path}\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "b572f37e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAksAAAGDCAYAAAA77lRGAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/MnkTPAAAACXBIWXMAAAsTAAALEwEAmpwYAAEAAElEQVR4nOydd3gc13W33zsz23exiw4SIAn2XkSRIiWqUL1X27Fsy7bce7djx5/TnMQlcZy4W4qjWLbc1axCiWqkSFFi772BIHrf3qbc749ZLAES7E0S5+WzD4HdmTt3Zmdxz57yO0JKiYODg4ODg4ODw9Ao53sCDg4ODg4ODg5vZhxjycHBwcHBwcHhGDjGkoODg4ODg4PDMXCMJQcHBwcHBweHY+AYSw4ODg4ODg4Ox8AxlhwcHBwcHBwcjoFjLDkMQgjxT0KIR873PACEEEkhxJjzcNxvCiF+dZaP8WshxL8Wfr5CCLHrLBzjfUKIF870uIWxPyWE6Ci8R+Vn4xgnOZ/7hRCvDfh9gRBiT2F+d53Hqb3tEEJ8Qgjx3+foWHcIIf54Lo7l4HAsHGPpAkQI8V4hxNrCQtImhHhOCHH5GRy/XgghhRDa6YwjpQxKKfefqXkBCCHeI4Q4IIQQhz2vCSE6hRC3SSm/I6X86Jk87rGQUi6XUk48nTGGuuZSyt9JKW84/RkecSwX8EPghsJ71HMGxjwghLjusOcGGUAnybeBnxbm92RhvKlCiJgQYsJhx3lZCPHdUzzOSSOEmCCE+KsQoksI0SuEWCyEmHjYNl8SQrQX5vuQEMJTeN4jhPhfIUSjECIhhNgghLj5sH2vFULsFEKkhRBLhBCjjjEXtxDi0cL1l0KIhceZuxv4FvAfhd/777tk4XFACPGNAdsLIcTnhRBbhRApIUSzEOIvQojph437T4VxLhn4vJTyKWCaEGLGsebl4HC2cYylCwwhxJeB/wa+A1QDI4GfA3eex2kN4nSNrOPwBBABrjrs+ZsACTx/Fo/9dqEa8ALbTnbHwuJ5Lv7ujOKw+UkptwE/AP6331gWQnwEqAX++Uwc9ATPLwI8BUzEvpargb8OGONG4BvAtUA9MGbA/DSgCfv+DQN/D/xZCFFf2LcCeLzwfBmwFvjTcebzGnAf0H78M+ROYKeUsuXwc5JSBoH3AP8ghLip8PyPgC8Any/MZwLwJHDrgPMVwPuBXuCDQxzzD8DHT2BuDg5nDyml87hAHth/XJPAu46xzT8BjxR+Xgg0H/b6AeC6ws+XYP8xjgMdwA8Lzx/ENjyShcelhec/DOwA+oDFwKgB40rgM8AeoGHAc+MKP/8a+BnwLJAAVgFjB+x/A7ALiGEbf68CHz3KOT4IPHTYc38eMP+B18ALPAL0AFFgDVB9+LU4fL/C73/BXoBiwDJg6oDXfg386+HXGXj3gOuWBHLA0sJrtwIbCte7CfinAeMdcc2B+4HXBmxzWWH+scL/lw14bSnwL8CKwvV9AagY4tpNAFIDjvXKCY79b4WxM/3v6dHuqwHPHT7/bwD7CvPbDtw91LaFbazCsZKAZ8B2WuEafgbbUOkuzN2DbUgdxL6Xfwn4CvuUAs8AXdj37jNA3cmc33E+l2WF61le+P33wHcGvH4t0H6M/TcD7yj8/HHg9QGvBQpzmnQC82gGFh5nm4eAbw34vb4wd23Ac2uArwLjARO45DhjXlmY433YnzP3Ya8voPA3wXk4j/P1cDxLFxaXYi/+T5yh8X4E/EhKWQKMxTY4wP7jB4Vvm1LKNwp5I98E7gEqgeXY3xgHchcwD5hylOO9B/sbdimwF3uB6v82/Sjwd0A5ttF02THm/TDwTiGEr7B/GLgd+M0Q234Q28gcURj7k9h/2E+E57AXjCpgPfC74+0gpfxT4ZoFgeHAfg5dpxTwAWzPxK3Apwbk4xxxzQeOK4QowzY0f1w4jx8Czx6Wb/Re4EOF+bqxF7zD57cbmDrgWNec4Njvx17IQ0Dj8a7DUdgHXIH9fvwz8IgQYtgQcxyLbfTcXrgWuQGvGdhG+79gG8GPSClfB76PbQjOAsZhe5v+obCbAvwftrdqJPb7/9PDDjvo/IQQzwwMRx2HK7GNof5w5lRg04DXNwHVQ+WGCSGqC/PeNtS+UsoU9nWbevi+p8h07M/XERS8agsKx9qAbeQ1SylXH2fMDwJPc8gDdtthr+8A6oUQJac8aweH08Qxli4syoHuwoJxJtCBcUKICillUkq58hjbfgL4rpRyR+H43wFmHZZP8V0pZa+U8mjGyONSytWF/X+HvbAB3AJsk1I+XnjtxxwjpCClXIHtPbi78NTfALullBuPco7l2N4CU0q5TkoZP8Z5DjzOQ1LKRGGx/idgZsEwOy6FUM7vsb1KDxTGWyql3CKltKSUm7GNqMPDiUfjVmCPlPK3UkpDSvkHYCe2kdjP/0kpdxeu/585dH3PxNi/llJuK7yuH2WcJ4UQ0f4HtoewiJTyL1LK1sL5/wnbC3nJUAMdCynlBuB/gcnANwthoI8BXyrcfwns+/PewvY9UsrHpJTpwmv/xpHXfdD5SSlvk1J+73hzEULUYXtMvzzg6SC2h66f/p9Dh+3rwv4cPCyl3HmUffv3D3FmiGB79g6nGzuM9ivgG1LKl7E/N23HGkwI4QfeBfy+cF88ypGhuP7jRU551g4Op4ljLF1Y9AAVZzAn6CPY32p3CiHWCCEO/0Y4kFHAjwYshL2AwP4G30/TcY430ABKYy8MYHtgivtKKSV2SOFY/AbbSwO2V+Dho2z3W+yQ4R+FEK1CiH8vLFLHRAihCiG+J4TYJ4SIY4eZACqOt2+Bf8Ne4D4/YMx5hYTdLiFEDNvLdaLjDedIj04jg6//0a7vmRj7eO8twF1Sykj/A/j0wBeFEB8QQmwccA9N4wTOXwixbUAC8hWFp7cBB6SUaWxPpx9YN2Ds5wvPI4TwCyEeKCRVx7FDqhEhhHqS53f4vCqxw50/LxiY/SSBgV6U/p8TA/ZVsO/NPPDZY+zbv39CCDFywHVInux8C/QxtOFVIaUslVJOllL+uPBcD3CE5+8w7gYMYFHh998BNxeuTT/9x4ue2pQdHE4fx1i6sHgDyGKHu06EFPYiAtgGAIUFBEBKuUdK+R7ssM33gUeFEAHsHIbDaQI+MXAxlFL6CiGQ4pAndTaHaAPqBsxTDPz9KPwGuFYIcSkwH9uLcwQFL8E/SymnYIf2buOQkTXo+gA1A35+L3Yy7HXYYaP6/ukd72SEEPdihxzfeZgX5vfYicEjpJRh7Lya/vGOd+1asQ3WgYwEDk/UPRVOZOxTfW8BKHgg/wfbMCgvGFNbOYHrKaWc2h/alFIuH2KTbuzQ2tQB92a4EAoF+Ap2Mva8Qsi5P+Q58NgndX5CiFJsQ+kpKeW/HfbyNmDmgN9nAh39YbrC/f2/2DlX7zjsHhm0b+HzOBbb83pwwHU4UUP4cDZjf0E6EV4G6oQQc46xzQexjfKDQoh27Dw/F/b9389kbMP2hDy6Dg5nA8dYuoCQUsaw8zB+JoS4q/CN2SWEuFkI8e9D7LIb8Aohbi14U76FnQgLgBDiPiFEpZTS4tC3PhM7EdbCruLp55fA3wkhphb2DQsh3nWGTu1ZYHrhnDTs5N2aY+0gpWzErgL6A/CilHLIsJ0Q4mohxPSCoRjHDsuZhZc3AvcWruEc4J0Ddg1hJ2f3YBtU3zmRExFCXAT8BNvL0nXYyyGgV0qZFXaJ9XsHvDbUNR/IImCCsGUjNCHEu7Fzw545kXkdh7M5dj/9RngXgBDiQ9iepdOmcP/+D/BfQoiqwvi1hao0sK97BogW8rP+8XSOV8i9WQyskFIOldf0G+AjQogpBaPqW9gFAf38AtuAuH2IkPUT2KX27xBCeLE/75sHhOmGmo+nsC2AWwjhLRhkQ7GIEwz9Sin3YIdS/yCEWChsmQKvEOJeIcQ3hBC12HlNt2GHfGdhG3rfZ3Ao7irs/D8Hh/OGYyxdYEgpf4idH/Et7IWnCfvb+pNDbBvDDoX8CttLkGJweOsmYFvBpf8j4F4pZbYQ2vg3YEUhrDFfSvkE9h/BPxZCGVuBQfowp3FO3dh5D/+ObZxMwa7Syx1rP+zQ2yiGTuzupwY7jyKOnWj6KnZiMNjl2WOxQxP/zGDv1G+wQ1Et2JVbx8rnGsid2Ansrw0ImfQvFJ8Gvi2ESGAvgv0J9Qx1zQcOWvBK3IbtJekB/ha4rXDtTouzOfaAY2wH/hPbO9qBnWi84kyND3wdu2hgZeH+fAnbmwS21IYP2wO1khOQlxC2dtk3j/Ly3cBc4EMDw2JCiJEAUsrnse/lJdj3UCMFA63gYfsEtmHRPmDf9xX27QLegX0v9GEXTNx7nOnuwjYGa7GNuAxHegr7eRqYJIQYfpwx+/k8djL8z7C/UO0rnP/T2OHvjVLKF6SU7f0P7JzDGUKIfmP4PcADJ3g8B4ezgrDTOxwc3j4U8jmagfdJKZec7/k4OLydEEJ8HJgipfziOTjW7cD7pZR/c7aP5eBwLBxjyeFtQSFksgr7W/HXsENxY45RWefg4ODg4HBCOGE4h7cLl2K7+LuxS9bvcgwlBwcHh7c2hcriDUKII3Ighc2PhRB7hRCbhRCzz9o8HM+Sg4ODg4ODw5sRYbfomgOUSClvO+y1W4DPYWvtzcMWSZ53NubheJYcHBwcHBwc3nQIW7T1Vuwio6G4E/iNtFmJrX92PG2vU8IxlhwcHBwcHBzejPw3dnWtdZTXaxksCNvMYDHcM8bZ7O5+XITdmfpHgAr86vD2AEKIhdjduBsKTz0upfz28catqKiQ9fX1Z3SuDg4ODg4Ob1bWrVvXLaWsPP6WZ4Ybrx0he3qzp7z/uo3d27BFkvt5UEr5YP8vwu4I0SmlXFewBYZiKD2ws5JbdN6MpYLI38+A67GtwTVCiKcKeioDWX54nPJ41NfXs3bt2jM0UwcHBwcHhzc3QohTbVB9SvT0Zln1yl2nvL9W9quslPJY6u4LgDsKeUleoEQI8YiU8r4B2zRjNznvpw67o8AZ53yG4S4B9kop90sp88AfseOPDg4ODg4ODm9ipARLylN+HH98+XdSyjopZT22sOorhxlKYLd/+kChKm4+EJNSHrN586lyPsNwQ8Uah8piv1QIsQnbWvyqlHLbuZicg4ODg4ODw9GQWGcn4nVMhBCfBJBS/hK7/c4t2Or7aeBDZ+u459NYOpFY43pglJQyWXDFPQmMH3IwW1X24wAjR448g9N0cHBwcHBwOF9IKZcCSws//3LA8xJbgPiscz7DcMeNNUop41LKZOHnRYBLCFEx1GBSygellHOklHMqK89ZjpuDg4ODg8MFiTyNf281zqdnaQ0wXggxGrvZ6L0M7qKOEKIG6JBSykKXdQW7UaeDg4ODg4PDeULCCeUevV04b8aSlNIQQnwWu8u1Cjwkpdx2WDzyncCnhBAGds+ve6UjOe7g4ODg4HDeOZr40duR86qzVAitLTrsuYHxyJ8CPz3X83JwcHBwcHBw6Oe8GksODg4ODg4Obz0knJdquPOFYyw5ODi85ZFSYlkSVXU6ODk4nCveionap4pjLDlc0OTyBjv3tWMaFuPHVBEKeM/3lBxOgmxO5/HnN7Js1R503WTapOG85/Y51FSFz/fUHBze5pwfnaXzhWMsOVyw7Gno5Mf/t4RsTkcIgRBw3z3zuGLuuPM9NYcT5JePLGPzjhYiJT4Uv4ftu9v47s8X8y9fvYOSoGP4OjicLeww3IWD47N2uCDJ5Q1+/H9LkFJSGvYTKfHh87p5+NGVtHXGzvf0HE6AlvYoW3e1Ul4aQNNUFEVQGvaTSudYtWH/+Z6eg4PD2wjHWHK4INm5t51cTsfvcxefc7tUpCVZu/mc9qN0OEW6ehIoioIQg5sBKIqguT16fibl4HABYZ3G462GE4ZzuCDRDfOo0fa8bp7TuTgciZSSTdubWbpyN9mcztyZ9Vw+dxwe96E/WdWVJZiWhZRykMFkWZL62vLzMW0HhwsGW5TyfM/i3OEYSw4XJBNGVyGEQDdMXJoK2IusEDBjUu15nt3xWbu5kScXb6S9K07dsFLuuWkWMybXne9pnTEef24Dzy7ZituloSiC3Q2drNnUyFc+dh0ul/1+DasKM2f6KNZsOkAo6EVVFeKJDJGwn3kXjT7PZ+Dg8PbnArKVHGPJ4cKkJOTjvrvn8tvHV2NZEoTd2fmq+RMYV3/2egu2dkQ50NxDMOBl8tia4sJ/MqzeeIBf/m4ZPq+bSNhPZ0+CH/3fEr700WuZNmH4WZj18dF1k+eWbuWV121P0EVTR/COmy+ioix40mP1RlM89+p2Skv8RSmAgM/NnoZONu1oZs6MUcVtP3rvAuqGRVhSOO6ls8dw142zBoVXHRwczg5vxXDaqeIYSw4XLFfOm8DYUVWs3dyIbpjMnFzHuPrKI3JgzgSWJXnkiVUsW7WnYJgJIiU+vvKx606qzF1KyePPbSDgc+Pz2gZB0O9BSskTz288p8aSlJKmtj76YmleWbGLzTtbKAl6CfjcrNl0gF37O/j2l28nGPCc1LgHmntQhBikmSSEQFEEO/a2DTKWXC6V26+bwe3XzThj5+Xg4OBwOI6x5HBBU1sTobYmctaPs27LQZa+sZuySABFsY2xWCLDA79fzj984dYTNtBMS9LZk6C8NDDoeb/PTcs5TGpOpXP89OGl7DnQhWlYNLX1UlkWpKI0iBBQFgnQE02xckMD110+6aTGDgW8DNUC0pKSsnBgiD0cHBzONU7OkoPD25jWjijPLdnK7oZOairD3Hz1VCaNrTnrx122ag8et1Y0lABKgl6a2qJ09iSorig5oXFURVBZHiKdyRU9SwCZjE5tdeRMT/uo/P6va9i9v5OyiJ9EKoemKvRG0/h9nqIhpykKB5p7TnrssaMqqa4ooaMnTiTkQwhBOpPHpanMm+3kIjk4vDkQWJx5L/ybFUc6wOGCoaU9yr/+5DneWH+AbM5W7v7BAy+eE6kAw7SG9B4J7BDdiSKE4O6bZpHK5Eln8kgpSaVz5PIGd9048wzO+OjkcjqrNx4gErYNGbdLRWKX7Hf3JYvbGZbFiGGlJz2+ogi++NFrGDOigmg8QzSexuPR+OKHr6Gi9ORzoBwcHM4OVsFgOpXHWw3Hs+RwwfD0y5vRdZOyiB8Aj1sjk83zp6fXcvH0kWclV6mf+bNHs2t/OwG/u3icVDpPWWmAmsoT8yoVx7poNKoieOL5jbR3J6irifCOm2cx/RxV8emGXa6vFM7D63FREvQRjacRuollSWKJDEG/h0svHnNKx6goDfJ3n7mJrp4Eed2kprLE6fvm4OBw3nCMJYcLht37Own4B1dJ+bxueqMpUun8SScinwyXzR7D+i0H2bq7tWhoeDwuPv6ey0/JSJs7s565M+uP0Bg6FwQDHkbVldPSHi22FBlVW4ppGqiqRl88zYxJtbz7totPu+VIZXnomK8nUllWrm+gsaWHEcPKuPTiMU6bEweHc4AEpHzreYhOFcdYcrhgqCgL0tTai9t16LbXDRO3S8PrObGPgpSSHXvbeWPdPnTD4pKZ9cycUndcr4fLpfKFD1/Djr3t7D3QSTjkY/b0kae9sJ9rQ6mfD9wzj/944EV6oykURcGyLCaNHcbXP3UDJYU8o7NNV0+C7/7seeLJLKqq8Mb6Bp5buo1vfPrGk/bWOTg4nDwXknyvYyw5XDDces00fvTQK7hdBh63hmGYROMZ7rh+Bpp2YnpHTy7eyDMvb0VR7FL2NZsamXdRPR87AQ+RogimThjG1AnDzsTpnFdG1ZXzL1+9ndfX7aejK8HY+koumTlqUNL52ebR5zYQT2UpixyqkOuLpfnLs+v43P1Xn7N5ODhciNiNdC+c0LhjLDlcMMycXMeH/+YyHl20nr5YGk1VuP266Ses0dPVk+DZV7YRKfEVPUlSSlZtPMBV8ycwcUz12Zz+m47ScIBbr5l+3o6/cVsT4aBv0HPhkI+N25vPS3jSweFC4wJSDnCMJYejI6Vk/8Fu9h7oIuB3M2vKiLOa13MuuHzuOObPHkMimSXgdw8KyR2PvQe6AHmEWCLSbsx7oRlL5xuvx4VpWYPeD9Oy8LpdjqHk4OBwRnGMJYchMU2Lh/78Oqs2NGBadkKy17OWL370GsbXV53v6Z0WmqpQGvaf9H4+71EWYcFZaa8RT2Z5cdl21m45iN/n5toFE7l09hjHEChw9aUT+OuLm6koDSCEQEpJNJ7h1mumne+pOThcALw1JQBOlQsn4OhwUmzY1sQb6/cTCfupLAsWhAYlDzyyHNO8kDoCHWLy+GEE/B4SqWzxuUzWFkucM2PkGT1WJpvnez9/nmeXbCWVztHeGeNXf1jBn59Zd0aP81bm1mumM29WPX2xDNF4hr5YhjnTRzqtTxwczgFSgiXFKT/eajieJYchWbl+Py5NLWrpAAT8HqLxNE1tfdTXlZ/H2Z0fPG6NL3/0Wn768FL6YmmEEHg9Lj53/1WUnuE2HKs2HKCjK0FFaRDTtEilc2RyeR5/fgNXXDKO4edQrfvNisul8sn7rqSjO05Hd4KqsuBJ9dlzcHA4PZwEb4cLHqEc3fJX3uRhoEQqy9adreQNk0ljq0+4lciJMLK2jO9+/S4aW3qxLMmo2jJcrhOrpDsZdu/vQNMU8rrB3gNd6IaJQGCYJt/+0SL+7Wt3FtuKxBIZVqzdR2NzLyNrS7l87jjCId9xjvD2obqi5Iy+xw4ODifGhRSGc4wlhyFZcPFY1m05iGXJYj+zRCpLJOyn7hRaWJwrtu5q4WcPv4pumEhpl+vfcf2Z7UqvqgpjRlacsfGGoroihGlatHXGMApaUEiJBNKZHI89t56Pv/cK2rvifPdnz5NK2/3Z1m1p5IVlO/jGp29kmONlcXBwcDgjXDg+NIeTYuaUOq65bCLReJqeviS9sTRul8an33/VoGawbyayOZ1fPLIcTVMpiwQoLw1QEvTy1xc2sf9gd3G7vliKJxZv5AcPvsifnl5LR3f8rM9N1032HOhkX2MXxgnkfC24ZByaZjen1VQFKSV5w8TvdaGpKkte301XT4JHF60nnclTFglQEvJRFgmQzuR5dNH6s35ObyVM02Ljtib+5w+v8ZvHVrKnofN8T8nB4S2N5NTzlZycJYe3DUII7rt7HgvnT2DfwW78XjfTJw3H63Gd76kdlV37O9B1g0jJoUo3VVWQEtZtaWTMyAo6uuP820+eI5XJ43Fp7NzXwdKVu/naJ244a96iHXvb+OUjy0mlc8STWXTdZO6MUdx546yjClRWlAb56sdv4Av/9CfyhokiFHxeF5msTirTh2FYfOBLvyaXN6iuLCEY8OAqCGuGQ1427XC0hvqRUvKrP77G6o2NqKpASnh11R7uuekip3LOweE0kBdQGM7xLDkck7phpVw1bzxzZ456UxtKRYZQSRPCrtwAeGLxRtIZnfJIgGDAQ1nYj7Qkf3xqzVmZTiyR4ccPLcEwTLp7k8QSGdKZPK+u2sMPHniRF5ZtP+q+4+oref898xlWGWbS2GpyOQOh2I1s+8/TMC26uhPsPdBVrFI0TAufx+0YSgV27mtn9aZGyiJ+IiV+SsN+wiEfTy7eSF8sdb6n5+DwlsUqyAecyuOthmMsObxtmDC6Ck1Tyeb04nOmaSGBi6fbpf1bdrRSEhwsrBkKetnb2I2un9lOR7pu8qen19LaGaO9K04qk8ft0nC7NYQARYHHnttAOpM/Yr9XV+3h+794gYOtvQyrDtPRk0A3LExTIi2Jz+dC01RcqoIlJfm8QV8sjSUl8USWaxZMPKPn8lZm2+42kIP76GkFIUtbaNTBwcHh2DhhOIe3DT6vm0+873J+8dtlpNJ5JLaY5i0LpxZDbKGgh1Q6P6gXnGFaeD3acZvhngzZnM4PHniRjdubSaZyWJaFaUk0VUHTVCSH1L8PtvYyaWwNYBt3P/n1ErbuasXrcWFJSS6vM7Ywf5/HRUtHFEWx56ppKi6XbSD2xtIoimD+7NHcds10eqMpVm5ooC+WZtLYGmZOrj3hHnjHQ9dNXl+/nzfW7UdVBVdcMp5LZta/KfPZAj43R/si+5bwljo4vAmxe8Odvc+7EMILLAM82LbKo1LKfzxsm4XAX4GGwlOPSym/fTbm4xhLDm8rZk4Zwff+7m427WhB100mj6uhtiZSfP2GK6fw28dX4XapqKqCZUliBdXnM7nQL1+9l/1N3VRXhEikspiWwMwZZHI6AUUAAr/PTTqrEwp4i/tt39PG9j1tlBdUqQEsy01Lewyfx4XbXTB2CpVxCBg9opx4MsuCOWO5+8ZZVJaH2L2/g//61cvohglC8Mrruxg3qpIvf+w6PO7T+9hbluSnDy9ly84WvF4XUkp27Gln59527n/Xpac19rFo64zx8oqdtLRHGTeqkqsvmzioie7RmDNjFE8s3kQ2pxeNo0QqS8DvKRqpDg4OJ4s42zpLOeAaKWVSCOECXhNCPCelXHnYdsullLedzYnAeQ7DCSFuEkLsEkLsFUJ84xjbzRVCmEKId57L+Tm8NYmU+Llq3niuu3zSIEMJYOH8CdyycCqJVJZYIkMskeHyS8Zxx/Uzz+gcVm88gM/jIuD3UBYO2N+/BFimRV43qSwLkM7qjBlRzvDqQyX+ew50Ig8LGSmKgqoKrpo/HsuyvUnprI6um1RXhMjrJqGAl3fdOpvK8hCWJfnVH1egKIKySICysJ+ysJ89DZ0sX7P3tM9tx952tu1upbw0QNDvIRTwUhYJ8NqavbS0R097/KHYe6CLb//3syxduYeDLb08t3Qb//hfz9DedfxKxsryEJ96/5WYliQaT9MXSxP0e/jyR689KxpZDg4XApKzq+AtbZKFX12Fx3nr3XvePEtCCBX4GXA90AysEUI8JaXcPsR23wcWn/tZOrzdUBTBu267mJuunkpnd4Ly0sCg6rljkUzlWLmxgebWPkbVlTFv1uij9oTz+9yYlv25HjG8lHCJj/bOGLFEhvKyIB63i4ljqvn4ey8fZBiFQ74hQ0ZCCC6ePoo7rp/Bmk0HWbZ6D81tfaiKwqjaMt531yVFFfGO7jh9sfSg/ndCCHxeF6vWN3DdgkknermGZH9jF5YlDzPo7J8bmnqOMFAPpy+W4o31DXR0xxlfX8XcGaPwHCcc9odCAn5Z4ZwCfg+90TRPvrCRT77vyuPO+aKpI/jh37+ThqZuNFVl9IjyMxp2dXC4EDnNMFyFEGLtgN8flFI+OHCDwvq/DhgH/ExKuWqIcS4VQmwCWoGvSim3nc6kjsb5DMNdAuyVUu4HEEL8EbgTOLw86HPAY8Dcczu9ty/ReJqV6xvo7Ekwvr6K2dNHnnZo5q1GKOAdFP46Hp09Cb73s+eJJ7MoiuC1NXt59uWtfOMzN1JRGjxi+6vmj2fLrhZM00JVFQJ+Nz6vi5KQj0tm1XP5nLHMmjriiP3mzBjFY89tIJnOEfR7kIWE7dKwn0ljq9E0lRuunMwNV05G1010wzzCYOv3lhwuHWBa8ozk6JSUeIcOWQpB6LDk+cNpaOrmBw+8RC6voyiCFWv28fzS7Xzj0zcSDAy9by5vcKCph7LIYKM2FPSwdWfrCc/b49acsJuDw5uHbinlnGNtIKU0gVlCiAjwhBBimpRy64BN1gOjCqG6W4AngfFnY7Lnc4WsBZoG/N4MzBu4gRCiFrgbuAbHWDojHGju4T8eeJFcTkcIwasr91C7dBtf/9QNBPzHXuguZP78zDriydygHJneaJonntvIx957+RHbXzR1BLddO53nlmwDCa2dUSxLMrw6zMbtTazb3MjYkZX0xtIEAm5uuGIKl88dSzjk48sfvY7/+cNr9EbtsvYRw0r5xH1XHJGc7XKpQ4aRKkqDjBlZQcPBHiJhu+2JaVnkdYOFl0447Wtx8bRR/OWZ9SRSWYKFeyaeyFJa4mPKuKF1o8A23n79lzcwLWvQdWztjLJ42TbecfPsIffTVAWPR8MwraKWFIBumJSETtzgdXBwOLPIcyQuKaWMCiGWAjcBWwc8Hx/w8yIhxM+FEBVSyu4hhjktzqcfeqirfHg88r+Brxesy2MPJsTHhRBrhRBru7qccuChKC5Wpr1YlYb9lJcGaGnv48XlO87IMbp6Ery6cjfLV+8lGk+fkTHPN1JKNm5rIlIyeGEOh7ys23JwyH2EENxz00X8+zfv4cr544iU+Jk6YRjlpUFKgj46uhO8unoPhmnSF03zf39+nUeftVW3x9VX8t2v38U/f/k2/vVrd/D3X7jlpHuffey9l1NVEaIvZufoxOIZbrxyCrOnHenNOlmCAQ9f/th1lJb4icYz9MUy1NZE+MrHrjtmDlAimaWlPUroMA9S0O9hzabGo+6nqgrXXjaRWDyDZR3Skkqn89x45ZTTPh8HB4eTRyIwUU75cTyEEJUFjxJCCB9wHbDzsG1qRMF9LoS4BNum6TnT5wrn17PUDAz8y12HHXMcyBzgj4VrUQHcIoQwpJRPHj5YIdb5IMCcOXPOWxLYm5l4MktzW9+gXBaw8z9WbTzAXTfOOq3xX1i2nb88ux6rkKujqgofe88C5s6sP61x3wy4XBqmJVEGfMZNy8LjOfZHqDTspzeaJhT0Fsv9e6MpTMsOz5mmRcDvwePWeGH5Dm68agolIR+KIhheHTnl+VaUBvn2V25n74FOEqkco+rKhgwXnipjRlbwb397Jx3dCVRFUFEWPK4IpqapCCGGDA/6vMcOD95x/UwSqRyvr91n7yvg1munc+W8s+Jxd3BwOAGO37jptBgGPFzIW1KAP0spnxFCfBJASvlL4J3Ap4QQBpAB7pVSnpX1/3waS2uA8UKI0UALcC/w3oEbSClH9/8shPg18MxQhpLDieEqLla2qnU/di7L6d0KLe1R/vLsekIBTzFclMsb/OqPrzNpXM1J5Qe92RBCcPWlE3j+1W2URwLFBT+eyHL79cdv0FsS8hbVtQFS6RwCW1W8P8lYVRUURdDRnaAk5Dsj81YUwYQx1WdkrKEQQlBTeeIeL7/PzUXTRrB+y0FKw36EEFiWJJ3Jc81lx046d7lU7n/Xpdxz0yx6Y2kqy4JO2NjB4W2MlHIzcNEQz/9ywM8/BX56LuZz3owlKaUhhPgsdpWbCjwkpdx2mNXocAbx+9zMnFLHxq1NlEYOLVaZTJ6rLz09xedNO5qxLDkor8bj1khl8mzf3ca8i0YfY+83B1JKNmxt4vll24nF00yfVMvNC6dRXhrgzutn0NoRZeuuVhRFwbIsLp4+8oR6i10xdzwr1uwjr5u4XSoet0afYREMeouJ9VJKLEse4fV7KyKlZOuuVpat2kMmpzN3Zj2Xzh6N26Xx/nvmEY1l2N/UjSLAsuCayyayYM7YExq7JOQ7Y8akg4PD6SEvoCYg57UESkq5CFh02HNDGklSyvvPxZze7nzgnnlEY2kaW3oRwhYYXDh/wgkvVsdCngEJDF032bKrhd5ommFVdk+0c1Xi/cKyHfz5mbW43Rpul8aS13ezfstB/uGLtxIp8fPFj1xLc1sfnT0JKstCeD0a2ZyB23Xsj5Hd420ef3hqLZmMrR7u8WpUlNpJzqZp0RfPcPH0kVSUnblQ2dkmlc7R3B6lJOhlWNUhrainXtzMX1/chEtTURTB9t1trFq/ny9/7DpCAS9/95kbOdjSy8HWXmLxDKGQj95Y6oyGCR0cHM4u/TpLFwoXVr24AyUhH//vczfT0NRNNJ6hblgpVeWh0x535uQ6Hn9uI4ZhDgrDqYpg8vijV0gNpC+W4vu/eIGevhSmaaEogjEjK/jSR6/F5x1az+hUkFLy2pp9PLd0G9F4moljqrnlmmk89twGQkEfihC0d8WIxjM0tfXxX//7Mt/8zM143Bp1w0qJJ7P8+NdLiMbSSGDm5Fruf9elxww1XjV/AsGAl2de3kw2Z3DFJeNoaOqhrTOGpipcfel4/ubWi8/YOZ4qUkoamnpIJLOMGF46pEK2lJLnX93Ok4s3AraxN350FZ96/1WYpsUzL2+htMRfNHKDfsmuhk4272hh9vSRCCFo7ojy28dXYZq2ga0ogvfeOZerL3N62jk4vFV4KzbEPVUcY+kCRAjBmJGVZ3TM2poI77jlIh57bkOhYkngUhU+/O7LKAmeWL7S755cQ3dfqig8KKVk74EuFi3ZetSy8lNh0Stbeey5Dfj9bnweF2s2HeC5JdvQDdtLZFoSAWguFcWCNRsb+cVvX+ULH76Gjq44P37oFVRNpTTsx7Ikm7Y38/PfvMrffvKGoyY5v/TaTv7w1BpURUFKi5b2KHU1Eb7/jbsJh3xvCiXpaDzNjx5aQnNbn+11lHDDFZN5162zB53X1l2tPPrsesIhr93nTkr27O/kf/+0goXzJyAEg7yBQggUIdi2p5XZ00cSjad5+C9v4Pe5i1453TD5/V/XMHXi8DNivDs4OJxd5Akqcb9dcIwlhzPGzQunMnvaCLbvaUNRFGZMGl5UlT4eum4WyvMHq04HA15eXrGLyy4eS01lyXErro5HLqfzzCtbCJf4cGkq6Uye7r4UhmliSYlpWmRzBh6PhiIEBlAS9LJ1VysHW3pZvakRw5SUhGxPl6IISgutRFo7YkOqV2eyeR5dtB5VEbR2RDFMCyR09yZZtnoP99x0RA7jeeF///Q6TW19lJb4EEJgWhbPL93G6BEVzJ05qrjdyyt2omlK0YMohKA04mfbrjaumjeeoWpRpJSEQ/Z7u3VXG6YlB4UvXZqKaVps2dnCtaepMO7g4OBwpnGMJYczSnVFyUlrAh2NVDpPQ1M3pmnx9//5NMOrwnzq/VcOyo85WXpjaUxTFsUNu3oSIO3F2spL8rqJlJJc3kBTFQSCyvIgmZxOW1ecrt4EmjrYYBNCoCoK8WSGWiJHHLO1I0ZeN2jriCGEsI8tJdm8wR+fWstdN8xCUY4sqT+XRONpduxpK1apAaiKLQa55PVdg4ylRCp3hECmEAIh7Pe/sjxId2+ScMg2ujLZPJqqcOns4yT5XzhfUh0c3hac5Ua6byounDN1eFPjcqlcNHVEUcjSMCz2NXaR102qKkOUlthCjv/54Evo+nE1So9KpOA1yeUNMlmddE5HIkll8khpJ6lLKPY+q68rw+txIRBUlAaZPK4G3RisLmKaFhJJbU0p0XiaF5fv4NFF69my0253Egp6SSSzRW0lAIRAUQT5vMGjz67ja//2GB/+2m/5hx8+zZadLYDtjdm1v4NXXt/Fxm1Np3XeYHvvjiZBouvmkIaaqihkcvlBz82eOoJMdvBzmWyeUMBDdWUJX/rItdQNK6UvliYaT6OqKp/54EIqC+G1qROGoSqCvG4cOr5hoioK0yYOP61zdHBwOHdIeeqPtxqOZ8nhTcN775pLS3uUzt4ksXgG3TQJB31UlYUQQhAOeemLp9mxr50Zk2pP6Rhej4vqihCvr9uHqirk8waGYSEE+LwuFEUQT2aRUjKsOlxo2Jpi7Kgqxo6qoLYmzMuv7aK1M0rA58YwLXJ5gzuvn0lHV5wf/upl8nkdEDy3dBtTxg/j8/dfTVk4QF80XfQemZaFQKCogsef30hleYiK0gA9vUl+9NArfOFD1/D8su3s2tdu62IpttDk1z5xA+WlJxba7GfH3jb+8NRamtts9exbrp7K9VdMGdTfraIsSHlpgFg8g1DsHCOf10U6qx8hKnr1ZRN5Y0MDbR1RXC67DYkiBB+9dwGaqlBZHuLvP38LHV1x8rrJ8JoI2oAcptKwnw++81IefvQNEsksEtsoe88dc8+YV9LBweHsIrmwPEuOseRwTFLpHHsaOlFVhYljq49bJn86lIYDfPsrt7N1VyvPv7qdzTuaqa2JDPJ4SAmpVO6Uj/Hqqj00tfYyrDpMT28KoYjiYo2w22h43BqqIujsTqApClfNm8A7C0nOXo+Lqy+bwG8eW8meA12EAh7eectsbrt2Ol//3hMoAsoLJfBSSrbtbmXlhv3cd888vvPT50ilbY+M26VSWxOmuT3KuPpwUcE64PdgWpJf/m4Z6axORWmgeP49fSkeeWIVX/jwNSd8vvsPdvHD/3kZl6ZSHvGT103+9PQ68rrJ7dcdEtQUQjBvVj2/eGR5MUFfUxWmT66ltjrCzn3tjBlZgdul4fe5+X+fvYmV6xvYuruV8tIgV80bPyhfSwhBzTHCpQvmjGXyuBq27GpFWpJpE4cfVzahL5Zm/8Fu/D4X40dXDzLAHBwczjXCqYZzuPDoi6XZ19iF1+ti4uhqXC6VFev28ZtHV2FJOyHZ53XxuQ9dzfj6qrM2D01TmTV1BC6Xxp4DnYNesyx7HqNHVpzy+Itf3U4w4MHndTOsMkw6k2fnvg7yukEylSt6VKoqQsycUscXP3ztIA/M6+v387snVlMS9FJVHiKdyfPC8h1UlgWJJzJHJKh73BpvrG9g4phqFEUgFBAIDNOisydJ0O8tNqPtx+d1sXt/B2NHVQ4yFMMhH1t2tpDJ5k9YSmHRkm0IYfdzA1soVCnx8dySbdx41ZSi8dvWGeO5JdsYN6qSVDpHXjfRDYNtu1r56cNLEQI8bhefvO9Kpk4Yhs/r5urLJnL1ZRMxDJMN25p46sVN+H1uFswZx7j641dblkUCXHUC7UqklDz78hb++uJm+7oC4bCfL33kmtNqCePg4OBwojjGkgPPLdnKE89vLEpKlgS93Hf3PH795zcI+A+Vd6cyeX780BJ+8K13FJWnzxaTx9UwY1Itm3a04HGrSEuSN0yuu3zySbXYOJxYIoPXc6gPmc/rwrIspCUJl/gQ2N6llvYY77vrkkGGUiqd4xe/WUZ3NImmKJRFAlSVh5ASXlqxC0tyRJK2lHb+0zMvb2HCmGpiiQzReAbDMMnmdHJ5g537OqiriRQNmnQmP2iO9jiSVDpHOpNn9cYDLHljN60dMYZXh7n7xpnMnDJ0g9zmtr4jDCuXppJK50kkc5SX2u/jyvX7saQkGPAQDHgwTYsde9vRDROXSyXo95DJ5vnpr5fw/b+7u6iibZgWP/n1UrbsasGlqRiGxYvLd3DbNdN59x1zzkjC+s597TyxeBOREl8x5yueyPKzh1/lX792x3lLindwuNBxPEsOFwx7Gjp57LkNlIR8xbBGIpnlR//3CooQg8JuAZ+bvphdNTVr6ul3rz8WiiL4zAeuYtXGA7yxfj9ul8blc8dy0RDH7elL8cTiDazdfBCPW2PhpRO49ZppQ4YMp4wfxqbtzcW2IvlC0rSqKXYCNHbfPL/PVUw2B9so+MGDL9HWGbONNynp6IqTSueoryunty9JXU2Eto4Y4RLbkLAsC103GTm8lH2NXbg0lYrSIC5N5UBzD5YlCQXs5O89BzoZO7ISodjG1c0Lp7Ji3X48blslvKGpm3QmDwL+4YdPUxL0oqkq7V0xduxt4xufuoGLpo064nxHj6hg7ebGQcZtXjdwu9VB+lfJdG6Q0REfkJBuFYQjfV433X1JNm5vLjaw3bKzha27WimPBIjGM7R2RrFMya/+tIJNO1v48kevLSZ2nyqvrdmHoohB2k2hoIfOngRNrX2MrC0bcr9tu9t4/LkNNLX1UlMZ5q4bZzJ72sjTmouDg4ONxNZaulBwjKULnNfX7UcIMSj/IxT00tWbPMK7AbaHQzdOryrrRNE0lQVzxh6zFUs6k+d7P3+evliakpAPy7J46sXNtLT18dn7rz5i+7tvnMXOve30RtN4PRrReAZVVZgwsgLDtDBMq5i43d1rK4lv39PG0pW72bKzGa9HQ0pQFAW3S5BM5+mJphhfX8VH7l3AD//nJfpitpElpeS6yycxdcIwlqzcXZxDW2cMRbGvd7jER2V5kOa2KE1tvVw2ZyzvuPki6uvK6e5Lsaehk6bW3qKkgSUlUkJfLIPXreFy2V6i//cfTzNpbDVVFSVcd/kkIiV+ggEPt1w9jQ3bmojFMwQDHnJ5g3Qmz3vvumSQEOaMSXUsfWNP0TNmWbL4s98/wDMlIZPVi79u3tGMogiyOYOm1j5UVaC5VfK6QVNrLz96aAn/8tXbT8v7k8vpgzx8cEiq4Gj34rbdbfzXr17C5VIpCfro6Uvys4df5ZP3XXFEwrqDg8Op4XiWHC4Ycnl9yIXM73NjWRaWJYsLlW6YZ6yTfS6n88LyHby2Zh8gWTBnHDdeORnPEAbasVizuZG+WPpQWw5VoaI0wMbtzbS0R48QiaytifCPX7yVl1fsZF9jNzMm17Ji3T4Cfs8gz0VPNMWY+kr++39fZuP2Zlrbo+T6vVCqwO91o6oKpmmSyejcc/MsaipL+M7X72LzjmYyGZ3xY6qoKg+h6yYhv4dEMmsbLDkDRRUIIYiU+HG7bC9PIpnj/3325uIc/vaTN7B42TYe+N1yrFQOr1uzK/UKr9seIg3dMMnrthG0eUcLL722k8qyIAG/mwljqvnsBxfywrLt7DnQRXmpn/vunse8i+oHXZepE4czc0otm7a3oKkKumliWZLhVSVFQ9qyLBRFYdLYQ+9/MODBkpLeWAqQKEpBqBJBSdBHR3echqYexpxGntmcmfWs39Y0KMSZzel43C5GDh/aq/Tk4g24XGqxBU3A70EIwWOLNjjGkoODw0njGEsXOHOmj2LVhoYjFqJQ0MvF00eyYs2+oligIgTvuWMu4dPs+m5Zkh899Ao793UU83SeXLyRHXva+NonbzjCi3AsGpt7jjD2hBAoikJHV5xhVWE2bm/ijXX7Abj04jFcNHUE994xt7h9RVmQZ17agtfjQtMUkukc1eUlICXrthyktSOGaR3SVjJNSSabx+ux87ned/dcJo8bxoHmHn77+CoONPWgaQqXzx3Lu269GK/HxRc/ei0/fXgpfdF00XMzekQF7oJ3J5PVqT4sF0tRBHU1pQXPn4pQFOw3wzaXJPZ71b9tIpWjJ5rEpRUEMmvC7N7fgaoqfOVj1x3zOmqqwqc/sJBN25tZu7kRn0ejsaBY3tWXJOh34/d5uHbBxEFhr0tnj+HZl7cST2QxLYlimuTytlGZTOfQNGWQJ+pUmDPDvkc372yxz172z/fKo7aJaWqzpR0G4vO66OxJYJiWU0nn4HAGcNqdOFwwzJxSx5wZ9azd0lh0qKqKwifuu4KLpo7gsovHsGl7My6XytwZ9YwYXnpS4zc297Bs9V5iiQyzptQxd2Y9DU3d7G7oonxAWbzHbVe/7drfzvjR1XT1JPB5XYOqy4airiZyhNBif7iqoizIbx59g+Vr9qFp9uK4butBrrxkPB985/zise++cRZ1NRFeem0XyVSWq+aP5/orpvCzh5fQ05fCKuTumKZVFFMTCMpLA4weWcEt10ynuy/Jv//yBSxLUhaxe8YteWM30ViGz33oakYOL+O7f3sXjS09rNt8kEVLtg0wlPJkcjp33jCDwxk7qhJVUTClhQsVl1sllzsk5miYthGnqSpdvQkMQ+L1aBimxDAlpWE/O/e2092XpKL02KX5mqpw8fSRXDx9JE+/tJklK3dTGvaTSufI5gxGDCs7ok9cQ3MPubxBKp1DN0wyWdtw83ldtHfFAIHPO/SfGSklPdEUqiKOaIvT30i5P0T82Q8uZNueNrbtaqUk6OWSWfXHzIUaXh2mvTNeNMYBsjmD8tIA6kkY4w4ODkMjEY7OksOFg6oqfOJ9V3Dl3vFs3dVC0O9h7qz6YjPTSWNrmDS25pTGXrl+P//7p9dtT4CmsH7LQZa+sZs5M0ZhWdagRbff2/La6n088LvlpDM6lmUxY3ItH/6bBcVFr7MnwZadLUgpmTaxlnkXjeaZl7fQG00TKfFhWhaxeIZpE4djWhavrd1Hadhf9FZZluS1NXu55rJDHhIhBHNn1lNbU0o8maFuWCmhgBerUIEHtj9HVRRMyzaYTMti5PBSvvrx69BUheWr95LPG8VwoKoKyiMBNu9soaM7TnVFCaqqMGZkJaNHVDCsOsyTizfR05eivDTA++6ex8XTj0zQ9vvcvPeuufz8N6+SzeUxBqh4y0L1naIIdMPEMGxvUzJl4HJpaIVQnxCQyegwhJ2r6yaxZIZw8FAz33giw1MvbaY0HCh6YKSU9MbSbNjaxPzZYwDo6I7z6z+/QWV5kJrKEjZubyaXN4rb22FGH4uWbOOzH1w46LgHW3v51R9W0NoRAyRjR1Xy0XsXYJgWf3hqDdt2teFyqVw1bzz33DQLj8fFjEm1JyxGeteNs/jRQ68g0vY1zOZ0Uhmd99x5Zir0HBwcbIPpQsExlhxQFMHUCcOYOmHYGRszlzf47ROr8fvcxUosKSX7m3qorYkMGWrTTYulK3dTEvIWGrW62LSjhQd+v5yvfOw6lr6xm989udoOiUlQ1HXce9vFfOMzN/Gnp9faHjBN5forJnP3TbNYsXZfMefKkpJkKmeX7Gd1djd0FI2leCLDz37zKvsOdqMqAinhjutncPnccby0YlcxR0gIUISCUMHvdfOu2y7mYGsf7Z1xWtqjQ/ZLU4SgN5oapEwthODyueNYMGesXZqvqcdcwO+56SIMw+L//vIGed3C7VKwpMStqRimRV43CfjcSCi2IcnrBvsP9lAa9hHwe6ipLEFKyfY97SxfvYdkKoeqCnbv78IwTdwujduuncZNC6fS2NKLYHDSf3//u22724rG0rotB7EGNMTVVAXN7yafNwn4PQyvjuB1a8X2Lf2k0jl+8MCL5HWT0rAd0t1/sJvv/nwxhm6SzRuURvxYpsWLr+2kqzfB5z904kKcADMm1fLZDy7ksUXrae2MUVUW4r13XsL84/Wnc3BwOGGcMJyDw2nS0t6HXljE+xFC4HGp9EbTlJcG6Y2mivlP0XiGRDJDJqPT3h0vNrENl/jYvruN3fs7+N2TqwkGPMUmuLph8sdn1jFjSh2fu//qYjiu3/Dwe90oit0Hbv/BbnTdQGKHeJav3svCSyeiqQr/+6fX2dfYVZATECRSWf7w1zV8/iPXMGF0Fdv3tGMYVtHAU4SdRP7A75YjLbuXXC5vIKUcVI5vWhaWlNRUhunojtPZnaCqIlQ0nMRh0gwUxunsjtPU2ofLpTJl/DACfg9/c9vFrNl0gK7eJD6Pi4DfjW5Y9MZSHGzuRdNUjIIXrD9U2BdLEU9muOvGWbhcKouWbOWxRRtQVTsvq6MrTijgYVx9FaZp8ZdF6/H53IwcXoaUksM1oyzLIlLiY9vuNrr7kjS19BY66dmoqoIQINzCTjD3ucnlDQK+waKb67ceJJ3JH0rKx26BcqC5B01VqBtmu8CUgur45h0ttHZET1qA8qKpI7ho6ojz2qDYwcHh7YFjLDmcFXxed6HMffBCZZgWpWEfH3zXfB55fDVbd7VgWZJsTieZypHLGQgBpqLg87qIxtKYpsXG7c1YUhYNJbDFFS1LsmVnC9cumHTEgjhzSh1er4v9B7vQdWtQH7PG5l5Wrt/PtInD2ba7jdKwn2zO4EBTN7phYVoW3/nJc3ztE9fz18Wb2La3jWzOQBGCiWOryGR0fF5X0diJxtO0tEeLpeqmaZJK51l46QT++NRa1m05iBC2MTR90nC+8KFrcA/QPsrmdP789DoWLdlKd18SraDJFAp6+PT7r2L6pFo8Hhehgvo4gMet4HHZ8gETx1TRF0vT3N6HQJDXTcIhH8Oqw2ze0UJLe5QnF28kXGLrabV1RHG7VTJZnXgyQzjkw6WpPPrsOv7rH//GbsXSFiVS4kNRlKLHas3mRp5/dbsdoswb9MZSREJeNE2joixIe2cMoQgCfg+WZRFPZnnXrbMHvS/RWAbLOrKTZi5voHrtKszeaJpYIoOmqXjcGl29yVNW63YMJQeHM4+UjmfJwQGw+4otfWM3vdE0M6bUcfmcsfh9J9Zmo6ayhNF15Rxo7iFS4kMIUdQKunLeBCpKg3zxI9eQyeZ5bulWnnlpazG/RlUVLAnZvIHX4yKezFIe8Q+Kjkspyesm+byBdZQW1n6fm4/eu4Cvf/cJwPZEuVSFUXUVSCl5deUexo2qpH8t3X+wG8uycLlUFFMgLclvHlvFv371dpLpHNF4hhHDSnltzV6eeWXrIK9QpMRPPm8wcXQ1bV1xSoI+7rn5IvqiKZau3I3X4+Jgq+1ta126nc3bm/nwuy9n+uThVJQGeejPr/PGuv30xdK43baWU3dfkoDfzc9/u4z//NY7uGreOP7w17V43Bq6URCMlJKAz4NuWGSyOqqqFgUcR4+swKWpROMZ1m5uhAGhtbxh4tZUdGnRG0vT0Z0gm9MxTYuv/MujVFWEaO+Kc6C5l6DfTd3wUsaMqGDfwe5iI99oLEWmQ2f91ma8HhfhEh8+nxuXppBK55ASrp4/gRuunDLofRk9qgJFEYMMaSml3ZNPFext7CKT1VGEgiVzmIbF/sZuZk6uO6F7z8HB4Vzg9IZzuMCxLMkvH1nGX1/YhGlZ+L1uNm5vYtnKPXzzszedkMEkhODTH7iSn/x6KU2tfYVyfsF9d88b1DfM53WzfkuzrXOkKHZ+kWUvoqZpYRgmJUEvI4eXoSgKed0ABI0tPaTSeSzL4rFFGygPB5g9/Uh15hHDyhgxrBSvx1VshCuE3brFNC0qy0OEgl7aOmPkdaOYX9X/mmlZrN1ykFuunlYcM5MzCiXskmzOQEqLrt4UPX1JcrrJnOkjed/d86ipLOFz//An/D43+xu7kYBLU9B1gwMtfXzvF89TV1PKRdNGsGFbk204iEJTXyj2q/P73OzY286IYWUk0zn2NnbZRqWiUF1Rwpc+eg2PLtqAbpjohp1/NKquHJdmK41blkVZJDAotBbw2e1LpCWJxdOoqorAbnWzv6mH7XvamDxuGAhpC1r6vexv7iZSUCePJ7M0tvbh0hQkEC6xlcjDIS8+rwtdN7lp4VT+5raLj/DsTB5bw8SxNezY04bP50ZKSSars3D+BNZsbiSRjOH1ukFKTANKI34WL9vOTQunnHBPPAcHh7OLxEnwdrjAeey59TyxeCOqquB1ucgbJj19KYQQLF+9lxuvmnL8QYDScIC///wttLRHSWfyjBheOuRi53arWJZFSchbXNB100Ip6Onk8gb//sCLCAHdfSl6+1LkdQNVVaivK8ftUvnlI8v4xy/ddoQIZVnET21NhI6ueLGfmZSSTCbPZXPGkkrncGsqrR0xdMMklzfQNIWQ30tFqd3CI53JDxpzxuRannphE62dMSzTsg0mwONWqaksYee+Dv79F4v56ieup7UzSjqdI5s18BZyeAzz0PcxRRW8sW4/umHiO0yQUxGCXF7H73NzoLmHvy7eSE9fEq9HOxTGErBjXwf/+a138Mb6/fzqjysIh+ykbikl0bhd3bdgzhheXL6Dtq4YkUJ4bk9DJ6ZpIoRS7L1nWDn0wjWIJzNUV5Tgq3TT3ZsglckXc8zau2wVckWxPXAlQR+9fWniyRwjhpehGyaLX91Oadh/hGdJVRU+/6GrWb56L6+v24emKlw5bzzzZ48hkcoRjaXJ5nVURWFYVQmV5SHiySzNbVHGjz57TZwdHBxOjgvJs3ThiCQ4nBCZbJ5nX9mGoohilZbtobBf27i96aTGE0JQN6yUCWOqj+oVuGr+BNJZ3S6v1xSEIlALGju6YTGqrpxIiZ1TI7DVmEfVljNl/DDKIgG8HhcW8NqavUMe/yP3LsDt1uiJpujuTdIXSzNlwjCuuGQsD/z+Nbr7kkwcW41LU4uJ5cOqSwo6PxxRJRgO+sjmdHTdxLQkpmlhWRaaau9fGvbTF0vzrf94inzeru4yLItUKmuX1kuKZfrSsrWQYokMAb+dCN2fqG5JicftQlEEm3c0k0jlcLk0PG4XPq8bl6aSyeRZv+Ug2bzBwksn8rVPXI/LZbdxicYzjBlZwRc+fDWKovD5D1/NqOFl9MXS6LrB6LpypowfjqoKDNPCpSooQiCxJQV6+lLFc7YsSV1NhFg8A9iaRaoiMAyT0rCfju4EmqZgGHao1aWphIJeFi3ZeoQOFti6WtddPol/+MKtfPOzN3P53HFoqsLw6jAVZUGmT6xlyvhhVFeUkMvpxOIZdu/vOMJwdXBwcDgXOJ6ltxG6brLkjV0sW7UX07S49OIxXH/FpJMKXfRG08UcnoE5JYoiSGd1IiV+utN277Nyn++MJM9ePmcs+w508vq6/VRXlBCNpUmmc1imWUhGjlE3LELA7yEaywCymDfTj6oI+goL+eGMHF7G975xN+u3HqQvmqaiPMCG7c184u9+T3NblIqyALXVEUbWltHWGcM0JW2dcfRSi0tmjTpCZ2r5mr1UlAUZpqm0d8cxTQuPR8O0JLkBeVaWhNrqMDv2pm1NJPuioigCj1uzQ5w+N5qmEg55yebs69sb7RfCtJObP/DO+Tz0p9dtTaUB11tVFTI5HbBlEcIhHzOnjOAH36qlrSOG16MNEm6sKA3y/z53Mx1dcXJ5g9qaCNFEhk998/fEEhk8bpctcll433M5w26p4tJQVMHt101n0ZJtdPcmEdhJ6f2yBL3RNgDcbq14T7hdKj19KUxLoqkndp9cNW88y1btKbQz0WjrjNHeFcft0nhi8UYWLdnGp95/ZVEIc+yoyiO8iQ4ODucGJ8Hb4S2HlJIHfr+cdVsOEvS7EULw5OKNbN3Vwt9+6sYTbu9QGvbjdmkEfG5SmXzRu2QUDIKNootFTz2OAEaXlvGl+ZcxMhw5rbmrqsKH372Am6+eRkNTNz/5v6XEkhksaRsflpUhl9eZNLYGn89Fqi9f1CfqP3fDsJgxafhRj+H3ubl87jhyeYN/+M+n6elL4ve5UVVBXyxNLmcwfnQVAb+Hjs4YoZCPz92/kOmTaouLv67bYbq+aAqt4DkxsIin7H5tAnseeCCT0ykr8bO3savQmfuQd8UqeKPKSwO43RoHW3rxelyUlwYIBb1UlAUpDfuZM30kC+aMpbI8xNMvbCaVzpPJpYo97CxLoqkqHrerKCIKduiyX2ldSsmu/R1s3dWKz+Ni7qx6aqrCxW0rSoMMr47QF8ugGyYCEIpAYHvV0pk8iWSWYdURLp09lvmzx7B5Rwvrtx5kyRu7KS3xoSgCt1sjlc4Vy/7Bbncysq7shO89KSVer4u7b5rFole20t4Vp70zTknIW8zB6oul+dq/PUZtTaRwzeHK+RN4/92XOFVvDg7nEAmFv20XBo6x9DahsaWXjduaqDishcj+g91s2916wpVEfp+bG66czF9f2IQlJZmMjiUlQoA20UuHlqHCY7cgORiL8q1XXuKB2+7E5zq5BrhDMawqzNMvbaGzJ4HX48I0ZLGzvMBOKpYSrlswkQ3bmlFVu+orlzcYM7JiSAXsw9m0vZmeaIqySADLkqiKgsBOME6mcwT9HsIlPt59x1xmTR0B2EbSY89tYOnK3RiGiSIEiXSObj1DTyaFqVrkMgZCERjSoqm1F2lJ2rti5HQTVREoKMXWJABer4tQ0MuOPW3oukl9XTmJVI68bnDjlVN49+1zBs379uum8+AfVqAWktwFdgisvCzAvXfMGbJHmmVJHvrz66xcv78QChP89cXNfOw9CwY1k503q562zlghXwxqqkrI5nS6e1NYFlw1bwJXXzqBpSt3k0hmmTC2mo+8ewHzLxrN489vpKmtj9EjyunqTQK2BEAmm0dKuPe2OUfM63CklDS19vHrR99g74GuwvssKS3xUVNVMkgyoKM7jmFauF0awYCHTFbniec3sK+hk4WXTmD+7NFOEriDwzlBOMaSw1uP5rY+YLCmjBC2cnVjc+9JlV3ffeMsQgEPzy/dTnc0ycjhZcxaMJJHGrdS7j3Uq63U66M7nWJNawtXjqo/7XOQUrJ89V5UxVaLdrvVYo5PLm/Q0tbHzKkj+Nh7LqehqYdXV+0hkcpy8fSRXDZ7TLGS7Vi0d8WxCk1xFUVQWxPhYGsfhmESi2fI5nTqakq5fM5YMtk86YzOX1/cxGur9xIJ+1EEdHQn7HCdInH5Ndw+DQMLS5Ps7uomgpvysgAHm/sKrVHsupF+hADTNPF5Xfh8bsaPjhRlCEzL4sXlO7l2wSQqyg71crtszlhyeZNHn1tPZ3ecXN5k+qThfPjdl9lVa0NcyyWv7+Ll13ZSURYoGhC5vMFDf36DaROHE09m+dUfVrDnQCd9sTSaqjJ2VDkul0YskeHum8bz6fdfxc597XznZ8+TL7RaeXbJVmZMquUzH7iKGQPuq6bWPp5buo2Gpm4mjKnmlqunMnpExTHfj32NXfzykWWs23IQwzQR2F4qRRE0NGdwaUoxLy2b08nnTRRFQSJJpLI0NPVgGCYbdzTT3N7HS6/t5O8+c9OgnnAODg4Op4tjLL1NiIT9Q4YhFCGOyO85HooiuOHKKYOqmBbt2Y154MhEXUNa9GWHzhU6WQzDwpIWoqDB43Fr5HXTbm8CaC6VWCJDR0+CSeNqmDTuxHvWGaZFJpunprJkUN6PHXZUaWmPMq6+kivmjeeSmaN4/PkNLF+9F90waWmLUjc8gqYqtLRH6e5NYkq7R5yRNnCF3PhrPGR782TSOkkkHo8Lj9dFJpMvKmorQqCotjRCeSRIZ0+CcNA7SK9JVWwV7APNPYOMJSEE1yyYyJXzx5PO5O1cp6OEtw629PLD/3mJnfvb0fMmvbEUJUE7lOVxa2SyOrsbOvndE6uJxjNUlgUJBTwcaO5l1/5O6uvKueGKKdx90ywM0+LB37+GoiqUF9TJpZRs2tHM6k0HuOziscXjVpQFuO3aaZSG/Sfk3enqSfAvP1pEU1svumEWrpMkm9UpCXlxabY3rq0jxuiRFUjAknYivd/rZndDZ7EAwe1SKS8N0tYV4+UVO7nzhpknfG84ODicGuYFVA3nGEtvEyaNraGqIkRHd4JIyIcQEE9kCQW8zJ424qj7SSk52NJLXyxNbU3kqJ3cx5aV2ZVSUmLlLeL7k6Ta0+QVi9zwLHLCybeUyGTzrN7UyN6GTqorQ1x28VjGjaokmcqRydoCidKyFbfdbpWJY6qJJ7M88vgqvvnZm0/oGFJKXly+g2de3kI6oxPwu1EVhe7eJOESH6Yp6epJUhL0UV9XzqjaMp5cvImXV+wklzeJxtJksnkaDvYgLUl3XxKXS0W1FCwFvGUest05LN3EyJsoechJg7aOGJoiGJitJKXENCWapuJ2a8R7s0cYPBJJXrFwe4f+aGqqMqilykByeYOf//ZVnn5x8wDjwz5+PJGloyvOsKqw/Z632u+53eLF1ruaPK6G7r4U9919CVfNn4CUkqdf3sLOve0oiiAU9FJdEcLt0vC4NFZtsI0ly5I8+cJGXli2o6iRdeNVk7nrhllD9gDs59VVe2jvjtv6WsLCLExYYlfbaaqCx60RTWTspHIhUBSFqgpb/0rX7W10UxbPI+Bzs27LwXNqLNlaVrKYS+bgcCEw2F/+9scxlt4maKrCVz9+HQ8/upKtu1oBGFdfxQffOf+o3/KTqRw/+fUS9h3sstWSLYsrLhnHfXfPO+IP/4SyciaWV7B0/36yXTlccYkvrxAWHp5/eguurODuG2cddX4tsTjL9+zH69K4dtJ4MCTf+9ni4mJpWRaLlmzjHTdfRFNHlJ5kir7uFAiBS1OYMKYKIYQtmniwu+hdGUg0nmbzjhZ0w2TS2BpqayIsfWM3f3xqLSUhL2URP9mcTjZvMHF0Fc3tfbR22O05Il4fr6/bz7LVe0il82RzOrmcrTdkSxiYHGjuLf6uCgVLk0jDfliqhdQlCLCzoCS6IQf9MSk4ThDY3h+7Ca6B3+umJOSjTUmxQ+mDKoVvb3yV29KTuG/GLDTlxBbhRxet5+XXdmKYlt0QGDBNia6bqKpCT1+KUNBLKOAhHPQOWdIPklgiC8Czr2zlz8+sKyTTK/RGU8QTWSaMqbJbzxTypF5ZsZNnXtpCJOxHU21v0NMvbSEU8HL9FZOPOt+DLb0YhonHrdnhVigal4ZhomkKFWVBIiE/t103Da/HTSjo5X9+/xrRWAbdsHvvlZYECIdsY8kwLQL+c5OzlMsbPPH8Rl5duZu8bjJt0nDuvX0OwwYk0Ds4vJ2R8sL5guAYS28jSsMBvviRa0ln8liWPG7exu+eXM3exi7KCiE8y5IsXbmHUbXlLLx0wqBt17a2sLunB8UEQ5UYlSArFWbqZXhNleeWbOXaBZOG9Hr8eOlr/Hr9hmI47XtLlnFneBxtXTEqSg+FmhLJLL9ZvZ7oDOiJQV9cIZxSma5UEfDYC6BVKGs/3JjbsK2JBx5Zhm5Ydom9IrjlmmksX7WHYMBTDHV5PS5MS5LJ6Xz43Qv42W9exeNSkUDQb4tGNjb32qGdQg6Ux+Mik7Ur8BRF2ErfmkYg4iKetpORzawEy17szcO+b/WrXFPwLAnFVuouDftRVYXG1l7SPpPOURYuXeCy4ODBXh6KrsW0JB+ZffHx3np03eT5pdtIpLJYlkSK/pCenbSdLzT6dWkqn/vQ1WiqWrye/R7Dvliazu4E67cepLo8yNMvbaayNEAikSVXkBDI6wZdPUncbpUr5o4D4Lml2wgGPEUvmaYqhZy3bVx/xeSCDpU8Igl90tgaFi2x29y43RrZnD7IG+b3ulGE4O6bZ7Fw/qH78ft/dzcbtjXx5OKNdHQnGFZVUsgDs8jlDK67/OgG2pnkwd8tZ8P2JlsENOBhx542vvfzxfzLV24vCqA6OLydsY6/yduG82oWCiFuEkLsEkLsFUJ8Y4jX7xRCbBZCbBRCrBVCXH4+5vlWw+9zH9dQymTzrN3cSGnJIa0kRREEfG5eeX3XoG2llPxy3Wp8mkYQN0HVTanqRWiCJley0G1e0NoRPeI4aw8089Da9aimIKi4CCgu8rrBU69vxe8dXEGXLZFsNLsIeNxMqqtmbE05yRKLfd447V1xmlp7aW2PcfH0kYOSuTPZPA/+fjlut0Z5aYCKsiABv4ffPraKLTtb2dfYRUd3ouhJ8RYas766cjct7VEONPfQ2NzD9j3txYaxAyvXPG7N7lumCPJ5g2zOwO1SGRkKUxsMISTH/KsxdlQlo2rLKBSkYZkWQb+H6soS4omMLW45woU0JXlhkXGbZFWTeF+G365ZT84wjvleAqzZfIDWjhjSsisI7cRyq6iy7XJpXDVvAv/x/+5h9IgKRgwv5dKLx9DblyKRyrHnQCcNTT0oiv0+/vjhpfT0pXC5NEYVyv/zuoll2UbVTVdNZcbkWgBiicygvCsAt0ujL5bmkSdW8Zm//yOf/Obv+Y8HXqSl/dA9cuW88VSVl5DJ2hIVXq+L/qhdWcRPZXmIu26cxVXzxg8aOxjwcMUl4/jnL9/OjMm19MXSxOIZ4sksd1w/45hh5zNFW2eMTTuaKY8EcGkqihBESvyk0jneWN9w1o/v4PB2RwjhFUKsFkJsEkJsE0L88xDbCCHEjws2xGYhxOyhxjoTnDfPkhBCBX4GXA80A2uEEE9JKbcP2Oxl4CkppRRCzAD+DEw697N9+2GasuilGYiqKmRz+qDn+rIZejJpKnwB4m6taHS4pKBHyZFK5+iNpli7+SDpdJ5pE4fbukxujT+v24wlJe6C10EAPlXDUHS64ilG+Q4ZdQe1JIoEj2bflpVlQfriaRrzCfJdCoolcLs0eqNpdN0seip27evALBg37V22SGQqk0fXbU+QYVq0d8bIZPPU15WTSucYNaKcNZsPIqWFy233J0ulc+xu6LLnWWjoq2mKnTtVsHRqqkpIpXOkMnl27e+gtiZCOOQjnsja15Mj4/gt7VHKSwP4vLboY3VFCbU1ERqbe8jlDSSSuMxjeCl8fbEwhER4wEim6IgmGVkROeI9tNuZpDEti0efXY/f6yJpWZimhIJHyTQtVMVWxv7UB64cZNTc/85LmTyuhicXb6IxbzJyeCnlpUEUReD1uti+u41sTsfrcTFpXA3JVI5oPM2Vl4znb2475O2aMKaafY1dxVYoAIlUFt0weeX1XURK/KgBwZ6GDtvz8tXbiZT4CQY8/Nc/vpPv/OR5du5rx6WqVA4Lcs/NFzFvVj0VZcFjJooHAx6+9onrae2IEU9mqK2OnDOPTldvEkVRhvz8NLX1npM5ODicT6Q866KUOeAaKWVSCOECXhNCPCelXDlgm5uB8YXHPOAXhf/POOczDHcJsFdKuR9ACPFH4E6gaCxJKZMDtg9wYeWTnRLZnE5zW5SA333M3ImA382o2jJaO2KDQmeJVJYrLpk2aFu/y4UqFIxCQ9au3iSGaaELCzOaZ/OOFhDw8F/eIBTyYBYSboN+Dz2+PEIbooquTJDtM7AK3g8pJQlDJ1ziKzaSRYKeN/F4NEaOKiWouPF6NPYe6GT1pgMsmGNXYglhC0vGk9liA95czkBRBKXhAIlUHiFsw6Kzx43bpTFr8gh27etAVVRMyyKVyhVK/CkeO5PJEwx68Hpd9PTmUVWFWDyNEIJwiQ8BVJaHUBQFXTfJZPNYkqJnx56bLR3Q0Z0oJAELqittHaOOngSmaT9n6BaWH1R56CY3hUQqJtn0kS0+Wjui/OqPK4p5P129SYZXRzjY2ks2eyicBTBlQg3f+dqdlEYOUz1XFS67eCwHmnrYe6CLrt4k3X0pyiO2dy7o99DRnaC2JoKq2HlbSBhVVz4oZ+xvbruY7/18Mb2xFD6Pi0xOL/auK48c0v3qVyd/fd3+YmPiXM5g4WUTuOSiekbXlTNr6ogTatTcjxC2/EMtEQzDpLsvSdDvwes5fd2vY1FdEbLDnYd94TBMi/q6Y8slODi8PRDIsxickvY31H4bwFV4HL6Y3An8prDtSiFERAgxTErZdqbncz6NpVpgYKOxZoawCIUQdwPfBaqAW8/N1N6aLFu1mz88tQ7LsjAtybhRlXzq/VcO+sbfjxCCD7xjPj944EV6oykURWCakmGV4SMa5Xo1F9eNGcuiPbup8PkZM7KChuZuUjmdklY7iVkBcrpBtsfA41bxeVxESnzkmjNoAQtrmEQplJka0sIqVblhyiTWbTpIOpsnlckTCSsYQVFcgDI5nbw08akuKgMBRGF/t1tjzabGorFUXRkiGs+gaQqaqtqeICSmBUG/h6qKEjq6EiTTWYZVhfnYey4nGkvjcqmMrC1jf2PXYEMJ0HwqOd0koechk0Modk6TblhkMjrprI7bpRJPNlFVXkJVZYjOLrs/Wl43bY+M24XX60LTbGNK01SGVZXY8gedMSzLzhcK+NwIJYeQYAmQClii0B9OwL9vWMF/19xK0G0bEdmczn888CLpTJ7SsB/TtGhpj9HaEWXCmGp6+1JFYccp44fx3a/fddRKLcMwWb5mL7FExm7QKyVtnTFSmRxlpQGmTRjOzn3tdHYnyOUNSsN+nnh+A88v3caXPnotY0ZWUF9Xzj984RZeWL6DxuYeRtWVM3J4GX96eu2Qnpf+cO2zr2zliec3FL12QsAd18/kjutnnPA938+yVbv5y6INZLM6qqpwzWUTuefmi4p5VPsau1i7uRHTksyeNoKJY6oHza2xuYc1mxsxTYvZ00Yyrr7ymNWd1RUlXDJrFCvXNxAKelFVhXgiSzjkY/5Fo096/g4Ob0Ws03NfVAgh1g74/UEp5YMDNyhEoNYB44CfSSlXHTbGUHZELfC2MpaG+kt0xKWXUj4BPCGEuBL4F+C6IQcT4uPAxwFGjhx5Bqf51mBPQycPP7aKUMCL26UipWRvYxcP/G45f/vJG4bcp76unH/92h28vm4/nd1xxtVXMWfGqCG/lX941sXkDJOljQ0oCgiXQuQAuBOgqoea3oKd+xRNZBhZW8bIqlLiTTk6K3REoT+YkHBv/VQ+fMdltLTF2LG3jUw6j8xIst0ZNnUlqZtQiSEtTCGZmC8pGkoAlmXh9x2aY1tnnKryIL3RNHndsMvXEUXDpdLnZlRtKfFklo+8ewFjRlaQSGVRhN2jzTqsKkwognzeRGqgelSEF4y0STqvY+myqJVkSUnY76WzJ8noEWX4/W7ShfCfQODxaIwZWVHMr+rpSzJnxih27m3nQHMPpSU+MgUvkMdQMDIWus82HBRAWKBpCm2pBI9u38r9s+xw/OYdLSSSOcoidgWYpqlUlNm6TdmsbktA6AbRWIYxoyr40UOvEI1n6IumUFSFeReN5vbrphMKeNmyq5VMVkfTFKS0jRlFg75YmqryEJ//0NVs3N7MTx9eSkUhRAd2JeXPf/sq3//G3aiqwvDqCPe/89LiNezsSfDIEyYdySSxXBZNVanyB2zPy4gKOrrjPPH8BkpCvqJBY5oWT724mbkzR51URdmm7c08/OgqggEPpWE/hmnx/NJtqIrgHbfM5pmXNvPkC5vp//PyyoqdXLNgEu+5Yw5CCJ5/dRuPPru+2D7lheU7uG7BJO4tvH40PvSuyxheHeGVFbvIZHXmz67nrhtnOYKYDhcM8vR0lrqllMeU+JdSmsAsIUQE2w6YJqXcOmCTE7IjzgTn01hqBgZmYtYBrUfbWEq5TAgxVghRIaXsHuL1B4EHAebMmXPBheuWvLHL1iMq5PEIISgt8bGnoZPOnsSg3mEDiZT4iyERgHgiw/NLt7FpRwtlYT/XXTGJyeOG4dE0vjj/Mj40azbRbJav/+Nj9EZ1csLk8HvTkqBiV1pZUlIXCfPBi6awbF8DXlXlHXNncNWscby4fAfNrb2k03k8Hg1FUXCZJtlGk55AnNsvm0ZLp59MNAcl9tiGaXvNrrhkXPF4Qb8Hv89DdUUJ8VQO0zRp74yj6yZ5w2DH3nYyWR2/z83WXa3UjygnFPDyvrsu4ZePLEMO+HqkCLCQYIJigmXZoSfVLdCzJordNQ0pbYmAEcPL6Omz24KUlwbwe91Y0i7XHzE8QiyRpbUji6YpZDJ5Xlmxi0DAg1LwnLlcGiAJ9iik6iy70k+CioLiUqgMBijz+lhyoKFoLLV3x9H1wUnfw2vCpDK5YigSaec0LVu5h47uOHndxKWq1FSH+esLm1i3pZHvfO0unn1lazHpOpfLo2kqmqrg0lRuWjgVTVNZs7kRl0slm9PtfCaPi2DAQ18sTVNbH/V15UfcV+Gwj2TEomN/FNWtIAV09Saoryrj0otGs3ZzI1IySGdKVW0Jie172k7KWHp2yVbcbrVolGqqQrjEx0srdnHpxWN48oXNhEPeAT31LF5ZsZPL54wl4Pfw2KINlAS9aIVeg5Zl8fKKXcyfPfqYCuQul8pt107ntmunn/BcHRwcTh4pZVQIsRS4CRhoLJ2UHXE6nE9jaQ0wXggxGmgB7gXeO3ADIcQ4YF8hwXs24AZ6zvlM3wLEE9liY9l+hBAoQpDOHJnzMuQYySz/+tPn6OlN4vO6ae2IsnFHMx98xzyunGeXboe9XsJeL6UBHz09SVwF742CHJSr4/XYCcKGaSGAWHuKH91/16B8lLWbD5I3TFubqJCn5FJV0KG6w8/NFWOp/uBF/PevXrb7jgnbALh04Xj2mjF2bOyhe3eUtpZoobTfoLIshBACTVVpbO6huzeFpipUlAWorijhry9uorM7jsfjIhpPM2f6KJZl99IXS2GZhcn3V7Yp4Cl1k+vNYenYnxajv4GtYPTICtwuDZ/XxWc/uLCgOq1SURbg73/wNFt2tWCatqhm3rDsXm6lQSIhH2WRAH2xFLphUlkWxJvXUQ5k6ao30Mrsa1Ti8VIfKUU3TdyKoL0rzv/9+XW27W6lvStOPJmlojxIOp0nlc5hWZI7rpvO5ZeM5/ml23h5xU76Yml0w84LyxsmB1t68fvcdPcm+dw//pG+WBohwON24dJUdMOktiaCUOwqPoDW9iiNTT0oqu198nk06kdUDP2drsCyxgNk6hUqfaXE9yfRMwZuv0abSPPKqt24FXXI/fsVuU+Gnt7kEa1uXJpKIpll6+5WJIMFIxVFwbIk2/e0EQ75kFIWDaXi69Ji2+6247ZrcXC4UDnbjXSFEJWAXjCUfNhRpe8fttlTwGcLOc/zgNjZyFeC82gsSSkNIcRngcXYjoiHpJTbhBCfLLz+S+AdwAeEEDqQAd4th1bSu+CZOaWO7XvaBoUAcnkDl0tlePWJfUtf+sZuenqTlA/QPsrrBn96ej3zLhrce+36KyZxYFGURC6HGhNYpt3+QxECVRGk0jkUxc5DqauJsGHLQR5WFD5135XFMYJ+N4YxuObefnvt/Ka8blJVHuJfv3Yn+xq7SKSzLO7ez9Nte8ms1OnsiqNYghmZUjRVpas3iWXZC25ndxxVVVALysqKUPB6XCRTWf7y7HpG1pahKILO7gSxRAafx0U2b2AYVlGZVnGDHteRpj0vqQCWreFUXhokUuIjm9PRNJWJY6rwDAhfLpgzlp372pEWICBS4iORzNLWGac0HKC2JkIup9MbS9PYYldPCSEojwGjYPiMCrINado2daC7JbddOZW//c7jdHYnUFWBogi6epPF5rUAPq+LF1/bQTyZY9vuVuJJO9QoitfVxrIsVFVhd0MntTWluFx6IadKQVUEbV1xLi7k9TS39bGvsQuJ7bERQDZvsKehg4ljaxgxrLQ4bjqTZ+P2Jnr6Urza04hb1XAFJZZuYaZNjKSB7Mzym+hKysMBTNMqVtv136+aphQlCU6USWNrWLXxAGWRQ/dnOmvnc4WDvkHtbfoRws59sysqh3gdjjDApJRs3dXK0jd2k0znmD1tJFfOG+c07nW4YLHObruTYcDDhbwlBfizlPKZw2yERcAtwF4gDXzobE3mvIpSSikXYZ/swOd+OeDn73OkJekwBJfPHctra/bS3NaH260VjZCP3LvgCA2co7F9T+sR+Upul0Y6k6GjO87I4WUAdKVTvGI1E50oSKYElikpbdOYEijn7htn85dn1xUb+2qKSiKVozwSYP2Wg8QTdh+5nfs6qK4M49LUQrd7ezHXDRO/143LpTK+3vZsKIpg/OgqXjvYyOubm6j0B9jf1Y3bUpEa7AkluMxVjSUl+bxBPJnF7dLQTbuSThGC3liKgN9De1cCIQQBv5uGph5yeR1F2O01+r1ggO3FyoLJIeNJRYCwW1u0d8UxTJPKshCfev+VgwwlgN0NHdTVlBaN13Qmz960LRaazen4vC6719mAEKCUdvhP7s/R2tWOUAVCU/DnNRb/aTP5vInP50JKSGcGyzsAZLI6fbE0y1fbQpyWZR0SnxxwHMOwcLttw6erJ07Q7yFrymIfPsWS5PIGf35mHZmcjs/nprw0QF8sXYy45k2LO2+Ygara0gotHVH+639eJpHKYloWHckkKZeJlgMjb9pJ+ypgCeKJLGUhH+GQl1zeJJO1z0VVFT7xviuIlPg5GW67bjqbdjTTG03j97nI5Q1MU/KRdy9g4pjqwj18qHqv38C9aGodbtehpPZQwEvA7yZfUDy/6DC9pueXbuPRRRsKhQQKew50snLDfr7xqRuPeP8dHN7+iLPqWZJSbgYuGuL5gTaCBD5z1iYxAEfB+22Cz+vmG5++kZXrG9i0o5nScICr5o8fMp/kaJRFguw/ODgdzCr0vQoN8Fj94PXXaEnGmTKimpxukMnmSY8w+Ni1VzN3eB0r1u6jtTNmG0FI4okssUSG8kiAV1fv4ekXt9iGTU6nL26HifJ6DlWxe4GFS3y8+/Y5R2jmvNKwD49qGz+pdK7gFZBkhUVHJkV7V6xQim/nvvQvel6PC0UIuvsSGKaF5lJIJHO2ErfbhaooZPM6LkVB120jUwxQkhaFB9LWLvJ5XRiGia6bTBk/jNnTjiwoCId8GKZZ/N3vc+Nxq6Qy+aJXKBZPF18v6jMVjqtmJKPHVeJzaQgDtvW22R4hIcgfJlI5UNupL5YhmcrbPdMKiuOKqmBa5qAdVEWQNW1NJlVRsKREWrbStserEY1neOm1ncSTGUqCXkYMK6WiNEg6k7fDcZYkHPLxh7+u4dVVezjY0oui2LIInd1JcqZOXjfIAYot+1QIjyqIgjxCKp3nX756B22dMZAwaVzNSckG9DOsKsy3Pn8Lzy/dxu6GTsbXl3DTwqmMH10FwOc+tJCfPfwq0VgahJ0Q/6n7rsTv8/DTXy8lnzfo7I7T1hnD7daorY7w8fdeMUhdPpnK8cTiTYRDh3Kb/D43B1v6WLO5kcvnjhtqag4ODm8THGPpbYTP6+bqyyZy9WUTT2n/axdMZPXGA8XQSL9a80XTRtDeFeeRx1fT0h1jQ66D4ePLEELY5fFuF2QzLN67h7nD6wA7wbl/4VNVMAyD3miaPz+9FsO0MAyLaDwDUqIqglDAh6IKbrtmOtdcNpFRxzHytMKCLRQASWd3AkUINLdqt9bQFCxptwHRFdOWEjAsTNOibliEVDpfDM8YhnVEOLCfgd+bDkWyJG63RiTsZ9vuNlo7oqTSeQzTZMzISjxujcvnjmPlhgbyulmsTiyNBPD5PBxs7aWnLzVIC0ke9r9pSir8toelN5WyPTiGiSltSYSBDIxLC2xPXEssjhVUScbzIEQxn0wA4aDt0elvW5vO6ggkRiFny6WpHGjuwaXZeT75vElZJIDf58bvc6MbJulMnpeW7+S1tftsYzmdR3Mp7GnotNuUWALVtNO/ZH86kCXxaCoS2wBHCEIBL8OmnX4vtZrKEu5/16VDvjZpbA3/+ffvYE9DF5ZlMX50FV6PiycXb2TbnlaGVZVQU1VCMpkllswye9pI5s4cNWiMprZeBAzKbRLCrrjcsrPFMZYcLjiO07jgbYdjLDkUGTuqkk+873IeeWI10XgGKSVzZtiaMz948CU0VcESklxnhrbOLoZfUYXqsRcPTSi09sZ5ddUeeqNp3G6VvG4c8loU3CYtHTFcmko2aytX97cRqSgPYpkSt0s7qqF0zeixrG1twZKSqoqQ3d5DEXgtFTORR6BQUxGirSNGIpUDsPWRAm5iiaydkK1pRJMZ3C4VS0oMwySbHyzieDyyOQNVFeRzOp3dcT701d8QCniJlPhwaRpjR1Wwt7GLZDJHV0+S8tIAmqowcUw1liXZtb+dRCprGyyHHbffOLMsSUNrDyV+L5qqoGCHqfJ5E8s68k9Uv3dJURXy0gRNoaQ6gDJKED+QxDQlAUsj6HcTTWTIZguNawvtV/qnIYT9yGR1Mlm7MFhVFfYd7KaqPFRUM79q/nge/stKsvlDXq5+r5xhGOim7Bcjt8cteJbsqjyFVCbPjEm1g3Ls+mIpnnh+I+u2NuF1ayy8dAI3XTX1iJ5yQ5HLG6za0EBjcy+1NREumjaC0vChcJ7bpTF1wjAAeqMpHl20nj8+tRZFsYsBIiU+SkI+An4P67cetD2QA5LCg35v4T4eLEJpmtagHD8HhwuJsxmGe7PhGEtvUaSUtLRHicYz1NaEKQ0Hjr/TCTB3Zj0XTRtJV0+CgM+N1+viS99+lFChGa0EPEkX+YxOvDFJ6YQwpmXR0N5LqtvFb1bEaWnvI5PT7Qo3aVAS9FJRFmL/wS4730NTAR0h7ARyt0tDWnb7ik07mnnf3ZdgWZKO7nihusxejC4bMZKrR49h6YEGLI/AF/GQiueojwXoxqAsEiCfN4qLmiVtlcdEKsddN8zkk/ddSTyZ5ee/eZVd+9vJFRK6YbDq9vGvPRiGpK0rAdghLdOyvVZCCPYc6GDSuGGMqisjGk9jWZKvfPw6Aj4P3/7xIsIhH41tfcgheqMM/LWtK0bMlUbT7Ea/LpeKacohvWCycA4+n4uMx0KxQKqS8hnllE8rpTue4vqxY9n7UgumZdmK4QWvnmXJoiinlHZ4bOC4igRpWdTVRBhWHebKS8bzp6fXkCsYSoefRk43i0afpip2Lphiyy0Yhddi8Qy7Gjr53s8X88n7rsDt0vjOT20V8JKgF8O0eOL5jTS3RfnU+6/kWGze0cx3f/Y8Xb1Ju8hAEQyvDvO5+69mzozBHqJYIsO//uQ5YvEMpmmhG7YgZb4qTFWFXUkppTziZqgbFqG+rpyGgj6WEIJM1r7HL5879pjzO5yW9ih98TS11YM/t+lMnk3bm4klM9TXljNhTHVR18rB4U2HdIwlhzc5qXSusOB3FMqcJddeNpF33z7njPxx1VSlqHPT1NqHrpsECiE1AYwpLWVnvou+1iRyhIueWAo1YTHBHSGZy9taSKbEsmxxxt5YmkQqh9fjxpJWIR5kh4YsS2KZFqGgh1zOoKoixJ6GTh78w2tEY2mkhNEjyvnE+64gnc1T0+Fmvl5NoMbH9HnDmF5RQy6ts3F7E396eh3tXXE8bg2XppLPG1SUBdE0lcnjalBVhdKwn69/6gb+/j+fJpvT6e5NkdfN/inZfwCOc32UgoHRj2lJrJyJZdnVZ0qhGtDvdREO+ensTbBtdxvj66uwTIum1j5M3Rqyj1wRAZiQkwaWKaksC5JI58hYdjK0y6UiLYll2V4hV+EcTVWytbUDK2eRBLp2t1JTWYLb7yJq5kmmcowbVcXGZDO5vH5ConIut0oynWfy+BrecbOt9bRrf+cRocN++q+lELYRKQr3lKYqCEUwangZ4RI7H23vgU5++uulXDpnDH0xu9VKP+7SAOu2NNLWGTuq7lI0nuaH//MSnd0JKFx7VRF0dCV48PfLmTJ+2KA8qFdX7rHz50oDhfc/icul0t4dp7wsQDyRZebkukHhNrDP5TMfvIr/+cMKdu1rRwhBMODho/deyfDqyHGvIdjG0C8eWcaOPW0F+QKLaxZM5N7b59LSHuUHD75IKm233VEVwbSJw/nMBxaekGfNweF8cJar4d5UOMbSW5DfP7mGnfvaKSv03TItixeX72DE8NIznjsRCnqKSd79hliJx0t9KEJJbYCx9cNZ9+p+SnIlaB6Vts5ocfWUEmThF9Oy0A3beOnpSw0I/wjKCp6jbE7n0tmj+eGvXkIRgtKwHykluxs6+My3/oCUEr/Pg9utYW620CdkueJD9WglAYZXh2ntiPGXZ9ejGxaaplA/opyySIBYIsPeA11cs8DuwbxrfyfdvUlG1ZbjcWs0NvehqMIWp1REsSlvP4d7nQYaSv3IQiWepir2/EyLjq44nT12Uvkjj6/iussn0dTWRy5/ZCXbIBTsJGyfittQGDG8lLbOGKNHVNLRFSOVyRerCA3DZPTIShoOdpHJ6UQTGcycBcM0tLCGZUlaOqKEKwPMnVVLk9qKJSXBoAczbnvDDm/1MmgqCnjdLtKZPO2d8eLzQf+xVapVVSkqunvcGopih+BqqkqIFMJjyXSOzp4EB5p6WLXxAELY3sX+6k0hBIqi0N4VP6qxtHbzQZrbY+QN85BEgBBoqiCZyrFzbzuzpx9KwN+5r902ptU8C2c3sX67QXfUS8Lw0NmdoKayhPfcOXfIY0VK/HztE9fT05cim9OpriwZFKo7Hn/46xq2726jLOJHCIFlWby4fCe11RFeeX0X2ZxOWcFYlFKyeUcLr63Ze8o5iA4ODmeOs9cFz+GskMnmWb3pAKVhfzF3QlUUfD43L6/YecaPFynxc/G0EbZoY2FRzeZ0NKHy+buu4gvzLqPa8KPamdZksnYVVD+aamv3SGkbGR1dcVulWthVWm6XSknASzqTZ8rcOn6/cRONvVHyih1Ka++K09YZp7UzRk8sbfctS9nVda+s2MkjT6yywzxCcPPCqQRG+8nOcBGbptBdYZDDxDAtagYsth3dcUzLzj2pqihB1RQsUxaMQmvA3O1Fd6ChpCgFD9RRMEyLTDZPIpmlvSte0HgShIJe/vriZnI5HcuiKEcwJIUpyLRFrtAY2Sp4G/pFLvuRgNejUTeslA+/ewFBn4fa8aXkahSywsRQJIYmEQmLq8eM4ZJZo4jGMlSXh3BpKn6fG1UVxXke7pl0uzQ7xGhZbNzezDe//yR/XbyRyy8Zh0s7+oXoz/nRVIWgT1JVHiQYcBcFUrM5nf0Hu9ELcgWJVIa+WJrNO1poaY/ahnbBSO+vSjNNi3gyizHAmN2xtw3dMIqJ7YoiEEh0w57z4dRUliBkhndc/hg3zlnCl969ivtv3cg7r9rM/XeF+PLHrkVVj/1tubzU1sk6GUMplzdYubGBSCGEB7b4ZcDn5rml245oaC2EwOd1sWLtvhM+hoPDucQWpTz1x1sNx7P0FkPXzSOSTME2SlJDdKcfir5Yit37O/G4NSaPH1YU3+vqsZul1lSFBy0E97/rUhRFYe3mRsAumf74ey9nXEEH6bKLx/D0i5txl9qerv7PgdJfhYVAFGQEpLSbxwqXimJJJo2t5osfvZaHd23k1e4WjO4MGSPP3t5uyjQvyZ6CsGJB2VnXDQ629eFyqQjgsec2kkjl+MwHFrKip4mWqjx6RseFykEtSSspZnpKi013AarKQ0WjQFUUpoyrYXdDJ9mc7fHxuNSifpDmUjHS+aJ36fD19/CQXP+Y3X1J/D43+byBqil2InnuUCL50UJwUrF7wgkThGpfu7xuEPC6iSczhIJeOnsSKIoglzfxuFXyeZ1wyMfMybW4XCr1IoirU9DWG8fMW5T7XIwM+/BoGvfePpfO7iT7D3ZRFvEX8nwK74uiHOFVy+UMdMNECEE2r7N7fwebdjQzvDrCuPoqduztOOIchACXpjC8MovPncCy4NPvWM7vX5rP1n22QdCfX6QbJqYlCRb66hmGSWd3HM2logo7FFU3LMKy1Xt5+C+v09Ftn/tV88bz2fsXEk9k7fdKWkWZB4RAWhaapjJpXM2guV1z2USysScpC3UST4dBwvCKNFNGZ4D/5Z9+mMS0VOpHVPCRd192Um1XjoWum8gB3tl+VFUhnRm6wECCk7Pk8KbGCcM5vGkJBb3U1kTo7EkQChz6JppMZVkwZ+px91/86nYeXbS+aHB5PS7uf9d8Fr+6nYamHjsXw+/mI/deXqwe8nndfOJ9V/CeO+eSTueoKA8NMqZuumoK23e30dDUjUtTyGTt54UodKWWEqHYPdVqqsOEQz6QEr/PTTyVoyEeZVNPB5UeP8kwZPamwLDoNJJ4LKXY/sKyJLm8rRdkGLZ7Jq/pbNjWxLL1e3hg42rCLg95aS9AKiC9gjmXjaW89FAuzKRxNdRWR2hu6yVS4sfrcTFieCmpVI54MoNuWMW+dukBBqjbpWKa1oDqvsHK2EChekxgmJDN6iiq7Ypq7veWHOf9UQbYKmahlD8U8FBZFsLnc5HN6limRSyTR2B7mvYe6ObzH1pI0O+hprKEhqZuevtS+BQVRWhkowZdRrKY+/N3n7mRhqYeevpS/OaxN0hl8nR2JUiks0XjTxRa0CjCzskqj/jp7E4UE6D3NXZRXRmisjxIV09y0DnY3xx1IoFepNSIp9x09Wl85JbF/PAv99DTlySRzGJZFrpu4narZHNGoTkx6IZFZ1ec++6Zxz03zWLD1iZ++OCLpNJ5NE3BMGDRkm0cbO1l6oThREI+ovFsUddKWhJNU7j/nfOP0G2qG1bKO67TifZ67IbHQlAW9hNPZfG5s4yty9AWq2BNTwuv/vpP3LNwJrdOnMjIcOQ479yxCfjdjBheRlvnYA9SMpXjussnsbexi+bWvmIul5S2eOmV88af1nEdHM4eZ1eU8s2GE4Z7iyGE4IPvnI8Qgp5oilgiQ09fiqryEm66asox921o6uYvz64jFPBQFglQGvZjmib/+MNn2La7jd5oivbOGAdbe/nhgy/S1ZMYtH9J0HuE1wlsY+rrn76RL3z4Gu6+6SIqy4P4C0rTdt8xDSR25/nyECVBr91tXlNRhGDdvoOkNsZpeLqJ1tc6MFImetwohKEMTMPC69aKnh+g6A3J5026e5P84P9epqc3RTSWJp2xm+ZOHjeM0cPLaDfT5HWDhqZu2jtjqIrgq5+4jisuGU8ynSORyrFgzlhuvnoamaztSdF1O3xX9JIpAqPgBRloHx2efGsbE4U5QjEx/kQMpaH+7Ph9bgzTwrIsLrt4DPf/zaWUhHyURwJUlAWpqQwxoraU55ZuJ5vTedcts+nusb02SEk2b2souV0aT724uWggVFeE2LSjmT0HuujuTVIa8dvim0KgqgK/z82wqhIiJT67CXBWtyUMhCCft9XOWztitqo3dsgSBXIRyFRA2iPYKsK0ud2YQC6v4HJJvvfZVt531yWMGF6Kz+vC5VIL3iWrkKNkaxcF/B7ed9cl+Lxu/vTMOuLJXKE3IGiagtetsWNPO8Oq7IqycfWV1FSWUBYJUF0ZYt5Fo7nu8slDXufS0lpG14WZOmEY0yYOIxTyYpgmLk2QNDys9XbTHM7QSZrfrd3IRx57nFf37j/Ou1d4z6VkT0MnazY10t4ZG3RfvP+eeSjKgM9tNEVFWZBbrpnGx+5dQCjopTeaorsvRV8szSUz65k/e8wJHdfB4XwgT+PxVsPxLL0FGTOykm9/5XZWrN1HR2ec8WOqmDdr9HHVj1dvPGD3+DpMWC+VzpHNGbg0BUURJP8/e28dZtl1Xnn/9j50+RZXNZO6W90tZlmSZdmSZZYpjmPHE3AyiZM4yTiTyUzoC00mmdBkJo6DDtmOIWaSQZLF0OIGNXMx3bp4aO/9/bFPQbfAMgtqPU89XX3r3nP2ORfOuutd73pbKXONkK/csZcffdPlz2pNriM59+xVnLN1JUHg8Y1799NohjSaEdpotm8eot6K8DNyoZRmpmY70R698zjxbITp6MWUs/nONGNNvwN9FfYeXJyPON8irpRhptZGBIJ4lYCOolCTxM0mw0cScmcVUfmU9/3efxAnNqNo49o+3vOul/LjP3QlP/bWKxbOwx/+1c0LgYlnlkXmVZ4z4XsOcaZ2SWkHFydppnAYQ5Iqojj9tj8cwsiSlNl6m7M3DdHuxHRVCqcpZQAzc21uu2c/j+8bsYZtowmVQsps3tt4jQ9/5gHu3HmIy85fx6nRGiMTc2hlSFHZzDmHwHcxxlAq5li7soep2SbtTmJjBoSk2Y4g66FzHWfhWGMfZs8SaNdkkQiSBgHTvk8pr9i4HlavWEHgW6P9edtX87t/8UWeODia+bEkBkMucBdeH7NzbfI5j8eeOEWSpChls9TnIxKUNrQ7MT/0uov41JcfoauSxxjo6ynxy+9++UKpWilNqvRCuVnkbsREd+E6CoRPmirK+RYj02t4InZoeSlODCpUtJKQthfxXz/1Rd5/4+u57Pz1T/tc1ept/s8/3srwWG3h+b/qkk38p7dcgeNINq7t4/d/5Q3c/eBhxibmOGt9P1dctJFC3qdazvOHv3YTu/eP0GiGrFvdy7pVPU8qty9jGcv4wWCZLD1P0ddd4qYbzgcgihIOHLWt3JvX9z/tYM84SZ+kXqSpVVB8z10gUVJK0jBm52PHnpYsGWMW0qmXfqALIXjXmy7j6myQbC7wKBV87n3kKPfsPMyRE1MU8j5jk3V7US4ENCYj8AwmMYuzRQxIX+JowVwjpFKy4YxxNrbDcayPaT5zyFOCUk0gxxVGaaQnCOci0kdSdh9I6Mnn0cqWZw6fmOL//fM3+K1ffM1pa5/PdTKGhQyhb4YwTLKcJat0qSUSUi7w6K4W7DgPB1BPv52nuyRqbewxt2O2b17BnQ8cWsiQarYilNbkcx5RnPDhz+4kH/i4riSKEjCWWMyXLjGG46emOTk8gwF6uwp4noPWOstwsiNihICergKdMMFow6oVXRw7NY3ReqHsKOdHl2RepuZGgfDBicm8aZBUJJ7RlIfgIKvZ4R4Dz0YP9HYV+I2fO49f+cMaxycaaGPVr3lvWk9Xkdm5Fnc/OGrLuGLRv6O1bSTI+R693UWuv3obL7loI0dPTVPI+Wxa17+gBH72a49zy937iKKEtat6eccbL2Xz+h2Y4n+G9j+DaVHKh+w7MsAtj72SCaeNo8hUTIHvu7iOoGMU7//EHZy9aei0MtpS/Osn7+PUWG0hh0lrw50PHGLjun6uzcppvd1F3nDDeU/5eN9zn3J0zjKW8VyEAfSLqAy3TJae59i9f5gPfOhO4uzi7nkOP/OOqzl/+5on3feic9bxjfsOnhYDMK+guO6S0lp24/DYHL/1p5+nt7vAK1+6ne2brYfpnoeO8KkvP8LMXIuucoE3vuoCrrl00wLxEEKwcW0fG9f28Y17D/C3H7kLR0p6uktMzzYZGa9RreRZNdhNsxXZDqlEEJ2xXg8J0pp/f/KHr+JfP3k/B4+OL5ApvUT+0QbKpwQhkObACHCFwLQUE7U6004D37Mt7J5ricGp0RprVnYvbGPlYJXd+0cWCMEz5iBlSJXJTOwQlSGtCNy2IZi1ZGntyh474LbVeZJ52khAP7taeJIqvn7XE5y3bTVpqth7YJRUKTv8NttuV6XAUF+FdqfIqbEaiMVU7YV9GlAZ+Wi2YxwpM2JhS46lvEcu55GktpGgVu/QaIXEsWJp+4B0BdoY1qzoYv/IFHFgcJVAZaqTcMELUgqBobuQcveIyxvXO4j8WzDJAUzzzxmb69A4ZyP1WgGBQ6XusCEq01PM0w4TBnor/MO/383qFT0cPDaB0oZ5v7NShr6e0oLSUynnOX/b6tOO9SOf2ck37jtAtZKnmPcZm5zjz/7u6/z2L72GlYOvwgQvBXWcnCjxyM0HODk2jOgzRCi0NgtEyWDH6pjUsPfgKFdcuOFJz0+rHbFr3whd5aXdboJ83uf2+w4skKVlLOOFhGXP0jKeF2i0Qt7/r7cvZBJ1Vwu4juQD/3YH07XWk+6/ffMQ11x6FrV6m+nZFtO1FtpAd7VgfTqZyjSfbB2GCbV6mycOjfFnf/917tx5iAcfP84/fPQuojilr7tEqhT//Il7uOeMFufRRoP333cvf/ShrzObhgQFl2LeW8jf6XQSOmFM4DuIbOSEFFaxcIS05u0kJU5sGetfP3kf9WYHpQ1K2cTpeX+L69oSjlYaPxXkGuDXDWJWo+Ms50kZoiwHKU0107MtWh1Lz9qdmJlaixuu2Uax4C+0pj/b0pmRkBRtF1u7z1BfB42V4Psu9UaHnmoRx4inVI+e7RvQGPg//3grOx87TpIq4iQljBYTyI2BRrPD7gMj2UX+9C0vdFWJxe1FUUI7jHGkYPWQw1Bvyo1XFzhrXQ+VUo7DxyeZnWs/pcpmCZqikI8Y6MsvlEQxoCWogiRWHko5pNpQDLoR1f8FshdT/12Oz4X83kOb8QoOeaHwdEKzRzPaE1Jvhtz40m2UioEdhJxzOXvjIIFvBycjIAhcfupHruLxfcM8+PhxOuHpnaD1ZsidOw/R3VXAc636WS7mUKleiNgQsoDwtiHdNfzcu17Gu958Oefk+5GuwPMc8jkPkw1q7lU5fC2ZqbW4/f6D3PvQERqtcGF/llw+OVZCCkEUPTuVchnLeL5h2bO0jOcFdu0bJknUQlecUprJmSaT0w1+7jc+wjWXbebtr79kYVxImmrO3bqSZiui0QrZummQay49i6/ftY/Pfe1x4kQBhiSVKG1Yu7qHfM7LyjwpH//8Q5RLAfmcTz7nAVY9MQY+9/VdXJUFYh6v1fi1r99Mcya0k+eFojYREjQFnXaM1oZWO+bY8AyV3gJ+waNdj/ADh47KWqzF4pT63q4CB49O4LoOnrsYdigzMzLY1OalHVVPBdtNZ8ertDsRE1MNvnrnXu576CidMKGrmmfHlpU8/sQwc43Os3oOpIB0vnqoIDcNXhucFFSXYeVgFzqbsfeFW3fRaEb2w8I9vfPt2SBJNZ/5yqNobbLyng2JnBfYUmVI2/GCZ8Zz7Xw+g1WTlkJg1TiJoRM2OTmi6akk7HzsGKUCjEz1LZbvnvK4DeiYE8NTrF/RZsx0U/cgccF4wv7dCMKWT6c0yOt2vALhrkZ3vgamzZdObEUZ6MsrCms0Y9OSettnNp/wize9hNddfQ4AL718Mx/93P286rInuPCHH0XQ4dhYif/4xoX84V/dTHc1T6WUJwhc/su7X8GmdTbOojbXztK8TyeNvu9warT2pOPxPIfrXrKVl125hX+4byfvv+teIhQI6FY+m9sVJpt1Pv6Fh3GkyOIRHN7zrpdy3rbVVMt5Vq/oYmyyvlCmM8bQakdcf83Z39oTvYxlLOM5h2Wy9DzGfObSPI6cnKLdiZFSks/5PLr3JIeOT/Lal+1gcrbJzseOM9foLIQanhqrceGONbz1NRchhOAb9x2wydNTdVat6DotpTnwXVuSGQ/pO8NcnAtcJmcaC3EEH9r1KGGc0lssENJASknUTqi3UpxM2kgdQ+gntGp1wrMd1IwiLhmMA04bHA3VyGVzoZdTk3O0qwYpFPmWQChLEOJE4RpJV7nA0ECZWr3D+GQdo/TThp5FsVWrpBT88Qe+SrMV4vnOgnn51GiNdau6abZC++3HPD35ssfu0UwS3A5oDwpTIB2BloaZuQ6HT0zxvp96Oa12zOe+sQvjWqIiRZYY/mxqfRns0yaoN0OS9OnVCpuZJLJZdadnQ81nERks0XMdhSMVrlQYk9JXjRDCJU3mgKdO6RbZd8NCXtNV1sw1c2xI6uyuljDaITEGBfgAGs4L+rh05apsAXXAMNzyiEPB/rEcUSLI+SnrVgQov8rW7SsWSlkvu2ILQfoh1vTcS60R0Il8+qotfuHNd/AXH7+Bk+PQXS1itOGv/uUb/MlvvAXXkYtfEM4YiBtF6QKheupzLPjpKy+jt+XzsdseQaaQ1w6NtLPg5ZrfXhgl/M2H7+TPfvMt5HM+P/FDV/Inf/d1pmuthYiFdat7uOFpuvKWsYznO57NuKQXCpbJ0vMYWzcOIoQNEgzjlHYnwXMkidIL3273HhhhbHwOpTUztTalYsCmdf24jqTRCvnHj93D7//K63n7Gy7hTTeeTzuM+fBndvL4E6dO25fOzL3rVvU8KeOp3YlZNdSFEILZuRZ33ryPZDKmiSUEaVuhOimIrAokra/IdrsZ0pmU9kqBmwi8UKB8TQLM9RomSDhajJhvRpszhq7jglzdGmh7u4qsXtFNtZxj49p+pmeb3P3g07d5zydDlwoBndCqXFGkKBUcPMchjBOOnJhmy4ZBhidqqFTTiRKEMBhzegCl4wg830WoBBRIBToHYRmMFpiOYnhsll/6nU9k6o7GSKu8CAlSZ4SJxfLNMyXbCiBJ04Vy6dMhjlPyed/6kXzB3FxkCdKSzzXj2H3t2DCO5xlOTVTQRiCIwShSlWeRWp1xDjFICf3dinYomZxxEdKlb1jRLAq0C24oqEiXvmqJLWu7F/1s3lYMknxHMTztUcDguYY4kRwejhgYillZrizsy3VCrj73AK1oHTONafI5QZJ6eE6Tl198gH+7+XImpuqctX6A2XqLD93/MPfOnGKm06GwzaW2t06/Z43sjWZEPu/z8qu2YoxhcqaJwHbPndl19ubrL+DK8zawe/8IUgpOjc5yxwOHTiNeucCjNtfmwJEJzt++mnWre/nDX30D9z96jKmZJmet7+eC7WuWZ7st4wUJY5YN3st4nmBooMobbjiXz31tF81WiEoVIBnoLZMLPA4dm0Rrg+c5hM2EIMsqmpxusGKgSjHvc3JklkPHJ9m8foAg8AgCjxtfup1H95wkjBJygYfSmtpch5dcvIGXXLKJP/u7W6g3Qwp5n04YkySKt776QurtkPf93WeZjUO8iiAfS3TboBOF1tbTYwT2Yoo1zhoNbhu691qWkOYNugub2ZMonsjP4icCsogl7UBtPfTvMQgD9WaHPQdC1q3q5qz1A+w/PPaM50wIm7AdRklWdgSMWZi35jqCRCtyOZcdm1cwU2tzanQWgFbndF+MUja00kGQYgi7oblu8cPD1eAcUojojBJYaECC0SyoSkJYT9OZ5bKl0AbGsnExTzWfbvEYbSfY/DmXYImqBJl30G210JnXiVxA4boaJ2OyBoXnPl0JzhIorQyjUx7NtkQbge9qjIZgJlsDBpGHqfEGg/3lxYe7OzDeZUzuapAraGJH4GuNcX1SBP1zHiV/STentuc+F+SQQix07UWJy4qeOataZp6qkUKHDx94nL5ykaLnU1MdWis1XTMaExsuOX8tb7zhfDqdhP/vg19gZGIODKwYqvLK1+6gu7vI5p5efBlDeoChbpehq7cihMd/fOnhp1QAjTg9mLRSznPDNctK0jJeDBCnfwN7gWOZLD3P8frrz+OcrSv5yh17+eqdT7Cir0qx4KOUptWJFkpyrbb1yriOZHauTbmU48TIDI045hf+18fpGijyM++4muvOPovNGwb4mXdew4c/s5PaXBsEXHXpJt5506UEgcd//Znr+exXH+PkyCxrV/bwhhvOpzpU4Mc/9UkOM4UegkSl5CJN34SHTjRJJbuQGhApkFgBV0vw50Bn18fcDLghtFaAkYZUQ0E4KGFLa1IZlCMIy5CftZlRWhu6KgUe3XOS6VobKU8vPWkBaQHaK0HloTIn8E6cTga0NsRpijGSfOBZFSLnUywGGFgwELuOIF2SuTSfMyQAvwbV0BD1QVoBIQXT6w29u0DMP2Te3XgGF5lPzf5mMGRepGeINvA9h06UmdmTLFgz26duLa7XdWGunacTpWxaNYPSHhOzebqKHYr5hKm5p1qQLeIpA76b4rkecSpIlEBredrdbJq5pNWOaLYipLRhlyr/X2jM/SMX6zqnCoJpt0COHFviPIXpxU0Mj9W45e7DvHRLHUNMnKR0Qsuau0oxR0d7UUpTLuVohhFj1YgdlW581yWux4QP1klaCWNByvq+Hq65dDPVSp7//kefIYpTuit5GiLhK+lxvvjFY6xd2cPFvcf4xR0PUfYd+6SJMpR/nYvOWcPN39iDUhonU5fmGwa2bhr85k/c8xhGTWCiO0BPI7zzwL8EIbwf9LKW8RzAM1kUXmhYJkvPc9g2/X5+9p0vpdNJbDeU52AwpKmmkPeolHOYLGMnUnbS/O79IyjHYIoC1zOMj9X5/b++mbF3X4M8mfLl2/bQ7kRsWNPLO266jAt22CiCVGuGVlX5lZ+5AXeJefbXvn4zc2GIryW+49AhoeWlzJiIQseQ71g1RGMVofn3mFBW8TBZpUK7VmlyQtBlgTSCVUNdOFJy9OQUSebDka4g8B2MNlRKecanGoxMzD1pSKPBEiWA4kloD8FsryJwoXJ4SZFJWKUnQXP1pRtIU8Xh0Wkmm01ildpOJ4mVpoRBeYC2Rm6ym6UCIiiMQhhD1G0wHiQl8LMwdGmeUqCwf3MlkdAgIM1nRvElYpZwBUaCUjYLiafZ1vwg4/lBskttUSazSTmupBBAGPlcev4or796D91lw0e/tp1dR/qZrJWfYsu266/TD8YXOLFBt8ARBq3nYyPsPgLftUNrBXz+ll189Y4nAMG5W1cy2F9mfFqTjOfJ+S7nDnVRLedptEJWr+gC4MiJSf7333yNJE2Zm9jK9Rc/iCNdtHKpFGOixOWL92wgSVNyvkvTJAz0lfFdl5Ksc/zBSZxY4OYCUteWkf/fP9/GW15zIa12RE9XEY3hsdwMBoObQL/b4IfX3cKROY+z+1YTOC7oBqbx+6xf/Xe89uXn8MVbdy8MYfZcyc/+6EufNtfsuQBjIsBBiG/vo94kuzD1PwCTABITfgW8bVD5bYR4ak/bMpbxQsQyWXqBQAjBz//Yy/jSbbu54/6DpInm7LOGaLWtX6WrUuAY0ySpQgqbkYO23hK3KHELDmkn5c8/ezulgxrP2NEWj+49xehEnd/6xdewN57mo7sfJ0xTSn7AO889n1edtZm5KGTf1BS9hTz16TYGCKRrIwj6BIVZF20g0ksGhmZXcIHtCpMR6CDz0ihLKlZSZEZEFPI+5WKOcilg/7EJOjqlmjgYNEJKoji2wY9PAe3ZbYqMROWn7QU/rliVyZ1vesvsOcYRjM80aHoJpwZCelaXqEqHyZ3T6NTQyWma6wQqsOUXrwnVE8ISJQxSQepCMAtRdcm2lz5XT/kEQuRZFSjJQ2u1vV/Xfqu0QZZtpM1C4rWQgiRZlKiktD6aNNUorRDY51ksZUtAPlD80CuOcvV5x9GqxZ6jg3zitkv5qZtO8ItvP0EjXs3bfi2H66qFaAKATg8012WL1TBWyuHkszUKCcbgew6u67B14yCu67B73zA93UWG+ioYA3fuPESzHTHUX2F0Yo44URw9OcXKwS5cR3LTKy+gGcd85LM7AYhjxadvX8+JMXj1FQfoKnV47NAKbn7gXJphF1devI5rL9vC9h0reO8tX+Sl/XfR3zzGR8w2qj0RkXJpqNXkcy6dWoddTwzbhHNgVkbEQpEzDjGKc6qHcKUhjl1mOh1WlMsgy6CmEelu3vSqS7jsgg3sPTiK77ucv20VXZXCU78hf8Aw6WFM6x8g2QfCxwSvRBR/9FsiOMYoTOMvARecrvkbIdmLCW9F5F/9PVn7Mp4/WDZ4L+N5icB3edONF/CmGy8AoN7o8Bf/eAsnR2uEYYwxhoHeMsYYputttAQUqEjj5BxSpYnbKabskouszJ4qzcRUg9/84JeYmK4jE0G+LyDeKvnrB++n5PucP2QnuxeLAYW8nR6/MGzWQKHg01oykFZKgV4iiwgBvoJY2fV4MVSnfIp16NtUpaUTTp6aI05S8iWPt607B12NufuBQ3SihFbr9JLUaXxMWvXKsjKQySJxSnNLyBJWucETdFTCWFdIi5RO3MSRArcIKoa5swBjkLFtn09KgtlNhu59LEo4EpKcVYeMhDSwKtF8uLc0i+ubh/KsObzdZUmcVJboNVdBVxZhpRJbihQm67jTBs+TGG2VEyms0qe0XhiIC6crbZ4L//Udd7BxxRzNKM+B4z0cOlVmrqG56/G1vO76S1Dua5HyQ+R8QYjNcjICmmtsCXWhpKgEaR7CXihO2Ru1hnIhQCnN2EQdIQUDvWWmay2U0jYrSxlq9TaFnEeS2lyvTpjwznddzt8eeZhjD8/SeGyage4yjZk2Qkju37uO+/fYdGvHsU0Nnqc5fGyK2VqHoYEiP7n1OFvy97BzfDXKCGIl8WTMSu8IxCNo1UcxvwZH2k61NDuQ+cMp5RaJYbq0jgtgbCbXqqEuVg118Z3C6DomvBnih0D2IfKvRXjPPNvxWW9bTWDmfgvbddAPpBB+HqNnEJVfffYbUsOga+D0Lt4mBIg8RHfBMll6UcPw4gqlXCZLL2BUynl++5dey8GjE9zxwCHuuO8AQwNV5hodas0Oymh7fVeGOE6Jo5QkgKStCFNrCHcdSTOMOXV8mkIlQBYk4WxEdF9E9coe/n3341yzbj3nDAyyd3KCjWv7mJhqMDY1h3ZhZVhg7cpuDh+fXPCbGKyqtUAulPUuCWVLcAaIhAKVMjQK0wdrJLnEZi81EnbuOsgf/OpN3H7fQRKlLTETEJctwRAhuFHGjxKQqd2P8myZz2QjVZwzIsONNjhll0LgE8o2UgmiOCGf80gLVjEyAnJGYaQdmOsZTZSTJAVwWwLjQKcbokFQgT2e5jroDELxFHitrM5vLGmaPwVagmyD70FYxC5QG+Jqtt4lPieNHWEiJeR8Dy+QtDsJSmvCyDyj+fv8s6ZYO1BjfCbPrQ9tZM+xAaTUONLwd5+q8rFb2rznR8foqhYYm5hbUJbSvF2SWLJpmbFO1Q1yRi58cE7XWtQabS7cmrC6f4Ra4zDHTw4xW/cXUtejmRQpBEIKVg1V6e4p8i8nduEISX++QBjMMV5vQKIxqT7dg5atKUkVvmcTyN//Tx/jz9/7eZppyuBAA2M0wihyjsEVBoNEmBpXnXeYON3II7tP4uYlussQpSk9lQLD0QYMjyAwVHOBlTh1255x77tn2ja6jqn9KugJEAVQRzDxvZjSzyNzr/jOtx9+DUwIznxEgmdJU3wfRo0hnKFntyHhw/yAxtMMdQrEU498WcaLC8/UvftCwzJZeoFDCMGWjYMIIbjvkaMYY6iUcpSLOWbqbTSGTpygYmtMFkbgtiHGqjW+ZxUnEwgc1yGNFGlLoWPN9G2TNM9u03lFwnsvu4Lfuu3rTLRaOEWHoXw3jWNNijOC/c0J4iW5QEYv8dDAfFUHJ4SwD9qrBK5vvVRjo9OUaoZCpsO4Lkx2mnzg325HBYYk0qgAapstGUKAci0xKY9aEkI2VsRJICyACcBr2DynpSoUCsysYto0yDc0c6UU4QjSRJGbMUS94EhN3ktJlSCMvQWDowg0ounYcmOf3ZbfsN1oGlA5S+SkytQuw8K4E7C3q8A+pjNgfU46u9/0+YLSYUPQWLJWAUpYFSnupBhts5vE4iafEqsHZgh8h+l6hT3HBvDdlJl6gShxiBOYmKrz9x+5myRNM18OGKNRqQBhE5Y8qfGEgkQQSomnNAKD0g75nE1if8u1D3HN+UdsKcfAG692+KtPXckTxwaWrMagleHUaA2/P0AZ6M7lAahuKjO9Z5Yk0U8r9EspODU2xyoTI3SLuUaBwZ46122aY+aq/dx8/yaaiYsQhkR5XHR2m7NXfI2t7/wn7ntkNXftPIzWLse7mhSLOR6dzrOpsInrVh6nIo9DPJvtaADT+SoUfvi7MtjWhF+xRMlZci5MBK0PYoJrEOI79ECpExnRWQIhAQf0FDxLsiScIYy7GdJDi+qSUWBiRP7G72yNy3hB4EXElZbJ0osFZ63vZ/O6fvYfGadSzrF+VS+dNKERx0RlSwTSLoHTsOqLk7Iwd0wIQTmfI4lS0lqSdYwa4lCR7mnwY+/7Z264ZhtrpwKmx6eROYfrz9/CaHGGu+esizrRp7d/zV/UjWNLTXEFysNZqScxqI5Ch4qky2DWQdcxk80ws3WoR/eeJM6yhuqb7JplFi+gcuC3bSnMSRYjC1LfHlduAgojlkMtJW0C0LFmdKKO60nKaMJecFNL5PwmmFXaJl9L8L0UbSyhGHA7zFJEFeSCojUPiS1PJWXrmRIZmzFZx9h8+reZN5kH838TuKH9Zt/YBN7+JdstCXRkcIouuVBkozfEgh/n6TDbKFPI5xiZKqGUYKxetgqZq0lSB61heLyG4whKBUjTFCEgMIIwFHRygq65mHTMBwG+gIIwJFriOhrPlZy9doxrzj/EbKNgny8gCBJ+5qb7+a/vfw1J6iwkiINV9GYbbXJyMV+purFMXE+YqddsxMIZsGGbBq0VI+MNPNdlZCrHYPcEAp+3XPsE29eNc9eujaTK57JzIy44u4MkQTgx11y2mWsus/Pa9k5OcNvRI4RpysY1v8Vg9TPQ+TjIIavOCB86H8XICiL/mmc8v88K8UNWUTrtgAIwLVAj4K7/zrbvboV45+m3mazG7az8ljYlyu/D1H8f1Oj8hiD/ZvAu/c7WuIxlPM+wTJZeJBBC8Is/eR1fvHU3dz5wiEQpnA05NmwZ5ODwJEVjB9fW8xHxgCE3bEMoy6U85UKOUjVg/4lJW0ZR9qIuBLhSUJtr89HPPUhfT5FNK3tIUsV9tx2i3grZvnkFx6drJGHH5j1N2tqXcAXGNTRWQdQNMraqEjpTXTAIBDKGuAuUM08yrBqhlEHkBQpIiwaRZGQn66qTqY0jMC6ZcRswtixWWpK3+XQ6QZpoJFAYW7yTPweio2kHLkLZQDYn0Lxi8Dg/de3j/NoHbmQqLSykAyzdthGnEyjDYknLYI/NiTKfk29vdSJ7XsAeS1SB/BQL71ojIPAc+koFOqHNiWqHS3byFLh/Tz8/9to8XaUWYexijMBzFVoLlJYL5DFVhrmGPcf9RcWqnpiLSg0OmxyjU2WcnCZVkiDWJB0HBOR9S6zOP+sEWkub8yQEWhjC2KOr2GHDyhkOnOh/0vmJpiLUXEh5wBqQhRTIQQ+OS/q9Au12TBgluNkIFzLCqrWikOvwa++8g+5SHWNihLAhots3TLB9YwPcbdmdWyB6QVROOyfb+wfY3r+o8uiZR8E76/RSk6xA59Pw3SBLTj+o02cpWrlV2/2QZTel+zDJLhBFhH85wul7VpsXuZdjws+DmgTZZTvZTANyr0XInm9pqcIZgK6/hHQf6Dq4mxAL5b1lvNixbPBexgsS+ZzPW19zEW99zUUcmZ3hv371yxTyPl2FPLV6GyTkXY/CKpe1Mkcx7/N/f/dtfPZrj/PFW3eTMw5tpRa72KTApIaOSfBch1q9Q7UcIoWgVPQ5NTaLs6oHL++iE2iHibU+SHB6XWoDqVWxQnuJjsuZGTuDNvataIwlQTo9XTUxCniacOS4bEtaRtr2ezFv7M5Kfk83wHZpWW7eKjRPagSQ2+Og+ySdbnCMYWAqZvZkhROVKvVWDsdY03iaz8zkZGU37Nw4lmzfYNejfHscMrH/d6IsMuCMCIS4aP/mGgHZ0NrWZEhdd9DaLMzMeyaEscsf/PNLWdN3iCR1rNFdSTqR96QPPgOYUNKoxLzuJfezbnCOv/rkFfQMhBgcdOoSJw7jMznC2MXSS2FjBAQLMQsGEI4tK0ZCWtXsDAGsWsgRzmgmSy2qQY7hiVkmG026laAZW4Ltug65wCVJFdqYLMVc8KaX7qa/q0mtmaenE3JqvJ8H9w3guYrLzhFsWufZcEujoPTeZyylGWOsqVmeSUx8MLPf9Pw+G4jcazDRPdZXJHKWJOkp8C9DyB6MMZjWX0F4G/MvAtP+F0zpvyGDS7759mUXVP8I0/k4xPfbjr7c2xG5V3176xUSvkvm82W8gGDEssF7GS98VIIc2lhC0ttdZGauRSdMMIHAjQW+5/Cf33kNnufy5lddSFc5z1988NYFv4yUEpF5ZubntMWJYu/BUTxX4nsuxhh2HxihEyUoCXgskKW6n6I82/k2X47RADmQrcV1GikQ2pyWN7SA2CA8cCKB8q3iJTIjdGuVLVu5HdvBNR82a8TT8isLabJYAFsSzE9BMCsWaIRRksKEoThpcIRm45oGrcTj7z9/KdrYElzlMDQ22nwngyWApWO2JKjdrOTmQH0juHXwQkuYwj7ITWVlQ7OovCjXdsjFAuJuwBjKJ6EwDanR2cDYb16Cm8eJUUOjuQLXVbQjD99VOFKTakt2FiHAwJauGZptj6lajpl6nr6uNr6bEEsf1/EY6O5wcqKEFC5xonhw/xou23aIwIVST5mx2QbHmiU+c+wi9vT1QjfkJqE4Yk3uvucQeC6v3rqNuSHNXUeP05qNOIdeSqskJ4Zn0dqgVEoYLQ4IBkPgaa7cMUytVUAYw0e/dh47961BConB5bbHqrzlumFuvLoE+R9G+jue8dwIITDeNkgPg+ha/IOpg/vdIQzC24Yp/QK0/xH0jCVL/uWI0i/YOySPQHirJWxZhyOmA82/wPgffFbt/8IZRJTeC7z3u7JmsMZ01Ijt3nuWKtcyXriw3XA/6FV8/7BMll6k6CsUuHz1ar7yxAFasx0EEBuNig3nlVfznndezeYNtjQhpeD6a7ax++AIX7xlN2mqUNpgtHnKN4tVOFKSVCOyFi5psuYiDwgg9bJuMAEYYcecSMC1Lf0yse3xANVjApHtSGSphwsKkIHSScPcxixTSS62tzfWQdcBu01jbI6TsEt7ShgMyrWJ30KAygvqG6CaGoKGwHEEKhvi6zk2GHKqVqQe+3RC317XMiN5137Dpk2THJ3sRjcc61sydsPCWP+U8kH3wTwP1A7EPZAfg86KxaiBtGDLisrNjgWor4fcHDipsHlKZ1gtn+ozzADGg8GBOXqCkE7oEUUuygh6K00maiUMzoLpXhhwhKLRCPjYredz7oYxVvXVGZmu0FuNcByVFUsFW9a2qVbWcPiU5sjIEHfuOpeXX7gXkYS0ZIkPjZ7D5EwBmdrj6gyB4wkGJv0sTdzhpRduYuPafja3K/zHQw/T112CMuQ3+tTm2tSbITdeu4NEpfzHFx7GdzW+bwu2RsPJyS7u2rWeoe4Q6eQp5ttcd/FxVvUdJw27cE0bI38e4W54hncGiMKPY+q/BWratsmbNggXUfxPz/i4bwUydx0muMp6gWT5tPKYie6xUpxYon+KPOhpSA+Ad+53bR3PBsYYTPtDEH4Wq8kqjP8SROkXloMpl/GiwTJZepHhxMgMdz1wiNm5Nht6izCaoEoCIaBkfNY1iyTTCWtXPdnbcNGOtTz4+AmarYjZWgv1DN8q5ktCruuQpMpOjpC2epTrz+HPpoTjKbm8R607wZuF3KwlPHEV0iL4MayKC0StiBA7WsL3HMI4BW0WvEFBKOh5wtDptsTCb1qFRjs28BIyH5C0ZOqpykDzcGJwYkFcApla6hB1C/yGQS2UCAVxanOoJmueJRfSdrM53RIxpbn+vEMcGu6lx0TMyRxKSyQmI0DC+rPOgDBWeSqO2mMIeyApZHEHmfcKDRKBEYZWL5TH7HlYyFRi0S+1cIiZWGQkGEeTtFyOTvXguSnS0UgEnqcJPE07cearZwBIFwqFBCfR7D46yKuvOMjIdJnpuRyuI5hrunSVOrzjhodZPXAHHX0F//zF89l54GommpewsmeET00ZRlQBp5hDuwkmNjihDbmMxhL6KmVede0ONqyxJyXw3dP0rcB3Geyv4Psu/b1Fbr5tD5ViyCsuPsD5m0cRQrOir8HOfavBGKTUCOrcdPVjdJdiZppVGu0S3e5JTP23oeuvEfKpE8oBhLcFqn+CCT8H6RHr08m9AeGuedrHfDsQwgd33VP8wX1qtivgm+ii3xOY6BbofBJkb7Y2DdFdGFFBlH76+76eZTx38CISln6wZEkI8SrgL7GfAP9gjPmjM/7+TuDXsv82gfcYYx77/q7yuYW9kxN8Yu9ujtdqbO7t5W3bz2FTT+83fyCw87Hj/N2/32nVD1cyMdWgEGnO2zyIdiBnHKQrmG212X94DK0NN9++l5m5Fv2rKqw4q4dSdw7fdRjqL7PnwOg3lWFTtdSEBI4GczyyRvEiRO2E4tSit8ek4CZgJkG6hp7+PKsuW8HO+4+S8z2kI0lShQKUa5CetF1RAoK6vcjPe4OcJQqSzVcyCGNVKrHkcrzUp2TJhsFvgnsItCeIukEXDCYRtrtuyfEtPFbbcpqcNHQVWzQ7PsZAX7edVdfoBAv+oFQ7tkTnnO7RMo6dnyewfiuvYUeLpKUzCZ5ZMFUpB0xqTvvQMtKuRyze26pTETiJYGhFg7e9ZRer++tEicOtD25kup6nlI/Zd2LwtOc0SSVx7BI4ig6CJHV51yt3cXikj12H+8n1dGi083zwCxdyzsYpbrz8Ps5ZV2fvqesJI4fVfSP0u0W8uIN0XCb8PpIwQKOIheb6l2/lR264mA1rehe8RBdsX8PHP/8QUZwS+PYjqh3GuK7DrXcfoFpR/PRr76BSaNDueCRK0FXqMNTdwPfsdOKVvW26ShHNMECYCCmxZmc1iYnuQeRvZHauxae+/Ag7Hz+B5zq87MrNvO4V51my5q5dLIt9nyGCl2LCr9o3w/yYEt2wxnR3y/d/QeHnQZQW1yIkyB6IvoYp/th3HnWwjOcvlj1L33sIIRzg/cANwClgpxDic8aYvUvudhS41hgzK4R4NfB3wOXf/9U+N/Dw6DC/d/s3cISg4Hk8MHyKnSPD/K9XvJKtvc/sIUgSxb9+8j7ygUcusKpIoxky1+jQrIX09ZROu//Ox45x90NHkQJOzs3R2X8ccY+gfFGVICdYFebwPZc0VQvKxlI1w3FAKVs2k1Kg1JJ0ZGVjACraoxPGCxdnIbAlMg0msIbgk7M1hpMmss+lM2WDDMGWBvy8S4sUEVtvknazbjGTdcKRmbuNwQ2t0iQWTOJn9mNhzchCLLT2k0UOBLMQlcCv28YiAHEaPRGkPgjPbmPdYI2RqQr5wBrae7vadJU7GGCyVmSuWaB80mZDaW9xKTLJuu8WtpqZ1MXpZMmANYRHWXnxDKVsgSQJez+MNYZrCSsqDX7xLfeigdlGDikMr7riIPfvXcPekbUImXnHNAhpEMIwMllmw8pZPDdlqKfOhpUzkFd8rrGKmahAfy5iKEx45MAApyby/OTrHuGJU9fx2su+wKq+EdZH27irVWRVLqUrP4PwziFKBanR/Oobr8d3TldLeruL/Mw7r+HvP3pXFmRq8H2Xm155Hp/68iNcvfkgAz0Rew4PMDJVJOcnNNsFLtk+w1d3OoRphWKxnb3WJFIaSvkQKGbP6zidMOZ/vf8rTNdaVMt5tNZ88dbdnByZ5Zd+8uXflTylbxvuNij8sI0v0PMvjgKi/N+/7Rlv3xF0PXtxL4WTddklPCnTaRkvGuhlsvR9wWXAIWPMEQAhxEeBm4AFsmSMuWfJ/e8DVn9fV/gcgjGGDz76MIHjUA6sTyBwXWY7HT70+CP8/nU3POPjR8ZrRHFy2iyrrkqe8ak6tXp7gSzFcUrLS/nYwT20Sgl6LEHOaRxAh+CMKdSWHEOrBlg71M1Xbt9DlKiFAapgSU8xH9BoRba7CE4bvwHgeQ6k2pqZ548xIyki66J2IvB7PXRbUzivhFihKY8L4iRFaxibruMZSxSUb71OfssqKzK1hEtiSPKgfDu/La0awl5BYVSTq4nTVCXLShbPmTCADxKN13SIC+BrQzUXMlRuIBAoJZmYK1JTAc0hQWEC6q2ArlKHZifA96x05DgGrcFz7EF6Leh9zHbNxVW73txMNox3CdzQEsDWiowUZbfL0BrQVQ6KY/Zv2s868NTi+vW8CJX5xa675DAIQ7Nl2+ITJZlt5Lhix0n2nnwFs7MtiDVSagIvJVWSVuiz71g/XeUOcSL4y7su4vZwNQ4G19cM53LMFn3ONnXGZwqcmijSU55gZe8ojXaJl/VN8OBMD9NRnioRUTJBZKq855LLn0SU5nHRuWv5881v5cDh4wh9mC3ryxwbs6/dVX2n+PQ3tvLgviHrp8FQLRp+4yce52fffIR/+Pw2Dg938fKLbMr4+hUtHNm18AIV7hYeevwEM7UWvV0ZgXIkvV1Fdh8Y5eTILGtX9WD0nO2ikwMIufi+McbQ7sT4nmtfx99lCCEQhR/GBC+D9AkgB/4FiB9UarZ/CYS3LEkEJzO8r+dJeVHLeHHhe1iHE0KsAf4VGMJ+h/s7Y8xfnnGflwGfxQorAJ8yxvze92I9P0iytAo4ueT/p3hm1ejdwJe/pyt6DiPVmuO1GgOF4mm3l4OAfVNT3/Tx+byP1vaDfv5bc7EQUCnlUUoxPdsCDFPFmLm1hulaB5Uq1Brwu6H7OJDC3KEG63ZUueuRw/zYpgtYMdjFXL1Nu5OQKoWUkovPXUujFbL/8DhpqhdIkpR2v1obkkQ9aSyH0JbogCUNIgGd2LwnM55QH+tQLJVotWNLxJZ0yst0iU8nM+7IEIxvqG2W1jNlQCAw0tBYL/H2GGSSKVXYv0kWS1rGBSk0KrGP1w6U8jEbB2uksbRGby9lQLTY0jfJA4fWoB04NNzLj7ziUe56fD1CGFxH0w5dWmFAo+0tKEHSQNDRdOmUtYM1WsLn5ESVMxWvvhMp66IQuS7iQNKNTiRG2llyUS8Ec9bkvJBUrhb9WiIbK2McCFfAqoE6YeKiEbhSY4zAGIkxHiPjp1BJFSEVGkGUOhidpYIbwWw9z//99EuY2uCSHwcvNoicIO3TtHskszmffNuw7/gAjx2o87ZrY4o5Rc43/Na5gnuaZ/HYtMOqYsJbzruOy1Y983efQDzEuUP/x3YGRLCh4hJ4r+CR/X08tL9AqRAjhX1NK+3zN59az+/91N382XsbHB5dR6nYzbqhcYTNh7ep2e4W8C/m5MijcIZ6JIT17o1NzrC6+lHbkSZsh6DJvw2RfzN7Dozykc88wPh0A991ePlLtvLGGy/4npAmZB/41/5gVS5A5H8IEz9oc5tEACYG4SGKP/MDX9syXtBIgV8xxjwshCgDDwkhvnZG9QngTmPM677Xi/lBkqWnepc9JU8VQlyHJUtXP+3GhPjPwH8GWLt27Xdjfc8puFLSlcsRKUXOXXzawjRlsFh6hkdaDPSWOWt9P4eOT9JdySOEIEkV3dUCP3LTpbTaEcqBfx5/nFV+wOx4M8vRMMQlG4joz1h/zPDXx0mSlJtP7EEAKwe7qFbyrByo8urrzmHvoVE+/eVHyQceOrBDXtud2JbqxCJhmsfS8t18CUzG9tqfNBPcnEtzpE0sNcPtBqppQwmVD+0hm4wtY6vMaC8rvWUkQSHoOmjllagiiHuNVYykIa4KclOLC5gnTAurUWBaji1lCUiq0NMMCROJk8nPndDD91Pedu1uHjs5xIpck8moxC0PbuLyHSfZd3yAUxMVEuWQGEmCg5TWuF2SMZt7ZtAG4sTlV3/kDh54YjUf+uqFC4vq72rS39UiSlySIw6/eu1O/vXwOcxMFYh7QGhBWjF4M8KWHj0gm4un/EXy6SjoGZccPt7L5sFpOqFPkiV4Oo5GKcNc06fU26bV9Egjl1QLpGPIuQlp6thj8KF0kgW/lJuAO+yghKZVcCjJhLHaOravP0ZPqYbraFxHsFLUCerTXNrrcdGKjeS6rfxlTAfihzBqGuFtAPcchJAYPQPNv7BdYNIqKp4M+dk33sPv/cO55L0pHGET1PNBiis7jM+UGJ3uZ2XvcbavGQe5Hkxky0TOCkai83hsJKbH+2/4/hCoIlobZkNBqFJyjgvK0Ff4BoRfzVr3s3JT+984Nlbi//7TJJ7r0FMtoJTmy9/YQxgnvOvNVzybt/Gzgkn2Y9r/BMk+kBVM7iZE/qYfTAkOsmDKP8eEX4fkCXDWIPI3Ir7FNPBlvPDwvQylNMaMAqPZ7w0hxBNYkeVMsvR9wdNl830/cApY2l6yGhg5805CiPOAfwBuMsZMn/n3eRhj/s4Yc4kx5pL+/hdewqwQgh/afi5zUUicmabDNKWVxPzwjm/eSjw122RooEKj0WHf4TGOD88wW2vxplddwPVXn81Nrzyf9dv7cR1J3vcIfNcOlhW2NBVmfMwYSKKUnq4i/T0lBvrKhHHKq687h1/8yZezecMAd+88TKWcY8PaPhwpiGO1UKIr5DzyuTP9Dwt+5YW33jxliaQmzkM7TTFtjZq1REk7UNtis4mMA0kR6husIVp5ixU1oQQm+3+uBrlJgZNNsFWOJVpJaXHArlmyGpEKnNimfid5+zN4yTS7urp5rKuLk04R6WpeffU+eist3vfGu9GJHbDb6ATc8tAmRqbKhLFHmLqEhflOM0OP7LBtYArX0RgkcepwsN7F1Zcd4/zN1rhULkSs6G2ijcRzNVJoHntkFe/b8iDFhp2ZJoUh7TMklYwgGhbSymUETseOahExqJbmtsc20tIeXdU2rqsoBAk9pQ4P7h9iw4oZVpfrrK42eMWlh5COQWtBJ/aJlY0UmA/ONA4gBKlw0BLcMUk4lyNMuyn4dd7+8l1ESR7PhbEwx57ZEjnZ4p/2n81P3drHoRO/g25/CTP5Gszsz0P9dzAzv4SZ+x2MiexIEJNwWoq2yLFt3RwXbu9Gi348T1PKx3iOTewWCIyzITNBC0amSjw28ktMmI/wqZGfYO/o19mS/zjrcvfwsi0foZw7xMTUE6h4L+P1GQ6NTjHph1SLt1oDs8jUIuGBKPL12+/GGKvICiFwXYfuaoE7HzhMs3XGVOZvEyY9YTv20qMgBwAJ7X+zrfs/QAjZjSz8ELL628jSTywTpWXYzt7v4AfoE0I8uOTnPz/dvoQQ64ELgfuf4s9XCiEeE0J8WQjxzEFq3wF+kMrSTmCzEGIDMAy8HXjH0jsIIdYCnwLeZYw58P1f4nMLr9+ylVQrPr53N404ouD5/Nwll3P12ie3HyulGRmfw3PtCIs//KubqTc61FshnU7M7FwH33P40Kfup1Zv8/bXX0Le8xYUnlUrujlyYtIqQMKghCVMbtNQyLusq3YBlsQVch53PXCIay+3s7aMMERCUc4HbDtriP1HxpitdUBYr5IQgjBKnraTLuuQRwVWgZleHdNdtxf8+QVqaUMNWyvtA6TKyFWf7YaLKuB15qMDBEiDFgavAXGfwDgCN2JhQJzK21Je6lty5CRYD6u0+UZOCKoEj0QDDA41aEU+zV7J9p5ZNq6aZbaVJzCKejtHqhxS5ZyWbqtzAiPBDVKGci0GulrkvBRjwHEUrbZHSaSEUnLhlSd47OAK+rqaKL24jcBTjM2U2bBqmiGnSdst0ltpoxGcKpWRbXBjGztQGLPnQ6bYd3lqB+8eWlPgv999HT+yeQ/nr5yg1vL5yu2b2HdigCS1EtrlO45z42WHKRYi/uPhHaS+IC3ZKIPePVk9U2KNUoCSEplAX9zFYM8EEzMuf/3pS+mtdLjonGGKQ22KfoInDZcO1Pj6SB/v39XDnxZ+HYmx6hEazBxEt2LCi0/rsAojwV2PFnnoiQLFIE9YTBhrR0zoPnpyCUO5GmHk0VVusaJngjDt528/uZE9R/qQXoM4/Tzrtj3Oj107QWp8Kl6NVDv83Nvu4fN3bOeRg6sZ8Bp0Vq0hXSP52KFefvbcM8iP8BmZ1AvdefNwHPt9c67RoVT8zjOHTPh52wW3EPoY2Jb98EuY/FsR8puryMtYxvMEU8aYbxpJL4QoAZ8EftkYUz/jzw8D64wxTSHEa4DPAJu/6yvlB0iWjDGpEOIXgK9gCx0fNMbsEUL8bPb3vwF+G+gF/jor36TP5uS+UCGE4M3bdvD6LWfTjGPKQYArnywO7js8xt//+13UmyFGG8IoRUrBXL1DkthASUcKtDHMzrX58m17yAceb3r1hQwWS0y2W3RX8lQqeSZaLYyBoJYFRWqIZxIORhMLs+O6izlGxmu85zc+zGFdZ6IrJgoULoIV4z5pK1rwEsVJivAlygOSeR/R6TBgR6IkQA2Kx2yZLS2C07bESPu2A84JrXcnKS56nsIdDsV9CpFk24kgDaw7Whib9eQ1oDMI5TEbEik0JDlDczXkJ+yP8ux+EPZ3J4J2HLByVZOin5AqwZ52H7U44OTxboZHK7bN3kuJ4tPfWiYLx77hkkMc2D9Aq+Phe4pUCxqtHOdvHqWcj3GyQE0DxJFLIcjyDwTEqUOpGKELUB90WHM8pB4ViB1JMARpr0GFEm/CoF1bkhTKkkxDds6a0Dpa5F/2XIJKrc/prZfv5qZr9tLs5BjqrlMqJMw2c7zyykN8sLV9oeNFB1AaDOlPQ+aMTzP17fDdWFIULkOlIvuOeniywsp+w/hMmT0n+3n9q/awenCOqhcRxTGuanNWcYR2lJL3yzgSjHEIEwetOtTrX2flxv8BSKJY8af/tpJjIz65QHE438dooUF32SDrkuFWjgmnl83ddX7mjbsQaD729Q08drBAX7eH9ApMt9uc23OUTlvSV2nY5Hpl6CpFvPsND3GqPUrgJPz1oR9nOixwx9ggP3vOXhBLsph0nS0bzuXEzoRCfpHIJanCdeSTukm/baTHMvK4BPO5S3oGlsnSMp5D+F6POxFCeFii9GFjzKeevP9F8mSM+ZIQ4q+FEH3GmG9u5P0W8QPNWTLGfAn40hm3/c2S338K+Knv97qe6/Ach+58/km3q1Rx39cf5y8/dg9BzmNgRTfSkTz2xCkcKVHakKYaJxtVMu8bSpXilnv2c9ONF/Bb117H799+G7tGxhg3LaQx5MazzqoATAg6NtTSDsIR1BshwxJwBLpLMr1KIzrWFyTmYG6qg5epQa4jaZASFQx+AriL7e/zXqXT3nraKiViKjN8p9hgyflyk7CESmWZRdq1xbuoqSjELI5micBLrIdHGEi6Ac/afr1VPmfnexmbqdMIO2ipLJHLZsohbIkuzdt9dmKP3ScHKOVieisdOonHn3/hKraVp5icKuO5ijBxn1TLFykQwKsvPsimnhluffAsao0cCLh46yne9vLdHBzuIVCanQ+vAQGjsxWENJQKCXEiiSKXV1x5kEePD9E8UqSTgKc1rieoHtP0F2b5Ty99nIfMWk6OdVE3PuOtEjLN/EwSCuMGEWhiI5EpyMRw5yMb2fSqBzlr1TTaCLSxpUQnp/ESgzKGUj5mbd8sTSdHtF/S63RYV50j1Q5JnOO8rTm+eKchih2UYwh8hetENGKfex9cxw+/9lEMgmPNMoHbZl1lllrL59hIjs1rIoYnPRoth1Je8KGvBQysOMC73/gjPPT4lzk+IuittImkYKrcS8G4dPoTNm2NSeYkTRJefdV+hgbqPDpR5baHAvK5Dk/MVllZ6eA4knYSQJIglG0s0NogjJ3anLQ1QUXgyxht8rjuKuCxLME7ANMBWeT6697IPbt2MjPXolQISBJFJ0x42+svfpLi9K3CGMPRk1OMnlzPQHGMjWuX+M9Nkr2Ql0eMLOPFA2EVkn8EnjDG/PnT3GcIGDfGGCHEZVjN+2ntOt8JlhO8n8OIk5RGM6JSyn3TbpuwHfH/fuEfeOTwOLPlPNqHPf4c0YCDOtsQ1KAyNj9iJGuZF8L+riGKUpIkpdfPM3TE4Z5OG6kM1YNZV5gBEZGF8Nh/hQPaEcR5Q9hjSEsaUjvHzZuzLe9C2WqNJwWp0jRWQ2HUPtYPPOJAoSNtDd3pk43ekHV1sUiqVJ6F8llayFQbLSDLLEqL0FwN5eOLCd5CW/KjApCJVdXwBG2dMEyTad1B+9qO6apbQmZc21HnYGMJ5qG0ZK6dY66Vw7jQaEGjGbDStCkXIjo17zTTusHuW7ugtWDDmlneNfQwygjOXjVFKRfjSk13KeT2vet5+NQKfAlGSyZrJYRoUirFXP+Sg5y1eZrf/Nfr7UiXFLSW5GVKGDuk+wqsfdUcE+tnOHi8n65Sh07qMpfmF2bNSQxCCdyF+Xu2y+3Td5zDj7/6IVzXrrpaCXl8YgClJIUgYU3vHOUgodPlcfV1J5jeX+HURJXB7iZveOXDnL95mnsffROeF1PKxSgl8D1F1QmZmixR9hM+e+QspsICHeUwFeYhL2h1JIdP+SSpxPcUnqtAruDBXScYGjyXJ8ZeTadwCuM6NL0SghaOkGgp0YWUap9ERw4HO4Nsb42SdxKS1KUhuomVz+HZGXb0D3Dv/rO4dOMJ5uoug92hnTfoGDqxhwoTWn6B6bBKLQr5oe0XIKrXYcIvQHIICMDbRl9O85vvfRVfuGUXDzx2nNm5Nq4jufOBg/R2Fbn0/PXfytt7AZ0w5q/+5Xb2Hx4D8qA2sWlVm/e+vUYh6IBpQP6HT4svWMYyXgS4CngXsEsI8Wh2268Da2FBWHkr8B4hRAp0gLcb83QGj+8My2TpOQhjDF+6dTdfvM3OYfM8l5tuOI8brtn2tK26d3ziHo48fhxvVS9JTjK9EaIyyMQGGXW6IC5B915wlEFk/qFUKTpRTLWaJ4wSHtp9kl3HR4n77OOEBhJrFJ7vMNP2qktrwNAetPu3IzkMwSSUhgGV+WUyKAxkhmozBkpDJ04WDMkmB7L5DOcEFkMZs7whlbMkJs0Djlm4owGbuu1bYiZTawhXHrRXAtog24BvSHMw3GhYopURsKgCzXU2C6kwChhDbhY6KwXaBWJwo0x5Mnbwb9v1mVIGGUE+SNFaECUu2mQdIwLiMnxtZD1v2L6f2ckCnoLjI12s7G9waLiHv//ypRxpduElBk8YEmO3MVkr0nYdvnR0I+PDO6ikCUM9bZSWTM0V6CQevpfS7nj8wycupd4oUGvmGJspga+RaJQraQ/YTCanY8tv8w2JSgmm5woMT1Y476xxHKlpxh4ffPw8AlexZmBucUyZgbPWTvNzVz5IO/TpRC737FrHl+/bghAJUtgpdY4EIQxKSYr5mH2zPeyr9zAd53CFYbVs4EhDMRfSaAdUixHlfMyeY+vppOtwqhF/svsevKLLbMnwuE7onWySDGk8KTDkcJwYTIdU+QgR8E+HrqWa76ddLrGj5yDXnncYT8Y8/MRabn1wIx//xnm89aWPo5Qk56ekyqPZyeO7in984DImChEXDK3gbTvOQbgexrsEotuth0gdwISfoz//Ol56+Wu575Fj9HYVKRZ8avWQD3zoDqI45epLz3rW7/N5fP7ru3ji4Ci93cXsy4vPwVMjfPq2iHe+RkDunYjcjd/ydpexjO8txPe0DGeMuYun7ppfep+/Av7qe7aIJVgmS89B3HLXPj558yNUy3lKhYBGGvGnt93JB088xrY1g9y0dRsXDK047TEPfOkRipUCyjV0ChCXBTJaLEU5WRkq7IHCpFVpong+TNLQacf85p98jq5KnuZMB92TGazzdmYbxio4QtnomahqgxKFyjxEGdHQeRYSphdglnSaZWQkP20JDMKSMDFPrIxBTjdwTk0jEoUaqJCs6UXMhxdq618yg5J4JRitESpTl4z1Mfk1u7+o13qZghkojGcqlJd1dDngKoFuGdIituahDDI0RAMCmdrHIRZ9S9WDhuYqQX7SrkEo62NC2uOvu4E1jQttt2eWDFUx4M/Bp3dtZVv/LFuLUwgMRsO+E/38+SeuphH6uBJkLEiWpGh0Yp/6nI9bL3H9+YcwayVHTvbQU+rQXepwdKKbJHHQBo4e72P1ijl0WUNHQyLYdP4E5TUdjjeqzIxVMcquSpp5AiqoNQM+e9d2OrHHyFSFe55Yw8imHN3ljg3UNNBMPLxUIyYl986spVIM+ZcvX0yr4+O6NrNpeLLKYE+DrlKIQBMnAZftOMFVg6e4csUwXzuwgSGnzaAIeWj/SgIv5dyNE5TyMVHi0lOeZbB6P7e21xIrRa5hMJEGFyZ7E5y6oV5U9OTz5IrbaEQ1Lhk8zI9sPMR0p4UrBW//iZi0o5lrBqQpvPbyXVx01gj//NXX89//eh2XnhexbW2TrmKdRqfCbY+u5KyLLuI91+xgS09vRlja0Pw/IAoL0QUYBeEXuOd+cGRAuWRvL+Z9HCn49M2PctUlm77l7KE7HzhEpZxfeJyQBbq6NnDPntX86Dt+ZDnLaBnPWXxvNJznJpbJ0nMQX7xtN6VCgOc6RCgeLc3SMQn1yZTUh4dGR3jPxZfx6s2Lc6LcwEVrjSkK0op9EUsWVRgj7YUxLYGoCRwEKtUEnsu2zUPkcz7NdsSBoxN0mjG5OUGnV9BabVUVAcyP5dCOVW7mjdEmU5rctjUVp3mrymR3tzCWXATTEPZbwuK3stuzdRoB7rFJ3KPjICVIgXtkHGdsjvjijeA6GAn19eB2NFEHcC15MxoKw1CYygiAsaSwM2AH0xq5JHfIZGqTtAqbSKwqJgz4TYHKZ3wnU6mEFmgP/IahenB+rMsiEdLY+zox1DZA9bh8yvEjbgTeXo/3H76W9UMTDHQ1mGoU2X+sD6PBFQaTzqeKL25fYChGimIxYs++Ic7dPkIY2fiFYi5msNrk6Gg3DgbP1QgBkXZxcoaVpQZnB7O84dwnMMAjq4b44D9djtFWKhLCZB94ktHpMv/y5YvwXIVSDl2HNM6Fhpkwh+No/CnoOqn59O5zAJipF/BcxYYVNbSBQhCTpJLpuSKFICVJHW645CBn7xgHJei0fPqTiC/dtY3XX7WPPUcG+NEbH6WUD6k187Q6JXq72rzmyru5436PI5N9tHWE40iMNqQSinVJqgRur8voXINLV0h+cu1OpiYEU45PTias7p8l9j3GZstoBSLOs2lVk6vOneZTtxZ4YFeRHetarOk/hRApSrV4xUvfTk/PEk9QuhdIQVTR2tBshaRKU84riu6j5PPXnPaezQUe07UWYZSQz31r4z+senx6mV1kZetlLGMZzw0sk6XnGIwxzNU79HbbpO5TbotIKArGI020DaZMU/7lsYd5+YaNBFlA5dVvvpwP//4n8ZIC7ZVW6RDZ0FftLJbQvEjglVzSUFEOcpZgZRf2fN6j1q2Y7Accq5oo1ypMRlolopj3aCXJAumYV17cMCMYEQRzp3uOlqJ4ypKW5karJrlt8OpQHAaSFPfYBPgeZGnfuA6iHeKM11CrekFD5TjMbLNKUSbgIIC0AknbDtCdH/lROpkRMdeSlfkyHdgynnaxrFJkXWPzx4UtW+anM9Vsfj/Z38RSKjjfZedDrm73RbqEYGK3q137r4k1e0f72Heib0FZ8107WuRMWDIjSFJJbS6PEIaHHl2N5xoarYAkcegqhXiFFNNx6K22kVKTaMnGrhkcZRibrjDZKSCE4eyBKUrFmEYrwHM0KrWz09S8LwyB1hJtwG1Jyo9I8n0JxXxMPO1TyCeUizFSGEZnyrQjj07skvNTNJLerg6VJOS/vfN2KsWIQjHmxFSV8Rlrfl83VGMyyfO3X72YX3rdvQz1NDFAr9OhkEs5OtrDMVWkv6fB4U43aVsiEm1fDgL8nEf5mKKv7eDnJefkHyXsixDkKOmEXD7CEYaSF9GdbxKmOXw3wBCzqm+U9WsuZ2bmMBduuo92lMcYwTWXnKTZ+t/kSn9AwZ9PyHfACMIw4fCJSZSy75NKoUmcrCMME7zSIsEJo4RKKUfgPzlD7Jvh0vPXcfdDRxZHrwBz9Q6Xnr9+WVVaxjKeI/hBhlIu4ykghGD9ml6abZvzMuOEuMZ+yyxmLcuB6xJrzWizsfC4K193CVe87mKS4zWUBCMNOr8YtqhdSyDyNXByjr34G4MR0CFFo9kVzDDWHeH6duiHccALBW4KQRNKsUtvuUQQuORiYb1GwhKeeXJUOpV5lZ4iEgCs4brrUJYGLiwR85u2/d8kod2mPOORUiJnW5bIyGzg7Cjgzis/lqRp33qSDBkpcVgYhouxpnOvZUlNXAAtNdkMGBAamWYDebPrXVy1niih7D4XzO2nxWcuElGMNYcr38YStFYZOn2a/v4656wfo7u/BYHGSINxDE5PwvrB2QWipISg3WeVuXkrgDEim94i7I+RNNo5eqptSvmY7evHeO9b7QjF1BVox5Bqh5yTUnQT2pHH6hW1zNQvmKsXWdHVpJqP0Gpx276n8Hxlya8RuI5BCk2r4+M0BK3xPI12QC5QTNWKHDzViyMMWktqzRyhcq3CJg1KOwz2NCnnIyZnSkRNHyNgb7OH/7H7pezq7eLg6hJ/tOdKZqIcUggCX1EuhNzVHOKfTpzLiXYF/BSnK0GUFAp7fqMxG0PRXy0yUCrSac+SJBphIgoGKiohTSVhZHOujDJgWghhqLeruE7E5jVturvXMTQ4yAPpefz8vZfzS3dU+E+f/jAf2/24nWfobQcRMDI2gtYGz3XI+eC6kocPrGau0aHVtrMPO2FCsxVx0w3nL4z0+Vbw5ldfSH9Pielai+lai5lai56uIm99zUXf8raWsYzvK+ZLAt/Oz/MMT6ssCSHOBf4eGy/+ZeDXjDGz2d8eMMZc9v1Z4osPb3vdxfz5399Crd7G65LEjsLHYcVAFQBtDNoYXCH5h4cf5NajRxACXv7Gs/ipt1zI4Xtuo2ESmklCikZoG8ZYOgW5kk8SJuQiRSPqoIsuj1amcNsO7ZadMeIXXFRiMLFB5wSi6uDNWIlkZriBMYruYkASxkS+tupMRpqcMCv5naEsaceSGSe0Kkx+AsJe6yGa3QbBJFSarlWEHLNAPrIDRuW809jXfEo10r7vZApkvqykaEmLwKo8QoPTykiQwr7qfZCRIDdhcBJN2qOJSpJgFuIuSANLkBrr7HEVhg2OsOTlzLe5MIbUnWc30FplAyyFMPRUOky4Dn4OziudJD9ruOX2zTiuRqWC6TRHqmxwaHMNRD2C4ikwyuDF2WeKEAvn0whDoh2GJ6qsXTnLE6cG+drxFu2NMCRrnDzcZY3bDtTrATk/5ZztY0gJjoDBngaO1PRUWyRKLuRBJakDjrGhnJEgUQIdgFdImWiUCGRKGLscGe4mSjwS5eE6YExCnDpo4zI6m8fTmivPOUGjE5DzUsLQIU4dZlSOfzp5LpOzJWQCgdCM6iK/8/DV/OjmPfQEIQUn4RszaxnItwmVZDDfZE2hwWyS44FjqzDjAV4LZCDIBZbRHh1fy2XbDqCNQSmYqhUo5yNyQUqcSMJYUsyFxEmORw6toxOGvPs1Y1QrBT55qMJnjlbpyaW4IiUh4kO7HqM7n+eVmzYzEf8cWv8GA10NDJCkPvc+8RIa4So2b6hgDJwanaW3u8jbXn8xV1+y6dt6v3dVCvzu+17PI3tOMjw6y8rBLi48Z83CMS5jGc9JmGXP0jw+APwOcB826+guIcQbjDGHsb1Dy/ge4exNQ/yPn7+RL922Bzk2RrOgWNFTpZD3UVoz1Wlz9dp1/Nl9d3NoZprunM1c+sy+vezt7WX9ij7aSYrnSOJUcXxqhmYuwk0kyakQahEhILTGPTKGbAyQdOfJC3CNQAwYvDx0IkWc88j3BVSUpLtaBAH1VsjsTIf+UkBzMkYVBCQaMaEXy06Z+LKQn5QNd1XVzBidBUYaB0jBb4MuB+hKAafWwvguC7n4AtTKbhac4lj1ZalfSrlZqHRg1aWoDwonIdeyY02iEjS22P2J2O5faEHcI6ge0uRmHcSQJhwUVA4Loh5b5pMx5KYMxhOYkAWCtkgGFz8tZGoI+4QNz4wNrmeYUwFKC1qpy0ycw3U0Oy4dZtbLMb6ni/ZEQN5PqHW5xD2CYDYjf8oKWcYTVtVi8VgBGqHPE7O96MThb4YvwCsYXJWnf6hO43iJVuCwbsMMr7zsIAR2mSkGl5S+7gb3716P0gK1xLuktETq7HnKPM06dCAVtI2tV9bbOeaZbKyhVNIEniLsSPJCkXiwd7iPE/9xBddfdJSta6eQssOXT6xjfK5EJ/QR0tBJXZSEW0bXc6jRjS8VkXKYjvLIkuJ3L76LsypzGKAe+0yeVeAfP3YJW14xx9XnnaJYcNl/aivfePR8dh9dwSVbTxDGDkEhpd4OODVZpacS0iNCZhsFPnvbSymVVvCjN1U4d8UtGO3z6SMVqoHCzUqvnpunJHw++cQeXrlpM9Icw3VsfdJBU+sE7Hyin1q9zdqVPfzGe19th0JrxYOjw3x0zy5Wl4tc2j+Jrx4EkUfkrkW437xDLvBdrrhwA1y44dl+THzLMLqFCb8C8T0giojcq8G/fLnUt4xvH8tkCYCSMebm7Pc/FUI8BNwshHgXL6pT9IPBhjV9/Px/uhaAu08e528f3MnEZJ20kXLx2lVctWotf3rfXQwUigsfdgOFIodnZnjHuefz0T27CNMETzoMdJVZ7/Xwuss38qVf+RRptcB0u4XwNK3tQxjjYFSKzjmkqcY7GBIcHKXQbBMP5hm84XzEioA93hx1E+I7gkIiGBoN+NP/chN/9IVbGZ2YY2p1RPmo9ToJMt/U0rykNJvb5mSG6A6URrJ08NiGSsbnriXYfRIx27R+JN8j2b4SUQgWvsWknh1lEmb/L4xYpUooqyrFVZvF1Fpn96V96AwthlLiWYULLAFJCrbDrXRKMLMDVJbiXT5u7zO7xbby5SS014DbsuNEnNDYsExA+9ZRH/ZnZUEscYuVQ95NSI1DTqYYBFM9AQUnRg6meB1YW51jptJF1yGBSYXtCNR23UnJlgYXSoFZTVFrWx7N9YZUPEm9nSc8ETA5ncNDMVBs84TfxeuKipIX4zqakh+z78AA9z2xljUrZolDl3o7R6vtkRoHpMBgIDDIFEQiMAsXUsmZmprvpqwfmOaPfu5mRmcrlIIIR2i+sW89562dAKCTOtyzey1fOLyFdsHF0fYYtBAINL5U+DJlKiowF+cQGDZV5ggczWi7QG8upOglOIU2v/vu25isFWi0KyTK49z1uxnsGuavPnUjB07uYeOKYfJBzCMHVxFGLpViSHe5w8Vbx/jNdx9AVH8SnNWYuc+h4sM04rX05zWYGISPkF0ECKbbbXS8lx7vP5hMSjQ6AqU0ntPkjS+5mQ98+krC5ih33FvlnAsu4Ndv+RpjzQbaGIQeYzA3y/+84ii9QYwJv4Qp/jQy/6rv2mfDtwNjomzm3BEQRSDFNB6H/A8hiu/4po9fxjJe7HgmsiSEEFVjzByAMeY2IcRbsNHjPd+X1S0DgMtXrmFP5yR37z2MIz2Ghyf4nV3HGOkNCTyPvkKBVZUKDjA32+Trf38L500ZuHAQ58IBLli9iuvWb+TQ3Qe4zwiMUkzkEqYu6qN4wsWg0K5c8DElJZfwspX4+07hjbQZ/chOJn96G6KuqYxhy2IYxnSDv/3kXcyt0XRSUL4kbGiKwyzEBCwgU0XmYwLCbug6nJGpLJFbpiA8l+ScNRCnNjXcdwgHXToDmZG8ZchNC6tGzVnikp+yJTYj7f/9JtTX2RJfZ9D+O2/4xtj9z3fMGQPay0aexIbuJ2D6XEFpXGGkgxYG0aOQqaFZ8XCbdiadEZAWhFWQIgjamiRvVZp5k3jqCAQGKQ0ag3QNvpNSTwOUASWh7CWkBryTzsI8PIywIZ2JQXn2mIRaXPMCHENhc5u5WhmvaUiEg68NWgpa0wGrD4f834krOG/NOP1+m1dffYBdhwZ53w/djQC+cM82XNdQKUZMz+Vpuy5D3Q1a7YBWI7AWrYV9nk6UXCdl67oJ4sSlE7lsHJqxc96At17+BO3I5eR0F/VWngu3j7D+xEb2ih5LeAU4rkbHlhy2U5926lNyY9rK44qBEbSBiahE1bfZTcXABncO9TTp7+oQJXkm57roKc/w2z+/BuHfyK//8cfpLkwxPpsnHyRMzJSIUof7967n55xxLj3nDxDdf42o/DZu+5/Z3HWKE42Aaq4L4a6h4ERc0X87Vw8dh9rforVioHc1J0bqdKKEWHpsWzfK//yZr2BMHmNu5fGDlzHW2kFfoQKmhklqjHUK/NuBDfzyBdOWiLU/iAmuQsgyxtj08PmZct8PmPQ4pvUxSB4FuQZkMP8H6HwKk38VQi5/pC/jW8O83/HFgmd6x/4xsG3pDcaYx4FXYIfbLuP7hLsfPMx9Dx+hv6dET1eR0aRFY8ZKK44QTLSaHJia4tjeU8yOzBKdnKN+cpbxjzzKiq+O8rrNWyn5Pn7OJksXPI+ZHVWINWK+PdmVoAxCWY8TUlK7ahCvEKDTBGdfjcJJjUm1NWE7Npzyid0jJHMRxIZC4tBZLVCBHUg7bwBfmAWbZSSlOVvmEYoFv9O89wiwnXCBhykEdFY4NDYIVGBNgXFVUN8E9Y1ACoUJFgiE0DZGQGgIZlkY0QLZuBRzxnU/e5zfMAhtwwCcCHqeMAz21hGbO7z9Rx/hb274MhesGidwFIUZuxGh5xWfrNVfSdxUk59dPD8y25kWgoofUfQSwBCm1nV/0459mERwbKwLHUuUIxEavLZdqzBZplNi17900V4uRfqGxBFw0qN83OZhCS1IU4cw9hifLtOdJuzbO8ieY0NMRgXWr5hlqLvBR752Aa3QI+enVIshXaWQLmIGvA6Xrh/mfW+7k56+JsLTnEmUyoWYciHGc+xrRymJIwwy60oUwpZL1/bV8HMpU2me3KwgUMqmr/sa7VmCW5zStFNvwfzgCo3OfGEGCJWDLzSu1DjS4HsaYyTlQsSmVVOsGiqwfmXIhrXreetrr2esvh5tXLrLIYGvqJZSyiWPD39lLXE8g4qfQMgysvRe3n35L2PcrUwnKwhTzQ+t+QSX9u2nOz9Ao5WQxLM4ej+eE+JKWN3fopBLUbpIJy6itOD86lf44wv/lWsH7iUvxgHoCRR3jhYyYugDGpPs45a79/Erv/8f/PSvfYjf+Ysv8MSh0W/j0+DZwxiDbv0bpvZfIPwMqElId4Ou2TsI17aTpse+p+tYxgsY5jv4eZ7hacmSMeYjxpj7nuL2E8aYn/7eLmsZS3HHfQfJ5zykEMxFIWGaUjEesmOI0xRXCOpzTSbabSrKIVA5prqLpKt6ePC2PZx44hQAZ120gbRa5JgwpN15dKowwjAfzyy0sWNMNKRuggkc9JoSRmn8msEo28mlpEa7hjSAJNW0Hm7iHkwo7E6pHDfU1wPOYoK3zkFzhS2FNVdDY23mWcquwTobUwJZo4QjMY5ES2itltkoFCsDCZ2pL459nBNZA/YimcgUpsj+u9RwLpfMejPSKlVeyypU9gRYf5SM4URa5Z3XPc7uqIdf23kdD9aHiFyBm2iEsiNdhF6ybkAnEtkU+A2DkgKVCIwET2jWFeZwpaaVBnQ3IzYOt1mbtJFoOl22BV0oeyzozMsFSG2Q2mTnBYxjGUkpF5NPFJ1TOZw5mwOFA7lczJY1U6zorVPIRahUEMYul55/Eq0El24f5oF9a9Ba4LuKdugxMVtCCEOSShqdgDdes5dXXHCEn7nxQTavmCHwU0uAACk0UigcaUMf+6otBrtbi5lQwv4UcgmFIGHL0BTdKsIzmlXDEbkJCBJNJUqojiiKcxpHaIwQKCPJuykH69140t5edBJUKqw6Z6AVuhgM0vEJPIEnWkAHHT3Mm14Rs2lVSqmgMDh4nk8xn8P3DDOtlPuOtPnNr3+Ov39oJ1GasmNgBX/6ytfwsnUbuax/irOqHVZVz6LZSJmqeTiOolRosXHlOFvXjpH322jtECcB1eIcK/ummOjk2D+bpyiO8M4Nt5NzEjTWTL8UX7lrhg99+gFSpentLjIx1eDP//4WDh+f/JY+C4yeQbc/iq79Orr5fkx69OnvnO6HzqdB9tgfkb1I0sNgVOYJ1CCr39IalrGMBbyIyNJyztLzAKlSiKwlOUxTjLFX095hh3a/Sy0O0cLg5STpqOBE9g0fR2B6yzz+0FFWbVnJ//rAVznaW6ZTa9pvvZU8bZOSn7UmYqEFwkiUm5IUFAiXsBHjI9DVHBKJ9kXGDLDG6gBMbBbmunkzkEsWrDUL0AEkXfZxUi8OpoVsZpqbjQ8hk3alWfQ8CUsSlJ8N880uRKq4SJicMEvoxj4mKVgClZ+A9gq7fRlaQqIC66cqnjIUpgTCCEsas68OxhGUo4TPnNrM8VYVYwSpkeBCFBjycyykB5wWIqDtPounrIcpDQx+KcEZ0pyqVYlil3TKQUy4jJpe7n10Ha4wNAYkhThLXDeL585AlrBu92DLe3ad060CORRpaLJymeFV5x7kLVfvBcCRhhPjVT5/z9lccclxNq2fYkNljqIbE8cOUmomZku0Qw/tgJE5lBJcuHmYs1ZPM14rcdaaGQ53yuAbciQkqX1cK/QAj1boI4Tgy/du4TVXHmCpT1gKG/iZc1POXj1Bf1eb2RM53rj1IFecfZKSF3PfgdX0rG5wwcYJck7KaKfIfRMrOVzv4vaxtbxi5TECoRCuIUkd2qFL4CuUgjAMcfIGR0bQ/BiYUTAJ6/qvpl7vohAokHbcTCOMSFMXV0Tcu9/nqwfu4+j4DH/4mhvZ0NXNL1/xEkxnGtPKg+NyeLrJQHcIxs5OlNLgSE3gaWaaPQgB1cIs/3ZoO18a2Yg2kGiXshdxUc8k90+VefV667lD10hUN1/4xgzVch4/C58sFQNq9Q5fvGUX7/2JqyF5HHQd3I0Id/1Tfg4YNYWZ+29WGRJ5SA9gom9gSr+ODC588v3j++0vwgGnD/QYCzVvXQcUuBvA2fiU+7MvKwOmCSJAiG8tbHMZy3ghYZksPQ9wxYUb+fgXHyLnW/KiZlKUTkl6BJ0ECq5H2gwRLc3skIOINdURjes6dKTg/qPjPPSBL3Prvfttp1U1R27K0B6CVPo0KhonEcjEINoRqUgwOJAaghMNVClP2O9SmBaLBEhYj4+MxUI6+MIXBgm1s61iUz5uL/6FCah1WZUJZTvUUDbFOylmQ3SFQTsC7YNxBU7HZiPF1UXDdGZ5QWRz2Tr91kMkE3CbmWqUqTKVg/a+peO2Ld9kn/VeG8pHwW0J0POhk9ZfZBUcQ7sqGGt0L9TkBfY44qogP7n41UjOm3AAHIHyoLXakB83lEYFBh99CKKC5TmeztLPQzBCkKaStAj1DdC9z25WZJtUeXAisTAE1/4iMkUARF7jxAKTwLZ1E/zwy3bbER/K5ipsWDnD//fjt3B0spsVuRau0CRKcvHWEe7etZ525BIWJFpm25SCz85t4rJjJyl4KdViRJAa6sZFuYpuPyRJJWHss2agRn93GzB8+o4d9He1uGz78MK5Wjgl0lAspPzoKx9keLKbzWumaMUuK7ubXL7tJI40JFoyF9sn50c2PcG/HjiHfbVeXr/mAK3Q4zN3buPq807QaPsM9rTorXRsWKdOwVkJomMVEuFz3UUHeOTg1cRpiO+1iFOXdsthy7opvnTqXBKKuEnKzQ/v48rySi7esoYVA+XMY2fVFmMSSrk2UeziuYpWWKQV+SRxQk+1TaOd5/HZPr40vIneXBtlBJ3UpZO63Ds5xNnVCd65adwOQJQ9tN3/Shw/QDEfnPa+zuc8To2OY2Z/HvQM869uE1yLKP08Qpye6m06nwY9C85AdksJdBPaf4vxP/AUXW1L/i8CcDdDehRMDKYO/pWI8nufthvOJHsxzb8FdRKEgwlejij+BELknvL+y1jGCxnflCwJIa4yxtz9zW5bxvcOL3/JFh7de5KHHj/BbL2dBS0aWkOCpJ6SOCBTCY6LiTTTQyAP2snquULAock5Th04ARikkKhYUxi1LeJhn1WUwootcTkNicoXkKGm9GgNvaIPijmCsRhVzuGGwpqeU43U0nqS/EVlB2Pw6+DPaJIuQX2ToHTc+nrcFoQFwAMZAYlVhuY75rRv1SOkVVFUzvpwor7s+/C8YmayjruMLLnNLDVcYbutBIhpmNlht911wFA+ZomezobvxiUQylhFTQniKkRd9rFBTVCveqcpxfO/pyVLYrzE2ARyqQkChTKCfCliJs5z0YZTnLtphpGjXTy4fxUNfFs+wx5zWgBV0eQSjXIk2hNoXzCzDXr22mM3rj2XTsjiuJr5zkIjMIHBXxHRPFjEGMnl206SpDIjSgCCY6NVvnJiM48fXkGlGHHV+Ue56tzjrF0xi+cqYsdBaYGTlV/NQEot7/OFU2fx7u2PM9PI04x9BDbg9KItp3jo8bWs7p9jRW+TWEumoiIKwSfuPodtmycoOAlLcxm1gU7qsmHtHGuGGhw+1UO5EFEqxAvqkyc1fbmQqh/TTjx+9bwHkMYhUVCL8nxt51Y81/CSc04QJ5I4leR9Oz1PmQRHz2GMi0Zz9roJ3vHKE3zi1jW0I8Vsxyff1eRQeSXHT/YhlME7oXDqin8cvpuHNjZ4x/V30deVUPTHcZ1heio5tFE4DoSxy/hsnkQV6SopivlZVgcOX9g3hCtTHKFxBDieoeimTEVlfmrHFKXqTQj/InC3UNaCXPAIcZzi+4sfue1OzJZVh8HUrPIDlvRFt2K88xC5l53+QZA8BLJy+m2iaL1IZhbE6SZtEbwE0/kMmNT6k2TFEibTge7/h3ROny+5FEYNY+q/a9+Msg9QEH4FoxuIyn972sct48WGF4/B+9koS/8PODNK9qluW8b3CEHg8Uvvfjnv+R8fIQhcXM+hScyUV0ckBpGAKyWpsITAeJbQOI6k4zlM15sACAQ6tVdcYaB8EkqjIPMOQmnCoqC2MQe+oDwCbmWQNFA4My3ykymTZ2mCOYE/q0hLEpUT5GbsRdyqOZZECSNxQ1BtTZqThP0QVwRJiUWfUgBz50LhlKE9JOg6mBGEjCjNjxBJfatQRd3ZbcpGDoh5tUVkhMuw0IWmXeuL0jnw5uzMN0cbOj2CsN+wvXeafJQyfrCLQpJyqi9Pu+hYFUnYeXLmad4ZSQlU3uAYQ0kmuI7NJ3KkZqjaoDuO+ImzdxELh77BFjsuGuXfvnohs40CvqPYsmIa3avYLboxsw7STRGeNd6rog20LIyDjA1unClqIjvH2blJipBsVJQmXTQSiaGUt91i+SBBSE13pUMUegx2d2jjcuxED5+47TweOrKKV11xgM1rJ9k/U8GbM2jXIPoUlDSuEuxLevAczb9//XxkW2IcgxaSzRsmOXWqh+5yh9QI9s31EisH12imx/P88WOX875zd1Jy4syvLfBcjesYapFLJRezaqCOK7I8LiOsCdmIhRLecKfEqkKTg3NdfHV4A+OdImMXwZ8fv4gNG6a4eP2YHW2jJB4KyRRaa5SSCAGxhku2PMD6wWE6yQCfOP4jfObYfkptGw1nRhN0XaGrisvO2817Xn47AkOtXmI47GbtwBSD3TNEsUO9FTA1VyZVEilDhvrLeOWfxjNtUvPo0gx3nCwvwnckBg9MDeHZ/hjXgTfeeD4f/vQDFPI+QeDSbEVIkfKaKw+A6F58gQlpS2zR1+BMsiS6Qc/BacqOWnzMGRDuWZjCO6D972QTDK3hvPwbz0iUAEznq2AScPqzW1yQ/RDfj1ETiAV1axkvajwPvUffLp4pwftK4CVAvxDifUv+VOH0mfLL+D4gDBOCwGWwUgBgEDjWbNEsqGy8iH3VGlcgY4OsFJFSoowhbYX41TxJki6WdDJIBaajccouxVQQxZqmr+0oFAdwHHQlh2xEFE+mNDa5tNa6GGlTpaN+qBw2OPMGaymzdnwQUmBcQXtI2DKbw2mdaMqD1hqBN2dVJCfMuuPAJm0baK+y/iZ3zj5epFgTurHKGAa8plWdtAftAetRyk9B7+NWMXEiUCVNsDbhD6+4E9mCD33uYtZ6DSa7AnTV4IWayJe2TJitb6Hmd+ZzsUURHINo2gWlCDxFX0+TMPLZsX6CW6bXcdvIOqQ2OK5G7Ig4a7TNf3nFveS91MYOGMkn81sZWlfnocYQ9TBg92Q/Ya/E+IbyYRC+sp2BSmKUXUtzLUSDhmIbOqMBwkC1u0OzTyArirDjc3ZvDRVL5up5fD/lpiv3sWtgkE/dtoP9Bwd47WX7eMmlx/j0wxvpdEkqnlWDUiVxhKYVefyfT7yEAyet2iFiAY5hVX+dod4GtUaOUDjkHFuaazRzlFa0uG7FCTqpazv60AgJqRI4Arr8DoFryPU0F+frzRPn7OXrSkPBSbltZA1/sfsyGqmPMYJQOTg9hrQMOycHqbgxm6o18p7JPDUgpbb+Ky0RQjPUc4Iv3Luaro6Lq6DjKFwDKo5pbBUM9nS4yytz6tFr+IUtD7Om0qBaSohjl8B10XIdnjtJdznCdaG7HOL5qxGFt2HCW7lm5UPcPe6jTYjMDqiVuBTdFhvLDRDl014zL3/JVgo5n8/fsovp2Sab1vXz5hvXsK7yeaDI6RC2JHjmrfk3YBp/DCZvzdpG2/Jd7gbEU5AlAFl4Kya4CpJdlih5FyOkXZsxCpLdoI7bsruetj/uubZcJ04vG1pSJu0+l8nSMp6nRu1vF8+kLPlAKbvP0nd+HXjr93JRy3gy5od0xnGKcAVKGyqTgtZaMB6oWFvy4EDxqMFko16lMeTQTK+ATmLIZ/4emZzOA0RqR3TERlk/kLIkw7q2fdIeD50zqKJYHHKbZSTVNwiq+2wmkMS24KdFZ2F4rMxUkdN6LzOVCCzx8Zos+HXmCVNzDcQVe7sEykcgHLDhkjqb+1Y+bgfnGglx2fqbvKYhN5HNw/PsQsOS5D3nPMrjtX6+csvZqLZLIZ8Q5eyAVI3Aia2itLBWfcaaAWEMxWJC6YKQde0m7f1FG0aZeGwammH7pcP85YFLKfmxnc8rDMoV/NKb7sU0BbOtPDiGwEl473U7SYTDS9UpjBKMNkr8/t1X0VB5jAe+0cSxi53UB0YJClMaVxiqExrf0chySm275oPHzuVg2M2b1h0gcFLG22W0EcyFAWkqOXf9OJ/U5zA9V+AP/+k63vnKRzmve4KHpodIlWPJiqsRvqZ2uMSekQJaC1CWiIZlwZ8duYyrNg8zvLNMLfAQlRTTMqzrnuVX33Qn1UqI7yhcYWjHLifbFUJljc//fvhs3rvjEXqCkDMtMo6wJnVtBFIY/mTX5czFOfJOClLjGdsp94kjZ/NTZz9Ooh1Odcpsy9fAaAyQpg5SZPlNRhCnkkMnA257ZA/rq3DFVY9y3fn7+J+PXoUnFDlHEacOw60y/3vP5fzvi26nGMSAhzaGfM6nVNwCehx0ZJWbym8gZBfILi4fbHHtiinuGK1mr3jwpeK/n3svnqmDSTEmQmSEQwjBlRdv5MqLrZna6AYmPQnNHusfEllHmjFgWiCK6NovAy4E1yNy14N/BRR/3CpFOjNqB9cgij/5jJ8dwlkBZyhJRrcxjT+AZL81cOtx+2J31kF0p32DmuT0sp/Jhj46K59xf8tYxgsRT0uWjDG3A7cLIf7ZGHP8+7imZTwFXNfhhpdv5wMfvYOOSRGOII0VXfsN0aAhCjReIigMa/wmEKdIo5Ge9/+z99/xlmVlnT/+XmvtdPK5+VbdWzl2dc50Nw00IFEygsg4BtTRUTGNXx1Gv4b5GmZ0DDMGfqDDjIooCCpIhraBjnSsDtWVc92cTt5prfX7Y517qzpSdMOMSH1er/u6956zwzr77L3XZz/P5/k8TNw8wfFwGZYErU0W1YNoCcIukLsfkxk6gwprDYNfbhBMddHFgHhnnbzmO2fsel/snJ9NlYHF+IKVi1crtlxlmUqsi9wb4YjN05hUrDbcNYHTD1kBMhVoD1Z29furpRAuQfmMiyzVDlhMAAhn3CgADLQ2u1Sd8Z0tQWs7VM44TZL2BWEh40Rc5e75CWRXIDxNrBXNOCDzXZPZNSuA1d/niNndh3Mkc321Tdf6vPbqg+y+aYl7T09QLia8aNtJ3n/wMt646QC768vM9oqcalfZUllmMIw5lVTw+oaYxUJGtZhwcrHKiokwWjBebvMT19zPf/nijUgtyTNFOUzJjXTVeALqOuO64RPoIYkJLZ+Sm8mVh04FHzuxi3sX1vMLl93JhNcl0R65kQhruWffJI1OASktWe7xgU9ew8tuPsiZoRLWODISBjnpko+/kpMHCpMKjOw3TA7gWLtOYhTBxYalTkAnDTADsLlmOZzUuMLErgmyMBzv1siN7FeKKW6b3szDi2O854q7mCw1CZQhlAYhDAVPIwUcXanxZwcvZyEpIoCu9gmkJlSa3FgeXBxzGiFl6eiARAuC/ncztVAlyXx8z9JLJKGfM1JvsWPyNJdsneYHbr6fj57cQaoVtUKCciZYRDJnIS5wqDXIFeE8uVZEvgWKIEsgNoA94U6C5E6srEFwHVIW+JmL7+ZVEyM8tlyi7Pe4fnSawTAFQog/jtVHoPprYGax8RfBzAF1SD4H+hAQsOqm7Xrp9D+MzSC9D2TFnXSd92KzRxCV/4AsvBEbvgLMNMiB52wmaeOPQ7YPxKjbFr478c0K+DtBT+MqMeYdYbKZI3GF70I8WTd1Ad/GuKBZOhehEOJ9wOZzl7fWvvSbNagLeCqstXwpOQW7Q6KTEt3TeGMReTOm/HiPapKjfQmrzTfTnFwK18x0U4FNPcuplSVsANqzdGqQtaFypL/9UOAfSRi57wiykZDVJAuv2Yoe7DddE+dUwvW9mFbJhQ775fs9g8kzJAbVzBi4bZ72CzfQ2xC4Crdzk7fG1cgb3xlIuhSdwBpnITCwD2zfJsCl51xKTRfB64o1qwIU9Ab7FWa5W0dYyEuwvFOi2uCtaIYem+L+XeNUVUyn5JGv+ChlKbQt3XKfyYmzP8LgoirgPr90/ksiExxeHGTr0DJXDM3SzkPkYMZ4pQXC8D3bH6ebe2TG4+rhGQKlaaY+ZT+jGiQcmhnEJorhYo8080h7PiIVSCtotUMuq81Tr/RQXgC5QEmLJzXaavJcUS/16A4oHg/qLMcRzTggMBpfGjIt6OYe791/NT+x+/61Bo6dnuK2B7axcWwZXxmEgPlGkb2PTPKet97NV5oTlKKMUGV87I4ryHwQgSX2lYt05IKoaYi8lOlemXoQk/kSoQyBMJzo1fitvTfwI7sf5DUbj5H2ReaRylHC8plTW+hkPitpyA98+TVsKDXZWl0mUIbxQo+LavNcNTjLj335lcxkZQQu2mSBWHtE5P1TRlILElppiMBwbiGiRdLoFBECtNZUhhOWms7s8tUvOAgCluMiUlpsXyvlKePsEAR0++WZuYEzy7vZOtGDvAX6NAjIxEay9t/jdz+OX3ojRK9EZI+zZ2CePQOn3ckCQOjSXXIUssex3b+D+GMuKmMz0MdwTyhVd5KZZadFkhsheqE70TofdFqh1RCcLUJ6F+gj4G1HyCLI59a0dw3JP/ejRinYBJdIsC7KZbWLdMkSBFdB+lVQgxC9HhG++Pnt9wL+VeFCI90n4iPAe4E/4+wd4QL+D+PYyjJHlpdYv2UQsfUsm59ZbtJoncbGIVYbvG4C3QS0RTXb+D99BSdaDSbKFZaCACldn6s0y0lqhrqw5MIS6xTvxAJqJSYbDFh69QR6MOyXYvVL1lfv3cLiLyR4rYys6kM5RCYgezmqm4IU6HIAAsq3HiP+nh1IpKt+i9z2VDPDhgHSuEa1a/sxLholc8g8+pVvzgRS+xYTOqG46rkIkvFcPzZsv0rN09iiYCzqMl7qkAwplgcC/JOaLBHUKha9Maa1HGAzl+oqzkq6w67sf1VY7ndBZP0KuT7JM0UXdNKJx6FDQ7zh1NspDcX83FVfpeKnJFnAUNSj5Hl0cx9PGjIjnR7ISiKVM1lvcep0naVmEQs0O5FL4giwSmC1YONij2uvO8zHb99Dnp8Nya0fbrAQF5hdGWPdRJP5uIjAuuhRP8rXTEPKXsajjWGWexGDJEykHYSwKAErOuSkqJAXBWJZ8p5Pv4x3XruXN+06SDHKeMkPTfPZvdv51AM713yeEP1edXOSyfUtSmHGqW6VsC9UMxgipdm7NM5rNxzhVMdFlRbTAp88tZUvT2/EIMiN07PNxBWGCzGh1ix0i9x6ZiPv2v4wi6aAkgbfWjKjULjzIjEKJSw7a4s8vDTCnvoidaUJpKYT+9yzb5LbHthOGOS84OKTbFnX5MCpYY5P11DKMlDuorXgsoE5Pj+9mVXWL4Q7l8Gye2CeZifkzz/1cn70B9+DqLWwrd/D2g4n2wXmujEDYY/1hQXy7A8I/fVIIV0K6wlIOGtFb6H7F84QUg1Atn9t35DhojkZ2ClIF8HfDHKsX71wbtn/av+c43AeTXm/PqyeX0+e9XJQQ8jyjwA/8g3e5wX8q8EFsvQE5NbaP/2mj+QCnhUrcYyS8gmeKNoappM26dUFWErIjUEtZNS/uojXSIi31JhJ25DBcq+H54OMLf5SD/9ME09LbLeIssa16zjTcFojC+n64tmdP0W7Y8EY8pKHKSpkN0ctJoi+V4+70VvS4YDoSI/y3TO0blyP8MFvWdAGERu8jqYwK/FSsWbEKM95VJF9s8vVnmgqcyQqLzudVmfYaZjy0L3vJxYjJZO1BoMkNA8UyRYCfGGpXl5hakmQ+5biQIp35QqdIyV6jYCwB2kIWQ28xFI8JfDi/oN/AK0NkK4WLK1+PC1pFySXVlZQbfgfn7yJH33tV5mxZYqFnI2jK3RyH2MhVIYz7TITpRYjpS6Pd0Z55Mg4r7zu4GpRmKtODFJmVsrsmFjg+ktOcfe+jaRGEgaaUOXoXJEKj6VUYufBKxg8adFGkGqFEJbYeBxr1/jQkT2U/QyBJWpYClqyXPY5UKn1LRgsYlgwoVq84aqDDIQ9DIJKIeHN1+0jCjL++q7LwVi8rqBe7fFj193DhokGxgqMgA8e2cOdc5MMhTHXjk7x3Vv3o6RgvNji4yd2khtJKDX/fs/97Kgus78xxEeP7uDmdVO8ftNhAql5bGmYvz++g14uGAxjJotNprplznSr5LZf3YmgHiS8fevjvP/xK7hudJqfuOQB0sxjar7K9okGw/X9/MlHr+OxY+vYun6R5WaI5xkKYc5Ss8i6oSZXj0xzxdAcDy2OuuNpJZmRvH3r44wVeyw266x0JzEWkOsgfZj5TpvZjqbkpawrrJAbhRQ5U60lJkvx01ypAkidCNrmYFMXoQGw3XOWydx7rPpBKIj/uV999nSNFSTI+te6TZw/wpdD94MuAiZqYBtu4lt187YxInrNN25/F/CvEOKcB4N/+RDOuOzd1trffy7rnw9Z+oQQ4t8Dfw8kqy9aa5eeyw4v4LlhS30AYy25MXhSYozh2NwCnSRlU61K4/AZ1K0nUc0MmRlUrGm/pkaic8ZKJVaShI7KKT4yS/k2V34tY5BWkO8YR1YKiMRA0I/yCEGwDKUZZ4yoC9BZD2nZoBoZ4ZkeMgfZzelcXHOCUwt4rk2JVQLVSDChJJhuY5XzJarsjwmXNAJJZzxF5ZFLyQk429Xe5VdU6rRRq2TCeQ0JVNdZD/RGLHlZUJiGtA4FlZF4ikGZsHRvHZ1IpG8gEyweGWBbbY4H0iEqpZTIZDQ2CjpKEcwJgoZL3ZVOOTNMoV2kSlioHoflyKUAsS4AFo+7vw80h/il6RczkXbopT61Uo9mKyQfUGvBOGNhplOm0w6ZLDd58NA6Ts/V2DS+zJb1y2vfcZJ6fODzV3HNjtMUSxmvf9VjfPZLu+jGAblWDFc6VGqC9nyVVrtIYV0PX2msVWRWrlWZWQRzcYmF2JWLbykv0xYRs5XAeWn17cE1kA3CchIRSoMvNeVKwsJCiZdfcpR/uns3nU6IFZYff/PdbB1ZZjYuYK0k8jPetethurnH8fYAu+uLNLMQJTS1AF6/6TALcYF37tiHwJIYxVUjs3zv9seY7pbo5D6ZkVw5MstEucVEscX9KxMcX6kyFnQJpGGqWyY1irKX8p8uu4O75idYSiO+e+vjBFYzs1ghNwqTegxXW7zqBcf4/L3baHYjxoZajA+06CY+H/vyHn78zfdQ9DXvueJObp+e5CuzkxRVzkvGT7G72qCXFqiX27zzZZ+i0XwLI+XHwC6xlAZ4QlP2036/Opd7nuuFTJRW27z0mf5qvhYNeha8CVeJYFebFkb9lJfmrDBuNe8bgRx3GiGhIX3ELScKIMqgJsC//Bt2PxGF12OzRyB7DGQZdL9bs6w63VLhzRDc+Jy3b80SNrndaZ+8ixDh9Wti9wu4gP8bsNZqIcQbgG8aWfq+/u+fP3e/wDN75F/ANxwDhQJvuehiPvzYI9g4Z/boHMs1idKWlROzVL80RdLOMaF00Z5UM/iRo2Tv2MbCduFuzYkm3lQhf1PI4G0zWO2T16sQhdgoIB+rI+fmsYGheCyh2AyxnnPUlilUj0Jjq9N7VO6ZR6JoXj2IrvrkQwGymyO7ButB8fEVVE8jU0OyKXLbaKWI2QXUnCDbNgKeoDViHSHL+maXpu+ZrXPnYCycQ7hdfQDvE6eVbY4oeW1LccZpn/KqoKhSWlMFTCJRofO+MVYQ+RntxRKDnz2B6qQICetqhlf9WJP1r9J8bu82Hr5nAr/nolw6Es7zCUBDtAidfrDN+iASV4XX6YUYIzhRr3DrI5t554sewRjJcjuiVuthEcx0S4hMMFjuAoLX37wfgGYn5KNfvoRKMWalE3Hv45O0hE+xMMorrjvM9s0LjI20WVguMb9c5K67N7O04pw7AiBdLrDu2gZH24MoDBJLdo6rh8FZAfi+obXDYPsk0Pbdyr2SxlOGR5ZGGF5/Eh+Q0jIx3mShU2Bgd5P2gyOMjrbYMb5EL/YpCU3HkyTap0rKC0anWF9sc+XgHNUgwesHRWpBSqg0UhgEAm0kOYKqnzBW6HKo6dzR5+Mik6UWo1GHd2x5jF+866UsNkuMlDtsKa/Qyz2+f+sjPHB6HdO6zDXDM66Br4TRgQ5Stmn3AlrdgI1jcwxUBnn5NUe48VLn+J3nCovFaAs+BNLw0omTvHTiJNpAkvpkOkQpizGCyeFpaqVfwTYeB5sQSkG6yoUw+FKwkoS4VoWr6c9+mox+iSaAGkbUfgPb+SAkX8KJuPt+GGu5i9Vqggi8TSAlmAxM3F8+c8Jv0YPyzyDEqgrtucHaFBvfBsltIDwIXgaFtyHMaawYcoJx2wJv03MWjgPY/DC28Stge7hj81lsbxPU/jNClp/XZ7iAf1n41okrreEOIcQfAX8LdFZftNY+8LVW/JpkyVq75fmN7QKeDo2FJvvuOog1lotesIOBsfrTLnfq4BR/8St/y9GHTzCxa4Lve/eL+ZN//CKBB0FZYoUkayWkyz1spFh1apSdHNHOKe1dpFkPoOzjLSfIbk42GNLZPUKxV3Bhj1g7P6Vto8TrBOU7zlDbn5JOhmuibOsBOZSmoT0CeUnSvmmcvOrjz8ToSKIHAsgt9dumCWZjZKpBQOuqYTdhBRKvpfHONEm2DJCXIuIRQTzkGtqqDAyWwiJ4XYmXgkw1JlSODBVx45UuFYcALxGunP+kAd9S3pgRt4O1Z3ZjBEYIxsI2UycigqUcZVJ27O5CYnj4jyW7f7XFT73oHt4fXck9X9rq+t89wVeh3/i3//dI1IHIGSl2Up809pA5fOLQDiZrLV546Uni1KOkFbFVZEYyUu8wUEw4slynm4aoFMqFhFded5BffO8ryY2rdpNFzWOnR9m7PMILJqaIhKYaJnzun3exmBXIlSNxGhAtyWAzY9P6EzRaEQ+2RvCVZiCMqQcJXe2xrbLMruoSDwejnGxXaXQjPGmQniW1ikS7CFggzVp8RAhDahWHgyolz7C+1kYKJ4wOrEUlGbkSDAQxr9lwlEjmTM9XObw0wlK1x84NC06YLuzaYQykRluJBWd5ICDRkpGoy1ihQzfxGSfmO9QpPtXcyvHeAKoL1ZWcj+y9nEs3z3HJ5DJ54DNS6JIaJ4o3WlAupPie5sT0ABdvmWXHhgUCX1MrJc4Oof+5rKVvgGnpxQHHZ+poIzBGMljtMj4YU690UeYOVnPPx5pVJkptLBYpoJX6THfLVPzkHKfy1bMtdBcJBRj4S5AR6Kl+FZzmLKkq97efAIPgbwVZcE8EZgHk+r42qd/52caQ/BMUXvac7jUA1hps67chfQBEP0SaPew8mso//g2b9Ky12PYf4zRPI2ff0Mew8T8hit/9DdrTBfyLwLeeZmk1XPrr57xmga9ZsHY+7U6KwM8CG621PyKE2AHsstb+03MZ6QXAvZ99kL/8tY+gM+2C90ry3b/wRl74puufsNyjdx7gF1/x66Sxm6lP7T/DV//pPka3jnLq9RMA5Ap0rjGewAQSoS2qnSGEcASl6KGWEowncf3PQPY0qliFdgrGIKzFZjmm6GPXDaOLMwjPRyQ5Vqi1FupWghfjtKb1kKzuozo5UltkD2RBopXCehLVyUgmSjRePE7W1z9ZASLRGE8SD2l66x3RQUE6KPq+TYJ0RBDOWaonASTWGnQAsqNRsx3SMEFsGUIlmuixNnmtSlYVCOvROVbmis3THFkaITOSUGnGih1EZklyhYxgqGKIpCb1FaYteODTZSqjkndcvo97b9+CWRVQCTexesJQHOtRKsLm8gpzcYmKl+JJi7Vwul1hoV3ECslt923jq49O0oojprMSg5c2GF/XZmt5mVvWn6SpQyi4CE+rFzJY6bF76xyPHFoHgcGWoDNh+KvjeziR1NheXuLg9DAHFwfoCr+froTQ5Pzo6+7lim0z6MgduqW0wL7lQf7+xC7KXsr373yYa4dnSY3glRuO8iv3vwhtJG0dIK0Ba2lkIZcPzFFQGZmWhJ7GaMk/fWkXW5tt4vGAubkSxgg8pclyhdaSwWKHwSDGWnj/x69j75HxNUf1dYMt3v2226mU0jWi0n/LwcJF9YW1NKUA8kwQ+Bl76gucPljn9NwAvdRjw4Ym/8/bb3fGj1YwMtRxLVoEeF5OkvloIyiEGY8dH+XGS09QitK1eoG8X1Eo+1YXEsvRqQHavYjBagetJVI6Q86Pffky3vHyvUAR6AEJewaW+LUHbiJUORfVF7hl/UkGwoT1pRauLHQD2FmcYDsFSlB4DUIfJmt8HtO5EysUgech1tJvmfMqMgs4ciVcFMY0AR/UUP9grTau9SA7iOl9CiE8Zyyphr6+m072CKQP9TVKq5UaZYi/iI1eh/A2fn3beybYZchPgnzS+GTV+TddIEv/enBukPRbBNbaW57ruueThvsAcD9nGdlpXIXcBbL0HNBYkuRE2gABAABJREFUaPIXv/oRipUCQeTC6lmS8Te//Q/svm47wxNnbzK/8/1/RNrLkJ4TdlspyIBjVU2n26X2xXn8+R5GgGqmmEAiWzmqkWC1e6rXFZ98IMQUFXgC1XJulCoXfZ2R7ZswOj8dr+tMJHWWIROJ9SVoC0oitOurZkoe2UQBsJiCIq0FWE/gtV2Jd+sFYzRumUSX5RM8ilQMKy8Zo37bLL2NERaLP99DaHfFmaKHP92le+kg8XpJPA7BggVPILspQx85TDDTpeAJyvfPYCLJ4hs3o4cUVgiQgnRQsO/IKMN+SsWLKZVTlpKIqYUhRHcFHUmqYe4MFwHlQ3NeYjJJSaQMjbVZOlZxVVg1SzwOtiyo16DiJQxFPeZ7RYyVpNp9sIlyi0YvQsxLjmSDGAQUDbHwOD1b4N4ufPf2fe44CJyWtyI4uVwjXRmiW5e88A0HWLRFJsotcgV3zG3gvoVxPnxsF2nLp5xLpLJIXGXdi648zlXbppnrFsgRWCG4ZHCe3fUFHl4aoxomXDk0y0ISUfYyLqot8Z0bDvPxUzuwMbSyACUsVwzMIIQl0Yqin9NKAj5z1w6OnRzCjxW3vOgAX7p9O5+4fTevu2k/gWdQMmG43sVY+Ow923nw0DqGat21OXhqscKHPn8FP/TGe50+CsupTpWCyljv5Rgs/lrJv0O9nFIxGdfuOc1QtccffPhGdmyc5223PMK6wRbNbsj8SokRY5HC0MkD6kGCZzU6lyysFNh/YphbrnJeGMYIfN+5eheC1bCg4wm3PrCNx46u44ZLjrNhtEGjHfHI0TGOnBniO649ynCtxWrh73ixw+9e/0U+fWorBxrDPLI0ysvXHydS/XSbVCD3gNwF+QMgQsgeJm7fTppM43s5Wit0bgkDULKfdpNlJyLXh/qu2euh+EZIvuBIkzjH1VufcqaRnff3j5eHLf8kMnrRed93bL7apfnJVXYC8sPwjSJLawTvHF8HcClI+fQu4xdwAf+nIIQYA34TWG+tfbUQYg9wg7X2z7/WuudDlrZZa98uhHgHgLW2J56pTfUFfE3su+sgRus1ogTghz5aax674wAvfpvjpMYYZo/PrRXGGG3QYQBSkoxHDPzTSWRqyAsKMoPILcF0DxXrtRlIALUvTRNvKmPKHqbgkVV9hLEYk9PcGZAOKYQVFKYMQcOSlyEfCBBnFlDhemwBjO+IkjAQDwuiaUM8XiIf7d/8ctcTLu9rpQY+d5pkvEDjpevWqiVkttp2xKN9URkrLeHpjhtLINeq6AqHmwhj6Vw1DNKSjgnIDGP/cAKRa5L1BbyVFNXOaF23Hl3xIU6hHIIUGAmN9R7ZtMdUq4hoAlIQDxvqXzyD18hItyhk0YK25LFgcndOK/e4+/QWpssFki0CkUDS7xEnQstSUqCVBWRGoRNFqn3CMCeKcuLYh9gZW+ZKoENLUlbkoSOXIoNHlkZ5G/ud2FlLPnj0Ema7RbCCKVNlZL7Cb95wG4VShjEwEvX41Jnt9LSPKhiiSo7oCXLPCblfevExWnGADiWryu5A5kgBb9+6j/WlDvUwoeznVPwEIeH7dz7CDWNT3DWznqWVItcOT0Mq+Ie9u5iaqRFajWoIYu1xqFJlbiDi9PRFiK2WaVvk8eOjbFm/yFA1odGOkNJw24PbKBXSJ8zB9XKPhw+voxMrSqGbnzeUmpzsVHl0aYixsM1wIUaps9OpsaC1ZO/8KA+mY3zHm/bx8smTeLjo62C5R70Y04hDylFKqHKaWUAv98gzSa8b0kpCHjq0nnJ0grnlMtsnF4n6RMn2q+oElpVWAW0Ujx5dz9GpEbpxSK4tUgqyvG+wtQZByde8desh4FD/qpKs6ZP8a6H849D4aTKGyI2HspAkh4gCR8qNkYh+RKnvb4/rJh0Am0BNIOv/1R0HOQzt38P19olcLzh9BtSWsy1GbAKdP8IGlzlH8fOBGOTpFSbiqc15nweELGODa/qmmkN9fwYDtgPhq75h+7mAC3iO+F+4ANB/6v9/EKdf+oaQpVS4xkMWQAixjXOq4i7g64N9Jhcv+8T3XBoNrLZo3b959z2MwuNtRGrQkcIqiQ0VSckjPNXBKM72YdOgOjn1W6eZf4czsdMjEaKTsXyxREjpfI00tLcoCjOW4NA8IjH480vkmUFduhkZWLKyIBkUBEuaoKHo7Vk1H7KIVIO1CCWxnkAkhur9S8S76mQjRaRx7tyYHDKNLnlYIdCRQvXyJzztWiWofXWezlWDTvAKeI2UYL6HLiis59J8WE1vZw0TSEzJX/OBsoDxBP6ypbmj/5oE0dMMZC6StjgfUI169DqC8oBh/Q3wP2cuY65Toi18zKCzDMD07/UIrBXkWnKyVSNMDWFuoQlRmKMBpS0mEORFS3u9dP49xmKtS3M+PlXjjtkJXj5xgr87tou5XpHRoMfMchmdSqZsmf9w50t5yaYTzKZF5tpF3rDlAA8sjTHVqTBwTcrsfQMkHQ+FRWEQocHKs2Lh3EpCYVDCspKE1MOYiu8cwCOlsQIuqi+yvbKEQKCkoZH5THfKHDs5Rqnaw1o4USqzEIZ4iaWAZqFV5FNsob4Ss21yiUanwIFTQ9y/fwKtFUIYzoUQoK1AIDm4XCW3isFCj786tIdDzQH++pZ/Okfv45BkisWkyOeWNnN4pc5vveDLLKQhNS+lbgS5VSip2dce4n3HLifRihtHz/Cy9SdQnuWvvrKTQjHn0WNjXLR5jq3rlh2tWX3YME68boFLty0xWu/w4quOoqRAG8U9j63n9oe3MlpvPenC7Fe3rf29KqDPgTJ4O+jGx1hurjDV8RFCUNRdNlU0xrhjbJTGaNEfh0UKjbE+0q42JTp7MER4M9b2oPfXLk1nOiCHQY2fc4BDMC2nOQrPL7okwuux3f/Vj1r1u1fZFZADWLUVTPsbJr4W5R/FNn/D9ZdbTcRGr0BEzzkDcgH/UvEtloYDhq21HxZC/EcAa20uhNBfayU4P7L0K8BngA1CiA8CNwHf/1xH+u2Oi16wEyklWZLh99228zRHKsmeG3exEvc4trxMLYoY3TjMzNE5wJEIpEBoQ3Syg6kFGF+618Hpa7QlG47wuhrVzp3WSAjCM128hR6m7GM8gQ09dBFUF7zUrS5TiOs5lf3z4AmyoQh/qYU4NkOy04VYCrP9cypQSA+0AbWSYkNXtSabKSIz2EAgckt0vE06ViQPBLKXQzclHy9gQ4UpethIobXFW4qxSiJyg78YIzu5k3Yo5weEABMoUBJPGQp1g+zkWCXQBQ+ZG1BuVrQSTCBobhbY1eCdcKnFvB5iiwEml5xZqXPzd8zz4tc3+VyynZl2iZUl12ZjNZoX+Jr1hRZTvQoagc0kSEtUyCh7OZHKaMUhcRxQmDNoX9Je56JwKnEEwiQx6XgBr5nylw/s4mSnwj1zE/jCcHR2gGYcoqRB5oLZoMjfnnCd6ithysdP7WRHdZHUeohCTOHaNgvTHjaHO7rjvH3DAdptH20FEuhkAdJPmYuL7F0a5V27HiZS+Zo5ZiCd4N7zLMJahIB6mPGqyw4x7nVYP9JirlniPfteRNAzWCGoFmMarQiU5e9P7OILX9iJwGm5JIabLzvO8ZlBwuBsGq7RjtZE1kUvZ7pVoCBzImt4ybpTzjE7V7SzAE8al07zDb3YQ2vBZLFN0ctodCOaEvJ5RZ4pbutO8KX5jUQyJ7eSfSvD3Dk7yU9sfYBCkGO1oJu5W1oY5GgjkH0yeVazJLjlygMsNgsstwpYBFIIbrjkJJdvW0A9oUX4quKqbx655onUPznJIP44981MMB4kBCoCBErn+L5GCYOxksDL3cOLdY7kxztDdPMppAzZVMmoD30vvmlBeg/WNBD+Lmz9zxB0sfEXoPtXz7vsSMgq1H4N2/p9l9Kztk/AAlj+IfdA4F+GKP8Y4nk2yRVyAGq/A/lB51DubXL96S7gXx++9chSRwgxxNngzwuAxvmseD7VcJ8XQjwAvAB3yf6UtXbheQx2DUKIVwF/iLvz/Jm19ref9P5uXMjsKuA/WWt/9xux3/+bGBit8Y73vJkP/ebH0NpFOqSSvOVnvpNbG1P85a0POFlL6LH8hkm89y058uBKeUAKVKwRniYvey6iYyzkBhMpVl4+AZ6kcu8C4enYaY4UCC3wp3trRMiEEm+644wXa5ETemtDOlHEX0oQ0pIORQTTK+iLhrC5xmhLsJBDGFKYCYjHLF4PxEJvrbZflzxUJ0PkGu0LbD9CI+OcfChEZMaJwmNNPhxifEk2GOEvJ1TunkP2DOlguBZtsgjywZCFt25m7M5TqI7BrliUtPithGysgM0NAoNVaq0ri1A4M+W+YaX1Jd1LBigcaoKULIyu4+8Wd/Kpv0+Z3VAmUwrZN98MpGZLfYXcSn5xz52UZMrfHNjFw711bKw0+Xe797J3dpTHVoYZHeuyQ63w/keuZ6Hqso4yN2fvIZ5AZgarYDxvMd2psBAXEcJiQknuW3TWT0NKENZyycA814zOYC3cOTfBaycPccfcBtq5T6eokMLy4VN7mM1LfO+2x5yTthVMt8t8ZnkEJS0PLo7z+MoUO6pLhFITKNc8tuSnGCvIjLMVCJSlHqXcdOlxZpcrBFFArRwTW59S5ETsUZiTxgFeKSdUgk4cIIShFGlee9N+PnnnHk7O1rDWpbkqpYTXvWQf7z9wObdNbyI3kptGT3P36XX8lxfdxulOiZleZS2m4sucnbVljjZr9PAIPO0ChcbwN39/JY2VCBPCoyM1NtYblGsZ7SxA2ZyH5sf4amE9l2+fZmK4SaWUsH1iyRV75Qrfy/vnkSP3QgiiUDM22MNThk4cMFjtUSmmKNnC3Yos7tao+yPM+//X+6HGBuCDt4HElJgMHyJUBojp6QLVYooU7hxIM4Xvu/M10y7Sua7QoJVFaFHiyzMbOHUy5qcu+tF+qb3BIiG4Fio/jwiux3b/2lkKkPbHIt0J/nX6LglvO9T/CMw01mbQ+DWwc2fF2NnD2OavQP2/P2+bAiEE+Lue1zYu4FsB33KKnJ8FPg5sE0LcAYwA33U+K55PZAkgApb7y+8RQmCt/fJzGekq+m6afwx8B040fq8Q4uPW2n3nLLYEvBt44/PZ17803PC6a4hKEbf+9VcAeNk7b2a6ZPjdf/gcspU5EW+u6SpD8JpJhv/xpJtYPIWV0jXJTQ2qkaK6mSNTgC77EGuSHSXit2ymuK/BwBenyYeq6JECtqMoPryIt5LQ21YlGy+gMqdZot3DBgLZ06wGJUWqaV49SHuX7yJYVhCss1SPC0onU5KhAB15KKWg2cVEEtnThCfamNCju7O+Zj/jT3XJxwuIntu46mTIXo4JFLboMf6+/ZiSj/Uli6+YeKIQVQrsaMDiNesY+ocT+K0MC9SmGySby64CD+d/tLqe8Vlz/kbgKvA2lyk+tkw65NHeI8lrkhUbkVWceEa2QOSG7bUlfJuzoiPiTFIM4N/u2cev3lnjl158FwvdiIvDJS4dW0RbyVC1y8uvO8xH9+4GlDtWniQPLSYogLWUlGHz9h77msOMFTrMxSUilYPwXOczC4HI+OWr7uLiwUVClaOE4Tsmj9PNPd629QA/fucrWEqc7sWTmn+e2sR9C+t46fhxjrbrPLAw7hriak0UZvzSfTeztbLCzvoyca74nm372FVfck15LWghCfueCIEPk6Mt1g+32Dy9wmJQxMNgrGCw2mUlCym2DJ7nrAV8z/DTb7udK7bPcunWOR45Ms7JuRrDtS4Xb5vlPQ+9mOlOiaJKyYTiEye3s9KLEJlgnhK+1Gu32dxIZrsl/uboRQTKolHcvzDGw1/awOJykZFqh6UoRArL9GKVYpQhpMVoFwJcFCGTI03KhYwoyChFKdpIFJbVvQhcuxfb7ynnqZyxwZxzrFaehH7IdW2Uw05jJCKwBfAmQYRkOqWZlaiLhMx4VPwWA4U2mVaAcBEm6UxAc+uxvzHChnKTw60hbl/8Tk51x1lq7+PfbJEMFful9ta6KFPyFWR0C7b4dmj9Lk9othu9CUQVaxNAIETA+UAI4Srxkq9gbQPU8Nk31TDoOcj2QnDNeW3vAi7gWwyPAS8GduEupgM8vWX+U3A+1gH/BXh7fyercWgLPC+yBFwHHLbWHu3v52+ANwBrZMlaOwfMCSFe+zz39S8Kn3jv5/jsB25da0J4dO9xDg0Y7A3DBIFHlmSkvRRlLcmGMrrsI3s5IskR1mKE08R4iwlSG6wnyGsB6aBPNlEiH3BOua1rh9AlhfUFweEVhj9zGmstnV01ejvrbj0pXESl7lN8ZAmvrfuiE0M6WaRzSQ2RuugXFgqLkrxgCM4kDNyf07woQEcSBgoEU00GPjWFVZLZH9yJGfDX7u35cIjsutQZmXVnkicQxkCiEdqgqx5Lr9xANhS5CjzvLGGSJYHdVoBdBdrtAtnGIqosCHopWU9gfUk+Ep2d21Q/zmpx20KQjhZp3LKOdFMJHXlIbZDotUslq0A1yQlVzmI34vraaaomwfctk9U2f3jjFxkOUqyBMybEKIGwkCjB5dec4QsnN9MQRYwPBucPtYpralM83him6GdEStPJfbq577IhWLQVfOemo1w2NM9CUgBCKl5KzU9ZV2hz59x6DILLh+Y42a6ynBYQQCON+OiJXeRGESiNyaAnXDqrpmIeWhrjwaVxfKF59YajKGHRbu5GPk0MXUr4lavv4EdufyV57hNITdv6bBhscEM0x7HOIBdtneO1N+znpktOuq9RWa7YOc2VO6cBuH12guluieGox3Iv4nSrSi/2CIzhUye38oZdh+jkwZowvRqkHGvV2L8ywCsmT/CGTYepewnFPa6JcNwL8K1B9JdfbBRZN9yiIwKUNIxX2kwtVujGAZGfMzrQwes3DM6sQAlXRej8zB2eVKv1LLBYJNbOOkNtEbioi5agNlPwPHLjcagZ8if7X8tg2OLdF32a3HiMBYqx0lEn8BZi7WcpKTAYZiwmg9T9BRokLMQ1hor9qj0hQBRcs9voFpfOkuP9cKlwmqPsXuzyj/TtBxQ2fBGi9INPqzuyZgXb+wfXjFeUIHoN6CZP3+rTgll0+snsYWz6VRAhInwhwrvgQ3wBT8K3XhruLmvtVTg+A0A/c3bV11rxfCJLb8T5Kn2jRd0TwKlz/j8NXP8My/6rwdSRGT77gX+mNlxFeW4yXZpZwTwyQzhZQCpF6lukEtDJ8Wf7pfWxXuuybosKPRLinWqTV32ysSK6qFh87QZM2e9nEZyDTbLVpTtGPnYcEk3nyiHa1wy7qE6kMKFEK4FqCap3u+yqDR0xSseLWCmQvRh8z6XTkgDjuXH4KzlDd+TkJcc2Cl84Ap5k+dUbXW+5c2akbKxIeKyJjQJEnNHXP6PLAdGxFtl4ifalgwx++jTNG0fJRgtYT5CNRKAEm8pNZnslVl4+gZnLsaklL3oQuznXBH3G8+RZUADGEASWV209xkteepLUSL54ahN3L6xD41GXMSupI1p5UdDIQy4Pp3ljZR+9NKQmNZHI0FLiKcv6UosFv0yuJTIyRGFO0lOsbJXURJelbhGrhRtYP7o1OpBwpiuwVhL3dTmZlTTSgHYaUMg0b9p0kFwLfGFIjaKb+0hp2F7s8OjMKHHiYZRkS6XJpGmBFZzqlJmNy1T66bWBQsK6UpuVLOK1E4eZTwt84uR2QHDr1AZuGJ1CCU1mPaJ+imr1sK1ipNDjx3Y/wH97+HpmkhIjfpfv2fQY1w3NIG4WWN+yru72P9UtUfRzSl6GEhpPwsl2FWMgTj0Wl0qIRFASOV087pldzy1bTzAYxeRG4klDohV//PhVvHP743zHxAk8qanIlD0b59mzYZ6/+eJl2K5lxO+ySMEdd2FIraTg5ewpLlD2NBPDLXItMefw7HONMVcfH5/S6vBZYKxL3zlBuiXOc0IvR9kpsBKpNvDP01v5/OkBprtdhPD52cbN/LuL9nHFjgCVH8elzgw5Auks1JksNfmZ3e/HWsNiDBOl9UDlnD27kKw1K5A+CGqsX+oP2AzMjLMc8C91yya3Yc0MVH/jCf0jrelgG+9xbUdkFUwb2n8E/lW4J4pz7AT6NxgrN0L7fzin775uy/b+EVt6F7JwoV/cBZyDbyJZEkJsAP4CGMddtu+z1v7hk5YROCnPa4Au8P1P58YthBjHcY6CEOJKzs4SVZyx2tfE+ZCloziF4zeaLD3dg91zPvRCiLX22Bs3fqM8Q54fTuw7xVc+dg8rcw0uvfkirnvNVTx25wFay21ay208XzEwVkdnGrmcEH7iGCLyqGlDMlkiON1BAmFsyC3oQJCPFhCxRsz1nHdROycbMXT3DGNKPiIzCCEwq07PvkR4Am+mhw4EvT11ZDdH9NcVWUwyWXZ6p5dNUr17Bq+RYgUk6wroio/qaeyqJ5MAK1dTXdKZCmowMicfCfFWMprXDwEC0W8XhwKUINlSJTrawhQ88tBgih4itUSdEEbGqN8xRV5S+DNdkskSqpnhE5ONFZiPi6RGMRa1mes6kum3MrKyT+XL03SuHkbXAkiNE7avzpYWlLL86uVfYc/oEp3MRwj4iUsf5KLTy7zv4OVO89M3PRTW8st7bufMqZDfmbuZ1PfhjHPtfmftQa6pLBGGhrGRFnO9Er6Xo4TljukJEqPwFXi+Js0k7kszECoOxCOsL7U4065Q8nNyS18zZKiSoE+GJM2AILAILQiLmtgqqiphqVWgrhNyLZleqqCUYbDWxVro5o4cWwRFmbOx0sQAvtAcXB7kPdfcyffveIQz/T5rX5mZ4AWj0xRU9gTCsNoD2QKd3OMzp7dRVJp15Xk6ecAHp/awfqDNxUPzHG/XkT3NWKHDsVYNrOWm8SmEcORisthCCuilPu1egABnEFrMefHkKX7jgRt5+cQxttUazMcF/urwxfS0z2s3HEVJw0jUI9WKTi+gVurx0qsOM1iNCcOchg24dWYjt81upN0KeF3tCOPlLqGviVMfIQxx4qFkdran85NwvkTJWki0wpe6f2MSfX0YLsFnTvDQHNx25lp0u0iUSirVjFoY8pFjO3jt5Kcp+au6J0WgFJvLLYSwaOuxkhbIjGVjeYWy2Af2MhdRsgZsgohe7mwC+vteg1k661u0SqDkMGQHQB/pu3/3P0PyFUeUVkXbApdGTB8CfwvkR0BW+qS+1U+/5Y4oyaEnErTu/8SGN56/XcEFXMDzQw78nLX2ASFEBbhfCPH5J0l1Xg3s6P9cD/wpTx90eSWuMG0S+G+cvaBawHvOZzDnQ5a6wENCiC/yxEa67z6fHTwLTgMbzvl/Eph6rhuz1r4PeB/ANddc8389OPjVzzzAX/zKhwHwAp+9t+3j43/6WfI0Z3FqmSDyscayNL3iIuvaIj0X5bG5pbh3kWw4RLU1JnPhcplagqmuc+OWgLbI3KLaOem6onPDtmA9QV+gAZHCGgtpjt9zY/PauSM9vkQIiRdbdATphhJL41sRnYxsyHMeRgJ0IFGZE6x210FxzlXmmYKit86nt8GDJEVcsg1/OUV2MnRZuNSdcaJnV3UtKDy6hEw0rRvHQSlsUdG4KmTwEyfxckApolMdkg0l4k0VhHIz8FIaMRp16e3X+FMJpqDIawGyneO3UmdfkFuEdkJvAHIXEri6cIaLBpaY6xX7z8mCTuZzy8QJPn58G4v5WbO8jgn4yKndHG3VUcIyFPYwFhZ7Bf574wb+dNvn6DUM9UpMbD20EXzs8E7umpugpz16WrKl2mLDeJP5XpHHloawQvBIY4QfHn+IxbhIO/PWSucVmqnZAdJRyWcWNvO9ux+l3fKo9DSqZBjwUpSwvHTDCe6Px5lPi/ja0OoFZFJxycA8d8xtoJt6XDI2j+qnqjrSsquvfZqPS/zuIy9AW8Hu2hJxLnjh6BRkMFBJnxhYABbiIqebZQpBSjOLKHtOsPy3J3bz26OzrC82MdbZKVw7Mk2OJLOCOFd4UrCrvkg1SDgW1+gazxHzSHPNxBQvqp9kqlPm48d3EgR6jfC9ftMhhqIeRS93tgPCMj7cotdTXLJ1jjPzVRqtAlGU8uZtB1G+4Yts5lihivQsnjKUCglx6gOWOPXp9DxGB3pPuC67ucdyEjIYdgmVfQqhMhZio8itoKRy6EemHJm0a4TQWBDWcMf0AL04IElKKN2lu2gYC1dIpeXxlRLXjKxaESgkPrUwI9ewv7kOT3pMViuMFIYhexTyE32xtYDo5RDc4P5Wo85vaa3kP8aFec/2b9NWcLRRwqTH2T62BX/tGngcnizWFsqZaRa+C/RpSG51r0VvRUSvxnY/1F/uHFopfPehs8chvOGpN7wL+LaDsGuZ9G8KrLXTwHT/75YQ4nFcdOhcsvQG4C+s8925WwhRF0Ks66977rb+N/C/hRBvsdZ+9LmM53zI0sf7P99o3AvsEEJsAc4A3w18zzdhP//HkfYduYvVIn7ocebgNCvzTc4cmsIYi5CuXFmGHjrLaTe6KCVhIUYpgbEWckswF7tqtf52Be6hUwicv5Jyb3rLCTLRLrVW9FwFnKV/R3d3dz1ewj/adORFCdDWeTXVHSEKVizWWkQvxXgGU4ygnUHFJ5sokscatMWWFCiLyCLykqS7WWKExYYeShvyeoDMLXIxRqUaXQmg7pP3G+J2rh5Gppq86iN8hUgtIjFYk2N9idexJOMB+WCEzO3ZUKMRxJ9uUrtzDnfrt2QDIe3LB1l63WZ0wbVlsUL1PQ3k2iy4Y12zf/BEf/KzrDrcbKw1OT5bY+1BQ8DnZ7dQ9VLGaWIKgiyF0GQ0/QKfObWVa80JTpys8bGPTjB/ryX2fVpXxtSvkvzSVXexpdJAWzfRnGhX+bUHb6KRRvz5wcu5bmSKHdUOy0mB2V6RU/NVejW37CdOb+OSkTkuH5qnLFNGC10EMLVYxhrJj27cy22LkzzSHqHbCXjzzv28ePwUP/SVQTJclZxB0M09wPLqjUdJjUfJyxgMYgww3S0BknqU0bHu8l9tO7Kakfm7YzspFXIaaciJdo1t1WUmC02+Y8NxKn5Gxc/oacVDiyNsqzao+im+tIQyp535pEbxQxc9yCeO7+K2fCNVmXJNfYbv3/EwcdfnbeMHedPWg0znJZQwDAQx64odQuXK7Z1LhqVQzhkqG3qJTxRohupd5nWB1EheM3mUx5ZGQBnunl/PLetPIoFCkNGOA6YXywTK8vufu4qLt85w3e4zRIWUU50yE8U2kXJRUgPI/ue2FlZyn6YJGFQxPSM5GZfZEHQoKr1GqlaPV5oJur0Clw/PcOlWJ+m86/QEhxfrDIx08OS5CT8LwkNSJvADLhs/J/ptU9dHTVSh8FZEeD3C23z2/fJPYJu/Dnre/a9XK51DsJbDzZDfvn+Y5diCd4pS8DF+/sabuXxsHNQE2LPpVrc/C9Yg1DpE+AIovvWJb4tnykoIEOEzvHcBF/DNgxBiM3AlcM+T3no6Oc8EfZL1NJgUQlRxEaX347RKv2it/dzXGsP5WAf8b+FKLXb2Xzpgrc2ebZ3zQd8M6ieAz+ISNf/TWvuYEOJH+++/t59nvA+XVzRCiJ8G9lhrm893/99MTB+dJUtyStUicycXWJ5r4Ic+aZL2jfIkcS/FDzyMcVRIKklQDMjinCztH94+SxKexCqwiWsKSmZcZKjgYXOL6mnK98+z8pJ1WCXPhggEICz+Ykz7sgEKR1qUH1qkde0IqpNhhCAvSkwJgsPL1G+bcSX/BY/FN2/GRJLceI50KbHWqLc7IeiOeshW5oyGjUXkYOoB6mQHoVwjX2o+ItPYFYHvBYSL0NpUdrOTtiAkIrDooiTeXCGY6SGtonPZoLsv5wZTDPpaqRwTSrJ64Br0GovXSCmc7JCNFxDhajoCROwqnujrmKZ6ZRACYZyQema/JOsIgj2KRhKuCawByn7KmzYf4I7ZDXi+JDWSINJkmSJJPXqJpFTK+eKvF5g5oUnLAWkPRr5wmp964QkuG+xwsNl3SxawudLgh3fu5Y/2XcVAGPPw0iidPEBYi9ey6FAgtUsVWiP5jQdu5Kbx0+yorfDvdjxAFGjWD7UxVrDQKPLG4AjfEz7OwTNDXL/9NPO9iJ+97Kt8+tQ2pnoVlDDU/JR3776P9aU2AKdaFd6y+QDbasuMF9oE/bRjuZQ5RwrjgggWONUsc7A5SC/3iZRmstSkqFLesf1xRiIXpZntFWhmIZcPLnCsVeNEu8bGUoOxQo+Sn4EwXB312FRs8cO7HkKnApkLNg43WGgWKYcZ9XLsTnHbj2R1ygRSs67UQQDBOUaXpUJGobBCpiUFm/cr2wxv3ryfHbUVUq1opQHlwF1fs8tFrBHMNgsEfsbhU0N0Y58rd02zZajhevoB2oj+92TWBOBJX/a+P66xJewQCIuU9gkmmqt/esrwjp176eGTZgqB5caJk3zm2Fbub4+zp77AWU8m4UiLqvaZqauERC+51JlNQcTQ+zBWiCeQJeFfDPU/xHY/Ct2PuPWshfwxEl3h1+55OanOGCzUEV6JTtrg//vSJ3nvd76dwfAWbO/v+5GpqhuPWQT/ElBPL1cQ4Y3Y3t+6FOAqOTItkCW33gVcwBrOr0ziGTAshLjvnP/f188QPXEPQpSBjwI//TRz/9cr5/lBa+0fCiFeCYwCP4CzJ3r+ZEkI8RLgfwPH+wPbIIT4vudrHQBgrf0U8Kknvfbec/6ewaXnvqVQrBQw2mCtZXFqCc/3+qJLgZBQKEXkec7G3RNYYzn04DGklHi+R9JJkUpi+l49+UBAXg9AW8Lpbj8lZslGCvjzMViLLnn4szHR4SadK4f7JElAqkEJRGKxgQIpqNyzAAYaLxpHV32XIssN2boC8YYC4WwMUuDPdomOtJCxZuVVk8huTjocYcueK6JRYGr9GI+xa/3dbEEhtGXgc1NQ9NFVD9HN0RvHseUialyiSy6NJ3JwaQZL54ohKg8tQSslHQ0Rce6q+qxFJgZvKSHdUEY8tOTShwZ0oAiPt8lfNYkpqDVSF8zHFPevAILuRVW+JDdy3fwMm3uLfOy3anRXBL403KaLnLooR998Vt/0yomjXDk4x5enN5IngvirMfbOFrajUesKVL5riY9+dZgjeyNCL6ZsYuxowFjRda0/2amteT2BZSkOuXHsDH99ZDc/ftED7BxY5pOHt/PxT1+C7AkaO0EY4QqdChYlLI085Cuzk7z74nvRRpJriZKWsYEOUwsSawXj9SZ/e2Q3nzq9bS0qVPNifubSe7l0cB4lLblxZHFdqcP6UpuynxGpHF86IpIbicCirSSwTpejkbxg5Ax3zU5y0cACUsBMp8gXzmymmQVcMTTLeKHDlkoDTxjXgNcoTnVq1MOEUBqKnkZbwelOmS/PbORVk8cQIazkASP1riNrfQigFsRM90ogLLkRePKsKNsCad9aoJGGaCsZjjpU/ZSb151mrlemmYVU/ZSK71KKY/UOS80CG8ZSJvppsDTz+MBnruTdb7kbP8gpeKtaIvpE2UXlplLXk21j2MUCG8I2fp9cPd1deaLa4uD8CMt5BLi+da/cepTXeYcIVvvHoc/+yHGIXgG9D7lIp97P2gVl22DL0P0bbHA1wtu2th+rZ6H3CbCL52zP0s27FGSLSEVgu9h0L0VgPvW4e/9P8epdt0DlZ6H7QdfgVkgIX4Qo/fCaENxa44wqRYiQgwg1gS39JHT+pD8mQJYRlfect0XBBXyb4Pml4Rastc/qUSGc4ddHgQ9aaz/2NIt8vXKe1cv4NcAHrLV7z7d92/mk4f4b8Apr7QEAIcRO4EPA1eezg29HjEwOsf2KzRzeexytDUopjDF4/eo3a53yuTJYprnYYnhikJW5BnEncSW7/a9uNaW22vy2u62Cv5RiZN8Ru7+srvh4zZSRDx9D1wOywRCVun2kowVM0adw1yxCO+fm8gMLhMeamKJH8+ph9FgBi6V58zqG/uE4Xjt31XPaEaF8JKR9+bAjRO3cRZiA8lfnqDy4hOrkZGMFGjeMYIpO2xBMd1G5QQeCzsWDxKUeqtNC9AYRQoEnnWu3BWsFuqToXr2B0iNLyNQ4x+6+K7nLf1iXstMW2clRzZRsvOBSin2yJrSleusMpUeX10ToxceXaV8xxB/Ia7npn+7DtjMGhnPaecCp5RqFe5aIJivYbUVCqXndxiOMFVpcMTjL3g/7qC81nP4rUIRTLf72lwYplDRSWoQQ6NiyrtBFC4kuB5i+2LrvD4sSlnXFNn9y0xcoeRklP2NoMWfU9uiVPNKeR68sEanAphavYGhnATeMniFHoKTFs8YRG2Gpl3t0egErhYBPHt3OUNRl1cR9Lo74g0ev5WcvuYdLhhYxVtDKfEaiLtpKIi9fCzpanOjaWkGsFQOhRgoYLXR4+foTvHHTYZpZwKNLI3xxahMCiFTOI8sjFFTOr179FcaAQBqksFgLzTRkJOohBWRGUA0Sbp3awsZyk1vWnSSQGtmPGK1miQFCZbhkwKWYermPL7O1ZZppwFISkWqFtoJAarp5wD+e2MEP7nyYgpcxVugwWuw4gbqFYpTje11ml0v0Eje5B17O2178KJ04wBifDeVWv3D+7H3SAlvDFqHQNI3PkvY5lRUZVjHjXowSdu1YC8FZ/VLXsrHcwI80EhgqdPG9Z5pFEii8AeFtxDZ+ARd5KvQjOALMNMgRbHrvGlkynQ+66jS79JStCQFv2/o4f3vsGif8FiVAY62lHS9B+/dBbYPyf0AEu0AEuO5V/c+cPYpt/w8XbbLWuXhXfhIZvRgbXA35fhABVm134vMLuIBz8c2thhO4nm2PW2t/7xkW+zjwE33roeuBxpP1Sk/C/UKIzwFbgP/YF46bZ1l+DedTGOKvEiUAa+1B4PnZu34b4F2/9U62XrqJIPJJeglGGzbsWs/G3ROkSU4Q+TTmW4xuGObH//sPsm7rGIVSiPIkhVKEH/nMv3Uz7SsG6Vw2yPLLJ2jdOEa2roBMNd5K6pyhBXgLMV4rQwADnzmDSq3TNAmB10xRqaW0vwWZdqJnAXgSr50zeNs0xUeWkRpk4ryBvIUY0XPNee3mMYrJACN7YeTOHuUDbdRyQv3WKYY/ecqJuQsKf7bH0CdPI9sp9S9OITPXu27undtpvGicbLRAZ1cNXfVRjdSl4azBerizSQo6e4p0tkcUH29gI89N7NZNxLoSUHp0CatcOk0YkJ2cbDTC9tNt/nxM6bFldNnHVHxE1cNWPCp7F9GnU/bG4xzVAzy8NMrB2Tq6B0IbyvcusGFlnj98wReot5oUuwn/YccdVL8wjWxkeMsp0UIXfyWnVMnZtDNmyx6nAdJG4FmNNoJ79o8xECSs2gWAZc/AIgJYTiIWk4hAaF5yyXEunphlZ22J6orG1wYbWIwVJChqQcIP7HyE3HrExiPwNYUgx1OGYpSxbqjFP89uJlB6bfKejyNOtWvsXR7lPfffwo/d8UpOtSrUgoxEqzUjysyoft821vyWip5zxLYWIk8zUWpTCRIGgpi/P7GTspcxVuhSDVKGwphGGvKpk9tAQGLOekmJ/p0zt45ECQTVIOahhTFGCz3qgXMExx0aMi3p5YpUSxLtKisDeVZfsxRH3D23nl9/8CYONAaxCE53K/z5gUv5+ImdPLI8Qt2PWV9qPYHEKGURwjJa76yRszT3CH3NyWaFrvZJjHL+S/1eev1CfYrSXUc9o/joylY+0djEh1e2MJWXaBl/bR+rv7WRhIFmpNKlolLqYYynnjyD9NN9lMF2EdlD4G0FIkduVqvaRL8SwjhNkrUJJnkI2n9wTlXcExHJnE3lBpFs9/eRYGyCQHDJYLe/ewudP3CRo3OJkp7FNv+zsxOQQ04wnj2Mbf6m0y/KMsg6tvs3sPRO7NI7MZ2/5hugwriACzgf3AR8L/BSIcRD/Z/XCCF+dFWug8tMHQUO4zRI//5rbPNdwC8C11pru0CAS8V9TZxPZOk+IcSfA3/Z//+dwP3ns/FvZ1SHKvzcn/0Y++89zHt/5n+R9FKU76HznJ1Xb+WtP/s6JnasY8Ou9QAc+OphvvSRO4m7qbNJCj30eJEkWm1pAvV75wnmErQUeLl14tTYuIqE3JU0R6c7jPzFQZLNVfK6TzDdI1hIybetQzx+GtnL1vqs9e/9FB9fwSioPLqCaiTIzN3ss92TmNEqJBkizfF8RfWUonTfKcKpFmiL38zRqcVGCrWSMvqho3itHKSgde0w2VCI6jrTSRv5kBv0QEhwqkO6seyibIBs52SBpHVllfEPHEbXAlpXDDh7AgOypQlmYkRsyEoeRgpsKFl+5SSm4LmxzPfWnAdlZnC+AU7FG013kdKSoRCxcRGrfimUyAzfVXyED7+7TLddJRI5YaTJOlApZWvi3zwTmFwiFfzwL09x+6dr/P2fDdPq+OQZnDkScGp3jfWjzX4bD42vDI8uDWOMJFKGzCgCT3P5thkeODDJpkITOVWmMJhABL2S5V07HyJUOX93bAe3Tm1htlfEk4bxQpsbRs/wzu37SY1aM5Xs5h4n2nU8odFCkmhFIw35rYdv4H03fxorJUs6oJF5DKuEWCsKSuP3SYIUsBAXCKQm8pzn9UoScahRZykpMBQ6rdLqZyr7GY8tjzDfH1dBZRRURj1I+ukqFwkEQUHlTJZarD6Crr0jIPIMuXHjL3o5UoB/DtHIrWA+LnK0Wedvju7pR6Nkv27BcqxV57qR2adcewJQ0mKtoBhmtHshuZEUQsvn5zbyssIpsDBealPxMjSC3EiU0ATK0rOWO9pjvLg8TUFoTmYlPt8cZ1PY5YbiHNVzWqgoZdm8brn/v2v30i9KRQqnB3vs2CgPHV5PISxw/aUJG8sr/Yq2grMAsKvHx8f1JrJgNXbpB0DPgm0C4TlH7ywiTzMQJCwnAT3tO5sGG/DidTPsHliVd/hOE5UdgODytXVt72NOM6VG+lFq6UiTPgb6CFaUsI1fxokGR4DMaarsCqL8teakC/h2wPNSLH0NWGtv/1q76FfB/fjXsdkX9n9fdp7ZtzWcD1n6sf5g3o0b+JeBP/m69vJtjN3Xbuc3PvkfufczD3F832kmd4xz3WuuojpYecJy//ZX38bV33EZ7/9//or504vURqos9yQrFR/ZyQlPNPGmumQVDxmfnXjW7p2rv3NLOJcQzM2TD4ZYTyB7Keqh4255KVC9HF0P+n3jBDLVVB5YxBQVQdclJ2zkY0aqEGdnz9ZMY0OfoC1QrX4EIM+Rcf7UQKa1dHfXEYlxvesMLlJVcJGhbF0Bq0BZSzXtkC5ptPBIxwosv2SMZEvFpdIkWGsxnmT2e7f3xeQGtOutZkPl4qNSYgKFTDU27euXrIt2CGvxyuAvJ9jYYH0FHshUI7QlmFTc8xeREz0PuGqsk3sjdC76LfkEUlikZ+l1JYOTrurrZW9Z4eH76xw8UueVb5vju37oKN//X97OxmvmGZtsUfJTXrPxKFnugYWBsIcQFs/TRL5mIYnYOLTCD7/qXkZrHaJCRr0S87nTm/iZu1/KYlqik/msJCEWwVyvxEy3zCPLY7x+40EeWRqhYlMW4wJYMEhCqWnHAZOlFstpxOcWNnDL8BQTqoPuu1kjBDPdEu3cx5MWbQQ949HKAyLPEaMz3TI7akuuhx0C1T/BVs0ZF5OId9/1Mi6qL3H96BQX1xfoaQ9pDJ0sQAhLahStLOAFY1NrMrpzTg9HagUU+kQpM+CfE+seLfTYVl2i6GUsJRFDYQ8lnd1AwcsZCuNnvO58z7iaR2nItKQUpYwPtnizf4BfuPel7KwtsancRAqDLzVv2XKQ8YI7pzOreGllBtHXMU0GXU5nRT7TmGBFB7ytfpw0F0wtVDFCsHVsZe0itECSS3xlsAbe/4nruO/AepSwGOtz7+Mp73zDcS67dDPQw1nJ6P4F3Ndy+S+B3kediaQsgBG4Rr7y7DLnYCjq8XOXHeC2qUEyW+BF605y3egKAu3WEUWwKZYc9BxWlKDz/4PuxxxRs0suxebtBOHjulGvYNMvu4iW6rdhIXB+TvGt2OI7XMPcC/j2xjcxDfdNws+f83eE6yRyP/DSr7Xi+VTDJUKIPwK+iJsSD1hr06+x2gWcg1KtxEveftOzLiOl5NKb9/B7X/51HvjCI9z/ub1srEk+Hi7QtC3Kp9qYyMUSvEUXkn/yc+bq37rk0bxhlO6uKtZXqFgz8OnTRCdcdZTIDKqVoas+JAbZ0+hI4i+laxuxke8iWk8eqDHYyjnahWfI9uqCRMbOymBtfP2Z0AaKaKHNmyoHeNWuE9S8lJ7w+Iu9F/GZ9k46Vw45z6TMrBEmU1RY6SoAn7ijs3Xf6ViE18wQ2pAPFrDCIhKNVYKh9TmlNxZo/GWTvGXWPlc8UcQzoDVEAwJtBQaB9AVWSNp5gK80IRl55ircbnpTi9ZgheF6g5/7H6d56KTmj/dfQ+fICcYG25x5aIjjh4cI1iW8fsMRPGMwQnCyXSWQhslSk4dnRpntFHn3d95NtZiQacm6ujNz3FRp8XhjhEhlNLOoX4Ju+41q4UynggDesXUff3vsIppZQG4FvrBsqaywEBd5YHEcX2p6vYhO7lH2MpSweFhio1jKQzCS1LgKwP2NGhfXF9aiIiNRh3qY8sLR03xpZgPDq1okLUi04sbh02yotCn5KZcPzDEQxe64IcisYjkOeWhxlHKQsrG6DIK+EWc/97/6BQjnH2rtE4nS6iKXDc6xvtRhMY5YSUICZSj6KRfXF7h++MzTn3x9BJ5lYqTN+qE2sl8kWg0yfu3q2/nl+27mn6c3cfHAAj+y60HGCo4kWqCqcjrGI7aei4JZy4TfZX3QxVpBL/E4cmaQUpTRiT0WmyH1ytk0mRBOlP7w4XHu2reBsXobTxpuufoouzaukJv70cufQpp5UgIU4K0RJg9MD0dyQlwhsH3mC62/vytHWlw55oOZc7onq/o5ya1ue7YLrf+GJXWVbaYHYhRnoxeA7YE+AWoLWON+638EET1pZ8pFoPQCXCBLF/AtRpasta879/++S/h/PZ91z6ca7rXAe4EjuPvXFiHEv7PWfvo5jPUCvgY83+O6V1/Jta+6gn13HeCR//BnLF5cpZc7YbPfzvsppqeep6vzjyl4lB5ZovTwEr2tFXQtoHnTKN5S7FJk1qIaCd5C7CI3SiDbrpJtbVvdFIQ4WwVkLTQ7yFYb0UnQoUQm5hljpCKH0t4lVl424aIzZR+tBAQS2Uj5CXU7t1y8yNKSzwoekcr58UseIv/9Jg8ujK21PBG4B2sbKGQnw/iStTpuy5rqTqSG4oEm1BVBJ0dOd7C+QPgSVRaEh1oEr6jg/+QYK3dr/FMJwYoh0B72YMZct8SGAafx6HQCOjbE2AwRKBIZkeuUUthh+2Ux2y5POLng0zE+MYotW5eorMT83dGLqA9msOIRphnbmx1ue2wzL7nkOLov1val5uHlUT4RbOAlLzlOaTCmZxW1Ug8p+9ZYWCaKLSyCRhoR972ScmA5ixiUMXfNr+P/vfJuLhmY5+9P7OTWqU1sLDeZ6ZVZTAoEMqcWJGwuNTjUGGKk0iKQBl9ohlRK0ctIM49Qabq5z2jUwe/ribSF0aiHsPCuXXvp5D73L46jhNMhXVebYu/D6/je193KYK3LsVaNoSgGYVw0xkCsPZbTgJ+/+nYC5VJ7nnj6c9aee/I+CSXP8EuXfZk/PXAth5p13rzpIC9ad5qxQptIPTOBWP0cjVxRVhaTC0JPs7HcYl2xw29e82VmewVes/H42vKrYxPAkJcymylSK/tVY5pxr8dGv0sYaNYPd9Da0pCKffPDXF+cwvdcCi7oVxs+fnqU3Api4/OC7Se5aPM8rd4gWR4w384YiHq0TYFFXaCiFGNhCWkWIH+gH+HpOhKDwkWgzoUEyn3RtYLwpVD5j5A9CJ0POPNIWcZZBayAMCACEBXIz7jtyhpQAttx5Eovum0W34pQQ1hvJ2SP8YQ2LNa1bkGNPeuxv4AL+BbBaeC8/DDOtxruFmvtYQAhxDbgk8AFsvQckMYp+796mCzJ2H7lFmrD1acsszi9zJ/+zAc4se80raNzhI/MOJ8h4+wIng0mlOiKh0wN3kJM9b4F8oqPDRQm8qCVg3Vu4IDzdLEuRUbr7A1ZpDnevlPoiSFsMYCVNnJpGRMpbM1HhgI6ObKTI55mzhK5iwqFx5t0Lx7E+gI8J2IdvfsUN797keVZhdUWKTSpkmS+5hXfOc+jv1Nj6B9PMv/2La6FSd8D6dwWJmuaWVxYwkqBTA25VOSbIkSskcISlg22YRDKaWDUgGKUJumBnss2hALVzejmgv2lQcbKXbpLEaqkMV2BJ43r7K4EQ5OWH/nVaSphykXjy0hl+dzpzfz1kT3Exme82mbJL6BjGG8mLDcL/NWxizkdFHnN1qMUVM498+v468N76JiAoYk2MjJ4FoaDxGUTBWwoN7EIlDB40hIKJ6g1VhCpnIlik+/afBBr4eLBRXbV76LkZdw6vYnpbqnv4i14/aZDeMqQZNBJQlQhRluPZS1YzkJ05nFyucp4oc3N685GaYSAJFdrJpE/c8lXme2VWIwjtlSa/NQHXo1c8jl0YojrLusReZqZXpGBIKGnPb40s4EvTG3mxrHT7Co28Va1UTw9JxLnvP50Jfpbah3+63W30Uo9AmldDzrFMyKzgoU8IrESJSyfWFrHa6qn8K2r+POkYUdtmaufQe8EzuepqlKms6JL+wnBiIrZGTTItaTlSz7a3cRyHkAIDy1VeX3tBCMqxZeOHN5w0Sm+cM92Uq24ZNscSRIACm01jbxLHUlJpjTtID2TkOdnCIQEUXVESU/hSFIF1zwhYS36JCfA3+wGq+chfCFS+hBeB+F1WD3jiI6IsN2/7hOm8OyHtJ6zC/AuBTvvtEtIqPwkInyZWyx6FTb5nCNRsgarUanCmxDyqfetC7iAf+kQQvwPzj4XSeAKYO/5rHs+ZGlulSj1cRSY+3oGeAEORx8+wR//9AdIu8maW/Jbf+51vPi7blxbxlrLn//HDzJzbI6km5DFqXP0Pt9wp+dCLaqZORIjBCiBKUj8hbOpAgsuqiSdcESXFN2dNWwkqXx1ARlr1HwTudLBVovknkEX1FolmvUVuiRIhwsUjrWeMoxVAtXbWcMau1ZOL1cSxh+eRWJds9nVwWhLmkgGBzNMyUO1Mor7G7SuHXEZidzgLSZYL8P6ElNQmJL3hFbyyWSR4mMe9CxRWSAF5JkTQpvdZRpZyHXFUzxwu0ZGAUnZmWzaSOJPdbELObO9An6336Pl6nGGNlvypYRcBlz2csPklh497WERnGmX2TOwxEX1RY636wAMBT32M8Th9QUGZIzFcKAzxOHHBvvfLwxGMWfiCvefmOSH1+2n5seoc1JQg2HCNcPT3D47yUjUIVI5nSygmYWMhB1+9pL72FptPOEr/6lL7mNTeYXff/Q6Sl7GxQPz3DR2huEwJtYemVYuSmchR/DefVex1CsyEMT84uV3kxm55r/UTAJSowhVj6LvJv4tXpPNlSYz3RKnJ0OuvnSWbdsWWIgjvnhmM6OFNsZKil5GqDQFpdleWSaQltQIfJxj9vMRhFaCs9YHz4TUSk6kZadVAyKRMR70aNmAEZGuHa9qkK6deudkBNcggJrKSEyCwUWaxr0e1kJqBH/T3ExmJRWZIYRlRQd8aGU7P1A7TNnLAMvEUJNaOSbNPXxPY1DkWmFligg9EhtSlDECQ1X1sDbHyiLC2+Ban9gOjizlLv2lLnYaIz0DdJ1I3DRBTSCe1IJEqHFQ4+4ztv/4iWX/cgjMGZduExLkOkekvG3I6OXnbGMEqr+F7X4Qsoechqr0DkT0qq/na7uAf61Yq/r9lsK5Jpg58CFr7R3ns+L5kKXHhBCfAj6MOzTfBdwrhHgzwDMYRV3Ak5AmGX/6s/8LjKU+WgMgT3M+8rsfZ9sVW5jcsQ6AuZMLnNh3mjzLaSy0UL6HSc6/VFfEripOxtrJFlbrw6V0wmjOEhmM0y+l6wrMv3UL1pMMfO4MeT1AtTJUJ0dkGrHYQlY9bBg+4eKw8my5+JMFVM2rh2i+aBzV01AQaF+iGim1W6dpLSjaDY+wYEh6q406oVjW3HNXxUWKlEA1UqyE8GSb6GSb5s3jqxX5zmwz1tjIQ7acc3MyVmTxtRsY+sRJxELGYKFHo+OTXF7Hrwi+c/IwD38hJM8lpiAQ0jIY9hgp9mgLS2tXkeXpABMpxPYapl7hsC+pb4jRiaSnmjy2OIwF2iZAG0XRS7lpbIoHF8cZDnscbA3SzV3PuMRT9HKPVhawq7a0JnDu5YqSynjj5GGEtaTaw7OGsJ9W8oTlldsOUCok3Dm1gZ722FZf5k0bD6KtYHOlQaD0E3w/lIDXbDjK3x7bw/fteJSLBxZcyi2MGQhiTsZlAKoq49YzG2knrtfev7voIQaCmFRLZ04pc0KlSbR01VyWfrWY6EuQBetKXb6yuIFkn+K3r7mNTeVlrhqeI1TapQ214qqhOWItWIxDKn6yxkTOTXU9FzxTAcsq6Wlo38VehLNi8IXh+uI8MYrECEL5xPP16Ta32qTEWKh7qSsQEKtVboJDaZXYSmpeBgisgYrIaRifM7rAmPGY6ZbZXl3kFTcc4h9uvYSHj2zh+j0nybQkGgYhBD1bJDEhocgoiARtBRYPkR/qf6IIyECUwZt0aTU76FJhcsCl1QpvRBTe9ARLgKfAuwjyh0H0e8nJMRALQO6iRgKQFUTp369FrlcrhYQ3iaj+wtfxDV3AtxW+xchSv0fcc8L5kKUImAVe3P9/HhgEXoc7VBfI0nng8ANH6bVjBvpECcALPKyx3P/5vWtkKek5B++lE8tIT6E7T++vAk9XSOzIkbeSrmWurBDokofs5cj4qfkya2H5JesoPbhI8WATfzFGFxTZUAhYVKffxDcx6NVy+z5kbklG+46+tk+eLOiyR/NF4y5Fp10kSpc8TNGneKyFQfDhPx3hXe+ZJiwY0lgQFQ2dtuIzXxxHZE7cnY4XUM2U0Q8dZv5t21BLCbboYT2JaGXI3JJHGutLig8v0b18iHRjmdl/u4P6F07DEUu9kjB6ahb7x7Pc+5pBHp8bpsYsCthQaTJa7JIbwbGrNxK/YIhiWdO8q4anLVYIlDYsJQVkZrlk5yzNbkQpyBDShUkS7TEU9TjZqWIsNNKAxCgsEp2bvheTx/7GEDuqS6RGYqzke7Y8xi3jp3j//itIrOT6kRkmii02V1ZYsT7LIuLf7HiMN249SKYlQlpqKnPRDdb6KEPf+NL2/37rpsfZXVtiOQmRApbTiMlSm12lFXIE3dTnw4cuZjCMmSw1qQcxJztVdtaWiHNJKwlIM8VgubNW4o+FdhYwHxfxpeGlE8fZv+8qWmmAlPDKyRMYK8iMZCTq0swCSipDSDeuzDijSdM/faxlLcp0LlnJ+y39+qcTxkBPK0r96NazoW/eTt4XwYPrL1eUGokhEs4qYfWcF6Kf3X2Gm33bKGaSEhNBB0+4Bw4pAGHpWYWxbvS2H9kU/VTj6V6ZnraMFNp8dX4df7ZyKd/9thEuGfwehsp/yKZoiUZm6eRtMgrc2ns56+UMVwT3MahaSNtx1WsIIAUCUP17xmokyduKqP8eQlaefvC4CDX5IWy2D7wtkO3tp9NKLsWnJiB6g3tykuvAvwwb/wMk/wwYbHAjovh9CDX0NY78BXw745vZSPcbCSHEIzwLtbPWXva1tnE+1XA/8HWO6wKeBnmmn/6rEoI0Phs5Wrd1lKgYkqVOP2T0s4tYnzyJWECtpH2BiECXPfylFNU+uw+rAO3WNUVF6dFlwjNd578EqFgj5mPyoRDVcaJn40tkZjDKpfVWK9XsOdoRYdy205EIYfuu2gB53wsKiy4oghwevLPC7/+8x8vevMzQeMaBhwp8/tZhFoVzI3epNg9/JcMUA2zRw19JoZGtfXBd9AhmE9KJEummCqqRgJJ4Mz0KJzr0CgFd35Vey1YKf6PpvKuKeommeKjFcKFLohVt6zO/fYSN5S6lgia80tJ+qEyS+HjGEpFTGuoxXOgRktMyPpGfO98hpfnq3Dq6uc/R1gDZOQfEIvo9xyzGwlxc4uKBed6y6QAby03+0/0vYrpbYTTqcLQ5wHISMVlu8bI9B7k4WiExCimcl05mJE3tMeI5ua85RxVtceaQM70ymytNenmfrBkoBRmRypACAixtJKs1jqX+ZxACZrplAqNpxAHjg20OdAbJmx6XD7mMe6A0qVF40hCpnO21Fb5v56NrfkIWS+Q5Yl3wcldVaARCWPY3B9lcbTCVF6mKlFE/Pkv0OOuKLcVqvzZHdBBQUJrcPLVS7smQffF4TWV9vZftG9w749bcSsJzxHXPls4TgDASm3nIAIxVKJGvXWuTgXNNX7UmEv3vVwKXVxYQueR0t8z7j+9h3cQSc+XjDA83qAz8NmSPUEge5o6Fx3k0HuR15TvZ5p9CCt1/DknBaqDY/3oHIXoz5I86ohR9J6L4pq9BlAy2/UeQ3MbZOBng7wazDN5FiMKbEf7Os8s3fgHyw86YEgHJ7dj8ENT/AHGhee4FfOvjzcAYT2y6C7CJZ2+PsobzqYbbAvwksPnc5a21rz/fUV4AbLtiM8qTpHFGEDk3yFXB9uUv3rO2nB/4/Jv/96381jv/kJW5xjNt7hlhhSMszgjZ4jWemMKzgDjHqkVkhmA2xhRds08TKmScIxONt3TWx0Z1c1oXD7g2Jj1NNhiSrC9Su/1JIlkD4akO4392kKzmk2yq0NtRRQ6F6IJHd0eV6HgbYeHovgJHH3PpA+tBMllGSkuyoURvVx1d8Qlme66lCbDmDrmaPjEWfzkh3VZFnun0NVpQPNRwbVGsgcygix6mHCA7Gf50THtrje62Gqfuj6mebtKdKFAb1fiBOz55CbqX56SzEtu1lFqaoqf5zF07eNOL9zFY6pEaScHLaWYhHzp6ERZBbp9IXe3ZJCUllbGnvsBbNh9gNOrynx+8kUeXR/GVYSEuMlFsMlroMt0tc7hdY5PXRipLRwcIbN+t25D3PZ+EwOm+cIekkboIn5IWXxnSDC4bmnNRESA3giOtAVJj+f4dexkpxM6xW+UoNMs6wFOaNFAsxkXed+hyDjcG2VZs8mtXf5lqkFIPeoBge3WFX7vqK2yuNCj2W6hY61x9lHBUTGIR0rIQF0i0z0JWwCLo4rOgoWskkTB4wjLiJc4BAhehSbRHoJyfkiesS5tikM9CmFaPvI/hWFqhoX2WspA31E/iYbBGkHNWl/VkGHs2xSdwruZbK0vugeJJjyQbgw57ohUei+v4fQKWWckVhWXqKuFPpy7l1mNbaScRvl3h8pGD6N7jGPsAUo0T2pRX1gNuyB5kwB5f2+lZ6qtZK/u3BuFtQpS//5k//JOR3e8iRHLYsTkA0wF9BjHwZ7h2W+cg3wf5UWc8uXoQ1AjoOUjvg/DZbU/OF1YvYpPbQE+DfxEivAnxZGuCC7iAbw5+H3iPtfbEuS8KIUb6773uadc6B+eThvsHXH+WT3CePVQu4KkoVYt8zy+9hb/8tY/QWu5rh4TghW++nh1XbX3Cspsu3kCxWmBxavnr35F0PeVk88mlxg5PjkTJzCKTnLwUIeIckRlHOizI7tmvWxio3DNPNhqRDQZ4KwmFA42nbE9YEJnFoPEbII+18FdSFocisNDbXSe/dxFvJXGaqf56vY1lZn9oN95ijOrkmECCJ6ncM08w03UmlApk1k8/9nVL0fE28c6a2++5eiqcJUIw08NsLmNWoxfdnHSihFfQxG8Y563qNHJDwvumNrtUDpY482iakGxIYjoClShMkPDA6XU8+lCN1+85xIZSk/sXx/nQkT2cbLs0iScs2TljODfL09E+R5p1vjS1gdQqjrfrCGHxhUvVnepUXUTGCFaWS3zWbOR7Rg6j0OQoelox6Oc0dUCWS8ai3lp0o5k5QjUcdbEYakFGJ/NppiGDYcyjy8P8zsPX08l9jIWKn/F9O/Zy6eACRZWjpKFpPXqxT8nXHGnVOdKpkynBVFzivY9fyS9feSfril1y7VJtJ9rVNd8ng4sEaSvIrUQK18tuIS7QyX0klgSJscKReSu4tTVBZgQtE/DTo4/h4RzpLa7iD6CVhngYZpfKjA60KUbZuVngp4UvLVcXFvhqZ5hpXSIxkoKnCVW2pkd98iZirUi1IlD5mkmnJwVK9vV/5+jyVtd9c/04O3sD7I0HEViuKixxUdRgqlfkzKkBksWAgXJML/H5/Yeu46evvI/a8AwlfRzkOJ7NGOTMM4u35KD7MQvgbXz2D/0k2OTLILyzRAlc+k0vQX7ERZjOhZ5xR+YpgjCD1Weelyh/bUz5YWzj/3WpRKEguRXb+weo/eazRsn+tcGlRw+670HWIbj6Wzpy962ShgM2W2sffvKL1tr7hBCbz2cD50OWYmvtf/96R3YBT8X1r76KLRdv4IEvPkLSS9l59Vamj87yOz/wxwRRwAvffD1Xf8dl/NY7/5CZY/MIKbDm6zsbpQaT27MztXAVb0I/83a8RoYpeKhOP/UXKUSin2IJIIBgLiaYe2bn5LMDAZEayCz+dJdwqoM1ltGPHHfC83O2bRXI1DDwyRN0rhzGhJK8HjD4qdOEp9qu1cunT7PynRvQkVj7XIX9K4RHm6jmKKtqZCsF6foShcNNZC9HGCcWF6veVIHC+pI4gV41ZPJSjc07bC6vcLJTQ1nD4pRCKwNFiZnI6FYUw1uWeCwfYiYe5dGHhpHCUvETGmlhLa1lnhJZWj1uLiW0kBR4YHEMIQTDUYduu05uBJ5yzWin2mWKKmd2vsZxinzBX88tA9NYNBLLY0tDHMrKXF2bJxCawTAlM648vuJnTHXLpEaiRMLWaoPcSOZ6Bf6/B29ECkvZT8iNYiUN+LMDV/KnN32aQOUs2YClzGeuXePepXHuXR5f+0y+ynloaYxO5tPOPQbCGAnsqK6gpF01Sl/T9AgMuZU00pDfefhafnzPQ4wVW6yYEIulJHMWdUDb+GRWOP+p/pGSwumWclzLFm0EnrKUopQsd73t1nRUT4NVLZTCclW0zJhJ8W0/TYZLX7rv6WwRpcCl/oSwrCQhmVFMdcsspwVeveHYM5IZJeDy4jKXF88+0CSp4n//01U0Dg/ixwGJDfEmetgtOZ8/uZkXDD3Yd+SexemRngkWdA/MPpBVbO8zUPhOhLfpWdZ5wuieebtP1w5UrQdW84pPrAkUasNTl6c/6ZtpwHdVc88Ca62ryMOc4wYO6NPY3j8iSv/mWdf/1wJrc2zrv0H6VdbSo7IO1V91FZDfivjWIUvPFsI8rw7R50OW/lAI8SvA53BGHwBYax84nx1cwFmkcco9n3qQ2z92N0k35TN/fis615QHSlht2f/VQ9z2t1vYe9tj6OypbQ3OF15Xnz2HLWvaoWdWt0Ew7RyM13SlzwOuCg9X7t9IEBaG/ukUC2/ahK76yFjT21BEdXK8RopIDNHpLsFMj9pd86AkWT0gmSy6yrxmSm97mZEPHibeUsVGkvBYm/BUx5V4f2mGlZevh35ULNlYpLurTu2OWbC4xr1S0L5yyJG4zGB8wfRKkSPTFa7essAP79rLB/fv4fb942SpJFzqUL5/gdbLxknWe9wTr2NTuUFuJctpAWNd5MNJyiyeMGgrkRjKXooQ0MzCfipOMBDG1PwUg2SmW+KywTmW/ZR27iONcNvLQrYVG3SzADXncdgO0jAhw16PcdFjS6HJDUMzlD1Xri5wnkFSWOZ7Bdq5j7WSw80aw2FCYiR3zk7QzAKGwh5dHeBLzUihx1Ic8cjSGDeMTjHkJRxIavzegavR/d518ERdjwYGonStmmx1Sl1JA5aSAuNFZ3HQzRUn2lV+6b4XUfUzLJZ1hS4lndO2Hgt5yO2dMXIraBufl5SmkQJS7Ur6F+KC85aSmsjPCD2DEHG/TctZIffTQaxGfqRFGEs9SNa0RKmVSGnWokuJlUgEzTRAYYmUxpOWR5cHGC30GI6WybV4mqa4z4yP37Gb/YfGqFZiYk+xkgR0ThWIoi6noirRqrBqzS/p2TAH1gdTgPhT2OSfofbrCP9syt5FKQ6AbYLaskZaRPhibPIlp30SfeJkWm5i9rY9dVfeRS7alD3Wd+UWTtukJiC4+imL22wftv3fnYs3FuvvQpR/GqFGn/6j2IazQpDDT3xdViC9A75dyFL8z5De1U93rqZHl7HtP4Da7/L19iq7gK8L9wohftha+/5zXxRCvIvz7HV7PmTpUvqdfzmbhrOcRy+VC3gi/ud/+mv23vYY1cEKWZpzav8ZonLE8MQgRhtOHZzi2KMnMfnzz3Z+zcturVqOvjmjwus8gwj9Oexd5M5Xx0V8XHSrdvssva0Vervq1L80DUKQjRZQjRTVr25DgA4lNpBEx9tYJdDVgNp9i3jLCV5j0ZE/a7G+wEgoPbKE10xpXjuMqQWEBzuU9i2DsBhf0LlqkN62KmiQ2uAtx6TrS9hWyu999nLKwwYx5JH/3QKlzmmKnoLEoHo5A586zey7dtJIQzp5wLpSm4KXsxAXSbRy0aWsgC8N28vLTHcr9LTPukKLDaUmBxpDfacDy3SvTGYUuRU8vjLE7voiC3GRxbiANpIXjp7mV668nf958HJu+P+z999xlhzneS/+raoOJ5/Ju7M5YhfAIkcCYM6kmJUpUZIpyaKsK0v+2bIlX11b8s/X0kfOsmWJlGSTFClSjGJOAAGSoIicFsBid7F5ZyfPyadTVd0/qmd2NmKRGeb5fBCmzznd1dXp6fd93ucdP854qUMn89lQaVH1UpqpT1FlSGHwBOil6jHLYJjQ1QGNuIixglD1iI2il/n0M48nkiFWlzuURZKXxQvaWYAV4KO5tNDgurXHuevIBrZVFuhrj0O9GkNBxBvXHqDip6eU/SdG8oE9V3DbiY1ILJmVvHHdk/zY+ie5b26c1aU+//mG22hZxT90RxnxIhaSkN3xALO6gAVuKE3z0orTvPnKWSoMhjECi8QipaWXeqRGURQZcaIwRlIspBjEkh7rlDNPuLhKIDVl3827xd24MgvaKiwWhSNQKItnDRP9MoHUXDU8jS+t89ISpxHGpejZqQEYV/EHt92/lcFKH5OzNisk0jf0jpa4/qpGXlXX4xRzsLMiwDXVjcEeBV0EIbCtP4KhDyKEwOpZbOvfQXYQ5/JtscV3IirvA/9KKLwVos+zFE2SJUT1XyLEmVEnIQRUfw/b+zuIbwUyKLwWUfpZhAhO+a7Vc267CFDD+c7vdcsG/htCnE1Y5ucTtjy+hyNzsnSeefghQ3yrq3RcPkdiALJDYGbgXGRzBc8Ffgv4jBDi3ZwkR9fiLrZ3XMgKLoQsvQPYstIP7tnh2L4TPPLtPQyvGUIIQTSxgBd4ZEnG9NFZpo/MEndjzNNMu50Lp69lMeVgT/+ChGyk6B4MhQx/7sI9nc4Fkat1rS9cui1vfuvNxrSvHKb86AIis5iCu3FmIwVEYlCRdim4mo/IXP86YVzPN3CkTqbG3Z+HAnTRVcjpigJtnb+SOXlfNgWPeHOZyu4Gqp3SvmqUrOCMKAd2T5N6HmklpL+3hz/RJJyKsUWJ1C4CYQoKr5XixSlJIWRva4iySgm8jNFiF6xl58A898+upuynDAQJFX+ew506U1GFQLa4cXSCb0+vJbOSsp8QaY8oUzTTkIfmxthWa7Cm3GEs7PL7V36Xgmf4uYseIbUexzoVAl9TkJpuphgJI3rao7Csemwx0hJIzZpix0Xagpiyl9LXHmtLHWaiErFRKGkYrkV5eb3g4vocALH1qMqEN6w9wM+v2XtSQI+lqDRjpS4qJwmLQuiP7L+Erx3fzEihjxKWSCs+dWgnodS8fv1BLq7OcCwrsjepcVVx3jUjDhJeF55AGMtwEFFS5hQCdrxXpZv6DIURI2EvL/kT+NLQT3wOTg1QL8fcdXwVP7b+ALUwWUrJLqce1oInLZmF1Cjmo5CxUn+J+CySnbb2ULhoVpT5FALNYOj8jjxpziBjSiwNaWl7Nk/paSOIU0UYpmjj0UoCDHm+OZW8fu0svTShqOKcaJ3rOq/mI1wkVRbouyhT+gBWH0F4G100It0NtnFyXd2/wKKQ1X+MqPwStvBayB53D2j/KsR5iImQZUTll6DyS+f8DuR6KBu76Aj5RKphJ9rO9sCyyNfydVv/Bki+l4vOhSNKtguFN553ez9c+MHJWV0QTtOJfj/DWjsF3CSEeCUn25t80Vp724Wu40LI0kPAACuu3c8K00dmEVIshVqlFCRRgs4MRx4/7kLqz9GJd7bVLApbBSz5y1gJyVgRpEBGmvZlQwzdfmYLiGeyfee5JBDaWQyIRCONpv7tSYRliSiJ1CA76dJVpwsSGRlUJ0XmOqtgLsndw93DKRsMQAmCuQjrSaexMhYbKLJBj2htxUWSyoqhLxxDVQSlE12shu4VQ5iyT3+4Qn3fHOWPHFjS5+iiIg2LrvrO4kIJhlMavXe1T1f7NOICRZVBahm0PWp+iictgYDNlQYzUYl/svNeNtS6nLi7zGRUQRuBxDJQ7zE61qAYpkgN60yfYiz45OGLuGHVCdfQloT5qIi2i+eLRVsnmvaKfay1BGrxYQoIl0qai4oEUtNJAz6091K+Nbme1EgEsNAvsp8BhoKYt2zYz7pKm8goDIKC0FxZmmdeB3SzkDIpG4odEiRt7VNSrnReCkiN4CvHtjAU9vPWKlBQmuGwz92z49yy+jgfP3gJ9bVN3rv6CSKjiI1HpD1imTGiYhTW+SotnpRAUWU0k5CZqMhQGHG4UUPjGhuvKXbYONokkZJvP7mea0dP4KuMQBnUsvN7OSEKZUZfh1T8lLb2KcoMXxg0grZWKCw945EZhbaC4YIjkkpYQnVmGtwCqVX46FO0U8ZCoCw71s3y5Ikh+tKjm/ko4WEi2LR5AWVnibRkLqqyttRBytOvUgEUILgK0ofB6iU9mMQgROZGEH0FW3wXJA/lRMkjspK51JIaTSn7SyJuZFP1CoS3zplZLo7fGpeyE6UzIkYXAmsjiL7iKufEYRcV8daz1EbFNM75W1H5NWxrwYmbkY5EFt6ICJ9dgsKaeWx8N9gIEewCtfX7N50Vvhq6fwa2cvLksU3wNp4knyt4XmGt/SbwzWfy2wshS6uAPUKIezhVs7RiHfA0MLxm0LX9sBadGWZPzJOl+mkLuJ8K51vbUiXQ4pcMeM0EU/LoXjq41KD3WWExfJV7MFnhnMMXK7b9hRirJNaXiCjDa6YnXcYBr5GBl2GVPJkq9ASyd1JwPvuuTQTHulTvn8WUfEQ+h1nd6Zvi68uUH2sQTvRQ7RQbBsSlgNbLxhFxhmo6crZw0QhZ4FF/fA7byFAzGXY2Jh0tuixDLyMteSS+B9ZS9DJqfsKaUhujBVOHPI6ENYIoodiNGRlPGBjRpAkURcJWM4uvFDNRiUwLAmUplvusXT/nxqzBU4YTfkC/XaI9u4a/P3IRb92wl3dt3sv2+jx7W0NoXGuVyV6VteUWUebhS0039Sh5Kal11Wi9TFEPYm49von/vfcy5ySOJFSaIMhIM0kjLvDPd93Nq9ccJtIeUhpXrWYVrSxESih7KRXlyJ9bg1lqh+LMMAWJUdTEqcFmT2haSYFAZrxj6xPspcLexiB3z6xBYblu9ATXDS/g4aI2edBxSYM0XupS8jImeyUiragUE6b7JTxhKXpOw9RMQ6pezL+9/2VUvIR3bX6C1609dFbRd4Kg5Kf4wtDOfL7VWYW2gg1BFytgIilxTXGOkYEOkZZI4dJ/SuBMJvNzclHA7giQRSy7a1rAWInB8qaXP85//9gtiBjKJmM4aMMAHB0e4ES/xPqyZLjQzw0fTpk5ZxOgj4KeJrMDzKURkVFEVhHk9goVZSD+DhTfAqYHWCIrORLnAnkkmUl5aPJPSPSvsb0osNl+kGsABf2/BTMPwscW3pin2U6zETgHrLXY9n90RAkB1gMakHac5gl7dj1UDiFrUP9/QR9wY1Abz61xukCY+F7o/AnYBLDYnnSRqvIvf18SJlF4JTa9z9kxOKMNkDWn9/o+HO8F4QcksvRc4ELI0r953kfxQwadaR759uPc/eX7AcHLfuJGdly7jYuu2cIT9z5JZ6FDr9l7zonS00Z+fXauHKJ7xTCrP/DEs1/nYgontYj0zP2zypU8eQvxSZuCfBy6okBKjBLoqo8/F7u0mxBIY1y0yoCu+IQTPZDCkY68CsoGLvo09LXjZLXAkcNIw/GY/utHQDirBHCBLNVK6GwZINjXhpqPF/UdeSxIEJJsIGT27RvBV5RUwlixx3AYkVnJ3BGJbkNRxsTFAGNSpo8HaJGiBj1+fN3jbBrv0s4CPGmJNaRGsn60hbJOcxQZRWagIDP84R4D2nK0W+HzR7bz2rWHqPkx64M2C60Cf3fwYhaSAr+56356mcdQmOFLZ/4oheFEWuRjx7azjh6HOjUaaQFPabaMTbNzaJ7pqMieqVFavTIffnIXa8pdxopdikGSN7i1DHgxXevTR+GJk+5CQe7EbXKPp1Aa1pbazMVFqv7JtG0zLXDLqqMMhhHTcYHvHNrEJ+frCFyF2p0TG/i5bbt5+8Z9LsGUhzgz63okq8UKw4LHX87soCl8BlXMzZVJSkGCtoKj3RqXDc3Sz3zm4hJ/9vjVHOvU+OWdZ1QFEwon5xZA3Uu5vjxLz/gIoKU9mjrgm901XFWcY2vQPkm4zvLcivLeet5ZfJqOdir0dUBSlLz7J+7jiSdGefjoagpDMT953ePM2AEuGZyiFkQE0pzl+RKAGsc1qp3mG+2NXBZOkyGWfJwyC8ZqZPowtvtREAUwhtn8fPaEpSJiBlTMS+QesvY/xcQhQo4BMZhJUNtAjYBNof8ZLAZRPn/abQn6MCT3g9ro1mc7gHIpOX0YSu9BqFXnXYUQIidU5yZVFwprY+j8FxfVkgP5Qg3RlyG8AfynNGR+wSGED9V/5VKj2YFl1gEXVIy1ghcZF+LgfYcQYhVwXb7obmvtSkruHDDG8Jf/6iPc/nd30l5wupbP/6+v8tqffzm/+P//aT7y7z7J5/7sq1gL0pPPiZj7mUJYV7JffLyBaqV4rWevVwL3srHwxrVU7pnBW0iWok1Sg0xy4fciUcp/oKs+6WgBby5CxhpdD0hXF/FmI2RsnO4pf8oUDrRIh0LCEz339i9wruJaozopyVABlECHPv58jIg11lfIXoZIFkmAQOQalLTo42Up6eoStpEw95o12JKP8Zz/NsD1YyeY6FVJjcRo6DYkYWAIspRyP8LTmuoawy1rj/OqHcfYUZql35FEfcuaUptEK4SAWilyRUo48uFL4yZMWYQwbCi3mehVmO8XsW1FwdOEQcoNoycYCGMemhtFYlld6iKwTPQr3LDmGJ+Y3cy0H3BDdYqbRk+wv1vnjTv2cVN9cqlg/In1dT6w93L2nFjNL3/rDVw/OsHvXH0XQhqktqwp9XKH8oC6SpeOJZw0mwSXQfjVnQ/xhw/czGykGCv0CJRmNOzxxvUHMFYw1a3w+NQYW8pNClIjhNP1/M3+Xdy06jhVL3YpNAEzUZGBICFUmp5VfCcaoxgm9BJBKuDr3bWkSC4LGkhheNnqY1w/Nslf7bmc+aTAl45t5R2b9jJcOGlpsRRFXRwzMKhSajLleFairDKuKs3zsYXNPBoN8MrKCV5eOTUFbYUg03C4U6PipYwVe2cQKmudw3onc1WP9WrMLdcfYufl0+zt1zFFw2Y1R1XF+IvRqsUeMkvQTqQtSqTBNdzbn2VXKF16UUhWeT0EltQqQlmF5LugBsEcIzEZCklBpNRVhMGjY0JikzJmIwR9F3mxNhcRD4HwXTPd6CvY0k9f2MNaT7qzSCoQFzn/JzMPeBDciCj/4lOv47lEuifXTi1rxyKcsa6N/wHxfUiWICeM/iVn1Xat4PsbF+Lg/ZPAnwC3424RfyqE+BfW2k8+z2P7gcSeu/dzxye+S3O2hdUWk2uRvviBr/PQHY+SpRqt3QPyxYosLYlTAZFZCsf7FI/3l5Y9W5iyR1b1kZFBnsUBQSxm3ZY9M7KhALTFes5PR/YyTMkjGwwpHOqc8vvad6dZeOM67N4WaIMNFSLKCKYjhIZgIUbHhmQkdFEp65rxxuvLCJuXxctcV2Usa6IFtlwdEXUlu48OEW+r58RR4HU0pUPT7Hj3LDNRiXbik2hFYbXGSyyR9thy5DhvXbOPG65t4wWWoeEMnUoaDY/uguJt6/bykQOXUfZjTCJRvibTiqKXLR0QkTnRtcZpVObbRWbTEkdP1HnLlfvZVl8g0Yq15TaNpMBf772cZhKireAN6w9wZWWOyVaJw2mZ1SLmrTv2cOPANAuJsy9AWC4tL/C7u+7i7+Quvnh0Gzuq82Spoid9pLXUspSyyhhW8ZIbj12WJluOy4dm+E/X38p0VF6yDaj7MQaLJx2JKwrtGtAiEPlyCzy6MMorxw+flG1YQV9LPKkBwSsrk/jCMJuFfL21Bo3hzt5qVtuEzChaaUjdj7lhbIKvHd+CEpYj3dopZGkRywXkAH3rERkPXxiqMmVL0GEiLXJHZ5yrivPUVHoyUmks83GBWpCQaElmXKuYUOlTiGNRZZhlPekCqTnUrnHFqimKnsbEIX3tMyj6+XyefpXFznUbHy02E3jjPJFdza5gN851yjUFdqLDGogRsPNQ+nkq2SfJbMaASgHFghkgsxlKCASBIzWL1XW2zZKdgPDc/5s2qAsgS2qNm01r3e/VKvePnoHw5S98GkksE7udgXP5TK3gOcdKGu4U/GvgusVoUm4P/g1ghSydBY/euYeF6SYmMwgpkFKiM6dNmjo8Q9x78YoKT7+1nO1Wc/o77zOBCSXDXzx61sa9S9tZvhEBVkmXMpOC1kvGKD/WQHYzkCw1BV78jd9MGfr8UXoX1Sgc6+FN9vD6y9zGU4tqJxSiDKzF+JLS7nm6VwyR1XwnCM8MwljeU76Pt//RETcGCQvlGf7t/SMcyqoIKzCewIyVuefWKuPXtXgoGqceRIhhMHhcIhvs3Hucm97YYm7eR44ouql70FbWZ5xohry+upfjq2p8Z3o9QaOAHOsyVOxR8xKO9GooCaLpYS1M9CrE2uNP9l+P8A3/47pbaQiPmpeyEBdJrWK40OeywWm+cHQbP7ftUQKpuaEyw7c7q3hkYZTQV2wZXcAYwYZCZ+lh3s48xsMe/8+V3+FIUuKmDUcxyi5F+O54ZBPNmRLbVs8zWOuzYdUC1fLZo40WWFNus6HadsaOi8dGuOfpqmKPspeihDOuXKxAE1iCPNKUH3oGwx7aOhG6LzRDyhBZyagX8bLqFN/urMZaSIRYEuP3tcfmahNrnYZqOOyfen4t++/yU61rvFO+VJAZvrRE2jKRlqippitQyKv+ar6zKah6Fk8a9rcG2FZrLLZeRAqcn1O5zbFehaLKSIzHYLnHQJDkxQ4Z/zCzjjeFeyl42TlMNS2IMQJ7iNeUNN+MXoonNFcE9zuyBPStT2gOgZ11EZXgWjqVm7hn+q94afFxND4JPtp2GF2s1gcQZUeuOEkwjOnRyTRfOvY1qv4g1w5ew3hx9VmPNYDwNmCDa/OKtkFAOS8mOYQIbznn7543eDtzg8+ucycHsE4EL8KbXvjx/KhihSydAnla2m2Os9rA/vDBWktjpkUQepTr5VM+01qTRCmzx+c58OAhwlLIZS/dSVgO0alGKnnybSs/oV4IovRckJ2z3cufzjq9+eSpfZ4W1yty/VA7xUqnn0rWV0jWlhGJxpuJGLz1+MkIlXAVdF4npXiw7fyZlpOyxYewwZnf4KJHMoGxjz7JzDs3kawv489EXGWP8PbXH6U556GNBCXwxyy/e+M9/Nptr8FYCSWFKSmiRw0Tu4bYUl3AWIExEhMbZtIyb3mVJo4lmVTUx0xuLSXwpaW1vkgjSnjL+r0c2TPAz+3ajazEPJwNMaMLjAc9Dk6MYCM3hmYSUgoThBRsqzSQwtJKQvxAM1zs0YgK9DKPdZU2b9mwn7ds2IuxEmthtYzpWMHXjm3mn6+aYjzsOp0RzuSxFDqNUyPxqYx1mY0KjPoRsVHc/+habvvWDpS13F9cR5IqBqoR//cvfJNaOeZ0LFayLR7nRf8hk5OXq4enUMIQaUUhJ2uRVoTKcNXw1NJ5aoFAgsXNm4fT55SlRlvNWr+XV5/5rCu2OZQMkRlJ2UuYi2rMRCWuHJ5iQ6V91vNr8cxYHKc6xSoO5rKCa8MCFF1DRUfqlom7tRUgBKk1DJf69I2ipDTGONLWTX2GC32qQczBTo2iH3N1uYfBNe+9a3YrQvj4ylkanHlthLgUl0TKUS4qHOZbvRnu7G1iJp7h5tIxutZjQ+D8lLBN5/CdPsbW+i8jsj1k/f3UZYOGrjESFqiJhhNhiwDkuIswiTKQYnSf2fg43+hczCF9lMwc5P6FB3jXunewq36p2289gU0ecL5J/tUItQpR/WfY3qcg/opLG4YvRZTejZCVs8798wkhAqj+K2zr3y+ZYwJQ/MlccL6C5xuCHxzrgOcCF0KWviKE+Crwt/nfPwV8+fkb0vcHDu4+wof/8BNMHZoBYNctO3n3v34X5YESX/0/t/OND9/BiQNT9DsxA2NVyrUyQcHnp37n7c40zhiElJi8Au6FxHMREH82I34m29ehZO5tGxFCIGKNKXvYuk/9myfypsCnDkxkFpla4jUligc7S8sXsxVYTm3XIkB1MkzZZ+jzRwimI172m5NoKcj8/DLQlnbq+qltqzbYNz/o0jGhoj1co2IhyAW+VhmQlm7bNf5FzLn+dSkUfcNAIcHDcNXgHIdbgzQTjxtfv4+N1QVGvT43qpml9/y58QJHunWebNX5m/27aEoPD0s3C1D59pLMo+xHXFKYQUnLlmoDKS2pdXYUTR3witpxvJLk20c2YzKJFE5YraTzphKWJbPHtcUO35pcx6W1BaS2fPu72yiXYkJpiGOPoXqf+VaROx7czFtu3gOwJMR2U3WyKe1ScaVdJE2WYpjyjose5y8evxprYVAmDAQJv3vFP1Dx07wsXtDLPAoqxZO5h1O+3G3LEAhDy/hcEi5QVik76nNMdMtYBF+f2MQr1xzmvRc9vLT9h/tD3NMfIbWSXYV5ri/NUlgmyq6rhMh6SCy7+4N0tE/Xegx6Cev9LoseSov7VPQ0Fk2qJRNJmdgo1oRdJnplvnp0M9+ZWk8jKXDl8BT/dNc9PGpqFFLLWhERWZ91YZGr11zFsLqT0LsKkd3LmS02Y0A6XZCoUPFqvG38Fr4x8yBH4zpazLLRb+IvpZ4EUIT+17F6P5s5CMVhbLZATU0j8HHVVjGIdUAPwptAbYJsHzM64AvtETpyB+X81E9MwucnvsjO6g5k/CXofhDQeSRPYSvvQxZejSj/LJR/9imu5hcGwr8EBt8P6YOOvPm7EOrc0bEVrODZ4EIE3v9CCPFO4BbcVfp+a+1nnveRvYhYmG7y33/9A2BhcFUday27v7OHP/vt/8PO67fy1f99O56v6LX6KCVpTLUYHBug1+zxF//ig4yuH2bq8AxGP/OWJS8mXoyXhcKxHoNfPkb7pjGyoRB/qk/9zinC472lMZ1BwrShcKRz8u1GnNRDnaLLgtzGQGCKylXkGYvnW6xxQm9rwQZyaT2+1IjFlVkojVn3PcRSKbmUID1oxQGUBWFgMLMwuCXGWIEWgpmsRD2I0KbIk70qbxk4CnnTWZWXDg4XIoYLEZO9Mlk+ciks01GRRxsjXFKf41ivzAePXMbB5iChynjdugP8+JY9hMqwoF359550gNWRazabph6ZERRlrq9ZNnkecFV5ls/MbOeDT+7kJcUZhIXQ08y1S9RCF0kKg4zHDo3ylpv3uDL/fD57mWIhDRkv9PKxnkyzWaBvJTNZyGvHj7B9YJ6PTW7HIvi9jfeyOozzdfik1s23tgqjDb60CGEpCE1iFj+DuooZlX2slZS9jG31JpEW/LtrvkVBnSQeX2yt577+MAXheund2lnLnmiAXxzahxDOEkABnjV8pb2Og0kFKSyrvYifGDiIlGeeY4t/e9Iy5Mc82h3k0cYQf/PYldR9J1IfCvs8MLeKP3rkRl667RAPxRtYQPHyesL6IAY/g8R3VWPn7EVuAeXcnL11bKm/gl8tDWDbD4GpuXTT0m99pyGyXWdMqTaBjRDCy3PWGYi1TowtR6D6ewj/kqVI91cOfpBpc4LSsvxAIANayTxzjf/NqP44yNXL0lsJdP4cG1yFkEPnGP+LAyHLEN78Yg9jBT8COCdZEkJsA1ZZa++01n4a+HS+/GVCiK3W2idfqEG+0Ljny/eTRAlDqwcBV8EwuKrOod2HefQ7j+MXAhozEUIIlO9hooR99x9AKknccymUH9Rc7gs+bAnWOJJTOtCmdODs6ZSzRau8dnbqB/bM7y7JNjKwviA83KF38QCFY13uu6fOjdfNgzXu88CjmDtfP9kdRAQCjEDFKZevn+P+6dXsi8qUVcrgWIZfzElPlPKxT63hnW+dZLiauC71QnAiKbnquUywttThWh3QNYpB5SoEFyMpiwLqNbUGpUofg0cS+Ugh+N9PXspb1hzg68c3kxnJSKFHYiSfPrSDw90a7730QQrC0LeKx6IBtleO4knDwU6d0UKHYu5cbRdnIzdcXOv3MLWU3XND3HZwM6pVRvehoDKGqn0yI0lTxehAb2ku9/frzHTKrKp0KauMxEoK0pwx37FReMKSWMHmUpudQ7PMZEVu647zFu8YRZlR9DKE9hBYmolPP/MZLfad0aeFQOi8dYmhJDQbCz0iowhyr6eisqf4Fc1lIQ/0h6nLhL71mMxKJEYykxb4fCvix2rHEHmqr+YlvKl2jJZRVGXGmBcvFagtFaudAUtRphRVwv0nLnJRr5yoaQQdofjm1AbkaI8g6DMiO6xXEoq/Bt3/mROlp0rD93HpuFVgWljvKhAFEG2XThOBE2VjXVVbNg0MuwHrWTf7suSsAbwxEBWwcwgZniLALntltNXURZPN3kEKIuJ4WuRRnVJMvgXM5r3h1jsRtwgA7YwwC688OSOm6SI6cvSsbVRW8EMOu5KGW8R/BX7vLMt7+WdveR7G832B2ePzSHXqxZ9EKcf3T6EzTRD6JFGKMQYv8EgTTZZlSCmx1mD1C1wZ8gJiecTmOcGiz9IzXeF5frfoy7QImRrqd0wy+9Nb6Fw2yOPftdx9xQDX3dBAeKDLEEnJf7nrSmRXE2hNaFLCUcHeP08pThwkqVfpjRRYuKSGv7OA7xk+fPBy4kHFrV/u8M8vv4srX9ZhLg3RKEJtWV9t40nNtZ5rXWIQS+aHi7twV3eEr/XXMTrewE9CtJHMTteY7Zb522M7SBKPnZWGS61JSzFIuG92nHf0n8APMk6kJQa9mHrQ4xe3P8Tnj17E5YPT9LKMRhJSUJqBMIK8astqQRQHzLbqlIsGtSoing5IheLhuTFWBV3SRNEYUuxvDbC11uBThy8i8gXvrT1OO/MY9U+2P1lMfVoBVZVRVtmSf9PVxTlu74zTsz4P9gfZUWhRVwme0ExHZf5iz2W8avwoZT9hpl8kUI4oxVpxR3eMtaUeNZmy2NP2dB0SwGRWRAhLZD2Op2UkFl8aUiu4s7uKcb/PTeUZkpycxlYw6vWpKXMGET89ay7ICa2FHcU2UeYvpWMBJtMSGRIlDKE1+Gi+262xMZznEvOHQAd4KlsOmf+TQfIYtvFbLnpU/mXofgD0tCuVFx6orTifo2pOZMjXn4dIF6NUQoCReVTqJK4bupZu71ZeV3zE6cyA9arLZUGZihrKnbg9Z5Ip646wwRKLtKaD7fxPSO7OD34dW34fMrz2KfZxBT90WCFLAGyy1p7h9GatvVcIsen5G9KLj61XbubOz9x9yrLj+05gjCEsBEglKZQE3WaPuBeTJRnKl6RJxlKO5ocYz2jvzhIBgjxt9hxPl1VgpcAG0jXdjY0LqhgIZiNWv/9xKCgKQ5aP/Nlq7pxaw8WvSZk/GrDvNo8DA1VEoJHCUh/JuPjh/Txxv6AYGgbbC2THFOnueeZ+YgMjOw0nFgpYDAtBlb9pXMWO9HskiY/Vgi31BcCSGYmShppK8E4LPM5kBb7WXkdZpmwvN1jwCpyIyoRr5hkyU7QbJeZblaVeZRKLztuQTPYrXFmaZpXX5+bKFCVpWLP+EFcMT/Pfdl/Le3c8QisN3QO/W+Wi+jxFlXG8VWPy2AhVNLUgJtuROr3XdEBmBMd1lcqODt/uruXbd6/lvRc9xP6ZYfR4xJdmN/C64WNkVhBIlgTSfu7KrYQ9pQLkqtIcnrA83B9kKivxeGOAK0vzXFZYIPEsP3PJY0Sp4taJTVw9PE2K4ninyof3X0pPe/z5zV+lLFNs/rA+WdPFUkuQUGiMFcyZAIFdKs8XQFlkfLu7mhtKMwQCUmsY82OwZxNbn+OcAjIgQ3D1yAk+cfBiyn5KagV9q0BDoDSVMMYKgSbhnq7ikrAJlHEJwP55tlDFkSpc1EgOgZmC3t/A4Aeg/2XnwG0BUpBrofKb0P4vLk0m6q5KDuuqxETRRZiWjCBPYmNxnHfWjzGbSFI8sCkF4bEl7AGDnPJKZBqu+k14rkEvYDv/GZIH8j5v0rmJd/4Yq/4jwtt4gTO6ghX8YOF8ZKlwns9+qC1Hr3rVLr7x4Ts4tu8E5VqJLM1ozrYYWz9CoRwysX8KpQR+wSfuu9C6OZnr+KHGM9lFKwV4EpGcXcP1nMfhDGRjBawU+DMR+JJ0KHSVc93MRZtizeahDjoVtP7eI6j2+OW3TnI0C9jzwJMc7w8wvi1lW32BD/ynVSjr4/kGg0Rh6HmKwnfmKVxewwJJLDGh5FAwykynxECY4PkaXxq0lbQyn+EwOulftGy4e6K6iwXkxo9DYUQ9iOkYj58YOMSecIwPtXYtfd9pbzQDKuGK2gyDqo/kpPhaACWlee3aw8RaUvNjIu2xoAO+NL+e4WKfmazAaq9LOy1ircDzDbVdHUwiaPVDKpWURHuMFFxK7v1PXMmC9llvY25vjfO9zhjvGjnATfUpUqQzyvT7Sw43i/GNyLglOwotHuwPcW9vhI1em7pM0AgGVEJHWL47sY5PP7mTrx7v0LcKoV2/tlYSMt0rsaXWXJofDaRWoHCi80BYBlTMiBcxGRXxMEsNbiUw4CV0jU9sFSWh8QRk1pI+jZCmAIJ83t+4/gDfOrGBqaiMkpYo8VDCctOWQygJFouylsSARTuVmyjlbwVnekG523CU75nvnJ2FADEAeg6RPYYo/zi29FanaRKBaxciBMZG0P3LfJB5ukyuclYB1kD5vQhZwdoMmzwI0ecguZcqx6kUBogZRooUXx91lW+2A2oD6COuFN/kKcDybyHkAFZPunScHD2Zr5Ql0D1s9FVE5VcvaD5XsIIfNJyPLN0jhPgVa+0Hli8UQrwXuO+52LgQ4g3Af8O9dv2ltfaPTvtc5J+/CZf++0Vr7f3PxbbPh6AQ8Nvv/zVu//id3Pe1h/ALPgvTTVZvGkV5Cs9XzBydw1qoDVXZfPkGHr7jMfQ5yMCPOoSx8ELOjXReT6rl+s7ZQGICQbK1QngiQpcUSMFj7SJbqg3Qlt2fC9i1MeSaV7SpDWZ0mq5Muz6c0W17TvxrXVoJCxQk3nTMpClj1oWY1KmDm7FioeezqtjFy4Xc8zqg4qeuIk2eFJ0b3Imf22QuEYvEunYjFtdE9lXjh/nc4e3MRkUGgojMSJI04DVrDrGq1MvTXeRrcTjeq7C11uBLR7fwqjWHmSLgW6nrjSYyS88LGBptkUx6uaeQC3cJD7yiYU2pwxO9Qbqpx0UD81y3qktiJAfTMs1Ag4TvRqNcUZsjzT2SFrKMusoF5hYS6+WHw+JhuChocXd7jJeVJxnzI3xh8KSlrDKaUYhG0DM+odAEfoIxkCnDNzurOSxLXFxoMub1SK1CCctcFtA0Pqu8iFsnNvAPRzajVnUZKkVUZMaQF3FjaZq9UR2AgnAzLfIxFfNmtmctHjgLnIjdUg8S/vj6b3L7iY3cP7uaoimzbmSB8Uont5UQ9I3HxcUG1kBCTMv6BKJIVWbIvMLMTXgAYhRMy50RcgQjQqKshxSSAsYRFly5vPU2QXIPtv9ZrBxwjWgH/xr0QSw+ZEcg/R6IKqLwWoR/iWs22/w3LhpkW+4CIUWYDgXRA7UDjHDkSnqgxpzNgJ6Cyj9GFF6NkE6/iWngTC1PmzHh5y7fK/iRwo9AgGAR5yNLvwV8Rgjxbk6So2txdrDveLYbFk4R+D+B1wLHcOTsc9bax5Z97Y3A9vyfG4D/lf/3eUepWuRNv/wa3vTLrwHg//w/H+PuL9/P0OpBBkbr1EdqzJ1Y4G2//npe+q4b+cWd/5Soe6YfzQ8azvWu/WxkRS8Y8vSWDRQicWIoU3A93lCS9g1jhJ8+hGobrC9JfMnBiSKhTmkvKP73fxjnK387xE//5jTDqxKMFjQXPNJYYMyiHMS6FF/bkFUDJpMqBsekhLHIzPClj4zwyt85RuC7CjpPaQTC+fXgxphagZdXw20LWtzOGibSAu5Ral20RxpWeT3qXsJ/uO52PvrkJdwzs4aiSvnF7Y/w1g37zvAqXnyEDYd9ullAT/v8yaPXUxhvo7B004CLavMk1iMtWdYNNdk3M0LNT7AIOqnPtvoCjSSgXOnxmsFD3Dx+HG0EI4U+zSTky6213J8NsWBCPrmwibfVj1CQmq4NCI3Bl5q90QB39UZpmYAtQYtrirPEVrE67NPQIQtpSDlMkcISG8mmgQbNIwG9RFLMBeiyGlMpRxwRZU50i9zZXcVLy5PcUJ5hIS/594CFLOSemTUc6dX41eAA1wxOsaA9hryYstKsC3o81hvgE43NlGTK1aV5xv1lrXJOn8NF6c9ZsGhGORCmvGPTfl63/hDfbI9xX3+URhYwpGKuqsyxMegw7vVoaw8hLYlO6FlBT4aMhmN4pXc5PVD0TdeGREgw0DQjTHcO5ATOUlMZhdIYg4C1Cbb1h5A+6litNdjoC1D+bWThZneNepuh8FKECJfGbDvvdyQK11LFLUyAFKyXm0uuA30Qp1WadoSo+lvI4ptPnQC1Lv996gjS0kYSCK4656W5gh9SfN8/FJ47nJMsWWungJuEEK8EFnMAX7TW3vYcbft6YL+19gCAEOJjwNuA5WTpbcCHrDMq+p4QYkAIMW6tPfEcjeGC0O9GrNo0Sq8VMTdxgOpQlbAYcPnLLuFV734ZQehz89uv44sf+Ma5K4N/gPCDKE+3visvExqINSKzJGtKyHaC18nojxcZ/Mpx/Lm8Ikk4MbL1JEkmSa3g+EHF8YMhxw6E7Lq+y8K0zyN3lclSZy+QpU7JHCUK4Rt61w+drJeXAisgSFKqhYykJzE118/OF65yyxPGRXZw/kgGQSgMo37MWr/DZDqKEsaRKGkpkHJHZzVvrR9hrNDjfRffz6UbTnBff5hHbZnR3hg3lafP2o5kpNAj6Sv2teto32mm0kziqwwhLdIzVGTMy7YcZnuxyR0TG5DC8tp1BymplO/MrOOqwWleueYIPe3hS0stiPGU5q3hYfYdr1JQzofnM82NGAsNHXJpOM/OUpMvtzaghMEXhgf7w+yOhqjkIudxr8vaoAe4xry+hDeNH+Ljh3byZGMI/IQjosjacp9hP2bUd6mrtvb4ZmcNQ15MXbkkWmwFAXCCkMGwz7WD0zSjEN8zRNYnwFIiQ0rL/qiKsYIH+iO8uXaYSwsNVE5Kcx6MXDaXZ+NSS2J2l+ykqEIWTJW3FI7S0T676gsUZEYhX2dVZnQyxRNRmUEvpZmE7EsHeFn9cvAucdVt8TdBVIiyBt3oMYrS6a48euzuDbOn+Ze8Z+v/jwdmv8Kh1kFG/GGurUnGfAE2gu6fYfwdTtMU3QFojH8ZT5pX8kSvRTV+kKvKRaqIZRGhkvstxvV489ZD+XcRcgTQ4F951sa4QlawpZ91PkwiAII8dbcaEb7yjO+vYAU/LLgQn6VvAt98Hra9Fji67O9jnBk1Ott31gIvGFmKejH/+Vf+nON7JxhcVccLFJ2FDrXhcQAe++4TXPGKS9l4yXo8T5GtpOJeHJjFvnIuamQqHv50HxMqog1lCoc6+I3EmRrn1dfCAonBegKRweJr0uThkMnD4SmrtxZ0BuGowKqQ3tXDJC8Zxmi79EQV2gnJ33ztURqzHkM153GkrSa14AtB0wSUZUKQC5A72iNDcDQpc21pmnGvjycsm4IOSli+2FrHZxsb2eK1eCQZ5lBaoSgz6tL5FbVMQF0lpwiqF8vfYyt4rD3Mr1z0ILeMH0cCs2mBL7TW0zE+GsGCCfjxLY/xlo37Odap8r2ZcVCGazcdZswkrC52MQgCpZ1mSGT0M8W1AzMcTSsE0hAbyWxWoGN9jqYVHloYZtiLKAjjCCGG6SykiUdNZdxQnsEXZqmNjS8MnoBfuORBPnF4J1ONOoVKzGChz6Zia9l+CRIruLOzikBq1npdLgpb3NceZSops6nQoewlDAYRiXFeUD3pYQWMqYiydC5WqRV8pb2eSwpN1LJyycxCuGi1dbZQqgBxSow1RQqfHx+a4979ZTZVm9RlrmE0jlXtiWrc2hlnKitSkRk3l6bY4u3FLPwGUpRcdEkNgOkSZyeYzIZQQqBNgwPxKEeTMg0zyZ/u+R1SavhCcSjR3Ne1vHtMsaVQcPqk5u+DmQQ5jLEw07kDoW/nkfbLiNOQe7uWXx+xFGRevohy1gJyCMJXIiq/hpDVC7rUROFtoNZh+18E24DgTYjCm18UJ+8VvIhYsQ54wXC2AMZZbk9P+R33RSF+FfhVgA0bNjy7kS3DXV+6n+N7JxheM4S1lvnJBr12n/0PHCCNEh687RHGt66mOdsmLIVkSe+pV7qC5xxCO7JilcAqgTefkA0GyF5GvLFKeU8TKwGpsNLmveFy7ZBcfACeJwkpIM0U86sHCX9mhI5fwVpXlyXyknmBYM3kDLObyhxujrB1vsPFg7Mo6TQs88bj09Ob2Sq69H3BsazIwazC9eUZfGF5U+04iVFkOfUJhebNteMciEp8rLUVmY9uo9/mDfUJfAxlmS45Zy/CAh3jMS8C/s0N32Zr0KaVBRigqhJ+dvBJ/nTiUmRoORxVmAwq1FXCxoEG6weaHOzV+PDeS/gPl9+5VMa/mEL0haGqUm4ozXC5XWBPVOPh/jBGCDxraOmAhglp6NCZQwpLXyt8aQil5p21fZSW/ImW6bcsvLw2xeC2mA1hj/u7w9zdHz3lBiCFZVYXiKxiQCUcTKp8qzvO4VYNG0vec8njjIYRiZWUbMZQGDGrA0DwRFxDW4EnLL6w9K1gMiuyzu+CAU+6tivgiPGcDsjy/nSnRu6Wnx8p2BZFqmyq+SSpWtofATwRV/lEczOh0AypmNgqvt5dyy12mjXBvCM5+CBck9q2KbLKW+CLzTX0TBGEQkjopD6pzRjzFqvdJH2j+OJcwG+MFxC2B+aosxoQgma6QEML6jJhV6HBfir0dZt7esPcUp5FWM+NXdZBDSPK/2iJKFkzD9l+R6S8nU70ffrVIAQE1yKCk1YB1nQw/a+BPg7eVkR4wympwBWs4AcdLyZZOgasX/b3OmDiGXwHAGvt+4H3A1x77bXPGd/d/Z3HCYrOy6TX7tOcaREUAnSqsThPpuP7pxgYqxH3fvA1S+fDC6VbulDB7dl+I7RF9TT0NKqVYKVg6EtHkImLAJnAGe1YpSDRCA0yOa0vCovC35OjWLQ4UI2UTt8jCDSpUBTTlAyBFpJiJ6JHwB/tv4VKXVOcNWyqN/nXV91JKgTH+lU+/PCVBFg2lpvYSoaqpHzLerymOoFFkCIxCIyFxAaMeBFClNEIutZjzOvz6tokHa1QwlWh1dViRaYb/kLmk1nJ0bTMDaVZjraqCCEohCl961FXCddUZ/nm3FpGB/r898lLGGrDUBBzrF+lG/lsLHYIpF5y517Wmo+KyCjLlMAabi7PUJSaz7U2goUM6dKNCCIUVudkEsslYYPtxRYaJ29eJBWplWgLZZVxbWkeKyw3lyd5JB6ibxzRUlim0wI+BmMFs1lh6RitkjEXDZxgS6VJN/Mp+ymJllhhWe1HHIwr3NsfYSj3dlrUIxWFdv3t8kxqYiXaCHrG447OKh6PBynJjJ8aOMC64PSyf4m1Gm1hTveZK0Mw45OkHsYKAj/j9s4aQqEpSp3bGxisydgdD/J6ZnCVCA06SZOpZI7EJISkaJtiKDgZthVEVjKmkvwoCLCaAjCfpXTTeSr+EE6P5D5rJxNIm2BtStU+AeJqijLi9s4qrihlrm+cCCB8DaL8iwg1jLUW2/sY9D958upTq6D2+yBXkdkMT3inmFsuXXt6Atv812CaS9eP7a+B+r9HyPqFX8Qr+MHD8/hAEEL8NfBjwLS1dtdZPn8F8PfAwXzRp621f/h8jefFJEv3ANuFEJuB48BPA6c3Hfoc8Bu5nukGoPlC65UGR+vOPwnoNXtYm7e9sJaFyQY6M3i+ojJQpjXXIUvO56Xyg4/Tq66e7m8v5HdPmygthlxOW7k0YM2yhRZk7NJuSIHQp3z0lNsXQOHJDt1H+rBLIAclpiCRCGoqIty/wFx1kHA6ptOw9BUkWwb4wBNX8lM7HuVPH70aJSyBl1EUBtkVHJ8dJBlpI2sGgSWx6hTTxcRKHo0G8DG0reDScAFroWd9sNA1HrEVrPKdC3VmBB3j8enmZmKtuLo4jzbKRXiiAKUMfc9QiODAiTEq1Ygg1Nx/eByMouzHvHrkGDeOTVAP4jx9mPsMWbHkpTTgpRxOQrBwRXGeu3qjrmmu1PSNom0DQrRzs8dpl+oqppUF1JQTdkdWonPbgYJwKUspLDNZgY7xuak4ybd64zTSgILUJCjWel0qniYyCoFFAzOlIr+28RGG/WhJU+R7mtgqYiP5fHM9s7pAT3uEwqCFYMzrMyBPpi+1hY7xmc9CFIZrSnPsT2pERvJ/5rfzGyOPU1MpznhTkFDGmAglUoY91wdQjDkRf+hl+MoymxWo5Gm5pQo8oWnqEGul84y0MUY/zqiU9ESRxMCJtEDLhAx6GoFhQ9Beaua7WD9p0EgUATGUfx2a/w/oGbBzrFYZPeGTWsWCLoOZwKqtWNvDll6PKO4A/yrXHmUR6QPQ/zuXlltcrqd5dPL/5Rvd7cwn81S9Ci8ffTnXDV1zCmmynfe7ij01enJ9+ji290lE5b3nuJpW8MOA5zkN93+A/wF86Dzf+ba19see11HkeNHIkrU2E0L8BvBV3B3gr621jwohfi3//M+BL+FsA/bjrAN+6YUe583vvIHvfu4e4n6C8t2bVRpnlGpFeq0+nu+RpRlBwWfbVZt4/Hv7yJLsqVf8A46nG2USy/77XF9fWUkiM4uKzlzzcuKz+KnIzsKsTvneuUcpgI3f2s9r36i531tH7HlcNjLDJTNH+IPyK/BkhihJtLBobZk/CF/1NzNdN+xrDFP23cNT4vySVod9uq2QA3GN60pzgMHHkQZhLZmVHEhrpEYSYPBysrIIg2RalzBWUpCO/X2uuYHHowEGZOwa6eK0Q1YLssynKlIenR9xTXoFFFXGzs2T9GbL/Msd9zJe7DAYRKi8ue2BuEwoDCWZUVEph5MqWd7bTuZprauKcxxLKyxkATWZghHEKKTVSOmiKo9GQzwRD3JdaZrXVSYAVxEocouF1MLxrIy2EiUsmwpdNoX7+dD8Nm4pneDO3mrK0iUpizLDImhrj5LKGAn6KHHy2AlAWEPDlJjWRUDQx6NnBYHV9I3HXy1cxDvqhwDBgIpRGCIrKQpDSercbNNFmh7sD/LSyjRt4zOdFXC1agXqyqXqBryMvlSEuY8TwJjXZ14HlJZZFkRWMepFCFEAOmA1nrAIJMNygSY1PFkAY7mm0ODGyhSTqeITjU2EVqCkxFpB2yiuLhsCfx30/hpnSOmcuj0BJZmgUTRMCZC00yk2VG9gsP5zZz/no6+76rZlBGpfPMAnZpqEQYMBf4DUpnzhxBcBuH7YpeCsTSB9GCi6qjpCV3En65B8G1ghSyt4ZrDWfuv7yQD7xYwsYa39Eo4QLV/258v+3wL/5IUe13JsvHgdv/CHP8XH/sNnwVqMNhQqBTZcvI799x8gTVM836MyWEEpycU3bOfAw4fo92JM+kNQGvcMccFis+cAXufMlhXLt/fMqvtO/dXysfemFF/5dUFpcILtN/Sp7Uz4+rfrmBsEUltMBviAEqSJIOl7dKxiXblFPUiYiYt0jEddpcRGsaHUYbXX5fGozsWFJprFEnXBV1pr6BqfMglbghaPxQNcVZpnebLSxxDh0c8UCYqGLlAQGW0bcE9/mCtLTRr9kFRIBoOI2ajIHdPrqQ118dEMqYRG0fBH13yPYf9kW47Mumq1DUHX2SNYsLlNwqKHUgnXtDY27m9PWAoywwjBsIgJpaatfQpC40mLj+au7hiDKmZD0CPAtX8pSU3XKA7ENUKRMe73qKuEqtS8feAwPa24rLDAI9GQE1ELZwQ7mxV4a+0IJh+rXaY9K0jL8X6Rpg5QWDxc2s0gqMqMJ6I6/yXZ5byhsNxYmmLEd+L7uayAWZJzC06kJQ7HZaR0f0sMSliaOmBQxUgsJ9Iiq/yIqqsW4JWVCT7W2ErPOI+n2Cpiq3h75RgZGQJJbBUyb1HcNSWMUGwpjbNTP8LragcJpGZYwVxlkm9312C1I3CXFFq8vm6cN5IxrtTfFoF+HrESLGQ+G7xJjsQbGQkM71r3jnOf7rYHpxlR3NGy+AIK0kcIQSAC8OD2mTuWokvWJs5fyUYnK+1E3emnZOm8V5jN86FnS+2t4AcEz+6mPiKEuHfZ3+/P5TRPBy8RQjyEk+f8c2vto89qROfBi0qWflBw3euv4opX7OLEgSnmjs/zqf/6RVqzbYrVIulcm42XrEMpSa/V58Ajh/ECD9s+m1PvDxfOUTD0oozjXIjWl+lcN4KuB4RHOlTumcVrnbtPlwC87RK9YLD9XKvUW7afHsjViqQJek5w7+crPHKrxfMNQdigdfUIKsowkUAWLaboMeK3+O3Vj7Np3T34edx6f7vOl49soad93rNjN6GfkVqn9xmQGZmVfLc3yn39EQAGVMpjyRAawcPRIJcXFrDLVFWfbW5ke9hkZ9hECsugl6CAx6M6B9tD7Co2qPopX5vYxH1mgLUbZxHCklpFZBSb/DYD3sl5sUDPSkq4SMlEGtDQIZuCDuv9HgeSCqmV+CKjZzyOpS56EwjNS8uTfL61EYOmpQNKIiNUOk95CQJpeCQa5qHeIFeWGnSNxxNRjVldIrYuLfeOgcOs9fvEVjAgE9b4ml2iQdf4HEyqzosKQSgyLi/Oo5FoYwnFyRIdA9zeXo2HIUXhSZcKMwaOpSUSK5HGUvFTYiu5tbOWt9SOUJdwT3fYrcO6uVjj9/l6ew03VWYIck2WwlLKK+wSK5ECYiMpO39SNoVtfmbgSW7rrmE6KzDqRbyyMsOWsE0jK5JSYiELgYyiKmFRlEWXtd4kO4oLKH870EPoWV5ebXJ9eZ65rE5VpdRVBmon2LaL4hicDsn2XbpYWkb9lLKaZVtBsm7wPXj+efRDwS2QPgS2ukR6ZlNNKBVLveEAX/g00yapTR156n9m2Up8dwWZBSCF4m+ddVPWtLC9D0L8LcBig5ucdkoOnXt8K/hhxKy19tk0FLwf2Git7Qgh3gR8FufJ+LxghSxdIILQZ+PF69h48TqufNUuJvZPYozh1o9+h9v+5lsc7kT0mj3KA2XqIxU6C12Mtc9537PvN1woOXoxpqG7s87Cm9YjMotIDd3Lh+ntGGDsI/vxmmcSJgHgg00tQgEeqI0Cvc9iM4HY5iEzS/FfVfEGIP5Uj+TjEUZbSoOG4Qem6K2rkI0WyF/v8eOMf/+S77IjbKKWJfh21hcYu2g3njI0TEBqJWOea1sypQu0tM8VhQUSo/hKey2z2kU6AD7b3MBD/SG2B00Sq9gdDTKrC7S0x65Cg51hg3t6o1RliictX5vYzGeikFAYxsYW8EspQku0UaRGYpTgutLsUtWXycfo4arsLC7dlyE5lpZZ73cZUxFd4zOZlbi1tZqmDSkLzU8MHmS912Z/UuexaAApLEGuRyJfr8SSWElBGm7rrCGxgumsxJCKKErNlqDNaq/P4aQMQIqin2nqSlCWGT83uI/MKiyGzzQ3cTQtc6nXILGSzIK0rjdcamQ+byz5KKXWpQfjxRPSChKriHP39Lt6ozR0wFRWpCpSMiTDXswT/SqPJYNIYXlDbSJvICwoyWypMfIav5dX9i1W3cH2QpvtxSfy/ZcY6yoLW3aQkugTqgLdrEtPx4SygMZQF9PU/BrKG89PzBpkhylKw7owdSdp8Seg9JPQ+G2cTzC5b5Jk0ezN6cQ0da8Bxdec91oRhZeTxreRRPeTAaHwWOMPcURvoLqsIi42MTWvRjftEsuYcvRV13tOHwabN+xd7OFXPLPXurUa2/oDyA44fRQC4u9gs/0w8F8RS42BV7CC88Na21r2/18SQvyZEGLEWjv7fGxvhSw9A0gpWXfRGvrdiGNPTFCsFhGeIu7GpHHGwlSLsBTS70ZOObqCZ4VnonOyEpqvHEf2NXIxHZoasqpP+9oRBm89S51A3jfEJhY88Lcp9KyBuoCSj0w16sYQW/VIBIQ/W4ZjGnNPTBAawm7Gqo8cINpaJV0V4jUSdr1tgWuG5zA4Lcki4elphVGQCUlsJaMycj5CCIZUwkIW0tQBV5fmeKRb56ipnTLUg0mVg8mpvjiH0iofXtjGy8onWBv0OJaU6WeKUpDS74dsLLdQlRirIROC1AhGvYhQah6NBripMpMLkZd5q1ryhJE7ApFVnMiKHIorfK87Ss96XBw2KMkW64MOY16fUFpeXZ1gW9DkG521pEiKLNfteFzmLzDmR/ztwhBlmVEUGVWV0dI+RZmirSBDLfV3C6RFYOlZxW2dNdxYnqYqLZFW/PX8Rby97kwmC1JTyJvq7olq/NLwfuoqZTItcGt7NfuSAeSymJwQlsm0SGIdkelqj5pKiawish5gWUhCWirgoqDB4aTKV1tr2FVsMKAS9scVLis0GPZiUitIrSIDEJpFqb5Y+rfEteOVzKYBq/yEgoiwqkhi4rxZcJ1NlSuoyAMAJDphNklJzDCDKiGs/DrF8juXxNnGvwzi7+IIU4eTNYbS/aPWgyginuJWPxXN86ETA4zKbaz1ZujZkMy7HK0jOlmHoioS65hO1qHilflv+/8HWNjkwduHAmrezpwsJflYYlyk6TSku0EfOrW3nBp1qbzkPghfct5xruD7DC/i400IsRqYstZaIcT1uJN+7vna3gpZeha4+0v3c+LAFKs2jjI3MU9zWuEFil6776wFzApRWsQLZTuwCF3xsaFCdU4V28tIk2yonDEesfgvC1hB4SWK4EZF/0nJwu4i9bE+4voK4tIAmxpEZsmUxH97kf5dCbNTAf2uwgoIp7uU6SKN4ZLLne9W3sQEgMm0yN8sbOWnBg6SGUcKpHREykV0FisuBdYK5DL2EpKhBPStwp4R1xMcSKocyEmUwnBz6QTXb5rjE49eRqwlBVzkQxtBPYypeSmRlfStR2IlgTC5ONr5PCFcRKZnFm8VFg/LY1GdE1mJES/mtdUJpnQRAbR1wN6oxhdbawmF5U21o3ytvY6mDlwKDFeJtilo0zY+TROQGEHdc7qhEc+J0n3hyJECAnGSdAhreTKpcW1phmNJieO6jEbyxdYGjiYl1vp9Vnk9ZnVIR/tc7jdoaJ+6SvjpwUN8aH4rk2mZOE+jaStoWj/fMxd5snrpjAAEIZqizNBISjLjaFphKiuR4WwRtgeud5svQRFgbEZKASm6uR5pcV0Z2jpjzbnMsDtaxU3lE9RVn5KwjJcugfIvOh1S5z/RSpoc7h3F4nrrZVrz0YMP8ts7Xk89qLumtunjYKZxJMzmJ4oHcsQ1xBW5Duk8KS5rLZ86/lliq2mIHTT0Dqy1NNIGNwxdx0w8y/H+BHW/Rl/3AUHNc+T9UFznb2Za/Np4EbloSqlnIbjx7FokM+X2T57+mcHqyRcljb+CZ47n83gJIf4WeAVO23QM+DfkDDzXNv848D4hRAb0gZ+29vnL5ayQpWeBx/5hL0HobrTFahEhBFLmvjIrROmCcSFE6umSLRnl7WklLDNpxvoSNXWynBtOug7IYfAvkpReHSAHBTaDyUs30tsesOqyE6SxCz3ZQCGM8+sRNUGGdHET5Srt0pGQVAjKfsTESDU3jcy9myx8obneNdjNAlb7ffrao28UBU+DdV5L1oLEuVy7ai7Ly8pT3FSewlrLRFbh7u4Ie5OaE12fBVVSFnSR947tRWWCTz25kzj2kZ5mIIxYXXZpk9gqdhSaWFxLkYrKILchkFg8YanKBGEsvrRMJCX2RgME0rA+6FBWKaMINIIHekN8qbWeGI93D+zn0kKDTUGbR6MhGjpgnd9lR6FBWwfc0RzP51/kKUpHJ4+nZTI7T0lmTmSel9y3jc/xrIyHpa0Dvthav2Q98OrqcS4rLCwdTyWgJp2A3iKIrYcUKa+oTPHV1lo6xqNj/fycOnnL1yja9qTQWQBr/B5lmTGnC/zswH4OpTX2RlUSqxjwEvYnVYZVTCoCqv4gnhomsAqyB1ge5bE2YzYLeaA/zAPRKgLp8ZV2yJhKeH29AXoe2v/JGULKNTR7d1OWFoXzQ/hKexvHo3k+e/zzvGfTu7GN34ZsD0taIQIgRVNnT7KF2TRj1OuxffhXCMW5b/XNtMlMPLNEgMClGAuqwLH+BP946y8D8N3Zf+Crk1+n5J0UbtfCTcxGezjWX2BDweZEaBBRfs/ZN6bWuPlw3ZuXf4DwXN85ay2kD2OTb4M1iPCW3OpghUr9KMFa+zNP8fn/wFkLvCBYIUvPAkOrB8hSF7koVgrUR2ssTDXItD5vM84fVTzT6NLyqrbzFfwvf+jJxFB6eJ7uVcOodoowYHyJ9QTVe05NaS/+yt+mqL43wHbc0qQYECc+diYl6vsEQYrOXJrDeILA1yS7tbuKdF55XQVPZGSJIn3PMJPFLvviKjsKLTIj6VnFVFakJhMe7A/xWu8EFZHSyXyGVIKP4XhaIhSGosq4o7OavvW4OJynrT3++8ylaCsY9iLeXDvKxqTD1zrrTp0J66q4tHTVVhNpmbmi4uqLD+Eby5wNEQJ6RiGEYlDF7AwaTKZFilJTtJqu8YisoqM9AqGpqYzjacAjnUHu7Y+QovCt4bJwHoPK/aEEOwst9sUtdsdDXFJoLImNby5PO8JoXQTtoaTKw/1BACIUVxbneCQaRmDp4PG51gbeUD1KWbp+egeTCp9tbGTehEgsH1nYghRO/3RNcYYrigs0tCMNFlgXdCG3IhD5uREZxbAXM53rvwI08RmtiE9ijddhlRfjC0PfKARQVRlrbI+79Fgugvc5klZ5PBrkXfVjGDXMoD8E2VEyqzieVhEYBmSPWzvruK83yrwOia2HErDGE/x0fT8DwcUgUkgPktqMySzg881xtoUJPRuwOxrjRFrEkvJA4wF+LtqASB8FirjQI2BTMhswmWo+Oa+whEi5nqFoH7+06SVU/bO3M5FCnvXCstailumVGmnzDEdvIUKEt5FOsBnCHqiNiPCWc7c+8S4Bb7sjeXKQJUG42gj+lW67vQ9C/3OAU8rb+JtQeB2Uf22FMH0/4fwOLD90WCFLzwI3v+MGvvPpu4i6MYVyyLrt4whgYbpJGqekcZ4CWh7C+BHHuW51FzJFJ4vCz/Z7ccbygTsmAehdNoSVoCLN0JeOUjjaPev6k7s08eWa8HIPUYXsuMA2MoIn+0xUqmy+bgEv0C415lvMAujdEWqDxMwZJ9loWTZe2eO692aUNi0wEfr86ewlrPYirinNUZMxHeMRoDmSDvFkUuOllSnW+V0e7A9iEYx4MT2r+HpznIdyQtHQRWayAjJPvk1mJf5qfgeb/fZSZdjyCVw0kZxMC/yvuZ0Yu9iDzZX2X1ZY4KH+EBbLO+qHUQJiJDUZ0TeKo2l5qXQeBH0Dn8nJCoAnDH3rIYWgbyQN44iKh+EdA0c4MVNECTcuA/SsQlmXTtII/nZ+M2mujpIIrijMcVVpnseiAQTW6YBUn79tbOGJeICGDlzEiMWmxC6eFgHXleaIjMJf9tmATJxtY2ZycwOoSM2huLqkG4uXbn9nnlVFkfHjA4cZUCkFqXmoP8i+uMawivnQwnYKMiPIe99ZBFNZkXv6q7nRm4asz75un081L6NnJAKDxdI3HgMqoYKP0a5Q3wBlKVFCQbaHe3sDfK01jMYylRZ4IgZNjcimWBthsbSzDh868kl+vi6Rp5AHn7ksIbYlBopXLC2di+f42uQ3eMP46yiqoiNHy1Dza6wrreN4/zg130WXrLXEJubqwauWvrextIG75u7OjXnddo11jupr6m9GBk9dzSaEhNrvY3t/B/GtbgYKb0SUfhohfGx21BElOXQyhWgNRN+AwmvB2/aU21jBC4gfoWfaCll6Fli3fZxf/uOf46P//lM0ZloYbbj29Vey88btfOjffJzJgzPuxoLgeUyl/sjhQj2chLYM3naC+nemMAWF10lPScmdjsp7AsysZe6f5f39Kn2G/QhrLOIOmLi2RvhTFYKyxuxPkP99lmAtmAnrolEG6sMZHNEM7Zvn0q0RLx007O4P8qnGJo63yksGkfM6xOIa636isXlpJywCscwWV+XC6PkszM0LLamVedIKTqQnUyLWnpyZQRWzWTV5JB1GWFDCGVwqa5FYjsVlHpsZwSD4EjE7y01qKkXYxbL7xfotiycMsVU0dIAAPJmnFLHc2lnD66tHlx6ekVUIA1cV5+gbD08YirnBowCsEMykIUVhcB6igpJI+W5vFW+oHefG0jSBdFWkoTT8zMAB/t3UlRSFk3srwFeGssxY0AFoPyeBZikdudp3XkPCWmoyoWt8lHSf3tUdyQnXIoVZTpTcPvg4OwADNI1PbAVXFOe5pjjHnC6QWklVpsvOO1fxd0dnDVfVmrR0j48316Jsn5p0x2s6Delaj0GVkBgIRLZU0XcgHeGKYIYn4xJfaI5QliklYYlkmkfBeoCXvxBYhvwhDkTzHC4OsTlsgvVZ7PxrrOZAumXZOWFJbcbXpr7BI63dlFWZ165+NVcOnCRTAO9Y+zY+ePjDNNOmy5ABVwxczhUDly99Z0f1ItYW13Ksf4yiKmKsITYx1w9dx9AFEKVFCFlGVH4JKr905ofZ425WhVr+A0Bjk8cQK2Tp+waLpQQ/KlghS88SV7z8UnbdvJPpI7MUKgUGx+pYa2nPd/jwH36C9lxnhSi9SBACV/5vDKplzvsSJEcFhZd5NP80WmrBRcvi1RPiWgm0pXBfi07g0x4PWHXbNHKVQB82zs/Pgh8a1m2L6fcVX//4EOuumSQeUlxaaHBf0OFQWsEXljRPRclco7MUFRKLSaSTyKk2KRLPWrK8d5z7uiXmTKF3WST80uATfLq1CYGLKIHTJqVAL/M4HlXwC4Y0Vnzu8Us5tOUoxTDjoqDJa6oT+NY47RRQlhl3dsYwSDxp8qiV0520tU9Dh1RVykP9IfbHtaXRKAHXlWdoaihLTZqTo6+319K0AY5kuN529/eGWef32Flooo0TXvetQljDmBexP6nTsz4ehku9eW4szwDwtdYajiYlrs6NOse8eMnJfDor0DIBgyrlYFLm9vY4x9MSfm4oGeWtZU5ami5SH8HmoImX2yYUhWFQJvjS0MgCUiucg7lwpM4iaOqAUa/BqGxwf7SJ1KYU8552UlgqKqOXeUxnBbIljZZGE4Aog1nge506njBLx2vIj+kbxYIN81EKirLA6uIq4gw+sjDOO2opw16XkhRUlOZoOsDu9JKlzNx8ssBcPIdEUPfrxDrm08f+npIqcVH1pCXNcDjEb277JxzoHqSTdVlTWM3q4upTzitPevzCpp/jnrk7eaTxD/hCcN3Qq7hs6ObzXFlPE8L5dZ0JiXgKk8sVvAj4EXq0rZCl5wDKU4xvWbX0txCCd/xfb+LV734pH/qDv+PLH7gVow1Zqs+zlhU8l5BVUOsF2ZMWMQx2HkTCspr4ZRDgrZFYDXIof0LmNtoq1hRmu2S+h7VQ+/okShts1VJ+b0jrP8auEAnwy+6V3PMtSU/QPKhQOsOsN2yWLQ5TQeIEuwLDkIpp6AIZyx/Yi0OyeXRDUCWlTUByWrLRPW7PRIzik83NdLSHwKXjbC7AdhV2riLOakGxkNIMNAcnR7hly0Hu7K3igf4wI37ErsICuwoL3NFZxSP9QTRgjCDJ2+Au2glILPf2RjgQVynJjADLsazE1ztrGfEitoZt+sZpmvbFVe7rDbtKMiC1lkYWEOHxicYmdhRaXFaYp28UD/WHmNOuT5wACriKtMfiIYyVjHp9prIyt3WKrAn6bPQ7FEXmPCkFzGUhH29sQWHpGI+28QmE4Q2VY2wMO3yjvZaJtMi8OWm6KLCs8vrcVJlePDXoGA+bFekaj6pKWaV6+MJSlJr9SY0TaZEMydvrR4gN9IzFWhd50vkRC6R20UALCFcjpy30DTSyjLbu0jYVvGUtixWwNuzRjAIEIu/Rl3Kgc4DEpFhb4LOtjaz2+gQio6QCdPAqDvf3IZEUVEgjaYKFgXAAgFCFaKu5Y/pbp5AlcGTo9GWnIzB7uUn9JTcNxbhQ6P0QzUPxbef93QXDv9oRJtOBRd2T6YEIIXg2/oUrWMGzwwpZep6x/76D7LxhO56nePD23ZgV36XnHQIQJacbFQWgmUf1y87w+AxY0HMGWYPKzweU3wrRtzLi+1PMLIjE4MfJSUGjB6YFzT+I3fp9IIOoLVmY9ilVNdZAITRYA72GZOZ7FvNyi5YulVLM9UMCS0EYetY7bUiCkIwERwq6mb+kjzkblqfgPGFpmYAEiYemd5rfjRCQZdKRMSsolyOmpgfYFw9gEHSsTyfxOZqU+VJrnWt1cpqAHhyRa2ufIRVzNKk4E0zh9El96wjVRxpbuTRsUJIZx9MSE1lpaT2Okyq6SLYEHS4uLGCtYH9cY04HHE6rS3YKAtD57cpa2B0PYuMhPAwJir+YvYgdYYtrSnNcUlggth5FqXlz7Sh7ozoP9IcYUjFvrx9myItJrOIdA4eoyoTbWqv5VnctfRRgeXP9KIMqIcqr4jSCUGjuj4fIrOTtA0fzVCjczDRfaa3lnv4IY36fo5GHb44hGVwyrhQuv0pZpgTCsKBdFV5FZWwNJV/r7uLh/gjb/QN8Lx2lwEnD1J5xhNdD4wtBzxg0KSDw8ZjIQqRaRUEUmI0tIp5AW02U+yNlNqOiKgyHw0vrDGTAfLJw1vPofLA2xrb+GFCgRvKFKXQ/hPUvQ3hbzvv7C4GQZadpav+xqw4UFkQJUf1dhBx41utfwXOL57mR7vcVVsjS84iHbn+MJE4ZHnJvSEEhIO4nK7YC58H5Kt6eTn7czIB/rSA7ZrFzrlLNLlrenGUD/pUKOSBR4wK0izSFL/HofCxGH7SYBbv0W1F2/ns2BbVKYHsWK8H6gvkpD6xl+9V9GiMFvj00Sk/5TGwMMDMQjymksNxSOM6ebBCDILZnK/13Kbp/NLTPpaRaHm0T0LXeWQnTcp2Tc5B2BCxdtsOLXlLWCnzPECcKD4tOFbVaL1fqnMRig5LzzX7b+vxNYyuJ9bBAR/t0jIcECiKjrhIKIuP+/jAG1zj31O1Y3lw9xjWl2VOWfqczxoGklqt05BkBQZ3vl0XkkTOP3fEQu+MhaiLhsuI815dmuTycZ2vQ5q7eCO8bfgJtyc0moWUCsHBRocNrqvfx/oWdzKcBd7RX8xMDhwiky8cqYTmcVJhMCrypPkHPKLq5N5OH4Q214+xPajzcG+Sq0jzjMuXiwgK7+wN4wqCtq+p6efkEG4MuX+lsZcTrIo0mpoDQk+xJCrSzEcoKGjogFIYMxWzmMywjIkr0DblJpxOyB9KJ7adSy6bSGM3+k1S8MlvLW+jrPolJmYwmUUI5AXmOvu6zrbL1rMfzvEh3O5dwdZJ4IXx3HOI7L5gsTUczPNB4kE7WZltlO5fUduLLk4Re+Dth8AOQ7XULvG0rzt7fr/gRepStkKXnEf1OH2tO3uZrI1UWJl2l3ArOjWctGvQBBdk+g3+JIplxkR4SznpxizJUfyZEz1u8MbHk4O2NS/x1EtvQrt2VBQoggvw7GdgM5LjAzLq/41SyfkfMS36ly9crG1DGMnfMI+0IvBEXMcqM4Kv99Xjos2YFF2fhFdVJ1vo9jqVFjJCMeBGrhGUhC05JHZ2OFEnb+Mt0US4iJTEMq4ie9mh5AWkq0QjmmxXWr509L1E9H6YzpyVp5G03JJb1fpfESq4uzrI+6HI8LdM2fh5xOom1fo9rSnMkVrLKi7DATBZyU2WG+6IRGjo8z5ZFTgaXL7F0rMddvTEejQZZ5/eY1+5B/MXmOraETS4rNChKTcv49PEIpOFAWuXXh/fwwYWtPNof5C/mdnJJYYFhFXMgqfJ4VOeqkjMHbuiAvXGd6axITSVcU5xja9DmS+11DHgJbVNgIg2oqJQQQ0lmXF2a5crCPFYILi09xFTigwBtfaSAR6Ix7mgPss1rszXUTKUBq7w+RxOPni0TKngyylu5YNDWIuhhbUCkMxKdktqUsiq7NixeicUY3vH+BN2sSyAD+rqPFJJXjr3igo+vNW1I78OmjwFnu3e5uN+F4PHmHv7u2CdzCqx4qLGbu0vr+IVNP0+wnDAJD/xLLniMK1jB840VsvQ8YvvVW5BKkcQJnfkunqcQZwsirOBZ45QHfcbSmS088C8VpI/ac97PvU3uzV/6OCGJcYSI0FJ4uY+et5iexjRB1YRbd8ttUBQEclCgVlls36Ln4f6DdU48MYzZ4BHPO4PJxQZlAhDSOVmnzm6QAEOyFMU5+fC/sjhP23gMqpQ1Xo9jaYmSzBhSSV7Cf25amaCoyYTMOkG4ta4SrSg0FT+lHQdkWjF5YhAvyCiXo+fkJVFgqUvX+sMXhnVBj2NJiXnthM2na7M2+R1CoYmtz1RWRGIpSI2PYXPQ4YH++cjSmXCZUkcRO8bn8biORhIKzRtqxxlUMdoKSlIzqBIOxmW+2l7H4aTCWr+LFNa1X5EZd/fG8io7F2UzVtDRHl9tr6NrPBSWmbTI4aTCoErQKD68sI2SsBREQkWmNFDs8ptcXGyT4RFZj4rQSGHpGZ8UH2sFuwonOBwrDqVVfqx+EIuhoIo83g/4RnuQohCEwpKgwVpknpID1ybnQO8A0gpCdep8FVSBDaX1rCuuZTaZY0d1B68YfekZ4u1zzmfyELb9H1wY1aagj4CJwNuUX3QasIjghqdcV2YyPjvxOUIZLo3TWsvR3lEebjzMtUPXPJ1DvYIVvKBYIUvPIzZdup5dt+zky391K9a4ypkVzdLzh6XHsAUSkCMCoaD2fxXo3ZbQ/7heEmMvh2nlKboUbF4PK4oC6QvklQJ/Z5HGf4qI78wQZciOOQ2KKIHVOQNKwHYF5Xf4JPdoOtZHtp1Y3KYgApBVcUqSf7H8P1kyRrQEZCSnXZYpkpdWJrmvN8KBpEqybA3nI0yh0PjC0NYBShi0hRRBYj0KZCwYybo1c5SKcW6m/GxjehaFpaYyNvptKirje51R9ib1ZWTwVLjMqKM3FZkx6MWA87x+c/UoR5Iyc/r0KNr59lss+9ZJcnZ1cZYBlVCQmpLMsLjeeAVp2B/XiFE8kQwsJSw7xkMKSK1E5I1553TIA9EwfaOoyAwLSDSxlRxJygg0a/2IG0rTDKiEA0mFR/sD3Nsb5iXlBlYWsVZT81p0jMx9vTWJVfSN5OrSAo81NnBXvIqy7DLR9XnV8BbGovuZziQFkdHVAiVc+xyBQOPaz5RUASkUzbTJsBxGCYW2mp7u8abVb+DGkacmM2ccTRtj238C+KDq+VIP9JOgpRNdI6HwFvB2PuX6puNpUpOeYo4phCCQIY+1Hl8hSz9oWDGlXMFzBSEE7YUOY+tHSJMMKQSleol99z2ZV8XkX/wROuFeMGjQkxa5ytL7fEZyvzmTKOXhKH3UkD6p8bcphCcQpZOfLeqcKu8KSB/TqFGJPqGRq8G/SGG7Aj1hkDVB+ac8iq/3Kb7Kku7RCCUxqUXWBN46eQFRRXEKUXq4P8h1pVmaxkcIwbXlWV5ZmWB3f5DPtTfmKbxzEweDoC4TIuuRGCdITqxiQCW0lcfQwKI55/lJ14XDeRe9vX6EB/uD3NsfxWhL3577NnMkqaCRlGXKgEqdFxQ2DwJafmLgEH8+t4NTL5ZTNU9nG7vNicQiZrICB+Iy1xbn0HbRSLJESaas8iImstJS5ZrAYpAYawmEQUnLGtWjJDT3dEdYE/SWtmlxVgx963FFOM9bBo45ImYFa/0eVxQX+Ku57eyLy2wqZIwFNaSdYdBTLGSBc3u3EoskEJaaP8ARMwYGmlmLlv8K3ru2xyONR9jXj5hKFVNZiXkd4guoScF4kOH7IzQzzYBfp5W1l2bkpaO3cP3wdc/scKaPgo1BLfNQ8kaB1JGj8CWI4HJQWy/IWTuQAQZziqklgLGaoio+szGu4MXFj9Cza4UsPY/oNLoc3n2U1ZvHlm4O1lqUr8iSFRuB5x0ppPca0nvPogxS7sXY5jbQ7f8ZM/iHRZYCIHnqTPqC5GCGKAjC6xXFV/rI8YzsMY2Zh+AySf1fhciKaxkhJKgxgRqTSzYF4twdNc6L2zvjbAi6jHnRUhPatg64tz/MzrBBK/OZ0OVz6p5a2mdQJoyqPg1CqjLhpZUpEiv5ZLL5PFt+5uTJIHmgV2d/UqckUlrCO+8NdU4XuK29mrfVjyCFQVgXDZrNnInjqBcxqmJmlqJL57IkPdvyk8uaOuQbnXXM6wKvrE7SN4rECkoIQpktuZXLpfU5BMLwnqF9rPF6/MHUNaTWHYPIKrQV9IyHxqUcX1s7QWRd6xeAyEJdxlxXmmVB+7y0MEzJToC1DCvXt65nPKTQlETGw8lGRsLhU4Zf94cplv9vrqsc49run0PyMI/GRT46Y6h5EIp8vMLHkzBeXM2vrf0VmmmLul87hYRY23fkR9SfRtuQs4n8AvAvRpbeeYHrcBgOhllTGOdENEnVqyKEIDMZ2mquHVyJKv0gYsWUcgXPCaSSIMQpb1JCCEbWDTN5YPoUArWCFxAKKACjwKQr6DE9CxKyAxpvrXQRJZdnQY1JbBcKN3ioMUn1V0Oib6R42yTeuIQYyL30bN+Jw2VBcJ62YxeEvvX4wNwOtoYthlXEgg45FFdcm46zpBNPhSVFcSwrM6hirizOcUN5hgNJlS+01p/yzdNbxbiWJIuNVZ4+vtUbp4TGEx6pfap1WPYnNZ6I61wSNvCkYS4L6VnnWF2WKW+sHWV/XOOhaIjIKCTkrVLc2F2PN5n/pbFnmfiu8Rjx+tzfH2Fr0ELl2qR9cZUjaZXFQsnFGTGAj6EsU2oy5VBaI7U+Bs1MVkBg0cilqrzMCu7qDiOkZFPQZkA5IXRkPbaHLb7b3Q7mONAEJEokrPO7JFaRIZhI6xzMLqHgS4w1tNMWq4qrWV9yx0p466D8j7Dp77AljCiqIN/LBEQdYz2irM3G0kaKqngqSTI9bO+vIL7DhUrVWqi8D/FUAmr/YkeMbD83i+SkRil8yVMc1zMhhOAn1/8EHz3yMWbimaXz7vWrX8vmyqanvb4VfB/gR+jRtUKWnkeUqkV23bKT3XfuYWjVAADWWEqVIhsvXc/E/kl0mv0onW8vHhYV4LmrNynY46A2CryNEtOwCOn0S6zlpBhcOrG3UBb/YoWsCkRRUH5HsKRHWjqA1mmdnmkk6WxwRo519lE/ZbnIrQUWH/Eemiz3CVqesoqsYiorkFnJPf0RuuZUz6V82EuRK4AsJx7PHJIeZ2/OuhwhGdcWZ/GEZVDFFJTGWBhRMX3jsyVwfe/WBR02Bh1uqkzzwbltzGrXI8/DOg3WsvGejSgB9KzHsbTCgIxZ0CFbwzZH0jJfaK1fMu1cTMGRz8drqxPcVJ6iJDUZkssLczwQDTqNlQBhXV87A0tmmQrLnqjOjaVpNoVdfGFo6ZBZu45PNYd4ffk+xrw5oITIRdshlo0hrNVrOdCbRAjBxbWLefOaN57Sx014W7DVf0mx+794ba3LVxohQlTp2jKN/l4C6fO1qW/Q011eOfaKpd/azn+F5B6Qwy70aeawzd/HFt4I+jCo1YjCG88o/ReiiK38M+j8CZg2S28PxbddkEbpbBgI6rxv669yIjpBX0eMF1ZT8lacuVfw/Y8VsvQ842d/75386W/8JZMHpwEXZbr+TVfxnn/7k3zsjz/LJ//z5+m3oxXvpecbOYcQJVBrJaZpKL4poPQ63+mb5o17acai5y1qWGK1df5MqSNMes6ixk62JkHkGldOLjqdY4hc9CwFeWuMRTLybHdneRzE7ZzE5AaSJ7OJCte2ZOYMkfSpMCx2HhNn7sTzhJ3FJq+qnqCZ+0ctZCFlmaGwrMsr044kZfrWo2cU0sJLK5N8urk5pzQnXc4vBG3j0zeK+3rDPBwN0tAB2spTjsfiVXhTaZpry7PM6ZBprfCF5u0Dh5mcDZjMitRFQklpGpm/ZPqprWDQS4is5O7eKBuDDgrLPb1x5rMF7tE+B/obuLJQ5i2DDeQSp40JZJn3rLuSSF2GRJ5R1dZIGkxEJyirVawb+HNurM8xNjzLF07czkxnH2PhKEPBIBa4Y+bbFFSRm0degtWTkNwHchSWUm8hZHug9yFQ6yB9DBvfjq38DjI8Vd8kw2ux/v+C5D6sjRH+ZQhv49M4ymdCCMGa4ppntY4VfH9gxZRyBc8Z6iM1fu+jv8X+Bw7SmG6xZttq1m0fB6A6WGHttnEOPXoUnWlXMbdCmp4/CBA1gawBQlK4RWG7FtO19L6WgBRUfjzE9ixGGcSAM6jEgkkt/uZzk5yzEaWSSPGFoW88lLXOOdtKPMxzQpiWQy0RHRdlUsIty85qeHl2PNO02zOFd0roSXA8K1KSmqHceuD2zjiHkwoNE5BaRZA3zF3EuSrszocMydGkTMXT9IyiY07eAoukhNLQMKETwWt/yZgztQpsyltrh/l4Yytt49MywTKiJlgwIaExVGVKz7p+cd/qjLM/KSJJqagyoSxzfz9jU9jnilIX0C7FJWpg7VL6rJv1+IfZf2B36zHmkwX6ukdJlkDAaDjCz218N1url2FOfJP1xfWnkKuyV+Y7s3dy88hLwMy7aNJyjZKecuk04bm+QFRdS5HuX2CDqxGnhUaFHILCa3+k9CkrWMHpWCFLLwCklFx0zZmOuYWyu8GVqgXa890VovR8wzotkZ63VH4hhExgDUT/kBHdrp3fXhtKb/cBQfpoRnRrSvUfh/hbniK3dpYnSYBhSMY0hfP8Mc7CKXexfq4q0HKjyyX9jCMEwrqI1umu3M8nnq6p5YGkijPLtHlETBAZmDYF/r65kYYJ6GtF37qWH0MqPoUsnX0EPOUoFmyBhbN4KxaEoW18BJaHoiE2hl1U/uockLHa7zHi9bm3P8qD/aGzbEUwmZWYxiCx/M3CtiWyZTDMpfM0UhhVHvf3R7miDMgBEBUgw3iX8NDCA9w1dzdPtPcihaKoCkxHM2irmWcBX/rMJwv87ZGP8b5t/5hW2sIXPrGJCUSAEAJf+DTShtNCqrVuPmzmyBGAdbopR5RAG01kLJgJ9s/dSuCvY3t1G4Fccc1ewVPgR+iRtUKWXkRc/ZrL+eJffJ3R9SP0OxFJ/3wPghU8aygIb/LwL1OE1yps0xI/op1/UtFpX7Njhs6HXEsam1psB4ieetXWnvryDtC1PgWrqcmUkkiZ0cXcyOm5v8PoPI22mJZKWXS3fuHI0tPbK8GCLnBrew2vrk6cQnM+trCJE1mJ1apPkwAPA0LQNMGSsPu5GsVyLNhFo09LbBXagsoHVpQuWmcQ/MzgAabTAseyMic1YsvazZylPcsiNDCrA9aaFOQAxmbE6XEmxMu4/eDfciSaINUZfd0HBJ2sTWazPG4okEKS6oSHmo/wYONhGmmTbtZBCUUgA8aL46QmY31pvSsgEXVs4R3Q/4TLQQvfESckyBHm43lmkzkyk1AQER+a+wxlf4yqX+UXNv08qwurzrEnK/iRx4rP0gpeKIytH+E9f/CT/M2/+xRj60eYeHIKow1CCgqlED/0ac93VqrlniOIIpR/xkeWJXgg6mDbbm7VkEBnFkIgtAjtTCbDq5UzL15WEHShUBjmdIHVsk/PKnTefDWvi3xud46TabSTYu3v58SJm/fv9sZ4MqmyI2wCsDeuM5m5iW4JV/LnSvotiZUs6Bci2uGsC3w0xkoCoSlJJz7PrPNQKssMmVfELf/d8n071/xnCPZEA/zFtKKbTjGvq1j20tYHCWQVqapIFJ5UdLIuFosSCmMNFosnfWIT8dHDf0vNqxHpCGsNvazPvvZ+hoJB3rn2rSdHVfpZrFoH0Rdcd+nCGyG9j17WZSaZBSwl2WdPNEbfKGzeGuUTRz/Fb2x739OwGVjBCn54sUKWXmRc9/qr2HXzTp586DD77nuSv/zdjxIUfJSnMNrgBYo0fso68RVcAOSowMxY57FngZJADgsn3RiQVN/n0/tshp4yCAXF13qU3xWQTRrMvEGtPX9U4/ToUoLCw9DKPKJcoaMRZM/jZede9p7rh9vzEw1bxFRWZCrLvReWYJnWRRb3xtqTRPCFeHXQKP5s7hJqKqUqU15WnuDmSoyH5vNNp1laHOczcZc1VvNgNyKzVUrSUhSayEqEbWG1QtuEMprQi+kbQd+4lL1AOGNHXPuQgWKdgipwrHeMxPSxWIwxfOrYZ7HArvqlCCGwwnfpNzMPNgH/Wnrdb1MWMcZm7I2HuLW7DU8oIhMRyID5ZI7ZZI7RcOQ5nNkV/DBhReC9ghcUxUqRXTfvZNfNO9l73wG+94X7yJKMsBQwvHacY3smyDL9IxXyfE4hQK4H4buy/+jbGTa2+JcogksVhAJvsyC80sO/SAECWXIVcAiQdUl8Z0pp7VNHNRaDgEI4c0WDZVPYoaUDTqTFZ0CUTnerfr5xvjYiT7X903/7dMd7Nh3XqR5QodAURXbeRsJPH2fXj2Uo5rUiMZLbumvZEHRIrcfRpEyAIRCWKI8WPp31CgRFqekaQSAgtpKCcLHA2EoGxCw1ZZDCUkBTV9AUGU1dQluNFJKiKuIrR9iM1WirKakSmc2oBTWEEPz1wQ9yeX0XWwuKq+SnKHllUKNgI0gf4Kvdm+jqhImkx2xqUcJDCPcANIvW9Ss3nRWsAFghS993+M0/+xVqw1V2f2cPynORjJf++Ev47t/fjdGWLM2jTALI+82t4BwIXKpN1gAj8LYLFn6/jzXOUwkpCK6UFN4kEalrpitEbiap3Qu48CDdr/F3XLh50vK0RYbioWiYAL2sB9wzxQtNnM63/RcDlsQqRlT/PGTp5AP+7I/6sy09335ZRryIyCru649RkanTggmJtsvtFs41lrNDCs+pylzYzJlgSktiBG+oHqMoLbd1VtM0AQLYEbYIZYt7ou1UvDLDwTDtrI21lk7WOWVzFstE/wSZzdjX2c/B1hR3qyq/vDqkCiAKIOGi4AhfbG9GyjLGTqKExViLxPWVq3hVpvrTzMZzbClvPsPOYAU/2hCsRJZW8CKiWC7wvv/8i8xOzNOabbN68xjFSoG//tcf5Tv/X3v/HR/Xfd754u/n1KnAoIMg2IuoLopUl9Wrm1wkW3HiuDuKYydOuUl2szd39/527/Xm3s1N1onjdWJbtuPe7Vi2umRHvXeJYgdI9DLA1NO+vz/OYAiQIAmSIMHyffM1xMyZU77fOTNznnnK5/nREximMNqfp1qqgoBf0SG6/WF2xJ4kccFcLlTuj5UmRUCygKso/TTCaAJ7g0nalDjR21NxDmyowBAkAdbaA4fgDpzXIfNgKM0HB/MUHO/hu9g0GQoSM5bt77hqn2WzoWZU482GJYowEsZDhy6rRKgMjFiUa84aTwBm7T1gGRaxcqmPQtVGAC1GhTHlsNwtMBm5vKOxn6oyUXg0GLFo+yMlD9vI8fGVH+EXfb/ijck38CKfiJAggpzdyEh1FEGwxCRpJkmJx4hv8r2hkPUZg9UJocFKcF5yiBeDRfSU+3BNl1JQBoEmK0c1qlL1qvxg148BsMXi/UtuY3V236pejeZUQBtLxymtXc20du1pYPmR//pbXHDTer78H75JYaxE1+pOhnYOM1bJL+Aoj1/MpYKREVLvtTEXGeQ/V4mNJCcOlUWjxKVJtdZl1UdCwl0R1hIjDr/VohBKKdxzj7ePyZEYIMcytDKbB2eux559XQVU5vS1dWDjdc/eOKChBLGYZbXm0Xq82EYxsqgody9Dafp4Z+6rxW6mxW0haSbZVtyOF3lUIsEUm1IUAMJkaDJJkowR4ZpJIsMlUgZRWEKIm9Ba4rCu4TTGqmO8ObmF93W/l1cmXuWxkcd5deI1mp0W0maK8VIeUVIP1+U9h+HAY6Qg9FQjTIF3Nvmcm23lQ8s/zGuTb7B5cjMhIY1WI2k7zb3995G20thGHOqrhlW+0/N9/vS0P9JNbzV70J4lzfGGYRisu2gNYRCy6rzlbHtpJ9WShxii9Zn2wuiEpv8ridVuoAKY/FKVqeuhmmpjUhObRECNxj/0839foeEzLvYKsy6BLQsaetp/DlCcDXUoooz7u7DPdpz5YLb35L5l9nPbbvqz8znWuVUMDgUJsobPDi/LeOTQapTZFWbqyeZ7zsPMfVliEaiAUlAia2dxTZfu1GJ6ij2xR0kSmFLBUArTsLDEZSL0eLPawVp3gElVS+oWIWl4vOCtY6g6zHBliC9v+ypJM0HOyXFu4zmszqzi0ZHHKIQFQhViYdGVXEyoQgaCuJ+ea0TkLMFXET8bgxXN7yNnOpybO5tzc2fXx/3Y8OMAdUMJwDVdKn6eLYWtnNV45pG86BrNCcn8ygjPERFpFpF7ReTN2t+m/az3FREZFJGXj/UYj0uUIooUXtWnmC/hVTxtKM2Ce1HchHXq2hWOR7Hu394pPxFxE1wfVBWisYjJL1SP0qgO9SK/7/oWsdDk1PNxV7LZvDez3Wbb/9GSFzh8Y+j4Q3CARlN402skJSEYBrYokkaEgbFfgzpQcYi8rCoMVAbYWexBKUWT08zbF72NZqeJM7JnckbuHFZmTsM0HCIifjDWwI6qgUOBrOHRbCp2hYv5TSHHqDdKqCIC5VMOK/SV+3lq7GmeG3+Bj6/4GO/tfg8XNG2g1W0haSYoBkUUgpIEzXYCUNhGgsjoYqvfst9xz1pzqCCs/9rQaKj1cDrM2wnGghhLwF8C9yul1gD31x7Pxp3ATcdqUMc7TsLhjEvWMtY/RrXsoQDDWqhTeJxiTAkVK4KeiPL9HkSgxuOKOCJQpfgv8WrxzYh7hVrLD94Adm/mrkMzl/X2Z8AoHAmxJcIloM2sYBPVasWiA2x3InDo45ZjZHRZmLQ6WZJi4iuTnqCBsTCDpwxKkVVzUB58LKEKKYdlRqqj3LzoBlZlVhJEIbsru+kp9bK9uINqWEEQSpHDV0ZO5xujq3m0spGfFC7hgfJFjPgFiGI1cMdwY8+PgB8FFIMimwpvcm7ubD60/IOc3ng6E/4E5bBMpCJa3XYy7jrEWY/YZ8QClfthdWY1BsYMwyiIAkSEFenl8/Cqak4KVJzgfbi3E42FCsPdAlxVu/814CHgL/ZeSSn1axFZfsxGdRyhlOK5B17mnjsfZLR/nNXnr+Adv3cD7//zd/HCg6+gVNxHzhDBcixQisA/hX/1GTVDxwRnvYW/O6LwFS9O0g6FcEwhJZDFYIoQFSGaVIgJqljbhw/uW6xDunYfumDfgTR5DryvoFamnjJCVjt5nii3x94mgcoJ+OWzh0Mf/LFq+BsSgdlEhWZydoGEmWKgMkDEoRVWRChyVgMrMsu4pOVivrPze4z6oxgqbn/sKQ+I/YWu4eIYDrsCm5GSy+nZdeRLPYQqxDEdnMjBrPVvMzDwIo9Gu4GdpZ1AHDL7wNL3M+aNsau8m+/1/JCslam/V/3IxxCDVZmVs451UbKTy9su5d+HH42/ZwBDhJs7b6TBbjjMV1KjObFZKGOpQynVB6CU6hOR9gUax3HLr3/4GN/53E9IphM4SYcXH36V1x7bxF98/TNc9p6LGPtfeUoTZUzTwLRj4UojUqgompOHUwzBMIQwODlarNinGRi5uO+b0SoYttD0X5KEuyNK9/goIuyVJpnfcTEysRhlsCti8l+qhDsV0gSpdzi4Zx2rj8ShX+g9BIuIRVaBN6o5pnrC+Qr2p+lz8nL05yoIzXYT13dcy9LUErzQ439s+jsCAqZEAw5lX5NhAUNMdpV38UL+RaIowsPbZ12r9rVsiIFS0Ow2cfvS2/i7TZ/HEYedlTicF2t5RSTNBL7yaXPbZuynyWmiyWmiFJS4q/9XRLXPuikGb+96O412437He237NZzecDpvTG7CxOT0hnW0J9r2u75Gc7Jz1K4MInIf0DnLU391lI73SeCTAEuXLj0ahzhm+J7Pz/7xbhqasziJOMmyqb2R0YFxvvlff8Cbz26jUqhiWgaGYZDNpUk3pujZtBsw8cqzdAmdQsBxbQI/REwjlhQ6wQ0maQTJCFFVkbzGwl5pEmyPiAYVRpOQ+S2Hwo8h+14XbJCsIK5grzJp/r/3H4446HGPaRuIuOGsIGz1Gmg3K5Qkbs5bPS5kCaZzpBV3s4tTHmtMMTm/aT2bC5v59dBvSJpJIhUdlqE01a6kw23n2bHnGawM1nS4Z6JQVFWVhEqgUKStNHk/T87JcU3H1dw38ABJI0kpLIGKPUuu6WKKyQXNG2c9/oUtF7A6u5othS0ArMmsJufkDjxmERYnu1ic7JrzPPdHMSjywviL9FX66Ews4tzc2WSszBHvV7PwHLCv9UnGUTOWlFLX7e85ERkQkUU1r9IiYHAejvcl4EsAGzduPKGDEvmhCbyKTyo7s0TXsi0e+fGTrDhnKdmmNKXJMkopihNlMk0ZLn/3RTz606dxU8Y+yd9WwsJNOpTyZbxKbExFYYTlWlimQXCitlRJgLhCNBZBSki9y4lTeHwwEkAQG0eZ9zogcdWbkZWZ1969r81zcNIsRL+sqQwlMDEMRVIFjKnpquIni3fp2BtKDjYefu1osTHU6rTwZmEztmGTNJNsL+4gOMTwG1BPAs/aGZakurmn/15Conpi+N7GV6ACPOWRNlPYYrEmswaAt7ReRtbK8u9Dj7CjtJNA+aStNO1uO29bdPMB25I0O00078eYOpqMeqN8eeudFMMCBhYvjr/CI8OP8rEVH6HFbT74DjTHNyf0lfbQWKgw3M+ADwGfq/396QKN47gk05TBMITAD7HsPV6D0b4xTMcilU2x4uyljPSNkR+eJKj6vPUT1/L237uB7/z3n3DXP9+Hm3QY7R8j8AIsx2b5md28+timmvt+TzFCUA1wkw7Y5omX85QCswPIgNlqkLzewsgI0YSK9ZOiONlbeQojJ0SjCrPT2F/+9J7lx629sSeteaefXdCRHJzDURs/VHXt+UOJwolb5+Lg0JpoYWV6Bbsqu0lbaforA1TDQ6+UTJtpFiU6McUiUD6rMisphqUZFXR7e6kMhAargaSZJOfkuKB5AxAb6OubzmV907lAnHQdqADXcGfkI414o6TMFA32gd8joQp5c3Iz20s7aLCynNV41kG3OVTu6b+fYlik0c7Vl+X9PHf338sHlr1/Xo+lOfYct1+VR4GFMpY+B3xPRD4G7ARuAxCRLuBflFJvrT3+NnEieKuI9AL/h1Lqywsz5GNHIuVy9e2XcfedD9HYmsVyLMqTFQIvINcWJ1ialkn7klbal7QyPphn2RlLEBFu/4t3sWRtFz/5h18yuHOYXHsjHcvaGR/MoxSYpkEUzSzdDKMIy7EIghAn4eAkbMqFCuHxbjyVINwNGAoKEYVv+dirLCQJ1hKDcFeE8sFICsH2CHuNiaRqH++IuBZ06mWYegwn8DfA8TrwuYTlFtZSDVRYC5cZ2KbNp1d/iq9u/xoJI0GoQib8PKZh4kcHCHHPQjEsMhlMkrUzvKf7XeTsHDk7x7iXpxgWZ6xrYNBoN6KIWJlZwekN67igeQNpKz3rvi3Dquc3ATw39jy/7LsbX/kopTitYS3vWvzOWUUkvcjnmzu+xfbijtjQUooHBh/ig8t+m2Xp+UtjeGPyDbLWTAMsa2XZVNhUz7vSaGZDRL4CvB0YVEqdNcvzAvw98FagBHxYKfXs0RrPghhLSqkR4NpZlu8mnvjU4986luM6nnjH79+I5Vjc/83fMDlaoG1JK+977y3c+7WHZ3zJBH6IApad0Q3Evz4vf89FtC1p4R/+8Ct14yqM4uCyUuyjzRSGIVEQYdsWDS1ZypPlE+dLzAazRTCysWJ3+V6f1LscJA326SZRRcW5Hc0GRuO0Oe1tGB2CoXTCvDbHFftvN7LQRp4gpMwUkYpQKBrsBgIV0O620Vfpr4kzxu1DDiVfySCudIuiiD9d+8ekrDg/7oq2yxnxRgmjkKqqEtW0wE0xSVtpbl50I5e3XjqnY0QqYmeph+3FHdw/+AAZK0vSSKKU4vWJN/gJP+O3lu7rwXl+7Hm2FbeTs3P193MpKPPD3h/z2bWfwZD5kSRxDbfe/HeKUIU4hqM/RycDR1cv6U7gH4Cv7+f5m4E1tdtFwD/V/h4VtIL3cYppmbz9927g5o9di1fxSKQThEHIjld6eePpzbhJhyiICIKQd9xxA42tM0t6l525BMsy8coeTtKhuSNH7xu7Y0Nprx/6gmDZJpZjsXh1Jwi8+exWAi/OzxAR1PEsIhYBZtz41nsuAKXIfCBO5jZSU/lJB0tCOvhhjo8v972lB46HMR0JCzt+o2YlKxS2YeMrn3JYIiJiY/NGvr3zOySMBKIgkggTk5BwTgaT1P5VokrdUAK4sPkCfBXwwMCDjHnjlMMSjuHSnVzMDZ3XsSy1DC/ycaYpaM/GcHWYb+z4Fnl/gtHqKJWoDAlodpoRERrsBt6Y3MSkP0l2r/DaS/mXcY3EjPd0ykoy4U8w4o0eMP/pULigeSMPD/26bpRNNf69ou0t87J/zQIypVF3tHZ/cOmgW4Cvq/ji9LiI5KZyoY/GeLSxdJxjWibJTOxGt2yLP/ifH+GpXz3Ps/e9SCKd4LJ3Xci6C1fvs10i5fI7f30rX/3fv0MhX0REcJMulWJlhvFjWgZuyq3t3ySRjvMfMo1pSvkyUMupOJYtxQ6FEMIhhaqA2RnnKHkvRkz6VdK3OZgt8/ML+fgwlKZzvI3nxCSqqZNWwwq+mCiliAyXp0ee4ZnxZ4miiAF/ECUKpRSNVgP5YCL2GHHgUqCQOLTX4s5UyhYRLm+9lIuaLuAXfXfx3PgLKBUxWB3ii1v+mWa3mZSZ5NKWS7iq/YpZvTxKKb6983tM+pM02g2MeWNEStFb2sW4N06r20rWysYil2FpH2PJMmzUXuOPNZUUlsxfdeWVbW9hxBvl1YlXY6FLIs5sOIMrtbGkidNrnp72+Eu1Qq25shjomfa4t7ZMG0sasB2bS995AZe+84KDrrvh+nPpXtvF03c/T2mixJvPbWPL89spjBcpT1YIwwjbMQmDiNbFzZiWSaVYJZF2STUkY6MKtY+RJEac4zDlbDqmnqcpo216iouAKiqUAcFWReajDslrbfytEWIL4oLYwnFXYa85bgiJCGuyAOWwwi/7746FHwWSRpKkmeTMxtMZ88Z5efxlFIpAhYQEB/0NcWnL7JGBneUenht/gQa7gUJQoFAtAJD3xsmlGnho6GEsw+KKtsv32ba/MsCIN0qDlSVUIZWwQqCC+vj7yn2UnBI5O0eLs29bk41N57OlsIWkStaNscmgQFeiiyZn1u5TB2XUG+XR4cfZWeqhzW3lstZL6Ep28b4l72WkejUj3ggtTvM+xqPmlGVYKXUkJZr7K9U5Kmhj6SSnY1kbb/vk9QA89N1H6N3UR9eqWP6qWvaYHCvilav8Pw/8Z7Y8v42ff+EehnaN0LU6Xic/NEExX0JFijAM6x4qBLyqT+Dt1UdKIJF28Ss+GELozUOSuFG7WUBA3AQXIEtc2efHIbiwJzbsSr/wSV3v4J5rIqagqoqooGLJAN0dRnMAUkaKchR7VF3DwYt8xsMx8v445aDEeblz8ZRPyOzvaxMzbpKLwhSTnN1Ib3n2H7ov5V/GEANDDEa9MQwxMMUkUD6+CshYGf59+FEub710H+9SMSjGvxNEmPQmQcU5T6GaChEKo9Ux3t11C5ax79f8GQ2nc0nLRTw+8hQiccgwZ+e4dcl7Dut1G6oO889bv4wXeSSMBEPVIV6deI3fXvpbrM6uosVt1lIBJyEL3LakF1gy7XE3sPtoHUwbS6cQF771fB767qMM7Bwm3ZCMq92U4t1/9DaaO3I037ieC25cX08g3/bSDv7Xn32dwniR0mSZ4V2jrDh7GemGOCxYnCiz6ektZJszNHXkmBiZYKRvjNAPWbNhJShh60s7SGRcJoYnD93mN0HaAQ/EEiStCPuBCuCA1SGxRECgCHeBfbqBvy0i2qUo/qhK6h1xojcesZEUN/LSHibNrJgYOIZDKSoBUArLREQ140MxGozxwPBDB9yHAEtTS3FMB9dwKQdlnht/jr95bYTFqS6ubLuC7tTi2rp7fhj7kV/Pn5rCEotiUCRQIU7NWOov9/NvfXexs9hDf3WAwcoQvvIIibCIG0i7pkvKSGKKud/2JCLCzYtu4qKWi9hd3k3KTLE8veywE7sfGny41nYlVgV3TZdyWOau/l/xmcynjsMwtmZeWFhj6WfAp0XkO8SJ3fmjla8E2lg6pUhlk/zZVz7Fg995hOcfeIl0Ls1V77+M9dfMrMqc+mJbcfYy/tsv/iPbXt7Jq49u4ldffYCG5j3Ku+MD41i2SSqbYHJ0kvJEBSfhoKKI4kSZ5Wd007K4KdaHMkzGBsYPPkghNmbC+KYmIHGNhXuBSTSkqD4e4L0WYeRq6ynAF5z1BonLLPytVdwrLBKX2mAKRkJQLhDEuVdxCBGd8qPZh5AIX8XSAAo1zVA6MAIYNa9OUEv+TppJCn6BnnJvbIAIbClsZXNhCx9c9ttM+BOMeqPkvQkSRoKUlaTox/pLBiZJM0ElqtDqtmLHnaGZ8Cf5yvavE0QBWSvLQGWQYrRHfiAkJG2maLVbGfKG8JXPt3Z+l41N5/PWrptnTRhvdppoPsyw23S2FreRNmdKHCSMBCPVESpRZVb5As2JzdHuzjibdBBgAyilvgjcRVw9v5lYOuAjR3E42lg61cjk0rzjjht4xx03zGl90zJZfd4K2pe0cu/XH8L3AmwnftuEYdyHbnwwj4iBnbCwlEWlVGXl2cv4q29/lp2v9fL/fuyfYiNlLkzlJCnAgOS1Fun3OSgPZDUkLrepvhBQuTcgHI4wXMG5xCTzPgdJCsHmkNQtLtFERPRmSJgUzOUGRkoQS/YcQ6OZhUJYqN+fe0uTOGdvqlJuyjszWB0CoM1twzZsBGHcz/MPm/+JrJWpSwtsKW6Nc48IQUFXYhGFoEhExE2dN9R/vDw//jzVsErOaWS0OoqIkJIU1agKKEzDxAt9+qv9KKXI2hmanBzPjj8PwLu63zlfL9M+NFoNjHhjM0J+UxIBjuEcYEvNCc3RrYY7oHRQrQruD47eCGaiMzg0c6KhJcutf/oOCmMFRvvHGO0fx7ItLDsWubQcCxCiMMJNOvRt7WfX5n6WnbGEP/nnO1izYcXcDhRRz0mSDJhtBtGAQo0pon6FKkbY3SaJG02a/zZF8/9MkfltByVgNAoNn0kgScVUVwrl1X4BCaiSQpX3TVg/GDqEoJkeMpO9rG1V69knCI1WI4YYTPgTVKJKXJGmoLfUy5bCVvrKfYx4I4x747imy7L0UlqdVlzD5dbu93Bpy0V4UZyzdH5u/YzebH3l/th7FQWUwlKc42SYOKZNV7IrFtAkJFQhjU4DXckuDDFotBt4If8ipaB01F6fy1svoxpV6qKdoQqZDCa5qOXCOFFeoznB0Z4lzZy58rZLWXXucp6+5wV2vt7L7s0DjA/m8aseIBiGIIaw7LRufD/gxYdfYdebffS8voutz+/AsIx65/NZmQq/TRGCtdqYETZTFcFabmC02IgB4UAUtzHprvXZSgjWEhNrEYQjCqZ6wQHYwtT39t4XvDpCvbJPG0mnHlPvCxsbD6923yKoyQBMeZsSJKhQqW9jYNDqtvDHa/+QJreJNyc28w+bv8C4N8Yww/scZzzIU5wskrCSBCogVCEPDj5MqAKSZhLbsHlm7Fk2F7bw8RUf4cWJl3lm7FnG/HGGveHYK6UiDAwUkLWz5Owcm4ub6Ux0zshVmvJ0lcOZek/zyZmNZ3BzcCMPDD5EJYxfl4tbLuLq9iuPyvE0xwnHo5zMUUIbS5pDonttF7/+4WN1JfEwjAj8EMMMWLR6EU2dOaIoYvurPfzsH+9mcqzA8K4RENnXUNpbu2mvAiNlg9EgUGaPweSApIRwc4j3Ykg4ooj6IsIxRfJqi/TvOIgZJ36b7YLy9hxHrGnHPYC2ozaSTl2mjCHLsJBI8KjGXktlxBVumDiGjRd5uIZLg91ApEJsw+G27vfSkewgVCG/GrgbQQgPoMXkE+AHk6SNONdn0p/EUx4NdkO9xcm4N84Pd/2EbcXtNDvNlMMyXuQTKJ9QRURGRJOdwxSTCX+C7mQ3XuTNOM7UWBv3k+w9H4gIl7RezIbmDUz4edJWWucpneyomW2zTna0saQ5JEb6xvju536K5VhYtoVSiuJ4Eb8SUKl4jA9N0PPGLsSIG68VxotESkG4t1hT/ItXSYTaz/VEPJBEHEojIjaAmoSoEjfGTVxpI3EnCipP+JT/LcBcapC82q4fQ1z20WWaYQxpu0gzC5WogkKRkAQ3dt5ANYrbkvjKpxAU2FHsocNtxzBir40f+fyy/27ObDyDgcogeX8ibsorDlV14Aa81ahCo5OjFJQwxWDMG68bSykrxQvjL9LmtuKaLktTSxmujjAZTCIqpNVpwTZsJoNCLPbYfgVf3/4N8t44CTOJF/mEKuDd3bNLCMw3jmHTOk/q35oTgFPHVtLGkubQePzfniGKIhw7TtoUEdKNaYr5EsM9I1iOhYoUtmvS+2YfgR/O/oFSICaoSBBDzWowqRKUfxKQepeNNAhmq6B8avUQgiqo+B1sQvISm6AnovLLgNQ1eyWUaoPohKfByFKIinFbkmkhsv0hCDmrkXwwUdc9OhSm1LkTZpLn8y9yduNZvKf7Fgwx+OmunzNcHakbSgC2YVMOy/SWejHEjENkNd0kP/QPovYtdCTa2V7cDgih2uNiDaJY72LK0LEMi85kBx2qnYlggj9Z+0cEKsA1EqRrIbbfW/UJHh15nC2FreTsHJe2XsyK9PJZjxyqEANDe1M1h8UC6ywdU7SxpDkk3KRd877uaeYrhmCYguVarNu4mjee3oJlx28tr+zVFb4lVr+rN/KNlMJ2LEzbpDxZmfV45X/3SdxsYVbBfy0CAfuMOPHIWmnEytyhIioq3PMsSj86tK7wmhODkirj1CrKWpwWxv1xCmFxv+u3Oi0kzSRjwTgGxpw8PNNzkgwMLLFI2yka7QZeyr/EmY2nc3rDOlzTjb2ls2AbNouSi0iYCZSKUIaBLRZVNbtxJwi2YWOLTdZqYMwbpdmOxRtDFVKNKpzZcCa9ld4ZVWWVqELOzsUJ5HsZOg12Azd1Hrja9Y2JTdwzcB9D1SGyVpar2q5gY/MGbTRpNPtBV8NpDokLblpPMpvAr3hxH60wojRRwq8GREFEcaJEIpMg8MPYYJK4NYoYUg+BGYaQbc5w/QevpPu0LqJo5q9u27HiRGyB5E02Zs6I+7+VAAUqBGtJrF2j/LhvnZEzMFsFd4OuvDnZMDAQBD8KEAxCFZK1sgfcJmWmmPAn6ttP99bsD1PMujBk0kxiGmbd62KKyUv5VwA4p/FsBAiioL5tMSiSsTJ0p7pxDIf3Ln43WTuLF1aJ9vJqTSWEC4IlJpaYlMISCcMl5zRhGgaT/iTFoMgVbW/h1u53kzEzjHvjlMMyeX8CPwp4R9fbDsu42VrYxrd2fpfJYJKcnSNUET/v+wVPjj51yPvSnOqoI7idWGjPkuaQaGxt4FP/34f5xz/6KuVCBb8ae3Ia2hrwSlV63thNS1cTfsUj8AJM26y3PDFqeUzNXc1km7PkhydIZhKc85Yz6H2zj/5tg6hI4fsBhiGopMJsEVRJxcnfsd2FmIIYoCow1bpOTDCaDFK3aGPpZCMiwhabQAUEBFRDj7Fg7IDb7K701Uv6AwKMvWKx071IUxVwkYrq28TLIWPHIqxxg9lYEuDF/EuYYrKz1EPWyuCaLqaYnNVwJq9NvM6azGpOb1zHf1j359w/+CCvTbzOQGUAwcBXfv04cX5PG6dn1xERsTqzkvNy51IIikwGk7S5rfXcpTtWfYKnxp5hW2EbLW4LFzdfSGey87Bez4eGfo1tWPUEbNd0EImXX9C88bBVvDWnHjoMp9EcgKtvv5zzrj6Lz3/6X3jt8TdZvHYRbtLhjae2EHgBYwN51mxYxciuEfyKT/vyNl59dBNiCKZlMDEyie3aDO4Ypn1pKyJCx9I2xocmYhmCCNqWtjIwNoi/KcLdUDuwAnwgUmAJ4ta8VUbN27TYiCvh5kBccn3ouSyahaEaVREEL/IYjUYPuG4sAm/SlVgUq2SHEzO8O4JgixW/nWqK3VPGkyFGzRMV0Ol24hgOoQqJVMTqzGr+afOXGPFGMMUkY2UIVEiDuJTCMo+MPIoxapAyU3xo+e/QkejgtiXvBaAQFLin/36eG3ueQlAga2c4v+l83tJ62T4901zT3WdZ1s5yTftV0H7VfuetVKw6fjBdo6HKEK7hzljmGA55L081quoqNs3cOYW+PrWxpDksmjpyuCmXxas7SaYTAKw4ayk7XuulPFlmfDBP+9I2fvuv3sOX/vwbrN24ksJYERUpGlqzVIoVyoUqgRdguzZDvSMYIqQySQzTwCt5qHFF9YmA1NtsjDYhGleIVWucW44/pWZTHI47lGCEg7NPgvCUmrLm+MXA2G8D2ymmQlxKFP3VAXJOI4WoSKD2hMwUCqMmAWArm0pUrhvNWSPDysxKXpt8nd2V3eyu9IHEOVD3DzzI1uK2OPSl4hJLU0zG/XFOy6ytJ3wXggI/6PkRn1p9Rz1MlrEybGhaz7g3xq7KblqcFtZmVs9Lc9kgCnho6GGeGHmKauSxIr2cmztv2K/naVFyETtKO8gYe1oXVcMqGTuzjxGl0WhitLGkOWy6VnXQ8/ouktn4l2gi7bLqvOWM7h7jT/7lDlavX8HO13ahFGSbMmSbMjO2T2QS5IcnaOrIUS5UENMg8EM6l7QwYPeT+1QCs9sgykO4VWG0GUSlCP83EambHSIjqisn22LhKX9OnqI4LKONoxONuZwvhYpVrKPYqAqrQVx5iZAyU4QqxI98AgJyViOj/ihpM41InNc0GRZ4ffJ1liSXsLO8k0AF2NikzTQv5V+O92Olata5ohiUMCQO9TnECdhpM82QN8yoN1Y3hnpKvdy5/esYYpAwEmwrbueF8Rdpd9u4rO1Srmx7y2F7dH66++e8MP4iWStL0kzSU+rhK9vv5FOr7iDn5PZZ/6r2K/jqtq9RCAokzSRe5FEJK7y78xYdgtMcIqeOa0l/MjSHzdW3X44YBoXxIkopfC9gfCDP1bdfRuviFt54agt+xScKI6Jo5ofKr/psuOFczrplHX2DA0QEBJ5P+9JWKh1lkr9vYrQK0YhCbIW5wqD4vSqTf+Vx4cDFtCRaSBiJWhVRBsdwccQhTsk98Nt6KtwyZWjB3C7EmoVlbk1tZ/oYq8ojIMAUE1NMHMMhZaYwxGDEG8UWB6kZCCJCRIQX+ZSiYtx7zUyhlKK/0k9ISEAwzUsVHytUBw99PTj4MIJB2kzTV+ln0p/AEINRb5RHhh7lzm3fmJEwPlfGvTwv5V+m0W6MhTRFaonlPs+MPTvrNktTS/jw8t9lcXIxlbBCo93I7Uvex/qm8w75+JpTGEWsf3e4txMM7VnSHDbda7v49Oc/xvf+5if0bR3ETTlc/6ErKYwV+etb/juGaRCFcTLryO5RmjtzGKZBaaIMBvRf2kuhfZJF1+covphg9xeGQYTqJSUkEFSxdnGsCCpSZN7rYvWmeOtHruMHzvfpTHZgismkP8nucl/crDSKP8MHLhNX9UReU0wCFXuack6OvJcnqv3THD4L5bnbn0E1PbwUqADHcOptOQAiFVKJqigUAQET/iSCEKkIT3l4oVfPayqHZVJmEgMzru7cy0AvhkVanVaanab6st5SL5EKGfVGKfpFHDNWU/WVT4PdwEB1gM2FLaxrOO2Q5pv3Y2mEvT1ClmHRXxnY73bL0kv56IoPHdKxNJq90QneGs0cOW3jKv7Td/+ESqmK49o8+N1HuPdrD9O8KIdhGCilGOodoakjx+RogShStHW30P3xdnrattNo5ZAWofUqhd1i0vd/jyOdCsMzENsgCsI4PaQKVofBB/76vay7cDWn71rHy+Ov0Og0UgxKtdYSIY7p4kc+KUlRiuLGodMrn0xMLLHqib0ZK0MxKJAwE3QnF2NIXLZdiWbXfdIcHEGOC2NzupepElZImAkiYrHIrJnBwMALq4gB5bBcTwI3MCiH5fo+FApHnNizpAIEoRJWcAyXlJliZWoF+SBfF6JMGkluXfKeer7Sa/nX6av0U50yxlSAEcUGjkns8YqUYqAyeMjGUrPTjCKqH3uKIApYnOw+0pdQo9HU0MaS5ogRkXqS98Pfe5RMLl1PdhURmjubKE2U+Nw9/zvPP/gyT//qeR784iO0XdJM5uYGrFT8C73z7HbKt3mUi4K5BIyKSVTrPReZIUuXdnPT5dcgIlzXfi07ijsZ9/IEyq+pGDuYYlKsKT0LgoWFEoVSis5EB4WgQDms0Gw30Z5sxxab1yffIFMT9+tKLGLCTLOttP2IXxer9vEKCU+pqrvjYa5TIVZLLFrtFvq92MuSMdM4pkt3cjGr0qv4ed+/UQyKM4w7SyxMMesGsyCxgnZEXXMpjEJa3RbOajyTW7vfQ1+ln13lXaTNNGuza3DN2JM16U/y/d4f0eI0018ZqFdgVqIKjuHQkWhHJB5rsxt7ol6feIOHh37NiDfKkmQ3V7dfRXdq8azzzNpZNjRt4InRp0ibKSzDYtIvkLKSbDjMsFo1rCJi4Bj2YW2v0ZyMaGNJM6+UJytYzsy3lWka+F7APV97iHvufAg35VCpeuz8135GH5vgnP+2FtONjavchRnUPwnV3yqCGyFVA8OJENfkHWv2iPDlnEY+tfr3eDn/Clsmt/DM+PM4YjNYHSIiqldFGRgsSnailOKO1Z8gY2X55o5vMVAdohxUKFNmbWYNeT/2DIQqjCug5gnTMOvJxicyFibBQSrRjhVT53Z6ZZyJOePxlFFiGza+BFhi4Rg2jXYjV7a/hYuaL8QxHJamuvn7Nz9PJarGXkfDwsTAi7xa4YBd31eL20yz00whKFANq3x85UdZllqKiLAk1c2S1B5Pzkh1lEdGHuWFsRcZqg6yKLmIxckuhqpDeJGHQpG1sjRYDUx4eRrtLKdlT+P58Rf4ce9PcQwH13TZVtzBtm138vGVH6Er2TXr63Hzohtpdpp4bOQJymGZsxrP4Jr2q8naBxbu3JuR6gg/330X24rbEYHTs+t426Kb61pTGs0+6Ea6Gs3hce5VZ/L4vz1Nc+eefI2J0UmWnbGY+7/5G5o6GjEtk+ZKE+PJcYrbygw/NkbHVS1M+pNccNoGuj+xlK/e+S0qlxaIOjysCZtb176bCzs3zjhW0kxyQfNGLmjeyHlN5/H5zV+If6Wr2KBKGAkUiqHqEJe0XMyixCJEhDtWfZJNk2+ys9TDktRi1mTXcFffr3hm7DnyXn6fru0HQ9hTEzIV+pnKfVGRIm2mqYQVAg49gfd4wRabqKbjMx9MD43O9ng2TExSRpJSVMY1HEpRHCozqMlHqOntSoSEkaASViiFJVxxcQ2Xvko/9/Tfx+rMKrqSXWwpbsOYUu4WZoRfpyroDMOgw+3AMW1CFXsJr+u8huXpZbOOc6g6zD9v/TJe6NUqzarsLPWwONHFiswK/Minp9SLCEwGk6zNruVti27CEpP7Bh4gaSZxDIdyWK5V73k8MPAQb+96GyPeCI12w4xmtaaYXNp6CZe2XnLY56MSVvjKtq9RCks02g0oFK9OvM6wN8Lvr/qkrpLTzIrOWdJoDpO3/971vPb4Jkb7xrAci8APSaRdLrx5A72bfoFpxVVDrU4r5bBC0SjS//wQicss2hJtXNdxDZnFGc645DS2vrAdwzJZvX4FjnvgkMBp2bU02U2kzCQREXlvgkJYQBASZoL3L70NiFs93DdwPy/kX8IPPRBYnFzMp1f/Ple3Xcn/t+l/Ug5LRCrabz+vvTGx6nIEe+frpIwknYnOOKx3gn2xCJAwklSjKhVVndfw2lSYLCKqv24H01BKWkmWpJYwVBliUaKDbcUdeJGPp+LWO9PHFyf5e/Vz4SuffDCBgTBQHeTzb/4TH13xIR4YfBA/ihvdqr1+JVtiUY0qJCVJJSpTrRlSF7dcxFVtV+53nA8N/hov8mh0GqmGVUa9MUQJg9Uh0lYaQwxa3GY+teoOmp2mepPcUlCiEBTIWBl6Sj1UokpccBRF/Hro39lUeBNTTJRSrMmu5tbu99TDfUfKaxOvUwwKNNakBgQh5zQyVB1me3EHKzMr5uU4mpONE+xL7QjQxpJmXmnqyPFX3/4sT971HNte3knX6k4ufvsG8sOTcWVcraGuZZgsTy2lzxrg3NWnc+PSq1mdWVUvwU5lk5x1+elzPq6I0Oq2UA7LpM10vU1EOSyTs3OAcOf2b/Ba/jUGvSEUChMTV1x6Sr38zev/g0taL6av0o8X+YjEnoyI6KBGwlR+1Gxel3JUYWepZ069yQ6Ho6lEbouDQpG2UhSDUv14BzNq5oqBgWM4NNm5WDlbTMb9MaphlUipfTxxXlDltYnXEQTXSNQbMy9NLmWgMlA3ehxxMESoRl7NEIOQCBMTQwwiFRGpkB/v+gmT/iSO4WAoYx+vUtJM4EcBhhhc03Y1KSvJE6NP8szYs/SUerm2I37PjnljvDrxOl7ksSqzkm3FbaTMFH7kUQpKuIZLKSzhBR5j3himYXJN+9W0J9pmzM81Y+/XYGWQUliuyR0YVFUFn4BKWK2HlN+YfJN7B+7n7V1vnZdzMeqN7+cdpOo99jSa6YgCWfg6jmOGNpY08066Mc3Vv3U5V09b1tjawJJ1XfS8sZumtkbEEMqTFTLJDB94/620ZlsOuM8tha08OfoUpaDEuoZ1bGw6f59f1de0X8UPen8ExKXi1ahKNaxyzeKreHT4cbYWt9VDN5ZYRCrCVz4Jw2WwOsQjQ4/S4jQzUB2s56xMVc7tL0wUt9XoZKA6hFfzRMVGgE0Qxbo8Vu2fj1/fbnq47kiYbqDN1z6n8JWPUorKtC/E+TCUDOIqsGa3mT9YfUfdAHgp/zJPjz7D02PPEhLuYwh6+PV8pXF/jMWpbnaVehmuDsdGkuEQqDg/yTTiCjNPefXtS2EJW+y6ftJQdQTbsOIct1qS9Z4wnsGUjlKkIoa9YZ4ffAHHcEiaSYarw3xj+ze5tOUSnhh9sh6ee2jw11SjKhP+BOWwXDfKDTGwDItLWy/h3Nw5dCUX7fO6mGJyeetl3Ln964QqnHE+XcNlMpikU3UgIjTYWZ4de46bF914UI2nudCV7ERE6j9mIG6fgmIfo06jORXRxpLmmCAi/P7ffpiv/+fv8caTm0GEXFsDH/zP76N18YENpUeGH+Oe/nsxa1VKO0o9vDD+Ah9b8ZEZBtM5ubMBuH/wQUa9MVrdFt7Z9XbWNZzGL/vvJm2mGIqGZowpVCFB7ULnmA5NThOBChjzx/FDH9d0abPaMABTLHZX+uqyA664rMysoByWaHGaGa71DJtqw2oZUs+jsWqJ3tONGxNjXpOm9zaS5pIHtDfTt5lvb5UgsYK1JHBMh41N57MsvZT+8gD/uPmfGPFGqYbVGR6lKaN3aiyO2DiGS0BAMSiwMr2S/ko/iNBk56iEFQa9IURJvWEtTBk/4CkPF5eUlaQaeeScHONenmgvz5+FVQ/tJUyXNwubKQRFApXHMRyanSZsw+Jnu/+NpeklOEas3u2FHr2lHsKpIoO6JysiZzWSsxtnNZSmaLJz+7xmClWTBtgjhVAOygxUB/m7TZ9ndWYVb2m7jGbn8FunrMmspjPRwe5yH2krjVKKUljitOxpLErsf7wazamCNpY0x4zG1gY+8w8fJz88QbXs0bq4uS4xsD/KYZn7Bx4gY2XquR0pkvRXBnkp/wobm8+fsf45ubM5J3f2ProzMULaSlHxKrVf0HHEfSpEljSSiAjtiXaanWZGvBEub72Mq9qu4J+3fYVxb5yu5CL6Kv1IJDTajYz7edJmihIVck6OpJkgUnHoane5DyJFZ6KTpJVElLC73MdkMEF7oh1RwpA3DIoZXqfDQQDZSwjSkfgCfiCBTkFISQpf+Ri1C3OVg+dqHcgQs7DI2tn6xTcf5EmIS9rO0Oa2kjAT5L086xpOY7AyxN9u+jtGvbG6d2YKhap7+KaOZ0osM0EEeW8iVtNW0JVcRDEsknNyiAjD1WECAhLiYhoWpbBU9xSahsFkUODS1ot5Y3ITFja+8hn3x+veoIiIchSLT17bfi3f7f1+XcS0GlYY88YQhED5FIMith17rCaDQu1M1LxitTwoU0wa7UaeH3+RS1ov3u/r+sjIozTajZSCIpZhI0AlrOIrn5wVz23cz7O7tJuE6RKogOfGnufVidf4vVWfmCGEeShYhsWHln+QR4Ye5YX8S5iGyeWtl3Jxy0V1T5NGsw+nTsqSNpY0x57G1oY5rzulQjxlKE1hGxabC5v3MZam2NtQWp87jwcGH6TdbWfcz8cGktqT85Mw3Bm9uSzDImEkWJFeTsbO8HsrP85z4y/w5MhT9JcH8PAY9AbrYSFHbDJOhqSZImnGmlNJI+67Nd3Qa7QbEIEJf5JIRdhik7SSjPqj+817mouHSE37fwpf+QetXut0O3BMh5XplbxZ2Myu8q4Drj9FQhIEKiBrZygEhVjQUcVhOkMMGu0GylGFFreFsxvPZGe5l5SZRDAY88boSLSzrmEd3+/5AZN+AUssQhXukxNVlwAQG3Oal6YaVQkkoFqtkrZSTARxXk3ez6OAZrsZRFiRWl5vKzLijaKUIlAh5+XO44bO67mo5UK+1/N9hqvDdJodsYEWxrlFrumStjL8+8gjmBiIxEKS1aha91oJwkBlkGpUpTPRWRO3jF9zW2wsw8Ko9Z0LVIB5kKqyvD9Bq9tKvwrwwlpYVwxECbZhM+lP0l/uxzIsupJdOIaD4ziM+3keHX7siHKYkmaS6zqv5brOaw97H5pTCaWlA442ItIMfBdYDmwH3qeUGttrnSXA14FO4k4yX1JK/f2xHalmoUmZqXql0vRfuKEKabQb57yfS1ouYkthKz3lnthg8sbxlEej1cAlrRczWh1jV2UXGSuDIBSCAq1uK6dl18bjsFJ0J7v4TnHbDE/NlBeioqqcnjyDSliuJ8Q2Og00u00UggKmmPiRz7A3TJPdxOJkE17ksbPUQymYUhqfvU3IXMNhe5fiz4UGu5EbF13Phqb1lMMKn33uT2eEvWbDwiSSiAYrS3eqm+HqMCPeaKygjs2y9DJWZ1aTcxo4v2k9zU4zT408zW+GH8GPfC5vvYzLWy/FMWw2F7bErUdqydWzGXexh0zR7nZQCSuMeCN1L1PGytCV7GTCL2CLSXdqMRkrw/lN63lk+FF2lnrI2lla3BaanByj3hjrsut4T/ctALS5rXxq1R0Me8OEUciWwlZ+NXAvq7OrMcSoJVO/QcJIUI08giiYkU9kY2OIQd6fIGkmmfAn6hV+nvIIozBWDq8ZVxubNhzwfKzMrODl/CssSy2lGJTwomps/Dk5Lm25hDcLm8n7eToSHdjTRCOTRoLtxe1zOueHSqQiNk2+ySv5VzDE5KzGM0kYCRzTpt1t154nzSnBQnmW/hK4Xyn1ORH5y9rjv9hrnQD4U6XUsyKSBZ4RkXuVUq8e68FqFo52t43FicXsquyiwWpARGKFYQzOb1o/5/24pstHVvwu24rbGawO0Wg3sCazun7BqYZVHhp6mGfHnidSERuaz+ea9qvqHqFRb4wvbP5fFILCPvtWKAwMJv0J/vL0/42eci8o6E4tJlIRL+dfYWe5h4HyAArqnegtw2Jpeim9pR4kFCIUJgYpM0019PDxsbGJiDAN84D6T47Yde9OrDJtEClFwkgwEU7M6p2yxeaKtsvYUHsdXXHqno/9ebNSRoql6SUUgyIT/gRD1SHGvDFsw8LBxot8BiuDfGj5B+uq07vLu3l05HFKYWwUvjD+Iqdl17LMWopruGTtDJVqZR9DaSrPaE1mNWuyq3hj8k0MwyBQPkkzRYOdxTVdymGZwcogAQFeLRm/FJa5vuMavr7jm+S9PJZh4UcBDXaWty66qX5Onx59hsHqIN3JJWxoOo8nx54mXWu0C/Fr6RoJKlGVRYlOdpV3118fSyyWpZeyq7ybIArYXe6LpSqMRD20GqqQclAma2dZnzuPc5vO2e85BLiy7Qo2TW5mIpis6YTFr8k7u97Bmuxq1jedx/bijn08p17k0ewsIVQho94YruHScIiilLOhlOKnu37Oc+MvYIlJMSjxy/67yVoZsnaWNreN25e8r/6e1pxiaM/SUecW4Kra/a8BD7GXsaSU6gP6avcnReQ1YDGgjaVTCBHh9qW38cPen7C9uD1urWImef+SW+lItB/SvgwxWJVZyarMyn2ec02XGztv4MbOGyiHZforA5SCWIZARHhq9GkKQaGesLs3llhIreJpRXr5jOc2NJ/PGn8NX912J5axp3LJj3wK/iQoYZHbyXiQx1c+nvJRosiZjSxLL2NLYQsg+PizGjCCkDbTNDqNDFYHUQoWJTvJ1lq4bJ7cTLGWszPlETExQcGv+u9lcXIx7W4b3+39AVILS85Gp9tJwkzUw06WmIxUR3HMODeqElbwVUCoAr6y7U4+u/YzuIbL17d/k1CFNNhx+LUclvnXHd/is2v/kEtaL+a+gQdosBqoeDNL9x3DwTVculKLeHf3u4D44v2Pm/+JyaCAa7oopegr98dzquUFCcK24jb6Kv18YOn7+VHvT9lV3k2z08xNnTfS4jazu7ybr277On7kYxk2b05u4cnRJ6lG1djYmUaz00xvuZekmaTdbWeoMoQYQovbTMpKsTK9gv7qAEpFdLjtSC3sN+VlylpZPrv2M/tV4J5Om9vKHas+waPDj7Gz1EOr28JlrZeyuLZtwkywoel8nhh9igY7W8uhisOCixNd/I83/i7Ou1KK1dlVvHvxu0hbqYMed3/0lHt5YfxFcnYjvvLpq/RjiUUxKNHmtjFcHeFfd36Lz6z+lBauPNVQ6JylY0BHzRhCKdUnIge86onIcmA98MQxGJvmOCNrZ/nwig8y7o1Tjaq0uq3zUi69N0opHhl5jAcGHgTikNCS5BLev/RWBioDmGJhsK+MgNQ0vC9puXDWff6q/x6eGH2SvJenEBaZ9Cdpc1vZUeqp56UoIGfnOKNhHd2pxTw9+mzctFWEJqeJoeowppj1Rq5T5eQQe2A6k53Yhs1gZQhFiGM49Wq/BruBUliqN4qdCh0KQk+5h7994+9xTRdDDJanlrGttJ1SWKrn5DiGQ5OVi19/Va0nOicsl4IqIpHUW3g4Evfn66/08+Vtd3J1+1VUoiqN9p48taSZZNwb543JN7is5RLGvXGeHH0ap6brZIlFykzR6DTUjIE9HjUR4YLmjfyi75e4hounfPzIAxGyVqZ+wXYNl6dGniYfTFANq7Qn2vAjnx/1/oRIRTwz9iwREY3OnlBu3stjG84Mccap87s6syrOOTIMxIgLBVrsFkIVMhlMcnr2NHrKvZi1HKX2RDvtiXZKQYmORPucDKUpmp2mA+Ye3dh5PYYYPD32DKEKyVgZrm29hgcGH8I1HBrsBpRSvDm5he/3/IAPr/jdOR97b7YXt9elFSa8ifr5iYioRJW4yMEbp6fUy7L00sM+jubERCt4zwMich9xvtHe/NUh7icD/BD4rFJqv+poIvJJ4JMAS5fqD+3JSG7aBexosLmwhXv776snZCul6Cnt5Me9P6U71c0r+VephhVMzBnl7YKwJruGK9ress8+nxt/nsdGHqfRbozbb5R2MukXmPAm8Gv7MMVkzB8jZ+fYXenjt5a9n23FHewq78LFpdlpJlBB7NGohXmanBytbis7ijsoRxUiFH7kk7WzVMNK3PcuLGOIQYPdyFjN0Nw71GVi4iuPil/BFJM2t4U12dUUgyIFvwgCn1jxUf7Hpr+rG0oAqNjoKQalel6ZIzaGmPjKp9FqJO/l2VrYiprFExehKAVlLMPilsXv4Mq2t/D5zV/ACz0qUZVCUKBQKmCIsCS5hCAK6iHRjc0beLOwmWdGn40VvCOfjJWh3d3zm0uhGPKGUUrVDSLHcPAij1/130M5KM94PwVRQMJM1BLys+T9cUyxCFSIa7p8ePkHaXZbyPt5in6R+wbvp6fUiykm65vO48bO6/n57l/wSv7V2LtVM1SrkcdFzfsa0UeCZVjcvOhGru24hmpYIW2luavvbpSK6lIaIkKj3cD20g6Gq8Mz2qMcCgkjUT/nQRTGrYRqbwGD+AeLMLNNjOZU4tSxlo6asaSUum5/z4nIgIgsqnmVFgGD+1nPJjaUvqmU+tFBjvcl4EsAGzduPHXOoGbeeGL0SSzDql+UY/G/RrYUtnJN+9U86TyFpzyKXqnunXENl/ctuZWr266cVQbhiZGnSJgJDDFwTZfuZDd9lT4mg8m618YxHFAwHoxjGxYT/gSXtFzEt3Z+BzdysQyLdredqKZ905noJG2laknuDSyxu4l1nSze3vVWzm08h22lbfiRT7vbzle3f43u5GJ2lnpioclp/1zTRZBYqZq4pL7JaSJtpUmaSSaDSV7Mv0TaTNcNlriPmmLcHydrZ6mEldpFVPAjH0MMmtwmSkEJW6y4ym+alINScY7XdE9EzslxectlfLvnu3UvVbwyPDbyGHl/nE+v/hSGYbCrvJttxR0krRRJpWKjJNyTlB6pCC/ycMTBMme2yXEMh7yfr1eohVFIf2Ugbi2iFGkrzcdXfJRtpe3sKhT9TIUAAB4NSURBVO2iPdHO+U3n1UOIbW4rbW4rH898lGpYxRSz/n55R9fbKIcVthW31assr2y7nLMaz5zX9+meudg4tZy7vD++T8WoSFypWQxKtB5mV5TTG9Zx98C9VMIqaStN3s8TRHFV39R7EKiHCTWak5WFCsP9DPgQ8Lna35/uvYLEJRZfBl5TSv3tsR2e5lSkGJT2Ce+JCCKCYzp8YuVHuX/wQV6beB0Dg/VN53FT5w37XKSmU6m1rZgiZSVpspsoBgVcI7GnoklARYpqVCVpJjktu5YbO2/ggcEHUWFsmG1oWs9p2bXcO3B/veJuQ/MG3rro5vpFc4rznHMBGK4OxzlNdpqu5CJ2lnrqRoWJiSUWgQqwjbhJ7PS2LJPBJGc2nMHuSh8pK8lkODltLoIirvQ6I7uOZ8afAyBjZWhymuIcLoSVmZWYhsUTI0/WthUCFXBe7hy6k4vrx4pUxHPjz9HitDBYGZwhHxCokJcmXuGegfu4sfN6ftH3S4TYcAFodHJsL2xjd3k3OacJlOLilosYrY6yrbQdF6e+r1CFmGJwftP5PDbyOGP+OFEUxdWKysfE5Lu93+czqz+FdZDGtHsryCfNJB9a/jsMVYcp+AXaEq1krMwB9zFfrM7ECfDpacuCKEDkyBS4s3aWDyy9ne/3/JBIRbVEeZ8Wpy2WjFCK6zquPWbz1Bxn6ATvo87ngO+JyMeAncBtACLSBfyLUuqtwGXAB4GXROT52nb/USl11wKMV3MKcEbDOu6tdX2fohJWSZlJmp0mTDF535JbD2mfpzeezmPDj+M4ey7YvvJwDBdq3qkpL0SoQlZlVpCo6TRd1noJG5vOZ8QbIWNl6t6Nc3JnM+FPkDAT9XX3R7PTTMpMUQmrNNgN9TBdJapi10KNSina3TaGvGEiFTHujSMIjU4jN3Zez70D9zNYGcIRB195mFi18UakzCTvX3obIgZvFDZRCorsLO1EEdHqtLIyvYIzGk5ndWYVz4+/iFIR5+TO5rTs2hkl5xP+JJNBob5sSv16SkXbxOQ3w//OW9ouo6/UR6hCBioDKBRZK8uS1BI85fPexe+iK9lFi9vMtuJ23ty2mWpYxTVdQhXWvHYXc13HNewo7WCgOljLwQlpcZtpc9vI+xO8Nvk6K9MrDys5esr7dCw5L3cuT44+zXB1uD7XIAq4sfP6Ge/nw2FVZiV/dtofs6u8m0hFjHljvDb5OgkjwflN61mRWT4/k9CceJw6ttLCGEtKqRFgH+UzpdRu4K21+/9OPTqu0Rx9NjZv4IX8SwxVhrAMm1AFCAbvWXLbYSeUX956Ka9NvM64F4dJgigkaSYxXQsBxrwxAnwipchaGW7rvm3G9q7p7pMcbIgx5/wtQwze2fV2vtPzfaphhZzdyEBYwRaLUEVEVMmYsT/i6rarOLPxdIaqQ7S6razNrsUxbC5ruYRX8q/S7DQxEUxSDIpEKqIz0cGHl/8uGTvDDZ3X8cqmV/AiHwODrN2AIQa/6P8lt3a/h7XZNazOrGKoOoRg7KMDlah5aaxa8+I9z6t4fRGUitt8jPv5WjVe/PU15o8zGRQ4LbOWs3Nn1fe5Ir2c25a8l1/130Pez2OKyRkNp2Ng8PDgr+lOLmZXeTcpM41j2LXzEzBcHebr2/+VlJWmO9nFO7veTkeiY45nfGFwTZePr/wIT48+w6sTr5Ox0lzUfAGrs6vnZf+WYdXDpitYzvnNc5ft0Jy8iPYsaTSnHkkzySdWfJQX8y+xubCFnN3IhqYNRxTGyFgZ7lj1CV4cf4kdxZ20JlpZnzuXXeXd/HjXT2h1W+vhjVu730Oze3jtKg7EaQ1ruWPVx3lm9FnG/HFu7LyerJVlV2U3I9UREobLmY1nsja7Ztby785kJx9a/kF+1X8PUTmaoen03Z7vc0PndWwv7iBbE6mcYkpj6oaO65jwJ/l+7w/r4cOcneP9S26lMxnXgCTMBOc0ns0zY8/Vq/4MZaCIDT5bLJJWkmJYjMeoFGJIPf+pHJRZku7eZ+zrsqdRCSs8M/Ycg5VBnhl9lqQZt7WpRtVaSKml3kS2p9RDtaapZIjJ6xObeH3ib/ntpbdzTu7sA4ZcF5qkmeQtbZfzlrbLF3oomlOBYyAdICI3AX8PmMRRp8/t9fxVxGk822qLfqSU+j+PxliO30++RrMAuKbLBc0buaB547ztM2kmuajlQi6aJi3Q5DSxMr2CrcX4M74yvYLUEejhHIyORAdv7bp5xrKzOWs/a+/LsvRSfm/Vx3l8+El+0XcXGTsTK2+HVb7X80Oa7NwMRWmIjRwDg6HKMN/r/QGRiupl7ZPBJF/b8a/88do/xDEcJvwJzmk8i1JYohpVGa4Ox2KcmCSMBLZhcWbDOsa8cRrtWFJgzBureaHiY41VZzQBIFIR3+35Pm9MbkIw6Cv3xUnPEkstBFEQV4t5I2StDOWgTLlWDh9GIb3VXlSthcu3dn6HF/Iv8cFlHziuDSaN5mRBREzgH4HrgV7gKRH52SzC1L9RSr39aI9Hf+o1mgUiZaWOWqXU0UApxW+Gf1M3lCAOn0UqZCKYIFIRrooVtYG6DtSIP0I1qtbb04hIXFnl5Xl14nU2T27m5YlX6rlbV7ReTqvTyiMjj7CluI1qVME2Mrww/hK7awKUAtiGjYGBaZj4oc+rk6+zo7iDZellAGwv7mDT5GZydo4xfxxDBEts8sEETWETrunSbDdzWsMaxr18LDNgNbLI7WBLraLNMEyI4mNtK27npfwrrG869xi/8hrN8chR7w13IbBZKbUVQES+QyxovSDC1NpY0mg0cyJQAZNBgZydm7HcNV3CIG5MvKnmxVEqTl4/N3cO/eWBGVV2UygUT4w8ya7yLhrtxno5/1NjT/Ouxe9kVXoVeX+SnN2IYcT7HKgMgMQNZx3DwRDBVwG2aZE2Uzwx+lTdWOot96JqgooGAsSVjUSxLpBruphicE7j2ZyTO5uByiBf2PK/qNR645kSJ8ADJM0UhgivTLx6RMZSpOJ8LN1PTXNycETGUquIPD3t8ZdqEkBTLAZ6pj3uBS6aZT+XiMgLwG7gz5RSrxzJoPaHNpY0Gs2csMSi2WmmHJZnVOGVwzIdiQ52l3fTYDdQDir4Klbdfin/MrvKu5jwJ2mwGuohrKmWMb3l3rqhBLFAZ9JM8sjwY4x6ozQ6DTP6tGXsLJWwTMpK4UVVwgjSVor2RDuhCsn7+fq40mYaqfWXy1hpBkXqopxTbUIsw2J1ZhUAHYl2zm44k2fGniNUIQZCqCISpkvaSlEICiSNA1cf7o+R6ih399/Dpsk3sQyLjc0buLrtyn3kBzSaE4p99WYPhWGl1IHyHWb7RbG3dfYssEwpVRCRtwI/AdYc0aj2g27mo9FoAPAin1fyr/LYyBNsK26ve1WmEBFu6LiOSlihFJQIVVjT2olYmloCwOLkYnJODkPiXCNDDFxxscSkt9QbK4MHBfJ+nnMaz0KU1BvmTmGKWW/PsnfVnIFgi01nooNlqWWsya6mO9WNYzhUwyprM2vr657esI6E6db0syw63Q6CyAcgjGJNqduXvG9Grti7u2/hlsXvIG2liVC0uM10p7pjEVIVHVLz5ilKQYmvbLuTTYU3ydpZXMPl0eHH+H7PDw95XxrNKUQvsGTa425i71EdpdSEUqpQu38XYIvIUdHt0J4ljUbDSHWUr27/GgW/QEiIiUlnspOMmaGn3EvObuSKtss5o+F0fmfZB3ho8GGGvGGWppZwdftV7CrtrotdTpXpT4W8MIQlqSUMVeP1pwQ912VPY9AbZqQ6QtraI6dYDEqclzuHSlRh08QmGqb1bysEBS5svoDFqS5+sutnVKMqtmFTDas0OU1sbN5QXzdlpfjd5b/DD3p+xLg/hhLh7Maz2Ni0kWa3ieXpZfXcqylMMbm45ULWZlfzrzu+zZg3RjEoAnB953WHpSn0Uv5lCkGhLvdgiEHOzrG5sIWBysBxL0ug0SwQTwFrRGQFsAu4HfjA9BVEpBMYUEopEbmQ2AE0cjQGo40ljUbDT3b9jGJQrPdRqwQVnhl7lkarkY5EO6PeGN/t+T7vWPQ2LmjZyJq99Htcw8UgzjmKe8HVmg0LpMwkhhgkzSQfWHr7jGqyty26ma9t/1fG/TyO2HiRT9pKcVX7FQDsLveR9/IoQARa3Vauar+CtJWm2WnmiZEnyfsTrM2uZmPThn0qChcnu/jDNX/AsDeCgUGz0zSnfKFmp5lPr/59esu7qIQVupKLDlulur8yMKsyvCEGo96YNpY0Jy5HMcFbKRWIyKeBu4mlA76ilHpFRO6oPf9F4Fbg90UkAMrA7Wpvl/g8oY0ljeYUpxAU6Cn30GA11JeN+bGKt6+8er88K7K4b/AB1jedt0/5fEeincvbLuM3w49gGTaloIRpmLQ6rfV+bGuyq/bZbmlqCZ9a9UmeGnuGwcogS1NL2dC0nqydBeDTq3+f1yZeZ8QboTPRydrsmrpEwdLUknr470CIyGEpahtizGn/B6MruYhnx56fsUypWAG91W054v1rNAuC4qi3O6mF1u7aa9kXp93/B+AfjuogamhjSaM5xdk7LwjipO29vSGOYTPhlykERXLTQmNTXNt+Neuya3l+7EUeH32CiAjLMBn38mSsNDd33jTr8VvcFm7qvGHW51zT5bzjoFS/GJTYUtiCQrEivYKGmjE3F85qPJNfD/07eW+cjJ0lUhGTQYGzGs6gzT18wVONZsE5dQS8tbGk0ZzqpK00S1NL6Cn11vvPOWJTiSq0WXs8MnG3eXO/4pkiQneqm+5UNzcsup7XJ16nr9JHm9PGGY2nH7SP3fHK6xNv8P3eHxJEAUGtEe87u94+Iz/qQCTNJB9b8RHuH3yAVydexzFsrmm/kstbLzvKI9doNPOFNpY0mpMYpRQv51/hwaGHGfPGWJTo5PqOfROV37X4nXx129fJ+3kiFeGYLgnl4ZouSikCFVAIClzZ9hacvZS6Z8MxbM7Jnc05nH2UZnZsKAUlvt/7Q/zQZ9QfJVQhkVLcuf0bdCTaWTLHMF3OaeS93e/mvUd5vBrNseOoi1IeV2hjSaM5iXl2/Hl+uutnJM0kGSvDYHWYr+34Bh9Z/qF6Y1SIE5r/cM0fsLmwhQl/ks5EB5Wgwt2D9zBSHcU1Xa7tuIa3HENvSKhCXs2/xksTL2OJxXm5c1mTWY2IMOqN8dTo0/SV++hOdbOxacOsocEjZUthK5Wwyqg3ikGsAI4oKmGVb2z/Fv/h9D/XApOaUxdtLGk0mhOdSEU8MPAAKTONa8Yl8lPiig8OPcyH0x+csb5t2JzesG7GsrUNa/AiL24tMkuT3aM59u/1/IDXJl7HNuyah+xVLm+9hLMbz+Yr2+7EVz622Gwv7uCp0af52IqPHFHT41nHQUQxKKJQGDL1dRlXso14IwxVh+f9mBrNCYM2ljQazYmOF3m1ZOzcjOUJI0F/rcfawRCRBVGZ3l7cwesTm8jZubrnJlIRjw4/ztbiNkIV1nvNAUz4E9w3cD8fWHb7vI5jZXpFrPqtqOsJKxWLZabMFMWwCGhjSXMKcgyq4Y4ntIK3RnOS4hgOaSuNF3kzlleiKh2J9gUa1dzYVtwBqBkhLkPi/nBbCtv20TxKW2k2F7bO+ziydpbLWi4hVCG+8vGVR6ACmpwmbMOmwz2+X0eNRjM/aGNJozlJMcTg6rYrKQYlqmEVpRSloESgAq5qv3Khh3dA0lZy9icEEmaCQAUzFgdRSGp/2xwh71r8Ts5oPJ20kaLRaqQ90RZXtHVcvd/KQI3m1EAdwe3EQofhNJqTmI3NG7AMm4emVcNd13EtK9LLF3poB+SMhjO4b+ABKmGFhJlAKUUxLJKxMpyfW8/Dw7+uN+ANVUgxLHJz2+xaTUeKa7rcseoTPDP6HK9OvkbaTHFh8wX1BrwazSnLkTXSPaHQxpJGcxIjIqxvOpf1TefGuTYnSOVWg53lA0tv5we9P2LCnwQUOSfH7Utuo9VtpRgVeW7seaTWVuWSlou4uOWiozaepJnk8rZLubzt0qN2DI3mxOLE9BAdLtpY0mhOEU4UQ2mKlZkV/Olpn2WgMoAhJh1ue30O7+x6O9e0XcW4P06T0zSjEa9Go9HMN9pY0mg0xy2mmHQlu2Z9LmNnyNiH19xWo9HMA6dQNZw2ljQajUaj0Rw6p46tpI0ljUaj0Wg0h4gC1KmT4a2NJY1Go9FoNIfOKRSG0zpLGo1Go9FoNAdAe5Y0Gs28E6qQLYWtDFWGyDk51mbXYBv2Qg9Lo9HMJ6eOY0kbSxqNZn4ph2W+tv0b9JcHiIgwxCBn5/joig/RYDcs9PA0Gs28oHQYTqPRaA6Xh4d+w+5yPw12A01OE412I+P+OL/su3uhh6bRaOYTpQ7/doKhjSWNRjOvvDD+AhkrPUMEM2tleW3ydUIVLuDINBqN5vDQYTiNRjOvyH5/g51YCuIajeYAKE5ID9HhsiCeJRFpFpF7ReTN2t+mWdZJiMiTIvKCiLwiIv9lIcaq0WgOjfW58ygEBdS0L9JJf4KzG8/EFHMBR6bRaOYVHYY76vwlcL9Sag1wf+3x3lSBa5RS5wLnATeJyMXHbogajeZwuKLtcpalljHhTzDujZP387Ql2rix8/qFHppGo5lPTiFjaaHCcLcAV9Xufw14CPiL6Suo+GdpofbQrt1OvFdYoznFcE2Xj674ENtLOxiuDtNk51iRWaG9ShrNScWJafQcLgtlLHUopfoAlFJ9ItI+20oiYgLPAKuBf1RKPXEMx6jRaA4TEWFFejkr0ssXeigajUZzxBw1Y0lE7gM6Z3nqr+a6D6VUCJwnIjngxyJyllLq5f0c75PAJwGWLl166APWaDQajUYzZ5T2LB05Sqnr9veciAyIyKKaV2kRMHiQfY2LyEPATcCsxpJS6kvAlwA2btx46pxBjUaj0WiONboa7pjwM+BDtfsfAn669woi0lbzKCEiSeA64PVjNUCNRqPRaDQH4BRK8F4oY+lzwPUi8iZwfe0xItIlInfV1lkEPCgiLwJPAfcqpf5tQUar0Wg0Go1mJqeQsbQgCd5KqRHg2lmW7wbeWrv/IrD+GA9No9FoNBqNZgZawVuj0Wg0Gs2hoRQqOvE8RIeL7g2n0Wg0Go3mMFBHcDs4InKTiLwhIptFZB/xaon5n7XnXxSR8+dhUrOiPUsajUaj0WgOnaPoWarpLP4jcV5zL/CUiPxMKfXqtNVuBtbUbhcB/1T7O+9oz5JGo9FoNJrjjQuBzUqprUopD/gOcfeP6dwCfF3FPA7kanJE8442ljQajUaj0RwGRzUMtxjomfa4t7bsUNeZF07KMNwzzzwzLCI7Fnocc6QVGF7oQRxFTub5ncxzg5N7fifz3ODknt/JPDc4/Pktm++BHIi+/K67/+vP/0PrEewiISJPT3v8pZq49BQyyzZ7W1lzWWdeOCmNJaVU20KPYa6IyNNKqY0LPY6jxck8v5N5bnByz+9knhuc3PM7mecGJ878lFI3HeVD9AJLpj3uBnYfxjrzgg7DaTQajUajOd54ClgjIitExAFuJ+7+MZ2fAb9bq4q7GMgrpfqOxmBOSs+SRqPRaDSaExelVCAinwbuBkzgK0qpV0TkjtrzXwTuIhay3gyUgI8crfFoY2nh+dLBVzmhOZnndzLPDU7u+Z3Mc4OTe34n89zg5J/fnFFK3UVsEE1f9sVp9xXwB8diLKJOwB4tGo1Go9FoNMcKnbOk0Wg0Go1GcwC0sXSMEZFmEblXRN6s/W2aZZ0lIvKgiLwmIq+IyB8txFgPh7nMr7beV0RkUERePtZjPFSOJ8n9+WYOc1snIo+JSFVE/mwhxngkzGF+v107Zy+KyKMicu5CjPNwmMPcbqnN63kReVpELl+IcR4uB5vftPUuEJFQRG49luM7EuZw7q4SkXzt3D0vIn+9EOPUTEMppW/H8Ab8DfCXtft/Cfz3WdZZBJxfu58FNgFnLPTY52t+teeuAM4HXl7oMR9kPiawBVgJOMALe58L4gTDXxJrflwMPLHQ457HubUDFwD/DfizhR7zUZjfpUBT7f7NJ9m5y7An1eIc4PWFHvd8zm/aeg8Q57XcutDjnsdzdxXwbws9Vn3bc9OepWPPLcDXave/Brxr7xWUUn1KqWdr9yeB1zhKqqRHgYPOD0Ap9Wtg9BiN6Ug4riT355mDzk0pNaiUegrwF2KAR8hc5veoUmqs9vBxYp2WE4G5zK2galdeIM1REus7SszlcwfwGeCHwOCxHNwRMte5aY4jtLF07OlQNR2I2t/2A60sIsuB9cATR39o88Ihze8E4LiS3J9nTtRxz5VDnd/HiD2EJwJzmpuIvFtEXgd+AXz0GI1tPjjo/ERkMfBu4IucWMz1fXmJiLwgIr8UkTOPzdA0+0NLBxwFROQ+oHOWp/7qEPeTIf7V9Fml1MR8jG0+mK/5nSAcV5L788yJOu65Muf5icjVxMbSiZLXM6e5KaV+DPxYRK4A/n/AdUd7YPPEXOb3d8BfKKVCkdlWP26Zy9yeBZYppQoi8lbgJ8Caoz0wzf7RxtJRQCm13y8kERkQkUVKqb5aqGZW97GI2MSG0jeVUj86SkM9LOZjficQx5Xk/jxzoo57rsxpfiJyDvAvwM1KqZFjNLYj5ZDOnVLq1yKySkRalVInQl+1ucxvI/CdmqHUCrxVRAKl1E+OyQgPn4PObfqPY6XUXSLyhRPo3J2U6DDcsednwIdq9z8E/HTvFST+9H8ZeE0p9bfHcGzzwUHnd4JxXEnuzzNzmduJzEHnJyJLgR8BH1RKbVqAMR4uc5nb6tp3CbUKTQc4UYzBg85PKbVCKbVcKbUc+AHwqRPAUIK5nbvOaefuQuJr9Yly7k5KtGfp2PM54Hsi8jFgJ3AbgIh0Af+ilHorcBnwQeAlEXm+tt1/VLGa6fHOXOaHiHybuOKjVUR6gf9DKfXlhRny/lHHmeT+fDKXuYlIJ/A00ABEIvJZ4sqd4yYsvD/meO7+GmgBvlC7NgXqxGhiOpe5vZfYiPeBMvD+aQnfxzVznN8JyRzndivw+yISEJ+720+Uc3eyohW8NRqNRqPRaA6ADsNpNBqNRqPRHABtLGk0Go1Go9EcAG0saTQajUaj0RwAbSxpNBqNRqPRHABtLGk0Go1Go9EcAG0saTQnCTVtlu+IyBYReVVE7hKRtQs9riOh1n390v08t05EHhORqoj82bEem0ajOXXQOksazUlATcDux8DXlFK315adB3QAJ5LY4t5cBRSAR2d5bhT4Q/bTrFmj0WjmC+1Z0mhODq4G/OlifUqp55VSv6kpi/8/IvKyiLwkIu+HutfmYRH5nohsEpHPichvi8iTtfVW1da7U0S+KCK/qa339tryhIh8tbbuc7X+aojIh0XkRyLyKxF5U0T+ZmpMInJDzRv0rIh8X+L+h4jIdhH5L7XlL9W8RsuBO4A/FpHnReQt0yeslBpUSj0F+Ef1ldVoNKc82rOk0ZwcnAU8s5/n3gOcB5xL3EPrKRH5de25c4HTib00W4lV1i8UkT8CPgN8trbecuBKYBXwoIisBv4AQCl1toisA+6ZFvY7D1gPVIE3ROTzxErE/wm4TilVFJG/AP4E+D9r2wwrpc4XkU8Bf6aU+riIfBEoKKX+38N+ZTQajeYI0caSRnPycznwbaVUCAyIyMPABcAE8NRUHzsR2QLcU9vmJWJv1RTfU0pFwJsishVYV9vv5wGUUq+LyA5gyli6XymVr+33VWAZkAPOAB6ptRZxgMemHWOqYfQzxAaeRqPRHBdoY0mjOTl4hbif1GzIAbarTrsfTXscMfP7Ye++SOoQ9hvW9iXAvUqp3zrINlPrazQazXGBzlnSaE4OHgBcEfnE1AIRuUBErgR+DbxfREwRaQOuAJ48xP3fJiJGLY9pJfBGbb+/XTvWWmBpbfn+eBy4rBbCQ0RSc6jWmwSyhzhWjUajmVe0saTRnATUOpK/G7i+Jh3wCvCfgd3EVXIvAi8QG1V/rpTqP8RDvAE8DPwSuEMpVQG+AJgi8hLwXeDDSqnq/naglBoCPgx8W0ReJDae1h3kuD8H3j1bgndNKqGXOO/pP4lIr4g0HOK8NBqN5qBI/B2r0Wg0syMidwL/ppT6wUKPRaPRaBYC7VnSaDQajUajOQDas6TRaDQajUZzALRnSaPRaDQajeYAaGNJo9FoNBqN5gBoY0mj0Wg0Go3mAGhjSaPRaDQajeYAaGNJo9FoNBqN5gBoY0mj0Wg0Go3mAPz/AcSCvKBnxUncAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 720x432 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "from sklearn.decomposition import PCA\n",
    "from sklearn.manifold import TSNE\n",
    "\n",
    "# Function to plot clusters\n",
    "def plot_clusters(tfidf_matrix, cluster_labels, half_year, method=\"PCA\"):\n",
    "    # Reduce dimensionality\n",
    "    if method == \"PCA\":\n",
    "        reducer = PCA(n_components=2, random_state=42)\n",
    "    elif method == \"TSNE\":\n",
    "        reducer = TSNE(n_components=2, random_state=42)\n",
    "    else:\n",
    "        raise ValueError(\"Invalid method. Choose 'PCA' or 'TSNE'.\")\n",
    "    \n",
    "    reduced_data = reducer.fit_transform(tfidf_matrix.toarray())  # Convert sparse matrix to dense\n",
    "    x = reduced_data[:, 0]\n",
    "    y = reduced_data[:, 1]\n",
    "\n",
    "    # Plot clusters\n",
    "    plt.figure(figsize=(10, 6))\n",
    "    scatter = plt.scatter(x, y, c=cluster_labels, cmap='viridis', alpha=0.7)\n",
    "    plt.colorbar(scatter, label='Cluster')\n",
    "    plt.title(f\"Clustering Visualization for Half-Year: {half_year} ({method})\")\n",
    "    plt.xlabel(\"Component 1\")\n",
    "    plt.ylabel(\"Component 2\")\n",
    "    plt.show()\n",
    "\n",
    "# Select one specific half-year to plot\n",
    "selected_half_year = \"2020-1\"  # Change this to the desired half-year\n",
    "selected_posts = grouped_data.get_group(selected_half_year)\n",
    "\n",
    "# Preprocess the text for the selected half-year\n",
    "selected_posts_text = selected_posts['post'].dropna().apply(preprocess_text).tolist()\n",
    "\n",
    "# TF-IDF feature extraction for unigrams\n",
    "tfidf_vectorizer_unigrams = TfidfVectorizer(max_features=5000, ngram_range=(1, 1))\n",
    "tfidf_matrix_unigrams = tfidf_vectorizer_unigrams.fit_transform(selected_posts_text)\n",
    "\n",
    "# K-Means clustering for the selected half-year\n",
    "num_clusters = 5  # Number of clusters\n",
    "kmeans = KMeans(n_clusters=num_clusters, random_state=42)\n",
    "cluster_labels = kmeans.fit_predict(tfidf_matrix_unigrams)\n",
    "\n",
    "# Plot the clustering result\n",
    "plot_clusters(tfidf_matrix_unigrams, cluster_labels, selected_half_year, method=\"PCA\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4c6de731",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}