traffic_signs.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Traffic Sign Recognition using Deep Learning\n",
    "## A Comprehensive Analysis of CNN Architectures for Traffic Sign Classification\n",
    "\n",
    "### Project Overview\n",
    "This notebook implements and analyzes various deep learning approaches for traffic sign recognition, comparing different architectures and evaluating their real-world applicability. The project demonstrates both theoretical understanding and practical considerations for production deployment.\n",
    "\n",
    "### Import Required Libraries"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [],
   "source": [
    "# !pip install -r requirements.txt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "import cv2\n",
    "import numpy as np\n",
    "import os\n",
    "import sys\n",
    "import tensorflow as tf\n",
    "from tensorflow.keras.applications import ResNet50, MobileNetV2 # type: ignore\n",
    "from tensorflow.keras.preprocessing.image import ImageDataGenerator # type: ignore\n",
    "from sklearn.model_selection import train_test_split\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "import time\n",
    "import psutil\n",
    "from datetime import datetime\n",
    "import pandas as pd\n",
    "\n",
    "# Suppress warnings\n",
    "import warnings\n",
    "warnings.filterwarnings('ignore')\n",
    "\n",
    "# Set random seeds for reproducibility\n",
    "np.random.seed(42)\n",
    "tf.random.set_seed(42)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Configuration Parameters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "EPOCHS = 10\n",
    "IMG_WIDTH = 32\n",
    "IMG_HEIGHT = 32\n",
    "NUM_CATEGORIES = 43\n",
    "TEST_SIZE = 0.4\n",
    "BATCH_SIZE = 32"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Data Loading and Preprocessing\n",
    "\n",
    "I designed a custom load_data function to load and preprocess images from categorized folders. The function resizes, normalizes, and organizes images and labels to enable seamless data loading."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "def load_data(data_dir):\n",
    "    \"\"\"\n",
    "    Load and preprocess image data from directory.\n",
    "    \n",
    "    Parameters:\n",
    "    data_dir (str): Directory containing categorized images\n",
    "    \n",
    "    Returns:\n",
    "    tuple: (preprocessed images, labels)\n",
    "    \"\"\"\n",
    "    images = []\n",
    "    labels = []\n",
    "    for num in range(NUM_CATEGORIES):\n",
    "        cat = os.path.join(data_dir, str(num))\n",
    "        print(f\"Loading category {num}...\", end='\\r')\n",
    "        for f in os.listdir(cat):\n",
    "            img_dir = os.path.join(cat, f)\n",
    "            img = cv2.imread(img_dir)\n",
    "            if img is not None:\n",
    "                img = cv2.resize(img, (IMG_WIDTH, IMG_HEIGHT))\n",
    "                img = img / 255.0  # Normalize pixel values\n",
    "                images.append(img)\n",
    "                labels.append(num)\n",
    "    print(\"\\nData loading completed!\")\n",
    "    return np.array(images), np.array(labels)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Data Analysis and Visualization\n",
    "I created a visualization function to explore class distribution and sample images from the dataset."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "def analyze_data(images, labels):\n",
    "    \"\"\"\n",
    "    Perform comprehensive data analysis and visualization.\n",
    "    \"\"\"\n",
    "    # Create a figure with multiple subplots\n",
    "    fig = plt.figure(figsize=(15, 10))\n",
    "    \n",
    "    # 1. Class Distribution\n",
    "    plt.subplot(2, 2, 1)\n",
    "    sns.histplot(labels, bins=NUM_CATEGORIES)\n",
    "    plt.title('Class Distribution')\n",
    "    plt.xlabel('Category')\n",
    "    plt.ylabel('Count')\n",
    "    \n",
    "    # 2. Sample Images\n",
    "    plt.subplot(2, 2, 2)\n",
    "    random_indices = np.random.choice(len(images), 9)\n",
    "    for idx, i in enumerate(random_indices):\n",
    "        plt.subplot(2, 2, 2 + idx//3)\n",
    "        plt.imshow(images[i])\n",
    "        plt.title(f'Category: {labels[i]}')\n",
    "        plt.axis('off')\n",
    "    \n",
    "    plt.tight_layout()\n",
    "    plt.savefig('data_analysis.png')\n",
    "    plt.show()\n",
    "    \n",
    "    # Print summary statistics\n",
    "    print(\"\\nData Summary:\")\n",
    "    print(f\"Total images: {len(images)}\")\n",
    "    print(f\"Number of classes: {NUM_CATEGORIES}\")\n",
    "    print(f\"Images per class (avg): {len(images)/NUM_CATEGORIES:.2f}\")\n",
    "    print(f\"Image dimensions: {IMG_WIDTH}x{IMG_HEIGHT}x3\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Model Architectures\n",
    "Designed a custom CNN architecture with regularization and dropout for this project and implemented transfer learning using ResNet50 and MobileNetV2."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_custom_cnn():\n",
    "    \"\"\"\n",
    "    Custom CNN architecture with regularization and dropout.\n",
    "    \"\"\"\n",
    "    model = tf.keras.Sequential([\n",
    "        # First Convolutional Block\n",
    "        tf.keras.layers.Conv2D(32, (3, 3), activation='relu', input_shape=(IMG_WIDTH, IMG_HEIGHT, 3)),\n",
    "        tf.keras.layers.BatchNormalization(),\n",
    "        tf.keras.layers.MaxPooling2D((2, 2)),\n",
    "        \n",
    "        # Second Convolutional Block\n",
    "        tf.keras.layers.Conv2D(64, (3, 3), activation='relu'),\n",
    "        tf.keras.layers.BatchNormalization(),\n",
    "        tf.keras.layers.MaxPooling2D((2, 2)),\n",
    "        \n",
    "        # Third Convolutional Block\n",
    "        tf.keras.layers.Conv2D(128, (3, 3), activation='relu'),\n",
    "        tf.keras.layers.BatchNormalization(),\n",
    "        tf.keras.layers.MaxPooling2D((2, 2)),\n",
    "        \n",
    "        # Dense Layers\n",
    "        tf.keras.layers.Flatten(),\n",
    "        tf.keras.layers.Dense(512, activation='relu'),\n",
    "        tf.keras.layers.BatchNormalization(),\n",
    "        tf.keras.layers.Dropout(0.5),\n",
    "        tf.keras.layers.Dense(NUM_CATEGORIES, activation='softmax')\n",
    "    ])\n",
    "    \n",
    "    model.compile(\n",
    "        optimizer='adam',\n",
    "        loss='categorical_crossentropy',\n",
    "        metrics=['accuracy']\n",
    "    )\n",
    "    \n",
    "    return model\n",
    "\n",
    "\n",
    "def create_transfer_model(base_model_class, model_name):\n",
    "    \"\"\"\n",
    "    Create a transfer learning model using pretrained architecture.\n",
    "    \"\"\"\n",
    "    base = base_model_class(\n",
    "        weights='imagenet',\n",
    "        include_top=False,\n",
    "        input_shape=(IMG_WIDTH, IMG_HEIGHT, 3)\n",
    "    )\n",
    "    base.trainable = False\n",
    "    \n",
    "    model = tf.keras.Sequential([\n",
    "        base,\n",
    "        tf.keras.layers.GlobalAveragePooling2D(),\n",
    "        tf.keras.layers.Dense(512, activation='relu'),\n",
    "        tf.keras.layers.BatchNormalization(),\n",
    "        tf.keras.layers.Dropout(0.5),\n",
    "        tf.keras.layers.Dense(NUM_CATEGORIES, activation='softmax')\n",
    "    ])\n",
    "    \n",
    "    model.compile(\n",
    "        optimizer='adam',\n",
    "        loss='categorical_crossentropy',\n",
    "        metrics=['accuracy']\n",
    "    )\n",
    "    \n",
    "    return model"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Data Augmentation\n",
    "To prevent overfitting, I applied data augmentation using rotation, zoom, shift, and fill strategies to simulate diverse training scenarios."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "def create_data_generator():\n",
    "    \"\"\"\n",
    "    Create data generator for training augmentation.\n",
    "    \"\"\"\n",
    "    return ImageDataGenerator(\n",
    "        rotation_range=10,\n",
    "        zoom_range=0.15,\n",
    "        width_shift_range=0.1,\n",
    "        height_shift_range=0.1,\n",
    "        horizontal_flip=False,\n",
    "        fill_mode='nearest',\n",
    "        validation_split=0.2\n",
    "    )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Model Evaluation and Metrics"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "def evaluate_model_metrics(model, x_test):\n",
    "    \"\"\"\n",
    "    Evaluate model performance metrics including inference time and resource usage.\n",
    "    \"\"\"\n",
    "    # Warm-up run\n",
    "    model.predict(x_test[:10])\n",
    "    \n",
    "    # Measure inference time\n",
    "    start_time = time.time()\n",
    "    model.predict(x_test[:100])\n",
    "    inference_time = (time.time() - start_time) / 100\n",
    "    \n",
    "    # Get model size\n",
    "    model.save('temp_model.h5')\n",
    "    model_size = os.path.getsize('temp_model.h5') / (1024 * 1024)  # Size in MB\n",
    "    os.remove('temp_model.h5')\n",
    "    \n",
    "    # Measure memory usage\n",
    "    memory_usage = psutil.Process().memory_info().rss / (1024 * 1024)  # MB\n",
    "    \n",
    "    return {\n",
    "        'inference_time': inference_time,\n",
    "        'model_size': model_size,\n",
    "        'memory_usage': memory_usage\n",
    "    }\n",
    "\n",
    "def experiment_with_models(x_train, y_train, x_test, y_test):\n",
    "    \"\"\"\n",
    "    Train and compare different model architectures.\n",
    "    \"\"\"\n",
    "    models = {\n",
    "        'Custom CNN': get_custom_cnn(),\n",
    "        'ResNet50': create_transfer_model(ResNet50, 'resnet50'),\n",
    "        'MobileNetV2': create_transfer_model(MobileNetV2, 'mobilenetv2')\n",
    "    }\n",
    "    \n",
    "    results = {}\n",
    "    histories = {}\n",
    "    \n",
    "    for name, model in models.items():\n",
    "        print(f\"\\nTraining {name}...\")\n",
    "        history = model.fit(\n",
    "            x_train, y_train,\n",
    "            epochs=EPOCHS,\n",
    "            validation_split=0.2,\n",
    "            batch_size=BATCH_SIZE\n",
    "        )\n",
    "        \n",
    "        # Evaluate model\n",
    "        test_loss, test_accuracy = model.evaluate(x_test, y_test, verbose=0)\n",
    "        metrics = evaluate_model_metrics(model, x_test)\n",
    "        \n",
    "        results[name] = {\n",
    "            'test_accuracy': test_accuracy,\n",
    "            'test_loss': test_loss,\n",
    "            **metrics\n",
    "        }\n",
    "        histories[name] = history.history\n",
    "    \n",
    "    return results, histories"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Visualization and Results Analysis"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_training_histories(histories):\n",
    "    \"\"\"\n",
    "    Plot training histories for all models.\n",
    "    \"\"\"\n",
    "    fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(15, 5))\n",
    "    \n",
    "    for name, history in histories.items():\n",
    "        ax1.plot(history['accuracy'], label=f'{name} (train)')\n",
    "        ax1.plot(history['val_accuracy'], label=f'{name} (val)')\n",
    "    \n",
    "    ax1.set_title('Model Accuracy over Epochs')\n",
    "    ax1.set_xlabel('Epoch')\n",
    "    ax1.set_ylabel('Accuracy')\n",
    "    ax1.legend()\n",
    "    \n",
    "    for name, history in histories.items():\n",
    "        ax2.plot(history['loss'], label=f'{name} (train)')\n",
    "        ax2.plot(history['val_loss'], label=f'{name} (val)')\n",
    "    \n",
    "    ax2.set_title('Model Loss over Epochs')\n",
    "    ax2.set_xlabel('Epoch')\n",
    "    ax2.set_ylabel('Loss')\n",
    "    ax2.legend()\n",
    "    \n",
    "    plt.tight_layout()\n",
    "    plt.savefig('training_history.png')\n",
    "    plt.show()\n",
    "\n",
    "def display_results(results):\n",
    "    \"\"\"\n",
    "    Display and compare model results in a formatted table.\n",
    "    \"\"\"\n",
    "    df = pd.DataFrame(results).T\n",
    "    df = df.round(4)\n",
    "    \n",
    "    print(\"\\nModel Comparison Results:\")\n",
    "    print(df.to_markdown())\n",
    "    \n",
    "    # Save results\n",
    "    df.to_csv('model_comparison_results.csv')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Main Execution"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Loading data...\n",
      "Loading category 42...\n",
      "Data loading completed!\n",
      "\n",
      "Analyzing data distribution...\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAABTgAAAPeCAYAAAAoJHVeAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8hTgPZAAAACXBIWXMAAA9hAAAPYQGoP6dpAACnUUlEQVR4nOzde3wU1f3/8ffuZrMJuRIgCREIIIhcBBSUIl5QgoigonhBKRelYhWoiNWWtiLghXpDBBHUVmy/BW1VVEQFEfAGiAhFRUFFEVTIhUsSErKbze78/uDH1jXc5pDbwOv5eOzjwc6cz3zOzM5Ohs+emXFZlmUJAAAAAAAAABzIXdsdAAAAAAAAAABTFDgBAAAAAAAAOBYFTgAAAAAAAACORYETAAAAAAAAgGNR4AQAAAAAAADgWBQ4AQAAAAAAADgWBU4AAAAAAAAAjkWBEwAAAAAAAIBjUeAEAAAAAAAA4FgUOAHgBNW8eXMNHz68trtxzCZOnCiXy1UjuXr27KmePXtG3r/77rtyuVx66aWXaiT/8OHD1bx58xrJBQAAAABOQYETAI4z3377rW6++Wa1bNlScXFxSk5OVo8ePfT444+rrKystrt3WM8995xcLlfkFRcXp6ysLPXp00fTp0/X3r17qyTP9u3bNXHiRK1fv75KlleV6nLfAAAAqltVn8s++eSTeu6556q+ow5UWFio9PT0Gv2BHqgpMbXdAQBA1XnjjTd09dVXy+fzaejQoerQoYPKy8v14Ycf6s4779QXX3yhp59+ura7eUSTJ09WixYtFAwGlZubq3fffVdjx47V1KlTtWDBAnXs2DHS9i9/+Yv++Mc/2lr+9u3bNWnSJDVv3lydO3c+6ri3337bVh4Th+vbM888o3A4XO19AAAAqA3VcS775JNPqmHDhsfFlUvHasKECdq3b19tdwOoFhQ4AeA4sWXLFg0aNEjZ2dlatmyZGjduHJk3atQobd68WW+88UYt9vDo9e3bV127do28Hz9+vJYtW6b+/fvrsssu08aNGxUfHy9JiomJUUxM9f4527dvn+rVq6fY2NhqzXMkXq+3VvMDAABUl+PpXNZEaWmpEhISqm35GzZs0KxZszRhwgRNmDCh2vIAtYVL1AHgOPHQQw+ppKREf//736NOCA9o1aqVbrvttkPG7969W7///e912mmnKTExUcnJyerbt68+/fTTSm1nzJih9u3bq169eqpfv766du2qefPmRebv3btXY8eOVfPmzeXz+ZSenq7evXtr3bp1xut34YUX6u6779bWrVv1r3/9KzL9YPfgXLJkic455xylpqYqMTFRbdq00Z/+9CdJ+++beeaZZ0qSbrjhhsjl8AcuXerZs6c6dOigtWvX6rzzzlO9evUisb+8B+cBoVBIf/rTn5SZmamEhARddtll+uGHH6LaHOqepz9f5pH6drB7cJaWluqOO+5Q06ZN5fP51KZNGz3yyCOyLCuqncvl0ujRo/Xqq6+qQ4cO8vl8at++vRYtWnTwDQ4AAFCD7J7LzpkzRxdeeKHS09Pl8/nUrl07zZo1KyqmefPm+uKLL/Tee+9Fzqt+fi5XWFiosWPHRs6jWrVqpQcffLDSFTO7du3SkCFDlJycrNTUVA0bNkyffvpp1HnaAcuWLdO5556rhIQEpaam6vLLL9fGjRuj2hw4f/3yyy91/fXXq379+jrnnHM0Z84cuVwu/fe//620/g888IA8Ho9++ukn7dy5U5s2bbI1GvO2227TFVdcoXPPPfeoYwAnYQQnABwnXn/9dbVs2VJnn322Ufx3332nV199VVdffbVatGihvLw8PfXUUzr//PP15ZdfKisrS9L+y6R/97vf6aqrrtJtt90mv9+vzz77TKtXr9b1118vSfrtb3+rl156SaNHj1a7du20a9cuffjhh9q4caPOOOMM43UcMmSI/vSnP+ntt9/WTTfddNA2X3zxhfr376+OHTtq8uTJ8vl82rx5s1asWCFJatu2rSZPnqwJEyZo5MiRkZO8n2+3Xbt2qW/fvho0aJB+/etfKyMj47D9uv/+++VyufSHP/xB+fn5mjZtmnJycrR+/frISNOjcTR9+znLsnTZZZdp+fLlGjFihDp37qzFixfrzjvv1E8//aTHHnssqv2HH36o+fPn69Zbb1VSUpKmT5+ugQMHatu2bWrQoMFR9xMAAKCq2T2XnTVrltq3b6/LLrtMMTExev3113XrrbcqHA5r1KhRkqRp06ZpzJgxSkxM1J///GdJipzX7du3T+eff75++ukn3XzzzWrWrJlWrlyp8ePHa8eOHZo2bZokKRwO69JLL9XHH3+sW265Raeeeqpee+01DRs2rFKf3nnnHfXt21ctW7bUxIkTVVZWphkzZqhHjx5at25dpR+qr776arVu3VoPPPCALMvSVVddpVGjRmnu3Lk6/fTTo9rOnTtXPXv21EknnaSJEydq0qRJWr58+UF/fP+lF198UStXrtTGjRv1/fffH9X2BRzHAgA4XlFRkSXJuvzyy486Jjs72xo2bFjkvd/vt0KhUFSbLVu2WD6fz5o8eXJk2uWXX261b9/+sMtOSUmxRo0addR9OWDOnDmWJGvNmjWHXfbpp58eeX/PPfdYP/9z9thjj1mSrIKCgkMuY82aNZYka86cOZXmnX/++ZYka/bs2Qedd/7550feL1++3JJknXTSSVZxcXFk+n/+8x9LkvX4449Hpv1yex9qmYfr27Bhw6zs7OzI+1dffdWSZN13331R7a666irL5XJZmzdvjkyTZMXGxkZN+/TTTy1J1owZMyrlAgAAqCkm57L79u2rNK1Pnz5Wy5Yto6a1b98+6lzrgHvvvddKSEiwvv7666jpf/zjHy2Px2Nt27bNsizLevnlly1J1rRp0yJtQqGQdeGFF1Y6Z+vcubOVnp5u7dq1KzLt008/tdxutzV06NDItAPnr9ddd12lfl133XVWVlZW1Hn5unXronIdiF++fHnlDfML+/bts5o1a2aNHz/esqz/nb+++OKLR4wFnIRL1AHgOFBcXCxJSkpKMl6Gz+eT273/z0IoFNKuXbsil3f//NLy1NRU/fjjj1qzZs0hl5WamqrVq1dr+/btxv05lMTExMM+TT01NVWS9Nprrxk/kMfn8+mGG2446vZDhw6N2vZXXXWVGjdurDfffNMo/9F688035fF49Lvf/S5q+h133CHLsvTWW29FTc/JydHJJ58ced+xY0clJyfru+++q9Z+AgAAHI7JuezPr5IpKirSzp07df755+u7775TUVHREeNffPFFnXvuuapfv7527twZeeXk5CgUCun999+XJC1atEherzfq6iG32x0ZJXrAjh07tH79eg0fPlxpaWmR6R07dlTv3r0Pel7429/+ttK0oUOHavv27Vq+fHlk2ty5cxUfH6+BAwdK2n+Ju2VZRzV6869//auCwWDklkvA8YoCJwAcB5KTkyXpsIW/IwmHw3rsscfUunVr+Xw+NWzYUI0aNdJnn30WdZL4hz/8QYmJiTrrrLPUunVrjRo1KnL59wEPPfSQNmzYoKZNm+qss87SxIkTq6yIVlJSctiT32uvvVY9evTQb37zG2VkZGjQoEH6z3/+Y6vYedJJJ9l6oFDr1q2j3rtcLrVq1araLwHaunWrsrKyKm2Ptm3bRub/XLNmzSoto379+tqzZ0/1dRIAAOAITM5lV6xYoZycnMi9Lhs1ahQp4h1NgfObb77RokWL1KhRo6hXTk6OJCk/P1/S/vOpxo0bq169elHxrVq1inp/4LyrTZs2lXK1bdtWO3fuVGlpadT0Fi1aVGrbu3dvNW7cWHPnzpW0/xz9+eef1+WXX257MMP333+vhx9+WPfff78SExNtxQJOQ4ETAI4DycnJysrK0oYNG4yX8cADD2jcuHE677zz9K9//UuLFy/WkiVL1L59+6jiYNu2bfXVV1/phRde0DnnnKOXX35Z55xzju65555Im2uuuUbfffedZsyYoaysLD388MNq3759pRGFdv34448qKiqqdEL5c/Hx8Xr//ff1zjvvaMiQIfrss8907bXXqnfv3gqFQkeVx859M4/WLx+EdMDR9qkqeDyeg063fvFAIgAAgJpk91z222+/Va9evbRz505NnTpVb7zxhpYsWaLbb79dko7qh+1wOKzevXtryZIlB30dGC1ZnQ52zunxeHT99dfr5Zdflt/v1/Lly7V9+3b9+te/tr38CRMm6KSTTlLPnj31/fff6/vvv1dubq4kqaCgQN9//73xFU9AXcNDhgDgONG/f389/fTTWrVqlbp37247/qWXXtIFF1ygv//971HTCwsL1bBhw6hpCQkJuvbaa3XttdeqvLxcV155pe6//36NHz9ecXFxkqTGjRvr1ltv1a233qr8/HydccYZuv/++9W3b1/jdfy///s/SVKfPn0O287tdqtXr17q1auXpk6dqgceeEB//vOftXz5cuXk5Byy2Gjqm2++iXpvWZY2b96sjh07RqbVr19fhYWFlWK3bt2qli1bRt7b6Vt2drbeeecd7d27N+oX/U2bNkXmAwAAOIGdc9nXX39dgUBACxYsiLpC5eeXdR9wqHOrk08+WSUlJZERm4eSnZ2t5cuXa9++fVGjODdv3lypnSR99dVXlZaxadMmNWzYUAkJCYfNdcDQoUP16KOP6vXXX9dbb72lRo0aHfH892C2bdumzZs3R51rHnDrrbdKkvbs2RO5xRPgZIzgBIDjxF133aWEhAT95je/UV5eXqX53377rR5//PFDxns8nkoj+V588UX99NNPUdN27doV9T42Nlbt2rWTZVkKBoMKhUKVLgtKT09XVlaWAoGA3dWKWLZsme699161aNFCgwcPPmS73bt3V5rWuXNnSYrkP3ByebCCo4l//vOfUZdUvfTSS9qxY0dUMffkk0/WRx99pPLy8si0hQsX6ocffohalp2+XXLJJQqFQnriiSeipj/22GNyuVzHVEwGAACoSXbOZQ9clfLzc9eioiLNmTOnUlxCQsJBz6uuueYarVq1SosXL640r7CwUBUVFZL2/7AeDAb1zDPPROaHw2HNnDkzKqZx48bq3Lmz/vGPf0Tl27Bhg95++21dcsklh1n7aB07dlTHjh31t7/9TS+//LIGDRqkmJj/jU/buXOnNm3apH379h12Offdd59eeeWVqNe9994raf/2fuWVV4666ArUdYzgBIDjxMknn6x58+bp2muvVdu2bTV06FB16NBB5eXlWrlypV588UUNHz78kPH9+/fX5MmTdcMNN+jss8/W559/rrlz51b6xfeiiy5SZmamevTooYyMDG3cuFFPPPGE+vXrp6SkJBUWFqpJkya66qqr1KlTJyUmJuqdd97RmjVr9Oijjx7Vurz11lvatGmTKioqlJeXp2XLlmnJkiXKzs7WggULIqNED2by5Ml6//331a9fP2VnZys/P19PPvmkmjRponPOOSeyrVJTUzV79mwlJSUpISFB3bp1O+h9kI5GWlqazjnnHN1www3Ky8vTtGnT1KpVq6ib0f/mN7/RSy+9pIsvvljXXHONvv32W/3rX/+KeuiP3b5deumluuCCC/TnP/9Z33//vTp16qS3335br732msaOHVtp2QAAAHWVnXPZiy66SLGxsbr00kt18803q6SkRM8884zS09O1Y8eOqOV26dJFs2bN0n333adWrVopPT1dF154oe68804tWLBA/fv31/Dhw9WlSxeVlpbq888/10svvaTvv/9eDRs21IABA3TWWWfpjjvu0ObNm3XqqadqwYIFkR/Vfz5C9OGHH1bfvn3VvXt3jRgxQmVlZZoxY4ZSUlI0ceJEW9tj6NCh+v3vfy9JlS5Pf+KJJzRp0iQtX778sA8aOnDu+3MHRmueeeaZGjBggK0+AXVaLT7BHQBQDb7++mvrpptuspo3b27FxsZaSUlJVo8ePawZM2ZYfr8/0i47O9saNmxY5L3f77fuuOMOq3HjxlZ8fLzVo0cPa9WqVdb5559vnX/++ZF2Tz31lHXeeedZDRo0sHw+n3XyySdbd955p1VUVGRZlmUFAgHrzjvvtDp16mQlJSVZCQkJVqdOnawnn3zyiH2fM2eOJSnyio2NtTIzM63evXtbjz/+uFVcXFwp5p577rF+/uds6dKl1uWXX25lZWVZsbGxVlZWlnXddddZX3/9dVTca6+9ZrVr186KiYmxJFlz5syxLMuyzj//fKt9+/YH7d8vt8Xy5cstSdbzzz9vjR8/3kpPT7fi4+Otfv36WVu3bq0U/+ijj1onnXSS5fP5rB49eliffPJJpWUerm/Dhg2zsrOzo9ru3bvXuv32262srCzL6/VarVu3th5++GErHA5HtZNkjRo1qlKffrkfAAAA1KajPZddsGCB1bFjRysuLs5q3ry59eCDD1rPPvusJcnasmVLpF1ubq7Vr18/KykpyZIUdd61d+9ea/z48VarVq2s2NhYq2HDhtbZZ59tPfLII1Z5eXmkXUFBgXX99ddbSUlJVkpKijV8+HBrxYoVliTrhRdeiOr/O++8Y/Xo0cOKj4+3kpOTrUsvvdT68ssvo9ocOH8tKCg45HbYsWOH5fF4rFNOOaXSvAPxy5cvP8qt+j8Hzl9ffPFF27FAXeayLJ4sAAAAAAAAcLReffVVXXHFFfrwww/Vo0ePKl/+zp071bhxY02YMEF33313lS8fON5wD04AAAAAAIBDKCsri3ofCoU0Y8YMJScn64wzzqiWnM8995xCoZCGDBlSLcsHjjfcgxMAAAAAAOAQxowZo7KyMnXv3l2BQEDz58/XypUr9cADDyg+Pr5Kcy1btkxffvml7r//fg0YMEDNmzev0uUDxysuUQcAAAAAADiEefPm6dFHH9XmzZvl9/vVqlUr3XLLLRo9enSV5+rZs6dWrlypHj166F//+pdOOumkKs8BHI8ocAIAAAAAAABwLO7BCQAAAAAAAMCxKHACAAAAAAAAcCweMnQUwuGwtm/frqSkJLlcrtruDgAAAHBCsSxLe/fuVVZWltxuxmgAAIBoFDiPwvbt29W0adPa7gYAAABwQvvhhx/UpEmT2u6G47Q5tYNRnCvGYz/GeDyISaBZsduy7Odyu2tuoItltC0kj9v+5yVJMQbrZlnlRrmCFX77MWGjVAoGK2zHuAy3vdtltu3dBl+YGI9ZHwPl9re9J8ZnlMvl9tqOcRt+nz0G+2+MxyxXTIzZtt9bUmw7piJktuO7DLaj6Q+HJscOr8HfFUn67PNPj9iGAudRSEpKkrT/hCo5ObmWewMAAACcWIqLi9W0adPIeTkAAMDPUeA8CgcuS09OTqbACQAAANQSbhcFAAAOhhvYAAAAAAAAAHAsCpwAAAAAAAAAHIsCJwAAAAAAAADHosAJAAAAAAAAwLEocAIAAAAAAABwLAqcAAAAAAAAAByLAicAAAAAAAAAx6LACQAAAAAAAMCxKHACAAAAAAAAcCwKnAAAAAAAAAAciwInAAAAAAAAAMeKqe0OAAAAAACqj8tlFmdZlv0Y2Y/ZH2jYSSP2x/l4PGb/dXZ77Ocy2Oz/P84sMKyw/SDTncrlsR8TrjDLFbK/XoabXpbBakky2h6W6bZ3248Lucy2iNdjP5fpESBs2f+cKyrM9qlwMGQUp7D9ProNP2eX2+D4ZhAjSW6Dfcr4gz4KjOAEAAAAAAAA4FgUOAEAAAAAAAA4FgVOAAAAAAAAAI5FgRMAAAAAAACAY1HgBAAAAAAAAOBYPEX9BOP3+xUIBIxiLcuSy/SJbZJ8Pp/i4uKM4wEAAAAAAIBfosB5AvH7/WrSLFu7CvKN4l2eGFmhCuP8DRql68dtWylyAgAAAAAAoMpQ4DyBBAIB7SrIV/8p8+WNT7QVu29PnhZPGqK+976kuKRk27mDZSVaOP5KBQIBCpwAAAAAAACoMhQ4T0De+ETF2ixwBstK/39sgu1YAAAAAAAAoLrwkCEAAAAAAAAAjkWBEwAAAAAAAIBjUeAEAAAAAAAA4FjcgxMAAAAAjmNut+G4Fo/9uHA4ZJTKNM5ETIz9/wbHeDxGuVxul+0YS5ZRLllhwzj7+ayw/fWSJJdlsD3ChtvDgGWwLY4lzmT/MImRDI8DxkPiDL7Pprt9yP5+HwyZHW+sUIVRnNvgWBrjMtv4LoPP2fhvhMv+h1ZhuO2PBiM4AQAAAAAAADgWBU4AAAAAAAAAjkWBEwAAAAAAAIBjUeAEAAAAAAAA4FgUOAEAAAAAAAA4FgVOAAAAAAAAAI5FgRMAAAAAAACAY1HgBAAAAAAAAOBYMbXdAQCoDn6/X4FAwDje5/MpLi6uCnsEAAAAAACqAwVOAMcdv9+vJs2ytasg33gZDRql68dtWylyAgAAAABQx1HgBHDcCQQC2lWQr/5T5ssbn2g7PlhWooXjr1QgEKDACQAAAABAHUeBE8BxyxufqFiDAicAAAAAAHAOHjIEAAAAAAAAwLEYwQkAAAAAxzHLZRnFuayw/Vxh+zH7A+330e12GaXyuD22Y8wymW1Dt8ssm8tgvSRJBn0MhSvMUoVCtmPCFfZj9icziHGZjQFzuU3jTPcs+zwx9ss/ZkcOyRW2/5m5DI8dVsh+XNjgeCNJQcMtkmCw7WMMjwMmRyvDo7YMNr1CIdO96sgYwQkAAAAAAADAsShwAgAAAAAAAHCsWi1wvv/++7r00kuVlZUll8ulV1999ZBtf/vb38rlcmnatGlR03fv3q3BgwcrOTlZqampGjFihEpKSqLafPbZZzr33HMVFxenpk2b6qGHHqqGtQEAAAAAAABQ02r1HpylpaXq1KmTbrzxRl155ZWHbPfKK6/oo48+UlZWVqV5gwcP1o4dO7RkyRIFg0HdcMMNGjlypObNmydJKi4u1kUXXaScnBzNnj1bn3/+uW688UalpqZq5MiR1bZuAI6d3+9XIBCwHVdUVFQNvQEAAAAAAHVRrRY4+/btq759+x62zU8//aQxY8Zo8eLF6tevX9S8jRs3atGiRVqzZo26du0qSZoxY4YuueQSPfLII8rKytLcuXNVXl6uZ599VrGxsWrfvr3Wr1+vqVOnUuAE6jC/368mzbK1qyDfeBnGN7kHAAAAAACOUaefoh4OhzVkyBDdeeedat++faX5q1atUmpqaqS4KUk5OTlyu91avXq1rrjiCq1atUrnnXeeYmNjI2369OmjBx98UHv27FH9+vVrZF0A2BMIBLSrIF/9p8yXNz7RVuy+PXlaPGmIwuHqe0IbAAAAAACoG+p0gfPBBx9UTEyMfve73x10fm5urtLT06OmxcTEKC0tTbm5uZE2LVq0iGqTkZERmXewAmcgEIi6LLa4uPiY1gOAOW98omJtFjiDZaXV1BsAAAAAAFDX1NmnqK9du1aPP/64nnvuOblcrhrNPWXKFKWkpEReTZs2rdH8AAAAAAAAAI5OnS1wfvDBB8rPz1ezZs0UExOjmJgYbd26VXfccYeaN28uScrMzFR+fvT9+SoqKrR7925lZmZG2uTl5UW1OfD+QJtfGj9+vIqKiiKvH374oYrXDgAAAAAAAEBVqLOXqA8ZMkQ5OTlR0/r06aMhQ4bohhtukCR1795dhYWFWrt2rbp06SJJWrZsmcLhsLp16xZp8+c//1nBYFBer1eStGTJErVp0+aQ99/0+Xzy+XzVtWoAAAAAAAAAqkitFjhLSkq0efPmyPstW7Zo/fr1SktLU7NmzdSgQYOo9l6vV5mZmWrTpo0kqW3btrr44ot10003afbs2QoGgxo9erQGDRqkrKwsSdL111+vSZMmacSIEfrDH/6gDRs26PHHH9djjz1WcysKAAAAAAAAoFrUaoHzk08+0QUXXBB5P27cOEnSsGHD9Nxzzx3VMubOnavRo0erV69ecrvdGjhwoKZPnx6Zn5KSorffflujRo1Sly5d1LBhQ02YMEEjR46s0nUBAABA3eb3+6MeJGmXz+dTXFxcFfYIAAAAVaFWC5w9e/aUZVlH3f7777+vNC0tLU3z5s07bFzHjh31wQcf2O0eAAAAjhN+v19NmmVrV0H+kRsfQoNG6fpx21aKnHCcUDhkFGeFj/7/av8LMoiR5HZ57Me47cfsz2X/URR2/t/6i0DbIS632UN2XQbrJUkm2Uz3qVDI/o9MoVDQKJfbE2s7Jub/39bOLk+M4b5o8Flb4bBhLvv7R9jkGCAZ7ffhkNk+FTbZHgbbQpLkMYtzG+wfHqNvptn2CIfM9qmQyZ8IV/WVIevsPTgBAACAqhIIBLSrIF/9p8yXNz7RdnywrEQLx1+pQCBAgRMAAKCOocAJAACAE4Y3PlGxBgVOAAAA1F2G43IBAAAAAAAAoPZR4AQAAAAAAADgWBQ4AQAAAAAAADgWBU4AAAAAAAAAjsVDhgAckt/vVyAQMI73+Xw8aRYAAAAAAFQrCpwADsrv96tJs2ztKsg3XkaDRun6cdtWipwAAAAAAKDaUOAEcFCBQEC7CvLVf8p8eeMTbccHy0q0cPyVCgQCFDgBAAAAAEC1ocAJ4LC88YmKNShwAgAAAAAA1AQeMgQAAAAAAADAsShwAgAAAAAAAHAsCpwAAAAAAAAAHIt7cAIAAADAcSxcETKKswxiXC6XUS65TMbemI3XCRmsmMftMcqlcIXtECscNkoVMguTZD8wZBAjSRWhoP2YsNn+Gx9r/zOL8/qMcsXEmO2LlsG6BQ22oSRZNTi+zWTvqDA54EgKGxypvG6z45TPbbYNTbJZhsfSkMHxo8Lw4OFye23H+LzV9wBiRnACAAAAAAAAcCxGcMIx/H6/AoGAUazP51NcXPX9UgAAAAAAAIDaQYETjuD3+9WkWbZ2FeQbxTdolK4ft22lyAkAAAAAAHCcocAJRwgEAtpVkK/+U+bLG59oKzZYVqKF469UIBCgwAkAAAAAAHCcocAJR/HGJyrWZoETAAAAAAAAxy8eMgQAAAAAAADAsShwAgAAAAAAAHAsCpwAAAAAAAAAHIsCJwAAAAAAAADHosAJAAAAAAAAwLEocAIAAAAAAABwLAqcAAAAAAAAABwrprY7AAAAAACoPuFw2CzQZX88jMvlMUoVlst2jBWuMMrlUsh2TDhotl4+t8E2tIxSKWS4PcKW/YQVhvtUhUGYJybWKJfX67MdE+MxK5F43fb3X0lyG+wfMZbZti+rKLcdYxl8LyUpbDKWzus1yuWSWZyJGMPP2eQr7Q+afZ+DBnEuw8853mv/uFgvvvo+L0ZwAgAAAAAAAHAsCpwAAAAAAAAAHIsCJwAAAAAAAADHosAJAAAAAAAAwLF4yBBOGEVFRcaxPp9PcXFxVdgbAAAAAAAAVAUKnDjuhYLlktuj7Oxs42U0aJSuH7dtpcgJAAAAAABQx1DgxHEvXBGUwiH1vfclxSUl244PlpVo4fgrFQgEKHACAAAAAADUMRQ4ccLwxicoNj6xtrsBAAAAAACAKsRDhgAAAAAAAAA4FgVOAAAAAAAAAI5FgRMAAAAAAACAY1HgBAAAAAAAAOBYFDgBAAAAAAAAOBZPUQcAAACA45hluYziXEbjYTxGuTxu+/81dbvDRrnCVtB2TChYYZQr4La/PVyWUSoZhilsEBmyzLJ5YuNsx1iW2T4V5/bajkmL8RnlSogxGzvmdRnsw16z7VFQbj9mZ3nIKFeFwTHHLbPjlAnLcP8NhsziXCH7xxwZ5ooxOZZ6zEqDLpf9z6w86DfKdTQYwQkAAAAAAADAsShwAgAAAAAAAHAsCpwAAAAAAAAAHKtWC5zvv/++Lr30UmVlZcnlcunVV1+NzAsGg/rDH/6g0047TQkJCcrKytLQoUO1ffv2qGXs3r1bgwcPVnJyslJTUzVixAiVlJREtfnss8907rnnKi4uTk2bNtVDDz1UE6sHAAAAAAAAoJrVaoGztLRUnTp10syZMyvN27dvn9atW6e7775b69at0/z58/XVV1/psssui2o3ePBgffHFF1qyZIkWLlyo999/XyNHjozMLy4u1kUXXaTs7GytXbtWDz/8sCZOnKinn3662tcPAAAAAAAAQPWq1aeo9+3bV3379j3ovJSUFC1ZsiRq2hNPPKGzzjpL27ZtU7NmzbRx40YtWrRIa9asUdeuXSVJM2bM0CWXXKJHHnlEWVlZmjt3rsrLy/Xss88qNjZW7du31/r16zV16tSoQigAAAAAAAAA53HUPTiLiorkcrmUmpoqSVq1apVSU1MjxU1JysnJkdvt1urVqyNtzjvvPMXGxkba9OnTR1999ZX27NlTo/0HAAAAAAAAULVqdQSnHX6/X3/4wx903XXXKTk5WZKUm5ur9PT0qHYxMTFKS0tTbm5upE2LFi2i2mRkZETm1a9fv1KuQCCgQCAQeV9cXFyl6wIAAAAAAACgajhiBGcwGNQ111wjy7I0a9asas83ZcoUpaSkRF5Nmzat9pwAAAAAAAAA7KvzBc4Dxc2tW7dqyZIlkdGbkpSZman8/Pyo9hUVFdq9e7cyMzMjbfLy8qLaHHh/oM0vjR8/XkVFRZHXDz/8UJWrBAAAAAAAAKCK1OkC54Hi5jfffKN33nlHDRo0iJrfvXt3FRYWau3atZFpy5YtUzgcVrdu3SJt3n//fQWDwUibJUuWqE2bNge9PF2SfD6fkpOTo14AAAAAAAAA6p5aLXCWlJRo/fr1Wr9+vSRpy5YtWr9+vbZt26ZgMKirrrpKn3zyiebOnatQKKTc3Fzl5uaqvLxcktS2bVtdfPHFuummm/Txxx9rxYoVGj16tAYNGqSsrCxJ0vXXX6/Y2FiNGDFCX3zxhf7973/r8ccf17hx42prtQEAAAAAAABUkVp9yNAnn3yiCy64IPL+QNFx2LBhmjhxohYsWCBJ6ty5c1Tc8uXL1bNnT0nS3LlzNXr0aPXq1Utut1sDBw7U9OnTI21TUlL09ttva9SoUerSpYsaNmyoCRMmaOTIkdW7cgAAAABQJ1g1HGeSKmw7JGwQI0nhsP04K2y2LUKhkEGUyyiX5TKLk8t+WcAVk2CUKjbWZzumXnyKUa6miam2Y5ICFUa50uPMtkdaUpLtmPwdW4xyJTSw/zlbAbMHLu8pLrAdEwr4jXLJsr/fBw2/Y2GPxyguxqCPHrfZMcfjtt9Hl8ds7KPJMThcYXbcPhq1WuDs2bOnLOvQH9rh5h2QlpamefPmHbZNx44d9cEHH9juHwAAAAAAAIC6rU7fgxMAAAAAAAAADocCJwAAAAAAAADHosAJAAAAAAAAwLEocAIAAAAAAABwLAqcAAAAAAAAAByLAicAAAAAAAAAx6LACQAAAAAAAMCxKHACAAAAAAAAcCwKnAAAAAAAAAAciwInAAAAAAAAAMeiwAkAAAAAAADAsShwAgAAAAAAAHCsmNruAAAAAACg+rjdNTeuxWWFjOLCYct+kGUQI0kGYS65zFKFw7Zjwobr5XJ5jOK8MfbLArGeZKNcvsQM2zFJDTKNcsV54mzHhCpKjXLtDdjPJUkxnkTbMUEFjHK5fT7bMYkJe41yWZ4K2zGhwgKjXBUB+7lKLbPvc7nb7DvmMvhKu42PAyZR9o9TksyOwabH7aPACE4AAAAAAAAAjkWBEwAAAAAAAIBjUeAEAAAAAAAA4FgUOAEAAAAAAAA4FgVOAAAAAAAAAI5FgRMAAAAAAACAY1HgBAAAAAAAAOBYFDgBAAAAAAAAOBYFTgAAAAAAAACORYETAAAAAAAAgGNR4AQAAAAAAADgWBQ4AQAAAAAAADgWBU4AAAAAAAAAjhVT2x0AAAAAAFQfd4zhf/tCIfu5XJZZLhnEGaZyuz32g1yGuQziQhVmuWLdPqO4xJhE2zH1fPWNcqleQ/sxsclGqYrt775Krl/PKFfYZbbtSw32xdikbKNc20t22Y4JeuONciUnpdmOibfMdvzA3r22Y3LLg0a5giZfaElWyH5c2PBY6nKF7ceYHktNDowuw4PpUWAEJwAAAAAAAADHosAJAAAAAAAAwLEocAIAAAAAAABwLAqcAAAAAAAAAByLAicAAAAAAAAAx6LACQAAAAAAAMCxKHACAAAAAAAAcCwKnAAAAAAAAAAciwInAAAAAAAAAMeiwAkAAAAAAADAsShwAgAAAAAAAHAsCpwAAAAAAAAAHCumtjsAAAAAAKhGrpoLc7sNkxnFmeXyeDwGmSyjXHLbH1PkdsUapYr31jeKS6nX0HZMckKqUa5QfD3bMWWuoFGuhCSf7Zi2p2Yb5cpunGYU51OF7RhX0GxfLFyx2nZMoLTUKFeiL9V2TP1ks/F3AZf9uL0lu4xyFZfb/7wkybLsH3NMjh2S5HLbz2U68tHkuBgOGx5LjwIjOAEAAAAAAAA4FgVOAAAAAAAAAI7FJeoAADic3+9XIBAwjvf5fIqLi6vCHgEAAABAzaHACQCAg/n9fjVplq1dBfnGy2jQKF0/bttKkRMAAACAI9VqgfP999/Xww8/rLVr12rHjh165ZVXNGDAgMh8y7J0zz336JlnnlFhYaF69OihWbNmqXXr1pE2u3fv1pgxY/T666/L7XZr4MCBevzxx5WYmBhp89lnn2nUqFFas2aNGjVqpDFjxuiuu+6qyVUFAKBaBAIB7SrIV/8p8+WNTzxywC8Ey0q0cPyVCgQCFDgBAAAAOFKt3oOztLRUnTp10syZMw86/6GHHtL06dM1e/ZsrV69WgkJCerTp4/8fn+kzeDBg/XFF19oyZIlWrhwod5//32NHDkyMr+4uFgXXXSRsrOztXbtWj388MOaOHGinn766WpfPwAAaoo3PlGxBi+ToigAAAAA1CW1OoKzb9++6tu370HnWZaladOm6S9/+Ysuv/xySdI///lPZWRk6NVXX9WgQYO0ceNGLVq0SGvWrFHXrl0lSTNmzNAll1yiRx55RFlZWZo7d67Ky8v17LPPKjY2Vu3bt9f69es1derUqEIoAAAAAAAAAOeps09R37Jli3Jzc5WTkxOZlpKSom7dumnVqlWSpFWrVik1NTVS3JSknJwcud1urV69OtLmvPPOU2xsbKRNnz599NVXX2nPnj01tDYAAAAAAAAAqkOdfchQbm6uJCkjIyNqekZGRmRebm6u0tPTo+bHxMQoLS0tqk2LFi0qLePAvPr161fKHQgEop5GW1xcfIxrAwAAAAAAAKA61NkRnLVpypQpSklJibyaNm1a210CAAAAAAAAcBB1dgRnZmamJCkvL0+NGzeOTM/Ly1Pnzp0jbfLz86PiKioqtHv37kh8Zmam8vLyotoceH+gzS+NHz9e48aNi7wvLi6myAnH8vv9USOSj1ZRUVE19AYAAAAAAKBq1dkCZ4sWLZSZmamlS5dGCprFxcVavXq1brnlFklS9+7dVVhYqLVr16pLly6SpGXLlikcDqtbt26RNn/+858VDAbl9XolSUuWLFGbNm0Oenm6JPl8Pvl8vmpeQ6D6+f1+NWmWrV0F+UdufAhWOFyFPQIAAAAAAKhatVrgLCkp0ebNmyPvt2zZovXr1ystLU3NmjXT2LFjdd9996l169Zq0aKF7r77bmVlZWnAgAGSpLZt2+riiy/WTTfdpNmzZysYDGr06NEaNGiQsrKyJEnXX3+9Jk2apBEjRugPf/iDNmzYoMcff1yPPfZYbawyUKMCgYB2FeSr/5T58sYn2ordtydPiycNUThsVVPvAAAAAAAAjl2tFjg/+eQTXXDBBZH3By4LHzZsmJ577jndddddKi0t1ciRI1VYWKhzzjlHixYtUlxcXCRm7ty5Gj16tHr16iW3262BAwdq+vTpkfkpKSl6++23NWrUKHXp0kUNGzbUhAkTNHLkyJpbUaCWeeMTFWuzwBksK62m3gAAAKAmhSuCRnFug9+5LavmHvPgcruM4kx+vo/xeIxyBQ2uhqpwJRjlshIaH7nRwaTYj3PHm13x2LJ+su2YdlkHv/LySJq1P9l2TNZpZremS0s32+/rqcx2jMdvuO0bxduO+fy/Xxrl+inf/u3O8kt2GeXa6w3Zjknw2Y+RpLjcQqO4cpf9o05MjNkxx+M22BcNr9q0wva3Y9iqvitEa7XA2bNnT1nWoT9ol8ulyZMna/LkyYdsk5aWpnnz5h02T8eOHfXBBx8Y9xMAAAAAAABA3cRT1AEAAAAAAAA4FgVOAAAAAAAAAI5FgRMAAAAAAACAY1HgBAAAAAAAAOBYtfqQIZx4iorsP03tWOLqCr/fr0AgYBRrWZZcLrMnRDp9uwEAAAAAABwJBU7UiFCwXHJ7lJ2dfUzLscLhKupRzfH7/WrSLFu7CvKN4l2eGFmhimPqgxO3GwAAAAAAwNGgwIkaEa4ISuGQ+t77kuKSkm3H79uTp8WThigctqqhd9UrEAhoV0G++k+ZL298oq3YA+t9Im43AAAAAACAo0GBEzXKG5+gWJtFPkkKlpVWQ29qljc+0fa6H1jvE3m7AQAAAAAAHA4PGQIAAAAAAADgWBQ4AQAAAAAAADgWBU4AAAAAAAAAjsU9OAEAAADgOOZ2mY1rcbvsx4Rl9nBLKxy2HeMyXS+DFasIma1XhdtrOyYmqb5RroT0JkZxli/Jdsxef4FRrlPSEmzHdCjfaZQrK66l7ZhSf7lRrt27zEorQYP9vmzH90a54vfssB1zeqz9/kmSvPbjvi6vMEq1w0q1HZPeqLFRruSijUZxxaWFtmMsw2NpOByqkRhJskL2P7NQyCzX0WAEJwAAAAAAAADHosAJAAAAAAAAwLEocAIAAAAAAABwLAqcAAAAAAAAAByLAicAAAAAAAAAx6LACQAAAAAAAMCxKHACAAAAAAAAcCwKnAAAAAAAAAAcK6a2OwDg+FZUVFSjcQAAAAAA4MRCgRNAtQgFyyW3R9nZ2ce0HCscrqIeAQAAAACA4xEFTgDVIlwRlMIh9b33JcUlJduO37cnT4snDVE4bFVD7wAAAAAAwPGCAieAauWNT1BsfKLtuGBZaTX0BgAAAAAAHG94yBAAAAAAAAAAx2IEJwAAAAAcxyzLZRboth/n8Zjlcrk99mNchutl2b8FkhU2y2UZ5KrnjTfKFSOvUVzA77efy20/RpKyW9e3HVPy9bdGud5d86HtmE3/jTPKtTemnlFcsi/WdoxPJUa56lUU2o8J2++fJJU1bmA7JrQvaJRr5zc7bMd495mVwhrFZxjFhfz7bMeUqcIoV1j2n2HhMoiRJMtl//jmsX+oP2qM4AQAAAAAAADgWBQ4AQAAAAAAADgWBU4AAAAAAAAAjkWBEwAAAAAAAIBjUeAEAAAAAAAA4FgUOAEAAAAAAAA4FgVOAAAAAAAAAI5FgRMAAAAAAACAYxkVOFu2bKldu3ZVml5YWKiWLVsec6cAAAAAAAAA4GgYFTi///57hUKhStMDgYB++umnY+4UAAAAAAAAAByNGDuNFyxYEPn34sWLlZKSEnkfCoW0dOlSNW/evMo6BwAAAAAAAACHY6vAOWDAAEmSy+XSsGHDouZ5vV41b95cjz76aJV1DgAAAAAAAAAOx1aBMxwOS5JatGihNWvWqGHDhtXSKQAAAABA1bAsl1Fc2OCOZm6XxyiXx2U/l0uWUa6wFTaIMduGqnxntyPnKgsYpSr3lhnFWV6v7ZjkjCSjXC3at7Yd47f8Rrn8sbbKHZKkxAqz/XdXwDDOE287JqV+ulEuX0o92zF7w2bfMa/BsSMrPtUoV7E/1naMK3evUa5keyW0iL0e+9+x8lCFUa6QZf8zswxijOPMUh0Vo09ny5YtVd0PAAAAAAAAALDNrPwsaenSpVq6dKny8/MjIzsPePbZZ4+5YwAAAAAAAABwJEYFzkmTJmny5Mnq2rWrGjduLJfLcLg+AAAAAAAAABwDowLn7Nmz9dxzz2nIkCFV3R8AAAAAAAAAOGr27/wqqby8XGeffXZV9wUAAAAAAAAAbDEqcP7mN7/RvHnzqrovlYRCId19991q0aKF4uPjdfLJJ+vee++NelKTZVmaMGGCGjdurPj4eOXk5Oibb76JWs7u3bs1ePBgJScnKzU1VSNGjFBJSUm19x8AAAAAAABA9TK6RN3v9+vpp5/WO++8o44dO8rrjX7k/dSpU6ukcw8++KBmzZqlf/zjH2rfvr0++eQT3XDDDUpJSdHvfvc7SdJDDz2k6dOn6x//+IdatGihu+++W3369NGXX36puLg4SdLgwYO1Y8cOLVmyRMFgUDfccINGjhxZI0VaAHAav9+vQCBgFOvz+SLHXgDHL44TAAAAqEuMCpyfffaZOnfuLEnasGFD1LyqfODQypUrdfnll6tfv36SpObNm+v555/Xxx9/LGn/6M1p06bpL3/5iy6//HJJ0j//+U9lZGTo1Vdf1aBBg7Rx40YtWrRIa9asUdeuXSVJM2bM0CWXXKJHHnlEWVlZVdZfAHA6v9+vJs2ytasg3yi+QaN0/bhtK8UL4DjGcQIAAAB1jVGBc/ny5VXdj4M6++yz9fTTT+vrr7/WKaecok8//VQffvhhZIToli1blJubq5ycnEhMSkqKunXrplWrVmnQoEFatWqVUlNTI8VNScrJyZHb7dbq1at1xRVX1Mi6AIATBAIB7SrIV/8p8+WNT7QVGywr0cLxVyoQCFC4AI5jHCcAAABQ1xgVOGvKH//4RxUXF+vUU0+Vx+NRKBTS/fffr8GDB0uScnNzJUkZGRlRcRkZGZF5ubm5Sk9Pj5ofExOjtLS0SJtfCgQCUZddFRcXV9k6AYATeOMTFWuzcAHgxMJxAgAAAHWFUYHzggsuOOyl6MuWLTPu0M/95z//0dy5czVv3jy1b99e69ev19ixY5WVlaVhw4ZVSY6DmTJliiZNmlRtywcAAAAAAABQNYwKnAfuv3lAMBjU+vXrtWHDhiotPN5555364x//qEGDBkmSTjvtNG3dulVTpkzRsGHDlJmZKUnKy8tT48aNI3F5eXmRPmZmZio/P/oeURUVFdq9e3ck/pfGjx+vcePGRd4XFxeradOmVbZeAAAAAAAAAKqGUYHzscceO+j0iRMnqqSk5Jg69HP79u2T2+2OmubxeBQOhyVJLVq0UGZmppYuXRopaBYXF2v16tW65ZZbJEndu3dXYWGh1q5dqy5dukjaP8I0HA6rW7duB83r8/nk8/mqbD0AAAAAAAAAVI8qvQfnr3/9a5111ll65JFHqmR5l156qe6//341a9ZM7du313//+19NnTpVN954o6T9T2wfO3as7rvvPrVu3VotWrTQ3XffraysLA0YMECS1LZtW1188cW66aabNHv2bAWDQY0ePVqDBg3iCeoAAAAAjnuW3EdudBBheQxyGf4X033oW6AdOlnYKFU4HLQdEwob9E9S2LIf45ZhrpBZnCc21nZMUmqyUa7kjINfRXk4DeMNP2d/ge2YvD1mA7YKi8z6WBiyH1fkq2eUy+PJOHKjXwruMcrVONH+MSct0f5+KElpcfaPUxWxZsfEuKD9XJLkMjgGh0wOHpIsGcSZHToMA822/dGo0gLnqlWrqvSJmDNmzNDdd9+tW2+9Vfn5+crKytLNN9+sCRMmRNrcddddKi0t1ciRI1VYWKhzzjlHixYtiurH3LlzNXr0aPXq1Utut1sDBw7U9OnTq6yfAAAAAAAAAGqHUYHzyiuvjHpvWZZ27NihTz75RHfffXeVdEySkpKSNG3aNE2bNu2QbVwulyZPnqzJkycfsk1aWprmzZtXZf0CAAAAAAAAUDcYFThTUlKi3rvdbrVp00aTJ0/WRRddVCUdAwAAAAAAAIAjMSpwzpkzp6r7AQAAAAAAAAC2HdM9ONeuXauNGzdKktq3b6/TTz+9SjoFAAAAAAAAAEfDqMCZn5+vQYMG6d1331VqaqokqbCwUBdccIFeeOEFNWrUqCr7CAAAAAAAAAAHZfR89jFjxmjv3r364osvtHv3bu3evVsbNmxQcXGxfve731V1HwEAAAAAAADgoIxGcC5atEjvvPOO2rZtG5nWrl07zZw5k4cMAQAAAAAAAKgxRgXOcDgsr9dbabrX61U4HD7mTgEAzPn9fgUCAaPYoqKiKu4NAAAAAADVy6jAeeGFF+q2227T888/r6ysLEnSTz/9pNtvv129evWq0g4CAI6e3+9Xk2bZ2lWQf0zLsfixCgAAAADgEEYFzieeeEKXXXaZmjdvrqZNm0qSfvjhB3Xo0EH/+te/qrSDAICjFwgEtKsgX/2nzJc3PtF2/L49eVo8aYjCYasaegcAAAAAQNUzKnA2bdpU69at0zvvvKNNmzZJktq2baucnJwq7RwAwIw3PlGxBgXOYFlpNfQGAAAAAIDqY+sp6suWLVO7du1UXFwsl8ul3r17a8yYMRozZozOPPNMtW/fXh988EF19RUAAAAAAAAAotgawTlt2jTddNNNSk5OrjQvJSVFN998s6ZOnapzzz23yjoIAAAAADBneucZt0FcyCyV3C6P7RiXreE6/xMM2r/XuOntyS2DTnrjE4xyxcSZxVkxcQbJ6hnlCrjjbcc0aJFtlKv0vxttxwR2/WSUK6Y81ijO8tS3HVOw22zHdxfY/3Z6874zylWvZSPbMYU7thvl8v+01XZMgtvsuxK2f5iSJJUFK2zH+CvMDjoug+u0vW6zfcoll/0Y0wP3UbC15E8//VQXX3zxIedfdNFFWrt27TF3CgAAAAAAAACOhq0CZ15enrxe7yHnx8TEqKCg4Jg7BQAAAAAAAABHw1aB86STTtKGDRsOOf+zzz5T48aNj7lTAAAAAAAAAHA0bBU4L7nkEt19993y+/2V5pWVlemee+5R//79q6xzAAAAAAAAAHA4tm4/+pe//EXz58/XKaecotGjR6tNmzaSpE2bNmnmzJkKhUL685//XC0dBQAAAAAAAIBfslXgzMjI0MqVK3XLLbdo/Pjxsqz9j9VzuVzq06ePZs6cqYyMjGrpKAAAAAAAAAD8ku0HyGdnZ+vNN9/Unj17tHnzZlmWpdatW6t+/frV0T8AAAAAAAAAOCTbBc4D6tevrzPPPLMq+wIAAAAAAAAAtth6yBAAAAAAAAAA1CUUOAEAAAAAAAA4FgVOAAAAAAAAAI5FgRMAAAAAAACAYxk/ZAgAAAAAUPeFrKBRnBUO245xWUapVGG5bMdYst+//bnsxxmESJJcXvvrVR4224iusNn4pWC5x3bM7kL76yVJe/31bceE/cVGufYV+W3HpMf5jHI1zs4yituV3Mh2zPaKVKNcnWIybMfseu8no1zpfvv71J69Zl+yWP8+g6CQUa6CvQVGcaVB+30MhM2O27Ex9st8bo/9z0uSXG77xyqX6R+Jo8AITgAAAAAAAACORYETAAAAAAAAgGNR4AQAAAAAAADgWBQ4AQAAAAAAADgWBU4AAAAAAAAAjkWBEwAAAAAAAIBjUeAEAAAAAAAA4FgUOAEAAAAAAAA4FgVOAAAAAAAAAI5FgRMAAAAAAACAY1HgBAAAAAAAAOBYFDgBAAAAAAAAOBYFTgAAAAAAAACOFVPbHQAAAAAAVJ9wKGgYGTLIZRllcnsMYtwuo1wK2++jFQobpfLF2V8xl1kqBcvMPufyoP0+Fhp2cu2qLbZjGp/T0ChXqi/Zfq60OKNcSZmJRnGbC3Ntx3z27ttGub5Rqu2YJhVpRrly99j/jm3attso108Bv+2YhJhyo1w7iguM4koq7OezDI6/klRhcBgIGB5KY732A92W6d+jo1h2tS0ZAAAAAAAAAKoZBU4AAAAAAAAAjkWBEwAAAAAAAIBjUeAEAAAAAAAA4FgUOAEAAAAAAAA4Vp0vcP7000/69a9/rQYNGig+Pl6nnXaaPvnkk8h8y7I0YcIENW7cWPHx8crJydE333wTtYzdu3dr8ODBSk5OVmpqqkaMGKGSkpKaXhUAAAAAAAAAVaxOFzj37NmjHj16yOv16q233tKXX36pRx99VPXr14+0eeihhzR9+nTNnj1bq1evVkJCgvr06SO/3x9pM3jwYH3xxRdasmSJFi5cqPfff18jR46sjVUCAAAAAAAAUIViarsDh/Pggw+qadOmmjNnTmRaixYtIv+2LEvTpk3TX/7yF11++eWSpH/+85/KyMjQq6++qkGDBmnjxo1atGiR1qxZo65du0qSZsyYoUsuuUSPPPKIsrKyanalAAAAAAAAAFSZOj2Cc8GCBeratauuvvpqpaen6/TTT9czzzwTmb9lyxbl5uYqJycnMi0lJUXdunXTqlWrJEmrVq1SampqpLgpSTk5OXK73Vq9enXNrQwAAAAAAACAKlenC5zfffedZs2apdatW2vx4sW65ZZb9Lvf/U7/+Mc/JEm5ubmSpIyMjKi4jIyMyLzc3Fylp6dHzY+JiVFaWlqkzS8FAgEVFxdHvQAAAAAAAADUPXX6EvVwOKyuXbvqgQcekCSdfvrp2rBhg2bPnq1hw4ZVW94pU6Zo0qRJ1bZ8AAAAAAAAAFWjTo/gbNy4sdq1axc1rW3bttq2bZskKTMzU5KUl5cX1SYvLy8yLzMzU/n5+VHzKyoqtHv37kibXxo/fryKiooirx9++KFK1gcAAAAAAABA1arTIzh79Oihr776Kmra119/rezsbEn7HziUmZmppUuXqnPnzpKk4uJirV69WrfccoskqXv37iosLNTatWvVpUsXSdKyZcsUDofVrVu3g+b1+Xzy+XzVtFYAAAAAUHNMR7VYlkFM2CBIkhUK2Y4JhVxGuUyiYr2xRrl8Xq/tGCu0zyhXWqrZtk+IS7AdE/aXGOX65MMPbcc0UiujXJkNDj6g6bC56scZ5Ur1JZvFNfPYjmnVu71RrtgS++WfHZ9tM8q1eN0W2zE/7t5jlGtfvP31CrpKjXL5fWZHU3/A/nfTbXgsragotx9jVZjlsuxv+3re6htnWacLnLfffrvOPvtsPfDAA7rmmmv08ccf6+mnn9bTTz8tSXK5XBo7dqzuu+8+tW7dWi1atNDdd9+trKwsDRgwQNL+EZ8XX3yxbrrpJs2ePVvBYFCjR4/WoEGDeII6AAAAAAAA4HB1usB55pln6pVXXtH48eM1efJktWjRQtOmTdPgwYMjbe666y6VlpZq5MiRKiws1DnnnKNFixYpLu5/v7zMnTtXo0ePVq9eveR2uzVw4EBNnz69NlYJAAAAAAAAQBWq0wVOSerfv7/69+9/yPkul0uTJ0/W5MmTD9kmLS1N8+bNq47uAQAAAAAAAKhFdfohQwAAAAAAAABwOBQ4AQAAAAAAADgWBU4AAAAAAAAAjkWBEwAAAAAAAIBjUeAEAAAAAAAA4FgUOAEAAAAAAAA4FgVOAAAAAAAAAI5FgRMAAAAAAACAY1HgBAAAAAAAAOBYMbXdAQCoq4qKioxjfT6f4uLiqrA3AOoav9+vQCBgHM9xAgAAAKgaFDgB4BdCwXLJ7VF2drbxMho0SteP27ZSvACOU36/X02aZWtXQb7xMjhOAKgplmWZBYbtx4VCYbNcCtmOcLs9RpliPF7bMV6DGElyuezHVFSUGuUKBMz+JiUm+GzH1EuJNcq1e99e2zHLPtpolOu0ti1tx7jrNTLKFUoy+1seLquwnyucaJRr49afbMd8/qX9GEnasttgH44126fiDA45xYV5RrmK9xoOgAnZv3g6xmNw8JDkNggLy+xvRLjC/nE7aJn+jTgyCpwA8AvhiqAUDqnvvS8pLinZdnywrEQLx1+pQCBA4QI4TgUCAe0qyFf/KfPljbf/Hw2OEwAAAEDVocAJAIfgjU9QrEHhAsCJwxufyHECAAAAqGU8ZAgAAAAAAACAY1HgBAAAAAAAAOBYFDgBAAAAAAAAOBYFTgAAAAAAAACORYETAAAAAAAAgGNR4AQAAAAAAADgWBQ4AQAAAAAAADgWBU4AAAAAAAAAjkWBEwAAAAAAAIBjUeAEAAAAAAAA4Fgxtd0BAAAAAED1sSyzOJfLfqDLLJURl2Eyj8djO8btNkxmhW2HhCr2GaUq2rvdKC7ktt/H+vUzjHIlxNazHbNl116jXDvX/2A7ZlO+Wa76qfa34X5+2xEBv9co09YtO23H7CrYYZTLirH/fXF5Ama5yoptx/iLi4xyhcvKjOLcLvufmcsgRpI8XvvjGD2GB1OXQZzLqr5xlozgBAAAAAAAAOBYFDgBAAAAAAAAOBaXqAMAADiM3+9XIGB2KZck+Xw+xcXFVWGPAAAAgNpDgRMAAMBB/H6/mjTL1q6CfONlNGiUrh+3baXICQAAgOMCBU4AAAAHCQQC2lWQr/5T5ssbn2g7PlhWooXjr1QgEKDACQAAgOMCBU4AAAAH8sYnKtagwAkAAAAcb3jIEAAAAAAAAADHosAJAAAAAAAAwLEocAIAAAAAAABwLAqcAAAAAAAAAByLAicAAAAAAAAAx6LACQAAAAAAAMCxKHACAAAAAAAAcKyY2u4AAAAAAKD6uOSqsTi3WSq5DQJdpsN1XJbtkLAVNkplhUMGufxGufaV7jSKKw2W2c8VLDXKldWoqe2Y2NhUo1xffm9/e3y25SejXHFxAaM4rytoO6ai3GOUq3Cv/X0xKc3+d0WSEmLs7x8VpQVGuUr32I8L+e1vd0nyuswOcKFQhe0YK8bsAOeyDI7bbsNcBgdhl7v6ypCM4AQAAAAAAADgWBQ4AQAAAAAAADgWBU4AAAAAAAAAjkWBEwAAAAAAAIBj8ZAhAKgmRUVFRnE+n09xcXFV3Bvg8NhfAQAAADgVBU4AqGKhYLnk9ig7O9sovkGjdP24bStFI9QI9lcAAAAATueoAudf//pXjR8/XrfddpumTZsmSfL7/brjjjv0wgsvKBAIqE+fPnryySeVkZERidu2bZtuueUWLV++XImJiRo2bJimTJmimBhHrT4AhwhXBKVwSH3vfUlxScm2YoNlJVo4/koFAgEKRqgR7K8AAAAAnM4xFb41a9boqaeeUseOHaOm33777XrjjTf04osvKiUlRaNHj9aVV16pFStWSJJCoZD69eunzMxMrVy5Ujt27NDQoUPl9Xr1wAMP1MaqADhBeOMTFBufWNvdAI4K+ysAAAAAp3LEQ4ZKSko0ePBgPfPMM6pfv35kelFRkf7+979r6tSpuvDCC9WlSxfNmTNHK1eu1EcffSRJevvtt/Xll1/qX//6lzp37qy+ffvq3nvv1cyZM1VeXl5bqwQAAAAAAACgCjiiwDlq1Cj169dPOTk5UdPXrl2rYDAYNf3UU09Vs2bNtGrVKknSqlWrdNppp0Vdst6nTx8VFxfriy++qJkVAAAAAAAAAFAt6vwl6i+88ILWrVunNWvWVJqXm5ur2NhYpaamRk3PyMhQbm5upM3Pi5sH5h+YdzCBQECBQCDyvri4+FhWAQAAAAAAAEA1qdMjOH/44Qfddtttmjt3bo0+vGDKlClKSUmJvJo2bVpjuQEAAAAAAAAcvTo9gnPt2rXKz8/XGWecEZkWCoX0/vvv64knntDixYtVXl6uwsLCqFGceXl5yszMlCRlZmbq448/jlpuXl5eZN7BjB8/XuPGjYu8Ly4upsgJAAAAwJE8LpdRnGUQZskyzGUQ5zZbr5AVsh1jul4KGcRZFUapLCtw5EYHUV5WZjtmV9B+jCR5wvbXLaNBO6NclstjO8Ybk2SUK86XYBTnVdB2jGW43+/ZW2Q7Juwy+5wLi7bZjvEXbTfKFSyz/2wVV9hsrF+MyXFKkstjP85teNyWQZxleHizDI5vVjhsluwo1OkRnL169dLnn3+u9evXR15du3bV4MGDI//2er1aunRpJOarr77Stm3b1L17d0lS9+7d9fnnnys/Pz/SZsmSJUpOTla7dgc/UPp8PiUnJ0e9AAAAAAAAANQ9dXoEZ1JSkjp06BA1LSEhQQ0aNIhMHzFihMaNG6e0tDQlJydrzJgx6t69u371q19Jki666CK1a9dOQ4YM0UMPPaTc3Fz95S9/0ahRo+Tz+Wp8nQAAAAAAAABUnTpd4Dwajz32mNxutwYOHKhAIKA+ffroySefjMz3eDxauHChbrnlFnXv3l0JCQkaNmyYJk+eXIu9BgAAAAAAAFAVHFfgfPfdd6Pex8XFaebMmZo5c+YhY7Kzs/Xmm29Wc88AAAAAAAAA1LQ6fQ9OAAAAAAAAADgcCpwAAAAAAAAAHIsCJwAAAAAAAADHosAJAAAAAAAAwLEc95AhAADqIr/fr0AgYBTr8/kUFxdXxT1yhmPZbtKJve0AAAAA7EeBEwCAY+T3+9WkWbZ2FeQbxTdolK4ft2094Qp1x7rdpBN32wEAAAD4HwqcAAAco0AgoF0F+eo/Zb688Ym2YoNlJVo4/koFAoETrkh3LNtNOrG3HQAAAID/ocAJAEAV8cYnKtagUHeiY7sBAAAAOBY8ZAgAAAAAAACAYzGCEwAAAACOYx5X2Cgu7HLZj7HMcoXC9uPs924/yyTS7THKFeOyH+cy3IZWKGQU57bsx4VDfqNcu3b9ZDtmb1GJUa4Yb33bMbHeWKNcHpfh2DG3/c86WFZqlMqy7McV7g0a5QqUFNiOcZeZPXQy1mDcXozBsU2S3G7LKM7sO22WyyzKjGXZz2aFK6qhJ/sxghMAAAAAAACAY1HgBAAAAAAAAOBYFDgBAAAAAAAAOBYFTgAAAAAAAACORYETAAAAAAAAgGNR4AQAAAAAAADgWBQ4AQAAAAAAADgWBU4AAAAAAAAAjkWBEwAAAAAAAIBjUeAEAAAAAAAA4Fgxtd0BwCmKiopqNA4nNvY3oPr5/X4FAgGj2OPhu8ZxBgAAAMcLCpzAEYSC5ZLbo+zs7GNajhUOV1GPcDxjfwNqht/vV5Nm2dpVkH9My3Hid43jDAAAAI43FDiBIwhXBKVwSH3vfUlxScm24/ftydPiSUMUDlvV0Dscb9jfgJoRCAS0qyBf/afMlzc+0Xa8k79rHGcAAABwvKHACRwlb3yCYg3+ExwsK62G3uB4x/4G1AxvfOIJ+13jOAOcOGJiPUZxIYPfMTxuw8c8eMz6aMRgvSzL7Ecdy+WyHeMy3IZWuMIoTuGQ7RCX4faIcduPi3HZ758kWcHdtmPKAmbrlRiTZhSXUd9+XIW32ChXOLzDdkxeSZlRLlfQ/nZ0u2ONclky+I65zL5jXp9RmELl+2zHmP+MbH/d3G6z0qDB4U1uk6CjXXa1LRkAAAAAAAAAqhkFTgAAAAAAAACORYETAAAAAAAAgGNR4AQAAAAAAADgWBQ4AQAAAAAAADgWT1EHAECS3+9XIBAwii0qKqri3gDHt2P5zvh8PsXFxVVhbwAAAOB0FDgBACc8v9+vJs2ytasg/5iWY4XDVdQj4PgUCpZLbo+ys7ONl9GgUbp+3LaVIicAAAAiKHACAE54gUBAuwry1X/KfHnjE23H79uTp8WThigctqqhd8DxI1wRlMIh9b33JcUlJduOD5aVaOH4KxUIBChwAgAAIIICJwAA/583PlGxBgXOYFlpNfQGOH554xOMvmsAAADAwfCQIQAAAAAAAACORYETAAAAAAAAgGNR4AQAAAAAAADgWNyDEwAAAACOY2ErbBQXMnh4nssok+R22e+jy2WYzTTOgCX729Ds05JBpv1cBpEew00Y4zLYp8LlRrncBlvSYDeUJCV4zcaOpScZPNwyuMcoV0G533ZMbEWFUS63vLZjXG7D8pTBvmj6XQlaIbNAt/1OhkNmvTTZE91uj1kug/WKjam+MiQFTgBAneH3+xUIBIzjLcsy+s9OUVGRcU4AOFrHcozz+Xw8OR4AAOAQKHACAOoEv9+vJs2ytasg33gZLk+MrJDZL82SZIVNx0wAwOEd6zGuQaN0/bhtK0VOAACAg6DACQCoEwKBgHYV5Kv/lPnyxhtcrrMnT4snDVHfe19SXFKyUWzY4FI8ADgax3KMC5aVaOH4KxUIBChwAgAAHAQFTgBAneKNT1SsQYEzWFb6/+MTbMcfiAWA6mZ6jAMAAMCh8RR1AAAAAAAAAI5FgRMAAAAAAACAY1HgBAAAAAAAAOBYdbrAOWXKFJ155plKSkpSenq6BgwYoK+++iqqjd/v16hRo9SgQQMlJiZq4MCBysvLi2qzbds29evXT/Xq1VN6erruvPNOVVSYP2UXAAAAAAAAQN1Qpx8y9N5772nUqFE688wzVVFRoT/96U+66KKL9OWXXyohIUGSdPvtt+uNN97Qiy++qJSUFI0ePVpXXnmlVqxYIUkKhULq16+fMjMztXLlSu3YsUNDhw6V1+vVAw88UJurBwAAAIcpKiqq0TgAAAAcWZ0ucC5atCjq/XPPPaf09HStXbtW5513noqKivT3v/9d8+bN04UXXihJmjNnjtq2bauPPvpIv/rVr/T222/ryy+/1DvvvKOMjAx17txZ9957r/7whz9o4sSJio2NrY1VAwAAgIOEguWS26Ps7OxjWo4VDldRjwAAAHBAnS5w/tKBX77T0tIkSWvXrlUwGFROTk6kzamnnqpmzZpp1apV+tWvfqVVq1bptNNOU0ZGRqRNnz59dMstt+iLL77Q6aefXrMrAQAAAMcJVwSlcEh9731JcUnJtuP37cnT4klDFA5b1dA7AACAE5tjCpzhcFhjx45Vjx491KFDB0lSbm6uYmNjlZqaGtU2IyNDubm5kTY/L24emH9g3sEEAgEFAoHI++Li4qpaDQAAADiYNz5BsfGJtuOCZaXV0BsAAABIdfwhQz83atQobdiwQS+88EK155oyZYpSUlIir6ZNm1Z7TgAAAAAAAAD2OWIE5+jRo7Vw4UK9//77atKkSWR6ZmamysvLVVhYGDWKMy8vT5mZmZE2H3/8cdTyDjxl/UCbXxo/frzGjRsXeV9cXEyREwAAAIAjhUIVhnEGt1Rwm91n1mVw+wa3ZZbLE+O1HWO6DS25bMd43PZjJMllFiaPy/64J49hLhnch9iyDG/t4TKJMxsD5nGblVZ83jjbMaEY+zGSFA7Zj3FZHqNcbpf97eEy3IYmn3PYMtgYMt8X3Qa7VbDC7PgWqrDfx5DRd0VGFcUKw2Pp0ajTIzgty9Lo0aP1yiuvaNmyZWrRokXU/C5dusjr9Wrp0qWRaV999ZW2bdum7t27S5K6d++uzz//XPn5+ZE2S5YsUXJystq1a3fQvD6fT8nJyVEvAAAAAAAAAHVPnR7BOWrUKM2bN0+vvfaakpKSIvfMTElJUXx8vFJSUjRixAiNGzdOaWlpSk5O1pgxY9S9e3f96le/kiRddNFFateunYYMGaKHHnpIubm5+stf/qJRo0bJ5/PV5uoBAAAAAAAAOEZ1usA5a9YsSVLPnj2jps+ZM0fDhw+XJD322GNyu90aOHCgAoGA+vTpoyeffDLS1uPxaOHChbrlllvUvXt3JSQkaNiwYZo8eXJNrQYAAEdUVFRUo3FVqbb7brKcurDdJGf3HTXvWD57y7LkMr1+VfuvcIqLM7ssEgAAoLrV6QLn0dzfIC4uTjNnztTMmTMP2SY7O1tvvvlmVXYNAIAqEQqWS26PsrOzj2k5lsE9rY5Vbfe9KvLXxnaTnN131Lyq2F9cnhhZx3DfqwaN0vXjtq0UOQEAQJ1UpwucAAAc78IVQSkcUt97X1Jckv17Pu/bk6fFk4YobPBwhmNV230/lvy1ud0kZ/cdNa+qvmum8cGyEi0cf6UCgQAFTgAAUCdR4AQAoA7wxicoNj7RdlywrLQaemNPbffdJH9d2G6Ss/uOmnes3zXTeAAAgLquTj9FHQAAAAAAAAAOhwInAAAAAAAAAMeiwAkAAAAAAADAsShwAgAAAAAAAHAsCpwAAAAAAAAAHIunqDuM3+9XIBAwii0qKqri3gBAZabHGo5RAI6WyfGCYwwAAMDxiwKng/j9fjVplq1dBfnHtBwrHK6iHgHA/4SC5ZLbo+zs7GNaDscoAIdSFccZjjE4EYVDZvu9Fbbs5zL9jrnt5/K4XGapPPZjTI8cMS77yQxXS26TFTMVNutk2GCfslyGW99lkMsyW6+QUZQUdtm/qDZseCFuSPb3jwrL/jaUJHns99HtNtzxDfpomMm4j5Zlf9t7TDdH2P7eWBEMmuUy+L5UBKvvPIwCp4MEAgHtKshX/ynz5Y1PtB2/b0+eFk8aYvRHBQCOJFwRlMIh9b33JcUlJduO5xgF4EiO5TjDMQYAAOD4RYHTgbzxiYo1KHAGy0qroTcAEM0bn8AxCkC1MjnOcIwBAAA4fvGQIQAAAAAAAACORYETAAAAAAAAgGNR4AQAAAAAAADgWBQ4AQAAAAAAADgWBU4AAAAAAAAAjkWBEwAAAAAAAIBjUeAEAAAAAAAA4FgUOAEAAAAAAAA4FgVOAAAAAAAAAI5FgRMAAAAAAACAY1HgBAAAAAAAAOBYMbXdAQAAAABA9bFMx7W4wgbJLKNUlkGcJZdRrrBlf3u43Wb/dfZ642zHuGSw3SVZoXKjOMlg25t9zLIMVi3sMkxmsB3DLrPvSsgoSgobbMhgsMIwl/2YUNhszTwek33Y8PscNshl+DkbfFWM49xus+0RqrD/mYVCZp9zOGx/O1rGG/HIGMEJAAAAAAAAwLEocAIAAAAAAABwLAqcAAAAAAAAAByLAicAAAAAAAAAx6LACQAAAAAAAMCxKHACAAAAAAAAcCwKnAAAAAAAAAAciwInAAAAAAAAAMeiwAkAAAAAAADAsShwAgAAAAAAAHAsCpwAAAAAAAAAHIsCJwAAAAAAAADHiqntDgAAAAAAqo/b4zGKc1ku2zEe+yGSpLDsB4ZDllGukMEwnxiX2digcMh+jCfGMJfZ5lA4ZNDJsFkfQ2H7MW7DYVkGqWRZhhuxBuPCFRVmqUw2vmWwb0gKh4MGuUw+MSkcNjnomO1ULpfZAS5YYf9zrjD9nC2zOBMug+3o8VRfGZIRnAAAAAAAAAAciwInAAAAAAAAAMeiwAkAAAAAAADAsShwAgAAAAAAAHAsCpwAAAAAAAAAHIsCJwAAAAAAAADHosAJAAAAAAAAwLEocAIAAAAAAABwrBOqwDlz5kw1b95ccXFx6tatmz7++OPa7hIAAAAAAACAY3DCFDj//e9/a9y4cbrnnnu0bt06derUSX369FF+fn5tdw0AAAAAAACAoROmwDl16lTddNNNuuGGG9SuXTvNnj1b9erV07PPPlvbXQMAAAAAAABg6IQocJaXl2vt2rXKycmJTHO73crJydGqVatqsWcAAAAAAAAAjkVMbXegJuzcuVOhUEgZGRlR0zMyMrRp06ZK7QOBgAKBQOR9UVGRJKm4uLh6O3oEB/Lv25OvoL/UdnxZUcH/jy9QuMJfY7G1HU/fnZf7WOPpO313Ut/ZbvSdvh//uY81vrb7Hizbf95ZXFwsl8tlO74qHDgPtiyrVvIDAIC6zWWdAGcJ27dv10knnaSVK1eqe/fukel33XWX3nvvPa1evTqq/cSJEzVp0qSa7iYAAACAw/jhhx/UpEmT2u4GAACoY06IEZwNGzaUx+NRXl5e1PS8vDxlZmZWaj9+/HiNGzcu8j4cDmv37t1q0KBBrf1qLe3/5bpp06b64YcflJycXGv9wImJ/Q+1if0PtYn9D7WNfXD/yM29e/cqKyurtrsCAADqoBOiwBkbG6suXbpo6dKlGjBggKT9RculS5dq9OjRldr7fD75fL6oaampqTXQ06OTnJx8wp7covax/6E2sf+hNrH/obad6PtgSkpKbXcBAADUUSdEgVOSxo0bp2HDhqlr164666yzNG3aNJWWluqGG26o7a4BAAAAAAAAMHTCFDivvfZaFRQUaMKECcrNzVXnzp21aNGiSg8eAgAAAAAAAOAcJ0yBU5JGjx590EvSncLn8+mee+6pdPk8UBPY/1Cb2P9Qm9j/UNvYBwEAAA7vhHiKOgAAAAAAAIDjk7u2OwAAAAAAAAAApihwAgAAAAAAAHAsCpwAAAAAAAAAHIsCJwAAAAAAAADHosDpIDNnzlTz5s0VFxenbt266eOPP67tLuE49P777+vSSy9VVlaWXC6XXn311aj5lmVpwoQJaty4seLj45WTk6NvvvmmdjqL486UKVN05plnKikpSenp6RowYIC++uqrqDZ+v1+jRo1SgwYNlJiYqIEDByovL6+WeozjyaxZs9SxY0clJycrOTlZ3bt311tvvRWZz76HmvTXv/5VLpdLY8eOjUxjHwQAADg4CpwO8e9//1vjxo3TPffco3Xr1qlTp07q06eP8vPza7trOM6UlpaqU6dOmjlz5kHnP/TQQ5o+fbpmz56t1atXKyEhQX369JHf76/hnuJ49N5772nUqFH66KOPtGTJEgWDQV100UUqLS2NtLn99tv1+uuv68UXX9R7772n7du368orr6zFXuN40aRJE/31r3/V2rVr9cknn+jCCy/U5Zdfri+++EIS+x5qzpo1a/TUU0+pY8eOUdPZBwEAAA7OZVmWVdudwJF169ZNZ555pp544glJUjgcVtOmTTVmzBj98Y9/rOXe4Xjlcrn0yiuvaMCAAZL2j97MysrSHXfcod///veSpKKiImVkZOi5557ToEGDarG3OB4VFBQoPT1d7733ns477zwVFRWpUaNGmjdvnq666ipJ0qZNm9S2bVutWrVKv/rVr2q5xzjepKWl6eGHH9ZVV13FvocaUVJSojPOOENPPvmk7rvvPnXu3FnTpk3j+AcAAHAYjOB0gPLycq1du1Y5OTmRaW63Wzk5OVq1alUt9gwnmi1btig3NzdqX0xJSVG3bt3YF1EtioqKJO0vMknS2rVrFQwGo/bBU089Vc2aNWMfRJUKhUJ64YUXVFpaqu7du7PvocaMGjVK/fr1i9rXJI5/AAAAhxNT2x3Ake3cuVOhUEgZGRlR0zMyMrRp06Za6hVORLm5uZJ00H3xwDygqoTDYY0dO1Y9evRQhw4dJO3fB2NjY5WamhrVln0QVeXzzz9X9+7d5ff7lZiYqFdeeUXt2rXT+vXr2fdQ7V544QWtW7dOa9asqTSP4x8AAMChUeAEANRJo0aN0oYNG/Thhx/WdldwAmnTpo3Wr1+voqIivfTSSxo2bJjee++92u4WTgA//PCDbrvtNi1ZskRxcXG13R0AAABH4RJ1B2jYsKE8Hk+lp2Tm5eUpMzOzlnqFE9GB/Y19EdVt9OjRWrhwoZYvX64mTZpEpmdmZqq8vFyFhYVR7dkHUVViY2PVqlUrdenSRVOmTFGnTp30+OOPs++h2q1du1b5+fk644wzFBMTo5iYGL333nuaPn26YmJilJGRwT4IAABwCBQ4HSA2NlZdunTR0qVLI9PC4bCWLl2q7t2712LPcKJp0aKFMjMzo/bF4uJirV69mn0RVcKyLI0ePVqvvPKKli1bphYtWkTN79Kli7xeb9Q++NVXX2nbtm3sg6gW4XBYgUCAfQ/VrlevXvr888+1fv36yKtr164aPHhw5N/sgwAAAAfHJeoOMW7cOA0bNkxdu3bVWWedpWnTpqm0tFQ33HBDbXcNx5mSkhJt3rw58n7Lli1av3690tLS1KxZM40dO1b33XefWrdurRYtWujuu+9WVlZW5EnrwLEYNWqU5s2bp9dee01JSUmR+8qlpKQoPj5eKSkpGjFihMaNG6e0tDQlJydrzJgx6t69O08QxjEbP368+vbtq2bNmmnv3r2aN2+e3n33XS1evJh9D9UuKSkpcr/hAxISEtSgQYPIdPZBAACAg6PA6RDXXnutCgoKNGHCBOXm5qpz585atGhRpYe9AMfqk08+0QUXXBB5P27cOEnSsGHD9Nxzz+muu+5SaWmpRo4cqcLCQp1zzjlatGgR9wtDlZg1a5YkqWfPnlHT58yZo+HDh0uSHnvsMbndbg0cOFCBQEB9+vTRk08+WcM9xfEoPz9fQ4cO1Y4dO5SSkqKOHTtq8eLF6t27tyT2PdQ+9kEAAICDc1mWZdV2JwAAAAAAAADABPfgBAAAAAAAAOBYFDgBAAAAAAAAOBYFTgAAAAAAAACORYETAAAAAAAAgGNR4AQAAAAAAADgWBQ4AQAAAAAAADgWBU4AAAAAAAAAjkWBEwAAAAAAAIBjUeAEANS43NxcjRkzRi1btpTP51PTpk116aWXaunSpUcV/9xzzyk1NbV6OwkAAAAAcISY2u4AAODE8v3336tHjx5KTU3Vww8/rNNOO03BYFCLFy/WqFGjtGnTptruom3BYFBer7e2uwEAAAAAJyRGcAIAatStt94ql8uljz/+WAMHDtQpp5yi9u3ba9y4cfroo48kSVOnTtVpp52mhIQENW3aVLfeeqtKSkokSe+++65uuOEGFRUVyeVyyeVyaeLEiZKkQCCg3//+9zrppJOUkJCgbt266d13343K/8wzz6hp06aqV6+errjiCk2dOrXSaNBZs2bp5JNPVmxsrNq0aaP/+7//i5rvcrk0a9YsXXbZZUpISNB9992nVq1a6ZFHHolqt379erlcLm3evLnqNiAAAAAAIAoFTgBAjdm9e7cWLVqkUaNGKSEhodL8A4VGt9ut6dOn64svvtA//vEPLVu2THfddZck6eyzz9a0adOUnJysHTt2aMeOHfr9738vSRo9erRWrVqlF154QZ999pmuvvpqXXzxxfrmm28kSStWrNBvf/tb3XbbbVq/fr169+6t+++/P6oPr7zyim677Tbdcccd2rBhg26++WbdcMMNWr58eVS7iRMn6oorrtDnn3+uESNG6MYbb9ScOXOi2syZM0fnnXeeWrVqVSXbDwAAAABQmcuyLKu2OwEAODF8/PHH6tatm+bPn68rrrjiqONeeukl/fa3v9XOnTsl7b8H59ixY1VYWBhps23bNrVs2VLbtm1TVlZWZHpOTo7OOussPfDAAxo0aJBKSkq0cOHCyPxf//rXWrhwYWRZPXr0UPv27fX0009H2lxzzTUqLS3VG2+8IWn/CM6xY8fqsccei7TZvn27mjVrppUrV+qss85SMBhUVlaWHnnkEQ0bNszWdgIAAAAAHD1GcAIAaszR/qb2zjvvqFevXjrppJOUlJSkIUOGaNeuXdq3b98hYz7//HOFQiGdcsopSkxMjLzee+89ffvtt5Kkr776SmeddVZU3C/fb9y4UT169Iia1qNHD23cuDFqWteuXaPeZ2VlqV+/fnr22WclSa+//roCgYCuvvrqo1pnAAAAAIAZHjIEAKgxrVu3lsvlOuyDhL7//nv1799ft9xyi+6//36lpaXpww8/1IgRI1ReXq569eodNK6kpEQej0dr166Vx+OJmpeYmFil6yHpoJfY/+Y3v9GQIUP02GOPac6cObr22msP2V8AAAAAQNVgBCcAoMakpaWpT58+mjlzpkpLSyvNLyws1Nq1axUOh/Xoo4/qV7/6lU455RRt3749ql1sbKxCoVDUtNNPP12hUEj5+flq1apV1CszM1OS1KZNG61ZsyYq7pfv27ZtqxUrVkRNW7Fihdq1a3fE9bvkkkuUkJCgWbNmadGiRbrxxhuPGAMAAAAAODYUOAEANWrmzJkKhUI666yz9PLLL+ubb77Rxo0bNX36dHXv3l2tWrVSMBjUjBkz9N133+n//u//NHv27KhlNG/eXCUlJVq6dKl27typffv26ZRTTtHgwYM1dOhQzZ8/X1u2bNHHH3+sKVOmRO6dOWbMGL355puaOnWqvvnmGz311FN666235HK5Isu+88479dxzz2nWrFn65ptvNHXqVM2fPz/yIKPD8Xg8Gj58uMaPH6/WrVure/fuVbvxAAAAAACVUOAEANSoli1bat26dbrgggt0xx13qEOHDurdu7eWLl2qWbNmqVOnTpo6daoefPBBdejQQXPnztWUKVOilnH22Wfrt7/9ra699lo1atRIDz30kKT9Ty0fOnSo7rjjDrVp00YDBgzQmjVr1KxZM0n776U5e/ZsTZ06VZ06ddKiRYt0++23Ky4uLrLsAQMG6PHHH9cjjzyi9u3b66mnntKcOXPUs2fPo1q/A5fS33DDDVWzwQAAAAAAh8VT1AEAJ7SbbrpJmzZt0gcffFAly/vggw/Uq1cv/fDDD8rIyKiSZQIAAAAADo2HDAEATiiPPPKIevfurYSEBL311lv6xz/+oSeffPKYlxsIBFRQUKCJEyfq6quvprgJAAAAADWES9QBACeUjz/+WL1799Zpp52m2bNna/r06frNb35zzMt9/vnnlZ2drcLCwsgl8wAAAACA6scl6gAAAAAAAAAcixGcAAAAAAAAAByLAicAAAAAAAAAx6LACQAAAAAAAMCxKHACAAAAAAAAcCwKnAAAAAAAAAAciwInAAAAAAAAAMeiwAkAAAAAAADAsShwAgAAAAAAAHAsCpwAAAAAAAAAHIsCJwAAAAAAAADHosAJAAAAAAAAwLEocAIAAAAAAABwLAqcAAAAAAAAAByLAicAAAAAAAAAx6LACQAAAAAAAMCxKHACAA7r22+/1c0336yWLVsqLi5OycnJ6tGjhx5//HGVlZXZXt6TTz6p5557ruo76hBvv/22RowYoQ4dOsjj8ah58+aHbLtjxw6NHDlSLVq0UHx8vE4++WSNGzdOu3btqrkOAwAA1CDOPatWz5495XK5Kr0uvvji2u4aUKVclmVZtd0JAEDd9MYbb+jqq6+Wz+fT0KFD1aFDB5WXl+vDDz/Uyy+/rOHDh+vpp5+2tcwOHTqoYcOGevfdd6un03Xc8OHD9e9//1tnnHGGtm3bJo/Ho++//75Su5KSEnXo0EGlpaW69dZb1bRpU3366ad66qmn1L59e61du1ZuN79TAgCA4wfnnlWvZ8+e+vbbbzVlypSo6VlZWbrwwgtrqVdA1Yup7Q4AAOqmLVu2aNCgQcrOztayZcvUuHHjyLxRo0Zp8+bNeuONN2qxh9WrtLRUCQkJVb7cBx54QM8884y8Xq/69++vDRs2HLTdggULtHXrVi1cuFD9+vWLTE9LS9PkyZP16aef6vTTT6/y/gEAANQGzj2r59xTklJSUvTrX/+6WpYN1BUM/QAAHNRDDz2kkpIS/f3vf486wTygVatWuu222yLv58yZowsvvFDp6eny+Xxq166dZs2aFRXTvHlzffHFF3rvvfcil8f07NkzMr+wsFBjx45V06ZN5fP51KpVKz344IMKh8NRy9m1a5eGDBmi5ORkpaamatiwYfr000/lcrkqXYK0bNkynXvuuUpISFBqaqouv/xybdy4MarNxIkT5XK59OWXX+r6669X/fr1dc4552jOnDlyuVz673//W2n9H3jgAXk8Hv3000/auXOnNm3apH379h1xu2ZlZcnr9R6xXXFxsSQpIyMjavqBzyI+Pv6IywAAAHAKzj2r59zzgIqKCpWUlBx1e8BpGMEJADio119/XS1bttTZZ599VO1nzZql9u3b67LLLlNMTIxef/113XrrrQqHwxo1apQkadq0aRozZowSExP15z//WdL/Cnj79u3T+eefr59++kk333yzmjVrppUrV2r8+PHasWOHpk2bJkkKh8O69NJL9fHHH+uWW27Rqaeeqtdee03Dhg2r1Kd33nlHffv2VcuWLTVx4kSVlZVpxowZ6tGjh9atW1fp/pdXX321WrdurQceeECWZemqq67SqFGjNHfu3EqjJefOnauePXvqpJNO0sSJEzVp0iQtX7486qT5WJx33nlyu9267bbb9Oijj6pJkyb67LPPdP/992vAgAE69dRTqyQPAABAXcC5Z/Wde3799ddKSEhQeXm5MjIydNNNN2nChAlH9aM74BgWAAC/UFRUZEmyLr/88qOO2bdvX6Vpffr0sVq2bBk1rX379tb5559fqe29995rJSQkWF9//XXU9D/+8Y+Wx+Oxtm3bZlmWZb388suWJGvatGmRNqFQyLrwwgstSdacOXMi0zt37mylp6dbu3btikz79NNPLbfbbQ0dOjQy7Z577rEkWdddd12lfl133XVWVlaWFQqFItPWrVsXletA/PLlyytvmMPo16+flZ2dfcj5f/vb36zU1FRLUuQ1bNgwKxgM2soDAABQl3Hu+T9Vfe554403WhMnTrRefvll65///Kd12WWXWZKsa6655oixgJNwiToAoJIDl0cnJSUddczPL5kuKirSzp07df755+u7775TUVHREeNffPFFnXvuuapfv7527twZeeXk5CgUCun999+XJC1atEher1c33XRTJNbtdkd+qT9gx44dWr9+vYYPH660tLTI9I4dO6p379568803K/Xht7/9baVpQ4cO1fbt27V8+fLItLlz5yo+Pl4DBw6UtP8yI8uyqmz05gEnnXSSzjrrLE2bNk2vvPKKxo0bp7lz5+qPf/xjleYBAACoTZx7/k9Vn3v+/e9/1z333KMrr7xSQ4YM0WuvvaabbrpJ//nPf/TRRx8dMR5wCi5RBwBUkpycLEnau3fvUcesWLFC99xzj1atWlXpfkBFRUVKSUk5bPw333yjzz77TI0aNTro/Pz8fEnS1q1b1bhxY9WrVy9qfqtWraLeb926VZLUpk2bSstq27atFi9eXOlm7i1atKjUtnfv3mrcuLHmzp2rXr16KRwO6/nnn9fll19u6yTcrhUrVqh///766KOP1LVrV0nSgAEDlJycrEmTJunGG29Uu3btqi0/AABATeHc839q4tzzjjvu0DPPPKN33nlHv/rVr6pkmUBto8AJAKgkOTlZWVlZh3zC9y99++236tWrl0499VRNnTpVTZs2VWxsrN5880099thjlW7UfjDhcFi9e/fWXXfdddD5p5xyiq11MHGwB/d4PB5df/31euaZZ/Tkk09qxYoV2r59e7U/ifKpp55SRkZGpLh5wGWXXaaJEydq5cqVFDgBAMBxgXPP/6mJc8+mTZtKknbv3l1lywRqGwVOAMBB9e/fX08//bRWrVql7t27H7bt66+/rkAgoAULFqhZs2aR6T+/tOYAl8t10GWcfPLJKikpUU5OzmFzZWdna/ny5dq3b1/UL+mbN2+u1E6Svvrqq0rL2LRpkxo2bBj1C/rhDB06VI8++qhef/11vfXWW2rUqJH69OlzVLGm8vLyFAqFKk0PBoOS9j8JEwAA4HjBuef/VPe553fffSdJhxy9CjgR9+AEABzUXXfdpYSEBP3mN79RXl5epfnffvutHn/8cUn7f2mWJMuyIvOLioo0Z86cSnEJCQkqLCysNP2aa67RqlWrtHjx4krzCgsLIwW9Pn36KBgM6plnnonMD4fDmjlzZlRM48aN1blzZ/3jH/+Iyrdhwwa9/fbbuuSSSw6z9tE6duyojh076m9/+5tefvllDRo0SDEx//uNcOfOndq0aVOly6OOxSmnnKK8vDy9++67UdOff/55Sar0ZE0AAAAn49zzf6rq3LO4uFiBQCBqmmVZuu+++yLrBhwvGMEJADiok08+WfPmzdO1116rtm3baujQoerQoYPKy8u1cuVKvfjiixo+fLgk6aKLLlJsbKwuvfRS3XzzzSopKdEzzzyj9PR07dixI2q5Xbp00axZs3TfffepVatWSk9P14UXXqg777xTCxYsUP/+/TV8+HB16dJFpaWl+vzzz/XSSy/p+++/V8OGDTVgwACdddZZuuOOO7R582adeuqpWrBgQeQSm5//Sv/www+rb9++6t69u0aMGKGysjLNmDFDKSkpmjhxoq3tMXToUP3+97+XpEqXCD3xxBOaNGmSli9ffsSbvX/22WdasGCBpP2//BcVFUVOMjt16qRLL71UkjR69GjNmTNHl156qcaMGaPs7Gy99957ev7559W7d29169bNVv8BAADqMs49o1XFuee6det03XXX6brrrlOrVq1UVlamV155RStWrNDIkSN1xhln2OoTUKfV6jPcAQB13tdff23ddNNNVvPmza3Y2FgrKSnJ6tGjhzVjxgzL7/dH2i1YsMDq2LGjFRcXZzVv3tx68MEHrWeffdaSZG3ZsiXSLjc31+rXr5+VlJRkSbLOP//8yLy9e/da48ePt1q1amXFxsZaDRs2tM4++2zrkUcescrLyyPtCgoKrOuvv95KSkqyUlJSrOHDh1srVqywJFkvvPBCVP/feecdq0ePHlZ8fLyVnJxsXXrppdaXX34Z1eaee+6xJFkFBQWH3A47duywPB6Pdcopp1SadyB++fLlR9yec+bMsSQd9DVs2LCotps2bbKuuuoqq2nTppbX67Wys7Ot3//+91ZpaekR8wAAADgR5577VcW553fffWddffXVVvPmza24uDirXr16VpcuXazZs2db4XD4sLGA07gs62djugEAcKhXX31VV1xxhT788EP16NGjype/c+dONW7cWBMmTNDdd99d5csHAACAc3DuCdQt3IMTAOA4ZWVlUe9DoZBmzJih5OTkarvU5rnnnlMoFNKQIUOqZfkAAAComzj3BOo+7sEJAHCcMWPGqKysTN27d1cgEND8+fO1cuVKPfDAA4qPj6/SXMuWLdOXX36p+++/XwMGDFDz5s2rdPkAAACo2zj3BOo+LlEHADjOvHnz9Oijj2rz5s3y+/1q1aqVbrnlFo0ePbrKc/Xs2VMrV65Ujx499K9//UsnnXRSlecAAABA3cW5J1D3UeAEAAAAAAAA4FjcgxMAAAAAAACAY1HgBAAAAAAAAOBYFDgBAAAAAAAAOBZPUQfqkFandTCKS/Ym2Y7J3bnTKFdcrMt2jM/nM8p1eatM+7lOaWeUa/m6/9qOSYoxe2LiTwWFRnFZ9e3/JpVWv5FRrrh6KbZj9vjNbun88TebbMfUKw8Z5fLFeYziguVB2zFhgxhJChr89BgTDhvlSoiLs58r1uy30YoKg7iTmhvlStxdbBSXtzfPfi632anUvoD9z6wkUGiUq2lGQ9sxjU9uaZRr/tx/G8UBqF5NmrcyigvL/t/2uFivUS6XZf8csyJk9vcvXFFhP8gyy+WJsX/u4XYbnq9UmJ0fhUL2t4cVNtiGkgx2Kblc9veN/QzOPUxTmQa6au6RKEbb0fSRLQZxobBZrrDBd9P0Y3aZ7MA1zeBzdrvNzu9NdqlwyOw4tWPH9iO2YQQn8P/atddgy9KzPuzPWnvvc+/rdM/0TM9opNFdIDMgkUhG2CYKkQhQAgmcCxhUccWJnbgMBIyxwxdI2Ri7HIrgKrsqqQpJYWzkYCPiEJJYTsKlAJkg6z6SRtKMZjSX7unTffrc9tl7r5UPg6s/pdLPQ810v6rf7/v//Ndee613vfs5CwAAAIBmGXACAAAAAM0y4AQAAAAAmmXACQAAAAA0y4ATAAAAAGiWAScAAAAA0CwDTgAAAACgWQacAAAAAECzDDgBAAAAgGYZcAIAAAAAzTLgBAAAAACaZcAJAAAAADTLgBMAAAAAaNb0Th8AcMtaPyvlJn3+Vt45d6bUNVudpDOTrZ1S1z997HPpzDfOasvafefPpjObm1ulruev3izlxmFMZ1b5yIu5Qmba1cre9OCFfGhZu1e+8KWnS7lZl/9/4NFyWeqKyJ/HSfG6n/RdOjNf1v43Oh/zV9W9/Vqpa/dwv5SbDot8ZlZbB1bdYTozi9r5eO7K9XTm2uEflLqAu1NxOxDTaf55OylkIiJizB/lrJ+UqpaFE7JYzktdsco//wqn4l8ni6l8rivsjf51W7or8vuViIghhnRmHGtd5bus8mUXD7F0HusXY1r1kuoL31lfLSuej7GQq2SquWHI3yt/2JaPDJVfmrfHG5wAAAAAQLMMOAEAAACAZhlwAgAAAADNMuAEAAAAAJplwAkAAAAANMuAEwAAAABolgEnAAAAANAsA04AAAAAoFkGnAAAAABAsww4AQAAAIBmGXACAAAAAM0y4AQAAAAAmjW90wcA3DKZnCrlrsWQzqyW+UxExHgyT2f+4lveVOp6rH9tOvPrv/cHpa57N47SmW97y1tKXZ8e8+cwImIYZ/lMV6qKYRzTmb7YNTk6SWe+9mteU+r6/JeeKeXG5XE6s7mxUeramOZzy25R6nph/yCd2djYLHXdf/mV6cwLzzxV6uq62vp2Y7WezswWk1LXfJ7/zvrCfRkR0Q358zHmL3ngblZbPmIsrB/L5arUNZvm9zljcb0fS3uW2kZnGPPHOKxqX1jf195f6rr8Zytu+0rG4vNvqDz/ivdK5Ry+mCtkSk3FXPVzFTLFU1+8fmufq3otVmLV81FRWev/MJlOVNep2/rbL9lfBgAAAAB4iRlwAgAAAADNMuAEAAAAAJplwAkAAAAANMuAEwAAAABolgEnAAAAANAsA04AAAAAoFkGnAAAAABAsww4AQAAAIBmGXACAAAAAM0y4AQAAAAAmmXACQAAAAA0y4ATAAAAAGjW9E4fAHDLO9797aXcb330k+nM0ROfLXWtr++mM08vav9L+dpX3pPOfPrh15a6vvD4v0pn/vGHP1LqWq5qS+84TNKZLsZSVzcMlVSp6/oy/7n+t//rX5a6psOqlOsKH+2kq133i6PjdGbsat/z5tq5dOb8hbOlrpMhfxLH1aLUdWljs5Sbre2kMw88cLnUtXo6vw5cv3G91LXYu5rObMes1AXcncax8lyPqGwHFotlqau6j6gYCh9sLO6pXk7jWNz3FXLVrkqu2hWFXFfZ9EVEFPdiJdXTUQh2Y+18lFac4rnvCnvu6rfVxHVf+nQv3/U7Fq+p2+ENTgAAAACgWQacAAAAAECzDDgBAAAAgGYZcAIAAAAAzTLgBAAAAACaZcAJAAAAADTLgBMAAAAAaJYBJwAAAADQLANOAAAAAKBZBpwAAAAAQLMMOAEAAACAZhlwAgAAAADNmt7pAwBu+fTVL5Vy/9abXpXO3Hz7V5W6+mc+mc7Ml2dLXf/88afTmdn8qNT1qnP3pzNfOjosde1E7Ri7wv+k+qFUFV3XFUK1rqOjeTpzcLBf6tpcX5Vy9559YzrzQuUcRkQ/LtOZG1/6TKnr4dc+ks58/PFPlbqmy+N05sFTa6Wu1blzpdz2Uf76+OTj+TUxImIy5M/HxqT2f+m1ra10ZhyLNzRwVyo91yNitcpvJLq+uH6sCs/ocSxVDYWusbinitK5r32u4umIoRAch9oJeVmfLv3L+D5X8YOVvrLqF12IjcULv3KEXT8pdfWFNad6HY7FY4zIn8eheI9VLo/iFRVd4R6bTGfFtv9/3uAEAAAAAJplwAkAAAAANMuAEwAAAABolgEnAAAAANAsA04AAAAAoFkGnAAAAABAsww4AQAAAIBmGXACAAAAAM0y4AQAAAAAmmXACQAAAAA0y4ATAAAAAGiWAScAAAAA0CwDTgAAAACgWdM7fQDALdc///FS7vFXvi6dWewOpa61xVE688e/9utLXd3eQ+nM0Sc/U+p68vF87vjkoNS10S1LuWFcpTPLofg9j/ncqpuUulaFR9HF86dLXT/xgz9Xyj1475vTmb/x4Q+Vun7jH/1MOrMxKz7OF7N05NSkdk0txvz/VHcLmYiIS4fzUu6J6zfSmVnxHpusFunMyWIsdQ2RXzvW1m0R4StJN6k9o6fT/Do8m66VuobCejos82tpRERXCpVSMUZh7a4t9zEUg5VzH2PxIAvKTX3+uu8m+b3Ri1W152bX5e+xYVn7LRFDfj8wFjIvBvPfWld+/y6f6/va/Rxd7WostRXvsdI6UPwdN13Pr/cbG+ulrtvhDU4AAAAAoFkGnAAAAABAsww4AQAAAIBmGXACAAAAAM0y4AQAAAAAmmXACQAAAAA0y4ATAAAAAGiWAScAAAAA0CwDTgAAAACgWQacAAAAAECzDDgBAAAAgGYZcAIAAAAAzZre6QMAbtn74hdLuaf29tOZrbPnS12TbpnOfGTz/yl1bd/7cDrzyJteU+raeviBdOYzj32u1NU/9aVSLrrr+a5xrHWNQzrSFatOn9pKZ97zllmp63e++OZS7rf/2V468xN/9l21rn/yC+nMavJ0qWu5zN/P0+lGqWsyW6Uzm1tnSl1PH85LubVuks5sb66XuqaFe/Mkauf++RdeSGcmq+NSF3B3ms1qz82usC5OpmulrtVikc6MhX1pRETX5z9XV9gbRUSMhfV+iNqmahxqxzgUjrEvHmPXd+nMpKu9lzWZ5p/R/TS/L42ImG2eKuUmk/z9cjI/qXV1+b3YsKjtB8Zl/n5eDrX7eTnmP9cYtXulcPlGRO2678ZiWf50RBSrJoVbczp76d6z9AYnAAAAANAsA04AAAAAoFkGnAAAAABAsww4AQAAAIBmGXACAAAAAM0y4AQAAAAAmmXACQAAAAA0y4ATAAAAAGiWAScAAAAA0CwDTgAAAACgWQacAAAAAECzDDgBAAAAgGYZcAIAAAAAzZre6QMAbpmOQym3WOYzz3zxS6WuSZ8/xm51UurauH6UzlyZbZS6bi7yXfef3S51rRb3l3KLGzfTmWEcS12ryH/Pw9iVuu695zCdeeu7/3Gp6wf+Tv57jog4O+Svq4/9+rVS13vf95+mMx/65Z8qde1e/3I+VL2ft7bSmZNYL3Vtrhal3MHJcTqzc+ZcqevqXv58zA52S11nz5xKZ5bHs1IXcHdan62VcvN5fj1djoWNaUSMUdhH9JNSV6zy+5zS8UVE1+Vzk77WtRprz78obBe7vvau1Gwtv6faWs8/MyMiZlG47iebpa5+/UwpN07y56Mv/B6LiFhfy19XfeE3UkTEcHyQzpx0tc91c57vWi7zvz8iIsbi+la5yWq/4iKisOZE9TfjMr/mnJy8dO9ZeoMTAAAAAGiWAScAAAAA0CwDTgAAAACgWQacAAAAAECzDDgBAAAAgGYZcAIAAAAAzTLgBAAAAACaZcAJAAAAADTLgBMAAAAAaJYBJwAAAADQLANOAAAAAKBZBpwAAAAAQLOmd/oAgFsWi5NSbhwn6cxqOS91bZ66lM48+/ReqWvx5L9KZyZbtWVttp4/h/ub50pdi5s3Srl7Nod0ZhjzmYiIGPORaV8IRcS7v/Fb0pm/9z/W7pX1o1IsDoZVOvPznzgodf33P/y2dOZXfu1CqetSn18Hru7VrqlVn783x+Pa2nH53NlS7rEvP5fOLE52Sl0nR4fpTPEWi63NrXTmcFG8WYC70qSrvdfSjfmFZ2N9rdQVk/xe7Pi4VjVfLtOZcagtwl2fP/fTWW0/21U2cBExrPL7nOnarNS1uX0xnTmzXdvnrI4K33NXO/ercaOUOzrq8l1D8RhX+a6tfr3UFav8/bxztranGjb205n9vSulruW8tjcdh/xiNUb++4qI6ArrfXXtqMRWy2LXbfAGJwAAAADQLANOAAAAAKBZBpwAAAAAQLMMOAEAAACAZhlwAgAAAADNMuAEAAAAAJplwAkAAAAANMuAEwAAAABolgEnAAAAANAsA04AAAAAoFkGnAAAAABAsww4AQAAAIBmGXACAAAAAM2a3ukDAG6ZrW+Wcjs7O+nM/Przpa7ZLH+MfZzUuqan0pmru3ulrunqhXTmYP2g1LXRDaXcan0jH+pry/xqyP//6xUXbpS6Lr/6h9KZT/3ybqnr0e2nSrnFK06nM889uVXq+qUPPpnOvOdb/lKp61f+wV9JZybT/LmIiDg6PExnupiXul44XCvllpHPjYtSVXTDMp0ZNialruU8f5DdtHYOgbvTsKrtPWIc05HZtLZWTdbX05lhtSp1LY/zz5daU0Q/ye+pptPa/m0cat/zdDpLZ7Z2zpa61nbuSWf2FvnfOhERqzH/rW1v5q/DiIj1WS3XF+6XIfLfV0TEqnC/zBf5/UpExLLr0pmjo9rasV64prZ38scXEXEw5NfEiIiTwr6vK1y/ERF9X/tsNfnzMelr3/Pt8AYnAAAAANAsA04AAAAAoFkGnAAAAABAsww4AQAAAIBmGXACAAAAAM0y4AQAAAAAmmXACQAAAAA0y4ATAAAAAGiWAScAAAAA0CwDTgAAAACgWQacAAAAAECzDDgBAAAAgGYZcAIAAAAAzZre6QMAblmNtf85zOeLfKiv3f7HR9fymfnNUtdkJ5/pxv1S187p0+nMsL5d6prsPVvK9WOXzozDstR1MpunMz/wXT9d6nrXf/14OjMdz5a63v8XHizluvvz18df+2tfLHX988+upTM//W//sVLXB848kM5s3vh0qSuWq3Tk4LB2P2+tnyrlZv1mOnN192qpa9mP6cxazEpd67NJOrPo10tdwN1ptaztB2LMr92zaX6/EhExdkM603X5tTQiYjLN77nH4j49xvznWq5q39d0Wtvfn965mM5Mts+Xum7O8+fxYH5U6rrv0oV05vL9Z0td956u/S44t30mnZlMa8/o6zfz+6rdvdpe7IkvX0lnni1kIiJObuavqa2Nwg/NiNjaya+JERHjmP+9vjyudVXWnMnLOBmc1B4Rt8UbnAAAAABAsww4AQAAAIBmGXACAAAAAM0y4AQAAAAAmmXACQAAAAA0y4ATAAAAAGiWAScAAAAA0CwDTgAAAACgWQacAAAAAECzDDgBAAAAgGYZcAIAAAAAzTLgBAAAAACaNb3TBwDccrLsSrmt1XE+NFkvdR3Mb6Qza2unSl3T2dl81+xmqWsYV+nMdDwpda1tninlusgf4zgsS13veej16czf/+hDpa7+Zv6a+oav2y91vfnRR0q5M/flM5uvG0pd+x+dpTMf+q2rpa7/5F1/Kd/1kZ8tdT332afTmYN+UuraWqvlLt6Tv4affObJUtdkPk9nZlG7pg6O8s+IcZa/DoG712qs5YbCurNYFPalETGJtXym+LrOtBAch1rZOObP4bjK7/kiIta2t0q5U2cvpTP7R/nvKyJinB+mM49cfqDU9cjr8rn7Ltaef2c2ar/jNkp7ltr1ce7CZjpz4ah23d/34Pl05jOfqf1GevxzT6Qzx7VlKnbWT5dy0+184d6y9lvzZHGQzgzL2h4zCs+I/iV8zdIbnAAAAABAsww4AQAAAIBmGXACAAAAAM0y4AQAAAAAmmXACQAAAAA0y4ATAAAAAGiWAScAAAAA0CwDTgAAAACgWQacAAAAAECzDDgBAAAAgGYZcAIAAAAAzTLgBAAAAACaZcAJAAAAADRreqcPALhlKN6Sa4uTdGa2tVnqGueTdKbv8pmIiMXB1XRm2tXO4eHxMt91uFfqWq3XjnG5uZbOnN+u/R/rkW/7/nTmp3786VLXA13+GP/yf/DKUtfi5KlS7sYn89fiX/2+ryl1/ch/8bF05sMfuVTq+rH/8s35rqvvKHWdufBkOnMS+fsyImK6KsViI8Z05oXNe0pd1x//SDozzualro1YT2euD/lzAdy9VoX1LSJijC6dWS5ri/A45vezi5N8JiJiuco/X7oufy5ezOX3fV03K3X1051S7uZx/vo42l+Uuh68dDGdec0jtX3OEIfpzFNPXil1XV+v7bkv3Xshndna2S517d08Tmeu3zwqda26/DE+cPlUqevoOH8On//SjVLX4jB/TUVETPr8Pb22tlXqOl7kv+cYanvuyrK4WA6lrtvhDU4AAAAAoFkGnAAAAABAsww4AQAAAIBmGXACAAAAAM0y4AQAAAAAmmXACQAAAAA0y4ATAAAAAGiWAScAAAAA0CwDTgAAAACgWQacAAAAAECzDDgBAAAAgGYZcAIAAAAAzZre6QMAbunHWu5oeZTOTM6cLnXd3DtMZ86cmpW6+iH/P5ijo71S17Rw7k+dO1Pr2ryvlFuuvpTOvO/Rryt1/Tf/w0E6szFeLHX9m+/u0pn1t26Vut7xp/50Kfe6zc+kM7/4gQ+Wuta/Kn9dfflTy1LXh379qXTmNWdeUer6P/7gf0pn1sfa59q+cK6UO/Xar0ln/thDby11fXiZ/2wb1x8rde1ez9/PN3afLXUBd6dJl3/WRkQM/SSdWS6HWteQzw3DqtTVReEYu/y5iIjou8pP7vVS17Cq5Y4X+fOxvnG21PXAQ5fzoS7/HIuI2L2S3+ccndS6nutqe5ZnDnfTmUuX7i11Pfvla+nM4rB4jy3zuZ3TZ0td992bPx8n+7U18ebVRSk3dmvpTD/dLHV1hbVqGIqDiEJsWVy3b4c3OAEAAACAZhlwAgAAAADNMuAEAAAAAJplwAkAAAAANMuAEwAAAABolgEnAAAAANAsA04AAAAAoFkGnAAAAABAsww4AQAAAIBmGXACAAAAAM0y4AQAAAAAmmXACQAAAAA0y4ATAAAAAGjW9E4fAHDLsFqUcuc2TqczX97bK3XFcJCOrIpLzd6Nm+nM1lrt/zaTSf4Yj2pfV5zq858rIuLRc0M68+xbv6vU9diHttKZM5dulLp+9Dtem84clZoidp89LuVWa1fSmbX+c6Wun/0z/24685//+OOlro99rEtnvun9X1fq+sV/ciadOXPw0VLXzd389xURsTx6IZ05+8raWnru3EY6s38t/31FRFzfzR/jww9dLHUBd6dJX1s/hvzWIxaL4gYpxnxiLBxgRETkz0c/qZ3DvpukM5M+/4yIiFibbZdyxwf587h9z06pa/vcuXRmb3e31DUtvM919nz++CIibuS/5hdzwyqdObk5L3WtZmvpzOnTtet+sp/fc9+4eq3Udf9Dl9OZM2dOlbr2b1wv5Var/G/Nfrpe6ur7WTozrKrvPubXjtoVdXu8wQkAAAAANMuAEwAAAABolgEnAAAAANAsA04AAAAAoFkGnAAAAABAsww4AQAAAIBmGXACAAAAAM0y4AQAAAAAmmXACQAAAAA0y4ATAAAAAGiWAScAAAAA0CwDTgAAAACgWdM7fQDALV2sSrnrR4fpzHxV+//GtBA72j8udQ2ro3Tm5GRS6jq1tZ3OTCsnIyKWk9r5eNWffm868/P/3UGpq3Ip/q33f1Wp6vTrt9KZ/JXxh7q1UuzyG1+dzszWa9fiV78lf10Nb6h9ro9/bJbOvON356WuP/WO96Uz//uvfLzUNe6/UMotDvfTmf6odj4++/kr6czkJL/WR0RMV/k1Z3m8UeoC7k5dV8uNMVZCJZM+/9zsCpmIiLFwjF3UTmJfOPl9X3uur5bF95fG/MZvY6PWtbmV3/ddu1L7no/2T9KZ9X5R6lrNatfHSf4QY6xtB2Ia+c927/0XS11bp+9JZ65/6olS12ySv1821ktV0U9q3/Oy8tu7uA5En9/fd8V3H/vC6ei74kPidv72S/aXAQAAAABeYgacAAAAAECzDDgBAAAAgGYZcAIAAAAAzTLgBAAAAACaZcAJAAAAADTLgBMAAAAAaJYBJwAAAADQLANOAAAAAKBZBpwAAAAAQLMMOAEAAACAZhlwAgAAAADNMuAEAAAAAJo1vdMHANzSd6tS7nCav5VXy6HU1Xdr6czJ8UGpa9pP0pnZWv74IiKOYpbObC3mpa5vfWBRyr1++K505uefrS3zDz6c///Xv/GNW6WuimUxN5nulHLftHg+neknp0tdm4XMz77vYqnrL3zyajrzf36ktnY8+h1vTWc+/KHXlrr2d/9lKXdwMqYzj33qC6WuU1un0pmDSX5NjIjYWNtOZ8ZuvdQF3KX66nstXaEqn4mImBX2s31X+1yrVX7PPYy1fXoX+WdLVzjvERHjUDsfXf4QS99XRERfuBbHsXY+Fov8B5sc1vY5MdR2p1ur/LN9Z3uj1HV0dD2dOfvKy6Wu5WH+e55EbZ8z7fPX4mxa+54nxTVnWXi3sOtq56Or7BeLn6sr3Jp9X1hwbvdvv2R/GQAAAADgJWbACQAAAAA0y4ATAAAAAGiWAScAAAAA0CwDTgAAAACgWQacAAAAAECzDDgBAAAAgGYZcAIAAAAAzTLgBAAAAACaZcAJAAAAADTLgBMAAAAAaJYBJwAAAADQLANOAAAAAKBZ0zt9AMAt/eZ2KTeZ5P9XsTEsSl2LrrBsDKtS1/rmej5z5lypa7XIn8PtfrfU9Zbv+xul3I/8/SGdOT2pnfv/9rsv5UNbpaqSsZgb+o1S7swrXlNIXS51VbzhG2onf/vhtXTm44/X1o7v/vJOOnPvW95V6up+76lS7vrB1XRmfTN/DiMiVtP8+jYcn5S6YtKlI3v7h7Uu4K40jpNasMvnur72lM6vVHXjmN9TjUM+ExGxinxuiNqzdjqpHeNQOPvjUPvGFsdH+dA4L3WdO39POrM+qz3X9/ZulnKTVf67ng61+3lSyA3L2vd8NC/sWYprR8U4FN/1G6vvCBbO48u5KBa7ukJuMik+j26DNzgBAAAAgGYZcAIAAAAAzTLgBAAAAACaZcAJAAAAADTLgBMAAAAAaJYBJwAAAADQLANOAAAAAKBZBpwAAAAAQLMMOAEAAACAZhlwAgAAAADNMuAEAAAAAJplwAkAAAAANGt6pw8AuOVoOZRy495hOnPfmbOlruf39tOZrqt9rrXpLJ1ZX42lrkrq0UffUOr66G8/XMqtL7fTmT/xx7dKXfd/6z2l3MuldkVFrK3lz2FExPDahwqp+0pdFee6Wu7H/sylfOYnP1Pq+oXfPUpn3v8d7yp1/ZXf/dVSbqN7Pp3ZXD9d6loslunM9qy2bdubn6Qzw3yv1AXcnVbL/JpTNQy1p/Qy8g+zcVyVuirnYyztFiPG0q6l9n2dLPLP2oiIsVtLZw72Dkpdi5v53xLT4s5vbWMznTlZ1d4BO478OYyImPf5vv1F7XwM0/wxPnltt9R1ZvNcOtPNaudwWfgNvb9fu1cWi9qaU/iaYznU1oFhmd/3xVj8dVX8DfJS8QYnAAAAANAsA04AAAAAoFkGnAAAAABAsww4AQAAAIBmGXACAAAAAM0y4AQAAAAAmmXACQAAAAA0y4ATAAAAAGiWAScAAAAA0CwDTgAAAACgWQacAAAAAECzDDgBAAAAgGYZcAIAAAAAzZre6QMAbpnEWMoNJ8fpzPFiUepaiy6dGdY2Sl1jN0tn1ieTUtfh+Fw68+ff/TOlru/8e7VjfHWf/57/4++8VOrq7/J/fw3F3HSSv6YiInYeOVNI1a77l9PXf0M+8/Dr1kpdn/7ESTrzF69VznvE+a8ufLCIOPj9T6Yz89pSGpMhHxymtW3b+T6/bl+ZH5a6gLvTajkv5YYx/8Qdik/p1Zh/Toy1rXN0XX5dHAuZiIihsL+fzmrncHOjllvkT30cH9SeEzdeuJEP9bW9x97Nm+nMfKjdK7Pt2r7vngv3pzPdeu18XL3x5XTmyo38b6SIiN3d/O+Wsd8udV27kb8Wr9/YK3WN46qUm07y9+ZikT+HERHDKn8NVz/XMObXxdWquHDfhrv8JywAAAAAwP83A04AAAAAoFkGnAAAAABAsww4AQAAAIBmGXACAAAAAM0y4AQAAAAAmmXACQAAAAA0y4ATAAAAAGiWAScAAAAA0CwDTgAAAACgWQacAAAAAECzDDgBAAAAgGZN7/QBALecHB/Wgst5OrI4OihVrfX5/4uMaxulru2dnXTmYDordb3vbe9OZ374gzdKXdsn66Xc9743n3n9206Xuu52tTMYcXHjTCl336XK/wO7UtfL6d7Cx3rPt14odf3MJ15IZ/7Wh75Y6vqx7/uzpdyPP/a/pjMbk9q6fXxzlc6cu7e2lr5i+2I683//fm19A+5OfeTXnIiIMYZCaKx1FXJdYV8aEdEXckPx3aBhsUhnjhf5Z2ZExGYsS7kzG5fTmeNF7Xt+Znc/nTl3trbzu3DmXDqzvpX/viIipqdqz+j1nfzedDXW9pg7a2fTmeVmbe24+UL+GPcOt0tdV67nf9cezE9KXZNJ7dyPy6N05uRor9QVq/xn64rPiChci+M4qXXdBm9wAgAAAADNMuAEAAAAAJplwAkAAAAANMuAEwAAAABolgEnAAAAANAsA04AAAAAoFkGnAAAAABAsww4AQAAAIBmGXACAAAAAM0y4AQAAAAAmmXACQAAAAA0y4ATAAAAAGiWAScAAAAA0KzpnT4A4Ja+60q5bjJJZ4blstQVs3xX362Xqm7sH6YzF6YvlLre/c1/N535xb+5V+p66HTtf0vv+u43lnJfic4Vc9//772plLv04Hax8SvPt/87tXPxy7/8XDrzxc/Uvunuyfw6FRFx8dXvTGf6536j1HVwPKQzT3/h+VLX84V1cTqZlbqAu9OYX3IiIqKLwt60up+txGpVMcSYzxRPYlfomo75TETE8nC/lFudXMtnCr8JIiKu7C/Smen66VLXpXP3pDMPXLhc6pqd2SnlVpP874K+et1vn8qHTj9Y6npuuJnO3DzMZyIidg9upDMni/x1GBGxvpyXcqvj/O/Gxbx2PvpYlXIVY2GtGqsPpNvgDU4AAAAAoFkGnAAAAABAsww4AQAAAIBmGXACAAAAAM0y4AQAAAAAmmXACQAAAAA0y4ATAAAAAGiWAScAAAAA0CwDTgAAAACgWQacAAAAAECzDDgBAAAAgGYZcAIAAAAAzZre6QMAbtnaOFXKHR/dSGe2N06Xuibb+WVjHGr/SxlmXTrzo9/zU6Wu9/ztT6UzDywfLnW9/5vHUu7yw7NS7ivRM/lLPiIivu5bX1HKrW/u1Aq/At03yd+XERF/8p3b6cw/+txeqesf/s5hKffD7/1z6cyP/e1fLXXdf+lCOvNMV1s7VvvXCqmTUhdwl+ompdiwWqUzYzeUuqaz/B6zL76uMxaW0762BMdQyI21UxiLYnA+yeeG8ajUNeznc0ez2uf67HG+6/lr+6Wui/ffW8ptn14vpPL3ZUTEcpFfB648V9t0P/vMbjqzv78sdQ1H+e+5W9S6FuNxLbfM702HYV7qGsfa9VGTX+CGobjA3QZvcAIAAAAAzTLgBAAAAACaZcAJAAAAADTLgBMAAAAAaJYBJwAAAADQLANOAAAAAKBZBpwAAAAAQLMMOAEAAACAZhlwAgAAAADNMuAEAAAAAJplwAkAAAAANMuAEwAAAABolgEnAAAAANCs6Z0+AOCW6bQr5bbOnE9n+lpVHB0dpTNrs61S11fv7KQzv3Flu9R19vBMOvPQ5YNS1/f8ubeVcl+phkLmf/m1j5W6fvKv/0el3N99/9enM+/7oZ8qdUU8WMzd3f6zf/9SOvMPP3C91LV77XQpd2M/v1atn3lnreuFD6Qzr3v1G0tdf/Dp/F3Wr66WuoC7VHHfV3kdZhzGUtViuSykal194YR0xZM4Fg5xLH6uk2JuudxPZzYnlR1cxHpM0pmT/VrXfpcfdzy/e6PU9eTTz5Rya2v589F1tWtxscrf0Mfz2rlfDfncZl97/26rcP0uu8p6E7G/2Cvl5svDdGY1rkpdMRa+s662dlTWxUnxe74d3uAEAAAAAJplwAkAAAAANMuAEwAAAABolgEnAAAAANAsA04AAAAAoFkGnAAAAABAsww4AQAAAIBmGXACAAAAAM0y4AQAAAAAmmXACQAAAAA0y4ATAAAAAGiWAScAAAAA0KzpnT4A4JZhHEq5g+OjdKbf2Ch1zQq5eVf7X8qj7/7GdOYf/FrtHM5ilc780LffW+qanC7FvmJ1hcxDD1+ulZ0+VYo99KbXFlLnS11fqXYKmXe++2Kp61/8wkEp93u/+0Q685e/5wdKXT/41z+Yzsw/94lS19sffXs689kvPFfqAu5OXeVhGxER48uUiRiGQm6sdVV0pR1LlE7+WKwah9o+eHGyl85Mp4elrsl0Kx8aaiekmxX2fcWTfzzP/5aIiJgf56/hsTjGGWJZSNXOx9ZO/hi7wnUYEbEad9OZ+eJmqWs+r+0xl4uTfGioXVOVNbgrrtulJ8RLuG57gxMAAAAAaJYBJwAAAADQLANOAAAAAKBZBpwAAAAAQLMMOAEAAACAZhlwAgAAAADNMuAEAAAAAJplwAkAAAAANMuAEwAAAABolgEnAAAAANAsA04AAAAAoFkGnAAAAABAsww4AQAAAIBmTe/0AQC3LFbzUu70dJLObG5ul7qizy8bb944KlVdufqqdObo+qlS1+XNZTrz5q96Y6lr94lSLLa38plJcZUvfM3RrdW6Krl3vf18qeszv/nbpdxO6f+BHrF/VH/zP7ynlHvbB54p5T771GY686Yhv3ZERDx0+Z3pzDNP/8+lrk997LfSmde/8e2lLuDu1PddKdeN+Vw31t6h6ccxH+qqn6uSKoUiCoc4LeztIyLWit9zxaSvfc9j4aOtulWpa9rnn9Gz6azU1Zf3ffkTMlYuqohYrfLncTXUzv3y5CSfOb5R6losDwqZ2u/Tcazt+yq35tgV77EYCpna+tYVcsOYP77b5Q1OAAAAAKBZBpwAAAAAQLMMOAEAAACAZhlwAgAAAADNMuAEAAAAAJplwAkAAAAANMuAEwAAAABolgEnAAAAANAsA04AAAAAoFkGnAAAAABAsww4AQAAAIBmGXACAAAAAM0y4AQAAAAAmjW90wcA3LI2mZRy3eZOOnPl8KDUdXrI/1/km77/vaWun/ul8+nMtK+dw2uLfObbf+i3Sl1D90QpN52O+czsNaWurp+nM6v84b2oP5uOTGa17zliKKVmhX8HTteOa12z/Inc3qo9zjfXlunMYnW21LW23qUz0672PfcxK+X2Fvlj/NA/e7LU9foHHkhnjncvlrquvZBfcz7xsd8pdQF3qeIzeqw+2wu6Lr8GR1QyEZWqsXgy+kl+E7Gzs13qOn2qllubraczY1/beyzG/LN9jOJvpMI+oi/+luiLe8yxcHNW78vlMr/vW63ymYiIxeIknRnXa+/f9dPNdGY2FPfOQ+17Xpzkz8fxUe33+sl8VcpV1K7Fl+7B4g1OAAAAAKBZBpwAAAAAQLMMOAEAAACAZhlwAgAAAADNMuAEAAAAAJplwAkAAAAANMuAEwAAAABolgEnAAAAANAsA04AAAAAoFkGnAAAAABAsww4AQAAAIBmGXACAAAAAM2a3ukDAG7p1jZKuVPrp9KZ48Wk1HXPyQvpzGL5SKnrfa8e0pnv/atvL3VFV4tVbO+8tRYcxnTk2vXa9/zs7iKdWdzMH19ExGNX89f9c8+flLpmMSvlns+fjtg5fLLUNe8LF+NiVeparfK54tccJ/s305nV8UGpa/v8vJRb7m+lM88+V7umzt+Xv4av38ivvxERk+l2OrO7e73UBdydhqH2nBhW+b3YGMUHRWEz1hW7xsKjtvq5ppP8XuzM+bOlrgfvv6+U29k6nc70G/lnS0TEyZh/x6p6RVWu3+VyWepaLQubxYhYrfK5sXg/j13+WuyK78StCr9bxkLmxVxhnSp2HR8dlnI3dq+lM9eu1L7nxclRPlRZFKN6b750P7y9wQkAAAAANMuAEwAAAABolgEnAAAAANAsA04AAAAAoFkGnAAAAABAsww4AQAAAIBmGXACAAAAAM0y4AQAAAAAmmXACQAAAAA0y4ATAAAAAGiWAScAAAAA0CwDTgAAAACgWQacAAAAAECzpnf6AIBbFqtlKXe8ymemlVBEPN/lc09+7IOlrj//Ez+Zzhw88zulrlMX70lnhuF0qev67rVS7omnnkhnJpNTpa5nVzfSmW/85u8qde3s7qUzj385n4mIOH2yXcrNn3gynVnr8ucwIuL45DCd6cZFqevJ6SSdeXSrdg533vC6dObtV54vdV181f2l3PaFS+nMT/9Xx6Wuf/Gb/zSdeeSec6WuZ67lr8WNU2dKXcDdaRhq+75hHPKhcSx1RVeoqjVFVyirdvV9/p2irc2NUteFC+dLubNnL6Yz083aHnM5yY8g+q72Xtawyn9r8+OTUtfh0c1Sbrk4SGcm+e1bRER0k/x1NZvV9n3R5e+xrnqTFXLLZW1NrP6Oqxzkwd71UlP+ivqjLNuFhbuUuT3e4AQAAAAAmmXACQAAAAA0y4ATAAAAAGiWAScAAAAA0CwDTgAAAACgWQacAAAAAECzDDgBAAAAgGYZcAIAAAAAzTLgBAAAAACaZcAJAAAAADTLgBMAAAAAaJYBJwAAAADQrOmdPgDglrX19VLuaO9KOnO4mJe6pt0infm1jz5Z6rr3V/9OOvOd3/K9pa6dtdPpzBd2j0tdX/PgxVLuTa97TTrTTTdLXRHdy5SJeOTimXTmTxQyfyRff8/L28eLXnO5GByKuWU6sfXwRqnp07/0m/mu2Umpa/vUdjozX9TWN+AuVXtER2U9Hcax1NQVYl35cxW6iu8G9WP+HI6L2nrfF19f2tgu7BentVFC5fIYh1Wpqy9cIF3Urt/VIv8bKSJiWOW/642N2m/GyrmfTCalrunaWjpTffuu6/LJ4+Pab+H17fyeKiJibWsrnemK576yMNau+uoa/NIt3N7gBAAAAACaZcAJAAAAADTLgBMAAAAAaJYBJwAAAADQLANOAAAAAKBZBpwAAAAAQLMMOAEAAACAZhlwAgAAAADNMuAEAAAAAJplwAkAAAAANMuAEwAAAABolgEnAAAAANAsA04AAAAAoFnTO30AwC37u/ulXN/lM8eLo1LXua2NdOZCX/tfysP3P1JIjaWup28+k86cnZ4vdR0e1pbe5Xr+i97ob5a6Jv1OITWUul7O/7Utq4c4ztOR6WS9WMYfXfWayuf2n1uUmk5t5u/ntWGz1NVtTdKZ9XG71AXcncYobBarXUPtYdsVDrGrhCJiLGwXK/vtiIhJl3+2TAuZiIiuz6/3ERFD4TyuzWr72YOb+b3pfF773TIs8190V9xDbG3U9n1dv1bI1C7Gvs9/Z9201rVY5fdHs35W6poUDnG2VuuKSe0eOz7Jr4vzk9rv2vHlfI+xsph2tc91O7zBCQAAAAA0y4ATAAAAAGiWAScAAAAA0CwDTgAAAACgWQacAAAAAECzDDgBAAAAgGYZcAIAAAAAzTLgBAAAAACaZcAJAAAAADTLgBMAAAAAaJYBJwAAAADQLANOAAAAAKBZ0zt9AMAtO+uzUq7r87fybFrrWsUqnXmhm5S6tl/fpTOnd+4tdf3Iz/1sOvOLP/ijpa7Pf/73S7mnVpfTmfvOf7HU9YY3fls6szHLXxsREasY0plJIRMR8dizB6Xcqcnn05lX3PeWUtfLahzzmS5/X7aicgUfRW0tXRwdpjOTzZ1S13TMf7LpbLPUBdydhqH2jK48JyZ97TnRFZ4v1UfSOOQ/V+GJ+aLCQY7Vczipvb9U6VsVr6njef75d7C/V+s6PEpnxtoWM6bT9VKu79bSmaH6nlqf/3DTtdrvuL2DeTpz9tS5Ute5M6fSmcp6ExHRRTWXP49dcVzXFa6P4mVfWt9eyp8S3uAEAAAAAJplwAkAAAAANMuAEwAAAABolgEnAAAAANAsA04AAAAAoFkGnAAAAABAsww4AQAAAIBmGXACAAAAAM0y4AQAAAAAmmXACQAAAAA0y4ATAAAAAGiWAScAAAAA0CwDTgAAAACgWd04juOdPggAAAAAgApvcAIAAAAAzTLgBAAAAACaZcAJAAAAADTLgBMAAAAAaJYBJwAAAADQLANOAAAAAKBZBpwAAAAAQLMMOAEAAACAZhlwAgAAAADN+n8B+lgK5mmwOXgAAAAASUVORK5CYII=",
      "text/plain": [
       "<Figure size 1500x1000 with 4 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Data Summary:\n",
      "Total images: 26640\n",
      "Number of classes: 43\n",
      "Images per class (avg): 619.53\n",
      "Image dimensions: 32x32x3\n"
     ]
    }
   ],
   "source": [
    "# Load data\n",
    "print(\"Loading data...\")\n",
    "data_dir = \"gtsrb\"  # Update with your data directory\n",
    "images, labels = load_data(data_dir)\n",
    "\n",
    "# Analyze data\n",
    "print(\"\\nAnalyzing data distribution...\")\n",
    "analyze_data(images, labels)\n",
    "\n",
    "# Prepare data for training\n",
    "labels = tf.keras.utils.to_categorical(labels)\n",
    "x_train, x_test, y_train, y_test = train_test_split(\n",
    "    images, labels, test_size=TEST_SIZE, random_state=42\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Training and evaluating models...\n",
      "\n",
      "Training Custom CNN...\n",
      "Epoch 1/10\n",
      "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m17s\u001b[0m 39ms/step - accuracy: 0.4680 - loss: 2.1966 - val_accuracy: 0.6578 - val_loss: 1.2175\n",
      "Epoch 2/10\n",
      "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m15s\u001b[0m 38ms/step - accuracy: 0.9315 - loss: 0.2471 - val_accuracy: 0.9750 - val_loss: 0.0985\n",
      "Epoch 3/10\n",
      "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m16s\u001b[0m 41ms/step - accuracy: 0.9765 - loss: 0.0869 - val_accuracy: 0.9715 - val_loss: 0.0985\n",
      "Epoch 4/10\n",
      "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m16s\u001b[0m 40ms/step - accuracy: 0.9834 - loss: 0.0554 - val_accuracy: 0.9828 - val_loss: 0.0631\n",
      "Epoch 5/10\n",
      "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m16s\u001b[0m 40ms/step - accuracy: 0.9858 - loss: 0.0491 - val_accuracy: 0.9840 - val_loss: 0.0542\n",
      "Epoch 6/10\n",
      "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m16s\u001b[0m 40ms/step - accuracy: 0.9878 - loss: 0.0366 - val_accuracy: 0.9822 - val_loss: 0.0622\n",
      "Epoch 7/10\n",
      "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m16s\u001b[0m 39ms/step - accuracy: 0.9944 - loss: 0.0229 - val_accuracy: 0.9844 - val_loss: 0.0537\n",
      "Epoch 8/10\n",
      "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m16s\u001b[0m 39ms/step - accuracy: 0.9952 - loss: 0.0182 - val_accuracy: 0.9815 - val_loss: 0.0664\n",
      "Epoch 9/10\n",
      "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m16s\u001b[0m 40ms/step - accuracy: 0.9903 - loss: 0.0334 - val_accuracy: 0.9875 - val_loss: 0.0414\n",
      "Epoch 10/10\n",
      "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m16s\u001b[0m 40ms/step - accuracy: 0.9908 - loss: 0.0286 - val_accuracy: 0.9897 - val_loss: 0.0354\n",
      "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 84ms/step\n",
      "\u001b[1m4/4\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 8ms/step \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "WARNING:absl:You are saving your model as an HDF5 file via `model.save()` or `keras.saving.save_model(model)`. This file format is considered legacy. We recommend using instead the native Keras format, e.g. `model.save('my_model.keras')` or `keras.saving.save_model(model, 'my_model.keras')`. \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Training ResNet50...\n",
      "Epoch 1/10\n",
      "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m51s\u001b[0m 118ms/step - accuracy: 0.1652 - loss: 3.3841 - val_accuracy: 0.0854 - val_loss: 6.0759\n",
      "Epoch 2/10\n",
      "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m47s\u001b[0m 118ms/step - accuracy: 0.3349 - loss: 2.3969 - val_accuracy: 0.0769 - val_loss: 8.4950\n",
      "Epoch 3/10\n",
      "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m48s\u001b[0m 120ms/step - accuracy: 0.4016 - loss: 2.1251 - val_accuracy: 0.1211 - val_loss: 7.2164\n",
      "Epoch 4/10\n",
      "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m49s\u001b[0m 122ms/step - accuracy: 0.4331 - loss: 1.9913 - val_accuracy: 0.1151 - val_loss: 7.5131\n",
      "Epoch 5/10\n",
      "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m49s\u001b[0m 122ms/step - accuracy: 0.4514 - loss: 1.9086 - val_accuracy: 0.1123 - val_loss: 8.3252\n",
      "Epoch 6/10\n",
      "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m48s\u001b[0m 121ms/step - accuracy: 0.4721 - loss: 1.8490 - val_accuracy: 0.2471 - val_loss: 3.8955\n",
      "Epoch 7/10\n",
      "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m49s\u001b[0m 122ms/step - accuracy: 0.4860 - loss: 1.7854 - val_accuracy: 0.1076 - val_loss: 9.2336\n",
      "Epoch 8/10\n",
      "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m49s\u001b[0m 123ms/step - accuracy: 0.4927 - loss: 1.7454 - val_accuracy: 0.1236 - val_loss: 8.7484\n",
      "Epoch 9/10\n",
      "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m48s\u001b[0m 121ms/step - accuracy: 0.5022 - loss: 1.7055 - val_accuracy: 0.1820 - val_loss: 7.1407\n",
      "Epoch 10/10\n",
      "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m49s\u001b[0m 122ms/step - accuracy: 0.5059 - loss: 1.6860 - val_accuracy: 0.1808 - val_loss: 6.5402\n",
      "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 1s/step\n",
      "\u001b[1m4/4\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 78ms/step\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "WARNING:absl:You are saving your model as an HDF5 file via `model.save()` or `keras.saving.save_model(model)`. This file format is considered legacy. We recommend using instead the native Keras format, e.g. `model.save('my_model.keras')` or `keras.saving.save_model(model, 'my_model.keras')`. \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Training MobileNetV2...\n",
      "Epoch 1/10\n",
      "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m20s\u001b[0m 43ms/step - accuracy: 0.1765 - loss: 3.4502 - val_accuracy: 0.3050 - val_loss: 2.5507\n",
      "Epoch 2/10\n",
      "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m13s\u001b[0m 32ms/step - accuracy: 0.3087 - loss: 2.4245 - val_accuracy: 0.3613 - val_loss: 2.1691\n",
      "Epoch 3/10\n",
      "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m13s\u001b[0m 31ms/step - accuracy: 0.3487 - loss: 2.2143 - val_accuracy: 0.3838 - val_loss: 2.0771\n",
      "Epoch 4/10\n",
      "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m12s\u001b[0m 31ms/step - accuracy: 0.3824 - loss: 2.0612 - val_accuracy: 0.3985 - val_loss: 2.0092\n",
      "Epoch 5/10\n",
      "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m12s\u001b[0m 31ms/step - accuracy: 0.4158 - loss: 1.9485 - val_accuracy: 0.4101 - val_loss: 1.9678\n",
      "Epoch 6/10\n",
      "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m12s\u001b[0m 31ms/step - accuracy: 0.4283 - loss: 1.8671 - val_accuracy: 0.4173 - val_loss: 1.9257\n",
      "Epoch 7/10\n",
      "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m12s\u001b[0m 31ms/step - accuracy: 0.4456 - loss: 1.7928 - val_accuracy: 0.4232 - val_loss: 1.9261\n",
      "Epoch 8/10\n",
      "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m14s\u001b[0m 36ms/step - accuracy: 0.4526 - loss: 1.7487 - val_accuracy: 0.4276 - val_loss: 1.9032\n",
      "Epoch 9/10\n",
      "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m13s\u001b[0m 33ms/step - accuracy: 0.4801 - loss: 1.6941 - val_accuracy: 0.4276 - val_loss: 1.8999\n",
      "Epoch 10/10\n",
      "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m14s\u001b[0m 34ms/step - accuracy: 0.4852 - loss: 1.6532 - val_accuracy: 0.4395 - val_loss: 1.8938\n",
      "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 636ms/step\n",
      "\u001b[1m4/4\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 24ms/step\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "WARNING:absl:You are saving your model as an HDF5 file via `model.save()` or `keras.saving.save_model(model)`. This file format is considered legacy. We recommend using instead the native Keras format, e.g. `model.save('my_model.keras')` or `keras.saving.save_model(model, 'my_model.keras')`. \n"
     ]
    }
   ],
   "source": [
    "# Train and evaluate models\n",
    "print(\"\\nTraining and evaluating models...\")\n",
    "results, histories = experiment_with_models(x_train, y_train, x_test, y_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Generating visualization...\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1500x500 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Model Comparison Results:\n",
      "|             |   test_accuracy |   test_loss |   inference_time |   model_size |   memory_usage |\n",
      "|:------------|----------------:|------------:|-----------------:|-------------:|---------------:|\n",
      "| Custom CNN  |          0.9877 |      0.0436 |           0.0016 |       4.4282 |        2524.48 |\n",
      "| ResNet50    |          0.1897 |      6.4846 |           0.0127 |     102.645  |        2636.24 |\n",
      "| MobileNetV2 |          0.4441 |      1.8762 |           0.0078 |      16.749  |        2740.39 |\n",
      "\n",
      "Experiment completed! Check the generated files for detailed results.\n"
     ]
    }
   ],
   "source": [
    "# Visualize results\n",
    "print(\"\\nGenerating visualization...\")\n",
    "plot_training_histories(histories)\n",
    "display_results(results)\n",
    "\n",
    "print(\"\\nExperiment completed! Check the generated files for detailed results.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Results and Analysis\n",
    "The notebook generates several visualizations and analysis files:\n",
    "1. `data_analysis.png`: Shows class distribution and sample images\n",
    "2. `training_history.png`: Compares training progress across models\n",
    "3. `model_comparison_results.csv`: Detailed metrics for each model\n",
    "4. Console output with summary statistics and performance metrics\n",
    "\n",
    "### Future Improvements\n",
    "1. Implement cross-validation for more robust evaluation\n",
    "2. Add confusion matrix visualization for error analysis\n",
    "3. Experiment with additional architectures (VGG16, EfficientNet)\n",
    "4. Implement gradual unfreezing for transfer learning\n",
    "5. Add model interpretability analysis (Grad-CAM, SHAP values)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "env",
   "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.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}