mw-lifecycle-analysis/text_analysis/case1/031025_phab_comments.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/case1/0312_resolved_ve_phab_comments.csv\"\n",
    "phab_df = pd.read_csv(phab_path)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "d449164e-1d28-4580-9eb1-f0f69978f114",
   "metadata": {},
   "outputs": [],
   "source": [
    "#find gerrit phab PHID: PHID-USER-idceizaw6elwiwm5xshb\n",
    "phab_df['isGerrit'] = phab_df['AuthorPHID'] == 'PHID-USER-idceizaw6elwiwm5xshb'\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 11-1-2012 before 11-1-2013\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'] < 1383264000) & (phab_df['date_created'] > 1351728000)]\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",
    "comment_phab_df = filtered_phab_df[filtered_phab_df['meta.gerrit'] != True]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "942344db-c8f5-4ed6-a757-c97f8454f18b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Unique conversation_ids: 2081\n",
      "Unique ids: 8804\n",
      "Unique speakers: 230\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": 5,
   "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": 6,
   "id": "3ae40d24-bbe8-49c3-a3a9-70bde1b4d559",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_14026/3649688126.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['text'].apply(preprocess_text)\n"
     ]
    }
   ],
   "source": [
    "comment_phab_df['processed_text'] = comment_phab_df['text'].apply(preprocess_text)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "b8eddf40-1fe2-4fce-be74-b32552b40c57",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_14026/1316816771.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_resolved_text'] = comment_phab_df['resolved_text'].apply(preprocess_text)\n"
     ]
    }
   ],
   "source": [
    "comment_phab_df['processed_resolved_text'] = comment_phab_df['resolved_text'].apply(preprocess_text)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "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": 9,
   "id": "8b9a12f9-71bf-4bc9-bcfd-c73aab4be920",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_14026/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": 10,
   "id": "337a528a-5667-4e1f-ac9a-37caabc03a18",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_14026/2117289791.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['resolved_dependency_tree'] = comment_phab_df['processed_resolved_text'].apply(extract_dependency_tree)\n"
     ]
    }
   ],
   "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_14026/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_14026/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_14026/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_14026/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_14026/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_14026/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_14026/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",
    "\n",
    "dependency_relations = []\n",
    "resolved_dependency_relations = []\n",
    "\n",
    "for index, row in comment_phab_df.iterrows():\n",
    "    text = row['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",
    "    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"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "82cd9dde-0d14-4de5-8482-5a39de8d2869",
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.figure(figsize=(10, 6))\n",
    "task_phab_df = phab_df[phab_df['comment_type']==\"task_description\"]\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",
    "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",
    "plt.title('New Phabricator Tasks Indexed with \"VisualEditor\"')\n",
    "plt.xlabel('Timestamp')\n",
    "plt.ylabel('Unique taskPHIDs')\n",
    "plt.xticks(rotation=45)\n",
    "plt.grid(True)\n",
    "plt.tight_layout()\n",
    "#plt.show()\n",
    "\n",
    "\n",
    "plt.savefig('031825_new_tasks_fig.png')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9a9b08a7-6c95-4971-b259-8e713c58fbe7",
   "metadata": {},
   "outputs": [],
   "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-01-2013 to 09-30-2013\n",
    "unaff_tasks_phab_df = unaff_tasks_phab_df[(unaff_tasks_phab_df['date_created'] < 1380499200) & (unaff_tasks_phab_df['date_created'] > 1370044800)]\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-01-2013 to 09-30-2013 Weekly Unaffiliated Task Creation by Contirbutor Tenure\")\n",
    "plt.xlabel('Week')\n",
    "plt.ylabel('Tasks')\n",
    "plt.legend(title=\"Contributor had created # tasks by 06-01-2013:\")\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": 33,
   "id": "b7cfad77-d48a-4708-91f3-89ae1179b90c",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_14026/3877447769.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_14026/3877447769.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_14026/3877447769.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_14026/3877447769.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                      1911\n",
      "After announcement, before deployment    1403\n",
      "After deployment                         5490\n",
      "dtype: int64\n",
      "\n",
      "Number of speakers for each date group:\n",
      "date_group\n",
      "Before announcement                      105\n",
      "After announcement, before deployment     92\n",
      "After deployment                         197\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          625\n",
      "                                                      True            86\n",
      "                                       True           False          864\n",
      "                                                      True           336\n",
      "After announcement, before deployment  False          False          589\n",
      "                                                      True           104\n",
      "                                       True           False          492\n",
      "                                                      True           218\n",
      "After deployment                       False          False         2895\n",
      "                                                      True           595\n",
      "                                       True           False         1638\n",
      "                                                      True           362\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          92\n",
      "                                                      True           25\n",
      "                                       True           False           7\n",
      "                                                      True            7\n",
      "After announcement, before deployment  False          False          77\n",
      "                                                      True           31\n",
      "                                       True           False           7\n",
      "                                                      True            7\n",
      "After deployment                       False          False         184\n",
      "                                                      True           60\n",
      "                                       True           False           7\n",
      "                                                      True            7\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         4109\n",
      "               True           785\n",
      "True           False         2994\n",
      "               True           916\n",
      "dtype: int64\n",
      "\n",
      "Number of speakers for each engaged commenter subgroup, and WMF affiliation:\n",
      "est_commenter  meta.affil\n",
      "False          False         212\n",
      "               True           79\n",
      "True           False           7\n",
      "               True            7\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": 33,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1333.5x1000 with 4 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "bins = [\n",
    "    pd.Timestamp('1900-01-01 00:00:01+00:00'),\n",
    "    pd.Timestamp('2013-06-06 00:00:01+00:00'),\n",
    "    pd.Timestamp('2013-07-01 00:00:01+00:00'),\n",
    "    pd.Timestamp('2100-01-01 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": 40,
   "id": "5a91a59a-0d1c-48b3-93dd-b9df76ca68e5",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<seaborn.axisgrid.FacetGrid at 0x155075344910>"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAABR4AAAHaCAYAAABmaVX2AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8ekN5oAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOzdd5wU9f0/8NeU7e36Hb0cHRTsigUOUcCGGqNRY0vRFBPRxPZN/NqSqIkaa9Tf14IaTUyMqFFBLIBiQ0CwIeXocMBxbXuZmc/vj71bbrnjuOX2bmeP1/Px2Ife7Ozu59b1Zuc97yIJIQSIiIiIiIiIiIiIskjO9QKIiIiIiIiIiIio92HgkYiIiIiIiIiIiLKOgUciIiIiIiIiIiLKOgYeiYiIiIiIiIiIKOsYeCQiIiIiIiIiIqKsY+CRiIiIiIiIiIiIso6BRyIiIiIiIiIiIso6Bh6JiIiIiIiIiIgo6xh4JCIiIiIiIiIioqxj4JGol7vttttQXl4OSZLw6quvtrvt8ssvx9lnn516zOTJkzFr1qzUz4MHD8YDDzzQ5bVk63l60uzZs1FQUJDrZRARkQnxGEtERETUMQYeiTrw+OOPw+PxQNO01LZgMAiLxYLJkyen7btw4UJIkoTq6moAyRMASZLwz3/+s83zjh07FpIkYfbs2altLfu3vvXv33+/a9y6dSusVivGjRvX5r5Vq1bh9ttvxxNPPIGamhrMmDGj3W0PPvhg2lr29vnnn+PKK6/c71pa7CtYl+nzZMvll1/e5r2VJAnr1q3r8bUQEVESj7FJ+XyMbe/Y2vp222239eh6iIiIyHwYeCTqQFVVFYLBIJYuXZra9uGHH6KiogKfffYZotFoavuCBQswcOBAVFZWprYNGDAAzzzzTNpzfvrpp9ixYwdcLleb17vjjjtQU1OTun3xxRf7XePs2bNx/vnnw+/347PPPku7r+UEbebMmaioqIDNZmt3m8/n6zCrr7S0FE6nc79r2Z9sPc+BmD59etp7W1NTgyFDhuRkLURExGNsi3w+xrZ+Px944AF4vd60bb/97W9T+woh0oLMREREdHBg4JGoAyNHjkSfPn2wcOHC1LaFCxdi5syZGDJkCD799NO07VVVVWmPv/jii7Fo0SJs2bIlte3pp5/GxRdfDFVV27yex+NBRUVF6lZaWtrh+oQQeOaZZ3DJJZfgoosuwlNPPZW677bbbsOZZ54JAJBlOZV5sPc2AG3KwPa2d/nW/fffj0MOOQQulwsDBgzAL37xCwSDwdT7cMUVV6CpqalNxsPez7N582bMnDkTbrcbXq8X559/Pnbu3Jn2O0yYMAHPP/88Bg8eDJ/Phx/84AcIBAIdvi/tsdlsae9tRUUFFEXp8Hdpz8qVK1FVVQWPxwOv14sjjjgi7aR58eLFOPHEE+FwODBgwAD8+te/RigUyni9RES9HY+xSfl8jG39fvp8PkiSlPr5u+++g8fjwdy5c3HEEUfAZrNh8eLF7b4fs2bNSstyNQwDd911F4YMGQKHw4Hx48fj5Zdf7vS6iIiIyDwYeCTaj6qqKixYsCD184IFCzB58mRMmjQptT0SieCzzz5rc1JUXl6OadOm4dlnnwUAhMNhvPTSS/jRj36UlbUtWLAA4XAYU6dOxQ9/+EP885//TAW5fvvb36YyQVpnHuy97UDIsoyHHnoI33zzDZ599lm8//77uOGGGwAAEydObJP10DrjoYVhGJg5cybq6+uxaNEivPPOO1i/fj0uuOCCtP2qq6vx6quv4o033sAbb7yBRYsW4e67707dP3v27NTJXbZ/l/ZcfPHF6N+/Pz7//HMsW7YMN910EywWS2qt06dPx/e+9z18+eWXeOmll7B48WJcffXVB7w+IqLejMfYtnrTMRYAbrrpJtx9991YtWoVDj300E495q677sJzzz2Hxx9/HN988w2uvfZa/PCHP8SiRYu6tBYiIiLqeQw8Eu1HVVUVPvroI2iahkAggC+++AKTJk3CSSedlMrS+OSTTxCLxdqcFAHAj370I8yePRtCCLz88suorKzEhAkT2n2tG2+8EW63O3V76KGHOlzbU089hR/84AdQFAXjxo3D0KFD8e9//xsA4Ha7U6VdLdkH7W07ELNmzUJVVRUGDx6MKVOm4A9/+AP+9a9/AQCsVmubrAe3293mOd577z189dVXePHFF3HEEUfgmGOOwXPPPYdFixbh888/T+1nGAZmz56NcePG4cQTT8Qll1yC9957L3W/z+fDyJEj97vmN954I+29/f73v7/f36U9mzdvxtSpUzFq1CgMHz4c3//+9zF+/HgAyROliy++GLNmzcLw4cMxceJEPPTQQ3juuefSSgaJiCiJx9i28vEY25E77rgDp5xyCiorK1FUVLTf/WOxGP70pz/h6aefxrRp0zB06FBcfvnl+OEPf4gnnniiS2shIiKinte2DoWI0kyePBmhUAiff/45GhoaMGLECJSWlmLSpEm44oorEI1GsXDhQgwdOhQDBw5s8/jTTz8dV111FT744AM8/fTTHWZiXH/99bj88stTP5eUlOxz38bGRrzyyitYvHhxatsPf/hDPPXUU2nP0R3effdd3HXXXfjuu+/g9/uhaRqi0SjC4XCn+0utWrUKAwYMwIABA1LbxowZg4KCAqxatQpHHXUUgGTpmMfjSe3Tp08f7Nq1K/XzOeecg3POOWe/r1dVVYXHHnss9XNL/69Mf5frrrsOP/nJT/D8889j6tSp+P73v5/qObZy5Up8+eWXeOGFF1L7CyFgGAY2bNiA0aNHd+q9ISI6WPAY21Y+HmM7cuSRR2a0/7p16xAOh3HKKaekbY/H4zjssMO6tBYiIiLqeQw8Eu3HsGHD0L9/fyxYsAANDQ2YNGkSAKBv374YMGAAPv74YyxYsABTpkxp9/GqquKSSy7Brbfeis8++wxz5szZ52uVlJRg2LBhnVrXiy++iGg0imOOOSa1rSXItWbNGowYMSKD37LzNm7ciDPOOAM///nP8cc//hFFRUVYvHgxfvzjHyMej2e9sX1LGXMLSZJgGEbGz+Nyudq8twfyu9x222246KKL8Oabb2Lu3Lm49dZb8c9//hPnnHMOgsEgrrrqKvz6179u87j2TpiJiA52PMamy9djbEf2HvQjyzKEEGnbEolE6t9b+lm++eab6NevX9p+Npstq2sjIiKi7sdSa6JOqKqqwsKFC7Fw4cK05ucnnXQS5s6diyVLlrRbAtbiRz/6ERYtWoSZM2eisLAwK2t66qmn8Jvf/AYrVqxI3VauXIkTTzwRTz/9dFZeoz3Lli2DYRi47777cOyxx2LEiBHYvn172j5WqxW6rnf4PKNHj8aWLVvShgJ8++23aGxsxJgxY7pl7XvrzO/SnhEjRuDaa6/F/Pnzce6556Z6eh1++OH49ttvMWzYsDY3q9Xa3b8OEVFe4jF2j950jN2X0tLSNv0vV6xYkfr3MWPGwGazYfPmzW2Opa0zOImIiCg/MPBI1AlVVVVYvHgxVqxYkcrGAIBJkybhiSeeQDwe7/CkaPTo0di9e3cqQNVVK1aswPLly/GTn/wE48aNS7tdeOGFePbZZ6FpWlZea2/Dhg1DIpHAww8/jPXr1+P555/H448/nrbP4MGDEQwG8d5772H37t0Ih8Ntnmfq1Kk45JBDcPHFF2P58uVYsmQJLr30UkyaNCmjsqw5c+Zg1KhR3fa7tBaJRHD11Vdj4cKF2LRpEz766CN8/vnnqRLqG2+8ER9//DGuvvpqrFixAmvXrsVrr73G4TJERB3gMXaP3nSM3ZcpU6Zg6dKleO6557B27Vrceuut+Prrr1P3ezwe/Pa3v8W1116LZ599FtXV1Vi+fDkefvjh1CAhIiIiyh8MPBJ1QlVVFSKRCIYNG4by8vLU9kmTJiEQCGDkyJHo06dPh89RXFwMh8ORlfU89dRTGDNmTLsnA+eccw527dqFt956Kyuvtbfx48fj/vvvxz333INx48bhhRdewF133ZW2z8SJE/Gzn/0MF1xwAUpLS/HnP/+5zfNIkoTXXnsNhYWFOOmkkzB16lQMHToUL730UkbraWpqwurVq7vtd2lNURTU1dXh0ksvxYgRI3D++edjxowZuP322wEAhx56KBYtWoQ1a9bgxBNPxGGHHYb//d//Rd++fQ9ofUREBwMeY/foTcfYfZk2bRpuueUW3HDDDTjqqKMQCARw6aWXpu1z55134pZbbsFdd92F0aNHY/r06XjzzTcxZMiQrK6FiIiIup8k9m6yQkRERERERERERNRFzHgkIiIiIiIiIiKirGPgkYiIiIiIiIiIiLKOgUciIiIiIiIiIiLKOgYeiYiIiIiIiIiIKOsYeCQiIiIiIiIiIqKsY+CRiIiIiIiIiIiIsq7XBx6FEPD7/RBC5HopREREeY/HVSIiIiIi6qxeH3gMBALw+XwIBAK5XgoREVHe43GViIiIiIg6q9cHHomIiIiIiIiIiKjnMfBIREREREREREREWcfAIxEREREREREREWUdA49ERERERERERESUdQw8EhERERERERERUdYx8EhERERERERERERZx8AjERERERERERERZR0Dj0RERERERERERJR1DDwSERERERERERFR1jHwSERERERERERERFnHwCMRERERERERERFlHQOPRERERERERERElHUMPBIREREREREREVHW5TTw+MEHH+DMM89E3759IUkSXn311bT7g8Egrr76avTv3x8OhwNjxozB448/npvFEhERERERERERUaflNPAYCoUwfvx4PProo+3ef91112HevHn4+9//jlWrVmHWrFm4+uqr8frrr/fwSomIiIiIiIiIiCgTai5ffMaMGZgxY8Y+7//4449x2WWXYfLkyQCAK6+8Ek888QSWLFmCs846q4dWSURERERERERERJkydY/HiRMn4vXXX8e2bdsghMCCBQuwZs0anHrqqft8TCwWg9/vT7sRERHRgeFxlYiIiIiIDpSpA48PP/wwxowZg/79+8NqtWL69Ol49NFHcdJJJ+3zMXfddRd8Pl/qNmDAgB5cMRERUe/S3cdV3YghoQchhMjq8xIRERERUe6ZPvD46aef4vXXX8eyZctw33334Ze//CXefffdfT7m5ptvRlNTU+q2ZcuWHlwxERFR79L9x1UBTQ8hptXDEIksPzcREREREeVSTns8diQSieB//ud/MGfOHJx++ukAgEMPPRQrVqzAvffei6lTp7b7OJvNBpvN1pNLJSIi6rV66rgqhIZYogGq4oJFcXX76xERERERUfczbcZjIpFAIpGALKcvUVEUGIaRo1URERFR9xHQ9CBiWgOE0HO9GCIiIiIi6qKcZjwGg0GsW7cu9fOGDRuwYsUKFBUVYeDAgZg0aRKuv/56OBwODBo0CIsWLcJzzz2H+++/P4erJiIiou5kGHHERD0sigeKbM/1coiIiIiI6ABJIofd3BcuXIiqqqo22y+77DLMnj0bO3bswM0334z58+ejvr4egwYNwpVXXolrr70WkiR16jX8fj98Ph+amprg9Xqz/SsQEREdVLJ9XNWNKOJa0z7vV2QHLIqn08d9IiIiIiIyj5wGHnsCA49ERETZ09OBRwCQJBVW1QtZsnT59YiIiIiIqOeYtscjEREREbBn8Iymh3O9FCIiIiIiygADj0RERJQHBBJ6ADGtEUJwyBwRERERUT5g4JGIiIjyhmHEENPqoBvxXC+FiIiIiIj2g4FHIiIiyitCGIhrDUjowVwvhYiIiIiIOsDAIxEREeUlTQ8hlqiHIRK5XgoREREREbWDgUciIiLKW4ZIIJZoQEIPQAiR6+UQEREREVErDDwSERFRnhPQ9HBz78dYrhdDRERERETNGHgkIiKiXkEIHXGtEXGtEULouV4OEREREdFBT831AoiIiIiySTdi0I04VMUFVXZCkqRcL4mIiIiI6KDEjEciIiLqhQQ0PYiYVg/D4PAZIiIiIqJcYOCRiIiIei0hNMS0BiT0IIfPEBERERH1MAYeiYiIqJcT0PRQMvtRMPuRiIiIiKinMPBIREREORNP6NANo0deSwgNsQSzH4mIiIiIegoDj0RERJQzumHAH4704Csmsx/jWgMMofXg6xIRERERHXwYeCQiIqKciicSCEWjPfqahkgglqiHpod69HWJiIiIiA4mDDwSERFRzgWjMSQ0vYdfVSChBxFL1MMQPf3aRERERES9HwOPRERElHtCoDEc6rF+j60lsx/roOnhHn9tIiIiIqLejIFHIiIiMgVDNxDo0X6PrQkk9ABiWgMEsx+JiIiIiLKCgUciIiIyjVgO+j22ZhhxRBN10I3crYGIiIiIqLdg4JGIiIhMJRiJIpbI5cRpgbjWhLjWBCF6vvSbiIiIiKi3YOCRiIiITMcfDuek32NruhFFTKuDbsRzug4iIiIionzFwCMRERGZjmEYaAyFIITI6TqEMBDXGpHQQzldBxERERFRPmLgkYiIiExJ03T4I7kaNtOagKYHEdMaWXpNRERERJQBBh6JiIjItKKxOCIxc5Q6G0aMpddERERERBlg4JGIiIhMzR+JQNP1XC8DAEuviYiIiIgywcAjERER5YRuxNEY+XL/fRyFQEMolPNhM3uw9JqIiIiIqDMYeCQiIqKc2N74DjbX/x11kX8joe/qcF9DN+APm6Hf4x4svSYiIiIi6hgDj0RERNTjook6bGt4GwAQ17ejNvwiGqPvQTf2HVyMJxIIRqM9tcROYek1EREREdG+MfBIREREPU6ChALnmLRt4cRX2BWajVB85T5LmEORKGKJRE8sMQMsvSYiIiIiag8Dj0RERNTjbJYijOrzMwwp/glUuTC1XSCGptgC1IZfREzb0u5j/eEINMMcw2ZaY+k1EREREVE6Bh6JiIgoZzz2ESh1/hBe20mQYE1t14zdqIv8B/WRN6EZ/rTHGIaBplB4/0NpciBZet3A0msiIiIiIjDwSERERDkmSQrc1sNR5roMDjW9/DqqrUVt6DkEYp9BCC21XdN00w2baY2l10REREREDDwSERGRSSiyC4WOU1HivAAWuTy1XUBDIP4JdoWeQyRRncp0jMbjiMRiuVrufrH0moiIiIgOdgw8EhERkalYlT4ocf4ABfZTIEvO1HZd+NEQ/S/qI68iodcDAPyRKBKa+fo9tthTeh00ZWk4EREREVF3YuCRiIiITEeSJDgtY1Hmugwuy2EApNR9MX0TasN/R1P0AxhGFI2hEHTD3CXNmh5CXGuAIcwbJCUiIiIiyjYGHomIiMi0ZMkGn30SSp0/hFUZ0OoeA6HEcuwKPYtg7Gs0Bc0/zMUQCcQSdcx+JCIiIqKDBgOPREREZHoWpRjFjnNRaD8DiuRNbTdEGI3R+djufwG1/vU5XGFnCWh6qLn3YzTXiyEiIiIi6lYMPBIREVFekCQJDsswlLkuhcd6LAAldV/C2IGtjc9hfe0cJPRg7hbZSULoiGtNiGkNMFpN6yYiIiIi6k0YeCQiIqK8IkkqPLZjUea6DHZ1eNp9TZGV+Hb7w9jl/xQiD/opGkYcsUQ9EnoAQpi7TyURERERUaYYeCQiIqK8pMpeFDlOR7Hje1Dl4tR2Q8SwrXEevtvxOALRfCm/DrP8moiIiIh6nZwGHj/44AOceeaZ6Nu3LyRJwquvvtpmn1WrVuGss86Cz+eDy+XCUUcdhc2bN/f8YomIiMiUbOoAlDovgtc2CRKsqe3RRC3W7XoO62tfQkxryOEKO0cIo7n8upHTr4mIiIioV8hp4DEUCmH8+PF49NFH272/uroaJ5xwAkaNGoWFCxfiyy+/xC233AK73d7DKyUiIiIzkyQFbuthKHNdDqdlXNp9TZFVWFXzKGqaFsIwEjlaYecZRgyxRB003fyTuomIiIiIOiIJIUSuFwEkG8bPmTMHZ599dmrbD37wA1gsFjz//PMH/Lx+vx8+nw9NTU3wer37fwARERHtU7aPq8FIALv927OwsnRxfSeaoguQMHakbbcqPvQrnAafYzQkScr662abLFlgVX2QJGX/OxMRERERmYxpezwahoE333wTI0aMwLRp01BWVoZjjjmm3XLs1mKxGPx+f9qNiIiIDky+HletSjlKnBeg0DkdquxObY/rTdiw+19Yt+s5ROK7crjCzjFEAjGtHroRy/VSiIiIiIgyZtrA465duxAMBnH33Xdj+vTpmD9/Ps455xyce+65WLRo0T4fd9ddd8Hn86VuAwYM6MFVExER9S75fFyVJAkOZRT6F/wYZZ6JkFp97QnGNuC7HY9ha8NcaEYkh6vcv2Tvx0Yk9GCul0JERERElBHTllpv374d/fr1w4UXXogXX3wxtd9ZZ50Fl8uFf/zjH+0+TywWQyy2JyvA7/djwIABLLUmIiI6AN19XO2uUuu9FbhdEGjC1oZ5CETXpd2nyk70LZiKItcESJJpr8kCSJZeW1QfZJZeExEREVEeUHO9gH0pKSmBqqoYM2ZM2vbRo0dj8eLF+3yczWaDzWbrtnUJocMQGmTJmhe9oYiIiLqiu4+rPcUfjqDIU4TK0ovhj6zG1sa3EW+edK0ZYWyufx27g0vRv3AGXDbzZnUaIoFYog4WxQ1VceZ6OUREREREHTLtZX2r1YqjjjoKq1evTtu+Zs0aDBo0KEerAgyhI641IpqoRUxrgKaHYAg9Z+shIiKi/TMMA8FIFJIkwecchdF9foE+vimQJUtqn3B8O9bsfAqb6uYgoQdyuNr9EUjoAcS0Bgh+ByEiIiIiE8tpxmMwGMS6dXvKnTZs2IAVK1agqKgIAwcOxPXXX48LLrgAJ510EqqqqjBv3jz897//xcKFC3O36BQBw4jDQBzQg5AlCxTZBkW2c/IkERGRCUXjcditFtgsFsiSBRW+k1DkGo9tje+gMfx1ar/60Eo0hlehwjcZpZ6jIUvmLBAxjDiiRh0sqgeq7Mj1coiIiIiI2shpj8eFCxeiqqqqzfbLLrsMs2fPBgA8/fTTuOuuu7B161aMHDkSt99+O2bOnNnp1/D7/fD5fFnrRaUb8VRp1r7IkgWybIUsWaHI1i6/JhERkVlk+7jaUz0eW8iyjGKPB7Kc3i4lGN2ILQ1zEU3sTNtuU0vQv3A6vI5hPbbGA6HINlgUr+l7VBIRERHRwcU0w2W6Sy4Cj+kkKLIVsmSDIluZDUlERHkt3wOPAGC3WeFztu2PKISO3cFlqGl6H7oRTbvP5xiJfoXTYFOLemqZGZMkGRbFA0W253opREREREQATDxcpvcQ0I0YdMSQ0AFJUlOBSFmycEANERFRD4vG4rBbrLBZ0r8GSZKCUs/RKHSOQ03T+9gdXJq6rymyGv7IOpR5j0e59wRTVjQIYSCuNUFVElBlN79jEBEREVHOsR6nhwmhQdPDiGsNiCZqEdeaoBtR9PLEUyIiIlPxR8L7PPaqihMDis7AyIqr4LINTG0X0LHT/wFW1TyChtDXpj12t3zP4OAZIiIiIso1Bh5zSkA3oohrTa2CkDHTnsgQERH1FoZuIBiNdriP09oHw8uuwKDi78GieFLbE7ofG+texrpdsxGJ7+jupR4QQyQQ0+rblIwTEREREfUkBh5NoyUI2YhoohYxrRGaHmG2AhERUTcJR2NIaB0fZyVJQpHrEIzuczXKvSdAwp5ezcHYJny34wlsqX8Tmh7u7uVmrKX0OqY1wuD3CSIiIiLKAfZ4NCUBw4jBYF9IIiKibuWPhFHk3n8/REW2oW/BVBS7DsPWxrfhj6xpvkdgd/BzNIS/Rl/fySh2H266ydKGEUPMiENVnFBlF79HEBEREVGPMdc3Y2pX276QjdCMCIQwcr00IiKivKZpOsKxWKf3t1mKUVl6EYaWXgybWpzarhsRbGl4A6t3/D8Eo5u6Y6ldJKDpIcS0OpZfExEREVGPYcZj3mmekm3EkIAEWbZAlqxQJCtk2ZLrxREREeWdYDQGm8UCVVH2v3Mzn2M4PPYhqA18ih1NH8AQcQBAJLEDa3c9g0LnIehbcAqsqre7ln1AhNAR15ogyxFYFDdkid8diIiIiKj7MPCY1wQMIw4DcWgAJEmGLCUDkcmAJE8miIiI9ksI+MMRFHncGT1MllSUe09AkfNQbGt8Fw3hL1P3NYS/QlPkO5R7T0KZ9zjIkrm+chlGHDGjvrn8ev+l5kREREREB4Kl1r2IEEYyE1IPIJaoT03K5pAaIiKijiU0DeFo50uuW7OoXgwuORfDy38Eh6VParshEqhpeg/f1fwNTamekOai6WHEtHoYIpHrpRARERFRL8TAYwbCse0IRjfmTW/FZCAyioTuRzSxG9FEHRJ6EIbBkwsiIqK9BaJRaPqBX6hz2wZiZMVPMaDoTKiyM7U9ptVjfe2LqN71AqKJ3dlYalYJoSGWaEBCD+V6KURERETUy5ir7sfktje9h13+j6HIdnjsQ+G1D4PHXgmr6sv10jolOaRGg4ZQc1m2FYpsgyxZTTeBk4iIqMcJgcZQCEVuD2T5wEqPJUlGifsIFDjHoKZxAXYHPwcgAAD+6FoEaqpR6j0OFd6ToMi2LC6+qwQ0PQjDiMGi+iBLne93SURERES0Lww8dpIQAo3hVQAA3YiiMfwtGsPfAgDsllJ47JXw2ofBbRuUF0NehDCgi2jzZMvkkBpFskGWbTzZICKig5auG2gKh1HodnXpeVTZgQFFp6HEfQS2NsxFMLYRACBgYJf/IzSEvkTfglNQ6DzEVP0VDZFALFEHi+KBqjhyvRwiIiIiynOSEELkehHdye/3w+fzoampCV7vgU+W1PQwvqt5HIFoNQT2XWotSSrctkHw2ivhsQ+D3VJqqhOKzpAkZa9syPxaPxERdZ9sHVdbhKMR1PprIEzWY9Bhs8HrzE7gTQiBxsi32NbwNhK6P+0+l20A+heeBqe1zz4enTuKbINF8bIqgoiIiIgOGAOPGYppftQHv0AgWg1/dB3iWkOH+1sUTyob0mMfClVxdri/+bRkQ1qbsyGZJEtEdDDL9nE1EoujPhCAEAnoIgIh4llYZXZ4nQ44bNkrhzaMOHb6F2On/yMIpPeSLHYfgb6+KVCVrmVaZpskybAoHiiyPddLISIiIqI8xMBjhnQjnhZsjCXq4Y+uQyBajUB0A4z9nDA5rf2asyEr4bL1h5RnZc17siGt7A1JRHQQ6q7AYwshNBgiCkNEu/zcXSZJKHC5YLNk96JbTGvAtoa30RT5Lm27ItnRp6AKJe4jTff9QJHtsCgeHveJiIiIKCMMPGZo78Bja0LoCMW2wN+cDRmJ13T4XLJkg8c+JJkN6aiETS3s8vp6lgRZUpMl2cyGJCI6KHR34LGFEEZzADKCluEsuSBJEoo8bqhK9gOB/sg6bG2Yh5iWPunabilD/8IZ8NiHZP01uyKZ/eiDIltzvRQiIiIiyhMMPGaoo8Dj3hJ6qDkTshr+SDU0I9jh/ja1CB77MHgdlXDbBpts2uX+SS1BSMkKWbKwNyQRUS/UU4HHFkIICBGFLiJABz2Wu5Msyyj0uKDK2Q8+CqGjNvAZapoWtqmaKHCORb+CU2FVfVl/3a5QZAcsipvZj0RERES0Xww8ZiiTwGNrQghEEjsRiK6DP1KNUGxzm/5OrUmQ4bINhNcxDB57JRyW8jz7gi9Blq1QmofUmK1kjIiIDkxPBx5bCCEgEINuhJGLAKSsyChyu6HI3XMsTugBbG98D/WhFWnbJUlFhfdElHknQpYs3fLaByKZ/ejNu4ukRERERNSzGHjM0IEGHtt7nmBsIwKRZFl2TKvrcH9VdiWH1DiSQ2osirvLa+hJrbMhWaJFRJS/chV4bK2lBFuIfV/A6w4WVUWh29WtGf2h2FZsbXgL4fj2tO1WpQD9CqfD5xhpqooC9n4kIiIioo4w8JihbAUe9xbXGuFvzoYMRtdDF7EO93dY+sDraBlSMyCv+itKktwcgLRxQA0RUZ4xQ+CxhSHiMEQYQmhdXkdn2a1W+FzObn0NIQzUh1Zge+O70Ixw2n0eeyX6F06H3VLarWvIBCdfExEREdG+MPCYoe4KPLYmhI5QfFsqGzKZ9bDv/0yyZIXbPjg5pMZeCZtaZKpsiP2RJQtk2dYciMyfACoR0cHITIHHFoZINGdAxve/cxZ4nQ44bN1fYqwZEexoWoTawGdI/x4go8xzDCp8k0wV7JNlG6yKh+1ViIiIiCiFgccM9UTgcW+aHkYguh7+5kE1Cd3f4f5WpSDVG9JjH2Kqk5L9kSQlVY7NbEgiIvMxY+CxhRAadBGB2E/VQJdJEorcbljUngmwRRK7sLV+LoKxDWnbVdmFvgWnoMh1qImOlxIsqgeq7Mj1QoiIiIjIBBh4zFAuAo+tCSEQ1WpT2ZDB2Kb9lJjJcNn6w2sfBq+9Eg5rHxOdnOyfJKmQJQsDkUREJmHmwGOLZAAy3K0ZkIoio9jj6bEKAyEEmiLfYVvD24jrjWn3Oa390L/wNLhs/XpkLZ3B7EciIiIiAhh4zFiuA497M4wEgrFNqWzIaGJXh/urshMe+9DkoBp7JSxq19+TntQSiEyWZ6ummvBJRHQwyIfAY4tkCXao23pAOu12eBw9W1VgGAnsDHyEnf7FbX6vYtdh6FNwsmkG0EmSDFVxM/uRiIiI6CDGwGOGzBZ43Ftc8yMQTWZDBqLroRuRDve3W8pSvSHd9oF5GMiTIEsqZDkZjJQkC2RmVxARdZt8Cjy26LYhNJKEYo8bqtLzx5241ohtDfPRGPk2bbsi2VDhm4xSz9GmyTZk9iMRERHRwYuBxwyZPfDYmhAGwvEaBKLr4I9WIxTbgo6G1EiSCrdtMLz2Sngdw2BTS/JqSE0LSZKbA5AtN5Ul2kREWZKPgccWhog1ByD1rD2nqioocrtzdrwMRNdja8NcRBO1advtllL0L5wBj31oTtbVFns/EhERER2MGHjMUD4FHvemG9E9Q2oi1W16RO3NoniT2ZCOSnjsQ/P6ZGFPMHJPqTaDkUREmcvnwGOLZAZkBEIksvJ8TrsNHkfujpFC6KgNfo4djQug7zVYx+cYjX6Fp8KmFuZodemS2Y9eHoOJiIiIDhIMPGbIEBriWlO39YvqKUIIxLS6ZFl2pBrB2AYYHZ6ASXBa+6WyIZ3WvnlfMpXqFylbIEtWlmgTEXVCbwg8thBCgyEiMLIwBdvncsFuzW27koQeQk3je6gLLU/bLkkqyj3Ho9x7PGTZmqPVtV6PDIvihSLbcr0UIiIiIupmDDweICF06CIOw4jDEHEIYWTtuXPBEBpCsS3J3pCRakQSOzrcX5Hs8NiHwONITsu2qgU9s9Bu1DYrUs374CoRUbb1psBjCyH05gBk9ICfQ5IkFOWo3+PewrFt2NowF6H41rTtFsWHfoWnosAxxhStVBTZAYviZvYjERERUS/GwGOWJE9aEtCNOAyRyPuMyIQeSJZlR9YhEK2GZoQ73N+mlsDrqITHPgwe2yBTZFRkgyTJzdmQKmTJCklSTXGyRkSUK70x8NhCCAOGiDYHIDO/oCgrMorcbihy7gNpQhhoCH+FbQ3vQDOCafe5bUPQv3AGHNayHK1uD06+JiIiIurdGHjsJnsyIhN5H4gUwkAksQP+SDUC0WqEYpshOjghk6DAbR8Ej70SXvsw2C1lvShYJ0GSlFQ2JPtFEtHBpjcHHlsIISAQgyGiGR+/cz1sZm+6EcOOpkWoDXy617FbQqnnaFT4Jpsi6CdLFqiKG0ovuXBJREREREkMPPaQZBaF1lyWrcMQWvNUzfx7+3UjhmB0Y3JITXQdYlp9h/tbFE9zELJ5SI3i6qGV9hxJUqHI1uYgpApZUnO9JCKibpHN42o4GsMf//EfzDjqMAypyH32XXuESEAXEQgR7/RjnHY7PA57N64qc9HEbmxtmIdAdF3adlV2om/BVBS5JpjiIpoi22FRPKZYCxERERF1HQOPOdZSom2IRHN2pIZ8C0bGtPrmbMh1CEQ3wNjPyZnT2jeVDemy9e+lfRSl5qzIlgE2KiSwTJuI8l+2jqvxhIZbn38JX27YBJtFxc/PmIYxA/tncaXZlVEAUpJQbJJ+j60JIeCPrMHWxnmIaw1p9zmtfdG/cAZctgE5Wt0eyeEzHiiyuYK3RERERJQ5Bh5NRgjRHIiMp4KR+RSIFEJvHlKTLMsOx7d3uL8sWZNDauzD4HVUwqYW9dBKcyEZjJSbMyNZok1E+Shbx9WvN27G72a/CE1Plv8qsowfT5+CI4dXZmup3SIZgAzttwTbbCXXrRkigV3+T7HT/wEMkUi7r8g1Hn0LpsKieHK0uj2Y/UhERESU/zIOPEYiEQgh4HQ6AQCbNm3CnDlzMGbMGJx66qndssiuyLfAY3v2ZEMm8m6CdkIPIRBdj0B0HfzRamh6sMP9bWpRKhvSbR8MRbb10EpzY09GpKV5iI25smOIiPaWzePq8nXr8YcXX0YskQziSQAunnIiTjpkTBZW2r0MEYVuhNDRxUGrqqLA7TJl8BEA4loTtje+g4bw12nbZcmKCt9klHqOznnrEEmSocpuqEru+1ASERERUeYyDjyeeuqpOPfcc/Gzn/0MjY2NGDVqFCwWC3bv3o37778fP//5z7trrQekNwQe95avE7SFEIgmdsEfTU7KDkY3QUDf5/4SZLhsA5OBSMcwOCzlvT7rQZJkSJIlNUU7Wa7du39nIsov2T6urqzeiD/84z8Ix2KpbedMPBrTj5xg2oBdi2T/5ggMEdnnPlaLBQUup6l/l2B0I7Y0zEU0sTNtu00tRv/CGfA6huVoZXvIshUWxcsLdERERER5JuPAY0lJCRYtWoSxY8fiySefxMMPP4wvvvgC//nPf/C///u/WLVqVXet9YD0xsDj3pInPom0XpH5UJ5tGHEEYpsQiFYjEFmHqLa7w/1V2QWPfSi8jmHw2CthUdw9tNLcahlWkwpGypZcL4mIDmLdMdX6642b8MCcN9EYCqe2Tz3sEJx34nGQTRywa7EnABlFe8dfq6rC53JBls37uwihY3dwGWqaFkA30gOpPsdI9CuYBpsl1+1QJKiKC6ps7kAuEREREe2RceDR6XTiu+++w8CBA3H++edj7NixuPXWW7FlyxaMHDkS4XB4/0/Sgw6GwOPehBAQzRO0dZGAYcSRD4HIuNaY7A0ZqUYguh66iHa4v8NSnuoN6bINzHk5WM+RUhO0ZckKSeLQGiLqOd0ReKwPBLDbH8ADc97Ersam1H3HjR6BS04+yXRDWvalowCkqioocLmgyObOYtf0MGqa3sfu4DK0/h0kKCjzTkS590QosjV3CwQgSUrz8Jne3Y6FiIiIqDfIOPB46KGH4ic/+QnOOeccjBs3DvPmzcNxxx2HZcuW4fTTT8eOHTu6a60H5GAMPO4tbWBNc3m22QmhIxzfDn8k2RsyHN+GjoKnsmSB2zY4lQ1pU4sPomBcy9AaS6uhNflxkk5E+ae7Ao8A4A9H8OCrb2FL7Z4M+EOHDMKVp02FVc2fi0vJAGS0uQR7z7HLarGg0O3K3cIyEI7XYGvDXIRim9O2WxQv+hWcggLnuJwfZ2XZBoviYfk1ERERkYllHHh8+eWXcdFFF0HXdZx88smYP38+AOCuu+7CBx98gLlz53bLQg8UA49tCWFAFzEYRgx6nmRDakYkOaQmUg1/dB0Sur/D/a1KATyO5JAaj30IFNneQys1B0mSmwOQLcFI9ookouzozsBjy8+P/nce1myrSW0b3q8PfnnmNDht+ZXhlqxAiEIXEQDJwXBepwOOPPk9hBBoCH+N7Y3zkdADafe5bYPQr3AGnNaKHK2uhQRVcTaXX/M4R0RERGQ2GQceAWDHjh2oqanB+PHjITeXDC1ZsgRerxejRo3q9PN88MEH+Mtf/oJly5ahpqYGc+bMwdlnn93uvj/72c/wxBNP4K9//StmzZrV6ddg4LFje7Ihk0HIfBhUI4RATNsNf6Qageg6BGIb97NuCS7bAHjtlfDYK+G09j0oT05SE7QlC2Q5+e9ERJnq7sAjACQ0Df837z2sqN6Y2jagtBjXzDwNXpezy6/Z09ICkJJAscedN+XjAKAbMez0f4hd/k/2GgonocR9JPr4qqAquf3vIkkyVMUNVeb0ayIiIiIzOaC6pYqKClRUpF/hPvroozN+nlAohPHjx+NHP/oRzj333H3uN2fOHHz66afo27dvxq9BHZMkCYpkhQIrLApgCD2ZCdlclm3GbEhJkmC3lMJuKUWZ91gYIoFgbHMqGzKa2LXXIwRCsc0IxTajpmkBFNmRHFJjr4THPgxW9eAISAuhQRcadESQPG+UWpVnq839Ig++gCwRmY9FVXHVaafg+fc+wMffrgYAbKmtw5///RpmnXM6Snz59XdbkiRIkgOSsEMgBn84hiJP/gRQFdmGvgVTUew6DFsb34Y/sqb5HoHdwc/REP4afX1TUOw+ImfHESEMJDQ/dCkCi+rhxTUiIiIik+hUxmNHQcG9vfLKKwe2EElqN+Nx27ZtOOaYY/D222/j9NNPx6xZs5jx2EPysTckACQ0P/zR6uSgmmh1m+mce7NbSpNDauyVcNsGHdRToyVJaVWa3dIv8mDplUlEndETGY8thBD4z+JPMX/5l6ltPpcTs84+Hf1Kcj1h+cAJIeB2KLDbjLyoNNhbU2QttjXMQ0yrS9vusFSgf+EMuO2DcrSyPRTZAYvi5gU1IiIiohzrVMajz+dL/bsQAnPmzIHP58ORRx4JAFi2bBkaGxszClB2hmEYuOSSS3D99ddj7NixWX1u2r/W2ZBQWprlx6E3ByHNerJkUb0odh+GYvdhEMJAOF6DQDSZDRmKbcHeWZzRRC2iiVrUBj6BJKlw2wYle0M6KmFXSw+qwJsQOnShtyqkk5qDkGpadiQRUU+QJAnnnXgc3A4HXvnoMwBAUyiMv7z8Gn511gxU9s11f8EDI0kSQjEBl90HWdGg6eG8ubgHAD7HcHjsQ1Ab+BQ7mj6AIeIAgEhiB9buegaFzkPQt+CUnFYU6EYEhohBlV1QZMdBdSwnIiIiMpNORRCeeeaZ1L/feOONOP/88/H4449Dae5PpOs6fvGLX2Q9o/Cee+6Bqqr49a9/3enHxGIxxGKx1M9+f8dDSDKVSOhQFBmyfPB9gZUkGYpkTw1qSQYiE6lgpBkDkZIkw2XrB5etHyp8J0E3oghENyQDkZF1iOuNafsLoSHQnCmJxuT0zpbekB770Jz3sOp5yaxXiESrzFEGI4kOJt19XO2M6UdOgMtuw9/f/xBCCIRjcdw/50387PRTcMjggT2+nqwQAg3BEEp9XtgsduhGHJoRhmHE9v9YE5AlFeXeE1DkPBTbGt9FQ3hPVmpD+Cs0Rb5DufcklHmPy9kxQggDCT0AzYjAorgOukFzRERERGaQ8XCZ0tJSLF68GCNHjkzbvnr1akycOBF1dXX7eOR+FrJXqfWyZctw+umnY/ny5anejoMHD95vqfVtt92G22+/vc32rJWERTVEYxoKffzyurd8yYhsIYRAXKtvLsteh2B0w34yTiQ4rX1T2ZAuaz9IUv4MB+hOkiSnD6+RLCxvI+oluv242kGp9d6Wr1uPJ+e9B01PToiWZRlXnDIZx4wa3uV15IrH6YDXueeiliESSGiBvMqABIBgbDO21s9FJFGTtt2mFqFf4XT4HCNytLI9ZMkCVXFDka25XgoRERHRQSPjwGNhYSFmz56NmTNnpm1/7bXXcPnll6OhoeHAFrJX4PGBBx7Addddl5qaDSQzK2VZxoABA7Bx48Z2n6e9zIwBAwZkNfBYuzuEvn08UBUGVjrSkhGpGzEYIgYhjFwvqUOG0BCKbUllQ0YSOzrcX5FscNuHwuuohNc+DFa1oGcWmieSgUi1OQipsl8kUZ7q9uNqBoFHAPhuyzY8+t+3EUskA3MSgAsmH48p48d1eS05IUko83lhUdOzAjU9As0Imv7Y2ZoQBupCX6Cm8T1oRjjtPq99OPoVToPdUpKj1e2RDEA6mQFJRERE1AMyrn254oor8OMf/xjV1dWpSdafffYZ7r77blxxxRVZW9gll1yCqVOnpm2bNm0aLrnkkg5fx2azwWazZW0d7REAmvwxFBc6uvV18l2yNNsGRbY1D6qJmzoIKUsqPPYh8NiHoG/BVCT0YHMQMll6rRmhtP11EUNTZBWaIqsAADa1OFmW7RgGt23wQZ9RsWeKdjS1LS0rUlY5dZQoD/TEcTUTowb0w2++dyYeeu0tBCNRCAD/XPgRQpEozjjmiPy7wNGq5Lr12lXFAUW2IaEHoRtR7N2f2IwkSUaJ+wgUOMdgR+MC1AY/R8u6/dG1CNRUo9R7HCq8J0GRc/eZMkQCca0JkhRiCTYRERFRN8s48HjvvfeioqIC9913H2pqkuU0ffr0wfXXX4/f/OY3GT1XMBjEunXrUj9v2LABK1asQFFREQYOHIji4uK0/S0WCyoqKtqUeedCMBSH122FxcJS285IDqqxpU40DCMBXcSgGzHTlmRbFDeKXONR5BoPIQxEEjtT2ZCh2GYIpAdPY1odaoN1qA0ugQQFLttAeB2V8NiHwWEpz7+T4W6wJxgZQXKCTbJfZEuvyOQkbf4/RUQdG1xeihu+PxN/feVNNASDAID/frYMwWgUF0w6HnKe/b1NaBr84Qh8rvQ+wpIkw6p6YQgnND0IPU/6P6qyA/2LTkOx+whsbZiLYGwjAEDAwC7/R2gIfYm+Baeg0HlITo+NQmiIa02Q5Sgsipv9iomIiIi6QUal1pqm4cUXX8S0adNQXl6eajB/oKVWCxcuRFVVVZvtl112GWbPnt1me2d6PO7N7/fD5/NltdR61+5k5pvTrqK0xNXl5zzYGUKHYcSgizgMI458yOrQjRiCsU0IRNbBH61GTOu4t6kqu5uDkMmbReHnZl8kSW4VhLQ0D7JhWwMis8j6cTXDUuvW6gNBPPjqm6ipb0xtO3rEMFx+6mSoSv5dxCj1+WC17Dv4pRtxaHowr/o/CiHQGPkW2xreRkJPH0zksg1A/8LT4LT2ydHqWpOgKk6ososXComIiIiyKOMej06nE6tWrcKgQYO6a01Z1Z2BRwAoL3XBbuMV8mxJL8mOQwg910vqlJjWgEAkOaQmEN0AQ3ScleKw9oHXPgxeeyVctgEcUrMfe/pFqpAlKyRJ5YkhUY6YKfAIAIFIBA+/Nhcbd9amto0dNAA/O/0U2Cz51c5BVRSUFfj2+/dNN6JI6MG8OUYCgGHEsdO/GDv9H0Egfd3F7iPQ1zcFqgkuykmSDFV2Q1XYToeIiIgoGzIOPE6ePBmzZs1KDYExu+4OPFosMvqWe7r8vNQ+Q2gwjHheZUMKoSMU35bKhgzHt3W4vyxZm3tLJofU2CxFPbTSfCY1Z0LuKdNmiRxRzzBb4BEAovE4HntjPlZt2fP3dmifcvzqrOlw2fOrf5/bYYfPtf8AnBACuhFGQg8hH46NLWJaA7Y1vI2myHdp2xXJjj4FVShxH2mKi3GSpLL/IxEREVEWZBx4/Ne//oWbb74Z1157LY444gi49vpyfOihh2Z1gV3V3YFHACgqsMPjNk/j/d4qHwbUtEfTwwhE18MfrUYgug4JveMTbKtamBxSYx8Gj31IThvw5xcpLQiZLNfO/ckrUW9jxsAjACQ0HU+9/T6Wr1uf2ta3uAizzj4NBe7cZ9JlosTn7XS2phAGNCMC3QjnzXERAPyRddjaMA8xbXfadrulDP0LZ8BjH5KjlaVLTsB2H/QD44iIiIgOVMaBR1lu22tNkiQIISBJEnTdXGU/PRF4lGUJ/So8kGWWfvakPQNqInlzsiWEQDRRi0A0mQ0ZjG5sU3KWTobbNiCZDekYBoelgv0OM8B+kUTZZ9bAIwAYhoEXFyzGB1+vSm0r9now6+zTUV7oy8pr9ARFUVDq80Jp5zvXvrRkQGp5FIAUQkdt4DPUNC2EIeJp9xU4x6Jfwamwqub47ybLVlhkN2Q5v8r3iYiIiHIt48Djpk2bOrzfbL0feyLwCABejw2FPpbj5IpuxKEbkeaJn/lTcmYYCQRjm5p7Q1YjmqjtcH9VdqYG1HgdlbAoLPPPlCTJkKCk+kYm/6kwO5Kok8wceASSAbjXPvkcb33+RWqbx+HArHNOw4DSkqy9TnezWSwo8WX+/iYDkBFoRihvApAJPYDtje+hPrQibbskqajwnogy70TIkjkCfopsh6q42N6DiIiIqJMyDjzmm54KPEqShH4VbigKs6lySQgBITQYItF8i+fNiRcAxLUmBKItQ2rWQzeiHe7vsJSnsiFdtoE8EeqSZN9IWbY0ByPZN5KoPWYPPLZ494sv8a8PPkn9bLdacfVZ0zCiX9+sv1Z36Wy/x/bkYwZkKLYVWxveQji+PW27VSlAv8Lp8DlGmmawmCLbYVHcvGhFREREtB8HFHisrq7GAw88gFWrkqVMY8aMwTXXXIPKysqsL7CreirwCABetxWFBZyCaDaGSEA34jCMGAyRyPVyOk0IA+H49mQQMlKNUHwrOsrmlCUL3LbB8Diah9SoxaY5QctfEiRJSU3UTpZsMzuSDm75EngEgE9WrcGz7yyE0fxVx6IouPK0qRg/dHC3vF53KPZ6YLceeH/BfAtACmGgPrQC2xvfhWaE0+7z2CvRv3A67JbSHK1ub1KrACQvPBMRERG1J+PA49tvv42zzjoLEyZMwPHHHw8A+Oijj7By5Ur897//xSmnnNItCz1QPRl4lAD06+Nh1qOJCWGkhtPoeTIlu4VmRBCMbkgOqYmsQ1xv6nB/q+JLZUO67UOgygyKZ4+0V5l2S2CSAUnq/fIp8AgAK9dvxP97610kmntQy5KES6dOwsQxI7vtNbNJlmWUFfgy6vfYnmQAMtpcgm2uftzt0YwIdjQtQm3gM6Qfq2WUeY5BhW+SiSZOS1AVJ1TZyQAkERER0V4yDjwedthhmDZtGu6+++607TfddBPmz5+P5cuXZ3WBXdWTgUeAvR7zSXJKdjIAmU9TsoHk2mNaXSobMhjbuJ9sTgkuaz94HMPgtQ+D09qXJ0fdQkoFIFsCky3BSaLeIt8CjwCwZtt2PPL624jG9www+f6Jx+GUww/t1tfNFrvVimJv9nr66kYUCT0EIbSsPWd3iSR2YWv9XARjG9K2q7ILfQumosg13kTHMwmq4oIqO0y0JiIiIqLcyjjwaLfb8dVXX2H48OFp29esWYNDDz0U0WjHPel6Wk8HHiVJQv8+nHCdj5IByDh0I5YXJ2OtGUJDKLYZ/khyWnY0sbPD/RXZAY99KLzNg2rMMjW099oTkNx7qA1RvsnHwCMAbKndjQdffQv+cCS1bcaRE3D2xKPzoi2F1+mEx5ndzHXdiELTw6ZvQyKEQFPkO2xrmNcm299p7Yf+hafBZeuXo9W1JUkyVNkFRXbkxWeLiIiIqDtlPDmhtLQUK1asaBN4XLFiBcrKyrK2sHwlhIA/GEOBl1mP+UaRrVBghUVxwxA6DCMGXcRgGAmYvSRbllR47EPhsQ9FPyQnhPoj1QhEk7e9+2TpRgSN4W/QGP4GAGC3lCbLsu2VcNsGQ5bNMT209xDJE/s2J/dSWnZk67JtIsquAaUluOH7M/HXOW+izp8MdM5dugLBaAwXV50AuYulzN3NHw7Doipd6ve4N0W2Q5Ht0I0YND1k2gCkJEkocI6G1z4MOwMfYad/ceoCYTi+DWt2/h+KXIehb8HJsCjuHK822dYloQegGeFUBiQRERHRwSrjs9uf/vSnuPLKK7F+/XpMnDgRQLLH4z333IPrrrsu6wvMR/5AHB6Xlb0e85gsKZAVJ1Q4IYTRPKAmljcl2RbFg2L3BBS7J0AIA5HEDvgj6xCIViMY2wIg/XeIJmoRTdSiNvApJChw2wfBYx8Gr70SdksZMza6TXIKu94mw5YBSaLuUFbgw43fn4kHXn0L2+vqAQAffr0KoWgMP542BRbV3FnI9YEgSn1eWNTs/i1QZBsU2QbdiCGhB02b9S/LFvTxTUaxawK2NcxHY+Tb1H31oS/QFP4WFb7JKPUcbYqeu0LoSGh+aFIYFsUDRc5e0JiIiIgoX2Rcai2EwAMPPID77rsP27dvBwD07dsX119/PX7961+bLkDR06XWLTjhuvcyjAR0EYVuRPMiCLk33YilhtT4o+sQ1xo63N+ieJqzIYfBYx8KVXH20Eqprb0DkhxqQz0vX0utWwtFY3jk9bmortnTlmL0gH74+RmnZjWjsDvIsowyn6/bLm4KIaAZIWh6GGbP9g9EN2Brw1uIJmrTttstpehfOAMe+9Acrax9spysqpAlVhUQERHRwaPTgccFCxbg+OOPh7XVF/JA84mCx5O9hufZlqvAowSgT7kbFgsDAr1ZMggZg2HETVuitj+xRH1ySE20GoHoBhgi3uH+TmvfVDaky9afQS8TkCQZkmRJBSJlycL/LtRtsn1cbQyGEQiHe7w3ciyRwBNvvoOvN21JbRtcXoZfzZwOj8PcFw5VRUGJz9vlSdcdMUQCcc1v2uzHFkLo2B1ciprGBdBFep9xn2M0+hWeCptamKPVtU+RHbAobg6gISIiooNCpwOPsizDbrfj2GOPRVVVFaZMmYJjjjkGapbLfbItV4FHALBaFfQpy32vIeoZQhjQRSxZkm3EYfZMkfYIoSMU25LKhozEazrcX5Zs8NiHJLMhHZWmO7k7mDEYSd0l28fVuqYQdtQ1ocBry8LqMqPpOma/sxBLVq9LbasoLMCsc05Hkcfcx2+LqqLE6+3WgG0y+zEM3QibPsM/oYdQ0/ge6kLL07ZLkopyz/Eo9x4P2VSlzhIsiguK7DRdtRARERFRNnU68Lhp0ya8//77WLRoERYuXIjNmzfD6XTi+OOPR1VVFaqqqnDUUUeZrjl7LgOPAFDgtcOXg5Mpyi0hDOip4TT5GYQEkidyLQNq/JFqaEaww/1talEyG9KRHFKjyPzsmwmDkZQN3RF4rN6yG2UlTljUnv8OYQiBlxZ9hAUrv0ltK3S7Meuc09CnyNwXU2wWC4q9nm4PXAlhQDPCeVF+HY5vx9b6txCKb03bblF86Fd4KgocY0wV6EtOwHZDke2mWhcRERFRtmTc47HF+vXrsXDhQixcuBCLFi3C1q1b4fF40NjYmOUldk02T5CEEHj5je8QjiQweeKgTj1GAlBR5obVypP7g1VyOE08GYg0YjD7Sdu+CCEQSexsDkKuQyi2GQL6PveXIMNlGwivYxg89ko4LOUsKzMhBiMpU90VeLTbFBQX5qbEWQiBN5csx+ufLk1tc9ntuGbmDAyuKMvJmjrLbrWiyOPukaBVMgAZgqZHYOZjmRACDeEvsa3hnTYXzNy2wehfOAMOa3mOVtc+SVKgyi6oirnL/ImIiIgydcCBR2BPFuTChQvx6quvIpFIIBwOZ3N9XZatE6Td9WHccd+HWLxkKxx2FQ/ceQrKSlydeixLrqnFnnLsaHMmZP7SjTiCsY0IRJJl2TGtrsP9VdmVHFLjqITHXgmLwv8nzIrBSOpIdwUeAaC40AG7LXeftQUrv8Y/F36UCqnZLBb84oxTMXpg/5ytqTMcNluPloYLoSOhh6AbkR57zQOhGzHsaFqE2sCnEGhdKi6h1H00KgomQ5XNFeiTJJUTsImIiKhXySjwuHnzZixcuBALFizAwoULsXv3bkycOBEnnngiJk2ahGOOOSZt+IwZZOsEqXZ3COf99BUEgslg0aFjynDrb07sdG+lkiIHXE5zvTeUW0Lo0I1osidkng6maS2uNcIfrUYgsg6B6HroItbh/g5LRSob0mUbAFkyd7/Ygx2DkdSiOwOPqiqhvJMX9brLktXr8PT8BTCMZKBKVWT8eNrJOGK4uSYk783rcvb4UBxDaND0YHM2v3lFE7uxtWEeAtF1adtV2Yk+BSej2HWY6TLyFdnePICGf2eJiIgov3U68Dh06FA0NDTg+OOPx0knnYSTTjoJRx555EE1XObNd9fhlnsWpX6+8pLDMGNKZaceqygS+pZ7enxqJ+WHZBCypSdkAmYuYesMIXSE4ttS2ZDh+HZ09DvJkgVu25DmbMhhsKlF7HWVBxiMPDh1Z+ARAHw+G9wOS5eftyu+3rgZj7/5DuJacqKzJEn44ZQTceK40TldV4ckCeUFPqhKz/8/qBtxJPSAqSdgCyHgj6zB1sZ5iGsNafc5rH0woPA0uGwDcrS6fZGgKk6ostN0gVEiIiKizup01DASSZbTyLIMVVVhsVig5ODLbS6ddnIl3lm0Hh98ugUA8OxLX2LCuPJOlVHrukBDUzRn/avI3CRJSZ5cwJkqxzaMGPQ8HUwjSQrctoFw2waiD6qg6WEEouuTGZHRdUjogbT9DZGAP7oG/ugaAIBVKUhlQ3rsQ6DI9lz8GrQfQhgQIgYDe7KdksHIZCBSggpJUpL/zpNm6qRAIAanTc3phbpxgwfi2nNPx8OvzUM4FoMQAs+/9wFC0RimHTHenBdGhEBjMIQSX9eDwZlSZCtkqQi6EYFmhEw5AVuSJPicI+FxDMUu/6fY6f8gVW0Qiddgzc6nUOQaj74FU2FRPDlebQsBrbmkXZVdUGSHOT97RERERB3IqNT6u+++S5VaL1q0CNFoFCeccAImT56MSZMm4Ygjjuj1U6231QRw0S9eTZVcjxlZgjtvmNTpE6SKMhdsVnNniZJ59JbBNK0JIRDValPZkMHYpv1kyUhw2QbAa09mQzqtfRjEykOSJEOCAklSmgOTyX8mt/FEOp90d8YjALicFhR4bV1+7q7aXlePB+a8icbQnv7Vpxx+KM474VjTfm59LhfcjtxdrBHCgG5EoRlhCLHvAWS5FteasK3xHTSGv07bLktWVPgmodRzjOlagEiSClVxQpE4AZuIiIjyR5eGy6xatSrV73H+/PkA0KunWgNAJKphztzVuPdvn6a2/ejC8Tjz1OGderzVqqCi1MUvjJQxIQQMkYAhkpmQZi5py4RhJBCMbUpOy45WI5rY1eH+iuxIDqlpvlnUns/uoWySmrMimwORkgK5OVOSAWZz6onAI5D7QTMtdvsDeOCVN7CryZ/aNnH0CFwydRIUk11sBQBIEsp8XlhM0ApHN6LQ9LCp+xgHoxuxpWEuoomdadttajH6F86A1zEsRyvbt+QEbCczIImIiCgvHHDgcefOnansxwULFmDt2rWw2Wypkmyz6I7A467dIdz32KdYvGQrAMBqkXH/7aegX5/OleZ4PTYU+lg6Sl1jCK25HLt3DKdpEdf8zUHI5iE1+5maareUwWtPlmW77QMhS7ntDUfZsydLslWGZPO/U+70VOBRUYCyYpcpeiP7Q2E8+Npb2FJbl9o2fugg/HTGVFhNEODbm6ooKPX5TPHeAcnp0poeMu2xSggdu4PLUdP0fptjjs8xEv0KpsFmKcrR6vZNkmQoshOq7OCFGiIiIjKtTgced+3ahYULF6aCjWvWrIHFYsHRRx+NqqoqVFVV4bjjjoPNlvvSqNa6K/DoD8Zwze/mo9Gf7G02orIIf/qfKiid/JJfVOiAx8Up15QdhtBh9KIJ2S2EMBCOb09lQ4ZiW9BRubkkqXDbBiezIR3DYFNLmA3SK0mtekfu+WcySMmT7+7WU4FHAHA6VNNcqAvHYnj0v29j7baa1LYR/frgF2dOg9Nk330AwGa1otjjNtXfQN2IQzPCMEw6BVvTw6hpeh+7g8vQ+lgjQUGZdyLKvSdCkc333Y0BSCIiIjKzTgceZVmGxWLBkUcemQo0Tpw4EQ6HuYeldFfgEQA+W74ddz/8ceq+H543Dt87fVSnn6u40AE3g4+UZYbQoDcHIXtLOXYL3YgiEN2QzIaMVCOuN3a4v0XxJntDOobBYx8KVTb33yvqupbhNhJaApIt2ZLMksyWngw8AkBxgR12uzmyCuOahv/31rv4csOm1LYBpcW4ZuZp8LqcOVxZ+xw2G4o8+x+A19MMIwHNCDX3LjafcLwGWxvmIhTbnLbdonjRr+BUFDjHmiqg20KSZKiyG6rCYx0RERGZR6cDj2+//TZOOOEEuFyu7l5TVnVn4BEAHvy/JVj4cfKLqarKuPfWkzGov69TzyUB6FPuhsXCE2LqHoaRgC6i0I2oKaeMdoUQAjGtHoHoOvgj1QjGNuwn21OC09ovlQ3ptPZlMOqgIu3JjEzLklRNGUAws54OPCoKUFrkgqKY47+Tbhh47t1F+GTVmtS2Mp8Xs849AyVes0xD3sPtsMNn0u9uhtCg6UFTBiCFEGgIf43tjfOR0ANp97ltg9CvcAac1oocra5jsmSBRfWabjgOERERHZy6NFwmH3R34DEYiuOa389HfWMUADB0UAHu+f0UqGrnSl2sVgV9ysyXjUC9z54gZMzUk0YPlCE0hGJbUtmQkcSODvdXJDs89iHwOIbBa6+EVS3omYWS6aRN2kbr8m2WLLanpwOPAOCwqygqMEfJNQAYQuA/iz/FO8u/TG0rcDlxzdmno1+J+XoBep1OeJzmzYLTjRgSesCUxybdiGGn/0Ps8n8Cgdbrk1DiPhJ9fFVQFfNluwISVMUJVeZAQyIiIsotBh4ztHfgEQCWfVmDP/z1o9TPF54zBuefNabTz1ngtcPnNV9/KOq9kuXYMRi9rCdkawk9mOwNGalGIFoNzQh1uL9NLYHXUQmPfRg8tkGQTdjHi3oWh9u0LxeBRwAo8NngcphneJQQAvOWrsCcj5ektjltNvxq5nRU9jFfJlyB2wWX3TzB270JIaAZIWh6GB318s2VWKIOWxvfhj+yJm27IjvQ1zcFxe4jTHmxguXXRERElGsMPGaovcAjADz69FK8++FGAICiSPjL/56MIQMLOvWcEoC+fTxQFfN9YaXeTwgduhGHIWLQjTjMeMLXVUIYiCR2wh9Zh0C0GqHYZgjsu/RcggKXbSC8zdmQdks5M0aoFWlP/0jZAlmyHFQljbkKPEoSUFrigsUkJdctPvx6Ff7+/odo+TplVVX8/IxTMXbQgByvrC23wwGfCXtRtiaEAc0IQzcipmwR0hRZi20N8xDT6tK2OywV6F84A277oBytrGOSpMKiuKHIvNBNREREPYuBxwztK/AYjiQw65Z3UFsXBgAMHuDDn//3ZFg6WXLtsKsoKzFnDyY6eAhhQBex5mzI3hmEBJKlc8HYxuZsyHWIafUd7q8q7uSQGvsweO1DoSr8f5X2JrUKQlp69cl9rgKPAGCzKigpMl/m1rK16/HU2+9B05OBMkWWccWpVTh65LAcr6wtsw6c2ZsQArqIQtPDphuUZggNtYFPsaPpAxginnZfofMQ9C04BVa16/9vdAdZskBV3Kaczk1ERES9EwOPGdpX4BEAvvx2J279y4epn887YxQu/t64Tj+312NDoc+8ZVB0cNkThIw2ByF7r5jWgEBkHfzRagSi69ucSO7NYe0Drz2ZDemyDeCQGkojSTLsltJcL6Pb5DLwCJiv5LrFqs1b8bc35iOWSLavkABcOPkETB4/NrcLa4fZez62ZuYS7ITmx7bGd9EQ/jJtuyxZUO49CWXe40ybDS3LVqiyiwFIIiIi6nadCjw+9NBDnX7CX//6111aULb1ZOARAJ54/gvMe78aACDLEu7+XRWGD+18o/myEhccdnN+SaWDV7IcuzkI2Ut7QrYQQkcotjU5pCZajXB8e4f7y5I1OaTGPgxeRyVsqvkGS1DPYuAxM5kGHiUpeaxUTVZyDQAbd+zCg6/NRSgaTW0769gjcfrRh5uuXUOJzwubxXwB3H0xhIaEHjDlhbBgbDO21s9FJFGTtt2mFqFf4XT4HCNytLL9k2UrLLIbspw/nwUiIiLKL50KPA4ZMiTt59raWoTDYRQUFAAAGhsb4XQ6UVZWhvXr13fLQg9UTwceI1EN1/7vO9hZm9ynf18P7rttKqyWzmVEqYqMPuVuyLK5TlCIWiQH00RN238r2zQ9hEB0PfzRavij66DpwQ73t6lF8Ngr4bUPg9s+uFeX3FL7GHjMTKaBR8C8JdcAUFPfgAfmvImG4J7vClPGj8P5kyZCNlHwUZZllPl8UPKsv7RmRKDpQdMdf4QwUBdajprG96EZ4bT7vPbh6Fc4DXZLSY5Wt3+ybINFdjEASURERFmXcan1iy++iL/97W946qmnMHLkSADA6tWr8dOf/hRXXXUVLr744m5Z6IHq6cAjAHyzuha33LMILe/s2TNG4LLzD+30a7icFpQUmbv5OxEA6EYcuhGBbsRgthK47iCEQDSxq7kkex2C0U0Q0Pe5vwQZLtvAZCDSUQmHpcKUU08puxh4zMyBBB4BwOe1wu00Z5lofSCIB+a8iR0NjaltR48chstPmQxVMU9rBqvFglKfOXsRdkQIAwk9CN2I5HopbWhGBDsaF6A2+DlaHxclyCj1HocK70mmviAlyzZYFBdkiQFIIiIiyo6MA4+VlZV4+eWXcdhhh6VtX7ZsGc477zxs2LAhqwvsqlwEHgHg6X+swH/nrwOQLAv7082TMWp45690F3jt8HnN+8WUqLX0oTSxXC+nxxhGHMHYpmQgMrIOUa3j4Ikqu+CxD4XXMQweeyUsivkHPFDmGHjMzIEGHs065bpFIBLBw6/Nxcadtalt4wYPxFWnTTVViXM+TLreF92II6EHTDd8BgAi8Z3Y2jAXwdjGtO2q4ka/glNQ6DzUdOX3rSmyDSoDkERERJQFGQcenU4nFi1ahKOOOipt+5IlSzB58mSEw+F9PDI3chV4jMV1XHfrO9i+I1mW2afMjb/eMRU2W+f7NxYVOuBxmTObg2hfhDCaS7F7fz/IvcW1pmRvyEhySI0uoh3u77BUpLIhXbaBph1CQJlh4DEzBxp4BACrRUZpsXmDZtF4HH97Yz6+27Itta2yTwWuPms6XHbzXFwsdLvhNNF6MqXpEWiGGcuvBRoj32Jbw9tI6P60+1y2AehfeBqc1j45Wl3nKLK9OQDJ4xMREREdmIwDj2eeeSa2bduGJ598EocffjiAZLbjlVdeiX79+uH111/vloUeqFwFHgFgdXUd/uePC2A0v8OnTx2Gn1w8odOvJcsS+lV42O+R8pYh9FQQ0owZKd1JCB3h+PZUNmQovg0dlaPLkgVu2+BUNqRNLTZ1NgztGwOPmelK4BEAfB4r3Ca+SJfQdDz19ntYvm5PRUi/4iJcc85pKHC5criyViQJxR4P7Nb8zW4TwoBmhE05/Vo34tjlX4yd/o/atOcodh+Bvr4pUBWTfBb2gQFIIiIiOlAZBx5ra2tx2WWXYd68ebA0lwppmoZp06Zh9uzZKCsr65aFHqhsnyCFIwnU1nU+q/O5f3+FOW+tTv18540nYdyozr9HbpcVxYXmbKBPlAlDJFKTsYXYd1/E3kozIghGN8AfWQd/tBoJvanD/a1KATyOSnjtlfDYh0KR7T20UuoqBh4z09XAowSgrNScU65bGIaBFxZ8iA+//i61rcTrwaxzTkdZgS+HK9tDkiSU+rywqPkdWBJCR0IPmbL/Y0xrwLaGt9EU+S5tuyLZ0aegCiXuIyFJ5ukB2p5kANIN2eTrJCIiIvPIOPDYYs2aNfjuu+QXp1GjRmHEiBFZXVi2ZPsEqTEQQfWWWtitNtgsFlj20yQ+kdDxm9vfw5ZtyRKbshInHrjjFDgcnc8qYL9H6m0MIwFdtGRCmqs0ricIIRDTdsMfSQ6pCcQ27icjVILL1h9eezIb0mntyyE1JsbAY2a6GngEAKdDRaHP3MF5IQRe/XgJ5i5dkdrmdTpwzdmnY0Bpce4W1oosyyjxemFR8z+oZAgNCT1oyr7D/sg6bG2Yh9hefYHtljL0L5wBj31IjlbWWVKrDMj8/6wQERFR9zrgwGM8HseGDRtQWVkJ1cRXx7sj8Lhm067Uz7IkwW61wG6x7jNLoHpjA264830YzTXXp04eip9fdnhGr1tW7MwoWEmUD4QQMEQMmhGBYcRzvZycMUQCwdhmBCLV8EfXIZrY1eH+iuxIDqmxV8JjHwarmn9TaXszBh4zk43AIwCUFjtgtZg/CDJ/+Uq8/OGnqZ8dViuuPms6hvczR68/RVFQ6vVCUXrHxQ2zDqARQkdt4DPUNC2CIdKDowXOsehXcCqsqjmyYfeNAUgiIiLav4wDj+FwGL/61a/w7LPPAkhmPg4dOhS/+tWv0K9fP9x0003dstAD1d2Bx9ZURYbNYoXDYoGyVybki3O+wb9fX5X6+dbfnIAJ4yo6/bqyLKFvubvXnAgQ7c0QWqt+kAdfKXZrCc0Pf3R9Mhsyuh6a0XF7B7ulFB77MHjtlXDbBkGWeZEilxh4zEy2Ao+qKqGs2JkXvVE//nY1nnt3EYzmr2AWRcGVp03F+KGDc7uwZqqioMTnhSL3nu8cmhGBpodMd3xJ6EFsb3wX9aEVadslSUWF90SUeSfmwWTpZADSorhMXypOREREPS/jb5Q333wzVq5ciYULF8Ju31PWNHXqVLz00ksZPdcHH3yAM888E3379oUkSXj11VdT9yUSCdx444045JBD4HK50LdvX1x66aXYvn17pkvOqo7OZzTdQCgaxe5AAE2hEBLanqvr3z9zNAYP2HPl+pGnlyEU7vzEX8MQaPSbr1yIKFtkSYVFccNuKYFVLYQiOw7acmKL6kWxewIGl5yHcf1+i5HlP0Uf3xS4bAPR3p/taKIWtYFPUF37d3y57R6s2/U8dvk/QSSxCweY1E6UdzRNoDGQH5nTE8eMxM/OOBVq80XKhK7jsTfm45NVa3K8siRN11HnD6QqNXoDVXbAphZDVdxIdgY1B4vixqDiszGi/CdwWvultguhoaZpAVZtfxSN4e9M/rdcQDciiCbqmrNLD74WKkRERLRvGZ/Vv/rqq3jkkUdwwgknpGUVjB07FtXV1Rk9VygUwvjx4/Hoo4+2uS8cDmP58uW45ZZbsHz5crzyyitYvXo1zjrrrEyXnFU2qwqnc/9XnqOJBOqDQdQF/AhFo5AkgV//5KhU8/u6hgie/sfKjF47GIojEGTwkXo/RbbCqnphUxmElCQZTls/VPhOwojyH+HQ/jdgSMkPUOI+Ela1sM3+QmgIRKuxrfFtfFfzN3yz/a/YVPcaGkJfN097Jeq9wuEEgpHOX9TLpQlDB+Oas0+D3ZqcyG0IgWfmL8C7X3yZ45UlJTQNDcFgrpeRVZIkwaK4YLeUQJHNNbjPZeuPEeU/xsCimVDlPROu43ojNuz+J6pr/45oojaHK+wMAU0PI5rYjYQeMnmwlIiIiHpKxmfytbW17U6uDoVCGZc3zZgxA3/4wx9wzjnntLnP5/PhnXfewfnnn4+RI0fi2GOPxSOPPIJly5Zh8+bNmS47qwo8VtisnSsl0XQDwWgUdYEAPAUyZp42PHXf+4s3YunKmoxeu74xioamaEaPIcpXkiSlgpB2SymsaiFUxXlQl3Ipsh0FzlEYUHQGxva9BmP6/Ar9C0+D1zGi3XK8hO5HfegLbKx7GV9t+wtW7/g/1DQuQDC22XQlh0TZ4G+KIZ7Ij4yrkf374vrzzoTHsScI9q8PPsFrn3xuiqBNNB5HIGy+6dBdJUly8uKWpQiybJ7hfZIko9h9GMb0/RVKPceh9df0QLQaq2oew9aGt6EbZv8eKKDpQcS03dD0sCk+y0REPWHy5MmYNWtWh/sMHjwYDzzwQOrnvSs/u8Ps2bNRUFDQra9hxtcm88g48HjkkUfizTffTP3cEmx88skncdxxx2VvZe1oamqCJEkdfnBjsRj8fn/aLdskSUJRgR2qmlmgVTcMTJnUH4MG7OmJ9egzS9HQlNmXen8ghiaWXdNBSJGtsCge2C0lsFmKoCouSJJ5h1v1BJulGKWeo1FZehEO6X8jhpVdjnLvCXBY2htUIRCOb8MO/yKs3fk0vtr6Z6yvfQm7g0sR1xp7eumUJ3riuJpNAsj4uJpLA0pLcMP3Z6LY60lte3PJcry4YDEMI/cBVH84jHCsd37nkCULbGoBrGqhqfooKrId/QunYVSfn8FjH9rqHgO1gU/w7faHURf8wvQlzUIYSOgBxLSWDEhzr5eot9uxYwd+9atfYejQobDZbBgwYADOPPNMvPfee7leWrdZuHAhJElCY2NjrpeyTzU1NZgxY0bWnm/vwCYAXHDBBVizpvvbueTytTvC4GfuZXzG/qc//QkzZszAt99+C03T8OCDD+Lbb7/Fxx9/jEWLFnXHGgEA0WgUN954Iy688MIOm9nfdddduP3227ttHS1kWUJxoRN19WFoeuev5CqKjMsuGoM/3bcEmmagsSmGx59fhisvOxQOqxV2ixVyJ5q5N/mjcLksUDlshg5SsmSBrFhgUdytBtPETDe5tCfJkgqPfTA89sHoWzAVCT2IQHQ9/JF1CESroRmhtP11EUNTZBWaIsnBVza1GF77MHgclXDbBkORrbn4Nchkeuq4mk2aJhCKJOBymCeY1JHyQh9u/P5MPPDqm9he1wAAWPTVtwhGo/jRqVNgUXOb5d0QCAICcNrNkx2YTYpshSIXQTeizQEycxxHHJYyVJZegqbId9jW8DbieiMAQDNC2Fz/GnYHl6J/4Wlw2fp1/EQ5JoQBTQ9C00NQFSdU2XnQtk8hypWNGzfi+OOPR0FBAf7yl7/gkEMOQSKRwNtvv41f/vKX+O6773K9xINWRUXnB84eKIfDAYcjNy1GcvnaZB4ZH/VPOOEErFixApqm4ZBDDsH8+fNRVlaGTz75BEcccUR3rBGJRALnn38+hBB47LHHOtz35ptvRlNTU+q2ZcuWblkTAKiKhOIiZ8aZj30r3Dhz+p4r2EuW7cDnX+xAIBLF7oAfjXsNpmmPAFDfkD8ZHUTdac9gmmLY1KKDuidkaxbFjSLXoRhcci7G9fsNRlZchb4FU+G2DYbUzp//mFaH2uBnWF/7Ir7aeg/W7nwWO/2LEY7vYKncQawnj6vZFAzG8+pzW+B24frzzsLQPuWpbcvWrscj/52HaDz3fSsbgkEEI2Yv8e0aRbbDphbBonhMcwyRJAkFztEY3eeXqPBNTsvyD8e3Yc3O/8OmuteQ0POhH6eApocQ0+qaJ4znz/+fRPnuF7/4BSRJwpIlS/C9730PI0aMwNixY3Hdddfh008/Te23efNmzJw5E263G16vF+effz527tyZuv+2227DhAkT8PTTT2PgwIFwu934xS9+AV3X8ec//xkVFRUoKyvDH//4x7TXlyQJTzzxBM444ww4nU6MHj0an3zyCdatW4fJkyfD5XJh4sSJbWZGvPbaazj88MNht9sxdOhQ3H777dBanSdLkoQnn3wS55xzDpxOJ4YPH47XX38dQDLYWlVVBQAoLCyEJEm4/PLL231/WjLiXn31VQwfPhx2ux3Tpk1L+85z+eWX4+yzz0573KxZszB58uS0bZqm4eqrr4bP50NJSQluueWWDv/e7V1qvXXrVlx44YUoKiqCy+XCkUceic8++wwAUF1djZkzZ6K8vBxutxtHHXUU3n333dRjJ0+ejE2bNuHaa6+FJEmp6tT2Mv4ee+wxVFZWwmq1YuTIkXj++efbrGtf7217OvvaB/oZamxsxE9+8hOUlpbC6/ViypQpWLlyz8yMlStXoqqqCh6PB16vF0cccQSWLl2KhQsX4oorrkhVz0qShNtuuw0A8Pzzz+PII4+Ex+NBRUUFLrroIuzatSv1nC0Zs2+//TYOO+wwOBwOTJkyBbt27cLcuXMxevRoeL1eXHTRRQiH9/TSnzx5Mq6++uqMPge93QF9q6qsrMT//d//YcmSJfj222/x97//HYcccki21wZgT9Bx06ZNeOeddzrMdgQAm80Gr9ebdutOqiKhqNCJTiQppjmlahCGDt4z5frFf69CIBiHEECseTBNYyjYYQAyEtXY75FoL7JsaTWYxgdFtsFME0xzRZJkOK19UO49AcPLL8ch/W/E0NKLUOo+Gja1uM3+AjqCsQ3Y3vguVu94HF9vuw+b6uagPvRlnpzgUrb09HE1WzRdIBQ1R+ZaZ7nsdlx7zukYO2hAatuqzVtx/ytvmCLo1xQKwR/u3UOqJEmCqjibJ2C7YJbjhyxb0Mc3GWP6XI0C55i0++pDX+Db7Q9jl/+TvOjdmyzBZg9Iop5SX1+PefPm4Ze//CVcLleb+1uCQoZhYObMmaivr8eiRYvwzjvvYP369bjgggvS9q+ursbcuXMxb948/OMf/8BTTz2F008/HVu3bsWiRYtwzz334Pe//30qWNbizjvvxKWXXooVK1Zg1KhRuOiii3DVVVfh5ptvxtKlSyGEwNVXX53a/8MPP8Sll16Ka665Bt9++y2eeOIJzJ49u01A6vbbb8f555+PL7/8Eqeddhouvvhi1NfXY8CAAfjPf/4DAFi9ejVqamrw4IMP7vN9CofD+OMf/4jnnnsOH330ERobG/GDH/wgo/caAJ599lmoqoolS5bgwQcfxP33348nn3yyU48NBoOYNGkStm3bhtdffx0rV67EDTfckGq9EgwGcdppp+G9997DF198genTp+PMM89MzcB45ZVX0L9/f9xxxx2oqalBTU378yTmzJmDa665Br/5zW/w9ddf46qrrsIVV1yBBQsWpO23r/e2PZ19beDAPkPf//73UwG/ZcuW4fDDD8fJJ5+cWs/FF1+M/v374/PPP8eyZctw0003wWKxYOLEiXjggQfg9XpT6/rtb38LIBlruvPOO7Fy5Uq8+uqr2LhxY7vB6dtuuw2PPPIIPv74Y2zZsgXnn38+HnjgAbz44ot48803MX/+fDz88MNpj9nf5+C2227D4MGD9/ke9TYZl1pPmTIFkyZNwq233pq2vaGhAd/73vfw/vvvZ21xLUHHtWvXYsGCBSgubntybAYWRUKh1466xs6fFMiyhMsuHIM/3PsZEgkDgWAC/3j5O/z0skNSVwdiCQ2xRBAWVYHDaoPNYoG81wAffyCGeFxHWYkz4+E+RL2ZJElQJDsU2Q4hDOhGFJoRMU0JXa4psg0+xwj4HCMAADGtAYFINfzRdQhEN8AQ6T3dNCOI+tBK1IeSVxYdlj7wOirhsQ+Dy9Yf8kHea5PMKRiMwWVX8+r4aLNY8Mszp+GZ+Qvw+Zpk5sfGnbvwl5dfw6yzT0ehx53T9QXCEQgh4Gvn5LU3kSQZFsUNVXYgoQdNM9DFqhZgSMn5CEQ3YGvDXEQTycwMQ8SwrfFt1AWXoV/RDHjtlTle6f619IDUjDBUxQXVZJPGiXqLdevWQQiBUaNGdbjfe++9h6+++gobNmzAgAHJC2DPPfccxo4di88//xxHHXUUgGSA8umnn4bH48GYMWNQVVWF1atX46233oIsyxg5ciTuueceLFiwAMccc0zq+a+44gqcf/75AIAbb7wRxx13HG655RZMmzYNAHDNNdfgiiuuSO1/++2346abbsJll10GABg6dCjuvPNO3HDDDWmxiMsvvxwXXnghgGRbuIceeghLlizB9OnTUVRUBAAoKyvbb4+/RCKBRx55JLXmZ599FqNHj8aSJUtw9NFHd/wmtzJgwAD89a9/hSRJGDlyJL766iv89a9/xU9/+tP9PvbFF19EbW0tPv/889Tahw0blrp//PjxGD9+fOrnO++8E3PmzMHrr7+Oq6++GkVFRVAUJZXBty/33nsvLr/8cvziF78AgFTm67333pvKEgU6fm/31tnXBjL/DC1evBhLlizBrl27YLPZUr/Dq6++ipdffhlXXnklNm/ejOuvvz71OR8+fM9QX5/PB0mS2qzrRz/6Uerfhw4dioceeghHHXUUgsEg3O4937f+8Ic/4PjjjwcA/PjHP8bNN9+M6upqDB2arGI977zzsGDBAtx4442px+zvc1BSUoLKSvMfq7Ml44zHhQsX4pFHHsHZZ5+NUGhPv7B4PJ5xj8dgMIgVK1ZgxYoVAIANGzZgxYoV2Lx5MxKJBM477zwsXboUL7zwAnRdx44dO7Bjxw7E4/FMl93t7HYVHndm/dDKy1w4+/Q9f0iWr9yFZSt2ttkvoenwh8PY7W9CQzCIUDSalgkZjWnYXc+ya6J9kSQZquJMlmJbiponY5ujjM4sbGohSjxHYmjpD3Bo/xswvPxHqPCeBKe1/d5hkUQNdvoXY92u2c1Dav6B2sASxBLtXwUl2hdZktBdcUFdBwKh3JcpZ0pVFPx4+smYfOjY1Laa+kbc8+/XsKOhMXcLaxaMRHt95mMLSVJgVX2mG0DjsQ/BqIqr0L9wBhTJntoe1XajetfzWF/7EmJaQw5X2HlC6EhofkQTdaYJ8BL1Jp3NKl61ahUGDBiQCjoCwJgxY1BQUIBVq1altg0ePBgez56BaOXl5RgzZkzanILy8vK0klUAOPTQQ9PuB5BWNVleXo5oNJoaYrdy5UrccccdcLvdqdtPf/pT1NTUpJW1tn5el8sFr9fb5rU7Q1XVVHAVAEaNGtXmd++MY489Nu2C53HHHYe1a9dC1/efkb5ixQocdthhqaDj3oLBIH77299i9OjRKCgogNvtxqpVq1IZj521atWqVCCtxfHHH9/md83We7u3TD9DK1euRDAYRHFxcdrnYcOGDany/Ouuuw4/+clPMHXqVNx9991tyvbbs2zZMpx55pkYOHAgPB4PJk2aBABt3s+9P7tOpzMVdNx7rS329zm4+uqre/Vgp70dUIrKu+++i6uuugrHHnss/vvf/x5wiujSpUvTIurXXXcdAOCyyy7DbbfdluohMGHChLTHLViwoE0vBTPwuq3QdQPhSOczqqpOHIAVX+3C2upGAMA/Xl6N4ZWF8HnbNnAXAohrGuLNQUdZkmC1qLBbkgHP2t0hlBQz85GoIy1DaVTZDUPEoBkRGIb5LmbkkiQpcNsGwm0biD6YAk0PJ4fURJNDahJ6IG1/Q8TRFFmNpshqAIBVLYTXnsyG9NiHNJe7E7XPZrGgxONFNJFANB5HohNfzDMRDMbhcFhgUfLr2ChLEi6cfDzcDjve+GwZAKA+EMRf/v0afj3zNAwqL83p+gLhCCRJgucgaRjfMoBG0yPQjKApJjRLkoJSzzEocI5DTdP7qAsuS93XFFkFf3Qtyj3Ho9x7POQ8GBYmhIa41gRJCkKVXVBkO7/TEmXB8OHDIUlS1gbIWCzpF2EkSWp3W0t5cHuPa/l/u71trcuKb7/9dpx77rlt1mC377ng0pnXzgZZltsEcROJ7F7c3N8Qlt/+9rd45513cO+992LYsGFwOBw477zzui0xq7ve20w/Q8FgEH369MHChQvbPFdLJuttt92Giy66CG+++Sbmzp2LW2+9Ff/85z9xzjnntLuGUCiEadOmYdq0aXjhhRdQWlqKzZs3Y9q0aW3ez70/pz31metNDijlp0+fPli0aBEOOeQQHHXUUe1+ADpj8uTJEEK0uc2ePRuDBw9u9z4hhCmDji0KvLaMhs3IsoRLfzAGNmtyYmUonMAL/17VqStThhCIxhNoDIWw29+EnQ0BbNvhh2GwVw7R/kiS1DxIoBA2SwlUxcUsyH1QFScKXeMwqPhsjO17HUZV/Bx9C06Fx14JCW2n7ca1BuwOLsWG3f/El1vvwdqdz2BH0wcIx7eb4mSdzEeWZThtNhR5PCj2eGC3Zi+zTABoaMzPqgBJknDWsUfiB5P2ZCUEIlHc98p/8d2WbTlcWZI/FEY4Gtv/jr2IqjhgU4uhmKgs2KK4MLDoTIysuBIua//UdiE07PAvwrc1j6Ix/G3e9FIUQkdC9zf3gIzkzbqJzKqoqAjTpk3Do48+mlax2KKxsREAMHr0aGzZsiVtoMq3336LxsZGjBkzps3jutvhhx+O1atXY9iwYW1ucicHLFityYsunck21DQNS5cuTf28evVqNDY2YvTo0QCA0tLSNn0LWyo3W9u7t+Wnn36K4cOHQ1Hafmfe26GHHooVK1bss4/iRx99hMsvvxznnHMODjnkEFRUVGDjxo1p+1it1v3+vqNHj8ZHH33U5rm7+t+5M699IA4//HDs2LEDqqq2+SyUlJSk9hsxYgSuvfZazJ8/H+eeey6eeeaZfa7ru+++Q11dHe6++26ceOKJGDVqVFayOVt05XPQG2V8lt1yJcJms+HFF1/ENddcg+nTp+Nvf/tb1heXjyRJQlGBI6NW5KUlTnzvrD09CL78ejc+W7rvZqzt0Q2BcCyG7XWN+HbDDgTCLFUh6ixZUmBR3KmBNPmQGZIrkiTBYS1HuXcihpVdgkP734TK0h+i1HMs7Jb2MrAMBGObUNP0Plbv+H/4etu92Lj7P6gLrmiTOUkEJMuMfU4Xij0e2CzZ6R2aSBjwB/M3s3nKhHH48bQpqROtaDyBh157C1+s25DjlQENoRCiJmyB050kSW4eYlaUNmU615zWvhhe/mMMKj4HqrKnN1VCb8KG3f/Cul3PIRLP3klVd0v2gPQ3T8FmAJKoKx599FHouo6jjz4a//nPf7B27VqsWrUKDz30EI477jgAwNSpU3HIIYfg4osvxvLly7FkyRJceumlmDRpEo488sgeX/P//u//4rnnnsPtt9+Ob775BqtWrcI///lP/P73v+/0cwwaNAiSJOGNN95AbW0tgsF9D0i0WCz41a9+hc8++wzLli3D5ZdfjmOPPTbV33HKlClYunQpnnvuOaxduxa33norvv766zbPs3nzZlx33XVYvXo1/vGPf+Dhhx/GNddc06n1XnjhhaioqMDZZ5+Njz76COvXr8d//vMffPLJJwCS2auvvPIKVqxYgZUrV+Kiiy5qk2k3ePBgfPDBB9i2bRt2797d7utcf/31mD17Nh577DGsXbsW999/P1555ZXU0JUD1ZnXPhBTp07Fcccdh7PPPhvz58/Hxo0b8fHHH+N3v/sdli5dikgkgquvvhoLFy7Epk2b8NFHH+Hzzz9PBY0HDx6MYDCI9957D7t370Y4HMbAgQNhtVrx8MMPY/369Xj99ddx5513Zm3N+/scPPLIIzj55JOz9npml3Hgce+D/u9//3u88MILuO+++7K2qHxnUWV4PZkFLk6c2A+jR+zp5fDSK2vQkMGwmtbCkTjWbtqFrbvqEAhHOpyMTUR7MAsyc7JsgdcxDP0Lp2N0n19ibN9rMbDoLBQ4x0KR7W3214wwGsJfYXP9q/h6231YVfMYtjXMRyC6HgYH/xyU9pWlryoKClxuFLhcUJWu/38YCMYRi5t/4u++HDNqOH555jRY1GSgS9MNPP7WO1j8TXZK5w6YEKgLBBHLcrlZPpBlC2xqESyKG2aZfi1JEopc4zGmz69Q5pkIqdVX/WBsA77b8Ri21s+FZuRPFvCeDMg6aHqImfNEB2Do0KFYvnw5qqqq8Jvf/Abjxo3DKaecgvfeew+PPfYYgOTfj9deew2FhYU46aSTMHXqVAwdOhQvvfRSTtY8bdo0vPHGG5g/fz6OOuooHHvssfjrX/+KQYMGdfo5+vXrlxpSU15enjY1e29OpxM33ngjLrroIhx//PFwu91pv/u0adNwyy234IYbbsBRRx2FQCCASy+9tM3zXHrppYhEIjj66KPxy1/+Etdccw2uvPLKTq3XarVi/vz5KCsrw2mnnYZDDjkEd999dypL7v7770dhYSEmTpyIM888E9OmTcPhhx+e9hx33HEHNm7ciMrKSpSWtt+W5eyzz8aDDz6Ie++9F2PHjsUTTzyBZ555psuVpZ157QMhSRLeeustnHTSSbjiiiswYsQI/OAHP8CmTZtQXl4ORVFQV1eHSy+9FCNGjMD555+PGTNm4PbbbwcATJw4ET/72c9wwQUXoLS0FH/+859RWlqK2bNn49///jfGjBmDu+++G/fee2/W1ry/z8Hu3bs71Yeyt5BEhpcPN23ahAEDBrRJb/7666+xbNmy1NQps/D7/fD5fGhqaoLX6+3y80XjCdQ1N7zdn931kYxOcuoborjjz58gGk0+ZuyoYlx95YQD7m+jKEBxoRMWVYYsy7BZLLBbLbBbrJBlc3xBJsoHuhGDbkSgG3EkCzepM4QwEI5vT/aGjFQjFN+Kjt4/WbLAbRsMj70SXkclbGpJXvb3kiR5H9mfvUM2j6v+QAzX3fouppwwCMcfPWCf+wkhEInHEIxG0ZWkJ1WRUFrszOtj4LrtO/DI63MRju3JMvzeCcdg2hETcrcoJE8KSn3eVGD0YJMMjgWgG+YqPY8mdmNbwzz4o+vStquyE30KTkax67A8vMCWvEioKg5TDfwhovw1e/ZszJo1K1V2TtQVkydPxoQJE/DAAw/keimmkfG3w31dYRg3bhzGjRvX5QX1JgU+O2rrQuhsn9GiQju+f/YIPP/P5DSpb76rw0efbccJx7Y/VXZ/dB3YXR9GSbELFhiIxGKIxGKAJMFmscBps8JhtebliT1RT1JkGxTZBiEM6EYUuhGFIQ6+7J5MSZIMl60/XLb+6OObDM2IIBjdAH+0GoHIOsT1prT9DZGAP7oW/uhabGsELIoPXnslvI5hcNuHQDVRTzXquh27gvjV795G9cZGfLlqFwp8dowd2X7AVpIkOG122C1WhGJRROLxAwpAarpAUyCGQl/bbNx8MaxvBX573ll48NW30BRKTvX8z+LPEIhE8b3jj8nZMV0Igd3+AEq8XljUg69/UXL6dQF0I4qEHjBNVp7dUoKhpRfDH12DrQ3zEG+edK0ZYWyp/y92B5diQOFpcNn2Hfg3H9F8MTDSHIB0Q5YOvs8cERFRvuhU4PHcc8/F7Nmz4fV6250q1dorr7ySlYX1BqoiobjQgd31kU6fIE08ui++WLkLX6+qAwC8/OoajB5RhOKiAzvhNgygvj6M4iIn1JaJnkIgFo8jFo+jUZJgt1phs6iwqipURWEgkmgfJEmGqjihKk4YQksFIYXI3/LNnqTKDhQ4x6DAOQZCCMS0ulQ2ZDC2sU0wN6E3oS60HHWh5QAkuKz94XFUwmuvhNPaLw+zdKi1aEzD7rpkuaemGbjroY9x1/9UYUC/fWdRyrIMj8MJp9WGUCyGaCLzAGQ4osFmTcDpyN9Mqf4lxbjh+zPxwJw3UduUrMKYv2wlQpEofnjySVA62XQ/2wzDwG6/H6U+L9SDtHm6ItshS1ZoRgiaHs71cgAkA/c+x0h47JXY5f8EO/0fpP7eRuI1WLPzKRS5xqNvwVRYFE+OV5uZ5HE4BlVxQJXZHoWIiMiMOlVqfcUVV+Chhx6Cx+PBFVdc0eG+LZODzCKXpdYt4gk9o+BjY1MMd9zzCcKRZL+zkcMLcc3PDu9SaZiqSigrdu4/qChJsCgKrKoKm8UCm8WS1yVpRD1BN+KpICRLsQ+MITSEYpvhj1QjEF2HSGJnh/srsh0e+1B47cPgsVfCqvp6aKX7x1Lrzlvx9U787Ia3EE8ks8NKi524+3dVKCrs3MU2XdcPKAApSUBpiQsWJb+Pb02hMB589S1s3V2X2jahcjB+Ov3knJY8K4qCUp83ZwFQszBEAgktYLoM+bjWhG2N76AxnD4UQZasqPBNQqnnGMgmGprTeSzBJiIiMqOMejwKIbBlyxaUlpbC4ciPkjczBB4BIBbXUVcf6XRI4rOlNXjmhW9SP//geyMx+YSulcG4nBYUeG2ZPUiSYFNVWFQFVpWBSKKOCCFgiBg0IwqD/SC7JKEHmoOQyZtmdJw5ZFdL4HEMg9deCbdtMGQ5dyedDDxm5q331uGWexalAoeDB/jwx5snZ5SRqBsGwhmWYFstMkqLnQewYnMJx2J49PV5WLt9R2rbiP598cszpsFhy2zQXTZZVBWlPi+rKJDsE5zQgxAmG6AVjG7Eloa5iO51ocemFqN/4Qx4HcNytLKukyULVMUJWbLxM0hERJRjGQUeDcOA3W7HN998g+HDh3fnurLGLIFHAAiG42jyx/e/I5IBjMef+RIrv6oFAFitMn7/22NRVtq1kySfxwq3qwsnIs2BSLs12R9SycKkUaLeiP0gs0cIA5HEDvgj6xCIViMY2wJg3/3TJChw2wfBY08GIu2Wsh498WTgMTPhSALP/HMlnnpxZWrb+DFl+N21J8CiZnaMMQwD0UQckXgcmr7/HnsFPhtceVxy3SKuafh/b72LLzdsSm0bWFaCX888DV5n7i4U261WFHncDPw004wIND1omv6PQHIozu7gctQ0vQ99r0nXPsdI9CuYBpulKEer6zpJkqHIDqiyAxL7QBIREeVExlOtx44di6eeegrHHntsd60pq8wUeASAuoYIorHO9YPzB2K4455PEQwlgxbDhhTguquP6HLG4QFlPu6DRVVht1pgVVVYVPWgL6siao8h9OZG+DHTZbzkI92I7RlSE61GTKvvcH+L4klOyrZXwmOvhKp0b5YbA4+ZCUcSqK0LY/ZLX+K1eWtS2ydPHIRf/+TIAw5aabqOaDyOaCIO3Wj/q46iAGXFrl6Rya/pOp5/7wN8smrPe1he4MOsc05HsTd3ffscNhuKPO6cvb7ZCGEgoQfbBPlyTdPDqGl6H7uDy9A6W1+CgjLvRJR7T4Qi5y6DNhuSg+Kcef97EBER5ZuMA4///e9/8ec//xmPPfZYXkyxNlvgUdcFdmUw6XrZip34v2e/Sv183szhmDq5/cnimXA6VBR4s19+YrVY4LBaYbNYDsqplkT7kxxKE2seSsMgZDbEEvXNQch1CEQ3wBAdZ5Y7rX2bA5HD4LL1z3oWDAOPmWkJPBqGwF//3xIs/mxL6r7zzhiFi7/Xte8ayUFGCQQjUejtHHyzeTEu1wwh8PKHn+DdL/Z8byhwuzDr7NPQtzh3WWsMPrZlGAnEdb/pjgPheA22NsxFKLY5bbtF8aJfwSkocI7L+wxWSVKhyg4osp3DaIiIiHpAxoHHwsJChMNhaJoGq9XaptdjfX3HmSc9zWyBRwCIRjXUNUY7vf+Tz32FpV8k++9YLDJ+95tjUFHu6tIagOTAmaICR8albJ0lyzIUWYYkSZAkCXLzTZIkKLIMi6okp2hD6hXZJkSZSmZCRmEYMZZjZ4kQOkKxLfBHq+GPrkMkXtPh/rJkg8c+JJkN6RgGm1rY5TUw8JiZlsAjACQSOm6/70N8s3p36v6fXXo4plUN7fLrCCEQikYRjsfa9IEsLnTAbusdF8uEEJi3dAXmfLwktc1ps+HXM2dgaJ/ynK3LYbOh0O3K+6BVNgkhoBthJPQQzNQTWAiBhvBX2N74DhJ6IO0+t20Q+hXOgNNakaPVZROH0RAREfWEjAOPzz77bIf3X3bZZV1aULZl8wRp3fYdCEYi8LmcsHZxWmR9YxSRaOeucgdDcdxxz6fwB5JZPEMGefHbXx2Zlf6KkgQUeG0ZNfHvFs3BSFVRYFFkWFQVFqU5MMmTFDoI7CnHjpiq/1e+S+ghBKLrEYiugz9SDc0Idri/TS1K9YZ02wdDkTPPhGPgMTOtA48AEArHcfOfFmLLtuRFPlkCbvr1RBw1oW+XXwtI9oEMx+MIx6KpAKSiAKVFLih5PuW6tQ+++hYvvP9hKpxlVVX8/IxTMXZQ1wbVdYXNakWR282LjXsxhI6EHoBhxHK9lDS6EcNO/4fY5f8EAq3bBEkocR+JPr6qbm9d0VNkyQJFcUCR7PzeSURElGUZBx7zTTZPkO55aQ4++HoVZFlG/5IiDCkvw5CKMgwuL0NFUQHkDL6oJHSB2tpQp69vr/hqFx5/+svUz2efPgzTpw7O7BfogNtlhc9jzp43qqI094+UIEvJLEpZlmFRFA63oV5JN+KpnpBmyoLJd0IIRBM7k9mQkXUIxTbvdTKdToIMl21gsizbMQwOS3mnyvIYeMzM3oFHANhdF8aNf3gf9c3VATargjtunIQRQ7NXLmwYBgLRCKLxZLaxw66iqMCetec3g6Vrq/HUvPdTJeaKLOPH06bgyBGVOVuTqigo8rhh6eIF3N5IN6JI6AHTXXyKJeqwteFt+KNr0rYrsgN9fVNQ7D6i15Qs7xlG4+w1vxNRV9x222147LHHsGvXLsyZMwdnn312rpdERHmoS4HHaDSKeDy9l1Y2TkKyKZsnSD+671HsbGxq9z671YrBZSXJQGRFMiBZ4Oq4HLopEEcw1Lkp1wDwzAtf47OlOwAAqiLh5t8cg359stczyW5TUOiz51UmgiRJUJszI4HkiaQhBHTDgBAiVead9pjmxyVLwSWosgKLqnA4DpkOJ2N3L92IIxjbiEAkWZYd0+o63F+VXc1ByOSQGovS/t9fBh4z017gEQA2bmnE//xpYao6wOux4e7fVaFPeXZ7BcYTCfgjYeiGQHGBHXZ77wqIfbtpKx57823EEsn3UQJwUdWJmHTomNwtSpLgdTjgdjC7bG9CGNCMEDQ9ArNdeGqKrMW2hrltBno5LBXoXzgDbnvXe5CbR7IM26K4OA2b8s7ll1+eVqVYVFSEo446Cn/+859x6KGHdvp5Vq1ahTFjxmDOnDk49thjUVhYCJutd/REpsxMnjwZEyZMwAMPPJDrpVCeyjjwGAqFcOONN+Jf//oX6uranqTpeucmNveUbJ0gxRMabnnuH1i7bQdiic4FAArdbgypKMWQ5kDkwNJS2K17SpqFENhVF4amde4/QSicwB1//hRNTclSnIH9Pbhx1lFZzfrr7r6PZqcoCqyqmropspw8SwNgGAJCCAgk/2k0/6+jysnMSwYtqTsZIpEKQpotG6a3iGuNySE1kXUIRNdDFx2XPTosFfA4WobUDIAsJQNWDDxmZl+BRwBY+c1O3PnXxdD15N/bPmVu3PW7KviyPAzGaO7/GNPiKC5ywtKLSq4BYMOOXXjotbcQiu75TM887iicdtRhOQ38WVQVhW4Xsx/bYQgNCc1vuotOhtBQG/gUO5o+aDPIq9B5CPoWnAKraq4khK6RoCoOqLKLGZCUNy6//HLs3LkTzzzzDABgx44d+P3vf48vv/wSmzdv3s+j93jjjTdw5plnwjCMLh0rEokELBb2Uc1nDDxSV2V8BL3hhhvw/vvv47HHHoPNZsOTTz6J22+/HX379sVzzz3XHWs0BatFxT0/vgTP3/Br3HLRefjhlBNxwthR6FdctM8/xA3BIJav24D/LP4M9778X1zz+DO4/e//xnPvLsKHX6/Ctt31KPTZoaqd+0Puclpw6QWjUz9v3hrAvHc3ZuPXS9E0gdq6MKKd7D/Z2+i6jkgshqZQCLVNTdjR0IAd9cnbrsZG1DY1YXeTH3X+ABoCQTQEgsn96huwbXcdauobUFPfgB0NjdjtD6ApFEYoGkU0nkA8oSGhaTCMzDMYhBAwjGQmp64b0HQdCU1HLJFAOBZDMBKFPxxGIBxBMBJFOBpDONZ8i8YQikYRikYRjEQRiEQQCCdv/nAYTaEwmkIhNAaTt4ZgMPXvLbemUHu35GMDkQjCsRii8ThiiQRiiQSi8ZZbHJFYHOFYDLrOYFlXyJIFFsUDm1oCq+qDfAC9B6ljVrUAJe4jMKT0AhzS/waMKP8xKryT4LT2R+oKRCuRxA7s8n+EdbuexVdb70H1rhdRG/gM0UQdenkXkx4zfmw5rv7Rkamfa3YF8acHP0Islt1jlCxJ8DgcKHJ5EI+KXpeFN6SiDDd8fyYK3XsqMV775HP864OPUxfRciGhaaht8iMS63z1x8FCllTYLEWwqj5TBbxkSUW59wSM6XM1Cp3pmVMN4a+wquZh7Gj6EIbJpnUfOAFNDyOa2I2EHuSFP8obNpsNFRUVqKiowIQJE3DTTTdhy5YtqK2tTe2zZcsWnH/++SgoKEBRURFmzpyJjRs3AkiWWJ955pkAkgNDW46LhmHgjjvuQP/+/WGz2TBhwgTMmzcv9ZwbN26EJEl46aWXMGnSJNjtdrzwwgsAgCeffBKjR4+G3W7HqFGj8Le//a3D32HevHk44YQTUFBQgOLiYpxxxhmorq5u81qvvPIKqqqq4HQ6MX78eHzyySepfWbPno2CggK8/fbbGD16NNxuN6ZPn46amj3DB/f3Oy1cuBCSJKGxsTG1bcWKFZAkKfV+deZ1AODpp5/G2LFjYbPZ8P/Zu+/wKOqtD+DfmdneNz2EQEIH6QJKUap0FSzIawXBLsUCVhQUr4qKYMOGImJviFQVBaQKCChdQk/vu5vtM/P+sWEgEiAhszXn8zw+9+4kO/PbZMnMnjklNTUVDz74oPS1srIyjB8/HomJiTCZTOjXrx927dolfX369Ono2LEjPvroIzRq1AgGgwH3338/eJ7HrFmzkJKSgqSkJLzwwgtVjlnT/X766afIyMiA2WzG6NGjYbcHhouNGTMGa9euxdy5c6VqwlOvm5CaqvUt5p9++gkLFy5Enz59MHbsWFxxxRVo1qwZGjdujM8++wy33HJLMNYZMTiWRXpiPNIT43Flu8A2t9eHYwWFOJJXgCN5BTiaX4BSR8VZzxVFEdnFJcguLsH6PfsBAGqlAumJCUgyWZEWl4C0+HiYtLpzfui5pHUCel7eABs25wAAlv18BO0uSUCjhvLdXRZFoLjMDbNRBYM+Mvs+RipBOH1ByvM8zpUvxbKsNOH7VPakIIqQJh2c+v3HUPDCajRAx1GwrK4YhgHHaMCxGogiD7+UBRkrH/IiA8Nw0KvToVenIxV94eedsHuOwO46BJs7Cz7eVuX7BdEHm/tgoAda6QqoFfFIMvVAetzQML2C2NGnR2MUl7iw6LvdAICDh0vw2rtb8NiD3WXv88uyLNRQQa/WgGF52F3umPk7nBpnxdQbr8WcH5ZJbWNW79wNh9uDOwb0llqWhJooiiix22ER9dBrYqvHphw4VgOWUcEvOOHnnYiU8mulwoSMhOuQ4OmCkyUr4PIFPlwLog+55atRUrEDadbBMGtbhHmlchHh5yvACy4oWD04VhtzNyjIhYmiWKs2WXIz6FUX9b5zOBxYtGgRmjVrhvj4eACBLMRBgwahe/fu+OOPP6BQKDBz5kwMHjwYf//9Nx599FFkZGRg7NixVYJnc+fOxWuvvYb33nsPnTp1wkcffYRrrrkGe/bsQfPmzaXve/zxx/Haa6+hU6dOUvDxmWeewVtvvYVOnTphx44duOuuu6DX6885nLaiogIPP/ww2rdvD4fDgWeeeQYjR47Ezp07wZ5RafbUU0/h1VdfRfPmzfHUU0/h//7v/3Do0CEoKrPpnU4nXn31VXz66adgWRa33norHn30USkgWtPXdCEXOs68efPw8MMP46WXXsKQIUNQXl6ODRs2SM+/8cYbodVqsWLFCpjNZrz33nvo378/Dh48iLi4QI/rrKwsrFixAitXrkRWVhZuuOEGHD58GC1atMDatWuxceNG3HnnnRgwYAAuu+yyWu138eLFWLp0KUpLSzFq1Ci89NJLeOGFFzB37lwcPHgQbdu2xXPPPQcASEyM3coeEhy1LrU2GAzYu3cvGjVqhIYNG+L7779Ht27dcOTIEbRr1w4Ox/knhoaa3CVhbq8PxTbbBb+vzFGBI/mVgci8AhwtKJQa2F+IQaNFWnw80uLikRafgLS4eKjPSE93uf14ftZmlJQGmu6npRrw+MPdglIeHclDZ0h0sRoN0FFfmKAJDKRxQxA9lJERZKIowu0vrOwNmQWH52i1gd9Uc19kJo4KwwqDK5Sl1qeIooj3Pt2BVb8flrYN6tsE99wWnFJhlmWQlmKEn+dR6nDAH2FtZOrC7nThjR+X41hBkbStXUYj3D10QJVrjXCg88T5BaZf2yAIkZUhKooCiit2ILdsNfxC1X/LJk1zpFkHQaNMCNPqgoNhOCg4PRSsNtxLISFkd3jQe+SisB1/7Q+3wmi48N/IMWPGYNGiRdBU3sypqKhAamoqli5dis6dOwMAFi1ahJkzZ2Lfvn3SedTr9cJisWDx4sUYOHAgFi9ejJEjR1ap4khLS8MDDzyAJ598UtrWrVs3dO3aFW+//TaOHj2KzMxMzJkzB5MmTZK+p1mzZnj++efxf//3f9K2mTNnYvny5di4cWONXn9RURESExPxzz//oG3bttKxPvzwQ4wbNw4AsHfvXlxyySXYt28fWrVqhQULFmDs2LE4dOgQmjYNDFZ755138NxzzyEvL69Gr2nNmjXo27cvSktLYbFYAAQyHjt16oQjR44gIyOjxscZO3YsZs6cedZrW79+PYYNG4aCgoIqfTSbNWuGqVOn4u6778b06dPxyiuvIC8vD0ajEQAwePBgHDhwAFlZWVIwtlWrVhgzZgwef/zxi97v1KlTsW7dOmzevBkAlVqTuqt1xmOTJk1w5MgRNGrUCK1atcLXX3+Nbt264aeffpL+IRLAYtCjkyETnZpmAghkwuWVluNIXj6O5hficF4BsouKqy1xcrhdOJB9EgeyT0rbEkwmNKzMiEyLS8Cto1vhjXk7AQDZuQ4sW3UYI4Y1k/11OCq8YBnAaKDgIyGRjGNV4FhVZQatp7IfpBeRkh0TSxiGgVaZBK0yCUmm7hBEHxzu47C7A9mQbl8BAMCiC+PwjhjDMAzuurUTSkpd2LozkHmx6vfDSIzT4frhrWQ/niCIKLd7YDVrkGg2o9xZAaf7/D0/o4VRp8XD112NeUtXYf/JQPXEP0ePY+7i5XjwmsFhDfyVOirAMgw0KrrmqA7LcFArrPALLvgjqOyXYVgkGC6FRdcGeWVrUOj4E6fOPTb3v7DnZiHR1B0ppivBxUibEFHk4fPb4GecUHKGmHldJHb07dsX8+bNAwCUlpbinXfewZAhQ/Dnn3+icePG2LVrFw4dOiQFmk5xu91VypnPZLPZkJOTg549e1bZ3rNnzyqluwDQpcvpNikVFRXIysrCuHHjcNddd0nb/X4/zGbzOV/Dv//+i2eeeQZbtmxBUVGRVFl2/PhxtG3bVvq+MwfmpKamAgAKCgrQqlXg+kCn00nBwFPfU1BQUOvXdCHnO05BQQFycnLQv3//ap+7a9cuOBwOKSP1FJfLVeX3kZGRUeV3lpycDI7jqmSAJicnS8e92P2euXZC5FDrwOPYsWOxa9cu9O7dG48//jiuvvpqvPXWW/D5fJg9e3Yw1hgTWJZFg3grGsRb0fOSwB9Bj8+H4wVFOJJfEAhG5uajxF59xmiRzYYimw07jwayPRQch8zLNSjKFeFzKPHr+iy0vyQBTTIssq/d5vCCYQGDjj4IEBLpqpZiC+AFD3jRHXEZMrGEZZQwaQPTrtMA+HgHXL58mLQ1L88hF8axDB659zI8M2sdDh4OTNVd9N1uxMdp0aeH/NN07XYPDHoVlAoWVoMBWpUKpY6KKi01opVWrcKEa4fgw5W/YUfWEQDAoZw8vPrtEkwcMRQWvf4CewgSUUSxzQ6TXgejljLJzkXBasExavh4O3jBHe7lSBSsFg3jhiDe0BknS1fA4TkKABAhoMC2ASUVu5BmuQpWXfuYKVMWRT+8/jKwjBIKzgCOpWtlEhn0ej2aNTudlPLhhx/CbDbjgw8+wMyZM+FwOHDppZdKZcBnkqOMVn/GeeRUReQHH3wglf+ewp2nzcfVV1+Nxo0b44MPPkCDBg0gCALatm0Lr7fqNe2Zg2vO7EVZ3ddPfU9tij5PBfXOfI6vmmGz5zuO9gLnNIfDgdTUVKxZs+asr52Z3FXdMarbdur112W/sXC9QyJHrQOPDz30kPT/BwwYgP3792P79u1o1qxZlbsN5MLUSiWap6WieVqqtO1YbimycvKRXVKM7OIiZJcUVztF28/z8KMChtNPxcKNK9D8WAoaJiRUlmnHQ6uS5w5suc0LQQBMlPlISNRgGDYwjRNaiCJfmQXpibgpqbFGpTDBpG164W8ktaZWK/DkpJ544oXfkVsQ+CDz1kfbYDVr0OGSZFmPJQIoK3cjMV4HANCoVEiyKFDmqIDbG/2BfKVCgXuGDsCi3/6Q+k6fLCrBrG+W4KGRw5BoDt9kYluFEz4/D4teD5aNjQCV3BiGhUphBi9o4ONtEZP9CABaVTKaJd2BMtdeZJf+DB8f6Cnq5x04VvwDiuzb0DBuCHSqBmFeqXwE0QevvxQsq4aS1YNlaYJvLDLoVVj7w61hPf7FYhgGLMvC5XIBADp37oyvvvoKSUlJNW6bYjKZ0KBBA2zYsAG9e/eWtm/YsAHdunU75/OSk5PRoEEDHD58uMbzIIqLi3HgwAF88MEHuOKKKwAEypHlVpPXdCoQm5ubC6vVCiBQal0bRqMRGRkZWL16Nfr27XvW1zt37oy8vDwoFApkZGRc3Iuphlz7ValU4GOo7QwJvVoHHv+rcePGaNxY/kyD+qphkgUqTomWaQ0BBO6sFNvtyC4pQnZxMbJLipFXVlrtHQiGE3AoLweH8nKkbXEGIxrGx6NBXAIaxscj2WK96AbydocXfh8Pq0UTM3eqCakvpH5UnB6CFISkoTQk+phNakx7pBcen/k7bHYPeF7Ey29twgtP9EFmI4usx3K6fHC5/dBqApdLHMsi3mSE1+eH3eWC2+eL6uEzLMvitv5XQq9RY9X2QElZUbkNL3/9IyaPGIqGifEX2EPwuDweeHw+WA16Kr0+D45Vg2Xi4eMd4AVXuJcjYRgGVt0lMGuaI9+2Afm29RAR+NBa4T2BA3nvI95wKRqY+0HBhSnDNggEwQOP4AHHqqHg9GAZCkDGEoZhatRjMRJ4PB6pt2BpaSneeustOBwOaVL1LbfcgldeeQXXXnutNNH52LFj+P777zF16lQ0bNiw2v1OmTIFzz77LJo2bYqOHTvi448/xs6dO6vNnDzTjBkzMHHiRJjNZgwePBgejwfbtm1DaWkpHn744bO+32q1Ij4+Hu+//z5SU1Nx/PhxPP7443X8qVTvQq+pWbNmSE9Px/Tp0/HCCy/g4MGDeO2112p9nOnTp+Pee+9FUlIShgwZArvdjg0bNmDChAkYMGAAunfvjhEjRmDWrFlo0aIFcnJysGzZMowcObJK6XptyLXfjIwMbNmyBUePHoXBYEBcXFyV8m5CLqRGgcc33nijxjucOHHiRS+GABzHwKhXodweyKZgGAYJJhMSTCZ0yGgCIJDtmFdWKmVEHjieC69Yfe+pEocdJQ47/j52NLB/lkWKxSoNrUmLj0ecwVjjQKLLw4MvccFi0ULJUfCRkGjEMhxYTg8lp4cg+gLl2IIrojJmCDmf1CQDnp7cE9NeXguPl4fL7cfM19fj5af7IaEyQ1EuxaVOpCYZqkzQVikViFcaIQgi3F4vXF4vPD5frUq3IgXDMLi+1+UwaDX4bv0WAIDN6cQr3y7Bg9cMrlKVEWqCIKDYZodapYJZp4NSEZ7J25EukP1ogiBo4eVtEXVDiWVVSLX0RZyhI7JLV6HctV/6WrFjO8oq9iDV0hcJhi5gmNj5/QbOqxSAJOGzcuVKqd+h0WhEq1at8M0336BPnz4AAv0I161bh8ceewzXXXcd7HY70tLS0L9///NmQE6cOBHl5eV45JFHUFBQgDZt2mDJkiUXnP48fvx46HQ6vPLKK5gyZQr0ej3atWuHyZMnV/v9LMviyy+/xMSJE9G2bVu0bNkSb7zxhrR+OV3oNSmVSnzxxRe477770L59e3Tt2hUzZ87EjTfeWKvj3HHHHXC73Xj99dfx6KOPIiEhATfccAOAwLl4+fLleOqppzB27FgUFhYiJSUFV155JZKTL76iQ679Pvroo7jjjjvQpk0buFwuaagOITVVo6nWmZmZNdsZw+Dw4cMX/sYQCtdU67oQRREFxU74/TX7AOP18njh9Y0oc9mgNPhgiBOgs/Jw1bAUTKtSocEZE7TT4uKhr5yCdi4MA1hMaui0dCFFaoamlUY+mowtD4ZhoVHWvT9SpArHVOtz2bozBy+9sRFC5ekyPc2EF5/sA73MPYk1agWSEnTnvUkniiLcXh9cXi/cXm9UBiHX79mPT1evk9Z+qhy7fWYEVLYwDAwaDUw6LVVdXICfr4CPr0AkDhezubKQXboCbn9Rle0aZRIaWofAqKnZZ45oQyXYhBBC6rMaBR6jWTQGHgHA5xdQWOyscQXX4aPleOWNrdL39+nVEIMGpeFkZXl2dnERcktLwNewSaxFb0DDygnaafHxSLFYoVScnSBrNKio7yOpEQo8Ro/AZGyv1BMyEj+8RjIKPNZOXQKPQGC69bsL/5IeX9IyAc8+cgWUSnmzp0wGFayWmg084QUBFW437C531JVi78g6gg9WrIa/spcTyzAYM7APLm/VIswrC+A4DmadDlo1XXucjyjyleXXkTN85hRR5FFo/xO55Wsg/Kdix6JrgzTLQKgUlvAsLshYVgUFq6chNIQQQuqVOgUeTz01ku88R2vgEQBcbj9Kymp+wfjDT/9i1W/HpMcPPdAZLZvFSY95nkd+eVllr8hAz8gie81eC8swSLZYK8uzA8HIBKMJDMNAp1PCaqKAEjk/CjxGJ2kytuCioTQ1RIHH2qlr4BEAPvtuN75derqEs1e3hnjonstkH0ySEKetVTalz+9Hsd0RdQ3ZD5zMwds/rYTbe/rf/E29e6B/x3ZhXFVVaqUSVkPVEnhyNl5ww8fbIzKL3cc7kFP2K0oqdlbZzjAKpJiuQJKpR8yWKAemYOvBsXRdRAghJPZdVOBx4cKFeOWVV/Dvv/8CAFq0aIEpU6bgtttuk32BdRXNgUcAKLN5UOGs2Yd9n1/Ai69tQU5eBQAgPk6DaVMuh0Zz7laebq9XyojMKSnByZIiVLhrFuxUK5WBEu24eDRJSULbJmmwGGKnQTiRFwUeox9Nxq4ZCjzWjhyBR1EU8caH27Bm4+mbb9cOboExN7Wv6/KqYFkGDZJrF+wSBBE2pxMVHk9UZT8eKyjEG4uXB7I2Kw3r1hnXXN4lYm44syxLw2dqQBQF+Hh7RGY/AkCF5yROlq6A05tdZbuKsyDNOghmbauIec/JLRCA1IFjz9/iiBBCCIlmtQ48zp49G9OmTcODDz6Inj17AgiMtn/77bcxc+ZMPPTQQ0FZ6MWK9sCjIIgoKK5ATZMljp2w4eU5WyFUNry6onsabhnVusbHE8XAB6STp6ZoV5Zo+2q4AKtBj8yUZGSmJCIzJQmNkxKhVsbm3WpSOxR4jC2BydguGkpTDQo81o4cgUcgcPPthdfXY9feAmnb+Fs6YtiAZnXe95kMehXirTUruT4Tzwsodzrh8lQ/DC4S5ZeW4fUflqHE7pC29W7XBv/Xp2dETbM0aLXU+7EGIjn7URQFlFTsQk7Zr/ALFVW+ZtQ0RUPr4Jj+u8owCig5PQUgCSGExKRaBx4zMzMxY8YM3H777VW2f/LJJ5g+fTqOHDki6wLrKtoDjwDgdvtRXIuS659WZGHZz6d/DxPv6YQ2reIv+viCIKCgvAzZJcWBnpHFRSi0ldfouQzDIC3eisyUJGQmJyMjJREN4qwR9YGFhAYFHmNToB+kB37BDUHwgvpBUuCxtuQKPJ7a11MvrsHRE4FzFMMAU+7vju5d0mTZ/ymJ8bqLHq7mdHtQVlERNcNnSh0VmPPDMuSWlErburRoijsH9oWCi5wpxCqlEha9niZfX4AoCvDyNghCZAbAecGN3PI1KLT/CeDMACmLRONlSDX3jungHMMoAhmQjIYC6YQQQmJGrQOPGo0Gu3fvRrNmVTMI/v33X7Rr1w7uGpbphkosBB4BoNTmgbOGJdd+v4CX5/yJE9mBDAWrRY1pUy+XdQK1x+dDbmkJThYXIaekGCeLi2B3uWr0XLVSicbJichMTqwMSCbBajTItjYSmSjwGPsC/SBd8AtuiKI/3MsJGwo81o6cgUcAKCl14fEXfpf2qVKymD7lSrRuniDbMViWQUqi/qIH2PC8AJvLCafHGxXl1w6XG28uWYEjeaezSds0aoj7hg+MuKoGnUYNk1ZHvR8vwM+74OPtiNSbRS5fAbJLV8LuPlxlu4LVo4FlAOL0HcAwsfs7ZhgOClYHjqVMXkIIIdGv1oHHtm3b4uabb8aTTz5ZZfvMmTPx1Vdf4Z9//pF1gXUVK4HH2pZcn8yx48XZf4LnA7/e7t1Sccf/XRLEFQI2pzPQL7IkEIzMKSmBx1ezYKlFr0NGZRDyVIk2TayMLRR4rF8E0VfZD9IdkWV9wUSBx9qRO/AIACeybXjif79LPZINehVeeqov0lKNsh2D4xgkJxqgVFx88COahs+4vT68u+xn7D1+UtqWmZKECdcMgUEbYRloDAOdWgWTTgeOKizOSRB5+HhbZbZ65BFFEeWu/cguXQUvX1blazpVGhpah0KvljebOdIwDAuO1ULBasEwlM1LCCEkOtU68Pjdd9/hpptuwoABA6Qejxs2bMDq1avx9ddfY+TIkUFZ6MWKlcAjEPhwVlpe89KY5b8cwZLlWdLj+8d3QPtLQvlhWICf8eJEURGO5hXgSH4BsotKINTgLccASImzShmRmSlJaBBvjaiyLlI7FHisn06VYgeCkPWjFJsCj7UTjMAjAOw5UIjpr/4Bvz8Q+E5K0OGlp/vBapYvSCZH8JEXBJQ6KuDxRmbw50x+nsdHP/+ObQdPX1ukxlkxeeQwWCNwuBzLsogzGiIuKzPS+AUX/LwjYm8SCYIP+fYNyLetPyubPk7fCQ0s/aHkYr1yhgHHqqFgdWBZej8TQgiJLhc11fqvv/7C7NmzsW/fPgBA69at8cgjj6BTp06yL7CuYinwCABFJS54vDXLjOB5AbPe2IZjxwPrNRlVePax7tDrQ3fBwgCIs2ikydoenw/HC4pwJL8AR/IKcDSvAMVnNK0/H6VCgUaJCWiSEghEZqQkId5ooBKUKEGBR1JfSrEp8Fg7wQo8AsCGP0/g1XlbpMdNGlsw8/E+0Faek+SgVLBITtTXubTX7nTB5gzOz0FOgiDgizUbsPafvdK2eKMBk0cOQ7LVEr6FnYfFoIdeE2FZmREm0idfA4DXX4bssp9R5txbZTvLqJFq7oNEY7d6kRV4ahI2y6jpGpgQQkhUqFXg0WazYcuWLfB6vejWrRsSEyP/g1WsBR59fgGFRc4a5wzl5lfghVe3SBkfXTunYNxtbYO3wGowAMxmNfTn6DFZXuHE0cpA5JH8QhzNK4CrhpkfRq02kBWZkoSM5ERkJCdBr6HgViSiwCM5kyD44BdcEERPxGbZXCwKPNZOMAOPAPDjqoNY8OXf0uNO7ZLx5MSeUNQhS/G/1CoOyYn6OgcB3F4fSh0OCEJk/5sQRRFLNm/Dsj//krYZtRpMHDEUjZMi871v0utg1NZ+Gnl9wwveysnXkXtzyO4+gpOlK+D2FVTZrlEkIC1uCEyapmFaWWgFyrB1lWXY1FKA1I4oirjnnnvw7bfforS0FDt27EDHjh3DvSwS4caMGYOysjIsXry4TvvZsGED7r33Xuzfvx/Dhg2r8/7qasGCBZg8eTLKyspk2+fRo0eRmZlJ/7Yq1fiW/86dOzF06FDk5+dDFEUYjUZ8/fXXGDRoUDDXR/5DqWCh1ynhqOGgmdRkPa4Z2hTfL/kXALD1rzx07pCETu2TgrnMKkQAZeUeCLwIo+Hsvo1mvQ4dmmSgQ5MMAIAgiigoKw8EIiv/O1lUDL6aD2J2lwt/HzmGv48ck7YlWy1VBtc0TIynEm1CIgzLKqFilf+Zih2ZU1ZJdLt2UAsUlzjx08+HAAA7/snHuwv/wgNjL5UtW8jj5VFW7obVUrfAlkalRJLZjGK7HT5/5AZ+GIbBtd27wqDV4Ku1GwEAdpcbr333Ex64ejBaNmwQ5hWezVbhhJ/nqe/jBXCsCiwTB79QAT/vRCS2xzBqMtEq5R4UObYht+x38GIgS9PtL0JWwacwa1sjzToQaoU1zCsNLlEU4Ocd8PMV4FhNZRakfNncJPpt2rQJvXr1wuDBg7Fs2bIqX1u5ciUWLFiANWvWoEmTJkhISADDMPjhhx8wYsSI8CyYhExGRgYmT56MyZMnh+X4Dz/8MDp27IgVK1bAYIj1VhmxoU+fPujYsSPmzJlzUc+v8dnpscceQ2ZmJr777jtoNBo8//zzePDBB/Hvv/9e1IHJxTPoVXC6fahpQsSA3o2w8+8CHD5aDgD4/Jt9aNbEUm0QMJhsDi94QYTZqDrvhz2WYZBitSDFakH31i0ABBrwHy8swtG8QqlMu7C8+szT/NIy5JeWYfP+wHtTwbFIT0yo0i8y0Wyi8hRCIgDDMOAYDThWA1Hk4Rfc4AUXRDHyh22Q6DHmpg4oKnFh07ZsAMDqP44iIU6L0SPkG7pmc3ihVHIw6Ot2buU4FolmE8ornKhwR27ZKwD079gOBo0GH/+yBoIgwO31Ye7i5bhrSH90apoZ7uWdxen2wOXxwqjVwqDV0HXAOTAMAyVnAMdq4OPtETl8hmE4JBovg0XXFrnlv6HYsV36WrlrH2zuf5Fs7IlkU0+wbKwPKxTBCy7wgqsyAKmnACQBAMyfPx8TJkzA/PnzkZOTgwYNTt8UysrKQmpqKnr06CH7cX0+H5TUW5ecR1ZWFu699140bNjwovfh9XqhUsX63/fYUeNbvtu3b8ebb76J7t27o1OnTvjoo4+QlZUFWxjLjusrjmNgrMUHG5ZlcMfNl0CpDPy67Q4fPv9mPy6ivWedVTh9KCpxSdO2a0qpUKBpagr6d2qH8YP744Ux/4fX7r4dE64ZguGXXYpLGqefs3+TnxdwJK8Av+3cjfmrfsPTn3yJh9//BHMXL8eSzdvwz5HjsLtccrw8QkgdMAwHJaeHRpkAlcIKjtUg0KyBkLphWQaT7+6G1s3jpW1f/bgPv647IutxSkpd8NawD/P5MAwDi0EPaxT0Mb6sVXM8MHwQlIpAoMPP83h32S/YsGd/mFdWPVEUYXM6kV9WDre3ZtUj9RXLKKBWWKFUmCK2lFfJ6dEo7mq0TLkbetXpD7Ci6EeebS325r6NUueesFzzhgMvuOHxFcPrL4cg0vu7PnM4HPjqq69w3333YdiwYViwYIH0tTFjxmDChAk4fvw4GIZBRkYGMjIyAAAjR46Utp3y448/onPnztBoNGjSpAlmzJgB/xlZ+QzDYN68ebjmmmug1+vxwgsvVLumTz/9FF26dIHRaERKSgpuvvlmFBScbpmwZs0aMAyD1atXo0uXLtDpdOjRowcOHDggfc/06dPRsWNHfPrpp8jIyIDZbMbo0aNht9ul7/F4PJg4cSKSkpKg0WjQq1cvbN26Vfr6ggULYLFYqqxt8eLFVc63NTmOIAiYNWsWmjVrBrVajUaNGlV57SdOnMCoUaNgsVgQFxeHa6+9FkePHq3yexgxYgT+97//ITk5GRaLBc899xz8fj+mTJmCuLg4NGzYEB9//HGVtdZ0v6+++ipSU1MRHx+PBx54AD5f4G9Cnz59cOzYMTz00ENgGOairjNmzJiBxMREmEwm3HvvvfCe0SZNEAS8+OKLyMzMhFarRYcOHfDtt98CCJQfMwyD4uJi3HnnnWAYRnpvrl27Ft26dYNarUZqaioef/zxKu+zPn364MEHH8TkyZORkJAgVd7u3r0bQ4YMgcFgQHJyMm677TYUFRWdd/0LFixAo0aNoNPpMHLkSBQXF5/1PTV93w8ZMgRarRZNmjSRXue5nO81Lly4EPHx8fB4qlaAjRgxArfddhuA0+/Ljz76CI0aNYLBYMD9998Pnucxa9YspKSkICkp6ax/g2VlZRg/frz0O+vXrx927dolff1C7/cxY8Zg7dq1mDt3rvSeOfM9VxM1voooKSmpEpG2WCzQ6/XV/pJimYJjYdBqoNOooVapAiW8YfhQoNcpoVDU/LjJiTqMHN5Merzj7wJs25EfjKVdkNcnoKjECa+vbj2sjFot2mU2wjWXd8GkEUMx++7bMfOO0Rg3qB/6dWyLJilJ5yyxrnB7sOfYCSzdsh1vLlmBR95fiCcXfIEPV6zGrzv+RlZuXkSXuRES6zhWBZXCDI0yAUrOAIayN0gdqZQcnpjYE2mpRmnbvE/+wva/c2U7hgigsNgJnpenR6NOrUaSxSwF9SJVu8xGeGjkMGgrMw9EUcQnv67Fz9t3XeCZ4cPzPIptNpRXRP5An3BTsFqoFfGVN4Mik07VAM2Tx6Fx/Ego2NNlez6+HEeLvsGhgoVweQvOs4fYEghAlsDjK4Gfd8ZcL+VwEUURDpc7bP/VJoD+9ddfo1WrVmjZsiVuvfVWfPTRR9Lz586di+eeew4NGzZEbm4utm7dKgXmPv74Y2kbAPzxxx+4/fbbMWnSJOzduxfvvfceFixYcFZgY/r06Rg5ciT++ecf3HnnndWuyefz4fnnn8euXbuwePFiHD16FGPGjDnr+5566im89tpr2LZtGxQKxVn7y8rKwuLFi7F06VIsXboUa9euxUsvvSR9ferUqfjuu+/wySef4K+//kKzZs0waNAglJSU1PjnV5PjPPHEE3jppZcwbdo07N27F59//jmSk5Ol1zpo0CAYjUb88ccf2LBhAwwGAwYPHlwlSPfbb78hJycH69atw+zZs/Hss89i+PDhsFqt2LJlC+69917cc889OHnyZK32+/vvvyMrKwu///47PvnkEyxYsEAK8H3//fdo2LAhnnvuOeTm5iI3t3bXQatXr8a+ffuwZs0afPHFF/j+++8xY8YM6esvvvgiFi5ciHfffRd79uzBQw89hFtvvRVr165Feno6cnNzYTKZMGfOHOTm5uKmm25CdnY2hg4diq5du2LXrl2YN28e5s+fj5kzZ1Y59ieffAKVSoUNGzbg3XffRVlZGfr164dOnTph27ZtWLlyJfLz8zFq1Khzrn/Lli0YN24cHnzwQezcuRN9+/Y96zg1fd9PmzYN119/PXbt2oVbbrkFo0ePlgYw/9eFXuONN94InuexZMkS6TkFBQVYtmxZlX8DWVlZWLFiBVauXIkvvvgC8+fPx7Bhw3Dy5EmsXbsWL7/8Mp5++mls2XJ6uOKNN96IgoICrFixAtu3b0fnzp3Rv3//Kv8mzvd+nzt3Lrp374677rpLes+kp6ef82dcnRoPl2FZFr/99hvi4uKkbT169MDXX39dJSDZvn37Wi0g2ORugn8uPC/AL/DgBQG8IEAQROmPuwgRgiBCEEX4eV62pvEutx8lZTUvwxIEEXPm/YWDh0oBBIKXzzx2Ocym8Az8YACYzGoYzjF0Rg5+nsfJohIcycvH0fxCHM4rQH5pWY2ey7Is0hPiKgfXBEq0k60WsBGefRKpaLgMqSte8FaWk3kQiX3HTqHhMrUT7OEy/1VQVIHHZ/6O0vLA+VOj5jDz8T5omiFfPziNWoHkRL1s+xNFEWUVFXC6I7sP6snCYsxZvLzKdO7Bl3bEyJ7dIjpzU6lQQKdWQ6tS1Xk6eazjBQ98vC2iA1m84EFe+VoU2jdDxJnrZJBo6IYUSx8o2Po2aIgBx6rBsVpwMV96HjwOlxs3/W922I7/1ZMPw6Ct2Q2Anj17YtSoUZg0aRL8fj9SU1PxzTffoE+fPgCAOXPmYM6cOVWylqrr8ThgwAD0798fTzzxhLRt0aJFmDp1KnJycqTnTZ48Ga+//nqtXs+2bdvQtWtX2O12GAwGrFmzBn379sWvv/6K/v37AwCWL1+OYcOGweVyQaPRYPr06XjllVeQl5cHozFwI3Hq1KlYt24dNm/ejIqKClitVixYsAA333wzgECw7lRPwylTplQ7SGTx4sUYOXKk9Pn9Qsex2+1ITEzEW2+9hfHjx5/12hYtWoSZM2di37590vnP6/XCYrFg8eLFGDhwIMaMGYM1a9bg8OHDYCt7D7dq1QpJSUlYt24dgMBNMrPZjA8//BCjR4+u1X6zsrLAVSbhjBo1CizL4ssvvwRw8T0ex4wZg59++gknTpyATqcDALz77ruYMmUKysvL4fP5EBcXh19//RXdu3eXnjd+/Hg4nU58/vnnAAJJbHPmzJECz0899RS+++67Kq/rnXfewWOPPYby8nKwLIs+ffrAZrPhr79OD7abOXMm/vjjD6xatUradvLkSaSnp+PAgQNo0aLFWa/h5ptvRnl5eZW+p6NHj8bKlSul90RN3/f33nsv5s2bJ33P5Zdfjs6dO+Odd945a7hMTV7j/fffj6NHj2L58uUAgNmzZ+Ptt9/GoUOHwDBMte/LwYMH48CBA8jKyqryPhozZgwef/xxrF+/HsOGDUNBQQHUZ3wWb9asGaZOnYq77777gu93IIQ9HgGgf//+Z91pGT58OBiGgSiKYBgGPF8/+3JxHFvji1VeEODz8/D5/ZXBShE8Hwha1uZOllajgErJ1jhzkGUZ3D66DZ5/ZTM8Hh4VTh8++3of7hvXISwfCEQA5eUe+Lw8zEY1WFb+NSg4rnLa9ekgQIXbg6P5BTiaX4gjefk4kldYbam1IAg4VlCEYwVFAPYCALQqFTIqB9dkpCShSXISTHqd7OsmhJyNY1XgWBVEUQAvuMELbiolI7WWlKDH0w/1xFMvrYXb7Yfbw2Pm6+vx0tP9ZAsWuj1+lJS6EGeVJ7jBMAysBgNUCgXKK5wRWzbaMDEej426Fq//sAxFlX2YV27fCYfbjVv6XRGxQ118fj/K/X6UO53QqVUwarU0lO4cOFYNlomHj7eDFyKzBynHqpFmHYh4Q2ecLF0Ju/tQ5VdEFDq2oNT5D1It/RGv7xSxJeTyE6XzJsMooGB14Fh1PXr99cuBAwfw559/4ocffgAAKBQK3HTTTZg/f74UeKypXbt2YcOGDVUyvXieh9vthtPplIJPXbp0ueC+tm/fjunTp2PXrl0oLS2VknGOHz+ONm3aSN93ZiJTamoqgEDmV6NGjQAEgmangiOnvudUyXZWVhZ8Ph969uwpfV2pVKJbt27nzEQ7l/MdZ9++ffB4PFKA9L927dqFQ4cOVXk+ALjdbmRlZUmPL7nkEilYBADJyclo27at9JjjOMTHx0vHrc1+uTPOY6mpqfjnn39q/NrPp0OHDtLvHQC6d+8Oh8OBEydOwOFwwOl04qqrrqryHK/Xi06dOp1zn/v27UP37t2rxCR69uwJh8OBkydPSr/7Sy+9tMrzdu3ahd9//73aATVZWVnVBh737duHkSNHVtnWvXt3rFy5ssp+a/K+PzO4eurxzp07L/o13nXXXejatSuys7ORlpaGBQsWYMyYMVWe89/3ZXJyMjiOO+t9dOZ7xuFwID7+dLshAHC5XFXeM+d7v8uhxoHHI0fk7YMEAOvWrcMrr7yC7du3Izc396w7LKIo4tlnn8UHH3yAsrIy9OzZE/PmzUPz5s1lX0socSwLTsVCozo7048XBPB8IGvSL/Dw+Xl4fL5zZkmaTZpaZYokxGtx/TXN8fk3gd5Lf+8pwuatuejeLXwTKJ0uP7w+HnEWLZSK4F8A6TVqXNI4HZc0DqQHi6KIYrsDRysnaB/OK8DxgkL4qgmiu7xe7DuRjX0nsqVtcUYDMpKT0CQlkBXZKCkBamqoTEjQMAwLBaeDgtNBEH3w8y4IoieiM3BIZGnS2Iqp91+OF+ZuAM+LKLN58Pzs9fjfU31gMsiTmW2v8EKpZGGUaX8AoNdooFWp4XC7al12FyqJZhOm3ngN3li8HCeLAiU86/fsR4XbjfGD+0d22bgowun2wOnxwqBRw6DVRmywNJwYhoVKYQYvaCI6+1GjTEDTxFtgcx3EybKV8PoDFT9+wYkTJT+hyLEN6dah0KtrVy4W7UTRDx9vg19gwbFaKFgdBSBjzPz58+H3+6sMkxFFEWq1Gm+99RbMZnON9+VwODBjxgxcd911Z31Nc0Z/fb3+/DfuKioqMGjQIAwaNAifffYZEhMTcfz4cQwaNKhKiTCAKoNpTgVczvws/N/BNQzD1KqikGXZs86fp/ofnmsd/z2OVnv+G4sOhwOXXnopPvvss7O+lph4OiGmumOc77h12a9cVZfn43A4AADLli1DWlpala+pZah8++/7zOFw4Oqrr8bLL7981veeClpfjJq+7+XWqVMndOjQAQsXLsTAgQOxZ8+esybSX8x7JjU1FWvWrDnreGf2Og32e6bGV3+NGzeW7aCnVFRUoEOHDrjzzjur/aXOmjULb7zxBj755BNkZmZi2rRpGDRoEPbu3RvUX3g4cSxb7UWun+fh9fnh9fvh53n4Kku2VUoWep0SFc6aZ/1c0T0NO/8uwN4DgQ8EX/9wEK1axMFqCd/P1O8XUVjkhNmshj6IpdfVYRgGCSYjEkxGdGnRNLAenkdOcak0QftofgFyi0urLe4ssTtQYnfgr0OHAQSmcjeIj6syRTs1zlLlLgQhRB4so4RKoYQoihBED/yCKyInsJLI06ldCu4fcynenL8NAJCdZ8eLczdi+pQroVbJk+1WUuaGgmOhlfG8xrIMTDod9GoNyioq4PZG3vvdotfj0RuuwVtLVuJQTh4AYEfWUbzx4wrcP3wQtOoIL/Ws7ONW4fbAqNPCoKEJ2NWJhuxHhmFg1rWEUdsEBbbNyLetkzLlXd5cHMyfjzh9BzSwDICSM15gb7FFFAX4+Qr4eecZ07Ap0/d89Bo1vnry4bAe/0L8fj8WLlyI1157DQMHDqzytREjRuCLL77AvffeW+1zlUrlWdWLnTt3xoEDB9CsWbNqn1NT+/fvR3FxMV566SWpN9y2bdvqtM/qNG3aVOoBeCp+4fP5sHXrVqmsODExEXa7HRUVFVIg61xZaufSvHlzaLVarF69utpS686dO+Orr75CUlKSrO3e5NqvSqW66ErVXbt2weVyScHXzZs3w2AwID09HXFxcVCr1Th+/Dh69+5d4322bt0a3333nVRFCwAbNmyA0Wg87+Trzp0747vvvkNGRgYUNbyx2bp16yr9D0+9hv/utybv+82bN+P222+v8vhcmZ01fY3jx4/HnDlzkJ2djQEDBtS6l+J/de7cGXl5eVAoFFWGRtVWXd4zQC1LreU2ZMgQDBkypNqviaKIOXPm4Omnn8a1114LIDDpJzk5GYsXL8bo0aNDudSwU3AcFBwHHU6fcE5lR1r0fpzMc0jl2rwgQBCFytLts/fFMAxuvakNnpu1CW43D5fbj0+/2ocJd3cM64W1CKCs3AOvT4DFqArrWhQch0ZJCWiUlIDe7QKp/26vt7I8OxCIPJJXgLJqmtILooiTRcU4WVSMP3YHUvrVSiUaJycis7JMOzMlGVaDfP2/CKnvGIYBx2jAsRoIIl/ZC9IVsZk4JDL065WBohInvvgh0E5j/6FivP7eFkx5oDs4mdp/FJW6kKrioJC5dyDHsYg3GeFwuVFeUSHrvuWgU6sxacRQvL/8V/xz9DgA4MDJHMz+/idMvHYojLrI77EniiJsFU5UuD0w6bTUp7gap7Mf1fDx9oj9m8sySqSYr0Ccvj1yyn5BqXO39LWSil0oc+5Dirk3Eo2Xga13w8xE6ZwZCEDqwDJUuVMdhmFq3GMxXJYuXYrS0lKMGzfurMzG66+/HvPnzz9n4DEjIwOrV69Gz549oVarYbVa8cwzz2D48OFo1KgRbrjhBrAsi127dmH37t1nDeQ4n0aNGkGlUuHNN9/Evffei927d+P555+v02utjl6vx3333SdNhW7UqBFmzZoFp9OJcePGAQAuu+wy6HQ6PPnkk5g4cSK2bNlSZep3TWg0Gjz22GOYOnUqVCoVevbsicLCQuzZswfjxo3DLbfcgldeeQXXXnutNMjn2LFj+P777zF16tTzBtPOR679ZmRkYN26dRg9ejTUajUSEhJqvAav14tx48bh6aefxtGjR/Hss8/iwQcfBMuyMBqNePTRR/HQQw9BEAT06tUL5eXl2LBhA0wmE+64445q93n//fdjzpw5mDBhAh588EEcOHAAzz77LB5++OHzJu888MAD+OCDD/B///d/mDp1KuLi4nDo0CF8+eWX+PDDD6uUm58yceJE9OzZE6+++iquvfZarFq1qkqZNYAav++/+eYbdOnSBb169cJnn32GP//8E/Pnz6/Ta7z55pvx6KOP4oMPPsDChQvP+7uoiQEDBqB79+4YMWIEZs2ahRYtWiAnJwfLli3DyJEja9QmAQi8Z7Zs2YKjR4/CYDAgLi6uVolVEZuCdeTIEeTl5WHAgAHSNrPZjMsuuwybNm0K48oiB8eyUCkV0Gs1SI43QK/RwKTTwWowIN5oQpLZggSTCfFGI+IMBpi0WmiUSig4FvFxGowa0VLa1979xVi/OSeMr+Y0p9OHwhIXeD6ySsg0KhVapadhSNdOuG/4IMwafxteHncr7h12FQZd2gEt0lKhVlZ/serx+XDwZA5Wbd+Fd5f9gsfmL8LUDz/FvKWrsHLbTuw/kR2RWSuERCOW4aDkDNAoE6FSWConsVK2EqnejVe3xoArM6XHW/7Kwcdf7JKtjFkQRBQWOyEIwTmnGbQaxBmNQARm5KmVStw3fCAua3W6Rc6xgiLM+nYJim32MK6sdnieR6ndgYKycjpXnwPHaiJ+8jUAqBRmZCTcgOZJY6BVJkvbBdGLnLJfsD93HmyuQ+fZQ2yTpmH7y8BT9UBUmj9/PgYMGFBtOfX111+Pbdu24e+//672ua+99hp++eUXpKenS1lbgwYNwtKlS/Hzzz+ja9euuPzyy/H666/XuhoyMTERCxYswDfffIM2bdrgpZdewquvvlr7F1gDL730Eq6//nrcdttt6Ny5Mw4dOoRVq1bBag0MkYuLi8OiRYuwfPlytGvXDl988QWmT59e6+NMmzYNjzzyCJ555hm0bt0aN910k9QTT6fTYd26dWjUqBGuu+46tG7dGuPGjYPb7a5TpqJc+33uuedw9OhRNG3atEqJNsMwFwzC9u/fH82bN8eVV16Jm266Cddcc02Vn9/zzz+PadOm4cUXX0Tr1q0xePBgLFu2DJmZmefcZ1paGpYvX44///wTHTp0wL333isFN8+nQYMG2LBhA3iex8CBA9GuXTtMnjwZFsu5qw0vv/xyfPDBB5g7dy46dOiAn3/++azj1PR9P2PGDHz55Zdo3749Fi5ciC+++KJKv9KLeY1msxnXX389DAZDlTaEF4thGCxfvhxXXnklxo4dixYtWmD06NE4duyYNIW9Jh599FFwHIc2bdpIrRJqtY6aTrUOtv9O0dq4cSN69uyJnJycKvX5o0aNAsMw+Oqrr6rdj8fjgcdzeuqjzWZDenp60Kdah5sgiMjOs9f4g40oBgbavPjmJvz1dz4AQK3mMG3q5UiIi4wsBIWCQbxVBwUXeR+mzkUQBOSUlOJoXiGO5AcG12QXl9ToAywDIDXeKpVnZ6YkoUF8XMz0l6Kp1iScAgNpXPALboiiP6jHirWp1sE+r4Z6qnV1eF7Ai29sxPa/86Rtd4xqhxFDWp7nWbWjVnFIStAHZZAaEGgRUl7hjMjAmCCK+GbdRqzeeTrLzGrQY/LIYUiNk2+aeKiolUqY9XooFVSWWh1ecEd09uMposijyPEXcst/Ay9UHTJo1rZEmnUQ1Iq4MK0uMgQG0WjAsVrqA0lIjDty5AhatGiBvXv3Rv1MjVCobgq8XPr3749LLrkEb7zxhuz7Dpca1RIsWbIEQ4YMOavhZCR68cUXMWPGjHAvI+RYloHFrEFJ6dnTmavDMAwUCgUeGNMFk6b9DEeFDx4Pjy++PoDHJ10OQRSkXpLh4veLKCqpQJxFB5UyOi52WJZFw4R4NEyIR6+2rQAEsh2PFxThSF6B1DOyxO4467kigJziUuQUl2LD3gMAAKVCgcZJCVWCkXFGA/WaIqSWAgNp9FBwegiCD37BVdmTLCLuvUW0+nBe5TgWj9x3OZ55eS0OHQ0MoPjk638QH6fDFZfJM3jC4+WRV+hAcoIenMxl10CgRUi8yQivzw+H2w2X14tq+62EAcswGHVlDxi0Wvy4aSsAoNRRgVnfLMHEa4cgMyUpzCusHY/Ph4Lycph0WhgvMGCgPuJYDVhGFdG9HwGAYTgkGrvCqrsEueW/ocixHafOCeWuA7C5DiHJ1APJpivAsRHelzRIAoNoHPDxFeBYNRSsDiwb+Z8HCSG1t3z5ctx9990UdAyj0tJSrFmzBmvWrME777wT7uXIqkYZjxzHIS8vD4mJieA4Drm5uUhKkvci8b8R48OHD6Np06bYsWMHOnbsKH1f79690bFjR8ydO7fa/dTXjEcgkMWYm++Az1+7O8xrNx3HnPf/lB7fdWtHDO0faKQqiCJ8/sBQG5/fX9k7MrQfZBgAJpMKBl3sXPSVVzhPD67JK8CR/MIaZ6mYdFpknApEJichIyUxKjIJKeORRBpRFMCLHvC8Sxo2IAfKeKwdt8ePgiJnRExoLit34/EXfkd+YaBnokLB4tlHeqFtK/mueVQqDimJ+qDfQOIFARXuwICUUEyyrKk1f+/BF7+vl0L+aqUC9w0bhDaNL67fVbiplEpYDXooqukjRaIn+xEAnN5cnCxdgQpP1fIxJWdCmuUqWHRt6cYvTmVBasGxGsqCJITUW8HIeMzIyEBpaSmmTZuGRx99VLb9RoIaBR5TUlLwwQcf4OqrrwbLssjPz6/SC0CWhfznFyeKIho0aIBHH30UjzzyCIDAh52kpCQsWLCgxsNlbDYbzGZzvQg8AoDL7UdBUe2azIuiiJff2oQtfwV6PKpVHF5/7iqkJhuq/X5BFOH1++Dz++Hjefh5PiRJFQadEmZTbAauBFFEfmlZlcE1J4pKavxhMcVqOSMQmYSGCXER9yGIAo8kkgmiv7K5vrvOH5BjLfD4X8E4rwqCiAqXD3a7p9Y3z+SWnWfHEy/8DrsjcDNIp1Xixaf6oFHa2f2yLpZOo0BiQmgGjAmCCIfbBYfLHRHBXQDYdjAL81f9Br7yHMexLMYP7o9LmzcJ88ouDsMwsOj10NVg4mx9JIoCfLwNvOC58DeHmSiKKHPuRnbZz/DxVfuQGtSNkWYdAp0qJUyrizRM5TAaLQ2jIYQQcl41CjxOnz4dzz33XI3u8tVmxLbD4cChQ4EGzp06dcLs2bPRt29faQLVyy+/jJdeegmffPIJMjMzMW3aNPz999/Yu3cvNJqaNa+ub4FHACgsdsLpql32TpnNjUlP/Qxb5QetVs3jMfPxPjWe6un1++Hx+cALpydrB+PzjU6nDPvE61Dx+f04XlgU6BeZV4DD+QUoKrfV6LkKjkOjxHhkpiRJ2ZGJZlNYf24UeCTRQBRFCKIHfsEN4SI/JFPgsW6cLh/KbG74fOELQO4/VIxnZ62Ft3IN8VYtXp7WD/FW+cpq1SoO8VYtlMrQ3CTieQGlDgc8Pvmye+tiz7ETmLf0Z3j9gZ6rDICb+12B3u2qb8oeDTQqFSwGfcz0ZpZbNGU/8oIX+bY/UGDbCBFnfrZhkGDoglRzXyg4XdjWF2lYRgmO04JjNPXiGp0QQkjt1Hi4zP79+3Ho0CFcc801+Pjjj2GxWKr9vmuvvbbGB1+zZg369u171vY77rgDCxYsgCiKePbZZ/H++++jrKwMvXr1wjvvvIMWLVrU+Bj1MfDI8wJy8h21nqC5cetJvPLOZunxmJva49rBNf9Zn0kQRfj9fnj8Pnh8fimrQQ4KBYM4ixZKRf27sLe7XJWByHwcyS/E0fwCVLhrFhzRazTITE4MBCMrsyMN2tBNn6TAI4k2osjDL7jBCy6IYs1vqlHgUR4ulw9ldg+83vD0Gt7yVzZefmuTdBMtI92MmY/3gV4nX2YPAyDOqoVBH7pWInZXIPsxEsqvD+fm480lK6qcx0Z074ohXTtFbfCCYRgYtBoYNNqgDRKKZqLIV/Z+jPzsRwDw+EqQXbYK5a4DVbZzrBYNzP0Qb7iUyo3PwDAsOFYLBaujnwshhBBJradaz5gxA1OmTIFOFx13+epj4BEA7BXeGg+aOdNr727B+i0nAABKBYvZzw1Aw9S6/9x8PA+Pzwev3ydLaTbDAGaTGnpt/S7tEEURBWU2qTz7SH4BThQWwc/X7ANlktkUCEJWBiLTE+OhVNRo5lStUeCRRDNe8FaWYntwoYE0FHiU+Xh2D8rK3WEZA7R89SF8sGin9Lh9myQ8/VAv2W98JcXroA3h+UwURbg8XpQ7nWEPQOYUl2LO4mUoc5xuEzOgUzvccEV3sFEafAQCw+aMWi30GnXUBlGDyS+44OcdUZH9CAA21784WboSHn9xle1aZTIaWofCoGkcppVFKoaG0RBCCJHUOvB4SmFhIQ4cCNz9a9mypew9H+VSXwOPAJBb4Kh1pojN4cGkp35GmS1wJ7p5EytefLKvrBM4RVEELwgQKv830C+Sv6isSJ1WAbNRTVkFZ/D5eWQXFePwqWBkXgEKyspr9Fyucir3qQnaGcmJSLZaZPnwR4FHEgtEUQAveMAL5x5IQ4FH+fl8PAqKnDW+qSKnhd/8gx+Wn8526t29ESbd1VX2YJLFpAl5H2NRFGFzuuBw1f5GpZyKbXbM+WEZ8s84V3Vv3QK39b8y4voV15ZSoYDVYIBSEd2vIxhEkYeXt190W4tQE0Q/Cu1bkFe+FoJYdSCgVdcWDSwDoVLUr88aNcEySig4HViGgvCEEFJf1Trw6HQ68eCDD+LTTz+V+jlyHIfbb78db775ZsRlQtbnwKPb45cmc9bGnzty8OIbG6XHt97QFtcPayXn0qoliCL8PA8/74fXz8Pr99UoM1LBMbBatFApqaTjXCrcbhzNL8TR/Moy7bwC2F3uGj1Xq1JVlmYnVgYkk2HS1b7PGQUeSawRRB/8vAuC6KmStUOBx+DgeQFFJS64Pf6QHRMIDGeZ+8GfWLf5hLTt+mEtcesN7WQ/ll6nREJc6K+j3F4vSuyOsA6fsTldeOPH5TheUCRta5/ZCHcPvQqqIGXihwrDMLAaDNCqQ1dSH038ggs+vx0XyiaPFD7ejuzSX1Dq/LvKdpZRItl0JZJM3cEy0f2eDYZAGbYOClZLZdiEEFLP1DrweM899+DXX3/FW2+9hZ49ewIA1q9fj4kTJ+Kqq67CvHnzgrLQi1WfA48AUFhUAae79h/S5n6wFWs2HgMAKBQsXn22Pxo3lG+iZ00IogiPzwe31ys1nz8XBoDFrIaunpde15Qoiii2O3AkLx9H8wpxOK8AxwsK4avhcKh4o6FKr8hGSQlQK8//s6fAI4lV/x1IQ4HH4HK5/Sgtc4V0+rXPx+O52euxe3+htO2e2zphcL+msh9Lp1UiIU4b8swgn59Hid0Ofy2GBMrN5fHi7Z9W4mB2rrSteYMUPHDN4Jg4fygVChi0mph4LXKLtuxHAHB4juNkyQq4fLlVtqsUVjS0DoZZ2zJMK4t0lWXYnI6mYRNCSD1R68BjQkICvv32W/Tp06fK9t9//x2jRo1CYWFh9U8Mk3B/QAo3n49Hbr6j1veQK5xeTHr6FxRX9ols0siCl6f1gyJMA138PA+nxwO3z3veLEizURXSJv2xxM/zyC4uqTK8Jq+ktEbvHZZhkJYQh8zkQDCySUoSUqwWsGdM9qTAI6kPRJEHL3hietppJJxXRVFEWbkbNof3wt8skwqnF0/+bw2OZ9sAACwDTH2wBy7r3ED2Y2nUCiTEaWVtc1ITgiCixOGAxxu6n+t/+fx+fLByNXZmHZW2NUyIx6QRQ2HWx8a/K47jYNBoqP9jNfy8Cz4+erIfRVFAccUO5Jathl9wVvmaSdMMadbB0CgTwrS6yHeqDJtjQzfskASIooh77rkH3377LUpLS7Fjxw507Ngx5OvIyMjA5MmTMXnyZNn2OWbMGJSVlWHx4sWy7ZMQUje1vqJ1Op1ITk4+a3tSUhKcTmc1zyDhpFRyMBpqH4jT61S4f+yl0uPDx8vw3dL9ci6tVhQcB5NOhwSjCSatFhqlEtVdq5fbvSgtd9d6ojcJ/IwbJyWid/s2GDOwL2bcNgpz7h2Lh68bjpE9uqFDk4xzfugTRBEnCouxbvc+LPx1LaYv+gaT31uA1777Cd9v2IIdh46gxO4I8SsiJPQYhovpoGOkYJhAi43kRD0UIQrO6XUqTHuoF+KtgVYTggjMfm8LDmQVX+CZtef2+JGT74DTVX0f0WBhWQYJJiO0YbxJpFQocM/Qq9CjzelssZNFxZj1zY8oLLeFbV1y4nke5RUVKCgrh9sb2t9xpFNwWmiU8WDZ6LiJzDAsEgyXonWDCUg0XIZADU6AzX0I+3PfQXbpL1EzxTvUBNEHr78cbl8RfHxF1AwbihabNm0Cx3EYNmzYWV9buXIlFixYgKVLlyI3Nxdt27YFwzAUrIswa9asAcMwKCsrC/dSCKmTWjcg6d69O5599lksXLgQGk3g7pTL5cKMGTPQvXt32RdI6s5kVMNe4at176bO7VJwVe9M/LL2CADgm6X70LVTKpo0tgZjmTXCsiy0ajW0arVUiu31+eD1+yFUvj6nyw+vl4fVooFKSc3c60KrVqFVehpapacBCNwdLXVU4EhegTRJ+1hBITy+s0vh3V4fDpzMwYGTOdK2BJMRc+4bC6vBELLXQAiJXRq1AqnJBpTb3LA7vEHPkUqI12HaQ73w5Iu/S+ea/83ZgBef6osGKUZZjyUIIgqLnbCaNTAZQxsItBr0gXNsmDIfOZbFHQN6w6DV4OftuwAAheU2vPz1j5g8cigaJsSHZV1y8/M8im02qFUqmHVaKKO8l6VcGIaDWmGNquxHBatFw7ghiDd0xsnSFXB4jgIARAgosG9AiXMX0ixXwaprT1mu1RBFHn7eAT9fQdOwZTR//nxMmDAB8+fPR05ODho0OJ2hn5WVhdTUVPTo0UP24/p8Pigv0IKJEFK/1DpNYO7cudiwYQMaNmyI/v37o3///khPT8fGjRsxd+7cYKyR1BHHsTAZL+7O8Zib2iMxPpC9w/Mi3vhwG3y+8PV/OhPLMNCqVDDr9Ug0mxFvNMKo1UKtVIAXRBQVu0JahlcfMAyDOKMBlzZvgut7XY5Hb7gGc+8di2duuQG39b8SvS5phYYJcee8qPb6/bDo9SFeNSEklrFsIPsxKVEPjgv+B/rG6WY89mAPKCqPZXN48fzr61Fmq9nArtoqLXejpNQV0sEvDMMg3miAXhO+8keGYXBDr8txXc/LpG02pxOvfrsEWTl5YVtXMHi8XhSUlaPIZqcMyDOcyn7k2Ohp06JVJaNZ0h3ISLgRSu50b3Q/78Cx4h/wb/5HcHpzzrOH+k4EL7jh8ZfA4ysBLwTn7+rFEkURft4Ztv9qcx5wOBz46quvcN9992HYsGFYsGCB9LUxY8ZgwoQJOH78OBiGQUZGBjIyMgAAI0eOlLad8uOPP6Jz587QaDRo0qQJZsyYAf8Z/fcZhsG8efNwzTXXQK/X44UXXqh2TQUFBbj66quh1WqRmZmJzz777KzvKSsrw/jx45GYmAiTyYR+/fph165d0tenT5+Ojh074r333kN6ejp0Oh1GjRqF8vLyc/4sPB4PJk6ciKSkJGg0GvTq1Qtbt24FEPidNmvWDK+++mqV5+zcuRMMw+DQoUPSa3zvvfcwfPhw6HQ6tG7dGps2bcKhQ4fQp08f6PV69OjRA1lZWVX2U5Of3YcffoiRI0dCp9OhefPmWLJkCQDg6NGj6Nu3LwDAarWCYRiMGTPmnK+TkEhW6x6PQKDc+rPPPsP+/YHS29atW+OWW26BVlv7SbfBFgm9qCKBIIjIzrNfVAny33sL8Owr66THwZrmKSdRFOH1++HyeiEyAixmDZQh+EBKAtxeH44XFuJIXgGO5AX+t9ThQJfmTTHj9pvCvTxCSB1E8nlVEEQUl7pCUqK8btNxvP7+n9LjZplWPP9Yb2jUwclaUypZJMbpoAxxJr/P70epowK+Cwx5C6b1u/fj09/WSR+6lQoF7h16FdplNgrbmoJJpVTCpNNecGhbfcILbvh4e1SV4gqCF/m2Dci3rYeIqjft4w2XItXcD0qObsZeCMNwULBaKCLgZ+XnnfjzyCNhO363zNdq3M7lo48+wrx587B161YsXboUkydPxr///guGYVBeXo433ngD77//PrZu3QqOC5xXkpKS8PHHH2Pw4MHgOA6JiYn4448/MHz4cLzxxhu44oorkJWVhbvvvhtjxozBs88+CyAQPEtKSsJLL72E3r17Q6FQoFGjs/8+Dx06FDk5OXj33XehVCoxceJE7NixA//73/+kHo9XXXUVtFotnnnmGZjNZrz33ntYsGABDh48iLi4OEyfPh2vvvoqLrvsMrz22muw2WwYN24cunXrJgUy/9vjcdKkSfj222/x4YcfonHjxpg1axaWLFmCQ4cOIS4uDv/73//w2WefYc+ePdJaJ02ahJ07d2Lt2rXSa0xLS8Ps2bPRsWNHPPbYY9i5cyeaNGmCqVOnolGjRrjzzjthsViwYsUKAKjxz65hw4aYNWsWunbtijfffBMfffQRjh07BrPZjB9//BHXX389Dhw4AJPJBK1WC7M5tANfCZHDRQUeo0kkf0AKNZvdg9Lyi7tz+P6nO7Dit8AdHJYBXny6H1o0iZNzeUEjCAK8vB9aHQeOi+m3e8QTRaBhYmyUyBFSX0XDedVm96Cs3B30As0flh/Awm/+kR536ZCKxyd0D9pQGIZhkJyog1oV2pLcU202XJ7w9anbcegIPlj5K/x8IPDEsizGXtUHl7VqHrY1BZtWrYZZpwv5kKFIJYoCfLw94rLgLsTjL0V26SqUu6r2SucYDVItfZFg6AKGodZAF6JRJoJhwvtvIZoCjz179sSoUaMwadIk+P1+pKam4ptvvpEGxM6ZMwdz5szB0aNHpecwDIMffvgBI0aMkLYNGDAA/fv3xxNPPCFtW7RoEaZOnYqcnBzpeZMnT8brr79+zvUcPHgQLVu2xJ9//omuXbsCAPbv34/WrVvj9ddfx+TJk7F+/XoMGzYMBQUFUJ/Ra7hZs2aYOnUq7r77bkyfPh0zZ87EsWPHkJYWaAW1cuVKDBs2DNnZ2UhJSakSeKyoqIDVasWCBQtw8803AwiUgp8aajNlyhTk5OSgUaNG2LhxI7p16wafz4cGDRrg1VdfxR133CG9xqeffhrPP/88AGDz5s3o3r075s+fjzvvvBMA8OWXX2Ls2LFwuVy1+tmdud+KigoYDAasWLECgwcPxpo1a9C3b1+UlpbCYrHU4DdPSGSiK5l6xGhQXXQT/ttHtUNKUuBOoyACb3y4Fd4IKbm+EJZloVGqAB8HnVILnUaNaifTkKCyGg0UdCSEhITJqEZKkgFKZXAvc0YMaYGh/ZtKj7ftysX7n+4IWlm0KIooKHLC7Qlt9uGpNhtWowEsG55Lx07NMjHx2qHQqAJZgIIg4KNVv+G3XbvDsp5QcHk8yC8rg73yQ2x9xzAsVAozVApz2ANQtaFWWNEkcTSaJt4GjeL0hGtedONk6Qrsz3sPdveRMK6QxJoDBw7gzz//xP/93/8BABQKBW666SbMnz+/1vvatWsXnnvuORgMBum/u+66C7m5uVUGy3bp0uW8+9m3bx8UCgUuvfT08NJWrVpVCabt2rULDocD8fHxVY535MiRKiXMjRo1koKOQGAGhSAIOHDgwFnHzcrKgs/nQ8+ePaVtSqUS3bp1w759+wAADRo0wLBhw/DRRx8BAH766Sd4PB7ceOONVfbVvn176f+fGrbbrl27KtvcbjdsNlutfnZn7lev18NkMqGgoOB8P05Cog51sa5HGIaByaRGSWntL2A1agUmjOuKp19aA1EEsnPt+Py73RgzukMQVhocIgCb3QerWYMUqw5OtwcVHg94PjoCqIQQQmpOpeLQINkIe4UX5TY3eF7+YCDDMLjz5o4oLnVhy1+B7IWf1x5BQrwON17dWvbjAYFy8vzCCmjUCljNGqhUocuU0qnV0ChVKHdWwOkOffZjq/Q0PHLd1Zj743I4XIGM1i/XbIDD5cbVl10ak0M7RFGErcIJl8cLq0FPA2gAcKwGLKOEl7dDiKJp0SZtUxg196HQ/idyy9dAEANrd/sKcKjgE1h0bZBmGQiVwhLehZJz4lgtumW+Ftbj18T8+fPh9/urDJMRRRFqtRpvvfVWrUp1HQ4HZsyYgeuuu+6sr2nO6AOsl6GHu8PhQGpqKtasWXPW14Kd7Td+/HjcdttteP311/Hxxx/jpptugk5XNbv0zIE5p8431W0ThEBmfk1/dv8dxMMwjLQPQmIFXb3UMwadEjabRypVqo02LRJw9cDmWLLqXwDAkp//RbfOaWjTIuECz4wspeVu8LwAq0ULo04Lt9cHp8cDt9cb0ub9hBBCgs+oV8GgU8Lu8KLc7rmoXsfnw7EMHrrnMjw7ay0OZJUAAD7/fg/irVr065Uh67HO5Pb4kVvggEGvgsWkDlk5LssysBoMYMCgwh36ktfGyYmYeuO1eP37ZSh1OAAAS7dsh8Plxug+PcHGYPARCPTaLCgrh06jhkmnAxemzNNIEZh8bYGfd8LHOxANk6+BwLqTTN1h1bdDTtmvKKnYKX2tzLkX5a6DSDFdgSRTD7AM9fiMNAzD1LjUOVz8fj8WLlyI1157DQMHDqzytREjRuCLL77AvffeW+1zlUrlWQkZnTt3xoEDB9CsWbM6ratVq1bw+/3Yvn27VGp94MABlJWVVTlWXl4eFApFleE2/3X8+PEqU7o3b94MlmXRsmXLs763adOmUKlU2LBhAxo3bgwgUGq9detWqa8kEOg/qdfrMW/ePKxcuRLr1q07a1+1JcfPTqUKDIilRBkS7er3VUs9dCrr8WLdfF1bpKUYAQT69b01f1vIS77kcOa0a41KiTijASlWK+KMRmjV6pjMmiCEkPqKYRiYjGo0SDZAp5H/nqtaxeHJST2RmmyQtr2zYDt27g7+9GVHhRc5+Y6QDNQ5k8WghyFMQwVTrBY8NupapMZZpG1r/t6D+StXwx/jH86cbg/ySwPl13SzFFBwOqiV8VEXpFNyBjSOH4EWyeOhU50uGRVFP3LLf8e+nLdR5txHv2NSa0uXLkVpaSnGjRuHtm3bVvnv+uuvP2+5dUZGBlavXo28vDyUlpYCAJ555hksXLgQM2bMwJ49e7Bv3z58+eWXePrpp2u1rpYtW2Lw4MG45557sGXLFmzfvh3jx4+vMpx2wIAB6N69O0aMGIGff/4ZR48excaNG/HUU09h27Zt0vdpNBrccccd2LVrF/744w9MnDgRo0aNQkpKylnH1ev1uO+++zBlyhSsXLkSe/fuxV133QWn04lx48ZJ38dxHMaMGYMnnngCzZs3R/fu3Wv1+qojx8+ucePGYBgGS5cuRWFhIRyVN9wIiTa1Djw2adIExcXFZ20vKytDkyZNZFkUCS6DTgnuIic8q1UcJo7vArby6bkFDiz6Njb6K7EsA61ahTijAalxVsSbTNBrNGHrZ0UIIUReHMciMUEPvU7+IIXJqMYzD/eCufLmHs+LmPX2Zhw5Xib7sf5LEEQUFjths4e27NSs1yHBbJImooZSnNGAKTdci4zkJGnb1oNZePunVfD4QhuEDbVT5dcOV3QNWQkWluGgVsZBwRkARNeNY726IVokj0OjuGuhYE+Xqnr5Mhwp+gpZhYvg9hWGcYUk2syfPx8DBgyotpz6+uuvx7Zt2/D3339X+9zXXnsNv/zyC9LT09GpUycAwKBBg7B06VL8/PPP6Nq1Ky6//HK8/vrrUvZgbXz88cdo0KABevfujeuuuw533303kpJO/w1nGAbLly/HlVdeibFjx6JFixYYPXo0jh07JvVUBALDZq677joMHToUAwcORPv27fHOO++c87gvvfQSrr/+etx2223o3LkzDh06hFWrVsFqtVb5vnHjxsHr9WLs2LG1fm3VkeNnl5aWhhkzZuDxxx9HcnIyHnzwQVnWRkio1XqqNcuyyMvLq/JHAgDy8/PRqFEjeMI48bA60TB9MxzKbR6U2S7+gvXTb/7B98tPN/B9buqVaNc66TzPiDyNG9a8v4nH54PL44XT46G7zxfJajRAp774bFtCSGSIlfNqmc2Ncpv81yyHjpTg6ZfWwuMNZN5ZLRq8/HQ/JMaHpjwvzqKB0RDav7WCIKLEbg9LwM/t9WHesp+x7/hJaVuT1GRMuGYw9Gf00IpFRp0WJl1kl32GmiD64fPbIIjRF3zmBTdyy9eg0P4ngDNbIrFIMl6GFHNvcGxsv6fPJxKmWpPwmz59OhYvXoydO3fKvu8//vgD/fv3x4kTJ6oEOgkhdVfjv95LlizBkiVLAACrVq2SHi9ZsgQ//PADnn/++fP2YiCRxWhQgWUv/q7w6BFtkJ52+gPnWx9tgyvEZV6hpFYqYTHokWK1wqTXhSW7gxBCiHwsJg2S4nWyt9ZolhmHKfdfLp1jS8vceG72H3BUeC/wTHmUlLlhD9GxTmFZBvGmQKuSUNOolJhwzWBc2vx01c3h3Hy88u1PKHNUhHw9JLxYRgGVwhqV2Y8cq0FD62C0Sr0XRs2ZVWQCCuybsDfnTRQ7dkAUaegEIXLyeDw4efIkpk+fjhtvvJGCjoQEQY0zHk+VmzIMc1bGl1KpREZGBl577TUMHz5c/lXWQaxkZgRDXbMes46WYurzv0mN+gf2zsR9Yy6Va3lBV5uMx+o4PR44XG74/NHX4zIcKOORkNgQa+dVj9ePgiKn7ENnfl57GPMW/CU9btMiAc8+egVUytDcuDLoVYizaELes9jmdMLudIX0mEBgiujnv6/Hut37pG3xJiMeGjkMSZa6ne8jFWU8np8g+uD12yCK0XedJooiyl37kV26Cl6+rMrXdKo0NLQOhV6dVv2TYxRlPBIgOBmPCxYswLhx49CxY0csWbIEaWn1698WIaFQ61LrzMxMbN26FQkJ0THJONY+IMlJFEVk59nB8xf/YeuLH/bg6yWnL/KfebgXOrU7u7FvJKpr4PEUn9+PCrcHLq8XgkB3oc+FAo+ExIZYPK96vTzyiypkDz7+9xzZo2tDPHLvZXWqOKgNpYJFQpwOKlVos/Sdbo80cTqURFHEks3bsOzP0wFfo1aLSSOGolFSdFy31gYFHi9MFEX4hQr4eSeiZfL1mQTBhwL7RuTZ/jgrgBqn74QGlv5QcoZzPDu2UOCREEKiV63/eh85ciRqgo7k/BiGgdlUt14xN1zdGpmNLNLjtz/ejgpnaEu8wk2pUMBi0EsDaWgqNiGERBeVikNKov6iB6+dy+gRbdCvV4b0eOPWk1jwVfVN/YPB5xeQV+AIWZn3KTqNGlajAQjxuZBhGFzbvStGXXl6Gqnd5cKr3/2Eg9k5IV0LiQwMw0DJGaBWWsEw8k+0DzaWVSLF3BttUh+ERdemytdKKnZgb86bKLBtgijG9jR3Qggh0a3WGY8AsHr1aqxevRoFBQVnZXh99NFHsi1ODrGYmSG3nDw7fP6Lz9Q7eqIMU2ashr8yc7Jfr8aYMK6rXMsLGrkyHqsjiiLcXh/cPi/cXh9lQoIyHgmJFbF8XvX5BRQUVsDPy/c32+8X8L+5G7Bjd7607c7/64CrBzaX7Rg1odMoYLVqoeBClzHk9HhQag995iMAbNp3EJ/8sgZC5WWukuNw19AB6NgkIyzrCQbKeKydaM9+BAC7+whOlq6A21dQZbtGkYC0uCEwaZqGaWXBRxmPhBASvWr913vGjBkYOHAgVq9ejaKiIpSWllb5j0Qfi7luWY8Z6RaMuvb0Xdjf1h/D1p31O7OAYRho1SpYDQakxlmRZLHAoA19ry1CCCE1p1SwSErUy1oKrVCwmHL/5WjS2CJt+/jLXdi49eS5nxQETrcfufmOkFYl6NRqWAz6kB3vTN1bt8D9wwdBWTkMzsfzeHfpz9i490BY1kPCT8p+VERn9iMAGDWZaJVyDxpah4BjTl+/u/1FyCr4FIcLv4THT5/HCCGERJZaZzympqZi1qxZuO2224K1JlnFcmaGnPIKHPB4L75Mg+cFPP7C7zh0JHCxYzVrMHfmQBgNKrmWKLtgZjyeiyCIqPC4UeH2gOfrV1kMZTwSEhvqw3nV7fGjoLBC1pyokjIXHp/5OwqLnQACQc7pU65AmxaJMh6lZrQaBeJCmP0YroEzAPBvdi7eWrISLu/pgOuNV3THVZ3bh2U9cqKMx4t3Ovsxeief+/gK5Jb/hmLH9irbGUaBZGNPJJt6gmUj9zq8tijjkRBColet/3p7vV706NEjGGshYVTXrEeOYzFxfFcoFYG3VGm5Gx9+tkOOpcUUlmVg1GqRbDEjzmiEWhU7F4SEEBIrNGpFnc+L/xVn0eKZR3rBoFcCCJR1v/jGRpzIscl6nJpwuf3IyXPA7vCE5HgmnS6Q+RiGrP/maal49IZrYNJppW3f/LEJP2zYgovoNkRixOnsx7iozX5Ucno0irsaLVPuhl7VUNouin7k2dZib+7bKHXuofc5IYSQsKt14HH8+PH4/PPPg7EWEkYatQI6Td0uvNIbmHDzdZdIj9dtPoFN27LrurSYdKoUO8FkRLLVAoNWC5alu7iEEBIpTEY14q1aWVtkNEw14YmJPaWbdI4KH56fvR4lZaHPBhRFESVlbuQVOODzBT8DX6/RINFkCsu5Lj0xHlNvvBYJJqO0bcW2nVj02zrqwVzPsawSakUcFFz0Zo7qVA3QPHkcGsePhOKMCdc+vhxHi77BoYKFcHkLzrMHQgghJLhqXWo9adIkLFy4EO3bt0f79u2hVCqrfH327NmyLrCu6kNJmFy8Xh65BXVrAs8LIp5+aQ32/1sMIPDBbe7Mq2Cp4/TsYAhHqfX5iKIIp8cDh8sNfwyWYVOpNSGxob6dVz1eP/ILnbJmDW3adhKvvLMZp3bZpJEFMx/vDa1Wef4nBgkDwGzSwGRUBb0XMc8LKLbb4fP7g3qc6pQ5KjBn8XLkFJdI2zo3y8S4Qf2hVHAhX09dUam1vHjBCx9vhyiG/r0pF17wIK98HQrtmyDizKA6g0RDN6RY+kDBas/5/EhGpdaEEBK9ah147Nu377l3xjD47bff6rwoOdW3D0h1VVTiRIXTV6d95OTZ8dCzv8Jb2TOye5c0TLn/8ogbrBJpgcczuTxeONxueH11+11EEgo8EhIb6uN51e3xo6BI3uDjTz//i4++2CU97nhJMp6a3BMKRfg+WCsVLCxmDXRBDoCKooiyigo43aEp9T5ThduDt5asQFbu6SnjrdLTcP/wgdBEWfsTCjzKL9D70VE5+Tp6uX1FyC5dCZv7UJXtClaHVEt/xOs7RV0QjwKPhBASvWodeIw29fEDUl34/AJy8+x1bqi/7NdD+PCzndLjh+/phisub1THvcorkgOPp3h8PtidLnhiIABJgUdCYkN9Pa+6PX4UFjshCPJdNi34chd+XPWv9Lhvz8aYMK5L2G/UadQKJMRpwQV5+IzT40GZoyLkPeg8Ph/eW/YLdh87IW1rnJSIiSOGwKiNnmwwCjwGTyD70QZRjN4KFFEUYXMfxMnSlfD+Z9K1VpWKdOtQ6NXpYVpd7VHgkRBCohf99SZVKBUs9Pq63/Ef0q8p2rY6Panz/UU7wtLDKtqplUokmE1INJujLhODEEJiiUatQEqiXtZJ0LePao+eXU8Phfh9wzF8sXivbPu/WG6PHzn5DtgrvBf+5jrQqdVINJuh4EJb5qxWKnH/1YNwWctm0rZjBYWY9c0SFNvsIV0LiUwcq4JaEQ8uSsuSgUAlmlnbEq1TH0CquT9Y5nQms8ubi4P583G06Hv4eHrPE0IICa6LKrU+3514KrWOfn5eQE6eo84ZCPmFFZj8zC9wuwO9crp0SMWTk3qEPZPjlGjIePwvnhfgcLvh9HiiriE+ZTwSEhvq+3nVzwvIzXfIlvno9fF47rU/sOdAkbTtvjs6Y2CfJrLsv660GgXirFpZA67/JQgiShwOeLzBDXSedVxRxNdrN+K3XbulbVaDHpNHDkNqnDWka7kYlPEYGrGQ/QgAXn85csp+RanznyrbWUaFFHNvJBovAxvBE74p45EQQqJXrf96d+zYER06dJD+a9OmDbxeL/766y+0a9cuGGskIabgWBgNdc+uS07UY8yo9tLjbbty8fuGY3Xeb33GcSzMeh2SLRaY9DqahE0IISGm4FgkxMkX7FEpOTw+oQfSG5wO4r638C9s25Ur2zHqwuX2IyfPgTKbW9Yy8zOxLIMEkxGGEJc5swyDm3r3wDWXd5G2lToqMOubJTiaR1OASUAg+zEuqrMfAUClMCMj4Xo0TxoLrTJF2i6IXuSU/YL9ufNgc/17nj0QQgghF0e2Ho/Tp0+Hw+HAq6++KsfuZFPfMzMuliCIOJlrr3PWoyiKeO619di5J9DEXadVYu7Mq2T90HaxojHj8b9EUYTL60WF2xPxg2go45GQ2EDn1QBHhRfFpfK1ECksduKxmb+htMwNAFCrODz/WG80bxIn2zHqimUZmAxqGA0qsGxwqhecHg9KHRVAiPs+rtm1B1+sWS/1uFYrlbh/+EC0btTwvM8LJ8p4DL1YyX4URQHFju3IKf8NvFD175hJ2wINLYOgVsaHaXXVo4xHQgiJXrL99b711lvx0UcfybU7EmYsy8BsrHuQiGEYPDD2Uui0gdINp8uHtz/aHvJG8rGKYZjKHlkmJFksMGg1lAVJCCEhYNCrkBSvky0Alxivw7SHekGrCZwvPV4eM+dsQG6BQ5b9y0EQRJTZ3MjOs8Pu8ATlXK5Tq5FoMoX8XNanwyUYN7i/dFyPz4c3l6zA9n8Ph3QdJLLFSvYjw7BIMHZFm9QJSDB0BXD675jNdRD7ct9BTtlq8ELoJ88TQgiJPbJd1W3atAkajUau3ZEIYDKqwHF1/0CVEK/DuJs7So937snHL2uP1Hm/pCqlgoNZr0eK1QKLQQ+lInL79BBCSCzQapVITTZApZJnOEpmIwsee7C7dO612T14fvZ6lNsi68O/IIgoKXMjJ88BRxAG0KiUCiSYTCHvCd2tZTM8ePUgqCrPn35ewPsrfsUfu/eFdB0ksjEMC5XCBJXCGvUZeApOh/S4YWiZcg8M6sbSdhE88m1/YF/uWyip+IcSBgghhNRJrUutr7vuuiqPRVFEbm4utm3bhmnTpuHZZ5+VdYF1RSVhdWOv8KJEhlIyURTx4hsbsXVnoGeVRqPA3OevQlKCvs77vlixUGp9IR6fDxVuD1xeb8jL1v6LSq0JiQ10Xj2bIIjIL6qA1ytP+eWajccw94Ot0uMWTePw3JQroVZH5g0lpYKF1aKVsjXl4vb6UGy3h/z8dTg3H2/8uAJOz+mA73U9L8OgSztEzIA8gEqtI4EoCvDxdvCCO9xLqTNRFFHm3I3ssp/PmnStVzdCQ+tQ6FQp53h28FGpNSGERK9a//U2m81V/ouLi0OfPn2wfPnyiAs6kroz6JSyTLJkGAb33tEZBr0SAOB2+/Hm/G1Ba1RPAtRKJeKMBqRYLTDpaBgNIYQEA8sySJSx7LpPj8a45fpLpMcHs0ow+70/wUfoOdPnF1BQVAGX2y/rfjUqJaz60N+gbJKajKk3XgOL/nRQ7/sNW/Dt+s0QKPOLnCGQ/WiGSmGO+qAYwzCw6tuhdeoEJJuuAIPTmdwVnuM4kPceTpQshZ93hnGVhBBCopFsw2UiFWVm1J1cWY8AsG7Tcbz+/p/S4/G3dMSwAc1k2Xdt1YeMx/8SRREujxcOtxs+v7wfEC+EMh4JiQ10Xj03l8uHwmIn5LiwEkUR7y7cgZ/XnO4xOLhfU9x9a8eIyro7U0KcFnqdSvb9Oj0elNpD3+uyyGbHnO+XoqDcJm3r3roFbh/QG1wE3MijjMfIEkvZjwDg8ZXgZNlK2FwHq2znWC1Szf2QYLg0pMFWyngkhJDoddF/vbdv345FixZh0aJF2LFjh5xrIhHGoFPK0usRAK64PB2XX5omPf70m3+Qmx85jfNjHcMw0GnUSLKYkWA2QUuBQEIIkY1Wq0R8nDxDJxiGwd23dkSXDqnStpW/ZeGH5Qdk2X800anVsBoNQIgDrgkmI6beeC3SE09P99207yDeXfYzvCG+eUci3+nsRysYJjLbItSGWhmHpok3o0niLVArTv8b4AUXTpYuw4G89+FwHwvjCgkhhESLWgceCwoK0K9fP3Tt2hUTJ07ExIkTcemll6J///4oLCwMxhpJmDEMA7NJnsFBDMPgnts7wWQIZER4vDzemL81YsvHYtnpMmwrDFpNxGbQEEJINNHrVEiM10GOv6gcx+KR+y5D8yZWadun3+7G2k3HZdh7dNGp1YgPQ/DRpNfhkeuvRvO00wHgXYeP4Y3Fy6v0gCTklFOTr5WcAZDlL0F4mbXN0Sr1PjSwXAWWOZ3R7PLl4d+Cj3G06Dt4/bbz7IEQQkh9V+vA44QJE2C327Fnzx6UlJSgpKQEu3fvhs1mw8SJE4OxRhIB5Or1CAAWkwb33N5Zerz/32Is/flfWfZNao/j2Mpp2FaY9XooOHmmsxJCSH2l0yqRkmSQ5bypUSvw1KReSEk63evwrflb8ffegjrvO9poVKqwBB91ajUmjRiKDk1OT/09mJ2L1777CbYK6ndHzsYwDBScHhplPDhWnpv34cQyCiSbeqJNgwmw6tpX+Vqp8x/sy30TeeV/QBApE5gQQsjZan1FvHLlSrzzzjto3bq1tK1NmzZ4++23sWLFClkXRyJHIOtRvrLcHl0botdl6dLjz77bjZO5dLc0nFiWgUGrQbLVgniTEWqlMtxLIoSQqKVScUhNNkAjwyRqs0mNaQ/1kqoF/LyIl9/aiKMnyuq872ijUakQZwh98FGlUODeYQPRo3ULaduJwmLM+uZHFNns53kmqc8Yhoup8mslZ0RGwnVonnwntMrTWcCC6ENu+Wrsy30b5a761w6CEELI+dU68CgIApTVBCSUSiUEQZBlUSQyGfQqKBXyNXW+69aOsJoDd4F9fgFvfLgVPE/voUigUamQYDYhyWKBTqMO+Qc8QgiJBaemXatUdc8kb5BixFOTe0r7crr8mPn6BhQV17+MO61aFZZp1xzL4var+uCqzqczvgrKbZj19WJkF5WEfD0kepwqv1ZwoX/fBoNB3QgtU+5CetzVULCnBxx5/aU4XPgFsgo+g9tXFMYVEkIIiSS1jiL169cPkyZNQk5OjrQtOzsbDz30EPr37y/r4niex7Rp05CZmQmtVoumTZvi+eefR4wP4o5oJqN8WY8mgxr3jTldcv3v4VIsXnHwPM8goaZUcLAaDEixWmDS6cBGwBRPQgiJJizLICleJ0vZdYum8Xjk3svAVt4LKi514bnX16PC6a3zvqONTqOGSR/6ic4sw+CGXpfjup6XSdvKKpx45dslyMrNC/l6SPRgGAZKzgC1Ii4msh8ZhkWC4VK0bjABiYZuOLOfpc39L/bnvoPs0l/AC9QLlRBC6rtaXwW/9dZbsNlsyMjIQNOmTdG0aVNkZmbCZrPhzTfflHVxL7/8MubNm4e33noL+/btw8svv4xZs2bJfhxSc3JnPXbt2AB9e57umfTl4j04dqJctv0TeXAsC6NOixSrBRYD9YEkhJDa4DgWSQk6sGzds8e7dWqAu27rJD0+kW3DS29ugs/H13nf0cao1cKglWeKeG0wDIPBXTritv5XSoPZnB4PXv9+GXYfrX+Df0jtsKyyMvsx9IHzYFCwWjSMG4pWKffCoM6QtosQUGDfgL25b6KkYhcljhBCSD3GiBdxFhBFEb/++iv2798PAGjdujUGDBgg++KGDx+O5ORkzJ8/X9p2/fXXQ6vVYtGiRTXah81mg9lsRnl5OUwmk+xrrI8cFV4Ul7pk21+F04tJT/8i7bNJIwtentYPChkDnNVp3NAc1P3HOqfHA4fLDZ+/Zo3ErUYDdGr5MmYJIeFB59WL5/b4kV9YIcu+Fn23G98t3S897nVZOh66u5sswc2LlRCnhV6nuvA3yqzE7oArTBOmt/97GPNXrYa/slUMx7IYO7AvurVsFvRjG3VamHSxEbyqrwTBBy9vgxgjQ1lEUUSZay+yS3+Gj6+aSKBXpaNh3BDoVA0uat8aZSIYhipvCCEkGl3UX2+GYXDVVVdhwoQJmDBhQlCCjgDQo0cPrF69GgcPBspvd+3ahfXr12PIkCHnfI7H44HNZqvyH5GXXqcEx8n3wUavU+GBsZdKjw8fL6vyYYpEJp1ajSSLGXFGI5SK6C8ZIoRUj86r8tGoFbINarvlukvQp0cj6fH6LSew6Nt/ZNl3tLEa9GEbiHZp8yaYeO1Q6fi8IGD+ytX4fdfusKyHRJfT2Y+x0fuRYRhYdZegTeoDSDH1BoPTFTIV3hM4kPc+jpf8BB8vzw0YQggh0aHGgcfffvsNbdq0qfYDR3l5OS655BL88ccfsi7u8ccfx+jRo9GqVSsolUp06tQJkydPxi233HLO57z44oswm83Sf+np6ef8XnJxGIaBUS9v5lqndim4qnem9PibpfuQdbRU1mOQ4NCqVUiymBFvogAkIbGIzqvyspg0MOjrnhXIMAzuH9sFHdokSdt+WHEQy389VOd9RxuGYcJ6E6xVehoeuf5qGLSBgXkigC/WbMDSLdupvJRcUKz1fgQAllUh1dIXrRs8CLO2dZWvFTu2Y1/Omyi0b4Eo1r8WEYQQUh/VOPA4Z84c3HXXXdWWVZnNZtxzzz2YPXu2rIv7+uuv8dlnn+Hzzz/HX3/9hU8++QSvvvoqPvnkk3M+54knnkB5ebn034kTJ2RdEwkwGlSyl3ONvak9EuMDJUM8L+KND7fWy55V0UqjOhWANEEVpswTQoj86Lwqv3irFjpt3f9OKhUspj7YHRnpp1uHfPj5Tmzenl3nfUcblmUQbzSCC1MP4ozkREy54RpYDQZp25LN2/DV2o0QKPhIaoBlldAo46HkjDhzUEs0UyusaJJ4E5om3gaNIkHazotunCxdgf1578HuPhLGFRJCCAmFGvd4bNy4MVauXInWrVtX+/X9+/dj4MCBOH5cvqba6enpePzxx/HAAw9I22bOnIlFixZJ/SUvhHpRBU+5zYMym1vWff6zrwDPzFonPb5+WEvcekM7WY9xCvV4DC6Pzwe70wWPzweAejwSEivovCoPQRCRV+iAzyfUeV8lpS48NvM3FJUEeiWrlCxmTLkSrZonXOCZ8gpXj8cz+fw8CsvLw5ZpWGJ3YM4Py5BXWiZt69ayGcZc1Uf2wWzU4zF2iSIPH2+PqYnQosij0P4ncsvXQBCrvi6L7hKkWa6CSmE55/OpxyMhhESvGv/1zs/Ph/I8WUwKhQKFhYWyLOoUp9MJlq26RI7jIAh1v0gndReMrMd2rZMwtH9T6fEPyw/gYFaxrMcgoaFWKpFgNiHRbIZGFd4PooQQEmlYlkFSgh4Kru4fpOOsWkx7uJeURen1CXhh7kZk59rrvO9oo1RwsBjC1y8vzmjAlBuvQUZyorTtzwOH8M5Pq6QbcYRcCMNwUCksUHIGxEr2I8NwSDJ1R5sGExCn71jla2XOPdib+xbyytdCEOnfCSGExJoaX+2mpaVh9+5zN8r++++/kZqaKsuiTrn66qvxwgsvYNmyZTh69Ch++OEHzJ49GyNHjpT1OOTisCwDk0H+DLbbbmyHlKTAhwZBBN6Yvw0eL5VcRyuVUoF4k5GyHQkh5D8UHIukRL0sA9sapZnxxMTuUCgCl3aOCi+ef309SsvlrUyIBjq1GjpN+M45Rq0WD183HK3S06Rtu4+dwJwflqHCHTsZbCT4FJweaoU1pjL9lJwBjeNHoEXyeOhUp/+NiKIfueW/Y1/O2yhz7qP+qIQQEkNqfBYbOnQopk2bBrf77AtYl8uFZ599FsOHD5d1cW+++SZuuOEG3H///WjdujUeffRR3HPPPXj++edlPQ65eMHIetSoFZgwriuYyt1m59rxxfc0HZIQQkjsUSpYJCfoZTmXtm2VhEnju0qP8wsr8MKcDXC5/XXed7Sx6PVh7TesUakw4Zoh6Nzs9OC8rNx8vPLtEpQ5aKIvqbnA5Ot4sGxs3cDVqxuiRfI4NIq7Fgr2dJayly/DkaKvkFW4CG6fvNV0hBBCwqPGPR7z8/PRuXNncByHBx98EC1btgQQ6O349ttvg+d5/PXXX0hOTg7qgmuLelEFX5nNjXKb/HfwP/5yF5as+hcAwDDAzMf7oE0L+fpVUY9HQgipPTqvBofH60d+oVOWLJ8fVx7Egq/+lh53bpeCJyf1ACdDWff5REKPxzOJoogSuwNurzdsaxAEAZ/9vh5/7N4nbUswGTF55DAkWep2HUI9HusfP++Cj7cjMDs9dvCCG7nla1Bo/xPAmS21WCQaL0OquTf06vSYyvwkhJD6pMaBRwA4duwY7rvvPqxatUq6MGYYBoMGDcLbb7+NzMzMC+wh9OgDUvDxvIDsPIfsJREeL49Hpv8q9ahKSdLj9eeugkatkGX/FHgkhJDao/Nq8Lg9fhQUVtQ5pCCKIuZ/vgvLfj0kbRtwRQbuH3spGCZ4/eIiLfB4SondAZcnfCXOoihi8aatWLF1h7TNpNNi0ohhSE+Mv+j9UuCxfhJEP7z+cohi7GUyu3wFyC5dCbv7cJXtClaPxvEjkWTqTsFHQgiJQrUKPJ5SWlqKQ4cOQRRFNG/eHFarNRhrkwV9QAqNklIX7BXyZxQczCrGEy/8DqHyXTq0f1PcdWsnWfZNgUdCCKk9Oq8Gl8vlQ2Gxs87BR14Q8dq8zdi0LVvaNnpEG9x0bZs67vncIjXwKIoiim32sA93+eWvv/HNH5ukx4Fy7MFonnZxPdIp8Fh/iaIIv1ABP+9ErGU/iqKIctd+ZJeugpcvq/I1gzoDl6RNAsdqwrM4QgghF+WibhlZrVZ07doV3bp1i+igIwkdo1EdlJl7LZrGY+TQltLj5auz8M++giAciRBCCAk/rVaJhPi6B5M4lsGku7qhVfPTGXVfLt6L1X8crfO+ow3DMIgzGqHguLCu46rO7THmqj5gK7NO3V4v5vywDH8fPhbWdZHowzAMlJwBaqUVDCNPJVCkYBgGFl1rtE59AKnmvlVen5IzUtCREEKiEOWqE1koFSx0uuA0cb/p2jZolHY6q+bN+dvgdIU3a4EQQggJFp1WCau57h+u1SoOT0zsgbQUo7TtnQXb8dc/eXXed7Rh2UDwMZil5jXRo01L3Dt8oBQE9fE83lm6Cpv2HQzrukh0Yhkl1Io4KDg9EJQUgPBhWSVSzL3RJvVBWHSXgIECGQk3hHtZhBBCLgIFHolszKbg3IFUKjlMHN8VHBe4oCosduKTM5rmE0IIIbHGZFRDp6l7JpPJoMYzj/SSApmCIOKVtzch62hpnfcdbZQKDlaDIdzLQMcmGZg0Yig0qkBZuiCK+Pjn3/HrDrq2IbUnZT8qrGCY8Gb1BoNKYUFmwo3o1OgZaFVJ4V4OIYSQi0CBRyIbpYKFPkhZj00zrLhheCvp8c9rj2BHPczYIIQQUn/EWbVg2bpnMSUl6PHU5J7QqANBCbeHx8zX16OgqKLO+442WrUKBq023MtAy4YNMOWGq2E8Yy1fr9uExRv/lH1YH6kfWDaQ/Rirpchq5cUPYiKEEBJeFHgksjIb1UHb9w3DW6NJI4v0+O2Pt6PCKf9AG0IIISQScBwrS8k1ELiBN+WB7lL1QJnNg+deWw+bI3zTnsPFrNdBrQr/EJz0xARMvfFaxBtPZ2Eu37oDn/32BwRBCOPKSLRiGBYqhRlKzoRYK70mhBASvSjwSGSlVHKylIZVR6FgMXF8VygqPzQVl7rw0Re7gnIsQgghJBIY9Cpo1PKcVzu3S8F9d1wqPc7Os+PFNzbC4+Vl2X80sRr04MI8bAYAkq1mPDZqBBrEx0nb1u3eh/dXrIbPX/9+L0QeCk4LtTIOLBOcSiRCCCGkNijwSGRnMgUv67Fxuhk3jWgjPf5t/TH8uSMnaMcjme3OUQAAMaZJREFUhBBCwi3OqpVtKEr/KzIw+ozz6P5/izHn/T/BC/WrvJdjWSSYjGDZ8F8KWwx6TLnhajRJTZa2/XXoMN5asgJuLw3TIxeHZRRQK+Og4Ayg7EdCCCHhFP6rLRJz1CqFbNkZ1Rk5pCWaN7FKj9/95K96WSpGCCGkflAqWFgt8vVtG3VNawy4MlN6vHl7Nj7+Yle96y2o4DgkmEwREXzUazR4aOQwXNI4Xdq270Q2Zn//E+wuVxhXRqKdktNT9iMhhJCwCv+VFolJ5iBmPXJcoORaqQi8fUvL3fhw0c6gHY8QQggJN6OMJdcMw+Ce2zqhc7sUaduyXw9hyap/Zdl/NFEqOCSYjLJllNaFWqnEA1cPQrcWzaRtR/ML8co3S1Bid4RxZSTancp+VFL2IyGEkDCgwCMJCo1aAbUqeL2TGqaacMv1baXHf2w5gY1bTwbteIQQQki4xVm1soUMFAoWj95/OZpmnK4gWPDV31i/5YRMR4geSoUCcWcMeAknBcfhzsH90Kf9JdK2vNIyvPz1j8grLQvfwkhMUHB6qJXxYNnwD1cihBBSf1DgkQSN2SRfWVh1hg9sjlbN46XH7y38C2U2d1CPSQghhISLUsHCaJAvYKDVKPD05J5ITtRL2+Z+uBW79xfKdoxooVGpYNbrL/yNIcAyDP6vT08Mv+z0IKBShwOzvvkRx/Lr3++GyItlOKgVVigVJjAMfRQkhBASfHS2IUGj1SigCmLWI8cymHBnF+kYNocX7y3cUe96VBFCCKk/TEa1rGXBFrMG0x7qBYM+END0+wW89OZGHM8ul+0Y0cKg1cCgDe5N05piGAbXXN4Fo/v0lLY5XG68+t1P2H8iO4wrI7FCwWqhVsSDY7XhXgohhJAYR4FHElSWIGc9Nkgx4vYb20mPN2/PrpdlYoQQQuoHjmNhkbmPclqqEU9N6gGVMnBZWOH04fnZ61FcWv+Gmpj1emhUkVOG2q9DW4wf3F8agOPx+fDGj8vx16HDYV4ZiQUMw0KlMEGlsIJhgjcYkhBCSP1GgUcSVFpNcCdcA8CQfk3RtlWi9Pj9RTtQUlb/PiwRQgipH4wGFZRKeS/hWjVPwEP3XIZTyZRFJS7MfH09nC6frMeJBnFGA9QRFHzs1rIZHrx6EJSKwPWUnxfw3vJf8fuu3WFeGYkVHKuCWkHDZwghhAQHBR5J0FnNwc16ZFkGE8Z1gUYTuCB3VPgwb8FfVHJNCCEkJjEMg6QEPRScvJdxl1+ahvE3d5QeHz1RjllvbYLPL8h6nEjHMAziIyz42DajER4eOQw6dWBNoiji/eW/4ts/NoV5ZSRWMAwDBaeHRhkPjpU3q5oQQkj9RoFHEnQqFQe9ThnUYyQl6DH2pvbS4227cvH7hmNBPSYhhBASLgqORVKiHhwnb3bS0AHNMHJIC+nxrr0FeOfjbfXuZt6p4OOpLMNI0LRBCh694RqY9Tpp28c//46lW7aHcVUk1jAMB5XCApXCTMNnCCGEyILOJiQkzCZN0As3ruqdiY6XJEuP53++E0XFziAflRBCCAkPpYJFUrxe9vPrrTe0wxWXpUuP12w8js++3yPzUSIfwzCIMxqk/oqRoGFCPKbeeC0SzSYAQKPEBFzZrnWYV0ViEcdqaPgMIYQQWUTOlRSJaUoFC6MhuCVLDMPggbGXQqcNZCc4XX68/fH2epelQQghpP5QqThYrfIGBk61MDmzf/J3S/dj5e9Zsh4nGig4DlaDIdzLqCLRbMLUG6/Fpc2b4Pk7RsOk0134SYRchKrDZ7hwL4cQQkiUosAjCRmjUR30rMeEeB3GndGfaueefPyy9kiQj0oIIYSEj1Gvkn2Qm1LJ4fEJ3dEozSRt++DTHdi6M0fW40QDjUoZccE9s16HR2+4Bglm04W/mZA6OjV8hrIfCSGEXAwKPJKQUXDBz3oEgL49G6NLh1Tp8cdf/Y2CooqgH5cQQggJlziL/C1N9DoVpj3UC/GVGZWCCLw6bwsOZhXLfKTIZ9RpI2rYDCGhdjr7kXo/EkIIqR06a5CQMhiCPyWPYRjcN6YzDPrABwS3248352+DIFDJNSGEkNikVHKIk7nkGghUEkx7qJfUxsTr5fHCnA3IzXfIfqxIF2cwQMFRuSmp3071fmRp8jUhhJAaosAjCSmlgoVOG9wJ1wAQZ9Hi7ls7So937y/Eit/qX28qQggh9YdBrwrKObZxuhmPPdgDisoJ2jaHF8/N/gNlNrfsx4pkLMsgzmgEwwS7cQwhkY1hWKgVFig5IxD0RkqEEEKiHQUeSciZjKEpVep1WTouvzRNerzwm3+Qk2cPybEJIYSQcIi3asFx8gcC2rdJwoRxXaXHeQUVeGHOBrg9ftmPFcmUisgbNkNIuCg4HdTKODCMvD1mCSGExBYKPJKQU6sUsjfBrw7DMLjn9k4wGQOlIF4vjzfnbwNPJdeEEEJiFMsyiLcEZwDEld0b4bYb2kqPDx0pxWvztoDnhaAcL1Jp1SoYdTRkgxAAYBkF1Io4KLjIGsBECCEkclDgkYSFKQRDZgDAYtLg3ts7SY/3HyrG0p//DcmxCSGEkHDQapVSn2O5jRzaEkP6NZUeb9uVi/cX7YQo1q+beiadDlo19bgjBAjc7FdyRqgUFho8Qwgh5Cx0ZiBhodUqoVKFpkF79y4NccVl6dLjz77bjRM5tpAcmxBCCAkHq1kDpUL+yzyGYTDulo64rHMDadvPaw7ju2X7ZT9WpLMa9FAqqMSUkFM4Vk2DZwghhJyFAo8kbCwmTciONf7WjrCaA8fz+QW8OX8r/PWsNIwQQkj9wbIMEuN1YFn5+z1yLIOH7u6GFk3jpG2ffbcHK38/LPuxIhnDMLAaDDRshpAz0OAZQggh/0WBRxI2Wo0C6hBlPZoMatw3prP0+N/DpVj49T8hOTYhhBASDkolh8T44PRdU6sVeGpST6Qmnx608tKbG7F5e3ZQjheplAoOFr0+3MsgJOIEBs9YafAMIYQQCjyS8LKYQ5f12LVjA/Tr1Vh6/O7Cv/DvkZKQHZ8QQggJNY1aAa0mOB/8TUY1nnm4F8ymQFklz4uY8txqHMwqDsrxIpVOo4ZOQ6WlhPwXyyihVsSBY2kYEyGE1GcUeCRhpVGHZsL1KXf+XwfEWwMXP36/gGdnrYPPx4fs+IQQQkionQoMBkNKkgFPTeopVTAkxuug14VmgFwksRoMUKvq3+sm5EIYhoFKYYJKYaXBM4QQUk/RX38SdhZz6LIE9DoVHhh7KQBAreIw7Kpm4Dj6Z0AIISR2qVUK6HXKoO2/eZM4PHr/5ehwSRI+mjMcaanGoB0rksUZDDRshpBz4FgV1Ip4cGzoqp0IIYREBro6ImGnVgXKwFxuf0iO16ldCsaMbo9rBjZHRrolJMckhBBCwslq1sDl9kMQxKDsv0uHVAzqkwmDvv6WHLNsYNhMQXk5IAbn50xINGMYFiqFGbygho+3QxRp0CMhhNQHlOpFIkIoJ1wDwLWDWlDQkRBCSL3BcSziLME919J058CwGbMuOAN9CIkVHKuh7EdCCKlHKPBIIoJKxUGnDV4ZGCGEEFLf6XUqOteGgEGroX6PhFzAqexHlcJMvR8JISTG0V95EjHMxvpbnkUIIYSEQpxFA5alzMRgsxr0YFm6zCbkQij7kRBCYh9dEZGIQVmPhBBCSHCFouSaABzLIt5oBKj8nJALouxHQgiJbfSXnUQUynokhBBCgkuvU0GnofmCwaZSKmDSacO9DEKixunsR/o8QAghsYQCjySiqFQcfRgihBBCgsxq1VLJdQgYtVpo1RREIaSmAtmPFigVJsp+JISQGBHxf82zs7Nx6623Ij4+HlqtFu3atcO2bdvCvSwSROYQT7gmhBBC6hsFx8JqpvNtKFj0eig4LtzLICSqKFgt1Io4sJT9SAghUS+iU8tKS0vRs2dP9O3bFytWrEBiYiL+/fdfWK3WcC+NBNGprEen2x/upRBCCCExy6BXwenywUXn26BiWQZxRiMKy8shimK4l0NI1GAYDmqFBX7BFe6lEEIIqYOIDjy+/PLLSE9Px8cffyxty8zMDOOKSKiYTGoKPBJCCCFBFmfVIifPQQGxIFMqOFgNBpTY7eFeCiFRR8FSr1RCCIlmEV1qvWTJEnTp0gU33ngjkpKS0KlTJ3zwwQfnfY7H44HNZqvyH4k+apUCWur1SAghYUfn1dgWKLmmUsZQ0KpVMNKwGUIIIYTUMxEdeDx8+DDmzZuH5s2bY9WqVbjvvvswceJEfPLJJ+d8zosvvgiz2Sz9l56eHsIVEzmZTfRBiBBCwo3Oq7HPaFBDpaIehKFg0umgVqnCvQxCCCGEkJBhxAiurVGpVOjSpQs2btwobZs4cSK2bt2KTZs2Vfscj8cDj8cjPbbZbEhPT0d5eTlMJlPQ10zkVVBUEbTeU40bmoOyX0IIiSV0Xq0fPF4/8goq6rSPhDgt9DoKql0ILwgoLLeB5/k67ceo08Kk08m0KkIIIYSQ4IjoWtbU1FS0adOmyrbWrVvju+++O+dz1Go11GrKlIsVZpOamt4TQkgY0Xm1flCrFDDqVbBXeMO9lJjHsSziDAYU2mxA5N7/J4QQQgiRRUSXWvfs2RMHDhyosu3gwYNo3LhxmFZEQk2tUkCjjuj4OCGEEBITrBYNFFxEXxrGDJVSAYueshUJIYQQEvsi+uryoYcewubNm/G///0Phw4dwueff473338fDzzwQLiXRkKIej0SQgghwccwDOLjaPhJqOg1Gmgpm5gQQgghMS6iA49du3bFDz/8gC+++AJt27bF888/jzlz5uCWW24J99JICGnUlPVICCGEhIJGrYDJQH0aQ8Vq0IPjaLAPIYQQQmJXxEdzhg8fjuHDh4d7GSTMTEY13B7q9UgIIYQEm9mkQYXLB56n/oPBxjAMrAY9ispt4V4KIYQQQkhQRHTGIyGnaDUKqFWUEUAIIYQEG8sysJo14V5GvaFWKqHX0M+bEEIIIbGJAo8kaphNdFFOCCGEhIJep6IbfiFk0umo5JoQQgghMYkCjyRqaDUKqOhDECGEEBIScRYtmHAvop5gWQYWvT7cyyCEEEIIkR0FHklUsRhp+iMhhBASCioVByOdd0NGo1JCp6GfNyGEEEJiCwUeSVTRapWU9UgIIYSEiMWkhlJJl4uhYtbpwbL08yaEEEJI7KArGxJ1KOuREEIICQ2GYZAYpwPDUNF1KLAsA6vBEO5lEEIIIYTIhgKPJOpotUrKviCEEEJCRKnkEGehAW+hQiXXhBBCCIklFL0hUclCE64JIYSQkDHoVdBpFOFeRr1h1ulpyjUhhBBCYgIFHklU0lHWIyGEEBJSFrOGplyHCE25JoQQQkisoMgNiVqU9UgIIYSEjlLJQa9XhXsZ9QaVXBNCCCEkFlDgkUQtynokhBBCQstiUtOgmRCiKdeEEEIIiXZ0JUOimpkmXBNCCCEhw3EsLCY694YKyzJIMJko+EgIIYSQqEVXMSSq6XUqKBX0NiaEEEJCxWRUQ62iwSeholRwSDAZKfhICCGEkKhEVzAk6pkp84IQQggJqYR4HZVch5BSoYDVQMNmCCGEEBJ9KPBIoh5lPRJCCCGhpeBYxFtpyFsoaVQqGjZDCCGEkKhD0RoSE0zU6/H/27v38KjqO4/jn8ltkpBMQi7kAiHcgxJAQMCoXLakEpatUdtCI08FS1UEq1ZFKlhDcRW67orVpTxYDdpVuWwL2FLECxBBbg1CgshNIjc1iMUmIQIJId/9wyezjElIlCGZDO/X8+R5mHN+c+b7Pb+T8818OWcGAIBm1SY8RG3Cg1s6jMtKVHgbBQZymzsAAGg9aDzCL0S0CVFQIIczAADNKSY6jPrbjAICHNxyDQAAWhX+UoTf4LMeAQBoXgEBDsXGhLV0GJcVZ3CwIsK4zR0AALQONB7hN9qEB3PVBQAAzSzUGcRHnjQzV3i4grjlGgAAtAJ0aeA3HA6HXFz1CABAs4t2ORUSTCOsuTgcDoU7+ZsHAAD4PhqP8CsRXPUIAECzczgcCqbxCAAAgG+gQwO/wlWPAAAAAAAAvoHGI/xORHiwAgMdLR0GAAAAAADAZY3GI/yOw+GQK4KrHgEAAAAAAFoSjUf4pciIEAUEcNUjAAAAAABAS6HxCL/EVY8AAAAAAAAti8Yj/FZkRIgcDq56BAAAAAAAaAk0HuG3AgIcckWGtHQYAAAAAAAAlyUaj/BrkW246hEAAAAAAKAl0HiEXwsMDFBkm+CWDgMAAAAAAOCyQ+MRfi8y0imueQQAAAAAAGheNB7h94ICA9SmDZ/1CAAAAAAA0JxoPOKy4OKqRwAAAAAAgGZF4xGXheCgAIWH81mPAAAAAAAAzYXGIy4bUZHOlg4BAAAAAADgskHjEZeN4OBAhYdx1SMAAAAAAEBzoPGIy0q0i6seAQAAAAAAmgONR1xWuOoRAAAAAACgedB4xGWHqx4BAAAAAAAuPRqPuOwEBwcqPDSopcMAAAAAAADwa62q8Thnzhw5HA7df//9LR0KWjkXVz0CAAAAAABcUq2m8VhQUKAFCxaoT58+LR0K/IAzhCseAQAAAAAALqVW0XisqKjQuHHj9Ic//EFt27Zt6XAAAAAAAAAANKJVNB6nTJmi0aNHKzMzs6VDAQAAAAAAANAEPn+/6eLFi7V9+3YVFBQ0aXxlZaUqKyvdj8vLyy9VaAAA+D3qKgAAAIDvyqeveDx69Kjuu+8+vfrqqwoNDW3Sc2bPnq2oqCj3T0pKyiWOEgAA/0VdBQAAAPBdOczMWjqIhqxYsUI333yzAgMD3cvOnTsnh8OhgIAAVVZWeqyT6r8yIyUlRWVlZXK5XM0WOwAA/oC6CgAAAOC78ulbrUeMGKEPPvjAY9ntt9+unj17atq0aXWajpLkdDrldDqbK0QAAPwadRUAAADAd+XTjcfIyEilp6d7LGvTpo1iY2PrLAcAAAAAAADgO3z6Mx4BAAAAAAAAtE4+fcVjffLz81s6BAAAAAAAAACN4IpHAAAAAAAAAF5H4xEAAAAAAACA19F4BAAAAAAAAOB1NB4BAAAAAAAAeB2NRwAAAAAAAABeR+MRAAAAAAAAgNfReAQAAAAAAADgdUEtHcClZmaSpPLy8haOBACA7y4yMlIOh6Olw6CuAgD8gq/UVQDwd37feDx58qQkKSUlpYUjAQDguysrK5PL5WrpMKirAAC/4Ct1FQD8ncNqL13wUzU1Nfrss8+89j9a5eXlSklJ0dGjR1t9ofKnXCT/ysefcpHIx5f5Uy6Sf+fTvn17n7gyw5t11Z/ni3x8iz/lIpGPL/OnXCT/zsdX6ioA+Du/v+IxICBAHTp08Pp2XS6XXxRfyb9ykfwrH3/KRSIfX+ZPuUj+mY+vvDm6FHXVH+eLfHyTP+UikY8v86dcJP/Mx1fqKgD4O75cBgAAAAAAAIDX0XgEAAAAAAAA4HU0Hr8lp9Op3NxcOZ3Olg7lovlTLpJ/5eNPuUjk48v8KReJfFobf8uPfHyXP+UikY8v86dcJPIBAFw8v/9yGQAAAAAAAADNjyseAQAAAAAAAHgdjUcAAAAAAAAAXkfjEQAAAAAAAIDX0XgEAAAAAAAA4HU0Hr+FefPmqVOnTgoNDdXgwYP197//vaVDqmP27NkaOHCgIiMj1a5dO910003at2+fx5jhw4fL4XB4/EyaNMljzJEjRzR69GiFh4erXbt2mjp1qqqrq5szFUnSzJkz68Tas2dP9/ozZ85oypQpio2NVUREhH74wx/q888/99iGr+TSqVOnOrk4HA5NmTJFku/Py/r16/WDH/xAycnJcjgcWrFihcd6M9Njjz2mpKQkhYWFKTMzUx999JHHmC+//FLjxo2Ty+VSdHS0Jk6cqIqKCo8xO3fu1JAhQxQaGqqUlBT9x3/8R7Pnc/bsWU2bNk29e/dWmzZtlJycrNtuu02fffaZxzbqm9M5c+Y0ez6Nzc2ECRPqxJmVleUxprXMjaR6f48cDoeeeuop9xhfmZumnJO9dR7Lz89X//795XQ61a1bN7300ktez8fbqKvU1YtBXW09527qqu/OjURd9ae6CgA+ydAkixcvtpCQEMvLy7MPP/zQ7rjjDouOjrbPP/+8pUPzMHLkSFu4cKHt2rXLCgsL7V//9V+tY8eOVlFR4R4zbNgwu+OOO6ykpMT9U1ZW5l5fXV1t6enplpmZaTt27LBVq1ZZXFycPfLII82eT25urvXq1csj1i+++MK9ftKkSZaSkmJr1qyxbdu22TXXXGPXXnutT+Zy/Phxjzzefvttk2Tr1q0zM9+fl1WrVtmMGTNs2bJlJsmWL1/usX7OnDkWFRVlK1assKKiIrvxxhutc+fOdvr0afeYrKws69u3r23ZssU2bNhg3bp1s5ycHPf6srIyS0hIsHHjxtmuXbts0aJFFhYWZgsWLGjWfEpLSy0zM9OWLFlie/futc2bN9ugQYNswIABHttITU21WbNmeczZ+b9rzZVPY3Mzfvx4y8rK8ojzyy+/9BjTWubGzDzyKCkpsby8PHM4HFZcXOwe4ytz05RzsjfOYx9//LGFh4fbAw88YLt377bnnnvOAgMDbfXq1V7Nx5uoq9TVi0VdbT3nbuqq786NGXXVX+oqAPgqGo9NNGjQIJsyZYr78blz5yw5Odlmz57dglE17vjx4ybJ3n33XfeyYcOG2X333dfgc1atWmUBAQF27Ngx97L58+eby+WyysrKSxluHbm5uda3b99615WWllpwcLD97//+r3vZnj17TJJt3rzZzHwrl2+67777rGvXrlZTU2NmrWtevvlHa01NjSUmJtpTTz3lXlZaWmpOp9MWLVpkZma7d+82SVZQUOAe88Ybb5jD4bBPP/3UzMx+//vfW9u2bT3ymTZtmqWlpTVrPvX5+9//bpLs8OHD7mWpqak2d+7cBp/TEvk09AYpOzu7wee09rnJzs62733vex7LfHFuzOqek711Hnv44YetV69eHq81duxYGzly5CXN52JQV6mr3kZdbV3nbuqq784NdbV11lUA8FXcat0EVVVVev/995WZmeleFhAQoMzMTG3evLkFI2tcWVmZJCkmJsZj+auvvqq4uDilp6frkUce0alTp9zrNm/erN69eyshIcG9bOTIkSovL9eHH37YPIGf56OPPlJycrK6dOmicePG6ciRI5Kk999/X2fPnvWYl549e6pjx47uefG1XGpVVVXplVde0c9+9jM5HA738tY0L+c7ePCgjh075jEXUVFRGjx4sMdcREdH6+qrr3aPyczMVEBAgLZu3eoeM3ToUIWEhLjHjBw5Uvv27dM///nPZsqmfmVlZXI4HIqOjvZYPmfOHMXGxqpfv3566qmnPG7T8aV88vPz1a5dO6Wlpenuu+/WiRMnPOJsrXPz+eef629/+5smTpxYZ50vzs03z8neOo9t3rzZYxu1Y3y1RlFXqaveRl39Wms5d0vUVV/K5XzU1dZZVwHAlwW1dACtwT/+8Q+dO3fOozhJUkJCgvbu3dtCUTWupqZG999/v6677jqlp6e7l996661KTU1VcnKydu7cqWnTpmnfvn1atmyZJOnYsWP15lq7rjkNHjxYL730ktLS0lRSUqLf/OY3GjJkiHbt2qVjx44pJCSkzh+sCQkJ7jh9KZfzrVixQqWlpZowYYJ7WWual2+qff364jt/Ltq1a+exPigoSDExMR5jOnfuXGcbtevatm17SeJvzJkzZzRt2jTl5OTI5XK5l997773q37+/YmJitGnTJj3yyCMqKSnR008/7Y7ZF/LJysrSLbfcos6dO6u4uFjTp0/XqFGjtHnzZgUGBrbquXn55ZcVGRmpW265xWO5L85Nfedkb53HGhpTXl6u06dPKywszOv5XAzqKnXV26irX2st527qqu/k8k3U1dZZVwHAl9F49GNTpkzRrl279N5773ksv/POO93/7t27t5KSkjRixAgVFxera9euzR3mBY0aNcr97z59+mjw4MFKTU3V0qVLW3XBf/HFFzVq1CglJye7l7WmebmcnD17VmPGjJGZaf78+R7rHnjgAfe/+/Tpo5CQEN11112aPXu2nE5nc4faoJ/85Cfuf/fu3Vt9+vRR165dlZ+frxEjRrRgZBcvLy9P48aNU2hoqMdyX5ybhs7JaD2oq76Lutp6UFd9G3UVAOBt3GrdBHFxcQoMDKzzbWiff/65EhMTWyiqC7vnnnu0cuVKrVu3Th06dLjg2MGDB0uSDhw4IElKTEysN9fadS0pOjpaPXr00IEDB5SYmKiqqiqVlpZ6jDl/Xnwxl8OHD+udd97Rz3/+8wuOa03zUvv6F/odSUxM1PHjxz3WV1dX68svv/TZ+ap9c3T48GG9/fbbHldl1Gfw4MGqrq7WoUOHJPlePrW6dOmiuLg4j2Ortc2NJG3YsEH79u1r9HdJavm5aeic7K3zWENjXC6XTzaTqKst//tTi7rqW7nUoq5+raXP3U1FXaWuAgAaRuOxCUJCQjRgwACtWbPGvaympkZr1qxRRkZGC0ZWl5npnnvu0fLly7V27do6tzzUp7CwUJKUlJQkScrIyNAHH3zg8QdT7R+HV1555SWJu6kqKipUXFyspKQkDRgwQMHBwR7zsm/fPh05csQ9L76Yy8KFC9WuXTuNHj36guNa07x07txZiYmJHnNRXl6urVu3esxFaWmp3n//ffeYtWvXqqamxv1mMCMjQ+vXr9fZs2fdY95++22lpaU1+y1HtW+OPvroI73zzjuKjY1t9DmFhYUKCAhw317lS/mc75NPPtGJEyc8jq3WNDe1XnzxRQ0YMEB9+/ZtdGxLzU1j52RvnccyMjI8tlE7xtdqVC3qqu+cv6mrvpVLLerq16irzYu62nrrKgD4tJb8ZpvWZPHixeZ0Ou2ll16y3bt325133mnR0dEe34bmC+6++26Lioqy/Px8Kykpcf+cOnXKzMwOHDhgs2bNsm3bttnBgwft9ddfty5dutjQoUPd26iurrb09HS74YYbrLCw0FavXm3x8fH2yCOPNHs+Dz74oOXn59vBgwdt48aNlpmZaXFxcXb8+HEzM5s0aZJ17NjR1q5da9u2bbOMjAzLyMjwyVzMvv7W1o4dO9q0adM8lreGeTl58qTt2LHDduzYYZLs6aefth07dri/jXLOnDkWHR1tr7/+uu3cudOys7Otc+fOdvr0afc2srKyrF+/frZ161Z77733rHv37paTk+NeX1paagkJCfbTn/7Udu3aZYsXL7bw8HBbsGBBs+ZTVVVlN954o3Xo0MEKCws9fpdqv+1w06ZNNnfuXCssLLTi4mJ75ZVXLD4+3m677bZmz+dCuZw8edIeeugh27x5sx08eNDeeecd69+/v3Xv3t3OnDnj3kZrmZtaZWVlFh4ebvPnz6/zfF+am8bOyWbeOY99/PHHFh4eblOnTrU9e/bYvHnzLDAw0FavXu3VfLyJukpd9Qbqaus4d1NXfXdualFXW39dBQBfRePxW3juueesY8eOFhISYoMGDbItW7a0dEh1SKr3Z+HChWZmduTIERs6dKjFxMSY0+m0bt262dSpU62srMxjO4cOHbJRo0ZZWFiYxcXF2YMPPmhnz55t9nzGjh1rSUlJFhISYu3bt7exY8fagQMH3OtPnz5tkydPtrZt21p4eLjdfPPNVlJS4rENX8nFzOzNN980SbZv3z6P5a1hXtatW1fvsTV+/HgzM6upqbFf//rXlpCQYE6n00aMGFEnzxMnTlhOTo5FRESYy+Wy22+/3U6ePOkxpqioyK6//npzOp3Wvn17mzNnTrPnc/DgwQZ/l9atW2dmZu+//74NHjzYoqKiLDQ01K644gp78sknPd50NFc+F8rl1KlTdsMNN1h8fLwFBwdbamqq3XHHHXWaO61lbmotWLDAwsLCrLS0tM7zfWluGjsnm3nvPLZu3Tq76qqrLCQkxLp06eLxGr6KukpdvVjU1dZx7qau+u7c1KKu+kddBQBf5DAz+zZXSAIAAAAAAABAY/iMRwAAAAAAAABeR+MRAAAAAAAAgNfReAQAAAAAAADgdTQeAQAAAAAAAHgdjUcAAAAAAAAAXkfjEQAAAAAAAIDX0XgEAAAAAAAA4HU0HnHZczgcWrFiRYvGYGa68847FRMTI4fDocLCwhaNpzETJkzQTTfd1NJhAAB8EHX126OuAgAAf0XjEa2WP/2Rvnr1ar300ktauXKlSkpKlJ6eXu+4P/zhD+rbt68iIiIUHR2tfv36afbs2c0c7aUzYcIEzZw58zs/38z0/PPPa/Dgwe59dPXVV+uZZ57RqVOnvBeoj+nUqZOeeeaZlg4DQCtHXaWufhN1FQAAXKyglg4AgFRcXKykpCRde+21DY7Jy8vT/fffr2effVbDhg1TZWWldu7cqV27djVjpJdGVVWVQkJCLno7P/3pT7Vs2TI9+uij+u///m/Fx8erqKhIzzzzjDp16uQ3b6gBABdGXaWuAgAA38AVj/Abw4cP17333quHH35YMTExSkxMrPO//B999JGGDh2q0NBQXXnllXr77bfrbOfo0aMaM2aMoqOjFRMTo+zsbB06dEiStHfvXoWHh+u1115zj1+6dKnCwsK0e/fuBmN79913NWjQIDmdTiUlJelXv/qVqqurJX19NcIvfvELHTlyRA6HQ506dap3G3/5y180ZswYTZw4Ud26dVOvXr2Uk5OjJ554wj2m9mqV3/zmN4qPj5fL5dKkSZNUVVXlHlNTU6PZs2erc+fOCgsLU9++ffWnP/3Jvf7cuXOaOHGie31aWpp+97vfNZibJBUUFCg+Pl6//e1vJUmlpaX6+c9/7o7he9/7noqKitzjZ86cqauuukovvPCCOnfurNDQ0Hq3+/vf/17du3dXaGioEhIS9KMf/ajBGJYuXapXX31VixYt0vTp0zVw4EB16tRJ2dnZWrt2rf7lX/7Fnf+sWbPUoUMHOZ1OXXXVVVq9erV7O4cOHZLD4dDSpUs1ZMgQhYWFaeDAgdq/f78KCgp09dVXKyIiQqNGjdIXX3xRZ98/+eSTSkhIUHR0tGbNmqXq6mpNnTpVMTEx6tChgxYuXOgR94WOt/O3+5//+Z9KSkpSbGyspkyZorNnz0r6+rg/fPiwfvnLX8rhcMjhcFxwrgCgqair1FXqKnUVAICLZkArNX78eMvOznY/HjZsmLlcLps5c6bt37/fXn75ZXM4HPbWW2+Zmdm5c+csPT3dRowYYYWFhfbuu+9av379TJItX77czMyqqqrsiiuusJ/97Ge2c+dO2717t916662WlpZmlZWVZmY2b948i4qKssOHD9vRo0etbdu29rvf/a7BOD/55BMLDw+3yZMn2549e2z58uUWFxdnubm5ZmZWWlpqs2bNsg4dOlhJSYkdP3683u3cdddd1rNnTzt06NAF90lERISNHTvWdu3aZStXrrT4+HibPn26e8y///u/W8+ePW316tVWXFxsCxcuNKfTafn5+e598Nhjj1lBQYF9/PHH9sorr1h4eLgtWbKk3n2/Zs0ai4qKsgULFrjXZ2Zm2g9+8AMrKCiw/fv324MPPmixsbF24sQJMzPLzc21Nm3aWFZWlm3fvt2Kiorc263dLwUFBRYYGGivvfaaHTp0yLZv337B/XzjjTdaWlpag+trPf300+ZyuWzRokW2d+9ee/jhhy04ONj2799vZmYHDx40Se59tHv3brvmmmtswIABNnz4cHvvvfds+/bt1q1bN5s0aZLHPomMjLQpU6bY3r177cUXXzRJNnLkSHviiSds//799vjjj1twcLAdPXrUva8bO97Gjx9vLpfLJk2aZHv27LG//vWvFh4ebs8//7yZmZ04ccI6dOhgs2bNspKSEispKWl0HwBAfair9e8T6uqFUVcBAMCF0HhEq1XfG6Trr7/eY8zAgQNt2rRpZmb25ptvWlBQkH366afu9W+88YbHG6T/+Z//sbS0NKupqXGPqaystLCwMHvzzTfdy0aPHm1DhgyxESNG2A033OAx/pumT59eZ5vz5s2ziIgIO3funJmZzZ0711JTUy+Y72effWbXXHONSbIePXrY+PHjbcmSJe5t1O6TmJgY++qrr9zL5s+f736tM2fOWHh4uG3atMlj2xMnTrScnJwGX3vKlCn2wx/+0ON1srOzbdmyZRYREWGLFy92r9uwYYO5XC47c+aMxza6du3qfhOVm5trwcHBDb4ZNDP785//bC6Xy8rLyy+4X2pdccUVduONNzY6Ljk52Z544gmPZQMHDrTJkyeb2f+/QXrhhRfc6xctWmSSbM2aNe5ls2fP9nhDNn78eEtNTfWYj7S0NBsyZIj7cXV1tbVp08YWLVpkZk073mq3W11d7R7z4x//2MaOHet+nJqaanPnzm00dwC4EOoqdfV81NW5jeYOAAAax2c8wq/06dPH43FSUpKOHz8uSdqzZ49SUlKUnJzsXp+RkeExvqioSAcOHFBkZKTH8jNnzqi4uNj9OC8vTz169FBAQIA+/PDDC96Gs2fPHmVkZHiMue6661RRUaFPPvlEHTt2bFJuSUlJ2rx5s3bt2qX169dr06ZNGj9+vF544QWtXr1aAQFff3JC3759FR4e7pFjRUWFjh49qoqKCp06dUrf//73PbZdVVWlfv36uR/PmzdPeXl5OnLkiE6fPq2qqipdddVVHs/ZunWrVq5cqT/96U8en/FUVFSkiooKxcbGeow/ffq0xz5MTU1VfHx8g/l+//vfV2pqqrp06aKsrCxlZWXp5ptv9sjtfGbW4LZqlZeX67PPPtN1113nsfy6667zuGVN8jyWEhISJEm9e/f2WFZ7bNXq1auXex5qx5z/hQaBgYGKjY11P6+px1uvXr0UGBjofpyUlKQPPvig0XwB4GJRV6mrF0JdBQAAjaHxCL8SHBzs8djhcKimpqbJz6+oqNCAAQP06quv1ll3/h/zRUVF+uqrrxQQEKCSkhIlJSV996C/pfT0dKWnp2vy5MmaNGmShgwZonfffdf9WUsXUlFRIUn629/+pvbt23usczqdkqTFixfroYce0n/9138pIyNDkZGReuqpp7R161aP8V27dlVsbKzy8vI0evRo976vqKhQUlKS8vPz67x+dHS0+99t2rS5YKyRkZHavn278vPz9dZbb+mxxx7TzJkzVVBQ4LGdWj169NDevXsb2wVNdv6xVPvm9pvLvnls1Xf8XeiYbOrxdrHHNQB8V9TVC6OuNh11FQCAyxONR1w2rrjiCh09etTjDc2WLVs8xvTv319LlixRu3bt5HK56t3Ol19+qQkTJmjGjBkqKSnRuHHjtH37doWFhTX4un/+859lZu4/tDdu3KjIyEh16NDhonK68sorJUlfffWVe1lRUZFOnz7tjmfLli2KiIhQSkqKYmJi5HQ6deTIEQ0bNqzebW7cuFHXXnutJk+e7F52/lUCteLi4rRs2TINHz5cY8aM0dKlSxUcHKz+/fvr2LFjCgoKavAD/ZsqKChImZmZyszMVG5urqKjo7V27Vrdcsstdcbeeuut+slPfqLXX39d2dnZHuvMTOXl5YqKilJycrI2btzokf/GjRs1aNCgi4r1u2jK8dYUISEhOnfunBcjA4DGUVepq9RVAADQGL7VGpeNzMxM9ejRQ+PHj1dRUZE2bNigGTNmeIwZN26c4uLilJ2drQ0bNujgwYPKz8/Xvffeq08++USSNGnSJKWkpOjRRx/V008/rXPnzumhhx5q8HUnT56so0eP6he/+IX27t2r119/Xbm5uXrggQc8bh9qzN13363HH39cGzdu1OHDh7Vlyxbddtttio+P97i1raqqShMnTtTu3bu1atUq5ebm6p577lFAQIAiIyP10EMP6Ze//KVefvllFRcXa/v27Xruuef08ssvS5K6d++ubdu26c0339T+/fv161//WgUFBfXG1K5dO61du1Z79+5VTk6OqqurlZmZqYyMDN1000166623dOjQIW3atEkzZszQtm3bmpzvypUr9eyzz6qwsFCHDx/WH//4R9XU1CgtLa3e8WPGjNHYsWOVk5OjJ598Utu2bdPhw4e1cuVKZWZmat26dZKkqVOn6re//a2WLFmiffv26Ve/+pUKCwt13333NTk2b2nK8dYUnTp10vr16/Xpp5/qH//4xyWMGAD+H3WVuipRVwEAwIVxxSMuGwEBAVq+fLkmTpyoQYMGqVOnTnr22WeVlZXlHhMeHq7169dr2rRpuuWWW3Ty5Em1b99eI0aMkMvl0h//+EetWrVKO3bsUFBQkIKCgvTKK6/o+uuv17/9279p1KhRdV63ffv2WrVqlaZOnaq+ffsqJiZGEydO1KOPPvqt4s/MzFReXp7mz5+vEydOKC4uThkZGVqzZo3H5z6NGDFC3bt319ChQ1VZWamcnBzNnDnTvf7xxx9XfHy8Zs+erY8//ljR0dHq37+/pk+fLkm66667tGPHDo0dO1YOh0M5OTmaPHmy3njjjXrjSkxM1Nq1azV8+HCNGzdOr732mlatWqUZM2bo9ttv1xdffKHExEQNHTrU/ZlOTREdHa1ly5Zp5syZOnPmjLp3765FixapV69e9Y53OBx67bXX9PzzzysvL09PPPGEgoKC1L17d912220aOXKkJOnee+9VWVmZHnzwQR0/flxXXnml/vKXv6h79+5Njs1bGjvemmrWrFm666671LVrV1VWVjbpc7kA4GJRV79GXaWuAgCAhjmMSgr4jQkTJqi0tFQrVqxo6VAAAGj1qKsAAAAXh1utAQAAAAAAAHgdjUcAAAAAAAAAXset1gAAAAAAAAC8jiseAQAAAAAAAHgdjUcAAAAAAAAAXkfjEQAAAAAAAIDX0XgEAAAAAAAA4HU0HgEAAAAAAAB4HY1HAAAAAAAAAF5H4xEAAAAAAACA19F4BAAAAAAAAOB1NB4BAAAAAAAAeN3/AdeG/yPesgQ5AAAAAElFTkSuQmCC",
      "text/plain": [
       "<Figure size 1333.5x500 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "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(\"Index of Speaker's Comment\", \"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:\")"
   ]
  },
  {
   "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.21"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}