09outlet senti.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "from nltk.tree import Tree\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "import datetime as datetime\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "import string\n",
    "import re\n",
    "from textblob import TextBlob\n",
    "from nltk.corpus import stopwords\n",
    "import nltk as nltk\n",
    "import time"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Setup working directory and relative filepaths\n",
    "current_dir = os.curdir\n",
    "data_dir = os.path.join(current_dir, \"data\")\n",
    "output_dir = os.path.join(current_dir, \"data_clean\")\n",
    "\n",
    "# Get data path\n",
    "abc_data_dir = os.path.join(data_dir, \"abc-news.csv\")\n",
    "bbc_data_dir = os.path.join(data_dir, \"bbc-news.csv\")\n",
    "cbs_data_dir = os.path.join(data_dir, \"cbs-news.csv\")\n",
    "cnn_data_dir = os.path.join(data_dir, \"cnn-news.csv\")\n",
    "\n",
    "# Read csv data\n",
    "abc_data_csv = pd.read_csv(abc_data_dir, encoding=\"utf-16\")\n",
    "bbc_data_csv = pd.read_csv(bbc_data_dir, encoding=\"utf-16\")\n",
    "cbs_data_csv = pd.read_csv(cbs_data_dir, encoding=\"utf-16\")\n",
    "cnn_data_csv = pd.read_csv(cnn_data_dir, encoding=\"utf-16\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "abc_data_df = pd.DataFrame(abc_data_csv.copy())\n",
    "bbc_data_df = pd.DataFrame(bbc_data_csv.copy())\n",
    "cbs_data_df = pd.DataFrame(cbs_data_csv.copy())\n",
    "cnn_data_df = pd.DataFrame(cnn_data_csv.copy())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Remove columns from Dataframe\n",
    "col_ls = ['id', 'page_id', 'caption', 'picture']\n",
    "abc_data_df.drop(columns = col_ls, inplace = True)\n",
    "bbc_data_df.drop(columns = col_ls, inplace = True)\n",
    "cbs_data_df.drop(columns = col_ls, inplace = True)\n",
    "cnn_data_df.drop(columns = col_ls, inplace = True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "class CleanData:\n",
    "    def __init__(self, df): # constructor for df\n",
    "        self.df = df\n",
    "\n",
    "    def show_df(self): # Show dateframe object when passed to CleanData\n",
    "        return self.df\n",
    "    \n",
    "    def news_outlet(self, outlet=''): # append news outlet name to self.df as a new column\n",
    "\n",
    "        self.df['news_outlet'] = outlet\n",
    "        return self.df\n",
    "    \n",
    "    def numeric_category(self): # Determine how many post_types and status_types and factorize types, use method only on combined dataframe\n",
    "\n",
    "        self.post_types_unique = pd.unique(self.df['post_type'])\n",
    "        self.post_types_factorize = pd.factorize(self.post_types_unique, sort=True)[0]\n",
    "        self.status_types_unique = pd.unique(self.df['status_type'])\n",
    "        self.status_types_unique = [i for i in self.status_types_unique if str(i) != 'nan']\n",
    "        self.status_types_factorize = pd.factorize(self.status_types_unique, sort=True)[0]\n",
    "\n",
    "        self.post_types_dict = dict(zip(self.post_types_unique, self.post_types_factorize)) # Create dictionary for post_types and status_types\n",
    "        self.status_types_dict = dict(zip(self.status_types_unique, self.status_types_factorize))\n",
    "        \n",
    "        def post_cat(x):\n",
    "            for type, category in self.post_types_dict.items():\n",
    "                if x in type:\n",
    "                    return category\n",
    "\n",
    "        def status_cat(x):\n",
    "            for type, category in self.status_types_dict.items():\n",
    "                if x in type:\n",
    "                    return category\n",
    "            \n",
    "        self.df['post_category'] = self.df['post_type'].apply(post_cat)\n",
    "        self.df['status_category'] = self.df['status_type'].apply(status_cat)\n",
    "\n",
    "        return self.df\n",
    "\n",
    "    def calculate_reacts(self): # Calculate reacts for self.df\n",
    "\n",
    "        self.react_col = ['likes_count', 'comments_count', 'shares_count', 'love_count', # store columns of interest \n",
    "            'wow_count', 'haha_count', 'sad_count', 'thankful_count', 'angry_count',]\n",
    "        self.df['total_reacts'] = self.df[self.react_col].sum(axis=1) # sum self.react_col by row\n",
    "\n",
    "        return self.df\n",
    "\n",
    "    def clean_datetime(self): # Clean datetime of self.df\n",
    "\n",
    "        def round_hour(t):\n",
    "            t_start_hr = t.replace(minute=0, second=0, microsecond=0) # round to down to nearest hour\n",
    "            t = t_start_hr\n",
    "            return t\n",
    "\n",
    "        self.df['posted_at'] = pd.to_datetime(self.df['posted_at']) # change dtype to datetime\n",
    "        self.df['posted_at'] = self.df['posted_at'].apply(round_hour) # apply round_hour\n",
    "        self.df['date_posted'] = [date.date() for date in self.df['posted_at']] # store date() from datetime object\n",
    "        self.df['time_posted'] = [time.time() for time in self.df['posted_at']] # store time() from datetime object\n",
    "        self.df.drop(columns=['posted_at'], inplace=True)\n",
    "\n",
    "        return self.df\n",
    "    \n",
    "    \n",
    "    def analyze_df(self):\n",
    "\n",
    "        def analyze_sentiment(headline):\n",
    "            analysis = TextBlob(str(headline))\n",
    "            return analysis.sentiment # returns sentiment, subjectivity\n",
    "\n",
    "        self.df[['name_sentiment', 'name_subjectivity']] = np.array([analyze_sentiment(str(headline)) for headline in self.df['name']]) # store sentiment, subjectivity in new columns\n",
    "\n",
    "        return self.df\n",
    "\n",
    "    def fill_na(self):\n",
    "        self.df['status_type'] = self.df['status_type'].fillna(self.df.mode().iloc[0][2]) # self.df.mode().iloc[0] returns a list of the most frequent values for each column in self.df iloc[0][2] accesses status_type\n",
    "        return self.df\n",
    "    \n",
    "    def process_text(self):\n",
    "\n",
    "        def clean_text(text):\n",
    "            text = re.sub('(https?:\\/\\/)?([\\da-z\\.-]+)\\.([a-z\\.]{2,6})([\\/\\w \\.-]*)', '', str(text)) # remove links\n",
    "            text = ''.join([char for char in str(text) if char not in string.punctuation]) # remove punction from string\n",
    "            text = ''.join([char if ord(char) < 128 else '' for char in text]) # join character only if unicode value is less than 128\n",
    "            text = re.sub('[0-9]+', '', text) # replace numbers with empty string\n",
    "            return text\n",
    "        \n",
    "        self.df['name_processed'] = self.df['name'].apply(clean_text)\n",
    "        self.df['message_processed'] = self.df['message'].apply(clean_text)\n",
    "        self.df['description_processed'] = self.df['description'].apply(clean_text)\n",
    "\n",
    "        return self.df\n",
    "        \n",
    "    def form_sentence(self, target_col=''):\n",
    "        def sentence(words):\n",
    "            words = ' '.join(word for word in words)\n",
    "            return words\n",
    "\n",
    "        self.df[target_col] = self.df[target_col].apply(sentence)\n",
    "\n",
    "        return self.df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# ABC Data cleaning\n",
    "abc_data_clean = CleanData(abc_data_df)\n",
    "abc_data_clean.fill_na()\n",
    "abc_data_clean.news_outlet(outlet='ABC')\n",
    "abc_data_clean.calculate_reacts()\n",
    "abc_data_clean.clean_datetime()\n",
    "abc_data_clean.analyze_df()\n",
    "abc_data_clean = abc_data_clean.show_df()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# BBC Data cleaning\n",
    "bbc_data_clean = CleanData(bbc_data_df)\n",
    "bbc_data_clean.fill_na()\n",
    "bbc_data_clean.news_outlet(outlet='BBC')\n",
    "bbc_data_clean.calculate_reacts()\n",
    "bbc_data_clean.clean_datetime()\n",
    "bbc_data_clean.analyze_df()\n",
    "bbc_data_clean = bbc_data_clean.show_df()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "# CBS Data cleaning\n",
    "cbs_data_clean = CleanData(cbs_data_df)\n",
    "cbs_data_clean.fill_na()\n",
    "cbs_data_clean.news_outlet(outlet='CBS')\n",
    "cbs_data_clean.calculate_reacts()\n",
    "cbs_data_clean.clean_datetime()\n",
    "cbs_data_clean.analyze_df()\n",
    "cbs_data_clean = cbs_data_clean.show_df()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "# CNN Data cleaning\n",
    "cnn_data_clean = CleanData(cnn_data_df)\n",
    "cnn_data_clean.fill_na()\n",
    "cnn_data_clean.news_outlet(outlet='CNN')\n",
    "cnn_data_clean.calculate_reacts()\n",
    "cnn_data_clean.clean_datetime()\n",
    "cnn_data_clean.analyze_df()\n",
    "cnn_data_clean = cnn_data_clean.show_df()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Combine news outlet and store in new dataframe\n",
    "news_data_combined_df = pd.concat([abc_data_clean, bbc_data_clean, cbs_data_clean, cnn_data_clean])\n",
    "news_data_combined_clean = CleanData(news_data_combined_df)\n",
    "news_data_combined_clean.process_text()\n",
    "news_data_combined_clean = news_data_combined_clean.show_df()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Melt columns \n",
    "news_data_text_pivot = news_data_combined_clean[['name_processed','message_processed', 'description_processed','news_outlet']].copy() # create a copy of df \n",
    "news_data_text_pivot['news_outlet'] = news_data_text_pivot['news_outlet'].str.cat(map(str, news_data_text_pivot.index), sep='_') # add incrementing int to end of string\n",
    "news_data_text_pivot = news_data_text_pivot.rename(columns={'name_processed':'A1','message_processed':'A2', 'description_processed':'A3'}) # rename columns before pivot .wide_to_long\n",
    "news_data_text_pivot = pd.wide_to_long(news_data_text_pivot, stubnames=['A'], i=['news_outlet'], j='drop').reset_index().drop('drop', 1) # combining name, message, description to one column      \n",
    "news_headlines = news_data_text_pivot[news_data_text_pivot['A'].str.contains('nan')==False] # remove rows containing 'nan'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Remove nan and empty rows\n",
    "news_headlines = news_headlines.copy()\n",
    "news_headlines['A'] = news_headlines['A'].replace(r'^\\s*$', np.nan, regex=True) # Replace empty rows containing only whitespace \n",
    "news_headlines = news_headlines.dropna(axis=0, how='any')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Tokenize\n",
    "def tokenize_text(text):  \n",
    "    text_token = TextBlob(text)\n",
    "    return text_token.words\n",
    "news_headlines['A'] = news_headlines['A'].apply(tokenize_text) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "       news_outlet                                                  A\n",
      "0            ABC_0  [Chief, Justice, Roberts, Responds, Judicial, ...\n",
      "1            ABC_1  [With, Reservations, Obama, Signs, Act, Allow,...\n",
      "2            ABC_2                 [Wishes, For, Fall, Times, Square]\n",
      "3            ABC_3  [Mitt, Romney, Vows, Veto, Dream, Act, President]\n",
      "4            ABC_4  [NY, Pharmacy, Shootout, Leaves, Suspect, ATF,...\n",
      "...            ...                                                ...\n",
      "393474   CNN_31630  [There, members, Wellesley, Women, Hillary, gr...\n",
      "393475   CNN_31631  [Kids, picked, Hillary, Clinton, president, on...\n",
      "393516   CNN_31672  [Before, pull, lever, Election, Day, know, sta...\n",
      "393519   CNN_31675  [You, wont, recognize, name, face, youve, defi...\n",
      "393532   CNN_31688  [If, Trump, wins, move, Canada, says, cape, Br...\n",
      "\n",
      "[295604 rows x 2 columns]\n"
     ]
    }
   ],
   "source": [
    "# Define method to remove stopwords using nltk stopwords\n",
    "stop_words = stopwords.words('english')\n",
    "def remove_stopwords(text):\n",
    "    text = [word for word in text if word not in stop_words]\n",
    "    return text\n",
    "news_headlines['A'] = news_headlines['A'].apply(remove_stopwords)\n",
    "print(news_headlines)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "       news_outlet                                                  A\n",
      "0            ABC_0  Chief Justice Roberts Responds Judicial Ethics...\n",
      "1            ABC_1  With Reservations Obama Signs Act Allow Detent...\n",
      "2            ABC_2                       Wishes For Fall Times Square\n",
      "3            ABC_3          Mitt Romney Vows Veto Dream Act President\n",
      "4            ABC_4  NY Pharmacy Shootout Leaves Suspect ATF Agent ...\n",
      "...            ...                                                ...\n",
      "393474   CNN_31630  There members Wellesley Women Hillary group Wh...\n",
      "393475   CNN_31631  Kids picked Hillary Clinton president online N...\n",
      "393516   CNN_31672  Before pull lever Election Day know states don...\n",
      "393519   CNN_31675  You wont recognize name face youve definitely ...\n",
      "393532   CNN_31688  If Trump wins move Canada says cape Breton island\n",
      "\n",
      "[295604 rows x 2 columns]\n"
     ]
    }
   ],
   "source": [
    "# Join tokenized text to form sentence\n",
    "news_headlines = CleanData(news_headlines.copy())\n",
    "news_headlines.form_sentence(target_col='A')\n",
    "news_headlines = news_headlines.show_df()\n",
    "print(news_headlines)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Split news_outlet into news_outlet and outlet_id\n",
    "news_headlines[['news_outlet', 'outlet_id']] = news_headlines['news_outlet'].str.split('_', expand=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "       news_outlet                                               name  \\\n",
      "0              ABC  Chief Justice Roberts Responds Judicial Ethics...   \n",
      "1              ABC  With Reservations Obama Signs Act Allow Detent...   \n",
      "2              ABC                       Wishes For Fall Times Square   \n",
      "3              ABC          Mitt Romney Vows Veto Dream Act President   \n",
      "4              ABC  NY Pharmacy Shootout Leaves Suspect ATF Agent ...   \n",
      "...            ...                                                ...   \n",
      "393474         CNN  There members Wellesley Women Hillary group Wh...   \n",
      "393475         CNN  Kids picked Hillary Clinton president online N...   \n",
      "393516         CNN  Before pull lever Election Day know states don...   \n",
      "393519         CNN  You wont recognize name face youve definitely ...   \n",
      "393532         CNN  If Trump wins move Canada says cape Breton island   \n",
      "\n",
      "       outlet_id  name_sentiment  name_subjectivity  \n",
      "0              0            0.00             0.0000  \n",
      "1              1            0.00             0.0000  \n",
      "2              2            0.00             0.0000  \n",
      "3              3            0.00             0.0000  \n",
      "4              4           -0.20             0.4000  \n",
      "...          ...             ...                ...  \n",
      "393474     31630           -0.05             0.8125  \n",
      "393475     31631            0.00             0.0000  \n",
      "393516     31672            0.00             0.0000  \n",
      "393519     31675           -0.20             0.6000  \n",
      "393532     31688            0.30             0.2000  \n",
      "\n",
      "[295604 rows x 5 columns]\n"
     ]
    }
   ],
   "source": [
    "# Sentiment Analysis\n",
    "news_headlines.rename(columns={'A' : 'name'}, inplace=True)\n",
    "news_headlines = CleanData(news_headlines)  \n",
    "news_headlines.analyze_df()\n",
    "news_headlines = news_headlines.show_df()\n",
    "print(news_headlines)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Sentiment density plot\r\n",
    "news_headlines_sample = news_headlines.sample(10000)\r\n",
    "sentiment_density = sns.kdeplot(data=news_headlines_sample, x='name_sentiment', y='name_subjectivity', hue='news_outlet', fill=True, palette='crest', alpha=0.4)\r\n",
    "sentiment_density.set(xlabel='Polarity', ylabel='Subjectivity', title='Sentiment Density Map of All Outlets News Headlines')\r\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYIAAAEWCAYAAABrDZDcAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8rg+JYAAAACXBIWXMAAAsTAAALEwEAmpwYAABF1UlEQVR4nO3deZwcdZ34/9e7qrrnyEzu+w4QEgLkgHCJHKIoIuK6ugoqAqvgAboeywriuujPr9eiIuCqCK7coIAIiroot4CQYCCQhCMXCZkkk0kmc/VRx/v3R9VMOpO5ZzrTw7yfecwjPV3VVe+p7qp3f476fERVMcYYM3w5gx2AMcaYwWWJwBhjhjlLBMYYM8xZIjDGmGHOEoExxgxzlgiMMWaYs0TQDyKyQUTe0Y/XN4nIAQMZUzf7+5mI/OcAbWtmEr+b/P6IiHxyILadbO+PInLuQG2vF/v9lojsEJGtfXy9ishByeNfici3BjbCbve/3/f5Zlb4uRaR80TkiYJl+/X8LSZLBLRd0DPJG7stOZmqir1fVa1S1XVJDP06gQv+hkYRqReRJ0Xk0yLS9h6r6qdV9f/r4ba6THCq+noSf9jXmAv2d4WI3NJu++9W1Rv7u+1exjET+DKwQFUnd7HeHBGJROSn/dzfdBG5VUTqRKRZRJ4RkTN68fq9Lkx92H+X77OInJwktv9p9/wTInJeX/fbHx3F3N/j0FeF5+9QZ4lgj/eqahVwBLAU+FqxdiQiXpE2/V5VrQZmAd8FvgLcMNA7KWL8g20mUKeq27tZ7+PALuDDIlLWlx2JyFjgCSAPHAqMB34E3CYiH+zLNoukGThHRGYPdiCmeCwRtKOqbwB/BA4DEJEzReSl5Fv2IyJySEevE5GjReSpZL0aEblWRNIFy1VELhKRV4FXC547SEQuBD4K/EdSKrlfRC4Rkbvb7eNqEflxD/6G3ap6H/Bh4FwRaf1b2kodIjJeRH6fxLtTRB4XEUdEbia+IN6fxPIfIjI7ifUTIvI68FDBc4VJ4cDkW22DiPwuudi1frPc3O5v2SAi7xCR04CvEl9Um0Tk+WR5YZHcEZGvichGEdkuIjeJyKhkWWsc54rI6xJX61ze2bERkVHJ62uT7X0t2f47gAeBqUkcv+rk9UKcCL4G+MB7u3s/OvFFoAn4hKpuVdWMqt4O/D/gBxLb5xi3Hpfkc/gz4Lgk3vpO4j1DRFbInlLiwuT5fd7nTuKsB34F/Fdnf4iI/KuIrBaRXSLyZxGZlTz/DRG5JnmckrjU89/J7xUikhWRsSJSLiK3SFwyqheRZ0VkUs8P5T7xTBWRu5P3eL2IfL5gWXfn6akiskZEdovItYB0sZ/21YA/EZE/SFwq/7uIHFiw7nwReTA5114WkQ8VLDtdRFYlr3tDRP69r397n6nqsP8BNgDvSB7PAF4C/j/gYOJvRKcCKeA/gNeAdAevOxI4FvCA2cBq4AsF+1DiC81YoKLguYOSx78CvlWw/pRk36OT3z1gO3Bkd39Du+dfBz7Tfh/Ad4gvJKnk5wRAOtpW8vcocBMwAqgoeM5L1nkEeIM4gY4A7gZuSZadDGzu4phf0bpuwfJHgE8mj/81Oe4HAFXAPcDN7WL7RRLXIiAHHNLJcboJ+B1Qnbz2FeKLcYdxdvD6E5LtjwGuAe5vt7zT97Tdek8D3+jg+TnJNua1P8YdHJfzgCfavb7wPV6SfGaOAVzg3OS4l3X1mSnY1snAZmAy0ADMS55/Ajgvefy+5L05hPgz+jXgyWTZKcDK5PFbgLXA3wuWPZ88/hRwP1CZxHkkMLKnn/PC40D85XY58HUgnXxm1gHv6u48JS6VNQIfJD4nvggEnR3vDt7rOuDoZNu3Ancky0YAm4Dzk2VLgB3EVZAANcAJyeMxwBH7+xpoJYI97k2+VT0BPAp8m/gb9R9U9UFV9YEriS82b2n/YlVdrqpPq2qgqhuAnwMntVvtO6q6U1Uz3QWjqjXAY8C/JE+dBuxQ1eW9/Lu2ECef9nziZDNLVX1VfVyTT2IXrlDV5i7iv1lVX1TVZuA/gQ9J0pjcTx8Ffqiq61S1CbgMOKtdaeQbGn+rfh54njgh7CWJ5SzgMlVtTN6nHwDn9CKWc4E/quou4DbgNBGZ2Ie/aTzxBaC9moLl/XUh8HNV/buqhhq3ueSIL4Q9pqpbib80fLODxZ8m/lyvVtWA+LxZnJQKngLmisg44ETiasppEre/nUR8nkH8WRxHfFENk3OpoYuQ7k2+0dcn52xhG8ZRwARV/aaq5jWuw/8F8fve3Xl6OvCSqt6VnO9XAb3pNPBbVX0mOQ63AouT588ANqjq/yb7/QfxF6XWc9sHFojISFXdparP9WKfA8ISwR7/pKqjVXWWqn42udhNBTa2rqCqEXFmn9b+xSJysMRVLVtFpIH4hGh/Mm/qZUw3Ah9LHn8MuLmXr4c41p0dPP/fxN/k/k9E1onIpT3YVnfxFy7fSPytaiAuaHu9D8ljDyisPig8YVuISw7tjU9iar+tfd7PjohIBfHJeyuAqj5FXOL6SE9e384O4kTc3pSC5f01C/hyu4vmDOLj2VvfA94lIu0T7CzgxwXb30lcnTItOYeWEV9oTyS+8D8JHM/eieBm4M/AHSKyRUS+LyKpLmJpPVdHq+po4LPt4pna7m/+KslnpZvzdCoFn+Hki1FvztnOPoOzgGPaxfRR4pIWwAeIk9BGEXlURI7rxT4HhCWCrm0hfhOBtvrhGcRVIO39FFgDzFXVkcQfvvb1i1194+5o2b3AQonr+M8guQD1lIgcRXyR26dHRfKN+MuqegBwJvAlEXl7N3F2V2KYUfB4JvE3nR3EVVyVBXG5wIRebHev9yHZdgBs6+Z17e1IYmq/rY7ez468HxgJ/E9yIdlKfHz70s31L8A/S0GvrsSHiC8+rxAfNyg4duy5eED3x20T8P8KL5qqWqlxW0RPXr9nR6p1xN+Q2/c62wR8qt0+KlT1yWT5o8TVQEuAZ5Pf30VchfJYsm1fVb+hqguIS9tnELfD9MUmYH27eKpV9fRkeVfnaQ0Fn+GC872/NgGPtoupSlU/A6Cqz6rq+4CJxOf8rwdgn71iiaBrvwbeIyJvT76hfJm4aP1kB+tWE9ejNonIfOAzvdzXNuL6zDaqmgXuIq6CeEZVX+/JhkRkpMTdEO8grntf2cE6Z0jcUC3AbiAEos5i6aGPicgCEakkrka4S+Pupa8A5SLynuQ4fg0o7G2zDZjdwUWx1e3AFyXutllF/C3uzqQI3mNJLL8G/p+IVCfVF18Cbun6lW3OBX4JHE5c7F9M/O12kYgc3ptYiHsIjQJuEJHJSYPp2cDlwCUaqyVOUh8TEVdE/hU4sGAb24DphY2d7fwC+LSIHCOxEcl7UF3w+t68zz8kvlAXdpj4GXCZiBwKbY3x/1Kw/FHii/oqVc2TtHEQX6xrk9e8TUQOT74gNBAn64i+eQZoFJGvSNwg7YrIYcmXIuj6PP0DcKiI/HNS7fh59k68ffV74GAROUfiRvOUiBwlIoeISFpEPioio5LqqAb6/rf3mSWCLqjqy8RVMtcQf5t8L3EXzXwHq/87cRVBI/EJeGcvd3cDcT1hvYjcW/D8jcQXnp5UC90vIo3E30AuJz5xz+9k3bnE30qbiOty/0dVH06WfQf4WhJLb3ow3EzcaLYVKCc+kVDV3cTF9+uJL2zNxI2QrX6T/F8nIh3Vj/4y2fZjwHogC3yuF3EV+lyy/3XEJaXbku13SUSmAW8HrtK4l0/rz3LgT/SyVJB8w34r8XFaRdzQ+CXgHFUt/OxcAFySLD+Uvb+EPETcsWGriOxTlaSqy5LXX0vc3fU14gbPVr16n5N6++9T0Oakqr8lrja6I6lqeRF4d8HLniRuV3ss+X0V8fv3WME6k4m/8DQQN94+St+qQVuT/RnESXo98Xl7PXHShS7OU1XdQVz1913i4z0X+Ftf4mgXUyPwTuJ2ii3E58f32PNl6BxgQ3L8Pk1cbbRftfYSMSVK4puc1gCTu2lAM8aYPrESQQlLqkq+RNwNzZKAMaYo3qx3iA55IjKCuA53I3HXUWOMKQqrGjLGmGHOqoaMMWaYG3JVQ+PHj9fZs2cPdhjGGDOkLF++fIeqTuho2ZBLBLNnz2bZsmWDHYYxxgwpIrKxs2VWNWSMMcOcJQJjjBnmLBEYY8wwN+TaCIwxpj3f99m8eTPZbHawQxl05eXlTJ8+nVSqqwFc92aJwBgz5G3evJnq6mpmz55NPI7i8KSq1NXVsXnzZubMmdPj11nVkDFmyMtms4wbN25YJwEAEWHcuHG9LhlZIjDGvCkM9yTQqi/HwRKBMcYMc5YIjBkgfhiwsX4rucAf7FCM6RVLBMYMgF2ZRi7788+5+sm7eWHr2sEOxwwxV111FS0tLW2/z549mx07up62+tvf/vaA7d8SgTEDoCmXYUxFNfPGzyQXdDSBnTGda58IesISgTElJh/6eI6H5zjkw15NpWyKZMOGDRxyyCFccMEFHHroobzzne8kk8mwdu1aTjvtNI488khOOOEE1qxZQxiGzJkzB1Wlvr4e13V57LF4Ns0TTzyRV199lUcffZTFixezePFilixZQmNjY4f7VVUuueQSDjvsMA4//HDuvDOeDfORRx7hjDPOaFvv4osv5le/+hVXX301W7Zs4W1vextve9vb9tneLbfcwtFHH83ixYv51Kc+RRiGXHrppWQyGRYvXsxHP9r/mS0tERgzAPJhgOe4eI6Hb4mgZLz66qtcdNFFvPTSS4wePZq7776bCy+8kGuuuYbly5dz5ZVX8tnPfhbXdZk3bx6rVq3iiSee4IgjjuDxxx8nl8uxadMm5s6dy5VXXslPfvITVqxYweOPP05FRUWH+7znnntYsWIFzz//PH/5y1+45JJLqKmp6TTGz3/+80ydOpWHH36Yhx9+eK9lq1ev5s477+Rvf/sbK1aswHVdbr31Vr773e9SUVHBihUruPXWW/t9nOyGMmMGgB8GpFwXz3HJhdZYXCrmzJnD4sWLATjyyCPZsGEDTz75JP/yL//Stk4ulwPghBNO4LHHHmP9+vVcdtll/OIXv+Ckk07iqKOOAuD444/nS1/6Eh/96Ef553/+Z6ZPn97hPp944gnOPvtsXNdl0qRJnHTSSTz77LOMHDmy1/H/9a9/Zfny5W0xZDIZJk6c2OvtdMdKBMYMgHzo4zouKde1XkMlpKysrO2x67rs3LmT0aNHs2LFiraf1atXA3EV0OOPP84zzzzD6aefTn19PY888ggnnHACAJdeeinXX389mUyG448/njVr1vQqFs/ziKKo7fee3PSlqpx77rltsb788stcccUVvdpvT1giMGYA5MOAlMQlgryVCErWyJEjmTNnDr/5zW+A+EL7/PPPA3D00Ufz5JNP4jgO5eXlLF68mJ///OeceOKJAKxdu5bDDz+cr3zlKxx11FGdJoITTjiBO++8kzAMqa2t5bHHHuPoo49m1qxZrFq1ilwuR319PX/961/bXlNdXd1hm8Pb3/527rrrLrZv3w7Azp072bgxnlYglUrh+wPzWbNEYMwA8MMAN2kjsERQ2m699VZuuOEGFi1axKGHHsrvfvc7IC49zJgxg2OPPRaIL+iNjY0cfvjhQNyz57DDDmPhwoWkUine/e53d7j997///SxcuJBFixZxyimn8P3vf5/JkyczY8YMPvShD3HYYYfxoQ99iCVLlrS95sILL+S0007bp7F4wYIFfOtb3+Kd73wnCxcu5NRTT21rb7jwwgtZuHDhgDQWD7nJ65cuXao2Q5kpNQ+++ixbGuuYNGIMG3dv41NHnznYIQ0rq1ev5pBDDhnsMEpGR8dDRJar6tKO1rcSgTEDIB8GeOLiuS55ayMwQ4z1GjJmAORDH89trRqy7qPDwcqVKznnnHP2eq6srIy///3vgxRR31kiMGYA5AKflOuRclx8ayMYFg4//HBWrFgx2GEMCKsaMmYA5MOAlNPaa8hKBGZosURgzABoHWIi5Xr4kSUCM7RYIjBmAOTDIGkjcG2ICTPkWBuBMQMgLhFY1VAp+/qDN1CfbRqw7Y0ur+Kbp36i2/Xuvfde3v/+97N69Wrmz5/fNhjevHnzUFVGjBjB//7v/zJv3jwA/vjHP/Kf//mftLS0UFZWximnnMIPfvCDAYu7I0VLBCIyA7gJmAQocJ2q/rjdOicDvwPWJ0/do6rfLFZMxhSLHwakHA/PcQmikEgVx6ZOLCn12SY+d9wHBmx71zx1d4/Wu/3223nrW9/K7bffzje+8Q0ADjzwwLaG5p///Od8+9vf5sYbb+TFF1/k4osv5g9/+APz588nDEOuu+66AYu5M8WsGgqAL6vqAuBY4CIRWdDBeo+r6uLkx5KAGZJaRx8VEaseMm2ampp44oknuOGGG7jjjjs6XKehoYExY8YA8P3vf5/LL7+c+fPnA/H4SJ/5zGeKHmfRSgSqWgPUJI8bRWQ1MA1YVax9GjNYWkcfBUi78TATZV5qkKMyg+13v/sdp512GgcffDDjxo1j+fLljBs3jrVr17J48WIaGxtpaWlpu/fgxRdf5Mtf/vJ+j3O/NBaLyGxgCdDRnRbHicjzIvJHETl0f8RjzEDzkxIBYHMSmDa33347Z511FgBnnXUWt99+O7Cnamjt2rVcddVVXHjhhYMZZvEbi0WkCrgb+IKqNrRb/BwwS1WbROR04F5gbgfbuBC4EGDmzJnFDdiYPvCjAM+JT6eUa3MSmHik0IceeoiVK1ciIoRhiIhw0UUX7bXemWeeyfnnnw/AoYceyvLly1m0aNF+jbWoJQIRSREngVtV9Z72y1W1QVWbkscPACkRGd/Betep6lJVXTphwoRihmxMn+StRGDaueuuuzjnnHPYuHEjGzZsYNOmTcyZM4dNmzbttd4TTzzBgQceCMAll1zCt7/9bV555RUAoijiZz/7WdFjLWavIQFuAFar6g87WWcysE1VVUSOJk5MdcWKyZhiCKMQUFwn/l6Vsi6kJWl0eVWPe/r0dHtduf322/nKV76y13Mf+MAH+M53vtPWRqCqpNNprr/+egAWLlzIVVddxdlnn01LSwsistc8x8VSzKqh44FzgJUisiJ57qvATABV/RnwQeAzIhIAGeAsHWrjYpthL590HW3luTY5TSnqSZ//gdR+/mGI5yf+/Oc/3+XrzjjjjP1y8S9UzF5DTwBddqRW1WuBa4sVgzH7Q9xjqCARWPdRM8TYEBPG9FMuuau4led4Nm+xGVJsiAlj+qm1RJDxfdZuqwPFSgRmSLFEYEw/5cMAVPjcLfchwCmLJ1obgRlSLBEY00/50EcVxldVMnl0NVEUWa8hM6RYG4Ex/RRXAwkp1yXluoQRViIwQ4qVCIzpp9aqobTnknZdgjBvjcUl6CM3Xk9t08ANQz2hqorbzv1kl+u4rsvhhx+OquK6Ltdeey1vectbSm4oaksExvRTa9VQynUp81yyYWQlghJU29TElf80cMNQ//u93d+cVlFR0Tbc9J///Gcuu+wyHn30UaC0hqK2qiFj+ikfBmhSIkh5LvnA2gjMvgqHm+5q2WAMRW0lAmP6yQ8DwkjjEoHr4gdWIjCxTCbD4sWLyWaz1NTU8NBDD7UtK6WhqK1EYEw/5UOfKIKU65D2PCsRmDatVUNr1qzhT3/6Ex//+MdpHUWnlIaitkRgTD/lAh8/iuLGYs8l74fkrbHYtHPcccexY8cOamtr91l25pln8thjjwF7hqLenywRGNNP+TAgCJS055H2XLJ+RD6yEoHZ25o1awjDkHHjxu2zbLCHorY2AmP6KR/6BEFEuizuPprzQxtiogRNqKrqUU+f3myvO61tBACqyo033oibTGlaSkNRWyIwpp/yoU8+jKuGylIemXxgbQQlqLs+/8UQhmGHz8+ePZtMJtPp6/b3UNRWNWRMP/lhQD7Y00aQ88NkshpjhgZLBMb0UxCF+EFE2vXwHIdI4+eMGSosERjTT0EUkgtC0l5c95tyXUsEZkixRGBMPwVhSN6P9iQCx7WqITOkWCIwpp+CKCRbUCIoS6UACKNoMMMypscsERjTT0EUkvND0km3wLTn4ohj1UNmyLDuo8b0kx8GiAiuIwCkXRdJEkEZqUGOzrQ68ds/p2Z344Btb8qoah776qe6XW/r1q184Qtf4Nlnn2X06NFMmjSJq666ikWLFnU4DPW2bdv4xCc+waZNm/B9n9mzZ/PAAw8MWNwdsURgTD/5UUiqYPL6tOciiJUISkzN7kZuufBDA7a9j133627XUVXe//73c+6553LHHXcA8Pzzz7Nt27ZOh6H++te/zqmnnsq//du/AfDCCy8MWMydsaohY/opiEJS7p5EkLJEYBIPP/wwqVSKT3/6023PLVq0iBkzZuy1XuEw1DU1NUyfPr1t2cKFC4sep5UIjOmnINrTPgAkjcaWCEw8pPSRRx7Z4bLOhqG+6KKL+PCHP8y1117LO97xDs4//3ymTp1a1DitRGBMP4VRhFdQNZRyXVQhsIHnTBc6G4b6Xe96F+vWreOCCy5gzZo1LFmypMMRSweSJQJj+inS+K7iVmnXRdVKBKbnQ0oXDkMNMHbsWD7ykY9w8803c9RRR+21rBgsERjTD5EqipLy9pxKac+Nh5noZMAxM3yccsop5HK5veYcfuGFF9i0adNe6xUOQ/3QQw/R0tICQGNjI2vXrmXmzJlFjdPaCIzphyAKEYS0t6ebaNpzUV+tRFBipoyq7lFPn95srzsiwm9/+1u+8IUv8L3vfY/y8nJmz57NVVdd1ekw1MuXL+fiiy/G8zyiKOKTn/wkRx111IDF3RFLBMb0Q5wIHFLunhJBmesS5iwRlJqe9PkvhqlTp/LrX++bgDobhvqSSy7hkksuKXZYeyla1ZCIzBCRh0VklYi8JCL/1sE6IiJXi8hrIvKCiBxRrHiMKYYgChAEr1330TCyRGCGjmKWCALgy6r6nIhUA8tF5EFVXVWwzruBucnPMcBPk/+NGRKCMERhr+6jZZ5nicAMKUUrEahqjao+lzxuBFYD09qt9j7gJo09DYwWkSnFismYgRZEIahQ5u19H0EYWiIwQ8d+6TUkIrOBJcDf2y2aBhQ2n29m32SBiFwoIstEZFmx+9Ma0xtBFBKpkipMBK6LH6n1GjJDRtETgYhUAXcDX1DVhr5sQ1WvU9Wlqrp0woQJAxugMf0QRCGqe1cNea5jJQIzpBQ1EYhIijgJ3Kqq93SwyhtA4aAb05PnjBkSgigkithrrCHPtcZiM7QUrbFYRAS4AVitqj/sZLX7gItF5A7iRuLdqlpTrJiMGWhx1VBcCmiVch3CMLJEUGKO/8w11NT1qVKiQ1PGjeRvP/1ct+t1Ngz1vHnzuPrqq/nc5+JtXHzxxSxdupTzzjuP8847jwcffJB169ZRVlbGjh07WLp0KRs2bBiw+AsVs9fQ8cA5wEoRWZE891VgJoCq/gx4ADgdeA1oAc4vYjzGDLi4RKB4zp5E4IoQqpIP/UGMzLRXU9fAbf/1sQHb3ke+cUu363Q1DPXEiRP58Y9/zKc+9SnS6fQ+r3Vdl1/+8pd85jOfGbCYO1O0RKCqTwDSzToKXFSsGIwpttYSgUbK/X97ie31Tbxj6TwEIRtYIhjuOhuGesOGDUyYMIHjjz+eG2+8kQsuuGCf137hC1/gRz/6UYfLBpqNNWRMPwRRSBgqTZk8a7fsxHEctu1qRMQh51siGO66GoYa4Ctf+QpXXnklYQc9zGbOnMlb3/pWbr755mKGCFgiMKZfgjAkjMAPQ6oryxhTVUEu7yMIucCGoTZdO+CAAzjmmGO47bbbOlx+2WWX8d///d9EUVTUOCwRGNMPQRTGPYT8kHTKJe15tGR9HHHIh5YIhrueDEP91a9+le9973vENeV7mzt3LosXL+5wrKKBZInAmH5oTQR5PyTluaRTLpmcJQIT68kw1PPnz2fBggXcf//9HW7j8ssv58orryxqnDb6qDH9ECeCCD8ISXsu6bRLpt7HGSH4lghKypRxI3vU06c32+tOV8NQF7r88stZsmRJh9s49NBDOeKII3juuecGIuwOWSIwph/8MCCKIJ8LSHsuZZ5HJu9TjWOJoMT0pM9/MXQ2DPWLL77Y9njRokV7tQP86le/2mvde+7p6H7cgWNVQ8b0QzbwEREyeZ90yiOdcsnmAlzHsRvKzJBhicCYfsj6cQ+hTC6gLOWRTnnk/LiNwBKBGSosERjTD7m9SgQuZSmPTD60RDAIOup1Mxz15ThYIjCmH/JBgIOQzcdtBK4joIojDqFaIthfysvLqaurG/bJQFWpq6ujvLy8V6+zxmJj+iEf+vFdxPmAdMpFREinPIggLPJNQGaP6dOns3nzZmy+kjgpTp8+vVevsURgTD/kwwBHnLhEkIpPp/K0iwKRWiLYX1KpFHPmzBnsMIYsqxoyph/8MMRB8IOgbXKatOehaonADB2WCIzpBz8KAcHzXMSJB9tNpzyiUIkY3vXVZuiwRGBMPwRhgCCUpfbUsqZTLlEoKFYiMEODJQJj+iHQEFUhnSqYvN5zicIIhnkPFjN0WCIwph/CKEJVKfP2JIKU5xKGcWkgsmRghgBLBMb0QxiFEO1dIihLufiBomA3lZkhwRKBMf0QakQUKSmvsI3AIwhDULFEYIaEHiUCEblHRN4jIpY4jCkQaUQUxe0CrdKei++HSYnARiA1pa+nF/b/AT4CvCoi3xWReUWMyZghI9KIMIxIFTYWpz38IEQ1nsrSmFLXo0Sgqn9R1Y8CRwAbgL+IyJMicr6IpIoZoDGlTIkIAvbuPup55PMRGlkbgRkaelzVIyLjgPOATwL/AH5MnBgeLEpkxgwBkSpBMjtZq3TKJQhCIrVEYIaGHo01JCK/BeYBNwPvVdWaZNGdIrKsWMEZU/qUIIhIFSQCz3Xwg5Ao8iwRmCGhp4PO/UJVHyh8QkTKVDWnqkuLEJcxJS8e8lgJA/C8PYXrlOMQhlFcWrBEYIaAnlYNfauD554ayECMGWoijUcTCkPwnD2nkjiC4ziE1kZghoguSwQiMhmYBlSIyBJAkkUjgcoix2ZMSWu9yIdRhFdQNQRxYogiKxGYoaG7qqF3ETcQTwd+WPB8I/DVIsVkzJAQRPE4Q2EY4rl7F65TnhBGShDafQSm9HWZCFT1RuBGEfmAqt7dmw2LyC+BM4DtqnpYB8tPBn4HrE+eukdVv9mbfRgzmOJEAGGo+yYC10M1JBP4gxSdMT3XXdXQx1T1FmC2iHyp/XJV/WEHL2v1K+Ba4KYu1nlcVc/oSaDGlJrWRBAEIal2iSBODBG5vCUCU/q6qxoakfxf1dsNq+pjIjK71xEZM0QEYUgUAQqO00EiULESgRkSuqsa+nny/zeKtP/jROR5YAvw76r6UpH2Y8yAC6KQSHWvrqOtUq4L+GT9/P4PzJhe6umgc98XkZEikhKRv4pIrYh8rJ/7fg6YpaqLgGuAe7vY/4UiskxEltXW1vZzt8YMDD8KCSNwnX1PI9cVVIWslQjMENDT+wjeqaoNxI2/G4CDgEv6s2NVbVDVpuTxA0BKRMZ3su51qrpUVZdOmDChP7s1ZsD4YUAU6j7tAwCe64JCzhKBGQJ6mghaq5DeA/xGVXf3d8ciMllEJHl8dBJLXX+3a8z+EkQhobJPjyGIn1MVSwRmSOjpEBO/F5E1QAb4jIhMALJdvUBEbgdOBsaLyGbgv4AUgKr+DPhgsq0g2e5Zqjavnxk6coEfT0rTQSJwXSGvkAvsPgJT+nqUCFT1UhH5PrBbVUMRaQbe181rzu5m+bXE3UuNGZKyfh7V1obhvXmui0aQD61EYEpfT0sEAPOJ7ycofE1X9wgY86aW8X1AOq8aiiBvdxabIaCnw1DfDBwIrABaB09RLBGYYSzj51GVuGG4nZTrEPk2xIQZGnpaIlgKLLA6fGP2yAZ50M66j7pEubiLqTGlrqe9hl4EJhczEGOGmlzgowpuJ1VDkQ1DbYaInpYIxgOrROQZINf6pKqeWZSojBkCsr4PXXQfjQIbhtoMDT1NBFcUMwhjhqJc4BOpdNhrKOW5hBGEaonAlL6edh99VERmAXNV9S8iUgns++k3ZhjJhQEadVI15DiEoRJpNAiRGdM7PR1r6ALgLuDnyVPT6GJsIGOGg3zgoxEdDjrneQ5BEBFZicAMAT1tLL4IOB5oAFDVV4GJxQrKmKEgHwVE0d7zFbfyXIfAVyLraGeGgJ4mgpyqto2nm9xUZp9wM6zF8xHoPvMVQ3xncRBEKFY1ZEpfTxPBoyLyVeJJ7E8FfgPcX7ywjCl9fhRPTNPhWEOOEIaKfV8yQ0FPE8GlQC2wEvgU8ADwtWIFZcxQEEZBh/MVA4gIogJiicCUvp72GopE5F7gXlW1mWGMIZmhLIzaGotVlVAjXHEQEVzHbXs+GXHdmJLUZYlAYleIyA7gZeDlZHayr++f8IwpXZFGBAF4jkvGz/PI5lU8unk121ri6To8x4knt7ebykyJ665q6IvEvYWOUtWxqjoWOAY4XkS+WPTojClhoYYEYYTnOrQEOapS5UweMYqWIO5X4TmCqo03ZEpfd4ngHOBsVV3f+oSqrgM+Bny8mIEZU+oiVQI/biPIhQEpxyXluPFgdEDKS8YbshFITYnrLhGkVHVH+yeTdoJUcUIyZmhQIlTBcYRskCfluqQdj1wyGY0nLlEEfmSJwJS27hJBvo/LjHnTUxRJTqFs6JN2PFKOR7Y1EbguoSp+aFVDprR112tokYg0dPC8AOVFiMeYISTCIe4NlA19Kr0y0q5HLqkKaq0aytsE9qbEdZkIVNUGljOmEyLgJCWCXOiTcjxcceK2gygk5bqoQotvhWdT2np6Q5kxpkDrGEKuE5cIcmFA2nUREcrcuJ3AdePuoy15SwSmtFkiMKYPgihEFVKumzxWXIlPp9Z2Aq8tEeS62Zoxg8sSgTF9EIQBUTI7WS70Sbte293DacclFwRx1VAkVjVkSp4lAmP6oG3AOcclGwaknD3NbSk3vpfA8+ISQcYSgSlxlgiM6YMgCogiJeU65AKftLOnX0Vh1VCkkLU2AlPiLBEY0wf5wI9LBJ7bdjNZq3SSCFKeg0aQte6jpsRZIjCmDzK+T5Q0FmeTrqOtWu8u9tz4zuJsYHcWm9JmicCYPmjJ51CNJ67PJ+MMtfJcN37OdYkiJRdY1ZApbZYIjOmD5nw+6T7qkI9CvIJE4IpDGEV4rhBFSt5KBKbEFS0RiMgvRWS7iLzYyXIRkatF5DUReUFEjihWLMYMtBY/H09cn9xH4MmeU8kRwXEccCEKIR9aG4EpbcUsEfwKOK2L5e8G5iY/FwI/LWIsxgyobGuJwHPxo7BtNrJWrYkhjBTfhqE2Ja5oiUBVHwN2drHK+4CbNPY0MFpEphQrHmMGUibIo1EySX0Utt1V3MpzHNRRwlBtYhpT8gazjWAasKng983Jc/sQkQtFZJmILKuttSmTzeDLJr2GHFfiqqB2cxK74hJqSBRiJQJT8oZEY7GqXqeqS1V16YQJEwY7HGPiRBABDns1FLfyHJcgikAtEZjSN5iJ4A1gRsHv05PnjCl5udBHI0UcxXX2PY08kXhmMhGbvN6UvMFMBPcBH096Dx0L7FbVmkGMx5geywcBUQQqiif7lggcx8GPQhwVQrVEYEpbdzOU9ZmI3A6cDIwXkc3Af5HMc6yqPwMeAE4HXgNagPOLFYsxAy0X+ISREgmdlAhc/DBEcIg0GoQIjem5oiUCVT27m+UKXFSs/RtTTPnAJwyUiL3vIWjlOg6ZwEcQFB2ECI3puSHRWGxMqcmFPqoQRlGnJYIgCnDEQbESgSltlgiM6YN8EIDGDcIdtRF4joMfxvcXtOtZakzJsURgTB/kw9ZEEHZYInDFwdcQBxcRqxoypc0SgTF9EEYhIG3f+ttznT1jEHWQJ4wpKfYRNaYPAg0R4hKB12EbgdPWfuA4SqRWKjClyxKBMX2gGiIa3yzmdtBGICK4jkPacwkjG4HUlDZLBMb0gUqEaOclAojbCVzPIQyhKZfZzxEa03OWCIzpC1EEJykRdHwaeY6L40IYwc7mlv0coDE9Z4nAmD4QURxxERGczhKBOIgDUQS7Wpr2c4TG9FzR7iw25s3MccDtIgkAbZPVRCHUZ6xEYEqXJQJjeimMIhxH8VyHyN23obiVJw5IXDXUmLU2AlO6rGrImF7KhT5hBJ7rdNhjqJXrCCoRUag05rL7MUJjescSgTG91JTNEIYgrnTaYwjiWcoiNO41lLdEYEqXJQJjemlnppkwAsel0x5DELcRhISEIbTkc/sxQmN6xxKBMb1U39JCMsJElyUCTxxCjQj8iIxvicCULksExvTS7kwLUQSRRLh00VjsxMNMhBG0WCIwJcwSgTG91JBtIWydprLLNoJ4ukoiIWuJwJQw6z5qTC815nKEgYJ0PClNK89xCTRsm7fAmFJlJQJjeqklnyUMIUK7TARuMgKpo45NYG9KmiUCY3qpOZ8jCJRQow5nJ2vVOgKpODZdpSltVjVkTC8157JEocYTz3Qz64wrLo4DIlY1ZEqXlQiM6aVmP4uqQxBFXd5HAHHPIVdculnNmEFlJQJjeikX+AgCQpeDzkGcCCJHcB2bocyULvueYkwvBVGAIKR68DXfExfXE1wXgtAajE1pskRgTC+FGsYNwV2MPNrKFQfHdYhschpTwiwRGNNbEuJI1yOPtnIdB0QJI6hrtslpTGmyRGBMb4niSNcjj7ZyxQEHwhB2ZZr3Q3DG9J4lAmN6yXFISgQ9aCNw9gxFXW+JwJSooiYCETlNRF4WkddE5NIOlp8nIrUisiL5+WQx4zFmIDiO4jjS5V3FrTxxiIgIQ6UhY3MSmNJUtO6jIuICPwFOBTYDz4rIfaq6qt2qd6rqxcWKw5iBFEURrgsi4HUx8mgr13EIidAQmnI2XaUpTcUsERwNvKaq61Q1D9wBvK+I+zOm6HZnM6gCTg/bCByHIAoJQ7UJ7E3JKmYimAZsKvh9c/Jcex8QkRdE5C4RmdHRhkTkQhFZJiLLamtrixGrMT1S19xMGMZDUPesasgliEKiUNjR1LgfIjSm9wa7sfh+YLaqLgQeBG7saCVVvU5Vl6rq0gkTJuzXAI0pVN/Skow8GvW411AERCHUZywRmNJUzETwBlD4DX968lwbVa1T1dYZO64HjixiPMb0W30yX3F3I4+2EhHSjouGDrnIJqcxpamYieBZYK6IzBGRNHAWcF/hCiIypeDXM4HVRYzHmH6raajHzyt5DUk53ScCgJTjIrjg2AikpjQVrdeQqgYicjHwZ8AFfqmqL4nIN4Flqnof8HkRORMIgJ3AecWKx5iBsGX3Tvy8IoDbw0TgOS4BSioV4IchqR4MTWHM/lTU0UdV9QHggXbPfb3g8WXAZcWMwZiBtL1pN2EI6VTPT52U45LRkHRK2FK/m1njxhYxQmN6b7Abi40ZUprzzUSR9LhaCOISgZsSghDW1m4vYnTG9I0lAmN6IdA8RA5eL6p3Uo6L4wp+Hjbs3FHE6IzpG0sExvSC40aAkOpBj6FWKcdDHcXPQ03DruIFZ0wfWSIwpoeyvk8qrTji4PWyakglIpuNqGtpKGKExvSNTVVpTA9tqKsjikA8p1c9f9Kuix+F5LMRjTmbk8CUHisRGNND6+u24/uCOPSqaqh1mAlCl3wPbiqr2V1PSy6Lqs1zbPYPKxEY00Ob6+vI5xWVqFdVQyISr+84uJ7PruYMY0ZU7LPe2u11/OiR+9D0bkCocKv57ukfx3PtNDXFZSUCY3poW9NucjklJCLVy4tzynXxXI/KMuH3L7QfiR2efHU9V/zfLaTK8hw/fSnHTV3K7kwzlz9wm5UMTNFZIjCmh3Y2N5DPRYSR4vVgdrJCKcelzHMJ8h4Prnl+r2V/XLmG/3n6PmaMHclJs4+kKl3ByPJy3jb7COrz9dy27MmB/DOM2YclAmN6qDHfHN9D4DiISK9e64mLl3bJN3qQbuSNXbtRVW576h/c8o//Y9aEkRw97TCcgu1WlZczq2o6j25YTnPOBqwzxWOJwJgeaMnnES+HhG6fxgpKuS7iQt32gFHVDp/43zv56HW38eD6vzFnYjVLpxyG00Ep49DJM/Fclx/89Y8D8WcY0yFLBMb0wL0vLAd18CRN2ul94225myZ0Quobc8waOYX5c/NMnLqLQ6ZMZOmUw3A7qWoSEQ6feBBvZDby6jablMkUhyUCY9rJBT7bmnZRn9nT5//p11fht6Rw01DmpXq9zXI3RTbME0bKpLKpvHX6Uo6dupj54w7ssCRQaNrI8VSmKvjeX+6zhmNTFNYvzZgCWxt3cs1Td+M5Llk/zxHTDmbmqEkEThNBYxWU5yl3+5AIvBSZ0GfaxJG8vGk7R8+fQboX2zli8jyeCp/nqgcf44vvPKnX+zemK5YIjEnUtTRw7VN3c8yMBUyqnMAbu+rZ3PAGT7z2Ki0tZTQ15UlVRn1KBI44lDkek8ZV8fLGbRw9f9/pufN+yMp1NaxcV4PnusyZOo5jF8zEdYRR5VXMGjWFlduf5yd/TXHBSceQ9mxeAzMwLBGYN60gCmnMtTC6vKrbXj6qyq0r/o/Zo6dxy2NrqG1czriqSnJ+yLwp43nLwdO4ZuXjTJqQ7lMigLhUMKLSY8uqBjJ+QEXBnAZv1O7mnsdWMrKynAOnjQdgzcatrNmwlQ+/fTFVFWXMHzeHJr+Z53c8z2k/fIHTDjuEty84iCUzp+I4vevFZEwhSwTmTSkb5LnmyXuoaazDFeH8I9/NgklzOl3/qddfYkdzI0+trOGYA2fykWMX7dWV89XNOxg3poKUaI9nJmsvrh7KM3FsNS9v2M7iuVOJFJ5cuYGnV23kqPkzmDV5TNv60yeM4vnXarjl/5Zz7mlHU1HmccSkBWyo2MyIEVt4I/cK33lwFTt2KqfMn8fbFxzE/CkTGDuiotfdW83wJkOt8Wnp0qW6bNmywQ7DlLBII773yB2s2VJHpqmCvGaZOVU554h3ctT0efusX9tcz38/djtr1oW85cADWTB14j7rPPD0GjKaRSsCDhw9uU9x7cw20RLkmOiM4fEX1nPwjPFs3r4bz3U4fuEcRpSn93mNqvLcK2+ws7GFj73ryLZSRD702Zmtpy6zi9qWnYQhtGQhHwakUornOJS7lZy54DhOOfjQPsVr3lxEZLmqLu1wmSUC82bz55eX8esVf2N65QEcOWsq+TDk/1atJjViNx8/4l0cM3NPMgiikO8/ejtrNjUwrXoqxx24b929KlxzzxMcfPAYfAmYXjWuT3G1+Dleb9rBcVMOJpPzefn17UweV82kMdVdfoNXVZa9vJn6pgxnv2MJVe0ShqrSEmTIBFkEB1c8mjI51tVvpzmso8odxzfe/SEq0/smGjN8dJUIrPuoeVNpyWf5/ZqnqHImcOSsqUA8DPR7DjsUzx/HTc/9iTv+8Sh+GLCzpYEfPf5r1m/fzZiy8Rx7wPQOt7mjoZkgCAkl7HP7ACRdSAOfMIqoKEuxeO40Jo8d2W01joiwdN50Joyq4uf3PsVzr75BJhfstXxEqpLxFWMZVzGa0eVVTB8zjhPnHMLx04+gJdzNxXf/gpe21PQ5dvPmZiUC86Zy5cO/ZeWWzZy54FhS7t7fc1SVZ19/nc2NmxhZDaiwtVaZMWoaJ86d3eEFOZMPuPlPy5gyfiQtFU1MrRpLVaq8z/G9Vr+VGSPHMblydJ9eX1vfxKr129i6s4GKsjSjRpQzqqqcqooyKsrTeK6Qcl0qylJMnzCK6soywijkyU0vsjvXyNyRh3DxySdTsZ9KB2EU8sdX/s5Drz3H2w86ktMOPgbXse+fg6GrEoE1Fps3jZdqNrG2/nWWTl2wTxKA+Jvz0bNmMS8zmde27yAXBLxnwcR9hoRuyfpsqq1n07Z6Xt5Uy6QxVRw0YyzPbNtFpde/C+jY8ipqmur7nAgmjK7ipCVVRFFEUzZPUyZPSyZPJu+zuzlLpEoYRmTzPvfvambimCpOXnIgJ8xaxLqdW3h118tc/Ns1HDrhID5x3MmMqqjs19/TnZ8+dT8vbNlEzXalObOMN+p3ceGxpxd1n6b3LBGYN4UwCvmfp35PmY5i1rixhJGycl0NW3Y0IALzZkxk9pSxOAKjKso4cta0fbaxqynDY8+vY83GWiaMqmTc6BEccfA0Jo+tZmNDLaPLRnR7F3B3Rqcr2dRURy70KetHNZPjOIysLGdkZeelkyhS1m/dyb2Pv8j0CaN459HzmHPAFF6u3cwrOzdw2Z9+waSKKfzrMW9nxpi+tXt05R9vvMZL215ncvlMTjt+Ov/YtIkVNa/yau0bzJ2w7/E3g8eqhsyQp6pc+vvb2JXdybsOOoa63S3c/ehKylIu0yeMIggjNm6rRwTefsRBzJ0xkcJu9zk/4OmXXueZVa9z8MwJzJ85kbL03t+Rnq55lakjxlCd3ndCmd7a2FBLVbqcgwp6HwVRyNbmenZkGmnyszjiUOmlmVo1hgkV1Ug/ElAQRqxcV8Nrm3dw9CEzOXrBTCrSHpt31bFy+3rEy1LhVPPW2Ydx2iGLqEiX9ftvzAc+//6H62jcXcaOTTlq61uYNLaKCTNdRlbDD957gXVx3c+s15B502rO5fnGH++iMdrB8dOPYPO2Rv7w1CqWzpvB7Mlj2i42qsrm2t2sXFtDpBHzZ05i5Ihytu9qYs3r25k8torFc6dRVbHvRbDJz/LctvUcNm7GgFy8cqHPut3bGFVWSVWqgt25ZnZmmxhZVsnodCUVSfVTc5BjZ6aJQCMOGj2JCRXdNyx3pbEly8q1W9lcu5tDZk/ksDmTmTlpDLuzLbxQs4FGfzfpdIRomjHpUYwbMRqPFOtqdlCzq4HmbI4RbiUnH3QInzjtOLwOqt9aXf34/Sx7fT3rX/I58uDpzJw4mrVv1PHC+hrmL/E4Y/7xvO/wDq9JpkgsEZg3lTCK2FRXz+9W/oPnt62iosxh6dTDePGVbTz3ymZOXHQg40aN6PC1qkptfTPbdjWQyQZUjyhj6vhRjBrRcRVLPgxYvn0dY8uqmFg5agD/hpCtLbtRlHI3xeiyER1Of6mqNOYzbGnZhYMws3o8EypH9mqqzPZasj7ra+rYuG0XTS15Zk4axfQJoxkzshJfA7a31NPkN+NHeZAI13HwHBfHEVRCysoi6nYIn33Luznp0IP32f7L2zdz1d/uZtULAW+dfwCTxlS3Ldu4dRdrdmxixqwUV7/vM6Q9q53eXywRmAEVRtF+6fmxYccubnr6Sdbu3Ew+yqLEffrFUUZXCZ7rMrlyEhPTE3jgqdUEUcQJCw+gomxP3Xvr57s336SDKKTJz1KfbWZLcz2jyiqYOmLsQP95vaKq7M63sDPbREM+Q9r1KHdTpB0X13FxxUEEBEFE4rGNXI8RqTKqUuWdJo6WnM/2nY3UNbTQksvj+yGu41BVWcb4USOYOn4kqXZjGjXkWnh510ZGVIWMZTLfeN8H26bu3LSrlu88cjuvbwo4ZOwMZkwcs88+V7y6GR1bz4LxB3HJqWcM/MEyHbJEYAbEI2vWcvMzT7ArtxNX0iyafBBfPPVtjCjruifN1t2N3PrM31m9bRNBAAeMm8rphx3KkbOndXiBfrmmlmse+SvNso3qCo+xZWMYW1mNanxBVAUJU9TWZVmzcTu19c0cfsBkDp4xARGJv0E37aQ200Q+9AGhwksxqqyCcRUjGV1WuVdDbRCF1Oeaqcs0sTPXRDbwqfDSjPDSjCwbQXWqvKTqsyNV8qFPPgoIoohII6LkuGjBPz8MyYU+LUGeSi/N6PIRjC6rpDpVQYWX7vff9PK2rTRILZXlDlMqJlFe5vF64xtseiPk4OoZzJoyhiiK2JVrxo9CUq7L2LIRgPDoqleYNMvn7MNP58S5+5YqzMCzRGD6JR+EfPuPf+SN7Fo8PIIWFzcFbmWe2jrhgmPfyamH7jt0Q0NLlh89/Gc2NW+gPO1SRgWKEkiGpgzs2pXi+FkLWDJ7KmnX5dVtO3j41VVIWT2jqhxormLT6xl2NWZpyedxcHAcIeW5VJanGFtdyZRxI5k+cRSOCHXZRjY21NLi5xlXUc3o9Ihk7gAlGwQ0+ZnkJwcIadclCEMCjRiRKqc6VU51Or5IOiV04e+vSCNaghxNfo4WP0fGz+FrRKWXpiL5KfNSpBwXV1xcERyRfRKFKw5pxyPtem3LckHIsg3rCL0sQaRozmPhlFmMrE6zsaGWmuZ6Ktw0KdcjH/pkw4AZ1WOZUjGWZ15/mVFj4XNv+QBLZnZ0R7cSqfa59KmqJZXAB9ugJQIROQ34MeAC16vqd9stLwNuAo4E6oAPq+qGrrZpiWBg5HyfnS3NVJeXU1XWeRfETTt3cenv7mDkqDyb14dUpaupqkzjhxG76puoGh9QNdIhyozmI0vfwtxJE6ltauQPL/2DdQ3rSLlC7WbYVpOnekQZjkBDS47xE10mT/PwyiKyGQdVKCtXohC2bg7INXhMGTeKSWOrGVVVQUXa26vhN9SIbOjT7OeozzazvWU3KddlQsWopJtn10M2BBoShBGuI3iO96a68PdEGIVkQ59cGJAPA4IoJNSIUEOipGRBu0tDSIQfxutVpcoZXV7JmLIRVKUqKHNdQlUa8hm2NtdTm2lI2lVG7jXvQjbIU9NST3M+y4zq8Wyp386osUrKH8txBxyE58HWph1sadxONsygRLiOx4yRkzjpwIUsmnJgp9VcbzTU8vdNq3ihZi27s814jsuB46Zx1PT5LJpyUKev251t5qFXV7B8yys0+y144jFj1CTOWHA0B4ydOmDHfLANSiIQERd4BTgV2Aw8C5ytqqsK1vkssFBVPy0iZwHvV9UPd7XdYiaCIIxYvWUbf1+/ng11OwjCiIlV1Rw5ZzZHzp5BVTdVIP3R+u2no29i7dfb2Zzhla21rNuxje2NjajC2BEjmDtpMvMnT2Bc1b4NpQ3ZHH9Z/RKPvvYiTWE95RURGoE44PuCF1Vy8PiZHDv7ICZUjeSlN2p44MUV+GU7iULItHjkCClz42+Oqkom9AFIqVJeETKiUggjcB1oaYGdOyLK3AqqqtI4HoSqCMQNj5GQy0Vk83lEAhTBwaM8laai0sMnIBPkyQUBgYaEUVzd0coVIe2mKHM9KlNljE5XUt7Pm71Mz4RRSHOQp9nP0uznyAR5gigEkbg6LR1XwaW6aNBu9rNsadpFLvQpdzwiyZJKgR9ANhvR3Ay5nBBFIE5I9SiXsaOEqgqHETKaw6bMZu7EyUQasrauhlXbN9AStFC/W9i2M6QpE+K5woTRLhPGupSllZkjp3H4lDlMqhpNXXMzKzZt4LWdm9BUjvrGiIYGJZdTXBeqqoRxox2cKMUxUw/no8ccR6oPM9O115LLc9MTT/Hs5peJ0hnKyxQRyGQFyZexZMpczj/xrVSV978Lb3uDlQiOA65Q1Xclv18GoKrfKVjnz8k6T4mIB2wFJmgXQfUnETRks1z/yN9YWfM66uYIo4hIQsSJSJcplWW0jeveUSNjNqdkchCFApGD4CTLFVovU6Ls/VUqeb22PlYQRRzF85R0CtKpfRsz/UAJQoiipIFUwHMh5dHt2PNhpPhB/FoRSHvguvFrMjklk1NyvhRsVylPC+VpSHl7th2ESlMG8jmHlJMiJR4Oe+871BCfAD8KUFEcIf5Gmfy9cTWDixs3YyZHJiIEIg0JtfB4Ca4QpwRxcHBxksbP1n/mzSXQkLz6+BqyTxGkA54LFWXxOeM58WfND+LPddan08+I4ygjyoWyVPwZV43Pkawfj9qqUfxZbT2fw0hRUUaUQ3VlfH7mfSWbhzDYc+7EDfTx/wCqAgqqcXVWFMXnu+NGlJdDebrgPMzHsUN8XpenobIsXp7NK5kMaOgiuDhRipkjJ/PJt72FWWP7dvPfYA0xMQ3YVPD7ZuCYztZR1UBEdgPjgB2FK4nIhcCFya9NIvJyXwJKVVWNKx8zenZZmk6rAlobIwGyDc2UjxwB0vn6A6Uw9/VkEpXOUmX84dz39V29prfajovZhx2bjg3149LZedVbHZ2H7Y9NZ/vK5pUrmzN12bq6DX3c/azOFgyJTryqeh1w3f7er4gsa6zdaXe9tGPHpXN2bDpmx6VzpXBsitkZ/A2gsCvA9OS5DtdJqoZGETcaG2OM2U+KmQieBeaKyBwRSQNnAfe1W+c+4Nzk8QeBh7pqHzDGGDPwilY1lNT5Xwz8mbj76C9V9SUR+SawTFXvA24AbhaR14CdxMmilOz36qghwo5L5+zYdMyOS+cG/dgMuRvKjDHGDCybKsgYY4Y5SwTGGDPMWSIoICL/IiIviUgkIp125xKR00TkZRF5TUQu3Z8xDgYRGSsiD4rIq8n/+w4pGa8XisiK5Kd9x4A3je7efxEpE5E7k+V/F5HZgxDmoOjBsTlPRGoLPiefHIw49zcR+aWIbBeRFztZLiJydXLcXhCRI/ZnfJYI9vYi8M/AY52tkAyd8RPg3cAC4GwRWbB/whs0lwJ/VdW5wF+T3zuSUdXFyc+Z+y+8/aeH7/8ngF2qehDwI+B7+zfKwdGLc+POgs/J9fs1yMHzK+C0Lpa/G5ib/FwI/HQ/xNTGEkEBVV2tqt3dtXw08JqqrlPVPHAH8L7iRzeo3gfcmDy+EfinwQtl0PXk/S88XncBb5fhMQzmcDw3ekRVHyPuGdmZ9wE3aexpYLSITNk/0Vki6IuOhs54s8/EPUlVa5LHW4FJnaxXLiLLRORpEfmn/RPafteT93+voVOA1qFT3ux6em58IKn+uEtE9h1/enga1OvKkBhiYiCJyF+AyR0sulxVf7e/4ykVXR2Xwl9UVUWksz7Hs1T1DRE5AHhIRFaq6tqBjtUMafcDt6tqTkQ+RVxyOmWQYxr2hl0iUNV39HMTPRk6Y8jp6riIyDYRmaKqNUlxdXsn23gj+X+diDwCLAHebImgN0OnbB5mQ6d0e2xUtfA4XA98fz/ENRQM6nXFqoZ6rydDZ7zZFA4Fci6wT8lJRMYkEw0hIuOB44FV7dd7E7ChUzrX7bFpV+99JrB6P8ZXyu4DPp70HjoW2F1QHVt88bCo9pOcp+8nrpvLAduAPyfPTwUeKFjvdOJJd9YSVykNeuxFPi7jiHsLvQr8BRibPL+UeOY5gLcAK4Hnk/8/MdhxF/F47PP+A98EzkwelwO/AV4DngEOGOyYS+jYfAd4KfmcPAzMH+yY99NxuR2oAfzkGvMJ4NPAp5PlQtzjam1y/izdn/HZEBPGGDPMWdWQMcYMc5YIjDFmmLNEYIwxw5wlAmOMGeYsERhjzDBnicAY9ho59UUR+Y2IVHax7nkicm0vt79URK5OHp8sIm/pb8zGDBRLBMbEWkdOPQzIE/fxHhAi4qnqMlX9fPLUycT3XRhTEiwRGLOvx4GDknkY7k0GSHtaRBa2X1FE3pvMOfAPEfmLiExKnr9CRG4Wkb8Rz8t9soj8Ppmb4NPAF5MSyAkisl5EUsnrRhb+bsz+YInAmALJ2EDvJr678xvAP1R1IfBV4KYOXvIEcKyqLiEedvk/CpYtAN6hqme3PqGqG4CfAT9KSiCPA48A70lWOQu4R1X9gfy7jOnKsBt0zphOVIjIiuTx48ANwN+BDwCo6kMiMk5ERrZ73XTgzmQMnTSwvmDZfaqa6cG+rydOIPcC5wMX9PWPMKYvLBEYE8uo6uLCJ3o4l8w1wA9V9T4RORm4omBZc082oKp/E5HZyetdVe1wOkNjisWqhozp3OPARyHu6QPsUNWGduuMYs9wwefSM41AdbvnbgJuA/63L4Ea0x+WCIzp3BXAkSLyAvBdOr7QXwH8RkSWAzt6uN37gfe3NhYnz90KjCEepdKY/cpGHzWmBIjIB4H3qeo5gx2LGX6sjcCYQSYi1xD3VDp9sGMxw5OVCIwxZpizNgJjjBnmLBEYY8wwZ4nAGGOGOUsExhgzzFkiMMaYYe7/B8SSEVRFM7irAAAAAElFTkSuQmCC",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Polarity Distribution\r\n",
    "sentiment_distribution = sns.kdeplot(data=news_headlines, x='name_sentiment', hue='news_outlet', fill=True, palette='crest')\r\n",
    "sentiment_distribution.set(xlabel='Polarity', title='Polarity Distribution of All Outlet News Headlines')\r\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "subjectivity_distribution = sns.kdeplot(data=news_headlines, x='name_subjectivity', hue='news_outlet', fill=True, palette='crest')\r\n",
    "subjectivity_distribution.set(xlabel='Subjectivity', title='Subjectivity Distribution of All Outlet News Headlines')\r\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "             name_sentiment  name_subjectivity\n",
      "news_outlet                                   \n",
      "ABC                0.040479           0.257900\n",
      "BBC                0.037401           0.215839\n",
      "CBS                0.036024           0.282539\n",
      "CNN                0.046376           0.261577\n"
     ]
    }
   ],
   "source": [
    "# Get average of sentiment/subjectivity by news_outlet\r\n",
    "news_outlet_avg_sentiment = news_headlines.groupby(by='news_outlet')[['name_sentiment', 'name_subjectivity']].mean()\r\n",
    "print(news_outlet_avg_sentiment)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYgAAAEWCAYAAAB8LwAVAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8rg+JYAAAACXBIWXMAAAsTAAALEwEAmpwYAAAy0klEQVR4nO3deXxV1bn/8c/XEAjKpIgiBCEOrYBCkIB1wBErKmJt61S1aqtWK716HaqWey21VqvYW4f251iVah2p81BaZ6nVCgqIgAOIgqCCFkWZw/P7Y+/gIZwkhyQnCcn3/XqdF2evvfY+z0rCfs5ea++1FRGYmZlVtkljB2BmZk2TE4SZmWXlBGFmZlk5QZiZWVZOEGZmlpUThJmZZeUEYRtE0g2S/rex42gpJI2WdGdjx7ExkfScpFMaO47mwAmiGZC0l6SXJH0u6TNJ/5Q0qB72e5KkCZllEXF6RPy6rvuuRSw5HyjTA8R/JLXJd1wbE0lzJH0iabOMslMkPdeIMfWR9Ej6t7tE0rOS9tiA7euUQCWFpB1qu31z5wSxkZPUAXgMuA7YAugO/ApY0ZhxNRZJvYAhQAAj8rD/VvW9zwZWAJzV2EEASNoe+CfwBlACdAMeBP4uaffGjM1SEeHXRvwCyoDFNdT5ETAD+A8wHuiZsS6A04F3gMXAHwEBvYHlQDnwZcVnALcDl6bv9wXmAT8HPgEWAN8BDgHeBj4DfpHxWZsAFwKzgE+B+4At0nW90lhOBD4AFgGj0nXDgJXAqjSWKdW09WKSg87/AY+lZW3Stu2cUa8LsAzYKl0eDkxO670E9MuoOwe4AJhKknhbZbRjCTAdOCKjfgHwu7QN7wEj07a1Std3BP6U/rw+BC4FCqpoz2hgHHBv+lmvAf3TdecDf61U/1rgmir2NSeN+zOgU1p2CvBcRp2dgH+kdd4CjkrLS9KfzSbp8s3AJxnb3QGcnb4/CZidxvsecFwV8dwBPJGl/Hrghcy/sSztGFrV3wXwHHBKTX//wAvp7+WrdPujG/v/c1N7NXoAftXxFwgdSA62Y4GDgc0rrT8ceJfkgN8K+B/gpYz1QXIG0gnYFlgIDEvXnQRMqLS/21k3QawmOSgXAqem298FtAf6khyES9L6ZwEvA8UkB+0bgbvTdb3SWG4G2gL9SQ7GvdP1o4E7c/h5vAv8FBiYHji2TstvBX6TUe9M4G/p+wEkCW43koP7ielBqE26fg5J8ugBtE3LjiT5xrsJcHR6kNkmXXc6SdIoBjYHnmLdBPFg2vbNgK2AfwM/qaI9o9N2fD/9GZ9HctAtBLZJP7dTWrdV2o6BVexrDsmB9YGM3+HaBJHGMxc4Od3XAJIk1ydd/0HFvkmSx+yM388Haf3NgC+Ab6bl2wB9q4jnI+DkLOX7kXwxaUs1CaKqvwsyEgS5/f3v0Nj/j5vqy11MG7mI+ALYi68PrgvTPt2t0yqnA5dHxIyIWA1cBpRK6pmxm99GxOKI+AB4FijdgBBWkRx4VwH3AFuSfINdEhFvkhwo+2fEMioi5kXECpL/3N+v1G3zq4hYFhFTgCkZ29ZI0l5AT+C+iJhE8g3/B+nqu4BjMqr/IC0DOA24MSJeiYjyiBhLkpy+lVH/2oiYGxHLACLi/oiYHxFrIuJekjOwwWndo9KfwbyI+A/w24wYtyY5wzo7Ir6KiE+A31eKrbJJETEu/Rn/H1AEfCsiFpB8Cz4yrTcMWJS2vToXAz+T1KVS+XBgTkTcFhGrI+J14K8Z+38e2EdS13R5XLpcQvJFZUpavgbYWVLbiFiQ/h1ksyXJWVRlC0gS7xY1tCMXufz9WxWcIJqB9I//pIgoBnYm+WZ7dbq6J3CNpMWSFpN0HYhkrKLCRxnvlwLtNuDjP42I8vT9svTfjzPWL8vYX0/gwYxYZpB8U9w6o35dYjkR+HtELEqX70rLIEl8m0raLR2nKCX5Jl8R17kVcaWx9SD5OVaYm/lBkn4oaXJG/Z1JDnik282tYtueJN/+F2RseyPJmURV1m4fEWtIuvUqYhsLHJ++P56k26ZaETGN5KzxwkqregK7Vfo5HAdUJITnSb7R702SmJ4D9klfL6bJ8iuSM6rT0zY+LmmnKkJZRHKGUdk2JEnmPzW1JQe5/P1bFTb2ATerJCJmSrod+ElaNJfkG/5farO7egvs61h+FBH/rLwiPWjXOhZJbUm+uRdIqkgybYBOkvpHxBRJ9wHHkiSwxyJiSUZcv4mI3+Ty+em3z5uBA4B/RUS5pMkkBx5IvgEXZ2zbI+P9XJKzky3Tb7S5WLu9pE3Sfc9Pix4Crpe0M8kZwM9z3OcvScYzflcptucj4sAqtnkeGEOSoJ4HJgA3kIxVPV9RKSLGA+PT38mlJD+rIVn29xTJ2cltlcqPIvm5LpX0FbBpxQpJBSTjR2s/rvpm1unvv8XzGcRGTtJOks6VVJwu9yA5CL6cVrkBuEhS33R9R0lHZt/bej4GiiW1rqdwbwB+U3F6L6mLpMM3IJZe6QEym++QnI30ITk7KCXpd34R+GFa5y6Sb7fH8XX3EiQHsNPTswtJ2kzSoZLaV/FZm5EcmBam7TiZ5Ayiwn3AWZK6S+pEMsANQNot9Hfgd5I6SNpE0vaS9qmm7QMlfTftijubJMG8nO5vOUlXz13Av9NuwhpFxLskA9//lVH8GPANSSdIKkxfgyT1Trd5h+SM8HiSRPIFye/le6QJQtLWkg5PL6VdQTL4u6aKMH4F7CHpN5K2kNRe0s9Ifl8VP7O3gaL091FIMoaQeflyTX8XNf39fwxsV+0PqwVzgtj4LSEZXH0l/bb1MjANOBcgIh4ErgDukfRFuu7gHPf9DPAm8JGkRTVVzsE1wCMklzEuSWPdLcdt70///VTSa1nWnwjcFhEfRMRHFS/gD8BxklpFxCskg7rdgCcrNoyIiSQD7H8g6dZ4l2SAPquImE7yzftfJAeYXUiunKpwM0kSmAq8DjxBMphf0RX3Q6A1yfjMf0gO8Nm6Wio8TJLY/gOcAHw3HY+oMDaNocbupUouIUl2Fe1aAnybZDxkPkl33xWse0B+nqRbcW7GskjORiA5ppyTbv8ZSffTGdk+PE04e5GMM80hOfP6HnBQxVlmRHxOctHBLSRXfH1FcgZTodq/ixz+/kcDY9MuqKOyxdmSKaK+exHMLJOkg4EbIiIvA6OStgVmAl3Tb/Vm9cJnEGb1TFJbSYdIaiWpO0l//4M1bVfLz6r4xn6Pk4PVN59BmNUzSZuSdL3sRNJn/zhwVn0fwNN+/o+B90nuXZlbwyZmG8QJwszMsnIXk5mZZdVs7oPYcssto1evXo0dhpnZRmXSpEmLIqLyXfVAM0oQvXr1YuLEiY0dhpnZRkXS+1WtcxeTmZll5QRhZmZZOUGYmVlWThBmZpaVE4SZmWXVbK5iqo1lq5Yx8z8zmfP5HLYo2oLenXuz1abVTctvZtZytOgE8Y/3/8Gof45auzyk+xB+veev6dy2cyNGZWbWNLTYLqYFXy7gilevWKfsxQ9f5O3/vN1IEZmZNS0tNkEsW72ML1auP3fakpVLstQ2M2t5WmyC6LpZV/bqvtc6ZYWbFFLSsaSRIjIza1pabILYtHBTfj7o5xzc62BaqRU7dtqR64dezw6ddmjs0MzMmoRmM913WVlZ1GYuphWrV/DZ8s/YtHBTOrbpmIfIzMyaLkmTIqIs27oWfRUTQJtWbdimXXWPAzYza5ny2sUkaZiktyS9K+nCLOvPkTRd0lRJT0vqmbHuSklvSpoh6VpJymesZma2rrwlCEkFwB+Bg4E+wLGS+lSq9jpQFhH9gHHAlem2ewB7Av2AnYFBwD75itXMzNaXzzOIwcC7ETE7IlYC9wCHZ1aIiGcjYmm6+DJQXLEKKAJaA22AQpJn75qZWQPJZ4LoDmQ+RH1eWlaVHwNPAkTEv4BngQXpa3xEzKi8gaTTJE2UNHHhwoX1FriZmTWRy1wlHQ+UAWPS5R2A3iRnFN2B/SUNqbxdRNwUEWURUdalS9Yn5pmZWS3lM0F8CPTIWC5Oy9YhaSgwChgRESvS4iOAlyPiy4j4kuTMYvc8xmpmZpXkM0G8CuwoqURSa+AY4JHMCpIGADeSJIdPMlZ9AOwjqZWkQpIB6vW6mMzMLH/yliAiYjUwEhhPcnC/LyLelHSJpBFptTFAO+B+SZMlVSSQccAs4A1gCjAlIh7NV6xmZra+Fn8ntZlZS1bdndRNYpDazMyaHicIMzPLygnCzMyycoIwM7OsnCDMzCwrJwgzM8vKCcLMzLJygjAzs6ycIMzMLCsnCDMzy8oJwszMsnKCMDOzrJwgzMwsKycIMzPLygnCzMyycoIwM7OsnCDMzCwrJwgzM8vKCcLMzLJygjAzs6zymiAkDZP0lqR3JV2YZf05kqZLmirpaUk90/L9JE3OeC2X9J18xmpmZuvKW4KQVAD8ETgY6AMcK6lPpWqvA2UR0Q8YB1wJEBHPRkRpRJQC+wNLgb/nK1YzM1tfPs8gBgPvRsTsiFgJ3AMcnlkhTQRL08WXgeIs+/k+8GRGPTMzawD5TBDdgbkZy/PSsqr8GHgyS/kxwN3ZNpB0mqSJkiYuXLiw1oGamdn6msQgtaTjgTJgTKXybYBdgPHZtouImyKiLCLKunTpkv9AzcxakFZ53PeHQI+M5eK0bB2ShgKjgH0iYkWl1UcBD0bEqrxFaWZmWeXzDOJVYEdJJZJak3QVPZJZQdIA4EZgRER8kmUfx1JF95KZmeVX3hJERKwGRpJ0D80A7ouINyVdImlEWm0M0A64P72cdW0CkdSL5Azk+XzFaGZmVctnFxMR8QTwRKWyizPeD61m2zlUP6htZmZ51CQGqc3MrOlxgjAzs6ycIMzMLCsnCDMzy8oJwszMsnKCMDOzrHJKEJLaSvpmvoMxM7Omo8YEIekwYDLwt3S5NPOGNjMza55yOYMYTTJ192KAiJgMlOQtIjMzaxJySRCrIuLzSmWRj2DMzKzpyGWqjTcl/QAokLQj8F/AS/kNy8zMGlsuZxA/A/oCK0hmVv0CODuPMZmZWRNQ4xlE+qjPUenLzMxaiBoThKRHWX/M4XNgInBjRCzPR2BmZta4culimg18Cdycvr4AlgDfSJfNzKwZymWQeo+IGJSx/KikVyNikKQ38xWYmZk1rlwSRDtJ20bEBwCStiV5ChzAyrxFZmZm1Vr10UeseOcdYs0ainbYgcLu9fuMtVwSxLnABEmzAJHcJPdTSZsBY+s1GjMzy8mK2bOZe+ZIVr33HgCtunalx803UbTjjvX2GblcxfREev/DTmnRWxkD01fXWyRmZpazJc88szY5AKz+6CM+f/hhis47r94+I9dnUu8IfBMoAvpLIiL+XG9RmJnZBlk+9Y31ypZNeo0oL0cFBfXyGblM1vdL4Lr0tR9wJTCiXj7dzMxqpd0B+69X1uGw4fWWHCC3y1y/DxwAfBQRJwP9gY657FzSMElvSXpX0oVZ1p8jabqkqZKeltQzY922kv4uaUZap1duTTIza/4222MPNj/pRGjVCjbZhI5HHUn7/far18/IpYtpWUSskbRaUgfgE6BHTRtJKgD+CBwIzANelfRIREzPqPY6UBYRSyWdQXJ2cnS67s/AbyLiH5LaAWtyb5aZWfNW2KULW597LpsfdRREUFhczCZt2tTrZ+SSICZK6kRyU9wkkpvm/pXDdoOBdyNiNoCke4DDgbUJIiKezaj/MnB8WrcP0Coi/pHW+zKHzzMza1FUWEib7bbL2/6rTRCSBFweEYuBGyT9DegQEVNz2Hd3YG7G8jxgt2rq/xh4Mn3/DWCxpAdILqt9CrgwIsorxXcacBrAtttum0NIZmaWq2rHICIigCcylufkmBw2iKTjgTJgTFrUChgCnAcMArYDTsoS300RURYRZV26dKnvsMzMWrRcBqlfkzSo5mrr+ZB1xyqK07J1SBpKMlPsiIhYkRbPAyZHxOyIWA08BOxaixjMzKyWchmD2A04TtL7wFckd1NHRPSrYbtXgR0llZAkhmOAH2RWkDQAuBEYFhGfVNq2k6QuEbEQ2J9k9lizvFi2ajXT53/Be4uWsmW71uzcrSNbtq/fAT+zjU0uCeKg2uw4IlZLGgmMBwqAWyPiTUmXABMj4hGSLqV2wP3JcAcfRMSIiCiXdB7wdDoOMgnPHGt59NiUBZw/7uve00N36cql39mZzTdzkrCWS8kwQw2VpL2AHSPiNkldgHYR8V5N2zWksrKymDjRJxm24eZ+tpRDrnmRJStWr1N+z6m78a3tt2ykqMwahqRJEVGWbV2ud1JfAFyUFhUCd9ZfeGaNa+nK8vWSA8Dny1c1QjRmTUcug9RHkEyt8RVARMwH2uczKLOG1K1TEYN6bbFOWZtWm7Ddlu2q2MKsZcglQaxML3cNgHSab7Nmo31RIZcdsTNDe2+FBDtstRm3nzyIHbZygrCWLZdB6vsk3UhyVdGpwI/wgLE1Mztu3Z7rjt2VRV+uoH1RKzpt2rqxQzJrdLk8D+IqSQeSPIv6m8DFFVNgmDUnbVsX0GOLTRs7DLMmo8YEIekc4F4nBTOzliWXMYj2wN8lvShppKSt8x2UmZk1vhoTRET8KiL6AmcC2wDPS3oq75GZmVmjyuUMosInwEfAp8BW+QnHzMyailxulPuppOeAp4HOwKk5zMNkZmYbuVwuc+0BnB0RkwEkFUk6MiLuz2tkZmbWqHIZg7gIeEPSIZLuAN7n68eCmplZM1XTE+X2IZmi+xDg38CeQElELG2A2MzMrBFVmSAkzQM+AK4HzouIJZLec3IwM2sZqutiGgd0I+lOOiydg6nmucHNzKxZqDJBRMTZQAnwO2Bf4C2gi6SjJHkWMzOzZq7aQepIPBsRp5Eki2OBw4E5DRCbmZk1olwucwUgIlYBjwGPSWqbv5DMzKwp2JA7qdeKiGX1HYiZmTUttUoQZmbW/OUy1cYuDRGImZk1LbmcQfw/Sf9O52TquCE7lzRM0luS3pV0YZb150iaLmmqpKcl9cxYVy5pcvp6ZEM+18zM6i6XqTaGAMeRzMk0SdJd6RPmqiWpAPgjcDDQBzhWUp9K1V4HytLJ/8YBV2asWxYRpelrRG7NMTOz+pLTGEREvAP8D3ABsA9wraSZkr5bzWaDgXcjYnZErATuIblENnO/z2bcmf0yULyhDTAzs/zIZQyin6TfAzOA/YHDIqJ3+v731WzaHZibsTwvLavKj4EnM5aLJE2U9LKk71QR22lpnYkLFy6sqSlmZrYBcrkP4jrgFuAXmZe3RsR8Sf9TH0FIOh4oIzk7qdAzIj6UtB3wjKQ3ImJW5nYRcRNwE0BZWZmnATEzq0e5dDE9GBF3ZCYHSWcBRMQd1Wz3Icm4RYXitGwdkoYCo4AREbGiojwiPkz/nQ08BwzIIVYzM6snuSSIH2YpOymH7V4FdpRUIqk1cAywztVIkgYAN5Ikh08yyjeX1CZ9vyXJNOPTc/hMMzOrJ9VN930sybMgSipdZtoe+KymHUfEakkjgfFAAXBrRLwp6RJgYkQ8AowB2gH3SwL4IL1iqTdwo6Q1JEnstxHhBGFm1oCqG4N4CVgAbEkyo2uFJcDUXHYeEU8AT1Qquzjj/dAqtnsJ8A16ZmaNqMoEERHvkzxedPeGC8fMzJqK6rqYJkTEXpKWsO6DgkQyE3iHvEdnZmaNproziL3Sf9s3XDhmZtZU5HKj3LWS3M1kZtbC5HKZ6yTgfyXNknSVpLJ8B2VmZo0vl8n6xkbEIcAgkudSXyHpnbxHZmZmjWpDHhi0A7AT0BOYmZ9wzMysqchlDOLK9IzhEmAayfTch+U9MjMza1S5TNY3C9g9IhblOxgzM2s6qrsPYqeImEkyp9K2krbNXB8Rr+U7ODMzazzVnUGcA5zGutNsVAiS50GYmVkzVd2Ncqelbw+OiOWZ6yQV5TUqMzNrdLlcxfRSjmVmZtaMVDcG0ZXkEaFt0+c2KF3VAdi0AWIzM7NGVN0YxEEkDwYqJhmHqEgQXwC/yG9YZmbW2KobgxgLjJX0vYj4awPGZGZmTUAuYxADJXWqWEgfB3pp/kIyM7OmIJcEcXBELK5YiIj/AIfkLSIzM2sSckkQBZLaVCxIagu0qaa+mZk1A7lMtfEX4GlJt6XLJwNj8xeSmZk1BblM930FcCnQO339OiKuzGXnkoZJekvSu5IuzLL+HEnTJU2V9LSknpXWd5A0T9IfcmuOmZnVl1zOIABmAKsj4ilJm0pqHxFLqttAUgHwR+BAYB7wqqRHImJ6RrXXSWaHXSrpDOBK4OiM9b8GXsi1MWZmmVatWsW8efNYvnx5zZWbuaKiIoqLiyksLMx5mxoThKRTSeZk2gLYnuTmuRuAA2rYdDDwbkTMTvdzD3A4sDZBRMSzGfVfBo7P+NyBwNbA3wA/xc7MNti8efNo3749vXr1QlLNGzRTEcGnn37KvHnzKCkpyXm7XAapzwT2JLlBjoh4B9gqh+26A3MzluelZVX5MfAkgKRNSG7OO6+6D5B0mqSJkiYuXLgwh5DMrCVZvnw5nTt3btHJAUASnTt33uAzqVwSxIqIWJnxQa1IZnOtN5KOJzlLGJMW/RR4IiLmVbddRNwUEWURUdalS5f6DMnMmomWnhwq1ObnkMsYxPOSfkEyJ9OBJAfvR3PY7kOgR8ZycVq2DklDgVHAPhGxIi3eHRgi6adAO6C1pC8jYr2BbjMzy49cEsSFJN0/bwA/AZ4Abslhu1eBHSWVkCSGY4AfZFZIJwG8ERgWEZ9UlEfEcRl1TiIZyHZyMDNrQLlc5romIm6OiCMj4vvp+xq7mCJiNTASGE9yFdR9EfGmpEskjUirjSE5Q7hf0mRJj9ShLWZmzcrVV1/N0qVL1y736tWLRYuqf/rzZZddVm+fr6qO9ZLui4ijJL3B+mMOAXwGXB0RD9dbNHVQVlYWEydObOwwzKwJmTFjBr17927sMGqtV69eTJw4kS233DLrcjbt2rXjyy+/zLou289D0qSIyHqlaHVnEGel/w4HDqv0GkFyhdEV1WxvZtbkzJkzh969e3PqqafSt29fvv3tb7Ns2TJmzZrFsGHDGDhwIEOGDGHmzJmUl5dTUlJCRLB48WIKCgp44YXk1qy9996bd955h+eff57S0lJKS0sZMGAAS5Zkv0UsIjj//PPZeeed2WWXXbj33nsBeO655xg+fPjaeiNHjuT222/n2muvZf78+ey3337st99+6+3vzjvvZPDgwZSWlvKTn/yE8vJyLrzwQpYtW0ZpaSnHHXfcettssIio8QV0JUkKhwFdM8oH5rJ9Q7wGDhwYZmaZpk+fvl7Ze++9FwUFBfH6669HRMSRRx4Zd9xxR+y///7x9ttvR0TEyy+/HPvtt19ERBx00EExbdq0ePTRR6OsrCwuvfTSWL58efTq1SsiIoYPHx4TJkyIiIglS5bEqlWrssYybty4GDp0aKxevTo++uij6NGjR8yfPz+effbZOPTQQ9fWO/PMM+O2226LiIiePXvGwoUL166rWJ4+fXoMHz48Vq5cGRERZ5xxRowdOzYiIjbbbLMN+nkAE6OK42ouN8qdAlwMPEPy0KDrJF0SEbdGxKS6pygzs4ZVUlJCaWkpAAMHDmTOnDm89NJLHHnkkWvrrFiRXFQ5ZMgQXnjhBd577z0uuugibr75ZvbZZx8GDRoEwJ577sk555zDcccdx3e/+12Ki4uzfuaECRM49thjKSgoYOutt2afffbh1VdfpUOHDhsc/9NPP82kSZPWxrBs2TK22iqX29M2TC5XMZ0PDIiITwEkdSZ5JvWt9R6NmVkDaNPm6wmpCwoK+Pjjj+nUqROTJ09er+7ee+/N9ddfz/z587nkkksYM2YMzz33HEOGDAHgwgsv5NBDD+WJJ55gzz33ZPz48ey00045x9KqVSvWrFmzdjmXm9kighNPPJHLL78858+pjVxulPsUyOxUW5KWmZk1Cx06dKCkpIT7778fSA7AU6ZMAWDw4MG89NJLbLLJJhQVFVFaWsqNN97I3nvvDcCsWbPYZZdduOCCCxg0aBAzZ87M+hlDhgzh3nvvpby8nIULF/LCCy8wePBgevbsyfTp01mxYgWLFy/m6aefXrtN+/bts45pHHDAAYwbN45PPknuDvjss894//33ASgsLGTVqlX18nOpMkGkM62eA7wLvCJptKRfksyZ9Ha9fLqZWRPxl7/8hT/96U/079+fvn378vDDyQWabdq0oUePHnzrW98CkgP9kiVL2GWXXYDkUtSdd96Zfv36UVhYyMEHH5x1/0cccQT9+vWjf//+7L///lx55ZV07dqVHj16cNRRR7Hzzjtz1FFHMWDAgLXbnHbaaQwbNmy9Qeo+ffpw6aWX8u1vf5t+/fpx4IEHsmDBgrXb9OvXr14Gqau7zPWX1W0YEb+q86fXI1/mamaVbeyXuda3Db3MtcoxiKaWAMzMrGHlchXTs2SZnC8i9s9LRGZmG7E33niDE044YZ2yNm3a8MorrzRSRLWXy1VMmVNuFwHfA1bnJxwzs43bLrvskvVqqI1RjQkiy70O/5T07zzFY2ZmTUQuXUxbZCxuAgwEOuYtIjMzaxJy6WKaRDIGIZKupfdIpv82M7NmLJfpvksiYrv03x0j4tsRMaEhgjMza64eeughJK29sW7OnDm0bduW0tJS+vfvzx577MFbb721tv6TTz5JWVkZffr0YcCAAZx77rl5j7G6G+UGSeqasfxDSQ9LurZSt5OZWbP10Osfsudvn6HkwsfZ87fP8NDr6z0Ys1buvvtu9tprL+6+++61Zdtvvz2TJ09mypQpnHjiiWuf7TBt2jRGjhzJnXfeyfTp05k4cSI77LBDvcRRnerOIG4EVgJI2hv4LfBn4HPgprxHZmbWyB56/UMueuANPly8jAA+XLyMix54o85J4ssvv2TChAn86U9/4p577sla54svvmDzzTcH4Morr2TUqFFr53gqKCjgjDPOqFMMuahuDKIgIj5L3x8N3BQRfwX+Kmly3iMzM2tkY8a/xbJV5euULVtVzpjxb/GdAd1rvd+HH36YYcOG8Y1vfIPOnTszadIkOnfuzKxZsygtLWXJkiUsXbp07b0T06ZNa5AupcqqO4MokFSRQA4gme67Qi6D22ZmG7X5i5dtUHmu7r77bo455hgAjjnmmLXdTBVdTLNmzeLqq6/mtNNOq9Pn1FV1B/q7geclLQKWAS8CSNqBpJvJzKxZ69apLR9mSQbdOrWt9T4/++wznnnmGd544w0kUV5ejiTOPPPMdeqNGDGCk08+GYC+ffsyadIk+vfvX+vPrY0qzyAi4jfAucDtwF7x9ax+mwA/y39oZmaN6/yDvknbwoJ1ytoWFnD+Qd+s9T7HjRvHCSecwPvvv8+cOXOYO3cuJSUlzJ07d516EyZMYPvtt0/iOP98LrvsMt5+O5lIe82aNdxwww21jiFX1XYVRcTLWco81beZtQgV4wxjxr/F/MXL6NapLecf9M06jT/cfffdXHDBBeuUfe973+Pyyy9fOwYREbRu3ZpbbrkFgH79+nH11Vdz7LHHsnTpUiSt8xzrfKlyuu962bk0DLgGKABuiYjfVlp/DnAKyQ14C4EfRcT7knoCD5KcrRQC10VEtenS032bWWWe7ntdGzrddy5PlKsVSQXAH4GDgT7AsZL6VKr2OlAWEf2AccCVafkCYPeIKAV2Ay6U1C1fsZqZ2fryliCAwcC7ETE7IlYC9wCHZ1aIiGcjYmm6+DJQnJavjIgVaXmbPMdpZmZZ5PPA2x3IHHWZl5ZV5cfAkxULknpImpru44qImF95A0mnSZooaeLChQvrKWwzM4Mm8s1c0vFAGTCmoiwi5qZdTzsAJ0rauvJ2EXFTRJRFRFmXLl0aLmAzsxYgnwniQ6BHxnJxWrYOSUOBUcCIjG6ltdIzh2nAkDzFaWZmWeQzQbwK7CipRFJr4BjgkcwKkgaQzPk0IiI+ySgvltQ2fb85sBfwFmZm1mDyliAiYjUwEhgPzADui4g3JV0iaURabQzQDrhf0mRJFQmkN/CKpCnA88BVEfFGvmI1M2tIBQUFa6f13nXXXXnppZeApjfld17nVIqIJ4AnKpVdnPF+aBXb/QPol8/YzMxyMvU+ePoS+HwedCyGAy6GfkfVaZdt27Zd+9zq8ePHc9FFF/H8888DX8/HBHDjjTdy2WWXMXbs2LVTfj/++OPstNNOlJeXc9NN+Z1Y25PumZlVZep98Oh/wap0PqbP5ybLUOckUSFzWu/q1jXGlN9OEGZmVXn6kq+TQ4VVy5LyOiSIZcuWUVpayvLly1mwYAHPPPP1ZNlNacrvJnGZq5lZk/T5vA0rz1FFF9PMmTP529/+xg9/+EMqpj1qSlN+O0GYmVWlY/GGldfC7rvvzqJFi8h2s++IESN44YUXgK+n/G5IThBmZlU54GIorPTsh8K2SXk9mTlzJuXl5XTu3Hm9dY095bfHIMzMqlIxzlDPVzFVjEEARARjx46loCB57kRTmvLbCcLMrDr9jqq3K5YqlJeXZy3v1asXy5ZV/TjT4cOHN8hzICq4i8nMzLJygjAzs6ycIMzMLCsnCDMzy8oJwszMsnKCMDOzrJwgzMwawUcffcQxxxzD9ttvz8CBAznkkEN4++23q5zu++OPP2b48OH079+fPn36cMghh+Q9Rt8HYWZWjcdnP841r13DR199RNfNunLWrmdx6HaH1mmfEcERRxzBiSeeyD333APAlClT+Pjjj6uc7vviiy/mwAMP5KyzzgJg6tSpdYohFz6DMDOrwuOzH2f0S6NZ8NUCgmDBVwsY/dJoHp/9eJ32++yzz1JYWMjpp5++tqx///706NFjnXqZ030vWLCA4uKv54Dq1y//j8zxGYSZWRWuee0alpcvX6dseflyrnntmjqdRUybNo2BAwdmXVfVdN9nnnkmRx99NH/4wx8YOnQoJ598Mt26dat1DLnwGYSZWRU++uqjDSqvD1VN933QQQcxe/ZsTj31VGbOnMmAAQOyzgBbn5wgzMyq0HWzrhtUnqtcp+7OnO4bYIsttuAHP/gBd9xxB4MGDVpnXT44QZiZVeGsXc+iqKBonbKigiLO2vWsOu13//33Z8WKFes8U3rq1KnMnTt3nXqZ030/88wzLF26FIAlS5Ywa9Ystt122zrFUZO8jkFIGgZcAxQAt0TEbyutPwc4BVgNLAR+FBHvSyoFrgc6AOXAbyLi3nzGamZWWcU4Q31fxSSJBx98kLPPPpsrrriCoqIievXqxdVXX13ldN+TJk1i5MiRtGrVijVr1nDKKacwaNCgOrex2jgrHnNX7zuWCoC3gQOBecCrwLERMT2jzn7AKxGxVNIZwL4RcbSkbwAREe9I6gZMAnpHxOKqPq+srCwmTpyYl7aY2cZpxowZ9O7du7HDaDKy/TwkTYqIsmz189nFNBh4NyJmR8RK4B7g8MwKEfFsRCxNF18GitPytyPinfT9fOAToEseYzUzs0rymSC6A5kdavPSsqr8GHiycqGkwUBrYFa9RmdmZtVqEvdBSDoeKAP2qVS+DXAHcGJErMmy3WnAaUDeB2vMzFqafJ5BfAhk3hZYnJatQ9JQYBQwIiJWZJR3AB4HRkXEy9k+ICJuioiyiCjr0sU9UGZm9SmfCeJVYEdJJZJaA8cAj2RWkDQAuJEkOXySUd4aeBD4c0SMy2OMZmZWhbwliIhYDYwExgMzgPsi4k1Jl0gakVYbA7QD7pc0WVJFAjkK2Bs4KS2fnF76amZmDSSvN8pFxBMR8Y2I2D4ifpOWXRwRj6Tvh0bE1hFRmr5GpOV3RkRhRnlpREzOZ6xmZg2pqum+JXHdddetrTdy5Ehuv/12AE466SS6d+/OihVJb/yiRYvo1atX3mL0ndRmZtX4/NFHeWf/A5jRuw/v7H8Anz/6aJ33WTHd97777susWbOYNGkSl19+OR9//DFbbbUV11xzDStXrsy6bUFBAbfeemudY8iFE4SZWRU+f/RRFvzvxayePx8iWD1/Pgv+9+I6J4nqpvvu0qULBxxwAGPHjs267dlnn83vf/97Vq9eXacYcuEEYWZWhU9+fzWxfN3pvmP5cj75/dV12m91030DXHDBBVx11VWUl5evt27bbbdlr7324o477qhTDLlwgtgYrF4Jq5bWXM/M6tXqBQs2qLy+bLfdduy2227cddddWddfdNFFjBkzhjVr1rs9rF45QTRla8phzgS493i49WCYfDcs/ayxozJrMVpts80Glecql+m+f/GLX3DFFVeQbb68HXfckdLSUu677746xVETJ4imbP7r8OfD4Z3xsGAyPHQ6zHyssaMyazG2+u+zUdG6032rqIit/vvsOu03l+m+d9ppJ/r06cOjVYx3jBo1iquuuqpOcdTECaIp++BfsKbSQNQ/r4al/2mUcMxamo6HHcY2v76EVt26gUSrbt3Y5teX0PGww+q034rpvp966im23357+vbty0UXXUTXrus+iGjUqFHMmzcv6z769u3LrrvuWqc4atIk5mKyKrQqWr+scDMo8K/NrKF0POywOieEbLp165a1i2jatGlr3/fv33+dcYaK+yEqPPDAA/UeVyafQTRlPfeAoo7rlu17EbRp3zjxmFmL4q+iTdnWfeGkx+Gdp+CrhfDNYVCc3ydImZlVcIJo6rrukrzMrFYiAkmNHUajq83TQ93FZGbNVlFREZ9++mmtDo7NSUTw6aefUlSUZVyzGj6DMLNmq7i4mHnz5rFw4cLGDqXRFRUVUVxcvEHbOEGYWbNVWFhISUlJY4ex0XIXk5mZZeUEYWZmWTlBmJlZVmouo/uSFgLv13LzLYFF9RhOU+a2Nj8tpZ3gtuZDz4jokm1Fs0kQdSFpYkSUNXYcDcFtbX5aSjvBbW1o7mIyM7OsnCDMzCwrJ4jETTVXaTbc1uanpbQT3NYG5TEIMzPLymcQZmaWlROEmZll1ewShKRhkt6S9K6kC7OsbyPp3nT9K5J6peWDJU1OX1MkHZGxTSdJ4yTNlDRD0u4N2KQq5amt/y3pTUnTJN0tacOmf8yT2rY1Y/22kr6UdF6u+2ws9d1WST0kPStpevq7PauBmlKjfPxe0/ICSa9LahIPcc/T32/+j0sR0WxeQAEwC9gOaA1MAfpUqvNT4Ib0/THAven7TYFW6fttgE8ylscCp6TvWwOdmmNbge7Ae0DbdN19wEkbc1sz1o8D7gfOy3Wfzait2wC7pu/bA28317ZmlJ8D3AU81lzb2RDHpeZ2BjEYeDciZkfESuAe4PBKdQ4n+cFC8kM/QJIiYmlErE7Li4AAkNQR2Bv4E0BErIyIxfltRk7qva2pVkBbSa1IEsn8vLUgd7VuK4Ck75Akvjc3cJ+Nod7bGhELIuK19P0SYAbJl4HGlo/fK5KKgUOBW/IX+gap93Y21HGpuSWI7sDcjOV5rP8fYW2d9CD5OdAZQNJukt4E3gBOT9eXAAuB29JT1lskbZbfZuSk3tsaER8CVwEfAAuAzyPi73ltRW5q3VZJ7YALgF/VYp+NIR9tXSvtuhgAvFJ/Iddavtp6NfBzYE09x1tb+WhngxyXmluCqJOIeCUi+gKDgIvS/vdWwK7A9RExAPgKaDL91bWVra2SNif5JlMCdAM2k3R8Y8ZZD0YDv4+ILxs7kAYwmmramh5s/gqcHRFfNGRgeTCaLG2VNBz4JCImNUpU9W802X+nDXJcam4PDPoQ6JGxXJyWZaszL+1G6Qh8mlkhImZI+hLYmSTbz4uIim9c42gaCSIfbS0B3ouIhQCSHgD2AO7MSwtyV5e27gZ8X9KVQCdgjaTlwKQc9tkY6r2tEfEHSYUkyeEvEfFAntuQq3z8XrsDIyQdQtJ92kHSnRHRmF908tHOcTTEcamxB3Dq80WS8GaTHOgqBoP6VqpzJusOBt2Xvi/h64HbniR971umyy8C30zfjwbGNMe2kvwxvkky9iCSPtGfbcxtrVRnNF8P3Na4z2bUVgF/Bq5u7Pblu62VyvelaQxS56WdDXFcalZnEBGxWtJIYDzJlQO3RsSbki4BJkbEIySDOndIehf4jOSXAbAXcKGkVSR9lz+NiIqpdn8G/EVSa5Jf9MkN16rs8tTWRZLGAa8Bq4HXaQK3+9exrRu0z7w2JAf5aCuwJ3AC8IakyWnZLyLiibw0Ikd5amuTk8d25v245Kk2zMwsKw9Sm5lZVk4QZmaWlROEmZll5QRhZmZZOUGYmVlWThDWLEgqVzI77TRJ90vatJq6J0n6wwbuv0zSten7fSXtUcs4J0u6pzbbmjU0JwhrLpZFRGlE7AysBE6vrx1LahUREyPiv9KifUnuMN/Q/fQmuQ5+SH3Mm5PecWuWN04Q1hy9COwgaQtJD0maKullSf0qV5R0WDr//uuSnpK0dVo+WtIdkv5JcgPTvpIeSye7Ox347/RsYIik99KpLJDUIXO5kmOBO4C/k87mmcbVNyOe59Kzlc0k3Srp32lsFfVPkvSIpGeApyW1k/S0pNckvVFRL637v0qeQTBBybM9Kp4Psb2kv0maJOlFSTvVxw/dmh8nCGtW0m/VB5PMUvsr4PWI6Af8gmS6icomAN+KZMKze0hmAa3QBxgaEcdWFETEHOAGkgnUSiPiReA5kumlIbkD9oGIWJXls45OP+NukmQBcC9wVBr7NsA2ETERGAU8ExGDgf2AMRlnHbsC34+IfYDlwBERsWta73dKDAK+B/RPfx5lGXHcRDKFykDgPOD/ZYnVrHlNtWEtWtuMaSReJJm64BWSgyQR8YykzpI6VNquGLg3PTi3Jpl3v8IjEbEsh8++hSSxPEQy3cGplStIKgMWRcQHkj4EbpW0BclDmf4O/JIkUYxLN/k2yaRzFU8QKwK2Td//IyI+q9g1cJmkvUmmTekObE0yvcbDEbEcWC7p0TSOdiTdY/credwAQJsc2mgtkBOENRfLIqI0syDjAFid64D/i4hHJO1LMulZha9y2UFE/FNSr3T7goiYlqXascBOkuakyx2A70XEzZI+Tbu/jubrsROl69+q1KbdKsV1HNAFGBgRq9L9V/eY2E2AxZV/VmbZuIvJmrMXSQ6gpAfvRbH+cxA68vXUyyfmuN8lJI/uzPRnkkdc3la5sqRNSM4OdomIXhHRi2QMIrOb6edAx4iYmpaNB34mrX2q2IAqYulI8vyDVZL2I5mdF+CfwGFKnvPRDhgOkLb/PUlHpvuVpP45tttaGCcIa85GAwMlTQV+S/YEMJqku2USsCjL+mweBY6oGKROy/4CbE4yvlDZEODDiMh8fOsLQJ+0a2sc6RTPGet/DRQCU5U8+e/XVcTyF6BM0hvAD4GZABHxKvAIMBV4kmRM5vN0m+OAH0uaQjK9e1N41Ko1QZ7N1aweSPo+cHhEnNDYsVSQ1C4ivkzvCXkBOC3SZ1Ob5cJjEGZ1JOk6kiuFDmnsWCq5SVIfkjGJsU4OtqF8BmFmZll5DMLMzLJygjAzs6ycIMzMLCsnCDMzy8oJwszMsvr/yhVg/KsbkDAAAAAASUVORK5CYII=",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Scatter plot of average sentiment by news_outlet\r\n",
    "sentiment_avg_scatter = sns.scatterplot(data=news_outlet_avg_sentiment, x=\"name_sentiment\", y=\"name_subjectivity\", hue=\"news_outlet\")\r\n",
    "sentiment_avg_scatter.set(xlabel='Polarity Average', ylabel='Subjectivity Average', title='Sentiment Average by News Outlet')\r\n",
    "plt.show()"
   ]
  }
 ],
 "metadata": {
  "interpreter": {
   "hash": "3f278169035c3cd7303066dacb0afc3bfc0b1393c2667d2553c33cfa2e66540a"
  },
  "kernelspec": {
   "display_name": "Python 3.9.1 32-bit",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.1"
  },
  "metadata": {
   "interpreter": {
    "hash": "3f278169035c3cd7303066dacb0afc3bfc0b1393c2667d2553c33cfa2e66540a"
   }
  },
  "orig_nbformat": 2
 },
 "nbformat": 4,
 "nbformat_minor": 2
}