mw-lifecycle-analysis/text_analysis/case3/.ipynb_checkpoints/041525_phab_comments-checkpoint.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "ba9e5acd-e17d-4318-9272-04c9f6706186",
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd \n",
    "import spacy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "e4f0b3f0-5255-46f1-822f-e455087ba315",
   "metadata": {},
   "outputs": [],
   "source": [
    "phab_path = \"/mmfs1/gscratch/comdata/users/mjilg/mw-repo-lifecycles/case3/0422_http_phab_comments.csv\"\n",
    "phab_df = pd.read_csv(phab_path)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "ac5e624b-08a4-4ede-bc96-cfc26c3edac3",
   "metadata": {},
   "outputs": [],
   "source": [
    "def http_relevant(text):\n",
    "    if pd.isnull(text):\n",
    "        return False\n",
    "    # expanded dictionary for relevancy\n",
    "    # http, login, SSL, TLS, certificate \n",
    "    for word in text.split():\n",
    "        if \"://\" not in word.lower():\n",
    "            #http\n",
    "            if \"http\" in word.lower():\n",
    "                return True\n",
    "            #login\n",
    "            if \"login\" in word.lower():\n",
    "                return True\n",
    "            #ssl\n",
    "            if \"ssl\" in word.lower():\n",
    "                return True\n",
    "            #tls\n",
    "            if \"tls\" in word.lower():\n",
    "                return True\n",
    "            #cert\n",
    "            if word.lower().startswith(\"cert\") and not word.lower().startswith(\"certain\"):\n",
    "                return True\n",
    "    return False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "d5925c49-ea1d-4813-98aa-eae10d5879ca",
   "metadata": {},
   "outputs": [],
   "source": [
    "def is_migrated(comment_text):\n",
    "    if pd.isnull(comment_text):\n",
    "        return False\n",
    "    text = comment_text.strip()\n",
    "    if text.startswith(\"Originally from: http://sourceforge.net\"):\n",
    "        return True \n",
    "    return False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "d449164e-1d28-4580-9eb1-f0f69978f114",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_34086/836739196.py:41: 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",
      "  mid_comment_phab_df['is_relevant'] = mid_comment_phab_df['conversation_id'].isin(relevant_conversation_ids)\n",
      "/tmp/ipykernel_34086/836739196.py:44: 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",
      "  mid_comment_phab_df['is_migrated'] = mid_comment_phab_df['conversation_id'].isin(migrated_conversation_ids)\n"
     ]
    }
   ],
   "source": [
    "#find gerrit phab PHID: PHID-USER-idceizaw6elwiwm5xshb\n",
    "phab_df['isGerrit'] = phab_df['AuthorPHID'] == 'PHID-USER-idceizaw6elwiwm5xshb'\n",
    "\n",
    "#cleaning df\n",
    "phab_df['id'] = phab_df.index + 1\n",
    "#may have to build out the reply_to column \n",
    "phab_df['reply_to'] = phab_df.groupby('TaskPHID')['id'].shift()\n",
    "phab_df['reply_to'] = phab_df['reply_to'].where(pd.notnull(phab_df['reply_to']), None)\n",
    "\n",
    "phab_df = phab_df.rename(columns={\n",
    "    'AuthorPHID': 'speaker',\n",
    "    'TaskPHID': 'conversation_id',\n",
    "    'WMFaffil':'meta.affil',\n",
    "    'isGerrit': 'meta.gerrit'\n",
    "})\n",
    "\n",
    "# after 07-01-2013 before 10-01-2015\n",
    "phab_df['timestamp'] = pd.to_datetime(phab_df['date_created'], unit='s', origin='unix', utc=True)\n",
    "filtered_phab_df = phab_df[(phab_df['date_created'] < 1443743999) & (phab_df['date_created'] > 1372636800)]\n",
    "#filtered_phab_df = phab_df[(phab_df['date_created'] < 1381691276) & (phab_df['date_created'] > 1379975444)]\n",
    "\n",
    "#removing headless conversations\n",
    "task_phab_df = filtered_phab_df[filtered_phab_df['comment_type']==\"task_description\"]\n",
    "headed_task_phids = task_phab_df['conversation_id'].unique()\n",
    "filtered_phab_df = filtered_phab_df[filtered_phab_df['conversation_id'].isin(headed_task_phids)]\n",
    "\n",
    "#removing gerrit comments \n",
    "mid_comment_phab_df = filtered_phab_df[filtered_phab_df['meta.gerrit'] != True]\n",
    "\n",
    "# filter out the sourceforge migration \n",
    "# Originally from: http://sourceforge.net in the task task_summary\n",
    "migrated_conversation_ids = task_phab_df[task_phab_df['comment_text'].apply(is_migrated)]['conversation_id'].unique()\n",
    "\n",
    "#cut down to only the data that is relevant (mentions http)\n",
    "relevant_conversation_ids = task_phab_df[\n",
    "    task_phab_df['comment_text'].apply(http_relevant) |\n",
    "    task_phab_df['task_title'].apply(http_relevant)\n",
    "]['conversation_id'].unique()\n",
    "\n",
    "task_phab_df['is_relevant'] = task_phab_df['conversation_id'].isin(relevant_conversation_ids)\n",
    "mid_comment_phab_df['is_relevant'] = mid_comment_phab_df['conversation_id'].isin(relevant_conversation_ids)\n",
    "\n",
    "task_phab_df['is_migrated'] = task_phab_df['conversation_id'].isin(migrated_conversation_ids)\n",
    "mid_comment_phab_df['is_migrated'] = mid_comment_phab_df['conversation_id'].isin(migrated_conversation_ids)\n",
    "\n",
    "comment_phab_df = mid_comment_phab_df[(mid_comment_phab_df['is_relevant'] == True) & (mid_comment_phab_df['is_migrated'] != True)]\n",
    "task_phab_df = task_phab_df[(task_phab_df['is_relevant'] == True) & (task_phab_df['is_migrated'] != True)]\n",
    "#comment_phab_df = mid_comment_phab_df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "942344db-c8f5-4ed6-a757-c97f8454f18b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Unique conversation_ids: 2281\n",
      "Unique ids: 14490\n",
      "Unique speakers: 634\n"
     ]
    }
   ],
   "source": [
    "unique_conversation_ids = len(comment_phab_df['conversation_id'].unique())\n",
    "unique_ids = len(comment_phab_df['id'].unique())\n",
    "unique_speakers = len(comment_phab_df['speaker'].unique())\n",
    "\n",
    "print(f\"Unique conversation_ids: {unique_conversation_ids}\")\n",
    "print(f\"Unique ids: {unique_ids}\")\n",
    "print(f\"Unique speakers: {unique_speakers}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "d226d781-b002-4842-a3ae-92d4851a5878",
   "metadata": {},
   "outputs": [],
   "source": [
    "import re\n",
    "\n",
    "def preprocess_text(text):\n",
    "    text = str(text)\n",
    "    text = text.replace('*', ' ')\n",
    "    text = text.replace('-', ' ')\n",
    "    text = re.sub(r'http\\S+', '', text)\n",
    "    return text"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "3ae40d24-bbe8-49c3-a3a9-70bde1b4d559",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_34086/2783900859.py:1: 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",
      "  comment_phab_df['processed_text'] = comment_phab_df['comment_text'].apply(preprocess_text)\n"
     ]
    }
   ],
   "source": [
    "comment_phab_df['processed_text'] = comment_phab_df['comment_text'].apply(preprocess_text)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b8eddf40-1fe2-4fce-be74-b32552b40c57",
   "metadata": {},
   "outputs": [],
   "source": [
    "#comment_phab_df['processed_resolved_text'] = comment_phab_df['resolved_text'].apply(preprocess_text)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "a8469b16-4ae6-4b06-bf1b-1f2f6c736cab",
   "metadata": {},
   "outputs": [],
   "source": [
    "nlp = spacy.load(\"en_core_web_sm\")\n",
    "\n",
    "def extract_dependency_tree(text):\n",
    "    doc = nlp(text)\n",
    "    dependency_trees = []\n",
    "    \n",
    "    for sentence in doc.sents:\n",
    "        for token in sentence:\n",
    "            token_info = (\n",
    "                token.text, \n",
    "                token.lemma_, \n",
    "                token.dep_, \n",
    "                token.head.text, \n",
    "                list(token.ancestors), \n",
    "                list(token.subtree), \n",
    "                list(token.children)\n",
    "            )\n",
    "            dependency_trees.append(token_info)\n",
    "        \n",
    "    return dependency_trees"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "8b9a12f9-71bf-4bc9-bcfd-c73aab4be920",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_34086/2805711855.py:1: 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",
      "  comment_phab_df['dependency_tree'] = comment_phab_df['processed_text'].apply(extract_dependency_tree)\n"
     ]
    }
   ],
   "source": [
    "comment_phab_df['dependency_tree'] = comment_phab_df['processed_text'].apply(extract_dependency_tree)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "337a528a-5667-4e1f-ac9a-37caabc03a18",
   "metadata": {},
   "outputs": [],
   "source": [
    "#comment_phab_df['resolved_dependency_tree'] = comment_phab_df['processed_resolved_text'].apply(extract_dependency_tree)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "a3f5d40b-f56e-4e31-a7f9-40b7ddb4d2a4",
   "metadata": {},
   "outputs": [],
   "source": [
    "#get VAD scores\n",
    "import numpy as np\n",
    "#https://saifmohammad.com/WebPages/nrc-vad.html\n",
    "column_headings = ['Word', 'Valence', 'Arousal', 'Domination']\n",
    "vad_lexicon = pd.read_csv('NRC-VAD-Lexicon.txt', delimiter='\\t', header=None, names=column_headings)\n",
    "vad_dict = vad_lexicon.set_index('Word').T.to_dict()\n",
    "\n",
    "def vad_scoring(dependency_tree):\n",
    "    valence = []\n",
    "    arousal = []\n",
    "    dominance = []\n",
    "    for token, lemma, dep, head, ancestors, subtree, children in dependency_tree:\n",
    "        if lemma in vad_dict:\n",
    "            valence.append(vad_dict[lemma]['Valence'])\n",
    "            arousal.append(vad_dict[lemma]['Arousal'])\n",
    "            dominance.append(vad_dict[lemma]['Domination'])\n",
    "\n",
    "    # Compute average scores across the comment\n",
    "    avg_valence = np.mean(valence) if valence else 0\n",
    "    avg_arousal = np.mean(arousal) if arousal else 0\n",
    "    avg_dominance = np.mean(dominance) if dominance else 0\n",
    "\n",
    "    return [avg_valence, avg_arousal, avg_dominance]\n",
    "\n",
    "def dominance_prevail(dependency_tree):\n",
    "    dominant_words = 0 \n",
    "    for token, lemma, dep, head, ancestors, subtree, children in dependency_tree:\n",
    "        if lemma in vad_dict:\n",
    "            if vad_dict[lemma]['Domination'] >= 0.75:\n",
    "                dominant_words += 1\n",
    "            if vad_dict[lemma]['Domination'] <= 0.25:\n",
    "                dominant_words += 1\n",
    "    return dominant_words\n",
    "\n",
    "def arousal_prevail(dependency_tree):\n",
    "    arousal_words = 0 \n",
    "    for token, lemma, dep, head, ancestors, subtree, children in dependency_tree:\n",
    "        if lemma in vad_dict:\n",
    "            if vad_dict[lemma]['Arousal'] >= 0.75:\n",
    "                arousal_words += 1\n",
    "            if vad_dict[lemma]['Arousal'] <= 0.25:\n",
    "                arousal_words += 1\n",
    "    return arousal_words\n",
    "\n",
    "def valence_prevail(dependency_tree):\n",
    "    valence_words = 0 \n",
    "    for token, lemma, dep, head, ancestors, subtree, children in dependency_tree:\n",
    "        if lemma in vad_dict:\n",
    "            if vad_dict[lemma]['Valence'] >= 0.75:\n",
    "                valence_words += 1\n",
    "            if vad_dict[lemma]['Valence'] <= 0.25:\n",
    "                valence_words += 1\n",
    "    return valence_words\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "828fb57a-e152-42ef-9c60-660648898532",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_34086/2858732056.py:2: 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",
      "  comment_phab_df['avg_vad_scores'] = comment_phab_df['dependency_tree'].apply(vad_scoring)\n",
      "/tmp/ipykernel_34086/2858732056.py:3: 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",
      "  comment_phab_df['dominant_wc'] = comment_phab_df['dependency_tree'].apply(dominance_prevail)\n",
      "/tmp/ipykernel_34086/2858732056.py:4: 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",
      "  comment_phab_df['arousal_wc'] = comment_phab_df['dependency_tree'].apply(arousal_prevail)\n",
      "/tmp/ipykernel_34086/2858732056.py:5: 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",
      "  comment_phab_df['valence_wc'] = comment_phab_df['dependency_tree'].apply(valence_prevail)\n"
     ]
    }
   ],
   "source": [
    "#establishing per-comment VAD scores \n",
    "comment_phab_df['avg_vad_scores'] = comment_phab_df['dependency_tree'].apply(vad_scoring)\n",
    "comment_phab_df['dominant_wc'] = comment_phab_df['dependency_tree'].apply(dominance_prevail)\n",
    "comment_phab_df['arousal_wc'] = comment_phab_df['dependency_tree'].apply(arousal_prevail)\n",
    "comment_phab_df['valence_wc'] = comment_phab_df['dependency_tree'].apply(valence_prevail)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "27e47f6f-0257-4b70-b222-e91ef888c900",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_34086/335308388.py:1: 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",
      "  comment_phab_df[['average_v_score', 'average_a_score', 'average_d_score']] = pd.DataFrame(comment_phab_df['avg_vad_scores'].tolist(), index=comment_phab_df.index)\n",
      "/tmp/ipykernel_34086/335308388.py:1: 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",
      "  comment_phab_df[['average_v_score', 'average_a_score', 'average_d_score']] = pd.DataFrame(comment_phab_df['avg_vad_scores'].tolist(), index=comment_phab_df.index)\n",
      "/tmp/ipykernel_34086/335308388.py:1: 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",
      "  comment_phab_df[['average_v_score', 'average_a_score', 'average_d_score']] = pd.DataFrame(comment_phab_df['avg_vad_scores'].tolist(), index=comment_phab_df.index)\n"
     ]
    }
   ],
   "source": [
    "comment_phab_df[['average_v_score', 'average_a_score', 'average_d_score']] = pd.DataFrame(comment_phab_df['avg_vad_scores'].tolist(), index=comment_phab_df.index)\n",
    "comment_phab_df = comment_phab_df.drop(columns=['avg_vad_scores'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "184ccbe6-0a7a-41b8-9b02-bc439ff975d0",
   "metadata": {},
   "outputs": [],
   "source": [
    "# expand the dependency parser \n",
    "\n",
    "#pattern = r'\\b(ve|VE|visualeditor|VisualEditor)\\b'\n",
    "#pattern = r'\\b(WMF|Foundation)\\b'\n",
    "#pattern = r'\\b(bots|scripts|gadgets)\\b'\n",
    "pattern = r'\\b(http|https)\\b'\n",
    "\n",
    "dependency_relations = []\n",
    "resolved_dependency_relations = []\n",
    "\n",
    "for index, row in comment_phab_df.iterrows():\n",
    "    text = row['comment_text']\n",
    "    timestamp = row['timestamp']\n",
    "    comment_id = row['id']\n",
    "    conversation_id = row['conversation_id']\n",
    "    WMFaffil = row['meta.affil']\n",
    "    \n",
    "    for token, lemma, dep, head, ancestors, subtree, children in row['dependency_tree']:\n",
    "        if re.search(pattern, token, re.IGNORECASE):\n",
    "            dependency_relations.append({\n",
    "                'comment_id': comment_id,\n",
    "                'timestamp': timestamp,\n",
    "                'wmfAffil':WMFaffil,\n",
    "                'token': token,\n",
    "                'dependency': dep,\n",
    "                'head': head,\n",
    "                'depth': len(list(ancestors)), \n",
    "                'children': len(list(children)) \n",
    "            })\n",
    "    '''        \n",
    "    for token, lemma, dep, head, ancestors, subtree, children in row['resolved_dependency_tree']:\n",
    "        if re.search(pattern, token, re.IGNORECASE):\n",
    "            resolved_dependency_relations.append({\n",
    "                'comment_id': comment_id,\n",
    "                'timestamp': timestamp,\n",
    "                'wmfAffil':WMFaffil,\n",
    "                'token': token,\n",
    "                'dependency': dep,\n",
    "                'head': head,\n",
    "                'depth': len(list(ancestors)), \n",
    "                'children': len(list(children)) \n",
    "            })\n",
    "    '''\n",
    "#resolved_dependency_relations_df = pd.DataFrame(resolved_dependency_relations)            \n",
    "dependency_relations_df = pd.DataFrame(dependency_relations)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "82498686-14f4-40c8-9e33-27b31f115b47",
   "metadata": {},
   "outputs": [],
   "source": [
    "#now analysis/plotting \n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "from matplotlib.gridspec import GridSpec\n",
    "import matplotlib.ticker as ticker\n",
    "import matplotlib.dates as mdates"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "9833922d-d69a-4f8d-96ed-b25eea626114",
   "metadata": {},
   "outputs": [],
   "source": [
    "given_date = pd.Timestamp(\"2015-07-02\").tz_localize(None)\n",
    "task_phab_df['timestamp'] = pd.to_datetime(task_phab_df['timestamp'], unit='s').dt.tz_localize(None)\n",
    "#task_phab_df = task_phab_df[(task_phab_df['date_created'] < 1380585599) & (task_phab_df['date_created'] > 1352592000)]\n",
    "task_phab_df['week_bin'] = ((task_phab_df['timestamp'] - given_date).dt.days // 7)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "ebd80040-8e9b-49f3-9eea-5643bdf12f5b",
   "metadata": {},
   "outputs": [],
   "source": [
    "task_phab_df\n",
    "task_phab_df.to_csv(\"/mmfs1/gscratch/comdata/users/mjilg/mw-repo-lifecycles/case3/phab_tasks.csv\", index=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "82cd9dde-0d14-4de5-8482-5a39de8d2869",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_96995/627627281.py:7: UserWarning: Converting to PeriodArray/Index representation will drop timezone information.\n",
      "  task_phab_df['week'] = task_phab_df['timestamp'].dt.to_period('W').dt.start_time\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x600 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(10, 6))\n",
    "#task_phab_df = phab_df[phab_df['comment_type']==\"task_description\"]\n",
    "task_phab_df = task_phab_df[task_phab_df['is_relevant'] == True]\n",
    "task_phab_df['first_comment'] = task_phab_df.groupby('speaker')['timestamp'].rank(method='first') <= 5\n",
    "#task_phab_df = task_phab_df[(task_phab_df['date_created'] < 1383264000) & (task_phab_df['date_created'] > 1351728000)]\n",
    "\n",
    "task_phab_df['week'] = task_phab_df['timestamp'].dt.to_period('W').dt.start_time\n",
    "unique_taskPHIDs = task_phab_df.groupby('week')['conversation_id'].nunique()\n",
    "\n",
    "wmf_task_phab_df = task_phab_df[(task_phab_df['meta.affil'] == True)]\n",
    "wmf_tasks = wmf_task_phab_df.groupby('week')['conversation_id'].nunique()\n",
    "\n",
    "other_task_phab_df = task_phab_df[(task_phab_df['meta.affil'] != True)]\n",
    "other_tasks = other_task_phab_df.groupby('week')['conversation_id'].nunique()\n",
    "\n",
    "'''\n",
    "task_phab_df['speakers_task'] = task_phab_df.groupby('speaker')['timestamp'].rank(method='first').astype(int)\n",
    "\n",
    "# Filter dates 06-12-2015 to 10-01-2015\n",
    "bounded_task_phab_df = task_phab_df[(task_phab_df['date_created'] < 1443743999) & (task_phab_df['date_created'] > 1434067200)]\n",
    "# Bin the speakers based on the number of tasks they created\n",
    "bins = [0, 6, 26, 51, float('inf')]\n",
    "labels = ['0-5', '6-25', '26-50', '51+']\n",
    "min_speakers_task = bounded_task_phab_df.groupby('speaker')['speakers_task'].min().reset_index()\n",
    "min_speakers_task = bounded_task_phab_df.rename(columns={'speakers_task': 'min_speakers_task'})\n",
    "bounded_task_phab_df = bounded_task_phab_df.merge(min_speakers_task, on='speaker', how='left')\n",
    "bounded_task_phab_df['task_bins'] = pd.cut(bounded_task_phab_df ['min_speakers_task'], bins=bins, labels=labels, right=False)\n",
    "print(bounded_task_phab_df)\n",
    "bounded_task_phab_df['week'] = bounded_task_phab_df['timestamp_y'].dt.to_period('W').dt.start_time\n",
    "weekly_breakdown = bounded_task_phab_df.groupby(['week', 'task_bins']).size().unstack(fill_value=0)\n",
    "speaker_breakdown = bounded_task_phab_df.groupby(['week', 'task_bins']).nunique()['speaker'].unstack(fill_value=0)\n",
    "\n",
    "# Reshape the DataFrame for use with Seaborn\n",
    "weekly_breakdown = weekly_breakdown.reset_index().melt(id_vars='week', value_vars=labels, var_name='task_bins', value_name='count')\n",
    "speaker_breakdown = speaker_breakdown.reset_index().melt(id_vars='week', value_vars=labels, var_name='task_bins', value_name='speakers')\n",
    "\n",
    "rookie_bounded_task_phab_df = weekly_breakdown[weekly_breakdown['task_bins'] == '0-5']\n",
    "\n",
    "#unaff_new_tasks_phab_df = task_phab_df[(task_phab_df['first_comment'] == True) & (task_phab_df['meta.affil'] != True)]\n",
    "#unaff_new_tasks = unaff_new_tasks_phab_df.groupby('week')['conversation_id'].nunique()\n",
    "\n",
    "#aff_new_tasks_phab_df = task_phab_df[(task_phab_df['first_comment'] == True) & (task_phab_df['meta.affil'] == True)]\n",
    "#aff_new_tasks = aff_new_tasks_phab_df.groupby('week')['conversation_id'].nunique()\n",
    "\n",
    "#sns.lineplot(x=unique_taskPHIDs.index, y=unique_taskPHIDs.values, color='black', label='Total', marker='o')\n",
    "#sns.lineplot(x=wmf_tasks.index, y=wmf_tasks.values, color='#c7756a', label='WMF-affiliated authors', marker='o')\n",
    "#sns.lineplot(x=other_tasks.index, y=other_tasks.values, color='#5da2d8', label='Nonaffiliated authors', marker='o')\n",
    "#sns.lineplot(x=aff_new_tasks.index, y=aff_new_tasks.values, color='#c7756a',linestyle=\"dotted\", label=\"WMF-affiliated new authors\", marker='x')\n",
    "#sns.lineplot(x=unaff_new_tasks.index, y=unaff_new_tasks.values, color='#5da2d8', linestyle=\"dotted\", label=\"Nonaffiliated new authors\", marker='x')\n",
    "'''\n",
    "#sns.barplot(x=unique_taskPHIDs.index, y=unique_taskPHIDs.values, color='black', label='Total')\n",
    "sns.barplot(x=other_tasks.index, y=other_tasks.values, color='#5da2d8', label='Nonaffiliated authors')\n",
    "sns.barplot(x=wmf_tasks.index, y=-wmf_tasks.values, color='#c7756a', label='WMF-affiliated authors')\n",
    "#sns.lineplot(data=rookie_bounded_task_phab_df, x='week', y='count', color='green', label='Authors with ≤ 5 tasks', marker='o')\n",
    "\n",
    "plt.title('New Relevant Phabricator Tasks Indexed with HTTP')\n",
    "plt.xlabel('Timestamp')\n",
    "plt.ylabel('Unique taskPHIDs')\n",
    "plt.xticks(rotation=90)\n",
    "# Customize the x-axis for weekly labels\n",
    "plt.grid(True)\n",
    "plt.tight_layout()\n",
    "plt.show()\n",
    "\n",
    "#plt.savefig('031825_new_tasks_fig.png')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "9a9b08a7-6c95-4971-b259-8e713c58fbe7",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_96995/3303796756.py:4: 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",
      "  unaff_tasks_phab_df['speakers_task'] = unaff_tasks_phab_df.groupby('speaker')['timestamp'].rank(method='first').astype(int)\n",
      "/tmp/ipykernel_96995/3303796756.py:17: UserWarning: Converting to PeriodArray/Index representation will drop timezone information.\n",
      "  unaff_tasks_phab_df['week'] = unaff_tasks_phab_df['timestamp'].dt.to_period('W').dt.start_time\n",
      "/tmp/ipykernel_96995/3303796756.py:18: FutureWarning: The default of observed=False is deprecated and will be changed to True in a future version of pandas. Pass observed=False to retain current behavior or observed=True to adopt the future default and silence this warning.\n",
      "  weekly_breakdown = unaff_tasks_phab_df.groupby(['week', 'task_bins']).size().unstack(fill_value=0)\n",
      "/tmp/ipykernel_96995/3303796756.py:20: FutureWarning: The default of observed=False is deprecated and will be changed to True in a future version of pandas. Pass observed=False to retain current behavior or observed=True to adopt the future default and silence this warning.\n",
      "  speaker_breakdown = unaff_tasks_phab_df.groupby(['week', 'task_bins']).nunique()['speaker'].unstack(fill_value=0)\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1200x800 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "#task_phab_df = phab_df[phab_df['comment_type'] == \"task_description\"]\n",
    "unaff_tasks_phab_df = task_phab_df[task_phab_df['meta.affil'] != True]\n",
    "# Rank speaker's task values within each group\n",
    "unaff_tasks_phab_df['speakers_task'] = unaff_tasks_phab_df.groupby('speaker')['timestamp'].rank(method='first').astype(int)\n",
    "\n",
    "# Filter dates 06-12-2015 to 10-01-2015\n",
    "unaff_tasks_phab_df = unaff_tasks_phab_df[(unaff_tasks_phab_df['date_created'] < 1443743999) & (unaff_tasks_phab_df['date_created'] > 1434067200)]\n",
    "# Bin the speakers based on the number of tasks they created\n",
    "bins = [0, 6, 26, 51, float('inf')]\n",
    "labels = ['0-5', '6-25', '26-50', '51+']\n",
    "min_speakers_task = unaff_tasks_phab_df.groupby('speaker')['speakers_task'].min().reset_index()\n",
    "min_speakers_task = min_speakers_task.rename(columns={'speakers_task': 'min_speakers_task'})\n",
    "unaff_tasks_phab_df = unaff_tasks_phab_df.merge(min_speakers_task, on='speaker', how='left')\n",
    "unaff_tasks_phab_df['task_bins'] = pd.cut(unaff_tasks_phab_df['min_speakers_task'], bins=bins, labels=labels, right=False)\n",
    "\n",
    "# Calculate the weekly breakdown of binned speakers_task values\n",
    "unaff_tasks_phab_df['week'] = unaff_tasks_phab_df['timestamp'].dt.to_period('W').dt.start_time\n",
    "weekly_breakdown = unaff_tasks_phab_df.groupby(['week', 'task_bins']).size().unstack(fill_value=0)\n",
    "\n",
    "speaker_breakdown = unaff_tasks_phab_df.groupby(['week', 'task_bins']).nunique()['speaker'].unstack(fill_value=0)\n",
    "\n",
    "# Reshape the DataFrame for use with Seaborn\n",
    "weekly_breakdown = weekly_breakdown.reset_index().melt(id_vars='week', value_vars=labels, var_name='task_bins', value_name='count')\n",
    "speaker_breakdown = speaker_breakdown.reset_index().melt(id_vars='week', value_vars=labels, var_name='task_bins', value_name='speakers')\n",
    "\n",
    "# Plot the stacked bar plot using Seaborn\n",
    "plt.figure(figsize=(12, 8))\n",
    "sns.barplot(data=weekly_breakdown, x='week', y='count', hue='task_bins', palette='colorblind')\n",
    "#sns.barplot(data=speaker_breakdown, x='week', y='speakers', hue='task_bins', palette='colorblind')\n",
    "plt.title(\"06-12-2015 to 10-01-2015 Weekly Unaffiliated Task Creation by Contributor Tenure\")\n",
    "plt.xlabel('Week')\n",
    "plt.ylabel('Tasks')\n",
    "plt.legend(title=\"Contributor had created # tasks between 8-01-2013 and 06-12-2015:\")\n",
    "plt.xticks(rotation=45)\n",
    "plt.tight_layout()\n",
    "plt.show()\n",
    "\n",
    "#plt.savefig('031625_weekly_tasks_by_history.png')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "b7cfad77-d48a-4708-91f3-89ae1179b90c",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_34086/62586942.py:27: FutureWarning: The default of observed=False is deprecated and will be changed to True in a future version of pandas. Pass observed=False to retain current behavior or observed=True to adopt the future default and silence this warning.\n",
      "  comment_counts = affective_comment_phab_df.groupby('date_group').size()\n",
      "/tmp/ipykernel_34086/62586942.py:28: FutureWarning: The default of observed=False is deprecated and will be changed to True in a future version of pandas. Pass observed=False to retain current behavior or observed=True to adopt the future default and silence this warning.\n",
      "  speaker_counts = affective_comment_phab_df.groupby('date_group')['speaker'].nunique()\n",
      "/tmp/ipykernel_34086/62586942.py:35: FutureWarning: The default of observed=False is deprecated and will be changed to True in a future version of pandas. Pass observed=False to retain current behavior or observed=True to adopt the future default and silence this warning.\n",
      "  comment_counts_engaged = affective_comment_phab_df.groupby(['date_group', 'est_commenter', 'meta.affil']).size()\n",
      "/tmp/ipykernel_34086/62586942.py:36: FutureWarning: The default of observed=False is deprecated and will be changed to True in a future version of pandas. Pass observed=False to retain current behavior or observed=True to adopt the future default and silence this warning.\n",
      "  speaker_counts_engaged = affective_comment_phab_df.groupby(['date_group', 'est_commenter', 'meta.affil'])['speaker'].nunique()\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of comments for each date group:\n",
      "date_group\n",
      "Before announcement                      10614\n",
      "After announcement, before deployment      802\n",
      "After deployment                          3074\n",
      "dtype: int64\n",
      "\n",
      "Number of speakers for each date group:\n",
      "date_group\n",
      "Before announcement                      521\n",
      "After announcement, before deployment    142\n",
      "After deployment                         310\n",
      "Name: speaker, dtype: int64\n",
      "\n",
      "Number of comments for each date group and engaged commenter subgroup:\n",
      "date_group                             est_commenter  meta.affil\n",
      "Before announcement                    False          False         10317\n",
      "                                                      True            297\n",
      "After announcement, before deployment  False          False           787\n",
      "                                                      True             15\n",
      "After deployment                       False          False          2992\n",
      "                                                      True             82\n",
      "dtype: int64\n",
      "\n",
      "Number of speakers for each date group and engaged commenter subgroup:\n",
      "date_group                             est_commenter  meta.affil\n",
      "Before announcement                    False          False         518\n",
      "                                                      True           56\n",
      "After announcement, before deployment  False          False         138\n",
      "                                                      True            7\n",
      "After deployment                       False          False         305\n",
      "                                                      True           24\n",
      "Name: speaker, dtype: int64\n",
      "\n",
      "Number of comments for each engaged commenter subgroup, and WMF affiliation:\n",
      "est_commenter  meta.affil\n",
      "False          False         14096\n",
      "               True            394\n",
      "dtype: int64\n",
      "\n",
      "Number of speakers for each engaged commenter subgroup, and WMF affiliation:\n",
      "est_commenter  meta.affil\n",
      "False          False         627\n",
      "               True           75\n",
      "Name: speaker, dtype: int64\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'\\nplot1 = sns.lmplot(data=comment_phab_df, x=\"date_created\", y=\"dominant_wc\", hue=\"date_group\", col=\"meta.affil\", row=\\'new_commenter\\', scatter=False, legend=False, palette=palette)\\nplot1.set_axis_labels(\"Timestamp\", \"Count of Dominance Polarized Words\")\\nplot1.set_titles(row_template=\"Author\\'s 100+ Comment: {row_name}\",col_template=\"WMF Affiliation: {col_name}\")\\nplot1.fig.subplots_adjust(top=0.9)  # Adjust subplots to make room for the title\\nplot1.add_legend(title=\"Comment publication timestamp:\")\\nfig1 = plot1.fig\\n# Plot for arousal_wc\\nplot2 = sns.lmplot(data=comment_phab_df, x=\"date_created\", y=\"arousal_wc\", hue=\"date_group\", col=\"meta.affil\", row=\\'engaged_commenter\\', scatter=False, legend=False, palette=palette)\\nplot2.set_axis_labels(\"Timestamp\", \"Count of Arousal Polarized Words\")\\nplot2.set_titles(row_template=\"Author\\'s 100+ Comment: {row_name}\",col_template=\"WMF Affiliation: {col_name}\")\\nplot2.add_legend(title=\"Comment publication timestamp:\")\\n#plot2.add_legend(title=\"Before/After 07/01/2013 Wide Release\")\\n\\nplot3 = sns.lmplot(data=comment_phab_df, x=\"date_created\", y=\"valence_wc\", hue=\"date_group\", col=\"meta.affil\", row=\\'engaged_commenter\\', scatter=False, legend=False, palette=palette)\\nplot3.set_axis_labels(\"Timestamp\", \"Count of Valence Polarized Words\")\\nplot3.set_titles(row_template=\"Author\\'s 100+ Comment: {row_name}\",col_template=\"WMF Affiliation: {col_name}\")\\nplot3.add_legend(title=\"Comment publication timestamp:\")\\n'"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAABR4AAAHaCAYAAABmaVX2AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8ekN5oAAAACXBIWXMAAA9hAAAPYQGoP6dpAACxkElEQVR4nOzdd3gUVdsG8Hu2pCcbEtKQQIBQQu8SUKkSirw0pSoEQVQ6SP0USbCAShUVeWkBBQSkiEhTXhIU6UgUCVFCCSUQIL1nd+b7Y5MhmwK7ySabcv+uay92z8yeeXaZZLLPPuccQZIkCURERERERERERERmpLB0AERERERERERERFT5MPFIREREREREREREZsfEIxEREREREREREZkdE49ERERERERERERkdkw8EhERERERERERkdkx8UhERERERERERERmx8QjERERERERERERmR0Tj0RERERERERERGR2TDwSERERERERERGR2THxSCbp0qULpk2b9sR9fHx8sGLFCvmxIAjYu3evUf2bsq8pjIm7NFn6+CURGBiIAQMGlFr/oaGh8PHxKbX+y4OgoCB4eHgYnN/52/K/z/nPmfw/V8Vlrn7KUkhICJydnS0dBpHZ8FpaMY9fEryWlhyvpURERBUTE48VVGBgIARBKHDr1auXUc8vyz+YYmJi0Lt37zI5Vkmlp6fDxcUF1atXR2ZmpsnPDw0NhSAISEhIMH9wJeDj41PgXKlZs6alwzLK119/DUdHR2i1WrktJSUFarUaXbp0Mdg39/2PiooC8Ph1f/fddwX6bdKkCQRBQEhIiNxW3Pfp9u3bsLKyQtOmTQtsi4iIQHBwMNasWSP/LBTWtnLlSoNY8jt79izGjx//1FhyFZWsM7Ufcynqd9bVq1fLPBaiXLyWlg5eS8sfXkv1KvK1tLDfVXlvQUFBZRoPERGRsZh4rMB69eqFmJgYg9u2bdssHVYBnp6esLa2tnQYRtm1axeaNGmCRo0alUq1iDllZWWZtP/ChQsNzpU//vijlCIzr65duyIlJQXnzp2T23799Vd4enri9OnTyMjIkNuPHTuGWrVqoV69enKbt7c3Nm7caNDnqVOncO/ePdjb2xc4XnHep5CQEAwZMgRJSUk4ffq0wbbcD279+/eXfxYKa9NoNE+s6nNzc4Odnd1TY3kac/VTHIX9zqpTp45FYiHKxWup+fFaWv7wWqpXka+led/PFStWwMnJyaBt5syZ8r6SJBkkmYmIiCyJiccKzNraGp6enga3atWqAdD/wREUFIRatWrB2toaNWrUwJQpUwDoh53cvHkT06dPl78lBYBHjx5h+PDheOaZZ2BnZ4dmzZoV+uFLq9Vi0qRJ0Gg0qF69OubPnw9JkoqMM++QmKysLEyaNAleXl6wsbFB7dq1sWjRIoP9Hz58iIEDB8LOzg7169fHvn37DLZfunQJvXv3hoODAzw8PPDaa6/h4cOH8vbU1FSMGjUKDg4O8PLywtKlS41+T9evX49XX30Vr776KtavX2+w7caNGxAEARcvXpTbEhISIAgCQkNDcePGDXTt2hUAUK1aNQiCgMDAQHlfURQxe/ZsuLi4wNPTs8A309HR0ejfvz8cHBzg5OSEIUOG4P79+/L2oKAgtGzZEuvWrUOdOnVgY2Nj9OsCAEdHR4Nzxc3NDTqdDmPHjkWdOnVga2uLhg0bYuXKlU/s5/vvv0ezZs1ga2sLV1dX9OjRA6mpqfL2devWwc/PDzY2NmjUqBG++uork+LMr2HDhvDy8kJoaKjcFhoaiv79+6NOnTo4deqUQXvu/0GukSNHIiwsDLdu3ZLbNmzYgJEjR0KlUhU4XmHv05NIkoSNGzfitddew4gRIwzOm6CgIPTr1w8AoFAo5IqE/G3A04fh5a+sWrZsGZo1awZ7e3t4e3tjwoQJSElJkd+HMWPGIDExsUAlRP5+jD3vvvnmG/j4+ECj0WDYsGFITk5+4vtSmMJ+ZymVyie+lsKEh4eja9eucHR0hJOTE9q0aWPwYfq3337D888/D1tbW3h7e2PKlCkG5yhRXryW8lpqCl5LeS0trJ+yuJbmfT81Gg0EQZAfX7lyBY6Ojjh48CDatGkDa2tr/Pbbb4W+H9OmTTOochVFEYsWLZLP3xYtWuD77783Oi4iIqKnYeKxktq1axeWL1+ONWvW4N9//8XevXvRrFkzAMDu3btRs2ZNg2+jASAjIwNt2rTBTz/9hEuXLmH8+PF47bXXcObMGYO+N23aBJVKhTNnzmDlypVYtmwZ1q1bZ1Rcn3/+Ofbt24cdO3YgMjISW7ZsKTAnUXBwMIYMGYI///wTffr0wciRIxEXFwdA/+GkW7duaNWqFc6dO4dDhw7h/v37GDJkiPz8WbNmISwsDD/88AOOHDmC0NBQXLhw4amxRUVF4eTJkxgyZAiGDBmCX3/9FTdv3jTqdQH6aoBdu3YBACIjIxETE2PwwWPTpk2wt7fH6dOn8emnn2LhwoX4+eefAej/6Ovfvz/i4uIQFhaGn3/+GdeuXcPQoUMNjnH16lXs2rULu3fvlj+0BQYGFhgmZSxRFFGzZk3s3LkTly9fxvvvv4//+7//w44dOwrdPyYmBsOHD8frr7+OiIgIhIaGYtCgQfKH5S1btuD999/HRx99hIiICHz88ceYP38+Nm3aVKz4cnXt2hXHjh2THx87dgxdunRB586d5fb09HScPn26wIclDw8PBAQEyDGkpaVh+/bteP3110sUU95Y0tLS0KNHD7z66qv47rvv5A+PM2fOlCtE8lYk5G8rDoVCgc8//xx///03Nm3ahP/973+YPXs2AKBjx44FqiHyVkLkMva8i4qKwt69e7F//37s378fYWFhWLx4sbw9JCRE/tBn7tdSmJEjR6JmzZo4e/Yszp8/j7lz50KtVsux9urVC4MHD8aff/6J7du347fffsOkSZOKHR9VXbyW8lpqDF5LS47X0pJfSwFg7ty5WLx4MSIiItC8eXOjnrNo0SJs3rwZX3/9Nf7++29Mnz4dr776KsLCwkoUCxERkUyiCmn06NGSUqmU7O3tDW4fffSRJEmStHTpUqlBgwZSVlZWoc+vXbu2tHz58qcep2/fvtI777wjP+7cubPk5+cniaIot82ZM0fy8/Mrsm8A0p49eyRJkqTJkydL3bp1M3h+XgCk9957T36ckpIiAZAOHjwoSZIkffDBB1LPnj0NnnPr1i0JgBQZGSklJydLVlZW0o4dO+Ttjx49kmxtbaWpU6c+8bX+3//9nzRgwAD5cf/+/aUFCxbIj69fvy4BkP744w+5LT4+XgIgHTt2TJIkSTp27JgEQIqPjzfou3PnztJzzz1n0NauXTtpzpw5kiRJ0pEjRySlUilFR0fL2//++28JgHTmzBlJkiRpwYIFklqtlmJjYw36mTt3rvTaa6898bXVrl1bsrKyMjhXVq5cWei+EydOlAYPHiw/Hj16tNS/f39JkiTp/PnzEgDpxo0bhT63Xr160tatWw3aPvjgA8nf37/I2I4dOybVrl37ifGvXbtWsre3l7Kzs6WkpCRJpVJJsbGx0tatW6UXXnhBkiRJOnr0qARAunnzpsHrXr58ubR3716pXr16kiiK0qZNm6RWrVpJkiRJGo1G2rhxo8H+xr5PuUaMGCFNmzZNftyiRQuDPvfs2SPl/1VbWFve91mS9OdM3nP2aT+zO3fulFxdXeXHGzdulDQaTYH98vZj7HlnZ2cnJSUlyfvMmjVLevbZZ+XHu3fvlho2bFhkbLmvL//vrJdffrlYr8XR0VEKCQkp9Lljx46Vxo8fb9D266+/SgqFQkpPT39ijFT18Fr6GK+lvJZKEq+l5f1aWlRcuT8ze/fuNdgv//shSZI0depUqXPnzpIkSVJGRoZkZ2cn/f777wb7jB07Vho+fLhRsRARET1NwbERVGF07doVq1evNmhzcXEBALzyyitYsWIF6tati169eqFPnz7o169focNhcul0Onz88cfYsWMH7ty5g6ysLGRmZhaYw6ZDhw4G38j6+/tj6dKl0Ol0UCqVT4w5MDAQL774Iho2bIhevXrhpZdeQs+ePQ32yfsNrb29PZycnBAbGwtAP8Ty2LFjcHBwKNB3VFQU0tPTkZWVhWeffdbgPWnYsOET49LpdNi0aZNBVcWrr76KmTNn4v3334dCUfLi4PzfPHt5ecmvKyIiAt7e3vD29pa3N27cGM7OzoiIiEC7du0AALVr1y4wXCn/8LqizJo1y2C4WvXq1QEAX375JTZs2IDo6Gj5/WvZsmWhfbRo0QLdu3dHs2bNEBAQgJ49e+Lll19GtWrVkJqaiqioKIwdOxZvvPGG/BytVguNRmNUjEXp0qULUlNTcfbsWcTHx6NBgwZwc3ND586dMWbMGGRkZCA0NBR169ZFrVq1Cjy/b9++ePPNN3H8+HFs2LDhiRUaRb1PhUlISMDu3bvx22+/yW25Qwvz9lEafvnlFyxatAhXrlxBUlIStFotMjIykJaWZvS8U8aedz4+PnB0dJT3yXvuAsDAgQMxcODApx4v/++s3HnBTH0tM2bMwLhx4/DNN9+gR48eeOWVV+S5yMLDw/Hnn39iy5Yt8v6SJEEURVy/fh1+fn5GvTdUdfBaaojX0ifjtZTX0vzK+lr6JG3btjVp/6tXryItLQ0vvviiQXtWVhZatWpVoliIiIhyMfFYgdnb28PX17fQbd7e3oiMjMQvv/yCn3/+GRMmTMBnn32GsLAweUhifp999hlWrlyJFStWyPPdTJs2zeSJ15+kdevWuH79Og4ePIhffvkFQ4YMQY8ePQzmkskfnyAIEEURgH4Fxn79+uGTTz4p0LeXl1exV8g9fPgw7ty5U2BYjE6nw9GjR/Hiiy/KH5ikPHNwZWdnG32MJ70uYxU2gbuxqlevXuB8+e677zBz5kwsXboU/v7+cHR0xGeffVZgUvdcSqUSP//8M37//XccOXIEq1atwrvvvovTp0/Lf6CvXbvW4MNq7vNKwtfXFzVr1sSxY8cQHx+Pzp07AwBq1KgBb29v/P777zh27Bi6detW6PNVKhVee+01LFiwAKdPn8aePXuKPFZh71NRtm7dioyMDIPXm5vk+ueff9CgQQMTXqXxbty4gZdeeglvv/02PvroI7i4uOC3337D2LFjkZWVZfYJ781x7gKF/84qzmsJCgrCiBEj8NNPP+HgwYNYsGABvvvuOwwcOBApKSl488035Xn48irsgzQRr6WGeC19Ml5LeS0tLnNdS58k/7mtUCgKzB2b9+ctdz7Ln376Cc8884zBfhVlMSsiIir/OMdjJWZra4t+/frh888/R2hoKE6ePIm//voLAGBlZQWdTmew/4kTJ9C/f3+8+uqraNGiBerWrYt//vmnQL/5/5A+deoU6tevb/QfxE5OThg6dCjWrl2L7du3Y9euXfK8U0/TunVr/P333/Dx8YGvr6/Bzd7eHvXq1YNarTaIMT4+vtDXkdf69esxbNgwXLx40eA2bNgweYLz3OqIvPMI5Z0cH9C/rwAKvLdP4+fnh1u3bhlM2n758mUkJCSgcePGJvVlihMnTqBjx46YMGECWrVqBV9fX3mVyKIIgoBOnTohODgYf/zxB6ysrLBnzx54eHigRo0auHbtWoH/G3OsXNy1a1eEhoYiNDTUYB6uF154AQcPHsSZM2cKzEmV1+uvv46wsDD0799fXjiipNavX4933nnH4JwJDw/H888/jw0bNpjlGIU5f/48RFHE0qVL0aFDBzRo0AB379412Kewn/H8LHXe5WXMaylMgwYNMH36dBw5cgSDBg2S5/pq3bo1Ll++XOAc9PX1lX8+iUzBa6ker6VF47W0ZHgtLT1ubm4F5r/M+/PWuHFjWFtbIzo6usD5lreCk4iIqCRY8ViBZWZm4t69ewZtKpUK1atXR0hICHQ6HZ599lnY2dnh22+/ha2tLWrXrg1AP9zj+PHjGDZsGKytrVG9enXUr18f33//PX7//XdUq1YNy5Ytw/379wv80RQdHY0ZM2bgzTffxIULF7Bq1SqjV7tctmwZvLy80KpVKygUCuzcuROenp5wdnY26vkTJ07E2rVrMXz4cHlVy6tXr+K7777DunXr4ODggLFjx2LWrFlwdXWFu7s73n333ScO73rw4AF+/PFH7Nu3D02bNjXYNmrUKAwcOBBxcXFwcXFBhw4dsHjxYtSpUwexsbF47733DPavXbs2BEHA/v370adPH9ja2hY6lC2/Hj16oFmzZhg5ciRWrFgBrVaLCRMmoHPnzk8dNjNv3jzcuXMHmzdvfupx8qtfvz42b96Mw4cPo06dOvjmm29w9uzZIj/cnD59GkePHkXPnj3h7u6O06dP48GDB/Lw1eDgYEyZMgUajQa9evVCZmYmzp07h/j4eMyYMcPk+PLq2rUrJk6ciOzsbLlKAwA6d+6MSZMmISsr64kflvz8/PDw4UOzVTBcvHgRFy5cwJYtW9CoUSODbcOHD8fChQvx4YcfmuVY+fn6+iI7OxurVq1Cv379cOLECXz99dcG+/j4+CAlJQVHjx5FixYtYGdnV+C1l+S8y2vPnj2YN28erly5UiqvJa/09HTMmjULL7/8MurUqYPbt2/j7NmzGDx4MABgzpw56NChAyZNmoRx48bB3t4ely9fxs8//4wvvvjC5Pio8uO1lNdSgNdSXksr9rW0KN26dcNnn32GzZs3w9/fH99++y0uXbokD6N2dHTEzJkzMX36dIiiiOeeew6JiYk4ceIEnJycMHr0aLPFQkREVRcrHiuwQ4cOwcvLy+D23HPPAQCcnZ2xdu1adOrUCc2bN8cvv/yCH3/8Ea6urgCAhQsX4saNG6hXr55cffDee++hdevWCAgIQJcuXeDp6YkBAwYUOO6oUaOQnp6O9u3bY+LEiZg6dSrGjx9vVMyOjo749NNP0bZtW7Rr1w43btzAgQMHjJ73qUaNGjhx4gR0Oh169uyJZs2aYdq0aXB2dpb7+Oyzz/D888+jX79+6NGjB5577jm0adOmyD43b94Me3t7dO/evcC27t27w9bWFt9++y0AYMOGDdBqtWjTpg2mTZtW4I/hZ555BsHBwZg7dy48PDyMXklXEAT88MMPqFatGl544QX06NEDdevWxfbt25/63JiYGERHRxt1nPzefPNNDBo0CEOHDsWzzz6LR48eYcKECUXu7+TkhOPHj6NPnz5o0KAB3nvvPSxduhS9e/cGAIwbNw7r1q3Dxo0b0axZM3Tu3BkhISFmq9JIT0+Hr68vPDw85PbOnTsjOTkZDRs2hJeX1xP7cHV1ha2tbYljAfQVGo0bNy7wQQnQz9MUGxuLAwcOmOVY+bVo0QLLli3DJ598gqZNm2LLli0F5ifr2LEj3nrrLQwdOhRubm749NNPC/RTkvMur8TERERGRpbaa8lLqVTi0aNHGDVqFBo0aIAhQ4agd+/eCA4OBqCf/y0sLAz//PMPnn/+ebRq1Qrvv/8+atSoUaz4qPLjtZTXUoDXUl5LK/a1tCgBAQGYP38+Zs+ejXbt2iE5ORmjRo0y2OeDDz7A/PnzsWjRIvj5+aFXr1746aefzHK+ERERAYAg5Z/4g4ioDIWGhiIwMBA3btywdChEREQVEq+lREREVF6x4pGIiIiIiIiIiIjMjolHIiIiIiIiIiIiMjsmHonIonx8fDBt2jRLh0FERFRh8VpKRERE5RXneCQiIiIiIiIiIiKzY8UjERERERERERERmR0Tj0RERERERERERGR2lT7xKEkSkpKSwBHlREREpuE1lIiIiIiISqLSJx6Tk5Oh0WiQnJxs6VCIiIgqFF5DiYiIiIioJCp94pGIiIiIiIiIiIjKHhOPREREREREREREZHZMPBIREREREREREZHZWTTxGBQUBEEQDG6NGjWSt2dkZGDixIlwdXWFg4MDBg8ejPv371swYiIiIiIiIiIiIjKGxSsemzRpgpiYGPn222+/ydumT5+OH3/8ETt37kRYWBju3r2LQYMGWTBaIiIiIiIiIiIiMobK4gGoVPD09CzQnpiYiPXr12Pr1q3o1q0bAGDjxo3w8/PDqVOn0KFDh7IOlYiIiIiIiIiIiIxk8YrHf//9FzVq1EDdunUxcuRIREdHAwDOnz+P7Oxs9OjRQ963UaNGqFWrFk6ePGmpcImIiIiIiIiIiMgIFq14fPbZZxESEoKGDRsiJiYGwcHBeP7553Hp0iXcu3cPVlZWcHZ2NniOh4cH7t27V2SfmZmZyMzMlB8nJSWVVvhERESVCq+hRERERERkThZNPPbu3Vu+37x5czz77LOoXbs2duzYAVtb22L1uWjRIgQHB5srRCIioiqD11AiIiIiIjIniw+1zsvZ2RkNGjTA1atX4enpiaysLCQkJBjsc//+/ULnhMw1b948JCYmyrdbt26VctRERESVA6+hRERERERkTuUq8ZiSkoKoqCh4eXmhTZs2UKvVOHr0qLw9MjIS0dHR8Pf3L7IPa2trODk5GdyIiIjo6XgNJSIiIiIic7LoUOuZM2eiX79+qF27Nu7evYsFCxZAqVRi+PDh0Gg0GDt2LGbMmAEXFxc4OTlh8uTJ8Pf354rWRERERERERERE5ZxFE4+3b9/G8OHD8ejRI7i5ueG5557DqVOn4ObmBgBYvnw5FAoFBg8ejMzMTAQEBOCrr76yZMhERERERERERERkBEGSJMnSQZSmpKQkaDQaJCYmcsgYERGRCXgNJSIiIiKikihXczwSERERERERERFR5cDEIxEREREREREREZkdE49ERERERERERERkdkw8EhERERERERERkdkx8UhERERERFRFVPK1RYmIqJxh4pGIiIiIiKiKYN6RiIjKEhOPREREREREVYQEZh6JiKjsMPFIRERERERUBXCYNRERlTUmHomIiIiIiKoA5h2JiKisMfFIREREREREREREZsfEIxERERERURXA+R2JiKisMfFIRERERERUFTDvSEREZYyJRyIiIiIioiqAFY9ERFTWmHgkIiIiIiKqAri4DBERlTUmHomIiIiIiKoEZh6JiKhsMfFIREREREREREREZsfEIxERERERURXAodZERFTWmHgkIiIiIiKqAri4DBERlTUmHomIiIiIiKoAVjwSEVFZY+KRiIiIiIioSmDmkYiIyhYTj0RERERERFUAKx6JiKisMfFIRERERERUBXCORyIiKmtMPBIREREREREREZHZMfFIRERERERUFbDgkYiIyhgTj0RERERERFUAh1oTEVFZY+KRiIiIiIioCuDiMkREVNaYeCQiIiIiIqoCWPFIRERljYlHIiIiIiIiIiIiMjsmHomIiIiIiKoCFjwSEVEZY+KRiIiIiIioCuBQayIiKmtMPBIREREREVUBXFyGiIjKGhOPREREREREVQIzj0REVLaYeCQiIiIiIqoCWPFIRERljYlHIiIiIiIiIiIiMjsmHomIiIiIiKoALi5DRERljYlHIiIiIiKiKoBDrYmIqKwx8UhERERERERERERmx8QjERERERFRFSCx5JGIiMoYE49ERERERERVANOORERU1ph4JCIiIiIiIiIiIrNj4pGIiIiIiKgq4FBrIiIqY0w8EhERERERVQFMOxIRUVlj4pGIiIiIiKgK4OIyRERU1ph4JCIiIiIiIiIiIrNj4pGIiIiIiIiIiIjMjolHIiIiIiKiKoBDrYmIqKwx8UhERERERFQFMO1IRERljYlHIiIiIiKiKkCSJFY9EhFRmWLikYiIiIiIqIqQJK2lQyAioiqEiUciIiIiIqIqQJIkiFK2pcMgIqIqhIlHIiIiIiKiKkACIEGEJImWDsUoFSVOIiIqGhOPREREREREVYhYQYZbV5Q4iYioaEw8EhERERERVQU5C8tIks7CgTydPunIikciooqOiUciIiIiIqJKLu9q1hIqQOJRzLJ0CEREZAZMPBIREREREVVyefKOFaLiUScx8UhEVBkw8UhERERERFSFlPfEoyRJrHgkIqokmHgkIiIiIiKq5CQ8Lnks74u2iFI2kCdeIiKquJh4JCIiIiIiquwkwweSVH4XbhE5zJqIqNJg4pGIiIiIiKiSk/JVEJbn4db6ikciIqoMmHgkIiIiIiKq5KR8I5fL68rW+vkdmXgkIqosmHgkIiIiIiKq9Awzj+V1nkdJ0oLzOxIRVR5MPBIREREREVUx5XWoNed3JCKqXMpN4nHx4sUQBAHTpk2T2zIyMjBx4kS4urrCwcEBgwcPxv379y0XJBERERERUQVUYKh1uU08ls9KTCIiKp5ykXg8e/Ys1qxZg+bNmxu0T58+HT/++CN27tyJsLAw3L17F4MGDbJQlERERERERBVTgcVlyukcj6x4JCKqXCyeeExJScHIkSOxdu1aVKtWTW5PTEzE+vXrsWzZMnTr1g1t2rTBxo0b8fvvv+PUqVMWjJiIiIiIiKhiKVjxKEKSRMsEUwRR0pW7mIiIqGQsnnicOHEi+vbtix49ehi0nz9/HtnZ2QbtjRo1Qq1atXDy5Mki+8vMzERSUpLBjYiIiJ6O11Aiosqs4IIt5a3qUZK4mjURUWVj0cTjd999hwsXLmDRokUFtt27dw9WVlZwdnY2aPfw8MC9e/eK7HPRokXQaDTyzdvb29xhExERVUq8hhIRVV75Kx71beUr8cj5HYmIKh+LJR5v3bqFqVOnYsuWLbCxsTFbv/PmzUNiYqJ8u3Xrltn6JiIiqsx4DSUiqrzyz/EIlL/Eo8TEIxFRpaOy1IHPnz+P2NhYtG7dWm7T6XQ4fvw4vvjiCxw+fBhZWVlISEgwqHq8f/8+PD09i+zX2toa1tbWpRk6ERFRpcRrKBFR1SKWs8RjeYuHiIhKzmKJx+7du+Ovv/4yaBszZgwaNWqEOXPmwNvbG2q1GkePHsXgwYMBAJGRkYiOjoa/v78lQiYiIiIiIqqYCh1qXX4qDCVJKlfxEBGReVgs8ejo6IimTZsatNnb28PV1VVuHzt2LGbMmAEXFxc4OTlh8uTJ8Pf3R4cOHSwRMhERERERUYVU6FDrcrS4jMiFZYiIKiWLJR6NsXz5cigUCgwePBiZmZkICAjAV199ZemwiIiIiIiIKpTCF5cRIUkiBMGia47mxMLEIxFRZSRIUmGXoMojKSkJGo0GiYmJcHJysnQ4REREFQavoURElUdyejqSUtPgqlFDktLldmu1CxSC2oKR6WVkPyow1NpKpYFSYb6FSImIqOxZ/qstIiIiIiIisghJEi0dAkQpm/M7EhFVUkw8EhERERERVXZFjHMTy0HCTxSzLB0CERGVEiYeiYiIiIiIKrnCFpcBAFGyfNKPC8sQEVVeTDwSERERERFVckXN7F8ehjgz8UhEVHkx8UhERERERFTpFZ551K9srSvjWB4TJW25mGeSiIhKBxOPRERERERElVxRFY8AIFoy8Siy2pGIqDJj4pGIiIiIiKgKs+Rw6/IwxyQREZUeJh6JiIiIiIgquaIWl9Fvs+xQayIiqryYeCQiIiIiIqrknjTU2lJzPOrnl2TikYioMmPikYiIiIiIqAqz1ByPHGZNRFT5MfFIRERERERUhVmq4lGUuLAMEVFlx8QjERERERFRJSc9aaw1JIskH7miNRFR5cfEIxERERERUSX3pLQjUPbDrSVJ4sIyRERVABOPREREREREld0TKx5R5ou86IdZPy0dSkREFR0Tj0RERERERJXc0yseLZF4JCKiyo6JRyIiIiIiokruyXM8ln0ikIlHIqKqgYlHIiIiIiKiKk6StE9NTpr3eEw8EhFVBUw8EhERERERUZnN8yhKWkiSWCbHIiIiy2LikYiIiIiIqJIzppqxrOZ5FEVWOxIRVRVMPBIREREREVVyxgyillBWFY9ZZXIcIiKyPCYeiYiIiIiIKjljKh4lSVcGkTDxSERUlTDxSERERERERBDLIPEoStmc35GIqAoxOfGYnp6OtLQ0+fHNmzexYsUKHDlyxKyBERERERERUdkpi4pHUSyb4dxERFQ+mJx47N+/PzZv3gwASEhIwLPPPoulS5eif//+WL16tdkDJCIiIiIiopIxZqg1IJV61aMocWEZIqKqxOTE44ULF/D8888DAL7//nt4eHjg5s2b2Lx5Mz7//HOzB0hEREREREQlY0zaEQCkUl7ZurT7JyKi8sXkxGNaWhocHR0BAEeOHMGgQYOgUCjQoUMH3Lx50+wBEhERERERUQkZVfFYusOtJUmCyMQjEVGVYnLi0dfXF3v37sWtW7dw+PBh9OzZEwAQGxsLJycnswdIRERERERExWfcMGu90kwM6odZGx8LERFVfCYnHt9//33MnDkTPj4+ePbZZ+Hv7w9AX/3YqlUrswdIREREREREZUNC6VU8cn5HIqKqR2XqE15++WU899xziImJQYsWLeT27t27Y+DAgWYNjoiIiIiIiErGhILHUh1qLUpZpdY3ERGVTyYnHgHA09MTnp6eBm3t27c3S0BERERERERkPpIJw5slSQdJkiAIgtnjEEVWPBIRVTVGJR4HDRpkdIe7d+8udjBERERERERkZiZOqyhBCwFqs4agnzuS8zsSEVU1Rs3xqNFo5JuTkxOOHj2Kc+fOydvPnz+Po0ePQqPRlFqgREREREREZDpTKh6B0hluzWpHIqKqyaiKx40bN8r358yZgyFDhuDrr7+GUqkEAOh0OkyYMIGrWhMREREREZUzpszxCACipIPSzDFwfkcioqpJkCTTLkNubm747bff0LBhQ4P2yMhIdOzYEY8ePTJrgCWVlJQEjUaDxMREJkaJiIhMwGsoEVHlkK3VITYhAQDgqlFDktKfuL9SYQMrlflGs4lSNjKz40x+npVKA6XCxmxxEBFR2TNqqHVeWq0WV65cKdB+5coViKJolqCIiIiIiIjIXEwredTPx2g+OjHDrP0REVHFYfKq1mPGjMHYsWMRFRUlr2R9+vRpLF68GGPGjDF7gERERERERFR8pg61liQtJEmEIJhcp1Ionchh1kREVZXJicclS5bA09MTS5cuRUxMDADAy8sLs2bNwjvvvGP2AImIiIiIiKj4TF1cBtDPyagUSj7MWZJESGauoCQioorDpMSjVqvF1q1bMXr0aMyePRtJSUkAwHmfiIiIiIiIyilTKx4B/XBrcywwY+5h20REVLGYVDuvUqnw1ltvISNDP0eHk5MTk45ERERERESVjLmqFCUp2yz9EBFRxWTypB3t27fHH3/8URqxEBERERERkdkVZ6i1zixHFpl4JCKq0kye43HChAl45513cPv2bbRp0wb29vYG25s3b2624IiIiIiIiKhkijPU2lwLzDDxSERUtQmSZNplSKEoeOERBAGSJEEQBOh05vlmzFySkpKg0WiQmJjIYeFEREQm4DWUiKhySMvMRHxyCgDAVaOGJKUb9TwrlTOUCutiH1eSdMjIfljs51upNFAqSr7ADRERWY7JFY/Xr18vjTiIiIiIiIioNBSj4hHIXWCm+IlHnZRV7OcSEVHlYHLisXbt2qURBxEREREREZUjJV0YRhQzzRQJERFVVCYnHgEgKioKK1asQEREBACgcePGmDp1KurVq2fW4IiIiIiIiKhkpGKWPOrELHlKLZOPKYnQiax4JCKq6kyeKfjw4cNo3Lgxzpw5g+bNm6N58+Y4ffo0mjRpgp9//rk0YiQiIiIiIqJiKs7iMjnPhFjM4dKipEWxx3gTEVGlYXLF49y5czF9+nQsXry4QPucOXPw4osvmi04IiIiIiIiKpniVjwCgE7MLNYCM5KkLfYxiYio8jC54jEiIgJjx44t0P7666/j8uXLZgmKiIiIiIiIzKQEhYclq3gkIqKqzuTEo5ubGy5evFig/eLFi3B3dzdHTERERERERFQOSJIOkiSa/DyxhAvTEBFR5WDyUOs33ngD48ePx7Vr19CxY0cAwIkTJ/DJJ59gxowZZg+QiIiIiIiIiq8kQ60BffJREIyvWdEvSsOKRyIiKkbicf78+XB0dMTSpUsxb948AECNGjUQFBSEKVOmmD1AIiIiIiIiKr7iLy6jJ0ILBdRG768V00p2QCIiqjQESTLuMnTs2DF06tQJVlZWcltycjIAwNHRsXSiM4OkpCRoNBokJibCycnJ0uEQERFVGLyGEhFVDompqUhJzwAAuGrUkKR0k56vUFjBWlXN6P3Ts2JhjhWtrVQaKBU2Je6HiIgsx+iKx+7du8PGxgYdOnRA165d0a1bNzz77LNQqUwumiQiIiIiIqIyUuKKRzELOjHDqCSgKOlgjqQjERFVDkZP1HH9+nV8+eWXqFWrFtavX4/nn38ezs7OCAgIwOLFi3H69GmIoumTDhMREREREVHpKekcjwCgEzONOxYXlSEiojyMHmqd37Vr1xAaGorQ0FCEhYXh9u3bcHR0REJCgplDLBkOEyMiIioeXkOJiCqH+JQUpGXoE4fFGWqtJ8BG7QZBEIrcQ5JEZOuSoRMzihmpIQ61JiKq+Io9Trpu3bpQKpUQBAGCIGDv3r3IysoyZ2xERERERERUQiUdap3TC3RiBlRK20K3ipIOmdkPzXEgIiKqRExKPEZHRyM0NBTHjh1DaGgoHj58iI4dO+L555/H/v378eyzz5ZWnERERERERGRBOjH9CYlHFqEQEVFBRice69ati/j4eHTq1AkvvPAC3nzzTbRt25aLyxAREREREZVjxZxdqwBR0ha9TeTcjkREVJDRi8ukp+vnAVEoFFCpVFCr1VAqlaUWGBEREREREZWc+daYliBK2kITmSIXlSEiokIYnXiMiYnByZMn0adPH5w+fRp9+/ZFtWrV8NJLL2HJkiU4e/YsV7UmIiIiIiIqb8xU8QjoE4zZumSIYjYkSf/5TydmQXpCNSQREVVdxV7VGgAiIiLk+R6PHDkCAFzVmoiIqJLgNZSIqHJ4mJiEzGx9RWLxV7XOJSC3hlKhsIIABUQpG5KkK3mg+XBVayKiis/oisf87t+/jz///BN//vknwsPDkZSUhMzMTJP6WL16NZo3bw4nJyc4OTnB398fBw8elLdnZGRg4sSJcHV1hYODAwYPHoz79+8XN2QiIiIiIqIqx3z1joa9iWIWdGJGqSQdiYiocjA68RgbG4sdO3ZgwoQJ8PPzQ40aNTB69GhcvnwZw4YNw//+9z+Tqx1r1qyJxYsX4/z58zh37hy6deuG/v374++//wYATJ8+HT/++CN27tyJsLAw3L17F4MGDTLpGERERERERFWZuRaXISIiMpXRQ60VCgXUajXatm2Lrl27omvXrujYsSNsbW3NGpCLiws+++wzvPzyy3Bzc8PWrVvx8ssvAwCuXLkCPz8/nDx5Eh06dDCqPw4TIyIiKh5eQ4mIKofYhERka/VzMJZ8qHXZ4VBrIqKKT2XsjgcPHsRzzz0He3v7UglEp9Nh586dSE1Nhb+/P86fP4/s7Gz06NFD3qdRo0aoVavWExOPmZmZBkO+k5KSSiVeIiKiyobXUCKiyokVj0REZClGD7UOCAgolaTjX3/9BQcHB1hbW+Ott97Cnj170LhxY9y7dw9WVlZwdnY22N/DwwP37t0rsr9FixZBo9HIN29vb7PHTEREVBnxGkpEREREROZU7MVlzKVhw4a4ePEiTp8+jbffflueN7K45s2bh8TERPl269YtM0ZLRERUefEaSkRUObHekYiILMXoodalxcrKCr6+vgCANm3a4OzZs1i5ciWGDh2KrKwsJCQkGFQ93r9/H56enkX2Z21tDWtr69IOm4iIqNLhNZSIqHLiUGsiIrIUi1c85ieKIjIzM9GmTRuo1WocPXpU3hYZGYno6Gj4+/tbMEIiIiIiIiIiIiJ6GotWPM6bNw+9e/dGrVq1kJycjK1btyI0NBSHDx+GRqPB2LFjMWPGDLi4uMDJyQmTJ0+Gv7+/0StaExERERERVXWseCQiIksxKvH4+eefG93hlClTjN43NjYWo0aNQkxMDDQaDZo3b47Dhw/jxRdfBAAsX74cCoUCgwcPRmZmJgICAvDVV18Z3T8REREREVFVx7QjERFZiiAZ8fVXnTp1DB4/ePAAaWlp8tyLCQkJsLOzg7u7O65du1YqgRZXUlISNBoNEhMT4eTkZOlwiIiIKgxeQ4mIKoc7j+KAnI99rho1JCndwhEZx0qlgVJhY+kwiIioBIya4/H69evy7aOPPkLLli0RERGBuLg4xMXFISIiAq1bt8YHH3xQ2vESERERERGRKTjUmoiILMSoise86tWrh++//x6tWrUyaD9//jxefvllXL9+3awBlhSrNYiIiIqH11AioopPkiTcfRQnP2bFIxERlSWTV7WOiYmBVqst0K7T6XD//n2zBEVEREREREQlx2JHIiKyJJMTj927d8ebb76JCxcuyG3nz5/H22+/jR49epg1OCIiIiIiIio+iUvLEBGRBZmceNywYQM8PT3Rtm1bWFtbw9raGu3bt4eHhwfWrVtXGjESERERERERERFRBaMy9Qlubm44cOAA/vnnH1y5cgUA0KhRIzRo0MDswREREREREVEJsOCRiIgsyOTEYy4fHx9IkoR69epBpSp2N0RERERERFRKONSaiIgsyeSh1mlpaRg7dizs7OzQpEkTREdHAwAmT56MxYsXmz1AIiIiIiIiKh4uLkNERJZkcuJx3rx5CA8PR2hoKGxsbOT2Hj16YPv27WYNjoiIiIiIiEqCmUciIrIck8dI7927F9u3b0eHDh0gCILc3qRJE0RFRZk1OCIiIiIiIiIiIqqYTK54fPDgAdzd3Qu0p6amGiQiiYiIiIiIyLI41JqobHTp0gXTpk174j4+Pj5YsWKF/FgQBOzdu7dU4woJCYGzs3OpHqM8HpvKD5MTj23btsVPP/0kP85NNq5btw7+/v7mi4yIiIiIiIhKhIvLEADcu3cPkydPRt26dWFtbQ1vb2/069cPR48etXRopSY0NBSCICAhIcHSoRQpJiYGvXv3Nlt/+RObADB06FD8888/ZjtGeTz2kzD5aXkmD7X++OOP0bt3b1y+fBlarRYrV67E5cuX8fvvvyMsLKw0YiQiIiIiIqJiYMUj3bhxA506dYKzszM+++wzNGvWDNnZ2Th8+DAmTpyIK1euWDrEKsvT07PUj2FrawtbW9tSP055OzaVHyZXPD733HO4ePEitFotmjVrhiNHjsDd3R0nT55EmzZtSiNGIiIiIiIiKhZmHqu6CRMmQBAEnDlzBoMHD0aDBg3QpEkTzJgxA6dOnZL3i46ORv/+/eHg4AAnJycMGTIE9+/fl7cHBQWhZcuW2LBhA2rVqgUHBwdMmDABOp0On376KTw9PeHu7o6PPvrI4PiCIGDNmjV46aWXYGdnBz8/P5w8eRJXr15Fly5dYG9vj44dOxZYM+KHH35A69atYWNjg7p16yI4OBhardag33Xr1mHgwIGws7ND/fr1sW/fPgD6ZGvXrl0BANWqVYMgCAgMDCz0/cmtiNu7dy/q168PGxsbBAQE4NatW/I+gYGBGDBggMHzpk2bhi5duhi0abVaTJo0CRqNBtWrV8f8+fMhPSH7n3+o9e3btzF8+HC4uLjA3t4ebdu2xenTpwEAUVFR6N+/Pzw8PODg4IB27drhl19+kZ/bpUsX3Lx5E9OnT4cgCPLo1MIq/lavXo169erBysoKDRs2xDfffFMgrqLe28IYe+zinkMJCQkYN24c3Nzc4OTkhG7duiE8PFzeHh4ejq5du8LR0RFOTk5o06YNzp07h9DQUIwZMwaJiYlyXEFBQQCAb775Bm3btoWjoyM8PT0xYsQIxMbGyn3mVswePnwYrVq1gq2tLbp164bY2FgcPHgQfn5+cHJywogRI5CWlmbwXkyaNMmk86CyMznxCAD16tXD2rVrcebMGVy+fBnffvstmjVrZu7YiIiIiIiIiKiY4uLicOjQIUycOBH29vYFtucmhURRRP/+/REXF4ewsDD8/PPPuHbtGoYOHWqwf1RUFA4ePIhDhw5h27ZtWL9+Pfr27Yvbt28jLCwMn3zyCd577z05WZbrgw8+wKhRo3Dx4kU0atQII0aMwJtvvol58+bh3LlzkCQJkyZNkvf/9ddfMWrUKEydOhWXL1/GmjVrEBISUiAhFRwcjCFDhuDPP/9Enz59MHLkSMTFxcHb2xu7du0CAERGRiImJgYrV64s8n1KS0vDRx99hM2bN+PEiRNISEjAsGHDTHqvAWDTpk1QqVQ4c+YMVq5ciWXLlmHdunVGPTclJQWdO3fGnTt3sG/fPoSHh2P27NkQRVHe3qdPHxw9ehR//PEHevXqhX79+iE6OhoAsHv3btSsWRMLFy5ETEwMYmJiCj3Onj17MHXqVLzzzju4dOkS3nzzTYwZMwbHjh0z2K+o97Ywxh4bKN459Morr8gJv/Pnz6N169bo3r27HM/IkSNRs2ZNnD17FufPn8fcuXOhVqvRsWNHrFixAk5OTnJcM2fOBABkZ2fjgw8+QHh4OPbu3YsbN24UmpwOCgrCF198gd9//x23bt3CkCFDsGLFCmzduhU//fQTjhw5glWrVhk852nnQVBQEHx8fIp8jyodyURdu3aVgoKCCrTHxcVJXbt2NbW7UpeYmCgBkBITEy0dChERUYXCaygRUcWXlpEp3X7wUL6lZyVKaZn3KsRNq0u39NtX4Z0+fVoCIO3evfuJ+x05ckRSKpVSdHS03Pb3339LAKQzZ85IkiRJCxYskOzs7KSkpCR5n4CAAMnHx0fS6XRyW8OGDaVFixbJjwFI7733nvz45MmTEgBp/fr1ctu2bdskGxsb+XH37t2ljz/+2CDGb775RvLy8iqy35SUFAmAdPDgQUmSJOnYsWMSACk+Pv6Jr33jxo0SAOnUqVNyW0REhARAOn36tCRJkjR69Gipf//+Bs+bOnWq1LlzZ/lx586dJT8/P0kURbltzpw5kp+fn/y4du3a0vLlyw1ew549eyRJkqQ1a9ZIjo6O0qNHj54Yb15NmjSRVq1aVWT/ua9Po9HIjzt27Ci98cYbBvu88sorUp8+fQzietJ7Wxhjjl2cc+jXX3+VnJycpIyMDIO+69WrJ61Zs0aSJElydHSUQkJCCo0rfwxFOXv2rARASk5OliTp8fnzyy+/yPssWrRIAiBFRUXJbW+++aYUEBAgPzbmPFi1apXUrVu3p8ZUWZhc8RgaGoovvvgCAwYMQGpqqtyelZXFOR6JiIiIiIjKES4uU7VJRg7vjIiIgLe3N7y9veW2xo0bw9nZGREREXKbj48PHB0d5cceHh5o3LgxFAqFQVveIasA0Lx5c4PtAAxGTXp4eCAjIwNJSUkA9ENnFy5cCAcHB/n2xhtvICYmxmBYa95+7e3t4eTkVODYxlCpVGjXrp38uFGjRgVeuzE6dOggDzMGAH9/f/z777/Q6XRPfe7FixfRqlUruLi4FLo9JSUFM2fOhJ+fH5ydneHg4ICIiAi54tFYERER6NSpk0Fbp06dCrxWc723+Zl6DoWHhyMlJQWurq4G58P169fl4fkzZszAuHHj0KNHDyxevLjAsP3CnD9/Hv369UOtWrXg6OiIzp07A0CB9zP/uWtnZ4e6desWGmuup50HkyZNqtQLO+Vn8uIyAPDLL7/gzTffRIcOHfDjjz9WrRJRIiIiIiKiioJ5xyqtfv36EATBbAvIqNVqg8eCIBTaljs8uLDn5SZkCmvLO6w4ODgYgwYNKhCDjY3NE+PJf2xzUCgUBZK42dnZZj3G0xZhmTlzJn7++WcsWbIEvr6+sLW1xcsvv4ysrCyzxpGrtN5bU8+hlJQUeHl5ITQ0tEBfuVMFBAUFYcSIEfjpp59w8OBBLFiwAN999x0GDhxYaAypqakICAhAQEAAtmzZAjc3N0RHRyMgIKDA+5n/PC2rc64yKdYcj15eXggLC0OzZs3Qrl27Qk8AIiIiIiIisixWPFZtLi4uCAgIwJdffmkwYjFXQkICAMDPzw+3bt0yWFDl8uXLSEhIQOPGjcsqXFnr1q0RGRkJX1/fAre8lXFPYmVlBQBGVRtqtVqcO3dOfhwZGYmEhAT4+fkBANzc3ArMW3jx4sUC/eSf2/LUqVOoX78+lErlU2No3rw5Ll68WOQ8iidOnEBgYCAGDhyIZs2awdPTEzdu3DDYx8rK6qmv18/PDydOnCjQd0n/n405dnG0bt0a9+7dg0qlKnAuVK9eXd6vQYMGmD59Oo4cOYJBgwZh48aNRcZ15coVPHr0CIsXL8bzzz+PRo0amaWaM1dJzoPKyOTEY+43EdbW1ti6dSumTp2KXr164auvvjJ7cERERERERERUfF9++SV0Oh3at2+PXbt24d9//0VERAQ+//xz+Pv7AwB69OiBZs2aYeTIkbhw4QLOnDmDUaNGoXPnzmjbtm2Zx/z+++9j8+bNCA4Oxt9//42IiAh89913eO+994zuo3bt2hAEAfv378eDBw+QkpJS5L5qtRqTJ0/G6dOncf78eQQGBqJDhw5o3749AKBbt244d+4cNm/ejH///RcLFizApUuXCvQTHR2NGTNmIDIyEtu2bcOqVaswdepUo+IdPnw4PD09MWDAAJw4cQLXrl3Drl27cPLkSQD66tXdu3fj4sWLCA8Px4gRIwpU2vn4+OD48eO4c+cOHj58WOhxZs2ahZCQEKxevRr//vsvli1bht27d8uLrhSXMccujh49esDf3x8DBgzAkSNHcOPGDfz+++949913ce7cOaSnp2PSpEkIDQ3FzZs3ceLECZw9e1ZOGvv4+CAlJQVHjx7Fw4cPkZaWhlq1asHKygqrVq3CtWvXsG/fPnzwwQdmi/lp58EXX3yB7t27m+145Z3Jicf85cXvvfcetmzZgqVLl5otKCIiIiIiIio5I6f4o0qsbt26uHDhArp27Yp33nkHTZs2xYsvvoijR49i9erVAPQFRj/88AOqVauGF154AT169EDdunWxfft2i8QcEBCA/fv348iRI2jXrh06dOiA5cuXo3bt2kb38cwzzyA4OBhz586Fh4eHwarZ+dnZ2WHOnDkYMWIEOnXqBAcHB4PXHhAQgPnz52P27Nlo164dkpOTMWrUqAL9jBo1Cunp6Wjfvj0mTpyIqVOnYvz48UbFa2VlhSNHjsDd3R19+vRBs2bNsHjxYrlKbtmyZahWrRo6duyIfv36ISAgAK1btzboY+HChbhx4wbq1asHNze3Qo8zYMAArFy5EkuWLEGTJk2wZs0abNy4EV26dDEqzqIYc+ziEAQBBw4cwAsvvIAxY8agQYMGGDZsGG7evAkPDw8olUo8evQIo0aNQoMGDTBkyBD07t0bwcHBAICOHTvirbfewtChQ+Hm5oZPP/0Ubm5uCAkJwc6dO9G4cWMsXrwYS5YsMVvMTzsPHj58aNQ8lJWFIBk722yOmzdvwtvbu0B586VLl3D+/HmMHj3arAGWVFJSEjQaDRITE+Hk5GTpcIiIiCoMXkOJiCq+5PR0JKXqF+OQJB2g+gsudo0hCMWadatMWak0UCpsnr4jUQmEhIRg2rRp8rBzopLo0qULWrZsiRUrVlg6lHLD5MVlivqGoWnTpmjatGmJAyIiIiIiIiIzySkzkSQRD9N2IS37T6RmtIK3S78KkXwkIqKKzajE46BBgxASEgInJ6dCV5XKa/fu3WYJjIiIiIiIiEomd3GZpMxfkZb9JwDgUeofECUdarv2hyBUzcUOiIiobBiVeNRoNPKiMhqNplQDIiIiIiIiIvPInVjL0fpZpGf/g0zdTQBAfNqfkCQtalcfBIVg8kA4okojMDAQgYGBlg6DKonQ0FBLh1DumDTHoyRJuHXrFtzc3GBra1uacZkN56ciIiIqHl5DiYgqvsTUNKSkpwMARCkLCZlbkJzxeFEDJ9sGqFN9SLlMPnKORyKiis+kST0kSYKvry9u375dWvEQERERERGR2TyuM1EIVqjnNgaONr5yW1L6P7j2YBtEMdsSwRERUSVnUuJRoVCgfv36ePToUWnFQ0RERERERGaSf3ybQqFGXbdh0Ng2lNuSM6IQ9WALdGJmGUdHRESVncnLmC1evBizZs3CpUuXSiMeIiIiIiIiKkUKQYU61YfA2a6J3JaSeQNRD76FTsywYGRERFTZmDTHIwBUq1YNaWlp0Gq1sLKyKjDXY1xcnFkDLCnOT0VERFQ8vIYSEVV88SkpSMt4XMnoqlFDkvRzPkqSDjcf/YD4tD/l7XZWNVDP7VWolHZlHmt+nOORiKjiM3kG4RUrVpRCGERERERERGRuTyozEQQlarsOgEJQ4VHqBQBAWtZdXI3dhHruo6BW2pdRlEREVFmZnHgcPXp0acRBREREREREZUwQFPB26QeFoMKDlDMAgPTs+7gaGwJf91FQKx0tHCFZSlBQEFavXo3Y2Fjs2bMHAwYMsHRIRFQBmTzHY14ZGRlISkoyuBEREREREVH5YMzMWoIg4JlqveHu2FFuy8h+gH/vb0SWNrE0wyMzCwwMhCAI8s3V1RW9evXCn3/++fQn5xEREYHg4GCsWbMGMTEx6N27dylFTOVdly5dMG3aNEuHQRWYyYnH1NRUTJo0Ce7u7rC3t0e1atUMbkRERERERFQ+GDuhvyAIqOH8IjydXpDbMrVx+Pf+RmRq40snOCoVvXr1QkxMDGJiYnD06FGoVCq89NJLJvURFRUFAOjfvz88PT1hbW1drFiys7OL9TwiqjxMTjzOnj0b//vf/7B69WpYW1tj3bp1CA4ORo0aNbB58+bSiJGIiIiIiIiKw4S1RAVBgJdzN3hpusltWboEffIx+1FpREelwNraGp6envD09ETLli0xd+5c3Lp1Cw8ePJD3uXXrFoYMGQJnZ2e4uLigf//+uHHjBgD9EOt+/foBABQKBQRBAACIooiFCxeiZs2asLa2RsuWLXHo0CG5zxs3bkAQBGzfvh2dO3eGjY0NtmzZAgBYt24d/Pz8YGNjg0aNGuGrr7564ms4dOgQnnvuOTg7O8PV1RUvvfSSnAzNe6zdu3eja9eusLOzQ4sWLXDy5El5n5CQEDg7O+Pw4cPw8/ODg4ODnJTN9bTXFBoaCkEQkJCQILddvHgRgiDI75cxxwGADRs2oEmTJrC2toaXlxcmTZokb0tISMC4cePg5uYGJycndOvWDeHh4fL2oKAgtGzZEhs2bECtWrXg4OCACRMmQKfT4dNPP4Wnpyfc3d3x0UcfGRzT2H6/+eYb+Pj4QKPRYNiwYUhOTgagr6ANCwvDypUr5Sra3NdNZCyTE48//vgjvvrqKwwePBgqlQrPP/883nvvPXz88cfyLxUiIiIiIiKqmDw1L+AZ5wD5cbYuCf/EbkRG9oMnPKtykyQJySmZFrsZM2S+MCkpKfj222/h6+sLV1dXAPoqxICAADg6OuLXX3/FiRMn5GRZVlYWZs6ciY0bNwKAXDkJACtXrsTSpUuxZMkS/PnnnwgICMB//vMf/PvvvwbHnDt3LqZOnYqIiAgEBARgy5YteP/99/HRRx8hIiICH3/8MebPn49NmzYVGXdqaipmzJiBc+fO4ejRo1AoFBg4cCBEUTTY791338XMmTNx8eJFNGjQAMOHD4dWq5W3p6WlYcmSJfjmm29w/PhxREdHY+bMmfJ2Y1/T0zztOKtXr8bEiRMxfvx4/PXXX9i3bx98fX3l7a+88gpiY2Nx8OBBnD9/Hq1bt0b37t0RFxcn7xMVFYWDBw/i0KFD2LZtG9avX4++ffvi9u3bCAsLwyeffIL33nsPp0+fNrnfvXv3Yv/+/di/fz/CwsKwePFi+f3x9/fHG2+8IZ8L3t7eJr03RCYvLhMXF4e6desCAJycnOQT9rnnnsPbb79t3uiIiIiIiIio2IqXrgLcnfwhCErcjj8AANDqUvDv/Y3wdR8FWytP8wVYQaSkZqHzwG8tdvywPa/C0cG44c779++Hg4MDAH0Cz8vLC/v374dCoa872r59O0RRxLp16+Rqxo0bN8LZ2RmhoaHo2bMnnJ2dAQCeno//r5csWYI5c+Zg2LBhAIBPPvkEx44dw4oVK/Dll1/K+02bNg2DBg2SHy9YsABLly6V2+rUqYPLly9jzZo1RS5eO3jwYIPHGzZsgJubGy5fvoymTZvK7TNnzkTfvn0BAMHBwWjSpAmuXr2KRo0aAdAnWb/++mvUq1cPADBp0iQsXLjQ5Nf0NE87zocffoh33nkHU6dOldvatWsHAPjtt99w5swZxMbGykPalyxZgr179+L777/H+PHjAeirMzds2ABHR0c0btwYXbt2RWRkJA4cOACFQoGGDRvK8T/77LMm9RsSEgJHR/1CUq+99hqOHj2Kjz76CBqNBlZWVrCzszM4F4hMYXLFY926dXH9+nUAQKNGjbBjxw4A+krI3F9OREREREREZHnFrZQDADfH9qjl8h/5sVZMw7+xm5CWecccoVEp6dq1Ky5evIiLFy/izJkzCAgIQO/evXHz5k0AQHh4OK5evQpHR0c4ODjAwcEBLi4uyMjIMBjOnFdSUhLu3r2LTp06GbR36tQJERERBm1t27aV76empiIqKgpjx46Vj+Xg4IAPP/ywyGMBwL///ovhw4ejbt26cHJygo+PDwAgOjraYL/mzZvL9728vAAAsbGxcpudnZ2cDMzdJ3e7Ka/paZ50nNjYWNy9exfdu3cv9Lnh4eFISUmBq6urwXt0/fp1g/fIx8dHTg4CgIeHBxo3biwnlHPbco9b3H7zxk5kDiZXPI4ZMwbh4eHo3Lkz5s6di379+uGLL75AdnY2li1bVhoxEhERERERkQW4OrSGIKhw89EeABJ0Yjr+jd0MX/dXYW/NIZflkb29vcEw3nXr1kGj0WDt2rX48MMPkZKSgjZt2hQ6VZqbm5tZjp8rJSUFALB27Vo8++yzBvsplcoi++jXrx9q166NtWvXokaNGhBFEU2bNkVWVpbBfmq1Wr6fdy7Kwrbn7mNKMj43qZf3OYUtmPOk49ja2j7xGCkpKfDy8kJoaGiBbXmLuwo7RmFtua+/JP3mH9JOVBImJx6nT58u3+/RoweuXLmC8+fPw9fX1+DbBiIiIiIiIrKsklQ85nKxbw5BUOLGw10ARIhSJq7GbkZdt5FwtPEpcf8VgYO9FcL2vGrR4xeXIAhQKBRIT08HALRu3Rrbt2+Hu7s7nJycjOrDyckJNWrUwIkTJ9C5c2e5/cSJE2jfvn2Rz/Pw8ECNGjVw7do1jBw50qhjPXr0CJGRkVi7di2ef/55APrhyOZmzGvKTcTGxMSgWrVqAPSLy5jC0dERPj4+OHr0KLp27Vpge+vWrXHv3j2oVCq5stMczNWvlZUVdDqd2eKiqsfkxGN+tWvXRu3atc0RCxEREREREZlRydOOetXsmkBRXYXrD3dAgg6ilI2oB9+ibvXhcLKt9/QOKjhBEIyeY9HSMjMzce/ePQBAfHw8vvjiC6SkpMgrVY8cORKfffYZ+vfvL6/ofPPmTezevRuzZ89GzZo1C+131qxZWLBgAerVq4eWLVti48aNuHjx4lMXmQ0ODsaUKVOg0WjQq1cvZGZm4ty5c4iPj8eMGTMK7F+tWjW4urriv//9L7y8vBAdHY25c+eW8F0p3NNek6+vL7y9vREUFISPPvoI//zzD5YuXWrycYKCgvDWW2/B3d0dvXv3RnJyMk6cOIHJkyejR48e8Pf3x4ABA/Dpp5+iQYMGuHv3Ln766ScMHDjQYOi6KczVr4+PD06fPo0bN27Iw/LzDu8mehqjEo+ff/650R1OmTKl2MEQERERERGR+Zij4jGXxq4h6roNx7WH30GStJAkLa492Io6bkOhsW1gtuNQyRw6dEie79DR0RGNGjXCzp070aVLFwD6+QiPHz+OOXPmYNCgQUhOTsYzzzyD7t27P7ECcsqUKUhMTMQ777yD2NhYNG7cGPv27UP9+vWfGM+4ceNgZ2eHzz77DLNmzYK9vT2aNWuGadOmFbq/QqHAd999hylTpqBp06Zo2LAhPv/8czl+c3raa1Kr1di2bRvefvttNG/eHO3atcOHH36IV155xaTjjB49GhkZGVi+fDlmzpyJ6tWr4+WXXwagT2ofOHAA7777LsaMGYMHDx7A09MTL7zwAjw8PIr92szV78yZMzF69Gg0btwY6enpuH79ulkrM6nyEyQjrkR16tQxrjNBwLVr10oclDklJSVBo9EgMTHR6DJyIiIi4jWUiKgyiImLN5ivzVWjhiSll6jP5IzruPZgK0RJP9edAAV8qr8MZ7vGJeo3PyuVBkqFjVn7JCKismVUxWPuKtZERERERERUtTna1EE999cQFbsFopQJCSKuP9wJH9dBqGbfzNLhERFROVKigfmSJJm1dJ+IiIiIiIjMp7Q+rzlY14Kv+6g8FYkSbjzajUcpf5TK8YiIqGIqVuJx8+bNaNasGWxtbWFra4vmzZvjm2++MXdsREREREREVAKlWSZib/0MfN1HQ6Wwk48WHfcDHiafK8WjEhFRRWJy4nHZsmV4++230adPH+zYsQM7duxAr1698NZbb2H58uWlESMREREREREVRymPULOz8oKvRyBUCge57Vb8fsQmnSrV4xIRUcVg1OIyedWpUwfBwcEYNWqUQfumTZsQFBRU7uaD5MT4RERExcNrKBFRxXfn4SODx+ZYXKYwGdkPcTV2M7J1SXJbDece8HB6rth9cnEZIqKKz+SKx5iYGHTs2LFAe8eOHRETE2OWoIiIiIiIiKhkynI+fht1ddT3GAMrpbPcdjfhF8QkHOO6AEREVZjJiUdfX1/s2LGjQPv27dtRv359swRFRET0JPwAQ0RE9HRlfbm0VlVDfY8xsFa5yG33ksJwN/EXXruJiKoolalPCA4OxtChQ3H8+HF06tQJAHDixAkcPXq00IQkERGRuYmiBKVSsHQYRERE5ZpUqkvLFM5KpUF9jzG4en8TMrQPAQCxSScgSVo849wLgsDrNxFRVWJyxePgwYNx5swZVK9eHXv37sXevXtRvXp1nDlzBgMHDiyNGImIiAzoRNHSIRAREZV/FioyVCsd4esRCBu1h9z2IPk0bsXvhyTxGk5EVJWYlHhMSkrCzz//jJiYGCxfvhznz5/H+fPn8e2336JVq1alFSMREZEBJh6JiIjKN7XSAfXdR8PWyktue5RyHtFx+5h8tDBJkjB+/Hi4uLhAEARcvHjR0iFRBRAYGIgBAwaUuJ8TJ06gWbNmUKvVZumvpEJCQuDs7GzWPm/cuMGfrTyMTjxevHgRjRo1Qq9evdCvXz/4+vri8OHDpRkbERFRAZIkcZ4oIiIiI1hiqHVeKqUdfN1Hwd6qptwWl3oRNx/thiTpLBhZ5Xfy5EkolUr07du3wLZDhw4hJCQE+/fvR0xMDJo2bQpBELB3796yD5TKnI+PD1asWGGx48+YMQMtW7bE9evXERISYrE4yHhdunTBtGnTiv18oxOPc+bMQZ06dfDbb7/h/Pnz6N69OyZNmlTsAxMRERWHKEoW/yBFRERUEZSH7+lUClvUc38NDta15bb4tEu4/nAnRElrwcgqt/Xr12Py5Mk4fvw47t69a7AtKioKXl5e6NixIzw9PaFSmbz0Q5Gys7PN1hdVTlFRUejWrRtq1qxZ7ErDrKws8wZFpcroxOP58+exatUq+Pv7o1WrVtiwYQOioqKQlJRUmvEREREZEDk8i4iIyEjlIPMIQKmwRj23kXC0qSu3JaZfwfUH2yFKTFSZW0pKCrZv3463334bffv2NagqCwwMxOTJkxEdHQ1BEODj4wMfHx8AwMCBA+W2XD/88ANat24NGxsb1K1bF8HBwdBqHyeMBUHA6tWr8Z///Af29vb46KOPCo3pm2++Qdu2beHo6AhPT0+MGDECsbGx8vbQ0FAIgoCjR4+ibdu2sLOzQ8eOHREZGSnvExQUhJYtW+Kbb76Bj48PNBoNhg0bhuTkZHmfzMxMTJkyBe7u7rCxscFzzz2Hs2fPytsLG1a7d+9eg0WPjDmOKIr49NNP4evrC2tra9SqVcvgtd+6dQtDhgyBs7MzXFxc0L9/f9y4ccPg/2HAgAH4+OOP4eHhAWdnZyxcuBBarRazZs2Ci4sLatasiY0bNxrEamy/S5YsgZeXF1xdXTFx4kQ5IdylSxfcvHkT06dPhyAIxVrsKTg4GG5ubnBycsJbb71lkAQURRGLFi1CnTp1YGtrixYtWuD7778H8Hj48aNHj/D6669DEAT53AwLC0P79u1hbW0NLy8vzJ071+A869KlCyZNmoRp06ahevXqCAgIAABcunQJvXv3hoODAzw8PPDaa6/h4cOHT4w/JCQEtWrVgp2dHQYOHIhHjx4V2MfY8753796wtbVF3bp15ddZlCe9xs2bN8PV1RWZmZkGzxkwYABee+01AI/Pyw0bNqBWrVpwcHDAhAkToNPp8Omnn8LT0xPu7u4FfgYTEhIwbtw4+f+sW7duCA8Pl7c/7XwPDAxEWFgYVq5cKZ8zec85YxideIyLi0PNmo9L5J2dnWFvb1/ofxIREVFp0Ynl40MUERERGU+hsEJdt+FwsmkgtyVl/ItrD7ZBFMt/9ZIkSUhJz7DYzZRpZnbs2IFGjRqhYcOGePXVV7Fhwwb5+StXrsTChQtRs2ZNxMTE4OzZs3JibuPGjXIbAPz6668YNWoUpk6disuXL2PNmjUICQkpkNgICgrCwIED8ddff+H1118vNKbs7Gx88MEHCA8Px969e3Hjxg0EBgYW2O/dd9/F0qVLce7cOahUqgL9RUVFYe/evdi/fz/279+PsLAwLF68WN4+e/Zs7Nq1C5s2bcKFCxfg6+uLgIAAxMXFGf3+GXOcefPmYfHixZg/fz4uX76MrVu3wsPDQ36tAQEBcHR0xK+//ooTJ07AwcEBvXr1MkjS/e9//8Pdu3dx/PhxLFu2DAsWLMBLL72EatWq4fTp03jrrbfw5ptv4vbt2yb1e+zYMURFReHYsWPYtGkTQkJC5ATf7t27UbNmTSxcuBAxMTGIiYkx6X05evQoIiIiEBoaim3btmH37t0IDg6Wty9atAibN2/G119/jb///hvTp0/Hq6++irCwMHh7eyMmJgZOTk5YsWIFYmJiMHToUNy5cwd9+vRBu3btEB4ejtWrV2P9+vX48MMPDY69adMmWFlZ4cSJE/j666+RkJCAbt26oVWrVjh37hwOHTqE+/fvY8iQIUXGf/r0aYwdOxaTJk3CxYsX0bVr1wLHMfa8nz9/PgYPHozw8HCMHDkSw4YNQ0RERKHHfdprfOWVV6DT6bBv3z75ObGxsfjpp58MfgaioqJw8OBBHDp0CNu2bcP69evRt29f3L59G2FhYfjkk0/w3nvv4fTp0/JzXnnlFcTGxuLgwYM4f/48Wrduje7duxv8TDzpfF+5ciX8/f3xxhtvyOeMt7d3ke9xYQTJyN9gCoUC//vf/+Di4iK3dezYETt27DBISDZv3tykAEpbUlISNBoNEhMT4eTkZOlwiIiohNIyMiFBgr2NjaVDqfR4DSUiqtiysrV4kJho0OaqUUOS0i0UESBKWtx4uAuJ6Y8/oDtY10ZdtxFQKqwN9rVSaaBUlI/rfUp6BoZ+vMxix9/+fzPgYGvce9GpUycMGTIEU6dOhVarhZeXF3bu3IkuXboAAFasWIEVK1YYVC0JgoA9e/YYLPbRo0cPdO/eHfPmzZPbvv32W8yePVsevi0IAqZNm4bly5eb9HrOnTuHdu3aITk5GQ4ODggNDUXXrl3xyy+/oHv37gCAAwcOoG/fvkhPT4eNjQ2CgoLw2Wef4d69e3B0dASgTzQeP34cp06dQmpqKqpVq4aQkBCMGDECgD5Z5+Pjg2nTpmHWrFkICQnBtGnTkJCQIMeyd+9eDBw4UE7OPu04ycnJcHNzwxdffIFx48YVeG3ffvstPvzwQ0RERMgVhVlZWXB2dsbevXvRs2dPBAYGIjQ0FNeuXYNCoa8Ha9SoEdzd3XH8+HEAgE6ng0ajwbp16zBs2DCT+o2KioJSqQQADBkyBAqFAt999x0AyO+HqXP2BQYG4scff8StW7dgZ2cHAPj6668xa9YsJCYmIjs7Gy4uLvjll1/g7+8vP2/cuHFIS0vD1q1bAeiL2FasWCEnnt99913s2rXL4HV99dVXmDNnDhITE6FQKNClSxckJSXhwoULcr8ffvghfv31V4O1R27fvg1vb29ERkaiQYPHX3LkGjFiBBITE/HTTz/JbcOGDcOhQ4fkc8LY8/6tt97C6tWr5X06dOiA1q1b46uvvsKNGzdQp04d/PHHH2jZsqVRr3HChAm4ceMGDhw4AABYtmwZvvzyS1y9ehWCIBR6Xvbq1QuRkZGIiooyOI8CAwMxd+5c/Pbbb+jbty9iY2Nhbf3496uvry9mz56N8ePHP/V8B/QVpy1btiz23KAmTebQvXv3At+0vPTSSxAEAZIkQRAE6HScJJiIiEqPThShUJg+LISIiKiqKY9zIisEFepUfxk3H+1BfNolAEBK5k1cjf0G9dxHQqWwtXCEFVtkZCTOnDmDPXv2AABUKhWGDh2K9evXy4lHY4WHh+PEiRMGlV46nQ4ZGRlIS0uTk09t27Z9al/nz59HUFAQwsPDER8fD1HUT50THR2Nxo0by/vlLWTy8tKviB4bG4tatWoB0CfNcpMjufvkDtmOiopCdnY2OnXqJG9Xq9Vo3759kZVoRXnScSIiIpCZmSknSPMLDw/H1atXDZ4PABkZGYiKipIfN2nSRE4WAYCHhweaNm0qP1YqlXB1dZWPa0q/uUnH3Nj/+usvo1/7k7Ro0UL+fwcAf39/pKSk4NatW0hJSUFaWhpefPFFg+dkZWWhVatWRfYZEREBf39/g2HfnTp1QkpKCm7fvi3/37dp08bgeeHh4Th27BgcHBwK9BkVFVVo4jEiIgIDBw40aPP398ehQ4cM+jXmvM+bXM19XNQq1sa8xjfeeAPt2rXDnTt38MwzzyAkJASBgYEGz8l/Xnp4eECpVBY4j/KeMykpKXB1dTWIJz093eCcedL5bg5GJx6vX79utoMSEREVlyiJUED59B2JiIioXBIEJWq7DoIgqBCXehEAkJZ1G1fvb4av+2tQKe2e3AEVaf369dBqtahRo4bcJkkSrK2t8cUXX0Cj0RjdV0pKCoKDgzFo0KAC22zyjDyxt7d/Yj+pqakICAhAQEAAtmzZAjc3N0RHRyMgIKDAIiFqtVq+n5twyU1S5t+eu0/e7U+jUCgKFFMVtiDOk45ja/vk5HhKSgratGmDLVu2FNjm5ub2xGM86bgl6deU96i4UlJSAAA//fQTnnnmGYNteavtiiv/eZaSkoJ+/frhk08+KbBvbtK6OIw9782tVatWaNGiBTZv3oyePXvi77//NqjMBIp3znh5eSE0NLTA8fLOdVra54zRicfatWs/fSciIqJSphMlqJh3JCIieqrysKp1UQRBgVou/4FCUOFhyjkAQHp2DP6NDYGv+yiolQWrmCzJ3sYa2/9vhkWP/zRarRabN2/G0qVL0bNnT4NtAwYMwLZt2/DWW28V+ly1Wl1g9GLr1q0RGRkJX1/f4gcO4MqVK3j06BEWL14szw137ty5EvVZmHr16slzAObmL7Kzs3H27Fl5WLGbmxuSk5ORmpoqJ7KKqlIrSv369WFra4ujR48WOtS6devW2L59O9zd3c06VY25+rWysir2SNXw8HCkp6fLyddTp07BwcEB3t7ecHFxgbW1NaKjo9G5c2ej+/Tz88OuXbvkUbQAcOLECTg6OhpM65df69atsWvXLvj4+Bi9Mrufn5/B/Ie5ryF/v8ac96dOncKoUaMMHhdV2Wnsaxw3bhxWrFiBO3fuoEePHibPpZhf69atce/ePahUKoNFo0xVknMGMGFxmdKwaNEitGvXDo6OjnB3d8eAAQMMVq0C9GXDEydOhKurKxwcHDB48GDcv3/fQhETEZGl6crgG1siIqLKoRxnHqFPPtas1hdujh3ktozsWPx7PwTZ2iQLRlaQIAhwsLWx2M2Y1Yf379+P+Ph4jB07Fk2bNjW4DR48GOvXry/yuT4+Pjh69Cju3buH+Ph4AMD777+PzZs3Izg4GH///TciIiLw3Xff4b333jPpvatVqxasrKywatUqXLt2Dfv27cMHH3xgUh/GsLe3x9tvv41Zs2bh0KFDuHz5Mt544w2kpaVh7NixAIBnn30WdnZ2+L//+z9ERUVh69atBqt+G8PGxgZz5szB7NmzsXnzZkRFReHUqVPy+zty5EhUr14d/fv3x6+//orr168jNDQUU6ZMkReKKQ5z9evj44Pjx4/jzp07T10BOr+srCyMHTsWly9fxoEDB7BgwQJMmjQJCoUCjo6OmDlzJqZPn45NmzYhKioKFy5cwKpVq7Bp06Yi+5wwYQJu3bqFyZMn48qVK/jhhx+wYMECzJgxw2AIcX4TJ05EXFwchg8fjrNnzyIqKgqHDx/GmDFjikySTZkyBYcOHcKSJUvw77//4osvvjAYZg0Yf97v3LkTGzZswD///IMFCxbgzJkzmDRpUole44gRI3D79m2sXbu2yIWaTNGjRw/4+/tjwIABOHLkCG7cuIHff/8d7777rknJfx8fH5w+fRo3btzAw4cPTa6GtGjiMSwsDBMnTsSpU6fw888/Izs7Gz179kRqaqq8z/Tp0/Hjjz9i586dCAsLw927dwsteSUioqqhLIaKmJskSZCkihc3ERFVbOW54jGXIAh4xjkAHk7PyW2Z2of4NzYEmdp4C0ZW8axfvx49evQodDj14MGDce7cOfz555+FPnfp0qX4+eef4e3tLVdtBQQEYP/+/Thy5AjatWuHDh06YPny5SaPhnRzc0NISAh27tyJxo0bY/HixViyZInpL9AIixcvxuDBg/Haa6+hdevWuHr1Kg4fPoxq1aoBAFxcXPDtt9/iwIEDaNasGbZt24agoCCTjzN//ny88847eP/99+Hn54ehQ4fKc+LZ2dnh+PHjqFWrFgYNGgQ/Pz+MHTsWGRkZJapUNFe/CxcuxI0bN1CvXj2DIdqCIDw1Cdu9e3fUr18fL7zwAoYOHYr//Oc/Bu/fBx98gPnz52PRokXw8/NDr1698NNPP6FOnTpF9vnMM8/gwIEDOHPmDFq0aIG33noLY8eOfWqCu0aNGjhx4gR0Oh169uyJZs2aYdq0aXB2di4yYdmhQwesXbsWK1euRIsWLXDkyJECxzH2vA8ODsZ3332H5s2bY/Pmzdi2bZvBfKXFeY0ajQaDBw+Gg4ODwUJPxSUIAg4cOIAXXngBY8aMQYMGDTBs2DDcvHlTXoXdGDNnzoRSqUTjxo3lqRJMisPYVa3LwoMHD+Du7o6wsDC88MILSExMhJubG7Zu3YqXX34ZgL5M28/PDydPnkSHDh2e0iNX5CQiqmzuPoqDxt6uwqxqLUo6ZGsToVY5QSGYtKabxfEaSkRUsaVlZiI+OcWgzdKrWhdFkiTcSwrDvcRQuc1KVQ1Nn5kOG7Vb0U8kohK7fv06GjRogMuXL6N+/fqWDqfcK2wVeHPp3r07mjRpgs8//9zsfVuKURWP+/btK3TCVXNLTEwEoP8WAtCvfJWdnY0ePXrI+zRq1Ai1atXCyZMnSz0eIiIqX/SVg+Xm+7Kn0omZyNLGQZRK/xpKRERUkQmCAC9NF9RwfvzZL0sbj0u3lyE9i1NtEZWmAwcOYPz48Uw6WlB8fDz27NmD0NBQTJw40dLhmJVRpRcDBw7EvXv34ObmBqVSiZiYGLi7u5s1EFEUMW3aNHTq1EleQv7evXuwsrIyWG0H0C8Pfu/evUL7yczMRGZmpvw4Kal8zQ1CRETFV5Hmd8zWJUOrS7N0GCbhNZSIqJKpON/VyTycnoMgqHAnPmfeNUGAIHBVOaLSVNkSXRVRq1atEB8fj08++QQNGza0dDhmZVTi0c3NDadOnUK/fv0MVuExp4kTJ+LSpUv47bffStTPokWLEBwcbKaoiIioPKkoiccsbSJ0YoalwzAZr6FERJWLVBEzjwDcHTtAIahwL/FXNKkxDTbq6pYOiYhIVhojsG7cuGH2PssLo4Zav/XWW+jfvz+USiUEQYCnpyeUSmWht+KYNGkS9u/fj2PHjhksJe7p6YmsrCwkJCQY7H///n14enoW2te8efOQmJgo327dulWsmIiIqPwRxfL/AaqiJh0BXkOJiCqbCjQ7SQHVHdqihfdc2FqZd6QdERGVLaMqHoOCgjBs2DBcvXoV//nPf7Bx48YCw5+LQ5IkTJ48WR7Hnn+lozZt2kCtVuPo0aMYPHgwACAyMhLR0dHw9/cvtE9ra2tYW1uXODYiIip/ynPFoySJyNIlQhSzLB1KsfEaSkRUuVTUisdcSkXFWEiOiIiKZvTymo0aNUKjRo2wYMECvPLKK7CzsyvxwSdOnIitW7fihx9+gKOjozxvo0ajga2tLTQaDcaOHYsZM2bAxcUFTk5OmDx5Mvz9/Y1a0ZqIiCqX8pp4lCQRWdoELiJDRERERESUhyAVc3D6gwcPEBkZCQBo2LAh3NzcTD94EXNFbty4EYGBgQCAjIwMvPPOO9i2bRsyMzMREBCAr776qsih1vklJSVBo9EgMTERTk5OJsdIRETlR3xKCtIyMuHsYA97m/JRBSFKOmRpEyBJ2ifuZ612hUIw+vu+coHXUCKiii05LR1JaYYLnblq1JCkdAtFZBorlYZVj0REFZzJice0tDRMmjQJ33zzDXQ6HQBAqVRi1KhRWLVqlVkqIc2JH5qIiCqP2MQkbDkahppurqjt7o6WdX1gpbZcMk+UsnOSjk+vxGTikYiIylpSWhqS0wyTjEw8EhFRWTJqcZm8pk+fjrCwMOzbtw8JCQlISEjADz/8gLCwMLzzzjulESMREREAID4pGb/88RdCjoQi+Nsd0Io6i8UiisYnHYmIiCyhIi8uQ0RElYPJicddu3Zh/fr16N27N5ycnODk5IQ+ffpg7dq1+P7770sjRiIiIgBATHyCfN/Z3g52FloIRatLRaY2nklHIiIq55h5pIIkScL48ePh4uICQRBw8eJFi8Th4+ODFStWmLXPwMBADBgwwKx9ElHJmJx4TEtLg4eHR4F2d3d3pOWbP4SIiMic7udJPHq6VCvz4+sXkUlEti4F/DBHRERE5dXJkyehVCrRt2/fAtsOHTqEkJAQ7N+/HzExMWjatCkEQcDevXvLPlAqUmhoKARBQEJCgqVDISoRkxOP/v7+WLBgATIyMuS29PR0BAcHw9/f36zBERER5dLpRDxISJQfe5Vx4lGUspGpjYdOzHj6zmR2Wp2Ih3FpSErOREamFsVcG4+IqErhr8qqa/369Zg8eTKOHz+Ou3fvGmyLioqCl5cXOnbsCE9PT6hU5puDOjs722x9EVHlYHLiceXKlThx4gRq1qyJ7t27o3v37vD29sbvv/+OlStXlkaMREREECURDxKT5MdeLs5lclx9lWMSMrPjnrpyNZUeSQJS07IRn5iB+w9SEX0nCXdikvHgYSoSkjKQmpaF7GwdE5JERHlIrM43G0mSoNWlWexmyvUtJSUF27dvx9tvv42+ffsiJCRE3hYYGIjJkycjOjoagiDAx8cHPj4+AICBAwfKbbl++OEHtG7dGjY2Nqhbty6Cg4Oh1T7+e0gQBKxevRr/+c9/YG9vj48++qjQmGJjY9GvXz/Y2tqiTp062LJlS4F9EhISMG7cOLi5ucHJyQndunVDeHi4vD0oKAgtW7bEmjVr4O3tDTs7OwwZMgSJiYkF+sqVmZmJKVOmwN3dHTY2Nnjuuedw9uxZAPr/U19fXyxZssTgORcvXoQgCLh69ar8GtesWYOXXnoJdnZ28PPzw8mTJ3H16lV06dIF9vb26NixI6Kiogz6Mea9W7duHQYOHAg7OzvUr18f+/btAwDcuHEDXbt2BQBUq1YNgiAgMDCwyNdJVJ6Z/NVG06ZN8e+//2LLli24cuUKAGD48OEYOXIkbG1tzR4gERERAOjE/IlHl1I/plaXDq2YwrkcyymtToRWJwIZef6IB6BSKaBUKqBSKaBSKqBUCvr7OY+JiKoKfhdjPjoxHWeuW24x1fZ1lkKltDNq3x07dqBRo0Zo2LAhXn31VUybNg3z5s2DIAhYuXIl6tWrh//+9784e/YslEolAP3UaRs3bkSvXr3ktl9//RWjRo3C559/jueffx5RUVEYP348AGDBggXy8YKCgrB48WKsWLGiyOrJwMBA3L17F8eOHYNarcaUKVMQGxtrsM8rr7wCW1tbHDx4EBqNBmvWrEH37t3xzz//wCXn776rV69ix44d+PHHH5GUlISxY8diwoQJhSYyAWD27NnYtWsXNm3ahNq1a+PTTz9FQEAArl69ChcXF7z++uvYuHEjZs6cKT9n48aNeOGFF+Dr6yu3ffDBB1i2bBmWLVuGOXPmYMSIEahbty7mzZuHWrVq4fXXX8ekSZNw8OBBk9674OBgfPrpp/jss8+watUqjBw5Ejdv3oS3tzd27dqFwYMHIzIyEk5OTsy3UIVVrJpqOzs7vPHGG+aOhYiIqEhanQ6xCWVT8agTs6DVpUCUSj5cSCdmIiHtMuLT/oKP62A42tY1Q4RUFAlAtlZEtlYEMgtuFwQBarUCapUCapVSf1+thFrFhCQREVUO69evx6uvvgoA6NWrFxITExEWFoYuXbpAo9HA0dERSqUSnp6eBs9zdnY2aAsODsbcuXMxevRoAEDdunXxwQcfYPbs2QbJsxEjRmDMmDFFxvPPP//g4MGDOHPmDNq1ayfH6OfnJ+/z22+/4cyZM4iNjYV1zuKBS5Yswd69e/H999/LSbuMjAxs3rwZzzzzDABg1apV6Nu3L5YuXVrg9aSmpmL16tUICQlB7969AQBr167Fzz//jPXr12PWrFkIDAzE+++/jzNnzqB9+/bIzs7G1q1bC1RBjhkzBkOGDAEAzJkzB/7+/pg/fz4CAgIAAFOnTjV4D4x97wIDAzF8+HAAwMcff4zPP/8cZ86cQa9eveRkq7u7O5ydnYt8f4nKO/NN5kBERFSKElPTkJ6VJT8ujTkeRSkb2drkEiccJUlCWtZtPEr5A/FplyBK+rjvJ//OxKOFSZKErCwdsrJ0AB7/P+cmJK3VSqitlPp/1QoIgmC5YImISojTT1Q9kZGROHPmDPbs2QMAUKlUGDp0KNavX48uXbqY1Fd4eDhOnDhhMHxap9MhIyMDaWlpsLPTV2C2bdv2if1ERERApVKhTZs2clujRo0Mkmnh4eFISUmBq6urwXPT09MNhjDXqlVLTjoC+jUoRFFEZGRkgcRjVFQUsrOz0alTJ7lNrVajffv2iIiIAADUqFEDffv2xYYNG9C+fXv8+OOPyMzMxCuvvGLQV/PmzeX7uYvtNmvWzKAtIyMDSUlJcHJyMvq9y9uvvb09nJycClSCElV0TDwSEVGFcDcuXr5va2UFjb1xw42MIUpaaHWpJV44JluXivjUP/Eo9QIysh8U2P4w+RzqVH8FSoV1iY5D5meQkEzVtwkArKyUsLZSQq1+/C8RUUXBtKP5KBW2aF9nqUWPb4z169dDq9WiRo0acpskSbC2tsYXX3wBjUZj9DFTUlIQHByMQYMGFdhmY2Mj37e3tze6zycdy8vLC6GhoQW2lXa137hx4/Daa69h+fLl2LhxI4YOHSonBnOp1Wr5fu6XkoW1iaJ+eh5j37u8feT2k9sHUWXBxCMREVmMfqJ2CTqdCJ1OhEIQYGurLnTfe3EJ8n2PapoSVaKJUjYkSYIkZUMnZUEUs57+pCJIkoikjCjEpVxAYnokJBT8Y1EpWMPVsR08nZ6DQrAq9rGobEkAMrN0yMzSyW0CAEEhQKkUoFQ8nj9Sqcwdvq2/T0RULrDi0WwEQTB6jkVL0Wq12Lx5M5YuXYqePXsabBswYAC2bduGt956q9DnqtVq6HQ6g7bWrVsjMjLSYK7D4mjUqBG0Wi3Onz8vD7WOjIxEQkKCwbHu3bsHlUplsLhNftHR0bh7966cWD116hQUCgUaNmxYYN969erBysoKJ06cQO3atQHoV90+e/Yspk2bJu/Xp08f2NvbY/Xq1Th06BCOHz9eoteb+3pK+t5ZWen/Zsz//0JU0TDxSEREZpc3oSiK+n/zPtbqROh0EkTR8AORna266MRjfIJ837OaswmxiNCJmZCggyRpc5KOJf8mOVMbj0cpfyAu9SKydUmF7uNgXRuuDq3hbOsHW2svKARedis6CYAk6s/d7EKSzACgUAiwypk3Uq1WQKVSwkrNhCQREZWu/fv3Iz4+HmPHji1Q2Th48GCsX7++yMSjj48Pjh49ik6dOsHa2hrVqlXD+++/j5deegm1atXCyy+/DIVCgfDwcFy6dAkffvih0XE1bNgQvXr1wptvvonVq1dDpVJh2rRpBoul9OjRA/7+/hgwYAA+/fRTNGjQAHfv3sVPP/2EgQMHysO5bWxsMHr0aCxZsgRJSUmYMmUKhgwZUmCYNaCvxHz77bcxa9YsuLi4oFatWvj000+RlpaGsWPHyvsplUoEBgZi3rx5qF+/Pvz9/Y1+bUUxx3tXu3ZtCIKA/fv3o0+fPrC1tYWDg0OJYyMqayb/BVy3bl08evSoQHtCQgLq1uW8VURElZ1WJyIjU4vUtCwkJWciPiEdD+PScP9BKu7eS0b0nSRE30nC3XvJuP8gFQ8epSEuIQNJyZlITctGeoYW2dligaTj08QmJMr33Z0doNWlQiumQydm5SwGk44sbRKytInI1CYgI/tRzu0hsnVJOUOpM0uUdBSlbMSl/oV/72/C5bsrcT/peIGko0rpAA+n59DYazLqe4yBi30LKBSscqxKRFFCRqYWyalZiEvIQOzDVNyOScatu0m4/yAV8YkZSE/Phk7HoVREVLrMWe+oUFjBWu2SM10I578tj9avX48ePXoUOpx68ODBOHfuHP78889Cn7t06VL8/PPP8Pb2RqtWrQAAAQEB2L9/P44cOYJ27dqhQ4cOWL58uVw9aIqNGzeiRo0a6Ny5MwYNGoTx48fD3d1d3i4IAg4cOIAXXngBY8aMQYMGDTBs2DDcvHlTnlMRAHx9fTFo0CD06dMHPXv2RPPmzfHVV18VedzFixdj8ODBeO2119C6dWtcvXoVhw8fRrVqhnOFjx07FllZWU9cJMcU5njvnnnmGXmRGg8PD0yaNMkssRGVNUEyccZhhUKBe/fuGfySAID79++jVq1ayMwsZAlJC0pKSoJGo0FiYiKcnJwsHQ4RUbmmy6lE1FcoPq5S1Goft5fmoC07WzXcXAsfxjRl9QZE3b0HABjX63n0ategFCMxlJYVk7NQzJ9FzAOpgMa2AVwdWsHJxheCUHAeQGu1a4WreCxP19BsrYi795ItGkNpUKsUsLZWwcpKCRvOIUlEZhabkIhsrdagzVWjhiSlm9yXlaoalDlfpIliNjK18SjtWSStVBooFTZP35GqhKCgIOzduxcXL140e9+//vorunfvjlu3bhkkOomo5Iz+BLRv3z75/uHDhw2+RdHpdDh69OgT52IgIiLLyT+X4uPkomTwuLzOBKUTRTxIeFxZ6OFc+kkwrZiO+NS/8CjlD6RnxxS6j7XKFa4OreFi3xxqpWOpx0SVT7ZWRLY2S17QRqEQYG2lhLWVSl7YRqFgZRERWZZKaS8nHQFAoVBDrXRAtq7yfSFEVUtmZiYePHiAoKAgvPLKK0w6EpUCoxOPAwYMAKAvgR49erTBNrVaDR8fHyxdarlVvoiIqiptTjJR1EnQilKBqsXC5lKsaFIzMpGUliY/9qhm/IqMppAkESmZN/Eo5QIS0iMgSdoC+ygENZztmsDVvhXsrWuVaJEbovxEUUJ6hhbpGfpzTwCgUitgbaWSF69RqZVQKQWee0Qk0+lECIJQ4IsKEwe3FUoh6JOM+amUdtCKqWaZN5nIUrZt24axY8eiZcuW2Lx5s6XDIaqUTB5qXadOHZw9exbVq1cvrZjMqjwNEyMiMsWTqhTzJhsrdkrRUFFDra/cuoN3/rsJAKBSKhEy83XYWJnvg06WNglxqRfxKPUPZGnjC4/N6hm4OrRGNbumOfNbmYZDrUumsg61LglBEKBUCLBSPx6ubW2lZEKSqBLJv0Bb7t8COrHgiAU3VzvY5Vug7X58ArT5VsQ1Zai1QlBDpXQwqHbMK0ubBJ1o+rBtY3GoNRFRxWfyJ6Dr16+XRhxERFWKQSKxklYpGkOSJGRk6BfhSE7JQlaW/sPR8x28YW/3+EPOnYdx8v3qTo5QmCGxIkpaJKX/g0cpfyAp4yoKm6dKpbBDNfvmcLVvDVsr94KdEFlQ7pcTWp2ItDwVkmorJazVSlhZKfWra6sVTEYSlTM6nX6RNa1OgigaJhT17SK0WqnEFYslebYgKGGlqvbE3x9KhU2pJh6JiKjiK1bpxdGjR3H06FHExsZCFA0rTjZs2GCWwIiIKiptTiViblJRvzCL/kNF7v3KmFLUakWk5CQQk1Mz9f/Kt5zHqVlykjElp12rK/hubP/vQNSv4yI/jol/XIXoXsL5HTOyH+BRyh+IS70IrZhWyB4CHG3qwdWhFTS2DStclSJVbRKArCydPomf+rhdpVTASq2AVc7ckVZqBZRKhcXiJKqMxDzXfK0oQcxJKmpzvkzUifpkY1mOVihJ4lIhqJ/6pYVSYQVBUHC4NRERFcnkT1PBwcFYuHAh2rZtCy8vL36DTkRVhv5Dg2FlQlmv+lwW8lchyknD3Ftqvracx2npBedDLK7EpEyDx/fjE+T7bhrTE486MRMJaX/jUcofSM26Veg+VkpnuDq0got9S1ipSmcOSSJL0eZUU+dWRgL6hWzUKgXUaiVUSgXUaoX8mIge0+lEZGv113pRlCBKEqScvwny/j1gjvkUyxPByC/elAo7aHUppRwNERFVVCYnHr/++muEhITgtddeK414iIjKXEVf8flJClYhZuuThqn5qhGNqEIsbXa2amgcreFSzQZKpeGXWvfjE+X7bhrjkoKSJCEt6zYepVxAfNoliFJ2gX0EKOFs5wdXh9ZwsPaBILACjKoOUZSQmaVDZpbh/G+CIMDGWgkbaxWsrfXDtflFM1UmkiRBkqBPIEqQk4hiTkWiNifJmDtqoSJPfVL8ZKgAlZFzK6oUtkw8EhFRkUxOPGZlZaFjx46lEQsRkdlVlrkUy0MVorFUSgGODtZwdLDKuenvO9jnPLa3yrdd36ZUKopcXMaUisdsXQriUv9EXMoFZGgfFrqPrdoTrg6tUM2+OVQK2xK9XqLKRpIKrqydO2+kSqWASqWAUilApeRwbSo/JEmfJMytTMzOneZE1FcnipIEUQQgVa5F2Z6muK9VpbSHIBhX/SwICigEdaFf8BEREZmceBw3bhy2bt2K+fPnl0Y8RERGybuqc96EopgnwVheV3x+4lyIqeWvCtEwQWidJ3loVSC56GhvBRsblVmro7K1OjxKflxJUdgcj5IkIinjKh6l/IHE9EgABeeaUgrW+oViHFrBzqqG2eIjquwM5o3MRxAEqJRCTjJSAYVC/1gQBAgCoBD02zh8m4ojN5mYla3Tf2mYs/CKKEpy1aJ+1IL+bwAqRDErHpVC4atYF0WhsIKoY+KRiIgKMjnxmJGRgf/+97/45Zdf0Lx5c6jVaoPty5YtM1twRFT1FDbsOe9E7eUpoVgRqxAdHIqoOnxCFaKl3YuLl4eKCYIAVydHeVumNk5eKCZbl1zo8x2sfeDq0ArOto2hUKgL3ccU+uHYue+LCEChb5MkCIISEkQIECBBgiRpOeE+VWqSJCFbKyFb++TzXACgUiugVuVUTeZUTKrUSqhVlv89Q5aV+2VibqVidraI7GwdtNqKOc1JxSeYfL1UCtbQ5l3RioiIKIfJicc///wTLVu2BABcunTJYBvn/yGiouQmFAtbmKU8TMyu04n55j00rDosX1WIKn2S0D5ftWHe6kN7dalWIZalO4/i5Psujg5QKEQkpP+FxLhzSMm8Uehz1EpHuNi3hKt9K1irXQrd58kEKARVzjAzAYKggFKwhiAoTZ4HUpIkSNBBACu+qOqSgJxkUsEEpQDIQ7jVKn0yUqVUyAnKivq7q6rS6URkZemQrRXlRVhECQYVirlVi6JUtis8VzXF/ZuqOF/SKRRqrm5NRESFMjnxeOzYsdKIg4gqKDlxmHe4s/g4qSiKUpkmFAtUIRZZjWj4OC297IcHqVSKfMOWHycKHYqoQnSws4KqilUH3Y2Ll++3qKfFnaRPIEoZheypgMa2AVwdWsPJxrcYC8UIUCqsoVBY5SQZzfM+C4IAwfTLLVGVIQH6KjetiPRCtiuVAgQIEBT6odvKnBW4c5OTSiUTlKVNpxP1yUNRggR9slCU9AnFvF8g5g6JpvKhuH96KUwcZv34eWropMziHZSIiCotfhIiIgOSlDOHki7fCo85i7DkTtReFkOe5bkQi6g6LLQKMTUL2qcM+SsNJs+F6GANG2uuFGuMmDyJR5WyOkTpH4PtNqrqcHFoBRf7FlArHUzuX6GwhkphB4Wg5v8HUTmkT2RJgDzFpA6FZSiVSiFnjkn9XJO5JAkQhNwvAXJ6yFNxJwBQKB7PS5n394CUr2IPeLxYh0IQoBAACPrjCgCEnDku5YpNlcIiv1fkqsKcZOHjysPH01YA+mpT5LxuSQKys3U5Q50fz6loqZEIVHLF/SvN1PkdcykEK+jAxCMRERkyOfHYtWvXJ/4B9b///a9EARGReeVPJOZWIeYmEPVJRRGSiFL7gFHZ50KsilWIJZX3w27uAhQQUOj7eC9P4tHRpgasVbWQrbsHZ7smcHVoBXsr72J9sFcorKBS2EOpKN4HLCIqX/RVd1Khw7ktSZ07hFyl0CcpcxfeUQjyTRBgsOJy7u/I3H9yf8WJIh5PWSLmXK9zhjDrdCKydSK0WiYLKUexTgMBglC82hSFQp3nCwIiIiI9k68qufM75srOzsbFixdx6dIljB492lxxEVEhRDFPFWLe1R0lyeCxLqdKURSLP79PUSp1FWIFnwuxtORW8eQmCAWFIFf65N4XFAKUitxtj/fL+xx9YZBgUIlkjHtxCfJ9d40Gz2iGwdnBEZJUvE83SoUNVEp9hSMRUWnLHUZOVBHo5zcu3t9B+uuqgGJmPImIqJIyOfG4fPnyQtuDgoKQkpJS4oCIKrO81YdinsnVc9sl8fG/ogR5aFRuQtHcsVTmKsTysiJzacithFEooJ/3TNA35g4jzDtcMO/wQjlJKCcMDROJue35+7AkUZTwIDFJflxd4wRHWy8oFdnQ6tJM6ksQVLBSOpllZWsiIqLyrjhDrRUlHAWgUFhBFDncmoiIHjPbHI+vvvoq2rdvjyVLlpirS6JyKXeosj5xaLg6oyTlDIGSKw8Nk4ml9f2vKSsyp6Q8rla0TBVi/hWZrQp5XHmqEAUACqXwxEpBhSBAoRQM5hlTKHKHH+fsX04SgWXtUXIysnWPKxvdNE6wUVtBhGmLASkVtlArHcy2YAwREVF5V5xBLyUdDaAQ1BA5zyMREeVhtsTjyZMnYWNjY67uiEpV3knX8w9bzp37sCyqDguLKyNT97jSMDULycn5qw5zVmROfvzYIisyV7K5EPMm+4pKEOYfNmy4GEHBRKGpQ4qpoLuP4uT7TnZ2sLOxhlKpgGj0KGsBVionKBW8PhERUVVTjIpHMyQeiYiI8jI58Tho0CCDx5IkISYmBufOncP8+fPNFhhRblWhlK+6UJL0CcHcydSBnORgzsqNUs5zcydof5xELJ05D4vCKsTS9dREYf6kIZBnDsLHcxEyQVi+3Xn4SL7vpnGCtdr4DzRKhTXUSkcIgrI0QiMiIirXTP2TVyGoSzwyQCGowHkeiYgoL5MTjxqNxuCxQqFAw4YNsXDhQvTs2dNsgVHFlLeSMLdKELnzF+Yk/vImE/NXFZZ1ctAYBaoQC50LMacKMU+7RasQ7a3g6Fh+qhANhw7r/1Uo8s07mLeiUD/JYIFkYe6QZSYKq447jx6vaO3u7AQbIxOPaqUjVEq70gqLiIio0inp/I4AIAgKKAQVRKns/w4mIqLyyeTE48aNG0sjDipjeROEkKTHFYMFHuckC0UxZ1iylLM9XwIxT7Vhefa0KsSU/AutWLQKUV3ICsxlW4UoCLkrFQNKhUK/GIlSUXAIMgznJhTwuKKwsi7wQmUjJu5x4tGYikdBUECt1EBphg9PREREFZlo4hf5SsHaLMdVKNQQdUw8EhGRXrHneDx//jwiIiIAAE2aNEGrVq3MFhQVrcDw49zVkfNUGBZaTShJkPJUG5b3BOHTFFiRuciVmctRFaIF50JUyEnCx9WGCoU+qahQKKBQ5iQYcxKNeR8TWdL9+AT5vqdLtScmshWCGlYqDYdWExERATBluLMgKKBQmGd+RoVgBSDNLH0REVHFZ3LiMTY2FsOGDUNoaCicnZ0BAAkJCejatSu+++47uLm5mTvGCkfKWy2Yp4Iw7wrIElAwQZinmlDKeQ5yEoflbfixOeWtQkzJP/9hTlIxKTlPVWJOW1WsQsyfGDRIHipyEozyfYW8D1FFJEkS7uVJPD7j6lLkvkqFDdRKJybLK6n7D1KRkpqFuIR0KJUKKJUCVEoFVCoFlEoFVEp+UUJEVBLmXBSGC8wQEVFeJiceJ0+ejOTkZPz999/w8/MDAFy+fBmjR4/GlClTsG3bNrMHWZ7odCLiEjIKTSBW5uSgMQpdkTlfFWJKahaSUsppFaK9FRwdrcusCrGwJGLuPIb5qw8VCn6wpqonKS0NGVmPfz94u7kWspeQM5+jbdkFRmXus69O4X+/3XjiPgqFAJVK/7tSpVRAqVLo/1XmtisKSVoKcntRzy1qW96+c5Ofhd/P2VclPH6cc2x1Tn9Kpf6LIiIiczLlY4k5k4WCoIAgqCBJWrP1SUREFZfJicdDhw7hl19+kZOOANC4cWN8+eWXVWJxGVGCRRJlZa2ouRBTihraXMVXZM6tPBRy/lUqFXmqEfMkEHOGOXPeQ6Knu/0gTr5va2UFVydHg+2CoIKVSpOzgiZVZsZcW0RRQlaWDlllEE9pEHLmxDVIcuZJUiqVipxE5eMEZv6kqj6pmfe5wlOTn4+35U+uCjmJWgXUKsOEbf7+WXVKVD6ZMrmSfni0+SgENXRMPBIREYqReBRFEepCJvdXq9UQxbJPOtGTGVOFmDsXYt5hzqlp5aQK0cEajvbqAtWHjvb6xw72pbMic8Gk4eMPfoZDnJlEJCottx8+ku+7V9NApXw8d6NCUEOlsocg8OevKtAn5QTodJV3VIEk6ROslvgCz1zkCtGcRGRhVadyJakqJ5FaaAJVyFNZmnPtlffP128hydCnJV4fV5oaDtln1SlVOkb/yhQgmPlLPIVCDZ2YbtY+iYioYjL5CtOtWzdMnToV27ZtQ40aNQAAd+7cwfTp09G9e3ezB0iPFVaFqE8WGiYVc4cyW3YuRH0VooO9FZyKqEJ0yLnv5GhdKlWI+QmAfhhzzocLZZ5kYu6HGyYSicqPu3GPKx49nDUG25QKm7IOhyxo+cIXka0VcScmCVqdBJ1On6DT6kToCnn8+L6o3z/nseH9gvvqtBKyc+/rRGi10uN+tDnHyX1uzjZtIfsWiEErynFX5hlZ9P8XOmRBZ+lQikWRU3Wat+KzsOrQvFWouQnNx0nVx1WrBRKhefsqcvh/4YlXVb4kbt4K17wVsKw6pbyMrXhUKNRmP3cUxV/DlIiIKhmTrwhffPEF/vOf/8DHxwfe3t4AgFu3bqFp06b49ttvzR5gZWRKFaKl50JUKoUiVmEuOAdibhWivb0V1KVQhVgYQRD0f3Qrcj4E5FmlWZVnfkQuskJU8cQ8ipfve7lUs2AkVF4IggC1StBfY6wtHY3pcueHlpOnuYlTrYjsnARlbuIyW5snAZqTyCx4PyfJqRMLJFflffNvy5+klY+r35adJwZtnphyjyuKlTdzKkqAqNW/BxVV3iHyhgnM/AlSodD5SouqOjVMdhacH9Xw8ZOrTg0TuIb982818zL2iw5zD7MGYPYKSiIiqrhMviJ4e3vjwoUL+OWXX3DlyhUAgJ+fH3r06GH24CoCnU5ESmp2gSRhkUnFcjAXYlFViA7550h0sIJtKVchFkUQhMcViIrHf0TnJhTzVisSUeV0Lz5Rvv9M9aJXtCaqKARByLl2AYDyabuXS6IoQSdKclI0W/s4cVlYhWfepGXeJKZB4jR/dag27z55+tE+PXmat5+ikqeVmT7ZrAMqRdVpERWfeRKYj+cgLaRy1KBytWAFa/7nPr7/lMWi/r+9e4+Our7zP/76fmdymVxJCAQChosK1BugFg+gB7ZSEFkq665WSwXh1O5acGHZbpUfl0BdS6HVUina3W5F212Bygo9p2eVclKBWkEBi7dSFNRClUtQkpCgucx8fn8kM5nJjYTM5TvfeT7OyXHmO5PJ+w0mb+ad9+fz6aTR6rSp0y5PPMbgFGrLsjhgBgAg6SIaj1JTIfnyl7+sL3/5y9GOx9GeePqA3jlcoTOfnk/oXogXM4UYq70Qu8OSIhqGoUNYwqYTg9ed9I82APFnjNHpysrQ/YG92zvRGkC82c0rCOK1siHa2kyddrBEv/XUaUPYVGjrz+2oydn6dS7ceG1n6jTiazR9LlOnztbZ1GnEsv329hltNUnaugHa7vL/sM8tLPCpMD9T48c0rUrr6h6PsTqkzba8HDADAOh64/F3v/ud5s+fr7179yovLy/isaqqKo0bN04//elPddNNN0U9SKd4+9Bp7X3946i+ZjJNIXYkfCox4rYneLvlH0oA0BVVted17rPPQ/cH9KHxCKDnXDN12qqB2Xris6OGZ6dL9lvvjdrOBGp7jdfQ57aaQm13yX7za7lZoqdO+xZl6cWNd0uSAl1Ya21Z3pgd1GZb3iSdvQUARFOXG49r167Vfffd16bpKEn5+fn6x3/8Rz322GOubjzm53V8mEHoRObwRmESTCF2JjihGLm8OXxD9abfwjqpCQrAHY5VnAndTvN6VJiTk8BoAMA5mqZOPUqL/urYuAifOu20+dnB0vpOl9230zwNNmFb9lDtfGq1dbO0vWlWJ0+dRr63iIyz+vxn+vRcjdLTC5WdYWRZVkyWWQdZMXxtAEDy6HLj8Y033tDq1as7fHzy5Mn64Q9/GJWgnGrapMt01Yg+MsZENhTjcCJzNLVe8tyyJKTVEmg2+AaQIB9VfBK63Tc/n59HAOAS4VOnGekumTrtqPnZalq09ZL98MZrZ0v2O2u0hjduJam4T3YoztYDj29/eExP79gpSbpqcH+tuOdW2XbsmoOxWsINAEguXa4Gp06dUlonv1r1er2qqKiISlBOdeMNl+iG6wbo45PnEh1Kh8KbihGba3MgC4AkYYzRx59yojUAwJmcOnXap3eWsnwtQbU+XKaiqjp0u1e2T1JsDpYJsiybA2YAAF1vPA4YMEBvv/22LrvssnYff/PNN9W/f/+oBYZIlhQ6fKWjZc9MKQJwg7qGRp2ubDnRul9hr8QFAwCAS5ypbhme6NsrV5Zlx3wq0bbSOGAGAFJclyvNrbfeqmXLlumWW25RZmbkXoefffaZysrK9Ld/+7dRDzAVWJbVZrkzU4oAUlVDY2PEVMaA3oUJjAYAgOTUeqn1maqWxmNxQW5c9mDkgBkAQJcbj0uXLtXzzz+vYcOGaf78+Ro+fLgk6c9//rPWr18vv9+vJUuWxCzQZNTe4SxNy5/DJhZtiylFAAhT39io05VhjcciTrQGAKCnzlS31Na+vXLjsgejxT6PAJDyulwJiouL9corr+j+++/X4sWLZZp/hWZZlqZMmaL169eruLg4ZoE6iW03b4ptNzcRww5jCS57Dt4GAHRP7ed1qqypCd0v6c0ejwAA9ER9Y6Oqas+H7jc1HtNj/nU5YAYA0K1KMGjQIP3f//2fzp49qyNHjsgYo8svv1wFBanzpjDNa+uSkrxEhwEArtTQ2KjTlZWh7fBty1KffH7mAgDQXSZsrfUnYfs72palovzsOE082rIsW8YEYv61AADOdFHVpqCgQF/84hejHQsAIMUFjFFF2DLrovw8eT2eBEYEAEByCt/iMXx/x6L8XHk9abKs+KzOajrZuj4uXwsA4DysBQYAOEr4wTLFBfkJjAQAgCQWNvEYvr9jcUGe7DgcLBNkiV8gAkAqY9MNAICjnK6qCt0uKUydrTwAtM+SZAf3z7ab9tQOfViWLEuyws7pa32Sb+h1LLU80RgZ0/Lc4GXLtpq+nm3JCnttS1bE57f+eiZgFDBGJmDkDxgZ0/zfQMt/A63iChijgL/l+UC0dTTxWNwrzo1Hi8YjAKQyGo8AAEepCHtz1L+wMIGRAIgG27bk9dryhg7gs5saiVbTXnNWcwMxKNjgs62WBmAqMMYoEGxQBhujMgoEpEAgoEBzE9PvN/L7A823Awr4jWhboj2mg4nHvr3yZNvxazzaNB4BIKXReAQAOEpFZdjEYxETj4ATNU0ftjQNg/dtjyWPx5Y32Gz02inTOOwpy7Lk8VzcolS/PxBqSDYGmiYpA8FGZvO14HOQms6EHS7Tr6BXnCceecsJAKmMKgAAcAx/IBDx5mhAbyYegVixrGDzUPJ67FDzsGnasHmZsR2cPLTlsZsbYx62CHcaj8dW0zlcF25bmtAy86bGZKPfRDQuw5uXLANPbsG/O2NMxGqCfgXx/aUeezwCQGqj8QgAcIxPqs/JHwiE7sf7zRHgBqHpQ7t5+rC5WRhsGnq9TU1EJhFTU3DvSsmSxyOlXWDwzZjw5mRTg7KxMaBGf6Dpv40Blno7VPDv5XxdnT6vbzlVurigd1zjaPp/ziNj/HH9ugAAZ6DxCABwjJOfVoZu98rOVmZ6/JaCAU4SOjjFVuhAldBS5tDhKnZoubPVvF+ibdNMRHRZlqU0r6U0b8eTrq2Xekfc9wfU2MjkZCIE/8zDpx0z0rzqlZMd91gsy0vjEQBSFI1HAIBjnDh7NnS7uCA/gZEA0WNJTVOGYVOHwWXL4YerBJc1s5QZyaYrS70b/QE11PtV39DUjAw2Jf3+piXfiJ3wg2V65+UlZNrZtjwKXPhpAAAXovEIAHCM8InH/oUss0by8HpspaXZzUubbXm9LSc500gEmr5HvD5bPl/bx9pbzu1vXsrdwMTkRQv+mZ0Jm3gsystNSCwWbzsBIGUl9F/Cu3fv1vTp01VSUiLLsrRt27aIx40xWr58ufr37y+fz6dJkybpvffeS0ywAICYO3m2MnS7X2GvhMUBhLMsS2lptnyZXuVkpysvN0MF+ZnqXeBT/745Kh2QpwH9c9W3KFu9C3zKz8tQdla6MtK9NB2BLmhazm0rM8Or7Kzm77FePvUpylZJca5KB+RpYP9c9eubraJCn3rlZSrLlyYv31+dCrZqz1S1TDz2yU9M49HmZGsASFkJrQC1tbUaOXKk5s6dq9tvv73N42vWrNHjjz+uZ555RkOGDNGyZcs0ZcoU/elPf1JmZmYCIgYAxFJ447E/B8sgxto91TnsMBZv2NJoAInlaZ4ezkiPvO73B5qWbzc2LeNuaPCroTHA8m1JCk48VodNPObnJSQUi8YjAKSshFaAqVOnaurUqe0+ZozR2rVrtXTpUt12222SpF/84hcqLi7Wtm3bdNddd8UzVABAjBljdCpsqfWAosLEBYOkEzx8xeNpOYjFCj/dudV9m1OdAVfweGz5PLZav63x+wNqaGxqRNY3BFTf4FdDQyBllmyH5xnReEzUUmtOtgaAlOXYXz198MEHOnnypCZNmhS6lp+frxtuuEF79uzpsPFYV1enurq60P3qsM2UAQDOdbamVp83NITuD+hN4zHenF5DLUneNFtpXo/S0myleVtu00QEEC44IZmZEfl2J3jITUNjUzOyvsGvxoaA3NaODPYdA4GAPoloPCZm4lFqWm7tp/EIACnHsY3HkydPSpKKi4sjrhcXF4cea8+qVau0cuXKmMYGAIi+k5+2nGidnZmhvOysBEaTmpxcQ9O8tkoHctI5gJ4JHXITds0Yo8bG5sNsmhuSTdOSyTshaZpbqWdrauUPtJwnXZSgPR6l4HLrugs+DwDgLq7btGjx4sWqqqoKfRw/fjzRIQEAuuDjsMZj3140mBKBGgogFTUdIOWRz5emvNwMFRVmRRwcVdwn/OCoNGVmeB1/sI1pZ3/HXJ9PGWlpiQqJA2YAIEU59qd/v379JEmnTp1S//79Q9dPnTqlUaNGdfh5GRkZysjIiHV4AIAoO0HjMeGooQAQydt80JTa+dFojFGjv3la0h9QY/N+kg2Nfvn9iZ2UDA5qRiyzTuC0o8QBMwCQqhz703/IkCHq16+fysvLQ43G6upqvfrqq7r//vsTGxwAIOpOfNLSeOxX0CtxgQAA0AWWZSnNaynN23b6MRAwzQfaNB1qUx/307abJx6rWvbq7ZPA/R2l4MSjJbluR00AQGcS2nisqanRkSNHQvc/+OADHTx4UIWFhSotLdXChQv17//+77r88ss1ZMgQLVu2TCUlJZoxY0biggYAxMSJs5Wh2zQeAQDJzLYtZWZ42z3cpr7er7p6v+rr/TGbjgxOPFaETTz2TvDEo9TUfAyYhgs/EQDgGgltPO7fv19/8zd/E7q/aNEiSdLs2bP19NNP6zvf+Y5qa2v1zW9+U5WVlbrxxhv14osvKjMzM1EhAwBiJPxwmRJOtAYAuFDwcJssX8tei8aY0FRkXX3TSdsN9f4ezQUGgns8VrU0HhM98Sg1L7em8QgAKSWhjceJEyd2elKcZVn67ne/q+9+97txjAoAEG/GGJV9/U4drzij90+cUmmfokSHBABAXFiWpfR0j9LTPcrJbrpmjAlNRdY1T0Y2NgS63IxsOVymZal1ovd4lCTbSpNfnyU6DABAHDl2j0cAQOqwLEsjLhmgIf366orSgeoVfOcFAEAKsqz2l2o3NPjV2BhQQ2Mg4r+N/kDE8wImoPrGRlXVng9dK8pzQOPR9kr+REcBAIgnGo8AAMfxeNpu1A8AQKpLS/MoLc0jX6vrrVeRBQIm4kRr27JUkJsThwg7Z4kDZgAg1fDODgDgLJYlj015AgCgqyzLkmVZofv+QCBif8fC3BxH1NamOD2JDgMAEEeJrz4AAIRxwhsjAACSWcAYVYTv7+iAZdZBtsWiOwBIJby7AwA4Co1HAAB6JhAI6JOwicei/MSfaB1k0XgEgJTCuzsAgKPQeAQAoGcaA4HIE62ZeAQAJAjv7gAAjmKH7VEFAAC6JxAw8vv9qnDoxCONRwBILTQeAQCOwsQjAAAXzx/wyxijM9XhjUfnTDw2HS7DLxkBIFXw7g4A4Cg0HgEAuHgNfr9qP6/T5/X1oWt98pwz8Sgx9QgAqYR3dwAAR7FtpiAAALhYgUDktGNGmlc5vswERtQWB8wAQOqg8QgAcBQmHgEA6JnIg2XyZDls/+Sm5dYAgFTAuzsAgKPYFqUJAICeOFPlzP0dg2wajwCQMnh3BwBwFJZaAwDQM2eqIicencYSjUcASBU0HgEAjmFbtuOWgwEAkGwqwk+0znPexCNLrQEgddB4BAA4Bvs7AgDQc5+ETzw6cKm1Zdmy2FoFAFICP+0BAI7BMmsAAHomEAjok3M1oft98p231FqSLCst0SEAAOKAxiMAAAAAuMSn52rkDwRC93s7cKm1JNmWN9EhAADigMYjAAAAALjE6cqq0O1cn08Zac6cLKTxCACpgcYjAAAAALjEqbDGYx8H7u8YxFJrAEgNNB4BAAAAwCUqwhqPRQ7d31GSbMvDATMAkAL4SQ8AAAAALnE6/ERrh+7vGGTJk+gQAAAxRuMRAAAAAFwifKl1UZ5zJx4lyWKfRwBwPRqPAAAAAOASkUutnT3xyAEzAOB+NB4BAAAAwAXqGhp0tqY2dN/JezxKTDwCQCqg8QgAAAAALnDqbMu0o23bKsjJTmA0F2ZZ7PEIAG5H4xEAAAAAXOBUZWXodmFOtjy2s9/u2ZZHkpXoMAAAMeTsSgQAAAAA6JJTZytDt52+zDqIqUcAcDcajwAAAADgAic/rQzdLspz9sEyQTaNRwBwNRqPAAAAAOACJ8MmHvskzcQjB8wAgJvReAQAAAAAFwhvPPZOkolHlloDgLvReAQAAACAJGeMiTjVOlkmHm0mHgHA1Wg8AgAAAECSO/fZZzpfVxe6nzx7PKaJk60BwL349RIAAAAAJLl0b5r+31236y+nK3Tik7PK8WU2PWBZ6pOXp+rz51XX0JDYIDtgW14FjDNjAwD0DI1HAAAAAEhymelpGn/lCI0cOlhVtbWh61kZ6UpP8yo/O0unK6s6eYXEsSyvROMRAFyJpdYAAAAA4FK+9HRJUprXq+zMzARH0z6bA2YAwLWYeAQAAAAAF7JtWxlpaaH7vXKyExhNxywr7cJPAgAkJSYeAQAAAMCFcnyZsiznH9zCxCMAuBeNRwAAAABwGdu2lZWekegwusSyPOJkawBwJxqPAAAAAOAyeVk+eTzJ83bPttgFDADcKHkqEQAAAADggjLS0hx7kExHLJZbA4Ar0XgEAAAAABdJpknHIIuJRwBwpeSrSAAAAACADnnt5Jse5IAZAHAnGo8AAAAA4CLJOfFI4xEA3Cj5KhIAAAAAoEO2lXxv8yzReAQAN0q+igQAAAAA6JBtWYkOodssy5aVhA1TAEDn+MkOAAAAAC5iJWHjUeKAGQBwIxqPAAAAAOAiyTjxKEk2jUcAcB0ajwAAAADgIkk78SgajwDgNjQeAQAAAMBFkrTvyMQjALgQjUcAAAAAcAnLSuKJR4uTrQHAbWg8AgAAAIBLWErOpqMUPNma5iMAuAmNRwAAAABwi+TtO0riZGsAcBsajwAAAADgEsl6onUQ+zwCgLvQeAQAAAAA16DxCABwDhqPAAAAAOASST7wyFJrAHAZGo8AAAAA4BLJfLiMJFnyKNmnNgEALWg8AgAAAIBLJP/Eo8XJ1gDgIjQeAQAAAMA1krzzKPZ5BAA3ofEIAAAAAC6R7BOPEvs8AoCb0HgEAAAAAJdI9j0eJSYeAcBNaDwCAAAAgFskf9+RxiMAuEhSNB7Xr1+vwYMHKzMzUzfccINee+21RIcEAAAAAI7jhonHpsNlkj8PAEASNB43b96sRYsWqaysTK+//rpGjhypKVOm6PTp04kODQAAAAAcxQ17PEpMPQKAWzi+8fjYY4/pvvvu05w5c3TFFVfopz/9qbKysvTUU08lOjQAAAAAcBTLJZ1HDpgBAHdw9E/z+vp6HThwQIsXLw5ds21bkyZN0p49e9r9nLq6OtXV1YXuV1dXxzxOAADcgBoKAHAKJh4BwB0cPfF45swZ+f1+FRcXR1wvLi7WyZMn2/2cVatWKT8/P/RxySWXxCNUAACSHjUUAOAUTDwCgDs4uvF4MRYvXqyqqqrQx/HjxxMdEgAASYEaCgBwCiYeAcAdHP3TvKioSB6PR6dOnYq4furUKfXr16/dz8nIyFBGRkY8wgMAwFWooQAAp7AsWzKum5MBgJTj6J/k6enpuu6661ReXh66FggEVF5errFjxyYwMgAAAABALDH1CADJz/E/yRctWqTZs2fr+uuv15gxY7R27VrV1tZqzpw5iQ4NAAAAABAjluXoORkAQBc4vvH41a9+VRUVFVq+fLlOnjypUaNG6cUXX2xz4AwAAAAAAAAA57CMMSbRQcRSdXW18vPzVVVVpby8vESHAwBA0qCGAgAAAOgJZtcBAAAAAAAARB2NRwAAAAAAAABRR+MRAAAAAAAAQNTReAQAAAAAAAAQdTQeAQAAAAAAAEQdjUcAAAAAAAAAUUfjEQAAAAAAAEDU0XgEAAAAAAAAEHU0HgEAAAAAAABEHY1HAAAAAAAAAFFH4xEAAAAAAABA1NF4BAAAAAAAABB1NB4BAAAAAAAARB2NRwAAAAAAAABR5010ALFmjJEkVVdXJzgSAACiKzc3V5Zlxez1qaEAALeKdQ0FADRxfePx3LlzkqRLLrkkwZEAABBdVVVVysvLi9nrU0MBAG4V6xoKAGhimeA4g0sFAgF9/PHHod9oVVdX65JLLtHx48ddWWjcnp/k/hzJL/m5PUfyc45YT2tQQ93F7flJ7s+R/JKf23NMpvyYeASA+HD9xKNt2xo4cGCb63l5eY4vhj3h9vwk9+dIfsnP7TmSn/tRQ93J7flJ7s+R/JKf23N0e34AgK7jcBkAAAAAAAAAUUfjEQAAAAAAAEDUpVzjMSMjQ2VlZcrIyEh0KDHh9vwk9+dIfsnP7TmSX+py+58N+SU/t+dIfsnP7Tm6PT8AQPe5/nAZAAAAAAAAAPGXchOPAAAAAAAAAGKPxiMAAAAAAACAqKPxCAAAAAAAACDqaDwCAAAAAAAAiLqkbjzu3r1b06dPV0lJiSzL0rZt2zp9/ssvv6zx48erd+/e8vl8GjFihH70ox9FPGfw4MGyLKvNx7x582KYScdikaPf79eyZcs0ZMgQ+Xw+XXrppXr44YeViHOGYpHfuXPntHDhQg0aNEg+n0/jxo3Tvn37YphFx7qbX7g//OEP8nq9GjVqVJvH1q9fr8GDByszM1M33HCDXnvttegF3Q2xyK8nrxkLschx1apV+uIXv6jc3Fz17dtXM2bM0OHDh6MbeBfFIr8nn3xS11xzjfLy8pSXl6exY8fqhRdeiG7gXRSr78Gg73//+7IsSwsXLuxxrPHm9hrq9vopUUM7Qw1NfA11e/2UqKGdcXsNBQB0XVI3HmtrazVy5EitX7++S8/Pzs7W/PnztXv3bh06dEhLly7V0qVL9Z//+Z+h5+zbt08nTpwIfezYsUOSdMcdd8QkhwuJRY6rV6/Wk08+qZ/85Cc6dOiQVq9erTVr1mjdunWxSqNDscjvG9/4hnbs2KFf/vKXeuuttzR58mRNmjRJH330UazS6FB38wuqrKzUrFmzdPPNN7d5bPPmzVq0aJHKysr0+uuva+TIkZoyZYpOnz4drbC7LBb5Xexrxkoscty1a5fmzZunvXv3aseOHWpoaNDkyZNVW1sbrbC7LBb5DRw4UN///vd14MAB7d+/X1/60pd022236Z133olW2F0Wi/yC9u3bp//4j//QNddc09MwE8LtNdTt9VOihnaEGuqMGur2+ilRQzuSCjUUANANxiUkma1bt3b78/7u7/7OfP3rX+/w8QULFphLL73UBAKBHkQXHdHKcdq0aWbu3LkRz7n99tvNzJkzexpij0Qjv/PnzxuPx2N+85vfRDzn2muvNUuWLIlGmBetO/l99atfNUuXLjVlZWVm5MiREY+NGTPGzJs3L3Tf7/ebkpISs2rVqihG233Ryu9iXzMeYpGjMcacPn3aSDK7du3qeZA9EKv8jDGmoKDA/Nd//VfPAuyhaOZ37tw5c/nll5sdO3aYCRMmmAULFkQ11nhzew11e/00hhoajhra/deMNbfXT2OooeFSrYYCADqX1BOPPfXHP/5Rr7zyiiZMmNDu4/X19frv//5vzZ07V5ZlxTm66Ggvx3Hjxqm8vFzvvvuuJOmNN97Qyy+/rKlTpyYqzIvWOr/Gxkb5/X5lZmZGPM/n8+nll19ORIjdtmHDBr3//vsqKytr81h9fb0OHDigSZMmha7Ztq1JkyZpz5498QzzonWWn1t0N8eqqipJUmFhYSzDipru5Of3+7Vp0ybV1tZq7NixcYiu57qS37x58zRt2rSI78VU4/Ya6vb6KVFDJWqo07i9fkrUUIkaCgCpxpvoABJh4MCBqqioUGNjo1asWKFvfOMb7T5v27Ztqqys1L333hvfAKOgsxwfeughVVdXa8SIEfJ4PPL7/XrkkUc0c+bMBEbcPR3ll5ubq7Fjx+rhhx/WF77wBRUXF2vjxo3as2ePLrvssgRHfWHvvfeeHnroIf3+97+X19v22/PMmTPy+/0qLi6OuF5cXKw///nP8Qrzol0oPzfobo6BQEALFy7U+PHjddVVV8Uhwp7pan5vvfWWxo4dq88//1w5OTnaunWrrrjiijhGenG6kt+mTZv0+uuvJ2zfu0Rzew11e/2UqKHUUGdye/2UqKESNRQAUpH7/tXSBb///e9VU1OjvXv36qGHHtJll12mu+++u83zfv7zn2vq1KkqKSlJQJQ901mOv/rVr/Q///M/evbZZ3XllVfq4MGDWrhwoUpKSjR79uwER941neX3y1/+UnPnztWAAQPk8Xh07bXX6u6779aBAwcSHHXn/H6/vva1r2nlypUaNmxYosOJOrfnJ11cjvPmzdPbb7+dFNNE3clv+PDhOnjwoKqqqrRlyxbNnj1bu3btcvQbp67kd/z4cS1YsEA7duxoMxWWKtxeQ91ePyVqaDIiv7aSqX5K1FCJGgoAKSvRa72jRRe5j83DDz9shg0b1ub6hx9+aGzbNtu2bYtCdNERrRwHDhxofvKTn7R5zvDhw3saYo9E+++wpqbGfPzxx8YYY+68805z66239jTEHrlQfmfPnjWSjMfjCX1YlhW6Vl5eburq6ozH42nzOrNmzTJf+cpXYpvABUQjv+6+ZrxFO8d58+aZgQMHmvfffz/GkXdNLP4Og26++WbzzW9+MwZRd1008tu6dWub50gylmUZj8djGhsb45dQFLm9hrq9fhpDDaWGOruGur1+GkMNTeUaCgDoXEpOPIYLBAKqq6trc33Dhg3q27evpk2bloCooqt1jufPn5dtR27v6fF4FAgE4h1aVHT0d5idna3s7GydPXtW27dv15o1axIQXdfl5eXprbfeirj2xBNP6He/+522bNmiIUOGKD09Xdddd53Ky8s1Y8YMSU35l5eXa/78+QmIuuu6kl+y62qOxhg98MAD2rp1q3bu3Jk0uffk77Cj71Mn6Up+gUCgzXPmzJmjESNG6MEHH5TH44lnyAnn9hrq9vopUUOpoc7g9vopUUOpoQCQupK68VhTU6MjR46E7n/wwQc6ePCgCgsLVVpaqsWLF+ujjz7SL37xC0nS+vXrVVpaqhEjRkiSdu/erR/+8If653/+54jXDQQC2rBhg2bPnp3wPXRikeP06dP1yCOPqLS0VFdeeaX++Mc/6rHHHtPcuXPjm5xik9/27dtljNHw4cN15MgR/du//ZtGjBihOXPmxDc5dS8/27bb7FHUt29fZWZmRlxftGiRZs+ereuvv15jxozR2rVrVVtb65r8LvSa8RaLHOfNm6dnn31Wv/71r5Wbm6uTJ09KkvLz8+Xz+eKTWLNY5Ld48WJNnTpVpaWlOnfunJ599lnt3LlT27dvj1teQbHIr/VzsrOz1bt376TZYyzI7TXU7fVTooZSQ51dQ91ePyVqaCrXUABANyR24LJnXnrpJSOpzcfs2bONMcbMnj3bTJgwIfT8xx9/3Fx55ZUmKyvL5OXlmdGjR5snnnjC+P3+iNfdvn27kWQOHz4cx2zaF4scq6urzYIFC0xpaanJzMw0Q4cONUuWLDF1dXVxzi42+W3evNkMHTrUpKenm379+pl58+aZysrKOGfWpLv5tVZWVmZGjhzZ5vq6detMaWmpSU9PN2PGjDF79+6NTQIXEIv8LvSa8RaLHNt7PUlmw4YNMcujI7HIb+7cuWbQoEEmPT3d9OnTx9x8883mt7/9beyS6ESsvgfDTZgwwSxYsCBqMceL22uo2+unMdRQaqiza6jb66cx1NBUrqEAgK6zjDGm47YkAAAAAAAAAHSffeGnAAAAAAAAAED30HgEAAAAAAAAEHU0HgEAAAAAAABEHY1HAAAAAAAAAFFH4xEAAAAAAABA1NF4BAAAAAAAABB1NB4BAAAAAAAARB2NR8Cl7r33Xs2YMSPRYQApaffu3Zo+fbpKSkpkWZa2bdvW7df41a9+pVGjRikrK0uDBg3SD37wg+gHCqAN6ieQWNRQAHAXb6IDANB9lmV1+nhZWZl+/OMfyxgTp4jad++996qysvKi/sEIJLPa2lqNHDlSc+fO1e23397tz3/hhRc0c+ZMrVu3TpMnT9ahQ4d03333yefzaf78+TGIGEgN1E/A+aihAOAulkn0v6wAdNvJkydDtzdv3qzly5fr8OHDoWs5OTnKyclJRGgReOMENDU6tm7dGjFBVVdXpyVLlmjjxo2qrKzUVVddpdWrV2vixImSpK997WtqaGjQc889F/qcdevWac2aNTp27NgFmycA2kf9BJILNRQAkh9LrYEk1K9fv9BHfn6+LMuKuJaTk9NmqdjEiRP1wAMPaOHChSooKFBxcbF+9rOfqba2VnPmzFFubq4uu+wyvfDCCxFf6+2339bUqVOVk5Oj4uJi3XPPPTpz5kzo8S1btujqq6+Wz+dT7969NWnSJNXW1mrFihV65pln9Otf/1qWZcmyLO3cuVOS9OCDD2rYsGHKysrS0KFDtWzZMjU0NIRec8WKFRo1apSeeuoplZaWKicnR9/61rfk9/u1Zs0a9evXT3379tUjjzwSEatlWXryySc1depU+Xw+DR06VFu2bIn+XwDQQ/Pnz9eePXu0adMmvfnmm7rjjjt0yy236L333pPU9KYqMzMz4nN8Pp/++te/6i9/+UsiQgZcgfpJ/UTyo4YCQHKh8QikkGeeeUZFRUV67bXX9MADD+j+++/XHXfcoXHjxun111/X5MmTdc899+j8+fOSpMrKSn3pS1/S6NGjtX//fr344os6deqU7rzzTknSiRMndPfdd2vu3Lk6dOiQdu7cqdtvv13GGH3729/WnXfeqVtuuUUnTpzQiRMnNG7cOElSbm6unn76af3pT3/Sj3/8Y/3sZz/Tj370o4hYjx49qhdeeEEvvviiNm7cqJ///OeaNm2a/vrXv2rXrl1avXq1li5dqldffTXi85YtW6a///u/1xtvvKGZM2fqrrvu0qFDh+Lwpwt0zbFjx7RhwwY999xzuummm3TppZfq29/+tm688UZt2LBBkjRlyhQ9//zzKi8vVyAQ0LvvvqtHH31UUtP3HYD4on4CzkANBYAkZAAktQ0bNpj8/Pw212fPnm1uu+220P0JEyaYG2+8MXS/sbHRZGdnm3vuuSd07cSJE0aS2bNnjzHGmIcffthMnjw54nWPHz9uJJnDhw+bAwcOGEnmww8/bDe21jF05Ac/+IG57rrrQvfLyspMVlaWqa6uDl2bMmWKGTx4sPH7/aFrw4cPN6tWrQrdl2T+6Z/+KeK1b7jhBnP//fdfMAYgViSZrVu3hu7/5je/MZJMdnZ2xIfX6zV33nmnMcaYQCBgvvOd75jMzEzj8XhMQUGBWbFihZFk9u7dm6BMAHehflI/4XzUUABIfhwuA6SQa665JnTb4/God+/euvrqq0PXiouLJUmnT5+WJL3xxht66aWX2t3v6ujRo5o8ebJuvvlmXX311ZoyZYomT56sf/iHf1BBQUGncWzevFmPP/64jh49qpqaGjU2NiovLy/iOYMHD1Zubm5EbB6PR7ZtR1wLxho0duzYNvcPHjzYaTxAPNXU1Mjj8ejAgQPyeDwRjwW/1yzL0urVq/W9731PJ0+eVJ8+fVReXi5JGjp0aNxjBlId9RNwBmooACQfGo9ACklLS4u4b1lWxLXgZtuBQEBS0z/upk+frtWrV7d5rf79+8vj8WjHjh165ZVX9Nvf/lbr1q3TkiVL9Oqrr2rIkCHtxrBnzx7NnDlTK1eu1JQpU5Sfn69NmzaFlsB0NdbgtWCsQLIYPXq0/H6/Tp8+rZtuuqnT53o8Hg0YMECStHHjRo0dO1Z9+vSJR5gAwlA/AWeghgJA8qHxCKBD1157rf73f/9XgwcPltfb/o8Ly7I0fvx4jR8/XsuXL9egQYO0detWLVq0SOnp6fL7/RHPf+WVVzRo0CAtWbIkdC2aG33v3btXs2bNirg/evToqL0+0BU1NTU6cuRI6P4HH3yggwcPqrCwUMOGDdPMmTM1a9YsPfrooxo9erQqKipUXl6ua665RtOmTdOZM2e0ZcsWTZw4UZ9//nloP6tdu3YlMCsAXUX9BC4eNRQA3IXDZQB0aN68efr000919913a9++fTp69Ki2b9+uOXPmyO/369VXX9X3vvc97d+/X8eOHdPzzz+viooKfeELX5DUtNzrzTff1OHDh3XmzBk1NDTo8ssv17Fjx7Rp0yYdPXpUjz/+uLZu3Rq1mJ977jk99dRTevfdd1VWVqbXXntN8+fPj9rrA12xf/9+jR49OvSmfdGiRRo9erSWL18uSdqwYYNmzZqlf/3Xf9Xw4cM1Y8YM7du3T6WlpaHXeOaZZ3T99ddr/Pjxeuedd7Rz506NGTMmIfkA6B7qJ3DxqKEA4C5MPALoUElJif7whz/owQcf1OTJk1VXV6dBgwbplltukW3bysvL0+7du7V27VpVV1dr0KBBevTRRzV16lRJ0n333aedO3fq+uuvV01NjV566SV95Stf0b/8y79o/vz5qqur07Rp07Rs2TKtWLEiKjGvXLlSmzZt0re+9S31799fGzdu1BVXXBGV1wa6auLEiTLGdPh4WlqaVq5cqZUrV7b7eFFRkfbs2ROr8ADEGPUTuHjUUABwF8t09lMdAJKIZVnaunWrZsyYkehQAABIGtRPAAAQKyy1BgAAAAAAABB1NB4BAAAAAAAARB1LrQEAAAAAAABEHROPAAAAAAAAAKKOxiMAAAAAAACAqKPxCAAAAAAAACDqaDwCAAAAAAAAiDoajwAAAAAAAACijsYjAAAAAAAAgKij8QgAAAAAAAAg6mg8AgAAAAAAAIg6Go8AAAAAAAAAou7/A9rtHzvsggw2AAAAAElFTkSuQmCC",
      "text/plain": [
       "<Figure size 1333.5x500 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "bins = [\n",
    "    pd.Timestamp('1900-01-01 00:00:01+00:00'),\n",
    "    pd.Timestamp('2015-06-12 00:00:01+00:00'),\n",
    "    pd.Timestamp('2015-07-02 00:00:01+00:00'),\n",
    "    pd.Timestamp('2100-08-28 00:00:01+00:00')\n",
    "]\n",
    "labels = ['Before announcement', 'After announcement, before deployment', 'After deployment']\n",
    "\n",
    "#creating variables of interest\n",
    "affective_comment_phab_df = comment_phab_df\n",
    "affective_comment_phab_df['date_group'] = pd.cut(affective_comment_phab_df['timestamp'], bins=bins, labels=labels, right=False)\n",
    "affective_comment_phab_df['speakers_comment'] = affective_comment_phab_df.groupby('speaker')['timestamp'].rank(method='first').astype(int)\n",
    "#all comments prior to june 1 2013\n",
    "subset_comment_phab_df = affective_comment_phab_df[affective_comment_phab_df['date_created'] <= 1370044800]\n",
    "#getting counts \n",
    "comment_counts = subset_comment_phab_df.groupby('speaker')['speakers_comment'].max().reset_index()\n",
    "comment_counts = comment_counts.rename(columns={'speakers_comment': 'pre_june_2013_comments'})\n",
    "#merge back \n",
    "affective_comment_phab_df = affective_comment_phab_df.merge(comment_counts, on='speaker', how='left')\n",
    "affective_comment_phab_df['pre_june_2013_comments'] = affective_comment_phab_df['pre_june_2013_comments'].fillna(0)\n",
    "\n",
    "affective_comment_phab_df['new_commenter'] = affective_comment_phab_df['pre_june_2013_comments'] <= 10\n",
    "affective_comment_phab_df['est_commenter'] = affective_comment_phab_df['pre_june_2013_comments'] > 50\n",
    "\n",
    "palette = ['#31449c', '#4a7c85', '#c5db68']\n",
    "\n",
    "comment_counts = affective_comment_phab_df.groupby('date_group').size()\n",
    "speaker_counts = affective_comment_phab_df.groupby('date_group')['speaker'].nunique()\n",
    "\n",
    "print(\"Number of comments for each date group:\")\n",
    "print(comment_counts)\n",
    "print(\"\\nNumber of speakers for each date group:\")\n",
    "print(speaker_counts)\n",
    "\n",
    "comment_counts_engaged = affective_comment_phab_df.groupby(['date_group', 'est_commenter', 'meta.affil']).size()\n",
    "speaker_counts_engaged = affective_comment_phab_df.groupby(['date_group', 'est_commenter', 'meta.affil'])['speaker'].nunique()\n",
    "\n",
    "print(\"\\nNumber of comments for each date group and engaged commenter subgroup:\")\n",
    "print(comment_counts_engaged)\n",
    "print(\"\\nNumber of speakers for each date group and engaged commenter subgroup:\")\n",
    "print(speaker_counts_engaged)\n",
    "\n",
    "comment_counts_wmf = affective_comment_phab_df.groupby(['est_commenter', 'meta.affil']).size()\n",
    "speaker_counts_wmf = affective_comment_phab_df.groupby(['est_commenter', 'meta.affil'])['speaker'].nunique()\n",
    "\n",
    "print(\"\\nNumber of comments for each engaged commenter subgroup, and WMF affiliation:\")\n",
    "print(comment_counts_wmf)\n",
    "print(\"\\nNumber of speakers for each engaged commenter subgroup, and WMF affiliation:\")\n",
    "print(speaker_counts_wmf)\n",
    "\n",
    "#comment_phab_df['before_after'] = comment_phab_df['timestamp'] > pd.Timestamp('2013-07-01 00:00:01+00:00')\n",
    "#fig, axes = plt.subplots(2, 1, figsize=(10, 12), sharex=True)\n",
    "affective_comment_phab_df['polarized_wc'] = affective_comment_phab_df['dominant_wc'] + affective_comment_phab_df['valence_wc'] + affective_comment_phab_df['arousal_wc'] \n",
    "plot1 = sns.lmplot(data=affective_comment_phab_df, x=\"date_created\", y=\"polarized_wc\", hue=\"date_group\", col=\"meta.affil\", row='est_commenter', scatter=False, legend=False, palette=palette)\n",
    "plot1.set_axis_labels(\"Timestamp\", \"Count of Polarized Words\")\n",
    "plot1.set_titles(row_template=\"Established Author: {row_name}\", col_template=\"WMF Affiliation: {col_name}\")\n",
    "plot1.fig.subplots_adjust(top=0.9)  # Adjust subplots to make room for the title\n",
    "plot1.add_legend(title=\"Comment publication timestamp:\")\n",
    "fig1 = plot1.fig\n",
    "'''\n",
    "plot1 = sns.lmplot(data=comment_phab_df, x=\"date_created\", y=\"dominant_wc\", hue=\"date_group\", col=\"meta.affil\", row='new_commenter', scatter=False, legend=False, palette=palette)\n",
    "plot1.set_axis_labels(\"Timestamp\", \"Count of Dominance Polarized Words\")\n",
    "plot1.set_titles(row_template=\"Author's 100+ Comment: {row_name}\",col_template=\"WMF Affiliation: {col_name}\")\n",
    "plot1.fig.subplots_adjust(top=0.9)  # Adjust subplots to make room for the title\n",
    "plot1.add_legend(title=\"Comment publication timestamp:\")\n",
    "fig1 = plot1.fig\n",
    "# Plot for arousal_wc\n",
    "plot2 = sns.lmplot(data=comment_phab_df, x=\"date_created\", y=\"arousal_wc\", hue=\"date_group\", col=\"meta.affil\", row='engaged_commenter', scatter=False, legend=False, palette=palette)\n",
    "plot2.set_axis_labels(\"Timestamp\", \"Count of Arousal Polarized Words\")\n",
    "plot2.set_titles(row_template=\"Author's 100+ Comment: {row_name}\",col_template=\"WMF Affiliation: {col_name}\")\n",
    "plot2.add_legend(title=\"Comment publication timestamp:\")\n",
    "#plot2.add_legend(title=\"Before/After 07/01/2013 Wide Release\")\n",
    "\n",
    "plot3 = sns.lmplot(data=comment_phab_df, x=\"date_created\", y=\"valence_wc\", hue=\"date_group\", col=\"meta.affil\", row='engaged_commenter', scatter=False, legend=False, palette=palette)\n",
    "plot3.set_axis_labels(\"Timestamp\", \"Count of Valence Polarized Words\")\n",
    "plot3.set_titles(row_template=\"Author's 100+ Comment: {row_name}\",col_template=\"WMF Affiliation: {col_name}\")\n",
    "plot3.add_legend(title=\"Comment publication timestamp:\")\n",
    "'''\n",
    "# Show plots\n",
    "#fig1.savefig('031725_engaged_commenter_D_scoring_fig.png')\n",
    "#plot2.fig.savefig('031725_engaged_commenter_A_scoring_fig.png')\n",
    "#plot3.fig.savefig('031725_engaged_commenter_V_scoring_fig.png')\n",
    "#plt.savefig('031625_engaged_commenter_VAD_scoring_fig.png')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "5a91a59a-0d1c-48b3-93dd-b9df76ca68e5",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAA7oAAAHTCAYAAAAJYGTWAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8ekN5oAAAACXBIWXMAAA9hAAAPYQGoP6dpAADWQElEQVR4nOzdd3xb1f0+8OdcbcnbJsuZZDkpMwtKyCDswhcSNqWMhk1ZhZb210FL09JSSgqUQtmBQMNMyoZASEIIkEASsmPiLDK9l2yte+/5/XGla8mWbTmS9/Nu87Is3XEUHF0/95zzOUJKKUFERERERETUQyid3QAiIiIiIiKiVGLQJSIiIiIioh6FQZeIiIiIiIh6FAZdIiIiIiIi6lEYdImIiIiIiKhHYdAlIiIiIiKiHoVBl4iIiIiIiHoUBl0iIiIiIiLqURh0iYiIiIiIqEdh0CXqQfbu3Ys77rgDY8eORVpaGoQQEELguOOOa7Lthx9+iPPPPx8DBgyA3W43t3344YcBAMuWLTOf++Mf/xj3fNOnTze3iSeRY3SWa665xmzb7t27O7s5vVZX/hkhou6L18PE8XpIPRWDLiVs6NCh5gfh/v37W9xW0zRkZWWZ2//0pz9t9fgPP/ywuf2dd94Z89q8efPM1yJ/1qxZk1C7Q6EQ+vTpE7PvNddcE3fbP/7xj03O09qfqqqqhNqRiPnz58cce968eQnvu23bNhx77LF49NFHsXXrVtTV1TW77QMPPICzzz4bb7/9Ng4ePIhQKJSC1neuZcuW4Y9//CP++Mc/8kLdBm39eW/8b5OoN+L1kNfDrozXw8Ts3r27zT/jzf1py88ndRxrZzeAuo9p06bhxRdfBAAsX74cP/7xj5vd9ttvv0V1dbX5/fLly1s9fvQ206dPb3X7efPmYfz48a1u9+6776K0tLTV7bqC559/vsn3zf0S0tg999yDyspKAMC5556L888/H3l5eQCAzMxMc7tDhw7h3nvvBQB4PB7cdtttOProo+F2uwEARx99dLJvo1MsW7YM9913HwDj52fo0KGd2yAi6rF4PWx/vB4ePl4PiQwMupSw6dOnJ3xhb3wh37VrF/bu3YtBgwbF3V5KiRUrVgAwepimTp3a7LGtVitUVcWCBQvw0EMPwW63t9juyF22yH6JuvTSS3HZZZe1up3H40n4mC3ZvXs3li1bFvPcihUrsGPHDgwfPrzFfUOhED7++GMAwJgxY/D22283O3zqk08+QTAYBAD87ne/w69//eu4202fPh1Syja+i9Qfo73MmzePd2AbWbRoUavbtPazSNQb8HoYH6+HzeP1sOvp06dPi9e9Tz/9FP/6178AAKeccgpuv/32ZrcdN25cyttHyWPQpYRNmzbNfNzaHenI66eccgq++OILBAIBLF++HD/5yU/ibr9p0yaUl5cDAI455hjk5OQ0e+yzzjoL7777LsrLy/HOO+/gwgsvbHbb0tJSfPDBBwCAs88+G++8806L7Y5WUFCAmTNnJrx9subNm2deBK+55hrz+3nz5mHOnDkt7ltWVga/3w8AOPbYY5u9qAPGvKWI448/PgUtp56iI3/eibozXg/bF6+H1BHcbneLP9fRQ/EHDx7Ma2Q3xDm6lLAjjzwSgwcPBgAUFhbi0KFDcbfTdd28G33GGWdg0qRJANDk7my06NdaG6Y1efJkjBw5EgBavQP50ksvIRQKQVEUXHXVVS1u25mklHjhhRcAALm5uXjssceQm5sLAHjhhReg63qL+wcCAfOxw+FI2bZERNQUr4fth9dDIkoVBl1qk0TuYm/YsMGcGzNt2jRz2FVLd73bOh/p6quvBmBUSiwpKWl2u8jF8tRTT8XAgQNbPW5nWbp0qVkw4rLLLoPH48Gll14KwLjjvGTJkrj7RSolDhs2zHzuhRdeaFIkIbrgQmTeDmD0MERvF/13n4oKkYkcIzJM77e//S1mzJiBAQMGwOFwwOPxYNiwYbjsssta7HmIFExp6X01fm9A26pMbt26FXfccQeOOuooZGZmwuVyYciQIbjkkksSGu4bKVwTmSelqiqeeuopnHzyycjLy4PL5cLIkSNx6623Yt++fa0er6tYs2YN5syZg7POOguDBw+G0+mEy+XCoEGDMHPmTLz00kvQNC0l51q7di1uuukmHH300cjIyIDNZkOfPn0wduxYnHXWWZgzZw62b9/e4jG8Xi8efvhhnH766ebPWU5ODiZOnIh7772328xdpK6B18P2weshr4fd6XoYXRwucrPpm2++wXXXXYcRI0bA4/FACGHewIr++WttznlbtgWMz4BrrrkGI0eORHp6OtxuN4YPH45rrrkGn3/+eXJvtJti0KU2SeTCHnne7XZjwoQJ5oW9qKgIBw4ciLvPZ599BqD1+UgRV111FRRFgaqqeOmll+Jus27dOqxfvx4AEi5g0Vmii25ceeWVABBzx71xUY6eZPbs2Zg6dSruv/9+LF26FAcPHkQwGER9fT12796NV199Feeddx7OPvts1NTUdHj7/vCHP+Doo4/Go48+is2bN6OmpgZ+vx/ff/89Xn/9dVxwwQU45ZRTUFFRkdDxysrKMH36dNx4441YuXIlysvL4ff7UVRUhH//+9845phjWqyg2rhKZGe57777MGHCBNx777346KOPsHfvXgQCAfj9fuzbtw9vvfUWrrzySpxwwgnN/rtP1B//+EdMmDABTz75JDZt2oTa2lqoqorS0lJs3boVH330Ee6991788pe/bPYYH3zwAYYPH46f//zn+OSTT8yfs8rKSnzzzTeYM2cOhg8fjrfffjuptlLvweth++D1kNfD7nY9jPa3v/0NJ554Ip599lns2LED9fX17X7O0tJSnHrqqTj77LPxwgsvoKioCF6vFz6fDzt37sQLL7yAKVOm4LrrrusRVcXbgnN0qU2i7wK2dmE/8cQTYbPZcNJJJ8FisUDTNCxfvhyXX355zPZbtmwxe1Jam48UMWjQIMyYMQOffPIJXnjhBdx1111NtoncWcvMzMSsWbPMi3xXU1NTg4ULFwIARo0ahRNOOAEAcMIJJ2DUqFH47rvvsGjRIlRVVSErKytm39tvvx0zZ85ESUkJbrzxRgDxCyZEF1x45ZVX8OqrrwIA5syZg6OOOsrcLlKVsiP5fD44HA5MmzYNkyZNwvDhw+HxeFBaWorvvvsO8+fPR0VFBT788ENcddVV+N///hez/2WXXYbjjjuuxfcFHN57+3//7//hb3/7GwDAYrHgsssuw4wZM+ByubBx40Y899xzKC4uxrJly3DKKadg1apVcDqdzR5PVVVceOGFWLlyJU455RTMnDkT/fv3x/79+/HMM89g8+bNqKysxGWXXYbNmze3WlimM/l8PlitVvzwhz/E5MmTMWLECGRkZKCiogK7du3CSy+9hP3792PNmjWYOXMmVq5cCZvN1ubzvPXWW2bvhMvlwuWXX44TTzwROTk5Zqj+5ptvzOIz8bz55pu49NJLoWkabDYbzjvvPEyfPh19+/ZFTU0Nli5ditdeew21tbWYNWsWPv74Y8yYMeOw/26od+D1MPV4PeT1sDteDyNeffVVfPjhh8jMzMTVV1+N8ePHw2KxYP369THVvlOpoqICP/zhD7Fjxw4Axrz0Cy64ACNGjICiKNi0aRPmzZuH/fv349lnn4Wqqr2r8JgkaqOBAwdKABKALCkpiXlN13WZm5srAcj77rvPfH7ChAkSgLzhhhuaHO/f//63ebw77rgj7jmff/55c5u//vWvUkopX3rpJfO5NWvWxGwfDAZlXl6eBCCvv/56KaWUX375pbn91VdfHfc8f/jDH8xt/vCHPyT4N5Kcp556yjznnDlzYl6bM2eO+doTTzzR7DF27drV6nuLiH6PS5cubXa7pUuXtvp3MW3aNHObwz3GZ599JisrK5tth9frlRdffLF5nGXLliX1viKuvvpqc/tdu3Y1ef2LL76QQggJQHo8Hrl8+fIm25SXl5s/2wDkL37xi7jnGjJkiLkNAPnkk0822cbn88kTTjjB3ObVV1+Ne6zo/9ap+Ag/3GOtXr1aHjx4sNnXA4GAvOOOO8xjz5s3L+52rf2MnHPOORKAtFgscuXKlc2ez+fzyVWrVjV5/vvvv5cZGRkSgBw8eLDcsGFD3P1XrVolMzMzJQA5cOBAGQwGmz0XUQSvh6nF6yGvh1J23vWwseh/a839LEVvA0AWFBTI/fv3N3vMtvx8JrLtzJkzJQAphJAPP/xw3G1qa2vlGWecYR7rgw8+aPG8PQmHLlObtTRcK7paZPSQq5bmJbV1PlLEBRdcgIyMDABNi3C8++67KCsrA3D4w7Tuu+++VhcIT8VC7JFhWEKIJlU4r7zySnM4Tk8drjVlypQmd+ajeTwePPvss+ayFfPnz++Qdj344INm1c8HH3ww7hDCnJwcvPHGG+aai//5z39iqjTGM3v2bNxwww1Nnnc6nfjzn/9sfv/RRx8l0frD09rPe/S/pYkTJ6Jfv37NHstut+Ohhx4y58sd7n+3oqIiAMAPfvADnHTSSc1u53Q6zUI/0R588EHU1NTAYrHgrbfeanZdzEmTJmHu3LkAgH379uH1118/rPZS78LrIa+HqcTroaErXA8PhxACr7zyCgYMGNAh51u7dq3Zq//zn/8cd9xxR9zt0tLS8Morr5i9ypFrXW/AoEtt1tJwrcj3DocDJ554ovl85EOxsLAQxcXFMfu0dT5ShMvlwiWXXAIAWLBgQcy8g8hFcNSoUS3+ctzZCgsL8eWXXwIATj755CaLug8ZMsT8O1m9ejU2b97c0U3sEtLT082AsmrVqnY/XyAQwPvvvw/AqPp57bXXNrvtkCFDzOGHXq8XixcvbvHYzV2IAOPfidVqzCjZsmVL3G2GDh0KKaX5pyuzWCzm0MPVq1cfVnsjvzTt27cP1dXVbdpXSomXX34ZgFGA57jjjmtx+0svvdT8+2/tvyMRwOthKvF6mBheDxt0tevhlClTcOyxx3bY+SI3OoQQuPvuu1vcNjs7Gz/60Y8AGJ8z0RXHezLO0aU2S+TCPnHixJi5GVOmTIEQAlJKLF++3LwgRy/LkOh8pGjXXHMNnnnmGZSVleHdd9/FrFmzUFJSYq4VGKlGeTguvfRSXHbZZS1u06dPn8M+PgA899xz5uPmlnu48sorzb/X559/Hv/4xz+SOmdXFAgE8Nprr+Gtt97C+vXrUVxcDK/XG/fC1RFVGNevX29eBKZPn97q3KAzzjgDzz77LADjF4/Iz3djbre72R5FwOgFzcvLw6FDh8xKrR2ptYqZkeVUInRdx//+9z+8+eabWLduHQ4cOIDa2tq4y3/U1taipqamzfOUTj/9dKxbtw4VFRWYNm0afvWrX+Gcc84xe69asnnzZrMoSnp6epP5bPGkpaWhqqoKW7dubVM7qXfi9bABr4epweuhobOvh4djypQpHXq+yNJlWVlZWL16davbR/47BgIB7Ny5E2PGjGnX9nUFDLrUZiNGjEB+fj72799vDs2KrHEXuQBFD+cCjCEtY8eOxebNm7Fs2TLzg68t6wXGE1lDcPv27Zg3bx5mzZqFl156CaqqJr1WYEFBQbsuDq5pmnk3zul04uKLL4673cUXX4zbbrsNPp8PL730Ev72t7+Zdzl7go0bN+LCCy9sdWmYiI6oNHnw4EHz8ahRo1rdPnqb6H0by83NbbUyZGQtR7/f3+p5U60tP+/79u3DzJkzW6yI2djhBN1f//rXePfdd7FlyxasX78eP/7xj2GxWHDcccdh8uTJOOWUU3DmmWfC5XI12Td6KOWbb76JN998M+HzdpdfrKhz8XqYGrweGng9jNWZ18PDkZ+f36Hni1zjKisrMWvWrDbt21uucR0ydPn999/Hb37zG9xzzz14+eWXe013eU8WuXBLKc2hVtHVIuMNuYo3L+lw5yNFi9yl/uCDD1BaWtpt1gr88MMPzYvA//3f/zUbADIyMnD++ecDAIqLi80hRD1BRUUFTjvtNPOiPmjQINx888145JFH8N///hcLFy7EokWLsGjRIvzgBz8AgLi9halWW1trPo7MhWpJWlpa3H0bU5SeMVskFArhzDPPNENuXl4eZs+ejblz5+Lll1/Gm2++af53O+WUU8z9DmdN3ezsbHz11Vf47W9/i759+5rHWbNmDR599FHMmjULffv2xb333otgMBizb1uHOkdrfCyi5vB6mDxeD3k97Ani3XBtT7zGtS6p22BFRUW45557AAC/+c1vMGHChJjXQ6EQzj///CaTyP/yl7/gww8/bDIMjrqPadOm4b///S8A4+I8a9Ys8yJttVrjzgOaOnUqnnjiCfMXgCOOOMLcp63zkaJdddVVuPfeexEKhXD33Xdjw4YNALrXWoGvv/56wmvAPf/88zjvvPPaq1kd6rHHHkNJSQkA4xe0Z555ptm783/5y186rF3p6enm47q6ula393q9cfftqRYsWGDOmTr99NOxaNGiZn8BisyRTUZ6ejr+/Oc/409/+hPWr1+PlStX4vPPP8eSJUtQVlaG2tpazJkzB6tXr8YHH3xg/luK/oXr3nvvNZcpIkolXg+Tx+shr4fUVGs3MiJTbQYPHow9e/Z0UKu6l6Rup7zyyiv43//+h2XLluGYY45p8vqf//xnfPjhhzETxaWU2LZtG2bOnNklJo7T4Yk3Lynyddy4cTG/YEZEX7g/++wzFBUV4cCBAwAObz5SRGQNQaBhYn5krcCuqry8HO+8885h7fvee++ZPQXd3SeffALA+GXw4YcfbnEIWkd+iPfv3998nMgQsuhtOqraYmeK/HcDgH/+858t3uVP5X83RVFw/PHH49Zbb8Urr7yC4uJiLFq0yPzs+Oijj/Dee++Z20cPI+uIuWzUO/F6mBxeDw28HvYOkeHYQOu9qpFq6c2JXONKSkpiCtBRg6R6dFeuXAnAuKPfeHK63+/Hww8/DCEEsrOz8ac//QlDhw7FU089hbfffhvr16/Ha6+9hksvvTSZJlAnGTVqFPr374+DBw9iw4YNqKysNC/szd2JHjBgAIYPH44dO3Zg2bJlMfMDDneYVsQ111wT88v3JZdc0uFDSNri5ZdfNj/gpk2bltD7/+KLL/Dxxx8jFArhpZdews9//vN2bmX7i1Qczc3NbXFJhXXr1rX6y0z0MKhkb6Ide+yxcDgcCAQCWLZsGUKhEGw2W7PbR1eWjLfETU8TXSl2+PDhzW5XUlKCb7/9tt3aoSgKZs6cif379+PWW28FAHz++ec499xzAQDHH388MjIyUFNTgyVLlkDX9R45XI46F6+HyeH10MDrYe8Q/d82cnOrOa1V1Z42bRo2b94Mv9+Pzz77DKeeemoqmtijJBV0v//+ewghmgxZBow767W1tRBC4LnnnjOHlpx55pkYO3YsioqK8PrrrzPodmPTpk3DK6+8Al3X8fTTT5vVIhsX3og2ZcoU7NixA8uXL49ZXy3ZC/sFF1yAKVOmmBfL66+/PqnjtbfoYVp/+ctfMHny5Fb3Wb9+vbk8yvPPP98jLuyRpWNKSkpQW1vb7DCnP/3pT60eK7rXJJHhVS1xOBw455xzsHDhQpSVlWHevHnN/kzt3bsXCxYsMNtw5plnJnXu7iDy3w0AduzYYc4Xa+yvf/1rh9xljl6GRFVV87HFYsEVV1yBJ554Anv27MEzzzwTd81GomTxenj4eD008HrYO7hcLgwdOhS7d+/G119/Da/XG3fURygUwhNPPNHisa666io8/vjjAIy1rqdPnw6LxdIu7e6ukrq1HelSj1fgYOnSpQCMIiXR8ycsFgsuu+wySCmxbt26ZE5PnSz6YvzQQw8BMO4innzyyc3uE7m7vWnTJnz44YcAkpuPFOFyufDZZ5/hq6++wldffYWJEycmdbz29O2335q9XMOGDUvoog4Yd1Ujpfg3btzYpmq3XVXkv5OUEr/73e+avC6lxO9///uEloUZNmyY+Xjt2rVJt+2Xv/yleVf87rvvNkewRKusrMRFF11k/iJx0003tbmqcFvt3r0bQgjzT2eI/vf1+9//Pu48oqeeegqPPvpo0ue64YYbsGnTpmZfV1UVTz/9tPl94zUMf/Ob35h30G+//Xa8+OKLLZ6vpKQEc+bMMec2EiWC18PDw+thA14P264rXA8Px1lnnQUAqK+vxx/+8Icmr6uqihtvvLHVZe5OOOEEXHjhhQCMpYauuOKKFitxq6qKhQsX4t///ncSre9ekurRjQy1iV4fLmLlypUQQsTtRj/yyCMBoMlC6dS9RF/YIwUUjjnmmBaH3EQu4FJK80ZJMvORuqPou9c/+clP2rTvlVdeaRaAe/755zF+/PiUtq2j3XLLLXjuueegaRoeffRRfPvtt7jgggvQr18/7N27F//973+xbt06jB07Fi6Xq8VfZqZMmQKbzYZQKIQHH3wQQggcc8wx5nyYnJycNg2jOvHEE/GrX/0Kf/3rX1FbW4tp06bh8ssvx4wZM+ByubBp0yY888wz5ufYMccck9Cd9p7gpz/9Ke6//37U1dVh0aJFGDduHK688koMHDgQxcXFWLhwIZYvX45+/frh6KOPxscff3zY53r66afx9NNP4wc/+AFOOeUUHHXUUcjJyUFdXR127tyJV155xZwTNmrUKFx00UUx+w8cOBCvvPIKzjvvPAQCAVx99dWYO3cuzjvvPIwcORIulwvV1dX47rvv8NVXX2HlypXQNC2mWjRRa3g9PDy8Hjbg9bD3uP322/Hcc88hGAxi7ty52LZtGy644AKkp6ejqKgIL774IgoLC3HZZZfhlVdeafFYzz33HL777jts3LgRr776Kj766CNccsklmDBhArKzs+Hz+bB//36sW7cOH3/8MSorK3Httdd20DvtfEkFXZfLBa/Xi4qKipjna2trzTt08e5mRgqX9JbS1j3V6NGj0a9fP3OIFtD8fKSI4cOHm2sORiQ7TKs7CQaDMVVo23ph//GPf4xf//rX0HUd//3vf/HQQw/FFDbobo477jj861//wq233gpd1/HZZ5+Zy3NEjBkzBm+99Rauu+66Fo+Vl5eHX/ziF/jrX/8Kr9eLe++9N+b1adOmxaxTmYj7778fVqsV999/PzRNw0svvYSXXnqpyXbTpk3Dm2++2aXnwaVS//798fLLL+Oyyy6D3+/H+vXrsX79+pht8vPzsWjRopTdOd68eTM2b97c7OvHHHMM3nrrrbj/Dc4880wsX74cV1xxBXbu3Bm3vdHS0tLavSeCehZeD9uO18NYvB72HmPGjMHjjz+OG264Abqu4/3332+yVNZ1112H//f//l+rQTcjIwOff/45brjhBrz66quoqqrCU089haeeeqrZfXpTkbCkhi4PGTIEAPDVV1/FPP/ee++Z6yXGG4YSCcYZGRnJnJ66gMbzjxIZcjVlypSY73vThf2dd95BeXk5AGOYUiKLr0fLz883K2pWVlYmNISpq7v55puxcuVKXHzxxejXrx9sNhv69OmDk046CXPnzsU333yDESNGJHSs+++/HwsWLMBZZ52Ffv36NSmSdzj+9Kc/YcOGDbjtttswduxYpKenw+FwYODAgbjwwgvx5ptvYtmyZcjNzU36XN3J+eefj7Vr1+Kaa67BoEGDYLPZkJubi/Hjx5vLAKViyOT+/fvx7LPP4pprrsG4ceOQnZ0Ni8ViznOaNWsWXn75ZaxduzZmrm5jJ554IgoLC/HSSy/hkksuwbBhw5CWlgar1YqcnBxMmDAB119/PV599VUcOnTIHBZJlCheD9uG18OmeD3sPa699lp8+eWXuOSSS9C/f3/YbDb069cP55xzDt599108/fTTCRdPzMjIwCuvvIK1a9fizjvvxPHHH4/c3FxYrVakpaVh5MiRmDlzJubOnYsdO3b0qt52IZMox3bzzTfjySefhNvtxpIlS3DCCSegtrYWU6dOxfr169GvX7+4FcVuv/12PPbYYxg/fjy+/vrrpN4AERERERERUbSkenRvuOEGCCHg8/kwZcoUHH/88TjyyCOxYcMGCCGaHVqxdOlSc74AERERERERUSolFXSPP/54/P73v4eUEqqqYv369SgvL4eUEmPHjsWvfvWrJvtEz7NqPGSHiIiIiIiIKFlJDV2OeOutt/DMM8+gqKgIbrcbp59+On7961/HrTZ44403mktBHDhwAP369Uv29ERERERERESmlARdIiIiIiIioq4iqaHLRERERERERF0Ng24nu+KKKzB+/HhcccUVnd0UIiKidsfrHhERdQRrZzegt9u2bRvWrl3b2c0gIiLqELzuERFRR0go6M6ePbtdTi6EwLPPPtsuxyYiIiIiIqLeKaGgO2/ePAgh2qUBDLpERERERESUSgkPXU6kOLMQosXtGr/eXuGZiIiIiIiIeq+Egu6uXbuafS0YDOLXv/41Fi1ahLS0NPzkJz/BqaeeihEjRsDj8aCurg5FRUVYsmQJXn75ZdTW1mLWrFl44IEHYLVyijARERERERGlVkJJc8iQIc2+dtFFF+F///sfpk6dildeeQX9+vVrss0xxxyDCy64APfeey8uu+wyLFq0CBaLBa+++urht5yIiIiIiIgojqSWF3r11VexcOFCDBo0CO+9917ckButb9++ePfddzFw4EC88cYbeO2115I5PREREREREVETSQXd5557DkIIXHvttfB4PAnt4/F4cN1110FKyUJURERERERElHJJBd2NGzcCAAoKCtq03+jRo2P2JyIiIiIiIkqVpIJuZWUlAKCqqqpN+1VXV8fsT0RERERERJQqSQXdvn37AgDeeuutNu339ttvx+xPRERERERElCpJBd3TTjsNUkp88MEHeP755xPa58UXX8R7770HIQROPfXUZE5PRERERERE1ERSQffOO++EzWYDAFx//fW47rrrsGXLlrjbbt26Fddffz1mz54NALBarbjrrruSOT0RERERERFREwmto9uco446Cg8//DB+9rOfAQCef/55PP/88+jTpw9GjBgBt9uN+vp6FBUVoaSkBAAgpQQAPPLII/jBD36QZPOJiIiIiIiIYiUVdAHg5ptvRm5uLm699VaUlZUBAIqLi81gCzSEWwDIy8vDv//9b1x88cXJnpqIiIiIiIioiaSGLkdccskl2L59O+bOnYupU6fC4/FASmn+8Xg8mDZtGh5++GFs376dIZeIiIiI6DBIqXd2E4i6haR7dCMyMzNx55134s477wRgLCHk9XqRlpaGzMzMVJ2GiIiIiKjX0aUGVasFoMBuzejs5hB1eUkF3UhhqeOOOw633357zGuZmZkMuERERERESZBSh6rXQdV8ACQsiquzm0TULSQVdOfNmwchBI499thUtYeIiIiIqNeTUkLTfVD1Og5XJjoMSc3Rzc3NBQDk5+enpDFERERERL2dpvsRUCsQ0moZcokOU1JBd9iwYQBgVlsmIiIiIqLDI6VEUK1GUK2GlGpnN4eoW0sq6M6aNQtSSrz//vupag8RERERUa+j6yEE1Apour+zm0LUIyQVdG+++WYMHDgQ7733HhYuXJiqNhERERER9XjGPFw/AqEKBNQK9uISpVBSQTcrKwtvvfUW8vPzcdlll+GXv/wl9uzZk6q2ERERERH1OFJKqFodAmoZgmo1dBnq7CYR9ThJVV2eMWMGACPw7tu3D3PnzsXcuXORn5+P/Px8uFwtlz8XQmDJkiXJNIGIiIiIqNtQdR9UrQ5Sap3dFKIeLamgu2zZMgghAMD8KqXE/v37sX///hb3lVKa+xARERER9WSaHoSqedl7S9RBkgq6gBFYE3mOiIiIiKi30aUKVfNC0wOd3RSiXiWpoKvrXNeLiIiIiKgxKSVU3QtV8wFgJxBRR0u6R5eIiIiIiBroeghBrYZVlIk6EYMuEREREVGKqJoPIa0W7MUl6lwMukRERERESZJSIqTVQtN9nd0UIkKKg66UEmvWrMGqVatw8OBB1NbWIj09HQMGDMCkSZMwfvx4VlomIiIioh5FSo3r4RJ1MSkLuk888QQefPBB7Nmzp9lthgwZgnvuuQc33XRTqk5LRERERNRpND2IkFYNKVmklagrUZI9gN/vx49+9CPceuut2LNnD6SUzf7ZvXs3fvazn+FHP/oRAgGWWCciIiKi7kvV6hBUKxlyibqgpHt0r7nmGnz44YcAACEETj31VJxxxhkYNWoU0tLS4PV6sX37dixevBiffvopdF3HRx99hKuvvhqvvPJK0m+AiIiIeidND8Ki2Du7GdQLGfNxa6Dp/s5uChE1I6mgu3TpUrz22msQQmDo0KF45ZVXMHHixLjb/uIXv8A333yDyy+/HDt27MDrr7+Om266CdOnT0+mCURERNRLaXo9pAzBavF0dlOoF9GlhqBaxaWDiLq4pIYuv/DCCwCA9PR0LFu2rNmQGzFhwgQsWbIEGRkZAIDnn38+mdMTERFRLyYBhDQvVK2us5tCvYSmBxBUKxhyibqBpILu559/DiEErr32WgwaNCihfQYPHoxrr70WUkqsXLkymdMTERERIaR5wz1snCdJ7Yc/Z0TdS1JB99ChQwCMntq2iGwf2Z+IiIgoGZoeQECthJRaZzeFehgpdQTVKo4cIOpmkgq6imLsrmltu6hEto/sT0RERJQsKVUE1EroDLuUInr4Z0rTuVoIUXeTVNIcMGAAAODLL79s036R7fv375/M6YmIiIhiSKkhqFZA04Od3RTq5jTdj0CI83GJuqukgu60adMgpcS8efNQWFiY0D6FhYWYN28ehBCYNm1aMqcnIiIiaiIy1JRLv9Dh0PUQAmolgmo1jJJnRNQdJRV0r732WgCA3+/HKaecgsWLF7e4/ZIlS3DqqafC5/MBAK677rpkTk9ERETUDImgWg1V93V2Q6ib0KWKoFqFgFoBnSMCiLq9pNbRnTRpEq677jo888wzKC4uxtlnn42jjz4aZ5xxBkaNGgWPx4O6ujps374dH3/8MdavXw8pJYQQuO666zBp0qRUvQ8iIiKiJkJqDTQlAJvigaLYOrs51AXpUoOqeTkCgKiHSSroAsATTzyB2tpavPrqqwCAjRs3YuPGjXG3ldIY/nHppZfiiSeeSPbURERERK3S9QACegBWiwc2S1pnN4e6CCl1hMyAyyHKRD1N0mWPLRYLFixYgAULFuD444+HlLLZP+PGjcOrr76K//73v6y4TERERB1K1eoQVKvNG+/UO0UCrj9UBk33gSGXqGdKukc34tJLL8Wll16KPXv2YPXq1Th48CBqa2uRnp6O/v37Y9KkSRgyZEiqTkdERETUZpHhqXZrZie3hDqalBKaXg9Vr4eUemc3h4jaWcJB96677sL06dMxdepUZGVlNbvdkCFDGGiJiIioy9J0P4KqgN2a0dlNoQ6i6X6ENC8k11gm6jUSHj/88MMPY9asWcjLy8O4ceNw11134e2330ZVVVU7No+IiIgo9TTdF14+hnoyKXUE1KrwkHWGXKLepE1DlyNzbdevX4/169fjkUcegRACxxxzDKZPn55Qjy8RERFRV2D07ErYLJkQQnR2cyjFjOWCqiGl2tlNIaJOkHDQ/ec//4nly5djxYoVKC8vN59n8CUiIqLuStMDkKiC3ZIJIVgosyeQUkLV66FqdWChKaLeS8jDKD24adMmLFu2DMuXL8dnn32G0tLS2ING3RVl8G3Z+PHjsXbtWowbNw5r1qzp7OYQERG1q1Re9wJqFXQ9kJJ2CWGFVXHDojjZu9uNGXNx63p0L65FcXF+OVECDqvq8lFHHYWjjjoKt956KwBg69atMcH30KFD5rat9fied955qXknRERERIdJShUhrQaq7oXdkgVFsXV2kygBUkpIqND0IDTd36MDLhG1TUqWFxozZgzGjBmDm2++GQDw3XffmcF3+fLlOHDggLltdPB99NFHoar8QCIiIqKuwSheVAmbJR1Wi6uzm0PNMIYne6FqXAeXiOJL2Tq60UaNGoVRo0bhhhtuAADs2LHDDL4ffvghysvLuVg7ERERdVESIa0GEipslvTObgxFkVKHpvvDa+GyijIRNa9dgm608vJybNiwwfxTUVHR3qckIiIiSpqq1UOXGuyWDBaq6mRS6lD1OvbgElHCUh50S0tLsXz5crMHd8uWLeZr0b24+fn5mDJlSqpPT0RERJQyuh5AQFbAbs2CItq9f4AaMQJuPVStHgy4RNQWSX9iHzp0KCbYFhYWmq9FB9vhw4djypQpmDp1KqZOnYojjzwy2VMTERERtTspNQTVSjisORDC0tnN6RWklND0+vAQZb2zm0NE3VCbg+7+/ftjgm1RUZH5WiTYCiEwduxYM9ROnToV/fv3T12riYiIiDqQUaSqCg5rNocxtyMj4Pqg6nUMuESUlISD7rXXXovly5dj165d5nORYGuxWHD88ceboXbKlCnIzs5OfWuJiIiIOomUKgJqBeyWTC4/lGK6HoKq+6DLAAMuEaVEwkH3+eefhxACUko4HA5MmjTJDLYnnXQSPB5Pe7aTiIiIqNNJqSGgVsKiOGFVXAy8h0lKCV0GoekBhlsiahdtHroshMDkyZNxxhlnYNq0aZgwYQIsFs5XISIiot7CGF6r6T4IYYVVccGiODmkuRVS6ma41fQAWFyKiNpTwkE3IyMDNTU1AIClS5di6dKlAAC3240TTzwR06ZNw9SpU3HiiSfCbre3T2uJiIiIuhApVYS0WoQ0LyyKAxbFCUXYIYTo7KZ1CbrUoOsBaDIAXQ+B4ZaIOkrCQbeiogLffvstli9fjuXLl2PFihWorKxEXV0dlixZgk8//RQA4HA4MHHiRDP4nnTSSXC73e32BoiIiIg6n4Sm+6HpfgihwKK4YVVcvbKXV9dD0KTRayul2tnNIaJeSsjoNYDaQEqJDRs2mMH3s88+Q3l5ecOBw3cyrVYrxo0bh6lTp2LatGk4+eSTkZGRkZrW9wDjx4/H2rVrMW7cOKxZs6azm0NERNSuUnndC6hV0PVAilrWHoQxl9fi7tFr8HK+bceyKC7Yrfxdmqg1hx1049m0aZMZfJcvX47S0tKGE4WDr6IoOOaYY8xCVrNmzUrV6bslBl0iIupNelfQjRCwWdJgtfScEW6cb9t5GHSJEpPS24tHHXUUjjrqKPzsZz8DAGzdujUm+B46dAiapuHbb7/Ft99+i3/9619Q1cMf0lJTU4P33nsPq1evxpo1a7B//36UlpYiEAggOzsbRx99NM477zz89Kc/RVpaWovHklJi/vz5eOGFF7Bp0yZUV1ejf//+OPXUU3Hbbbfh2GOPPex2EhERUW8mEdJqockgLMIGIWywKN2znokuQ1C1Omh6EAy3RNSVpbRHtyVVVVV4+umn8dBDD6G0tBRSSgghoGnaYR/zk08+wemnn97qdoMGDcKbb76JiRMnxn29vr4eM2fOxMcffxz3dZvNhkceeQQ333zzYbe1OezRJSKi3qR39ug2JYQFFsUJi+KCIrru6hW6DEHTg5BSg4QGXQ92dpN6PfboEiWm3SaMVFZW4rPPPjN7czds2ABdT/2cjcGDB2PGjBkYP348Bg0ahP79+yMYDGLPnj3473//iw8++AB79+7FGWecgU2bNiE/P7/JMa6++moz5J5xxhm47bbb0LdvX3zzzTeYM2cODh48iJ/97GcYNGgQzj333JS/ByIiIupdpNSganVQtToowhau2Nw1ildpehC6WUzq8DskiIg6U8qCbnl5ecww5U2bNiG6s7hxx3G/fv0wbdq0pM55yimnYM+ePXFfO/nkk3HFFVfg0UcfxR133IGqqir84x//wD//+c+Y7T7++GO88cYbAIALL7wQr732GhTFuMhMnDgRZ599No4//nhUVVXh9ttvx5lnngmbjYvDExERUWroMgRdC0HV62G1pMEinJDQjF5UqQGQEMISXrYo9UE4er6tLoMsJkVEPcJhB92SkpKYYLtly5aY1xsH2/79+2PatGmYPn06pk+fjlGjRh3uqU0WS+tDfW655Rb89re/hdfrxYoVK5q8/tBDDwEwqkP/61//MkNuxNChQ/Gb3/wG99xzD3bt2oVFixbhkksuSbrtRERERNGk1BFSaxBCTTNbCFgUBxRhh6JYw/sYU8EELG0KwVLqRiEpGQgPR+Z8WyLqWRIOugcPHowJtoWFhTGvNw62+fn5mDZtmhluR44cmZoWt5HVaoXT6YTX60UgEDuPp6amBkuXLgVgDFnu379/3GNcddVVuOeeewCAQZeIiIg6SXitXviBOCOKhVCgCHt4OaOmo890qRq9tnoAugx1QHuJiDpPwkE3Pz/fXCIIaBpsBw4cGNNjO3z48NS1MglLly5FWVkZAGD06NExr3399dcIBo2iClOnTm32GH379sXo0aNRWFiIlStXtl9jiYiIiA6TlDo06Yem+6EIW7iHV0BCjxoGTUTUO7Rp6HJ0uB08eHBMj+2RRx6Z8sYdLq/Xi7179+L11183hyYDwO233x6z3datW83HBQUFLR6zoKAAhYWF2LdvH+rq6uDxeFLbaCIiIqIU0WWIo5GJqFdLOOgOGTLEDLXTpk3DsGHD2rNdbfbYY4/htttui/uaxWLBQw891KTXdt++febjgQMHtnj8yOtSSuzbt69J73C0J598Ek899VRC7Y4O20RERN0Rr3tERNTVJBx0d+3a1Z7taDfTpk3D448/jrFjxzZ5rba21nzcWg9t9Oter7fFbQ8ePIi1a9e2saVERETdE697RETU1bTbOrod7cc//jGmT58OAKivr0dhYSFefPFFfPLJJ7jkkkvw1FNP4aSTTorZx+/3m4/tdnuLx3c4HOZjn8/X4rb9+/fHuHHjEmr31q1bWz0eERFRV8brHhERdTU9Jujm5OQgJyfH/H7SpEm48sor8cADD+DXv/41ZsyYgUWLFuHss882t3E6nebjSFGq5kRXbHa5XC1ue+ONN+LGG29MqN3jx4/nXXAiIurWeN0jIqKuJvWrjncxv/rVr3DiiSciEAjghhtugKqq5mvp6enm47q6uhaPE/16Wlpa6htKREREREREKdHjgy4AnHfeeQCM4lOrVq0yn48uQBVdmCqeyOtCCOTn57dDK4mIiIiIiCgVekXQzcvLMx9///335uMxY8aYj7dt29biMQoLCwEY4Zg9ukRERERERF1Xrwi6+/fvNx9Hh9SJEyeaRahWrFjR7P4lJSVm0J08eXI7tZKIiIiIiIhSoccHXV3XsXDhQvP7o446ynyckZGBU045BQCwePFiHDx4MO4xXnjhBUhprLo+a9asdmwtERERERERJatbB90XXnghphpyY7qu45577sHGjRsBGL2xw4YNi9nm7rvvBgCEQiHcdtttZqCN2L17N+6//34AwLBhwxh0iYiIiIiIurhuvbzQH/7wB9x99924+OKLMXnyZBx55JHweDyorq7GunXr8MILL2DdunUAjCHLjz32WJNjnH766bjwwgvx5ptv4s0338RZZ52F22+/HX369MGaNWswZ84cVFVVQQiBRx55BDabraPfJhEREREREbVBtw66AFBeXo7//Oc/+M9//tPsNiNHjsT8+fNx3HHHxX39hRdeQE1NDT7++GMsXrwYixcvjnndZrPhkUcewf/93/+lsulERERERETUDrp10P3www/x3nvvYeXKlSgqKkJxcTEqKirgcrnQv39/HH/88Zg5cyYuuOACs+hUPB6PBx999BHmz5+PF154ARs3bkRNTQ369++PGTNm4Pbbb8exxx7bge+MiIiIiIiIDle3DroFBQUoKCgw59kmQwiBq666CldddVUKWkZERERERESdJaGgO2PGjHY5uRACS5YsaZdjExERERERUe+UUNBdtmwZhBApPbGUMuXHJCIiIiIiIkp46HLjZXcai4TWlrZLZBsiIiIiIiKiZCS0jq6u683+qaysxKxZsyClxKBBg/DAAw/gm2++QVVVFUKhEKqqqvDNN9/ggQcewJAhQyClxAUXXICqqipomtbe74+IiIiIiIh6maSKUWmahvPOOw+ff/45Lr30Ujz33HNwuVwx22RkZGDcuHEYN24cbrvtNsyePRuvvvoqysvLsWTJEihKQlmbiIiIiIiIKCFJpcxnn30WK1aswJgxYzB//vwmIbcxp9OJF198EQUFBfjss8/w7LPPJnN6IiIiIiIioiaSCrovvfQShBC4+uqrYbUm1jlstVrx05/+FFJKzJ8/P5nTExERERERETWRVNAtLCwEAAwdOrRN+w0ZMiRmfyIiIiIiIqJUSSro1tbWAgBKSkratF9k+8j+RERERERERKmSVNDNz88HALz66qtt2i+yfWR/IiIiIiIiolRJKuieddZZkFJi5cqVuO+++xLa589//jM+//xzCCHwox/9KJnTExERERERETWRVND95S9/CY/HAwD405/+hNNOOw0ffPABfD5fzHY+nw8ffPABzjjjDPzhD38AAHg8HvziF79I5vRERERERERETSS1ju7gwYMxf/58XHrppVBVFUuXLsXSpUuhKAr69esHt9uN+vp6HDp0CLquAwCklLDZbJg/fz4GDRqUkjdBREREREREFJFUjy4AzJw5E59++ilGjhwJKSWklNA0Dfv370dRURH2798PTdPM10aPHo2lS5fi/PPPT0X7iYiIiIiIiGIk1aMbMXnyZGzZsgXvvPMOFi1ahK+//hoHDhyA1+tFWloaBgwYgEmTJmHWrFk499xzoShJ52siIiIiIiKiuFISdAFAURScf/757KklIiIiIiKiTsWuVSIiIiIiIupRGHSJiIioW5FS7+wmEBFRF5eyocsA8NVXX2Hx4sXYunUrKisrEQqFsGTJkphtysrKEAwG4XQ6kZOTk8rTExERUS9wqHo5DlV/hgzXaGS6RsBtz4cQvHdPREQNUhJ0t23bhtmzZ2PVqlXmc1JKCCGabPvAAw9g7ty5yMvLw/79+2G1pjRrExERUQ9XUbcBvtAh+EKHUFyzHFbFg0zXaGS6RyPdcSQUxdbZTSQiok6W9O3Pr776ChMnTsSqVavMJYSklM1uf+utt0JKibKyMixevDjZ0xMREVEvomr1qPF9F/ucXofyurXYWboAG/f/HTtLX0G591uoWn0ntZKIiDpbUkG3rq4Os2bNQl1dHaxWK37/+9+jsLAQr732WrP7DBkyBBMmTAAABl0iIiJqk8r6zZBofo6uLkOo9m3D9xX/w8b9D2J78fMoqfkSAbWiA1tJRESdLalxw48//jiKi4uhKAoWLlyIc845BwCwZcuWFvc7+eST8c033+Cbb75J5vRERETUy1gUJ9Kdw1Hr3wmg+RFkBglvYA+8gT3YX/URnLYjkOkqQKZrNNz2AZzXS0TUgyUVdN955x0IIXDeeeeZITcRBQUFAICioqJkTk9ERES9TI7naOR4jkZIq0VJzSpU1W9CjX8HpFRb3dcfKoU/VIrimhWwWtKMeb2uAqQ7h0ERrBlCRNSTJPWpvm3bNgDAWWed1ab9ItWWq6urkzk9ERER9VI2Szry0icgx3M0dD2IWv9OVPkKUeMrhKq3PjdX1bwo965BuXcNFGFHhnMEMt2jkeEaBavi6oB3QERE7SmpoBsJqnl5eW3aLxQKAQAsFksypyciIiKCotiR6S5AprsAUuqoC+5Ddf02VPsKEVDLW91fl0FU+bagyrcFgECaYwgy3QXIchXAbs1q9/YTEVHqJRV0c3JyUFJSgvLy1i8i0Xbt2gWg7QGZiIiIqCVCKEhzDEaaYzDys8+AP1SKal8hquu3oS64L4EjSHgDu+EN7Mb+yg/hsvU15vW6R8Nl6x936UQiIup6kgq6I0eORElJCb744gtcf/31Ce/3wQcfQAiB448/PpnTExEREbXIaTsCTtsR6JtxMkKaNxx6C1Hr3wEJrdX9faFi+ELFOFSzHDZLRnhe72ikOYdyXi8RUReWVLnBs846C1JKvPHGG9i/f39C+3z00UdYuXIlAOBHP/pRMqcnIiIiSpjNkoa8tPEY3ufHOHrgrzAs71LkeI6FJcE5uSGtBmXer7Gj9CVs3PcgdpW9joq6jdB0fzu3nIiI2iqpW5E33ngjHnjgAXi9Xpx//vl499130a9fv2a3/+STT3DFFVcAAPr27YurrroqmdMTERERHRaLYkeWewyy3GMgpYa6wF5U+QpR7duGoFrZ6v66DKCqfjOq6jcDUJDuHGpWcbZbM9v/DRARUYuSCrq5ubl45JFHMHv2bKxbtw4FBQW4/PLLY4pMvfDCC9i3bx8WL16Mzz//HFJKKIqCp59+Gg6HI+k3QERERJQMISxIcw5FmnMo8rMi83qNYlb1wURGrOmo9e9ErX8n9lV+AJetPzLdRuh12fpyXi8RUSdIenLJNddcg+rqavzyl79ETU0NnnrqKQAwP9Rnz55tbiulhM1mwxNPPNGmdXeJiIiIOoIQAi57H7jsfdAvcypCag2qfd+h2rcNtf5dCc7rPQhf9UEcql4GuyXT6Ol1FyDNMQRCcMUJIqKOkJIqCnfccQcmT56MP/3pT3j//feh63qTbYQQOPvss/HnP/+ZRaiIiIioW7BZM5CXPgF56ROg6QHU+ItQXV+IGv93Cc3NDWrVKPWuRql3NSzCiQzXSGS6RiPDNRIWhSPbiIjaS8rKBU6YMAFvv/02qqqqsHLlSuzevRvV1dVIS0tDfn4+pk6diiOOOCJVpyMiIiLqUBbFgWz3D5Dt/gGk1OANfG8Mca4vRFCranV/TfpRWb8RlfUbIWAMl850FSDTNRp2a0b7vwEiol4k5XXxs7KyOCyZiIiIejQhLEh3DkO6cxjys86CP1SMal8hqnzb4AsebHV/CQ21/h2o9e/Avsr34LYPMEOv09aH83qJiJLEBeCIiIiIkmDM6+0Hl70f+mVOQ1CtNtbr9RXC698FiaZTuhqrDx5AffAADlZ/Crs1u2G9XsdgzuslIjoMSQXdSKGprKws/OlPf0JaWlpC+61btw7/+te/IITAs88+m0wTiIiIiLoUuzUTR6RPwhHpk6DpftT4ilDt24Ya33ZoMtDq/kG1EqW1X6G09itYFBcynCOR5S5AunM45/USESUoqaA7b948c2jNJ598gnfeeQdDhgxpdb/vv//e3JdBl4iIiHoqi+JEtucoZHuOgi5VeAN7UF1v9PaGtOpW99d0HyrrN6CyfgMELEh3HolMdwEyXaNgs6R3wDsgIuqeUjJ0WUqJTZs2YdKkSVi4cCEmT56cisMSERER9RiKsCLDORwZzuEYKM+GL3QI1fXGer2+0KFW95fQUOPfjhr/duwF4LYPDC9dNBpO6xGc10tEFCUlQffEE0/EV199hdLSUpx22mn4z3/+g6uvvjoVhyYiIiLqcYQQcNv7w23vj/5ZpyCoVhnFrOq3wRvYAyQ0r3cf6oP7cLB6CRzWnPC83gJ4HIMghNL+b4KIqAtLSdD99a9/jdLSUtxyyy0IBAKYPXs2tm7dir/97W+pODwRERFRj2a3ZuGI9BNwRPoJUHUfanzbUe0rRI1vO3QZbHX/gFqBktovUVL7JayKGxmuUcZ6vc7hUBR7B7wDIqKuJWVVl6+99lqMGDECF110EcrLy/Hggw+isLAQL7/8Mtxud6pOQ0RERNSjWRUXcjzHIMdzjDGv17/bWK/XV4iQVtvq/qpej4q6b1FR9y2EsCLdeSSyXAXIcI2CzZJY4VAiou4upcsLTZs2DV999RXOPfdcFBYW4u2338bkyZPxzjvvYODAgak8FREREVGPpwgrMlwjkOEagYHyHPiCB8z1ev2hklb3l1JFje871Pi+AwB47IPCxaxGw2nLa+/mExF1mpSvozt8+HCsWrUKF198MT7++GNs2LABEydOxFtvvYVJkyal+nREREREvYIQAm5HPtyOfPTPmoGAWmkWszLm9cpWj1EX3Iu64F4cqPoYDmueWczKYx/Ieb1E1KO0yydaRkYGPvjgA9xyyy2QUqK4uBjTp0/HggUL2uN0RERESZNSh5StBwWirsJhzUafjB9iZN9rcHT+LzEkdxayXGOgCFtC+wfUMpTUrsT24uewaf9D+L78LVTXF0LXQ+3cciKi9pfyHt0IRVHw2GOPYezYsbjzzjvh9/vxk5/8BFu2bMH48ePb67RERESt0qUKKVXo4T9ShiClDoctF6L9Lo1E7cZqcSPHcyxyPMdClyHU+neh2leI6vpCqLq31f1VvQ7ldetQXrcOirAh3Tk8XMV5FKwWTwe8AyKi1Gr3q/ktt9yCUaNG4ZJLLkFVVRXuv/9+DBs2rL1PS0REBCn1mFAb+ZrIEE+i7koRNmS6RiHTNQoy+xzUBw+Yxaz8odJW99dlKLz9NgACHscgZLkKkOkqgMOW0/5vgIgoBTrktvVpp52GL7/8Eueeey527NiBXbt2dcRpiYioF9GlBilDjYKt1tnNIupUQijwOAbC4xiIAVmnIRAqR5WvENW+bagL7EXrN30k6gLfoy7wPfZXLYbTdoS5Xq/bPoDzeomoy0o66CY6n2n06NFYvXo1LrjgAixfvjzZ0xIRUS/WEGobgq2Uemc3i6jLc9hy0dd2EvpmnARVq0O17ztjvV5/EaRUW93fHyqFP1SK4prPYbWkhUPvaKQ7hyU8N5iIqCMkFXQjPbN9+vRJaPvs7Gx8/PHHeOyxx1BdXZ3MqYmIqJeQUgvPpQ3FzKclouRYLR7kph2P3LTjoesh1Pp3mkOcVb2+1f1VzYty7xqUe9dAEXZkOIcj012ADOdIWC3uDngHRETNSyroDhkypO0ntFpx5513JnNaIiLqoSJzanUZMntsGWqJ2p+i2JDpNpYaklJHXXAfquuNIc4BtbzV/XUZRJVvK6p8WwEIpDmGhJcuKoDDmt3+b4CIqBGWliQiok4RG2ojXzmnlqizCaEgzTEYaY7ByM8+Hf5QmdHTW1+IuuDeBI4g4Q3shjewG/urPoLT1heZrtHIco2Gyz4AQoh2fw9ERAy6RETU7hqqH4eiwi1DLVF34LTlwWk7GX0zTkZI86LG9x2qfNtQ69+Z4LzeYvhDxSiu+Qw2S7pZzCrNORSK4K+iRNQ+Evp0efHFF83HV111VdznD1f08YiIqPtrGmrVhH4ZJqKuz2ZJQ27aOOSmjYOmB1Hr32Gs1+srhKb7Wt0/pNWizPsNyrzfGPN6XSOR6RqNDNdIWBVXB7wDIuothEygbLKiKBBCQAgBVVWbPH/YJ290vN5o/PjxWLt2LcaNG4c1a9Z0dnOIiNqkp4Vahy2XPUztLJXXvYBaBV0PpKhllAwpddQF9prFrAJqRRuPoCDNMQRZ7gJkukbDbs1qj2b2CBbFBbs1o7ObQdTlJXw1by4PJ7q8EBERdW9cp5aImiOEgjTnEKQ5h2BA1hnwq6VmMav64P4EjqDDG9gFb2AX9lV+AJetn1nMymXrx3m9RNRmCQXd559/vk3PExFR96broUaFolQAvLFJRK0TQsBl6wNXZh/0y5yCkFZrDG+uLzTm9aL1G2S+0CH4QodwqGY5bJbMcOgdjXTHUAhh6YB3QUTdXUJB9+qrr27T80RE1H1IKc2qx7oMckkfIkopmyUdeWkTkJc2AZoeQK1/B6rqt6HG/x003d/q/iGtGmXe1SjzroZFOMLzeguQ4RoBi+LsgHdARN0RJyIREfUiUkpIGD20us7eWiLqWBbFgSz3WGS5x0JKDd7A9+He3m0IalWt7q/JACrrN6GyfhMEFKQ5h4WrOI+G3ZrZ/m+AiLqNpILu7NmzAQDHHXccbr/99pQ0iIiIkielDik1SGjhubXRc2oZaomo8wlhQbpzGNKdw5CfdSb8oZJwBedtqA8eaHV/CR21/h2o9e/Avsr34bL3R5bLKGbltPXlvF6iXi6poDtv3jwIIXDsscemqj1ERNQGZg+tHp5PCyPUcugxEXUnQgi47H3hsvdFv8ypCKo1Zuj1+ndBovXPNF/wIHzBgzhYvRR2SxYy3eH1eh2DOa+XqBdKKujm5uaioqIC+fn5qWoPERG1IFIgisOOiagns1szcET6RByRPhGa7keNrwjVvkLU+L6DJltfUiqoVaG0dhVKa1fBojiR4RyFTPdoZDhHwKI4OuAdEFFnSyroDhs2DBUVFSgrK0tVe4iIKExKLVwgqiHcMtQSUW9jUZzI9hyFbM9R4Xm9e1Bdvw1VvkKEtOpW99d0PyrrN6CyfgMEjOHSma4CZLpHw2ZJ74B3QESdIamgO2vWLHzzzTd4//33cdNNN6WqTUREvY6Uekyolax8TETUhDGv90ikO49EvjwbvtAhs5iVL3So1f0lNNT4i1DjL8Leynfhtueb6/U6rUdwXi9RD6Iks/PNN9+MgQMH4r333sPChQtT1aY2+frrr3HffffhtNNOw4ABA2C325Geno4xY8bgxhtvxNq1axM+VigUwmOPPYaTTjoJeXl5cLvdGDVqFO644w7s3LmzHd8FEfU2ulShaj4E1Wr4Q2Xwh0oRVKugal7oeoAhl4ioFUIIuO390T9zOgr634QfDLgTA7PPRrrzSCT6K259cD8OVn+KbQcfx9aD/8L+yo/g9e8OF+4jou5MSCmTGge3bt06nH/++Th06BDuuOMO3HrrrRgyZEiq2teiqVOnYsWKFS1uI4TAz3/+c/zjH/9o8S5dcXExzj77bKxbty7u62lpaZg/fz5mzpyZTJObGD9+PNauXYtx48ZhzZo1KT02EXUdkaHHkbVqGWS7JoctF4rgynvtKZXXvYBaBV1vfb4m9T6q7gvP692GGt926DLYpv0tiguZrlHIdBUg3TkcFsXeTi1tO4vigt2a0dnNIOrykrqaz5gxAwCQlZWFffv2Ye7cuZg7dy7y8/ORn58Pl8vV4v5CCCxZsuSwz3/ggFF6fuDAgbj44osxZcoUDBo0CIFAAMuXL8fcuXNRXl6OuXPnwmaz4W9/+1vc46iqipkzZ5oh97LLLsPs2bORnp6OFStW4M9//jNqampw+eWX4/PPP8f48eMPu81E1PM1DEMOcW4tEVEnsCou5HiORo7naOhShde/26ziHNJqW91f032oqFuPirr1EMKKdMeR4SrOo2GzpHXAOyCiZCXVo6soSpNeUillQvMbIttp2uEPDfm///s/XH311Zg1axYslqZl43ft2oUf/vCHKC4uhtVqxbZt2zB8+PAm2z399NO44YYbAAA///nPMXfu3JjXv/76a0yePBmhUAgnn3xyq73IbcEeXaLuzQi1kXm1ka8c8tZdsUe3/bFHlzqTlBK+0EGzmJU/VNzmY3jsA5HpLkCmqwBOW147tLJl7NElSkxSc3SB8BqOUX/iPRfvTyq88847uOiii+KGXMCoCn3vvfcCMHpt33rrrbjbPfTQQwCAvLw83H///U1enzhxIq6//noAwOeff47Vq1enovlE1M1IqUHTg1C1ukZzayuhal5oup8hl4ioCzPm9Q5A/6wZGNP/ZowdcAfys85CmmMogMQKUdUF9+FA1SfYevAxbDnwL+yvXAxv4HtOSSHqYpK6ba3rXf8f9LRp08zHO3bsaPL6tm3bUFhYCAC45JJL4HQ64x7n6quvxuOPPw4AWLRoESZNmtQOrSWirsBY1kcz16mVUoWExl9iiIh6GIc1G30yTkSfjBOhavWo8W9HdX0havxFCc3rDajlKKn9AiW1X8CquJHhGo0s12ikO4dDUWwd8A6IqDk9fnxWMNjwIRWv53flypXm46lTpzZ7nHHjxsHj8aCuri5mHyLqnqSU4fCqmqHWCLgqOJ+WiKj3sVrcyPEcixzPsdBlCLX+3aj2bUO1rxCq5m11f1WvR0XdOlTUrYMQVmQ4hyPTVYAM1yjYLJ4OeAdEFK3HB93PPvvMfDxmzJgmr2/dutV8XFBQ0OxxrFYrRowYgfXr18fsQ0Rdm5S6EWBhBNmGYKuBgZaIiOJRhA2ZrpHIdI2ElOegPnjALGblD5W2ur+Uanj7QgACHscgY71eVwGcttz2fwNE1LODrs/nwyOPPAIAsNvtOP/885tss2/fPvPxwIEDWzzewIEDsX79epSVlSEQCMDhcMTd7sknn8RTTz2VUBsZmolSx+iRDZnDjfVwLy0RtS9e96gnE0KBxzEQHsdADMg6FYFQhdnT6w18j9ZvmkrUBb5HXeB7HKj6GE5rXriY1Wi47fkQIumSOUQUR48Our/73e+wa9cuAMAtt9yCAQMGNNmmtrahxLzH0/KwkujXvV5vs0H34MGDWLt27eE0mYgSFFvtOBT+yjm0RJ2B1z3qTRy2HPSxnYQ+GSdB1epQ7duOat821Pp3QJehVvf3q2Xw13yO4prPYVXSjPV63QVIdw6DIjivlyhVUhp09+/fj9WrV2Pfvn2oqalJaOmgSFXkVHvjjTfMZYJGjRqFv/zlL3G38/v95mO7veXFwKODrc/na3a7/v37Y9y4cQm1c+vWrS0ei4gildzVqLVpjR5bIuoaeN2j3spq8SA37Tjkph0HXQ+hNrAT1fXGkGVVr2t1f1X3orxuLcrr1kIRNqQ7R4SHOI+C1eLugHdA1HMltY5uxJo1a3DPPfdg2bJlbd43mXV0m/Pll1/i1FNPhc/nQ1ZWFlasWIGjjjoq7rbnnHMO3n//fQBGeG2u6jIAXHrppXjttdcAAGVlZcjNTX6OBdfRJWoqEmZ1PWQOQeZ8WuoIXEe3/XEdXeoNpNRRH9yPKt82VNcXIqCWtfEIAmmOwch0FSDTPRoOa475CtfRJUpM0lfzRYsW4fLLL0coFGp1fVwhRMw2QiS2XllbbN68Geeccw58Ph9cLhfeeeedZkMuAKSnp5uP6+rqWgy6dXUNd+bS0tJS02CiXs4oDBXuqdVDDLVERNTtGfN6B8HjGIT8rNPhD5WH5/VuQ11gbwJHkPAG9sAb2IP9VR/BaetjFrNKdx7Z7u0n6gmSCrrFxcW46qqrEAwG4fF4cPfdd+Okk07CWWedBSEE5syZg+OOOw579uzBRx99hHfffRcAcNVVV+Gaa65JRftj7Nq1C2eccQYqKyths9nwxhtv4OSTT25xn+gCVPv27WuxlzZSuCovL6/Z+blEFF9DgSgu5UNERL2L05YLp20y+mZMRkjzosb3Hap9hajx70hoKo4/VAJ/qATFNStgs2SYyyBlukdxXi9RM5IKuo8//jjq6uoghMA777yD6dOnx7x+1FFH4Uc/+hEA4Oabb8batWtx4YUX4sUXX8SoUaPw//7f/0vm9DEOHTqE008/HQcOHICiKJg/f7557pZELzm0bds2HHvssXG30zQNRUVFTfYholgNBaK4lA8REVFjNksactPGITdtHHQ9iBr/TlT7tqHG9x1Uvb7V/UNaDYprVqC4ZgWOPOLH6Jc5pQNaTdT9JFXPfPHixRBCYMaMGU1Cbjzjxo3D4sWL4XA4cO+99+Lrr79O5vSmiooKnH766dixYwcAY5mDSy+9NKF9J0+ebD5esWJFs9utXbvWHLocvQ9RbyWlDl0PQdV8CKo1CIQq4AuWIBAqR0itgarVQdMD4TvVDLlERESNKYodWe4CDMmdiaPyf4GRfX6KPuknxczJbUmO5+h2biFR95VUj26kh/O0006L+3oo1LTE+siRI3HllVfi6aefxlNPPYWJEycm0wR4vV786Ec/wqZNmwAADz30EK677rqE9y8oKMDo0aNRWFiIV199Ff/4xz/iztOdN2+e+XjWrFlJtZmou5BSh4RmfDUfa6x6TN2CUa07BFX3Q9N90HRf1GN/o++Nx7oMQtN9GJp3EY5In9TZb4GIehEhFKQ5hyDNOQT52WfAHypFta8QVfXbUB/c12T7NMdQ2K1ZHd9Qom4iqaBbXV0NABg8eHDM83a7HaFQKKZ4U7TJkyfj6aefxvLly5M5PQKBAGbOnIlVq1YBMJYquuuuu9p8nLvvvhs33HADysrK8Jvf/MZclijim2++wdNPPw0AOPnkkzFpEn/5oZ6hYb6sCgk9PNw4Emgl2BNLXYGuh+KG0tjAGnkcG2AlDq+yf0irbX0jIqJ25LQdAaftCPTNOBkhrRbVvu9QXb8Ntf5dkFCR4zmms5tI1KUlFXRdLhe8Xi8UJXYEdGZmJsrKyvD999/H3S+y/cGDB5M5PS6//HIsWbIEAHDuuefi4osvNnt24/F4PBg2bFiT53/605/iueeew1dffYV//vOfOHToEGbPno309HSsWLECc+bMQSgUgtPpxMMPP5xUm4k6mpR6VCGo6EDLebPUcXSpxgZSLfxY+mO/jxNmDzesJkPVWp8nR0TUUWyWdOSljUde2ngACuqD++BxDG51P6LeLKmgO3jwYGzZsgWlpaUxz48cORJlZWX44osv4u63YcOGZE5rWrRokfn43XffNas6N2fatGlx1/q1Wq343//+h7PPPhvr1q3DggULsGDBgpht0tLSMH/+fIwfPz4lbSdKJaMXNjy8WGpGMShEemv1zm4e9RBGWG3cg9o4oPrjft/dhronUhCGiKgzWBQHctOO7+xmEHV5SQXd4447Dlu2bGnSizp58mR88cUX+OSTT/Dtt9/iuOOOM1/bvXs3nnzySQghMHr06GROn1J9+/bFV199hSeffBILFixAYWEhfD4fBg4ciLPOOgt33nknjjyS65ZR5zFDLFSzR1YPL9PDnllKlJRawiG18Wu6bFp3oecQsChOWBUPrBYP570RERF1c0kF3enTp+Pll1/Gp59+GvP81VdfjYceegiapmH69Om48cYbMXz4cOzYsQPPPPMMamtrIYTAJZdcklTjjTmEqWO323HbbbfhtttuS+lxidrCGGocMocbS6mZBaGIgEhYbRxO4xVYahpYe3ZYBSyKExbFFQ6trkaPm39NEXYIocBhy4Uikro0EhERUReQ1NX8/PPPx4033ogdO3bgq6++woknnggAGDt2LO6++248+OCDqK2txT/+8Y8m+x599NG4/fbbkzk9UbckpYQM98rqUgOgh2/a6GZxKOr5pNTi9KA2VxE4NszqMtjZzW9XFuEIh9BmQqql8Wvh14UDQiS1ah4RERH1EEkF3by8PGzfvh3BYBB9+vSJee2BBx5ARkYG/va3vzWpvnzBBRfgqaeeiruMD1F3FB1UESn2FDVnVkKiIdBymHFPIaXeaiht7rWeHlYV4YDVDKeuqMfORt9HPba4GFaJiIgoJZIenxWvinHEb3/7W9x999348ssvUVxcDLfbjQkTJmDAgAHJnpbiMIa2CgghOrsp3VK8dWIjwbX5fSKhleG1u2oIq20PrLoMdHbz25Ui7LE9ps0F1CavOZMOq5quQ0LCqlhS9G6IiIioN2n3iUhOpxOnnHJKe5+GAAS1auh6MPwLpgIBAQgBQBj/EwoEFECEX0PDaxDhr1B6RFA2hgfraOhFhfEYEsb/9ai5r5H5rwyr3ZWUOjQZaLHqb8z3WlSAlf7Obn67UoS9lZDaXGB1QojUh0wpJTSpQ9clNF2HruvQpYSuS6i6Bl2X0KUEpITTbkemx53yNhAlQggrLIoDirCb1ex1GQwXACQioq6OFTd6ICO06UZsO6zsJiCEpSEoRxX9kojuwZTh8xlfGwJyVIAGooJ15DUZPpKMNDjO8fWYY8e0ToQDeTi8y0h7pIwaIszCTd2NlBK6DDQTUpt7HNkugJ58o0IRtrYNAY56rT3CanOMkKpD02U4wOpQdd18Xg8/T9RVKYoDNosHAtY4N31dABpGT0lo0PUANBmErocASOOaxCkqRERdAoMuxSGNar/Gw8T3ahRKZZMHqRGZD3v4QZ7aSySstrZMTXPf9+T/oEZYbUtF4Ibvu0IVYE03RkeomtELq8lwmNV1s4c21ZXwiTqKEFbYLGmwKI4EtjWG5QtYoVissMLT5IZvwyiTAHS9Z09xICLqqjr/tyci6lKMsBpsNCc13hqrsRWCI6/35LAqhLXFUNrSa10hrLYkMpRY1TRoUoem6dCiQiwYYqmbEcJq/ruLLg4Y/RklhAKbJR0WJbnimI17f4VQYBXGZ4IuNWi6D4qwQhE2SOjQpQpVq+MwaCKidpTQb14WS/sMfRNCQFW5lApRqhlhNWSG1MQKLEVe96OlAlzdnYClyZDfZntVLbGvKcLW2c1PmhFmdWiaBlVv+MohxdQdKcIKi8UBi+Iwhw3rMgQhRNx/r8Y65Soin3GKcLR7XQpFWKBY0szvBSzGCA/hhKrXQ9Xq0JNvEBIRdZaEgi6HoxF1PCklpAzFBNGm66w238Mqe3xYbVrpt2mF4KZzWRWl+4fV1khp9M6GNA16ONiqugZN0/l5Tj2KVfHEBFUhBCzC3uz2Qigtvt6RhBCwWTywKk6ENG94+gYREaVKQkF36tSpPaISL1Fn0PVQk57TpoE1/msSPXdYm4DS7NI0rS1pI4St134mRebKatFFniTM+bLsnaXepKzCB4sikJHhgNXSPddfFsICuzUTuu5GSK/jnF4iohRJKOguW7asnZtB1LUZw4Cj5qhqrRVYagisPTmsAkqLa6k2H1idUIS914bVlkSW39E0CS16vqw0emY5V5aogZQStXUheOuCSE+zIz29+wZeRbHBoWRBSg2aHoAmA2Y1ZyIiaruuXR2FKIV0qTZTVKn5wBp5LGVPnksuEupFjTckmGH18ER6ZFVNh6aH58hqOlQWfiI6LBJAjTeIWm8QHo8dGekO2KzdM/AKYYHV4oYVbqN6s+6DLkPh+cWhzm4eEVG3waBL3YqUWptDauRxbwir8ZetaXkJm44oxtLTabpurOEczqgSMlwUR0LqEjpkQxVjDi3ulaSU4aHmxjBzKQGng5fgVJMAvHVBeOuCcDutyMhwwGHvvn/PQiiwWjzm95FqzZzPS0TUuu776U/dlhFWE6kC3DSw9vS72S2vs9p8YDV6Vrtn70V3EVl6RzWrFTO0dnfmzQjAuEmhS0CqRlqKvCbD3+rGY10adzMij41vG77q4R3M13QZd+CpEAKD8zM69P32NvV+FfV+FTarAo/bDrfb1m17eSMUYTXm88q0cOD1dXaTiIi6rJQG3ZqaGixevBirVq3CwYMHUVtbi/T0dAwYMACTJk3CmWeeifT09FSekjqJMYfIn3BgjX5Nl8HObn67sghnbBC1tNarGn5OOBhWO1mkwJOqa2ZhJ1VjteKOZIRFI1yGNB2hkAYJQNdhBEw0Ez4RCZhoEj4lGoVP2fxqAlbhgOjiax5T24RUHVU1flTV+GGzKXC7bHA7bbDb22fpxI6gCAvs1gzougtBraaHj1giIjo8KbmaB4NB/P73v8d//vMfeL3eZrdLS0vDzTffjPvuuw8OhyMVp6YolVV+aHoQdpsCm80Cm1WBojQ/JNWY+9NyKG3utZ4fVh3NzldtHFjN1ywuhtVOpusSOvSY2i0NQ4nDlYmlDj0yjFTXoaPhMcUXCY2RvyGpG8GyIXzCDJ8NvZ3Rr8mY45g9n+H9GoZ8x3JYQwi4eIOBUicU0lEdCqC6JgCbTUG6xw63ywZLNy5g5VRyoelB6DIATQ9Ayp5cAJGIKHFJB93KykrMmDEDGzZsaLXHo7a2Fg8++CAWL16MJUuWIDs7O9nT93qRQhWqXo/64D74g9XQZQASfujwQ4gAIIKA8ENHAFL6zcCqy569hIEiHC1WBG5unVWL4mRY7YIi1Yh13ZjvqsvIUjoSmq5B12Wv6nVtLnxGD5dtHD7NXlAkGD4jj4l6oFBIR0WVH5VVfqOAVZodNlv37OW1KHZYYIfNkg5dD0HV66HpAbBiMxH1ZkkH3QsvvBDr168HALjdblx++eU444wzMGrUKKSlpcHr9WL79u1YvHgxFixYgLq6Oqxfvx4XXXQRlixZkvQb6O3qg/uxfu/9nd2MdqMIezMBtaWKwM5wWO2ev7D0VjFBNjz3VQs/VsNBtjukruiht0bAbCZ8QkLq8cMnIsdg+CRqd9EFrBx2C9wuG1yu7jufV1FssCuZUcUbfZCSI1aIqPdJKuj+73//w7JlyyCEwPjx4/HGG29g8ODBTbY79thjcdFFF+H3v/89LrroInz99ddYtmwZ3nrrLZx//vnJNKHXsyjuzm5CqxRhayWUNv8aw2rPEXdJHV0aQ4m7wNBhI2hH5n3KcA9xpN2Rnk9phlDd/L4hvDKAEnVvgaCGQFBDZXX3n88rhAU2SxpslrSGteA1H9jLS0S9RVJBd8GCBQCAvn37YvHixcjKympx+0GDBuHDDz/E2LFjUVJSgpdffplBN0lWS8cEXQFbw9xUS+M5qtEFlhoHVicUFnbpsSK9sJomzSAYKf6jh3sjI0OLtQ7okY2EVZhzcKOH5cIc3myE1/BjPf78UCLq3RrP501z2+Fxd8/5vIqwQbHYYFXcCJnLE/FTj4h6tqQSyKpVqyCEwOzZs1sNuRHZ2dm47rrr8Je//AWrVq1K5vQEo8IvpAKIRHrDrFDghBAO4yscUIQTAs7w1/DzwgkFDojIa4itQmpVFFitCqxWAavVAouiwGoTsCrd7+JP8Wm6boZBPZwEY4Nr6pfWiTfnVEbWoQ0XlNJ1hL9v6HVtWMaFv7YRUfsIhXRUVvtRVe2H02mFx22D22XrdmuQi0i1ZumBqnk5j5eIerSkgm5JSQkA4Oijj27TfkcddRQAoLS0NJnTE4y1GL/5uh9qvSrq660IBa1QhBMWixMOqxMupwdpHg+yMtKRl52GI3KdSPPYkzqnqhnDTxEAgIZ1bQUAq02BVVFgsYbDsMUIxJYeG4JF+BedyB9AhL8i6hcggYZtjEJXAgJKzC9JkSVQwoNgW/nVQ5pfpZRRxwyfJ3xYqQO61M0lVYz5nno4HBoFnTRdhy6NHldNU82QG2lH9LliTg0BwPjvGhmCLKWErunm/NLoIb/RwTRyHA75JaLuRALw+VX4/CqE8MPjtsHjtsHp6F4jl4zliYx5vCGux0tEPVRSn8x2ux2BQAA+X9s+ICPb2+3JBS4yQueLL+QbhXqa0AHUhv8cMp91OhRkZ9uRk2VHTo4DOVl25OU4kJvtQG6OEzk5DnjcNigiHJsSvGMtYdz1DiESghsoioDVosBmU2CzKrBYLLDZulIAFhDCAiEUCIRDY+SxEA3hNRxOjW2UDrubHylK1DDsVo/5o2p6eOkcIz1GhuUa+zY6VuNjG7cowt80fCREhv5qUkJqUfNSNT3c0xsZHhynvTHhOPKn8d9V4230RtvH+5kOPx8zgqFRECci6gBSSrOIlaIIOOwW2O0W2G0Wc4m/rq6hh9eNkOaFrvfs1RiIqHdJKugOGjQIW7ZswdKlS3HNNdckvN+nn35q7k/JKa/wNRNym+cP6Dh4yI+Dh/zNbhMJw1mZNmRn2ZGTbUN2lsP4mm2EY4/bBiHCvZVCQAhEIqJxEBHp4TTCcgAA/A2REUJAEQK2cC+wzao07BM+rhDhp8zQHd416hyRbQSiTisagqqiWKAI4yugRPWkKka4NXtZE2csbyMhw5WBzeJFgLmUS9TbbCI6rJpDdiXMwkyaZiydo6oqVFWDGhmiq0tzCK/ZAdwFNfxXbqcbAS288aZ94Y3Dc7w/zW0HQLQUvImIjBuDkZ7eCCGM8OtwWOCwW+Fydt1eX0VY4bBmQdODUDUvdBlqfScioi4uqU/dU089FZs3b8aCBQtwww03YPLkya3u88UXX2DBggUQQuDUU09N5vQEoLi0rl2Om2gYzsqyIzvLCMNZ4a/ZWTZkZRk9xk5n23s9I6FVmEHZGB4cHaoVoUDAEg6qlnB4tZq9sUBDaIZUzfAjlIYIJsNrjkIaPc5GYBZmT2ZkyG+kTQCMOaKNA485/NYIoSJOuIsMSzZCatTwXUq5pn//SYZtc6R1455nHbHht3Fgjn4c6YlmaCbqLaSU8AdU+AMqgAAURcATXrrI6bB0yfm9FsUOi5ITXovXB10GuDQREXVbSQXdm266Cf/+97+haRrOPvts/OMf/8Ds2bNhtTY9rKZpmDdvHu6++25omgar1YqbbropmdMTgL5HeHDXjZNQXFaH7buKUVruQ1V1EFXVoXaf9+gP6DhU7Meh4ubDsMOhNITfTDuys1sPw1IqkNLofYUZXBu+jxckDWozzxMlr2GedRLDEWX0w8PtZWZoJuqOdF2iti6I2vBQZ6fD6OV1Oq2wdrFKzsZavLbwtJkgNN3PwlVE1O0kFXQLCgrwm9/8BnPmzEFdXR1uvvlm/O53v8P06dMxatQoeDwe1NXVYfv27Vi2bBnKysrChXMEfvOb36CgoCBV76PX6nuEBz+5yCgGtnnHd/D6jR5eTZOoqQ2hsiqEyqogKiuDqKoKobI6iMrKUIeF4UBCYdiC7EwHsrMcyM5yIivLaXyf7UR2phNZWQ64XdYuefeb6HA1BOfD1ObQrCOmN1pEeqWJqKPpukS9L4R6nzFE2GZVjNDrMIJvV7neCSFgEQ5YFAek1KHJAFStHlLyxjIRdX1JTxi57777EAwG8fe//x1SSpSVleHNN9+Mu62UEoqi4Fe/+hX++Mc/JntqaoHFIsI9p3YAnrjbaJpEbW0IFVUhVFUFjUAcDsZV4a/VNaG4xYZSKRDQcKikHodK6pvdxmG3ICschCOBODvTgawsJ3KyGIapdzus0NwkKEfEKwrWOCzr4YJg7FEmSoWQqiPkDaLGG4QAYAsXtbLbLXA6rF2isJUQCqzCBaviMuby6vUsXkVEXVpKKiP89a9/xXnnnYcHH3wQH3zwAQKBph98DocD55xzDn75y1/ihBNOSMVpKUkWi0BWlh1ZLYRhXZeoqQn3DJu9wSFUVoZ7iquCqK4Jtn8YDmooLqlHcVvCcKbxNSsqHDMMEzUVOx3AkthOMXOX481bjjf8OhKS2ZtM1BwJIBjUEAxqQLgMh82mwOW0weW0wmHv/Pm9xlxeO3Q9hKBWDSm1Tm0PEVE8KSsB+MMf/hALFy5EMBjE+vXrcfDgQdTW1iI9PR39+/fHsccey+WEuh0FirAiK9ONrEwFw2ABYGkyR1bXJWpqg6is8qOi0o+q6gAqq/yorDK+VlUHUFUdaHN16LZKJAzb7Uo4ADvDoTjSO+xEdrYRjt1uhmGiRAlzDn0bNAnJjYZVm4+NKumSoZga0XUJRek9n9OhkI5QKICa2gCEEHA5LHC5jOBr6cT5vYpig0PkIKR5oel+cIQHEXUlSQVdv9+PqqoqZGRkwO12AzDWxp04cWJKGkdtY7UrcOjGBS8y9zay9qrxZKQ6MKJ+0QQABTCLP1nCf6wtFH2KpSgCWZkOZGU6MGxIZtxtosNwVXWgUSA2QnFHhOFgUEdxaT2KSw8zDEd6hhmGiZLWEJLjB2UFNlgVY7SJUflVD4fexo9luEdJMhT3En/71xdYs+EQRg3PwYih2SgYmYv8fum94nNZSol6v4r68FJGNpsCh90aXsNXgd3WsT2+QijmWryqVhcOvEREna/NQbeqqgoPPPAA3njjDezcudN8fujQobj44ovxy1/+Erm5uSltJCUmw2OHw97S8CGlYTkeYYWAFYBxQTTWgQ3/yqgbSVjXw0vmyIZSN5BGWtY0Y4kcXZfGOrKRr83k1Ogw3Bxdl6itDaKiUfjtymG48VDprCyHOWfYWGe45//SRdQRjLWuleZvv0W9EAnF4UXEoh7Hzj82v5fR21J38O3mYuz6vgq7vq/CR+Hn0jx2jB6Rg4IRuSgYkYsRw3LgdHTdtWtTxejtDZrDnBvP8XXYLLDZ2r7UX1spwgq7NRO6dCOk1nItXiLqdG26Amzfvh1nnHEGvv/+ewBo6CkEsHv3bjz44IP473//i8WLF7OicqcR4V8II4HWEvW4+eFNQghYLOF+FcvhXwzNwBwOyJomoWk6QpqEGtKMYKzF/3VSUQQyMx3IbEPPcMwQ6aoAKquN77tCGLbZFLNoVkPvcFQxLYZhonYRCcVAgiW6+E+wW6mtC2LH7somz3vrgliz/hDWrD8EwLimDBuchYIRuRg9IhdjRuQiL9fd0c3tcPHm+MaEX5sCm8143B7DvxVhg92ajZBWw95dIupUCQddVVVx0UUXYc+ePWYPYLTI9/v27cPFF1+MtWvXwmazpba11CKrkgndEr+oVEdpCMzhi2czPwKqJqHrOkKqDk2TUFUdqqZD0/QWC1sl3DPsDcaEYKM32I/KSiMMV1UHoGntG4ZDIR0lpfUoaSUMZ2U29AIbATh6eSUHPB6GYSKiiM3bShNaGk/XJXbsrsSO3ZV475MiAEButgujwz2+o0fkYtjgrC5R0bi9xYTfKOawZ5sCq0WB1Wr8SfaaI4SA3ZoJTXcgpNVxOSIi6hQJB90333wTGzduhBACubm5uP/++3HOOefgiCOOQGlpKd5991387ne/Q2lpKbZs2YLXX38dP/7xj9uz7QTAFwjipkefNC9KAoBQFCjC6NVQhICiCOOrEBCRr4piPhfZxtg+vF/UPsbrSsO+jY6pCAVCabQtACV8jtjtFQgBKOFziKjzK+H2AoAuw0OopTAGGeowvwohIND4/TT63iKQk2dD3hF2CJER+1r4HF5vKFwoK9ipYbi0zIfSMl+z2zAMExE1UBSBCcf1x6ZtpfD72xagyit9+OLrffji630AALtNwYhhOUaP78hcjB6ei4z05m+k9jTmsOdGLBYBq0WBw26Bw2FUej6colcWxQmL4oSq+6Bq3vC0AiKijpFw0F24cCEAwOVyYfny5RgzZoz5Wv/+/XH99ddjypQpmDBhAnw+HxYtWsSg2wE0XUdZTW1nN6PbM4OwS0C4BTIGKsgUACCMKXzhP7puBHBNA3QtPAw7POXPmMMsoh5H7R/5XhphtKEgmGjomQi/3rAtIMP7+wEcCAD7DwngUPi18LEgjV/8XE4b3C4b3C4r3C47PG4rPG470jw2pHnscDmtsTcfzK/GjYkmz0V9H7k5EbuNaLRNy68REaXCpOMHYNLxA6BqOpZ/tRvbvitH4Y5KFBaVo7S8+RE08QRDOrZ8V4Yt35VhUfi5Af3SMHp4Q6/voAEZvarCM4DwtCMNgaAGeI0gbLUoxpxfuwU2m/E10b8Xq+KCRTih6fVQ9XoGXiLqEAkH3bVr10IIgSuuuCIm5EYrKCjAFVdcgaeffhrr1q1LWSOpeTovFimhh5NsQisBCgBWQFhTuD5XigTCfyqDAIIAqjq1OTFaCsKth+VwQI8+jhInkKMhkBvhPPYYQrQc6JXwfub54rWx8WiCRiMdBFp+jy2/13htj3+DId5zRL2J1aJgYL4HGVkWzJg6GC67AxVVfmwrKkdhUTkKd5Rj5+5KqG0cmXPgkBcHDnmxdOUeAIDbZYspcjVyWA5crt43NUvVdKg+HfW+hiJTVosCi0XAYlFiQq8xusz4bLLZjIBstSiwWjywKG5oug+qXsfAS0TtKuHf04uLiwEAJ510UovbnXTSSXj66adRUlKSXMsoIY3nShN1VVJKaPx5bVeJ9rArovVA3vL+Ld1MaPtIAOMGRdQNjfDrdqsVHqcTQgAnjCqARen5cymp7aQEan1++IJBZKS7MXniQEyeOBCAsb76jt1Gb+/W7WUoLCpHjbfpUN2W1PtCWLexGOs2Gr8HKQIYMijLnOtbMCIXffLcvfJmk6rpUDUACdwmVhQBmzVqHjDSIYUfQD0gjL9XocR+rhARJSPhoOv1eiGEQHZ2dovbZWVlAQDq6uqSahglRgiB4f37QpcSIVWFpuvQdWlWPdZlwzJAUuoNjyHN7XQpIXWdC2sQdXM9+WbCxJGjm1ltl8igajoqvF64HXZ4nC4oQsBht2DsqDyMHZWHWRgNKSUOFnvNXt9tReXYe6AmoeJWEbqEubTRh5/uAABkZzpjilwNH5IFm40/sdF0XSIQDA+HNglI6YKOOugytkKzoohwj7HRa2yzKlAUBRbFCMQWhWGYiFrW1UZeUhtluN149JZrAQBl1TUIhA5/3ToZHYrNIKyHlwyKDs26uW30PsbrOqQuocNYWzd6n4ZQ3TiINwrn4fPqMvY5Ge9YMcfUGwX7Rts02rfhnHrT8K9LaLrecOMg/H3j48U9h/k19u9Jgj3wRIdL4S+0lKD6QBCBUAhpLhecNnvMa0IIDOiXjgH90jHj5KEAgLr6IL7bUYGtReX4rqgchTsr2lzkqrLaj6/W7MdXa/YDAKxWBSOGZsf0+mZlOlPy/noaIRRYkA4FTmiyFpFJRLouEdQ1INR8b7HVosBmVWCxhr9ajKKaZukL2fDVmJYSO6y6t829JuptGHTJJISARQgcRmHFXkPTJFRNR0jToYWMJZGMpZESC7AyTkCWQJNQ3LZA3bCNpuuo96morQ2gpi6AuroQvPVBeL3G1/r6EOp8IWOdYSERqbcFwPjefAwIIaMeA4A0txXC2D7utuFjNbtt1LmsNgVWqwjP8Wr4oyiRIWzSqMAtIzcZ0OjvLv7fA/U8DLrUFpouUV1XD78tiHSXu8Vh7x63Hccf3Q/HH93P3Pf7fdVmj++2onIUl7ZtlJqq6ua+b4Wf63uExwi9I43gOyg/ExYGLZMQNliQHe7dbX4lgmjG0GndKE6RzLkbGmF+MUKxCA+1NnqXIYSZnjW94XpjUaLmKluM36XY20zU+docdPkPl3oz40JmgQMWwNXwvJQSIVVCVTWomoSm6QiGNGiqjBkSHl2BuLMGtUkp4a0LobLKj6qqACoiSytV+VFZ3bDusKp2fpEQi8VYN9lYUsnRaFklJ7KzHUjz2JvclW+ph11KNNvrnsiNhURvOrS4DeK9pkft33wbO6qd8W4idNbNhEgRMqK2CoRUBNUapDmdcNkdCf0cWRSBYYOzMGxwFs6aMRyA0WMbCb6FReUo2l3Z5s/I4tI6FJfWYfmX3wMAXE4rRh2ZY/b6jhqeC4+79xW5iiaEgAVpELBDl7WQ6JjrkPmJFv5sa/iIk4cdpC0WYQRgRZgh2LiRawy/VhSFPcpE7azNQXfmzJkJbSelhMXS8q/yQgioKhcRp+5PCAG7TcBua9prEFKNXt+QqiMU0hBSNWgJlXduH0IIpKfZkZ5mx+CB8beRUqKuLmQE38roAGyE4MoqY53hUKh9fwnRNInyCj/KK/zNbtNcGM7KcpprD6enNQ3DdPjMkQlofFOh6c2EZG46WC0WuOx2SFYQoCTIqGJVaU4XHLa2h8nsTCdOHJ+PE8fnAwBCIQ079lTFFLmqqmlbGvL5VazfUoL1W4zinUIAg/MzY4Y79+vj6ZU3eRRhh0AmNFndYWE31SJLNLVGiPB8YwVmkcDG/8kjo5kiFKHDbrWY+yqWhjnLFsUchmXuHPmsluZyhzJmWHdk5YnI641vZloUI6ArFgFFIBzWY89L1BUd1tDllu7mR/dYcQghEWALzx2K6gBuGAKtagipEqGQBjXUdQqCCSGQlmZHWpodg/LT424TCcMV4Z7h6DAc/X1XCcOZGQ4z+MaE4iwHsjOdSE9nGE5UR62N7LTZkOnxtPt5qHdQNR1VdXWwW61Iczphsx7+7C2bzWKG0fPPGgUpJUrK6s3hyoVF5diztwp6Gz7UpQT27KvGnn3VWLxsJwAgI91hnmf0iFwMH5oNh713FLkSwgoLMqHJqh59s0tKaUx/asMNcEVo0LpQR1HjwK0oIiYcWxRhzo2ODAk39kPscHHADPoMz5QKbfqUTyS4MtwStc4cAt3oF5aGXl9p9v7qXfRmdnQYbrFnuD5k9gKbvcFRvcIVHRSGKyr9qKhsPgwrSqRnOBKAG8JwVqYRkhmGibq/oKqiwuuF025DutMFJQXLVgkh0PcID/oe4cG0Hw4GAPh8IWzfVYGt2xvW9a33tS2c1NQGsHrdAaxedwAAYLUIHDkktshVTrarlaN0X0bYzerWPbu9weGE9dYIwAjJFgVWJTL0u2EutDXO+s1EjSUcdPWu+ts2UQ8S6f2NFtIk1JBmDIEOaQh28tDnthBCIM1jR5qn5Z7h+no1JghXVvtRWRlAZXXDPOL2DsO6Hh2Gq+NuEy8MN/4+g2GYqFvwB0MIhlSkuVxw2e2t79BGLpcNx4zti2PG9gVgFC/ad6AmpsjVwWJvm46pahLf7azAdzsr8M7i7QCAI3LdZugtGJmLIQMzYelBVSXNsItaSHn4K0tQ9yLRMPy7pZWvhRAxodcangctokZwh0dmm0O0dRk1lLvRNBqEH2ekOZCR7uiIt0rtiFWXibo4m0XAZrHGDH1WNYlgUEUoZBS9Cqk6uutgCiEEPB4bPB4bBrYWhiMBOBKGqwJm73BXDcNN5g8zDBN1GbqUqKmvhy8YQIbLDWsrtUWSYVEEhgzMxJCBmThj+pEAgOqaAAp3RBW52lWBYBs/x0rL61FaXo8Vq/YCAJwOC0YemWMOdx49PBdpntQH+Y4khAVWZEEiBB0+6DLJMsvUY0SKgYZSXEBT766/VFEMBl2ibshqEbC6bDGVn2N6flVj/m/jqs/dVUwYHtBCGPaFe4Yb9QZ3xTCcmWGPP0Q62/iameFgGCbqICFVQ4W3Fi67Ax6ns8OWs8rMcGDS8QMw6fgB4Xbo2LWnElvDwbewqBwVVc1PuYjHH9CwcWspNm4tNZ8bNCAjZrjzgH5p3XIOpLEEkQ0CAejSy+HMRNQiBl2iHiJez2/0skfdYd5vMoQQ8Lht8LhbCcORnuHIkkpVAfP7SDGtYLD9w7BxvgAYhom6BimB+kAAgVAI6a7Dq86cLJtVwajhxlJDONP4zCotr0fhjgps216GbUXl2L232lgLvQ32HqjB3gM1+OSzXQCA9DQ7Rg9vKHI1clg2HI7u8yuhIhwQsEFHfcJr7hJR79N9PtWo24lUZhVCxKyDqYQnTkSeU0RDOX0BEbVye/g4aHgtun/SmEohm2wbWaM0MvciMvzEHIYiG/aKFE/TdL1HzkNvbtkjVTNCbzCk9+jw21hbeoYbeoNj1xeOhONAsH0nSh9uGG4YKm18n5Fu71Hz9Yjam6Yb1ZkdNhvSXS5YUlCs6nAJIdAnz4M+eR5MOWEQAGNZoqJdFTFDnr11bZu7WusN4pv1B/HN+oMAjAKJwwZlYfSIXIwZaYTfvBx3yt9PKgmhwII0KHBAgxdSdp0qxETUNTDo9nBGyfemF+nG94LjVcuOBFDzqyKgCAVWiwKLYoFFUcKhtaFUvHHO7lsWXgunvcj7abz2p64b38eu+Wns21DkIGqfLpoerRYBq8UKl7PhuZAmEQqqZs9vMKR123m/yYjuGc4fkBZ3m+gwHN0bXBVdUKuLheGszEZLKpnB2InMDIZhosYCoRCCaghpTifcDmfrO3QQl9OKo8f0wdFj+gAwPgf2H6qNKXK1/2Btm46paRJFuytRtLsS731SBADIy3GhYITRu1wwIhfDBmfBau16nxNC2GBFdnjubj2HMxORiUG3B8lOT4sJrBZF6baBs7M0vSkgkExpEiklNF2HpuuNQnNDZT9Amr3T0aFZRv3ROyA02ywCNlfsUL2QGi52FS561ZXW+u1MiYZhv19DRXg4dENvsB8VndQzvGtP/G2EALIyHU3CcFamEznZDMPUe0kJ1Pr88AWDyHC5k1p7t70oisCgARkYNCADp00dBgCo8Qbw3Y4Ks8d3+86KNn/WlFX48Pnqffh89T4AgN1uwYhh2SgYblR3Hj08t0tVpVWECwIOaKhhdWYiAsCg26N05vAqis8oe29JSSVPo4dYQtU1BFUVwZCKoKq2awA2lztyNbShSfhVGX3jEULA5bIi35WG/P7Nh2GfX0VlZQBV1dEBOLLGsNE7HAi0bxiWEgmF4cwMR5y5wgzD1POpmo4Krxduhx0ep6vDilUdrow0ByYc2x8Tju0PAFBVHXv2VWPr9jKz57esom1zW4NBDVsKy7ClsMx8bkC/NHOeb8GIXAzsn9GpdQOEUGCRGdBFLXTZ0qI0RNQbMOgSdRNCCHOhdIetoeKyrktougZV043h1eawaRnTM6w36VFue0A15vxaYLc1BHddN8JvKKrgFXt+EyOEgNtlg9vVfM8wgHAYjp4rHF1J2gjH/g4Iw1XVAVRVB7BrT03cbYQAMjIcyMlq3Dvc8JhhmFIpPc0OWCQ01Rj1ouvhG4Ka3i51B+oDQQRCIaQ5XXC2w9q77cVqVTB8aDaGD83GuaePBACUldeb83y3FZVj1/dV0LS2fXIfOOTFgUNefPq5cYfM47Zh1PAcjBmRZxS5OjIHLmfH/qophAJFZkAIH3Tp41Bmol6MQZeom1MUAUWxwtbGf82Nw3BMSA6/FnkcGX6t6XqTgKwoAg67BQ67JebYIVUiqBqhl8Oek+NyWuHqn4YBzfQMA4DPpxrFs6qN4FvRqHhWZQeF4erqAKqrAwASD8NZWc7Y7zMdDMOUELvdirRmgkx03QFV1aCqekwBwzgfZwnRdInq+nr4Q0GkO12wtOPau+0pL9eNvFw3Jk8yilwFAiqKdleaw523FZWj1tu2XtG6+hDWbSzGuo3FAABFAEPDRa4KRhhDno/Idbf7tCqjCKYbAi5I+Dl3l6iXYtAl6qXMHuI27qdpRuBVdc2sVq3pEqrW8H1MtefotX7VSJVnCU0Nr/nbxh4Eiq+1YdJAuGc4qjc4ZmmlSj8qq/3w+7tIGE63IzfbhT55acjLcSE324W8HDdyw49zslxdsjAOdR3x6g7Eo2kSmi6hazrU8GgXqcN8LqTp0DTZJBQHQiqCai08DifcDke3r4nhcFjxg9FH4AejjwBg3LA8WOw1g+/WonLs3R//32xzdAns/L4KO7+vwgef7gAAZGc5Y4Y7Hzk4CzZb+9wsMAIv5+4S9VYJBd2aGuODzePxdNs7l0SUGhaLAotFgb2Fj49IGNZ0Yzh1Q49wQyCO/Nao6xLBkA5VbVjuiOG3fbicVrj6pWFAvwTDcLUflZUBc85wJBz7/O27jIeUQHVNENU1QezcE7+atFFAy9kQgLNdRiCOeswwTIkwpoQIwNbyz4oxJDo8EiYyTFoCUtfgU33wOFywKpZwz3H3J4TAgH7pGNAvHTNOHgoAqKsPGmv6hsPvdzvK2zxSpLLKjy+/2Y8vv9kPwKgFMXxYttHjO8IocpWVmdoq15G5u5pg2CXqTRIKullZWVAUBQsXLsR5551nPv/iiy8CAGbMmIGBAwe2TwuJqNuJhOHmRKpRq5oxt1jVNKjh3mBVM4YYhkIaAuHg21uXOuoMiYRhv1+NM184/H04HHdEGI6cv2hXZdxthACyMpxmL3CkRziPYZgOg6II2M1CS/Fu+mtwOqzIcKdB12AU7VN148afJhEMadD17v1B5nHbMe7ofhh3dD8Axk3N7/fXGPN8t5ejcEc5ikvr2nTMkKpj23Zj/4h+fTwxvb6D8jNhSbLIlRl2UQWJ9h25QkRdQ8JDl+Ots3rNNddACIFFixYx6BJRwhKpRq2Fe0wiw6H9wRC89UHU+wLwB1WEOOe30zidVvR3WtG/r6fZbfx+NVw5OrpwVkPPcFVVAPW+DgjD1Ub4bjUMZ7saQnCOC3nZRu9wXo4L2Vkuo/o4USt8gQACoRAy3C6keZr2SqqajlBQgz+gwhcwPse6M4tFwbDBWRg2OAtnzxgOAKio8qGwqAKFRWXYVlSOHXuqoKpte5+HSupwqKQOy774HoBxA27U8Byz13fU8Fy4ExiW3pgQCizIhCarOGeXqBdIKOhG5p1oGu+AEVHHsCgKLApgC/ecuJ0O5GQYr2majpCmot4XQn0gCL8/BF9QRTCgQmPXb5fgdFrRz2lFvzaG4ci84cj3HRqGd7chDJtDpY3vGYYpQtd1VHnrUB8IIsvjgc3acEPPalFgdSlwuWzIhjEcOhDUEAiqCAY1BILdv9c3J8uFH07Ixw8n5AMwerZ3hotcRf5U1wTadEyfX8X6zSVYv7kEgPFvcsjATLPHd/SIXPQ7wpPQPGkhLFFht3v/XRNRyxIKuhkZGaipqcGBAwfauz1ERK0yhkbb4bTbkYOGICWlRCCowh/U4POH4A+E4POHwkOjjbnBzMFdR2th2GmzwW5xoLyyHuUVPpRV+FBeWY+yCh/KKupRUelHWUU96urbd87d4YTh6LnDkTCck+Vst6I71PUEQyGUVFcjzelAussdd31ZRRHGdIGoJXhUTUcgoMLnV+EPqG1e8qersdssKBiZh4KReQCMz+ni0joz9BYWlWPPvuo2fTZLCezeW43de6vx0dKdAIx1vqOHOw8fmh2zFF40IaxQkAFd1jDsEvVgCQXd0aNHY/Xq1Xjqqadw0UUXoW/fvu3dLiKiNhNCwOmwwemwISu9YdhgKGT0lAQCKuoDQdTXBxHSNYQ0DarG+b9dmctpxcD+GRjYP6PZbXx+FeWV9aio9JkhuLzSj/KKepRXGt976zo/DANAVobDHBI9dFAW+ua5ccL4fIwJhwDqYaSE1+dHfSCIDLcLHmfrRZasFgVWtx0et7FObyT4Rnp8gyE97nSy7kIIgX590tCvTxqmnzQEAFDvC+G7nRUo3B4OvzvK2zzPv7omgFVrD2DVWqNTxmoROHJoVJGrEbnIyWpYBkARdgBp0GRtyt4bEXUtCQXdmTNnYvXq1di0aRPy8/PRt29fOBwO8/UbbrgBd955Z5tPLoTAjh072rwfEVFb2GwW2GwWpHnsyIUbUhqFYSK/OEZ6f1WzOrRmVoruxr9P9hqJhGF/QEV5VI9weYUPZZW+qDDsg7eubWuGHo6qmgCqagLYsbvS/IX8F3YLg24PFxnOXOcPINPjhsOW+PzShuDb8Fzk5l0wqJk1C7ozt8uG437QF8f9wOhI0XSJfZEiV+Fe34Ml3jYdU9UkvttRge92VODtj7YDAPrkuWN6fYcMzISiuKHL+pS/JyLqfAkF3TvvvBNvvPEG1q5da6yrdvCg+ZqUEiUlJYd18u6+5hwRdU9CCDjsVjjsVqSHn9M03Qi+IQ2BQGSuXLgStB69RJLxnC4ldMkg3F04HVbk909Hfv/0ZrcJBNRw+I30CjcMl44MnW6PMNz3iOYrXFPPElJVlFXXwOVwIN3lipm/2xaRm3eRmRu6LhEINEzb6O7B16IIDBmUiSGDMnHmKUcCAKpq/DFFrop2VSLUxiJXJWX1KCmrx2df7QUAOB0WjDwyB6OGp2PUCDdGHpmBNE/bi1wRUdeUUNB1Op1YsWIFnnjiCXzwwQfYu3cvAoEA9uzZAyEE8vLy4Ha7Wz9QOygpKcHq1auxevVqfP311/j6669RXm6UqP/DH/6AP/7xjwkfq7a2Fv/617/wxhtvYOfOndA0DUOGDMH555+PO+64A3369Gmnd0FEnc1iUeAKF4mJiATfYLhYTLxfHnUpIXUdmgyvrSkb1gzWOC+4W3E4rMjvl478fomH4YoqX0MPcTgc13rbFob79Wm+YBf1TL5AAL5AADartc09vPEoioDLZTOKXGU6oWk6fH4VPl8IvoDWrYc6R2RlOHHCuAE4YdwAAMayRLv2xBa5qqzyt+mY/oCGjVtLsXFrqfncwAFujBqegdEjMjF6RAb693WxY4aom0p4eSGXy4W77roLd911l/mcohgVJp9++umY9XU7UqrmC2/btg3nnHMOdu7cGfP85s2bsXnzZjzzzDNYtGgRTjrppJScj4i6PrvdAru9odek8ZDnYEgzwq/FEndVzcg+mq5D1bXwOsHGY00zeoWpe2lLGK6ojC2gZQydNgJxdBjuk8eg21tFenjTXC5kuFMXqCwWBWkeO9I89nCRvshIFbVHVHYGAJtVwajhxlJD551pfNaWltcba/KGhzvv3luFtr7VfQfqse9APT5dcQgAkJ5mxajhRugdNTwDw4emw+FgUTmi7iDhoNsdDB48GAUFBVi8eHGb9quursa5556LnTt3QgiBW265BRdddBFsNhs+/PBD/P3vf0dJSQnOO+88rFmzBkOGDGmnd0BEXVm8Ic/Nht+ofZpbM1iP6QmWkNJYO9gYFi05RLqbSiQMB0M6HDYFxWV1yM12Nbsd9Q5enw+BUAhZHg/sttT+amYU6bPC6bACMOqrRApc1fuM6s49ocdXCIE+eR70yfNg6g8HAzAK1W3fWYHCooYiV22t0l7rVbFmfTnWrDdGC1osAkMHp2H08AyMGpGB0cMzkZvjaOUoRNQZkvo0ff755wEA48aNS0ljDse9996LiRMnYuLEiejbty92796NYcOGtekYf//7382iWA8//DBuv/1287XJkydj/PjxmDVrFsrLy/G73/0O8+fPT+l7IKLuK6HwG9TiziVTFAUKAMQJwY3JqPCrRQKxOX+YQ6S7G4fdgsH5GRg8MLOzm0JdREhVUVpdDafdjjSXM+nhzC2JruwspYTfr6LOF4LPr/aI3t4Il9OKY8b2wTFjjalnui6x/2BtTJGr/YfaVnVZ0yR27KrFjl21eP+T/QCAvBwHRkWC74hMDBnogZXrahN1OiF7wm28KNFBN5E5usFgEEcccQRqampw1FFHYcOGDXGHDp1zzjl4//33oSgK9u3bh/79+6ekvePHj8fatWsxbtw4rFmzJiXHJKKuR9ebhl9VS23BmIaeYWO4dGS+cHddRslpsyHT0zOH9QohMDi/+SrRPVkqr3tlNbUIBNu/WnZnsFmtSHM64XLYO2yOqJQS/oAGny+Een+o26/hm4ia2gAKd5Sbvb7bd1UiGNSSOqbdrmDEsHSMGp6BghGZGDk8A+lpqbtxoQgnLKL5ESOUvMwMB7IyWl8OjLq2dhm67PV6cejQIdTW1iI9PR39+vVDWlrXrCr56aefoqamBgBw1VVXNXsxufrqq/H+++9D13W8/fbbuPHGGzuymUTUzSlK9PBBg6bpCIaMas/BoIpASEvqF0uzhxhAvF+pQpoGVVUR0jSENDXlQZuIUiekqqj0elFdryDT44bb0f7DY4UQcDmtcDmtyIELwaBmFLXyhxBIMvx1VRnpDkw8bgAmHmcUuVJVHbu+r0LhjnJs224Mdy6r8LXpmMGgji2F1dhSWA3AqPA8oJ/LnOs7ekQGBvRzQ1FY5IqoPaUs6BYXF+Pf//43Fi5ciG3btsXM9xBCoKCgABdddBFuvvnmlBWQSoWVK1eaj6dOndrsdtGvrVy5kkGXiJJmsShwWRS4nLFz50Lhas+hoIZgSE9ZILVZLLBZLIjMCJVSGkOfNS3qK4dBE3Uluq6jstYLr8+PDLcLdqutwwJSpCBfZoYjtpKzX0VP/YiwWhWMPDIHI4/MwbmnjwQAlJXXY1tRKbYWHUJhURV27/W2+abkgUM+HDjkw7KVRpErj9tqDHcebgTfEcMy4HSyyBVRKqUk6C5YsAA333wzamuNeQ6NR0NLKbF161bMmTMHDz/8MP7zn//gsssuS8Wpk7Z161bzcUFBQbPb9evXD5mZmaiuro7Zh4golawWBdZGyxzpulE1NRTSzK9tXT8yHiGEGX4b0xqtHRyZB6yHl04ioo4VUlWU1xi/ZzlsNridDrjsHTesObqSs65L1PlCqKsL9tie3mh5uW6cnDsEJ58wBLoMwOevQtHuGhQW1eC7HTX4bkc1ar1qm45ZV69i3cYKrNtYAQBQFGDIwDSjuvOITIwenoG8XAeXNiJKQtJBd/78+fjpT38KGZ4XJoTAmDFjMGrUKKSlpcHr9WL79u3Ytm0bdF1HTU0NrrjiCmiahiuuuCIV7yEp+/btAwCkpaUhM7PloiADBw5EdXW1uU9znnzySTz11FMJnZ+hmYhaoygNwwkjIuE3GK70nOo5vxZFgUWJX0zFnAMcFYRVXYeqGWGYeh9e9zpWIBRCIBRCtaLA43TA43Q2+++1PSiKQLrHjnSPHSFVR329Mac32bmt3YEiHHA5s/GD0RaMHZ0FwPhMPFjsQ2FRDQqLqvHdjhrsO1DfpuPqOrDrey92fe/Fh58eAABkZ9nD1Z2NIc/DBqexyBVRGyQVdA8dOoRbbrkFuq5DURTccsstuOeeezBo0KAm2+7btw9///vf8fjjj0PXddx000049dRT0a9fv2SakLRIL7Tn/7d35+FNVfn/wN83a9M06ZK20AVa9kUQAQFFRhSwCooL47jM44gLo4L7PooLOqPzG9DRUZYZHRV0RmRccMMNUb9u2BZRUKBAC21ZWrq3aZpmPb8/0lxSmrZpkzZN+n49Tx/Dveeee3JP7Okn99zzCWDBE2+ZxsbGDsuVlZVh+/btwTeOiKgd/oJfl8vzvK/NZ9GrnlhB1Zsyyd9q0UIIOF0u+TlgV0veYE6Fjm4c98LD7XbD3GSF2doMnUaDWK0WMZqeW63ZH7VKgXijFvFGrecLOJsTTc1ONFkdUbWCsy+FpAFghFs0QMBzkyd9YCzSB8bi7Bmev2sbLY6Wu70N2FfYgP0HG2Czde2LwNo6O374sQo//FgFAFCrFRiWHYdRw5MwZng6Rg1P4oJJRB0IKtBdtWoVLBYLJEnCyy+/jKuvvrrdspmZmXjuuecwZcoULFy4EE1NTVi9ejUef/zxYJoQtObmZgCARqPptKy2ZSEIq7XjRQnS0tICTrm0Z8+eTusjIgqEUqmA7oRpzw6HC80td35tNmdIpjx3RJIkqFUqqFXHnzsGjk+F9r0L7F0Vms8ERz6Oe2EmBKw2G6w2GxQKBWI0aug0GmjV6l6d+qpQSNDp1NDp1DAl6tBsc8LS5IClyREVuXp9eYJdA1yiwe/+OL0ak042YdLJJgCetESlhxuxtyXw3VvUgMqq5i6d0+Fwo2B/Awr2N+A9FAMA0lLjMGq4CaOHmzB6hAmD0o1c5IqoRVDphaZMmYLt27dj7ty5+PDDDwM+bv78+di0aRMmT56M/Pz87p7er66mFzrppJOwe/duDBgwAOXl5R2WnTZtGvLy8hAXFyffCQ4W0wsRUW9qNeU5BCs9h6xdJ0yH9s4U6o2VZsOB6YWYXqg3SJKEmDDd6fUlhECT1YEmq9OzkFUUBb1u0Qy3aIToxvJcNbU2+a7v3sJ6HCjp+iJXJ4rVqTBqmEkOfkcMTUKsLnx9H6mYXig6BHVH9+DBgwCACy+8sEvHXXjhhdi0aZN8fDgZDJ48ZBaLpdOy3jJ9NVUSEVFnWk959gSRvTXlucN2SRIU7UyHJqLuESfc6dVpNNCoVFAoJAgBxGh6546vJEnQx2qgj9V4cvU2O2FpCXwjPehVSDGQoIGADW5h6VLAm5SoxWmnpuC0U1MAAHaHGweKzXLgu7ewAQ1mR5fa02R14qdfj+GnX4+1tA8YnBmP0cOPB78DUvRc5Ir6haACXe+zqomJiV06LiEhodXx4ZSZmYnc3Fw0Njaivr6+wwWpvItQZWZm9lbziIh6nN8pz0437HannOfXZndF/B+kRP2Z2+2GpbkZvl/rq5RKGGJ1vTpzQpKOT28WQqDZ5kKzzZOr1+GIzMXsJEkBCTpIUMElGiDQvfehUSswekQ8Ro+IBzAIQggcq2xumepcj32FDSg9YunSox5uARQfqkfxoXp88uUBAECCUXt8uvNwE4ZmJ0Kj5peMFH2CCnRNJhPKy8tRWFjYpeO85U0mUzCnD4kxY8bIrwsKCjBt2jS/5crLy1FfX9/mGCKiaKRWKaBWaeC7TJ83vZHdJ88vQ1+iyOV0uVBrboS5ySpPb/Y8X987JOn4DJPE+Bg4HC40WuwwWyLzmV5JUkOJBLhEPQSCX4FakiQMTNVhYKoOZ04fAABoanKiqLgZ+wqbUFBYjX1FNbA2dy21UV2DDbnbjyJ3u2d1Z5VKgWFZCS13fZMxeoQJifGctkuRL6jfZqeccgo+/vhjrF27Fvfccw/U6s6fAXA4HFi3bh0kScIpp5wSzOlD4owzzpBff/PNN+0Gut98843fY4iI+gu1Wgm1Wglv9CuEkFMbNdtCn+KIiHqH0+VCQ1MTGpoARZhSFgGe3zGJCTokxMccf6bX6oioL9QkSekJdtEAIbo27TgQsbEqTDgpGZPGeR69c7kFDh2pR0FhNfYWVqOgsBrlFZ0/jufL6XRjb1EN9hbVAJ/uBwAMSNFj1DDPAlejh5swOMMIpZKpjSiyBBXoXnLJJfj4449RWFiIP/zhD1i3bp28MrE/drsd1157Lfbt2wdJkvDb3/42mNOHxKxZs2A0GtHQ0IB169bh7rvv9vvcwtq1awF4BoCuPpNMRBSNJEmCVqOCVqOCoWXpApfLDZvd584vpzwTRRRvyqJGazP0MVooFUrEaNSelGK9xPeZXrfbu5CVo8t3LsNFkhRQini4pUa4RddWVu4qpUJC9qAEZA9KwHlnDwMA1NU3Y2+RJ+gtKKxG0cHaLq+4f6zSgmOVFnz9QykAICZGhZFDkzBquAljhpswclgS9LGdZywhCqegAt1rr70WTz31FPbv348333wT+fn5uO2223DOOedg5MiRUKlUcDqd2L9/PzZv3oznn38eBw4cgCRJGDVqFBYuXBiq99FtGo0Gt9xyC5588kn8+uuveP7553Hbbbe1KvPee+/ho48+AgD8/ve/R1paWjiaSkTU5ymVCsTqFK1W+XQ4XPKdX7vDzeCXKAIIIdBo9QRp9RZArVJ5pjYrVdCoVL12d0+hkBCn1yBOr4HL5UZTs+cub3Ozs0/f6ZUkCUoYIEEJl+jaHdZgJcTHYNqkDEyblAHA8zv4QGnd8bu++6tRW9+1ALy52Ymduyuwc3cFAECSgEHpRvlZ31HDTUgfEMdFrqhPCSq9EADs27cPM2bMQFVVVZsPtzfQ9SWEQEpKCr777jsMHz48mFMDAL799ttWzwhXVVXh3nvvBQBcdNFFuPjii+V9cXFxuPTSS9vUUV9fj8mTJ6OoqAiSJOHmm2/GpZdeCrVajY8//hjLly+H3W6HyWTCjz/+iKysrKDb7cX0QkTUH8mLXdk9eX772/O+TC/E9EKRTqlUQqVUQqVQQKVUQqfV9OpUZ987vX096HWLZrhEaNJSAp6VnpWSodvHCyFQUdUk3/HdW1iNkkN1CHaxfWOcplVO32HZSdBqInORK6YXig5BB7oAcOTIESxatAiffvppp2Xnzp2LF154ARkZGcGeFgBwzTXXYN26dQGVzcrKQnFxsd99BQUFOP/883HgwAG/+1NTU7Fx40ZMnz69u031i4EuEdHx531tNhdstr6T37enMNBloBt1JMmTukiSoNNooNNqeu3uXiTc6Q0m3+6Jgg10/bFaHdh/sBZ7C6uxp7AK+4pqYGkK7hljlVLCEN9FroabYErUhajFPYuBbnQIydJ6GRkZ+Pjjj/HLL7/gnXfeQV5eHsrKymA2m2EwGJCWloapU6diwYIFGD9+fChOGXKjR4/Gzz//jOeffx5vvfUWioqK4HK5kJWVhYsuugh33HEHUlNTw91MIqKo5Pu8LwyetR68d31tNhea7c6ITT1C1C8IAbvDExg12+0wW5WI1+uhUirgdgs4XS6olEpIkgS3cMPtFlAplVCrgr/jp1QqYNBrYPBOb7Y60NjkgN0e/MrHoaKQYgAo4BYNIQl2Q02nU+Pksak4eaznb123W+BImbnlrm8VCgqrcbS8a2lBnS6B/Qdqsf9ALT74zDP7MsUU2yq1UVZmPFQqLnJFPSMkd3Sp+3hHl4goMG63kBe5studaLa74A52rl2Y8I4u7+iSh1KpRGzLtGcJkmc6tFIJhSL4u8FOlxtNTQ5YrH0n6BXC2ZJ+qPtf3PXEHd1ANJhtnkWu9lejoKgahQdqYA/yC0itRokRLYtcjW5Z5MoY13t5ndvDO7rRofeSpREREQVBoTiecxNoe9eXuX2JIo/L5YK5ydpmu0KhgEKSIPn8wHtvRpIgAfLUaJVSAaVC0fKMsAS32w2X2xOASUogzqCE0ynB0mSHpckBm8PZUpWARqVGbAcZQ0JNklQhzbXbm4wGLaacko4pp6QD8Pz+PVhah70+qY2qa9v2ZUdsdhd+LajErwWV8raMNIN8x3fUcBMyBhpC8sUH9T8MdImIKGKpVQqoVRroYz3/FsJz19dmi/y7vkT9mdvtDuKep3/eoFfrlGCzOWFtdsHp6v1gs6dz7fYWtUqBkUOTMHJoEubnjAAAVFUfX+Rqz/4qFB+q7/Lv4CNlZhwpM2PLN8UAgDi9BqOGJ8nB7/AhSYjRMoShzvFTQkREUUOSJMRoVS1/BB2/62uzeVd45rO+0WDr7r2w2h0wGQ1IiouFohdX+6XI5/2CLE6vgVatgUahQWOTvVd/NxzPtdsAt4ie6ffJpljMMMVixrRBAIBmmxOFB2uwt7AGewqrsLewBo2Wrr3fRosdP+4ox487ygF4ZvcMGZwg3/EdPdyE5CQdUxtRGwx0iYgoqnn/qIXe82/fZ31tdidsvOsbcTZ+n4ddJYcAePK7DkpOwuDUZAxOScHg1GSkmxKhUkZmWhPqXUqlBGOcFkaDFna7C5YmOxqbHL3yO0GSJCiEEZDMcAtbj58vHGK0KowbnYpxoz2LXAkhcLS8sVVqo0NHG7pUp9stUFRci6LiWmz63LPIlSlR1yqn75DBCVBzkat+j4EuERH1K3zWN7K53QIHyo7J/3Y4nThQXoED5RXyNpVSgXRTEganJHsC4NRkZCaboFHxzx5qn0ajhEajQ0J8DBotdpgb7XA4e/YuryRJUMIIoCFqg11fkiQhI82AjDQDZv8mGwBgbrRj34GWRa4Kq7H/QA1sXVw8rLrWiu/zD+P7/MMAAI1ageFDji9yNWqYCfHG8C9yRb2Lv/GJiKjf8/esr93hvevr+W9P/8FLgSmrqYG1k5WWnS43SiuqUFpRBezybFNIEgYmJSIrNVkOgAelmBCj0fRCqymSSJIEQ5wWhjgtrM1ONFrssFodPfrllwIGCMkd0c/sdpchToPJJ6dh8slpADx5kYsP1csLXBUUVqOyuqlLddodbuzeV4Xd+6rkbWkD4lotcjUo3chFrqIcA10iIqIT+Ob19SbxODG9kc3hgsvF+769rfBoebeOcwuBo9U1OFpdg6179gEAJACpCfHyXV9PAJwCfQzv/JCHd/aHy+WGueUub09Ma5YkCUphhAt1Ebcac6gplQoMy07EsOxEzJszHIDnju1en+nOB0pq4ezi79+yY40oO9aIL78rAQDE6tQYNcwntdHQJOh06pC/HwofBrpEREQB8Dfl2elyt7rra7O7wPT0PWva6JF46o9Xo6isHLtKDuNg+TEcra6V08l0hQBwrK4ex+rqkb+vSN5uMhpaTXvOSkmG0Xu7n/olpVKBBGMM4g1aNDY50NBgg9MV2lkekqSAEvFwibqg8uxGI1OiDtOnZGL6lEwAnrRERcW1re76Npi7NvW7yerAT78ew0+/eh6FUEjA4Mx4jB5uwqSTB+L0yZlIHxjHRa4iGANdIiKiblIpFVDpFIj1uQvgcPgEvnzeN+RiNGqMGZyJMYMzcdqYUbDZ7XA4XThaXYPSSs905dLKKhyurIajm6ljqhvMqG4w46eig/K2BH1sq7u+g1OTkRin5x/B/YwkSTDoNTDoNbA02VFvtoV0tWZP6iFvsMvfHO3RapQYOzIZY0cmA/A8blJeYfEEvfurUNCyyFVXvnd0C6D4UD2KD9Xjky8PAACSk3RY/f/Ow/AhST3xNqiHMdAlIiIKIbVaCbVaKa/y7Pu8b7PN818XV3kOKbVKiawBKcgakCJvc7ndKKupRWlFFQ5VVqGkogqHKqthc3TvGcg6SxPqDpZi58FSeVucLub4nd+W/6bEGxn89hP6WA30sRo025wwN4buOV5JUrUEu/UMdgMkSRLSBsQhbUAczj4jCwBgabJjX1GNPN1574EaNDc7u1RvbV0zMgYaOi9IfVJQge7XX38NABg3bhySkgL/pqOurg47d+4EAJx55pnBNIGIiKhPa/W8b5xnmyvEUx6pLaVCgcxkEzKTTQBGAfA8p1tZV4+Slru+3gWrmmzdW+220dqM3aWHsbv0sLxNp9FgUGoyBqeYPNOeU1MwICGeuX6jmDd3t9stYG12wNLkgLWLAdWJJEkNBQxwCzOD3W7Sx2owcfxATBw/EADgcguUHm69yNWxSkuHdYwcZuJzuxEsqED3rLPOgiRJ2LhxIy688MKAj8vNzcXcuXOhUCjgdAb3i4CIiCjSKJUMesJBIUkYkJiAAYkJmDrKs8iNEALV5kYcqqhCSUWlJwiuqILZau3WOax2O/YdPop9h4/K2zQqFQalmDAoJdmz6nNqCtKSEpjrN8ooFJJ8l9fhdMNstqHRYu92mKqQtJCggEs08JndEFAqJAwZnIAhgxNw3qxhAIDa+ubjge/+KhSV1MHps8L+hJNSw9VcCoGwTl3mgh1EREQUTpIkIdloQLLRgInDhwDw/H1SZ2nCoZY7v57gtxK1jR3f/WmP3elEUdkxFPnk/1UpFcgwJbUseJWCrJRkZCQnQc1cv1FBrVIgKVGHeKMWliYHGi3dy8krSWookQAXzP0y9VBPS4yPwWmTM3Da5AwAnjUWikrqUHK4HvuKajBtUkaYW0jBCMtvU2+Ay2dYiIiIqK+RJAmJcXokxulx8tAsebu5ydpqwavSiipU1jd06xxOlxslFZ4gGigA4LnjnJaU2Crd0aCUZMRoOHUyUimVChgNWhgNnpy8DWYbmm1dm80oSUooRTzckgVu0b2ZBhQYtVqJ0cNNmDYpHQnGmHA3h4IUlkC3qsqTvFmv14fj9ERERERdZojV4aSsQTgpa5C8rclmw6HK6pbnfStRWlmF8pq6bk1XdQuBI9U1OHJirt/EBGSlJGPwgOPBL3P9Rh5vejKb3Yn6BluXnuOVJAlKxAGcwkwUsF4PdG02G9atWwcAyM7O7u3TExEREYVMrFaLUZnpGJWZLm+zORw4XFmNksoqefrzkepauLub67e2Dsdq65C3r1Denmw0eNIctSx6NTg1BcZYXSjeEvUwrUaF1GQV7HYX6s02NFkDn5KsgAEC3Vs8jai/CTjQXbdunRygnuihhx7Cs88+2+HxQghYLBYUFBTAYrFAkiTMnj27S40lIiIi6uu0ajWGpQ/EsPSB8jaH04mj1bUoqag8nuu3qgbObub6rWowo6rBjO2FB+RtCXH64+mOUpORlZKMBOb67bM0GiVSTLFwutxotNhhsTjg7GRFdkmSIIFTaokCEXCgW1xcjK+++qrNL0shBHbt2hXwCb3P56ampuKee+4J+DgiIiKiSKVWqdrk+nW6XCivqZOf9y2pqMLhqirYHN3LSFHXaEFdowU7D5bI2wy6GJ88vykYnJqMZKOBwW8folIqkGCMQYIxBs02J6xWByxWB1wuLtpKFIwuT132t1JyIKsnS5KEuLg4DBkyBLNnz8bdd9+N9PT0To8jIiIiikYqpRKZKSZkppgwfWxLrl+3G8fq6lue+/WkOzpUWYUmm71b5zBbm7Gr5DB2lbTO9eu74NXg1GTm+u0jvDl5ExN0aLI60GC2wWbv3l1/ov4u4ED30UcfxaOPPtpqm0Kh6FYeXSIiIiJqS6FQIC0pEWlJia1z/TaY5TRH3jvAZmtzt85htdux9/BR7PXJ9atVq5CZ7M3z6wmABzLXb1jF6tSI1alhszvRYLZ36VleIgrBYlTMhUtERETUcyRJQnK8EcnxRkweMRRAS67fRkurac+llVWo62auX5vDiaKychSVlcvbVEolMpOTfJ77TUGGKZG5fnuZVqNCikkFh9ONxkYbzBYH//4mCkBQv6m6s3ogEREREQVHkiQkGuKQaIjDhKHZ8vaGJisOVVah5FglSlumP1c1mLt1DqfLheJjlSg+VilvUygUSPfJ9ZuVkozMFBO0aub67WlqlQKJCTrEG2NgbrTDbLHxOV6iDvArOSIiIqIoYfST69fSbMOhlju/pZWeZ367nevX7cbhqmocrqrG97v3AvDk+h2QmHA8+E1NwaAUE2K1zPXbExQKCfFGLYwGDZqsDpgb7XyOl8gPBrpEREREUUwfo8XoQRkYPShD3tZsd+BQZVWrRa/Kamrh7saUWAGgvLYO5bV1yNt7PNdvSryx1YJXg1OSYWCu35CRJAn6WA30sRo4HC5YrI6AUhQR9RchC3S3bduGTz/9FLt370ZtbS2amztfIEGSJGzZsiVUTSAiIiKiAMRo1BiRkYYRGWnyNofTiSNVNSjx3v2tqMKR6upuB06V9Q2orG/Aj/uP5/pNjNO3Dn5TU5Cgj2W6oyCp1UokqJVyiqKmJk+KIrebU5up/wo60C0tLcXVV1+Nb775pkvHCSH4S42IiIioj1CrVMgemIrsganyNqfLhbKaulapjg5VVsPu7F6u39pGC2obLdhxwDfXr65VuqOs1GSYmOu3246nKIqBpcmBhkYbHA7e5aX+J6hAt66uDjNnzkRpaSlXfyMiIiKKMiqlEoNSTBiUYsIZJ3m2eXP9eu/6eld+ttq7m+vXil0lh7Cr5JC8LVaraXXXd3BqMlIT4qFg8BswSZIQp9cgTq+BtdmJ+oZmPstL/UpQge7y5ctRUlICSZIwZMgQPPjgg5g1axYyMjKg0WhC1UYiIiIi6iN8c/1OGz0CgGemXmV9Aw5VVqOkotKz8nNFFRq7meu3yWZHweGjKGiV61eNQSmmVlOf05ISoVQoQvK+opkuRgVdTBwDXupXggp033//fQDA4MGDkZ+fj6SkpJA0ioiIiIgihyRJSE2IR2pCfKtcv7WNllZ3fUsrKlFnaerWOWwOBwqPlqPw6PFcv2qlEhnJJmT5TH1ONyVBrVKG5H1FG9+At66hGXYGvBTFggp0i4uLIUkSFi9ezCCXiIiIiGSSJCHJEIckQxxOGZYtb2+wNKGksgqHWgLgkooqVHcz16/D5ULxsQoUH6uQtykUCmSYEjEohbl+2yMHvFYH6sw2BrwUlYIKdDUaDaxWK4YOHRqq9hARERFRFDPqYzFePxjjswfL27y5fksqKlvuAFejorb7uX4PVVbjUKVPrl9JwsDE+JYpz55nfgelmBAb079z/ep0auh0aga8FJWCCnSHDRuG7du3o6amJlTtISIiIqJ+xn+uX7snz69PuqNu5/oVAmU1dSirqUOuT67f1IR4jMxIw7D0gZg1YRyS440heT+RhgEvRaOgAt3LL78cP/74Iz799FPccMMNoWoTEREREfVzMRpNm1y/dqcTh6uqcajCGwBX4kh1Tbdz/VbU1aOirh7f7irA5BHD+m2g6yUHvM1OmBttsDZ3L40UUV8QVKC7ZMkSvPLKK3jvvffw8ccfY+7cuaFqFxERERFRKxqVCkMHDsDQgQPkbZ5cv7UoqTi+4NWhqho4upDrV6VUYHBKck80OSJ5nuFVweFwoaHRDovF3q1p5EThFFSgGxsbiw8//BDnn38+FixYgIcffhg333wz4uPjQ9U+IiIiIqJ2eXL9JmNQSjLgk+u3vLYeJRWVOFxZjZKW6c/N7eT6zRqQypWa/VCrlTAl6pBg1MJsscPcaIfbzZCXIkNQge6sWbMAADqdDjabDQ8//DCWLVuGkSNHIjk5GYpO8ppJkoQtW7YE0wQiIiIiolYUCgXSTYlINyUCYzzb3EKgqr6hdbqjSk+u3+FpA8Pb4D5OqVQgwRiDeIMWjRY7Gsz2bk8XJ+otQQW6X331FSRJAgD5v06nE3v27On0WCGEfAwRERERUU9S+OT6PXXkMACATquByy3gdjNoC4QkSTDEaWGI06LJ6kCD2QYbF66iPiqoQBfwBKyBbCMiIiIi6kskSUJKvCHczYhIsTo1YnVq2OxONDTY0MSFq6iPCSrQ5bdfRERE1Bf4Pi4lhPAsnBOKL94lKTT1EEUprUaFlGQVHE43zGYbGpscvOlFfULQd3SJiIiIwiFRrwf0eigUUruPQwkhIAQgIICW/7rcbnm75zCp5d8CkDxTXJUKBZQKJRQKSa4HANxuz/FOtwsQAKTj53G6XHD5LNSjkDztkiTPnUOFJEGCBJdwe8q63HC63XC73S3lPO3gjQSKRGqVAkmJOsQbtWi0OGC22OByMeCl8GGgS0RERBFJqex40UsAcqApR6TwrNLbVd5AWqmUoFQqoOnBP6GE8ATT3h8IwCU8AbHD6YLD5WIwTH2WUqlAvFELo0EDS5MDDY02OBz8vFLvY6BLRERE1IdIkgSVUtlhQO5yu1vuLrtgdzrlANjldkMh+dyhJgoTSZIQp9cgTq+B1epAQ6MdzTY+x0u9h4EuERERUYTxTK0G1FAiRqPxW8Y7ndrhcsHpcsHpapky3TJdmqi36HRq6HRq2O0uNDTa0NTkAL+GoZ4WVKD7+OOPB92ARx55JOg6iIiIiKg1SZKgVqmgVrX9c08IAbvTCafLBbdbwOn2BMIOp5N3gqnHaDRKJCfFwhnvWbjKbOHCVdRzggp0ly1bFnQuXAa6RERERL1LkiRo1Wpo1eo2+5wuV8tUaKcc/Drdbq4+TSGjUiqQmKCD0aCF2WJHg9nOgJdCrkfy6AYq2CCZiIiIiELL+3ywDq2nRDucninQdqcTNocDDieft6TgKJUKJBhjYNBr0NBoh7mRAS+FTlCB7pdfftlpGbfbjaqqKuTm5uLVV19FdXU1rrjiCtxwww3BnJqIiIiIepFapYRapYRO6wmAfac/251O2B2e10RdpVQqkBgfA2OcBg1mmyfgDXejKOIFFejOnDkz4LK/+93v8PDDD+OKK67AG2+8gTFjxuChhx4K5vREREREFCa+05/1LdscTieabHbPHV+Xi9OdqUuULVOaDQYtGhpsaLQw4KXu6zwBXQjFx8fj7bffRnp6OpYtW4atW7f25umJiIiIqAepVSrE62ORmhCP9KREDEhMQJLBgDhdDDRqNcDH1igAKqUCSYk6pKcZEKfXgJ8a6o5eDXQBIDY2Ftdeey3cbjdWrlzZ26cnIiIiol7gzQes02oQr9cjJd6ItMREmIwGxOl00KjVXK+FOqRSKmBK1CFtIANe6rqw5NE96aSTAADffvttOE5PRERERGGgUEiI0Wjk3L9CCDicLjQ2N8Nqs4W5ddRXqVWegDfe2DKluYlpiahzYQl07XY7AKCioiIcpyciIiKiPkCSJGjUKiSp4+DSx8LhdHoWtnK64HA64Xa7w91E6kO8U5oT4mNgbrTDbLHB5WLAS/6FJdD99NNPAXie2SUiIiIiUioUUPrc7QU8i1tZ7XZYbXau6EwyhUJCvFELo0EDS5MDDY02OBz8UoRa6/VAd9WqVVi/fj0kScK0adN6+/REREREFCHUKhXUKhWMsZ67vc0OBxxOTzojFwPffk+SJMTpNYjTa2BtdsLcaIO1mfmdySOoQPfxxx8PqJzdbsfRo0fx1VdfoaSkBEIISJKEW2+9NZjTExEREVE/4Q16vVxuN5wuF5rtDjTZbJzm3M/pYlTQxajgcLjQ0GiHhamJ+r2gAt1ly5Z1ebU874PjDz/8MObMmRPM6YmIiIion1IqFFAqFNCq1YjXx6LJZoO5ycopzv2cWq2EKVGHBKMWZosd5kY73G6GvP1R0FOXu7LimUajwaxZs3DPPfdg1qxZwZ6aiIiIiAgAEKvVIlarhdVmR2NzM+wOR7ibRGGkVCqQYIxBvEGLxiYHzGYbHE7e9e9Pggp0v/zyy4DKabVaJCQkYPjw4VCpwrL+FRERERH1AzqtBjqtBg6nE2Yr0xb1d5IkwaDXwKDXwGp1oKHRjmYbn+PtD4KKOmfOnBmqdhARERERhYxapUKSIQ7OWB0arc1ostmYe7Wf0+nU0OnUsNtdaGi0oanJwed4oxhvrxIRERFR1FIplUiI08MYGwuLrRlNzTY+x9vPaTRKJCfFwhnv9uTjbbTzS5AoxECXiIiIiKKeQiHBoNPBoNPBarPD0twc7iZRmKmUCiTGtzzH27JwldPF53ijRUgDXSEEfvzxR+Tm5qKsrAxmsxkGgwHp6emYOnUqJk+e3OVVmomIiIiIQsn7HC9X4yXA8yWI0aCF0aCFpcke7uZQiIQs0F2zZg1WrFiBkpKSdstkZWXhvvvuw0033RSq0xIRERERdYtCwRsw1Jo+VhPuJlCIKIKtoLm5GfPmzcMtt9yCkpISCCHa/SkuLsbNN9+MefPmwcYV8IiIiIiIiKgHBH1H95prrsEnn3wCwLN89+zZs5GTk4ORI0ciLi4OjY2N2L9/Pz777DN88cUXcLvd+PTTT7Fw4UK88cYbQb+BUNuxYweef/55bNmyBWVlZYiPj8e4ceNwzTXX4KqrruLUayIiIiIioj5OEkEsMfbll19i9uzZkCQJ2dnZeOONNzBlypR2y2/btg1XXnklioqKIEkStmzZgrPOOqu7pw+51atX44477oCjnQTjOTk52LhxI2JjY0N2zsmTJ2P79u2YNGkSfvzxx5DVS0RE1Bdx3CMiot4Q1NTldevWAQAMBgO++uqrDoNcADj11FOxZcsWGI1GAMArr7wSzOlD6oMPPsAtt9wCh8OB9PR0rF69Gnl5efjggw+Qk5MDAPjss8+wcOHCMLeUiIiIiIiIOhJUoPvtt99CkiRcf/31GDRoUEDHDB48GNdffz2EEPjuu++COX3IOBwO3H777RBCICEhAd9//z0WL16MKVOm4IILLsDHH3+MBQsWAADeeustbNmyJcwtJiIiIiIiovYEFeiWl5cD8Nyp7Qpvee/x4fb222/j4MGDAIClS5ciKyur1X6FQoHnn38eKpXnkeann36619tIREREREREgQkq0FUoPIe7XK4uHect7z0+3N59910AnsW0rr76ar9l0tPTcc455wAAtmzZArPZ3FvNIyIiIiIioi4IKtJMT08HAGzdurVLx3nLp6WlBXP6kPFOoR41ahRSU1PbLXfmmWcCAOx2O/Lz83ulbURERERERNQ1QQW6M2fOhBACa9euxd69ewM6Zu/evVi7di0kScLMmTODOX1ImM1mHD58GAAwevToDsv67t+zZ0+PtouIiIiIiIi6J6g8utdffz1efPFFNDc34+yzz8batWvlFYr92bJlCxYuXAir1QpJkrBo0aJgTh8SR44ckV9nZmZ2WNZ3vzc49udf//oXXnjhhYDOz4CZiIgiHcc9IiLqa4IKdKdOnYpFixbh3//+N44dO4a5c+di/PjxyMnJwciRI6HX62GxWLB//35s3rwZO3bsgBBCDnKnTp0aqvfRbb7P2ur1+g7L+u5vbGxst1xZWRm2b98efOOIiIgiAMc9IiLqa4IKdAFgzZo1MJvN2LBhAwDgl19+wS+//OK3rBACAHD55ZdjzZo1wZ46JJqbm+XXGo2mw7JarVZ+bbVa2y2XlpaGSZMmBXT+PXv2dFgXERFRX8dxj4iI+pqgA12lUon169fj4osvxvLly/HTTz+1W3bSpEm4//778bvf/S7Y04ZMTEyM/Nput3dY1mazya91Ol275W688UbceOONAZ1/8uTJ/BaciIgiGsc9IiLqa4IOdL0uv/xyXH755SgpKUFeXh7KyspgNpthMBiQlpaGqVOntslP2xcYDAb5tcVi6bCs7/64uLiQnN+bv3fPnj2YPHlySOokIqL+ZfTo0fjvf/8b7mYEhOMeEREFK5BxL2SBrldWVlafDGjbk5GRIb/uaIGpE/d3tnBVoLxTp61WK7/hJiKiqMdxj4iIekPIA91IYzAYkJmZicOHD6OgoKDDsr4plMaMGROS86empqKiogIxMTEYMmRIt+vxPvOk0+lC1jbqfezH6MB+jA6R1I+dpcfrSzjukS/2Y3RgP0aHSOrHQMa9LgW6LpcL3333HQBArVbj9NNP71KDfvjhB/k52BkzZkChCCqNb8icccYZ2LBhA/bu3YuKigqkpqb6Lff1118D8CxaNWXKlJCcu7i4OCT1eJ95GjNmDH788ceQ1Em9j/0YHdiP0YH92DM47pEv9mN0YD9Gh2jrxy5FmqtXr8bZZ5+Ns88+G3l5eV0+WW5uLs466yycffbZePHFF7t8fE+5+OKLAXhWhX711Vf9likrK8Nnn30GAJg9e3arZ3uJiIiIiIio7wg40HU4HPjLX/4CAJgzZw5uv/32Lp/s9ttvx5w5cyCEwOOPPw63293lOnrCggULkJ2dDQB48sknUVJS0mq/2+3GLbfcAqfTCQC4++67e7uJREREREREFKCAA91NmzahsrISAPDEE090+4TeY8vLy/HRRx91u55Q0mg0eO655yBJEmprazF9+nT885//RH5+PjZt2oS5c+finXfeAQBceumlmD17dphbTERERERERO0JOND9+OOPAQDjxo3Dqaee2u0TTpkyBePHjwfgCZ77ivnz5+P555+HWq3G0aNHsXjxYkydOhUXXHCBPGU5JycH69atC3NLiYiIiIiIqCMBB7r5+fmQJAnnnXde0Cc977zzIIRAfn5+0HWF0s0334z8/Hxcd911yM7OhlarRUpKCmbNmoV169bhk08+QWxsbLibSURERERERB0IeNVlbw7ZYcOGBX1Sbx2lpaVB1xVqEyZMwEsvvRTuZhAREREREVE3BXxHt76+HgBgMpmCPmlSUlKrOomIiIiIiIhCJeBAV6/XAwhNcNrQ0AAAnAZMREREREREIRdwoJucnAwgNInevXV46yQiIiIiIiIKlYAD3bFjx0IIgc2bNwd90s2bN0OSJIwdOzbouoiIiIiIiIh8BbwY1ezZs/H+++8jLy8PeXl5mDp1ardOmJubi9zcXEiSxHy0IXTDDTegrKwMaWlp4W4KBYH9GB3Yj9GB/di3sX+iA/sxOrAfo0O09aMkhBCBFDx69CiGDRsGu92OCRMm4Ouvv0ZcXFyXTtbY2IgZM2Zg586d0Gq1KCoqQnp6ercaTkRERERERORPwFOX09PTsWjRIgghsGPHDsydO1dOORSIQ4cO4bzzzsPOnTshSRKuv/56BrlEREREREQUcgHf0QU8qyVPmzYN+/btAwAYDAZcd911uOqqq3DKKadAoWgdN7vdbvz888947bXX8Morr8BsNkMIgVGjRiE3NxdGozG074aIiIiIiIj6vS4FugBQWFiI2bNn49ChQ5AkSd6u0+mQlZWFhIQEAEBdXR1KSkpgtVoBAN7TZGZm4osvvsDw4cND9BaIiIiIiIiIjutyoAsANTU1uPrqq/HRRx+1rswn8AWOB7de8+bNw7p162AymbrRVCIiIiIiIqLOBfyMrq+kpCR8+OGH+O6773DZZZfJgasQotWPt+xll12G7777Dh9++CGD3BDbsWMHFi1ahCFDhiAmJgYDBgzA7Nmz8dprr7X5ooFCIz8/H4899hjmzJmD9PR0aDQaGAwGjBkzBjfeeCO2b98ecF0OhwMrV67E9OnTkZycjNjYWIwcORK33347Dhw4EHA9/ByE1hVXXAFJkuSfzvKHsx/7jgMHDmDp0qWYOHEiTCaTPNto1qxZeOKJJzrsS/ZjZOD17X0c96Ifx73IxXGvAyJE9uzZIz7//HOxYcMGsWHDBvH555+L3bt3h6p68mPVqlVCrVYLAH5/cnJyhMViCXczo8pvfvObdq+390eSJHHXXXcJt9vdYV3l5eVi4sSJ7dYTFxcnNm7c2Gmb+DkIrY8++qjNNTx48GC75dmPfcfy5ctFTExMh/9/PvPMM36PZT9GBl7f3sdxL/px3ItcHPc6FrJAl3rX+++/LyRJEgBEenq6WL16tcjLyxMffPCByMnJkT9cl156abibGlWGDRsmAIjMzExx5513infeeUfk5+eLb7/9VjzxxBPCZDLJ1/7+++9vtx6HwyFOO+00uewVV1whPvvsM7F161axfPlyYTQaBQARExMjtm3b1m49/ByElsViEdnZ2QKASE1N7XTAZz/2HQ8++KB8nSZNmiRWrlwpvv76a7F9+3bxySefiD//+c9iwoQJ4tlnn21zLPsxMvD6hgfHvejGcS9ycdzrHAPdCGS328WQIUMEAJGQkCCKi4tb7Xe5XGLBggXyh+vzzz8PU0ujzwUXXCDefPNN4XQ6/e4/cOCAGDBggAAgVCqVKCws9FvuhRdekPvnzjvvbLM/Ly9P/nZsxowZfuvg5yD07rnnHgFAzJo1SyxcuLDTAZ/92Dd8/PHH8vV58MEHO7yrZLPZ2mxjP/Z9vL7hw3EvunHci0wc9wLDQDcCrV+/Xv7QrFixwm+ZI0eOCJVKJQCIuXPn9nIL+7dVq1bJ/fP000/7LTNq1CgBQCQnJwur1eq3zJIlS+R6cnNz2+zn5yC0fvrpJ6FSqYRGoxEFBQUBDfjsx/BzuVxi6NChAoA4//zzu1UH+7Hv4/Xt2zjuRSaOe5GJ417gGOhGoMsvv1wAnmdijh071m65uXPnCgBCo9GIhoaGXmxh//brr7/K/+MvWbKkzf49e/Z0uN8rNzdXLvenP/2pzX5+DkLH5XKJKVOmCADioYceEkKITgd89mPfsGnTJvn6fv/9910+nv0YGXh9+zaOe5GH417k4rgXuG6tukzh9d133wEARo0ahdTU1HbLnXnmmQAAu92O/Pz8Xmkbea63l1KpbLPf23/A8T7yZ9KkSdDr9W2OObEefg6Ct2rVKuTn52Po0KF48MEHAzqG/dg3vPnmmwCA5ORknH766fL2iooKFBYWoqGhocPj2Y+Rgde3b+O4F3k47kUujnuBY6AbYcxmMw4fPgwAGD16dIdlfffv2bOnR9tFx3399dfy6zFjxrTZ79sXHfWhSqXC8OHD2xwD8HMQSocPH8bSpUsBACtXroROpwvoOPZj35CXlwcAGD9+PIQQeP755zF06FAMGDAAI0aMQHx8PE455RS89NJLcLvdbY5nP/Z9vL59H8e9yMJxL7Jx3AscA90Ic+TIEfl1ZmZmh2V993s/jNSzrFYr/vGPfwAANBoNLrroojZlfPsi0D6sqqqCzWaTt/NzEDq33norzGYzfvvb32Lu3LkBH8d+DD+3242CggIAnpztv/3tb3Hbbbfh4MGDrcp58/stWLCg1Z0ngP0YCXh9+zaOe5GH417k4rjXNQx0I4zZbJZfe6cTtMd3f2NjY4+1iY576KGH5F82S5YsQXp6epsyoehDfg5C491338W7776LuLg4PPvss106lv0YfvX19fK31Zs2bcLGjRsxcuRIvP/++2hoaIDZbMaHH34of5v83nvv4U9/+lOrOtiPfR+vb9/GcS+ycNyLbBz3uoaBboRpbm6WX2s0mg7LarVa+bXVau2xNpHHW2+9hb///e8AgJEjR+KJJ57wWy4UfcjPQfDMZjNuvfVWAMBjjz3W6TeSJ2I/hp/FYpFfNzc3Y+DAgfj2228xf/58GAwGxMXF4fzzz8c333wj//G9cuXKVt8osx/7Pl7fvovjXmThuBf5OO51DQPdCBMTEyO/PnEqwol8pxgE+vwFdc/WrVtx9dVXAwASEhLw9ttvIzY21m/ZUPQhPwfBW7p0KQ4fPoyTTz4Zt912W5ePZz+Gn+/1A4D77rsPKSkpbcolJyfLi604HA688847futgP/ZNvL59E8e9yMNxL/Jx3OsaBroRxmAwyK99v9Xxx3d/XFxcj7Wpv9u1axfOP/98WK1W6HQ6fPDBBxg3bly75UPRh/wcBCc/Px+rVq2CJElYs2YNVCpVl+tgP4af7/UDgJycnHbLnnvuufJr31Uf2Y99H69v38NxL/Jw3IsOHPe6puufcgqrjIwM+XVnD3R35WFz6p6DBw8iJycHtbW1UKvVeOuttzBjxowOjznxoXyTydRuWW8fJicnt5r6wc9BcJ566im43W5MmDABpaWlKC0tbVPGd2GHDz74ACkpKdBoNFiwYAEA9mNfoNVqkZKSgsrKSgDAoEGD2i3ru89bHmA/RgJe376F415k4rgXHTjudQ0D3QhjMBiQmZmJw4cPy6uutWfv3r3ya3/L/VNwysvLcc455+Do0aNQKBR47bXXMG/evE6P8+2LgoICTJgwwW85l8uFwsLCNscA/BwEyzuNZseOHbjyyis7Le+d4hUfHy8P+OzHvmHs2LH4v//7PwCea90e332+dzLYj30fr2/fwXEvcnHcix4c9wLHqcsR6IwzzgDg+eBUVFS0W86b106j0WDKlCm90rb+oqamBueccw6KiooAAP/6179w+eWXB3Sst/8A4Jtvvmm33Pbt2+XpHr7HnFgPPwfhwX7sG3yT3R84cKDdct7/V4HW30SzHyMDr2/4cdwj9mPfwHGvCwRFnPXr1wsAAoBYsWKF3zJHjx4VKpVKABBz587t5RZGN7PZLKZNmyb3wdNPP93lOkaNGiUAiOTkZGG1Wv2WWbJkiXyO3NzcNvv5OehZCxculK/vwYMH/ZZhP4bfTz/9JF+/pUuXtltu2bJlcrlXX3211T72Y9/H6xteHPf6B457kYHjXuAY6EYgm80msrOzBQCRmJgoiouLW+13uVxiwYIF8ofv888/D1NLo09zc7OYPXu2fG0feeSRbtXzwgsvyHXceeedbfbn5+cLtVotAIgZM2b4rYOfg54VyIDPfuwbcnJyBACh1+vFr7/+2mb/7t27RVxcnDyoWyyWVvvZj30fr2/4cNzrPzjuRQ6Oe4FhoBuh3n//fSFJkgAg0tPTxZo1a0ReXp748MMP5Q8/AHHppZeGu6lR5ZJLLpGv7QUXXCB++eWXDn8OHDjgtx6HwyFOO+00ua4rr7xSbN68Wfzwww9ixYoVwmg0CgAiJiZGbNu2rd328HPQcwIZ8NmPfcPu3bvla52QkCCefPJJsXXrVrF161bxt7/9TSQmJsrX8PXXX29zPPsxMvD6hgfHvf6D417k4LgXGAa6EWzlypXyty3+fnJyctp8g0PBae9at/czc+bMdusqLy8XEydObPfYuLg4sXHjxk7bxM9BzwhkwBeC/dhXfPnllyI5Obnd66dSqcTzzz/f7vHsx8jA69v7OO71Hxz3IgvHvc4x0I1wP//8s7juuutEdna20Gq1IiUlRcyaNUusW7dOuN3ucDcv6oRywBfCM+3jueeeE6effrpISkoSOp1OjBgxQtx6662iqKgo4HbxcxB6gQ74QrAf+4pjx46JpUuXivHjxwuDwSD3w0033SQKCgo6PZ79GBl4fXsXx73+g+Ne5OG41zFJCCFAREREREREFCWYXoiIiIiIiIiiCgNdIiIiIiIiiioMdImIiIiIiCiqMNAlIiIiIiKiqMJAl4iIiIiIiKIKA10iIiIiIiKKKgx0iYiIiIiIKKow0CUiIiIiIqKowkCXiIiIiIiIogoDXSIiIiIiIooqDHSJiIiIiIgoqjDQJSKKUtnZ2ZAkCdnZ2eFuChERUY/juEe+GOhS1Dty5Aiee+45XHTRRRgxYgQSExOh0WiQkpKCiRMn4oYbbsDGjRtht9vD3VTqYcuWLcOyZcuwdu3akNYpSRIkScKyZctCVi8RUXdx3CMvjnvUn6nC3QCinlJfX4+HHnoIL774Imw2W5v9VVVVqKqqws8//4wXX3wRKSkpeOihh7B48WKo1eowtJh62mOPPQYAmDlzJq655prwNoaIKMQ47tGJOO5Rf8ZAl6JSYWEh5s+fj4KCAnnb1KlTcc455yA7Oxvx8fGorq5GUVERPvnkE/z666+orKzE7bffjpNPPhlnnXVW+BpPRETURRz3iIhaY6BLUae6uhqzZ89GaWkpAODkk0/GP//5T5x++ul+y69YsQJ5eXlYunQpPv/8895sKhERUdA47hERtcVAl6LOwoUL5cH+9NNPxyeffAKj0djhMVOnTsXmzZvxzDPPcPoWERFFFI57RERtcTEqiipbt27Fpk2bAAAGgwHr16/vdLD3deedd+KMM85od39ubi5uuOEGjBo1CgaDAXq9HsOGDcPChQvxxRdfdFq/d/EG7xSxuro6/OUvf8Epp5yC+Ph4JCYmYvr06fjPf/4Dt9vd6tgdO3bguuuuw4gRI6DT6ZCamooFCxbgxx9/7PCcZ511lnxeAHC73Xj55Zdx1llnITU1FXq9HuPGjcNf/vIXmM3mVseWl5fj4Ycfxsknnwyj0Yj4+HiceeaZ+N///tfpe/UqLS3F0qVLMXXqVKSkpECj0WDgwIE455xzsGbNmk4XQznxmlksFjz11FM49dRTkZiYCL1ej5NOOgkPPPAAamtrO6zD6//+7//kbb4/X331VcDvqytO7AMAeOONN3DOOedg4MCB0Gq1yMrKwjXXXNNq2mFHqqqq8MADD2Ds2LHQ6/VISkrClClT8NRTT6GpqanLbdy1axfuuusunHLKKUhKSoJWq0VGRgYuvPBC/Pe//23zefRatGiR/N5uvfXWDs/x1FNPyWVzcnIghOhyO4moNY57bXHc47gXCI57/YAgiiKXXXaZACAAiNtuuy1k9TocDvHHP/5Rrru9n8suu0w0NTW1W4+33MyZM8WuXbvEkCFD2q3r2muvFW63WwghxJo1a4RKpfJbTqVSiY0bN7Z7zpkzZ8plzWazmD17drvnnDhxoqipqRFCCPH999+LlJSUdsvefffdnV63J598Umi12g6v2YgRI8TevXsDumZFRUVi7Nix7daVlZUlDh482G4dnf18+eWXnb6nEz366KPy8Y8++qjfMr59YLVaxcUXX9xuG7Rarfjoo486POf3338vkpOT263jpJNOEsXFxSIrK0u+Lu1xOBzitttuEwqFosNrM23aNFFWVtbm+MbGRjFy5Ei53Icffuj3PNu3bxcajUYAEMnJyeLo0aMdvkciCgzHvbY47nHc47hHQgjBQJeihtvtFiaTSf7Fk5+fH7K6r7jiCrnemJgYceONN4p169aJ//znP+KOO+4QBoNB3n/uuefKA/WJvGVOOeUUMXz4cKFQKMTll18u/v3vf4s33nhD3HfffUKv18vlXn75ZfHWW28JAGLAgAHigQceEK+//rp4+eWXxbx58+RyCQkJoqKiwu85fQebSy+9VAAQZ5xxhvjHP/4hNmzYIJYvXy4PDADE1VdfLQ4ePCgMBoPQarVi0aJFYu3ateL1118XixcvbvWHx+bNm9u9ZnfccUer9t10003ipZdeEv/73//EP/7xD3H22WfL+wcOHOh3MPG9ZhMnThSjR48WkiSJiy66SKxZs0Zs2LBB/PWvfxWDBw+Wy/3mN79pU8fGjRvFxo0bWw2I3m2+P5WVlQF8Glrr6oB/5ZVXCgBi8uTJYsWKFWLDhg1i1apVYvr06XKZpKSkdtuyf/9+YTQa5bLjx48XK1asEG+88YZ45plnxNSpUwUAMXXqVJGent7hgO92u8Ull1wi15WWlibuvPNOsXbtWvG///1PrFixQkyePFneP3bsWGGxWNrUs23bNqFWqwUAkZqaKsrLy1vtt1gsYtSoUXI9H3zwQZeuMRH5x3GP4x7HPY571D4GuhQ1du/eLf9C0el0wuFwhKTeN954Q653wIABYteuXW3KFBcXt/qWeuXKlX7r8v2mMCYmxu+A+c033whJkuRf1CaTSZx22mmitra2TdnrrrtOru9vf/ub33P6DjYAxBNPPNGmTEVFhTw4KJVKMWHCBJGSkiJ27NjRpuyrr74q1zV37ly/53z33XflMnPmzBFVVVV+y/3zn/+Uy11++eV+y/i2XaPR+B0sqqqqWl3/3NzcDuuaOXOm3/3d0dUBH4BYunRpmz8KXS5Xq2+82+tP3zsT1157bZvPudvtFnfddVer87U34D/77LNymauuusrvYO52u8WDDz4ol7v//vv91rV8+fJ2/+j1vSt08803+z2eiLqO4x7HPY57HPeofQx0KWps3rxZ/qUyevTokNU7ceJEud6Optbk5ua2GqidTmebMr6/hP/617+2W1dOTo5cTqvVitLSUr/lDh06JJ9z1qxZfsv4Djbnnntuu+d88sknW7Vvw4YN7ZYdMWKE3DZ/f1idfPLJAoAYNGiQaGxsbLceIYT4wx/+IP+h4e99+rbp8ccfb7eeF198sdNyfWHAb6+fhPB8a91RuZ9++kneP3LkSGGz2fzW43a75W+42xvwrVarSE1NFQDElClThMvl6vB9/uY3vxEAhNFoFFar1e8558yZI5/z73//uxBCiLffflveNm7cOL/HElH3cNzjuMdxz4PjHvnDxagoalRXV8uvExISQlJncXExfvrpJwDA+PHjMXfu3HbLTp06FbNmzQIAlJSUdLhYhlKpxE033dTuft+FQebPn49Bgwb5LZeZmYns7GwAwO7du9utz+uWW24J6JwDBgzApZde2m7ZGTNmAABsNhuKiopa7duxYwd27twJAFi8eDH0en2HbbrqqqsAAC6XC1u2bGm3nFKp7LD93msPBHYtwuX2229vd9/w4cPlvvb3HjZu3Ci/vvXWW6HRaPzWI0kS7r777g7b8emnn6KiogKAZzEahaLj4cDbTw0NDfjhhx/8nvPVV19FcnIyAOCBBx7Apk2b8Mc//hEAEBMTg/Xr1yMmJqbD8xBR4Djucdzz4rjHcY/aYnohog7k5eXJr3Nycjotn5OTIw9aubm5mDp1qt9yo0aN6vCPkgEDBsiv26vDt+zBgwfbXXnR17Rp0wI65+TJkzscAHzLnnjeb775Rn5ts9nw7rvvdtimI0eOyK/37NnTbrmRI0ciMTGx3f0ZGRnttqkvOe200zrcn5GRgUOHDvl9D/n5+fLr2bNnd1hPZ/t9+6m2trbL/eRdDdRXWloaXn75ZVx44YWw2Wy44IIL5H0rVqzAuHHjOjwHEYUfx73Oy3Lc6xqOexQuDHQpaphMJvl1XV1dSOosKyuTX48cObLT8r5lfI89kW9b/dFqtV0ua7PZOm1fR3V155wA0Nzc3GpfcXGx/Pqxxx7rtE2+Ohqovd+YdqdNfUmg78Nffx49elR+PXz48A7rMZlMSEhIaPf/Bd9+uvnmmzus60Qd9dP8+fOxZMkSrF69Wt52wQUXdHhXgoi6h+Mex7322tSXcNyjcOHUZYoa6enp8uuSkhI4nc6g6/TNr9fZVCQAiIuL83vsiTqbLtPdsqGqK5hz1tfXd/vYjnILhvI6hFMw76OxsREAoFKpoFarOy3f0We2p/oJ8Ny58dXRdEAi6j6Oe6Gri+Nez+G4R+HCO7oUNcaMGYOkpCTU1NTAarXi559/xqmnnhpUnQaDQX5tsVg6Le/9hXzisf2J7x89X3zxBc4+++wwtia6eK+t0+mEw+HodNDv6DPr208HDhzAkCFDQtLGX3/9Fffff3+rbXfddRfmzJnTapodEQWP417fwHGv53Dco2BEx1dFRPAsCjBnzhz536+99lrQdaalpcmv9+/f32l53zK+37T3J76/1A8fPhzGlkQf389UYWFhh2Wrq6s7nMrYE/3U3NyMK6+8Up5Ct2DBAgBATU0N/vCHP8DtdofkPETkwXGvb+C413M47lEwGOhSVPFd2e+VV15BSUlJUPX5LoixefPmTst/9tlnfo/tT2bOnCm/9r0efYEkSQAAIUSYW9I9vp+pL774osOyHa3kCfRMP91777349ddfAQA33HAD3nrrLZx77rkAgC+//BLLly8PyXmI6DiOe+HHca/ncNyjYDDQpagyffp0zJs3D4DnWaErr7yyw2eGTvTss8/i+++/l/+dnZ2NSZMmAfCkD+ho0N+2bZv8SzgrKwuTJ0/uzluIeKeeeipOOukkAMCGDRuwa9euMLfoOO+0pUCm4/VFl1xyifx65cqVcDgcfssJIfDMM890WNe8efPkBUJWr17d4SIygdi0aRNWrlwJwPOs0jPPPANJkrB27VqkpKQAAB555BFs27YtqPMQUWsc98KP417P4bhHwWCgS1Fn3bp1yMzMBABs3boVM2bM8Jv/zFdeXh5ycnJw5513tllwwPe5i4ULF6KgoKDN8aWlpbjiiivkKSr33nsvlEplsG8lIkmShL/+9a8AAIfDgXnz5rVKD+DP7t27sXjx4h5vm/d5nIKCAlit1h4/X6hNmDBBnqZYUFCAJUuWwOVytSojhMD999/f6Wder9fj0UcfBeCZYnXeeed1Ok0xNzcX9913X5vtx44dw3XXXQcA0Gg0WL9+PWJjYwEAAwcOxCuvvALA83n4/e9/H7F/cBH1VRz3wovjXs/huEfB4GJUFHWSk5OxZcsWzJ8/H/v27cPOnTtx+umnY9q0aTjnnHOQnZ0No9GImpoaFBUV4ZNPPsEvv/zSbn2XXXYZNm7ciDfeeANlZWWYNGkSrrnmGpx++ulQKpXYtm0bXnrpJTQ0NADw5BRcsmRJb73dPmn+/Pl45JFH8Pjjj6O0tBTTpk1DTk4O5syZg8zMTEiShOrqauzatQtfffUVdu/eDaVSiTVr1vRou2bPno2dO3fCYrFg/vz5WLhwIZKTk+WpXVOnTkVSUlKPtiFYa9asweTJk9HQ0IB///vfyMvLw9VXX41BgwahvLwcr7/+upzL8vDhw61SM5zolltuQX5+Pl599VXs3LkTY8eOxYUXXogzzzwTaWlpcLlcqKysxC+//IItW7bg4MGDGDZsWKupWEIILFy4EBUVFQCAJ554AhMnTmx1nvPPPx+33HILVq5cif379+O2227DSy+91DMXiKgf4rgXfhz3eg7HPeo2QRSlamtrxeLFi4VGoxEAOv0ZOHCgWLVqlXA4HG3qcjgcYtGiRZ3Wcemll4qmpqZ22+QtN3PmzA7b/sorr8hlX3nllQ7Lzpw5Uy7bnf1eBw8elMstXLiww7KPPvqoXPbLL79st9yLL74ojEZjQNc/KyvLbx2BXrNAyh4+fFikpKS024aO3kt7fK/Fo48+6rdMoH0QaNnvvvtOJCcnt/s+TjrpJFFSUiKysrI6vLZCCOF2u8Wf//xnodVqA+qnE6/t3//+d3nfnDlzhNvt9nseq9Uqxo0bJ5d98803O70WRNQ1HPcC2+/FcY/jHse96MapyxS1EhISsHr1ahQVFeGZZ57BBRdcgKFDh8JoNEKlUsFkMmHixIm44YYb8N577+HQoUNYsmQJVKq2Ex1UKhVefPFFbN26Fddffz2GDx8OvV4PnU6HIUOG4KqrrsKWLVvw5ptvQqfTheHd9k2LFi1CSUkJnn76aeTk5CA9PR1arRZarRYDBw7EmWeeiXvvvRdbtmzBgQMHerw9GRkZ2L59O26//XaMGzcOcXFx8rfakWT69OnYs2cP/vSnP2H06NHQ6XRISEjA5MmTsXz5cuTl5WHw4MEB1SVJEh566CEcPHgQjz/+OGbOnImBAwdCo9EgJiYGmZmZmDNnDh5++GFs3boVX331lXzsjh078MADDwAATCYT1q1b1+71jImJwfr16xETEwPAs2jHoUOHgrsQRNQKx73w47jXMzjuUXdIQkToMmxEREREREREfvCOLhEREREREUUVBrpEREREREQUVRjoEhERERERUVRhoEtERERERERRhYEuERERERERRRUGukRERERERBRVGOgSERERERFRVGGgS0RERERERFGFgS4RERERERFFFQa6REREREREFFUY6BIREREREVFUYaBLREREREREUYWBLhEREREREUUVBrpEREREREQUVf4/zoueixtWypUAAAAASUVORK5CYII=",
      "text/plain": [
       "<Figure size 1000x500 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "sns.set_context(\"talk\", font_scale=1.2)\n",
    "plot2 = sns.lmplot(data=affective_comment_phab_df, x=\"speakers_comment\", y=\"polarized_wc\", hue=\"date_group\", col=\"meta.affil\", scatter=False, legend=False, palette=palette)\n",
    "plot2.set_axis_labels(\"Comment Index\", \"Count of Polarized Words\")\n",
    "plot2.set_titles(col_template=\"WMF Affiliation: {col_name}\")\n",
    "plot2.fig.subplots_adjust(top=0.9)  # Adjust subplots to make room for the title\n",
    "#plot2.add_legend(title=\"Comment publication timestamp:\")\n",
    "plot2.fig.savefig('c3-050125_affective_language_use-slides.png')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d2d67d38-f005-4c94-be3c-39eb6b22686f",
   "metadata": {},
   "outputs": [],
   "source": [
    "#pattern = r'\\b(ve|VE|visualeditor|VisualEditor)\\b'\n",
    "#pattern = r'\\b(WMF|Foundation)\\b'\n",
    "#pattern = r'\\b(bots)\\b'\n",
    "filtered_dependencies = dependency_relations_df[dependency_relations_df['token'].str.contains(pattern, regex=True)]\n",
    "resolved_filtered_dependencies = resolved_dependency_relations_df[resolved_dependency_relations_df['token'].str.contains(pattern, regex=True)]\n",
    "\n",
    "plt.figure(figsize=(12, 8))\n",
    "gs = GridSpec(2, 1, height_ratios=[6, 6])\n",
    "\n",
    "# Main plot: Token depth by timestamp\n",
    "'''\n",
    "ax0 = plt.subplot(gs[0])\n",
    "sns.scatterplot(data=filtered_dependencies, x='timestamp', y='dependency', hue='wmfAffil', style='dependency', markers=True, s=100, ax=ax0)\n",
    "ax0.set_title('VE Depth by Timestamp w/o URLS')\n",
    "ax0.set_xlabel('')\n",
    "ax0.set_ylabel('Dependency Type')\n",
    "ax0.legend().set_visible(False)\n",
    "'''\n",
    "# Calculate the median depth over time\n",
    "filtered_dependencies['week'] = filtered_dependencies['timestamp'].dt.to_period('W').dt.start_time\n",
    "median_depth = filtered_dependencies.groupby('week')['depth'].median().reset_index()\n",
    "\n",
    "wmf_filtered_dependencies = filtered_dependencies[filtered_dependencies['wmfAffil'] == True]\n",
    "wmf_median_depth = wmf_filtered_dependencies.groupby('week')['depth'].median().reset_index()\n",
    "\n",
    "other_filtered_dependencies = filtered_dependencies[filtered_dependencies['wmfAffil'] != True]\n",
    "other_median_depth = other_filtered_dependencies.groupby('week')['depth'].median().reset_index()\n",
    "\n",
    "# Plot the median depth over time\n",
    "ax0 = plt.subplot(gs[0])\n",
    "sns.lineplot(data=median_depth, x='week', y='depth', ax=ax0, color='black', label='Median Depth', marker='o')\n",
    "sns.lineplot(data=wmf_median_depth, x='week', y='depth', ax=ax0, color='#c7756a', label='WMF-affiliated authors', marker='x')\n",
    "sns.lineplot(data=other_median_depth, x='week', y='depth', ax=ax0, color='#5da2d8', label='Nonaffiliated authors', marker='x')\n",
    "ax0.set_title('Median Depth of \"VE\" in Phabricator Sentence Dependency Trees')\n",
    "ax0.set_ylabel('Median Depth')\n",
    "ax0.set_xlabel('')\n",
    "\n",
    "# Calculate the median depth over time\n",
    "resolved_filtered_dependencies['week'] = resolved_filtered_dependencies['timestamp'].dt.to_period('W').dt.start_time\n",
    "resolved_median_depth = resolved_filtered_dependencies.groupby('week')['depth'].median().reset_index()\n",
    "\n",
    "resolved_wmf_filtered_dependencies = resolved_filtered_dependencies[resolved_filtered_dependencies['wmfAffil'] == True]\n",
    "resolved_wmf_median_depth = resolved_wmf_filtered_dependencies.groupby('week')['depth'].median().reset_index()\n",
    "\n",
    "resolved_other_filtered_dependencies = resolved_filtered_dependencies[resolved_filtered_dependencies['wmfAffil'] != True]\n",
    "resolved_other_median_depth = resolved_other_filtered_dependencies.groupby('week')['depth'].median().reset_index()\n",
    "\n",
    "# Plot the median depth over time\n",
    "ax1 = plt.subplot(gs[1])\n",
    "sns.lineplot(data=resolved_median_depth, x='week', y='depth', ax=ax1, color='black', label='Median Depth', marker='o')\n",
    "sns.lineplot(data=resolved_wmf_median_depth, x='week', y='depth', ax=ax1, color='#c7756a', label='WMF-affiliated authors', marker='x')\n",
    "sns.lineplot(data=resolved_other_median_depth, x='week', y='depth', ax=ax1, color='#5da2d8', label='Nonaffiliated authors', marker='x')\n",
    "ax1.set_title('Median Depth of \"VE\" in Coreference-resolved Phabricator Sentence Dependency Trees')\n",
    "ax1.set_ylabel('Median Depth')\n",
    "ax1.set_xlabel('')\n",
    "\n",
    "plt.tight_layout()\n",
    "#plt.show()\n",
    "\n",
    "#plt.savefig('031625_VE_depth_fig.png')"
   ]
  }
 ],
 "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.18"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}