V2 Capstone project.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "b2187221-8378-4b16-a649-19385c803ba2",
   "metadata": {},
   "source": [
    "# Task 1: Class Imbalance Problem - EDA"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "378209dd-2ce1-4feb-9fa2-a13e73f1bfb0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Positive Review Example:\n",
      "Purchased on Black FridayPros - Great Price (even off sale)Very powerful and fast with quad core processors Amazing soundWell builtCons -Amazon ads, Amazon need this to subsidize the tablet and will remove the adds if you pay them $15.Inability to access other apps except the ones from Amazon. There is a way which I was able to accomplish to add the Google Play storeNet this is a great tablet for the money\n",
      "Negative Review Example:\n",
      "was cheap, can not run chrome stuff, returned to store.\n",
      "Neutral Review Example:\n",
      "Just an average Alexa option. Does show a few things on screen but still limited.\n",
      "Class Count:\n",
      "Positive    3749\n",
      "Neutral      158\n",
      "Negative      93\n",
      "Name: sentiment, dtype: int64\n"
     ]
    }
   ],
   "source": [
    "import pandas as pd\n",
    "\n",
    "# Load the train_data CSV file\n",
    "train_data_path = 'Ecommerce/train_data.csv'\n",
    "train_data = pd.read_csv(train_data_path)\n",
    "\n",
    "# Display positive, negative, and neutral reviews\n",
    "print(\"Positive Review Example:\")\n",
    "print(train_data[train_data['sentiment'] == 'Positive']['reviews.text'].iloc[0])\n",
    "print(\"Negative Review Example:\")\n",
    "print(train_data[train_data['sentiment'] == 'Negative']['reviews.text'].iloc[0])\n",
    "print(\"Neutral Review Example:\")\n",
    "print(train_data[train_data['sentiment'] == 'Neutral']['reviews.text'].iloc[0])\n",
    "\n",
    "# Check class count for each sentiment\n",
    "class_counts = train_data['sentiment'].value_counts()\n",
    "print(\"Class Count:\")\n",
    "print(class_counts)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6565e15d-f6b2-4953-983d-00bf871033b7",
   "metadata": {},
   "source": [
    "# Task 2: Convert Reviews to Tf-Idf Scores"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "75ba40de-405f-4e53-b495-2ee68230825d",
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.feature_extraction.text import TfidfVectorizer\n",
    "\n",
    "# Convert reviews.text to Tf-Idf scores\n",
    "tfidf_vectorizer = TfidfVectorizer()\n",
    "tfidf_train = tfidf_vectorizer.fit_transform(train_data['reviews.text'])\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6a072c6d-efe0-4eaf-acce-b5c920ed405c",
   "metadata": {},
   "source": [
    "# Task 3: Run Multinomial Naive Bayes Classifier"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "c4653774-f27d-4d3c-a870-3a5384ed6ec9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Multinomial Naive Bayes Classifier Report:\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "    Negative       0.00      0.00      0.00        13\n",
      "     Neutral       0.00      0.00      0.00        36\n",
      "    Positive       0.94      1.00      0.97       751\n",
      "\n",
      "    accuracy                           0.94       800\n",
      "   macro avg       0.31      0.33      0.32       800\n",
      "weighted avg       0.88      0.94      0.91       800\n",
      "\n"
     ]
    }
   ],
   "source": [
    "from sklearn.naive_bayes import MultinomialNB\n",
    "from sklearn.metrics import classification_report\n",
    "from sklearn.model_selection import train_test_split\n",
    "\n",
    "# Split the data into training and validation sets\n",
    "train_df, val_df = train_test_split(train_data, test_size=0.2, random_state=42)\n",
    "tfidf_val = tfidf_vectorizer.transform(val_df['reviews.text'])\n",
    "\n",
    "# Train the Multinomial Naive Bayes classifier\n",
    "nb_classifier = MultinomialNB()\n",
    "nb_classifier.fit(tfidf_train, train_data['sentiment'])\n",
    "\n",
    "# Predict on the validation set\n",
    "nb_pred = nb_classifier.predict(tfidf_val)\n",
    "\n",
    "# Set zero_division=0 to handle the warning\n",
    "zero_division_value = 0\n",
    "\n",
    "# Evaluate the model\n",
    "print(\"Multinomial Naive Bayes Classifier Report:\")\n",
    "print(classification_report(val_df['sentiment'], nb_pred, zero_division=zero_division_value))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "41182d43-59cd-4a03-90ce-9fd9808e8578",
   "metadata": {},
   "source": [
    "# Task 4: Tackling Class Imbalance Problem - Oversampling or Undersampling"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "7f864968-d6a4-4d97-a796-aad810694304",
   "metadata": {},
   "outputs": [],
   "source": [
    "from imblearn.over_sampling import RandomOverSampler\n",
    "from imblearn.under_sampling import RandomUnderSampler\n",
    "\n",
    "# Oversampling using RandomOverSampler\n",
    "over_sampler = RandomOverSampler(random_state=42)\n",
    "tfidf_train_over, train_over_sentiment = over_sampler.fit_resample(tfidf_train, train_data['sentiment'])\n",
    "\n",
    "# Undersampling using RandomUnderSampler\n",
    "under_sampler = RandomUnderSampler(random_state=42)\n",
    "tfidf_train_under, train_under_sentiment = under_sampler.fit_resample(tfidf_train, train_data['sentiment'])\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4426a98d-f2dc-4cbd-a15f-a0fc7c773f5a",
   "metadata": {},
   "source": [
    "# Task 5: Tree-Based Classifiers (Random Forest and XGBoost)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "664c42b8-5791-4a9c-af1d-d5a27f342c27",
   "metadata": {},
   "source": [
    "### One hot encode Target Variable"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "afa2a66d-acb0-4b7d-ab73-d73fa7423887",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Perform label encoding using pd.get_dummies on the target variable\n",
    "encoded_sentiment_train = pd.get_dummies(train_data['sentiment'])\n",
    "\n",
    "# Extract the TF-IDF features for the training data\n",
    "tfidf_train = tfidf_vectorizer.transform(train_data['reviews.text'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "490c2325-712a-42cd-b1c4-1fb050ba4d80",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Random Forest Classifier Report:\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0       1.00      1.00      1.00        93\n",
      "           1       1.00      0.99      1.00       158\n",
      "           2       1.00      1.00      1.00      3749\n",
      "\n",
      "   micro avg       1.00      1.00      1.00      4000\n",
      "   macro avg       1.00      1.00      1.00      4000\n",
      "weighted avg       1.00      1.00      1.00      4000\n",
      " samples avg       1.00      1.00      1.00      4000\n",
      "\n",
      "XGBoost Classifier Report:\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0       1.00      1.00      1.00        93\n",
      "           1       1.00      0.96      0.98       158\n",
      "           2       1.00      1.00      1.00      3749\n",
      "\n",
      "   micro avg       1.00      1.00      1.00      4000\n",
      "   macro avg       1.00      0.99      0.99      4000\n",
      "weighted avg       1.00      1.00      1.00      4000\n",
      " samples avg       1.00      1.00      1.00      4000\n",
      "\n"
     ]
    }
   ],
   "source": [
    "from sklearn.preprocessing import LabelEncoder\n",
    "from xgboost import XGBClassifier\n",
    "from sklearn.ensemble import RandomForestClassifier\n",
    "from sklearn.metrics import classification_report\n",
    "\n",
    "\n",
    "\n",
    "# Train the Random Forest Classifier\n",
    "rf_classifier = RandomForestClassifier(random_state=42)\n",
    "rf_classifier.fit(tfidf_train, encoded_sentiment_train)\n",
    "\n",
    "# Train the XGBoost Classifier\n",
    "xgb_classifier = XGBClassifier(random_state=42)\n",
    "xgb_classifier.fit(tfidf_train, encoded_sentiment_train)\n",
    "\n",
    "# Make predictions using the Random Forest Classifier\n",
    "rf_pred = rf_classifier.predict(tfidf_train)\n",
    "\n",
    "# Make predictions using the XGBoost Classifier\n",
    "xgb_pred = xgb_classifier.predict(tfidf_train)\n",
    "\n",
    "# Evaluate Random Forest Classifier\n",
    "print(\"Random Forest Classifier Report:\")\n",
    "print(classification_report(encoded_sentiment_train, rf_pred, zero_division=zero_division_value))\n",
    "\n",
    "# Evaluate XGBoost Classifier\n",
    "print(\"XGBoost Classifier Report:\")\n",
    "print(classification_report(encoded_sentiment_train, xgb_pred, zero_division=zero_division_value))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "59896b4a-c0cd-43f8-a405-8bec9de3082f",
   "metadata": {},
   "source": [
    "# Task 6: Model Evaluation with Sentiment Score Feature"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "4fe06c30-3651-4690-b071-070f4fd7d594",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'from textblob import TextBlob\\n\\ndef sentiment_scoring_function(text):\\n    return TextBlob(text).sentiment.polarity'"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from textblob import TextBlob\n",
    "\n",
    "def sentiment_scoring_function(text):\n",
    "    return TextBlob(text).sentiment.polarity\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "5abc7e91-9a95-44a2-bf92-622374c54274",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Multinomial Naive Bayes Classifier (with Sentiment Score) Report:\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0       0.00      0.00      0.00        13\n",
      "           1       0.00      0.00      0.00        36\n",
      "           2       0.94      1.00      0.97       751\n",
      "\n",
      "    accuracy                           0.94       800\n",
      "   macro avg       0.31      0.33      0.32       800\n",
      "weighted avg       0.88      0.94      0.91       800\n",
      "\n",
      "Random Forest Classifier (with Sentiment Score) Report:\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0       1.00      1.00      1.00        13\n",
      "           1       1.00      0.97      0.99        36\n",
      "           2       1.00      1.00      1.00       751\n",
      "\n",
      "    accuracy                           1.00       800\n",
      "   macro avg       1.00      0.99      1.00       800\n",
      "weighted avg       1.00      1.00      1.00       800\n",
      "\n",
      "XGBoost Classifier (with Sentiment Score) Report:\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0       1.00      1.00      1.00        13\n",
      "           1       1.00      0.97      0.99        36\n",
      "           2       1.00      1.00      1.00       751\n",
      "\n",
      "    accuracy                           1.00       800\n",
      "   macro avg       1.00      0.99      1.00       800\n",
      "weighted avg       1.00      1.00      1.00       800\n",
      "\n"
     ]
    }
   ],
   "source": [
    "from scipy.sparse import csr_matrix\n",
    "from scipy.sparse import hstack\n",
    "from sklearn.preprocessing import MinMaxScaler\n",
    "\n",
    "# Engineer a sentiment score feature based on the reviews for both training and validation data\n",
    "train_data['sentiment_score'] = train_data['reviews.text'].apply(sentiment_scoring_function)\n",
    "val_df['sentiment_score'] = val_df['reviews.text'].apply(sentiment_scoring_function)\n",
    "\n",
    "# Scale sentiment scores to positive scale for MultinomialNB\n",
    "scaler = MinMaxScaler(feature_range=(0, 1))\n",
    "train_data['sentiment_score_scaled'] = scaler.fit_transform(train_data[['sentiment_score']])\n",
    "val_df['sentiment_score_scaled'] = scaler.transform(val_df[['sentiment_score']])\n",
    "\n",
    "# Convert reviews to Tf-Idf scores\n",
    "tfidf_vectorizer = TfidfVectorizer()\n",
    "tfidf_train = tfidf_vectorizer.fit_transform(train_data['reviews.text'])\n",
    "tfidf_val = tfidf_vectorizer.transform(val_df['reviews.text'])\n",
    "\n",
    "# Convert sentiment scores into sparse format\n",
    "sparse_sentiment_train_scaled = csr_matrix(train_data['sentiment_score_scaled']).T\n",
    "sparse_sentiment_val_scaled = csr_matrix(val_df['sentiment_score_scaled']).T\n",
    "\n",
    "# Combine original Tf-Idf scores with scaled sentiment score\n",
    "tfidf_train_combined = hstack((tfidf_train, sparse_sentiment_train_scaled))\n",
    "tfidf_val_combined = hstack((tfidf_val, sparse_sentiment_val_scaled))\n",
    "\n",
    "# Convert categorical target to numerical form\n",
    "from sklearn.preprocessing import LabelEncoder\n",
    "\n",
    "le = LabelEncoder()\n",
    "\n",
    "train_data['sentiment'] = le.fit_transform(train_data['sentiment'])\n",
    "val_df['sentiment'] = le.transform(val_df['sentiment'])\n",
    "\n",
    "\n",
    "# Train and evaluate classifiers using combined feature representation\n",
    "nb_classifier_combined = MultinomialNB()\n",
    "nb_classifier_combined.fit(tfidf_train_combined, train_data['sentiment'])\n",
    "nb_pred_combined = nb_classifier_combined.predict(tfidf_val_combined)\n",
    "\n",
    "rf_classifier_combined = RandomForestClassifier(random_state=42)\n",
    "rf_classifier_combined.fit(tfidf_train_combined, train_data['sentiment'])\n",
    "rf_pred_combined = rf_classifier_combined.predict(tfidf_val_combined)\n",
    "\n",
    "# Expected: [0 1 2], got ['Negative' 'Neutral' 'Positive']\n",
    "xgb_classifier_combined = XGBClassifier(random_state=42)\n",
    "xgb_classifier_combined.fit(tfidf_train_combined, train_data['sentiment'])\n",
    "xgb_pred_combined = xgb_classifier_combined.predict(tfidf_val_combined)\n",
    "\n",
    "\n",
    "# Evaluate the models with combined features\n",
    "print(\"Multinomial Naive Bayes Classifier (with Sentiment Score) Report:\")\n",
    "print(classification_report(val_df['sentiment'], nb_pred_combined, zero_division=zero_division_value))\n",
    "\n",
    "print(\"Random Forest Classifier (with Sentiment Score) Report:\")\n",
    "print(classification_report(val_df['sentiment'], rf_pred_combined, zero_division=zero_division_value))\n",
    "\n",
    "print(\"XGBoost Classifier (with Sentiment Score) Report:\")\n",
    "print(classification_report(val_df['sentiment'], xgb_pred_combined, zero_division=zero_division_value))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9e7e4293-cf67-4898-bb06-9b373b1641a1",
   "metadata": {},
   "source": [
    "# Task 7: Topic Modeling with LDA or NMF"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "069b989c-943e-46a6-b4b3-638621cc9c1a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Topic 1: keeps, does, product, young, amazon, busy, good, love, expectations, tablet\n",
      "Topic 2: echo, alexa, love, great, music, home, use, easy, sound, product\n",
      "Topic 3: kindle, tablet, bought, love, gift, great, got, christmas, loves, read\n",
      "Topic 4: old, year, loves, tablet, bought, grandson, easy, daughter, great, son\n",
      "Topic 5: tablet, great, use, easy, price, good, kindle, kids, love, bought\n",
      "Topic 1: love, kindle, kids, books, read, reading, new, games, awesome, size\n",
      "Topic 2: loves, old, bought, year, daughter, tablet, gift, grandson, son, christmas\n",
      "Topic 3: great, tablet, price, good, works, product, kids, recommend, apps, buy\n",
      "Topic 4: easy, use, set, product, setup, fun, recommend, super, lightweight, navigate\n",
      "Topic 5: echo, alexa, music, home, amazon, plus, like, smart, sound, screen\n"
     ]
    }
   ],
   "source": [
    "from sklearn.feature_extraction.text import TfidfVectorizer\n",
    "from sklearn.decomposition import LatentDirichletAllocation, NMF\n",
    "\n",
    "# Vectorize the text data\n",
    "tfidf_vectorizer = TfidfVectorizer(max_df=0.95, min_df=2, stop_words='english')\n",
    "tfidf_train = tfidf_vectorizer.fit_transform(train_data['reviews.text'])\n",
    "tfidf_val = tfidf_vectorizer.transform(val_df['reviews.text'])\n",
    "\n",
    "# Get feature names\n",
    "feature_names = tfidf_vectorizer.get_feature_names_out()\n",
    "\n",
    "# Topic Modeling with Latent Dirichlet Allocation (LDA)\n",
    "lda_model = LatentDirichletAllocation(n_components=5, random_state=42)\n",
    "lda_model.fit(tfidf_train)\n",
    "lda_topics_train = lda_model.transform(tfidf_train)\n",
    "lda_topics_val = lda_model.transform(tfidf_val)\n",
    "\n",
    "# Topic Modeling with Non-Negative Matrix Factorization (NMF)\n",
    "nmf_model = NMF(n_components=5, random_state=42)\n",
    "nmf_model.fit(tfidf_train)\n",
    "nmf_topics_train = nmf_model.transform(tfidf_train)\n",
    "nmf_topics_val = nmf_model.transform(tfidf_val)\n",
    "\n",
    "# Display the top words for each topic in LDA\n",
    "for topic_idx, topic in enumerate(lda_model.components_):\n",
    "    top_words_indices = topic.argsort()[:-11:-1]\n",
    "    top_words = [feature_names[i] for i in top_words_indices]\n",
    "    print(f\"Topic {topic_idx+1}: {', '.join(top_words)}\")\n",
    "\n",
    "# Display the top words for each topic in NMF\n",
    "for topic_idx, topic in enumerate(nmf_model.components_):\n",
    "    top_words_indices = topic.argsort()[:-11:-1]\n",
    "    top_words = [feature_names[i] for i in top_words_indices]\n",
    "    print(f\"Topic {topic_idx+1}: {', '.join(top_words)}\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2eba3f9b-18fa-4830-a3e4-f82ceb9ec07d",
   "metadata": {},
   "source": [
    "# Task 8: Visualization of Sentiment Distribution"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "661c1863-247a-412c-aa05-d0e73b37ca3b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "# Plot the distribution of sentiment classes\n",
    "sentiment_counts = train_data['sentiment'].value_counts()\n",
    "plt.bar(sentiment_counts.index, sentiment_counts.values)\n",
    "plt.title('Sentiment Distribution')\n",
    "plt.xlabel('Sentiment')\n",
    "plt.ylabel('Count')\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e975beec-ca34-4d23-ab00-591b00a45fd2",
   "metadata": {},
   "source": [
    "### Word Frequency Distribution: \n",
    "This will give you a sense of the most common words appearing in your reviews. You might need to preprocess your text data (remove stop words, punctuation, etc.) to get meaningful insights."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "04a7bf52-606a-4054-95d0-15d30f85c340",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[nltk_data] Downloading package stopwords to\n",
      "[nltk_data]     C:\\Users\\templ\\AppData\\Roaming\\nltk_data...\n",
      "[nltk_data]   Package stopwords is already up-to-date!\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkQAAAHHCAYAAABeLEexAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/P9b71AAAACXBIWXMAAA9hAAAPYQGoP6dpAABNhUlEQVR4nO3dd1QU5/4/8PdSdqkLolRFQFECKhox0bUT0FXRaMR7YwUNajRw7caQGBW9CX41FpJYkptETKKxJGqMxIICFiTGhl0sEVFpNlhB6fP7w8P8XEEFBBac9+ucPYd55pmZzyy7y5uZZ2ZlgiAIICIiIpIwPV0XQERERKRrDEREREQkeQxEREREJHkMRERERCR5DEREREQkeQxEREREJHkMRERERCR5DEREREQkeQxEREREJHkMRESviLi4OMhkMsTFxem6FHoJ8+bNg0wmq5Vt9ezZEz179hSnS19Dv/76a61sf/To0XB2dq6VbRG9CAMRUSVs2rQJMpkMW7duLTOvbdu2kMlkiI2NLTOvadOm6Ny5c22U+EKRkZGQyWTlPj766CNdl/dKefq5NjIygoODA9RqNb788ks8ePCgWraTmpqKefPmITExsVrWV53qcm1ETzLQdQFE9UnXrl0BAIcOHcI777wjtms0Gpw9exYGBgaIj4+Ht7e3OO/GjRu4ceMGhg4dWuv1Ps/8+fPh4uKi1da6dWsdVfNqK32uCwsLkZ6ejri4OEyZMgVLly7F9u3b4enpKfadPXt2pYNpamoqwsLC4OzsjHbt2lV4uT179lRqO1XxvNr+97//oaSkpMZrIKoIBiKiSnBwcICLiwsOHTqk1Z6QkABBEPCvf/2rzLzS6dIwVVWCICAvLw/GxsYvtZ5Sffv2RYcOHSrUNy8vD3K5HHp6PKhcFU8/16GhoYiJiUH//v3x9ttv48KFC+Lv1cDAAAYGNfvR/PDhQ5iYmEAul9fodl7E0NBQp9snehI/3YgqqWvXrjh58iQePXoktsXHx6NVq1bo27cv/vrrL63/euPj4yGTydClSxcAQFFRERYsWIDmzZtDoVDA2dkZH3/8MfLz87W24+zsjP79+2P37t3o0KEDjI2N8c033wAAbt68iUGDBsHU1BQ2NjaYOnVqmeWrqnQcyYYNGzB79mw0btwYJiYm0Gg0AIAjR46gT58+sLCwgImJCXr06IH4+Pgy6zl06BDeeOMNGBkZoXnz5vjmm2/KjI9JTk6GTCZDZGRkmeVlMhnmzZun1Xbr1i289957sLW1hUKhQKtWrfDDDz+UW/+mTZvw2WefoUmTJjAyMoKPjw+uXLlSZjtHjhxBv3790KBBA5iamsLT0xMREREAgDVr1kAmk+HkyZNllvv888+hr6+PW7duvfA5Lc9bb72FTz/9FNevX8fPP/8stpc3hig6Ohpdu3aFpaUlzMzM4Obmho8//ljc3zfeeAMAMGbMGPH0XOlz2rNnT7Ru3RrHjx9H9+7dYWJiIi779BiiUsXFxfj4449hZ2cHU1NTvP3227hx44ZWH2dnZ4wePbrMsk+u80W1lTeGKDc3F9OnT4ejoyMUCgXc3NzwxRdfQBAErX4ymQwhISHYtm0bWrduLb4edu3aVf4TTvQCPEJEVEldu3bFTz/9hCNHjogf/PHx8ejcuTM6d+6M7OxsnD17VjwNEh8fj9deew0NGzYEAIwdOxZr167FkCFDMH36dBw5cgTh4eG4cOFCmbFJSUlJGDZsGN5//32MGzcObm5uePToEXx8fJCSkoJJkybBwcEBP/30E2JiYiq1H9nZ2bhz545WW6NGjcSfFyxYALlcjhkzZiA/Px9yuRwxMTHo27cvvLy8MHfuXOjp6WHNmjV46623cPDgQbz55psAgDNnzqB3796wtrbGvHnzUFRUhLlz58LW1rZSNT4pIyMDnTp1Ev8QWltbY+fOnQgKCoJGo8GUKVO0+i9cuBB6enqYMWMGsrOzsWjRIowYMQJHjhwR+0RHR6N///6wt7fH5MmTYWdnhwsXLmDHjh2YPHkyhgwZguDgYKxbtw6vv/661vrXrVuHnj17onHjxlXep1GjRuHjjz/Gnj17MG7cuHL7nDt3Dv3794enpyfmz58PhUKBK1euiCHU3d0d8+fPx5w5czB+/Hh069YNALTGrN29exd9+/bF0KFDMXLkyBf+Hj777DPIZDLMmjULmZmZWL58OXx9fZGYmFipI5QVqe1JgiDg7bffRmxsLIKCgtCuXTvs3r0bM2fOxK1bt7Bs2TKt/ocOHcKWLVvwwQcfwNzcHF9++SX8/f2RkpIivt+IKkwgoko5d+6cAEBYsGCBIAiCUFhYKJiamgpr164VBEEQbG1thRUrVgiCIAgajUbQ19cXxo0bJwiCICQmJgoAhLFjx2qtc8aMGQIAISYmRmxzcnISAAi7du3S6rt8+XIBgLBp0yaxLTc3V3B1dRUACLGxsc+tf82aNQKAch+CIAixsbECAKFZs2bCw4cPxeVKSkqEFi1aCGq1WigpKRHbHz58KLi4uAi9evUS2wYNGiQYGRkJ169fF9vOnz8v6OvrC09+7Fy7dk0AIKxZs6ZMnQCEuXPnitNBQUGCvb29cOfOHa1+Q4cOFSwsLMRaS+t3d3cX8vPzxX4RERECAOHMmTOCIAhCUVGR4OLiIjg5OQn379/XWueT+zds2DDBwcFBKC4uFttOnDjxzLqfVPpcHz169Jl9LCwshNdff12cnjt3rtZztGzZMgGAcPv27Weu4+jRo8+sp0ePHgIAYfXq1eXO69Gjhzhd+tw1btxY0Gg0YvumTZsEAEJERITY5uTkJAQGBr5wnc+rLTAwUHBychKnt23bJgAQ/vvf/2r1GzJkiCCTyYQrV66IbQAEuVyu1Xbq1CkBgPDVV1+V2RbRi/CUGVElubu7o2HDhuLYoFOnTiE3N1f8r7dz587if+8JCQkoLi4Wxw/9+eefAIBp06ZprXP69OkAgKioKK12FxcXqNVqrbY///wT9vb2GDJkiNhmYmKC8ePHV2o/VqxYgejoaK3HkwIDA7WOBiQmJuLy5csYPnw47t69izt37uDOnTvIzc2Fj48PDhw4gJKSEhQXF2P37t0YNGgQmjZtqvW8Pb0vFSUIAn777TcMGDAAgiCI275z5w7UajWys7Nx4sQJrWXGjBmjNUam9OjEP//8AwA4efIkrl27hilTpsDS0lJr2SdPWQUEBCA1NVXr6sF169bB2NgY/v7+VdqfJ5mZmT33arPS2n7//fcqD0BWKBQYM2ZMhfsHBATA3NxcnB4yZAjs7e3F129N+fPPP6Gvr49JkyZptU+fPh2CIGDnzp1a7b6+vmjevLk47enpCaVSKf6OiSqDp8yIKkkmk6Fz585iAIiPj4eNjQ1cXV0BPA5EX3/9NQCIwag0EF2/fh16enpi31J2dnawtLTE9evXtdqfvgqsdB2urq5lxpm4ublVaj/efPPN5w6qfnrbly9fBvA4KD1LdnY28vPz8ejRI7Ro0aLMfDc3tyr9Ub19+zaysrLw7bff4ttvvy23T2Zmptb0k2EMABo0aAAAuH//PgDg6tWrAF58ZV2vXr1gb2+PdevWwcfHByUlJfjll18wcOBArdBQVTk5ObCxsXnm/HfffRffffcdxo4di48++gg+Pj4YPHgwhgwZUuFB7o0bN67UAOqnf3cymQyurq5ITk6u8Dqq4vr163BwcCjzvLq7u4vzn/T07xh4/Hsu/R0TVQYDEVEVdO3aFX/88QfOnDkjjh8q1blzZ3HMw6FDh+Dg4IBmzZppLV/RG+9V1xVlVfH0tkuPTixevPiZl3abmZlVanD3s56H4uLicrc9cuTIZwayJy9dBwB9ff1y+wlPDc59EX19fQwfPhz/+9//sHLlSsTHxyM1NRUjR46s1HrKc/PmTWRnZ5cJyE8yNjbGgQMHEBsbi6ioKOzatQsbN27EW2+9hT179jxzP59eR3V73u+uIjVVh+r6HRMBDEREVfLk/Yji4+O1BvR6eXlBoVAgLi5OvIKplJOTE0pKSnD58mXxv17g8YDhrKwsODk5vXDbTk5OOHv2LARB0PqjlJSUVA179mylpyaUSiV8fX2f2c/a2hrGxsbiEaUnPV1j6VGbrKwsrfanjwRYW1vD3NwcxcXFz912ZZTuz9mzZ1+4zoCAACxZsgR//PEHdu7cCWtr6yqf/nvSTz/9BAAvXJeenh58fHzg4+ODpUuX4vPPP8cnn3yC2NhY+Pr6VvudrZ/+3QmCgCtXrmiFzgYNGpT5vQGPf3dP/gNQmdqcnJywd+9ePHjwQOso0cWLF8X5RDWFY4iIqqBDhw4wMjLCunXrcOvWLa0jRAqFAu3bt8eKFSuQm5urdf+h0nC0fPlyrfUtXboUAODn5/fCbffr1w+pqalaX6/w8OHDZ55Kqi5eXl5o3rw5vvjiC+Tk5JSZf/v2bQCP/2tXq9XYtm0bUlJSxPkXLlzA7t27tZZRKpVo1KgRDhw4oNW+cuVKrWl9fX34+/vjt99+w9mzZ5+57cpo3749XFxcsHz58jJ/2J8+wuDp6QlPT0989913+O233zB06NCXvldQTEwMFixYABcXF4wYMeKZ/e7du1emrfQIXenROFNTUwBlg2VV/fjjj1rjmn799VekpaWhb9++Ylvz5s3x119/oaCgQGzbsWNHmcvzK1Nbv379UFxcLJ5yLrVs2TLIZDKt7RNVNx4hIqoCuVyON954AwcPHoRCoYCXl5fW/M6dO2PJkiUAtG/I2LZtWwQGBuLbb79FVlYWevTogb///htr167FoEGDtO5w/Szjxo3D119/jYCAABw/fhz29vb46aefYGJiUr07+RQ9PT1899136Nu3L1q1aoUxY8agcePGuHXrFmJjY6FUKvHHH38AAMLCwrBr1y5069YNH3zwAYqKivDVV1+hVatWOH36tNZ6x44di4ULF2Ls2LHo0KEDDhw4gEuXLpXZ/sKFCxEbG4uOHTti3Lhx8PDwwL1793DixAns3bu33ODwov1ZtWoVBgwYgHbt2mHMmDGwt7fHxYsXce7cuTLhLSAgADNmzACASp8u27lzJy5evIiioiJkZGQgJiYG0dHRcHJywvbt22FkZPTMZefPn48DBw7Az88PTk5OyMzMxMqVK9GkSRPxtdW8eXNYWlpi9erVMDc3h6mpKTp27FjuGLSKsLKyQteuXTFmzBhkZGRg+fLlcHV11bo1wNixY/Hrr7+iT58++Pe//42rV6/i559/1hrkXNnaBgwYAG9vb3zyySdITk5G27ZtsWfPHvz++++YMmVKmXUTVSvdXeBGVL+FhoYKAITOnTuXmbdlyxYBgGBubi4UFRVpzSssLBTCwsIEFxcXwdDQUHB0dBRCQ0OFvLw8rX5OTk6Cn59fudu+fv268PbbbwsmJiZCo0aNhMmTJwu7du2q1GX3z7oUvPTS682bN5c7/+TJk8LgwYOFhg0bCgqFQnBychL+/e9/C/v27dPqt3//fsHLy0uQy+VCs2bNhNWrV5e5pFwQHl+2HxQUJFhYWAjm5ubCv//9byEzM7PMZfeCIAgZGRlCcHCw4OjoKBgaGgp2dnaCj4+P8O23376w/mdd4n/o0CGhV69egrm5uWBqaip4enqWe9l2WlqaoK+vL7Rs2bLc56U8T9/iQC6XC3Z2dkKvXr2EiIgIrUvbSz39HO3bt08YOHCg4ODgIMjlcsHBwUEYNmyYcOnSJa3lfv/9d8HDw0MwMDDQ2s8ePXoIrVq1Kre+Z112/8svvwihoaGCjY2NYGxsLPj5+WndQqHUkiVLhMaNGwsKhULo0qWLcOzYsTLrfF5tT192LwiC8ODBA2Hq1KmCg4ODYGhoKLRo0UJYvHix1q0QBOHxZffBwcFlanrW7QCIXkQmCBx9RkS1Y968eQgLC6uXg17v3LkDe3t7zJkzB59++qmuyyGiasYxREREFRAZGYni4mKMGjVK16UQUQ3gGCIioueIiYnB+fPn8dlnn2HQoEFlvnuLiF4NDERERM8xf/58HD58GF26dMFXX32l63KIqIZwDBERERFJHscQERERkeQxEBEREZHkcQxRBZSUlCA1NRXm5ubVfot8IiIiqhmCIODBgwdwcHB44ZchMxBVQGpqKhwdHXVdBhEREVXBjRs30KRJk+f2YSCqgNIvGbxx4waUSqWOqyEiIqKK0Gg0cHR01Pqy4GdhIKqA0tNkSqWSgYiIiKieqchwFw6qJiIiIsljICIiIiLJYyAiIiIiyWMgIiIiIsnTaSBatWoVPD09xcHKKpUKO3fuFOf37NkTMplM6zFhwgStdaSkpMDPzw8mJiawsbHBzJkzUVRUpNUnLi4O7du3h0KhgKurKyIjI2tj94iIiKie0OlVZk2aNMHChQvRokULCIKAtWvXYuDAgTh58iRatWoFABg3bhzmz58vLmNiYiL+XFxcDD8/P9jZ2eHw4cNIS0tDQEAADA0N8fnnnwMArl27Bj8/P0yYMAHr1q3Dvn37MHbsWNjb20OtVtfuDhMREVGdVOe+3NXKygqLFy9GUFAQevbsiXbt2mH58uXl9t25cyf69++P1NRU2NraAgBWr16NWbNm4fbt25DL5Zg1axaioqJw9uxZcbmhQ4ciKysLu3btqlBNGo0GFhYWyM7O5mX3RERE9URl/n7XmTFExcXF2LBhA3Jzc6FSqcT2devWoVGjRmjdujVCQ0Px8OFDcV5CQgLatGkjhiEAUKvV0Gg0OHfunNjH19dXa1tqtRoJCQk1vEdERERUX+j8xoxnzpyBSqVCXl4ezMzMsHXrVnh4eAAAhg8fDicnJzg4OOD06dOYNWsWkpKSsGXLFgBAenq6VhgCIE6np6c/t49Go8GjR49gbGxcpqb8/Hzk5+eL0xqNpvp2mIiIiOocnQciNzc3JCYmIjs7G7/++isCAwOxf/9+eHh4YPz48WK/Nm3awN7eHj4+Prh69SqaN29eYzWFh4cjLCysxtZPREREdYvOT5nJ5XK4urrCy8sL4eHhaNu2LSIiIsrt27FjRwDAlStXAAB2dnbIyMjQ6lM6bWdn99w+SqWy3KNDABAaGors7GzxcePGjarvIBEREdV5Og9ETyspKdE6XfWkxMREAIC9vT0AQKVS4cyZM8jMzBT7REdHQ6lUiqfdVCoV9u3bp7We6OhorXFKT1MoFOKtAPj9ZURERK8+nZ4yCw0NRd++fdG0aVM8ePAA69evR1xcHHbv3o2rV69i/fr16NevHxo2bIjTp09j6tSp6N69Ozw9PQEAvXv3hoeHB0aNGoVFixYhPT0ds2fPRnBwMBQKBQBgwoQJ+Prrr/Hhhx/ivffeQ0xMDDZt2oSoqChd7joRERHVIToNRJmZmQgICEBaWhosLCzg6emJ3bt3o1evXrhx4wb27t2L5cuXIzc3F46OjvD398fs2bPF5fX19bFjxw5MnDgRKpUKpqamCAwM1LpvkYuLC6KiojB16lRERESgSZMm+O6773gPIiIiIhLVufsQ1UW8DxEREVH9U5m/3zq/yowA54/q3um75IV+ui6BiIio1tS5QdVEREREtY2BiIiIiCSPgYiIiIgkj4GIiIiIJI+BiIiIiCSPgYiIiIgkj4GIiIiIJI+BiIiIiCSPgYiIiIgkj4GIiIiIJI+BiIiIiCSPgYiIiIgkj4GIiIiIJI+BiIiIiCSPgYiIiIgkj4GIiIiIJI+BiIiIiCSPgYiIiIgkj4GIiIiIJI+BiIiIiCSPgYiIiIgkj4GIiIiIJI+BiIiIiCSPgYiIiIgkj4GIiIiIJI+BiIiIiCSPgYiIiIgkj4GIiIiIJI+BiIiIiCSPgYiIiIgkj4GIiIiIJI+BiIiIiCSPgYiIiIgkj4GIiIiIJI+BiIiIiCSPgYiIiIgkj4GIiIiIJI+BiIiIiCSPgYiIiIgkj4GIiIiIJE+ngWjVqlXw9PSEUqmEUqmESqXCzp07xfl5eXkIDg5Gw4YNYWZmBn9/f2RkZGitIyUlBX5+fjAxMYGNjQ1mzpyJoqIirT5xcXFo3749FAoFXF1dERkZWRu7R0RERPWETgNRkyZNsHDhQhw/fhzHjh3DW2+9hYEDB+LcuXMAgKlTp+KPP/7A5s2bsX//fqSmpmLw4MHi8sXFxfDz80NBQQEOHz6MtWvXIjIyEnPmzBH7XLt2DX5+fvD29kZiYiKmTJmCsWPHYvfu3bW+v0RERFQ3yQRBEHRdxJOsrKywePFiDBkyBNbW1li/fj2GDBkCALh48SLc3d2RkJCATp06YefOnejfvz9SU1Nha2sLAFi9ejVmzZqF27dvQy6XY9asWYiKisLZs2fFbQwdOhRZWVnYtWtXhWrSaDSwsLBAdnY2lEplte+z80dR1b7Ol5W80E/XJRAREb2Uyvz9rjNjiIqLi7Fhwwbk5uZCpVLh+PHjKCwshK+vr9jntddeQ9OmTZGQkAAASEhIQJs2bcQwBABqtRoajUY8ypSQkKC1jtI+pesoT35+PjQajdaDiIiIXl06D0RnzpyBmZkZFAoFJkyYgK1bt8LDwwPp6emQy+WwtLTU6m9ra4v09HQAQHp6ulYYKp1fOu95fTQaDR49elRuTeHh4bCwsBAfjo6O1bGrREREVEfpPBC5ubkhMTERR44cwcSJExEYGIjz58/rtKbQ0FBkZ2eLjxs3bui0HiIiIqpZBrouQC6Xw9XVFQDg5eWFo0ePIiIiAu+++y4KCgqQlZWldZQoIyMDdnZ2AAA7Ozv8/fffWusrvQrtyT5PX5mWkZEBpVIJY2PjcmtSKBRQKBTVsn9ERERU9+n8CNHTSkpKkJ+fDy8vLxgaGmLfvn3ivKSkJKSkpEClUgEAVCoVzpw5g8zMTLFPdHQ0lEolPDw8xD5PrqO0T+k6iIiIiHR6hCg0NBR9+/ZF06ZN8eDBA6xfvx5xcXHYvXs3LCwsEBQUhGnTpsHKygpKpRL/+c9/oFKp0KlTJwBA79694eHhgVGjRmHRokVIT0/H7NmzERwcLB7hmTBhAr7++mt8+OGHeO+99xATE4NNmzYhKqruXdlFREREuqHTQJSZmYmAgACkpaXBwsICnp6e2L17N3r16gUAWLZsGfT09ODv74/8/Hyo1WqsXLlSXF5fXx87duzAxIkToVKpYGpqisDAQMyfP1/s4+LigqioKEydOhURERFo0qQJvvvuO6jV6lrfXyIiIqqb6tx9iOoi3oeIiIio/qmX9yEiIiIi0hUGIiIiIpI8BiIiIiKSPAYiIiIikjwGIiIiIpI8BiIiIiKSPAYiIiIikjwGIiIiIpI8BiIiIiKSPAYiIiIikjwGIiIiIpI8BiIiIiKSPAYiIiIikjwGIiIiIpI8BiIiIiKSPAYiIiIikjwGIiIiIpI8BiIiIiKSPAYiIiIikjwGIiIiIpI8BiIiIiKSPAYiIiIikjwGIiIiIpI8BiIiIiKSPAYiIiIikjwGIiIiIpI8BiIiIiKSPAYiIiIikjwGIiIiIpI8BiIiIiKSPAYiIiIikjwGIiIiIpI8BiIiIiKSPAYiIiIikjwGIiIiIpI8BiIiIiKSPAYiIiIikjwGIiIiIpI8BiIiIiKSPAYiIiIikjydBqLw8HC88cYbMDc3h42NDQYNGoSkpCStPj179oRMJtN6TJgwQatPSkoK/Pz8YGJiAhsbG8ycORNFRUVafeLi4tC+fXsoFAq4uroiMjKypnePiIiI6gmdBqL9+/cjODgYf/31F6Kjo1FYWIjevXsjNzdXq9+4ceOQlpYmPhYtWiTOKy4uhp+fHwoKCnD48GGsXbsWkZGRmDNnjtjn2rVr8PPzg7e3NxITEzFlyhSMHTsWu3fvrrV9JSIiorrLQJcb37Vrl9Z0ZGQkbGxscPz4cXTv3l1sNzExgZ2dXbnr2LNnD86fP4+9e/fC1tYW7dq1w4IFCzBr1izMmzcPcrkcq1evhouLC5YsWQIAcHd3x6FDh7Bs2TKo1eqa20EiIiKqF+rUGKLs7GwAgJWVlVb7unXr0KhRI7Ru3RqhoaF4+PChOC8hIQFt2rSBra2t2KZWq6HRaHDu3Dmxj6+vr9Y61Wo1EhISyq0jPz8fGo1G60FERESvLp0eIXpSSUkJpkyZgi5duqB169Zi+/Dhw+Hk5AQHBwecPn0as2bNQlJSErZs2QIASE9P1wpDAMTp9PT05/bRaDR49OgRjI2NteaFh4cjLCys2veRiIiI6qY6E4iCg4Nx9uxZHDp0SKt9/Pjx4s9t2rSBvb09fHx8cPXqVTRv3rxGagkNDcW0adPEaY1GA0dHxxrZFhEREelenThlFhISgh07diA2NhZNmjR5bt+OHTsCAK5cuQIAsLOzQ0ZGhlaf0unScUfP6qNUKsscHQIAhUIBpVKp9SAiIqJXl04DkSAICAkJwdatWxETEwMXF5cXLpOYmAgAsLe3BwCoVCqcOXMGmZmZYp/o6GgolUp4eHiIffbt26e1nujoaKhUqmraEyIiIqrPdBqIgoOD8fPPP2P9+vUwNzdHeno60tPT8ejRIwDA1atXsWDBAhw/fhzJycnYvn07AgIC0L17d3h6egIAevfuDQ8PD4waNQqnTp3C7t27MXv2bAQHB0OhUAAAJkyYgH/++QcffvghLl68iJUrV2LTpk2YOnWqzvadiIiI6g6dBqJVq1YhOzsbPXv2hL29vfjYuHEjAEAul2Pv3r3o3bs3XnvtNUyfPh3+/v74448/xHXo6+tjx44d0NfXh0qlwsiRIxEQEID58+eLfVxcXBAVFYXo6Gi0bdsWS5YswXfffcdL7omIiAgAIBMEQdB1EXWdRqOBhYUFsrOza2Q8kfNHUdW+zpeVvNBP1yUQERG9lMr8/a4Tg6qJiIiIdImBiIiIiCSPgYiIiIgkj4GIiIiIJI+BiIiIiCSPgYiIiIgkj4GIiIiIJI+BiIiIiCSPgYiIiIgkj4GIiIiIJI+BiIiIiCSPgYiIiIgkj4GIiIiIJI+BiIiIiCSPgYiIiIgkj4GIiIiIJI+BiIiIiCSPgYiIiIgkj4GIiIiIJI+BiIiIiCSPgYiIiIgkj4GIiIiIJI+BiIiIiCSPgYiIiIgkj4GIiIiIJI+BiIiIiCSPgYiIiIgkj4GIiIiIJI+BiIiIiCSPgYiIiIgkj4GIiIiIJK9Kgeiff/6p7jqIiIiIdKZKgcjV1RXe3t74+eefkZeXV901EREREdWqKgWiEydOwNPTE9OmTYOdnR3ef/99/P3339VdGxEREVGtqFIgateuHSIiIpCamooffvgBaWlp6Nq1K1q3bo2lS5fi9u3b1V0nERERUY15qUHVBgYGGDx4MDZv3oz/+7//w5UrVzBjxgw4OjoiICAAaWlp1VUnERERUY15qUB07NgxfPDBB7C3t8fSpUsxY8YMXL16FdHR0UhNTcXAgQOrq04iIiKiGmNQlYWWLl2KNWvWICkpCf369cOPP/6Ifv36QU/vcb5ycXFBZGQknJ2dq7NWIiIiohpRpUC0atUqvPfeexg9ejTs7e3L7WNjY4Pvv//+pYojIiIiqg1VCkSXL19+YR+5XI7AwMCqrJ6IiIioVlVpDNGaNWuwefPmMu2bN2/G2rVrK7ye8PBwvPHGGzA3N4eNjQ0GDRqEpKQkrT55eXkIDg5Gw4YNYWZmBn9/f2RkZGj1SUlJgZ+fH0xMTGBjY4OZM2eiqKhIq09cXBzat28PhUIBV1dXREZGVnyHiYiI6JVWpUAUHh6ORo0alWm3sbHB559/XuH17N+/H8HBwfjrr78QHR2NwsJC9O7dG7m5uWKfqVOn4o8//sDmzZuxf/9+pKamYvDgweL84uJi+Pn5oaCgAIcPH8batWsRGRmJOXPmiH2uXbsGPz8/eHt7IzExEVOmTMHYsWOxe/fuquw+ERERvWJkgiAIlV3IyMgIFy9eLDNoOjk5Ge7u7nj06FGVirl9+zZsbGywf/9+dO/eHdnZ2bC2tsb69esxZMgQAMDFixfh7u6OhIQEdOrUCTt37kT//v2RmpoKW1tbAMDq1asxa9Ys3L59G3K5HLNmzUJUVBTOnj0rbmvo0KHIysrCrl27XliXRqOBhYUFsrOzoVQqq7Rvz+P8UVS1r/NlJS/003UJREREL6Uyf7+rdITIxsYGp0+fLtN+6tQpNGzYsCqrBABkZ2cDAKysrAAAx48fR2FhIXx9fcU+r732Gpo2bYqEhAQAQEJCAtq0aSOGIQBQq9XQaDQ4d+6c2OfJdZT2KV3H0/Lz86HRaLQeRERE9OqqUiAaNmwYJk2ahNjYWBQXF6O4uBgxMTGYPHkyhg4dWqVCSkpKMGXKFHTp0gWtW7cGAKSnp0Mul8PS0lKrr62tLdLT08U+T4ah0vml857XR6PRlHs0Kzw8HBYWFuLD0dGxSvtERERE9UOVrjJbsGABkpOT4ePjAwODx6soKSlBQEBApcYQPSk4OBhnz57FoUOHqrR8dQoNDcW0adPEaY1Gw1BERET0CqtSIJLL5di4cSMWLFiAU6dOwdjYGG3atIGTk1OViggJCcGOHTtw4MABNGnSRGy3s7NDQUEBsrKytI4SZWRkwM7OTuzz9BfLll6F9mSfp69My8jIgFKphLGxcZl6FAoFFApFlfaFiIiI6p+X+uqOli1b4l//+hf69+9fpTAkCAJCQkKwdetWxMTEwMXFRWu+l5cXDA0NsW/fPrEtKSkJKSkpUKlUAACVSoUzZ84gMzNT7BMdHQ2lUgkPDw+xz5PrKO1Tug4iIiKStiodISouLkZkZCT27duHzMxMlJSUaM2PiYmp0HqCg4Oxfv16/P777zA3NxfH/FhYWMDY2BgWFhYICgrCtGnTYGVlBaVSif/85z9QqVTo1KkTAKB3797w8PDAqFGjsGjRIqSnp2P27NkIDg4Wj/JMmDABX3/9NT788EO89957iImJwaZNmxAVVfeu7iIiIqLaV6VANHnyZERGRsLPzw+tW7eGTCar0sZXrVoFAOjZs6dW+5o1azB69GgAwLJly6Cnpwd/f3/k5+dDrVZj5cqVYl99fX3s2LEDEydOhEqlgqmpKQIDAzF//nyxj4uLC6KiojB16lRERESgSZMm+O6776BWq6tUNxEREb1aqnQfokaNGolf6CoFvA8RERFR/VPj9yGSy+VwdXWtUnFEREREdU2VAtH06dMRERGBKhxcIiIiIqpzqjSG6NChQ4iNjcXOnTvRqlUrGBoaas3fsmVLtRRHREREVBuqFIgsLS3xzjvvVHctRERERDpRpUC0Zs2a6q6DiIiISGeqfGPGoqIi7N27F9988w0ePHgAAEhNTUVOTk61FUdERERUG6p0hOj69evo06cPUlJSkJ+fj169esHc3Bz/93//h/z8fKxevbq66yQiIiKqMVU6QjR58mR06NAB9+/f1/ousHfeeafMV2QQERER1XVVOkJ08OBBHD58GHK5XKvd2dkZt27dqpbCiIiIiGpLlY4QlZSUoLi4uEz7zZs3YW5u/tJFEREREdWmKgWi3r17Y/ny5eK0TCZDTk4O5s6dK5mv8yAiIqJXR5VOmS1ZsgRqtRoeHh7Iy8vD8OHDcfnyZTRq1Ai//PJLdddIREREVKOqFIiaNGmCU6dOYcOGDTh9+jRycnIQFBSEESNGaA2yJiIiIqoPqhSIAMDAwAAjR46szlqIiIiIdKJKgejHH3987vyAgIAqFUNERESkC1UKRJMnT9aaLiwsxMOHDyGXy2FiYsJARERERPVKla4yu3//vtYjJycHSUlJ6Nq1KwdVExERUb1T5e8ye1qLFi2wcOHCMkePiIiIiOq6agtEwOOB1qmpqdW5SiIiIqIaV6UxRNu3b9eaFgQBaWlp+Prrr9GlS5dqKYyIiIiotlQpEA0aNEhrWiaTwdraGm+99RaWLFlSHXURERER1ZoqBaKSkpLqroOIiIhIZ6p1DBERERFRfVSlI0TTpk2rcN+lS5dWZRNEREREtaZKgejkyZM4efIkCgsL4ebmBgC4dOkS9PX10b59e7GfTCarniqJiIiIalCVAtGAAQNgbm6OtWvXokGDBgAe36xxzJgx6NatG6ZPn16tRRIRERHVpCqNIVqyZAnCw8PFMAQADRo0wH//+19eZUZERET1TpUCkUajwe3bt8u03759Gw8ePHjpooiIiIhqU5UC0TvvvIMxY8Zgy5YtuHnzJm7evInffvsNQUFBGDx4cHXXSERERFSjqjSGaPXq1ZgxYwaGDx+OwsLCxysyMEBQUBAWL15crQUSERER1bQqBSITExOsXLkSixcvxtWrVwEAzZs3h6mpabUWR0RERFQbXurGjGlpaUhLS0OLFi1gamoKQRCqqy4iIiKiWlOlQHT37l34+PigZcuW6NevH9LS0gAAQUFBvOSeiIiI6p0qBaKpU6fC0NAQKSkpMDExEdvfffdd7Nq1q9qKIyIiIqoNVRpDtGfPHuzevRtNmjTRam/RogWuX79eLYURERER1ZYqHSHKzc3VOjJU6t69e1AoFC9dFBEREVFtqlIg6tatG3788UdxWiaToaSkBIsWLYK3t3e1FUdERERUG6p0ymzRokXw8fHBsWPHUFBQgA8//BDnzp3DvXv3EB8fX901EhEREdWoKh0hat26NS5duoSuXbti4MCByM3NxeDBg3Hy5Ek0b968umskIiIiqlGVPkJUWFiIPn36YPXq1fjkk09qoiYiIiKiWlXpI0SGhoY4ffp0tWz8wIEDGDBgABwcHCCTybBt2zat+aNHj4ZMJtN69OnTR6vPvXv3MGLECCiVSlhaWiIoKAg5OTlafU6fPo1u3brByMgIjo6OWLRoUbXUT0RERK+GKp0yGzlyJL7//vuX3nhubi7atm2LFStWPLNPnz59xDtip6Wl4ZdfftGaP2LECJw7dw7R0dHYsWMHDhw4gPHjx4vzNRoNevfuDScnJxw/fhyLFy/GvHnz8O233750/URERPRqqNKg6qKiIvzwww/Yu3cvvLy8ynyH2dKlSyu0nr59+6Jv377P7aNQKGBnZ1fuvAsXLmDXrl04evQoOnToAAD46quv0K9fP3zxxRdwcHDAunXrUFBQgB9++AFyuRytWrVCYmIili5dqhWciIiISLoqdYTon3/+QUlJCc6ePYv27dvD3Nwcly5dwsmTJ8VHYmJitRYYFxcHGxsbuLm5YeLEibh79644LyEhAZaWlmIYAgBfX1/o6enhyJEjYp/u3btDLpeLfdRqNZKSknD//v1yt5mfnw+NRqP1ICIioldXpY4QtWjRAmlpaYiNjQXw+Ks6vvzyS9ja2tZIcX369MHgwYPh4uKCq1ev4uOPP0bfvn2RkJAAfX19pKenw8bGRmsZAwMDWFlZIT09HQCQnp4OFxcXrT6l9aanp6NBgwZlthseHo6wsLAa2SciIiKqeyoViJ7+NvudO3ciNze3Wgt60tChQ8Wf27RpA09PTzRv3hxxcXHw8fGpse2GhoZi2rRp4rRGo4Gjo2ONbY+IiIh0q0qDqks9HZBqWrNmzdCoUSNcuXIFAGBnZ4fMzEytPkVFRbh375447sjOzg4ZGRlafUqnnzU2SaFQQKlUaj2IiIjo1VWpQFR66fvTbbXl5s2buHv3Luzt7QEAKpUKWVlZOH78uNgnJiYGJSUl6Nixo9jnwIEDKCwsFPtER0fDzc2t3NNlREREJD2VPmU2evRo8Qtc8/LyMGHChDJXmW3ZsqVC68vJyRGP9gDAtWvXkJiYCCsrK1hZWSEsLAz+/v6ws7PD1atX8eGHH8LV1RVqtRoA4O7ujj59+mDcuHFYvXo1CgsLERISgqFDh8LBwQEAMHz4cISFhSEoKAizZs3C2bNnERERgWXLllVm14mIiOgVVqlAFBgYqDU9cuTIl9r4sWPHtL4MtnTcTmBgIFatWoXTp09j7dq1yMrKgoODA3r37o0FCxaIgQwA1q1bh5CQEPj4+EBPTw/+/v748ssvxfkWFhbYs2cPgoOD4eXlhUaNGmHOnDm85J6IiIhEMqG2BwLVQxqNBhYWFsjOzq6R8UTOH0VV+zpfVvJCP12XQERE9FIq8/f7pQZVExEREb0KGIiIiIhI8hiIiIiISPIYiIiIiEjyGIiIiIhI8hiIiIiISPIYiIiIiEjyGIiIiIhI8hiIiIiISPIYiIiIiEjyGIiIiIhI8hiIiIiISPIYiIiIiEjyGIiIiIhI8hiIiIiISPIYiIiIiEjyGIiIiIhI8hiIiIiISPIYiIiIiEjyGIiIiIhI8hiIiIiISPIYiIiIiEjyGIiIiIhI8hiIiIiISPIYiIiIiEjyGIiIiIhI8hiIiIiISPIYiIiIiEjyGIiIiIhI8hiIiIiISPIYiIiIiEjyGIiIiIhI8hiIiIiISPIYiIiIiEjyGIiIiIhI8hiIiIiISPIYiIiIiEjyGIiIiIhI8hiIiIiISPIYiIiIiEjydBqIDhw4gAEDBsDBwQEymQzbtm3Tmi8IAubMmQN7e3sYGxvD19cXly9f1upz7949jBgxAkqlEpaWlggKCkJOTo5Wn9OnT6Nbt24wMjKCo6MjFi1aVNO7RkRERPWITgNRbm4u2rZtixUrVpQ7f9GiRfjyyy+xevVqHDlyBKamplCr1cjLyxP7jBgxAufOnUN0dDR27NiBAwcOYPz48eJ8jUaD3r17w8nJCcePH8fixYsxb948fPvttzW+f0RERFQ/yARBEHRdBADIZDJs3boVgwYNAvD46JCDgwOmT5+OGTNmAACys7Nha2uLyMhIDB06FBcuXICHhweOHj2KDh06AAB27dqFfv364ebNm3BwcMCqVavwySefID09HXK5HADw0UcfYdu2bbh48WKFatNoNLCwsEB2djaUSmW177vzR1HVvs6XlbzQT9clEBERvZTK/P2us2OIrl27hvT0dPj6+optFhYW6NixIxISEgAACQkJsLS0FMMQAPj6+kJPTw9HjhwR+3Tv3l0MQwCgVquRlJSE+/fvl7vt/Px8aDQarQcRERG9uupsIEpPTwcA2NraarXb2tqK89LT02FjY6M138DAAFZWVlp9ylvHk9t4Wnh4OCwsLMSHo6Pjy+8QERER1Vl1NhDpUmhoKLKzs8XHjRs3dF0SERER1aA6G4js7OwAABkZGVrtGRkZ4jw7OztkZmZqzS8qKsK9e/e0+pS3jie38TSFQgGlUqn1ICIioldXnQ1ELi4usLOzw759+8Q2jUaDI0eOQKVSAQBUKhWysrJw/PhxsU9MTAxKSkrQsWNHsc+BAwdQWFgo9omOjoabmxsaNGhQS3tDREREdZlOA1FOTg4SExORmJgI4PFA6sTERKSkpEAmk2HKlCn473//i+3bt+PMmTMICAiAg4ODeCWau7s7+vTpg3HjxuHvv/9GfHw8QkJCMHToUDg4OAAAhg8fDrlcjqCgIJw7dw4bN25EREQEpk2bpqO9JiIiorrGQJcbP3bsGLy9vcXp0pASGBiIyMhIfPjhh8jNzcX48eORlZWFrl27YteuXTAyMhKXWbduHUJCQuDj4wM9PT34+/vjyy+/FOdbWFhgz549CA4OhpeXFxo1aoQ5c+Zo3auIiIiIpK3O3IeoLuN9iIiIiOqfV+I+RERERES1hYGIiIiIJI+BiIiIiCSPgYiIiIgkj4GIiIiIJI+BiIiIiCSPgYiIiIgkj4GIiIiIJI+BiIiIiCSPgYiIiIgkj4GIiIiIJI+BiIiIiCSPgYiIiIgkj4GIiIiIJI+BiIiIiCTPQNcFUP3l/FGUrksoI3mhn65LICKieohHiIiIiEjyGIiIiIhI8hiIiIiISPIYiIiIiEjyGIiIiIhI8hiIiIiISPIYiIiIiEjyGIiIiIhI8nhjRpKc+npDyfpaNxFRfcAjRERERCR5DEREREQkeQxEREREJHkMRERERCR5DEREREQkeQxEREREJHkMRERERCR5DEREREQkebwxIxHVKN5QkojqAx4hIiIiIsnjESIionLwyBaRtPAIEREREUkeAxERERFJHgMRERERSR4DEREREUlenR5UPW/ePISFhWm1ubm54eLFiwCAvLw8TJ8+HRs2bEB+fj7UajVWrlwJW1tbsX9KSgomTpyI2NhYmJmZITAwEOHh4TAwqNO7TkRUJRwMTlQ1dT4VtGrVCnv37hWnnwwyU6dORVRUFDZv3gwLCwuEhIRg8ODBiI+PBwAUFxfDz88PdnZ2OHz4MNLS0hAQEABDQ0N8/vnntb4vREREVDfV+UBkYGAAOzu7Mu3Z2dn4/vvvsX79erz11lsAgDVr1sDd3R1//fUXOnXqhD179uD8+fPYu3cvbG1t0a5dOyxYsACzZs3CvHnzIJfLa3t3iIioHDyyRbpW5wPR5cuX4eDgACMjI6hUKoSHh6Np06Y4fvw4CgsL4evrK/Z97bXX0LRpUyQkJKBTp05ISEhAmzZttE6hqdVqTJw4EefOncPrr7+ui10iIqJXBIPcq6NOB6KOHTsiMjISbm5uSEtLQ1hYGLp164azZ88iPT0dcrkclpaWWsvY2toiPT0dAJCenq4Vhkrnl857lvz8fOTn54vTGo2mmvaIiIiI6qI6HYj69u0r/uzp6YmOHTvCyckJmzZtgrGxcY1tNzw8vMxgbiIiInp11avL7i0tLdGyZUtcuXIFdnZ2KCgoQFZWllafjIwMccyRnZ0dMjIyyswvnfcsoaGhyM7OFh83btyo3h0hIiKiOqVOHyF6Wk5ODq5evYpRo0bBy8sLhoaG2LdvH/z9/QEASUlJSElJgUqlAgCoVCp89tlnyMzMhI2NDQAgOjoaSqUSHh4ez9yOQqGAQqGo+R0iIiLSAY59KqtOB6IZM2ZgwIABcHJyQmpqKubOnQt9fX0MGzYMFhYWCAoKwrRp02BlZQWlUon//Oc/UKlU6NSpEwCgd+/e8PDwwKhRo7Bo0SKkp6dj9uzZCA4OZuAhIiIiUZ0ORDdv3sSwYcNw9+5dWFtbo2vXrvjrr79gbW0NAFi2bBn09PTg7++vdWPGUvr6+tixYwcmTpwIlUoFU1NTBAYGYv78+braJSIiIqqD6nQg2rBhw3PnGxkZYcWKFVixYsUz+zg5OeHPP/+s7tKIiIjoFVKvBlUTERER1QQGIiIiIpI8BiIiIiKSPAYiIiIikjwGIiIiIpI8BiIiIiKSPAYiIiIikjwGIiIiIpI8BiIiIiKSPAYiIiIikjwGIiIiIpI8BiIiIiKSPAYiIiIikjwGIiIiIpI8BiIiIiKSPAYiIiIikjwGIiIiIpI8BiIiIiKSPAYiIiIikjwGIiIiIpI8BiIiIiKSPAYiIiIikjwGIiIiIpI8BiIiIiKSPAYiIiIikjwGIiIiIpI8BiIiIiKSPAYiIiIikjwGIiIiIpI8BiIiIiKSPAYiIiIikjwGIiIiIpI8BiIiIiKSPAYiIiIikjwGIiIiIpI8BiIiIiKSPAYiIiIikjwGIiIiIpI8BiIiIiKSPAYiIiIikjxJBaIVK1bA2dkZRkZG6NixI/7++29dl0RERER1gGQC0caNGzFt2jTMnTsXJ06cQNu2baFWq5GZmanr0oiIiEjHJBOIli5dinHjxmHMmDHw8PDA6tWrYWJigh9++EHXpREREZGOSSIQFRQU4Pjx4/D19RXb9PT04Ovri4SEBB1WRkRERHWBga4LqA137txBcXExbG1ttdptbW1x8eLFMv3z8/ORn58vTmdnZwMANBpNjdRXkv+wRtb7Miqyr6y7+rDu2sW6axfrrl2vct1VXacgCC/uLEjArVu3BADC4cOHtdpnzpwpvPnmm2X6z507VwDABx988MEHH3y8Ao8bN268MCtI4ghRo0aNoK+vj4yMDK32jIwM2NnZlekfGhqKadOmidMlJSW4d+8eGjZsCJlMVuP1VoVGo4GjoyNu3LgBpVKp63IqjHXXLtZdu1h37WLdtas+1C0IAh48eAAHB4cX9pVEIJLL5fDy8sK+ffswaNAgAI9Dzr59+xASElKmv0KhgEKh0GqztLSshUpfnlKprLMvzOdh3bWLddcu1l27WHftqut1W1hYVKifJAIRAEybNg2BgYHo0KED3nzzTSxfvhy5ubkYM2aMrksjIiIiHZNMIHr33Xdx+/ZtzJkzB+np6WjXrh127dpVZqA1ERERSY9kAhEAhISElHuK7FWgUCgwd+7cMqf66jrWXbtYd+1i3bWLddeu+lr3s8gEoSLXohERERG9uiRxY0YiIiKi52EgIiIiIsljICIiIiLJYyCiWhcXFweZTIasrCxdl/JKGz16tHjfrWfp2bMnpkyZUiv1vApe1eerIu/JefPmoV27drVWU0W8qr8P0g0GoldIRf4A1jSZTPbcx7x583RaX11QlUBYVz74IyMj681NSumx6npPzpgxA/v27avZYitpy5YtWLBgAQDA2dkZy5cv121BlfTkZ3ZdeY9LmaQuu6eal5aWJv68ceNGzJkzB0lJSWKbmZkZjh07povSXlpBQQHkcrmuyyCqlOp6T5qZmcHMzKxGaqwqKysrXZdArxAeIaJqZWdnJz4sLCwgk8m02p78QD1+/Dg6dOgAExMTdO7cWetDGgB+//13tG/fHkZGRmjWrBnCwsJQVFRUbbU+ePAAI0aMgKmpKezt7bFs2TKt/9KcnZ2xYMECBAQEQKlUYvz48QCAQ4cOoVu3bjA2NoajoyMmTZqE3Nxccb0//fQTOnToAHNzc9jZ2WH48OHIzMwEACQnJ8Pb2xsA0KBBA8hkMowePfq5dY4ePRr79+9HRESE+F/91atXERQUBBcXFxgbG8PNzQ0RERHlLh8WFgZra2solUpMmDABBQUFz9xWfn4+ZsyYgcaNG8PU1BQdO3ZEXFwcgMdHtsaMGYPs7OxqO+JX3n/17dq1w7x58yAIAubNm4emTZtCoVDAwcEBkyZNqlCtteH+/fsICAhAgwYNYGJigr59++Ly5csAHn/Hk7GxMXbu3Km1zNatW2Fubo6HDx9/0/iNGzfw73//G5aWlrCyssLAgQORnJxcrXVW13vy6VNmcXFxePPNN2FqagpLS0t06dIF169fr9baX6T0/dqzZ09cv34dU6dOFV+b9Ul57/Hqfh28SElJCcLDw8XPlLZt2+LXX38FABQXF7/w8+ZZr4fk5GTo6emVCd3Lly+Hk5MTSkpKam0fX4SBiHTmk08+wZIlS3Ds2DEYGBjgvffeE+cdPHgQAQEBmDx5Ms6fP49vvvkGkZGR+Oyzz6pt+9OmTUN8fDy2b9+O6OhoHDx4ECdOnNDq88UXX6Bt27Y4efIkPv30U1y9ehV9+vSBv78/Tp8+jY0bN+LQoUNaN/wsLCzEggULcOrUKWzbtg3Jycli6HF0dMRvv/0GAEhKSkJaWtozg0ypiIgIqFQqjBs3DmlpaUhLS0OTJk3QpEkTbN68GefPn8ecOXPw8ccfY9OmTVrL7tu3DxcuXEBcXBx++eUXbNmyBWFhYc/cVkhICBISErBhwwacPn0a//rXv9CnTx9cvnwZnTt3xvLly6FUKsU6ZsyYUZmnvFJ+++03LFu2DN988w0uX76Mbdu2oU2bNhWqtTaMHj0ax44dw/bt25GQkABBENCvXz8UFhZCqVSif//+WL9+vdYy69atw6BBg2BiYoLCwkKo1WqYm5vj4MGDiI+Ph5mZGfr06fPc0FqTnveefFJRUREGDRqEHj164PTp00hISMD48eN1FkS2bNmCJk2aYP78+eJrsz4p7z3u6OhYqzWEh4fjxx9/xOrVq3Hu3DlMnToVI0eOxP79+1FSUvLcz5vnvR6cnZ3h6+uLNWvWaG1vzZo1GD16NPT06lAMEeiVERgYKAwcOFDXZYjWrFkjWFhYlGmPjY0VAAh79+4V26KiogQAwqNHjwRBEAQfHx/h888/11rup59+Euzt7aulNo1GIxgaGgqbN28W27KysgQTExNh8uTJgiAIgpOTkzBo0CCt5YKCgoTx48drtR08eFDQ09MTa3/a0aNHBQDCgwcPBEH4//t///79Ctfbo0cPsa5nCQ4OFvz9/cXpwMBAwcrKSsjNzRXbVq1aJZiZmQnFxcVl1nv9+nVBX19fuHXrltZ6fXx8hNDQUEEQnv07rSonJydh2bJlWm1t27YV5s6dKyxZskRo2bKlUFBQUGa5itRaE0qfr0uXLgkAhPj4eHHenTt3BGNjY2HTpk2CIAjC1q1bBTMzM/H5z87OFoyMjISdO3cKgvD49ezm5iaUlJSI68jPzxeMjY2F3bt310j9L/OenDt3rtC2bVtBEATh7t27AgAhLi6uRuqsqCdfv+W9luq6Jz+zK/Ieryl5eXmCiYmJcPjwYa32oKAgYdiwYeUu8+TnzYteDxs3bhQaNGgg5OXlCYIgCMePHxdkMplw7dq16tuJalCHohlJjaenp/izvb09AIinlk6dOoX58+eL4xbMzMzE/55KTze8jH/++QeFhYV48803xTYLCwu4ublp9evQoYPW9KlTpxAZGalVl1qtRklJCa5duwbg8WmHAQMGoGnTpjA3N0ePHj0AACkpKS9d95NWrFgBLy8vWFtbw8zMDN9++22ZbbRt2xYmJibitEqlQk5ODm7cuFFmfWfOnEFxcTFatmyptX/79+/H1atXq7X2ivjXv/6FR48eoVmzZhg3bhy2bt0qnjLVda0XLlyAgYEBOnbsKLY1bNgQbm5uuHDhAgCgX79+MDQ0xPbt2wE8PuKlVCrh6+sL4PFr6cqVKzA3Nxfrt7KyQl5enk6eb+D578knWVlZYfTo0VCr1RgwYAAiIiLq3VEZ+v+uXLmChw8folevXlrvpx9//FF8LT7v8+ZFr4dBgwZBX18fW7duBfD44gxvb284OzvX+r4+DwdVk84YGhqKP5ceai89n5yTk4OwsDAMHjy4zHJGRka1UyAAU1NTremcnBy8//77WmNZSjVt2hS5ublQq9VQq9VYt24drK2tkZKSArVaXa2nQTZs2IAZM2ZgyZIlUKlUMDc3x+LFi3HkyJEqrzMnJwf6+vo4fvw49PX1tebV1GBaPT09CE99e1BhYSGAx6cXk5KSsHfvXkRHR+ODDz7A4sWLsX//fp3UWllyuRxDhgzB+vXrMXToUKxfvx7vvvsuDAwef+zm5OTAy8sL69atK7OstbV1bZcL4PnvyaetWbMGkyZNwq5du7Bx40bMnj0b0dHR6NSpU63UStUnJycHABAVFYXGjRtrzVMoFBX6vHne60EulyMgIABr1qzB4MGDsX79+hcOFdAFBiKqk9q3b4+kpCS4urrWyPqbNWsGQ0NDHD16FE2bNgUAZGdn49KlS+jevftz6zp//vwz6zpz5gzu3r2LhQsXimMAnh5MWHqlWnFxcYXrlcvlWv3j4+PRuXNnfPDBB2JbeUcVTp06hUePHsHY2BgA8Ndff8HMzKzc8Qmvv/46iouLkZmZiW7dulWojpdlbW2t9Z+kRqMRj7QBgLGxMQYMGIABAwYgODgYr732Gs6cOVOhWmuSu7s7ioqKcOTIEXTu3BkAcPfuXSQlJcHDw0PsN2LECPTq1Qvnzp1DTEwM/vvf/4rz2rdvj40bN8LGxgZKpbLW96E6vP7663j99dcRGhoKlUqF9evX6ywQVfdrs7bpsn4PDw8oFAqkpKSIR7SfVNHPm+e9HsaOHYvWrVtj5cqVKCoqKvefXV3jKTOqk+bMmYMff/wRYWFhOHfuHC5cuIANGzZg9uzZ1bJ+c3NzBAYGYubMmYiNjcW5c+cQFBQEPT295w4MnTVrFg4fPoyQkBAkJibi8uXL+P3338VB1U2bNoVcLsdXX32Ff/75B9u3bxfvk1LKyckJMpkMO3bswO3bt8X/zp7H2dkZR44cQXJyMu7cuYMWLVrg2LFj2L17Ny5duoRPP/0UR48eLbNcQUEBgoKCcP78efz555+YO3cuQkJCyh3I2LJlS4wYMQIBAQHYsmULrl27hr///hvh4eGIiooS68jJycG+fftw586dlz59+dZbb+Gnn37CwYMHcebMGQQGBopHfCIjI/H999/j7Nmz+Oeff/Dzzz/D2NgYTk5OFaq1JrVo0QIDBw7EuHHjcOjQIZw6dQojR45E48aNMXDgQLFf9+7dYWdnhxEjRsDFxUXrFNuIESPQqFEjDBw4EAcPHsS1a9cQFxeHSZMm4ebNmzW+Dy/j2rVrCA0NRUJCAq5fv449e/bg8uXLcHd311lNzs7OOHDgAG7duoU7d+4AAG7duoXXXnsNf//9t87qqqin3+O1efWVubk5ZsyYgalTp2Lt2rW4evUqTpw4ga+++gpr16594edNRV4P7u7u6NSpE2bNmoVhw4aJ/6TVJQxEVCep1Wrs2LEDe/bswRtvvIFOnTph2bJlcHJyqrZtLF26FCqVCv3794evry+6dOkCd3f3556S8/T0xP79+3Hp0iV069YNr7/+OubMmQMHBwcAj494REZGYvPmzfDw8MDChQvxxRdfaK2jcePGCAsLw0cffQRbW1utK9SeZcaMGdDX14eHhwesra2hVqsxePBgvPvuu+jYsSPu3r2r9d9bKR8fH7Ro0QLdu3fHu+++i7fffvu5l8qvWbMGAQEBmD59Otzc3DBo0CCto2idO3fGhAkT8O6778La2hqLFi16Ye3PExoaih49eqB///7w8/PDoEGD0Lx5cwCApaUl/ve//6FLly7w9PTE3r178ccff6Bhw4YVqrWmrVmzBl5eXujfvz9UKhUEQcCff/5Z5rTTsGHDcOrUKYwYMUJreRMTExw4cABNmzbF4MGD4e7ujqCgIOTl5dX5I0YmJia4ePEi/P390bJlS4wfPx7BwcF4//33dVbT/PnzkZycjObNm4unHAsLC5GUlFQt4w5r2tPv8eoec/giCxYswKefforw8HC4u7ujT58+iIqKgouLC95///3nft5U9PUQFBSEgoKCZ169qGsy4ekT+EQSlZubi8aNG2PJkiUICgrSdTlERK+UBQsWYPPmzTh9+rSuSykXxxCRZJ08eRIXL17Em2++iezsbMyfPx8AtE55EBHRy8nJyUFycjK+/vprrXF0dQ1PmZGkld540dfXF7m5uTh48CAaNWqk67KIiF4ZISEh8PLyQs+ePevs6TKAp8yIiIiIeISIiIiIiIGIiIiIJI+BiIiIiCSPgYiIiIgkj4GIiKgSevbsiSlTpui6DCKqZgxERFSvrF69Gubm5igqKhLbcnJyYGhoiJ49e2r1jYuLg0wm09m3xxNR/cFARET1ire3N3JycrS+NPfgwYOws7PDkSNHkJeXJ7bHxsaiadOm4teBVJQgCFqBi4hefQxERFSvuLm5wd7eHnFxcWJbXFwcBg4cCBcXF/z1119a7d7e3sjPz8ekSZNgY2MDIyMjdO3aVevLKUuPJO3cuRNeXl5QKBQ4dOgQcnNzERAQADMzM9jb22PJkiVl6lm5ciVatGgBIyMj2NraYsiQITW6/0RUMxiIiKje8fb2RmxsrDgdGxuLnj17okePHmL7o0ePcOTIEXh7e+PDDz/Eb7/9hrVr1+LEiRNwdXWFWq3GvXv3tNb70UcfYeHChbhw4QI8PT0xc+ZM7N+/H7///jv27NmDuLg4nDhxQux/7NgxTJo0CfPnz0dSUhJ27dqF7t27186TQETVSyAiqmf+97//CaampkJhYaGg0WgEAwMDITMzU1i/fr3QvXt3QRAEYd++fQIAITk5WTA0NBTWrVsnLl9QUCA4ODgIixYtEgRBEGJjYwUAwrZt28Q+Dx48EORyubBp0yax7e7du4KxsbEwefJkQRAE4bfffhOUSqWg0WhqYa+JqCbxCBER1Ts9e/ZEbm4ujh49ioMHD6Jly5awtrZGjx49xHFEcXFxaNasGbKzs1FYWIguXbqIyxsaGuLNN9/EhQsXtNbboUMH8eerV6+ioKAAHTt2FNusrKzg5uYmTvfq1QtOTk5o1qwZRo0ahXXr1uHhw4c1uOdEVFMYiIio3nF1dUWTJk0QGxuL2NhY9OjRAwDg4OAAR0dHHD58GLGxsXjrrbcqtV5TU9NK9Tc3N8eJEyfwyy+/wN7eHnPmzEHbtm2RlZVVqfUQke4xEBFRveTt7Y24uDjExcVpXW7fvXt37Ny5E3///Te8vb3RvHlzyOVyxMfHi30KCwtx9OhReHh4PHP9zZs3h6GhIY4cOSK23b9/H5cuXdLqZ2BgAF9fXyxatAinT59GcnIyYmJiqm9HiahWGOi6ACKiqvD29kZwcDAKCwvFI0QA0KNHD4SEhKCgoADe3t4wNTXFxIkTMXPmTFhZWaFp06ZYtGgRHj58iKCgoGeu38zMDEFBQZg5cyYaNmwIGxsbfPLJJ9DT+///R+7YsQP//PMPunfvjgYNGuDPP/9ESUmJ1mk1IqofGIiIqF7y9vbGo0eP8Nprr8HW1lZs79GjBx48eCBeng8ACxcuRElJCUaNGoUHDx6gQ4cO2L17Nxo0aPDcbSxevBg5OTkYMGAAzM3NMX36dGRnZ4vzLS0tsWXLFsybNw95eXlo0aIFfvnlF7Rq1apmdpqIaoxMEARB10UQERER6RLHEBEREZHkMRARERGR5DEQERERkeQxEBEREZHkMRARERGR5DEQERERkeQxEBEREZHkMRARERGR5DEQERERkeQxEBEREZHkMRARERGR5DEQERERkeT9P5dEd3xkcNGaAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from collections import Counter\n",
    "import nltk\n",
    "from nltk.corpus import stopwords\n",
    "\n",
    "nltk.download('stopwords')\n",
    "stopwords = set(stopwords.words('english'))\n",
    "\n",
    "words = ' '.join(train_data['reviews.text']).split()\n",
    "words = [word for word in words if word not in stopwords]\n",
    "\n",
    "word_counts = Counter(words)\n",
    "common_words = word_counts.most_common(10)\n",
    "\n",
    "words, counts = zip(*common_words)\n",
    "plt.bar(words, counts)\n",
    "plt.title('Word Frequency Distribution')\n",
    "plt.xlabel('Words')\n",
    "plt.ylabel('Frequency')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0bdf507e-1e29-4b0b-a105-5f2aeba0db29",
   "metadata": {},
   "source": [
    "### Distribution of Review Lengths: \n",
    "This could give you an idea of how long your typical review is."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "a7b3a039-de15-449d-98e1-5ec8bacd28f3",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "review_lengths = train_data['reviews.text'].apply(lambda x: len(x.split()))\n",
    "plt.hist(review_lengths, bins=30)\n",
    "plt.title('Review Length Distribution')\n",
    "plt.xlabel('Review Length')\n",
    "plt.ylabel('Frequency')\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "764b8bbd-1888-40f1-8f13-4f8b4c980ad7",
   "metadata": {},
   "source": [
    "### Distribution of Reviews by Primary Categories: \n",
    "This will give you an understanding of which categories have the most reviews."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "fc2312a6-2541-43f8-bfdb-a78ad6037443",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "primary_category_counts = train_data['primaryCategories'].value_counts()\n",
    "plt.bar(primary_category_counts.index, primary_category_counts.values)\n",
    "plt.title('Primary Category Distribution')\n",
    "plt.xlabel('Primary Category')\n",
    "plt.ylabel('Count')\n",
    "plt.xticks(rotation=90)\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e02c96ac-9081-4d51-a1b7-9d737a30f42c",
   "metadata": {},
   "source": [
    "### Boxplot of Review Lengths by Sentiment: \n",
    "This can provide some insights into whether sentiment is related to review length."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "c2714c03-d009-4ee4-bc44-f6d727f6036e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1000x600 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "train_data['review_length'] = train_data['reviews.text'].apply(lambda x: len(x.split()))\n",
    "plt.figure(figsize=(10, 6))\n",
    "plt.boxplot([train_data.loc[train_data['sentiment']==sentiment, 'review_length'] for sentiment in sentiment_counts.index], \n",
    "            labels=sentiment_counts.index, showfliers=False)\n",
    "plt.title('Boxplot of Review Lengths by Sentiment')\n",
    "plt.ylabel('Review Length')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7115ce0e-b90f-4566-81c4-877bb5743590",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}