data_preprocessing.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Data preprocessing"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the next notebook of the series, we will perform the data preprocessing that consist of the following steps:\n",
    "- drop the duplicated rows\n",
    "- check the data frame in terms of missing values\n",
    "- explode the measurements JSON array, sort it according to sensor serial number and limit the number of measurements\n",
    "- extract the sensor, timestamp and RSSI information from array of measurements\n",
    "- verify sensors' location and correct their elevation\n",
    "- perform data casting and filtering\n",
    "- conduct timestamps synchronization [1]\n",
    "- create linear regression models of timestamp corrections\n",
    "- perform the feature extraction\n",
    "- calculate the normalization parameters\n",
    "\n",
    "The notebook gives you a choice for the destination of the preprocessed data, it can be a HDF5 dataset or a MariaDB database. Both of those data stores could be used as a source of data for the machine learning model, thanks to our implementation of the dataset loaders."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For the record, our dataset comprises of three CSV files:\n",
    "- round2_training1.csv\n",
    "- round2_training2.csv\n",
    "- round2_training3.csv\n",
    "\n",
    "To perform the preprocessing of the entire dataset, you have to repeat all aforementioned steps for each of those files. You can do this by simply re-runing the entire notebook with the path changed in the following parts of the code:\n",
    "\n",
    "- <code>df = spark.read.format(\"csv\") \\\n",
    "    .options(header='True', inferSchema='True') \\\n",
    "    .load(\"round2_training/round2/round2_training3.csv\") </code>\n",
    "- <code>pd.read_csv('round2_training/round2/training3/training3.csv', dtype=types)</code>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "After saving the data either by <code>df.write.save()</code> or <code>pandas.to_csv()</code> it is advised to restart the kernel in order to free up the memory."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We will begin with importing all libraries that will be used in this notebook."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "import operator\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "import json\n",
    "import urllib\n",
    "import time\n",
    "import pickle\n",
    "import matplotlib.pyplot as plt\n",
    "import findspark\n",
    "findspark.init()\n",
    "import pyspark\n",
    "import pyspark.sql.functions as F\n",
    "from pyspark.sql import types\n",
    "from pyspark.sql import SparkSession\n",
    "from tqdm import tqdm\n",
    "import warnings\n",
    "warnings.filterwarnings('ignore')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we can instantiate the <i>SparkSession</i>. For testing, the application will be running locally with 2 cores, and 4 GB of memory for the driver process. \n",
    "\n",
    "Other options to run <i>Spark</i> (locally, on cluster) can be found [here](http://spark.apache.org/docs/latest/submitting-applications.html#master-urls)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "spark = SparkSession.builder \\\n",
    "    .master(\"local[2]\") \\\n",
    "    .appName(\"ads-b data processing\") \\\n",
    "    .config(\"spark.driver.memory\", \"4g\") \\\n",
    "    .getOrCreate()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We will also set the number of output partitions (low values speed up processing) and the log level for our application."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Set number of output partitions\n",
    "spark.conf.set(\"spark.sql.shuffle.partitions\", 100)\n",
    "\n",
    "# Set log level\n",
    "spark.sparkContext.setLogLevel(\"ERROR\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Below we will load the CSV file and print its schema."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "df = spark.read.format(\"csv\") \\\n",
    "    .options(header='True', inferSchema='True') \\\n",
    "    .load(\"round2_training/round2/round2_training3.csv\") "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "root\n",
      " |-- id: integer (nullable = true)\n",
      " |-- timeAtServer: double (nullable = true)\n",
      " |-- aircraft: integer (nullable = true)\n",
      " |-- latitude: double (nullable = true)\n",
      " |-- longitude: double (nullable = true)\n",
      " |-- baroAltitude: double (nullable = true)\n",
      " |-- geoAltitude: double (nullable = true)\n",
      " |-- numMeasurements: integer (nullable = true)\n",
      " |-- measurements: string (nullable = true)\n",
      "\n"
     ]
    }
   ],
   "source": [
    "df.printSchema()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As we can see the shema of the data frame corresponds to the input dataset (inspected in the previous notebook)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We will also check how many rows our data frame contains."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of rows in the data frame: 6535444\n"
     ]
    }
   ],
   "source": [
    "print('Number of rows in the data frame: {}'.format(df.count()))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Below we will drop the duplicated rows. We will take into consideration the following columns: timeAtServer, aircraft, measurements, latitude, longitude and baroAltitude."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "df = df.dropDuplicates(['timeAtServer', 'aircraft', 'measurements', 'latitude', 'longitude', 'baroAltitude'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of rows in the data frame without duplicates: 6367870\n"
     ]
    }
   ],
   "source": [
    "print('Number of rows in the data frame without duplicates: {}'.format(df.count()))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we have to check whether the data frame contains any missing values."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+---+------------+--------+--------+---------+------------+-----------+---------------+------------+\n",
      "| id|timeAtServer|aircraft|latitude|longitude|baroAltitude|geoAltitude|numMeasurements|measurements|\n",
      "+---+------------+--------+--------+---------+------------+-----------+---------------+------------+\n",
      "|  0|           0|       0|       0|        0|           0|          0|              0|           0|\n",
      "+---+------------+--------+--------+---------+------------+-----------+---------------+------------+\n",
      "\n"
     ]
    }
   ],
   "source": [
    "df.select([F.count(F.when(F.isnan(col), col)).alias(col) for col in df.columns]).show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "According to the preceding tally, there are no missing values."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's take a look at how the data frame looks like."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+----+------------------+--------+----------------+-----------------+------------+-----------+---------------+--------------------+\n",
      "|  id|      timeAtServer|aircraft|        latitude|        longitude|baroAltitude|geoAltitude|numMeasurements|        measurements|\n",
      "+----+------------------+--------+----------------+-----------------+------------+-----------+---------------+--------------------+\n",
      "|  94|0.0260000228881836|    2308|51.0823757365599| 6.52473449707031|     1325.88|    1264.92|              4|[[398,1005256156,...|\n",
      "| 218|0.0739998817443848|     997|53.0042266845703|  5.7818603515625|     12192.0|   12092.94|              4|[[529,-1510290083...|\n",
      "| 666| 0.332000017166138|    1633|45.0371246337891| 9.33380126953125|     2118.36|    2042.16|              2|[[132,1314392468,...|\n",
      "| 886| 0.454999923706055|    2625|48.3951012562897| 10.2624592028166|    10988.04|    10858.5|             10|[[257,1435786406,...|\n",
      "|1000| 0.519999980926514|     370| 46.047797768803| 6.03437805175781|     4480.56|     4381.5|              2|[[131,1502574265,...|\n",
      "|1018| 0.523999929428101|    1972|53.2917022705078|-0.65659005301336|      8686.8|    8641.08|              5|[[216,1465412046,...|\n",
      "|1027| 0.530999898910523|    2000|50.8355557716499| 14.0164184570313|     11277.6|   11155.68|              5|[[694,84457592500...|\n",
      "|1079| 0.557999849319458|    2643|53.0450592041016|-2.24525451660156|     10363.2|   10264.14|             12|[[185,811651796,5...|\n",
      "|1187| 0.615999937057495|    2874|40.0789031982422| -8.1033935546875|     11277.6|    11277.6|              3|[[564,1571338843,...|\n",
      "|1248| 0.651000022888184|      75|47.4375682766155| 7.70958533653846|     10972.8|   10828.02|             17|[[259,1643958296,...|\n",
      "+----+------------------+--------+----------------+-----------------+------------+-----------+---------------+--------------------+\n",
      "only showing top 10 rows\n",
      "\n"
     ]
    }
   ],
   "source": [
    "df.show(10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Explode the measurements data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We have to extract the measurements data from the JSON array. To do this firstly we have to specify the shema of that array, so the <i>Spark</i> will be able to transform the data correctly. As we established in the first notebook, we take into account a limited number of measurements, thus we have to set the max_measurements to 6 (75th percentile of the distribution of the measurements)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "df = df.limit(df.count())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "max_measurements = 6\n",
    "json_schema = types.ArrayType(types.ArrayType(types.DoubleType()))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "df = df.withColumn('meas', F.from_json('measurements', schema=json_schema))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It would be convenient to have the measurements in some kind of order. That's why we will now sort arrays of measurements according to the sensor's serial number. To achieve this we will utilize the RDD's <i>map</i> function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Sort arrays within 'meas' column (x[9]) according to sensor number (itemgetter(0))\n",
    "df = df.rdd.map(lambda x: [x[0], x[1], x[2], x[3], x[4], x[5], x[6], x[7], x[8], \\\n",
    "                           sorted(x[9], key=operator.itemgetter(0), reverse=False)]) \\\n",
    "                                .toDF(df.schema.names)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+----+--------------------+--------------------+\n",
      "|  id|        measurements|                meas|\n",
      "+----+--------------------+--------------------+\n",
      "|  94|[[398,1005256156,...|[[134.0, 1.005387...|\n",
      "| 218|[[529,-1510290083...|[[170.0, 2.078536...|\n",
      "| 666|[[132,1314392468,...|[[132.0, 1.314392...|\n",
      "| 886|[[257,1435786406,...|[[141.0, 1.435664...|\n",
      "|1000|[[131,1502574265,...|[[131.0, 1.502574...|\n",
      "|1018|[[216,1465412046,...|[[184.0, 4.861520...|\n",
      "|1027|[[694,84457592500...|[[26.0, 2.0826087...|\n",
      "|1079|[[185,811651796,5...|[[184.0, 4.916273...|\n",
      "|1187|[[564,1571338843,...|[[513.0, 8.271332...|\n",
      "|1248|[[259,1643958296,...|[[10.0, 1.6436849...|\n",
      "+----+--------------------+--------------------+\n",
      "only showing top 10 rows\n",
      "\n"
     ]
    }
   ],
   "source": [
    "df.select('id', 'measurements', 'meas').show(10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We will explode the 'meas' field so that the sensor, timestamp and RSSI information of each measurement is presented as a separate column, at the same time we will cast new fields to the proper data type."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "col_names = ['sensor', 'tmp', 'RSSI']\n",
    "col_types = ['int', 'Decimal(16,0)', 'int']\n",
    "\n",
    "for i in range(max_measurements):\n",
    "    for j, col_name in enumerate(col_names): \n",
    "        df = df.withColumn('{}_{}'.format(col_name, i), F.col('meas')[i][j].cast(col_types[j]))\n",
    "\n",
    "df = df.drop('meas', 'measurements') "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+----+--------+-----------+------+--------+-----------+------+\n",
      "|id  |sensor_0|tmp_0      |RSSI_0|sensor_1|tmp_1      |RSSI_1|\n",
      "+----+--------+-----------+------+--------+-----------+------+\n",
      "|94  |134     |1005387312 |107   |248     |-268722583 |105   |\n",
      "|218 |170     |20785362500|186   |507     |57626342333|20    |\n",
      "|666 |132     |1314392468 |83    |277     |60809942500|59    |\n",
      "|886 |141     |1435664828 |115   |143     |1435638218 |115   |\n",
      "|1000|131     |1502574265 |73    |665     |44191180417|84    |\n",
      "|1018|184     |4861520250 |184   |216     |1465412046 |39    |\n",
      "|1027|26      |20826087583|132   |236     |21155851500|11    |\n",
      "|1079|184     |4916273917 |98    |185     |811651796  |50    |\n",
      "|1187|513     |82713328667|101   |564     |1571338843 |51    |\n",
      "|1248|10      |1643684906 |119   |14      |1643671093 |101   |\n",
      "+----+--------+-----------+------+--------+-----------+------+\n",
      "only showing top 10 rows\n",
      "\n"
     ]
    }
   ],
   "source": [
    "df.select('id', 'sensor_0', 'tmp_0', 'RSSI_0', 'sensor_1', 'tmp_1', 'RSSI_1').show(10, False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we will save the transformed data frame into a disk."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "df.write.save('round2_training/round2/training3', format='csv', header=True, mode='overwrite')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "file_name = [name for name in os.listdir('round2_training/round2/training3') if name.startswith('part')]\n",
    "\n",
    "os.rename(os.path.join('round2_training/round2/training3', file_name[0]),\n",
    "          'round2_training/round2/training3/training3.csv')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Sensor localizations"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this section, we will verify the localization of the sensors. We do not have enough data to check whether the receiver's location is not very accurate. What we can do is to find incorrect coordinates like for instance (0, 0, 0)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "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>serial</th>\n",
       "      <th>latitude</th>\n",
       "      <th>longitude</th>\n",
       "      <th>height</th>\n",
       "      <th>type</th>\n",
       "      <th>good</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>3</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.0</td>\n",
       "      <td>SBS-3</td>\n",
       "      <td>False</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>5</td>\n",
       "      <td>52.356455</td>\n",
       "      <td>4.952216</td>\n",
       "      <td>0.0</td>\n",
       "      <td>dump1090</td>\n",
       "      <td>False</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>6</td>\n",
       "      <td>47.174200</td>\n",
       "      <td>8.524700</td>\n",
       "      <td>0.0</td>\n",
       "      <td>Radarcape</td>\n",
       "      <td>False</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>8</th>\n",
       "      <td>9</td>\n",
       "      <td>45.410944</td>\n",
       "      <td>11.887529</td>\n",
       "      <td>0.0</td>\n",
       "      <td>Radarcape</td>\n",
       "      <td>False</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>26</th>\n",
       "      <td>27</td>\n",
       "      <td>49.408540</td>\n",
       "      <td>6.950260</td>\n",
       "      <td>0.0</td>\n",
       "      <td>SBS-3</td>\n",
       "      <td>False</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>77</th>\n",
       "      <td>78</td>\n",
       "      <td>33.573110</td>\n",
       "      <td>-7.589843</td>\n",
       "      <td>0.0</td>\n",
       "      <td>dump1090</td>\n",
       "      <td>False</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>78</th>\n",
       "      <td>79</td>\n",
       "      <td>34.018125</td>\n",
       "      <td>-5.007845</td>\n",
       "      <td>0.0</td>\n",
       "      <td>dump1090</td>\n",
       "      <td>False</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>144</th>\n",
       "      <td>145</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.0</td>\n",
       "      <td>dump1090</td>\n",
       "      <td>False</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>228</th>\n",
       "      <td>229</td>\n",
       "      <td>52.450600</td>\n",
       "      <td>5.500400</td>\n",
       "      <td>0.0</td>\n",
       "      <td>dump1090</td>\n",
       "      <td>False</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>333</th>\n",
       "      <td>334</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.0</td>\n",
       "      <td>dump1090</td>\n",
       "      <td>False</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>334</th>\n",
       "      <td>335</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.0</td>\n",
       "      <td>dump1090</td>\n",
       "      <td>False</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>336</th>\n",
       "      <td>337</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.0</td>\n",
       "      <td>dump1090</td>\n",
       "      <td>False</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>381</th>\n",
       "      <td>382</td>\n",
       "      <td>56.033300</td>\n",
       "      <td>14.133300</td>\n",
       "      <td>0.0</td>\n",
       "      <td>dump1090</td>\n",
       "      <td>False</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>426</th>\n",
       "      <td>427</td>\n",
       "      <td>52.145090</td>\n",
       "      <td>4.647430</td>\n",
       "      <td>0.0</td>\n",
       "      <td>dump1090</td>\n",
       "      <td>False</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>433</th>\n",
       "      <td>434</td>\n",
       "      <td>43.339208</td>\n",
       "      <td>2.813991</td>\n",
       "      <td>0.0</td>\n",
       "      <td>dump1090</td>\n",
       "      <td>False</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>434</th>\n",
       "      <td>435</td>\n",
       "      <td>29.691740</td>\n",
       "      <td>-9.719102</td>\n",
       "      <td>0.0</td>\n",
       "      <td>dump1090</td>\n",
       "      <td>False</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>475</th>\n",
       "      <td>476</td>\n",
       "      <td>33.045397</td>\n",
       "      <td>-3.994095</td>\n",
       "      <td>0.0</td>\n",
       "      <td>dump1090</td>\n",
       "      <td>False</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>495</th>\n",
       "      <td>496</td>\n",
       "      <td>52.676435</td>\n",
       "      <td>-8.652775</td>\n",
       "      <td>0.0</td>\n",
       "      <td>dump1090</td>\n",
       "      <td>False</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>504</th>\n",
       "      <td>505</td>\n",
       "      <td>52.454559</td>\n",
       "      <td>0.204492</td>\n",
       "      <td>0.0</td>\n",
       "      <td>dump1090</td>\n",
       "      <td>False</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>584</th>\n",
       "      <td>585</td>\n",
       "      <td>42.361670</td>\n",
       "      <td>-3.675535</td>\n",
       "      <td>0.0</td>\n",
       "      <td>dump1090</td>\n",
       "      <td>False</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>649</th>\n",
       "      <td>650</td>\n",
       "      <td>52.263500</td>\n",
       "      <td>20.963500</td>\n",
       "      <td>0.0</td>\n",
       "      <td>dump1090</td>\n",
       "      <td>False</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>702</th>\n",
       "      <td>703</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.0</td>\n",
       "      <td>dump1090</td>\n",
       "      <td>False</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "     serial   latitude  longitude  height       type   good\n",
       "2         3   0.000000   0.000000     0.0      SBS-3  False\n",
       "4         5  52.356455   4.952216     0.0   dump1090  False\n",
       "5         6  47.174200   8.524700     0.0  Radarcape  False\n",
       "8         9  45.410944  11.887529     0.0  Radarcape  False\n",
       "26       27  49.408540   6.950260     0.0      SBS-3  False\n",
       "77       78  33.573110  -7.589843     0.0   dump1090  False\n",
       "78       79  34.018125  -5.007845     0.0   dump1090  False\n",
       "144     145   0.000000   0.000000     0.0   dump1090  False\n",
       "228     229  52.450600   5.500400     0.0   dump1090  False\n",
       "333     334   0.000000   0.000000     0.0   dump1090  False\n",
       "334     335   0.000000   0.000000     0.0   dump1090  False\n",
       "336     337   0.000000   0.000000     0.0   dump1090  False\n",
       "381     382  56.033300  14.133300     0.0   dump1090  False\n",
       "426     427  52.145090   4.647430     0.0   dump1090  False\n",
       "433     434  43.339208   2.813991     0.0   dump1090  False\n",
       "434     435  29.691740  -9.719102     0.0   dump1090  False\n",
       "475     476  33.045397  -3.994095     0.0   dump1090  False\n",
       "495     496  52.676435  -8.652775     0.0   dump1090  False\n",
       "504     505  52.454559   0.204492     0.0   dump1090  False\n",
       "584     585  42.361670  -3.675535     0.0   dump1090  False\n",
       "649     650  52.263500  20.963500     0.0   dump1090  False\n",
       "702     703   0.000000   0.000000     0.0   dump1090  False"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sensor_data = pd.read_csv(\"round2_training/round2/round2_sensors.csv\")\n",
    "sensor_data.loc[(sensor_data.latitude == 0) | (sensor_data.longitude == 0) | (sensor_data.height == 0)]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As we can see there are some coordinates with all zero values indicating that those locations haven't been specified, but also we can see that for some latitude/longitude coordinates the value of the height (elevation) equals zero, this requires to manually check and amend those elevations. To achieve this we will utilize the <i>Opentopodata</i> Public API."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "def getElevation(lat, lon):\n",
    "    \"\"\"Returns the elevation (m) for provided latitude and longitude coordinates. Returns 0 if elevation hasn't been found.\n",
    "    \n",
    "    \"\"\"\n",
    "\n",
    "    coords = '{},{}'.format(lat, lon)\n",
    "\n",
    "    url = \"https://api.opentopodata.org/v1/etopo1?locations=\" + urllib.parse.quote(coords)\n",
    "\n",
    "    opener = urllib.request.build_opener()\n",
    "    opener.addheaders = [('User-agent', 'Mozilla/5.0 (X11; Linux x86_64; rv:69.0) Gecko/20100101 Firefox/69.0')]\n",
    "    urllib.request.install_opener(opener)\n",
    "\n",
    "    response = urllib.request.urlopen(url)\n",
    "    data = response.read()\n",
    "    encoding = response.info().get_content_charset('utf-8')\n",
    "    \n",
    "    time.sleep(3)\n",
    "\n",
    "    data = json.loads(data.decode(encoding))\n",
    "    \n",
    "    try:\n",
    "        return data['results'][0]['elevation']\n",
    "    except:\n",
    "        return 0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we will use the <i>getElevation</i> function to populate the data frame with new elevations."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i, row in sensor_data.loc[(sensor_data.latitude != 0) & (sensor_data.longitude != 0) \\\n",
    "                           & (sensor_data.height == 0)].iterrows():\n",
    "\n",
    "    sensor_data.loc[i, 'height'] = getElevation(row.latitude, row.longitude)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "That operation is successful. Only one data point has been left with unspecified elevation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "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>serial</th>\n",
       "      <th>latitude</th>\n",
       "      <th>longitude</th>\n",
       "      <th>height</th>\n",
       "      <th>type</th>\n",
       "      <th>good</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>381</th>\n",
       "      <td>382</td>\n",
       "      <td>56.0333</td>\n",
       "      <td>14.1333</td>\n",
       "      <td>0.0</td>\n",
       "      <td>dump1090</td>\n",
       "      <td>False</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "     serial  latitude  longitude  height      type   good\n",
       "381     382   56.0333    14.1333     0.0  dump1090  False"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sensor_data.loc[(sensor_data.latitude != 0) & (sensor_data.longitude != 0)   & (sensor_data.height == 0)]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we have to determine the number of times given sensor without coordinates occurred in the flights' dataset."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "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>serial</th>\n",
       "      <th>latitude</th>\n",
       "      <th>longitude</th>\n",
       "      <th>height</th>\n",
       "      <th>type</th>\n",
       "      <th>good</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>3</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>SBS-3</td>\n",
       "      <td>False</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>144</th>\n",
       "      <td>145</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>dump1090</td>\n",
       "      <td>False</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>333</th>\n",
       "      <td>334</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>dump1090</td>\n",
       "      <td>False</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>334</th>\n",
       "      <td>335</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>dump1090</td>\n",
       "      <td>False</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>336</th>\n",
       "      <td>337</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>dump1090</td>\n",
       "      <td>False</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>702</th>\n",
       "      <td>703</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>dump1090</td>\n",
       "      <td>False</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "     serial  latitude  longitude  height      type   good\n",
       "2         3       0.0        0.0     0.0     SBS-3  False\n",
       "144     145       0.0        0.0     0.0  dump1090  False\n",
       "333     334       0.0        0.0     0.0  dump1090  False\n",
       "334     335       0.0        0.0     0.0  dump1090  False\n",
       "336     337       0.0        0.0     0.0  dump1090  False\n",
       "702     703       0.0        0.0     0.0  dump1090  False"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sensor_data.loc[(sensor_data.latitude == 0) & (sensor_data.longitude == 0)]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Firstly we need to load the flights data frame."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "flights = pd.read_csv('round2_training/round2/training3/trainig3.csv')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Subsequently, the frequency of sensors without coordinates can be established."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "max_measurements = 10\n",
    "count_dict = {}\n",
    "\n",
    "for i, row in sensor_data.loc[(sensor_data.latitude == 0) & (sensor_data.longitude == 0)].iterrows():\n",
    "    count = 0\n",
    "    for sensor_nu in range(max_measurements):\n",
    "        count += flights.loc[flights['{}_sensor'.format(sensor_nu)] == row.serial, '{}_sensor'.format(sensor_nu)].count()\n",
    "    count_dict[row.serial] = count"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "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>count</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>145</th>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>334</th>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>335</th>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>337</th>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>703</th>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "     count\n",
       "3        0\n",
       "145      0\n",
       "334      0\n",
       "335      0\n",
       "337      0\n",
       "703      0"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pd.DataFrame({'count': count_dict})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In each of our flights' datasets, neither of the sensors without localization information is included, thus we do not have to perform any further filtering of sensors in the dataset."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "sensor_data.to_csv('round2_training/round2/round2_sensors.csv', index=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Data casting and filtering"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next, we will cast the data to proper data types and filter-out data with incorrect timestamps."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "flights = pd.read_csv('round2_training/round2/training3/training3.csv')\n",
    "\n",
    "max_measurements = 6"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Change column data types\n",
    "types = {'id': 'int32', 'timeAtServer': 'float32', 'aircraft': 'int16', 'latitude': 'float32', 'longitude': 'float32',\n",
    "        'baroAltitude': 'float32', 'geoAltitude': 'float32', 'numMeasurements': 'int16'}\n",
    "\n",
    "for i in range(max_measurements):\n",
    "    types['tmp_{}'.format(i)] = 'float64'\n",
    "    types['RSSI_{}'.format(i)] = 'int16'\n",
    "    \n",
    "# Fill missing values for RSSI fields\n",
    "flights.fillna(value={i:0 for i in list(types.keys()) if i.startswith('RSSI')}, inplace=True)\n",
    "\n",
    "flights = flights.astype(types, errors='ignore')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are some negative values for the timestamp of sensor_0, thus to be able to use this sensor as a reference clock during the synchronization process we have to take absolute values of those timestamps."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "flights['tmp_0'] = flights['tmp_0'].abs()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we will drop all the rows that contain 0 values in timestamp columns."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "idx = []\n",
    "\n",
    "for i in range(max_measurements):\n",
    "    idx.extend(flights.loc[flights['tmp_{}'.format(i)] == 0].index)\n",
    "        \n",
    "flights.drop(idx, inplace=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "flights.to_csv('round2_training/round2/training3/training3.csv', index=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Timestamp synchronization"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the dataset, only some receivers will provide GPS-synchronized timestamps while others do not offer such time synchronization and thus experience clock drifts. We have to perform timestamp synchronization in order to ensure that all timestamps are measured according to the same reference clock."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The method of timestamp synchronization is depicted in the following diagram and is based on the paper - <i> The Testing of MLAT Method Application by means of Usage low-cost ADS-B Receivers</i> [1]. According to that method, the ADS-B message with airplane position pA is received by ground station p1 and p2 in time t1 and t2 respectively. Knowing the distance between airplane and first sensor |pA-p1| and between airplane and second sensor |pA-p2| we are able to calculate the signal reception time at receiver p2 (t2_corr) with respect to sensor's p1 clock. By subtracting t2_corr from the original time of reception (t2) we can determine the correction that needs to be applied to each message at sensor p2 [1]. Because the correction value tend to change in time, we will also create the linear regression models of sensor corrections that represent the relationship between the correction that has to be applied and the timeAtServer."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"assets/clock_synch_method.png\" width=\"500 px\">\n",
    "<p><center>Receiver’s clock synchronization method [1]</center></p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "max_measurements = 6\n",
    "\n",
    "types = {'id': 'int32', 'timeAtServer': 'float32', 'aircraft': 'int16', 'latitude': 'float32', 'longitude': 'float32',\n",
    "        'baroAltitude': 'float32', 'geoAltitude': 'float32', 'numMeasurements': 'int16'}\n",
    "\n",
    "for i in range(max_measurements):\n",
    "    types['tmp_{}'.format(i)] = 'float64'\n",
    "    types['RSSI_{}'.format(i)] = 'int16'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To speed up the timestamp synchronization calculations we will use the <i>Modin</i> library, whose implementation enables you to use all of the cores on your machine, or in a cluster."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "from distributed import Client\n",
    "\n",
    "# set up cluster and workers\n",
    "client = Client(n_workers=2, \n",
    "                threads_per_worker=1,\n",
    "                memory_limit='5GB')\n",
    "\n",
    "import modin.pandas as pd"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We will begin by loading the flights' dataset and the sensors' dataset."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "flights = pd.read_csv('round2_training/round2/training3/training3.csv', dtype=types)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "sensors = pd.read_csv('round2_training/round2/round2_sensors.csv')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Below we will define functions for converting WSG84 coordinates to cartesian ones, and for calculating the Euclidean distance between coordinates."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def lla_to_ecef(latitude, longitude, altitude):\n",
    "    latitude = np.radians(latitude)\n",
    "    longitude = np.radians(longitude)\n",
    "\n",
    "    # WSG84 ellipsoid constants\n",
    "    a = 6378137\n",
    "    e = 8.1819190842622e-2\n",
    "\n",
    "    # prime vertical radius of curvature\n",
    "    N = a / np.sqrt(1 - e**2 * np.sin(latitude)**2)\n",
    "\n",
    "    x = (N + altitude) * np.cos(latitude) * np.cos(longitude)\n",
    "    y = (N + altitude) * np.cos(latitude) * np.sin(longitude)\n",
    "    z = ((1 - e**2) * N + altitude) * np.sin(latitude)\n",
    "    \n",
    "    return x, y, z\n",
    "\n",
    "def calculateDist(x1, y1, z1, x2, y2, z2):  \n",
    "    x1, y1, z1 = lla_to_ecef(x1, y1, z1)\n",
    "    x2, y2, z2 = lla_to_ecef(x2, y2, z2)\n",
    "    \n",
    "    return np.sqrt((x1-x2)**2 + (y1-y2)**2 + (z1-z2)**2) / 1000"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Before joining flights' and sensors' dataframes together, we have to set the index of the sensors' dataframe to 'serial'."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "sensors.set_index('serial', inplace=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "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>latitude</th>\n",
       "      <th>longitude</th>\n",
       "      <th>height</th>\n",
       "      <th>type</th>\n",
       "      <th>good</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>serial</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>46.681067</td>\n",
       "      <td>7.665313</td>\n",
       "      <td>680.9232</td>\n",
       "      <td>SBS-3</td>\n",
       "      <td>False</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>40.337042</td>\n",
       "      <td>-3.770206</td>\n",
       "      <td>735.7872</td>\n",
       "      <td>SBS-3</td>\n",
       "      <td>False</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.0000</td>\n",
       "      <td>SBS-3</td>\n",
       "      <td>False</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>47.143056</td>\n",
       "      <td>7.243889</td>\n",
       "      <td>550.1640</td>\n",
       "      <td>SBS-3</td>\n",
       "      <td>False</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>52.356455</td>\n",
       "      <td>4.952216</td>\n",
       "      <td>-1.0000</td>\n",
       "      <td>dump1090</td>\n",
       "      <td>False</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "         latitude  longitude    height      type   good\n",
       "serial                                                 \n",
       "1       46.681067   7.665313  680.9232     SBS-3  False\n",
       "2       40.337042  -3.770206  735.7872     SBS-3  False\n",
       "3        0.000000   0.000000    0.0000     SBS-3  False\n",
       "4       47.143056   7.243889  550.1640     SBS-3  False\n",
       "5       52.356455   4.952216   -1.0000  dump1090  False"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sensors.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "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>id</th>\n",
       "      <th>timeAtServer</th>\n",
       "      <th>aircraft</th>\n",
       "      <th>latitude</th>\n",
       "      <th>longitude</th>\n",
       "      <th>baroAltitude</th>\n",
       "      <th>geoAltitude</th>\n",
       "      <th>numMeasurements</th>\n",
       "      <th>sensor_0</th>\n",
       "      <th>tmp_0</th>\n",
       "      <th>...</th>\n",
       "      <th>RSSI_2</th>\n",
       "      <th>sensor_3</th>\n",
       "      <th>tmp_3</th>\n",
       "      <th>RSSI_3</th>\n",
       "      <th>sensor_4</th>\n",
       "      <th>tmp_4</th>\n",
       "      <th>RSSI_4</th>\n",
       "      <th>sensor_5</th>\n",
       "      <th>tmp_5</th>\n",
       "      <th>RSSI_5</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>94</td>\n",
       "      <td>0.026</td>\n",
       "      <td>2308</td>\n",
       "      <td>51.082375</td>\n",
       "      <td>6.524734</td>\n",
       "      <td>1325.880005</td>\n",
       "      <td>1264.920044</td>\n",
       "      <td>4</td>\n",
       "      <td>134</td>\n",
       "      <td>1.005387e+09</td>\n",
       "      <td>...</td>\n",
       "      <td>170</td>\n",
       "      <td>670.0</td>\n",
       "      <td>1.005362e+09</td>\n",
       "      <td>62</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>218</td>\n",
       "      <td>0.074</td>\n",
       "      <td>997</td>\n",
       "      <td>53.004227</td>\n",
       "      <td>5.781860</td>\n",
       "      <td>12192.000000</td>\n",
       "      <td>12092.940430</td>\n",
       "      <td>4</td>\n",
       "      <td>170</td>\n",
       "      <td>2.078536e+10</td>\n",
       "      <td>...</td>\n",
       "      <td>19</td>\n",
       "      <td>704.0</td>\n",
       "      <td>7.726590e+10</td>\n",
       "      <td>10</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>666</td>\n",
       "      <td>0.332</td>\n",
       "      <td>1633</td>\n",
       "      <td>45.037125</td>\n",
       "      <td>9.333801</td>\n",
       "      <td>2118.360107</td>\n",
       "      <td>2042.160034</td>\n",
       "      <td>2</td>\n",
       "      <td>132</td>\n",
       "      <td>1.314392e+09</td>\n",
       "      <td>...</td>\n",
       "      <td>0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>886</td>\n",
       "      <td>0.455</td>\n",
       "      <td>2625</td>\n",
       "      <td>48.395100</td>\n",
       "      <td>10.262459</td>\n",
       "      <td>10988.040039</td>\n",
       "      <td>10858.500000</td>\n",
       "      <td>10</td>\n",
       "      <td>141</td>\n",
       "      <td>1.435665e+09</td>\n",
       "      <td>...</td>\n",
       "      <td>148</td>\n",
       "      <td>257.0</td>\n",
       "      <td>1.435786e+09</td>\n",
       "      <td>55</td>\n",
       "      <td>263.0</td>\n",
       "      <td>1.435661e+09</td>\n",
       "      <td>67</td>\n",
       "      <td>388.0</td>\n",
       "      <td>7.471172e+10</td>\n",
       "      <td>23</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>1000</td>\n",
       "      <td>0.520</td>\n",
       "      <td>370</td>\n",
       "      <td>46.047798</td>\n",
       "      <td>6.034378</td>\n",
       "      <td>4480.560059</td>\n",
       "      <td>4381.500000</td>\n",
       "      <td>2</td>\n",
       "      <td>131</td>\n",
       "      <td>1.502574e+09</td>\n",
       "      <td>...</td>\n",
       "      <td>0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>5 rows x 26 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "     id  timeAtServer  aircraft   latitude  longitude  baroAltitude  \\\n",
       "0    94         0.026      2308  51.082375   6.524734   1325.880005   \n",
       "1   218         0.074       997  53.004227   5.781860  12192.000000   \n",
       "2   666         0.332      1633  45.037125   9.333801   2118.360107   \n",
       "3   886         0.455      2625  48.395100  10.262459  10988.040039   \n",
       "4  1000         0.520       370  46.047798   6.034378   4480.560059   \n",
       "\n",
       "    geoAltitude  numMeasurements  sensor_0         tmp_0  ...  RSSI_2  \\\n",
       "0   1264.920044                4       134  1.005387e+09  ...     170   \n",
       "1  12092.940430                4       170  2.078536e+10  ...      19   \n",
       "2   2042.160034                2       132  1.314392e+09  ...       0   \n",
       "3  10858.500000               10       141  1.435665e+09  ...     148   \n",
       "4   4381.500000                2       131  1.502574e+09  ...       0   \n",
       "\n",
       "   sensor_3         tmp_3  RSSI_3  sensor_4         tmp_4  RSSI_4  sensor_5  \\\n",
       "0     670.0  1.005362e+09      62       NaN           NaN       0       NaN   \n",
       "1     704.0  7.726590e+10      10       NaN           NaN       0       NaN   \n",
       "2       NaN           NaN       0       NaN           NaN       0       NaN   \n",
       "3     257.0  1.435786e+09      55     263.0  1.435661e+09      67     388.0   \n",
       "4       NaN           NaN       0       NaN           NaN       0       NaN   \n",
       "\n",
       "          tmp_5  RSSI_5  \n",
       "0           NaN       0  \n",
       "1           NaN       0  \n",
       "2           NaN       0  \n",
       "3  7.471172e+10      23  \n",
       "4           NaN       0  \n",
       "\n",
       "[5 rows x 26 columns]"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "flights.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we will join the aforementioned dataframes, so that we will have all the sensors coordinates together with the flights' data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in range(max_measurements):\n",
    "    flights = flights.join(sensors.loc[:, ['latitude', 'longitude', 'height']], on='sensor_{}'.format(i),\n",
    "                           rsuffix='_{}'.format(i))\n",
    "    \n",
    "flights.rename({'height': 'height_0'}, axis=1, inplace=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "types_coords = {}\n",
    "\n",
    "for i in range(max_measurements):\n",
    "    types_coords['latitude_{}'.format(i)] = 'float32'\n",
    "    types_coords['longitude_{}'.format(i)] = 'float32'\n",
    "    types_coords['height_{}'.format(i)] = 'float32'\n",
    "    \n",
    "flights = flights.astype(types_coords, errors='ignore')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "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>sensor_0</th>\n",
       "      <th>sensor_1</th>\n",
       "      <th>tmp_0</th>\n",
       "      <th>tmp_1</th>\n",
       "      <th>latitude_0</th>\n",
       "      <th>longitude_0</th>\n",
       "      <th>latitude_1</th>\n",
       "      <th>longitude_1</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>134</td>\n",
       "      <td>248</td>\n",
       "      <td>1.005387e+09</td>\n",
       "      <td>-2.687226e+08</td>\n",
       "      <td>50.937080</td>\n",
       "      <td>7.353797</td>\n",
       "      <td>51.228470</td>\n",
       "      <td>6.679641</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>170</td>\n",
       "      <td>507</td>\n",
       "      <td>2.078536e+10</td>\n",
       "      <td>5.762634e+10</td>\n",
       "      <td>52.532749</td>\n",
       "      <td>7.309251</td>\n",
       "      <td>53.062771</td>\n",
       "      <td>6.076188</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>132</td>\n",
       "      <td>277</td>\n",
       "      <td>1.314392e+09</td>\n",
       "      <td>6.080994e+10</td>\n",
       "      <td>45.556053</td>\n",
       "      <td>10.225396</td>\n",
       "      <td>45.976501</td>\n",
       "      <td>8.945900</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>141</td>\n",
       "      <td>143</td>\n",
       "      <td>1.435665e+09</td>\n",
       "      <td>1.435638e+09</td>\n",
       "      <td>47.511948</td>\n",
       "      <td>10.280076</td>\n",
       "      <td>48.365822</td>\n",
       "      <td>11.478391</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>131</td>\n",
       "      <td>665</td>\n",
       "      <td>1.502574e+09</td>\n",
       "      <td>4.419118e+10</td>\n",
       "      <td>46.479492</td>\n",
       "      <td>6.837746</td>\n",
       "      <td>45.741699</td>\n",
       "      <td>4.821200</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>184</td>\n",
       "      <td>216</td>\n",
       "      <td>4.861520e+09</td>\n",
       "      <td>1.465412e+09</td>\n",
       "      <td>52.990002</td>\n",
       "      <td>-0.411000</td>\n",
       "      <td>51.872524</td>\n",
       "      <td>-0.506857</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>26</td>\n",
       "      <td>236</td>\n",
       "      <td>2.082609e+10</td>\n",
       "      <td>2.115585e+10</td>\n",
       "      <td>48.996437</td>\n",
       "      <td>14.392090</td>\n",
       "      <td>51.062847</td>\n",
       "      <td>13.674202</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7</th>\n",
       "      <td>184</td>\n",
       "      <td>185</td>\n",
       "      <td>4.916274e+09</td>\n",
       "      <td>8.116518e+08</td>\n",
       "      <td>52.990002</td>\n",
       "      <td>-0.411000</td>\n",
       "      <td>51.759014</td>\n",
       "      <td>-1.256688</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>8</th>\n",
       "      <td>513</td>\n",
       "      <td>564</td>\n",
       "      <td>8.271333e+10</td>\n",
       "      <td>1.571339e+09</td>\n",
       "      <td>39.276299</td>\n",
       "      <td>-7.590500</td>\n",
       "      <td>39.231777</td>\n",
       "      <td>-9.308084</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>9</th>\n",
       "      <td>10</td>\n",
       "      <td>14</td>\n",
       "      <td>1.643685e+09</td>\n",
       "      <td>1.643671e+09</td>\n",
       "      <td>47.400169</td>\n",
       "      <td>8.630680</td>\n",
       "      <td>47.248295</td>\n",
       "      <td>8.529757</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>10</th>\n",
       "      <td>150</td>\n",
       "      <td>434</td>\n",
       "      <td>1.755763e+09</td>\n",
       "      <td>2.487414e+10</td>\n",
       "      <td>43.571663</td>\n",
       "      <td>1.471375</td>\n",
       "      <td>43.339207</td>\n",
       "      <td>2.813991</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "    sensor_0  sensor_1         tmp_0         tmp_1  latitude_0  longitude_0  \\\n",
       "0        134       248  1.005387e+09 -2.687226e+08   50.937080     7.353797   \n",
       "1        170       507  2.078536e+10  5.762634e+10   52.532749     7.309251   \n",
       "2        132       277  1.314392e+09  6.080994e+10   45.556053    10.225396   \n",
       "3        141       143  1.435665e+09  1.435638e+09   47.511948    10.280076   \n",
       "4        131       665  1.502574e+09  4.419118e+10   46.479492     6.837746   \n",
       "5        184       216  4.861520e+09  1.465412e+09   52.990002    -0.411000   \n",
       "6         26       236  2.082609e+10  2.115585e+10   48.996437    14.392090   \n",
       "7        184       185  4.916274e+09  8.116518e+08   52.990002    -0.411000   \n",
       "8        513       564  8.271333e+10  1.571339e+09   39.276299    -7.590500   \n",
       "9         10        14  1.643685e+09  1.643671e+09   47.400169     8.630680   \n",
       "10       150       434  1.755763e+09  2.487414e+10   43.571663     1.471375   \n",
       "\n",
       "    latitude_1  longitude_1  \n",
       "0    51.228470     6.679641  \n",
       "1    53.062771     6.076188  \n",
       "2    45.976501     8.945900  \n",
       "3    48.365822    11.478391  \n",
       "4    45.741699     4.821200  \n",
       "5    51.872524    -0.506857  \n",
       "6    51.062847    13.674202  \n",
       "7    51.759014    -1.256688  \n",
       "8    39.231777    -9.308084  \n",
       "9    47.248295     8.529757  \n",
       "10   43.339207     2.813991  "
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "flights.loc[:10, ['sensor_0', 'sensor_1', 'tmp_0', 'tmp_1', 'latitude_0', 'longitude_0', 'latitude_1', 'longitude_1']]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The following code performs the timestamp synchronization and calculates the corrections. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|███████████████████████████████████████████████████████████████████████████████████| 5/5 [38:49<00:00, 465.85s/it]\n"
     ]
    }
   ],
   "source": [
    "for i in tqdm(range(1, max_measurements)):\n",
    "    dist_aircraft_t1 = flights.apply(lambda x: calculateDist(x['latitude'], x['longitude'], x['geoAltitude'], \\\n",
    "                                                                x['latitude_0'.format(i)], \n",
    "                                                                x['longitude_0'.format(i)], \n",
    "                                                                x['height_0'.format(i)],), axis=1)\n",
    "    \n",
    "    dist_aircraft_t2 = flights.apply(lambda x: calculateDist(x['latitude'], x['longitude'], x['geoAltitude'], \\\n",
    "                                                                x['latitude_{}'.format(i)], \n",
    "                                                                x['longitude_{}'.format(i)], \n",
    "                                                                x['height_{}'.format(i)],), axis=1)\n",
    "    \n",
    "    # Time of message reception at t2 receiver according to t1 clock (ns)\n",
    "    t2_corr = flights.tmp_0 - (dist_aircraft_t1[0]/29979e-8) + (dist_aircraft_t2[0]/29979e-8) \n",
    "    \n",
    "    # Correction applied to each time message reception at t2 receiver (ns)\n",
    "    correction = flights['tmp_{}'.format(i)] - t2_corr\n",
    "    \n",
    "    flights['tmp_{}'.format(i)] = t2_corr\n",
    "    \n",
    "    flights['corr_{}'.format(i)] = correction\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Below we will plot calculated corrections for chosen sensor pairs. We will also fit the linear regression line into the data to depict how well this method represents the relationship between correction and timeAtServer for each sensor pair."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAA1gAAALICAYAAABijlFfAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/d3fzzAAAACXBIWXMAAAsTAAALEwEAmpwYAACsdklEQVR4nOzdeXxU1f3/8dcnIeyLsmjRsKkoyCriiiKKBUXFpVhF61q3umvVovZbl2q1av25S7EKdQGrKIprkYqiuIIiu4oYJYLKogIiS5LP7497M0zCTDLJTGYmyfv5eMwjc+89997PvZmZM597zj1j7o6IiIiIiIgkLyfTAYiIiIiIiNQVSrBERERERERSRAmWiIiIiIhIiijBEhERERERSRElWCIiIiIiIimiBEtERERERCRFlGBJrWJmHc1snZnl1sC2B5jZ5+H2j0n19iWzzGyQmRVmOg4RqR9UX0l1qb6q/ZRgCQBmdpKZzQw/rJeb2StmdkAWxFVgZoeWTrv71+7e3N2La2B3NwL3hdt/rga2XyeY2RFm9raZ/Whm35rZQ2bWIka51ma2wszeLjf/EDP7yMzWmNkSMzsnfdHHZ2bTwnjXmNknZnZ0ueXtzGx8eNw/mNkT5ZYfGh7Xz2a21Mx+m94jEKkfVF8Bqq8SUll9ZWaNzOyR8HP/WzO7PGrZgeFrLPrhZvabzBzN1szsoDCmm6LmVXbM48xsU7njSvlFgPpOCZYQfqDcBfwN2B7oCDwAHF3BavG21SCReVmqEzC/OivWomMEIMkP01bATcAOQHcgH7g9Rrm/AwvL7TcPmAT8M9zOCcCdZtYniXhS5RKgvbu3BM4BHjez9lHLnwW+JXidbAfcUbrAzHYHxgPXEhxXX2BWesIWqT9UX0WovkpMZfXV9UBXgvN5MHCVmR0G4O5vhQlsc3dvDhwJrANeTSKelAnr07uB98stSqSOvi362GroIkD95u561OMHwRtxHXB8BWUaEVRoy8LHXUCjcNkgoBD4E8GXz8cIPrAmAo8Da4Czwv08DCwHviF48+dG7eNsgi/ja4EFQL9wWyXAL2GMVwGdAQcahOvtAEwGVgOLgbOjtnk98BTwaLjd+UD/OMf4Rbl9NUpg22WOMcY2h4XHsjY85iuilh0JzAZ+BN4BekctKwCuAOYAPwH/ARqHy9oCL4brrQbeAnLCZd2BN8Jl84HhUdscBzwIvAz8DBxaUXxVfA0dB8wtN28/4F3gDODtqPnbh/+/plHzPgRGxtn2EcDH4TleClwftaz0tXAa8DWwErg2anmT8Lh/CI/zSqAwwWPaG9gA7B1ODwn/L7lxyo8H/prp97MeetTlB6qvSsuqvkpRfRVua0jU9F+BJ+OsOxYYW8G201pfAaOA28L1bqrCMVdYXo/UPDIegB4ZfgHAYUARYQUQp8yNwHsEV+3bhR+wfw2XDQrX/3v4Id8k/DDfDBxD0EraBHiOoNWiWbidD4Bzw20cH37I7QUYsAvQKVxWABwaFUvph1RphfUmwdXLxgStBiuAweGy6wm+JA8DcoFbgPcqOM7y+6ps22WOMcb2lgMHhs+3BfqFz/sB3wP7hHGdFu67UVQcHxBUmK0JKvLzwmW3AKOBvPBxYHjO8ggq1WuAhsAhBBXRbuF64wgqvwFhvI3jxRdO/wgckOBr6C6iKqTwmD4C9gROJyrBCpePBy4Iy+0XnosOcbY9COgVxtwb+A44ptxr4SGC11gfYCPQPVx+K0GF3hroAMyj8grrxfA14wRXKUu/DPwF+C/BF5RVBEnhQVHrLSGomOeG5/VxoHWm39966FGXHqi+ij7O8vtSfZXYa+guwvoq3I4D20ctH0G5C4bh/KZhjIMq2PYg0lRfEbS4fQY0p/IEK3LMUed3dfiYBfwm0+/tuvjIeAApPyB4JPwwmJdg+d8SXC2YD4yvwn4eBj4huGozEWgeo0yn8MU7O9z+eVHLngA+Dd9EjwB54fwrw/Kzw2XFVPJFDbiZ4GrJunLzGxFcTVpM0ITcOca6JwPfVrL9L4BhUdNDgYLw+SBgE+EVq3De9cD0qOntww+SJlHzRgLTwuf/BS6Js+8C4lRY4YdQMdAiavktwLioOKZGLdsd+KWC44zsK8FtT4+3rbDM18C5QMty8x+kXGtH+Fo4KCqO30Utuw0YHT6/EXge2KXc+gcSXJHNiZo3gfAKGsEH6qOJxFfF99uvCa647Ro17zLgwfD56WydYB1FUPEUhY+zq7C/u4D/V+61kB+1/APgxPD5EuCwqGXnkEALFkHlfzhwWdS8MeG+fh8uP5GgUm8bLt8U/t92JajwngGeqO551aPuP6hCXQUMJLhoUQSMKLfsNODz8HFapo+rhs+Z6qsY+0pw26qvytVX4Xnzcq+HX5e+XsqtewrwJWBV2N9d1FB9FZ7XE6LOV8wEq/wxh/P6AW3C1+UwgsRxQHXPqx6xH3XxHqxxBFe5KmVmXYGrCV5YPYBLY5Q53cyuj7H6Ze7ex917E7zxL4xRZjmwv7v3Jbj6M8rMdgiXPQF0I7ja0YSgWwLufru79w3XuRp4091XV3IoLxB0aSrv98AP7r4L8P8IrtqVtwpoW0mf7B2Ar6KmvwrnlVrh7hvKrbM06nkngi+ly8ObLn8kuDq4Xbi8A0GlWFU7AKvdfW252HaMmv426vl6oHGC/c8T2fZSKvYbgg+vr8zsTTPbL5zfCfhj6bkIz0cHyp7T8nE3D5/fTpAwTwkHiBgVFe9Sdy+pQrzx4kuIme1L0Bo1wt0/C+ftAFxMcC9SrHW6EST9pxJcuexB0Of9iDjl94kafOIn4DyCbifR4p2rHSh7zNGv4bjcfbO7vwIMNbPh4exfCCrdh8PlT4bbHhC1fKy7f+bu6wjuDxmWyP6k3hpHgnUVQR1zOsH7LcLMWgPXEdQvewPXmdm2qQsx66i+qv62VV+Vq68IulcCtIwq2pIg4SjvNIKkzyvYR1rqKzM7iiCZ/k+8MmG5WMeMu3/k7qvcvcjdXyb4PnpcRduSqqtzCZa7Tydo9owws53N7FUzm2Vmb4Vf8iDoR32/u/8Qrvt9FfazJty2ESRIW73p3H2Tu28MJxsRdb7d/WUPEVzFyI+xm5EEV3VKj+N3ZvaBmc02s3+W3vjp7u+5+/IY6x8N/Dt8PhEYHMYb7V2CbgnHVHC4ywg+ZEt1DOdFDifGOtHzlhJcEWzr7tuEj5ZhUlu6fOc4+477YRbG0NrKjmDXkaD7RrIS2XZFseHuH7r70QQV83ME/eshON6bo87FNu7e1N0nxNtW1DbXuvsf3X0ngpagy81scBhvBzOLfk9XGG8F8VXKzPYg6O9/prv/L2rR3kB7YIGZfUtwA+7e4UhGuUBP4FN3/6+7l7j7p8BLBC1GsYwP99PB3VsRdDcp/xqOZznBF4FSHRNcr1QDtrwu51Dx/7uy5SJlVKWucvcCd59DcN9NtKHAa+6+OqzHXiPxpK02Un1V/W2rvipXX4XvmeUE3fVK9aHc4CFm1oGg9fPRSnaVrvpqMNA/rFe/JRgs6lIzez4q5nh1dCxehTglQXUuwYpjDHCRu+9JcDPmA+H8XYFdzWyGmb1XOnJMosxsLMHViG7AvXHKdDCzOQQfUn9392XllucRND2/Wm5+U4KK8plwujvBm2hA2LpVTNBdoiI7hvvF3YsI+jS3iS7g7j8R3F9yv5kdY2ZNzSzPzA43s9vCYhOAP1swTHXbsPzjlew7eh/LgSnAP8yspZnlhF8kDgqL/Au4wsz2tMAuZlZaQX4H7BRnu0sJ+tffYmaNzaw3QavdE7HKV0Wy2zazhmZ2spm1cvfNBDe9lo7S8xBwXni1y8ysmQXDqm411HmM7R4Znh+L2mYxQRfQnwlag/LMbBBBhfZkNeKrLIaeBK/Xi9z9hXKLXyHoCtE3fPyF4Kbfvh6MUvQx0NWCodrNzHYmuIH6kzi7a0FwZXaDme0NnJRIjKGngKvNbFszywcuquCYuoWv+Sbh+fsdQbesN8Mik4Btzew0M8s1sxEE768Z4fKxwBlmtlP43v0Twf1cIlURr66KJ/IZHyqkbCtAnaL6Km7Mqq/ix1BRfQVB0vTnsJ7oRnDhfVy5MqcA77h7ZS2XaamvgP8j+P7aN3xMJvg/nQGVH7OZjTCz5uFrewjwu3AbkkJ1PsEys+bA/sDTZjaboKm/dOjlBgTDcw4iaC36l5ltY2ZtLGglmk3Qh/i80mkz61W6bXc/g6BZdyFB8rMVd18adiPcBTjNzLYvV+QBgr7Rb5WbfxQwI6p74GCCQQM+DOMaTJwP8ujDjxVSjBjvBC4H/kxwY+xSgi6Pz4VFbgJmElyln0twL8BN5bdTidIuYQsI+gNPJPw/uPvTBPeRjSdomn+O4EZPCPqR/9mCrglXxNjuSIIv9MsIvgRf5+6vVTG2eJLd9ilAgZmtIegq8DsAd59J8CF+H8G5WEzQ/ScRXYGpBF0b3gUecPc33H0TMJygJWglwevqVHdfVNX4ACz4XYwD46z3R4Kbxx+2Lb+hMT88to3u/m3pgyCp3xw+J6ygzgTuIagk3yS4iPBwnH2dD9xoZmsJviglfNUSuIGgm8WXBF+YHqugrBHcp/A9wXvgEoL+7R+Fca8mOL9XhMc0Cjja3VeGyx8hqKjfD/e5kaCrpEhCKqmr4q4WY16dbklVfRWX6qvY4tZXoesIunx+RVAf3e7u5YdhP5UtvYEqkpb6KmwZjK5nfwF+jvq+WNkxX0LQWvgjQTfOs939jSrEKgkwj9+dtNYys87Ai+7e08xaEnRJ2qqiMrPRBKP0jAun/weMcvcPo8qcTjA4xPUV7O8g4Ep3P7KSuMYCL7n7xHD6OmAP4Dgv2xcZM5sEPO3u48Ppi4Ad3P3qCra/zoPfaiid/i/BTaPvWtCP+1ugndfFf7qISC2TaF0VVX5cWL60DhlJMKrZueH0P4E3Eum+JSIiNafOt2B5cK/Ul2Z2PAT3TNmWHzV9juCH5Qi7EuxKMJJLhUq7BZQ+J2ht2urKi5nlm1mT8Pm2BDfEfxpOn0XQf35kjOSqFXAQwSgxpf4HjDCz7cIyraO6JcQzmeDGTAiGHn1dyZWISPappK6K57/AkLBb0bYEv9f23xoOVUREKlHnEiwzm0DQFL2bmRWa2e8J7lX6vZl9QnDz4tFh8f8Cq8xsATCNoBVqVSK7Af5tZnMJuiC0J+hKiJn1N7N/heW6A++H+30TuMPd54bLRhMMB/tu2PXwL1HbPxaY4u4/l85w9wUEXSKmWHBP12vhfjGz28ysEGgaHvP14WoPA23MbDFBl4pRiIhIxlWlrjKzvcLP+OOBf0Z1yV1N8PtrH4aPG73yUWdFRKSG1ckugiIiIiIiIplQ51qwREREREREMiWRH7CrNdq2beudO3fOdBgiIpKEWbNmrXT3dpmOo6aorhIRqRvi1Vd1KsHq3LkzM2fOzHQYIiKSBDP7KtMx1CTVVSIidUO8+kpdBEVERERERFJECZaIiIiIiEiKKMESERERERFJkTp1D1YsmzdvprCwkA0bNmQ6FKkhjRs3Jj8/n7y8vEyHIiIiIvWIvmfWD1X9rlnnE6zCwkJatGhB586dMbNMhyMp5u6sWrWKwsJCunTpkulwREREpB7R98y6rzrfNet8F8ENGzbQpk0bvejrKDOjTZs2unIkIiIiaafvmXVfdb5r1vkEC9CLvo7T/1dEREQyRd9D6r6q/o/rRYIlIiIiIiKSDkqw0qB58+ZbzRs9ejSPPvpoBqLJLsOGDePHH3/MdBgiIiIitZK+Z8aXqe+ZdX6Qi2x13nnn1ej23R13Jycndg5dXFxMbm5utbdfVFREgwbJv3xefvnlpLchIiIiIlvoe2YgU98z1YKVIddffz133HEHAIMGDeJPf/oTe++9N7vuuitvvfUWELw4r7zySvbaay969+7NP//5TwDWrVvH4MGD6devH7169eL5558HoKCggO7du3P++efTr18/li5dWmafnTt35sYbb+SAAw7g6aefZsqUKey3337069eP448/nnXr1gHBi7Fbt24ccMABXHzxxRx55JGRmM855xyGDBnCqaeeyooVK/jNb37DXnvtxV577cWMGTMAePPNN+nbty99+/Zljz32YO3atSxfvpyBAwfSt29fevbsGTnGzp07s3LlSgDuvPNOevbsSc+ePbnrrrvKHNPZZ59Njx49GDJkCL/88ktN/VtEpLpe6A7jbctDRLJD4WT48MLgr9Qb+p6Z2e+Z9aoF64YX5rNg2ZqUbnP3HVpy3VE9kt5OUVERH3zwAS+//DI33HADU6dO5eGHH6ZVq1Z8+OGHbNy4kQEDBjBkyBA6dOjApEmTaNmyJStXrmTfffdl+PDhAHz66aeMHTuWBx54IOZ+GjduzNtvv83KlSs57rjjmDp1Ks2aNePvf/87d955J1dddRXnnnsu06dPp0uXLowcObLM+rNmzeLtt9+mSZMmnHTSSVx22WUccMABfP311wwdOpSFCxdyxx13cP/99zNgwADWrVtH48aNGTNmDEOHDuXaa6+luLiY9evXb7XdsWPH8v777+Pu7LPPPhx00EFsu+22fP7550yYMIGHHnqI3/72tzzzzDP87ne/S/qci0iKjM8BvNw8g5M8ZnERSZPCyTBjJBSvhyVjYcAEyB+e6ajqLH3P1PfMUvUqwcpmxx13HAB77rknBQUFAEyZMoU5c+YwceJEAH766Sc+//xz8vPzueaaa5g+fTo5OTl88803fPfddwB06tSJfffdN+5+TjjhBADee+89FixYwIABAwDYtGkT++23H4sWLWKnnXaKjPM/cuRIxowZE1l/+PDhNGnSBICpU6eyYMGCyLI1a9awdu1aBgwYwOWXX87JJ5/McccdR35+PnvttRdnnnkmmzdv5phjjqFv375l4nr77bc59thjadasWeR8vPXWWwwfPpwuXbpEykefHxHJAmqtEsley6cEyRUEf5dPUYJVT+l7Znq/Z9arBCsVVwBqSqNGjQDIzc2lqKgICPq33nvvvQwdOrRM2XHjxrFixQpmzZpFXl4enTt3jozNX/rCiad0ubvz61//mgkTJpRZ/vHHHye0PkBJSQnvvvtu5I1QatSoURxxxBG8/PLL7LvvvkydOpWBAwcyffp0XnrpJU455RSuvPJKTj311Mg67vGvdJeeGwjOj7oIimQJJVci2a39kKDlqng95DYNpqXG6HumvmeW0j1YWWzo0KE8+OCDbN68GYDPPvuMn3/+mZ9++ontttuOvLw8pk2bxldffVXlbe+7777MmDGDxYsXA7B+/Xo+++wzunXrxpIlSyLZ+3/+85+42xgyZAj33XdfZHr27NkAfPHFF/Tq1Ys//elP9O/fn0WLFvHVV1+x3XbbcfbZZ/P73/+ejz76qMy2Bg4cyHPPPcf69ev5+eefmTRpEgceeGCVj0tE0qSy5ErdA0UyL3940C2w6wXqHihb0ffMmvueWa9asDJl/fr15OfnR6Yvv/zyhNY766yzKCgooF+/frg77dq147nnnuPkk0/mqKOOon///vTt25du3bpVOaZ27doxbtw4Ro4cycaNGwG46aab2HXXXXnggQc47LDDaNu2LXvvvXfcbdxzzz1ccMEF9O7dm6KiIgYOHMjo0aO56667mDZtGrm5uey+++4cfvjhPPnkk9x+++3k5eXRvHnzrYYO7devH6effnpkf2eddRZ77LGHugOKZJsJDcE3V1xGyZVI9sgfrsSqjtP3zOz7nmkVNZnVNv379/eZM2eWmbdw4UK6d++eoYhqp3Xr1tG8eXPcnQsuuICuXbty2WWXZTqsCun/LJIGiXQJTEFyZWaz3L1/0hvKUrHqKhGpnfT9o+pq4/dMiP2/jldfqYugbOWhhx6ib9++9OjRg59++olzzz030yGJSKalKbkSEZG6rT58z1QXQdnKZZddViuuJIhImlSWXDVsDSNW8f3aDRQVOzts06Ti8iIiUm/Vh++ZSrBERCS+BAezuO3VRTzwxhds2zSPj/+ikcpERKT+UoIlIiJbe+t4WDqx4jInOUXFJexy7SuRWbeN6FPDgYmIiGQ3JVgiIlJWgvdbLVi2hmH3vBWZ9eG1h9KuRaMKVhIREan7lGCJiMgWCSZXN7+0gIfe+jIy68tbhmGmHx4WERHRKIJ11I8//sgDDzwQmV62bBkjRozIYEQikvUSGcziJKfzqJciydXQHttTcOsRSq5EROoZfdeMTwlWlioqKqpwujLlX/Q77LADEydWcj+FiNRflSVXA59n9eHL6Tzqpcisx3+/D/88pc7+XJWISJ2m75o1R10E0+DRRx/ljjvuwMzo3bs3N910E2eeeSYrVqygXbt2jB07lo4dO3L66afTunVrPv74Y/r168eqVavKTJ9//vlccMEFrFixgqZNm/LQQw/RrVs3vvvuO8477zyWLFkCwIMPPsg999zDF198Qd++ffn1r3/NBRdcwJFHHsm8efPYsGEDf/jDH5g5cyYNGjTgzjvv5OCDD2bcuHFMnjyZ9evX88UXX3Dsscdy2223ZfjsiUiNeqE7rF1UcZmTnOdnf8Ml970WmbXgxqE0bagqREQkG+i7ZnZR7RhL4WRYPgXaD4H84Ultav78+dx8883MmDGDtm3bsnr1ak477TROPfVUTjvtNB555BEuvvhinnvuOQA+++wzpk6dSm5uLqeffnqZ6cGDBzN69Gi6du3K+++/z/nnn8/rr7/OxRdfzEEHHcSkSZMoLi5m3bp13HrrrcybN4/Zs2cDUFBQEInp/vvvB2Du3LksWrSIIUOG8NlnnwEwe/ZsPv74Yxo1asRuu+3GRRddRIcOHZI6ByKSpRK83+rwu99i4fI1ADRv1IB5Nwyt4cBEROqwFH7PBH3XzEZKsMornAwzRkLxelgyFgZMSOrF//rrrzNixAjatm0LQOvWrXn33Xd59tlnATjllFO46qqrIuWPP/54cnNzt5pet24d77zzDscff3xk2caNGyP7ePTRRwHIzc2lVatW/PDDD3Fjevvtt7nooosA6NatG506dYq86AcPHkyrVq0A2H333fnqq6/q3IteREgoudp8QjFdo7oE/t+Ru/P7A7rUZFQZY2YFwFqgGChy9/7llm8LPALsDGwAznT3eeGybYB/AT0BD5e9m7bgRaT2SPH3TNB3zWykBKu85VOCFz0Ef5dPSeqF7+6V3vwdvbxZs2ZllpVOl5SUsM0220SuEiTD3eMua9RoyxDLubm5Ve6PKyK1QGXJVYPmzBtQyJFRv2/11lUH06F10xoOLOMOdveVcZZdA8x292PNrBtwPzA4XHY38Kq7jzCzhkCdP1EiUk0p/p4J+q6ZjTTIRXnth0BuWDfmNg2mkzB48GCeeuopVq1aBcDq1avZf//9efLJJwF44oknOOCAAyrdTsuWLenSpQtPP/00ELxwP/nkk8g+HnzwQQCKi4tZs2YNLVq0YO3atTG3NXDgQJ544gkgaCb++uuv2W233ZI6ThGpJSpLrk5yrm/8Hkfe+3Zk1pe3DKsPyVVldgf+B+Dui4DOZra9mbUEBgIPh8s2ufuPGYtSRLJbir9ngr5rZiMlWOXlDw+aa7tekJJm2x49enDttddy0EEH0adPHy6//HLuuecexo4dS+/evXnssce4++67E9rWE088wcMPP0yfPn3o0aMHzz//PAB3330306ZNo1evXuy5557Mnz+fNm3aMGDAAHr27MmVV15ZZjvnn38+xcXF9OrVixNOOIFx48aVuZogInXQxDYJJVedR73EuHcKADiyd/v6NAS7A1PMbJaZnRNj+SfAcQBmtjfQCcgHdgJWAGPN7GMz+5eZNSu/spmdY2YzzWzmihUrau4oRCS7pfh7Jui7Zjayiprwapv+/fv7zJkzy8xbuHAh3bt3z1BEki76P4tUIIH7rVYO30D/m6ZGpiecvS/77dymJqOKy8xmlb8HKg373MHdl5nZdsBrwEXuPj1qeUuCroB7AHOBbsBZQB7wHjDA3d83s7uBNe7+f/H2FauuEpHaSd8/6o9Y/+t49ZXuwRIRqcsSSK6e7baUy6OSq4U3HkaThrkVrFH3uPuy8O/3ZjYJ2BuYHrV8DXAGgAVNel+Gj6ZAobu/HxadCIxKY+giIpJl1EVQRKSuSiC5OvTbN7j8qaCPfetmDSm49Yh6l1yZWTMza1H6HBgCzCtXZptwAAsIWq6mu/sad/8WWGpmpTcXDAYWpCl0ERHJQvWiBSuR0VWk9qpL3VxFUqaS5GrTjr9l11dOBdYBcMPwHpy2f+eajys7bQ9MCuuJBsB4d3/VzM4DcPfRQHfgUTMrJkigfh+1/kXAE2ECtoSwpUtE6gd9z6z7qvpds84nWI0bN2bVqlW0adNGL/46yN1ZtWoVjRs3znQoItnhk2th/t8qLnLgDxx9/4zI9IxRh7DjNk1qOrKs5e5LgD4x5o+Oev4u0DXO+rOBtN4zJiLZQd8z677qfNes8wlWfn4+hYWFaNSmuqtx48bk5+dnOgyRzJvQEHxzhUX+3HQOj0clV1/eMkxfCkREqknfM+uHqn7XrPMJVl5eHl26dMl0GCIiNSuB+606z3kR+BqAY/fYkf93Qt+ajUlEpI7T90yJpc4nWCIidV4lydX3m7dh74WPR6afOnc/9u7SuqajEhERqZeUYImI1GaVJFdP/TCMq5aeH5le9NfDaJxXv0YJFBERSae0D9NuZh3MbJqZLTSz+WZ2SYwyZmb3mNliM5tjZv3SHaeISFYrnFxpcjXom9cjydWvWjam4NYjlFyJiIjUsEy0YBUBf3T3j8LfHZllZq+5e/TvhhxOMFpTV2Af4MHwr4iIPNUCitbFXbyxpAG7zXsOWA/Azcf25OR9OqUnNhERkXou7QmWuy8HlofP15rZQmBHyv4w49HAox4MOv9e+AOP7cN1RUTqr0parT76eTeO++Ifken3rh7Mr1rpZwxERETSJaP3YJlZZ2AP4P1yi3YElkZNF4bztkqwzOwc4ByAjh071kicIiJZoZLkalThJTy5+teRaQ3BLiIikn4ZS7DMrDnwDHCpu68pvzjGKjF/QtndxwBjAPr371+1n1kWEaktKkiu3KHL3Bcj07/tn89tI7b63VwRERFJg4wkWGaWR5BcPeHuz8YoUgh0iJrOB5alIzYRkaxTQXL13ebW7LPw0cj0M3/Ynz07bZuOqERERCSGTIwiaMDDwEJ3vzNOscnAqeFogvsCP+n+KxGpd946vsLkavyqoWWSq09vOkzJlYiISIZlogVrAHAKMNfMZofzrgE6Arj7aOBlYBiwmGAYrDPSH6aISAZNaAi+Oe7i/Rc+wrLN2wHQoXUT3rrqkHRFJiIiIhXIxCiCbxP7HqvoMg5ckJ6IRESyTAWtVhtK8ug2b1Jk+u+/6cUJe2mAHxERkWyR0VEERUSknAqSqw9/3p3jv7gtMv3BNYPZrqWGYBcREckmSrBERLJFBcnVH5deyjM/HBqZLrj1iHREJCIiIlWkBEtEJBvESa7KD8F+8j4dufnYXumKSkRERKpICZaISKbFSa6WbWrL/ovGRaafu2AAfTtsk56YREREpFrSPky7iIiEPrk2bnL12MphZZKrz246XMmViIhILaAWLBGRTJjYBjatjrmo/4LHWFkU/J7VTu2a8fofB6UxMBEREUmGEiwRkXSL02q1oaQh3eY9G5m+4/g+jNgzP11RiYiISAoowRIRSac4ydV763py4pJbI9MfXnso7Vo0SldUIiIikiJKsERE0iVOcnXx11cw+cdBkWkNwS4iIlJ7KcESEUmHGMlV+SHYT9uvEzcc3TOdUYmIiEiKKcESEalpMZKrwk3tOGDR2Mj0CxceQK/8VumMSkRERGqAEiwRkZoUI7kau/Ioblh2bmT685sPJy9Xv5ohIiJSFyjBEhGpKTGSq97zn2RNcXMAuv2qBa9eOjDdUYmIiEgNUoIlIpJqL3SHtYvKzPqlpBHd5z0Tmb7rhL4cs8eO6Y5MREREapgSLBGRVBqfC5SUmTVjbR9O/vLmyPSsPx9Km+Yagl1ERKQuUoIlIpIqMboE/uGrq3nlpwGRaQ3BLiIiUrcpwRIRSYVyyVX5IdjP6jKPP5/7p3RHJSIiImmmBEtEJFnlkqulm7bnwEUPR6ZfuvgAeuyglisREZH6QAmWiEgyyiVXD604lpuX/z4yvfjmw2mgIdhFRETqDSVYIiLVVS656jZ3Ihu8MQC9mnzOC9ddmoGgREREJJOUYImIVEdUcvVzcWN6zJ8Ymb6349856vzpmYhKREREMkwJlohIVUUlV9PX7sGpX/41Mv3x7iPZ9tQ1mYhKREREsoASLBGRqohKrs4q+DNT1+wbmS7ofSSc5JmISkRERLKEEiwRkURMGQAr3wG2HoL9vHZPM6r9v5VciYiIiBIsEZFKPdkESjYAULCxPYM+fSiy6NWuF9CtSaGSKxEREQGUYImIVGx8DhAkTw98P4Lbvj09smhxr+E0aLkrHFWUmdhEREQk6yjBEhGJJ+p+q53nPE8xuQDs2XQBz+xyFXQYAQc+nanoREREJAspwRIRiSVMrtYWN6HX/C1J1IOd/sbhrd6BHtdAn5szFZ2IiIhkKSVYIiLlhcnVtDX9OaPg+sjsT3Y/gVYNftb9ViIiIhKXEiwRkWhhcnXal9fz5tr+kdkFvY8Mnii5EhERkQoowRIRKTXeKHFjp7kvRGZdtN2T/PFXjwcTSq5ERESkEkqwREQAxhtLNu7AIZ+Oicx6bdc/0LXx0mBCyZWIiIgkQAmWiMh4497vTuAf350SmfVFr+HkWkkwoeRKREREEqQES0Tqt/FG5zkvRib3bTaHJ3e+ZstyJVciIiJSBdVOsMxsO2AAsAPwCzAPmOnuJSmKTUSkRq15rBm9529JrsZ0+itDWr2/pYCSq1pF9ZKIiGSDKidYZnYwMApoDXwMfA80Bo4BdjazicA/3H1NCuMUEUmpqaP34ayCpyLTn/Q4gVa5P28poOSq1lC9JCIi2aQ6LVjDgLPd/evyC8ysAXAk8GvgmSRjExGpESffdDMz1v0lMh0Zgr2UkqvaRvWSiIhkjSonWO5+ZQXLioDnkglIRKSmFJc4O1/zMtAXgMu2f5xLtn+ybCElV7WO6iUREckmOdVd0cwuMbOWFnjYzD4ysyEJrvuImX1vZvPiLG9lZi+Y2SdmNt/MzqhunCIiAIu/XxsmV4Gpu56n5KqOSaZeEhERSZVqJ1jAmWF/9iFAO+AM4NYE1x0HHFbB8guABe7eBxgE/MPMGlY/VBGpz+587TMOvXN6ZHpJr6PYpXFh2UJKruqCZOolERGRlEhmmHYL/w4Dxrr7J2ZmFa1Qyt2nm1nniooALcLtNQdWA0VJxCoi9VTnUS9Fnh/Y/CMe2+kvWxdSclVXVLteMrMCYC1QDBS5e/9yy7cFHgF2BjYQJHPzopbnAjOBb9y93E19IiJSnySTYM0ysylAF+BqM2sBpGoo3PuAycAyoAVwQrxhds3sHOAcgI4dO6Zo9yJS2/30y2b63DAlMv1I5+s5pOXMrQsquapLkq2XDnb3lXGWXQPMdvdjzawbcD8wOGr5JcBCoGU14hYRkTokmS6CvycYFncvd18PNCTojpEKQ4HZBL9l0he4z8xiVlruPsbd+7t7/3bt2qVo9yJSm706b3mZ5Gpuj+OVXNUPNVkv7Q78D8DdFwGdzWx7ADPLB44A/pWifYmISC1W7RYsdy8xs++A3cNhcFPpDOBWd3dgsZl9CXQDPkjxfkSkjjl+9Dt8WPBDZHqrIdhLKbmqc5KslxyYYmYO/NPdx5Rb/glwHPC2me0NdALyge+Au4CrCHpcxKTeFiIi9Ue1EyMz+ztwArCAoM86BBXU9LgrJe5rgq4Xb4VXCHcDlqRguyJSR20Zgj1w5a/+zQXbPb11QcuDkZvSGJmkS5L10gB3X2Zm2wGvmdkid49e71bgbjObDcwl+EHjIjM7Evje3WeZ2aB4Gw8TtjEA/fv3V3YvIlKHJdPydAywm7tvrOqKZjaBYHTAtmZWCFwH5AG4+2jgr8A4M5tLcNPynyroFy8i9dyn365l6F1bvgtP2+0cujRatnXBtvvDkBlpjEzS7BiqWS+5+7Lw7/dmNgnYm6jELByd8AyAcOCML8PHicBwMxsGNAZamtnj7v67JI9FRERqqWQSrCUESVF1KrKRlSxfRjDMrohIhW57dREPvPFFZHpJr6PIsRgNBOoSWB9Uq14ys2ZAjruvDZ8PAW4sV2YbYL27bwLOAqaHSdfV4YOwBesKJVciIvVbMgnWemC2mf2PqMrM3S9OOioRkQRED8F+SIsPeKTLjbELKrmqL6pbL20PTApHdG8AjHf3V83svHD90UB34FEzKybogvj7GohfRETqgGQSrMnhQ0QkrX5cv4m+N74Wmf53l79wUIuPYhdWclWfVKtecvclQJ8Y80dHPX8X6FrJdt4A3qjq/kVEpG5JZhTBf6cyEBGRRLw0ZzkXjN+STM3rcTzNc3+JXVjJVb2ieklERLJBlX8Hy8xeMLOjzCwvxrKdzOxGMzszNeGJiGxx9P0zIslVnm2moPeRSq5E9ZKIiGSV6rRgnQ1cDtxlZquBFQQjJ3UBFgP3ufvzqQtRROq7ouISdrn2lcj01b96hHO3ezb+Ckqu6hvVSyIikjWqnGC5+7cEP6h4lZl1BtoDvwCfufv61IYnIvXdgmVrGHbPW5Hp6bv9no6Nvou/gpKrekf1koiIZJNkBrnA3QuAgpREIiJSzt9eXsiY6Vt+Y/zLXkcSDPQWh5Krek/1koiIZFpSCZaISE2JHoJ9aMt3+Gfnv1W8gpIrERERyQJKsEQkq6z+eRP9/rplCPbHu1zLAS0+ib9CTmM4Mc5AFyIiIiJppgRLRLLG87O/4ZInZ0emF/T8DU1zNsZfQa1WIiIikmWqnWCZ2QDgeqBTuB0D3N13Sk1oIlKfHH73WyxcvgaAZg1zmd/t8IpXUHIl5aheEhGRbJBMC9bDwGXALKA4NeGISH2zubiErlFDsP95l9c4q+ndFa+k5EpiU70kIiIZl0yC9ZO7v1J5MRGR2OZ98xNH3vt2ZPqtbmfSoeH3Fa+k5EriU70kIiIZl0yCNc3MbgeeBSI3Sbj7R0lHJSJ13vWT5zPunYLIdKVDsIOSK6mM6iUREcm4ZBKsfcK//aPmOXBIEtsUkXogegj2I3q35372rGQNg5NKajYoqQtUL4mISMZVO8Fy94NTGYiI1H0r122k/01TI9Pjz96H/d9vV/FKA5+H/OE1HJnUBaqXREQkGyQzimAr4DpgYDjrTeBGd/8pFYGJSN3y7EeFXP7Ult+zWnjjYTSZWMlHkLoEShWoXhIRkWyQk8S6jwBrgd+GjzXA2FQEJSJ1y6F3vhlJrlo3a0hB/1OVXElNUL0kIiIZl8w9WDu7+2+ipm8ws9lJxiMidcimohJ2/fOWQd1uGN6D0wq6wKZKVlRyJdWjeklERDIumRasX8zsgNKJ8Acef0k+JBGpCz5Z+mOZ5GrGqEOC5KoySq6k+lQviYhIxiXTgvUH4N9hn3cDVgOnpyIoEand/vzcXB5/7+vI9Je3DMMmVHY9RyMFStJUL4mISMYlM4rgbKCPmbUMp9ekKigRqb2ih2A/do8d+X8n9IXxlfzAVYtucNTCmg1M6jzVSyIikg2qnGCZ2e/c/XEzu7zcfADc/c4UxSYitcj3azew983/i0w/de5+7N2ldeXJlboESpJUL4mISDapTgtWs/BvixjL9E1JpB566sOlXPXMnMj0or8eRuMFf4Hxf6t4RSVXkhqql0REJGtUOcFy93+GT6e6+4zoZeENxSJSjwy6fRoFq9YDsF2LRnxw7aHwZBMo2VDxikquJEVUL4mISDZJZhTBexOcJyJ10MaiYjqPeimSXN10TM8guRpvSq4kU1QviYhIxlXnHqz9gP2BduX6u7cEclMVmIhkr4++/oHjHngnMv3e1YP5VavGld9vBUquJOVUL4mISDapzj1YDYHm4brR/d3XACNSEZSIZK9Rz8zhyQ+XRqa/vGVYMJhAZclVw9YwYlUNRyf1lOolERHJGtW5B+tN4E0zG+fuX9VATCKShdydLle/HJn+bf98bhvRJ5ioLLnqMAIOfLoGo5P6TPWSiIhkk2TuwfqXmW1TOmFm25rZf5MPSUSyzXdrNpRJrp75w36JJ1cnuZIrSRfVSyIiknHV/qFhoK27/1g64e4/mNl2yYckItlk/Ptfc82kuZHpT286jEYNwtta9BtXkl1UL4mISMYlk2CVmFlHd/8awMw6od8bEalT9r/lfyz7KRgRMH/bJrz9p0OCBZ9cC/P1G1eSdVQviYhIxiWTYF0LvG1mb4bTA4Fzkg9JRDJtw+Ziuv3fq5Hpv/+mFyfs1TGYeKoFFK2reANKriQzVC9JdiicDMunQPshkD8809GISJpVO8Fy91fNrB+wL2DAZe6+MmWRiUhGfFiwmuNHvxuZ/uCawWzXsnEwoWHYJYupXpKsUDgZZoyE4vWwZCwMmKAkS6SeqfYgF2ZmwGFAP3d/AWhqZnunLDIRSbs/PvVJmeSq4NYjEk+uGrZWciUZpXpJssLyKUFyBcHf5VMyG4+IpF0yowg+AOwHjAyn1wL3Jx2RiKSdu9N51Es881EhACft05GCW4/YUqCy5Grg8/qNK8kGqpck89oPgdymwfPcpsG0iNQrydyDtY+79zOzjyEyWlPDFMUlImmy7Mdf2P/W1yPTk87fnz06brulgEYKlNpD9ZJkXv7woFug7sESqbeSSbA2m1ku4QhNZtYOKElJVCKSFo+9W8D/PT8/Mv3ZTYfTsEHYsF04GaYfXfEGlFxJdlG9JNkhf7gSK5F6LJkE6x5gErCdmd0MjAD+nMiKZvYIcCTwvbv3jFNmEHAXkAesdPeDkohVRMrpf9NrrFy3CYCd2jXj9T8O2rJwYhvYtLriDSi5kuxT7XpJREQkVaqVYJlZDvAlcBUwmGC0pmPcfWGCmxgH3Ac8Gmf72xD0pT/M3b/WD0WKpE75IdjvOL4PI/bM31JAIwVKLZSCeklERCQlqpVguXuJmf3D3fcDFlVj/elm1rmCIicBz5b+WKS7f1+dOEWkrPeWrOLEMe9Fpj+89lDatWi0pYCSK6mlkq2XREREUiWZUQSnmNlvwmFxU21XYFsze8PMZpnZqTWwD5F65eIJH5dJrgpuPaJqyVWHEUquJNvVZL0kIiKSkGTuwbocaAYUmdkGgu4Y7u4tUxTXngTdPJoA75rZe+7+WfmCZnYOcA5Ax44dU7BrkbrF3ely9cuR6dP268QNR5e79VEjBUrdUJP1koiISEKSuQfrMHefkeJ4ShUSDGzxM/CzmU0H+gBbJVjuPgYYA9C/f399CxSJUvjDeg74+7TI9AsXHkCv/FZbCkwZACvfqXgjSq6kFkhDvSQiIpKQanURdPcS4I4UxxLteeBAM2tgZk2BfQDdqCxSBWNnfFkmufr85sPLJlfjc5VcSZ2RhnpJREQkIcl0EZxiZr8hGIyiSt/CzGwCMAhoa2aFwHUEw7Hj7qPdfaGZvQrMIfgNk3+5+7wkYhWpV3pf/1/WbCgCoNuvWvDqpQPLFtBgFlI3VbteEhERSZVU3INVbGa/UIW+7u4+MoEytwO3JxGfSL3zy6Ziuv9lyxDsd53Ql2P22LFsocqSqxbd4Cg1GEutVO16SUREJFWqnWC5e4tUBiIiyZmxeCUn/+v9yPSsPx9Km+aNyhaqLLnqcQ30ubkGohOpeaqXREQkGyTTgoWZDQdK+x694e4vJh+SiFTVHx6fxSvzvo1MF9x6RNkC6hIo9YTqJRERybRqJ1hmdiuwF/BEOOsSMzvA3UelJDIRqVT5Idh/f0AX/u/I3csWUnIl9YTqJRERyQbJtGANA/qGIzdhZv8GPgZUkYmkwdLV6znwti2jBL508QH02KFV2UJKrqR+Ub0kIiIZV61h2qNsE/W8VbxCIpJaD01fUia5Wnzz4WWTq0+uTex+KyVXUvdsE/Vc9ZKIiKRdMi1YtwAfm9k0gpGaBgJXpyQqEYmr2/+9wobNJQD02rEVL1x0QNkCarWS+kv1kmS3wsmwfAq0HwL5wzMdjYjUkGRGEZxgZm8Q9Hc34E/u/m3Fa4lIdf28sYge1/03Mn3vyD04qs8OZQspuZJ6TPWSZLXCyTBjJBSvhyVjYcAEJVkidVS1uwia2bHAenef7O7PAxvM7JiURSYiEdM/W1Emufr4/35dNrkabwkkV6bkSuo01UuS1ZZPCZIrCP4un5LZeESkxiRzD9Z17v5T6YS7/whcl3REIlLGWf+eyamPfBCZLrj1CLZt1nBLgURardruDyeV1EB0Ilml2vWSmRWY2Vwzm21mM2Ms39bMJpnZHDP7wMx6hvM7mNk0M1toZvPN7JJUHYzUMe2HQG7T4Hlu02BaROqkZO7BipWcJfW7WiKyRfkh2M89aCeuPrz7lgJPtYCidZVvSK1WUn8kWy8d7O4r4yy7Bpjt7seaWTfgfmAwUAT80d0/MrMWwCwze83dF1Qpcqn78ocH3QJ1D5ZInZdMQjTTzO4kqGQcuAiYlZKoROq5gpU/M+iONyLTr156IN1+1XJLgURarciBk4pTHptIFqvJeml3gkE0cPdFZtbZzLZ39+XA8nD+WjNbCOwIKMGSreUPV2IlUg8k00XwImAT8B/gKeAX4IJUBCVSnz3wxuIyydXimw/fklxNbJP4QBZKrqT+SaZecmCKmc0ys3NiLP8EOA7AzPYGOgH50QXMrDOwB/B++ZXN7Bwzm2lmM1esWJFgSCIiUhslM4rgz+jHG0VSaudrXqa4JOjS16/jNjx7/oAtCxNqtUJdAqXeSrJeGuDuy8xsO+A1M1vk7tOjlt8K3G1ms4G5BD9gXFS60MyaA88Al7r7mhixjQHGAPTv319vUhGROkz3TIlkgbUbNtPr+i0jSj14cj8O79U+mEg0scppDCf+UgPRidR97r4s/Pu9mU0C9gamRy1fA5wBYGYGfBk+MLM8guTqCXd/Ns2hi4hIllGCJZJh0xZ9zxnjPoxMz/7Lr9mmaThKoFqtRGqcmTUDcsJ7qJoBQ4Aby5XZhmAI+E3AWcB0d18TJlsPAwvd/c40hy4iIllICZZIBp32yAe8+dmW+zEKbj0ieJJoYkUunFRUeTERqcj2wKQgV6IBMN7dXzWz8wDcfTTQHXjUzIoJBrD4fbjuAOAUYG7YfRDgGnd/GRERqZeqnWCZ2U7A3cB+QAnwLnCZuy9JUWwidVZJibPTNVu+f1148C5cMXS3YEKtViLVUt16KVzeJ8b80VHP3wW6xijzNpDoFRGpqwona/h1EYlIpgVrPMFQuMeG0ycCE4B9kg1KpC5bsmIdh/zjzcj0lMsGsuv2LRJPrCwPRm6qoehEajXVS5J+hZNhxkgoXg9Lxga/daUkS6ReS2aYdnP3x9y9KHw8TjDMrYjEce//Pi+TXH3xt2Hs+lbnqrVaKbkSiUf1kqTf8ilBcgXB3+VTKi4vInVeMi1Y08xsFPAkQQV2AvCSmbUGcPfVKYhPpM7oPOqlyPN9urTmP+ful3hi1eMa6HNzDUUmUmeoXpL0az8kaLkqXg+5TYNpEanXkkmwTgj/nltu/pkEFdtOSWxbpM5Ys2EzvaOGYB9zyp4MWX0RjJ+Y2AZ0r5VIolQvSfrlDw+6Bca7B0v3Z4nUO8n80HCXVAYiUhdNXfAdZz06MzL9yXVDaDWpYWIrq9VKpEpUL0nG5A+PnTzp/iyReimZUQRzgSOAztHb0e+AiARO/td7zFi8KjJdcMjfYNKRla/YohsctbAGIxOpm1QvSdaJdX+WEiyROi+ZLoIvABuAuQTD4YoIUFzi7Bw1BPulh3bl0u93g5UJrKzugCLJUL0k2UX3Z4nUS8kkWPnu3jtlkYjUAYu/X8uhd06PTE+9/CB2mdqi8hWb7AjHFtZgZCL1guolyS6V3Z8lInVSMgnWK2Y2xN01HqkIcOdrn3HP/z6PTC/Z+zxypiaQNKnVSiRVVC9J9ol3f5aI1FnJJFjvAZPMLAfYTPBL9u7uLVMSmUgtEj0E+4Fd2/JYk32DjkoVadgaRqyqpJCIVIHqJRERybhkEqx/APsBc91dl+ClXvrpl830uWHLxfKH+09l8Ka7Kl9RrVYiNUH1koiIZFwyCdbnwDxVYlJfvTpvOec9/lFkem6P39Ji0/rKV1RyJVJTVC+JiEjGJZNgLQfeMLNXgI2lMzUcrtQHx49+hw8LfohMF/ROYPh1JVYiNU31koiIZFwyCdaX4aNh+BCp88oPwX7F9o9y4fZPVb6ikiuRdFC9JCIiGVftBMvdb0hlICLZ7tNv1zL0ri1DsE/b7Ry6NFpW8Ur60WCRtFG9JCIi2aDaCZaZtQOuAnoAjUvnu/shKYhLJKvc9uoiHnjji8j0kl5HkWOVtEqp1UokrVQviYhINshJYt0ngEVAF+AGoAD4MAUxiWSVzqNeiiRXh7T4gILeR1acXOU0VnIlkhmql0REJOOSuQerjbs/bGaXuPubwJtm9maqAhPJtB/Xb6Lvja9Fpsd1+QuDWnxUwRoosRLJLNVLIiKScckkWJvDv8vN7AhgGZCffEgimffSnOVcMH5LMjWvx/E0z/2lgjUMTiqp+cBEpCKqlyQ7FU6G5VOg/RDIH57paESkhiWTYN1kZq2APwL3Ai2BS1MRlEgmHXP/DGYv/RGAPNvM572OrXgFtVqJZAvVS5J9CifDjJFQvB6WjIUBE5RkidRxySRYP7j7T8BPwMEAZjYgJVGJZEBRcQm7XPtKZPrqXz3Cuds9G3+FnMZwYkWtWiKSZqqXJPssnxIkVxD8XT5FCZZIHZfMIBf3JjhPJOstWLamTHL15m5nVZxcneRKrkSyj+olyT7th0Bu0+B5btNgWkTqtCq3YJnZfsD+QDszuzxqUUsgN8FtPAIcCXzv7j0rKLcX8B5wgrtPrGqsIon4239eYMzHW641fNnrSMziFO4wAg58Oj2BiUhCUlEvidSY/OFBt0DdgyVSb1Sni2BDoHm4bouo+WuAEQluYxxwH/BovAJmlgv8HfhvNWIUSUjnUS9R2pA7pOW7jOl8c5ySGsRCJIulol4SqTn5w5VYidQjVU6wooa+HefuXwGYWQ7Q3N3XJLiN6WbWuZJiFwHPAHtVNUaRyqx+dFv6LXg8Mv14l2s5oMUnsQtrEAuRrJaKeklERCRVkrkH6xYza2lmzYAFwKdmdmUqgjKzHYFjgdEJlD3HzGaa2cwVK1akYvdSxz1//0FlkqsFPX8TO7myPCVXIrVLjdVLIiIiiUomwdo9vDJ4DPAy0BE4JRVBAXcBf3L34soKuvsYd+/v7v3btWuXot1LnTTeOPz6e7lk6VUANMtZT0HvI2mas3Hrsic5jNyU5gBFJEk1WS+JiIgkJJlh2vPMLI+gIrvP3TebWaou9/cHnrRgpIG2wDAzK3L351K0falnNj/RgK5zX4xM/7n9Q5zV7vmtC/a4BvrEuw9LRLJcTdZLIiIiCUkmwfonUAB8Akw3s04ENxQnzd27lD43s3HAi0qupFrGG/PW78yRi7ckU291O5MODb8vW87y1GIlUvvVWL0kIiKSqGonWO5+D3BP1KyvzOzgRNY1swnAIKCtmRUC1wF54XYrve9KpFLjGwDF3LDsbMauPDoyO+YQ7LrPSqROSKZeEhERSZVqJ1hmtj3wN2AHdz/czHYH9gMermxddx+Z6H7c/fTqxij11Pggg+o8Z0uXwCNaTef+TreVLddkRzi2MJ2RiUgNSqZeqrOmDICV76RhRzlgDcA3A7poVf8Yqfu/5wAlQAPIbQTFP6dou/VcTiMo2US1/k9NdoRmnSr4LGkAFFWykVywXPAs6y3UohsctTDlm02mi+A4YCxwbTj9GfAf6nNFJpn1ZBMo2cDKolb0X/BEZPb4na5m/+Zzy5ZVq5VIXTSOelAv+fTjeXfRp2woaQRACTl4+JFWQg5OcJHJMdwNGEAJFplf4galz8vNL7Nu6XM3StjS9B/sI4zFt+yvwn341mW8zPyobWLh+gDl9l1uf8SIvaRc7LHji95f+fO3JQ73nPB52XMS71zFj2PLdqP3UeJbxhor87/zYLp038Q5h9HnNn4cUfuIE0e8/6N7cH62xFjBOYgZ35Zz6+WOOzqOWP9HB0r0O+FSQ/LzvuXZXa5gu7WL4IXuKU+ykkmw2rr7U2Z2NYC7F5lZpaP+idSIsNXq2R8O5vKlf4zMXtjzNzSJHiVw4PP6sUeRuqvu10tvHc9tHzbjwRW3ZDoSEZFaq3Dzr/h8Qye2y/sR1n6W8u0nk2D9bGZtCC+umNm+wE8piUokUZ9cC/P/BsChnz7A4o0dAdg29yc+7nHylnI5jeHEXzIRoYikT92vl757nZPb5PLgiuMzHUlaWJn2EDCcHItueyoJ50OObXlupfONqDJb2lDMgvae8tu0Mu0sYZtQuPOcqLa0YH7UvmPEAeX2HbUPi4ojh633HQx+ueW4cyiJxGFRx025446OY0t85fYRK45458C8XLmofVjUeS4TR9n9WYztbv1/jJ4f/X8MzsPW+4iOo9xxxDi3xDm+RP+PZV5TFbxeYu5jq/hivTaJGQcQtGvGPVeJ/C8r3kf594iViZuY2604jtjvyTL7iHOetnrvlZ7/8u+TVA8O22LX1G6P5BKsy4HJwM5mNgNoB4xISVQiiRifAzibShqw67znIrNv2GE0p7Utvf8qF06qrF+wiNQRdb9e2v4Q8jdNpKD3kZmOpBzdg1W/6R6srKd7sGLLtnuw3P0jMzsI2I3gnfWpu29OWWQi8RROhunByICfrO/K0Yv/X2TRjG5nsGPDFcGEugOK1Cv1ol468Gl463hYOrFq69XQl4g6o3AyLJ8C7YckX2+kclsiUislM4pgLjAM6BxuZ4iZ4e53pig2ka290B3WLgLgz9/8gcdXHRFZFBmCXb9pJVIv1Zt66cCnMx1B3ZM/PHXJUCq3JSK1UjJdBF8ANgBzIaqzqEhNmdAw7H5Sdgj2Y7aZxl0d/xFMqNVKpD5TvSQiIhmXTIKV7+69UxaJSDxRA1l8v3kb9l74eGTRUzv/ib2bzVf3FxEB1UsiIpIFkkmwXjGzIe4+JWXRiJQ3PpfSC9FPrT6UqwovjSxa1PM4GucU6TetRKSU6iWpGdW5r0r3YonUW8kkWO8Bk8wsB9hMOISMu7dMSWQi47f8uOSgRWMo2LQDANs1WMUHu59GMEJg3fqJGxFJiuolSb3CyTBjJBSvhyVjYcCEyhOm6qwjInVGTuVF4voHsB/Q1N1bunsLVWKSMmFytbGkAZ3nvBhJrm7a8f4guWrRTcOvi0h5qpck9ZZPCRIlCP4uj9NAWjgZPrxwS8tVIuuISJ2UTAvW58A8d1f/LEmdp1pA0ToAPvp5N4774h+RRe91P41f5a3SQBYiEo/qJUm99kOCVqji9ZDbNJgur3yLVbdLg7IVrSMidVYyCdZy4A0zewXYWDqzzg2HK+kT1SVwVOFFPLl6aGQ6MgS77rcSkfhUL0nq5Q8PuvhVdD9V+RarTT9Vvo6I1FnJJFhfho+G4UOk+sLkyh26zN0yBPvx277G7R3uDiaUXIlIxVQvSc2o7LetYrVyRa+jAS9E6pVqJ1jufkMqA5F66q3jYelEAL7b3Jp9Fj4aWfTMzlewZ7NF0KA5/HZtpiIUkVpC9ZJkTEWtXBrwQqTeqXKCZWb3ufuFZvYCsFWTgrvrU0MSEzUE+/hVQ7nmm4siiz7teQyNNAS7iCRA9ZJkhdIWq9LBLkoTrVgDXijBEqnTqtOCdSpwIXBHimOR+iTqfqv9Fz7Css3bAZCf9y1vdz8rWKDkSkQSo3pJ0i9Wt79YrVWJDJIhInVKdRKsLwDc/c0UxyL1RZhcbSjJo9u8SZHZt+54Dye2CYeyVXIlIolTvSTpFa/bX6zWqr3u04AXIvVMdRKsdmZ2ebyFGq1J4oq632rmz90Z8cXtkUUfdD+F7fJ+0P1WIlIdqpckveJ1+4vXWlXZIBkiUqdUJ8HKBZoDVllBkYioLoF/XHopz/xwaGS6oPeRwRO1WolI9ahekuqp7uh+7YfAFw9BySbIaVg2kVJrlUi9V50Ea7m735jySKTuijME+8jWr3BL/v3BhJIrEak+1UtSdUmP7mfl/obUWiVS7+VUYx1dIZTEhcnVsk1tyyRXk3a5XMmViKRK0vWSmRWY2Vwzm21mM2Ms39bMJpnZHDP7wMx6Ri07zMw+NbPFZjYq2VgkTWJ186vKuiXhb1mXbKzauiJS51UnwRqc8iik7vnk2khy9djKYey/aFxk0Wc9j2GPpp9Bkx2VXIlIKqSqXjrY3fu6e/8Yy64BZrt7b4JRC+8GMLNc4H7gcGB3YKSZ7Z6ieKQmtR8S3CcFVR/dL5l1RaTOq3IXQXdfXROBSB0yoSH4ZgD6L3iMlUXbArBTw0Je73ZeUEaJlYikSJrqpd2BW8L9LTKzzma2PbATsNjdlwCY2ZPA0cCCNMRUf1X33qloVblfqvz+Kls33hDuujdLpF6ozj1YIvFFhmBvSLd5z0Zm357//zi+9f+CCSVXIpJ9HJhiZg78093HlFv+CXAc8LaZ7Q10AvKBHYGlUeUKgX3SEG/9lfS9U1ESuV8q3v7irRurPKQuZhHJetXpIiiytcLJkeTqvXU9yyRXH3b/nZIrEcl2A9y9H0FXvwvMbGC55bcC25rZbOAi4GOgiNj3f231QWdm55jZTDObuWLFitRGXt8kc+9UOvYXq3y6YxaRjFKCJcmblA/Tjwbg4q+v4MQlt0YWFfQ+knZ5P8LA55VciUjWcvdl4d/vgUnA3uWWr3H3M9y9L8E9WO2ALwlarDpEFc0HlsXY/hh37+/u/du1a1czB1FfpPv+p6ruL1Z53bMlUq+oi6Ak58kmULJhqyHYT2vzAjfs+E8gF04qylx8IiKVMLNmQI67rw2fDwFuLFdmG2C9u28CzgKmu/saM/sQ6GpmXYBvgBOBk9J6APVNun9rqqr7i1dev48lUm8owZLqG58LlFC4qR0HLBobmT15l0vp3XQx5DSGE3/JXHwiIonZHphkZhDUi+Pd/VUzOw/A3UcD3YFHzayYYACL34fLiszsQuC/BD94/Ii7z8/AMdQv6f6tqarsL95gFvp9LJF6QwmWVN1TLaBoHQBjVx7FDcvOjSz6vNfR5Fkx9LgG+tycqQhFRBIWjgDYJ8b80VHP3wW6xln/ZeDlGgtQao9UDsAhIrWWEiypmvFb7ufuPf9J1hQ3B2C3xgX8d9cLgwW610pEROqjWINZKMESqXc0yIUk5oXukeTql5JGdJ7zYiS5+n8d7giSqwbNlVyJiEj9pcEsRAS1YEkiJuXDL98AMGNtH07+ckvXv1m7n0SbBmuUWImIiKR7AA4RyUpKsKRiUV0C//DV1bzy04DIdEHvI8HyYKSSKxEREUCDWYiIEiyJY2Ib2LQaYKsh2M9s+xx/2eFf0LA1jFiVqQhFRERERLKOEiwp663jYenEyOTSTdtz4KKHI9Mvdr2Ynk2WQIcRcODTmYhQRERERCRrKcGSLaK6AwI8tOJYbl7++8j04l7DadBuXxjyRbojExERERGpFZRgSfC7HdOPLjOr29yJbPDGAPRq8jkvdL1MA1mIiIiIiFQiI8O0m9kjZva9mc2Ls/xkM5sTPt4xs61+AFJSZMqAMsnVz8WN6TznxUhydW/Hvyu5EhERERFJUKZ+B2sccFgFy78EDnL33sBfgTHpCKpeeapF0CVw5TuRWdPX7kGP+Vvuv/po95M4asCBSq5ERERERBKUkS6C7j7dzDpXsPydqMn3gPwaD6o+GZ8DlE2azir4M1PX7BuZLuh9pBIrEREREZEqqg33YP0eeCXeQjM7BzgHoGPHjumKqXb65FqY/7cys8oPwX5uu4lcvdNrcKySKxERERGRqsrqBMvMDiZIsA6IV8bdxxB2Iezfv7+ygniifteqVMHG9gz69KHI9Ct9/0H3E19Pd2QiIiKZVTgZlk+B9kP0I8EikrRM3YNVKTPrDfwLONrd9Wu21fXJtcG9VuWSqwe+H1EmuVp8wjtKrkREpP4pnAwzRsLn9wd/CydnOiIRqeWysgXLzDoCzwKnuPtnmY6nVorRHbDUznOep5hcAPZoUcCkay8AjkhjcCIiIlli+RQoXh88L14fTKsVS0SSkJEEy8wmAIOAtmZWCFwH5AG4+2jgL0Ab4AEzAyhy9/6ZiLVWGt8AKN5q9rriJvSc/3Rk+sEDFnH4kX9MY2AiIiJZpv0QWDI2SK5ymwbTIiJJyNQogiMrWX4WcFaawqk7JuXDL9/EXDRtTX/OKLg+Mj37L79mm6ZqtRIRkXoufzgMmKB7sEQkZbKyi6BUUQXdAQFO+/J63ly7pQGw4FYlViIiIhH5w5VYiUjKKMGq7cbnAiUxF5W4sdPcFyLTFx68C1cM3S1NgYmIiIiI1D9KsGqrwskw/ei4i5ds3IFDPh0TmZ5y2UB23b5FOiITEREREam3lGDVRuOtwsX3fncC//julMj0F38bRm5OxeuIiIiIiEjylGDVJpXcawXQec6Lked7d2nNU+fuV9NRiYiIiIhISAlWbVFJq9Wa4qb0nv9UZPqfp+zJ0B6/qumoREREREQkihKsbDexDWxaXWGRqWv25qyCv0SmP7luCK2a5NV0ZCIiIiIiUo4SrGxWSasVwMlLbmLGur6RaQ3BLiIiIiKSOUqwstFbx8PSiRUWKfYcdp47OTJ96aFdufTQXWs6MhERERERqYASrGxTwe9alVq8IZ9DPxsdmZ56+UHssl3zGg5MREREREQqowQrmyTQJfDONX/inoIDI9NL/jaMHA3BLiIiIiKSFZRgZYMpA2DlO5UWix6C/YBd2vL4WfvUZFQiIiIiIlJFSrAyLYFWq59+dRJ9ppwUmX74tP4M7r59TUYlIiIiIiLVoAQrUyY0BN9cabFXey/nvMdnRabnXj+EFo01BLuIiIiISDZSgpUJCbRa0bA1x698gQ+jkisNwS4iIiIikt2UYKVTAsOvAxQf8Dw7P5AL/ADAFUN25cJDutZwcCIiIiIikiwlWOkyvgFQXHGZBs35dOAyht41PTLr9T8exE7tNAS7iIiIiEhtkJPpAOq8wslhl8BKkquBz3Nbyw/LJFdL/jZMyZWIiIiISC2iFqyalEirFcBJTudRLwFfAHDwbu0Ye8beNRqaiIiIiIiknhKsmpLIQBbk8OMxv9B31EuROePO2ItBu21Xc3GJiIiIiEiNUYKVak+1gKJ1lZc7yXlpznIuuPG1yKx5NwyleSP9S0REREREait9m0+lhFqtDE4q4Zj7ZzB76Y8A5OUan988rEZDExERERGRmqcEKxVe6A5rF1Ve7iSnqLiEXaK6BI46vBvnHbRzDQYnIiIiIiLpogQrWQnea8VJxSxYtoZh97wVmfvmlYPo1KZZzcUmIiIiIiJppQSruhJttWrRDY5ayN9eXsiY6Usis7+8ZRhmiSRnIiIiIiJSWyjBqo6EWq2AkxwgHII9MGT37Rlzav+aiEpERERERDJMCVZVFE6G6UcnUDAXTipi9c+b6PfXLaMEPv77fTiga9uai09ERERERDJKCVaiqthq9fzsb7jkydmR2QtuHErThjrdIiIiIiJ1mb7xV2ZSPvzyTeXlOoyAA58G4Ih73mL+sjUANGuYy/wbD6vJCEVEREREJEsowapIFVutNheX0PXaVyKz/3xEd846cKeaiExERERERLKQEqxYJraBTasrLxfVajXvm5848t63I4veuupgOrRuWlMRioiISE0onAzLp0D7IZA/PNPRiEgtpAQrWqJDrzdsDSNWRSZveGE+Y2cURKY1BLuIiEgtVDgZZoyE4vWwZCwMmKAkS0SqTAlWqUTvtRr4fJkP2+gh2I/o3Z77T+pXE9GJiIhITVs+JUiuIPi7fIoSLBGpMiVYEFyxSiS5Cu+1Ali5biP9b5oamR5/9j7sv7OGYBcREam12g8JWq6K10Nu02BaRKSKlGBBcIWqIj2ugT43Ryaf/aiQy5/6JDK98MbDaNIwt6aiExERkXTIHx50C9Q9WCKSBCVYEHyIfn7/1vOb7AjHFpaZdeidb7L4+3UAbNs0j4//oqtbIiIidUb+cCVWIpIUJVgQfJAOfB6mH71lXlR3QIBNRSXs+uctQ7DfMLwHp+3fOU0BiohITTKzAmAtUAwUuXv/cstbAY8DHQnqzjvcfWy47DLgLMCBucAZ7r4hfdGLiEg2UYJVKn/4VklVqU+W/sjR98+ITM8YdQg7btMkXZGJiEh6HOzuK+MsuwBY4O5HmVk74FMzewJoB1wM7O7uv5jZU8CJwLi0RCwiIlknJxM7NbNHzOx7M5sXZ7mZ2T1mttjM5phZxobm+7/n5pVJrr68ZZiSKxGR+seBFhb8BkdzYDVQFC5rADQxswZAU2BZZkIUEZFskJEEi+DK3mEVLD8c6Bo+zgEeTENMW+k86iUee+8rAI7puwMFtx6h37cSEambHJhiZrPM7JwYy+8DuhMkT3OBS9y9xN2/Ae4AvgaWAz+5+1YjJ5nZOWY208xmrlixouaOQkREMi4jCZa7Tye4+hfP0cCjHngP2MbM2qcnOvh+7YYyv2/11Ln7cdeJe6Rr9yIikn4D3L0fwQW+C8xsYLnlQ4HZwA5AX+A+M2tpZtsS1FldwmXNzOx35Tfu7mPcvb+792/Xrl0NHoaIiGRaplqwKrMjsDRqujCct5VUXxV8auZS9r75f5HpRX89jL27tE56uyIikr3cfVn493tgErB3uSJnAM+GF/4WA18C3YBDgS/dfYW7bwaeBfZPX+QiIpJtsjXBitUPL+YIFKm8Kjjo9mlcNXEOANu1aETBrUfQOE+/byUiUpeZWTMza1H6HBgClL9H+GtgcFhme2A3YEk4f18zaxrenzUYWJiu2CUFCifDhxcGf0VEUiBbRxEsBDpETedTwzcNz176IwWr1gNw0zE9+d2+nWpydyIikj22ByaF99g2AMa7+6tmdh6Au48G/gqMM7O5BBcB/xSOOLjSzCYCHxEMevExMCYDxyDVUTgZZoyE4vWwZGzwI8P6DSwRSVK2JliTgQvN7ElgH4KbhpfX5A577tCS3/bP57Jf70r7VholUESkvnD3JUCfGPNHRz1fRtCyFWv964DraixAqTnLpwTJFQR/l09RgiUiSctIgmVmE4BBQFszKySomPIgUqG9DAwDFgPrCfq+16gGuTncNmKr+lVERETqqvZDgpar4vWQ2zSYFhFJUkYSLHcfWclyJ/hRRxEREZGakT886Ba4fEqQXKn1SkRSIFu7CIqIiIjUvPzhSqxEJKWydRRBERERERGRWkcJloiIiIiISIoowRIREREREUkRJVgiIiIiIiIpogRLREREREQkRZRgiYiIiIiIpIgSLBERERERkRRRgiUiIiIiIpIiSrBERERERERSxNw90zGkjJmtAL5KYhNtgZUpCifdFHtmKPbMUOyZka7YO7l7uzTsJyNSUFeBXkeZotgzQ7GnX22NG9Ibe8z6qk4lWMkys5nu3j/TcVSHYs8MxZ4Zij0zanPsdU1t/l8o9sxQ7JlRW2OvrXFDdsSuLoIiIiIiIiIpogRLREREREQkRZRglTUm0wEkQbFnhmLPDMWeGbU59rqmNv8vFHtmKPbMqK2x19a4IQti1z1YIiIiIiIiKaIWLBERERERkRRRgiUiIiIiIpIiSrBCZnaYmX1qZovNbFSm44nFzArMbK6ZzTazmeG81mb2mpl9Hv7dNqr81eHxfGpmQ9Mc6yNm9r2ZzYuaV+VYzWzP8JgXm9k9ZmYZiPt6M/smPO+zzWxYtsUd7rODmU0zs4VmNt/MLgnn14bzHi/2rD/3ZtbYzD4ws0/C2G8I59eG8x4v9qw/7/WVqa5Kday1sq6qIPZa8d6t4DM/6899BbFn9bmv4PO+Npzz2ldXuXu9fwC5wBfATkBD4BNg90zHFSPOAqBtuXm3AaPC56OAv4fPdw+PoxHQJTy+3DTGOhDoB8xLJlbgA2A/wIBXgMMzEPf1wBUxymZN3OE+2wP9wuctgM/CGGvDeY8Xe9af+3A/zcPnecD7wL615LzHiz3rz3t9fKC6qiZirZV1VQWx14r3Lqqv0h47qqvSGrtasAJ7A4vdfYm7bwKeBI7OcEyJOhr4d/j838AxUfOfdPeN7v4lsJjgONPC3acDq8vNrlKsZtYeaOnu73rwrng0ap10xh1P1sQN4O7L3f2j8PlaYCGwI7XjvMeLPZ5sit3dfV04mRc+nNpx3uPFHk/WxF5Pqa5KsdpaV1UQezzZFrvqqzTHrroqvbErwQrsCCyNmi6k4jdLpjgwxcxmmdk54bzt3X05BG96YLtwfjYeU1Vj3TF8Xn5+JlxoZnPCLhmlzedZG7eZdQb2ILjKU6vOe7nYoRacezPLNbPZwPfAa+5ea857nNihFpz3eigbP9djUV2V2WOoVe9d1Vdbza/JeFVXpSl2JViBWP0vs3H8+gHu3g84HLjAzAZWULa2HBPEjzVbjuFBYGegL7Ac+Ec4PyvjNrPmwDPApe6+pqKiMeZlNP4YsdeKc+/uxe7eF8gnuErWs4LitSH2WnHe66Hacp5VV2XuGGrVe1f1Vcz5NUZ1VfpiV4IVKAQ6RE3nA8syFEtc7r4s/Ps9MImgG8V3YZMn4d/vw+LZeExVjbUwfF5+flq5+3fhG7sEeIgt3VeyLm4zyyP4wH/C3Z8NZ9eK8x4r9tp07gHc/UfgDeAwasl5LxUde2077/VINn6ub0V1VeaOoTa9d1VfZe7cq67aan7KKcEKfAh0NbMuZtYQOBGYnOGYyjCzZmbWovQ5MASYRxDnaWGx04Dnw+eTgRPNrJGZdQG6EtzYl0lVijVsql5rZvuGo7ycGrVO2pR+8ISOJTjvkGVxh/t6GFjo7ndGLcr68x4v9tpw7s2snZltEz5vAhwKLKJ2nPeYsdeG815Pqa5Kj6x/78ZTW967qq/SH7vqqjTH7jU46kdtegDDCEaC+QK4NtPxxIhvJ4IRUT4B5pfGCLQB/gd8Hv5tHbXOteHxfEqaR/QCJhA0124muGLw++rECvQneMN8AdwHWAbifgyYC8wheNO2z7a4w30eQNDUPQeYHT6G1ZLzHi/2rD/3QG/g4zDGecBfwvm14bzHiz3rz3t9faC6KtXx1sq6qoLYa8V7F9VXaY8d1VVpjd3CnYmIiIiIiEiS1EVQREREREQkRZRgiYiIiIiIpIgSLBERERERkRRRgiUiIiIiIpIiSrBERERERERSRAmW1Gtm1sbMZoePb83sm/D5OjN7II1xDDKz/dO1v2SY2V1mNrCC5Rea2RnpjElEpK5TfVV1qq8kUzRMu0jIzK4H1rn7HXVh3+GP6JkHv3Be3W3kuntx1HRr4GV337eCdZoCM9x9j+ruV0RE4lN9FXMbqq8ka6gFSySG8Ardi+Hz683s32Y2xcwKzOw4M7vNzOaa2atmlheW29PM3jSzWWb233K/MF663aPM7H0z+9jMpprZ9mbWGTgPuCy8GnlguXUOirpq+bGZtQjnX2lmH5rZHDO7IZzX2cwWhlczPwL+z8xui9rW6WZ2b/j8d2b2Qbjdf5pZbjh/nZndaGbvA/uVO4QRwKtR27vVzBaEMdwB4O7rgQIz2zuJf4GIiCRA9ZXqK8k+SrBEErMzcARwNPA4MM3dewG/AEeElda9wAh33xN4BLg5xnbeBvYNr5Y9CVzl7gXAaOD/uXtfd3+r3DpXABe4e1/gQOAXMxsCdAX2BvoCe9qWbhC7AY+G+3gAOC5qWycA/zGz7uHzAeF2i4GTwzLNgHnuvo+7v10ulgHALIhcHTwW6OHuvYGbosrNDGMVEZH0Un0VUH0lGdMg0wGI1BKvuPtmM5sL5LLlqthcoDNBJdETeC3o6UAusDzGdvIJKoz2QEPgywT2PQO408yeAJ5198KwwhoCfByWaU5QgX0NfOXu7wG4+wozW2Jm+wKfh3HOAC4A9gQ+DONtAnwfbqsYeCZOLO2BFeHzNcAG4F9m9hLwYlS574FuCRybiIikluqrgOoryRglWCKJ2Qjg7iVmttm33LxYQvA+MmC+u5fvolDevcCd7j7ZzAYB11e2Y3e/NawQhgHvmdmh4f5ucfd/RpcNu2/8XG4T/wF+CywCJrm7W1BL/dvdr46xyw3R/djL+QVoHMZVFHarGAycCFwIHBKWaxyWFRGR9FJ9FVB9JRmjLoIiqfEp0M7M9gMwszwz6xGjXCvgm/D5aVHz1wItYm3YzHZ297nu/neCrgzdgP8CZ5pZ87DMjma2XZzYngWOAUYSVF4A/wNGlK5jZq3NrFMCx7kQ2CVcpznQyt1fBi4l6PpRaldgXgLbExGR9FJ9pfpKapgSLJEUcPdNBDfU/t3MPgFmA7GGsb0eeNrM3gJWRs1/ATg21k3DwKVmNi/c7i8E3T+mAOOBd8NuIBOJU+G5+w/AAqCTu38QzlsA/BmYYmZzgNcIulNU5iVgUPi8BfBiuP6bwGVR5QYAUxPYnoiIpJHqK9VXUvM0TLuIVImZvQ0c6e4/xlm+B3C5u5+S1sBERESiqL6STFGCJSJVYmb7AL+4+5w4y38NfB6ONiUiIpIRqq8kU5RgiYiIiIiIpIjuwRIREREREUkRJVgiIiIiIiIpogRLREREREQkRZRgiYiIiIiIpIgSLBERERERkRRRgiUiIiIiIpIiSrBERERERERSRAmWiIiIiIhIiijBEhERERERSRElWCIiIiIiIimiBEtqFTPraGbrzCy3BrY9wMw+D7d/TKq3L5llZoPMrDDTcYhI/aD6SqpL9VXtpwRLADCzk8xsZvhhvdzMXjGzA7IgrgIzO7R02t2/dvfm7l5cA7u7Ebgv3P5zNbD9OsHM2pvZZDNbZmZuZp1jlDnUzD4ys5/NbKmZ/TZq2VFmNi98rb1jZrun9QBiiPoiFP1wM/tjVJmTzOyr8JieM7PWUcsamdkjZrbGzL41s8szcyQidZ/qK0D1VUIqq6/M7LawjloTfr5fG7WsrZnNMLNVZvajmb1rZgPSfhAxmNlfzWyumRWZ2fUVlBsbHvcuUfPiHrOkjhIsIfwyeBfwN2B7oCPwAHB0NbbVIJF5WaoTML86K9aiYwQgySuqJcCrwG/ibHt3YDxwLdAK6AvMCpd1BZ4AzgO2AV4AJmf6/EV9EWru7s2BXgTH+QyAmfUA/gmcQvAeWU/wHil1PdCV4DV0MHCVmR2WviMQqR9UX0WovkpMhfUV8DDQzd1bAvsDJ5nZceGydcCZQDtgW+DvwAtZcv4WA1cBL8UrEF502DnGooqOWVLF3fWoxw+CL8DrgOMrKNOIoEJbFj7uAhqFywYBhcCfgG+Bxwi+bE4EHgfWAGeF+3kYWA58A9wE5Ebt42xgIbAWWAD0C7dVAvwSxngV0BlwoEG43g7AZGA1wQfO2VHbvB54Cng03O58oH+cY/yi3L4aJbDtMscYY5vDwmNZGx7zFVHLjgRmAz8C7wC9o5YVAFcAc4CfgP8AjcNlbYEXw/VWA28BOeGy7sAb4bL5wPCobY4DHgReBn4GDq0ovgRfOw3C/0XncvPHA3+Ns86FwEtR0znhOR8cp/wRwMfhOV4KXB+1rPS1cBrwNbASuDZqeZPwuH8Ij/NKoDDBY7sOmBY1/TdgfNT0zsAmoEU4/Q0wJGr5X4EnM/3+1kOPuvRA9VVpWdVXKaqvypXZEZgLXBVjWQ5wVLiN7eKsn/b6KvyfXh/neD8Geof73aWqx6xHco+MB6BHhl8AcBhQRFgBxClzI/AesB3BlZx3CL9AE1RYRQRXdhqFHxLXA5uBY8IPpSbAcwQtAM3C7XwAnBtu4/jwA3MvwIBdgE7hsgLg0KhYSj+kSiusNwmuXjYmaClZQfhlPYxjQ/jBnAvcArxXwXGW31dl2y5zjDG2txw4MHy+LdAvfN4P+B7YJ4zrtHDfjaLi+ICgwmxNUJGfFy67BRgN5IWPA8NzlkdQqV4DNAQOIaiIdgvXG0dQ+Q0I420cL75w+kfggEpeO/ESrCUECcbccB+PA63DZRcBL0eVzQ3/R5fE2ccggtakHIKK4jvgmHKvhYcIXmN9gI1A93D5rQQVemugAzCPxBOsL4DTo6afB/5Ursw6YM/w3DmwfdSyEcDcTL+/9dCjLj1QfRV9nOX3pfqq4tdO3AQLGEXwee4E9Vd+ueVzCC6oOfBQBfsYRJrrK+InWFcCd4fPt0qwKjtmPVLweZXpAFJ+QPBI+GEwL4GyA4GPCD5wR5Rbdhrwefg4LdPHVYPn62Tg20rKfAEMi5oeChSEzweFHzyNo5ZfD0yPmt4+/CBpEjVvJGELAfBf4n/BLiBOhRV+CBUTtiKEy28BxkXFMTVq2e7ALxUcZ2RfCW57erxthWW+Bs4FWpab/yDlWniAT4GDouL4XdSy24DR4fMbCb7sl/+wPJDgimxO1LwJpR+8BBXWo4nEV4XXTrwEa1N4DLsCzQm62T0RLutGcEVyEEHF+n8EV2KvTnCfdwH/r9xrIT9q+QfAieHzJcBhUcvOIbEK60CCiqd51Lz/EX5piJr3TXgcHcI4ot8DvyZ8j+ihR6wHVaurOgLTCK5IzyHq87g+PVB9FXNfCW5b9VUFLVgEid8ewA3R5zFqeePwdXBaFfZ5FzVfX22VYIWvh8VAq3B6qwQrkWPWI7lHXbwHaxzBVa5EfA2cTtClKSK8ef06gis2ewPXmdm2qQsxq6wC2lbSp3gH4Kuo6a/CeaVWuPuGcussjXreieCK1fLwRtEfCa4Obhcu70BQKVbVDsBqd19bLrYdo6a/jXq+HmicYP/pRLa9lIr9huBq5Fdm9qaZ7RfO7wT8sfRchOejA2XPafm4m4fPbyf44JxiZkvMbFRUvEvdvaQK8caLL1m/AGPd/TN3X0fQvW4YgLsvIrh4cR/BFcm2BN0hYo6WZGb7mNk0M1thZj8R3LvVtlyxeOdqB8oec/RruCKnAc+EsZdaB7QsV64lwVXXdVHT5ZeJxDOOxOuqPwNPufsewImUvf+vPlF9Vf1tq76qgAc+Jqi/boixfIO7TwBGmVmfWNvIUH0Vy13Aje7+U0WFKjtmSU6dS7DcfTpBX98IM9vZzF41s1lm9paZdQvLFrj7HIIr6NGGAq+5+2p3/wF4jcQrwtrmXYJuCcdUUGYZwYdsqY7hvFIeY53oeUsJrgi2dfdtwkdLd+8RtTzWjZjxth0dV2sza1Eutm8qWCdRiWy7othw9w/d/WiCivk5gv71EBzvzVHnYht3bxp+eFfI3de6+x/dfSeC/uCXm9ngMN4OZhb9nq4w3griS9ac8vsqt9+J7t7T3dsQXMjoBHwYp/h4gvsKOrh7K4LuJpZgHMsJvgiU6ljZCmbWhKAL0L/LLZpP0KWjtNxOBF2MPgs/I5ZHLw+fV+sGdKkfqlJXEbyfShP4VpT9/K1PVF9Vf9uqrxLTgPj/XwiS753iLEtrfVWBwcDt4Yi2pQndu2Z2UpzylR2zVEOdS7DiGANc5O57EtyMWdnVvx0peyWhkLJXVuqM8ArHX4D7zewYM2tqZnlmdriZ3RYWmwD82czamVnbsPzjVdjHcmAK8A8za2lmOeEXiYPCIv8CrjCzPS2wi5mVVpDfEefDzN2XEvSvv8XMGptZb+D3BKPUJSXZbZtZQzM72cxauftmgpteS4fqfQg4L7zaZWbWzMyOKFc5xtvukeH5sahtFgPvE3S9uyr8/w0iqNCerEZ8iRxfY4IEA6BROF1qLHCGme1kZk0Jbih/MWrdPc0s18zaEVwZfiFs2YqlBcGV2Q1mtjcQr4KI5SngajPb1szyCe7/qsyxBP35p5Wb/wRwlJkdaGbNCLq+PBt1xfhRgvfItuGX4rMJWihEqiJeXXU98DsLfhfnZRJ7Ldc5qq/ixqz6quI4YtZX4f/23PBz28I65gKCLuGY2b5mdkC4/yZm9ieCLqTvx9lV2uqr8Lw1Jvge3yD8v5eOtrgrwUW+vuEDgvM7qbJjltSp8wmWmTUnGIbyaTObTfCFrn1lq8WYV+HVn9rM3e8ELifohrKCILm8kOAqEQQjKM0kaJmYS3Df2k1V3M2pBPfcLCAYJWci4f/B3Z8Gbia4+rM23G/pbwzdQlBZ/mhmV8TY7kiCvs3LgEnAde7+WhVjiyfZbZ8CFJjZGoKuAr8DcPeZBF/A7yM4F4sJuqomoiswlaBb2rvAA+7+hrtvAoYDhxOMTvQAcGoFiUvc+AAs+H2ZAytYt3T0KoBF4TTh8T1CkHC8T9DNYSNwcdS6dxMkMZ+Gf8+uYD/nAzea2VqCL0pVuWp5Q7j/Lwm+MD2WwDqnEfT9L3/1dD7BOXqC4L6ZFmFspa4j6Db0FcHN5re7+6tViFXquUrqqpEE99PkE3STeszKXv2vN1RfxaX6Kr649RXBRbUvCP6XjwP3hg8IkrL7CbqmfkPw3jvC3eO1IKezvnooPI6RBD+J8gvBOcLdv3f3b0sfYfmV7l563BUds6SIlfseUSdY8ENyL7p7TzNrCXzq7nGTKjMbF5afGE6PBAa5+7nh9D+BNxJpEhcREUlEonWVmc0nuAF+aTi9BNjX3b9Pa8AiIpKQOn8FzN3XAF+a2fEAYZNozBsUo/wXGBI2oW4LDAnniYiIpFwlddXXBPdVYGbdCUY0W5GRQEVEpFJ1rgXLzCYQDMXalqA/9HXA6wRDjbYnuEHxSXe/0cz2ImhK35bgxtlvS29kNbMzCX6jAYIbPMem8zhERKTuqmJdtTtBl6DmBN3Vr3L3KZmIW0REKlfnEiwREREREZFMqfNdBEVERERERNIlkR+wqzXatm3rnTt3znQYIiKShFmzZq1093aZjqOmqK4SEakb4tVXdSrB6ty5MzNnzsx0GCIikgQz+yrTMdQk1VUiInVDvPpKXQRFRERERERSRAmWiIiIiIhIiijBEhERERERSZE6dQ+WiIiIiEi6bN68mcLCQjZs2JDpUKQGNW7cmPz8fPLy8hIqrwRLRERERKQaCgsLadGiBZ07d8bMMh2O1AB3Z9WqVRQWFtKlS5eE1lEXQRERERGRatiwYQNt2rRRclWHmRlt2rSpUiulEiwRERERkWpSclX3VfV/rARLREREREQkRWoswTKzDmY2zcwWmtl8M7skRpkrzWx2+JhnZsVm1jpcdpiZfWpmi81sVE3FKSIiIiJSWzVv3nyreaNHj+bRRx/NQDTZZdiwYfz4449p329NDnJRBPzR3T8ysxbALDN7zd0XlBZw99uB2wHM7CjgMndfbWa5wP3Ar4FC4EMzmxy9bsoVToZ3T4PNP0GL3eCohTW2KxEREcmAwsmwfAq0HwL5wzMdjUiNOe+882p0++6Ou5OTE7utpri4mNzc3Gpvv6ioiAYNkk9TXn755aS3UR01lmC5+3Jgefh8rZktBHYE4iVJI4EJ4fO9gcXuvgTAzJ4Ejq5g3eQUTobpR2+ZXrsIxpfva9kAchpASfQNbgZ4kjvPAUqqUNbD/YbrNNgGdjsfFt4NJT9XvG5uEyiOUcYagOVAyaYqxlPDOoyAA5/OdBQiIlIXFE6GGSOheD0sGQsDJijJkpS64YX5LFi2JqXb3H2Hllx3VI8qr3f99dfTvHlzrrjiCgYNGsQ+++zDtGnT+PHHH3n44Yc58MADKS4uZtSoUbzxxhts3LiRCy64gHPPPZd169Zx9NFH88MPP7B582Zuuukmjj76aAoKCjj88MM5+OCDeffdd3nuuefo1KlTZJ+dO3fmzDPPZMqUKVx44YW0bt2a6667jo0bN7LzzjszduxYmjdvzssvv8zll19O27Zt6devH0uWLOHFF1/k+uuvZ9myZRQUFNC2bVvuvvtuzjvvPL7++msA7rrrLgYMGMCbb77JJZcEHePMjOnTp7Nu3TpOOOEE1qxZQ1FREQ8++CAHHnggnTt3ZubMmbRt25Y777yTRx55BICzzjqLSy+9NHJMBxxwAO+88w477rgjzz//PE2aNEnq/5aWYdrNrDOwB/B+nOVNgcOAC8NZOwJLo4oUAvvEWfcc4ByAjh07Vi/A5VP4qbgZh376ICuKWldvG1FyKSbXimlgxawvSe4fVH67DayIhlZEXvhoYEXkzSsmz26LzGtoReTlFNGALc/zbDMNrJiGpetEtrM5sl6eFZebLqKBFYdly86PfjQMtx1rWVL3fS6dGCPRrSJrGPz1IsokpQBFP8ZYIVaCWXp1JhWJZ2mSXJqYW/CwBmC5ULKZoPE3Wuk5iErmrUHwaLIj5OTB2s/D7eSAF7Ml+Q//NmgWXCDYtDos1xB8U9S2iYrhly3z2u4PQ2ak4LhFRDJs+ZQguYLg7/IpSrCk3igqKuKDDz7g5Zdf5oYbbmDq1Kk8/PDDtGrVig8//JCNGzcyYMAAhgwZQocOHZg0aRItW7Zk5cqV7LvvvgwfHrxXPv30U8aOHcsDDzwQcz+NGzfm7bffZuXKlRx33HFMnTqVZs2a8fe//50777yTq666inPPPZfp06fTpUsXRo4cWWb9WbNm8fbbb9OkSRNOOukkLrvsMg444AC+/vprhg4dysKFC7njjju4//77GTBgAOvWraNx48aMGTOGoUOHcu2111JcXMz69eu32u7YsWN5//33cXf22WcfDjroILbddls+//xzJkyYwEMPPcRvf/tbnnnmGX73u98ldb5rPMEys+bAM8Cl7h4vrT8KmOHuq0tXi1EmZlORu48BxgD079+/es1J7Yewfv6TKUmuAIrJpdhz2ZRs41ac7W70RqndsNRquUQnxsWRxHtLIr4luS5NtqMT6siyWEn090U0XHgsDczJs41bJeGRhD3HycuBhrmQ13wHGuQ2IG/tgmC+baJh8VrycjbQgOItiXfD1lC8KUjsitYRJJY50GLX4MuP5UHDbWDzj7BhBRRvCJPCRGVRaywGOY3BN4fJfrllTXYIzsOGlVEt0bnQrDPseae+BIqkQvshQctV8XrIbRpMi6RQdVqa0uW4444DYM8996SgoACAKVOmMGfOHCZOnAjATz/9xOeff05+fj7XXHMN06dPJycnh2+++YbvvvsOgE6dOrHvvvvG3c8JJ5wAwHvvvceCBQsYMGAAAJs2bWK//fZj0aJF7LTTTpHfkxo5ciRjxoyJrD98+PBI69HUqVNZsGBL57U1a9awdu1aBgwYwOWXX87JJ5/McccdR35+PnvttRdnnnkmmzdv5phjjqFv375l4nr77bc59thjadasWeR8vPXWWwwfPpwuXbpEykefn2TUaIJlZnkEydUT7v5sBUVPZEv3QAharDpETecDy1IfYenWh9N+j3MpaHhk0ptyh2JyKPLSZKghG0oastkbsNkbUOS5bPYGbPK8yLytH3ls9lyKwulNMZaVPt/kDdhc0oAiGpSZv7kkWC/YX16Z7QTb3VK2mOr3kZXMK028N6Q4oZcs8S7AS1VeLZdi8nKKy7Qy/yrvB/ZoXkCuFdEgrxm52+9Pg1a7krvuMxp8/zq5m1fToEEeuSVryS3+mRwroUFUi3zuVtPFNKCYHINccxqwiR5NC2nc82Loc3PKT4VIUvKHB90CdQ+W1EONGgUX53NzcykqCi70uTv33nsvQ4cOLVN23LhxrFixglmzZpGXl0fnzp0jvwFVmqDEU7rc3fn1r3/NhAkTyiz/+OOPE1ofoKSkhHfffXer7nqjRo3iiCOO4OWXX2bfffdl6tSpDBw4kOnTp/PSSy9xyimncOWVV3LqqadG1nGP/yWp9NxAcH5++eWXuGUTVWMJlgUDxj8MLHT3Oyso1wo4CIhui/sQ6GpmXYBvCBKwk2oqViD4MtBmH3j/XNj4bYwCid2DZQYNKKGBlQCbaUZlP0qme7DqgxK3SHJdlUdpIr4lUS6bXBeVT7bDBLpMcl2abNMg8nzzVmWj9xn8LVHiXasVk0txSS4baBiZ993m1nyyfucthQoBFhO87w9NyX67Nf6SV+2iYEJJlmSb/OFKrERCQ4cO5cEHH+SQQw4hLy+Pzz77jB133JGffvqJ7bbbjry8PKZNm8ZXX31V5W3vu+++XHDBBSxevJhddtmF9evXU1hYSLdu3ViyZAkFBQV07tyZ//znP3G3MWTIEO677z6uvPJKAGbPnk3fvn354osv6NWrF7169eLdd99l0aJFNGnShB133JGzzz6bn3/+mY8++qhMgjVw4EBOP/10Ro0ahbszadIkHnvssaqftATVZAvWAOAUYK6ZzQ7nXQN0BHD30eG8Y4Ep7h755u/uRWZ2IfBfIBd4xN3n12Csgdr8wVuXvshMyodfvknNtrLkHqwccxpaEQ0pATZSa+7BkhpV4hajtTovZjIenWxHt4CXb5Eu0+Jd0oDNbHneJGcjnRotp9hzg1Z2cihquAPFG1aG0+F8z6GYHIrD50VhK+mWMjllpos9h5Kw5f7a9g8HB1c4uW59LomIZKn169eTn58fmb788ssTWu+ss86ioKCAfv364e60a9eO5557jpNPPpmjjjqK/v3707dvX7p161blmNq1a8e4ceMYOXIkGzduBOCmm25i11135YEHHuCwww6jbdu27L333nG3cc8993DBBRfQu3dvioqKGDhwIKNHj+auu+5i2rRp5Obmsvvuu3P44Yfz5JNPcvvtt5OXl0fz5s23GqK+X79+nH766ZH9nXXWWeyxxx4p6Q4Yi1XUZFbb9O/f32fOnJnpMERqv8LJMPfGIHEr2Rwn8YtiDYJ7pnLyoGVXyGkEP8wJ5lMCReu3Xl/3YG1ZFvMerFSMUlpZWA1g96tgwW0x4kpSj2uqnWCZ2Sx375/agLKH6iqRumPhwoV0794902HUKuvWraN58+a4OxdccAFdu3blsssuy3RYlYr1v45XX6VlFEERqWVqc2tuXfLJtfDl47B5TfAbfXiQvOY0gtxGsN1B0Hh7aNgKNv0U/F3237BFE2jULvi7cUWQJOfkBTf3UwxNO0KvvwT/5zb7BAn1z19DXkvYtCpIbGOKlfjlhK2nRUHr6O5XqPVKRERieuihh/j3v//Npk2b2GOPPTj33HMzHVLKqQVLRESyilqwRKS2UAtW/VGVFqzYP78sIiIiIiIiVaYES0REREREJEWUYImIiIiIiKSIEiwREREREZEUUYIlIiIiIiJV8uOPP/LAAw9EppctW8aIESMyGFH2UIIlIiIiIlLPFBUVVThdmfIJ1g477MDEiRNTElttpwRLRERERCRdCifDhxcGf1Pk0UcfpXfv3vTp04dTTjmFr776isGDB9O7d28GDx7M119/DcDpp5/O5ZdfzsEHH8yf/vSnraa/+OILDjvsMPbcc08OPPBAFi1aBMB3333HscceS58+fejTpw/vvPMOo0aN4osvvqBv375ceeWVFBQU0LNnTwA2bNjAGWecQa9evdhjjz2YNm0aAOPGjeO4447jsMMOo2vXrlx11VUpOwfZRD80LCIiIiKSDoWTYcZIKF4PS8bCgAnBD74nYf78+dx8883MmDGDtm3bsnr1ak477TROPfVUTjvtNB555BEuvvhinnvuOQA+++wzpk6dSm5uLqeffnqZ6cGDBzN69Gi6du3K+++/z/nnn8/rr7/OxRdfzEEHHcSkSZMoLi5m3bp13HrrrcybN4/Zs2cDUFBQEInp/vvvB2Du3LksWrSIIUOG8NlnnwEwe/ZsPv74Yxo1asRuu+3GRRddRIcOHZI6B9lGCZaIiIiISDosnxIkVxD8XT4l6QTr9ddfZ8SIEbRt2xaA1q1b8+677/Lss88CcMopp5RpKTr++OPJzc3danrdunW88847HH/88ZFlGzdujOzj0UcfBSA3N5dWrVrxww8/xI3p7bff5qKLLgKgW7dudOrUKZJgDR48mFatWgGw++6789VXXynBEhERqS/M7DDgbiAX+Je731pu+SDgeeDLcNaz7n5jOmMUkVqk/ZCg5ap4PeQ2DaaT5O6YWYVlopc3a9aszLLS6ZKSErbZZptIi1SyMcXTqFGjyPPc3Nwq3/tVG+geLBERkRjMLBe4Hzgc2B0YaWa7xyj6lrv3DR9KrkQkvvzhQbfArhekpHsgBC1CTz31FKtWrQJg9erV7L///jz55JMAPPHEExxwwAGVbqdly5Z06dKFp59+GgiSpE8++SSyjwcffBCA4uJi1qxZQ4sWLVi7dm3MbQ0cOJAnnngCCLokfv311+y2227JHWgtogRLREQktr2Bxe6+xN03AU8CR2c4JhGp7fKHw173pSS5AujRowfXXnstBx10EH369OHyyy/nnnvuYezYsfTu3ZvHHnuMu+++O6FtPfHEEzz88MP06dOHHj168PzzzwNw9913M23aNHr16sWee+7J/PnzadOmDQMGDKBnz55ceeWVZbZz/vnnU1xcTK9evTjhhBMYN25cmZarus4qasKrbfr37+8zZ87MdBgiIpIEM5vl7v2zII4RwGHuflY4fQqwj7tfGFVmEPAMUAgsA65w9/kxtnUOcA5Ax44d9/zqq69qPH4RqXkLFy6ke/fumQ5D0iDW/zpefaUWLBERkdhi3dRQ/qrkR0And+8D3As8F2tD7j7G3fu7e/927dqlNkoREckqSrBERERiKwSih7bKJ2ilinD3Ne6+Lnz+MpBnZm3TF6KIiGQbJVgiIiKxfQh0NbMuZtYQOBEo88ugZvYrC4fnMrO9CerVVWmPVEQypi7dbiOxVfV/rGHaRUREYnD3IjO7EPgvwTDtj7j7fDM7L1w+GhgB/MHMioBfgBNd37ZE6o3GjRuzatUq2rRpU+lQ6VI7uTurVq2icePGCa+jBEtERCSOsNvfy+XmjY56fh9wX7rjEpHskJ+fT2FhIStWrMh0KFKDGjduTH5+fsLllWCJiIiIiFRDXl4eXbp0yXQYkmV0D5aIiIiIiEiKKMESERERERFJESVYIiIiIiIiKaIES0REREREJEWUYImIiIiIiKSIEiwREREREZEUUYIlIiIiIiKSIkqwREREREREUkQJloiIiIiISIoowRIREREREUkRJVgiIiIiIiIpogRLREREREQkRZRgiYiIiIiIpIgSLBERERERkRRRgiUiIiIiIpIiSrBERERERERSRAmWiIiIiIhIiijBEhERERERSZEaS7DMrIOZTTOzhWY238wuiVNukJnNDsu8GTX/EjObF86/tKbiFBERERERSZUGNbjtIuCP7v6RmbUAZpnZa+6+oLSAmW0DPAAc5u5fm9l24fyewNnA3sAm4FUze8ndP6/BeEVERERERJJSYy1Y7r7c3T8Kn68FFgI7lit2EvCsu38dlvs+nN8deM/d17t7EfAmcGxNxSoiIiIiIpIKabkHy8w6A3sA75dbtCuwrZm9YWazzOzUcP48YKCZtTGzpsAwoEM6YhUREREREamumuwiCICZNQeeAS519zUx9r8nMBhoArxrZu+5+0Iz+zvwGrAO+ISgy2Gs7Z8DnAPQsWPHmjkIERERERGRBNRoC5aZ5REkV0+4+7MxihQCr7r7z+6+EpgO9AFw94fdvZ+7DwRWAzHvv3L3Me7e3937t2vXrmYOREREREREJAE1OYqgAQ8DC939zjjFngcONLMGYVfAfQju1SJqwIuOwHHAhJqKVUREREREJBVqsovgAOAUYK6ZzQ7nXQN0BHD30WFXwFeBOUAJ8C93nxeWfcbM2gCbgQvc/YcajFVERERERCRpNZZgufvbgCVQ7nbg9hjzD6yJuERERERERGpKWkYRFBERERERqQ+UYImIiIiIiKSIEiwREREREZEUUYIlIiIiIiKSIkqwREREREREUkQJloiIiIiISIoowRIREREREUkRJVgiIiIiIiIpogRLREREREQkRZRgiYiIiIiIpIgSLBERERERkRRRgiUiIiIiIpIiSrBERERERERSRAmWiIiIiIhIiijBEhERERERSRElWCIiIiIiIimiBEtERERERCRFlGCJiIiIiIikSIPKCpjZdsAAYAfgF2AeMNPdS2o4NhERkUqpnhIRkWwSN8Eys4OBUUBr4GPge6AxcAyws5lNBP7h7mvSEKeIiEgZqqdERCQbVdSCNQw4292/Lr/AzBoARwK/Bp6podhE5P+3d+/xVtV1wsc/X48oxkVTsDExwR7zLqgnxVDUofDS5O3RTMtL1qiTlkppTj7zpL3qmRobJ+9GmZfGtFJRKzKkUMLUBCVBwGvIEIyipoiocfk+f+wFczyec9jnsPfZ68Dn/Xrt117rt397re9euM/X716/9VuSOmKekiSVTrsFVmae18Fry4E76xGQJEnVME9JkspojZNcRMTZEdE/Kq6LiEcjYnR3BCdJ0pqYpyRJZVLNLIKnFuPXRwMDgc8C365rVJIkVc88JUkqjWoKrCieDwOuz8w/tWiTJKnRzFOSpNKopsCaFhETqCSu30REP8CpbyVJZWGekiSVxhrvgwV8DhgGPJeZSyNiCyrDLyRJKgPzlCSpNNZYYGXmyoh4Adi5mPZWkqTSqGeeiohDgMuAJuCHmfntVq9H8fphwFLglMx8tJYxSJJ6ljUmooj4DnAcMAtYUTQnMLmOcUmSVJV65amIaAKuonIvrfnAIxFxd2bOatHtUGD74rEPcE3xXD8/8fIySaqZE7Lmm6zml74jgR0y8+2a712SpLV3JPXJU3sDz2TmcwARcStwBJVCbpUjgJsyM4GHImKziNgqMxfWOJaKnwQn//ki7n+9uS6bl6T1xT9sOpkrt/23yo9WNS6yqpnk4jmgV033KklS7dQrT20N/FeL9flFW2f7EBGnRcTUiJi6aNGitQpq3z4z1ur9kiT4SN8/1W3b1ZzBWgpMj4jfAqt/HczML9UtKkmSqlevPNXWWLzWP3NW04fMHAuMBWhubl6rn0rP2PJ2ztjy9rXZhCSpjqopsO4uHpIklVG98tR8YJsW64OABV3oUzsnpNdgSVItNeIarMy8seZ7lSSpRuqYpx4Bto+IIcBfgE8BJ7TqczdwVnF91j7Aa3W7/mqVOvzPgCSpdtq9BisifhERn4iId41rj4jtIuIbEXFqfcOTJKlt9c5TmbkcOAv4DTAb+FlmPhERZ0TEGUW38VSuAXsG+AHwha7uT5K0bujoDNY/AmOA70XEK8AioDcwhEoiuTIz76p/iJIktanueSozx1Mpolq2XdtiOYEz12YfkqR1S7sFVmb+N3A+cH5EDAa2At4EnsrMpd0TniRJbTNPSZLKqKo73mfmXGBuXSORJKmLzFOSpLKo5j5YkiRJkqQq1K3AiohtImJSRMyOiCci4ux2+h0YEdOLPve3aD+3aJsZEbdERO96xSpJkiRJtVDPM1jLgS9n5k7AcODMiNi5ZYeI2Ay4Gjg8M3cBji3atwa+BDRn5q5AE5XpcSVJkiSptNZ4DVZEjAAuArYt+geViZO26+h9xX1AFhbLr0fEbGBrYFaLbicAd2TmvKLfi61i2yQilgHvoZ43bpQk9VhdzVOSJNVDNZNcXAecC0wDVnRlJ8XsTnsAD7d66UNAr4i4D+gHXJaZN2XmXyLiu8A8KjNCTcjMCV3ZtyRpnbfWeUqSpFqppsB6LTN/3dUdRERf4HbgnMxc3Mb+9wJGAZsAD0bEQ1TuZXIElXuZvAr8PCI+k5n/2cb2TwNOA/jABz7Q1TAlST3XWuUpSZJqqZoCa1JEXALcAby9qjEzH13TGyOiF5Xi6ubMvKONLvOBlzLzDeCNiJgMDC1e+3NmLiq2cwfwEeBdBVZmjgXGAjQ3N2cVn0eStG7pcp6SJKnWqimw9imem1u0JfD3Hb0pIoLKsI3ZmXlpO93uAq6MiA2BjYp9/QfQBxgeEe+hMkRwFDC1ilglSeufLuUpSZLqYY0FVmYe1MVtjwBOBGZExPSi7WvAB4rtXpuZsyPiHuBxYCXww8ycCRARtwGPUpmN8DGKs1SSJLW0FnlKkqSaq2YWwU2BrwMji6b7gW9k5msdvS8zp1CZyalDmXkJcEkb7V8v9itJUru6mqckSaqHau6D9SPgdeCTxWMxcH09g5IkqRPMU5Kk0qjmGqwPZub/brF+cYshf5IkNZp5SpJUGtWcwXozIvZbtVLc0PHN+oUkSVKnmKckSaVRzRmsfwJuLMa4B/AKcEo9g5IkqRPMU5Kk0qhmFsHpwNCI6F+st75ZsCRJDWOekiSVSbsFVkR8JjP/MyLGtGoHoIN7W0mSVHfmKUlSGXV0BqtP8dyvjdeyDrFIktQZ5ilJUum0W2Bl5veLxYmZ+UDL14oLiCVJahjzlCSpjKqZRfCKKtskSWoE85QkqTQ6ugZrX+AjwMBW49v7A031DkySpI6YpyRJZdTRNVgbAX2LPi3Hty8GjqlnUJIkVcE8JUkqnY6uwbofuD8ibsjM57sxJkmS1sg8JUkqo2quwfphRGy2aiUi3hsRv6lfSJIkdYp5SpJUGtUUWAMy89VVK5n5V2DLukUkSVLnmKckSaVRTYG1MiI+sGolIrbF+4tIksrDPCVJKo2OJrlY5UJgSkTcX6yPBE6rX0iSJHWKeUqSVBprLLAy856I2BMYDgRwbma+VPfIJEmqgnlKklQmaxwiGBEBHALsmZm/AN4TEXvXPTJJkqpgnpIklUk112BdDewLHF+svw5cVbeIJEnqHPOUJKk0qrkGa5/M3DMiHoPK7EwRsVGd45IkqVrmKUlSaVRzBmtZRDRRzMgUEQOBlXWNSpKk6pmnJEmlUU2BdTkwDtgyIr4FTAH+X12jkiSpeuYpSVJpdDhEMCI2AP4MnA+MojI705GZObsbYpMkqUPmKUlS2XRYYGXmyoj498zcF5jTTTFJklQV85QkqWyqGSI4ISL+dzENriRJZWOekiSVRjWzCI4B+gDLI+ItKsMvMjP71zUySZKqY56SJJVGNddgHZKZD3RTPJIkVc08JUkqmw6HCGbmSuC73RSLJEmdYp6SJJWN12BJkno685QkqTQ6cw3Wioh4E8e2S5LKxTwlSSqNNRZYmdmvOwKRJKkrzFOSpDKp5gwWEXE4MLJYvS8zf1m/kCRJ6hzzlCSpLNZ4DVZEfBs4G5hVPM4u2iRJajjzlCSpTKo5g3UYMKyYqYmIuBF4DLignoFJklQl85QkqTSqmUUQYLMWy5vWIQ5JktbGZi2WzVOSpIap5gzWvwKPRcQkKjMzjQT+ua5RSZJUPfOUJKk0qplF8JaIuA/4MJXE9dXM/O96ByZJUjXMU5KkMqlmkoujgKWZeXdm3gW8FRFH1j0ySZKqYJ6SJJVJNddgfT0zX1u1kpmvAl+vW0SSJHWOeUqSVBrVFFht9anq/lmSJHUD85QkqTSqKbCmRsSlEfHBiNguIv4DmLamN0XENhExKSJmR8QTEXF2O/0OjIjpRZ/7i7YdirZVj8URcU6nPpkkaX3RpTwlSVI9VFNgfRH4G/BT4GfAm8CZVbxvOfDlzNwJGA6cGRE7t+wQEZsBVwOHZ+YuwLEAmflkZg7LzGHAXsBSYFw1H0iStN7pap6SJKnmqplF8A26cLPGzFwILCyWX4+I2cDWwKwW3U4A7sjMeUW/F9vY1Cjg2cx8vrMxSJLWfV3NU5Ik1UO1NxpeKxExGNgDeLjVSx8C3hsR90XEtIg4qY23fwq4pYNtnxYRUyNi6qJFi2oWsyRp/RURm0fEvRHxdPH83nb6zY2IGcVw9qndHackqXzqXmBFRF/gduCczFzc6uUNqQwB/DhwMPAvEfGhFu/dCDgc+Hl728/MsZnZnJnNAwcOrHn8kqT10gXAbzNze+C3dHyG7KBiWHtz94QmSSqzuhZYEdGLSnF1c2be0UaX+cA9mflGZr4ETAaGtnj9UODRzHyhnnFKktTKEcCNxfKNwJGNC0WS1JNUc6Ph7SLiFxHxUkS8GBF3RcR2VbwvgOuA2Zl5aTvd7gL2j4gNI+I9wD7A7BavH08HwwMlSepqnlqD9xXXEq+6pnjLdvolMKEY5n5aBzE6nF2S1hPV3CfkJ8BVwFHF+qprovZZw/tGACcCMyJietH2NeADAJl5bWbOjoh7gMeBlcAPM3MmQFFwfQw4vepPI0laH3UpT0XERODv2njpwk7se0RmLoiILYF7I2JOZk5u3SkzxwJjAZqbm7MT25ck9TDVFFiRmT9usf6fEXHWmt6UmVOAqKLfJcAlbbQvBbaoIj5J0vqtq3nqo+1uMOKFiNgqMxdGxFZAW7PckpkLiucXI2IcsDeV4e6SpPVUNddgTYqICyJicERsGxHnA78qZljavN4BSpK0BvXIU3cDJxfLJ1MZ0v4OEdEnIvqtWgZGAzO7uD9J0jqimjNYxxXPrYfqnUpl7PnajnOXJGlt1CNPfRv4WUR8DpgHHAsQEe+nMpz9MOB9wLjKJcdsCPwkM+/pwr4kSeuQam40PKQ7ApEkqSvqkacy82UqN7pv3b4AOKxYfo53znwrSdKaC6yIaKJyn6rBLft3MDOgJEndxjwlSSqTaoYI/gJ4C5hBZaY/SZLKxDwlSSqNagqsQZm5e90jkSSpa8xTkqTSqGYWwV9HxOi6RyJJUteYpyRJpVHNGayHqMyStAGwjMq9rTIz+9c1MkmSqmOekiSVRjUF1r8D+wIzMtO7z0uSysY8JUkqjWqGCD4NzDRpSZJKyjwlSSqNas5gLQTui4hfA2+vanT6W0lSSZinJEmlUU2B9efisVHxkCSpTMxTkqTSWGOBlZkXd0cgkiR1hXlKklQmayywImIgcD6wC9B7VXtm/n0d45IkqSrmKUlSmVQzycXNwBxgCHAxMBd4pI4xSZLUGeYpSVJpVFNgbZGZ1wHLMvP+zDwVGF7nuCRJqpZ5SpJUGtVMcrGseF4YER8HFgCD6heSJEmdYp6SJJVGNQXWNyNiU+DLwBVAf+CcegYlSVInmKckSaVRTYH118x8DXgNOAggIkbUNSpJkqpnnpIklUY112BdUWWbJEmNYJ6SJJVGu2ewImJf4CPAwIgY0+Kl/kBTvQOTJKkj5ilJUhl1NERwI6Bv0adfi/bFwDH1DEqSpCqYpyRJpdNugZWZ9wP3R8QNmfk8QERsAPTNzMXdFaAkSW0xT0mSyqiaa7D+NSL6R0QfYBbwZEScV+e4JEmqlnlKklQa1RRYOxe/BB4JjAc+AJxYz6AkSeoE85QkqTSqKbB6RUQvKonrrsxcBmRdo5IkqXrmKUlSaVRTYH0fmAv0ASZHxLZULiCWJKkMzFOSpNJY442GM/Ny4PIWTc9HxEH1C0mSpOqZpyRJZbLGM1gR8b6IuC4ifl2s7wycXPfIJEmqgnlKklQm1QwRvAH4DfD+Yv0p4Jw6xSNJUmfdgHlKklQS1RRYAzLzZ8BKgMxcDqyoa1SSJFXPPCVJKo1qCqw3ImILihmZImI48Fpdo5IkqXrmKUlSaaxxkgtgDHA38MGIeAAYCBxT16gkSaqeeUqSVBrVzCL4aEQcAOwABPBkcY8RSZIazjwlSSqTNRZYEdEEHAYMLvqPjggy89I6xyZJ0hqZpyRJZVLNEMFfAG8BMyguIJYkqUTMU5Kk0qimwBqUmbvXPRJJkrrGPCVJKo1qZhH8dUSMrnskkiR1jXlKklQa1ZzBeggYFxEbAMuoXECcmdm/rpFJklQd85QkqTSqOYP178C+wHsys39m9qsmaUXENhExKSJmR8QTEXF2O/0OjIjpRZ/7W7RvFhG3RcScYhv7Vv2pJEnrky7lKUmS6qGaM1hPAzMzMzu57eXAl4vpc/sB0yLi3syctapDRGwGXA0ckpnzImLLFu+/DLgnM4+JiI2A93Ry/5Kk9UNX85QkSTVXTYG1ELgvIn4NvL2qcU3T32bmwuK9ZObrETEb2BqY1aLbCcAdmTmv6PciQET0B0YCpxTtfwP+Vt1HkiStZ7qUpyRJqodqhgj+GfgtsBHQr8WjahExGNgDeLjVSx8C3hsR90XEtIg4qWjfDlgEXB8Rj0XEDyOiTzvbPi0ipkbE1EWLFnUmLEnSumGt85QkSbWyxjNYmXnx2uwgIvoCtwPnZObiNva/FzAK2AR4MCIeKtr3BL6YmQ9HxGXABcC/tBHfWGAsQHNzs8NDJGk9s7Z5SpKkWmq3wIqIKzPzrIj4BfCuwiUzD1/TxiOiF5Xi6ubMvKONLvOBlzLzDeCNiJgMDAV+D8zPzFVnvG6jUmBJkgTUJk9JklRrHZ3BOgk4C/huVzYcEQFcB8zuYBz8XcCVEbEhlaEd+wD/kZn/HRH/FRE7ZOaTVM5wzWpnG5Kk9dNa5SlJkuqhowLrWYDMvL+DPh0ZAZwIzIiI6UXb14APFNu9NjNnR8Q9wOPASuCHmTmz6PtF4OZiBsHngM92MQ5J0rppbfOUJEk111GBNTAixrT3YhWzCE6hcrPHDmXmJcAlbbRPB5rX9H5J0nprrfKUJEn10FGB1QT0pYoiSZKkBjBPSZJKp6MCa2FmfqPbIpEkqXPMU5Kk0unoPlj+IihJKjPzlCSpdDoqsEZ1WxSSJHWeeUqSVDrtFliZ+Up3BiJJUmeYpyRJZdTRGSxJkiRJUidYYEmSJElSjVhgSZIkSVKNWGBJkiRJUo1YYEmSJElSjVhgSZLUSkQcGxFPRMTKiGjuoN8hEfFkRDwTERd0Z4ySpHKywJIk6d1mAkcDk9vrEBFNwFXAocDOwPERsXP3hCdJKqsNGx2AJEllk5mzASKio257A89k5nNF31uBI4BZdQ9QklRansGSJKlrtgb+q8X6/KLtXSLitIiYGhFTFy1a1C3BSZIawzNYkqT1UkRMBP6ujZcuzMy7qtlEG23ZVsfMHAuMBWhubm6zjyRp3WCBJUlaL2XmR9dyE/OBbVqsDwIWrOU2JUk9nEMEJUnqmkeA7SNiSERsBHwKuLvBMUmSGswCS5KkViLiqIiYD+wL/CoiflO0vz8ixgNk5nLgLOA3wGzgZ5n5RKNiliSVg0MEJUlqJTPHAePaaF8AHNZifTwwvhtDkySVnGewJEmSJKlGLLAkSZIkqUYssCRJkiSpRiywJEmSJKlGLLAkSZIkqUYssCRJkiSpRiywJEmSJKlGLLAkSZIkqUYssCRJkiSpRiywJEmSJKlGLLAkSZIkqUYssCRJkiSpRiywJEmSJKlGLLAkSZIkqUYssCRJkiSpRiywJEmSJKlGLLAkSZIkqUYssCRJkiSpRiywJEmSJKlGLLAkSZIkqUbqVmBFxDYRMSkiZkfEExFxdjv9DoyI6UWf+1u0z42IGcVrU+sVpyRJkiTVyoZ13PZy4MuZ+WhE9AOmRcS9mTlrVYeI2Ay4GjgkM+dFxJattnFQZr5UxxglSZIkqWbqdgYrMxdm5qPF8uvAbGDrVt1OAO7IzHlFvxfrFY8kSZIk1Vu3XIMVEYOBPYCHW730IeC9EXFfREyLiJNavJbAhKL9tA62fVpETI2IqYsWLap57JIkSZJUrXoOEQQgIvoCtwPnZObiNva/FzAK2AR4MCIeysyngBGZuaAYNnhvRMzJzMmtt5+ZY4GxAM3NzVnPzyJJkiRJHanrGayI6EWluLo5M+9oo8t84J7MfKO41moyMBQgMxcUzy8C44C96xmrJEmSJK2tes4iGMB1wOzMvLSdbncB+0fEhhHxHmAfYHZE9CkmxiAi+gCjgZn1ilWSJEmSaqGeQwRHACcCMyJietH2NeADAJl5bWbOjoh7gMeBlcAPM3NmRGwHjKvUaGwI/CQz76ljrJIkSZK01upWYGXmFCCq6HcJcEmrtucohgpKWj8tW7aM+fPn89ZbbzU6FNVJ7969GTRoEL169Wp0KJIk1UzdJ7mQpK6YP38+/fr1Y/DgwRRns7UOyUxefvll5s+fz5AhQxodjiRJNdMt07RLUme99dZbbLHFFhZX66iIYIsttvAMpSRpnWOBJam0LK7Wbf77SpLWRRZYkiRJklQjFliS1I6+ffu+q+3aa6/lpptuakA05XLYYYfx6quvNjoMSZJKx0kuJKkTzjjjjLpuPzPJTDbYoO3fv1asWEFTU1OXt798+XI23HDt//SPHz9+rbchSdK6yAJLUuld/IsnmLVgcU23ufP7+/P1T+zS6fdddNFF9O3bl6985SsceOCB7LPPPkyaNIlXX32V6667jv33358VK1ZwwQUXcN999/H2229z5plncvrpp7NkyRKOOOII/vrXv7Js2TK++c1vcsQRRzB37lwOPfRQDjroIB588EHuvPNOtt1229X7HDx4MKeeeioTJkzgrLPOYvPNN+frX/86b7/9Nh/84Ae5/vrr6du3L+PHj2fMmDEMGDCAPffck+eee45f/vKXXHTRRSxYsIC5c+cyYMAALrvsMs444wzmzZsHwPe+9z1GjBjB/fffz9lnnw1Uro+aPHkyS5Ys4bjjjmPx4sUsX76ca665hv3335/BgwczdepUBgwYwKWXXsqPfvQjAD7/+c9zzjnnrP5M++23H3/4wx/Yeuutueuuu9hkk01q8K8nSVJ5WWBJ0lpYvnw5f/zjHxk/fjwXX3wxEydO5LrrrmPTTTflkUce4e2332bEiBGMHj2abbbZhnHjxtG/f39eeuklhg8fzuGHHw7Ak08+yfXXX8/VV1/d5n569+7NlClTeOmllzj66KOZOHEiffr04Tvf+Q6XXnop559/PqeffjqTJ09myJAhHH/88e94/7Rp05gyZQqbbLIJJ5xwAueeey777bcf8+bN4+CDD2b27Nl897vf5aqrrmLEiBEsWbKE3r17M3bsWA4++GAuvPBCVqxYwdKlS9+13euvv56HH36YzGSfffbhgAMO4L3vfS9PP/00t9xyCz/4wQ/45Cc/ye23385nPvOZ+vxDSJJUEhZYkkqvK2eausvRRx8NwF577cXcuXMBmDBhAo8//ji33XYbAK+99hpPP/00gwYN4mtf+xqTJ09mgw024C9/+QsvvPACANtuuy3Dhw9vdz/HHXccAA899BCzZs1ixIgRAPztb39j3333Zc6cOWy33Xar7yl1/PHHM3bs2NXvP/zww1efPZo4cSKzZs1a/drixYt5/fXXGTFiBGPGjOHTn/40Rx99NIMGDeLDH/4wp556KsuWLePII49k2LBh74hrypQpHHXUUfTp02f18fj973/P4YcfzpAhQ1b3b3l8JElal1lgSdJa2HjjjQFoampi+fLlQOU6qiuuuIKDDz74HX1vuOEGFi1axLRp0+jVqxeDBw9efR+oVQVKe1a9npl87GMf45ZbbnnH64899lhV7wdYuXIlDz744LuG611wwQV8/OMfZ/z48QwfPpyJEycycuRIJk+ezK9+9StOPPFEzjvvPE466aTV78nMdve56thA5fi8+eabHcYoSdK6wFkEJanGDj74YK655hqWLVsGwFNPPcUbb7zBa6+9xpZbbkmvXr2YNGkSzz//fKe3PXz4cB544AGeeeYZAJYuXcpTTz3FjjvuyHPPPbf6LNFPf/rTdrcxevRorrzyytXr06dPB+DZZ59lt91246tf/SrNzc3MmTOH559/ni233JJ//Md/5HOf+xyPPvroO7Y1cuRI7rzzTpYuXcobb7zBuHHj2H///Tv9uSRJWld4BkuS2rF06VIGDRq0en3MmDFVve/zn/88c+fOZc899yQzGThwIHfeeSef/vSn+cQnPkFzczPDhg1jxx137HRMAwcO5IYbbuD444/n7bffBuCb3/wmH/rQh7j66qs55JBDGDBgAHvvvXe727j88ss588wz2X333Vm+fDkjR47k2muv5Xvf+x6TJk2iqamJnXfemUMPPZRbb72VSy65hF69etG3b993TVG/5557csopp6ze3+c//3n22GMPhwNKktZb0dHwjp6mubk5p06d2ugwJNXA7Nmz2WmnnRodRo+yZMkS+vbtS2Zy5plnsv3223Puuec2OqwOtfXvHBHTMrO5QSHVnblKktYN7eUrhwhK0jriBz/4AcOGDWOXXXbhtdde4/TTT290SJIkrXccIihJ64hzzz239GesJEla13kGS5IkSZJqxAJLkiRJkmrEAkuSJEmSasQCS5IkSZJqxAJLkkrk1Vdf5eqrr169vmDBAo455pgGRiRJkjrDAkuSamj58uUdrq9J6wLr/e9/P7fddltNYpMkSfVngVVr8++GR86qPEvqXjX+/t10003svvvuDB06lBNPPJHnn3+eUaNGsfvuuzNq1CjmzZsHwCmnnMKYMWM46KCD+OpXv/qu9WeffZZDDjmEvfbai/333585c+YA8MILL3DUUUcxdOhQhg4dyh/+8AcuuOACnn32WYYNG8Z5553H3Llz2XXXXQF46623+OxnP8tuu+3GHnvswaRJkwC44YYbOProoznkkEPYfvvtOf/882vy+aV1knlaUp15H6xamn83PHA8rFgKz10PI26BQYc3Oipp/VDj798TTzzBt771LR544AEGDBjAK6+8wsknn8xJJ53EySefzI9+9CO+9KUvceeddwLw1FNPMXHiRJqamjjllFPesT5q1CiuvfZatt9+ex5++GG+8IUv8Lvf/Y4vfelLHHDAAYwbN44VK1awZMkSvv3tbzNz5kymT58OwNy5c1fHdNVVVwEwY8YM5syZw+jRo3nqqacAmD59Oo899hgbb7wxO+ywA1/84hfZZpttuvz5pXWSeVpSN/AMVi0tnFD5ow2V54UTGhuPtD6p8ffvd7/7HccccwwDBgwAYPPNN+fBBx/khBNOAODEE09kypQpq/sfe+yxNDU1vWt9yZIl/OEPf+DYY49l2LBhnH766SxcuHD1Pv7pn/4JgKamJjbddNMOY5oyZQonnngiADvuuCPbbrvt6gJr1KhRbLrppvTu3Zudd96Z559/fq0+v7ROMk9L6gaewaqlrUZXfhFbsRSa3lNZl9Q9avz9y0wiosM+LV/v06fPO15btb5y5Uo222yz1Wek1jam9my88carl5uamjp97Ze0XjBPS+oGnsGqpUGHV4YbbH+mww6k7lbj79+oUaP42c9+xssvvwzAK6+8wkc+8hFuvfVWAG6++Wb222+/NW6nf//+DBkyhJ///OdApUj605/+tHof11xzDQArVqxg8eLF9OvXj9dff73NbY0cOZKbb74ZqAxJnDdvHjvssMNafU5pvWKeltQNLLBqbdDh8OEr/aMtNUINv3+77LILF154IQcccABDhw5lzJgxXH755Vx//fXsvvvu/PjHP+ayyy6rals333wz1113HUOHDmWXXXbhrrvuAuCyyy5j0qRJ7Lbbbuy111488cQTbLHFFowYMYJdd92V88477x3b+cIXvsCKFSvYbbfdOO6447jhhhveceZKtRMRx0bEExGxMiKaO+g3NyJmRMT0iJjanTGqi8zTkuosOhpy0tM0Nzfn1KnmN2ldMHv2bHbaaadGh6E6a+vfOSKmZWa7RU13iIidgJXA94GvZGabySUi5gLNmflStds2V0nSuqG9fOU1WJIktZKZs4E1XocnSVJrDhGUJKnrEpgQEdMi4rT2OkXEaRExNSKmLlq0qBvDkyR1N89gSSqtambyU8/V6CHqETER+Ls2XrowM++qcjMjMnNBRGwJ3BsRczJzcutOmTkWGAuVIYJdDlqSVHoWWJJKqXfv3rz88stsscUWFlnroMzk5Zdfpnfv3o2M4aM12MaC4vnFiBgH7A28q8CSJK0/LLAkldKgQYOYP38+Dqdad/Xu3ZtBgwY1Oowui4g+wAaZ+XqxPBr4RoPDkiQ1mAWWpFLq1asXQ4YMaXQYWk9FxFHAFcBA4FcRMT0zD46I9wM/zMzDgPcB44ozrBsCP8nMexoWtCSpFCywJElqJTPHAePaaF8AHFYsPwcM7ebQJEkl5yyCkiRJklQjFliSJEmSVCPR6GlyaykiFgHPr8UmBgAv1Sic7mbsjWHsjWHsjdFdsW+bmQO7YT8NUYNcBf531CjG3hjG3v16atzQvbG3ma/WqQJrbUXE1MxsbnQcXWHsjWHsjWHsjdGTY1/X9OR/C2NvDGNvjJ4ae0+NG8oRu0MEJUmSJKlGLLAkSZIkqUYssN5pbKMDWAvG3hjG3hjG3hg9OfZ1TU/+tzD2xjD2xuipsffUuKEEsXsNliRJkiTViGewJEmSJKlGLLAkSZIkqUYssAoRcUhEPBkRz0TEBY2Opy0RMTciZkTE9IiYWrRtHhH3RsTTxfN7W/T/5+LzPBkRB3dzrD+KiBcjYmaLtk7HGhF7FZ/5mYi4PCKiQbFfFBF/KY799Ig4rGyxR8Q2ETEpImZHxBMRcXbRXvrj3kHsPeG4946IP0bEn4rYLy7ae8Jxby/20h/39VWYq2odq7mqMbGbr7o59g7+3veEY97zclVmrvcPoAl4FtgO2Aj4E7Bzo+NqI865wIBWbf8GXFAsXwB8p1jeufgcGwNDis/X1I2xjgT2BGauTazAH4F9gQB+DRzaoNgvAr7SRt/SxA5sBexZLPcDniriK/1x7yD2nnDcA+hbLPcCHgaG95Dj3l7spT/u6+MDc1U9YjVXNSZ281U3x465qltj9wxWxd7AM5n5XGb+DbgVOKLBMVXrCODGYvlG4MgW7bdm5tuZ+WfgGSqfs1tk5mTglVbNnYo1IrYC+mfmg1n5VtzU4j3dHXt7ShN7Zi7MzEeL5deB2cDW9IDj3kHs7SlT7JmZS4rVXsUj6RnHvb3Y21Oa2NdT5qoaM1c1LHbzVTfHbq7q3tgtsCq2Bv6rxfp8Ov6yNEoCEyJiWkScVrS9LzMXQuVLD2xZtJfxM3U21q2L5dbtjXJWRDxeDMtYdQq9lLFHxGBgDyq/8vSo494qdugBxz0imiJiOvAicG9m9pjj3k7s0AOO+3qojH/X22KuMldVzXz1rvZ6xmuu6qbYLbAq2hp/Wcb560dk5p7AocCZETGyg7495TNB+7GW6TNcA3wQGAYsBP69aC9d7BHRF7gdOCczF3fUtY22ssXeI457Zq7IzGHAICq/ku3aQfeeEHuPOO7roZ5ynM1V5qqqmK/abK8bc1X3xW6BVTEf2KbF+iBgQYNiaVdmLiieXwTGURlG8UJxypPi+cWiexk/U2djnV8st27vdpn5QvHlXgn8gP8ZwlKq2COiF5U/+Ddn5h1Fc4847m3F3lOO+yqZ+SpwH3AIPeS4r9Iy9p523NcjZfy7/i7mKnNVNcxXjTv25qp3tdecBVbFI8D2ETEkIjYCPgXc3eCY3iEi+kREv1XLwGhgJpU4Ty66nQzcVSzfDXwqIjaOiCHA9lQu7GukTsVanKp+PSKGF7O8nNTiPd1q1R+fwlFUjj2UKPZiP9cBszPz0hYvlf64txd7DznuAyNis2J5E+CjwBx6xnFvM/aecNzXU+aq7lH67257esp313zV/bGbq7o59qzjrB896QEcRmUmmGeBCxsdTxvxbUdlRpQ/AU+sihHYAvgt8HTxvHmL91xYfJ4n6eYZvYBbqJyuXUblF4PPdSVWoJnKF+ZZ4EogGhT7j4EZwONUvrhblS12YD8qp7ofB6YXj8N6wnHvIPaecNx3Bx4rYpwJ/N+ivScc9/ZiL/1xX18fmKtqHa+5qjGxm6+6OXbMVd0aexQ7kyRJkiStJYcISpIkSVKNWGBJkiRJUo1YYEmSJElSjVhgSZIkSVKNWGBJkiRJUo1YYGm9FhFbRMT04vHfEfGXYnlJRFzdjXEcGBEf6a79rY2I+F5EjOzg9bMi4rPdGZMkrevMV51nvlKjOE27VIiIi4AlmfnddWHfxU30Iit3OO/qNpoyc0WL9c2B8Zk5vIP3vAd4IDP36Op+JUntM1+1uQ3zlUrDM1hSG4pf6H5ZLF8UETdGxISImBsRR0fEv0XEjIi4JyJ6Ff32ioj7I2JaRPym1R3GV233ExHxcEQ8FhETI+J9ETEYOAM4t/g1cv9W7zmgxa+Wj0VEv6L9vIh4JCIej4iLi7bBETG7+DXzUeBfIuLfWmzrlIi4olj+TET8sdju9yOiqWhfEhHfiIiHgX1bfYRjgHtabO/bETGriOG7AJm5FJgbEXuvxT+BJKkK5ivzlcrHAkuqzgeBjwNHAP8JTMrM3YA3gY8XSesK4JjM3Av4EfCtNrYzBRhe/Fp2K3B+Zs4FrgX+IzOHZebvW73nK8CZmTkM2B94MyJGA9sDewPDgL3if4ZB7ADcVOzjauDoFts6DvhpROxULI8otrsC+HTRpw8wMzP3ycwprWIZAUyD1b8OHgXskpm7A99s0W9qEaskqXuZryrMV2qYDRsdgNRD/Dozl0XEDKCJ//lVbAYwmEqS2BW4tzLSgSZgYRvbGUQlYWwFbAT8uYp9PwBcGhE3A3dk5vwiYY0GHiv69KWSwOYBz2fmQwCZuSginouI4cDTRZwPAGcCewGPFPFuArxYbGsFcHs7sWwFLCqWFwNvAT+MiF8Bv2zR70Vgxyo+mySptsxXFeYrNYwFllSdtwEyc2VELMv/uXhxJZXvUQBPZGbrIQqtXQFcmpl3R8SBwEVr2nFmfrtICIcBD0XER4v9/Wtmfr9l32L4xhutNvFT4JPAHGBcZmZUstSNmfnPbezyrZbj2Ft5E+hdxLW8GFYxCvgUcBbw90W/3kVfSVL3Ml9VmK/UMA4RlGrjSWBgROwLEBG9ImKXNvptCvylWD65RfvrQL+2NhwRH8zMGZn5HSpDGXYEfgOcGhF9iz5bR8SW7cR2B3AkcDyV5AXwW+CYVe+JiM0jYtsqPuds4H8V7+kLbJqZ44FzqAz9WOVDwMwqtidJ6l7mK/OV6swCS6qBzPwblQtqvxMRfwKmA21NY3sR8POI+D3wUov2XwBHtXXRMHBORMwstvsmleEfE4CfAA8Ww0Buo52El5l/BWYB22bmH4u2WcD/ASZExOPAvVSGU6zJr4ADi+V+wC+L998PnNui3whgYhXbkyR1I/OV+Ur15zTtkjolIqYA/5CZr7bz+h7AmMw8sVsDkySpBfOVGsUCS1KnRMQ+wJuZ+Xg7r38MeLqYbUqSpIYwX6lRLLAkSZIkqUa8BkuSJEmSasQCS5IkSZJqxAJLkiRJkmrEAkuSJEmSasQCS5IkSZJq5P8DeRv4CeuM0GwAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 864x720 with 4 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "sensor_pairs = [(248, 366), (207, 425), (169, 700), (133, 143)]\n",
    "\n",
    "fig, axes = plt.subplots(2, 2, figsize=(12,10), sharex=False)\n",
    "count = 0\n",
    "\n",
    "for row in range(2):\n",
    "    for col in range(2):\n",
    "        s1, s2 = sensor_pairs[count]\n",
    "        xy = flights.loc[(flights.sensor_0 == s1) & (flights.sensor_1 == s2), ['timeAtServer', 'corr_1']].values\n",
    "\n",
    "        m, b = np.polyfit(xy[:, 0], xy[:, 1], 1)\n",
    "\n",
    "        axes[row, col].scatter(xy[:, 0], xy[:, 1], s=10, c='orange', label='correction')\n",
    "        axes[row, col].plot(xy[:, 0], m * xy[:, 0] + b, label='Linear regression')\n",
    "        axes[row, col].set_title('Correction for sensors: {} and {}'.format(s1, s2))\n",
    "        axes[row, col].set_ylabel('Timestamp correction (ns)')\n",
    "        axes[row, col].set_xlabel('Time at server (s)')\n",
    "        axes[row, col].legend()\n",
    "        \n",
    "        count += 1\n",
    "        \n",
    "plt.tight_layout()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As we can see there are some outliers on the preceding plots, but in general, the linear regression line fits the correction data very well, thus it can be used to estimate the correction that has to be applied to each timestamp measurement."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We will implement a custom function responsible for writing the dataframe into CSV file in the bach manner."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "def pandas_to_csv(df, path, n_chunks=10, chunk_size=None, index=False):\n",
    "    \n",
    "    df_len = len(df)\n",
    "    \n",
    "    if chunk_size:\n",
    "        n_chunks = df_len // chunk_size\n",
    "        \n",
    "    if df_len % (n_chunks) != 0:\n",
    "        chunk_idxs = list(range(0, df_len, df_len//n_chunks)) \n",
    "    else:\n",
    "        chunk_idxs = list(range(0, df_len+1, df_len//n_chunks))\n",
    "        \n",
    "    chunk_idxs[-1] = df_len\n",
    "    \n",
    "    header = True\n",
    "    mode = 'w'\n",
    "    \n",
    "    for start, end in zip(chunk_idxs[:-1], chunk_idxs[1:]):\n",
    "        chunk = df.iloc[start:end]\n",
    "        chunk.to_csv(path, index=index, header=header, mode=mode)\n",
    "        \n",
    "        del chunk\n",
    "        \n",
    "        header = False\n",
    "        mode = 'a'\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "pandas_to_csv(flights, 'round2_training/round2/training3/training3.csv', n_chunks=5, index=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Linear regression models of sensor corrections"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this section, we are going to fit the linear regression models into timestamp correction data of all sensors. There will be a single model for each pair of sensors (reference sensor + sensor_N), that given the current timeAtServer returns the correction value that needs to be applied."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We have to begin by loading the synchronized data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "max_measurements = 6\n",
    "\n",
    "usecols = ['timeAtServer'] + ['sensor_{}'.format(i) for i in range(max_measurements)] + \\\n",
    "    ['corr_{}'.format(i) for i in range(1, max_measurements)]\n",
    "\n",
    "flights = pd.read_csv('round2_training/round2/training3/training3.csv', usecols=usecols)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we will create the dictionary that contains all sensors that make a pair with the reference sensor. The dictionary will also include their corresponding correction and timeAtServer values."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|█████████████████████████████████████████████████████████████████████| 6166940/6166940 [02:10<00:00, 47240.92it/s]\n"
     ]
    }
   ],
   "source": [
    "corr_dict = {}\n",
    "\n",
    "for row in tqdm(flights.itertuples(), total=len(flights)):\n",
    "\n",
    "    s1 = row.sensor_0\n",
    "    timeAtServer = row.timeAtServer\n",
    "    \n",
    "    for i in range(1, max_measurements):\n",
    "        s2 = getattr(row, 'sensor_{}'.format(i))\n",
    "        corr = getattr(row, 'corr_{}'.format(i))\n",
    "        \n",
    "        if np.isnan(s2):\n",
    "            continue\n",
    "            \n",
    "        s1, s2 = int(s1), int(s2)\n",
    "        corr_dict.setdefault('{}_{}'.format(s1, s2), {'TaS': [], 'corr': []})\n",
    "        corr_dict['{}_{}'.format(s1, s2)]['TaS'].append(timeAtServer)\n",
    "        corr_dict['{}_{}'.format(s1, s2)]['corr'].append(corr)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Below we will fit the linear regression models one by one and save their coefficients into a dictionary."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "coeff_dict = {}\n",
    "\n",
    "for sensors in list(corr_dict.keys()):\n",
    "    x = np.array(corr_dict[sensors]['TaS'])\n",
    "    y = np.array(corr_dict[sensors]['corr'])\n",
    "    m, b = np.polyfit(x, y, 1)\n",
    "    \n",
    "    coeff_dict[sensors] = (m, b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "At last, we will persist the coefficients dictionary on a disk for further use."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "if os.path.exists('coeff_dict.pickle'):\n",
    "    with open(r\"coeff_dict.pickle\", \"rb\") as output_file:\n",
    "        coeff_dict_read = pickle.load(output_file)\n",
    "        coeff_dict.update(coeff_dict_read)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "with open(r\"coeff_dict.pickle\", \"wb\") as output_file:\n",
    "    pickle.dump(coeff_dict, output_file)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Feature extraction and filtering"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this section we are going to focus on extracting the following additional features:\n",
    "- timestamp differences\n",
    "- the mean latitude and longitude location of the receivers\n",
    "- the weighted mean of sensors coordinates"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "At first, we will instantiate the <i>SparkSession</i> and set the number of output partitions and the log level."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "spark = SparkSession.builder \\\n",
    "    .master(\"local[2]\") \\\n",
    "    .appName(\"ads-b data processing\") \\\n",
    "    .config(\"spark.driver.memory\", \"4g\") \\\n",
    "    .getOrCreate()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Set number of output partitions\n",
    "spark.conf.set(\"spark.sql.shuffle.partitions\", 100)\n",
    "\n",
    "# Set log level\n",
    "spark.sparkContext.setLogLevel(\"ERROR\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "df = spark.read.format(\"csv\") \\\n",
    "    .options(header='True', inferSchema='True') \\\n",
    "    .load('round2_training/round2/training3/training3.csv') "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next, we will remove the columns that are no longer useful."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "max_measurements = 6\n",
    "\n",
    "# Select columns to drop. We will keep timeAtServer and aircraft fields for visualization purposes\n",
    "cols = ['id', 'numMeasurements'] + ['sensor_{}'.format(i) for i in range(max_measurements)] \\\n",
    "    + ['corr_{}'.format(i) for i in range(1, max_measurements)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "df = df.drop(*cols)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Below we will calculate the timestamp differences that are going to be used as additional features."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Specify the number of measurements to be taken into account while calculating differences\n",
    "n_meas_diff = 4\n",
    "\n",
    "for col_1 in range(1, n_meas_diff):\n",
    "    for col_2 in range(col_1):\n",
    "        df = df.withColumn('diff_{}_{}'.format(col_1, col_2), F.col('tmp_{}'.format(col_1)) - \\\n",
    "                           F.col('tmp_{}'.format(col_2)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+---------------+--------------------+--------------------+-------------------+-------------------+\n",
      "|          tmp_0|               tmp_1|               tmp_2|           diff_1_0|           diff_2_0|\n",
      "+---------------+--------------------+--------------------+-------------------+-------------------+\n",
      "|  6.040732833E9| 6.040755583653483E9|6.0415790803354225E9| 22750.653483390808|  846247.3354225159|\n",
      "|  4.181512167E9|4.1815121993956394E9|4.1816904042636733E9| 32.395639419555664|  178237.2636733055|\n",
      "|6.8231743833E10| 6.82318009082791E10|                null|  57075.27909851074|               null|\n",
      "|4.4342689333E10|4.434263257770246E10|4.434262728769303E10|-56755.297538757324|-62045.306968688965|\n",
      "|   3.06961578E8| 3.067029259464967E8|3.0658706102887994E8|-258652.05350327492| -374516.9711200595|\n",
      "+---------------+--------------------+--------------------+-------------------+-------------------+\n",
      "only showing top 5 rows\n",
      "\n"
     ]
    }
   ],
   "source": [
    "df.select('tmp_0', 'tmp_1', 'tmp_2', 'diff_1_0', 'diff_2_0').show(5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The next feature to extract is the mean latitude and longitude location of the sensors receiving the signal."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "cols = [col for col in df.columns if 'latitude_' in col]\n",
    "\n",
    "df = df.withColumn('mean_lat',\\\n",
    "     sum([F.when(F.col(col).isNull(), 0).otherwise(F.col(col)) for col in cols])/ \\\n",
    "     sum([F.when(F.col(col).isNull(), 0).otherwise(1) for col in cols])). \\\n",
    "     fillna(0, 'mean_lat')\n",
    "\n",
    "cols = [col for col in df.columns if 'longitude_' in col]\n",
    "\n",
    "df = df.withColumn('mean_lon',\\\n",
    "     sum([F.when(F.col(col).isNull(), 0).otherwise(F.col(col)) for col in cols])/ \\\n",
    "     sum([F.when(F.col(col).isNull(), 0).otherwise(1) for col in cols])). \\\n",
    "     fillna(0, 'mean_lon')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+----------+----------+----------+----------+------------------+\n",
      "|latitude_0|latitude_1|latitude_2|latitude_3|          mean_lat|\n",
      "+----------+----------+----------+----------+------------------+\n",
      "|   49.9943|    50.123|   48.0281|      null|           49.3818|\n",
      "|   49.5692| 49.569286| 46.762405|      null|48.633630333333336|\n",
      "|   53.0433| 53.571148|      null|      null|53.307224000000005|\n",
      "|   52.2627| 52.436016|   52.1114|  52.38154|         52.297914|\n",
      "| 51.759014|   53.0433| 52.780922|   53.3575|52.574139333333335|\n",
      "+----------+----------+----------+----------+------------------+\n",
      "only showing top 5 rows\n",
      "\n"
     ]
    }
   ],
   "source": [
    "df.select('latitude_0', 'latitude_1', 'latitude_2', 'latitude_3', 'mean_lat').show(5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+-----------+-----------+-----------+-----------+-------------------+\n",
      "|longitude_0|longitude_1|longitude_2|longitude_3|           mean_lon|\n",
      "+-----------+-----------+-----------+-----------+-------------------+\n",
      "|     8.6604|    8.69833|    10.7168|       null|            9.35851|\n",
      "|      6.064|   6.064015|   7.600447|       null|           6.576154|\n",
      "|    -2.2295|  -3.059619|       null|       null|-2.6445594999999997|\n",
      "|  13.619793|  13.361244|    11.6383|    9.98306|        12.15059925|\n",
      "|  -1.256688|    -2.2295|   -1.20459|    -1.4963|-1.4577513333333334|\n",
      "+-----------+-----------+-----------+-----------+-------------------+\n",
      "only showing top 5 rows\n",
      "\n"
     ]
    }
   ],
   "source": [
    "df.select('longitude_0', 'longitude_1', 'longitude_2', 'longitude_3', 'mean_lon').show(5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We will also use the weighted mean of sensors coordinates as an additional feature. In this calculation, weights are going to be inverse values of timestamp measurements."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "cols = [col for col in df.columns if 'latitude_' in col]\n",
    "\n",
    "df = df.withColumn('w_mean_lat',\\\n",
    "     sum([F.when(F.col(col).isNull(), 0).otherwise(F.col(col)*(1/F.col('tmp_{}'.format(i)))) \\\n",
    "          for i, col in enumerate(cols)])/ \\\n",
    "     sum([F.when(F.col(col).isNull(), 0).otherwise(1/F.col('tmp_{}'.format(i))) \\\n",
    "          for i, col in enumerate(cols)])). \\\n",
    "     fillna(0, 'w_mean_lat')\n",
    "\n",
    "cols = [col for col in df.columns if 'longitude_' in col]\n",
    "\n",
    "df = df.withColumn('w_mean_lon',\\\n",
    "     sum([F.when(F.col(col).isNull(), 0).otherwise(F.col(col)*(1/F.col('tmp_{}'.format(i)))) \\\n",
    "          for i, col in enumerate(cols)])/ \\\n",
    "     sum([F.when(F.col(col).isNull(), 0).otherwise(1/F.col('tmp_{}'.format(i))) \\\n",
    "          for i, col in enumerate(cols)])). \\\n",
    "     fillna(0, 'w_mean_lon')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+----------+----------+---------------+--------------------+------------------+\n",
      "|latitude_0|latitude_1|          tmp_0|               tmp_1|        w_mean_lat|\n",
      "+----------+----------+---------------+--------------------+------------------+\n",
      "|   49.9943|    50.123|  6.040732833E9| 6.040755583653483E9| 49.38186227698855|\n",
      "|   49.5692| 49.569286|  4.181512167E9|4.1815121993956394E9|48.633656917200746|\n",
      "|   53.0433| 53.571148|6.8231743833E10| 6.82318009082791E10|53.307223889614946|\n",
      "|   52.2627| 52.436016|4.4342689333E10|4.434263257770246E10| 52.29791384004996|\n",
      "| 51.759014|   53.0433|   3.06961578E8| 3.067029259464967E8| 52.57458086608702|\n",
      "+----------+----------+---------------+--------------------+------------------+\n",
      "only showing top 5 rows\n",
      "\n"
     ]
    }
   ],
   "source": [
    "df.select('latitude_0', 'latitude_1', 'tmp_0', 'tmp_1', 'w_mean_lat').show(5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+-----------+-----------+---------------+--------------------+-------------------+\n",
      "|longitude_0|longitude_1|          tmp_0|               tmp_1|         w_mean_lon|\n",
      "+-----------+-----------+---------------+--------------------+-------------------+\n",
      "|     8.6604|    8.69833|  6.040732833E9| 6.040755583653483E9|  9.358447406976023|\n",
      "|      6.064|   6.064015|  4.181512167E9|4.1815121993956394E9|  6.576139448214619|\n",
      "|    -2.2295|  -3.059619|6.8231743833E10| 6.82318009082791E10| -2.644559326403184|\n",
      "|  13.619793|  13.361244|4.4342689333E10|4.434263257770246E10| 12.150603058294632|\n",
      "|  -1.256688|    -2.2295|   3.06961578E8| 3.067029259464967E8|-1.4574936088578214|\n",
      "+-----------+-----------+---------------+--------------------+-------------------+\n",
      "only showing top 5 rows\n",
      "\n"
     ]
    }
   ],
   "source": [
    "df.select('longitude_0', 'longitude_1', 'tmp_0', 'tmp_1', 'w_mean_lon').show(5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As the last step, we will fill in missing values and save the data frame."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "df = df \\\n",
    "    .fillna(-90, subset=[col for col in df.columns if 'latitude' in col]) \\\n",
    "    .fillna(-180, subset=[col for col in df.columns if 'longitude' in col]) \\\n",
    "    .fillna(-90, subset=[col for col in df.columns if 'mean_lat' in col]) \\\n",
    "    .fillna(-180, subset=[col for col in df.columns if 'mean_lon' in col]) \\\n",
    "    .fillna(0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "df.repartition(1).write.save('round2_training/round2/tmp_training3/', format='csv', header=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "list_dir = os.listdir('round2_training/round2/tmp_training3/')\n",
    "\n",
    "if '_SUCCESS' in list_dir:\n",
    "    file_name = [name for name in list_dir if name.startswith('part')]\n",
    "    os.rename(os.path.join('round2_training/round2/tmp_training3', file_name[0]), \\\n",
    "              'round2_training/round2/tmp_training3/training3.csv')\n",
    "    os.replace('round2_training/round2/tmp_training3/training3.csv', 'round2_training/round2/training3/training3.csv')\n",
    "    \n",
    "    import shutil\n",
    "    shutil.rmtree('round2_training/round2/tmp_training3/')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Normalization parameters"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this section, we are going to calculate the normalization parameters - minimum and maximum, that subsequently can be used by machine learning models to normalize the input batches of data."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "First, we have to load the data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_csv = pd.read_csv('round2_training/round2/training3/training3.csv', nrows=1)\n",
    "\n",
    "columns = list(df_csv.columns)\n",
    "\n",
    "use_cols = [col for col in columns if ('latitude' not in col) and ('longitude' not in col) and \\\n",
    "           ('mean' not in col)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "flights = pd.read_csv('round2_training/round2/training3/training3.csv', usecols=use_cols)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we will calculate the normalization parameters (MIN, MAX) for each feature."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "norm_params = {}\n",
    "\n",
    "for col in columns:\n",
    "    if ('latitude' in col) or ('mean_lat' in col):\n",
    "        norm_params[col] = {'min': -90, 'max': 90}\n",
    "    elif ('longitude' in col) or ('mean_lon' in col):\n",
    "        norm_params[col] = {'min': -180, 'max': 180}\n",
    "    elif ('timeAtServer' in col) or ('aircraft' in col):\n",
    "        pass\n",
    "    else:\n",
    "        norm_params[col] = {'min': flights[col].min(), 'max': flights[col].max()}\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The following code will update the normalization parameters if the notebook is restarted."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "if os.path.exists('norm_params.pickle'):\n",
    "    with open(r\"norm_params.pickle\", \"rb\") as output_file:\n",
    "        norm_params_read = pickle.load(output_file)\n",
    "        \n",
    "    # Update normalization parameters\n",
    "    for k, v in norm_params_read.items():\n",
    "        if k == 'input_features':\n",
    "            norm_params[k] = norm_params_read[k]\n",
    "        elif k == 'target':\n",
    "            norm_params[k] = norm_params_read[k]\n",
    "        elif v['max'] > norm_params[k]['max']:\n",
    "            norm_params[k]['max'] = v['max']\n",
    "        elif v['min'] < norm_params[k]['min']:\n",
    "            norm_params[k]['min'] = v['min']\n",
    "            "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "target_cols = ['latitude', 'longitude', 'geoAltitude']\n",
    "vis_cols = ['timeAtServer', 'aircraft']\n",
    "input_feature = [col for col in columns if (col not in target_cols) and (col not in vis_cols)]\n",
    "\n",
    "norm_params['input_features'] = input_feature\n",
    "norm_params['target'] = target_cols"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we will save the dictionary with the normalization parameters as a <i>pickle</i> file."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "with open(r\"norm_params.pickle\", \"wb\") as output_file:\n",
    "    pickle.dump(norm_params, output_file)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Create the HDF5 training dataset"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The rest of the code in this notebook should be run last after the entire training dataset (all three files) has been preprocessed. \n",
    "\n",
    "We will write the content of the CSV training dataset into to HDF5 file."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import pickle\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "After importing the libraries we have to specify the paths of all preprocessed files and the name of the HDF5 file."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_path_1 = 'round2_training/round2/training1/training1.csv'\n",
    "train_path_2 = 'round2_training/round2/training2/training2.csv'\n",
    "train_path_3 = 'round2_training/round2/training3/training3.csv'\n",
    "\n",
    "files = [train_path_1, train_path_2, train_path_3]\n",
    "\n",
    "hdf5_path = 'training.hdf5'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "with open(r\"norm_params.pickle\", \"rb\") as output_file:\n",
    "    norm_params = pickle.load(output_file)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "input_feature = norm_params['input_features']\n",
    "target_cols = norm_params['target']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The following code will create the HDF5 file."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "with pd.HDFStore(hdf5_path, 'w') as store:\n",
    "    for file in files:\n",
    "        try:\n",
    "            df = pd.read_csv(file, encoding='utf-8', chunksize=500000, index_col=False)\n",
    "            \n",
    "            try:\n",
    "                nrows = store.get_storer('input').nrows\n",
    "            except:\n",
    "                nrows = 0\n",
    "            \n",
    "            for chunk in df:\n",
    "                chunk.index = pd.Series(chunk.index) + nrows\n",
    "                store.append('input', chunk.loc[:, input_feature].astype('float'))\n",
    "                store.append('target', chunk.loc[:, target_cols].astype('float'))\n",
    "\n",
    "        except Exception as detail:\n",
    "            print(file, detail)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Populate MariaDB database"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Before we insert the data into MariaDB database we have to first create one. Use the <i>createDB.py</i> python script to create MariaDB database."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import mariadb\n",
    "import pickle\n",
    "import logging\n",
    "import sys\n",
    "from getpass import getpass\n",
    "from config import mariadb_hostname, mariadb_port, mariadb_database_name, mariadb_table_name"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_path_1 = 'round2_training/round2/training1/training1.csv'\n",
    "train_path_2 = 'round2_training/round2/training2/training2.csv'\n",
    "train_path_3 = 'round2_training/round2/training3/training3.csv'\n",
    "\n",
    "files = [train_path_1, train_path_2, train_path_3]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Use the login and the password you provided during the initialization of the MariaDB."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Login to MariaDB:\n",
      "User: root\n",
      "Password: ········\n"
     ]
    }
   ],
   "source": [
    "print('Login to MariaDB:')\n",
    "mariadb_user = input('User: ')\n",
    "mariadb_password = getpass('Password: ')\n",
    "\n",
    "# For Docker - uncomment the following line to override the mariadb_hostname\n",
    "# mariadb_hostname = 'mariadb' \n",
    "\n",
    "# Connect to MariaDB server\n",
    "try:\n",
    "    cnx = mariadb.connect(host=mariadb_hostname, port=mariadb_port, user=mariadb_user, password=mariadb_password)\n",
    "except mariadb.Error as msg:\n",
    "    logging.error(\"Error connecting to MariaDB Platform: {}\".format(msg))\n",
    "    sys.exit(1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we will insert all the data into MariaDB database."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Data inserting ended successfully\n"
     ]
    }
   ],
   "source": [
    "with open(r\"norm_params.pickle\", \"rb\") as output_file:\n",
    "    norm_params = pickle.load(output_file)\n",
    "    \n",
    "columns = ['timeAtServer', 'aircraft'] + norm_params['input_features'] + norm_params['target']\n",
    "\n",
    "# Instantiate cursor object\n",
    "cursor = cnx.cursor()\n",
    "\n",
    "# Use given database\n",
    "cursor.execute(\"USE {};\".format(mariadb_database_name))\n",
    "\n",
    "insert_query = \"INSERT INTO \" + mariadb_table_name + \" (\" + \", \".join(columns) + \") VALUES (\" + \\\n",
    "    \", \".join([\"?\" for i in range(len(columns))]) + \");\"\n",
    "\n",
    "for file in files:\n",
    "    df = pd.read_csv(file, encoding='utf-8', chunksize=10000, index_col=False)\n",
    "    \n",
    "    for chunk in df:\n",
    "        data = list(zip(*[chunk[col] for col in columns]))\n",
    "\n",
    "        try:\n",
    "            cursor.executemany(insert_query, data)\n",
    "            cnx.commit()\n",
    "        except mariadb.Error as msg:\n",
    "            logging.error(msg)\n",
    "            sys.exit(1)\n",
    "else:\n",
    "    print(\"Data inserting ended successfully\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### References"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[1]. <i>The Testing of MLAT Method Application by means of Usage low-cost ADS-B Receivers</i>, Stanislav Pleninger, Department of Air Transport, Czech Technical University in Prague. "
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "aircraft",
   "language": "python",
   "name": "aircraft"
  },
  "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.8.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}