From 5cf0f6e478fb43cad88394e557d59fef4dfbd25b Mon Sep 17 00:00:00 2001 From: alolika bhowmik <152315710+alo7lika@users.noreply.github.com> Date: Fri, 25 Oct 2024 17:07:04 +0530 Subject: [PATCH] Add files via upload --- ...Prediction Model using Deep Learning.ipynb | 568 ++++++++++++++++++ 1 file changed, 568 insertions(+) create mode 100644 Traffic Accident Prediction Model using Deep Learning /Model/Traffic Accident Prediction Model using Deep Learning.ipynb diff --git a/Traffic Accident Prediction Model using Deep Learning /Model/Traffic Accident Prediction Model using Deep Learning.ipynb b/Traffic Accident Prediction Model using Deep Learning /Model/Traffic Accident Prediction Model using Deep Learning.ipynb new file mode 100644 index 000000000..bfe7600f2 --- /dev/null +++ b/Traffic Accident Prediction Model using Deep Learning /Model/Traffic Accident Prediction Model using Deep Learning.ipynb @@ -0,0 +1,568 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 2, + "id": "792c2779-a4f3-4f53-8d94-6ee1dcdf26d4", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Requirement already satisfied: pandas in c:\\users\\asus\\anaconda3\\lib\\site-packages (2.1.4)\n", + "Requirement already satisfied: numpy in c:\\users\\asus\\anaconda3\\lib\\site-packages (1.26.4)\n", + "Requirement already satisfied: tensorflow in c:\\users\\asus\\anaconda3\\lib\\site-packages (2.16.2)\n", + "Requirement already satisfied: scikit-learn in c:\\users\\asus\\anaconda3\\lib\\site-packages (1.2.2)\n", + "Requirement already satisfied: python-dateutil>=2.8.2 in c:\\users\\asus\\anaconda3\\lib\\site-packages (from pandas) (2.8.2)\n", + "Requirement already satisfied: pytz>=2020.1 in c:\\users\\asus\\anaconda3\\lib\\site-packages (from pandas) (2023.3.post1)\n", + "Requirement already satisfied: tzdata>=2022.1 in c:\\users\\asus\\anaconda3\\lib\\site-packages (from pandas) (2023.3)\n", + "Requirement already satisfied: tensorflow-intel==2.16.2 in c:\\users\\asus\\anaconda3\\lib\\site-packages (from tensorflow) (2.16.2)\n", + "Requirement already satisfied: absl-py>=1.0.0 in c:\\users\\asus\\anaconda3\\lib\\site-packages (from tensorflow-intel==2.16.2->tensorflow) (2.1.0)\n", + "Requirement already satisfied: astunparse>=1.6.0 in c:\\users\\asus\\anaconda3\\lib\\site-packages (from tensorflow-intel==2.16.2->tensorflow) (1.6.3)\n", + "Requirement already satisfied: flatbuffers>=23.5.26 in c:\\users\\asus\\anaconda3\\lib\\site-packages (from tensorflow-intel==2.16.2->tensorflow) (24.3.25)\n", + "Requirement already satisfied: gast!=0.5.0,!=0.5.1,!=0.5.2,>=0.2.1 in c:\\users\\asus\\anaconda3\\lib\\site-packages (from tensorflow-intel==2.16.2->tensorflow) (0.6.0)\n", + "Requirement already satisfied: google-pasta>=0.1.1 in c:\\users\\asus\\anaconda3\\lib\\site-packages (from tensorflow-intel==2.16.2->tensorflow) (0.2.0)\n", + "Requirement already satisfied: h5py>=3.10.0 in c:\\users\\asus\\anaconda3\\lib\\site-packages (from tensorflow-intel==2.16.2->tensorflow) (3.11.0)\n", + "Requirement already satisfied: libclang>=13.0.0 in c:\\users\\asus\\anaconda3\\lib\\site-packages (from tensorflow-intel==2.16.2->tensorflow) (18.1.1)\n", + "Requirement already satisfied: ml-dtypes~=0.3.1 in c:\\users\\asus\\anaconda3\\lib\\site-packages (from tensorflow-intel==2.16.2->tensorflow) (0.3.2)\n", + "Requirement already satisfied: opt-einsum>=2.3.2 in c:\\users\\asus\\anaconda3\\lib\\site-packages (from tensorflow-intel==2.16.2->tensorflow) (3.3.0)\n", + "Requirement already satisfied: packaging in c:\\users\\asus\\anaconda3\\lib\\site-packages (from tensorflow-intel==2.16.2->tensorflow) (23.1)\n", + "Requirement already satisfied: protobuf!=4.21.0,!=4.21.1,!=4.21.2,!=4.21.3,!=4.21.4,!=4.21.5,<5.0.0dev,>=3.20.3 in c:\\users\\asus\\anaconda3\\lib\\site-packages (from tensorflow-intel==2.16.2->tensorflow) (4.25.5)\n", + "Requirement already satisfied: requests<3,>=2.21.0 in c:\\users\\asus\\anaconda3\\lib\\site-packages (from tensorflow-intel==2.16.2->tensorflow) (2.31.0)\n", + "Requirement already satisfied: setuptools in c:\\users\\asus\\anaconda3\\lib\\site-packages (from tensorflow-intel==2.16.2->tensorflow) (68.2.2)\n", + "Requirement already satisfied: six>=1.12.0 in c:\\users\\asus\\anaconda3\\lib\\site-packages (from tensorflow-intel==2.16.2->tensorflow) (1.16.0)\n", + "Requirement already satisfied: termcolor>=1.1.0 in c:\\users\\asus\\anaconda3\\lib\\site-packages (from tensorflow-intel==2.16.2->tensorflow) (2.4.0)\n", + "Requirement already satisfied: typing-extensions>=3.6.6 in c:\\users\\asus\\anaconda3\\lib\\site-packages (from tensorflow-intel==2.16.2->tensorflow) (4.9.0)\n", + "Requirement already satisfied: wrapt>=1.11.0 in c:\\users\\asus\\anaconda3\\lib\\site-packages (from tensorflow-intel==2.16.2->tensorflow) (1.14.1)\n", + "Requirement already satisfied: grpcio<2.0,>=1.24.3 in c:\\users\\asus\\anaconda3\\lib\\site-packages (from tensorflow-intel==2.16.2->tensorflow) (1.66.2)\n", + "Requirement already satisfied: tensorboard<2.17,>=2.16 in c:\\users\\asus\\anaconda3\\lib\\site-packages (from tensorflow-intel==2.16.2->tensorflow) (2.16.2)\n", + "Requirement already satisfied: keras>=3.0.0 in c:\\users\\asus\\anaconda3\\lib\\site-packages (from tensorflow-intel==2.16.2->tensorflow) (3.4.1)\n", + "Requirement already satisfied: tensorflow-io-gcs-filesystem>=0.23.1 in c:\\users\\asus\\anaconda3\\lib\\site-packages (from tensorflow-intel==2.16.2->tensorflow) (0.31.0)\n", + "Requirement already satisfied: scipy>=1.3.2 in c:\\users\\asus\\anaconda3\\lib\\site-packages (from scikit-learn) (1.11.4)\n", + "Requirement already satisfied: joblib>=1.1.1 in c:\\users\\asus\\anaconda3\\lib\\site-packages (from scikit-learn) (1.2.0)\n", + "Requirement already satisfied: threadpoolctl>=2.0.0 in c:\\users\\asus\\anaconda3\\lib\\site-packages (from scikit-learn) (2.2.0)\n", + "Requirement already satisfied: wheel<1.0,>=0.23.0 in c:\\users\\asus\\anaconda3\\lib\\site-packages (from astunparse>=1.6.0->tensorflow-intel==2.16.2->tensorflow) (0.41.2)\n", + "Requirement already satisfied: rich in c:\\users\\asus\\anaconda3\\lib\\site-packages (from keras>=3.0.0->tensorflow-intel==2.16.2->tensorflow) (13.3.5)\n", + "Requirement already satisfied: namex in c:\\users\\asus\\anaconda3\\lib\\site-packages (from keras>=3.0.0->tensorflow-intel==2.16.2->tensorflow) (0.0.8)\n", + "Requirement already satisfied: optree in c:\\users\\asus\\anaconda3\\lib\\site-packages (from keras>=3.0.0->tensorflow-intel==2.16.2->tensorflow) (0.11.0)\n", + "Requirement already satisfied: charset-normalizer<4,>=2 in c:\\users\\asus\\anaconda3\\lib\\site-packages (from requests<3,>=2.21.0->tensorflow-intel==2.16.2->tensorflow) (2.0.4)\n", + "Requirement already satisfied: idna<4,>=2.5 in c:\\users\\asus\\anaconda3\\lib\\site-packages (from requests<3,>=2.21.0->tensorflow-intel==2.16.2->tensorflow) (3.4)\n", + "Requirement already satisfied: urllib3<3,>=1.21.1 in c:\\users\\asus\\anaconda3\\lib\\site-packages (from requests<3,>=2.21.0->tensorflow-intel==2.16.2->tensorflow) (2.0.7)\n", + "Requirement already satisfied: certifi>=2017.4.17 in c:\\users\\asus\\anaconda3\\lib\\site-packages (from requests<3,>=2.21.0->tensorflow-intel==2.16.2->tensorflow) (2024.2.2)\n", + "Requirement already satisfied: markdown>=2.6.8 in c:\\users\\asus\\anaconda3\\lib\\site-packages (from tensorboard<2.17,>=2.16->tensorflow-intel==2.16.2->tensorflow) (3.4.1)\n", + "Requirement already satisfied: tensorboard-data-server<0.8.0,>=0.7.0 in c:\\users\\asus\\anaconda3\\lib\\site-packages (from tensorboard<2.17,>=2.16->tensorflow-intel==2.16.2->tensorflow) (0.7.2)\n", + "Requirement already satisfied: werkzeug>=1.0.1 in c:\\users\\asus\\anaconda3\\lib\\site-packages (from tensorboard<2.17,>=2.16->tensorflow-intel==2.16.2->tensorflow) (2.2.3)\n", + "Requirement already satisfied: MarkupSafe>=2.1.1 in c:\\users\\asus\\anaconda3\\lib\\site-packages (from werkzeug>=1.0.1->tensorboard<2.17,>=2.16->tensorflow-intel==2.16.2->tensorflow) (2.1.3)\n", + "Requirement already satisfied: markdown-it-py<3.0.0,>=2.2.0 in c:\\users\\asus\\anaconda3\\lib\\site-packages (from rich->keras>=3.0.0->tensorflow-intel==2.16.2->tensorflow) (2.2.0)\n", + "Requirement already satisfied: pygments<3.0.0,>=2.13.0 in c:\\users\\asus\\anaconda3\\lib\\site-packages (from rich->keras>=3.0.0->tensorflow-intel==2.16.2->tensorflow) (2.15.1)\n", + "Requirement already satisfied: mdurl~=0.1 in c:\\users\\asus\\anaconda3\\lib\\site-packages (from markdown-it-py<3.0.0,>=2.2.0->rich->keras>=3.0.0->tensorflow-intel==2.16.2->tensorflow) (0.1.0)\n", + "Note: you may need to restart the kernel to use updated packages.\n" + ] + } + ], + "source": [ + "pip install pandas numpy tensorflow scikit-learn" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "dc60e63c-dc53-4c40-a84f-01872990aa2a", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " date traffic_volume weather_condition road_type accident_occurred\n", + "0 2023-01-01 1226 fog urban road 0\n", + "1 2023-01-02 1559 snow rural road 0\n", + "2 2023-01-03 960 snow highway 0\n", + "3 2023-01-04 1394 fog rural road 0\n", + "4 2023-01-05 1230 snow urban road 0\n" + ] + } + ], + "source": [ + "import numpy as np\n", + "import pandas as pd\n", + "import random\n", + "from datetime import timedelta, datetime\n", + "\n", + "# Set random seed for reproducibility\n", + "np.random.seed(42)\n", + "\n", + "# Generate a sequence of dates (e.g., over one year)\n", + "def generate_dates(start_date, days):\n", + " return [start_date + timedelta(days=x) for x in range(days)]\n", + "\n", + "# Parameters\n", + "num_days = 365\n", + "traffic_volume_range = (100, 2000) # Simulate number of cars per day\n", + "weather_conditions = ['clear', 'rain', 'fog', 'snow']\n", + "road_types = ['highway', 'urban road', 'rural road']\n", + "\n", + "# Create base date\n", + "start_date = datetime(2023, 1, 1)\n", + "dates = generate_dates(start_date, num_days)\n", + "\n", + "# Generate data\n", + "data = {\n", + " 'date': dates,\n", + " 'traffic_volume': np.random.randint(traffic_volume_range[0], traffic_volume_range[1], num_days),\n", + " 'weather_condition': np.random.choice(weather_conditions, num_days),\n", + " 'road_type': np.random.choice(road_types, num_days)\n", + "}\n", + "\n", + "# Simulate accident occurrence based on certain conditions\n", + "# We'll make accidents more likely in bad weather and high traffic\n", + "def simulate_accident(row):\n", + " if row['weather_condition'] in ['rain', 'fog', 'snow'] and row['traffic_volume'] > 1500:\n", + " return 1 if random.random() < 0.3 else 0 # 30% chance of accident\n", + " elif row['traffic_volume'] > 1800:\n", + " return 1 if random.random() < 0.2 else 0 # 20% chance of accident\n", + " else:\n", + " return 1 if random.random() < 0.05 else 0 # 5% chance otherwise\n", + "\n", + "# Create DataFrame\n", + "df = pd.DataFrame(data)\n", + "\n", + "# Apply function to create accident occurrence\n", + "df['accident_occurred'] = df.apply(simulate_accident, axis=1)\n", + "\n", + "# Show a preview of the dataset\n", + "print(df.head())\n", + "\n", + "# Save dataset to CSV\n", + "df.to_csv('synthetic_traffic_accident_data.csv', index=False)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "a17718b8-07fb-4ba9-892c-8fdd5aa7eb98", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " date traffic_volume weather_condition road_type accident_occurred\n", + "0 2023-01-01 1226 fog urban road 0\n", + "1 2023-01-02 1559 snow rural road 0\n", + "2 2023-01-03 960 snow highway 0\n", + "3 2023-01-04 1394 fog rural road 0\n", + "4 2023-01-05 1230 snow urban road 0\n", + "date 0\n", + "traffic_volume 0\n", + "weather_condition 0\n", + "road_type 0\n", + "accident_occurred 0\n", + "dtype: int64\n" + ] + } + ], + "source": [ + "import pandas as pd\n", + "import numpy as np\n", + "from sklearn.preprocessing import LabelEncoder, MinMaxScaler\n", + "import matplotlib.pyplot as plt\n", + "\n", + "# Load dataset\n", + "df = pd.read_csv('synthetic_traffic_accident_data.csv')\n", + "\n", + "# Preview the data\n", + "print(df.head())\n", + "\n", + "# Check for missing values\n", + "print(df.isnull().sum())\n", + "\n", + "# Convert 'date' to datetime\n", + "df['date'] = pd.to_datetime(df['date'])\n", + "\n", + "# Convert categorical features into numerical form (Label Encoding)\n", + "label_encoder = LabelEncoder()\n", + "df['weather_condition'] = label_encoder.fit_transform(df['weather_condition'])\n", + "df['road_type'] = label_encoder.fit_transform(df['road_type'])\n", + "\n", + "# Normalize features (LSTM requires normalized data)\n", + "scaler = MinMaxScaler()\n", + "df[['traffic_volume', 'weather_condition', 'road_type']] = scaler.fit_transform(df[['traffic_volume', 'weather_condition', 'road_type']])\n", + "\n", + "# Target column ('accident_occurred') should remain binary" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "528ff056-8dfe-4495-bafb-0dde31228858", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Training data shape: (286, 7, 3)\n", + "Testing data shape: (72, 7, 3)\n" + ] + } + ], + "source": [ + "# Create sequences and labels\n", + "def create_sequences(data, target, time_steps=7):\n", + " X, y = [], []\n", + " for i in range(len(data) - time_steps):\n", + " X.append(data[i:i + time_steps])\n", + " y.append(target[i + time_steps])\n", + " return np.array(X), np.array(y)\n", + "\n", + "# Define features and target\n", + "features = df[['traffic_volume', 'weather_condition', 'road_type']].values\n", + "target = df['accident_occurred'].values\n", + "\n", + "# Create sequences with a 7-day time window (adjust if needed)\n", + "time_steps = 7\n", + "X, y = create_sequences(features, target, time_steps)\n", + "\n", + "# Split into training and testing sets (80% train, 20% test)\n", + "train_size = int(0.8 * len(X))\n", + "X_train, X_test = X[:train_size], X[train_size:]\n", + "y_train, y_test = y[:train_size], y[train_size:]\n", + "\n", + "print(\"Training data shape: \", X_train.shape)\n", + "print(\"Testing data shape: \", X_test.shape)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "7ace3dcb-760d-4842-8b3e-e19e3b3e9a61", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "C:\\Users\\ASUS\\anaconda3\\Lib\\site-packages\\keras\\src\\layers\\rnn\\rnn.py:204: UserWarning: Do not pass an `input_shape`/`input_dim` argument to a layer. When using Sequential models, prefer using an `Input(shape)` object as the first layer in the model instead.\n", + " super().__init__(**kwargs)\n" + ] + }, + { + "data": { + "text/html": [ + "
Model: \"sequential\"\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1mModel: \"sequential\"\u001b[0m\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━┓\n",
+       "┃ Layer (type)                         ┃ Output Shape                ┃         Param # ┃\n",
+       "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━┩\n",
+       "│ lstm (LSTM)                          │ (None, 7, 50)               │          10,800 │\n",
+       "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n",
+       "│ dropout (Dropout)                    │ (None, 7, 50)               │               0 │\n",
+       "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n",
+       "│ lstm_1 (LSTM)                        │ (None, 50)                  │          20,200 │\n",
+       "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n",
+       "│ dropout_1 (Dropout)                  │ (None, 50)                  │               0 │\n",
+       "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n",
+       "│ dense (Dense)                        │ (None, 1)                   │              51 │\n",
+       "└──────────────────────────────────────┴─────────────────────────────┴─────────────────┘\n",
+       "
\n" + ], + "text/plain": [ + "┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━┓\n", + "┃\u001b[1m \u001b[0m\u001b[1mLayer (type) \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1mOutput Shape \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1m Param #\u001b[0m\u001b[1m \u001b[0m┃\n", + "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━┩\n", + "│ lstm (\u001b[38;5;33mLSTM\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m7\u001b[0m, \u001b[38;5;34m50\u001b[0m) │ \u001b[38;5;34m10,800\u001b[0m │\n", + "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n", + "│ dropout (\u001b[38;5;33mDropout\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m7\u001b[0m, \u001b[38;5;34m50\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │\n", + "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n", + "│ lstm_1 (\u001b[38;5;33mLSTM\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m50\u001b[0m) │ \u001b[38;5;34m20,200\u001b[0m │\n", + "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n", + "│ dropout_1 (\u001b[38;5;33mDropout\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m50\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │\n", + "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n", + "│ dense (\u001b[38;5;33mDense\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m1\u001b[0m) │ \u001b[38;5;34m51\u001b[0m │\n", + "└──────────────────────────────────────┴─────────────────────────────┴─────────────────┘\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
 Total params: 31,051 (121.29 KB)\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1m Total params: \u001b[0m\u001b[38;5;34m31,051\u001b[0m (121.29 KB)\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
 Trainable params: 31,051 (121.29 KB)\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1m Trainable params: \u001b[0m\u001b[38;5;34m31,051\u001b[0m (121.29 KB)\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
 Non-trainable params: 0 (0.00 B)\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1m Non-trainable params: \u001b[0m\u001b[38;5;34m0\u001b[0m (0.00 B)\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import tensorflow as tf\n", + "from tensorflow.keras.models import Sequential\n", + "from tensorflow.keras.layers import LSTM, Dense, Dropout\n", + "\n", + "# Build the LSTM model\n", + "model = Sequential()\n", + "\n", + "# First LSTM layer with Dropout\n", + "model.add(LSTM(units=50, return_sequences=True, input_shape=(X_train.shape[1], X_train.shape[2])))\n", + "model.add(Dropout(0.2))\n", + "\n", + "# Second LSTM layer with Dropout\n", + "model.add(LSTM(units=50, return_sequences=False))\n", + "model.add(Dropout(0.2))\n", + "\n", + "# Output layer (binary classification)\n", + "model.add(Dense(units=1, activation='sigmoid'))\n", + "\n", + "# Compile the model\n", + "model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy'])\n", + "\n", + "# Model summary\n", + "model.summary()" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "4cd279e5-b211-4122-ae08-ce4e5ca03a1e", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 1/20\n", + "\u001b[1m9/9\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m8s\u001b[0m 120ms/step - accuracy: 0.7830 - loss: 0.6564 - val_accuracy: 0.9028 - val_loss: 0.5349\n", + "Epoch 2/20\n", + "\u001b[1m9/9\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 19ms/step - accuracy: 0.8766 - loss: 0.5079 - val_accuracy: 0.9028 - val_loss: 0.3351\n", + "Epoch 3/20\n", + "\u001b[1m9/9\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 16ms/step - accuracy: 0.8913 - loss: 0.3606 - val_accuracy: 0.9028 - val_loss: 0.3093\n", + "Epoch 4/20\n", + "\u001b[1m9/9\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 17ms/step - accuracy: 0.8713 - loss: 0.4032 - val_accuracy: 0.9028 - val_loss: 0.3042\n", + "Epoch 5/20\n", + "\u001b[1m9/9\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 16ms/step - accuracy: 0.8804 - loss: 0.3650 - val_accuracy: 0.9028 - val_loss: 0.3110\n", + "Epoch 6/20\n", + "\u001b[1m9/9\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 19ms/step - accuracy: 0.8901 - loss: 0.3489 - val_accuracy: 0.9028 - val_loss: 0.3063\n", + "Epoch 7/20\n", + "\u001b[1m9/9\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 17ms/step - accuracy: 0.8715 - loss: 0.3820 - val_accuracy: 0.9028 - val_loss: 0.3045\n", + "Epoch 8/20\n", + "\u001b[1m9/9\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 21ms/step - accuracy: 0.8997 - loss: 0.3275 - val_accuracy: 0.9028 - val_loss: 0.3032\n", + "Epoch 9/20\n", + "\u001b[1m9/9\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 18ms/step - accuracy: 0.8932 - loss: 0.3445 - val_accuracy: 0.9028 - val_loss: 0.3116\n", + "Epoch 10/20\n", + "\u001b[1m9/9\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 19ms/step - accuracy: 0.8953 - loss: 0.3413 - val_accuracy: 0.9028 - val_loss: 0.3069\n", + "Epoch 11/20\n", + "\u001b[1m9/9\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 19ms/step - accuracy: 0.8875 - loss: 0.3472 - val_accuracy: 0.9028 - val_loss: 0.3051\n", + "Epoch 12/20\n", + "\u001b[1m9/9\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 17ms/step - accuracy: 0.8968 - loss: 0.3320 - val_accuracy: 0.9028 - val_loss: 0.3051\n", + "Epoch 13/20\n", + "\u001b[1m9/9\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 18ms/step - accuracy: 0.8698 - loss: 0.3828 - val_accuracy: 0.9028 - val_loss: 0.3073\n", + "Epoch 14/20\n", + "\u001b[1m9/9\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 23ms/step - accuracy: 0.9009 - loss: 0.3268 - val_accuracy: 0.9028 - val_loss: 0.3061\n", + "Epoch 15/20\n", + "\u001b[1m9/9\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 21ms/step - accuracy: 0.9051 - loss: 0.3089 - val_accuracy: 0.9028 - val_loss: 0.3062\n", + "Epoch 16/20\n", + "\u001b[1m9/9\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 23ms/step - accuracy: 0.9134 - loss: 0.2947 - val_accuracy: 0.9028 - val_loss: 0.3058\n", + "Epoch 17/20\n", + "\u001b[1m9/9\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 19ms/step - accuracy: 0.8769 - loss: 0.3587 - val_accuracy: 0.9028 - val_loss: 0.3111\n", + "Epoch 18/20\n", + "\u001b[1m9/9\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 20ms/step - accuracy: 0.8957 - loss: 0.3315 - val_accuracy: 0.9028 - val_loss: 0.3050\n", + "Epoch 19/20\n", + "\u001b[1m9/9\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 18ms/step - accuracy: 0.8807 - loss: 0.3706 - val_accuracy: 0.9028 - val_loss: 0.3065\n", + "Epoch 20/20\n", + "\u001b[1m9/9\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 17ms/step - accuracy: 0.8656 - loss: 0.3980 - val_accuracy: 0.9028 - val_loss: 0.3063\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkAAAAHFCAYAAAAaD0bAAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy81sbWrAAAACXBIWXMAAA9hAAAPYQGoP6dpAABqr0lEQVR4nO3deXhTVeI+8PcmaZKu6UYX6AZlKbvQsrSVTbQs6ojoUEFZVARUUGScEURkGR10FMUFcJgvi6gjqIjjb0ChKHsBEVpEWUWgBVpKW9p0T5vc3x9pQkMXmjbpTZr38zz3aXJz78m5vW3z9pxzzxVEURRBRERE5EJkUleAiIiIqKUxABEREZHLYQAiIiIil8MARERERC6HAYiIiIhcDgMQERERuRwGICIiInI5DEBERETkchiAiIiIyOUwABFRs6xfvx6CIEAQBOzevbvW66IoomPHjhAEAUOHDrXpewuCgEWLFlm938WLFyEIAtavX9+o7d5+++2mVZCIHBYDEBHZhLe3N9asWVNr/Z49e3D+/Hl4e3tLUCsioroxABGRTSQnJ2Pz5s3QarUW69esWYP4+HhERERIVDMiotoYgIjIJsaPHw8A+Pzzz83rCgsLsXnzZjzxxBN17pOfn49nnnkG7dq1g1KpRIcOHTB//nxUVFRYbKfVavHUU08hICAAXl5eGDlyJM6ePVtnmefOncOECRMQFBQElUqFrl27YsWKFTY6yrplZGTgscces3jPZcuWwWAwWGy3atUq9O7dG15eXvD29kZMTAxefvll8+ulpaV48cUX0b59e6jVavj7+yMuLs7ie0pEtqGQugJE1Dr4+Pjg4Ycfxtq1azF9+nQAxjAkk8mQnJyM5cuXW2xfXl6OYcOG4fz581i8eDF69eqFffv2YenSpUhPT8fWrVsBGMcQjRkzBqmpqXj11VfRr18/HDhwAKNGjapVh5MnTyIhIQERERFYtmwZQkJCsH37djz33HPIzc3FwoULbX7c169fR0JCAnQ6Hf7+978jKioK//vf//Diiy/i/PnzWLlyJQBg48aNeOaZZzBr1iy8/fbbkMlk+P3333Hy5ElzWXPmzMEnn3yC1157DX369EFJSQl+/fVX5OXl2bzeRC5PJCJqhnXr1okAxCNHjoi7du0SAYi//vqrKIqi2K9fP3HKlCmiKIpi9+7dxSFDhpj3++ijj0QA4hdffGFR3ptvvikCEHfs2CGKoih+9913IgDxvffes9ju9ddfFwGICxcuNK8bMWKEGBYWJhYWFlpsO3PmTFGtVov5+fmiKIrihQsXRADiunXrGjw203ZvvfVWvdvMnTtXBCAePnzYYv3TTz8tCoIgnjlzxlwHX1/fBt+vR48e4pgxYxrchohsg11gRGQzQ4YMQXR0NNauXYsTJ07gyJEj9XZ//fjjj/D09MTDDz9ssX7KlCkAgB9++AEAsGvXLgDAo48+arHdhAkTLJ6Xl5fjhx9+wIMPPggPDw9UVVWZl9GjR6O8vByHDh2yxWHWOo5u3bqhf//+tY5DFEX8+OOPAID+/fujoKAA48ePx3//+1/k5ubWKqt///747rvvMHfuXOzevRtlZWU2ry8RGTEAEZHNCIKAxx9/HJ9++ik++ugjdO7cGYMGDapz27y8PISEhEAQBIv1QUFBUCgU5m6fvLw8KBQKBAQEWGwXEhJSq7yqqip88MEHcHNzs1hGjx4NAHWGjubKy8tDaGhorfVt27Y1vw4AEydOxNq1a3Hp0iU89NBDCAoKwoABA5CSkmLe5/3338dLL72Eb775BsOGDYO/vz/GjBmDc+fO2bzeRK6OAYiIbGrKlCnIzc3FRx99hMcff7ze7QICAnDt2jWIomixPicnB1VVVQgMDDRvV1VVVWscTHZ2tsVzPz8/yOVyTJkyBUeOHKlzMQUhWwoICEBWVlat9VevXgUA83EAwOOPP47U1FQUFhZi69atEEUR9913Hy5dugQA8PT0xOLFi3H69GlkZ2dj1apVOHToEO6//36b15vI1TEAEZFNtWvXDn/9619x//33Y/LkyfVuN3z4cBQXF+Obb76xWL9hwwbz6wAwbNgwAMBnn31msd1//vMfi+ceHh4YNmwY0tLS0KtXL8TFxdVabm1FsoXhw4fj5MmTOHbsWK3jEATBXP+aPD09MWrUKMyfPx86nQ6//fZbrW2Cg4MxZcoUjB8/HmfOnEFpaanN607kyngVGBHZ3BtvvHHbbSZNmoQVK1Zg8uTJuHjxInr27In9+/fjH//4B0aPHo27774bAJCUlITBgwfjb3/7G0pKShAXF4cDBw7gk08+qVXme++9hzvvvBODBg3C008/jaioKBQVFeH333/H//t//888HsdaJ06cwFdffVVrfb9+/fDCCy9gw4YNuPfee7FkyRJERkZi69atWLlyJZ5++ml07twZAPDUU0/B3d0diYmJCA0NRXZ2NpYuXQqNRoN+/foBAAYMGID77rsPvXr1gp+fH06dOoVPPvkE8fHx8PDwaFLdiageEg/CJiInV/MqsIbcehWYKIpiXl6eOGPGDDE0NFRUKBRiZGSkOG/ePLG8vNxiu4KCAvGJJ54QfX19RQ8PD/Gee+4RT58+XesqMFE0Xrn1xBNPiO3atRPd3NzENm3aiAkJCeJrr71msQ2suAqsvsW0/6VLl8QJEyaIAQEBopubm9ilSxfxrbfeEvV6vbmsjz/+WBw2bJgYHBwsKpVKsW3btuK4cePEX375xbzN3Llzxbi4ONHPz09UqVRihw4dxBdeeEHMzc1tsJ5EZD1BFG/pgCciIiJq5TgGiIiIiFwOAxARERG5HAYgIiIicjkMQERERORyGICIiIjI5TAAERERkcvhRIh1MBgMuHr1Kry9vWvdp4iIiIgckyiKKCoqQtu2bSGTNdzGwwBUh6tXryI8PFzqahAREVETZGZmIiwsrMFtGIDq4O3tDcD4DfTx8ZG4NkRERNQYWq0W4eHh5s/xhjAA1cHU7eXj48MARERE5GQaM3yFg6CJiIjI5TAAERERkcthACIiIiKXwzFARERkF3q9HpWVlVJXg1oZpVJ520vcG4MBiIiIbEoURWRnZ6OgoEDqqlArJJPJ0L59eyiVymaVwwBEREQ2ZQo/QUFB8PDw4ISyZDOmiYqzsrIQERHRrJ8tBiAiIrIZvV5vDj8BAQFSV4daoTZt2uDq1auoqqqCm5tbk8vhIGgiIrIZ05gfDw8PiWtCrZWp60uv1zerHAYgIiKyOXZ7kb3Y6meLAYiIiIhcDgMQERGRHQwdOhSzZ8+WuhpUDw6CJiIil3a7LpXJkydj/fr1Vpf79ddfN2uQLgBMmTIFBQUF+Oabb5pVDtXGANSCRFFEXokOhWWViG7jJXV1iIgIQFZWlvnxpk2b8Oqrr+LMmTPmde7u7hbbV1ZWNirY+Pv7266SZHPsAmtBu89eR9xrO/HsZ8ekrgoREVULCQkxLxqNBoIgmJ+Xl5fD19cXX3zxBYYOHQq1Wo1PP/0UeXl5GD9+PMLCwuDh4YGePXvi888/tyj31i6wqKgo/OMf/8ATTzwBb29vREREYPXq1c2q+549e9C/f3+oVCqEhoZi7ty5qKqqMr/+1VdfoWfPnnB3d0dAQADuvvtulJSUAAB2796N/v37w9PTE76+vkhMTMSlS5eaVR9nwgDUgiL8jZeFZuSXQhRFiWtDRGR/oiiiVFclyWLLv7MvvfQSnnvuOZw6dQojRoxAeXk5YmNj8b///Q+//vorpk2bhokTJ+Lw4cMNlrNs2TLExcUhLS0NzzzzDJ5++mmcPn26SXW6cuUKRo8ejX79+uH48eNYtWoV1qxZg9deew2AsWVr/PjxeOKJJ3Dq1Cns3r0bY8eOhSiKqKqqwpgxYzBkyBD88ssvOHjwIKZNm+ZSV++xC6wFhfm5QyYApTo9rhdXIMhbLXWViIjsqqxSj26vbpfkvU8uGQEPpW0+5mbPno2xY8darHvxxRfNj2fNmoXvv/8eX375JQYMGFBvOaNHj8YzzzwDwBiq3n33XezevRsxMTFW12nlypUIDw/Hhx9+CEEQEBMTg6tXr+Kll17Cq6++iqysLFRVVWHs2LGIjIwEAPTs2RMAkJ+fj8LCQtx3332Ijo4GAHTt2tXqOjgztgC1IJVCjlCNsS85I69U4toQEVFjxcXFWTzX6/V4/fXX0atXLwQEBMDLyws7duxARkZGg+X06tXL/NjU1ZaTk9OkOp06dQrx8fEWrTaJiYkoLi7G5cuX0bt3bwwfPhw9e/bEn//8Z/z73//GjRs3ABjHJ02ZMgUjRozA/fffj/fee89iLJQrYAtQC4sK9MCVgjJczCtFXBQHyBFR6+buJsfJJSMke29b8fT0tHi+bNkyvPvuu1i+fDl69uwJT09PzJ49GzqdrsFybh08LQgCDAZDk+okimKtLitTt58gCJDL5UhJSUFqaip27NiBDz74APPnz8fhw4fRvn17rFu3Ds899xy+//57bNq0Ca+88gpSUlIwcODAJtXH2bAFqIVF+Bt/iTLySiSuCRGR/QmCAA+lQpLFnuNZ9u3bhwceeACPPfYYevfujQ4dOuDcuXN2e7+6dOvWDampqRZjnVJTU+Ht7Y127doBMH7/ExMTsXjxYqSlpUGpVGLLli3m7fv06YN58+YhNTUVPXr0wH/+858WPQYpsQWohUUFGAdCX2QXGBGR0+rYsSM2b96M1NRU+Pn54Z133kF2drZdxtEUFhYiPT3dYp2/vz+eeeYZLF++HLNmzcLMmTNx5swZLFy4EHPmzIFMJsPhw4fxww8/ICkpCUFBQTh8+DCuX7+Orl274sKFC1i9ejX+9Kc/oW3btjhz5gzOnj2LSZMm2bz+jooBqIVFBhhbgC7lMwARETmrBQsW4MKFCxgxYgQ8PDwwbdo0jBkzBoWFhTZ/r927d6NPnz4W60yTM27btg1//etf0bt3b/j7++PJJ5/EK6+8AgDw8fHB3r17sXz5cmi1WkRGRmLZsmUYNWoUrl27htOnT+Pjjz9GXl4eQkNDMXPmTEyfPt3m9XdUgsjrsWvRarXQaDQoLCyEj4+PTcs+laXFqPf2wdfDDemvJtm0bCIiqZWXl+PChQto37491Gpe6Uq219DPmDWf3xwD1MIiq7vACkorUVhaKXFtiIiIXBMDUAvzUCrQxlsFALiUz4HQREREUmAAkoBpIPQlDoQmIiKSBAOQBEyXwl/ipfBERESSYACSAFuAiIiIpMUAJIEIBiAiIiJJMQBJIKp6LqCL7AIjIiKSBAOQBEyXwucUVaBUVyVxbYiIiFwPA5AEfD2U0Lgbb4iXwRmhiYiIWhwDkEQiOQ6IiKhVGTp0KGbPnm1+HhUVheXLlze4jyAI+Oabb5r93rYqx5UwAEnEfE8wjgMiIpLU/fffj7vvvrvO1w4ePAhBEHDs2DGryz1y5AimTZvW3OpZWLRoEe64445a67OysjBq1Cibvtet1q9fD19fX7u+R0tiAJJIpD9bgIiIHMGTTz6JH3/8EZcuXar12tq1a3HHHXegb9++Vpfbpk0beHh42KKKtxUSEgKVStUi79VaMABJhF1gRESO4b777kNQUBDWr19vsb60tBSbNm3Ck08+iby8PIwfPx5hYWHw8PBAz5498fnnnzdY7q1dYOfOncPgwYOhVqvRrVs3pKSk1NrnpZdeQufOneHh4YEOHTpgwYIFqKw03jdy/fr1WLx4MY4fPw5BECAIgrnOt3aBnThxAnfddRfc3d0REBCAadOmobi42Pz6lClTMGbMGLz99tsIDQ1FQEAAnn32WfN7NUVGRgYeeOABeHl5wcfHB+PGjcO1a9fMrx8/fhzDhg2Dt7c3fHx8EBsbi59//hkAcOnSJdx///3w8/ODp6cnunfvjm3btjW5Lo2hsGvpVK+owOouMN4PjIhaM1EEKiX6R8/NAxCE226mUCgwadIkrF+/Hq+++iqE6n2+/PJL6HQ6PProoygtLUVsbCxeeukl+Pj4YOvWrZg4cSI6dOiAAQMG3PY9DAYDxo4di8DAQBw6dAhardZivJCJt7c31q9fj7Zt2+LEiRN46qmn4O3tjb/97W9ITk7Gr7/+iu+//x47d+4EAGg0mlpllJaWYuTIkRg4cCCOHDmCnJwcTJ06FTNnzrQIebt27UJoaCh27dqF33//HcnJybjjjjvw1FNP3fZ4biWKIsaMGQNPT0/s2bMHVVVVeOaZZ5CcnIzdu3cDAB599FH06dMHq1atglwuR3p6OtzcjBcEPfvss9DpdNi7dy88PT1x8uRJeHl5WV0PazAAScTUBXblRhl0VQYoFWyMI6JWqLIU+Edbad775auA0rNRmz7xxBN46623sHv3bgwbNgyAsftr7Nix8PPzg5+fH1588UXz9rNmzcL333+PL7/8slEBaOfOnTh16hQuXryIsLAwAMA//vGPWuN2XnnlFfPjqKgo/OUvf8GmTZvwt7/9De7u7vDy8oJCoUBISEi97/XZZ5+hrKwMGzZsgKen8fg//PBD3H///XjzzTcRHBwMAPDz88OHH34IuVyOmJgY3Hvvvfjhhx+aFIB27tyJX375BRcuXEB4eDgA4JNPPkH37t1x5MgR9OvXDxkZGfjrX/+KmJgYAECnTp3M+2dkZOChhx5Cz549AQAdOnSwug7W4qeuRNp4q+DuJodBBK4UlEldHSIilxYTE4OEhASsXbsWAHD+/Hns27cPTzzxBABAr9fj9ddfR69evRAQEAAvLy/s2LEDGRkZjSr/1KlTiIiIMIcfAIiPj6+13VdffYU777wTISEh8PLywoIFCxr9HjXfq3fv3ubwAwCJiYkwGAw4c+aMeV337t0hl8vNz0NDQ5GTk2PVe9V8z/DwcHP4AYBu3brB19cXp06dAgDMmTMHU6dOxd1334033ngD58+fN2/73HPP4bXXXkNiYiIWLlyIX375pUn1sAZbgCQiCAIiAzxwOrsIF/NK0D6wcf+lEBE5FTcPY0uMVO9thSeffBIzZ87EihUrsG7dOkRGRmL48OEAgGXLluHdd9/F8uXL0bNnT3h6emL27NnQ6XSNKlsUxVrrhFu65w4dOoRHHnkEixcvxogRI6DRaLBx40YsW7bMquMQRbFW2XW9p6n7qeZrBoPBqve63XvWXL9o0SJMmDABW7duxXfffYeFCxdi48aNePDBBzF16lSMGDECW7duxY4dO7B06VIsW7YMs2bNalJ9GoMtQBIyDYTO4EBoImqtBMHYDSXF0ojxPzWNGzcOcrkc//nPf/Dxxx/j8ccfN39479u3Dw888AAee+wx9O7dGx06dMC5c+caXXa3bt2QkZGBq1dvhsGDBw9abHPgwAFERkZi/vz5iIuLQ6dOnWpdmaZUKqHX62/7Xunp6SgpuTnG9MCBA5DJZOjcuXOj62wN0/FlZmaa1508eRKFhYXo2rWreV3nzp3xwgsvYMeOHRg7dizWrVtnfi08PBwzZszA119/jb/85S/497//bZe6mkgegFauXIn27dtDrVYjNjYW+/bta3D7iooKzJ8/H5GRkVCpVIiOjjY3WZps3rwZ3bp1g0qlQrdu3bBlyxZ7HkKTRfKeYEREDsPLywvJycl4+eWXcfXqVUyZMsX8WseOHZGSkoLU1FScOnUK06dPR3Z2dqPLvvvuu9GlSxdMmjQJx48fx759+zB//nyLbTp27IiMjAxs3LgR58+fx/vvv1/r8ysqKgoXLlxAeno6cnNzUVFRUeu9Hn30UajVakyePBm//vordu3ahVmzZmHixInm8T9NpdfrkZ6ebrGcPHkSd999N3r16oVHH30Ux44dw08//YRJkyZhyJAhiIuLQ1lZGWbOnIndu3fj0qVLOHDgAI4cOWIOR7Nnz8b27dtx4cIFHDt2DD/++KNFcLIHSQPQpk2bMHv2bMyfPx9paWkYNGgQRo0a1WB/57hx4/DDDz9gzZo1OHPmDD7//HPzgCrAmKiTk5MxceJEHD9+HBMnTsS4ceNw+PDhljgkq/BSeCIix/Lkk0/ixo0buPvuuxEREWFev2DBAvTt2xcjRozA0KFDERISgjFjxjS6XJlMhi1btqCiogL9+/fH1KlT8frrr1ts88ADD+CFF17AzJkzcccddyA1NRULFiyw2Oahhx7CyJEjMWzYMLRp06bOS/E9PDywfft25Ofno1+/fnj44YcxfPhwfPjhh9Z9M+pQXFyMPn36WCyjR482X4bv5+eHwYMH4+6770aHDh2wadMmAIBcLkdeXh4mTZqEzp07Y9y4cRg1ahQWL14MwBisnn32WXTt2hUjR45Ely5dsHLlymbXtyGCWFfHZAsZMGAA+vbti1WrVpnXde3aFWPGjMHSpUtrbf/999/jkUcewR9//AF/f/86y0xOToZWq8V3331nXjdy5Ej4+fndds4GE61WC41Gg8LCQvj4+Fh5VI23/1wuHltzGNFtPPHDX4ba7X2IiFpKeXk5Lly4YG7ZJ7K1hn7GrPn8lqwFSKfT4ejRo0hKSrJYn5SUhNTU1Dr3+fbbbxEXF4d//vOfaNeuHTp37owXX3wRZWU3r6I6ePBgrTJHjBhRb5mAsVtNq9VaLC3B1AKUmV8GvUGyHEpERORyJLsKLDc3F3q9vlZ/ZHBwcL39qn/88Qf2798PtVqNLVu2IDc3F8888wzy8/PN44Cys7OtKhMAli5dam6Ga0ltfd3hJheg0xuQrS1HO1/3Fq8DERGRK5J8EPStl801dPmewWCAIAj47LPP0L9/f4wePRrvvPMO1q9fb9EKZE2ZADBv3jwUFhaal5qj2O1JLhMQ7lc9DiiXA6GJiIhaimQBKDAwEHK5vFbLTE5OTr2j1ENDQ9GuXTuLqb+7du0KURRx+fJlAMYbwllTJgCoVCr4+PhYLC0lwjQQOp8DoYmIiFqKZAFIqVQiNja21s3gUlJSkJCQUOc+iYmJuHr1qsUN3c6ePQuZTGaeXTM+Pr5WmTt27Ki3TKlF8VJ4ImqFJLy+hlo5W/1sSdoFNmfOHPzf//0f1q5di1OnTuGFF15ARkYGZsyYAcDYNTVp0iTz9hMmTEBAQAAef/xxnDx5Env37sVf//pXPPHEE3B3N46fef7557Fjxw68+eabOH36NN58803s3LmzzpvOOYIIf06GSESth2l24dJS/k0j+zDNvl3zNh5NIemtMJKTk5GXl4clS5YgKysLPXr0wLZt2xAZGQkAyMrKspgTyMvLCykpKZg1axbi4uIQEBCAcePG4bXXXjNvk5CQgI0bN+KVV17BggULEB0djU2bNjXqZnVSiAo0BqCLDEBE1ArI5XL4+vqa7ynl4eHR4BhMImsYDAZcv34dHh4eUCiaF2EknQfIUbXUPEAAcP56MYYv2wNPpRy/Lh7BPxRE5PREUUR2djYKCgqkrgq1QjKZDO3bt4dSqaz1mjWf37wZqsTC/NwhCECJTo/cYh3aeKukrhIRUbMIgoDQ0FAEBQWhsrJS6upQK6NUKiGTNX8EDwOQxFQKOdpq3HGloAwZ+SUMQETUasjl8maP0yCyF8nnAaKbM0JfzOU4ICIiopbAAOQATHeF51xARERELYMByAHcvCs85wIiIiJqCQxADiAqgJfCExERtSQGIAcQ4W/sAstgCxAREVGLYAByAKYusBullSgs4yWjRERE9sYA5AA8VQoEehkvf+ctMYiIiOyPAchB3BwHxG4wIiIie2MAchAR1QEog5fCExER2R0DkIOIqp4L6GIuW4CIiIjsjQHIQZjnAmILEBERkd0xADkI82zQHANERERkdwxADsI0CPqatgJlOr3EtSEiImrdGIAchK+HEj5qBQAOhCYiIrI3BiAHEhXIbjAiIqKWwADkQCL8TTdFZQsQERGRPTEAORDzpfBsASIiIrIrBiAHwskQiYiIWgYDkANhCxAREVHLYAByIKbJEK/cKIOuyiBxbYiIiFovBiAHEuStgtpNBoMIXCkok7o6RERErRYDkAMRBAGR/rwUnoiIyN4YgByM+Z5gvBSeiIjIbhiAHAwDEBERkf0xADkY3hSViIjI/hiAHIy5BYhzAREREdkNA5CDMc0FlJFfCoNBlLg2RERErRMDkIMJ1ajhJhegqzIgW1sudXWIiIhaJQYgB6OQyxDmZ+wG44zQRERE9sEA5IBM44AyeCUYERGRXTAAOaBIf1MLEAMQERGRPTAAOSBeCk9ERGRfDEAOiJMhEhER2RcDkAOq2QIkirwUnoiIyNYYgBxQuL87BAEo0emRV6KTujpEREStDgOQA1Ip5GircQfAcUBERET2wADkoCL8OQ6IiIjIXhiAHFRUIC+FJyIishfJA9DKlSvRvn17qNVqxMbGYt++ffVuu3v3bgiCUGs5ffq0eZv169fXuU15uXPdViLCv/qeYOwCIyIisjmFlG++adMmzJ49GytXrkRiYiL+9a9/YdSoUTh58iQiIiLq3e/MmTPw8fExP2/Tpo3F6z4+Pjhz5ozFOrVabdvK21lUAFuAiIiI7EXSAPTOO+/gySefxNSpUwEAy5cvx/bt27Fq1SosXbq03v2CgoLg6+tb7+uCICAkJMTW1W1RkTXuCk9ERES2JVkXmE6nw9GjR5GUlGSxPikpCampqQ3u26dPH4SGhmL48OHYtWtXrdeLi4sRGRmJsLAw3HfffUhLS7Np3VtCRHULUH6JDtrySolrQ0RE1LpIFoByc3Oh1+sRHBxssT44OBjZ2dl17hMaGorVq1dj8+bN+Prrr9GlSxcMHz4ce/fuNW8TExOD9evX49tvv8Xnn38OtVqNxMREnDt3rt66VFRUQKvVWixS81IpEOilAsCbohIREdmapF1ggLG7qiZRFGutM+nSpQu6dOlifh4fH4/MzEy8/fbbGDx4MABg4MCBGDhwoHmbxMRE9O3bFx988AHef//9OstdunQpFi9e3NxDsbnIAA/kFlfgYl4JerTTSF0dIiKiVkOyFqDAwEDI5fJarT05OTm1WoUaMnDgwAZbd2QyGfr169fgNvPmzUNhYaF5yczMbPT72xPvCUZERGQfkgUgpVKJ2NhYpKSkWKxPSUlBQkJCo8tJS0tDaGhova+Looj09PQGt1GpVPDx8bFYHEGkP+8KT0REZA+SdoHNmTMHEydORFxcHOLj47F69WpkZGRgxowZAIwtM1euXMGGDRsAGK8Si4qKQvfu3aHT6fDpp59i8+bN2Lx5s7nMxYsXY+DAgejUqRO0Wi3ef/99pKenY8WKFZIcY3NwMkQiIiL7kDQAJScnIy8vD0uWLEFWVhZ69OiBbdu2ITIyEgCQlZWFjIwM8/Y6nQ4vvvgirly5And3d3Tv3h1bt27F6NGjzdsUFBRg2rRpyM7OhkajQZ8+fbB3717079+/xY+vuUy3w+AgaCIiItsSRFEUpa6Eo9FqtdBoNCgsLJS0O+xGiQ59/m7sIjz995FQu8klqwsREZGjs+bzW/JbYVD9fD3c4K02NtJxQkQiIiLbYQByYIIgIKp6RuiLuRwITUREZCsMQA7ONCM0W4CIiIhshwHIwd28KSpbgIiIiGyFAcjB3ZwLiC1AREREtsIA5OA4GzQREZHtMQA5uKhAYwvQlYIyVOoNEteGiIiodWAAkoIVUy8FeaugdpNBbxBx5UaZHStFRETkOhiAWlLGIWB5L2BNUqN3EQTh5jggXglGRERkEwxALcnNAyi4BNy4YNVuEeZxQLwSjIiIyBYYgFqSJsz4teQ6UFne6N3Ml8LnsgWIiIjIFhiAWpK7n7EVCAC0Vxq9W0T1bNAZ+WwBIiIisgUGoJYkCIBPO+PjwsuN3u3mZIhsASIiIrIFBqCWZuoGs6IFyDQIOiO/FAZD468gIyIioroxALU0jfUtQG191VDIBOiqDMjWNn7sEBEREdWNAailacKNX60IQAq5DGF+7gA4IzQREZEtMAC1tCaMAQKAyADTPcE4EJqIiKi5GIBaWhPGAAE17gnGyRCJiIiajQGopZkCUOFlq26JwRYgIiIi22EAammmLjBdMVBe2OjdIv15V3giIiJbYQBqaUoPwN3f+NiauYACbwYg0YqWIyIiIqqNAUgKTRgHFObnAUEAiiuqkF+is1PFiIiIXAMDkBTM44AyG72L2k2OUB81AM4ITURE1FwMQFIwByBrrwTjPcGIiIhsgQFICk2eC4h3hSciIrIFBiApNHkuIF4KT0REZAsMQFJowhgggJMhEhER2QoDkBTMLUBZgEHf6N3MAYiDoImIiJqFAUgKXiGAIAMMlUBxTqN3M3WB5ZfooC2vtFftiIiIWj0GICnIFYB3W+NjK8YBeakUCPRSAgAy2ApERETUZAxAUtGYrgSzbhxQBG+JQURE1GwMQFJp4lxAUdXdYBd5JRgREVGTMQBJpYlzAUVUD4RmFxgREVHTMQBJRRNu/Kq1LgCxBYiIiKj5GICkomlmCxDnAiIiImoyBiCpNHMMUFZhOcorGz+HEBEREd3EACQVn+oAVJIDVFU0ejc/Dzd4qxUAgEy2AhERETUJA5BUPPwBhbvxsRVzAQmCcPOmqBwITURE1CQMQFIRhCaPA+JNUYmIiJqHAUhKTRwHFMnJEImIiJqFAUhKpnFAVrYA8VJ4IiKi5pE8AK1cuRLt27eHWq1GbGws9u3bV++2u3fvhiAItZbTp09bbLd582Z069YNKpUK3bp1w5YtW+x9GE1jvis8L4UnIiJqSZIGoE2bNmH27NmYP38+0tLSMGjQIIwaNQoZGRkN7nfmzBlkZWWZl06dOplfO3jwIJKTkzFx4kQcP34cEydOxLhx43D48GF7H471mjgGyNQCdPlGGSr1BlvXioiIqNWTNAC98847ePLJJzF16lR07doVy5cvR3h4OFatWtXgfkFBQQgJCTEvcrnc/Nry5ctxzz33YN68eYiJicG8efMwfPhwLF++3M5H0wRNHAMU5K2CSiGD3iDiakGZHSpGRETUukkWgHQ6HY4ePYqkpCSL9UlJSUhNTW1w3z59+iA0NBTDhw/Hrl27LF47ePBgrTJHjBjRYJkVFRXQarUWS4sw3Q7DyhYgmYyXwhMRETWHZAEoNzcXer0ewcHBFuuDg4ORnZ1d5z6hoaFYvXo1Nm/ejK+//hpdunTB8OHDsXfvXvM22dnZVpUJAEuXLoVGozEv4eHhzTgyK5huiKorAsoLrdo1wt/YDZbBgdBERERWU0hdAUEQLJ6LolhrnUmXLl3QpUsX8/P4+HhkZmbi7bffxuDBg5tUJgDMmzcPc+bMMT/XarUtE4KUHoC7P1CWb2wFUmsavWsUW4CIiIiaTLIWoMDAQMjl8lotMzk5ObVacBoycOBAnDt3zvw8JCTE6jJVKhV8fHwslhZjHght5VxAAZwLiIiIqKkkC0BKpRKxsbFISUmxWJ+SkoKEhIRGl5OWlobQ0FDz8/j4+Fpl7tixw6oyW5R5HFCmVbtxNmgiIqKmk7QLbM6cOZg4cSLi4uIQHx+P1atXIyMjAzNmzABg7Jq6cuUKNmzYAMB4hVdUVBS6d+8OnU6HTz/9FJs3b8bmzZvNZT7//PMYPHgw3nzzTTzwwAP473//i507d2L//v2SHONt+TT1dhg35wIyGETIZPV38REREZElSQNQcnIy8vLysGTJEmRlZaFHjx7Ytm0bIiMjAQBZWVkWcwLpdDq8+OKLuHLlCtzd3dG9e3ds3boVo0ePNm+TkJCAjRs34pVXXsGCBQsQHR2NTZs2YcCAAS1+fI1ingzRui6wdr7uUMgEVFQZcK2oHKEadztUjoiIqHUSRFEUpa6Eo9FqtdBoNCgsLLT/eKATXwGbnwQiE4HHt1m169C3duFiXik2ThuIgR0C7FRBIiIi52DN57fkt8JweZqm3Q8MACI4DoiIiKhJGICkZhoDpL0KGKy7rQUvhSciImoaBiCpeYcCggwwVAIlOVbtGuFfPRCaAYiIiMgqDEBSkyuMIQho8k1RL7ILjIiIyCoMQI6gieOAzJfC55WCY9mJiIgajwHIETRxLqBwfw8IAlBUUYX8Ep0dKkZERNQ6MQA5gibOBaR2kyPERw0AuJTPcUBERESNxQDkCMxdYNbdDgOoeU8wjgMiIiJqLAYgR2AOQNa1AAFApL9pLiC2ABERETUWA5AjaOIYIACIDORd4YmIiKzFAOQITHeEL8kBqiqs2vVmCxC7wIiIiBqLAcgRePgDCuNgZmsHQt8cA8QWICIiosZiAHIEgtDkcUCmAJRXokNReaWta0ZERNQqMQA5iiaOA/JWuyHAUwmArUBERESNxQDkKEzjgLRNGAjNbjAiIiKrMAA5Ck0zrgSrvifYpXwOhCYiImqMJgWgzMxMXL5884P6p59+wuzZs7F69WqbVczlNGcuIFMLUC5bgIiIiBqjSQFowoQJ2LVrFwAgOzsb99xzD3766Se8/PLLWLJkiU0r6DKaMxeQKQCxBYiIiKhRmhSAfv31V/Tv3x8A8MUXX6BHjx5ITU3Ff/7zH6xfv96W9XMd5jFATWkB4mzQRERE1mhSAKqsrIRKpQIA7Ny5E3/6058AADExMcjKyrJd7VyJaQxQhRYoL7Rq10h/YwtQVmE5yiv1tq4ZERFRq9OkANS9e3d89NFH2LdvH1JSUjBy5EgAwNWrVxEQEGDTCroMpSfg7md8bOU4IH9PJbxVCgBAJu8KT0REdFtNCkBvvvkm/vWvf2Ho0KEYP348evfuDQD49ttvzV1j1AQ+poHQ1o0DEgQBEbwUnoiIqNEUTdlp6NChyM3NhVarhZ+fn3n9tGnT4OHhYbPKuRxNGHDtRJPmAooK8MRvV7W4yHuCERER3VaTWoDKyspQUVFhDj+XLl3C8uXLcebMGQQFBdm0gi6lGXMBmVqAMtgFRkREdFtNCkAPPPAANmzYAAAoKCjAgAEDsGzZMowZMwarVq2yaQVdSjPmAoqqDkAX2QVGRER0W00KQMeOHcOgQYMAAF999RWCg4Nx6dIlbNiwAe+//75NK+hSmjgGCAAi/I2XwmewC4yIiOi2mhSASktL4e3tDQDYsWMHxo4dC5lMhoEDB+LSpUs2raBLMbUANWUMUKCxBejyjTJU6Q22rBUREVGr06QA1LFjR3zzzTfIzMzE9u3bkZSUBADIycmBj4+PTSvoUsxjgK4AButCTLC3GiqFDFUGEVcLyu1QOSIiotajSQHo1VdfxYsvvoioqCj0798f8fHxAIytQX369LFpBV2KdyggyABDJVBy3apdZTIBEf6mcUDsBiMiImpIkwLQww8/jIyMDPz888/Yvn27ef3w4cPx7rvv2qxyLkfuBniFGB83567wDEBEREQNatI8QAAQEhKCkJAQXL58GYIgoF27dpwE0RY0YUDR1epxQLFW7Wq6KeoF3hWeiIioQU1qATIYDFiyZAk0Gg0iIyMREREBX19f/P3vf4fByrErdItmzAXULdQ4/urnS/m2rBEREVGr06QWoPnz52PNmjV44403kJiYCFEUceDAASxatAjl5eV4/fXXbV1P19GMuYASOwYCAE5cKURBqQ6+Hkpb1oyIiKjVaFIA+vjjj/F///d/5rvAA0Dv3r3Rrl07PPPMMwxAzWGeCyjT6l1DNGp0DPLC7znFOHg+D6N6htq4ckRERK1Dk7rA8vPzERMTU2t9TEwM8vPZ/dIs5rmArG8BAoA7q1uBDpzPtVWNiIiIWp0mBaDevXvjww8/rLX+ww8/RK9evZpdKZfWjDFAwM1usAO/59mqRkRERK1Ok7rA/vnPf+Lee+/Fzp07ER8fD0EQkJqaiszMTGzbts3WdXQtmnDj1+JrQFUFoFBZtfuADv6QywRcyC3B5RulCPPzsEMliYiInFuTWoCGDBmCs2fP4sEHH0RBQQHy8/MxduxY/Pbbb1i3bp2t6+haPAIAhdr4WHvV6t191G7oHaYBAKSyFYiIiKhOTZ4HqG3btrUGOx8/fhwff/wx1q5d2+yKuSxBAHzaAfnnjeOA/NtbXcSdHQNxLKMA+3/Pxbh+4XaoJBERkXNrUgsQ2ZnNxgHlwmAQbVUrIiKiVkPyALRy5Uq0b98earUasbGx2LdvX6P2O3DgABQKBe644w6L9evXr4cgCLWW8nInukGoaRxQEwNQnwg/uLvJkVeiw5lrRTasGBERUesgaQDatGkTZs+ejfnz5yMtLQ2DBg3CqFGjkJGR0eB+hYWFmDRpEoYPH17n6z4+PsjKyrJY1Gq1PQ7BPnya1wKkVMgwoIM/AGMrEBEREVmyagzQ2LFjG3y9oKDAqjd/55138OSTT2Lq1KkAgOXLl2P79u1YtWoVli5dWu9+06dPx4QJEyCXy/HNN9/Uel0QBISEhFhVF4fSzLmAACAxOhC7z1zH/t9zMXVQBxtVjIiIqHWwqgVIo9E0uERGRmLSpEmNKkun0+Ho0aNISkqyWJ+UlITU1NR691u3bh3Onz+PhQsX1rtNcXExIiMjERYWhvvuuw9paWmNO0BH0cwxQMDNcUCH/8iHror3ZyMiIqrJqhYgW17inpubC71ej+DgYIv1wcHByM7OrnOfc+fOYe7cudi3bx8UirqrHhMTg/Xr16Nnz57QarV47733kJiYiOPHj6NTp0517lNRUYGKigrzc61W28SjshHzGKCmtwDFhHgjwFOJvBId0jJuYECHABtVjoiIyPlJPghaEASL56Io1loHAHq9HhMmTMDixYvRuXPnessbOHAgHnvsMfTu3RuDBg3CF198gc6dO+ODDz6od5+lS5datGSFh0t86bhpDFBFIVDetDAmkwlIMN8Wg/MBERER1SRZAAoMDIRcLq/V2pOTk1OrVQgAioqK8PPPP2PmzJlQKBRQKBRYsmQJjh8/DoVCgR9//LHO95HJZOjXrx/OnTtXb13mzZuHwsJC85KZaf2NSG1K5QWofY2PmzEO6M6OxlYfDoQmIiKyJFkAUiqViI2NRUpKisX6lJQUJCQk1Nrex8cHJ06cQHp6unmZMWMGunTpgvT0dAwYMKDO9xFFEenp6QgNrf/O6CqVCj4+PhaL5EwDoW0wDig9swBF5ZW2qBUREVGr0OSZoG1hzpw5mDhxIuLi4hAfH4/Vq1cjIyMDM2bMAGBsmbly5Qo2bNgAmUyGHj16WOwfFBQEtVptsX7x4sUYOHAgOnXqBK1Wi/fffx/p6elYsWJFix5bs2nCgGu/NisAhfl5ICrAAxfzSnH4j3zc3a12yxoREZErkjQAJScnIy8vD0uWLEFWVhZ69OiBbdu2ITIyEgCQlZV12zmBblVQUIBp06YhOzsbGo0Gffr0wd69e9G/f397HIL9NHMuIJPEjoG4mJeB/b/nMgARERFVE0RR5L0SbqHVaqHRaFBYWChdd9i+d4AfFgO9xwMPftTkYr47kYWnPzuGTkFeSJkzxIYVJCIicizWfH5LfhUY1cMGY4AAID46AIIAnMspxjWtE90OhIiIyI4YgByVjQKQr4cSPdtpAPBqMCIiIhMGIEdlGgOkvQIYmjeTs+lqsP0MQERERAAYgByXT1sAAqDXAaXNCy53miZE/D0XHPJFRETEAOS45G6Ad/XcRYXNm5gxNtIPSoUM17QVOH+92AaVIyIicm4MQI7MfFPUps8GDQBqNzn6RfkBAA78zttiEBERMQA5MhsNhAY4DoiIiKgmBiBHVnMgdDOZxgEdOp+HKn3zBlUTERE5OwYgR6apvit9M8cAAUD3thpo3N1QVFGFX64UNrs8IiIiZ8YA5MhsNAYIAOQyAQnR1XeHP8duMCIicm0MQI7MhmOAAI4DIiIiMmEAcmQ+1QGo+BpQpWt2caZxQMcybqBUV9Xs8oiIiJwVA5Aj8wwE5CoAIlB0tdnFRQZ4oJ2vOyr1In66kN/8+hERETkpBiBHJgg2HQckCILFrNBERESuigHI0dl6HFAn0zggTohIRESuiwHI0ZnGAWltE4BMV4KdytIit7jCJmUSERE5GwYgR2fjFqBALxW6hvoAAA6eZysQERG5JgYgR2fDMUAmiab5gDgOiIiIXBQDkKOzcQsQcHMc0L5zuRBF0WblEhEROQsGIEdn4zFAANA/yh9ucgFXCsqQkV9qs3KJiIicBQOQozN1gZUXAhVFNinSU6VAnwg/AJwVmoiIXBMDkKNTeQNqjfGxDccBcT4gIiJyZQxAzsB8V3gbjgOqDkCp5/OgN3AcEBERuRYGIGfgY7oSLNNmRfYO08BLpUBBaSVOXtXarFwiIiJnwADkDExXgmlt1wWmkMswsIPxcniOAyIiIlfDAOQMzHMB2a4LDADu7Mj5gIiIyDUxADkDO4wBAoA7q+cDOnIxH+WVepuWTURE5MgYgJyBj31agKLbeCHYR4WKKgOOXbph07KJiIgcGQOQMzCPAboKGAw2K1YQBPPVYBwHREREroQByBn4tAUgAPoKoNS2QYXzARERkStiAHIGcjfAO8T42MbdYKYWoF+uFKKwtNKmZRMRETkqBiBnYadxQME+anQM8oIoAgf/YCsQERG5BgYgZ2GHuYBM7uQ4ICIicjEMQM7CFIBs3AIE3OwGO/B7ns3LJiIickQMQM7CjgFoQAd/yGUCLuSW4PKNUpuXT0RE5GgYgJyFncYAAYCP2g29w4x3nE9lKxAREbkABiBnYccxQADHARERkWthAHIWpgBUlA1U6WxefGKN+YAMBtHm5RMRETkSBiBn4REIyFUARKAoy+bF94nwg7ubHHklOpy5VmTz8omIiBwJA5CzkMmqZ4SGXcYBKRUyDOjgD4CzQhMRUevHAORMWmgcEAMQERG1dpIHoJUrV6J9+/ZQq9WIjY3Fvn37GrXfgQMHoFAocMcdd9R6bfPmzejWrRtUKhW6deuGLVu22LjWEjFfCp9pl+JN44AOX8iHrsp2N10lIiJyNJIGoE2bNmH27NmYP38+0tLSMGjQIIwaNQoZGRkN7ldYWIhJkyZh+PDhtV47ePAgkpOTMXHiRBw/fhwTJ07EuHHjcPjwYXsdRssxByD7tAB1CfZGoJcSpTo90jML7PIeREREjkDSAPTOO+/gySefxNSpU9G1a1csX74c4eHhWLVqVYP7TZ8+HRMmTEB8fHyt15YvX4577rkH8+bNQ0xMDObNm4fhw4dj+fLldjqKFmTHuYAAQCYTEB/Ny+GJiKj1kywA6XQ6HD16FElJSRbrk5KSkJqaWu9+69atw/nz57Fw4cI6Xz948GCtMkeMGNFgmRUVFdBqtRaLQ9KEG7/aaQwQANzZMQAAxwEREVHrJlkAys3NhV6vR3BwsMX64OBgZGdn17nPuXPnMHfuXHz22WdQKBR1bpOdnW1VmQCwdOlSaDQa8xIeHm7l0bQQjakFyD5jgICb44DSMwtQVF5pt/chIiKSkuSDoAVBsHguimKtdQCg1+sxYcIELF68GJ07d7ZJmSbz5s1DYWGhecnMtF/AaBZTF1h5IVBhn7l6wvw8EBXgAb1BxOE/8u3yHkRERFKruxmlBQQGBkIul9dqmcnJyanVggMARUVF+Pnnn5GWloaZM2cCAAwGA0RRhEKhwI4dO3DXXXchJCSk0WWaqFQqqFQqGxyVnal9AJUGqCg0DoQOirHL2yR2DMTFvAzs/z0Xd3er//tGRETkrCRrAVIqlYiNjUVKSorF+pSUFCQkJNTa3sfHBydOnEB6erp5mTFjBrp06YL09HQMGDAAABAfH1+rzB07dtRZplMyzwVkn4HQAOcDIiKi1k+yFiAAmDNnDiZOnIi4uDjEx8dj9erVyMjIwIwZMwAYu6auXLmCDRs2QCaToUePHhb7BwUFQa1WW6x//vnnMXjwYLz55pt44IEH8N///hc7d+7E/v37W/TY7EbTDsj5zW5XggFAfHQABAE4l1OMa9pyBPuo7fZeREREUpA0ACUnJyMvLw9LlixBVlYWevTogW3btiEyMhIAkJWVdds5gW6VkJCAjRs34pVXXsGCBQsQHR2NTZs2mVuInJ6d5wICAF8PJXq20+CXy4VIPZ+LB/uE2e29iIiIpCCIoshbf99Cq9VCo9GgsLAQPj4+UlfH0t63gR//DvSeADzY8HxJzfHm96exavd5PNQ3DMvG9bbb+xAREdmKNZ/fkl8FRlYyzwVkvy4wwHIcEDMyERG1NgxAzkZj39mgTWIj/aBSyJCtLcf56yV2fS8iIqKWxgDkbGqOAbJjy4zaTY5+Uf4AeDUYERG1PgxAzsa7LQAB0FcAJfYNJqZZoXlfMCIiam0YgJyNQgl4VU9OaOdxQInV9wU7dD4PVXqDXd+LiIioJTEAOaMWGgfUva0GGnc3FFVU4ZcrhXZ9LyIiopbEAOSMWmAuIACQywQkRFffHf4cu8GIiKj1YAByRj6mAGT/m7ZyHBAREbVGDEDOyHw/MPu2AAE35wM6lnEDpboqu78fERFRS2AAckYtNAYIACIDPNDO1x2VehFHLt6w+/sRERG1BAYgZ9RCY4AAQBAE3h2eiIhaHQYgZ2QaA1SUBegr7f52iZ2qxwFxIDQREbUSDEDOyLMNIFcCEI0hyM5MV4KdzNIir7jC7u9HRERkbwxAzkgmA3xabhxQoJcKXUONd9VNPZ9n9/cjIiKyNwYgZ9WC44AA4M7qWaE5DoiIiFoDBiBnpWm5uYCAm/MB7TuXC9GON2ElIiJqCQxAzsrUBdYCcwEBQP/2/nCTC7hSUIYTvC0GERE5OQYgZ2VuAbL/GCAA8FAqEB9tbAV6+KOD+OCHc9BV8QapRETknBiAnFULjwECgH8+1AtDOreBrsqAZSlnce/7+/DzxfwWe38iIiJbYQByVi08BggAQjRqrH+8H9575A4EeCpxLqcYD390EPO3nEBhmf3nIyIiIrIVBiBnZRoDVF4AVBS32NsKgoAH7miHH/4yBMlx4QCAzw5n4O539mDbiSwOkCYiIqfAAOSs1D6ASmN83EIDoWvy9VDizYd7YeO0gegQ6InrRRV45rNjmPrxz7hSUNbi9SEiIrIGA5Aza8GbotZnYIcAbHt+EJ4b3glucgE/nM7BPe/swdr9F6A3sDWIiIgcEwOQM2vhK8Hqo3aTY849nbHtuUGIi/RDqU6PJf87iQdXHsCvvGSeiIgcEAOQM2vhuYBup1OwN76YHo9/PNgT3moFfrlciAdWHMDSbadQqquSunpERERmDEDOzEFagGqSyQRMGBCBH+YMwb29QqE3iPjX3j+Q9O5e7D6TI3X1iIiIADAAOTcHDEAmQT5qrJjQF2smx6GtRo3LN8owZd0RPPd5Gq4X8Y7yREQkLQYgZ+bAAchkeNdgpMwZgifvbA+ZAHx7/CrufmcPNh3J4CXzREQkGYXUFaBmqDkGSBQBQZC2PvXwVCmw4L5uGHNHO8z9+hf8dlWLlzafwNfHruAfY3siuo2X1FV0aT+evoZlO86ipKIKAzsEID7auAR5q6WuGhGR3Qgi/w2vRavVQqPRoLCwED4+PlJXp35VFcBrwQBE4K/nAc9AqWt0W1V6A9YduIh3Us6irFIPpVyGZ4d1xIyhHaBSyKWunku5kFuCv//vJH48XffYrE5BXkiIDkBCx0AMbB8AjYdbC9eQiMg61nx+MwDVwWkCEAC83RkovgZM2wO0vUPq2jRaZn4pXvnmV+w5ex0A0DHIC0vH9kS/KH+Ja9b6lVRU4cNdv2PNvgvQ6Q1QyAQ8cWd7DGjvj0N/5CH1fB5OZmlR8y+DIAA92mqQUN061C/KH54qNiATkWNhAGompwpA/74LuHIUSP4M6Hqf1LWxiiiK+H+/ZGHJ//sNucU6AMDoniGIjw5E3whfdAn2hkLOYWq2Iooivj1+Ff/YdgrXtMaB6IM7t8Gr93VDxyDLbsgbJTocvmAMQ6nn8/B7juXtVhQyAXeE+yKhYyASogPQJ8KXLXhEJDkGoGZyqgC0aSJw6ltg1D+BAdOlrk2TFJTq8MZ3p7HxiOWNXT2UcvQK06BPhB/6hPuib6QfAr1UEtWyYeWVetwo1SHERw3BAcdinbyqxaJvf8NPF/MBABH+HlhwXzfc3TWoUfW9pi3HwfN5SD2fiwO/59W63YlKIUO/KH/ERwcgIToAPdtpGF6JqMUxADWTUwWg718GDq0AEmYBSa9JXZtmOZ5ZgB9O5yAt4wbSMwpQVFF78sRwf3f0rRGIuob6wK2FPmhFUUReiQ7nc4rxR24JzucU4/x14+PM/FIYRCC6jSfGxYVjbN8wtPGWPqzdKNFhWcoZ/OdwBgwioHaTYeawjpg6qAPUbk1vscnML0Xq+VxzC9GtUxt4qRQY0N7f3ELUJdgbMpnjBUMial0YgJrJqQLQwRXA9peB7mOBP6+TujY2YzCI+P16MdIybuDYpQKkZd7AuZxi3PrTqlLIzK1EfSN80SfCD8E+zbt6qVJvwKW8UmO4uV6C89eLzY8LyyobVYZCJuCumCCMiwvH0C5tWrw1RG8Q8flPGXh7xxkUlBrrfG+vUMwf3RVtfd1t+l6iKOL3nOLqMJSLg+fzoC23DK/+nkokdgzE4E6BGNK5DYKaeY5IenqDCG1ZJcoq9fBSK+ClVDDkkuQYgJrJqQLQyf8CX0wCwvoDU1Okro1dacsrcTyzwByI0jIK6gwk7XzdcUeEr7mVqHtbnzrHpxSU6ozhJqcE53ONX/+4XoyM/FJU1XMjV0EAwvzc0SHQC9FtvBAd5Gl8HOQJtZsc/zuehS9+zkR6ZoF5nyBvFR6KDcOfY8PQoQUu+T9yMR8L//sbTmZpAQBdgr2x6E/dER8dYPf3BowfjKeytOYWop8u5KNUp7fYJibEG0O6tMGQTm0QG+XH8UMSqtIboC2vQkGpDgVllSgsrcSNUh0KSiurnxvX3yi9+bigtBLa8spaA+W9VQr4uLvBR+0GjbsbfNwV8FG7mddZPq/e1t24radS7pDdx+RcGICayakC0OWjwP/dZZwTaM5JqWvTogwGERfySnDs0g2kZRbg2KUbOHutCLdmF6Vchu7tfNA7zBfllXpza05eia7esj2UcnRo42kMOW28zI/bB3o2quvoTHYRvvg5E1vSriC/xvv0j/LHuH7hGN0zBB5K215FlV1YjqXfncJ/068CAHzUCsy5pzMeGxgp6XicSr0B6ZkF2Hv2OvaevY5frhRafHB6KOWI7xCAIV3aYHCnNogK9JSsrs5IFEVUVBmgLa9EUXkVisurUFRehaLq59rySmjLKs3B5UapDoXVjwtKdbVa66zlJhdQqW/+x4hMQO2gpHaDr4cb/DyVCPBUws9DCX8vJfw9lPD3VCLASwl3NwYnuokBqJmcKgAVXQOWdQYEGfDKdUDu2pcmF1dU4ZfMAnMgSssssAggt2qrUaNDGy9Et/FEdJCXuTXHVoOZdVUG/HDqGr74ORN7zl43hzMvlQL39w7Fn+PC0Sfct1nvVVGlx5r9F/Dhj7+jVKeHIACP9IvAi0mdEeCAg8bzS3TYd+469py9jr1nc5FbbDl+KDLAA4M7tcHgzm0QHx0ALye53F4URYgiYBBFiID5MVC9TgTEmo9rrCur1JsDy82vxqW4wvK56fXiipuP62uxtIa3SgFfTzf4uivh62FslfH1cIOfh7L6sRK+1et8PW5u4yaXobxSbw5bhWXGwKUtr6r+Wglt2c0gpi2vQmFZJYqqXyssq2xWgFIpZMZw5GkMRabFtM4UnAK8jF99PZSQs6uu1WIAaianCkAGA/BaEGCoBGb/CviGS10jhyKKIjLyS3Es4wZOXNbCS60whp3q1pyWnMsmq7AMm49exhc/X0ZGfql5facgLyT3C8eDfdpZHVh2nc7Bkv+dxIXcEgBA3whfLP5TD/QM09i07vZiMIg4la3F3rO52HM2B0cv3bD4MHSTC4iN9MOQzkEY3DkQ3UJ9bP7fviiKyC/RIauwHFcKypBVUIarheW4WlCGqwVlyCosR2FZpUWIqSvsSE0QjMHaR+0Gb7UCXiqF8avaDb7ubvDzcIPGIsTcDDU+1UFGCuYWLHMgqhGWqluq8kp0uFGqQ37JzSWvRAddlcHq9xMEwM9DCT8PNwR4qhCsUSPczx3h/h4I9/NAuL872vq6S/b9oOZhAGompwpAAPBeb+DGReDx74HIeKlrQ7dhMIg4fCEfX/yciW0nslBR/UdcIRNwd9dgJPcLx+DObRr8L/VibgmW1JjFuY23CvNGxWDMHe2ceiBqcUUVDp7Pw96zxhaimkERMB7noOqB1IM6tYG/p/K2ZZbqqnC1oLw6zJThSkF5dcgpQ1aBMfRUNOGD1JaUChl8zKGlZoAxPr65uJmDjeVrbvBwkzv1ubeWKIoo1ektQpF5KdUhv7j6a4kON6oDU2MvYpAJQKjGHWG3BCPT4yBvlVN8r/UGERVVeuiqDKioMlR/1aOixvNbX6v5XF8jHpiOtub/H0L12rr+J6n5j0rd+wJtvNW4t1eobQ62mlMFoJUrV+Ktt95CVlYWunfvjuXLl2PQoEF1brt//3689NJLOH36NEpLSxEZGYnp06fjhRdeMG+zfv16PP7447X2LSsrg1rduCtPnC4ArbsXuLQfeGgN0PNhqWtDVtCWV+Lb9Kv44udM/HK50Lw+xEeNh2LbYVxcOCIDbo6JKamowopdv+P/bpnFedZdHeGtbn23qriYW1LdVXYdqefzUFZ5czC1IAC92mkwuHMbxEb6obCsElcLypFVaGy5uVL92HQV3O0EeqnQzleNUI2xBaCtrxptfd0RqlEjwFMFQTC+p0wQbn4FgBqPTa8JECDIjH/kBUGAzLSuugwB1etM+znBh2lrUKk3oKC0skYrUgWuFpQhM78MmTdKkZlfiss3bh+IlQoZwnzdEebvUav1KNzPA74ebrdtqRRFEWWVepRU6FGm06NEV4VSXRVKKvSWX3V6lOr0KK0wPb75WqlOfzO46A2oqDRAp78ZavQ26Bq1p74Rvvj6mUSblmnN57ekneubNm3C7NmzsXLlSiQmJuJf//oXRo0ahZMnTyIiIqLW9p6enpg5cyZ69eoFT09P7N+/H9OnT4enpyemTZtm3s7Hxwdnzpyx2Lex4ccpme8Kn9nwduRwfNRueGxgJB4bGIlTWVp88XMmvkm7gmxtOVbsOo8Vu85jQHt/JPcLh0wQ8MZ3p5GtLQdQ/yzOrUlUoCeiAj0xOSEKFVV6HL14A3uqW4dOZxfh+OVCHK8RHOvjpVLUCDTutYJOiEbNK9FcgJtchjbeqgbn6BJFEdeLKqoDURky80tvPr5RiqzCcuiqDPgjtwR/VHc938pbpUA7P+PPV5VBRNmtgaaiCqWV+hbtOpUJgEohh1Ihg0ohg7J6qblOVfM1uQxymbEb0NjRC6BGfU0Pa7ah3FzXuO3aB0h7wYOkLUADBgxA3759sWrVKvO6rl27YsyYMVi6dGmjyhg7diw8PT3xySefADC2AM2ePRsFBQVNrpfTtQD9sATYtwzo9xRw79tS14aaqaJKj50nc7Dp50zsO3e91h9Ja2dxbq2uacvNXWWnsrQI9FKZA40x5Bg/gEJ91fBpha1jJI0qvQFZheW1gpHxeVmtSUEbw0Mph4dSAU9V9VelHB6q6q9KhfF1lRye1Y89Vcav7m5yqNzkUMplULkZQ4vaTQalXG5+bgo3rjIzu1O0AOl0Ohw9ehRz5861WJ+UlITU1NRGlZGWlobU1FS89prlDMjFxcWIjIyEXq/HHXfcgb///e/o06ePzerucMwtQJelrQfZhEohx729QnFvr1BcLSjDV0cv48ujmSgsrcRTgzrgqcHNm8W5tQj2UePPceH4cxwH/lPLUchlxi4vf486Xy+v1ONydTDKKiyHUiGrFWjMQUclh1rhWmO3HIlkASg3Nxd6vR7BwcEW64ODg5Gdnd3gvmFhYbh+/TqqqqqwaNEiTJ061fxaTEwM1q9fj549e0Kr1eK9995DYmIijh8/jk6dOtVZXkVFBSoqbqZ2rVbbjCOTgE91ANIyALU2bX3d8dzwTph1V0eXbu0hchZqNzk6BnmjY5C31FWh25B8go1b/6iLonjbP/T79u1DcXExDh06hLlz56Jjx44YP348AGDgwIEYOHCgedvExET07dsXH3zwAd5///06y1u6dCkWL17czCOREFuAWj2GHyIi25IsAAUGBkIul9dq7cnJyanVKnSr9u3bAwB69uyJa9euYdGiReYAdCuZTIZ+/frh3Llz9ZY3b948zJkzx/xcq9UiPNyJmtU17Yxfy24AuhJAyZl0iYiIGiLZqCilUonY2FikpFjevyolJQUJCQmNLkcURYvuq7peT09PR2ho/XMNqFQq+Pj4WCxORa0BVNV1LrwibV2IiIicgKRdYHPmzMHEiRMRFxeH+Ph4rF69GhkZGZgxYwYAY8vMlStXsGHDBgDAihUrEBERgZiYGADGeYHefvttzJo1y1zm4sWLMXDgQHTq1AlarRbvv/8+0tPTsWLFipY/wJbk0w64rjVeCt+ms9S1ISIicmiSBqDk5GTk5eVhyZIlyMrKQo8ePbBt2zZERkYCALKyspCRkWHe3mAwYN68ebhw4QIUCgWio6PxxhtvYPr06eZtCgoKMG3aNGRnZ0Oj0aBPnz7Yu3cv+vfv3+LH16I0YcD1U4CWLUBERES3I/lM0I7I6eYBAoD/9zxwdD0w5CVg2MtS14aIiKjFWfP57RozI7kC85VgbAEiIiK6HQag1sKHt8MgIiJqLAag1sLUAsQxQERERLfFANRamOYCKryMFr3DHhERkRNiAGotfKoDUFU5UJovbV2IiIgcHANQa6FQAZ5BxsccB0RERNQgBqDWhOOAiIiIGoUBqDWpOQ6IiIiI6sUA1Jpoqm/geu1XaetBRETk4BiAWpOoO41fj20A0j+Xti5EREQOjAGoNYm5F0h4zvj425nA7zulrQ8REZGDYgBqbe5eDPQcBxiqgE2TgKtpUteIiIjI4TAAtTYyGfDACqDDUKCyBPjsz0D+BalrRURE5FAYgFojhRIY9wkQ0hMouQ58OhYoyZW6VkRERA6DAai1UvsAj34F+EYA+X8A/xkH6EqkrhUREZFDYABqzbxDgMe+Btz9gCtHgS8fB/RVUteKiIhIcgxArV1gJ2DCF4DCHTi3HfjfbN4slYiIXB4DkCsI7w88vBYQZEDaJ8DupVLXiIiISFIMQK4iZjRw7zvGx3veBH5eJ219iIiIJMQA5EriHgeGvGR8vHUOcHqbtPUhIiKSCAOQqxk6D+gzERANwFdPAJk/SV0jIiKiFscA5GoEAbhvOdBpBFBVBvwnGcg9J3WtiIiIWhQDkCuSK4A/rwPaxQJl+caJEouypa4VERFRi2EAclVKT+Pl8f7RQEEG8NnDQLlW6loRERG1CAYgV+YZCDy2GfBsA2SfADY9BlTppK4VERGR3TEAuTr/9sCjXwJKL+DCHuC/zwIGg9S1IiIisisGIALa9gHGbQBkCuDEF8DOhVLXiIiIyK4YgMio43DgTx8aH6e+DxxaJW19iIiI7IgBiG66YzwwvLr15/t5wK9fS1sfIiIiO2EAIkt3vgD0ewqACGyZDlzcL3WNiIiIbI4BiCwJAjDqTaDr/YBeB3w+Abj2m9S1IiIisikGIKpNJgfG/huIiAcqCoFPHwYKL0tdKyIiIpthAKK6ubkD4z8H2sQARVeBTx8Cym5IXavmKbvBeY5aWkUxcHwj8OXjwNYXgfT/ADmnAINe6poR2VdpPnDpoPErOSSF1BUgB+buZ5wo8f/uAa6fNnaHTdwCuKmlrlnjGPTAlaPA2e3Aue3GyR7lSiC4u/HSf9PSJgaQu0ld29ZDXwVc2A0c3wSc/h9QWXrztSPVX908gdDelufBvwMg4/9k5IREEbhxEcg8DGQcBDIOGf9mAgAE4893h6FA9DAgfACgUElYWTIRRFEUpa6Eo9FqtdBoNCgsLISPj4/U1ZHetd+AtaOM3WEx9wHDXjaGBplc6prVVlYAnP/BGHp+3wmU5t1+H4UaCOlp/CMVekd1KOrimMfnqEQRyP7FGHp+/QoovnbzNf8OQI+HgMoy4MoxIOs4UFlSuwyVBmhbMxT1BXwjjOPSiByJvgq49qsx6JgCT3Ed91P0Cqm9XuEORCYYw1CHoUBQdwZ/G7Lm85sBqA4MQHW4sM9401R9dReS0hto1xcI7w+E9TMuHv4tXy9RNP6ndXY7cG6H8Q+RWKN7RaUBOt4FdBoBdLzb+MF7Na3GctwY7G7l5gGE9LJsoQjoyD9Utyq8Ypw88/gm4Pqpm+vd/Yyhp9cjQFicZYgx6IHcc8DVYzfPQ/YJoKq8dvnu/sbvfbu+N8+DdyhDEbWsimLgys83A8/lnwFdseU2Mjfjz2fEQOP4yfABgGcAoM0C/tgN/LHL+LXmPweA8VZEHYZWL8MATbuWOaZWigGomRiA6nH+R2D/u8b/4m/95QeMAcEUhsL7A0Hd7NOKUllmvDz/7PfA2R1AYYbl64FdgM5JxtATMbDh7i2DAbhxoUYgSgey0us+PqV3dbfNHZbdNq72YVyuBU59C/yyyRiMUf0nRK4Cuow0hp6OdwMKZePL1FcaxwbVDKfXfgMMlbW39Qo2tg7VDKdebWxyaK2GrtT4QVucA5TmGs+NygtQeRtve6PyNi7s+q1bUXZ12KkOPNknLP+xAoz/XEUMMAadiHhjSHdzb7hcUTT+nJvC0MUDtVtDAzpVtw4NA6LuBNT8DLIGA1AzMQDdhkFv/CW+/BOQeQS4fATIO1d7OzfPGq1E1S1FngFNe8/Cyzdbef7YA1SV3XxNrgLaDzIGns5JgF9U097DxGAA8n63/DDOOm75niZqzc1us9BegHdbwCPAuLj7tp5uNH2VMQD/shE4vc3yexGRAPROBrqNMR6zrVRVGLsZaobTnFO1P4gAY6uQV7CxFdL8/fevfn7rugDnGcdWk0Fv7NItvmZciq7dDDnF2dVfq59XaBtXpkJdOxSZlsauc/MwliWKAMRmfsXNr6Z1gmC8TY9MYQxstR67Na9lVhSB3LPVXVnVY3huXKi9nSa8unWnuoWnTdfmtwhX6Yx/R//YDZzfZWwVFWvci1GQG1tQO1R3l4XF2Ta0VpYZhw2U3QDKq7+anpfdMLb4CzLLRSavfixUf5XXs41wy/pbtpPJjL+LHYba7njAANRsDEBNUJpvbBa+fMT4C335KKArqr2df4fqMBRX3UrUHZDXMRbfoDeWdXa7ccm5ZS4in3ZApySg8wig/WBA6Wmf4zLRVxn/SNYMRdknAH1F/fsIMmNXkOnD1yOg+sM48JZ1ATc/pFXejtOiJIrG4/xlE/DrZqDk+s3XAjoZQ0/PcYBfZMvVSVdq/L5fTbvZhZZ7DuZWqMZy87j5fTeFIoug5Ge5TulVT0H1vK81f1ZF0fjhUyvI3BJySq7XHf7qo1AbQ6FnoPGDrKIYqCgytm7W1d3o1ATLQCRX1AhH8vpfEwRjqC679UotAQjuUSPwDAQ0YfY/jLIC4OI+Yxj6YzeQf97ydaWXsVWowzBjK1FgZ2NgKi+0DC+3hhnz81vWSf1zENYfmJpi0yIZgJqJAcgGDHrg+hnLVqLcM7W3c/MwdmeE9zP+MuhKjFds/b7T8rJ7QWZsQTKFnuAe0gcFfaVx/FHNLpuS68b/0svrGFfUGHJl7VDkEWAMTe5+xuZwi//ANTX+E3e3zfekIAP45Qtj8Mk9e3O9RyDQ82GgV7KxxUvq779JudZYz9I8YxAvzTN+oJXmVS83LNcZqqSucTMIxkDjFVxjCTJ+9b5lncqn/nOkrzSGIVMgMj2ub53F82JjC5NpnWlcYF11FYQmfq1RBkTj3xN9pbFLtGYLia0o1EC7uBrjd/oZW3elVpBxMwz9sbt2UFO4190ybQ1BBqh9jX9f3Ku/mp4rVMaALhpqLPpbnle/brh1fQOLads2McC9bzev/rdgAGomBiA7KbthbBmq2UpU1wBkE7WvcSxJ5+oBzFIMsm4qfaXxeEvzgJLcGh/Gpg/mOtbVvFy8KWSKGsHI55av1Yva55Z1Pje7NjIOGoPPpRq3P1GogZh7jaEn+i7nHzMiisYP79J842IRlGqGp3zLdXWNRbIlN4/qEBNyM9DcGnK8Q4whtK4WUymZ53SqDjD2DsYGgzHEGqqM50Vf47Ghqvq56XGlsX6GyurHVTcX03PfSOPYPmvGrEnBYDBeaWkaUH3poGULtNK7OsD41h9o6nqu9G5VF3c4VQBauXIl3nrrLWRlZaF79+5Yvnw5Bg0aVOe2+/fvx0svvYTTp0+jtLQUkZGRmD59Ol544QWL7TZv3owFCxbg/PnziI6Oxuuvv44HH3yw0XViAGohBoPxP/fLPwGZPxnn7BHkxjvTdx5pbPFxtD/29qQrrfFhXDMsVQemshuW/5WXa6sfa2F1F1CDBGMze+9HgK5/4iBMUTR+WN72g72B12+3b2sZK0Ytp7IM0F41tlSpNc7/z4mNWPP5Lemny6ZNmzB79mysXLkSiYmJ+Ne//oVRo0bh5MmTiIiIqLW9p6cnZs6ciV69esHT0xP79+/H9OnT4enpiWnTpgEADh48iOTkZPz973/Hgw8+iC1btmDcuHHYv38/BgwY0NKHSA2RyYCgGOPSd5LUtZGe0sO4+IZbt58oGrsOK7Q1ApK2RkCqsa5CW0+IKjKOcej5MNBrXMuMd3AWguD4rQPketzcgYBoqWvh1CRtARowYAD69u2LVatWmdd17doVY8aMwdKlSxtVxtixY+Hp6YlPPvkEAJCcnAytVovvvvvOvM3IkSPh5+eHzz//vFFlsgWIiIjI+Vjz+S1Zx59Op8PRo0eRlJRksT4pKQmpqamNKiMtLQ2pqakYMmSIed3BgwdrlTlixIgGy6yoqIBWq7VYiIiIqPWSLADl5uZCr9cjODjYYn1wcDCys+uYUryGsLAwqFQqxMXF4dlnn8XUqVPNr2VnZ1td5tKlS6HRaMxLeLiVXRBERETkVCQf+i3cMjhQFMVa6261b98+/Pzzz/joo4+wfPnyWl1b1pY5b948FBYWmpfMzEwrj4KIiIiciWSDoAMDAyGXy2u1zOTk5NRqwblV+/btAQA9e/bEtWvXsGjRIowfPx4AEBISYnWZKpUKKhXvzktEROQqJGsBUiqViI2NRUqK5SyQKSkpSEhIaHQ5oiiiouLmXAjx8fG1ytyxY4dVZRIREVHrJull8HPmzMHEiRMRFxeH+Ph4rF69GhkZGZgxYwYAY9fUlStXsGHDBgDAihUrEBERgZiYGADGeYHefvttzJo1y1zm888/j8GDB+PNN9/EAw88gP/+97/YuXMn9u/fX7sCRERE5JIkDUDJycnIy8vDkiVLkJWVhR49emDbtm2IjDTeWygrKwsZGTfv9G0wGDBv3jxcuHABCoUC0dHReOONNzB9+nTzNgkJCdi4cSNeeeUVLFiwANHR0di0aRPnACIiIiIzyWeCdkScB4iIiMj5OMU8QERERERSYQAiIiIil8MARERERC6HAYiIiIhcDgMQERERuRwGICIiInI5ks4D5KhMMwPwrvBERETOw/S53ZgZfhiA6lBUVAQAvCs8ERGREyoqKoJGo2lwG06EWAeDwYCrV6/C29v7tnemt5ZWq0V4eDgyMzNb/SSLPNbWy5WOl8faernS8brKsYqiiKKiIrRt2xYyWcOjfNgCVAeZTIawsDC7voePj0+r/iGsicfaernS8fJYWy9XOl5XONbbtfyYcBA0ERERuRwGICIiInI5DEAtTKVSYeHChVCpVFJXxe54rK2XKx0vj7X1cqXjdaVjbSwOgiYiIiKXwxYgIiIicjkMQERERORyGICIiIjI5TAAERERkcthALKDlStXon379lCr1YiNjcW+ffsa3H7Pnj2IjY2FWq1Ghw4d8NFHH7VQTZtu6dKl6NevH7y9vREUFIQxY8bgzJkzDe6ze/duCIJQazl9+nQL1bppFi1aVKvOISEhDe7jjOfUJCoqqs7z9Oyzz9a5vTOd17179+L+++9H27ZtIQgCvvnmG4vXRVHEokWL0LZtW7i7u2Po0KH47bffblvu5s2b0a1bN6hUKnTr1g1btmyx0xFYp6HjraysxEsvvYSePXvC09MTbdu2xaRJk3D16tUGy1y/fn2d57u8vNzOR9Ow253bKVOm1KrzwIEDb1uuI57b2x1rXedHEAS89dZb9ZbpqOfVnhiAbGzTpk2YPXs25s+fj7S0NAwaNAijRo1CRkZGndtfuHABo0ePxqBBg5CWloaXX34Zzz33HDZv3tzCNbfOnj178Oyzz+LQoUNISUlBVVUVkpKSUFJSctt9z5w5g6ysLPPSqVOnFqhx83Tv3t2izidOnKh3W2c9pyZHjhyxONaUlBQAwJ///OcG93OG81pSUoLevXvjww8/rPP1f/7zn3jnnXfw4Ycf4siRIwgJCcE999xjvj9gXQ4ePIjk5GRMnDgRx48fx8SJEzFu3DgcPnzYXofRaA0db2lpKY4dO4YFCxbg2LFj+Prrr3H27Fn86U9/um25Pj4+Fuc6KysLarXaHofQaLc7twAwcuRIizpv27atwTId9dze7lhvPTdr166FIAh46KGHGizXEc+rXYlkU/379xdnzJhhsS4mJkacO3dundv/7W9/E2NiYizWTZ8+XRw4cKDd6mgPOTk5IgBxz5499W6za9cuEYB448aNlquYDSxcuFDs3bt3o7dvLefU5Pnnnxejo6NFg8FQ5+vOel4BiFu2bDE/NxgMYkhIiPjGG2+Y15WXl4sajUb86KOP6i1n3Lhx4siRIy3WjRgxQnzkkUdsXufmuPV46/LTTz+JAMRLly7Vu826detEjUZj28rZWF3HOnnyZPGBBx6wqhxnOLeNOa8PPPCAeNdddzW4jTOcV1tjC5AN6XQ6HD16FElJSRbrk5KSkJqaWuc+Bw8erLX9iBEj8PPPP6OystJudbW1wsJCAIC/v/9tt+3Tpw9CQ0MxfPhw7Nq1y95Vs4lz586hbdu2aN++PR555BH88ccf9W7bWs4pYPyZ/vTTT/HEE0/c9sbAznhea7pw4QKys7Mtzp1KpcKQIUPq/f0F6j/fDe3jqAoLCyEIAnx9fRvcrri4GJGRkQgLC8N9992HtLS0lqlgM+3evRtBQUHo3LkznnrqKeTk5DS4fWs4t9euXcPWrVvx5JNP3nZbZz2vTcUAZEO5ubnQ6/UIDg62WB8cHIzs7Ow698nOzq5z+6qqKuTm5tqtrrYkiiLmzJmDO++8Ez169Kh3u9DQUKxevRqbN2/G119/jS5dumD48OHYu3dvC9bWegMGDMCGDRuwfft2/Pvf/0Z2djYSEhKQl5dX5/at4ZyafPPNNygoKMCUKVPq3cZZz+utTL+j1vz+mvazdh9HVF5ejrlz52LChAkN3iwzJiYG69evx7fffovPP/8carUaiYmJOHfuXAvW1nqjRo3CZ599hh9//BHLli3DkSNHcNddd6GioqLefVrDuf3444/h7e2NsWPHNrids57X5uDd4O3g1v+URVFs8L/nurava72jmjlzJn755Rfs37+/we26dOmCLl26mJ/Hx8cjMzMTb7/9NgYPHmzvajbZqFGjzI979uyJ+Ph4REdH4+OPP8acOXPq3MfZz6nJmjVrMGrUKLRt27bebZz1vNbH2t/fpu7jSCorK/HII4/AYDBg5cqVDW47cOBAi8HDiYmJ6Nu3Lz744AO8//779q5qkyUnJ5sf9+jRA3FxcYiMjMTWrVsbDAfOfm7Xrl2LRx999LZjeZz1vDYHW4BsKDAwEHK5vNZ/Bzk5ObX+izAJCQmpc3uFQoGAgAC71dVWZs2ahW+//Ra7du1CWFiY1fsPHDjQ6f7D8PT0RM+ePeutt7OfU5NLly5h586dmDp1qtX7OuN5NV3ZZ83vr2k/a/dxJJWVlRg3bhwuXLiAlJSUBlt/6iKTydCvXz+nO9+hoaGIjIxssN7Ofm737duHM2fONOl32FnPqzUYgGxIqVQiNjbWfNWMSUpKChISEurcJz4+vtb2O3bsQFxcHNzc3OxW1+YSRREzZ87E119/jR9//BHt27dvUjlpaWkIDQ21ce3sq6KiAqdOnaq33s56Tm+1bt06BAUF4d5777V6X2c8r+3bt0dISIjFudPpdNizZ0+9v79A/ee7oX0chSn8nDt3Djt37mxSQBdFEenp6U53vvPy8pCZmdlgvZ353ALGFtzY2Fj07t3b6n2d9bxaRarR163Vxo0bRTc3N3HNmjXiyZMnxdmzZ4uenp7ixYsXRVEUxblz54oTJ040b//HH3+IHh4e4gsvvCCePHlSXLNmjejm5iZ+9dVXUh1Cozz99NOiRqMRd+/eLWZlZZmX0tJS8za3Huu7774rbtmyRTx79qz466+/inPnzhUBiJs3b5biEBrtL3/5i7h7927xjz/+EA8dOiTed999ore3d6s7pzXp9XoxIiJCfOmll2q95szntaioSExLSxPT0tJEAOI777wjpqWlma96euONN0SNRiN+/fXX4okTJ8Tx48eLoaGholarNZcxceJEi6s6Dxw4IMrlcvGNN94QT506Jb7xxhuiQqEQDx061OLHd6uGjreyslL805/+JIaFhYnp6ekWv8cVFRXmMm493kWLFonff/+9eP78eTEtLU18/PHHRYVCIR4+fFiKQzRr6FiLiorEv/zlL2Jqaqp44cIFcdeuXWJ8fLzYrl07pzy3t/s5FkVRLCwsFD08PMRVq1bVWYaznFd7YgCygxUrVoiRkZGiUqkU+/bta3Fp+OTJk8UhQ4ZYbL97926xT58+olKpFKOiour9gXUkAOpc1q1bZ97m1mN98803xejoaFGtVot+fn7inXfeKW7durXlK2+l5ORkMTQ0VHRzcxPbtm0rjh07Vvztt9/Mr7eWc1rT9u3bRQDimTNnar3mzOfVdMn+rcvkyZNFUTReCr9w4UIxJCREVKlU4uDBg8UTJ05YlDFkyBDz9iZffvml2KVLF9HNzU2MiYlxmPDX0PFeuHCh3t/jXbt2mcu49Xhnz54tRkREiEqlUmzTpo2YlJQkpqamtvzB3aKhYy0tLRWTkpLENm3aiG5ubmJERIQ4efJkMSMjw6IMZzm3t/s5FkVR/Ne//iW6u7uLBQUFdZbhLOfVngRRrB6dSUREROQiOAaIiIiIXA4DEBEREbkcBiAiIiJyOQxARERE5HIYgIiIiMjlMAARERGRy2EAIiIiIpfDAEREVA9BEPDNN99IXQ0isgMGICJySFOmTIEgCLWWkSNHSl01ImoFFFJXgIioPiNHjsS6dess1qlUKolqQ0StCVuAiMhhqVQqhISEWCx+fn4AjN1Tq1atwqhRo+Du7o727dvjyy+/tNj/xIkTuOuuu+Du7o6AgABMmzYNxcXFFtusXbsW3bt3h0qlQmhoKGbOnGnxem5uLh588EF4eHigU6dO+Pbbb82v3bhxA48++ijatGkDd3d3dOrUqVZgIyLHxABERE5rwYIFeOihh3D8+HE89thjGD9+PE6dOgUAKC0txciRI+Hn54cjR47gyy+/xM6dOy0CzqpVq/Dss89i2rRpOHHiBL799lt07NjR4j0WL16McePG4ZdffsHo0aPx6KOPIj8/3/z+J0+exHfffYdTp05h1apVCAwMbLlvABE1ndR3YyUiqsvkyZNFuVwuenp6WixLliwRRVEUAYgzZsyw2GfAgAHi008/LYqiKK5evVr08/MTi4uLza9v3bpVlMlkYnZ2tiiKoti2bVtx/vz59dYBgPjKK6+YnxcXF4uCIIjfffedKIqieP/994uPP/64bQ6YiFoUxwARkcMaNmwYVq1aZbHO39/f/Dg+Pt7itfj4eKSnpwMATp06hd69e8PT09P8emJiIgwGA86cOQNBEHD16lUMHz68wTr06tXL/NjT0xPe3t7IyckBADz99NN46KGHcOzYMSQlJWHMmDFISEho0rESUctiACIih+Xp6VmrS+p2BEEAAIiiaH5c1zbu7u6NKs/Nza3WvgaDAQAwatQoXLp0CVu3bsXOnTsxfPhwPPvss3j77betqjMRtTyOASIip3Xo0KFaz2NiYgAA3bp1Q3p6OkpKSsyvHzhwADKZDJ07d4a3tzeioqLwww8/NKsObdq0wZQpU/Dpp59i+fLlWL16dbPKI6KWwRYgInJYFRUVyM7OtlinUCjMA42//PJLxMXF4c4778Rnn32Gn376CWvWrAEAPProo1i4cCEmT56MRYsW4fr165g1axYmTpyI4OBgAMCiRYswY8YMBAUFYdSoUSgqKsKBAwcwa9asRtXv1VdfRWxsLLp3746Kigr873//Q9euXW34HSAie2EAIiKH9f333yM0NNRiXZcuXXD69GkAxiu0Nm7ciGeeeQYhISH47LPP0K1bNwCAh4cHtm/fjueffx79+vWDh4cHHnroIbzzzjvmsiZPnozy8nK8++67ePHFFxEYGIiHH3640fVTKpWYN28eLl68CHd3dwwaNAgbN260wZETkb0JoiiKUleCiMhagiBgy5YtGDNmjNRVISInxDFARERE5HIYgIiIiMjlcAwQETkl9t4TUXOwBYiIiIhcDgMQERERuRwGICIiInI5DEBERETkchiAiIiIyOUwABEREZHLYQAiIiIil8MARERERC6HAYiIiIhczv8HtoKWXUb9basAAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Train the LSTM model\n", + "history = model.fit(X_train, y_train, epochs=20, batch_size=32, validation_data=(X_test, y_test))\n", + "\n", + "# Visualize training and validation accuracy\n", + "plt.plot(history.history['accuracy'], label='Train Accuracy')\n", + "plt.plot(history.history['val_accuracy'], label='Validation Accuracy')\n", + "plt.title('Model Accuracy')\n", + "plt.xlabel('Epochs')\n", + "plt.ylabel('Accuracy')\n", + "plt.legend()\n", + "plt.show()\n", + "\n", + "# Visualize training and validation loss\n", + "plt.plot(history.history['loss'], label='Train Loss')\n", + "plt.plot(history.history['val_loss'], label='Validation Loss')\n", + "plt.title('Model Loss')\n", + "plt.xlabel('Epochs')\n", + "plt.ylabel('Loss')\n", + "plt.legend()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "862f2d04-36b1-4d4c-b628-e0df5ff2a9b9", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m3/3\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 7ms/step - accuracy: 0.9006 - loss: 0.3125 \n", + "Test Accuracy: 90.28%\n" + ] + } + ], + "source": [ + "# Evaluate the model\n", + "test_loss, test_accuracy = model.evaluate(X_test, y_test)\n", + "print(f'Test Accuracy: {test_accuracy*100:.2f}%')" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "37b33d7a-1040-4483-8cf5-358c11651bf5", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m3/3\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 280ms/step\n", + "Predicted: [0 0 0 0 0 0 0 0 0 0]\n", + "Actual: [0 0 0 0 1 0 0 0 0 0]\n" + ] + } + ], + "source": [ + "# Predict on test data\n", + "y_pred = model.predict(X_test)\n", + "\n", + "# Convert predictions to binary (accident or no accident)\n", + "y_pred_binary = (y_pred > 0.5).astype(int)\n", + "\n", + "# Example: Comparing the predicted and actual values for the first 10 test cases\n", + "print(f\"Predicted: {y_pred_binary[:10].flatten()}\")\n", + "print(f\"Actual: {y_test[:10]}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "df917308-4720-40f1-b2d7-9d450c6c7914", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import seaborn as sns\n", + "\n", + "# Plot the relationship between traffic volume and accidents\n", + "sns.scatterplot(x=df['traffic_volume'], y=df['accident_occurred'])\n", + "plt.title('Traffic Volume vs. Accident Occurrence')\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "b02e4f00-ce5b-4a7d-bc26-10418e7dfe00", + "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.11.7" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +}