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

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "ba9e5acd-e17d-4318-9272-04c9f6706186",
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd \n",
    "import spacy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "e4f0b3f0-5255-46f1-822f-e455087ba315",
   "metadata": {},
   "outputs": [],
   "source": [
    "phab_path = \"/mmfs1/gscratch/comdata/users/mjilg/mw-repo-lifecycles/case3/0422_http_phab_comments.csv\"\n",
    "phab_df = pd.read_csv(phab_path)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "ac5e624b-08a4-4ede-bc96-cfc26c3edac3",
   "metadata": {},
   "outputs": [],
   "source": [
    "def http_relevant(text):\n",
    "    if pd.isnull(text):\n",
    "        return False\n",
    "    # expanded dictionary for relevancy\n",
    "    # http, login, SSL, TLS, certificate \n",
    "    for word in text.split():\n",
    "        if \"://\" not in word.lower():\n",
    "            #http\n",
    "            if \"http\" in word.lower():\n",
    "                return True\n",
    "            #login\n",
    "            if \"login\" in word.lower():\n",
    "                return True\n",
    "            #ssl\n",
    "            if \"ssl\" in word.lower():\n",
    "                return True\n",
    "            #tls\n",
    "            if \"tls\" in word.lower():\n",
    "                return True\n",
    "            #cert\n",
    "            if word.lower().startswith(\"cert\") and not word.lower().startswith(\"certain\"):\n",
    "                return True\n",
    "    return False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "d5925c49-ea1d-4813-98aa-eae10d5879ca",
   "metadata": {},
   "outputs": [],
   "source": [
    "def is_migrated(comment_text):\n",
    "    if pd.isnull(comment_text):\n",
    "        return False\n",
    "    text = comment_text.strip()\n",
    "    if text.startswith(\"Originally from: http://sourceforge.net\"):\n",
    "        return True \n",
    "    return False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "d449164e-1d28-4580-9eb1-f0f69978f114",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_34086/836739196.py:41: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  mid_comment_phab_df['is_relevant'] = mid_comment_phab_df['conversation_id'].isin(relevant_conversation_ids)\n",
      "/tmp/ipykernel_34086/836739196.py:44: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  mid_comment_phab_df['is_migrated'] = mid_comment_phab_df['conversation_id'].isin(migrated_conversation_ids)\n"
     ]
    }
   ],
   "source": [
    "#find gerrit phab PHID: PHID-USER-idceizaw6elwiwm5xshb\n",
    "phab_df['isGerrit'] = phab_df['AuthorPHID'] == 'PHID-USER-idceizaw6elwiwm5xshb'\n",
    "\n",
    "#cleaning df\n",
    "phab_df['id'] = phab_df.index + 1\n",
    "#may have to build out the reply_to column \n",
    "phab_df['reply_to'] = phab_df.groupby('TaskPHID')['id'].shift()\n",
    "phab_df['reply_to'] = phab_df['reply_to'].where(pd.notnull(phab_df['reply_to']), None)\n",
    "\n",
    "phab_df = phab_df.rename(columns={\n",
    "    'AuthorPHID': 'speaker',\n",
    "    'TaskPHID': 'conversation_id',\n",
    "    'WMFaffil':'meta.affil',\n",
    "    'isGerrit': 'meta.gerrit'\n",
    "})\n",
    "\n",
    "# after 07-01-2013 before 10-01-2015\n",
    "phab_df['timestamp'] = pd.to_datetime(phab_df['date_created'], unit='s', origin='unix', utc=True)\n",
    "filtered_phab_df = phab_df[(phab_df['date_created'] < 1443743999) & (phab_df['date_created'] > 1372636800)]\n",
    "#filtered_phab_df = phab_df[(phab_df['date_created'] < 1381691276) & (phab_df['date_created'] > 1379975444)]\n",
    "\n",
    "#removing headless conversations\n",
    "task_phab_df = filtered_phab_df[filtered_phab_df['comment_type']==\"task_description\"]\n",
    "headed_task_phids = task_phab_df['conversation_id'].unique()\n",
    "filtered_phab_df = filtered_phab_df[filtered_phab_df['conversation_id'].isin(headed_task_phids)]\n",
    "\n",
    "#removing gerrit comments \n",
    "mid_comment_phab_df = filtered_phab_df[filtered_phab_df['meta.gerrit'] != True]\n",
    "\n",
    "# filter out the sourceforge migration \n",
    "# Originally from: http://sourceforge.net in the task task_summary\n",
    "migrated_conversation_ids = task_phab_df[task_phab_df['comment_text'].apply(is_migrated)]['conversation_id'].unique()\n",
    "\n",
    "#cut down to only the data that is relevant (mentions http)\n",
    "relevant_conversation_ids = task_phab_df[\n",
    "    task_phab_df['comment_text'].apply(http_relevant) |\n",
    "    task_phab_df['task_title'].apply(http_relevant)\n",
    "]['conversation_id'].unique()\n",
    "\n",
    "task_phab_df['is_relevant'] = task_phab_df['conversation_id'].isin(relevant_conversation_ids)\n",
    "mid_comment_phab_df['is_relevant'] = mid_comment_phab_df['conversation_id'].isin(relevant_conversation_ids)\n",
    "\n",
    "task_phab_df['is_migrated'] = task_phab_df['conversation_id'].isin(migrated_conversation_ids)\n",
    "mid_comment_phab_df['is_migrated'] = mid_comment_phab_df['conversation_id'].isin(migrated_conversation_ids)\n",
    "\n",
    "comment_phab_df = mid_comment_phab_df[(mid_comment_phab_df['is_relevant'] == True) & (mid_comment_phab_df['is_migrated'] != True)]\n",
    "task_phab_df = task_phab_df[(task_phab_df['is_relevant'] == True) & (task_phab_df['is_migrated'] != True)]\n",
    "#comment_phab_df = mid_comment_phab_df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "942344db-c8f5-4ed6-a757-c97f8454f18b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Unique conversation_ids: 2281\n",
      "Unique ids: 14490\n",
      "Unique speakers: 634\n"
     ]
    }
   ],
   "source": [
    "unique_conversation_ids = len(comment_phab_df['conversation_id'].unique())\n",
    "unique_ids = len(comment_phab_df['id'].unique())\n",
    "unique_speakers = len(comment_phab_df['speaker'].unique())\n",
    "\n",
    "print(f\"Unique conversation_ids: {unique_conversation_ids}\")\n",
    "print(f\"Unique ids: {unique_ids}\")\n",
    "print(f\"Unique speakers: {unique_speakers}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "d226d781-b002-4842-a3ae-92d4851a5878",
   "metadata": {},
   "outputs": [],
   "source": [
    "import re\n",
    "\n",
    "def preprocess_text(text):\n",
    "    text = str(text)\n",
    "    text = text.replace('*', ' ')\n",
    "    text = text.replace('-', ' ')\n",
    "    text = re.sub(r'http\\S+', '', text)\n",
    "    return text"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "3ae40d24-bbe8-49c3-a3a9-70bde1b4d559",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_34086/2783900859.py:1: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  comment_phab_df['processed_text'] = comment_phab_df['comment_text'].apply(preprocess_text)\n"
     ]
    }
   ],
   "source": [
    "comment_phab_df['processed_text'] = comment_phab_df['comment_text'].apply(preprocess_text)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b8eddf40-1fe2-4fce-be74-b32552b40c57",
   "metadata": {},
   "outputs": [],
   "source": [
    "#comment_phab_df['processed_resolved_text'] = comment_phab_df['resolved_text'].apply(preprocess_text)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "a8469b16-4ae6-4b06-bf1b-1f2f6c736cab",
   "metadata": {},
   "outputs": [],
   "source": [
    "nlp = spacy.load(\"en_core_web_sm\")\n",
    "\n",
    "def extract_dependency_tree(text):\n",
    "    doc = nlp(text)\n",
    "    dependency_trees = []\n",
    "    \n",
    "    for sentence in doc.sents:\n",
    "        for token in sentence:\n",
    "            token_info = (\n",
    "                token.text, \n",
    "                token.lemma_, \n",
    "                token.dep_, \n",
    "                token.head.text, \n",
    "                list(token.ancestors), \n",
    "                list(token.subtree), \n",
    "                list(token.children)\n",
    "            )\n",
    "            dependency_trees.append(token_info)\n",
    "        \n",
    "    return dependency_trees"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "8b9a12f9-71bf-4bc9-bcfd-c73aab4be920",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_34086/2805711855.py:1: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  comment_phab_df['dependency_tree'] = comment_phab_df['processed_text'].apply(extract_dependency_tree)\n"
     ]
    }
   ],
   "source": [
    "comment_phab_df['dependency_tree'] = comment_phab_df['processed_text'].apply(extract_dependency_tree)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "337a528a-5667-4e1f-ac9a-37caabc03a18",
   "metadata": {},
   "outputs": [],
   "source": [
    "#comment_phab_df['resolved_dependency_tree'] = comment_phab_df['processed_resolved_text'].apply(extract_dependency_tree)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "a3f5d40b-f56e-4e31-a7f9-40b7ddb4d2a4",
   "metadata": {},
   "outputs": [],
   "source": [
    "#get VAD scores\n",
    "import numpy as np\n",
    "#https://saifmohammad.com/WebPages/nrc-vad.html\n",
    "column_headings = ['Word', 'Valence', 'Arousal', 'Domination']\n",
    "vad_lexicon = pd.read_csv('NRC-VAD-Lexicon.txt', delimiter='\\t', header=None, names=column_headings)\n",
    "vad_dict = vad_lexicon.set_index('Word').T.to_dict()\n",
    "\n",
    "def vad_scoring(dependency_tree):\n",
    "    valence = []\n",
    "    arousal = []\n",
    "    dominance = []\n",
    "    for token, lemma, dep, head, ancestors, subtree, children in dependency_tree:\n",
    "        if lemma in vad_dict:\n",
    "            valence.append(vad_dict[lemma]['Valence'])\n",
    "            arousal.append(vad_dict[lemma]['Arousal'])\n",
    "            dominance.append(vad_dict[lemma]['Domination'])\n",
    "\n",
    "    # Compute average scores across the comment\n",
    "    avg_valence = np.mean(valence) if valence else 0\n",
    "    avg_arousal = np.mean(arousal) if arousal else 0\n",
    "    avg_dominance = np.mean(dominance) if dominance else 0\n",
    "\n",
    "    return [avg_valence, avg_arousal, avg_dominance]\n",
    "\n",
    "def dominance_prevail(dependency_tree):\n",
    "    dominant_words = 0 \n",
    "    for token, lemma, dep, head, ancestors, subtree, children in dependency_tree:\n",
    "        if lemma in vad_dict:\n",
    "            if vad_dict[lemma]['Domination'] >= 0.75:\n",
    "                dominant_words += 1\n",
    "            if vad_dict[lemma]['Domination'] <= 0.25:\n",
    "                dominant_words += 1\n",
    "    return dominant_words\n",
    "\n",
    "def arousal_prevail(dependency_tree):\n",
    "    arousal_words = 0 \n",
    "    for token, lemma, dep, head, ancestors, subtree, children in dependency_tree:\n",
    "        if lemma in vad_dict:\n",
    "            if vad_dict[lemma]['Arousal'] >= 0.75:\n",
    "                arousal_words += 1\n",
    "            if vad_dict[lemma]['Arousal'] <= 0.25:\n",
    "                arousal_words += 1\n",
    "    return arousal_words\n",
    "\n",
    "def valence_prevail(dependency_tree):\n",
    "    valence_words = 0 \n",
    "    for token, lemma, dep, head, ancestors, subtree, children in dependency_tree:\n",
    "        if lemma in vad_dict:\n",
    "            if vad_dict[lemma]['Valence'] >= 0.75:\n",
    "                valence_words += 1\n",
    "            if vad_dict[lemma]['Valence'] <= 0.25:\n",
    "                valence_words += 1\n",
    "    return valence_words\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "828fb57a-e152-42ef-9c60-660648898532",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_34086/2858732056.py:2: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  comment_phab_df['avg_vad_scores'] = comment_phab_df['dependency_tree'].apply(vad_scoring)\n",
      "/tmp/ipykernel_34086/2858732056.py:3: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  comment_phab_df['dominant_wc'] = comment_phab_df['dependency_tree'].apply(dominance_prevail)\n",
      "/tmp/ipykernel_34086/2858732056.py:4: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  comment_phab_df['arousal_wc'] = comment_phab_df['dependency_tree'].apply(arousal_prevail)\n",
      "/tmp/ipykernel_34086/2858732056.py:5: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  comment_phab_df['valence_wc'] = comment_phab_df['dependency_tree'].apply(valence_prevail)\n"
     ]
    }
   ],
   "source": [
    "#establishing per-comment VAD scores \n",
    "comment_phab_df['avg_vad_scores'] = comment_phab_df['dependency_tree'].apply(vad_scoring)\n",
    "comment_phab_df['dominant_wc'] = comment_phab_df['dependency_tree'].apply(dominance_prevail)\n",
    "comment_phab_df['arousal_wc'] = comment_phab_df['dependency_tree'].apply(arousal_prevail)\n",
    "comment_phab_df['valence_wc'] = comment_phab_df['dependency_tree'].apply(valence_prevail)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "27e47f6f-0257-4b70-b222-e91ef888c900",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_34086/335308388.py:1: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  comment_phab_df[['average_v_score', 'average_a_score', 'average_d_score']] = pd.DataFrame(comment_phab_df['avg_vad_scores'].tolist(), index=comment_phab_df.index)\n",
      "/tmp/ipykernel_34086/335308388.py:1: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  comment_phab_df[['average_v_score', 'average_a_score', 'average_d_score']] = pd.DataFrame(comment_phab_df['avg_vad_scores'].tolist(), index=comment_phab_df.index)\n",
      "/tmp/ipykernel_34086/335308388.py:1: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  comment_phab_df[['average_v_score', 'average_a_score', 'average_d_score']] = pd.DataFrame(comment_phab_df['avg_vad_scores'].tolist(), index=comment_phab_df.index)\n"
     ]
    }
   ],
   "source": [
    "comment_phab_df[['average_v_score', 'average_a_score', 'average_d_score']] = pd.DataFrame(comment_phab_df['avg_vad_scores'].tolist(), index=comment_phab_df.index)\n",
    "comment_phab_df = comment_phab_df.drop(columns=['avg_vad_scores'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "184ccbe6-0a7a-41b8-9b02-bc439ff975d0",
   "metadata": {},
   "outputs": [],
   "source": [
    "# expand the dependency parser \n",
    "\n",
    "#pattern = r'\\b(ve|VE|visualeditor|VisualEditor)\\b'\n",
    "#pattern = r'\\b(WMF|Foundation)\\b'\n",
    "#pattern = r'\\b(bots|scripts|gadgets)\\b'\n",
    "pattern = r'\\b(http|https)\\b'\n",
    "\n",
    "dependency_relations = []\n",
    "resolved_dependency_relations = []\n",
    "\n",
    "for index, row in comment_phab_df.iterrows():\n",
    "    text = row['comment_text']\n",
    "    timestamp = row['timestamp']\n",
    "    comment_id = row['id']\n",
    "    conversation_id = row['conversation_id']\n",
    "    WMFaffil = row['meta.affil']\n",
    "    \n",
    "    for token, lemma, dep, head, ancestors, subtree, children in row['dependency_tree']:\n",
    "        if re.search(pattern, token, re.IGNORECASE):\n",
    "            dependency_relations.append({\n",
    "                'comment_id': comment_id,\n",
    "                'timestamp': timestamp,\n",
    "                'wmfAffil':WMFaffil,\n",
    "                'token': token,\n",
    "                'dependency': dep,\n",
    "                'head': head,\n",
    "                'depth': len(list(ancestors)), \n",
    "                'children': len(list(children)) \n",
    "            })\n",
    "    '''        \n",
    "    for token, lemma, dep, head, ancestors, subtree, children in row['resolved_dependency_tree']:\n",
    "        if re.search(pattern, token, re.IGNORECASE):\n",
    "            resolved_dependency_relations.append({\n",
    "                'comment_id': comment_id,\n",
    "                'timestamp': timestamp,\n",
    "                'wmfAffil':WMFaffil,\n",
    "                'token': token,\n",
    "                'dependency': dep,\n",
    "                'head': head,\n",
    "                'depth': len(list(ancestors)), \n",
    "                'children': len(list(children)) \n",
    "            })\n",
    "    '''\n",
    "#resolved_dependency_relations_df = pd.DataFrame(resolved_dependency_relations)            \n",
    "dependency_relations_df = pd.DataFrame(dependency_relations)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "82498686-14f4-40c8-9e33-27b31f115b47",
   "metadata": {},
   "outputs": [],
   "source": [
    "#now analysis/plotting \n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "from matplotlib.gridspec import GridSpec\n",
    "import matplotlib.ticker as ticker\n",
    "import matplotlib.dates as mdates"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "9833922d-d69a-4f8d-96ed-b25eea626114",
   "metadata": {},
   "outputs": [],
   "source": [
    "given_date = pd.Timestamp(\"2015-07-02\").tz_localize(None)\n",
    "task_phab_df['timestamp'] = pd.to_datetime(task_phab_df['timestamp'], unit='s').dt.tz_localize(None)\n",
    "#task_phab_df = task_phab_df[(task_phab_df['date_created'] < 1380585599) & (task_phab_df['date_created'] > 1352592000)]\n",
    "task_phab_df['week_bin'] = ((task_phab_df['timestamp'] - given_date).dt.days // 7)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "ebd80040-8e9b-49f3-9eea-5643bdf12f5b",
   "metadata": {},
   "outputs": [],
   "source": [
    "task_phab_df\n",
    "#task_phab_df.to_csv(\"/mmfs1/gscratch/comdata/users/mjilg/mw-repo-lifecycles/case3/phab_tasks.csv\", index=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "82cd9dde-0d14-4de5-8482-5a39de8d2869",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_96995/627627281.py:7: UserWarning: Converting to PeriodArray/Index representation will drop timezone information.\n",
      "  task_phab_df['week'] = task_phab_df['timestamp'].dt.to_period('W').dt.start_time\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x600 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(10, 6))\n",
    "#task_phab_df = phab_df[phab_df['comment_type']==\"task_description\"]\n",
    "task_phab_df = task_phab_df[task_phab_df['is_relevant'] == True]\n",
    "task_phab_df['first_comment'] = task_phab_df.groupby('speaker')['timestamp'].rank(method='first') <= 5\n",
    "#task_phab_df = task_phab_df[(task_phab_df['date_created'] < 1383264000) & (task_phab_df['date_created'] > 1351728000)]\n",
    "\n",
    "task_phab_df['week'] = task_phab_df['timestamp'].dt.to_period('W').dt.start_time\n",
    "unique_taskPHIDs = task_phab_df.groupby('week')['conversation_id'].nunique()\n",
    "\n",
    "wmf_task_phab_df = task_phab_df[(task_phab_df['meta.affil'] == True)]\n",
    "wmf_tasks = wmf_task_phab_df.groupby('week')['conversation_id'].nunique()\n",
    "\n",
    "other_task_phab_df = task_phab_df[(task_phab_df['meta.affil'] != True)]\n",
    "other_tasks = other_task_phab_df.groupby('week')['conversation_id'].nunique()\n",
    "\n",
    "'''\n",
    "task_phab_df['speakers_task'] = task_phab_df.groupby('speaker')['timestamp'].rank(method='first').astype(int)\n",
    "\n",
    "# Filter dates 06-12-2015 to 10-01-2015\n",
    "bounded_task_phab_df = task_phab_df[(task_phab_df['date_created'] < 1443743999) & (task_phab_df['date_created'] > 1434067200)]\n",
    "# Bin the speakers based on the number of tasks they created\n",
    "bins = [0, 6, 26, 51, float('inf')]\n",
    "labels = ['0-5', '6-25', '26-50', '51+']\n",
    "min_speakers_task = bounded_task_phab_df.groupby('speaker')['speakers_task'].min().reset_index()\n",
    "min_speakers_task = bounded_task_phab_df.rename(columns={'speakers_task': 'min_speakers_task'})\n",
    "bounded_task_phab_df = bounded_task_phab_df.merge(min_speakers_task, on='speaker', how='left')\n",
    "bounded_task_phab_df['task_bins'] = pd.cut(bounded_task_phab_df ['min_speakers_task'], bins=bins, labels=labels, right=False)\n",
    "print(bounded_task_phab_df)\n",
    "bounded_task_phab_df['week'] = bounded_task_phab_df['timestamp_y'].dt.to_period('W').dt.start_time\n",
    "weekly_breakdown = bounded_task_phab_df.groupby(['week', 'task_bins']).size().unstack(fill_value=0)\n",
    "speaker_breakdown = bounded_task_phab_df.groupby(['week', 'task_bins']).nunique()['speaker'].unstack(fill_value=0)\n",
    "\n",
    "# Reshape the DataFrame for use with Seaborn\n",
    "weekly_breakdown = weekly_breakdown.reset_index().melt(id_vars='week', value_vars=labels, var_name='task_bins', value_name='count')\n",
    "speaker_breakdown = speaker_breakdown.reset_index().melt(id_vars='week', value_vars=labels, var_name='task_bins', value_name='speakers')\n",
    "\n",
    "rookie_bounded_task_phab_df = weekly_breakdown[weekly_breakdown['task_bins'] == '0-5']\n",
    "\n",
    "#unaff_new_tasks_phab_df = task_phab_df[(task_phab_df['first_comment'] == True) & (task_phab_df['meta.affil'] != True)]\n",
    "#unaff_new_tasks = unaff_new_tasks_phab_df.groupby('week')['conversation_id'].nunique()\n",
    "\n",
    "#aff_new_tasks_phab_df = task_phab_df[(task_phab_df['first_comment'] == True) & (task_phab_df['meta.affil'] == True)]\n",
    "#aff_new_tasks = aff_new_tasks_phab_df.groupby('week')['conversation_id'].nunique()\n",
    "\n",
    "#sns.lineplot(x=unique_taskPHIDs.index, y=unique_taskPHIDs.values, color='black', label='Total', marker='o')\n",
    "#sns.lineplot(x=wmf_tasks.index, y=wmf_tasks.values, color='#c7756a', label='WMF-affiliated authors', marker='o')\n",
    "#sns.lineplot(x=other_tasks.index, y=other_tasks.values, color='#5da2d8', label='Nonaffiliated authors', marker='o')\n",
    "#sns.lineplot(x=aff_new_tasks.index, y=aff_new_tasks.values, color='#c7756a',linestyle=\"dotted\", label=\"WMF-affiliated new authors\", marker='x')\n",
    "#sns.lineplot(x=unaff_new_tasks.index, y=unaff_new_tasks.values, color='#5da2d8', linestyle=\"dotted\", label=\"Nonaffiliated new authors\", marker='x')\n",
    "'''\n",
    "#sns.barplot(x=unique_taskPHIDs.index, y=unique_taskPHIDs.values, color='black', label='Total')\n",
    "sns.barplot(x=other_tasks.index, y=other_tasks.values, color='#5da2d8', label='Nonaffiliated authors')\n",
    "sns.barplot(x=wmf_tasks.index, y=-wmf_tasks.values, color='#c7756a', label='WMF-affiliated authors')\n",
    "#sns.lineplot(data=rookie_bounded_task_phab_df, x='week', y='count', color='green', label='Authors with ≤ 5 tasks', marker='o')\n",
    "\n",
    "plt.title('New Relevant Phabricator Tasks Indexed with HTTP')\n",
    "plt.xlabel('Timestamp')\n",
    "plt.ylabel('Unique taskPHIDs')\n",
    "plt.xticks(rotation=90)\n",
    "# Customize the x-axis for weekly labels\n",
    "plt.grid(True)\n",
    "plt.tight_layout()\n",
    "plt.show()\n",
    "\n",
    "#plt.savefig('031825_new_tasks_fig.png')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "9a9b08a7-6c95-4971-b259-8e713c58fbe7",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_96995/3303796756.py:4: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  unaff_tasks_phab_df['speakers_task'] = unaff_tasks_phab_df.groupby('speaker')['timestamp'].rank(method='first').astype(int)\n",
      "/tmp/ipykernel_96995/3303796756.py:17: UserWarning: Converting to PeriodArray/Index representation will drop timezone information.\n",
      "  unaff_tasks_phab_df['week'] = unaff_tasks_phab_df['timestamp'].dt.to_period('W').dt.start_time\n",
      "/tmp/ipykernel_96995/3303796756.py:18: FutureWarning: The default of observed=False is deprecated and will be changed to True in a future version of pandas. Pass observed=False to retain current behavior or observed=True to adopt the future default and silence this warning.\n",
      "  weekly_breakdown = unaff_tasks_phab_df.groupby(['week', 'task_bins']).size().unstack(fill_value=0)\n",
      "/tmp/ipykernel_96995/3303796756.py:20: FutureWarning: The default of observed=False is deprecated and will be changed to True in a future version of pandas. Pass observed=False to retain current behavior or observed=True to adopt the future default and silence this warning.\n",
      "  speaker_breakdown = unaff_tasks_phab_df.groupby(['week', 'task_bins']).nunique()['speaker'].unstack(fill_value=0)\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1200x800 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "#task_phab_df = phab_df[phab_df['comment_type'] == \"task_description\"]\n",
    "unaff_tasks_phab_df = task_phab_df[task_phab_df['meta.affil'] != True]\n",
    "# Rank speaker's task values within each group\n",
    "unaff_tasks_phab_df['speakers_task'] = unaff_tasks_phab_df.groupby('speaker')['timestamp'].rank(method='first').astype(int)\n",
    "\n",
    "# Filter dates 06-12-2015 to 10-01-2015\n",
    "unaff_tasks_phab_df = unaff_tasks_phab_df[(unaff_tasks_phab_df['date_created'] < 1443743999) & (unaff_tasks_phab_df['date_created'] > 1434067200)]\n",
    "# Bin the speakers based on the number of tasks they created\n",
    "bins = [0, 6, 26, 51, float('inf')]\n",
    "labels = ['0-5', '6-25', '26-50', '51+']\n",
    "min_speakers_task = unaff_tasks_phab_df.groupby('speaker')['speakers_task'].min().reset_index()\n",
    "min_speakers_task = min_speakers_task.rename(columns={'speakers_task': 'min_speakers_task'})\n",
    "unaff_tasks_phab_df = unaff_tasks_phab_df.merge(min_speakers_task, on='speaker', how='left')\n",
    "unaff_tasks_phab_df['task_bins'] = pd.cut(unaff_tasks_phab_df['min_speakers_task'], bins=bins, labels=labels, right=False)\n",
    "\n",
    "# Calculate the weekly breakdown of binned speakers_task values\n",
    "unaff_tasks_phab_df['week'] = unaff_tasks_phab_df['timestamp'].dt.to_period('W').dt.start_time\n",
    "weekly_breakdown = unaff_tasks_phab_df.groupby(['week', 'task_bins']).size().unstack(fill_value=0)\n",
    "\n",
    "speaker_breakdown = unaff_tasks_phab_df.groupby(['week', 'task_bins']).nunique()['speaker'].unstack(fill_value=0)\n",
    "\n",
    "# Reshape the DataFrame for use with Seaborn\n",
    "weekly_breakdown = weekly_breakdown.reset_index().melt(id_vars='week', value_vars=labels, var_name='task_bins', value_name='count')\n",
    "speaker_breakdown = speaker_breakdown.reset_index().melt(id_vars='week', value_vars=labels, var_name='task_bins', value_name='speakers')\n",
    "\n",
    "# Plot the stacked bar plot using Seaborn\n",
    "plt.figure(figsize=(12, 8))\n",
    "sns.barplot(data=weekly_breakdown, x='week', y='count', hue='task_bins', palette='colorblind')\n",
    "#sns.barplot(data=speaker_breakdown, x='week', y='speakers', hue='task_bins', palette='colorblind')\n",
    "plt.title(\"06-12-2015 to 10-01-2015 Weekly Unaffiliated Task Creation by Contributor Tenure\")\n",
    "plt.xlabel('Week')\n",
    "plt.ylabel('Tasks')\n",
    "plt.legend(title=\"Contributor had created # tasks between 8-01-2013 and 06-12-2015:\")\n",
    "plt.xticks(rotation=45)\n",
    "plt.tight_layout()\n",
    "plt.show()\n",
    "\n",
    "#plt.savefig('031625_weekly_tasks_by_history.png')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "b7cfad77-d48a-4708-91f3-89ae1179b90c",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_34086/62586942.py:27: FutureWarning: The default of observed=False is deprecated and will be changed to True in a future version of pandas. Pass observed=False to retain current behavior or observed=True to adopt the future default and silence this warning.\n",
      "  comment_counts = affective_comment_phab_df.groupby('date_group').size()\n",
      "/tmp/ipykernel_34086/62586942.py:28: FutureWarning: The default of observed=False is deprecated and will be changed to True in a future version of pandas. Pass observed=False to retain current behavior or observed=True to adopt the future default and silence this warning.\n",
      "  speaker_counts = affective_comment_phab_df.groupby('date_group')['speaker'].nunique()\n",
      "/tmp/ipykernel_34086/62586942.py:35: FutureWarning: The default of observed=False is deprecated and will be changed to True in a future version of pandas. Pass observed=False to retain current behavior or observed=True to adopt the future default and silence this warning.\n",
      "  comment_counts_engaged = affective_comment_phab_df.groupby(['date_group', 'est_commenter', 'meta.affil']).size()\n",
      "/tmp/ipykernel_34086/62586942.py:36: FutureWarning: The default of observed=False is deprecated and will be changed to True in a future version of pandas. Pass observed=False to retain current behavior or observed=True to adopt the future default and silence this warning.\n",
      "  speaker_counts_engaged = affective_comment_phab_df.groupby(['date_group', 'est_commenter', 'meta.affil'])['speaker'].nunique()\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of comments for each date group:\n",
      "date_group\n",
      "Before announcement                      10614\n",
      "After announcement, before deployment      802\n",
      "After deployment                          3074\n",
      "dtype: int64\n",
      "\n",
      "Number of speakers for each date group:\n",
      "date_group\n",
      "Before announcement                      521\n",
      "After announcement, before deployment    142\n",
      "After deployment                         310\n",
      "Name: speaker, dtype: int64\n",
      "\n",
      "Number of comments for each date group and engaged commenter subgroup:\n",
      "date_group                             est_commenter  meta.affil\n",
      "Before announcement                    False          False         10317\n",
      "                                                      True            297\n",
      "After announcement, before deployment  False          False           787\n",
      "                                                      True             15\n",
      "After deployment                       False          False          2992\n",
      "                                                      True             82\n",
      "dtype: int64\n",
      "\n",
      "Number of speakers for each date group and engaged commenter subgroup:\n",
      "date_group                             est_commenter  meta.affil\n",
      "Before announcement                    False          False         518\n",
      "                                                      True           56\n",
      "After announcement, before deployment  False          False         138\n",
      "                                                      True            7\n",
      "After deployment                       False          False         305\n",
      "                                                      True           24\n",
      "Name: speaker, dtype: int64\n",
      "\n",
      "Number of comments for each engaged commenter subgroup, and WMF affiliation:\n",
      "est_commenter  meta.affil\n",
      "False          False         14096\n",
      "               True            394\n",
      "dtype: int64\n",
      "\n",
      "Number of speakers for each engaged commenter subgroup, and WMF affiliation:\n",
      "est_commenter  meta.affil\n",
      "False          False         627\n",
      "               True           75\n",
      "Name: speaker, dtype: int64\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'\\nplot1 = sns.lmplot(data=comment_phab_df, x=\"date_created\", y=\"dominant_wc\", hue=\"date_group\", col=\"meta.affil\", row=\\'new_commenter\\', scatter=False, legend=False, palette=palette)\\nplot1.set_axis_labels(\"Timestamp\", \"Count of Dominance Polarized Words\")\\nplot1.set_titles(row_template=\"Author\\'s 100+ Comment: {row_name}\",col_template=\"WMF Affiliation: {col_name}\")\\nplot1.fig.subplots_adjust(top=0.9)  # Adjust subplots to make room for the title\\nplot1.add_legend(title=\"Comment publication timestamp:\")\\nfig1 = plot1.fig\\n# Plot for arousal_wc\\nplot2 = sns.lmplot(data=comment_phab_df, x=\"date_created\", y=\"arousal_wc\", hue=\"date_group\", col=\"meta.affil\", row=\\'engaged_commenter\\', scatter=False, legend=False, palette=palette)\\nplot2.set_axis_labels(\"Timestamp\", \"Count of Arousal Polarized Words\")\\nplot2.set_titles(row_template=\"Author\\'s 100+ Comment: {row_name}\",col_template=\"WMF Affiliation: {col_name}\")\\nplot2.add_legend(title=\"Comment publication timestamp:\")\\n#plot2.add_legend(title=\"Before/After 07/01/2013 Wide Release\")\\n\\nplot3 = sns.lmplot(data=comment_phab_df, x=\"date_created\", y=\"valence_wc\", hue=\"date_group\", col=\"meta.affil\", row=\\'engaged_commenter\\', scatter=False, legend=False, palette=palette)\\nplot3.set_axis_labels(\"Timestamp\", \"Count of Valence Polarized Words\")\\nplot3.set_titles(row_template=\"Author\\'s 100+ Comment: {row_name}\",col_template=\"WMF Affiliation: {col_name}\")\\nplot3.add_legend(title=\"Comment publication timestamp:\")\\n'"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAABR4AAAHaCAYAAABmaVX2AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8ekN5oAAAACXBIWXMAAA9hAAAPYQGoP6dpAACxkElEQVR4nOzdd3gUVdsG8Hu2pCcbEtKQQIBQQu8SUKkSirw0pSoEQVQ6SP0USbCAShUVeWkBBQSkiEhTXhIU6UgUCVFCCSUQIL1nd+b7Y5MhmwK7ySabcv+uay92z8yeeXaZZLLPPuccQZIkCURERERERERERERmpLB0AERERERERERERFT5MPFIREREREREREREZsfEIxEREREREREREZkdE49ERERERERERERkdkw8EhERERERERERkdkx8UhERERERERERERmx8QjERERERERERERmR0Tj0RERERERERERGR2TDwSERERERERERGR2THxSCbp0qULpk2b9sR9fHx8sGLFCvmxIAjYu3evUf2bsq8pjIm7NFn6+CURGBiIAQMGlFr/oaGh8PHxKbX+y4OgoCB4eHgYnN/52/K/z/nPmfw/V8Vlrn7KUkhICJydnS0dBpHZ8FpaMY9fEryWlhyvpURERBUTE48VVGBgIARBKHDr1auXUc8vyz+YYmJi0Lt37zI5Vkmlp6fDxcUF1atXR2ZmpsnPDw0NhSAISEhIMH9wJeDj41PgXKlZs6alwzLK119/DUdHR2i1WrktJSUFarUaXbp0Mdg39/2PiooC8Ph1f/fddwX6bdKkCQRBQEhIiNxW3Pfp9u3bsLKyQtOmTQtsi4iIQHBwMNasWSP/LBTWtnLlSoNY8jt79izGjx//1FhyFZWsM7Ufcynqd9bVq1fLPBaiXLyWlg5eS8sfXkv1KvK1tLDfVXlvQUFBZRoPERGRsZh4rMB69eqFmJgYg9u2bdssHVYBnp6esLa2tnQYRtm1axeaNGmCRo0alUq1iDllZWWZtP/ChQsNzpU//vijlCIzr65duyIlJQXnzp2T23799Vd4enri9OnTyMjIkNuPHTuGWrVqoV69enKbt7c3Nm7caNDnqVOncO/ePdjb2xc4XnHep5CQEAwZMgRJSUk4ffq0wbbcD279+/eXfxYKa9NoNE+s6nNzc4Odnd1TY3kac/VTHIX9zqpTp45FYiHKxWup+fFaWv7wWqpXka+led/PFStWwMnJyaBt5syZ8r6SJBkkmYmIiCyJiccKzNraGp6enga3atWqAdD/wREUFIRatWrB2toaNWrUwJQpUwDoh53cvHkT06dPl78lBYBHjx5h+PDheOaZZ2BnZ4dmzZoV+uFLq9Vi0qRJ0Gg0qF69OubPnw9JkoqMM++QmKysLEyaNAleXl6wsbFB7dq1sWjRIoP9Hz58iIEDB8LOzg7169fHvn37DLZfunQJvXv3hoODAzw8PPDaa6/h4cOH8vbU1FSMGjUKDg4O8PLywtKlS41+T9evX49XX30Vr776KtavX2+w7caNGxAEARcvXpTbEhISIAgCQkNDcePGDXTt2hUAUK1aNQiCgMDAQHlfURQxe/ZsuLi4wNPTs8A309HR0ejfvz8cHBzg5OSEIUOG4P79+/L2oKAgtGzZEuvWrUOdOnVgY2Nj9OsCAEdHR4Nzxc3NDTqdDmPHjkWdOnVga2uLhg0bYuXKlU/s5/vvv0ezZs1ga2sLV1dX9OjRA6mpqfL2devWwc/PDzY2NmjUqBG++uork+LMr2HDhvDy8kJoaKjcFhoaiv79+6NOnTo4deqUQXvu/0GukSNHIiwsDLdu3ZLbNmzYgJEjR0KlUhU4XmHv05NIkoSNGzfitddew4gRIwzOm6CgIPTr1w8AoFAo5IqE/G3A04fh5a+sWrZsGZo1awZ7e3t4e3tjwoQJSElJkd+HMWPGIDExsUAlRP5+jD3vvvnmG/j4+ECj0WDYsGFITk5+4vtSmMJ+ZymVyie+lsKEh4eja9eucHR0hJOTE9q0aWPwYfq3337D888/D1tbW3h7e2PKlCkG5yhRXryW8lpqCl5LeS0trJ+yuJbmfT81Gg0EQZAfX7lyBY6Ojjh48CDatGkDa2tr/Pbbb4W+H9OmTTOochVFEYsWLZLP3xYtWuD77783Oi4iIqKnYeKxktq1axeWL1+ONWvW4N9//8XevXvRrFkzAMDu3btRs2ZNg2+jASAjIwNt2rTBTz/9hEuXLmH8+PF47bXXcObMGYO+N23aBJVKhTNnzmDlypVYtmwZ1q1bZ1Rcn3/+Ofbt24cdO3YgMjISW7ZsKTAnUXBwMIYMGYI///wTffr0wciRIxEXFwdA/+GkW7duaNWqFc6dO4dDhw7h/v37GDJkiPz8WbNmISwsDD/88AOOHDmC0NBQXLhw4amxRUVF4eTJkxgyZAiGDBmCX3/9FTdv3jTqdQH6aoBdu3YBACIjIxETE2PwwWPTpk2wt7fH6dOn8emnn2LhwoX4+eefAej/6Ovfvz/i4uIQFhaGn3/+GdeuXcPQoUMNjnH16lXs2rULu3fvlj+0BQYGFhgmZSxRFFGzZk3s3LkTly9fxvvvv4//+7//w44dOwrdPyYmBsOHD8frr7+OiIgIhIaGYtCgQfKH5S1btuD999/HRx99hIiICHz88ceYP38+Nm3aVKz4cnXt2hXHjh2THx87dgxdunRB586d5fb09HScPn26wIclDw8PBAQEyDGkpaVh+/bteP3110sUU95Y0tLS0KNHD7z66qv47rvv5A+PM2fOlCtE8lYk5G8rDoVCgc8//xx///03Nm3ahP/973+YPXs2AKBjx44FqiHyVkLkMva8i4qKwt69e7F//37s378fYWFhWLx4sbw9JCRE/tBn7tdSmJEjR6JmzZo4e/Yszp8/j7lz50KtVsux9urVC4MHD8aff/6J7du347fffsOkSZOKHR9VXbyW8lpqDF5LS47X0pJfSwFg7ty5WLx4MSIiItC8eXOjnrNo0SJs3rwZX3/9Nf7++29Mnz4dr776KsLCwkoUCxERkUyiCmn06NGSUqmU7O3tDW4fffSRJEmStHTpUqlBgwZSVlZWoc+vXbu2tHz58qcep2/fvtI777wjP+7cubPk5+cniaIot82ZM0fy8/Mrsm8A0p49eyRJkqTJkydL3bp1M3h+XgCk9957T36ckpIiAZAOHjwoSZIkffDBB1LPnj0NnnPr1i0JgBQZGSklJydLVlZW0o4dO+Ttjx49kmxtbaWpU6c+8bX+3//9nzRgwAD5cf/+/aUFCxbIj69fvy4BkP744w+5LT4+XgIgHTt2TJIkSTp27JgEQIqPjzfou3PnztJzzz1n0NauXTtpzpw5kiRJ0pEjRySlUilFR0fL2//++28JgHTmzBlJkiRpwYIFklqtlmJjYw36mTt3rvTaa6898bXVrl1bsrKyMjhXVq5cWei+EydOlAYPHiw/Hj16tNS/f39JkiTp/PnzEgDpxo0bhT63Xr160tatWw3aPvjgA8nf37/I2I4dOybVrl37ifGvXbtWsre3l7Kzs6WkpCRJpVJJsbGx0tatW6UXXnhBkiRJOnr0qARAunnzpsHrXr58ubR3716pXr16kiiK0qZNm6RWrVpJkiRJGo1G2rhxo8H+xr5PuUaMGCFNmzZNftyiRQuDPvfs2SPl/1VbWFve91mS9OdM3nP2aT+zO3fulFxdXeXHGzdulDQaTYH98vZj7HlnZ2cnJSUlyfvMmjVLevbZZ+XHu3fvlho2bFhkbLmvL//vrJdffrlYr8XR0VEKCQkp9Lljx46Vxo8fb9D266+/SgqFQkpPT39ijFT18Fr6GK+lvJZKEq+l5f1aWlRcuT8ze/fuNdgv//shSZI0depUqXPnzpIkSVJGRoZkZ2cn/f777wb7jB07Vho+fLhRsRARET1NwbERVGF07doVq1evNmhzcXEBALzyyitYsWIF6tati169eqFPnz7o169focNhcul0Onz88cfYsWMH7ty5g6ysLGRmZhaYw6ZDhw4G38j6+/tj6dKl0Ol0UCqVT4w5MDAQL774Iho2bIhevXrhpZdeQs+ePQ32yfsNrb29PZycnBAbGwtAP8Ty2LFjcHBwKNB3VFQU0tPTkZWVhWeffdbgPWnYsOET49LpdNi0aZNBVcWrr76KmTNn4v3334dCUfLi4PzfPHt5ecmvKyIiAt7e3vD29pa3N27cGM7OzoiIiEC7du0AALVr1y4wXCn/8LqizJo1y2C4WvXq1QEAX375JTZs2IDo6Gj5/WvZsmWhfbRo0QLdu3dHs2bNEBAQgJ49e+Lll19GtWrVkJqaiqioKIwdOxZvvPGG/BytVguNRmNUjEXp0qULUlNTcfbsWcTHx6NBgwZwc3ND586dMWbMGGRkZCA0NBR169ZFrVq1Cjy/b9++ePPNN3H8+HFs2LDhiRUaRb1PhUlISMDu3bvx22+/yW25Qwvz9lEafvnlFyxatAhXrlxBUlIStFotMjIykJaWZvS8U8aedz4+PnB0dJT3yXvuAsDAgQMxcODApx4v/++s3HnBTH0tM2bMwLhx4/DNN9+gR48eeOWVV+S5yMLDw/Hnn39iy5Yt8v6SJEEURVy/fh1+fn5GvTdUdfBaaojX0ifjtZTX0vzK+lr6JG3btjVp/6tXryItLQ0vvviiQXtWVhZatWpVoliIiIhyMfFYgdnb28PX17fQbd7e3oiMjMQvv/yCn3/+GRMmTMBnn32GsLAweUhifp999hlWrlyJFStWyPPdTJs2zeSJ15+kdevWuH79Og4ePIhffvkFQ4YMQY8ePQzmkskfnyAIEEURgH4Fxn79+uGTTz4p0LeXl1exV8g9fPgw7ty5U2BYjE6nw9GjR/Hiiy/KH5ikPHNwZWdnG32MJ70uYxU2gbuxqlevXuB8+e677zBz5kwsXboU/v7+cHR0xGeffVZgUvdcSqUSP//8M37//XccOXIEq1atwrvvvovTp0/Lf6CvXbvW4MNq7vNKwtfXFzVr1sSxY8cQHx+Pzp07AwBq1KgBb29v/P777zh27Bi6detW6PNVKhVee+01LFiwAKdPn8aePXuKPFZh71NRtm7dioyMDIPXm5vk+ueff9CgQQMTXqXxbty4gZdeeglvv/02PvroI7i4uOC3337D2LFjkZWVZfYJ781x7gKF/84qzmsJCgrCiBEj8NNPP+HgwYNYsGABvvvuOwwcOBApKSl488035Xn48irsgzQRr6WGeC19Ml5LeS0tLnNdS58k/7mtUCgKzB2b9+ctdz7Ln376Cc8884zBfhVlMSsiIir/OMdjJWZra4t+/frh888/R2hoKE6ePIm//voLAGBlZQWdTmew/4kTJ9C/f3+8+uqraNGiBerWrYt//vmnQL/5/5A+deoU6tevb/QfxE5OThg6dCjWrl2L7du3Y9euXfK8U0/TunVr/P333/Dx8YGvr6/Bzd7eHvXq1YNarTaIMT4+vtDXkdf69esxbNgwXLx40eA2bNgweYLz3OqIvPMI5Z0cH9C/rwAKvLdP4+fnh1u3bhlM2n758mUkJCSgcePGJvVlihMnTqBjx46YMGECWrVqBV9fX3mVyKIIgoBOnTohODgYf/zxB6ysrLBnzx54eHigRo0auHbtWoH/G3OsXNy1a1eEhoYiNDTUYB6uF154AQcPHsSZM2cKzEmV1+uvv46wsDD0799fXjiipNavX4933nnH4JwJDw/H888/jw0bNpjlGIU5f/48RFHE0qVL0aFDBzRo0AB379412Kewn/H8LHXe5WXMaylMgwYNMH36dBw5cgSDBg2S5/pq3bo1Ll++XOAc9PX1lX8+iUzBa6ker6VF47W0ZHgtLT1ubm4F5r/M+/PWuHFjWFtbIzo6usD5lreCk4iIqCRY8ViBZWZm4t69ewZtKpUK1atXR0hICHQ6HZ599lnY2dnh22+/ha2tLWrXrg1AP9zj+PHjGDZsGKytrVG9enXUr18f33//PX7//XdUq1YNy5Ytw/379wv80RQdHY0ZM2bgzTffxIULF7Bq1SqjV7tctmwZvLy80KpVKygUCuzcuROenp5wdnY26vkTJ07E2rVrMXz4cHlVy6tXr+K7777DunXr4ODggLFjx2LWrFlwdXWFu7s73n333ScO73rw4AF+/PFH7Nu3D02bNjXYNmrUKAwcOBBxcXFwcXFBhw4dsHjxYtSpUwexsbF47733DPavXbs2BEHA/v370adPH9ja2hY6lC2/Hj16oFmzZhg5ciRWrFgBrVaLCRMmoHPnzk8dNjNv3jzcuXMHmzdvfupx8qtfvz42b96Mw4cPo06dOvjmm29w9uzZIj/cnD59GkePHkXPnj3h7u6O06dP48GDB/Lw1eDgYEyZMgUajQa9evVCZmYmzp07h/j4eMyYMcPk+PLq2rUrJk6ciOzsbLlKAwA6d+6MSZMmISsr64kflvz8/PDw4UOzVTBcvHgRFy5cwJYtW9CoUSODbcOHD8fChQvx4YcfmuVY+fn6+iI7OxurVq1Cv379cOLECXz99dcG+/j4+CAlJQVHjx5FixYtYGdnV+C1l+S8y2vPnj2YN28erly5UiqvJa/09HTMmjULL7/8MurUqYPbt2/j7NmzGDx4MABgzpw56NChAyZNmoRx48bB3t4ely9fxs8//4wvvvjC5Pio8uO1lNdSgNdSXksr9rW0KN26dcNnn32GzZs3w9/fH99++y0uXbokD6N2dHTEzJkzMX36dIiiiOeeew6JiYk4ceIEnJycMHr0aLPFQkREVRcrHiuwQ4cOwcvLy+D23HPPAQCcnZ2xdu1adOrUCc2bN8cvv/yCH3/8Ea6urgCAhQsX4saNG6hXr55cffDee++hdevWCAgIQJcuXeDp6YkBAwYUOO6oUaOQnp6O9u3bY+LEiZg6dSrGjx9vVMyOjo749NNP0bZtW7Rr1w43btzAgQMHjJ73qUaNGjhx4gR0Oh169uyJZs2aYdq0aXB2dpb7+Oyzz/D888+jX79+6NGjB5577jm0adOmyD43b94Me3t7dO/evcC27t27w9bWFt9++y0AYMOGDdBqtWjTpg2mTZtW4I/hZ555BsHBwZg7dy48PDyMXklXEAT88MMPqFatGl544QX06NEDdevWxfbt25/63JiYGERHRxt1nPzefPNNDBo0CEOHDsWzzz6LR48eYcKECUXu7+TkhOPHj6NPnz5o0KAB3nvvPSxduhS9e/cGAIwbNw7r1q3Dxo0b0axZM3Tu3BkhISFmq9JIT0+Hr68vPDw85PbOnTsjOTkZDRs2hJeX1xP7cHV1ha2tbYljAfQVGo0bNy7wQQnQz9MUGxuLAwcOmOVY+bVo0QLLli3DJ598gqZNm2LLli0F5ifr2LEj3nrrLQwdOhRubm749NNPC/RTkvMur8TERERGRpbaa8lLqVTi0aNHGDVqFBo0aIAhQ4agd+/eCA4OBqCf/y0sLAz//PMPnn/+ebRq1Qrvv/8+atSoUaz4qPLjtZTXUoDXUl5LK/a1tCgBAQGYP38+Zs+ejXbt2iE5ORmjRo0y2OeDDz7A/PnzsWjRIvj5+aFXr1746aefzHK+ERERAYAg5Z/4g4ioDIWGhiIwMBA3btywdChEREQVEq+lREREVF6x4pGIiIiIiIiIiIjMjolHIiIiIiIiIiIiMjsmHonIonx8fDBt2jRLh0FERFRh8VpKRERE5RXneCQiIiIiIiIiIiKzY8UjERERERERERERmR0Tj0RERERERERERGR2lT7xKEkSkpKSwBHlREREpuE1lIiIiIiISqLSJx6Tk5Oh0WiQnJxs6VCIiIgqFF5DiYiIiIioJCp94pGIiIiIiIiIiIjKHhOPREREREREREREZHZMPBIREREREREREZHZWTTxGBQUBEEQDG6NGjWSt2dkZGDixIlwdXWFg4MDBg8ejPv371swYiIiIiIiIiIiIjKGxSsemzRpgpiYGPn222+/ydumT5+OH3/8ETt37kRYWBju3r2LQYMGWTBaIiIiIiIiIiIiMobK4gGoVPD09CzQnpiYiPXr12Pr1q3o1q0bAGDjxo3w8/PDqVOn0KFDh7IOlYiIiIiIiIiIiIxk8YrHf//9FzVq1EDdunUxcuRIREdHAwDOnz+P7Oxs9OjRQ963UaNGqFWrFk6ePGmpcImIiIiIiIiIiMgIFq14fPbZZxESEoKGDRsiJiYGwcHBeP7553Hp0iXcu3cPVlZWcHZ2NniOh4cH7t27V2SfmZmZyMzMlB8nJSWVVvhERESVCq+hRERERERkThZNPPbu3Vu+37x5czz77LOoXbs2duzYAVtb22L1uWjRIgQHB5srRCIioiqD11AiIiIiIjIniw+1zsvZ2RkNGjTA1atX4enpiaysLCQkJBjsc//+/ULnhMw1b948JCYmyrdbt26VctRERESVA6+hRERERERkTuUq8ZiSkoKoqCh4eXmhTZs2UKvVOHr0qLw9MjIS0dHR8Pf3L7IPa2trODk5GdyIiIjo6XgNJSIiIiIic7LoUOuZM2eiX79+qF27Nu7evYsFCxZAqVRi+PDh0Gg0GDt2LGbMmAEXFxc4OTlh8uTJ8Pf354rWRERERERERERE5ZxFE4+3b9/G8OHD8ejRI7i5ueG5557DqVOn4ObmBgBYvnw5FAoFBg8ejMzMTAQEBOCrr76yZMhERERERERERERkBEGSJMnSQZSmpKQkaDQaJCYmcsgYERGRCXgNJSIiIiKikihXczwSERERERERERFR5cDEIxEREREREREREZkdE49ERERERERERERkdkw8EhERERERERERkdkx8UhERERERFRFVPK1RYmIqJxh4pGIiIiIiKiKYN6RiIjKEhOPREREREREVYQEZh6JiKjsMPFIRERERERUBXCYNRERlTUmHomIiIiIiKoA5h2JiKisMfFIREREREREREREZsfEIxERERERURXA+R2JiKisMfFIRERERERUFTDvSEREZYyJRyIiIiIioiqAFY9ERFTWmHgkIiIiIiKqAri4DBERlTUmHomIiIiIiKoEZh6JiKhsMfFIREREREREREREZsfEIxERERERURXAodZERFTWmHgkIiIiIiKqAri4DBERlTUmHomIiIiIiKoAVjwSEVFZY+KRiIiIiIioSmDmkYiIyhYTj0RERERERFUAKx6JiKisMfFIRERERERUBXCORyIiKmtMPBIREREREREREZHZMfFIRERERERUFbDgkYiIyhgTj0RERERERFUAh1oTEVFZY+KRiIiIiIioCuDiMkREVNaYeCQiIiIiIqoCWPFIRERljYlHIiIiIiIiIiIiMjsmHomIiIiIiKoCFjwSEVEZY+KRiIiIiIioCuBQayIiKmtMPBIREREREVUBXFyGiIjKGhOPREREREREVQIzj0REVLaYeCQiIiIiIqoCWPFIRERljYlHIiIiIiIiIiIiMjsmHomIiIiIiKoALi5DRERljYlHIiIiIiKiKoBDrYmIqKwx8UhERERERERERERmx8QjERERERFRFSCx5JGIiMoYE49ERERERERVANOORERU1ph4JCIiIiIiIiIiIrNj4pGIiIiIiKgq4FBrIiIqY0w8EhERERERVQFMOxIRUVlj4pGIiIiIiKgK4OIyRERU1ph4JCIiIiIiIiIiIrNj4pGIiIiIiIiIiIjMjolHIiIiIiKiKoBDrYmIqKwx8UhERERERFQFMO1IRERljYlHIiIiIiKiKkCSJFY9EhFRmWLikYiIiIiIqIqQJK2lQyAioiqEiUciIiIiIqIqQJIkiFK2pcMgIqIqhIlHIiIiIiKiKkACIEGEJImWDsUoFSVOIiIqGhOPREREREREVYhYQYZbV5Q4iYioaEw8EhERERERVQU5C8tIks7CgTydPunIikciooqOiUciIiIiIqJKLu9q1hIqQOJRzLJ0CEREZAZMPBIREREREVVyefKOFaLiUScx8UhEVBkw8UhERERERFSFlPfEoyRJrHgkIqokmHgkIiIiIiKq5CQ8Lnks74u2iFI2kCdeIiKquJh4JCIiIiIiquwkwweSVH4XbhE5zJqIqNJg4pGIiIiIiKiSk/JVEJbn4db6ikciIqoMmHgkIiIiIiKq5KR8I5fL68rW+vkdmXgkIqosmHgkIiIiIiKq9Awzj+V1nkdJ0oLzOxIRVR5MPBIREREREVUx5XWoNed3JCKqXMpN4nHx4sUQBAHTpk2T2zIyMjBx4kS4urrCwcEBgwcPxv379y0XJBERERERUQVUYKh1uU08ls9KTCIiKp5ykXg8e/Ys1qxZg+bNmxu0T58+HT/++CN27tyJsLAw3L17F4MGDbJQlERERERERBVTgcVlyukcj6x4JCKqXCyeeExJScHIkSOxdu1aVKtWTW5PTEzE+vXrsWzZMnTr1g1t2rTBxo0b8fvvv+PUqVMWjJiIiIiIiKhiKVjxKEKSRMsEUwRR0pW7mIiIqGQsnnicOHEi+vbtix49ehi0nz9/HtnZ2QbtjRo1Qq1atXDy5Mki+8vMzERSUpLBjYiIiJ6O11Aiosqs4IIt5a3qUZK4mjURUWVj0cTjd999hwsXLmDRokUFtt27dw9WVlZwdnY2aPfw8MC9e/eK7HPRokXQaDTyzdvb29xhExERVUq8hhIRVV75Kx71beUr8cj5HYmIKh+LJR5v3bqFqVOnYsuWLbCxsTFbv/PmzUNiYqJ8u3Xrltn6JiIiqsx4DSUiqrzyz/EIlL/Eo8TEIxFRpaOy1IHPnz+P2NhYtG7dWm7T6XQ4fvw4vvjiCxw+fBhZWVlISEgwqHq8f/8+PD09i+zX2toa1tbWpRk6ERFRpcRrKBFR1SKWs8RjeYuHiIhKzmKJx+7du+Ovv/4yaBszZgwaNWqEOXPmwNvbG2q1GkePHsXgwYMBAJGRkYiOjoa/v78lQiYiIiIiIqqYCh1qXX4qDCVJKlfxEBGReVgs8ejo6IimTZsatNnb28PV1VVuHzt2LGbMmAEXFxc4OTlh8uTJ8Pf3R4cOHSwRMhERERERUYVU6FDrcrS4jMiFZYiIKiWLJR6NsXz5cigUCgwePBiZmZkICAjAV199ZemwiIiIiIiIKpTCF5cRIUkiBMGia47mxMLEIxFRZSRIUmGXoMojKSkJGo0GiYmJcHJysnQ4REREFQavoURElUdyejqSUtPgqlFDktLldmu1CxSC2oKR6WVkPyow1NpKpYFSYb6FSImIqOxZ/qstIiIiIiIisghJEi0dAkQpm/M7EhFVUkw8EhERERERVXZFjHMTy0HCTxSzLB0CERGVEiYeiYiIiIiIKrnCFpcBAFGyfNKPC8sQEVVeTDwSERERERFVckXN7F8ehjgz8UhEVHkx8UhERERERFTpFZ551K9srSvjWB4TJW25mGeSiIhKBxOPRERERERElVxRFY8AIFoy8Siy2pGIqDJj4pGIiIiIiKgKs+Rw6/IwxyQREZUeJh6JiIiIiIgquaIWl9Fvs+xQayIiqryYeCQiIiIiIqrknjTU2lJzPOrnl2TikYioMmPikYiIiIiIqAqz1ByPHGZNRFT5MfFIRERERERUhVmq4lGUuLAMEVFlx8QjERERERFRJSc9aaw1JIskH7miNRFR5cfEIxERERERUSX3pLQjUPbDrSVJ4sIyRERVABOPREREREREld0TKx5R5ou86IdZPy0dSkREFR0Tj0RERERERJXc0yseLZF4JCKiyo6JRyIiIiIiokruyXM8ln0ikIlHIqKqgYlHIiIiIiKiKk6StE9NTpr3eEw8EhFVBUw8EhERERERUZnN8yhKWkiSWCbHIiIiy2LikYiIiIiIqJIzppqxrOZ5FEVWOxIRVRVMPBIREREREVVyxgyillBWFY9ZZXIcIiKyPCYeiYiIiIiIKjljKh4lSVcGkTDxSERUlTDxSERERERERBDLIPEoStmc35GIqAoxOfGYnp6OtLQ0+fHNmzexYsUKHDlyxKyBERERERERUdkpi4pHUSyb4dxERFQ+mJx47N+/PzZv3gwASEhIwLPPPoulS5eif//+WL16tdkDJCIiIiIiopIxZqg1IJV61aMocWEZIqKqxOTE44ULF/D8888DAL7//nt4eHjg5s2b2Lx5Mz7//HOzB0hEREREREQlY0zaEQCkUl7ZurT7JyKi8sXkxGNaWhocHR0BAEeOHMGgQYOgUCjQoUMH3Lx50+wBEhERERERUQkZVfFYusOtJUmCyMQjEVGVYnLi0dfXF3v37sWtW7dw+PBh9OzZEwAQGxsLJycnswdIRERERERExWfcMGu90kwM6odZGx8LERFVfCYnHt9//33MnDkTPj4+ePbZZ+Hv7w9AX/3YqlUrswdIREREREREZUNC6VU8cn5HIqKqR2XqE15++WU899xziImJQYsWLeT27t27Y+DAgWYNjoiIiIiIiErGhILHUh1qLUpZpdY3ERGVTyYnHgHA09MTnp6eBm3t27c3S0BERERERERkPpIJw5slSQdJkiAIgtnjEEVWPBIRVTVGJR4HDRpkdIe7d+8udjBERERERERkZiZOqyhBCwFqs4agnzuS8zsSEVU1Rs3xqNFo5JuTkxOOHj2Kc+fOydvPnz+Po0ePQqPRlFqgREREREREZDpTKh6B0hluzWpHIqKqyaiKx40bN8r358yZgyFDhuDrr7+GUqkEAOh0OkyYMIGrWhMREREREZUzpszxCACipIPSzDFwfkcioqpJkCTTLkNubm747bff0LBhQ4P2yMhIdOzYEY8ePTJrgCWVlJQEjUaDxMREJkaJiIhMwGsoEVHlkK3VITYhAQDgqlFDktKfuL9SYQMrlflGs4lSNjKz40x+npVKA6XCxmxxEBFR2TNqqHVeWq0WV65cKdB+5coViKJolqCIiIiIiIjIXEwredTPx2g+OjHDrP0REVHFYfKq1mPGjMHYsWMRFRUlr2R9+vRpLF68GGPGjDF7gERERERERFR8pg61liQtJEmEIJhcp1Ionchh1kREVZXJicclS5bA09MTS5cuRUxMDADAy8sLs2bNwjvvvGP2AImIiIiIiKj4TF1cBtDPyagUSj7MWZJESGauoCQioorDpMSjVqvF1q1bMXr0aMyePRtJSUkAwHmfiIiIiIiIyilTKx4B/XBrcywwY+5h20REVLGYVDuvUqnw1ltvISNDP0eHk5MTk45ERERERESVjLmqFCUp2yz9EBFRxWTypB3t27fHH3/8URqxEBERERERkdkVZ6i1zixHFpl4JCKq0kye43HChAl45513cPv2bbRp0wb29vYG25s3b2624IiIiIiIiKhkijPU2lwLzDDxSERUtQmSZNplSKEoeOERBAGSJEEQBOh05vlmzFySkpKg0WiQmJjIYeFEREQm4DWUiKhySMvMRHxyCgDAVaOGJKUb9TwrlTOUCutiH1eSdMjIfljs51upNFAqSr7ADRERWY7JFY/Xr18vjTiIiIiIiIioNBSj4hHIXWCm+IlHnZRV7OcSEVHlYHLisXbt2qURBxEREREREZUjJV0YRhQzzRQJERFVVCYnHgEgKioKK1asQEREBACgcePGmDp1KurVq2fW4IiIiIiIiKhkpGKWPOrELHlKLZOPKYnQiax4JCKq6kyeKfjw4cNo3Lgxzpw5g+bNm6N58+Y4ffo0mjRpgp9//rk0YiQiIiIiIqJiKs7iMjnPhFjM4dKipEWxx3gTEVGlYXLF49y5czF9+nQsXry4QPucOXPw4osvmi04IiIiIiIiKpniVjwCgE7MLNYCM5KkLfYxiYio8jC54jEiIgJjx44t0P7666/j8uXLZgmKiIiIiIiIzKQEhYclq3gkIqKqzuTEo5ubGy5evFig/eLFi3B3dzdHTERERERERFQOSJIOkiSa/DyxhAvTEBFR5WDyUOs33ngD48ePx7Vr19CxY0cAwIkTJ/DJJ59gxowZZg+QiIiIiIiIiq8kQ60BffJREIyvWdEvSsOKRyIiKkbicf78+XB0dMTSpUsxb948AECNGjUQFBSEKVOmmD1AIiIiIiIiKr7iLy6jJ0ILBdRG768V00p2QCIiqjQESTLuMnTs2DF06tQJVlZWcltycjIAwNHRsXSiM4OkpCRoNBokJibCycnJ0uEQERFVGLyGEhFVDompqUhJzwAAuGrUkKR0k56vUFjBWlXN6P3Ts2JhjhWtrVQaKBU2Je6HiIgsx+iKx+7du8PGxgYdOnRA165d0a1bNzz77LNQqUwumiQiIiIiIqIyUuKKRzELOjHDqCSgKOlgjqQjERFVDkZP1HH9+nV8+eWXqFWrFtavX4/nn38ezs7OCAgIwOLFi3H69GmIoumTDhMREREREVHpKekcjwCgEzONOxYXlSEiojyMHmqd37Vr1xAaGorQ0FCEhYXh9u3bcHR0REJCgplDLBkOEyMiIioeXkOJiCqH+JQUpGXoE4fFGWqtJ8BG7QZBEIrcQ5JEZOuSoRMzihmpIQ61JiKq+Io9Trpu3bpQKpUQBAGCIGDv3r3IysoyZ2xERERERERUQiUdap3TC3RiBlRK20K3ipIOmdkPzXEgIiKqRExKPEZHRyM0NBTHjh1DaGgoHj58iI4dO+L555/H/v378eyzz5ZWnERERERERGRBOjH9CYlHFqEQEVFBRice69ati/j4eHTq1AkvvPAC3nzzTbRt25aLyxAREREREZVjxZxdqwBR0ha9TeTcjkREVJDRi8ukp+vnAVEoFFCpVFCr1VAqlaUWGBEREREREZWc+daYliBK2kITmSIXlSEiokIYnXiMiYnByZMn0adPH5w+fRp9+/ZFtWrV8NJLL2HJkiU4e/YsV7UmIiIiIiIqb8xU8QjoE4zZumSIYjYkSf/5TydmQXpCNSQREVVdxV7VGgAiIiLk+R6PHDkCAFzVmoiIqJLgNZSIqHJ4mJiEzGx9RWLxV7XOJSC3hlKhsIIABUQpG5KkK3mg+XBVayKiis/oisf87t+/jz///BN//vknwsPDkZSUhMzMTJP6WL16NZo3bw4nJyc4OTnB398fBw8elLdnZGRg4sSJcHV1hYODAwYPHoz79+8XN2QiIiIiIqIqx3z1joa9iWIWdGJGqSQdiYiocjA68RgbG4sdO3ZgwoQJ8PPzQ40aNTB69GhcvnwZw4YNw//+9z+Tqx1r1qyJxYsX4/z58zh37hy6deuG/v374++//wYATJ8+HT/++CN27tyJsLAw3L17F4MGDTLpGERERERERFWZuRaXISIiMpXRQ60VCgXUajXatm2Lrl27omvXrujYsSNsbW3NGpCLiws+++wzvPzyy3Bzc8PWrVvx8ssvAwCuXLkCPz8/nDx5Eh06dDCqPw4TIyIiKh5eQ4mIKofYhERka/VzMJZ8qHXZ4VBrIqKKT2XsjgcPHsRzzz0He3v7UglEp9Nh586dSE1Nhb+/P86fP4/s7Gz06NFD3qdRo0aoVavWExOPmZmZBkO+k5KSSiVeIiKiyobXUCKiyokVj0REZClGD7UOCAgolaTjX3/9BQcHB1hbW+Ott97Cnj170LhxY9y7dw9WVlZwdnY22N/DwwP37t0rsr9FixZBo9HIN29vb7PHTEREVBnxGkpEREREROZU7MVlzKVhw4a4ePEiTp8+jbffflueN7K45s2bh8TERPl269YtM0ZLRERUefEaSkRUObHekYiILMXoodalxcrKCr6+vgCANm3a4OzZs1i5ciWGDh2KrKwsJCQkGFQ93r9/H56enkX2Z21tDWtr69IOm4iIqNLhNZSIqHLiUGsiIrIUi1c85ieKIjIzM9GmTRuo1WocPXpU3hYZGYno6Gj4+/tbMEIiIiIiIiIiIiJ6GotWPM6bNw+9e/dGrVq1kJycjK1btyI0NBSHDx+GRqPB2LFjMWPGDLi4uMDJyQmTJ0+Gv7+/0StaExERERERVXWseCQiIksxKvH4+eefG93hlClTjN43NjYWo0aNQkxMDDQaDZo3b47Dhw/jxRdfBAAsX74cCoUCgwcPRmZmJgICAvDVV18Z3T8REREREVFVx7QjERFZiiAZ8fVXnTp1DB4/ePAAaWlp8tyLCQkJsLOzg7u7O65du1YqgRZXUlISNBoNEhMT4eTkZOlwiIiIKgxeQ4mIKoc7j+KAnI99rho1JCndwhEZx0qlgVJhY+kwiIioBIya4/H69evy7aOPPkLLli0RERGBuLg4xMXFISIiAq1bt8YHH3xQ2vESERERERGRKTjUmoiILMSoise86tWrh++//x6tWrUyaD9//jxefvllXL9+3awBlhSrNYiIiIqH11AioopPkiTcfRQnP2bFIxERlSWTV7WOiYmBVqst0K7T6XD//n2zBEVEREREREQlx2JHIiKyJJMTj927d8ebb76JCxcuyG3nz5/H22+/jR49epg1OCIiIiIiIio+iUvLEBGRBZmceNywYQM8PT3Rtm1bWFtbw9raGu3bt4eHhwfWrVtXGjESERERERERERFRBaMy9Qlubm44cOAA/vnnH1y5cgUA0KhRIzRo0MDswREREREREVEJsOCRiIgsyOTEYy4fHx9IkoR69epBpSp2N0RERERERFRKONSaiIgsyeSh1mlpaRg7dizs7OzQpEkTREdHAwAmT56MxYsXmz1AIiIiIiIiKh4uLkNERJZkcuJx3rx5CA8PR2hoKGxsbOT2Hj16YPv27WYNjoiIiIiIiEqCmUciIrIck8dI7927F9u3b0eHDh0gCILc3qRJE0RFRZk1OCIiIiIiIiIiIqqYTK54fPDgAdzd3Qu0p6amGiQiiYiIiIiIyLI41JqobHTp0gXTpk174j4+Pj5YsWKF/FgQBOzdu7dU4woJCYGzs3OpHqM8HpvKD5MTj23btsVPP/0kP85NNq5btw7+/v7mi4yIiIiIiIhKhIvLEADcu3cPkydPRt26dWFtbQ1vb2/069cPR48etXRopSY0NBSCICAhIcHSoRQpJiYGvXv3Nlt/+RObADB06FD8888/ZjtGeTz2kzD5aXkmD7X++OOP0bt3b1y+fBlarRYrV67E5cuX8fvvvyMsLKw0YiQiIiIiIqJiYMUj3bhxA506dYKzszM+++wzNGvWDNnZ2Th8+DAmTpyIK1euWDrEKsvT07PUj2FrawtbW9tSP055OzaVHyZXPD733HO4ePEitFotmjVrhiNHjsDd3R0nT55EmzZtSiNGIiIiIiIiKhZmHqu6CRMmQBAEnDlzBoMHD0aDBg3QpEkTzJgxA6dOnZL3i46ORv/+/eHg4AAnJycMGTIE9+/fl7cHBQWhZcuW2LBhA2rVqgUHBwdMmDABOp0On376KTw9PeHu7o6PPvrI4PiCIGDNmjV46aWXYGdnBz8/P5w8eRJXr15Fly5dYG9vj44dOxZYM+KHH35A69atYWNjg7p16yI4OBhardag33Xr1mHgwIGws7ND/fr1sW/fPgD6ZGvXrl0BANWqVYMgCAgMDCz0/cmtiNu7dy/q168PGxsbBAQE4NatW/I+gYGBGDBggMHzpk2bhi5duhi0abVaTJo0CRqNBtWrV8f8+fMhPSH7n3+o9e3btzF8+HC4uLjA3t4ebdu2xenTpwEAUVFR6N+/Pzw8PODg4IB27drhl19+kZ/bpUsX3Lx5E9OnT4cgCPLo1MIq/lavXo169erBysoKDRs2xDfffFMgrqLe28IYe+zinkMJCQkYN24c3Nzc4OTkhG7duiE8PFzeHh4ejq5du8LR0RFOTk5o06YNzp07h9DQUIwZMwaJiYlyXEFBQQCAb775Bm3btoWjoyM8PT0xYsQIxMbGyn3mVswePnwYrVq1gq2tLbp164bY2FgcPHgQfn5+cHJywogRI5CWlmbwXkyaNMmk86CyMznxCAD16tXD2rVrcebMGVy+fBnffvstmjVrZu7YiIiIiIiIiKiY4uLicOjQIUycOBH29vYFtucmhURRRP/+/REXF4ewsDD8/PPPuHbtGoYOHWqwf1RUFA4ePIhDhw5h27ZtWL9+Pfr27Yvbt28jLCwMn3zyCd577z05WZbrgw8+wKhRo3Dx4kU0atQII0aMwJtvvol58+bh3LlzkCQJkyZNkvf/9ddfMWrUKEydOhWXL1/GmjVrEBISUiAhFRwcjCFDhuDPP/9Enz59MHLkSMTFxcHb2xu7du0CAERGRiImJgYrV64s8n1KS0vDRx99hM2bN+PEiRNISEjAsGHDTHqvAWDTpk1QqVQ4c+YMVq5ciWXLlmHdunVGPTclJQWdO3fGnTt3sG/fPoSHh2P27NkQRVHe3qdPHxw9ehR//PEHevXqhX79+iE6OhoAsHv3btSsWRMLFy5ETEwMYmJiCj3Onj17MHXqVLzzzju4dOkS3nzzTYwZMwbHjh0z2K+o97Ywxh4bKN459Morr8gJv/Pnz6N169bo3r27HM/IkSNRs2ZNnD17FufPn8fcuXOhVqvRsWNHrFixAk5OTnJcM2fOBABkZ2fjgw8+QHh4OPbu3YsbN24UmpwOCgrCF198gd9//x23bt3CkCFDsGLFCmzduhU//fQTjhw5glWrVhk852nnQVBQEHx8fIp8jyodyURdu3aVgoKCCrTHxcVJXbt2NbW7UpeYmCgBkBITEy0dChERUYXCaygRUcWXlpEp3X7wUL6lZyVKaZn3KsRNq0u39NtX4Z0+fVoCIO3evfuJ+x05ckRSKpVSdHS03Pb3339LAKQzZ85IkiRJCxYskOzs7KSkpCR5n4CAAMnHx0fS6XRyW8OGDaVFixbJjwFI7733nvz45MmTEgBp/fr1ctu2bdskGxsb+XH37t2ljz/+2CDGb775RvLy8iqy35SUFAmAdPDgQUmSJOnYsWMSACk+Pv6Jr33jxo0SAOnUqVNyW0REhARAOn36tCRJkjR69Gipf//+Bs+bOnWq1LlzZ/lx586dJT8/P0kURbltzpw5kp+fn/y4du3a0vLlyw1ew549eyRJkqQ1a9ZIjo6O0qNHj54Yb15NmjSRVq1aVWT/ua9Po9HIjzt27Ci98cYbBvu88sorUp8+fQzietJ7Wxhjjl2cc+jXX3+VnJycpIyMDIO+69WrJ61Zs0aSJElydHSUQkJCCo0rfwxFOXv2rARASk5OliTp8fnzyy+/yPssWrRIAiBFRUXJbW+++aYUEBAgPzbmPFi1apXUrVu3p8ZUWZhc8RgaGoovvvgCAwYMQGpqqtyelZXFOR6JiIiIiIjKES4uU7VJRg7vjIiIgLe3N7y9veW2xo0bw9nZGREREXKbj48PHB0d5cceHh5o3LgxFAqFQVveIasA0Lx5c4PtAAxGTXp4eCAjIwNJSUkA9ENnFy5cCAcHB/n2xhtvICYmxmBYa95+7e3t4eTkVODYxlCpVGjXrp38uFGjRgVeuzE6dOggDzMGAH9/f/z777/Q6XRPfe7FixfRqlUruLi4FLo9JSUFM2fOhJ+fH5ydneHg4ICIiAi54tFYERER6NSpk0Fbp06dCrxWc723+Zl6DoWHhyMlJQWurq4G58P169fl4fkzZszAuHHj0KNHDyxevLjAsP3CnD9/Hv369UOtWrXg6OiIzp07A0CB9zP/uWtnZ4e6desWGmuup50HkyZNqtQLO+Vn8uIyAPDLL7/gzTffRIcOHfDjjz9WrRJRIiIiIiKiioJ5xyqtfv36EATBbAvIqNVqg8eCIBTaljs8uLDn5SZkCmvLO6w4ODgYgwYNKhCDjY3NE+PJf2xzUCgUBZK42dnZZj3G0xZhmTlzJn7++WcsWbIEvr6+sLW1xcsvv4ysrCyzxpGrtN5bU8+hlJQUeHl5ITQ0tEBfuVMFBAUFYcSIEfjpp59w8OBBLFiwAN999x0GDhxYaAypqakICAhAQEAAtmzZAjc3N0RHRyMgIKDA+5n/PC2rc64yKdYcj15eXggLC0OzZs3Qrl27Qk8AIiIiIiIisixWPFZtLi4uCAgIwJdffmkwYjFXQkICAMDPzw+3bt0yWFDl8uXLSEhIQOPGjcsqXFnr1q0RGRkJX1/fAre8lXFPYmVlBQBGVRtqtVqcO3dOfhwZGYmEhAT4+fkBANzc3ArMW3jx4sUC/eSf2/LUqVOoX78+lErlU2No3rw5Ll68WOQ8iidOnEBgYCAGDhyIZs2awdPTEzdu3DDYx8rK6qmv18/PDydOnCjQd0n/n405dnG0bt0a9+7dg0qlKnAuVK9eXd6vQYMGmD59Oo4cOYJBgwZh48aNRcZ15coVPHr0CIsXL8bzzz+PRo0amaWaM1dJzoPKyOTEY+43EdbW1ti6dSumTp2KXr164auvvjJ7cERERERERERUfF9++SV0Oh3at2+PXbt24d9//0VERAQ+//xz+Pv7AwB69OiBZs2aYeTIkbhw4QLOnDmDUaNGoXPnzmjbtm2Zx/z+++9j8+bNCA4Oxt9//42IiAh89913eO+994zuo3bt2hAEAfv378eDBw+QkpJS5L5qtRqTJ0/G6dOncf78eQQGBqJDhw5o3749AKBbt244d+4cNm/ejH///RcLFizApUuXCvQTHR2NGTNmIDIyEtu2bcOqVaswdepUo+IdPnw4PD09MWDAAJw4cQLXrl3Drl27cPLkSQD66tXdu3fj4sWLCA8Px4gRIwpU2vn4+OD48eO4c+cOHj58WOhxZs2ahZCQEKxevRr//vsvli1bht27d8uLrhSXMccujh49esDf3x8DBgzAkSNHcOPGDfz+++949913ce7cOaSnp2PSpEkIDQ3FzZs3ceLECZw9e1ZOGvv4+CAlJQVHjx7Fw4cPkZaWhlq1asHKygqrVq3CtWvXsG/fPnzwwQdmi/lp58EXX3yB7t27m+145Z3Jicf85cXvvfcetmzZgqVLl5otKCIiIiIiIio5I6f4o0qsbt26uHDhArp27Yp33nkHTZs2xYsvvoijR49i9erVAPQFRj/88AOqVauGF154AT169EDdunWxfft2i8QcEBCA/fv348iRI2jXrh06dOiA5cuXo3bt2kb38cwzzyA4OBhz586Fh4eHwarZ+dnZ2WHOnDkYMWIEOnXqBAcHB4PXHhAQgPnz52P27Nlo164dkpOTMWrUqAL9jBo1Cunp6Wjfvj0mTpyIqVOnYvz48UbFa2VlhSNHjsDd3R19+vRBs2bNsHjxYrlKbtmyZahWrRo6duyIfv36ISAgAK1btzboY+HChbhx4wbq1asHNze3Qo8zYMAArFy5EkuWLEGTJk2wZs0abNy4EV26dDEqzqIYc+ziEAQBBw4cwAsvvIAxY8agQYMGGDZsGG7evAkPDw8olUo8evQIo0aNQoMGDTBkyBD07t0bwcHBAICOHTvirbfewtChQ+Hm5oZPP/0Ubm5uCAkJwc6dO9G4cWMsXrwYS5YsMVvMTzsPHj58aNQ8lJWFIBk722yOmzdvwtvbu0B586VLl3D+/HmMHj3arAGWVFJSEjQaDRITE+Hk5GTpcIiIiCoMXkOJiCq+5PR0JKXqF+OQJB2g+gsudo0hCMWadatMWak0UCpsnr4jUQmEhIRg2rRp8rBzopLo0qULWrZsiRUrVlg6lHLD5MVlivqGoWnTpmjatGmJAyIiIiIiIiIzySkzkSQRD9N2IS37T6RmtIK3S78KkXwkIqKKzajE46BBgxASEgInJ6dCV5XKa/fu3WYJjIiIiIiIiEomd3GZpMxfkZb9JwDgUeofECUdarv2hyBUzcUOiIiobBiVeNRoNPKiMhqNplQDIiIiIiIiIvPInVjL0fpZpGf/g0zdTQBAfNqfkCQtalcfBIVg8kA4okojMDAQgYGBlg6DKonQ0FBLh1DumDTHoyRJuHXrFtzc3GBra1uacZkN56ciIiIqHl5DiYgqvsTUNKSkpwMARCkLCZlbkJzxeFEDJ9sGqFN9SLlMPnKORyKiis+kST0kSYKvry9u375dWvEQERERERGR2TyuM1EIVqjnNgaONr5yW1L6P7j2YBtEMdsSwRERUSVnUuJRoVCgfv36ePToUWnFQ0RERERERGaSf3ybQqFGXbdh0Ng2lNuSM6IQ9WALdGJmGUdHRESVncnLmC1evBizZs3CpUuXSiMeIiIiIiIiKkUKQYU61YfA2a6J3JaSeQNRD76FTsywYGRERFTZmDTHIwBUq1YNaWlp0Gq1sLKyKjDXY1xcnFkDLCnOT0VERFQ8vIYSEVV88SkpSMt4XMnoqlFDkvRzPkqSDjcf/YD4tD/l7XZWNVDP7VWolHZlHmt+nOORiKjiM3kG4RUrVpRCGERERERERGRuTyozEQQlarsOgEJQ4VHqBQBAWtZdXI3dhHruo6BW2pdRlEREVFmZnHgcPXp0acRBREREREREZUwQFPB26QeFoMKDlDMAgPTs+7gaGwJf91FQKx0tHCFZSlBQEFavXo3Y2Fjs2bMHAwYMsHRIRFQBmTzHY14ZGRlISkoyuBEREREREVH5YMzMWoIg4JlqveHu2FFuy8h+gH/vb0SWNrE0wyMzCwwMhCAI8s3V1RW9evXCn3/++fQn5xEREYHg4GCsWbMGMTEx6N27dylFTOVdly5dMG3aNEuHQRWYyYnH1NRUTJo0Ce7u7rC3t0e1atUMbkRERERERFQ+GDuhvyAIqOH8IjydXpDbMrVx+Pf+RmRq40snOCoVvXr1QkxMDGJiYnD06FGoVCq89NJLJvURFRUFAOjfvz88PT1hbW1drFiys7OL9TwiqjxMTjzOnj0b//vf/7B69WpYW1tj3bp1CA4ORo0aNbB58+bSiJGIiIiIiIiKw4S1RAVBgJdzN3hpusltWboEffIx+1FpREelwNraGp6envD09ETLli0xd+5c3Lp1Cw8ePJD3uXXrFoYMGQJnZ2e4uLigf//+uHHjBgD9EOt+/foBABQKBQRBAACIooiFCxeiZs2asLa2RsuWLXHo0CG5zxs3bkAQBGzfvh2dO3eGjY0NtmzZAgBYt24d/Pz8YGNjg0aNGuGrr7564ms4dOgQnnvuOTg7O8PV1RUvvfSSnAzNe6zdu3eja9eusLOzQ4sWLXDy5El5n5CQEDg7O+Pw4cPw8/ODg4ODnJTN9bTXFBoaCkEQkJCQILddvHgRgiDI75cxxwGADRs2oEmTJrC2toaXlxcmTZokb0tISMC4cePg5uYGJycndOvWDeHh4fL2oKAgtGzZEhs2bECtWrXg4OCACRMmQKfT4dNPP4Wnpyfc3d3x0UcfGRzT2H6/+eYb+Pj4QKPRYNiwYUhOTgagr6ANCwvDypUr5Sra3NdNZCyTE48//vgjvvrqKwwePBgqlQrPP/883nvvPXz88cfyLxUiIiIiIiKqmDw1L+AZ5wD5cbYuCf/EbkRG9oMnPKtykyQJySmZFrsZM2S+MCkpKfj222/h6+sLV1dXAPoqxICAADg6OuLXX3/FiRMn5GRZVlYWZs6ciY0bNwKAXDkJACtXrsTSpUuxZMkS/PnnnwgICMB//vMf/PvvvwbHnDt3LqZOnYqIiAgEBARgy5YteP/99/HRRx8hIiICH3/8MebPn49NmzYVGXdqaipmzJiBc+fO4ejRo1AoFBg4cCBEUTTY791338XMmTNx8eJFNGjQAMOHD4dWq5W3p6WlYcmSJfjmm29w/PhxREdHY+bMmfJ2Y1/T0zztOKtXr8bEiRMxfvx4/PXXX9i3bx98fX3l7a+88gpiY2Nx8OBBnD9/Hq1bt0b37t0RFxcn7xMVFYWDBw/i0KFD2LZtG9avX4++ffvi9u3bCAsLwyeffIL33nsPp0+fNrnfvXv3Yv/+/di/fz/CwsKwePFi+f3x9/fHG2+8IZ8L3t7eJr03RCYvLhMXF4e6desCAJycnOQT9rnnnsPbb79t3uiIiIiIiIio2IqXrgLcnfwhCErcjj8AANDqUvDv/Y3wdR8FWytP8wVYQaSkZqHzwG8tdvywPa/C0cG44c779++Hg4MDAH0Cz8vLC/v374dCoa872r59O0RRxLp16+Rqxo0bN8LZ2RmhoaHo2bMnnJ2dAQCeno//r5csWYI5c+Zg2LBhAIBPPvkEx44dw4oVK/Dll1/K+02bNg2DBg2SHy9YsABLly6V2+rUqYPLly9jzZo1RS5eO3jwYIPHGzZsgJubGy5fvoymTZvK7TNnzkTfvn0BAMHBwWjSpAmuXr2KRo0aAdAnWb/++mvUq1cPADBp0iQsXLjQ5Nf0NE87zocffoh33nkHU6dOldvatWsHAPjtt99w5swZxMbGykPalyxZgr179+L777/H+PHjAeirMzds2ABHR0c0btwYXbt2RWRkJA4cOACFQoGGDRvK8T/77LMm9RsSEgJHR/1CUq+99hqOHj2Kjz76CBqNBlZWVrCzszM4F4hMYXLFY926dXH9+nUAQKNGjbBjxw4A+krI3F9OREREREREZHnFrZQDADfH9qjl8h/5sVZMw7+xm5CWecccoVEp6dq1Ky5evIiLFy/izJkzCAgIQO/evXHz5k0AQHh4OK5evQpHR0c4ODjAwcEBLi4uyMjIMBjOnFdSUhLu3r2LTp06GbR36tQJERERBm1t27aV76empiIqKgpjx46Vj+Xg4IAPP/ywyGMBwL///ovhw4ejbt26cHJygo+PDwAgOjraYL/mzZvL9728vAAAsbGxcpudnZ2cDMzdJ3e7Ka/paZ50nNjYWNy9exfdu3cv9Lnh4eFISUmBq6urwXt0/fp1g/fIx8dHTg4CgIeHBxo3biwnlHPbco9b3H7zxk5kDiZXPI4ZMwbh4eHo3Lkz5s6di379+uGLL75AdnY2li1bVhoxEhERERERkQW4OrSGIKhw89EeABJ0Yjr+jd0MX/dXYW/NIZflkb29vcEw3nXr1kGj0WDt2rX48MMPkZKSgjZt2hQ6VZqbm5tZjp8rJSUFALB27Vo8++yzBvsplcoi++jXrx9q166NtWvXokaNGhBFEU2bNkVWVpbBfmq1Wr6fdy7Kwrbn7mNKMj43qZf3OYUtmPOk49ja2j7xGCkpKfDy8kJoaGiBbXmLuwo7RmFtua+/JP3mH9JOVBImJx6nT58u3+/RoweuXLmC8+fPw9fX1+DbBiIiIiIiIrKsklQ85nKxbw5BUOLGw10ARIhSJq7GbkZdt5FwtPEpcf8VgYO9FcL2vGrR4xeXIAhQKBRIT08HALRu3Rrbt2+Hu7s7nJycjOrDyckJNWrUwIkTJ9C5c2e5/cSJE2jfvn2Rz/Pw8ECNGjVw7do1jBw50qhjPXr0CJGRkVi7di2ef/55APrhyOZmzGvKTcTGxMSgWrVqAPSLy5jC0dERPj4+OHr0KLp27Vpge+vWrXHv3j2oVCq5stMczNWvlZUVdDqd2eKiqsfkxGN+tWvXRu3atc0RCxEREREREZlRydOOetXsmkBRXYXrD3dAgg6ilI2oB9+ibvXhcLKt9/QOKjhBEIyeY9HSMjMzce/ePQBAfHw8vvjiC6SkpMgrVY8cORKfffYZ+vfvL6/ofPPmTezevRuzZ89GzZo1C+131qxZWLBgAerVq4eWLVti48aNuHjx4lMXmQ0ODsaUKVOg0WjQq1cvZGZm4ty5c4iPj8eMGTMK7F+tWjW4urriv//9L7y8vBAdHY25c+eW8F0p3NNek6+vL7y9vREUFISPPvoI//zzD5YuXWrycYKCgvDWW2/B3d0dvXv3RnJyMk6cOIHJkyejR48e8Pf3x4ABA/Dpp5+iQYMGuHv3Ln766ScMHDjQYOi6KczVr4+PD06fPo0bN27Iw/LzDu8mehqjEo+ff/650R1OmTKl2MEQERERERGR+Zij4jGXxq4h6roNx7WH30GStJAkLa492Io6bkOhsW1gtuNQyRw6dEie79DR0RGNGjXCzp070aVLFwD6+QiPHz+OOXPmYNCgQUhOTsYzzzyD7t27P7ECcsqUKUhMTMQ777yD2NhYNG7cGPv27UP9+vWfGM+4ceNgZ2eHzz77DLNmzYK9vT2aNWuGadOmFbq/QqHAd999hylTpqBp06Zo2LAhPv/8czl+c3raa1Kr1di2bRvefvttNG/eHO3atcOHH36IV155xaTjjB49GhkZGVi+fDlmzpyJ6tWr4+WXXwagT2ofOHAA7777LsaMGYMHDx7A09MTL7zwAjw8PIr92szV78yZMzF69Gg0btwY6enpuH79ulkrM6nyEyQjrkR16tQxrjNBwLVr10oclDklJSVBo9EgMTHR6DJyIiIi4jWUiKgyiImLN5ivzVWjhiSll6jP5IzruPZgK0RJP9edAAV8qr8MZ7vGJeo3PyuVBkqFjVn7JCKismVUxWPuKtZERERERERUtTna1EE999cQFbsFopQJCSKuP9wJH9dBqGbfzNLhERFROVKigfmSJJm1dJ+IiIiIiIjMp7Q+rzlY14Kv+6g8FYkSbjzajUcpf5TK8YiIqGIqVuJx8+bNaNasGWxtbWFra4vmzZvjm2++MXdsREREREREVAKlWSZib/0MfN1HQ6Wwk48WHfcDHiafK8WjEhFRRWJy4nHZsmV4++230adPH+zYsQM7duxAr1698NZbb2H58uWlESMREREREREVRymPULOz8oKvRyBUCge57Vb8fsQmnSrV4xIRUcVg1OIyedWpUwfBwcEYNWqUQfumTZsQFBRU7uaD5MT4RERExcNrKBFRxXfn4SODx+ZYXKYwGdkPcTV2M7J1SXJbDece8HB6rth9cnEZIqKKz+SKx5iYGHTs2LFAe8eOHRETE2OWoIiIiIiIiKhkynI+fht1ddT3GAMrpbPcdjfhF8QkHOO6AEREVZjJiUdfX1/s2LGjQPv27dtRv359swRFRET0JPwAQ0RE9HRlfbm0VlVDfY8xsFa5yG33ksJwN/EXXruJiKoolalPCA4OxtChQ3H8+HF06tQJAHDixAkcPXq00IQkERGRuYmiBKVSsHQYRERE5ZpUqkvLFM5KpUF9jzG4en8TMrQPAQCxSScgSVo849wLgsDrNxFRVWJyxePgwYNx5swZVK9eHXv37sXevXtRvXp1nDlzBgMHDiyNGImIiAzoRNHSIRAREZV/FioyVCsd4esRCBu1h9z2IPk0bsXvhyTxGk5EVJWYlHhMSkrCzz//jJiYGCxfvhznz5/H+fPn8e2336JVq1alFSMREZEBJh6JiIjKN7XSAfXdR8PWyktue5RyHtFx+5h8tDBJkjB+/Hi4uLhAEARcvHjR0iFRBRAYGIgBAwaUuJ8TJ06gWbNmUKvVZumvpEJCQuDs7GzWPm/cuMGfrTyMTjxevHgRjRo1Qq9evdCvXz/4+vri8OHDpRkbERFRAZIkcZ4oIiIiI1hiqHVeKqUdfN1Hwd6qptwWl3oRNx/thiTpLBhZ5Xfy5EkolUr07du3wLZDhw4hJCQE+/fvR0xMDJo2bQpBELB3796yD5TKnI+PD1asWGGx48+YMQMtW7bE9evXERISYrE4yHhdunTBtGnTiv18oxOPc+bMQZ06dfDbb7/h/Pnz6N69OyZNmlTsAxMRERWHKEoW/yBFRERUEZSH7+lUClvUc38NDta15bb4tEu4/nAnRElrwcgqt/Xr12Py5Mk4fvw47t69a7AtKioKXl5e6NixIzw9PaFSmbz0Q5Gys7PN1hdVTlFRUejWrRtq1qxZ7ErDrKws8wZFpcroxOP58+exatUq+Pv7o1WrVtiwYQOioqKQlJRUmvEREREZEDk8i4iIyEjlIPMIQKmwRj23kXC0qSu3JaZfwfUH2yFKTFSZW0pKCrZv3463334bffv2NagqCwwMxOTJkxEdHQ1BEODj4wMfHx8AwMCBA+W2XD/88ANat24NGxsb1K1bF8HBwdBqHyeMBUHA6tWr8Z///Af29vb46KOPCo3pm2++Qdu2beHo6AhPT0+MGDECsbGx8vbQ0FAIgoCjR4+ibdu2sLOzQ8eOHREZGSnvExQUhJYtW+Kbb76Bj48PNBoNhg0bhuTkZHmfzMxMTJkyBe7u7rCxscFzzz2Hs2fPytsLG1a7d+9eg0WPjDmOKIr49NNP4evrC2tra9SqVcvgtd+6dQtDhgyBs7MzXFxc0L9/f9y4ccPg/2HAgAH4+OOP4eHhAWdnZyxcuBBarRazZs2Ci4sLatasiY0bNxrEamy/S5YsgZeXF1xdXTFx4kQ5IdylSxfcvHkT06dPhyAIxVrsKTg4GG5ubnBycsJbb71lkAQURRGLFi1CnTp1YGtrixYtWuD7778H8Hj48aNHj/D6669DEAT53AwLC0P79u1hbW0NLy8vzJ071+A869KlCyZNmoRp06ahevXqCAgIAABcunQJvXv3hoODAzw8PPDaa6/h4cOHT4w/JCQEtWrVgp2dHQYOHIhHjx4V2MfY8753796wtbVF3bp15ddZlCe9xs2bN8PV1RWZmZkGzxkwYABee+01AI/Pyw0bNqBWrVpwcHDAhAkToNPp8Omnn8LT0xPu7u4FfgYTEhIwbtw4+f+sW7duCA8Pl7c/7XwPDAxEWFgYVq5cKZ8zec85YxideIyLi0PNmo9L5J2dnWFvb1/ofxIREVFp0Ynl40MUERERGU+hsEJdt+FwsmkgtyVl/ItrD7ZBFMt/9ZIkSUhJz7DYzZRpZnbs2IFGjRqhYcOGePXVV7Fhwwb5+StXrsTChQtRs2ZNxMTE4OzZs3JibuPGjXIbAPz6668YNWoUpk6disuXL2PNmjUICQkpkNgICgrCwIED8ddff+H1118vNKbs7Gx88MEHCA8Px969e3Hjxg0EBgYW2O/dd9/F0qVLce7cOahUqgL9RUVFYe/evdi/fz/279+PsLAwLF68WN4+e/Zs7Nq1C5s2bcKFCxfg6+uLgIAAxMXFGf3+GXOcefPmYfHixZg/fz4uX76MrVu3wsPDQ36tAQEBcHR0xK+//ooTJ07AwcEBvXr1MkjS/e9//8Pdu3dx/PhxLFu2DAsWLMBLL72EatWq4fTp03jrrbfw5ptv4vbt2yb1e+zYMURFReHYsWPYtGkTQkJC5ATf7t27UbNmTSxcuBAxMTGIiYkx6X05evQoIiIiEBoaim3btmH37t0IDg6Wty9atAibN2/G119/jb///hvTp0/Hq6++irCwMHh7eyMmJgZOTk5YsWIFYmJiMHToUNy5cwd9+vRBu3btEB4ejtWrV2P9+vX48MMPDY69adMmWFlZ4cSJE/j666+RkJCAbt26oVWrVjh37hwOHTqE+/fvY8iQIUXGf/r0aYwdOxaTJk3CxYsX0bVr1wLHMfa8nz9/PgYPHozw8HCMHDkSw4YNQ0RERKHHfdprfOWVV6DT6bBv3z75ObGxsfjpp58MfgaioqJw8OBBHDp0CNu2bcP69evRt29f3L59G2FhYfjkk0/w3nvv4fTp0/JzXnnlFcTGxuLgwYM4f/48Wrduje7duxv8TDzpfF+5ciX8/f3xxhtvyOeMt7d3ke9xYQTJyN9gCoUC//vf/+Di4iK3dezYETt27DBISDZv3tykAEpbUlISNBoNEhMT4eTkZOlwiIiohNIyMiFBgr2NjaVDqfR4DSUiqtiysrV4kJho0OaqUUOS0i0UESBKWtx4uAuJ6Y8/oDtY10ZdtxFQKqwN9rVSaaBUlI/rfUp6BoZ+vMxix9/+fzPgYGvce9GpUycMGTIEU6dOhVarhZeXF3bu3IkuXboAAFasWIEVK1YYVC0JgoA9e/YYLPbRo0cPdO/eHfPmzZPbvv32W8yePVsevi0IAqZNm4bly5eb9HrOnTuHdu3aITk5GQ4ODggNDUXXrl3xyy+/oHv37gCAAwcOoG/fvkhPT4eNjQ2CgoLw2Wef4d69e3B0dASgTzQeP34cp06dQmpqKqpVq4aQkBCMGDECgD5Z5+Pjg2nTpmHWrFkICQnBtGnTkJCQIMeyd+9eDBw4UE7OPu04ycnJcHNzwxdffIFx48YVeG3ffvstPvzwQ0RERMgVhVlZWXB2dsbevXvRs2dPBAYGIjQ0FNeuXYNCoa8Ha9SoEdzd3XH8+HEAgE6ng0ajwbp16zBs2DCT+o2KioJSqQQADBkyBAqFAt999x0AyO+HqXP2BQYG4scff8StW7dgZ2cHAPj6668xa9YsJCYmIjs7Gy4uLvjll1/g7+8vP2/cuHFIS0vD1q1bAeiL2FasWCEnnt99913s2rXL4HV99dVXmDNnDhITE6FQKNClSxckJSXhwoULcr8ffvghfv31V4O1R27fvg1vb29ERkaiQYPHX3LkGjFiBBITE/HTTz/JbcOGDcOhQ4fkc8LY8/6tt97C6tWr5X06dOiA1q1b46uvvsKNGzdQp04d/PHHH2jZsqVRr3HChAm4ceMGDhw4AABYtmwZvvzyS1y9ehWCIBR6Xvbq1QuRkZGIiooyOI8CAwMxd+5c/Pbbb+jbty9iY2Nhbf3496uvry9mz56N8ePHP/V8B/QVpy1btiz23KAmTebQvXv3At+0vPTSSxAEAZIkQRAE6HScJJiIiEqPThShUJg+LISIiKiqKY9zIisEFepUfxk3H+1BfNolAEBK5k1cjf0G9dxHQqWwtXCEFVtkZCTOnDmDPXv2AABUKhWGDh2K9evXy4lHY4WHh+PEiRMGlV46nQ4ZGRlIS0uTk09t27Z9al/nz59HUFAQwsPDER8fD1HUT50THR2Nxo0by/vlLWTy8tKviB4bG4tatWoB0CfNcpMjufvkDtmOiopCdnY2OnXqJG9Xq9Vo3759kZVoRXnScSIiIpCZmSknSPMLDw/H1atXDZ4PABkZGYiKipIfN2nSRE4WAYCHhweaNm0qP1YqlXB1dZWPa0q/uUnH3Nj/+usvo1/7k7Ro0UL+fwcAf39/pKSk4NatW0hJSUFaWhpefPFFg+dkZWWhVatWRfYZEREBf39/g2HfnTp1QkpKCm7fvi3/37dp08bgeeHh4Th27BgcHBwK9BkVFVVo4jEiIgIDBw40aPP398ehQ4cM+jXmvM+bXM19XNQq1sa8xjfeeAPt2rXDnTt38MwzzyAkJASBgYEGz8l/Xnp4eECpVBY4j/KeMykpKXB1dTWIJz093eCcedL5bg5GJx6vX79utoMSEREVlyiJUED59B2JiIioXBIEJWq7DoIgqBCXehEAkJZ1G1fvb4av+2tQKe2e3AEVaf369dBqtahRo4bcJkkSrK2t8cUXX0Cj0RjdV0pKCoKDgzFo0KAC22zyjDyxt7d/Yj+pqakICAhAQEAAtmzZAjc3N0RHRyMgIKDAIiFqtVq+n5twyU1S5t+eu0/e7U+jUCgKFFMVtiDOk45ja/vk5HhKSgratGmDLVu2FNjm5ub2xGM86bgl6deU96i4UlJSAAA//fQTnnnmGYNteavtiiv/eZaSkoJ+/frhk08+KbBvbtK6OIw9782tVatWaNGiBTZv3oyePXvi77//NqjMBIp3znh5eSE0NLTA8fLOdVra54zRicfatWs/fSciIqJSphMlqJh3JCIieqrysKp1UQRBgVou/4FCUOFhyjkAQHp2DP6NDYGv+yiolQWrmCzJ3sYa2/9vhkWP/zRarRabN2/G0qVL0bNnT4NtAwYMwLZt2/DWW28V+ly1Wl1g9GLr1q0RGRkJX1/f4gcO4MqVK3j06BEWL14szw137ty5EvVZmHr16slzAObmL7Kzs3H27Fl5WLGbmxuSk5ORmpoqJ7KKqlIrSv369WFra4ujR48WOtS6devW2L59O9zd3c06VY25+rWysir2SNXw8HCkp6fLyddTp07BwcEB3t7ecHFxgbW1NaKjo9G5c2ej+/Tz88OuXbvkUbQAcOLECTg6OhpM65df69atsWvXLvj4+Bi9Mrufn5/B/Ie5ryF/v8ac96dOncKoUaMMHhdV2Wnsaxw3bhxWrFiBO3fuoEePHibPpZhf69atce/ePahUKoNFo0xVknMGMGFxmdKwaNEitGvXDo6OjnB3d8eAAQMMVq0C9GXDEydOhKurKxwcHDB48GDcv3/fQhETEZGl6crgG1siIqLKoRxnHqFPPtas1hdujh3ktozsWPx7PwTZ2iQLRlaQIAhwsLWx2M2Y1Yf379+P+Ph4jB07Fk2bNjW4DR48GOvXry/yuT4+Pjh69Cju3buH+Ph4AMD777+PzZs3Izg4GH///TciIiLw3Xff4b333jPpvatVqxasrKywatUqXLt2Dfv27cMHH3xgUh/GsLe3x9tvv41Zs2bh0KFDuHz5Mt544w2kpaVh7NixAIBnn30WdnZ2+L//+z9ERUVh69atBqt+G8PGxgZz5szB7NmzsXnzZkRFReHUqVPy+zty5EhUr14d/fv3x6+//orr168jNDQUU6ZMkReKKQ5z9evj44Pjx4/jzp07T10BOr+srCyMHTsWly9fxoEDB7BgwQJMmjQJCoUCjo6OmDlzJqZPn45NmzYhKioKFy5cwKpVq7Bp06Yi+5wwYQJu3bqFyZMn48qVK/jhhx+wYMECzJgxw2AIcX4TJ05EXFwchg8fjrNnzyIqKgqHDx/GmDFjikySTZkyBYcOHcKSJUvw77//4osvvjAYZg0Yf97v3LkTGzZswD///IMFCxbgzJkzmDRpUole44gRI3D79m2sXbu2yIWaTNGjRw/4+/tjwIABOHLkCG7cuIHff/8d7777rknJfx8fH5w+fRo3btzAw4cPTa6GtGjiMSwsDBMnTsSpU6fw888/Izs7Gz179kRqaqq8z/Tp0/Hjjz9i586dCAsLw927dwsteSUioqqhLIaKmJskSZCkihc3ERFVbOW54jGXIAh4xjkAHk7PyW2Z2of4NzYEmdp4C0ZW8axfvx49evQodDj14MGDce7cOfz555+FPnfp0qX4+eef4e3tLVdtBQQEYP/+/Thy5AjatWuHDh06YPny5SaPhnRzc0NISAh27tyJxo0bY/HixViyZInpL9AIixcvxuDBg/Haa6+hdevWuHr1Kg4fPoxq1aoBAFxcXPDtt9/iwIEDaNasGbZt24agoCCTjzN//ny88847eP/99+Hn54ehQ4fKc+LZ2dnh+PHjqFWrFgYNGgQ/Pz+MHTsWGRkZJapUNFe/CxcuxI0bN1CvXj2DIdqCIDw1Cdu9e3fUr18fL7zwAoYOHYr//Oc/Bu/fBx98gPnz52PRokXw8/NDr1698NNPP6FOnTpF9vnMM8/gwIEDOHPmDFq0aIG33noLY8eOfWqCu0aNGjhx4gR0Oh169uyJZs2aYdq0aXB2di4yYdmhQwesXbsWK1euRIsWLXDkyJECxzH2vA8ODsZ3332H5s2bY/Pmzdi2bZvBfKXFeY0ajQaDBw+Gg4ODwUJPxSUIAg4cOIAXXngBY8aMQYMGDTBs2DDcvHlTXoXdGDNnzoRSqUTjxo3lqRJMisPYVa3LwoMHD+Du7o6wsDC88MILSExMhJubG7Zu3YqXX34ZgL5M28/PDydPnkSHDh2e0iNX5CQiqmzuPoqDxt6uwqxqLUo6ZGsToVY5QSGYtKabxfEaSkRUsaVlZiI+OcWgzdKrWhdFkiTcSwrDvcRQuc1KVQ1Nn5kOG7Vb0U8kohK7fv06GjRogMuXL6N+/fqWDqfcK2wVeHPp3r07mjRpgs8//9zsfVuKURWP+/btK3TCVXNLTEwEoP8WAtCvfJWdnY0ePXrI+zRq1Ai1atXCyZMnSz0eIiIqX/SVg+Xm+7Kn0omZyNLGQZRK/xpKRERUkQmCAC9NF9RwfvzZL0sbj0u3lyE9i1NtEZWmAwcOYPz48Uw6WlB8fDz27NmD0NBQTJw40dLhmJVRpRcDBw7EvXv34ObmBqVSiZiYGLi7u5s1EFEUMW3aNHTq1EleQv7evXuwsrIyWG0H0C8Pfu/evUL7yczMRGZmpvw4Kal8zQ1CRETFV5Hmd8zWJUOrS7N0GCbhNZSIqJKpON/VyTycnoMgqHAnPmfeNUGAIHBVOaLSVNkSXRVRq1atEB8fj08++QQNGza0dDhmZVTi0c3NDadOnUK/fv0MVuExp4kTJ+LSpUv47bffStTPokWLEBwcbKaoiIioPKkoiccsbSJ0YoalwzAZr6FERJWLVBEzjwDcHTtAIahwL/FXNKkxDTbq6pYOiYhIVhojsG7cuGH2PssLo4Zav/XWW+jfvz+USiUEQYCnpyeUSmWht+KYNGkS9u/fj2PHjhksJe7p6YmsrCwkJCQY7H///n14enoW2te8efOQmJgo327dulWsmIiIqPwRxfL/AaqiJh0BXkOJiCqbCjQ7SQHVHdqihfdc2FqZd6QdERGVLaMqHoOCgjBs2DBcvXoV//nPf7Bx48YCw5+LQ5IkTJ48WR7Hnn+lozZt2kCtVuPo0aMYPHgwACAyMhLR0dHw9/cvtE9ra2tYW1uXODYiIip/ynPFoySJyNIlQhSzLB1KsfEaSkRUuVTUisdcSkXFWEiOiIiKZvTymo0aNUKjRo2wYMECvPLKK7CzsyvxwSdOnIitW7fihx9+gKOjozxvo0ajga2tLTQaDcaOHYsZM2bAxcUFTk5OmDx5Mvz9/Y1a0ZqIiCqX8pp4lCQRWdoELiJDRERERESUhyAVc3D6gwcPEBkZCQBo2LAh3NzcTD94EXNFbty4EYGBgQCAjIwMvPPOO9i2bRsyMzMREBCAr776qsih1vklJSVBo9EgMTERTk5OJsdIRETlR3xKCtIyMuHsYA97m/JRBSFKOmRpEyBJ2ifuZ612hUIw+vu+coHXUCKiii05LR1JaYYLnblq1JCkdAtFZBorlYZVj0REFZzJice0tDRMmjQJ33zzDXQ6HQBAqVRi1KhRWLVqlVkqIc2JH5qIiCqP2MQkbDkahppurqjt7o6WdX1gpbZcMk+UsnOSjk+vxGTikYiIylpSWhqS0wyTjEw8EhFRWTJqcZm8pk+fjrCwMOzbtw8JCQlISEjADz/8gLCwMLzzzjulESMREREAID4pGb/88RdCjoQi+Nsd0Io6i8UiisYnHYmIiCyhIi8uQ0RElYPJicddu3Zh/fr16N27N5ycnODk5IQ+ffpg7dq1+P7770sjRiIiIgBATHyCfN/Z3g52FloIRatLRaY2nklHIiIq55h5pIIkScL48ePh4uICQRBw8eJFi8Th4+ODFStWmLXPwMBADBgwwKx9ElHJmJx4TEtLg4eHR4F2d3d3pOWbP4SIiMic7udJPHq6VCvz4+sXkUlEti4F/DBHRERE5dXJkyehVCrRt2/fAtsOHTqEkJAQ7N+/HzExMWjatCkEQcDevXvLPlAqUmhoKARBQEJCgqVDISoRkxOP/v7+WLBgATIyMuS29PR0BAcHw9/f36zBERER5dLpRDxISJQfe5Vx4lGUspGpjYdOzHj6zmR2Wp2Ih3FpSErOREamFsVcG4+IqErhr8qqa/369Zg8eTKOHz+Ou3fvGmyLioqCl5cXOnbsCE9PT6hU5puDOjs722x9EVHlYHLiceXKlThx4gRq1qyJ7t27o3v37vD29sbvv/+OlStXlkaMREREECURDxKT5MdeLs5lclx9lWMSMrPjnrpyNZUeSQJS07IRn5iB+w9SEX0nCXdikvHgYSoSkjKQmpaF7GwdE5JERHlIrM43G0mSoNWlWexmyvUtJSUF27dvx9tvv42+ffsiJCRE3hYYGIjJkycjOjoagiDAx8cHPj4+AICBAwfKbbl++OEHtG7dGjY2Nqhbty6Cg4Oh1T7+e0gQBKxevRr/+c9/YG9vj48++qjQmGJjY9GvXz/Y2tqiTp062LJlS4F9EhISMG7cOLi5ucHJyQndunVDeHi4vD0oKAgtW7bEmjVr4O3tDTs7OwwZMgSJiYkF+sqVmZmJKVOmwN3dHTY2Nnjuuedw9uxZAPr/U19fXyxZssTgORcvXoQgCLh69ar8GtesWYOXXnoJdnZ28PPzw8mTJ3H16lV06dIF9vb26NixI6Kiogz6Mea9W7duHQYOHAg7OzvUr18f+/btAwDcuHEDXbt2BQBUq1YNgiAgMDCwyNdJVJ6Z/NVG06ZN8e+//2LLli24cuUKAGD48OEYOXIkbG1tzR4gERERAOjE/IlHl1I/plaXDq2YwrkcyymtToRWJwIZef6IB6BSKaBUKqBSKaBSKqBUCvr7OY+JiKoKfhdjPjoxHWeuW24x1fZ1lkKltDNq3x07dqBRo0Zo2LAhXn31VUybNg3z5s2DIAhYuXIl6tWrh//+9784e/YslEolAP3UaRs3bkSvXr3ktl9//RWjRo3C559/jueffx5RUVEYP348AGDBggXy8YKCgrB48WKsWLGiyOrJwMBA3L17F8eOHYNarcaUKVMQGxtrsM8rr7wCW1tbHDx4EBqNBmvWrEH37t3xzz//wCXn776rV69ix44d+PHHH5GUlISxY8diwoQJhSYyAWD27NnYtWsXNm3ahNq1a+PTTz9FQEAArl69ChcXF7z++uvYuHEjZs6cKT9n48aNeOGFF+Dr6yu3ffDBB1i2bBmWLVuGOXPmYMSIEahbty7mzZuHWrVq4fXXX8ekSZNw8OBBk9674OBgfPrpp/jss8+watUqjBw5Ejdv3oS3tzd27dqFwYMHIzIyEk5OTsy3UIVVrJpqOzs7vPHGG+aOhYiIqEhanQ6xCWVT8agTs6DVpUCUSj5cSCdmIiHtMuLT/oKP62A42tY1Q4RUFAlAtlZEtlYEMgtuFwQBarUCapUCapVSf1+thFrFhCQREVUO69evx6uvvgoA6NWrFxITExEWFoYuXbpAo9HA0dERSqUSnp6eBs9zdnY2aAsODsbcuXMxevRoAEDdunXxwQcfYPbs2QbJsxEjRmDMmDFFxvPPP//g4MGDOHPmDNq1ayfH6OfnJ+/z22+/4cyZM4iNjYV1zuKBS5Yswd69e/H999/LSbuMjAxs3rwZzzzzDABg1apV6Nu3L5YuXVrg9aSmpmL16tUICQlB7969AQBr167Fzz//jPXr12PWrFkIDAzE+++/jzNnzqB9+/bIzs7G1q1bC1RBjhkzBkOGDAEAzJkzB/7+/pg/fz4CAgIAAFOnTjV4D4x97wIDAzF8+HAAwMcff4zPP/8cZ86cQa9eveRkq7u7O5ydnYt8f4nKO/NN5kBERFSKElPTkJ6VJT8ujTkeRSkb2drkEiccJUlCWtZtPEr5A/FplyBK+rjvJ//OxKOFSZKErCwdsrJ0AB7/P+cmJK3VSqitlPp/1QoIgmC5YImISojTT1Q9kZGROHPmDPbs2QMAUKlUGDp0KNavX48uXbqY1Fd4eDhOnDhhMHxap9MhIyMDaWlpsLPTV2C2bdv2if1ERERApVKhTZs2clujRo0Mkmnh4eFISUmBq6urwXPT09MNhjDXqlVLTjoC+jUoRFFEZGRkgcRjVFQUsrOz0alTJ7lNrVajffv2iIiIAADUqFEDffv2xYYNG9C+fXv8+OOPyMzMxCuvvGLQV/PmzeX7uYvtNmvWzKAtIyMDSUlJcHJyMvq9y9uvvb09nJycClSCElV0TDwSEVGFcDcuXr5va2UFjb1xw42MIUpaaHWpJV44JluXivjUP/Eo9QIysh8U2P4w+RzqVH8FSoV1iY5D5meQkEzVtwkArKyUsLZSQq1+/C8RUUXBtKP5KBW2aF9nqUWPb4z169dDq9WiRo0acpskSbC2tsYXX3wBjUZj9DFTUlIQHByMQYMGFdhmY2Mj37e3tze6zycdy8vLC6GhoQW2lXa137hx4/Daa69h+fLl2LhxI4YOHSonBnOp1Wr5fu6XkoW1iaJ+eh5j37u8feT2k9sHUWXBxCMREVmMfqJ2CTqdCJ1OhEIQYGurLnTfe3EJ8n2PapoSVaKJUjYkSYIkZUMnZUEUs57+pCJIkoikjCjEpVxAYnokJBT8Y1EpWMPVsR08nZ6DQrAq9rGobEkAMrN0yMzSyW0CAEEhQKkUoFQ8nj9Sqcwdvq2/T0RULrDi0WwEQTB6jkVL0Wq12Lx5M5YuXYqePXsabBswYAC2bduGt956q9DnqtVq6HQ6g7bWrVsjMjLSYK7D4mjUqBG0Wi3Onz8vD7WOjIxEQkKCwbHu3bsHlUplsLhNftHR0bh7966cWD116hQUCgUaNmxYYN969erBysoKJ06cQO3atQHoV90+e/Yspk2bJu/Xp08f2NvbY/Xq1Th06BCOHz9eoteb+3pK+t5ZWen/Zsz//0JU0TDxSEREZpc3oSiK+n/zPtbqROh0EkTR8AORna266MRjfIJ837OaswmxiNCJmZCggyRpc5KOJf8mOVMbj0cpfyAu9SKydUmF7uNgXRuuDq3hbOsHW2svKARedis6CYAk6s/d7EKSzACgUAiwypk3Uq1WQKVSwkrNhCQREZWu/fv3Iz4+HmPHji1Q2Th48GCsX7++yMSjj48Pjh49ik6dOsHa2hrVqlXD+++/j5deegm1atXCyy+/DIVCgfDwcFy6dAkffvih0XE1bNgQvXr1wptvvonVq1dDpVJh2rRpBoul9OjRA/7+/hgwYAA+/fRTNGjQAHfv3sVPP/2EgQMHysO5bWxsMHr0aCxZsgRJSUmYMmUKhgwZUmCYNaCvxHz77bcxa9YsuLi4oFatWvj000+RlpaGsWPHyvsplUoEBgZi3rx5qF+/Pvz9/Y1+bUUxx3tXu3ZtCIKA/fv3o0+fPrC1tYWDg0OJYyMqayb/BVy3bl08evSoQHtCQgLq1uW8VURElZ1WJyIjU4vUtCwkJWciPiEdD+PScP9BKu7eS0b0nSRE30nC3XvJuP8gFQ8epSEuIQNJyZlITctGeoYW2dligaTj08QmJMr33Z0doNWlQiumQydm5SwGk44sbRKytInI1CYgI/tRzu0hsnVJOUOpM0uUdBSlbMSl/oV/72/C5bsrcT/peIGko0rpAA+n59DYazLqe4yBi30LKBSscqxKRFFCRqYWyalZiEvIQOzDVNyOScatu0m4/yAV8YkZSE/Phk7HoVREVLrMWe+oUFjBWu2SM10I578tj9avX48ePXoUOpx68ODBOHfuHP78889Cn7t06VL8/PPP8Pb2RqtWrQAAAQEB2L9/P44cOYJ27dqhQ4cOWL58uVw9aIqNGzeiRo0a6Ny5MwYNGoTx48fD3d1d3i4IAg4cOIAXXngBY8aMQYMGDTBs2DDcvHlTnlMRAHx9fTFo0CD06dMHPXv2RPPmzfHVV18VedzFixdj8ODBeO2119C6dWtcvXoVhw8fRrVqhnOFjx07FllZWU9cJMcU5njvnnnmGXmRGg8PD0yaNMkssRGVNUEyccZhhUKBe/fuGfySAID79++jVq1ayMwsZAlJC0pKSoJGo0FiYiKcnJwsHQ4RUbmmy6lE1FcoPq5S1Goft5fmoC07WzXcXAsfxjRl9QZE3b0HABjX63n0ategFCMxlJYVk7NQzJ9FzAOpgMa2AVwdWsHJxheCUHAeQGu1a4WreCxP19BsrYi795ItGkNpUKsUsLZWwcpKCRvOIUlEZhabkIhsrdagzVWjhiSlm9yXlaoalDlfpIliNjK18SjtWSStVBooFTZP35GqhKCgIOzduxcXL140e9+//vorunfvjlu3bhkkOomo5Iz+BLRv3z75/uHDhw2+RdHpdDh69OgT52IgIiLLyT+X4uPkomTwuLzOBKUTRTxIeFxZ6OFc+kkwrZiO+NS/8CjlD6RnxxS6j7XKFa4OreFi3xxqpWOpx0SVT7ZWRLY2S17QRqEQYG2lhLWVSl7YRqFgZRERWZZKaS8nHQFAoVBDrXRAtq7yfSFEVUtmZiYePHiAoKAgvPLKK0w6EpUCoxOPAwYMAKAvgR49erTBNrVaDR8fHyxdarlVvoiIqiptTjJR1EnQilKBqsXC5lKsaFIzMpGUliY/9qhm/IqMppAkESmZN/Eo5QIS0iMgSdoC+ygENZztmsDVvhXsrWuVaJEbovxEUUJ6hhbpGfpzTwCgUitgbaWSF69RqZVQKQWee0Qk0+lECIJQ4IsKEwe3FUoh6JOM+amUdtCKqWaZN5nIUrZt24axY8eiZcuW2Lx5s6XDIaqUTB5qXadOHZw9exbVq1cvrZjMqjwNEyMiMsWTqhTzJhsrdkrRUFFDra/cuoN3/rsJAKBSKhEy83XYWJnvg06WNglxqRfxKPUPZGnjC4/N6hm4OrRGNbumOfNbmYZDrUumsg61LglBEKBUCLBSPx6ubW2lZEKSqBLJv0Bb7t8COrHgiAU3VzvY5Vug7X58ArT5VsQ1Zai1QlBDpXQwqHbMK0ubBJ1o+rBtY3GoNRFRxWfyJ6Dr16+XRhxERFWKQSKxklYpGkOSJGRk6BfhSE7JQlaW/sPR8x28YW/3+EPOnYdx8v3qTo5QmCGxIkpaJKX/g0cpfyAp4yoKm6dKpbBDNfvmcLVvDVsr94KdEFlQ7pcTWp2ItDwVkmorJazVSlhZKfWra6sVTEYSlTM6nX6RNa1OgigaJhT17SK0WqnEFYslebYgKGGlqvbE3x9KhU2pJh6JiKjiK1bpxdGjR3H06FHExsZCFA0rTjZs2GCWwIiIKiptTiViblJRvzCL/kNF7v3KmFLUakWk5CQQk1Mz9f/Kt5zHqVlykjElp12rK/hubP/vQNSv4yI/jol/XIXoXsL5HTOyH+BRyh+IS70IrZhWyB4CHG3qwdWhFTS2DStclSJVbRKArCydPomf+rhdpVTASq2AVc7ckVZqBZRKhcXiJKqMxDzXfK0oQcxJKmpzvkzUifpkY1mOVihJ4lIhqJ/6pYVSYQVBUHC4NRERFcnkT1PBwcFYuHAh2rZtCy8vL36DTkRVhv5Dg2FlQlmv+lwW8lchyknD3Ftqvracx2npBedDLK7EpEyDx/fjE+T7bhrTE486MRMJaX/jUcofSM26Veg+VkpnuDq0got9S1ipSmcOSSJL0eZUU+dWRgL6hWzUKgXUaiVUSgXUaoX8mIge0+lEZGv113pRlCBKEqScvwny/j1gjvkUyxPByC/elAo7aHUppRwNERFVVCYnHr/++muEhITgtddeK414iIjKXEVf8flJClYhZuuThqn5qhGNqEIsbXa2amgcreFSzQZKpeGXWvfjE+X7bhrjkoKSJCEt6zYepVxAfNoliFJ2gX0EKOFs5wdXh9ZwsPaBILACjKoOUZSQmaVDZpbh/G+CIMDGWgkbaxWsrfXDtflFM1UmkiRBkqBPIEqQk4hiTkWiNifJmDtqoSJPfVL8ZKgAlZFzK6oUtkw8EhFRkUxOPGZlZaFjx46lEQsRkdlVlrkUy0MVorFUSgGODtZwdLDKuenvO9jnPLa3yrdd36ZUKopcXMaUisdsXQriUv9EXMoFZGgfFrqPrdoTrg6tUM2+OVQK2xK9XqLKRpIKrqydO2+kSqWASqWAUilApeRwbSo/JEmfJMytTMzOneZE1FcnipIEUQQgVa5F2Z6muK9VpbSHIBhX/SwICigEdaFf8BEREZmceBw3bhy2bt2K+fPnl0Y8RERGybuqc96EopgnwVheV3x+4lyIqeWvCtEwQWidJ3loVSC56GhvBRsblVmro7K1OjxKflxJUdgcj5IkIinjKh6l/IHE9EgABeeaUgrW+oViHFrBzqqG2eIjquwM5o3MRxAEqJRCTjJSAYVC/1gQBAgCoBD02zh8m4ojN5mYla3Tf2mYs/CKKEpy1aJ+1IL+bwAqRDErHpVC4atYF0WhsIKoY+KRiIgKMjnxmJGRgf/+97/45Zdf0Lx5c6jVaoPty5YtM1twRFT1FDbsOe9E7eUpoVgRqxAdHIqoOnxCFaKl3YuLl4eKCYIAVydHeVumNk5eKCZbl1zo8x2sfeDq0ArOto2hUKgL3ccU+uHYue+LCEChb5MkCIISEkQIECBBgiRpOeE+VWqSJCFbKyFb++TzXACgUiugVuVUTeZUTKrUSqhVlv89Q5aV+2VibqVidraI7GwdtNqKOc1JxSeYfL1UCtbQ5l3RioiIKIfJicc///wTLVu2BABcunTJYBvn/yGiouQmFAtbmKU8TMyu04n55j00rDosX1WIKn2S0D5ftWHe6kN7dalWIZalO4/i5Psujg5QKEQkpP+FxLhzSMm8Uehz1EpHuNi3hKt9K1irXQrd58kEKARVzjAzAYKggFKwhiAoTZ4HUpIkSNBBACu+qOqSgJxkUsEEpQDIQ7jVKn0yUqVUyAnKivq7q6rS6URkZemQrRXlRVhECQYVirlVi6JUtis8VzXF/ZuqOF/SKRRqrm5NRESFMjnxeOzYsdKIg4gqKDlxmHe4s/g4qSiKUpkmFAtUIRZZjWj4OC297IcHqVSKfMOWHycKHYqoQnSws4KqilUH3Y2Ll++3qKfFnaRPIEoZheypgMa2AVwdWsPJxrcYC8UIUCqsoVBY5SQZzfM+C4IAwfTLLVGVIQH6KjetiPRCtiuVAgQIEBT6odvKnBW4c5OTSiUTlKVNpxP1yUNRggR9slCU9AnFvF8g5g6JpvKhuH96KUwcZv34eWropMziHZSIiCotfhIiIgOSlDOHki7fCo85i7DkTtReFkOe5bkQi6g6LLQKMTUL2qcM+SsNJs+F6GANG2uuFGuMmDyJR5WyOkTpH4PtNqrqcHFoBRf7FlArHUzuX6GwhkphB4Wg5v8HUTmkT2RJgDzFpA6FZSiVSiFnjkn9XJO5JAkQhNwvAXJ6yFNxJwBQKB7PS5n394CUr2IPeLxYh0IQoBAACPrjCgCEnDku5YpNlcIiv1fkqsKcZOHjysPH01YA+mpT5LxuSQKys3U5Q50fz6loqZEIVHLF/SvN1PkdcykEK+jAxCMRERkyOfHYtWvXJ/4B9b///a9EARGReeVPJOZWIeYmEPVJRRGSiFL7gFHZ50KsilWIJZX3w27uAhQQUOj7eC9P4tHRpgasVbWQrbsHZ7smcHVoBXsr72J9sFcorKBS2EOpKN4HLCIqX/RVd1Khw7ktSZ07hFyl0CcpcxfeUQjyTRBgsOJy7u/I3H9yf8WJIh5PWSLmXK9zhjDrdCKydSK0WiYLKUexTgMBglC82hSFQp3nCwIiIiI9k68qufM75srOzsbFixdx6dIljB492lxxEVEhRDFPFWLe1R0lyeCxLqdKURSLP79PUSp1FWIFnwuxtORW8eQmCAWFIFf65N4XFAKUitxtj/fL+xx9YZBgUIlkjHtxCfJ9d40Gz2iGwdnBEZJUvE83SoUNVEp9hSMRUWnLHUZOVBHo5zcu3t9B+uuqgGJmPImIqJIyOfG4fPnyQtuDgoKQkpJS4oCIKrO81YdinsnVc9sl8fG/ogR5aFRuQtHcsVTmKsTysiJzacithFEooJ/3TNA35g4jzDtcMO/wQjlJKCcMDROJue35+7AkUZTwIDFJflxd4wRHWy8oFdnQ6tJM6ksQVLBSOpllZWsiIqLyrjhDrRUlHAWgUFhBFDncmoiIHjPbHI+vvvoq2rdvjyVLlpirS6JyKXeosj5xaLg6oyTlDIGSKw8Nk4ml9f2vKSsyp6Q8rla0TBVi/hWZrQp5XHmqEAUACqXwxEpBhSBAoRQM5hlTKHKHH+fsX04SgWXtUXIysnWPKxvdNE6wUVtBhGmLASkVtlArHcy2YAwREVF5V5xBLyUdDaAQ1BA5zyMREeVhtsTjyZMnYWNjY67uiEpV3knX8w9bzp37sCyqDguLKyNT97jSMDULycn5qw5zVmROfvzYIisyV7K5EPMm+4pKEOYfNmy4GEHBRKGpQ4qpoLuP4uT7TnZ2sLOxhlKpgGj0KGsBVionKBW8PhERUVVTjIpHMyQeiYiI8jI58Tho0CCDx5IkISYmBufOncP8+fPNFhhRblWhlK+6UJL0CcHcydSBnORgzsqNUs5zcydof5xELJ05D4vCKsTS9dREYf6kIZBnDsLHcxEyQVi+3Xn4SL7vpnGCtdr4DzRKhTXUSkcIgrI0QiMiIirXTP2TVyGoSzwyQCGowHkeiYgoL5MTjxqNxuCxQqFAw4YNsXDhQvTs2dNsgVHFlLeSMLdKELnzF+Yk/vImE/NXFZZ1ctAYBaoQC50LMacKMU+7RasQ7a3g6Fh+qhANhw7r/1Uo8s07mLeiUD/JYIFkYe6QZSYKq447jx6vaO3u7AQbIxOPaqUjVEq70gqLiIio0inp/I4AIAgKKAQVRKns/w4mIqLyyeTE48aNG0sjDipjeROEkKTHFYMFHuckC0UxZ1iylLM9XwIxT7Vhefa0KsSU/AutWLQKUV3ICsxlW4UoCLkrFQNKhUK/GIlSUXAIMgznJhTwuKKwsi7wQmUjJu5x4tGYikdBUECt1EBphg9PREREFZlo4hf5SsHaLMdVKNQQdUw8EhGRXrHneDx//jwiIiIAAE2aNEGrVq3MFhQVrcDw49zVkfNUGBZaTShJkPJUG5b3BOHTFFiRuciVmctRFaIF50JUyEnCx9WGCoU+qahQKKBQ5iQYcxKNeR8TWdL9+AT5vqdLtScmshWCGlYqDYdWExERATBluLMgKKBQmGd+RoVgBSDNLH0REVHFZ3LiMTY2FsOGDUNoaCicnZ0BAAkJCejatSu+++47uLm5mTvGCkfKWy2Yp4Iw7wrIElAwQZinmlDKeQ5yEoflbfixOeWtQkzJP/9hTlIxKTlPVWJOW1WsQsyfGDRIHipyEozyfYW8D1FFJEkS7uVJPD7j6lLkvkqFDdRKJybLK6n7D1KRkpqFuIR0KJUKKJUCVEoFVCoFlEoFVEp+UUJEVBLmXBSGC8wQEVFeJiceJ0+ejOTkZPz999/w8/MDAFy+fBmjR4/GlClTsG3bNrMHWZ7odCLiEjIKTSBW5uSgMQpdkTlfFWJKahaSUsppFaK9FRwdrcusCrGwJGLuPIb5qw8VCn6wpqonKS0NGVmPfz94u7kWspeQM5+jbdkFRmXus69O4X+/3XjiPgqFAJVK/7tSpVRAqVLo/1XmtisKSVoKcntRzy1qW96+c5Ofhd/P2VclPH6cc2x1Tn9Kpf6LIiIiczLlY4k5k4WCoIAgqCBJWrP1SUREFZfJicdDhw7hl19+kZOOANC4cWN8+eWXVWJxGVGCRRJlZa2ouRBTihraXMVXZM6tPBRy/lUqFXmqEfMkEHOGOXPeQ6Knu/0gTr5va2UFVydHg+2CoIKVSpOzgiZVZsZcW0RRQlaWDlllEE9pEHLmxDVIcuZJUiqVipxE5eMEZv6kqj6pmfe5wlOTn4+35U+uCjmJWgXUKsOEbf7+WXVKVD6ZMrmSfni0+SgENXRMPBIREYqReBRFEepCJvdXq9UQxbJPOtGTGVOFmDsXYt5hzqlp5aQK0cEajvbqAtWHjvb6xw72pbMic8Gk4eMPfoZDnJlEJCottx8+ku+7V9NApXw8d6NCUEOlsocg8OevKtAn5QTodJV3VIEk6ROslvgCz1zkCtGcRGRhVadyJakqJ5FaaAJVyFNZmnPtlffP128hydCnJV4fV5oaDtln1SlVOkb/yhQgmPlLPIVCDZ2YbtY+iYioYjL5CtOtWzdMnToV27ZtQ40aNQAAd+7cwfTp09G9e3ezB0iPFVaFqE8WGiYVc4cyW3YuRH0VooO9FZyKqEJ0yLnv5GhdKlWI+QmAfhhzzocLZZ5kYu6HGyYSicqPu3GPKx49nDUG25QKm7IOhyxo+cIXka0VcScmCVqdBJ1On6DT6kToCnn8+L6o3z/nseH9gvvqtBKyc+/rRGi10uN+tDnHyX1uzjZtIfsWiEErynFX5hlZ9P8XOmRBZ+lQikWRU3Wat+KzsOrQvFWouQnNx0nVx1WrBRKhefsqcvh/4YlXVb4kbt4K17wVsKw6pbyMrXhUKNRmP3cUxV/DlIiIKhmTrwhffPEF/vOf/8DHxwfe3t4AgFu3bqFp06b49ttvzR5gZWRKFaKl50JUKoUiVmEuOAdibhWivb0V1KVQhVgYQRD0f3Qrcj4E5FmlWZVnfkQuskJU8cQ8ipfve7lUs2AkVF4IggC1StBfY6wtHY3pcueHlpOnuYlTrYjsnARlbuIyW5snAZqTyCx4PyfJqRMLJFflffNvy5+klY+r35adJwZtnphyjyuKlTdzKkqAqNW/BxVV3iHyhgnM/AlSodD5SouqOjVMdhacH9Xw8ZOrTg0TuIb982818zL2iw5zD7MGYPYKSiIiqrhMviJ4e3vjwoUL+OWXX3DlyhUAgJ+fH3r06GH24CoCnU5ESmp2gSRhkUnFcjAXYlFViA7550h0sIJtKVchFkUQhMcViIrHf0TnJhTzVisSUeV0Lz5Rvv9M9aJXtCaqKARByLl2AYDyabuXS6IoQSdKclI0W/s4cVlYhWfepGXeJKZB4jR/dag27z55+tE+PXmat5+ikqeVmT7ZrAMqRdVpERWfeRKYj+cgLaRy1KBytWAFa/7nPr7/lMWi/r+9e4+Our7zP/76fmdymVxJCAQChosK1BugFg+gB7ZSEFkq665WSwXh1O5acGHZbpUfl0BdS6HVUina3W5F212Bygo9p2eVclKBWkEBi7dSFNRClUtQkpCgucx8fn8kM5nJjYTM5TvfeT7OyXHmO5PJ+w0mb+ad9+fz6aTR6rSp0y5PPMbgFGrLsjhgBgAg6SIaj1JTIfnyl7+sL3/5y9GOx9GeePqA3jlcoTOfnk/oXogXM4UYq70Qu8OSIhqGoUNYwqYTg9ed9I82APFnjNHpysrQ/YG92zvRGkC82c0rCOK1siHa2kyddrBEv/XUaUPYVGjrz+2oydn6dS7ceG1n6jTiazR9LlOnztbZ1GnEsv329hltNUnaugHa7vL/sM8tLPCpMD9T48c0rUrr6h6PsTqkzba8HDADAOh64/F3v/ud5s+fr7179yovLy/isaqqKo0bN04//elPddNNN0U9SKd4+9Bp7X3946i+ZjJNIXYkfCox4rYneLvlH0oA0BVVted17rPPQ/cH9KHxCKDnXDN12qqB2Xris6OGZ6dL9lvvjdrOBGp7jdfQ57aaQm13yX7za7lZoqdO+xZl6cWNd0uSAl1Ya21Z3pgd1GZb3iSdvQUARFOXG49r167Vfffd16bpKEn5+fn6x3/8Rz322GOubjzm53V8mEHoRObwRmESTCF2JjihGLm8OXxD9abfwjqpCQrAHY5VnAndTvN6VJiTk8BoAMA5mqZOPUqL/urYuAifOu20+dnB0vpOl9230zwNNmFb9lDtfGq1dbO0vWlWJ0+dRr63iIyz+vxn+vRcjdLTC5WdYWRZVkyWWQdZMXxtAEDy6HLj8Y033tDq1as7fHzy5Mn64Q9/GJWgnGrapMt01Yg+MsZENhTjcCJzNLVe8tyyJKTVEmg2+AaQIB9VfBK63Tc/n59HAOAS4VOnGekumTrtqPnZalq09ZL98MZrZ0v2O2u0hjduJam4T3YoztYDj29/eExP79gpSbpqcH+tuOdW2XbsmoOxWsINAEguXa4Gp06dUlonv1r1er2qqKiISlBOdeMNl+iG6wbo45PnEh1Kh8KbihGba3MgC4AkYYzRx59yojUAwJmcOnXap3eWsnwtQbU+XKaiqjp0u1e2T1JsDpYJsiybA2YAAF1vPA4YMEBvv/22LrvssnYff/PNN9W/f/+oBYZIlhQ6fKWjZc9MKQJwg7qGRp2ubDnRul9hr8QFAwCAS5ypbhme6NsrV5Zlx3wq0bbSOGAGAFJclyvNrbfeqmXLlumWW25RZmbkXoefffaZysrK9Ld/+7dRDzAVWJbVZrkzU4oAUlVDY2PEVMaA3oUJjAYAgOTUeqn1maqWxmNxQW5c9mDkgBkAQJcbj0uXLtXzzz+vYcOGaf78+Ro+fLgk6c9//rPWr18vv9+vJUuWxCzQZNTe4SxNy5/DJhZtiylFAAhT39io05VhjcciTrQGAKCnzlS31Na+vXLjsgejxT6PAJDyulwJiouL9corr+j+++/X4sWLZZp/hWZZlqZMmaL169eruLg4ZoE6iW03b4ptNzcRww5jCS57Dt4GAHRP7ed1qqypCd0v6c0ejwAA9ER9Y6Oqas+H7jc1HtNj/nU5YAYA0K1KMGjQIP3f//2fzp49qyNHjsgYo8svv1wFBanzpjDNa+uSkrxEhwEArtTQ2KjTlZWh7fBty1KffH7mAgDQXSZsrfUnYfs72palovzsOE082rIsW8YEYv61AADOdFHVpqCgQF/84hejHQsAIMUFjFFF2DLrovw8eT2eBEYEAEByCt/iMXx/x6L8XHk9abKs+KzOajrZuj4uXwsA4DysBQYAOEr4wTLFBfkJjAQAgCQWNvEYvr9jcUGe7DgcLBNkiV8gAkAqY9MNAICjnK6qCt0uKUydrTwAtM+SZAf3z7ab9tQOfViWLEuyws7pa32Sb+h1LLU80RgZ0/Lc4GXLtpq+nm3JCnttS1bE57f+eiZgFDBGJmDkDxgZ0/zfQMt/A63iChijgL/l+UC0dTTxWNwrzo1Hi8YjAKQyGo8AAEepCHtz1L+wMIGRAIgG27bk9dryhg7gs5saiVbTXnNWcwMxKNjgs62WBmAqMMYoEGxQBhujMgoEpEAgoEBzE9PvN/L7A823Awr4jWhboj2mg4nHvr3yZNvxazzaNB4BIKXReAQAOEpFZdjEYxETj4ATNU0ftjQNg/dtjyWPx5Y32Gz02inTOOwpy7Lk8VzcolS/PxBqSDYGmiYpA8FGZvO14HOQms6EHS7Tr6BXnCceecsJAKmMKgAAcAx/IBDx5mhAbyYegVixrGDzUPJ67FDzsGnasHmZsR2cPLTlsZsbYx62CHcaj8dW0zlcF25bmtAy86bGZKPfRDQuw5uXLANPbsG/O2NMxGqCfgXx/aUeezwCQGqj8QgAcIxPqs/JHwiE7sf7zRHgBqHpQ7t5+rC5WRhsGnq9TU1EJhFTU3DvSsmSxyOlXWDwzZjw5mRTg7KxMaBGf6Dpv40Blno7VPDv5XxdnT6vbzlVurigd1zjaPp/ziNj/HH9ugAAZ6DxCABwjJOfVoZu98rOVmZ6/JaCAU4SOjjFVuhAldBS5tDhKnZoubPVvF+ibdNMRHRZlqU0r6U0b8eTrq2Xekfc9wfU2MjkZCIE/8zDpx0z0rzqlZMd91gsy0vjEQBSFI1HAIBjnDh7NnS7uCA/gZEA0WNJTVOGYVOHwWXL4YerBJc1s5QZyaYrS70b/QE11PtV39DUjAw2Jf3+piXfiJ3wg2V65+UlZNrZtjwKXPhpAAAXovEIAHCM8InH/oUss0by8HpspaXZzUubbXm9LSc500gEmr5HvD5bPl/bx9pbzu1vXsrdwMTkRQv+mZ0Jm3gsystNSCwWbzsBIGUl9F/Cu3fv1vTp01VSUiLLsrRt27aIx40xWr58ufr37y+fz6dJkybpvffeS0ywAICYO3m2MnS7X2GvhMUBhLMsS2lptnyZXuVkpysvN0MF+ZnqXeBT/745Kh2QpwH9c9W3KFu9C3zKz8tQdla6MtK9NB2BLmhazm0rM8Or7Kzm77FePvUpylZJca5KB+RpYP9c9eubraJCn3rlZSrLlyYv31+dCrZqz1S1TDz2yU9M49HmZGsASFkJrQC1tbUaOXKk5s6dq9tvv73N42vWrNHjjz+uZ555RkOGDNGyZcs0ZcoU/elPf1JmZmYCIgYAxFJ447E/B8sgxto91TnsMBZv2NJoAInlaZ4ezkiPvO73B5qWbzc2LeNuaPCroTHA8m1JCk48VodNPObnJSQUi8YjAKSshFaAqVOnaurUqe0+ZozR2rVrtXTpUt12222SpF/84hcqLi7Wtm3bdNddd8UzVABAjBljdCpsqfWAosLEBYOkEzx8xeNpOYjFCj/dudV9m1OdAVfweGz5PLZav63x+wNqaGxqRNY3BFTf4FdDQyBllmyH5xnReEzUUmtOtgaAlOXYXz198MEHOnnypCZNmhS6lp+frxtuuEF79uzpsPFYV1enurq60P3qsM2UAQDOdbamVp83NITuD+hN4zHenF5DLUneNFtpXo/S0myleVtu00QEEC44IZmZEfl2J3jITUNjUzOyvsGvxoaA3NaODPYdA4GAPoloPCZm4lFqWm7tp/EIACnHsY3HkydPSpKKi4sjrhcXF4cea8+qVau0cuXKmMYGAIi+k5+2nGidnZmhvOysBEaTmpxcQ9O8tkoHctI5gJ4JHXITds0Yo8bG5sNsmhuSTdOSyTshaZpbqWdrauUPtJwnXZSgPR6l4HLrugs+DwDgLq7btGjx4sWqqqoKfRw/fjzRIQEAuuDjsMZj3140mBKBGgogFTUdIOWRz5emvNwMFRVmRRwcVdwn/OCoNGVmeB1/sI1pZ3/HXJ9PGWlpiQqJA2YAIEU59qd/v379JEmnTp1S//79Q9dPnTqlUaNGdfh5GRkZysjIiHV4AIAoO0HjMeGooQAQydt80JTa+dFojFGjv3la0h9QY/N+kg2Nfvn9iZ2UDA5qRiyzTuC0o8QBMwCQqhz703/IkCHq16+fysvLQ43G6upqvfrqq7r//vsTGxwAIOpOfNLSeOxX0CtxgQAA0AWWZSnNaynN23b6MRAwzQfaNB1qUx/307abJx6rWvbq7ZPA/R2l4MSjJbluR00AQGcS2nisqanRkSNHQvc/+OADHTx4UIWFhSotLdXChQv17//+77r88ss1ZMgQLVu2TCUlJZoxY0biggYAxMSJs5Wh2zQeAQDJzLYtZWZ42z3cpr7er7p6v+rr/TGbjgxOPFaETTz2TvDEo9TUfAyYhgs/EQDgGgltPO7fv19/8zd/E7q/aNEiSdLs2bP19NNP6zvf+Y5qa2v1zW9+U5WVlbrxxhv14osvKjMzM1EhAwBiJPxwmRJOtAYAuFDwcJssX8tei8aY0FRkXX3TSdsN9f4ezQUGgns8VrU0HhM98Sg1L7em8QgAKSWhjceJEyd2elKcZVn67ne/q+9+97txjAoAEG/GGJV9/U4drzij90+cUmmfokSHBABAXFiWpfR0j9LTPcrJbrpmjAlNRdY1T0Y2NgS63IxsOVymZal1ovd4lCTbSpNfnyU6DABAHDl2j0cAQOqwLEsjLhmgIf366orSgeoVfOcFAEAKsqz2l2o3NPjV2BhQQ2Mg4r+N/kDE8wImoPrGRlXVng9dK8pzQOPR9kr+REcBAIgnGo8AAMfxeNpu1A8AQKpLS/MoLc0jX6vrrVeRBQIm4kRr27JUkJsThwg7Z4kDZgAg1fDODgDgLJYlj015AgCgqyzLkmVZofv+QCBif8fC3BxH1NamOD2JDgMAEEeJrz4AAIRxwhsjAACSWcAYVYTv7+iAZdZBtsWiOwBIJby7AwA4Co1HAAB6JhAI6JOwicei/MSfaB1k0XgEgJTCuzsAgKPQeAQAoGcaA4HIE62ZeAQAJAjv7gAAjmKH7VEFAAC6JxAw8vv9qnDoxCONRwBILTQeAQCOwsQjAAAXzx/wyxijM9XhjUfnTDw2HS7DLxkBIFXw7g4A4Cg0HgEAuHgNfr9qP6/T5/X1oWt98pwz8Sgx9QgAqYR3dwAAR7FtpiAAALhYgUDktGNGmlc5vswERtQWB8wAQOqg8QgAcBQmHgEA6JnIg2XyZDls/+Sm5dYAgFTAuzsAgKPYFqUJAICeOFPlzP0dg2wajwCQMnh3BwBwFJZaAwDQM2eqIicencYSjUcASBU0HgEAjmFbtuOWgwEAkGwqwk+0znPexCNLrQEgddB4BAA4Bvs7AgDQc5+ETzw6cKm1Zdmy2FoFAFICP+0BAI7BMmsAAHomEAjok3M1oft98p231FqSLCst0SEAAOKAxiMAAAAAuMSn52rkDwRC93s7cKm1JNmWN9EhAADigMYjAAAAALjE6cqq0O1cn08Zac6cLKTxCACpgcYjAAAAALjEqbDGYx8H7u8YxFJrAEgNNB4BAAAAwCUqwhqPRQ7d31GSbMvDATMAkAL4SQ8AAAAALnE6/ERrh+7vGGTJk+gQAAAxRuMRAAAAAFwifKl1UZ5zJx4lyWKfRwBwPRqPAAAAAOASkUutnT3xyAEzAOB+NB4BAAAAwAXqGhp0tqY2dN/JezxKTDwCQCqg8QgAAAAALnDqbMu0o23bKsjJTmA0F2ZZ7PEIAG5H4xEAAAAAXOBUZWXodmFOtjy2s9/u2ZZHkpXoMAAAMeTsSgQAAAAA6JJTZytDt52+zDqIqUcAcDcajwAAAADgAic/rQzdLspz9sEyQTaNRwBwNRqPAAAAAOACJ8MmHvskzcQjB8wAgJvReAQAAAAAFwhvPPZOkolHlloDgLvReAQAAACAJGeMiTjVOlkmHm0mHgHA1Wg8AgAAAECSO/fZZzpfVxe6nzx7PKaJk60BwL349RIAAAAAJLl0b5r+31236y+nK3Tik7PK8WU2PWBZ6pOXp+rz51XX0JDYIDtgW14FjDNjAwD0DI1HAAAAAEhymelpGn/lCI0cOlhVtbWh61kZ6UpP8yo/O0unK6s6eYXEsSyvROMRAFyJpdYAAAAA4FK+9HRJUprXq+zMzARH0z6bA2YAwLWYeAQAAAAAF7JtWxlpaaH7vXKyExhNxywr7cJPAgAkJSYeAQAAAMCFcnyZsiznH9zCxCMAuBeNRwAAAABwGdu2lZWekegwusSyPOJkawBwJxqPAAAAAOAyeVk+eTzJ83bPttgFDADcKHkqEQAAAADggjLS0hx7kExHLJZbA4Ar0XgEAAAAABdJpknHIIuJRwBwpeSrSAAAAACADnnt5Jse5IAZAHAnGo8AAAAA4CLJOfFI4xEA3Cj5KhIAAAAAoEO2lXxv8yzReAQAN0q+igQAAAAA6JBtWYkOodssy5aVhA1TAEDn+MkOAAAAAC5iJWHjUeKAGQBwIxqPAAAAAOAiyTjxKEk2jUcAcB0ajwAAAADgIkk78SgajwDgNjQeAQAAAMBFkrTvyMQjALgQjUcAAAAAcAnLSuKJR4uTrQHAbWg8AgAAAIBLWErOpqMUPNma5iMAuAmNRwAAAABwi+TtO0riZGsAcBsajwAAAADgEsl6onUQ+zwCgLvQeAQAAAAA16DxCABwDhqPAAAAAOASST7wyFJrAHAZGo8AAAAA4BLJfLiMJFnyKNmnNgEALWg8AgAAAIBLJP/Eo8XJ1gDgIjQeAQAAAMA1krzzKPZ5BAA3ofEIAAAAAC6R7BOPEvs8AoCb0HgEAAAAAJdI9j0eJSYeAcBNaDwCAAAAgFskf9+RxiMAuEhSNB7Xr1+vwYMHKzMzUzfccINee+21RIcEAAAAAI7jhonHpsNlkj8PAEASNB43b96sRYsWqaysTK+//rpGjhypKVOm6PTp04kODQAAAAAcxQ17PEpMPQKAWzi+8fjYY4/pvvvu05w5c3TFFVfopz/9qbKysvTUU08lOjQAAAAAcBTLJZ1HDpgBAHdw9E/z+vp6HThwQIsXLw5ds21bkyZN0p49e9r9nLq6OtXV1YXuV1dXxzxOAADcgBoKAHAKJh4BwB0cPfF45swZ+f1+FRcXR1wvLi7WyZMn2/2cVatWKT8/P/RxySWXxCNUAACSHjUUAOAUTDwCgDs4uvF4MRYvXqyqqqrQx/HjxxMdEgAASYEaCgBwCiYeAcAdHP3TvKioSB6PR6dOnYq4furUKfXr16/dz8nIyFBGRkY8wgMAwFWooQAAp7AsWzKum5MBgJTj6J/k6enpuu6661ReXh66FggEVF5errFjxyYwMgAAAABALDH1CADJz/E/yRctWqTZs2fr+uuv15gxY7R27VrV1tZqzpw5iQ4NAAAAABAjluXoORkAQBc4vvH41a9+VRUVFVq+fLlOnjypUaNG6cUXX2xz4AwAAAAAAAAA57CMMSbRQcRSdXW18vPzVVVVpby8vESHAwBA0qCGAgAAAOgJZtcBAAAAAAAARB2NRwAAAAAAAABRR+MRAAAAAAAAQNTReAQAAAAAAAAQdTQeAQAAAAAAAEQdjUcAAAAAAAAAUUfjEQAAAAAAAEDU0XgEAAAAAAAAEHU0HgEAAAAAAABEHY1HAAAAAAAAAFFH4xEAAAAAAABA1NF4BAAAAAAAABB1NB4BAAAAAAAARB2NRwAAAAAAAABR5010ALFmjJEkVVdXJzgSAACiKzc3V5Zlxez1qaEAALeKdQ0FADRxfePx3LlzkqRLLrkkwZEAABBdVVVVysvLi9nrU0MBAG4V6xoKAGhimeA4g0sFAgF9/PHHod9oVVdX65JLLtHx48ddWWjcnp/k/hzJL/m5PUfyc45YT2tQQ93F7flJ7s+R/JKf23NMpvyYeASA+HD9xKNt2xo4cGCb63l5eY4vhj3h9vwk9+dIfsnP7TmSn/tRQ93J7flJ7s+R/JKf23N0e34AgK7jcBkAAAAAAAAAUUfjEQAAAAAAAEDUpVzjMSMjQ2VlZcrIyEh0KDHh9vwk9+dIfsnP7TmSX+py+58N+SU/t+dIfsnP7Tm6PT8AQPe5/nAZAAAAAAAAAPGXchOPAAAAAAAAAGKPxiMAAAAAAACAqKPxCAAAAAAAACDqaDwCAAAAAAAAiLqkbjzu3r1b06dPV0lJiSzL0rZt2zp9/ssvv6zx48erd+/e8vl8GjFihH70ox9FPGfw4MGyLKvNx7x582KYScdikaPf79eyZcs0ZMgQ+Xw+XXrppXr44YeViHOGYpHfuXPntHDhQg0aNEg+n0/jxo3Tvn37YphFx7qbX7g//OEP8nq9GjVqVJvH1q9fr8GDByszM1M33HCDXnvttegF3Q2xyK8nrxkLschx1apV+uIXv6jc3Fz17dtXM2bM0OHDh6MbeBfFIr8nn3xS11xzjfLy8pSXl6exY8fqhRdeiG7gXRSr78Gg73//+7IsSwsXLuxxrPHm9hrq9vopUUM7Qw1NfA11e/2UqKGdcXsNBQB0XVI3HmtrazVy5EitX7++S8/Pzs7W/PnztXv3bh06dEhLly7V0qVL9Z//+Z+h5+zbt08nTpwIfezYsUOSdMcdd8QkhwuJRY6rV6/Wk08+qZ/85Cc6dOiQVq9erTVr1mjdunWxSqNDscjvG9/4hnbs2KFf/vKXeuuttzR58mRNmjRJH330UazS6FB38wuqrKzUrFmzdPPNN7d5bPPmzVq0aJHKysr0+uuva+TIkZoyZYpOnz4drbC7LBb5Xexrxkoscty1a5fmzZunvXv3aseOHWpoaNDkyZNVW1sbrbC7LBb5DRw4UN///vd14MAB7d+/X1/60pd022236Z133olW2F0Wi/yC9u3bp//4j//QNddc09MwE8LtNdTt9VOihnaEGuqMGur2+ilRQzuSCjUUANANxiUkma1bt3b78/7u7/7OfP3rX+/w8QULFphLL73UBAKBHkQXHdHKcdq0aWbu3LkRz7n99tvNzJkzexpij0Qjv/PnzxuPx2N+85vfRDzn2muvNUuWLIlGmBetO/l99atfNUuXLjVlZWVm5MiREY+NGTPGzJs3L3Tf7/ebkpISs2rVqihG233Ryu9iXzMeYpGjMcacPn3aSDK7du3qeZA9EKv8jDGmoKDA/Nd//VfPAuyhaOZ37tw5c/nll5sdO3aYCRMmmAULFkQ11nhzew11e/00hhoajhra/deMNbfXT2OooeFSrYYCADqX1BOPPfXHP/5Rr7zyiiZMmNDu4/X19frv//5vzZ07V5ZlxTm66Ggvx3Hjxqm8vFzvvvuuJOmNN97Qyy+/rKlTpyYqzIvWOr/Gxkb5/X5lZmZGPM/n8+nll19ORIjdtmHDBr3//vsqKytr81h9fb0OHDigSZMmha7Ztq1JkyZpz5498QzzonWWn1t0N8eqqipJUmFhYSzDipru5Of3+7Vp0ybV1tZq7NixcYiu57qS37x58zRt2rSI78VU4/Ya6vb6KVFDJWqo07i9fkrUUIkaCgCpxpvoABJh4MCBqqioUGNjo1asWKFvfOMb7T5v27Ztqqys1L333hvfAKOgsxwfeughVVdXa8SIEfJ4PPL7/XrkkUc0c+bMBEbcPR3ll5ubq7Fjx+rhhx/WF77wBRUXF2vjxo3as2ePLrvssgRHfWHvvfeeHnroIf3+97+X19v22/PMmTPy+/0qLi6OuF5cXKw///nP8Qrzol0oPzfobo6BQEALFy7U+PHjddVVV8Uhwp7pan5vvfWWxo4dq88//1w5OTnaunWrrrjiijhGenG6kt+mTZv0+uuvJ2zfu0Rzew11e/2UqKHUUGdye/2UqKESNRQAUpH7/tXSBb///e9VU1OjvXv36qGHHtJll12mu+++u83zfv7zn2vq1KkqKSlJQJQ901mOv/rVr/Q///M/evbZZ3XllVfq4MGDWrhwoUpKSjR79uwER941neX3y1/+UnPnztWAAQPk8Xh07bXX6u6779aBAwcSHHXn/H6/vva1r2nlypUaNmxYosOJOrfnJ11cjvPmzdPbb7+dFNNE3clv+PDhOnjwoKqqqrRlyxbNnj1bu3btcvQbp67kd/z4cS1YsEA7duxoMxWWKtxeQ91ePyVqaDIiv7aSqX5K1FCJGgoAKSvRa72jRRe5j83DDz9shg0b1ub6hx9+aGzbNtu2bYtCdNERrRwHDhxofvKTn7R5zvDhw3saYo9E+++wpqbGfPzxx8YYY+68805z66239jTEHrlQfmfPnjWSjMfjCX1YlhW6Vl5eburq6ozH42nzOrNmzTJf+cpXYpvABUQjv+6+ZrxFO8d58+aZgQMHmvfffz/GkXdNLP4Og26++WbzzW9+MwZRd1008tu6dWub50gylmUZj8djGhsb45dQFLm9hrq9fhpDDaWGOruGur1+GkMNTeUaCgDoXEpOPIYLBAKqq6trc33Dhg3q27evpk2bloCooqt1jufPn5dtR27v6fF4FAgE4h1aVHT0d5idna3s7GydPXtW27dv15o1axIQXdfl5eXprbfeirj2xBNP6He/+522bNmiIUOGKD09Xdddd53Ky8s1Y8YMSU35l5eXa/78+QmIuuu6kl+y62qOxhg98MAD2rp1q3bu3Jk0uffk77Cj71Mn6Up+gUCgzXPmzJmjESNG6MEHH5TH44lnyAnn9hrq9vopUUOpoc7g9vopUUOpoQCQupK68VhTU6MjR46E7n/wwQc6ePCgCgsLVVpaqsWLF+ujjz7SL37xC0nS+vXrVVpaqhEjRkiSdu/erR/+8If653/+54jXDQQC2rBhg2bPnp3wPXRikeP06dP1yCOPqLS0VFdeeaX++Mc/6rHHHtPcuXPjm5xik9/27dtljNHw4cN15MgR/du//ZtGjBihOXPmxDc5dS8/27bb7FHUt29fZWZmRlxftGiRZs+ereuvv15jxozR2rVrVVtb65r8LvSa8RaLHOfNm6dnn31Wv/71r5Wbm6uTJ09KkvLz8+Xz+eKTWLNY5Ld48WJNnTpVpaWlOnfunJ599lnt3LlT27dvj1teQbHIr/VzsrOz1bt376TZYyzI7TXU7fVTooZSQ51dQ91ePyVqaCrXUABANyR24LJnXnrpJSOpzcfs2bONMcbMnj3bTJgwIfT8xx9/3Fx55ZUmKyvL5OXlmdGjR5snnnjC+P3+iNfdvn27kWQOHz4cx2zaF4scq6urzYIFC0xpaanJzMw0Q4cONUuWLDF1dXVxzi42+W3evNkMHTrUpKenm379+pl58+aZysrKOGfWpLv5tVZWVmZGjhzZ5vq6detMaWmpSU9PN2PGjDF79+6NTQIXEIv8LvSa8RaLHNt7PUlmw4YNMcujI7HIb+7cuWbQoEEmPT3d9OnTx9x8883mt7/9beyS6ESsvgfDTZgwwSxYsCBqMceL22uo2+unMdRQaqiza6jb66cx1NBUrqEAgK6zjDGm47YkAAAAAAAAAHSffeGnAAAAAAAAAED30HgEAAAAAAAAEHU0HgEAAAAAAABEHY1HAAAAAAAAAFFH4xEAAAAAAABA1NF4BAAAAAAAABB1NB4BAAAAAAAARB2NR8Cl7r33Xs2YMSPRYQApaffu3Zo+fbpKSkpkWZa2bdvW7df41a9+pVGjRikrK0uDBg3SD37wg+gHCqAN6ieQWNRQAHAXb6IDANB9lmV1+nhZWZl+/OMfyxgTp4jad++996qysvKi/sEIJLPa2lqNHDlSc+fO1e23397tz3/hhRc0c+ZMrVu3TpMnT9ahQ4d03333yefzaf78+TGIGEgN1E/A+aihAOAulkn0v6wAdNvJkydDtzdv3qzly5fr8OHDoWs5OTnKyclJRGgReOMENDU6tm7dGjFBVVdXpyVLlmjjxo2qrKzUVVddpdWrV2vixImSpK997WtqaGjQc889F/qcdevWac2aNTp27NgFmycA2kf9BJILNRQAkh9LrYEk1K9fv9BHfn6+LMuKuJaTk9NmqdjEiRP1wAMPaOHChSooKFBxcbF+9rOfqba2VnPmzFFubq4uu+wyvfDCCxFf6+2339bUqVOVk5Oj4uJi3XPPPTpz5kzo8S1btujqq6+Wz+dT7969NWnSJNXW1mrFihV65pln9Otf/1qWZcmyLO3cuVOS9OCDD2rYsGHKysrS0KFDtWzZMjU0NIRec8WKFRo1apSeeuoplZaWKicnR9/61rfk9/u1Zs0a9evXT3379tUjjzwSEatlWXryySc1depU+Xw+DR06VFu2bIn+XwDQQ/Pnz9eePXu0adMmvfnmm7rjjjt0yy236L333pPU9KYqMzMz4nN8Pp/++te/6i9/+UsiQgZcgfpJ/UTyo4YCQHKh8QikkGeeeUZFRUV67bXX9MADD+j+++/XHXfcoXHjxun111/X5MmTdc899+j8+fOSpMrKSn3pS1/S6NGjtX//fr344os6deqU7rzzTknSiRMndPfdd2vu3Lk6dOiQdu7cqdtvv13GGH3729/WnXfeqVtuuUUnTpzQiRMnNG7cOElSbm6unn76af3pT3/Sj3/8Y/3sZz/Tj370o4hYjx49qhdeeEEvvviiNm7cqJ///OeaNm2a/vrXv2rXrl1avXq1li5dqldffTXi85YtW6a///u/1xtvvKGZM2fqrrvu0qFDh+Lwpwt0zbFjx7RhwwY999xzuummm3TppZfq29/+tm688UZt2LBBkjRlyhQ9//zzKi8vVyAQ0LvvvqtHH31UUtP3HYD4on4CzkANBYAkZAAktQ0bNpj8/Pw212fPnm1uu+220P0JEyaYG2+8MXS/sbHRZGdnm3vuuSd07cSJE0aS2bNnjzHGmIcffthMnjw54nWPHz9uJJnDhw+bAwcOGEnmww8/bDe21jF05Ac/+IG57rrrQvfLyspMVlaWqa6uDl2bMmWKGTx4sPH7/aFrw4cPN6tWrQrdl2T+6Z/+KeK1b7jhBnP//fdfMAYgViSZrVu3hu7/5je/MZJMdnZ2xIfX6zV33nmnMcaYQCBgvvOd75jMzEzj8XhMQUGBWbFihZFk9u7dm6BMAHehflI/4XzUUABIfhwuA6SQa665JnTb4/God+/euvrqq0PXiouLJUmnT5+WJL3xxht66aWX2t3v6ujRo5o8ebJuvvlmXX311ZoyZYomT56sf/iHf1BBQUGncWzevFmPP/64jh49qpqaGjU2NiovLy/iOYMHD1Zubm5EbB6PR7ZtR1wLxho0duzYNvcPHjzYaTxAPNXU1Mjj8ejAgQPyeDwRjwW/1yzL0urVq/W9731PJ0+eVJ8+fVReXi5JGjp0aNxjBlId9RNwBmooACQfGo9ACklLS4u4b1lWxLXgZtuBQEBS0z/upk+frtWrV7d5rf79+8vj8WjHjh165ZVX9Nvf/lbr1q3TkiVL9Oqrr2rIkCHtxrBnzx7NnDlTK1eu1JQpU5Sfn69NmzaFlsB0NdbgtWCsQLIYPXq0/H6/Tp8+rZtuuqnT53o8Hg0YMECStHHjRo0dO1Z9+vSJR5gAwlA/AWeghgJA8qHxCKBD1157rf73f/9XgwcPltfb/o8Ly7I0fvx4jR8/XsuXL9egQYO0detWLVq0SOnp6fL7/RHPf+WVVzRo0CAtWbIkdC2aG33v3btXs2bNirg/evToqL0+0BU1NTU6cuRI6P4HH3yggwcPqrCwUMOGDdPMmTM1a9YsPfrooxo9erQqKipUXl6ua665RtOmTdOZM2e0ZcsWTZw4UZ9//nloP6tdu3YlMCsAXUX9BC4eNRQA3IXDZQB0aN68efr000919913a9++fTp69Ki2b9+uOXPmyO/369VXX9X3vvc97d+/X8eOHdPzzz+viooKfeELX5DUtNzrzTff1OHDh3XmzBk1NDTo8ssv17Fjx7Rp0yYdPXpUjz/+uLZu3Rq1mJ977jk99dRTevfdd1VWVqbXXntN8+fPj9rrA12xf/9+jR49OvSmfdGiRRo9erSWL18uSdqwYYNmzZqlf/3Xf9Xw4cM1Y8YM7du3T6WlpaHXeOaZZ3T99ddr/Pjxeuedd7Rz506NGTMmIfkA6B7qJ3DxqKEA4C5MPALoUElJif7whz/owQcf1OTJk1VXV6dBgwbplltukW3bysvL0+7du7V27VpVV1dr0KBBevTRRzV16lRJ0n333aedO3fq+uuvV01NjV566SV95Stf0b/8y79o/vz5qqur07Rp07Rs2TKtWLEiKjGvXLlSmzZt0re+9S31799fGzdu1BVXXBGV1wa6auLEiTLGdPh4WlqaVq5cqZUrV7b7eFFRkfbs2ROr8ADEGPUTuHjUUABwF8t09lMdAJKIZVnaunWrZsyYkehQAABIGtRPAAAQKyy1BgAAAAAAABB1NB4BAAAAAAAARB1LrQEAAAAAAABEHROPAAAAAAAAAKKOxiMAAAAAAACAqKPxCAAAAAAAACDqaDwCAAAAAAAAiDoajwAAAAAAAACijsYjAAAAAAAAgKij8QgAAAAAAAAg6mg8AgAAAAAAAIg6Go8AAAAAAAAAou7/A9rtHzvsggw2AAAAAElFTkSuQmCC",
      "text/plain": [
       "<Figure size 1333.5x500 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "bins = [\n",
    "    pd.Timestamp('1900-01-01 00:00:01+00:00'),\n",
    "    pd.Timestamp('2015-06-12 00:00:01+00:00'),\n",
    "    pd.Timestamp('2015-07-02 00:00:01+00:00'),\n",
    "    pd.Timestamp('2100-08-28 00:00:01+00:00')\n",
    "]\n",
    "labels = ['Before announcement', 'After announcement, before deployment', 'After deployment']\n",
    "\n",
    "#creating variables of interest\n",
    "affective_comment_phab_df = comment_phab_df\n",
    "affective_comment_phab_df['date_group'] = pd.cut(affective_comment_phab_df['timestamp'], bins=bins, labels=labels, right=False)\n",
    "affective_comment_phab_df['speakers_comment'] = affective_comment_phab_df.groupby('speaker')['timestamp'].rank(method='first').astype(int)\n",
    "#all comments prior to june 1 2013\n",
    "subset_comment_phab_df = affective_comment_phab_df[affective_comment_phab_df['date_created'] <= 1370044800]\n",
    "#getting counts \n",
    "comment_counts = subset_comment_phab_df.groupby('speaker')['speakers_comment'].max().reset_index()\n",
    "comment_counts = comment_counts.rename(columns={'speakers_comment': 'pre_june_2013_comments'})\n",
    "#merge back \n",
    "affective_comment_phab_df = affective_comment_phab_df.merge(comment_counts, on='speaker', how='left')\n",
    "affective_comment_phab_df['pre_june_2013_comments'] = affective_comment_phab_df['pre_june_2013_comments'].fillna(0)\n",
    "\n",
    "affective_comment_phab_df['new_commenter'] = affective_comment_phab_df['pre_june_2013_comments'] <= 10\n",
    "affective_comment_phab_df['est_commenter'] = affective_comment_phab_df['pre_june_2013_comments'] > 50\n",
    "\n",
    "palette = ['#31449c', '#4a7c85', '#c5db68']\n",
    "\n",
    "comment_counts = affective_comment_phab_df.groupby('date_group').size()\n",
    "speaker_counts = affective_comment_phab_df.groupby('date_group')['speaker'].nunique()\n",
    "\n",
    "print(\"Number of comments for each date group:\")\n",
    "print(comment_counts)\n",
    "print(\"\\nNumber of speakers for each date group:\")\n",
    "print(speaker_counts)\n",
    "\n",
    "comment_counts_engaged = affective_comment_phab_df.groupby(['date_group', 'est_commenter', 'meta.affil']).size()\n",
    "speaker_counts_engaged = affective_comment_phab_df.groupby(['date_group', 'est_commenter', 'meta.affil'])['speaker'].nunique()\n",
    "\n",
    "print(\"\\nNumber of comments for each date group and engaged commenter subgroup:\")\n",
    "print(comment_counts_engaged)\n",
    "print(\"\\nNumber of speakers for each date group and engaged commenter subgroup:\")\n",
    "print(speaker_counts_engaged)\n",
    "\n",
    "comment_counts_wmf = affective_comment_phab_df.groupby(['est_commenter', 'meta.affil']).size()\n",
    "speaker_counts_wmf = affective_comment_phab_df.groupby(['est_commenter', 'meta.affil'])['speaker'].nunique()\n",
    "\n",
    "print(\"\\nNumber of comments for each engaged commenter subgroup, and WMF affiliation:\")\n",
    "print(comment_counts_wmf)\n",
    "print(\"\\nNumber of speakers for each engaged commenter subgroup, and WMF affiliation:\")\n",
    "print(speaker_counts_wmf)\n",
    "\n",
    "#comment_phab_df['before_after'] = comment_phab_df['timestamp'] > pd.Timestamp('2013-07-01 00:00:01+00:00')\n",
    "#fig, axes = plt.subplots(2, 1, figsize=(10, 12), sharex=True)\n",
    "affective_comment_phab_df['polarized_wc'] = affective_comment_phab_df['dominant_wc'] + affective_comment_phab_df['valence_wc'] + affective_comment_phab_df['arousal_wc'] \n",
    "plot1 = sns.lmplot(data=affective_comment_phab_df, x=\"date_created\", y=\"polarized_wc\", hue=\"date_group\", col=\"meta.affil\", row='est_commenter', scatter=False, legend=False, palette=palette)\n",
    "plot1.set_axis_labels(\"Timestamp\", \"Count of Polarized Words\")\n",
    "plot1.set_titles(row_template=\"Established Author: {row_name}\", col_template=\"WMF Affiliation: {col_name}\")\n",
    "plot1.fig.subplots_adjust(top=0.9)  # Adjust subplots to make room for the title\n",
    "plot1.add_legend(title=\"Comment publication timestamp:\")\n",
    "fig1 = plot1.fig\n",
    "'''\n",
    "plot1 = sns.lmplot(data=comment_phab_df, x=\"date_created\", y=\"dominant_wc\", hue=\"date_group\", col=\"meta.affil\", row='new_commenter', scatter=False, legend=False, palette=palette)\n",
    "plot1.set_axis_labels(\"Timestamp\", \"Count of Dominance Polarized Words\")\n",
    "plot1.set_titles(row_template=\"Author's 100+ Comment: {row_name}\",col_template=\"WMF Affiliation: {col_name}\")\n",
    "plot1.fig.subplots_adjust(top=0.9)  # Adjust subplots to make room for the title\n",
    "plot1.add_legend(title=\"Comment publication timestamp:\")\n",
    "fig1 = plot1.fig\n",
    "# Plot for arousal_wc\n",
    "plot2 = sns.lmplot(data=comment_phab_df, x=\"date_created\", y=\"arousal_wc\", hue=\"date_group\", col=\"meta.affil\", row='engaged_commenter', scatter=False, legend=False, palette=palette)\n",
    "plot2.set_axis_labels(\"Timestamp\", \"Count of Arousal Polarized Words\")\n",
    "plot2.set_titles(row_template=\"Author's 100+ Comment: {row_name}\",col_template=\"WMF Affiliation: {col_name}\")\n",
    "plot2.add_legend(title=\"Comment publication timestamp:\")\n",
    "#plot2.add_legend(title=\"Before/After 07/01/2013 Wide Release\")\n",
    "\n",
    "plot3 = sns.lmplot(data=comment_phab_df, x=\"date_created\", y=\"valence_wc\", hue=\"date_group\", col=\"meta.affil\", row='engaged_commenter', scatter=False, legend=False, palette=palette)\n",
    "plot3.set_axis_labels(\"Timestamp\", \"Count of Valence Polarized Words\")\n",
    "plot3.set_titles(row_template=\"Author's 100+ Comment: {row_name}\",col_template=\"WMF Affiliation: {col_name}\")\n",
    "plot3.add_legend(title=\"Comment publication timestamp:\")\n",
    "'''\n",
    "# Show plots\n",
    "#fig1.savefig('031725_engaged_commenter_D_scoring_fig.png')\n",
    "#plot2.fig.savefig('031725_engaged_commenter_A_scoring_fig.png')\n",
    "#plot3.fig.savefig('031725_engaged_commenter_V_scoring_fig.png')\n",
    "#plt.savefig('031625_engaged_commenter_VAD_scoring_fig.png')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "5a91a59a-0d1c-48b3-93dd-b9df76ca68e5",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x500 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "sns.set_context(\"talk\", font_scale=1.2)\n",
    "plot2 = sns.lmplot(data=affective_comment_phab_df, x=\"speakers_comment\", y=\"polarized_wc\", hue=\"date_group\", col=\"meta.affil\", scatter=False, legend=False, palette=palette)\n",
    "plot2.set_axis_labels(\"Comment Index\", \"Count of Polarized Words\")\n",
    "plot2.set_titles(col_template=\"WMF Affiliation: {col_name}\")\n",
    "plot2.fig.subplots_adjust(top=0.9)  # Adjust subplots to make room for the title\n",
    "#plot2.add_legend(title=\"Comment publication timestamp:\")\n",
    "plot2.fig.savefig('c3-050125_affective_language_use-slides.png')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d2d67d38-f005-4c94-be3c-39eb6b22686f",
   "metadata": {},
   "outputs": [],
   "source": [
    "#pattern = r'\\b(ve|VE|visualeditor|VisualEditor)\\b'\n",
    "#pattern = r'\\b(WMF|Foundation)\\b'\n",
    "#pattern = r'\\b(bots)\\b'\n",
    "filtered_dependencies = dependency_relations_df[dependency_relations_df['token'].str.contains(pattern, regex=True)]\n",
    "resolved_filtered_dependencies = resolved_dependency_relations_df[resolved_dependency_relations_df['token'].str.contains(pattern, regex=True)]\n",
    "\n",
    "plt.figure(figsize=(12, 8))\n",
    "gs = GridSpec(2, 1, height_ratios=[6, 6])\n",
    "\n",
    "# Main plot: Token depth by timestamp\n",
    "'''\n",
    "ax0 = plt.subplot(gs[0])\n",
    "sns.scatterplot(data=filtered_dependencies, x='timestamp', y='dependency', hue='wmfAffil', style='dependency', markers=True, s=100, ax=ax0)\n",
    "ax0.set_title('VE Depth by Timestamp w/o URLS')\n",
    "ax0.set_xlabel('')\n",
    "ax0.set_ylabel('Dependency Type')\n",
    "ax0.legend().set_visible(False)\n",
    "'''\n",
    "# Calculate the median depth over time\n",
    "filtered_dependencies['week'] = filtered_dependencies['timestamp'].dt.to_period('W').dt.start_time\n",
    "median_depth = filtered_dependencies.groupby('week')['depth'].median().reset_index()\n",
    "\n",
    "wmf_filtered_dependencies = filtered_dependencies[filtered_dependencies['wmfAffil'] == True]\n",
    "wmf_median_depth = wmf_filtered_dependencies.groupby('week')['depth'].median().reset_index()\n",
    "\n",
    "other_filtered_dependencies = filtered_dependencies[filtered_dependencies['wmfAffil'] != True]\n",
    "other_median_depth = other_filtered_dependencies.groupby('week')['depth'].median().reset_index()\n",
    "\n",
    "# Plot the median depth over time\n",
    "ax0 = plt.subplot(gs[0])\n",
    "sns.lineplot(data=median_depth, x='week', y='depth', ax=ax0, color='black', label='Median Depth', marker='o')\n",
    "sns.lineplot(data=wmf_median_depth, x='week', y='depth', ax=ax0, color='#c7756a', label='WMF-affiliated authors', marker='x')\n",
    "sns.lineplot(data=other_median_depth, x='week', y='depth', ax=ax0, color='#5da2d8', label='Nonaffiliated authors', marker='x')\n",
    "ax0.set_title('Median Depth of \"VE\" in Phabricator Sentence Dependency Trees')\n",
    "ax0.set_ylabel('Median Depth')\n",
    "ax0.set_xlabel('')\n",
    "\n",
    "# Calculate the median depth over time\n",
    "resolved_filtered_dependencies['week'] = resolved_filtered_dependencies['timestamp'].dt.to_period('W').dt.start_time\n",
    "resolved_median_depth = resolved_filtered_dependencies.groupby('week')['depth'].median().reset_index()\n",
    "\n",
    "resolved_wmf_filtered_dependencies = resolved_filtered_dependencies[resolved_filtered_dependencies['wmfAffil'] == True]\n",
    "resolved_wmf_median_depth = resolved_wmf_filtered_dependencies.groupby('week')['depth'].median().reset_index()\n",
    "\n",
    "resolved_other_filtered_dependencies = resolved_filtered_dependencies[resolved_filtered_dependencies['wmfAffil'] != True]\n",
    "resolved_other_median_depth = resolved_other_filtered_dependencies.groupby('week')['depth'].median().reset_index()\n",
    "\n",
    "# Plot the median depth over time\n",
    "ax1 = plt.subplot(gs[1])\n",
    "sns.lineplot(data=resolved_median_depth, x='week', y='depth', ax=ax1, color='black', label='Median Depth', marker='o')\n",
    "sns.lineplot(data=resolved_wmf_median_depth, x='week', y='depth', ax=ax1, color='#c7756a', label='WMF-affiliated authors', marker='x')\n",
    "sns.lineplot(data=resolved_other_median_depth, x='week', y='depth', ax=ax1, color='#5da2d8', label='Nonaffiliated authors', marker='x')\n",
    "ax1.set_title('Median Depth of \"VE\" in Coreference-resolved Phabricator Sentence Dependency Trees')\n",
    "ax1.set_ylabel('Median Depth')\n",
    "ax1.set_xlabel('')\n",
    "\n",
    "plt.tight_layout()\n",
    "#plt.show()\n",
    "\n",
    "#plt.savefig('031625_VE_depth_fig.png')"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.11.11"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}