notebook/advanced_feature_engineering_keras.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Advanced Feature Engineering in Keras \n",
    "\n",
    "## Objectives\n",
    "\n",
    "1. Process temporal feature columns in Keras.\n",
    "2. Use Lambda layers to perform feature engineering on geolocation features.\n",
    "3. Create bucketized and crossed feature columns.\n",
    " \n",
    "\n",
    "## Introduction \n",
    "\n",
    "In this notebook, we use Keras to build a taxifare price prediction model and utilize feature engineering to improve the fare amount prediction for NYC taxi cab rides. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Set up environment variables and load necessary libraries \n",
    "We will start by importing the necessary libraries for this lab."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Run the chown command to change the ownership of the repository\n",
    "!sudo chown -R jupyter:jupyter /home/jupyter/training-data-analyst"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2.6.2\n"
     ]
    }
   ],
   "source": [
    "# You can use any Python source file as a module by executing an import statement in some other Python source file.\n",
    "# The import statement combines two operations; it searches for the named module, then it binds the results of that search\n",
    "# to a name in the local scope.\n",
    "import datetime\n",
    "import logging\n",
    "import os\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import tensorflow as tf\n",
    "\n",
    "from tensorflow import feature_column as fc\n",
    "from tensorflow.keras import layers\n",
    "from tensorflow.keras import models\n",
    "\n",
    "# set TF error log verbosity\n",
    "logging.getLogger(\"tensorflow\").setLevel(logging.ERROR)\n",
    "\n",
    "print(tf.version.VERSION)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Load taxifare dataset\n",
    "\n",
    "The Taxi Fare dataset for this lab is 106,545 rows and has been pre-processed and split for use in this lab.  Note that the dataset is the same as used in the Big Query feature engineering labs.  The fare_amount is the target, the continuous value we’ll train a model to predict.  \n",
    "\n",
    "First, let's download the  .csv data by copying the data from a cloud storage bucket."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# `os.makedirs()` method will create all unavailable/missing directory in the specified path.\n",
    "if not os.path.isdir(\"../data\"):\n",
    "    os.makedirs(\"../data\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Copying gs://cloud-training/mlongcp/v3.0_MLonGC/toy_data/taxi-train1_toy.csv...\n",
      "/ [1 files][  1.7 MiB/  1.7 MiB]                                                \n",
      "Operation completed over 1 objects/1.7 MiB.                                      \n",
      "Copying gs://cloud-training/mlongcp/v3.0_MLonGC/toy_data/taxi-valid1_toy.csv...\n",
      "/ [1 files][436.2 KiB/436.2 KiB]                                                \n",
      "Operation completed over 1 objects/436.2 KiB.                                    \n"
     ]
    }
   ],
   "source": [
    "# The `gsutil cp` command allows you to copy data between the bucket and current directory.\n",
    "!gsutil cp gs://cloud-training/mlongcp/v3.0_MLonGC/toy_data/taxi-train1_toy.csv ../data\n",
    "!gsutil cp gs://cloud-training/mlongcp/v3.0_MLonGC/toy_data/taxi-valid1_toy.csv ../data\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's check that the files were copied correctly and look like we expect them to."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-rw-r--r-- 1 jupyter jupyter 1756557 Dec 27 16:37 ../data/taxi-train1_toy.csv\n",
      "-rw-r--r-- 1 jupyter jupyter  446676 Dec 27 16:37 ../data/taxi-valid1_toy.csv\n"
     ]
    }
   ],
   "source": [
    "# `ls` shows the working directory's contents.  \n",
    "# The `l` flag list the all files with permissions and details.\n",
    "!ls -l ../data/*.csv"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "==> ../data/taxi-train1_toy.csv <==\n",
      "fare_amount,passenger_count,pickup_longitude,pickup_latitude,dropoff_longitude,dropoff_latitude,hourofday,dayofweek\n",
      "8.1,1,-73.973731,40.791909999999994,-73.962737,40.767317999999996,14,4\n",
      "4.5,2,-73.98649499999999,40.739278000000006,-73.986083,40.730933,10,6\n",
      "2.9,1,-73.95604300000001,40.772026000000004,-73.956245,40.773934000000004,22,3\n",
      "7.0,1,-74.006557,40.705797,-73.980017,40.713617,6,3\n",
      "6.5,1,-73.98644300000001,40.741611999999996,-73.990215,40.746466999999996,10,2\n",
      "15.0,1,-73.96014404,40.7789917,-73.98536682,40.73873138,17,6\n",
      "5.5,1,-73.981625,40.74957,-73.97639000000001,40.754807,18,0\n",
      "9.0,3,-73.99884,40.734719,-73.978865,40.72422,21,1\n",
      "14.0,2,-73.986827,40.742839000000004,-73.94695899999999,40.780063,19,1\n",
      "\n",
      "==> ../data/taxi-valid1_toy.csv <==\n",
      "fare_amount,passenger_count,pickup_longitude,pickup_latitude,dropoff_longitude,dropoff_latitude,hourofday,dayofweek\n",
      "15.5,3,-73.98902199999999,40.718837,-73.974645,40.761427000000005,18,3\n",
      "7.5,1,-73.97336578,40.76422882,-73.98596954,40.75464249,20,0\n",
      "3.3,2,-73.961372,40.760443,-73.956565,40.767154999999995,2,6\n",
      "13.5,6,-73.989437,40.757082000000004,-73.98344200000001,40.725312,18,4\n",
      "7.5,2,-73.981992,40.740312,-73.965375,40.752895,13,4\n",
      "7.3,1,-73.99553,40.759465000000006,-73.978126,40.752683000000005,20,2\n",
      "13.5,5,-73.99021149,40.75678253,-73.95141602,40.7700119,7,3\n",
      "6.1,1,-74.005032,40.72971,-73.985805,40.722916999999995,19,4\n",
      "10.0,6,-73.95796800000001,40.765155,-73.960672,40.781222,12,1\n"
     ]
    }
   ],
   "source": [
    "# By default `head` returns the first ten lines of each file.\n",
    "!head ../data/*.csv"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Create an input pipeline \n",
    "\n",
    "Typically, you will use a two step process to build the pipeline. Step one is to define the columns of data; i.e., which column we're predicting for, and the default values.  Step 2 is to define two functions - a function to define the features and label you want to use and a function to load the training data.  Also, note that pickup_datetime is a string and we will need to handle this in our feature engineered model.  \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "CSV_COLUMNS = [\n",
    "    'fare_amount',\n",
    "    'pickup_datetime',\n",
    "    'pickup_longitude',\n",
    "    'pickup_latitude',\n",
    "    'dropoff_longitude',\n",
    "    'dropoff_latitude',\n",
    "    'passenger_count',\n",
    "    'key',\n",
    "]\n",
    "LABEL_COLUMN = 'fare_amount'\n",
    "STRING_COLS = ['pickup_datetime']\n",
    "NUMERIC_COLS = ['pickup_longitude', 'pickup_latitude',\n",
    "                'dropoff_longitude', 'dropoff_latitude',\n",
    "                'passenger_count']\n",
    "DEFAULTS = [[0.0], ['na'], [0.0], [0.0], [0.0], [0.0], [0.0], ['na']]\n",
    "DAYS = ['Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "# A function to define features and labesl\n",
    "def features_and_labels(row_data):\n",
    "    for unwanted_col in ['key']:\n",
    "        row_data.pop(unwanted_col)\n",
    "    label = row_data.pop(LABEL_COLUMN)\n",
    "    return row_data, label\n",
    "\n",
    "\n",
    "# A utility method to create a tf.data dataset from a Pandas Dataframe\n",
    "def load_dataset(pattern, batch_size=1, mode='eval'):\n",
    "    dataset = tf.data.experimental.make_csv_dataset(pattern,\n",
    "                                                    batch_size,\n",
    "                                                    CSV_COLUMNS,\n",
    "                                                    DEFAULTS)\n",
    "    dataset = dataset.map(features_and_labels)  # features, label\n",
    "    if mode == 'train':\n",
    "        dataset = dataset.shuffle(1000).repeat()\n",
    "        # take advantage of multi-threading; 1=AUTOTUNE\n",
    "        dataset = dataset.prefetch(1)\n",
    "    return dataset"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Create a Baseline DNN Model in Keras\n",
    "\n",
    "Now let's build the Deep Neural Network (DNN) model in Keras using the functional API. Unlike the sequential API, we will need to specify the input and hidden layers.  Note that we are creating a linear regression baseline model with no feature engineering. Recall that a baseline model is a solution to a problem without applying any machine learning techniques."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Build a simple Keras DNN using its Functional API\n",
    "def rmse(y_true, y_pred):  # Root mean square error\n",
    "    return tf.sqrt(tf.reduce_mean(tf.square(y_pred - y_true)))\n",
    "\n",
    "\n",
    "def build_dnn_model():\n",
    "    # input layer\n",
    "    inputs = {\n",
    "        colname: layers.Input(name=colname, shape=(), dtype='float32')\n",
    "        for colname in NUMERIC_COLS\n",
    "    }\n",
    "\n",
    "    # feature_columns\n",
    "    feature_columns = {\n",
    "        colname: fc.numeric_column(colname)\n",
    "        for colname in NUMERIC_COLS\n",
    "    }\n",
    "\n",
    "    # Constructor for DenseFeatures takes a list of numeric columns\n",
    "    dnn_inputs = layers.DenseFeatures(feature_columns.values())(inputs)\n",
    "\n",
    "    # two hidden layers of [32, 8] just in like the BQML DNN\n",
    "    h1 = layers.Dense(32, activation='relu', name='h1')(dnn_inputs)\n",
    "    h2 = layers.Dense(8, activation='relu', name='h2')(h1)\n",
    "\n",
    "    # final output is a linear activation because this is regression\n",
    "    output = layers.Dense(1, activation='linear', name='fare')(h2)\n",
    "    model = models.Model(inputs, output)\n",
    "\n",
    "    # compile model\n",
    "    model.compile(optimizer='adam', loss='mse', metrics=[rmse, 'mse'])\n",
    "\n",
    "    return model"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We'll build our DNN model and inspect the model architecture."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model = build_dnn_model()\n",
    "\n",
    "# We can visualize the DNN using the Keras `plot_model` utility.\n",
    "tf.keras.utils.plot_model(model, 'dnn_model.png', show_shapes=False, rankdir='LR')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Train the model\n",
    "\n",
    "To train the model, simply call [model.fit()](https://keras.io/models/model/#fit).  Note that we should really use many more NUM_TRAIN_EXAMPLES (i.e. a larger dataset). We shouldn't make assumptions about the quality of the model based on training/evaluating it on a small sample of the full data.\n",
    "\n",
    "We start by setting up the environment variables for training, creating the input pipeline datasets, and then train our baseline DNN model."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "TRAIN_BATCH_SIZE = 32 \n",
    "NUM_TRAIN_EXAMPLES = 59621 * 5\n",
    "NUM_EVALS = 5\n",
    "NUM_EVAL_EXAMPLES = 14906"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/5\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/opt/conda/lib/python3.7/site-packages/keras/engine/functional.py:585: UserWarning: Input dict contained keys ['pickup_datetime'] which did not match any model input. They will be ignored by the model.\n",
      "  [n for n in tensors.keys() if n not in ref_input_names])\n",
      "2021-12-27 16:39:22.040059: I tensorflow/compiler/mlir/mlir_graph_optimization_pass.cc:185] None of the MLIR Optimization Passes are enabled (registered 2)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1863/1863 [==============================] - 9s 4ms/step - loss: 213.2594 - rmse: 14.1722 - mse: 213.2594 - val_loss: 188.1402 - val_rmse: 13.7060 - val_mse: 188.1402\n",
      "Epoch 2/5\n",
      "1863/1863 [==============================] - 7s 4ms/step - loss: 178.7151 - rmse: 12.8783 - mse: 178.7151 - val_loss: 157.0119 - val_rmse: 12.5167 - val_mse: 157.0119\n",
      "Epoch 3/5\n",
      "1863/1863 [==============================] - 8s 4ms/step - loss: 151.9335 - rmse: 11.7713 - mse: 151.9335 - val_loss: 133.5690 - val_rmse: 11.5399 - val_mse: 133.5690\n",
      "Epoch 4/5\n",
      "1863/1863 [==============================] - 8s 4ms/step - loss: 135.2108 - rmse: 10.9575 - mse: 135.2108 - val_loss: 119.2002 - val_rmse: 10.9039 - val_mse: 119.2002\n",
      "Epoch 5/5\n",
      "1863/1863 [==============================] - 8s 4ms/step - loss: 116.2354 - rmse: 10.0750 - mse: 116.2354 - val_loss: 108.3143 - val_rmse: 10.3647 - val_mse: 108.3143\n"
     ]
    }
   ],
   "source": [
    "# `load_dataset` method is used to load the dataset.\n",
    "trainds = load_dataset('../data/taxi-train*',\n",
    "                       TRAIN_BATCH_SIZE,\n",
    "                       'train')\n",
    "evalds = load_dataset('../data/taxi-valid*',\n",
    "                      1000,\n",
    "                      'eval').take(NUM_EVAL_EXAMPLES//1000)\n",
    "\n",
    "steps_per_epoch = NUM_TRAIN_EXAMPLES // (TRAIN_BATCH_SIZE * NUM_EVALS)\n",
    "\n",
    "# `Fit` trains the model for a fixed number of epochs\n",
    "history = model.fit(trainds,\n",
    "                    validation_data=evalds,\n",
    "                    epochs=NUM_EVALS,\n",
    "                    steps_per_epoch=steps_per_epoch)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Visualize the model loss curve\n",
    "\n",
    "Next, we will use matplotlib to draw the model's loss curves for training and validation.  A line plot is also created showing the mean squared error loss over the training epochs for both the train (blue) and test (orange) sets."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "# A function to define plot_curves.\n",
    "def plot_curves(history, metrics):\n",
    "    nrows = 1\n",
    "    ncols = 2\n",
    "    fig = plt.figure(figsize=(10, 5))\n",
    "\n",
    "    for idx, key in enumerate(metrics):  \n",
    "        ax = fig.add_subplot(nrows, ncols, idx+1)\n",
    "        plt.plot(history.history[key])\n",
    "        plt.plot(history.history['val_{}'.format(key)])\n",
    "        plt.title('model {}'.format(key))\n",
    "        plt.ylabel(key)\n",
    "        plt.xlabel('epoch')\n",
    "        plt.legend(['train', 'validation'], loc='upper left');    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 720x360 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_curves(history, ['loss', 'mse'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Predict with the model locally\n",
    "\n",
    "To predict with Keras, you simply call [model.predict()](https://keras.io/models/model/#predict) and pass in the cab ride you want to predict the fare amount for.  Next we note the fare price at this geolocation and pickup_datetime."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[8.0715685]], dtype=float32)"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Use the model to do prediction with `model.predict()`.\n",
    "model.predict({\n",
    "    'pickup_longitude': tf.convert_to_tensor([-73.982683]),\n",
    "    'pickup_latitude': tf.convert_to_tensor([40.742104]),\n",
    "    'dropoff_longitude': tf.convert_to_tensor([-73.983766]),\n",
    "    'dropoff_latitude': tf.convert_to_tensor([40.755174]),\n",
    "    'passenger_count': tf.convert_to_tensor([3.0]),\n",
    "    'pickup_datetime': tf.convert_to_tensor(['2010-02-08 09:17:00 UTC'], dtype=tf.string),\n",
    "}, steps=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Improve Model Performance Using Feature Engineering \n",
    "\n",
    "We now improve our model's performance by creating the following feature engineering types:  Temporal, Categorical, and Geolocation. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Temporal Feature Columns"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We incorporate the temporal feature pickup_datetime.  As noted earlier, pickup_datetime is a string and we will need to handle this within the model.  First, you will include the pickup_datetime as a feature and then you will need to modify the model to handle our string feature."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "# TODO 1a\n",
    "def parse_datetime(s):\n",
    "    if type(s) is not str:\n",
    "        s = s.numpy().decode('utf-8')\n",
    "    return datetime.datetime.strptime(s, \"%Y-%m-%d %H:%M:%S %Z\")\n",
    "\n",
    "\n",
    "# TODO 1b\n",
    "def get_dayofweek(s):\n",
    "    ts = parse_datetime(s)\n",
    "    return DAYS[ts.weekday()]\n",
    "\n",
    "\n",
    "# TODO 1c\n",
    "@tf.function\n",
    "def dayofweek(ts_in):\n",
    "    return tf.map_fn(\n",
    "        lambda s: tf.py_function(get_dayofweek, inp=[s], Tout=tf.string),\n",
    "        ts_in)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Geolocation/Coordinate Feature Columns\n",
    "\n",
    "The pick-up/drop-off longitude and latitude data are crucial to predicting the fare amount as fare amounts in NYC taxis are largely determined by the distance traveled. As such, we need to teach the model the Euclidean distance between the pick-up and drop-off points.\n",
    "\n",
    "Recall that latitude and longitude allows us to specify any location on Earth using a set of coordinates. In our training data set, we restricted our data points to only pickups and drop offs within NYC. New York city has an approximate longitude range of -74.05 to -73.75 and a latitude range of 40.63 to 40.85.\n",
    "\n",
    "#### Computing Euclidean distance\n",
    "The dataset contains information regarding the pickup and drop off coordinates. However, there is no information regarding the distance between the pickup and drop off points. Therefore, we create a new feature that calculates the distance between each pair of pickup and drop off points. We can do this using the Euclidean Distance, which is the straight-line distance between any two coordinate points."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "def euclidean(params):\n",
    "    lon1, lat1, lon2, lat2 = params\n",
    "    londiff = lon2 - lon1\n",
    "    latdiff = lat2 - lat1\n",
    "    return tf.sqrt(londiff*londiff + latdiff*latdiff)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Scaling latitude and longitude\n",
    "\n",
    "It is very important for numerical variables to get scaled before they are \"fed\" into the neural network. Here we use min-max scaling (also called normalization) on the geolocation features.  Later in our model, you will see that these values are shifted and rescaled so that they end up ranging from 0 to 1.\n",
    "\n",
    "First, we create a function named 'scale_longitude', where we pass in all the longitudinal values and add 78 to each value.  Note that our scaling longitude ranges from -70 to -78. Thus, the value 78 is the maximum longitudinal value.  The delta or difference between -70 and -78 is 8.  We add 78 to each longitudinal value and then divide by 8 to return a scaled value."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "def scale_longitude(lon_column):\n",
    "    return (lon_column + 78)/8."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next, we create a function named 'scale_latitude', where we pass in all the latitudinal values and subtract 37 from each value.  Note that our scaling longitude ranges from -37 to -45. Thus, the value 37 is the minimal latitudinal value.  The delta or difference between -37 and -45 is 8.  We subtract 37 from each latitudinal value and then divide by 8 to return a scaled value."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "def scale_latitude(lat_column):\n",
    "    return (lat_column - 37)/8."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Putting it all together\n",
    "We now create two new \"geo\" functions for our model.  We create a function called \"euclidean\" to initialize our geolocation parameters.  We then create a function called transform.   The transform function passes our numerical and string column features as inputs to the model, scales geolocation features, then creates the Euclidean distance as a transformed variable with the geolocation features. Lastly, we bucketize the latitude and longitude features."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "def transform(inputs, numeric_cols, string_cols, nbuckets):\n",
    "    print(\"Inputs before features transformation: {}\".format(inputs.keys()))\n",
    "\n",
    "    # Pass-through columns\n",
    "    transformed = inputs.copy()\n",
    "    del transformed['pickup_datetime']\n",
    "\n",
    "    feature_columns = {\n",
    "        colname: tf.feature_column.numeric_column(colname)\n",
    "        for colname in numeric_cols\n",
    "    }\n",
    "\n",
    "    # TODO 2a\n",
    "    # Scaling longitude from range [-70, -78] to [0, 1]\n",
    "    for lon_col in ['pickup_longitude', 'dropoff_longitude']:\n",
    "        transformed[lon_col] = layers.Lambda(\n",
    "            scale_longitude,\n",
    "            name=\"scale_{}\".format(lon_col))(inputs[lon_col])\n",
    "\n",
    "    # TODO 2b\n",
    "    # Scaling latitude from range [37, 45] to [0, 1]\n",
    "    for lat_col in ['pickup_latitude', 'dropoff_latitude']:\n",
    "        transformed[lat_col] = layers.Lambda(\n",
    "            scale_latitude,\n",
    "            name='scale_{}'.format(lat_col))(inputs[lat_col])\n",
    "\n",
    "    # add Euclidean distance\n",
    "    transformed['euclidean'] = layers.Lambda(\n",
    "        euclidean,\n",
    "        name='euclidean')([inputs['pickup_longitude'],\n",
    "                           inputs['pickup_latitude'],\n",
    "                           inputs['dropoff_longitude'],\n",
    "                           inputs['dropoff_latitude']])\n",
    "    feature_columns['euclidean'] = fc.numeric_column('euclidean')\n",
    "\n",
    "    # TODO 3a\n",
    "    # create bucketized features\n",
    "    latbuckets = np.linspace(0, 1, nbuckets).tolist()\n",
    "    lonbuckets = np.linspace(0, 1, nbuckets).tolist()\n",
    "    b_plat = fc.bucketized_column(\n",
    "        feature_columns['pickup_latitude'], latbuckets)\n",
    "    b_dlat = fc.bucketized_column(\n",
    "        feature_columns['dropoff_latitude'], latbuckets)\n",
    "    b_plon = fc.bucketized_column(\n",
    "        feature_columns['pickup_longitude'], lonbuckets)\n",
    "    b_dlon = fc.bucketized_column(\n",
    "        feature_columns['dropoff_longitude'], lonbuckets)\n",
    "\n",
    "    # TODO 3b\n",
    "    # create crossed columns\n",
    "    ploc = fc.crossed_column([b_plat, b_plon], nbuckets * nbuckets)\n",
    "    dloc = fc.crossed_column([b_dlat, b_dlon], nbuckets * nbuckets)\n",
    "    pd_pair = fc.crossed_column([ploc, dloc], nbuckets ** 4)\n",
    "\n",
    "    # create embedding columns\n",
    "    feature_columns['pickup_and_dropoff'] = fc.embedding_column(pd_pair, 100)\n",
    "\n",
    "    print(\"Transformed features: {}\".format(transformed.keys()))\n",
    "    print(\"Feature columns: {}\".format(feature_columns.keys()))\n",
    "    return transformed, feature_columns"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next, we'll create our DNN model now with the engineered features. We'll set `NBUCKETS = 10` to specify 10 buckets when bucketizing the latitude and longitude."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "NBUCKETS = 10\n",
    "\n",
    "\n",
    "# DNN MODEL\n",
    "def rmse(y_true, y_pred):\n",
    "    return tf.sqrt(tf.reduce_mean(tf.square(y_pred - y_true)))\n",
    "\n",
    "\n",
    "def build_dnn_model():\n",
    "    # input layer is all float except for pickup_datetime which is a string\n",
    "    inputs = {\n",
    "        colname: layers.Input(name=colname, shape=(), dtype='float32')\n",
    "        for colname in NUMERIC_COLS\n",
    "    }\n",
    "    inputs.update({\n",
    "        colname: tf.keras.layers.Input(name=colname, shape=(), dtype='string')\n",
    "        for colname in STRING_COLS\n",
    "    })\n",
    "\n",
    "    # transforms\n",
    "    transformed, feature_columns = transform(inputs,\n",
    "                                             numeric_cols=NUMERIC_COLS,\n",
    "                                             string_cols=STRING_COLS,\n",
    "                                             nbuckets=NBUCKETS)\n",
    "    dnn_inputs = layers.DenseFeatures(feature_columns.values())(transformed)\n",
    "\n",
    "    # two hidden layers of [32, 8] just in like the BQML DNN\n",
    "    h1 = layers.Dense(32, activation='relu', name='h1')(dnn_inputs)\n",
    "    h2 = layers.Dense(8, activation='relu', name='h2')(h1)\n",
    "\n",
    "    # final output is a linear activation because this is regression\n",
    "    output = layers.Dense(1, activation='linear', name='fare')(h2)\n",
    "    model = models.Model(inputs, output)\n",
    "\n",
    "    # Compile model\n",
    "    model.compile(optimizer='adam', loss='mse', metrics=[rmse, 'mse'])\n",
    "    return model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Inputs before features transformation: dict_keys(['pickup_longitude', 'pickup_latitude', 'dropoff_longitude', 'dropoff_latitude', 'passenger_count', 'pickup_datetime'])\n",
      "Transformed features: dict_keys(['pickup_longitude', 'pickup_latitude', 'dropoff_longitude', 'dropoff_latitude', 'passenger_count', 'euclidean'])\n",
      "Feature columns: dict_keys(['pickup_longitude', 'pickup_latitude', 'dropoff_longitude', 'dropoff_latitude', 'passenger_count', 'euclidean', 'pickup_and_dropoff'])\n"
     ]
    }
   ],
   "source": [
    "model = build_dnn_model()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's see how our model architecture has changed now."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAABScAAAHhCAYAAACcMgtqAAAABmJLR0QA/wD/AP+gvaeTAAAgAElEQVR4nOzdeVhW1do/8C+DBohMKimOIAgG5pA/SkvRE/ieyqmjqHWMcjigZurBTHMoTUEtERxIM/PggEdROw5YiYkTBgczBxQHUkBUBEXmQeDh/v3B+zyvKMODAhvk+7kurisWa69973Xvhy5u115bR0QERERERERERERERHVrl67SERAREREREREREVHjxOIkERERERERERERKYLFSSIiIiIiIiIiIlIEi5NERERERERERESkCH1tOu3atQu7du2q7ViI6Bm0a9cOK1euVDoMIiIiIiIiIiKtabVycteuXYiMjKztWIjoKSUlJcHf31/pMIiIiIiIiIiIqkWrlZMA0KdPH4SEhNRmLET0lEJCQjB69GilwyAiIiIiIiIiqhbuOUlERERERERERESKYHGSiIiIiIiIiIiIFMHiJBERERERERERESmCxUkiIiIiIiIiIiJSBIuTREREREREREREpAgWJ4mIiIiIiIiIiEgRLE4SERERERERERGRIlicJCIiIiIiIiIiIkWwOElERERERERERESKYHGSiIiIiIiIiIiIFMHiJBERERERERERESmCxUkiIiIiIiIiIiJSBIuTREREREREREREpAgWJ4mIiIiIiIiIiEgRDa44WVhYiIiICKXDqFJGRobSIRAREREREREREdVrihcnX331VcyaNavKfg8ePMDnn38Oc3Nz9OvXrw4iq76CggL4+PigT58+aNGihSIxaDufdeXkyZOYM2cOdHR0oKOjAw8PD+zbt0/psHD06FG4u7tr4vLy8sKpU6eUDouIiIiIiIiIqFFRvDhpbW0NAwODKvtZWFjA19cXzZo1q4Oono6BgQG8vb1x9epVlJSUVOvYpKSkap+vvGO0nc+60q9fPyxbtgwdOnQAAKxfvx7Dhg1TJJZH52vgwIHYvHkzAKBDhw747rvv8PrrrysSFxERERERERFRY6WvdAA7duzQuq+Ojg4sLCxw7969Wozo2RgaGsLS0hLp6elaHxMfHw8PDw+cPHnymY+pznzWJUNDQwCAkZGRIucvb77UsahjIyIiIiIiIiKiuqV4cbKxu3XrFgYPHgyVSlWrxzRmnC8iIiIiIiIiovqpxh/rFhFERkZi5syZ6NSpE+7evYsRI0bAwsICTk5O2LNnDwBApVIhJCQEH374Ifr37685PicnB4sXL8bYsWMxbdo0uLi4ICAgACJS7vlWrFiBF154ATNnzkRERAQ2bNig2UcQALKysuDn56dp0zY+beXl5cHb2xuenp6YP38+Pv/8c+Tm5pbpc+3aNYwcORKzZ8/GBx98gH79+uHChQsAgKCgIMTGxuLu3buYNGmS5pj8/HwsX74cEyZMQO/eveHq6oqYmJgKjylvPnNzc7Ft2za899576Nu3LyIjI9GzZ0907NgRERERuHr1KoYPH46WLVvCwcEBv//+e5m4K4sBAMLDw9GuXTscP368WnMmIti3bx88PT3Rrl07pKen48MPP0SLFi3g5OSE33//Xes8VZXvyua4OirL4bZt22BkZAQdHR0sW7YMxcXFAIDg4GA0bdoUQUFBlc6nSqXCsWPHMGPGDHTq1Am3b9+Gi4sLOnToUK0VuEREREREREREDY5owd3dXdzd3bXpKsXFxXLgwAExMDAQADJ16lQ5fvy4BAcHi7GxsQCQiIgIERFJTEwUAGJvby8iIoWFheLi4iJjx44VlUolIiKbNm0SALJ//34REbG3txd12GlpaTJ27Fg5f/58mRhsbGzk8UtTt1UnvqoUFRWJs7OzTJw4UUpKSkRE5M8//xQ9Pb0y57e1tRUbGxvNNZqamoqjo6Pm54/OgdrEiRPl8uXLmu/d3NzE0tJSMjMzKzzm8flUqVQSFxcnAMTExERCQ0Pl0qVLAkA6duwoX3/9tWRkZMgff/whAMTFxaVaMezdu1cMDQ01uanMo3krKSmRpKQkadasmQCQJUuWSEJCgmzdulUAiLOzc7XyVFm+K5vjytofV1UO582bJwDk4sWLmrbExEQZPny45vuK5jM1NVVOnTolhoaGAkB8fX3l8OHDMmHCBMnOzq4yNhGRnTt3PjEHRERERERERET1XEiNFyfV7OzsBIDk5ORo2vz9/QWAjB49WkRKi1SPFof8/PwEgFy5ckVzTFFRkWzatEkePHggIv9X5Lp+/bqMHz9eUlNTnzj3o4Wwitq0ia8qa9asEQASGxtb7rWr+fn5yfbt20WktGBoY2Mj+vr6mp8/XiCLiooSAOV+HThwoNxjRJ6cz4rarKysysRXUlIirVq1ElNT02rFIFKaH22Ul5MuXbo8EYelpaU0bdpU06ZNnrTJ97MWJ6vK4f3798XY2FgmTpyoafP19dXMlTbzqZ6PtLS0KuN5HIuTRERERERERNQAhdTa27p1dUuHfvTt2kOHDgUAxMXFAYDmsVu1Y8eOAQDatWunadPX18e4ceNgbm5epu8777yD3NxctGzZstbiq0pYWBgAoFOnTuWOrebt7Y0hQ4YgMDAQPj4+ePjwoebR3/KcPn0ajo6OEJEnvgYPHlzhcY/PZ0VtzZs3f6KPhYUFMjMzqx2Dvv7Tb1v6eGw6OjowNzdHYWGhpq0m8lQTqsphixYt8Mknn2Dz5s24ffs2RARHjhzBX//6VwDazad6PiwsLOrsuoiIiIiIiIiIlFRrxcnyWFlZAQDat29f7s9TUlIAaFd0WrFiBXbu3Inly5fXWXyPu337NgAgLS2t0n7R0dHo1q0bbGxssGDBAhgbG1faPy0tDTdu3Hhi70oAdfZSl/oQQ0Wqm6dnkZqaiqKiIq1y6O3tjaZNmyIgIABnzpyBs7Ozpnhbn+eTiIiIiIiIiEgpdVqcVBfxXF1dy/159+7dAQA+Pj4oKSnRtCckJOCnn34q0/edd97B3LlzMXfu3Cd+pl6B9vDhQwBASUmJZlWgVPBiHW3ie5yDgwMA4ODBg5X28/DwQFFREd566y1NPI/H8ugqPAcHB83LUx4VGxuLtWvXlntMTasPMVTk8Txpm+/qxioimDJlCvT09LTKYcuWLTF58mSsX78eq1evxvjx4zU/03Y+iYiIiIiIiIgak6d/JldLxcXFmtVjv/76K3r16gUvLy8AQHZ2NoDSNywDwJw5cxAcHIzdu3fD1dUVI0aMwN27d5Gamop169YBKFuAWrRoESIjI/H+++/j6NGj6NmzJ4DSQtCVK1ewZMkSeHh4IDQ0VHPcoUOH4ObmplV8VZk1axZ27tyJuXPnomPHjujfvz+ioqJw584dAEB8fDysra2RnJyMrKwshIWF4d69e8jIyABQuqLSysoKnTt3RnJyMm7evIkOHTpg2LBhsLa2xuLFi3Hr1i28+eabuHz5MqKjo7F7924AeOKY8uYTKH1DNFC2iFZUVKTpr37Eu6CgAEDpKj49PT2tYggNDcWYMWOwa9cuTdGuInl5eQBK3yCufkRbfU4R0RQY1ddQVFSEJk2aaI6vLE/a5Lu8+VLnKTs7GyUlJWUex8/MzMSsWbNgYGAAXV3dKnOoXsU5c+ZMrF69Gjdv3oStra1mPG3mUz0fOTk5Va6uJSIiIiIiIiJ6HtT6ysmAgADcv38fqampSE5OxvHjx9GkSRPk5ubC19cXAJCcnIyVK1eiZcuWiIqKwqBBg3D27Fn4+voiOzsbX3/9NTIyMrB48WIkJCQAAJYtW4aUlBR89NFHyMzMhIuLC5YuXYqMjAwsX74czs7OWLlyJT7++GO88847cHR0xNixY5GRkVFmBV1F8WmjR48eCA8Ph4ODA9zd3eHk5ITo6Gj06NEDXl5euHHjBlQqFXx9fWFiYoL58+ejc+fOmDdvHszMzODr6wsjIyO4u7vDxMQEp0+fBgAYGBggPDwcQ4YMwd69ezFz5kykpqYiODgYJiYmAPDEMeXNZ1xcHObNmwegdPXpr7/+ikOHDiExMREAMG/ePKSlpWHNmjWaNj8/P9y/f1+rGF544QWYmJjghRdeqHCOTp48iTlz5iApKQkA4OnpiX379iEwMFBzTh8fH2RmZiIgIEBTMFywYIGmsFpVnrTJ9+PzFR4ejsmTJwMoLVK+9NJLGDhwIAYOHAh7e3tYWlri+++/1xSyq8qhWuvWreHm5oYJEyaUmYfK5lNPTw9fffWVZj68vb1x9uzZqm9AIiIiIiIiIqIGTkcqe875f40aNQoAEBISovXADg4OuHr1aqWPUSupvsdHpRpannJzc9G9e3dcuHChTNGytoWEhGD06NENZp6IiIiIiIiIiADsqtM9JxsSHR2dKr+uXLmidJhUzwQGBuKTTz6p08IkEREREREREVFDVWt7TqrfSlxf98+rKj6uQKsf6vt9BABRUVHw9PREXl4eVCoVi9ZERERERERERFqq8ZWTOTk5mDt3Lm7dugUAmDZtGiIjI2v6NE+tvsdHpRpSnpo1a4asrCzo6upi+/btle7BSURERERERERE/6fW9pwkorrDPSeJiIiIiIiIqAHinpNERERERERERESkDBYniYiIiIiIiIiISBEsThIREREREREREZEiWJwkIiIiIiIiIiIiRbA4SURERERERERERIpgcZKIiIiIiIiIiIgUweIkERERERERERERKYLFSSIiIiIiIiIiIlIEi5NERERERERERESkCBYniYiIiIiIiIiISBEsThIREREREREREZEiWJwkIiIiIiIiIiIiRbA4SURERERERERERIrQ17ZjZGQkRo0aVZuxENFTSkpKUjoEIiIiIiIiIqJq06o46e7uXttxENEzaN++Pfr06aN0GERERERERERE1aIjIqJ0EERERERERERERNTo7OKek0RERERERERERKQIFieJiIiIiIiIiIhIESxOEhERERERERERkSJYnCQiIiIiIiIiIiJFaPW2biKi+qR9+/a4deuW0mEQUR1r164dkpKSlA6DiIiIiIhqEIuTRNTg3Lp1C//85z/Rp08fpUMhojoSGRkJf39/pcMgIiIiIqIaxuIkETVIr732Gtzd3ZUOg4jqiIgoHQIREREREdUC7jlJREREREREREREimBxkoiIiIiIiIiIiBTB4iQREREREREREREpgsVJIiIiIiIiIiIiUgSLk0RERERERERERKQIFieJiIiIiIiIiIhIESxOEhERERERERERkSJYnCQiIiIiIiIiIiJFsDhJREREREREREREimBxkoiIiIiIiIiIiBTB4iQREREREREREREpgsVJIiIiIiIiIiIiUgSLk0RERERERERERKQIFieJiIiIiIiIiIhIESxOEhE9g5SUFISEhMDHx6dOzpeRkVEn51FSXc/ps3je85GZmflUxz3v80JERERERDVHvzqdExIScPr06dqKhYieQuvWrdGvXz+lw2iULl++jLVr1+Lbb7+Fvb095s2bVyvnKSgogJ+fH0JDQxEdHQ2VSlUr53laIoI1a9bg9u3biI6ORnFxMTZu3IguXbqU225vb1/hWDU9p6+++ir69++Pb7755pnGeVRt5uPo0aP49ttvsXv3bgCAp6cnPDw88Prrr9fYOapSXFyMFStWIDQ0FFFRUSguLtbquPp+nxIRERERUf2kIyKibef33nsPO3bsqM14iKia9PX1UVRUpHQYdUpHRwc7d+7EqFGjlA4FBQUFMDQ0hL29Pa5cuVJr58nPz0fbtm2Rnp6OavzarhOrVq3CvHnzkJGRgZycHIwfPx5z5sxBZGRkue3Ozs6Vjve0c5qUlIT27duXaRszZgzs7OywePHiSvtVV23mIy8vD82aNUOHDh2QmJhYo2Nr62mvrzbnJSQkBKNHj6539z8RERERET2TXdVaOalSqeDu7o6QkJDaCoiIqkH9xzopx8DAoE7OY2hoCEtLS6Snp9fJ+apj3bp1aNu2LfT19WFmZoYff/wRAODh4VFue1WeZk7j4+Ph4eGBkydPlml//B/UKupXXbWZDyMjI805lPK011ef71MiIiIiIqqfuOckERE9k6SkJOjo6GjdXtNu3bqFwYMH4969ezXSj4iIiIiIiOpOtVZOEhE1RKdPn8bUqVPRu3dvWFhYYOnSpcjIyICxsTFycnLg7++Pq1evwsLCAufPn8e7776L6dOnQ0dHB9euXcPcuXPRuXNn3LlzBwkJCQgMDMTLL79c4fny8/OxevVqXLt2DefPn4eZmRn8/f3RrVs3rWPOy8vD/PnzkZOTA0tLS6hUKuTm5gIoXcV+8uRJ7N27F3v37sWpU6fw/vvvIz4+HufPn4euri58fHygq6uLwsJCXLx4EU5OTliwYAHMzMwQFRWF3bt3Y8+ePYiKisLHH3+Mo0ePwsrKCosWLcKIESMAlL4MpaJxzM3NERoaitDQUOTl5eHu3buYNGkSAGDAgAE4duzYE+0rVqyAsbHxU+WwsjwEBQUhNjYWpqammDRpEtavXw+VSoU9e/bg4MGDiI+Px4kTJ8rtt2HDBnh5eQEo3TszKysL33//PT799FNNW1X50Dbv4eHh8PDwQHBwMFxcXJ5qHqozL7m5ufjPf/6DgwcPIjExEX5+fpgyZQoePHiA4OBgtGrVCrNnz0ZERARatmyJbdu2oXfv3k+cIy4uDt7e3oiIiICtrS2+/vprDBw4UOt5eZrPEBERERERNSJSDe7u7uLu7l6dQ4ioFu3cuVOq+TF+LgCQnTt3at3fzs5OzM3NpaSkRERERo0aJSkpKVJYWCguLi4yduxYUalUIiKyadMmASD79+8XERFbW1uxsbEREZHCwkIxNTUVR0fHJ+Kxt7fXfD9x4kS5fPmy5ns3NzextLSUzMxMreItKioSZ2dnmThxoibmP//8U/T09ASAFBQUyKlTp8TQ0FAAiK+vrxw+fFgmTJggd+7cETs7O/nyyy8146WkpIidnZ1YW1vL/fv35cCBA2JgYCAAZOrUqXL8+HEJDg4WY2NjASARERGSlZVV6Tjp6ekVXn9V7dp4/Niq8lDeuRITE59oL6+fjY3NE5+jR9uqyodaVXnfu3evGBoaau6t6lx/RSqbF5VKJXFxcQJATExMJDQ0VC5duiQApGPHjvL1119LRkaG/PHHHwJAXFxcyoxtb28vAGT69OkSFhYm69evFyMjI9HV1ZXz589rPS/afIa00Vh/3xERERERPedCWJwkasAa6x/r1S1OtmzZUgBIQECAqFQqiYmJkczMTPHz8xMAcuXKFU3foqIi2bRpkzx48EBERPz8/GT79u0iUlrssbGxEX19/SfiUReSoqKiBEC5XwcOHNAq3jVr1ggAiY2NLdNuZ2dXJt9dunQRAJKWlqZpmzt3rgCQO3fulDl28+bNAkBmzZpVZqycnBxNH39/fwEgo0eP1nqcx6+/onmprsePrSoP5Z2rpKREq+KkughXUZs2+dA270VFRU91/RWpal7KmwMrK6sy11tSUiKtWrUSU1PTcufg0aJ6QECAABAPDw+t71NtPkPaaKy/74iIiIiInnMhfKybiJ5769atw7hx4zBjxgxs3boVa9euhYmJCY4dOwYAaNeunaavvr4+xo0bp/ne29sbOTk5CAwMxIMHD/Dw4UMUFxdXeK7Tp0/D0dERFy9efOp4w8LCAACdOnUq066rW3abYPV+jhYWFpq2U6dOAQCaN29epm///v0BAL/99luZsZo1a6bpM3ToUPzzn/9EXFwc7t69q9U4daW6eQBQY/tdapMPbfOur1+z/9utal7Km4PHc6qjowMLCwtcvXq13HOYmJho/nv48OGYMWMGYmNjNS+9qeo+fZrcERERERFR48EX4hDRc2/kyJE4d+4cBg0ahDNnzqBfv34ICgpCSkoKgNI99SoSHR2Nbt26wcbGBgsWLKhyz8S0tDTcuHHjiX33gNK9IrVx+/ZtzVjVpS4MJSQklGl/8cUXAQCmpqYVHmtlZQUAaN++/TONUxuqm4eapE0+aiLv1ZGamoqioqI6nxd1/jt06KD1fapk7oiIiIiIqP5jcZKInntffPEFOnfujEOHDmH79u0oLi7G/Pnz0b17dwCAj48PSkpKNP0TEhLw008/AQA8PDxQVFSEt956CwA0/eR/X5TyOAcHB+Tn52P58uVl2mNjY7F27Vqt4nVwcAAAHDx4sBpXWUq9svHxY5OSkgAArq6uFR6rLjK5uro+0zi1QZs8aLsa7/F+6tWFDx8+1IydmZmpGV+bfGib95pYMSgimDJlCvT09Kp9fz4rdf4HDx6s9X1a1zESEREREVHDwuIkESmmU6dOcHZ2xpIlS3D69OkyBcKatGLFCs0jqCNHjoSJiQnatm2LOXPmwMjICLt374arqysCAwOxYMECLF26FH/9618BAMnJybh9+zbCwsIQHByMjIwMAKWrwZKSkpCXlwcAKCgoAAAMGzYM1tbWWLx4McaPH4/g4GDMnz8fM2bMKPO4eGVmzZoFPT09zJ07F7/88gvy8vIQHh6OO3fuAADi4+PLnDMnJ0dz7GeffQZHR0esWbMGycnJmvbAwED07dsXU6dOLXOuR4tlv/76K3r16gUvLy+tx3nw4AEAoLCwsMy4FbVr4/E5BarOQ+fOnZGcnIybN29qjsnOzgYAZGVladrK66cusi1ZsgRxcXFYtWqVplB56NAheHt7V5kPbfIeGhoKMzMz/Pzzz5Vev3rc7OzsJz4TmZmZ8PLygoGBAXR1daucl/z8fABlC4FFRUVl5ufRuX50lae6aKvOpYjA398fQ4cOxUcffaT1fVpVjERERERE1LjpLVy4cKG2nXft2gUAcHd3r614iKgaLl26hN27d6MaH+N65fPPP8fNmzcRERGB7777DqtWrcKFCxeQn5+P1q1bl9kP8VGLFi2Cu7s7HB0dtTrP/PnzERYWhvT0dGzYsAEvvvgiNm3aBBsbGwwdOhTXr1/HmTNnEBUVBVtbW/j6+sLQ0BBA6X57ERERuHDhAv7+97/DxsYGUVFRuHnzJnr16oWVK1ciOjoamZmZMDMzg6OjI8aMGYMbN24gLCwMR44cQbt27RAYGFhmb8jKtG7dGgMGDMD58+exdu1abN68Ga1bt0Z2djbeeustmJqaYvv27di/fz8A4P79+2jXrh3atGmDJk2a4IMPPkB6ejrWr1+Pc+fO4ciRIzAzM8P333+Ppk2bAgDWrl2LtLQ0mJiYoEuXLsjJycHJkyexbt06GBoaajVOTEwMli1bhjNnzmhWGpqbm+PevXvltrdu3brKa79x4waWLFlSZk7t7e1haWlZYR5GjhyJzMxMXL58GT169MBLL72E3Nxc+Pj4ICIiAjk5OTAxMYGjoyMePHhQph8A9OrVC9HR0di3bx9iYmIwY8YMREZGon///ujQoQNcXFzg6upaYT6srKzQuXNnvPvuu5XmPTExET///DNGjRoFa2vrcq8/PDwcCxYswNWrV5GdnY2dO3diz5492Lx5M5YuXYp58+bh9OnTmDlzJnr06FHp/dmvXz+sWLECUVFRyM7ORp8+fRAXF4dvv/0WIoKcnBw4Ozvjhx9+wI4dOwCU7kFqb28PIyMj2NvbIz09HVu3bsVvv/2GX3/9FV27dsU333wDXV3dKu9TKysrdOzYEaamppXmzsjISKvPRUP/fUdEREREROWK1ZFqPFc1atQoAEBISEitRURE2gsJCcHo0aMb7OORlpaWuHfvXpk2PT09iAhKSkpgZ2eHv/3tb5rHjNWFNR0dHezcuVPzO4mqz8HBAVevXm2w9w41Pg399x0REREREZVrFx/rJiLFlPdSFZVKpXmUNS4uDitXroSbmxssLCwwYsQI/PDDD3UdZo3S0dGp8uvKlStKh1krGvO1ExERERERUfn0lQ6AiBqP7OxsZGRkICMjA5mZmVo9zqneHy83Nxc//vgjfvzxx9oOs1bVl1Vf6rdK5+Tk1Nnbk+vLtRMREREREVH9weIkEWktPz8f6enpZb4KCgrKbX/8Ky0t7YmXo9jY2Gh1XvWqOkNDQ3h6esLf3782Lq9RyMnJga+vL27dugUAmDZtGv7xj3+gT58+CkdGREREREREjRGLk0SNSEVFRG0KjPfv39esYnycgYEBzM3Nn/iysbEpt139NWPGDCQkJFT4lu6mTZuisLAQNjY2+OSTTzBx4kQ0a9aMxclnYGxsDF9fX/j6+iodChEREREREZFyxcmMjAyYmZkpdfo6kZKSguPHjyMuLg7z5s1TOpxKNYZ8PM/8/f2RmZmpeWRa/dj0o99nZGSUe6yRkRHMzMxgZmYGU1NTzX+3b98eTk5OMDMzg7m5ebl9zMzM8MILLzx13JaWltDT03uiONmkSROoVCq8+eab8Pb2xptvvgkdHZ2nPg8RERERERER1U91WpwsKCiAn58fQkNDER0dDZVKVZenr5KIYM2aNbh9+zaio6NRXFyMjRs3okuXLuW229vbVzjW5cuXsXbtWnz77bewt7d/5uLkq6++iv79++Obb755pnEeVZv5OHnyJA4ePIjly5cDAD744AOMGDECw4YNq7FzPI2jR4/i22+/xe7duwEAnp6e8PDwwOuvv65oXM9q5cqVTxQN27ZtW+b78r5MTU01b8BWgqmpKXR1S9/LpaurCxGBubk5pk6dCi8vL1hZWSkWGxERERERERHVvjotThoYGMDb2xt+fn4VPsappNWrV2PevHnIyMhATk4Oxo8fj8zMzArbK9O1a1f4+fnh22+/rXYcSUlJaN++fZk2a2trGBgYVNmvOmozH/369UO/fv3w73//Gzdv3sT69eu1evlJbXh0ngYOHIhXX30Vu3fvRocOHfDdd98pElNNS0pKUjqEp2JmZoaHDx8CAHr37o0ZM2ZgxIgRihZMiYiIiIiIiKju1Plj3YaGhrC0tER6enpdn7pK69atQ9u2baGvrw8zMzPNW4E9PDzKba/K48VEbcTHx8PDwwMnT54s075jxw6t+lVXbefD0NAQAGR+5XsAACAASURBVBQrTJY3T+pY1LGRcgYNGoSkpCSMGzcOPXv2VDocIiIiIiIiIqpjfCHOIypaifisKxS1devWLQwePLjKx6u17dfYcZ7qv+7du2P16tVKh0FERERERERECtGt7RPk5eXB29sbnp6emD9/Pj7//HPk5uYCAFQqFY4dO4YZM2agU6dOuH37NlxcXNChQwekp6cjMzMTn332GebMmQNvb28MGjQI3t7eSE9Ph4ggMjISM2fORKdOnXD37l2MGDECFhYWcHJywp49ezQxVDYOAISGhmLSpEnIy8vD3bt3MWnSJEyaNAk7duwotz0nJ+ep5+PatWsYOXIkZs+ejQ8++AD9+vXDhQsXAABBQUGIjY3VnEs9RyEhIfjwww/Rv3//Cvtt2LABOjo6mpeGZGVlwc/Pr0xbVflQy8/Px/LlyzFhwgT07t0brq6uiImJ0fw8PDwc7dq1w/Hjx6t17SKCffv2wdPTE+3atUN6ejo+/PBDtGjRAk5OTvj999+1zqs211vePFVXZfnatm0bjIyMoKOjg2XLlqG4uBgAEBwcjKZNmyIoKKjS+azq/iciIiIiIiIieu5JNbi7u4u7u7vW/YuKisTZ2VkmTpwoJSUlIiLy559/ip6engCQgoICOXXqlBgaGgoA8fX1lcOHD8uECRPkzp07YmdnJ19++aVmvJSUFLGzsxNra2u5f/++HDhwQAwMDASATJ06VY4fPy7BwcFibGwsACQiIkKysrIqHSc9PV3TDkDs7e2fuI6K2rXx+LG2trZiY2MjIiKFhYViamoqjo6OlZ4rMTHxifby+tnY2MjjKX20rap8qE2cOFEuX76s+d7NzU0sLS0lMzNTRET27t0rhoaGsn///iqv397eXjN2SUmJJCUlSbNmzQSALFmyRBISEmTr1q0CQJydnaW4uFirvGpzvRXNU2Xtj6sqX/PmzRMAcvHiRU1bYmKiDB8+XPN9RfOZmppa4f2fnZ1dZWwiIjt37nxiDhoDALJz506lwyCiOtRYf98RERERET3nQmq1OLlmzRoBILGxsWXa7ezsyvyB0aVLFwEgaWlpmra5c+cKALlz506ZYzdv3iwAZNasWWXGysnJ0fTx9/cXADJ69GitxxGpm+Kkn5+fbN++XUREVCqV2NjYiL6+fqXnKikp0ao4+WghsLw2bfIRFRUlAMr9OnDggOaYoqIira6/vJjU+X70+iwtLaVp06ZPxFRRXrW5XpFnz2lV+bp//74YGxvLxIkTNW2+vr6audJmPsu7/7XVWP9YZ3GSqPFprL/viIiIiIiecyG1uudkWFgYAKBTp05l2nV1yz5Nrn4M18LCQtN26tQpAEDz5s3L9FU/2vzbb7+VGatZs2aaPkOHDsU///lPxMXF4e7du1qNU1e8vb2Rk5ODwMBAPHjwAA8fPtQ8DlyRRx/Lfhba5OP06dNwdHTExYsXKx1LX//pb53Hr0dHRwfm5uZITU19IqaK8lpXqspXixYt8Mknn2DFihVYuHAhrKyscOTIEcyaNQuAdvNZ3v1PRERERERERNQY1Oqek7dv3wYApKWlVftYdXEqISGhTPuLL74IADA1Na3wWCsrKwBA+/btn2mc2hAdHY1u3brBxsYGCxYsgLGxcZ2dW5t8pKWl4caNG0/sQwlA8RfLPJrX2paamoqioiKt8uXt7Y2mTZsiICAAZ86cgbOzs6Z4W5/nk4iIiIiIiIhIabVanHRwcAAAHDx4sNrHqlc2Pn5sUlISAMDV1bXCY9XFN1dX12capzZ4eHigqKgIb731FgCgpKQEQOnLYtSqWklZUT/1CryHDx9qxs7MzNSMr00+HBwcNC9weVRsbCzWrl1b7Rhr0qN5Baq+XrXqxioimDJlCvT09LTKV8uWLTF58mSsX78eq1evxvjx4zU/03Y+iYiIiIiIiIgao1otTs6aNQt6enqYO3cufvnlF+Tl5SE8PBx37twBAMTHxwMACgoKAKDMW7A/++wzODo6Ys2aNUhOTta0BwYGom/fvpg6dWqZcz1agPr111/Rq1cveHl5aT3OgwcPAACFhYVlxq2oXRt5eXllrg8AkpOTcfv2bYSFhSE4OBgZGRkASldUJiUloXPnzkhOTsbNmzc1x2RnZwMofSO1Wnn91MXHJUuWIC4uDqtWrdIU7g4dOgRvb+8q8zFs2DBYW1tj8eLFGD9+PIKDgzF//nzMmDED48aNA1D6dnMzMzP8/PPPWs/BoysH1fPxaIFPfY1FRUVljq8or9pcr0qlKnee1NebnZ2tKTaqZWZmwsvLCwYGBtDV1a0yX2ozZ85EYWEhbt68CVtbW027NvNZ3v1PRERERERERNQY1GpxskePHggPD4eDgwPc3d3h5OSE6Oho9OjRA15eXoiJicGXX36JxMREAKWPx549exYAYGRkhMjISLz//vv48MMPMXPmTHz22Wdo0aIFwsPD0aRJkzLnCggIwP3795Gamork5GQcP34cTZo00WqcmJgYzJ07F0Dp49+LFi3C+fPnK2zXxo0bNzBnzhwAQGJiIgICApCeng5fX1+YmJhg/vz56Ny5M+bNmwczMzP4+vrCyMgI7u7uMDExwenTpwGUFvV8fX0BlBY2V65ciaysrCf6AcDy5cvh7OyMlStX4uOPP8Y777wDR0dHjB07FhkZGXBycqo0Hzdu3ECTJk0QHh6OIUOGYO/evZg5cyZSU1MRHBwMExMTAMALL7wAExMTvPDCCxVe/8mTJzFnzhxNAc/T0xP79u1DYGCgJt8+Pj7IzMxEQECApmC4YMEC5OfnV5lXba63uLj4iXkKDw/H5MmTAZQWKV966SUMHDgQAwcOhL29PSwtLfH999/Dzc0NAKrMl1rr1q3h5uaGCRMmlJkHAwODCudTT08PX331Vbn3PxERERERERFRY6Ajjy5fq8KoUaMAACEhIbUWUHU5ODjg6tWrqMZlUAPQ0PKam5uL7t2748KFC2WKlrUtJCQEo0ePbjDzVFOaNGmiyNYCRKQsfX39J1bYExERERFRg7arVt/W/bzS5u3Zly9f1jx2TM+/wMBAfPLJJ3VamGzMwsPDcffuXaXDIKJKJCcnY+PGjbh48SLMzMzQv39//OUvf0GbNm2eeszWrVvXYIRERERERFQfNPjipHovw5ycnDp783VjW6WmBCXyWl1RUVHw9PREXl4eVCoVrly5onRIjUa/fv2UDoGItDBt2jTEx8cjKCgI//rXv7B//3688cYbmDBhAtzd3fkPOkREREREVLt7TtamnJwczJ07F7du3QJQ+gdQZGSkwlHRs2pIeW3WrBmysrKgq6uL7du3V7oHJxFRY2VtbY1FixYhISEBYWFh6NSpEyZPnow2bdrAy8sLsbGxSodIREREREQKavB7ThI1Zo11z0kiatju3buHH374AevXr0dSUhIGDRqEjz/+GG+//TZ0dRvsv5sSEREREVH17eJfAERERFSnWrVqhTlz5uD69ev4z3/+g5KSEgwdOhS2trb45ptv8ODBA6VDJCIiIiKiOsLiJBERESlCT08PQ4cOxaFDh3DlyhUMGzYMvr6+6NixI6ZPn474+HilQyQiIiIiolrG4iQREREprkuXLvD390dSUhL8/Pzwyy+/wNbWFkOGDKm3ew8TEREREdGzY3GSiIiI6g1jY2N4enri0qVLCA4ORnJyMvr27YsBAwYgNDSUe+wSERERET1nWJwkIiKiekdfXx9jxozB77//jpMnT6J58+YYOnQounfvjl27drFISURERET0nGBxkoiIiOq1N954AwcOHMCFCxfQo0cPvPfee3j55ZexZcsWlJSUKB0eERERERE9AxYniYiIqEFwcnLCli1bcP78efTs2RPjx49H9+7dsWXLFqhUKqXDIyIiIiKip8DiJBERETUojo6O2LJlC86dO4euXbti3Lhx6N27N8LCwpQOjYiIiIiIqonFSSIiImqQnJycEBISgvPnz6N9+/b4n//5H7i5ueGPP/5QOjQiIiIiItISi5NERETUoDk5OWH//v2IjIzEw4cP0bt3b4waNQrXr19XOjQiIiIiIqoCi5NERET0XHjttddw4sQJhIWF4fLly+jatSu8vLyQkpKidGhERERERFQBFieJiIjoueLq6oqzZ89i7dq1OHDgAGxtbTFnzhxkZ2crHRoRERERET2GxUkiIiJ67ujr68PT0xPXrl3Dp59+isDAQDg4OGDjxo18szcRERERUT2iIyKibedRo0YhKSkJ3t7etRkTEQBARKCjo6N0GPVaZGQk/P39UY2PMRFRo3T//n2sWLECAQEBsLa2xqpVqzBo0CClwyIiIiIiaux2Vas46e3tDX9//9oMiIiqqV27dkhKSlI6DCKiBuHq1auYPn06wsLCMHr0aHzzzTdo166d0mERERERETVW1StOEtWVO3fuYObMmdixYwfefvttBAQEwM7OTumwiIjoOfHrr7/ik08+wc2bNzFr1izMmTMHBgYGSodFRERERNTY7OKek1QvWVlZ4d///jeOHz+OW7duwdHREdOnT+fLDIiIqEa4urriwoUL8PX1xcqVK9GlSxds2bJF6bCIiIiIiBodFiepXuvfvz/Onj2LjRs3Yvv27XBwcMCWLVu4xyIRET2zJk2aYPr06bhy5QoGDBiAjz76CK6urrh06ZLSoRERERERNRosTlK9p6urCw8PD1y9ehUjR47E+PHjMWDAAFy4cEHp0IiI6DlgZWWFLVu24NixY7h//z569uyJ6dOnIysrS+nQiIiIiIieeyxOUoNhYWGBVatWITo6GsXFxejZsyc8PDxw//59pUMjIqLnQP/+/XHmzBkEBARg27ZtcHBwwK5du5QOi4iIiIjoucYX4lCDJCLYunUrPvvsMxQVFeGLL77A1KlToaenp3RoVEN27drFogARac3d3R3u7u41Nl5aWho+++wz/Otf/8Lbb7+NwMBAdOzYscbGJyIiIiIiAHwhDjVUOjo6mke9PTw88Omnn6JPnz7473//q3RoVEN27dqFyMhIpcMgogYgMjKyxv8xo0WLFvjhhx9w4sQJxMfH46WXXsLChQtRVFRUo+chIiIiImrsuHKSnguXLl3CtGnTcPToUYwdOxZLly5F27ZtlQ6LnsGoUaMAACEhIQpHQkT1XW3/vigqKsLKlSuxcOFC2NvbY8OGDXB2dq6VcxERERERNTJcOUnPB0dHRxw5cgT79u3DqVOn0KVLFyxcuBD5+flKh0ZERA1ckyZNMHv2bMTExKBVq1bo06cPvLy8kJ2drXRoREREREQNHouT9FwZMmQILl++DF9fX/j7+6NLly7YsmULuECYiIiela2tLcLCwvCvf/0LP/74IxwcHLBnzx6lwyIiIiIiatBYnKTnTtOmTTF9+nRcuXIFb7/9NsaPH48+ffogKipK6dCIiKiBU+95fOnSJQwcOBAjR47EyJEjkZycrHRoREREREQNEouT9Nxq06YNvvvuO0RHR6Np06Z4/fXX4eHhgbt37yodGhERNXCWlpbYtm0bDh06hHPnzsHR0RFbt25VOiwiIiIiogaHxUl67vXq1QsnTpzA3r17cfLkSdja2mLhwoUoKChQOjQiImrgBg0ahJiYGHh6euKjjz7C22+/jVu3bikdFhERERFRg8HiJDUaQ4YMQWxsLBYsWAA/Pz9069YNu3btUjosIiJq4AwNDbFs2TKcPHkS169fh5OTEzZs2KB0WEREREREDQKLk9SoGBoaYvbs2bhy5Qr69OmD0aNH480338SFCxeUDo2IiBq4vn374ty5c5g0aRImT57MVZRERERERFpgcZIapbZt22LLli2IiIhAVlYWXnnlFUyePBmpqalKh0ZERA2YehXliRMncP36dXTr1o2rKImIiIiIKsHiJDVqffv2xX//+19s3LgRoaGhsLOzw9KlS5Gfn690aERE1IC9/vrrOHfuHLy8vDB58mS88847uH37ttJhERERERHVOyxOUqOnq6uLDz/8EFevXsXcuXOxbNkydOnSBRs2bEBJSYnS4RERUQOlXkV55MgRXL58GS+//DK2b9+udFhERERERPUKi5NE/8vIyAizZ8/G9evX8be//Q1TpkyBs7Mzjh07pnRoRETUgA0YMAAXLlzAmDFjMHbsWIwZMwbp6elKh0VEREREVC+wOEn0mJYtW2LVqlWIiYlBmzZtMHDgQLi5ueHSpUtKh0ZERA2UsbExAgMDERYWhoiICHTv3h1Hjx5VOiwiIiIiIsWxOElUga5du+LAgQM4fPgw7t27h549e8LLy4svzSEioqfm6uqKixcv4o033sCbb76J6dOn4+HDh0qHRURERESkGBYniarg6uqKP/74Axs3bsSBAwfQuXNnLFy4EAUFBUqHRkREDZCZmRm2b9+OoKAgbNq0Cb1798aFCxeUDouIiIiISBEsThJpQVdXFx4eHoiLi8P8+fOxcuVKdOnSBVu2bIGIKB0e1YGUlBSEhITAx8enTs6XkZFRJ+dRUl3PqRKe9zxmZmY+1XHP+7xoy8PDAzExMTAzM8Orr76K5cuX80VsRERERNTosDhJVA3NmjXD7NmzERsbi7/85S8YN24c+vbti99++03p0KgWXb58GV999RVGjx6NrVu31tp5CgoK4OPjgz59+qBFixa1dp6nJSJYvXo1Zs+ejYEDB6Jfv364evVqhe2Vqas5rcqrr76KWbNm1eiYtZnHo0ePwt3dHTo6OtDR0YGXlxdOnTpVo+eoSnFxMZYtW4Y33nijWtdX3+9vpXTq1AlHjx7FwoULsWDBAvz1r3/FnTt3lA6LiIiIiKjO6AiXfRE9tT/++AOffvopjh49iuHDh8PX1xddu3ZVOqznwqhRowAAISEhCkdSqqCgAIaGhrC3t8eVK1dq7Tz5+flo27Yt0tPT692q3FWrVmHevHnIyMhATk4Oxo8fjzlz5iAyMrLcdmdn50rHq6s5rcyYMWNgZ2eHxYsXa9qSkpLQvn37Zxq3NvOYl5eHZs2aoUOHDkhMTKzRsbX1tNdXW/NS335fPK2oqCiMHTsWWVlZ2LBhA4YPH650SEREREREtW0XV04SPYNevXohPDwchw8fRmJiIpycnDBq1CgkJCQoHRrVMAMDgzo5j6GhISwtLevkXNW1bt06tG3bFvr6+jAzM8OPP/4IZ2fnCturUldzWpkdO3aUKUzGx8fj/ffff+ZxazOPRkZGmnMo5Wmvrz7f3/XBa6+9hpiYGLz33nt499134eHhgby8PKXDIiIiIiKqVSxOEtUAV1dX/P7779ixYwfOnDkDe3t7TJ8+Henp6UqHRlRjkpKSoKOjo3V7Q3Pr1i0MHjwY9+7dUzoUasQMDQ2xatUq/PjjjwgNDcX/+3//DxcvXlQ6LCIiIiKiWqOvdABEzwtdXV24u7tj2LBhCAoKwoIFC7B161bMnj0b06ZNU3SVU2Nx+vRpTJ06Fb1794aFhQWWLl2KjIwMGBsbIycnB/7+/rh69SosLCxw/vx5vPvuu5g+fTp0dHRw7do1zJ07F507d8adO3eQkJCAwMBAvPzyyxWeLz8/H6tXr8a1a9dw/vx5mJmZwd/fH926ddM65ry8PMyfPx85OTmwtLSESqVCbm4uAEClUuHkyZPYu3cv9u7di1OnTuH9999HfHw8zp8/D11dXfj4+EBXVxeFhYW4ePEinJycsGDBApiZmSEqKgq7d+/Gnj17EBUVhY8//hhHjx6FlZUVFi1ahBEjRgAofalJReOYm5sjNDQUoaGhyMvLw927dzFp0iQAwIABA3Ds2LEn2lesWAFjY+OnymFlsZiZmWH//v04ePAgfvrpJ8TExGDGjBkIDQ1FmzZtEBQUhN69ewMo3R9z7dq1+O9//4vmzZtj06ZNKCws1JynuLgYe/bswcGDBxEfH48TJ04gKCgIsbGxMDU1xaRJk7B+/Xps2LABXl5emjGzsrLw/fff49NPP9W0VZVHtarul/DwcHh4eCA4OBguLi5PNX+Pq+y+zs3NxX/+8x8cPHgQiYmJ8PPzw5QpU/DgwQMEBwejVatWmD17NiIiItCyZUts27ZNM7+PiouLg7e3NyIiImBra4uvv/4aAwcO1Hpenuaz1xi8++67eOWVV/Dee+/B2dkZS5cuxfTp05UOi4iIiIio5gkR1Yrs7GxZtmyZNG/eXNq1ayffffedFBcXKx1Wg+Hu7i7u7u7VOsbOzk7Mzc2lpKRERERGjRolKSkpUlhYKC4uLjJ27FhRqVQiIrJp0yYBIPv37xcREVtbW7GxsRERkcLCQjE1NRVHR8cy4wMQe3t7zfcTJ06Uy5cva753c3MTS0tLyczM1CreoqIicXZ2lokTJ2pi/vPPP0VPT08ASEFBgZw6dUoMDQ0FgPj6+srhw4dlwoQJcufOHbGzs5Mvv/xSM15KSorY2dmJtbW13L9/Xw4cOCAGBgYCQKZOnSrHjx+X4OBgMTY2FgASEREhWVlZlY6Tnp5e4fVX1a6NR4+tKpYHDx5IUlKSNGvWTADIkiVLJCEhQbZu3SoAxNnZWXPc6tWrRVdXV+7fvy8iIr6+vgJAvL29NX0SExOfiL28a7GxsZHH/3f5aFtVeVSr6n7Zu3evGBoaau5JbeetMpXd1yqVSuLi4gSAmJiYSGhoqFy6dEkASMeOHeXrr7+WjIwM+eOPPwSAuLi4lBnb3t5eAMj06dMlLCxM1q9fL0ZGRqKrqyvnz5/Xel60+exV5Wl+XzQURUVF8uWXX4qurq588MEHkp2drXRIREREREQ1KYTFSaJalpqaKtOmTRN9fX3p2rWrhISEKB1Sg/A0xYaWLVsKAAkICBCVSiUxMTGSmZkpfn5+AkCuXLmi6VtUVCSbNm2SBw8eiIiIn5+fbN++XURKizY2Njair69fZvxHC0JRUVECoNyvAwcOaBXvmjVrBIDExsaWabezsytTvOnSpYsAkLS0NE3b3LlzBYDcuXOnzLGbN28WADJr1qwyY+Xk5Gj6+Pv7CwAZPXq01uM8fv0VzUt1PXqstrGo50OtpKRELC0tpWnTppq2IUOGiI6Ojjx8+FBERGJiYgSAvPrqq2WO06Y4qS7CVdSmTR61vV+Kioq0mTat57yq+7q8ObCysnpiflu1aiWmpqblzsGjxfiAgAABIB4eHlrf39p89qryPBcn1Q4fPiytW7cWe3t7OXv2rNLhEBERERHVlBDuOUlUy1q1aoVVq1ZpHk8dPXo0+vTpgxMnTigd2nNn3bp1MDY2xowZM+Ds7IycnByYmJjg2LFjAIB27dpp+urr62PcuHEwNzcHAHh7e2PIkCEIDAyEj48PHj58iOLi4grPdfr0aTg6OkJEnvgaPHiwVvGGhYUBADp16lSmXVe37K9m9X6OFhYWmrZTp04BAJo3b16mb//+/QEAv/32W5mxmjVrpukzdOhQAKWP42o7Tl3QNpbH97fU0dGBubl5mce23dzcICI4ePAggP97+c5f/vKXMsfVBG3yqO39oq9fs7utVHVflzcHj8+/jo4OLCwskJmZWe45TExMNP+tfrt0bGys1vd3dT97jZWrqyvOnTuHDh064LXXXsOqVauUDomIiIiIqEawOElUR+zt7RESEoKoqCgYGhrCxcUFbm5uuHDhgtKhPTdGjhyJc+fOYdCgQThz5gz69euHoKAgpKSkACgtxlUkOjoa3bp1g42NDRYsWFDlnolpaWm4cePGE/vnAaV7RWrj9u3bmrGqS13gefzN8C+++CIAwNTUtMJjraysAADt27d/pnFqWk3GMnXqVHz//feYMGECPv30U8ycOROLFi3CV199VWPxqmmTx5q4X6ojNTUVRUVF1b6vn5U6Vx06dND6/q7rGBuyF198Eb/88gsWLVqEmTNn4t1338WDBw+UDouIiIiI6JmwOElUx5ydnREeHo7Q0FCkpKTglVdewT/+8Q/cunVL6dAavC+++AKdO3fGoUOHsH37dhQXF2P+/Pno3r07AMDHxwclJSWa/gkJCfjpp58AAB4eHigqKsJbb70FAJp+8r8vPHmcg4MD8vPzsXz58jLtsbGxWLt2rVbxOjg4AIBmdV91qFcTPn5sUlISgNJVVhVRF4tcXV2faZyaVpOxqFQqXLx4EVFRUVixYgX27duHL774QquViY+v2lOvLnz48CGA0ntDvYpQRLTKo7b3S02sGBQRTJkyBXp6etW+r5+VOleDBw/W+v6u6xgbOl1dXcyePRuHDx9GdHQ0XnnlFZw+fVrpsIiIiIiInl7dP0pORGoqlUqCgoKkY8eOYmBgINOnT5e7d+8qHVa98DR7yBkaGmr2kCwsLBQTExNxdnaW69evi5GRkQCQgQMHytq1a2X+/Pni6empeUGOiYmJAJBDhw7Jtm3bpFWrVgJAoqKi5ObNm5Kbm6t5UYiISH5+vlhbWwsAGTdunGzbtk3mzZsnbm5uWr8Q5+zZs6KnpycWFhby888/S25urhw5ckSaN28uAOTGjRsiItKxY0cBUOZFGLm5ueLo6Cht27Yts0fjtGnTpG/fvlJYWCgi/7cv4KN7GQYFBUmvXr2ksLBQ63HS0tIEgFhbW5e5horatfH4nGobi3o+1C9ZEfm/fRLVfRYtWiQ2NjayceNG+fnnn+XUqVNy9erVMvOQlZUlAKRNmzaats6dO4uRkZEkJiZq2oYPHy4AZP78+XLt2jVZuXKlmJubCwD5+eef5ffff68yj9rcLwcOHJBmzZrJTz/9VOm83b59WwCIlZWV5v5Vy8jIkH/84x/y97//XUSqvq/z8vIE+P/s3XlYjXn/B/D36ZxSoQWTSgsppRgNI5LlQYylrFPZhxCGkSlLY5mxNjUmU7ahYYydEw3K2NKMLZ5GDBlbRGmhQStFy/37w6/zaBRHqrv0fl3XuS7dnft73vf3LFc+57tAaNGihaKN4s1+srKyFMeK+/zlTb2sjjg6kAAAIABJREFUrKxKrIVaVFQkTJkyRRgwYIBQVFSk9Ov7TRmVURvWnCxNWlqa0Lt3b6FOnTrCjz/+KHYcIiIiIqLykEsXLly4sEqqoET0ColEAltbW0ydOhX6+vpYu3Yt/P39kZaWhrZt29bq6Y0hISEAABcXF6XPmT9/Po4ePYr09HQEBwejcePG+Pnnn2FmZoYBAwbg9u3biImJwblz52Bubg5fX19oaGgAeLFu3unTp3H58mWMHDkSZmZmOHfuHBITE9G2bVusWLEC0dHRyMzMhI6ODmxsbDBs2DDEx8fj6NGjOH78OIyMjLBmzZoSa0O+jr6+Pv7zn//g0qVLWL16NTZv3gx9fX1kZ2ejb9++0NbWxo4dO3DgwAEAwMOHD2FkZAQDAwOoqqpi9OjRSE9Px7p16/DXX3/h+PHj0NHRwU8//QQ1NTUAwOrVq/Ho0SNoaWmhRYsWyMnJwalTp/Djjz9CQ0NDqXZiY2Ph5+eHmJgYxYhBXV1d/PPPP6Ue19fXf+O1x8fHY+nSpSX6tFWrVvDw8HhtljVr1mDnzp0AXqzP2KZNG6xbtw579uwBADx//hwODg4QBAG7du3Czp07sX37dvz8889YvXo1fvzxRzRv3hympqZYtmwZTp8+rVib1MbGBo8fP8a1a9dga2sLa2trAEDbtm0RHR2N/fv3IzY2FjNmzMDZs2fRtWtXmJiYoFu3bnB0dCzzeTQ0NETz5s0xePDg175eEhIScOjQIbi6uqJZs2al9ltkZCQWLFiAGzduIDs7G7t378bevXuxefNmfPvtt5g3bx7+/PNPeHt7w9bW9rWv6y5duuD777/HuXPnkJ2dDXt7e8TFxWHt2rUQBAE5OTmws7PDxo0bsWvXLgAv1i61tLSEpqYmLC0tkZ6ejq1btyIqKgoRERFo2bIlli9fDhUVlTe+vg0NDWFqagptbe0yM3766afQ1NR84+upPJ8X74O6deti1KhRUFNTg7e3N+Li4vDJJ58o3v9ERERERDXAVYkgcN4UUXXx/Plz/PLLL/jmm2+Qk5ODqVOnwsfHBzo6OmJHq3Kurq4AALlcLnKSms3Kygo3btyoVVNkBUHApk2b8PDhQ8yePRvAi2neKSkp+P333zFz5kykpaWJnJIqEj8vXhSuhw8fjgYNGmDv3r2K4joRERERUTUXwjUniaoRNTU1eHh44NatW5g/fz6Cg4PRvHlzLFy4EFlZWWLHo7cgkUjeeLt+/brYMSuF2Nfu7++P8ePHY/z48YpjUqkUxsbG6Ny5M5o0aVJpj00klh49euD8+fPQ0dFBx44da3WhloiIiIhqFhYniaqhunXrYs6cOUhISMDs2bMRGBiI5s2bw9/fH7m5uWLHIyUIgvDGW/GGIZWpeHfonJycSn+sYmJf++nTpwEA69atw8OHDxXHY2Ji4OPjg23btlXaYxOJydjYGH/88QfGjRsHNzc3TJo0Cfn5+WLHIiIiIiJ6LRYniaqx+vXrY86cObh9+zbGjx+PxYsXo0WLFggKClLsHExUmpycHMydO1exC/z06dNx9uxZkVNVjc2bN2PatGnYuHEjjIyM0KlTJ7i4uODChQvYtm0bbGxsxI5IVGnq1KmDoKAgbNu2Ddu3b0ePHj2QkpIidiwiIiIiojJxzUmiGuSff/5BQEAAgoKC0LhxY8ydOxfu7u6QyWRiR6twXEOOiJTFz4vSXblyBUOHDkVmZiZ27dqF//znP2JHIiIiIiL6N645SVSTfPDBB/Dz88PNmzfxySefYOrUqWjdujW2bNmCwsJCseMREVE10qpVK5w/f16xo7y/v7/YkYiIiIiIXsHiJFENZGxsjPXr1+PatWto164dxo0bh7Zt2yI0NBRFRUVixyMiomqifv362L17N9auXYv58+dj+PDhePr0qdixiIiIiIgUWJwkqsHMzc2xbds2XL58GZaWlnBxcUGbNm2we/duFimJiEjBw8MDx44dw/Hjx+Hg4IA7d+6IHYmIiIiICACLk0TvBRsbG8jlcsTGxuKjjz7CqFGjYGFhgeDgYBQUFIgdj4iIqoH//Oc/OHv2LAoLC9G+fXscP35c7EhERERERCxOEr1PrK2tsWXLFty4cQOOjo6YOnUqd/cmIiKF5s2bIyoqCj169ECfPn24DiURERERiY7FSaL3kJmZGdavX4+4uDg4Oztjzpw5sLS0RFBQEPLy8sSOR0REIqpXrx52796NpUuXYt68eRg5ciTXoSQiIiIi0bA4SfQea9q0KYKCgnDz5k0MHDgQPj4+ipGUubm5YscjIiKRSCQSzJkzB+Hh4Th06BAcHBxw9+5dsWMRERERUS3E4iRRLWBiYoKgoCDcvXsXI0aMwFdffYWmTZvC39+fo2WIiGqxPn36IDo6Gvn5+ejQoQNOnjwpdiQiIiIiqmVYnCSqRRo3bgw/Pz8kJCRgypQp8PX1hampKRYuXIjMzEyx4xERkQjMzc1x7tw5dO7cGb169cLGjRvFjkREREREtQiLk0S10AcffICFCxfi1q1bGD9+PFasWAFzc3MsW7YMWVlZYscjIqIqVq9ePezZsweLFy/GxIkTMWnSJBQUFIgdi4iIiIhqARYniWqxDz74AH5+frhz5w6mTp2KgIAAGBkZwdPTE0lJSWLHIyKiKlS8DuXu3buxbds2ODk5ISMjQ+xYRERERPSeY3GSiNCwYUMsXLgQ8fHxmDt3LkJCQmBubo7x48fj2rVr79R2SkoK7O3t4erqim+++Qa7du3CxYsXuSEPEVE15eLigjNnzuDq1auws7PDjRs3xI5ERERERO8xiSAIgtghiKh6ef78OXbt2gV/f39cu3YN/fv3h6enJxwdHd+6rTt37sDMzAwSiQQymQwFBQUQBAESiQT6+vqwsbHBhx9+CEtLS1hZWcHa2hqNGjWCq6srAEAul1f05RHRe4afF5UjJSUFgwYNwu3btxESEoIePXqIHYmIiIiI3j8hLE4SUZkEQUB4eDj8/f1x5swZtGvXDtOnT8fIkSMhlUqVbqNevXqv3RW8uK3CwkIAgJaWFqRSKQoKCtCnT593vxAiqjBxcXFo1KgRdHV1xY6icPbsWdjb27M4WQny8vIwceJE7Nq1Cz/88AOmTZsmdiQiIiIier+EcFo3EZVJIpHA2dkZp0+fxvnz52FtbQ13d3dYWloiKChIqanZEokErVu3fu19CgsLFYVJAMjKykJ6ejo0NDTA70+Iqo/8/HzcvHkTERERCA8PR0xMDFJTU0u8f8Vgb28PFxcXUTO8r9TV1bFlyxYsXboUnp6emDRpEvLz88WORURERETvEY6cJKK3cvv2baxcuRI//fQT6tevjylTpmD69Olo0KBBmeeMHTsWO3bsUOo/tFKpFHp6evDz88OYMWMqMjoRVZC///4b4eHhCAsLQ1RUFNTV1eHg4AAnJyd8+umnaNKkidgRqRKEhIRg7Nix6NKlC+RyObS0tMSOREREREQ1H6d1E1H5pKWlYe3atVi1ahWeP38Od3d3eHp6Ijc3FzExMbh69Sr+/vtvnD9/Hvfv34dUKn3t6CpVVVXIZDLMnj0bPj4+UFdXr8KrIaLy+ueff3Do0CGEh4fj0KFDyMnJgbW1NZydneHk5AQHBwdIJBKxY1IFiYmJwYABA9CgQQOEh4fD1NRU7EhEREREVLOxOElE5ZOSkoLLly/jzz//xL59+xAbG6sYGammpobWrVujTZs2+PDDDyGTycpcp0wmk6GwsBAjR47E999/j8aNG1flZRBRBcrNzcWZM2cQFhaGvXv3Ijk5Gaampvjkk0/g5OSE3r17o06dOmLHpHeUkpICZ2dnpKSk4MCBA2jfvr3YkYiIiIio5mJxkoher3iNudJGQwKAgYEBbGxsYGVlhefPn+P48eO4ffs2HBwc4OnpiSFDhiAvLw/169cvsX6kiooKioqK0K1bN6xcuRIffvihWJdIRJXk39O/NTQ00KNHDzg7O8PZ2RkGBgZiR6RyysnJwfDhwxEREYFNmzZh2LBhYkciIiIiopqJxUki+p/09HT8/fffiImJURQjr1y5gmfPnkFVVRUWFhZo164dbGxsYG1tDTs7u1dGOgqCgMOHDyMwMBDHjh2Dubk5vvjiCyxfvhz37t0D8KIw2axZMwQFBaF///5iXCoRVbHExESEh4fjwIED+OOPP1BQUIBOnTphyJAhGDp0KIyNjcWOSG+psLAQM2bMwJo1a/D1119j4cKFYkciIiIioprn1eLkqVOn0KNHDxQUFIgViogqyJdffokVK1a8clzZ0ZDW1taKYmSrVq3eejpmXFwcVq9ejY0bN+LZs2coKChAvXr14Ovri8mTJ0NVVbVCrpOIapacnBwcOXIE+/btQ1hYGLKystChQwcMHToUQ4cORbNmzcSOSG8hKCgI3t7eGDt2LH788Ud+thMRERHR23i1OCmXy+Hm5ga5XC5WKCKqACtWrICxsTHWr1//zqMh31V6ejpmzpyJPXv2ICcnB87Ozpg+fTq6d+/OjTKIarnCwkKcPXsWISEh2LVrF9LS0mBtbQ0XFxcMGzYMVlZWYkckJRw+fBiurq7o0KED9uzZA21tbbEjEREREVHNUHZxkrO9iWo2V1dXHD58GNnZ2QAAY2NjfPjhh2jdujVsbW3x4YcfwsLCAjKZrMoyFRUV4eDBg1i5ciUiIiLQokULuLu7Y+LEiWjQoEGV5SCi6unlQqVcLsf9+/cVhUpXV1dYW1uLHZFe49KlS3BycoKOjg538iYiIiIiZbE4SfS+cnV1RVJSEpYtW4Y2bdpUu+LftWvXsG7dOvz8888oKCiAi4sLvL290aZNG7GjEVE1UFRUhKioKISEhGDPnj1ISUmBmZkZnJyc4OLigs6dO4sdkUqRmJgIJycnPHz4EAcPHsRHH30kdiQiIiIiqt5CVMROQESVx8jICN27d692hUkAaNmyJYKCgpCcnIygoCBcvHgRtra2+PjjjxEcHIy8vDyxIxKRiFRUVNC5c2cEBQXh3r17OHXqFJycnBAaGoouXbrAzMwMnp6eOH36NL9QrUZMTExw+vRp2NjYoFu3bjh69KjYkYiIiIiommNxkohEpaWlBQ8PD1y+fBnHjh2DiYkJpk6dimbNmmHevHm4ffu22BGJSGQvFyoTExMRFRWFwYMHY//+/ejSpQssLCwwd+5cxMbGih2V8OJz/dChQ3Bzc0P//v0RHBwsdiQiIiIiqsZYnCSiakEikcDR0RGhoaG4c+cOJkyYgM2bN8PCwgI9e/bEjh07OJqSiCCRSGBvb4+AgADcuXMH0dHRGDp0KHbs2IEPP/wQH374Ifz8/JCQkCB21FpNJpMhODgY8+bNw+TJk7Fw4UKxIxERERFRNcXiJBFVO0ZGRliyZAkSExNx9OhRNGzYEGPHjoW+vj4mTZqECxcuiB2RiKoBiUSC9u3bw9/fH3fv3sX58+fRvXt3BAYGomnTpvj4448RFBSEBw8eiB21VpJIJFi4cCE2bNiAZcuWwd3dHfn5+WLHIiIiIqJqhsVJIqq2VFRU4OjoCLlcjsTERCxatAhnz55Fu3btYGNjA39/fzx69EjsmERUTbRr106xlu2xY8dgbW2NBQsWoEmTJujVqxe2bNmC7OxssWPWOu7u7ggPD8eePXvQv39/PgdEREREVAKLk0RUI+jr68PT0xOXLl3CiRMn8PHHH2Px4sUwMTHBqFGjcOjQIRQWFoodk4iqAalUCkdHR2zZsgUPHjzAr7/+Cl1dXUycOBF6enpwdnZGSEgInj9/LnbUWuOTTz7B8ePHcenSJfTs2ZOjWYmIiIhIgcVJIqpRJBIJunbtis2bNyMlJUWx7lz//v1hZGSEL7/8ktO+iUhBQ0MDzs7OkMvlSE5ORkBAADIyMuDm5gZDQ0N8/vnniIqKEjtmrdC+fXucOXMGjx8/hoODA+Li4sSORERERETVAIuTRFRjaWtrY/LkyThz5gzu3r2LGTNm4LfffkO7du1gbW2NhQsXIj4+XuyYRFRNNGrUCJ9//jlOnTqFO3fuwNvbGydPnoSDgwNatGiBpUuXciOdSmZubo6oqCg0bNgQnTt3RkxMjNiRiIiIiEhkLE4S0XvBxMQEc+bMwY0bNxAVFYXu3btj9erVsLCwQI8ePbBp0yZkZmaKHZOIqglTU1N89dVXuHLlCq5cuYIhQ4Zg9erVMDMzQ+fOnREcHMy1ESuJnp4eIiMj0a5dO3Tr1g2HDx8WOxIRERERiYjFSSJ679jb22PNmjV48OABjhw5AiMjI0ybNg2NGzeGs7MztmzZgqysLLFjElE1YWNjAz8/PyQnJ+PIkSMwMzPDjBkzoKenB1dXV4SFhaGgoEDsmO+VunXr4sCBA3Bzc8PAgQOxa9cusSMRERERkUhYnCSi99bLm2IkJydj3bp1KCwsxIQJE6Cvr49PP/0UISEhePr0qdhRiagaePkzIyUlBUFBQUhJScHAgQPRtGlTxaZcVDFkMhk2bNgAT09PjBgxAitWrBA7EhERERGJgMVJIqoVdHR0MHbsWPz222948OAB1q1bh2fPnmHkyJFo1KiRYkTlkydPlG6zqKgIdnZ2+Prrrzmqiug9o6OjAw8PD5w+fRpXr17FmDFjEBoaCltbW3Ts2BFr1qzB48ePxY5Z40kkEnz33Xf44YcfMHPmTPj4+EAQBLFjEREREVEVYnGSiGodXV1djBkzBmFhYUhKSkJAQACys7Mxbtw4GBoaYtSoUdi7d+8bR1T++eef+PPPP7Fs2TI4ODhwIw2i95SVlRV8fX2RkJCAU6dOoU2bNvDx8YGhoSGcnZ0REhLCLyjekaenJ3755ResWLEC7u7u7E8iIiKiWqRSi5MZGRmV2Xy18ODBA8jlcixbtkzsKJWmNjyPVHvp6elhypQp+OOPP5CUlISlS5ciKSkJbm5uaNSoEQYPHoytW7ciPT39lXMPHDgANTU1FBUV4cKFC7C2tsaOHTtEuAoiqgoqKiro3Lkz1q9fj5SUFKxduxbp6elwdXWFmZkZvvnmG9y5c0fsmDXWmDFjsHfvXsjlcnz66afIzc0VOxIRERERVQGJ8K+5M3K5HG5ubuWeUpOXl4eAgACEh4cjOjoahYWFFRK0ogiCgFWrViE5ORnR0dEoKCjAhg0b0KJFi1KPW1paltnWtWvXsHr1aqxduxaWlpa4fv16FV7J/3To0AFdu3bF8uXLK6zNynweT506hYMHD8Lf3x8AMHr0aAwdOhQDBw6ssMcoj99//x1r167Fnj17AAAeHh4YM2YMHBwcRM1VXq6urgBevKfp7T169AgHDx5ESEgIjh07hoKCAnTs2BEuLi5wcXGBoaEhWrZsWer7fuTIkVi/fj3q1q1b4nheXh5+++23ave5SLWLVCpFv379oK6uLnaU98bNmzexY8cObNq0CUlJSbC3t8eYMWMwcuTIVz4H6M1Onz6NAQMGoE2bNjhw4ADq168vdiQiIiIiqjwhFV6cBIDc3Fw0adIE6enp1W7doKCgIMybNw8ZGRnIycmBu7s7fHx8cPbs2VKP29nZvba9vLw8aGhoiFqcHDZsGCwsLLBkyRLFsXv37sHY2Pid2q3s59HU1BSJiYl48uQJNDU1K7x9Zfy7n54+fYq6devCxMSkxk/RZXGy4mRmZuLgwYP49ddfcejQIeTm5qJt27Y4f/58qfeXyWQwNTVFSEgIPvroI8Xx0NBQDB06tKpiE5Vp7969GDJkiNgx3juFhYX4/fffERwcjH379kFTUxNubm4YPXo0OnfuLHa8GiU2NhaffPIJjIyMcOjQITRs2FDsSERERERUOUIqZVq3hoYG9PT0KqPpd/bjjz+iSZMmkMlk0NHRQWhoKOzs7Mo8/ibVYeTJrl27ShQm79y5gxEjRrxzu5X9PGpoaACAaIXJ0vqpOEtxNiIA0NbWxogRIxASEoJ//vkHe/fuhVQqhUwmK/X+BQUFSEhIQIcOHeDv74+ioiLFceDFCG7eeBPr9vJrkSpW8W7fcrkc9+/fx3fffYdz586hS5cusLa2hr+/P/755x+xY9YIrVu3xpkzZ/D48WN06dIFycnJYkciIiIiokpS6zbEuXfvHiQSidLHa5qkpCQ4OTnxPz9vwH6i8tLQ0MCgQYNQv359RdGxNAUFBcjPz8fcuXPRu3dv3L9/vwpTEpHYGjRoAA8PD1y6dAlnzpxBp06dsGzZMhgbG8PV1RVHjhx57WcIAc2aNcOpU6cglUrRpUsX3L59W+xIRERERFQJKqQ4+fTpU3h5ecHDwwPz58/HV199hSdPngB4McXpjz/+wIwZM9C0aVMkJyejW7duMDExQXp6OjIzMzF79mz4+PjAy8sLvXv3hpeXl2Iq8dmzZ+Ht7Y2mTZvi/v37GDp0KBo0aIBWrVph7969igyvawcAwsPDMXnyZDx9+hT379/H5MmTMXnyZOzatavU4zk5OeXujzdd0/79++Hh4QEjIyOkp6fjs88+Q8OGDdGqVasS00QF4cX6mKNGjcKUKVNQp04dSCQSxa2wsBByuRyfffYZunbtCgD45ZdfcPXqVcW1AEBwcLDiHADIyspCQEBAiWNveh6L5ebmwt/fH+PHj8fHH38MR0dHxMbGKn4fGRkJIyMjnDhx4q36TJl+Ufb1oMz1ltZPb+vmzZv49NNPMWfOHIwePRpdunTB5cuXAQDbtm2DpqYmJBIJ/Pz8FKOUtm/fDjU1Nfzyyy+v7c83vW9IXDk5OThx4oRShYWioiKcPHkSrVq1wl9//VUF6YiouunUqRM2bNiA1NRUrFu3DqmpqejTpw/Mzc2xbNkypKSkiB2x2jIwMMDx48ehra2NLl264MqVK2JHIiIiIqKKJvzL7t27hVIOlyk/P1+ws7MTJkyYIBQVFQmCIAi3bt0SpFKpAEDIy8sTzpw5I2hoaAgABF9fX+HYsWPC+PHjhZSUFMHCwkL45ptvFO09ePBAsLCwEJo1ayY8fPhQCAsLE9TV1QUAwrRp04QTJ04I27dvF+rVqycAEE6fPi1kZWW9tp309HTFcQCCpaXlK9dR1nFlvHzum7I8fvxYuHfvnlC3bl0BgLB06VLh7t27wtatWwUAgp2dneK8lStXCioqKsLDhw8FQRAEX19fAYDg5eWluE9CQsIr2Uu7FjMzs1ee15ePvel5LDZhwgTh2rVrip979eol6OnpCZmZmYIgCMK+ffsEDQ0N4cCBA2/sN0tLS0XbRUVFb+yXgoICpV4PylxvWf30uuP/Zm5uLpiZmQmCIAjPnz8XtLW1BRsbG8Xv582bJwAQrly5ojiWkJAgDBo0SPFzWf2ZlpZW5vsmOzv7jdkEQRBcXFwEFxcXpe5Lbyc0NFSQSCQCgLe6FZ9DJCYAwu7du8WOUevduHFDmDNnjvDBBx8IKioqgqOjoyCXy4X8/Hyxo1VL6enpQqdOnQQ9PT3h4sWLYschIiIiooojf+fi5KpVqwQAwtWrV0sct7CwKNFOixYtBADCo0ePFMfmzp0rABBSUlJKnLt582YBgDBr1qwSbeXk5Cju88MPPwgABDc3N6XbEYTKL04qm6W4P4oVFRUJenp6gpqamuKYs7OzIJFIhGfPngmCIAixsbECAKFDhw4lzlOmOPlyIbC0Y8o8j+fOnSuz6BIWFqY4R9n/WJWWSZl+edPrQZnrFYR3fy0EBAQIO3bsEARBEAoLCwUzMzNBJpMpfv/w4UOhXr16woQJExTHfH19FX2lTH+W9r5RFouTlWfatGlvLERqaGgIOjo6QpMmTYSWLVsK7dq1E6ytrVmcJNGxOFm9PHv2TJDL5YKjo6MgkUgEQ0NDYc6cOcKdO3fEjlbt5OTkCL179xZ0dHQUX0YSERERUY0nf+dp3UePHgUANG3atMRxFZWSTRdPp23QoIHi2JkzZwAA9evXL3Hf4inKUVFRJdqqW7eu4j4DBgwAAMTFxSndTlVQNsu/17eUSCTQ1dXF8+fPFcd69eoFQRBw8OBBAP/bfKdHjx4lzqsIyjyPf/75J2xsbErdYMHJyUlxv7I2CVGGMv3yptdDVfHy8oKzszPWrFmDZcuW4dmzZyU2mWjYsCG++OILbN68GcnJyRAEAcePH0efPn0AKNefpb1vSHyzZs3C3r17cezYMURFReHixYu4ffs2Hjx4gKysLAiCgKdPnyI9PR1JSUm4evUqzp8/j2+++Ubs6ERUzaipqcHFxQXHjh3DjRs3MHr0aGzatAnNmzdHr169EBISgvz8fLFjVgt169ZFWFgYevTogd69eyv+diEiIiKimu2di5PFuyc+evTo7R/8/4tMd+/eLXG8cePGAF7skFsWQ0NDAICxsfE7tVPRKjLLtGnT8NNPP2H8+PGYOXMmvL29sWjRIixevLjC8hZT5nl89OgR4uPjX1mHEnixtqiYXn49VLa0tDTk5+cjOjoarVu3hpmZGRYsWIB69eq9cl8vLy+oqakhMDAQMTExsLOzUxRvq3N/0uuZmJhgyJAhcHR0hL29PWxtbWFmZgY9Pb1XvpggIlKWhYUF/Pz8cO/ePezbtw+6uroYPnw4TE1N4ePjgzt37ogdUXRqamqQy+VwdXWFs7NzifXHiYiIiKhmeufipJWVFQAoRve9jeLRhP8+9969ewAAR0fHMs8tLqI5Ojq+UzsVrSKzFBYW4sqVKzh37hy+//577N+/H19//bVSIxNfHsEH/G8E3rNnzwC82KQjMzMTwIvNaJR5Hq2srBQbuLzs6tWrWL16dZmPXRVefj0Ab77eYm+bVRAEfP7555BKpRgzZgzy8/PRt29fxWP8u/1GjRphypQpWLduHVauXAl3d3fF75TtTyIiql3U1NTg7OwMuVyOmzdvYuzYsdiyZQvMzc3Rt29f7N+/v1Z/iSWVSvHzzz9j8uTJcHNzU2wyR0REREQ10zsXJ2fNmgWpVIq5c+fi8OGE29nfAAAgAElEQVTDePr0KSIjIxU7TxZ/y5+XlwcAJXbBnj17NmxsbLBq1SqkpqYqjq9ZswadOnXCtGnTSjzWy4WkiIgItG3bFpMmTVK6ncePHwNAiSnCrzuujKdPn5a4PmWzFN//5UJWdnY2ACimb/n6+iIsLAynTp3C4cOHERUVhZs3b5boh+JzsrKyFMeaN2+O1NRUJCYmKo4VFx+XLl2KuLg4BAUFKQp3R44cgZeX1xufx4EDB6JZs2ZYsmQJ3N3dsX37dsyfPx8zZszAuHHjALzYFV1HRweHDh1Suu9eHjmoTL8UK+v1oMz1FhYWltpPxdebnZ39yk7MmZmZmDRpEtTV1aGiooLU1FQkJyfj6NGj2L59OzIyMgAA0dHRimI0AHh7e+P58+dITEyEubm54rgy/Vna+4aIiGoPMzMz+Pr6IiEhAXv27IEgCBgyZAjMzMywbNkyPHjwQOyIopBIJAgMDISXlxfc3d0RFBQkdiQiIiIiKqd3Lk7a2toiMjISVlZWcHFxQatWrRAdHQ1bW1tMmjQJsbGx+Oabb5CQkADgxTTXixcvAgA0NTVx9uxZjBgxAp999hm8vb0xe/ZsNGzYEJGRkVBVVS3xWIGBgXj48CHS0tKQmpqKEydOQFVVVal2YmNjMXfuXAAvplwvWrQIly5dKvO4MuLj4+Hj4wMASEhIQGBgIJ49e/bGLGvWrFH0x7Jly5CZmYnAwEBFYWzBggXIzc2Fvb09cnJyMGHCBPTt2xcODg6wtLSEgYEB9u7diydPnsDX1xcAkJqaihUrViArKwsuLi7Q0tLCn3/+qcjq7+8POzs7rFixAlOnTkX//v1hY2ODUaNGISMjA61atXrt8xgfHw9VVVVERkbC2dkZ+/btg7e3N9LS0rB9+3ZoaWkBAOrUqQMtLS3UqVOnzH47deoUfHx8FAU8Dw8P7N+/X+l+edPrQZnrLSgoeKWfIiMjMWXKFAAvipTW1tbo3r07unfvDktLS+jp6eGnn35Cr169ALwoHmtpaWH+/Plo3rw55s2bBx0dHfj6+kJTU1ORU19fH7169cL48eNL9IO6unqZ/SmVSrF48eJS3zdERFT7qKqqYvDgwTh8+DBu3ryJ4cOHIzAwECYmJnB1dUVERESJL/ZqA4lEgu+++w7ffvstZsyYgUWLFokdiYiIiIjKQSL86y9ZuVwONze3avUHrpWVFW7cuFGtMlU2QRCwadMmPHz4ELNnzwbwYpp3SkoKfv/9d8ycORNpaWkipxRHTXs9PHnyBG3atMHly5dLFC0rm6urK4AX72mqHqrj5yvVPhKJBLt371Z8RlDN9ezZMxw4cADBwcGIiIiApaUlxo0bBw8PD+jq6oodr0qtXbsWX3zxBWbNmgU/Pz+x4xARERGR8kLKv63ye06ZXbCvXbummD5c0fz9/fHVV1/h4cOHimNSqRTGxsbo3LkzmjRpUimPSxVvzZo1+OKLL6q0MFksLi4Oy5cvh46ODnR0dKCrqwttbW3Fzzo6Oq+MUCYiopqhTp06cHFxgYuLCy5cuID169djyZIlWLp0KUaMGIEpU6bA1tZW7JhV4vPPP4e2tjbGjh2LrKwsrF69WrFJIRERERFVbzWiOFm8JmFOTk6pOyJXBrFHNp0+fRoAsG7dOkyaNAmNGjUCAMTExMDf3x/btm0TM56oxHg9vK1z587Bw8MDT58+RWFhIa5fvy5KjtTUVKxduxYZGRmKNTH/TVNTs0Sx8t/FS21tbejq6pZ5n9dN4X+fXbhwAf7+/hg3bhx69+7N/wQTkajatm2L9evXY/ny5di1axdWrVqF4OBgtGvXDh4eHhg9ejQ0NDTEjlmpRo4ciTp16mDkyJF4+vQpNm7cCKlUKnYsIiIiInqDal2czMnJga+vL5KSkgAA06dPx8SJE2Fvby9yssq3efNmLFy4EBs3bsSSJUvQtm1bNGnSBL1798a2bdugpqYmdsQqV5NeD3Xr1kVWVhbU1NSwdetW0Qp4Xbt2LTGtOzc3F+np6aXe8vLySvz+3r17uHz5suLnhw8fvrIpUTF1dXXo6uq+9U1DQ6PGTj08deoUQkJCIJfLYWpqihkzZmDs2LHQ0dEROxoR1WJaWlrw8PCAh4cHTp8+jZUrV2LatGmYM2cOxowZgxkzZqBZs2Zix6w0n376KerVq4chQ4bg2bNn2Lp1K2Syav3nLhEREVGtVyPWnCSit1cZa06WVtz8d1GzrNujR4/w/PnzUtt92+KmhoaG4hwDAwOllmGoaAsXLoSfn59iF/ji6fFubm6YOXMm2rRp88o5/Hyl6oBrTtY+9+/fx+bNm7F27VokJSWhR48e8PDwwJAhQ97bkYUnT55E//790adPH+zYsYNLmBARERFVX1xzkoiUp6GhAQ0NDRgaGpbr/H8XMd9U2IyPj1f8+/Hjx4pC4L+9TXHz5cKmrq4u9PX1yzUlOzMzs0SRsXhUqVwux7Zt29CmTRt4eXlh+PDh1f4/xQ8ePMCJEycQFxeHefPmvfX5GRkZHDH6BpmZmdDW1n7r89i3VBH09fUxZ84czJo1C5GRkQgKCoKbmxsMDQ0xYcIETJ06FR988IHYMStU165dcejQIfTr1w9DhgzBnj17au0yJERERETVHYuTRFRl3rW4+eTJE8X6mRkZGcjMzCz15/T0dNy/fx/Xr18vcZ/SRm5KpdIS62mWtmlQaT8nJyejsLDwlfaKHyM2NhZjx46Fl5cXJkyYgGnTppXrmivbtWvXsHr1aqxduxaWlpYlipMdOnRA165dsXz58lfOy8vLQ0BAAMLDwxEdHV1qX4jp999/x9q1a7Fnzx4AgIeHB8aMGQMHB4cqy1BQUIDvv/8e4eHhOHfuHAoKCpQ6r7r3LdVcKioqcHR0hKOjI+Li4rBx40asXr0a3377LQYOHAgPDw84OjqKHbPCdO7cGYcOHULfvn0xdOhQ7N27lwVKIiIiomqI07qJ3lOVMa27psvNzVV6GnpZ63IWU1VVLXMNzn8rXu/Mzs4OUVFR1e7zNS8vDxoaGrC0tCyxedOwYcNgYWGBJUuWlHpebm4umjRpgvT09Gp3TQDw9OlT1K1bFyYmJkhISBAlQ3n7qDL7ltO66WV5eXkICwtDYGAgoqKi0LJlS0yaNAnjx4+vtpvOva2oqCj07dsXDg4OCA0Nhbq6utiRiIiIiOh/OK2biGqP4pGburq65Rq9mZeXpxihOXz4cFy8eFGp8woKCiCRSBAVFfXWj1kVyvqP+q5du157noaGBvT09JCenl4Zsd6ZpqYmAIi6Q3F5+6i69y29P9TV1eHi4gIXFxfExMQgODgYc+fOxddff41hw4Zh2rRpaN26tdgx30mnTp0QGRmJ3r17Y/Dgwfj1119ZoCQiIiKqRt5+oTUiolpKXV0d+vr6sLS0LHNzn2ISiUQxYlJfXx8TJkyAt7d3VcQkIiqXdu3aYf369UhMTMSCBQsQGRmJNm3aoGfPnti/fz+KiorEjlhu7dq1w7FjxxAdHY1BgwYhNzdX7EhERERE9P9YnCQiKofSRrSpqqpCIpFAKpXCzs4OS5cuxfnz55GSkoLg4GDY2dm99ePk5ubC398f48ePx8cffwxHR0fExsYCAIKDgyGRSBS7lWdlZSEgIKDEMQDIycnBkiVLMGrUKEyfPh3dunVDYGBgmdOFCwsLIZfL8dlnn6Fr166K40+fPoWXlxc8PDwwf/58fPXVV3jy5InSeQHg5s2b+PTTTzFnzhyMHj0aXbp0weXLlyEIAvbv3w8PDw8YGRkhPT0dn332GRo2bIhWrVrh/PnzijYiIyNhZGSEEydOvHV/lqWsXMCLtU63bduG4cOHo1OnTjh79iw++ugjmJqa4vTp07hx4wYGDRqERo0awcrKqkTWl8XFxcHZ2Rm6urpo3749fv/997fq29dlJKpIDRs2xMyZM3Hjxg0cOnQIGhoaGDJkCMzNzREQEICMjAyxI5ZL27ZtERERgfPnz6Nv376vvMeIiIiISCTCv+zevVso5TAR1TAuLi6Ci4uL2DHeW/Xr1xckEokglUoFAIKJiYkwbdo04eDBg8KTJ09KPac8n68TJkwQrl27pvi5V69egp6enpCZmSkIgiCYmZm90ubLx54/fy5069ZNGDVqlFBYWCgIgiD8/PPPAgDhwIEDinMACJaWloqfExISShzLz88X7OzshAkTJghFRUWCIAjCrVu3FNevbF5zc3PBzMxMkU1bW1uwsbERioqKhHv37gl169YVAAhLly4V7t69K2zdulUAINjZ2Sna3Ldvn6ChoVEif1n+fV1lKSuXIAhCYWGhEBcXJwAQtLS0hPDwcOHvv/8WAAimpqbCd999J2RkZAgXLlwQAAjdunUr0balpaUAQPD09BSOHj0qrFu3TtDU1BRUVFSES5cuKd23r8v4NgAIu3fvfuvzqHa7deuWMGfOHEFXV1dQV1cXRo8eLcTGxoodq1wuXrwoNGrUSOjatauQnZ0tdhwiIiKi2k7ONSeJiMqhdevW0NbWRv/+/dGnTx80b968wh/jv//9LzZs2IANGza88ruTJ0/CyckJqqqqr/zu5WOrVq3CiRMncP36daiovBgsP3r0aAAvdrIti7GxcYmf161bh+joaPzyyy+KUZnNmzeHmZkZ4uLilM47ZcoUGBgYAHixU3rDhg1x48YNSCQSGBkZoUmTJrh586Zi13ATExN4e3vjr7/+UrQ1cOBAZGVlKabNV4SycgEvdjgufn4NDAzQv39/AIChoSESEhIwa9YsAICtrS0++OCDEllftnjxYmhpaQF4sX7pjBkzEBAQgPbt27+xb9+UkaiyNW/eHH5+fpg3bx527tyJoKAgtG7dGg4ODvD09MSQIUMglUrFjqkUW1tbREREwNHREf369cPBgwdRv359sWMRERER1VosThIRlcOZM2cq/TH+/PNP2NjY4MqVK+Vu448//gAAGBkZKY7JZDKMGzfutee9PC0cAI4ePQoAaNq0aYnjxQVPZfN6eXkhJycHa9aswePHj/Hs2TMUFBSU+bgSiQS6urpIS0srcbwiC5PlyQXglWKGRCJBgwYNyiwYFhcmAWDQoEGYMWMGrl69qlgi4HV9q0xGoqpQv359eHh4YOLEiTh+/DiCgoLg5uYGMzMzTJw4ER4eHtDV1RU75hu1adMGJ0+eRM+ePdGvXz/89ttvJd7T58+fx4ABA7Bx40b07dtXxKRERERE7z+uOUlEVE09evQI8fHxpa6LVlhYqFQbDx48AIASI/DKIzk5WZGpLMrkjY6ORuvWrWFmZoYFCxagXr1675TrXaWlpSE/P7/KczVu3BjAi5GhyvQtUP36jmo3iUQCR0dHhIWFKdZD9fPzg6mpKSZNmoSrV6+KHfGNWrZsicjISMTHx6NPnz7IysoCAJw7dw7du3fH/fv3sWDBApFTEhEREb3/WJwkIqqmrKysFBvMvOzq1atYvXo1gP+N6Hv27BkAoKioCJmZmQAAQRDQpk0bAMCyZctK7LR79+5d/Pbbb2+VBQAOHjz4TnnHjBmD/Px8xUik4kxCGZvzlKUiRgwKgoDPP/8cUqm0wnIp6969ewAAJycnpfoWqLi+I6po5ubm8PPzQ0JCAr7//nucPHkSrVq1Qq9evRASEqL0lylisLKyQmRkJO7evYuePXvi8OHDcHR0RG5uLgRBQExMjGIEOhERERFVDhYniYiqqYEDB6JZs2ZYsmQJ3N3dsX37dsyfPx8zZsxQTMsuLmwtXboUcXFxCAoKUhQqjxw5glmzZkFTUxN79uyBo6Mj1qxZgwULFuDbb79Fnz59ALzYKRp4sQ5isezsbABQjCSaNWsWpFIp5s6di8OHD+Pp06eIjIxESkoKAODOnTtK5U1NTUVycjKOHj2K7du3K3b9jY6Oxr179xQZXi64FWfJz88HAISHh0NHRweHDh16bf8VZ8vOzi5RmAWAzMxMTJo0Cerq6lBRUXljrtzc3FdyFecpzvdyH75cjCkuID9+/FjRxg8//IABAwZg7NixSvWtMn1HJDYtLS14eHjg77//xtGjR6Gurg43NzdYWVnB399fqV2+U1JSMGbMGMWI4qpgaWmJyMhIpKenY/DgwcjLy1O8h2UyGZYtW1ZlWYiIiIhqIxYniYiqKXV1dURGRsLZ2Rn79u2Dt7c30tLSsH37dsX6hf7+/rCzs8OKFSswdepU9O/fHzY2Nhg1ahQyMjJgYmKCc+fOoXfv3rh48SJ8fX2RnZ2N7777DioqKoiPj4ePjw8AICEhAYGBgUhKSoKvry+AFwWxFStWwMzMDJGRkbCysoKLiwtatWqF6Oho2NraYtKkSYiPj4eqquob8/r6+kJLSwvz589H8+bNMW/ePOjo6MDX1xebNm1CQkICgBcjPTMzMxEYGKgo0i1YsAC5ubmoU6cOtLS0UKdOnTL7LjIyElOmTAHwothhbW2N7t27o3v37rC0tISenh5++ukn9OrV6425srOzFRv03L17FxEREThy5Igi67x58/Do0SOsWrVKcSwgIAAPHz4EAKxcuRJOTk4YMmQIPDw84OnpCRsbG4SGhkIikcDW1vaNfVtYWPjajJqamhX0qiN6dyoqKoop39evX0e/fv2wZMkSmJiYYNKkSbh27VqZ5/7www/YunUrOnTogFu3blVZ5vv37yM5ORn5+fklvlwoKChAREQELly4UGVZiIiIiGobifCv+WChoaEYOnSoWHmIqAINGzYMO3fuFDsG/T+5XA43NzdOwyVRSSQS7N69G66urmJHoVokMzMTv/zyCwIDA5GYmIgePXpg+vTpcHJyUowuzsnJgYGBAXJyciCTyaCjo4PIyEi0bt26UrMdOXIEAwYMQEFBwSujrAFAVVUVgwcPxu7duys1BxEREVEtFfLKdqf9+vXD3r17q/X6QESknPbt24sdgYiICNra2vD09MQXX3yBgwcPYuXKlRg4cCAsLCzw+eefY8KECfj5558VSygUFBQgIyMDnTp1wpEjR9CpU6dKyXX48GEMGDAAhYWFpRYmgRdLOOzZswfx8fEwMzOrlBxEREREtdkrxUl1dXUMGTJEjCxERERE9B5TUVGBs7MznJ2dcenSJaxcuRI+Pj5YtGgRpFJpiQJhQUEBcnNz0bNnT+zfvx+9e/eu8DwxMTEoKCiATCYrszgJAFKpFMuXL8ePP/5Y4RmIiIiIartXpnUTEdHr3b17FwcPHoSqqipkMhnq168P4MXIIBUVFWhqaqJOnTpQVVVFvXr1AAA6OjrYv38/3N3dOa2bRMVp3VTdPHz4EF9++SW2bdtW6u9VVFSgoqKCXbt2VcrSQ7GxsfD398eOHTsgk8kUm139m6qqKhISEmBgYFDhGYiIiIhqsRAWJ4mI3tLKlSvh6ekJmUwGQRDeehkMfuySmCQSCdq2bQt7e3uYmJjAxMQEpqamMDU1hYGBgWL9P6Kq5ODggP/+979lfp5KJBJIJBL89NNPcHd3r5QMV65cgZ+fH3bu3AmpVPpKkVJVVRUzZ85UbBhGRERERBWCxUkiord169YtWFhYvNU5EokE6urqyM3NZXGSRCWRSNC1a1cIgoDExEQkJyejoKAAAKCmpgZjY2OYmpqWKFoW/2xsbPzaXdKJyuPChQto166dUveVSCQICAjAl19+WWl5/v77b3z77bfYuXMnZDIZnj9/rvidpqYmUlJSoK2tXWmPT0RERFTLsDhJRFQeLVu2xPXr15W6r1QqRatWrTB+/HhMnz6dxUkSVWnTutPT0xEfH6+4paSkIDU1FfHx8YiLi0NWVpbivrq6ujAzM4OZmRkMDAxgaGio+NnMzAy6urpiXBbVYCNHjoRcLlcUyZWxZMkSzJ8/vxJTvShSLl68GCEhIVBVVcXz588hlUrh6+uL2bNnV+pjExEREdUiLE4SEZXHwoUL4evrW+baZMCLIpAgCPjiiy/w/fffY9++fXBzc2NxkkRVnjUn09PTSxQs/13EvHPnjuJ1ra6u/krB8uUipqmpKaRSaWVdHtVAurq6yMjIAPBifUmZTAaJRILCwsLXFiy9vb2xfPnySl+K4Nq1a1i8eDHkcjmKiorQqFEjJCUlcRQxERERUcUIeWW3biIiKltRUREiIiIQHR392sKkqqoq1NTUsGnTJri4uFRhQqKKp6urC11dXdjY2JT6+2fPniE5OfmVUZfx8fGIiIhAYmJiianjRkZGpY66NDAwQNOmTVG3bt2qvDzReXl54YcffhA7RrVQVFRUYhr16wQEBCAgIKCSE73q4cOHUFdXr/LHpdpHJpMhMjISXbp0ETtKuRgbGyMpKUnsGLWSkZER7t27J3aMcjl16hR69OjxVqPpqeJ8+eWXWLFihdgxyoV/T9UMZX0+sThJRKSEuLg4/PLLL9iyZQuSkpJgb28PPT09pKWlvXJfmUwGa2trhIaGwszMTIS0RFWrTp06igJjWcqaOh4REfFWU8ebN28OHR2dqrisKpOUlISOHTvCy8tL7CjVniAIyMrKQnZ2Np48eQIzMzOoqqpWaYanT59CU1OzSh+TaidXV1ekpqaKHaPckpKS8OWXX8Le3l7sKLXK2bNna3SBJjU1FQUFBZDL5WJHqXVWrFhRo79Q4N9T1d/rPp9YnCQiKkN+fj5CQ0Oxdu1anDp1CoaGhhg9ejTGjh0LS0tLzJw5E6tWrVKM8imexj1u3DisXr0aampqIl8BUfWhq6uLdu3albnxSVlTx2NiYhAeHv5WU8ebNm0KFRWVqrw8hZMnT2Lu3Ln48ssvMXjwYKVzGBsbc5Q1Eb13OnbsyM+2Kva+LB/E103VCwkJETvCO+PfU9Xb6z6fWJwkIvqX1NRUBAcHIzg4GA8ePICzszMOHjyI3r17l1grb/DgwYophTKZDOrq6ti6dSsGDRokVnSiGqsqp443a9as0ka+nTp1ClFRUYiKioKFhQUWLVoEV1dX0YqlRERERETVHYuTRET/LyYmBt9//z1CQ0OhpaWFCRMmYPLkyTA1NS31/vb29mjYsCEePXqEVq1aITQ0FM2aNavi1ES1Q3mmjhcXMiMiInDz5k1kZ2cr7vu6qePm5ubQ1tYuV86EhARIpVIUFBTg1q1bGDFiBGbPno358+fD3d0dMhn/9CIiIiIiehn/QiaiWi8iIgL+/v6IiIhA27ZtERwcDDc3tzI3PNi1axe2b98OXV1dWFtbIz8/HwMHDsSxY8egq6sLbW3tV25cn4yo8ikzdby0kZdnzpxBSkoK7t+//85Tx2/fvq0YwVlUVAQASE5OxuTJk7FkyRIsWLAA48aNq/J1EomIiIiIqisWJ4moViosLERoaCj8/f0RExODnj174ujRo+jVq9cbz71+/TrCw8OhoqICmUwGiUSCixcvoqioqMwdvKVSKerUqVPRl0FEb+FNxcucnBwkJCTg7t27SExMVNz+/vtvHDx4EKmpqYqCo7q6OkxNTWFqagoTExOYmJjA1NQU169ff6Xdl4uUU6ZMwaJFizB79mxMmjSJuz4TERERUa3H4iQR1SqCICA8PBwLFixAbGws+vXrh3PnzqFDhw5Kt9GnTx8sWrQIRUVFis1w3qSwsFBRoCCi6qlevXqwsbEpc93L/Px8/PPPP69s2pOSkoKLFy/ixo0byM3NLbN9QRAgCAJSU1Ph5eUFPz8/+Pj4oLCwsMR6tkREREREtQmLk0RUaxw6dAjz58/HX3/9BVdXV8jlcrRo0eKt22nfvj20tLSQlZWl1P1VVFTw8ccfY9SoUZg+ffpbPx4RVQ+qqqowNDSEoaFhqaMv//nnH+jp6b2xneIi5f379zFjxgzUqVMHdnZ2lRGZiIiIiKja49aRRPTeO336NDp37ox+/fqhSZMmuHjxInbu3FmuwiTwYop2r1693rixhUwmg1QqxYIFCxAVFYXGjRuX6/GIqGZISEhQ6n4SiQRqamoAXnx5oaamplinkoiIiIiotuHISSJ6byUmJmL27NmQy+Xo3r07zp49i44dO5a7vbS0NBw+fBjh4eEIDw9/7TRtmUyGpk2bQi6X46OPPirxu5CQkHJnIKLqKyEhARKJRLGpTrHi4mNRURE0NTXRoUMHdO3aFe3atYODgwMmT54sUmIiIiIiIvGxOElE753c3FysXLkSS5cuhb6+Pnbv3g0XF5dytXXx4kUcOHAAYWFhuHDhAjQ1NfHJJ59g+fLl8PT0fOX+KioqKCoqwrhx4xAYGFhil24DAwPIZDK4urqW+9qI3pVMJoOBgYHYMd5LiYmJAF70cUFBAaRSKVq0aIHu3bujQ4cO6NixY7lHbBMRERERva9YnCSi90pISAi8vb2RmZmJBQsWwNPT8612yS4oKMC5c+cQEhKCX3/9Fffu3cMHH3yAPn36YM6cOejbty/q1asHANiwYQMuX76sOFdVVRX169fH5s2b4eTk9ErbXbp0KXM3byKq+Vq3bo3Bgwejffv2sLe3x8cff4y6deuKHYuIiIiIqFpjcZKI3gspKSn4/PPPceDAAXz22Wf49ttvoa+vr9S5jx8/xvHjxxEWFoYDBw4gMzMT1tbWGDFiBJycnODg4ACJRPLKeQMHDsT169fx/PlzSCQS9O3bFxs3bkSjRo0q+vKIqAZwdHSEo6Oj2DGIiIiIiGoUFieJqEYTBAFbt26Fl5cXtLS0cPToUaWKA/Hx8QgLC0N4eDhOnDiBoqIidOzYEV999RUGDx6s1NTLPn36YMmSJdDQ0MCqVaswfvz4irgkIiIiIiIiolqDxUkiqrHu3LmDCRMm4MSJE5gxYwYWL15cYo3HlxUVFeHixYuKgmRMTAwaNGiAnj17YsOGDRg4cCC0tbXf6vE7duyIJUuWYNiwYTA3N6+ISyIiIiIiIiKqVVicJKIaaefOnZg8eTJMTU1x9uxZtG/f/pX7FBYW4uzZswgJCYFcLsf9+/fRrFkzOKggyasAACAASURBVDs7w8/PD926dYOqqmq5M6ioqGD+/PnvchlEREREREREtRqLk0RUo+Tm5sLHxwerVq3CxIkT8cMPP5QYLfns2TNERERgz549OHDgAB4/foy2bdti+vTpGDRoEFq2bClieiKiypWRkQEdHR2xYxARlUtmZuZbz2QhAvjaIarpVMQOQESkrAsXLsDW1hY7duzA/v37sX79emhqaiIvLw9hYWEYM2YMGjduDCcnJ0RHR+OLL77AjRs3EBMTg6+++oqFSSJ6L+Xl/R979x0WxdW2AfxeFpH2qgiiIl1RIyYmFqzYwViwRUQJYlREjY1gDPZojCCJGFDMG7GDWNBEERMTDYgBe0vsGEARsGABaVJ29/n+8GNeUcpSh/L8rmuvS2Zn59wze7Y9zpyTgzVr1qBnz57Q1dUVO06ZERE2bNgADw8PDBgwANbW1oiJiRE7VrVLTk7G9u3bMX78ePTs2bNc2zhx4gSGDh0KiUQCiUSCAQMGYMCAAejatStGjhyJrVu3Ijc3t5KTV8z333+PJk2aQCKRQCqVwtbWFiNGjMDw4cMxaNAgGBsbQyKR4MGDB2JHZVXo+++/R9++fZV6D6uvrxVWNGX7DhFh69at+PDDD6GtrY1OnTph+/btIKIytcd9p+6pad9D6m0fI8YYqwUCAgJITU2NBg4cSMnJyZSTk0OHDh0iBwcH0tbWJhUVFerTpw/5+vrSgwcPxI7LGGNKs7e3J3t7+wptIzs7m3R0dKg2frXz9fUlLS0tys/Pp9TUVBozZgydP3++wtutjZ8FCQkJBIDatWtX7m0kJSURADI1NRWWyeVyOnLkCJmbm1ObNm3oxo0blRG30iQnJxMAatOmzTv3yeVyGj58OMXGxlZKW7WpXwCg/fv3ix2DTp48SfPnz6czZ86QQqFQ+nFlyf/q1Stq2rSp0u9h9fW1ooz9+/fXmM+C77//ntauXUv3799X+jFlza9s3/Hw8KBPP/2U/P39ad68eaSurk4AaMOGDUq3VaCu9p3K+D5SGbKysmjGjBkUFBREGRkZSj+uvPmr6ntIRdTVPlbC6zuEz5xkjNVoMpkMc+fOxYwZM/DVV19h4cKFWLp0KVq0aIFPPvkEjx8/hre3N5KSkhAVFYX58+fDyMhI7NiMMVatNDQ0oK+vL3aMcvnvf/+LVq1aQVVVFU2aNMEvv/wCKyurCm3z3r17cHR0rKSE1cfY2LjC22jVqhUAoGHDhsIyFRUV2NnZISoqCpmZmRg5ciRevXpV4bYqS8uWLQEAUqn0nftUVFSwePFiaGtrV7id2tovxPbbb7/Bz88PvXr1gpGREZYuXYobN25Uahvq6upo1qyZ0uvX19dKbbNp0yYsWrQIZmZm6N69OzZt2oSnT59WahvK9J3ExEQkJiZi9+7dmD17Nvz8/HD48GEAgJ+fX5nb5L5TtR48eIDNmzdj0qRJ0NPTw/jx4xEaGlplZwtWxfeQiqqPfYyLk4yxGuvFixf4+OOPERAQAFtbW2zduhVDhw7FhQsXMH/+fMTGxiIyMhKff/658MOGMcZY7ZKYmAiJRFJp20tKSsKIESMq/QdwXWBgYIDVq1cjPj4ePj4+YscRlPT8//333+jduzeaN29eoTa4X1RMwQ/k5ORkrFu3Du+//z4sLCywcuVKxMbGipyu8tXU10ptRUS4ePEi5s+fjxYtWqBnz54ICAhAenp6tbSfkJDwzvNoa2sLPT09pKSkVGpb3HcqV25uLg4fPowxY8ZAV1cXkyZNQlhYGGQyWaW1UdnfQ6paXe1jXJxkjNVIBw8ehLm5OU6dOoW8vDwkJydjzpw5iI2Nxc2bN7Fy5UqYmZmJHZMxxkSRnZ0Nd3d3uLq6YtmyZVi8eDGysrIKrfPq1St4e3tj2rRp6Nq1KwYPHozr16+DiBAaGgpXV1cYGhoiNTUVkydPhq6uLjp27IhLly4J27h48SK6d++O2bNnY/ny5VBVVUVmZmaJ21fW0aNHMXPmTGRnZ+Px48eYOXMmZs6ciczMzFK3fffuXYwbNw4eHh6YNGkSrK2tce3aNQDAzp07cevWLWGbABAQECCM3QQA6enp8PHxEZbJ5XJERkbCzc0NpqamSE5ORr9+/WBsbIzU1NRS85R0nCpLREQEDA0NcerUqQptZ9y4cVBRUcHx48eFZTWxr+Tl5eH69euYO3duqTkL1Md+IYa8vDwAQGxsLDw9PWFhYYFOnTrBz88Pjx8/rvD2U1JS8Mknn6Bp06awtLTExYsXy/T4+vZaqS2ICHK5HAqFAhcvXsSsWbOgp6eHYcOGITAwENnZ2RVuo7i+06dPH7Ro0eKd9fPy8mBtbS38zX2nZsrPzwcRISsrCyEhIRg5ciT09PQwY8YMREdHl3nc0AIlfQ8p7vOkop8L3MdKUE2XljPGWKmSk5Ppu+++I3NzcwJA6urq5ObmRtevXxc7GmOMVZmyjpGUn59PVlZW5OLiIoz/FhsbS1KptNA4Pi4uLnT79m3hbxsbG9LX16e0tDRKTEwkLS0tAkDffvst3b9/n4KCgggAWVlZCY+xsLAgHR0doZ3x48fTkydPStz+y5cvy7T/KGLcuNK23aZNGzI3Nyciory8PGrcuDFZWlqWuM2Cz5ailuXk5NDp06dJQ0ODAJCnpyedOHGCpk2bRhkZGaXmKek4lVVR2YmIDh8+TBoaGnTkyJFyb6NAixYtqGnTpsLfNaGvACjy1rhx41Jz1tV+gRoy5uTChQupYcOGxT5HAEgikZBUKiWJREI9evSgzZs3lzl/u3btCACtWLGC7t27R0ePHiUA1KNHjyLXr6+vldLUpDEnTU1NS+w3AKhBgwYkkUhIU1OTnJyc6Kuvvipz/rL2HSKi6OhoUldXp8uXLwvL6nvfqSljTt6+fbvUflPQdwCQgYEBzZs3j2xsbMqVv6jnsrjPk4p+LtT3PlbSmJM1412LMVZvvXr1ikJCQmjEiBGkqqpKWlpaJJVKqWfPnpSVlSV2PMYYq3Jl/TGwceNGAkC3bt0qtNzCwkL4wnfu3Lliv8yHhYUREVHbtm0LfUFUKBSkr69PampqwjI9PT0CQL6+viSXy+n69ev08uVLpbavrLe/fCuzbR8fH9qzZw8RvR4g3tzcnFRVVYvdJtH/fryWtKzgmDx//rxMeYo7TuVR0o+R/Pz8Cm+DiMjQ0JBatmxJRDWnr7ydWSaT0d27d+mDDz5QOmdd6xfK/Divjpu6unqpxck3bxKJRPj3zp07ld7fguMul8uJ6HU/a9q0KWloaBR7fOrja6U0BT/+a8KtcePG5X5sWZS17+Tn51Pfvn2F94u371NGXew79vb2ZGZmJnq/qcita9euSu9vgaKey9I+T8r7uUBUv/tYScVJVTDGWDVTKBQ4c+YMgoKCsHfvXmRnZ2PAgAGYOnUqduzYAScnJ2zduhWqqvwWxRhjbyu4hMfU1LTQchWV/43Wc/HiRVhaWpY4acXb4ytJJBLo6OgUGn/rv//9L6ZMmQI3NzcEBQXB398fjRo1Umr75aXMtt3d3ZGZmYlNmzbhxYsXyM3NrZTxpwqOSdOmTcuUp7jjVNkq43MxLy8PT548weDBgwHU3L4ilUphYWGB2bNnK52zLvaLL774Aj179ixf8Eqyd+9e/Pbbb6WuJ5FIhPehwYMH448//oCGhkaZ2yvYhkQiQbNmzRATE1PmbdSn10pxQkJCKmU7FeHm5oaXL1+Wup6qqirkcjm0tbVhZWWF8PDwcrWnbN9ZtWoVBg0ahIkTJxaZpaJqc99p3bo1vL29K7ydikhOTsYXX3yh1LoNGjRAfn4+zM3NoaGhIUwkU1GlfZ6U93MB4D5WHP7lzxirNjExMdi7dy+CgoIQHx+PDh06YOnSpfjss89w8OBBzJ07F4sXL8a3335bqwYlZoyx6pScnAwAeP78OQwNDYtc5/nz54iPj0dWVha0tLQK3SeXy4ucFbko48aNw0cffYTPP/8cx48fh7W1NbZs2VJp2y9v9gsXLsDBwQE//vgjZs+ejeDg4HK3Vxl5ijtOn332WZXlKq+IiAjk5+dj0KBBAGp+X3F1dVU6Z13sFz169IC9vX0lpy+bksZ8lEgkUFVVhUwmQ7du3eDo6IgJEyagefPmtf67XG17rbxN7H4DAF999VWx90mlUhARpFIpbGxs8Nlnn2HUqFE4fPhwuYuTyggLC4OWlhYWLVpUZW3U5r6jo6Mjet+5c+dOicVJNTU15OXloVmzZpg4cSLs7e3Rp08fjB8/vtIylOfzpCq/G72tNvex4vCEOIyxKpWWloaAgAD06dMH7733HrZs2YIRI0bg6tWruHnzJjw8PHDkyBHMnTsXa9aswZo1a2r9l1nGGKtK7du3BwD8+uuvJa5TMHD5m27dugV/f3+l21qxYgVat26NP/74A3v27IFMJsOyZcsqbfvlze7s7Iz8/HwMHToUwOsz8gEUGhT/7TPmCj5bcnNzhccUnNFDJQymr0ye4o5TZavoWYC5ublYsmQJPvzwQ8ybNw9AzegrJR3/AtwvapYGDRoAeH2W1ZIlSxAbG4vz589j/vz5FZ5ZvTLU1ddKbSeRSCCVSqGiooK+fftix44deP78OX799VfY29tDTU2tSts/fvw4kpKS3ilMnjlzRvg3952aqeA9R1tbG+PHj8eRI0fw6NEj+Pn5oU+fPpXenjKfJ29T9nngPlYMpS8OZ4wxJclkMjpy5AiNHj2a1NTUSEtLiyZNmkQnTpwQxoIpsHPnTlJRUaFVq1aJlJYxxsRV1jEnr169SlKplJo2bUrHjh2jrKwsCg8Pp//85z8EgOLj4+nVq1fCuFFTpkyh3bt309KlS8nGxkYY887ExIQACIOeExEZGBgQAMrLyyMiIg0NDXrx4gURvR4QvlGjRmRlZaXU9pXx/PlzAkBmZmbCMmW23ahRIwJAf/zxB+3evZuaNWtGAOjcuXP04MEDat26NWlqalJCQoKw3dGjRxMAWrZsGd29e5fWr19POjo6BICOHTtGMplMOCYZGRllylPccSqrrKwsAkBt2rR5576wsDDS0tKi3377TaltmJiYFFp++fJlsra2JlNTU7p582aZ9q+q+0pGRgYBICMjo2L3qz72C6DmTIijoqIiTD5hYmJCK1asKDQxQlHKmr9ly5YEoNB7SIsWLd459kT197WijJo4IY6qqipJJBLq3bs3bd68udA4fW8rT35l+s6JEydowIABtHHjRuG2YcMGcnNzo6VLlxIR952aNiGOiooKSSQSUldXp4kTJ9LRo0eFY1GU8uQv6nsIUemfJ+X9XKjvfYwnxGGMVYvY2FhasmQJGRgYkEQioQEDBtCuXbve+UJZYO/evSSVSoUvBIwxVh+V58v0qVOnqFevXqStrU1mZmbk5eVF1tbWNGPGDPrzzz9JJpPRvXv3yM7OjnR0dKh58+Y0ffp0SklJISIif39/YSDz1atXU1paGv3www/CMg8PD8rOziYA9NFHH5GXlxc5OjrS8OHDKT4+noioxO0r49q1azRjxgwCXk+gsXLlSvr777+V2ra/vz81atSIunXrRmfPniVfX19q0qQJjRw5kp49e0aLFi2iFi1a0MGDB4XHxMTEkJWVFWlqapKNjQ3FxMRQnz59yMnJibZu3UpLliwR9n/69Ol05coV4bGl5SnpOCkrIiKCpk+fLvyQ9/b2pqtXrwr3Hz9+nFq2bEnh4eHFbiMqKoqmTp0q7Ee/fv3I1taW7OzsaOzYseTv71/kZ7KYfeX06dOFMnt4eBSaPVfZnAVZ61K/qCnFST8/P2revDl98cUXdOHCBaUfp2x+uVxO3333nXCc58+fTxkZGeTt7S0sc3d3p5ycHCKqv68VZdWk4mS/fv3ogw8+oHXr1lFSUpJSjylLfmX7TkREhDC7clG32NhYIuK+U1OKk48fP6YmTZrQ8OHDae/evUpPklrW/CV9Dynu82TQoEE0b968cn8u1Pc+VlJxUkKkxHUUjDFWjNzcXBw5cgQBAQEIDw9HixYt4OzsjOnTp6N169bFPu6vv/6Cra0tPv/8c6xfv74aEzPGWM1SMEZSTZi8gDFWc0gkEuzfv79Sx1GrTrU9f20VEhICBwcHpYZLqIlqe/7arLZ/H6nt+euDEl7fB3jMScZYudy6dQuLFi2CoaGhMNPd/v37kZCQgLVr15ZYmIyLi8O4ceNgZ2eHdevWVVdkxhhj1UQikZR6u3PnjtgxqxwfB8YYY4yx0vFs3YwxpaWnp2Pfvn0IDAzE6dOnYWFhgdmzZ2Pq1KkwNjZWahspKSmwtbVFmzZtEBgYCBUV/j8Sxhira/iMl9f4ODDGGGOMlY6Lk4yxUl2+fBkBAQEIDg6GTCbDyJEjceLECQwaNKhMM2vL5XJMmDABABAaGgoNDY2qiswYY4wxxhhjjLFagIuTjLEiPX36FDt37sS2bdsQExODzp0747vvvoOjoyOaNGlSrm0uW7YMZ8+exenTp9GsWbNKTswYY4wxxhhjjLHahouTjLFCoqKi8NNPP+Hnn3+Guro6Pv30U+zZswedO3eu0HZ//fVXeHt7Y+vWrRXeFmOMMcYYY4wxxuoGHuyNMYb09HQEBATgww8/RN++fRETE4MNGzYgKSkJmzZtqnAxMTk5Gc7Ozpg8eTKmTp1aSamV4+7urtSEBHzjG9/Eubm7u1fre0JV2r59OzQ1NdGnTx8sWbIEYWFhePbsmdixGGOMMcYYq9H4zEnG6rErV65g8+bN2LNnD2QymTB79uDBgyu1HVdXV+jq6sLf379St6uMpKQk9OjRo04VQBirK9avX4+kpCSxY1QamUyGnJwcnD59GhcuXEB+fj4AwNjYGP3790evXr3Qq1cvWFpa8mRgjDHGGGOM/T8uTjJWz+Tk5CAsLAwBAQH4888/0bZtWyxbtgwuLi7Q1dWt9Pa2bt2K33//HZGRkdDS0qr07SvDyMgI9vb2orTNGCvegQMHxI5QqYyNjYXZmQsKkwDw4MED7NmzR/iPIHV1dXTq1An9+/dH7969kZeXBzU1NbFiM8YYY4wxJiouTjJWT9y9exfbt2/H1q1bkZGRgVGjRpVrxu2ySEpKwpdffgl3d3dYW1tXSRuMMVZTGBsbF3ufTCYT/p2Tk4MLFy7g6tWr8Pb2BgC8//77VZ6PMcYYY4yxmoiLk4zVYXl5eQgNDUVAQADCw8NhYGCAOXPm4PPPP4e+vn6Vt//ll19CX18fq1evrvK2GGNMLDk5OUhMTER8fLzSjyEiKBQKSCQSNG/eHK1atarChIwxxhhjjNVcXJxkrA56/Pgxdu3aBX9/fzx8+BADBw7E/v37MXbsWEil0mrJEB0djZCQEISFhUFdXb1a2mSMscqmUCjw+PFjPHjwAImJiUhMTMSDBw8K/f3kyRNh/QYNGhS6pLsoDRo0gEwmg42NDb755ht89913Vb0bjDHGGGOM1VhcnGSsDjl9+jQ2btyIX375BU2aNMH06dMxc+ZMGBkZVWsOuVyO2bNnw8bGBsOHD6/WthljrCxevXqFR48eIT4+Hg8fPhT+XfD3/fv3kZ2dLayvo6MDc3NztGzZEp07d8a4ceOEvw0MDDBs2DDExMQU2VZBUXLkyJH45ptv0KFDh+raTcYYY4wxxmosLk4yVsvl5ubiyJEjWL9+Pc6dO4fOnTvD398fkyZNgoaGhiiZdu7cidu3b+PgwYOitM8YY8DroS2ePXv2TsHxzb9TU1OF9dXV1WFgYCAUG7t06QJzc3PhbzMzM2hqapbYZuvWrd8pTqqpqUEul8PBwQHLli1Du3btqmR/GWOMMcYYq424OMlYLfXw4UMEBARg06ZNSE9Px6hRo7B69WoMHjxY1Fz5+flYs2YNpk6dCgsLC1GzMMbqttTU1CLPdiz4OyEhAXK5HMDrAqGurq5QfBw8eLBwtmNBAVJHR6fCmUxNTYVLuxs0aAAAmDZtGjw8PGBiYlLh7TPGGGOMMVbXcHGSsVomOjoaGzZswKFDh6Cnp4dp06Zhzpw5MDQ0FDsaAGDbtm1ITk7GokWLxI7CGKvFcnJy8PDhw2Ivt37w4AEyMzOF9XV0dAoVG98uPpqYmFTLmLtGRkbIz8+Huro6Zs2ahS+//BIGBgZV3i5jjDHGGGO1FRcnGasFcnJyEBISgnXr1uH69evo0qULtm3bhokTJwpn5tQE+fn58PLywvTp02Fqaip2HMZYLZCUlARvb28kJiYiISEBDx48QFJSEl68eCGso62tDWNjYxgbG8PMzAx9+/aFiYkJjIyMhFvDhg1F3Iv/sbe3BxHBxcUFzZo1EzsOY4wxxhhjNR4XJxmrweLi4uDv748dO3YgNzcXjo6O2LVrFz766COxoxXp4MGDSE5OxoIFC8SOwhirJW7evImHDx/CyMgIJiYmGDZsGIyMjIRipJGRUaVcbl1dWrdujcWLF4sdgzHGGGOMsVqDi5OM1UCRkZHw9fVFWFgYDA0NsXjxYri4uEBXV1fsaCXy8/PD2LFjYWZmJnYUxlgtMWTIEISEhIgdQ1RSqRT79u2DRCIROwpjrIZRVa29P9dUVVXh4OAABwcHsaPUO7W93wDgz0SRTJgwQewI5cbfp2qH4t6fau+7FmN1TF5eHkJDQ+Hj44Pz58+jS5cu2LFjBxwdHWvFF4zz58/j/PnzWLdundhRGGOsVvHy8sLYsWPFjlHtnj17hqVLlyI9PV2YuOhNUqkUKioqICIoFAooFArhvq5du2LBggXVMo4oAFy9ehUhISGIi4vDgAEDMGvWrGppl9VvUqkUw4YNEztGuUVERODx48dix6iXWrRoIXaEchs2bBh+/vnnIj8XWNXr1q2b2BHKrb5+n6ptint/khARVXMWxtgbUlJSsGPHDmzcuBEpKSkYPXo03Nzc0KtXL7GjlYmLiwsuX76Mq1evih2lkPHjxwNAvT8zi7GaiF+f9Vt2djZatmyJ9PR0pR+joqICZ2dnbN26tcoLk0SE0NBQrFy5Ev/8849wJsbff/+NDz74oErbZowxxhirRw6oiJ2Asfrqn3/+wYwZM2BqagovLy988skniIuLQ0hISK0rTGZlZSEkJARTpkwROwpjjLFaQlNTEzNnzlR6YjeJRILZs2dj+/btVVqYVCgUCAsLQ6dOnTBmzBjcuHEDwOuz2IYMGcKFScYYY4yxSsbFScaqkUKhwJ9//gk7Ozt89NFHiIyMhJeXFx4+fAg/Pz8YGRmJHbFcfv75Z+Tm5mLixIliR2GMMVaLzJ49W+lL91asWIENGzZU2VhSCoUCBw4cQNu2bTFq1CjcvHkTAIR8MpkMy5Ytq5K2GWOMMcbqMy5OMlYNMjIyEBAQAEtLS9ja2iInJwehoaG4c+cO5s+fD01NTbEjVkhwcDCGDx+OZs2aiR2FMcZYLdKyZUt07dq12LGVJRIJVFRUEBAQgJUrV1ZJhvz8fAQGBqJNmzZwcHBAfHy8MM5lAVVVVfTp0we9e/eukgyMMcYYY/UZFycZq0IJCQlYsGABDA0NsWDBAgwcOBB37tzBiRMnYGdnVydmEktLS0NkZCTs7e3FjsJYpYmKisKiRYsgkUggkUjg7OyM0NBQsWPh5MmTsLe3F3LNmDEDp0+fFjsWY2X2+PFjrF69Gqamprh06RJkMtk766ioqAgzb06fPr3SM8jlcvz4448wMTHBlClTkJCQACJCUcOxy2QyLF++vNIzMMYYY4wxnhCHsSpx6dIl+Pj44ODBg2jZsiXmzp2L6dOno0mTJmJHq3RBQUGYNm0aUlJSauT+8YQbLDExsdxDJpiYmODBgwfIysoS7Qznt/NnZ2dDS0sLxsbGSEhIECVTZeHXZ/1z+fJlBAQEIDAwEA0bNsTkyZPh5uaGMWPG4Pr168LZilKpFA0aNEBoaChsbW2rJMv58+fRo0ePUteTSqXo2LEj/v777yrJwRhjjDFWz/GEOIxVFiISxpPs1q0bbt++jW3btiEuLg4LFy6skYW7yhAaGoqBAwfW2f1jtdu9e/fg6OhY7sdraGgAgGiFyaLyF2QpyMZYTZebm4sDBw6gV69e6Nq1Ky5dugQ/Pz9hvGUzMzN88cUXwvqqqqrQ0tLCyZMnq6wwCQDdu3fH999/X+p6CoUCK1asqLIcjDHGGGP1HRcnGaug3NxcBAYGomPHjrCxsUFqaiqOHDmCq1evwtnZWelZSGsjhUKByMhIDB06VOwojL0jKSkJI0aMwNOnT8WOUi61PT9jycnJWLlyJQwNDeHk5ARDQ0OcOHECly9fhqura6Gi/4QJE9CkSRNIJBI0a9ZM6bMaK+rLL7+Ej49PsfdLJBKYm5tj9OjRVZ6FMcYYY6y+4uIkY+X09OlTeHt7w9zcHNOnT0eXLl1w48YNREdH15nxJEtz/fp1PH/+HP369RM7SqUgIpw9exYLFiyAqakpHj9+jE8++QRNmzZFx44d8fPPPwvr3r17F+PGjYOHhwcmTZoEa2trXLt2Tbj/4sWL6N69O2bPno3ly5dDVVUVmZmZpd736tUreHt7Y9q0aejatSsGDx6M69evg4gQGhoKV1dXGBoaIjU1FZMnT4auri46duyIS5cuFdqPjRs3wsnJCbNmzULDhg2FMQoL+mVx7cjlckRGRsLNzQ2mpqZITk5Gv379YGxsjNTUVKWOY2ZmJlavXg0nJyfMmzcP/fr1g6+vrzCO28uXL/HVV19h0aJFcHd3h62tLdzd3YXtBwQEFMqanp4OHx8fYZmyx2Lnzp24desWHj9+jJkzZwr5IiIiYGhoiFOnTpW5f5TWrrJ9qLR9LCl/WZTUT3fv3g1NTU1IJBKsXbtWGPMvODgYampq2LlzJ4Cq7SusboqOjsb48eNhamqKzZs3Y9q0aYiLi0NISAgGDx5c5GMaNmwIDw8PdOjQAefPn0f79u2rLa+7uzu++uqrIu+TSCRYvnw5AvSHMAAAIABJREFUVFT4KzNjjDHGWJUhxliZxMbG0rx580hTU5MaN25M8+bNo6SkJLFjicLX15d0dHRILpeLHaVY9vb2ZG9vr9S6MpmMwsLCSF1dnQDQnDlz6NSpUxQcHEza2toEgKKjo4mIqE2bNmRubk5ERHl5edS4cWOytLQUtmVhYUE6OjqkUCiIiGj8+PH05MmTUu9zcXGh27dvC9uxsbEhfX19SktLo8TERNLS0iIA9O2339L9+/cpKCiIAJCVlZXwmA0bNpCKigo9e/aMiIg8PT0JALm7uwvrFNdOSkoKnT59mjQ0NAgAeXp60okTJ2jatGmUkZFR6jHMy8ujfv36kZOTk9Avtm/fTgDoyJEjlJ6eThYWFvT1118Lj3ny5AlZWFiQmZkZpaamEhGRubk5vf0RVbBMoVAofSwAULt27Qpt5/Dhw6ShoUFHjhwpdX/atWsn5FCm3bL0oZL2saT8JS1/W2n9dOnSpQSAbty4ISxLSEig0aNHC39XVV8hKtvrk9Vs6enptHnzZrK0tCQA1KVLF9q1axfl5eWJHa1UV65cIT09PerduzdJJBICINxatGhBubm5YkdkjDHGGKvLQrg4yZiSIiMjyc7OjlRUVMjCwoJ+/PFHysrKEjuWqMaMGUOjRo0SO0aJylP8sLCwIACUmZkpLPvhhx8IADk4OBARkY+PD+3Zs4eIiORyOZmbm5Oqqqqwvp6eHgEgX19fksvldP36dXr58mWJ9507d67Qj+I3b2FhYURE1LZt20LFK4VCQfr6+qSmpiYss7OzI4lEIvygvn79OgGg7t27ExGVqZ3nz5+X6dj5+PgQALpz546wLD8/n7Zv304vXrygJUuWEAB6+PBhocft2rWLANDChQuJqHBRsMDby5Q5FsUV8fLz85Xan6JyKNOuMn1ImX2saHGytH767Nkz0tbWJhcXF2GZp6en0A+qsq8QcXGyLoiJiSEPDw9q0qQJqaur06RJk+iff/4RO5bSLl26RLq6utS/f3/KyMggX19foUAplUrJ399f7IiMMcYYY3VdCF+jwlgJFAoFwsLC0KtXL/Tv3x8PHz7Ejh07cPv2bcyaNUu0STJqAiJCVFRUnbmk+00Fl+9paWkJy0aOHAkA+PfffwG8vgzQzs4OmzZtwpo1a5CbmytcFgsA//3vf6GtrQ03NzdYWVkhMzMTjRo1KvG+ixcvwtLSEkT0zm3EiBEA8M5wARKJBDo6OsjLyxOW2djYgIjw66+/AgDU1dUBAAMHDgSAMrXTtGnTMh27yMhIAIChoaGwTFVVFVOmTIGOjg5Onz4NAPjPf/5T6HF9+/YFAJw5c0bptpQ5FsVRVVVVup3ytKtMH6oOpfVTXV1dzJ07F7t27UJycjKICOHh4fj4448BVG1fYbWXQqEQJoBr3749Dh48iEWLFiE5ORmBgYH44IMPxI6olDNnzmDgwIGwsrLCsWPHoK2tjfnz58PPzw8SiQSNGzfG1KlTxY7JGGOMMVbncXGSsSLk5eVh+/btsLS0xOjRo9G8eXOcPXsWly5dgrOzM6RSqdgRRXfjxg08e/asThYni2JgYAAAMDIyAgBcuHAB77//PszNzbF8+XJoa2sXWn/cuHH4+++/YWtri8uXL8Pa2loYw6+4+54/f474+HhkZWW9075cLlc665w5c7BlyxZMmzYNX375JRYsWIBVq1bhm2++AYBKa6coT548AVB8Aa6gaHf//v1Cy5s3bw4AaNy4cYXar8ne7kNVKSUlBfn5+aX2U+B1AVNNTQ2+vr64fPkyrKyshOJtVfYVVvukpKQIYy0PGTIEOTk52L9/P2JiYuDh4VGrCtRRUVH4+OOP0bdvXxw6dEj4TxwAmDt3LoKDg7Fjxw5oaGiImJIxxhhjrH7g4iRjb8jMzISfnx/atGmDmTNnolu3brh+/ToOHTpULbOG1iZRUVFo3LgxOnXqJHaUavH8+XMAECZzcHZ2Rn5+vjBTuUKhAABh0pcVK1agdevW+OOPP7Bnzx7IZDIsW7asxPvat28vTD7yplu3bsHf31/prHK5HDdu3MC5c+ewbt06hIaGYsWKFULBqbLaKUpBf1izZo1wTIDXxcjffvtNOEOy4KzOAomJiQD+d3wLzsbLzc0F8Pr4vnz5EsD/jrGy3jxTsKRlVe3tPqTsPpY1KxHh888/h1QqLbWfAoCenh5mzZqFn376CRs2bCh0plhV9hVWe1y+fBkzZsyAqakpvLy8MGTIENy4cQMnTpyAvb19rfsPu1OnTmHYsGH4+OOP8csvv6Bhw4bvrDNx4kThbGfGGGOMMVbFqvEacsZqrJSUFPr666+padOmpK2tTfPmzaMHDx6IHatGc3Fxof79+4sdo1TlGdOuYNy/N8cl3LlzJ3Xu3FmY3KFRo0YEgP744w/avXs3NWvWjADQuXPn6MGDB6ShoUEvXrwgotcTkTRq1EiYqKW4+169ekVmZmYEgKZMmUK7d++mpUuXko2NjTBepYmJiTApTAEDAwMCIGRbtWoVmZub09atW+nYsWN0+vRpiomJEfanLO0oO7FJgbi4ONLU1CQANGDAAPL396dly5aRq6sryeVyysrKIktLS2rVqlWhcSfnzZtHvXr1EvZh9OjRBICWLVtGd+/epfXr15OOjg4BoGPHjpFMJlPqWLRu3Zo0NTUpISFBWCcsLIy0tLTot99+K3V/jIyM3hk7Upl2lelDyuxjUfmTk5MJABkYGLwzGVVaWhpNnz6dPv30UyIqvZ8WePToEampqVG/fv0Kba8q+woRjzlZk2VnZ9POnTupW7duBIA+/PBD2rJlS60fa/nYsWOkoaFBEyZMUHrsWcYYY4wxVqV4QhxWv8XHxwszbzdr1oy+/vrrck3qUB9ZWVnR/PnzxY5RqooUJ7///nt6+vQpPXnyhLy8vAoVX/z9/alRo0bUrVs3Onv2LPn6+lKTJk1o5MiR9OzZMwJAH330EXl5eZGjoyMNHz6c4uPjiYhKvO/evXtkZ2dHOjo61Lx5c5o+fTqlpKQIbeL/JyNZvXo1paWlCZOsACAPDw/Kzs6m48ePk76+/jsTmOjp6dHBgwdLbCczM5NWrVolPGb69Ol05cqVMh2/a9euka2tLTVp0oQMDAxo/vz5lJaWJtyfnp5OCxcuJBsbG3J3d6eFCxfSqlWrKCcnR1gnJiaGrKysSFNTk2xsbCgmJob69OlDTk5OtHfvXmHindKOxaJFi6hFixbCfhMRHT9+nFq2bEnh4eHF7sNff/1FHh4ewvYcHR3p8OHDSj8HyvSh0vYxJyfnnfzh4eE0cuRIob127dpR//79qX///tS2bVtSU1MjALRz506l+umbhg8fToGBge8ci6rsK1ycrHlu3bpFbm5upKOjQ2pqauTg4EBRUVFix6oUR48eJXV1dfr0009JJpOJHYcxxhhjjL0WIiEq4/VxjNUB165dw7p167B3714YGhrCzc0N06dPr9cT3JSFQqFAo0aN4Ofnh2nTpokdp0Tjx48HAISEhCj9mPbt2yMmJqbMlw/XBESEHTt24NmzZ/jqq68AvL7M++HDhzh58iS+/PJLpKSkiJyy7qttfSgrKwudOnXCtWvXqvV9sDyvT1b58vLyEBoaioCAAISHh8PAwABOTk6YM2dOocmtarODBw/C0dERn332GX766Sdh/FvGGGOMMSa6A+WfrpSxWig6Ohre3t749ddf8f7772Pbtm1wdHSs0My99VFsbKxQzGA1i7e3NxYvXoxnz54Jy6RSKYyMjNCnTx+0atWq3Nt+e5bqoty+fRvt27cvdxtMHJs2bcLcuXP5P2jqmbi4OGzZskX4D42BAwdi//79GDt2bK0bR7Ik+/fvh5OTE1xcXPDjjz8q9V7GGGOMMcaqD1dkWJ2nUCjw66+/wtPTE+fOnUPv3r0RGhqKESNG8A+Ucvrnn38glUrRoUMHsaNUiYKZiTMzM4uc3bgmi46OBgD89NNPmDFjBvT09AC8ntDC29sbu3fvLve2a8tZgDVBbehD586dg6urK7KzsyGXy3Hnzh2xI7FqoFAoEBERgYCAAPzyyy/Q19fHlClTMGvWLJiYmIgdr9Lt2bMHkydPhpubG77//nux4zDGGGOMsSLwNS2szsrLy0NgYCA6duyI0aNHQ09PD2fPnkV0dDTs7Oy4MFkB165dg4WFRZ07yyozMxNLlixBUlISAGDevHk4e/asyKnKZteuXZgzZw62bdsGQ0ND9OrVC/b29rhy5Qp2794NS0tLsSPWabWpD2lpaSE9PR0qKirYs2dPkTMWs7rj4cOH8Pb2hpmZGYYMGYLU1FTs3bsXDx48wNq1a+tkYXLr1q2YNGkSFixYwIVJxhhjjLEajMecZHVORkYGtm/fjnXr1iElJQUODg5YvHgx3nvvPbGj1RkFl/wdOHBA7Cil4jHtGKu5+PVZtd48S/LQoUPQ1dXFZ599BldXV5ibm4sdr0pt3rwZn3/+ORYuXIi1a9eKHYcxxhhjjBWPx5xkdUdKSgp+/PFHbNiwAfn5+Zg6dSoWLlxYZwbzr0n+/fdfjBo1SuwYjDHGivD48WPs2rULmzdvxr1799ClSxds27YNEyZMgJqamtjxqpyPjw8WLlwILy8veHh4iB2HMcYYY4yVgouTrNaLj4+Hn58ftmzZgv/85z+YN28e5s+fDx0dHbGj1UlEhPj4eLRu3VrsKIwxxt4QHR2NDRs24PDhw9DS0sL48eMxd+5cdOzYUexo1ebrr7/G6tWrsX79eri5uYkdhzHGGGOMKaHcxUl3d3dhTC3GxJKSkoK//voLWlpa6NChA0xMTHDr1i3MmDFD7GhVSiqVwsvLC6amptXednJyMrKzs9GmTZtqb5sxxlhhaWlpCAkJwYYNG3Dz5k106dIF/v7+cHJyqnPjApeEiLBgwQJs2LABAQEBcHFxETsSY4wxxhhTUrmLkz/88AN69OgBIyOjyszDWJno6emhR48eaNWqVb2a4Gbfvn0YM2aMKMXJ2NhYAODiJGOMiejy5csICAhAUFAQGjRogAkTJiA4OBidOnUSO1q1k8vlcHV1xe7du7F3717Y29uLHYkxxhhjjJVBhS7r/uKLL4TB7Blj1UfMQmxsbCy0tbXRokUL0TIwxlh9lJaWhsDAQGzevBm3bt1Ct27dsHHjRkyYMAFaWlpixxNFbm4uHB0d8ccff+DIkSMYMmSI2JEYY4wxxlgZ8ZiTjLEyiYuLQ+vWrevVmaqMMSamgrMkg4ODIZfLYWdnh4CAAPTu3VvsaKLKysrCmDFjcPHiRRw/fhy9evUSOxJjjDHGGCsHLk4yxsokLi6OL+lmjLEqVjDj9rZt2/Dvv/+ia9euWLduHRwdHdGoUSOx44kuNTUVw4YNw7179xAZGVkvL2dnjDHGGKsruDjJGCuT+Ph4DBw4UOwYjDFW5ygUCkRERCAgIACHDx+GpqYmHBwcsG/fPnTu3FnseDXGo0ePMGTIEKSnpyMqKgoWFhZiR2KMMcYYYxWgInYAxljtEh8fDzMzM7FjMMZYnZGUlARvb2+Ym5vDxsYG8fHx8Pf3x8OHD7F582YuTL7h3r17sLa2hkwmQ3R0NBcmGWOMMcbqAD5zkjGmtLS0NKSmpsLc3FzsKIwxVqvl5ubiyJEjCAwMxLFjx6Cvrw9nZ2e4uLjw0BnFuHnzJmxtbdGyZUv8/vvv0NPTEzsSY4wxxhirBFycZIwpLS4uDgC4OMkYY+V07do1bN++HUFBQUhPT8ewYcNw6NAhDB06FKqq/LWsOBcvXsTQoUPRsWNHHDlyhMfdZIwxxhirQ/hbMGNMafHx8VBRUYGxsbHYURhjrNZ48eIFgoODsXPnTly5cgVt2rTBwoULMXnyZLRs2VLseDXeyZMnMWrUKPTr1w8hISHQ0NAQOxJjjDHGGKtEXJxkjCnt3r17MDQ0RMOGDcWOwhhjNVrB5DaBgYE4ePAgAGDEiBHw9vbGoEGDIJFIRE5YO4SGhmLChAn45JNPsGPHDjRo0EDsSIwxxhhjrJJxcZIxprS4uLhad0m3VCrFvn37uBDAWA01YcIEsSNUqpiYGOzduxc7d+5EQkICunTpAl9fXzg6OkJbW1vseLVKYGAgpk2bBldXV2zcuBEqKjyPI2OMMcZYXcTFScaY0u7evYt27dqJHaNMvLy8MHbsWLFjMMaK0a1bN7EjVFh6ejoOHz6MoKAghIeHw8DAAE5OTjy5TQVs3LgR8+fPx1dffYW1a9eKHYcxxhhjjFUhLk4yxpR29+5djBgxQuwYZWJqagpTU1OxYzDG6hiFQoEzZ84gKCgIwcHBkMlkGDlyJEJDQ3lymwogInh4eGDdunX44YcfMH/+fLEjMcYYY4yxKsbfnBljSsnMzMSjR49q3ZmTjDFWme7cuYPdu3dj9+7dSEhIQPfu3eHj4wMHBwc0adJE7Hi1mkwmw8yZMxEUFISgoCB8+umnYkdijDHGGGPVgIuTjDGl3L17F0SEtm3bih2FMcaq1dOnT7Fv3z7s3r0bFy5cgKGhIT799FM4OzujQ4cOYserE7KysmBvb4+oqCiEhobi448/FjsSY4wxxhirJlycZIwpJSYmBqqqqjAzMxM7CmOMVbnc3FwcP34cQUFBCA0NhVQqxYgRI7Bs2TK+bLuSPXnyBMOHD0dSUhIiIyPRpUsXsSMxxhhjjLFqVOu/Wefl5eHChQvo06eP2FEAvP6CferUKfz7779YunSp2HFKlJaWxpegMaXdvXsX5ubmaNCggdhRGGOsyly+fBmBgYHYs2cPXrx4gZ49e2Ljxo0823YVuXfvHoYMGQK5XI6oqChYWFiIHYkxxhhjjFUzFbEDvK179+5YuHBhqeu9ePECixcvho6ODqytrashWelu376Nb775Bg4ODggKCqrw9pQ9FmWRk5ODNWvWoGfPntDV1a3UbUdFRWHRokWQSCSQSCRwdnZGaGhopbZRHidPnoS9vb2Qa8aMGTh9+rTYsWqd27dvo3379mLHYIyxSpeQkABvb29YWFiga9eu+PPPPzF79mzEx8cjOjoarq6uXJisApcuXUKPHj3QuHFjnD17lguTjDHGGGP1VI0rTpqZmUFdXb3U9Zo2bQpPT09oaWlVQyrlvPfee/Dx8SnXYxMTE99ZVtSxKGq9slBXV4e7uztiYmKgUCgqtK23WVtbY+3atTA2NgYA/PTTTxg1alSltqGsN4/TgAEDsGvXLgCAsbExNm/ejN69e4uSqza7cuUKPvroI7FjMMZYpXjy5An8/f3Rs2dPmJqaYsOGDRg9ejT++ecf3Lx5EytXroSJiYnYMeus8PBwDBo0CB988AHCw8Ohr68vdiTGGGOMMSaSGndZ9759+5ReVyKRoGnTpnj69GkVJiobZQqrb7t37x6cnZ0RFRVVaPnbx6K49cpKQ0MD+vr6SE1NrdB2Sto+AGhqalbJ9ktT1HEqyFKQjZVNeno64uLi0LlzZ7GjMMZYub18+RKHDh3C3r17ER4eDk1NTYwaNQqrVq3CoEGDIJVKxY5YLwQGBsLFxQUTJ07E1q1bebgQxhhjjLF6rsYVJ+ubpKQkjBgxAnK5vFLWq+/4OFWNv//+GwqFgs+cZIzVOjk5OThx4gQOHDiAX375BTKZDDY2Nti+fTvGjh3Ll2tXs2+++QYrV66Eh4cHPD09IZFIxI7EGGOMMcZEVuWXdRMRzp49iwULFsDU1BSPHz/GJ598gqZNm6Jjx474+eefAQByuRwhISGYPHky+vbtKzw+MzMTq1evhpOTE+bNm4d+/frB19cXRFRke+vWrUPDhg2xYMECREdHIyAgQBhrEHh9BpiPj4+wTNl8FXH37l2MGzcOHh4emDRpEqytrXHt2jUAwM6dO3Hr1i08fvwYM2fOLPZYFLVeaftWIDs7G+7u7nB1dcWyZcuwePFiZGVlFcr46tUreHt7Y9q0aejatSsGDx6M69evC/dHRETA0NAQp06dKtO+ExFCQ0Ph6uoKQ0NDpKamYvLkydDV1UXHjh1x6dIlpZ8DZfa3qONUViU9X7t374ampiYkEgnWrl0LmUwGAAgODoaamhp27txZ4vGUy+WIjIyEm5sbTE1NkZycjH79+sHY2LjKzmStDFeuXIGuri6MjIzEjsIYY6WSy+WIjo7GjBkz0Lx5c4wePRrx8fFYs2YNEhMTERYWBmdnZy5MViOZTIaZM2fim2++gb+/P7y8vLgwyRhjjDHGXqNyAkD79+8vdT2ZTEZhYWGkrq5OAGjOnDl06tQpCg4OJm1tbQJA0dHRRESUkJBAAKhdu3ZERJSXl0f9+vUjJycnksvlRES0fft2AkBHjhwhIqJ27dpRwW48f/6cnJyc6J9//imUwdzcnN7e1YJlZclXlmNTsA9ERG3atCFzc3Nhnxo3bkyWlpbFrl/UsShuvZL2jYgoPz+frKysyMXFhRQKBRERxcbGklQqLfQ4FxcXun37tvC3jY0N6evr08uXL4mI6PDhw6ShoSEc95K8+ZwoFApKTEwkLS0tAkDffvst3b9/n4KCgggAWVlZlek5KG1/iztOJS1/W2nP19KlSwkA3bhxQ1iWkJBAo0ePFv4u7nimpKTQ6dOnSUNDgwCQp6cnnThxgqZNm0YZGRmlZntzX5R5/VUWZ2dnsrW1rbb2GGOsPC5dukTz5s2jFi1aEADq0KEDrV27lh4+fCh2tHotIyODhg0bRlpaWhQWFiZ2HMYYY4wxVrOEVHlxsoCFhQUBoMzMTGHZDz/8QADIwcGBiF4Xst4sIPn4+BAAunPnjvCY/Px82r59O7148YKI/lcIi4uLo6lTp1JKSso7bb9ZLCtumTL5lPV2EczHx4f27NlDRERyuZzMzc1JVVW12PWLOhbFrVfavm3cuJEA0K1btwqtU7C/RETnzp0jAEXe3vwRkZ+fr9T+F5Wpbdu2hZYpFArS19cnNTW1dzKV9Bwo81xWtDhZ2vP17Nkz0tbWJhcXF2GZp6encKyUOZ4Fx+P58+el5ilKdRcnO3bsSIsWLaq29hhjTBkKhYLOnTtHCxcuJBMTE6EguXr1aoqNjRU7HiOihw8fUufOnalFixZ06dIlseMwxhhjjLGaJ6TaZutWUXnd1Juza48cORIA8O+//wLAO5f3REZGAgAMDQ2FZaqqqpgyZQp0dHQKrTt8+HBkZWVBT0+vyvKVl7u7O+zs7LBp0yasWbMGubm5wuXAxamsS52OHz8OADA1NS20vGB/AeDixYuwtLQEEb1zGzFihLCeqmr5hyh9e38kEgl0dHSQl5f3TqaqeA7KorTnS1dXF3PnzsWuXbuQnJwMIkJ4eDg+/vhjAModz4Lj0bRp02rbr/LKzMzEnTt3eLxJxliNoFAoEBUVBTc3N5iYmKBHjx74+eefMWHCBPz999+4efMmli1bhtatW4sdtd67efMmevTogZycHJw9exZdunQROxJjjDHGGKuBqq04WRQDAwMAKHYcuydPngBQrjC1bt067N+/H97e3tWWT1kXLlzA+++/D3Nzcyxfvrxax7hKTk4GADx//rzYdZ4/f474+Ph3xqEEIPrEMpX1HCgjJSUF+fn5Sj1f7u7uUFNTg6+vLy5fvgwrKyuheFuTj2d5nDlzBjKZDH369BE7CmOsnioYQ3L+/PkwMjJC3759ERYWhjFjxiAqKgqxsbFYu3YtOnXqJHZU9v8iIiLQp08fYbzqt/+TlDHGGGOMsQKiFicLCmaDBw8u8v6CHxlr1qyBQqEQlt+/fx+//fZboXWHDx+OJUuWYMmSJe/cV3CWWm5uLoDXZ128fPkSAIqdWEeZfMpydnZGfn4+hg4dKrT/dtulnUlZ3Hql7Vv79u0BAL/++mux22zfvr0wgcubbt26BX9//zJnrExvPwfKPpdlzUpE+PzzzyGVSpV6vvT09DBr1iz89NNP2LBhA6ZOnSrcp+zxrC3++usvWFhYCIVixhirDm8WJFu1agVra2v8+eefmD59Oi5duoS4uDj4+fmhT58+PLFKDRMUFIShQ4di6NChiIiIKPdVLYwxxhhjrH6o9uLkm0WjP//8E507d8aMGTMAABkZGQBez8IMAIsWLYKmpiYOHjyIwYMHY9OmTVi+fDm8vLyES2jfLFKtWrUK/fv3h6OjI65evSq0U1Cg+/bbb/Hvv//Cz89PeNwff/xR6Gy2kvIpIzs7GwCQk5MjLHv06BGSk5Nx/PhxBAcHIy0tDcDrMyoTExPRunVrPHr0CA8ePBAe8/axAFDkeqXtm7u7O6RSKZYsWYLff/8d2dnZiIiIwMOHDwEA9+7dw6hRo2BmZobVq1dj6tSpCA4OxrJly+Dm5oYpU6YAAI4ePYomTZrg2LFjSh+DN88cLDgebxb4CvYxPz+/0ONLeg6UeS6LOk4F+5uRkVGo0A0AL1++xIwZM6Curg4VFZVSn68CCxYsQF5eHh48eIA2bdoIy5U5ngXHIzMzs9TjKbZTp04Js8YzxlhVysnJEWbS1tXVFQqSM2fOxJ07d3Dz5k2sXLmSLw+uoYgIX3/9NSZPngx3d3cEBwejYcOGYsdijDHGGGM1XLUXJ319ffHs2TOkpKTg0aNHOHXqFBo0aICsrCx4enoCeF3MW79+PfT09HDu3DnY2tri6tWr8PT0REZGBr777jukpaVh9erVuH//PgBg7dq1ePLkCT777DO8fPkS/fr1g5eXF9LS0uDt7Q0rKyusX78es2fPxvDhw2FpaQknJyekpaUVKoYVl08Z8fHxWLRoEQAgISEBvr6+SE1NhaenJxo1aiSMgbV06VI0adIEnp6e0NTUhL29PRo1aoSLFy8CQJHHIj09/Z31AJS6bx07dkRERATat28Pe3t7dOzYERcuXMCHH36IGTNmID4+Hg0aNEBERATs7Oxw+PBhLFiwACkpKQgODkajRo0AAA0bNkSjRo1K/JERFRWFRYsWCQVeBYUyAAAgAElEQVQ8V1dXhIaGYtOmTUhISADw+izYly9fwtfXVygYLl++HK9evVLqOVDmuXz7OEVERGDWrFkAXhcpO3TogAEDBmDAgAFo164d9PX1sWXLFtjY2ABAqc9XgRYtWsDGxgbTpk0rdBzU1dWLPZ5SqRTffPONcDzc3d0LFdJrmvT0dJw/fx4DBw4UOwpjrI569eqVUJDU19fH6NGjER8fj8WLF+Pff/8VCpLt2rUTOyorQW5uLpydneHp6Ql/f394eXnxGa2MMcYYY0wpEirpuuaSHiiRYP/+/Rg/frxS67dv3x4xMTElXkYtppqerz6obc9BVlYWOnXqhGvXrhUqWlaHsr7+yuuXX36Bvb09Hj9+jGbNmlVpW4yx+iMlJQW//fYbDh06hOPHj0Mmk6Ffv3745JNPMGbMGLRo0ULsiKwMnj9/jjFjxuDGjRs4ePAg/4cWY4wxxhgriwPln365nlHmf/9v374tXHbM6r5NmzZh7ty51V6YrE6///47rKysuDDJGKuw69ev4+jRowgLC8P58+ehpqaGgQMHYtOmTRg1ahR0dXXFjsjK4ebNm7Czs4NEIsHp06fx3nvviR2JMcYYY4zVMtVWnCwYfzAzM7NaZ6tWVmn5asvZfLVZTe8jAHDu3Dm4uroiOzsbcrkcd+7cETtSlSEiHDt2DC4uLmJHYYzVQjKZDOfOncPRo0dx+PBhxMTEQE9PDwMGDMDMmTMxevRoYegQVjudOHEC48ePx3vvvYfDhw9DX19f7EiMMcYYY6wWqvIxJzMzM7FkyRIkJSUBAObNm4ezZ89WdbNKq+n56oPa9BxoaWkhPT0dKioq2LNnT50e6P/MmTNISkrC2LFjxY7CGKslnj9/jgMHDsDZ2Rl6enqwtrbGgQMHMGTIEJw4cQKPHj1CSEgInJ2duTBZy23ZsgXDhw/HkCFDEB4ezoVJxhhjjDFWbtU25iRjrPJUx+vPzc0Nv//+e50+O5QxVnHx8fEICwvD0aNHERkZCQDo3r077OzsMGbMGLRt21bcgKxSyeVyLF26FN999x1WrFiBr7/+mie+YYwxxhhjFcFjTjLG3qVQKHDw4MF3ZiJnjDG5XI6zZ88Webn2tm3b+HLtOiw9PR0TJ05EREQE9u7dCwcHB7EjMcYYY4yxOoCLk4yxd5w8eRLJyck1/szo+/fvY/HixZDL5WJHYaxeSExMxKVLlyCTydC4cWMYGBhg4MCBaNq0KQDg6NGjOHr0aKW2KZVK4eXlBVNT00rdLiubuLg4jBw5Ei9evMDJkyfRo0cPsSMxxhhjjLE6osrHnGSMVY0LFy7g8uXLePr0aaVve9u2bejevTssLS0rfduV6cKFC9i3b5/YMRirNxo3boz3338fw4cPh62tLTp27AhdXd0qvax33759uHDhQpVtn5UuKioKPXv2RIMGDXDu3DkuTDLGGGOMsUrFZ04yVkutX78ePj4+AAANDQ2YmprC2NhYuJmYmAjLWrVqBVVV5V7uaWlpOHz4MPz8/KoyfqUKCQkROwJjrIrweIbiCggIwJz/a+/O46qo9z6Af44sIiqKmhYuLGZS6nVJ4GoiWmqPieg1wSXESpMsFcXccElTSAoSl7L0uUaJJWQ3SzN3JTEIl8QFxC1BXEDZQVnO4fv84cO5oiCDgsPyeb9evu5lzpyZz3znnN+F752Z35QpGD58OIKDg2Fqaqp2JCIiIiKqZdicJKqhQkJC0K9fP1y/fh2XLl3S/7t27RqOHz+O+Ph45OTk6Nc3NzeHjY2N/t8zzzwDCwsL2NjY4Nlnn0WTJk0AABs3bkS9evUwevToJ3o8CQkJ8PX1haenJ1588cUnum8iIipJq9XC29sba9aswezZs+Hn54d69XjDDRERERFVPjYniWooQ0NDWFhYwMLCosxmXnp6ur5heW8Tc+/evfplxczNzfHMM8/g8uXLsLS0xBdffFGigWllZVWlf5geOHAA69evx/r16zFo0CAsWbKEtw4SEakgNTUVbm5uiI6OxpYtWzBixAi1IxERERFRLcbmJFEtZm5ujhdffLHM5mVeXh6uXbumb1ru378fsbGxaNq0KdatW4eEhAT9ZDP169dH69atSzQs770K09ra+rFu90tISED9+vWRn5+PAwcOYPfu3XBwcICvry9eeeWVR94uEREpd/r0abi4uKCwsBAHDx7klexEREREVOXYnCSqw0xMTPQNRuDuLd1Dhw7FL7/8AgAoLCzEzZs3S711fO/evTh37hyys7P127v31vH7m5jt27dH06ZNy8ySmJiob4QWFhYCAI4dO4YBAwbAwcEB8+fPx9ChQ6uqFEREdd6OHTswduxYdO7cGT/++CNatWqldiQiIiIiqgPYnCQiAEBkZCQiIiKwf/9+/TIjI6Nybx1PTk5GYmIiEhIS9P+ZkJCAQ4cOITExEampqfp1zc3N9RP2WFlZwdLSUv/z2bNnodVqS2y7+Odjx47BxcUFdnZ2WLhwIZydnTlJBhFRJRERLF26FEuWLMGECROwZs0aGBsbqx2LiIiIiOoINieJCACwcOFCvPTSS+jfv3+F3teqVSu0atUKdnZ2pb5+763j9z77Mi4uDr/++isSExOh1WrRuHHjMvdR3KQ8fvw4XFxc0KlTJ3z44YcQkQplJSKikjIzM+Hh4YGdO3di9erVeO+999SORERERER1DJuTRISIiAjs27evxFWTleX+W8fvp9VqkZSUhOeee67cbRXf9h0XFwc3Nze0bdu2UrMSEdUl8fHxGDFiBG7evIldu3ahX79+akciIiIiojqo6qbeJaIaY/78+Xj55ZcrfNVkZTA0NISJiYn+OZPlMTAwgIGBAQDg2rVrVRmNiKjW2rZtGxwcHNC0aVPExMSwMUlEREREquGVk0R13M8//4xDhw4hIiJCtQwJCQllvmZsbAytVouioiI0b94cDg4OsLOzQ58+fXDjxg2MGzfuCSYlIqrZdDodli5diqVLl2LixIlYvXo1ny9JRERERKp6rObkihUrsGXLlsrKQkRPWEFBAWbNmoUxY8agd+/equVITEwEcPeqSI1GA61WCyMjI3Tv3h19+vRB79698c9//hOtW7cu8b6wsDA14hIR1UhpaWkYM2YMwsPD8dVXX2HixIlqRyIiIiIievTm5IwZM5CUlFSZWYhIodGjR8Pe3v6xtxMQEICrV69i7969lZDq0TVt2hTt27eHnZ0devXqBQcHB/To0QNGRkaq5iIiqi1iYmIwYsQIFBQUIDw8HA4ODmpHIiIiIiIC8BjNyc8++6wycxDRE5aUlISPP/4Y8+bNQ7t27VTNMnDgQFy4cEHVDEREtdXGjRvh6emJf/7znwgNDcVTTz2ldiQiIiIiIj1OiENUR3l6esLCwgIffPCB2lGIiKgK5OXl4d1338X48eMxefJk7N69m41JIiIiIqp2OCEOUR30zTffYOfOnTh48CBMTEzUjkNERJUsMTERbm5uiI2NxebNm+Hm5qZ2JCIiIiKiUvHKSaI65vr16/D29sbUqVPh6OiodpxaJTk5GWFhYfD19VU7iiIFBQWqztJ+v5pUv4yMDLUjVKnMzMxHel9tr0tNsX37dnTr1g3Z2dn4888/2ZgkIiIiomqNzUmiOkREMGnSJDRt2rRGNIBqkri4OHz00UcYNWoUNm7cqEoGBwcHzJo1q9z10tLSMG/ePJibm1ebBnVl109pLSoiLy8Pvr6+6NWrF5o3b16p2z5w4ABcXV2h0Wig0Wjg6emJw4cPV+o+yqPVarF8+XL06dOnQsdXlXWhitFqtVi8eDGGDRsGZ2dnHDlyBM8//7zasYiIiIiIHorNSaI6JCgoCDt37sQ333yDhg0bqh2nVnn++ecRGBioagZra2tFt+k3a9YMfn5+1eoz8Dj1u3LlygPLSqtFaetVhImJCby9vREfH4+ioqLH2tb9+vfvj2+++QYA0K5dO3z11Vd46aWXKnUf5TE0NISXlxdiY2Oh0+kUv68q60LKpaSk4H/+53/g7++PL7/8Et9++y1MTU3VjkVEREREVC4+c5Kojjh69Cjmzp2Ljz76CH369FE7Tq2k9vM7N2/erHhdjUaDZs2a4ebNm1WYqGIepX5///03PDw8cOjQoRLL769FWetVVIMGDdCyZUukp6c/1nZKU9xIatCgQaVvW6lHPb6qrAuVLzw8HGPGjEGjRo3w559/4h//+IfakYiIiIiIFOOVk0R1QHZ2Nt544w289NJLmD17ttpxiCpFUlISnJ2dy22wKl2PqKYREaxcuRIDBgyAvb09oqOj2ZgkIiIiohqHzUmiWq6oqAjjxo1DdnY2Nm/eDAMDA7UjqerIkSNwcHDA+++/j4ULF8LQ0BA5OTkAgJycHCxduhTu7u6YNm0anJycEBQUBBEBAJw7dw4jR47EnDlzMG7cODg6OuLkyZMP3d+dO3fg7++PCRMmoGfPnhgwYABOnTqlKKuIIDIyEjNnzoSVlRVu3LiB119/Hc2aNUPnzp3x448/AgB0Oh3CwsIwfvx49O3bV//+8o7nfgEBAahfvz5mzpyJiIgIrFu3Tv8MRADIyspCYGCgfpnSfI/jYTUPDg5GbGwsbty4gXfffbfMWpS2XnnHVuz27dvw9vbGpEmTsGDBAsybNw+5ubklMpZ3jvfv3482bdogPDz8seuhpC65ubkICQnBmDFj0Lt3b0RGRqJ79+6wtLREREQE4uPjMXz4cLRo0QK2trY4evRoqfs4f/48hg4dCnNzc9jZ2eHAgQMVqsujfF9IuZSUFLz22muYPXs2AgICsHXrVjRt2lTtWEREREREFSdEVKvNmzdPjIyM5ODBg2pHqXShoaFS0WGsQ4cOYm5uLkVFRSIi4ubmJsnJyVJQUCBOTk7i7u4uOp1OREQ2bNggAOSXX34REZFnn31WbGxsRESkoKBAmjRpIp06dSqxfQDSsWNH/c8TJ06UuLg4/c8DBw6Uli1bSmZmZrlZtVqtbNu2TUxMTASATJkyRcLDw2XTpk3SqFEjASAREREiIpKQkFBi30qOp2PHjvr6paamiru7u8TExJTIYGNj80CNi5dVJJ9S99evvJrfv35ptShrvYcdm4hIYWGh2Nvby8SJE/WflwsXLoiBgUGJ95V3jrdu3SoNGjTQ170ix1+Wh9VFp9PJ+fPnBYCYmZnJ9u3b5cyZMwJALC0t5ZNPPpGMjAw5fvy4ABAnJ6cS2y7+XHh5ecnu3bvlyy+/FFNTU6lXr57ExMQorouS74sSACQ0NLTC76vN9uzZI08//bRYW1tLVFSU2nGIiIiIiB5HGJuTRLVYWFiYaDQaWb9+vdpRqsSjNCdbtGghACQoKEh0Op2cOnVKMjMzJTAwUADI2bNn9esWFhbKhg0bJC0tTUREAgMD5bvvvhORuw0gGxsbMTQ0LLH9e5tLUVFRAqDUf9u2bVOcuUOHDgJAcnJy9MtWrFghAGTUqFEiIlJUVFRi30qOp7gJdfHiRXn77bclJSXlgX3f28Asa5mSfErd35wrr+alNfPur0VZ65V3bKtXrxYAEhsbW2Kd4uMVUX6OCwsLH+n4y1JeXUqrgYWFRYnjLSoqkqeeekqaNGlSag3ubaAHBQUJAPHw8FBUFyUZlWJz8r8KCwvlww8/lHr16smIESP032UiIiIiohosjBPiENVS0dHR8PDwwIwZMzBx4kS141Qba9euxVtvvYXp06dj48aNWLNmDczMzHDw4EEAQJs2bfTrGhoa4q233tL/7O3tjZycHHz++edIS0tDfn4+tFptmfs6cuQIOnXqhNOnTz9W5nr17j6B497ZtV1cXDBjxgycP38eAErcigxA0fEUGzJkCLp27YoWLVpUWb5HVdGaAw/W4lHt3r0bAGBlZVViefHxAsrPsaFh5f7PbXl1Ka0GjRs3LvFz8aRI8fHxpe7DzMxM/9+HDx+O6dOnIzY2Vj/pzcPqoiQjVUxiYiLGjh2LY8eO4bPPPoOXl5fakYiIiIiIKgWfOUlUC124cAFDhw5F//798cknn6gdp1oZOXIkTpw4gUGDBuHYsWNwdHREcHAwkpOTAeChzbTo6Gh06dIFNjY2WLhwIRo1avTQfaWmpuLSpUsPPIsPuPtsxMdhYWEBAGjbtm2prys5nmIBAQEIDQ2Fv7//Y2WqSD6lKlrzynT16lUAd89jWaryHJcmJSUFhYWFT7wurVq1AgC0a9dOUV0Adc9dbfPTTz+hW7duSE9PR3R0NBuTRERERFSrsDlJVMvcvHkTr732Gtq1a4ewsLA6PwHO/RYtWoT27dtj165d+O6776DVarFgwQJ07doVAODr64uioiL9+pcvX8aOHTsAAB4eHigsLMTgwYMBQL+elDHBjK2trX6ylHvFxsZizZo1j3UcxY2hAQMGlPq6kuMpNmTIEPj4+MDHx+eB14qvwMvPzwdw95gzMzMBlH3cSvIppaTmSq/Gu3+98o7N1tYWAPDrr7+WuU2l57gyrhgUEbz33nswMDCo8GfxcV25cgUA4OzsrKguQMW/L/SgvLw8eHl5YcSIEXB2dsaRI0fQpUsXtWMREREREVUq3tZNVItkZWXh1VdfhYhg+/btvFKpFAEBAZgxYwbMzc0xcuRIvPvuu2jdujXmzp2LTZs2YcuWLRgwYABef/113LhxAykpKVi7di0A4Pr168jKysLu3btx8+ZNZGRkALh7hZiFhQWaN28O4G5DAQCGDRsGa2trLF26FElJSXjllVcQFxeH6OhobNmypcLZtVqt/vbgvXv3okePHvD09AQAZGdnA7j7GQCg6HjubcotWbIEkZGRGDt2LA4cOIDu3bsDuNt8O3v2LJYtWwYPDw9s375d/75du3Zh4MCBivIpcfv27RL1A8qvefv27XH9+nUkJiaiXbt2pdYCQKnrlXds3t7eCA0NhY+PDywtLdG3b19ERUXh2rVrAIC///5b0Tnevn07Ro8ejR9++EHfqCtN8Xazs7NRVFRU4jbpzMxMzJo1CyYmJqhXr165dSm+Rf/eRmBhYaF++8W3eBfXWqfT6f+PjOKmbVpaGpo1awYRwYoVK+Di4oI333wT3bt3L7cu1tbW5WZ83Ktqa7u4uDiMHj0aCQkJ2Lx5M0aNGqV2JCIiIiKiKsErJ4lqiTt37mDYsGFITk7Gnj179LdhUkl37tzBK6+8guXLl+PNN9+Eo6MjNm/eDBsbG0RFRWHQoEH466+/4Ofnh+zsbHzyySf6JpGfnx/MzMywYMECtG/fHvPnz0fTpk3h5+eHGzduYO7cuQCAhIQEBAUF4c6dO9i/fz+GDh2KrVu3YubMmUhJScGmTZtKPM9PqaCgINy6dQspKSm4fv06wsPDYWRkhNzcXPj5+QG428z77LPP0KJFizKPJyMjA0uXLsXly5cBAMuXL0dycjLefPNNZGZmwsnJCR9//DEyMjLg7+8Pe3t7fPbZZ3j//fcxZMgQdOrUCe7u7sjIyChxRWBZ+ZS4dOnSA/VLT09/aM1NTU3h6uoKMzMzHDlyBABKrUVWVtYD6wEo99g6d+6M/fv3w9bWFq6urujcuTOio6PRrVs3eHp64tKlSzAyMir3HNevXx9mZmaoX79+mce/f/9+TJ48GcDdJuULL7yA/v37o3///ujYsSNatmyJ9evX65vBD6tLdnY25s+fD+DulbJ79+7Frl27kJCQAACYP38+UlNTsXr1av2ywMBA3Lp1CwCwatUqODs7Y8SIEZg0aRK8vLzQqVMn/Oc//4FGo0G3bt3KrYtOpyv33FHpRARr167Fiy++iMaNG+PkyZNsTBIRERFRraYR3l9FVOPl5+dj+PDhiI6OxsGDB+vMbX9hYWEYNWpUrb9N1NbWFvHx8dX2OKt7PqrZNBoNQkND4ebmpnaUKnfjxg1MmDABu3btgo+PDxYtWlTpkykREREREVUzP/A3XqIarrCwEG5uboiMjMSePXvqTGOyNlAyq3RcXNwTSFK1lB5n8bMMieqi3377DW+//TZMTEywf/9+9O3bV+1IRERERERPBG/rJqrBdDodPDw8sG/fPmzbtg12dnZqR6IKEJFy/9na2upngs7JyVE5cenKy6f0OInqouzsbHh6euK1117DwIEDcfLkSTYmiYiIiKhOYXOSqIYqLCzEG2+8gV9++QU7duyAo6Oj2pGokuXk5MDHxwdJSUkAgGnTpiEyMlLlVP9V3fMRVXdRUVHo0aMHfvrpJ/z000/49ttv9ZMVERERERHVFXzmJFENlJ+fj1GjRumvmOzXr5/akVRRV545SVSX1cZnTmq1WixbtgzLli3DgAEDsGHDBlhYWKgdi4iIiIhIDXzmJFFNk5+fDzc3N4SHh2PXrl3o3bu32pGIiEihs2fPwt3dHbGxsQgMDMS0adMUPZeViIiIiKi24m3dRDVITk4OBg8ejIiICOzdu5eNSSKiGqKoqAirVq1Cjx49YGBggBMnTsDLy4uNSSIiIiKq89icJKohbt68iZdffhlnzpzB/v370bNnT7UjERGRAhcuXED//v3xwQcfYPbs2Th8+DCee+45tWMREREREVULvK2bqAZISEjAq6++ivz8fBw6dIh/1BIR1QAigvXr12PmzJmwtrbGH3/8wf9jiYiIiIjoPrxykqiai42NhaOjIwwNDREREcHGJBFRDXDx4kX0798fU6ZMwfvvv4+jR4+yMUlEREREVAo2J4mqsT179uCll16CtbU1IiIi0Lp1a7UjERHRQxQVFWHdunXo2rUr0tPTERUVheXLl8PY2FjtaERERERE1RKbk0TV1BdffIHXXnsNr732Gnbt2oWmTZuqHYmIiB6i+NmSU6ZMwZQpU3DkyBH06NFD7VhERERERNUam5NE1YxOp8PcuXMxZcoUzJw5EyEhITAxMVE7FhERlUGr1cLf3x9dunRBZmYm/vzzT14tSURERESkECfEIapGsrOzMWbMGOzbtw8hISEYO3as2pGIiOghTpw4gXfeeQenT5/G4sWLMXPmTBga8tcrIiIiIiKl+NszUTVx8eJFuLi4ICMjA7///jvs7OzUjkRERGXIzc3FokWLsGrVKjg4OOD48eN4/vnn1Y5FRERERFTj8LZuomrg8OHD6NWrF4yNjREZGcnGJBFRNfbrr7+iU6dO2LBhAwICAvD777+zMUlERERE9IjYnCRS2VdffYX+/fujX79+OHz4MNq1a6d2JCIiKsX169fh4eEBZ2dndOnSBadPn4aXlxfq1eOvU0REREREj4q/TROpJDc3F+PGjcN7770HHx8fhIaGwtTUVO1YRER0n6KiIqxbtw62trY4fPgwdu7ciW3btqF169ZqRyMiIiIiqvH4zEkiFcTHx8PV1RXXrl3D9u3bMXjwYLUj1Whubm5qRyCiWiomJgaenp44fvw4Jk+eDD8/PzRs2FDtWEREREREtQavnCR6wkJCQtCzZ0+YmJjg6NGjbEw+Bnt7e4wePVrtGERUhUaPHg17e/snvt+cnBx4e3ujZ8+eMDY2xokTJ7By5Uo2JomIiIiIKplGRETtEER1QV5eHubMmYPVq1dj6tSp+PTTT2FsbKx2LCIiuoeIYMuWLfjggw+QlZWFxYsXY+rUqXyuJBERERFR1fiBt3UTPQEJCQlwc3PD2bNnERoaCldXV7UjERHRfY4fPw4vLy/88ccfeOONNxAQEICWLVuqHYuIiIiIqFbjZQBEVeyHH37AP/7xDxQVFeHEiRNsTBIRVTOpqanw8vKCvb09CgoK8Mcff+Dbb79lY5KIiIiI6Algc5KoimRmZmL8+PFwc3PDuHHjEBERAWtra7VjERHR/yssLMTKlSvRvn17bNmyBRs2bEBUVBQcHBzUjkZEREREVGfwtm6iKnD48GGMHz8e2dnZ2Lp1K4YNG6Z2JCIiuse+ffswffp0nDt3Du+++y6WLVuGxo0bqx2LiIiIiKjO4ZWTRJUoLy8Pc+fORd++fdGtWzecOXOGjUkiomrk4sWLcHNzw4ABA2BlZYW4uDisXLmSjUkiIiIiIpXwykmiSnLq1CmMGzcOf//9N9auXYtJkyapHYmIiP5fWloaPvnkE6xcuRKWlpbYsWMHBg8erHYsIiIiIqI6j1dOEj0mrVYLf39/9OzZE40aNcLx48fZmCQiqiZu374NX19fWFtbIzg4GIGBgTh9+jQbk0RERERE1QSvnCR6DLGxsZgwYQJiYmLg7+8PLy8vaDQatWMREdV5RUVFCAkJwbx585CZmYkpU6bAx8cHZmZmakcjIiIiIqJ78MpJokeQn5+PxYsXo0ePHtDpdDh69CimT5/OxiQRUTWwd+9edOvWDRMnToSzszMuXLiA5cuXszFJRERERFQNsTlJVEF//PEHevTogU8//RRLlixBZGQkXnjhBbVjERHVeVFRUXBycsKgQYNga2uL2NhYfPXVV3j66afVjkZERERERGVgc5JIoczMTHh5ecHR0RGWlpY4c+YM5syZAwMDA7WjERHVaadPn4aLiwt69eoFQ0NDREdHIywsDM8++6za0YiIiIiIqBxsThIpsG3bNnTp0gUhISFYu3YtduzYASsrK7VjERHVaTExMRg5ciS6du2KK1euYOfOndi3bx969uypdjQiIiIiIlKIzUmih7h69Sr+9a9/YdiwYXj55Zdx7tw5zsRNRKSyU6dOwcPDAz169MC5c+fw9ddf4+jRo3j11VfVjkZERERERBXE5iRRKQoLC7Fy5Uq88MILOHnyJHbu3Ing4GA0b95c7WhERHVWTEwM3Nzc0LVrV8TExGDz5s2IiYmBh4cHH7FBRERERFRDsTlJdJ/9+/eje/fumDdvHiZPnoyYmBgMGjRI7VhERHVWREQEhg4diu7du+P8+fMIDQ3FiRMn4OrqCo1Go3Y8IiIiIiJ6DGxOEv2/pKQkeHh44JVXXoG1tTXOnDmD5cuXo1GjRmpHI+LwFM8AABYlSURBVCKqcwoKCvD111+jS5cu6Nu3LwoKCrBr1y789ddfbEoSEREREdUihmoHIFLbnTt34O/vD39/f7Rr1w47duzA4MGD1Y5FRFQnZWVl4euvv0ZAQACSk5MxfPhwbNiwAXZ2dmpHIyIiIiKiKsDmJNVpP/74I2bOnIn09HT4+vpi6tSpMDIyUjsWEVGdc/LkSXzxxRfYtGkTDAwM4OnpiWnTpqF169ZqRyMiIiIioirE27qpTjpy5Aj69esHV1dX9O3bF/Hx8fD29mZjkojoCSooKMD3338PR0dHdO3aFQcPHsSyZctw5coV+Pv7szFJRERERFQHsDlJdcqlS5cwevRoODg4QEQQFRWFb7/9Fk8//bTa0YiI6ozr16/D398f7du3h7u7O0xMTPDLL78gLi4OXl5eaNy4sdoRiYiIiIjoCeFt3VQnpKenw9/fHytXrkS7du0QGhoKV1dXtWMREdUZOp0OBw4cwLp16/DTTz+hefPmePPNNzF58mRYWlqqHY+IiIiIiFTC5iTVagUFBQgODsaCBQtQVFSExYsXY8aMGTA2NlY7GhFRnXDmzBn8+9//RkhICNLS0jBo0CB8//33GDZsGB+lQURERERE0IiIlPZCXl4eduzYAZ1O96QzEVWKjIwMzJ8/H1lZWRgyZAiGDRuGBg0aqB3ribCzs4OVlZXaMSrNoUOHcOPGDbVjEFEFREdH4+eff8b58+fRqlUr9OvXD/369UPz5s0rbR9PP/00HB0dK217RERERET0xP1QZnPyP//5D15//fUnHYiIKsHo0aPx/fffqx2j0hgZGUGr1aodg4iqGUNDQxQWFqodg4iIiIiIHt0PZd7WXdwIKKN3SUTVlJubW6274lmr1SI0NBRubm5qRyGiaiIsLAyjRo1SOwYRERERET0mztZNREREREREREREqmBzkoiIiIiIiIiIiFTB5iQRERERERERERGpgs1JIiIiIiIiIiIiUgWbk0RERERERERERKQKNieJiIiIiIiIiIhIFWxOEhERERERERERkSrYnCQiIiIiIiIiIiJVsDlJREREREREREREqmBzkoiIiIiIiIiIiFTB5iQRERERERERERGpgs1JIiIiIiIiIiIiUgWbk0RERERERERERKQKNieJiIiIiIiIiIhIFTWiOVlQUICIiAi1Y+glJycjLCwMvr6+akepMhkZGWpHIKqWatr3n+Pnk1fbx8/MzMxHel9trwsRERERET0aVZqTDg4OmDVrVrnrpaWlYd68eTA3N4ejo+MTSFa+uLg4fPTRRxg1ahQ2btyoWg6lNayIvLw8+Pr6olevXmjevHmlbvvQoUOYO3cuNBoNNBoNPDw88PPPP1fqPh7FgQMH4Orqqs/l6emJw4cPqx2Lqqnq8P3n+Pn4atr4WR3GKa1Wi+XLl6NPnz4VOr6qrAsREREREdUOGhGR0l4ICwvDqFGjUMbLj2X06NHo0KEDli5dWu66IoJWrVrh5s2bVZLlUeTl5aFBgwbo2LEjzp49q0qG0mp45coVtG3b9rG2e+fOHbRu3Rrp6elVUm9LS0skJiYiNzcXpqamlb59Je6v0+3bt9GwYUO0a9cOCQkJqmSqTG5ubgDufodrC41Gg9DQUP2xqUnt7z/Hz8dXE8fP6jBOPerxVVVdqvL3FCIiIiIiemJ+MFRjr5s3b1a8rkajQbNmzXDz5s0qTFQxJiYmakd4oIZ///03PDw8cOjQocfaboMGDdCyZUukp6c/1nYetn0AqjUmS6tTcZbibFR1Vq9ejWXLluGNN97AmDFjYGdnp3akClP7+8/x8/HVxPGzOoxTj3p8Vf2/K0REREREVLPViGdO0sMlJSXB2dm5WjUgqiPWSX1JSUm4desW1qxZA3t7e1haWmLRokWIi4tTOxrVURwXiIiIiIiI1FUpzUkRQWRkJGbOnAkrKyvcuHEDr7/+Opo1a4bOnTvjxx9/BADodDqEhYVh/Pjx6Nu3r/79OTk5WLp0Kdzd3TFt2jQ4OTkhKCiozFu1AgICUL9+fcycORMRERFYt26d/llcAJCVlYXAwED9MqX5HkdmZiZmz56NuXPnwtvbG4MGDYK3t7f+Nraff/4ZkyZNQps2bZCeno7x48ejefPm6Ny5M44ePVqilqtXr4a7uzsmT56M+vXr649Do9GUWsPg4GDExsbixo0bePfddwGg3JoUu337Nry9vTFp0iQsWLAA8+bNQ25ubolju3PnDvz9/TFhwgT07NkTAwYMwKlTp/Sv79+/H23atEF4eHiFaqakLkrPnZLjLa1OFXXu3DmMHDkSc+bMwbhx4+Do6IiTJ08CAEJCQmBqagqNRoPly5dDq9UCADZt2gRjY2MEBwc/tJ46nQ4HDx7E9OnTYWVlhatXr8LJyQnt2rWrVVccGRkZobCwEACQmJiI5cuX44UXXkCHDh2wePFiXLx48bH3ceTIETg4OOD999/HwoULYWhoiJycHADljzcPO8dlKe878jAcPzl+Psr4+TAP+wzn5uYiJCQEY8aMQe/evREZGYnu3bvD0tISERERiI+Px/Dhw9GiRQvY2tqWqO+9zp8/j6FDh8Lc3Bx2dnY4cOBAheryKN8zIiIiIiKqpaQMoaGh8pCXS9BqtbJt2zYxMTERADJlyhQJDw+XTZs2SaNGjQSAREREiIhIQkKCAJCOHTuKiEhBQYE4OTmJu7u76HQ6ERHZsGGDAJBffvlFREQ6duyoz5Kamiru7u4SExNTIoONjc0DeYuXVSSfUvceQ1ZWlnTo0EE+/PBD/evJycnSoUMHsba2lrS0NLly5Yo0bNhQAMiyZcvk8uXLsnHjRgEg9vb2+vetWrVK6tWrJ7du3RIRET8/PwEg3t7e+nXur+H9eZTURESksLBQ7O3tZeLEiVJUVCQiIhcuXBADA4MS75s4caLExcXpfx44cKC0bNlSMjMzRURk69at0qBBA/35eph7z2VRUVG5danIuSvveMuq08OW3+/ZZ58VGxsbEbn72W3SpIl06tRJ//r8+fMFgJw+fVq/LCEhQYYPH67/uax6pqSkyOHDh6VBgwYCQPz8/GTPnj0yYcIEyc7OLjdbMVdXV3F1dVW8/pM0e/ZsqV+/vgB44J9GoxEjIyMBIF27dpWgoCC5ceOGiNw9P6GhoYr306FDBzE3N9d/rt3c3CQ5OVnReFPeOS7Oc+/npbzvyMNw/OT4qXT8rIxxSqfTyfnz5wWAmJmZyfbt2+XMmTMCQCwtLeWTTz6RjIwMOX78uAAQJyenEtsu/jx5eXnJ7t275csvvxRTU1OpV6+exMTEKK6Lku9ZeSryewoREREREVVbYZXSnCzWoUMHASA5OTn6ZStWrBAAMmrUKBG525C69w+swMBAASBnz57Vv6ewsFA2bNggaWlpIvLfP4YuXrwob7/9tqSkpDyw73v/AC9rmZJ8St17DD4+PgJArl27VmKdb775RgDIrFmzRETkueeeK5GnqKhIWrZsKcbGxvplQ4cOFY1GI/n5+SIicurUKQEgDg4OJd6n5I/r8mqyevVqASCxsbEl1imuk4hIVFRUqY0kALJt2zb9ewoLC5WUrdRMSuqi5Nwp+Qw8bnMyMDBQvvvuOxG5+0e+jY2NGBoa6l+/deuWNGrUSCZOnKhf5ufnp6+VknoW1yM1NbXcPKVxdXWVAQMGSFhYWLX7N2zYsDKbk/c3Kg0MDMTAwEAGDRpU4eZkixYtBIAEBQWJTqeTU6dOSWZmpqLxprxzLFLy86L0O1Iejp8cP8tTWeNUaTWwsLB4oL5PPfWUNGnSpNQa3Nt4DwoKEgDi4eGhqC5KMirB5iQRERERUa0QVqkT4tSrd/cu8YYNG+qXubi4YMaMGTh//jwAlLglDgAOHjwIAGjTpo1+maGhId56660Htj9kyBB07doVLVq0qLJ8j+Lw4cMAgMaNG5dYXnzb4B9//AHgwWPXaDQwNzdHSkqKftnAgQOxbds2/Prrr/jXv/6lnzzi5ZdfLvG+yrB7924AgJWVVYnlxXUC7t4e26lTJ5w+ffqh2zI0fPSPkpK6VNW5qyhvb2/k5OTg888/R1paGvLz8/W3bwNA8+bNMXXqVAQEBGDx4sWwsLDAvn37MGvWLADK6llcj2bNmj1yzkuXLlWLma1LU79+/XLXERHodDpoNBr95/T27duK97F27Vq89dZbmD59OjZu3Ig1a9bAzMxM0XhT3jm+n9LvSHk4fnL8rCzlfYZLq8H99S+eTCk+Pr7UfZiZmen/+/DhwzF9+nTExsbqH0HxsLooyUhERERERHVHlU+IY2FhAQBo27Ztqa8nJycDgKI/bgMCAhAaGgp/f/8nlk+J4j+6Ll++XGJ5q1atAABNmjRRvK0pU6Zg/fr1mDBhAj744APMnDkTS5YswUcfffTI+cpy9epVAEBqamqZ66SmpuLSpUsPPC8MuPsMPDVVxrlTKiUlBYWFhYiOjkaXLl1gY2ODhQsXolGjRg+s6+3tDWNjYwQFBeHYsWOwt7fXNx+eVD1ffPFFiEi1+zd79uxys2s0GhgYGECj0cDBwQFBQUEAKjbD+8iRI3HixAkMGjQIx44dg6OjI4KDgxWNN0rO8b2q8pxy/OT4WREVGacqU/G5ateunaK6ABX/nhERERERUe1V5c3J4j9QBgwYUOrrXbt2BQD4+vqiqKhIv/zy5cvYsWNHiXWHDBkCHx8f+Pj4PPBa8ZUg+fn5AICioiJkZmYCQJkTQyjJp0TxFT6//vprieVXrlyp8LZ1Oh1Onz6NqKgoBAQE4Oeff8aiRYsUXVlz/1Un5dXE1ta21Nz3srW11U/ocK/Y2FisWbOmzH0/CfefO6WfgYpmFRG89957MDAwgIeHBwoLCzF48GD9Pu7ffosWLTB58mR8+eWXWLVqFd5++239a0rrWRcZGRkBADp06ABfX19cu3YNkZGR8PLyqvC2Fi1ahPbt22PXrl347rvvoNVqsWDBAkXjjZJzfK+qPKccPzl+KlXRcaoyFZ8rZ2dnRXUBKv49IyIiIiKiWqysG74f5VlOxc+iuvf5WcHBwdKjRw8pKCgQkbuTHwCQZ555RkRELl68KKampgJA+vfvL2vWrJEFCxbIpEmT9BM8WFlZCQDR6XRSWFgo/fv3lyZNmsjx48f1+xk+fLgAkAULFsi5c+fks88+E3NzcwEgv/32m2i1WkX5lMjNzdVPHlD8c6dOnaR169Ylnps2bdo06d27t37blpaWAkA/SYDIf5/zVbzOkiVLxMbGRv73f/9XfvvtNzl8+LDEx8eXyHx/DUVE2rdvL6amppKQkKC4JkePHhUDAwNp1qyZ/Pbbb5Kbmyv79u2Txo0bCwC5dOmS3LlzR6ytrQWAvPXWWxISEiLz58+XgQMH6p85tm3bNmnYsKHs2LGj3Nq1bdv2gefWKamLknOn5DNQWp2uXr0qAMTCwkL/mSuWkZEh77zzjrzxxhsiImJmZiYAZNeuXRISEiJPPfWUAJCoqChJTEzUv+/69etibGz8wGQSSupZXI+KTIJzr5o0IY6xsbEAkGeffVY+/PBDOX/+fKnvQwWfOdmgQQP9MxcLCgrEzMxM7O3tFY035Z3j+7//Ss6pEhw/OX4+TGWOU7dv3xYA8txzz+m3UTzZT1ZWln5Zcc21Wq1+ma2tbYln4hYVFcnkyZPFxcVFioqK5K+//iq3LkoyKsFnThIRERER1QqVOyFO8R+vn376qdy8eVOSk5Pl448/1jdZcnJyZO7cufrGRGBgoGRmZsrJkydl0KBB0rRpU7GwsBAvLy/JyMiQ1NRU+eijj/Tr+/r6SlJSkn6ihMaNG4ufn5+kp6dLfHy82Nvbi6mpqQwcOFDi4+OlT58+4u7uLt9//73k5eWVm0+JixcvytSpU/WZVqxYIWlpaZKVlSWzZs2SgQMHire3t8yaNUuWLFkieXl5IiKyZs0a/XuWLl0qGRkZ+skkAMicOXPk9u3bsnv3bmnZsuUDkye0aNFCtmzZUmYN586dK08//bRs2bJFn1VJTcLDw6V3797SqFEjsba2lo8//lgcHR3F09NT9u7dK1qtVv7++28ZOnSomJubS6tWreSdd94pManG7t275ZlnnpF9+/aVWbfff/9d5syZo889duxY2bp1q+K6KDl3So73/jrt27dPXFxc9Pvr2LGj9OvXT/r16yfPPfecvnkWHBysP49mZmZiZ2cnkZGREhQUJE2bNhUXFxf9DMHFhgwZIt9+++0DtSirnjk5ObJkyRJ9lnfeeadEA0mp6t6cLD6+1q1by7x58+TkyZPlvq+izUkA0r17d/n4449l7NixMmTIEH1TpKzxptjDznF0dHSp3//yviNKcPzk+FmWyhynzpw5IzNmzND/nwN79uyRnTt36mfTnjp1qty6dUtWrVql35+/v7/cvHlTn9fZ2VmcnJzknXfekalTp8qaNWtKNDCV1KUiY2lZ2JwkIiIiIqoVwjQipd9DFRYWhlGjRlXoFitbW1vEx8dX29uyqns+EcHXX3+NW7du6Z/Np9PpcO3aNRw4cAAffPBBickf6pLqfu7ul5ubi65du+LkyZMVelZiZSieCCcsLOyJ7leJ8PBw/PTTT3Bzc0OvXr0UT06i0WgQGhpabSf5qQzV/TNe3fNx/Kx7HuX3FCIiIiIiqnZ+qNwpQms4JY2SuLg4/TO1Kpu/vz/mzZuHW7du6ZcZGBigbdu26NOnD1q3bl0l+6XK9/nnn2Pq1KlPvDFZ3Tk5OcHJyUntGE+U0nGlpuP4SURERERERI+iUpuTxTOS5uTkVMuZN8vLp/bVFxEREQCAL7/8Ep6enmjRogUA4NixY/D390dISIia8VRV3T9bABAVFYVJkybh9u3b0Ol0OHv2rNqRqBpQOq5U9884x08iIiIiIiKqCpUyW3dOTg58fHyQlJQEAJg2bRoiIyMrY9OVorrnK/bNN99gypQp+Pe//402bdqgd+/ecHV1xfHjxxESEoJOnTqpHfGJqynnDgAaNmyIrKws1KtXD9999x3q16+vdiSqAar7Z7y65yvG8ZOIiIiIiKhmqtRnThKR+qrzMycfVV145iQRVQx/TyEiIiIiqhV+qJQrJ4mIiIiIiIiIiIgqis1JIiIiIiIiIiIiUgWbk0RERERERERERKQKNieJiIiIiIiIiIhIFWxOEhERERERERERkSrYnCQiIiIiIiIiIiJVsDlJREREREREREREqmBzkoiIiIiIiIiIiFTB5iQRERERERERERGpgs1JIiIiIiIiIiIiUgWbk0RERERERERERKQKNieJiIiIiIiIiIhIFWxOEhERERERERERkSoMy1vhhx9+eBI5iKiSXLlyBW3btlU7RqWLioqCRqNROwYRVRNRUVFqRyAiIiIiokpQZnPymWeegaGhIdzc3J5kHiKqBL169VI7QqVq06YNVqxYgRUrVqgdhYiqkTZt2qgdgYiIiIiIHpNGRETtEERERERERERERFTn/MBnThIREREREREREZEq2JwkIiIiIiIiIiIiVbA5SURERERERERERKpgc5KIiIiIiIiIiIhU8X+wwCaM1cji2wAAAABJRU5ErkJggg==",
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# We can visualize the DNN using the Keras `plot_model` utility.\n",
    "tf.keras.utils.plot_model(model, 'dnn_model_engineered.png', show_shapes=False, rankdir='LR')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/8\n",
      "1863/1863 [==============================] - 30s 15ms/step - loss: 101.7476 - rmse: 9.4526 - mse: 101.7476 - val_loss: 86.5350 - val_rmse: 9.2814 - val_mse: 86.5350\n",
      "Epoch 2/8\n",
      "1863/1863 [==============================] - 28s 15ms/step - loss: 57.1090 - rmse: 6.7129 - mse: 57.1090 - val_loss: 31.1709 - val_rmse: 5.4735 - val_mse: 31.1709\n",
      "Epoch 3/8\n",
      "1863/1863 [==============================] - 29s 15ms/step - loss: 29.5231 - rmse: 4.4291 - mse: 29.5231 - val_loss: 29.3169 - val_rmse: 5.3298 - val_mse: 29.3169\n",
      "Epoch 4/8\n",
      "1863/1863 [==============================] - 31s 17ms/step - loss: 26.8839 - rmse: 4.2551 - mse: 26.8839 - val_loss: 30.6080 - val_rmse: 5.4437 - val_mse: 30.6080\n",
      "Epoch 5/8\n",
      "1863/1863 [==============================] - 27s 15ms/step - loss: 25.4303 - rmse: 4.1923 - mse: 25.4303 - val_loss: 27.5711 - val_rmse: 5.1631 - val_mse: 27.5711\n",
      "Epoch 6/8\n",
      "1863/1863 [==============================] - 28s 15ms/step - loss: 28.1514 - rmse: 4.3305 - mse: 28.1514 - val_loss: 25.9438 - val_rmse: 4.9743 - val_mse: 25.9438\n",
      "Epoch 7/8\n",
      "1863/1863 [==============================] - 29s 15ms/step - loss: 24.3768 - rmse: 4.1611 - mse: 24.3768 - val_loss: 27.6296 - val_rmse: 5.0931 - val_mse: 27.6296\n",
      "Epoch 8/8\n",
      "1863/1863 [==============================] - 27s 15ms/step - loss: 25.6503 - rmse: 4.1949 - mse: 25.6503 - val_loss: 29.1195 - val_rmse: 5.3123 - val_mse: 29.1195\n"
     ]
    }
   ],
   "source": [
    "# `load_dataset` method is used to load the dataset.\n",
    "trainds = load_dataset('../data/taxi-train*',\n",
    "                       TRAIN_BATCH_SIZE,\n",
    "                       'train')\n",
    "evalds = load_dataset('../data/taxi-valid*',\n",
    "                      1000,\n",
    "                      'eval').take(NUM_EVAL_EXAMPLES//1000)\n",
    "\n",
    "steps_per_epoch = NUM_TRAIN_EXAMPLES // (TRAIN_BATCH_SIZE * NUM_EVALS)\n",
    "\n",
    "# `Fit` trains the model for a fixed number of epochs\n",
    "history = model.fit(trainds,\n",
    "                    validation_data=evalds,\n",
    "                    epochs=NUM_EVALS+3,\n",
    "                    steps_per_epoch=steps_per_epoch)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As before, let's visualize the DNN model layers. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 720x360 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_curves(history, ['loss', 'mse'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's a prediction with this new model with engineered features on the example we had above. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[7.0562654]], dtype=float32)"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Use the model to do prediction with `model.predict()`.\n",
    "model.predict({\n",
    "    'pickup_longitude': tf.convert_to_tensor([-73.982683]),\n",
    "    'pickup_latitude': tf.convert_to_tensor([40.742104]),\n",
    "    'dropoff_longitude': tf.convert_to_tensor([-73.983766]),\n",
    "    'dropoff_latitude': tf.convert_to_tensor([40.755174]),\n",
    "    'passenger_count': tf.convert_to_tensor([3.0]),\n",
    "    'pickup_datetime': tf.convert_to_tensor(['2010-02-08 09:17:00 UTC'], dtype=tf.string),\n",
    "}, steps=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Below we summarize our training results comparing our baseline model with our model with engineered features."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "| Model              | Taxi Fare | Description                               |\n",
    "|--------------------|-----------|-------------------------------------------|\n",
    "| Baseline           | 12.29     | Baseline model - no feature engineering |\n",
    "| Feature Engineered | 07.28      | Feature Engineered Model                |"
   ]
  }
 ],
 "metadata": {
  "environment": {
   "kernel": "python3",
   "name": "tf2-cpu.2-11.m113",
   "type": "gcloud",
   "uri": "gcr.io/deeplearning-platform-release/tf2-cpu.2-11:m113"
  },
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}