add Peak hours predicton code

PeakTimePrediction/Untitled.ipynb

+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "9d700331",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import time\n",
+    "import keras\n",
+    "import logging\n",
+    "import pandas as pd\n",
+    "import numpy as np\n",
+    "import matplotlib.pyplot as plt\n",
+    "from sklearn.tree import DecisionTreeRegressor\n",
+    "from sklearn.model_selection import train_test_split\n",
+    "from sklearn.preprocessing import MinMaxScaler, LabelEncoder\n",
+    "from sklearn.metrics import mean_squared_error as mse, mean_absolute_error as mae\n",
+    "from tensorflow.keras.models import Sequential\n",
+    "from tensorflow.keras.layers import Dense, Dropout\n",
+    "from joblib import dump\n",
+    "import tensorflow as tf"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "f65c8027",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "class MultiColumnLabelEncoder:\n",
+    "    def __init__(self, columns = None):\n",
+    "        # array of column names to encode\n",
+    "        self.columns = columns\n",
+    "\n",
+    "    def fit(self, X, y=None):\n",
+    "        # not relevant here\n",
+    "        return self\n",
+    "\n",
+    "    def transform(self,X):\n",
+    "        output = X.copy()\n",
+    "        if self.columns is not None:\n",
+    "            for col in self.columns:\n",
+    "                output[col] = LabelEncoder().fit_transform(output[col])\n",
+    "        else:\n",
+    "            for colname,col in output.iteritems():\n",
+    "                output[colname] = LabelEncoder().fit_transform(col)\n",
+    "        return output\n",
+    "\n",
+    "    def fit_transform(self, X, y=None):\n",
+    "        return self.fit(X, y).transform(X)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "44ca2765",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def get_scores(y_true, y_pred, x_test):\n",
+    "    try:\n",
+    "        assert (y_true.shape[0] == y_pred.shape[0])\n",
+    "        print(\"RMSE {}\".format(np.sqrt(mse(y_true, y_pred))))\n",
+    "        mean_absolute_deviations = mae(y_true, y_pred)\n",
+    "        print(\"MAE {}\".format(mean_absolute_deviations))\n",
+    "        mean_absolute_deviations = mean_absolute_deviations\n",
+    "    except AssertionError as error:\n",
+    "        logging.error(\"Unequal number of observations\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "3ea3e20b",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>Day</th>\n",
+       "      <th>Type</th>\n",
+       "      <th>Time</th>\n",
+       "      <th>Condition</th>\n",
+       "      <th>Count</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>Monday</td>\n",
+       "      <td>Car</td>\n",
+       "      <td>7.45 AM</td>\n",
+       "      <td>Rainy</td>\n",
+       "      <td>20</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>TuseDay</td>\n",
+       "      <td>Jeep</td>\n",
+       "      <td>8.00 AM</td>\n",
+       "      <td>Cloudy</td>\n",
+       "      <td>30</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>Thursday</td>\n",
+       "      <td>Van</td>\n",
+       "      <td>8.05 AM</td>\n",
+       "      <td>Light Rain</td>\n",
+       "      <td>10</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>Friday</td>\n",
+       "      <td>Bike</td>\n",
+       "      <td>8.10 AM</td>\n",
+       "      <td>Rainy</td>\n",
+       "      <td>21</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>Saturday</td>\n",
+       "      <td>Car</td>\n",
+       "      <td>8.15 AM</td>\n",
+       "      <td>Windy</td>\n",
+       "      <td>12</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "        Day  Type     Time   Condition  Count\n",
+       "0  Monday    Car   7.45 AM  Rainy       20   \n",
+       "1  TuseDay   Jeep  8.00 AM  Cloudy      30   \n",
+       "2  Thursday  Van   8.05 AM  Light Rain  10   \n",
+       "3  Friday    Bike  8.10 AM  Rainy       21   \n",
+       "4  Saturday  Car   8.15 AM  Windy       12   "
+      ]
+     },
+     "execution_count": 6,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "import os\n",
+    "columns = [\"Day\",\"Type\",\"Time\",\"Condition\",\"Count\"]\n",
+    "data = pd.read_csv(os.path.join('datax.csv'), names = columns, skiprows=1)\n",
+    "pd.set_option('display.max_colwidth', 1)\n",
+    "data.head()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "06b9364f",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def scaling_operation(do_scaling, X, y):\n",
+    "\n",
+    "    try:\n",
+    "        X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.20)\n",
+    "\n",
+    "        if do_scaling:\n",
+    "            scaler_x_minmax = MinMaxScaler()\n",
+    "\n",
+    "            scaler_x_minmax.fit(X_train)\n",
+    "            X_train_scaled = scaler_x_minmax.transform(X_train)\n",
+    "\n",
+    "            X_test_scaled = scaler_x_minmax.transform(X_test)\n",
+    "\n",
+    "            scaler_y_minmax = MinMaxScaler()\n",
+    "            scaler_y_minmax.fit(y_train)\n",
+    "            y_train_scaled = scaler_y_minmax.transform(y_train)\n",
+    "\n",
+    "            y_test_scaled = scaler_y_minmax.transform(y_test)\n",
+    "\n",
+    "            return scaler_y_minmax, X_train_scaled, X_test_scaled, y_train_scaled, y_test_scaled, scaler_x_minmax\n",
+    "\n",
+    "        else:\n",
+    "\n",
+    "            return None, X_train, X_test, y_train, y_test, None\n",
+    "    except:\n",
+    "        logging.error(\"Something went wrong...\")\n",
+    "\n",
+    "\n",
+    "def get_plots(y_true, y_pred, x_tick_labels):\n",
+    "    try:\n",
+    "        assert (y_true.shape[0] == y_pred.shape[0])\n",
+    "        fig = plt.figure()\n",
+    "        ax1 = fig.add_subplot(1, 1, 1)\n",
+    "        xc = np.arange(len(x_tick_labels))\n",
+    "        ax1.plot(xc, y_pred, label='pred')\n",
+    "        ax1.plot(xc, y_true, label='true')\n",
+    "        ax1.set_ylabel(\"Count Per Day\")\n",
+    "        plt.legend()\n",
+    "        plt.show()\n",
+    "\n",
+    "    except AssertionError as error:\n",
+    "        logging.error(\"Unequal number of samples in output\")\n",
+    "\n",
+    "\n",
+    "\n",
+    "def pre_process(data):\n",
+    "    try:\n",
+    "        Day = data.iloc[:, 0].astype(str)\n",
+    "        Type = data.iloc[:, 1].astype(str)\n",
+    "        Time = data.iloc[:, 2].astype(str)\n",
+    "        Condition = data.iloc[:, 3].astype(str)\n",
+    "        Count = data.iloc[:, 4].fillna(0)\n",
+    "\n",
+    "        # stack independent and dependent feature variables\n",
+    "        processed_data = pd.concat([Day,Type,Time,Condition,Count], axis=1)\n",
+    "        # processed_data = pd.DataFrame(processed_data)\n",
+    "        \n",
+    "        # data with label encoding (get the unique number for each unique observation)\n",
+    "        encodedData = MultiColumnLabelEncoder(\n",
+    "            columns=[\"Day\",\"Type\",\"Time\",\"Condition\"]).fit_transform(processed_data)\n",
+    "\n",
+    "        # getting all the raw data features\n",
+    "        #raw_data_features = encodedData.iloc[:, 0:-1].values\n",
+    "        # getting the target value\n",
+    "        raw_data_target = encodedData.iloc[:, 4].values.reshape(-1, 1)\n",
+    "\n",
+    "        # mutual information graph\n",
+    "        # mutual_info_regr(raw_data_features, raw_data_target)\n",
+    "\n",
+    "        # Choosing the best features based on mutual information graph\n",
+    "        best_feature_1 = encodedData.iloc[:, 1]\n",
+    "        best_feature_2 = encodedData.iloc[:, 3]\n",
+    "\n",
+    "        train_data_X = pd.concat([best_feature_1, best_feature_2], axis=1)\n",
+    "        target_data_y = raw_data_target\n",
+    "\n",
+    "        # set the scaling true (scaled data) or false (processed raw data)\n",
+    "        scaling = True\n",
+    "\n",
+    "        # all features and target scaled/raw (Scaled -> True/False) data\n",
+    "        scaler_y_minmax, X_train_scaled, X_test_scaled, \\\n",
+    "        y_train_scaled, y_test_scaled, scaler_x_minmax = scaling_operation(scaling, train_data_X,\n",
+    "                                                                           target_data_y)\n",
+    "\n",
+    "        # test instances are saved for latter plotting purposes\n",
+    "        test_instances = X_test_scaled[:, 0]\n",
+    "\n",
+    "        return scaler_y_minmax, X_train_scaled, X_test_scaled, y_train_scaled, y_test_scaled, scaler_x_minmax, test_instances\n",
+    "\n",
+    "    except AssertionError as error:\n",
+    "        print(\"input data cannot have NaN or Inf values\")\n",
+    "\n",
+    "def train(X, y, use_keras=False, params=None):\n",
+    "    try:\n",
+    "        assert (X.shape[0] == y.shape[0])\n",
+    "        logging.info(\"Training model\")\n",
+    "        if params == None:\n",
+    "\n",
+    "            num_layers = 2\n",
+    "            num_neurons = 130\n",
+    "            activation = 'relu'\n",
+    "            learning_rate = 1e-10\n",
+    "            n_epochs = 300\n",
+    "            batch_size = 8\n",
+    "            dropout = Dropout(0.2)\n",
+    "\n",
+    "        else:\n",
+    "            num_layers = params['num_layers']\n",
+    "            num_neurons = params['num_neurons']\n",
+    "            activation = params['activation']\n",
+    "            learning_rate = params['learning_rate']\n",
+    "            n_epochs = params['n_epochs']\n",
+    "            batch_size = params['batch_size']\n",
+    "            dropout = params['dropout']\n",
+    "\n",
+    "        if use_keras:\n",
+    "\n",
+    "            keras.backend.clear_session()\n",
+    "\n",
+    "            # Choose an Optimizer\n",
+    "            optimizer = tf.optimizers.Adam(lr=learning_rate)\n",
+    "\n",
+    "            # Initialize a sequential / feed forward model\n",
+    "            model = Sequential()\n",
+    "\n",
+    "            # Add input and first hidden layer\n",
+    "            model.add(Dense(units=num_neurons, activation=activation, input_dim=X.shape[1]))\n",
+    "\n",
+    "            # add dropout\n",
+    "            model.add(dropout)\n",
+    "\n",
+    "            # Add subsequent hidden layer\n",
+    "            for _ in range(num_layers - 1):\n",
+    "                model.add(Dense(units=num_neurons,\n",
+    "                                    activation=activation\n",
+    "                                    )\n",
+    "                              )\n",
+    "\n",
+    "            # Add Output Layer\n",
+    "            model.add(Dense(units=y.shape[1], activation='relu'))\n",
+    "\n",
+    "            # Compile the regressor\n",
+    "            model.compile(optimizer=optimizer, loss='mae', metrics=['accuracy'])\n",
+    "\n",
+    "            history = model.fit(X, y, validation_split=0.20,\n",
+    "                                    epochs=n_epochs, batch_size=batch_size,\n",
+    "                                    verbose=1, shuffle=True)\n",
+    "\n",
+    "            # summarize history for loss\n",
+    "            plt.plot(history.history['loss'])\n",
+    "            plt.plot(history.history['val_loss'])\n",
+    "            plt.title('Model loss')\n",
+    "            plt.ylabel('Loss (mae)')\n",
+    "            plt.xlabel('Number of epochs')\n",
+    "            plt.legend(['training', 'validation'], loc='upper right')\n",
+    "            plt.grid()\n",
+    "            plt.show()\n",
+    "\n",
+    "        else:\n",
+    "\n",
+    "            model = DecisionTreeRegressor()\n",
+    "            model.fit(X, y)\n",
+    "        return model\n",
+    "\n",
+    "    except AssertionError as error:\n",
+    "        logging.error(\"Unequal number of samples\")\n",
+    "\n",
+    "def predict(model, input):\n",
+    "    logging.info(\"Predicting\")\n",
+    "    output = model.predict(input)\n",
+    "    return output"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "09a6d873",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def main(path):\n",
+    "    try:\n",
+    "        assert (path != \"\")\n",
+    "        logging.info(\"Starting pipeline\")\n",
+    "#         data = get_data(path)\n",
+    "\n",
+    "        # checking if the data has been imported correctly\n",
+    "        logging.info(\"Shape of data imported: \" + str(data.shape))\n",
+    "\n",
+    "        # pre processing the data\n",
+    "        scaler_y_minmax, X_train_scaled, X_test_scaled, y_train_scaled, y_test_scaled, scaler_x_minmax, test_instances = pre_process(data)\n",
+    "\n",
+    "        # Hyper parameter tuning for neural network\n",
+    "        param = {}\n",
+    "        param['num_layers'] = 4\n",
+    "        param['num_neurons'] = 130\n",
+    "        param['activation'] = 'relu'\n",
+    "        param['learning_rate'] = 0.01\n",
+    "        param['n_epochs'] = 10\n",
+    "        param['batch_size'] = 64\n",
+    "        param['dropout'] = Dropout(0.3)\n",
+    "\n",
+    "        # training\n",
+    "        model = train(X_train_scaled, y_train_scaled, use_keras=True, params=param)\n",
+    "\n",
+    "        # making predictions on the transformed dataset\n",
+    "        y_pred_scaled = predict(model, X_test_scaled)\n",
+    "\n",
+    "        # inverting the predictions to their original scale\n",
+    "        #y_pred = self.post_process(y_pred_raw, scaler_y)\n",
+    "\n",
+    "        # generating scores\n",
+    "        get_scores(y_test_scaled, y_pred_scaled, X_test_scaled)\n",
+    "\n",
+    "        # persist model if model-accuracy is satisfactory\n",
+    "#             if self.mean_absolute_deviations < 1:\n",
+    "#                 dump(self.model, \"model.pkl\")\n",
+    "\n",
+    "#             # generating plots\n",
+    "        get_plots(y_test_scaled[0:20], y_pred_scaled[0:20], test_instances[0:20])\n",
+    "\n",
+    "        return None\n",
+    "    except AssertionError as error:\n",
+    "\n",
+    "        logging.error(\"Path cannot be null\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "02f45dcd",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "c:\\python39\\lib\\site-packages\\tensorflow\\python\\keras\\optimizer_v2\\optimizer_v2.py:374: UserWarning: The `lr` argument is deprecated, use `learning_rate` instead.\n",
+      "  warnings.warn(\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 1/10\n",
+      "21/21 [==============================] - 0s 6ms/step - loss: 0.0828 - accuracy: 7.5988e-04 - val_loss: 0.0529 - val_accuracy: 0.0000e+00\n",
+      "Epoch 2/10\n",
+      "21/21 [==============================] - 0s 3ms/step - loss: 0.0482 - accuracy: 7.5988e-04 - val_loss: 0.0523 - val_accuracy: 0.0000e+00\n",
+      "Epoch 3/10\n",
+      "21/21 [==============================] - 0s 3ms/step - loss: 0.0490 - accuracy: 7.5988e-04 - val_loss: 0.0524 - val_accuracy: 0.0000e+00\n",
+      "Epoch 4/10\n",
+      "21/21 [==============================] - 0s 3ms/step - loss: 0.0481 - accuracy: 7.5988e-04 - val_loss: 0.0522 - val_accuracy: 0.0000e+00\n",
+      "Epoch 5/10\n",
+      "21/21 [==============================] - 0s 3ms/step - loss: 0.0477 - accuracy: 7.5988e-04 - val_loss: 0.0533 - val_accuracy: 0.0000e+00\n",
+      "Epoch 6/10\n",
+      "21/21 [==============================] - 0s 3ms/step - loss: 0.0489 - accuracy: 7.5988e-04 - val_loss: 0.0522 - val_accuracy: 0.0000e+00\n",
+      "Epoch 7/10\n",
+      "21/21 [==============================] - 0s 3ms/step - loss: 0.0475 - accuracy: 7.5988e-04 - val_loss: 0.0525 - val_accuracy: 0.0000e+00\n",
+      "Epoch 8/10\n",
+      "21/21 [==============================] - 0s 3ms/step - loss: 0.0476 - accuracy: 7.5988e-04 - val_loss: 0.0534 - val_accuracy: 0.0000e+00\n",
+      "Epoch 9/10\n",
+      "21/21 [==============================] - 0s 3ms/step - loss: 0.0480 - accuracy: 7.5988e-04 - val_loss: 0.0538 - val_accuracy: 0.0000e+00\n",
+      "Epoch 10/10\n",
+      "21/21 [==============================] - 0s 4ms/step - loss: 0.0478 - accuracy: 7.5988e-04 - val_loss: 0.0523 - val_accuracy: 0.0000e+00\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAY4AAAEWCAYAAABxMXBSAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8rg+JYAAAACXBIWXMAAAsTAAALEwEAmpwYAAA6QklEQVR4nO3deXxc1Znn/89TpdJWKi2WbMmWbMl4kRdssC3MThS2MQkBkgaMQ0igCUySTtKkJzNDunsgMMmvQ3cCCWlIGoIhbAHGJMHpmJgmWKzBsQ3GC17xKu+WZO2ytuf3x72SSrKWKlmlKpWe9+tVL926W5064Pute86954qqYowxxoTKE+0CGGOMGVksOIwxxoTFgsMYY0xYLDiMMcaExYLDGGNMWCw4jDHGhMWCw5gIEZEiEVERSQhh3VtF5J3T3Y8xw8GCwxhARPaISLOI5PSY/6F70C6KUtGMiTkWHMZ02Q0s6XgjInOA1OgVx5jYZMFhTJdngC8Hvf8K8HTwCiKSISJPi8gxEdkrIv8sIh53mVdEfiwix0VkF/DZXrZ9QkQOicgBEfmBiHjDLaSITBCR5SJSKSI7ReSOoGULRWStiNSIyBERedCdnywiz4pIhYicEJE1IpIb7mcbAxYcxgR7H0gXkZnuAf0m4Nke6/wcyADOAD6FEzS3ucvuAK4G5gElwPU9tn0KaAWmuutcCXx1EOV8ASgHJrif8f+JyKXusp8BP1PVdGAK8JI7/ytuuScC2cDXgMZBfLYxFhzG9NBx1nEFsAU40LEgKEy+p6q1qroH+Alwi7vKjcBPVXW/qlYC/xK0bS7wGeAuVa1X1aPAQ+7+QiYiE4ELgf+tqk2quh74FV1nSi3AVBHJUdU6VX0/aH42MFVV21R1narWhPPZxnSw4DCmu2eALwK30qOZCsgBfMDeoHl7gXx3egKwv8eyDoXutofcpqITwH8A48Is3wSgUlVr+yjD7cB0YKvbHHV10PdaCbwgIgdF5F9FxBfmZxsDWHAY042q7sXpJP8M8Nsei4/j/HIvDJo3ia6zkkM4TUHByzrsB04COaqa6b7SVXV2mEU8CIwRkUBvZVDVHaq6BCeQHgCWiYhfVVtU9T5VnQVcgNOk9mWMGQQLDmNOdTtwqarWB89U1TacPoMfikhARAqBf6CrH+Ql4NsiUiAiWcDdQdseAl4DfiIi6SLiEZEpIvKpcAqmqvuB94B/cTu857rlfRZARL4kImNVtR044W7WLiKfFpE5bnNbDU4Atofz2cZ0sOAwpgdV/URV1/ax+FtAPbALeAd4HljqLnscpznoI+ADTj1j+TKQCHwMVAHLgPGDKOISoAjn7ON3wL2q+rq7bBGwWUTqcDrKb1LVRiDP/bwanL6bN3Gar4wJm9iDnIwxxoTDzjiMMcaExYLDGGNMWCw4jDHGhMWCwxhjTFhGxTDNOTk5WlRUNKht6+vr8fv9Q1ugEczqo4vVRXdWH13ipS7WrVt3XFXH9pw/KoKjqKiItWv7urqyf2VlZZSWlg5tgUYwq48uVhfdWX10iZe6EJG9vc23pipjjDFhseAwxhgTFgsOY4wxYRkVfRzGmPjR0tJCeXk5TU1N0S5KnzIyMtiyZUu0ixGy5ORkCgoK8PlCGzDZgsMYM6KUl5cTCAQoKipCRKJdnF7V1tYSCAQGXjEGqCoVFRWUl5czefLkkLaxpipjzIjS1NREdnZ2zIbGSCMiZGdnh3UGZ8FhjBlxLDSGVrj1acHRj6f/sofVh1qjXQxjjIkpFhz9eGntft4ut+AwxnQ5ceIEjz76aNjbfeYzn+HEiRP9rnPPPffw+uuv97tOLLDg6EdxbjrldfaQNGNMl76Co7W1/x+ZK1asIDMzs9917r//fi6//PLTKd6wsODoR3FeGidOKlX1zdEuijEmRtx999188sknnH322ZxzzjlcfPHFXHPNNcyaNQuA6667jksuuYTZs2fz2GOPdW5XVFTE8ePH2bNnDzNnzuSOO+5g9uzZXHnllTQ2NgJw6623smzZss717733XubPn8+cOXPYunUrAMeOHeOKK65g9uzZfPWrX6WwsJDjx48Pax3Y5bj9KM5LB2DbkVrOOyM7yqUxxvR03x828/HBmiHd56wJ6dz7udl9Lv/Rj37Epk2bWL9+PWVlZXz2s59l06ZNnZeyLl26FJ/PR0JCAueccw5/8zd/Q3Z29+PHjh07+M1vfsPjjz/OjTfeyMsvv8yXvvSlUz4rJyeHDz74gEcffZQf//jH/OpXv+K+++7j0ksv5Xvf+x5/+tOfeOKJJ4b0+4fCzjj6MSPPuQ572+HaKJfEGBOrFi5c2O3+h4cffpgLLriA8847j/3797Njx45Ttpk8eTJnn302AAsWLGDPnj297vsLX/jCKeu888473HTTTQAsWrSIrKysofsyIbIzjn6MCyTh98FWCw5jYlJ/ZwbDJXj49LKyMl5//XVef/11cnNzKS0t7fX+iKSkpM5pr9fb2VTV13per3fAPpThZGcc/RARCtI8bD9iwWGMcQQCAWprez8mVFdXk5WVRWpqKlu3buX9998f8s+/8MILeemllwB47bXXqKqqGvLPGIidcQygIODhr4drUVW76cgYQ3Z2NhdeeCFnnnkmKSkp5Obmdi5btGgRv/zlLykpKWHmzJmcd955Q/759957L0uWLOGZZ57h/PPPJy8vb9iHN7HgGEBBmoc/72vmwIlGCrJSo10cY0wMeP7553udn5SUxKuvvtrrWFUdfRQ5OTls2rSpc/53v/vdzumnnnrqlPUBSkpKKCsrA5wBFFeuXElCQgJ/+ctfWLNmTbemr+FgwTGAgoDTmrftcK0FhzEm6vbt28eNN95Ie3s7iYmJPP7448NeBguOAeSnucFxpJbLZuYOsLYxxkTWtGnT+PDDD6NaBuscH0CqT8jPTLFLco0xxmXBEYLpuWkWHMYY44pocIjIIhHZJiI7ReTuXpYniciL7vLVIlLkzveJyK9FZKOIbBGR74W6z0gozkvnk2N1tLTZuFXGGBOx4BARL/AIcBUwC1giIrN6rHY7UKWqU4GHgAfc+TcASao6B1gA/HcRKQpxn0NuRl6AljZl9/H6SH+UMcbEvEiecSwEdqrqLlVtBl4Aru2xzrXAr93pZcBl4twsoYBfRBKAFKAZqAlxn0Nueq5zWZ3dQW6MCVdaWhoABw8e5Prrr+91ndLSUtauXdvvfn7605/S0NDQ+T6UYdojJZJXVeUD+4PelwPn9rWOqraKSDWQjRMi1wKHgFTgO6paKSKh7BMAEbkTuBMgNze38xrocNXV1dGydR0egf9avYn0qu2D2k+8qKurG3Rdxhuri+6Gqz4yMjL6vHM7VrS1tXUrY8d9HU8++WSvZW9ra6O+vr7f7/XQQw9x3XXXdQ6Y+OKLL3bueyg0NTWF/N8vVi/HXQi0AROALOBtEQnr6Saq+hjwGEBJSYmWlpYOqiBlZWWUlpYyZf2bNCb5KS0tGdR+4kVHfRiri56Gqz62bNky7HdKB7v77ruZOHEif/d3fwfA97//fRISEli1ahVVVVW0tLTwT//0T50DEYIzTMmePXu4+uqr2bRpE42Njdx222189NFHzJgxg+bmZvx+P4FAgK9//eusWbOGxsZGrr/+eu677z4efvhhDh06xOc+9zlycnJYtWoVRUVFrF27lpycHB588EGWLl0KwFe/+lXuuusu9uzZw1VXXcVFF13Ee++9R35+Pq+88gopKSm9fq/k5GTmzZsXUh1EMjgOABOD3he483pbp9xtlsoAKoAvAn9S1RbgqIi8C5TgnG0MtM+IKM4L8FH5ieH4KGNMqF69Gw5vHNp95s2Bq37U5+LFixdz1113dQbHSy+9xMqVK/n2t79Neno6x48fZ+HChSxevLjPYYp+8YtfkJqaypYtW9iwYQPz58/vXPbDH/6QMWPG0NbWxmWXXcaGDRv49re/zYMPPsiqVavIycnptq9169bx5JNPsnr1alSVc889l0996lNkZWWFPHx7uCLZx7EGmCYik0UkEbgJWN5jneXAV9zp64E3VFWBfcClACLiB84Dtoa4z4gozg2wv7KRupOxM0KlMWb4zZs3j6NHj3Lw4EE++ugjsrKyyMvL4x//8R+ZO3cul19+OYcOHeLIkSN97uOtt97qPIDPnTuXuXPndi576aWXmD9/PvPmzWPz5s18/PHH/ZbnnXfe4fOf/zx+v5+0tDS+8IUv8PbbbwOhD98eroidcbh9Ft8EVgJeYKmqbhaR+4G1qroceAJ4RkR2ApU4QQDOlVNPishmQIAnVXUDQG/7jNR3CFbsPptjx5Fa5k0a/vHvjTG96OfMIJJuuOEGli1bxuHDh1m8eDHPPfccx44dY926dfh8PgoLC3sdTn0gu3fv5sc//jFr1qwhKyuLW2+9dVD76RDq8O3hiuh9HKq6QlWnq+oUVf2hO+8eNzRQ1SZVvUFVp6rqQlXd5c6vc+fPVtVZqvpv/e1zOMzoeBqgXVllzKi3ePFiXnjhBZYtW8YNN9xAdXU148aNw+fzsWrVKvbt29fv9pdccknnQImbNm1iw4YNANTU1OD3+8nIyODIkSO8+uqrndv0NZz7xRdfzO9//3saGhqor6/nd7/7HRdffPEQfttTxWrneMwpyEohNdFrl+QaY5g9eza1tbXk5+czfvx4br75Zj73uc8xZ84cSkpKmD59er/bf/3rX+e2225j5syZzJw5kwULFgBw1llnMW/ePGbMmMHEiRO58MILO7e58847WbRoERMmTGDVqlWd8+fPn8+tt97KwoULAadzfN68eUPWLNUbcboU4ltJSYkOdI10X4KvFLn2kXfxJ3p5/o6hH2N/pLAribpYXXQ3nFdVzZw5M+Kfczp6G1Y91vVWryKyTlVPuZTUxqoKw4zcgDVVGWNGPQuOMBTnBaiob+ZY7cloF8UYY6LGgiMMHVdW2VmHMdE1GprYh1O49WnBEYbO4DhiwWFMtCQnJ1NRUWHhMURUlYqKCpKTk0Pexq6qCkNOWhI5aYlsO1wT7aIYM2oVFBRQXl7OsWPHol2UPjU1NYV1II625ORkCgoKQl7fgiNM062D3Jio8vl8TJ48OdrF6FdZWVnI4z6NRNZUFabivADbj9TR3m6nycaY0cmCI0wz8gI0trSxv6ph4JWNMSYOWXCEyR7qZIwZ7Sw4wtQRHNstOIwxo5QFR5j8SQlMGpPKVrsk1xgzSllwDEJxnl1ZZYwZvSw4BqE4N8Du4/WcbG2LdlGMMWbYWXAMQnFegLZ25ZOj9dEuijHGDDsLjkGY0Tn0iN1BbowZfSw4BqEox4/PK3ZJrjFmVLLgGASf18OUsWl2Sa4xZlSKaHCIyCIR2SYiO0Xk7l6WJ4nIi+7y1SJS5M6/WUTWB73aReRsd1mZu8+OZeMi+R36MsOurDLGjFIRCw4R8QKPAFcBs4AlIjKrx2q3A1WqOhV4CHgAQFWfU9WzVfVs4BZgt6quD9ru5o7lqno0Ut+hP9PzAhysbqK6sSUaH2+MMVETyTOOhcBOVd2lqs3AC8C1Pda5Fvi1O70MuExEpMc6S9xtY0pHB/l2uxHQGDPKRHJY9Xxgf9D7cuDcvtZR1VYRqQaygeNB6yzm1MB5UkTagJeBH2gvT3QRkTuBOwFyc3MpKysb1Jeoq6vrdduqxnYA/vDWOur3+Aa175Gor/oYjawuurP66BLvdRHTz+MQkXOBBlXdFDT7ZlU9ICIBnOC4BXi657aq+hjwGEBJSYmWlpYOqgxlZWX0tq2q8v33X0PTx1Naeuag9j0S9VUfo5HVRXdWH13ivS4i2VR1AJgY9L7AndfrOiKSAGQAFUHLbwJ+E7yBqh5w/9YCz+M0iQ07EWG6dZAbY0ahSAbHGmCaiEwWkUScEFjeY53lwFfc6euBNzqanUTEA9xIUP+GiCSISI477QOuBjYRJcV5AbYdqbVnHxtjRpWIBYeqtgLfBFYCW4CXVHWziNwvIte4qz0BZIvITuAfgOBLdi8B9qvqrqB5ScBKEdkArMc5Y3k8Ut9hIDPyAlQ3tnCk5mS0imCMMcMuon0cqroCWNFj3j1B003ADX1sWwac12NePbBgyAs6SF0PdaohL2PkPJjeGGNOh905fhrsklxjzGhkwXEaMlMTyU1PsjGrjDGjigXHaSrOS7crq4wxo4oFx2kqzk1jx9E6Wtvao10UY4wZFhYcp6k4L53m1nb2VjZEuyjGGDMsLDhOU+dDnay5yhgzSlhwnKap49LwCNZBbowZNSw4TlOyz0tRtt8e6mSMGTUsOIZAx9AjxhgzGlhwDIHpuQH2VNTT2NwW7aIYY0zEWXAMgRl5AVRhx1E76zDGxD8LjiFQbFdWGWNGEQuOIVCY7ScpwWPBYYwZFSw4hoDXI0zLTbMOcmPMqGDBMUSKc23MKmPM6GDBMURm5AU4WnuSqvrmaBfFGGMiyoJjiEzP63iok511GGPimwXHELGHOhljRgsLjiEyLpBEZqrPzjiMMXEvosEhIotEZJuI7BSRu3tZniQiL7rLV4tIkTv/ZhFZH/RqF5Gz3WULRGSju83DIiKR/A6hEhGm5wbYdrgm2kUxxpiIilhwiIgXeAS4CpgFLBGRWT1Wux2oUtWpwEPAAwCq+pyqnq2qZwO3ALtVdb27zS+AO4Bp7mtRpL5DuGbkBdh+pA5VjXZRjDEmYiJ5xrEQ2Kmqu1S1GXgBuLbHOtcCv3anlwGX9XIGscTdFhEZD6Sr6vvqHJ2fBq6LUPnDVpwXoO5kKwdONEa7KMYYEzEJEdx3PrA/6H05cG5f66hqq4hUA9nA8aB1FtMVOPnufoL3md/bh4vIncCdALm5uZSVlQ3qS9TV1YW8bUOVM8jhsv96j7PHRbJqoyec+oh3VhfdWX10ife6iOmjm4icCzSo6qZwt1XVx4DHAEpKSrS0tHRQZSgrKyPUbec3tfDD1a/hG1tEaenUQX1erAunPuKd1UV3Vh9d4r0uBgwOESkAbgIuBiYAjcAm4I/Aq6ra3semB4CJQe8L3Hm9rVMuIglABlARtPwm4Dc91i8YYJ9Rk57sIz8zxS7JNcbEtX77OETkSWAp0IzTcb0E+AbwOk6n9Dsickkfm68BponIZBFJxAmB5T3WWQ58xZ2+HnjD7btARDzAjbj9GwCqegioEZHz3L6QLwOvhPhdh0VxXsCGHjHGxLWBzjh+0kcz0Sbgt24gTOptQ7fP4pvASsALLFXVzSJyP7BWVZcDTwDPiMhOoBInXDpcAuxX1V09dv0N4CkgBXjVfcWM6bkB3t5xjJa2dnxeu03GGBN/+g2O4NAQkRRgkqpuC1reDOzsZ/sVwIoe8+4Jmm4Cbuhj2zLgvF7mrwXO7K/c0TQjL0BLm7LrWH3nczqMMSaehPSTWESuAdYDf3Lfny0iPZudDEEPdbJ+DmNMnAq1LeVenPsyTgC4N+NNjkyRRrYpY9NI8IjdQW6MiVuhBkeLqlb3mGe3R/ciMcHD5By/dZAbY+JWqMGxWUS+CHhFZJqI/Bx4L4LlGtGK8wLWVGWMiVuhBse3gNnASZz7KmqAuyJUphFvRl6A/ZWN1J1sjXZRjDFmyIV057iqNgD/5L7MAKbndj2bY/6krCiXxhhjhlZIwSEiY4H/hXPWkdwxX1UvjVC5RrQZeekAbD9swWGMiT+hNlU9B2zFuZLqPmAPzp3hphcFWSmkJnrtoU7GmLgUanBkq+oTOFdXvamqfwvY2UYfPB5hWq4NPWKMiU8hX47r/j0kIp8VkXnAmAiVKS7MyHWurLKHOhlj4k2owfEDEckA/gfwXeBXwHciVqo4UJwXoLK+meN1zdEuijHGDKlQr6r6T3eyGvh05IoTP2Z0DD1yuJaxgaQol8YYY4ZOqFdVTca5l6MoeBtVvSYyxRr5prvBsfVwDRdNy4lyaYwxZuiE+gTA3+MMgf4HoK8HN5kgOWlJ5KQl2kOdjDFxJ9TgaFLVhyNakjhkD3UyxsSjUDvHfyYi94rI+SIyv+MV0ZLFgem5AbYfqaO93a6sMsbEj1DPOOYAt+Dcu9HRVKXYvRz9mpEXoLGljX2VDRTl+KNdHGOMGRKhBscNwBnuE/9MiIrdoUe2Ham14DDGxI1Qm6o2AZkRLEdcmjYuDcD6OYwxcSXU4MgEtorIShFZ3vEaaCMRWSQi20Rkp4jc3cvyJBF50V2+WkSKgpbNFZG/iMhmEdkoIsnu/DJ3n+vd17gQv8Ow8yclMGlMqgWHMSauhNpUdW+4OxYRL/AIcAVQDqwRkeWq+nHQarcDVao6VURuAh4AFotIAvAscIuqfiQi2XQNewJws6quDbdM0WAPdTLGxJt+g0NERB1vDrROL4sWAjtVdZe73gvAtUBwcFwLfN+dXgb8u4gIcCWwQVU/AlDVihC/T8yZkRfgja1HOdnaRlKCN9rFMcaY0zbQGccqEXkZeEVV93XMFJFE4CLgK8Aq4Klets0H9ge9LwfO7WsdVW0VkWogG5gOqIisBMYCL6jqvwZt96SItAEvAz/oLbhE5E7gToDc3FzKysoG+Kq9q6urG/S2AK0VrbS1Ky+sKKMwfeQHx+nWRzyxuujO6qNLvNfFQMGxCPhb4DfusCMngBScvpHXgJ+q6ocRKtdFwDlAA/BnEVmnqn/GaaY6ICIBnOC4BXi65w5U9THgMYCSkhItLS0dVEHKysoY7LYA+Udq+cVHb5E+sZjSeQWD3k+sON36iCdWF91ZfXSJ97roNzhUtQl4FHhURHxADtCoqidC2PcBYGLQ+wJ3Xm/rlLv9GhlABc7ZyVuqehxARFYA84E/q+oBt2y1IvI8TpPYKcERK4py/CR6PfZQJ2NM3Aj1qipUtUVVD4UYGuA8IXCaiEx2m7ZuAnpeibUcp7kL4HrgDbfZaSUwR0RS3UD5FPCxiCSISA6AG2RX41wqHLN8Xg9njPXblVXGmLgR6lVVYXP7LL6JEwJeYKmqbhaR+4G1qrocZ+DEZ0RkJ1CJEy6oapWIPIgTPgqsUNU/iogfWOmGhhd4HXg8Ut9hqMzIC7B6d2W0i2GMMUMiYsEBoKorgBU95t0TNN2Ec1d6b9s+i3NJbvC8emDB0Jc0sorz0vn9+oNUN7aQkeKLdnGMMea0hNRUJSJ+EfG409NF5Br3V78JQcdDnWyIdWNMPAi1j+MtIFlE8nGuprqF3i/BNb3oeqiTBYcxZuQLNThEVRuALwCPquoNwOzIFSu+TMhIJpCcwHYLDmNMHAg5OETkfOBm4I/uvJF/N9swERGKc+2hTsaY+BBqcNwFfA/4nXtl1Bk4d4ybEE3PC7D1cA29j85ijDEjR0jBoapvquo1qvqA20l+XFW/HeGyxZUZeQFqmlo5XNMU7aIYY8xpCfWqqudFJN29j2ITzs14/zOyRYsvxblOB7k1VxljRrpQm6pmqWoNcB3wKjAZ58oqE6LiPAsOY0x8CDU4fO59G9cBy1W1BeeObhOizNREctOTLDiMMSNeqMHxH8AewA+8JSKFQE2kChWvivPS7aFOxpgRL9TO8YdVNV9VP+M+2Gkv8OkIly3uzMgLsONoHa1t7dEuijHGDFqoneMZIvKgiKx1Xz/BOfswYZieG6C5tZ09FQ3RLooxxgxaqE1VS4Fa4Eb3VQM8GalCxSsbs8oYEw9CDY4pqnqvqu5yX/cBZ0SyYPFo6rg0PGJjVhljRrZQg6NRRC7qeCMiFwKNkSlS/Er2eSnK9rPtsF1XYIwZuUJ9HsfXgKdFJMN9X0XXk/tMGIrzAmw5ZMFhjBm5Qr2q6iNVPQuYC8xV1XnApREtWZwqzguwt7KBxua2aBfFGGMGJeRnjgOoao17BznAP0SgPHGvODeAKuw4av0cxpiRKazg6EGGrBSjSLE91MkYM8KdTnAMOOSIiCwSkW0islNE7u5leZKIvOguXy0iRUHL5orIX0Rks4hsFJFkd/4C9/1OEXlYREZUgBVm+0n2eeyhTsaYEavf4BCRWhGp6eVVC0wYYFsv8AhwFTALWCIis3qsdjtQpapTgYeAB9xtE4Bnga+p6mygFGhxt/kFcAcwzX0tCvnbxgCvR5g2LmBDjxhjRqx+g0NVA6qa3ssroKoDXZG1ENjp3vfRDLwAXNtjnWuBX7vTy4DL3DOIK4ENqvqRW44KVW0TkfFAuqq+r84TkZ7GGXhxRJmeG7CmKmPMiBXq5biDkQ/sD3pfDpzb1zqq2ioi1UA2MB1QEVkJjAVeUNV/ddcv77HP/N4+XETuBO4EyM3NpaysbFBfoq6ubtDb9iWhvoVjtc384bVVBBJHVEtbROpjpLK66M7qo0u810Ukg+N0JAAXAecADcCfRWQdUB3qDlT1MeAxgJKSEi0tLR1UQcrKyhjstn3xTDjGi9v+Ss6UuZw/JXtI9x1pkaiPkcrqojurjy7xXhen0zk+kAPAxKD3Be68Xtdx+zUygAqcM4m3VPW4qjYAK4D57voFA+wz5nU91MluBDTGjDyRDI41wDQRmSwiicBNwPIe6yyn6w7064E33L6LlcAcEUl1A+VTwMeqegioEZHz3L6QLwOvRPA7RMS4QBKZqT7rIDfGjEgRa6py+yy+iRMCXmCpqm4WkfuBtaq6HHgCeEZEdgKVOOGCqlaJyIM44aPAClX9o7vrbwBPASk4j7F9NVLfIVJEhOLcgD0N0BgzIkW0j0NVV+A0MwXPuydougm4oY9tn8W5JLfn/LXAmUNb0uE3Iy/Ayx8cQFUZYbeiGGNGuUg2VZl+TM8LUHeylfIqG2TYGDOyWHBEiT3UyRgzUllwRMn0XBuzyhgzMllwREkg2Ud+Zop1kBtjRhwLjigqzrMrq4wxI48FRxQV5wX45Fgdza3t0S6KMcaEzIIjiopzA7S2K7uP10e7KMYYEzILjijqeqiTDT1ijBk5LDiiaMrYNBI8YpfkGmNGFAuOKEpM8HDGWL91kBtjRhQLjiizhzoZY0YaC44om5EXoLyqkbqTrdEuijHGhMSCI8qK89IBG3rEGDNyWHBEWXFux0OdLDiMMSODBUeUFWSlkJroteAwxowYFhxR5vEI0+2hTsaYEcSCIwYU5wbYdqQW56m5xhgT2yw4YkBxXoDK+maO1Z2MdlGMMWZAFhwxoPOhTofrolwSY4wZWESDQ0QWicg2EdkpInf3sjxJRF50l68WkSJ3fpGINIrIevf1y6Btytx9diwbF8nvMBxszCpjzEiSEKkdi4gXeAS4AigH1ojIclX9OGi124EqVZ0qIjcBDwCL3WWfqOrZfez+ZlVdG6GiD7vstCRy0hKtg9wYMyJE8oxjIbBTVXepajPwAnBtj3WuBX7tTi8DLhMRiWCZYlZxntNBbowxsS5iZxxAPrA/6H05cG5f66hqq4hUA9nusski8iFQA/yzqr4dtN2TItIGvAz8QHu5HElE7gTuBMjNzaWsrGxQX6Kurm7Q24bD33KSNQdbeWPVKjwxnJ3DVR8jgdVFd1YfXeK9LiIZHKfjEDBJVStEZAHwexGZrao1OM1UB0QkgBMctwBP99yBqj4GPAZQUlKipaWlgypIWVkZg902HEf8+3ht70bOmLOQohx/xD9vsIarPkYCq4vurD66xHtdRLKp6gAwMeh9gTuv13VEJAHIACpU9aSqVgCo6jrgE2C6+/6A+7cWeB6nSWzE6xizykbKNcbEukgGxxpgmohMFpFE4CZgeY91lgNfcaevB95QVRWRsW7nOiJyBjAN2CUiCSKS4873AVcDmyL4HYbN9Nw0RGywQ2NM7ItYU5XbZ/FNYCXgBZaq6mYRuR9Yq6rLgSeAZ0RkJ1CJEy4AlwD3i0gL0A58TVUrRcQPrHRDwwu8Djweqe8wnFITE5g0JtWurDLGxLyI9nGo6gpgRY959wRNNwE39LLdyzj9Fz3n1wMLhr6kscF5qJPdy2GMiW2x2jk+Ks3IC/DG1qM0tbSR7PNGuzjGGID2djhZA00noKkaGk840/38LamuhBMXQeEFUHQhZBZCDF8tGS4LjhhSnBegrV355FgdsydkRLs4xsSP9jbnoN/nAb+fZSdrQNv73rd4ISUTkjOdvylZnGwS0rb9EdY/66yTnu+ESOGFzitn2ogOEguOGBL8UCcLjhjV3ABHt8CRjUzc9wHsaIW8ORDIjXbJRqeWRqjcDZWfQMUnULUbGiq6DvxN1dBYDSer+9+PN7HrwJ+cCf6xzsE9eF6vfzMgMe2UENhYVkbpJZfAsa2w913Y+x7sfgs2/j9nBf/Y7kEybhZ4Rs7QgRYcMaQox0+i12Md5LFAFeqOwOFNcHgDHNkEhzdCxc7OX59TAHa5Ax/4xzoBknsm5M2FvDMhexp47Z/YaWtpgqo9XeFQ+QlU7oKKXVBT3n3d1Gznv0VypvMrf9zsUw/0vYWAL2XozwA8Hsid5bwW3uH8P1W5C/a84wTJ3vfg41ecdZMzYJLbrFV4AeSdFdP/78RuyUYhn9fDlHFpNvTIcGtrhYodTjB0vI5sgvpjXetkToLcOTD7850B8c66TVw0LcsNl41OwKz+JbQ1O9t4k2DcTGf9jjDJne0cJEx3rc19h0P1fiBocIiUMZA9BYoucv6OOcN5ZU+J7boVccqYPQUWuHchnNjnhsi7sOdd2P6qMz8xDSae23VWkj8fEpKiV/YeLDj685svMu/QTjg8DdLGgX8cpI2FtFx32n0lDt2d3sW5aazeXTlk+zM9NFU7B/oj7pnE4U1O01Ob+ywUb6JzsJ/239wD/hznYJ+SecquWn17nYNX0UVdM9ta4Pj27mcq21bAh890rZNZ2LXvjrOUzEkjus07JG0tULW3ezhUuAFRvb97P0JypnOAnXQeZN8MY9yAyD4DUrKi9hWGXOYk53WWeydC7eGuINn7Hrzxf535CclQcE5XkBScA4mpUSu2BUd/MifSfmS/8z/2vvedtlN6eUqfz98VIp0BEzyd6wSOf9yA/7GL89L5/fqDVDe0kJHqi8z3Gg1U4cTerrOBjqA4sa9rndQc5yzg3Duds4m8OU67tvc06t3rc4ImdzactbirLLWHu85KOpq9tv6Rzv+fkjPcZq6gMBk3M6Z+ZYakrdWp98pdPc4cPnHqXtu61k3KcIKg4BznwNkZDlMgdUz0vkM0BfLgzC84L4CGyq5mrb3vwFv/BvoAeHzOWUhHkEw8F5LTh62YFhz9ueoBPkoJGnOmrRUajjtt33XHoP5o13TdEef98Z3OKWdjH2cNiYGgs5axbsB0TOey0JdAgRxjx8FjlEydMGxftV+q7qvd+RtrWprg2Bb3wNwRFJuDOkQFsqdCfgksuNVpNso90/lHOhy/8kUgfbzzmn5l1/zmejjyMRzZ2FX2D56BlnpnuScBcqYH9Z24oeLPGfoytrVCcx20NDgXAHRO13e9Wtz5ze78lo5lDdBcy8LDO+Gto9De2rXfxIATDhPmwZzre4RDdvyfZZ2u1DEw82rnBc4Z8/6/dvWTvPdzeOchEI/z/3XhhU4/yaTzIxq+Fhzh8CY4B5tA3sDrtrU4beR1R92/R5zpuqNu4ByFY9tgz9vQWNW52QLgnSTgWSAp3T1rGev8ku04eLe3uQfxEF/tbUEH/uBX8H60l23c6aCzrFKAdxKdJh2vz/0bNO3xBc3vZXmv06Gu7/5tbYajm7sOtse3d/2STUxzfu3PvaGro3rczKie1vcp0Q8Tz3FeHdrbnSuDOprRDm90DhIbXuxaJzD+1CAJ+WDfx8G/o18mJOKUPdEPvlSnzhNTqUubTGrJku7h4B9r4TCUkjNg2hXOC5z/duVrus5K1j4B7z/iLBs3yzkjufT/9NrUejosOCLF64P0Cc5rIK3NTrjUH0Vrj3DPb1Zxyfh2rpjk6QqethbnV4V4ICGha7rny9PHfPG6f6XH+t4e60mP9bsv27NrJ0UTJzjlaWt2X8HTrd3nt1T3WKfHdu0t0HqSXpsAB5Je4DQ1zby661d51uQRdVnjKTyerg7U2Z/vml9f4Z6ZBDW97VrV/df9KftKcA/u7kE+0T3Ip+ZApr/Xg3+36d629aX2eQXSx2VljIvjEWFjUqIfzih1XuD8WzrwgdtH8i5s+U9Y9MCQf6wFRyxISISMfMjIR4AtuelsVbjiqguiXbJT7NEyiiJxcGhv6yOIek67ATq2eHS1g/uzux8gwDlIHNvmNF8k9hIECYnRKq2JloQkKDzfefFd5ww2Aj+kLDhiUHFegD98dBBVZdQ8ENHjBU+K82vWhCYhCcbPjXYpTCyL0Nn3CD6nj1/FeQFqmlo5XNMU7aIYY8wpLDhiUMfQI/ZQJ2NMLLLgiEHFeU5wbLfgMMbEIAuOGJSZmkhuepKNWWWMiUkWHDGqOC/dmqqMMTHJgiNGzcgLsPNYHa1t/TwHwBhjosCCI0YV5wZobm1nT0VDtItijDHdRDQ4RGSRiGwTkZ0icncvy5NE5EV3+WoRKXLnF4lIo4isd1+/DNpmgYhsdLd5WOL0RoeODnLr5zDGxJqIBYeIeIFHgKuAWcASEZnVY7XbgSpVnQo8BATfG/+Jqp7tvr4WNP8XwB3ANPe1KFLfIZqmjkvDI7DtcE20i2KMMd1E8oxjIbBTVXepajPwAnBtj3WuBdxHqLEMuKy/MwgRGQ+kq+r7qqrA08B1Q17yGJDs81KU47eHOhljYk4khxzJB/YHvS8Hzu1rHVVtFZFqINtdNllEPgRqgH9W1bfd9YOfFVnuzjuFiNwJ3AmQm5tLWVnZoL5EXV3doLc9XWM8Tazf3RC1z+9NNOsj1lhddGf10SXe6yJWx6o6BExS1QoRWQD8XkRmh7MDVX0MeAygpKRESwc5MF9ZWdDzOIbZ+tbt/OzPO1h4wUWkJsbGf6po1kessbrozuqjS7zXRSSbqg4AE4PeF7jzel1HRBKADKBCVU+qagWAqq4DPgGmu+sXDLDPuDEjL4Aq7DxaF+2iGGNMp0gGxxpgmohMFpFE4CZgeY91lgPuU9u5HnhDVVVExrqd64jIGTid4LtU9RBQIyLnuX0hXwZeieB3iKriPOdRkHYjoDEmlkSs/cPts/gmsBLwAktVdbOI3A+sVdXlwBPAMyKyE6jECReAS4D7RaQFaAe+pqodz2L9BvAUkAK86r7i0qQxqST7PHZJrjEmpkS04VxVVwAresy7J2i6Cbihl+1eBl7uY59rgTOHtqSxyesRpo0LDFtwtLUrh2uaOFDVyIETDe7fRsrdv8dqT+L3tjFrzxomjUmlKDuVwmw/hdmpFGSlkphg95MOl7Z25ZNjdWwsr8bjgfmTspg0JnX0PL/FRFVs9LiaPhXnBXhz+7Eh2dfJ1jYOnugeDOUnGjsD4lB1E23t3R/hmu1PJD8rhRl5AS6emsOmXeUcqm7i/V0VNDS3da7nEZiQmUJhR5iMSe2azk6Nmc79kai1rZ1PjtWz8UA1mw5Us/FANR8frKGxpa3bejlpicyblMWCwizmT8pibkEGyT5vlEpt4pn9a45xxbkBlq0rp7K+mTH+/h8FWneytTMUyqsaTwmGY7Unu63vEchLTyY/K4WSwizys1LIz0x1/zqvlMTuB56ysuOUll6MqnK8rpm9FfXsrWhgb2VD5/SrGw9R1dDSbbuxgSQ3TPxuoDjTRdmpZKbaI047tLa1s9M9k+gMiUM1NLU4Y5al+LzMnpDO4nMmMic/gzkFGbS1Kx/sq2Ld3io+3HeC//r4CAAJHmF2fgbzJ2WyoNAJlPEZ9oRFc/osOGJcx9AjWw/XUJwb4EBQEHQ0IXW8r27sfrBO9HqYkOkEw6eLx3aGQoEbDHkZyfi8g2teEhHGBpIYG0iipOjUZ39XN7awr6KBvZVusFTUs6eigXd3HuflD7o/2TA9OYGiHL/b/OVnUrbztzA7lXGBpLhtfmlta2fH0bpuZxJbgkIiNdEJiSULJzkhkZ/BGWPT8HpOrY+Z49O5+dxCACrqTvLBvhOs21vFB/uqeH71Pp58dw8A4zOSmV+YxYJJWcwvzGLW+HRrYjRhs+CIcTPc4Ljlib+e0ozkT/S6QZDKgs4zhhRnXmYKOWlJeHo5yAyHjBQfcwqcX8Q9NTa3sb+qgT3H69lX2cAe90xl44FqXt10uNv3TPF5mdTZ7JXKpGw/E7Oc75aZ6mOMP5EUnzfmw6WlrZ0dR+o6A6IjJE62OiHhT/Qye0IGX1xYyJyCdObkZzA5p/eQGEh2WhJXzMrlilm5ADS3trPlUE3nWckHe6v444ZDACQleDirIJN5hZmdYZKTljR0X9zEJQuOGDc2kMR3Lp9OTVNLZyjkZzpnDRkpvpg/YPYmJdHL9NwA091H5AZraWvn4IlG9lQ0sM89S9lb0cDu4/W8uf1Y54E2WGKCh6xUH1mpiWSlJjLGn9gZKpmpic4yv7ssNZFMv49AUkLE6i44JDYcOMHGAzVs7RkS+Rl86bxC5uRncGZ+Bmfk+CMW8okJHs6amMlZEzO57cLJAByqbuSDvSc6w2TpO7v5j7ZdABRmp3aGyPxJWRTnBQYVYPFEVWlsaeNEQwtVDc1UN7RwotGZPtHQQnVjCycamqlqaKG6oYVDFY3kfPwu/sQEUhK9+BO9pCYlkOpz/voTvaQmeklNTMCf5CUlsWNegjM/yets6/NG7cdffyw4YpyI8PeXT4t2MYaNz+tx+0H8wNhuy9rblSO1Tud+ZX0zVe4/1Koe01sP11DV4PxD7nGS1inBI2SmJjLG7+sMl46gGZPaPXjG+J3l6cm+U/4Rt7S1s/1IbdCZRA1bDtXQ7IZEWlICsyekc8t5hcwpcEJicnbkQiJU4zNS+OzcFD47dzwATS1tbDpQzbq9TpC8teMYv/3Qubc2LSmBsydmMn9SJvMLs5g3KYuMFF80iz9o4QbAicau6eZ+no2T7POQmeL8f5OZ6iM7WUhLSqChuY3jdSdpaG5zX63dLioJRYrP64aLEyapwQGT2BVEneHjBpQ/yVnvginZJAyySbovFhxmxPB4hPEZKSF38La3KzVNLVQ1tFBZ39x5QOgKmmaq6luobGhm9/F61u09wYmGZlr7SBuPOI/1zUz1MSY1kYqqRg68vrIzJAJJCczOT+cr5xdyptsnURQDIRGKZJ+XkqIxnf1Vqsr+ykbW7avkg71Of8m/r9rZGcTTxqU5V2+5ZyVTxvpD+hxVpbVdaWt3/ra2tXe+b2lrD5qvtLa3u/M71m+nta3/bVvalZrGoQuAM3LSyEz1keGe0Wam+Nxl7jruuj2vXnOGHOk5NJ+jvV1pam2j/mRXkDQ0t7rv3enmNho757V2Bk/9yVYaW5y/x+tOUt/cSmOzs6+eV9l12Pp/F5EwxBfXWXCYuOVxzyoyUxOZnBP6ga32ZCsn6p1foZUNTuBU1re4f5s7f60mJ9AZEnMLMikckzoiQiIUIsKk7FQmZafy+XnOKD91J1vZsN8JkXX7qlix8RAvrHHGMc1M9ZFMK76/vkFbm3tgdw/uHQf0Nvc1HIYqACLB4xH3jCEBGLr+pPZ252yqvrmVhqAQSorAxQ8WHMYEERHSk51mqUnZqf2u6/yq7PmImfiVlpTABVNzuGBqDuAcqHYdr+u8DHjX/oPkjx+D1yMkeIQEr5Dg8Tjvvc48r8eDzyN43fcJHg8JXsHrEXzd1vX0uh+fu27Hds5yj7tvZ9305OEJgFjj8Qj+pAT8SQlwavfhkLLgMMYMiscjTB0XYOq4AIvPmURZWSWlpWdHu1hmGNgF3MYYY8JiwWGMMSYsFhzGGGPCYsFhjDEmLBYcxhhjwmLBYYwxJiwWHMYYY8JiwWGMMSYsojo8QwBEk4gcA/YOcvMc4PgQFmeks/roYnXRndVHl3ipi0JVHdtz5qgIjtMhImtVtSTa5YgVVh9drC66s/roEu91YU1VxhhjwmLBYYwxJiwWHAN7LNoFiDFWH12sLrqz+ugS13VhfRzGGGPCYmccxhhjwmLBYYwxJiwWHH0QkUUisk1EdorI3dEuTzSJyEQRWSUiH4vIZhH5+2iXKRaIiFdEPhSR/4x2WaJJRDJFZJmIbBWRLSJyfrTLFE0i8h3338kmEfmNiCRHu0xDzYKjFyLiBR4BrgJmAUtEZPQ8I/RUrcD/UNVZwHnA343y+ujw98CWaBciBvwM+JOqzgDOYhTXiYjkA98GSlT1TMAL3BTdUg09C47eLQR2quouVW0GXgCujXKZokZVD6nqB+50Lc6BIT+6pYouESkAPgv8KtpliSYRyQAuAZ4AUNVmVT0R1UJFXwKQIiIJQCpwMMrlGXIWHL3LB/YHvS9nlB8oO4hIETAPWB3lokTbT4H/BbRHuRzRNhk4BjzpNtv9SkT80S5UtKjqAeDHwD7gEFCtqq9Ft1RDz4LDhExE0oCXgbtUtSba5YkWEbkaOKqq66JdlhiQAMwHfqGq84B6YNT2CYpIFk7rxGRgAuAXkS9Ft1RDz4KjdweAiUHvC9x5o5aI+HBC4zlV/W20yxNlFwLXiMgenGbMS0Xk2egWKWrKgXJV7TgDXYYTJKPV5cBuVT2mqi3Ab4ELolymIWfB0bs1wDQRmSwiiTidW8ujXKaoERHBacPeoqoPRrs80aaq31PVAlUtwvl/4w1VjbtflaFQ1cPAfhEpdmddBnwcxSJF2z7gPBFJdf/dXEYcXiyQEO0CxCJVbRWRbwIrca6KWKqqm6NcrGi6ELgF2Cgi6915/6iqK6JXJBNDvgU85/7I2gXcFuXyRI2qrhaRZcAHOFcjfkgcDj9iQ44YY4wJizVVGWOMCYsFhzHGmLBYcBhjjAmLBYcxxpiwWHAYY4wJiwWHiRsioiLyk6D33xWR7w/Rvp8SkeuHYl8DfM4N7gizqyL9WT0+91YR+ffh/EwzcllwmHhyEviCiOREuyDB3MHuQnU7cIeqfjpS5THmdFlwmHjSinOz1Xd6Luh5xiAide7fUhF5U0ReEZFdIvIjEblZRP4qIhtFZErQbi4XkbUist0dr6rjmRz/JiJrRGSDiPz3oP2+LSLL6eVOahFZ4u5/k4g84M67B7gIeEJE/q2Xbf5n0Ofc584rcp+D8Zx7prJMRFLdZZe5Aw9uFJGlIpLkzj9HRN4TkY/c7xlwP2KCiPxJRHaIyL8Gfb+n3HJuFJFT6taMPnbnuIk3jwAbOg58IToLmAlU4tz5/CtVXeg+sOpbwF3uekU4Q+5PAVaJyFTgyzgjoJ7jHpjfFZGO0VDnA2eq6u7gDxORCcADwAKgCnhNRK5T1ftF5FLgu6q6tsc2VwLT3M8XYLmIXIIzxEUxcLuqvisiS4FvuM1OTwGXqep2EXka+LqIPAq8CCxW1TUikg40uh9zNs7IxyeBbSLyc2AckO8+WwIRyQyjXk2csjMOE1fcUXufxnmYTqjWuM8cOQl8AnQc+DfihEWHl1S1XVV34ATMDOBK4MvuUCyrgWycAzzAX3uGhuscoMwdCK8VeA7nmRb9udJ9fYgznMWMoM/Zr6rvutPP4py1FOMMtrfdnf9r9zOKgUOqugac+nLLAPBnVa1W1Sacs6RC93ueISI/F5FFwKgdFdl0sTMOE49+inNwfTJoXivuDyUR8QCJQctOBk23B71vp/u/kZ7j8yjOr/9vqerK4AUiUoozxPhQEeBfVPU/enxOUR/lGozgemgDElS1SkTOAv4b8DXgRuBvB7l/EyfsjMPEHVWtBF7C6WjusAenaQjgGsA3iF3fICIet9/jDGAbzkCYX3eHnUdEpofwIKO/Ap8SkRxxHlO8BHhzgG1WAn/rPhMFEckXkXHusknS9ZzvLwLvuGUrcpvTwBmk8k13/ngROcfdT6C/znv3QgOPqr4M/DOje8h047IzDhOvfgJ8M+j948ArIvIR8CcGdzawD+egnw58TVWbRORXOM1ZH7jDaB8DrutvJ6p6SETuBlbhnEn8UVVfGWCb10RkJvAX52OoA76Ec2awDec58Etxmph+4ZbtNuD/ucGwBvilqjaLyGLg5yKSgtO/cXk/H52P83S/jh+Z3+uvnGZ0sNFxjRnB3Kaq/+zovDZmOFhTlTHGmLDYGYcxxpiw2BmHMcaYsFhwGGOMCYsFhzHGmLBYcBhjjAmLBYcxxpiw/P+BSJByAp5vBAAAAABJRU5ErkJggg==\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "RMSE 0.08548474266469736\n",
+      "MAE 0.051503154099111575\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYgAAAD4CAYAAAD2FnFTAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8rg+JYAAAACXBIWXMAAAsTAAALEwEAmpwYAAA7pUlEQVR4nO2deZhU5Znof29X7ztLg9DdCAoKuCE2REW8jhqDGyRejbsmcWKi42jGyeLc3Gji5M5NosnNplGSGPc9ZsSEaAyIGhQFAREEpBtRutkbqN7X+u4f36nuoqjuruqqU+v7e57znKqzvn26znnP965ijEFRFEVRgslKtACKoihKcqIKQlEURQmJKghFURQlJKogFEVRlJCoglAURVFCkp1oAWLF6NGjzcSJExMthqIoSkrx3nvv7TPGVIRalzYKYuLEiaxatSrRYiiKoqQUIvLJQOvUxKQoiqKERBWEoiiKEhJVEIqiKEpI0sYHoSiKMly6u7upr6+no6Mj0aK4Rn5+PlVVVeTk5IS9jyoIRVEynvr6ekpKSpg4cSIikmhxYo4xhsbGRurr65k0aVLY+7lqYhKReSKyWURqReSOEOtvF5EPRWSdiCwRkSMD1vWKyFpnWuSmnIqiZDYdHR2MGjUqLZUDgIgwatSoiEdIro0gRMQD3Ad8FqgHVorIImPMhwGbrQFqjDFtInIT8BPgcmdduzFmhlvyKYqiBJKuysHPcP4+N0cQs4FaY8xWY0wX8DSwIHADY8xrxpg25+sKoMpFeRQlPdm6DPZ+lGgplDTETQVRCWwP+F7vLBuIG4C/BnzPF5FVIrJCRD4fagcRudHZZtXevXujFlhRUpIXboRl/zfRUihJwrJly7joooticqykcFKLyDVADfA/AhYfaYxpEJGjgKUi8oExpi5wP2PMQmAhQE1NjXY+UjKPnk5o2Q3e7UNvq6Q0vb29eDyeuJ7TzRFEA1Ad8L3KWXYIInIu8F1gvjGm07/cGNPgzLcCy4CTXZRVUVKTJueW8h52aykpxLZt25g6dSpXX30106ZN49JLL6WtrY2JEyfyne98h5kzZ/Lcc8/xt7/9jdNOO42ZM2dy2WWX0dLSAsDLL7/M1KlTmTlzJi+88ELM5HJzBLESmCIik7CK4QrgqsANRORk4EFgnjFmT8DyEUCbMaZTREYDc7AObEVRAvHW23nzTujtBk/4Me5KaH7w0gY+3NEU02NOH1/KXRcfN+g2mzdv5ve//z1z5szhK1/5Cvfffz8Ao0aNYvXq1ezbt49LLrmEv//97xQVFfHjH/+Yn/3sZ3z729/mq1/9KkuXLmXy5Mlcfvnlg54nElwbQRhjeoBbgFeAjcCzxpgNInK3iMx3NrsHKAaeCwpnnQasEpH3gdeAHwVFPymKAgEjB2OVhJKyVFdXM2fOHACuueYa/vGPfwD0PfBXrFjBhx9+yJw5c5gxYwaPPPIIn3zyCZs2bWLSpElMmTIFEeGaa66JmUyu+iCMMYuBxUHL7gz4fO4A+70FnOCmbIqSFjTV93/2NkD5hMTJkiYM9abvFsFhqP7vRUVFgE12++xnP8tTTz11yHZr1651TSatxaQoqYy3PvRnJeX49NNPefvttwF48sknOeOMMw5Zf+qpp7J8+XJqa2sBaG1t5aOPPmLq1Kls27aNujobwxOsQKJBFYSipDLeBhh5lP3cpAoilTn22GO57777mDZtGgcOHOCmm246ZH1FRQUPP/wwV155JSeeeCKnnXYamzZtIj8/n4ULF3LhhRcyc+ZMxowZEzOZkiLMVVGUYdLUABXToK1RI5lSnOzsbB5//PFDlm3btu2Q72effTYrV648bN958+axadOmmMukIwhFSWW8DVBWCaVV/SGvihIjVEEoSqrS0QSdXiittEpCk+VSlokTJ7J+/fpEi3EYqiAUJVXxjxjKquykJiYlxqiCUJRUxRugIEoroX0/dLUNvo+iRIAqCEVJVfwmpdJKqyRA/RBKTFEFoSipSlMDSBaUjLNKAjQXQokpqiAUJVXxNljl4MnWEUSKc/Dgwb7aS8mEKghFSVWa6vtHDqXj7Vwd1SnJQAqip6cnAdL0owpCUVIVb70NbwXIzoOiMRrqmqLccccd1NXVMWPGDGbNmsXcuXOZP38+06dPZ9u2bRx//PF929577718//vfB6Curo558+ZxyimnMHfu3Jgny2kmtaKkIsZA0w6YemH/sjJNlosJf70Ddn0Q22MecQKc/6MBV//oRz9i/fr1rF27lmXLlnHhhReyfv16Jk2adFg2dSA33ngjDzzwAFOmTOGdd97h5ptvZunSpTETWxWEoqQibY3Q02EzqP2UVWpv6jRh9uzZTJo0adBtWlpaeOutt7jsssv6lnV2dg6yR+SoglCUVMRvSioLaPNeWgW1S+3oIqh0tBIBg7zpxwt/iW+wNZp8Pl/f946ODgB8Ph/l5eVa7ltRlCD8zujSAAVRVgndrdBxMCEiKcOnpKSE5ubmkOvGjh3Lnj17aGxspLOzkz//+c8AlJaWMmnSJJ577jnA9ot4//33YyqXjiAUJRXpK7MR0PbdH+rqbYCCEfGXSRk2o0aNYs6cORx//PEUFBQwduzYvnU5OTnceeedzJ49m8rKSqZOndq37oknnuCmm27ihz/8Id3d3VxxxRWcdNJJMZNLFYSipCLeevDkQdHo/mWlAbkQRxwfej8laXnyyScHXHfrrbdy6623HrZ80qRJvPzyy67JpCYmRUlFvPU29yHQ1+D3R2ioqxIjVEEoSirS1NBvUvJTPBaysjVZTokZqiAUJRXxhlAQWR4oGa+5EMPEGJNoEVxlOH+fKghFSTV6e6B5x6ERTH7KKrVg3zDIz8+nsbExbZWEMYbGxkby8/Mj2k+d1IqSarTsAuM7NAfCT2kl1B/es1gZnKqqKurr69m7d2+iRXGN/Px8qqqqht4wAFUQipJqeEOEuPopq4IPXwSfD7LUQBAuOTk5Q2YuZyL6C1KUVKPJMSGFNDFVga8bWtP3TViJH6ogFCXV8PsYBjIxBW6jKFGgCkJRUg1vA+SVQn7Z4ev6GgepglCiRxWEoqQaTQ2hzUtwaLkNRYkSVRCKkmp4t4c2L4GtwZRdoCYmJSaoglCUVMM7yAhCxCoPNTEpMUAVhKKkEt0d0LYvdIirn7IqNTEpMUEVhKKkEn1lvgcYQYCt6qrlNpQYoApCUVIJ7yA5EH7KKqF5F/R0xUcmJW1RBaEoqUTfCGKQkgllVYCB5p1xEUlJX1RBKEoqEarVaDD+dWpmUqJEFYSipBLe7VA4GnIGqcrZlwuhkUxKdKiCUJRUoqlhcAc1aLkNJWa4qiBEZJ6IbBaRWhG5I8T620XkQxFZJyJLROTIgHXXi8gWZ7reTTkVJWXwNgwe4gqQVwz55WpiUqLGNQUhIh7gPuB8YDpwpYhMD9psDVBjjDkReB74ibPvSOAu4DPAbOAuERnhlqyKkjIMVmYjEM2FUGKAmyOI2UCtMWarMaYLeBpYELiBMeY1Y0yb83UF4A/N+BzwqjFmvzHmAPAqMM9FWRUl+enwQmfT0CYmsEpETUxKlLipICqB7QHf651lA3ED8NdI9hWRG0VklYisSudOUIoCBDQKCqMrWFmVlttQoiYpnNQicg1QA9wTyX7GmIXGmBpjTE1FRYU7wilKsuD3KZSGoyAqof0AdLW6K5OS1ripIBqAQG9albPsEETkXOC7wHxjTGck+ypKRuF1BtVhmZi07LcSPW4qiJXAFBGZJCK5wBXAosANRORk4EGsctgTsOoV4DwRGeE4p89zlilK5uJtAMmC4iOG3tavRNTMpERBtlsHNsb0iMgt2Ae7B3jIGLNBRO4GVhljFmFNSsXAcyIC8KkxZr4xZr+I/CdWyQDcbYzZ75asipISNDVAyXjwhHHbauMgJQa4piAAjDGLgcVBy+4M+HzuIPs+BDzknnSKkmJ468MzL4FVJIjmQihRkRROakVRwsBbH14OBEB2LhSP6fdbKMowUAWhKKmAMdC0I7wQVz+aLKdEiSoIRUkFWvdBb2dkCqK0Uk1MSlSoglCUVMBvKgrXxATOCKLejj4UZRioglCUVCCcVqPBlFZCd5tNmFOUYaAKQlFSgb4yG0NUcg3Eb45SM5MyTFRBKEoq0FQP2flQOCr8fTQXQokSVRCKkgp466F0PNiE0vDoaxykoa7K8FAFoSipgLchsggmgOKxkJWjJiZl2KiCUJRUoKkhvCqugWRlQek4NTEpw0YVhKIkO7090LwzsggmP6VV2jhIGTaqIBQl2WneCcYXWQ6En7JKreiqDBtVEIqS7DQNI8TVT1kVNO0Eny+2MikZwZAKQkQ88RBEyWBWPAC7NyRaiuTFbyIalompEnzd0Lpn6G0VJYhwRhBbROQeEZnuujRK5vHJ2/Dyd2CVVnYfEL+CGJaJyZ8LoWYmJXLCURAnAR8BvxORFSJyo4iUuiyXkim84bQhP6ix+gPS1AB5ZZA/jNtOFYQSBUMqCGNMszHmt8aY04HvAHcBO0XkERGZ7LqESvrS8B7ULQHxaDLXYHgbhmdegv5Rh+ZCKMMgLB+EiMwXkT8BPwd+ChwFvERQtzhFiYg37oX8cjjpCjj4qVYdHQjv9uGZlwAKRkBOoY4glGERlg8CWADcY4w52RjzM2PMbmPM88DL7oqnpC27PoDNi+HUm2HMdOhq0aqjA9EUxQhCxCoXVRDKMAinJ/WJxpiWUCuMMbfGWB4lU3jjXsgrhc98DT5+3S7zbofCkYmVK9noboe2xsjLbARSVqUmJmVYhKMgekTkX4DjgHz/QmPMV1yTSklv9m6GD1+EubdDQXl/fP/B7TDupISKlnT4y2REWmYjkLJK2LIxNvIoGUU4JqbHgCOAzwGvA1VAs5tCxZWuVlj7FOzfmmhJMoc3fwo5BXDqv9jv5RPsXB3Vh9MURQ6En9IqaNkNPV2xkUnJGMJREJONMd8DWo0xjwAXAp9xV6w40tkC/30TrHs20ZJkBvu3wgfPQc1XoMjpbVA4CrILNNQ1FH2NgqI0MWGgeUdMRFIyh3AURLczPygixwNlwBj3RIozJWNhwmnw4aJES5IZvPkzW4L69H/tXyYC5dXg/TRxciUrft/BcKOYoH/0oVVdlQgJR0EsFJERwPeARcCHwI9dlSreTJ8PezZAY12iJUlvDm6H95+CU66HkiMOXVdWrSOIUHi3Q1EFZOcN/xilmiynDI9wEuV+Z4w5YIx53RhzlDFmjDHmwXgIFzemXWznH76YWDnSneW/AATm3Hb4uvJq9UGEwtsQ3egB+kcQWtVViZBBFYSIHCsiPxWRvzjTvSJyTLyEixtlVVB5CmxUM5NrNO+C1Y/CjKtC29PLJ9hwzq7W+MuWzDQNo5NcMLlFNmFOTUxKhAyoIETkNGAZ0AIsBH4LtALLROTUuEgXT6ZdDDvW2IxeJfa89Svw9cAZ/xZ6fZkTyaRmpn6MsWahaBUEWDOT5kIoETLYCOJO4EpjzF3GmBeNMf9tjLkLuBJbjym9mDbfzje+lFg50pHWfbZa64lfhJGTQm9T7uRCqJmpnw6vzTCP1sQE1sykPgglQgZTEEcbY5YFLzTGvI6txZRejDoaxh6v0Uxu8PZ9NiP4jNsH3qYvWU5HcH00xSDE1U+Zth5VImcwBTFYMlx6GoqnzYft71h7uRIb2vbDu7+F474AFYO4r0qOgKxsHUEEEoscCD+lldBx0Ob9KEqYDFZqo1pEfhliuQAxGPMmIdPnw7L/smam2V9NtDTpwbsLoasZzvzm4NtleexDTH0Q/fiVZUxMTI6SaWqAimOjP56SEQymIL41yLpVsRYkKaiYCqOm2GgmVRDR09EEK+6HqRfB2OOG3r58go4gAmlqsL0ygnNGhkNg4yBVEEqYDKggnLIamYWIHUX84+fQ2thfCkIZHit/Zx2tQ40e/JRVw9ZlroqUUngboHS8HV1FizYOUoZBOJnUmcW0+WB6YfNfEi1JatPVCm//GiZ/FsafHN4+5ROgeacWlfPjrY+NeQmsokE0F0KJCFUQwYw7yT6oNJopOt572Ca+nTmYpTKI8mrAaMavn6b66Kq4BuLJgeKxGsmkRMRQmdQeERkgsylNEbGjiK3LoP1goqVJTbo7YPkvYdKZMCGCwr+BfSEyHZ8PmnbEJoLJT1mVKl8lIgZVEMaYXmxi3LAQkXkisllEakXkjhDrzxSR1SLSIyKXBq3rFZG1zhTf1/npC8DXDR+9EtfTpg1rHoOWXZGNHkCT5QJp2we9XdE1CgqmrFJNTEpEhGNiWi4ivxaRuSIy0z8NtZOIeID7gPOB6cCVIjI9aLNPgS8BT4Y4RLsxZoYzzQ9DzthRWQMl41KjNpOvF/5wAbyzMNGSWHq6rJO/+lSYODeyfUurANERBPQryViZmMBeX2+9LeGRLnz8BjwyH177r0RLkpaE03J0hjO/O2CZAc4eYr/ZQK0xZiuAiDwNLMCWC7cHMWabs84XnrhxIivL1mZa/ahNLMorTrREA3PwU/hkuZ1EEh+eu+5pa8a4+BdWnkjIzrUhnTqCiG2SnJ+yKuhph/YDqd/7+9MVsPSHsO1NkCyoXwmn/QvklyVasrQinHLf/xRiGko5gE2mC7zT64kswS5fRFaJyAoR+XyoDUTkRmebVXv37o3g0GEwbT70dEDtq7E9bqzx97AYfSws/ia8l8Do5N4e2050/Mkw+ZzhHaOsWsttQECjoBibmCC1HdU71sDjl8JDn7O9zef9CL70F+hug/V/TLR0aceQCkJExorI70Xkr8736SJyg/uicaQxpga4Cvi5iBwdvIExZqExpsYYU1NRURHjs58OhaOTP5qpcYudX/sCTD4XXrrN9thOBOv/CAe2Wd9DpKMHP9oXwuKth+z82L7plwZkU6cauzfA01fDwrOgYRWc+wO4bS2cepPtCDn2eFj9WKKlTDvC8UE8DLwCjHe+fwR8I4z9GoDqgO9VzrKwMMY0OPOt2LLjYQbTx4gsD0y9ELb8zUblJCuNtXZYXVoJlz9uI4devDn+b1M+H7x5r71Rjzl/+Mcpn2DNK77e2MmWivhzIIaraEORiiOIvR/Bc1+G38yx/oZ/+i7ctg7O+IbtcwH2Gp18LexYDbs+SKi46UY4CmK0MeZZwAdgjOkBwrl7VwJTRGSSiOQCV2Bblg6JiIwQkTzn82hgDgG+i7gxfb4tt1y3NO6nDpvGWhg12d4kOQVw5VPWQfzHr8Z39LPxRdj3Ecz9d+vDGS5l1TaCLNMLJsaiUVAwRWNsP/BUUBD7P4Y/fR3u/4yNJpz77/CNdfA/vg35pYdvf+IXwZOno4gYE86d3Coio7COaZxmQd6hdnIUyS3Y0cdG4FljzAYRuVtE5jvHmiUi9cBlwIMissHZfRqwSkTeB14DfmSMib+CmHimfTtP5mimfY6C8JNbBFc/azvkPf8V2Pyy+zIYA2/ca+tYTV8Q3bHKncZBmW5m8rqgILKybEZ1MpuYvPXWTPrrGtjwJzj1ZqsYzvme7Yo3EIUjYdpFsO6Z5B7xpxjhRDHdjn3zP1pElgMVwKWD72IxxiwGFgctuzPg80qs6Sl4v7eAE8I5h6tk58KxF8DmxTZ8Mzs30RIdSlebjRgaNeXQ5XklcM3z8OgCePZaO6qYfK57cmz+K+xeD194MPq6QYHJchPSr3FhWPR225IjsSqzEUiy9oVo3gVv/gze+4N94aj5iu0fUjou/GPMvM6aVjf9GU4I6xGlDMFQmdQVzjafB04HvgYcZ4xZ575oScK0+bbg3LY3Ei3J4ezfauejDvPf25HPNS/Yyp1PX23tt27JsPSHMGIiHB+Dm7IvWS6DI5madwIm9iMIcBREko0gVjwAv5hhizuedCXcugYuuCcy5QB2xF9+pA1PV2LCYD2p/xnYAPwK+ADbYW69MaY7XsIlBUefDbnFyRnN1Fhr54EmpkAKR8K1L8KISfDk5fDJ27E798HtsOhW+FWNVRLn/R/whDMgHYLcIigYmdnJcn05EC6MIEoroXlH8gQBtB+AV++E6llwy0qY/8v+l4RIycqyzuqPX7c+DCVqBhtBfAM7WjgNO3r4j7hIlGzk5MOU82DTX5LnpvLjD3ENNYLwUzQKrl9kHwxPXAb1UbbyaN4Fi78Fv5oJ7z8Fs/7ZhhtOuyi64waS6aGufhNQLHMg/JRVgq8HWvbE/tjDYd1z0NtpXzAG+x2Hy4yrbOLc2ieiP5YyqILoMsbshb5Q07z4iJSETJ9va+N88laiJTmUxjr74PeH+w1E8RirJIpGw2OX2GSjSGndB698F35xEqx6yN6It66BC34Sm4Y2gZRVZ/YIwl9Qz5URREDjoERjjDUHjZsB406MzTHLKq2/bc0TNnFTiYrBFESViPzSP4X4njlM/qxNWkq2aKbG2vDfukrHw/UvWd/EY18IP168/QAsuRt+fqLtDnfcF6wp4OJfuGMjh/7OculUMygSvA32/5RXEvtj97UeTQIFsXMt7P4AZl4b2+POvM6a0eqWxPa4GchgCuJbwHsBU/D3zCGv2L6VbHzJJoQlA8bAvi0D+x9CUV5tRxI5hTbCac+mgbftaIJlP4afn2TLZxzzObj5HfjCAzDyqOjlH1TOCbZ0Qtt+d8+TrDQ1uGNegoBkuSRwVK9+FLILYhPcEMgx86CoQp3VMUBbjobLtPk2fK5hFVTPTrQ09uHZcfDwENehGDnJjiT+cD48Oh++tBhGByiZrlZ497ew/Od29DD1IjjrP+CI42Mp/eD0hbp+kpltX73b3TEvAeSXQ05R4k1MXW3wwfM2b6agPLbH9uTYaKgV91tfS/GY2B4/g9COcuFyzOdsFuqHLyZaEstQEUyDMepouG6Rdbo/crGNQurugBW/sT6Gv99lS55/9TW44on4KgfQvhBuJMn5EUmOxkEfvgidTdYc5AYzr7PO+PcTVJcsTYhBXGKGUFAOR50FGxdhPvufNHX0sqe5g91Nnexr6aQg10NFSR4VxXmMLs6jIDcGjeYHI5wIpgEwxtBaNhnv/KcZ+6dL6fnt+QiQ176L7glnkP3Fx5AjT4utvCFo7+plX0sne1s6KcjxMLo4j5FFuXiSqLOcMYauXh/tXb20OZP93ENbdy8dzjKfMWSJkJWFnfdNkJUV8FnE+W4/i4BHhMLcbMoLcyjL6aa0fb87SXJ+kqBxUO97j9BbNolVPcewZ00D3b0+CnOzKcz1kJ/joTDXTgW5nr7ledlZSLi1qUZPsUX8Vj8Kp98a05pWxhi87d32t9vcxb6WTnzGUJqfQ2lBNmUFOc7nnMhkDuO87d29eNu7aWrvcebdFH38Mrl5eZxyzuWxrd1FGApCROYYY5YPtSwdMMbQ1NHDXufBv7upgz3Nzrypk+P2HMfNTa9yyZ0PsKbnyEGPVZTrYXSAwhhdkmvnxXlUlDhzZ3lh7jD0dGOtHdGUWzl6fYYDbfbH2thi5/ta/N/t58aAZZ091pdynHyLx3L/L1vNeH7acwNvf3QcuXUHqShZSkVJHmNK8hhTmseYknzGlOQ5y/IZU5rHqKJcsj2HDkI7unvZ22wf+vua7fn2Nnc6N1OnI5f93Np1eNhwlsDIwlzeoIA331rJK9vX9l+vQ+a5jCjMJSvr8BvCGENbVy/NHT00d3TT3NnT/9mZt3T00NTRv7zN/9Dv6qWjO0ARdPfS64ufs/wo2cHSPPjeawdZ/u4yygpzKC/Iobwwl7KCHMoDvzufywpyEBE6untp77by28kqtuBl53iLmHzwfe56dm3fMk+WUJqfQ0l+NqX52ZQ4n/vn9nNpQTal+QM/+Nq7etnd1GGn5k72+D8H3E8FTVtZnPU293RfwQO/ezfsayMCBTkBiiMn21EgVokU5XkoysumKNfOZxTN46xP7+LNJYvoHH8qhXkeivOyKczNtvM8D0W52XiyBJ/PcNB56O/z/37991Hf79b+lhtbO+nuDe83kevJstcsQGmU5tvv/YrE3v99D/2O7r6Hf1NHj507y4PPm00Py/LupiVnNJxzedjXMlzCeTL9CgjuIBdqWUqyr6WTmx9fze5m+0Pu6D7cCV2cl82Y0jy6Ck+jt+mXfLN6Exunz2NMaT5jS/IYXZJHW2f/27D9UXX1PSTr9rbwzsedHGgLnWNYmOshNzsya9+9vrc4ijFc8n+W4vMZWjp7CPUcy84SRhVb5TSqOI+jxxTbz0X+ZbNoKLiSnh64srmTc5s72dPcwd6mTvY0d7KtsZV3t+3nYAjZRWBUkX1gd3T3sq+5k+bO0KGF5YU5fUrxhKpyRhfn9j3wRxfn0tHtO0SJHNg4lrKuXbzz8X72tnTS1XP4/8WTJX1/h8+Y/of/ANciWPbiPPuwK86zD5fC3GxGFef1vb32v8lmH/pgCvGmmyWCMeAzhl5jMMbgc777fM48YJl/fa/P4PMZWrt6OdjWRVGDF9bAxKOmcMBT6rypdlG7t4WDbVbBRUOWQH5OHidnNbK6bjfZefnk52TR02uvX5Nz/YYKIMvxyCHKo6Pbx+6mjpDy5WVncURZPmNL8jlufClXFb+Hb7eHGRffxFMV1YwpzSPXk2WVcrdV1O1Bo7X2bh/tjgJv6w4YxTnbHGxrp7Wrh9bOXlo7e2jv7qWAat7NK2D367/jm90DP+oKcjx09/roCfGjyc6SQ17wph5RwuiA3619ycvDkyWHPND9D/qm9p5DHvje9m7q97f1LQt+4Od45JARSFlBDhNGFlKa74xMghTLxE9foOrNfbQu+FXMRw8wiIIQEX+CXIWI3B6wqhRw2X4SP4pysxGBk6rKGVva/3Y8tjSfsaX2rbkoL+AyPXIGc5reYs4ZkXdM6+719b3dB75h72vppKc3suioEzbu5UDeJBYcZauwlxXkMMoZofgVwuji3L63y2jp7OllX0sXe5y3wD3Nnext6mCv81DPd0xEfWa2klwqivMZXZLLqKK8iBUgTxxDZfNOln/97L6RXaACOXTehSdL7MMq7/C33+IQb8WFOZ6Qo4+E4/HBGrjhwjNtQEEQPb0+mjp6ONjWxcH2brxt3Rxs7wLsgy4vx0NBjlVedp5l57ke8rM95HgEWXsAXnyeZV87JuQ5fD5DS9fho67mvlFXd9C6HvKyszhj8mh775TkO/dPHmNK8ynNz+7/DfZ2w89egWPmMe/UGa5dxl6foa2rB8/iZVzy4bNM+/L9NJlCWjt7+hRJW1cPLZ09tHb2kOPJchRB/4O/oiQvZvdPKIwxdHT78Lbbl6+yghzycyIwSfX2wF8fgHEnUXR8FCX2B2GwEUQuUOxsExiQ3USYxfpSgYJcD898LQJ7+7T5tnPb3k0wZlpE58rx2DepI8ryI5QyCF8vrGtg7MwL+cF58XEg52V7qCwvoLK8IC7no6watlvzg4h9qyoryOHoiiRu/xoL/L6B0vEhV2d7shhZlMvIoigKR/r9G00NIRVElmNuKs3PAWL8//7oFWjd655z2sG+MOTAZ74M6x7luP2v2gKASYSIUOCMSofFhhdsgMnlj7syeoDBw1xfB14XkYeNMZ+4cvZUZNrFttTEh4siVhAxw1tvyxNEGuKaSpRPsGG8nc3uJIwlK97ttm9DtouFC8oSmE29+lEoPsLd6sKBjD/Z6Tb3aNIpiKjw+WyJ/THT4dgLXTtNOOP+PBFZKCJ/E5Gl/sk1iZKdkiOg+jOJzaqOJsQ1VShPnkimuOJGo6Bg/COIeCuIph22x/vJV8emsGM4iNjRyo416dVtbuMi2Lc5+gZdQxDOkZ8D1gD/G5tN7Z8yl+nzbf+DxrrEnD8TFESZ0zjoYIaV/fY2uJck5ye30FbMjXfjoLVPgPHBydfE97wnXJZe3eb6GnRNtqVvXCQcBdFjjPmNMeZdY8x7/slVqZKdaRfbeaJGEY21kFea3hmimZgsZ4zTi9rlEQTEPxfC57MP6Ilz3S/VEkzhSHvPpku3uY9etjWs5v579A26hiAcBfGSiNwsIuNEZKR/clWqZKd8grVtJqpHhL9In0uOqaSgaAx4cjNrBNFxELpb3R9BgFVC8TQxbXvTlk6ZeX38zhnIzOvs9d3058ScP1YYA2/cY59BJ1zm+unCURDXY01Kb9FfqC/KpgJpwLT5sGN1YmzkwX2o05GsLKf7WQaNIPoaBcVjBBHnchurH7UVamPZNyQSJs51us2leIm5ra9Bw3u2Hasnx/XTDakgjDGTQkxxHiMmIdMX2PnGl+J73u52+9BM5wgmP5nWF8LvE4iXianDa6PE3KZtv71PTrwccuIUJh1MVpYtK/7xG6ndbe71e2yQwYyr4nK6IRWEiFwXaoqHcEnNqKNhzHHx90Ps/xgwsem+lexkWmc5/98aLxMTxMcP8YHTNe7kGPd9iJQZV9tuc2seT6wcw2Xbcvj0LZhzm7th0AGEY2KaFTDNBb4PzHdRptRh+nz4dAU0747fOfuK9KW5iQmsSaBld3o4FsPB2wBZ2VA81v1zxatxkBtd44ZL6Xjb/Gvtk6nZbe6Nn1jfnMtJhoGEY2L614Dpq9gaTGmezhom0+YDBjbF0czUF+KaASMIf1XXeIdjJoqmBigZ73pkChC/xkE71tiQ8Fh3jRsuM69NzW5z21fC1mVw+r/G1Uw3nAyLVuDw/PxMZMw0+yYfz2imxjooGZcZ2cV9yXIZksjvrY+PeQnsbwhxX/m61TVuuKRqt7k37rG5K3HOBg/HB/GSiCxypr8Am4E/uS9aCiBiRxHb/hG/9piNGRDB5CeJ+kLEBW+9u30gAvHk2KoAboa6drXC+j/CcZ+Pfde44eLJsQ7ej16Or2k4Gna+D1tegdNutu2P40g4I4h7gZ86038BZxpj7nBVqlRi+nwwvbD5r/E5374tmWFeAmszlqzMcFT7fLYURTxCXP2UuZwL4e8al2jndDAnX5ta3ebeuBfyymD2jXE/dTg+iNeBTdiKriOALreFSinGzbB9fj992/1zte2H9v2ZEeIKzlvu+MwYQbTuBV93fBVEaaW7JqbVj8LIo+HI0907x3AYPQUmnA5rHmPIxheJZs9GGyn5mRttHkmcCcfE9EXgXeAy4IvAOyKSJAbFJEAEqmps8orb+Gs/ZYqJCTIn1NX/Jh8vExP0jyDceEju22JfmmZem5wZ/zOvtebaeLzYRcObP4WcIjj15oScPhwT03eBWcaY640x1wGzge+5K1aKUVljNX1Hk7vnyaQQVz+ZkiznDzeNt4mpp8Md/9nqR0E8cFJ8EroiZvoCW88smZ3VjXXWhzPrBltPKgGEoyCyjDF7Ar43hrlf5lA1CzA2pM9NGmttnPyIwfthpxXlE6wZJBXj1iMhnmU2/PQ1DoqxH6K329r3j5kHJXHI6RgOuUVwwqWw4b9tRnky8ubPbD2y0/81YSKE86B/WUReEZEviciXgL8AcfLIpgiVTnvuBpdLVDXWwoiJcanBkjSUV9sggOadiZbEXbz1Nhy0YET8zulWLsRHL8ela1zUnHwt9LTDB88nWpLDOfAJrHsaTvlSQqs2h+Ok/hbwIHCiMy00xnzbbcFSisKR1hlX77KCyIQifcH4Q13T3Q/R5ORAxNNe31duI8YjiNWP2jyLeHWNGy7jT4axJ1hndbKx/Oc2gu/0WxMqxoAKQkQmi8gcAGPMC8aY240xtwN7RSRD4iwjoGqWVRBuRUX4fLC/LvMURHmGNA7yxqGTXDBFFdaEEUsTk7cBav9ucw3i1TVuuIhYZ3WydZtr2mHrRc24On6JkwMw2Aji50Aor6vXWacEUlUDrXvce9NtarAOxUxTEP6HZro7qpsa4lPFNZCsLJtrEksT09onE9M1brj4u82teCDRkvSz/Jfg64Uz/i3RkgyqIMYaYw5Tq86yia5JlKpUnmLnbpmZMjGCCWzdmaIK8KbxCKKnC5p3JeZtMZaNg3w+a65JRNe44VI4EmZ/FdY+bstZJJqWPfDew3DSFUkRjDKYgigfZF2CironMWOPh+x8FxVEBuZA+En3UNfmnYCJv4kJnMZBMRpBbHsjsV3jhstn/xNOvAKW/tC+vSeSt39tS6OfcXti5XAYTEGsEpGvBi8UkX/GdpVTAsnOhXEnuRfJ1FgLucW2fk6mke7Jcn2NghIwgiirtDZvX2/0x0p017jhkpUFC+6D4y6BV7+XOHNT235Y+Xsrx+jkeBEcTEF8A/iyiCwTkZ860+vADcBt4RxcROaJyGYRqRWRw+o3iciZIrJaRHqCs7NF5HoR2eJMqfFKUlljC2v1uFCNJBP6UA9E+QT3Mn6TAW8CkuT8lFbaMOKWKAvXJUPXuGjwZMMlC2HqRfDyd2DVQ/GXYcVvoKsFzvxm/M89AAMqCGPMbmPM6cAPgG3O9ANjzGnGmF1DHVhEPMB9wPnAdOBKEZketNmnwJeAJ4P2HQncBXwGm7l9l4jEMUB8mFTVWEfy7vWxP/a+LZlpXgIom2Cva+veREviDokos+GnLEahruuehd6u5M99GAxPDlz6B5vg9+d/i2/nuQ4vvPMgTLvYthFIEsLJg3jNGPMrZ1oawbFnA7XGmK3GmC7gaWBB0LG3GWPWAb6gfT8HvGqM2W+MOQC8CsyL4NyJoarGzmNdl6mn04Z5ZqqC6OsLkaZmpqYGW/AxzqWcgdgoiMCucUecEBOxEkZ2Llz2CBx9Nrx4i1V88eDdhdDphTO/FZ/zhYmbJTMqgcA7ut5Z5va+iaOs2rYEjLWjuq8PdYZUcQ2mL1kuTSOZEpED4aev3EYUjuodq2HPhtQePQSSkw9XPAkTz4A/fQ02uNz+prMF3r4fpnzO+jGTiCTPZBkcEbkRuBFgwoQJCZYGp7LrLKhfGdvj9oW4Zmh+Yt8IIl0VRBwbBQWTX2aDHzb+Gbrbh3eMj9+wZUJOSKMizzkFcNUz8Pj/hD/+s00onHph7M9jDCz/hS3jn2SjB3BXQTQA1QHfq5xl4e57VtC+y4I3MsYsBBYC1NTUJIcHs+oU2PwX67SLVQXGvj7UGWpiyi+zDVPS0cTU3WH/v5PmJub8IjDhNKh9FbavGP5xZn8tIf0KXCW3CK56Fh77Ajx7vR1VHHNebI5tDGx5FV77oQ1sOfZCqJ4Vm2PHEDcVxEpgiohMwj7wrwDCrf37CvBfAY7p84D/iL2ILlDp90OshikxqkXTWAvFYyG/NDbHS0XSNdT107dtwbijzkqcDFc/Z7OfoyHLExtZko38Urjmj/DoAnjmGrjqaeufGC7GwMev25yL+pW2+ObnH7AZ3UmIaz4IY0wPcAv2Yb8ReNYYs0FE7haR+QAiMktE6rHNiB4UkQ3OvvuB/8QqmZXA3c6y5KdyJiCxNTNlYpG+YNI1Wa5uiTVfTDwjcTKI2Ad8NFM6U1AO1/7JdqJ76irbg344fPIWPHyRVTZNO+HiX8Atq2DGlUlbt8pVqYwxi4HFQcvuDPi8Ems+CrXvQ0ACgpGjJK/EhqnFMmGusRamXhC746Ui5RPgk+WJliL21C6BCadac4aSvBSOhOtehIcvhCe+CNe+YP9v4VD/njUl1S21loDz74FTrofsPHdljgHa+McNKk+xoa6xSOxqPwBt+zI3gslPeTV0NkH7wURLEjuadsCeD+HocxItiRIORaPhukVQOg4ev9Q++Adj5zp48gr43dnWz3DeD+HWtba/dAooB1AF4Q5Vs+yDff/W6I+VyTWYAknHvhB1TlrRZFUQKUPJWLj+JSgaBY9/AXasPXybPZusU/vBufDpW3D2/4bb3red4XIL4y5yNKiCcAN/wlws/BCZHsHkJx2T5WqXWJPD2OMTLYkSCaXjrZLIK4XHPg+7N9jljXXwwo1w/6m2J8aZ34bb1tnw1byShIo8XJLTM5LqVEy1seX1q2zZ3mhorLXN30dMjIloKUtZmjUO8vXC1tfgmPMzs75WqlM+wSqJP1wAj8yHKefBumdswMGcW+H02+woI8VRBeEGWR7bzjAWjurGWlsXPjs3+mOlMkWjbTJWupiYdqy1Zkg1L6UuIydZJfHwBbD+eZh9o23yUzI20ZLFDFUQblFVA2/9ymanRlPdUkNcLSK2HEW6jCDqlgACR/1ToiVRomH0ZPj6csBA8ZhESxNz1AfhFpU14OuxkQzDJVP7UA9EOiXL1S6B8TPSwgyR8RRXpKVyAFUQ7tFX2TUKM1PzTuhuUwXhp3xCejip2w/aAAYNb1WSHFUQblFyhA3NjCaSKVP7UA9EWbXNCelqS7Qk0fHx67ZJj/oflCRHFYSbVJ4ydDLNYGiI66GUO5FM0Ta3STS1S2yIZFXyFWdTlEBUQbhJVY3tYdA8zHaOjXWQUwgl42IrV6qSDn0hjLEJcpPOtB3MFCWJUQXhJv43xOH6IfZtsT0gsvTfBKRHsty+LdbRruYlJQXQJ4+bjDsJsrKH32GuUUNcD6FknL2eqRzqWrfEztVBraQAqiDcJKcAxh43vBFETxcc/EQVRCBZHlvmIJVDXWuX2P/piCMTLYmiDIkqCLepmgUNa2xphUg48LFt4pLpVVyDKUvhUNfuDttLQEcPSoqgCsJtKmugqxn2bo5sP41gCk35hNQdQXz6lu0ep/4HJUVQBeE2w02Y61MQR8dWnlSnvNomEPZ2J1qSyKlNgu5xihIBqiDcZuTRkF8euaO6sRaKKmy7Q6WfsmpremtqSLQkkVO3FCacpt3jlJRBFYTbZGU5CXMRKggt0heaVA119XePU/OSkkKogogHVTWwdyN0toS/T2OtmpdCkaqd5fzd49RBraQQqiDiQdUsaxbZsSa87Tu80LpHRxChKKuy81QbQdQugeIjbNizoqQIqiDiQeUpdh5u4b4+B7WGuB5Gdp590KZSspy/e9zRZ2v3OCWlUAURDwpHwsijoCHMwn2NdXauI4jQlFenVj2mHWu0e5ySkqiCiBdVs+wIwpiht22sBcmyLQ2Vw0m1vhC12j1OSU1UQcSLyhpo2R1eqep9W+xDMDvPfblSkbJqG+bq8yVakvCo0+5xSmqiCiJeVDl+iHAS5rRI3+CUV0Nvl1W4yU77QRviPPncREuiKBGjCiJejD0BPHlD50MYY30QqiAGpszfOCgFzEz+7nEa3qqkIKog4kV2ri3/PZSjunkXdLeqghiMvmS5FHBU93WPq0m0JIoSMaog4klVjY1oGayOkPahHppUSZbT7nFKiqMKIp5U1UBPB+zeMPA2WsV1aPKKoWBE8o8gtHuckuKogognlWFUdm2sg+wCKK2Mj0ypSll18oe61v7dztX/oKQoqiDiSfkEW6F1MEe19qEOj1ToC1Gn3eOU1EafQvFExEmYG2wEoUX6wsKfLBdO4mEi6O6Abct19KCkNKog4k3lKdYR3X7g8HW93XBgm/ofwqGs2kZ7hbqOyUBf9zjNf1BSF1UQ8aavw1yIcNcD22zMvBbpG5pkD3Xt6x43J9GSKMqwUQURb8bPBATqQygIjWAKn2QPddXucUoaoAoi3uSXQsXU0JFM2oc6fMqdbOpkjGTS7nFKmqAKIhFUOS1Igx2s+7ZAwUhbHlwZnIIRkFOUnCMI7R6npAmuKggRmScim0WkVkTuCLE+T0Secda/IyITneUTRaRdRNY60wNuyhl3qmZB+37Yv/XQ5Y11MFr9D2EhYv0QyeiDqP27do9T0gLXFISIeID7gPOB6cCVIjI9aLMbgAPGmMnA/wN+HLCuzhgzw5m+7pacCaFyAEe1VnGNjPIJyacgfL1Qp93jlPTAzRHEbKDWGLPVGNMFPA0sCNpmAfCI8/l54ByRDLirxkyz5pHAfIjOZmjZpf6HSCirTj4T04410HFQ/Q9KWuCmgqgEAu/eemdZyG2MMT2AF/B3VZkkImtE5HURmRvqBCJyo4isEpFVe/fuja30bpLlgfEnH9qjWvtQR055tc2D6GxJtCT9aPc4JY1IVif1TmCCMeZk4HbgSREpDd7IGLPQGFNjjKmpqKiIu5BRUVUDuz6wGbegfaiHQzKGutYtscpfu8cpaYCbCqIBqA74XuUsC7mNiGQDZUCjMabTGNMIYIx5D6gDjnFR1vhTVQO+bqskwBlBiPahjoRkC3Xt6x6n5iUlPXBTQawEpojIJBHJBa4AFgVtswi43vl8KbDUGGNEpMJxciMiRwFTgKCQnxTH76j2m5n2bbFvxDkFiZMp1egbQSSJo1q7xylpRrZbBzbG9IjILcArgAd4yBizQUTuBlYZYxYBvwceE5FaYD9WiQCcCdwtIt2AD/i6MWa/W7ImhNJxUFrVnzDXWAuj1bwUEcVjbTmLZBlB1P5du8cpaYVrCgLAGLMYWBy07M6Azx3AZSH2+yPwRzdlSwoCE+Ya66B6dqIlSi2ysmzfjGTwQRgDtdo9TkkvktVJnRlU1sDBT2D3euhqVgf1cEiWXIh9H0FTvfoflLRCFUQiqZpl5+8/beeqICKnPEk6y9UusXP1PyhphCqIRDLuJBAPfPC8/a4KInLKJtgEw57OxMpRt8TmsGj3OCWNUAWRSHILbb2ell3gyYOyqkRLlHr4+0J46xMng797nJqXlDRDFUSi8ZuZRh1tM6yVyEiGZDl/9zg1LylphiqIROMPidQaTMOjr7NcAhWEdo9T0hRXw1yVMPAnzKn/YXiUVoJkwZIfwNu/TowMB7dr9zglLVEFkWhGT4Gz/gOO/5+JliQ18eTAP/2v/pIliaBiKsy6IXHnVxSXUAWRaETgrMN6KSmRcOa3Ei2BoqQl6oNQFEVRQqIKQlEURQmJKghFURQlJKogFEVRlJCoglAURVFCogpCURRFCYkqCEVRFCUkqiAURVGUkIgxJtEyxAQR2Qt8EsUhRgP7YiSOG6h80aHyRYfKFx3JLN+RxpiKUCvSRkFEi4isMsYkbTNhlS86VL7oUPmiI9nlGwg1MSmKoighUQWhKIqihEQVRD8LEy3AEKh80aHyRYfKFx3JLl9I1AehKIqihERHEIqiKEpIVEEoiqIoIckoBSEi80Rks4jUishhXXpEJE9EnnHWvyMiE+MoW7WIvCYiH4rIBhG5LcQ2Z4mIV0TWOtOd8ZIvQIZtIvKBc/5VIdaLiPzSuYbrRGRmHGU7NuDarBWRJhH5RtA2cb2GIvKQiOwRkfUBy0aKyKsissWZjxhg3+udbbaIyPVxlO8eEdnk/P/+JCLlA+w76G/BRfm+LyINAf/DCwbYd9D73UX5ngmQbZuIrB1gX9evX9QYYzJiAjxAHXAUkAu8D0wP2uZm4AHn8xXAM3GUbxww0/lcAnwUQr6zgD8n+DpuA0YPsv4C4K+AAKcC7yTw/70LmwSUsGsInAnMBNYHLPsJcIfz+Q7gxyH2GwlsdeYjnM8j4iTfeUC28/nHoeQL57fgonzfB74Zxv9/0PvdLfmC1v8UuDNR1y/aKZNGELOBWmPMVmNMF/A0sCBomwXAI87n54FzRETiIZwxZqcxZrXzuRnYCFTG49wxZgHwqLGsAMpFZFwC5DgHqDPGRJNdHzXGmDeA/UGLA39njwCfD7Hr54BXjTH7jTEHgFeBefGQzxjzN2NMj/N1BVAV6/OGywDXLxzCud+jZjD5nGfHF4GnYn3eeJFJCqIS2B7wvZ7DH8B92zg3iBcYFRfpAnBMWycD74RYfZqIvC8ifxWR4+IrGQAG+JuIvCciN4ZYH851jgdXMPCNmehrONYYs9P5vAsYG2KbZLmOX8GOCEMx1G/BTW5xTGAPDWCiS4brNxfYbYzZMsD6RF6/sMgkBZESiEgx8EfgG8aYpqDVq7Emk5OAXwH/HWfxAM4wxswEzgf+RUTOTIAMgyIiucB84LkQq5PhGvZhrK0hKWPNReS7QA/wxACbJOq38BvgaGAGsBNrxklGrmTw0UPS30uZpCAagOqA71XOspDbiEg2UAY0xkU6e84crHJ4whjzQvB6Y0yTMabF+bwYyBGR0fGSzzlvgzPfA/wJO5QPJJzr7DbnA6uNMbuDVyTDNQR2+81uznxPiG0Seh1F5EvARcDVjhI7jDB+C65gjNltjOk1xviA3w5w3kRfv2zgEuCZgbZJ1PWLhExSECuBKSIyyXnDvAJYFLTNIsAfLXIpsHSgmyPWOPbK3wMbjTE/G2CbI/w+ERGZjf3/xVOBFYlIif8z1pm5PmizRcB1TjTTqYA3wJwSLwZ8c0v0NXQI/J1dD7wYYptXgPNEZIRjQjnPWeY6IjIP+DYw3xjTNsA24fwW3JIv0Kf1hQHOG8797ibnApuMMfWhViby+kVEor3k8ZywETYfYaMbvussuxt7IwDkY80StcC7wFFxlO0MrKlhHbDWmS4Avg583dnmFmADNiJjBXB6nK/fUc6533fk8F/DQBkFuM+5xh8ANXGWsQj7wC8LWJawa4hVVDuBbqwd/AasX2sJsAX4OzDS2bYG+F3Avl9xfou1wJfjKF8t1n7v/x36I/vGA4sH+y3ESb7HnN/WOuxDf1ywfM73w+73eMjnLH/Y/5sL2Dbu1y/aSUttKIqiKCHJJBOToiiKEgGqIBRFUZSQqIJQFEVRQqIKQlEURQmJKghFURQlJKogFEVRlJCoglAURVFC8v8BWGRVhjWaox0AAAAASUVORK5CYII=\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "#if __name__ == \"__main__\":\n",
+    "path = \"datax.csv\"\n",
+    "main(path)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "530f2e46",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "a6300081",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.9.5"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}