Italian Popular TV News - Sentiment Analysis.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "0603bfef",
   "metadata": {},
   "source": [
    "## Sentiment Analysis using FEEL-IT and SENTITA classifiers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "9a39010c",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\loren\\anaconda3\\envs\\nlp_sentita\\lib\\site-packages\\tensorflow\\python\\framework\\dtypes.py:523: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
      "  _np_qint8 = np.dtype([(\"qint8\", np.int8, 1)])\n",
      "C:\\Users\\loren\\anaconda3\\envs\\nlp_sentita\\lib\\site-packages\\tensorflow\\python\\framework\\dtypes.py:524: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
      "  _np_quint8 = np.dtype([(\"quint8\", np.uint8, 1)])\n",
      "C:\\Users\\loren\\anaconda3\\envs\\nlp_sentita\\lib\\site-packages\\tensorflow\\python\\framework\\dtypes.py:525: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
      "  _np_qint16 = np.dtype([(\"qint16\", np.int16, 1)])\n",
      "C:\\Users\\loren\\anaconda3\\envs\\nlp_sentita\\lib\\site-packages\\tensorflow\\python\\framework\\dtypes.py:526: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
      "  _np_quint16 = np.dtype([(\"quint16\", np.uint16, 1)])\n",
      "C:\\Users\\loren\\anaconda3\\envs\\nlp_sentita\\lib\\site-packages\\tensorflow\\python\\framework\\dtypes.py:527: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
      "  _np_qint32 = np.dtype([(\"qint32\", np.int32, 1)])\n",
      "C:\\Users\\loren\\anaconda3\\envs\\nlp_sentita\\lib\\site-packages\\tensorflow\\python\\framework\\dtypes.py:532: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
      "  np_resource = np.dtype([(\"resource\", np.ubyte, 1)])\n",
      "Using TensorFlow backend.\n"
     ]
    }
   ],
   "source": [
    "import json\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import os\n",
    "import pandas as pd\n",
    "import random\n",
    "import spacy\n",
    "import seaborn as sns\n",
    "import time\n",
    "from feel_it import EmotionClassifier, SentimentClassifier\n",
    "from sentita import calculate_polarity"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "35845241",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Prevent the kernel from dying\n",
    "# Demand to the RAM is too high -> on my computer, a 8GB RAM is installed\n",
    "os.environ['KMP_DUPLICATE_LIB_OK']='True'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "3481aa94",
   "metadata": {},
   "outputs": [],
   "source": [
    "nlp = spacy.load('it_core_news_md')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "d8773b99",
   "metadata": {},
   "outputs": [],
   "source": [
    "sentiment_classifier = SentimentClassifier()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9e473cae",
   "metadata": {},
   "outputs": [],
   "source": [
    "#emotion_classifier = EmotionClassifier()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "85609e39",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Sentita\n",
    "\n",
    "def evaluate_chunk_sentiment_sentita(TG_chunks, pred_values):\n",
    "    '''Divide the whole sentences list into 10 chunks,\n",
    "    based on the time interval of the broadcast they belong to.\n",
    "    For every chunk, compute the negativity score\n",
    "    '''\n",
    "    pred_chunks = np.array_split(pred_values, 10)\n",
    "    pred_chunks = [arr.tolist() for arr in pred_chunks]\n",
    "    for idx, chunk in enumerate(pred_chunks):\n",
    "        TG_chunks[idx].append(round(np.mean(chunk),2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "bd6cef63",
   "metadata": {},
   "outputs": [],
   "source": [
    "# FEEL-IT\n",
    "\n",
    "def evaluate_document_sentiment(pred_values):\n",
    "    '''Determine which sentiment is prevalent\n",
    "    and to what extent\n",
    "    '''\n",
    "    if pred_values.count(0) >= pred_values.count(1):\n",
    "        doc_sentiment = 'negative'\n",
    "    else:\n",
    "        doc_sentiment = 'positive'\n",
    "    negative_degree = round(pred_values.count(0) / len(pred_values) * 100)\n",
    "    return doc_sentiment, negative_degree"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "6696fda4",
   "metadata": {},
   "outputs": [],
   "source": [
    "# FEEL-IT\n",
    "\n",
    "def evaluate_chunk_sentiment_feelit(TG_chunks, pred_values):\n",
    "    '''Divide the list containing sentences into 10 chunks,\n",
    "    based on the time interval of the broadcast they belong to.\n",
    "    For every chunk, compute the negativity score\n",
    "    '''\n",
    "    pred_chunks = np.array_split(pred_values, 10)\n",
    "    pred_chunks = [arr.tolist() for arr in pred_chunks]\n",
    "    for idx, chunk in enumerate(pred_chunks):\n",
    "        _, neg_score = evaluate_document_sentiment(chunk)\n",
    "        TG_chunks[idx].append(neg_score)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "f0fd5701",
   "metadata": {},
   "outputs": [],
   "source": [
    "# FEEL-IT\n",
    "\n",
    "def evaluate_document_emotions(pred_values):\n",
    "    ''' Count total number of sentences \n",
    "    labelled with a specific emotion\n",
    "    '''\n",
    "    anger_count = pred_values.count('anger')\n",
    "    fear_count = pred_values.count('fear') \n",
    "    joy_count = pred_values.count('joy')\n",
    "    sadness_count = pred_values.count('sadness')    \n",
    "\n",
    "    return anger_count, fear_count, joy_count, sadness_count"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "6d0eac97",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create empty lists to store day-to-day polarity detection \n",
    "# for each TV news\n",
    "TGA_scores_sentita = []\n",
    "TGB_scores_sentita = []\n",
    "TGC_scores_sentita = []\n",
    "\n",
    "TGA_scores_feelit = []\n",
    "TGB_scores_feelit = []\n",
    "TGC_scores_feelit = []"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "add5b579",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create empty lists to store polarity evolution within newscasts\n",
    "TGA_chunks_sentita = []\n",
    "TGB_chunks_sentita = []\n",
    "TGC_chunks_sentita = []\n",
    "\n",
    "TGA_chunks_feelit = []\n",
    "TGB_chunks_feelit = []\n",
    "TGC_chunks_feelit = []\n",
    "\n",
    "for i in range(10):\n",
    "    # During each iteration, add an empty list to the list named TG*_chunks_sentita or TG*_chunks_feelit\n",
    "    TGA_chunks_sentita.append([])\n",
    "    TGB_chunks_sentita.append([])\n",
    "    TGC_chunks_sentita.append([])\n",
    "    \n",
    "    TGA_chunks_feelit.append([])\n",
    "    TGB_chunks_feelit.append([])\n",
    "    TGC_chunks_feelit.append([])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "80a737a4",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create empty lists to be filled with all TV news sentences\n",
    "TGA_sents = []\n",
    "TGB_sents = []\n",
    "TGC_sents = []\n",
    "\n",
    "# Create empty lists to be filled with sentences score\n",
    "TGA_scores_sents_sentita = []\n",
    "TGB_scores_sents_sentita = []\n",
    "TGC_scores_sents_sentita = []\n",
    "\n",
    "TGA_scores_sents_feelit = []\n",
    "TGB_scores_sents_feelit = []\n",
    "TGC_scores_sents_feelit = []"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "0d0b865d",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create empty lists to compute sentences emotion scores\n",
    "# for each TV news\n",
    "TGA_anger = []\n",
    "TGA_fear = []\n",
    "TGA_joy = []\n",
    "TGA_sadness = []\n",
    "TGB_anger = []\n",
    "TGB_fear = []\n",
    "TGB_joy = []\n",
    "TGB_sadness = []\n",
    "TGC_anger = []\n",
    "TGC_fear = []\n",
    "TGC_joy = []\n",
    "TGC_sadness = []"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "8c0d7b4c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "### SENTIMENT ANALYSIS WITH SENTITA CLASSIFIER ###\n",
      "\n",
      "Now TGA20220502.json is being extracted\n",
      "Elapsed time 19.37 seconds\n",
      "\n",
      "Now TGA20220503.json is being extracted\n",
      "Elapsed time 34.94 seconds\n",
      "\n",
      "Now TGA20220504.json is being extracted\n",
      "Elapsed time 49.2 seconds\n",
      "\n",
      "Now TGA20220505.json is being extracted\n",
      "Elapsed time 62.11 seconds\n",
      "\n",
      "Now TGA20220506.json is being extracted\n",
      "Elapsed time 76.3 seconds\n",
      "\n",
      "Now TGA20220507.json is being extracted\n",
      "Elapsed time 90.2 seconds\n",
      "\n",
      "Now TGA20220508.json is being extracted\n",
      "Elapsed time 104.41 seconds\n",
      "\n",
      "Now TGB20220502.json is being extracted\n",
      "Elapsed time 119.37 seconds\n",
      "\n",
      "Now TGB20220503.json is being extracted\n",
      "Elapsed time 131.97 seconds\n",
      "\n",
      "Now TGB20220504.json is being extracted\n",
      "Elapsed time 145.6 seconds\n",
      "\n",
      "Now TGB20220505.json is being extracted\n",
      "Elapsed time 161.6 seconds\n",
      "\n",
      "Now TGB20220506.json is being extracted\n",
      "Elapsed time 176.05 seconds\n",
      "\n",
      "Now TGB20220507.json is being extracted\n",
      "Elapsed time 189.85 seconds\n",
      "\n",
      "Now TGB20220508.json is being extracted\n",
      "Elapsed time 204.46 seconds\n",
      "\n",
      "Now TGC20220502.json is being extracted\n",
      "Elapsed time 216.74 seconds\n",
      "\n",
      "Now TGC20220503.json is being extracted\n",
      "Elapsed time 227.5 seconds\n",
      "\n",
      "Now TGC20220504.json is being extracted\n",
      "Elapsed time 238.59 seconds\n",
      "\n",
      "Now TGC20220505.json is being extracted\n",
      "Elapsed time 249.55 seconds\n",
      "\n",
      "Now TGC20220506.json is being extracted\n",
      "Elapsed time 259.95 seconds\n",
      "\n",
      "Now TGC20220507.json is being extracted\n",
      "Elapsed time 272.0 seconds\n",
      "\n",
      "Now TGC20220508.json is being extracted\n",
      "Elapsed time 283.51 seconds\n",
      "\n"
     ]
    }
   ],
   "source": [
    "start = time.time()\n",
    "# Set the path where TV news transcripts are stored\n",
    "file_path = \"C:\\\\Users\\\\loren\\\\Documents\\\\Personali\\\\Università\\\\UNIMI\\\\CORSI\\\\YEAR 2\\\\Text Mining and Sentiment Analysis\\\\Trascrizioni\\\\\"\n",
    "\n",
    "print('### SENTIMENT ANALYSIS WITH SENTITA CLASSIFIER ###\\n')\n",
    "files = os.listdir(file_path)\n",
    "for idx_file,file_name in enumerate(files):\n",
    "    tv_news_name = file_name[:3]\n",
    "    with open(file_path + file_name, encoding='utf-8') as f:\n",
    "        data = json.load(f)\n",
    "        \n",
    "        print(f\"Now {file_name} is being extracted\")\n",
    "       \n",
    "        # From a transcript to a list of sentences\n",
    "        txt = data['results']['transcripts'][0]['transcript']\n",
    "        doc = nlp(txt)\n",
    "        sents = [sent.text for sent in doc.sents]\n",
    "\n",
    "        # Day-to-day polarity detection (Sentita)\n",
    "        _, sentiment_pred_sentita = calculate_polarity(sents)\n",
    "        neg_scores_sentita = [0 if pos_score>neg_score else 1 for pos_score,neg_score in sentiment_pred_sentita]\n",
    "        # Remove the hashtag, if you want to calculate the exact polarity score for each sentence\n",
    "        #neg_scores_sentita = [int(np.ceil(neg_score/(pos_score+neg_score)*100)) for pos_score,neg_score in sentiment_pred]\n",
    "\n",
    "        if tv_news_name=='TGA':\n",
    "            TGA_sents.extend(sents)\n",
    "            # Scores (Sentita)\n",
    "            TGA_scores_sentita.append(round(np.mean(neg_scores_sentita),2))\n",
    "            TGA_scores_sents_sentita.extend(neg_scores_sentita)\n",
    "            evaluate_chunk_sentiment_sentita(TGA_chunks_sentita, neg_scores_sentita)\n",
    "        elif tv_news_name=='TGB':\n",
    "            TGB_sents.extend(sents)\n",
    "            # Scores (Sentita)\n",
    "            TGB_scores_sentita.append(round(np.mean(neg_scores_sentita),2))\n",
    "            TGB_scores_sents_sentita.extend(neg_scores_sentita)\n",
    "            evaluate_chunk_sentiment_sentita(TGB_chunks_sentita, neg_scores_sentita)\n",
    "        elif tv_news_name=='TGC':\n",
    "            TGC_sents.extend(sents)\n",
    "            # Scores (Sentita)\n",
    "            TGC_scores_sentita.append(round(np.mean(neg_scores_sentita),2))\n",
    "            TGC_scores_sents_sentita.extend(neg_scores_sentita)\n",
    "            evaluate_chunk_sentiment_sentita(TGC_chunks_sentita, neg_scores_sentita)        \n",
    "\n",
    "        # Once text from all the files inside the directory have been extracted,\n",
    "        # migrate sentences saved for each TV news into distinct dataframes\n",
    "        if idx_file == len(files)-1:\n",
    "            df_A = pd.DataFrame()\n",
    "            df_A['Sentence'] = TGA_sents\n",
    "            df_A['Sentita score'] = TGA_scores_sents_sentita\n",
    "            df_B = pd.DataFrame()\n",
    "            df_B['Sentence'] = TGB_sents\n",
    "            df_B['Sentita score'] = TGB_scores_sents_sentita\n",
    "            df_C = pd.DataFrame()\n",
    "            df_C['Sentence'] = TGC_sents\n",
    "            df_C['Sentita score'] = TGC_scores_sents_sentita\n",
    "            \n",
    "        current_time = time.time()\n",
    "        print(f\"Elapsed time {round(current_time - start, 2)} seconds\\n\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "6608bb2f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "### SENTIMENT ANALYSIS WITH FEEL-IT CLASSIFIER ###\n",
      "\n",
      "Now TGA20220502.json is being extracted\n",
      "Elapsed time 136.14 seconds\n",
      "\n",
      "Now TGA20220503.json is being extracted\n",
      "Elapsed time 284.65 seconds\n",
      "\n",
      "Now TGA20220504.json is being extracted\n",
      "Elapsed time 411.84 seconds\n",
      "\n",
      "Now TGA20220505.json is being extracted\n",
      "Elapsed time 521.46 seconds\n",
      "\n",
      "Now TGA20220506.json is being extracted\n",
      "Elapsed time 665.84 seconds\n",
      "\n",
      "Now TGA20220507.json is being extracted\n",
      "Elapsed time 763.34 seconds\n",
      "\n",
      "Now TGA20220508.json is being extracted\n",
      "Elapsed time 906.26 seconds\n",
      "\n",
      "Now TGB20220502.json is being extracted\n",
      "Elapsed time 1000.0 seconds\n",
      "\n",
      "Now TGB20220503.json is being extracted\n",
      "Elapsed time 1064.95 seconds\n",
      "\n",
      "Now TGB20220504.json is being extracted\n",
      "Elapsed time 1136.88 seconds\n",
      "\n",
      "Now TGB20220505.json is being extracted\n",
      "Elapsed time 1218.84 seconds\n",
      "\n",
      "Now TGB20220506.json is being extracted\n",
      "Elapsed time 1324.14 seconds\n",
      "\n",
      "Now TGB20220507.json is being extracted\n",
      "Elapsed time 1441.0 seconds\n",
      "\n",
      "Now TGB20220508.json is being extracted\n",
      "Elapsed time 1542.88 seconds\n",
      "\n",
      "Now TGC20220502.json is being extracted\n",
      "Elapsed time 1616.73 seconds\n",
      "\n",
      "Now TGC20220503.json is being extracted\n",
      "Elapsed time 1686.36 seconds\n",
      "\n",
      "Now TGC20220504.json is being extracted\n",
      "Elapsed time 1809.4 seconds\n",
      "\n",
      "Now TGC20220505.json is being extracted\n",
      "Elapsed time 1886.7 seconds\n",
      "\n",
      "Now TGC20220506.json is being extracted\n",
      "Elapsed time 1942.35 seconds\n",
      "\n",
      "Now TGC20220507.json is being extracted\n",
      "Elapsed time 2035.65 seconds\n",
      "\n",
      "Now TGC20220508.json is being extracted\n",
      "Elapsed time 2113.84 seconds\n",
      "\n"
     ]
    }
   ],
   "source": [
    "start = time.time()\n",
    "# Set the path where TV news transcripts are stored\n",
    "file_path = \"C:\\\\Users\\\\loren\\\\Documents\\\\Personali\\\\Università\\\\UNIMI\\\\CORSI\\\\YEAR 2\\\\Text Mining and Sentiment Analysis\\\\Trascrizioni\\\\\"\n",
    "\n",
    "print('### SENTIMENT ANALYSIS WITH FEEL-IT CLASSIFIER ###\\n')\n",
    "files = os.listdir(file_path)\n",
    "for idx_file,file_name in enumerate(files):\n",
    "    tv_news_name = file_name[:3]\n",
    "    with open(file_path + file_name, encoding='utf-8') as f:\n",
    "        data = json.load(f)\n",
    "        \n",
    "        print(f\"Now {file_name} is being extracted\")\n",
    "       \n",
    "        # From a transcript to a list of sentences\n",
    "        txt = data['results']['transcripts'][0]['transcript']\n",
    "        doc = nlp(txt)\n",
    "        sents = [sent.text for sent in doc.sents]\n",
    "        \n",
    "        # Day-to-day polarity detection (FEEL-IT)\n",
    "        sentiment_pred_feelit = sentiment_classifier.predict(sents)        \n",
    "        sentiment_pred_binary = list(map(lambda sent: 1 if sent=='positive' else 0, sentiment_pred_feelit))\n",
    "\n",
    "        doc_sentiment, neg_score_feelit = evaluate_document_sentiment(sentiment_pred_binary)\n",
    "\n",
    "        if tv_news_name=='TGA':\n",
    "            # Scores (FEEL-IT)\n",
    "            TGA_scores_feelit.append(neg_score_feelit)\n",
    "            TGA_scores_sents_feelit.extend(sentiment_pred_binary)\n",
    "            evaluate_chunk_sentiment_feelit(TGA_chunks_feelit, sentiment_pred_binary)\n",
    "        elif tv_news_name=='TGB':\n",
    "            # Scores (FEEL-IT)\n",
    "            TGB_scores_feelit.append(neg_score_feelit)\n",
    "            TGB_scores_sents_feelit.extend(sentiment_pred_binary)\n",
    "            evaluate_chunk_sentiment_feelit(TGB_chunks_feelit, sentiment_pred_binary)\n",
    "        elif tv_news_name=='TGC':      \n",
    "            # Scores (FEEL-IT)\n",
    "            TGC_scores_feelit.append(neg_score_feelit)\n",
    "            TGC_scores_sents_feelit.extend(sentiment_pred_binary)\n",
    "            evaluate_chunk_sentiment_feelit(TGC_chunks_feelit, sentiment_pred_binary)\n",
    "        \n",
    "        '''\n",
    "        # One-week emotions detection (FEEL-IT)\n",
    "        emotions_pred = emotion_classifier.predict(sents)\n",
    "        \n",
    "        if tv_news_name=='TGA':\n",
    "            TGA_anger.append(evaluate_document_emotions(emotions_pred)[0])\n",
    "            TGA_fear.append(evaluate_document_emotions(emotions_pred)[1])\n",
    "            TGA_joy.append(evaluate_document_emotions(emotions_pred)[2])\n",
    "            TGA_sadness.append(evaluate_document_emotions(emotions_pred)[3])\n",
    "        elif tv_news_name=='TGB':\n",
    "            TGB_anger.append(evaluate_document_emotions(emotions_pred)[0])\n",
    "            TGB_fear.append(evaluate_document_emotions(emotions_pred)[1])\n",
    "            TGB_joy.append(evaluate_document_emotions(emotions_pred)[2])\n",
    "            TGB_sadness.append(evaluate_document_emotions(emotions_pred)[3])\n",
    "        elif tv_news_name=='TGC':\n",
    "            TGC_anger.append(evaluate_document_emotions(emotions_pred)[0])\n",
    "            TGC_fear.append(evaluate_document_emotions(emotions_pred)[1])\n",
    "            TGC_joy.append(evaluate_document_emotions(emotions_pred)[2])\n",
    "            TGC_sadness.append(evaluate_document_emotions(emotions_pred)[3]) \n",
    "        '''\n",
    "        \n",
    "        # Once text from all the files inside the directory have been extracted,\n",
    "        # migrate sentences saved for each TV news into distinct dataframes\n",
    "        if idx_file == len(files)-1:\n",
    "            df_A['FEEL-IT score'] = TGA_scores_sents_feelit\n",
    "            df_B['FEEL-IT score'] = TGB_scores_sents_feelit\n",
    "            df_C['FEEL-IT score'] = TGC_scores_sents_feelit\n",
    "            \n",
    "        current_time = time.time()\n",
    "        print(f\"Elapsed time {round(current_time - start, 2)} seconds\\n\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4c310176",
   "metadata": {},
   "source": [
    "### Visualization part"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fc84e6f2",
   "metadata": {},
   "source": [
    "### Day-to-day polarity detection"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "4f5699a6",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Convert to percentage (code could be improved elsewhere)\n",
    "TGA_scores_feelit = [score/100 for score in TGA_scores_feelit]\n",
    "TGB_scores_feelit = [score/100 for score in TGB_scores_feelit]\n",
    "TGC_scores_feelit = [score/100 for score in TGC_scores_feelit]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "dffab003",
   "metadata": {
    "collapsed": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'\\nfor idx_chunk,chunk in enumerate(TGC_chunks_feelit):\\n    for idx_score,score in enumerate(chunk):\\n        TGC_chunks_feelit[idx_chunk][idx_score] = round(score/100,2)\\n'"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Convert to percentage (code could be improved elsewhere)\n",
    "for idx_chunk,chunk in enumerate(TGA_chunks_feelit):\n",
    "    for idx_score,score in enumerate(chunk):\n",
    "        TGA_chunks_feelit[idx_chunk][idx_score] = round(score/100,2)\n",
    "\n",
    "for idx_chunk,chunk in enumerate(TGB_chunks_feelit):\n",
    "    for idx_score,score in enumerate(chunk):\n",
    "        TGB_chunks_feelit[idx_chunk][idx_score] = round(score/100,2)\n",
    "        \n",
    "for idx_chunk,chunk in enumerate(TGC_chunks_feelit):\n",
    "    for idx_score,score in enumerate(chunk):\n",
    "        TGC_chunks_feelit[idx_chunk][idx_score] = round(score/100,2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "abc6b40e",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Add one-week polarity detected for each TV news \n",
    "# to the lists of already existing day-to-day polarity scores \n",
    "TGA_scores_sentita.append(round(np.mean(TGA_scores_sentita),2))\n",
    "TGB_scores_sentita.append(round(np.mean(TGB_scores_sentita),2))\n",
    "TGC_scores_sentita.append(round(np.mean(TGC_scores_sentita),2))\n",
    "\n",
    "TGA_scores_feelit.append(round(np.mean(TGA_scores_feelit),2))\n",
    "TGB_scores_feelit.append(round(np.mean(TGB_scores_feelit),2))\n",
    "TGC_scores_feelit.append(round(np.mean(TGC_scores_feelit),2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "e3010258",
   "metadata": {},
   "outputs": [],
   "source": [
    "barplot_sentiment_index = ['2/5','3/5','4/5','5/5','6/5','7/5','8/5','OVERALL']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "id": "63ab9e77",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1152x648 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Sentita\n",
    "\n",
    "#sns.set() # call sns.reset_orig() to get back to the original background\n",
    "\n",
    "fig, ax = plt.subplots(figsize=(16,9))\n",
    "width = 0.25\n",
    "TGA_bars = ax.bar(np.arange(len(TGA_scores_sentita)) - width, TGA_scores_sentita, width=width, label='TG#1', color='mediumblue', edgecolor='darkblue', alpha=0.65)\n",
    "TGB_bars = ax.bar(barplot_sentiment_index, TGB_scores_sentita, width=width, label='TG#2', color='darkorange', edgecolor='orangered', alpha=0.6)\n",
    "TGC_bars = ax.bar(np.arange(len(TGC_scores_sentita)) + width, TGC_scores_sentita, width=width, label='TG#3', color='green', edgecolor='darkgreen', alpha=0.6)\n",
    "\n",
    "# Set plot background color\n",
    "ax.set_facecolor('#fcfcfc')\n",
    "\n",
    "# Change the color of the left and bottom spines to black\n",
    "ax.spines['left'].set_color('black')\n",
    "ax.spines['bottom'].set_color('black')\n",
    "\n",
    "# Labels\n",
    "ax.set_xlabel(\"Day of the week\", labelpad=5)\n",
    "ax.set_ylabel(\"Negativity score\", labelpad=7)\n",
    "# Tweak the axis labels\n",
    "xlab = ax.xaxis.get_label()\n",
    "ylab = ax.yaxis.get_label()\n",
    "xlab.set_size(18)\n",
    "#ylab.set_style('italic')\n",
    "ylab.set_size(18)\n",
    "\n",
    "# Ticks \n",
    "xtick = ax.set_xticks(barplot_sentiment_index)\n",
    "ax.tick_params(axis='x', which='major', labelsize=12)\n",
    "ytick = ax.set_yticks(np.arange(0.1,1.1,0.1))\n",
    "\n",
    "# Add values to bars\n",
    "'''for i in range(len(barplot_sentiment_index)):\n",
    "    plt.text(i-width,TGA_scores[i]+0.005,TGA_scores[i],ha='center')\n",
    "    plt.text(i,TGB_scores[i]+0.005,TGB_scores[i],ha='center')\n",
    "    plt.text(i+width,TGC_scores[i]+0.005,TGC_scores[i],ha='center')\n",
    "    if i==7:\n",
    "        plt.text(i-width,TGA_scores[i]+0.005,TGA_scores[i],ha='center')\n",
    "        plt.text(i,TGB_scores[i]+0.005,TGB_scores[i],ha='center')\n",
    "        plt.text(i+width,TGC_scores[i]+0.005,TGC_scores[i],ha='center')\n",
    "'''    \n",
    "for i in range(len(barplot_sentiment_index)):\n",
    "    plt.text(i-width,TGA_scores_sentita[i]-0.02,TGA_scores_sentita[i],color='white',fontweight='bold',ha='center')\n",
    "    plt.text(i,TGB_scores_sentita[i]-0.02,TGB_scores_sentita[i],color='white',fontweight='bold',ha='center')\n",
    "    plt.text(i+width,TGC_scores_sentita[i]-0.02,TGC_scores_sentita[i],color='white',fontweight='bold',ha='center')\n",
    "    if i==7:\n",
    "        plt.text(i-width,TGA_scores_sentita[i]-0.02,TGA_scores_sentita[i],color='white',fontweight='bold',ha='center')\n",
    "        plt.text(i,TGB_scores_sentita[i]-0.02,TGB_scores_sentita[i],color='white',fontweight='bold',ha='center')\n",
    "        plt.text(i+width,TGC_scores_sentita[i]-0.02,TGC_scores_sentita[i],color='white',fontweight='bold',ha='center')  \n",
    "\n",
    "# Title\n",
    "ttl = ax.set_title('Day-to-day Polarity Detection using Sentita Classifier', pad=10)\n",
    "ttl.set_weight('bold')\n",
    "ttl.set_size(16)\n",
    "ax.legend(fontsize=14, loc='upper left')\n",
    "ax.grid(axis='y')\n",
    "ax.set_axisbelow(True)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "id": "8849eaeb",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1152x648 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# FEEL-IT\n",
    "\n",
    "#sns.set() # call sns.reset_orig() to get back to the original background\n",
    "\n",
    "fig, ax = plt.subplots(figsize=(16,9))\n",
    "width = 0.25\n",
    "TGA_bars = ax.bar(np.arange(len(TGA_scores_feelit)) - width, TGA_scores_feelit, width=width, label='TG#1', color='mediumblue', edgecolor='darkblue', alpha=0.65)\n",
    "TGB_bars = ax.bar(barplot_sentiment_index, TGB_scores_feelit, width=width, label='TG#2', color='darkorange', edgecolor='orangered', alpha=0.6)\n",
    "TGC_bars = ax.bar(np.arange(len(TGC_scores_feelit)) + width, TGC_scores_feelit, width=width, label='TG#3', color='green', edgecolor='darkgreen', alpha=0.6)\n",
    "\n",
    "# Set plot background color\n",
    "ax.set_facecolor('#fcfcfc')\n",
    "\n",
    "# Change the color of the left and bottom spines to black\n",
    "ax.spines['left'].set_color('black')\n",
    "ax.spines['bottom'].set_color('black')\n",
    "\n",
    "# Labels\n",
    "ax.set_xlabel(\"Day of the week\", labelpad=5)\n",
    "ax.set_ylabel(\"Negativity score\", labelpad=7)\n",
    "# Tweak the axis labels\n",
    "xlab = ax.xaxis.get_label()\n",
    "ylab = ax.yaxis.get_label()\n",
    "xlab.set_size(18)\n",
    "#ylab.set_style('italic')\n",
    "ylab.set_size(18)\n",
    "\n",
    "# Ticks \n",
    "xtick = ax.set_xticks(barplot_sentiment_index)\n",
    "ax.tick_params(axis='x', which='major', labelsize=12)\n",
    "ytick = ax.set_yticks(np.arange(0.1,1.1,0.1))\n",
    "\n",
    "# Add values to bars\n",
    "for i in range(len(barplot_sentiment_index)):\n",
    "    plt.text(i-width,TGA_scores_feelit[i]-0.02,TGA_scores_feelit[i],color='white',fontweight='bold',ha='center')\n",
    "    plt.text(i,TGB_scores_feelit[i]-0.02,TGB_scores_feelit[i],color='white',fontweight='bold',ha='center')\n",
    "    plt.text(i+width,TGC_scores_feelit[i]-0.02,TGC_scores_feelit[i],color='white',fontweight='bold',ha='center')\n",
    "    if i==7:\n",
    "        plt.text(i-width,TGA_scores_feelit[i]-0.02,TGA_scores_feelit[i],color='white',fontweight='bold',ha='center')\n",
    "        plt.text(i,TGB_scores_feelit[i]-0.02,TGB_scores_feelit[i],color='white',fontweight='bold',ha='center')\n",
    "        plt.text(i+width,TGC_scores_feelit[i]-0.02,TGC_scores_feelit[i],color='white',fontweight='bold',ha='center')  \n",
    "\n",
    "# Title\n",
    "ttl = ax.set_title('Day-to-day Polarity Detection using FEEL-IT Classifier', pad=10)\n",
    "ttl.set_weight('bold')\n",
    "ttl.set_size(16)\n",
    "ax.legend(fontsize=14, loc='upper left')\n",
    "ax.grid(axis='y')\n",
    "ax.set_axisbelow(True)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d4670f3d",
   "metadata": {},
   "source": [
    "### Polarity evolution within newscasts"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "040d2d58",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Sentita\n",
    "\n",
    "TGA_chunks_avg_score = []\n",
    "TGB_chunks_avg_score = []\n",
    "TGC_chunks_avg_score = []\n",
    "\n",
    "TGA_chunks_std_error = []\n",
    "TGB_chunks_std_error = []\n",
    "TGC_chunks_std_error = []\n",
    "\n",
    "for chunks_list in [TGA_chunks_sentita,TGB_chunks_sentita,TGC_chunks_sentita]:  \n",
    "    for chunk_scores in chunks_list: \n",
    "        if chunks_list == TGA_chunks_sentita:\n",
    "            # Compute chunk mean score\n",
    "            avg_score = np.mean(chunk_scores)\n",
    "            TGA_chunks_avg_score.append(avg_score)\n",
    "            # Compute chunk standard error\n",
    "            std_error = round(np.std(chunk_scores),2)\n",
    "            TGA_chunks_std_error.append(std_error)\n",
    "        elif chunks_list == TGB_chunks_sentita:\n",
    "            # Compute chunk mean score\n",
    "            avg_score = np.mean(chunk_scores)\n",
    "            TGB_chunks_avg_score.append(avg_score)\n",
    "            # Compute chunk standard error\n",
    "            std_error = round(np.std(chunk_scores),2)\n",
    "            TGB_chunks_std_error.append(std_error)\n",
    "        elif chunks_list == TGC_chunks_sentita:\n",
    "            # Compute chunk mean score\n",
    "            avg_score = np.mean(chunk_scores)\n",
    "            TGC_chunks_avg_score.append(avg_score)\n",
    "            # Compute chunk standard error\n",
    "            std_error = round(np.std(chunk_scores),2)\n",
    "            TGC_chunks_std_error.append(std_error)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "f5815cab",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1152x648 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Sentita\n",
    "\n",
    "%matplotlib inline\n",
    "fig, ax = plt.subplots(figsize=(16,9))\n",
    "\n",
    "ax.plot(np.arange(1,11,1), TGA_chunks_avg_score, label='TG#1', color='mediumblue', marker='o')\n",
    "ax.errorbar(np.arange(1,11), TGA_chunks_avg_score, yerr=TGA_chunks_std_error, capsize=4, alpha=0.5)\n",
    "ax.plot(np.arange(1,11,1), TGB_chunks_avg_score, label='TG#2', color='orangered', marker='o')\n",
    "ax.errorbar(np.arange(1,11), TGB_chunks_avg_score, yerr=TGB_chunks_std_error, capsize=4, alpha=0.5)\n",
    "ax.plot(np.arange(1,11,1), TGC_chunks_avg_score, label='TG#3', color='green', marker='o')\n",
    "ax.errorbar(np.arange(1,11), TGC_chunks_avg_score, yerr=TGC_chunks_std_error, capsize=4, alpha=0.5)\n",
    "\n",
    "# Set plot background color\n",
    "ax.set_facecolor('#fcfcfc')\n",
    "\n",
    "# Change the color of the left and bottom spines to black\n",
    "ax.spines['left'].set_color('black')\n",
    "ax.spines['bottom'].set_color('black')\n",
    "\n",
    "# Labels\n",
    "ax.set_xlabel(\"Time slot\", labelpad=5)\n",
    "ax.set_ylabel(\"Negativity score\", labelpad=7)\n",
    "# Tweak the axis labels\n",
    "xlab = ax.xaxis.get_label()\n",
    "ylab = ax.yaxis.get_label()\n",
    "xlab.set_size(18)\n",
    "#ylab.set_style('italic')\n",
    "ylab.set_size(18)\n",
    "\n",
    "# Ticks\n",
    "xtick = ax.set_xticks(np.arange(1,11,1))\n",
    "ytick = ax.set_yticks(np.arange(0,1.1,0.1))\n",
    "\n",
    "# Add values to bars\n",
    "for i in np.arange(0,10):\n",
    "    plt.text(i+0.7,round(TGA_chunks_avg_score[i],2)+0.01,round(TGA_chunks_avg_score[i],2),color='blue')\n",
    "    plt.text(i+0.7,round(TGB_chunks_avg_score[i],2)+0.02,round(TGB_chunks_avg_score[i],2),color='orangered')\n",
    "    plt.text(i+0.7,round(TGC_chunks_avg_score[i],2)+0.01,round(TGC_chunks_avg_score[i],2),color='darkgreen')\n",
    "    \n",
    "# Title\n",
    "ttl = ax.set_title('Polarity Evolution within Newscasts using Sentita Classifier', pad=10)\n",
    "ttl.set_weight('bold')\n",
    "ttl.set_size(16)\n",
    "\n",
    "plt.legend(fontsize=14, loc='lower left')\n",
    "plt.grid(axis='y')\n",
    "ax.set_axisbelow(True)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "id": "eb8c13a6",
   "metadata": {},
   "outputs": [],
   "source": [
    "# FEEL-IT\n",
    "\n",
    "TGA_chunks_avg_score = []\n",
    "TGB_chunks_avg_score = []\n",
    "TGC_chunks_avg_score = []\n",
    "\n",
    "TGA_chunks_std_error = []\n",
    "TGB_chunks_std_error = []\n",
    "TGC_chunks_std_error = []\n",
    "\n",
    "for chunks_list in [TGA_chunks_feelit,TGB_chunks_feelit,TGC_chunks_feelit]:  \n",
    "    for chunk_scores in chunks_list: \n",
    "        if chunks_list == TGA_chunks_feelit:\n",
    "            # Compute chunk mean score\n",
    "            avg_score = np.mean(chunk_scores)\n",
    "            TGA_chunks_avg_score.append(avg_score)\n",
    "            # Compute chunk standard error\n",
    "            std_error = round(np.std(chunk_scores),2)\n",
    "            TGA_chunks_std_error.append(std_error)\n",
    "        elif chunks_list == TGB_chunks_feelit:\n",
    "            # Compute chunk mean score\n",
    "            avg_score = np.mean(chunk_scores)\n",
    "            TGB_chunks_avg_score.append(avg_score)\n",
    "            # Compute chunk standard error\n",
    "            std_error = round(np.std(chunk_scores),2)\n",
    "            TGB_chunks_std_error.append(std_error)\n",
    "        elif chunks_list == TGC_chunks_feelit:\n",
    "            # Compute chunk mean score\n",
    "            avg_score = np.mean(chunk_scores)\n",
    "            TGC_chunks_avg_score.append(avg_score)\n",
    "            # Compute chunk standard error\n",
    "            std_error = round(np.std(chunk_scores),2)\n",
    "            TGC_chunks_std_error.append(std_error)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "id": "43302020",
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAA7sAAAI1CAYAAAAXV+3qAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8QVMy6AAAACXBIWXMAAAsTAAALEwEAmpwYAAD/iUlEQVR4nOzdeVxU5f7A8c8zDPu+iKKACG6A+55LqWkuZS6ZGd1MzdI2LVvs3vabLbdft7JVLcvKcLltaiaamqbmvm+oICi4oCjbsDPn+f1xBhgUFRUYwOf9es0LOOfMme8cZs7M9zzP832ElBJFURRFURRFURRFqUsMtg5AURRFURRFURRFUSqbSnYVRVEURVEURVGUOkclu4qiKIqiKIqiKEqdo5JdRVEURVEURVEUpc5Rya6iKIqiKIqiKIpS56hkV1EURVEURVEURalzVLKrKDWYEOJ1IYS86GYWQpwTQiwVQvS6gX0nWvaXWIkhW+9/rlXMIVbLn7Y8r6er4DF7l3O8rG+Jlf2Y5cRQ/Fhrb2Aflz1GQoixVo8x9gZCtZnyjpEQIsTynF8XQvQu5z5ri+9Xgf1bvw5er+TYrd+TmhCi9UXrz1Q0zpuN1f93rK1juZqL/s+9bRhHhc9p1bTt2ut8HtbnrbmWZWuvEkPJrYKP0UcIsUAIcUIIkSeEOC+E2CmEeEsI0diyTcjFcdjS5T6HhRBdhBBrhBAXrOIdVhfO/4pS3Yy2DkBRlGtmAPyAu4DBQoiRUspfbBzTtXgaaAwcBz6yaSQ119PcfMcoBHjN6u+1tgnjmgjgDWCErQOpJYr/v+uAuTaMQ6lDhBAC+ByYdNEqR8AHaA+co5acSy3PZzHQwNaxKEpdoFp2FaX2eENKKQBPYKZlmQH4r+1CupQQwglASjlWSikst0QbhLLO6vGLbyE2iKNSSSnnWj2fubaO53pYxd+7iva/1uoxXq+Kx7AyTAjRvoofQ6lmUsrXrV5Da20dj8W1nNOqattKI6Xsbf2Y6Bf3ijW5aN2VvEZpopsOPAR4A85AV2AWUFS50VcOKWVIOce7IaWJ7h+Ag2WbX6vy/F/82a0odY1KdhWllpFSZgIvWS1qIoTwK/7D0s1poxAiSwiRL4SIF0J8ZL3N5Qgh2gkhfhZCxAkhMoUQhZZumT8LITpdtK11N+VeQogfhRAZwKFy1ocUd4VDb7EEaGzdZc7SRav472kXPdZ/rdbdcp2Hznp/1o/14kXr/mO1rq9lmVEI8YylS1y2pYvcQSHEv4UQrhV4vMt16b6mY2S5z2W7sVX0f2/ddU4I0VUI8acQIsfS/e89IYTDVZ7P01Yx9Lcsc7Y8phRCfGC17R+WZdlCCHvLsjJdIi3dCf+0eojXrLZ5vZzHD7W8JrMsr8+vhBAeVuvL7cYsynabbCmEWHK5fVSQGb1195IYy4nZSQjxshBin+VYZwshtgkhxlttYxB610sphNhotfxNUTqEwcuyrIfVc/mXZZmfEOIzIcQxy2NkCiEOCyHmCyFaWO1PCCEeFkJsEEJkWP5viUKIH6y2uV0I8ZtluUkIUSCESBJCzBNCNL3oubW1/D9OWvZV3H10lhDCvvg1a3WX28p5DVQo9ssc23K7HF9h+QghxHqhDwfJt/z//xJCPFuB+5bELYQYbPkf5gr9vfaCEKJMYmbZZo/QzxmHhRAPirLv+94o100I4QO8YLVonJTyOyllupQyT0q5VUo5idILxJfbz31CP1clWV5/+ZbX4kwhRP2Ltu0thFhhed0UWF5Hm4UQ71pt4yyEeMfyPzdZ3u/HhBA/CSG6WW1Xphuz0M9XyVYP1x8oEKWfEVc6/0dZXsfF7+kjQu/C7XLRdtav4WFCiN1CiAKgzGehotQZUkp1Uzd1q6E39C/R0nJ73Wq5n9VyCfhZls+6aLn1LRFoYLWPxOLlVstGX+H+2UC41bZzrdalWj9OOetDgN5Xic0AxFv+jgeEZT8COGFZfuAqx8v6MdZeYTsjcMay3R6r5cWtCxI4ZvnbDvj9CrHvAFyt9nHJ4198LC63/GrHyHKfsVbLxlrt63r+9zlAXjnbv3yV49zGatt/l3Pst1kdZ5Nl2YrLHaOLjsPFt9ct26y1WnamnO2+uszrwPp9Y72PtCvto4LvyW+tfu9oWV8Sm9V9XIDNV3iOn1pt+7NlWT7gXE7cd1qW/dNq2S2WZcuu8Bh3Wb3G/3e57aziePEK+zpL6TnHBb2L6OW2daPsa/bi29qKxl7B/0nvKy1Hb+kzX+Zxtldgn8XLMgCtnH3846LXYVE525wsb983ck6rKdteYR/Wr4G5l9km0WqbkAru916r+xypwPYh5cWBngxf7vUXi966ChCMft4sb7tUq/19doX9PVnOcy4+v79+hfuFcPnz/ydXuN82LOeSi17DFyj7Xni9Isdc3dSttt1Uy66i1DJCb31602rRMSllqhCiO/CoZdlxoB36eKVvLMsaA/++yu53AgOAAPTxTh7AY5Z1LsDEy9wvE7gFvdvY4PI2kJaupZR2VTsurbrMSSk19A9sgFDgDsvvPYEgy+9fXiV+a9atR8W3jyyxFAHzLNu1EUJEWn7vgf5lBvQvQhL9AsAgy7JdQBh6F7MVlmUdgCnXENdlXe0YXe5+N/C/dwYWoF88udtq+YNXCXUfeoID0OuinxrQXgjhBnQEilu+11xuZ1LKsUAfq0VvyCt3Q96D/hrtip4UAvzj4la1q9haCfvYBvxm+f1K763JlscBeBI9AawHLLIse0II0cHye/FxcgC6CL2VvQv6cYXS43yr5WeWJQ7rZT+jD3fwQL8w8SylrUX3AiMtv59Ef5+5AU3Rxx8X+8Oyv/qAPfrr6S3LunrAPyy/h6O/fkBvYXOyrO8JvAMUSUvXS6t9W3eb7X0NsVeGnpT2arsF/TgHAkOA+dewHw/05+eN/j8tZv3eeQv9YhnoXW09gfvRu6lej8ue06px25qmidXvh25gP9Ho71E/9Nd7fUrPny0o/VzrjH7eBP2zwRH9PNIPPcEtVvx63oz+fnAFWgKPXylOy/nO+jl9a/VeSSzvPpaW4uLX4Fz0zycX4HnLsk6Ufo5b8wZ+QH89eqHG0St1lEp2FaX2eE3oXQEzKB2fJCntwnWX1bYzpJR7pJRpwFTLdnCZRNTKGeB29C/c6ehJ7BdW6y/XnfBlKeVmqXcbO1iRJ3MZcyyPCaXPcbTlZz7w/Q3s+2JfW/1+/0U/NUo/+O+02u5NKeUxKWUKYN3V+mrHtapd7//eDEyRUp6XUi4FzluWN77Sg1kuAqy1/NlV6N2Ti7/c/YL+Bf8Wq2VwhWT3OjwrpTwjpdwK7Lcsc0T/glqd+4DSokuDhRBdLrPNEKvfP0Vv7T4HjLJaXnxxx/o49aT0y/Uv6P/LXkIIO6C7ZZv1los3AAmWn7cALwP3oCdzH0kpd1vWWV/UeElK+YeUMltKGX/RhYWT6O+Hvy3xXqDs8Inic0ESpeMhR6O/L/oCKVLKf0kp8y45GuWrSOyVIcHq9xfRL1S1B7ZIKa+l/kEK8KqUMh29hb9YYwBL19Hi7qoXgLeklJlSygXox1SpWU4DT6Ff0MxB//+Os1pf/Hq3fv1MQr8YcwtwWEr5mtW64u3CgVeAB9AvGM2RUq6u5Nitzy9j0T/Hc4D/s1p+B5fKACZJKU9LKTMul0wrSm2nkl1FqX2Kux/9DtwupfzJsrye1TYnSjbWv4wVJ5D+V9n3IvTkOZzSq9fWylsG+heEGyalzKI0CR0ihAimtBXqVynl+fLvWa7yiq48bfVYB4Etlj/vF0IY0Vu9AFZJKYuPYbnHlbLFVK52XC+nsiriX+//PkVKmWH1d7blp2MFHrM4KSsuAtMNvev3QsvyWylNdjPQew1UlsNWv2db/X4tBVYqYx9IKXeiV06Fy7fuVuT14WvZ30H0L6ugt+IWt+QuRm8R6oT+5bp4fLF1cvwI+vMKQG/V+QbYDhwTQrSzbGOdzJd7YUoIYQBWo7cGhVH+68HZEu9Z9C/9qei9HN5Afw0ctYyLreg46IrEfq3Ke3/9gl65Nx8Yip4QLAVOCyE+vYZ9x0spzZbfy3v9+FD6Heuk1bZQ9jxyLa54TqumbS/rorHI1TUm2Tr5DL+eHQghPIEN6L0VgtBbdi9W/HrfiZ68ZqF3734bvTdCktDHrRe/5qai97jwRO/ZMRv9IsdJIUR5ieeNqPD55SKHpZQ5lRyLotQ4KtlVlNqjuGunQUrpK6W8U0r5p9X6c1a/F3fFRegFbYq/cJ693M6FEN7oXZhBv6odid5C16YCseVWYJti8irrP0ZvWbUDvqP0g/xaujBXVHE3tVD01qTipNG61bfc43rR75c9rhb5Vr9bJ1Ohl9n+asfoYtf7vy+8gce1fu1NRu8Kux74y7LsNvRu4QB/XfRlvzwVfmwppXXc13qsKm0fVl6z7GMApV16rVkf+8ByEgtB2SI7ay0/u6N/oYbSY+tAafdEsPo/SCm3SClboneDHITecmlCb238j2WzFKv7Xi45aANEWH4/gD5W0EDZVuESUso56F0nW6O3yH5sWdUTeOIyj3HxPioS++VU+P0ldU+gd+Hsit7teDn6+eYJUfECeCWvH0tPh4tdoLTreYDlAkKxoHK2V67Pako/f5oJIYaWt5FVElqePpR+zqwGAizvycnlbSylnI7+Pu+A3puhuLDbcCwXTKWUcVLKLuhdhPujTyd32nK/T6hc1ueXBy5zfimv18m1fG4rSq2lkl1FqTt+s/p9shCitSXZeR+9KA3oRWAup7iQSvHvmegfzG9e9h7Xp7h11k8I0ejilVLKBGCJ5c/bLD+PUbndYIvNp/QDv7iL5gXgV6ttrI/rS0KIJpbqnO9aLb/ScYWyrcBDACxfyi73xfqKx6gcN/q/v2ZSysPoXV1BT3BA71KbAhxFT3S8Lcsr8r+zbrUPF1epCF2TSCn3oLcYQukYTWvW/585QohmQq/O3FwI8Q8hxAbKdh0vPl7u6F+Uky1dDNdblhd3W0wDdhffyVJ5dQh69/Q16D010iyriy+CFL+3AN4SetVlF0ul11csy62naclHTzqD0YtilSH0Ksrvo7+Wz6K3ki622sT6olBJN3nLxTXr/VQk9ssp7/3VFT35uDje24Re7b05cAT4Edh0mXivm6XFbLPlTz/gOSGEuxBiNKVd0GsjHyHEwHJuRll2urlqmbZJSnkB/TxX7BvLe8rT8h7rLISYxaVz8Fqzfr3nAdmWOg5PXbyhECJCCPEG0Ba9hf4XYJXVJsGW7Z4XQtyHfvFlPXpvh1PW21Qi6/PLdKFXancSQgQJIQYJIaLRu1Erys1J1oAqWeqmbupW/o3LVGO+wvY3Wo35j3Lud8Tq97VW2861Wh5STizlrkcfs3jxY8y96L63XrT+pQoer95XeP7FN6+L7vP9Res/uWh9ZVRjDkNvCSpel2n5mX2tx4jKrcaceNFzLV4uK3i8Lz52zS3Lv7poeZuL7lfeMXKi/Kq+vS3r15YXG2UrFYeU8zp4vbxtr7aPCr4nrauqtuKi6rxW61zQuzRe6XVp/f8Pu2hdtGV54EXLf74otrgr7P8jyzZXrcaM3v33YDnrrc8Fcy8T08W3YVbx/VbO+tcrGvsV/ide6BepirfP4tL3V/Hr6B9XeBwT0Kic/3PvK712L1pufT7tTfnVmE9Z/X7bNZzT1l7Dtpe7eVXltleIbezFr51ytkm02uaK78OL7mdA7/lzpfietmwbcnEc6BflzpZzH+vXe/HrtOcVHsMMdLBst+oK2/16pXNxeTFe5jhan/8/v8rzt962Qq8ndVO3unJTLbuKUodIKSeiF9XYhP7FrRC9VXQG0ElKeeYKdwf9i+BC9BaVDPSKxfdVcpivo1cAPne5DaSUf1E6DthMaXfjqvD1lf6Wevfbu9ELkexCL/yRjz5+8k3gVillNlcgpYxHb2Xah95ycBq9Kuf/LnOX17nKMSrnMW70f389rFtsz0opj1h+X2+1PBX9eV+R1AsZ3Yd+8aDWjSOTUu7nMv9Pqbfy3YreVX4P+vPLRf///AKMp7TVp/j1Yt1aucGyPBn9y3Gxi1vMP7UsOwUUoL/WDqB3s37esg+JXhjrEWAj+oWXAvRWqgWWbYrQX/PL0RPHVPSuyeV160wDPkRP5lPR369Z6OMTo6SUv1pt+xT6haO0cvZz1dgvR+pj0+9Er7Cdi96C/IolrovtQD+fHEI/x5ktcf+GntSeLOc+10XqrZpD0V//BejJ00OUHb9+LXUIlHJIKTUp5SPovSD+h97jpIDSng/vUNrzorz7p6F3nd+A/t48hX4OfreczY+hF23cY9m/2fJzDTBI6mN6QS9a9jt6JfE89PNxHPABV692f82klI+jf36vQ39dF1oe+0/0IRLLK/sxFaW2KJ7HUlEUpcYQQriif5kIA36RUo6wcUiKoijXxFKlvA/wp7SMERdCDEQfJuGIftErUOrTrimKoihVQCW7iqLUGJbxqavRK7J6oHcB7Gp1tVxRFKVWsMw1nYXeypaCPgbb07K6CLhHSrnkMndXFEVRKoHqxqwoSk1ijz6foSsQC9ynEl1FUWqpfPTurMfRpyJyRu8uPg/orBJdRVGUqqdadhVFURRFURRFUZQ6R7XsKoqiKIqiKIqiKHWOSnYVRVEURVEURVGUOkclu4qiKIqiKIqiKEqdo5JdRVEURVEURVEUpc5Rya6iKIqiKIqiKIpS56hkV1EURVEURVEURalzjLYOoCr5+fnJkJAQW4ehKIqiKIqiKIqiVIEdO3akSinrlbeuRiS7QoivgbuAs1LKVuWsF8AMYDCQA4yVUu682n5DQkLYsmVLZYerKIqiKIqiKIqi1ABGo/H45dbVlG7Mc4GBV1g/CGhmuT0KfFENMSmKoiiKoiiKoii1VI1IdqWUfwEXrrDJUOA7qdsMeAkhAqonOkVRFEVRFEVRFKW2qRHJbgU0ApKs/k62LFMURVEURVEURVGUS9SIMbsVIMpZJsvdUIhH0bs6U79+fdavX1+VcSmKoiiKoiiKoig1UG1JdpOBIKu/A4FT5W0opZwNzAbo1KmT7NWrV9VHpyiKoiiKoiiKotQotaUb8xJgjNB1AzKklKdtHZSiKIqiKIqiKIpSM9WIll0hxHygN+AnhEgGXgPsAaSUM4Hf0acdikOfemicbSJVFEVRFEVRFEVRaoMakexKKe+/ynoJPFFN4SiKoiiKoiiKoii1XG3pxqwoiqIoiqIoiqIoFaaSXUVRFEVRFEVRFKXOUcmuoiiKoiiKoiiKUueoZFdRFEVRFEVRFEWpc1SyqyiKoiiKoiiKotQ5KtlVFEVRFEVRFEVR6hyV7CqKoiiKoiiKoih1jkp2FUVRFEVRFEVRlDrHaOsAFEVRFEW5ySRuQBzfAIA4sw8A2aB1yWrZuCeE9LRJaIqiKErdoZJdRVEURVGqV0hPZHEyuycaANk2yoYBKYqiKHWRSnYVRVFquG1ntrE9ZTsAh9MOA9DCu0XJ+k71O9G5QWebxKYoiqIoilJTqWRXURSlhuvcoHNJMrs4fjEAQ8OG2jIkRVEURalW6sKvcj1UsqsoiqIoiqIoSo2mLvwq10NVY1YURVEURVEURVHqHNWyqyiKoiiKoijXSXWvVZSaSyW7iqIoiqIoinKdVPdaRam5VLKrKIqiKMXU/K9KXaJez4qi3ORUsqsoiqIoxdT8r0pdol7PiqLc5FSBKkVRFEVRFEVRFKXOUS27iqIoiqIoinK9rLqLhyeuBkAkHypZrbqLK4rtqGS3uqnxM4qiKIqiKHWHVXfxWJkBQPPbXrRlRIqiWKhkt7qp8TOKoig3bnsMhplTQTMjB45HjppWdn1WGoYPJ8DpY+DgiPbMVxDSCgDxwQTE1mXg5Y82c48NglcURanbYg7EMHXRVMyamfE9xjNtYNlzdFp2GhO+m8Cx1GM4Gh35asxXtGrUiqQLSYydO5aUzBQMwsCEnhOYfPtkGz0LpS5Qya6iKNdP9VRQbMFsxvDZZLS3Y8AvEMOUbsiuQ6BxRMkmYuE7yLC2yFd/gqRYDJ89hfbuHwDI/mOQdz+O4f1xtnoGiqIodZZZMzN5/mRipsQQ6B1It3e6MaTNECIalp6j34l5h7ZBbfnpsZ+IPRPLU/Of4o9n/sBoZ+T/Rv4fHYI7kJWXRZe3u9AvvF+Z+yrKtVDJrlI3qSSseqieCootHNkKDcMgIBQAedsoxOYlSOtk98QhtOLW3qCWkHIc0lLAuz60vhVSEm0QuKIoSt23NXErYf5hhNbTz9GjOo9iyd4lZRLWQ6cPlbT2tmzQkuPnj5OSmUKAZwABngEAuDu507JBS06mn1TJrnLdVLKr1E0qCVOUuiv1FLJeUOnffoFweGuZTWRoG8TfvyBb9dTXnT0Oqcl6sqsoiqJUmVNppwjyLj1HB3oFsjWh7Dm6TWAbftn1Cz2b9mRrwlaOXzhOcloy9T1Kz9GJqYnsTtpN1yZdqy12pe5RUw8piqIotYwsZ5kou8W908CUjuGJjogln0FYe7BT13cVRVGqmiznHC1E2XP0tAHTSM9Jp+P0jny29jPaB7XHaHWONuWZGDV7FB+M+gAPZ48qj1mpu9Qnv6IoilK7+DVCnEsq/TqVmgy+AWW3cfVATp2jbyMlYmxTqN+keuNUFKXGud7CSQATvpvAsn3L8Hf3Z8+rqrjd5TTybkRSWlLJ38npyQR4lT1Hezh7MOehOQBIKWn6UlOa+Orn6EJzIffOvpf7u9zP8PbDqy9wpU5Sya6iKEpNp+ZwLKt5ZzgVB2cSwLcRYt0itGnfl93GlA6OLmDvgIiZg2zdC1xV64Ci3MxupHASwJhbxvB478cZN1cVt7uSzo07E3c2joTUBBp5NWLRtkV8/3DZc3R6TjouDi44GB2Ys2EOvZr1wsPZAyklj3z3COENwnmm3zM2egZKXaKSXUVRlJpOzeFYlp0R7bEZGF4eDGYz8o6x0DgSsWwWAPLOiZB0SK+2bLCD4HC0p78subt49wHE3nWQmYrhH42RD76GHDDeRk9GUZTqciOFk+p71OfWZreSmJpoi9BrFaOdkRn3zWDwx4Mxa2bGdh9LZMNIZv2ln6Mn3jqRQ2cOMe6bcdgZ7AgPCOfLB/Vz9Mb4jczbMo/WjVrTcXpHAN4c+iaDWw+22fNRajeV7CqKoii1T5fBaF3KfvmRd04s/SP8FrQ5seXeVb74Q7mjfpXqs/nYebYkXADglOXf1DD1aMn6rk186Bbqa4vQlDqssgonKVc3uPXgSxLUibeWnqNvCb2F2DcvPUf3bNqToplFVR6fcvNQya6iKIqiKNXKzuUYDn7bAUjxiQEgxC/Dan0nQCW7SuWqaOGkZxY9Q8fpHWnVqNUlhZMURald1LtXURRFUZRq1blBZzo36AxAwVG9deexto/ZMiTlJnCjhZMURal91NRDiqIoiqIoSp1nXTipoKiARdsWMaTNkDLbpOekU1BUAFCmcJJSc0Tvj2bi4omMnD+S0E9Cid4fbeuQlBpMtewqiqIoiqIodd6NFE4CeOCrB1h3ZB2pplQav9iY14a8xvgeqrhddYreH82kZZPIKcwB4ETGCSYtmwRAVKsoW4am1FAq2VUURVEURVFuCtdbOAnghwk/VGlsdZVZM5NdmE1mfiZZBVlkFWRhKjCRXZiNqdBETkEO2YXZ5BTmkFOUQ25RLrmFueSac8kvyie3SP+Zb85n/9n9ODo64ujkiNlsJisni5zCHF7+82WV7CrlUsmuoiiKoiiKotyg6P3RPLttFqn5mQTtW8j0PtNrdAJm1sxk5WeRWaAnoaZCE1kFWSXJZ3ECml2YTW5Rrp6IFuaWJJ955rzSn+Z8CswFFJgLKDQXUqiV3szSfF3x2Qk77A32JTcHOweKZBFSSqSUONo7ggtk5mSSlJF09R0qNyWV7CqKolSimAMxTF00FbNmZnyP8SXzNRbLyM1gzNdjSLqQRJFWxNT+UxnbfSwAH6/+mDkb5yCl5OGeDzPl9ik2eAaKoijKtarM7rWF5kJMBabSJLTAhKnQRHZBNqYCU9kEtDCn5GdJ8lmUV5KA5pvzyS/Kp1Ar1BNRqyRUk9p1PVejMGJvZ49RGHGwc8Dezh4HgwNOdk54OHjgaOeIk9Gp5OZsdMbJ6ISL0QUXexdc7V1xsXfB2d4ZN3s33Bz0m7u9O+4O7rg7uuNq74qdwe6Sxw79JJQTGScAcHZ0xt3ZnSJzEX5Oftf1XJRLbTuzje0perX8w2mHAWjh3aJkfaf6nUoKDNYGKtlVFEWpJGbNzOT5k4mZEkOgdyDd3unGkDZDiGgYUbLN52s/JzwgnMVPLOZc1jkiXosgqksUR1KOMGfjHDa9uAkHOwcGfzKYwa0G06x+Mxs+o5uXWBON+PIZSD+P8H8Z+dB0ZN+a20KjKIptvfzny+QU5mC0M2K0M5ZMafTs6mdZdXyVnoAWJ6GWLrnFyWelJKESjAY9CbUX9noCaueAg50DzvbOeBm8cDRaklA7J5zs9Z/ORmdc7F1KEtHiZNTV3lVPQB30BNTV3hUPRw9c7V0xGGxX33Z6n+klFxVy83Oxt7PH1cmVQc0G2Symusa6Wv7i+MUADA0basuQbohKdhVFuW6bj51nS8IFAE5Zhjg1TD1asr5rEx+6hd48c2VuTdxKmH8YofVCARjVeRRL9i4pk+wKITDlmZBSYso34ePqg9FgJPZMLF2bdMXFwQWAW5vdyq+7f+X5Ac/b5LnczMSaaMTHkxD5egsNZ0/Ax3oLjUp4FUW5WGJ6Iql5qfi4+1wyJ6+UktXHV+uJqKUrroNBbw11tnfGy85LTz4tSaijvSPOds442zuXaQl1Mjrh5uBWJgl1s3fD3VFPRl2MLjZNQqtLcSv51JVTOZ9zHk+jJw4ODiw7tozxp8fTMaCjjSNUahqV7CqKct26hfqWJLPbTSsB6HT7zdsSeSrtFEHeQSV/B3oFsjVha5ltnuj9BMM+H0bQtCCy8rOInhCNwWAgsmEkryx+hfOm8zg7OLN8/3I6Ne5U3U9ByTiHmPs0wr0A/BzALKFAIgrz4ZupyMhuUD/U1lEqimJjeYV5RB+MZsHBBRw4fwA3ZzcKiwrJzMmkoLAAiT6uNNgjmGOPH7N1uHVKVKsoXJ1dAb3F8cC5A9z9092M+30ca+5fg5+L6tKslKoxya4QYiAwA7ADvpJSvnvRem/gayAMyAPGSyn3V3ugiqIolyGRlywr7spWbOWBlbQNbMuqZ1YRfy6egTMG0qtpL8IDwnl+wPMMnDEQV0dX2ga2LXe8klIFMlMR679F7PgFTu5FOJmhyAA5mv6J5GgAV4EgC7tXWiMdXME7GNmgBQS3QzbtBmGdwcHJ1s9EUZQqtvXUVmbtnsW6E+vIKcrBxejCoNBBhHiE8N7G98grzCvZ1sXehel9p9sw2ptDZL1I/tP7P0xZNYX7F99PzH0x6vNTKVEjkl0hhB3wGdAfSAa2CSGWSCkPWm32L2C3lHK4EKKlZfvbqz9apdJtj8EwcypoZuTA8chRZQv6kJ2B4b0xcC4JzEXIe6Yi7xgLyYcxvGPVpfD0MeSDryOHq6I+im008m5EUlppRcjk9GQCvALKbDN301xeGPACQgia+jclxC+E2DOxdGnShfE9xpfM2fjSry8R6BVYrfHfVLLTEH99h9j+M5zchdDMSEcPZORA2L4ece5c2e0NIH39kAMfhOT9iHPxiL1LEHt+BUAKO/AIQNYLg8BIZGhnaNELvAMufezaRJ2fq4c6zjXa+ZzzfLn7S345+gtJWUkIBJF+kYwOH01URBRO9vqFrlCvUJ5d/qRejdkzuMZXY65LRrYcyZ6UPczZN4cpf0zh0wGf2jokpYaoEcku0AWIk1IeAxBCLACGAtbJbgTwDoCUMlYIESKEqC+lTKn2aJXKYzZj+Gwy2tsx4BeIYUo3ZNch0NhqjOPSz5HB4cg3FkP6OQyPRCD7REFgC7TPdpTu58FgZPdhtnkeigJ0btyZuLNxJKQm0MirEYu2LeL7h78vs02wTzBrYtfQq1kvUjJTOHLmSMkY37OZZ/H38OfEhRP8uutXNrywwRZPo+7KyYT13yG2/4RI2onQipAObsjwAWi3REHHu8HODtZEg/WYXUDauyDHflAyZlcCFORB/DZE3GY4sRtx5jDixHZE3DpYa7mfkyf4NEYGtEQ2bg9Nb4EmHfTHqenU+bl6qONcI2maxtK4pXy37zu2ndlGkSzC18mXByMf5LH2jxHiFXLJfaJaReGWug+Au3u/U80RK2/0eoMDqQf4+ejPtKvfjgntJtg6JKUGqCnJbiPAeoKsZKDrRdvsAUYAG4QQXYDGQCBQJtkVQjwKPApQv3591q9fX1Ux37AGp48AcCaz5sZY1TySDxDi7MPeuJMQd5Lgxl1gwcec6P5AyTbBx4/jmHmWo3/9hVPGGdraO7Nl0yYQpYUYvI9tI8TVj11HTsCRE2UeQx3nqnM07yhH8/SCVAlpOwFosjS5ZH0zp2Y0c7q5xvA+2upR+vynD5rUGBQ2iAvxF3h+uV5k6u7md9PPtx//2fQf5m2Yh0QyNnIsh3YdAmDyyslk5mdiZ7Dj8Y6Ps3/npSM1zpw+A1Cjz201iaEwlwZHVuKfuA6PtMMYpJkigxPp9dqREno755r0BDt7yAf+/lu/k30Q/gOeodnqTzFmZ5DvUZ9jvSdw1j4IyjvuXt30Wxv9T8eMU3id2YdH6mFc0xNxTk3C4dReDDsWAaAJO/Kc65Hr1giTdxMy67Uko0Fripw9q+egVFB1nJ8BMjIygJv3NV1dx1l9FlbMydyTLDm7hO2Z2zFpJowYaeHagoF+A+nk0QmDwUDSviSSKH9eV3WOrh5HTPrref2pssd5ku8kjp47yhsb3sB8ykyEe0R5d1cq6HLHuTYRUl46xqzagxDiXmCAlHKC5e8HgS5SyqestvFAH9PbHtgHtAQmSCn3XG6/nTp1klu2bKnS2G+E2BMNgGx7E3dxWf8TYscK5NOzARCr58HhrcjHPy7dJicLwxvDIOkw5Gah/TMautxZZjfigwnQtD3y7icueQh1nKvHjB/1bnNTRs6wcSR125K1/wRUq8EV5WXDxh8Q235EHN+GMBcg7Z2Rod2Rt9wPXe4Bo0O5dy1bYXwbAA1bls4neN0VxvNMcHQTIm4LJO1FpByBtCREUen4PuniA75NkAHhyJD20LwnBEaArSqsVsP5GdS5o7qOs/osvLzcwly+3/89Cw8t5NAF/eJjiEcII5qPYELbCXg5e1V4X+ocXT2uNCXOkfNHGPy/wTjaObImag31XetXd3h1Rm2ZeshoNO6QUpZb1bOmtOwmA0FWfwcCp6w3kFJmAuMAhF7xJcFyq1XKTNScuBqAFmSUrK9tEzXfuPIutpQt6MOOlcjQtsh3V8HpeAz/GogW2QtcPfT1hQWILUvRxr1V5dEqilJD5efC3/MRWxchjm9FFOUjjU7IsB5oXe+DrvdWqIBUlVUYd3KD1v2RrfsDljOfpsHJQ3BkI+L4LsSpg3A+EZG0A8PWefp2RifwCkTWbw5BrZFhXaHZLeDiceMxXZU6P1cPdZxtZWPSRr7c8yXrk9eTW5SLm70bd4fdzaPtH6VDgw62Dk+5Ts19m/Ph7R/y2IrHuP/X+1kxegX2dva2DkuxkZqS7G4DmgkhmgAngdFAmUuPQggvIEdKWQBMAP6yJMBV43qLRQCY0jF89CgcPwBCoD3zJYTfApSdqHlJmt7N6O62j1XZ06jx/BohziWVftSnJoNv2YIuhj/moo16AYSAhk2hQQgkx0KLLvoG22MgrD14qyt3St0WvT+aZ7fN0ouf7Fuoip8U5MHmRYgtCxEJmxFFeUijIzKkK1qXUdD9/ppdIdlggKBICIpEYpXymC7A4b8Rx7ZC8j7E2aOIQ38gDvwOxdu5+SP9mkDDSGSTjtCiJ/iHVm4rsDo/Vw91nKtVSnYKs3fNZnHcYk6ZTmHAQOt6rYmKiGJ0xGiVFNURQ5oNYU/KHj7f/TlPrnySWYNm2TokxUZqRLIrpSwSQjwJrECf6OFrKeUBIcQky/qZQDjwnRDCjF646uEqC+hGikXYOyBmPoPsNAD58iIoLACrIifKRZp3hlNxcCYBfBsh1i1Cm1a2oI+sF4zYvQbZqhekpUDyEWhQOs+lWLsA2Xt0dUeuKNUqen80k5ZNIqdQP5+cyDjBpGWTAG6uhLeoADb/iNi8AJHwN6IwF2nngAzpgtZ5JHSPAidXW0d5Y9x8oONdyI53AZbk1myGE7vhyCa9Ffh0rF4QK3EL/P21vp29C/gE663Awe2QTbtC027Xn/Cr83P1UMe5ypk1M78c+YXv93/PzpSdmKUZf2d/xrUax2MdHiPQQ1W+r4te7vky+87tY2n8UtruaMvjHR+3dUiKDdSIZBdASvk78PtFy2Za/b4JqJ5KN0e2QsMwCNA/SORtoxCblyCtkl2EgFwTSKmPxXL3ATsjZGci9q9He1b/8oG9g35TymdnRHtsBoaXB4PZrLeON45ELNOvwMk7JyKjXsLw3/GIx9qBlMjx74CnZcLwvBzErlVok7+w2VNQlOrw8p8vk1OYg6uTK84OzuQV5pGbn8vLf75c95PdokLY/gvi72hE/EZEYQ7Szh4Z3ElPcHv+Q+8mXJfZ2UGTjtCkY9lW4PQUOLwecWxb6ZRI+5Yh9i4BQAoDuDdA1guFwFbIJp30KZF8K/DlXp2fq4c6zlXmUOohZu6aycqElWQUZOBgcKBXYC/GtxlP38Z9MdhqPLxSbb6+82v6zu/Lu5vfpXW91vQK7mXrkJRqVmOS3Rol9RSyntUQYr9AOLy1zCZyyBMY3hiGeCCotFiEwQBnjoGnH+KDhxHH9iKbdUBO+rD2tzRUpS6D0boMLrNI3jmx9A/fhnore3mcXNAWna3C4BTF9jYfO8+JjCTcXdxxdnCmsKgQZwdnXBxdyCjM4N9/zuKl2yZgZ6gF09lUlNkMO37VE9y49YiCbKTBiAzqiNb5Huj5YJWMW7Wuq7AlRx+z23VP6RfiGldXwas+dB2J7DoSsCTBRQWlUyId341IOYxI3oOI3wDr9LtJRw+9FTigpd4K3OwWPZk2XtSFU52fq4c6zpUmuyCbb/d9y8LYhRy9cBQEhHmF8Vj7xxjXZhzuju62DlGpRq4OrkQPiWbQ/wbxaMyjrBq9ikYejWwdllKNVLJbrhsoFmEugrhdyMdmIFt2Rcx8BrHoP8gx/66WyBWdKgSm1CUtA+zwc/fFYGfAlGsiJz8HgzDg5OCEq5MrMw+8waK4TxjRYgSTO03Gz8XP1iFfH7MZdv2G2DhPT3Dzs5AGIwS2w9zpHuj1ILh6V2kI1nUVCo7GAvBYbaurYHSAFj2QLXoAVp9o5xIhdj0iYSecOoA4dwyx6yfEzh/17QxG8AhA+jfXW4FDO+tjgT3r2eRpKMq1WHt8LXP2zGHjyY3kmfNwt3dnePPhTGo/idb+rW0dnmJDYT5hfNzvYybETGD0ktGsvn81Dnaq1+XNQiW75bmRYhH1gvWW4Jb6NMGy5wgMi94rN31Wqo4qBKbUFScyTjDilxEIgyA3L5ccSw0ATWqgwTu3vkNmQSbzDszjq71f8e3+b7kt8Dae7vJ07agmqmmw+3c9wT2yDpGfiRR2ENgWrcNw5G1j9TGsyo2rFwL1QpC9HgQsSXBeNsRt0VuBLVMiiYS/EUdWwxr9btLZG3xD9CmRGreH5t0huI3tpkRSFIvTptPM3DmTpfFLOZN9BoMw0K5eOx5o9QAjW4xUxaaUEgPDBjK5w2Q+2vERE5dP5Ju7vrF1SEo1UclueW6kWISnH9QLhOTDENhC3yY43EZPRFGU2mzv2b3cv/h+MgsyeevWt3Cyc2LKb4+TVmQi2DO4TDXmyZ0ns+LYCj7f+TlrTqxh1YlVtPRpycNtHmZ0xOia1cVZ02DfH4gN3yEOr0XkpetjSxu2QeswDHnrWNWaWF2cXKFVX2SrvoDVlEinj8CRDYjEXXDqICI1AZG8C8M2y1ytdo7g1UgvhhXYGhnWBZr3AFdP2z0X5aZg1swsil3ED/t/YPe53WhSo4FrAx5t+ygT208kwC3g6jtRbkov3PICe8/tZUXiCj7c+iHPdHnG1iEp1UAlu+W5wWIR2mMz9GmJCgsgoAnaM3Ns91wURamV1iSu4dGYR9GkxswBM7mz6Z0AnIvdAsCUkTMuuc+A0AEMCB1AQnoCH2z9gOXHlvP82ud5d/O73NPiHp7q+BS+Lr7V+jxKaBocWKMnuLF/InIv6AluQCRa+6eQt43Tx58qtmcwQKOW0KhlSa8kCZCdoc8JHG+ZEinlCOLwGsTBmNJtXOtZpkSKQIa014thNWh22VZgsSaaCQu+xT3bBEuXIh+ajuxbxwuuKddl39l9zNw1k9WJq8kszMTRzpE+QX0Y33Y8fRr3sXV4Si3x1aCvuH3+7Xyw7QNa+7emX0g/W4ekVDGV7F7OjRSLCGuH9vGWKgxOqSixJpoBs2bhnJkJ3yxUX6SUWmH+wfm8uPZFnO2c+e7u7+jSsMs13b+JVxM+ueMTcgtzmbVrFj8c/IHZe2Yzd99cbgu6jac7P037Bu2rKHormgaxfyHWf4uIXYPITkUKAQ0i0HpPRPZ+GLxVK0yt4eoJ7Qcj2+ufjSVTIiXtgyN/W6ZEOqTPC3x8K2yaq29n7wzelimRgtogm3aDZrcgNv6C+HgSHsXT8509AR/r02mp83TlqO31K7Lys5izZw4/HfmJ+PR4kNDcpzmTW05mTOsxuDnU8SrsSqVzsndi/tD53LHgDp5Y8QQrR6+ksWdjW4elVCGV7Cp1llgTjfh4Ei7qi5RuewyGmVNBMyMHjkeOmlZ2fXaG3iPhXBKYi5D3TNV7NRQzmzFM7gp+DdHeWFKtodcqN3icZ2z+gP4f/osfXJ1p8P5qmvo0ve5QnO2debrL0zzd5Wli4mP4YtcXrD6+mj8S/yDcN5wJbSdwX/h9lT/9RuwGxF/f6Amu6ayeFNVvidZzvJ7gVmTaG6V2sLODkHYQ0q7slEgZZ+HwRsSxrfqUSGePIg4sR+xbCqBf9CgE4VoEDnagSZAgZB7MfQbpZAAHZ3B0AQcXcHTVb06u4OCqL7+4crRyidpYv0LTNNYcX8PXe7/m75N/U6AV4OngyagWo5jYfiLhfmpomHJjgj2D+XzA5zy07CHuX3w/a+5fg5P9dc5HrtR4KtlVai+zGbJSIeOMfstMRWSl6suyLyDWRiNcCsDNqH8DK5KIojyY+xyyYz/w9Lf1M6g+ZjOGzybrvRH8AjFM6YbsOgSs5o4WSz9HBocj31gM6ecwPBKB7BNVMk+0WPwxMrglIifTVs+i5rvB4/ziny/ivHQmp7w9uc23PfY3kOhebGDYQAaGDST+QjwfbvuQmIQYnv3zWd7e9DYjW4xkcqfJeDvfQKXjo5sR675BHPoDkZWiJz3+zdG6/QPZ52G9OJJy8/D0hy7DkV2GA8VTIhVCwg7E0U1wYjdi40JwNIBr2dkOBCbs5j581YeQQoDBCAZ7/aed/aU3owPYOSKNDmDvCHYO+jnN6KT/be9kuTnrPx2ckQ6W30sSbRc98S5Osp3c9MTbwbnWFOmqDb2ckjOT+WLnFyw7toyzOWexE3Z0qN+BB1s9yPDmw2tW3QGl1usb0pdnOz/Le1vfY8LyCcy7e56tQ1KqiEp2FdvLy4Z0S8KacRayzulJa/Z5yE6HnHTITUfkZUFeFuRnQ2EOFOZePCFUGdJBgtGgtxgIAS6AEAgysHu+CdLBFdzrI70DoV6oPt9kUCu9laKKpzepdke2QsMwCAgFQN42CrF5CdIqCUMIyDWBlJBnAncfsLOcIs4lI7b+jjb6n4hfPqr++GuL6zzOZiF4+Lex7Du0nG/SHWj++Dc4Lp2JVgUhhvmE8emAT8kuyGb27tn8cOAHZu2ZxTf7vqF3cG+e7vQ07Rq0q9jO4rcj1s1BHPwDkXlaT2j8mqJ1Hq234DYIq4JnoNRaRnto1g3ZrBsAYtN6OH0CDOiz+wkBAqRXPbTHP4KCXCjIRVh+UpgHhbl6PYzCPCjKg8J8KMrXf5rzEUWF+t/mQjAX6J8X5kKEuRC0ItAK9SkCtcIrfn5UlDTYWRJuS9JdbsJtSbaNDmB0LL2VSbadLkq2HcHeBRyLW7ctibajq56AO7nqSbfx6tOn1OReToXmQhYcXED0wWj2nduHhkZDt4Y83u5xHmn/CPVd1Th+peo83eVp9p7bS0xCDP/Z9B+m3TLt6ndSah2V7CqVQ9P0FtX00+W2spKTBjkZiLxMyM3Uv4AU6Emr0Iouu1sJ+hV4h+IPezekZwA4e4KLF9LVB1y9ke5+4FEP3P3BqwF41sfwWDv9Q72YAIwC6eWDvH00nItHXEhCJO1CxP1V9nEdPcCjPtI7GPzDkA1bQFBraNxO/5JR26SeQtYLKv3bLxAOby2ziRzyBIY3hiEeCILcLLR/Rpe0WhhmTUV7+F3IzarOqGuf6zjOuc9/w8hfRrAjZQdLE11oNW0RhvzsKg/V1cGVZ7o8w5ROU/Qqzrs+54/EP1iZsJIIvwgeafsI97a899Iuzom7EWvnIA6sQGSc1J+TbyhanyeRvSdAQLMqj12pG+RD0+HjSYjiJAyJdHRBjn0fuo0q3e5a9nktARQV6Bec8nP0z6T8bP33AsvP/NIEu2zCbX2zJNsltwKEuUDfd1EBFORAboaebJck3JZkWzNfS7SXeb6W1m27chJuo73ekn0yDuFWAK5GyNUgV9OP+bcv2yzZ3XVmF7N2zWLNiTWYCk04G53pF9KPCW0n0DOop01iUm5OMwfOpN/8fnyy8xPa1GvDoKaDbB2SUslUsquUZd3KmnkWMotbWdMsSWu6/sGdl6m3shZYvhhcrZXVYKdfpXawjLvyrI908gQXD6SLN7j6gpuPnrR61tcTV68A8PDXx4Rdo83HzpPe6UnuWPkq9kV5liCgUDqysvM0vHo9RLdQ39IvRpmpcHw3IvkAnI6Fc8cQacmIhE36fJOU7AKcvcGjAdInGOqHIQPC9Tkng1qBQ00d81HeV8CL/mM7ViJD2yLfXQWn4zH8ayBaZC/Y/xfSyx+adYS9a6sj2Frs2o5z2rHtFEzrzeEe7rzl1oOOLRtAi87VepwNBgODmg5iUNNBxF2I44OtH7AicQXPrHmGtza9xb0t7uWp+rfjvWkhYv8KRHoSANKnMdptk5C9H9Er9yrKNSpOtLI+f1yvxuwfXL3da40O+hzOFZjHuUoSbk3TE+j8bD3pLsgtm2wX5Og/LYl1acJtlXQXFZT+tLRwi6ICMFtat4sKQBaCvQCDAFc7yCqCdLNeN6Aapeem89Wer/j5yM8kZiYCEO4Tzn3h9/Fgqwdxtneu1niU2se64FqxL/Z8UfL79RRcc7BzYP7d8+m3oB+TV08mxieGMB/VK6kuUcmujVTp+BnrVtbMs5BxVk9YTef1W04a5GYicjP0VtaC7JKuwVXVyoqLx2X3G3MghqmLpmLWzIzvMZ5pt44psz4jN4MxX48h6UISRVoRU/tPZWz3sSXrzZqZru90paFXQ5Y8oRdO6hbqC09NRUQ2INPqi5TdQ9MZWN5x9vCD1v2QrUtL0Jd8YUk7DYm79ET4zBFIPYZIO4k4uhZxaEXp9kKAi6+eCPs2hvrNkA1b6q3BDVvatpiKXyPOH0qiZ4QBsxm+vP0kt91WtgqueflcXtn3IjGz7Cgqas4f7ZtQPzkWcfBvxOaliG3LOX8mDzdDJg7vjUG+8J2NnkwN5tcIcS6p9LWTmgy+ZY+z4Y+5aKNeID7tGPeum8hnThqvB4/mgUwXxJYfYHuM/uU1JxNRzce5qU9TPh/4OdkF2Xy17t+sif2RzbtmEa/NonNGPncaPWnS81G9i3Jwq2qLS6m7ZN8ovrpw+em06jSDwdId2ZWY5J1lPwcHlu1OeW2fg3+UfZiHQiHF0svJywjuRrA3AFU/l7Wmaaw4toK5++ay+fRmCrVCvB29iQqPYlL7STdUgE+5+VgXXKtMjTwaMXvgbB5Y+gBRS6NYc/8aXB1qYS8+pVwq2bWBCo+fKa+V1XRBT1izL0BOhmUsa6blqnBx1+A8xBWuLV/SyupRta2sV2LWzEyeP5mYKTEEegfS7Z1uDGkzhIiGpWMcP1/7OeEB4Sx+YjHnss4R8VoEUV2icLCMVfp4zce0bNCSzLxLCydVyhcp7wDwDiiZbgMsibCmwfkkSNyJOHkIzhxBpCZA+ilESixi/7LS7YUduPqBV4AlEW6ODIyA4LZXnIOyspjDOpMbH0fM3HgaRDbixNCFxI38Hutrl/vOBHO772reXtqD83EpFE08TIFvKA7j3kaOe5sPPxTkbF7LwKwP6KgS3fI17wyn4uBMAvg2QqxbhDbt+zKbyHrBnFn/A3fZrcPZlEmHQldu6fcy0tMPOe5tfaO9azH89EH1X1A4fRTx52zc9y1n6vkEnga21vfnq/oufOCdzlvkEGm/n0eyDzJSi6j8Ks6KchOq8s9B6+7i6UVQoCF9jGCXDTt/gw53VfpzSkxP5ItdX7D82HJSc1MxCiOdG3RmTOsxDGk6RJ07lBqnV3Av/tntn7y56U3GLRvHgqEL1Ou0jlDJrg2Ib1/WP3Tc7fTCHAaBMBTA9xMRv796A62sDW64lbW6bU3cSph/GKH19II+ozqPYsneJWU+5IUQmPJMSCkx5ZvwcfXBaNBfuslpyfy+73f+OeiffLT6o+oN3mCAeo2hXmNkZ6uKo6AnwmeOwok9iOSDkHIUcT4R0k8jTu5DyNKxWtJgD271wKsh0i8EGrRANgqHkPbgG1wpifDWHUaW23/C9NmDwWzmdLNxbNzain/mztRjuHMiGxq/TP894zBMaodngeRf6e/yro8fAMnJ8PvvgvcekGiLbjicusvOiPbYDAwv68dZ3jEWGkcils0C9OO8pnt3HGZMZEmemUZuDXGa+B7S0892MZ+JR6z9CrF3GaTGIwDp0RDtlrHIW8fROawTnYGj54/ywbYPWJm4kqdXP81bf+tdnJ/s+CRezl62i19Rarmq/hwsvoieO+tJvTeZWyDy1tGI7d9hmHU/sv+zyJGv3/DzKDAXMG//PBYcXMCB8weQSILcg5jcYTKPtHsEXxffG34MRalKj3V8jD1n97Akfglv/f0Wr/R8xdYhKZVAJbu2UDxOxsNOH86noVcM1ops2spqC6fSThHkXVrQJ9ArkK0JZQv6PNH7CYZ9PoygaUFk5WcRPSG65Grb1EVTeXfEu2Tl1bDCSQYDNGwBDVuUJMAliXBRIZw6DMd3IU7FWhLh43A+EZG0AyFLW+Wl0RHc/JHejcAvFBo0RwZG6omwd8DFj3pZp07BmaBBaLMHAnB8nuDUVpAvTizZ5qGpAQwbtpLDWyErC6KjtZI8e+pUA+++q5GR1ZsPjH1ZUiV1guuILoPRugwus0jeqR/nb/d+yyubX8GtVzA/DPkBlwbty++D0aY3WpveVRfjuUTEmq8Qe3+Dc0f1BNe9AbLrP9BuHQeWarnWmvk244uBX2AqMDFz50yiD0Xz+e7PmbNvDn2C+zC1y1Ra1VNdmxXlWlXH56DsG8UKwz4A7u79jr7sricxfDgUw8r/Q0vcgXxyvl7h+RptPbWV2btnsy5pHdmF2bgYXRgYOpCJ7SbSpWGXa95fbWQ9llQUZAA3PpZUsY1P7viEIwuPMHP3TNr4t2Fo86G2Dkm5QSrZtYV6QXrX5ZMFZZf7B6O9utE2MdmILOervhBlC/qsPLCStoFtWfXMKuLPxTNwxkB6Ne3FX0f/wt/dn46NO7L28NpqirgSGO318Y7BrS5NhAvyIGk/nNiLOH0Izh5DnD+OOHMYEjaXKXUk7V3A3b9k6iQCWuqJcJMOlxRckeVkVBcdZlauhLZtJatWSeLjYeBAA716afz1F/j7Szp2hLVrK+cQ3Ize2/QeM3bMIMA1gB+H/0iIV0j1BpCahPjzK8SepXD2sJ7guvkjO0eh9XoIWlasAqqbgxvPdXuOqV2msix+GTN3zWRFwgpiEmJo5deKR9s9yojmI2pv96/EDYjjGwBoa0oBQKx7t2S1bNwTQlS1WKXy2Oxz0Lsh2qt/I+Y8imHHIuSrndAm/wyBEVe96/mc83y5+0t+OfoLSVlJCASRvpGMjhhNVEQUTvY1tVhj1bAeSyr2RAMg29aseYyVirG3s2f+0Pn0je7Ls2ueJdw3nOa+zW0dlnIDVLJrA5dOt4A+3cJD020YlW008m5EUlppRcjk9GQCvMq2WM7dNJcXBryAEIKm/k0J8Qsh9kwsf8f/zdK9S1m+fzl5RXlk5mYy5usxfDe+Fo8ndXCCsE4Q1unSRDjPBMf3QNI+xKnDlqmTTiCS9yLiN5TZjXR01+cQ9gmCemE0Sr+NpNjbIUeAiwfJyRBwUcPw3LkGXnhBQwho2hRCQiA2Fv7+W7B0qWD5ckFeHmRmwpgxgu++u6ZJPm5amqbx7JpnWRi7kGbezfh5+M/V150v7RTizzmIXYshJRaBRLr6ITveZ0lwe113N3mDwcCQZkMY0mwIR84f4YOtehfnyasmM33jdEa1HMWTnZ7Ew7HmDJuokJCeSEsyu9o8F4Det421XTxKnWfTz0GjPXLiN5hXdsbwy0sY3rkN7YFPoPvoSzbVNI3f4n7j2/3fsu30NopkEb5OvjwY+SCT2k+iiVeTGzoOilJT1Hetz9d3fs2oX0cRtSSKtQ+sxc3h2ns9KDWDSnZt4JLxM9U93UIN0rlxZ+LOxpGQmkAjr0Ys2raI7x8uW9An2CeYNbFr6NWsFymZKRw5c4TQeqG8Pfxt3h6uF/RZe3gtH6z6oHYnulfj5AYtekCLHpcmwtlpkLgbkvYjTsfCuQREWhIicSviyJ90074hbu9+jj88iEY+Jhb9vJp5D36M+MEeGdASgtsQ3Kgza9bY0auXJCUFjhyB0FB4+23J22/rj7R2LXzwgUEluhVUaC5k7G9j+TPpTzo36MyCoQuqfnqN9BR9Htxdi+HMAYSUSGcfZPsRaL3GQkTvSi+I1ty3OTMHzSQrP4svdn7BgkML+HTXp3y590v6Nu7L1M5TiawXWamPqSh1RY34HLzjcbQmHTB8cT+GuROQx7Yho/4PDAbiLsQxc9dMlh9bTlp+GvYGe7o17Ma41uMYEDqg9vbiUJQr6NqwK692f5VXNrzCmKVj+HH4j+q1XkupZNdGyhs/czMy2hmZcd8MBn88GLNmZmz3sUQ2jGTWX3pBn4m3TuSlwS8x/tvxtPt3OySSd0a8g5+bDQv61ESu3hDZByL7XJoIZ5xFJO7i46AdDJy1FnOhxriIBbQy/cCsWf8A9jOp5dO8ktOQcXO/od3MRkg7B94ZthG/g7l6xejAyCtOnSTWRDNhwbf6FE9Ll960F2+smQpMjPxlJHvP7WVw6GBmDZyFneHGxtlf9jhnnEP89Q1ixy9wej9CakgnL2SboWi9xkCr/lVe8RvA3dGdF255gee6Psdvcb8xc/dMYo7FsPzYclr7tebRdo8yvPlw9YVBUazUmM/BZt3QXt+GYcYIiv6ayW8nV/FZI2/2px8BIMQjhHGtxzGh7QRVlE65KTzc7mF2n93NT0d+4tX1rzL9tpuvB2ZdIGR5g/nqiE6dOsktW7bYOozLWrL2n8DNnexWhxk/TgFuwjkcK+J8sj51UvJByxzCiYj0ZDCdRZgLSzaTwqBPneQZgPQN1qdOahQOwW0RsTsRnz5+abf8yTNv2oT3jOkMw38ezvGM44xvM75SPiCLpywrOc4CpJsjBAdD1kmENCMdPZAtbkP2GANtB1ZLgns1samxfLjtQ/5I/IM8cx7+Lv7c1/I+nuj4RI3v4vzKmrkAvNl3rE3jqOvUObp6VOQ7x9/Jf/PlrtkkJq6hPhKDWVKvUXce6vUiHRp0qK5QazU1ZrduMWtmBi0cxIHzB/jo9o+4N/xeW4dUrRbHLwZgaFjNLtRlNBp3SCk7lbuuuoNRFKUG8Q0E30Bkx7tLFpXMIXw2Qa8YffIgnCmeOukU4vR+xN6lpdtrILw0KDKCZUYlQQF89wTs+6Van05NcFxm87Q4gKPBzIfmYEbvPgy7b/zDUexahXAuAGcj2AHOBoQAmX4C2eZOtB7/gHZ31rgq7S39WjJr0Cyy8rP4fOfnLDi0gE92fsKXe77k9pDbmdp5KuF+4bYOU1FuWmezzzJ712wWxy3mpOkkBgy09m/NPfZNuGfVQoxHVqH59geV7Co3ITuDHdFDo+k7vy/T1k4j3C9czTxQy6hkV1GUSxkM0CAMGoRd2i3abIbThyFxN+LUIcQv74FRUOhgpMjOiJMssFSNzkccXmOL6G0m1knwTrAjzsC7Sfl0Nx0FjlbOzo35YLS01GqASYNcMxSA/KrmT37s7ujOtFum8XzX51lydAmzds9iWfwylsUvo229tkxsN5G7m92tujjXMDEHYpi6aCpmzcz4HuOZNnBamfUZuRmM+XoMSReSKNKKmNp/KmO7jyXpQhJj544lJTMFgzAwoecEJt8+2UbPQoneH82z22aRmp9J0L6F/Pu2f+Pk4MT3+79nZ8pOzNKMv7M/41qNY2L7iQR7But37PQYfHIPdgueRovfihw/s8ZdUFOUqubn4sc3g7/hnl/u4cGlD7LugXU1vmeSUkolu0qdFr0/mulx35JWZGLGJ0uZ3mc6Ua1U16IbYmcHgRFoDVuyZbeJjOz15Lg7ckrWQzMbcNAK8StKhxzBgT4z6dTKjR4d3fHyuPyY37pgyZElTFk9BaPByFeDvqJb8G2VOhux4aFQfcqyi/kHV+KjVD2DwcCwFsMY1mIYh1IP8eG2D1mVuIrH/3icNza+UdLF2d3R3dah3vTMmpnJ8ycTMyWGQO9Aur3TjSFthhDRsHRqms/Xfk54QDiLn1jMuaxzRLwWQVSXKIx2Rv5v5P/RIbgDWXlZdHm7C/3C+5W5r1I9ovdHM2nZJHIKczAIA6l5qTz757PY2dnhYHCgV2AvxrcZT9/GfS+92BTcGu2N7YhP7sWwLRp5ch/a04vBq75tnoyi2EjHgI682etNpq2dRtTiKJaMXKIuztYSKtlV6qySD/gifYzjiYwTTFo2CUAlvNcp01TEzyvOE7PhAtsOZ5KeXUgrt7GMYwkdsw/hWWQi1d6bk3b1mJ0znL0/noAf9fv6utnTuIEzLRu70ralKz06eNAi1KlOfFh8uetL3vj7DbwdvZk/dH6VdHGqi1OWhfuFM3vQbLLys/hsx2csjF3Ixzs/Zvae2fQL6cfUzlNp6dfS1mHetLYmbiXMP4zQeqEAjOo8iiV7l5RJWIUQmPJMSCkx5ZvwcfXBaDAS4BlAgKc+fY67kzstG7TkZPpJlexWMU3TSM5KJi4tjoT0BI5nHufLXV9itDfi7eiN0c6IEIKCwgKMGNn7yN6rt1C5eCCfX472v1cQa2ZgeL0T2qPzIOK2anlOilJTPNj6Qfac3UP0oWheXPsi7/V9z9YhKRWgkl2lznr5z5fJKczBweiAJjWKzEXkFObw8p8vq2T3Ghw4ks3C5ams3Z7G4eRsijSJvZ2BloGujBkUwJyPPFmdf4bbm24l2CmFE3n1+TJuGMcdurJueQibdmex61AWh4/nknA6l51xmUSv1vftZG+gkZ8TzQJdaNXUlS6t3eja3h03l9pzanpzw5t8sfsLAt0C+WXELzTyaFQlj1Nc7Cvr88f1asx1aMoyd0d3Xuz+Ii90e4Ffj/7K7N2z+S3+N5bFL6NNvTZMaj+JIU2H1IkLI7XJqbRTBHkHlfwd6BXI1oStZbZ5ovcTDPt8GEHTgsjKzyJ6QvQl/6fE1ER2J+2ma5Ou1RJ3XZaWm8aRtCPEXYjjROYJkrOSOWM6w9ncs1zIvUBmQSZmaS57JwMYMaJpGjn5OeQW5KJpGgJR8a6YBgPyvreQYV0wfDsRw8d3I4e8hrxzauU/SUWpwd7r8x4Hzx9k3sF5tPVvywOtHrB1SMpV1J5vlIpSQZqmseb4Gi4UXMDPw6/ki1dufi6mPBNJGUk2jrBmy8vX+G3NBX5bd54tBzM4m1EAgLerPX07+DK4lzfD7/AtSUib+V5g0qTBzN8wqGQfLi6CmTMDaNXClVYtXIEGJetSLxSycWcmOw6YOBCfTfzJXFbvvEDMtlSYD0KAv4cjIQ2caNnElY4RbnTv4E6ToCqen/YaaZrGEyufYHHcYiJ8I/h5xM9VPoZH9o3iqwt6hfm6WLnWYDAwosUIRrQYwYFzB/hw24esPr6ax1Y+xhsb3mB0+Gge7/g4bg5utg71piC5dLYGIUSZv1ceWEnbwLasemYV8efiGThjIL2a9sLDWX8vmPJMjJo9ig9GfVCyTClfXmEecelxxF2IIzEjkeSsZE6ZTnE25yznc8+Tnp9Ovjn/kvu52bvh7eRNiGcI9V3r08itEY09GxPiFUIz72b0+bYPJ7IuHQIR5Bl0ybKr6jQULTASw4zhGBa/gpawFTnpOzA6XM9TVpRax2AwED0kmt7ze/Py+peJ8IugfYP2tg5LuQKV7Cp1xpHzR5i9ezYrE1eSmpuKs4Mz+YX55BXkYW+0x8XRBUd7R+ykHWbNfMNzntYlCUm5LPo9lVVb0ziQaCK/SMMgBE0DXLi7Vz3uucOXTq3dym1Zi4ryAWDK1EOknXclOMiB6dMblCy/mJ+PPUP7+TK0n2/JssJCjT2Hcti8O5Pdh00cOZHDoRPZbDmcwbcx+jaujnYE1XOiWZALbZq70aWNG51au+PkWP2tfQXmAqIWR/H3qb/p0agHP9z9Aw52+pe9mBiYOtWA2Qzjx0umTSubMGRkwJgxBpKSoKgIpk6VjB2rbzNhgmDZMoG/P+zZU5kjfmufyHqRfDX4KzLzM/UuzocW8tGOj5i1Zxb9Gvejs2dnPljxwTUXTgKY8N0Elu1bhr+7P3te3WODZ1c7NPJuRFJa6cXB5PRkArwCymwzd9NcXhjwAkIImvo3JcQvhNgzsXRp0oVCcyH3zr6X+7vcz/D2w6s7/BrFrJlJykziSNoREtMTOZ5xnFOmU6TkpJCak0p6fjqmAhOUvZaAk50TXo5e+Dr7EukXSQO3BgS7BxPiGUIzn2Y08WyCk73TFR97et/pJWN2i7nYuzC9z3UOgWjQFO31rYgvHsSwdynytS5oT/8K9UKub3+KUst4OXvx3V3fMeynYYxdNpa1UWvxdva2dVjKZahkV6nV0nLT+GbvN/x69Ffi0uJAQLB7ME+0fwIfRx+mrZ5GQVEBBUUF5BXk4eHigcFooPv33flv3//SM6inrZ+CTZjNGqs2ZvDr6lT+3pdB8vk8ANyc7Oga7snAHj6MHOiHr3fFikpFRflwzkGvCHw9LY729gY6tXGjU5uyLXYnz+SzcWcWOw9mcfBYNgmn8/h9SypLN50DwM4gqO/lSJMAJyJDXekY6U6Pju4E+DtecwwVlZmfyYifR3Dw/EGGNxvOJ/0/KbkIYDbD5MkGYmI0AgOhWzcDQ4ZIIqyGKX7+uSA8XLJ4seTcOYiIMBAVJXFwgDFjJI8/Lhk3TnXXLebh6ME/u/+Tad2m8cuRX5i9ezZL4pYw98hcbul0C091eYrpP06vcOEkB6MDY24Zw+O9H2fc3HE2fGY1X+fGnYk7G0dCagKNvBqxaNsivn/4+zLbBPsEsyZ2Db2a9SIlM4UjZ44QWi8UKSWPfPcI4Q3CeabfMzZ6BtUnNSeVw+cPcyz9GMczjnPSdJLTptOcyz1HWl4amQWZaLLsBSw7YYeXoxfeTt608WhDA9cGBHkEEewZTFPvpjTzaoaXs9cNx1Y8bOfZ5U/q1Zg9g2+8WKOjM/LpH9EWv4tY/jaGf9+CNn4OtB98w/EqSm3Qxr8N79z2Ds+seYb7l9zPsnuXqUaUGkolu0qtY9bM/Hz4Z6IPRLMjZQdFsghPB0+GNx/OhLYTynQn8XTyZMpvj5NWZKKReyPevO1NTuWcYubumdy3+D4GNBnAf/v+96a4IpeSWsD/fk9l5aYL7I7PIjtfH9fVuJ4zUbcHMLyfD727edaocZGNGjgyarAjowb7lSzLy9fYvi+LLXtM7D1i4mhSDrvjsth4IB0s0/96OBsJ9nemebAzbVu40a2tB+0jXbCzu7HnlpyZzIifR5BsSuaxdo/xSs9XyqzfuhXCwiBUr+fDqFGSJUsEERGlrbtCgMkEUuo/fXzAaDkT33orJCbeUIh1lsFg4J6W93BPy3v4YccP/PPsPzmec5ynVj+FQRh4/rfnWTh2YUkX58sVTgK4tdmtJKYm2vDZ1A5GOyMz7pvB4I8HY9bMjO0+lsiGkcz6axYAE2+dyEuDX2L8t+Np9+92SCTvjHgHPzc/NsRtYN6WebRu1JqO0zsC8ObQNxncuvYlQ9kF2Ry9cJT49PjS7sVZpziXc44LeRdIz0+nQCsocx+BwN3eHS8nL8K8wqjvWp9A90CCPYIJ9QqlmXczAtwCqu18G9UqCrfUfQDc3fudStuvHPoiMrQThq/GYph5H/KO55D3vFZp+1eUmuy+iPvYnbKbbw98y7Orn+Wj/h/ZOiSlHCrZVWqNrae2MmfPHNaeWEtWYRYOBge6NezGA5EPcFfTu8q9ohbVKopzsZeOcYyKiGLq6qnEJMSw8buNPNvlWSa0nVCjEr0bpWkam3aZ+GllKut3p5OQkoOUelGoNqHu9O/mw6hBfgQGVF0raFVwcjTQs5MnPTt5lll+7EQuG3dmsutQNrEJ2SScyeXAiSx+Xn8WAHs7Aw28HWka6ExkqCudWrnTvYN7hVuv95/bz+hfR5NRkMG/e/6bCe0mXLLNqVMQFFSa2AYG6gmwtSeekAwbZiAoSJCVBdHRGnXoZVctnHBiYPOBvDfyPT7b+RmzN8zmr8S/aPt1W+4IuYOpnadWqHCScnWDWw++JEGdeOvEkt8bejUkZkrMJffr2bQnRTOLqjy+G2XWzCSkJ5RULz6ReeKS7sXFFf2tORud8XL0wt/Vn9b1WtPQvSFB7kGEeIbQ3Kc5TbyaYG9Xt6dbK9G6H9qrmzF8NAzDivfQEnYgn5wPTq62jkxRqtxbt73FwfMHWRS7iDb+bRjfdrytQ1IuopJdpUY7mXmSL/d8ybL4ZZw0nQSgpXdLRrQYwUOtH7ruuTgbeTRi4fCFLItbxst/vczrG19nwaEFzOg3g9b+rSvzKVSrjKwifoo5T8zGC+w4nEF6jv5lM8DbkWE9/BnSx5dBt3rj4FD3vvSHBjsTGuzMg8NKl5lyiti0M4vt+7PYdzSHuOQcNh1I58/dF+BnfRsfN3uC/Z1pGeJCu5Zu3NLOnYhmzmUSo7XH1/JIzCMUaUV81v8z7m5+d7kxyEvr+XBRPR9WroS2bSWrVkni42HgQAO9eml4qNo9FVZcOMnL2YuXerxEkCGIBbsXUORZxOKji1kSt4QAAghyC+L4O8dJOJ9wSeEkpWJuZAy6rWmaxtmcsxy+cLgkkU3OSiYlO4WzOWdJz0snsyDzkkJc9gZ7PB098XHyIdQrlAC3AALdAwnxDCHMO4xm3s3UPNAX8w1Ee20T4qtHMOz8H/K1TmhP/QSBaqoppW4zGAzMGzKP3tG9+ffGf9OqXiu6NOxi67AUKyrZVWqc3MJcfjjwA4tiF3Ew9SAaGvVd6vNQ5ENMaDuBMJ+wSnusO5veSf8m/Xl9/ev8cPAHBv9vMCNbjGT6rdNxdagdV6X3xppYtDyVtTvSOXIyG7NlaqDwYFfGdvZm1CA/WoS62DpMm3BzMdK/pzf9e5Z2U9c0jdj4PP7elcme2Gxij2eTeCaX3ccyWbBG38bRqE+J1DTQBfuQzazjXZzs7Zh/9/d0a9Ttso/XqBEkJQmwfHlOToaAsvV8mDvXwAsvaAgBTZtCSAjExkIX9dlYYRcXTjqVcYpbm9zKiwNfZN/ZfXy47UMWrV1Eol8iXb7rwv3h9xPkE1RSOEmpmBsdg14R0fujmR73LWlFJmZ8svSaxpJm5Wdx5MIR4tPjOZ5xnKTMJM5knyElJ4W0vDTS89IpkmVblwUCDwcPvJ28ae7TnAauDWjk3ojGHo317sU+zfB38Ve9AK6H0R45aS7mlV0w/PIShnduQ3vwM+g2ytaRKUqVcnd0Z96Qedz14108/PvDrL5/Nf6u/rYOS7FQya5SI2iaxh+Jf/D9/u/5++Tf5JnzcDG60D+kP2PbjOW24KqbvN7BzoG3e7/N2NZjmbJqCgtjF7IqcRWv9XyNkS1HVtnjXq/cPDNLVl9g2boLbD2UwblMfayYr5s9/Tv6cuetPgzt74Ors3p7l8dgMBDRzIWIZmUvAKRlFLJxh94KXDwl0rr0ZTia/4DcVpzf8CBjlxkIabCP8BAX2oW70aODB6HBjiVfjDt3hrg4SEjQE99FiwTff1+2KE1wsGTNGkGvXpKUFDhypHSMr1IxVyqc1Nq/NV/f+TWG8wYSshI4p53j/c3vk5aYxhd7v8DH04emPk1t/Axqhxsdg3410fuj9SrBlm7CJzJOMGnZJABGho/kWNox4tL0aXhOZJ7gtOk0KdkpnM/Tp+HJLcq9ZJ8uRhe8nLxo6NaQ9v7taejWUJ+GxzOEpt5NaezZ+ObpXmwrdzyO1qQDhi/ux/D1eGTcFmTU/6HGayh1WbhfOP/t81+e+OMJopZEseK+FapgVQ2hvg0rNhWbGsvsPbP5I+EPzuedxyAMtKvXjvvC7+O+iPtKpnOpDs19m7P8vuV8v+973tn0DpNXTeb7/d8zo98MQrxCqi2O8sQfz2XR8nOs3prOgeMmCoo07Az61EDDb6vHyAH16NhazT16I7w97bmrrw939dWnTHpp7Ut8s+8bfJyaMsr3/zjWwYnDx3M4kpzNtiMZfLdSv5+Lgx2B9ZxoFuhCm+auPPKEDwMHuSE1GDtWEhkJs2bpfZknTpS89JJk/HgD7doJpIR33pH4WepvPfCAYN06QWoqNG5s4LXXJOPH14wuoTVJRQon/fvufzP+2/GIkwKnfCeahzVnxYkVrIxeiTgryM/OJys3i8YvNua1Ia8xvocaZ3WxyhiDXmAuIC0vjYy8DDIKMsjIzyAzP5Os/CxeWvMSmtBwdnTGIAzYGewwGAw8u+ZZnl/7/CXdix0MDng5euHj5FNS4CnIPYjGno0J8wqjmU+zWtMjp85r1g3tta0YPh6B4a+ZaCd2Iaf8BK51vxikcvMa1mIYu8/uZvae2Ty18ik+H/i5rUNSUMmuYgNpuWnM2TOHxXGLiU+LBwGNPRoTFRHF+Lbjqe9a36bxPdj6QYY1H8a0P6exJH4JvaN7M671OP7V/V/V1iJQWKixckM6S9acZ9P+DE5e0KcGcnc20j3Ci4E9fRg50BdvT9VCUdnMmplHYx5l+bHltPVvy/+G/6+kwm+x02fz+XtnFjsOmCxTIuUSsy2VZVvOAYkYGgjqezmwKcmZF95zpUOEGz07egCONGwIMTHlz6H7ww8SUMltRVxP4aS9Z/fy4dYP+dPwJ5qm0cq1FVERUdzX/r5qibkmM2vmkjGs6XnpZORnsO2kG3Fp3szauYqsgiz+PhzG8ZP1eSzme3KLcsktzCV+Y3tSnZoT8s6HZJ6qx8jxnxH0zyEUOV6gQCu4ZLqdMozgYdTHUEspMWtmNKmRV5TH6IjRJdWLw7zDaO7THD8Xv8vvS6l5POuhvbQO8d0UxN9fI17thPbkImjS0daRKUqVebXHq+w/t59f436l3a52PNr+UVuHdNNTya5SLQrNhfx8+GfmH5zPzpSdFMkivBy9GNliJOFpz/DJG2HMNYOhnAIo778vmD9fbxkrKoJDh+DMGQ0fH/j4Y8GcOXoL2cMPS6ZMqZxEwd3Rnc8Hfs640+OYunoqs/bMYmn8Ut7t/S79QvpVymNc7PTZfBYtT+WPTWnsic8ip8CMEPrUQP/oH8Dwfn7c2sVdjSWrQrmFuYxePJptZ7bRN7gv39z5TbkXOAL8HblnoCP3DCz98l1QoLFjv4kte7PYE2viSFIue49l8ffBdOYs07dxdzYSXM+JZsEutG3uSte27nSIdMPeXv1Pq0Mb/zZ8c9c3pOWm8cmOT/hf7P94f9v7fL7rcwY0GcDUzlNLagJE74/msx0vkJl/gR8O/PvG5yWtJJqmYSo0lSSkxTdTgYmsgiyyCrIwFZgwFZrIKcwhuzCb3MJccopyyCvK02/mPPLN+eQX5VOoFVJgLrhkbCtA4fFOZB98jti/3wAge+9k4DCnjy7G3s4eBzsHzq56kgaD5mKWRfgGpnG6fiqN8m+nUehJnO2dcTG64Grvipu9G24O+s3dwR0PRw8eWfoIZ0xnkEikVXW3YM9gvhj4RXUdUqUqGQzIsZ8gQztjWDAVw//1R7v3PehzaTV7RakLDAYDc++aS9/ovkz/ezqRfpH0COph67BuakKWVz60jujUqZPcsmWLrcO4rCVr/wlU7px3Nc3mk5uZs3cO606sw1RowsHgQNeArvyj1T+4M+xOpDQQHl62AMq8eVqZAijWli6FGTMMrFqlsX8/PPCAgU2bNBwcYPBgA599ptGsWdn7zPhxClB26qFroWkan+74lE92fkJ2YTZ9g/vywe0f3HDxAU3T2Lgji59XprJ+TwaJZ/WpgZwd7Ggb6kb/W3y4d6AfjRrUjqmBbvQ429r5nPOM+HkER9OPMrrlaN7v+36lXFg4fjKPjTsy2XnQxKGEHBLP5HI2Ix/Ncuo1GgQNvB0Ja+RMRKgrnVu50aOjJ34+lybZ0dEXmDL1EGnnXQkOcmD69AZERfnccIw3K03TWBi7kDl75nAw9SBCCDrW70ikbySfbfuMnMLSKWdc7F2YeefMa0p4cwtzSc9PL0lMMwsyyczXb6YCE6YCE9mF2fqtyJKUFuaQW5RbmpQW5ZNvzqdAK6DAXEChuRDE1R+7mFEYcbBzwN5gj6PREUc7R5zsnHA0OuJs1JNRZ3tnXO1dcbF3KUlK3R3ccTK4Me3uYXwUvZ+wYCfG3NmSOXPz6NzWpeS98cQTAn9/eO01fQx6584Gdu7USrrmX0nJmN0bPM5Kxdj8O8eJfRg+uQeRcRKtSxRy3Eywq3tjGsWeaABkW/UavpkdPX+UwT8Oxt5gz+r7VxPgFnD1O9VAi+MXAzA0bKiNI7kyo9G4Q0rZqdx11R3MzW7zsfNsSbig/36wIQAJ5qMl67s28aFbqK9NYqssJzJO8NWer/g9/ndOZZ9CIGjp05J7WtzDmNZjynQJ3bTp6gVQrC1cKBg9Wl8XGwtdu0pcLHWGbr1V8uuvguefr9wLOAaDgcmdJzM6YjRTV09lzfE19JjXg6c6PMWTHZ+8poQoPbOQH0umBsokM1dvTWno48SIXv7c3cePAb28VEtfNUtMT+SeX+7hTPYZnun0DM93e77S9t24kRONGzkRdXfpxZHs3CK27Mpi2z4Te49mE5ecy9bYDNbtTeOLX/VtvF3tCfZ3okVjfUqktNOSt18/R06O/v45caKQSZOSAVTCe50MBgP3R9zP/RH3s+vMLj7a9hHrktaxPWU7jo6OaEJDSokQAonk2VXP8lfSX3pCata78RYnpvlmS1JqLihJTC8ec3rFWIQBB4ODfjM66Emp0QlXZ9cySamL0QUXB0tSaq8npa4Orng4eODh6IGnoyceDh54OXnh4ehxw0MvfD6HZx/ugtmsj0Hv2t5Y4THoV1Oc0E757XHSikwEewbXmBZ0pQoEt0Z7Yzvik3sxbI1GJu9He/pX8LLt0CVFqQrNfJvxYd8PmbRiEqMXj2bV6FWqOJ6NqGS3mnUL9S1NZtM+BWDK7c2ucI/aIbsgmx8O/MCPsT9y4PwBJJIGrg0Y12ocj7R75LIFnipSAKVYTg6sWCH4+GN9DFhkJLzyiuD8eYmzMyxfLujUqep6Kvi7+jPv7nmsSljFi2tf5N0t7/Lj4R/58PYP6Rhw+TFIuw6a+N/yVNbtTOfoKX1qIAejgYhgN/p28eK+QfVoGuJcZXErV7brzC4eWPIApkIT79z2DmNaj6nyx3R1NtK3uzd9u5edEuloYh5/78xid6yJ2MRsEs/ksSchi1/3H8DeLxWv0RqeRYVIcyGyqABZVMC/V2s06zuIzg06V3ncdVn7Bu35dsi3nM85T8inITg7OuPhcumcvEvjl5a2lNo5ltw8HD1wNjpf0lrqau9a0lLqau+Ku6N7SVLq6eCJp5P+08neyQbP+uoGD4bBg8uOu504sfQ8e6Ux6BUR1SqKc7F6D6za2itEuQYuHsjnl6Mtehnx58cYXu+MNvEHCO9l68gUpdLd1ewuHj/7OJ/u+pTHVjzGV4O/snVIN6Uak+wKIQYCMwA74Csp5bsXrfcE5gHB6HG/L6X8ptoDVUpomsaKYyv4/sD3bDq1iXxzPq72rgxoMoDxbcbTM6jnVfdRXi96cZkuer/9JujeXZ/aAiA8HJ5/XjJwoAFXV2jbVlZLj6h+TfqxKXgTb//9Nt/s+4ahPw/l7rC7+U+f/+Du6E5unpnFqy7w27rzbDuUSWqWPjWQn7sDd3Ty5a7bfBnazwdnp7rXfau2WZmwksdWPAbAl4O+ZEDoAJvFYjAYaBHqYpkTubSlIz2zkL93ZjHygWPYuZoxuGrYuWoIO/3Nc9YseGKKHeEhh+kc6c6tXTxo1dxFje2+Tr4uvtRzrseJjBMl00YUjykNdA8k/sl4dWwV5UYYDMjRbyPDOmP4dhKGGXch734dOfgZW0emKJXuXz3+xf7U/fx+7Hc+3f4pT3Z60tYh3XRqRLIrhLADPgP6A8nANiHEEinlQavNngAOSimHCCHqAYeFED9IKQtsEPJN7cC5A3y15yv+SPiDC/kXsBN2tPdvz33h93Fv+L3XNF1Qo0aQlCQorkCbnAwBlxnWYN2Fudj48aVTs7z0kiAw8Lqe0jWzt7PntV6vMab1GJ5e9TS/Hv2NFYd34ZU4hlN725ZMDdSsoSsj+/ozcqAf7SPU1EA1ybz98/jXun/hau/KvCHzrtg6b0teHvYM7u1DA8cznDhWaFkqMThr2LlruNWTFBRJlm9N5bfN52COPu67sb8zkaEudGntQZ+unoQ1Vr0HKmp6n+nljiV9q+9bKtGtZNHRF5g+dRRp512Z8cJBNQ79ZtJ5OFpQawwzhmP49WW0Y1uRk74FY/VNOago1WHO4Dn0nd+X/2z5D63qtaJ34962DummUiOSXaALECelPAYghFgADAWsk10JuAshBOAGXAAuLR+pVInzOedLpgtKyEgAoIlHEx5s9SAPt334uqeE6NwZ4uIgIUFPfBctEnz//aVd4jIy4K+/4Lvvyia7Z8+Cvz+cOAG//irYsOH6u9Ndi8JCjRXr01m8ppBjB16hyHkHRW1Wcr7JIjzrr2NM0DM8PqQDXh5qfEZN9N8t/+WDbR9Q37U+Pw3/iSZeTWwd0lVNn96ASZOSycmRgEDLtcNJGJnxfiBRUT7k5pnZsD2TjTsz2X3YxNHkHH5ef5af/joLn+mVoEMbONO6qRtd27jTp5snAf61o/hZdSseM/rk8qfJzL+gxpJWkejoC0yalERugStIocah34waNEV7fSviiwcx7F2CfK2LPo63XoitI1OUSuNs78z8u+dzx8I7mLRiEqtGryLQo5paZ5Qak+w2ApKs/k4Gul60zafAEuAU4A7cJ+WVJvBTblShuZAfY39kwaEF7EzZiVma8Xb05t4W9/JIu0doVa/VDT+G0QgzZmgMHmwoKYASGUmZAiigJ7L9+0tcXcve/957DVy4APb28PHHGt7FQyATNyCObwCgrSkFALGutGe8bNwTQq7ezdraqZR8Fv6eyqrNF9hzzESuZWqgEH8XHmjVn0G33c3vWe/x09EfmZWxCdPOB3i91+vX1NKtVC1N03hh7QtEH4wmzCuMX0b8Umvm7iz+8v/C1KOknHck6KJqzM5OdvTv6U3/nqXjgNMzC1m3JYO/d2ex96iJuJM57EnIYt4fpwHwdbMnrJELbZq50b2dO727eeHpXlM+FmwrqlUUh87qHYfe7DvWtsHUAcVj0rfuzWLfkRwOH89hw7ZMjG00POwkheeM5Bx1IicHXn75jEp2byaOzsinf0T79W1EzLsY/n0L2vg50H7w1e+rKLVEiFcIn97xKeN/H8/oxaNZE7VGfT+sJjVi6iEhxL3AACnlBMvfDwJdpJRPWW0zEugBTAXCgD+AtlLKzIv29SjwKED9+vU7LliwoHqexHX488gcAPo0f9jGkZR1IOsAMedi2GvaS57Mw17Y09KlJf19+9PZs3Ot68b33YmNAIwJvrZ5zjRNsveIYP1uwYHjkGLSxxg7GiG0HnRqAb07afh6lR1kHJ8dzxcnviCpIAkvOy8eDnyYLl5dKu351FQ19fVcrFAr5P2E99lt2k1T56a8GvYqjna1r2Uz4+BKADwj7riu+59Pl+w+bOBgAiSmCE6lS3ItvaOFAC8nCPQVNG0kiQyVtG4mcXS4hrlu6pDrPXfczDRNcjpVcDhREJ8sSDoHKemSC9lQaHV52skIpvN2mHP0zxPHgEKK0oxkxzohJKxZk2WjZ1C3HM07ytE8fcYHt6xjAJjcQ0vWN3NqRjOnmlMk0zt5OxHr38WuKIfj4fdxvNNDtg6pQg6dNxN7wQxA/rl4ABzrhZWsb+ljR7ivqtOhwP9O/Y8fz/1IB7cOTAubZutwrmqzaTMA3dy62TiSK+vTp0+Nn3ooGQiy+jsQvQXX2jjgXaln53FCiASgJVCmdq+UcjYwG/R5dnv1qrkV/nam/AhATYjxeMZxvtz9JcuPLed09mkEgnDfcO5tcS8PtHqgzHRBtc3KNfoHT0WOc1qGZWqgDRfYcTSTLMvUQIG+Toy81ZO7+/rSv8eVpwbqRS/GaGP4cveX/Hfbf/lv4n/pFdiLj/p/VGvnWauImvR6vpipwMSoX0ex27SbgU0G8uWgL0uKD9U22y/sBaDTDRznYUPK/h1/PJc/t2SwdV8mB47lEHc2h33Jkl+2COwMBhr6ONEy2IUO4W706uRJp9ZuN8X0WNdy7rgZHT+Zx5Y9JvYeNnE4MYeE03mcvpBHXklWK3F2sCPAx5FWTZ1pEeJMu5ZudG3rTmCAI6GhBzlxQr/SouUYcA7LxzUyF+8MD3XMK0kvSo9j7Zj/tRfccS/io2E0OTSfxtpZ5BPzwcn16ne1IetX6/bFsQB0Gnq7bYJRarRe9CJjaQZ/HP+DrQ5bebbrs7YO6YouxOvTpfYKq73n5JqS7G4DmgkhmgAngdHAxWfjE8DtwHohRH2gBXCsqgKKORDD1EVTMWtmxvcYz7SBZa++vL/yfeZvnQ9AkVbEodOHOPP+Gc5lnSPqq9LQj6Ue4/UhrzPl9ilVFep1MxWYmLd/Hj8e/pFD5w8hkTR0bcjDrR9mQrsJNPZsbOsQq8WOfSb+t+Icf+1MJ+50TsnUQJGN3bi9izf3DfYjNPjaivsYDAYmdpjIyJYjeW7Nc6xMXEnPeT15rN1jTO0ytda1jtdmKdkpjPhpBAmZCYyJHMO7fd69+p1uMmGNnQlr7MyEUQ0AvcvpvsM5rNuawfYDJg4dz2btnjT+2Hme//wADkYDQX5OhIe42qwCdEwMTJ2qD38YP14ybVrZXkrvvy+YP19vkS4qgkOH4MwZjXPnICqqNM5jx+D11yVTpti+l1NNdfJMPlv2ZLEnNpvDiTkcO53L6fP55BSYS7ZxsjfQwNuRbhFetGjsQpsWrnRt60bjRo6XfV1Yj0MvOOOALBK4NM/Drp6JE6fyCW5Y+3peKJXANxDttU2IryZg2Pkj8rVOaJN/gUYtbR2ZolSKWQNn0W9BPz7c/iGt/VtzR5Pr66mlVEyNSHallEVCiCeBFehTD30tpTwghJhkWT8TeBOYK4TYBwhgmpQytSriMWtmJs+fTMyUGAK9A+n2TjeGtBlCRMOIkm2eu+M5nrvjOQCW7l3KjNUz8HH1wcfVhx0v7yjZT/CLwQxrN6wqwrwumqax/Nhyvt//PVtObyHfnI+bvRuDQgcxrvU4egTVre560dEX+Oy5SDLP2fNDkF7pc+hwDxb/cYFlf11g66EMLpj0loV6Hg4M6uLHnbf5MqSvd6VMDeTr4ss3d33D+hPree7P5/hg+wf8dOQn/tv3v3QP7H7D+1eu7Oj5o9y7+F5Sc1J5seuLTO482dYh1QoGg4G24W60DS/t0VFYqLF1r4kN2zPYGWsi9nh2mQrQLg52NK7vTGQTVzq3dqdvN89rvkhUUWYzTJ5sICZGIzAQunUzMGSIJKL0FM1zz0mee05PYJcuhRkzDPj46FOX7dihlewnONjAsGEq0QVISS1g8+4s9sZmcyghh4RTuZw8n0d2fmlS62DUk9pOLTxo3tiFNs1d6drWndDgyye1l1M8LnfK1EOknXclwMWFAd18+Hnbae6YuIfFM1pZpuJSbjpGe+SkbzGv7ILhl5cwvN0L7cHPoNsoW0emKDfMyd6J6LujuWPhHTy58klW3reSEK8QW4dVZ9WIZBdASvk78PtFy2Za/X4KqJZLH1sTtxLmH0ZoPX1cy6jOo1iyd0mZZNfawm0LGd1p9CXLV8euJtQvlMa+tm8h3X9uP1/u/pJViatIy0/DKIy0r9+e0RGjGdliJPZ2da9qsF7pM5mcHAeEg8aZ/Bwef/cIU2aZ0ZAYDYLmjVwZ3b8+9w70o03Lquuq3Su4F38/+DfvbX6PL/d8yb2/3sug0EG83+d9vJy9quxxb2ZbTm3hoaUPkWvO5b99/8t9EffZOqRazd7eQI+OHvTo6FGyLDfPzPptlgrQR/QK0D+tT+HHv1LgM/BwNhIa4EKrMFe6tfWg7y2e1Pe78YIcW7dCWBiEWoYejholWbJEEBFRftJa3rRlAKtX6/tobPtTdLVKvVDIlj1Z7I41ceiYJalNzSMrrzSptbczUN/LgXZN3Wke7ELr5vpFjJZhTpXagh8V5cM5h0UATBk5A4D+Kzx44r0jDH5iL4vea0XH1rV3GI1yg+54Ai2kPYYvojB8PR4ZvwV5//+B6h2l1HLBnsHMHDCTB397kPuX3M+a+9fgbK+mCKwKNSbZrUlOpZ0iyLt0CHGgVyBbE7aWu21OQQ4rDqzg49EfX7Ju0fZFjO58aRJcXVJzUvXpgo4uJjEzEYBQz1DGth7L+Dbj8XXxtVlsVSn5dD5/bcvgmbdOQFAR7q4aBme9JUfLN0C6A++/EsyIAb7VWnnWzmDHP7v/kwdbPciUVVP4/djvbEjawAvdXmB82/HVFsfN4LejvzF51WQMwsDcO+fSp3EfW4dUJzk72XFHL2/u6FVaAToto5C1WzLYZKkAHX8qh93HMstUgG7ayIU2zd24pZ0Hvbt6XvP78NQpCAoqTV4DA/UEuDw5ObBiheDjjy8t3r9oUflJcF2RnlnIlt0mdh8ycfBYDsdO5pKcmkdmbumsfUaDoL6XI62auNMs2IXWzVzp1NqVyGYu2NnZJqEYMcAPd1c7xr8Ry/Bn9zFvegS3dvG0SSxKDdC8O9rr2/T5eNfNRDuxGzn5R3D1vvp9FaUG6924N9O6TuPtzW/z8O8PEz002tYh1Ukq2S2H5NIvP/r0vpf6be9vdA/rjo9r2WkSCooKWLpnKW8Ne6tKYrycAnMBiw4tYuGhhew+uxuzNOPj6MPolqN5uO3DRNaLrNZ4qpKmacTG57FxZyY7D2ZxKDGH4ym5pV/k/MAuX2DOtqMgxZ7CNDu0HANCCMaNrG+zuAM9AvlpxE8sObKEV9e/ysvrX2b+wfl81O+jOvX/sZWv93zNaxtew8PBg/lD59PGv42tQ7qpeHvaM/wOP4bfUTql06mUfP7cnMHmvVnsjzdx8LiJLYcz+HLpSYSA+l6ONA90oV0Ld3p2cKdHJ0+cHC+faJU3icBlTtH89puge3e9+7K1ggJYulTw1lu1fwa7TFMR2/ZksetQNgfjs4k/mcfJ1DzSsgtLtrEzCPw9HQgPdqVZsAutmrnSsZUbrZu71MhiY/17evO/9yIZ/c+D3P+vA8z6V0vu6qumI7ppedZDe2kd4rvJiE1zEa92RntyITTpaOvIFOWGPNnpSXaf3c3vx37n7Y1v868e/7J1SHWOSnbL0ci7EUlppdP+JqcnE+BVfhXdhdsWltt6G7M/hvbB7anvUT1J1YakDXy992vWJ68nuzAbRztHbg28lQdbPcgdTe6o9QWRCgs1duw3sWm33vXuyIkcklJzyS3Qv6gKAX7u+he5iFBX6jU/wde/bSArs+iSfXl6Gth2poDODTpX99Mo4+7md3NHkzt4df2rLDi0gIGLBnJf+H282etN1ZXlOr298W0+3fUpDd0a8vPwnwn2DLZ1SArQsL4jDwz154Gh/iXL4hJLK0AfTMhma2wGf+1L4+Mf9cSsoY8TLRu70DHcnV6dPOjcxq2kpbFRI0hKEmC5MJmcDAGXKXR+uS7MMTHQvj3Ut911r2uWnVvEtj3Z7Dpk4kBcNvEnc0k+l1dSdwDAIAT1PB0Ia+hCsyBnWjVzpUOkK+3C3XBwqF2fA93ae/DbjNYMn7qfCdNj+cDUlKi7/a9+R6XE5mPn2ZKgV1M9pRcJpmHq0ZL1XZv40C20lvTysrNDjvsMGdYVw4KpGP6vP9q970GfCbaOTFFuyBcDvqDfgn58vutz2vi34a5md9k6pDpFJbvl6Ny4M3Fn40hITaCRVyMWbVvE9w9/f8l2GbkZ/HX0L74b/90l6xZsX1DlXZgT0xOZvXs2McdiOJNzBoEg0jeSe1veS1RkFK4ONbtU/+WYcor4e0cWW/Zmse9oNkeTczh9IZ9Cs57Y2hkEAd6OdG3pRaumrnRp407PTh4XdYUMJSivTUmlz2IuLoL3ZwbSuUHNaCFwsnfivb7vMa7NOKasmkL0wWhWJqzk9Z6vM6LFCFuHV2tomsaUVVP46chPtPRuyc8jflZjoWu4piHONA1x5pH7SitA74nN4a9tGWzfb6kAvTuNP3ac5915lgrQ9ZyICHGlfUt3Dh5qRHy8RlCQgUWLBN9/f2kLbUYG/PUXfPfdpcnuggU1twtzbp6ZHftN7Dxg4kBcDnHJelJ73lRQ0qpdfIEvpIEz/QJ9iGzqSsdIN9pHul2xVby2adXClRVftGHI5P08/eFRMk1mJkXV3SncKlu3UN+SZHa7SZ+ju9PtNWde3ety6xi0xm0xfHIvhvlTkPHbkOM+B7vaOZ2cotjb2bNg6AJun387z6x5hpa+LWnq09TWYdUZKtkth9HOyIz7ZjD448GYNTNju48lsmEks/6aBcDEWycC8OuuX+kf0R9Xx7JJZU5BDqsOreKLB76o9NhMBSa+2/cdPx3+idgLsfp0QW4NeaTNIzzS7hECPQIr/TGrUuqFQv7alsHWfVkciM/m2Klczmbko1m+0DkaDTTyc+L2Dj60a+FGt3budG7jXqEvc8WVPqe+cJLzKRpBQfZMn96gZHlNEu4XzsrRK5m7dy7/2fwfnvzjSb7f9z0f9f/oppkC6noVmAt4cMmDrD+5nlsCbuGHu3/Ayd7J1mEp18hgMNA+wo32EWUrQG/Zk8X67ZnsijVx+EQ2yzansnTTOQrd04lo1xSjwUCrTplsOVjIr0t98PN2YOJE/QTy66+C/v0lrhdd98vJgVWrBF98YdsuzAUFGjsP6Ent/rhs4pJySTqXR2pmQck5UAjwcbUnyN+Z29p7EdnUlQ4RbnRo5Yqr883xER4a7Myq2W248/H9vDw7noysIqZNDLr6HZW6q3FbtDe2IT4dhWHrPGTyXrSnfwWvWtRVQ1GsBLgF8OXAL7l/yf1ELYniz6g/a22jVU1zc3xSXofBrQczuPXgMsuKk9xiD3V/iIe6P3TJfV0cXDj737OVFoumaSyLX8a8/fPYcnoLBVoB7vbu3Bl2Jw+3fZiuDbtW2mNVpWMnclm/PZOdB00cTMgm8Uxume53bk52BNdz5pZWnnQId+OWDh60aXFjRVKionxwaJkDwMgONf9CwNg2YxnRYgTPr3meZfHL6B3dmwltJvDiLS9iZ1BXrS+WmZ/JPT/fw4HzBxjadCif3fFZre+yr5SytzfQs5MnPTuVFifKzi1iw7YsNu7KZPfhI8Ql5xKfmc/zn+rrPZyNLNrsQpumrnRt68FHn3gCZStAu7jA2bPVl+gWFmrsjc1h+/4s9h/N4WhSDkln8ziXWYBZK21d9na1J7CeE91bexEZ5kr7CDc6t3HFzUV9VAf4O7Lm6zYMnrSf96KPk5ZVxLvPNbF1WIotuXoin1+OtuglxJ+fYHijC9qj8yC8l60jU5Tr0iOoBy93f5nXN77OQ789xKJhi9R3mkqgPkFrsL1n9/Ll7i9ZfXw16fnpGIWRjvU7cn/k/QxvPrzGThdU3B1x085Mdh4ycfh4DifO5WKymtbCx82ekAbODG7iR4cIN3p18qiyOTlrGw9HD2YNmsWWU1uYunoqn+36jMVHF/Nen/fo3bi3rcOrMU6bTjPsp2EkZSbxaLtHeb3X67YOSakGrs5GBtzqzYBby1aA/nNzBpt2Z7L3aHZJBejvVuoVoP3cHWjayJk2zdzo3t6T27p64OFW+R9/ZrPG/iM5bNtnYt+RbOKScjiRksfZjAKKrJJaLxcjjfyc6BLuQUSYK+3CXenS1r1aq8PXRl4e9vwxpzV3P36QL5eeJCOriM9eC1NfBq8kcQPi+AYAXHMzARDr3i1ZLRv3hJCeNgmtUhgMyNHvIEO7YPhuEoYZQ5BD30AOmmLryBTlujza/lF2pexicdxi/r3x3+q7TSVQn6yXERMDU6caMJth/HjJtGllx3a9/75g/ny9/GdRERw6BGfOaPj4QFiYAXd3ffiI0QhbtlS8BeFs9lnm7JnDkrglHM88DhLCvMN4uM3DjG8zHm/nmlVqPy9fY9veLDbvzmL3YRNHknI4mZpHflFp4aj6no60CXUnMsyVLq318bX+vjc+12Zd17VhV9Y/sJ6Ptn3EZ7s+I2ppFP0b9+eD2z+os9NGVdSBcwcYvXg0aflpvNbjNSZ2mHj1Oyl1lrenPSMG+DFiQGkF6JNn8lmzOZ2te03sizexP9HE5tgMZlsqQDfwcqR5kAvtW7jTo4M73TuWrQAdHX2Bz56LJPOcPT8EHSwzBELTNA7F5bJtn4m9R7I5ekJPalPSC0pqC4DeytzQ14n2zT0ID3Whfbgbndu44etdMy9U1gauzkaWz2rFyKcPsmhtChkmM9+/19xm0yTVeCE9kZZk9sDOZADCa0Evp2vWZThaUCsMHw/H8Mu/0I5tQU6cC0b1XUOpfT6941OOph3lyz1f0sa/jarhcoOELG8OhzqiU6dOcsuWLdd8P7MZwsMNxMRoBAZCt24G5s3TiIgof/ulS2HGDAOrVulfcsLCDGzZouHnV/72ANH7o5ny2+OkFZkI9ghmcPPBJGYmsufcHszSjK+TLwOaDGBC2wm09Gt5zc+hKmRkFbFheyZb92bp48tO5nA6Lb+kG57RIGjo60SzQH2uxq5t3One0d3mXfB+tHzA14ZuzJdzxnSGZ1Y9w7qkdbg5uPFMp2eY2H6izVs0rCt9Hk5cDUCLkNtL1ldFpc8NSRsY//t4CswFfHT7RwxrMaxS91/TbV/8GQCdhj5h40hqnyMJuay1qgB9/GwueYX6ebv4/NWysSt2BXYsnm8iN10gHCR2LhoOHhrh7ezJF2ZS0vMpKCpNat2c7Gjo60RoQ2ciQl1o29KNLm3d1EW9K7FqcfwzYTcAfZq0K1l9tRZHs1ljzLQjxGxLpUeEFz/OiKh11aarW134LLyq/FzEF//AcDAG6d8cbcqvUK96616oc7RSGc5mn+X2+beTU5TDbyN/I9wv3CZxLI5fDMDQsKE2efyKMhqNO6SUncpdV93B1AZbt0JYGISG6n+PGiVZskQQEVH+hYHLTW1xOdH7o5m0bBIFsgA3JzeyyebnuJ8xCiO3Bd3GmNZj6Ne4n00TmVMp+fy1LZPt+7M4eCybY6dzSc0qrQTq7GAgyM+ZQV38aNfSjVvaudOxlVuNnK+xLmjg1oD5w+YTEx/Dv/76F29uepOFsQv58PYPad+gvc3isq70uWTt1wDc3bvqKn3+fPhnpq6eioOdA/OGzKNnUC3ufqdUu+ZNnGnexJlHR5dWgN59yFIB+kAWscdz+HPXBQrNGg6R4CABq/l741IKaBrkQu92PrQMcaFdSxe6tHUnwN/RNk+oNrNqcVxtngtA79vGVvjudnYGvn+vOU+9aWTBmjMMfHQfS7+IvGmKdimX4eiMfPontF/fRsS8i+HNW9DGzYH2g2wdmaJcE39Xf76+82vu/eVe/rH0H6yNWou7o7utw6qV1KdCOU6dgqCg0uQ1MFBPgMuTkwMrVgg+/rj0Kr8QMGiQASHgkUckjzxilQgnbuDl5U+RW5iLn6fe9JtfmE9WYRb1Dc7MazOpWsfPaJrG0cQ8S+GoLA4l5nA8JZeMnNL5aT2cjTT2d6Z3e286RLjTs6MHLcOcbN6qeDMaGDaQviF9eXPDm3x34DuG/DSEEc1G8E7vd+p81b4vdnzBW5vfwsfJh0VDF9WYHg9K7WUwGOgQ6UaHyNIK0AUFGu71dmNw1bBz0dDyBOYcA1qOHZgFWza2tWHEijWDwcBnrzXF083IrCXJ9Ht4H79/0QpvT9VN/GYnh/0/e3cep1P5/3H8dZ1ZMMNgDMYy9n2NxlKhkJJIC8q0WCqJIu0LrVJaFG2S/FqRVEhS0Yav3dhlL2RnjGUwy7l+f9yTfRtm5txzez8fj/vhPudc97nf53x9NZ+5rnNdT2PL18P5qDPO0A7Yax/D3vys17FEMqResXo83+h5nv7jae74/g6+u/k7/ex9HlTsnsKpRnYbc/I+gIkTDZdfDpHHrGbz558uxYvD9u3QsqVD5cqWJk3SD5ZpxMbDe7FYEg8kkpKWwn9DyTeRkqWFblqay/yl+5m5cB8LV+xn5YYkNu44RFLy0YmjovKFUqlkONXKhRNbPS9N6uWnZDH1WviT0KBQXrryJTrV7MRDUx5i7KqxTP1nKs9e8Sy3VrvV63hZ4tk/n2X4ouGUiijFd7d8R7G8WmdTskZoqEOJQrnZsCGFlBOOlSqlIsofDXikDAXyBfHayH9odvdifnivBsWL6r9bF72aLXCfnYUz+EacyQNx/56P7TEScgf2L4YlsHSu1ZmF2xYyZuUY+v7ZlwFXDfA6Uo6jYvcUSpSAjRsNkF6EboJip/nZ+lRDmIsX9/1ZpAi0bWuZO9fQpMnRNjH5Y9iQuIHk1OTjPheTP/PWDTxwMJVZC/Yxa/E+lqw6wKpNSWzedfjI5ClBjiG6QC5iK0dQo0I49WtG0Cg2n34jnoNUiKzAxA4TGbV8FP1n9KfPr334fOnnDL56MOUjy3sdL1O4rkv3n7ozce1EahSuwTc3faNhPJLl+vePpnv3TSQlHf13OyzM0L9/tIep5Ewe7xZD/nzB9Bu2jhbdFvP9OzU0w79AVAzuc7MwH92NE/8N9rl6uL2+hRIaGSQ5x5vN3+Sv3X/xydJPqF2kdsB2bGQVFbunUK8erFkD69f7Ct8xYwyff37yjMqJifDnn/DZZ0d/IDpwAFwX8uXzvf/lF0Pfvsd/tn/T/nT/oTtJKUlH9oWFhNG/af/zyrsrIYU/5yYyd8l+lq7dz7rNB9m2Jxk3vcc4NNjXU9G0TiS1KobT8JIIGl6Slzy5tW5rIOhYrSNtKrThqd+f4rvV39F8dHPuqnEX/a7o57fLU52LQymH6Di+I7O3zqZJySZ83ubzHH09knP8N+vyA4+uZe+OEErFhB43G7P4p/s6FiMibzB93lrNtfcv5rtBNahRWb14F73gEOz9n5H2U32ccX1xXmmCe8d70LC918lEzkmQE8SXbb6k2ahmPPXHU1SLqkbNIjW9jpVjqNg9heBgGDzYpVUr39JDnTtbqleHDz/0jWW+7z5fETlunKFFC0v4Mf8t3bYN2rXzjadPTYXbbrO0bHn8+eNqxAHwwI8PsffwbkrlL0X/pv2P7D+Tf/49xJ9zE1mwbD/L1x9g/ZaD7Np/dLBdeK4gYgrnoX61/NStkpfL6kRwSbUwLcsQ4PKG5uWda96hS60u9Jnah+GLh/PD2h945apXuKbsNV7Hy7CEgwnc/O3NrExYSfvK7Xmr+Vt6TkWyVVxcJCuiJwDwUrPO3oaRc9axTWEi8gbR7eW/aN1rMaNeqc5ldSO8jiX+4NoHcMvWxfkgDmdEF+zaOdiOA0H/bZEcoFBYIT65/hNu/u5m7pp4F791/I0CeQp4HStHULF7Gq1aQatWx/fI/lfk/qdTJ0unTsd/rlw5WLDgHNbVXdwS3voBdoRATCgUioYaRw+7rsvSVUn8b8E+FqzYx19/J7Fh+0H2HTr6fG3B8BBKF83DtQ2iqFstL41jIyhXKpeKgotY3ei6/NbxN4bGD+WteW/ReWJnrip1FW9d/RZFw4t6He+c/JP4D7d8ewubD2zmwboP8tTlT3kdSURykOubRjI6b3Xu6Luc9k8sY8SzVbimsX+tUS8eqXQ57vNzfc/x/vE+7oZ4bK+vIVx/P8T/1YmuQ//G/Xns98eI+z6Oie0m6mf+c6Bi1wMjR+5Ofx7Mtwbjhg3J3Nf7HybN3AW501i1MYl/dx46sv6jMVAkIhfVy+SjevlwYmvko3GslruQU3Mchx6X9qBD1Q48MvURfvnnF674/Ap61u1J79jefv0P4+Lti+k4viN7k/fSv3F/utbu6nUkEcmBGtfLz3eDatL+0aV0en4F7z5WiVtaRnkdS/zB6vmwYTc2MRdm7zTMc/Vwe46BsnUBMGPfwPw2ytc2LRU2rsAdvRUOHcB5ozMkbAPjYK+7B3tjL++uQy5Kt9e4nYXbF/Ll8i95/LfHeaP5G15H8nsqdj3Qt+9Wkg665Cl/mKC8LkFhaeDAj4sPEOwYikXm5rLqBahZIS8NauXj8kvzEZFX/1NJxkSFRfFpm0/57Z/feOK3J3h9zut8s/IbBjUfRP3i9b2Od5Ipf0+h++TuuNZl6LVDub7C9V5H8h9/T8f8Mx2A8IN7ATB/vHrksC3dKFuXLBPJCepWz8uP79fmhl5L6DFwJYn70ujaPmeMcJEskpaG814v3AGTIaokzj2VYM9OnNdb4LZ/HZp2xbZ7FNvuUV/7Wd/jjBsM+SIh5TDuva9DhbqQtA+nV31snauhdDVvr0kuOgOvGsiKnSsYuXwktYvU5s6ad3odya+pgvLAxo0pYCE4fxpusuHw1lDS9ju4SQ77dlxCaKj/9rxJztO0dFNm3jWTV/73Ch8v+Zibv72Z1uVb81qz14jI5R/Pso1aPoonf3+SPMF5+Kz1Z35ZjHuqTCNsejG7bMEmAKrWLellIpEcoVLZPEwZVpvrey7hifdWk7g/lT5dSngdS7yyag4ULw/FygFgW3WHPVswq3/EGfUgdt1sbOf3Icg3gaf54yvslbf5PhtZzPcCCMsHMVVg178qdiXbOY7DyLYjuerLq+g3rR/VC1enbnRdr2P5LVVVHoiJCQEM+xaEc2BpGIfW5yJlRwglCuVWoStZIsgJom+jvvwe9zv1ousxYe0EGnzagE8Xf+p1NN6e8zaP/vookbkjmdhuogpdEclUJYvlYurw2pQtGkb/T9bz3OB/vI4kXtm5GVv4mGUeo0pCmsV9YS623BU4s7/A6d8YErfDoSTMvJ+wjW4++Tzb/oa1C6Fyg+xKLnKciFwRfNbmMxzj0PmHzuxK2uV1JL+lysoD/ftHExZmjtunNRwlO5TOX5rv2n3Huy3eJSQohKf+fIprR1/LXzv/yvYsruvyxG9P8Nqc1yibvyw/3foTFSIrZHsOEQl8UZEhTPm4FjVK5+PdbzfS5+W1XkcST9hT7DMQnh/7+GTcpg/A5sU4z9fDfPcGVLvcN4T5WAf34/TvgHvfIAj3j9FRcnGqUbgGA68ayK6Du+g4oSNpbtrZP3QRUrHrgbi4SIYOLUlEkWQwllKlQhg6tKTWcJQsNXnZZKo9V43K/Sqzev1qZt81m7iqcSzftZxrvrqGZh80o85Ldbi0/6XUfrE2ofeHsvvAbjbu3kjzQc2p8XwNar1QiyFTh1xwljQ3ja6TuvL5ss+pU6QOP936E0XCi2TCVYqInFpE3mB++qgmDSrn57Oft9DlyZW47jmsniCBI6oEZsfGo9s7N0Gh9KHJjoPtOBD37k8h5SDm65exBQsc//nUFJz+7bFNO8IVN2VbbJHTaV+1PV1qdmHpzqX0mdLH6zh+Sc/sekRrOEp2SnPT6DWqF5N7T6ZkwZI0fKUhbWq14Y3mb9C5VmcemvIQy3ctp0jxIjzf5Hk4CIOnDiYyPJLDqYd5vd3r1C1Vl32H9lF/QH2urno11YpXO27ipCoJW4GzT5x0IPkAt467lQXbF9CidAtGXD+CICco2+6FiFy8cudy+P6D6nR8ZCUTZu6g/UNpjH6zCiEh+t3/RaFSPdi8Brauh0IlMH+MwX3i8+Pb1L8Ft1BZnN4NcZZ+jfteCva+TyAoBPP2vdiYqtibVVSI/3ix8Yss27GMsavGcknRS7SSxQlU7IpcBOb8PYfyRcpTrrBvUo4O9TowYfEEqhWvRo3CNZjScQofL/yY12a/xn0/3UfozlB6XtETgGL5i1Esv+833/ly56NKdBX+3fOvr9g9ZuKkFWvHA1CpfNvT5tiZtJObvr2JtXvWcke1O3j1qlf9eikkEQk8QUEOowdV5t5+axg3fTut71/GuHerkSe3fukW8IKCce8fjNO3FaSlYa/pDKWrY374EAB7/X0AmHVLsJfdhA1LwVk0Hvt8Q9yWz+BM/QJbpiam56UAuJ1egvqtvLoaEcA3YdVnbT6j6cimvDDjBaoXrk6D4nqe/D8qdkUuApsTNhNT8OikHCULlGTO+jnHtbn7kru5pfItPPTLQ3y54kve/etd0sLTeKzhY0d6Xv/e+TcLNy6kQdmM/yO6dvda2o1rx/ak7Txa71EebvDwhV2UiMh5chyHj1+uRP5Xgvl08mauuWcJEz+oQf58+rEo4NVvhXtCgfpfkXtku0UnaNEJAHfcAMyPr+KMeZC0V3+A2tdmW1Q5wTGjyczWJQDY6JpHDl/My/Dly5WPL9p8Qeuxren6Q1d+jfuVouFaag30zK7IRcGeYlIOY8xJ+wrkKUCr4q1oWLYhxfMXZ8iCIVz++eVM3zid/Yf202FYBwZ1GEREnoxNyjF3y1xaj23NroO7eKPpGyp0RcQvDHqqHA+1L8Xyjftpfvditu9K9jqS+Bl749O4Pb8GwHm/PebblzxOdBEr0wh75ZO+V5Xrfa//tq988qItdP9TJaoKg5oNYs/hPXQc15GUtBSvI/kFFbsiF4ESBUuwMeHopByb9myiWIFip2z71dyv6NGkBzPumEGf2D7sPLiTDuM6UPXlqtxY50ZuqpOxSTkmr53MreNuJdlNZkSrEXSs3vGCrkVEJDP1e6AUz3Utyz/bk7j6nsVs2HzY60jib2pdi/vsbChcAWfyq5hBbeHQAa9TiZzkhko30P2S7vyV8BcP/vyg13H8gopdkYtAvdL1WLN9Det3ric5NZkxc8fQplabk9olHkzkz9V/ckPtG3Ach8caPsYfHf8gd0Ju9rh7+HTDpwyLH3bOM5h+svgT7p18L7mDczP2xrFcXfbqzL40EZEL1qtTCV5/sCLb9hzmmvsWsWJNkteRxN9ExeA+Pwv3kptx/pqC83w92LzS61QiJ3nm8mdoXKIxE9ZO4IP5H3gdx3MqdkUuAsFBwQy+dTCthrSixvM1aHdpO6oXr86Hf37Ih39+eKTduPhxtKjWgvBc4Uf2/b3jbzZs3kARU4R/V/5Lr097Uff9uizevviM3zlw5kCe+fMZioYV5ccOP1Inuk6WXZ+IyIXqfEtRhj5Vmb1JqVz/4GLmL9nvdSTxN8Gh2B6fk3bzq5C4GWdAY5j1tdepRI7jOA4jrh9BTL4YXpn1CtM2TPM6kqc0E4PIRaJVzVa0qnn8pBz3NTl+Uo5Ol3ei0+WdjtvXqEIjUoemApCclszz057ny+Vfcv3X19Oucjv6N+lPeOjR4th1XR6e+jBjVo6hYsGKjLt5HAXzFMyiqxLJXHO3zmXetnkA7EneC8AHi47+Zjy2aCz1out5kk2y3k3XRBERHkTn5//ipkeW8NmL1biqYX6vY4m/afkgbtm6OEPjcEZ0wa6bg71tIGh1AfET4aHhjGwzkpZft6Tb5G78GvcrxfKe+vG1QKdiV0TOWWhQKAOuGkDnmp3pPaU3X/31FVP+nkKL0i0YuWQku5J2EZUvChNkqB9dn1FtR5EnJI/XsXO8Wet2MXv97uP2DZ66+sj7BmUjaViuUHbHCkj1ousdKWbHpm0CoF3tkl5GkmzW/IqCjH29Orc9uZzb+y5j6FNVaNM80utY4m8qX4H7/FycwTfh/P4+7j/xcElHLvnieUL3J8C3b2I79cc2i/M6qVykykeWZ0jzIdz7073cNu42fun4C6FBoV7HynYqdkUkwyoVqsSPt/7I50s+57lpzzF65WiSSSZfWD5MkOHQ4UO0r9RehW4maViukIpZkWzU4JIIJg6pyY19lnLvy3/x5v4K3N62iNexxN/kL4L7zJ+YTx/AzPwUVv2PXAfTZ/TevgGGdAdQwSueua7CdTy440EGzx9M98ndGXH9CK8jZTuNtxCR83ZnzTuxqZYDhw6QKyQXuUJysS9pH3sP7qXfH/28jicict6qVwrn56G1iIoI4aG3VvPBl5u9jiT+KCgI2/UDOByBCQKiQyG3b2k/czgJ82lfb/PJRe+Jy56gWalmTF4/mbfnvO11nGynYldELsimvZs4cOgAu/ftZs/+PRxMPgjAxsSNZ/mkiIh/KxuTh1+G1SImKjf9PlrHK0P175qcxs5dsDUZUi1EhUDe9B+xd+jvjHhv+HXDKRNRhjfnvsmvf//qdZxspWJXRC5ITP4YANLctOMWMP9vv4hITlasSC5+HVGLyiXCeWPUPzzx+nqvI4k/KhwDacD2FDjkQsEQKBAEUXrmX7yXOyQ3o9qOIiw4jPt/up9/Ev/xOlK2UbErIhekf9P+hIWEHbcvLCSM/k37e5RIRCRzFYgI4efhNalTPoLhE/+l+7Orz3m9cbk42E79sbnCwAI7U2FfKuQLhiK54ECC1/FEKJ2/NO9d+x5JqUnEjY/jUMohryNlCxW7InJB4mrEMfT6oUSFRWEwlMpfiqHXDyWuhibkEJHAEZ4nmElDa9CoRkG+/mMbtz+2irQ0FbziY5vFYXsN5XDegljAhpbArdAC9m7Eeb4hbFl9tlOIZNjkZZOp9lw1KverzMDJA0/Z5veVv3Np/0up9UItXv7mZR6u9zDr966nyftNqP1ibWq9UIvBUwdnc/Lso9mYReSCxdWIIzyPb63dtuXbepxGRCRrhIY6fDukKp2eXMWPc3Zy4wOpfDO4GqGh6jsQX8G7cJ+vFze2bU/fvt+G43z1KM6AJrj3j4JqV3mYUAJJmptGr1G9mNx7MiULlqThKw1pU6sN1YpXO9JmT9IeHhz1ID/0+oFSkaXYvnc7RSKK8MeaP/hx9o/0a9ePJy9/klbvtKJVjVZULFrRwyvKGvrXWUREROQcBQU5fDawEh2bRfO/5Xto2W0J+5NSvY4l/qrpPbgPfAtYnHduhD8+8TiQBIo5f8+hfJHylCtcjtDgUDrU68CExROOazNqzihurHMjpSJLAVAkwreE2m0Vb6NQgUIMXTyUKX9PoUnFJoxbOC67LyFbqNgVERERyQDHcXj3uQp0b1uSRev30eLuJSQkppz9g3JxqtEM98nfIbwIzpcPYL7SckRy4TYnbCam4NHJQEsWKMnmhOOXSFu9fTV7kvbQ7M1m1B9Qn89nfQ5A7ZK1CU8LJ8yE8cDPDzBu0Tg2JWzK1vzZxW+GMRtjWgKDgSBguLX21ROOPwbcnr4ZDFQFCltrd2drUMkRZq3bxez1x//VGDz16PMyDcpG0rBcoeyOJSIiwNytc5m3bR4Ae5L3AvDBog+OHI8tGku96HqeZMuIlx8uQ4F8wQz88m+adl3MpPdrULxoLq9jiT8qUQX32f/hDGqNM/Ut3B1rsN0/h+AQr5NJDmWxJ+0zxhy3nZqWyvwN8/nloV84mHKQRgMb0aBsA6oWq8pT1z3Faz+/xqZ9m9ifb392xc52flHsGmOCgPeAFsAmYK4xZoK1dvl/bay1rwOvp7dvA/RRoSun07BcIRWzIiJ+ql50vSPF7Ng0X29Cu9o5c4mWx+4tSf58wfT9cC1Xd1vM90NqUL50Hq9jiT+KiMLt+yfm3Ticxd9jBzTFfeR7CC/odTLJgUoULMHGhKPrOG/as4liBYqd1KZQ3kKE5wonPFc4jSs2ZvGmxVQqWomuV3Sl6xVdeX/++zz53ZPM2DYjuy8hW/jLMOb6wBpr7TprbTIwGjjTLDcdgVHZkkxERETkDLrdFs2QRyqxe18KLXssZvFfgdtLIhcoOBT70Fjcpg/ApnicFy6DrWu9TiU5UL3S9VizfQ3rd64nOTWZMXPH0KZWm+Pa3FD7BqavmU5qWipJyUnM+XsOVaKrALB973YAWpdtTcihEDaxif7TA2/ZSL/o2QVKABuP2d4ENDhVQ2NMGNASeOA0x7sB3QCKFi3KtGnTMjdpJtq6ZSuAX2cUOVer9q8CYNpm/X2WwLBqk+8ZzGkH1nucJLAFyn0ukR8evcXw5jcurR5YSN/bLdUreJ3qqEC5z/4uces5/mxXsjXFLnWpuOBD3BcvZ+mVz5JYvFY2JAwM0Vt8P3Ns3Xtx/8zRrUY3mg5simtdrit/HbvX7uaxHx8D4IZKNwBQKawSlZ+qjDGG6ytcT8K6BKatm0avn3ux9/Begpwgnq73NGMSx/DBwg8I3R3KZQUvAwLjZztj7cnjvbM9hDHtgWuttfekb98J1LfWPniKtrcCd1hr25x47ESxsbF29uzZmZ43s/T79RMAXmrW2dMcIplh/NrxgJYeksAxdkH68Nq6OXN4bU4RaPd52txE7ui7nDQXPu5XhWub+McQ1UC7z/5q3vj3gKNLD53Vkl9wht0Jqcm4Hd+GJndlXbgAYhaNBMDWjvM4SeDYdmAbzUY243DaYSa1n0SlQpVyzM92wcHB8621sac65i/DmDcBMcdslwQ2n6btbWgIs4iIiPihxvXyM+6tmuQOcej8wgrG/rjT60jiz2q2wH3iVwiPxPmiB+br57xOJBepouFF+bjVx6S4KcR9H8f+5MB4HMNfit25QEVjTFljTCi+gnbCiY2MMfmBK4Hx2ZxPRERE5JzUqZaXSe/VokB4MD1eW8nwMVu9jiT+rGQ13GdnQbHqOL+8gXnvdkhL8zqVXIQalmhIv8v7sXn/Zu76/i5c1/U60gXzi2d2rbWpxpgHgJ/wLT00wlq7zBjTPf340PSmNwE/W2sPeBT1gh27JM7O3VGAlsQREREJNJXK5uGXD2tzfc8lPPn+GvbuT+PhriW8jiX+KiIKt980zDu34iwahx3QDPfhCRCe3+tkcpG555J7WLhtId+u/pbpG6aTcCCBmPwx9G/an7gaOW/YuF8UuwDW2knApBP2DT1h+xPgk+xLlfmOXRJn/Frfykpty1f0MpKIiIhkgZLFcjF1eG1a9VjCy5+uZ8++VF7sXdrrWOKvgkOxvb/BHfUY5o+hOC82xH34ByhazutkcpFpWKwhXy3/iuDgYIKDg9mQuIHuP3QHyHEFr78MYxYREREJOFGRIUwZXouapfPx3rcb6d1/bUAMDZQs4jjY29/Ebf8mJG7GebkxrAzM9U/Ffz37x7PsObCHNDeN/GH5cRyHpJQk+v7W1+toGaZiV0RERCQLReQNZvJHNWlQOT9f/LKFrk+vVsErZ9aiO+79Y8BNxRncBqZ/6XUiuYhsTNyIxZJ4IJHUtFSwR/fnNCp2RURERLJY7lwO339QnavrFuL7mTto3/svUlJU8MoZ1L7WN1NznoI4n9+H+eYFrxPJRSImv2+RnDQ3jT0H9uBa97j9OYmKXREREZFsEBTkMOrNytzUqAi/L95N6/uXcfCQZt2VM4ip7pupuUgVnJ9ew3xwl2ZqlizXv2l/wkLCjtsXFhJG/6b9PUp0/lTsioiIiGQTx3EY/nIlOl9XnHmrE7nmniUk7kv1Opb4s/yFcftNx61yNU78N5hXm0PSXq9TSQCLqxHH0OuHEhUWhcFQKn8phl4/NMdNTgV+NBuziIiIyMXizSfLUSBfMG+P2UDzuxcz6YMaFCkU6nUs8VehubEPfYf7xSOY6cMwLzbEfWQSFC7jdTIJUHE14gjPEw5A2/JtPU5z/tSzKyIiIuKBfj1L8VzXsvyzPYnm9yxmw+bDXkcSf+Y42Lvewm33Guz5F6d/I1j1P69Tifg1FbsiIiIiHunVqQRv9KrI9j2HadFtESvWJHkdSfzdNT1x7xsFack4b7eG/43yOpGI31KxKyIiIuKhTjcXZehTldl3MJXrH1zMvMX7vY4k/q5OK9zHp0LuAjif3ov5LudNHCSSHfTMroiIiGSrWet2MXv97uP2DZ66+sj7BmUjaViuUHbH8tRN10QRER5E5+f/4uZHl/DZi9W4qmF+r2OJPytVE/fZmThvtsL58RXc7Wux9wyHoCCvk4n4DRW7IiIikq0alit00RWz56L5FQX55o3q3PrEcuKeWcYHT1Wm7dW6T3IGBYri9puBGdIeZ/4Y3J3/YB+ZALnzep1MxC9oGLOIiIiIn6hfO4KJQ2qSN3cQ3V7+i8/HbfM6kvi70NzYh8fjXnEPzj+zcV5oCDv+8TqViF9QsSsiIiLiR6pXCuenobUonD+Uh99ew/tfbPY6kvg7x8F2Gkzaza9CwgbfTM1rZnudSsRzKnZFRERE/EzZmDxMHV6bmMK5eXb4Ol4ZusHrSJITtHwQ996RkHoIZ1ArmDXG60QinlKxKyIiIuKHikaF8uvHtahcIpw3Rm3g8dfWex1JcoJLW+M+PgVyR+D8392Y8a96nUjEMyp2RURERPxUgYgQfh5ek7oVIvj4h3+5r99qXNf1Opb4u9K1cfv9DwpXxPnhJcywu0F/b+QipGJXRERExEOTJ0O1ag6VKzsMHGhOOh6eJ5gn42pi/6rP/70dQ/GyyaSluRw6BA0bOtSt61CrlsPzz5/8WbmIFSyG228GboUrceaNxgy8Bg4d8DqVSLbKULFrjMlnjHnWGDPdGLPaGHNZ+v6o9P1VsiamiIiISOBJS4NevRwmTnRZssTlq68My5cf32bPHnjooSAWzA7m1u7/cLj4Itr2XI4xLlOmuCxY4DJ/vstPPxlmzfLkMsRf5cqDfXQi7mWdcdbP9M3UvHOj16lEss05F7vGmMLAPKAfUAgoB+QBsNbuBDoB3bIgo4iIiEhAmjMHypeHcuUgNBQ6dLBMmHB8D+2oUYYbb7SUKePw6cCK3HFdFDNX7KHlfUvASQUgJQVSU8Goc1dO5DjYLu/h3tgfdv+D0/8KWDPX61Qi2SIjPbv9gWigAdAYOPGf0/FA80zKJSIiIhLwNm+GmBh7ZLtkSd++Y61e7evdbdbMoWHDYOqXrcD9N5Zk8fp9NO+6hNq1DcWKOTRvbmnQIHvzS85hW/XBvfdzSDmIM+g6mD3W60giWS4jxW5r4H1r7QLAnuL4OiAmU1KJiIiIXATsKX6iOrF3NjUV5s83fP+9y6RJLi+/bLjr+jI8dWcZ1m49gKkwj1lzDzJ3rmHp0uzJLTlUbFvcR3+CXHlxRnTBfP+a14lEslRGit0oYM0ZjrtA7guLIyIiInLxKFECNm48Wt1u2gTFip3c5tprLeHhEBUFjRtbFi+GR+8pySv3V2Dz7kPc8thial2SzE8/aRyznEXZurjPzoSo8jjfv4AZfq9mapaAlZFidytQ/gzH6wBa8VxERETkHNWrB2vWwPr1kJwMY8YY2rQ5vrv3hhss06cbUlMhKQnmzDFUqQI7dkD7a6N559FK7NqTxrBPD5Mr/KBHVyI5SsFiuM/OxC3fGGfOSMxrLTVTswSkjBS7k4C7jTHFTjxgjGkA3IXvuV0REREROQfBwTB4sEurVg41aji0a2epXh0+/NDw4Ye+XtqqVX09u3XqOFx2mUPXrpYaNWDLFrj6aodX+xYl/N8GBBdI4PXv4pkxf6/HVyU5Qq482Mcm4Ta8C2fdDJwXL4eEzWf/nEgOYuypHhY5VUNjooH5QBAwAbgb+AIIBW4GNgOXWmt3Z03UjIuNjbWzZ8/2OsZx5m6dy7xt8057PLZoLPWi62VjIpHMMX6t73ddbcu39TiJyPmbtW4Xs9ef/j9jDcpG0rBcoWxMJHLups9L5PZnlpPmWj7uV5VrmxQ8cmzsgk0AtKtb0qt4F4V5498DILZtT4+TZIyZ+Abm+xcgLBK317dQ9lKvI52RWTQSAFs7zuMkgS2n/GwXHBw831obe8pj53oSa+3W9HV13wG64puN+U58k1VNAu73p0LXX9WLrqdiVkTETzUsV0jFrORYjWLzM+6tmrR/dBmdX1jBO49Wot11UV7HkhzAtn4UW6Q8zqf34rxxLW6nj6D+TV7HErlgGRnGjLV2g7W2LRCJbwmihkBha20ba+2mrAgoIiIiIuemTrW8TH6/FgXCg+nx2kqGj9nqdSTJKerf5JupOTQc5+O7MD+86XUikQt2TsWuMSavMSbNGNMPwFq711o711o7R725IiIiIv6jQpk8TBlWm2IFc/Hk+2u468HVPHBDAh0b7KJcueWMHKkf3eQ0yl6K23cGFCqHM/5ZzIj7NVOz5GjnVOxaa/cDe4DtWZpGRERERC5Yiehc/PpxbQqH5eaHxdvYyyGshQ0bUujefZMKXjm9QiVxn/0fbrkrcGZ9hnm9FRzWLN+SM2VkGPNvwJVZFUREREREMk+hgiEc+isPKbuDyVP+MGGVDxJSKIWkwy59+2p4s5xB7nDs45Nx68fhrJ2G8+JlkLDF61QiGZaRYvcxoJEx5gVjTERWBRIRERGRzLFpYypJf+Xm8OZQggukEVblEPkb7GdX3r288M4G1vytHjs5DcfB3vMRbpvnYOdaX8H790KvU4lkSEaK3alAbqAvkGCM2WqMWXfCa23WxBQRERGRjIqJCQFrOLQ+F3tnh7N/SR4ObwklONxlyNgNNOg0n9o3z+PBF9fy55xEXD2fKSewbR7H7fp/cHg/zustYN54ryOJnLNzXnoI2IBvmSERERERyQH694+me/dNJCVZwJC2N5hcqSEMeb4E5aqGMHrSDv6I38PIqVsYOXULBcJDaFA1P22bFaLt1YXInStDC3dIoGrQDrdQaZx3b8H56E7s9hewrfp4nUrkrDKyzu5VWZhDRERERDJZXFwkAA8//i+7trnExITQv3/0kf2X1fU9mbZuw0G+/H4HU2YnMHXBLn6at5OH33KoXS4frRoV4rbWhYmKDPHsOsQPVKiH23cGzputcMb1xd22BtvpHXD0CxHxXxnp2RURERGRHCYuLpLQKkkAtKtb8pRtypXKQ7+epejXsxR79qYwZtIuJv65k/jV+5i9MpEXRqynUokwmtUrSFzrIlStEJadlyD+IioG97lZmLfa4sz8BHfHemzvbyBXHq+TiZxShotdY0x5oC1QLn3XOmC8tVbP64qIiIjkcAUiQuh2WzTdbosmJcVl0u+7+W7qLmYuTeT97zbx/nebKB6Zm8a189PumiiuapgfR717F4/c4dgnfsYdfi/OvNHYl67AffRHKFDU62QiJ8lQsWuMeQl4Egg64dBrxpgB1tpnMy2ZiIiIiHgqJMShbYso2raIAmDOor2MnrSTPxYk8NVv2/jqt21E5AmmQdX83NC0EDddU4g8uU/8MVECjuNgu32MW7QiZtLLOC82xO09DkrX9jqZyHHOudg1xnQFngH+B7wOLE0/VB3fskTPGGPWW2v/L9NTioiIiIjn6teOoH5t33O+//x7iJHf7+DnWbv5beFuflmwi0cHO9Qsm4+WV0QS16YwRaNCPU4sWcm2fRJbtBzOZ/fjvHa1b9bmS1t7HUvkiIz07PYEZgNXWWtTj9m/1hgzCZgGPACo2BUREREJcKVL5Oap7jE81T2GvftTGTNpJ5Om7WLeyr3MW53IgE/XU75YOM1iCxLXujA1Kod7HVmyQsMOuIVK4bzbHuejONwdL0PLB71OJQJkbJ3dqsDoEwpdANL3jU5vc16MMS2NMSuNMWuMMU+eps1VxpiFxphlxpg/zve7RERERCTzROQN5p4O0Xz7TnXW/9iAz56vRpvLi5B4IIUPJ2ziym7xVL9xLt36reLnaQmkpWk934BSsSFu3+lQIIagb5/EfNobtGaz+IGM9OwmA3nPcDxfepsMM8YEAe8BLYBNwFxjzARr7fJj2hQA3gdaWms3GGOKnM93iYiIiEjWCQpyuL5pJNc39S1vtGDZfkb/sIPf5ifw7bTtfPPndvLlDqJelfy0vrIQ7a4rRHgeLRCS4xUujfv8bMybN+DMGO6bqbnXGAjN7XUyuYhl5F+WucB9xpjh1tptxx5ILzy74RvmfD7qA2ustevSzzca34zPy49pEwd8a63dAGCt3X6e3yUiIiIi2aRu9bzUrZ4XKMu/Ww8z8vsd/DRzN9OW7OHXhbt58r21VC+dl5aXR9KxdWFKROfyOrKcr9x5sU/+gvvR3TgLvsa+1Aj30UmQX31U4o2MFLsvAVOBFcaYjzlaiFYHuuDr2b39PHOUADYes70JaHBCm0pAiDHm9/TvGmyt/ezEExljuuErvClatCjTpk07z0gikhGr9q8CYNpm/X9ORMTfrNqUAsC0A+s9TgINq/heBw9Z/lzgMHOp5a8Ne4lfu5dXP/+b6PyGS8pBs1iXiqW9TpsxiVu3Aujnz+p3U/pQKKWXjyT1mTosbj6AA1Hlzv65cxS9xfczx9a9F/l9zmKB8LPdORe71to/jTE3A+8Cj5xweAPQyVp7vnfCnOorT9gOBi4FmgN5gJnGmFnW2lUn5BwGDAOIjY21jRs3Ps9IIpIRu9fuBqBxef1/TkTE32xbsAmAxnVLepzkeNe08P2ZluYyZUYi3/yygxmLE/kx/jA/xhuK5A/l8poFuPnqKFo2KUBQkH+v5ztv92IAYvXzJzRujP1fU0K/6Ens1Mdw7/4E6rTKlFObRb4+soq1dZ+zUiD8bJehBySstd8bY37AV3SWxVekrgUWWGsv5Cn0TUDMMdslgc2naLPTWnsAOGCM+ROoDaxCRERERHKsoCCHa5sU5NomBQFY/Nd+Rk3cwW/z9zB+xnbGTd9OeK4gYitH0LpJFO2uK0REXj3n6/cu74gbVRrnvQ44H3bEvXkAXNPT61RyEcnwvxLpRe3c9FdmmQtUNMaUBf4FbsP3jO6xxgPvGmOCgVB8w5zfysQMIiIiIuIHalXJS60qvnlRt2w/zOgfdjJ5xi5mLk/kj8UJPP3BWqqVCqdFw0huv6EIpYqf23O+kyfDww87pKVB166WJ544fiDh77/DzTc7lC3r277xRku/fpaVKyEu7miv8rp18Pzzlt69TxyIKADMm4wz9GFw07Atu+L2nY7zZiucsY9jt67B1roB56VbINp3o+3lN2Jv7+f77P49OG93g3+WgTG4fT6Cqpd5eDGSk51zsWuMaQ5cba196jTHXwF+ttb+ltEQ1tpUY8wDwE9AEDDCWrvMGNM9/fhQa+0KY8xkYDHgAsOttUsz+l0iIiIiknMUK5KLPl1K0KdLCQ4eSuPbn3bx/e+7mL0ikTdG/cMbo/6hTJE8XHVpQW69Lor6tSNOeZ60NOjVy2HyZJeSJaFhQ4c2bSzVqh3frlEjmDDh+AGLlSvD/PnukfOUKuVw440qdE8pLQ3nvV64AyZDVEmc3g2xDdrgPjsL89YNONOH4a6aC9Uux31p4kkfN0P7YGOvxfYdAynJcDjJg4uQQJGRnt0ngMQzHC+b3ibDxS6AtXYSMOmEfUNP2H4deP18zi8iIiIiOVue3EHc3rYIt7ctguu6/D4rka9/2sn0xYl88uNmPvlxM1H5Qrm8Rn5uvDqKVlcWJCTE1yM7Zw6ULw/l0udJ6tDBMmGCoVq1jBWtU6f6zlE6h02elW1WzYHi5aGY70bbKztgZk3A3vok9smpuMO64Mz8GpucBxJ3QP7CRz97YC9m6TTcR0b4tkNCfS+R85SRYrc28NoZjs8GHr+wOCIiIiIiZ+c4Ds0uL0izy33P+S5fncSoH7YzdU4CE2ftZMLMHYQNDKJupQiub1yI3CmFiYk5OidqyZK+AvhEs2ZB3boOxYrBa6+5VK9+/PExYwy33aZe3dPauRlb+JipeKJKwsr0Gx0UhL3/M9zUIMzkz3E6lYIK9XEffB9KV4et6yB/FGbQ3Zh1i7EV62K7vwW5w725FsnxMjKlXX7gwBmOHwQKXlgcEREREZGMq1YxjJceKsP/RtZh2Tf1eK5rWWqUzcvcvxJ56oM19Bq4hol/7Obl9zewbsNBAMwJ64HUrQvr1rksWODSs6fLLbcc/6NycjJ8/72hXTsVu6d3qntz/I22XQfjPvIhFMsDuxbjPHOd70BaKqyJx15/H+578yB3OGbMwKyPLAErI8Xuv/hmYT6dS4GtFxZHREREROTCFCkUSq9OJfhxWE3WTWrIe49Vpn6t3OzdE8SgrzZQ7875PPHav8z/axczF+zFdX3P40ZEQF7fvFi0agUpKbBz59HzTp4MdepA0aIeXFROEVUCs2Pj0e2dm6BQsePbhEdAs7txe0+AfGGwZwtMeMPXCxxVEqo0AMA2uhmzJj4bw0ugyUix+wPQyRhz9YkH0iev6sQJz9yKiIiIiHgpdy6H21oXZtJnpSkWUYD3+9Smw5XR7NkUydLdf9O6z2Iqt5nLnY+tZMSo3Rw+7Ct858wB14VChY6ea/RoDWE+q0r1YPMa2LoeUpIxf4zBNmxzfJvdW8FaqNIIt+O74AThfP8s5sfXoXBJ2LQSALPwV2ypqh5chASKjDyz+zJwC/CTMeZHYCG+cQp1gOvw9eq+lNkBRUREREQuVHAwDB7s8sgj+UlLy88zj1radazKI08d5K+/k/hp3j98Nz6EHveFkSe3Q6GCDkOHgW/VS0hKgilTDB984J7lmy5yQcG49w/G6dsK0tKw13SG0tUxP3wIgL3+Psz0b3zbQcEQmhv3ue9xJr2E88dQ3BINcQbeAampUKwsbp+Pvb0eydHOudi11m4zxlwOfICvuG313yHgR+ABa+2WzI8oIiIiInLhWrWCVq2OLVbz8P3oPEAkuxKK8tUPO5g0fQ0L1+4lIdnlzgGGyp+Gc3WDSG5vU5jt2/N4FT1nqd8Kt36r43bZ6+87+v6Gntgbeh533L2kGWboXTiLxmGL1cB95BeIiMqWuBK4MtKzi7X2H6CVMaYgUAHf0+arrbUJWRFORERERCQ7FCoYQo87itPjjuIkJ7t8/+tuvpu6k1nLEhkydgNDxm6gZKHcNLmkIB2ui+KKS/PhOBl5IlDOKCgI2/NL3K+fxfwyCOfFhrh9JkKJKl4nkxwsQ8Xuf9KL27mZnEVERERExHOhoQ63tIzilpZRuK7LzPj9jPlxB3/E72Hk1C2MnLqFguEhNKiWnxuaFqLt1YX49ps9PP5wLNt25SImZjn9+0cTFxfp9aXkOLb9i9ii5XFGPYTz6lW43T6Hmi28jiU51DkXu8aYCkAFa+3kY/Y1APoCkcCn1tphmR9RRERERMQbjuNwxaURXHFpBADrNhzky+93MGV2AlPm72Ly3J30et1weGcQhwnGGtiwIYXu3TcBqOA9H0064UaVwRnaEee9drjtX2dW2VuYvX43AJv/8jUrvnP1kY80KBtJw3KFTnU2uYhlpGd3IL6idjKAMSYK37O6efGtsfuBMWa7tXZcZocUEREREfEH5UrloV/PUvTrWYo9e1MYM2kXz7y6AScihbBCqbiHDQeWhpGU5NC371YVu+er2pW4T/+JM6g1zld9uKzpWhp29K25O2//zwDENq/oZULJATLyoEEsMOWY7Y5ABFAXKAzMBnpnXjQREREREf9VICKEbrdFs2dZLvbOCefAsjwYB/LWSsIJS2PjxhSvI+Zs0RVwn5sJJevg/PYu5u12kJrsdSrJQTJS7BYGNh+z3RKYYa1daq1NBkYD1TIznIiIiIiIv4uJCQEMqXuC2b8kDGshb82DFCnjdbIAEF4Q9+nfcGvdgLP8R5wnanLJF89Sf2hvnE7lML+O9Dqh+LGMFLsHgAIAxpggoBHw5zHHD+Lr6RURERERuWj07x9NWJgBwD3osH9xGDbVkFx8P2Mm7fQ4XQAIDsE+MAq34rWwdyO5wpMwQWC2b8AM6a6CV04rI8XuMuBOY0wh4F58z+r+cszx0sCOTMwmIiIiIuL34uIiGTq0JNFRhzDGElM0F8/dWY7C+UN54PWVDB+z1euIAcEsXYjZmQrBBoqEggPmcBLm075eRxM/lZEJql4HxgPb07fjgWnHHL8GWJBJuUREREREcoy4uEgqhc8DILZtTwDatytIqx5LeOr9NRw4mEbvTiW8jJjz7dgI1sL2FCgSAlEhvvc7NnqdTPzUOffsWmt/AJoBbwMvANdYay1Aem/vJuCTzI8oIiIiIpLzlIjOxdThtSlTNIwXR6znpXc3eB0pZysc4/szxcLuVMjlQMFgKFzS21zitzIyjBlr7Z/W2kestS9aa3cfs3+XtfZmLTskIiIiInJUVGQIU4bXolpMXt7+egOPDVzndaQcy3bqj80V5ts46EJiKuQNwlav6W0w8VsZKnZFRERERCRj8ucL5ufhNbm0QgQjJm3mvn6rcV3X61g5jm0Wh+01lMN5C2IBm6s4NqIUZs2vMF2TVMnJMvLMroiIiIiInIc8uYP4YWgN2j+0grF/bmP/42l8NrASQUHqe8oI2yyOhfsSgPRno/fuxHmhPs7IB3FLVIGydT1OKP5E/+8SEREREckGISEO3wypSst6UUyeu5Obe60gJUU9vBckIgr3gbGAwXm3HezVUk9ylIpdEREREZFsEhTk8PlrlehwVVGmL03g+u5LOXgozetYOVvZurhxQ2Dfdpy320Ka7qf4qNgVEREREclGjuPwwQsVufv6Esxfs5dr7llC4r5Ur2PlbI3isFfdj9m0EPNxN6/TiJ9QsSsiIiIi4oHXHi/LQx1KsXzjfq6+ZzE7d6d4HSlHs7cNxK1wJc680TD5Ha/jiB845wmqjDGrgI+BT621W7MukojkFHO3zmXetnnH7ftg0QdH3scWjaVedL3sjiUiIpJj9OtZioi8QfT/v/U0v2cRk96vSYnoXF7HypkcB9vra+zz9XDG9cWNqQHVm3qdSjyUkdmYU4BXgJeMMZOA4cAka62eqhe5SNWLrqdiVkRE5AL17lSCiPBgnnhvDVd3W8T3Q2pSoUwer2PlTLnDcR+agPNyY5wP78Dt9z8oXNrrVOKRcx7GbK2tDlwOfAo0BcYDG40xLxtjymdRPhERERGRgNelXVHefawyew6k0rLHYhb/td/rSDlXdAXcriPg8D6ct26A5ENeJxKPZOiZXWvtLGvtvUAx4B5gPfAUsMoY86sxJs4Yo3EXIiIiIiIZ1KFVFP/3bFUOJqdxw0NLmRW/1+tIOVed67Ct+2J2rsG8F+d1GvHIeU1QZa1Nstb+n7W2EVAFGA1cBXwObDbGvGWMKZV5MUVEREREAl/LKwsy+pXquK6l/ePLmDojwetIOZZt8zhu7bY4K37CfP2c13HEA+c9G7MxJsgYcxMwCLgVsMBvwCzgQWCFMaZtpqQUEREREblINK6Xn+/erElIsOHOZ1cw/pedXkfKsex9n2KLVcdMeRPmfON1HMlmGS52jTFVjDGvA/8C3wCxwBtAJWvt1dba6/H19q4EXsvMsCIiIiIiF4NLa+blh3dqkS9PMN0GrOTL8du9jpQzBYfg9vkewgrhfNodNi7zOpFko3Mudo0xXY0xM4BlwMPAIqA9UNJa+6S1du1/ba21a4AhgCauEhERERE5D1UrhPHzh7UonD+UPm+vZujILV5HypkKFMXt8RW4aThDboIDiV4nkmySkZ7d4UBZ4FWgvLX2WmvtN9ba1NO0X47vGV4RERERETkPpUvk5pdhtShZKDd9h63l9Y82eR0pZ6rYELfDG5D4L+btm8DV6qkXg4wUu7cAMdbaZ6y1f5+tsbV2jrW2y3knExERERERihXJxdSPa1GxWDivfvE3/d7+2+tIOVPTrtjLu+L8Mxvz6YNep5FskJFitw2+53NPyRhT3xgz4sIjiYiIiIjIsQrmD+GXj2tSq2w+3v9uE737rz37h+Qk9q7BuGUbYmZ+AlOHeR1HslhGit3OnPkZ3LJApwtKIyIiIiIip5Q3LJgfP6xJwyr5+eKXLXR9aiWuhuNmjONge30L+UvijH0CVs7wOpFkofNeeugUwoGUTDyfiIiIiIgcI3cuhwnvV6fZJZGM/98Obu3zF2lpKngzJDw/bu/vICgE54OOkKCJvwLVGYtdY0wpY0wTY0yT9F1V/ts+4XUjcD+wJqsDi4iIiIhczIKCHL56qwo3XFaYXxfu5oYey0lOVsGbISWr4Xb6EA4m4AxqA6nJXieSLHC2nt0uwO/Ab4AFnkl/f+LrW6AOMDCrgoqIiIiIiI/jOPzfq5W5o0UxZv21h2u7LWF/0ukWSZFTqncT9ppHMdtWYIbe5XUayQLBZzk+DvgbMMAIYBgw84Q2FtgPzLXWbszkfCIiIiIichqD+5YnX3gQH4zbRIt7lvDj0BoUiAjxOlaOYW95DnfjEpzF3+OOfxXb9kmvI0kmOmOxa61dBCwCMMaUBr6x1i7NiiDGmJbAYCAIGG6tffWE41cB44H16bu+tda+mBVZRERERERyiv59yhARHsRrI/+hWdfF/Di0JkWjQr2OlWPYHl9gX7wMM2kAtlQtqNPK60iSSc55gipr7QtZWOgGAe8B1wHVgI7GmGqnaDrNWntJ+kuFroiIiIgI8Hi3GPp3K8/GnYdofs8i/vn3kNeRco7Q3LgPTYDcETgjusKW1V4nkkxy2mL3hImpOM3EVCe9zjNHfWCNtXadtTYZGA20Pc9ziYiIiIhcdLrHFWPQQxXYkZjMNfctZsWaJK8j5RxRMbj3fQkph3DebguH9nudSDLBmXp2fwd+M8aEHrt9htd/x89HCeDY5303pe870WXGmEXGmB+NMdXP87tERERERALSnTcWZdjTldl3MJXrH1zMgmUq2s5ZtStxbx6ASfgHM7gdaA3jHO9Mz+x2xTf5VMoJ21nBnGLfid+1AChtrd1vjGmFb/KsiiedyJhuQDeAokWLMm3atEyOKiIiIpKzrNrk+3Fu2oH1Z2kpFyJx61YAz3/+jMwNT3SAgWNc2vRayNNxllqVPI2UqbL0PuepSeXSV1Ns7RQ2vXE7ay7rkfnfkUOs2r8KgGmbc249ddpi11r7yZm2M9kmIOaY7ZLA5hO+f+8x7ycZY943xkRZa3ee0G4YvlmjiY2NtY0bN8661CIiIiI5wLYFmwBoXLekx0kC27zdiwGI9YOfPxs3hgb193Lbk8sYMMrycb+qtLyyoNexMkWW3+fLL8cOuIoSayZQ7LJW0PjOrPkeP7d77W4AGpf3/u/z+TrnCaqMMbWyMMdcoKIxpmz6sOnbgAknfH+0Mcakv6+PL/uuLMwkIiIiIpJjNawTwYTBNckTGkSXF1cw9sedZ/+QQFAQbp/xkK8YzqiHYP18rxPJeTrnYhdYaIxZYIzpbYwpnJkhrLWpwAPAT8AKYIy1dpkxprsxpnt6s3bAUmPMImAIcJu1NquGVYuIiIiI5Hi1quRl8vu1KBAeTM/XVvJ/Y7d5HSlnyBuJ2+sbwOC80w4Sd3idSM5DRordgUAh4C3gX2PMeGPMLcdMYHVBrLWTrLWVrLXlrbUvp+8baq0dmv7+XWttdWttbWttQ2vt/zLje0VEREREAlmFMnn45cPaRBfMxePvrmbIp/96HSlnKF0b9453YP8O3wzNaWleJ5IMOtMEVcex1j5ljHkaaAbcBdwEtAb2GGNGA59Za2dnTUwRERERET/093TMP9MBCD/om2LG/PHqkcO2dCMo08iTaMcqWSwXU4fX5rr7l/DCiPXsO5DGMz1KeR3L/13eEbthMc6vQzDD78He939eJ5IMOOdiFyB92PBUYKox5n7gFnyF731Ad2PMKmtt1cyPKSIiIiLih8o0wqYXs8vSJwKr6qcTgUVFhjBleC2uv38pg77aQOL+NF57vKzXsfye7fAy7qalOPPH4P54Cfa63l5HknOUkWHMx7HWJllrP7fWtsBX8O4DAmhScxERERGRwJI/XzC/DK9J3QoRfPzDv9z/3GpcrSd7Zo6DfWA0tlBZzPhnYckUrxPJOTrvYtcYU8EY86IxZh3wORAGTMy0ZCIiIiIikuny5A7ihw9q0KhGQcb8vo07H1+lgvdscofjPjQBQsJwProLdvztdSI5Bxkqdo0xBdJnSP4fsBLoCyQCjwAlrLVtsyCjiIiIiIhkotBQh2+HVOXa2Cgmz93JLb1WkJKigveMipbDvfcTSN6P89YNcPig14nkLDKyzu5YYAvwPlAWeBu4xFpbx1r7trVW83GLiIiIiOQQQUEOX7xeiXZNivLnkgRa37+Ug4c04/AZ1boW2+Y5zM61mPdu8zqNnEVGenavBybgm4G5pLX2EWvt4qyJJSIiIiIiWc1xHD58qSJdrivOvNV7ufbeJezdn+p1LL9mr38E95Kbcf6aghnTz+s4cgYZKXajrbW3pq+Hq1/5iIiIiIgEiDeeLMdD7UuxbMN+rr57MTt3p3gdya/ZbiOwxWtipr4Fs772Oo6cxjkXu9baxKwMIiIiIiIi3un3QCn6dSnL+m1JNL9nEf9uPex1JP8VHILbZwKEReF83gM2LPE6kZzCadfZNcY8C1jgZWutm759NtZa+1KmpRMRERERkWzzUOcS5A0L4ukP1tKi22K+f6cG5Uvn8TqWf8pfBLfn1ziDrsUZcjPuC3MgvKDXqeQYpy12gefxFbsDgeT07bOxgIpdEREREZEc6p4O0UTkDabXG6to2WMx3w2qQY3K4V7H8k8V6uHeOgjny56Yt2/CPvUrOOe9uqtksjMVu2UBrLXJx26LiIiIiP+btW4Xs9fvPm7f4Kmrj7xvUDaShuUKZXcsySE6tIoib5jDvf3/onXvJXz1ajUaXBLhdSz/dGVn7D+LcKYPw/2kJ7brB14nknSnLXattf+caVtERERE/FfDcoVUzMoFaXVVJKPCqnNH3+W0e2wZn75QhWaXa5juqdg73sTdvAxn1meklaoNV3f3OpKQsXV2fzXGND/D8abGmF8zJ5aIiIiIiHitSf38fPdmTUKCDXf0W8H4Kbu8juSfHAfbayy2QAzON0/CX9O9TiRkbOmhq4CiZzheBLjygtKIiIiIiIhfubRmXiYOqUXe3EHcN2AlIyds9zqSfwqLwH1oPATlwhnaERI2e53oopeZT08XADQ/uYiIiIhIgKlWMYyfhtaiUEQID721mg9HbfE6kn8qXhm3y0dwcA/OoDaQmnz2z0iWOdMEVRhjagGXHLOrsTHmVJ+JBHoAyzMvmoiIiIiI+IuyMXmYMqwWrXos5ZkP17LvQBqP3lPS61j+59IbsC2fwPnxFcz7d2B7jfE60Tmbu3Uu87bNO27fB4uOTrgVWzSWetH1sjvWeTtjsQvcBDyX/t4C96W/TmUf0CuTcomIiIiIiJ8pViQXv35ci+u6L+WVz/9m74E0Xuxd2utYfsfe1Bd342KcpT/gjhuAvfFpryOdk3rR9XJUMXs2ZxvG/AnQFGgGGGBA+vaxr6uAWKCotXZyVgUVERERERHvFcwfwpSPa1KzTD7e+3YjfV5e63Ukv2R7fIEtUhnz4yswf4LXcS5KZ+zZTV9u6B8AY0wX4A9r7d/ZkEtERERERPxU3rBgJg+ryc0PLuOzn7eQeCCN4f0r4DiZOSVQDhccittnAs6Ll+H83724xSpD8cpep7qonPPfRmvtpyp0RUREREQEIHcuh+8/qE7TSyIZP2M7HR9ZSVqa63Us/1KoJO79oyDtMM7bbSFpr9eJLioZ/tWLMSbWGNPTGNPXGPPsCa9+WRFSRERERET8T1CQw5i3qtDmssJMWbCLtj2Xk5ysgvc4VRrh3vIqZs9GzJB24Or+ZJezTVB1hDEmD/AtcA2+53dt+p8c894CL2VyRhERERER8VOO4zBiQEV6vxzMyClbuO6+pUx4vxrhec651Ah8V3fH/SceZ/YXuF8+gr3zLa8TXRQy0rP7LL5C92V8E1MZoBNwHTANmAtUy+yAIiIiIiLi3xzH4Z1+5enetiQL1+2lxd1L2LM3xetYfsV2+QBbKhYzbRj8+anXcS4KGSl22wFfW2ufBZam7/vXWvsTcDUQCnTO3HgiIiIiIpJTvPxwGR6PK82qzQdodvditu1M9jqS/3Ac3D7jIKIYzug+sGau14kCXkaK3Rjgj/T3ael/hgJYa1OBUcBtmRdNRERERERymifui+Gle8uxccchrr5nEf/8e8jrSP4jvCBur+/ABOG81x4St3udKKBlpNjdx9FnfPcBLlD8mOOJQHQm5RIRERERkRzq/tuL82bvCmxPTOaa+xazcl2S15H8R6mauHe+D0k7cd66AVI13DurZKTYXQtUArDWpgHL8A1txhhjgJuBjZkdUEREREREcp67birK0Kcqs+9gKq16LmbBsv1eR/IfDdtjmz2E2bwE89HdXqcJWBkpdqcAtxhjgtK3PwRaGmPWAqvxPbf7cSbnExERERGRHOqma6L49IWqHE613PTwEqbPS/Q6kt+wt/bHrXI1Tvw3mB/e9DpOQMpIsfsqR2dhxlr7PvAovuHLCcDTwGuZHVBERERERHKuFo0K8vXA6hjgtqeW8dOfCV5H8hu252hsVHnM9y/A4p+8jhNwzrnYtdbut9auTJ+M6r99g6y1da219ay1A621NmtiioiIiIhITnVZ3QjGv12T3CFBdH5hBd9M3ul1JP+QKw9unwkQmhfno86wbZ3XiQJKRnp2RUREREREzkvtqnmZ9F4t8ocF02PgSj75ZpvXkfxD4TK4934GKUk4b7eFQwe8ThQwgs/exMcYc9dZmljgILABWHBsD7CIiIiIiEilsnmYMqw21/dcwmPvrGb/gTQeuKv42T8Y6Gpejb3heZxxfTHv3oZ9eDw46pe8UOdc7AKf4Cto/2PS/zxxnwV2GWOesdZ+dGHxREREREQkkJQslotfPqpFq/uX8vyIdSQeSOWZ+0t5HctztlUf3A2LcBZ8jTumL/a2AV5HyvEy8uuCFsAC4G/gSeDG9NdT6fvm4Vt+6HFgPzDUGHNLpiUVEREREZGAUKRQKFM/rkWVknkZNHoDT76x3utIfsHe+zG2RG3Mr0Pgf6O9jpPjZaTYvQLIBdS01r5urZ2Q/noNqA2EATWstW8CtfAVwA9ndmAREREREcn58ucL5pfhNalTPoKPvv+XHs+vxnVdr2N5KygI96HxkLcwzpcPwD+LvE6Uo2Wk2L0b+NRam3TiAWvtfnzDnO85ZvszoGYmZBQRERERkRxi8mSoVs2hcmWHgQPNSccnTIA6dRwuvdThqitD6HtXTa6oXoCvfttGwxa7qFXLoVYth8GDT/7sRSF/YdyeX4O1OENugf27vU6UY2Wk2C0CBJ3heDBQ9JjtzWTsmWAREREREcnB0tKgVy+HiRNdlixx+eorw/Llx7dp1gwWLHCZP9/lo49cevYM4rt3qtGwTAkWzs1HmcuXMnt2Kj/8YFi92pvr8Fz5WNzb3oJ9W3DeutF3YyXDMlLsrgLuNsZEnHjAGJMfX8/vymN2lwW2X1g8ERERERHJKebMgfLloVw5CA2FDh0sEyYc30ObNy+Y9F0HDvjeBwU5dLq+DBUqpjBjxW5ufHAZl1+exrhxF2nvLkCTu7BXdsdsnI/5v+5ep8mRMlLsvghUAFYaYwYYYzqnv14B/gLKA/0BjDEOcBswI7MDi4iIiIiIf9q8GWJiji7WUrKkb9+Jxo2D6tUdbrjB4aOPfM/p1qxpsEn5ufXKksz9ax9vf3CIdevsyR++iNiOr+OWb4QzZyT8/L7XcXKccy52rbXfAHGAi2825hHpryfS991hrR2b3jwIuA548FzPb4xpaYxZaYxZY4x58gzt6hlj0owx7c713CIiIiIikvXsKWpTc4rO2RtvhGXLXL75xuW553wlSdWq8Nhjlrk/lqPA9nokB+9l/G872JWQkrWh/ZnjYHt/gy1YGufbp2H5H14nylEytFKxtfYroBTQEOiIr/i9DChlrR11TLsUa+1Ka+05PU1tjAkC3sNXIFcDOhpjqp2m3UDgp4zkFhERERGRrFeiBGzceLS63bQJihU7ffsmTWDdOti507fdtatl7lyXdatCaFQ3nH12H83vWczmbYezOLkfy53XN0NzSG6cD2+HnRu9TpRjZKjYBbDWpllr51hrv7LWjrbWzrbWXugT0/WBNdbaddbaZGA00PYU7R4EvkHPAouIiIiI+J169WDNGli/HpKTYcwYQ5s2x3f3rllztAd4wQJfu0KFfNvb03/K37AB/l0XQf8nwtm8+xBXd1vM2n8OZuOV+JliFXG7DIdDe3HevgGSD3mdKEfI8GzJxpgmwDX4Zl5+01r7lzEmL1AXWGyt3XMeOUoAx/6KYhPQ4ITvLQHcBDQD6p0hXzegG0DRokWZNm3aecQREREREcmYVZt8w22nHVjvcRJvdesWSdOmFXBdw3XXbWH37g089lhxAG64YTOjRsXw00/RBAdbcuVK48kn1zF9eiIAvXpdwt69IQQFWXr0WEPdinvo2drw3sTDNL93Pi92sUTu3QpwEf6cn59S1eMot/RzEvpfx9IWL2b6NyT+s4jQnUsASDvgG6QbFB555HhyVE3yl66d6d+bVYw91cD6UzX0DSEeCbQDDGCBFtbaX40xufEtNfSGtXZAhkMY0x641lp7T/r2nUB9a+2Dx7T5Gl9xPcsY8wkw8ZhnhE8pNjbWzp49O6NxREREREQybOyCTQC0q1vS4ySB54ffdtPt5b/AhbRVDru25SYmJpT+/aOJi4s8+wkCiHn3NpzF3+O2fAJ787NZ9j3zxr8HQGzbnln2HZkhODh4vrU29lTHMjKM+QngFuBhoCq+ghcAa+0h4Dug1Xlm3ATEHLNdEl/xfKxYYLQx5m98Bff7xpgbz/P7REREREQkh7i+aSR3NyvFwUOW5FJpmDCXDRtS6N59EyNHntM0QQHDdv8MW7Qq5qfXYd54r+P4tYwUu3cBn1lrBwM7T3F8Bb7lh87HXKCiMaasMSYU37JFE45tYK0ta60tY60tA4wFelhrx53n94mIiIiISA7yxfC97F8chnUhX+0kwiofJDkkhb59t3gdLXsFh+I+/D3kKYjzyb2wabnXifxWRordMsDMMxzfAxQ8nxDW2lTgAXyzLK8AxlhrlxljuhtjtIKyiIiIiMhFbuPGFNxDDvsXh3F4awjBBdIIr3GQhMKJ9O6/ljV/X0QTWBUshttjNKSl4Ay5GZL2ep3IL2Wk2N0HnGlAfAVgx/kGsdZOstZWstaWt9a+nL5vqLV26Cnadj7b87oiIiIiIhI4YmJCALDJDofW5Wbv3HCSVuUmyHX44pctNOw8n6vuWsTwMVtJTnY9TpsNKl2O224g7NmIGXwzuBfBNWdQRord6cAdxpy8LLQxpiDQFfgts4KJiIiIiIj8p3//aMLCjilFXEPIgVCG9KnEz+9ewg2XF2H9tiSeeG8NFdvM5u5nVhG/fL93gbND827YyzrjrJ+J+byP12n8TkaWHnoZX8H7K/BJ+r7axpiKwJNAOPBqpqYTERERERGBI7MuP/7warbtynXSbMwjalbi0GGXz8dt54sftjF+xnbGTd9OhWLh3HZtEe69tSh5wzK88qrfs53ewd28AjNjOLZUbWja1etIfuOclx4CMMa0Aj7Gt8Yu+JYfMsB24C5r7c+ZnvACaOkhEREREckuWnooe5zrkjir1h/knS828+PMnSQcSCF3iMOVtSO5/7ZiNK6XPzuiZp8DiTjP14P9O3EfngQVG17wKQNh6aEM/WrDWjvJGFMGaMHR5YdWAz9Za5MuNKiIiIiIiEhmqFQ2D+/0K09aWlm+/nEX/zduK1MW7OKneTuJicrDLc0K0yOuGIUKhngd9cKF58ft9R3Oq1fhvH8r7nNzoEDRs38uwGWoZzenUc+uiIiIiGQX9exmob+nY/6ZDsDyLb6Zh6sVizhy2JZuBGUanfU0m7Yc5t0vNzPhz51sSzxMSJBDw6r5ueeWYrS6qgCOk5EpjfzQnG9wPu4M0VVx+82A4PMv5C+6nl0REREREZFsV6YRNr2YXZb+S4Wq5/FLhZLFcvHqo2UZ8HBpfvxjD8O/2cLM5YlMeyGBIm+HckPjwjx4R3FKFsuVqfGzTf1bsP8sxvnlDcyHnbE9v/Q6kafOWOwaYyZk8HzWWtv2AvKIiIiIiIhkKcdxuL5pJNc3jWRXQgpDR23h66k7GD7xX/5v0mbqlI+gc9toOrQqRFBQzurtte1fwN20GGfRONzvX8e2eczrSJ45W89u6wyeL3DHRIuIiIiISMApVDCEZ3qU4pkepZg2N5GhX23h94W7eeCNRPp+EEKrhlE8cEcxKpcL8zrqObM9R2Gfb4D54SVsqVpQ+1qvI3nijL+msNY6Z3sBzYC56R/ZkuWJRUREREREskDjevn58o0qrJxQn35dylI4fygjp27hiq4LaHLnQoaN3sqhw67XMc8uNDdunwkQmg9neGfYusbrRJ447z55Y0wNY8wPwFSgMtAPqJhZwURERERERLyQNyyYhzqXYNaoOkz54BJuvKII/2w/yFMfrKHyDbPp+vQq5i/Z73XMMytcGve+LyAlCefttnDogNeJsl2Gi11jTIwx5hMgHmgODAHKW2tfttYezOR8IiIiIiIinqlTLS/DX67E6u8bMLBnBcpGhzHhf9u55oGF1L9tAYNG/Mve/alexzy16k1xb+yP2f035p0O4OaAXulMdM7FrjGmoDHmDWAlcCfwFVDFWtvHWrsrqwKKiIiIiIh4LTTU4Z4O0fz+aW1mfXIpd7Qoxu69Kbz86Xqq3jiH2x5ewe+zErMv0LzJOPdUw+laGTNm4MnHZ07Aub8OzvefYPflxVn6K+arpyD5EE7vhjg96uLcVwvz+fPZlzmbnXXpIWNMLuAh4AmgAPAL8IS1dmFWBhMREREREfFHFcrkYXDf8gxKK8vYybv4ZPxWfo3fzS/zd1GyUG5ublqEnrcXIyry/Ne5PaO0NJz3euEOmAxRJXF6N8Q2aAOlqx1tc0kz3IZtwBhYsxDnsUaY397DlqyF++oUyJMXUlNwHm2CjW0JVRtmTVYPnbFn1xjTFVgDDADWAldba69VoSsiIiIiIhe7oCCHW68vzI/DahI/Kpb7bihJSpplyNgN1Gg3l7Y9l/H91N24mT18eNUcKF4eipWDkFDslR0ws05YNTZPXl+hC5ByECJjIF8RnFG9YVv6hFWpKZCaerRdgDlbz+5wfMsJzQPGAJcYYy45Q3trrX0rk7KJiIiIiIjkCCWiczHgkTL071OKn6cl8tHYLfxv+R6mv5hA4bdDuaFxYR64oziliue68C/buRlbOObodlRJWDnn5HYzxuF88gzs2Y774gTInQvn9WtwhtwESRGw7W9s6/uhSoMLz+SHzjqMGTBAvfTX2VhAxa6IiIiIiFyUHMeh5ZUFaXllQRISUxg6agtfT9nBxz/8y/9N2kyd8vnodEM0t7WOIijofBfHsafYd4re2StuxL3iRljyJ85nz+G+8jNu3BCcz7pByeK4A9fhDOiA/XsplKlxnln819mK3abZkkJERERERCTAFMwfwlPdS/FU91LMmL+XD0Zv5veFCfQatIpnh66jZcMoHri9OFUrhGXsxFElMDs2Hi15d26CQsVO375mE9iyDhJ3QqM47IZ4nN/fx3z1OLbWlZh5P2EvtmLXWvtHdgUREREREREJVFdcGsEVl0Zw4GAqH4/ZxqiftjP616189dtWqsXk5fZWRel0c1Fy5zqH3t5K9WDzGti6HgqVwPwxBveJz49vs3kNFCufPkHVAkhNhohCsGcHtvVTuJuW4cwZhbUlcbsNypqL9ti5DGMWERERERGRTBCeJ5henUrQq1MJFv+1n3e/3MzPc3bx9NC1vPx/f9O8biQ940oQWyvv6U8SFIx7/2Ccvq0gLQ17TWcoXR3zw4cA2Ovvw0z/FjP1CwgOgdDcuE+O9BW+CVtw3ugKaSnYXUCujZA3PFuuPbsZa0813jswxMbG2tmzZ3sdQ0REREQuAmMXbAKgXd2SHicJbIF4n5OTXb6csIPPJ25l8d/7sBbKRYdxa4si3HtrNPnzZVEf5dY1OC83BuPgPjsLoo5OejVv/HsAxLbtmTXfnUmCg4PnW2tjT3XsfJ+IFhERERERkUwQGurQpV1Rfv2kNnM+u5S7ri3Onv0pvPL531S9cQ639lnBr/9LyPwvjq6A23UEHN6H81YbSD6U+d/hIRW7IiIiIiIifqJcqTy89XQ5Vn5fjw+frEKdCvn4beFu2j+1jFo3zeP5If+wfVcykydDtWoOlSs7DBx48kzMEyZAnToOl17q0KCBw/Tpvv0bN0Lz5g41ajjUquUwZForbOt+mB2rMe/FZfPVZi0VuyIiIiIiIn7GcRzaXRfFDx/WZNFXsdx/Y0nSrOWdbzZS45a5dOiYSu8nd7FoUSpffWVYvvz4zzdrBgsWuMyf7/LRRy733ecr/YKD4fXXXZYudZkxw+WDDwzLyj+GW/tGnBU/Yb5+zoOrzRoqdkVERERERPxYsSK56N+nDEu+vZRR/atTo2gJUoKTePrjZdRuN4+8RXfx2Rdpx30mb17ffFQABw4cfV+sGNSt63ufLx9UqQL//gv2vk+wxapjpgyCOd9l49VlHc3GLCIiIiJynmat28Xs9buP2zd46uoj7xuUjaRhuULZHUsClOM4XNO4IPu2FyQmj6XaZaUZM2U78Ut3MH/pYeZt3U6nG4py2/WFCQlxGDcOnnnGYft2mDDBPel8f/8NCxdCgwZAcAhun+9xXqiPM6IrdXYZQvbvhW/fxHbqj22W84Y4q9gVERERETlPDcsVUjEr2c5ayBXq8MR9MTxxXwzPv3yIr747zMqNB3jordU89+F6WjYoxAO3l2DZsjD+/BOee87h55+PFrz790OHDg6DBrlERKTvLFAU2+BuzJRXCQ23cADYvgGGdPd9bw4reDWMWUREREREJAcpUQI2bjw6KVXuoDx0aleAvybU44V7ylEsMhdf/baNxvcsoNEdC1m2cTNr18LOnb72KSnQvr1Dx46Wm246/tzmx08wu1IhxECkr2/UHE7CfNo3uy4v06jYFRERERERyUHq1YM1a2D9ekhOhjFjDG3aWMLzBPPAncWZ8WUdPn+mLu2aFOXfnYd4atB2Nm5J5uHXVjIrfi/33muoWtXSp489+eQ7NsIhFxLTII8Doebo/hxGw5hFRERERERykOBgGDzYpVUrh7Q06NzZUr06fPihrzC97z7L0oXhzBxfmYLBEHIwhYimf/PjnB2M/+UwB5bUIbpEMr/+GkxQkOGll1xatUo/eeEY39DlfWlw2IVke3R/DqNiV0REREREJIdp1QpatTp+0qn77jvaU/v445bHH/9vOwgoz/qNxXn3yy1MLDGTnfuS2R7s0KhmQXLljwYKAmA79Ych3TGHk44UujZXmG9/DqNiV0RERERE5CJQNiYPbz5ZjtfdMoz7ZTcjvtvKH4t2MzV+F8Ujc3PTVYXpeXs71sYeoMxvz1MiZDubU6NZf8WzXJ7DJqcCMNaeYpx2gIiNjbWzZ8/2OoaIiIiIiGSSsQs2AdCubkmPkwSGbTuTee/LLXz323Y2JxzGAZJ3hnBoSzBpe4MAQ1iYYejQksTFRXod9yTBwcHzrbWxpzqmCapEREREREQuUkWjQnmxd2mWjKvHmAHVYU8uggqmkrfmQfLVTcIJSyMpydK371avo2aYhjGLiIiIiIgIza8oyJ7loVgTQkihVEKLpOAe9vWPbtyY4nG6jFPProiIiIiIiAAQExMCriFlRwgHloVBmjm6P4dRsSsiIiIiIiIA9O8fTViYOW5fWJihf/9ojxKdPxW7IiIiIiIiAkBcXCRDh5YkOuoQxlhKlQrx28mpzkbP7IqIiIiIiMgRcXGRVAqfB0Bs254epzl/6tkVERERERGRgOM3xa4xpqUxZqUxZo0x5slTHG9rjFlsjFlojJlnjGnkRU4RERERERHxf34xjNkYEwS8B7QANgFzjTETrLXLj2k2FZhgrbXGmFrAGKBK9qcVERERERERf+cvPbv1gTXW2nXW2mRgNND22AbW2v3WWpu+GQ5YRERERERERE7BX4rdEsDGY7Y3pe87jjHmJmPMX8APQNdsyiYiIiIiIiI5jF8MYwbMKfad1HNrrf0O+M4Y0wR4Cbj6pBMZ0w3oBlC0aFGmTZuWyVFFRERERMQrqzalADDtwHqPkwS2xK1bAXJ0PeUvxe4mIOaY7ZLA5tM1ttb+aYwpb4yJstbuPOHYMGAYQGxsrG3cuHFW5BUREREREQ9sW7AJgMZ1S3qcJLDN270YgNgcXE/5yzDmuUBFY0xZY0wocBsw4dgGxpgKxhiT/r4uEArsyvakIiIiIiIi4vf8omfXWptqjHkA+AkIAkZYa5cZY7qnHx8K3ALcZYxJAQ4Ctx4zYZWIiIiIiIjIEX5R7AJYaycBk07YN/SY9wOBgdmdS0RERERERHIefxnGLCIiIiIiIpJpVOyKiIiIiIhIwFGxKyIiIiIiIgFHxa6IiIiIiIgEHBW7IiIiIiIiEnBU7IqIiIiIiEjAUbErIiIiIiIiAUfFroiIiIiIiAQcFbsiIiIiIiIScFTsioiIiIiISMBRsSsiIiIiIiIBR8WuiIiIiIiIBBwVuyIiIiIiIhJwgr0OICIiIiIiIn7g7+mYf6YDEH5wLwDmj1ePHLalG0GZRp5EOx8qdkVERERERATKNMKmF7PLFmwCoGrdkl4muiAaxiwiIiIiIiIBR8WuiIiIiIiIBBwVuyIiIiIiIhJwVOyKiIiIiIhIwFGxKyIiIiIiIgFHxa6IiIiIiIgEHBW7IiIiIiIiEnBU7IqIiIiIiEjAUbErIiIiIiIiASfY6wAiIiIiIiLivVnrdjF7/e7j9g2euvrI+wZlI2lYrlB2xzpvKnZFRERERESEhuUK5ahi9mw0jFlEREREREQCjopdERERERERCTgqdkVERERERCTgqNgVERERERGRgKNiV0RERERERAKOil0REREREREJOCp2RUREREREJOCo2BUREREREZGAo2JXREREREREAo6KXREREREREQk4KnZFREREREQk4AR7HUBERERERORMZq3bxez1u4/bN3jq6iPvG5SNpGG5QtkdS/ycil0REREREfFrDcsVUjErGaZhzCIiIiIiIhJw/KbYNca0NMasNMasMcY8eYrjtxtjFqe//meMqe1FThEREREREfF/flHsGmOCgPeA64BqQEdjTLUTmq0HrrTW1gJeAoZlb0oRERERERHJKfyi2AXqA2usteustcnAaKDtsQ2stf+z1iakb84CSmZzRhEREREREckh/GWCqhLAxmO2NwENztD+buDHUx0wxnQDugEULVqUadOmZVZGERERERERySH8pdg1p9hnT9nQmKb4it1GpzpurR1G+hDn2NhY27hx48zKKCIiIiIiIjmEvxS7m4CYY7ZLAptPbGSMqQUMB66z1u7KpmwiIiIiIiKSw/jLM7tzgYrGmLLGmFDgNmDCsQ2MMaWAb4E7rbWrPMgoIiIiIiIiOYRf9Oxaa1ONMQ8APwFBwAhr7TJjTPf040OBZ4FCwPvGGIBUa22sV5lFRERERETEfxlrT/lobECIjY21s2fP9jqGiIiIiIiIZIHg4OD5p+sE9ZdhzCIiIiIiIiKZRsWuiIiIiIiIBBwVuyIiIiIiIhJwVOyKiIiIiIhIwFGxKyIiIiIiIgFHxa6IiIiIiIgEHBW7IiIiIiIiEnBU7IqIiIiIiEjAUbErIiIiIiIiAUfFroiIiIiIiAQcFbsiIiIiIiIScFTsioiIiIiISMBRsSsiIiIiIiIBR8WuiIiIiIiIBBwVuyIiIiIiIhJwVOyKiIiIiIhIwFGxKyIiIiIiIgEn2OsAXnFdl927d5OYmEhaWhrWWq8jBRRjDEFBQeTPn5/IyEgcR79XERERERGR7HPRFrubN2/GcRxKly5NSEgIxhivIwUUay0pKSls376dzZs3U7JkSa8jiYiIiIjIReSi7W5LSkqiePHihIaGqtDNAsYYQkNDKV68OElJSV7HERERERGRi8xFW+xaazW0Nhs4jqMh4iIiIiIiku1U7YmIiIiIiEjAUbErIiIiIiIiAUfFroiIiIiIiAQcFbs5iOM4Z3x16dLlSNs//viDtm3bUqRIEXLnzk358uVp3749U6dOPe35W7duzbBhwwC49957efHFF487vmzZMtq3b0/58uVxHIfnn38+S65TRERERETkQqnYvUAjR+6mTJmlBAXFU6bMUkaO3J1l37V58+Yjr/+K0mP3vf322wB8+OGHNG/enAIFCjB69GhWrFjBF198wZVXXknv3r1PeW5rLbNmzeKKK64AYMaMGUfe/ycpKYnSpUvz0ksvUbZs2Sy7ThERERERkQt10a6zmxlGjtxNt24bSEryzTa8YUMK3bptACAuLjLTvy86OvrI+wIFCpy0D2Djxo307t2bXr16MWjQoCP7y5Yty2WXXUbPnj1Pee6VK1fiui7VqlVj165drFmzhgYNGhzXpl69etSrVw+AV155JTMuSUREREREJEuo2D3GQw9tYtGig+fcftasAxw+fPyyOklJlrvv3sBHH+06p3PUrp2Ht98umaGcZzJ27FiSk5N5/PHHT3n8xDWF27Rpw/Tp00lNTeXgwYNERkaSlpZGWloaMTExACQkJGRaPhERERERkeygYcwX4MRC92z7s8OqVauIiIg4rsd34sSJ5MuX78hr2rRpR4599NFHxMfH06hRI/r27Ut8fDw33XQTPXv2JD4+nvj4eC8uQ0RERERE5IKoZ/cYGe1hLVNmKRs2pJy0v1SpEH77rWJmxcqwE3tvmzZtSnx8PAkJCTRo0IC0tLQjx6Kjo0lJSWHWrFkMGTKEMmXKMHPmTEaMGEGZMmWyObmIiIiIiEjmUM/uBRgwoDhhYccXlmFhhgEDinuUCCpVqkRiYiJbtmw5si88PJwKFSqcNKnUgAEDyJcvHwULFiQxMZG6deuSL18+1qxZQ8uWLU/qBRYREREREckpVOxegLi4SIYNK0WpUiEY4+vRHTasVJZMTnWu2rVrR0hIyDlNINW9e3fi4+Pp1q0b7du3Jz4+nqeffpqrrrqKhQsXEh8fT2xsbDakFhERERERyVwaxnyB4uIiPS1uTxQTE8Nbb73Fgw8+SEJCAl26dKFcuXIkJCTw9ddfAxAUFARAZGQkkZGRrFixgg4dOlChQgVWr15NixYtqFChwknnTk5OZvny5QAcOnSIrVu3snDhQvLmzXvK9iIiIiIiIl5Rz24A6tGjB1OmTGHPnj3ceuutVKpUieuuu47ly5czfvx4GjdufKRtamoqM2bMoEmTJgD8+eefR96faPPmzdStW5e6deuydu1ahg0bRt26dbn33nuz5bpERERERETOlXp2c6h27drhuu5pjzdt2pSmTZue9TzBwcHs3bv3yPaaNWtO27ZMmTJn/E4RERERERF/oZ5dERERERERCTgqdkVERERERCTgqNgVERERERGRgKNiV0RERERERAKO3xS7xpiWxpiVxpg1xpgnT3G8ijFmpjHmsDHmUS8yioiIiIiISM7gF7MxG2OCgPeAFsAmYK4xZoK1dvkxzXYDvYAbsz+hiIiIiIiI5CT+0rNbH1hjrV1nrU0GRgNtj21grd1urZ0LpHgRUERERERERHIOv+jZBUoAG4/Z3gQ0OJ8TGWO6Ad0AihYtyrRp007ZLn/+/Ozfv/98vkIy6PDhw6f930FERERERCQr+Euxa06xz57Piay1w4BhALGxsbZx48anbLdy5Ury5s17Pl8hGZQrVy5O97+DiIiIiIhIVvCXYcybgJhjtksCmz3KIiIiIiIiIjmcvxS7c4GKxpiyxphQ4DZggseZ/I7jOGd8denS5UjbP/74g7Zt21KkSBFy585N+fLlad++PVOnTj3t+Vu3bs2wYcMAuPfee3nxxRePO/7RRx/RpEkTChUqRMGCBWnWrBnTp0/PmosVERERERG5AH5R7FprU4EHgJ+AFcAYa+0yY0x3Y0x3AGNMtDFmE/Aw0NcYs8kYE+Fd6nS/joQ7y0DLIN+fv47Msq/avHnzkdd/Remx+95++20APvzwQ5o3b06BAgUYPXo0K1as4IsvvuDKK6+kd+/epzy3tZZZs2ZxxRVXADBjxowj7//zxx9/0KFDB6ZMmcKsWbOoVKkSLVu2ZPXq1Vl2zSIiIiIiIufDWHtej8bmCLGxsXb27NmnPLZy5UqqVq16YV/w60h4uxvmcNKRXTZXGDw0DJrFXdi5z2Ls2LF06NAB13WP279x40YqVqxIjx49GDRo0Emfs9ZizMmPSP/1119cfvnl7Nq1i927d1OsWDF27959xuearbUUL16cp59+mgcffPC07VasWEHlypUzcHUiIiIiIiJnFxwcPN9aG3vKY9kdxq998BCsW3Tu7VfMwqQcPm6XOZyEHXQ3/PjRuZ2jXG24/+1z/86zGDt2LMnJyTz++OOnPH5iodumTRumT59OamoqBw8eJDIykrS0NNLS0oiJ8T1GnZCQcMpzJScnc+jQIQoWLJhp+UVERERERDKDXwxjzrFOKHTPuj8brFq1ioiICKKjo4/smzhxIvny5TvyOnYZoI8++oj4+HgaNWpE3759iY+P56abbqJnz57Ex8cTHx9/2u/q27cvefPm5YYbbsjSaxIREREREcko9eweK6M9rHeWge0bTt5fpBS8/ltmJDovJ/beNm3alPj4eBISEmjQoAFpaWlHjkVHR5OSksKsWbMYMmQIZcqUYebMmYwYMYIyZcqc9jsGDx7MsGHD+OWXX4iI8P7RaRERERERkWOpZ/dCdBnge0b3GDZXGHQZ4FEgqFSpEomJiWzZsuXIvvDwcCpUqEDZsmWPaztgwADy5ctHwYIFSUxMpG7duuTLl481a9bQsmXLk3qB/zN48GD69evHDz/8QP369bP8mkRERERERDJKxe6FaBYHDw3DFimFNQZbpFS2TE51Ju3atSMkJIRXXnnlrG27d+9OfHw83bp1o3379sTHx/P0009z1VVXsXDhQuLj44mNPf5Z70GDBtG3b18mTpxIo0aNsuoyRERERERELoiGMV+oZnGeFrcniomJ4a233uLBBx8kISGBLl26UK5cORISEvj6668BCAoKAiAyMpLIyEhWrFhBhw4dqFChAqtXr6ZFixZUqFDhpHO//vrr9O3bl88//5xKlSqxdetWAPLkyUP+/Pmz7yJFRERERETOQj27AahHjx5MmTKFPXv2cOutt1KpUiWuu+46li9fzvjx42ncuPGRtqmpqcyYMYMmTZoA8Oeffx55f6L333+flJQUbrvtNooXL37k9dBDD2XHZYmIiIiIiJwz9ezmUO3atTtpjd1jNW3alKZNm571PMHBwezdu/fI9po1a07bdv369RkLKSIiIiIi4hH17IqIiIiIiEjAUbErIiIiIiIiAUfFroiIiIiIiAQcFbsiIiIiIiIScFTsioiIiIiISMBRsSsiIiIiIiIBR8WuiIiIiIiIBBwVuyIiIiIiIhJwVOyKiIiIiIhIwFGxKyIiIiIiIgFHxW4O4jjOGV9dunQ50vaPP/6gbdu2FClShNy5c1O+fHnat2/P1KlTT3v+1q1bM2zYMADuvfdeXnzxxeOOf/3119SrV4+CBQuSN29e6tSpw6effpo1FysiIiIiInIBVOxeoJFLRlJmcBmCXgyizOAyjFwyMsu+a/PmzUde/xWlx+57++23Afjwww9p3rw5BQoUYPTo0axYsYIvvviCK6+8kt69e5/y3NZaZs2axRVXXAHAjBkzjrz/T6FChXjmmWeYOXMmixYtonPnztxzzz1MmjQpy65ZRERERETkfBhrrdcZskxsbKydPXv2KY+tXLmSqlWrXtD5Ry4ZSbeJ3UhKSTqyLywkjGGthxFXM+6Czn02Y8eOpUOHDriue9z+jRs3UrFiRXr06MGgQYNO+py1FmPMSfv/+usvLr/8cnbt2sXu3bspVqwYu3fvJm/evGfMcemll3LNNdfwyiuvnLbNihUrqFy58jlemYiIiIiIyLkJDg6eb62NPeWx7A7jzx766SEWbV10zu1nbZrF4bTDx+1LSkni7gl389GCj87pHLWja/P2tW9nJOYZjR07luTkZB5//PFTHj+x0G3Tpg3Tp08nNTWVgwcPEhkZSVpaGmlpacTExACQkJBw0nmstfz666+sXLmS/v37Z1p+ERERERGRzKBhzBfgxEL3bPuzw6pVq4iIiCA6OvrIvokTJ5IvX74jr2nTph059tFHHxEfH0+jRo3o27cv8fHx3HTTTfTs2ZP4+Hji4+OPO39iYiL58uUjV65ctG7dmsGDB3Pddddl2/WJiIiIiIicC/XsHiOjPaxlBpdhQ+KGk/aXyl+K3zr9lkmpMu7E3tumTZsSHx9PQkICDRo0IC0t7cix6OhoUlJSmDVrFkOGDKFMmTLMnDmTESNGUKZMmZPOnS9fPuLj49m/fz9Tp07lkUceoUyZMjRv3jyrL0tEREREROScqWf3AgxoNoCwkLDj9oWFhDGg2QCPEkGlSpVITExky5YtR/aFh4dToUIFypYte1zbAQMGkC9fPgoWLEhiYiJ169YlX758rFmzhpYtW57UCwy+GaErVKjAJZdcwiOPPEK7du3O+LyuiIiIiIiIF1TsXoC4mnEMaz2MUvlLYTCUyl8qWyanOpN27doREhJyTgVo9+7diY+Pp1u3brRv3574+HiefvpprrrqKhYuXEh8fDyxsad81vsI13U5fNi7YdsiIiIiIiKnomHMFyiuZpynxe2JYmJieOutt3jwwQdJSEigS5culCtXjoSEBL7++msAgoKCAIiMjCQyMpIVK1bQoUMHKlSowOrVq2nRogUVKlQ46dwvv/wyDRo0oFy5chw+fJhJkybxxRdfMGTIkGy9RhERERERkbNRsRuAevToQdWqVRk0aBC33noriYmJREZG0rBhQ8aPH0/jxo2PtE1NTWXGjBm8++67APz555/cfffdpzzv/v376dGjB5s2bSJPnjxUqVKFTz/9lI4dO2bLdYmIiIiIiJwrrbMrWU7r7IqIiIiISFY40zq7emZXREREREREAo6KXREREREREQk4KnZFREREREQk4KjYFRERERERkYBz0Ra7xhgCeXIuf2GtxRjjdQwREREREbnIXLTFbnBwMAcPHvQ6RsA7ePAgwcFa4UpERERERLLXRVvsRkVF8e+//5KUlKQe3ixgrSUpKYl///2XqKgor+OIiIiIiMhF5qLtcouIiABg8+bNpKamquDNZMYYgoODKVy48JF7LSIiIiIikl0u2mIXfAWvCjEREREREZHAc9EOYxYREREREZHA5TfFrjGmpTFmpTFmjTHmyVMcN8aYIenHFxtj6nqRU0RERERERPyfXxS7xpgg4D3gOqAa0NEYU+2EZtcBFdNf3YAPsjWkiIiIiIiI5Bh+UewC9YE11tp11tpkYDTQ9oQ2bYHPrM8soIAxplh2BxURERERERH/5y/Fbglg4zHbm9L3ZbSNiIiIiIiIiN/MxmxOse/EtYDOpQ3GmG74hjkD7A8ODl55gdmyWhSw0+sQFwHd5+yh+5w9dJ+zj+519tB9zh66z9lD9zl76D5nj5xwn0uf7oC/FLubgJhjtksCm8+jDdbaYcCwzA6YVYwx86y1sV7nCHS6z9lD9zl76D5nH93r7KH7nD10n7OH7nP20H3OHjn9PvvLMOa5QEVjTFljTChwGzDhhDYTgLvSZ2VuCCRaa7dkd1ARERERERHxf37Rs2utTTXGPAD8BAQBI6y1y4wx3dOPDwUmAa2ANUAS0MWrvCIiIiIiIuLf/KLYBbDWTsJX0B67b+gx7y3QM7tzZYMcM+Q6h9N9zh66z9lD9zn76F5nD93n7KH7nD10n7OH7nP2yNH32fhqSBEREREREZHA4S/P7IqIiIiIiIhkGhW7HjHGjDDGbDfGLPU6SyAzxsQYY34zxqwwxiwzxvT2OlMgMsbkNsbMMcYsSr/PL3idKZAZY4KMMfHGmIleZwlUxpi/jTFLjDELjTHzvM4TqIwxBYwxY40xf6X/O32Z15kCjTGmcvrf4/9ee40xD3mdKxAZY/qk/zdwqTFmlDEmt9eZApUxpnf6fV6mv8+Z51T1iTEm0hjzizFmdfqfBb3MmFEqdr3zCdDS6xAXgVTgEWttVaAh0NMYU83jTIHoMNDMWlsbuARomT5rumSN3sAKr0NcBJpaay/JyUsu5ACDgcnW2ipAbfT3OtNZa1em/z2+BLgU3ySf33mbKvAYY0oAvYBYa20NfBOu3uZtqsBkjKkB3AvUx/fvRmtjTEVvUwWMTzi5PnkSmGqtrQhMTd/OMVTsesRa+yew2+scgc5au8VauyD9/T58P0iV8DZV4LE++9M3Q9JfmhAgCxhjSgLXA8O9ziJyIYwxEUAT4GMAa22ytXaPp6ECX3NgrbX2H6+DBKhgII8xJhgIAzZ7nCdQVQVmWWuTrLWpwB/ATR5nCginqU/aAp+mv/8UuDE7M10oFbty0TDGlAHqALM9jhKQ0ofWLgS2A79Ya3Wfs8bbwP+3d/+hftV1HMefLzYNXZK1NTPNpv2iH/+0YFizpdmvhU0MQyvDRFqRZusPQ6clSWhRhoRSjK3UNMVNnUohCjYwUpOtNOsuRiprTZ2RuFnJxnz3xzkXvt3u7t3V3Xu6Z88HfDm/z3ldGOz7/p7355yvAy92nKPvCrg7yfokS7sO01PHAM8AP23b8lcmmdV1qJ47Hbix6xB9VFV/A74PbAaeBJ6rqru7TdVbjwKLksxOcjDNq0nf0HGmPjusqp6E5iYSMLfjPBNisav9QpJXArcAy6pqe9d5+qiqdrdtckcCC9o2I+1DSU4CtlXV+q6z7AcWVtV8YDHN8IdFXQfqoZnAfOBHVfVu4J9Ms/a46STJgcASYHXXWfqoHcd4MnA08HpgVpIzuk3VT1U1BHwXuAe4C3iYZtia9D8sdtV7SQ6gKXRvqKpbu87Td20b4jockz4ZFgJLkjwB3AR8MMn13Ubqp6ra2k630YxvXNBtol7aAmwZ6AJZQ1P8anIsBjZU1dNdB+mpDwGPV9UzVbULuBV4X8eZequqVlXV/KpaRNN2u6nrTD32dJLDAdrpto7zTIjFrnotSWjGgw1V1Q+6ztNXSV6b5NB2/iCa//Q3dhqqh6rqwqo6sqrm0bQj3ltV3jnYx5LMSnLI8DzwEZq2Oe1DVfUU8Nckb2tXnQj8qcNIffdpbGGeTJuBY5Mc3H73OBEfuDZpksxtp0cBn8R/25PpDuDMdv5M4PYOs0zYzK4D7K+S3AgcD8xJsgW4pKpWdZuqlxYCnwP+0I4nBVheVb/sLlIvHQ5cm2QGzY9oN1eVr8XRdHUYcFvzfZWZwM+r6q5uI/XWV4Ab2hbbx4CzOs7TS+24xg8DX+w6S19V1YNJ1gAbaFpqfwes6DZVr92SZDawCzinqp7tOlAfjFafAN8Bbk5yNs2POp/qLuHEpcoHpkqSJEmS+sU2ZkmSJElS71jsSpIkSZJ6x2JXkiRJktQ7FruSJEmSpN6x2JUkSZIk9Y7FriRJkiSpdyx2JUmaBEmuSTKt3++XZF2SJ7rOIUnSSzGz6wCSJE0HEyxcj560INNIks8Dh1bVlR1HkSTth1I1rX90liRpSiQ5Y8Sq9wNLgRXAfSO23QbsBGZU1QtTEG9SJFkHzKuqeV0cL0nSy+GdXUmS9kJVXT+4nGQmTbF7/8htA3ZNejBJkjQqx+xKkjQJRhuzO7wuyex2/u9JdiRZm+R17T5LkwwleSHJxiQn7+H8pyX5dXv8v5I8mOTUvcyWJMuSPNIevz3Jn5OsSnLAXhy/KMk9SZ5L8u8kG5KcPWKfJ4APAG9s/+bhz/F7k1GSpJfLO7uSJE29u4AtwDeBNwPnAbcluZXmbvEq4IV2/Zokb62qx4cPTvJt4KL2PN8AXgROAVYnObeqrh7n+hcDlwJ3Aj8GdtOMM14CvIIx7kgn+QRNm/ZTwBXADuB0YGWSY6rqonbXZcDlwBzgawOnGBonmyRJ+4TFriRJU++3VXXO8EISaArCI4B3VdX2dv29wMM0BfCF7br5NIXu5VW1fOCcP0yyFrg8yXVVtWOM658CDFXVkhHrLxgrdJIZwFXA88CCqtrarr8a+BVwQZJrqmpTVa1Nsgw4aIw2b0mSJo1tzJIkTb0rRywPP+DquuFCF6CqHgG2A28Z2PezQAHXJpkz+AHuAA4B3jvO9Z8Djkhy3ARzvwc4CvjJcKHb5twJfI/me8WobdeSJE017+xKkjT1Hhux/Gw7fXzkju222QPLbwcCbBzj/IeNc/3lwFrgviRbgXXAL4A1beG6J8OvVPrjKNsebafHjHNtSZKmhMWuJElTrKp272HTntZnxHwBi8fYf7RidPD69yd5E/BR4IT28xng4iTHVdU/9iKHJEn/1yx2JUmaXjYBHwM2V9VLfthTVT0P3NJ+SPJl4GrgbJqW5NH8pZ2+c5Rt72ing3eta5T9JEmaEo7ZlSRpevlZO72sfWDUf0kyd7wTtON7R9rQTl8zxqEbgM3AWcOvSmrPdwBwPk1xe/vA/s8Dr077BC5JkqaSd3YlSZpGquqhJJcA3wJ+n2Q1sBU4nOYBUh8HDhznNENJHgAeHDh2KbATuGmMa+9Oci7Nq4ceSrKC5tVDpwHHApdV1aaBQx4ATgKuSvIbmrbre6tq2wT/bEmSJsxiV5KkaaaqLk2ynuY9vMuAWcA2modEfXUvTnEFTVF8HvCq9tgHaF5n9PA4174zyYk07+o9n6awHgK+UFUrR+x+Jc0Dq04FvkTTUXZCez1JkiZVqhxOI0mSJEnqF8fsSpIkSZJ6x2JXkiRJktQ7FruSJEmSpN6x2JUkSZIk9Y7FriRJkiSpdyx2JUmSJEm9Y7ErSZIkSeodi11JkiRJUu9Y7EqSJEmSesdiV5IkSZLUO/8Bl9DSBR/FOAQAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 1152x648 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# FEEL-IT\n",
    "\n",
    "%matplotlib inline\n",
    "fig, ax = plt.subplots(figsize=(16,9))\n",
    "\n",
    "ax.plot(np.arange(1,11,1), TGA_chunks_avg_score, label='TG#1', color='mediumblue', marker='o')\n",
    "ax.errorbar(np.arange(1,11), TGA_chunks_avg_score, yerr=TGA_chunks_std_error, capsize=4, alpha=0.5)\n",
    "ax.plot(np.arange(1,11,1), TGB_chunks_avg_score, label='TG#2', color='orangered', marker='o')\n",
    "ax.errorbar(np.arange(1,11), TGB_chunks_avg_score, yerr=TGB_chunks_std_error, capsize=4, alpha=0.5)\n",
    "ax.plot(np.arange(1,11,1), TGC_chunks_avg_score, label='TG#3', color='green', marker='o')\n",
    "ax.errorbar(np.arange(1,11), TGC_chunks_avg_score, yerr=TGC_chunks_std_error, capsize=4, alpha=0.5)\n",
    "\n",
    "# Set plot background color\n",
    "ax.set_facecolor('#fcfcfc')\n",
    "\n",
    "# Change the color of the left and bottom spines to black\n",
    "ax.spines['left'].set_color('black')\n",
    "ax.spines['bottom'].set_color('black')\n",
    "\n",
    "# Labels\n",
    "ax.set_xlabel(\"Time slot\", labelpad=5)\n",
    "ax.set_ylabel(\"Negativity score\", labelpad=7)\n",
    "# Tweak the axis labels\n",
    "xlab = ax.xaxis.get_label()\n",
    "ylab = ax.yaxis.get_label()\n",
    "xlab.set_size(18)\n",
    "#ylab.set_style('italic')\n",
    "ylab.set_size(18)\n",
    "\n",
    "# Ticks\n",
    "xtick = ax.set_xticks(np.arange(1,11,1))\n",
    "ytick = ax.set_yticks(np.arange(0,1.1,0.1))\n",
    "\n",
    "# Add values to bars\n",
    "for i in np.arange(0,10):\n",
    "    plt.text(i+0.7,round(TGA_chunks_avg_score[i],2)+0.01,round(TGA_chunks_avg_score[i],2),color='blue')\n",
    "    plt.text(i+0.7,round(TGB_chunks_avg_score[i],2)+0.02,round(TGB_chunks_avg_score[i],2),color='orangered')\n",
    "    plt.text(i+0.7,round(TGC_chunks_avg_score[i],2)+0.01,round(TGC_chunks_avg_score[i],2),color='darkgreen')\n",
    "    \n",
    "# Title\n",
    "ttl = ax.set_title('Polarity Evolution within Newscasts using FEEL-IT Classifier', pad=10)\n",
    "ttl.set_weight('bold')\n",
    "ttl.set_size(16)\n",
    "\n",
    "plt.legend(fontsize=14, loc='lower left')\n",
    "plt.grid(axis='y')\n",
    "ax.set_axisbelow(True)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "id": "3feb071b",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Make values in df_*['Sentita score'] comparable to df_*['FEEL-IT score']\n",
    "# Both classifiers scores become of the same format -> 0: negative, 1: positive\n",
    "\n",
    "df_A['Sentita score'] = [1 if score == 0 else 0 for score in df_A['Sentita score']]\n",
    "df_B['Sentita score'] = [1 if score == 0 else 0 for score in df_B['Sentita score']]\n",
    "df_C['Sentita score'] = [1 if score == 0 else 0 for score in df_C['Sentita score']]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "id": "1a9eae8b",
   "metadata": {},
   "outputs": [],
   "source": [
    "def display_scores_info(df):\n",
    "    '''Display info such as length of the dataframe\n",
    "    where sentences are stored, the total number of equal \n",
    "    Sentita and FEEL-IT scores and the percentage out of\n",
    "    the total number of sentences.\n",
    "    \n",
    "    In input, choose the TV news you want selecting df_A, df_B or df_C \n",
    "    '''\n",
    "    equal_score_abs = sum(df['Sentita score']==df['FEEL-IT score'])\n",
    "    equal_score_perc = round(sum(df['Sentita score']==df['FEEL-IT score']) / len(df),2)\n",
    "    \n",
    "    print(f'A total of {equal_score_abs} sentences have the same score')\n",
    "    print(f'The total number of sentences is {len(df)}')\n",
    "    print(f'The percentage of sentences with the same score is {equal_score_perc}%')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "id": "db24ffc4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "### SCORES INFO FOR TG#1 ###\n",
      "\n",
      "A total of 1646 sentences have the same score\n",
      "The total number of sentences is 2262\n",
      "The percentage of sentences with the same score is 0.73%\n",
      "\n",
      "### SCORES INFO FOR TG#2 ###\n",
      "\n",
      "A total of 1486 sentences have the same score\n",
      "The total number of sentences is 1924\n",
      "The percentage of sentences with the same score is 0.77%\n",
      "\n",
      "### SCORES INFO FOR TG#3 ###\n",
      "\n",
      "A total of 1176 sentences have the same score\n",
      "The total number of sentences is 1502\n",
      "The percentage of sentences with the same score is 0.78%\n"
     ]
    }
   ],
   "source": [
    "print(f'\\n### SCORES INFO FOR TG#1 ###\\n')\n",
    "display_scores_info(df_A)\n",
    "print(f'\\n### SCORES INFO FOR TG#2 ###\\n')\n",
    "display_scores_info(df_B)\n",
    "print(f'\\n### SCORES INFO FOR TG#3 ###\\n')\n",
    "display_scores_info(df_C)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "id": "1aeeb00e",
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_sentences_different_score(df):\n",
    "    ''' \n",
    "    Create a subset of 5 samples\n",
    "    Sentita score must differ from FEEL-IT score\n",
    "    This function provides examples of sentences\n",
    "    that have been classified differently\n",
    "    '''\n",
    "    df_subset = df.loc[df['Sentita score']!=df['FEEL-IT score']]\n",
    "    \n",
    "    random_idx = []\n",
    "    for selection in range(0,5):\n",
    "        random_idx.append(random.choice(df_subset.index))\n",
    "        \n",
    "    return df.loc[random_idx]        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "id": "b0128f8d",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Sentence</th>\n",
       "      <th>Sentita score</th>\n",
       "      <th>FEEL-IT score</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>286</th>\n",
       "      <td>Ascoltiamo un brano di una delle sue canzoni più famose, una parentesi di una mezzora brucerà Piccola stella senza cielo ti mostrerà e ci incontreremo mentre scoppia in volo Lotti sceglierà dietro una scia, un soffio velo Buonasera Ligabue.</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>322</th>\n",
       "      <td>Sulla carta Netflix aveva fatto ponti d'oro un contratto da cento milioni di dollari una fortuna che avrebbe messo al sicuro per anni le finanze della coppia, Accordo che ora scricchiola.</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1055</th>\n",
       "      <td>I volontari le hanno dato vestiti puliti e qualcosa da mangiare.</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>75</th>\n",
       "      <td>Il sindaco Ivan Fedorov ci risponde da Sap Orisha, dove si è rifugiato dopo il sequestro opera delle forze russe, la prigionia un'esperienza che lo ha reso un simbolo della resistenza civile all' occupazione.</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>800</th>\n",
       "      <td>Questo ha aggiunto il ministro Di Maio e il conflitto resta al centro anche del dibattito politico.</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                                                                                                                                                                                                                                              Sentence  \\\n",
       "286   Ascoltiamo un brano di una delle sue canzoni più famose, una parentesi di una mezzora brucerà Piccola stella senza cielo ti mostrerà e ci incontreremo mentre scoppia in volo Lotti sceglierà dietro una scia, un soffio velo Buonasera Ligabue.   \n",
       "322                                                        Sulla carta Netflix aveva fatto ponti d'oro un contratto da cento milioni di dollari una fortuna che avrebbe messo al sicuro per anni le finanze della coppia, Accordo che ora scricchiola.   \n",
       "1055                                                                                                                                                                                  I volontari le hanno dato vestiti puliti e qualcosa da mangiare.   \n",
       "75                                    Il sindaco Ivan Fedorov ci risponde da Sap Orisha, dove si è rifugiato dopo il sequestro opera delle forze russe, la prigionia un'esperienza che lo ha reso un simbolo della resistenza civile all' occupazione.   \n",
       "800                                                                                                                                                Questo ha aggiunto il ministro Di Maio e il conflitto resta al centro anche del dibattito politico.   \n",
       "\n",
       "      Sentita score  FEEL-IT score  \n",
       "286               0              1  \n",
       "322               1              0  \n",
       "1055              1              0  \n",
       "75                0              1  \n",
       "800               1              0  "
      ]
     },
     "execution_count": 94,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Choose the TV news you want selecting df_A, df_B or df_C\n",
    "pd.set_option('display.max_colwidth', None)\n",
    "TGA_different_scores = get_sentences_different_score(df_A)\n",
    "TGA_different_scores"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2cb73975",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.6.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}