Project 3 - Airbnb_final.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": 46,
   "metadata": {},
   "outputs": [],
   "source": [
    "from pyspark.sql import *\n",
    "from pyspark.sql import functions as f\n",
    "from pyspark.sql.types import *\n",
    "\n",
    "import numpy as np\n",
    "from scipy import stats\n",
    "import pandas as pd\n",
    "import re\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "plt.style.use(['seaborn-whitegrid'])\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": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'/home/jovyan/work/Project3/Computational_Tools'"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pwd"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 124,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Load listings\n",
    "df = spark.read.option('header', True).option('inferSchema', True).option('multiline', True).option('escape','\"').csv('../listings.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Load reviews\n",
    "df_review = spark.read.option('header', True).option('inferSchema', True).option('multiline', True).option('escape','\"').csv('../reviews.csv')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Describe the data\n",
    "List the features (schema) and sizes of the datasets."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 125,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "root\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": [
    "# Print schema of listings\n",
    "df.printSchema()"
   ]
  },
  {
   "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": "markdown",
   "metadata": {},
   "source": [
    "#### Description of data cleaning\n",
    "*In this section only columns of the data that is used in the analysis is kept. Furthermore, rows containing NA values in any of the selected columns are dropped. The new reduced dataframes are saved as csv in order to stage the data. They are forced to be partitioned into 16 parts, yielding 16 CSV files. We need to repartion because it is not automatically partitioned due to the multiline nature of the raw data. They are then loaded again, so that further processing is faster.*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 126,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Drop rows with NA values in columns city, neighbourhood, property_type, price\n",
    "df = df.select('id','country','city', 'neighbourhood', 'property_type', 'price','review_scores_rating')\n",
    "df = df.dropna(how='any')\n",
    "# Write file\n",
    "df.repartition(16).write.csv('data/clean_data',header=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 127,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Load reduced CSV files\n",
    "df = spark.read.option(\"header\", \"true\").csv(\"data/clean_data/*.csv\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Subset of Review data and change column name \n",
    "df_review = df_review.select('listing_id', f.col('id').alias('review_id'),\\\n",
    "                             'date','comments')\n",
    "\n",
    "# Write CSV\n",
    "df_review = df_review.dropna(how='any')\n",
    "df_review.repartition(16).write.csv('data/clean_review_data',header=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Load CSV\n",
    "df_review = spark.read.option(\"header\", \"true\").csv(\"data/clean_review_data/*.csv\")"
   ]
  },
  {
   "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.\n",
    "\n",
    "\n",
    "#### Description of implementation of the basics\n",
    "*We are computing the desired dataframe in Spark using a group by 'city' clause and then a count of listings and an approximate count of distinct neighbourhoods. The distinct count is done internally by using a HyperLogLog sketch, which is faster for large amount of data. The data frame is then ordered by the distinct number of neighbourhoods, so that we below show the cities with the highest number of neighbourhoods.*\n",
    "\n",
    "*Afterwards the data frame is filtered using a user defined function, so that only listings with either Copenhagen or København in the city column is still in the data. The data is grouped by property type and neighbourhood to get an overview of the city.*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 128,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+--------------+--------+--------------+\n",
      "|          city|Listings|Neighbourhoods|\n",
      "+--------------+--------+--------------+\n",
      "|Greater London|   33230|           151|\n",
      "|        London|   25734|           150|\n",
      "|       Toronto|   17876|           146|\n",
      "|    Washington|    7227|           105|\n",
      "|     San Diego|   10331|           104|\n",
      "|   Los Angeles|   22328|            99|\n",
      "|        Berlin|   19719|            93|\n",
      "|   Minneapolis|    2082|            89|\n",
      "|      Portland|    4098|            88|\n",
      "|      New York|   16163|            87|\n",
      "|       Chicago|    7642|            82|\n",
      "|        Denver|    4074|            81|\n",
      "|        Austin|    8042|            79|\n",
      "|       Seattle|    7667|            79|\n",
      "|Rio de Janeiro|    9566|            75|\n",
      "|        Sydney|     841|            71|\n",
      "|       Oakland|    2619|            71|\n",
      "|     Barcelona|   15530|            70|\n",
      "|        Madrid|   15782|            67|\n",
      "|         Paris|   48164|            65|\n",
      "+--------------+--------+--------------+\n",
      "only showing top 20 rows\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# Count number of listings and distinct neighbourhoods per city, using hyperloglog.\n",
    "df.groupby('city').agg(f.count('id').alias('Listings'), f.approxCountDistinct('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": 129,
   "metadata": {},
   "outputs": [],
   "source": [
    "# User defined function to extract all listings contaning Copenhagen or København in city column\n",
    "def extract_cph(city):\n",
    "    regex_pattern = r'(.*København.*|.*Copenhagen.*)'\n",
    "    if re.match(regex_pattern, city, re.IGNORECASE):\n",
    "        return True\n",
    "    return False\n",
    "\n",
    "extract_cph_udf = f.udf(extract_cph, BooleanType())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 130,
   "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(id)</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>176</th>\n",
       "      <td>Apartment</td>\n",
       "      <td>Amager</td>\n",
       "      <td>1409</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>177</th>\n",
       "      <td>Apartment</td>\n",
       "      <td>Østerbro</td>\n",
       "      <td>2086</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>178</th>\n",
       "      <td>Apartment</td>\n",
       "      <td>Indre By</td>\n",
       "      <td>2456</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>179</th>\n",
       "      <td>Apartment</td>\n",
       "      <td>Vesterbro</td>\n",
       "      <td>3162</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>180</th>\n",
       "      <td>Apartment</td>\n",
       "      <td>Nørrebro</td>\n",
       "      <td>4163</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "    property_type neighbourhood  count(id)\n",
       "176     Apartment        Amager       1409\n",
       "177     Apartment      Østerbro       2086\n",
       "178     Apartment      Indre By       2456\n",
       "179     Apartment     Vesterbro       3162\n",
       "180     Apartment      Nørrebro       4163"
      ]
     },
     "execution_count": 130,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Filter data frame to only contain Copenhagen and group by property type\n",
    "prop_neigh_city = df.filter(extract_cph_udf(df.city)).groupby('property_type','neighbourhood').agg(f.count('id')).orderBy('count(id)').toPandas()\n",
    "prop_neigh_city.tail()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 131,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1152x432 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Plot the property type count per neighbourhood\n",
    "prop_neigh_city = prop_neigh_city[prop_neigh_city['count(id)']>10]\n",
    "prop_neigh_city.pivot(index='neighbourhood',columns='property_type',\\\n",
    "                      values='count(id)').plot(kind='bar',figsize=(16,6),stacked=True)\n",
    "plt.title('Property type by neighbourhood')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Prices\n",
    "Compute the minimum, maximum and average listing price in your city. \n",
    "\n",
    "\n",
    "#### Description of Implementation of Prices-section\n",
    "*We see that 20,526 listings appears in Copenhagen. The price is cast to double, so that it is ready to use for some statistics. The minimum, maximum and average price of the Copenhagen is computed. It should be noted that we have data with a price of 0, that could indicate a need for removing price outliers. The distribution of the prices is also visualized and here it is clear that both the extremely low and high prices are outliers and only occurs very rarely.*\n",
    "\n",
    "*At the end of the section we compute a new attribute called value, that says something about the value for money, based on the average rating score and price per night. In order to show the top three value for money listings in each Copenhagen neighbourhood, we implemented a window function that orders by value and is used for filtering.*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 136,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "20526"
      ]
     },
     "execution_count": 136,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Listings in Copenhagen\n",
    "df_cph = df.filter(extract_cph_udf(df.city))\n",
    "df_cph.count()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 137,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Cast price into double and remove $\n",
    "df_cph = df_cph.withColumn(\"price\",f.expr(\"substring(price, 2, length(price))\"))\n",
    "df_cph = df_cph.withColumn(\"price\", f.regexp_replace(f.col(\"price\"), \",\", \"\"))\n",
    "df_cph = df_cph.withColumn(\"price\",df_cph[\"price\"].cast(DoubleType()))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 138,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Basic statistics for Copenhagen\n",
      "+-----------------+---------+---------+\n",
      "|    Average price|Max price|Min price|\n",
      "+-----------------+---------+---------+\n",
      "|815.9543505797525|  59999.0|      0.0|\n",
      "+-----------------+---------+---------+\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# Min, max and average price data frame\n",
    "print(\"Basic statistics for Copenhagen\")\n",
    "df_cph.select(f.avg('price').alias(\"Average 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": 139,
   "metadata": {},
   "outputs": [],
   "source": [
    "sns.set_palette(\"cubehelix\", 4)\n",
    "plt.style.use(['seaborn-whitegrid'])\n",
    "sns.set(rc={'figure.figsize':(16,6)})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 140,
   "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_cph.toPandas()\n",
    "plt.hist(df_city_p.price,bins=1500)\n",
    "plt.title('Distribution of prices in Copenhagen')\n",
    "plt.xlabel('Price')\n",
    "plt.xlim(0,10000)\n",
    "plt.ylabel('Count');"
   ]
  },
  {
   "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": 144,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create new value column\n",
    "df_value = df_cph.withColumn(\"review_scores_rating\",df_cph[\"review_scores_rating\"].cast(DoubleType()))\n",
    "df_value = df_value.withColumn(\"value\",f.lit(f.col(\"review_scores_rating\")/f.col(\"price\")))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 145,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Window function to select top three\n",
    "sorted_by_value = Window.partitionBy('neighbourhood').orderBy(f.desc('value'))\n",
    "# Apply window function\n",
    "ranked_by_value = df_value.withColumn('value_rank', f.rank().over(sorted_by_value))\n",
    "# Filter top three\n",
    "ranked_df = ranked_by_value.filter(f.col('value_rank') <= 3).drop('value_rank').orderBy('neighbourhood', f.desc('value'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 146,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+--------+-------+-----------+--------------+-------------+-----+--------------------+-------------------+\n",
      "|      id|country|       city| neighbourhood|property_type|price|review_scores_rating|              value|\n",
      "+--------+-------+-----------+--------------+-------------+-----+--------------------+-------------------+\n",
      "| 5710617|Denmark| Copenhagen|        Amager|    Apartment|150.0|               100.0| 0.6666666666666666|\n",
      "|23337696|Denmark|  København|        Amager|    Apartment|178.0|               100.0| 0.5617977528089888|\n",
      "|22900213|Denmark|  København|        Amager|    Apartment|178.0|               100.0| 0.5617977528089888|\n",
      "|27815787|Denmark| Copenhagen|   Amager Vest|    Apartment| 75.0|               100.0| 1.3333333333333333|\n",
      "| 4831559|Denmark| Copenhagen|   Amager Vest|    Apartment| 96.0|                90.0|             0.9375|\n",
      "|37172149|Denmark|  København|   Amager Vest|    Apartment|177.0|               100.0| 0.5649717514124294|\n",
      "|13746265|Denmark|  København|    Amager Øst|    Apartment| 68.0|               100.0| 1.4705882352941178|\n",
      "|33156740|Denmark|København S|    Amager Øst|    Apartment|123.0|                95.0| 0.7723577235772358|\n",
      "|15472837|Denmark|  København|    Amager Øst|    Apartment|137.0|                96.0| 0.7007299270072993|\n",
      "|11860639|Denmark|  København|     Amagerbro|    Apartment|157.0|                98.0| 0.6242038216560509|\n",
      "|23213098|Denmark|  København|     Amagerbro|    Apartment|212.0|               100.0| 0.4716981132075472|\n",
      "|18621920|Denmark|  København|     Amagerbro|    Apartment|253.0|               100.0| 0.3952569169960474|\n",
      "|14162456|Denmark|  København|      Brønshøj|    Apartment|123.0|                87.0| 0.7073170731707317|\n",
      "|30925351|Denmark|  København|      Brønshøj|    Apartment|150.0|               100.0| 0.6666666666666666|\n",
      "|10491752|Denmark|  København|      Brønshøj|    Apartment|137.0|                90.0|  0.656934306569343|\n",
      "|14295875|Denmark|  København|   Christiania|    Apartment|751.0|                85.0|0.11318242343541944|\n",
      "|24096788|Denmark|  København|Christianshavn|    Apartment|253.0|               100.0| 0.3952569169960474|\n",
      "| 3145494|Denmark| Copenhagen|Christianshavn|    Apartment|280.0|                97.0| 0.3464285714285714|\n",
      "|12194944|Denmark|  København|Christianshavn|    Apartment|369.0|               100.0|0.27100271002710025|\n",
      "|19115574|Denmark|  København| Frederiksberg|    Townhouse|259.0|                87.0| 0.3359073359073359|\n",
      "+--------+-------+-----------+--------------+-------------+-----+--------------------+-------------------+\n",
      "only showing top 20 rows\n",
      "\n"
     ]
    }
   ],
   "source": [
    "ranked_df.show()"
   ]
  },
  {
   "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.\n",
    "\n",
    "#### Description of Trends\n",
    "*In this section we first join (left) the Review data on the Listing data (filtered on Copenhagen) and then count the number of reviews pr. unique date using group by. The data is transformed to Pandas Dataframe and the Date column is changed to Pandas Datetime type. We then sum the number of reviews pr. month, again using groupby and plot the result. To vizualize the popularity of neighbourhoods over time we do almost the same as just described. The only difference is that we also group by \"neighbourhood\". This is done to show the number of reviews pr. neighbourhood. Lastly, to show seasonality we sum the number of reviews pr. month and plot the result.*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 147,
   "metadata": {},
   "outputs": [],
   "source": [
    "# left-join Review-data on Listing-data on listing_id and id\n",
    "df_join = df_cph.join(df_review, (df_cph.id == df_review.listing_id), how='left')\n",
    "# Groupby date count reviews\n",
    "df_plot = df_join.groupby('date').agg(f.count('review_id')).toPandas()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 148,
   "metadata": {},
   "outputs": [],
   "source": [
    "# To datetime and groupby date at month level\n",
    "df_plot.date = pd.to_datetime(df_plot.date)\n",
    "df_plot = df_plot.groupby(pd.Grouper(key='date',freq='M')).sum()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 149,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1152x432 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Plotting number of reveis over entire time period\n",
    "df_plot.plot(figsize=(16,6))\n",
    "\n",
    "plt.title('Reviews per month over entire time period')\n",
    "plt.ylabel('Count')\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": 153,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Group by date and neighbourhood\n",
    "df_plot = df_join.groupby('date','neighbourhood').agg(f.count('review_id')).toPandas()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 154,
   "metadata": {},
   "outputs": [],
   "source": [
    "# To datetime and group by date at month level\n",
    "df_plot.date = pd.to_datetime(df_plot.date)\n",
    "df_plot = df_plot.groupby(['neighbourhood',pd.Grouper(key='date',freq='M')]).sum().reset_index()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 155,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_plot = df_plot.pivot(index='date',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": 158,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1152x432 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Plot review count of four largest neighbourhoods\n",
    "df_plot.plot(x='date', y=['Østerbro','Nørrebro','Vesterbro','Indre By'],figsize=(16,6))\n",
    "plt.title('Number of reviews for different neighbourhoods')\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": 115,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Group by date\n",
    "df_plot = df_join.groupby('date').agg(f.count('review_id')).toPandas()\n",
    "# To datetime and select month\n",
    "df_plot.date = pd.to_datetime(df_plot.date)\n",
    "df_plot['date'] = df_plot['date'].dt.month\n",
    "\n",
    "# Group by name of month\n",
    "df_plot = df_plot.groupby('date',as_index=False).sum()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 122,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAA+UAAAGJCAYAAADsapKCAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8QZhcZAAAgAElEQVR4nOzdZ2BUZdrG8f+kd0hvQIAkQOghCb33SFc6NnR1saGirr7qiuCioru4IjZUmlIWhAXpSBFQaaF3QgsQQkIJpJI2835As0ZBAikn5fp90cxpV+4MydznOec5JovFYkFERERERERESp2V0QFEREREREREKis15SIiIiIiIiIGUVMuIiIiIiIiYhA15SIiIiIiIiIGUVMuIiIiIiIiYhA15SIiIiIiIiIGUVMuIiJSxm3bto327dvf9fbfffcdjzzySDEmurWdO3fSvXt3wsPDWbt2bakcszi88sorfPDBB0bHEBGRSkhNuYiIlKqYmBiGDh1KREQEzZs3Z+jQoezbt8/oWBVa3759mTZtWv7XdevWJS4urkSONXnyZEaMGMHu3bvp2rXrTddZunQp9957L+Hh4bRt25a//OUvxMTElEgeERGRss7G6AAiIlJ5pKWlMWrUKN58802io6PJyckhJiYGOzs7o6NVWLm5udjYlN6f+/PnzxMaGnrL5dOnT2fq1KmMGzeOtm3bYmtry+bNm1m3bh2RkZGlllNERKSs0Ei5iIiUmlOnTgHQu3dvrK2tcXBwoG3bttSrVy9/nW+//Zbo6GiioqJ49NFHiY+Pz1/2j3/8gw4dOtCsWTPuvffeAqOr+/bt495776VZs2a0bt2ad955J3/ZunXr6NWrF5GRkTzwwAOcOHEif1nnzp356quv6NOnDxERETz33HNkZWXdNP+iRYsYOnQob731FhEREfTs2ZMtW7bkL09MTGTUqFE0b96cbt26MX/+/PxlH330EaNHj+a5554jPDycAQMGcOTIkfzlvx+9/rPLqadOnUrXrl0JDw/nnnvu4fvvv/9DxrfffpvmzZvz0UcfsWjRIoYNGwbAiBEjAOjXrx/h4eGsWLGC3r17s379+vx95OTk0KJFCw4fPnzT48+fP59u3brRvHlzRo0aRWJiIgBdu3bl7NmzjBo1ivDwcLKzswtsl5qayuTJk3njjTfo3r07Tk5O2Nra0rlzZ15++WUAsrOzmTBhAm3btqVt27ZMmDAhfz+/Xsb/2Wef0aJFCzp37sx3332Xv//s7GwmTpxIx44dad26NW+88QbXr18vsO20adNo1aoVbdu2ZeHChQXypaSk8PjjjxMeHs6gQYM4c+ZM/rI/e+9dv36dl19+maioKKKjo/niiy8K3G6QmJjIM888Q8uWLencuTOzZs3KX/bRRx/x7LPP8re//Y3w8HB69erF/v37b1p3ERGpmNSUi4hIqalVqxbW1ta8/PLLbNy4kWvXrhVYvnbtWj7//HOmTJnCli1biIiI4IUXXshf3qhRIxYvXsz27dvp3bs3zz77bH4DPWHCBB588EF27drF999/T3R0NHDjRMALL7zAq6++ypYtW2jfvj2jRo0q0DCuXLmSL7/8knXr1nH06FEWLVp0y+9h3759VK9ena1btzJ69Giefvpprl69CsALL7yAn58fmzdvZvLkyUyaNKlA075u3Tp69uyZn//JJ58kJyfnjutYvXp1Zs+ezc6dO3n66ad56aWXSEpK+kPGn3/+mSeeeKLAtrNnzwZgyZIl7N69m3vuuYd+/foVaG43btyIj48PYWFhfzj2li1b+Ne//sW///1vfvzxRwIDAxkzZgxw4+cXEBDAZ599xu7du/9wBcTu3bvJysqiW7dut/zePv30U/bu3cuSJUv47rvv2L9/P5988kn+8kuXLpGcnMzmzZt59913eeONNzh58iQA77//PqdOnWLx4sWsWbOGpKQkPv744wLbpqamsmnTJiZMmMD48eMLvAeXL1/O008/zY4dO6hRo0aBkyJ/9t6bMmUK8fHxrF27lunTpxeopdls5oknnqBu3bps2rSJmTNnMnPmTDZv3py/zvr16+nVqxcxMTF07tyZt95665b1ERGRikdNuYiIlBoXFxfmzJmDyWTi73//O61atWLUqFFcunQJgHnz5vH4448THByMjY0No0aN4vDhw/mj5f369cPd3R0bGxseeeQRsrOz80ffbWxsOHPmDFeuXMHZ2ZmmTZsCsGLFCjp06ECbNm2wtbXl0Ucf5fr16+zevTs/1wMPPICvry9Vq1alU6dOtxwhBvDw8OChhx7C1taWe+65h1q1avHDDz+QkJDAzp07efHFF7G3tycsLIxBgwaxZMmS/G0bNGhAz549sbW1ZeTIkWRnZ7N37947rmN0dDS+vr5YWVlxzz33EBQUVOC+fB8fHx544AFsbGxwcHC47f769u3Lxo0bSUtLA25MDNe3b9+brrt06VLuu+8+GjRogJ2dHWPGjGHPnj2cO3futse5evVq/s/vVpYuXcpTTz2Fp6cnHh4ePPXUUwWaXIBnn30WOzs7mjdvTocOHVi5ciUWi4UFCxbw6quvUrVqVVxcXPjrX//K8uXL87ezsbHhqaeewtbWlg4dOuDk5JT//gHo1q0bjRs3xsbGhr59+xZ4H/zZe2/lypX89a9/pUqVKvj5+fHggw/mb7d//36uXLnC008/jZ2dHdWrV2fw4MGsWLEif52IiAg6dOiAtbU1/fr1K3AFhYiIVHy6p1xEREpVcHAw7777LgAnTpzgpZde4u2332bSpEmcP3+et99+m4kTJ+avb7FYSExMJDAwkGnTprFgwQKSkpIwmUykpaWRnJwM3Bgpnzx5MtHR0VSrVo2nn36aTp06kZSUREBAQP7+rKys8Pf3z7/kGsDb2zv//x0dHQuMOv+er68vJpMp/+uAgACSkpJISkqiSpUquLi4FFh24MCB/K/9/PwK5PD19f3TY93K4sWLmT59ev7JioyMjPw6/P44heHr60uzZs1YvXo13bp1Y9OmTbz22ms3XTcpKYkGDRrkf+3s7EzVqlVJTEykWrVqf3qcqlWrkpyc/Kf3uf/+5/VrfX/l5uaGk5PTH5ZfuXKFzMxM7r333vxlFosFs9lc4Pi/Pa6joyMZGRn5X3t5eeX/v4ODQ4Flf/beS0pKwt/fP3/d39Y/Pj6epKSkAvfL5+XlFfj698fNysoq9bkARETEOPptLyIihgkODubee+/lP//5DwD+/v6MGjXqpqO0MTExfPHFF8yYMYPQ0FCsrKyIiorCYrEAULNmTSZNmoTZbGbNmjWMHj2abdu24ePjw7Fjx/L3Y7FYSEhIwNfX964yJyYmYrFY8hvzhIQEOnfujI+PD9euXSMtLS2/Mf/9cS5cuJD//2azmcTERHx8fIAbDWJmZmb+8osXL940Y3x8PK+//jozZswgPDw8f3T1t3570qCwBgwYwIIFC8jLy6Np06a3rI+Pj0+B+/wzMjK4evVqoeoZHh6Ovb09a9eupWfPnrfc/28ni0tISMivEdy47zsjIyO/MU9ISCA0NBR3d3ccHBxYvnz5Xf9sb+V27z1vb28uXLhASEgIUPDn7O/vT7Vq1VizZk2xZhIRkYpDl6+LiEipOXHiBNOmTctvWhISEli2bBlNmjQBYOjQoUydOpXY2FjgxsRgK1euBCA9PR1ra2s8PDzIzc1lypQp+Zdbw417pK9cuYKVlRVubm4AWFtbEx0dzcaNG9myZQs5OTlMmzYNOzs7wsPD7+p7uHLlCrNmzSInJ4eVK1dy4sQJOnTogL+/P+Hh4UyaNImsrCyOHDnCt99+S58+ffK3PXjwIGvWrCE3N5eZM2diZ2eX/73Xq1ePZcuWkZeXx6ZNm9ixY8dNj5+ZmYnJZMLDwwOAhQsX5tersLy8vDh79myB17p27cqhQ4eYNWsW/fv3v+W2ffr0YdGiRRw+fJjs7GwmTZpE48aNbztKDuDq6sro0aMZP348a9euJTMzk5ycHDZu3Mh7770HQK9evfj000+5cuUKV65c4eOPPy5QQ7gxOVp2djYxMTH88MMP9OzZEysrKwYNGsTbb7/N5cuXgRsnUH577/bdut17Lzo6ms8//5xr166RmJjIN998k7+scePGuLi4MHXqVK5fv05eXh7Hjh3TYwBFRCSfRspFRKTUuLi4sHfvXqZPn05qaiqurq506tSJv/3tb8CNe3rT09MZM2YM8fHxuLq60rp1a6Kjo2nbti3t27enR48eODk58dBDDxW4ZPjXib+uX79OQEAAH3zwAfb29tSuXZv333+ft956i8TERMLCwvjss8/u+jFsjRs3Ji4ujpYtW+Ll5cXkyZNxd3cHYNKkSYwdO5Z27drh5ubGM888Q5s2bfK37dKlCytWrODll18mKCiIjz76CFtbWwBee+01XnnlFWbPnk3Xrl1v+YzvkJAQHnnkEYYOHYrJZKJ///40a9bsjr6Hp59+mldeeYXr168zfvx47rnnHhwcHOjevTvLly//04nYWrVqxbPPPsszzzxDSkoK4eHht5wl/mZGjhyJp6cnn3zyCS+++CLOzs40aNCAUaNGAfDkk0+Snp6ef7VEz549efLJJ/O39/Lyws3NjXbt2uHo6Mibb75JcHAwAC+99BIff/wxgwcPJjk5GV9fX4YNG0a7du3uqD6/d7v33lNPPcXYsWPp0qUL3t7e+Scu4MaJoU8//ZSJEyfSpUsXsrOzqVWrFs8991yRMomISMVhsvx67ZWIiIj8qUWLFrFgwQLmzp17x9t+9NFHxMXF8c9//rMEkhWPKVOmcPr06TKbcdu2bbz00kts2rTJ6Ch/as6cOaxYsaLAiLmIiMit6PJ1ERER4erVqyxcuJAhQ4YYHaXcSUpKYufOnZjNZk6ePMn06dNveaWDiIjI7+nydRERkUpu/vz5vP322/Tt25eoqCij45Q7OTk5jB07lnPnzuHq6kqvXr0YPny40bFERKSc0OXrIiIiIiIiIgbR5esiIiIiIiIiBlFTLiIiIiIiImIQNeUiIiIiIiIiBtFEb7eQnJyO2azb7e+Wp6cLly+nGR2jXFMNi041LDrVsHiojkWnGhadalh0qmHRqYZFpxoWnZWVCXd3Z6Nj5FNTfgtms0VNeRGpfkWnGhadalh0qmHxUB2LTjUsOtWw6FTDolMNi041rFh0+bqIiIiIiIiIQdSUi4iIiIiIiBhETbmIiIiIiIiIQdSUi4iIiIiIiBhETbmIiIiIiIiIQdSUi4iIiIiIiBhETbmIiIiIiIiIQdSUi4iIiIiIiBhETbmIiIiIiEg5l5BwniVLFv3h9cmT/8WGDWuL9ViLF3/Lf/4zu1j3+XsPPzycrKzrN102cGAfTp48DsDTTz/O+fPxJZqlpKkpFxERERERKecSEs7z3Xf/LfBaUlIiMTHb6dixyx/WN5vNWCyWuzpW//4DGTJkxF1tW1gzZszB3t7htusNHjycadOmlmiWkmZjdAAREREREZGS8NP+BH7cl1Ai+27b2J82jfwLte6BA/v4+OMPycjIAOCpp57F1dWVf//7n1y/nomDgyPPPfciYWEN2LUrho8//pCvvvoaoMDXu3bF8Mkn/6ZOnTAOHtwPmBg37m1q1qzFpEnvkZAQz8MPD6datWr84x/vsWLFUjp27ILJZALgq68+Jz7+HJmZGcTHn2PKlC+4evUKH344iWvXrpKTk8PgwcPo1asvM2Z8SUrKNUaPfgGAa9euMmzYfSxcuIw5c2aRmZnJ008/B8Ds2TP54Yd15OXl4eXlw8svv4anpxf9+0czffps3N09ePHF0ZhMJt5//0OSk68wcuQIFi9eeev6to1kzZpNODk5sXfvbv71r3ext7enQYNGBU4mtG7dlvfem0BGRjpOTs53/HMsCzRSLiIiIlKBXUvP5qvlh9i0+5zRUUQqpZSUa7z66ks8+eRoZs6cy7Rp3xASEsprr/2Nv/xlFDNnzuOxx57gtdf+Rk5Ozm33d/z4cfr3v4+ZM+fRuXNXZs78CoAxY/5GzZq1mTFjDv/4x3sA7N69k/r1GxbYfs+eXbz88t+ZNes/ODk58eabrzN69Bi+/HIWn376Jd98M4O4uNP07NmbdevWkJubC8D336+ibdv2ODo6Ftjf6tUrOHfuHJ9/PoNp02bTqlUbpkz5NwDNmkWyc+cOcnNzuXAhgfPn48nNzSUmZjsREZGFql92djZjx77Kc8+9xBdfzKJRo6YkJl7IX25jY0Pt2sHs27e3UPsrizRSLiIiIlJB7Tl+iekrDpOakcPu2Eu8/VhL3JztjI4lUmraNCr8aHZJOXBgPzVr1qJRoyYAWFtbk5ycjK2tLVFRLQCIjGyOra0tZ87E3XZ/tWrVok6degA0aNCIn37afMt1k5IS8fDwKPBaq1ZtqFq1KgBnz54hLu4UY8e+mr88JyeH06dP0aFDJ2rWrM3WrT/Rtm0HVqxYxrPPvvCHY/z44yaOHDnMI4/cD0BeXi4uLi7AjaY8JmY73t4+1K/fEIvFwsGDB35pypvf9nsFOHMmDgcHB5o1u9HEd+nSjfffn1BgHQ8PTy5eTCrU/soiNeUiIiIiFUxWTh7z1x9nw+54qnm78GCPuny25CCLNp3k4eh6RscTqVRudt+2xWLJv6T8t0wmsLa2wWIx57+WnZ1dYB07u/+dWLOysiIvL++Wx7a3d/jD9o6OTgVyVKlSlRkz5tx0++jo3qxcuYyAgEDS09No0iT8pt/LQw89Qu/e/f6wLDKyOTNnfoW3tw8REVFYLBZ27tzOzp07GDny8Vvm/v3+byc7Oxt7e/tC7a8s0uXrIiIiIhVI3IVUxs/YwYbd8fRoXp2/PxRJRF0feretzea954m7kGp0RJFKpVGjxpw+fYoDB/YBkJeXh4eHB9nZ2ezaFQPcuG88NzeX6tWDCAgI4Pz5eFJSUrBYLKxdu7pQx3F2diE9Pa3Aa8HBwX86+l6jRhAODg6sWrU8/7W4uNP5++nYsQt79+5m7txviI7ufdN9tG3bnv/+91tSUlKAGw1ybOwxAPz8/LGysmLVquVERDQnMrIFK1cuw8bGBj8/v0J9X0FBNcnKymLPnl0AbNiwlrS0gt9nXNwpQkJCC7W/skgj5SIiIiIVgNliYfX2MyzaeBJXJ1teGNqUBjX/d9nq0O51WR9zhjlrj/HKiGY3HaUTkeLn5laFCRPe46OPPuD69UxMJiueeupZJkx4r8BEb//4x0RsbW3x9vZh6ND7efTRBwgICKBevfqcOnXytscJDg6hRo0gHnhgMEFBNfnHP96jffvOrF//Pffc0+em29jY2DBx4gdMnvwv5s79mrw8Mx4eHowf/y4ADg4Ov1y6vpT587+76T569uzFtWtXeeaZGyPfZrOZAQMGERpaB4CIiCj27duLl5cXAPb29jRu3LTQ9bOzs+PNNyfkT/TWrFkUvr7/a+gvXLgxkV/t2iGF3mdZY7Lc7Tz4Fdzly2mYzSrN3fL2duXiRZ2JLwrVsOhUw6JTDYuH6lh0quGfu5Jyna+WH+ZwXDIRdbx5KLoeLo62Bdbx9nbl2++PMHPVUUb1a0DzMF+D0pZfeh8WnWpYdHdSw7y8PB577EHee+/D/Ka4ovnssylUq1aN3r37F3obKysTnp4uJZjqzmikXERERKQc23EkiVmrjpCbZ2FkdD3aNva/5Sh4u8YBbNgVz/wNx2kS4oW9rXUppxWR0mRtbc1LL71KQkJ8hW3Kvby8uOeevkbHKBI15SIiIiLlUGZWLnPWHuOn/Reo5e/G433q4+vh9KfbWFmZGN6tDu/O3sXKrXH0b1e7lNKKiFHCwhoYHeGWpk//go0bN/zh9Q8+mIK7u8dNtvijgQOHFnesUqemXERERKScORF/jalLD3Lp2nV6t65J3zY1sbEu3Py9dapXpXmYDyu3naFtY3+8qjjefiMRkRIwcuRjjBz5mNExDKfZ10VERETKiTyzme9+PMU73+zCbIaXhzfj3va1C92Q/2pQxxBMwIINJ0omqIiIFJpGykVERETKgaSrmXy59BDH46/RsoEv93eri5PD3X2U86ziQHTLIJb8eIrOZ5KpW8O9mNOKiEhhaaRcREREpAyzWCz8tD+BN6dtJ/5SGo/3qc/jfRrcdUP+q54tauDhZs+ctbF64oyIiIHUlIuIiIiUUenXc/j8u4N8tfwwNXxcGPdIc1o28Lv9hoVgb2vN4E4hnE1KY9O+88WyTxERuXO6fF1ERESkDDoSl8yXyw9xLS2be9vX5p6WQVhZ3fxRZ3crqp4P63eeY9HGk0TV88HZwfb2G4mISLHSSLmIiIhIGZKbZ+bbH07w/tzd2Fpb8eoDEfRuXbPYG3IAk8nEsK51SM/M4bsfTxf7/kVE5PY0Ui4iIiJSRiRcTmfqd4eIS0ylfRN/hnYJxcGuZD+uBfm50r5pAOt3naND0wACvJxL9HgiIlKQRspFREREDGaxWPhhdzzjpu/g0rVMnhrQiIejw0q8If/VgPa1sbO1Zt66WCwWTfomIlKaNFIuIiIiYqCUjGxmrDjCnuOXqF/TnUd71cfd1b5UM7g52dGvTU3mrT/O3hOXaRriVarHFxGpzNSUi4iIiBhk/8nLTFt+mPTrOQztHELXqOpYmYr/3vHC6BxRjY17zzNvXSwNanpga6MLKkVESoN+24qIiIiUspzcPOZ8f4wP5u/FxdGW1x+MpHvzGoY15AA21lYM7RJKUnIma3eeNSyHiEhlo5FyERERkVJ0LimNz5ceJP5iOl0iqjGoYzB2ttZGxwKgUW1PmgR7svSn07Ru4EcVl9K9jF5EpDLSSLmIiIhIKTBbLKzZcZbxM3eQmpHDc4OaMKJbnTLTkP9qaJdQcnLNLNx40ugoIiKVgkbKRUREREpYcmoW05Yf4uDpZJqGePFwdD3cnO2MjnVTvh5OdIuqzqptZ+jULJBa/m5GRxIRqdA0Ui4iIiJSgnYdu8jYaduJPXeNB3rU5Zn7GpXZhvxXfVrXxM3Jljlrj+kRaSIiJUxNuYiIiEgJyMrOY8bKI0xZtB8PN3vGjoyiU3ggJgMncyssR3sb7usQzIn4FLYeSjQ6johIhabL10VERESK2amEFKYuPUTSlQyiW9RgQPva2FiXr7GQNo39Wb87ngUbjhMe6oWDnT42ioiUhPL110FERESkDDObLSzfcpq3v95Jdk4eLw4LZ1CnkHLXkANYmUyM6FqHq2nZrNgaZ3QcEZEKS6c8RURERIrB5WvX+WLZIY6dvUpkPR8e6lkXZwdbo2MVSUi1KrRs4MuqbWdp1zgA76qORkcSEalwyt9pWxEREZEyZtuhRN6Ytp24xFQe7RXGE/0alPuG/FcDOwRjZQXz1x83OoqISIWkkXIRERGRu5SZlcs3a46x5eAFggPceKxPfXzcnYyOVaw83Bzo1TKI/24+xeHTVwir6WF0JBGRCkUj5SIiIiJ3IfbcVcZO287WQxfo17YWr9zfrMI15L/q0bwGXlUcmLsuljyz2eg4IiIVippyERERkTuQm2fmv5tO8u7sXQD83/0R9GtbC2urivuxys7WmsGdQjh3MZ2Ne84bHUdEpELR5esiIiIihZSYnMEXSw9x8nwKbRr6MbxbHRztK8fHqYi63tSrUZX/bjpJ8zBfXBwrxj3zIiJGq7indEVERESKicViYfO+87w5bQcXLmcwql8DHu1dv9I05AAmk4lhXeuQkZXLks2njI4jIlJhVJ6/JCIiIiJ3IS0zh5mrjrDz6EXq1ajKX3rXx8PNwehYhqju40LHpoFs2B1Ph/AAqnm7GB1JRKTc00i5iIiIyC0cPn2FsdO2syf2EoM6BvPi0PBK25D/akD72jjaWzN3bSwWi8XoOCIi5Z6achEREZHfyck1M3/9cd6ftwd7W2tefzCS6JZBWFmZjI5mOBdHW/q1rcXhuGR2x14yOo6ISLmny9dFREREfuP8pXSmfneQM0lpdAwPZEjnEOxtrY2OVaZ0ahbIxj3n+c/6WBrV9sDWRvUREblbGikXERER4cZkbut3nWPcjB1cSc1i9H2NebBHXTXkN2FtZcXQrqFcvHqdNTvOGh1HRKRc00i5iIiIVHrX0rOZvuIw+05cpmFtDx69J4wqLvZGxyrTGtT0IDzUi2U/x9G6oT/urqqXiMjd0Ei5iIiIVGr7Tlxi7FfbOHQ6meFdQ3l+UBM15IU0pHMIeWYzCzeeMDqKiEi5pZFyERERqZSyc/KYv+E463fFU83bhReH1dcjvu6Qj7sT3aNqsGJrHJ2aBRIcUMXoSCIi5U6pjZR37tyZnj170q9fP/r168fmzZsBOHXqFEOGDKFHjx4MGTKE06dP529TEstEREREziSmMm7GDtbviqd7VHX+/lCEGvK71KtVEFVc7JjzfSxmPSJNROSOlerl65MnT2bJkiUsWbKEdu3aATB27FiGDx/O6tWrGT58OG+88Ub++iWxTERERCovs8XCqm1neGtmDBlZubwwpClDu4Rq9vAicLS3YWCHYE4lpLDlwAWj44iIlDuG3lN++fJlDh06RO/evQHo3bs3hw4d4sqVKyWyTERERCqv5NQs/jVvD/M3HKdJiBfjH2lOg1oeRseqEFo19KOWvxvf/nCCzKxco+OIiJQrpXpP+YsvvojFYiEiIoIxY8aQkJCAr68v1tY3zk5bW1vj4+NDQkICFoul2Jd5eOgPr4iISGUUcySJmauOkJNn5uHoerRr7I/JZDI6VoVhZTIxvFsoE2btZPmWOAZ2DDY6kohIuVFqTfns2bPx9/cnOzubCRMmMH78eB5++OHSOvwd8/TUfWVF5e3tanSEck81LDrVsOhUw+KhOhbd3dQwMyuXLxbv5/vtZwipXpUXR0QQWInvHS/J96G3tyudI5NYs+Ms/TqFEOBVMeusf8tFpxoWnWpYsZRaU+7v7w+AnZ0dw4cP54knnuD//u//SExMJC8vD2tra/Ly8khKSsLf3x+LxVLsy+7E5ctpmM2arORueXu7cvFiqtExyjXVsOhUw6JTDYuH6lh0d1PDE+ev8cV3h7h4NZPerYPo26YWNlgq7c+iNN6HvVvW4Kd95/ns2708c1/jEj2WEdQIldIAACAASURBVPRvuehUw6JTDYvOyspUpgZhS+We8oyMDFJTb7xxLBYLK1asICwsDE9PT8LCwli2bBkAy5YtIywsDA8PjxJZJiIiIhVfntnMdz+d4p2vd5FnNvPyiGbc2z4YG2tDp9KpFKq62NO7VRC7Yy9x8JTm8xERKQyTxVLyz644e/YszzzzDHl5eZjNZoKDg3n99dfx8fHhxIkTvPLKK6SkpODm5sbEiROpXbs2QIksKyyNlBeNzuAVnWpYdKph0amGxUN1LLrC1vDi1Uy+WHaI4+eu0bK+L/d3r4OTg20pJCz7Sut9mJObx+tfbsPWxpo3R0ZVqJMh+rdcdKph0amGRVfWRspLpSkvj9SUF41+WRSdalh0qmHRqYbFQ3UsutvV0GKxsPVgIl+vOYrJBPd3r0urBn6lmLDsK8334e5jF/lo0X6Gdw2la2T1UjlmadC/5aJTDYtONSy6staUl+rs6yIiIiLFLeN6DrNWH2X74SRCq1Xhsd718arqaHSsSq1pqBf1a7qzePMpWtT3xdXJzuhIIiJlVsW5nkhEREQqnaNnkhk7bTsxRy4yoH1tXh7eTA15GWAymRjWJZTr2Xks3nzK6DgiImWaRspFRESk3MnNM7Pkx1Os2BKHt7sjrz4QQe0AN6NjyW8EervQqVkg63edo0PTAGr46hFOIiI3o5FyERERKVcSLqcz4eudLN8SR9vG/rw5MkoNeRnVv10tnB1smbcuFk1jJCJycxopFxERkXLBYrGwae955q6LxdbaiqcGNCSiro/RseRPODvYMqBdLb5ec4ydRy8SWU8/LxGR31NTLiIiImXetbQspizaz+7YS9Sv6c6jverj7mpvdCwphPZNA9iwO57/rD9O42BP7GytjY4kIlKm6PJ1ERERKdMOnLrMM//cwP6TlxnSOYQxQ5qqIS9HrK2sGNa1DpdTrrN6+xmj44iIlDkaKRcREZEyKTUjm/nrj/PTgQtU93Xl2YGNNVlYORUW5E5EXW+Wb42jTSN/PNwcjI4kIlJmaKRcREREyhSLxcLmved5depWth5KpFerID54voMa8nJuSKcQzGb49ocTRkcRESlTNFIuIiIiZUb8pXS+XnWEY+euEVqtCg/2qEugtwv2ug+53POq6kjPFjVY9vNpOjULJLRaVaMjiYiUCRopFxEREcNl5+SxaNMJ3py2nfhL6TwcXY+XRzQj0NvF6GhSjHq1DMLd1Z45a2Mx6xFpIiKARspFRETEYAdOXeab1cdIuppJqwZ+DOkcgpuzndGxpATY21kzqGMwU5ce4qd9CbRrEmB0JBERw6kpFxEREUNcS8ti7rpYth9OwtfDiZeGNiWspofRsaSEtajvy/pd8SzceIKIuj44OejjqIhUbrp8XUREREqV2WJhw+54Xv1iG7uOXaRf21qMfyRKDXklYTKZGN4tlNSMHJb9fNroOCIihtOpSRERESk1Z5PSmLXqCCfOp1CvRlUe6FEXf09no2NJKavp50abxv58H3OW9k0D8PNwMjqSiIhh1JSLiIhIicvKzmPJT6dYs/0sTg42/KV3GK0a+GEymYyOJga5r31tYo4kMW9dLM8NamJ0HBERw6gpFxERkRK15/glZq85xuWU67Rv4s/AjiG4ONoaHUsMVsXFnr5tajF/w3H2nbhM42BPoyOJiBhCTbmIiIiUiCsp15m7Npadxy4S6OXMKyOaUae6nk0t/9M1shob98Qzb10s9Wu6Y2Ot6Y5EpPJRUy4iIiLFymy2sG7XORZtOonZbOG+DrXp0byGGi75AxtrK4Z2CeXDb/exfuc5ujevYXQkEZFSp6ZcREREis3pCynMXHWUuAupNKztwf3d6+JT1dHoWFKGNQ72pGFtD5b8dJqWDfz0jHoRqXR0ylpERESKLDMrlznfH+OtmTFcTc1iVL8GPD+oiRpyuS2TycSwLqFk5+SxaNNJo+OIiJQ6jZSLiIjIXbNYLOw6dpHZ3x/jWlo2HZsFcl/7YJwc9BFDCs/f05kuEdX4fsdZOoUHEuTnanQkEZFSo5FyERERuSuXrmUy+dt9fPzfA7g62fHqgxE80L2uGnK5K33b1MTFyZY5a49hsViMjiMiUmr0V1NERETuSG6eme9jzrLkx1OYMDGkcwhdI6thbaVz/XL3nBxsubd9bWauOsqOI0k0D/M1OpKISKlQUy4iIiKFdjz+GrNWHeHcxXSahngxolsdPKs4GB1LKoh2jQPYsCue+RuO0yTEC3tba6MjiYiUOJ3SFhERkdvKuJ7DrNVHeefrnaRfz+XpexsxemBjNeRSrKysTAzvVocrKVms3BpndBwRkVKhkXIRERG5JYvFwrbDicxbd5zUjGy6RVWnX9taONrrI4SUjDrVq9I8zIeV287QrnGATvyISIWnkXIRERG5qaTkDCbN38vU7w7h4WrPGw9FMbRLqBpyKXGDOoZgAuZvOG50FBGREqe/qiIiIlJAbp6ZldvOsOzn01hbmRjRrQ6dwgOxsjIZHU0qCc8qDkS3DGLJj6fofCaZujXcjY4kIlJi1JSLiIhIvqNnkpm1+igJlzOIrOfDsC6huLvaGx1LKqGeLWqwed955q6N5Y2Ho3RSSEQqLF2+LiIiIqRl5jBt+WEmztlNTq6Z5wY15sn+DdWQi2Hsba0Z3CmEM0lpbNp33ug4IiIlRiPlIiIilZjFYuHnAxf4z/rjZGblEt2yBn3b1NKjqKRMiKrnw/qd51i08STN6/ng5GBrdCQRkWKnkXIREZFKKuFyOu/P3c1Xyw/j5+HE2IejGNQxRA25lBkmk4lhXeuQnpnDkh9PGx1HRKREaKRcRESkksnJzWPZz3Gs3BaHnY01D/WsS7smAViZdM+ulD1Bfq60bxrA+l3n6NA0gAAvZ6MjiYgUKzXlIiIilcjB01f4evVRkpIzadnAlyGdQ6nibGd0LJE/NaB9bbYfTmLeulieH9wEk04giUgFoqZcRESkEkhJz2be+li2HkzEx92RF4Y2pUFND6NjiRSKm5Md/drWYt66WPaeuEzTEC+jI4mIFBs15SIiIhWY2WJh097zfLvhBFk5efRtU5NerYKwtdF941K+dG4WyMY98cxbF0vDWh7YWGtqJBGpGNSUi4iIVFDnLqYxa9VRjsdfo271qjzYsy7+nrofV8onG2srhnYJ5YP5e/k+5izRLYKMjiQiUizUlIuIiFQwWTl5fPfTKdZsP4ujvQ2P9gqjdUM/3Ycr5V6j2p40CfZk6U+nad3Ajyou9kZHEhEpMl33IyIiUoHsO3GJv3+5jZVbz9CqoR9vP96SNo381ZBLhTG0Syg5uWYWbjppdBQRkWKhkXIREZEKIDk1i7nrYok5koS/pxMvDw+nbg13o2OJFDtfDye6RVVn9bYzdAoPpJa/m9GRRESKRE25iIhIOWY2W9iwO55Fm06Qm2dhQPvaRLeooUmwpELr07omP+9PYM7aY7x6f4SuBBGRcu2umvKtW7dibW1NVFRUcecRERGRQoq7kMqs1Uc4lZBKg1oePNC9Dj7uTkbHEilxjvY23NchmOkrj7D1UCKtGvgZHUlE5K4V6jT6/fffz86dOwGYOnUqY8aMYcyYMXz22WclGk5ERET+6Hp2LvPWxTJ+5g4up2TxeN/6jBncRA25VCptGvsT5OfKgg3HuZ6da3QcEZG7VqimPDY2lqZNmwKwYMECvv76a+bPn8+8efNKNJyIiIgUtOvYRV77Yhvf7zhLh6aBvP1YC1rW18zqUvlYmUyM6FqHq2nZrNh6xug4IiJ3rVCXr5vNZkwmE2fOnMFisRAcHAzAtWvXSjSciIiI3HD52nVmf3+MPccvUc3bhSf7NyQ4sIrRsUQMFVKtCi0b+LJq2xnaNfbHu6qj0ZFERO5YoZryiIgIxo8fz8WLF+nWrRsAZ86cwd1ds7qKiIiUpDyzmbUx51i8+RQWLAzqFEy3yOqayE3kFwM7BLPr2EXmbzjOUwMaGR1HROSOFaopf+edd5g+fToeHh785S9/AeDkyZM8+OCDJRpORESkMjt5PoVZq45wJimNJsGejOheB68qGgkU+S0PNwd6tQziv5tPcTgumbAgDRqJSPlSqKbc3d2dMWPGFHitY8eOJZFHRESk0su4nsuiTSfYsCueqq72PDWgIc3qeOu+cZFb6NG8Bpv3JTB37THGjozC2kpXkohI+VGoprxFixZERkYSFRVF8+bNCQsL0wcDERGRYmaxWNhxJIm562JJSc+mS0Q1BrSvjaP9XT3BVKTSsLO1ZnCnED5ZfIBNe87TqVk1oyOJiBRaof7Kz58/n5iYGHbs2MGsWbNITU0lIiKCqKgoHn300ZLOKCIiUuElXc3kmzVHOXDyCkF+rjw7sDE1/dyMjiVSbkTU9aZejaos2nSSqDBfXBxtjY4kIlIohWrKg4KCCAoK4r777uPUqVMsXryYb775hh9//FFNuYiISBHk5plZvf0M3/10GisrE8O6htKlWTWsrHRFmsidMJlMDOtahzenb2fJj6cY0a2O0ZFERAqlUE353Llz2bFjB7t27cLHx4fIyEgmTZpERERESecTERGpsGLPXWXWqqPEX0onoo43w7qG4uHmYHQskXKruo8LHZsGsmFXPB2aBlDN28XoSCIit1WopnzcuHHUqFGDJ598ko4dO+Lj41PSuURERCqstMwcvv3hOJv2JuDpZs/ogY1pGuJldCyRCmFA+9psP5zI3LWxvDi0qeZBEpEyr1BN+caNG9mxY0f+PeU5OTlERUURFRVFv379SjqjiIhIhWCxWNh6MJF562NJz8ylZ4sa9GtTC3s7a6OjiVQYLo629GtbizlrY9kTe4nwOt5GRxIR+VOFasp9fX3p3bs3vXv35tChQ6xevZpvvvmGhQsXqikXEREphAtXMvh69VEOxyUTHODGA0PqUsPX1ehYIhVSp2aBbNxznnnrY2lY2wNbG534EpGyq1BN+YwZM9i2bRs7d+7EycmJqKgoXn75ZaKioko6n4iISLmWk2tm7uojzF93DFsbax7oUZcOTQOw0iW1IiXG2sqKoV1D+de8PazZcZZerWoaHUlE5JYK1ZQfOXKErl278uqrr1K9evWSziQiIlJupWXmEH8xjfhL6cRfTOfgqSskXc2kRX1fhnYOoYqLvdERRSqFBjU9CA/1YtnPcbRu6I+7q/7tiUjZVKim/N133wXAbDaTlJSkid5ERKTSy8zK5fzlG413/MV04i+lEX8xnWvp2fnrONrbUN3HhacGN6W6h6OBaUUqpyGdQ3j9y20s3HiCv/Sub3QcEZGbKlRTnpKSwrhx41i9ejU2Njbs2bOHdevWsW/fPp5//vmSzigiImKYnNw8Ei5nEH8xnXO/NN7xF9O5nHI9fx07GysCvJxpWNuDQC8Xqnk7E+jtQlUXO0wmE97erly8mGrgdyFSOfm4O9E9qgYrtsbRqVkgwQFVjI4kIvIHhWrKx44di5ubG+vXr6dXr14AhIeHM3HiRDXlIiJSIeTmmUlKzvzlsvO0X5rwdJKSM7BYbqxjbWXC39OJkGpV6OAVQKC3M4FeznhVddQ94iJlVK9WQfx0IIE538fy2oMR+rcqImVOoZryLVu2sHnzZmxtbfOf9ejh4cHly5fv+IBTpkzho48+YunSpdSpU4dTp07xyiuvcPXqVapWrcrEiROpWbMmQIksExGRys1ssXDp2vX8xvvXe78vXEknN+9G920y3Rhhq+blTIswHwK8box8+7o7YmNtZfB3ICJ3wtHehoEdgvlq+WG2HLhAm0b+RkcSESmgUE25q6srycnJBe4lP3/+PN7ed/bcx4MHD7Jnzx4CAgLyXxs7dizDhw+nX79+LFmyhDfeeINZs2aV2DIREakcLBYLV9Oyib+Yxrlf7vk+f+lGE56dY85fz9PNgUBvZxoFexDo5Uyglwv+nk7Y2eoRSiIVRauGfmzYHc+3P5ygWR1vHO0L9RFYRKRUFOo30qBBgxg9ejTPPfccZrOZ3bt3M2nSJIYOHVroA2VnZzN+/Hj++c9/8tBDDwFw+fJlDh06xPTp0wHo3bs3b731FleuXMFisRT7Mg8Pj8JXRkREyo3UjOz/jXr/5vLzjKzc/HWqONsR6O1MhyaB+ZedB3g568O5SCVgZTIxrGsoE2btZPmWOAZ2DDY6kohIvkJ9Ennsscews7Nj/Pjx5Obm8uqrrzJkyJD85rowPvzwQ/r27VvgkWoJCQn4+vpibX1jNMLa2hofHx8SEhKwWCzFvkxNuYhI+ZaZlfu/pvtSen4jnvKbGc+d7G2o5u1Mi/q+BHg5U837RvPt6mRnYHIRMVpwQBVaN/RjzY4ztG/ij4+7k9GRRESAQjblJpOJhx9+mIcffviuDrJ7927279/Piy++eFfbG8HT08XoCOWet7er0RHKPdWw6FTDojOihlk5eZxNTOXMhRTOXEgl7kIqcRdSuJicmb+Og501NfxcaV7fjyB/V2r4uRHk54qHm0P+/Cdlid6LRacaFl1lr+Ff72vC7nfX8t8fT/P6Iy3uah+VvYbFQTUsOtWwYrllU75jxw6ioqKAGxO93UqrVq1ue5AdO3Zw8uRJunTpAsCFCxd49NFH+b//+z8SExPJy8vD2tqavLw8kpKS8Pf3x2KxFPuyO3H5chpms+WOtpH/0eN/ik41LDrVsOhKuoa5eWYSr2QUGPWOv5hG0tXM/BnPbaxN+Hs6E+zvRvvG/gR6uRDo7YxnFYc/zKJszs7l0qW0Est7t/ReLDrVsOhUwxvuaRnEwo0n+WF7HA1q3dlVlKph0amGRacaFp2VlalMDcLesikfN24cy5YtA+C111676Tomk4l169bd9iCPP/44jz/+eP7XnTt35rPPPqNOnTrMnTuXZcuW0a9fP5YtW0ZYWFj+ZeZhYWHFvkxEREqf2Wzh4rXMAo13/KV0LlzOIM/8vxnPfd2dqObjQov6vlTzvtF8+7g7Ym2lGc9FpHh0j6rB5r0JzF0Xy5sjo/REBRExnMlisZT6cPBvm/ITJ07wyiuvkJKSgpubGxMnTqR27doAJbKssDRSXjQ6g1d0qmHRqYZFd6c1tFgsJKdmce5i+o2Zzi+mce5SOgmX0snO/d+M515VHG7MdP5L4x3o5Yy/pxO2NhVzxnO9F4tONSw61fB/dh+7yEeL9jO8ayhdI6vffoNfqIZFpxoWnWpYdGVtpLxQTfmMGTPo3bs3Xl5epZGpTFBTXjT6ZVF0qmHRqYZF92c1TPl1xvMCk66lkZmVl79OFRc7qv3afP/y3wAvJxzsKteM53ovFp1qWHSq4f9YLBb+9Z89nE5I5Z2/tiz0RJCqYdGphkWnGhZdWWvKC/WpaPv27XzwwQeEh4fTp08fevTogYtL2fkmRESk5GRcz+X8pXTOXUor0ISnZuTkr+PsYEOgtwstG/jlN+EBXs64ONoamFxE5OZMJhPDuoQydtoOFm8+xQM96hodSUQqsUI15Z988gkpKSmsXr2aJUuW8NZbb9GuXTv69OlD9+7dSzqjiIgYYM/xS8z7fAtJv5nx3N7OmkAvZ5qGeBW49LyKs12ZnPFcRORWAr1d6NQskPW7ztExPJDqPhpwEhFjFPr6QTc3NwYNGsSgQYM4f/48r7/+Os8++yyHDx8uyXwiImKAE+ev8dniAwR4uzCwY8CNS8+9nPG4yYznIiLlVf92tdh2KJG5a4/x0rBwnVwUEUPc0U19MTExLF++nNWrV+Pu7s4zzzxTUrlERMQgSckZfLhgH1Vc7Hjrr63JuZ5tdCQRkRLh7GDLgHa1+HrNMXYevUhkPR+jI4lIJVSopnzixImsWrUKk8lEdHQ0X331FWFhYSWdTURESllqRjYfzN+LxWLh+cFNqepqz0U15SJSgbVvGsCG3fHM33CcxsGe2NlWzKdAiEjZVaimPCMjg/fff5/IyMiSziMiIgbJzslj8sJ9XE7J4qVhTfHzcDI6kohIibO2smJY1zq8P3c3q7efoU+bWkZHEpFKxqowK40bN47IyEgSEhLYs2dPSWcSEZFSZjZbmLr0ECfjU3i8T31Cq1U1OpKISKkJC3Inoq43y7fGcSXlutFxRKSSKVRTnpCQwNChQ4mOjmbkyJEArFq1itdee61Ew4mISOmYtz6WXccuMqRLqO6pFJFKaUinEMxm+PaHE0ZHEZFKplBN+d///nc6duzIrl27sLG5ccV7mzZt+Pnnn0s0nIiIlLw128+wNuYc3SKr0z2qutFxREQM4VXVkZ4tarD1UCKx564aHUdEKpFCNeX79+/n8ccfx8rKKv9REa6urqSmppZoOBERKVkxR5L4z/rjRNTxZkjnEKPjiIgYqlfLINxd7ZmzNhazxWJ0HBGpJArVlHt6ehIXF1fgtePHj+Pv718ioUREpOTFnrvK1KWHCA6swmN96mNlpefzikjlZm9nzaCOwcRdSOWnfQlGxxGRSqJQTfkjjzzCqFGjWLhwIbm5uSxbtoznn3+exx57rKTziYhICUi4nM7kb/fh6WbPM/c10iOARER+0aK+LyGBVVi48QSZWblGxxGRSqBQTfnAgQN56aWXWLVqFf7+/ixevJhnn32Wvn37lnQ+EREpZtfSbzyL3MrKxPODm+DqZGd0JBGRMsNkMjG8WyipGTks/em00XFEpBK47XPK8/LymDJlCk888QRdu3YtjUwiIlJCsrLz+HDBXlLSs/nb8Gb4uOtZ5CIiv1fTz402jf35PuYs7ZsG4Oeh35UiUnJuO1JubW3NnDlz8mddFxGR8inPbOazJQeIS0zlr/0aUDvAzehIIiJl1n3ta2NrY8V/1sUaHUVEKrhCXb7ev39/5s6dW9JZRESkhFgsFuZ8H8veE5cZ3rUO4aHeRkcSESnTqrjY07dNLfaeuMz+k5eNjiMiFVihhr/37dvHN998w1dffYWfn1/+Y9EAZs+eXWLhRESkeKzcdoYNu+Pp2aIGXSKqGR1HRKRc6BpZjY174pm7NpawR92NjiMiFVShmvLBgwczePDgks4iIiIlYOuhC3z7wwmah/kwsGOw0XFERMoNG2srhnYJ5cNv97F+5zlG9KpidCQRqYAK1ZQPGDCgpHOIiEgJOHommWnLD1OnelUe7VUfK5OeRS4icicaB3vSsLYHS346Ta/2IUbHEZEKqFD3lIuISPkTfymdjxbux7uqI0/f2whbG/3KFxG5UyaTiWFdQsnOyWPm8kNGxxGRCkif0EREKqDk1Cz+PX8PtjZWPD+oCS6OtkZHEhEpt/w9nenZogZrd5xhx5Eko+OISAWjplxEpILJzMrlw2/3kpaZy3ODmuBV1dHoSCIi5V6/trWoG+TOjJWHSbqaaXQcEalAbtmU/3ZitylTppRKGBERKZrcPDOfLjnAuaR0nujfkCA/V6MjiYhUCDbWVrx0fyQmTHy+5AC5eWajI4lIBXHLpvz06dNkZWUBMG3atFILJCIid8disfD16qMcOHmFB3rUoXGwp9GRREQqFF8PJ0beU49TCal8+8MJo+OISAVxy9nXu3TpQo8ePQgMDCQrK4sRI0bcdD09p1xEpGxY9vNpNu9LoHfrIDo0DTQ6johIhRRR14cuzaqxZsdZ6gW50zTEy+hIIlLO3bIpf+edd4iJiSE+Pp79+/czcODA0swlIiJ34Kf9Cfx38ylaNfBjQLvaRscREanQBncOJvbcVb5adohxjzTHw83B6EgiUo796XPKIyMjiYyMJCcnR88qFxEpow6evsKMlUcIC3Jn5D31MOlZ5CIiJcrWxppR/RsybsYOPv/uIH8bHo61leZPFpG786dN+a8GDhzI1q1bWbJkCUlJSfj4+NC3b19atWpV0vlERORPnE1K4+NF+/HzdOKpAY2wsdaHQhGR0uDn4cSDPeryxdJDLPnxNPe211VKInJ3CvXpbcGCBTz//PN4e3vTrVs3fHx8ePHFF5k/f35J5xMRkVu4knKdfy/Yi6O9Dc8PaoKTQ6HOs4qISDFp1cCPto39Wf7zaQ6evmJ0HBEppwr1Ce7LL79k+vTp1KtXL/+16OhoRo8eXeDRaSIiUjoyrufy7wV7yczK5ZURzXQ/o4iIQUZ0rcOJ+Gt8sfTG/eVVnO2MjiQi5UyhRsqvXr1KcHBwgddq167NtWvXSiSUiIjcWm6emY//u5+Eyxk8NaARNXz1LHIREaPY21nzRP+GZGbl8uXSg5gtFqMjiUg5U6imvFmzZrz77rtkZmYCkJGRwXvvvUd4eHiJhhMRkYIsFgszVh7hcFwyD/WsR4NaHkZHEhGp9Kp5uzC8aygHTyezcmuc0XFEpJwpVFM+btw4jh49SmRkJK1btyYqKoojR44wbty4ks4nIiK/sXjzKX4+cIH+bWvRtrG/0XFEROQX7ZsE0DzMh/9uOkXsuatGxxGRcqRQ95T7+PjwzTffcOHChfzZ1/38/Eo6m4iI/MamvedZ+vNp2jb2p0+bmkbHERGR3zCZTDzUsx6nE1L5/LuDvDmyOS6OtkbHEpFy4I6enePn50fjxo3VkIuIlLJ9Jy4za9VRGtby4MEedfUschGRMsjR3oZR/RtwLS2bacsPY9H95SJSCHqgrYhIGRd3IZVPFx+gmrczT/RvqGeRi4iUYTX93BjcOYQ9xy+xNuac0XFE/p+9O4+Lqtz/AP6ZhVVk3xEFRBZRQDPcUTF3BcQ1y7qWtng181Zqeq+VdbtZv9uqZYtmWba54e5NTQ0X3BJQARWVRXbZd5h5fn8Yk7giA5yZ4fN+vXzJnDMz5ztfHs6c73mecx7SAzyyIyLSYfnFlfjwlzi0M1Ni3qQgmJlwLnIiIl33yEMd0KOLPX7+7RKuZJVIHQ4R6bj7FuVqtRpHjx5FTU1Na8RDRER/Kq+qxQc/x6GmTo35k4Jg095E6pCIiKgRZDIZZoz2h5WFMVZFn0VFVZ3UIRGRDrtvUS6XyzF79mwYGxu3RjxEDJiHUwAAIABJREFURASgtk6NFRsTkFtYiTlR3eHmYCF1SERE9AAszIzwXHg3XC+uxrd7knh9ORHdVaOGrz/88MM4c+ZMS8dCREQA1EJgzc5EJKcX4ekx/vDvZCN1SERE1ATeHawwPtQTxxNzcSguU+pwiEhHNeriRFdXV8yaNQtDhw6Fs7Nzg7v+zps3r8WCIyJqizYeTEHs+RxMGOSFPgGc7YKISJ+N6tMJSWlFWL/3Ijq7WqGDI0c+EVFDjeopr66uxiOPPAKZTIacnBxkZ2dr/hERUfP57XQGdh1Lw+BgV4zu00nqcIiISEtymQwzx3aFuYkSn0WfRXWNSuqQiEjHNKqn/D//+U9Lx0FE1OaduZiP7369gKDOdnhsuA/nIiciMhBW7Ywxa1xX/PfHM/j+1wt4aoy/1CERkQ5p9JRoKSkpWLlyJZYtWwYAuHz5MpKSklosMCKituRKVglWbT2Ljk7t8VxENyjknLGSiMiQdPWwxdh+HohJyMLRsxxtSkR/adRR365du/DYY48hJycHW7ZsAQCUl5fjnXfeadHgiIjagtyiSnz0SxwszY3x4sRAmBgrpA6JiIhaQPgAD/h0sMK3e5KRXVAhdThEpCMaVZR//PHH+Prrr7Fs2TIoFDcOFv38/NhTTkSkpbLKG3ORq9QC8ycHwcqCc5ETERkqhVyOZ8IDYKSU47MtZ1Fbx+vLiaiRRXlBQQH8/PwAQHONo0wm4/WORERaqKlV4eON8bheXIW5EwLhYtdO6pCIiKiF2Vqa4ukx/kjPLcNP+y9JHQ4R6YBGFeUBAQGIjo5usGzHjh0IDAxskaCIiAydWgh8tf08LmUUY9a4rvBxt5Y6JCIiaiVB3vYYEeKO/aev4WRSrtThEJHEGnX39SVLluDpp5/Ghg0bUFFRgaeffhpXrlzBmjVrWjo+IiKD9PP+SziZnIfJQ7zxsJ+j1OEQEVErmzCoMy6kF+PrXUno5NweDtZmUodERBJpVE95586dsWvXLkybNg0vvvgioqKisG3bNnh4eLRweEREhufXE+n434l0DH2oA0aEuEsdDhERSUCpkOO5iAAAwOdbz6FOpZY4IiKSSqPn3DEzM8NDDz2EkJAQ9OrVC+3a8dpHIqIHdSo5Fz/uu4geXezx6NAuvDcHEVEb5mBthhmj/HA5swSbDl2WOhwikkijhq9nZmbi5ZdfRlxcHCwtLVFSUoLAwED83//9H9zc3Fo6RiIig3ApoxhfbDsPL1dLPBMeALmcBTkRUVvXy88RQ3q4YXdsGvw62iCws53UIRFRK2tUT/nChQsREBCAEydO4OjRozh+/Di6d++ORYsWtXR8REQGIaegAh9vjIdNexPMnRgIEyPORU5ERDdMHeqNDg4W+Gr7eRSWVksdDhG1skYV5efOncOCBQtgbm4OAGjXrh1efvllnD17tkWDIyIyBCXlNfjg5zgAwPzJQbA0N5Y4IiIi0iVGSgWejwxAbZ0aX2w9B7VaSB0SEbWiRhXlwcHBiI+Pb7Ds7Nmz6NGjR4sERURkKKprVfhoQzwKy6oxb2IgnGzMpQ6JiIh0kItdOzw+3AfJ6UXYeviK1OEQUSu66zXlH330keZnd3d3PPPMMxg8eDCcnZ2RnZ2NgwcPYuzYsa0SJBGRPlKrBb7Yeg5Xs0owe3x3dHazkjokIiLSYf27uyAptRDbDl+Fb0cb+HeykTokImoFd+0pz87O1vyrqanB8OHDYWxsjIKCAhgbG2PYsGGoruY1L0REdyKEwPq9F/DHxXw8+kgXPOTrIHVIRESkBx4b7gMnW3N8se0cSsprpA6HiFrBXXvK//Of/7RmHEREBmXP8XTsP30NI0Lc8UgvzkVORESNY2qsxPOR3fDmNyfx1fbzeHFyEOScPpPIoDVqSjQAqKysRGpqKioqKhos79mzZ7MHRUSkz44n5uDn3y6hl58jJg3xljocIiLSM+6OFnj0kS5YtycZe2LTMKpPJ6lDIqIW1KiifMuWLVi2bBmMjIxgamqqWS6TyXDgwIGWio2ISO9cSC/CV9vPo0sHK8wa68/eDSIiapLBwa5ITC3ExoOX0cXdGt68LwmRwWpUUf7ee+/hk08+Qf/+/Zu8odmzZyMjIwNyuRzm5ub417/+BX9/f1y5cgWLFi1CUVERrK2tsXz5cnh4eABAi6wjImopmfnl+GRjPOytzDB3QiCMlJyLnIiImkYmk+FvI/1wNasEn0efxetPhaCdqZHUYRFRC2jUlGhGRkYICQnRakPLly/H1q1bsWXLFjz11FNYvHgxAOC1117DtGnTsGfPHkybNg1Lly7VvKYl1hERtYTismp88HMcFHIZ5k8OgoUZD5yIiEg75qY3ri8vKqvBmh2JEILzlxMZokYV5fPmzcM777yDgoKCJm+offv2mp/Lysogk8lw/fp1nD9/XjO12tixY3H+/HkUFBS0yDoiopZQVVOHD3+JR2llDeZNCoKDtZnUIRERkYHwdLHEpMGd8cfFfOw/fU3qcIioBTRq+LqHhwc+/vhjrF+/XrNMCAGZTIbExMRGb2zJkiU4fPgwhBD46quvkJWVBScnJygUN4Z4KhQKODo6IisrC0KIZl9na2vb6FiJiBpDpVZjVfQ5pOWWYu6EQHi6WEodEhERGZhhD7sjMbUQP+2/CG83K3Rybn//FxGR3mhUUb5gwQJERERg9OjRDW709qD+/e9/A7hx47h3330X8+bNa/J7tTQ7OwupQ9B7Dg78wtAWc6i9lsyhEAIrN8QhPuU6Zk8MwrC+Hi22LSmxHTYP5lF7zKH2mEPtSZXDBU+GYN5/f8MX28/jw/mDYK7H15ezHWqPOTQsjSrKi4qKMG/ePMia6S7CkZGRWLp0KZydnZGTkwOVSgWFQgGVSoXc3Fy4uLhACNHs6x7E9etlUKt53U5TOTi0R15eqdRh6DXmUHstncPtR65iz7FUjOnbCb287Qzy98V22DyYR+0xh9pjDrUndQ5nju2K5etP4/3vT+GZcV2b7di8NUmdQ0PAHGpPLpfpVCdso64pj4qKQnR0dJM3Ul5ejqysLM3j/fv3w8rKCnZ2dvD398f27dsBANu3b4e/vz9sbW1bZB0RUXM5ejYbmw5dRp+uThgf6iV1OERE1Ab4uFsjcqAXYs/n4Pf4rPu/gIj0gkw04jaOjz76KBISEuDm5gZ7e/sG677//vv7biQ/Px+zZ89GZWUl5HI5rKyssHDhQgQEBCAlJQWLFi1CSUkJLC0tsXz5cnh53TjAbYl1jcWecu3wDJ72mEPttVQOE68W4P2f49ClgxXmTw6GkbJR5zf1Etth82Aetcccao851J4u5FCtFvjvT2eQcq0Y/3qyF9wcdKe3rzF0IYf6jjnUnq71lDeqKN+8efNd140fP75ZA9IVLMq1w52F9phD7bVEDjPyyvCf707Bpr0pFj/eU6+v6WsMtsPmwTxqjznUHnOoPV3JYXFZNV5bcxwW5sb415O9YGKkkDqkRtOVHOoz5lB7ulaUN+qackMtvImIHkRh6Y25yI2NFJg/KcjgC3IiItJNVhYmmDUuAO//dAY/7L2Av43ylzokItJCo4ryDRs23HXdxIkTmy0YIiJdVVldhw9/iUNFdR1efawn7KyaPhMFERGRtgI8bTG6byfsOJoKv0426NPVWeqQiKiJGlWU33qTt/z8fKSnp6NHjx4syonI4NWp1Ph0cwKu5ZXjxUmB6OjEaUiIiEh6kQM9kZxehG92J8PT2RJOtuZSh0RETdCoonzdunW3LduwYQNSUlKaPSAiIl0ihMA3u5Nw7mohZozyQzcvO6lDIiIiAgAo5HI8Fx6A19Ycx6roc1g8/SGDvvkokaFq8l9tVFQUNm7c2JyxEBHpnK2Hr+JwQjbC+3tgYJCr1OEQERE1YGtpiqfG+CM1pxS//HZJ6nCIqAkaVZSr1eoG/8rLy/HTTz+hfXsO4SQiw/V7fCaiY66gf3dnRAzwlDocIiKiO+rRxQHDerlj76kMnL6QJ3U4RPSAGjV8vWvXrpDJZA2WOTk54c0332yRoIiIpHb2ynV8uzsZAR42eHKk3237QCIiIl0ycXBnXMgowpodiejoZAF7KzOpQyKiRmpUUb5v374Gj83MzGBra9siARERSS0tpxQrN5+Fi107zB7fHUoFr88jIiLdZqSU4/mIALz+9Ql8vvUcFk7rye8vIj3RqL9UNze3Bv9YkBORobpeXIUPfomDuYkS8ycHwcykUecuiYiIJOdoY46/jfJDyrUSbPn9itThEFEj3fNoc/r06fccsimTyfDNN980e1BERFKoqKrFh7/EoaZWhVcfewg27U2kDomIiOiBhPg7ITG1EDuPpcKvozVnDSHSA/csysPDw++4PCcnB+vWrUNVVVWLBEVE1Npq69RYsSkB2QUV+MfkIHRwtJA6JCIioiZ5dGgXXLpWjC+3n8cbT4XA2oInmYl02T2L8kmTJjV4XFhYiC+++AI///wzRo8ejb///e8tGhwRUWsQQuDrXYlISivCzLH+8PfgJTpERKS/jI0UeC6iG9785gS+2HoOL0/tAbmcNywl0lWNuqa8rKwMH374IYYPH478/Hxs3rwZb775JpydnVs6PiKiFrfp0GUcO5eD8aFe6NfNRepwiIiItOZm3w6PDfNBUloRth+9KnU4RHQP9+wpr6qqwjfffIM1a9agd+/eWL9+Pbp06dJasRERtbgDZ65hx9FUhAa5YmzfTlKHQ0RE1GwGdHdBUmohomOuwNfdGr4dbaQOiYju4J5F+dChQ6FSqTBz5kx069YN+fn5yM/Pb/Ccvn37tmiAREQtJe5SPtbtSUZ3LztMH+HDuciJiMigyGQyPD7cF5czS/D51nN4/akQWJobSx0WEd3inkW5icmNm0L88MMPd1wvk8lum8OciEgfXMkqwWfRZ9HRsT2ejwyAQs65XImIyPCYmSjxfGQ3vPXtKazenoh5kwIh50loIp1yz6J8//79rRUHEVGrySuqxEcb4tHezBgvTgqEqTHnIiciIsPV0ak9poR54/tfL+B/x9MxsndHqUMiopuwa4iI2pSyylp88HMc6urUmD85CFacJoaIiNqAsJ5ueMjHARsPpiAls1jqcIjoJizKiajNqK1T4ZON8cgvrsTcCd3hat9O6pCIiIhahUwmw4zRfrC2MMHn0edQUVUrdUhE9CcW5UTUJqiFwFfbE3ExoxhPj+nKO9ASEVGbY25qhOciAlBYWo2vdyVBCCF1SEQEFuVE1EZs+C0FJ5JyMWlIZ/Tu6iR1OERERJLo7GaFqEFeOJWch9/+uCZ1OEQEFuVE1AbsO5WB3cfTENbTDSNDeHMbIiJq20aEdER3Lzv8uO8S0nJKpQ6HqM1jUU5EBu2PC3lY/+sFBHvbY9ojnIuciIhILpPh6bH+sDBT4rPoc6iqqZM6JKI2jUU5ERms5NQCfL71HDxcLPFsRADkchbkREREAGBpboxnwwOQW1iBdXuSeX05kYRYlBORQcq6Xo5lq2NhZWGMeRMDYWKkkDokIiIineLb0QYR/T1x9FwODidkSx0OUZullDoAIqLmVKdS49cT6YiOuQITYyXmTw6GZTtjqcMiIiLSSWP7eSAprRDf/ZoML1dLThdKJAH2lBORwbicWYJla0/ilwMp6OZlh49fGgxnW3OpwyIiItJZcrkMs8YFwMRIgc+iz6KmViV1SERtDotyItJ7ldV1WP/rBfz725Moq6zB38d3x5yo7rC3NpM6NCIiIp1n094EM8d2xbW8cvy476LU4RC1ORy+TkR67Y+LefjufxdQVFqNsJ4dEDXIC2Ym3LURERE9iO5edhjVpyN2HUuDXycbhPg7SR0SUZvBI1ci0kuFpdVY/+sFnLqQBzeHdpgd2Q2d3aykDouIiEhvjR/ohQvpRfhmdxI8nNvD0YaXgBG1Bg5fJyK9ohYCv53OwD+/Oob4y9cxYZAXXvvbwyzIiYiItKRUyPFseABkkGFV9DnUqdRSh0TUJrCnnIj0RkZeGb7ZnYSUayXo6mGDJ0b48iw+ERFRM7K3MsNTY/yxYlMCNhxIwdShXaQOicjgsSgnIp1XU6vCtiNXsTs2DWYmSswc64++Ac6QyWRSh0ZERGRwevo4YOhDHfC/E+nw7WiNHl0cpA6JyKCxKCcinZZ4tQDf7ElGbmEl+ndzxuQwb7Q357zjRERELWnyEG9czCjCmh2JeOOp9rC1NJU6JCKDxWvKiUgnlVbUYPX283jvxzMAgJenBuPpsV1ZkBMREbUCI6Ucz0d0Q51aYNXWc1CpeX05UUthTzkR6RQhBI6ey8aP+y6hsroOY/p2wrh+HjA2UkgdGhERUZviZGuOJ0f44ott57Hl9yuYMKiz1CERGSQW5USkM3ILK/DtnmScv1qIzq6WeHKUHzo4WEgdFhERUZvVJ8AZiamF2Hk0FX4dbRDgaSt1SEQGh0U5EUmuTqXGnuNp2Hr4KpQKGR4f7oPBPdwg543ciIiIJDdtmA9SMkvw5bZzeOOpEFhZmEgdEpFB4TXlRCSplGvFWLb2BDYevIxALzu8NbMPwnp2YEFORESkI0yMFHg+IgBVNSp8se081GohdUhEBoU95UQkicrqOmw6eBn7T2fAur0J5kZ1Rw8fTrlCRESki9wcLDBtmA/W7krCjmOpGNfPQ+qQiAwGi3IianWnL+Th+18voKi0GkMf6oDxoV4wM+HuiIiISJcNDHRBYmohtvx+Gb7u1vBxt5Y6JCKDwOHrRNRqCkursWJTAlZsSkA7UyMseaIXpg3zYUFORESkB2QyGZ4Y4QsHKzN8vvUcyiprpQ6JyCCwKCeiFqdWC+w7lYElXx7D2cvXMWlwZyz9Wy94uVpKHRoRERE9ADMTJZ6P7IbSihqs3n4eQvD6ciJtsXuKiFpURm4Z1u5OwuXMEgR42mL6CF84WptJHRYRERE1USfn9pg0xBs/7L2IX0+kY3hIR6lDItJrLMqJqEXU1Kqw7chV7I5Ng7mpErPGdUWfrk6Q8a7qREREeu+RhzogKbUQvxxIQRd3a3i6cPQbUVNx+DoRNbtzVwuwdPVx7Diair4Bzvj3rD7oG+DMgpyIiMhAyGQyzBjtD2sLY3y25SwqquqkDolIb7EoJ6JmU1JRgy+3ncd/fzwDmQx45dEeeGqMPyzMjKQOjYiIiJqZhZkRng3vhoKSanyzO4nXlxM1EYevE5HWhBA4cjYbP+2/hMrqOozt54Fx/TrBSKmQOjQiIiJqQd4drDA+1BMbD16GfycbDO7hJnVIRHqHRTkRaSWnsALf7k5GYmohvN2s8ORIX7g5WEgdFhEREbWSUX06ISmtCD/su4jOblZwd+RxANGD4PB1ImqSOpUa249cxdLVx3E1uwTTR/hi0eM9WZATERG1MXKZDLPGdoW5iRKros+iukYldUhEeoVFORE9sEvXivHG2hPYdOgygjrb4a2ZfTCkhxvkvJEbERFRm2TZzhjPjOuK7OsV+O7XZKnDIdIrHL5ORI1WUVWHjYdScOD0NdhYmuCFCYEI7mIvdVhERESkA/w9bDG2nwe2HbkKv4426N/dReqQiPQCi3Iiui8hBE5fyMP3v15AcXkNhvbqgPEDvWBmwl0IERER/SV8gAeS04vw3f8uwMvVEi527aQOiUjncfg6Ed1TQUkVVmxKwMrNZ9He3Bj/fKIXpj3iw4KciIiIbqOQy/FseACMlHJ8tuUcamp5fTnR/bAoJ6I7UqsF9p5Mx5KvYnHuSgEmD/HG0r/1gqeLpdShERERkQ6zaW+CmWP9kZFXhp/2X5I6HCKdx64uIrpNem4Z1u5KwpWsEnTztMX0Eb5wsDaTOiwiIiLSE4Gd7TEypCN2H0+Dfycb9PJzlDokIp3FopyINKprVdh6+Ar2xKajnZkSz4R3RW9/J8h4V3UiIiJ6QFGDvJCcXoSvdyWik3N7nuAnugsOXyciAMDZK9fxr69isetYGvp3d8a/Z/VBn67OLMiJiIioSZQKOZ6LCAAgw6roc6hTqaUOiUgnsSgnauNKKmrw5bZzeP+nOCgUciyc1gMzRvvDwsxI6tCIiIhIzzlYm2HGKD9cySrBxoMpUodDpJM4fJ2ojRJCICYhCz/vv4SqGhXC+3tgTN9OMFIqpA6NiIiIDEgvP0cM6emGPcfT0bu7KzwcOE0a0c1YlBO1QdkFFfh2dxKS0orQpYMVnhjpBzd7fkESERFRy5ga5o1LGcX499fHEeRtj9AgV3TztIVczsvkiFqlKC8sLMSCBQuQlpYGY2NjdOrUCcuWLYOtrS2uXLmCRYsWoaioCNbW1li+fDk8PDwAoEXWEbVldSo1dh1LxbYjqTBSyvHESF+EBrlCzuvGiYiIqAUZKRX4x+QgHDqbg73HU3H6Qh7sLE0wINAVA7q7wM7KVOoQiSQjE0KIlt5IUVERkpOT0bt3bwDA8uXLUVxcjLfffhtPPPEEJkyYgIiICERHR2Pjxo349ttvAaBF1jXW9etlUKtbPDUGy8GhPfLySqUOQ681dw4vZRRj7e4kZOaX42E/Rzz6SBdYW5g02/vrIrZD7TGHzYN51B5zqD3mUHvMofYcHNojK7sYf1zMx6G4TJy/UgAA6OZlh9AgVwR520Gp4G2v7oXtUHtyuQx2dhZSh6HRKi3e2tpaU5ADQHBwMDIzM3H9+nWcP38eY8eOBQCMHTsW58+fR0FBQYusI2qLKqpq8e2eZLz93SlU19Rh3sRAPB/ZzeALciIiItJNSoUcD/s54qUpwXjnub4Y088D6bmlWLk5Aa98egQbDqQgt7BC6jCJWk2rX1OuVqvxww8/ICwsDFlZWXBycoJCcePGUgqFAo6OjsjKyoIQotnX2dratvbHJZKMEAKnkvPw/d4LKCmvwfCH3RE50BOmxryVBBEREekGB2szRIV6IWKABxJSCnAoLhO7YlOx81gq/DvZIDTIFT19HGCkZO85Ga5WPzp/8803YW5ujscffxznz59v7c03mi4NZ9BXDg7tpQ5B7zU1h3mFlfh8UzyOn8+Gl5sVXp/ZF97u1s0cnX5gO9Qec9g8mEftMYfaYw61xxxq7245dHaywrB+nrheXIm9J9Lwv9g0fL71HNqbG2FIL3eM6N0JHZ0tWzla3cR2aFhatShfvnw5UlNTsWrVKsjlcri4uCAnJwcqlQoKhQIqlQq5ublwcXGBEKLZ1z0IXlOuHV7ror2m5FCtFth3KgObDl2GgMDkId4Y9nAHKOTyNvn7YDvUHnPYPJhH7TGH2mMOtcccaq+xOQwLcsXgQBckXi3EwbhM7Ii5gq2HLsPbzQqhQa542M8RJsZtcxpXtkPttclrygHggw8+wNmzZ7Fy5UoYGxsDAOzs7ODv74/t27cDALZv3w5/f3/Y2tq2yDoiQ5aWU4q3vj2JH/ZdhI+7Nd56ujdG9u4IhZzDvYiIiEj/yGUyBHjaYnZkN/x3Tn9MHuKNssparNmZiH+sjMG3e5KRms3ilPRfq9x9/eLFixg7diw8PDxganpjuoMOHTpg5cqVSElJwaJFi1BSUgJLS0ssX74cXl5eANAi6xqLPeXa4Rk87TU2h9U1KkQfvoL/HU+HhZkS04b54GE/R8g4zRnbYTNgDpsH86g95lB7zKH2mEPtaZtDIQQuZhTj4JlMnEzORW2dGp2c2iM02BV9ujrBzMTw753Ddqg9Xespb5WiXB+xKNcOdxbaa0wOz16+jm/3JCO/uAqhQa6YNKQz2pkatVKEuo/tUHvMYfNgHrXHHGqPOdQec6i95sxheVUtjp3LwcEzmcjIK4OxkRwhfk4IDXZFZ1dLg+2gYDvUnq4V5YZ/KonIAJWU1+DHfRdx7HwOXOzMseixnvBpozdyIyIiorapnakRhj7UAWE93XA1uxQHz2QiNjEHMQlZcLNvh4FBrujXzRkWZuywIN3GopxIjwghEBOfhZ9/u4TqWhUiBnhidJ9OnCaEiIiI2iyZTAZPF0t4ulhiSpg3TiTl4uCZTPy47yI2HEjBQ74OCA1yhV9Ha4PtPSf9xqKcSE9kXS/Huj3JSEorgk8HKzw5yg8udu2kDouIiIhIZ5iZKBEa5IrQIFek55bhUFwmjp7NRuz5HDjamCE0yBX9uznDysJE6lCJNFiUE+m42jo1dh1LxfajV2GsVOBvo/wwINAFcp7pJSIiIrord0cLPDbMB5MGd8ap5DwcjMvEhgMp2HzoMoK87REa5IpunraQy3lMRdJiUU6kwy6kF+Gb3UnIul6BEH9HPDq0C8/sEhERET0AYyMF+nZzRt9uzsi6Xo7f47Jw+GwWTl/Ig52lCQYEumJAdxfYWZlKHSq1USzKiXRQeVUtft4Qh91Hr8LO0hQvTgpCYGc7qcMiIiIi0msudu0wOcwbUYO8cOZiPg7GZWJrzBVsjbmCbl52CA1yRZC3HZQK3q+HWg+LciIdoRYCyWlFiInPwqnkXNSp1BgR4o7IAV4wMVZIHR4RERGRwVAq5Ojl54hefo7IL6rEofgsxMRnYuXmBFi1M0b/7i4IDXKBo4251KFSG8CinEhi+cWVOJKQjZiELOQXV8HM5MYQqwlDfWBhxLO0RERERC3J3toMUaFeiBjggYSUAhyKy8Su2FTsPJYK/042CA1yRU8fB852Qy2GRTmRBGpqVTh9MQ8x8VlIvFoIAcC/kw3Gh3qhp48DTIwUcHBoj7y8UqlDJSIiImoTFHI5grvYI7iLPQpLqxGTkIXf4zLx+dZzaGeqRL9uLggNdoWbPWe/oebFopyolQghcDW7FL/HZyH2fA4qq+tgZ2mKcf090L+7CxyszaQOkYiIiIgA2LQ3wbh+HhjTtxMSrxbiYFwm9p/OwK8n0+HtZoXQIFc87OfISwypWbAoJ2phxeU1OHo2G4cTsnAtvxxGSjke8nXAgO4u8Otkw6nNiIiIiHSUXCZDgKctAjxtUVJRgyMJ2TgUl4k1OxP2Qr52AAAgAElEQVTxw74L6N3VGYOCXNHJub3UoZIeY1FO1ALqVGokXL6OmPgsxKdch0ot4OVqiSdG+CLE3xHmpkZSh0hERERED8DS3Bgje3fEiBB3XMwoxsEzmTickIUDf1xDJ6f2CA12RZ+uTjAzYYlFD4YthqgZXcsrQ0xCFo6ezUZJRS0s2xljWC939A904fVHRERERAZAJpPBx90aPu7WmDasC46dy8GhuEys25OMn/ZfRIifE0KDXdHZ1RIyjoikRmBRTqSliqo6HE/Mwe/xWbiSVQKFXIbAznYYEOiC7l6c55KIiIjIULUzNcLQhzogrKcbrmaX4uCZTMQm5iAmIQtu9u0wMMgV/bo5w8KMoyTp7liUEzWBWggkpRYiJiELp5LzUFunhpt9O0wJ80bfAGdYtjOWOkQiIiIiaiUymQyeLpbwdLHElDBvnEjKxcEzmfhx30VsOJCCh3wdEBrkCr+O1uw9p9uwKCd6APlFlYhJyMLhhGxcL6mCmYkSA7q7YECgCzyc23MnS0RERNTGmZkoERrkitAgV6TnluFQXCaOns1G7PkcONqYITTIFf27OcPKwkTqUElHsCgnuo/qWhVOJ+chJiELiamFkAHo6mGDCYO90LOLA4yNOBUGEREREd3O3dECjw3zwaTBnXEqOQ8H4zKx4UAKNh+6jCBve4QGuaKbpy3kcnbstGUsyonuQAiBy5kliEnIwvHEHFRWq2BvZYrIgZ7o380FdlamUodIRERERHrC2EiBvt2c0bebM7Kul+P3uCwcPpuF0xfyYGdpggGBrhgY6AJbSx5jtjQhBNRqIXUYDbAoJ7pJcVk1jpzLRkx8FrKuV8BYKUcvP0cM6O4Cn47WnFOciIiIiLTiYtcOk8O8ETXIC2cu5uNgXCa2xlzB1sNX0N3LDqFBrgjszJsFAzcK6JpaNapqVaiuqUNVjQpVNSpU16pQfdPPVX+uq65R/fncP9fV1P31uPbGspoaFdwcLfDZwqFSfzwNFuXU5tWp1Ii7dB2HE27MKa4WAp3dLPG3UX542M+Rc00SERERUbNTKm50/vTyc0R+USUOxWchJj4TKzYlwKqdMfp3d0FokAscbcylDrVRhBCoqVP/WRDX3VY831xAV9eqUFX9VwFdXVv/nLoGhXV1jQqN7dOWy2QwNVbAxFgB0z//mRgpYNveFCZ//ly/3M3BokVz8aBYbVCblZH755zi57JRWlELq3bGGNHbHQO6u8DFjnOKExEREVHrsLc2Q1SoFyIGeCDhcgEOncnE7tg07DyWCv9ONggNckVPHwcYKZun97xBAa0pnOtu6X2+qYCuubVn+ube57omFdC3Fs+mxrcX0CZGCpiaKGBqpPhzufKv1xj/tdzUWAGlQt7omy7r2jX8LMqpTSmvqkXs+RzExGfhanYpFHIZgr3tMSDQBd28bKGQc5gQEREREUlDIZcj2Nsewd72KCytRkxCFn6Py8TnW8+hnakS/bq5YFgfDxQVVTTojb7TMO6/Cuubh3X/VWSLRlbQMhlgaqy8rYC2tjD+syBWNlhuonmeskHxfPO6Bymg2wIW5WTw1GqB86kFiInPwukL+ahTqdHBwQKPDu2CPgFOaG/OOcWJiIiISLfYtDfBuH4eGNO3ExKvFuJgXCb2n87AryfT7/qamwtokz97kc0aFNC39zb/Naxb2aD3uf61LKBbHotyMli5hRWIScjGkbNZKCipRjtTJQYFuWJAoAs6Ollw50JEREREOk8ukyHA0xYBnrYoqahBXmkNKiuqYXpTT3R9MW2kZAGtj1iUk0GprlHhZHIuYuKzkJxeBBmAAE9bTB7ijR5d7GGk5JziRERERKSfLM2N0bmTHfLySqUOhZoRi3LSe0IIpFwrwe/xmTielIvqGhUcbW7cLKNfN2fO90hERERERDqLRTnprcLSahz9c07x7IIKmBgp0MvPAQMDXdGlgxWH7hARERERkc5jUU56pU6lxpmL+YhJyELC5esQAujSwQqjevuhF+cUJyIiIiIiPcMKhvRCWk4pYuKzcOx8Dsoqa2FtYYzRfTqhf3cXONuaSx0eERERERFRk7AoJ51VVnljTvHf4zORllMGpUKG4C4OGBjoggAPW8jlHJ5ORERERET6jUU56RS1WuDc1QL8Hp+FMxfzUKcS6OhkgWmPdEGfAGdYmBlJHSIREREREVGzYVFOOiGnoAIxCVk4cjYbhaXVsDAzwuBgtz/nFG8vdXhEREREREQtgkU5Saaqpg4nkm7MKX4xoxgyGdDdyw6PDu2CIG97GCnlUodIRERERETUoliU30V6bhkAwFgph7GRAsZKOYyUcigVLBS1IYTAxYxixMRn4URSLqprVXCyNceEQV7o180FNu1NpA6RiIiIiIio1bAov4tPNsYjt7DytuUKuQxGNxXqxkaKG4/vsMxEqYCRkbzhMs3zFTC+ZZ3m9X+uU8hlBjPXdkFJFY6czUZMQhZyCythYqxAiL8jBga6orObpcF8TiIiIiIiogfBovwu/jbKHyXl1aipVaO2ToXqP/+vqVPfZZkKVdV1KC5ruKymTo3aOnWTYpDJcFuhbnxzoX/LMhNlfXHfiGVGDU8MKBXyZi+Ma+vU+ONiHmISsnDuSgGEAHzdrTGunwd6+TrCxFjRrNsjIiIiIiLSNyzK76Krhw3UatEs76UWAnV16gaFuqZgr398y7Lquj+L+1p1w2V/Pqe6VoWyitpbnnfj/6aQAbcU6n8O2b/p59tGB9yyrn4kgEIhw5Xfr+C3U+kor6qDraUJxvT1wIDuznC04ZziRERERERE9ViUtwK5THajoDVSAC08pZcQAnUqtaZHv+aWgr1BAX+PXv/aW15fXlX75zJVg/cWdzlvYaSUo0cXewwIdEHXTpxTnIiIiIiI6E5YlBsYmUwGI6UCRkoF2pm27LaEEFCpxW29/zW1agR0cUBleXXLBkBERERERKTnWJRTk8lkMigVMigVctw6KN3C3JhFORERERER0X1wfi8iIiIiIiIiibAoJyIiIiIiIpIIi3IiIiIiIiIiibAoJyIiIiIiIpIIi3IiIiIiIiIiibAoJyIiIiIiIpIIi3IiIiIiIiIiibAoJyIiIiIiIpIIi3IiIiIiIiIiibAoJyIiIiIiIpIIi3IiIiIiIiIiiSilDkBXyeUyqUPQe8yh9phD7TGH2mMOmwfzqD3mUHvMofaYQ+0xh9pjDrWja/mTCSGE1EEQERERERERtUUcvk5EREREREQkERblRERERERERBJhUU5EREREREQkERblRERERERERBJhUU5EREREREQkERblRERERERERBJhUU5EREREREQkERblRERERERERBJhUU5EREREREQkEYMoysPCwnDhwgWpw9ArYWFhGDlyJCIiIhAREYG33377ns+fPn06fvvtt1aKzjCEhYVhwIABUKlUmmUbN26Er68vvvvuu2bbjq+vL8rLy5vt/fRBcXExunfvjn//+99Nfo9Zs2YhLS0NQNts363VPg0Zv3uaT2Ny2dbz3Rz7PW188sknqKmpkWTbN9u1axciIyMRERGBkSNH4qWXXmrye5WUlODLL79sxujuLyMjA717927VbWqjpqYG77zzDh555BGMHDkSkZGR2Lt3LwBg06ZNeOGFF+74ugdpL4bytx0WFoaxY8dCrVY3WCb1Z9OFGBqrvj4JDw/HsGHD8Pzzz+P06dNSh9UqOTSIolwX3Hxgqy8+/vhjREdHIzo6GosXL26W96yrq2uW91Gr1RBCNMt7ScnBwQExMTGax1u2bEFAQMADvUdz5dSQbNu2DcHBwdixY8cDHyTWt60vv/wSHTt2bKEI9UNztE8iah3a7Peaw4oVK1BbW9vq271Zbm4u3njjDXz22WeIjo7Grl27MHPmzCa/X0lJCb766qtmjLD1tNZx5+uvv47s7Gzs2LEDu3fvxrvvvotly5bhxIkT93xda7cXXTlWqqioQHR0tNRhNLvWzO/HH3+MrVu34tdff8X48ePxzDPPIC4urtW231Lul0ODKsrXrFmDCRMmIDIyElOmTEFiYqJmna+vL1atWoUJEyZg6NCh2LNnD4Dbz1je/Liurg5PP/00oqKiMGbMGLz66quaL8JNmzbh6aefxiuvvIKoqCicO3cOY8eObRBPeHi4TpzdaayysjIsWbIEEydOxLhx4/DWW2812OkfOXIE06dPx7Bhw/D+++9rlk+fPh3vv/8+nnzyScyePRuxsbGIiorSrL/5cV5eHqZPn67J6bvvvqt53ieffIKXX34Zs2fPRkREBHbt2oVnn31Ws76mpgYDBgxAVlZWS6ahWY0fPx6bNm0CAKSnp6OyshI+Pj4AgKNHj2LKlCmIjIzEuHHjsGPHDs3rbs0pAPz222+IiopCeHg4IiMjkZSUpHn+unXrbmvbhmzjxo2YPXs2fHx8sH//fgA32s+8efMwa9YsjBkzBnPnzkVpaalm3c1tq6SkRK/OHLeUprTP+Ph4vd/XNbdb29LNj8PCwvDRRx9hypQpCAsLazAK4fLly5g5cyYmTJiA8PBwbNy4sdVj1zX3ymW9ttoG77TfW7RoUYM2dfPjnJwcPPnkkxgzZgyee+45PPfcc5p1t44OuvnxihUrNCPpIiMjUVJSgjfeeAMAMHXqVM0+VAr5+flQKpWwtrYGAMhkMvj7+wMA4uLiNMcXUVFROHDgAIC/juuWL1+uOb45efIkAGDZsmUoLS1FREQEpk6dCuBGLt555x1MmzYNgwYNwurVq7F9+3ZMnToVYWFh2LVrlyae+23zgw8+QGRkJEaMGKHZZr07xQMABw8exNSpUxEVFYUpU6bgzJkzAG4cS0VERODNN9/E5MmTcejQoeZP8C2uXbuGXbt24fXXX4eJiQkAwMfHB8899xxWrFjR4LlZWVmIiorCzp0779he8vPz8fe//x3jxo3DuHHjsGXLlgav37ZtGx577DEMGzas0ftJX19ffPXVV5g+ffpt8Uhlzpw5dxwlkJqaiieffBLjxo3D+PHjNb+/lStXNhitWlhYiN69e6OiogI1NTWadhIREYFXXnlFMzJy0aJFWLp0KZ544gkMGTIEb7/9No4ePYpp06YhLCwM33zzTYPt62t+hw8fjqlTp2L16tX3zEdpaSleffVVjBs3DuHh4Vi2bBkA6FcOhQEYMmSISE5OFtevX9csO3z4sJg0aZLmsY+Pj1i3bp0QQoiTJ0+KAQMGCCGESE9PFyEhIZrn3fxYrVaLgoICzc+vvPKKWL9+vRBCiI0bN4rg4GCRmpqqee2kSZNEbGysEEKIEydOiIiIiJb4uM1iyJAhYsSIESI8PFyEh4eLQ4cOicWLF4vNmzcLIYRQqVRi/vz54qeffhJCCPH444+LGTNmiNraWlFWVibGjh0r9u/fr1n37LPPitraWiGEEMeOHRPjx4/XbOvmx1VVVaKsrEwIIURNTY2YPn26OHjwoBBCiI8//lgMGjRI83usra0VgwcPFmlpaUIIITZv3ixmz57d0qlpNkOGDBFJSUlixIgRoqioSHz00Udi3bp1YuHChWLdunWiqKhI1NXVCSGEyMvLEwMHDhRFRUVCiNtzevnyZdGvXz9x5coVIYQQ1dXVorS0VAhx97ZtqBITE8WQIUOEWq0W0dHRYubMmUKIG+2nf//+Ii8vTwghxKJFi8Q777yjWXdz2xLir/2GEDfyXd+e2wpt2qc+7etaUn0burkt3by8/uf6dpieni6Cg4NFWVmZqK2tFePHjxeXLl0SQghRWloqhg8frnnc1jQ2l/U/t7U2eLf9Xv3fa72bH8+ZM0esXLlSCCFERkaG6NGjh2bdrfu8+sdFRUUiODhYVFZWCiFutMv67yEfHx/N97dUVCqVeP7550VISIiYO3eu+Prrr0VBQYEoLi4WERERIicnRwghRE5Ojhg4cKAoLi4W6enpwsfHR3N8ExsbKwYOHCiqq6tvOwYU4kYu5s2bJ1QqlcjOzhaBgYHi/fffF0IIERcXJwYOHCiEEI3aZn2Oo6OjxZQpU4QQ4p7xpKamismTJ2u+3y9cuCAGDRokhLhxLOXn5ydOnz7dUum9zf79+0V4ePhty8+dOydCQkLExo0bxdy5c0ViYqIYM2aMOH78uOY5t7aXefPmiQ8++EAIcSNX/fv3b/C3vWjRIiHEje+b/v37i8TExPvuJ318fMTnn3/eMh++Cer3UXPnzhVr165tsGzixIni559/FkIIcfHiRRESEiKuX78url27Jvr376/5O/v22281uVi5cqXmb1gIId59911NW1y4cKGYOnWqqK6uFhUVFaJPnz5i0aJFmnZb/11TH4O+5PfW7wAhhPjf//4nRo0adc98LFq0SCxbtkyoVCohhNAc7+lTDpXNcRZDV5w9exaff/45iouLIZPJcPXq1QbrR48eDQAIDg5Gbm4uqqur7/l+arUaa9aswaFDh6BWq1FcXAxTU1PN+p49ezYY/jp9+nSsX78eISEh+P777/HYY48134drAR9//LGmVwwAFixYgPj4eHz99dcAgKqqKjg5OWnWR0ZGQqlUQqlUYvTo0Th27BiGDBkCABg3bhyUyvs3J5VKhXfffRd//PEHhBDIz89HUlISQkNDAQChoaGwtbUFACiVSkyZMgU//vgjXnnlFaxfvx4vvvhis33+1iCTyTBq1Cjs2LEDO3fuxA8//ICzZ88CAAoKCrB48WKkpqZCoVCguLgYV65cQXBwMICGOT1y5AhCQ0Ph4eEBADA2NoaxsbFmO3dq2/VntQ3Nhg0bEBERAZlMhuHDh+Ott95CTk4OAGDw4MGwt7cHAEycOBFvvfWW5nU3ty26oantU9/2dVKr//vs0KEDLC0tkZ2dDSEEUlJS8I9//EPzvNraWly+fBmdO3eWKlS90dba4L32e3cTGxuLf/7znwAANzc39O3b977bsbCwgKenJ1555RUMHDgQgwcPhoWFRbN8huYgl8vx6aef4sKFCzhx4gT27t2L1atXY8GCBcjIyMCsWbM0z5XJZEhNTYWNjQ2MjIwQHh4OAAgJCYGpqSkuX7581882cuRIyOVyODk5wdraGo888ggAICAgADk5OaiursYff/xxz22am5trjpGCg4OxfPlyzfPuFs+pU6eQlpbWoD3X1dUhPz8fANCpUyf06NGjOVLZKKIRlxEmJydjzpw5+Pzzz++57zp69CgWLVoEAHB0dMSgQYMQGxurOQ6dOHEiAMDe3h6DBw/G8ePHoVQq77ufHD9+fJM/X0t58cUX8cQTT2g+kxACiYmJmDBhAgDA29sb/v7+OHPmDMLCwtC5c2ccPHgQQ4cOxebNmzWXlO7fvx9lZWWaEZA1NTXw8/PTbOeRRx7RHAt6enpi0KBBmnZb/11Tnyd9zm99O7xXPn777Tds2rQJcvmNQeD1x3v6lEODKcrVajXmzZuH7777TrPTrC/06tUXKQqFAsCNHZ1SqWyw07m5UN+2bRtOnTqF77//HhYWFli1alWDQr9du3YN3n/kyJF4//33cf78ecTGxt735mm6RgiBTz/9FO7u7o16rkwm0zw2NzfX/KxQKO6a06+//holJSX45ZdfYGJign/9618N1t+a08mTJ2P8+PEICwtDSUlJow4qdE1UVBQmTZqEkJAQ2NjYaJa//vrrCAsLw4oVKyCTyTBixIgGubg5p/f7YrxT2zbEorympgbbtm2DiYmJ5pqt2tpabN68+bbn3tpGb21bdENT2qe+7+uam0KhaHBjn1tP+N78t6hQKKBSqSCTyWBjY2OQ1x5q4365rNeW2uC99nuNzdet7vY6hUKBn3/+GadPn8axY8cQFRWFr776qsFBrC7w8fGBj48PHnvsMYwePRpCCPj6+uL777+/7bkZGRm3Lbv1++FWt/7N3uk79n7bvPnEuVwuv+f1pDfHM3DgwAaX9tVLSUlpcFzQGnx8fJCWloaioiLNJQMAcObMGfj6+gIAnJycUF5ejtjY2PueULw153f7HdTnQwhx3/1ka+ekMby8vDBo0CBNJ9fdjuHqP//48eOxZcsWuLu7o7S0FL169dK87rXXXrvrse/d2mn947vdd0Df8puQkIAuXbogIyPjnvm4E33KoUFdU15XVwcXFxcAwPr16xv1Gnt7e9TW1iI1NRUAsH37ds260tJS2NjYwMLCAqWlpQ3W3YmRkREmTJiA559/HuPGjYOZmVkTP4k0wsLC8MUXX2gaYEFBAdLT0zXro6OjUVdXh4qKCuzevfuudw91d3dHeno6iouLIYRocK10aWkpHBwcYGJigpycHOzbt++eMdna2qJfv374xz/+gWnTpt3zS1RXubu7Y/78+Zprw+uVlpbCzc0NMpkMhw8f1rTBOxkwYAAOHTqkOSlUU1ODsrKylgxbJ+3duxdeXl44dOgQ9u/fj/3792PNmjWa66IPHDiAgoICAMDmzZv16g63UmlK+9T3fV1z69ixIxISEgDc6A2q79W6F09PT5iamja4rjIlJaVN/l3frLG5bEtt8F77vZvzlZubi9jYWM3rQkJCNCcss7KycOzYMc26m1936dIlzT14ysrKUFBQgJCQELzwwgvw8fHBxYsXAdw4sSl1+8zJycEff/yheZydnY2CggJ4e3sjNTW1wWeMj4/XFEO1tbXYtm0bAODkyZOorq6Gp6cnLCwsUFVV1aSbWPXo0eOe27yXu8XTv39//P7775qc17+nVDp06ICRI0fi9ddf15y4uXDhAlatWoU5c+YAAKytrbF27Vps3boVa9as0bz21vbSt29f/PTTTwBu3F/o4MGDDb6j69tqQUEBDh06hJCQEL3eT86dOxfr169HeXk55HI5/P39NZ8xJSUFSUlJCAoKAgCMGDECJ06cwJo1axr0qoaFhWHt2rWoqqoCcOPvMyUlpUnx6Gt+9+7dix9++AEzZsy4Zz6GDBmC1atXa/7+6o8F9SmHBtFTXldXBzMzM7zwwguYOHEiXFxcbuslvxulUoklS5ZgxowZcHNza7CDiIyMxL59+zBmzBg4OTnhoYceuu9Z6EmTJmHFihV49NFHtfpMUli8eDHee+89zRA5IyMjLF68WNNzHhAQgBkzZiAnJwcjR47UDMu6lZOTE2bMmIGoqCh06NAB3bt313zBTJ8+HfPmzUNkZCScnZ0bdbZr4sSJ2L17t04MoWmqKVOm3LbspZdewhtvvIEvv/wSvr6+mrPOd+Lh4YE333wT8+fPh0qlgkKhwDvvvHPP1xiiTZs2Ydy4cQ2W9ejRA2q1GidOnEDfvn2xePFipKenw9PTUzNUju6tKe1Tn/d1zaV+RMq8efOwaNEi/PLLL+jZsydcXV3v+1qlUolVq1bh7bffxurVq6FWq2FnZ4cPP/ywFSLXPU3JZVtpg/fa7/Xo0QMxMTEIDw+Hh4cHAgMDNc9ZsmQJFixYgJ07d8LLyws9e/bUDNeeNWsW5s2bh0OHDsHX1xddu3YFcOOAde7cuaiqqoIQAl27dsXw4cMBAE899RSeeOIJmJqaYt26dbC0tGylDPylrq4On3zyCa5duwZTU1Oo1Wq8+OKL6Nq1Kz799FO89957ePvtt1FbWwt3d3esWrUKwI3CMTU1FZMmTUJVVRXef/99zWVg9Tces7Kywo8//tjoWKysrO65zXu5WzweHh547733sGTJElRVVaG2thY9e/Zs8Httba+//jr++9//YvTo0TAyMoKJiQmWLFmCkJAQzSiE9u3bY/Xq1XjuuedQUVGBOXPm3NZe/vnPf2Lp0qWatvzyyy+jS5cumu24uLhg2rRpyMvLw7PPPqv5ztHX/aSzszMiIiI0Jyr+7//+D0uXLsXatWuhVCrx7rvvaoZYm5mZYejQodi0aVODzqpnnnkGK1aswMSJEyGTySCTyTBnzpwmXeKkT/l94YUXYGxsjMrKSnTu3BlffPEFgoODERAQcNd8vPrqq3j77bcxduxYKBQKhISE4J///Kde5VAmGnNKT4fl5uZi1KhROHz4cIPrvaUSHR2NHTt24IsvvpA6FIPx6aefIi8vD6+99prUoZAO++STT1BRUYGFCxdKHUqb0Nb3dbr23aPPmprLtt4G76eqqkpzH5jc3FxMnDgRa9euhZeXl9ShtaqMjAxMmDChwSgCIiJdo9c95d9++y3Wr1+PhQsX6sRB0dNPP420tDR89tlnUodiMMaMGQOFQoHVq1dLHQoR/amt7+t07btHnzU1l229DTbG1atXsXDhQgghUFdXhzlz5rS5gpyISF/ofU85ERERERERkb4yqBu9EREREREREekTFuVEREREREREEmFRTkRERERERCQRFuVERETUaL6+vg3mrSciIiLtsCgnIiLSU2FhYejWrRsKCgoaLI+IiICvr69mHuGmmj59On755Ret3oOIiIjujUU5ERGRHnNzc8OOHTs0j5OTk1FVVSVhRERERPQgWJQTERHpsYiICGzZskXzeMuWLYiMjNQ8Li0txYIFC9CnTx8MGTIEn376KdRqNQBg06ZNePTRR7F8+XI8/PDDCAsLw8GDBwEAH3zwAU6ePIlly5ahR48eWLZsmeY9jxw5guHDh+Phhx/GG2+8Ac6uSkRE1HQsyomIiPRYcHAwysrKkJKSApVKhZ07dyI8PFyz/s0330RpaSn27t2LdevWITo6Ghs3btSsj4+Ph6enJ44dO4aZM2diyZIlEEJg/vz56NWrF5YuXYo//vgDS5cu1bzmwIED2LBhA6Kjo7Fr1y78/vvvrfqZiYiIDAmLciIiIj1X31t++PBheHl5wcnJCQCgVquxc+dOvPTSS7CwsECHDh0wY8YMbN26VfNaV1dXTJ48GQqFAuPHj0deXh7y8/Pvub1Zs2bB0tISrq6u6N27N5KSklr08xERERkypdQBEBERkXYiIiLw+OOPIyMjAxEREZrlhYWFqK2thaurqwtx1J4AAAEySURBVGaZq6srcnJyNI/t7e01P5uZmQEAKioq7rk9BweHBq8pLy/X+jMQERH9f3t3jJpAEIZh+ItgoZ1gt+INLL2BiIWd3RbexE5rjyAeY0vPIuoFtjfdQgiEFAlDzPOUfzFM+/IzzH9lUw4Af1xVVZlMJrlcLlkul918NBql3+/nfr93s8fj0W3SAYDyRDkAvIDD4ZDz+ZzhcNjNer1eVqtVjsdj2rbN7XbL6XT68Ob8K+PxONfr9beuDABElAPAS5hOp5nNZp/mu90ug8Egi8UidV1nvV5ns9l868ztdpumaTKfz7Pf73/6ygBAkrenf0wAAACgCJtyAAAAKESUAwAAQCGiHAAAAAoR5QAAAFCIKAcAAIBCRDkAAAAUIsoBAACgEFEOAAAAhYhyAAAAKOQdLr2iV/sYL8wAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 1152x432 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Plot season popularity\n",
    "fig = df_plot.plot(x='date', y='count(review_id)',figsize=(16,6))\n",
    "fig.set_xticks(np.arange(1,13))\n",
    "fig.set_xticklabels(['January','February','March','April','May','June','July','August','Septmenber','Oktober','November','December'])\n",
    "plt.title('Season popularity of Copenhagen')\n",
    "plt.xlabel('Month')\n",
    "plt.ylabel('Number of reviews')\n",
    "plt.show()"
   ]
  },
  {
   "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": [
    "#### Description of Reviews\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": [
    "# Load listings\n",
    "dfl = spark.read.option('header', True).option('inferSchema', True).option('multiline', True).option('escape','\"').csv('../listings.csv')\n",
    "# Load reviews\n",
    "dfr = spark.read.option('header', True).option('inferSchema', True).option('multiline', True).option('escape','\"').csv('../reviews.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 remover\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
}