Sentiment_Analysis_Model.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Sentiment_Analysis_Model.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "include_colab_link": true
    },
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/Agentum07/tomatinator/blob/main/Sentiment_Analysis_Model.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "LyKiD_uJdc5x"
      },
      "source": [
        "import tweepy\n",
        "from textblob import TextBlob\n",
        "from textblob import Word\n",
        "from wordcloud import WordCloud\n",
        "import pandas as pd\n",
        "import numpy as np\n",
        "import re \n",
        "import matplotlib.pyplot as plt\n",
        "plt.style.use('fivethirtyeight')\n",
        "from wordcloud import WordCloud,ImageColorGenerator\n",
        "from PIL import Image\n",
        "import urllib\n",
        "import requests\n",
        "import nltk"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "dakhoiIxkT8p"
      },
      "source": [
        ""
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "E5kLBqlvdyjH",
        "outputId": "670326da-7696-4a67-8077-f67867eb3914"
      },
      "source": [
        "flag = True\n",
        "lines2 = []\n",
        "while flag:\n",
        "  val = input(\"Enter the text: \")\n",
        "  lines2.append(val)\n",
        "  ans = input(\"do u want to enter another tweet y/n? \")\n",
        "  flag = ans == 'y'\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Enter the text: i had an amazing day because his sucked lol\n",
            "do u want to enter another tweet y/n? n\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 94
        },
        "id": "vXQZX_TYfHPg",
        "outputId": "7319d2ce-4834-4861-abe4-072b2215db77"
      },
      "source": [
        "#Create a dataframe with coloumn called tweet\n",
        "print(lines2)\n",
        "df = pd.DataFrame({'Tweets' : lines2})\n",
        "\n",
        "df.head()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "['i had an amazing day because his sucked lol']\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "execute_result",
          "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>Tweets</th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>0</th>\n",
              "      <td>i had an amazing day because his sucked lol</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "</div>"
            ],
            "text/plain": [
              "                                        Tweets\n",
              "0  i had an amazing day because his sucked lol"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 15
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 77
        },
        "id": "ck8T7OzOfp91",
        "outputId": "05678642-aae0-4cc2-a35b-3c89943948fb"
      },
      "source": [
        "#Clean the text\n",
        "def cleanText(text):\n",
        "  text = re.sub(r'@[A-za-z0-9]+' , '', text) #Remove mentions\n",
        "  text = re.sub(r'RT[\\s]+', '', text) #remove retweets\n",
        "  text = re.sub(r'https?:\\/\\/\\S+', '', text) #remove hyperlinks\n",
        "\n",
        "  return text \n",
        "\n",
        "#Clean the text\n",
        "df['Tweets'] = df['Tweets'].apply(cleanText)\n",
        "\n",
        "#Show the cleaned text\n",
        "df\n",
        "\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "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>Tweets</th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>0</th>\n",
              "      <td>i had an amazing day because his sucked lol</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "</div>"
            ],
            "text/plain": [
              "                                        Tweets\n",
              "0  i had an amazing day because his sucked lol"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 16
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 77
        },
        "id": "3tBVL2wpgqjw",
        "outputId": "b58b0bf8-9820-410d-abd3-c91f60f8f9ea"
      },
      "source": [
        "#Create a function to get the subjectivity\n",
        "def getSubjectivity(text):\n",
        "  return TextBlob(text).sentiment.subjectivity \n",
        "\n",
        "#Create a function to get polarity\n",
        "def getPolarity(text):\n",
        "  return TextBlob(text).sentiment.polarity\n",
        "  \n",
        "\n",
        "#Create new columns\n",
        "df['Subjectivity'] = df['Tweets'].apply(getSubjectivity)\n",
        "df['Polarity'] = df['Tweets'].apply(getPolarity)\n",
        "\n",
        "df\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "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>Tweets</th>\n",
              "      <th>Subjectivity</th>\n",
              "      <th>Polarity</th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>0</th>\n",
              "      <td>i had an amazing day because his sucked lol</td>\n",
              "      <td>0.8</td>\n",
              "      <td>0.7</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "</div>"
            ],
            "text/plain": [
              "                                        Tweets  Subjectivity  Polarity\n",
              "0  i had an amazing day because his sucked lol           0.8       0.7"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 17
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 264
        },
        "id": "ywleKlQnhIvD",
        "outputId": "62e4d6b3-d1d4-4da2-e07e-ab2f6bc31c4e"
      },
      "source": [
        "#Plot wordcloud\n",
        "allWords = ' '.join([twts for twts in df['Tweets']])\n",
        "Mask = np.array(Image.open(requests.get('http://clipart-library.com/image_gallery2/Twitter-PNG-Image.png', stream=True).raw))\n",
        "\n",
        "image_colors = ImageColorGenerator(Mask)\n",
        "wordCloud = WordCloud(width = 500, height = 300, random_state = 21, max_font_size = 110, mask = Mask).generate(allWords)\n",
        "\n",
        "plt.imshow(wordCloud.recolor(color_func=image_colors), interpolation =  \"hamming\")\n",
        "\n",
        "plt.axis('off')\n",
        "plt.show()\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": []
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 77
        },
        "id": "9yKQ-oQkh3Pt",
        "outputId": "fefa7ad5-2d32-4e8b-e568-3d1f98f40935"
      },
      "source": [
        "#Create a fn to compute the negative, neutral and positive analysis\n",
        "def getAnalysis(score):\n",
        "  if score < - 0.2:\n",
        "    return 'Negative'\n",
        "  elif score > 0.2:\n",
        "    return 'Positive'\n",
        "  else: \n",
        "    return 'Neutral'\n",
        "\n",
        "df['Analysis'] = df['Polarity'].apply(getAnalysis)\n",
        "\n",
        "df"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "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>Tweets</th>\n",
              "      <th>Subjectivity</th>\n",
              "      <th>Polarity</th>\n",
              "      <th>Analysis</th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>0</th>\n",
              "      <td>i had an amazing day because his sucked lol</td>\n",
              "      <td>0.8</td>\n",
              "      <td>0.7</td>\n",
              "      <td>Positive</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "</div>"
            ],
            "text/plain": [
              "                                        Tweets  ...  Analysis\n",
              "0  i had an amazing day because his sucked lol  ...  Positive\n",
              "\n",
              "[1 rows x 4 columns]"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 19
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "zAqbWfqMGtih",
        "outputId": "5c4f0d72-5ddb-4456-b6f0-6b3000179378"
      },
      "source": [
        "# function to get all the hashtags\n",
        "# this will help us classify the tweets\n",
        "def Hashtags_Extract(x):\n",
        "    hashtags=[]\n",
        "    # Loop over the words in the tweet\n",
        "    for i in x:\n",
        "        ht = re.findall(r'#(\\w+)',i)\n",
        "        hashtags.append(ht)\n",
        "    return hashtags\n",
        "\n",
        "\n",
        "ht_positive = Hashtags_Extract(df['Tweets'][df['Analysis'] == 'Positive'])\n",
        "ht_negative = Hashtags_Extract(df['Tweets'][df['Analysis'] == 'Negative'])\n",
        "ht_neutral = Hashtags_Extract(df['Tweets'][df['Analysis'] == 'Neutral'])\n",
        "\n",
        "ht_positive_unnest = sum(ht_positive,[])\n",
        "ht_negative_unnest = sum(ht_negative,[])\n",
        "ht_neutral_unnest = sum(ht_neutral,[])\n",
        "\n",
        "ht_neutral_unnest"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[]"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 9
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "pYUfcDLQxI-S"
      },
      "source": [
        "\n",
        "# counting the frequency of positive hashtags\n",
        "\n",
        "word_freq_positive = nltk.FreqDist(ht_positive_unnest)\n",
        "word_freq_negative = nltk.FreqDist(ht_negative_unnest)\n",
        "word_freq_neutral = nltk.FreqDist(ht_neutral_unnest)\n",
        "\n",
        "# creating a dataframe for the most frequently used words in hashtags\n",
        "df_positive = pd.DataFrame({'Hashtags':list(word_freq_positive.keys()),'Count':list(word_freq_positive.values())})\n",
        "df_negative = pd.DataFrame({'Hashtags':list(word_freq_negative.keys()),'Count':list(word_freq_negative.values())})\n",
        "df_neutral = pd.DataFrame({'Hashtags':list(word_freq_neutral.keys()),'Count':list(word_freq_neutral.values())})\n",
        "\n",
        "def show_plot(sentiment, num_of_tags=1):\n",
        "  if sentiment == 'Positive':\n",
        "    df_positive_plot = df_positive.nlargest(num_of_tags, columns='Count')\n",
        "    sns.barplot(data=df_positive_plot,y='Hashtags', x='Count')\n",
        "    sns.despine()\n",
        "    plt.show()\n",
        "\n",
        "  elif sentiment == 'Negative':\n",
        "    df_negative_plot = df_negative.nlargest(num_of_tags,columns='Count') \n",
        "    sns.barplot(data=df_negative_plot,y='Hashtags', x='Count')\n",
        "    sns.despine()\n",
        "    plt.show()\n",
        "\n",
        "  else:\n",
        "    df_neutral_plot = df_neutral.nlargest(num_of_tags,columns='Count') \n",
        "    sns.barplot(data=df_neutral,y='Hashtags', x='Count')\n",
        "    sns.despine()\n",
        "    plt.show()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "HxQ3ZGDxgdrP",
        "outputId": "e58aa0cb-80c3-4625-916d-598c48d5707e"
      },
      "source": [
        "# print all statements in increasing order of positivity\n",
        "def printHistory(asc, num = 1):\n",
        "  j = 1\n",
        "  sortedDF = df.sort_values(by = ['Polarity'], axis=0, ascending = asc)\n",
        "  sortedDF = sortedDF.reset_index(drop=True)\n",
        "  sortedDF = sortedDF[['Tweets', 'Analysis']].iloc[:num]\n",
        "  print(sortedDF)\n",
        "  \n",
        "  # for tweet in sortedDF[['Tweets', 'Analysis']]:\n",
        "  #   if (j > num):\n",
        "  #     print(\"breaking out\")\n",
        "  #     break\n",
        "  #   print(str(j) + '. ' + sortedDF['Tweets'][j - 1] + \" \" + sortedDF['Analysis'][j - 1])\n",
        "  #   print()\n",
        "  #   j = j + 1\n",
        "  \n",
        "\n",
        "  # for tweet in sortedDF['Tweets']:\n",
        "  #   if (j > num):\n",
        "  #     print(\"breaking out\")\n",
        "  #     break\n",
        "  #   print(str(j) + '. ' + tweet + \" \" + sortedDF['Analysis'][j - 1])\n",
        "  #   print()\n",
        "  #   j = j + 1\n",
        "\n",
        "printHistory(False, 2)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "                                  Tweets Analysis\n",
            "0  he had a terrible day, and I am glad!  Neutral\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 441
        },
        "id": "k_kSXIZFhX_-",
        "outputId": "758690c4-6b35-4c1b-b24c-0555434e9527"
      },
      "source": [
        "# Plot the polarity and subjectivity\n",
        "plt.figure(figsize=(8,6)) \n",
        "for i in range(0, df.shape[0]):\n",
        "  plt.scatter(df[\"Polarity\"][i], df[\"Subjectivity\"][i], color='Blue') \n",
        "# plt.scatter(x,y,color)   \n",
        "plt.title('Sentiment Analysis') \n",
        "plt.xlabel('Polarity') \n",
        "plt.ylabel('Subjectivity') \n",
        "plt.show()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAlIAAAGoCAYAAACNPguRAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nOzdeXRM9//H8deIINZYEkFIUFRirdiKFKkt9lqjSovyFarV2tr6arW2VFtFibb20sXaUutXpcSaUppQVWtqDUJsDSKZ3x+O+ZlmnSsxWZ6Pc3JO53M/9973O+Pqy7137phiYmLMAgAAgM1y2bsAAACArIogBQAAYBBBCgAAwCCCFAAAgEEEKQAAAIMIUgAAAAYRpACkyNnZWW3btrV3GUhCZGSknJ2dNXjw4Ceyv9DQUDk7O2vy5MlPZH9AVkCQAp6QhIQELV68WO3atVP58uVVokQJVaxYUQ0bNtTgwYO1cuVKu9Tl7Oys6tWr22XfT9LkyZPl7OyspUuXPtZ2goOD5ezsLGdnZ+3bty+dqgOQVeW2dwFATpCQkKCAgABt2rRJhQsXVuvWrVW6dGnFxcXp6NGjWrNmjfbt26cuXbrYu9REwsLC5OTkZO8yMo1FixbJZDLJbDZr4cKF8vHxsXdJT0ydOnUUFham4sWL27sUINMgSAFPwMqVK7Vp0yZVq1ZN69atU5EiRayW3717V7t377ZTdSmrXLmyvUvINHbt2qU///xT3bp10+7du7V69WpNmjRJhQsXtndpT0T+/Pn58wD8C5f2gCdg7969kqRevXolClGSlDdvXjVt2jTJdbdv366ePXuqYsWKcnFxUbVq1fTWW28pKioq0dy2bdvK2dlZkZGRWrBggZ599lmVLFlSlSpV0uuvv67r169b5j6830WSzpw5Y7lc9e97bpK6R+rRy2QhISFq06aNypQpo4oVKyowMFAxMTGSpN9//109evSQp6enypQpo549eyoyMjLJPq9fv66JEyeqYcOGKlWqlNzd3dW6dWv98MMPieY+rH3w4MGKjIxUv379VKFCBZUsWVJNmzbVxo0bE/1egoKCJElDhgyx6jW5epKycOFCSVLv3r0VEBCg27dva/ny5UnOXbp0qeV+ovDwcHXv3l3lypVTqVKl5O/vb/kz8agLFy4oKChIrVq1UuXKleXi4qKnn35a/fv315EjR9JUY//+/eXs7KwdO3YkuXzLli1ydnbWwIEDLWOnT5/WG2+8oWeeeUZubm7y8PBQvXr1NGTIEJ05c8YyL7l7pNK6PpAdEaSAJ+BhYDlx4oRN63322Wfq0KGD9u7dq+eff16DBw9WlSpVNG/ePDVr1kznzp1Lcr333ntP7733nqpVq6YBAwaoVKlSWrRokXr37m2ZU65cOY0ePVqSVLhwYY0ePdryk9abyzds2KCePXuqZMmSevnll1WqVCl98803eumllxQWFqY2bdpIehA8atSooY0bN6pnz55KSEiw2s758+fVvHlzTZ06Vc7Oznr55ZfVpUsXRUZG6uWXX0725uYzZ87Iz89Pf//9t3r06KHOnTvryJEj6tWrl7Zv326Z16tXLzVq1EiS5O/vb9VrUsE2KdeuXdOaNWtUtmxZ+fr66sUXX5TJZNKiRYtSXO/gwYNq1aqV7ty5oz59+qhVq1bas2ePOnbsqGPHjlnN3bVrlz777DMVKVJEHTp0UGBgoHx8fLRmzRr5+fnp999/T7XOfv36Sfr/0PdvCxYskCS98sorkqSLFy+qWbNmWrJkiSpVqqSBAwcqICBAlStX1tq1a1P9M/u46wNZHZf2gCegffv2mj59uubPn6+bN2+qbdu2qlmzpjw8PGQymZJcZ+fOnRo/frzq1q2r5cuXW8KYJH333Xf6z3/+ozFjxujrr79OtO6+ffu0c+dOlS1bVpJ0//59tW/fXqGhodq/f7/q1KkjDw8Pvf322woKClKRIkX09ttv29zXpk2btH79etWtW1eSdO/ePTVt2lShoaHq3r27goOD1bFjR0mS2WxW165d9fPPP2vDhg1WYW3w4ME6efKk5s6dq65du1rGb9y4oXbt2umjjz5Su3btEt0Uv2PHDo0ZM0ZjxoyxjHXr1k1dunTRzJkz5evrK0l68cUX9ffff2vnzp1q27atXnzxRZt7/fbbb3Xnzh0FBATIZDLJ09NTzz77rHbu3KnffvtNzzzzTLK/o1mzZlntc8GCBRo+fLjmzJmjTz75xDLu6+urv/76S4UKFbLaRkREhFq3bq0PPvgg1Q8lNGrUSF5eXlqzZo2io6Ot7me6cOGCNm3aJC8vLzVs2FCS9OOPP+ratWuaNGmSAgMDrbZ19+5dxcXFpbi/x10fyOo4IwU8ATVr1tSXX34pV1dXLVu2TH379lWtWrXk4eGh7t27a+XKlYnO0syZM0dms1nTpk2zClGS1LNnT9WoUUPr16/XzZs3E+1v1KhRlhAlSblz57b8j3z//v3p1lfXrl0tIUqS8uTJo06dOkmSvL29LSFKkkwmkyUkRUREWMYPHz6sbdu2qW3btlYhSnpwpmzMmDEym81JXkIrW7asRo4caTXm5+cnd3f3dO1T+v+bzHv16mUZe/g7Te7sjyQ1aNAgUXDr3bu3cufOnahGFxeXRCFKkqpXr64mTZpox44daQom/fr107179xJ9QnHx4sW6f/++Xn755UTrJPWBgrx586pgwYKp7i891geyKs5IAU9I586d1a5dO4WGhmr37t0KDw/Xnj17tHnzZm3evFnffPONvv32W+XJk0fSg/uqcufOrbVr12rt2rWJtnfv3j3Fx8frxIkTqlWrltWyf7+WJHd3d0my3L+UHmrUqJFozM3NLdllpUqVkvTgUt5DD+8VunnzZpKX8KKjoyVJR48eTbSsevXqcnBwSDTu7u6usLCwtLSQJrt27dLRo0fVqFEjeXp6WsY7duyoUaNGadWqVZo4cWKSISip98LR0VGurq5JvhebNm3S/PnzdfDgQUVHR+v+/ftWy6Ojoy2/4+T06NFD48eP18KFC/Xaa6/JZDIpPj5eX3/9tQoUKKAePXpY5rZp00YffvihRo4cqS1btsjPz09169aVt7e3cuVK/d/aj7s+kNURpIAnyNHRUc2bN1fz5s0lSfHx8VqzZo2GDh2qn3/+WfPmzbPc6H316lXdv3/fcpN0cm7dupVoLKn7fh4Gjvj4+MdtwyKpT6s93E9Kyx49q3L16lVJ0rZt27Rt27Zk93X79u1EY8nd3+Tg4JDoDN/jeHjG6dGzUZJUoEABderUSUuWLNGKFSss9x2ltcZ/vxfBwcF6++235ezsrGbNmsnd3V1OTk4ymUxat26dDh06pLt376Zab6FChdS9e3fNmzdP27ZtU9OmTbV582adPXtWL730klVN5cqV09atWxUUFKQtW7Zo3bp1kiRXV1cNHDhQw4cPTzKsptf6QFZHkALsyMHBQZ07d9bhw4f18ccfa9u2bZYgVbhwYcXFxWX7Tz09DFwTJkzQ0KFD7VxNYteuXdOPP/4o6cEn/oYMGZLkvIULFyYZpNLq/v37mjJlikqWLKlt27YlOuv066+/2rS9/v37a968eVqwYIGaNm1qCYMPb0Z/VOXKlTVv3jzFx8fr8OHD2r59u+bOnasJEyYoPj7e8qGE5Dzu+kBWRpACMoGHl4TMZrNlrG7dutq0aZMiIiIy9MnjuXLlStezN7aqV6+eJGn37t0ZGqSMnpH75ptvdPfuXVWvXj3Jy3SS9PPPP+v333/XwYMHk52TmujoaF2/fl2+vr6JQtStW7fS9Im9Rz28oXz9+vX67bff9L///U+1atVS7dq1k13HwcFBNWrUUI0aNdS6dWv5+Pjop59+SnMQetz1gayIC9jAE7BixQqFhIQkGViioqIsH6F/+BF9SZYzH2+88UaSjzm4c+dOujzEs1ixYrpy5YpiY2Mfe1tG1KpVS40aNdL69eu1aNEiqzD50PHjxx/7zFyxYsUkSWfPnrVpvYfvTVBQkGbOnJnkz8OziCnddJ4aFxcX5c+fXwcPHrS6XBsXF6cxY8ZY7hWzxYABAxQXF6fevXsrISEhybNRBw8eTPJerYfPKcufP3+K+3jc9YGsjjNSwBOwb98+zZkzRyVLllSDBg3k4eEh6cGXzm7evFmxsbGqV6+eXn31Vcs6vr6++vDDD/Xee++pTp06atGihTw9PXXnzh2dOXNGu3btUrly5ZJ98GJaNWvWTMuXL1eXLl307LPPKm/evKpWrZrlGVBPwty5c9WxY0e9/vrr+uKLL1S3bl0VLVpU58+f159//qnw8HAtWbLE6pOItvL19VWuXLk0Z84cXbt2Ta6urpKkgQMHJnsf086dO/XXX3+pcuXKevbZZ5PddkBAgD788EOtXLlSEyZMMPRJtVy5cmnQoEGaNm2ann32Wfn7+ysuLk6hoaG6du2amjRpotDQUJu22aFDB7m6uur8+fMqXLhwkl9B9N1332nBggWqX7++KlSooGLFiunMmTNav369HBwcNGzYsBT38bjrA1kdQQp4Al577TVVqlRJISEh+uOPPxQSEqJ//vlHRYsWVb169dSpUyf17t1bjo6OidZr0KCB5syZo927d2vjxo0qWLCgSpUqpe7du6tz586PXdvkyZOVK1cu/fLLL9qzZ4/lewGfZJAqVaqUQkJC9NVXX+nHH3/UypUrFRcXJ1dXVz311FMKCgpS48aNH2sflStX1pdffqmZM2dqyZIlljNw3bt3TzZIPTzD1KdPnxS3XaJECfn7++uHH37QypUr1bdvX0M1vvvuuypevLi+/vprLVy4UIULF1bTpk01duzYZB9KmhJHR0f16NFDM2fOVI8ePVSgQIFEc7p27aq4uDjt3btXERER+ueff+Tm5qbWrVsrMDBQderUSXEfj7s+kNWZYmJiEp9HBwBkCy+88IK2bt2qXbt2ycvLy97lANkO90gBQDb1+++/a+vWrWrcuDEhCsggXNoDgGxm3rx5unDhgr755huZTCa988479i4JyLa4tAcA2Uz16tV17tw5eXp6asSIEYkeJAog/RCkAAAADOIeKQAAAIMIUgAAAAYRpFJw7Ngxe5fwxNFzzpDTes5p/Ur0nBPktH6lzNkzQQoAAMAgghQAAIBBBCkAAACDCFIAAAAGEaQAAAAMIkgBAAAYRJACAAAwiCAFAABgEEEKAADAIIIUAACAQQQpAAAAgwhSAAAABhGkAAAADCJIAQAAGESQAgAAMIggBQAAYBBBCgAAwCCCFAAAgEEEKQAAAIMIUgAAAAYRpAAAAAwiSAEAABhEkAIAADCIIAUAAGAQQQoAAMAgghQAAIBBBCkAAACDCFIAAAAGEaQAAAAMIkgBAAAYRJACAAAwiCAFAABgEEEKAADAIIIUAACAQQQpAAAAgwhSAAAABhGkAAAADCJIAQAAGESQAgAAMIggBQAAYBBBCgAAwCC7BqmdO3eqZ8+eqlq1qpydnbV06dJU1zl8+LD8/f3l5uamqlWrKigoSGazOcm5K1askLOzs3r06JHepQMAANg3SN2+fVteXl6aMmWKnJycUp1/48YNde7cWa6urtq6daumTJmimTNn6vPPP0809/Tp0xo3bpwaNmyYEaUDAAAotz133rJlS7Vs2VKSFBgYmOr85cuXKzY2VsHBwXJycpKXl5f++usvzZ49W0OHDpXJZJIkxcXFqX///ho7dqxCQ0N19erVDO0DAADkTFnqHqmwsDA1bNjQ6uyVn5+fLly4oMjISMvYhx9+qHLlyqlXr172KBMAAOQQdj0jZatLly6pdOnSVmMuLi6WZZ6entq6datWr16t0NBQm7Z97Ngxm8azM3rOGXJazzmtX4mec4Kc1q+UfM+VKlV6wpU8kKWCVGquXLmiwMBAzZ07V87Ozjatm9QbcOzYMbu9MfZCzzlDTus5p/Ur0XNOkNP6lTJnz1kqSLm6uury5ctWYw9fu7q66siRI7p48aI6duxoWZ6QkCBJKl68uPbs2ZPp3gAAAJB1ZakgVa9ePb3//vu6c+eO8uXLJ0kKCQlRqVKl5OHhIRcXF+3atctqnQkTJigmJkYff/yxPDw87FE2AADIpux6s/mtW7cUHh6u8PBwJSQk6OzZswoPD9eZM2ckSePHj1eHDh0s87t27SonJycFBgbqjz/+0Jo1a/TZZ58pMDBQJpNJBQoUkJeXl9VPkSJFVKhQIXl5eSlPnjz2ahUAAGRDdg1SBw4ckK+vr3x9fRUbG6vJkyfL19dXkyZNkiRdvHhRp06dsswvUqSIVq9erQsXLqhZs2YaOXKkhgwZoqFDh9qrBQAAkIPZ9dJekyZNFBMTk+zy4ODgRGPe3t7asGFDmveR1DYAAADSQ5Z6jhQAAEBmQpACAAAwiCAFAABgEEEKAADAIIIUAACAQQQpAAAAgwhSAAAABhGkAAAADCJIAQAAGESQAgAAMIggBQAAYBBBCgAAwCCCFAAAgEEEKQAAAIMIUgAAAAYRpAAAAAwiSAEAABhEkAIAADCIIAUAAGAQQQoAAMAgghQAAIBBBCkAAACDCFIAAAAGEaQAAAAMIkgBAAAYRJACAAAwiCAFAABgEEEKAADAIIIUAACAQQQpAAAAgwhSAAAABhGkAAAADCJIAQAAGESQAgAAMIggBQAAYBBBCgAAwCCCFAAAgEEEKQAAAIMIUgAAAAYRpAAAAAwiSAEAABhEkAIAADCIIAUAAGAQQQoAAMAgghQAAIBBBCkAAACDCFIAAAAGEaQAAAAMIkgBAAAYRJACAAAwiCAFAABgEEEKAADAIIIUAACAQXYNUjt37lTPnj1VtWpVOTs7a+nSpamuc/jwYfn7+8vNzU1Vq1ZVUFCQzGazZfmiRYvUpk0beXh4qFy5cmrXrp12796dkW0AAIAcyq5B6vbt2/Ly8tKUKVPk5OSU6vwbN26oc+fOcnV11datWzVlyhTNnDlTn3/+uWXOjh071LlzZ61Zs0Y///yzKlWqpC5duujEiRMZ2QoAAMiBcttz5y1btlTLli0lSYGBganOX758uWJjYxUcHCwnJyd5eXnpr7/+0uzZszV06FCZTCZ99dVXVut8+umnWrdunbZs2aKKFStmSB8AACBnylL3SIWFhalhw4ZWZ6/8/Px04cIFRUZGJrnOvXv3dOfOHTk7Oz+pMgEAQA5h1zNStrp06ZJKly5tNebi4mJZ5unpmWidCRMmqGDBgmrTpk2K2z527JhN49kZPecMOa3nnNavRM85QU7rV0q+50qVKj3hSh7IUkHKVsHBwVq4cKF++OEHFS5cOMW5Sb0Bx44ds9sbYy/0nDPktJ5zWr8SPecEOa1fKXP2nKWClKurqy5fvmw19vC1q6ur1fjs2bM1adIkLV++XHXq1HliNQIAgJwjS90jVa9ePe3evVt37tyxjIWEhKhUqVLy8PCwjH3++eeaNGmSvv/+ezVs2NAepQIAgBzArkHq1q1bCg8PV3h4uBISEnT27FmFh4frzJkzkqTx48erQ4cOlvldu3aVk5OTAgMD9ccff2jNmjX67LPPFBgYKJPJJEmaMWOGxo8fr5kzZ+qpp55SVFSUoqKidP36dbv0CAAAsi+7BqkDBw7I19dXvr6+io2N1eTJk+Xr66tJkyZJki5evKhTp05Z5hcpUkSrV6/WhQsX1KxZM40cOVJDhgzR0KFDLXO++uorxcXF6ZVXXlGVKlUsP2PGjHni/QEAgOzNrvdINWnSRDExMckuDw4OTjTm7e2tDRs2JLtOREREutQGAACQmix1jxQAAEBmQpACAAAwiCAFAABgEEEKAADAIIIUAACAQQQpAAAAgwhSAAAABhGkAAAADCJIAQAAGESQAgAAMIggBQAAYJBNQapFixaaP3++rl27llH1AAAAZBk2Bam7d+/qrbfe0tNPP63evXtr7dq1iouLy6jaAAAAMjWbgtT27du1d+9eDRkyROHh4erTp48qV66sN998U3v37s2oGgEAADIlm++Rqly5ssaNG6fw8HD99NNP6tChg1avXq02bdqodu3amjJlik6ePJkRtQIAAGQqj3WzeaNGjTR9+nQdPHhQnTp10unTpxUUFCQfHx+1bt1aP/30U3rVCQAAkOnkfpyVt2/frmXLlmnNmjW6efOmqlWrpoCAADk6Omrx4sXq06eP3njjDY0bNy696gUAAMg0bA5Sf/zxh5YtW6YVK1bo/PnzcnFxUZ8+fRQQECBvb2/LvFdffVXDhw/XggULCFIAACBbsilINWrUSEeOHFHevHnVpk0bBQQEyM/PT7lyJX2FsFGjRlq4cGF61AkAAJDp2BSkChUqpGnTpqlTp04qUqRIqvP9/f31+++/Gy4OAAAgM7MpSH311VcqUaKEnJycklweGxurK1euqGzZspKk/Pnzq1y5co9fJQAAQCZk06f2atasmeIn8TZs2KCaNWs+dlEAAABZgU1Bymw2p7j8/v37MplMj1UQAABAVmHzc6SSC0rXr1/Xli1b5OLi8thFAQAAZAWpBqkpU6aoWLFiKlasmEwmkwYOHGh5/ehP+fLltXz5cnXp0uVJ1A0AAGB3qd5sXqdOHfXv31+SNHfuXDVr1kwVK1a0mmMymVSgQAHVqlVLHTp0yJhKAQAAMplUg1SLFi3UokULSdLt27fVr18/+fj4ZHhhAAAAmZ1Njz+YPXt2RtUBAACQ5aQYpHbu3CnpwRPKH32dmofzAQAAsrMUg1S7du1kMpl08eJF5cmTx/I6OWazWSaTSVevXk33QgEAADKbFIPU2rVrJUl58uSxeg0AAIBUglTjxo1TfA0AAJCT2fRAzqCgIJ04cSKjagEAAMhSbA5SdevWla+vr2bMmKEzZ85kVF0AAACZnk1BKiIiQuPHj5ejo6Pee+891axZUy1bttQXX3yhqKiojKoRAAAgU7IpSJUpU0avvfaafv75Zx08eFBjx45VbGysxowZI29vb7Vv316LFi3KqFoBAAAyFZu/tPghDw8PvfnmmwoNDdWvv/6qESNG6Pfff9ebb76ZnvUBAABkWjY92Twpv/32m1atWqUffvhBN2/eVKFChdKjLgAAgEzPUJCKiIjQ6tWrtWrVKv3999/Kly+fWrRooYkTJ6pVq1bpXSMAAECmZFOQmjRpklavXq0TJ04od+7catasmd555x35+/urYMGCGVUjAABApmRTkPr000/VuHFjvfbaa+rQoYOcnZ0zqi4AAIBMz6YgdeTIEbm4uGRULQAAAFmKTZ/aI0QBAAD8vxTPSA0ZMkQmk0nTp0+Xg4ODhgwZkuoGTSaTPv/883QrEAAAILNKMUht375duXLlUkJCghwcHLR9+3aZTKYUN5jacgAAgOwixSAVERGR4msAAICczKZ7pM6cOaPY2Nhkl8fGxvJFxgAAIMewKUjVrFlTP/30U7LLN2zYoJo1az52UQAAAFmBTUHKbDanuPz+/fvcIwUAAHIMm7+0OLmgdP36dW3ZsoVHJAAAgBwj1SA1ZcoUFStWTMWKFZPJZNLAgQMtrx/9KV++vJYvX64uXbo8iboBAADsLtUnm9epU0f9+/eXJM2dO1fNmjVTxYoVreaYTCYVKFBAtWrVUocOHTKmUgAAgEwm1SDVokULtWjRQpJ0+/ZtvfLKK6pbt26GFwYAAJDZ2XSP1OzZs9M1RO3cuVM9e/ZU1apV5ezsrKVLl6a6zuHDh+Xv7y83NzdVrVpVQUFBiW6C//HHH1W/fn25urqqfv36Wrt2bbrVDCDriIw06dVXnfSf/1TWq686KTKSD8MASF82Balp06apVatWyS5v06aNZs6cmebt3b59W15eXpoyZYqcnJxSnX/jxg117txZrq6u2rp1q6ZMmaKZM2dafSVNWFiY+vXrp27duik0NFTdunXTyy+/rH379qW5LgBZX2SkSZ06FdDy5Xm0f39hLV+eR506FSBMAUhXNgWp5cuXp3hGqm7duvruu+/SvL2WLVtq3Lhx6tixo3LlSr2U5cuXKzY2VsHBwfLy8lLHjh31+uuva/bs2ZazUsHBwWrSpIlGjBihKlWqaMSIEWrcuLGCg4PTXBeArG/ChHw6dcrBauzUKQdNmJDPThUByI5SvUfqUadPn1alSpWSXV6xYkXNnz//sYtKTlhYmBo2bGh19srPz08TJ05UZGSkPD099euvv2rgwIFW6/n5+enLL79McdvHjh2zaTw7o+ecIbv3fPJkZUl5khi/k+17fyin9PmonNZzTutXSr7nlPJJRrIpSOXNm1cXL15MdvmFCxfSdGbJqEuXLql06dJWYw+fW3Xp0iV5enoqKioq0bOsXFxcdOnSpRS3ndQbcOzYMbu9MfZCzzlDTui5QoV82r8/6fHs3ruUM97jf8tpPee0fqXM2bNNqadevXpasmSJrl+/nmhZTEyMlixZovr166dbcQBg1Nixd1S+fLzVWPny8Ro79o6dKgKQHdl0RmrMmDFq06aNGjVqpMGDB6tq1aqSpD/++ENz5szR5cuXtXDhwoyoU5Lk6uqqy5cvW409fO3q6ipJKlmyZJJzHi4HkDN4eJj1ww+3NWFCPp08eUcVKuTT2LF35OGR8lddAYAtbApStWvX1vfff6/XX39dY8eOtXxdjNlslqenp77//nv5+PhkSKHSgzNi77//vu7cuaN8+R7cMBoSEqJSpUrJw8ND0oMb3kNCQjRs2DDLeiEhIZwpA3IgDw+zvvoqNlNeDgCQPdgUpCTpueee04EDB3Tw4EGdPn1aklS+fHnVrFnT5i8svnXrlk6ePClJSkhI0NmzZxUeHq6iRYuqbNmyGj9+vPbv3681a9ZIkrp27aqgoCAFBgZqxIgROn78uD777DONGjXKsu///Oc/8vf317Rp09S2bVv99NNPCg0N1caNG21tFQAAIEU2BynpwVfC1K5dW7Vr136snR84cEDt27e3vJ48ebImT56sgIAABQcH6+LFizp16pRleZEiRbR69WqNGDFCzZo1k7Ozs4YMGaKhQ4da5tSvX1/z58/XhAkTNGnSJJUvX17z58/P0DNlAAAgZ7I5SF29elWzZ89WaGiorly5ouDgYNWrV09Xr17VV199pU6dOqlKlakEtIsAACAASURBVCpp2laTJk0UExOT7PKknv3k7e2tDRs2pLjdjh07qmPHjmmqAQAAwCibglRkZKTatGmjq1evysvLS6dOnVJsbKwkqVixYlq1apWuXLmiqVOnZkixAAAAmYlNQeq9996T2WzWnj17VKhQIT311FNWy/39/bVu3bp0LRAAACCzsuk5Ur/88oteffVVeXp6JnljuYeHh86fP59uxQEAAGRmNgWpu3fvytnZOdnl169fz9AnmwMAAGQmNqWeqlWraufOnckuX7dunWrUqPHYRQEAAGQFNgWpwYMHa/Xq1fr444917do1SQ+e//TXX39pwIAB2rdvn4YMGZIhhQIAAGQ2Nt1s3q1bN509e1aTJk3SpEmTJEldunSRJOXKlUvjx49XmzZt0r9KAACATMjm50gNHz5c3bp105o1a3Ty5EklJCSofPnyat++vTw9PTOgRAAAgMzJ0JPN3d3dFRgYmN61AAAAZCl8xA4AAMCgFM9I1ahRQ7ly5dKvv/4qR0dH1ahRI01fTJw7d24VL15czz33nIYPH678+fOnW8EAAACZRYpBqlGjRjKZTJZnQz18nZr4+HhFRUVp+vTpOnfunGbPnp0+1QIAAGQiKQapf39pcFJfIpySoKAgffnll7ZXBQAAkAUYutk8rdq1ayez2ZyRuwAAALAbm4PU/fv39e2332rTpk36+++/JUnlypVTq1atFBAQoNy5/3+T3t7e8vb2Tr9qAQAAMhGbPrV3+fJlNWvWTMOGDdOOHTtkMplkMpm0Y8cODRs2TE2bNtWlS5cyqlYAAIBMxaYgNWrUKB09elQzZ87UiRMntG3bNm3btk0nTpzQjBkz9Ndff2n06NEZVSsAAECmYtOlvS1btmjQoEHq3bu31biDg4Neeukl/fnnn1q8eHG6FggAAJBZ2XRGKk+ePCpbtmyyyz08PJQ3b97HLgoAACArsClIvfDCC1q5cqXi4uISLbt3755Wrlypzp07p1txAAAAmVmKl/b2799v9bpjx47atWuXmjVrpn79+qlChQqSpBMnTmjBggWWOQAAADlBikHq+eefT/Qk84fPhXrrrbcsyx59VlSHDh109erV9K4TAAAg00kxSM2aNetJ1QEAAJDlpBikevXq9aTqAAAAyHJsutkcAAAA/8+m50gNGTIk1Tkmk0mff/654YIAAACyCpuC1Pbt2xPdfJ6QkKCLFy8qPj5eJUqUUP78+dO1QAAAgMzKpiAVERGR5HhcXJwWLFig4OBgrV69Ol0KAwAAyOzS5R4pR0dHDRw4UM2bN9eoUaPSY5MAAACZXrrebF6tWjXt2rUrPTcJAACQaaVrkAoJCZGTk1N6bhIAACDTsukeqaCgoCTHr1+/rl27dun333/X8OHD06UwAACAzM6mIDVlypQkx52dnVW+fHlNmzZNffv2TZfCAAAAMjubgtS1a9cyqg4AAIAsx6Yg9W+hoaFatmyZLl68qMqVK+s///mPypYtm161AQAAZGqp3mw+ZcoUlSpVSleuXLEaX7p0qTp27KglS5Zoy5Ytmj17tpo3b66///47w4oFAADITFINUqGhoWrevLlKlChhGbt7967efvttFS5cWD/++KPOnj2r+fPn69atW/r0008ztGAAAIDMItUgdfLkSdWqVctqbNu2bbp586aGDRsmX19fFShQQJ07d1b37t31yy+/ZFStAAAAmUqqQeratWtyc3OzGgsNDZXJZFKrVq2sxmvVqqWLFy+mb4UAAACZVKpBqmTJkrpw4YLV2O7du5U/f349/fTT1hvLlUt58uRJ3woBAAAyqVSDVJ06dfTtt98qJiZGknTo0CEdOHBAzz33nBwcHKzmHj16VGXKlMmYSgEAADKZVB9/MHr0aD333HOqU6eOqlSpooiICJlMJr3xxhtW88xms3766Sc1b948w4oFAADITFI9I1WlShWtWbNGderU0ZUrV1S/fn2tWrVKdevWtZoXGhqqggULqkOHDhlWLAAAQGaSpgdy1qtXT8uWLUtxjq+vr3bt2pUuRQEAAGQFqZ6RAgAAQNIIUgAAAAYRpAAAAAwiSAEAABhEkAIAADCIIAUAAGAQQQoAAMAgghQAAIBBdg9Sc+fOVY0aNVSyZEk999xzqT7U86uvvlK9evXk5uYmHx8fffvtt4nmBAcHq27dunJzc5OXl5dGjBihW7duZVQLAAAgh0rTk80zyqpVqzRmzBh98sknatCggebOnatu3bppz549Klu2bKL58+bN0/vvv6/p06fLx8dH+/fv1+uvvy5nZ2e1adNGkrR8+XK99957mjFjhho2bKjTp0/rtdde0507d/T5558/6RYBAEA2ZtczUrNmzVKvXr3Ut29fValSRVOnTlXJkiU1f/78JOd///336tOnj7p27SpPT0916dJFffv21fTp0y1zwsLC5OPjo549e8rDw0PPPfecevbsqf379z+ptgAAQA5htyB17949HTx4UM2bN7cab968ufbu3ZvkOnfv3lW+fPmsxpycnLR//37FxcVJkho0aKBDhw7p119/lSSdOXNGGzZsUIsWLTKgCwAAkJPZ7dJedHS04uPj5eLiYjXu4uKiS5cuJbmOn5+fvv76a7Vv3161a9fWwYMHtXjxYsXFxSk6Olpubm7q0qWLrl69Kn9/f5nNZt2/f189evTQ+PHjU6zn2LFjNo1nZ/ScM+S0nnNavxI95wQ5rV8p+Z4rVar0hCt5wK73SNlq5MiRioqKUsuWLWU2m+Xq6qqAgABNnz5duXI9OLm2Y8cOTZ06VZ988onq1KmjkydP6u2339akSZP07rvvJrvtpN6AY8eO2e2NsRd6zhlyWs85rV+JnnOCnNavlDl7ttulveLFi8vBwUGXL1+2Gr98+bJcXV2TXMfJyUmzZs3ShQsXFB4erkOHDqlcuXIqVKiQSpQoIUmaOHGiunTpoj59+sjb21vt27fXf//7X82YMUP379/P8L4AAEDOYbcglSdPHtWqVUshISFW4yEhIapfv36K6zo6OqpMmTJycHDQypUr1apVK8sZqX/++UcODg5W8x0cHGQ2m9O3AQAAkOPZ9dLekCFDNGjQINWpU0f169fX/PnzdfHiRb3yyiuSpEGDBkmSvvjiC0nS8ePHtW/fPtWtW1cxMTGaNWuWjhw5ouDgYMs2W7durdmzZ6t27dqqU6eOTp06pYkTJ6pVq1bKnTtLXckEAACZnF2TxQsvvKCrV69q6tSpioqKUtWqVbVs2TKVK1dOknT27Fmr+fHx8Zo1a5aOHz8uR0dHNW7cWJs3b5aHh4dlzsiRI2UymTRx4kSdP39exYsXV+vWrfXf//73ifYGAACyP7ufohkwYIAGDBiQ5LJ169ZZva5SpYpCQ0NT3F7u3Lk1ZswYjRkzJt1qBAAASIrdvyIGAAAgqyJIAQAAGESQAgAAMIggBQAAYBBBCgAAwCCCFAAAgEEEKQAAAIMIUgAAAAYRpAAAAAwiSAEAABhEkAIAADCIIAUAAGAQQQoAAMAgghQAAIBBBCkAAACDCFIAAAAGEaQAAAAMIkgBAAAYRJACAAAwiCAFAABgEEEKAADAIIIUAACAQQQpAAAAgwhSAAAABhGkAAAADCJIAQAAGESQAgAAMIggBQAAYBBBCgAAwCCCFAAAgEEEKQAAAIMIUgAAAAYRpAAAAAwiSAEAABhEkAIAADCIIAUAAGAQQQoAAMAgghQAAIBBBCkAAACDCFIAAAAGEaQAAAAMIkgBAAAYRJACAAAwiCAFAABgEEEKAADAIIIUAACAQQQpAAAAgwhSAAAABhGkAAAADCJIAQAAGESQAgAAMIggBQAAYBBBCgAAwCC7B6m5c+eqRo0aKlmypJ577jnt2rUrxflfffWV6tWrJzc3N/n4+Ojbb79NNOfGjRsaNWqUnn76abm6uqp27dpavXp1RrUAAAByqNz23PmqVas0ZswYffLJJ2rQoIHmzp2rbt26ac+ePSpbtmyi+fPmzdP777+v6dOny8fHR/v379frr78uZ2dntWnTRpIUFxenzp07q2jRolqwYIFKly6t8+fPK2/evE+6PQAAkM3ZNUjNmjVLvXr1Ut++fSVJU6dO1c8//6z58+frvffeSzT/+++/V58+fdS1a1dJkqenp3777TdNnz7dEqSWLl2qK1euaMOGDcqTJ48kycPD4wl1BAAAchK7Xdq7d++eDh48qObNm1uNN2/eXHv37k1ynbt37ypfvnxWY05OTtq/f7/i4uIkSevWrVP9+vU1atQoVa5cWfXr19fkyZMtywEAANKL3c5IRUdHKz4+Xi4uLlbjLi4uunTpUpLr+Pn56euvv1b79u1Vu3ZtHTx4UIsXL1ZcXJyio6Pl5uam06dPa/v27eratauWLVumyMhIjRw5Urdv39aECROSrefYsWM2jWdn9Jwz5LSec1q/Ej3nBDmtXyn5nitVqvSEK3nArpf2bDVy5EhFRUWpZcuWMpvNcnV1VUBAgKZPn65cuR6cXEtISJCLi4tmzJghBwcH1apVS9euXdM777yjDz/8UCaTKcltJ/UGHDt2zG5vjL3Qc86Q03rOaf1K9JwT5LR+pczZs90u7RUvXlwODg66fPmy1fjly5fl6uqa5DpOTk6aNWuWLly4oPDwcB06dEjlypVToUKFVKJECUlSyZIlVbFiRTk4OFjWq1y5sv755x9FR0dnXEMAACDHsVuQypMnj2rVqqWQkBCr8ZCQENWvXz/FdR0dHVWmTBk5ODho5cqVatWqleWMVIMGDXTy5EklJCRY5h8/flz58+dX8eLF078RAACQY9n1OVJDhgzRN998o8WLF+vo0aMaPXq0Ll68qFdeeUWSNGjQIA0aNMgy//jx4/ruu+904sQJ7d+/X/369dORI0f03//+1zKnX79+iomJ0ejRo3Xs2DH9/PPPmjJlivr375/sZT0AAAAj7HqP1AsvvKCrV69q6tSpioqKUtWqVbVs2TKVK1dOknT27Fmr+fHx8Zo1a5aOHz8uR0dHNW7cWJs3b7Z6vIG7u7tWrVqld999V02aNJGrq6tefPFFjRw58on2BgAAsj+732w+YMAADRgwIMll69ats3pdpUoVhYaGprrNunXravPmzelSHwAAQHLs/hUxAAAAWRVBCgAAwCCCFAAAgEEEKQAAAIMIUgAAAAYRpAAAAAwiSAEAABhEkAIAADCIIAUAAGAQQQoAAMAgghQAAIBBBCkAAACDCFIAAAAGEaQAAAAMIkgBAAAYRJACAAAwiCAFAABgEEEKAADAIIIUAACAQQQpAAAAgwhSAAAABhGkAAAADCJIAQAAGESQAgAAMIggBQAAYBBBCgAAwCCCFAAAgEEEKQAAAIMIUgAAAAYRpAAAAAwiSAEAABhEkAIAADCIIAUAAGAQQQoAAMAgghQAAIBBBCkAAACDCFIAAAAGEaQAAAAMIkgBAAAYZIqJiTHbuwgAAICsiDNSAAAABhGkAAAADCJIAQAAGESQAgAAMIggBQAAYBBBCgAAwKBsGaTu3r2rkSNHqkKFCipdurR69uypc+fOpbjOzp071bNnT1WtWlXOzs5aunRpojmXLl3S4MGD9fTTT6tUqVLq0qWLTpw4YVkeGRkpZ2fnJH9mzJhhmde2bdtEy/v165cle05rPzExMRo4cKDKlSuncuXKaeDAgYqJicmSPV+7dk0jR45U3bp15ebmJm9vb7355pu6evWq1XaqV6+e6Pfy/vvvZ8me07rvM2fOqEePHipdurQqVKigUaNG6d69e5mu31u3bmnkyJHy8vKSm5ubfHx8NGvWLMvy7Hgsp9ZzWvvJSsdyaj1nx2M5Le9zdjqWkztOR4wYYdOcwYMHJ1r+/PPPp6m3bBmk3n77ba1du1bz5s3T+vXrdfPmTfXo0UPx8fHJrnP79m15eXlpypQpcnJySrTcbDbrxRdf1MmTJ7V06VJt375dZcuWVceOHXX79m1Jkru7u44ePWr188knn8hkMqlDhw5W23vxxRet5k2bNi1L9pzWfgYMGKDw8HCtWLFCK1asUHh4uAYNGpQle75w4YIuXLig8ePHa9euXfriiy+0a9cu9e/fP9H2Ro0aZfV7efTAzUo9p2Xf8fHx6tGjh27duqX169dr3rx5WrNmjd59991M1a8kvfvuu9q8ebPmzJmjvXv36q233tL48eP13XffScp+x3Jaek5rP1nlWE5Lz9ntWE5Lz2nZd1Y6lv99nD7ss1OnTjbNkaSmTZtazVu+fHmaest2D+S8fv26nnrqKc2aNUvdu3eXJJ09e1bVq1fXihUr5Ofnl+o2ypQpo48++kgvvviiZez48ePy8fFRaGioqlevLklKSEhQ5cqVNW7cOPXp0yfJbXXq1Ekmk0mrV6+2jLVt21ZeXl6aOnXq47RqYe+eU+vn6NGjql+/vjZu3KgGDRpIknbv3q02bdro119/VaVKlbJcz/+2efNm9ejRQ5GRkSpcuLCkB/+KHThwoF577TWb+0uKPXtOy77/97//qXv37oqIiJC7u7sk6fvvv9ewYcN07Ngxy+/F3v1KUsOGDdW+fXu98847ljF/f395e3sn++c4Kx/LUtp6zk7Hclp7/resfCxLqfec3Y7lfxs2bJh27dqlffv22TRn8ODBunr1qr7//vs0dvX/st0ZqYMHDyouLk7Nmze3jLm7u6tKlSrau3ev4e3evXtXkpQvXz7LWK5cuZQ3b17t3r07yXVOnz6tbdu26eWXX060bOXKlapQoYIaNGigsWPH6ubNm4Zryww9p9RPWFiYChYsqPr161vGGjRooAIFChiuLzP0/KibN28qb968yp8/v9X4zJkzVb58eTVu3Fgff/zxY50at2fPadl3WFiYqlSpYvmLV5L8/Px09+5dHTx40Oa6Mqpf6cGfv40bN+rs2bOSpL179+rQoUPJ/oWe1Y9lKe09Z5dj+WFttrzPUtY+lqXUe85ux/Kjbt26pVWrVqlv376G5uzevVtPPfWU6tSpo2HDhuny5ctp2m9uwxVnUpcuXZKDg4OKFy9uNe7i4qJLly4Z3m7lypXl7u6uDz74QDNmzFCBAgU0e/ZsnTt3TlFRUUmus3jxYpUoUUL+/v5W4926dVPZsmXl5uamP//8U+PHj9fhw4et/qVrC3v3nFo/ly5dUvHixWUymSzrmEwmlShRwnB99u75UTExMZo4caL69Omj3Ln//5AaNGiQatSooWLFium3337T+++/r8jISM2cOdNQbfbsOS37vnTpklxcXKyWFy9eXA4ODobqy6h+JSkoKEhvvPGGqlWrZnnPPvroI7Vu3TrJ+Vn9WJbS1nN2OpYl29/nrH4sS6n3nN2O5UetWLFC9+7dU0BAgM1znn/+ebVv314eHh76+++/NWHCBHXo0EG//PKL8ubNm+J+s0yQmjBhgj7++OMU56xduzbD9u/o6KglS5Zo6NChKl++vBwcHNS0aVO1aNFCZnPiq6P379/X0qVLFRAQIEdHR6tlj/6r1tvbW56envLz89PBgwdVq1Yty7Ks0nNa+0mLrNLzQ7du3VJAQIBKlSqlDz74wGrZ0KFDLf9drVo1FSpUSK+88orGjx+vYsWKWZZltZ4fl737laQvvvhCYWFh+vbbb1W2bFnt2rVL//3vf1WuXLlEN5hmh2NZSlvP2elYlmx7n7PDsSzZ1vPjygz9PmrRokXy9/dXiRIlbJ7TpUsXy397e3urVq1aql69ujZt2pTovsh/yzJBavDgwZZrq8lxd3fXr7/+qvj4eEVHR1v9oi5fvqyGDRs+Vg21atXSjh07dP36dcXFxalEiRLy8/NT7dq1E83dsGGDoqKikr2n5lG1a9eWg4ODTp48afWXVVbrObl+XF1dFR0dLbPZbPmXrNls1pUrV+Tq6mq1blbq+datW+rWrZukB/cPPHppLCl16tSRJJ08edLqL9+s0LOrq2uq+3Z1dU10mj46Olrx8fFW77O9+42NjdUHH3yghQsXqk2bNpIe/M8xIiJCM2fOTPQ/m+xwLNvac3L9ZKVj2Zaes8uxnJaes9Ox/Kjw8HAdOHBA48aNe6w5D5UqVUqlS5fWyZMnU52bZYJU8eLFE50WTEqtWrXk6OiokJAQy4Fx7tw5y02S6aFIkSKSpBMnTujAgQNJfpJh8eLFatSokZ566qlUt3f48GHFx8erZMmSVuNZreeH/t1PvXr1dOvWLYWFhVnqCQsL0+3btxPVl1V6vnnzprp16yaz2awVK1aoYMGCqW4vIiJCkrLk+5yWfderV08ff/yxzp07pzJlykiSQkJClDdvXqtQYe9+4+LiFBcXJwcHB6txBwcHJSQkJJqfHY5lW3t+KCsfy2ntOTsdy2npOTsdy49atGiRPDw81LRp08ea81B0dLQuXLiQ6D1OisOYMWPeT3upmV++fPl08eJFzZ07V97e3rp+/bqGDx+uwoULa/z48cqV68H99XXr1pX0//+yuHXrlv78809FRUXp66+/lpeXlwoXLqx79+5Z/ufyww8/6NKlSzKbzdq5c6cGDBggX19fvfXWW1Y1nDlzRqNGjdLYsWPl7e1ttezUqVP68ssvVaBAAd27d09hYWF64403VKZMGY0dO9ZSX1bpOS39lChRQvv27dOKFStUvXp1nTt3TsOHD9czzzxj+GPT9uz55s2beuGFF3Tjxg3Nnz9fJpNJt2/f1u3bt5UnTx45ODgoLCxMP/zwg/Lly6fY2FiFhIRo9OjRatKkieHnDNmz57Ts29PTU2vXrtXWrVvl7e2tP//8UyNGjFC3bt3Uvn37TNNv3rx5FRoaqo0bN6pKlSoym81at26dPv30Uw0aNEg+Pj6WGrLLsZyWnrPbsZyWnrPbsZyWnrPTsfzQP//8o8DAQA0cOFCNGjVKsoaU5ty6dUsffPCBChYsqPv37ysiIkKvvfaa4uPjNXXq1FTvkVJMTIw5u/1ERUWZX331VXPRokXNTk5O5latWpkPHTpkNUeSefTo0ZbXa9euNUtK9BMQEGCZM2XKFHOZMmXMjo6OZnd3d/OIESPMly5dSrT/UaNGmZ2dnc0XL15MtOzQoUPmZ5991ly0aFFznjx5zOXLlzcPGjTIfOrUqSzZc1r7OX36tLl79+7mQoUKmQsVKmTu3r27+fTp01my5+S2Icm8du1ac0xMjPmXX34x+/j4mAsXLmzOly+fuVKlSubRo0ebz58/nyV7Tuu+IyIizK1atTI7OTmZixYtah44cKA5Kioq0/V79OhRc69evcylSpWyvD8ffvih+dq1a9n2WE6t5+x4LKfWc3Y8ltPyZzs7HcsxMTHmzz//3Ozg4GA+cuRIsvtPac6FCxfMzZs3N5coUcLyd2BAQECi+pL7yXbPkQIAAHhSst1zpAAAAJ4UghQAAIBBBCkAAACDCFIAAAAGEaQAAAAMIkgBAAAYRJACkCW1bdtWbdu2zTLbBZA9EaQAPDFLly6Vs7Oz5ad48eLy8vJSYGCgzp8/b+/ykvTPP/9o8uTJCg0NtXcpADKhLPNdewCyjzFjxqh8+fK6e/eu9uzZo++++047d+7U7t27lT9/frvWtnr1aqvXsbGxCgoKkiQ1adLEHiUByMQIUgCeOD8/P8v3avXp00dFixbVrFmztH79enXt2tUuNf3zzz/Knz+/8uTJY5f9A8iauLQHwO58fX0lSZGRkYqPj9fHH3+s2rVry9XVVdWqVdO4ceMUGxub6nZmzpyp1q1bq0KFCipZsqSeffZZLV68ONG86tWrq0uXLtq2bZv8/PxUsmRJTZ8+XZL1PVKRkZGqWLGiJCkoKMhySXLw4MEKCQmRs7Oz1qxZk2j769evl7Ozs/73v/8Z/p0AyBo4IwXA7k6dOiVJKlasmN544w19/fXXat++vYYMGaIDBw5oxowZOnLkiJYtWyaTyZTsdoKDg9WqVSt16tRJJpNJ69ev17Bhw3T//n3169fPau7JkyfVp08f9e3bVy+99JLc3d0Tba9EiRL69NNP9eabb6pdu3Zq3/7BN9+XL19ePj4+Kl26tJYtW6YOHTpYrbds2TKVLFlSzZs3f9xfDYBMjiAF4Im7ceOGoqOjdefOHe3du1cfffSRnJycVKlSJQ0fPly9evXS7NmzLfPd3d0VFBSkTZs2qXXr1slud9++fVb3WA0aNEidO3fWzJkzEwWpU6dO6ZtvvpG/v3+y2ytQoIA6duyoN998U97e3urRo4fV8u7duys4OFgxMTFydna29LZx40b169dPDg4ONv1eAGQ9XNoD8MR16dJFFStWlLe3t/r16ydXV1d99913CgsLkyQNGTLEan5gYKAcHBy0efPmFLf7METFxcXp2rVrio6OVpMmTXTq1Cldv37dam6ZMmVSDFFpERAQoLt371rdoP7jjz/qzp07iUIXgOyJM1IAnrigoCBVqVJFefPmlbu7u9zd3WUymfTDDz/IZDLpqaeesppfpEgRubm56e+//05xu+vWrdPUqVMVERGh+Ph4q2U3btxQkSJFLK89PDweu48qVaromWee0bJly/TKK69IenBZr2rVqqpZs+Zjbx9A5keQAvDEPfPMM5ZP7aWX3bt3q3fv3mrQoIGmTZsmNzc35cmTR5s3b9bs2bOVkJBgNd/JySld9tuzZ0+NHj1akZGRyp07t3bu3Klx48aly7YBZH4EKQCZRtmyZWU2m3X8+HF5e3tbxm/cuKGLFy+qVatWya77448/Kl++fFq9erXy5ctnGX/cB2mmdHO7JHXt2lVjx47VsmXLLI9O6Nat22PtE0DWwT1SADKNli1bSnrw6btHzZkzR/Hx8SkGKQcHB5lMJqszTzExMVqyZMlj1fTwzFVMTEySy4sVK6aWLVtq2bJlWrZsmZo0aaIyZco81j4BZB2ckQKQaVSrVk0vvfSSvv6/du5QRYEojOL42WgQ1IEJlikWzVYnDWg16YDZL6IJzQAAAVNJREFUpMEkA76BQUFEUAziZOs8gc1i8R0mKRYxyG4TZJdduILuuv9fvuHEw3fvd5dLHY9Hua6r7XarMAzled61aH2lUqloPB6rWq2qVqtpv99rsVjItm3FcWycKZFIKJ/Pa7VaKZfLKZPJyHEcFYvF65l6va5GoyFJN9uGAF4fRQrArzIcDuU4jsIwVBRFsm1b7XZbQRB8e81WKpU0mUw0GAwUBIGy2ayazaZSqZRardZdmUajkbrdrnq9ns7ns3zfvylS5XJZlmXpdDp9+lMKwGt7OxwO788OAQB/2eVyUaFQkOu6ms1mz44D4IF4IwUAd4qiSHEcy/f9Z0cB8GBMpADA0Gaz0W63U7/fVzKZ1Hq9/nHLD8BrYSIFAIbm87k6nY7S6bSm0yklCviHmEgBAAAYYiIFAABgiCIFAABgiCIFAABgiCIFAABgiCIFAABg6AO4C/1RqDHOpQAAAABJRU5ErkJggg==\n",
            "text/plain": [
              "<Figure size 576x432 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": []
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "OhX7wkfdiPs5",
        "outputId": "8d1400e5-962e-4756-cc76-6db95bba2dfa"
      },
      "source": [
        "# Print the percentage of different types of tweets\n",
        "sentiments = ['Positive', 'Neutral', 'Negative']\n",
        "for sentiment in sentiments:\n",
        "  postweets = df[df.Analysis == sentiment]\n",
        "  postweets = postweets['Tweets']\n",
        "  print(sentiment + \" tweets: \" + str(round( (postweets.shape[0] / df.shape[0]) * 100 , 1)))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Positive tweets: 0.0\n",
            "Neutral tweets: 100.0\n",
            "Negative tweets: 0.0\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "PNhM-dv6isSg"
      },
      "source": [
        "# end of code"
      ],
      "execution_count": null,
      "outputs": []
    }
  ]
}