Project 3 - Airbnb_oliver-Copy1.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Project 3: Airbnb\n",
    "**This is the third of three mandatory projects to be handed in as part of the assessment for the course 02807 Computational Tools for Data Science at Technical University of Denmark, autumn 2019.**\n",
    "\n",
    "#### Practical info\n",
    "- **The project is to be done in groups of at most 3 students**\n",
    "- **Each group has to hand in _one_ Jupyter notebook (this notebook) with their solution**\n",
    "- **The hand-in of the notebook is due 2019-12-05, 23:59 on DTU Inside**\n",
    "\n",
    "#### Your solution\n",
    "- **Your solution should be in Python/PySpark**\n",
    "- **For each question you may use as many cells for your solution as you like**\n",
    "- **You should not remove the problem statements**\n",
    "- **Your notebook should be runnable, i.e., clicking [>>] in Jupyter should generate the result that you want to be assessed**\n",
    "- **You are not expected to use machine learning to solve any of the exercises**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Introduction\n",
    "[Airbnb](http://airbnb.com) is an online marketplace for arranging or offering lodgings. In this project you will use Spark to analyze data obtained from the Airbnb website. The purpose of the analysis is to extract information about trends and patterns from the data.\n",
    "\n",
    "The project has two parts.\n",
    "\n",
    "### Part 1: Loading, describing and preparing the data\n",
    "There's quite a lot of data. Make sure that you can load and correctly parse the data, and that you understand what the dataset contains. You should also prepare the data for the analysis in part two. This means cleaning it and staging it so that subsequent queries are fast.\n",
    "\n",
    "### Par 2: Analysis\n",
    "In this part your goal is to learn about trends and usage patterns from the data. You should give solutions to the tasks defined in this notebook, and you should use Spark to do the data processing. You may use other libraries like for instance Pandas and matplotlib for visualisation.\n",
    "\n",
    "## Guidelines\n",
    "- Processing data should be done using Spark. Once data has been reduced to aggregate form, you may use collect to extract it into Python for visualisation.\n",
    "- Your solutions will be evaluated by correctness, code quality and interpretability of the output. This means that you have to write clean and efficient Spark code that will generate sensible execution plans, and that the tables and visualisations that you produce are meaningful and easy to read.\n",
    "- You may add more cells for your solutions, but you should not modify the notebook otherwise."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Create Spark session and define imports"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "from pyspark.sql import *\n",
    "from pyspark.sql import functions as f\n",
    "from pyspark.sql.types import *\n",
    "\n",
    "spark = SparkSession.builder.appName(\"SparkIntro\").getOrCreate()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Part 1: Loading, describing and preparing the data\n",
    "The data comes in two files. Start by downloading the files and putting them in your `data/` folder.\n",
    "\n",
    "- [Listings](https://files.dtu.dk/u/siPzAasj8w2gI_ME/listings.csv?l) (5 GB)\n",
    "- [Reviews](https://files.dtu.dk/u/k3oaPYp6GjKBeho4/reviews.csv?l) (9.5 GB)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Load the data\n",
    "The data has multiline rows (rows that span multiple lines in the file). To correctly parse these you should use the `multiline` option and set the `escape` character to be `\"`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "df = spark.read.option('header', True).option('inferSchema', True).option('multiline', True).option('escape','\"').csv('listings_sub_10000.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_review = spark.read.option('header', True).option('inferSchema', True).option('multiline', True).option('escape','\"').csv('reviews_sub_10000.csv')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Describe the data\n",
    "List the features (schema) and sizes of the datasets."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "root\n",
      " |-- _c0: integer (nullable = true)\n",
      " |-- id: string (nullable = true)\n",
      " |-- listing_url: string (nullable = true)\n",
      " |-- scrape_id: string (nullable = true)\n",
      " |-- last_scraped: string (nullable = true)\n",
      " |-- name: string (nullable = true)\n",
      " |-- summary: string (nullable = true)\n",
      " |-- space: string (nullable = true)\n",
      " |-- description: string (nullable = true)\n",
      " |-- experiences_offered: string (nullable = true)\n",
      " |-- neighborhood_overview: string (nullable = true)\n",
      " |-- notes: string (nullable = true)\n",
      " |-- transit: string (nullable = true)\n",
      " |-- access: string (nullable = true)\n",
      " |-- interaction: string (nullable = true)\n",
      " |-- house_rules: string (nullable = true)\n",
      " |-- thumbnail_url: string (nullable = true)\n",
      " |-- medium_url: string (nullable = true)\n",
      " |-- picture_url: string (nullable = true)\n",
      " |-- xl_picture_url: string (nullable = true)\n",
      " |-- host_id: string (nullable = true)\n",
      " |-- host_url: string (nullable = true)\n",
      " |-- host_name: string (nullable = true)\n",
      " |-- host_since: string (nullable = true)\n",
      " |-- host_location: string (nullable = true)\n",
      " |-- host_about: string (nullable = true)\n",
      " |-- host_response_time: string (nullable = true)\n",
      " |-- host_response_rate: string (nullable = true)\n",
      " |-- host_acceptance_rate: string (nullable = true)\n",
      " |-- host_is_superhost: string (nullable = true)\n",
      " |-- host_thumbnail_url: string (nullable = true)\n",
      " |-- host_picture_url: string (nullable = true)\n",
      " |-- host_neighbourhood: string (nullable = true)\n",
      " |-- host_listings_count: string (nullable = true)\n",
      " |-- host_total_listings_count: string (nullable = true)\n",
      " |-- host_verifications: string (nullable = true)\n",
      " |-- host_has_profile_pic: string (nullable = true)\n",
      " |-- host_identity_verified: string (nullable = true)\n",
      " |-- street: string (nullable = true)\n",
      " |-- neighbourhood: string (nullable = true)\n",
      " |-- neighbourhood_cleansed: string (nullable = true)\n",
      " |-- neighbourhood_group_cleansed: string (nullable = true)\n",
      " |-- city: string (nullable = true)\n",
      " |-- state: string (nullable = true)\n",
      " |-- zipcode: string (nullable = true)\n",
      " |-- market: string (nullable = true)\n",
      " |-- smart_location: string (nullable = true)\n",
      " |-- country_code: string (nullable = true)\n",
      " |-- country: string (nullable = true)\n",
      " |-- latitude: string (nullable = true)\n",
      " |-- longitude: string (nullable = true)\n",
      " |-- is_location_exact: string (nullable = true)\n",
      " |-- property_type: string (nullable = true)\n",
      " |-- room_type: string (nullable = true)\n",
      " |-- accommodates: string (nullable = true)\n",
      " |-- bathrooms: string (nullable = true)\n",
      " |-- bedrooms: string (nullable = true)\n",
      " |-- beds: string (nullable = true)\n",
      " |-- bed_type: string (nullable = true)\n",
      " |-- amenities: string (nullable = true)\n",
      " |-- square_feet: string (nullable = true)\n",
      " |-- price: string (nullable = true)\n",
      " |-- weekly_price: string (nullable = true)\n",
      " |-- monthly_price: string (nullable = true)\n",
      " |-- security_deposit: string (nullable = true)\n",
      " |-- cleaning_fee: string (nullable = true)\n",
      " |-- guests_included: string (nullable = true)\n",
      " |-- extra_people: string (nullable = true)\n",
      " |-- minimum_nights: string (nullable = true)\n",
      " |-- maximum_nights: string (nullable = true)\n",
      " |-- minimum_minimum_nights: string (nullable = true)\n",
      " |-- maximum_minimum_nights: string (nullable = true)\n",
      " |-- minimum_maximum_nights: string (nullable = true)\n",
      " |-- maximum_maximum_nights: string (nullable = true)\n",
      " |-- minimum_nights_avg_ntm: string (nullable = true)\n",
      " |-- maximum_nights_avg_ntm: string (nullable = true)\n",
      " |-- calendar_updated: string (nullable = true)\n",
      " |-- has_availability: string (nullable = true)\n",
      " |-- availability_30: string (nullable = true)\n",
      " |-- availability_60: string (nullable = true)\n",
      " |-- availability_90: string (nullable = true)\n",
      " |-- availability_365: string (nullable = true)\n",
      " |-- calendar_last_scraped: string (nullable = true)\n",
      " |-- number_of_reviews: string (nullable = true)\n",
      " |-- number_of_reviews_ltm: string (nullable = true)\n",
      " |-- first_review: string (nullable = true)\n",
      " |-- last_review: string (nullable = true)\n",
      " |-- review_scores_rating: string (nullable = true)\n",
      " |-- review_scores_accuracy: string (nullable = true)\n",
      " |-- review_scores_cleanliness: string (nullable = true)\n",
      " |-- review_scores_checkin: string (nullable = true)\n",
      " |-- review_scores_communication: string (nullable = true)\n",
      " |-- review_scores_location: string (nullable = true)\n",
      " |-- review_scores_value: string (nullable = true)\n",
      " |-- requires_license: string (nullable = true)\n",
      " |-- license: string (nullable = true)\n",
      " |-- jurisdiction_names: string (nullable = true)\n",
      " |-- instant_bookable: string (nullable = true)\n",
      " |-- is_business_travel_ready: string (nullable = true)\n",
      " |-- cancellation_policy: string (nullable = true)\n",
      " |-- require_guest_profile_picture: string (nullable = true)\n",
      " |-- require_guest_phone_verification: string (nullable = true)\n",
      " |-- calculated_host_listings_count: string (nullable = true)\n",
      " |-- calculated_host_listings_count_entire_homes: string (nullable = true)\n",
      " |-- calculated_host_listings_count_private_rooms: string (nullable = true)\n",
      " |-- calculated_host_listings_count_shared_rooms: string (nullable = true)\n",
      " |-- reviews_per_month: string (nullable = true)\n",
      "\n"
     ]
    }
   ],
   "source": [
    "df.printSchema()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "from functools import reduce\n",
    "import matplotlib.pyplot as plt\n",
    "import pandas as pd\n",
    "\n",
    "#test = df.where(reduce(lambda x, y: x & y,  (f.col(x) != 'null' for x in df.columns)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Prepare the data for analysis\n",
    "You should prepare two dataframes to be used in the analysis part of the project. You should not be concerned with cleaning the data. There's a lot of it, so it will be sufficient to drop rows that have bad values. You may want to go back and refine this step at a later point when doing the analysis.\n",
    "\n",
    "You may also want to consider if you can stage your data so that subsequent processing is more efficient (this is not strictly necessary for Spark to run, but you may be able to decrease the time you sit around waiting for Spark to finish things)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "dfp = df.toPandas()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "_c0                                            0\n",
       "minimum_maximum_nights                         0\n",
       "maximum_minimum_nights                         0\n",
       "minimum_minimum_nights                         0\n",
       "maximum_nights                                 0\n",
       "minimum_nights                                 0\n",
       "extra_people                                   0\n",
       "guests_included                                0\n",
       "price                                          0\n",
       "amenities                                      0\n",
       "bed_type                                       0\n",
       "accommodates                                   0\n",
       "calculated_host_listings_count_shared_rooms    0\n",
       "property_type                                  0\n",
       "is_location_exact                              0\n",
       "longitude                                      0\n",
       "latitude                                       0\n",
       "country                                        0\n",
       "maximum_maximum_nights                         0\n",
       "country_code                                   0\n",
       "dtype: int64"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dfp.isna().sum().sort_values().head(20)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Part 2: Analysis\n",
    "Use Spark and your favorite tool for data visualization to solve the following tasks.\n",
    "\n",
    "## The basics\n",
    "Compute and show a dataframe with the number of listings and neighbourhoods per city."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+------------------+--------+--------------+\n",
      "|              city|Listings|Neighbourhoods|\n",
      "+------------------+--------+--------------+\n",
      "|         Stockholm|    4297|            14|\n",
      "|              Oslo|    2227|            14|\n",
      "|        Stockholm |      27|             9|\n",
      "|              null|      13|             7|\n",
      "|  Stockholm County|       7|             5|\n",
      "|       Kungsholmen|     360|             5|\n",
      "|         Södermalm|     845|             4|\n",
      "|      Oslo kommune|       6|             3|\n",
      "|         Östermalm|     267|             3|\n",
      "|Hässelby-Vällingby|      92|             2|\n",
      "|            Bromma|     182|             2|\n",
      "|        斯德哥尔摩|       3|             2|\n",
      "|      Enskededalen|      21|             2|\n",
      "|            Farsta|      80|             2|\n",
      "|            Älvsjö|      89|             2|\n",
      "|         Estocolmo|       3|             2|\n",
      "|       Johanneshov|       7|             2|\n",
      "|         Hägersten|      13|             2|\n",
      "|         Stoccolma|       2|             2|\n",
      "|           Enskede|      12|             2|\n",
      "+------------------+--------+--------------+\n",
      "only showing top 20 rows\n",
      "\n"
     ]
    }
   ],
   "source": [
    "df.groupby('city').agg(f.count('_c0').alias('Listings'), f.countDistinct('neighbourhood').alias('Neighbourhoods')).orderBy(f.desc('Neighbourhoods')).show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Based on the table above, you should choose a city that you want to continue your analysis for. The city should have mulitple neighbourhoods with listings in them.\n",
    "\n",
    "Compute and visualize the number of listings of different property types per neighbourhood in your city."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>property_type</th>\n",
       "      <th>neighbourhood</th>\n",
       "      <th>count(_c0)</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <td>0</td>\n",
       "      <td>Apartment</td>\n",
       "      <td>Farsta</td>\n",
       "      <td>62</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>1</td>\n",
       "      <td>Villa</td>\n",
       "      <td>Spånga-Tensta</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>2</td>\n",
       "      <td>Cabin</td>\n",
       "      <td>Hägersten-Liljeholmen</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>3</td>\n",
       "      <td>Townhouse</td>\n",
       "      <td>Skarpnäck</td>\n",
       "      <td>10</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>4</td>\n",
       "      <td>Villa</td>\n",
       "      <td>Hässelby-Vällingby</td>\n",
       "      <td>3</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "  property_type          neighbourhood  count(_c0)\n",
       "0     Apartment                 Farsta          62\n",
       "1         Villa          Spånga-Tensta           1\n",
       "2         Cabin  Hägersten-Liljeholmen           1\n",
       "3     Townhouse              Skarpnäck          10\n",
       "4         Villa     Hässelby-Vällingby           3"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "prop_neigh_city = df.filter(f.col('city')=='Stockholm').groupby('property_type','neighbourhood').agg(f.count('_c0')).toPandas()\n",
    "prop_neigh_city.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1152x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "prop_neigh_city.pivot(index='neighbourhood',columns='property_type',\\\n",
    "                      values='count(_c0)').plot(kind='bar',figsize=(16,6),stacked=True)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Prices\n",
    "Compute the minimum, maximum and average listing price in your city. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "city = \"Stockholm\"\n",
    "df_s = df.filter(f.col(\"city\")==city)\n",
    "df_s.count()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "from pyspark.sql.types import *\n",
    "from pyspark.sql.functions import substring, length, col, expr\n",
    "df_s = df_s.withColumn(\"price\",expr(\"substring(price, 2, length(price))\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "from  pyspark.sql.functions import regexp_replace, col\n",
    "df_s = df_s.withColumn(\"price\", regexp_replace(f.col(\"price\"), \",\", \"\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [],
   "source": [
    "from pyspark.sql.types import *\n",
    "df_d = df_s.withColumn(\"price\",df_s[\"price\"].cast(DoubleType()))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Basic statistics for Stockholm\n",
      "+------------------+---------+---------+\n",
      "|      Averge price|Max price|Min price|\n",
      "+------------------+---------+---------+\n",
      "|1104.4123807307424|  22463.0|     98.0|\n",
      "+------------------+---------+---------+\n",
      "\n"
     ]
    }
   ],
   "source": [
    "print(\"Basic statistics for\", city)\n",
    "df_d.select(f.avg('price').alias(\"Averge price\"), f.max('price').alias(\"Max price\"), f.min('price').alias(\"Min price\")).show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Compute and visualize the distribution of listing prices in your city."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "import seaborn as sns\n",
    "import matplotlib.pyplot as plt\n",
    "from scipy import stats\n",
    "sns.set(rc={'figure.figsize':(16,6)})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1152x432 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "df_city_p = df_d.toPandas()\n",
    "sns.distplot(df_city_p.price, kde=False, rug=False, bins=150);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The value of a listing is its rating divided by its price.\n",
    "\n",
    "Compute and show a dataframe with the 3 highest valued listings in each neighbourhood."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [],
   "source": [
    "from pyspark.sql.functions import lit"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_d = df_d.withColumn(\"review_scores_rating\",df_s[\"review_scores_rating\"].cast(DoubleType()))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_d = df_d.withColumn(\"value_listing\",lit(f.col(\"review_scores_rating\")/f.col(\"price\")))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_value = df_d.select(f.col(\"city\"),f.col(\"neighbourhood\"),(f.col(\"value_listing\")))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [],
   "source": [
    "#df_value.orderBy(df_value.value_listing.desc()).show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [],
   "source": [
    "sorted_by_value = Window.partitionBy('neighbourhood').orderBy(f.desc('value_listing'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [],
   "source": [
    "ranked_by_value = df_d.withColumn('value_listing_rank', f.rank().over(sorted_by_value))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [],
   "source": [
    "ranked_df = ranked_by_value.filter(f.col('value_listing_rank') <= 3).drop('value_listing_rank').orderBy('neighbourhood', f.desc('value_listing'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+--------------------+-------------------+---------+--------------------+\n",
      "|       neighbourhood|      value_listing|     city|                name|\n",
      "+--------------------+-------------------+---------+--------------------+\n",
      "|              Bromma| 0.7948717948717948|Stockholm| Nice room in Bromma|\n",
      "|              Bromma| 0.4444444444444444|Stockholm|        Balla Bromma|\n",
      "|              Bromma|              0.375|Stockholm|Rent a room in St...|\n",
      "|Enskede-Årsta-Vantör| 0.6802721088435374|Stockholm|Shared room for F...|\n",
      "|Enskede-Årsta-Vantör| 0.5102040816326531|Stockholm|Cosy 50th style a...|\n",
      "|Enskede-Årsta-Vantör|0.47959183673469385|Stockholm|Bekväm lägenhet i...|\n",
      "|              Farsta|0.47804878048780486|Stockholm|Private room in c...|\n",
      "|              Farsta|0.38188976377952755|Stockholm|Cozy Nice Room Wi...|\n",
      "|              Farsta|0.35826771653543305|Stockholm|Rum uthyres i Far...|\n",
      "|Hägersten-Liljeho...| 0.4266666666666667|Stockholm|Warm big room wit...|\n",
      "|Hägersten-Liljeho...|0.36742424242424243|Stockholm| \"My home your home\"|\n",
      "|Hägersten-Liljeho...|0.36220472440944884|Stockholm|Egen lägenhet i G...|\n",
      "|  Hässelby-Vällingby|  0.673469387755102|Stockholm|    Shared Apartment|\n",
      "|  Hässelby-Vällingby| 0.5923566878980892|Stockholm|Room2, for GIRL, ...|\n",
      "|  Hässelby-Vällingby|  0.489247311827957|Stockholm|Do you like to sh...|\n",
      "|         Kungsholmen| 0.5306122448979592|Stockholm|L32: bed in a dor...|\n",
      "|         Kungsholmen|             0.4375|Stockholm|L32:bed in a dorm...|\n",
      "|         Kungsholmen| 0.4030612244897959|Stockholm|L32:bed in a dorm...|\n",
      "|         Kungsholmen| 0.4030612244897959|Stockholm|L32: bed in a dor...|\n",
      "|            Norrmalm| 0.6054421768707483|Stockholm|A room with a vie...|\n",
      "|            Norrmalm|0.45365853658536587|Stockholm|Cozy shared room ...|\n",
      "|            Norrmalm| 0.2375296912114014|Stockholm|Cozy studio apart...|\n",
      "|       Rinkeby-Kista| 0.5102040816326531|Stockholm|Cosy room,peacefu...|\n",
      "|       Rinkeby-Kista| 0.5060240963855421|Stockholm|One single room c...|\n",
      "|       Rinkeby-Kista|                0.5|Stockholm|Pleasant, quiet l...|\n",
      "|           Skarpnäck|0.36742424242424243|Stockholm|Sunny room to let...|\n",
      "|           Skarpnäck| 0.3661417322834646|Stockholm|Near by The Tele2...|\n",
      "|           Skarpnäck| 0.3415492957746479|Stockholm|Room 15 min to St...|\n",
      "|          Skärholmen|0.31496062992125984|Stockholm| Bedroom in Vårberg.|\n",
      "|          Skärholmen| 0.3102310231023102|Stockholm|Comfy private roo...|\n",
      "|          Skärholmen| 0.3029197080291971|Stockholm|Happy Stay in My ...|\n",
      "|       Spånga-Tensta| 0.5102040816326531|Stockholm|Room P in a house...|\n",
      "|       Spånga-Tensta| 0.4744897959183674|Stockholm|Room V in a house...|\n",
      "|       Spånga-Tensta|0.45408163265306123|Stockholm|Cozy private room...|\n",
      "|           Södermalm|0.33003300330033003|Stockholm|Fantastiskt rum i...|\n",
      "|           Södermalm| 0.3234323432343234|Stockholm| Södermalm Stockholm|\n",
      "|           Södermalm| 0.3231292517006803|Stockholm|Skyscraper apartm...|\n",
      "|              Älvsjö| 0.2840909090909091|Stockholm|Comfortable doubl...|\n",
      "|              Älvsjö|0.26420454545454547|Stockholm|Nice room in a qu...|\n",
      "|              Älvsjö|0.25806451612903225|Stockholm|Comfortable styli...|\n",
      "|           Östermalm| 1.0204081632653061|Stockholm|Lägenhet om 40 kv...|\n",
      "|           Östermalm|0.33003300330033003|Stockholm|Sunlit room in th...|\n",
      "|           Östermalm|0.32673267326732675|Stockholm|Nice room at Gärdet!|\n",
      "+--------------------+-------------------+---------+--------------------+\n",
      "\n"
     ]
    }
   ],
   "source": [
    "ranked_df.select(f.col(\"neighbourhood\"),f.col(\"value_listing\"),f.col(\"city\"),f.col(\"name\")).show(50)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Trends\n",
    "Now we want to analyze the \"popularity\" of your city. The data does not contain the number of bookings per listing, but we have a large number of reviews, and we will assume that this is a good indicator of activity on listings."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Compute and visualize the popularity (i.e., number of reviews) of your city over time."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+----------+---------+-------------------+-----------+\n",
      "|listing_id|review_id|               date|reviewer_id|\n",
      "+----------+---------+-------------------+-----------+\n",
      "|    145320|156423122|2017-05-30 00:00:00|  123386382|\n",
      "|    145320|170211906|2017-07-15 00:00:00|  123091743|\n",
      "|    145320|172169175|2017-07-20 00:00:00|      78004|\n",
      "|    145320|176647581|2017-07-31 00:00:00|  103178743|\n",
      "|    145320|185676021|2017-08-22 00:00:00|    4023961|\n",
      "|    145320|189668224|2017-09-02 00:00:00|  142869362|\n",
      "|    145320|191894030|2017-09-09 00:00:00|   25194419|\n",
      "|    145320|193316070|2017-09-13 00:00:00|   52056015|\n",
      "|    145320|196760607|2017-09-24 00:00:00|    3980456|\n",
      "|    145320|201885633|2017-10-09 00:00:00|   72139946|\n",
      "|    145320|203410181|2017-10-15 00:00:00|   23002655|\n",
      "|    145320|210619953|2017-11-10 00:00:00|    3451329|\n",
      "|    145320|211523951|2017-11-13 00:00:00|  105945750|\n",
      "|    145320|212932349|2017-11-19 00:00:00|     203826|\n",
      "|    145320|214018139|2017-11-24 00:00:00|   70756436|\n",
      "|    145320|216533345|2017-12-04 00:00:00|   10655526|\n",
      "|    145320|219021131|2017-12-16 00:00:00|   29246547|\n",
      "|    145320|231273225|2018-01-31 00:00:00|  160717975|\n",
      "|    145320|233159940|2018-02-08 00:00:00|   33212603|\n",
      "|    145320|234271335|2018-02-12 00:00:00|  160422715|\n",
      "+----------+---------+-------------------+-----------+\n",
      "only showing top 20 rows\n",
      "\n"
     ]
    }
   ],
   "source": [
    "df_review.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Filtering Listings data \n",
    "df_stockholm = df.filter(f.col('city')=='Stockholm').select('city','neighbourhood','id')\n",
    "\n",
    "# Subset of Review data and change column name \n",
    "df_review = df_review.select('listing_id', 'reviewer_id', f.col('id').alias('review_id'),\\\n",
    "                             'date')\n",
    "\n",
    "# Alternative solution - not finished\n",
    "#df_review = df_review.select('listing_id', 'reviewer_id', f.col('id').alias('review_id'),\\\n",
    "#                             'date', f.year(\"date\").alias('year'), f.month(\"date\").alias('month'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "metadata": {},
   "outputs": [],
   "source": [
    "# left-join Review-data on Listing-data on listing_id and id\n",
    "df_join = df_stockholm.join(df_review, (df_stockholm.id == df_review.listing_id), how='left')\n",
    "\n",
    "# Groupby date count reviews\n",
    "df_plot = df_join.groupby('date').agg(f.count('review_id')).toPandas()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 135,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Change time format, from day to (year and month)\n",
    "df_plot['newDate'] = pd.to_datetime(df_plot.date.dt.strftime('%Y %m'))\n",
    "\n",
    "# Now groupby the new data format (year and month)\n",
    "df_plot_newdate = df_plot.groupby('newDate').sum()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 138,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1152x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "df_plot_newdate.plot(figsize=(16,6))\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Compute and visualize the popularity of neighbourhoods over time. If there are many neighbourhoods in your city, you should select a few interesting ones for comparison."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 158,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_plot = df_join.groupby('date','neighbourhood').agg(f.count('review_id')).toPandas()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 159,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_plot['newDate'] = pd.to_datetime(df_plot.date.dt.strftime('%Y %m'))\n",
    "df_plot_newdate = df_plot.groupby(['newDate','neighbourhood'], as_index=False).sum()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 166,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_plot = df_plot_newdate.pivot(index='newDate',columns='neighbourhood',\\\n",
    "                      values='count(review_id)')\n",
    "df_plot = df_plot[df_plot.index.notnull()].reset_index()\n",
    "df_plot = df_plot.fillna(0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 181,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1152x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "df_plot.plot(x='newDate', y=['Södermalm','Bromma','Östermalm'],figsize=(16,6))\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Compute and visualize the popularity of your city by season. For example, visualize the popularity of your city per month."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 182,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_plot = df_join.groupby('date').agg(f.count('review_id')).toPandas()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 189,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_plot['newDate'] = pd.to_datetime(df_plot.date.dt.strftime('%m'),format='%m' )\n",
    "df_plot_newdate = df_plot.groupby('newDate', as_index=False).sum()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 195,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.dates as mdates"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 199,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAA7UAAAF/CAYAAACWte7OAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8QZhcZAAAgAElEQVR4nOzdd1iV5ePH8c/NFsSB4kTFgVtA3JqmObLMrFRMKxvf0rIys73r2x5q2rLx1ZblrKwsyxxlzhzgHjjBBeJCkf38/pD8mVku4D7n8H5dFxfn3OcZH/TyeD48z/08xnEcAQAAAADgjrxsBwAAAAAA4EJRagEAAAAAbotSCwAAAABwW5RaAAAAAIDbotQCAAAAANwWpRYAAAAA4LZ8bAc4m/Llyzvh4eG2YwAAAAAACsHy5cv3O44TeqHru3ypDQ8P17Jly2zHAAAAAAAUAmPMjotZn9OPAQAAAABui1ILAAAAAHBblFoAAAAAgNty+Tm1AAAAAIqP7OxsJSUlKSMjw3YUFLCAgACFhYXJ19e3QLdLqQUAAADgMpKSkhQcHKzw8HAZY2zHQQFxHEepqalKSkpSzZo1C3TbnH4MAAAAwGVkZGSoXLlyFFoPY4xRuXLlCuUIPKUWAAAAgEuh0Hqmwvp7pdQCAAAAANwWpRYAAAAAitCbb76p9PT0k88dx9Fll12mI0eOFMj2r7zySh06dKhAtnWq22+/XevWrfvb+Mcff6x77rlHkvT2229r/PjxBb7vf0OpBQAAAIAidHqp/eGHHxQVFaVSpUr9ZTnHcZSXl3fe2//hhx9UpkyZi855uo8++kgNGzb812Vuu+02jRkzpsD3/W8otQAAAABwmk8//VSRkZGKiorSTTfdpB07dqhz586KjIxU586dtXPnTknSLbfcoqlTp55cr2TJkpKkefPmqWPHjurTp4/q16+vG264QY7jaMyYMdq9e7c6deqkTp06SZImTJigXr16SZK2b9+uBg0aaMiQIYqJiVFiYqJ+/vlntWnTRjExMerbt6+OHj2qH3/8UbGxsSf3O2/ePPXs2VOSFB4erv3790uSPv/8c7Vs2VLR0dEaPHiwcnNzNXnyZA0fPlySNHr0aNWqVUuStGXLFl1yySX/+GfSsWNHLVu2TJI0fvx41a1bV5deeqkWLFhwcpnAwECFh4dr6dKlF/Gnf364pQ8AAAAAl/Tcd2u1bnfBnJL7p4ZVSumZno3+dZm1a9fqxRdf1IIFC1S+fHkdOHBAN998swYOHKibb75Z48aN09ChQ/XNN9/863ZWrlyptWvXqkqVKmrXrp0WLFigoUOHauTIkZo7d67Kly8vSVqwYIHef//9k+tt3LhR48eP17vvvqv9+/frhRde0C+//KKgoCC9+uqrGjlypB5//HENHjxYx44dU1BQkCZNmqR+/fr9Zf/r16/XpEmTtGDBAvn6+mrIkCGaMGGCunXrptdff12SNH/+fJUrV067du3S77//rvbt25/1z3DPnj165plntHz5cpUuXVqdOnVS06ZNT77evHlzzZ8/Xy1btjzrtgoCR2oBAACKyIFjWbp1/FKN+32b7SgA/sWcOXPUp0+fk6UzJCREixYt0oABAyRJN910k37//fezbqdly5YKCwuTl5eXoqOjtX379jMud+DAAQUHB598XqNGDbVu3VqStHjxYq1bt07t2rVTdHS0PvnkE+3YsUM+Pj7q3r27vvvuO+Xk5GjGjBknj/b+afbs2Vq+fLlatGih6OhozZ49W1u3blWlSpV09OhRpaWlKTExUQMGDNBvv/2m+fPnn1OpXbJkiTp27KjQ0FD5+fn9rUxXqFBBu3fvPut2CgpHagEAAIrA3sMZuvF/S5SQfFS/bkpRVLXSalYjxHYswKWd7YhqYXEc56y3n/nzdR8fn5PzXh3HUVZW1sll/P39Tz729vZWTk7OGbf15za8vE4ccwwKCvpLlq5du+rLL7/823r9+vXTO++8o5CQELVo0eIvxfjPdW+++Wa9/PLLf1u3TZs2Gj9+vOrVq6f27dtr3LhxWrRokUaMGPGvP/fpP/+ZZGRkqESJEue0nYJw1iO1xphxxphkY8yaM7z2oDHGMcaUP2XsMWNMgjFmozHm8lPGmxljVue/NsZw8ykAAFBMbN9/TH3GLtTewxn6aGBzVS1bQsMmxSktI9t2NABn0LlzZ02ePFmpqamSThxJbdu2rSZOnCjpxBzYP+eehoeHa/ny5ZKk6dOnKzv77P+ug4ODlZaWdvJ5vXr1tHXr1jMu27p1ay1YsEAJCQmSpPT0dG3atEnSiTmuK1as0Icffvi3o6V//hxTp05VcnLyyZ9jx44dkqQOHTrojTfeUIcOHdS0aVPNnTtX/v7+Kl269Fnzt2rVSvPmzVNqaqqys7M1ZcqUv7y+adMmNW7c+KzbKSjncvrxx5K6nz5ojKkmqauknaeMNZR0vaRG+eu8a4zxzn/5PUmDJEXkf/1tmwAAAJ5m/Z4j6jN2kY5l5uiLO1qpS8OKGhUbrV0Hj+u57/5+awwA9jVq1EhPPPGELr30UkVFRWn48OEaM2aMxo8fr8jISH322WcaPXq0JOmOO+7Qr7/+qpYtW2rJkiV/Ocr6TwYNGqQrrrji5IWievTooXnz5p1x2dDQUH388cfq37+/IiMj1bp1a23YsEHSiaO/V111lX788UddddVVf1u3YcOGeuGFF9StWzdFRkaqa9eu2rNnjySpffv2SkxMVIcOHeTt7a1q1ar960WiTlW5cmU9++yzatOmjbp06aKYmJi/vL5gwQJ16dLlnLZVEIzjOGdfyJhwSd87jtP4lLGpkp6XNF1Sc8dx9htjHpMkx3Fezl/mJ0nPStouaa7jOPXzx/tL6ug4zuCz7bt58+bOn1fYAgAAcCfLdxzUreOXKtDPR5/9p6UiKv7/qYEjf96oMXMS9O4NMbqySWWLKQHXsn79ejVo0MB2jCK1Z88eDRw4ULNmzbId5aKtXLlSI0eO1GeffXbG18/092uMWe44TvML3ecFXSjKGHO1pF2O48Sf9lJVSYmnPE/KH6ua//j0cQAAAI80f3OKbvxoicoG+WnKnW3+Umgl6d7OEYqqVkaPfbVaew4ft5QSgCuoXLmy7rjjDh05UrBXerZh//79ev7554t0n+ddao0xgZKekPT0mV4+w5jzL+P/tI9BxphlxphlKSkp5xsRAADAqh9X79FtH/+hGuUCNeXONqoWEvi3ZXy9vTS6X7Syc/P04JR45eWd/ew5AJ4rNjZWpUqVsh1DknTttdcqOjr6L18//fTTOa3btWtXhYeHF27A01zI1Y9rS6opKT7/Wk9hklYYY1rqxBHYaqcsGyZpd/542BnGz8hxnA8kfSCdOP34AjICAABYMXlZoh6dtkrR1cpo/C0tVTrQ9x+XDS8fpGd6NtQj01brf79v0x0dahVhUgA4s6+//tp2hPNy3kdqHcdZ7ThOBcdxwh3HCdeJwhrjOM5eSd9Kut4Y42+MqakTF4Ra6jjOHklpxpjW+Vc9HqgTc3EBAAA8xkfzt+rhqavUrk55fX57q38ttH+KbV5N3RpW1Os/bdS63e5/6iFQEM7luj9wP4X193out/T5UtIiSfWMMUnGmP/807KO46yVNFnSOkkzJd3tOE5u/st3SfpIUoKkLZJ+vMjsAAAALsFxHI38eaNemLFeVzSupI9ubq5Av3M7Ic4Yo1d6R6pMoK+GTVqpjOzcs68EeLCAgAClpqZSbD2M4zhKTU1VQEBAgW/7nK5+bBNXPwYAAK4sL8/Rf79fp48Xblds8zC9dG0T+Xif/7U4f9uUooHjluqWtuF69upGhZAUcA/Z2dlKSkpSRkaG7SgoYAEBAQoLC5Ov71/PYrnYqx9fyJxaAAAASMrJzdPDU1fpq5W7dPslNfVEjwbKv+bIeetQN1S3tgvX+AXb1al+BV1aN7SA0wLuwdfXVzVr1rQdA27kgm7pAwAAUNxlZOfqrgkr9NXKXXqga92LKrR/eqR7fdWrGKwHp8Qr9WhmASUFAM9GqQUAADhPRzNzdOv4PzRr3T49d3Uj3ds54qILrSQF+HrrzeujdTg9W49+tZo5hQBwDii1AAAA5+HgsSzd8OFiLd1+QCNjo3Rz2/AC3X6DyqX0cPd6mrVunyb9kVig2wYAT0SpBQAAOEd7D2co9v1FWr83Te/dEKPrYsIKZT+3taupS+qU13PfrdO2/ccKZR8A4CkotQAAAOdgR+ox9X1/oXYfOq6Pb22hbo0qFdq+vLyM3ugbJX9fLw2buFLZuXmFti8AcHeUWgAAgLPYuDdNfcYuUlpGjr64o7Xa1i5f6PusVDpAL1/bRPFJhzVm9uZC3x8AuCtKLQAAwL9YufOgYt9fJC8jTR7cRlHVyhTZvq9oUll9m4XpnbkJ+mP7gSLbLwC4E0otAADAP1iQsF83fLREpUv4auqdbVW3YnCRZ3jm6kYKKxuo+yfF6UhGdpHvHwBcHaUWAADgDGau2atbx/+hamUDNfXONqoWEmglR0l/H43qF609hzP07LdrrWQAAFdGqQUAADjN1OVJGjJhuRpWKaVJg1urQqkAq3ma1SirezrV0Vcrdun7VbutZgEAV0OpBQAAOMW437fpwSnxalO7nCbc3kplAv1sR5Ik3XtZHTWtXkaPf7Vauw8dtx0HAFwGpRYAAECS4zgaNWuT/vv9Ol3eqKLG3dJCQf4+tmOd5OPtpTf7RSs3z9EDk+OVl+fYjgQALoFSCwAAir28PEfPfbdOo2dvVp9mYXpnQIz8fbxtx/qbGuWC9MzVjbRoa6o+nL/VdhwAcAmUWgAAUKzl5Obpoamr9PHC7bqtXU291jtSPt6u+xGpb7MwdW9USW/8vFFrdh22HQcArHPdd2wAAIBClpGdqyETVmjaiiTd36Wunrqqgby8jO1Y/8oYo5eva6KQID8NmxSnjOxc25EAwCpKLQAAKJaOZeboP5/8oZ/X7dMzPRvqvi4RMsa1C+2fygb56Y2+UUpIPqqXf1hvOw4AWEWpBQAAxc6h9Czd8NESLd56QCP6RunWdjVtRzpv7SNC9Z9LauqTRTs0d2Oy7TgAYA2lFgAAFCvJRzLU7/3FWrf7iN69IUa9m4XZjnTBHrq8nupXCtZDU1Zp/9FM23EAwApKLQAAKDZ2pqarz9hFSjyYrvG3ttDljSrZjnRRAny99eb10TqSka1Hp62S43CbHwDFD6UWAAAUC5v2panP2IU6fDxbE25vpXZ1ytuOVCDqVyqlR7rX1y/rk/XF0p224wBAkaPUAgAAjxeXeEix7y+SJE0e3EZNq5e1nKhg3do2XO0jyuv579dpS8pR23EAoEhRagEAgEdbmLBfN3y4WMEBPpp6Z1vVqxRsO1KB8/IyeqNvlEr4euv+SXHKzs2zHQkAigylFgAAeKyf1+7VLR//oaplS2jqnW1VvVyg7UiFpmKpAL18XaRWJR3Wm79ssh0HAIoMpRYAAHikr1Yk6a4JK9SgcilNGtRGFUsF2I5U6Lo3rqR+zavp3XlbtHTbAdtxAKBIUGoBAIDH+XjBNg2fHK9WNUM04fZWKhvkZztSkXm6Z0NVDwnU/ZPidCQj23YcACh0lFoAAOAxHMfRmNmb9ex369S1YUWNu6WFSvr72I5VpIL8ffRmv2jtPZKhp79ZYzsOABQ6Si0AAPAIeXmOXpixXiNnbdJ1MVX13g0xCvD1th3LiqbVy2roZRH6Jm63psftsh0HAAoVpRYAALi9nNw8PTxtlf73+zbd0jZcb/SJko938f6Yc3en2mpWo6ye/GaNdh06bjsOABSa4v1uDwAA3F5mTq7u+WKlpi5P0n2dI/RMz4by8jK2Y1nn4+2lUbHRchxp+KQ45eY5tiMBQKGg1AIAALd1LDNHt3+yTDPX7tXTVzXU/V3ryhgK7Z+qlwvUs1c30pJtB/TBb1ttxwGAQkGpBQAAbulwerZu/N8SLUjYr9f7ROq2S2rajuSSesdU1ZVNKmnkrI1as+uw7TgAUOAotQAAwO0kp2Wo3weLtHbXEb17Q4z6Nq9mO5LLMsbopWubqFyQv+6buFLHs3JtRwKAAkWpBQAAbiXxQLr6jl2knQfSNe6WFureuLLtSC6vTKCfRsRGaUvKMb30w3rbcQCgQFFqAQCA29i8L019xi7UofRsfX57K10SUd52JLfRrk553dG+pj5bvENzNuyzHQcACgylFgAAuIX4xEOKfX+R8hxp0uDWiqle1nYkt/Pg5fXUoHIpPTx1lfYfzbQdBwAKBKUWAAC4vEVbUjXgw8UqGeCjqXe2Uf1KpWxHckv+Pt4afX20jmTk6OGpq+Q43OYHgPuj1AIAAJf2y7p9unn8UlUpU0JTBrdVjXJBtiO5tboVg/XYFfU1Z0OyPl+y03YcALholFoAAOCyvl6ZpMGfL1eDSsGaPLiNKpUOsB3JI9zSNlwd6obqxRnrlJB81HYcALgolFoAAOCSPl20XfdPilfL8BBNuKO1ygb52Y7kMYwxeqNPpAL9fDRs0kpl5eTZjgQAF4xSCwAAXIrjOHp7zmY9PX2tujSoqPG3tlBJfx/bsTxOhVIBeuW6Jlqz64hG/bLJdhwAuGCUWgAA4DIcx9FLP6zXGz9v0rVNq+q9G2MU4OttO5bH6taokvq3rKaxv27R4q2ptuMAwAWh1AIAAJeQm+fo0Wmr9eH8bbq5TQ2N6BslX28+qhS2J3s0VI2QQA2fFKfDx7NtxwGA88b/FAAAwLrMnFzd++UKTVqWqKGX1dGzVzeSl5exHatYCPL30ZvXN9W+tEw99c0a23EA4LxRagEAgFXpWTm6/ZNl+mH1Xj3Zo4GGd6snYyi0RSm6WhkN6xyhb+N3a3rcLttxAOC8UGoBAIA1h9OzddP/lmpBwn691jtSt7evZTtSsTWkUx01r1FWT369RkkH023HAYBzRqkFAABWpKRlqt8Hi7Qq6ZDeGRCj2BbVbEcq1ry9jEb1i5YjafikeOXmObYjAcA5odQCAIAil3QwXX3HLtSO1HT97+YWuqJJZduRIKlaSKD+26uRlm4/oLG/brEdBwDOCaUWAAAUqYTkNPV5b5EOHMvS57e3VIe6obYj4RTXNq2qHpGVNWrWJq1KOmQ7DgCcFaUWAAAUmdVJhxX7/mLl5DmaNLiNmtUIsR0JpzHG6KVrmig02F/DJsYpPSvHdiQA+FeUWgAAUCSWbE1V/w8Xq4Svt6be2UYNKpeyHQn/oHSgr0bERmlb6jG9OGO97TgA8K8otQAAoNDN2bBPA8ctVaXSAZp2V1uFlw+yHQln0bZ2eQ1qX0sTluzUL+v22Y4DAP/orKXWGDPOGJNsjFlzytjrxpgNxphVxpivjTFlTnntMWNMgjFmozHm8lPGmxljVue/NsZwAzoAAIqF6XG7NOjT5apbMViTB7dRpdIBtiPhHA3vVlcNK5fSI9NWKSUt03YcADijczlS+7Gk7qeNzZLU2HGcSEmbJD0mScaYhpKul9Qof513jTHe+eu8J2mQpIj8r9O3CQAAPMxni3do2KQ4NatRVl/c0UohQX62I+E8+Pt4a/T10TqamaOHp8bLcbjNDwDXc9ZS6zjOb5IOnDb2s+M4f141YLGksPzHvSRNdBwn03GcbZISJLU0xlSWVMpxnEXOiXfDTyVdU1A/BAAAcC2O4+iduQl66ps1uqxeBX1yW0sFB/jajoULEFExWI9f2UBzN6bos8U7bMcBgL8piDm1t0n6Mf9xVUmJp7yWlD9WNf/x6eMAAMDDOI6jV37coNd/2qhe0VU09qZmCvD1PvuKcFkD29RQx3qhenHGeiUkp9mOAwB/cVGl1hjzhKQcSRP+HDrDYs6/jP/TdgcZY5YZY5alpKRcTEQAAFCEcvMcPf71ar3/21bd1LqGRsVGy9eb61K6O2OMXusTqSB/H903MU5ZOXm2IwHASRf8v4wx5mZJV0m6wfn/CRZJkqqdsliYpN3542FnGD8jx3E+cBynueM4zUNDuSE7AADuICsnT0MnrtSXSxN1T6c6+m+vRvLy4rqQnqJCcIBe6x2ptbuPaMSsjbbjAMBJF1RqjTHdJT0i6WrHcdJPeelbSdcbY/yNMTV14oJQSx3H2SMpzRjTOv+qxwMlTb/I7AAAwEUcz8rVHZ8u04xVe/TElQ304OX1xI0OPE+XhhU1oFV1ffDbVi3akmo7DgBIOrdb+nwpaZGkesaYJGPMfyS9LSlY0ixjTJwxZqwkOY6zVtJkSeskzZR0t+M4ufmbukvSRzpx8agt+v95uAAAwI0dPp6tm/63RPM3p+jV3k10R4datiOhED3Zo4FqlgvS8MlxOpyebTsOAMi4+qXZmzdv7ixbtsx2DAAAcAYpaZm6edxSbU5O0+jrm+rKJpVtR0IRWJV0SNe9u1DdG1fSW/2bclQewEUxxix3HKf5ha7PlRsAAMAF2XXouGLfX6St+4/qo5tbUGiLkciwMrq/a119v2qPvonbZTsOgGKOUgsAAM5bQvJR9XlvofYfzdTn/2mlS+tyYcfi5s5La6tleIie/matEg+kn30FACgkPrYDAABQFHJy87R46wFl5+bJ28vIx8vI+5QvHy+vE9+988eM+ctzHy+vE2Pep6xrTLG8uu+aXYc1cNxSeRlp4qDWalSltO1IsMDby2hkvyhd8eZ8DZ8cp4mD2si7GP57AGAfpRYA4PHmbUzWizPWa3Py0QLftpfR34ux14my63Ny/P9fP+O4t5GX+fO514nv3idK86nLnNyGOfX5KSXc+7Rt/KW0/zWj9xlynEvBT0g+qiGfr1CpEr767D8tVSu0ZIH/mcJ9hJUN1PPXNNawSXF6b16C7rkswnYkAMUQpRYA4LE27UvTizPW69dNKapRLlBj+jdV9ZBA5eY5ys1zlJOXl//dUW6uo1zH+f/neXnKyT3x/OR47l9fz83TieXyTh0/bRunjJ26zP9vw1FWzinbOH2feXnKzT1l247zl+c5eXnKK+JrPtYODdLnt7dS5dIlinbHcEm9oqto9oZkvfnLZrWPCFVUtTK2IwEoZii1AACPs/9opkbN2qQvl+5UkL+PnuzRQAPbhMvPxzMvJeE4ZyrM+YU3T38t7/nFOc85c3n/s+D/tTT/f9k2RurWsJLKBvnZ/rHhIowxeuGaxlq+/YCGTYrT9/deoiB/PmICKDq84wAAPEZGdq4+Xrhd78xJUHp2rga2CdfQzhEK8fACZvJPR/bxtp0ExVXpEr4a2S9a/T9crBdmrNfL1zWxHQlAMUKpBQC4Pcdx9MPqvXpl5nolHjiuy+pX0ONXNlCdCsz3BIpK61rlNLhDbY39dYs61QtVt0aVbEcCUExQagEAbi0u8ZCe/36dlu84qPqVgvXZf1qqfQS3lwFsGN61rn5PSNGjX61WdPUyqhAcYDsSgGLAMycXAQA83u5DxzVs4kpd884C7Ug9ppeva6IZQ9tTaAGL/Hy89Ga/pkrPytFDU1bJcYr4KmYAiiWO1AIA3MqxzByN/XWLPvhtqxxJd3eqrbs61lFJLkwDuIQ6FUrqiSsb6Knpa/XJwu26pV1N25EAeDg+AQAA3EJunqNpy5P0+s8blZKWqaujqujh7vUUVjbQdjQAp7mxdQ3N3Ziil37coLZ1yqtuxWDbkQB4ME4/BgC4vIUJ+3XVW7/r4WmrVK1sCX01pK3G9G9KoQVclDFGr/aOVLC/j+6bGKfMnFzbkQB4MEotAMBlbU05qts/WaYBHy3RkePZeqt/U027q61iqpe1HQ3AWYQG++u1PpFav+eIRvy8yXYcAB6M048BAC7nUHqWRs/erM8W7VCAr7ce7l5Pt7WrqQBfbsQKuJPODSrqxtbV9eH8repYN1Rt65S3HQmAB6LUAgBcRlZOnj5bvENjZm9WWka2+rWoruFd6yo02N92NAAX6IkrG2rhllQNnxyvmcPaq0ygn+1IADwMpx8DAKxzHEc/r92ry9/8Tc9/v06RYaX1w33t9fJ1TSi0gJsr4eet0f2aav/RTD3x9Rpu8wOgwHGkFgBg1drdh/XC9+u1aGuqaocGafwtLdSxXqiMMbajASggTcJKa3i3unpt5kZdtqKCejcLsx0JgAeh1AIArEg+kqE3ft6oKcuTVKaEr/7bq5H6t6wuX29OIgI80eAOtTVvY4qe+XatWtYMUbUQrl4OoGDwyQEAUKSOZ+VqzOzN6vjGPH29cpduv6Sm5j3USQPbhFNoAQ/m7WU0ql+0jJGGTYpTTm6e7UgAPARHagEARSIvz9H0+F16beZG7Tmcoe6NKumxK+urRrkg29EAFJGqZUrohWsa676JcXp33hYN7RxhOxIAD0CpBQAUuj+2H9AL369TfNJhNalaWm/2i1arWuVsxwJgQa/oqpqzIVmjZ29W+4jyasp9pwFcJEotAKDQ7ExN1ysz1+uH1XtVsZS/RvSN0rVNq8rLi4tAAcXZf3s11rLtB3X/pDjNGNpeQf58JAVw4Zi8BAAocEcysvXyD+vVZeSvmrshRcO6RGjugx3Vu1kYhRaASpfw1cjYKO04kK7nv19nOw4AN8evxQAABSYnN09f/pGoUbM26WB6lnrHhOnBbvVUqXSA7WgAXEyrWuV016W19e68LepYr4K6N65kOxIAN0WpBQAUiHkbk/XijPXanHxUrWqG6KmrGqpx1dK2YwFwYcO61NX8zfv12Fer1LR6GVUsxS/AAJw/Tj8GAFyUjXvTNHDcUt0y/g9l5eZp7I3NNHFQawotgLPy8/HSm9dH63h2rh6cEq+8PMd2JABuiCO1AIALsv9opkbN2qQvl+5UkL+PnuzRQAPbhMvPh9+XAjh3tUNL6skeDfXkN2v08cLtuu2SmrYjAXAzlFoAwHnJyM7V+AXb9c7cBB3PztXANuEa2jlCIUF+tqMBcFM3tKqueRuT9crMDWpbp5zqVyplOxIAN8Kv0wEA58RxHH2/are6jPxVr87coFY1Q/TTsA569upGFFoAF8UYo1d6R6pUgI+GTYxTRnau7UgA3AilFgBwVnGJh9Rn7CLd88VKlfT30ef/aaX/3dJCdSqUtB0NgIcoX9Jfr/eJ0oa9aXrjp4224wBwI5x+DAD4R7sOHdfrM7G84HkAACAASURBVDfom7jdKl/SX69c10R9m1eTN/eaBVAIOtWvoIFtauij37epY70KuiSivO1IANwApRYA8DfHMnM09tct+uC3rXIk3d2ptu7qWEcl/flvA0DheuyKBlqQsF8PTInTzPs6qCzTGwCcBacfAwBOys1zNOmPner4xjy9NSdBlzeqpDkPXKqHLq9PoQVQJEr4eWv09U114FiWHv96tRyH2/wA+Hd8QgEASJIWJuzX8zPWa/2eI4qpXkbv39RMMdXL2o4FoBhqXLW0HuhWT6/8uEFTlicptnk125EAuDBKLQAUc1tSjurlH9brl/XJqlqmhN7q31RXRVaWMcybBWDPHe1rad7GZD337Vq1qhmiGuWCbEcC4KI4/RgAiqlD6Vl69tu1unzUb1q89YAe7l5Psx+4VD2jqlBoAVjn7WU0MjZa3l5G90+KU05unu1IAFwUR2oBoJjJysnTZ4t3aMzszUrLyNb1Lavr/i51FRrsbzsaAPxFlTIl9OK1TXTvlyv19twEDetS13YkAC6IUgsAxYTjOJq1bp9e/nGDtu0/pvYR5fVEjwaqX6mU7WgA8I96RlXRnA3JemtOgjrUDWWuP4C/4fRjACgG1uw6rAEfLtGgz5bLy0jjb2mhT29rSaEF4Bae69VIlUoFaNjEOB3NzLEdB4CLodQCgAfbdyRDD02JV8+3f9eGvUf0316NNHNYB3WqX4F5swDcRqkAX715fbSSDqbruW/X2o4DwMVw+jEAeKDjWbn6cP5Wjf11i7Jz83T7JTV1z2URKl3C13Y0ALggLcJDNKRjHb09N0GX1a+gK5pUth0JgIug1AKAB8nLc/RN3C69NnOj9h7J0BWNK+nRK+pzKwwAHuG+LhGavzlFj329Wk2rl1Wl0gG2IwFwAZx+DAAe4o/tB3TNuws0fHK8QoP9NWlQa713YzMKLQCP4evtpVH9opWZnafhk+OUm+fYjgTABVBqAcDN7UxN15AJy9V37CLtO5KhEX2jNP3udmpVq5ztaABQ4GqFltRzVzfSwi2pemvOZttxALgATj8GADd1JCNb78xJ0PgF2+XtZTSsS4QGdailQD/e2gF4tr7Nw7R4W6pGz96sFuEhalenvO1IACzikw8AuJmc3Dx9uXSnRv2yWQfTs9Q7JkwPdqvH3DIAxYYxRi9c01irkw7rvokr9cPQ9qpQivdAoLji9GMAcCNzNyar++j5emr6WkVUKKnv7rlEb/SNotACKHYC/Xz07g0xOpaZq6ETVyonN892JACWUGoBwA3sO5KhgeOW6tbxfygnN0/v39RMEwe1VuOqpW1HAwBrIioG64VrGmvx1gMaPZv5tUBxxenHAODi8vIcDZsYp7jEQ3qyRwMNbBMuPx9+JwkAktS7WZiWbEvV23MT1Dw8RJfWDbUdCUAR41MRALi4TxZt16KtqXq6Z0Pd3r4WhRYATvPc1Y1Vt0Kw7p8Upz2Hj9uOA6CI8ckIAFxYQvJRvfLjBnWqF6rrW1SzHQcAXFIJP2+9c0OMMrJzNfRL5tcCxc1ZS60xZpwxJtkYs+aUsRBjzCxjzOb872VPee0xY0yCMWajMebyU8abGWNW5782xhhjCv7HAQDPkZObpwemxKuEn7de7R0p3jYB4J/VqVBSL1/XRH9sP6g3ft5kOw6AInQuR2o/ltT9tLFHJc12HCdC0uz85zLGNJR0vaRG+eu8a4zxzl/nPUmDJEXkf52+TQDAKd6bt0XxiYf0fK/G3KoCAM5Br+iq6t+yusb+ukVzNuyzHQdAETlrqXUc5zdJB04b7iXpk/zHn0i65pTxiY7jZDqOs01SgqSWxpjKkko5jrPIcRxH0qenrAMAOM2aXYc1evZm9Yyqop5RVWzHAQC38UzPhmpQuZSGT47XrkPMrwWKgwudU1vRcZw9kpT/vUL+eFVJiacsl5Q/VjX/8enjAIDTZGTn6oHJ8QoJ8tPzvRrZjgMAbiXA11vv3hCjnFxH936xQtnMrwU8XkFfKOpME76cfxk/80aMGWSMWWaMWZaSklJg4QDAHYyatUkb96Xp1d6RKhPoZzsOALidmuWD9ErvJlqx85Bem7nBdhwAhexCS+2+/FOKlf89OX88SdKpl+cMk7Q7fzzsDONn5DjOB47jNHccp3loKPcaA1B8/LH9gD6Yv1X9W1ZTp/oVzr4CAOCMroqsopta19CH87dp1jrm1wKe7EJL7beSbs5/fLOk6aeMX2+M8TfG1NSJC0ItzT9FOc0Y0zr/qscDT1kHACDpWGaOHpgcr7CyJfREj4a24wCA23vyqgZqUrW0Hpgcp8QD6bbjACgk53JLny8lLZJUzxiTZIz5j6RXJHU1xmyW1DX/uRzHWStpsqR1kmZKuttxnNz8Td0l6SOduHjUFkk/FvDPAgBu7aUf1ivxYLpG9I1WSX8f23EAwO35+3jrnQExciTd8+VKZeUwvxbwRObExYhdV/PmzZ1ly5bZjgEAhWrexmTdMv4P3dG+JkdpAaCAzVyzV3d+vly3tgvXMz25AB/gaowxyx3HaX6h6xf0haIAAOfpcHq2Hpm2ShEVSuqBbvVsxwEAj9O9cSXd2i5c4xds18w1e2zHAVDAKLUAYNnT365R6tEsjYyNVoCvt+04AOCRHruigaKqldFDU1dpZyrzawFPQqkFAItmrNqj6XG7de9lEWoSVtp2HADwWH4+Xnq7f1MZSXd/sUKZOblnXQeAe6DUAoAlyWkZevKb1YoMK60hnWrbjgMAHq9aSKBGxEZr9a7DenHGettxABQQSi0AWOA4jh6btlrpWbkaGRslX2/ejgGgKHRtWFF3tK+pTxft0PerdtuOA6AA8CkKACyYsixJszck6+Hu9VWnQrDtOABQrDzcvb5iqpfRo9NWa9v+Y7bjALhIlFoAKGKJB9L13Hdr1bpWiG5tG247DgAUO77eXnp7QIx8vI3unrBCGdnMrwXcGaUWAIpQXp6jB6fEyxij1/tEycvL2I4EAMVSlTIlNCo2Wuv2HNF/v19nOw6Ai0CpBYAiNH7hdi3ZdkBPX9VQ1UICbccBgGKtU/0KuvPS2vpiyU5Nj9tlOw6AC0SpBYAikpCcptdmblDn+hXUt3mY7TgAAEkPdqurFuFl9dhXq5WQfNR2HAAXgFILAEUgOzdPwyfHK9DPWy/3biJjOO0YAFyBj7eX3uofowBfb909YYWOZzG/FnA3lFoAKALvzt2iVUmH9eK1TVQhOMB2HADAKSqVDtCoftHalJymZ75dYzsOgPNEqQWAQrY66bDemrNZvaKr6MomlW3HAQCcwaV1Q3V3xzqavCxJ05Yn2Y4D4DxQagGgEGVk52r45DiVK+mn/17d2HYcAMC/GNYlQq1qhujJb9Zo874023EAnCNKLQAUohE/b9Tm5KN6tXekSgf62o4DAPgXJ+bXNlWQv7eGTFih9Kwc25EAnANKLQAUkiVbU/XR79t0Q6vq6livgu04AIBzUKFUgEZf31QJKUf15Ddr5DiO7UgAzoJSCwCF4Ghmjh6cGq9qZQP1+JUNbMcBAJyHdnXKa+hlEfpqxS5NWcb8WsDVUWoBoBC8OGOdkg4e14jYKAX5+9iOAwA4T0M7R6hdnXJ6avoabdh7xHYcAP+CUgsABWzuhmR9uTRRgzrUUovwENtxAAAXwNvL6M1+TVWqhK+GTFiho5nMrwVcFaUWAArQofQsPTJtlepVDNbwrnVtxwEAXITQYH+91b+ptu8/pie+Xs38WsBFUWoBoAA9NX2tDhzL0ojYKPn7eNuOAwC4SK1rldPwrnU1PW63vlyaaDsOgDOg1AJAAfkufre+i9+t+zpHqHHV0rbjAAAKyJCOddShbqie/W6t1u4+bDsOgNNQagGgACQfydBT09coqloZ3dWxtu04AIAC5OVlNCo2SiGBfrp7wgqlZWTbjgTgFJRaALhIjuPokWmrlJGdq5GxUfLx5q0VADxNuZL+emtAUyUePK5Hv2J+LeBK+OQFABdp4h+JmrsxRY90r6/aoSVtxwEAFJIW4SF6sFs9zVi1R58v3mE7DoB8lFoAuAiJB9L1wvfr1LZ2Od3cJtx2HABAIRvcoZY61QvV89+v1+ok5tcCroBSCwAXKC/P0QNT4uVljF7vGyUvL2M7EgCgkHl5GY2MjVb5kn66+4sVOnyc+bWAbZRaALhA4xZs09JtB/R0z4aqWqaE7TgAgCJSNshPbw2I0e5Dx/Xw1Hjm1wKWUWoB4AJs2pem137aqC4NKqpPszDbcQAARaxZjbJ6pHt9/bR2n8Yv2G47DlCsUWoB4Dxl5+Zp+OQ4lfT30cvXNZExnHYMAMXR7e1rqkuDinr5x/WKSzxkOw5QbFFqAeA8vT0nQWt2HdFL1zZWaLC/7TgAAEuMMRrRN0oVggN094QVOpSeZTsSUCxRagHgPKxKOqS35ybo2qZV1b1xZdtxAACWlQ701Ts3xCg5LUMPTlnF/FrAAkotAJyjjOxc3T8pTqEl/fXs1Y1sxwEAuIjoamX02BUN9Mv6ffpo/jbbcYBih1ILAOfo9Z82akvKMb3eN1KlS/jajgMAcCG3tgtX90aV9OrMDVq+46DtOECxQqkFgHOwaEuqxi3Yppta11D7iFDbcQAALsYYo1f7RKpymQDd+8UKHTzG/FqgqFBqAeAs0jKy9eCUeNUICdRjV9a3HQcA4KJKl/DVuwOaaf/RLA2fHKe8PObXAkWBUgsAZ/HC9+u15/BxjYiNUqCfj+04AAAX1iSstJ68qoHmbkzR+79ttR0HKBYotQDwL+Zs2KdJyxI1+NLaalYjxHYcAIAbuKl1DfWIrKw3ft6oP7YfsB0H8HiUWgD4BweOZenhqatVv1KwhnWJsB0HAOAmjDF65bomqh4SqHu+WKHUo5m2IwEejVILAGfgOI6e+maNDh/P0sjYaPn7eNuOBABwI8EBvnp7QFMdTM/W/ZPjmV8LFCJKLQCcwbfxuzVj9R4N61JXDauUsh0HAOCGGlUprWd7NtJvm1L07rwE23EAj0WpBYDT7DuSoaenr1XT6mU0uEMt23EAAG6sf8tq6hVdRSNnbdKiLam24wAeiVILAKdwHEcPT12lzJxcjYyNlo83b5MAgAtnjNFL1zZRePkgDZ24UilpzK8FChqf1gDgFF8s3alfN6Xo8SsbqGb5INtxAAAeIMjfR+/eEKO0jGwNm7RSucyvBQoUpRYA8u1IPaYXZ6zXJXXK68ZWNWzHAQB4kPqVSum/VzfWgoRUvTVns+04gEeh1AKApNw8Rw9OiZe3l9FrfSLl5WVsRwIAeJi+zcN0XUxVjZ69Wb9v3m87DuAxKLUAIOmj+Vv1x/aDerZnI1UpU8J2HACABzLG6IVrGqtOaEkNm7RSyUcybEcCPAKlFkCxt3Fvmkb8vEmXN6qo62Kq2o4DAPBggX4n5tcey8zVvV+uVE5unu1IgNuj1AIo1rJy8jR8cpyCA3z00rVNZAynHQMACldExWC9cE1jLdl2QG/+wvxa4GJRagEUa2/P2ay1u4/opeuaqFxJf9txAADFRO9mYYptHqZ35iXo100ptuMAbo1SC6DYiks8pHfmbVHvmDBd3qiS7TgAgGLmuasbq26FYN0/KU57Dh+3HQdwWxdVao0x9xtj1hpj1hhjvjTGBBhjQowxs4wxm/O/lz1l+ceMMQnGmI3GmMsvPj4AXJiM7FwNnxynisH+eubqhrbjAACKoRJ+3nrnhhhlZOdqKPNrgQt2waXWGFNV0lBJzR3HaSzJW9L1kh6VNNtxnAhJs/OfyxjTMP/1RpK6S3rXGON9cfEB4MK8OnODtqYc0+t9o1QqwNd2HABAMVWnQkm9fF0T/bH9oN74eZPtOIBbutjTj30klTDG+EgKlLRbUi9Jn+S//omka/If95I00XGcTMdxtklKkNTyIvcPAOdt4Zb9Gr9gu25uU0Pt6pS3HQcAUMz1iq6q/i2ra+yvWzRnwz7bcQC3c8Gl1nGcXZLekLRT0h5Jhx3H+VlSRcdx9uQvs0dShfxVqkpKPGUTSfljAFBkjmRk66Epq1SrfJAevaKB7TgAAEiSnunZUA0ql9LwyfHadYj5tcD5uJjTj8vqxNHXmpKqSAoyxtz4b6ucYcz5h20PMsYsM8YsS0nhanAACs7z363TnsPH9UZslEr4MQMCAOAaAny99e4NMcrJdXTvFyuUzfxa4JxdzOnHXSRtcxwnxXGcbElfSWoraZ8xprIk5X9Pzl8+SVK1U9YP04nTlf/GcZwPHMdp7jhO89DQ0IuICAD/b9a6fZqyPEl3daytmOplz74CAABFqGb5IL3Su4lW7Dyk12ZusB0HcBsXU2p3SmptjAk0xhhJnSWtl/StpJvzl7lZ0vT8x99Kut4Y42+MqSkpQtLSi9g/AJyz1KOZeuyrVWpQuZTu61zXdhwAAM7oqsgqGtimhj6cv02z1jG/FjgXFzOndomkqZJWSFqdv60PJL0iqasxZrOkrvnP5TjOWkmTJa2TNFPS3Y7j5F5UegA4B47j6Mlv1ujI8RyNjI2Snw+36AYAuK4nejRQk6ql9cDkOCUeSLcdB3B5xnHOOK3VZTRv3txZtmyZ7RgA3Ng3K3dp2KQ4PdK9vu7qWNt2HAAAzmpnarp6vDVftUJLasrgNvxCFh7NGLPccZzmF7o+/zoAeLQ9h4/r6elr1KxGWQ3qUMt2HAAAzkn1coF6vU+U4hMP6eUf19uOA7g0Si0Aj+U4jh6eukrZuY5G9I2St9eZLsIOAIBr6t64km5tF67xC7Zr5po9tuMALotSC8Bjfb5kp+Zv3q/HezRQePkg23EAADhvj13RQFHVyuihqau0M5X5tcCZUGoBeKTt+4/ppRnr1T6ivG5sVd12HAAALoifj5fe7t9URtKQL5YrI5vrrAKno9QC8Di5eY4emBIvH2+j1/pE6sRdxwAAcE/VQgI1IjZaa3Yd0YszmF8LnI5SC8DjfPDbVi3fcVDP92qsyqVL2I4DAMBF69qwou5oX1OfLd6h7+J3244DuBRKLQCPsmHvEY2atUlXNK6kXtFVbMcBAKDAPNy9vmKql9FjX63Wtv3HbMcBXAalFoDHyMrJ0/2T4lWqhI9euKYxpx0DADyKr7eX3h4QIx9voyETVjC/FshHqQXgMUbP3qT1e47o5esiVa6kv+04AAAUuCplSmhUbLTW7zmi575bZzsO4BIotQA8woqdB/XevC3q2yxMXRtWtB0HAIBC06l+Bd15aW19uXSnpsftsh0HsI5SC8DtHc/K1YOT41W5dAk93bOh7TgAABS6B7vVVYvwsnrsq9VKSD5qOw5gFaUWgNt7deYGbd1/TK/3jVRwgK/tOAAAFDofby+91T9GAb7eunvCCh3PYn4tii9KLQC3tiBhvz5euF23tgtX29rlbccBAKDIVCodoFH9orUpOU3PfLvGdhzAGkotALd1JCNbD02JV63QID3Svb7tOAAAFLlL64bq7o51NHlZkqYtT7IdB7CCUgvAbT337TrtS8vUyNhoBfh6244DAIAVw7pEqFXNED35zRpt3pdmOw5Q5Ci1ANzST2v3atqKJN3dsbaiq5WxHQcAAGtOzK9tqiB/bw2ZsELpWTm2IwFFilILwO3sP5qpx79arUZVSumeyyJsxwEAwLoKpQI0+vqmSkg5qie/WSPHcWxHAooMpRaAW3EcR098vVppGTkaGRstPx/exgAAkKR2dcrrvs4R+mrFLk1ZxvxaFB98GgTgVr5euUs/rd2nB7rVVb1KwbbjAADgUu69LEKX1Cmvp6av0Ya9R2zHAYoEpRaA29h96Lie+XatWoSX1e3ta9mOAwCAy/H2MhrVL1qlSvhqyIQVOprJ/Fp4PkotALeQl+fo4amrlJvnaETfaHl7GduRAABwSaHB/nqrf1Nt339MT3y9mvm18HiUWgBu4fMlO/R7wn490aOBqpcLtB0HAACX1rpWOQ3vWlfT43bry6WJtuMAhYpSC8Dlbdt/TC/9sF6X1g3VgJbVbccBAMAtDOlYRx3qhurZ79Zq7e7DtuMAhYZSC8Cl5eTmafjkOPn7eOu1PpEyhtOOAQA4F15eRqNioxQS6Ke7J6xQWka27UhAoaDUAnBp7/+2VSt3HtJ/ezVSxVIBtuMAAOBWypX011sDmirx4HE9Oo35tfBMlFoALmvd7iN685dN6tGksq6OqmI7DgAAbqlFeIge7FZPM1bv0WeLd9iOAxQ4Si0Al5SZk6vhk+NUJtBPz1/TmNOOAQC4CIM71FKneqF64fv1Wp3E/Fp4FkotAJf05i+btWFvml7t3UQhQX624wAA4Na8vIxGxkarfEk/DfliuQ4fZ34tPAelFoDLWb7jgN7/dYv6Na+my+pXtB0HAACPUDbIT28NiNGeQxl6eGo882vhMSi1AFxKelaOHpgcr8qlS+jJqxrYjgMAgEdpVqOsHuleXz+t3af//b7NdhygQFBqAbiUV37coB0H0jUiNkrBAb624wAA4HFub19TXRtW1Asz1uvRaau41Q/cHqUWgMuYvzlFny7aodva1VTrWuVsxwEAwCMZY/T2gKa6q2NtTV6WqO5vztfCLfttxwIuGKUWgEs4fDxbD01ZpToVSuqhy+vZjgMAgEfz9/HWI93ra8qdbeXn46UBHy7Rs9+u1fGsXNvRgPNGqQXgEp77dq1SjmZqZGyUAny9bccBAKBYaFajrGYMvUS3tA3Xxwu368ox87V8x0HbsYDzQqkFYN3MNXv01cpduqdTHUWGlbEdBwCAYiXQz0fPXt1IX9zeSlk5eeo7dqFenblBmTkctYV7oNQCsColLVOPf71GTaqW1j2X1bEdBwCAYqttnfKaOay9+jarpvfmbdHVby3Qml2HbccCzopSC8Aax3H0+NerdTQzRyNjo+TrzVsSAAA2BQf46tU+kRp3S3MdSM/SNe8s0JjZm5Wdm2c7GvCP+AQJwJppK3Zp1rp9evjyeoqoGGw7DgAAyHdZ/Yr6eVgHXdmkskbO2qTe7y3U5n1ptmMBZ0SpBWDFrkPH9dy3a9WyZohua1fTdhwAAHCaskF+GtO/qd4ZEKPEA+nq8dbv+vC3rcrNc2xHA/6CUgugyOXlOXpoSrzyHEcj+kbJy8vYjgQAAP5Bj8jK+vn+S9UhIlQv/rBe/T9YrB2px2zHAk6i1AIocp8u2q6FW1L11FUNVS0k0HYcAABwFqHB/vpwYDON6Bul9XuP6IrR8/X54h1yHI7awj5KLYAitSXlqF6ZuUGX1a+gfi2q2Y4DAADOkTFGvZuF6adhHdSsRlk9+c0aDRy3VLsPHbcdDcUcpRZAkcnJzdPwyfEK8PXWK9c1kTGcdgwAgLupUqaEPr2tpV64prGW7zioy9/8TdOWJ3HUFtZQagEUmbG/blF84iE936uxKpQKsB0HAABcIGOMbmxdQz/e1171KwXrgSnxGvTZcqWkZdqOhmKIUgugSKzZdVhv/rJZPaOqqGdUFdtxAABAAahRLkgTB7XRkz0a6NdNKeo26lf9sHqP7VgoZii1AApdZk6uHpgcr5AgPz3fq5HtOAAAoAB5exnd3r6Wfhh6iaqFBGrIhBUa+uVKHUrPsh0NxQSlFkChSjyQrsGfLdfGfWl6tXekygT62Y4EAAAKQZ0KwZp2V1sN71pXP6zeo66jftOcDftsx0IxQKkFUCgyc3L19pzN6jrqVy3ZekDP9myoTvUr2I4FAAAKka+3l4Z2jtA3d7dTuSA/3fbxMj0ydZXSMrJtR4MH87EdAIDnmb85Rc9MX6ut+4/pisaV9NRVDVWlTAnbsQAAQBFpXLW0pt/TTqN/2ayxv27R7wn79XqfSLWtU952NHggjtQC+L/27jw+rrrq4/jnZE+arWu6r6R7KbSl7IuICrKvVlFAeMAFRXgEAbWACoiIC6ggiCDqI8iitIi0LFKWskmhLU2XpBtd0jbdkibNnpznj7lJpm0SoJNmZpLv+/XKa+7cZebkl5uZe+753d/tMJvKqrjy/97jK398BwceuXQ69315qhJaERGRbig1KZHvnTyWJ79xFKlJCXzpwbe5ZXYBVbUN0Q5NuhhVakUkYnUNjTz0+hrufqmIhkbnu58ZzRXHjyQ1KTHaoYmIiEiUTRnak2evOpafzVnOn95YyyuFW7nr/MlMHdYz2qFJF2GxfpPkadOm+bvvvhvtMESkDW+t3s7Mp5dQVFLBSeP6cfPpExjSKyPaYYmIiEgMemPVNq57YjGbyqq44rhRXPOZfJ0EF8xsgbtP29/tI+p+bGa5ZvakmS03s2VmdqSZ9TKzF8ysKHjsGbb+jWa20sxWmNnnInlvEYmukvJqrn7sfWY88BZVdQ08eNE0Hrz4MCW0IiIi0qajRvVhztXHcsG0Ifz+lVWc8Zv5LNlYFu2wJM5FVKk1s0eA19z9QTNLATKA7wM73P0OM7sB6Onu15vZeOBRYDowEHgRGO3u7XaqV6VWJLbUNzTyl7c+5JfPF1JT38jXjh/JN084iPQUnWUVERGRj+/l5SVc/9Riduyu5dsn5vPNT40iOVFD/nRHkVZq9zupNbNsYBEw0sNexMxWACe4+yYzGwDMc/cxZnYjgLv/NFhvLnCLu7/Z3vsoqRWJHQs+3MnMp5ewdNMujs3vw4/PnMiIPj2iHZaIiIjEqdLKWm6eXcCshcVMGpTDLy+YTH5eVrTDkk4Wze7HI4GtwMNm9r6ZPWhmPYA8d98EEDw23ZhyELA+bPsNwTwRiXHbK2r43pOLOPe+N9hZWct9F07hz5dOV0IrIiIiEcnNSOHuGYdy74VT2Fhaxam/eZ0HXl1FQ2Nsj/sjsSWS0Y+TgCnAt939bTO7G7ihnfWtlXmt7q1mdgVwBcDQoUMjCFFEItHQ6Dz233XcOWcFu2vq+drxI7nqxHx6pGrgdBEREek4n580gMOG9+L7//yA2/+9nOcLtnDX+ZMZrhPo8jFEUqndAGxwKHblWgAAHk1JREFU97eD508SSnK3BN2OCR5LwtYfErb9YKC4tRd29wfcfZq7T+vbt28EIYrI/lq8oZRz7p3PD/65hHEDsnjuO8dy4ynjlNCKiIjIAdE3K5UHvjKVX14wmRVbyjnl7tf4y1sfEut3a5Ho2++k1t03A+vNbEww69PAUmA2cHEw72JgVjA9G5hhZqlmNgLIB97Z3/cXkQOjtLKWH/zzA8783XyKy6q5e8YhPHr5Ebq+RURERA44M+OcKYN5/prjmDa8JzOfXsJFD71DcWlVtEOTGBbp6MeHAA8CKcBq4KuEEuXHgaHAOuB8d98RrP8D4FKgHrja3Z/7qPfQQFEinaOx0XnyvQ3c8dxySitrufio4VzzmdFkpyVHOzQRERHphtydv72zjtueXUaiGTefMYFzpwzCrLWrGiWeRW30486ipFbkwFtavIuZs5aw4MOdTB3Wk5+cOZHxA7OjHZaIiIgI67ZXcu0Ti3hn7Q5OGpfH7edMpF9WWrTDkg6kpFZE9tuu6jp+9UIhj7yxltyMFG44ZSznTRlMQoLOgIqIiEjsaGx0Hpq/hjvnrqBHSiK3njWJUw8eEO2wpINEmtRqxBeRbsjdmbWwmNv+vYxtFTV8afpQrvvcGHIzUqIdmoiIiMg+EhKM/zl2JCeM6ct3H1/ElX97jzkFA/nxGRPo2UPHL92dklqRbqZoSzkzZy3hrdU7OHhwDg9eNI3JQ3KjHZaIiIjIRzqoXxZPfeMo7pu3irtfKuKt1dv52bmTOHFsXrRDkyhS92ORbmJ3TT33vFTEH19fQ4/UJL538hhmHDaURHU1FhERkThUUFzGdx9fxPLN5VwwbTAzTxtPlga4jEvqfiwi7XJ3nluymZ/8aymbyqq5YNpgrj95LL0zU6MdmoiIiMh+mzAwh1nfOpq7Xyzi96+sYv7K7dx53sEcfVCfaIcmnUyVWpEubM223dw0awmvFW1j3IBsbj1rAlOH9Yp2WCIiIiId6r11O7n28UWs3rabi48cxvWnjCUjRfW7eKFKrYjso6q2gXvnreT+V1aTmpTAzaeP5ytHDCMpMSHaoYmIiIh0uClDe/LsVcdy59zlPDx/La8UbuUXF0zWyfxuQpVakS7mxaVbuOWZAjbsrOLsQwdx4+fH6l5uIiIi0m28uWo71z6xiE1lVVx+3EiuOWk0acmJ0Q5L2qFKrYgAsH5HJT96poAXl5WQ3y+Tx644giNG9o52WCIiIiKd6shRvZl7zXHc9uxS7n9lNS8vL+GXFxzCxEE50Q5NDhBVakXiXE19Aw+8sprfvrySxATj6pPy+erRI0hWV2MRERHp5l5eUcL1Ty5mx+5avnXiQVz5qYN0jBSDIq3UKqkViWOvFG7l5llLWLu9klMnDeCHp41jQE56tMMSERERiRmllbXcMruApxcWM2lQDr+4YDKj87KiHZaEiTSp1WkKkThUXFrFN/66gIsfegcz48+XTud3F05RQisiIiKyl9yMFH4941Duu3AKG0urOO03r/PAq6toaIzt4p58fLqmViSO1NY38tD8NdzzUhGN7lz72dFcftxIUpM0+IGIiIhIe06ZNIDDRvTi+//4gNv/vZznC7Zw1/mTGd6nR7RDkwip+7FInHhj1TZumlXAypIKThqXx82nj2dIr4xohyUiIiISV9ydpxdu5KZZBdQ3ON///FguPHwYCQkW7dC6LY1+LNLFleyq5tZnlzF7UTFDeqXzx4un8elxedEOS0RERCQumRlnHzqYI0b25vqnPmDmrALmFmzhZ+cdzKBcXcoVj1SpFYlR9Q2NPPLmh/zqhUJq6xv5+gmj+OYJo3SfNREREZEO4u48+s56bn12KYlm3HT6eM6bOhgzVW07kyq1Il3Qu2t38MOnl7B8cznHj+7Lj86YoOs9RERERDqYmfGlw4dyzEF9uPbJRVz35GLmFmzm9nMm0S8rLdrhycekSq1IDNlWUcMdzy3nyQUbGJiTxk2nj+dzE/rrbKGIiIjIAdbY6Dz8xlrunLOc9JREbj1rIqcdPDDaYXULqtSKdAENjc7f3lnHz+csp7K2ga8fP4qrPn0QGSn6FxURERHpDAkJxmXHjOD40X357hOL+Nbf3mfOks385MyJ9OyREu3wpB06YhaJskXrS5k5awmLN5Rx5Mje/OSsCRzUTzcEFxEREYmGg/pl8tTXj+T+V1fz6xcLeXvNDn569iROGq+BOmOVuh+LRElpZS13zl3Bo++so29mKj84dRxnTB6orsYiIiIiMWJp8S7+9/GFLN9czvlTBzPz9PFkpyVHO6wuR92PReJMY6Pz5IIN3DFnOWVVdVx69AiuPimfLH1AioiIiMSU8QOzmfWto7nnpSLum7eK+Su38fPzJ3P0QX2iHZqEUaVWpBMVFJcx8+klvLeulMOG9+THZ05k3IDsaIclIiIiIh/h/XU7+e7ji1i9bTcXHTmMG04Zq/FPOogqtSJxYFd1Hb98vpA/v7mWnhkp3HX+ZM6dMkhdjUVERETixKFDe/LsVcfy87kreGj+Gl4t3MptZ0/i0KG5Sm6jTJVakQPI3Xl64UZue3Y523fX8OXDh3HtZ8eQk6GuxiIiIiLx6s1V27nuyUVs2FkFQM+MZAb1TGdgTjqDeqYzKDf46ZnOwNx0evdIUTGjHarUisSowi3lzHx6CW+v2cHkIbk8fMlhTBqcE+2wRERERCRCR47qzZyrj+M/y0vYsLOSjTurKC6tYu323cxfuY3dtQ17rJ+WnMDA3JZkd2DY4+Ce6fTPSSM5MSFKv038U1Ir0sEqauq5+8VCHp6/lsy0JG4/exIzDhtCQoLOzomIiIh0FZmpSZwxeeA+892dXVX1bCitpLi0mo07K9lYWkVxaTUbSqtYtqyEbRU1e2xjBnlZac2V3aYq76DcNAblZjAwN02DirZDSa1IB3F3nv1gE7f+axmbd1XzhWlDuP6UsfTSzbpFREREug0zIycjmZyMHCYMbL2XXnVdA5vKqikurWLjzio2lFY1Ty/eUMqcJZuoa9jzMtHstCQG9cwIEt0g+Q3r6twnM7XbFlGU1HZR7k5JeQ2FW8qpb3Ry0pPJTU8mJz2Z7PRkdW/oYKu2VnDL7AJeK9rGhIHZ3PvlKUwZ2jPaYYmIiIhIDEpLTmREnx6M6NOj1eWNjc7Wiho2BolucWlV8/SGnVW8vWYH5dX1e2yTkpjAgCDhbS3pHZCbRmpSYmf8ep1OSW0XsHN3LYVbyincUs6KLeUUbq5gxZZyyqrq2tymR0oiuRkpZKcnk5OeRE6Q8OZmpDQnvs3zwqaz05NJ7KZngFpTVdvAb18u4oFXV5OWnMiPzpjAl48YpjYSERERkf2WkGDkZaeRl53WZqFkV3Vdc3W3uLSp2hvq7vxq0VZKymvYe0zgvlmpew5ilZMWVH9D87LTk+JyQCsltXFkd009RSUVFG4Oktct5azYXE5JeUuf/Ky0JMbkZXHqwQMYk5dFfl4mqUmJ7Kqqo7SqlrLKOsqq6imrqgt+aimrqmPNtt3N86rrGtuNIyutJQluSYb3TIRDyXDKHs+z0pK6TJcId+eFpVv40TNL2VhaxTmHDuLGz4+jb1ZqtEMTERERkW4gOy2Z7P7JjO2f3ery2vpGNpdVhyq8e1V8l23axYvLtlBTv+dxf2ZqEgObqr3h1/cGz/tlpcVk8UZJbQyqqW9g9dbdzUlrUwV2/Y6q5nXSkhPI75fFsfl9GdM/k9F5WYzpn0X/7LSIz65U1zWwqznpraO0si4sCd73p6ikIjRdWUdtQ9sJsVnon2+PhDgjed8EOawq3LROVmrsnDVat72SW54p4D/LSxidl8nfrziCw0f2jnZYIiIiIiLNUpISGNo7g6G9M1pd7u5sq6htTnSLS0Ndm5um319fSmnlnj0/kxKM/jlpeyS64V2dB+akk57S+V2cdZ/aKGpodD7c3pS8VjQnr2u27aahMfR3SUowRvbtEUpa87IY3T/0OKRXRsydJXF3qusa90h4Sytrm6ebEuXSvZLiXUHiXN/Y9r6YmGBkh1eIM5qqwEl7VIaz90qYc9OTyUhJ7JCEuLqugftfWc2981aSlGBcfdJoLjl6uK5PFhEREZEuaXdNfVjX5n2v7928q5q9D+F790jZYwTnvau9PTOS9zk2131q44C7U1xW3dJtOHgsKqmgNij5m8HQXhmMzsvi5An9m5PXEX16kJIUH0mTmZGekkh6SiL9c9I+0bbuTmVtw14Jcd2eFeOq2j26Tq/fUUlpZS27quubTwK0JinB2q0M7/OT0dJ1Oi05ATNj3ooSbp5dwIfbKzn14AHMPHX8J/4dRURERETiSY/UJPLzssjPy2p1eX1DI5t3VYeS3bJQoruxNNTluaiknFcKt1JVt+c9e9OTE0NdnMNGco6UktoOtq2iZp9rXgu3VFBR0zI6Wf/sNEb3z+KoUb2buw0f1C+TjJTu++cwM3qkJtEjNYmBn3DHdncqasKuE26lu3RpWFV4x+5a1mzbHUqaq+v2uYA+XEpiAllpSWzfXcvIPj3462WHc0x+nwh/WxERERGR+JeUmMDgnhkM7tl2F+edlXX7dG1uSoILNpaxfXdtxHGo+/F+2lVdR1F4t+Hg2tfwP0puRjJjgqS1KXkd3S+LnAzdODlWNDY65TX1LV2jK/dOhmvZVVXHqL6ZfOXIYV12GHQRERERkWioqm0gIzVJ3Y8PpOq6BlaWVOwxYFPh5nKKy6qb1+mRkkh+XhYnjctr7jY8un8mfTNTY2ZwI2ldQljX5CHRDkZEREREpJvpiIGllNQG6hoaWbtt9x7XvBZuqWDt9t3N3VNTEhMY1S+T6SN6tSSveVkMyk3vMreqERERERERiSfdLqltbHTW76xkxebQQE1NFdhVWyuoawhlrwkGw/v0YGz/LM6YPLC5+/Dw3hkkaaRbERERERGRmNFlk1p3p6S8pjlpXR48Fm2p2GMErkG56Yzpn8UJY/o13+91VN9M0pJ17aSIiIiIiEis6xJJ7c7dtc2jDRduKadwcwUrtpRTVtVys+A+mamM6Z/JjOlDmu/3mt8vk6w0DdokIiIiIiISr+Iqqa2oqaeo+VY5Fc0DN20tr2leJystiTF5WZx68IDma15H52XSOzM1ipGLiIiIiIjIgRDzSe3mXdVc9qf/smJLORt2VjXPT0tOYHReFseP7ttceR2dl0n/7DSNOCwiIiIiItJNxHxSu628hg07qzh0aE9mHDak+X6vg3tmkKgRh0VERERERLq1mE9qJwzMYe41x0U7DBEREREREYlBMX9/GvUkFhERERERkbbEfFIrIiIiIiIi0hYltSIiIiIiIhK3lNSKiIiIiIhI3FJSKyIiIiIiInFLSa2IiIiIiIjELSW1IiIiIiIiErciTmrNLNHM3jezfwXPe5nZC2ZWFDz2DFv3RjNbaWYrzOxzkb63iIiIiIiIdG8dUan9DrAs7PkNwEvung+8FDzHzMYDM4AJwMnAvWaW2AHvLyIiIiIiIt1UREmtmQ0GTgUeDJt9JvBIMP0IcFbY/Mfcvcbd1wArgemRvL+IiIiIiIh0b5FWan8NfA9oDJuX5+6bAILHfsH8QcD6sPU2BPNERERERERE9st+J7VmdhpQ4u4LPu4mrczzNl77CjN718ze3bp16/6GKCIiIiIiIl1cJJXao4EzzGwt8Bhwopn9FdhiZgMAgseSYP0NwJCw7QcDxa29sLs/4O7T3H1a3759IwhRREREREREujJzb7VY+slexOwE4Fp3P83Mfg5sd/c7zOwGoJe7f8/MJgB/I3Qd7UBCg0jlu3vDR7x2ObAi4iC7txygLNpBxDm1YeTUhpFTG3YMtWPk1IaRUxtGTm0YObVh5NSGHSPf3XP2d+OkjowkcAfwuJldBqwDzgdw9wIzexxYCtQDV35UQhtY4e7TDkCc3YaZPeDuV0Q7jnimNoyc2jByasOOoXaMnNowcmrDyKkNI6c2jJzasGOY2QORbN8hSa27zwPmBdPbgU+3sd5twG0d8Z7yiTwT7QC6ALVh5NSGkVMbdgy1Y+TUhpFTG0ZObRg5tWHk1IYdI6J27JDuxweSmb2rSq2IiIiIiIi0JtJb+nSGiErRIiIiIiIi0nXFfKVWREREREREpC3xUKmVj2BmDWa2MOxneDvrnmBm/+q86OKDmbmZ/SXseZKZbVVbfXJmdnbQnmOjHUs80T7YscysItoxdBUf1ZZmNs/MdJnQXvRZGDkz+4GZFZjZ4uD45vBoxxSPzGywmc0ysyIzW2Vmd5tZSjvrX21mGZ0ZYywL/o9/Efb8WjO7JYohxZ2wXKXAzBaZ2f+aWYfmoTGT1OoAJCJV7n5I2M/aaAcUh3YDE80sPXj+GWDjJ3kBMzsQo4nHoy8CrwMzPslGZpZ4YMKJGxHvgyISU/brs1BCzOxI4DRgirsfDJwErI9uVPHHzAz4B/C0u+cDo4FM2h+49WpASW2LGuAcM+sT7UDiWFOuMoHQ8c3ngZs78g1iJqmVjmVmiWb2czP7b3CG82thi7PN7J9mttTMft/RZ0ri2HPAqcH0F4FHmxaY2XQze8PM3g8exwTzLzGzJ8zsGeD5zg85tphZJnA0cBnBgVzQO+DV1vY5M6swsx+b2dvAkdGLPGbszz74mpkdErbefDM7uFOjjlF790wxs9+a2SXB9Foz+5GZvWdmH6ia1r722lL21c5nYVv74+fNbLmZvW5m96iHBgADgG3uXgPg7tvcvdjMpprZK2a2wMzmmtkAaO4x8Ovg83GJmU2PavSx40Sg2t0fBghup3kNcKmZ9TCzu4LPwMVm9m0zuwoYCLxsZi9HMe5YUk9ojJ9r9l5gZsPM7KWg/V4ys6FmlhN8xzQd62SY2XozS+7swGORu5cAVwDfspA2cxYz+16wfy4yszvae92YSmbMLDPYIZoOMs4M5g83s2Vm9oegbP18WDVDIN1auh7/M5h3GVDm7ocBhwGXm9mIYNl04LvAJGAUcE6nRxybHgNmmFkacDDwdtiy5cBx7n4ocBNwe9iyI4GL3f3ETos0dp0FzHH3QmCHmU0J5re1z/UAlrj74e7+eqdHG3v2Zx98ELgEwMxGA6nuvrjTIo5v29x9CnAfcG20g5Eupa3Pwn0E/+/3A6e4+zFA306KMdY9Dwwxs0Izu9fMjg+Sgt8A57n7VOAh9qw49nD3o4BvBssEJgALwme4+y5gHfA/wAjg0KAa/n/ufg9QDHzK3T/V2cHGsN8BF5pZzl7zfwv8uan9gHvcvQxYBBwfrHM6MNfd6zot2hjn7qsJ5aH9aCNnMbNTCH2WHu7uk4E723vNmEpqgWrg7OAg41PAL8zMgmX5wO+CsnUpcG6UYoxF4d2Pzw7mfRa4yMwWEjow7k2oDQHecffVwdm6R4FjOj/k2BMkAsMJVcj+vdfiHOAJM1sC/IrQl0STF9x9R6cEGfu+SCgxI3j8YjDd1j7XADzVuSHGrv3cB58ATgsO9i4F/tQpwXYN/wgeFxBqd5GO0tZnYWvGAqvdfU3w/NF21u023L0CmEqoorMV+DvwNWAi8EJwfPNDYHDYZo8G275KqFdabqcGHZsMaG1UWAOOA37v7vUAOpZpW3Ai4M/AVXstOhL4WzD9F1qOb/4OfCGYnhE8lz015Xht5SwnAQ+7eyV89P4Za9cAGnC7mR0HNAKDgLxg2Rp3XxhM6wDkoxnwbXefu8dMsxPY98NNQ2C3mA3cBZxA6J+qyU+Al939bAsNxDUvbNnuTootpplZb0LdnCaamQOJhPatf9P2PlcdJLrS4hPtg+5eaWYvAGcCFwAasKdFPXuevE3ba3lN8NhA7H0fxpqPaksJtPNZOJvW29CQVgXfD/OAeWb2AXAlUODubV2uouObfRWwVyHIzLKBIcBq1EafxK+B94CH21mnqT1nAz81s16ETs785wDHFlfMbCSh794S2s5ZTuYT7J+xVqm9kFC3m6nufgiwhZYP/Zqw9XQA8tHmAt9o6r9vZqPNrEewbHpQ1k8gdBZJ3T5bPAT82N0/2Gt+Di2D9lzSqRHFj/MIdcEZ5u7D3X0IsIbQWUvtcx/f/uyDDwL3AP/VmfY9fAiMN7PUoMvYp6MdUBxTW358bX0WQuttuBwYaS13LvgCgpmNMbP8sFmHAMuAvhYaRAozSzaz8J5TXwjmH0OoO2NZpwUcu14CMszsImgelPEXhHr1PA983YKBLoMEDKAcyOr8UGNb8P36OKHusk3eoGUwuAsJjm+CngbvAHcD/9IJ/BZm1hf4PfBbD91btq2c5XlC135nBPN7tfWaEHtJbQ5Q4u51ZvYpYFi0A4pjDwJLgfeC7or303Ii4E3gDmAJoS/af7b6Ct2Qu29w97tbWXQnoTNu8wmddZd9fZF996WngC+hfe5j25990N0XALto/+xxtxEcoNW4+3pCByCLCV3r9H5UA4tDasv90t5n4T5t6O5VhK4BnWNmrxM6oa9kLDRC7yMWGmBwMTCe0HgC5wE/M7NFwELgqLBtdprZG4QOmC/b+wW7oyBpOBs438yKgEJCl/t9n9Cx4jpgcdCeXwo2ewB4TgNFteoXQPgoyFcBXw320a8A3wlb9nfgy6jrMbSM/1MAvEgoYf1RsKzVnMXd5xCqeL8bdE1ud+wLC+3r0RV8aW4BxgDPAMmEPqiOBk4JVvuXu08M1r8WyHT3Wzo/WhH5JIIu79e6+2nRjqWrMrOBhLrojXX3xiiHE3VmNhn4g7tr9NMIqS07h5lluntFMI7I74Aid/9VtOOKJ2Y2j9B3zbvRjkVEOl+sdOGdAKxy9220fVuPiU0T7n5Xp0QlIhLjgi5ltwH/q4QWzOzrhM6cXx3tWOKd2rJTXW5mFwMphCq490c5HhGRuBL1Sm34l6a7d/v7fIqIiIiIiMjHF/WkVkRERERERGR/xdpAUSIiIiIiIiIfW6cntWb2kJmVBKNbNc2bbGZvmtkHZvZMcP+spmU3mtlKM1thZp8Lmz81WH+lmd0TDK4gIiIiIiIi3Ug0KrV/Ak7ea96DwA3uPonQMPjXAZjZeEL3fpoQbHNvcH8tgPuAK4D84Gfv1xQREREREZEurtOTWnd/Fdix1+wxwKvB9AvAucH0mcBj7l7j7muAlcB0MxsAZLv7m8H9t/4MnHXgoxcREREREZFYEivX1C4BzgimzweGBNODgPVh620I5g0KpveeLyIiIiIiIt1IrCS1lwJXmtkCIAuoDea3dp2stzNfREREREREupGkaAcA4O7Lgc8CmNlo4NRg0QZaqrYAg4HiYP7gVuaLiIiIiIhINxITlVoz6xc8JgA/BH4fLJoNzDCzVDMbQWhAqHfcfRNQbmZHBKMeXwTMikLoIiIiIiIiEkWdXqk1s0eBE4A+ZrYBuBnINLMrg1X+ATwM4O4FZvY4sBSoB65094ZgvW8QGkk5HXgu+BEREREREZFuxEKDB4uIiIiIiIjEn5jofiwiIiIiIiKyP5TUioiIiIiISNxSUisiIiIiIiJxS0mtiIiIiIiIxC0ltSIiIiIiIhK3lNSKiIjECDO7xMy2mtn7ZlZkZnPN7KiPsd1ZZja+M2IUERGJNUpqRUREYsvf3f1Qd88H7gD+YWbjPmKbswAltSIi0i0pqRUREdlPZjbczJaZ2R/MrMDMnjezdDMbZWZzzGyBmb1mZmPNLNHMVltIrpk1mtlxweu8ZmYH7f367v4y8ABwRbDe5Wb2XzNbZGZPmVlGUMk9A/i5mS0M3nuf9+/MdhEREelMSmpFREQikw/8zt0nAKXAuYQS0W+7+1TgWuBed28ACglVVI8BFgDHmlkqMNjdV7bx+u8BTUnpP9z9MHefDCwDLnP3N4DZwHXufoi7r2rt/Tv+1xYREYkNSdEOQEREJM6tcfeFwfQCYDhwFPCEmTWtkxo8vgYcB4wAfgpcDrwC/Led17ew6YlmdiuQC2QCc/dZ2SyznfcXERHpcpTUioiIRKYmbLoByANK3f2QVtZ9Dfg6MBC4CbgOOAF4tZ3XP5RQVRbgT8BZ7r7IzC4Jtt1bQjvvLyIi0uWo+7GIiEjH2gWsMbPzAYJraCcHy94mVEVtdPdqYCHwNULJ7j7M7HhC19P+IZiVBWwys2TgwrBVy4NluHt77y8iItLlKKkVERHpeBcCl5nZIqAAOBPA3WuA9cBbwXqvEUpGPwjb9gvBgE+FwPeBc929qVI7k1Bi/AKwPGybx4DrglsBjWrr/UVERLoic/doxyAiIiIiIiKyX1SpFRERERERkbilpFZERERERETilpJaERERERERiVtKakVERERERCRuKakVERERERGRuKWkVkREREREROKWkloRERERERGJW0pqRUREREREJG79PySGcZNCEbAHAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 1152x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig = df_plot_newdate.plot(x='newDate', y='count(review_id)',figsize=(16,6))\n",
    "fig.format_xdata = mdates.DateFormatter('%Y-%m-%d')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 218,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1152x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, ax = plt.subplots(figsize=(16,6))\n",
    "\n",
    "ax.plot(df_plot_newdate.newDate, df_plot_newdate['count(review_id)'])\n",
    "#ax.xaxis.\n",
    "ax.set_xticks(df_plot_newdate.newDate, minor=True)\n",
    "ax.xaxis.set_major_formatter(mdates.DateFormatter(\"%B\"))\n",
    "ax.xaxis.set_minor_formatter(mdates.DateFormatter(\"%B\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Reviews\n",
    "In this part you should determine which words used in reviews that are the most positive. \n",
    "\n",
    "The individual reviews do not have a rating of the listing, so we will assume that each review gave the average rating to the listing, i.e., the one on the listing.\n",
    "\n",
    "You should assign a positivity weight to each word seen in reviews and list the words with the highest weight. It is up to you to decide what the weight should be. For example, it can be a function of the rating on the listing on which it occurs, the number of reviews it occurs in, and the number of unique listings for which it was used to review.\n",
    "\n",
    "Depending on your choice of weight function, you may also want to do some filtering of words. For example, remove words that only occur in a few reviews."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "___"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Answer\n",
    "\n",
    "To assess the possitivity score for each word in the reviews, we are merging the listing and review dataframe, such that all reviews are getting the average score for the respective listing. Before analyzing the words, we are handling things that might tweak the correct positivity-score of a given word. This includes things like lowercasing and removal of symbols. \n",
    "\n",
    "The weight measure is calculated by exploding each review such that every word in the `comments` column gets its own row. This means, that every review, which initially consitis of one row, gets exploded into as many rows as the number of words in the review comment. Thereby, we will have distinct words with the score for that particular listing. We can then group by words and use an aggregate mean to get the final score for each word. \n",
    "\n",
    "We are ignoring all words which occurs less than 500 times in total, in order to ensure that words are actually having an impotance before they can occur as a positive word. This hinders, that a word which are mentioned very few times in a review that has been very positive, will outweigh other more relevant words. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 194,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Importing packages\n",
    "from pyspark.sql.functions import lower, regexp_replace, split\n",
    "from pyspark.ml.feature import Tokenizer, RegexTokenizer\n",
    "from pyspark.ml.feature import StopWordsRemover\n",
    "from pyspark.sql.functions import udf"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 195,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Loading the relevant dataframes\n",
    "dfl = spark.read.option(\"delimiter\",\",\").option(\"multiline\",True).option(\"header\", True).option(\"escape\",'\"').option(\"inferSchema\",True).csv('listings_sub_10000.csv')\n",
    "dfr = spark.read.option(\"delimiter\",\",\").option(\"multiline\",True).option(\"header\", True).option(\"escape\",'\"').option(\"inferSchema\",True).csv('reviews_sub_10000.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 196,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Selecting the relevant columns in the two dataframes\n",
    "dfr = dfr.select('listing_id','comments')\n",
    "dfl = dfl.select('id','review_scores_rating')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "After selecting the correct columns, we have to join the two dataframes. As we do not have a rating for each of the reviews, each review will get the average rating which is contained in the listing dataset. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 197,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Joining the reviews and listings on listing ID\n",
    "df = dfr.join(dfl, (f.col('listing_id') == f.col('id')), 'left')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 198,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Cleaning text in the comments column \n",
    "def clean_text(c):\n",
    "    c = lower(c)\n",
    "    c = regexp_replace(c, \"[^a-zA-Z0-9\\\\s]\", \"\")\n",
    "    return c\n",
    "\n",
    "df = df.withColumn(\"text_clean\", clean_text(f.col(\"comments\")))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 199,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Creating a tokenizer and tokenizing all the comments, enabling us to analyze each word seperately \n",
    "tokenizer = Tokenizer(inputCol=\"text_clean\", outputCol=\"words\")\n",
    "df = tokenizer.transform(df)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 200,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Defining a stopwords remiver\n",
    "remover = StopWordsRemover()\n",
    "stopwords = remover.getStopWords() \n",
    "\n",
    "#Defining the input column on which the stopwords remover is applied and what to call the output column\n",
    "remover.setInputCol(\"words\")\n",
    "remover.setOutputCol(\"comments_wo_stopwords\")\n",
    "\n",
    "#Apply the stopwords remover to the dataframe \n",
    "df = remover.transform(df)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 202,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+------------+-------------------+----------+\n",
      "|        Word|Average word-review|Word count|\n",
      "+------------+-------------------+----------+\n",
      "|      highly|  95.71049840933192|       943|\n",
      "|        home|   95.6472081218274|      1182|\n",
      "|   wonderful|  95.49268841394826|       889|\n",
      "|   beautiful|  95.41916167664671|       835|\n",
      "|        back|  95.38628762541806|       598|\n",
      "|  experience|  95.33395176252318|       539|\n",
      "|     perfect|  95.32115942028986|      1725|\n",
      "|        gave|  95.28654124457309|       691|\n",
      "|        even|  95.24183006535948|       918|\n",
      "|       quiet|  95.23913043478261|      1012|\n",
      "|        best|   95.2211350293542|       511|\n",
      "| restaurants|   95.2008501594049|       941|\n",
      "|    spacious|  95.18773234200744|       538|\n",
      "|        feel|   95.1842105263158|       570|\n",
      "|neighborhood|             95.165|       600|\n",
      "|  definitely|  95.14994829369184|       967|\n",
      "|      stayed|  95.11324041811847|       574|\n",
      "|      lovely|  95.10166520595969|      1141|\n",
      "|     staying|  95.09146341463415|       820|\n",
      "|       visit|  95.08969465648855|       524|\n",
      "+------------+-------------------+----------+\n",
      "only showing top 20 rows\n",
      "\n"
     ]
    }
   ],
   "source": [
    "#Displaying results of which words are the most positive given the reviews\n",
    "df.withColumn('Word', f.explode(f.col('comments_wo_stopwords'))).select('review_scores_rating','Word')\\\n",
    "    .groupBy('Word').agg(f.mean('review_scores_rating').alias(\"Average word-review\"), f.count('Word').alias(\"Word count\"))\\\n",
    "    .sort('Average word-review', ascending=False)\\\n",
    "    .filter(f.col('Word count') > 500)\\\n",
    "    .show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As we see above, the words are very relevant from the perspective of an AirBnB review. Words like \"home\", \"beautiful\", \"quiet\", \"restaurants\", are all words we associate with positive holiday experiences. "
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}