optiResNet101.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "15410362-191b-4e7c-ac29-8d8907683c86",
   "metadata": {
    "editable": true,
    "scrolled": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2024-04-28 21:25:01.591976: E external/local_xla/xla/stream_executor/cuda/cuda_dnn.cc:9261] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n",
      "2024-04-28 21:25:01.592000: E external/local_xla/xla/stream_executor/cuda/cuda_fft.cc:607] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n",
      "2024-04-28 21:25:01.592768: E external/local_xla/xla/stream_executor/cuda/cuda_blas.cc:1515] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n",
      "2024-04-28 21:25:01.598304: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n",
      "To enable the following instructions: AVX2 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n",
      "2024-04-28 21:25:02.120030: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Found 4000 files belonging to 4 classes.\n",
      "Using 3200 files for training.\n",
      "Using 800 files for validation.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2024-04-28 21:25:04.216090: I external/local_xla/xla/stream_executor/cuda/cuda_executor.cc:901] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355\n",
      "2024-04-28 21:25:04.216370: I external/local_xla/xla/stream_executor/cuda/cuda_executor.cc:901] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355\n",
      "2024-04-28 21:25:04.247394: I external/local_xla/xla/stream_executor/cuda/cuda_executor.cc:901] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355\n",
      "2024-04-28 21:25:04.247542: I external/local_xla/xla/stream_executor/cuda/cuda_executor.cc:901] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355\n",
      "2024-04-28 21:25:04.247638: I external/local_xla/xla/stream_executor/cuda/cuda_executor.cc:901] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355\n",
      "2024-04-28 21:25:04.247727: I external/local_xla/xla/stream_executor/cuda/cuda_executor.cc:901] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355\n",
      "2024-04-28 21:25:04.341524: I external/local_xla/xla/stream_executor/cuda/cuda_executor.cc:901] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355\n",
      "2024-04-28 21:25:04.341637: I external/local_xla/xla/stream_executor/cuda/cuda_executor.cc:901] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355\n",
      "2024-04-28 21:25:04.341722: I external/local_xla/xla/stream_executor/cuda/cuda_executor.cc:901] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355\n",
      "2024-04-28 21:25:04.341800: I external/local_xla/xla/stream_executor/cuda/cuda_executor.cc:901] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355\n",
      "2024-04-28 21:25:04.341876: I external/local_xla/xla/stream_executor/cuda/cuda_executor.cc:901] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355\n",
      "2024-04-28 21:25:04.341952: I external/local_xla/xla/stream_executor/cuda/cuda_executor.cc:901] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355\n",
      "2024-04-28 21:25:04.349483: I external/local_xla/xla/stream_executor/cuda/cuda_executor.cc:901] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355\n",
      "2024-04-28 21:25:04.349585: I external/local_xla/xla/stream_executor/cuda/cuda_executor.cc:901] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355\n",
      "2024-04-28 21:25:04.349671: I external/local_xla/xla/stream_executor/cuda/cuda_executor.cc:901] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355\n",
      "2024-04-28 21:25:04.349751: I external/local_xla/xla/stream_executor/cuda/cuda_executor.cc:901] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355\n",
      "2024-04-28 21:25:04.349833: I external/local_xla/xla/stream_executor/cuda/cuda_executor.cc:901] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355\n",
      "2024-04-28 21:25:04.349903: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1929] Created device /job:localhost/replica:0/task:0/device:GPU:0 with 22459 MB memory:  -> device: 0, name: NVIDIA GeForce RTX 3090, pci bus id: 0000:01:00.0, compute capability: 8.6\n",
      "2024-04-28 21:25:04.350118: I external/local_xla/xla/stream_executor/cuda/cuda_executor.cc:901] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355\n",
      "2024-04-28 21:25:04.350181: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1929] Created device /job:localhost/replica:0/task:0/device:GPU:1 with 22461 MB memory:  -> device: 1, name: NVIDIA GeForce RTX 3090, pci bus id: 0000:03:00.0, compute capability: 8.6\n",
      "2024-04-28 21:25:04.602119: I external/local_tsl/tsl/platform/default/subprocess.cc:304] Start cannot spawn child process: No such file or directory\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['herida_y_picadura', 'podrida', 'quemadura_y_otros', 'sanas_1000']\n"
     ]
    }
   ],
   "source": [
    "import tensorflow as tf\n",
    "import numpy as np\n",
    "from tensorflow.keras.utils import image_dataset_from_directory\n",
    "from tensorflow import keras\n",
    "from tensorflow.keras import layers\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "BATCH_SIZE = 32\n",
    "IMG_SIZE = (224, 224)\n",
    "\n",
    "train, validation = tf.keras.utils.image_dataset_from_directory(\n",
    "    directory = \"/home/wartin/Dataset_4_clases\" ,\n",
    "    labels='inferred',\n",
    "    label_mode= \"int\",\n",
    "    class_names=None,\n",
    "    color_mode='rgb',\n",
    "    batch_size= BATCH_SIZE,\n",
    "    image_size= IMG_SIZE,\n",
    "    shuffle=True,\n",
    "    seed=126,\n",
    "    validation_split=0.2,\n",
    "    subset=\"both\",\n",
    "    interpolation='bilinear',\n",
    "    crop_to_aspect_ratio=False,\n",
    ")\n",
    "\n",
    "class_names = train.class_names\n",
    "print(class_names)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "70ae5dd9-0733-45a4-9067-41a94316cdfa",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(32, 224, 224, 3)\n",
      "(32,)\n",
      "Number of validation batches: 20\n",
      "Number of test batches: 5\n",
      "Forma de los datos de entrenamiento: (32, 224, 224, 3)\n",
      "Forma de las etiquetas de entrenamiento: (32,)\n"
     ]
    }
   ],
   "source": [
    "for image_batch, labels_batch in train:\n",
    "  print(image_batch.shape)\n",
    "  print(labels_batch.shape)\n",
    "  break\n",
    "\n",
    "val_batches = tf.data.experimental.cardinality(validation)\n",
    "test_dataset = validation.take(val_batches // 5)\n",
    "validation_dataset = validation.skip(val_batches // 5)\n",
    "\n",
    "print('Number of validation batches: %d' % tf.data.experimental.cardinality(validation_dataset))\n",
    "print('Number of test batches: %d' % tf.data.experimental.cardinality(test_dataset))\n",
    "\n",
    "AUTOTUNE = tf.data.AUTOTUNE\n",
    "\n",
    "train_dataset = train.cache().prefetch(buffer_size=AUTOTUNE)\n",
    "validation_dataset = validation_dataset.cache().prefetch(buffer_size=AUTOTUNE)\n",
    "test_dataset = test_dataset.cache().prefetch(buffer_size=AUTOTUNE)\n",
    "\n",
    "print(\"Forma de los datos de entrenamiento:\", image_batch.shape)\n",
    "print(\"Forma de las etiquetas de entrenamiento:\", labels_batch.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "fd33c827-ad45-4c6a-ae0e-db24eb3e5d31",
   "metadata": {},
   "outputs": [],
   "source": [
    "data_augmentation = keras.Sequential(\n",
    "  [\n",
    "    layers.RandomFlip(\"horizontal\", input_shape=(224, 224, 3)),\n",
    "    layers.RandomRotation(0.1),\n",
    "    layers.RandomZoom(0.1),\n",
    "  ]\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "ad47d296-4afb-4e54-a8d2-3d322abdac86",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of layers in the base model:  345\n"
     ]
    }
   ],
   "source": [
    "preprocess_input = tf.keras.applications.resnet.preprocess_input\n",
    "\n",
    "IMG_SHAPE = IMG_SIZE + (3,)\n",
    "base_model = tf.keras.applications.ResNet101(input_shape=IMG_SHAPE, include_top=False, weights='imagenet')\n",
    "base_model.trainable = False\n",
    "\n",
    "\n",
    "print(\"Number of layers in the base model: \", len(base_model.layers))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "3313eda9-691d-493d-9988-223ff97d9f75",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2024-04-28 21:25:08.175527: W tensorflow/core/kernels/data/cache_dataset_ops.cc:858] The calling iterator did not fully read the dataset being cached. In order to avoid unexpected truncation of the dataset, the partially cached contents of the dataset  will be discarded. This can happen if you have an input pipeline similar to `dataset.cache().take(k).repeat()`. You should use `dataset.take(k).cache().repeat()` instead.\n",
      "2024-04-28 21:25:08.599643: I external/local_xla/xla/stream_executor/cuda/cuda_dnn.cc:454] Loaded cuDNN version 8902\n",
      "2024-04-28 21:25:08.646338: I external/local_tsl/tsl/platform/default/subprocess.cc:304] Start cannot spawn child process: No such file or directory\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(32, 7, 7, 2048)\n"
     ]
    }
   ],
   "source": [
    "image_batch, label_batch = next(iter(train_dataset))\n",
    "feature_batch = base_model(image_batch)\n",
    "print(feature_batch.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "f06f318b-76e6-49e9-8105-93a7a37e1952",
   "metadata": {},
   "outputs": [],
   "source": [
    "base_model.trainable = False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "d9d5e798-468a-45f5-a28e-e64f58e43e46",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: \"model\"\n",
      "_________________________________________________________________\n",
      " Layer (type)                Output Shape              Param #   \n",
      "=================================================================\n",
      " input_2 (InputLayer)        [(None, 224, 224, 3)]     0         \n",
      "                                                                 \n",
      " sequential (Sequential)     (None, 224, 224, 3)       0         \n",
      "                                                                 \n",
      " tf.__operators__.getitem (  (None, 224, 224, 3)       0         \n",
      " SlicingOpLambda)                                                \n",
      "                                                                 \n",
      " tf.nn.bias_add (TFOpLambda  (None, 224, 224, 3)       0         \n",
      " )                                                               \n",
      "                                                                 \n",
      " resnet101 (Functional)      (None, 7, 7, 2048)        42658176  \n",
      "                                                                 \n",
      " global_average_pooling2d (  (None, 2048)              0         \n",
      " GlobalAveragePooling2D)                                         \n",
      "                                                                 \n",
      " dense (Dense)               (None, 512)               1049088   \n",
      "                                                                 \n",
      " dense_1 (Dense)             (None, 512)               262656    \n",
      "                                                                 \n",
      " dense_2 (Dense)             (None, 128)               65664     \n",
      "                                                                 \n",
      " dropout (Dropout)           (None, 128)               0         \n",
      "                                                                 \n",
      " dense_3 (Dense)             (None, 4)                 516       \n",
      "                                                                 \n",
      "=================================================================\n",
      "Total params: 44036100 (167.98 MB)\n",
      "Trainable params: 1377924 (5.26 MB)\n",
      "Non-trainable params: 42658176 (162.73 MB)\n",
      "_________________________________________________________________\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "8"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "inputs = tf.keras.Input(shape=(224, 224, 3))\n",
    "x = data_augmentation(inputs)\n",
    "x = preprocess_input(x)\n",
    "x = base_model(x, training=False)\n",
    "x = tf.keras.layers.GlobalAveragePooling2D()(x)\n",
    "\n",
    "act = \"relu\"\n",
    "x = tf.keras.layers.Dense(units=512, activation=act)(x)\n",
    "x = tf.keras.layers.Dense(units=512, activation=act)(x)\n",
    "x = tf.keras.layers.Dense(units=128, activation=act)(x)\n",
    "\n",
    "x = tf.keras.layers.Dropout(0.5)(x)  # Regularización con dropout\n",
    "outputs = tf.keras.layers.Dense(4, activation='softmax')(x)\n",
    "model = tf.keras.Model(inputs, outputs)\n",
    "model.summary()\n",
    "len(model.trainable_variables)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "3bb414d5-1cf4-4837-9c62-6add7c971535",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "20/20 [==============================] - 2s 43ms/step - loss: 1.4672 - sparse_categorical_accuracy: 0.2484\n",
      "initial loss: 1.47\n",
      "initial accuracy: 0.25\n",
      "Epoch 1/5\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2024-04-28 21:25:16.698215: I external/local_xla/xla/service/service.cc:168] XLA service 0x7f2ba5846fe0 initialized for platform CUDA (this does not guarantee that XLA will be used). Devices:\n",
      "2024-04-28 21:25:16.698235: I external/local_xla/xla/service/service.cc:176]   StreamExecutor device (0): NVIDIA GeForce RTX 3090, Compute Capability 8.6\n",
      "2024-04-28 21:25:16.698238: I external/local_xla/xla/service/service.cc:176]   StreamExecutor device (1): NVIDIA GeForce RTX 3090, Compute Capability 8.6\n",
      "2024-04-28 21:25:16.701713: I tensorflow/compiler/mlir/tensorflow/utils/dump_mlir_util.cc:269] disabling MLIR crash reproducer, set env var `MLIR_CRASH_REPRODUCER_DIRECTORY` to enable.\n",
      "WARNING: All log messages before absl::InitializeLog() is called are written to STDERR\n",
      "I0000 00:00:1714353916.768860 3571807 device_compiler.h:186] Compiled cluster using XLA!  This line is logged at most once for the lifetime of the process.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "100/100 [==============================] - 11s 63ms/step - loss: 0.6957 - sparse_categorical_accuracy: 0.7337 - val_loss: 0.4331 - val_sparse_categorical_accuracy: 0.8375\n",
      "Epoch 2/5\n",
      "100/100 [==============================] - 7s 73ms/step - loss: 0.4237 - sparse_categorical_accuracy: 0.8447 - val_loss: 0.3535 - val_sparse_categorical_accuracy: 0.8875\n",
      "Epoch 3/5\n",
      "100/100 [==============================] - 7s 73ms/step - loss: 0.3209 - sparse_categorical_accuracy: 0.8884 - val_loss: 0.4057 - val_sparse_categorical_accuracy: 0.8578\n",
      "Epoch 4/5\n",
      "100/100 [==============================] - 7s 73ms/step - loss: 0.2677 - sparse_categorical_accuracy: 0.9069 - val_loss: 0.3221 - val_sparse_categorical_accuracy: 0.8875\n",
      "Epoch 5/5\n",
      "100/100 [==============================] - 7s 73ms/step - loss: 0.2471 - sparse_categorical_accuracy: 0.9094 - val_loss: 0.3619 - val_sparse_categorical_accuracy: 0.8781\n"
     ]
    }
   ],
   "source": [
    "callback = keras.callbacks.EarlyStopping(monitor='val_loss', patience=3)\n",
    "\n",
    "base_learning_rate = 0.000270088126636346\n",
    "model.compile(loss=tf.keras.losses.SparseCategoricalCrossentropy(),\n",
    "              optimizer = tf.keras.optimizers.Adam(learning_rate=base_learning_rate),\n",
    "              metrics=[tf.keras.metrics.SparseCategoricalAccuracy()])\n",
    "\n",
    "initial_epochs = 5\n",
    "\n",
    "loss0, accuracy0 = model.evaluate(validation_dataset)\n",
    "\n",
    "print(\"initial loss: {:.2f}\".format(loss0))\n",
    "print(\"initial accuracy: {:.2f}\".format(accuracy0))\n",
    "\n",
    "history = model.fit(train_dataset,\n",
    "                    epochs=initial_epochs,\n",
    "                    validation_data=validation_dataset,\n",
    "                    callbacks=[callback])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "b0c62d7f-7721-48ae-a043-750730a9e79c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 800x800 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "acc = history.history['sparse_categorical_accuracy']\n",
    "val_acc = history.history['val_sparse_categorical_accuracy']\n",
    "\n",
    "loss = history.history['loss']\n",
    "val_loss = history.history['val_loss']\n",
    "\n",
    "plt.figure(figsize=(8, 8))\n",
    "plt.subplot(2, 1, 1)\n",
    "plt.plot(acc, label='Training Accuracy')\n",
    "plt.plot(val_acc, label='Validation Accuracy')\n",
    "plt.legend(loc='lower right')\n",
    "plt.ylabel('Accuracy')\n",
    "plt.ylim([min(plt.ylim()),1])\n",
    "plt.title('Training and Validation Accuracy')\n",
    "\n",
    "plt.subplot(2, 1, 2)\n",
    "plt.plot(loss, label='Training Loss')\n",
    "plt.plot(val_loss, label='Validation Loss')\n",
    "plt.legend(loc='upper right')\n",
    "plt.ylabel('Cross Entropy')\n",
    "plt.ylim([0,2.0])\n",
    "plt.title('Training and Validation Loss')\n",
    "plt.xlabel('epoch')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "fb88198f-601f-40ba-9042-78fde320e1fc",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of layers in the base model:  345\n"
     ]
    }
   ],
   "source": [
    "base_model.trainable = True\n",
    "# Let's take a look to see how many layers are in the base model\n",
    "print(\"Number of layers in the base model: \", len(base_model.layers))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "25939349-8c07-4b9b-be8e-8121a6810dc3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: \"model\"\n",
      "_________________________________________________________________\n",
      " Layer (type)                Output Shape              Param #   \n",
      "=================================================================\n",
      " input_2 (InputLayer)        [(None, 224, 224, 3)]     0         \n",
      "                                                                 \n",
      " sequential (Sequential)     (None, 224, 224, 3)       0         \n",
      "                                                                 \n",
      " tf.__operators__.getitem (  (None, 224, 224, 3)       0         \n",
      " SlicingOpLambda)                                                \n",
      "                                                                 \n",
      " tf.nn.bias_add (TFOpLambda  (None, 224, 224, 3)       0         \n",
      " )                                                               \n",
      "                                                                 \n",
      " resnet101 (Functional)      (None, 7, 7, 2048)        42658176  \n",
      "                                                                 \n",
      " global_average_pooling2d (  (None, 2048)              0         \n",
      " GlobalAveragePooling2D)                                         \n",
      "                                                                 \n",
      " dense (Dense)               (None, 512)               1049088   \n",
      "                                                                 \n",
      " dense_1 (Dense)             (None, 512)               262656    \n",
      "                                                                 \n",
      " dense_2 (Dense)             (None, 128)               65664     \n",
      "                                                                 \n",
      " dropout (Dropout)           (None, 128)               0         \n",
      "                                                                 \n",
      " dense_3 (Dense)             (None, 4)                 516       \n",
      "                                                                 \n",
      "=================================================================\n",
      "Total params: 44036100 (167.98 MB)\n",
      "Trainable params: 23922052 (91.26 MB)\n",
      "Non-trainable params: 20114048 (76.73 MB)\n",
      "_________________________________________________________________\n"
     ]
    }
   ],
   "source": [
    "# Fine-tune from this layer onwards\n",
    "fine_tune_at = 245\n",
    "\n",
    "# Freeze all the layers before the `fine_tune_at` layer\n",
    "for layer in base_model.layers[:fine_tune_at]:\n",
    "  layer.trainable = False\n",
    "\n",
    "model.summary()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "cf5044ab-e8b6-495a-af62-d88aad84c4ac",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 5/15\n",
      "100/100 [==============================] - 24s 103ms/step - loss: 0.2253 - sparse_categorical_accuracy: 0.9247 - val_loss: 0.3331 - val_sparse_categorical_accuracy: 0.9016\n",
      "Epoch 6/15\n",
      "100/100 [==============================] - 9s 94ms/step - loss: 0.1433 - sparse_categorical_accuracy: 0.9519 - val_loss: 0.3007 - val_sparse_categorical_accuracy: 0.9047\n",
      "Epoch 7/15\n",
      "100/100 [==============================] - 9s 94ms/step - loss: 0.1065 - sparse_categorical_accuracy: 0.9644 - val_loss: 0.2786 - val_sparse_categorical_accuracy: 0.9297\n",
      "Epoch 8/15\n",
      "100/100 [==============================] - 10s 95ms/step - loss: 0.0860 - sparse_categorical_accuracy: 0.9706 - val_loss: 0.3269 - val_sparse_categorical_accuracy: 0.9078\n",
      "Epoch 9/15\n",
      "100/100 [==============================] - 10s 96ms/step - loss: 0.0842 - sparse_categorical_accuracy: 0.9719 - val_loss: 0.2708 - val_sparse_categorical_accuracy: 0.9297\n",
      "Epoch 10/15\n",
      "100/100 [==============================] - 10s 96ms/step - loss: 0.0548 - sparse_categorical_accuracy: 0.9819 - val_loss: 0.3135 - val_sparse_categorical_accuracy: 0.9328\n",
      "Epoch 11/15\n",
      "100/100 [==============================] - 10s 96ms/step - loss: 0.0416 - sparse_categorical_accuracy: 0.9866 - val_loss: 0.3323 - val_sparse_categorical_accuracy: 0.9234\n",
      "Epoch 12/15\n",
      "100/100 [==============================] - 10s 97ms/step - loss: 0.0450 - sparse_categorical_accuracy: 0.9850 - val_loss: 0.3097 - val_sparse_categorical_accuracy: 0.9312\n"
     ]
    }
   ],
   "source": [
    "model.compile(loss=tf.keras.losses.SparseCategoricalCrossentropy(),\n",
    "              optimizer = tf.keras.optimizers.Adam(learning_rate=base_learning_rate/10),\n",
    "              metrics=[tf.keras.metrics.SparseCategoricalAccuracy()])\n",
    "\n",
    "fine_tune_epochs = 10\n",
    "total_epochs =  initial_epochs + fine_tune_epochs\n",
    "\n",
    "history_fine = model.fit(train_dataset,\n",
    "                         epochs=total_epochs,\n",
    "                         initial_epoch=history.epoch[-1],\n",
    "                         validation_data=validation_dataset,\n",
    "                         callbacks=[callback])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "475cb94a-4a2b-44d6-9983-ef4291f46971",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "f700e393-05b0-4c78-9f9f-6c98fe8cc900",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 800x800 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "acc += history_fine.history['sparse_categorical_accuracy']\n",
    "val_acc += history_fine.history['val_sparse_categorical_accuracy']\n",
    "\n",
    "loss += history_fine.history['loss']\n",
    "val_loss += history_fine.history['val_loss']\n",
    "\n",
    "plt.figure(figsize=(8, 8))\n",
    "plt.subplot(2, 1, 1)\n",
    "plt.plot(acc, label='Training Accuracy')\n",
    "plt.plot(val_acc, label='Validation Accuracy')\n",
    "plt.ylim([0.25, 1])\n",
    "plt.plot([initial_epochs-1,initial_epochs-1],\n",
    "          plt.ylim(), label='Start Fine Tuning')\n",
    "plt.legend(loc='lower right')\n",
    "plt.title('Training and Validation Accuracy')\n",
    "\n",
    "plt.subplot(2, 1, 2)\n",
    "plt.plot(loss, label='Training Loss')\n",
    "plt.plot(val_loss, label='Validation Loss')\n",
    "plt.ylim([0, 2.0])\n",
    "plt.plot([initial_epochs-1,initial_epochs-1],\n",
    "         plt.ylim(), label='Start Fine Tuning')\n",
    "plt.legend(loc='upper right')\n",
    "plt.title('Training and Validation Loss')\n",
    "plt.xlabel('epoch')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "c9584af7-1bbb-477f-b321-1d9673e33d0c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5/5 [==============================] - 1s 46ms/step\n",
      "0.95\n",
      "0.9457918050941306\n",
      "0.9579545454545454\n",
      "0.9498611815983521\n",
      "dict_keys(['loss', 'sparse_categorical_accuracy', 'val_loss', 'val_sparse_categorical_accuracy'])\n"
     ]
    }
   ],
   "source": [
    "from sklearn.metrics import f1_score, accuracy_score, confusion_matrix, precision_score, recall_score\n",
    "y_t = model.predict(test_dataset)\n",
    "y_t = np.argmax(y_t,-1)\n",
    "# Inicializar una lista para almacenar las etiquetas\n",
    "y_p = []\n",
    "\n",
    "# Iterar sobre el conjunto de datos de prueba para extraer las etiquetas\n",
    "for _, label in test_dataset:\n",
    "    y_p.append(label.numpy())  # Convertir el tensor de etiqueta a un arreglo NumPy y agregarlo a la lista\n",
    "\n",
    "# Convertir la lista de etiquetas a un arreglo NumPy para poder usarlo en las métricas de evaluación\n",
    "y_p = np.concatenate(y_p)\n",
    "\n",
    "# Luego, puedes calcular las métricas de evaluación usando y_t (las predicciones del modelo) y y_p (las etiquetas verdaderas)\n",
    "print(accuracy_score(y_t, y_p))\n",
    "print(precision_score(y_t, y_p, average='macro'))\n",
    "print(recall_score(y_t, y_p, average='macro'))\n",
    "print(f1_score(y_t, y_p, average='macro'))\n",
    "\n",
    "\n",
    "print(history.history.keys())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "8fb5f687-d805-4c59-bb52-82ea8560f136",
   "metadata": {},
   "outputs": [],
   "source": [
    "import itertools\n",
    "def plot_confusion_matrix(cm,classes,normalize=False,title=\"Confusion_matrix\",cmap=plt.cm.Blues):\n",
    "  plt.imshow(cm,interpolation=\"nearest\",cmap=cmap)\n",
    "  plt.title(title)\n",
    "  plt.colorbar()\n",
    "  tick_marks=np.arange(len(classes))\n",
    "  plt.xticks(tick_marks,classes,rotation=45)\n",
    "  plt.yticks(tick_marks,classes)\n",
    "\n",
    "  if normalize:\n",
    "    cm=cm.astype(\"float\") / cm.sum(axis=1)[:,np.newaxis]\n",
    "    cm = cm.round(decimals=4)\n",
    "    print(\"Normalized confusion matrix\")\n",
    "  else:\n",
    "    print(\"Confusion matrix,without normalization\")                                       # se define la matriz de confusion.\n",
    "  print(cm)\n",
    "\n",
    "  thresh = cm.max() /2.\n",
    "  for i, j in itertools.product(range(cm.shape[0]),range(cm.shape[1])):\n",
    "    plt.text(j,i,cm[i,j],\n",
    "                    horizontalalignment=\"center\",\n",
    "                    color=\"white\" if cm[i,j] > thresh else \"black\")\n",
    "  plt.tight_layout()\n",
    "  plt.ylabel(\"True label\")\n",
    "  plt.xlabel(\"Predicted label\")\n",
    "  plt.savefig(\"matrix.png\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "7017c708-0006-45d9-bbca-c9106b6c2066",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Confusion matrix,without normalization\n",
      "[[27  0  0  0]\n",
      " [ 1 41  2  0]\n",
      " [ 0  0 39  0]\n",
      " [ 2  1  2 45]]\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "cm_plot_labels = ['herida_y_picadura', 'podrida', 'quemadura_y_otros', 'sanas_1000']\n",
    "cm = confusion_matrix(y_true=y_t,y_pred=y_p)                                             # se muestra dicha matriz de confusion\n",
    "plot_confusion_matrix(cm=cm, classes=cm_plot_labels,title=\"Confusion Matrix\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "fb8fcecb-2bf3-4f6a-bc7a-10b50c216d87",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Normalized confusion matrix\n",
      "[[1.     0.     0.     0.    ]\n",
      " [0.0227 0.9318 0.0455 0.    ]\n",
      " [0.     0.     1.     0.    ]\n",
      " [0.04   0.02   0.04   0.9   ]]\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjQAAAHpCAYAAACVw6ZvAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8fJSN1AAAACXBIWXMAAA9hAAAPYQGoP6dpAACnsklEQVR4nOzddVwUWxsH8N8u3Z2KiIiIIKCoCBaIndh5BcXGDrw2dit24QUDu/XagV4lRBS7UFQUARsB6fP+wcvICii7ArsLz/d+5nPds2dmzhyG3YdTw2OMMRBCCCGESDG+uAtACCGEEPKnKKAhhBBCiNSjgIYQQgghUo8CGkIIIYRIPQpoCCGEECL1KKAhhBBCiNSjgIYQQgghUo8CGkIIIYRIPQpoCCGEECL1KKAhpBx69uwZWrVqBQ0NDfB4PBw9erREj//y5UvweDwEBgaW6HGlmYuLC1xcXMRdDKkQGBgIHo+Hly9fcmniqL/g4GDweDwEBweX6XlJ6aCAhpBS8vz5cwwbNgzVqlWDoqIi1NXV0ahRI6xevRrfv38v1XN7eHjg3r17WLBgAXbu3Il69eqV6vnKkqenJ3g8HtTV1Qutx2fPnoHH44HH42H58uVCHz8uLg6+vr6IiooqgdKKLu8aVqxYUeC9vIDg5s2bYigZIZJJVtwFIKQ8+vfff9GjRw8oKChgwIABsLGxQUZGBq5du4bJkyfjwYMH2LJlS6mc+/v37wgNDcX06dMxatSoUjmHqakpvn//Djk5uVI5/u/IysoiNTUVJ06cQM+ePQXeCwoKgqKiItLS0kQ6dlxcHObMmYOqVavC3t6+2PudO3dOpPP9zrJlyzBixAgoKyuXyvElRWnVH6k4qIWGkBIWExOD3r17w9TUFA8fPsTq1asxZMgQeHt7Y8+ePXj48CGsra1L7fzv378HAGhqapbaOXg8HhQVFSEjI1Nq5/gVBQUFuLm5Yc+ePQXe2717N9q3b19mZUlNTQUAyMvLQ15evkSPbW9vj4SEBGzatKlEj/uzlJSUUj1+cZRG/ZGKhQIaQkrY0qVLkZycjG3btsHIyKjA+9WrV8fYsWO511lZWZg3bx7Mzc2hoKCAqlWrYtq0aUhPTxfYr2rVqujQoQOuXbuGBg0aQFFREdWqVcOOHTu4PL6+vjA1NQUATJ48GTweD1WrVgWQ21WT9+/8fH19wePxBNLOnz+Pxo0bQ1NTE6qqqrC0tMS0adO494saQ3Pp0iU0adIEKioq0NTUROfOnfHo0aNCzxcdHQ1PT09oampCQ0MDAwcO5IKD4ujbty9Onz6NL1++cGkRERF49uwZ+vbtWyD/p0+fMGnSJNSuXRuqqqpQV1dH27ZtcefOHS5PcHAw6tevDwAYOHAg1+2Td50uLi6wsbFBZGQkmjZtCmVlZa5efh4D4uHhAUVFxQLX37p1a2hpaSEuLu6319ioUSM0b94cS5cuLVY3pTD1//DhQ/Tt2xdaWlpo3LgxgB/3WHBwMOrVqwclJSXUrl2bG2Ny+PBh1K5dG4qKinBwcMDt27cFjn337l14enpy3ayGhoYYNGgQPn78+Nuy/1x/VatW5er/5y3/mJe3b99i0KBBMDAwgIKCAqytrfHPP/8UOP6bN2/g7u4OFRUV6OvrY/z48QV+x4h0oy4nQkrYiRMnUK1aNTg7Oxcr/+DBg7F9+3Z0794dEydORHh4OBYtWoRHjx7hyJEjAnmjo6PRvXt3eHl5wcPDA//88w88PT3h4OAAa2trdO3aFZqamhg/fjz69OmDdu3aQVVVVajyP3jwAB06dICtrS3mzp0LBQUFREdH4/r167/c78KFC2jbti2qVasGX19ffP/+HWvXrkWjRo1w69atAsFUz549YWZmhkWLFuHWrVvw9/eHvr4+lixZUqxydu3aFcOHD8fhw4cxaNAgALmtMzVr1kTdunUL5H/x4gWOHj2KHj16wMzMDAkJCdi8eTOaNWuGhw8fwtjYGFZWVpg7dy5mzZqFoUOHokmTJgAg8LP8+PEj2rZti969e6N///4wMDAotHyrV6/GpUuX4OHhgdDQUMjIyGDz5s04d+4cdu7cCWNj42Jdp6+vL5o2bYqNGzdiwoQJReYTtv579OgBCwsLLFy4EIwxLj06Ohp9+/bFsGHD0L9/fyxfvhwdO3bEpk2bMG3aNIwcORIAsGjRIvTs2RNPnjwBn5/7t/H58+fx4sULDBw4EIaGhlzX6oMHDxAWFlYgcP4VPz8/JCcnC6StWrUKUVFR0NHRAQAkJCSgYcOG4PF4GDVqFPT09HD69Gl4eXkhKSkJ48aNA5DbDevm5obXr19jzJgxMDY2xs6dO3Hp0qVil4dIAUYIKTFfv35lAFjnzp2LlT8qKooBYIMHDxZInzRpEgPALl26xKWZmpoyAOzq1atcWmJiIlNQUGATJ07k0mJiYhgAtmzZMoFjenh4MFNT0wJlmD17Nsv/UbBq1SoGgL1//77IcuedIyAggEuzt7dn+vr67OPHj1zanTt3GJ/PZwMGDChwvkGDBgkcs0uXLkxHR6fIc+a/DhUVFcYYY927d2dubm6MMcays7OZoaEhmzNnTqF1kJaWxrKzswtch4KCAps7dy6XFhERUeDa8jRr1owBYJs2bSr0vWbNmgmknT17lgFg8+fPZy9evGCqqqrM3d39t9fIGGMAmLe3N2OMMVdXV2ZoaMhSU1MZY4wFBAQwACwiIoLLL2z99+nTp8A58+6xkJCQAtegpKTEXr16xaVv3ryZAWCXL1/m0vLKl9+ePXsK3Ld55Y+JieHSCqu//Pbv388ACPysvLy8mJGREfvw4YNA3t69ezMNDQ2uPH5+fgwA279/P5cnJSWFVa9evcA1EOlFXU6ElKCkpCQAgJqaWrHynzp1CgAK/OU9ceJEALmDi/OrVasW12oAAHp6erC0tMSLFy9ELvPP8sbeHDt2DDk5OcXa5927d4iKioKnpye0tbW5dFtbW7Rs2ZK7zvyGDx8u8LpJkyb4+PEjV4fF0bdvXwQHByM+Ph6XLl1CfHx8od1NQO64m7yWhOzsbHz8+JHrTrt161axz6mgoICBAwcWK2+rVq0wbNgwzJ07F127doWioiI2b95c7HPl8fX1RXx8fJFjaUqi/vPUqlULTk5O3GtHR0cAQPPmzVGlSpUC6fnvPSUlJe7faWlp+PDhAxo2bAgAQtXxzx4+fIhBgwahc+fOmDFjBgCAMYZDhw6hY8eOYIzhw4cP3Na6dWt8/fqVO+epU6dgZGSE7t27c8dUVlbG0KFDRS4TkTwU0BBSgtTV1QEA3759K1b+V69egc/no3r16gLphoaG0NTUxKtXrwTS83+h5NHS0sLnz59FLHFBvXr1QqNGjTB48GAYGBigd+/e2L9//y+Dm7xyWlpaFnjPysoKHz58KDDw9Odr0dLSAgChrqVdu3ZQU1PDvn37EBQUhPr16xeoyzw5OTlYtWoVLCwsoKCgAF1dXejp6eHu3bv4+vVrsc9ZqVIloQavLl++HNra2oiKisKaNWugr69f7H3zNG3aFK6urkWOpRGl/s3MzAo9188/Fw0NDQCAiYlJoen5f16fPn3C2LFjYWBgACUlJejp6XHnEaaO80tKSkLXrl1RqVIl7Nixg+u2ev/+Pb58+YItW7ZAT09PYMsLOBMTEwHk1k/16tULdHkVVl9EetEYGkJKkLq6OoyNjXH//n2h9ivu2IKiZhWxfGMghD1Hdna2wGslJSVcvXoVly9fxr///oszZ85g3759aN68Oc6dO1diM5v+5FryKCgooGvXrti+fTtevHgBX1/fIvMuXLgQM2fOxKBBgzBv3jxoa2uDz+dj3LhxxW6JAgRbIYrj9u3b3BfrvXv30KdPH6H2zzN79my4uLhg8+bNJTKDrajrKOrnUpyfV8+ePRESEoLJkyfD3t4eqqqqyMnJQZs2bYSq4/w8PT0RFxeHGzducH8wAOCO179/f3h4eBS6r62trUjnJNKJAhpCSliHDh2wZcsWhIaGCjTdF8bU1BQ5OTl49uwZrKysuPSEhAR8+fKFm7FUErS0tARmBOX5uRUIAPh8Ptzc3ODm5oaVK1di4cKFmD59Oi5fvowWLVoUeh0A8OTJkwLvPX78GLq6ulBRUfnziyhE37598c8//4DP56N3795F5jt48CBcXV2xbds2gfQvX75AV1eXey3MwNXfSUlJwcCBA1GrVi04Oztj6dKl6NKlCzeTShjNmjWDi4sLlixZglmzZgm8J876z/P582dcvHgRc+bMESjfs2fPRD7m4sWLcfToURw+fBg1a9YUeE9PTw9qamrIzs4u9J7Mz9TUFPfv3wdjTODnW1h9EelFXU6ElDAfHx+oqKhg8ODBSEhIKPD+8+fPsXr1agC5XSZA7oyO/FauXAkAJbqeirm5Ob5+/Yq7d+9yae/evSswk+rTp08F9s1bYK6oaa5GRkawt7fH9u3bBYKm+/fv49y5c9x1lgZXV1fMmzcP69atg6GhYZH5ZGRkCrT+HDhwAG/fvhVIy/viLyz4E9aUKVPw+vVrbN++HStXrkTVqlXh4eEh8nThvLE0Py/KKM76z5PXgvNzHf98bxfXhQsXMGPGDEyfPh3u7u6Fnq9bt244dOhQoS2ieesxAbm/Z3FxcTh48CCXlpqaWmqLWxLxoBYaQkqYubk5du/ejV69esHKykpgpeCQkBAcOHAAnp6eAAA7Ozt4eHhgy5Yt+PLlC5o1a4YbN25g+/btcHd3h6ura4mVq3fv3pgyZQq6dOmCMWPGIDU1FRs3bkSNGjUEBmzOnTsXV69eRfv27WFqaorExERs2LABlStX5tYrKcyyZcvQtm1bODk5wcvLi5s2rKGh8cuuoD/F5/O5gaK/0qFDB8ydOxcDBw6Es7Mz7t27h6CgIFSrVk0gn7m5OTQ1NbFp0yaoqalBRUUFjo6ORY45KcqlS5ewYcMGzJ49m5tGHhAQABcXF8ycORNLly4V6nhAbitNs2bNcOXKlQLviav+86irq6Np06ZYunQpMjMzUalSJZw7dw4xMTEiHa9Pnz7Q09ODhYUFdu3aJfBey5YtYWBggMWLF+Py5ctwdHTEkCFDUKtWLXz69Am3bt3ChQsXuOB8yJAhWLduHQYMGIDIyEgYGRlh586d5X715QpHfBOsCCnfnj59yoYMGcKqVq3K5OXlmZqaGmvUqBFbu3YtS0tL4/JlZmayOXPmMDMzMyYnJ8dMTEzY1KlTBfIwljultn379gXO8/N016KmbTPG2Llz55iNjQ2Tl5dnlpaWbNeuXQWmbV+8eJF17tyZGRsbM3l5eWZsbMz69OnDnj59WuAcP09tvnDhAmvUqBFTUlJi6urqrGPHjuzhw4cCefLO9/O08MKm8hYm/7TtohQ1bXvixInMyMiIKSkpsUaNGrHQ0NBCpwsfO3aM1apVi8nKygpcZ7NmzZi1tXWh58x/nKSkJGZqasrq1q3LMjMzBfKNHz+e8fl8Fhoa+strQL5p2/ldvnyZASgwbZuxP6t/xoq+xworS2F1/ObNG9alSxemqanJNDQ0WI8ePVhcXBwDwGbPns3lK8607bxrLGzLP806ISGBeXt7MxMTEyYnJ8cMDQ2Zm5sb27Jli0B5X716xTp16sSUlZWZrq4uGzt2LDtz5gxN2y5HeIwJMQKPEEIIIUQC0RgaQgghhEg9CmgIIYQQIvUooCGEEEKI1KOAhhBCCCFlZvHixeDxeNzDQ4Hcp63//FT1oh7PURSatk0IIYSQMhEREYHNmzcXuorzkCFDMHfuXO61sNPqqYWGEEIIIaUuOTkZ/fr1w9atW7lnt+WnrKwMQ0NDbsv/qIvioBYaItVycnIQFxcHNTW1El2ynhBCxIkxhm/fvsHY2Jh7SnxJS0tLQ0ZGhsj7s58eJQHkPl9NQUGh0Pze3t5o3749WrRogfnz5xd4PygoCLt27YKhoSE6duyImTNnCtVKQwENkWpxcXEFngJMCCHlRWxsLCpXrlzix01LS4OSmg6QlSryMVRVVZGcnCyQNnv27EJXpt67dy9u3bqFiIiIQo/Vt29fmJqawtjYGHfv3sWUKVPw5MkTHD58uNjloYCGSDU1NTUAgOvC45BVLN2H75U3uzzqibsIhJAifEtKQnUzE+4zrqRlZGQAWalQsB4IyMgLf4DsDCQ/CEBsbKxA11BhrTOxsbEYO3Yszp8/D0VFxUIPN3ToUO7ftWvXhpGREdzc3PD8+XOYm5sXq0gU0BCpltfcKauoAjklVTGXRroI2z9NCCl7pd6VLisPnkzhXUS/wv5fLHV19d9+lkRGRiIxMZF7phkAZGdn4+rVq1i3bh3S09O5h5vmcXR0BABER0dTQEMIIYSQ3+DxczdR9ismNzc33Lt3TyBt4MCBqFmzJqZMmVIgmAGAqKgoALlPki8uCmgIIYQQUmrU1NRgY2MjkKaiogIdHR3Y2Njg+fPn2L17N9q1awcdHR3cvXsX48ePR9OmTQud3l0UCmgIIYSQiorHy91E2a+EyMvL48KFC/Dz80NKSgpMTEzQrVs3zJgxQ6jjUEBDCCGEVFRl0OVUmODgYO7fJiYmuHLlyh8dD6CAhhBCCKm4JKCFpqRQQEMIIYRUWCK20EjggwYooCGEEEIqqnLUQiN5IRYhhBBCiJCohYYQQgipqMQ0KLg0UEBDCCGEVFTlqMuJAhpCCCGkoqIWGkIIIYRIvXLUQiN5IRYhhBBCiJCohYYQQgipqKjLiRBCCCFSj8cTMaCRvC4nCmgIIYSQiorPy91E2U/CUEBDCCGEVFTU5UQIIYQQqUeznAghhBBCJAe10BBCCCEVFXU5EUIIIUTqlaMuJwpoCCGEkIqKWmgIIYQQIvWohYYQQgghUq8ctdBIXokIIYQQQoRELTSEEEJIRVWOupyohYYQEVgbqWFWGwvs+Mse/w5vgIZVNX+7T21jNazuZo2jQ+phax9btLDULf2CSqBNG9bDsnpVaKoqoomzIyJu3Phl/kMHD8DOpiY0VRVRz742zpw+VUYllSxUb6Khevsd/o9uJ2E2CQwfJK9EhEgBRVk+Yj6mYuN/r4qV30BNHr5ta+BuXBJGH7iPY3fjMaaZGepW1ijlkkqWA/v3YcrkCZg+YzZCb9yCra0dOrVvjcTExELzh4aEwKN/H3gM9EJYxG107OyOnt3c8eD+/TIuuXhRvYmG6q0Y8lpoRNlEtHjxYvB4PIwbN45LS0tLg7e3N3R0dKCqqopu3bohISFBuEthjDGRS0WImCUlJUFDQwMtV16EnJKqWMrw7/AGmHfmKcJefikyz0DHyqhnqgnv/T8+GH1amENVXgazTj0tg1IWdGhwgzI/ZxNnRzjUqw+/NesAADk5OahuZoIR3qMx2efvAvn79+2F1JQUHD52kktr2qgh7OzssXbDpjIrt7hRvYlGmustKSkJBjoa+Pr1K9TV1Uvl+BoaGlBotRQ8OSWh92eZ35F+zkfo8kVERKBnz55QV1eHq6sr/Pz8AAAjRozAv//+i8DAQGhoaGDUqFHg8/m4fv16sY9NLTSElIGaBqqIepMkkHYr9itqGognCBOHjIwM3L4VieZuLbg0Pp+P5s1b4EZYaKH7hIeFwrV5C4G0lq1aI7yI/OUR1ZtoqN4kT3JyMvr164etW7dCS0uLS//69Su2bduGlStXonnz5nBwcEBAQABCQkIQFhZW7ONTQENIGdBSlseX75kCaV++Z0JFQRbyMpI3uK40fPjwAdnZ2dDXNxBI1zcwQHx8fKH7JMTHQ9/gp/z6BkhIKDx/eUT1Jhqqt2ISZfxMvqneSUlJAlt6enqRp/L29kb79u3RooVg0BgZGYnMzEyB9Jo1a6JKlSoIDS1+MCkVAY2Li4tAX1tZHrdq1apck5ikCw4OBo/Hw5cvX0rtHC9fvgSPx0NUVFSpnYMQQkgZ+cMxNCYmJtDQ0OC2RYsWFXqavXv34tatW4W+Hx8fD3l5eWhqagqkG/wi+CxMhZ62ffjwYcjJyYm7GCXG2dkZ7969g4ZGxRpoKg0+p2ZAU0nwXtNUkkNKehYysivGMDZdXV3IyMggMVFwoF9iQgIMDQ0L3cfA0BCJPw0MTExMgIFB4fnLI6o30VC9FdMfLqwXGxsrMIZGQUGhQNbY2FiMHTsW58+fh6KioshF/R2paKEpaRkZGQAAbW1tqKmpibk0JUdeXh6GhobgSeD6APnl1X9F8jghGfaVBAfO1amsgccJyWIqUdmTl5dHnboOuHzpIpeWk5ODy5cvokFDp0L3cWzohODLFwXSLl44D8ci8pdHVG+ioXorpj9soVFXVxfYCgtoIiMjkZiYiLp160JWVhaysrK4cuUK1qxZA1lZWRgYGCAjI6NA70LCL4LPwkhNQJOTkwMfHx9oa2vD0NAQvr6+3HtfvnzB4MGDoaenB3V1dTRv3hx37tzh3vf19YW9vT38/f1hZmbGRYg/dzklJiaiY8eOUFJSgpmZGYKCggqUY+XKlahduzZUVFRgYmKCkSNHIjn5919KKSkpUFdXx8GDBwXSjx49ChUVFXz79u2X++d19ezduxfOzs5QVFSEjY0Nrly5wuUprMvp+vXrcHFxgbKyMrS0tNC6dWt8/vwZAHDmzBk0btwYmpqa0NHRQYcOHfD8+XOB8964cQN16tSBoqIi6tWrh9u3bwu8HxgYWKCZ8OjRowJBVVH1X5zzSypFWT6q6Sijmo4yAMBQXQHVdJShpyoPAPBoUBkTXKtx+U89TIShugIGNjRBZU1FtLfWRxNzbRy9K9y0RGk3ZtwEBGzbil07tuPxo0cY4z0CqSkpGOAxEADg5TkAM6dP5fJ7jxqLc2fPwG/VCjx5/Bjz5/riVuRNDB85SkxXIB5Ub6KheiuGPxxDUxxubm64d+8eoqKiuK1evXro168f9285OTlcvPgjmHzy5Alev34NJ6fiB5NS0+W0fft2TJgwAeHh4QgNDYWnpycaNWqEli1bokePHlBSUsLp06ehoaGBzZs3w83NDU+fPoW2tjYAIDo6GocOHcLhw4chIyNT6Dk8PT0RFxeHy5cvQ05ODmPGjCmwXgGfz8eaNWtgZmaGFy9eYOTIkfDx8cGGDRt+WX4VFRX07t0bAQEB6N69O5ee97q4LUWTJ0+Gn58fatWqhZUrV6Jjx46IiYmBjo5OgbxRUVFwc3PDoEGDsHr1asjKyuLy5cvIzs4GkBtkTZgwAba2tkhOTsasWbPQpUsXREVFgc/nIzk5GR06dEDLli2xa9cuxMTEYOzYscUq588Kq//fnb8w6enpAoPOkpKSCs1X2iz0VbC4kxX3eoizKQDgwpP3WHU5BtoqctBTk+feT/iWAd/TTzHEuQo61zbAh+QMrLkSg1tvvpZ52cWpR89e+PD+PebOmYWE+HjY2tnj2MkzMPj/QMzY2NcCP3snZ2cE7tyNObNnYPaMaahuYYH9h47C2sZGXJcgFlRvoqF6kwxqamqw+akOVVRUoKOjw6V7eXlhwoQJ0NbWhrq6OkaPHg0nJyc0bNiw2OeRinVoXFxckJ2djf/++49La9CgAZo3b44OHTqgffv2SExMFGjqql69Onx8fDB06FD4+vpi4cKFePv2LfT09ASOa29vDz8/Pzx9+hSWlpa4ceMG6tevDwB4/PgxrKyssGrVqiIHDx88eBDDhw/Hhw8ffnsdN27cgLOzM2JjY2FkZITExERUqlQJFy5cQLNmzX6578uXL2FmZobFixdjypQpAICsrCyYmZlh9OjR8PHxQXBwMFxdXfH582doamqib9++eP36Na5du/bbsgG5swL09PRw79492NjYYMuWLZg2bRrevHnDtaps2rQJI0aMwO3bt2Fvb4/AwECMGzdOoFXo6NGj6NKlC/JuraLq/3fnL4yvry/mzJlTIF2c69BIK3GsQ0MIKZ4yW4emw1rR16E5OVrk8uX//gVyF9abOHEi9uzZg/T0dLRu3RobNmwon11Otra2Aq/zAoI7d+4gOTmZW10wb4uJiRHovjA1Nf3ll+mjR48gKysLBwcHLq1mzZoFulMuXLgANzc3VKpUCWpqavjrr7/w8eNHpKam/vYaGjRoAGtra2zfvh0AsGvXLpiamqJp06bFqQIAEGh+k5WVRb169fDo0aNC8+a10BTl2bNn6NOnD6pVqwZ1dXVUrVoVAPD69WsAuXVia2srMIhLmOa//Aqr/9+dvzBTp07F169fuS02Nlak8hBCCAF4PJ7I258IDg4WmEGsqKiI9evX49OnT0hJScHhw4eFCmYAKepy+nk2Eo/HQ05ODpKTk2FkZITg4OAC++QPRlRUVP64DC9fvkSHDh0wYsQILFiwANra2rh27Rq8vLyQkZEBZWXl3x5j8ODBWL9+Pf7++28EBARg4MCBpTaIV0np11F3x44dYWpqiq1bt8LY2Bg5OTmwsbERatAun8/Hz418mZmZBfIVVv+inF9BQaHQQWeEEEKEJ3JwIoGTT6SmhaYodevWRXx8PGRlZVG9enWBTVe3+A//q1mzJrKyshAZGcmlPXnyRKArJTIyEjk5OVixYgUaNmyIGjVqIC4uTqjy9u/fH69evcKaNWvw8OFDeHh4CLV//lUT88prZWVVaF5bW1uBQVb5ffz4EU+ePMGMGTPg5uYGKysrbrBwHisrK9y9exdpaWmFnh8A9PT08O3bN6SkpHBpxVmjpjjnJ4QQUsp4f7BJGKkPaFq0aAEnJye4u7vj3LlzePnyJUJCQjB9+nTcvHmz2MextLREmzZtMGzYMISHhyMyMhKDBw8WaOWoXr06MjMzsXbtWrx48QI7d+7Epk3CPd9DS0sLXbt2xeTJk9GqVStUrlxZqP3Xr1+PI0eO4PHjx/D29sbnz58xaNCgQvNOnToVERERGDlyJO7evYvHjx9j48aN+PDhA7S0tKCjo4MtW7YgOjoaly5dwoQJEwT279u3L3g8HoYMGYKHDx/i1KlTWL58uUAeR0dHKCsrY9q0aXj+/Dl2796NwMDAYtXD785PCCGkdImry6k0SH1Aw+PxcOrUKTRt2hQDBw5EjRo10Lt3b7x69YobyV5cAQEBMDY2RrNmzdC1a1cMHToU+vr63Pt2dnZYuXIllixZAhsbGwQFBRW5KuKv5HVRFRWI/MrixYuxePFi2NnZ4dq1azh+/HiRLVE1atTAuXPncOfOHTRo0ABOTk44duwYZGVlwefzsXfvXkRGRsLGxgbjx4/HsmXLBPZXVVXFiRMncO/ePdSpUwfTp0/HkiVLBPJoa2tj165dOHXqFGrXro09e/YITKkvSnHOTwghhBSXVMxyKm927tyJ8ePHIy4uDvLy8r/fAT9mOeXNLiK5JOFp29KKZjkRIrnKapaTSpeNIs9ySjkyotTKJwqpGRRcHqSmpuLdu3dYvHgxhg0bVuxghhBCCCkNNCiYFKpt27YCU8fzbwsXLsTSpUtRs2ZNGBoaYurUqQL7Lly4sMh927ZtK6YrIoQQUp6VpzE01EJTgvz9/fH9+/dC39PW1oa2tnaR40uGDx+Onj17FvqekpISKlWqVGB6NCGEEPJHRJ2xJHnxDAU0JalSpUoi75sX8BBCCCFEeBTQEEIIIRVUeRpDQwENIYQQUkHxeBAxoCn5svwpCmgIIYSQCooHUQf4Sl5EQwENIYQQUkFRlxMhhBBCpF85muVE69AQQgghROpRCw0hhBBSUYnY5cSoy4kQQgghkkLUMTS0UjAhhBBCJAYFNIQQQgiRfuVoUDAFNIQQQkgFVZ5aaGiWEyGEEEKkHrXQEEIIIRVUeWqhoYCGEEIIqaAooCGEEEKI1CtPAQ2NoSGEEEIqKt4fbMW0ceNG2NraQl1dHerq6nBycsLp06e5911cXLjAKm8bPny40JdCLTSEEEIIKTWVK1fG4sWLYWFhAcYYtm/fjs6dO+P27duwtrYGAAwZMgRz587l9lFWVhb6PBTQEEIIIRVUWXQ5dezYUeD1ggULsHHjRoSFhXEBjbKyMgwNDYUuR37U5UQIIYRUUD939QizAUBSUpLAlp6e/svzZWdnY+/evUhJSYGTkxOXHhQUBF1dXdjY2GDq1KlITU0V+lqohYYQQgipoP60hcbExEQgffbs2fD19S2Q/969e3ByckJaWhpUVVVx5MgR1KpVCwDQt29fmJqawtjYGHfv3sWUKVPw5MkTHD58WKgyUUBDCCGEVFR/+OiD2NhYqKurc8kKCgqFZre0tERUVBS+fv2KgwcPwsPDA1euXEGtWrUwdOhQLl/t2rVhZGQENzc3PH/+HObm5sUuEgU0hBBCSAX1py00eTOXfkdeXh7Vq1cHADg4OCAiIgKrV6/G5s2bC+R1dHQEAERHRwsV0NAYGkIIIYSUqZycnCLH20RFRQEAjIyMhDomtdAQQgghFVRZzHKaOnUq2rZtiypVquDbt2/YvXs3goODcfbsWTx//hy7d+9Gu3btoKOjg7t372L8+PFo2rQpbG1thSoTBTSEEEJIBcWDiAGNEANvEhMTMWDAALx79w4aGhqwtbXF2bNn0bJlS8TGxuLChQvw8/NDSkoKTExM0K1bN8yYMUPoMlFAQwghhFRQZdFCs23btiLfMzExwZUrV4Q+f2EooCGEEEIqqj+c5SRJKKAh5UJg/7rFGmlPftBqv0LcRZA6cUfGibsIUklJXkbcRSBFoIdTEkIIIYRIEGqhIYQQQiqo8tRCQwENIYQQUkHxeLmbKPtJGgpoCCGEkAoqN6ARpYWmFArzhyigIYQQQioqEVtoJHGWEw0KJoQQQojUoxYaQgghpIKiQcGEEEIIkXo0KJgQQgghUo/P54HPFz46YSLsU9oooCGEEEIqKGqhIYQQQojUK09jaGiWEyGEEEKkHrXQEEIIIRUUdTkRQgghROqVpy4nCmgIIYSQCooCGkIIIYRIPepyIoQQQojU40HEFhoJfJgTzXIihBBCiNSjFhpCCCGkgqIuJ0IIIYRIPRoUTAghhBCpV55aaGgMDSGEEFJB5bXQiLIV18aNG2Frawt1dXWoq6vDyckJp0+f5t5PS0uDt7c3dHR0oKqqim7duiEhIUHoa6GAhhBCCKmg8lpoRNmKq3Llyli8eDEiIyNx8+ZNNG/eHJ07d8aDBw8AAOPHj8eJEydw4MABXLlyBXFxcejatavQ10JdToQQQggpNR07dhR4vWDBAmzcuBFhYWGoXLkytm3bht27d6N58+YAgICAAFhZWSEsLAwNGzYs9nmohYYQQgipoP60yykpKUlgS09P/+X5srOzsXfvXqSkpMDJyQmRkZHIzMxEixYtuDw1a9ZElSpVEBoaKtS1UEBDCCGEVFSidjf9v8vJxMQEGhoa3LZo0aJCT3Pv3j2oqqpCQUEBw4cPx5EjR1CrVi3Ex8dDXl4empqaAvkNDAwQHx8v1KVQlxMhhBBSQf3ptO3Y2Fioq6tz6QoKCoXmt7S0RFRUFL5+/YqDBw/Cw8MDV65cEa3QRaCAhhBCCKmg/nTadt7Mpd+Rl5dH9erVAQAODg6IiIjA6tWr0atXL2RkZODLly8CrTQJCQkwNDQUqkzU5UQIIYSQMpWTk4P09HQ4ODhATk4OFy9e5N578uQJXr9+DScnJ6GOSQENIf+3ZdMGWNeoBl0NZbg2ccLNiBu/zH/k0AHUta0FXQ1lODrY4eyZU9x7mZmZmDn9bzg62MFAWw0WZpUxdJAH3sXFcXlevXyJkcMGw8bSHHqaKrC1ssCCub7IyMjg8iycNwdqijIFNgNttRK/flEM62iPx9sH4/OJsbi6ui/qWRb9F5WsDB9T+zXEgwAvfD4xFuEb/0LLelUF8gzpYIcbGwcg4fAoJBweheBVfdDqpzyD2tbG2aU9kXB4FL6fnQgNlYJN3NUraWG/b2fE7h+JhMOjcHFFbzS1MymJSy4R/ps3wM7KHEbaKmjRzAmRN399rx09fBCOdaxhpK2CRvXtcT7fvfazCWNGQltFFhvXrRZIt7Myh7aKrMDmt3wJ9/7rVy8LvK+tIouIG2F/drFitmnDelhWrwpNVUU0cXZExI1f1/WhgwdgZ1MTmqqKqGdfG2dOF13X5UFZrEMzdepUXL16FS9fvsS9e/cwdepUBAcHo1+/ftDQ0ICXlxcmTJiAy5cvIzIyEgMHDoSTk5NQM5wACmgIAQAcOrAPU30m4u/pM3Et7CZsatuiS8e2eJ+YWGj+sNAQDBzQDwM8B+FaeCQ6dOyMPj264uGD+wCA1NRU3Ll9C1OmTsd/YTcRtPcgnj17il7d3bljPH36GDk5OVi9biNu3LqHRctWYJv/ZvjOms7lGTN+IqJfvhXYalrVgnvX7qVaH8XRvZkllgxthgVBoXDy3om7L97j+IJu0NNQKjS/r2cjDG5niwkbLqHOkED4/3sX+2Z1gp25Ppfn7ftvmPnPf3AetQuNRgch+M5rHPB1h5WpDpdHWVEO52++xLK9RX8xHZ7rDlk+H22n7IfzqF24++I9Ds/tAgMt5ZKrABEdPrgfM/6eBJ+pM3H5egRsatuhe+d2Rd5r4WEhGOLZD/0GDERwyE2069gJ/Xt34+61/E4eP4qbN8JhZGRc6LGmzvTFo+dvuG3IiFEF8hw5eVYgj30dhz+7YDE6sH8fpkyegOkzZiP0xi3Y2tqhU/vWSCyirkNDQuDRvw88BnohLOI2OnZ2R89u7nhwv2BdlxdlsQ5NYmIiBgwYAEtLS7i5uSEiIgJnz55Fy5YtAQCrVq1Chw4d0K1bNzRt2hSGhoY4fPiw8NfCGGNC70WIhEhKSoKGhgbeJn4uVj9uUVybOKGuQz2s8FsLILc5tGZ1UwwbMQoTJ08pkN+jf2+kpKTg4JETP47R1Bm2tnZYvW5joeeIvBkBl8YN8fBpDEyqVCk0j9/K5di2ZRPuPY4u9P17d+/AuUFdnLkQjEaNmwh7mQL0Oq36o/2vru6LyKfxGL/+EoDcD7joXUOx8VgUlu8vGGy82D0MS/aEY/OJKC5tz8yO+J6ehUFLTxfIn+ftwZGYtvUqtp8V/FJpYlsZ55b1gmHXdfia8mOqqI66Et4cGIkWE/fi+v23AABVJTm8PzoG7f4+gMu3X4t8zXFHxom8b54WzZxQ16E+lq5cAyD3XqtdoyqGDPfGuEkF77VBA/ogNSUFew8d59Jaujijtq09Vq7Z8KNscW/RspkzDh47hd7dOmG49xiMGDWWe9/OyrxAWn6vX72Efa3quBJyE7Xt7P/4OvNTkpcp0eMVVxNnRzjUqw+/NesA5NZ1dTMTjPAejck+fxfI379vL6SmpODwsZNcWtNGDWFnZ4+1GzaVWbmB3M82Ax0NfP369Y8+2351fA0NDTScfwayiipC75+VloKwGW1KrXyioBYaUuFlZGTg9q1IuDR349L4fD5cXN1wI7zwdRBuhIXBtXkLgbQWLVrhRnjRzfNJX7+Cx+NB46fpiT/n0dLWLvL97QHbUN2ixh8HM39KTpaPOhYGuHTrR3DAGHDp9ms0qGVU6D7ycjJIy8gSSPuengVn60qF5ufzeejRzBIqCnIIfxRXaJ7CfEz6jiexn9C3RS0oK8hChs/D4PZ2SPicgtvPhF9OvSRlZGTgzu1baOYqeK81c3UrsmsnIjxMID8ANG/RChH57rWcnByM8PLA6HETYVXLusjzr16xFOYm+mjmVA9rVi1HVlZWgTx9e3ZBDVMjtG3RFKf/PVHIUaRD3u91c7cfv6d8Ph/Nm7fAjbDCf6/Dw0IL/F63bNUa4UXkLw/KosuprFBAQ34pMDCwwPoAhXFxccG4ceN+madq1arw8/MrkXKVpI8fPiA7Oxv6+gYC6foGBkgs4nkiCQnx0NfXL5A/IaHwdRPS0tIwa8ZU9OjZu8i/Zp4/j8bmjesw0GtIkcfYv3c3BngO+t0llTpddSXIyvCR+CVFID3xcyoMtQr/a+9C5EuM6eYAc2NN8HhA87qm6NzIAobagvmtq+ri/dHR+HpyHNaMaYFec4/j8etPQpWv/d8HYGeuj/dHx+DLyXEY09UBnacfxpfkXy/6Vdo+fsy91/R+unf09PWLvHcSE+IL3pv6BkjMl3/1iqWQkZXFsJGjizz30BGj4L89CMdPXYCn1xCsWr4Ys6f/aBFSUVHFvEXLELBrL/YePo6GTo3Qv1dXqQ1qPvzi97qo9U0S4uOhb1Cwrov62ZQHZdHlVFZo2jYpEYcPH4acnJy4iyGRMjMzMaBfLzDGsGrthkLzxL19i64d28G9a/ciA5oTx47g27dv6Nd/QGkWt9RM2ngZG8a1wh3/gWAAXsR9wY5zD+DRWrBF4embT3AcuRMayvLo0qQGtk5qg1aT9wkV1Kwa5Yb3X1LRYuJefM/Igmeb2jg0xx2NxwQh/lPK7w8gRaJuR2LzhrW4HBLxy7+avceM5/5tXdsWcnLymDBmBGbNXQgFBQXo6OoK5KnrUB/x795hrd9ytG3fsbBDEiJRqIWG/JG8GTna2tpQU5OMmTfC0tHVhYyMDBITBVtjEhMSCvy1lsfAwLDAwMLEhAQYGAjO8skLZmJfv8axf88W2jrzLi4O7Vq7wbGhE9Zu2FxkObcH/IM27doXWaay9CHpO7Kyc6CvKdi6oq+ljPjPhQcMH75+R885x6DTeQ0s/9oKu8EBSEnLQEz8V4F8mVk5eBH3BbejEzEr4BruxbyHt3vdYpfNxb4K2jWohgGL/kXowzhERSdi3LqL+J6Rhf4tiu6OKQs6Orn32s8DgN8nJha4d/LoGxgWvDcTE6D///yh16/h/ftE2FqaQU9dAXrqCoh9/Qozp06GnZV5kWVxqN8AWVlZeP3q5S/zxDx/Xsyrkyy6v/i9Lmp9EwNDwwKtsomJBX+vyxPqciISycXFBaNGjcKoUaOgoaEBXV1dzJw5E3njvj9//owBAwZAS0sLysrKaNu2LZ49eyZwjMDAQFSpUgXKysro0qULPn78KPC+r68v7O3t4e/vDzMzMygqKnLnzt/llJiYiI4dO0JJSQlmZmYICgoqUN6VK1eidu3aUFFRgYmJCUaOHInk5OQSrpXfk5eXR526Drhy+RKXlpOTgyvBl9DAsfB1EBo0bIjgyxcF0i5duoAGjj+mGeYFM8+jo3H81Dno6Oj8fBjEvX2Ltq2ao06duti49R/w+YX/Sr6MicHVK5clorsJyA06bj9LgGudH4ObeTzA1b4Kbjx898t90zOzEfcxGbIyfLg3tsDJ0F9/YfJ5PCjIFX9QqbJCbsNzTo7gfIecHAaemD/x5OXlYVenLq4GF7zX6jcofIpqfceGAvkBIPjSBdT//73Wq09//Bd+G1dCI7nNyMgYo8dNxMFjRU85vn/3Dvh8PvT09IvMc+/uHRgYFj4mStLl/V5fvvTj9zQnJweXL19Eg4aF/147NnQq8Ht98cJ5OBaRvzygLicisbZv3w4vLy/cuHEDN2/exNChQ1GlShUMGTIEnp6eePbsGY4fPw51dXVMmTIF7dq1w8OHDyEnJ4fw8HB4eXlh0aJFcHd3x5kzZzB79uwC54iOjsahQ4dw+PBhyMgU/kXj6emJuLg4XL58GXJychgzZkyBFg0+n481a9bAzMwML168wMiRI+Hj44MNGwrvlgGA9PR0gYefJSUliVhTgkaNGYdhgweiTl0HONRvgA1rVyM1JQV/DfAEAAwd5AEj40qYM38hAGCE9xi0bemKNX4r0bptOxzavw+3I29i7frcmRCZmZno36cH7ty+jQNHjiMnOxsJ/++319LWhry8POLevkW7Vs1hUsUUCxYvw4f377nyGPz0F+TO7QEwNDJCq9ZtS+R6S8Kaw5HYOqkNIp/G4+aTeIzqUhfKinLYcS53NpL/5DaI+5CMWQHXAAD1LQ1hrKuKO8/fo5KuKqb3dwKfx8PK/RHcMecObIyzETGIff8Nakry6OVaE01tTdBx+iEuj4GWMgy0VGBurAUAsDHTxbfUDMS+/4bP39IQ/ugdPienw39yGywMCsudRdW2NqoaauDMjZgyrKHCjRw9Ht5DB8K+jgPq1quPTevXIDU1BX3/8gQAjBjsCSNjY8yam3uvDRs5Gh1bN8e61SvRqk07HD64D1G3IrFqbe69pq2jA+2fgmVZOTnoGxjCooYlAOBGeCgiI26gSVMXqKqpISI8DNOnTETP3v2gqZVbj3t27YC8vDw3w+nk8SMI2hGA1eu3lEGtlI4x4yZgyCAPODjUQ736DbBujR9SU1IwwGMgAMDLcwCMK1XCvAW5zx/yHjUWrdyawW/VCrRt2x4H9u/FrcibWL9Reuvgd/700QeShAKacsbExASrVq0Cj8eDpaUl7t27h1WrVsHFxQXHjx/H9evX4ezsDAAICgqCiYkJjh49ih49emD16tVo06YNfHx8AAA1atRASEgIzpw5I3COjIwM7NixA3p6eoWW4enTpzh9+jRu3LiB+vXrAwC2bdsGKysrgXz5W3SqVq2K+fPnY/jw4b8MaBYtWoQ5c+YIXS+/061HL3z48AEL5voiISEetnb2OHz8FNe9ExsbC16+1pOGTs74Z/suzPWdhTmzpsO8ugX2HDiMWtY2AHJbXk6dzB1M6dxAsLvk1NmLaNLMBZcunsfz59F4/jwaluaC07i/pWVz/87JyUHQzu3o19+jyABSHA5eeQJdDSXMGtAIBlrKuPviPTpPP4TEL6kAABM9dYFWEgV5Wcz2aAwzIw0kf8/E2YgX8Fp6WmDKtZ6mMrZNbgtDbRV8Tc3A/Zj36Dj9EC7desXlGdzeDjP+cuZeX1jRGwAwZPkZ7Dr/AB+TvqPz9EPw9WyM00t6QE6Gj0evPqKH71Hce/EjaBSXrt174uOH91g03xeJCfGwsbXDgaP/cvfamzevBVrqHBs6Y0vALiycOwvzfWegmrkFdu09xN1rxaEgr4DDB/dhycK5yEhPR5WqZhgxaixG5hszAwDLlizAm9evICMrC4salti2Yw86d+lWMhcuBj169sKH9+8xd84sJMTn/l4fO3kGBtzvtWBdOzk7I3DnbsyZPQOzZ0xDdQsL7D90FNY2xa9racODiI8+KPGS/Dlah6YccXFxQbVq1fDPP/9waceOHUP37t1x8OBBdO/eHWlpaQJfinXq1EGXLl0wa9YsgX/nWb16NWbPno0vX74AyO1yCgoKKtBV5eLiAnt7e/j5+XHnTE9PF/iw0NLSwuzZs7lA5sKFC1i0aBEeP36MpKQkZGVlIS0tDSkpKVBWLnwBtMJaaExMTP54HZqK6E/XoamISmIdmopIXOvQSLOyWofGZekFyCqJsA7N9xQE+7SgdWiIdFNREf7m/9nLly/RoUMH2Nra4tChQ4iMjMT69esBQGDp/58pKChwD0Mr7kPRCCGElH8U0JQz4eHhAq/DwsJgYWGBWrVqISsrS+D9jx8/4smTJ6hVqxYAwMrKqtD9hVWzZk1kZWUhMjKSS3vy5AnXygMAkZGRyMnJwYoVK9CwYUPUqFEDcXHFXzyNEELInytPg4IpoClnXr9+jQkTJuDJkyfYs2cP1q5di7Fjx8LCwgKdO3fGkCFDcO3aNdy5cwf9+/dHpUqV0LlzZwDAmDFjcObMGSxfvhzPnj3DunXrCoyfKQ5LS0u0adMGw4YNQ3h4OCIjIzF48GAoKf14xk/16tWRmZmJtWvX4sWLF9i5cyc2bSrbpcUJIaSio2nbRGINGDAA379/R4MGDeDt7Y2xY8di6NChAICAgAA4ODigQ4cOcHJyAmMMp06d4hbEa9iwIbZu3YrVq1fDzs4O586dw4wZM0QqR0BAAIyNjdGsWTN07doVQ4cOFVhZ187ODitXrsSSJUtgY2ODoKAgLFq06M8rgBBCSLHxeaJvkoYGBZcj+QfmVhQl9XDKiogGBQuPBgWLhgYFC6+sBgW3WHkRckqqQu+f+T0ZFya4SdSg4GJN2z5+/PjvM/1fp06dRC4MIYQQQogoihXQuLu7F+tgPB4P2dnZv89ICCGEELETdYCvBA6hKV5Ak5OTU9rlICUgODhY3EUghBAiRXj//0+U/STNH60UnJaWxj3LhxBCCCHSRdQBvpI4KFjoWU7Z2dmYN28eKlWqBFVVVbx48QIAMHPmTGzbtq3EC0gIIYSQ0lGhp20vWLAAgYGBWLp0KeTl5bl0Gxsb+Pv7l2jhCCGEEFJ6KvTCejt27MCWLVvQr18/gWcC2dnZ4fHjxyVaOEIIIYSQ4hB6DM3bt29RvXr1Auk5OTnIzMwskUIRQgghpPTxeTzwRWhuEWWf0iZ0C02tWrXw33//FUg/ePAg6tSpUyKFIoQQQkjpK09dTkK30MyaNQseHh54+/YtcnJycPjwYTx58gQ7duzAyZMnS6OMhBBCCCkFog7wLReDgjt37owTJ07gwoULUFFRwaxZs/Do0SOcOHECLVu2LI0yEkIIIaQUlKcWGpEeTtmkSROcP38eiYmJSE1NxbVr19CqVauSLhshhBBCSlHeGBpRtuJatGgR6tevDzU1Nejr68Pd3R1PnjwRyOPi4lJgWvjw4cOFuhaRF9a7efMmHj16BCB3XI2Dg4OohyKEEEJIOXXlyhV4e3ujfv36yMrKwrRp09CqVSs8fPgQKioqXL4hQ4Zg7ty53GtlZWWhziN0QPPmzRv06dMH169fh6amJgDgy5cvcHZ2xt69e1G5cmVhD0kIIYQQMeD9fxNlv+I6c+aMwOvAwEDo6+sjMjISTZs25dKVlZVhaGgoQmlyCd3lNHjwYGRmZuLRo0f49OkTPn36hEePHiEnJweDBw8WuSCEEEIIKVt/ulJwUlKSwJaenv7bc379+hUAoK2tLZAeFBQEXV1d2NjYYOrUqUhNTRXqWoRuobly5QpCQkJgaWnJpVlaWmLt2rVo0qSJsIcjhBBCiJj86bOcTExMBNJnz54NX1/fIvfLycnBuHHj0KhRI9jY2HDpffv2hampKYyNjXH37l1MmTIFT548weHDh4tdJqEDGhMTk0IX0MvOzoaxsbGwhyOEEEKImPzptO3Y2Fioq6tz6QoKCr/cz9vbG/fv38e1a9cE0ocOHcr9u3bt2jAyMoKbmxueP38Oc3PzYpVJ6C6nZcuWYfTo0bh58yaXdvPmTYwdOxbLly8X9nCEEEIIkVLq6uoC268CmlGjRuHkyZO4fPnyb8fbOjo6AgCio6OLXZZitdBoaWkJRHApKSlwdHSErGzu7llZWZCVlcWgQYPg7u5e7JMTQgghRLxKe00ZxhhGjx6NI0eOIDg4GGZmZr/dJyoqCgBgZGRU7PMUK6Dx8/Mr9gEJIYQQIh3KYqVgb29v7N69G8eOHYOamhri4+MBABoaGlBSUsLz58+xe/dutGvXDjo6Orh79y7Gjx+Ppk2bwtbWttjnKVZA4+HhUewDEkIIIUQ6/Omg4OLYuHEjgNzF8/ILCAiAp6cn5OXlceHCBfj5+SElJQUmJibo1q0bZsyYIVSZRF5YDwDS0tKQkZEhkJZ/cBAhhBBCJFdZtNAwxn75vomJCa5cuSJ0GX4m9KDglJQUjBo1Cvr6+lBRUYGWlpbARgghhBDpwPuDTdIIHdD4+Pjg0qVL2LhxIxQUFODv7485c+bA2NgYO3bsKI0yEkIIIYT8ktBdTidOnMCOHTvg4uKCgQMHokmTJqhevTpMTU0RFBSEfv36lUY5CSGEEFLChH3QZP79JI3QLTSfPn1CtWrVAOSOl/n06RMAoHHjxrh69WrJlo4QQgghpYbHE32TNEIHNNWqVUNMTAwAoGbNmti/fz+A3JabvIdVEkIIIUTy/emznCSJ0AHNwIEDcefOHQDA33//jfXr10NRURHjx4/H5MmTS7yAhBBCCCkd5amFRugxNOPHj+f+3aJFCzx+/BiRkZGoXr26UAvgEEIIIUS8ytMYmj9ahwYATE1NYWpqWhJlIYQQQggRSbECmjVr1hT7gGPGjBG5MIQQQggpO6J2H0lgA03xAppVq1YV62A8Ho8CGiIWsjJ8yMoIPSSsQvv870RxF0HqaPf+R9xFkEqf9g4SdxFIEcpipeCyUqyAJm9WEyGEEELKDz5EmB0k4j6l7Y/H0BBCCCFEOpWnFhpJDLIIIYQQQoRCLTSEEEJIBcXjAfyKNCiYEEIIIeUPX8SARpR9ShsFNIQQQkgFVeHH0Pz333/o378/nJyc8PbtWwDAzp07ce3atRItHCGEEEJKT14LjSibpBE6oDl06BBat24NJSUl3L59G+np6QCAr1+/YuHChSVeQEIIIYSUjvL0LCehA5r58+dj06ZN2Lp1K+Tk5Lj0Ro0a4datWyVaOEIIIYSQ4hB6DM2TJ0/QtGnTAukaGhr48uVLSZSJEEIIIWWgPD2cUugWGkNDQ0RHRxdIv3btGqpVq1YihSKEEEJI6eP/wSZphC7TkCFDMHbsWISHh4PH4yEuLg5BQUGYNGkSRowYURplJIQQQkgpKE9jaITucvr777+Rk5MDNzc3pKamomnTplBQUMCkSZMwevTo0igjIYQQQkoBHyJ2OUHyIhqhW2h4PB6mT5+OT58+4f79+wgLC8P79+8xb9680igfIYQQQkpJWbTQLFq0CPXr14eamhr09fXh7u6OJ0+eCORJS0uDt7c3dHR0oKqqim7duiEhIUGoaxG5G0xeXh61atVCgwYNoKqqKuphCCGEEFKOXblyBd7e3ggLC8P58+eRmZmJVq1aISUlhcszfvx4nDhxAgcOHMCVK1cQFxeHrl27CnUeobucXF1df7lC4KVLl4Q9JCGEEELEoCwefXDmzBmB14GBgdDX10dkZCSaNm2Kr1+/Ytu2bdi9ezeaN28OAAgICICVlRXCwsLQsGHDYp1H6IDG3t5e4HVmZiaioqJw//59eHh4CHs4QgghhIhJ7sMpRXn0Qe7/k5KSBNIVFBSgoKDwy32/fv0KANDW1gYAREZGIjMzEy1atODy1KxZE1WqVEFoaGjpBTSrVq0qNN3X1xfJycnCHo4QQgghYiLqjKW8fUxMTATSZ8+eDV9f3yL3y8nJwbhx49CoUSPY2NgAAOLj4yEvLw9NTU2BvAYGBoiPjy92mUrs4ZT9+/dHgwYNsHz58pI6JCGEEEJK0Z92OcXGxkJdXZ1L/13rjLe3N+7fv18qz34ssYAmNDQUioqKJXU4QgghhEg4dXV1gYDmV0aNGoWTJ0/i6tWrqFy5MpduaGiIjIwMfPnyRaCVJiEhAYaGhsUui9ABzc+jjhljePfuHW7evImZM2cKezhCCCGEiAnv//+Jsl9xMcYwevRoHDlyBMHBwTAzMxN438HBAXJycrh48SK6desGIPcxS69fv4aTk1OxzyN0QKOhoSHwms/nw9LSEnPnzkWrVq2EPRwhhBBCxKQsZjl5e3tj9+7dOHbsGNTU1LhxMRoaGlBSUoKGhga8vLwwYcIEaGtrQ11dHaNHj4aTk1OxBwQDQgY02dnZGDhwIGrXrg0tLS1hdiWEEEKIhCmLgGbjxo0AABcXF4H0gIAAeHp6AsidcMTn89GtWzekp6ejdevW2LBhg1BlEiqgkZGRQatWrfDo0SMKaAghhBApx+Pxfrm23K/2Ky7G2G/zKCoqYv369Vi/fr3QZckj9ErBNjY2ePHihcgnJIQQQohkyGuhEWWTNEIHNPPnz8ekSZNw8uRJvHv3DklJSQIbIYQQQkhZK3aX09y5czFx4kS0a9cOANCpUyeBJifGGHg8HrKzs0u+lIQQQggpcX+6sJ4kKXZAM2fOHAwfPhyXL18uzfIQQgghpIzweTyRHn0gyj6lrdgBTd6gnmbNmpVaYQghhBBSdspillNZEWoMjSgjoQkpzzZtWA/L6lWhqaqIJs6OiLhx45f5Dx08ADubmtBUVUQ9+9o4c/pUGZVUclCdCa+RlQEO/t0Cz7f0RurBQehYv8pv92libYiQpZ3weY8H7q3tjv4u1cugpJKH7rff4P3odhJmE2EtvlInVEBTo0YNaGtr/3IjpKI4sH8fpkyegOkzZiP0xi3Y2tqhU/vWSExMLDR/aEgIPPr3gcdAL4RF3EbHzu7o2c0dD+7fL+OSiw/VmWhUFOVw7+UnjPcPLVZ+U31VHJ7aElfux6PhpKNY/+8DbBjRGC3sKpVySSUL3W+/xwdP5E3S8FhxJogjd0VgPz+/AisF/8zDw6NECkZIcSQlJUFDQwMJH78W+3kiJaWJsyMc6tWH35p1AHKfIlvdzAQjvEdjss/fBfL379sLqSkpOHzsJJfWtFFD2NnZY+2GTWVWbnGS9jrT7v1PmZ/zZ6kHB6HXkgs4EfG6yDzz+tdDm7omqD/hCJe2fbwLNJXl0XnBuTIopaBPeweV+TkB6b7fkpKSYKCjga9fS+ezLe+zc9nZu1BSURN6/+8p3zC5tW2plU8UQi2s17t3b+jr65dWWQiRGhkZGbh9KxKTp0zl0vh8Ppo3b4EbYYX/FR0eFooxYycIpLVs1Ronjh0tzaJKDKqzsuNYQx+X78YJpF2Ieoulno5iKlHZo/uteMrTLKdidznR+BlCfvjw4QOys7Ohr28gkK5vYMA9p+RnCfHx0Df4Kb++ARISCs9f3lCdlR0DTSUkfv0ukJb45Ts0VOShKC8jplKVLbrfiqdCLqxXzJ6pCs3X1xf29vbiLgYhhBBSLHnTtkXZJE2xA5qcnBzqbiIAch8wNm7cOHEXQ6x0dXUhIyODxMQEgfTEhAQYGhoWuo+BoSESE37Kn5gAA4PC85c3VGdlJ+HLd+hrKAmk6Wsq4WtKBtIyKsbip3S/FY8oM5xE7aYqbUI/+oCUroyMDHEXoUQwxpCVlSXuYpQaeXl51KnrgMuXLnJpOTk5uHz5Iho0dCp0H8eGTgi+fFEg7eKF83AsIn95Q3VWdsKfJsKltpFAWnNbY9x4WvjsnvKI7rfi4UPEFhoJnOUk1oAmJSUFAwYMgKqqKoyMjLBixQqBv/55PB6OHj0qsI+mpiYCAwO517GxsejZsyc0NTWhra2Nzp074+XLl9z7np6ecHd3x8KFC2FgYABNTU3MnTsXWVlZmDx5MrS1tVG5cmUEBAQInGfKlCmoUaMGlJWVUa1aNcycOROZmZkCeRYvXgwDAwOoqanBy8sLaWlpAu8X1pLh7u7OPS4dAKpWrYp58+ZhwIABUFdXx9ChQ4t9/sK8fPkSfD4fN2/eFEj38/ODqakpcnJyfnuMK1euoEGDBlBQUICRkRH+/vtvLjjx9PTElStXsHr1au4prS9fvkRwcDB4PB5Onz4NBwcHKCgo4Nq1a0hPT8eYMWOgr68PRUVFNG7cGBEREdy5Pn/+jH79+kFPTw9KSkqwsLAo8LOQVGPGTUDAtq3YtWM7Hj96hDHeI5CakoIBHgMBAF6eAzBz+o8Bid6jxuLc2TPwW7UCTx4/xvy5vrgVeRPDR44S0xWUPaoz0agoysK2qjZsq+YujWFqoAbbqtqorKsCAJjT1wFbRzfl8vufewwzAzXM718PNYw1MLR1TXRzNsPakw/EUn5xofutYhFqllNJmzx5Mq5cuYJjx45BX18f06ZNw61bt4o9DiUzMxOtW7eGk5MT/vvvP8jKymL+/Plo06YN7t69C3l5eQDApUuXULlyZVy9ehXXr1+Hl5cXQkJC0LRpU4SHh2Pfvn0YNmwYWrZsicqVKwMA1NTUEBgYCGNjY9y7dw9DhgyBmpoafHx8AAD79++Hr68v1q9fj8aNG2Pnzp1Ys2YNqlWrJnQ9LF++HLNmzcLs2bO5tN+dvyhVq1ZFixYtEBAQgHr16nHpAQEB8PT0BJ//6xj27du3aNeuHTw9PbFjxw48fvwYQ4YMgaKiInx9fbF69Wo8ffoUNjY2mDt3LgBAT0+PCyL//vtvLF++HNWqVYOWlhZ8fHxw6NAhbN++Haampli6dClat26N6OhoaGtrY+bMmXj48CFOnz4NXV1dREdH4/v370WWLz09Henp6dxrcT4QtUfPXvjw/j3mzpmFhPh42NrZ49jJMzD4/6DC2NjXAvXt5OyMwJ27MWf2DMyeMQ3VLSyw/9BRWNvYiOsSyhzVmWjqmuvi7Jx23Ou82Uo7Lz/DsPX/wVBLGSb/D24A4FViMrouOo+lno7wbm+Ntx9TMHLjNVy487bMyy5OdL/9Xnma5VTsdWhKWnJyMnR0dLBr1y706NEDAPDp0ydUrlwZQ4cOhZ+fH3g8Ho4cOQJ3d3duP01NTfj5+cHT0xO7du3C/Pnz8ejRI24WVkZGBjQ1NXH06FG0atUKnp6eCA4OxosXL7gbt2bNmtDX18fVq1cBANnZ2dDQ0IC/vz969+5daHmXL1+OvXv3ci0fzs7OqFOnDtavX8/ladiwIdLS0hAVFQUgt4XG3t4efn5+XB53d3eBVqaqVauiTp06OHLkx3oRxTn/r+zfvx/Dhw/Hu3fvoKCggFu3bqFevXp48eIFqlat+st9p0+fjkOHDgnU6YYNGzBlyhR8/foVfD6/0OsKDg6Gq6srjh49is6dOwPIbYHT0tJCYGAg+vbtCyA3CK1atSrGjRuHyZMno1OnTtDV1cU//xRvfQ9fX1/MmTOnQLo41qEhFY8krEMjjcS1Do00K6t1aDZcug8lVRHWoUn+hpHNbSRqHRqxdTk9f/4cGRkZcHT8sS6CtrY2LC0ti32MO3fuIDo6GmpqalBVVYWqqiq0tbWRlpaG58+fc/msra0FonADAwPUrl2bey0jIwMdHR2B1SP37duHRo0awdDQEKqqqpgxYwZev/6xkNWjR48Eyg4ATk6i9bPmb0kp7vl/xd3dHTIyMlyQFBgYCFdX198GM0DudTk5OQlM02/UqBGSk5Px5s0boa7l+fPnyMzMRKNGjbg0OTk5NGjQAI8ePQIAjBgxAnv37oW9vT18fHwQEhLyy+NPnToVX79+5bbY2NjflokQQkjh8oYOiLJJGokeFMzj8QpMF88/jiQ5ORkODg6IiooS2J4+fcq1CAC5X6I/H7ewtLzxJaGhoejXrx/atWuHkydP4vbt25g+fbrQA3b5fP4vy59HRUVF4PWfnl9eXh4DBgxAQEAAMjIysHv3bgwaVDZ/If18Lb/Ttm1bvHr1CuPHj0dcXBzc3NwwadKkIvMrKChAXV1dYCOEECIa3h9skkZsAY25uTnk5OQQHh7OpX3+/BlPnz7lXuvp6eHdu3fc62fPniE1NZV7XbduXTx79gz6+vqoXr26wPa7RzT8SkhICExNTTF9+nTUq1cPFhYWePXqlUAeKysrgbIDQFhYmMDrn8ufnZ2N+8V4Jkhxzv87gwcPxoULF7BhwwZkZWWha9euxdrPysoKoaGhAoHY9evXoaamxo0vkpeXR3b276d+mpubQ15eHtevX+fSMjMzERERgVq1anFpenp68PDwwK5du+Dn54ctW7YU9zIJIYQQAGIMaFRVVeHl5YXJkyfj0qVLuH//foFBq82bN8e6detw+/Zt3Lx5E8OHDxdoWenXrx90dXXRuXNn/Pfff4iJiUFwcDDGjBlTrO6RolhYWOD169fYu3cvnj9/jjVr1hQY4zJ27Fj8888/CAgIwNOnTzF79mw8eCA4g6B58+b4999/8e+//+Lx48cYMWIEvnz5UiLn/x0rKys0bNgQU6ZMQZ8+faCkpPT7nQCMHDkSsbGxGD16NB4/foxjx45h9uzZmDBhAvezqVq1KsLDw/Hy5Ut8+PChyJlTKioqGDFiBCZPnowzZ87g4cOHGDJkCFJTU+Hl5QUAmDVrFo4dO4bo6Gg8ePAAJ0+ehJWVlVDXSgghRDQVcmG90rBs2TI0adIEHTt2RIsWLdC4cWM4ODhw769YsQImJiZo0qQJ+vbti0mTJkFZWZl7X1lZGVevXkWVKlXQtWtXWFlZcdOn/6QrolOnThg/fjxGjRoFe3t7hISEYObMmQJ5evXqhZkzZ8LHxwcODg549eoVRowYIZBn0KBB8PDwwIABA9CsWTNUq1YNrq6uJXL+4vDy8kJGRoZQ3U2VKlXCqVOncOPGDdjZ2WH48OHw8vLCjBkzuDyTJk2CjIwMatWqBT09vV+O7Vm8eDG6deuGv/76C3Xr1kV0dDTOnj0LLS0tALmtPVOnToWtrS2aNm0KGRkZ7N27V+hrJYQQIpry0N0EiHGWU1EKm0FDRDNv3jwcOHAAd+/eFXdRSo04n7ZNKh6a5SQamuUkvLKa5bT1ykMoizDLKTX5G4Y0qyVRs5zEug4NKR3Jycl4+fIl1q1bh/nz54u7OIQQQiSUqDOWaJYTKRHW1tbcNPWft6CgIIwaNQoODg5wcXEp0N00fPjwIvcdPny4mK6IEEKIOPD/YJM0EtdCExwcLO4iSLxTp04V+RgEAwMD9OvXT+DxEPnNnTu3yGnRktJsSAghpHy5evUqli1bhsjISLx7967Aormenp7Yvn27wD6tW7fGmTNnin0OiQtoyO+ZmpqKvK++vj49NZ0QQgiAsutySklJgZ2dHQYNGlTkMiJt2rQReJafgoKCUOeggIYQQgipoESdtSTsPm3btkXbtm1/mUdBQQGGhoYilCaXJHaDEUIIIaQM/OmjD5KSkgS2/A8PFlZwcDD09fVhaWmJESNG4OPHj0LtTwENIYQQUkH96aBgExMTaGhocNuiRYtEKkebNm2wY8cOXLx4EUuWLMGVK1fQtm3bYq1Kn4e6nAghhJAK6k/H0MTGxgpMKBF23Eue3r17c/+uXbs2bG1tYW5ujuDgYLi5uRXrGNRCQwghhBCR/PywYFEDmp9Vq1YNurq6iI6OLvY+1EJDCCGEVFBlNShYWG/evMHHjx9hZGRU7H0ooCGEEEIqKB4vdxNlP2EkJycLtLbExMQgKioK2tra0NbWxpw5c9CtWzcYGhri+fPn8PHxQfXq1dG6detin4MCGkIIIaSC4oMHvgjtLcLuc/PmTYGHM0+YMAEA4OHhgY0bN+Lu3bvYvn07vnz5AmNjY7Rq1Qrz5s0TqguLAhpCCCGkgiqrFhoXFxf86lnYZ8+eFb4QP6FBwYQQQgiRetRCQwghhFRQvP//J8p+koYCGkIIIaSCKqsup7JAAQ0hhBBSQfFEHBRMLTSEEEIIkRjUQkMIIYQQqVeeAhqa5UQIIYQQqUctNIQQQkgFRbOcCCGEECL1+LzcTZT9JA0FNIQQQkgFRS00hBBCCJF65WlQMAU0hBBCSAXFg2itLRIYz9AsJ0IIIYRIP2qhIYQQQiooGhRMCCGEEKlHg4IJIYQQIvVoUDAhhBBCpB4Pog3wlcB4hgYFE0IIIUT6UQsNKRe+Z2RDLiNb3MWQKnIykvg3lmR7u8ND3EWQSlr1R4m7CFKHZWeUyXn44IEvQv8RXwLbaCigIYQQQiqo8tTlRAENIYQQUlGVo4iGAhpCCCGkgqJp24QQQgiRfiJO25bAeIZmORFCCCGkdF29ehUdO3aEsbExeDwejh49KvA+YwyzZs2CkZERlJSU0KJFCzx79kyoc1BAQwghhFRQvD/YhJGSkgI7OzusX7++0PeXLl2KNWvWYNOmTQgPD4eKigpat26NtLS0Yp+DupwIIYSQiqqMBgW3bdsWbdu2LfQ9xhj8/PwwY8YMdO7cGQCwY8cOGBgY4OjRo+jdu3exzkEtNIQQQkgFxfuD/wAgKSlJYEtPTxe6DDExMYiPj0eLFi24NA0NDTg6OiI0NLTYx6GAhhBCCKmg8p7lJMoGACYmJtDQ0OC2RYsWCV2G+Ph4AICBgYFAuoGBAfdecVCXEyGEEFJB/WmPU2xsLNTV1bl0BQWFkiiWSKiFhhBCCCEiUVdXF9hECWgMDQ0BAAkJCQLpCQkJ3HvFQQENIYQQUlGV1TSnXzAzM4OhoSEuXrzIpSUlJSE8PBxOTk7FPg51ORFCCCEVVFmtFJycnIzo6GjudUxMDKKioqCtrY0qVapg3LhxmD9/PiwsLGBmZoaZM2fC2NgY7u7uxT4HBTSEEEJIBZV/gK+w+wnj5s2bcHV15V5PmDABAODh4YHAwED4+PggJSUFQ4cOxZcvX9C4cWOcOXMGioqKxT4HBTSEEEJIBVVWz6Z0cXEBY6zo4/F4mDt3LubOnStCaXLRGBpCCCGESD1qoSGEEEIqqrJqoikDFNAQQgghFVRZDQouCxTQEEIIIRVUWQ0KLgsU0BBCCCEVVDnqcaKAhhBCCKmwylFEQ7OcCCGEECL1qIWGEEIIqaBoUDAhhBBCpB4NCiaEEEKI1CtHQ2gooCGEEEIqrHIU0VBAQwghhFRQ5WkMDc1yIoQQQojUoxYaQgghpIIqT4OCqYWGkGLy37wBdlbmMNJWQYtmToi8eeOX+Y8ePgjHOtYw0lZBo/r2OH/mVJF5J4wZCW0VWWxct7qkiy12WzZtgHWNatDVUIZrEyfcjPh1vR05dAB1bWtBV0MZjg52OJuv3jIzMzFz+t9wdLCDgbYaLMwqY+ggD7yLiyvtyyhzdL+VjGE9m+Lxv3PwOWwVru6YhHrWpkXmlZXlY+rQNnhwfDY+h61C+L6/0dLZqgxLW/Z4f7BJGgpoCCmGwwf3Y8bfk+AzdSYuX4+ATW07dO/cDu8TEwvNHx4WgiGe/dBvwEAEh9xEu46d0L93Nzx8cL9A3pPHj+LmjXAYGRmX9mWUuUMH9mGqz0T8PX0mroXdhE1tW3Tp2LbIegsLDcHAAf0wwHMQroVHokPHzujToytXb6mpqbhz+xamTJ2O/8JuImjvQTx79hS9uruX4VWVPrrfSkb3VnWxZGIXLNh8Gk59l+Du07c4vsEbelqqheb3HdkRg7s1xoSlB1Cn23z4H7yGfSuGwM6ychmXvAyVo4iGxxhj4i4EIaJKSkqChoYGXr77BHV19VI7T4tmTqjrUB9LV64BAOTk5KB2jaoYMtwb4yZNKZB/0IA+SE1Jwd5Dx7m0li7OqG1rj5VrNnBpcXFv0bKZMw4eO4Xe3TphuPcYjBg1ttSuIz85mdL/RHJt4oS6DvWwwm8tgNx6q1ndFMNGjMLEyQXrzaN/b6SkpODgkRM/jtHUGba2dli9bmOh54i8GQGXxg3x8GkMTKpUKZ0L+b/M7LL5uCxv95txo7K5p392dcckRD54hfFLDgAAeDweos/Mw8a9V7A84HyB/C/OLcAS/7PYvP8ql7Zn+WB8T8vAoBk7yqzcAMCyM5B+byu+fv1aKp9teZ+dt57FQ1VN+OMnf0tCXQvDUiufKKiFhpDfyMjIwJ3bt9DM1Y1L4/P5aObqhogbYYXuExEeJpAfAJq3aIWI8B/5c3JyMMLLA6PHTYRVLevSKbwYZWRk4PatSLg0F6w3F1c33AgPLXSfG2FhcG3eQiCtRYtWuBFeeD0DQNLXr+DxeNDQ1CyRcosb3W8lQ05WBnWsTHAp/AmXxhjDpfAnaGBrVug+8nKySMvIFEj7npYB5zrmpVpWUjIooCHkNz5+/IDs7Gzo6esLpOvp6yMhIb7QfRIT4qGvbyCQpq9vgMR8+VevWAoZWVkMGzm65AstAT5+yK23AvVgYIDEhIRC90lIiIf+T/Wsb2BQZD2npaVh1oyp6NGzt8T8lfin6H4rGbpaqpCVlUHip28C6Ykfk2CoU/i9ciH0Ecb0bw7zKnrg8Xho7lgTnZvbw1C3fNxbheL9GBgszCaJXU40y4kQMYi6HYnNG9bickgEeJI4XUAKZGZmYkC/XmCMYdXaDb/foQKj+614Ji07iA0z++DO4ZlgjOHFmw/YcTwMHp0birtopaYcratHLTSkoHfv3qFv376oUaMG+Hw+xo0bV2i+AwcOoGbNmlBUVETt2rVx6pTgrArGGGbNmgUjIyMoKSmhRYsWePbsmUCeT58+oV+/flBXV4empia8vLyQnJxcWpcmEh0dXcjIyBQYkPk+MREGBoaF7qNvYIjERMFWiMTEBOj/P3/o9Wt4/z4RtpZm0FNXgJ66AmJfv8LMqZNhZ1U+mrd1dHPrrUA9JCRA38Cg0H0MDAyR+FM9JyYkFKjnvGAm9vVrHPv3bLlpnQHofispHz4nIysrG/raagLp+jrqiP+YVOQ+PSdshY7zBFi2mwW7LvOQkpqOmLcfy6LI4lGOBgVTQEMKSE9Ph56eHmbMmAE7O7tC84SEhKBPnz7w8vLC7du34e7uDnd3d9y//2NWxdKlS7FmzRps2rQJ4eHhUFFRQevWrZGWlsbl6devHx48eIDz58/j5MmTuHr1KoYOHVrq1ygMeXl52NWpi6vBl7i0nJwcXAm+hPoNCv/Lrb5jQ4H8ABB86QLqO+bm79WnP/4Lv40roZHcZmRkjNHjJuLgsaKn20oTeXl51KnrgCuXC9ZbA0enQvdp0LAhgi9fFEi7dOkCGjj+qOe8YOZ5dDSOnzoHHR2d0rkAMaH7rWRkZmXj9qNYuDpacmk8Hg+uDWrgxt2YX+6bnpGFuPdfISvLh7ubPU4G3y3t4ooN7w/+kzQU0JSigwcPonbt2lBSUoKOjg5atGiBlJQUREREoGXLltDV1YWGhgaaNWuGW7duCezL4/Hg7++PLl26QFlZGRYWFjh+/McMhuzsbHh5ecHMzAxKSkqwtLTE6tWCa0oEBwejQYMGUFFRgaamJho1aoRXr179ttxVq1bF6tWrMWDAAGhoaBSaZ/Xq1WjTpg0mT54MKysrzJs3D3Xr1sW6desA5LbO+Pn5YcaMGejcuTNsbW2xY8cOxMXF4ejRowCAR48e4cyZM/D394ejoyMaN26MtWvXYu/evYiTsHVFRo4ejx0B/tizaweePH6EiWO9kZqagr5/eQIARgz2xNxZ07j8w0aOxsXzZ7Fu9Uo8ffIYixfMQdStSAweNhIAoK2jg1rWNgKbrJwc9A0MYVHDsrAiSKVRY8Yh8B9/BO3cjsePH2Hc6JFITUnBXwM8AQBDB3lg9owf9TbCewwunDuLNX4r8eTJYyycNwe3I29i2AhvALnBTP8+PXA7MhLbAnciJzsbCfHxSIiPR0ZGhjgusVTQ/VYy1uy6hIFdnNGvoyMszQywZlovKCspYMex3MHS/vP+wtzRnbj89W1M0bm5HapW0kGjOuY4vs4bfD4PKwMviOsSSp0o42dEXYyvtNEYmlLy7t079OnTB0uXLkWXLl3w7ds3/Pfff2CM4du3b/Dw8MDatWvBGMOKFSvQrl07PHv2DGpqP5pH58yZg6VLl2LZsmVYu3Yt+vXrh1evXkFbWxs5OTmoXLkyDhw4AB0dHYSEhGDo0KEwMjJCz549kZWVBXd3dwwZMgR79uxBRkYGbty4UWL956GhoZgwYYJAWuvWrblgJSYmBvHx8WjR4seMFQ0NDTg6OiI0NBS9e/dGaGgoNDU1Ua9ePS5PixYtwOfzER4eji5duhQ4b3p6OtLT07nXSUmFNx2XtK7de+Ljh/dYNN8XiQnxsLG1w4Gj/3JdJ2/evAaf/+PvA8eGztgSsAsL587CfN8ZqGZugV17D6GWtU2ZlFdSdOvRCx8+fMCCub5ISIiHrZ09Dh8/xdVbbGwsePnqraGTM/7ZvgtzfWdhzqzpMK9ugT0HDnP1Fvf2LU6dzJ3S7dygrsC5Tp29iCbNXMrkukob3W8l4+C5W9DVUsWsEe1hoKOGu0/eorP3em6gsImhNnJyfkzFV1CQw2zvDjCrpIvk1HScvf4AXjN34Gvyd3FdAhECrUNTSm7dugUHBwe8fPkSpqZFr0wJ5DYna2pqYvfu3ejQoQOA3BaaGTNmYN68eQCAlJQUqKqq4vTp02jTpk2hxxk1ahTi4+Nx8OBBfPr0CTo6OggODkazZs1Evg4XFxfY29vDz89PIF1eXh7bt29Hnz59uLQNGzZgzpw5SEhIQEhICBo1aoS4uDgYGRlxeXr27Akej4d9+/Zh4cKF2L59O548eSJwbH19fcyZMwcjRowoUB5fX1/MmTOnQHppr0NTHpXFOjTlTVmtQ1PeiGsdGmlWVuvQ3H2RADUR1qH59i0JttUMilW+wj63LS0t8fjxY6HP+yvU5VRK7Ozs4Obmhtq1a6NHjx7YunUrPn/+DABISEjAkCFDYGFhAQ0NDairqyM5ORmvX78WOIatrS33bxUVFairqwsMmFy/fj0cHBygp6cHVVVVbNmyhTuGtrY2PD090bp1a3Ts2BGrV6/Gu3fvyuDKS9fUqVPx9etXbouNjRV3kQghRHqV0aBga2trvHv3jtuuXbtWUlfAoYCmlMjIyOD8+fM4ffo0atWqhbVr18LS0hIxMTHw8PBAVFQUVq9ejZCQEERFRUFHR6fAGAA5OTmB1zweDzk5OQCAvXv3YtKkSfDy8sK5c+cQFRWFgQMHChwjICAAoaGhcHZ2xr59+1CjRg2EhRW9QJkwDA0NkfDTWiIJCQkwNDTk3s9L+1Wen2e0ZGVl4dOnT1yenykoKEBdXV1gI4QQIpqyGhQsKysLQ0NDbtPV1S3xa6GAphTxeDw0atQIc+bMwe3btyEvL48jR47g+vXrGDNmDNq1awdra2soKCjgw4cPQh37+vXrcHZ2xsiRI1GnTh1Ur14dz58/L5CvTp06mDp1KkJCQmBjY4Pdu3eXyLU5OTnh4kXB2Sjnz5+Hk1Pu7BUzMzMYGhoK5ElKSkJ4eDiXx8nJCV++fEFkZCSX59KlS8jJyYGjo2OJlJMQQkjReBBxUPD/909KShLY8o9xzO/Zs2cwNjZGtWrV0K9fvwI9EiWBAppSEh4ejoULF+LmzZt4/fo1Dh8+jPfv38PKygoWFhbYuXMnHj16hPDwcPTr1w9KSkpCHd/CwgI3b97E2bNn8fTpU8ycORMRERHc+zExMZg6dSpCQ0Px6tUrnDt3Ds+ePYOVVfGeHBsVFYWoqCgkJyfj/fv3iIqKwsOHD7n3x44dizNnzmDFihV4/PgxfH19cfPmTYwaNQpAbjA3btw4zJ8/H8ePH8e9e/cwYMAAGBsbw93dHQBgZWWFNm3aYMiQIbhx4wauX7+OUaNGoXfv3jA2Lv8PziOEEHH70x4nExMTaGhocNuiRYsKnMPR0RGBgYE4c+YMNm7ciJiYGDRp0gTfvn0rkPdP0CynUqKuro6rV6/Cz88PSUlJMDU1xYoVK9C2bVsYGhpi6NChqFu3LkxMTLBw4UJMmjRJqOMPGzYMt2/fRq9evcDj8dCnTx+MHDkSp0+fBgAoKyvj8ePH2L59Oz5+/AgjIyN4e3tj2LBhxTp+nTp1uH9HRkZi9+7dMDU1xcuXLwEAzs7O2L17N2bMmIFp06bBwsICR48ehY3Nj1kVPj4+SElJwdChQ/Hlyxc0btwYZ86cgaKiIpcnKCgIo0aNgpubG/h8Prp164Y1a9YIVReEEELEIzY2VqDrX0FBoUCetm3bcv+2tbWFo6MjTE1NsX//fnh5eZVYWWiWE5FqZfW07fKIZjkJj2Y5iYZmOQmvrGY5PXyZCDURjv8tKQm1quqLXL769eujRYsWhbboiIq6nAghhJAKq+yffZCcnIznz58LLOlREiigqYCsra2hqqpa6BYUFCTu4hFCCCkjZbFS8KRJk3DlyhW8fPkSISEh6NKlC2RkZATWMSsJNIamAjp16hQyMzMLfc+giIcGEkIIKX/K4mnbb968QZ8+ffDx40fo6emhcePGCAsLg56enghnLhoFNBXQ71YuJoQQUjGI+lwmYfbZu3ev8CcQAXU5EUIIIUTqUQsNIYQQUkGJsupv3n6ShgIaQgghpKIqi0E0ZYQCGkIIIaSCKkfxDAU0hBBCSEVVFoOCywoNCiaEEEKI1KMWGkIIIaSCokHBhBBCCJF+5WgQDQU0hBBCSAVVjuIZCmgIIYSQiqo8DQqmgIYQQgipsEQbQyOJbTQ0y4kQQgghUo9aaAghhJAKqjx1OVELDSGEEEKkHrXQEEIIIRVUeWqhoYCGEEIIqaBoYT1CCCGESL3y1EJDY2gIIYQQIvWohYYQQgipoGilYEIIIYRIv3IU0VBAQwghhFRQNCiYEEIIIVKPBgUTQgghhEgQCmgIIYSQCor3B5uw1q9fj6pVq0JRURGOjo64ceNGCVzBDxTQEEIIIRVVGUU0+/btw4QJEzB79mzcunULdnZ2aN26NRITE0vqSiigIYQQQioq3h/8J4yVK1diyJAhGDhwIGrVqoVNmzZBWVkZ//zzT4ldCw0KJlKNMQYA+PYtScwlkT5yMhI4qk/CZWYzcRdBKrHsDHEXQerk1VneZ1xp+fYtSaQBvnmfuUlJgp+9CgoKUFBQEEjLyMhAZGQkpk6dyqXx+Xy0aNECoaGhwp+8CBTQEKn27ds3AEDtGlXFWxBCCCkF3759g4aGRokfV15eHoaGhrAwMxH5GKqqqjAxEdx/9uzZ8PX1FUj78OEDsrOzYWBgIJBuYGCAx48fi3z+n1FAQ6SasbExYmNjoaamBp6EzSNMSkqCiYkJYmNjoa6uLu7iSAWqM9FQvYlGkuuNMYZv377B2Ni4VI6vqKiImJgYZGSI3nrGGCvwuftz60xZooCGSDU+n4/KlSuLuxi/pK6uLnEflpKO6kw0VG+ikdR6K42WmfwUFRWhqKhYqucAAF1dXcjIyCAhIUEgPSEhAYaGhiV2HhoUTAghhJBSIy8vDwcHB1y8eJFLy8nJwcWLF+Hk5FRi56EWGkIIIYSUqgkTJsDDwwP16tVDgwYN4Ofnh5SUFAwcOLDEzkEBDSGlREFBAbNnzxZrn7K0oToTDdWbaKjeyk6vXr3w/v17zJo1C/Hx8bC3t8eZM2cKDBT+EzxW2nPCCCGEEEJKGY2hIYQQQojUo4CGEEIIIVKPAhpCCCGESD0KaAghhBAi9SigIYQQQojUo4CGEEIIIVKPAhpCCCFl5ueVQirCyiEV4RolAa1DQwgpNwp7WB6RHDk5OeDzc/+OfvPmjcQ/h01U9+7dQ2pqKr5//w4XFxdxF6fCoBYaQiqYnJycAmnZ2dliKMmf+/la8oIZ+jtN8uQPZubPn48ZM2bg6tWrYi5Vydu6dSvatm2Lnj17onv37mjSpAnCw8P/6KnWpHiohYaQCiT/l0pMTAyys7NhamoKOTk5MZdMePmvZdeuXbh37x5kZGTQoUMHODs7U2uNhJoyZQr++ecfbN68Gc7OzgJPW87/M5VG169fR6dOnbB161ZYWVkhKysLgwYNQlJSEubOnQt3d3d6zEIpkt47hxAilPxfFnPmzEH79u3RsmVLWFpaIjg4GN+/fxdzCYWTdy1TpkzBtGnT8PjxY8TExKBFixY4deoUBTMS6N9//8XevXtx4cIFdO3aFfr6+vjw4QOuX78Oxhj4fH6hLYjSIjY2FiYmJnBzc4OVlRVq166NiIgIWFpaYvbs2bhy5Yq4i1iuUUBDSAWRFwDMnj0bmzdvxvz583Hr1i1UrlwZgwcPxvHjx5Geni7mUv7azw3K/v7+2LNnDw4dOoRjx47B3d0daWlp6NChA/bs2SOmUpKiZGZmQktLC6ampnj8+DHmzp2LevXqoU+fPmjYsCGys7OluoXm69ev+Pz5M5SVlQGA+yPh+PHjMDQ0xOTJk6U6YJN00nvnEEKKJX8QcOPGDZw/fx6BgYHo2rUrQkNDce/ePWhpacHLywtHjx5FamqqGEtbtGnTpuHQoUPcF0JSUhJiYmIwc+ZM1K9fHydPnsTQoUOxcuVKeHt746+//sKJEyfEXOqKq7DRDLKyssjKykL37t3h6uqKV69ewcfHB/7+/njz5g0uX74shpKWnK5duyIlJQUTJ04EACgpKXF/JBw7dgzx8fHYsGGDOItYvjFCSLmVk5PD/TslJYV9/vyZbdq0iTHG2KVLl5iBgQH32snJiZmbm7N//vmHpaeni6W8RUlOTmaWlpasUaNG7N9//2VZWVmMMcYePHjAoqOj2bNnz1iNGjXY6tWrGWOMnTlzhvF4PMbj8djZs2fFWfQKKTs7m/t3YmIie/nyJff62LFjbMaMGWz//v0sMTGRMcZYbGwss7e3ZyEhIWVe1j/x7t07FhcXx1JTU7m0LVu2sEqVKrF58+ZxaVlZWSw5OZnVr1+fLVmyRBxFrRBkxR1QEUJKB8s3KHbw4MG4desWbt26hW7dugEANm3ahJ49e2LIkCHIysqCiYkJXrx4gaCgIAwcOFCcRReQk5MDFRUVhIWFoXPnzli0aBGysrLQvn171KpVCwBw8uRJaGhooF+/fgAADQ0NDB06FE5OTmjevLk4i1/hsP+PhQEAX19fnDhxAjExMbC2toanpyf69++PTp06AcidXffp0yeMGDECampqaNCggTiLLpTAwEAsWbIEGRkZXKtM9+7dMWDAALx+/Rr+/v5ISUnBokWLICMjAxUVFeTk5EjlAHxpQQENIeVUXjATHR2Nt2/fYsWKFQAAXV1dpKamIiYmBvb29uDz+eDz+ZCRkUFISAiqVq0qxlIXTVNTE5s3b0a3bt2wdu1ayMrKok2bNuDz+UhPT8fNmzfx6NEj1KhRAwsXLoS2tjY8PDwAAFlZWZCVpY+7spB33y1YsADr1q3DypUrYWBgAH9/f/j7++Ply5eYPn065OXlsW7dOpw+fRofPnxAaGgoZGRkkJ2dDRkZGTFfxa+dPn0a3t7eWLFiBaytrXH27Fns2LED4eHhmD17NqZNmwYNDQ3Mnz8fV65cQbVq1fDq1SukpqZi9OjR4i5+uUXTtgkpxwIDA+Hv7w9tbW3s378f8vLy3F/P/fr1w8WLFzFgwABcu3YNSUlJuHPnDmRkZCRy+uzEiRMRHx+P+/fvIzo6GmZmZli6dClat26NnJwceHp6Ys+ePTA3N4eSkhIiIyMhJydH07fLSF49M8bw+fNntG3bFsOGDcOgQYMAAGlpaZg3bx7OnDmDxYsXo2XLlti1axdevXqFKVOmcONrJDnwzLvGKVOmICYmBvv37+fe279/PzZu3Ag1NTUsW7YMlpaWePz4MZYtWwZZWVmoq6tj0aJFkJWVlYqgTRpRQENIOZIXiOTk5CAtLQ3Lli1DUFAQZGVl8fDhQwBAeno6txaGh4cHEhMToampiR07dkBOTk4igxl/f3/4+Pjg4sWL0NXVBWMMnTp1goyMDBYsWIA2bdogOzsbFy5cQHp6Otq3bw8ZGRmJ/4IsL/LfM/Hx8VBVVUXjxo3h6emJcePGCXyB16lTB/Xq1cPWrVsFjiFNX/LTpk3DlStXcOHCBSgpKXHphw8fxrJly9CkSRPMmTNH4L08dE+WHsn61CKE/JG8L5WPHz9CWVkZI0aMwIgRIxAfH49hw4YBABQUFLhVS7dv344jR45gz549kJOTQ1ZWltiDmfXr1+P9+/cCadHR0ahXrx7s7e1RqVIlVKlSBZcvX0ZKSgqmTJmCU6dOAQBat27NBTrZ2dn0xVEG8o+ZGTVqFLy9vfH161eoq6sjODgYALifBwA4OzsXOpNOWoIZAKhevTqePn2KO3fuAMgNUoDcWU69e/fGxo0b8eHDBwAFZ3vRPVl6KKAhpJw5dOgQDAwMcOfOHejr6+Ovv/7CtGnTcP36dYwdOxYAIC8vzwU1ioqKAHI/eMX9Ybt9+3ZcvXoV2traXBpjDBkZGfj27Rt4PB74fD6+f/8OLS0tLF68GI8ePcK0adMQGhoqcCxp+oKUZnndeW/fvsWNGzcwZswYVKpUCWvWrMGFCxcwatQobupyVlYWbt26JbA6sDRIS0vDt2/fuNeDBg1CvXr10LdvX7x9+5brRgJygzpVVVXufqTuzrJDAQ0h5YydnR06dOgAFxcX3L17F7q6uhgwYAA8PDxw+fJljB8/HkBuUJOfJHzwenh4YPfu3ZCRkcHFixfx+vVr8Hg89OvXDxEREViyZAkAcE35jDF07doVDRs2hJOTkziLXqEtWrQII0aMgIWFBTdTyd7eHrt370ZgYCCaNm2Kdu3awdXVFUlJSdzPURrs3r0b3bt3R506dTBy5Ejs3LkTQO7jNnR0dNCsWTM8ePCAC6Dj4+Ohrq4OLS0tcRa7QqKAhhAp9vNDJRljqF69OtasWQMXFxc0atQId+/ehb6+Pjw8PLiAwc/PTzwF/oW8FiMZGRncuXMHAwYMwOrVqxEbGwsHBwcsXboUs2bNwqxZs/Dy5Uu8fPkS/v7+sLa2xqZNmwS6NUjZUlFRwcWLFxEVFSUQGHfq1AkPHjyAq6srLC0t0bx5c9y5c4cbACzp9u3bBy8vLzg6OmLAgAF48eIFFixYgClTpkBHRwfHjx9H5cqV4erqCh8fH6xYsQJeXl5QUVGh5QLEocxXviGE/LHMzEyB1xs3bmSvXr1ijP1YTO/FixfM3d2dqampsQcPHjDGchcCCwoK4hamk0TLli1jmZmZbNGiRaxevXps8uTJLCEhgWVnZ7OtW7cyTU1NVrlyZVa5cmVmb2/PMjIyGGOCiwiS0hMREcEeP37MGGNs0qRJ7PTp0+z79+8sICCAycnJsWnTpnF5f75P80jy/ZcnIyOD/fXXXwLXExsby1auXMn09fXZhAkTuPTp06ezNm3aMGdnZ9avXz/unpSG6yxPKKAhRMr07NmTDRw4kFvNNy4ujtnb2zMzMzP25s0bxtiPL/f79+8zU1NTZmRkxG7fvi1wHEn5sM2/qqy/vz/j8Xjs1q1bjDHG5s+fz+zt7dnkyZPZu3fvGGO5Xyrnzp1jZ8+e5a6hqC9OUrKio6NZrVq12MiRI9mgQYMYj8djd+/eZYwxlp6ezjZt2sRkZGTYnDlzuH2ys7OlMtjMzMxkjo6OzMPDQyD906dPbM2aNczMzIytWrWKS09LSxNYYZvuybJHAQ0hUmb37t1MUVGRTZgwgfvQDAsLY25ubszCwoILahjL/VDt0KED09TUZG5ubowxyWrJyP+hf/bsWTZ37lx24MABgTx5QY2Pjw/XCpWfpARmFcWOHTuYgYEBk5eXZ0ePHmWM/bin8oIaWVlZgaX/pdW8efNY8+bN2f379wXS3717x4YMGcLat2/PkpOTGWOCv1eS9DtWkVBAQ4gUyfvyPnr0KFNQUGATJkzgmrfDw8OZi4sLs7CwYAkJCYwxxr5//8769OnDrly5ItASIm7Dhw9nT58+ZYzlfvhfv36dVa1alamrq7OTJ08yxnL/4s2zYMECVq9ePTZs2DD2/v17sZS5osu7fy5dusRq1KjBLC0t2ejRo7nuzDzp6els8+bNjMfjsX/++UccRf0j+YORq1evMhMTEzZx4kTudypP3vPCfg52iPhQQEOIlMjfEnHv3j32999/Mx6Px6ZNm8Z92YSHhzNXV1emrq7OvL29Wf369ZmjoyO3ryQENdHR0axu3brM3NycxcTEMMZyu5Hmz5/PdHV1Wf/+/bm8+Zvwp0yZwjw9Pemv3zL28z2TmprK0tPT2bZt21idOnXY0KFD2cOHDwvsc+TIEanqdnn06BH78uULY0zwmnft2sX4fD7z8fFhz58/59Lv3LnD7O3t2bNnz8q8rKRwFNAQImUmT57MLCws2PDhw5mjoyPj8/ls7Nix3Bf927dv2aRJk1inTp3YoEGDuBYcSQhmGMstx82bN1mrVq2Yqakpi46OZowxlpCQwBYtWsSqVavGJk6cyOXPH9TkXSMFNWUj/z1z48YN9t9//7EbN25waZs3b2Z16tRhI0eO5FpqunTpwi5evMjlkYagZteuXczAwIDNnDmTC2ry/wGxfft2pq2tzXr16sXWr1/Prl27xlq2bMmcnJwk5veKUEBDiFQ5f/48U1dXZ9euXWOMMZaSksJ27NjB5OTk2Pjx4wW+/L9//879W1K+VPKCK8YYu3DhAmvUqBGzsrJiL1++ZIzljk1YuHAhs7a2ZpMnTy50Pwpmyp6Pjw8zNzdnurq6rHLlyqxt27bc/bVp0yZWv3591rBhQ+bo6MiMjY0Ffl6S7tKlS8zc3Jw5ODiwhg0bsnnz5nFBTf7fm1OnTrF+/foxHR0d5uDgwFxdXSXuj4WKjtZgJkSKJCcnw8DAAHZ2dgAAZWVl/PXXX0hOToa3tze0tLQwYcIEqKioSNQKwHnk5OQAAPPmzUNYWBjS09Px+PFjuLm54ezZszA3N8fAgQPB5/MRFBSEL1++YMuWLdx+gGQsAFiRrF27Fv7+/jhx4gSUlZWRmJiIESNGoEWLFrh27RqGDRsGPT09PHjwAJ8+fcK1a9ek4kGTQO46Tnfv3kWDBg2wePFirF69GkePHgUAjB49GhoaGtx1tG3bFq6urvj69Suys7NhZGQEHo8nFddZYYg7oiKEFF94eDiTkZFhwcHBjLEfrRV3795lampqjMfjMT8/P3EW8bfWrVvHVFRU2OXLl9mLFy/Y3r17WZMmTVjVqlW57qd3796xadOmsX79+lGLjJh5eXmx8ePHC6Q9ffqUGRsbsyFDhhS6j6S0CBZHYmIiCw0N5V6PGzeOOTg4sHnz5rHPnz8zxopuFaSWGclCT9smRAIV9cTrb9++YejQoXj37h0WLlwIZ2dnALnP0VmwYAG6du0KFxcXif2LMScnB8OHDwcAbNmyhUu/fv06Ro0ahe/fv+PcuXOoUqUKPn36BC0tLfB4PDDGqGVGTJo3bw5VVVUcP34cwI+nYi9cuBCnTp3C6dOnoaamJuZSlqwJEybg6tWrcHd3x9ixY8Hj8bBo0SL4+voKtBYSyUKPPiBEwuQPZo4cOYKtW7di9erVyM7OhpqaGoYMGQJ1dXUMHz4cW7duxfHjxzFo0CA8evQIbm5uEr2sPJ/Ph4yMDG7fvi2Q3qhRI7i7u+Pp06ewtrbGmzdvoK2tTcGMGOX9rZu35P/hw4cB/Hjop7a2NtLS0sRWvtKQ9+iMlStXomnTpjh+/DgWLVqEli1bYu/evWJ/Ej35Ncn8M46QCooxxn1o/v3339i5cycsLCzw/Plz7Nu3D+vWrUPz5s2hrKyMvXv3YsKECTAzM4OWlhYuXLjABQCS0EJTVCtT8+bNERoaisDAQPTq1Yt70GTNmjXRo0cP1KxZE0ZGRlx+CmbEI6/enZycYG5ujoCAAKSlpaFv375ITEzEsWPHYG5uDlVVVTGXtOTkPQ9MRkYGK1euxMiRI7F48WLUqVMHjx8/hoyMTJH3NRE/6nIiRAL5+flh2bJlOHHiBOrWrYsjR46gW7dusLe3x+bNm1G/fn0AuU/2lZGRga6urkQNUMz/oX/16lUkJydDUVERzZs3R1ZWFjw9PfHs2TP069cPPXv2hIyMDAYPHgwLCwssX74cwI+uDSJ+N2/exPLly/Hff/+Bx+NBW1sbfD4fERERkJOTK3etaIwxfPv2DR06dEB6ejquX78uNQOdKzIKaAiRMB8/fsSCBQtQp04d/PXXXzh8+DC8vLwwf/58bNmyBbKysli7di3q168v0J8viX85Tp48GUFBQVBVVcXz58/Rrl07zJw5E3Xr1sWIESMQGRmJR48ewczMDDwej3sSc3n7giwP4uPj8f79ewQHB8PY2Bju7u6QkZEpt1/yS5cuxZIlSxAfHw85Oblye53lCQU0hIjZz4EIYwwXL16Era0t4uPj0a1bN4wePRpjxozBwYMH0bNnT5iamuLkyZOwtrYWY8l/bdu2bZg2bRpOnDgBc3NzvHnzBiNGjICamhpWrFgBKysrvHjxAjdv3oSysjI6dOgg0ORPSldhQaOwgaQ0/Kz+JNDP25eCGelAAQ0hYpT/wzYgIAB6enro0KED9/62bduwY8cO7N+/HwYGBjhw4ABCQ0Px+fNn+Pv7S/SXydixY/H27VscPHiQu86HDx+iW7ducHZ2xrZt2wrsIw1fkOXNihUrICcnhzFjxvw2788BjyS2CuaXv3zPnj1DtWrVinV/ZWZm0mwmKSS5dyIhFUDeh62Pjw9mzpyJO3fu4NOnT9z7MTExePPmDdLT0/H582fs2LEDxsbGCAgI4FozJEFOTo7A67wxCCkpKVxaZmYmatWqhVmzZuHQoUOIi4srsB8FM2UrNTUVDx48QEhICLKysvCrv2/zBzOPHz8GAKkJZmbPno1+/fohNDT0tzMAGWNcMPP27VuJ+R0jvye5dyMh5dTPXxr+/v4ICAjA8ePH8ffff0NbW5t7b9y4ccjIyEC9evXg4OCA169fY+zYsdz7khAA5P/ieP78OeLi4sAYg6enJ86ePYtDhw6Bz+dzXxKysrIwNzeHioqKRH8hVgTKyspo3749/v33X9y/f5+bJfez/MHMpk2bMHDgQLx8+bKMSyucvHtr2rRp2LJlC6ZOnYrq1asX6DrKf735r3Pt2rUYNmyYwB8YRLJRlxMhZejFixeoVq2aQNq4ceOQmZmJ9evXc331+YOEr1+/YufOnVBVVUX//v0larZF/i+Av//+G8eOHcP79+9hbW2NHj16ID09HTNmzMCmTZvQqlUryMjIwNPTEwDw77//0sDfMvSr8THdu3eHnJwcAgICuEdmFLbfli1bMGHCBAQGBqJ79+6lXuY/dfv2bXTv3h3+/v5wdXVFamoqPn36hIiICFhYWMDGxobL+/N1Tpo0CVu3bkWvXr3EVXwirNJchpgQ8oOPjw9r2rSpQFpOTg5zdXVlnTp1EkhjjLG0tDR269atAsfJ/xRgccq/7PuePXuYoaEhO3r0KAsMDGQ+Pj5MUVGRjRkzhm3cuJHJy8szExMTVqNGDVa3bl16qJ8YLVmyhO3atYvdv3+fS9u2bRuztrZmb9++ZYz9+LnkX/J/06ZNTF1dnR06dKhsC/wHrl69yqpUqcJiY2NZSEgIGz9+PKtZsybT0NBgzZo1YyEhIYwxwftQGq+T5KKAhpAykpiYyH2RJyYmculLlixhdevW5Z7PlOf58+esbdu27MaNG2VaTmFdvnyZDR48mK1cuZJL+/r1K1u3bh1TVVVlJ0+eZE+ePGHHjh1j//77LxeQSdPzfsqLnJwcNmDAAGZjY8MsLS3ZzJkzuednOTg4sJEjRxa634YNG5impiY7ePBgWRZXKIU9byktLY0ZGhqyWrVqMRUVFTZ8+HB2+PBh9uTJE2ZgYMD27t0rkD8vmJHk6yRFo4CGkDK2b98+xuPx2N27dxljjN26dYtZW1uznj17shMnTjDGGHv58iXr2LEja9y4scS0yBTm3bt3zNzcnKmpqbH58+cLvPfx40fWuXNnNmrUqAL7SfI1VQQPHjxggYGBrFq1aszJyYn16tWLTZ8+nTk5ObEXL14I5D169CjT0NBgBw4cEFNpfy9/C0t8fDz79OkT+/LlC2OMsQ8fPjA/Pz927tw5lpqayuVzcnJiu3fv5l4HBAQwZWVlapmRYjSGhpAyFhsbi+HDh+PmzZs4f/48bG1tcf36dcyYMQOvX79GcnIyDA0NIScnh9DQUMjJyUn0dOa7d++ia9eu0NDQgL+/P+rUqcO9N3jwYLx9+xanT58WYwlJHvbTOJr3798jIiICa9euRUhICL59+4Zt27Zh4MCBXN7Tp09DWVkZzZo1E2PJi5Z/vNn8+fNx/vx5vHjxAm3atEHPnj3RsmVLLu/379/x7ds3eHp6IiEhATdu3OB+r06ePAkAAssmEOlCAQ0hpaiodToSEhLg5eWFkJAQBAcHw9bWFi9fvsTHjx8RFhaGqlWrok2bNlKzEuvdu3cxYMAA2NnZYfz48bC3t8e3b9/Qpk0bWFtbCzxZm0iGn+/NK1euICgoCGFhYTh79qzA87SkwcyZM7Fx40asX78eALB161bExcVh2bJlaN++PbKzs7FlyxYEBgZCVlYWwcHBtAJwOUMBDSGlJP8XxsGDB5GYmAg1NTW4urqicuXK+PTpEwYMGICQkBBcuXIFtWvXLnAMSW6Z+dnt27fRv39/fPr0CfXq1YO8vDxiYmIQFhYGeXl5epyBhMp/n16/fh2DBg1CUFAQ6tWrJ+aSFd/Zs2cxceJEbNu2DY6Ojrh48SI6dOgAe3t7fPnyBX5+fmjdujWio6Nx/vx5DB06VGr+WCBCEFtnFyHlWP4Bij4+PkxFRYU5OjoyRUVF1rhxY7Z582bGWG7/fseOHZm+vj67ffu2mEpbcu7du8fMzMxYkyZN2MaNG7n0vMHQRDLlv1/Nzc2Zv7+/GEsjvKdPn7LJkyczxhg7deoU09XVZVu3bmURERHM1NSUWVhYFBgDROO4yh9a1YqQUpDXEvH06VOcP38eFy9eRFhYGKKjo2FmZoZdu3YhKCgIOjo62LRpE2rUqIFp06aJudR/zsbGBocPH0ZGRgZu3bqF6OhoAKBl5MvAz6su/y49D8vXcrZv3z58/PgRTZs2LfHylZTCrsfCwgIzZsxAZmYm1q1bh5EjR2Lw4MGoV68eLC0twefzcfz4cYF9pKXlkxQfBTSElJJFixZh6tSpMDMzg52dHQCgUqVKmDdvHtTV1bF3714AgLGxMY4cOcINSpR29vb22LhxI+7cuYOZM2dyy+ST0vNzt9GpU6dw9epVALkr5ha1fH/+YCYqKgppaWnconOSKP91Pnz4EJGRkdx76urq+PLlCx48eAA9PT0AwKdPn6ClpYX58+dj+/btYikzKTvUeUhIKdHR0cGRI0dQuXJlJCYmokqVKsjJyYGpqSl8fHzg4uKCu3fvwtbWFrq6ugAk/2F/xVWnTh2sW7cOkydPhoaGhriLU64xxrh7ZurUqTh8+DBSUlJQpUoVmJqaYs+ePYWOF2E/LfM/b948XL16FdWrVxfLdRRH/mefBQUFITk5GTVr1sSKFSvQoEEDqKuro2HDhti/fz8yMzNx6tQppKamomvXruDxeOXm94sUjn6yhJSSoUOHYu/evYiLi8O6deuQmprKfZgqKiqievXqUFBQENinPH3Y1q9fH2fOnJG62TLSJi8oWbJkCQICAhAQEIBXr16hefPm2LdvH9q0aQMg9xlaeS01+YOZzZs3Y/bs2Vi7di1q1qwpnov4jfzdTMeOHcPx48exZcsWXLhwATIyMhg2bBguXboEBQUFDB06FEZGRvjnn3+gpKSE4OBg8Pl8CmYqAJrlREgpCwwMhJeXF4YPH45OnTrByMgIU6dORWJiIsLDw+lDlogk/xd0bGwsBg0ahHHjxqF9+/Y4c+YMevToAU9PT5w8eRLW1tZcl2ZmZiY3pmnz5s3w8fHBP//8g27duontWopr7969ePXqFeTk5DBhwgQuvXnz5nj37h3WrFnDrTvz+fNnaGpqgsfj0WymikKMA5IJqTACAwOZrKws4/F4bPjw4axLly70PCMisvyzki5cuMAYy32eVlxcHAsJCWGVKlXiZtKNGjWK8Xg85uDgIHAMaVvmP+N/7d17XM73//jxx1VSIVR8mnwJM4fMLM3IYdhC5oM5H5IyrOQ0x5xJEa2YpLKKYlIO1UgYPiaEbdEccpjkkJrDmFZNquv9+8Ov61PMPrJRV573f+a63q/3+3q+d3tf1/vZ6/18vV6PHim1a9dWVCqVMn78+Ke2f/jhh0qLFi2UmJiYEqPq5Pv1+pA/DYV4BRwdHYmIiEBXV5e6deuyZcsWzQzA0kMjSkMp9rho4cKFTJw4kbS0NIYOHUqdOnXYvXs3H374ISNHjgSgUaNG9OvXD2tra80jp0OHDjF16lSt6ZlRq9Xo6elx7do1rK2t2b17Nz/88ANKsQcMBw4cQEdHh23btpUYVSffr9eH9MEJ8QKUJyaJe57n84MGDSI7O5sxY8YA4ObmJsOZRakVXXdnz57l1KlTBAUF0bBhQ832K1eukJKSgoGBAQUFBRw5coSOHTsyZcoUTZvOnTuTkJCAtbX1K4//eTz5fSr6d1FNjJWVFS4uLk8ttXH69OlnjugSFZ/U0AjxNyxbtox27drRpUuX/9m26Ec6PDycUaNG4enpWSHmnhGvXkBAABEREajVamJiYjAzM9PMKh0fH8+UKVOoXLkyBgYG5Obm8tNPP1GpUiUURUGtVpfrOViKJzOBgYGcO3eOa9euMWPGDCwtLalVqxY5OTlYWVlRvXp1QkJCaNWqVYk/MLRphm3xz5G+OCFeUF5eHkeOHCE4OJi8vLy/bFv8R7pXr17s2rWLfv36vYowRQXw5GRyLVq0ICMjg+TkZL7//nvgvxPFderUiZUrV/LRRx/RvXt3TTJTWFiISqUq9zf64kPQ3d3dURSFatWqMWjQIMLDw7lx4wZVq1bl1KlT5OTk0Lt3b80EjkXK+zmKl6QM63eE0HqrV69WmjVrpmRmZiqK8ucFiMULOIOCgpQ2bdoov/zyyyuLUVQcBw4cUO7cuaMoiqL8+OOPSuPGjZXevXsrJ06c+Mv98vPzX0V4/5iwsDDFwsJCOXnypKIoivL9998rKpVKMTc3Vzw9PZX09HRFURQlKytLGTJkiCxjIBRFkaJgIZ7Ls6aPnzBhApUqVcLd3R14ugBReWK+j2nTpjFr1izMzMxebsCiwklISGDcuHF4eXlx7949rK2tCQ8PJyUlBR8fH3744QdN2yfrSMr7kOUnv1/5+flMnz4dKysrYmNj6datGxs2bGDUqFF4eHjw9ddfc+XKFYyMjIiMjERXV1dqZ4TU0AhRGiEhIdSqVYsOHTpoplcPDAxk06ZNREVFUbduXU3bJ5OZmTNnsn79evr3718msQvtpigKc+fO5dChQ3To0AE3NzdMTU05evQoTk5OWFtbM2nSJNq3b1/WoZZK8cexMTExvP/++6jVaipVqkR+fj59+vTB0dGRKVOmkJmZSfPmzSkoKCAwMBAHBwdZxV1oSA+NEM8pPz+f4OBgli5dio2NDVFRUaSlpTFy5EguXrzIzp07S7Qv+pENCgpi1qxZrFu3TpIZ8VyK9zYU/VulUrFkyRK6du1KQkICy5cv5969e3To0IHw8HB27drF7t27yyrkF6IUW7Zhzpw5TJgwgejoaMzMzKhTpw4ZGRnk5+fTqVMnAO7evYuDgwPLly9n+PDhAJLMCI3y3Q8pRDmip6fHiRMnSElJYcOGDbi7u1O5cmWGDRvGgAEDCAkJoXfv3iV6aWJiYpg8eTIRERFaMd+HKFtFa3sVFbWGhYWRkZHBtGnT0NfXR6VS4eHhAcDWrVvR09Nj+vTptG/fnsTERCwtLcsy/FIrSkY8PDwIDg4mPj6eZs2aUblyZQAePnzIr7/+SkpKCgDu7u4YGRkxfvx4QEYziZLkkZMQz+nJuTHOnj3LuXPnmDdvHnl5edy8eZO9e/dia2ur+aHdsmULtWvXpmvXrmUYudAGK1euZNmyZWzatAlbW1vy8/MZPnw4V65cYeTIkTg7O2NgYKBpb2dnx9mzZ+nVqxfe3t6aRUC17SZ/7949hgwZgpOTE/b29ty8eZPU1FQ2bNjAxx9/jL+/P+fOncPAwAAzMzOOHj0q8zeJPyUJjRCl9OQz+6ysLI4dO4avry8PHjzg2LFjMjupKLWEhATWrl3L2bNnWb58OXZ2duTm5jJ58mROnz7N0KFDcXFxwdDQEHi84vS+ffvo0qULK1as0NpHL/fv3+ftt99m1KhRdO/enYCAANLS0igsLOTWrVt4eHjQokULCgsLadOmzZ+uHC4ESEIjxN9SvNfm8OHDjB8/nq+//pp33nmnjCMT2ujkyZOsXbuWxMRE/Pz86Nq1K7m5uUyYMIGUlBQGDhzIZ599hpGREQ4ODnzyyScMGDAAlUql1atJh4aGMmPGDAoLC3FxcaFbt27Y2toyfPhwDAwMWLdunaattvVAiVdHO69+IcqJ4jcQKysr7t69S3p6ehlGJLRN8SHL169fx8DAgNTUVFxdXdm/fz9VqlTB398fKysrIiMjsbKyom3btiQlJdGvXz+tT2YARo8eTXJyMj/++CPLly/H1tYWtVrN7du3MTc3L9FWkhnxLNJDIwTPXovpf90oij9+2r59O/b29pw7d44333zzpcUqKqbp06ezdetWnJ2dyczM5ODBgwD4+PhgZ2fHw4cP2b17N8nJyejq6jJnzhzNDMAV6SafnZ1NcnIyy5cv59q1a5w8eVIeL4nnIgmNeO0VT1qKVvBVqVS0adMGeLpmpkjx95OSkkhKSuKjjz6SZEaUWkpKCn369MHf3x87OzsADh48yJo1azh//jz+/v5/Wlhe0ZIZRVE4dOgQvr6+5Ofns3PnTs2q9BXpPMXLob19lEL8A4rPgzFv3jwcHBwYPHgww4cPZ8GCBcDjoaVP5v3Fk5nVq1fj5OREp06dJJkRL0SlUvHLL7+UeK9r166MHTuWW7duMXHiROLj45/ar6Ld5FUqFTY2NixevJj4+Hj09PQoKCiocOcpXg5JaMRrrSgp8fT0JDg4mODgYJKSkujbty+enp5MmzZN064oqXlyBuD58+czb948mjdvXjYnIbRW0TVlbGyMlZUVycnJ5OTkaLb36NGDd955h7y8PKKiosoqzFdKX18fKysrdHR0NDMGC/E8JKERr529e/dy//59zeuUlBQSExPZsGEDnTp14vjx44SGhuLk5IS/vz8zZswAHic1RSsWw3+XMwgNDWXIkCFlci5Cuzy5ZlHRtfTGG2/w/vvv4+fnR1xcnCapuXfvHiYmJixevJiwsLBXHW6Z0+ZCZ/HqSeorXitfffUVU6dOxcfHh2HDhlGjRg3q1atHz549ad++PQkJCTg7O+Pl5YWzszOFhYX4+vpy//59QkJCNF3fQUFBuLm5sW7dOpkBWDyX4rVa69at49ixYxgYGNC6dWtGjRqFr68vd+7cYcaMGezYsYNGjRrx3XffUVhYyJAhQyrEaCYhXiYpChavHVdXV/bt28fUqVMZPHgwpqamPHr0iMqVKzN16lTu379PQEAAhoaGzJ8/n6SkJAoLC9m9ezc6Ojrs2bOHkSNHEhAQwMCBA8v6dISWcXNzY+PGjfTu3Ru1Ws2ePXsYPXo0ixYtAh7PGJycnExqaioNGjRg/fr16OnpSTIjxP8gCY14beTl5aGvrw+As7MzR48exdXVFXt7e2rUqEF+fj49evTA1NSUrVu38scff2Bvb8+AAQOwt7fXHOf69eukp6dr3arGouyFhYXh6enJpk2baNu2LZs3b2bUqFGoVCpcXFxYuXIl8Hj0UkFBgeZ6lZlxhfjf5BsiXguKomhuDuHh4TRq1Ijw8HAWL16MSqVi2LBh1KxZEycnJz799FN69uzJ7du3KSgo0NTHKIqCoijUr1+f+vXrl+XpCC2kVqvJyMhg9OjRtG3blp07d+Lq6sqSJUvIy8tj3rx5GBsbs2DBAnR1dTWPNxVFkWRGiOcgPTTitbJo0SJWrVrFmjVrKCgoIDo6muPHj7Nw4UIcHByoXLky27ZtIy4ujjp16rBs2TKZB0O8kD+bvyg3N5fMzEwMDQ3p0aMHjo6OTJ8+nR9++AFbW1t+//13Vq5cyeTJk8soaiG0lyQ0osJKSUnB0tJS8/ru3bt07doVV1dXxo0bp3l/1KhRxMbG4uXlxfDhw6levXqJegXp7helVfz6ycrKolq1aiXqXw4cOMDEiRM5cOAAderU4fTp03h7ezN06FB69uwpybMQL0AqzESFNGbMGDZu3FjivUqVKpXovn/48CEA69evp0mTJnz55ZesXbuWrKysEjcfSWZEaRVdP56engwaNIgPPviA/fv38+DBAwCqV6/OjRs3iIqK4ubNm8yaNQtFUejVqxe6uroUFhaWZfhCaCVJaESFZG9vz+LFiwHIyMgAoGbNmpibmxMeHg6AgYEB+fn5ADRs2JCsrCySk5MxMjIqm6BFhRIUFMTq1avp0qULhoaGODg4sH79eu7evUurVq2YOHEi8+bNo2PHjvzyyy+EhYVpJnCUHhohSk8eOYkKp3jtQkhICDExMcyZM4cOHTpw7tw5bG1tsbGxITo6WvNoYNiwYUyYMAEbGxt0dHSeuX6TEM/y5LBqPz8/TE1NNSPkZs6cyZYtW5g0aRIuLi5UqlSJS5cukZGRwUcffYSurq483hTib5BvjqhQiicimZmZNGvWjIyMDIKCgqhcuTJt2rQhJCQEZ2dnmjdvTtOmTUlPTycrK4t27dpppluX+T5EaRRfEyw6Opo7d+5w/PhxBg8erGnj7e0NPE50VCoVw4cP5+233+btt98GHg/VlmRGiBcnv9qiwiiezEyYMIFmzZrRsWNH3N3duXjxIitWrODkyZP06tVL89/69evTuXNnUlJSNLULksyI0ih+3c2cORNHR0dWrVpFZGQkX3/9Nenp6Zq23t7eDBs2jNmzZ3Pw4MESx5HHTEL8PfLngKgwim4qly9fJisrix07dgDQp08fFEVhyZIlfPHFF0yePJl27drh4+NTYn/p7hcvoui6O3XqFGlpaezbtw8rKyt8fHzYunUr/v7+TJw4kbp16wLg5eVFvXr1GDRoUFmGLUSFI7/eokKJiIhg8eLFGBsb07JlS/Lz89HT06Nv374ALF26FH9/f/Ly8ujcuXOJfSWZES8qKioKf39/qlevjpWVFfr6+sydOxeAbdu2oSgKkydPxtzcHHi8/AYg8xsJ8Q+SX3BRYSiKQm5uLsbGxly6dAkAPT09zTpNffv2RUdHh0mTJtG4ceOnEhohXtSNGze4f/8+V65c4bfffsPMzAyAuXPnolKpiImJ4cGDB3h6elKrVi3NfpLMCPHPkVFOQmv9WfFuYWEhsbGxzJo1i3r16rFt2zZMTEw0PTUAR44cwcbGRm4m4oU8q2g8LCyML774gpYtW+Lt7V1ieYxZs2Zx69Yt1q1bJ6PnhHhJJKERWqn4TWXv3r3cv38fRVH497//jZGREdu3b8fX1xcTExM2btyIsbGxpqemiHT3i9Iqft19++23ZGdnk5OTg4ODAwChoaGEhYVhYWGhqZUpUlQ8LFMCCPFySEIjtJqbmxsRERE0bdqUCxcu0LhxY+bOnYutrS2bN28mICAAExMT1q9fj6mpaVmHKyoINzc3IiMjsbCw4NKlS7z55pv4+PhgY2NDUFAQERERNGzYEHd3dxo0aKDZT5IZIV4eGZ8qtFZoaCgbN24kNjaW/fv3M3/+fI4cOUJBQQEqlYqhQ4cyceJELly4wLJly8o6XFFBBAcHEx4ezjfffENCQgK+vr4cO3aM33//HQAXFxdGjBjBiRMn2LBhQ4l9JZkR4uWRomChtS5cuMDAgQOxtrYmKioKNzc3Vq9eTc+ePcnJyUGtVjNo0CBMTEz48MMPyzpcUUFcunQJR0dH3n33XSIjIxk/fjxr1qyhe/fuZGdnU61aNT777DNq165Nnz59yjpcIV4b0kMjtMKTT0bVajXXr1+nYcOGnDx5kjFjxrBs2TLGjRuHWq0mNDSUrVu3oqOjQ7du3WTBP/FC1Gr1U6/Pnj1LjRo1SEpKYuzYsSWuOz8/P0JDQwHo16+fXHdCvEKS0Ihyr7CwUNNVf+XKFW7fvo2Ojg4DBgxgzpw5vPfee3z11Ve4uLgAkJubS1xcHFeuXClxHCkAFqVVVAB84cIFcnNz0dHRYcSIEQQGBvL++++zZs0azXWXk5NDQkICV69eLXEMue6EeDUkoRHlVmBgIMnJyZobwuzZs+nTpw+WlpbMnDkTQ0NDJk6cSJ06dTAzM+OPP/4gNTWVQYMGce/ePRYtWlS2JyAqhOjoaNq0aUNcXByPHj2iU6dOdOzYkSZNmlC7dm3g8ezUQ4YM4ddff2XhwoVlHLEQrycZ5STKpbS0ND744AN69uzJzJkzSUlJwdXVFX9/f06fPs2ePXuoX78+rVu35ubNmwQEBGBubo6xsTFGRkb85z//QU9PT4Zmi3/EJ598wpkzZ/D29mbAgAEcP36cL7/8kri4OExNTalZsyZGRkYcPHhQrjshyogkNKLcSk5OZsyYMXTq1AkdHR0sLS0ZPXo0ADt27GD16tUYGxszduxYzM3NSUlJoXbt2nzwwQfo6OjI2kyi1P5qWPXAgQP5/vvvWblyJQMGDCArK4sLFy5w6dIl6tevT4cOHdDV1ZXrTogyIgmNKNdOnjyJs7MzqampLFiwgM8//1yzbefOnXz55ZdUr14dNzc32rVrp9kmfyGLvyMgIABLS0tNclykf//+HDlyhMDAQOzs7KhatWqJ/eS6E6LsSA2NKNdat27NunXrMDY2Jj4+njNnzmi29e7dm2nTpnH58mW++eYb4L+joeSmIkrjyb/rgoODcXBw4Pjx4yVGOkVHR1O3bl08PDzYvn07jx49KrGfXHdClB1JaES517JlS6Kjo7l79y6rV6/m3Llzmm0ff/wxa9euxdPTE5CJy0TpFX/MFBERwebNmzl16hRNmjTB3t6eY8eOaYZeK4pC06ZNuXbtGnFxcSWW0hBClC1JaIRWaNWqFaGhoSQlJbFq1SpSUlI029q3by/zfYgXolarNcnM2bNn8fHxYfny5cTHx3PgwAEaNGjAiBEjSExMJDc3F5VKRZUqVUhMTCQyMrKMoxdCFCc1NEKrnDp1CmdnZywsLPD29qZhw4ZlHZKoAGbMmEFqairp6en8/PPPGBsbs3LlSvr27Uv37t25fPkyb731Fr///ju//fYbZ86cQVdX95krbwshXj0pxRdaxcrKCn9/f4KCgrCwsCjrcEQFsGHDBkJDQ9m/fz8WFhbk5eXh5OSEh4cHOjo6fPvttyxfvpy0tDR0dXVZtWqVJDNClEPSQyO0UlHdg9xUxN+1cOFCDhw4QEJCAiqVCpVKxc2bN+nfvz+3bt3Cx8eHgQMHAv8dxSRDs4Uof+ROILSSSqVCURRJZsQLK/pbztDQkLy8PPLy8lCpVOTn51O3bl2WLl3K7du38ff3Jzg4GECSGSHKMbkbCK0lI5rE31F0/fTu3Zvk5GS8vb0B0NPTAyAvL48ePXpgamrKxo0bCQsLA5BkRohySr6ZQojXWosWLQgODuazzz4jOzubwYMHY2JiQkBAAK1bt2bcuHF8/vnnrFixAj09Pezt7cs6ZCHEn5AaGiGEALZv346rq6tmbpnatWuTmJiIgYEB6enpzJ07l8WLF0sxuhDllCQ0Qgjx/2VkZHDz5k1ycnLo1KkTurq6PHz4EAMDA1nWQIhyThIaIYR4BklihNAektAIIYQQQuvJKCchhBBCaD1JaIQQQgih9SShEUIIIYTWk4RGCCGEEFpPEhohhBBCaD1JaIQQQgih9SShEUIIIYTWk4RGCFFhODk58cknn2hed+nShc8///yVx/Hdd9+hUqn47bffntlGpVIRGxv73MdctGgR77777t+K6+rVq6hUKpKTk//WcYQojyShEUK8VE5OTqhUKlQqFZUrV6Zx48YsXryYgoKCl/7Z0dHReHh4PFfb50lChBDll6y2LYR46ezs7Fi/fj15eXnEx8czfvx49PT0mD179lNtHz16pFkg8u8yMTH5R44jhCj/pIdGCPHS6evr88Ybb2BhYcG4ceOwtbVlx44dwH8fEy1ZsgRzc3OaNm0KwI0bNxg8eDA1a9bExMSEvn37cvXqVc0xCwsLmTp1KjVr1sTU1JSZM2fy5EouTz5yysvLw83NjXr16qGvr0/jxo0JDQ3l6tWrdO3aFQBjY2NUKhVOTk4AqNVqvLy8aNiwIYaGhrRq1Ypt27aV+Jz4+HiaNGmCoaEhXbt2LRHn83Jzc6NJkyZUqVKFRo0aMX/+fPLz859qt3btWurVq0eVKlUYPHgwDx48KLE9JCSE5s2bY2BgQLNmzQgICCh1LEJoI0lohBCvnKGhIY8ePdK8PnDgABcvXmTfvn3ExcWRn59Pjx49MDIy4vDhwxw9epRq1aphZ2en2c/X15ewsDDWrVvHkSNHuHfvHjExMX/5uSNHjmTz5s34+flx/vx51q5dS7Vq1ahXrx7bt28H4OLFi2RmZrJq1SoAvLy82LBhA0FBQZw7d44pU6YwYsQIDh06BDxOvPr370/v3r1JTk5mzJgxzJo1q9T/T4yMjAgLCyMlJYVVq1YRHBzMypUrS7S5fPkyW7ZsYefOnezZs4dTp07h6uqq2b5p0yYWLFjAkiVLOH/+PEuXLmX+/PmEh4eXOh4htI4ihBAvkaOjo9K3b19FURRFrVYr+/btU/T19ZXp06drtpuZmSl5eXmafTZu3Kg0bdpUUavVmvfy8vIUQ0NDZe/evYqiKEqdOnUUb29vzfb8/Hzl//7v/zSfpSiK0rlzZ2Xy5MmKoijKxYsXFUDZt2/fn8Z58OBBBVDu37+vee/hw4dKlSpVlMTExBJtR48erQwbNkxRFEWZPXu2YmlpWWK7m5vbU8d6EqDExMQ8c/sXX3yhWFtba14vXLhQ0dXVVdLT0zXv7d69W9HR0VEyMzMVRVGUN998U4mIiChxHA8PD8XGxkZRFEVJS0tTAOXUqVPP/FwhtJXU0AghXrq4uDiqVatGfn4+arWa4cOHs2jRIs32li1blqib+emnn7h8+TJGRkYljvPw4UNSU1N58OABmZmZtG3bVrOtUqVKvPfee089diqSnJyMrq4unTt3fu64L1++TG5uLt26dSvx/qNHj7CysgLg/PnzJeIAsLGxee7PKBIVFYWfnx+pqalkZ2dTUFBA9erVS7SpX78+devWLfE5arWaixcvYmRkRGpqKqNHj2bs2LGaNgUFBdSoUaPU8QihbSShEUK8dF27diUwMJDKlStjbm5OpUolf3qqVq1a4nV2djbW1tZs2rTpqWPVrl37hWIwNDQs9T7Z2dkA7Nq1q0QiAY/rgv4px44dw97eHnd3d3r06EGNGjWIjIzE19e31LEGBwc/lWDp6ur+Y7EKUV5JQiOEeOmqVq1K48aNn7t969atiYqK4l//+tdTvRRF6tSpw4kTJ/jggw+Axz0RSUlJtG7d+k/bt2zZErVazaFDh7C1tX1qe1EPUWFhoeY9S0tL9PX1uX79+jN7dpo3b64pcC5y/Pjx/32SxSQmJmJhYcHcuXM17127du2pdtevXycjIwNzc3PN5+jo6NC0aVPMzMwwNzfnypUr2Nvbl+rzhagIpChYCFHu2NvbU6tWLfr27cvhw4dJS0vju+++Y9KkSaSnpwMwefJkli1bRmxsLBcuXMDV1fUv55Bp0KABjo6OfPrpp8TGxmqOuWXLFgAsLCxQqVTExcVx584dsrOzMTIyYvr06UyZMoXw8HBSU1M5efIkq1ev1hTauri48PPPPzNjxgwuXrxIREQEYWFhpTrft956i+vXrxMZGUlqaip+fn5/WuBsYGCAo6MjP/30E4cPH2bSpEkMHjyYN954AwB3d3e8vLzw8/Pj0qVLnDlzhvXr17NixYpSxSOENpKERghR7lSpUoWEhATq169P//79ad68OaNHj+bhw4eaHptp06bh4OCAo6MjNjY2GBkZ0a9fv788bmBgIAMHDsTV1ZVmzZoxduxYcnJyAKhbty7u7u7MmjULMzMzJkyYAICHhwfz58/Hy8uL5s2bY2dnx65du2jYsCHwuK5l+/btxMbG0qpVK4KCgli6dGmpzrdPnz5MmTKFCRMm8O6775KYmMj8+fOfate4cWP69+/Pxx9/TPfu3XnnnXdKDMseM2YMISEhrF+/npYtW9K5c2fCwsI0sQpRkamUZ1XQCSGEEEJoCemhEUIIIYTWk4RGCCGEEFpPEhohhBBCaD1JaIQQQgih9SShEUIIIYTWk4RGCCGEEFpPEhohhBBCaD1JaIQQQgih9SShEUIIIYTWk4RGCCGEEFpPEhohhBBCaL3/ByhfpWHo5FpjAAAAAElFTkSuQmCC",
      "text/plain": [
       "<Figure size 640x480 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "cm_plot_labels = ['herida_y_picadura', 'podrida', 'quemadura_y_otros', 'sanas_1000']\n",
    "cm = confusion_matrix(y_true=y_t,y_pred=y_p)                                             # se muestra dicha matriz de confusion normalizada\n",
    "plot_confusion_matrix(cm=cm, classes=cm_plot_labels,normalize = True ,title=\"Confusion Matrix Normalized\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "d0c7d415-9e5a-46eb-8e49-956c94cb51dd",
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "Cannot serialize object Ellipsis of type <class 'ellipsis'>. To be serializable, a class must implement the `get_config()` method.",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "Cell \u001b[0;32mIn[20], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[43mmodel\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43msave\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43mResNet101_opti_with_fine_tuning.keras\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m)\u001b[49m\n",
      "File \u001b[0;32m~/.conda/envs/apple/lib/python3.10/site-packages/keras/src/utils/traceback_utils.py:70\u001b[0m, in \u001b[0;36mfilter_traceback.<locals>.error_handler\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m     67\u001b[0m     filtered_tb \u001b[38;5;241m=\u001b[39m _process_traceback_frames(e\u001b[38;5;241m.\u001b[39m__traceback__)\n\u001b[1;32m     68\u001b[0m     \u001b[38;5;66;03m# To get the full stack trace, call:\u001b[39;00m\n\u001b[1;32m     69\u001b[0m     \u001b[38;5;66;03m# `tf.debugging.disable_traceback_filtering()`\u001b[39;00m\n\u001b[0;32m---> 70\u001b[0m     \u001b[38;5;28;01mraise\u001b[39;00m e\u001b[38;5;241m.\u001b[39mwith_traceback(filtered_tb) \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[1;32m     71\u001b[0m \u001b[38;5;28;01mfinally\u001b[39;00m:\n\u001b[1;32m     72\u001b[0m     \u001b[38;5;28;01mdel\u001b[39;00m filtered_tb\n",
      "File \u001b[0;32m~/.conda/envs/apple/lib/python3.10/site-packages/keras/src/saving/serialization_lib.py:395\u001b[0m, in \u001b[0;36m_get_class_or_fn_config\u001b[0;34m(obj)\u001b[0m\n\u001b[1;32m    393\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m object_registration\u001b[38;5;241m.\u001b[39mget_registered_name(obj)\n\u001b[1;32m    394\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m--> 395\u001b[0m     \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mTypeError\u001b[39;00m(\n\u001b[1;32m    396\u001b[0m         \u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mCannot serialize object \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mobj\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m of type \u001b[39m\u001b[38;5;132;01m{\u001b[39;00m\u001b[38;5;28mtype\u001b[39m(obj)\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m. \u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m    397\u001b[0m         \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mTo be serializable, \u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m    398\u001b[0m         \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124ma class must implement the `get_config()` method.\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m    399\u001b[0m     )\n",
      "\u001b[0;31mTypeError\u001b[0m: Cannot serialize object Ellipsis of type <class 'ellipsis'>. To be serializable, a class must implement the `get_config()` method."
     ]
    }
   ],
   "source": [
    "model.save('ResNet101_opti_with_fine_tuning.h5')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8dc2be21-02ba-4aca-80d0-c7b57175d3ba",
   "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.8.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}