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

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "ba9e5acd-e17d-4318-9272-04c9f6706186",
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd \n",
    "import spacy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "e4f0b3f0-5255-46f1-822f-e455087ba315",
   "metadata": {},
   "outputs": [],
   "source": [
    "phab_path = \"/mmfs1/gscratch/comdata/users/mjilg/mw-repo-lifecycles/case3/0422_http_phab_comments.csv\"\n",
    "phab_df = pd.read_csv(phab_path)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "ac5e624b-08a4-4ede-bc96-cfc26c3edac3",
   "metadata": {},
   "outputs": [],
   "source": [
    "def http_relevant(text):\n",
    "    if pd.isnull(text):\n",
    "        return False\n",
    "    # expanded dictionary for relevancy\n",
    "    # http, login, SSL, TLS, certificate \n",
    "    for word in text.split():\n",
    "        if \"://\" not in word.lower():\n",
    "            #http\n",
    "            if \"http\" in word.lower():\n",
    "                return True\n",
    "            #login\n",
    "            if \"login\" in word.lower():\n",
    "                return True\n",
    "            #ssl\n",
    "            if \"ssl\" in word.lower():\n",
    "                return True\n",
    "            #tls\n",
    "            if \"tls\" in word.lower():\n",
    "                return True\n",
    "            #cert\n",
    "            if word.lower().startswith(\"cert\") and not word.lower().startswith(\"certain\"):\n",
    "                return True\n",
    "    return False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "d5925c49-ea1d-4813-98aa-eae10d5879ca",
   "metadata": {},
   "outputs": [],
   "source": [
    "def is_migrated(comment_text):\n",
    "    if pd.isnull(comment_text):\n",
    "        return False\n",
    "    text = comment_text.strip()\n",
    "    if text.startswith(\"Originally from: http://sourceforge.net\"):\n",
    "        return True \n",
    "    return False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "d449164e-1d28-4580-9eb1-f0f69978f114",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_96995/836739196.py:41: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  mid_comment_phab_df['is_relevant'] = mid_comment_phab_df['conversation_id'].isin(relevant_conversation_ids)\n",
      "/tmp/ipykernel_96995/836739196.py:44: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  mid_comment_phab_df['is_migrated'] = mid_comment_phab_df['conversation_id'].isin(migrated_conversation_ids)\n"
     ]
    }
   ],
   "source": [
    "#find gerrit phab PHID: PHID-USER-idceizaw6elwiwm5xshb\n",
    "phab_df['isGerrit'] = phab_df['AuthorPHID'] == 'PHID-USER-idceizaw6elwiwm5xshb'\n",
    "\n",
    "#cleaning df\n",
    "phab_df['id'] = phab_df.index + 1\n",
    "#may have to build out the reply_to column \n",
    "phab_df['reply_to'] = phab_df.groupby('TaskPHID')['id'].shift()\n",
    "phab_df['reply_to'] = phab_df['reply_to'].where(pd.notnull(phab_df['reply_to']), None)\n",
    "\n",
    "phab_df = phab_df.rename(columns={\n",
    "    'AuthorPHID': 'speaker',\n",
    "    'TaskPHID': 'conversation_id',\n",
    "    'WMFaffil':'meta.affil',\n",
    "    'isGerrit': 'meta.gerrit'\n",
    "})\n",
    "\n",
    "# after 07-01-2013 before 10-01-2015\n",
    "phab_df['timestamp'] = pd.to_datetime(phab_df['date_created'], unit='s', origin='unix', utc=True)\n",
    "filtered_phab_df = phab_df[(phab_df['date_created'] < 1443743999) & (phab_df['date_created'] > 1372636800)]\n",
    "#filtered_phab_df = phab_df[(phab_df['date_created'] < 1381691276) & (phab_df['date_created'] > 1379975444)]\n",
    "\n",
    "#removing headless conversations\n",
    "task_phab_df = filtered_phab_df[filtered_phab_df['comment_type']==\"task_description\"]\n",
    "headed_task_phids = task_phab_df['conversation_id'].unique()\n",
    "filtered_phab_df = filtered_phab_df[filtered_phab_df['conversation_id'].isin(headed_task_phids)]\n",
    "\n",
    "#removing gerrit comments \n",
    "mid_comment_phab_df = filtered_phab_df[filtered_phab_df['meta.gerrit'] != True]\n",
    "\n",
    "# filter out the sourceforge migration \n",
    "# Originally from: http://sourceforge.net in the task task_summary\n",
    "migrated_conversation_ids = task_phab_df[task_phab_df['comment_text'].apply(is_migrated)]['conversation_id'].unique()\n",
    "\n",
    "#cut down to only the data that is relevant (mentions http)\n",
    "relevant_conversation_ids = task_phab_df[\n",
    "    task_phab_df['comment_text'].apply(http_relevant) |\n",
    "    task_phab_df['task_title'].apply(http_relevant)\n",
    "]['conversation_id'].unique()\n",
    "\n",
    "task_phab_df['is_relevant'] = task_phab_df['conversation_id'].isin(relevant_conversation_ids)\n",
    "mid_comment_phab_df['is_relevant'] = mid_comment_phab_df['conversation_id'].isin(relevant_conversation_ids)\n",
    "\n",
    "task_phab_df['is_migrated'] = task_phab_df['conversation_id'].isin(migrated_conversation_ids)\n",
    "mid_comment_phab_df['is_migrated'] = mid_comment_phab_df['conversation_id'].isin(migrated_conversation_ids)\n",
    "\n",
    "comment_phab_df = mid_comment_phab_df[(mid_comment_phab_df['is_relevant'] == True) & (mid_comment_phab_df['is_migrated'] != True)]\n",
    "task_phab_df = task_phab_df[(task_phab_df['is_relevant'] == True) & (task_phab_df['is_migrated'] != True)]\n",
    "#comment_phab_df = mid_comment_phab_df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "942344db-c8f5-4ed6-a757-c97f8454f18b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Unique conversation_ids: 2281\n",
      "Unique ids: 14490\n",
      "Unique speakers: 634\n"
     ]
    }
   ],
   "source": [
    "unique_conversation_ids = len(comment_phab_df['conversation_id'].unique())\n",
    "unique_ids = len(comment_phab_df['id'].unique())\n",
    "unique_speakers = len(comment_phab_df['speaker'].unique())\n",
    "\n",
    "print(f\"Unique conversation_ids: {unique_conversation_ids}\")\n",
    "print(f\"Unique ids: {unique_ids}\")\n",
    "print(f\"Unique speakers: {unique_speakers}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "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": 10,
   "id": "3ae40d24-bbe8-49c3-a3a9-70bde1b4d559",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_96995/2783900859.py:1: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  comment_phab_df['processed_text'] = comment_phab_df['comment_text'].apply(preprocess_text)\n"
     ]
    }
   ],
   "source": [
    "comment_phab_df['processed_text'] = comment_phab_df['comment_text'].apply(preprocess_text)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b8eddf40-1fe2-4fce-be74-b32552b40c57",
   "metadata": {},
   "outputs": [],
   "source": [
    "#comment_phab_df['processed_resolved_text'] = comment_phab_df['resolved_text'].apply(preprocess_text)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "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": 12,
   "id": "8b9a12f9-71bf-4bc9-bcfd-c73aab4be920",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_96995/2805711855.py:1: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  comment_phab_df['dependency_tree'] = comment_phab_df['processed_text'].apply(extract_dependency_tree)\n"
     ]
    }
   ],
   "source": [
    "comment_phab_df['dependency_tree'] = comment_phab_df['processed_text'].apply(extract_dependency_tree)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "337a528a-5667-4e1f-ac9a-37caabc03a18",
   "metadata": {},
   "outputs": [],
   "source": [
    "#comment_phab_df['resolved_dependency_tree'] = comment_phab_df['processed_resolved_text'].apply(extract_dependency_tree)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "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": 14,
   "id": "828fb57a-e152-42ef-9c60-660648898532",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_96995/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_96995/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_96995/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_96995/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": 15,
   "id": "27e47f6f-0257-4b70-b222-e91ef888c900",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_96995/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_96995/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_96995/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": 16,
   "id": "184ccbe6-0a7a-41b8-9b02-bc439ff975d0",
   "metadata": {},
   "outputs": [],
   "source": [
    "# expand the dependency parser \n",
    "\n",
    "#pattern = r'\\b(ve|VE|visualeditor|VisualEditor)\\b'\n",
    "#pattern = r'\\b(WMF|Foundation)\\b'\n",
    "#pattern = r'\\b(bots|scripts|gadgets)\\b'\n",
    "pattern = r'\\b(http|https)\\b'\n",
    "\n",
    "dependency_relations = []\n",
    "resolved_dependency_relations = []\n",
    "\n",
    "for index, row in comment_phab_df.iterrows():\n",
    "    text = row['comment_text']\n",
    "    timestamp = row['timestamp']\n",
    "    comment_id = row['id']\n",
    "    conversation_id = row['conversation_id']\n",
    "    WMFaffil = row['meta.affil']\n",
    "    \n",
    "    for token, lemma, dep, head, ancestors, subtree, children in row['dependency_tree']:\n",
    "        if re.search(pattern, token, re.IGNORECASE):\n",
    "            dependency_relations.append({\n",
    "                'comment_id': comment_id,\n",
    "                'timestamp': timestamp,\n",
    "                'wmfAffil':WMFaffil,\n",
    "                'token': token,\n",
    "                'dependency': dep,\n",
    "                'head': head,\n",
    "                'depth': len(list(ancestors)), \n",
    "                'children': len(list(children)) \n",
    "            })\n",
    "    '''        \n",
    "    for token, lemma, dep, head, ancestors, subtree, children in row['resolved_dependency_tree']:\n",
    "        if re.search(pattern, token, re.IGNORECASE):\n",
    "            resolved_dependency_relations.append({\n",
    "                'comment_id': comment_id,\n",
    "                'timestamp': timestamp,\n",
    "                'wmfAffil':WMFaffil,\n",
    "                'token': token,\n",
    "                'dependency': dep,\n",
    "                'head': head,\n",
    "                'depth': len(list(ancestors)), \n",
    "                'children': len(list(children)) \n",
    "            })\n",
    "    '''\n",
    "#resolved_dependency_relations_df = pd.DataFrame(resolved_dependency_relations)            \n",
    "dependency_relations_df = pd.DataFrame(dependency_relations)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "82498686-14f4-40c8-9e33-27b31f115b47",
   "metadata": {},
   "outputs": [],
   "source": [
    "#now analysis/plotting \n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "from matplotlib.gridspec import GridSpec\n",
    "import matplotlib.ticker as ticker\n",
    "import matplotlib.dates as mdates"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9833922d-d69a-4f8d-96ed-b25eea626114",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "82cd9dde-0d14-4de5-8482-5a39de8d2869",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_96995/627627281.py:7: UserWarning: Converting to PeriodArray/Index representation will drop timezone information.\n",
      "  task_phab_df['week'] = task_phab_df['timestamp'].dt.to_period('W').dt.start_time\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x600 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(10, 6))\n",
    "#task_phab_df = phab_df[phab_df['comment_type']==\"task_description\"]\n",
    "task_phab_df = task_phab_df[task_phab_df['is_relevant'] == True]\n",
    "task_phab_df['first_comment'] = task_phab_df.groupby('speaker')['timestamp'].rank(method='first') <= 5\n",
    "#task_phab_df = task_phab_df[(task_phab_df['date_created'] < 1383264000) & (task_phab_df['date_created'] > 1351728000)]\n",
    "\n",
    "task_phab_df['week'] = task_phab_df['timestamp'].dt.to_period('W').dt.start_time\n",
    "unique_taskPHIDs = task_phab_df.groupby('week')['conversation_id'].nunique()\n",
    "\n",
    "wmf_task_phab_df = task_phab_df[(task_phab_df['meta.affil'] == True)]\n",
    "wmf_tasks = wmf_task_phab_df.groupby('week')['conversation_id'].nunique()\n",
    "\n",
    "other_task_phab_df = task_phab_df[(task_phab_df['meta.affil'] != True)]\n",
    "other_tasks = other_task_phab_df.groupby('week')['conversation_id'].nunique()\n",
    "\n",
    "'''\n",
    "task_phab_df['speakers_task'] = task_phab_df.groupby('speaker')['timestamp'].rank(method='first').astype(int)\n",
    "\n",
    "# Filter dates 06-12-2015 to 10-01-2015\n",
    "bounded_task_phab_df = task_phab_df[(task_phab_df['date_created'] < 1443743999) & (task_phab_df['date_created'] > 1434067200)]\n",
    "# Bin the speakers based on the number of tasks they created\n",
    "bins = [0, 6, 26, 51, float('inf')]\n",
    "labels = ['0-5', '6-25', '26-50', '51+']\n",
    "min_speakers_task = bounded_task_phab_df.groupby('speaker')['speakers_task'].min().reset_index()\n",
    "min_speakers_task = bounded_task_phab_df.rename(columns={'speakers_task': 'min_speakers_task'})\n",
    "bounded_task_phab_df = bounded_task_phab_df.merge(min_speakers_task, on='speaker', how='left')\n",
    "bounded_task_phab_df['task_bins'] = pd.cut(bounded_task_phab_df ['min_speakers_task'], bins=bins, labels=labels, right=False)\n",
    "print(bounded_task_phab_df)\n",
    "bounded_task_phab_df['week'] = bounded_task_phab_df['timestamp_y'].dt.to_period('W').dt.start_time\n",
    "weekly_breakdown = bounded_task_phab_df.groupby(['week', 'task_bins']).size().unstack(fill_value=0)\n",
    "speaker_breakdown = bounded_task_phab_df.groupby(['week', 'task_bins']).nunique()['speaker'].unstack(fill_value=0)\n",
    "\n",
    "# Reshape the DataFrame for use with Seaborn\n",
    "weekly_breakdown = weekly_breakdown.reset_index().melt(id_vars='week', value_vars=labels, var_name='task_bins', value_name='count')\n",
    "speaker_breakdown = speaker_breakdown.reset_index().melt(id_vars='week', value_vars=labels, var_name='task_bins', value_name='speakers')\n",
    "\n",
    "rookie_bounded_task_phab_df = weekly_breakdown[weekly_breakdown['task_bins'] == '0-5']\n",
    "\n",
    "#unaff_new_tasks_phab_df = task_phab_df[(task_phab_df['first_comment'] == True) & (task_phab_df['meta.affil'] != True)]\n",
    "#unaff_new_tasks = unaff_new_tasks_phab_df.groupby('week')['conversation_id'].nunique()\n",
    "\n",
    "#aff_new_tasks_phab_df = task_phab_df[(task_phab_df['first_comment'] == True) & (task_phab_df['meta.affil'] == True)]\n",
    "#aff_new_tasks = aff_new_tasks_phab_df.groupby('week')['conversation_id'].nunique()\n",
    "\n",
    "#sns.lineplot(x=unique_taskPHIDs.index, y=unique_taskPHIDs.values, color='black', label='Total', marker='o')\n",
    "#sns.lineplot(x=wmf_tasks.index, y=wmf_tasks.values, color='#c7756a', label='WMF-affiliated authors', marker='o')\n",
    "#sns.lineplot(x=other_tasks.index, y=other_tasks.values, color='#5da2d8', label='Nonaffiliated authors', marker='o')\n",
    "#sns.lineplot(x=aff_new_tasks.index, y=aff_new_tasks.values, color='#c7756a',linestyle=\"dotted\", label=\"WMF-affiliated new authors\", marker='x')\n",
    "#sns.lineplot(x=unaff_new_tasks.index, y=unaff_new_tasks.values, color='#5da2d8', linestyle=\"dotted\", label=\"Nonaffiliated new authors\", marker='x')\n",
    "'''\n",
    "#sns.barplot(x=unique_taskPHIDs.index, y=unique_taskPHIDs.values, color='black', label='Total')\n",
    "sns.barplot(x=other_tasks.index, y=other_tasks.values, color='#5da2d8', label='Nonaffiliated authors')\n",
    "sns.barplot(x=wmf_tasks.index, y=-wmf_tasks.values, color='#c7756a', label='WMF-affiliated authors')\n",
    "#sns.lineplot(data=rookie_bounded_task_phab_df, x='week', y='count', color='green', label='Authors with ≤ 5 tasks', marker='o')\n",
    "\n",
    "plt.title('New Relevant Phabricator Tasks Indexed with HTTP')\n",
    "plt.xlabel('Timestamp')\n",
    "plt.ylabel('Unique taskPHIDs')\n",
    "plt.xticks(rotation=90)\n",
    "# Customize the x-axis for weekly labels\n",
    "plt.grid(True)\n",
    "plt.tight_layout()\n",
    "plt.show()\n",
    "\n",
    "#plt.savefig('031825_new_tasks_fig.png')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "9a9b08a7-6c95-4971-b259-8e713c58fbe7",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_96995/3303796756.py:4: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  unaff_tasks_phab_df['speakers_task'] = unaff_tasks_phab_df.groupby('speaker')['timestamp'].rank(method='first').astype(int)\n",
      "/tmp/ipykernel_96995/3303796756.py:17: UserWarning: Converting to PeriodArray/Index representation will drop timezone information.\n",
      "  unaff_tasks_phab_df['week'] = unaff_tasks_phab_df['timestamp'].dt.to_period('W').dt.start_time\n",
      "/tmp/ipykernel_96995/3303796756.py:18: FutureWarning: The default of observed=False is deprecated and will be changed to True in a future version of pandas. Pass observed=False to retain current behavior or observed=True to adopt the future default and silence this warning.\n",
      "  weekly_breakdown = unaff_tasks_phab_df.groupby(['week', 'task_bins']).size().unstack(fill_value=0)\n",
      "/tmp/ipykernel_96995/3303796756.py:20: FutureWarning: The default of observed=False is deprecated and will be changed to True in a future version of pandas. Pass observed=False to retain current behavior or observed=True to adopt the future default and silence this warning.\n",
      "  speaker_breakdown = unaff_tasks_phab_df.groupby(['week', 'task_bins']).nunique()['speaker'].unstack(fill_value=0)\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1200x800 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "#task_phab_df = phab_df[phab_df['comment_type'] == \"task_description\"]\n",
    "unaff_tasks_phab_df = task_phab_df[task_phab_df['meta.affil'] != True]\n",
    "# Rank speaker's task values within each group\n",
    "unaff_tasks_phab_df['speakers_task'] = unaff_tasks_phab_df.groupby('speaker')['timestamp'].rank(method='first').astype(int)\n",
    "\n",
    "# Filter dates 06-12-2015 to 10-01-2015\n",
    "unaff_tasks_phab_df = unaff_tasks_phab_df[(unaff_tasks_phab_df['date_created'] < 1443743999) & (unaff_tasks_phab_df['date_created'] > 1434067200)]\n",
    "# Bin the speakers based on the number of tasks they created\n",
    "bins = [0, 6, 26, 51, float('inf')]\n",
    "labels = ['0-5', '6-25', '26-50', '51+']\n",
    "min_speakers_task = unaff_tasks_phab_df.groupby('speaker')['speakers_task'].min().reset_index()\n",
    "min_speakers_task = min_speakers_task.rename(columns={'speakers_task': 'min_speakers_task'})\n",
    "unaff_tasks_phab_df = unaff_tasks_phab_df.merge(min_speakers_task, on='speaker', how='left')\n",
    "unaff_tasks_phab_df['task_bins'] = pd.cut(unaff_tasks_phab_df['min_speakers_task'], bins=bins, labels=labels, right=False)\n",
    "\n",
    "# Calculate the weekly breakdown of binned speakers_task values\n",
    "unaff_tasks_phab_df['week'] = unaff_tasks_phab_df['timestamp'].dt.to_period('W').dt.start_time\n",
    "weekly_breakdown = unaff_tasks_phab_df.groupby(['week', 'task_bins']).size().unstack(fill_value=0)\n",
    "\n",
    "speaker_breakdown = unaff_tasks_phab_df.groupby(['week', 'task_bins']).nunique()['speaker'].unstack(fill_value=0)\n",
    "\n",
    "# Reshape the DataFrame for use with Seaborn\n",
    "weekly_breakdown = weekly_breakdown.reset_index().melt(id_vars='week', value_vars=labels, var_name='task_bins', value_name='count')\n",
    "speaker_breakdown = speaker_breakdown.reset_index().melt(id_vars='week', value_vars=labels, var_name='task_bins', value_name='speakers')\n",
    "\n",
    "# Plot the stacked bar plot using Seaborn\n",
    "plt.figure(figsize=(12, 8))\n",
    "sns.barplot(data=weekly_breakdown, x='week', y='count', hue='task_bins', palette='colorblind')\n",
    "#sns.barplot(data=speaker_breakdown, x='week', y='speakers', hue='task_bins', palette='colorblind')\n",
    "plt.title(\"06-12-2015 to 10-01-2015 Weekly Unaffiliated Task Creation by Contributor Tenure\")\n",
    "plt.xlabel('Week')\n",
    "plt.ylabel('Tasks')\n",
    "plt.legend(title=\"Contributor had created # tasks between 8-01-2013 and 06-12-2015:\")\n",
    "plt.xticks(rotation=45)\n",
    "plt.tight_layout()\n",
    "plt.show()\n",
    "\n",
    "#plt.savefig('031625_weekly_tasks_by_history.png')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "b7cfad77-d48a-4708-91f3-89ae1179b90c",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_96995/62586942.py:27: FutureWarning: The default of observed=False is deprecated and will be changed to True in a future version of pandas. Pass observed=False to retain current behavior or observed=True to adopt the future default and silence this warning.\n",
      "  comment_counts = affective_comment_phab_df.groupby('date_group').size()\n",
      "/tmp/ipykernel_96995/62586942.py:28: FutureWarning: The default of observed=False is deprecated and will be changed to True in a future version of pandas. Pass observed=False to retain current behavior or observed=True to adopt the future default and silence this warning.\n",
      "  speaker_counts = affective_comment_phab_df.groupby('date_group')['speaker'].nunique()\n",
      "/tmp/ipykernel_96995/62586942.py:35: FutureWarning: The default of observed=False is deprecated and will be changed to True in a future version of pandas. Pass observed=False to retain current behavior or observed=True to adopt the future default and silence this warning.\n",
      "  comment_counts_engaged = affective_comment_phab_df.groupby(['date_group', 'est_commenter', 'meta.affil']).size()\n",
      "/tmp/ipykernel_96995/62586942.py:36: FutureWarning: The default of observed=False is deprecated and will be changed to True in a future version of pandas. Pass observed=False to retain current behavior or observed=True to adopt the future default and silence this warning.\n",
      "  speaker_counts_engaged = affective_comment_phab_df.groupby(['date_group', 'est_commenter', 'meta.affil'])['speaker'].nunique()\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of comments for each date group:\n",
      "date_group\n",
      "Before announcement                      10614\n",
      "After announcement, before deployment      802\n",
      "After deployment                          3074\n",
      "dtype: int64\n",
      "\n",
      "Number of speakers for each date group:\n",
      "date_group\n",
      "Before announcement                      521\n",
      "After announcement, before deployment    142\n",
      "After deployment                         310\n",
      "Name: speaker, dtype: int64\n",
      "\n",
      "Number of comments for each date group and engaged commenter subgroup:\n",
      "date_group                             est_commenter  meta.affil\n",
      "Before announcement                    False          False         10317\n",
      "                                                      True            297\n",
      "After announcement, before deployment  False          False           787\n",
      "                                                      True             15\n",
      "After deployment                       False          False          2992\n",
      "                                                      True             82\n",
      "dtype: int64\n",
      "\n",
      "Number of speakers for each date group and engaged commenter subgroup:\n",
      "date_group                             est_commenter  meta.affil\n",
      "Before announcement                    False          False         518\n",
      "                                                      True           56\n",
      "After announcement, before deployment  False          False         138\n",
      "                                                      True            7\n",
      "After deployment                       False          False         305\n",
      "                                                      True           24\n",
      "Name: speaker, dtype: int64\n",
      "\n",
      "Number of comments for each engaged commenter subgroup, and WMF affiliation:\n",
      "est_commenter  meta.affil\n",
      "False          False         14096\n",
      "               True            394\n",
      "dtype: int64\n",
      "\n",
      "Number of speakers for each engaged commenter subgroup, and WMF affiliation:\n",
      "est_commenter  meta.affil\n",
      "False          False         627\n",
      "               True           75\n",
      "Name: speaker, dtype: int64\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'\\nplot1 = sns.lmplot(data=comment_phab_df, x=\"date_created\", y=\"dominant_wc\", hue=\"date_group\", col=\"meta.affil\", row=\\'new_commenter\\', scatter=False, legend=False, palette=palette)\\nplot1.set_axis_labels(\"Timestamp\", \"Count of Dominance Polarized Words\")\\nplot1.set_titles(row_template=\"Author\\'s 100+ Comment: {row_name}\",col_template=\"WMF Affiliation: {col_name}\")\\nplot1.fig.subplots_adjust(top=0.9)  # Adjust subplots to make room for the title\\nplot1.add_legend(title=\"Comment publication timestamp:\")\\nfig1 = plot1.fig\\n# Plot for arousal_wc\\nplot2 = sns.lmplot(data=comment_phab_df, x=\"date_created\", y=\"arousal_wc\", hue=\"date_group\", col=\"meta.affil\", row=\\'engaged_commenter\\', scatter=False, legend=False, palette=palette)\\nplot2.set_axis_labels(\"Timestamp\", \"Count of Arousal Polarized Words\")\\nplot2.set_titles(row_template=\"Author\\'s 100+ Comment: {row_name}\",col_template=\"WMF Affiliation: {col_name}\")\\nplot2.add_legend(title=\"Comment publication timestamp:\")\\n#plot2.add_legend(title=\"Before/After 07/01/2013 Wide Release\")\\n\\nplot3 = sns.lmplot(data=comment_phab_df, x=\"date_created\", y=\"valence_wc\", hue=\"date_group\", col=\"meta.affil\", row=\\'engaged_commenter\\', scatter=False, legend=False, palette=palette)\\nplot3.set_axis_labels(\"Timestamp\", \"Count of Valence Polarized Words\")\\nplot3.set_titles(row_template=\"Author\\'s 100+ Comment: {row_name}\",col_template=\"WMF Affiliation: {col_name}\")\\nplot3.add_legend(title=\"Comment publication timestamp:\")\\n'"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAABR4AAAHaCAYAAABmaVX2AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8ekN5oAAAACXBIWXMAAA9hAAAPYQGoP6dpAACyn0lEQVR4nOzdd3gU1f4G8He2pCcbEkICEgi99yIBlXoNRS5NiqAUwUpHQLyKEBBBpIpX5EcLKCIqRUUpGklUpMZLLESESFMCoaRt+u6c3x+bneymsZts+vt5njzslJ05uwxM9t3vOUcSQggQEREREREREREROZCqvBtAREREREREREREVQ+DRyIiIiIiIiIiInI4Bo9ERERERERERETkcAweiYiIiIiIiIiIyOEYPBIREREREREREZHDMXgkIiIiIiIiIiIih2PwSERERERERERERA7H4JGIiIiIiIiIiIgcjsEjERERERERERERORyDR7JLr169MGvWrCL3CQoKwrp165RlSZJw4MABm45vz772sKXdpam8z18SEydOxNChQ0vt+BEREQgKCiq141cEixcvhr+/v9X1nXdd3vc57zWT999VcTnqOGUpLCwM3t7e5d0MIofhvbRynr8keC8tOd5LiYiIKicGj5XUxIkTIUlSvp/+/fvb9Pyy/IUpLi4OAwYMKJNzlVR6ejp8fHxQs2ZNZGZm2v38iIgISJKExMRExzeuBIKCgvJdK3Xr1i3vZtnk/fffh6enJwwGg7JOr9dDq9WiV69eVvua3//Y2FgAua/7448/znfcVq1aQZIkhIWFKeuK+z79/fffcHJyQuvWrfNti4mJQWhoKDZt2qT8Wyho3fr1663akteZM2fw7LPP3rctZoWFdfYex1EK+z/r0qVLZd4WIjPeS0sH76UVD++lJpX5XlrQ/1WWP4sXLy7T9hAREdmKwWMl1r9/f8TFxVn97N69u7yblU9AQACcnZ3Luxk22bt3L1q1aoXmzZuXSrWII2VlZdm1/5IlS6yulf/973+l1DLH6t27N/R6Pc6ePaus++GHHxAQEIBTp04hIyNDWX/s2DHUq1cPjRo1UtYFBgZi+/btVsc8efIkbt68CXd393znK877FBYWhlGjRiE5ORmnTp2y2mb+4DZkyBDl30JB63Q6XZFVfX5+fnBzc7tvW+7HUccpjoL+z2rQoEG5tIXIjPdSx+O9tOLhvdSkMt9LLd/PdevWwcvLy2rd3LlzlX2FEFYhMxERUXli8FiJOTs7IyAgwOqnRo0aAEy/cCxevBj16tWDs7Mz6tSpgxkzZgAwdTu5evUqZs+erXxLCgB3797FE088gQceeABubm5o06ZNgR++DAYDpk2bBp1Oh5o1a2LhwoUQQhTaTssuMVlZWZg2bRpq164NFxcX1K9fH8uXL7fa/86dOxg2bBjc3NzQpEkTfPHFF1bbf/vtNwwYMAAeHh7w9/fHU089hTt37ijbU1NTMX78eHh4eKB27dpYvXq1ze/p1q1b8eSTT+LJJ5/E1q1brbZduXIFkiTh3LlzyrrExERIkoSIiAhcuXIFvXv3BgDUqFEDkiRh4sSJyr6yLGP+/Pnw8fFBQEBAvm+mr127hiFDhsDDwwNeXl4YNWoUbt26pWxfvHgx2rdvjy1btqBBgwZwcXGx+XUBgKenp9W14ufnB6PRiMmTJ6NBgwZwdXVFs2bNsH79+iKP89lnn6FNmzZwdXWFr68v+vXrh9TUVGX7li1b0KJFC7i4uKB58+Z477337GpnXs2aNUPt2rURERGhrIuIiMCQIUPQoEEDnDx50mq9+e/AbNy4cYiMjMT169eVddu2bcO4ceOg0Wjyna+g96koQghs374dTz31FMaOHWt13SxevBiDBw8GAKhUKqUiIe864P7d8PJWVq1ZswZt2rSBu7s7AgMD8eKLL0Kv1yvvw6RJk5CUlJSvEiLvcWy97j744AMEBQVBp9NhzJgxSElJKfJ9KUhB/2ep1eoiX0tBoqOj0bt3b3h6esLLywudOnWy+jD9448/4uGHH4arqysCAwMxY8YMq2uUyBLvpbyX2oP3Ut5LCzpOWdxLLd9PnU4HSZKU5T/++AOenp44dOgQOnXqBGdnZ/z4448Fvh+zZs2yqnKVZRnLly9Xrt927drhs88+s7ldRERE98PgsYrau3cv1q5di02bNuHixYs4cOAA2rRpAwDYt28f6tata/VtNABkZGSgU6dO+Oqrr/Dbb7/h2WefxVNPPYXTp09bHXvHjh3QaDQ4ffo01q9fjzVr1mDLli02teudd97BF198gU8++QQXLlzArl278o1JFBoailGjRuGXX37BwIEDMW7cONy7dw+A6cNJnz590KFDB5w9exaHDx/GrVu3MGrUKOX58+bNQ2RkJD7//HMcPXoUERER+Pnnn+/bttjYWJw4cQKjRo3CqFGj8MMPP+Dq1as2vS7AVA2wd+9eAMCFCxcQFxdn9cFjx44dcHd3x6lTp7By5UosWbIE33zzDQDTL31DhgzBvXv3EBkZiW+++QZ//fUXRo8ebXWOS5cuYe/evdi3b5/yoW3ixIn5uknZSpZl1K1bF59++inOnz+P119/Hf/5z3/wySefFLh/XFwcnnjiCTz99NOIiYlBREQEhg8frnxY3rVrF15//XUsW7YMMTExePPNN7Fw4ULs2LGjWO0z6927N44dO6YsHzt2DL169ULPnj2V9enp6Th16lS+D0v+/v4ICQlR2pCWloY9e/bg6aefLlGbLNuSlpaGfv364cknn8THH3+sfHicO3euUiFiWZGQd11xqFQqvPPOO/j999+xY8cOfPfdd5g/fz4AoHv37vmqISwrIcxsve5iY2Nx4MABHDx4EAcPHkRkZCRWrFihbA8LC1M+9Dn6tRRk3LhxqFu3Ls6cOYOoqCgsWLAAWq1WaWv//v0xYsQI/PLLL9izZw9+/PFHTJs2rdjto+qL91LeS23Be2nJ8V5a8nspACxYsAArVqxATEwM2rZta9Nzli9fjp07d+L999/H77//jtmzZ+PJJ59EZGRkidpCRESkEFQpTZgwQajVauHu7m71s2zZMiGEEKtXrxZNmzYVWVlZBT6/fv36Yu3atfc9z6BBg8RLL72kLPfs2VO0aNFCyLKsrHv55ZdFixYtCj02ALF//34hhBDTp08Xffr0sXq+JQDitddeU5b1er0AIA4dOiSEEGLp0qXi0UcftXrO9evXBQBx4cIFkZKSIpycnMQnn3yibL97965wdXUVM2fOLPK1/uc//xFDhw5VlocMGSIWLVqkLF++fFkAEP/73/+UdQkJCQKAOHbsmBBCiGPHjgkAIiEhwerYPXv2FA899JDVui5duoiXX35ZCCHE0aNHhVqtFteuXVO2//777wKAOH36tBBCiEWLFgmtVivi4+OtjrNgwQLx1FNPFfna6tevL5ycnKyulfXr1xe479SpU8WIESOU5QkTJoghQ4YIIYSIiooSAMSVK1cKfG6jRo3ERx99ZLVu6dKlIjg4uNC2HTt2TNSvX7/I9m/evFm4u7uL7OxskZycLDQajYiPjxcfffSReOSRR4QQQoSHhwsA4urVq1ave+3ateLAgQOiUaNGQpZlsWPHDtGhQwchhBA6nU5s377dan9b3yezsWPHilmzZinL7dq1szrm/v37Rd7/agtaZ/k+C2G6Ziyv2fv9m/3000+Fr6+vsrx9+3ah0+ny7Wd5HFuvOzc3N5GcnKzsM2/ePPHggw8qy/v27RPNmjUrtG3m15f3/6zHH3+8WK/F09NThIWFFfjcyZMni2effdZq3Q8//CBUKpVIT08vso1U/fBemov3Ut5LheC9tKLfSwtrl/nfzIEDB6z2y/t+CCHEzJkzRc+ePYUQQmRkZAg3Nzfx008/We0zefJk8cQTT9jUFiIiovvJ3zeCKo3evXtj48aNVut8fHwAACNHjsS6devQsGFD9O/fHwMHDsTgwYML7A5jZjQa8eabb+KTTz7BP//8g6ysLGRmZuYbw6Zbt25W38gGBwdj9erVMBqNUKvVRbZ54sSJ+Ne//oVmzZqhf//+eOyxx/Doo49a7WP5Da27uzu8vLwQHx8PwNTF8tixY/Dw8Mh37NjYWKSnpyMrKwsPPvig1XvSrFmzIttlNBqxY8cOq6qKJ598EnPnzsXrr78OlarkxcF5v3muXbu28rpiYmIQGBiIwMBAZXvLli3h7e2NmJgYdOnSBQBQv379fN2V8navK8y8efOsuqvVrFkTAPDf//4X27Ztw7Vr15T3r3379gUeo127dujbty/atGmDkJAQPProo3j88cdRo0YNpKamIjY2FpMnT8YzzzyjPMdgMECn09nUxsL06tULqampOHPmDBISEtC0aVP4+fmhZ8+emDRpEjIyMhAREYGGDRuiXr16+Z4/aNAgPPfcc/j++++xbdu2Iis0CnufCpKYmIh9+/bhxx9/VNaZuxZaHqM0fPvtt1i+fDn++OMPJCcnw2AwICMjA2lpaTaPO2XrdRcUFARPT09lH8trFwCGDRuGYcOG3fd8ef/PMo8LZu9rmTNnDqZMmYIPPvgA/fr1w8iRI5WxyKKjo/HLL79g165dyv5CCMiyjMuXL6NFixY2vTdUffBeao330qLxXsp7aV5lfS8tSufOne3a/9KlS0hLS8O//vUvq/VZWVno0KFDidpCRERkxuCxEnN3d0fjxo0L3BYYGIgLFy7g22+/xTfffIMXX3wRb7/9NiIjI5UuiXm9/fbbWL9+PdatW6eMdzNr1iy7B14vSseOHXH58mUcOnQI3377LUaNGoV+/fpZjSWTt32SJEGWZQCmGRgHDx6Mt956K9+xa9euXewZco8cOYJ//vknX7cYo9GI8PBw/Otf/1I+MAmLMbiys7NtPkdRr8tWBQ3gbquaNWvmu14+/vhjzJ07F6tXr0ZwcDA8PT3x9ttv5xvU3UytVuObb77BTz/9hKNHj2LDhg149dVXcerUKeUX9M2bN1t9WDU/ryQaN26MunXr4tixY0hISEDPnj0BAHXq1EFgYCB++uknHDt2DH369Cnw+RqNBk899RQWLVqEU6dOYf/+/YWeq6D3qTAfffQRMjIyrF6vOeT6888/0bRpUztepe2uXLmCxx57DC+88AKWLVsGHx8f/Pjjj5g8eTKysrIcPuC9I65doOD/s4rzWhYvXoyxY8fiq6++wqFDh7Bo0SJ8/PHHGDZsGPR6PZ577jllHD5LBX2QJuK91BrvpUXjvZT30uJy1L20KHmvbZVKlW/sWMt/b+bxLL/66is88MADVvtVlsmsiIio4uMYj1WYq6srBg8ejHfeeQcRERE4ceIEfv31VwCAk5MTjEaj1f7Hjx/HkCFD8OSTT6Jdu3Zo2LAh/vzzz3zHzfuL9MmTJ9GkSRObfyH28vLC6NGjsXnzZuzZswd79+5Vxp26n44dO+L3339HUFAQGjdubPXj7u6ORo0aQavVWrUxISGhwNdhaevWrRgzZgzOnTtn9TNmzBhlgHNzdYTlOEKWg+MDpvcVQL739n5atGiB69evWw3afv78eSQmJqJly5Z2Hcsex48fR/fu3fHiiy+iQ4cOaNy4sTJLZGEkSUKPHj0QGhqK//3vf3BycsL+/fvh7++POnXq4K+//sr3d+OImYt79+6NiIgIREREWI3D9cgjj+DQoUM4ffp0vjGpLD399NOIjIzEkCFDlIkjSmrr1q146aWXrK6Z6OhoPPzww9i2bZtDzlGQqKgoyLKM1atXo1u3bmjatClu3LhhtU9B/8bzKq/rzpItr6UgTZs2xezZs3H06FEMHz5cGeurY8eOOH/+fL5rsHHjxsq/TyJ78F5qwntp4XgvLRneS0uPn59fvvEvLf+9tWzZEs7Ozrh27Vq+682ygpOIiKgkWPFYiWVmZuLmzZtW6zQaDWrWrImwsDAYjUY8+OCDcHNzw4cffghXV1fUr18fgKm7x/fff48xY8bA2dkZNWvWRJMmTfDZZ5/hp59+Qo0aNbBmzRrcunUr3y9N165dw5w5c/Dcc8/h559/xoYNG2ye7XLNmjWoXbs2OnToAJVKhU8//RQBAQHw9va26flTp07F5s2b8cQTTyizWl66dAkff/wxtmzZAg8PD0yePBnz5s2Dr68vatWqhVdffbXI7l23b9/Gl19+iS+++AKtW7e22jZ+/HgMGzYM9+7dg4+PD7p164YVK1agQYMGiI+Px2uvvWa1f/369SFJEg4ePIiBAwfC1dW1wK5sefXr1w9t2rTBuHHjsG7dOhgMBrz44ovo2bPnfbvNvPLKK/jnn3+wc+fO+54nryZNmmDnzp04cuQIGjRogA8++ABnzpwp9MPNqVOnEB4ejkcffRS1atXCqVOncPv2baX7amhoKGbMmAGdTof+/fsjMzMTZ8+eRUJCAubMmWN3+yz17t0bU6dORXZ2tlKlAQA9e/bEtGnTkJWVVeSHpRYtWuDOnTsOq2A4d+4cfv75Z+zatQvNmze32vbEE09gyZIleOONNxxyrrwaN26M7OxsbNiwAYMHD8bx48fx/vvvW+0TFBQEvV6P8PBwtGvXDm5ubvlee0muO0v79+/HK6+8gj/++KNUXoul9PR0zJs3D48//jgaNGiAv//+G2fOnMGIESMAAC+//DK6deuGadOmYcqUKXB3d8f58+fxzTff4N1337W7fVT18V7KeynAeynvpZX7XlqYPn364O2338bOnTsRHByMDz/8EL/99pvSjdrT0xNz587F7NmzIcsyHnroISQlJeH48ePw8vLChAkTHNYWIiKqvljxWIkdPnwYtWvXtvp56KGHAADe3t7YvHkzevTogbZt2+Lbb7/Fl19+CV9fXwDAkiVLcOXKFTRq1EipPnjttdfQsWNHhISEoFevXggICMDQoUPznXf8+PFIT09H165dMXXqVMycORPPPvusTW329PTEypUr0blzZ3Tp0gVXrlzB119/bfO4T3Xq1MHx48dhNBrx6KOPok2bNpg1axa8vb2VY7z99tt4+OGHMXjwYPTr1w8PPfQQOnXqVOgxd+7cCXd3d/Tt2zfftr59+8LV1RUffvghAGDbtm0wGAzo1KkTZs2ale+X4QceeAChoaFYsGAB/P39bZ5JV5IkfP7556hRowYeeeQR9OvXDw0bNsSePXvu+9y4uDhcu3bNpvPk9dxzz2H48OEYPXo0HnzwQdy9excvvvhioft7eXnh+++/x8CBA9G0aVO89tprWL16NQYMGAAAmDJlCrZs2YLt27ejTZs26NmzJ8LCwhxWpZGeno7GjRvD399fWd+zZ0+kpKSgWbNmqF27dpHH8PX1haura4nbApgqNFq2bJnvgxJgGqcpPj4eX3/9tUPOlVe7du2wZs0avPXWW2jdujV27dqVb3yy7t274/nnn8fo0aPh5+eHlStX5jtOSa47S0lJSbhw4UKpvRZLarUad+/exfjx49G0aVOMGjUKAwYMQGhoKADT+G+RkZH4888/8fDDD6NDhw54/fXXUadOnWK1j6o+3kt5LwV4L+W9tHLfSwsTEhKChQsXYv78+ejSpQtSUlIwfvx4q32WLl2KhQsXYvny5WjRogX69++Pr776yiHXGxEREQBIIu/AH0REZSgiIgITJ07ElStXyrspRERElRLvpURERFRRseKRiIiIiIiIiIiIHI7BIxERERERERERETkcg0ciKldBQUGYNWtWeTeDiIio0uK9lIiIiCoqjvFIREREREREREREDseKRyIiIiIiIiIiInI4Bo9ERERERERERETkcFU+eBRCIDk5GexRTkREZB/eQ4mIiIiIqCSqfPCYkpICnU6HlJSU8m4KERFRpcJ7KBERERERlUSVDx6JiIiIiIiIiIio7DF4JCIiIiIiIiIiIodj8EhEREREREREREQOx+CRiIiIiIiIiIiIHI7BIxERERERERERETkcg0ciIiIiIiIiIiJyOAaPRERERERERERE5HAMHomIiIiIiIiIiMjhGDwSERERERERERGRwzF4JCIiIiIiIiIiIodj8EhEREREREREREQOx+CRiIiIiIiIiIiIHI7BIxERERERERERETkcg0ciIiIiIiIiIiJyOAaPRERERERERERE5HAMHomIiIiIiIiIiMjhGDwSERERERERERGRwzF4JCIiIiIiIiIiIodj8EhERERERFRNCCHKuwlERFSNMHgkIiIiIiKqJpg7EhFRWWLwSEREREREVE0IMHkkIqKyw+CRiIiIiIioGmA3ayIiKmsMHomIiIiIiIiIiMjhGDwSERERERFVAyx4JCKissbgkYiIiIiIqBrg+I5ERFTWGDwSERERERFVB8wdiYiojDF4JCIiIiIiqgZY8UhERGWNwSMREREREVE1wDEeiYiorDF4JCIiIiIiqhaYPBIRUdli8EhEREREREREREQOx+CRiIiIiIioGmBXayIiKmsMHomIiIiIiKoBTi5DRERljcEjERERERFRNcCKRyIiKmsMHomIiIiIiKoFJo9ERFS2GDwSERERERFVA6x4JCKissbgkYiIiIiIqBrgGI9ERFTWGDwSERERERFVB8wdiYiojDF4JCIiIiIiIiIiIodj8EhERERERFQNsKs1ERGVNQaPRERERERE1YAQgOAMM0REVIYYPBIREREREVUDAgICxvJuBhERVSMMHomIiIiIiKoDAQjB4JGIiMoOg0ciIiIiIqJqQEBUquCR3cKJiCo/Bo9ERERERETVgBCAgAwh5PJuik1kkV3eTSAiohJi8EhERERERFSNVIZxHk2hY+UISImIqHAMHomIiIiIiKoFU9flytDdWpZZ7UhEVBUweCQiIiIiIqoGzEMmypUheGQ3ayKiKoHBIxERERERUTUgKlPFo8gq7yYQEZEDMHgkIiIiIiKqBswVj0IYyrch9yELY6WZAIeIiIrG4JGIiIiIiKgaqeiTy7DakYio6mDwSEREREREVA0IYe5qLVfoikJOLENEVHUweCQiIiIiIqoGhNXjilv1yIlliIiqDgaPRERERERE1UxFnWDGVI1ZscegJCIi2zF4JCIiIiIiqg5Ebs2jXEGDR47vSERUtTB4JCIiIiIiqgasulpX0KpCdrMmIqpaGDwSERERERFVA8Ki4rGidrXmxDJERFULg0ciIiIiIqJqRq6AFY9CiArZLiIiKj4Gj0RERERERNWAZcUjICpc1aOpm7W4735ERFR5MHgkIiIiIiKqBvJGehVtghlOLENEVPVUmOBxxYoVkCQJs2bNUtZlZGRg6tSp8PX1hYeHB0aMGIFbt26VXyOJiIiIiIgqKeuKx4o3ziMnliEiqnoqRPB45swZbNq0CW3btrVaP3v2bHz55Zf49NNPERkZiRs3bmD48OHl1EoiIiIiIqKqQ6CCBY+cWIaIqMop9+BRr9dj3Lhx2Lx5M2rUqKGsT0pKwtatW7FmzRr06dMHnTp1wvbt2/HTTz/h5MmT5dhiIiIiIiKiyq8iTeTC8R2JiKqmcg8ep06dikGDBqFfv35W66OiopCdnW21vnnz5qhXrx5OnDhR6PEyMzORnJxs9UNERET3x3soEVHVlr+rdQUKHlntSERUJZVr8Pjxxx/j559/xvLly/Ntu3nzJpycnODt7W213t/fHzdv3iz0mMuXL4dOp1N+AgMDHd1sIiKiKon3UCKiqi1vPaEQRgghl0tb8uL4jkREVVO5BY/Xr1/HzJkzsWvXLri4uDjsuK+88gqSkpKUn+vXrzvs2ERERFUZ76FERFWcyN+VuaJ0t+aM1kREVZOmvE4cFRWF+Ph4dOzYUVlnNBrx/fff491338WRI0eQlZWFxMREq6rHW7duISAgoNDjOjs7w9nZuTSbTkREVCXxHkpEVHXl7WZtJossqOFUxq3J2wZDham8JCIixyq34LFv37749ddfrdZNmjQJzZs3x8svv4zAwEBotVqEh4djxIgRAIALFy7g2rVrCA4OLo8mExERERERVSmynAWoy7sN7GZNRFRVlVvw6OnpidatW1utc3d3h6+vr7J+8uTJmDNnDnx8fODl5YXp06cjODgY3bp1K48mExERERERVUqFFDxWiK7W7GZNRFR1lVvwaIu1a9dCpVJhxIgRyMzMREhICN57773ybhYREREREVGlIvJNLWOxRRghSeVX9sjgkYio6pJEYYN9VBHJycnQ6XRISkqCl5dXeTeHiIio0uA9lIio6jAaZdxMSICvTgsh0q22OWlqQK0qn3EeZWFAZvbdArc5aXRQqxw3ESkREZW9cpvVmoiIiIiIiMpG4RWPgBDGMmyJNY7vSERUtTF4JCIiIiIiquKK6ucmUH7jPMqCwSMRUVXG4JGIiIiIiKjKKzx5lMuz4pHBIxFRlcbgkYiIiIiIqBorr67WQsgQFWBWbSIiKj0MHomIiIiIiKq4Irtal1PwKDN0JCKq8hg8EhERERERVXFFTS4DCAghl1lbzNjNmoio6mPwSEREREREVMUVVfFo2l72VY+CwSMRUZXH4JGIiIiIiKjKKzp5FCj74JFdrYmIqj4Gj0RERERERFXc/Soey3pma1lkl9vYkkREVHYYPBIREREREVVxRY/xWPZdrY1yVpmej4iIygeDRyIiIiIioqrufmM8lnFXa04sQ0RUPTB4JCIiIiIiquIqWsUjJ5YhIqoeGDwSERERERFVc0IYIe43EKRDzyWXybmIiKh8MXgkIiIiIiKq4mzJFAXKJgzkbNZERNUHg0ciIiIiIqIq7n5drYGy627N4JGIqPpg8EhERERERFTV2VLxWEbBo2DwSERUbTB4JCIiIiIiquJsqngso5mtWfFIRFR9MHgkIiIiIiKq4mwa47EMJnwRQmbFIxFRNcLgkYiIiIiIqMqzpeKx9INHVjsSEVUvDB6JiIiIiIiqONsqHku/q7UQ2aV+DiIiqjgYPBIREREREVGZBI9GObPUz0FERBUHg0ciIiIiIqIqzpbJZQBRquGjLAyQWfFIRFStMHgkIiIiIiKq4mzpag0AcmkGj6x2JCKqdhg8EhEREREREYDS7W7NiWWIiKofBo9ERERERERVnLCx5FGg9MJBBo9ERNUPg0ciIiIiIqIqzsae1qVW8ShE6Y4fSUREFRODRyIiIiIioqrOxorH0hrjUQgDbI8/iYioqmDwSERERERERABMAaGt3bLtwW7WRETVE4NHIiIiIiKiKs6eKFHA8VWPssh2+DGJiKjiY/BIRERERERUxdlTxSiEXArnZ8UjEVF1xOCRiIiIiIiIFKUxCQy7WhMRVU8MHomIiIiIiKo4uyoeHdzV2ihngRPLEBFVTwweiYiIiIiIqji7xnh0cMWjQU5z6PGIiKjyYPBIRERERERUxdlT8ejobtGynOXQ4xERUeXB4JGIiIiIiIgUjqx4NIWY7GZNRFRdMXgkIiIiIiIiC8JhVY+czZqIqHpj8EhERERERFTF2dPVGgBkke2Q88qlMEM2ERFVHgweiYiIiIiIqjh7Ozs7qrs1Kx6JiKo3Bo9ERERERERVnZ0Vj44LHlnxSERUndkdPKanpyMtLU1Zvnr1KtatW4ejR486tGFERERERERUcvZ2swYcM7O1LIwO67JNRESVk93B45AhQ7Bz504AQGJiIh588EGsXr0aQ4YMwcaNGx3eQCIiIiIiIipbQhiLFVhaMsrpDmoNERFVVnYHjz///DMefvhhAMBnn30Gf39/XL16FTt37sQ777zj8AYSERERERFR8cnFChAFBErWTdooZ5bo+UREVPnZHTympaXB09MTAHD06FEMHz4cKpUK3bp1w9WrVx3eQCIiIiIiIip7JekmLYTg+I5ERGR/8Ni4cWMcOHAA169fx5EjR/Doo48CAOLj4+Hl5eXwBhIREREREVEJFLPHtCyXJHg0FP/ERERUZdgdPL7++uuYO3cugoKC8OCDDyI4OBiAqfqxQ4cODm8gERERERERFZ8oZgBYkopHR0xOQ0RElZ/G3ic8/vjjeOihhxAXF4d27dop6/v27Ythw4Y5tHFERERERERUMsWdI8Y8wYwkSXY/l7NZExERUIzgEQACAgIQEBBgta5r164OaRARERERERE5UnG7PAsIYYAkae1/JiseiYgINgaPw4cPt/mA+/btK3ZjiIiIiIiIyLGKW/EIAEaRCRXsDx7Z1ZqIiAAbx3jU6XTKj5eXF8LDw3H27Flle1RUFMLDw6HT6UqtoURERERERGS/4o7xCABGOdPu58icWIaIiHLYVPG4fft25fHLL7+MUaNG4f3334darQYAGI1GvPjii5zVmoiIiIiIqIIpScWjEAYIIUOSbJ+XlN2siYjITBLCvtuQn58ffvzxRzRr1sxq/YULF9C9e3fcvXvXoQ0sqeTkZOh0OiQlJTEYJSIisgPvoUREVUNGVjbuJicDAHx1WgiRbtfznTQ1oFY52bx/tjEVBqPernMUfF4d1CqXEh+HiIjKj+1fW+UwGAz4448/8q3/448/IMuyQxpFREREREREjlKybs/CzhmqWfFIRERmds9qPWnSJEyePBmxsbHKTNanTp3CihUrMGnSJIc3kIiIiIiIiIqvJF2tAfsniuHEMkREZGZ38Lhq1SoEBARg9erViIuLAwDUrl0b8+bNw0svveTwBhIREREREVHxlWRyGcD+IFEIY4nOR0REVYddwaPBYMBHH32ECRMmYP78+UjOGSeE4z4RERERERFVUCWseBTCCCEEJEm6776yMJb8hEREVGXYNcajRqPB888/j4yMDACmwJGhIxERERERUcVV0opH0xFsq3q0dzxIIiKq2uyeXKZr16743//+VxptISIiIiIiogrI1u7WHN+RiIgs2T3G44svvoiXXnoJf//9Nzp16gR3d3er7W3btnVY44iIiIiIiKhk5JLOLgNAlrMBlasN52LFIxER5ZKEsO8upFLlL5KUJEkZ88NorFgDCScnJ0On0yEpKYndwomIiOzAeygRUdWQkp6O5NQ0AICvTgsh0u0+hiSp4azxLXKcR1kYkJl9D44a49FJo4Na5eKQYxERUfmwu+Lx8uXLpdEOIiIiIiIiKg0OyAGFMMIoZ0CjLrzqMcuQ5JiTERFRlWF38Fi/fv3SaAcRERERERGVgpJPLmNikFMhYIBa5QaVpM6zLR2C4zsSEVEedgePABAbG4t169YhJiYGANCyZUvMnDkTjRo1cmjjiIiIiIiIqGQcMMRjznGMMBjTIISAkyZ3CA6jnAWDMdUxJyEioirF7lmtjxw5gpYtW+L06dNo27Yt2rZti1OnTqFVq1b45ptvSqONREREREREVGyO7f4si0xkG1NhMKbDYExFliEBQlSssf6JiKhisHtymQ4dOiAkJAQrVqywWr9gwQIcPXoUP//8s0MbWFIcGJ+IiKh4eA8lIqoaklJToU/PAFD8yWXKAyeXISKq/OyueIyJicHkyZPzrX/66adx/vx5u461ceNGtG3bFl5eXvDy8kJwcDAOHTqkbM/IyMDUqVPh6+sLDw8PjBgxArdu3bK3yURERERERNWWo7paExER2cvu4NHPzw/nzp3Lt/7cuXOoVauWXceqW7cuVqxYgaioKJw9exZ9+vTBkCFD8PvvvwMAZs+ejS+//BKffvopIiMjcePGDQwfPtzeJhMREREREVVbjppchoiIyF52Ty7zzDPP4Nlnn8Vff/2F7t27AwCOHz+Ot956C3PmzLHrWIMHD7ZaXrZsGTZu3IiTJ0+ibt262Lp1Kz766CP06dMHALB9+3a0aNECJ0+eRLdu3extOhERERERUbXDikciIiovdgePCxcuhKenJ1avXo1XXnkFAFCnTh0sXrwYM2bMKHZDjEYjPv30U6SmpiI4OBhRUVHIzs5Gv379lH2aN2+OevXq4cSJEwweiYiIiIiIiIiIKjCbg8djx46hR48ecHJywuzZszF79mykpKQAADw9PYvdgF9//RXBwcHIyMiAh4cH9u/fj5YtW+LcuXNwcnKCt7e31f7+/v64efNmocfLzMxEZmamspycnFzsthEREVUnvIcSEREREZEj2TzGY9++feHt7Y0+ffpg6dKlOH78OFxdXUsUOgJAs2bNcO7cOZw6dQovvPACJkyYYPckNZaWL18OnU6n/AQGBpaofURERNUF76FERFWTYF9rIiIqJ5Kw8S509epVfPfdd4iMjERERASuXbsGNzc39OjRA71790bv3r3RpUsXqFR2z1djpV+/fmjUqBFGjx6Nvn37IiEhwarqsX79+pg1axZmz55d4PMLqtYIDAxEUlISvLy8StQ2IiKiqoz3UCKiqulOcgoys7IAAL46LYRIL+cW2cZJo4Na5VLezSAiohKwOSWsX78+Jk2ahLCwMFy5cgWXLl3CO++8A39/f2zcuBHdu3eHj49PiRskyzIyMzPRqVMnaLVahIeHK9suXLiAa9euITg4uNDnOzs7w8vLy+qHiIiI7o/3UCIiIiIiciS7J5cxa9iwIdRqNSRJgiRJOHDgALJyvkWz1SuvvIIBAwagXr16SElJwUcffYSIiAgcOXIEOp0OkydPxpw5c+Dj4wMvLy9Mnz4dwcHBnFiGiIiIiIjIVuxqTURE5cSu4PHatWuIiIjAsWPHEBERgTt37qB79+54+OGHcfDgQTz44IN2nTw+Ph7jx49HXFwcdDod2rZtiyNHjuBf//oXAGDt2rVQqVQYMWIEMjMzERISgvfee8+ucxAREREREVVnjB2JiKi82DzGY8OGDZGQkIAePXrgkUcewSOPPILOnTtDoyl20WSZSE5Ohk6n4/hUREREduI9lIioaohPTEK2wQCAYzwSEVHZsnmMx/R0081JpVJBo9FAq9VCrVaXWsOIiIiIiIiIiIio8rI5eIyLi8OJEycwcOBAnDp1CoMGDUKNGjXw2GOPYdWqVThz5gxkWS7NthIREREREREREVElYXNX64LExMQo4z0ePXoUAJCYmOiotjkEu4kREREVD++hRERVw62ERBiMRgDsak1ERGXL5orHvG7duoVffvkFv/zyC6Kjo5GcnIzMzExHto2IiIiIiIiIiIgqKZtnhomPj0dERIQyq/Wff/4JrVaLrl27YsyYMejduzeCg4NLs61ERERERERkJ85qTURE5cXm4DEgIABarRadO3fGiBEj0Lt3b3Tv3h2urq6l2T4iIiIiIiIqgRKMrkVERFQiNgePhw4dwkMPPQR3d/fSbA8RERERERERERFVATYHjyEhIaXZDiIiIiIiIiIiIqpCij25DBEREREREVV87GpNRETlhcEjERERERFRFcbYkYiIyguDRyIiIiIioqqMFY9ERFROGDwSERERERERERGRw9k0ucw777xj8wFnzJhR7MYQERERERGR43B8RyIiKk82BY9r1661Wr59+zbS0tLg7e0NAEhMTISbmxtq1arF4JGIiIiIiKiCYO5IRETlyaau1pcvX1Z+li1bhvbt2yMmJgb37t3DvXv3EBMTg44dO2Lp0qWl3V4iIiIiIiIiIiKqBCRhZ+19o0aN8Nlnn6FDhw5W66OiovD444/j8uXLDm1gSSUnJ0On0yEpKQleXl7l3RwiIqJKg/dQIqLKzyjLuHkvQVn21WkhRHo5tsh2Thod1CqX8m4GERGVgN2Ty8TFxcFgMORbbzQacevWLYc0ioiIiIiIiByAXa2JiKgc2R089u3bF8899xx+/vlnZV1UVBReeOEF9OvXz6GNIyIiIiIiouITTB6JiKgc2R08btu2DQEBAejcuTOcnZ3h7OyMrl27wt/fH1u2bCmNNhIREREREREREVElY9Os1pb8/Pzw9ddf488//8Qff/wBAGjevDmaNm3q8MYRERERERFR8XFWayIiKk92B49mQUFBEEKgUaNG0GiKfRgiIiIiIiIqNUweiYio/Njd1TotLQ2TJ0+Gm5sbWrVqhWvXrgEApk+fjhUrVji8gURERERERERERFT52B08vvLKK4iOjkZERARcXFyU9f369cOePXsc2jgiIiIiIiIqvrxdrYWQy6chRERULdkdPB44cADvvvsuHnroIUiSpKxv1aoVYmNjHdo4IiIiIiIiKj7LWa2zjDcRE7ceGdm3y7FFRERUndgdPN6+fRu1atXKtz41NdUqiCQiIiIiIqLyZa54zDLG4ZZ+GzKyb+LirTCGj0QO1qtXL8yaNavIfYKCgrBu3TplWZIkHDhwoFTbFRYWBm9v71I9R0U8N1UcdgePnTt3xldffaUsm8PGLVu2IDg42HEtIyIiIiIiIofINsZDFukAAIOciovxO5CRfaecW0Vl5ebNm5g+fToaNmwIZ2dnBAYGYvDgwQgPDy/vppWaiIgISJKExMTE8m5KoeLi4jBgwACHHS9vsAkAo0ePxp9//umwc1TEcxeF4Wf5s3s66jfffBMDBgzA+fPnYTAYsH79epw/fx4//fQTIiMjS6ONREREREREVCymkkd3p3YQwoi76fsBCBiMelyK34HGtSbCRetbvk2kUnXlyhX06NED3t7eePvtt9GmTRtkZ2fjyJEjmDp1Kv7444/ybmK1FRAQUOrncHV1haura6mfp6KdmyoOuyseH3roIZw7dw4GgwFt2rTB0aNHUatWLZw4cQKdOnUqjTYSERERERFRMVhOLuPh3BH1fUcoy9nGFFyKD0Nm9t1yaBmVlRdffBGSJOH06dMYMWIEmjZtilatWmHOnDk4efKkst+1a9cwZMgQeHh4wMvLC6NGjcKtW7eU7YsXL0b79u2xbds21KtXDx4eHnjxxRdhNBqxcuVKBAQEoFatWli2bJnV+SVJwqZNm/DYY4/Bzc0NLVq0wIkTJ3Dp0iX06tUL7u7u6N69e745Iz7//HN07NgRLi4uaNiwIUJDQ2EwGKyOu2XLFgwbNgxubm5o0qQJvvjiCwCmsLV3794AgBo1akCSJEycOLHA98dcEXfgwAE0adIELi4uCAkJwfXr15V9Jk6ciKFDh1o9b9asWejVq5fVOoPBgGnTpkGn06FmzZpYuHAhRN4ZnvK8N5Zdrf/++2888cQT8PHxgbu7Ozp37oxTp04BAGJjYzFkyBD4+/vDw8MDXbp0wbfffqs8t1evXrh69Spmz54NSZKU3qkFVfxt3LgRjRo1gpOTE5o1a4YPPvggX7sKe28LYuu5i3sNJSYmYsqUKfDz84OXlxf69OmD6OhoZXt0dDR69+4NT09PeHl5oVOnTjh79iwiIiIwadIkJCUlKe1avHgxAOCDDz5A586d4enpiYCAAIwdOxbx8fHKMc0Vs0eOHEGHDh3g6uqKPn36ID4+HocOHUKLFi3g5eWFsWPHIi0tzeq9mDZtml3XQVVnd/AIAI0aNcLmzZtx+vRpnD9/Hh9++CHatGnj6LYRERERERFRCVhOLgMAvh5dEOgzWFnONqbgYvwOZBrulXXTqAzcu3cPhw8fxtSpU+Hu7p5vuzkUkmUZQ4YMwb179xAZGYlvvvkGf/31F0aPHm21f2xsLA4dOoTDhw9j9+7d2Lp1KwYNGoS///4bkZGReOutt/Daa68pYZnZ0qVLMX78eJw7dw7NmzfH2LFj8dxzz+GVV17B2bNnIYTAtGnTlP1/+OEHjB8/HjNnzsT58+exadMmhIWF5QukQkNDMWrUKPzyyy8YOHAgxo0bh3v37iEwMBB79+4FAFy4cAFxcXFYv359oe9TWloali1bhp07d+L48eNITEzEmDFj7HqvAWDHjh3QaDQ4ffo01q9fjzVr1mDLli02PVev16Nnz574559/8MUXXyA6Ohrz58+HLMvK9oEDByI8PBz/+9//0L9/fwwePBjXrl0DAOzbtw9169bFkiVLEBcXh7i4uALPs3//fsycORMvvfQSfvvtNzz33HOYNGkSjh07ZrVfYe9tQWw9N1C8a2jkyJFK4BcVFYWOHTuib9++SnvGjRuHunXr4syZM4iKisKCBQug1WrRvXt3rFu3Dl5eXkq75s6dCwDIzs7G0qVLER0djQMHDuDKlSsFhtOLFy/Gu+++i59++gnXr1/HqFGjsG7dOnz00Uf46quvcPToUWzYsMHqOfe7DhYvXoygoKBC36MqR9ipd+/eYvHixfnW37t3T/Tu3dvew5W6pKQkAUAkJSWVd1OIiIgqFd5DiYgqv9SMDPH37TvKT3pWkkjLvCmu3T0ojl98Xvk5/dd8kZAaI9Iyb1aYH4Mxvbzfvkrv1KlTAoDYt29fkfsdPXpUqNVqce3aNWXd77//LgCI06dPCyGEWLRokXBzcxPJycnKPiEhISIoKEgYjUZlXbNmzcTy5cuVZQDitddeU5ZPnDghAIitW7cq63bv3i1cXFyU5b59+4o333zTqo0ffPCBqF27dqHH1ev1AoA4dOiQEEKIY8eOCQAiISGhyNe+fft2AUCcPHlSWRcTEyMAiFOnTgkhhJgwYYIYMmSI1fNmzpwpevbsqSz37NlTtGjRQsiyrKx7+eWXRYsWLZTl+vXri7Vr11q9hv379wshhNi0aZPw9PQUd+/eLbK9llq1aiU2bNhQ6PHNr0+n0ynL3bt3F88884zVPiNHjhQDBw60aldR721BbDl3ca6hH374QXh5eYmMjAyrYzdq1Ehs2rRJCCGEp6enCAsLK7BdedtQmDNnzggAIiUlRQiRe/18++23yj7Lly8XAERsbKyy7rnnnhMhISHKsi3XwYYNG0SfPn3u26aqwu6Kx4iICLz77rsYOnQoUlNTlfVZWVkc45GIiIiIiKgiKaR3X02PzgisMUhZzjYm49KtMGQaEsqoYVQWhI3dO2NiYhAYGIjAwEBlXcuWLeHt7Y2YmBhlXVBQEDw9PZVlf39/tGzZEiqVymqdZZdVAGjbtq3VdgBWvSb9/f2RkZGB5ORkAKaus0uWLIGHh4fy88wzzyAuLs6qW6vlcd3d3eHl5ZXv3LbQaDTo0qWLsty8efN8r90W3bp1U7oZA0BwcDAuXrwIo9F43+eeO3cOHTp0gI+PT4Hb9Xo95s6dixYtWsDb2xseHh6IiYlRKh5tFRMTgx49elit69GjR77X6qj3Ni97r6Ho6Gjo9Xr4+vpaXQ+XL19WuufPmTMHU6ZMQb9+/bBixYp83fYLEhUVhcGDB6NevXrw9PREz549ASDf+5n32nVzc0PDhg0LbKvZ/a6DadOmVemJnfIqVlfrb7/9Fjdv3kS3bt1w5coVBzeJiIiIiIiIHCFvV2tLNT27oG6NgcpyljEJl27tQJYhsQxaRmWhSZMmkCTJYRPIaLVaq2VJkgpcZ+4eXNDzzIFMQessuxWHhobi3Llzys+vv/6KixcvwsXFpcj25D23I6hUqnwhbnZ2tkPPcb9JWObOnYv9+/fjzTffxA8//IBz586hTZs2yMrKcmg7zErrvbX3GtLr9ahdu7bVtXDu3DlcuHAB8+bNA2Dquvz7779j0KBB+O6779CyZUvs37+/0DakpqYiJCQEXl5e2LVrF86cOaPsn/f9zHudltU1V5UUK3isXbs2IiMj0aZNG3Tp0gUREREObhYRERERERGV1P0K3vw8u6JujQHKcpYxERdvhTF8rCJ8fHwQEhKC//73v1Y9Fs0SExMBAC1atMD169etJlQ5f/48EhMT0bJly7JqrqJjx464cOECGjdunO/HsjKuKE5OTgBgU7WhwWDA2bNnleULFy4gMTERLVq0AAD4+fnlG7fw3Llz+Y6Td2zLkydPokmTJlCr1fdtQ9u2bXHu3LlCx1E8fvw4Jk6ciGHDhqFNmzYICAjIVwjm5OR039fbokULHD9+PN+xS/r3bMu5i6Njx464efMmNBpNvmuhZs2ayn5NmzbF7NmzcfToUQwfPhzbt28vtF1//PEH7t69ixUrVuDhhx9G8+bNHVLNaVaS66Aqsjt4NH8T4ezsjI8++ggzZ85E//798d577zm8cURERERERFS6/DwfxAM1+ivLWcZEXIzfgSxDUjm2ihzlv//9L4xGI7p27Yq9e/fi4sWLiImJwTvvvIPg4GAAQL9+/dCmTRuMGzcOP//8M06fPo3x48ejZ8+e6Ny5c5m3+fXXX8fOnTsRGhqK33//HTExMfj444/x2muv2XyM+vXrQ5IkHDx4ELdv34Zery90X61Wi+nTp+PUqVOIiorCxIkT0a1bN3Tt2hUA0KdPH5w9exY7d+7ExYsXsWjRIvz222/5jnPt2jXMmTMHFy5cwO7du7FhwwbMnDnTpvY+8cQTCAgIwNChQ3H8+HH89ddf2Lt3L06cOAHAVL26b98+nDt3DtHR0Rg7dmy+SrugoCB8//33+Oeff3Dnzp0CzzNv3jyEhYVh48aNuHjxItasWYN9+/Ypk64Uly3nLo5+/fohODgYQ4cOxdGjR3HlyhX89NNPePXVV3H27Fmkp6dj2rRpiIiIwNWrV3H8+HGcOXNGCY2DgoKg1+sRHh6OO3fuIC0tDfXq1YOTkxM2bNiAv/76C1988QWWLl3qsDbf7zp499130bdvX4edr6KzO3jMW1782muvYdeuXVi9erXDGkVEREREREQlV1RXa0u1PLvhAe8QZTnLkICL8WHIMiSXVtOojDRs2BA///wzevfujZdeegmtW7fGv/71L4SHh2Pjxo0ATAVGn3/+OWrUqIFHHnkE/fr1Q8OGDbFnz55yaXNISAgOHjyIo0ePokuXLujWrRvWrl2L+vXr23yMBx54AKGhoViwYAH8/f2tZs3Oy83NDS+//DLGjh2LHj16wMPDw+q1h4SEYOHChZg/fz66dOmClJQUjB8/Pt9xxo8fj/T0dHTt2hVTp07FzJkz8eyzz9rUXicnJxw9ehS1atXCwIED0aZNG6xYsUKpkluzZg1q1KiB7t27Y/DgwQgJCUHHjh2tjrFkyRJcuXIFjRo1gp+fX4HnGTp0KNavX49Vq1ahVatW2LRpE7Zv345evXrZ1M7C2HLu4pAkCV9//TUeeeQRTJo0CU2bNsWYMWNw9epV+Pv7Q61W4+7duxg/fjyaNm2KUaNGYcCAAQgNDQUAdO/eHc8//zxGjx4NPz8/rFy5En5+fggLC8Onn36Kli1bYsWKFVi1apXD2ny/6+DOnTs2jUNZVUjC1tFmc1y9ehWBgYH5ypt/++03REVFYcKECQ5tYEklJydDp9MhKSkJXl5e5d0cIiKiSoP3UCKiyi8lLR3JFpNx+Oq0ECK90P1vJf+EG4lHlWVnjQ+a1JoIrabs7wNOGh3UKpf770hUAmFhYZg1a5bS7ZyoJHr16oX27dtj3bp15d2UCkNj7xMK+4ahdevWaN26dYkbRERERERERI5ha8Wjmb9XdwACNxK/AQBkGu7hYvwONPGfCK3as+gnExER5WFT8Dh8+HCEhYXBy8sLw4cPL3Lfffv2OaRhREREREREVPb8vXpACBlxSeEAgEzDXVy8tQNN/CcwfCQiIrvYFDzqdDplUhmdTleqDSIiIiIiIiLHsG9grVwBuocBCMQlfQcAyDTcwaVbO9DYfyK0ag/HNZConE2cOBETJ04s72ZQFREREVHeTahw7BrjUQiB69evw8/PD66urqXZLofh+FRERETFw3soEVHll5SaCn16hrJ8vzEe87qZFIm4pGPKsovWD41rTSiT8JFjPBIRVX52zWothEDjxo3x999/l1Z7iIiIiIiIyEGKW/FoFqDriQBdL2U5I/s2LsXvRLYxtWQHJiKiasGu4FGlUqFJkya4e/duabWHiIiIiIiIHMTeyWUKUlvXCwFejyjLGdnxuBS/AwaGj0REdB92BY8AsGLFCsybNw+//fZbabSHiIiIiIiIKpgAXW/4ez2sLJvCx50wGNPKsVVERFTR2TXGIwDUqFEDaWlpMBgMcHJyyjfW47179xzawJLi+FRERETFw3soEVHldy9Fj/TMTGXZ3jEeLQkhEJcUjlvJPyrrXLUBaFxrPDRqtxK3NS+O8UhEVPnZNKu1pXXr1pVCM4iIiIiIiKgikyQJtXV9IYRAfMpxAEB69k1civ8Ajf3HQ6OqHBOQEhFR2bE7eJwwYUJptIOIiIiIiIgczM4ObvclSRLqePcDIBCf8hMAID07Dpfid5oqHxk+VhmLFy/Gxo0bER8fj/3792Po0KHl3SQiqoTsHuPRUkZGBpKTk61+iIiIiIiIqGJwbOxoYgof/wU/z27KuvSsOMTGfwCDXLxu3OQYEydOhCRJyo+vry/69++PX375xa7jxMTEIDQ0FJs2bUJcXBwGDBhQSi2miq5Xr16YNWtWeTeDKjG7g8fU1FRMmzYNtWrVgru7O2rUqGH1Q0RERERERBWEgysezSRJwgPeIfDzfFBZl5Z1A7HxH8IoZ5TKOck2/fv3R1xcHOLi4hAeHg6NRoPHHnvMrmPExsYCAIYMGYKAgAA4OzsXqy3Z2dnFeh4RVR12B4/z58/Hd999h40bN8LZ2RlbtmxBaGgo6tSpg507d5ZGG4mIiIiIiKiCMYWP/eHn0VVZl5b1Dy4xfCxXzs7OCAgIQEBAANq3b48FCxbg+vXruH37trLP9evXMWrUKHh7e8PHxwdDhgzBlStXAJi6WA8ePBgAoFKpIEkSAECWZSxZsgR169aFs7Mz2rdvj8OHDyvHvHLlCiRJwp49e9CzZ0+4uLhg165dAIAtW7agRYsWcHFxQfPmzfHee+8V+RoOHz6Mhx56CN7e3vD19cVjjz2mhKGW59q3bx969+4NNzc3tGvXDidOnFD2CQsLg7e3N44cOYIWLVrAw8NDCWXN7veaIiIiIEkSEhMTlXXnzp2DJEnK+2XLeQBg27ZtaNWqFZydnVG7dm1MmzZN2ZaYmIgpU6bAz88PXl5e6NOnD6Kjo5XtixcvRvv27bFt2zbUq1cPHh4eePHFF2E0GrFy5UoEBASgVq1aWLZsmdU5bT3uBx98gKCgIOh0OowZMwYpKSkATBW0kZGRWL9+vVJFa37dRLayO3j88ssv8d5772HEiBHQaDR4+OGH8dprr+HNN99U/lMhIiIqTY4er4qIiKiqKu07piRJeKDGANT06KKsS8v6G7Hxu2CUM4t4ZuUihECKPrPcfor7u49er8eHH36Ixo0bw9fXF4CpCjEkJASenp744YcfcPz4cSUsy8rKwty5c7F9+3YAUConAWD9+vVYvXo1Vq1ahV9++QUhISH497//jYsXL1qdc8GCBZg5cyZiYmIQEhKCXbt24fXXX8eyZcsQExODN998EwsXLsSOHTsKbXdqairmzJmDs2fPIjw8HCqVCsOGDYMsy1b7vfrqq5g7dy7OnTuHpk2b4oknnoDBYFC2p6WlYdWqVfjggw/w/fff49q1a5g7d66y3dbXdD/3O8/GjRsxdepUPPvss/j111/xxRdfoHHjxsr2kSNHIj4+HocOHUJUVBQ6duyIvn374t69e8o+sbGxOHToEA4fPozdu3dj69atGDRoEP7++29ERkbirbfewmuvvYZTp07ZfdwDBw7g4MGDOHjwICIjI7FixQrl/QkODsYzzzyjXAuBgYF2vTdEdk8uc+/ePTRs2BAA4OXlpVywDz30EF544QXHto6IiKgAsiygVkvl3QwiIqIKryy+rJMkCXVrDAAgcEd/FgCQmnUdsbc/RCO/J6FWFa+bbkWiT81Cz2Efltv5I/c/CU8P297HgwcPwsPDA4ApwKtduzYOHjwIlcpUd7Rnzx7IsowtW7Yo1Yzbt2+Ht7c3IiIi8Oijj8Lb2xsAEBAQoBx31apVePnllzFmzBgAwFtvvYVjx45h3bp1+O9//6vsN2vWLAwfPlxZXrRoEVavXq2sa9CgAc6fP49NmzYVOnntiBEjrJa3bdsGPz8/nD9/Hq1bt1bWz507F4MGDQIAhIaGolWrVrh06RKaN28OwBSyvv/++2jUqBEAYNq0aViyZIndr+l+7neeN954Ay+99BJmzpyprOvSxRTW//jjjzh9+jTi4+OVLu2rVq3CgQMH8Nlnn+HZZ58FYKrO3LZtGzw9PdGyZUv07t0bFy5cwNdffw2VSoVmzZop7X/wwQftOm5YWBg8PT0BAE899RTCw8OxbNky6HQ6ODk5wc3NzepaILKH3RWPDRs2xOXLlwEAzZs3xyeffALAVAlp/s+JiIioNMlCvv9OREREVGYkSYW6NQbC16OTsi418zpib++CUc4qx5ZVP71798a5c+dw7tw5nD59GiEhIRgwYACuXr0KAIiOjsalS5fg6ekJDw8PeHh4wMfHBxkZGVbdmS0lJyfjxo0b6NGjh9X6Hj16ICYmxmpd586dlcepqamIjY3F5MmTlXN5eHjgjTfeKPRcAHDx4kU88cQTaNiwIby8vBAUFAQAuHbtmtV+bdu2VR7Xrl0bABAfH6+sc3NzU8JA8z7m7fa8pvsp6jzx8fG4ceMG+vbtW+Bzo6Ojodfr4evra/UeXb582eo9CgoKUsJBAPD390fLli2VQNm8znze4h7Xsu1EjmB3xeOkSZMQHR2Nnj17YsGCBRg8eDDeffddZGdnY82aNaXRRiIiIitGWUBb3o0gIiKqBMpyeBJJUiGwxiBACNxN/RkAkJp5DX/d3oWGfuOgVjmVWVuqM3d3d6tuvFu2bIFOp8PmzZvxxhtvQK/Xo1OnTgUOlebn5+eQ85vp9XoAwObNm/Hggw9a7adWqws9xuDBg1G/fn1s3rwZderUgSzLaN26NbKyrENsrTb3N0LLsSgL2m7ex55/E+ZQz/I5BU2YU9R5XF1dizyHXq9H7dq1ERERkW+bZXFXQecoaJ359ZfkuHm7tBOVhN3B4+zZs5XH/fr1wx9//IGoqCg0btzY6tsGIiKi0sKKRyIioopJklQI9HkMAjLupZ4DAOgzr+Kv2x+hkd9YqCpp+Ojh7oTI/U+W6/mLS5IkqFQqpKenAwA6duyIPXv2oFatWvDy8rLpGF5eXqhTpw6OHz+Onj17KuuPHz+Orl27Fvo8f39/1KlTB3/99RfGjRtn07nu3r2LCxcuYPPmzXj44YcBmLojO5otr8kcxMbFxaFGjRoATJPL2MPT0xNBQUEIDw9H7969823v2LEjbt68CY1Go1R2OoKjjuvk5ASj0eiwdlH1Y3fwmFf9+vVRv359R7SFiIjovmRZcHIZIiIiG5XHHVOSVKjn828AAvdSTTPo6jOvIPb2bjTye6JSho+SJNk8xmJ5y8zMxM2bNwEACQkJePfdd6HX65WZqseNG4e3334bQ4YMUWZ0vnr1Kvbt24f58+ejbt26BR533rx5WLRoERo1aoT27dtj+/btOHfu3H0nmQ0NDcWMGTOg0+nQv39/ZGZm4uzZs0hISMCcOXPy7V+jRg34+vri//7v/1C7dm1cu3YNCxYsKOG7UrD7vabGjRsjMDAQixcvxrJly/Dnn39i9erVdp9n8eLFeP7551GrVi0MGDAAKSkpOH78OKZPn45+/fohODgYQ4cOxcqVK9G0aVPcuHEDX331FYYNG2bVdd0ejjpuUFAQTp06hStXrijd8i27dxPdj03B4zvvvGPzAWfMmFHsxhAREd0Pqx2JiIhsV15f1pnCxyEQQiAh7RcAgD7zMv668zEa1nwCKhUHTSkthw8fVsY79PT0RPPmzfHpp5+iV69eAEzjEX7//fd4+eWXMXz4cKSkpOCBBx5A3759i6yAnDFjBpKSkvDSSy8hPj4eLVu2xBdffIEmTZoU2Z4pU6bAzc0Nb7/9NubNmwd3d3e0adMGs2bNKnB/lUqFjz/+GDNmzEDr1q3RrFkzvPPOO0r7Hel+r0mr1WL37t144YUX0LZtW3Tp0gVvvPEGRo4cadd5JkyYgIyMDKxduxZz585FzZo18fjjjwMwhdpff/01Xn31VUyaNAm3b99GQEAAHnnkEfj7+xf7tTnquHPnzsWECRPQsmVLpKen4/Llyw6tzKSqTxI23IkaNGhg28EkCX/99VeJG+VIycnJ0Ol0SEpKsrmMnIiIKq6sbAOyjQa4u7iUd1OqPN5DiYgqv7h7CVbjtfnqtBAivczOL4SMq3f3IyHtV2Wdp0sjNPQbA5VUdPjopNFBreL9noioMrOp4tE8izUREVF5Y8UjERGR7cp7eBJJUqG+7zAAAglpvwEAUjJi8dftPWjoN/q+4SMREVVuJeqYLwTH2SIiorJl5Cx7RERENqsIn9bM4aO3WytlXUrGJVy+/QlkYSjHlhERUWkrVvC4c+dOtGnTBq6urnB1dUXbtm3xwQcfOLptRERE+chyRfgIRUREVElUkEIRSVIjyHc4vN1aKuuSMy4yfCQiquLsDh7XrFmDF154AQMHDsQnn3yCTz75BP3798fzzz+PtWvXlkYbiYiIFOxqTUREZJuK1jvNFD6OgLdrC2VdcsafuHLnU4aPRERVlE2Ty1hq0KABQkNDMX78eKv1O3bswOLFiyvceJAcGJ+IqGq5l6KHs1bDyWXKAO+hRESVmywLxN27Z7WurCeXKYgQRly+8ymS0v9Q1ulcmyOo5uNQSbnTEHByGSKiys/uise4uDh079493/ru3bsjLi7OIY0iIiIqjMwxHomIiGwiKsQIj/lJkhpBNR+HzrW5si4p/Q9cubMXQhjLsWVERORodgePjRs3xieffJJv/Z49e9CkSROHNIqIiKgwcgXrNkZERET2U0kaBNV8HF6uTZV1SekxDB+JiKoYzf13sRYaGorRo0fj+++/R48ePQAAx48fR3h4eIGBJBERkSNxVmsiIiIbVfDv6lSSBg1qjsLl23uQnHERAJCYfh5X7koI8h1ezq0jIiJHsLviccSIETh9+jRq1qyJAwcO4MCBA6hZsyZOnz6NYcOG2XWs5cuXo0uXLvD09EStWrUwdOhQXLhwwWqfjIwMTJ06Fb6+vvDw8MCIESNw69Yte5tNRERVgBCiUna1FsIIwUlxiIiojFXUrtaWVJIGDfxGw8ulsbIuMe13XLm7n5WPRERVgF3BY3JyMr755hvExcVh7dq1iIqKQlRUFD788EN06NDB7pNHRkZi6tSpOHnyJL755htkZ2fj0UcfRWpqqrLP7Nmz8eWXX+LTTz9FZGQkbty4geHD+e0XEVF1JMsV/wNUXrKcjUzDPQgweCQiorJVWUYnMYePnlbh42+Ivf0Rv7grBUIIPPvss/Dx8YEkSTh37lx5N4kqgYkTJ2Lo0KElPs7x48fRpk0baLVahxyvpMLCwuDt7e3QY165coX/tizYHDyeO3cOzZs3R//+/TF48GA0btwYR44cKdHJDx8+jIkTJ6JVq1Zo164dwsLCcO3aNURFRQEAkpKSsHXrVqxZswZ9+vRBp06dsH37dvz00084efJkic5NRESVj1zJPnwY5HRkGhL4oYmIiMpJJUkeAagkLRr6jYanS0Nl3V39z7gUv5P30WI4ceIE1Go1Bg0alG/b4cOHERYWhoMHDyIuLg6tW7eGJEk4cOBA2TeUylxQUBDWrVtXbuefM2cO2rdvj8uXLyMsLKzc2kG269WrF2bNmlXs59scPL788sto0KABfvzxR0RFRaFv376YNm1asU9ckKSkJACAj48PACAqKgrZ2dno16+fsk/z5s1Rr149nDhxosBjZGZmIjk52eqHiIiqhso0vmO2MQXZhmRUpg99vIcSEVUtlaXi0UwladGw5hNW4ePtlFNISr9QxLOoIFu3bsX06dPx/fff48aNG1bbYmNjUbt2bXTv3h0BAQHQaOye+qFQ2dnZDjsWVU2xsbHo06cP6tatW+xKw6ysLMc2ikqVzcFjVFQUNmzYgODgYHTo0AHbtm1DbGyswz6UyLKMWbNmoUePHmjdujUA4ObNm3Bycsp3Mfr7++PmzZsFHmf58uXQ6XTKT2BgoEPaR0RE5a+ydLXOMiTDYEwr72bYjfdQIiIqbyqVFg1rjoGHcxAAoKHfGHi7tSjfRlUyer0ee/bswQsvvIBBgwZZVZVNnDgR06dPx7Vr1yBJEoKCghAUFAQAGDZsmLLO7PPPP0fHjh3h4uKChg0bIjQ0FAaDQdkuSRI2btyIf//733B3d8eyZcsKbNMHH3yAzp07w9PTEwEBARg7dizi4+OV7REREZAkCeHh4ejcuTPc3NzQvXt3qzkgFi9ejPbt2+ODDz5AUFAQdDodxowZg5SUFGWfzMxMzJgxA7Vq1YKLiwseeughnDlzRtleULfaAwcOQJIku84jyzJWrlyJxo0bw9nZGfXq1bN67devX8eoUaPg7e0NHx8fDBkyBFeuXLH6exg6dCjefPNN+Pv7w9vbG0uWLIHBYMC8efPg4+ODunXrYvv27VZttfW4q1atQu3ateHr64upU6cqgXCvXr1w9epVzJ49G5IkWb1uW4WGhsLPzw9eXl54/vnnrUJAWZaxfPlyNGjQAK6urmjXrh0+++wzALndj+/evYunn34akiQp12ZkZCS6du0KZ2dn1K5dGwsWLLC6znr16oVp06Zh1qxZqFmzJkJCQgAAv/32GwYMGAAPDw/4+/vjqaeewp07d4psf1hYGOrVqwc3NzcMGzYMd+/ezbePrdf9gAED4OrqioYNGyqvszBFvcadO3fC19cXmZmZVs8ZOnQonnrqKQC51+W2bdtQr149eHh44MUXX4TRaMTKlSsREBCAWrVq5fs3mJiYiClTpih/Z3369EF0dLSy/X7X+8SJExEZGYn169cr14zlNWcLm4PHe/fuoW7dusqyt7c33N3dC/xLKo6pU6fit99+w8cff1yi47zyyitISkpSfq5fv+6Q9hERUfkzVoKuVlmGZBjl9PJuRrHwHkpEVLVUhsllCqJSOaGh31g08X8aAbqe5d0cAKZxEfXpGeX2I+woX/3kk0/QvHlzNGvWDE8++SS2bdumPH/9+vVYsmQJ6tati7i4OJw5c0YJ5rZv366sA4AffvgB48ePx8yZM3H+/Hls2rQJYWFh+YKNxYsXY9iwYfj111/x9NNPF9im7OxsLF26FNHR0Thw4ACuXLmCiRMn5tvv1VdfxerVq3H27FloNJp8x4uNjcWBAwdw8OBBHDx4EJGRkVixYoWyff78+di7dy927NiBn3/+GY0bN0ZISAju3btn8/tny3leeeUVrFixAgsXLsT58+fx0Ucfwd/fX3mtISEh8PT0xA8//IDjx4/Dw8MD/fv3twrpvvvuO9y4cQPff/891qxZg0WLFuGxxx5DjRo1cOrUKTz//PN47rnn8Pfff9t13GPHjiE2NhbHjh3Djh07EBYWpgR8+/btQ926dbFkyRLExcUhLi7OrvclPDwcMTExiIiIwO7du7Fv3z6EhoYq25cvX46dO3fi/fffx++//47Zs2fjySefRGRkJAIDAxEXFwcvLy+sW7cOcXFxGD16NP755x8MHDgQXbp0QXR0NDZu3IitW7fijTfesDr3jh074OTkhOPHj+P9999HYmIi+vTpgw4dOuDs2bM4fPgwbt26hVGjRhXa/lOnTmHy5MmYNm0azp07h969e+c7j63X/cKFCzFixAhER0dj3LhxGDNmDGJiYgo87/1e48iRI2E0GvHFF18oz4mPj8dXX31l9W8gNjYWhw4dwuHDh7F7925s3boVgwYNwt9//43IyEi89dZbeO2113Dq1CnlOSNHjkR8fDwOHTqEqKgodOzYEX379rX6N1HU9b5+/XoEBwfjmWeeUa4Ze4sT7KqpPn/+vFWloRACMTExVsl/27Zt7WoAAEybNg0HDx7E999/bxVuBgQEICsrC4mJiVbfSty6dQsBAQEFHsvZ2RnOzs52t4GIiCq+ij6jdbZRX2lDR4D3UCKiqqaydbW2pFY5wce9TXk3Q5GakYnRb64pt/Pv+c8ceLi62LTv1q1b8eSTTwIA+vfvj6SkJERGRqJXr17Q6XTw9PSEWq3O95na29vbal1oaCgWLFiACRMmAAAaNmyIpUuXYv78+Vi0aJGy39ixYzFp0qQi22QZnjRs2BDvvPMOunTpAr1eDw8PD2XbsmXL0LOnKWxesGABBg0ahIyMDLi4mF67LMsICwuDp6cnAOCpp55CeHg4li1bhtTUVGzcuBFhYWEYMGAAAGDz5s345ptvsHXrVsybN8+m9+9+50lJScH69evx7rvvKu9No0aN8NBDDwEA9uzZA1mWsWXLFqWicPv27fD29kZERAQeffRRAKYh5t555x2oVCo0a9YMK1euRFpaGv7zn/8AyA03f/zxR4wZM8bm49aoUQPvvvsu1Go1mjdvjkGDBiE8PBzPPPMMfHx8oFarlcpTezk5OWHbtm1wc3NDq1atsGTJEsybNw9Lly5FdnY23nzzTXz77bcIDg4GYPq7/vHHH7Fp0yb07NkTAQEBkCQJOp1OOf97772HwMBAvPvuu5AkCc2bN8eNGzfw8ssv4/XXX4dKZaqXa9KkCVauXKm05Y033kCHDh3w5ptvKuu2bduGwMBA/Pnnn2jatGm+9q9fvx79+/fH/PnzAQBNmzbFTz/9hMOHDyv72Hrdjxw5ElOmTAEALF26FN988w02bNiA9957L9957/caXV1dMXbsWGzfvh0jR44EAHz44YeoV68eevXqpRxHlmVs27YNnp6eaNmyJXr37o0LFy7g66+/Vq6jt956C8eOHcODDz6IH3/8EadPn0Z8fLzyO/6qVatw4MABfPbZZ3j22WeV4xZ2vet0Ojg5OcHNza1Y1wxgZ/DYt2/ffN+0PPbYY5AkCUIISJIEo9Fo8/GEEJg+fTr279+PiIgINGjQwGp7p06doNVqER4ejhEjRgAALly4gGvXrikXMhERVR/GCtzVOtuoh8GYWt7NICIislBx75tUOi5cuIDTp09j//79AACNRoPRo0dj69atVgGGLaKjo3H8+HGrSi+j0YiMjAykpaXBzc0NANC5c+f7HisqKgqLFy9GdHQ0EhISlC+Tr127hpYtWyr7WRYy1a5dG4Cp8qtevXoATBOjmMMR8z7mLtuxsbHIzs5Gjx49lO1arRZdu3YttBKtMEWdJyYmBpmZmejbt2+Bz42OjsalS5esng8AGRkZiI2NVZZbtWqlhGqAaUg587BzAKBWq+Hr66uc157jqtVqq7b/+uuvNr/2orRr1075eweA4OBg6PV6XL9+HXq9HmlpafjXv/5l9ZysrCx06NCh0GPGxMQgODjYqtt3jx49oNfr8ffffyt/9506dbJ6XnR0NI4dO2YVXJvFxsYWGDzGxMRg2LBhVuuCg4Otgkdbr/u8mVRwcHChs1jb8hqfeeYZdOnSBf/88w8eeOABhIWFYeLEiVbPyXtd+vv7Q61W57uOLK8ZvV4PX19fq/akp6dbXTNFXe+OYHPwePnyZYed1Gzq1Kn46KOP8Pnnn8PT01OpptTpdHB1dYVOp8PkyZMxZ84c+Pj4wMvLC9OnT0dwcDC6devm8PYQEVHFVlErHrONKZVyTEciIqraKnPFIxXP1q1bYTAYUKdOHWWdEALOzs549913odPpbD6WXq9HaGgohg8fnm+buQIRANzd3Ys8TmpqKkJCQhASEoJdu3bBz88P165dQ0hISL5JQrRarfLYHLhY/v5nud28jz2/H6pUqnzFVAVNiFPUeVxdXYs8h16vR6dOnbBr16582/z8/Io8R1HnLclxy+J3aL1eDwD46quv8MADD1htc0SPmrzXmV6vx+DBg/HWW2/l29ccWheHrde9o3Xo0AHt2rXDzp078eijj+L333/HV199ZbVPca6Z2rVrIyIiIt/5LHsVl/Y1Y3PwWL9+fYed1Gzjxo0AkO+bl+3btyvjPaxduxYqlQojRoxAZmYmQkJCCixdJSKiqk+uYJ+ghBDINibDKGeUd1OIiIjyqaxjPFZE7i7O2POfOeV6/vsxGAzYuXMnVq9erXS7NRs6dCh2796N559/vsDnarXafL0XO3bsiAsXLqBx48bFbziAP/74A3fv3sWKFSuUseHOnj1bomMWpFGjRsoYgOb8Ijs7G2fOnMGsWbMAmAK6lJQUpKamKkFWYVVqhWnSpAlcXV0RHh6udLW11LFjR+zZswe1atWCl5dXiV5TaRzXycnJrp6qlqKjo5Genq6ErydPnoSHhwcCAwPh4+MDZ2dnXLt2Tekub4sWLVpg7969Si9aADh+/Dg8PT2thuLLq2PHjti7dy+CgoJsnpm9RYsWVuMfml9D3uPact2fPHkS48ePt1ourLLT1tc4ZcoUrFu3Dv/88w/69etX4okeO3bsiJs3b0Kj0VhNGmWvklwzgB2Ty5QGIUSBP5aDzLq4uOC///0v7t27h9TUVOzbt6/Y/cqJiKhyy8zOxuIPP8WKPQew6aujSMvIvP+TSlG2MYmhIxERVVzMHR1GkiR4uLqU248tsw8fPHgQCQkJmDx5Mlq3bm31M2LECGzdurXQ5wYFBSE8PBw3b95EQkICAOD111/Hzp07ERoait9//x0xMTH4+OOP8dprr9n13tWrVw9OTk7YsGED/vrrL3zxxRdYunSpXcewhbu7O1544QXMmzcPhw8fxvnz5/HMM88gLS0NkydPBgA8+OCDcHNzw3/+8x/Exsbio48+spr12xYuLi54+eWXMX/+fOzcuROxsbE4efKk8v6OGzcONWvWxJAhQ/DDDz/g8uXLiIiIwIwZM5SJYorDUccNCgrC999/j3/++ee+M0DnlZWVhcmTJ+P8+fP4+uuvsWjRIkybNg0qlQqenp6YO3cuZs+ejR07diA2NhY///wzNmzYgB07dhR6zBdffBHXr1/H9OnT8ccff+Dzzz/HokWLMGfOHKsuxHlNnToV9+7dwxNPPIEzZ84gNjYWR44cwaRJkwoNyWbMmIHDhw9j1apVuHjxIt59912rbtaA7df9p59+im3btuHPP//EokWLcPr0aUybNq1Er3Hs2LH4+++/sXnz5kInarJHv379EBwcjKFDh+Lo0aO4cuUKfvrpJ7z66qt2hf9BQUE4deoUrly5gjt37thdDVmuwSMREZE9bicl48bde/j50l84eCoKWhu/3XQ0IQSyDEkwyuUbfBIRERWFFY/Vy9atW9GvX78Cu1OPGDECZ8+exS+//FLgc1evXo1vvvkGgYGBStVWSEgIDh48iKNHj6JLly7o1q0b1q5da3dvSD8/P4SFheHTTz9Fy5YtsWLFCqxatcr+F2iDFStWYMSIEXjqqafQsWNHXLp0CUeOHEGNGjUAmCZ0+fDDD/H111+jTZs22L17NxYvXmz3eRYuXIiXXnoJr7/+Olq0aIHRo0crY+K5ubnh+++/R7169TB8+HC0aNECkydPRkZGRokqFR113CVLluDKlSto1KiRVRdtSZLuG8L27dsXTZo0wSOPPILRo0fj3//+t9X7t3TpUixcuBDLly9HixYt0L9/f3z11Vf55vOw9MADD+Drr7/G6dOn0a5dOzz//POYPHnyfQPuOnXq4Pjx4zAajXj00UfRpk0bzJo1C97e3oUGlt26dcPmzZuxfv16tGvXDkePHs13Hluv+9DQUHz88cdo27Ytdu7cid27d1uNV1qc16jT6TBixAh4eHhg6NChRb5+W0iShK+//hqPPPIIJk2ahKZNm2LMmDG4evWqMgu7LebOnQu1Wo2WLVsqQyXY1Q6Rd4CDKiY5ORk6nQ5JSUkOLXMmIqKyZZRlhP/vF6w/8DUAwE/nhbC5BX+rWJpkYUS2IQmyyD8eUFGctb5QSeUTlBYX76FERJWbPj0DSanWE5/56rQQIr2cWmQfJ40OalXpjalGRCaXL19G06ZNcf78eTRp0qS8m1PhSZKE/fv3OyQczKtv375o1aoV3nnnHYcfu7zYVPH4xRdfFDjgKhERUVmRZRm3k5KV5QAf7zJvQ7ZRj8zsu3aHjlRyQghkGyrm5EJERBUVKx6JyBZff/01nn32WYaO5SghIQH79+9HREQEpk6dWt7NcSibSi+GDRuGmzdvws/PD2q1GnFxcahVq1Zpt42IiEhhlGXcsQwec7rMlAUhZGQZkyDLWfffmUqFwShw42YKJAAarQpajRoajQpajQranGWV6v7jXxERVSvMHYnIBlUt6KqMOnTogISEBLz11lto1qxZeTfHoWwKHv38/HDy5EkMHjzYahYeIiKismKUZdxOSlGWA2p4l8l5hTAiqxhdq6l0CADZ2TKys/NXP6pUUk4QqYZWo1KCSY1Gxd9diKhaYsUjEZHjlcaIhVeuXHH4MSsKm4LH559/HkOGDIEkSZAkqchZpUsyxTYREVFhjLKMO8ll29XaKGch25gEIdjFtzKQZYHMLCMys6x/F5EAaCyDSItgUqPmPHtEVHVV7dH8iYioMrApeFy8eDHGjBmDS5cu4d///je2b98Ob2/vUm4aERFRLoPRiDtlWPFoMKYi26gv8XFkYUBiWgzupUajgd8oeDgHOqB1ZA8BINsgI9sgI+90CpIk5XTVzg0mzd242XWbiIiIiKhkbJ5es3nz5mjevDkWLVqEkSNHws3NrTTbRUREZCU5LQPpWbljLJZG8CiEgFHOgEFOgxCGEh0rM/su7uijcC/1HAxyGgDgVtIP8Kg11hFNJQcRQiAry4isrPw9NtRqCVpNnm7bOdWSRESVA0seiYiofNkcPJotWrQIAHD79m1cuHABANCsWTP4+fk5tmVEREQWbiUkKo9dnLTQuTvuCzAhZMgiG9lGfYkCR1kYkJR+AXf1UUjJ+Cvf9tsppxFUczjUKpeSNJfKiNEoYDQakJFpvd7cddsyiNRqTd221ey6TUQVCLtaExFRebM7eExLS8O0adPwwQcfKOM5qtVqjB8/Hhs2bGAlJBERFUmWBQwGGUajDIMsTH8aZBiNAk5aFWp4uxb4PMvgsZa3ziGThRjlTBjk9JzZqov/6SzTkIC7+p9xV/8zDHJqvu2SpEFNj04I0D0CleRcghZTRWDZdRsZ1kG15QQ3GrXKqhs3J7ghorLGyWWIiKi82R08zp49G5GRkfjiiy/Qo0cPAMCPP/6IGTNm4KWXXsLGjRsd3kgiIqocZHOQaDT/KedUjZnCRYNRFDkLnEqlLXRbfFLuxDK1dB7IMiRBklRWE7+oVS5QqwoP9kznlmGQM2CUM0pU3SiEEUnpF3FXfxbJGZcK3MdF6wdfj07wcW8Hd+e6UEl233apkrnfBDdarRrOTmo4OZn+ZBhJRKWJFY9ERFTe7P4EtHfvXnz22Wfo1auXsm7gwIFwdXXFqFGjGDwSEVVRRssQ0aJqUVl3n1CxJGRZ4E5SkrLs5+0Jo5yRv41yBiRJBUnSQC05QZK0kEU2ZJENQECWTX+WRJYhyVTdmPozso0p+bZLUMPbrSVqenSGu3M9BksEwLpKMi09G4ApjNQ6qeGSE0Q6adWsjCSiCk2SVABUJR4HmcqXEALPPfccPvvsMyQkJOB///sf2rdvX+btCAoKwqxZszBr1iyHHXPixIlITEzEgQMHHHZMIiqZYnW19vf3z7e+Vq1aSEtLc0ijiIiobJkqE/NXJ1quK8+iCaMs47bFjNa1vD0L3VcIGUJkQUZWofvYSwgZyRmXcEd/FsnpF1FQeOms8YGvRyf4ureHRu3usHNT1SWAfBPbSADUOV201WrTuJEajQSNJneZiMhWjvxCUKN2h0blDkAg05DA8LGCO3HiBB566CH0798fX331ldW2w4cPIywsDBEREWjYsCFq1qwJSZKwf/9+DB06tHwaTPlERESgd+/eSEhIgLe3d3k3h6jY7A4eg4ODsWjRIuzcuRMuLqbB8dPT0xEaGorg4GCHN5CIiErGssuzMraiUShho2ys+CNAGWUZdyy7Wnt7lcl5s40puKv/H+7qo5BlTMq3XYIKOrcWqOnRCR7ODVipRiUmYPoiwGCUC9wuAdBoVabZtrUqOGnV0HKmbSIqhGPu7xK0aneoVW459zkJzhpvZGTfccjRqXRs3boV06dPx9atW3Hjxg3UqVNH2RYbG4vatWuje/fuDj9vdnY2tNrCh84hourH7t9S169fj+PHj6Nu3bro27cv+vbti8DAQPz0009Yv359abSRiIiKYDTKyMwyIC09G8kpmbiXkI74O6m4cSsF1/5Jxt9xKbgZn4rbd9OQkJSBZH0W0tKzkZVlhLEShI4AkGXIxr0UvbJcmsGjEDKS02Nx+fYe/PbPWsQlfZcvdHRSe6O2ri9aPTAHDWqOhKdLQ4aOVCYEgOxsU3ftpORM3L6bhhs3U/B3XDJu30lFUnIm0jMMkOXK8C+biEqdAyoeNWo3aNTuVvc5SVJDJVWvcEkIAYMxrdx+7Kle1ev12LNnD1544QUMGjQIYWFhyraJEydi+vTpuHbtGiRJQlBQEIKCggAAw4YNU9aZff755+jYsSNcXFzQsGFDhIaGwmDIrXaVJAkbN27Ev//9b7i7u2PZsmUFtik+Ph6DBw+Gq6srGjRogF27duXbJzExEVOmTIGfnx+8vLzQp08fREdHK9sXL16M9u3bY9OmTQgMDISbmxtGjRqFpKT8Xw6bZWZmYsaMGahVqxZcXFzw0EMP4cyZMwBMf6eNGzfGqlWrrJ5z7tw5SJKES5cuKa9x06ZNeOyxx+Dm5oYWLVrgxIkTuHTpEnr16gV3d3d0794dsbGxVsex5b3bsmULhg0bBjc3NzRp0gRffPEFAODKlSvo3bs3AKBGjRqQJAkTJ04s9HUSVWR2Vzy2bt0aFy9exK5du/DHH38AAJ544gmMGzcOrq4Fz0RKRETFZ+7ubDB3gTbISkWUwVB64ypWJPGJSZAtXqefzsPh58g26nEv9Rzu6KOQZUgoYA8JOtdmqOnROSdoZIUZVRxGo0Ca0YA0i1m2Td20VVCrLbpqq3Ifq1QMy4kqEyFEgUOhmMde9vZygauL4ycxU0sFT9qmUjlDNmY7/HwVlVFOx+nLL5Xb+bs2WA2N2s2mfT/55BM0b94czZo1w5NPPolZs2bhlVdegSRJWL9+PRo1aoT/+7//w5kzZ6BWqwGYhk7bvn07+vfvr6z74YcfMH78eLzzzjt4+OGHERsbi2effRYAsGjRIuV8ixcvxooVK7Bu3TpoNAVfgxMnTsSNGzdw7NgxaLVazJgxA/Hx8Vb7jBw5Eq6urjh06BB0Oh02bdqEvn374s8//4SPjw8A4NKlS/jkk0/w5ZdfIjk5GZMnT8aLL75YYJAJAPPnz8fevXuxY8cO1K9fHytXrkRISAguXboEHx8fPP3009i+fTvmzp2rPGf79u145JFH0LhxY2Xd0qVLsWbNGqxZswYvv/wyxo4di4YNG+KVV15BvXr18PTTT2PatGk4dOiQXe9daGgoVq5cibfffhsbNmzAuHHjcPXqVQQGBmLv3r0YMWIELly4AC8vL+YtVGkV687k5uaGZ555xtFtISKqlhgs3t/NhNxvsr093OGk0QAwFv4EGwkhoM+8gjv6s0hKi4FA/u6tWrUXanp0gq97B2g1ZdPFm8gRiuqyDZgqLTQaCRp17viRViGlWmIlL1EZkS0mbTPIIs/kbbb9PlDQ9pL+BqFWuUClKriyUaNygcGY6oCzkKNt3boVTz75JACgf//+SEpKQmRkJHr16gWdTgdPT0+o1WoEBARYPc/b29tqXWhoKBYsWIAJEyYAABo2bIilS5di/vz5VuHZ2LFjMWnSpELb8+eff+LQoUM4ffo0unTporSxRYsWyj4//vgjTp8+jfj4eDg7m8LuVatW4cCBA/jss8+U0C4jIwM7d+7EAw88AADYsGEDBg0ahNWrV+d7Pampqdi4cSPCwsIwYMAAAMDmzZvxzTffYOvWrZg3bx4mTpyI119/HadPn0bXrl2RnZ2Njz76KF8V5KRJkzBq1CgAwMsvv4zg4GAsXLgQISEhAICZM2davQe2vncTJ07EE088AQB488038c477+D06dPo37+/ErbWqlWLYzxSpeb4r8SIiMhKQcGi0SgjuxoFi9kGGSn6TKSkZCFZn4lkfRZSUjKRos9ZTslCSmomUlOzoU/LwqaVA/FA7dwJZG7eS1Qe+3kVPrGMrQzGNNxLjcYd/VlkGu4WsIcEL5cmqOnZCV4uTVjdSFWSEALZ2QLZ2YWHk2q1ZDHJjQpOWhWcnDQcU5KoGMwhYna29Z8Gg1xqwyOU9HeMoirsJEkNrdoD2caUQvehsnfhwgWcPn0a+/fvBwBoNBqMHj0aW7duRa9evew6VnR0NI4fP27VfdpoNCIjIwNpaWlwczNdH507dy7yODExMdBoNOjUqZOyrnnz5lZhWnR0NPR6PXx9fa2em56ebtWFuV69ekroCJjmoJBlGRcuXMgXPMbGxiI7Oxs9evRQ1mm1WnTt2hUxMTEAgDp16mDQoEHYtm0bunbtii+//BKZmZkYOXKk1bHatm2rPDZPttumTRurdRkZGUhOToaXl5fN753lcd3d3eHl5ZWvEpSosmPwSERUDLK5GiHnT1kWMMoCsjHnT1kok7hUtWDRYJCRkpqF5JzgMMUiOExOyV1O1ucEiymmMefscS8x3Sp4jE9MVB7X1BWv6lAIgdSs67iTchaJab9DFFAxqVV7wte9A3w9OsJJ412s8xBVJaaKKyOy8vx7UakkaDUqZWIbrUYFrZOas25TtWQa+y+327Ms5y6bKxkr4+8DKpXzfcdxVKtckW3UozpUPapVrujaYHW5nt8WW7duhcFgsJpMRggBZ2dnvPvuu9DpdDafU6/XIzQ0FMOHD8+3zTzRLGAKzEpKr9ejdu3aiIiIyLettKv9pkyZgqeeegpr167F9u3bMXr0aCUYNLOcMMfcG6CgdbJs+jLP1vcu70Q8kiQpxyCqKhg8EhHlkdutybKbk7D6MFHZPjwUxmg0hYgpFsFhsmVlYk6QaFmZmJZe+uM5JSZnWC3fSsztal3TzopHg5yOhNRfcEcfhYzsgr9B9nRphJoenaFzbQpJUtvfYKJqRpYFMrOMyMzKH0g6adXQmMNIBpJUySnjKhpMXaDNvRYsfz+oyL8TlKRtGhuCLkmSoFY5wyhn3Hffyk6SJJvHWCwvBoMBO3fuxOrVq/Hoo49abRs6dCh2796N559/vsDnarVaGI3W/6d37NgRFy5csBrrsDiaN28Og8GAqKgopav1hQsXkGjxxXLHjh1x8+ZNaDQaq8lt8rp27ZrVLN0nT56ESqVCs2bN8u3bqFEjODk54fjx46hfvz4A06zbZ86cwaxZs5T9Bg4cCHd3d2zcuBGHDx/G999/X6LXa349JX3vnJycACDf3wtRZcPgkYiqHYMxz4eGnA8Ulb3rs1EW0OvNlYbmakNzkJjTvVmfW4mYos+EPrVsB4V30qrg6eEMnaczPD2d4OnhDE93J2W5po8b6j2gQ7PGPlbPu52YrDy2peJRCIG0rH9wRx+FhLRfIUT+ikuNyh2+HqbqRmeNTwFHISJ7ybJARqYByLRer1ZLcNaq4eSkgZOWYSRVHOYvG41GizEWLULGyj5DfPFbL0ElOdm0p0rlVC2Cx8rg4MGDSEhIwOTJk/NVNo4YMQJbt24tNHgMCgpCeHg4evToAWdnZ9SoUQOvv/46HnvsMdSrVw+PP/44VCoVoqOj8dtvv+GNN96wuV3NmjVD//798dxzz2Hjxo3QaDSYNWuW1WQp/fr1Q3BwMIYOHYqVK1eiadOmuHHjBr766isMGzZM6c7t4uKCCRMmYNWqVUhOTsaMGTMwatSofN2sAVMl5gsvvIB58+bBx8cH9erVw8qVK5GWlobJkycr+6nVakycOBGvvPIKmjRpguDgYJtfW2Ec8d7Vr18fkiTh4MGDGDhwIFxdXeHh4fgJFolKm93BY8OGDXHmzJl8Yy8kJiaiY8eO+OuvvxzWOCIie1iFiQUMzG7q/lw5PkDIsoA+LavIysO8y6lpWSjLzFSrUcHL0xmeHk6mP92d4OnpDC8PJ3h6mMNE87LpT2fnom87bq5a+PlaVxMIIXAnOTd49CsieDTKmUhI/RV39GeRnn2zwH08nBugpkcn6NyaQyXx+zeislDQrNvm6kgnranLtouLhmEkOUze7s+WFYrKcCgGucp3EC7ul6lqlYvNk0upJWdUn7mtK7atW7eiX79+BXanHjFiBFauXIlffvmlwOeuXr0ac+bMwebNm/HAAw/gypUrCAkJwcGDB7FkyRK89dZb0Gq1aN68OaZMmWJ327Zv344pU6agZ8+e8Pf3xxtvvIGFCxcq2yVJwtdff41XX30VkyZNwu3btxEQEIBHHnlEGVMRABo3bozhw4dj4MCBuHfvHh577DG89957hZ53xYoVkGUZTz31FFJSUtC5c2ccOXIENWrUsNpv8uTJePPNN4ucJMcejnjvHnjgAWWSmkmTJmH8+PEICwtzSPuIypIk7LwbqVQq3Lx5E7Vq1bJaf+vWLdSrVw+ZmZmFPLN8JCcnQ6fTISkpCV5enI2UqDKy/PBg2f05d4xF03JF/fAgywKpadmmsQ/1ecZAzFuJmLM+NTULZVlkodGo4JUTIHqYKxBzAkRTuJgbKHp5OsPL0xnOTmqHz3hbUPCYqE/DuLfWKcsrpzyJujXd4KTN7XaSlhWHO/qzSEj9FbLIyndctcoVvu7t4evRCS7amg5ts62ctb6VLuisSPfQbIOMGzc5gUFVp9Wo4OqigTanuzZn1yYzZSxlWYZsFJCFgCwAkbNeyKZ1lpWLFfX3gtLi5+sGN1fr8eLi7iXkGy/OV6eFEOlFHstJo4Na5VLkPpYyDYmQZcd/DrS3HVS1LV68GAcOHMC5c+ccfuwffvgBffv2xfXr162CTiIqOZs/AX3xxRfK4yNHjlh9i2I0GhEeHl7kWAxERIWxrDww5FQjKN2dcqoUKgpZFkhLz0ZySm6IaJ5ARZmp2TzxSqqpq7Nen1m2IaJagmdOBWLeikRzaOjp4aQEjZ4eznBxdnyI6Cg37t5THms1GuhyBvs2yllITPsNd/RnkZZ1o8DnujvXQ02PzvB2a1npQj+i6ijbICNbn//LA41aBa3WNGakxmJCGzUrJCsdy8nZ5DyhoZAFhIDpsUCVnqitorvfpDJ5qVXOpRI8EpW2zMxM3L59G4sXL8bIkSMZOhKVAps/hQ0dOhSAqQR6woQJVtu0Wi2CgoKwenX5zfJFRBVP3uoEq9mec8ZUNOZ0eSoPQuSEiObAUJ+FZH3RlYgp+qwyba9aLd03QDSFiLnLri6aChsiFsfNhATlcU0vT2TLtxCXdAaJ6ecgi/wfctSSC3zc28HXsxNctbXybbeHJGmgkjSQJA0kIGfiGRUkSBCQIUkqACpAyIBkuqZkkQkhZBjlTFSHWT6JyoIh54uoomq0TJNcSFCpJWhUErROajhp1abqSVZNliohhDKciVHOnYwtX9dmBohlrjjvt1rlbPdEa6bu1hJ436PKZvfu3Zg8eTLat2+PnTt3lndziKoku7taN2jQAGfOnEHNmuXTVc1eFambGFFlV1CQmLfbc+4+ZfuLpxAC6RkGi+rD/JWISjdni8rEsqymVKkkJSS07MasjIFofqxUJDrDzbVqhYj3U1BX64+++wG7jv0AABgU7Iz2TS8V/Fynuqjp0Qk13FpBpbJtQPy8VCpnaFQuOUFjyapAhZAhhDEnkDRCJTnlBJWVR0W6h7KrNTmCBACSBJUKUEkSVCpzWKlSHksqCSrJNLyQSpXzp4QiqyuFyLn35dxTLP/rEAIQEJBlQJZlJZyTZQE5595peo4ESTLPnCtBndMmICfKEQLICVctQ1bzsrkN5vEMzROnWd6fZSGgkkzHVqul3PblVBiqJOS8ftP7IEmABAmyyO2JIOdUJZraZXpdDBMrhoK6Wt+4ey/f38/9ulpr1V7QqO8/o3VeWYZkGOWiu3Dbi12tiYgqP7v7nV2+fLk02kFE5aDQikTzB5Q8E7SU1ccKIQQyMgxKl+XknADRKkhUZmbOrVA0lGWIKAEeHs7w8nSyqEh0zp1UJSdYNM/g7OXpBFcXrfIhkmx3MyFReWzIDgTwFwDTeFUqyQk+7m1R06MzXJ3yz2ZoC0lSQa1ygVrlBpWdFR73O64SNNrZZY2ISoc5wDMaAWMx7moqlZQb2MkVJ3izp87MCIFsg3z/HalKKM6VWdwv79QqZ4cHj0REVPkVa8Cr8PBwhIeHIz4+Pt9gxdu2bXNIw4jIPuZKBstB1s0VibJsMQmLLOdUWYgyCRKFEMjMMirBoeXEKtZdnK2DRUMZfiiSJJhmZPZwhmdOkGgKDJ2UsRKtlj2c4OHmVO1DRHN1jqkyxrSskiSlYkbKeQzzepX5sek55qojCbmVNaoCKgzjE5OUxzo3P7hpWwBSEnw9OqCGW2uoVc7FbL8GWrVHsZ9PRNWPXA4V/baoeC2iCsPOUFySVMX+Ek4lOcG+GJyIiKoDu4PH0NBQLFmyBJ07d0bt2rWrVRdAovJgWXFoyFOBaDCWbYgIAJlZxpxuy/mDw+QUi67MSpViJrKyyzZEdHfTKmMhKl2YLQJFZTmnO7O7uxPUVTRElACrUE/pQpfTnU+lkvJ3rQNyQ0CLLolKaKgq27HSblkEjzV1XqitGwMfT2cYjGnFOp5K0kKjdmPXLSIiojxM4WHxmH6v0EKW808QRURE1ZfdweP777+PsLAwPPXUU6XRHqIqyXLsJ1kUPIujZffmshon0RwiWnZpzleBaDGxSrI+C1lZxlJtU14e7lp4uudUIirdmJ0tJlSxHCux8oaIklXAlzv2mFVVobmSEDmVghbbLAPCvOFiZWaUZdxNzh3Xr5bOC27O7gAMdh9LklTQqj0ZOBIRUbVQnCEAShI8mp8vg8EjERHlsjt4zMrKQvfu3UujLUQVmrkrc+5YiLJVgJgbJEIJE837l0U1Yna2scDKw4K6OJurETPLOER0d9PmTq7imTvJSmHLnu5ORQ7mX56kAoI+q8rBAqoIzUGiZffi+01YUN3dTU6B0WJID1+dF9ycnSEL+4JHtcoFWrVnpZvchYiIqLjkYs1oXbLgUa1ygqFsf70kIqIKzu7gccqUKfjoo4+wcOHC0mgPUamzrD5UAkQBUzWi+bFSdVj2XZmB3BBRCRLNk6mkWASLqdaViBkZ9leAlYSbqyan27KTqSLRXHXoaTlrs7ki0dTtWaMp/9CnqMBQrZKU8QilnC7F5rDQeqbTsu1qXJ3duHtPeezl5gpPV1eoVSrINn6okSQVNCqPYs3OSUREVJ1IkgZSCSdZU0laSJIKQnACIyIiMrE7eMzIyMD//d//4dtvv0Xbtm2h1VrP1LlmzRqHNY6oIJaVh1aVhbJpZsncx0IJGcu6+tCSwSArXZnzVh2mKNWJ1pWI6WUcIrq4aODlYVFx6GlReWgRKOZ2eXaGtpxCRJU5LFRbdydWq0zr1CpJ2Uey+pOVhZXRjbsJyuOaOi84aWy/balVrtCqPVjlSERE1ZOdv/Q6aigSlaSFUWQ65FhERFT52R08/vLLL2jfvj0A4LfffrPaxgogsiQsAkBTGGhaZ/ox/S4k8nRfhjAFg0LkPD9nR8vnlyej0RQiWlUe6jOtH+dUI5qX09LLPkQ0TaJiPR5i7rL1mIieHk7Qakv27bYtzJOcmGdAthzD0FxNaFVVaFmRqJaU/al6ibuXGzz6eXnCOc+XXQWT4KTRcbZqIiKq1uz9ul0l2XKPvT9J0gJg8EhERCZ2B4/Hjh0rjXZQBZNv7MKcENEcFoo84xgqk6NYVB6Wd0h4P0ZZQK9UGuapPMyZaMU8sYp5fWpadpm20clJDU/3nMDQM28Foqn7srkrs7lK0akUQ8S84aFapVK6I6tU1gGiyuJPdk2m4rqZkKg8rqnzglZT9PVtmkBGV+IxqoiIiCo7+34VlxwWPKokuz9iEhFRFca7QhViriwUOSWDecNBWSDPJCjWFYnCoptyZWOUBVJTLbsr54yJmHeylZTc8RL1qWUbImo1KiUw9MqpOrQcA9HLwwmeyjbTn87Ojv0nag4OrSoMbaw4VDM8pHJwyyJ4DKjhDbWq8G7TKkkLJ403u1YTEREBsKevtUrSOOz3PInBIxERWbD7rtC7d+8ib0rfffddiRpU3RiNshIImkNCAdy3utA8c7K5i3JFry60hywLpKZlW1Ue5qtEVGZqNq3Xp2bZ+a1uyZhDRKXbsoczPJVxEU3LeSsRnZ3UDg/uzFWFarWq8IpDtQSVSqWsI6pM4hOTlce1fX0K3U+lcoKTWsfQkYiIqBhUKsdUOwKASlLD9HV31fl8QkRExWd38Gge39EsOzsb586dw2+//YYJEyY4ql0VWrZBzg0BRe5YhkLkTm6CnApD8/p81YeVoCuyI8iyQFp6tlWlYe64iFkWE6zkLuv1mSjLokuNWjKFhu5OFmGiM3R5gkNlfER3J7i4OO5bYUsqlQS1WoJapcr50xQaWk6aovzJiVKoikvPzEJKerqyHFjTt4C9JGg1ntCoOGt1Vbbyvydw+n83IASg0Zj+/9Pk/Kg1EjRqFbQalWm9JudHrYJGLeWuy/lTrZbyLJv2M69TWzxXY3nMIp6v5pc6RFQB2fNRw9FViipJA1mUbe8iIiKqmOy+w6xdu7bA9YsXL4Zery9xgyq6bIOMGzdTyrsZ5UIIc4hoPQOz+U9zsGg5Q3OKPqtMu25r1JIymYqXRVCojIloUaFoXnYtpRBRAnKqDaV8YyFq1ObHKuUxg0Qiazfu3VMea9Rq1PLWWW2XJA2cNF4OG5OKKq64W3r8dTWxvJtRKJUEJaBUKyGolCcEzflCSaOCVq2y2F+CVmMZgqqgyQlT7xd65u6Td3/r0FSb59hqi/ZwCA2iqsueyWUcfS9VqZwhGxk8EhGRA8d4fPLJJ9G1a1esWrXKUYekUiSEQHqGITcwtJxMxWJZqUxMyURKahaMxrILEVUqqcBxD3O7NFsv6zydSy1EtCTB9AHTXIWoNn+YVKugybNMRMV3427ujNY1vTzhpM29ZakkLTQad3atriayDXJ5N6FIsgBkg1zh21mQIis71UVXeiohZwHVo3mPV/Ax84emlqGtWp0T0poDWouKVA4dQnR/tlY8SpLK4RPC8EtBIiIyc9gd5sSJE3BxcXHU4cgOQghkZBiUsQ8tqw2TcwJDy8rElFRTkGgoyxBRAjzM4x66552V2bpC0Tz5ipurtswqMfJ2YTaPjag8Vlk/JqLSd+NubsVj3mpHtYr3m+rkhQkdMXxgM8TfSYPBKMNolGEwyDmPhfLYYDD9GI3mZWGxv0C2wQijUcBoNIWEBqMMoyHnGMa8xzCtyzaY95HLdBiQsmIwChiMRgDG8m6KXcy9B6wrRfMEpAWFnoVUf+ZWpxbSPb+AdeZK0oIqTbVWFam521ScqI3KlG3/aUmlEBJyZmsiIjKz+44wfPhwq2UhBOLi4nD27FksXLjQYQ2rroQQyMg05nZZLqDy0HJyFXPIaCjDKgtJAjzdTRWInp45E6tYBIaeBSy7u2nLPLDLO/GKMn6iRWUiZ2smqrhu3ktUHgfU8C63dlD5a9XMD00b+Zb7UCeyLJSwMttoEVAaLINQ82NhFZAajML0PKtg1CL0tApNhbJfQcfL3SZyA1SjjOzs3OcbLJ9fhl80lhVZFsiSBbKyK2GVad6Q06rrfN7K0oLGJC24S31BQaz5mJZjoOZdznfeAqpazb9LUeVi63BHpRESSpIKkqSBEAaHH5uIiCoXu+8yOp111YlKpUKzZs2wZMkSPProow5rWFUghEBmltFiBuaciVVSs6y6OOetSCzLrlqSBLi7aXNCwtyJVbwKCxQ9neDu5lSuA+nnm4BFnTtOoqmawLTMMJGocruVkKg8ru1bo/waQpRDpZLgpFIDWjUq03RGQggluFSqPQsLTXOqQ837WQaZhoJC05wQNvfYuaFngVWpOcGtwWKd0eJ4lpWoBqNs1+QYlYX5vaxsLKtM84eT9wlNC+qiX0C4qckzBmqhAet9xkC13Lc6V5naOsZjaVUnqiQNjAweiYiqPbvvMtu3by+NdlQKGZkG3LmXhr+uJuRUG5orEHNnajavNwWJmWX+TbyHu1apODTNwpw7oYrlsjlYdHcv3xDRUkEzOluOl2gOGKvrL49E1YkQArcSk5TlB3x9yrE1RJWbJEnQakxVbpWNUc4TZBYQZuatLM1XPZpt0cXeaL0t/7HzVqrKMBoK74pvMOQJU4251ahVTWWtMpUk2D5jfRHd6wsax9Q07qiUp8K06IrUQkPTAs5T0t95bQ3uS2s8RpWkqWSDOBARUWko9tdbUVFRiImJAQC0atUKHTp0cFijKqrn5x/CL+fjy+x8bq7a3MDQsgLRoouzl2du12ZPd6cKOaGJBCi/RFlWKFqFitX422giyi/LYMDd5NxutbV9WPFIVB2pVRLUTmoA6vJuil1kWSjhZlGhqcEiCM22qCLN7XJvLCRkzVtZmicwNcgovDt/ntA0T2Bb1QhhmqCqMk7+pFYXPflS3rFK3Vw18PN1x9KXewKwreLR1CW6dP59qSSnUjkuERFVLnYHj/Hx8RgzZgwiIiLg7e0NAEhMTETv3r3x8ccfw8/Pz9FtrDB0Xs7Ffq6bqyZfF+aCuzSbHnu4O0FTCSoTJEmyChGVX4Q4uzMRlUB8QiKyjbl1EhzjkYgqE9PY0mpoK9nEvkII01imRXaHN1oFnbnd981ha56Q1SjDkF1EcGrM89y8IWlB1acFBLG2jmdYmZgqde2b/CnAzz13wYa3pDRnn5Y4wQwREaEYweP06dORkpKC33//HS1atAAAnD9/HhMmTMCMGTOwe/duhzeyovD2Ms2i6uqiUWZgzu3CbDGpijJ7s6ky0dPDuVJ2bzJ3fTZ/02r1rSsHGieiUvTP3QTlsaerC9xciv/FDxER2UaScifiq2z/6ypVphYVoNkFBqd5uucbcieNUgLOwiaNylddWtDkUPlD0wKrTC2O50iWhQt5Kx7/vn0X0Zevor6/Nx6o6YZGtWuWajgoSRIkSQ0h2OGaiKg6s/tOc/jwYXz77bdK6AgALVu2xH//+98qP7nM/7d351FS1Wf+xz/fW9X7RrM1tNAsKuAKuOAPMQdGkEUGZZzRxBBBONEZAw6EyUQ5LA1xDIGMhojEmclEYpIRiIzgOTmjhOkIaARlCS4JohAzorIq3U230kvV9/dHdxdVdjf0UlW36tb7dU4f6t6qvv08QNfT9+nv8t3Z/08PzRmpk59+7nYonWKkFqc9O865Y7/fYeozANd88tm5xmMRox0BABdwbpRpck3Lbxpleq4hem6t0MgmacubPIU3QpsGR5y7duTXOvTJMb2wc7ck6aoBxSr9xqSYjniU1LizNY1HAEhl7W48BoNBpbUwbyQtLU3BYPKtndIeOdnpCb8+zJenPocaiT6Hqc8AkkIwaCN2tKbxCADwqvBRpp3Vo1u2srPC79MiO4+nzpxbO7lHQa6k2E61bri+X0HVxPRrAAASW7sbjzfffLPmzp2rdevWqbi4WJL08ccf69vf/rbGjh0b9QDRwJiGXZ4dnwlbP7HlUYsAkMzqAwGdqqgMHbO+IwAA7fflEY/hm7b1KMiVMT4ZE9sBCQ7rPAJAymt3JXjyySd12223qX///urbt68k6ciRI7ryyiv1q1/9KuoBel2LOz77G3Z59vmMHKfhMQ1FAKmipq5OJyvO3Rxd1K2ri9EAAJCcgl/qPIY3Hnt2yY35aEeJDWYAAB1oPPbt21f79u3T//7v/+rdd9+VJF122WUaN25c1INLdi1Ne25qKPr9Tmj6MwDgnC9qa3WqMmzEY9cu7gUDAIBHRIx47JIXl9GIRsm15iYAIPo6VG2MMbrlllt0yy23RDuepNHiSEXWUgSATqkPBFR99qwqqs9t4sVUawAA2s+GjXisqavTmS/Oho57FuTKxGXEo5ExjqxN7HXyAQCx0+bO2O9+9ztdfvnlqgwbhdKkoqJCV1xxhV555ZWoBpeI/D6j4l55KulToOJeeSrqkaPuXbNVWJCpvNwMZWWlKT3dR9MRADogEAzqVNg0a5/jqHt+vosRAQCQnMInWn9aWRV67HccFeblxGWqtcSoRwBIdW3ujq1atUr33Xef8lu4ASwoKNDf//3f6/HHH49qcInIGKM0P01FAIiV8I1luufn8YscAAA6ImzEY/g0624FuUrzpcuY+KwhbwyNRwBIZW2+m3vzzTc1ceLEVp8fP3689u7dG5WgAACp62TYyPoiplkDiKGG9bgdpaf7lJXpV3amX5kZfmWk+5Se7lNamqO0xnW5v/yR5j/34Q8ts9OwISBbAiIRRI54DNtYpiBfjpMetzhoPAJAamvzGo/Hjx9XWlrrw/H9fr9OnjwZlaAAAKkrfMQjG8sAqctxjHyOOfenz5HjNLb0rA0N5jKOkTGSY5oafw2b+ZnG1xoTNvDLWskYOUZxGU1trVUwaBW0kg1aBQJB1QetggHbsOOwbXyu6XVB22wnYjW8TFZWwWDkun3A+YT/Xzl1Jv4byzSh8QgAqa3NFeeiiy7SO++8o0suuaTF59966y317t07aoEBAFLTybA1HnsXFroYCYCOMKapUfilxqHjyHEanncc07jpRENj0MiEGohGCj2f7ExjM/Rc26XzDZjwZmYwGAw1I8Mbl8GAVaDxOBAMKhBoeIzUFTHisUu+TBwbj07H9jMFAHhEm6vArbfeqsWLF2vixInKzMyMeO6LL75QaWmp/vqv/zrqAQIAUsupsKnWvRnxCLjKqGFEoWMaGon+xpGHvsamYlMT0XGMfD5Hfp83GoaJLLKZ2b5Rm4FAQxOyaeRlIBAMNSkDgWBjo5ImpVfYVtZ4ZMQjACCe2lxxFi1apOeff16DBg3SnDlzNHjwYEnSu+++qzVr1igQCGjhwoUxCxQA4H3W2ohdrXt1ZcQjEG0NaxE6zUcjNjYTw6crh6Y2wxN8Pkc+n3ShkZfWhjUjA1b1gaDq64Oqq2/4s74+KFqTia+1NR57dYlvbTXGkTGOrA3G9esCABJDmxuPRUVFeu211/TAAw9owYIFod+gGWM0YcIErVmzRkVFRTELFADgfRXVn6u2vj50zBqPQPsZY5SW1rgJir/xo3E0ot/vMCIRF9Sw6U7DxjutCQSCqm8cQVlfH1Qg0NCYrKtrOA/3Nd2v1dTV6cwXZ0PnexZ2jXssRj5Z8f8CAFJRu8bY9+vXT//zP/+j06dP69ChQ7LW6tJLL1Uha3ABAKLg+Ony0OPsjAzlZWW5FwyQoIyaRq41Tm9u2lk5rMkIxFrD/8GW/68Fg1a1dQHV1gZCfzJK0j2fVlaFHjuOo+75BXGPwRi/ZOvi/nUBAO7r0OIehYWFuv7666MdCwAgxR0rrwg97tkl/jdGQCIJbzCmpfmUnu5TZrpPaWmsl4bE5jhGmRl+ZWZE3mrU1QdVXxcITd2ub5zG3TSlm8ZkdDWNeAyfZt01L1c+J/6/nHCMX4G4f1UAQCJgizEAQMIIH/FYVEjjEd4UGqnYtBmLc26jlqYNWpo2awG8JK1xdG5rIja/CVtXkunbHdPUyA1vPHbPy3Ullnjuog0ASCyu/kS7Y8cOTZkyRcXFxTLGaPPmzRHPW2u1ZMkS9e7dW1lZWRo3bpzef/99d4IFAMTc8dPnRjz2KuziXiBAJxhjlJ7uU052mrrkZ6p71yz16pmji3rnqeSifPXpna/ePXPVo1u2CrtkqUt+pvJyM5Sbk66sTL/S0nw0HZGSfD5H6ek+ZWWlKS83Q4VdstSz+7nvneKihu+bLvmZys5KU5rfESuWXtipM+caj93y81yJwWFnawBIWa7+6qm6ulpDhw7VrFmzdMcddzR7fuXKlXriiSf0zDPPaMCAAVq8eLEmTJigP/3pT8rMzHQhYgBALIWPeGRjGbjJSJIxchw17vzsyDGS42v40zhGjjGNf0qOObfeIjtBA9HXsGlS41IDYcv/WtuwnmRNTUA1tY3rSTI6skELU63dajwa41PDOysT6gEg1bjaeJw0aZImTZrU4nPWWq1atUqLFi3S7bffLkn6xS9+oaKiIm3evFlf+9rX4hkqACAOjoet8dibjcsQBaaxeWhkZJzGY2NkTENDsal52LSDb9MGLez8DCQHY4wy0v3KSD93W9O0uU1dXUB1dY3TtesDCgRSp+nVtL6jlBiNR6mh+WhtvWtfHwDgjoRdbOODDz7QsWPHNG7cuNC5goIC3XDDDdq5cyeNRwDwmLr6en0WdnNU3I3GI84vYndnxzSMRnRMaJfnNH/ru+4C8K7WNrex1jY2IgOqqw+Gdt32YkMyrO8Yucaji41Hx/gUoPEIACknYRuPx44dkyQVFRVFnC8qKgo915KamhrV1NSEjisrK2MTIAAgqo6frghNwHKMURFrPMZdItdQn2NUWJApv7+h0ej30VQE0D5N66+mp0euNxi+kU3DrtvndttO1qZk0x7hNXV1OvPF2dB5d0c8+iXVXPB1AABvSdjGY0ctX75cy5YtczsMAEA7HSsvDz3umpcrv4+F6OMtkWuo4xjl52W4HQYAD/I37jKf2cJbTNMoychdthtGTAaDCdyUbAzt08qq0CnHcdQlJ9ulgCSHna0BICUl7FCBXr16SZKOHz8ecf748eOh51qyYMECVVRUhD6OHDkS0zgBANFx7LPy0OMeBfnuBZLCqKEAEKlplGR2Vpry8zLUrTBLvXrmqm9xvvoW56tXzxx1K8xSfl6GsjP9CbPTdtOIx/Bp1l3zcuU47t3+GXa2BoCUlLC/dhowYIB69eqlsrIyDRs2TFLDlK/XX39dDzzwQKufl5GRoYwMRkQAQLI5Frajdc8uBe4FksKooQDQdo7TtLFN5Hlrrc7WBHS2pl5na+pV78LoSNvCjtbd83LjGsOXmcS99QQAxJCr7/5VVVU6dOhQ6PiDDz7Q/v371bVrV5WUlGjevHn6l3/5F1166aUaMGCAFi9erOLiYk2dOtW9oAEAMXHss9Ohx0WFNB4BAMnJGKOsTL+yMs/dallrVR+wjetGNqwdGWiavh0Iqr4uqGi2JoONjcdTZxJjR2up4e+lYWfrgKtxAADiy9XG4549e/RXf/VXoeP58+dLkmbMmKGf//zn+u53v6vq6mrdf//9Ki8v10033aSXXnpJmZmZboUMAIiR8BGPvQrZ0RoA4B3GGKX5jdL8rU91Dq0fWRdUbW29ajqx43ZLIx7dbjxKovEIACnI1cbjmDFjQkWxJcYYfe9739P3vve9OEYFAHDDyYpzOyj37kbjEQCQWtL8TkNjMkuSGpa9CASCqq0Lqr4+oPr6sN23688/QjKYqI1Hsc4jAKQaFtoAACSEZx+ap48//VTvffSJ+vXs7nY4AAC4zudzlOVz9OXbNmut6uuDqq0LqLY2oJraQOSmNqFdrcPWeEyExiMbzABAyqHxCABICD6fo6LCLvI5jrIzWFIDAIDWGGOUluZTWppPOdnNnw9aq5q6Op354mzoXCKMeHRoPAJAyml9kREAAFzicyhPAAB0lLVWn1ZWhY59jqMuLXUo44yp1gCQerizAwAkFmPkOObCrwMAAC0KWhsxzbowL1dOAvxSj6nWAJB63K8+AACEYbQjAACdE7TByPUd83JdjOYcYxxJ/HIRAFIJd3cAgIRC4xEAgM4JBK1OnUmsHa2bMOoRAFILd3cAgIRC4xEAgM4JBiNHPCZS49Ex7G8KAKmEuzsAQEJxDFOwAADojEACNx4NjUcASCk0HgEACYURjwAAdJy1ttnmMt0TqPHoMNUaAFIKd3cAgIRC4xEAgI6rqw+oprZWZ744GzqXSCMeHZPmdggAgDji7g4AkFAch6nWAAB0VH0goE8rq0LHjuOoS062ixFFathchloPAKmCxiMAIKE4htIEAEBHfXmadde8XDkJNpuAna0BIHUkVgUCAKQ8ploDANA5Ees75uW6GEnLWOcRAFIHd3cAgITCVGsAADrn1JnE3NG6CTtbA0DqoPEIAEgYjjEyhsYjAACdET7iMSEbj2LEIwCkChqPAICEwfqOAAB0XsI3HplqDQApgzs8AEDCYJo1AACdF7HGYwI2Hh2mWgNAyqDxCABIGEyzBgCgc87W1unMF2dDx4k54tGRRM0HgFRA4xEAAAAAPOJURWXosc9x1CUn28VoWseoRwBIDTQeAQAAAMAjTlZUhB4X5uXKcRLzlo91HgEgNSRmFQIAAAAAtNuJsBGP3fNyXYzk/Gg8AkBqoPEIAAAAAB5xMqzxmIjrOzZhqjUApAYajwAAAADgESfLk6PxaMSIRwBIBTQeAQAAAMAjwtd4TOjGI1OtASAl0HgEAAAAAI8In2rdPaEbj46M4XYUALyOd3oAAAAA8ICztbWq/PyL0HEij3iUJGPS3A4BABBjNB4BAAAAwANOlJ+bZu04jrrkZLsYzYWxwQwAeB+NRwAAAADwgONhjceueblynMS+3aPxCADel9iVCAAAAADQJsdPn2s8ds/LdTGStjE0HgHA82g8AgAAAIAHhE+1TvT1HaWmEY/G7TAAADFE4xEAAAAAPOD46fLQ42RoPEpMtwYAr6PxCAAAAAAekGwjHiWmWwOA1/EuDwAAAAAeEL65TPcvNR7T09KUmZ4mxyTW1GbHpCmgL9wOAwAQIzQeAQAAACDJna2tVUX156HjpsZjRnq6CnNy5PMl5mQ3ploDgLfxLg8AAAAASa4uENDtI6/Xx59+ppPlFSrIyZbjOCrIzk7YpqPEVGsA8Dre5QEAAAAgyeVlZen+W29R1RdnVVFdLUlK8/uV5ve5HNn5GWNkjF/W1rsdCgAgBhL3V18AAAAAgA7LSEuOcSZMtwYA76LxCAAAAAAelJ2e4XYIbcJ0awDwLhqPAAAAAOAxfp8vodd2DMeIRwDwruSoRAAAAACANstMT3M7hDZzTPLECgBoHxqPAAAAAOAxGWnJ08wzxpEx3JoCgBfx7g4AAAAAHpPmS67py6zzCADeROMRAAAAADwkPS0tadZ3bMI6jwDgTclVjQAAAAAA55WZRNOsmxjReAQAL6LxCAAAAAAe4nOS7zbPGJ/bIQAAYiD5KhIAAAAAoFWOY9wOod0cGo8A4Ek0HgEAAADAQ5wk3CG6YcRj8jVMAQDnl3wVCQAAAADQqmScai0x3RoAvCg5KxIAAAAAoEXGJOfIQRqPAOA9NB4BAAAAwEOStO/IOo8A4EE0HgEAAADAI4xJ4hGPovEIAF5D4xEAAAAAPCJZm44SU60BwItoPAIAAACAR5gk3hnaGL/bIQAAoozGIwAAAAB4RBIPeGxc4zGJEwAANEPjEQAAAAA8I7kbdw6jHgHAU2g8AgAAAIBHJPOIR4np1gDgNTQeAQAAAMAjknmNR4kRjwDgNTQeAQAAAMAjkn3Eo2PS3A4BABBFNB4BAAAAwDOSu/NojM/tEAAAUUTjEQAAAAA8ItlHPBrjsM4jAHgIjUcAAAAA8IhkX+NRYtQjAHgJjUcAAAAA8Irk7zvKcJsKAJ7BOzoAAAAAeAQjHgEAiYTGIwAAAAB4RLKv8ShJDo1HAPAMGo8AAAAA4BHGA51HIxqPAOAVSdF4XLNmjfr376/MzEzdcMMNeuONN9wOCQAAAAAQA8YkxW0qAKANEv4dfcOGDZo/f75KS0u1b98+DR06VBMmTNCJEyfcDg0AAAAAEGUNazwm/8hNAEASNB4ff/xx3XfffZo5c6Yuv/xy/du//Zuys7P19NNPux0aAAAAACAG2GAGALzB73YA51NbW6u9e/dqwYIFoXOO42jcuHHauXNni59TU1Ojmpqa0HFlZWXM4wQAwAuooQCARMF0awDwhoR+Nz916pQCgYCKiooizhcVFenYsWMtfs7y5ctVUFAQ+ujbt288QgUAIOlRQwEAiYINZgDAGxK68dgRCxYsUEVFRejjyJEjbocEAEBSoIYCABIFU60BwBsSeqp19+7d5fP5dPz48Yjzx48fV69evVr8nIyMDGVkZMQjPAAAPIUaCgBIFEy1BgBvSOh38/T0dF177bUqKysLnQsGgyorK9PIkSNdjAwAAAAAECtMtQYAb0joEY+SNH/+fM2YMUPXXXedRowYoVWrVqm6ulozZ850OzQAAAAAQAw4xqegDbodBgCgkxK+8fjVr35VJ0+e1JIlS3Ts2DENGzZML730UrMNZwAAAAAA3mCMT7L1bocBAOgkY621bgcRS5WVlSooKFBFRYXy8/PdDgcAgKRBDQUAuClo6+SYNLfDAAB0QkKv8QgAAAAASE2s8wgAyY/GIwAAAAAg4bCzNQAkP97JAQAAAAAAAEQdjUcAAAAAAAAAUUfjEQAAAAAAAEDU0XgEAAAAAAAAEHU0HgEAAAAAAABEHY1HAAAAAAAAAFFH4xEAAAAAAABA1NF4BAAAAAAAABB1NB4BAAAAAAAARB2NRwAAAAAAAABRR+MRAAAAAAAAQNTReAQAAAAAAAAQdTQeAQAAAAAAAEQdjUcAAAAAAAAAUUfjEQAAAAAAAEDU0XgEAAAAAAAAEHV+twOINWutJKmystLlSAAAiK68vDwZY2J2fWooAMCrYl1DAQANPN94PHPmjCSpb9++LkcCAEB0VVRUKD8/P2bXp4YCALwq1jUUANDA2KbhDB4VDAb1ySefhH6jVVlZqb59++rIkSOeLDRez0/yfo7kl/y8niP5JY5Yj9aghnqL1/OTvJ8j+SU/r+eYTPkx4hEA4sPzIx4dx1GfPn2anc/Pz0/4YtgZXs9P8n6O5Jf8vJ4j+XkfNdSbvJ6f5P0cyS/5eT1Hr+cHAGg7NpcBAAAAAAAAEHU0HgEAAAAAAABEXco1HjMyMlRaWqqMjAy3Q4kJr+cneT9H8kt+Xs+R/FKX1/9uyC/5eT1H8kt+Xs/R6/kBANrP85vLAAAAAAAAAIi/lBvxCAAAAAAAACD2aDwCAAAAAAAAiDoajwAAAAAAAACijsYjAAAAAAAAgKhL6sbjjh07NGXKFBUXF8sYo82bN5/39a+++qpGjRqlbt26KSsrS0OGDNGPfvSjiNf0799fxphmH7Nnz45hJq2LRY6BQECLFy/WgAEDlJWVpYsvvliPPPKI3NhnKBb5nTlzRvPmzVO/fv2UlZWlG2+8Ubt3745hFq1rb37hfv/738vv92vYsGHNnluzZo369++vzMxM3XDDDXrjjTeiF3Q7xCK/zlwzFmKR4/Lly3X99dcrLy9PPXv21NSpU3Xw4MHoBt5Gscjvqaee0tVXX638/Hzl5+dr5MiRevHFF6MbeBvF6nuwyQ9+8AMZYzRv3rxOxxpvXq+hXq+fEjX0fKih7tdQr9dPiRp6Pl6voQCAtkvqxmN1dbWGDh2qNWvWtOn1OTk5mjNnjnbs2KEDBw5o0aJFWrRokf7jP/4j9Jrdu3fr6NGjoY+tW7dKku68886Y5HAhschxxYoVeuqpp/Tkk0/qwIEDWrFihVauXKnVq1fHKo1WxSK/b37zm9q6dat++ctf6u2339b48eM1btw4ffzxx7FKo1Xtza9JeXm5pk+frrFjxzZ7bsOGDZo/f75KS0u1b98+DR06VBMmTNCJEyeiFXabxSK/jl4zVmKR4/bt2zV79mzt2rVLW7duVV1dncaPH6/q6upohd1mscivT58++sEPfqC9e/dqz549uvnmm3X77bfrj3/8Y7TCbrNY5Ndk9+7d+vd//3ddffXVnQ3TFV6voV6vnxI1tDXU0MSooV6vnxI1tDWpUEMBAO1gPUKS3bRpU7s/72/+5m/sN77xjVafnzt3rr344ottMBjsRHTREa0cJ0+ebGfNmhXxmjvuuMNOmzatsyF2SjTy+/zzz63P57O/+c1vIl5zzTXX2IULF0YjzA5rT35f/epX7aJFi2xpaakdOnRoxHMjRoyws2fPDh0HAgFbXFxsly9fHsVo2y9a+XX0mvEQixyttfbEiRNWkt2+fXvng+yEWOVnrbWFhYX2P//zPzsXYCdFM78zZ87YSy+91G7dutWOHj3azp07N6qxxpvXa6jX66e11NBw1ND2XzPWvF4/raWGhku1GgoAOL+kHvHYWX/4wx/02muvafTo0S0+X1tbq1/96leaNWuWjDFxji46WsrxxhtvVFlZmd577z1J0ptvvqlXX31VkyZNcivMDvtyfvX19QoEAsrMzIx4XVZWll599VU3Qmy3tWvX6s9//rNKS0ubPVdbW6u9e/dq3LhxoXOO42jcuHHauXNnPMPssPPl5xXtzbGiokKS1LVr11iGFTXtyS8QCGj9+vWqrq7WyJEj4xBd57Ulv9mzZ2vy5MkR34upxus11Ov1U6KGStTQROP1+ilRQyVqKACkGr/bAbihT58+OnnypOrr67V06VJ985vfbPF1mzdvVnl5ue699974BhgF58vx4YcfVmVlpYYMGSKfz6dAIKBHH31U06ZNczHi9mktv7y8PI0cOVKPPPKILrvsMhUVFWndunXauXOnLrnkEpejvrD3339fDz/8sF555RX5/c2/PU+dOqVAIKCioqKI80VFRXr33XfjFWaHXSg/L2hvjsFgUPPmzdOoUaN05ZVXxiHCzmlrfm+//bZGjhyps2fPKjc3V5s2bdLll18ex0g7pi35rV+/Xvv27XNt3Tu3eb2Ger1+StRQamhi8nr9lKihEjUUAFKR935qaYNXXnlFVVVV2rVrlx5++GFdcskluvvuu5u97mc/+5kmTZqk4uJiF6LsnPPl+Otf/1r/9V//pWeffVZXXHGF9u/fr3nz5qm4uFgzZsxwOfK2OV9+v/zlLzVr1ixddNFF8vl8uuaaa3T33Xdr7969Lkd9foFAQF//+te1bNkyDRo0yO1wos7r+Ukdy3H27Nl65513kmI0UXvyGzx4sPbv36+Kigpt3LhRM2bM0Pbt2xP6xqkt+R05ckRz587V1q1bm40KSxVer6Fer58SNTQZkV9zyVQ/JWqoRA0FgJTl9lzvaFEH17F55JFH7KBBg5qd/8tf/mIdx7GbN2+OQnTREa0c+/TpY5988slmrxk8eHBnQ+yUaP8bVlVV2U8++cRaa+1dd91lb7311s6G2CkXyu/06dNWkvX5fKEPY0zoXFlZma2pqbE+n6/ZdaZPn25vu+222CZwAdHIr73XjLdo5zh79mzbp08f++c//znGkbdNLP4Nm4wdO9bef//9MYi67aKR36ZNm5q9RpI1xlifz2fr6+vjl1AUeb2Ger1+WksNpYYmdg31ev20lhqayjUUAHB+KTniMVwwGFRNTU2z82vXrlXPnj01efJkF6KKri/n+Pnnn8txIpf39Pl8CgaD8Q4tKlr7N8zJyVFOTo5Onz6tLVu2aOXKlS5E13b5+fl6++23I8795Cc/0e9+9ztt3LhRAwYMUHp6uq699lqVlZVp6tSpkhryLysr05w5c1yIuu3akl+ya2uO1lo9+OCD2rRpk7Zt25Y0uXfm37C179NE0pb8gsFgs9fMnDlTQ4YM0UMPPSSfzxfPkF3n9Rrq9fopUUOpoYnB6/VTooZSQwEgdSV147GqqkqHDh0KHX/wwQfav3+/unbtqpKSEi1YsEAff/yxfvGLX0iS1qxZo5KSEg0ZMkSStGPHDv3rv/6r/vEf/zHiusFgUGvXrtWMGTNcX0MnFjlOmTJFjz76qEpKSnTFFVfoD3/4gx5//HHNmjUrvskpNvlt2bJF1loNHjxYhw4d0j//8z9ryJAhmjlzZnyTU/vycxyn2RpFPXv2VGZmZsT5+fPna8aMGbruuus0YsQIrVq1StXV1Z7J70LXjLdY5Dh79mw9++yzeuGFF5SXl6djx45JkgoKCpSVlRWfxBrFIr8FCxZo0qRJKikp0ZkzZ/Tss89q27Zt2rJlS9zyahKL/L78mpycHHXr1i1p1hhr4vUa6vX6KVFDqaGJXUO9Xj8lamgq11AAQDu4O+Cyc15++WUrqdnHjBkzrLXWzpgxw44ePTr0+ieeeMJeccUVNjs72+bn59vhw4fbn/zkJzYQCERcd8uWLVaSPXjwYByzaVkscqysrLRz5861JSUlNjMz0w4cONAuXLjQ1tTUxDm72OS3YcMGO3DgQJuenm579eplZ8+ebcvLy+OcWYP25vdlpaWldujQoc3Or1692paUlNj09HQ7YsQIu2vXrtgkcAGxyO9C14y3WOTY0vUk2bVr18Ysj9bEIr9Zs2bZfv362fT0dNujRw87duxY+9vf/jZ2SZxHrL4Hw40ePdrOnTs3ajHHi9drqNfrp7XUUGpoYtdQr9dPa6mhqVxDAQBtZ6y1tvW2JAAAAAAAAAC0n3PhlwAAAAAAAABA+9B4BAAAAAAAABB1NB4BAAAAAAAARB2NRwAAAAAAAABRR+MRAAAAAAAAQNTReAQAAAAAAAAQdTQeAQAAAAAAAEQdjUfAo+69915NnTrV7TCAlLRjxw5NmTJFxcXFMsZo8+bN7b7Gr3/9aw0bNkzZ2dnq16+ffvjDH0Y/UADNUD8Bd1FDAcBb/G4HAKD9jDHnfb60tFQ//vGPZa2NU0Qtu/fee1VeXt6hHxiBZFZdXa2hQ4dq1qxZuuOOO9r9+S+++KKmTZum1atXa/z48Tpw4IDuu+8+ZWVlac6cOTGIGEgN1E8g8VFDAcBbjHX7JysA7Xbs2LHQ4w0bNmjJkiU6ePBg6Fxubq5yc3PdCC0CN05AQ6Nj06ZNESOoampqtHDhQq1bt07l5eW68sortWLFCo0ZM0aS9PWvf111dXV67rnnQp+zevVqrVy5Uh9++OEFmycAWkb9BJILNRQAkh9TrYEk1KtXr9BHQUGBjDER53Jzc5tNFRszZowefPBBzZs3T4WFhSoqKtJPf/pTVVdXa+bMmcrLy9Mll1yiF198MeJrvfPOO5o0aZJyc3NVVFSke+65R6dOnQo9v3HjRl111VXKyspSt27dNG7cOFVXV2vp0qV65pln9MILL8gYI2OMtm3bJkl66KGHNGjQIGVnZ2vgwIFavHix6urqQtdcunSphg0bpqefflolJSXKzc3Vt771LQUCAa1cuVK9evVSz5499eijj0bEaozRU089pUmTJikrK0sDBw7Uxo0bo/8PAHTSnDlztHPnTq1fv15vvfWW7rzzTk2cOFHvv/++pIabqszMzIjPycrK0kcffaT/+7//cyNkwBOon9RPJD9qKAAkFxqPQAp55pln1L17d73xxht68MEH9cADD+jOO+/UjTfeqH379mn8+PG655579Pnnn0uSysvLdfPNN2v48OHas2ePXnrpJR0/flx33XWXJOno0aO6++67NWvWLB04cEDbtm3THXfcIWutvvOd7+iuu+7SxIkTdfToUR09elQ33nijJCkvL08///nP9ac//Uk//vGP9dOf/lQ/+tGPImI9fPiwXnzxRb300ktat26dfvazn2ny5Mn66KOPtH37dq1YsUKLFi3S66+/HvF5ixcv1t/+7d/qzTff1LRp0/S1r31NBw4ciMPfLtA2H374odauXavnnntOX/nKV3TxxRfrO9/5jm666SatXbtWkjRhwgQ9//zzKisrUzAY1HvvvafHHntMUsP3HYD4on4CiYEaCgBJyAJIamvXrrUFBQXNzs+YMcPefvvtoePRo0fbm266KXRcX19vc3Jy7D333BM6d/ToUSvJ7ty501pr7SOPPGLHjx8fcd0jR45YSfbgwYN27969VpL9y1/+0mJsX46hNT/84Q/ttddeGzouLS212dnZtrKyMnRuwoQJtn///jYQCITODR482C5fvjx0LMn+wz/8Q8S1b7jhBvvAAw9cMAYgViTZTZs2hY5/85vfWEk2Jycn4sPv99u77rrLWmttMBi03/3ud21mZqb1+Xy2sLDQLl261Eqyu3btcikTwFuon9RPJD5qKAAkPzaXAVLI1VdfHXrs8/nUrVs3XXXVVaFzRUVFkqQTJ05Ikt588029/PLLLa53dfjwYY0fP15jx47VVVddpQkTJmj8+PH6u7/7OxUWFp43jg0bNuiJJ57Q4cOHVVVVpfr6euXn50e8pn///srLy4uIzefzyXGciHNNsTYZOXJks+P9+/efNx4gnqqqquTz+bR37175fL6I55q+14wxWrFihb7//e/r2LFj6tGjh8rKyiRJAwcOjHvMQKqjfgKJgRoKAMmHxiOQQtLS0iKOjTER55oW2w4Gg5IafribMmWKVqxY0exavXv3ls/n09atW/Xaa6/pt7/9rVavXq2FCxfq9ddf14ABA1qMYefOnZo2bZqWLVumCRMmqKCgQOvXrw9NgWlrrE3nmmIFksXw4cMVCAR04sQJfeUrXznva30+ny666CJJ0rp16zRy5Ej16NEjHmECCEP9BBIDNRQAkg+NRwCtuuaaa/Tf//3f6t+/v/z+lt8ujDEaNWqURo0apSVLlqhfv37atGmT5s+fr/T0dAUCgYjXv/baa+rXr58WLlwYOhfNhb537dql6dOnRxwPHz48atcH2qKqqkqHDh0KHX/wwQfav3+/unbtqkGDBmnatGmaPn26HnvsMQ0fPlwnT55UWVmZrr76ak2ePFmnTp3Sxo0bNWbMGJ09eza0ntX27dtdzApAW1E/gY6jhgKAt7C5DIBWzZ49W5999pnuvvtu7d69W4cPH9aWLVs0c+ZMBQIBvf766/r+97+vPXv26MMPP9Tzzz+vkydP6rLLLpPUMN3rrbfe0sGDB3Xq1CnV1dXp0ksv1Ycffqj169fr8OHDeuKJJ7Rp06aoxfzcc8/p6aef1nvvvafS0lK98cYbmjNnTtSuD7TFnj17NHz48NBN+/z58zV8+HAtWbJEkrR27VpNnz5d//RP/6TBgwdr6tSp2r17t0pKSkLXeOaZZ3Tddddp1KhR+uMf/6ht27ZpxIgRruQDoH2on0DHUUMBwFsY8QigVcXFxfr973+vhx56SOPHj1dNTY369euniRMnynEc5efna8eOHVq1apUqKyvVr18/PfbYY5o0aZIk6b777tO2bdt03XXXqaqqSi+//LJuu+02ffvb39acOXNUU1OjyZMna/HixVq6dGlUYl62bJnWr1+vb33rW+rdu7fWrVunyy+/PCrXBtpqzJgxsta2+nxaWpqWLVumZcuWtfh89+7dtXPnzliFByDGqJ9Ax1FDAcBbjD3fuzoAJBFjjDZt2qSpU6e6HQoAAEmD+gkAAGKFqdYAAAAAAAAAoo7GIwAAAAAAAICoY6o1AAAAAAAAgKhjxCMAAAAAAACAqKPxCAAAAAAAACDqaDwCAAAAAAAAiDoajwAAAAAAAACijsYjAAAAAAAAgKij8QgAAAAAAAAg6mg8AgAAAAAAAIg6Go8AAAAAAAAAoo7GIwAAAAAAAICo+/9sAjUM1ysxDQAAAABJRU5ErkJggg==",
      "text/plain": [
       "<Figure size 1333.5x500 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "bins = [\n",
    "    pd.Timestamp('1900-01-01 00:00:01+00:00'),\n",
    "    pd.Timestamp('2015-06-12 00:00:01+00:00'),\n",
    "    pd.Timestamp('2015-07-02 00:00:01+00:00'),\n",
    "    pd.Timestamp('2100-08-28 00:00:01+00:00')\n",
    "]\n",
    "labels = ['Before announcement', 'After announcement, before deployment', 'After deployment']\n",
    "\n",
    "#creating variables of interest\n",
    "affective_comment_phab_df = comment_phab_df\n",
    "affective_comment_phab_df['date_group'] = pd.cut(affective_comment_phab_df['timestamp'], bins=bins, labels=labels, right=False)\n",
    "affective_comment_phab_df['speakers_comment'] = affective_comment_phab_df.groupby('speaker')['timestamp'].rank(method='first').astype(int)\n",
    "#all comments prior to june 1 2013\n",
    "subset_comment_phab_df = affective_comment_phab_df[affective_comment_phab_df['date_created'] <= 1370044800]\n",
    "#getting counts \n",
    "comment_counts = subset_comment_phab_df.groupby('speaker')['speakers_comment'].max().reset_index()\n",
    "comment_counts = comment_counts.rename(columns={'speakers_comment': 'pre_june_2013_comments'})\n",
    "#merge back \n",
    "affective_comment_phab_df = affective_comment_phab_df.merge(comment_counts, on='speaker', how='left')\n",
    "affective_comment_phab_df['pre_june_2013_comments'] = affective_comment_phab_df['pre_june_2013_comments'].fillna(0)\n",
    "\n",
    "affective_comment_phab_df['new_commenter'] = affective_comment_phab_df['pre_june_2013_comments'] <= 10\n",
    "affective_comment_phab_df['est_commenter'] = affective_comment_phab_df['pre_june_2013_comments'] > 50\n",
    "\n",
    "palette = ['#31449c', '#4a7c85', '#c5db68']\n",
    "\n",
    "comment_counts = affective_comment_phab_df.groupby('date_group').size()\n",
    "speaker_counts = affective_comment_phab_df.groupby('date_group')['speaker'].nunique()\n",
    "\n",
    "print(\"Number of comments for each date group:\")\n",
    "print(comment_counts)\n",
    "print(\"\\nNumber of speakers for each date group:\")\n",
    "print(speaker_counts)\n",
    "\n",
    "comment_counts_engaged = affective_comment_phab_df.groupby(['date_group', 'est_commenter', 'meta.affil']).size()\n",
    "speaker_counts_engaged = affective_comment_phab_df.groupby(['date_group', 'est_commenter', 'meta.affil'])['speaker'].nunique()\n",
    "\n",
    "print(\"\\nNumber of comments for each date group and engaged commenter subgroup:\")\n",
    "print(comment_counts_engaged)\n",
    "print(\"\\nNumber of speakers for each date group and engaged commenter subgroup:\")\n",
    "print(speaker_counts_engaged)\n",
    "\n",
    "comment_counts_wmf = affective_comment_phab_df.groupby(['est_commenter', 'meta.affil']).size()\n",
    "speaker_counts_wmf = affective_comment_phab_df.groupby(['est_commenter', 'meta.affil'])['speaker'].nunique()\n",
    "\n",
    "print(\"\\nNumber of comments for each engaged commenter subgroup, and WMF affiliation:\")\n",
    "print(comment_counts_wmf)\n",
    "print(\"\\nNumber of speakers for each engaged commenter subgroup, and WMF affiliation:\")\n",
    "print(speaker_counts_wmf)\n",
    "\n",
    "#comment_phab_df['before_after'] = comment_phab_df['timestamp'] > pd.Timestamp('2013-07-01 00:00:01+00:00')\n",
    "#fig, axes = plt.subplots(2, 1, figsize=(10, 12), sharex=True)\n",
    "affective_comment_phab_df['polarized_wc'] = affective_comment_phab_df['dominant_wc'] + affective_comment_phab_df['valence_wc'] + affective_comment_phab_df['arousal_wc'] \n",
    "plot1 = sns.lmplot(data=affective_comment_phab_df, x=\"date_created\", y=\"polarized_wc\", hue=\"date_group\", col=\"meta.affil\", row='est_commenter', scatter=False, legend=False, palette=palette)\n",
    "plot1.set_axis_labels(\"Timestamp\", \"Count of Polarized Words\")\n",
    "plot1.set_titles(row_template=\"Established Author: {row_name}\", col_template=\"WMF Affiliation: {col_name}\")\n",
    "plot1.fig.subplots_adjust(top=0.9)  # Adjust subplots to make room for the title\n",
    "plot1.add_legend(title=\"Comment publication timestamp:\")\n",
    "fig1 = plot1.fig\n",
    "'''\n",
    "plot1 = sns.lmplot(data=comment_phab_df, x=\"date_created\", y=\"dominant_wc\", hue=\"date_group\", col=\"meta.affil\", row='new_commenter', scatter=False, legend=False, palette=palette)\n",
    "plot1.set_axis_labels(\"Timestamp\", \"Count of Dominance Polarized Words\")\n",
    "plot1.set_titles(row_template=\"Author's 100+ Comment: {row_name}\",col_template=\"WMF Affiliation: {col_name}\")\n",
    "plot1.fig.subplots_adjust(top=0.9)  # Adjust subplots to make room for the title\n",
    "plot1.add_legend(title=\"Comment publication timestamp:\")\n",
    "fig1 = plot1.fig\n",
    "# Plot for arousal_wc\n",
    "plot2 = sns.lmplot(data=comment_phab_df, x=\"date_created\", y=\"arousal_wc\", hue=\"date_group\", col=\"meta.affil\", row='engaged_commenter', scatter=False, legend=False, palette=palette)\n",
    "plot2.set_axis_labels(\"Timestamp\", \"Count of Arousal Polarized Words\")\n",
    "plot2.set_titles(row_template=\"Author's 100+ Comment: {row_name}\",col_template=\"WMF Affiliation: {col_name}\")\n",
    "plot2.add_legend(title=\"Comment publication timestamp:\")\n",
    "#plot2.add_legend(title=\"Before/After 07/01/2013 Wide Release\")\n",
    "\n",
    "plot3 = sns.lmplot(data=comment_phab_df, x=\"date_created\", y=\"valence_wc\", hue=\"date_group\", col=\"meta.affil\", row='engaged_commenter', scatter=False, legend=False, palette=palette)\n",
    "plot3.set_axis_labels(\"Timestamp\", \"Count of Valence Polarized Words\")\n",
    "plot3.set_titles(row_template=\"Author's 100+ Comment: {row_name}\",col_template=\"WMF Affiliation: {col_name}\")\n",
    "plot3.add_legend(title=\"Comment publication timestamp:\")\n",
    "'''\n",
    "# Show plots\n",
    "#fig1.savefig('031725_engaged_commenter_D_scoring_fig.png')\n",
    "#plot2.fig.savefig('031725_engaged_commenter_A_scoring_fig.png')\n",
    "#plot3.fig.savefig('031725_engaged_commenter_V_scoring_fig.png')\n",
    "#plt.savefig('031625_engaged_commenter_VAD_scoring_fig.png')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "5a91a59a-0d1c-48b3-93dd-b9df76ca68e5",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<seaborn.axisgrid.FacetGrid at 0x14e285a3ad30>"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "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.18"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}