Speaker_Identification_Recognition.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "gpuType": "T4",
      "authorship_tag": "ABX9TyPe6aBcjQNCpN6VXOIeoSCj",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    },
    "accelerator": "GPU"
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/rahulzach/FFT/blob/main/Speaker_Identification_Recognition.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "d8o9DuZKJLvX"
      },
      "outputs": [],
      "source": [
        "import os\n",
        "import sys\n",
        "from tempfile import NamedTemporaryFile\n",
        "from urllib.request import urlopen\n",
        "from urllib.parse import unquote, urlparse\n",
        "from urllib.error import HTTPError\n",
        "from zipfile import ZipFile\n",
        "import tarfile\n",
        "import shutil\n",
        "import tensorflow as tf\n",
        "import os\n",
        "from os.path import isfile, join\n",
        "import numpy as np\n",
        "import shutil\n",
        "from tensorflow import keras\n",
        "from pathlib import Path\n",
        "from IPython.display import display, Audio\n",
        "import subprocess\n",
        "from tensorflow.keras.layers import Conv1D\n",
        "import matplotlib.pyplot as plt\n",
        "import numpy as np\n",
        "from sklearn.metrics import confusion_matrix\n"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "CHUNK_SIZE = 40960\n",
        "DATA_SOURCE_MAPPING = 'speaker-recognition-dataset:https%3A%2F%2Fstorage.googleapis.com%2Fkaggle-data-sets%2F470244%2F881667%2Fbundle%2Farchive.zip%3FX-Goog-Algorithm%3DGOOG4-RSA-SHA256%26X-Goog-Credential%3Dgcp-kaggle-com%2540kaggle-161607.iam.gserviceaccount.com%252F20240213%252Fauto%252Fstorage%252Fgoog4_request%26X-Goog-Date%3D20240213T170642Z%26X-Goog-Expires%3D259200%26X-Goog-SignedHeaders%3Dhost%26X-Goog-Signature%3D5726f82e0d9666a57598257ea7db777f479ca136bbea25424b365edc397adb06d2576b7afb9d2a5ef8ecacf289dcd23c914bed457b0961bc34af55f27ac22b8bd8157fdd727d5b5d751e6d04880053d2c59e15817af360dbd9babde179e1d15b7b6c6034ec5ab30594d2cec49a6f6d5d90d992e8bdc4d772a0e6561eaa4788914d60a5162bfc5f86c98c398069ebbf8d1ee5c8f1ec47c047c2f78cd8a0ca0e6a73cc7c8ee0cf541faa355306f939312399af63ea14f7ea6c40d45397ad2ac9bef1664cae8a97eb172ee569c3132861e3f639edb463e835ef8cbcfb11d0e7766b64c274c61c8579c2ab3803863d0117addea246b86ff87ed71753df3a36cef4ae'\n",
        "\n",
        "KAGGLE_INPUT_PATH='/kaggle/input'\n",
        "KAGGLE_WORKING_PATH='/kaggle/working'\n",
        "KAGGLE_SYMLINK='kaggle'\n",
        "\n",
        "!umount /kaggle/input/ 2> /dev/null\n",
        "shutil.rmtree('/kaggle/input', ignore_errors=True)\n",
        "os.makedirs(KAGGLE_INPUT_PATH, 0o777, exist_ok=True)\n",
        "os.makedirs(KAGGLE_WORKING_PATH, 0o777, exist_ok=True)\n",
        "\n",
        "try:\n",
        "  os.symlink(KAGGLE_INPUT_PATH, os.path.join(\"..\", 'input'), target_is_directory=True)\n",
        "except FileExistsError:\n",
        "  pass\n",
        "try:\n",
        "  os.symlink(KAGGLE_WORKING_PATH, os.path.join(\"..\", 'working'), target_is_directory=True)\n",
        "except FileExistsError:\n",
        "  pass\n",
        "\n",
        "for data_source_mapping in DATA_SOURCE_MAPPING.split(','):\n",
        "    directory, download_url_encoded = data_source_mapping.split(':')\n",
        "    download_url = unquote(download_url_encoded)\n",
        "    filename = urlparse(download_url).path\n",
        "    destination_path = os.path.join(KAGGLE_INPUT_PATH, directory)\n",
        "    try:\n",
        "        with urlopen(download_url) as fileres, NamedTemporaryFile() as tfile:\n",
        "            total_length = fileres.headers['content-length']\n",
        "            print(f'Downloading {directory}, {total_length} bytes compressed')\n",
        "            dl = 0\n",
        "            data = fileres.read(CHUNK_SIZE)\n",
        "            while len(data) > 0:\n",
        "                dl += len(data)\n",
        "                tfile.write(data)\n",
        "                done = int(50 * dl / int(total_length))\n",
        "                sys.stdout.write(f\"\\r[{'=' * done}{' ' * (50-done)}] {dl} bytes downloaded\")\n",
        "                sys.stdout.flush()\n",
        "                data = fileres.read(CHUNK_SIZE)\n",
        "            if filename.endswith('.zip'):\n",
        "              with ZipFile(tfile) as zfile:\n",
        "                zfile.extractall(destination_path)\n",
        "            else:\n",
        "              with tarfile.open(tfile.name) as tarfile:\n",
        "                tarfile.extractall(destination_path)\n",
        "            print(f'\\nDownloaded and uncompressed: {directory}')\n",
        "    except HTTPError as e:h\n",
        "        print(f'Failed to load (likely expired) {download_url} to path {destination_path}')\n",
        "        continue\n",
        "    except OSError as e:\n",
        "        print(f'Failed to load {download_url} to path {destination_path}')\n",
        "        continue\n",
        "\n",
        "print('Data source import complete.')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "WXH0AjYuJZle",
        "outputId": "21fe71e3-b16a-4b1d-dc1e-dab5ac35df51"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Downloading speaker-recognition-dataset, 241803761 bytes compressed\n",
            "[==================================================] 241803761 bytes downloaded\n",
            "Downloaded and uncompressed: speaker-recognition-dataset\n",
            "Data source import complete.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "!cp -r \"../input/speaker-recognition-dataset\" ./"
      ],
      "metadata": {
        "id": "8hdZIAFbJqNx"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "data_directory = \"./speaker-recognition-dataset/16000_pcm_speeches\"\n",
        "audio_folder = \"audio\"\n",
        "noise_folder = \"noise\"\n",
        "\n",
        "audio_path = os.path.join(data_directory, audio_folder)\n",
        "noise_path = os.path.join(data_directory, noise_folder)"
      ],
      "metadata": {
        "id": "ERyI2s6EJzXp"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "audio_path"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "id": "65HaoTyQJ5Wv",
        "outputId": "bdb4cfd2-2398-4c01-9d81-0b852828e64c"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'./speaker-recognition-dataset/16000_pcm_speeches/audio'"
            ],
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            }
          },
          "metadata": {},
          "execution_count": 5
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "valid_split = 0.1\n",
        "shuffle_seed = 43\n",
        "sample_rate = 16000\n",
        "scale = 0.5\n",
        "batch_size = 128\n",
        "epochs = 15"
      ],
      "metadata": {
        "id": "bQKsMujeJ6TI"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "for folder in os.listdir(data_directory):\n",
        "    if os.path.isdir(os.path.join(data_directory, folder)):\n",
        "        if folder in [audio_folder, noise_folder]:\n",
        "\n",
        "            continue\n",
        "        elif folder in [\"other\", \"_background_noise_\"]:\n",
        "\n",
        "            shutil.move(\n",
        "                os.path.join(data_directory, folder),\n",
        "                os.path.join(noise_path, folder),\n",
        "            )\n",
        "        else:\n",
        "            shutil.move(\n",
        "                os.path.join(data_directory, folder),\n",
        "                os.path.join(audio_path, folder),\n",
        "            )"
      ],
      "metadata": {
        "id": "7VUKhsFaJ9TX"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "noise_paths = []\n",
        "for subdir in os.listdir(noise_path):\n",
        "    subdir_path = Path(noise_path) / subdir\n",
        "    if os.path.isdir(subdir_path):\n",
        "        noise_paths += [\n",
        "            os.path.join(subdir_path, filepath)\n",
        "            for filepath in os.listdir(subdir_path)\n",
        "            if filepath.endswith(\".wav\")\n",
        "        ]"
      ],
      "metadata": {
        "id": "bO8XTt1EKXVl"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "noise_paths"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "kwUVt6tIKaiz",
        "outputId": "afad6606-0328-4e1c-c893-3cede32e1500"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['speaker-recognition-dataset/16000_pcm_speeches/noise/_background_noise_/10convert.com_Audience-Claps_daSG5fwdA7o.wav',\n",
              " 'speaker-recognition-dataset/16000_pcm_speeches/noise/_background_noise_/running_tap.wav',\n",
              " 'speaker-recognition-dataset/16000_pcm_speeches/noise/_background_noise_/doing_the_dishes.wav',\n",
              " 'speaker-recognition-dataset/16000_pcm_speeches/noise/_background_noise_/dude_miaowing.wav',\n",
              " 'speaker-recognition-dataset/16000_pcm_speeches/noise/other/exercise_bike.wav',\n",
              " 'speaker-recognition-dataset/16000_pcm_speeches/noise/other/pink_noise.wav']"
            ]
          },
          "metadata": {},
          "execution_count": 9
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "command = (\n",
        "    \"for dir in `ls -1 \" + noise_path + \"`; do \"\n",
        "    \"for file in `ls -1 \" + noise_path + \"/$dir/*.wav`; do \"\n",
        "    \"sample_rate=`ffprobe -hide_banner -loglevel panic -show_streams \"\n",
        "    \"$file | grep sample_rate | cut -f2 -d=`; \"\n",
        "    \"if [ $sample_rate -ne 16000 ]; then \"\n",
        "    \"ffmpeg -hide_banner -loglevel panic -y \"\n",
        "    \"-i $file -ar 16000 temp.wav; \"\n",
        "    \"mv temp.wav $file; \"\n",
        "    \"fi; done; done\"\n",
        ")"
      ],
      "metadata": {
        "id": "j2GV3t5sKbU3"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "os.system(command)\n",
        "def load_noise_sample(path):\n",
        "    sample, sampling_rate = tf.audio.decode_wav(\n",
        "        tf.io.read_file(path), desired_channels=1\n",
        "    )\n",
        "    if sampling_rate == sample_rate:\n",
        "        slices = int(sample.shape[0] / sample_rate)\n",
        "        sample = tf.split(sample[: slices * sample_rate], slices)\n",
        "        return sample\n",
        "    else:\n",
        "        print(\"Sampling rate for\",path, \"is incorrect\")\n",
        "        return None\n",
        "\n",
        "\n",
        "noises = []\n",
        "for path in noise_paths:\n",
        "    sample = load_noise_sample(path)\n",
        "    if sample:\n",
        "        noises.extend(sample)\n",
        "noises = tf.stack(noises)"
      ],
      "metadata": {
        "id": "9sLlBHs8Kd1-"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def paths_and_labels_to_dataset(audio_paths, labels):\n",
        "    path_ds = tf.data.Dataset.from_tensor_slices(audio_paths)\n",
        "    audio_ds = path_ds.map(lambda x: path_to_audio(x))\n",
        "    label_ds = tf.data.Dataset.from_tensor_slices(labels)\n",
        "    return tf.data.Dataset.zip((audio_ds, label_ds))"
      ],
      "metadata": {
        "id": "aaEyZ6BzKfgU"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def path_to_audio(path):\n",
        "    audio = tf.io.read_file(path)\n",
        "    audio, _ = tf.audio.decode_wav(audio, 1, sample_rate)\n",
        "    return audio"
      ],
      "metadata": {
        "id": "6fMgDo6aKhEJ"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def add_noise(audio, noises=None, scale=0.5):\n",
        "    if noises is not None:\n",
        "        tf_rnd = tf.random.uniform(\n",
        "            (tf.shape(audio)[0],), 0, noises.shape[0], dtype=tf.int32\n",
        "        )\n",
        "        noise = tf.gather(noises, tf_rnd, axis=0)\n",
        "\n",
        "        prop = tf.math.reduce_max(audio, axis=1) / tf.math.reduce_max(noise, axis=1)\n",
        "        prop = tf.repeat(tf.expand_dims(prop, axis=1), tf.shape(audio)[1], axis=1)\n",
        "\n",
        "        audio = audio + noise * prop * scale\n",
        "\n",
        "    return audio"
      ],
      "metadata": {
        "id": "AJ6i3-uVKjud"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def audio_to_fft(audio):\n",
        "    audio = tf.squeeze(audio, axis=-1)\n",
        "    fft = tf.signal.fft(\n",
        "        tf.cast(tf.complex(real=audio, imag=tf.zeros_like(audio)), tf.complex64)\n",
        "    )\n",
        "    fft = tf.expand_dims(fft, axis=-1)\n",
        "\n",
        "    return tf.math.abs(fft[:, : (audio.shape[1] // 2), :])"
      ],
      "metadata": {
        "id": "KzxoWbqdKmHN"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "class_names = os.listdir(audio_path)\n",
        "print(class_names,)\n",
        "\n",
        "audio_paths = []\n",
        "labels = []\n",
        "for label, name in enumerate(class_names):\n",
        "    print(\"Speaker:\",(name))\n",
        "    dir_path = Path(audio_path) / name\n",
        "    speaker_sample_paths = [\n",
        "        os.path.join(dir_path, filepath)\n",
        "        for filepath in os.listdir(dir_path)\n",
        "        if filepath.endswith(\".wav\")\n",
        "    ]\n",
        "    audio_paths += speaker_sample_paths\n",
        "    labels += [label] * len(speaker_sample_paths)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "w8dZSIY4Kn5G",
        "outputId": "09533ca6-ceb2-4ca3-c1e7-9cc5661d2c2e"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "['Benjamin_Netanyau', 'Nelson_Mandela', 'Jens_Stoltenberg', 'Julia_Gillard', 'Magaret_Tarcher']\n",
            "Speaker: Benjamin_Netanyau\n",
            "Speaker: Nelson_Mandela\n",
            "Speaker: Jens_Stoltenberg\n",
            "Speaker: Julia_Gillard\n",
            "Speaker: Magaret_Tarcher\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Shuffle to generate random data\n",
        "rng = np.random.RandomState(shuffle_seed)\n",
        "rng.shuffle(audio_paths)\n",
        "rng = np.random.RandomState(shuffle_seed)\n",
        "rng.shuffle(labels)"
      ],
      "metadata": {
        "id": "gWh699WrKp4l"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Split into training and validation\n",
        "num_val_samples = int(valid_split * len(audio_paths))\n",
        "train_audio_paths = audio_paths[:-num_val_samples]\n",
        "train_labels = labels[:-num_val_samples]\n",
        "\n",
        "\n",
        "valid_audio_paths = audio_paths[-num_val_samples:]\n",
        "valid_labels = labels[-num_val_samples:]"
      ],
      "metadata": {
        "id": "sIyh0jynKrmv"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Create datasets, one for training and the other for validation\n",
        "train_ds = paths_and_labels_to_dataset(train_audio_paths, train_labels)\n",
        "train_ds = train_ds.shuffle(buffer_size=batch_size * 8, seed=shuffle_seed).batch(\n",
        "    batch_size\n",
        ")\n",
        "\n",
        "valid_ds = paths_and_labels_to_dataset(valid_audio_paths, valid_labels)\n",
        "valid_ds = valid_ds.shuffle(buffer_size=32 * 8, seed=shuffle_seed).batch(32)"
      ],
      "metadata": {
        "id": "JdjXpZ8nKtAd"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Add noise to the training set\n",
        "train_ds = train_ds.map(\n",
        "    lambda x, y: (add_noise(x, noises, scale=scale), y),\n",
        "    num_parallel_calls=tf.data.experimental.AUTOTUNE,\n",
        ")\n",
        "\n",
        "# Transform audio wave to the frequency domain using `audio_to_fft`\n",
        "train_ds = train_ds.map(\n",
        "    lambda x, y: (audio_to_fft(x), y), num_parallel_calls=tf.data.experimental.AUTOTUNE\n",
        ")\n",
        "\n",
        "train_ds = train_ds.prefetch(tf.data.experimental.AUTOTUNE)\n",
        "\n",
        "valid_ds = valid_ds.map(\n",
        "    lambda x, y: (audio_to_fft(x), y), num_parallel_calls=tf.data.experimental.AUTOTUNE\n",
        ")\n",
        "valid_ds = valid_ds.prefetch(tf.data.experimental.AUTOTUNE)"
      ],
      "metadata": {
        "id": "CEAgkSInKxlt"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def residual_block(x, filters, conv_num = 3, activation = \"relu\"):\n",
        "    s = keras.layers.Conv1D(filters, 1, padding = \"same\")(x)\n",
        "\n",
        "    for i in range(conv_num - 1):\n",
        "        x = keras.layers.Conv1D(filters, 3, padding = \"same\")(x)\n",
        "        x = keras.layers.Activation(activation)(x)\n",
        "\n",
        "    x = keras.layers.Conv1D(filters, 3, padding = \"same\")(x)\n",
        "    x = keras.layers.Add()([x, s])\n",
        "    x = keras.layers.Activation(activation)(x)\n",
        "\n",
        "    return keras.layers.MaxPool1D(pool_size = 2, strides = 2)(x)\n",
        "\n",
        "def build_model(input_shape, num_classes):\n",
        "    inputs = keras.layers.Input(shape = input_shape, name = \"input\")\n",
        "\n",
        "    x = residual_block(inputs, 16, 2)\n",
        "    x = residual_block(inputs, 32, 2)\n",
        "    x = residual_block(inputs, 64, 3)\n",
        "    x = residual_block(inputs, 128, 3)\n",
        "    x = residual_block(inputs, 128, 3)\n",
        "    x = keras.layers.AveragePooling1D(pool_size=3, strides=3)(x)\n",
        "    x = keras.layers.Flatten()(x)\n",
        "    x = keras.layers.Dense(256, activation=\"relu\")(x)\n",
        "    x = keras.layers.Dense(128, activation=\"relu\")(x)\n",
        "\n",
        "    outputs = keras.layers.Dense(num_classes, activation = \"softmax\", name = \"output\")(x)\n",
        "\n",
        "    return keras.models.Model(inputs = inputs, outputs = outputs)\n",
        "\n",
        "model = build_model((sample_rate // 2, 1), len(class_names))\n",
        "\n",
        "model.summary()\n",
        "\n",
        "model.compile(optimizer=\"Adam\", loss=\"sparse_categorical_crossentropy\", metrics=[\"accuracy\"])\n",
        "\n",
        "model_save_filename = \"model.h5\"\n",
        "\n",
        "earlystopping_cb = keras.callbacks.EarlyStopping(patience=10, restore_best_weights=True)\n",
        "\n",
        "mdlcheckpoint_cb = keras.callbacks.ModelCheckpoint(model_save_filename, monitor=\"val_accuracy\", save_best_only=True)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "7qSCnjxYKzt3",
        "outputId": "3faeda34-503a-43e1-8d69-388f94244c11"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Model: \"model\"\n",
            "__________________________________________________________________________________________________\n",
            " Layer (type)                Output Shape                 Param #   Connected to                  \n",
            "==================================================================================================\n",
            " input (InputLayer)          [(None, 8000, 1)]            0         []                            \n",
            "                                                                                                  \n",
            " conv1d_15 (Conv1D)          (None, 8000, 128)            512       ['input[0][0]']               \n",
            "                                                                                                  \n",
            " activation_10 (Activation)  (None, 8000, 128)            0         ['conv1d_15[0][0]']           \n",
            "                                                                                                  \n",
            " conv1d_16 (Conv1D)          (None, 8000, 128)            49280     ['activation_10[0][0]']       \n",
            "                                                                                                  \n",
            " activation_11 (Activation)  (None, 8000, 128)            0         ['conv1d_16[0][0]']           \n",
            "                                                                                                  \n",
            " conv1d_17 (Conv1D)          (None, 8000, 128)            49280     ['activation_11[0][0]']       \n",
            "                                                                                                  \n",
            " conv1d_14 (Conv1D)          (None, 8000, 128)            256       ['input[0][0]']               \n",
            "                                                                                                  \n",
            " add_4 (Add)                 (None, 8000, 128)            0         ['conv1d_17[0][0]',           \n",
            "                                                                     'conv1d_14[0][0]']           \n",
            "                                                                                                  \n",
            " activation_12 (Activation)  (None, 8000, 128)            0         ['add_4[0][0]']               \n",
            "                                                                                                  \n",
            " max_pooling1d_4 (MaxPoolin  (None, 4000, 128)            0         ['activation_12[0][0]']       \n",
            " g1D)                                                                                             \n",
            "                                                                                                  \n",
            " average_pooling1d (Average  (None, 1333, 128)            0         ['max_pooling1d_4[0][0]']     \n",
            " Pooling1D)                                                                                       \n",
            "                                                                                                  \n",
            " flatten (Flatten)           (None, 170624)               0         ['average_pooling1d[0][0]']   \n",
            "                                                                                                  \n",
            " dense (Dense)               (None, 256)                  4368000   ['flatten[0][0]']             \n",
            "                                                          0                                       \n",
            "                                                                                                  \n",
            " dense_1 (Dense)             (None, 128)                  32896     ['dense[0][0]']               \n",
            "                                                                                                  \n",
            " output (Dense)              (None, 5)                    645       ['dense_1[0][0]']             \n",
            "                                                                                                  \n",
            "==================================================================================================\n",
            "Total params: 43812869 (167.13 MB)\n",
            "Trainable params: 43812869 (167.13 MB)\n",
            "Non-trainable params: 0 (0.00 Byte)\n",
            "__________________________________________________________________________________________________\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "history = model.fit(\n",
        "    train_ds,\n",
        "    epochs=epochs,\n",
        "    validation_data=valid_ds,\n",
        "    callbacks=[earlystopping_cb, mdlcheckpoint_cb],\n",
        ")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Qqb-taKVK6Tg",
        "outputId": "1dbd677a-2a24-4762-96a7-fff378d6235c"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch 1/15\n",
            "53/53 [==============================] - ETA: 0s - loss: 17.9802 - accuracy: 0.5501"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.10/dist-packages/keras/src/engine/training.py:3103: UserWarning: You are saving your model as an HDF5 file via `model.save()`. This file format is considered legacy. We recommend using instead the native Keras format, e.g. `model.save('my_model.keras')`.\n",
            "  saving_api.save_model(\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r53/53 [==============================] - 36s 524ms/step - loss: 17.9802 - accuracy: 0.5501 - val_loss: 0.4457 - val_accuracy: 0.8653\n",
            "Epoch 2/15\n",
            "53/53 [==============================] - 25s 468ms/step - loss: 0.2614 - accuracy: 0.9107 - val_loss: 0.1692 - val_accuracy: 0.9333\n",
            "Epoch 3/15\n",
            "53/53 [==============================] - 27s 505ms/step - loss: 0.1346 - accuracy: 0.9492 - val_loss: 0.1321 - val_accuracy: 0.9547\n",
            "Epoch 4/15\n",
            "53/53 [==============================] - 27s 500ms/step - loss: 0.1005 - accuracy: 0.9639 - val_loss: 0.0699 - val_accuracy: 0.9787\n",
            "Epoch 5/15\n",
            "53/53 [==============================] - 21s 385ms/step - loss: 0.0835 - accuracy: 0.9699 - val_loss: 0.0728 - val_accuracy: 0.9787\n",
            "Epoch 6/15\n",
            "53/53 [==============================] - 27s 499ms/step - loss: 0.0662 - accuracy: 0.9748 - val_loss: 0.0603 - val_accuracy: 0.9813\n",
            "Epoch 7/15\n",
            "53/53 [==============================] - 25s 472ms/step - loss: 0.0901 - accuracy: 0.9658 - val_loss: 0.0553 - val_accuracy: 0.9867\n",
            "Epoch 8/15\n",
            "53/53 [==============================] - 20s 380ms/step - loss: 0.0503 - accuracy: 0.9836 - val_loss: 0.0583 - val_accuracy: 0.9787\n",
            "Epoch 9/15\n",
            "53/53 [==============================] - 21s 386ms/step - loss: 0.0533 - accuracy: 0.9816 - val_loss: 0.0567 - val_accuracy: 0.9867\n",
            "Epoch 10/15\n",
            "53/53 [==============================] - 21s 391ms/step - loss: 0.0568 - accuracy: 0.9784 - val_loss: 0.0570 - val_accuracy: 0.9853\n",
            "Epoch 11/15\n",
            "53/53 [==============================] - 24s 443ms/step - loss: 0.0460 - accuracy: 0.9824 - val_loss: 0.0502 - val_accuracy: 0.9907\n",
            "Epoch 12/15\n",
            "53/53 [==============================] - 21s 394ms/step - loss: 0.0710 - accuracy: 0.9769 - val_loss: 0.0462 - val_accuracy: 0.9893\n",
            "Epoch 13/15\n",
            "53/53 [==============================] - 21s 386ms/step - loss: 0.0532 - accuracy: 0.9840 - val_loss: 0.0375 - val_accuracy: 0.9867\n",
            "Epoch 14/15\n",
            "53/53 [==============================] - 21s 382ms/step - loss: 0.0392 - accuracy: 0.9847 - val_loss: 0.0495 - val_accuracy: 0.9880\n",
            "Epoch 15/15\n",
            "53/53 [==============================] - 21s 387ms/step - loss: 0.0318 - accuracy: 0.9887 - val_loss: 0.0354 - val_accuracy: 0.9907\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "print(\"Accuracy of model:\",model.evaluate(valid_ds))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "YVJloH4pLAIJ",
        "outputId": "4b545e59-636a-49b0-f0da-d98ecdc16b91"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "24/24 [==============================] - 1s 38ms/step - loss: 0.0354 - accuracy: 0.9907\n",
            "Accuracy of model: [0.035441067069768906, 0.9906666874885559]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "\n",
        "import matplotlib.pyplot as plt\n",
        "\n",
        "# Get the accuracy and loss values from the history object\n",
        "acc = history.history['accuracy']\n",
        "loss = history.history['loss']\n",
        "val_acc = history.history['val_accuracy']\n",
        "val_loss = history.history['val_loss']\n",
        "\n",
        "# Create a figure with two subplots\n",
        "fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(10, 5))\n",
        "\n",
        "# Plot the accuracy and validation accuracy on the first subplot\n",
        "ax1.plot(acc, color='red', label='Accuracy')\n",
        "ax1.plot(val_acc, color='blue', label='Validation Accuracy')\n",
        "ax1.set_xlabel('Epoch')\n",
        "ax1.set_ylabel('Accuracy')\n",
        "ax1.legend()\n",
        "\n",
        "# Plot the loss and validation loss on the second subplot\n",
        "ax2.plot(loss, color='red', label='Loss')\n",
        "ax2.plot(val_loss, color='blue', label='Validation Loss')\n",
        "ax2.set_xlabel('Epoch')\n",
        "ax2.set_ylabel('Loss')\n",
        "ax2.legend()\n",
        "\n",
        "# Show the figure\n",
        "plt.show()\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 455
        },
        "id": "GIUATkaVM8DM",
        "outputId": "c8b971bf-ad6e-469c-c4c7-36325b3211a3"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 1000x500 with 2 Axes>"
            ],
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAA04AAAHACAYAAACVhTgAAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAAB/eElEQVR4nO3dd3wT9f8H8FeStumgi9GFpS17F2SJqIBUyxApIGB/QMv+ghTBimJlO6iiDBGELwoUvooMBURBoFSG7FGLIENGpYwOhm3aAh3J/f44kjY0HWmTXNO+no/HPXK53F3eCSWXVz6f+5xMEAQBREREREREVCy51AUQERERERFVdgxOREREREREpWBwIiIiIiIiKgWDExERERERUSkYnIiIiIiIiErB4ERERERERFQKBiciIiIiIqJSMDgRERERERGVwkbqAixNo9Hg9u3bcHZ2hkwmk7ocIqJqRRAEZGZmwsfHB3I5f7vT4rGJiEgaxhyXql1wun37Nnx9faUug4ioWrtx4waeeuopqcuoNHhsIiKSVlmOS9UuODk7OwMQ3xwXFxeJqyEiql5UKhV8fX11n8Uk4rGJiEgaxhyXql1w0naBcHFx4cGJiEgi7I6mj8cmIiJpleW4xA7mREREREREpWBwIiIiIiIiKgWDExERERERUSkkPcfp4MGD+Oyzz3D69GkkJydj69atCAkJKXGb/fv3IzIyEn/99Rd8fX0xY8YMjBgxwiL1EhEREZF5CIKA/Px8qNVqqUuhKsbW1hYKhaLC+5E0OGVnZyMwMBCjRo3CgAEDSl0/MTERffr0wfjx4/Hdd98hLi4OY8aMgbe3N4KDgy1QMRERERGZWm5uLpKTk/HgwQOpS6EqSCaT4amnnkKNGjUqtB9Jg1OvXr3Qq1evMq+/YsUKBAQEYMGCBQCAZs2a4dChQ1i0aBGDExEREZEV0mg0SExMhEKhgI+PD+zs7DjyJpmMIAi4c+cObt68iUaNGlWo5cmqhiM/evQogoKC9JYFBwdjypQpxW6Tk5ODnJwc3X2VSmWu8oiIiIjISLm5udBoNPD19YWjo6PU5VAVVKdOHfzzzz/Iy8urUHCyqsEhUlJS4OnpqbfM09MTKpUKDx8+NLhNdHQ0XF1ddROvzE5ERERU+cjlVvW1lKyIqVowq/xfaFRUFDIyMnTTjRs3pC6JiIiIiIisjFV11fPy8kJqaqrestTUVLi4uMDBwcHgNkqlEkql0hLlERERERFRFWVVLU6dO3dGXFyc3rLY2Fh07txZooqIiIiIiKg6kDQ4ZWVlISEhAQkJCQDE4cYTEhKQlJQEQOxmFxYWplt//PjxuHbtGt59911cvHgRX331FTZt2oS33npLivKJiIiIqBobMWJEqdcgpapD0uB06tQptG3bFm3btgUAREZGom3btpg1axYAIDk5WReiACAgIAA7duxAbGwsAgMDsWDBAnzzzTccipyIiIiIiMxK0nOcunXrBkEQin08JibG4DZ//PGHGasiososNxe4cAE4cwZISBBv09OBGjWKTk5OZV/u5ATYWNVZn6an0QD37gEpKUBqqnhraH7oUGDaNKmrJZ3MTODFF8X/COfPA7a2UldEVDGCAEh1IVxHR8BEI7AdOHAA77zzDs6cOYOaNWsiPDwcH330EWweH2x++OEHzJ07F1euXIGjoyPatm2Ln376CU5OTti/fz/effdd/PXXX7C1tUWLFi2wfv16+Pn5maQ2Kp9q/jWBiCqze/fEYFQ4JJ0/D+Tlmef5lMqigapmTcDTE/DyEqfC815egKuryY6xZiEIQEZG8SFIO5+SAqSlAWp16fu8fPwegFpmr53KyMEBOHVKnM/IAGrXlrYeoop68ED8AJZCVpb4S1oF3bp1C71798aIESOwbt06XLx4EWPHjoW9vT3mzJmD5ORkhIaGYv78+ejfvz8yMzPx+++/QxAE5OfnIyQkBGPHjsX333+P3NxcnDhxghcFrgQYnIhIchoNcPVqQTjS3t68aXh9V1egTRsgMFCcvLyA7GzxeKednrxf0vL8fHG/OTnidO9e2Wu3szMcqp4MWJ6exn0P0GjEWot7HSW9xsxM4M6dgkCUm1v25wWA2s458HRUwUtxB17qW/B6cA2emVfhhWR4IQUN3bsCmGHcTsl8bGwAZ2fxH/7ffxmciCqBr776Cr6+vli6dClkMhmaNm2K27dvY9q0aZg1axaSk5ORn5+PAQMG6FqRWrVqBQC4f/8+MjIy8Morr6BBgwYAgGbNmkn2WqgAgxORCQgCkJxc8KU/MVH8Yh8cDDz+zKu0BEGse/dusQucg4Nx3d5q1BBbasr6Q1h2NnD2rH5IOntWXG5I/fpiONIGpTZtgHr1TNfKIwhisDAUQjIzgfv3i2+hycgQt01KEqfSODkVhCjttbyLC0Cm7qXi6gp4eQnwqpUPTwcVvGzuwiv/JjwfJMIr/SK8UhLg+e8FeCANtpn5QKaBnTg7i3/QjdkVrNJxdy8ITkTWztFR/CCU6rlN4MKFC+jcubNeK1GXLl2QlZWFmzdvIjAwED169ECrVq0QHByMl19+Ga+99hrc3d1Rs2ZNjBgxAsHBwXjppZcQFBSEwYMHw9vb2yS1UfkxOBEZKS8PuHixaBeyO3cMr9+ggRiggoOB7t3F755Su3MHiI0Vw9KePWIIqAiFouRg5eQkHgPPnAEuXxbDypPs7YFWrfRDUuvWgItLxWorjUwmBj+lUuyWZ4xHjwrC1JOh6sn7Dx6IAenqVXEypr6S3tcaNYAaTgJqOOSjhr0aNZR5cLLNRR11CrweXINX+kV4pv4J+8QLwJUrwKWMkp+wdm3xj7Zhw4Jb7XydOpW7X2J15u4upncGJ6oKZDKTdJerzBQKBWJjY3HkyBHs2bMHX375JaZPn47jx48jICAAa9aswZtvvoldu3Zh48aNmDFjBmJjY/HMM89IXXq1xuBEVIL0dP1wlJAA/PWX4a5PcjnQpIn4hd/fHzh6FDh8WPyS/NVX4mRrC3TpUhCkAgPF7cpMowH++afgW34xF35+Ul6eWM/u3eIUH68fXpycxFD3zDPiumXt5vbwobi9Wg2oVOJUFl5e+i1IgYFAo0bWNziDvT3g5ydOpcnKehyirucg9chVpJy8AfmDLNSQP0ANZKGGLAs1hCzU0KhQQ8iEk1qFGuoMOOSpIMvLLdSPMBe4nSP+EeY8vtX2NSyrunWLhiLtratr+d4Mkpa7u3jL4ERUKTRr1gw//vgjBEHQtTodPnwYzs7OeOqppwAAMpkMXbp0QZcuXTBr1iz4+flh69atiIyMBADdyNNRUVHo3Lkz1q9fz+AkMSv7mkJkHhqN2L3uyZBUXPcrZ+eC82u0X/xbtCjawp+ZCezbVxBYrl4F9u8Xp6gowMMDePllMUS9/LJ4v1h//AGMHw+cOFGwTKkUvzAZmK7JGmD37VbYfa0hfrvgjcyH+t2rAgMLAlyXLuKujKVWF4Sp0sKWra3YghQYWMrrNMbDh8C1a2L6bNxYbPqqbB4+BI4dQ40DB9Bw/340PHZMDDzmZGcHPPVU0VDUsCEQEGCyrijW6ODBg/jss89w+vRpJCcnY+vWrXrXYCnu5Ov58+fjnXfeMfjYnDlzMHfuXL1lTZo0wcWLF01Wd6kYnIgkk5GRobsmqda4ceOwePFiTJo0CREREbh06RJmz56NyMhIyOVyHD9+HHFxcXj55Zfh4eGB48eP486dO2jWrBkSExOxcuVKvPrqq/Dx8cGlS5dw+fJlvWubkjQYnKjayMnR71Z16xZw7pwYkP78Uww5hvj5FW0d8fcvW0uRszPw6qviBIg9pbQh6rffxFHMvv1WnACgbVsxyPTsCXTuLH7/RWYmMGsWsGSJmPBsbMTmIrVafFGP+4JlwQn70Q270RG7EYzLaKxXS23cwcvYg2DsxsvYA6+L6UBaTeCXQoGrVi3xC7evr/5UzNBxCoXYlc6s3ekyMsTEeeVK0dtbtwrWc3AQk1mbNuIb2bat2PevjK1yJpOdLTbvHTggJuQTJ4o2UXp6Al27in9cSqX4D1341tCykh4rPG9ry+50JcjOzkZgYCBGjRqFAQMGFHk8OTlZ7/6vv/6K0aNHY+DAgSXut0WLFti7d6/uvo2lm08ZnIgks3//ft01SbVGjx6NnTt34p133kFgYCBq1qyJ0aNHY8YMcWAdFxcXHDx4EIsXL4ZKpYKfnx8WLFiAXr16ITU1FRcvXsTatWtx7949eHt7Y+LEifjPf/4jxcujQhicyKrl5+uPHlbSeSbp6SXvS6kUW40Kh6TWrQE3N9PVq+0ZNXGi+F36yJGCIPXHHwXTJ58ANWoIeLFpMoIvL0VwxnY0gAYYMgRYuBDw9oagysSZw1ni9gcdcOicK/LyC9KcjVyNzrX+RrDrcQTb7cPTOUchT78vfrHSaIAciCNaPPFF0aAaNYqGqSen8vZHFwTxH/HJUKSdv3u35O1dXcU/hOxs4PhxcdKSy4GmTQuClDZUGXsyU0myssQ+mdqgdPJk0a5zPj5iUOraFejWTWwdY7iRRK9evdCrV69iH/fy8tK7/9NPP6F79+6oX79+ifu1sbEpsq1FMTgRSSImJsbgdUe1ThTuJVJIs2bNsGvXLoOPeXp6YuvWraYoj0yMwYkq7OpV4O+/zbNvQRBHNSvu2jN37xoeaKA4trb6Q0U3a1YQkpo0sew5NnZ24nfobt2A6Gjxde3Z83jAhl1q3LmnwPZTPtiOeQDmoYH3AwTXckTgL+L39D17XJCSot/UExBQ0P3uxRcVcHFpBqAZgBEFK2k0BaNvPTnduQPcuKE/3b8vhoMLF8SpOO7uYoAy1GLl6yu+YO3ICE+2HhXX3Kfl4WG421nDhmII0o5nXjh9/vGH+HrOnxen774r2F+9evpBqm1bscayhBmVCjh0qCAonT5d9OJHvr4FIalrV7FeBiWrk5qaih07dmDt2rWlrnv58mX4+PjA3t4enTt3RnR0NOrVq2eBKh9jcCIiMjsGJyo3QQCWLgWmTBG/t0pFLhe/V5d2LR1PT/G7RWX9/urpCQwfkovhNxdA8+NHSEAT7Jb3xm7f0Th8yx9Xkx3x1Vf62zg6ioM6aLv3NWxYhtcnl4utNK6uYp/D0mRnixdUejJQFZ4KB7E//zT+xctkYth4Mhg1aCBOpQ1FqFCIrTiNG4utckDBGPF//CH2x9SGqWvXCsYP/+mngn3UrKkfpNq2FfeXlQX8/rsYlA4cEEfWePIP3t+/ICR17Srer6x/aFRma9euhbOzs8EufYV16tQJMTExaNKkCZKTkzF37lw8//zzOHfuHJyL+dvNyclBTqFz3VRlHVmlOAxORERmx+BE5ZKXB0yaBPz3v+L95s3NdyqJm1vJgahWrco5JoDRDh4EJkwAzp+HHMDT3d3w9FfDENU0ACpVwSATFy4AHTtWbFAHozg5ic1xTZoUv45KVXKwunFD/KMJCDAcjgICxCHqTEkmE7vI+fgAffoULM/IEEf/0AYp7VCJ9++LJ5799lvBuvb24nlkTzZrNmigH5Qs2bJAFrN69WoMHToU9qX8bRbu+te6dWt06tQJfn5+2LRpE0aPHm1wm+jo6CIDSlQIgxMRkdkxOJHR7t8HBg0Sv1/KZMCnnwJTp1rZD+wqldjyUJbWDHO7exd4911gzRrxfp064nlMQ4fq3lQXF6BfP3GqlFxcxBPEWrQw/LggiK00lSHhuroCL7wgTlo5OWJ4KtwydeZMwQUYmzQpCEldu4rDeVOV9vvvv+PSpUvYuHGj0du6ubmhcePGuHLlSrHrREVF6YYcBsQWJ19f33LVCoDBiYjIAhicyCgXLwJ9+4qnptSoAaxfL96vtLKzxSaav/4Sp3PnxFvtOONKJRAUBISEiEPfmWyc7DLQaICYGOCdd8Q0CgDjxoknPJly8ILKQCarHKGpOEol8PTT4qSl0YjhukYNsWmTqpVVq1ahXbt2CAwMNHrbrKwsXL16FcOHDy92HaVSCaUpm4sZnIiIzI7Bicpszx5g8GCxp5OfH/Dzz+Joz5VCTo6Y6gqHo3PnxIszFTd6hIuL2PK0Y4c4jRsn9n0LCRGnBg3MV++5c2K3vEOHxPutWwMrVohjkFPlIJeLXQmpSsnKytJrCUpMTERCQgJq1qypG8xBpVJh8+bNWLBggcF99OjRA/3790dERAQAYOrUqejbty/8/Pxw+/ZtzJ49GwqFAqGhoeZ/QVoMTkREZsfgRKXSDgLx1lvi4GFdugBbtli2cUYnLw+4fLloQLpypejIZlq1awMtW4rdyLS3LVqIXzTOnwe2bQO2bhVHRzt0SJymThVToTZEtW1rmr6I2dnAhx8CCxaIQ1Y7OQEffAC8+aZlh/QjqqZOnTqF7t276+5ru8uFh4frhhTesGEDBEEoNvhcvXoVdwsNk3/z5k2Ehobi3r17qFOnDp577jkcO3YMderUMd8LeZL2ugkqlfhZWJlbeImIrJRMEIwZzNn6qVQquLq6IiMjAy5mvWpn1fDkIBDh4eK82QckAMQR0U6cAM6eLQhJly6JRRni5qYfjrS3ZU14N26Io6xt3SqOnlY4iNWrVxCinn++fCHnl1+AiAjg+nXxfkiIeFHbipzXQGRl+BlsWIXfl7y8x1fMhnjeZK1api2QyIwePXqExMREBAQElDoYC1F5lPQ3ZsznL3/ipmJZdBAIlUps8TlxomC6edPwuk5OhgOSj0/FivP1FYNNRIT44nfsEEPUrl3iOVFLlohTzZriiV0hIcDLL4tjgpfkxg1g8mRxX4AYwr78UjyniojIFGxtxc/G7Gyxux6DE5FV6NatG9q0aYPFixcDAPz9/TFlyhRMmTKl2G1kMhm2bt2KkJCQCj23qfZTnTA4kUFPDgLx3Xcm/J6fmyu2IhUOSRcuFD0XSSYTxzl/+mn9gFSvnnj+iTnVrAkMHy5ODx4AsbFil76ffwbu3QPWrhUnBwdxXPCQEOCVV/S/rOTni0Fr1izxy4yNDfD228DMmeIXHCIiU3J3LwhORGRWffv2RV5eHnbt2lXksd9//x0vvPACzpw5g9atWxu135MnT8LJxN8R5syZg23btiEhIUFveXJyMty150eaSUxMDKZMmYL09HSzPo+lMDhRESYdBEIQxPRVOCT98Yc4mMOT/PzECxR17Ah06CAGJqmHCgfEFiXtWOD5+eI5UNu2idP16wXzCoU4xHVICNCoERAVJQ5pDYgnhi1fXolG0yCiKsfdXWypZ3AiMrvRo0dj4MCBuHnzJp566im9x9asWYP27dsbHZoAWPTcSC+OGGs0M/9sT9ZEOwhE795iaOrSRcw5Rn3XT00Vk9bMmWJLTK1aQOPGwLBhYuvLsWNiaHJ3Fx+fOVNcPyUF+OcfYNMmsT9g166VIzQ9ycZGvPDp4sXiiH3x8WKLUqtW4jlR+/aJ3fJ69xZDU82awDffiBe3ZWgiInPiyHpEFvPKK6+gTp06ukFltLKysrB582aMHj0a9+7dQ2hoKOrWrQtHR0e0atUK33//fYn79ff313XbA4DLly/jhRdegL29PZo3b47Y2Ngi20ybNg2NGzeGo6Mj6tevj5kzZyLv8fngMTExmDt3Ls6cOQOZTAaZTKarWSaTYdu2bbr9nD17Fi+++CIcHBxQq1YtjBs3Dlna6xkCGDFiBEJCQvD555/D29sbtWrVwsSJE3XPVR5JSUno168fatSoARcXFwwePBipqam6x8+cOYPu3bvD2dkZLi4uaNeuHU6dOgUAuH79Ovr27Qt3d3c4OTmhRYsW2LlzZ7lrKQu2OBEA8bziN98UR8QGjBgE4uFDsctaXJyYsrTXRypMe40cbWtSx47iUN9WdcVcA2QycbS9tm2BuXOBq1fFwSW2bRND04ABwPz54gVtiYjMTRucqkiXGKq+BEHsJS8FR8eyfT2xsbFBWFgYYmJiMH36dMgeb7R582ao1WqEhoYiKysL7dq1w7Rp0+Di4oIdO3Zg+PDhaNCgATp27Fjqc2g0GgwYMACenp44fvw4MjIyDJ775OzsjJiYGPj4+ODs2bMYO3YsnJ2d8e6772LIkCE4d+4cdu3ahb179wIAXF1di+wjOzsbwcHB6Ny5M06ePIm0tDSMGTMGEREReuFw37598Pb2xr59+3DlyhUMGTIEbdq0wdixY0t/0wy8Pm1oOnDgAPLz8zFx4kQMGTIE+/fvBwAMHToUbdu2xfLly6FQKJCQkABbW1sAwMSJE5Gbm4uDBw/CyckJ58+fR40aNYyuwyhCNZORkSEAEDIyMqQupdK4d08QXnxREABBkMkEYf58QdBoStno0SNB+PJLQfD2FjfUTjKZILRoIQgjRwrC8uWCcPq0IOTmWuR1EFHlx89gw0zyvowYIX4OR0ebrjAiC3j48KFw/vx54eHDh4IgCEJWlv5XC0tOWVllr/vChQsCAGHfvn26Zc8//7wwbNiwYrfp06eP8Pbbb+vud+3aVZg8ebLuvp+fn7Bo0SJBEARh9+7dgo2NjXDr1i3d47/++qsAQNi6dWuxz/HZZ58J7dq1092fPXu2EBgYWGS9wvtZuXKl4O7uLmQVegN27NghyOVyISUlRRAEQQgPDxf8/PyE/Px83TqDBg0ShgwZUmwta9asEVxdXQ0+tmfPHkGhUAhJSUm6ZX/99ZcAQDhx4oQgCILg7OwsxMTEGNy+VatWwpw5c4p97sKe/BsrzJjPX7Y4VXNGDwKRmwusWQN89FHBqHf16gHjx4sXb23XrnJ2sSMiqurYVY/Iopo2bYpnn30Wq1evRrdu3XDlyhX8/vvv+OCDDwAAarUa8+bNw6ZNm3Dr1i3k5uYiJycHjqWNxvvYhQsX4OvrCx8fH92yzp07F1lv48aNWLJkCa5evYqsrCzk5+cbfVmDCxcuIDAwUG9gii5dukCj0eDSpUvw9PQEALRo0QKKQteJ8/b2xtmzZ416rsLP6evrC99Cl2Vp3rw53NzccOHCBXTo0AGRkZEYM2YM/ve//yEoKAiDBg1CgwYNAABvvvkmJkyYgD179iAoKAgDBw4s13llxuA5TtXYnj3AM8+IoalePeDw4RJCU14esHo10KSJGJJu3gTq1gW++kq8IG1UlHjuD0MTEZE0GJyoinB0BLKypJnKmGl0Ro8ejR9//BGZmZlYs2YNGjRogK5duwIAPvvsM3zxxReYNm0a9u3bh4SEBAQHByM3N9dk79XRo0cxdOhQ9O7dG7/88gv++OMPTJ8+3aTPUZi2m5yWTCaDRqMxy3MB4oiAf/31F/r06YPffvsNzZs3x9bHl3cZM2YMrl27huHDh+Ps2bNo3749vvzyS7PVAjA4VUtPDgLx7LPAyZOAwZCuVgP/+x/QrBkwerQ4gIOXF/DFF2LimjCh4KKLREQkHQYnqiJkMvGqHVJMxp5+PXjwYMjlcqxfvx7r1q3DqFGjdOc7HT58GP369cOwYcMQGBiI+vXr4++//y7zvps1a4YbN24gOTlZt+zYsWN66xw5cgR+fn6YPn062rdvj0aNGuH69et669jZ2UGtVpf6XGfOnEF2drZu2eHDhyGXy9GkSZMy12wM7eu7ceOGbtn58+eRnp6O5s2b65Y1btwYb731Fvbs2YMBAwZgzZo1usd8fX0xfvx4bNmyBW+//Ta+/vprs9SqxeBUzeTlAW+8AUyaJGaisDDxArceHk+sqNEAGzaI100KCxMHPqhTB/j8c3H+zTcBXt2biKjyYHAisrgaNWpgyJAhiIqKQnJyMkaMGKF7rFGjRoiNjcWRI0dw4cIF/Oc//9EbMa40QUFBaNy4McLDw3HmzBn8/vvvmD59ut46jRo1QlJSEjZs2ICrV69iyZIluhYZLX9/fyQmJiIhIQF3795FjoFLwgwdOhT29vYIDw/HuXPnsG/fPkyaNAnDhw/XddMrL7VajYSEBL3pwoULCAoKQqtWrTB06FDEx8fjxIkTCAsLQ9euXdG+fXs8fPgQERER2L9/P65fv47Dhw/j5MmTaNasGQBgypQp2L17NxITExEfH499+/bpHjMXBqdq5P59oGdPceQ8mQz49FMgJuaJkfM0GuCHH8Tmp9BQ4NIlcUjtTz4Brl0TL+BqbDs2ERGZH4MTkSRGjx6Nf//9F8HBwXrnI82YMQNPP/00goOD0a1bN3h5eSEkJKTM+5XL5di6dSsePnyIjh07YsyYMfj444/11nn11Vfx1ltvISIiAm3atMGRI0cwc+ZMvXUGDhyInj17onv37qhTp47BIdEdHR2xe/du3L9/Hx06dMBrr72GHj16YOnSpca9GQZkZWWhbdu2elPfvn0hk8nw008/wd3dHS+88AKCgoJQv359bNy4EQCgUChw7949hIWFoXHjxhg8eDB69eqFuXPnAhAD2cSJE9GsWTP07NkTjRs3xldffVXheksiEwRBMOszVDIqlQqurq7IyMgw+sQ5a3bpEvDKK2LvOicnYP36J85nEgRg+3Zg9uyCi7a6uYlB6c03gWr0XhGR+VTXz+DSmOR9OXpU7HsdECD+0EVkJR49eoTExEQEBATAnr1ZyAxK+hsz5vOXo+pVAxs3AmPHApmZ4iAQP/9c6HwmQQB+/VW8iOvp0+IyZ2fgrbfEyc1NqrKJiMgYbHEiIjIrBqcq7OFDYMoUYOVK8f5zzwE//vj4fCZBAPbuFQOT9kRDJyexdWnqVLF7HhERWQ9tcMrIELtdy9kbn4jIlBicqqgLF4AhQ4CzZ8XzmaKigLlzARsbAPv2iYHp0CFxZQcHYOJE4N13xQEgiIjI+miDkyCI4Ul7n4iITILBqQpau1YcOe/BA7F16dtvgZdeghiUZs0SgxMgjgoxfjzw3nviEONERGS97OzEwXsePBC76zE4ERGZFINTFZKVJQam//1PvN+jhxiavOqogdeHiic7AYCtLTBunNgMVbeudAUTEZFpubkVBCciIjIpdoCuIs6cAdq3F0OTXA589BGwe/fjhqQPPhBDk42NGJiuXBGvgMvQRERUtXCACLJi1WygZ7IgU/1tscXJygkC8N//ioNA5OSIWWj9euCFFx6vsHcv8OGH4vzatcD//Z9UpRIRkbkxOJEVsrW1BQA8ePAADg4OEldDVVFubi4A8dpQFcHgZMXS08Vhxn/4Qbzfp494QdvatR+vkJICDBsmpquxYxmaiIiqOgYnskIKhQJubm5IS0sDIF6MVSaTSVwVVRUajQZ37tyBo6MjbGwqFn0YnKzUyZPiqHmJiWIPvE8/FS+7pPucUavFoJSaCrRqBXzxhaT1EhGRBTA4kZXyejxIlTY8EZmSXC5HvXr1KhzIGZysjCAAixaJA+Hl5YkXiN+wAejY8YkVP/pIHD3PyQnYtEkccpyIiKo2BieyUjKZDN7e3vDw8EBeXp7U5VAVY2dnB7kJrm3H4GRF7t0DRowAfvlFvP/aa8DXX4uDKOn57Tfxok0AsGIF0LSpBaskIiLJMDiRlVMoFBU+D4XIXDiqnpX4/XegTRsxNCmVwFdfiQ1JRUJTaiowdKjYNDVqlHiOExERVQ/a4JSeLmkZRERVEYNTJadWAx9/DHTrBty8CTRuDBw/DkyYUOh8psIrDxsmDgrRogXw5ZdSlExERFJhixMRkdmwq14llpICDB8ujigOiPNffQXUqFHMBvPmiSs7OgKbN4u3RERUfTA4ERGZDYNTJbV3r9jjLi1NzD9ffQWEh5ewwYEDwJw54vxXXwHNmlmiTCIiqkwYnIiIzIZd9SqZ/Hxgxgzg5ZfF0NSyJXDqVCmhKS0NCA0FNBpx9IgSVyYioiqLwYmIyGzY4lSJ3Lwp5p9Dh8T7//mPOPR4iSOJazRiH77kZKB5c2DpUovUSkRElVDhwSE0GsAEw+8SEZGIwamS0GiAXr2Ac+cAZ2dxmPEhQ8qw4SefAHv2iOlq0ybxuk1ERFQ9aYOTRgNkZgKurtLWQ0RUhTA4VRJ794qhycUFiI8HGjQow0YHDwIzZ4rzy5aJI+kREVH1ZW8vTo8eid31GJyIiEyGbfiVhHbk8JEjyxia7twpOK9p+HDx3CYiIiKe50REZBYMTpXAtWvAjh3i/BtvlGEDjQYICwNu3waaNhVH0StyUSciIqqWGJyIiMyCwakS+OorQBCAnj3FC9yWav58YNcusTvGpk0lXNiJiIiqHQYnIiKzYHCS2IMHwKpV4nxERBk2OHRIHK8cEEfQa9XKbLUREZEVYnAiIjILBieJrV8vjhpbv744ql6J7t4Vz2tSq8Wr444aZYkSiYjImri5ibcMTkREJsXgJCFBKBgUYuLEUi63odGIF7a9eVPsz7d8Oc9rIiKiotjiRERkFgxOEjp0CPjzT8DRURxNr0QLFgA7d4rnNW3eLF7siYiI6EkMTkREZsHgJCFta9OwYQXHOYOOHAGiosT5L74AWrc2e21ERFXRwYMH0bdvX/j4+EAmk2Hbtm16j48YMQIymUxv6tmzZ6n7XbZsGfz9/WFvb49OnTrhxIkTZnoFZcDgRERkFgxOErl1C9iyRZyfOLGEFe/dA15/XTyvKTQUGDvWIvUREVVF2dnZCAwMxLJly4pdp2fPnkhOTtZN33//fYn73LhxIyIjIzF79mzEx8cjMDAQwcHBSEtLM3X5ZcPgRERkFjZSF1Bd/fe/YhZ64YUSGpAEQbyw7Y0bQKNG4kY8r4mIqNx69eqFXqWMxKNUKuHl5VXmfS5cuBBjx47FyMd9rlesWIEdO3Zg9erVeO+99ypUb7kwOBERmQVbnCSQkyNmIACYNKmEFRcuBH75BVAqxes18bwmIiKz279/Pzw8PNCkSRNMmDAB9+7dK3bd3NxcnD59GkFBQbplcrkcQUFBOHr0aLHb5eTkQKVS6U0mw+BERGQWDE4S+OEHIC0NqFsX6NevmJWOHQO0v1QuXgy0aWOh6oiIqq+ePXti3bp1iIuLw6effooDBw6gV69eUKvVBte/e/cu1Go1PD099ZZ7enoiJSWl2OeJjo6Gq6urbvL19TXdi9AGp/R00+2TiIjYVU8K2kEhJkwAbG0NrHD/PjBkCJCfDwweDPznPxatj4iounr99dd1861atULr1q3RoEED7N+/Hz169DDZ80RFRSEyMlJ3X6VSmS48FW5xEgR28SYiMhG2OFnYyZPA8eOAnV0x4zwIgjg2eVIS0KAB8PXXPOgREUmkfv36qF27Nq5cuWLw8dq1a0OhUCA1NVVveWpqaonnSSmVSri4uOhNJqMNTmo1kJVluv0SEVVzDE4Wph3IafBgwMPDwApffAFs3y4mq02bAFMeTImIyCg3b97EvXv34O3tbfBxOzs7tGvXDnFxcbplGo0GcXFx6Ny5s6XK1OfgIB5DAJ7nRERkQgxOFnTnDrBhgzhvcFCIEyeAd98V5xcuBJ5+2mK1ERFVB1lZWUhISEBCQgIAIDExEQkJCUhKSkJWVhbeeecdHDt2DP/88w/i4uLQr18/NGzYEMHBwbp99OjRA0uXLtXdj4yMxNdff421a9fiwoULmDBhArKzs3Wj7FmcTMYBIoiIzIDnOFnQN9+II+p16AB07GhghUmTgLw84LXXgDfesHh9RERV3alTp9C9e3fdfe15RuHh4Vi+fDn+/PNPrF27Funp6fDx8cHLL7+MDz/8EEqlUrfN1atXcffuXd39IUOG4M6dO5g1axZSUlLQpk0b7Nq1q8iAERbl7g6kpjI4ERGZkEwQBEHqIixJpVLB1dUVGRkZpu1TXor8fKB+ffGSTOvWAcOHG1jJ1RVQqYDz54FmzSxWGxGRpUj1GVzZmfx9efZZ4OhR8Urr/ftXfH9ERFWUMZ+/7KpnIdu3i6GpTh1g0CADK+TkiKEJAKT8lZKIiKwfu+oREZkcg5OFaLvDjx0L2NsbWEF7gUWFAnBzs1RZRERUFTE4ERGZHIOTBZw7B+zbJ2ai8eOLWenOHfG2Vi1Azn8WIiKqAAYnIiKTk/wb+rJly+Dv7w97e3t06tQJJ06cKHbdvLw8fPDBB2jQoAHs7e0RGBiIXbt2WbDa8tEOQR4SAhR7fUPtica1a1uiJCIiqsoYnIiITE7S4LRx40ZERkZi9uzZiI+PR2BgIIKDg5GWlmZw/RkzZuC///0vvvzyS5w/fx7jx49H//798ccff1i48rJLTxcHgwCAiIgSVtS2ONWpY+6SiIioqmNwIiIyOUmD08KFCzF27FiMHDkSzZs3x4oVK+Do6IjVq1cbXP9///sf3n//ffTu3Rv169fHhAkT0Lt3byxYsMDClZddTAzw4AHQsiXQtWsJK7LFiYiITEV7riyDExGRyUgWnHJzc3H69GkEBQUVFCOXIygoCEePHjW4TU5ODuyfGFnBwcEBhw4dKvZ5cnJyoFKp9CZL0WgKuulFRIjXJCwWgxMREZkKW5yIiExOsuB09+5dqNXqIhcI9PT0REpKisFtgoODsXDhQly+fBkajQaxsbHYsmULkpOTi32e6OhouLq66ibfYk8yMr3du4ErV8TLMw0bVsrK7KpHRESmwuBERGRykg8OYYwvvvgCjRo1QtOmTWFnZ4eIiAiMHDkS8hJGoYuKikJGRoZuunHjhsXq1Q5BPmoU4ORUyspscSIiIlNhcCIiMjnJglPt2rWhUCiQmpqqtzw1NRVeXl4Gt6lTpw62bduG7OxsXL9+HRcvXkSNGjVQv379Yp9HqVTCxcVFb7KEK1eAX38Vu+e98UYZNmCLExERmUrh4CQI0tZCRFRFSBac7Ozs0K5dO8TFxemWaTQaxMXFoXPnziVua29vj7p16yI/Px8//vgj+vXrZ+5yjfbVV+KxqlcvoGHDMmzAFiciIjIVbXDKzweys6WthYioirCR8skjIyMRHh6O9u3bo2PHjli8eDGys7MxcuRIAEBYWBjq1q2L6OhoAMDx48dx69YttGnTBrdu3cKcOXOg0Wjw7rvvSvkyisjOBrQDA5Y4BHlhbHEiIiJTcXICbGzE4PTvv0CNGlJXRERk9SQNTkOGDMGdO3cwa9YspKSkoE2bNti1a5duwIikpCS985cePXqEGTNm4Nq1a6hRowZ69+6N//3vf3DTDrtaSXz7LZCRIbY0BQeXYQNBYIsTERGZjkwmtjrduSMGJwsOjEREVFVJGpwAICIiAhHFNMvs379f737Xrl1x/vx5C1RVfoJQMCjExIlACeNWFMjIEH8VBBiciIjINLTBKT1d6kqIiKoEqxpVzxocOACcOwc4OgIjRpRxI21rk5MT4OBgrtKIiKg64ch6REQmxeBkYtrWprCwggu3l4rd9IiIyNQYnIiITIrByYRu3AC2bRPnJ040YkMODEFERKbG4EREZFIMTia0YgWgVgPdugEtWxqxIVuciIjI1BiciIhMisHJRB49AlauFOcnTTJyY7Y4ERGRqTE4ERGZFIOTiWzeLDYc+foCr75q5MZscSIiIlNjcCIiMikGJxP58kvxdsIE8ZqDRmGLExERmRqDExGRSTE4mcCJE8DJk4CdHTBmTDl2wBYnIiIyNQYnIiKTYnAyAW1r0+uvl7PRSNvixOBERESmwuBERGRSDE4VlJoKbNokzhs9KISWtsWJXfWIiMhUtBcTZHAiIjIJBqcK+uYbIDcX6NQJaN++nDthVz0iIjK1wi1OgiBtLUREVQCDUwXk5QHLl4vz5W5tys0FMjLEebY4ERGRqWiDU24u8PChtLUQEVUBDE4V8NNPwK1bgIcH8Npr5dzJvXvirVxecJAjIiKqKGdnQKEQ59ldj4iowhicKkA7KMS4cYBSWc6daAeGqFVLDE9ERESmIJPxPCciIhPiN/Vy+vNP4OBB8ce88eMrsCOe30RERObCkfWIiEyGwamcli0TbwcMAOrWrcCOePFbIiIyFwYnIiKTYXAqh3//Bb79VpyPiKjgztjiRERE5sLgRERkMgxO5bBmDfDgAdC6NfD88xXcGYMTERGZC4MTEZHJMDgZSa0u6KYXESGee1sh7KpHRETmog1O6emSlkFEVBUwOBlp1y7g2jVxoKKhQ02wQ7Y4ERGRubDFiYjIZBicjLR0qXg7ejTg6GiCHbLFiYiIzIXBiYjIZBicjKDRAP7+QI0awBtvmGinbHEiIiJzYXAiIjIZBicjyOXA8uVAaipQv76JdsoWJyIiMhcGJyIik2FwKgeTdNEDAEFgixMREZkPgxMRkckwOElJpQLy8sR5BiciIrM7ePAg+vbtCx8fH8hkMmzbtk33WF5eHqZNm4ZWrVrByckJPj4+CAsLw+3bt0vc55w5cyCTyfSmpk2bmvmVlBGDExGRyTA4SUnb2uToaMJmLCIiKk52djYCAwOxTHtdiUIePHiA+Ph4zJw5E/Hx8diyZQsuXbqEV199tdT9tmjRAsnJybrp0KFD5ijfeAxOREQmYyN1AdUau+kREVlUr1690KtXL4OPubq6IjY2Vm/Z0qVL0bFjRyQlJaFevXrF7tfGxgZeXl4mrdUktMHp0SNxsreXth4iIivGFicpcWAIIqJKLSMjAzKZDG5ubiWud/nyZfj4+KB+/foYOnQokpKSSlw/JycHKpVKbzILZ2dxZCOArU5ERBXE4CQltjgREVVajx49wrRp0xAaGgoXF5di1+vUqRNiYmKwa9cuLF++HImJiXj++eeRmZlZ7DbR0dFwdXXVTb6+vuZ4CWJocnUV5xmciIgqhMFJSmxxIiKqlPLy8jB48GAIgoDly5eXuG6vXr0waNAgtG7dGsHBwdi5cyfS09OxadOmYreJiopCRkaGbrpx44apX0IBnudERGQSPMdJSmxxIiKqdLSh6fr16/jtt99KbG0yxM3NDY0bN8aVK1eKXUepVEKpVFa01LJhcCIiMgm2OEmJLU5ERJWKNjRdvnwZe/fuRa1atYzeR1ZWFq5evQpvb28zVFgODE5ERCbB4CQltjgREVlUVlYWEhISkJCQAABITExEQkICkpKSkJeXh9deew2nTp3Cd999B7VajZSUFKSkpCA3N1e3jx49emDp0qW6+1OnTsWBAwfwzz//4MiRI+jfvz8UCgVCQ0Mt/fIMY3AiIjIJdtWTEluciIgs6tSpU+jevbvufmRkJAAgPDwcc+bMwfbt2wEAbdq00dtu37596NatGwDg6tWruKv94QvAzZs3ERoainv37qFOnTp47rnncOzYMdSpLJ/tDE5ERCbB4CQltjgREVlUt27dIAhCsY+X9JjWP//8o3d/w4YNFS3LvBiciIhMgl31pMTgRERE5sbgRERkEgxOUsnLA9LTxfnK0p2DiIiqHgYnIiKTYHCSyr174q1MVnBQIyIiMjUGJyIik2Bwkop2YIhatQCFQtpaiIio6tIGJ20vByIiKhcGJ6nw/CYiIrIEtjgREZkEg5NUOBQ5ERFZAoMTEZFJMDhJhS1ORERkCdrg9OABUOhCvkREZBwGJ6mwxYmIiCzB1VUciAhgqxMRUQUwOEmFLU5ERGQJcrkYngAGJyKiCmBwkgqDExERWQrPcyIiqjAGJ6mwqx4REVkKgxMRUYUxOEmFLU5ERGQpDE5ERBXG4CQVtjgREZGluLmJtwxORETlxuAkBUFgixMREVkOW5yIiCqMwUkKmZkF19JgixMREZkbgxMRUYUxOElB29rk4AA4OkpbCxERVX0MTkREFcbgJAWe30RERJbE4EREVGEMTlLg+U1ERGRJDE5ERBXG4CQFBiciIrIkBiciogpjcJICu+oREZElMTgREVUYg5MU2OJERESWxOBERFRhDE5SYIsTERFZkjY4ZWcDeXnS1kJEZKUYnKTAFiciIrIkN7eC+fR0qaogIrJqDE5SYIsTERFZkkIBuLiI8+yuR0RULgxOUmCLExERWRrPcyIiqhAGJymwxYmIiCyNwYmIqEIYnCwtL6+gfzlbnIiIyFIYnIiIKoTBydLu3xdvZTKgZk1payEiouqDwYmIqEIYnCxN202vZk3xZF0iIiJLYHAiIqoQBidL48AQREQkBQYnIqIKYXCyNA4MQUREUtBey4nBiYioXBicLI0tTkREJAW2OBERVYjRwcnf3x8ffPABkpKSzFFP1ccWJyIikgKDExFRhRgdnKZMmYItW7agfv36eOmll7Bhwwbk5OSUu4Bly5bB398f9vb26NSpE06cOFHi+osXL0aTJk3g4OAAX19fvPXWW3j06FG5n9/i2OJERERSYHAiIqqQcgWnhIQEnDhxAs2aNcOkSZPg7e2NiIgIxMfHG7WvjRs3IjIyErNnz0Z8fDwCAwMRHByMtLQ0g+uvX78e7733HmbPno0LFy5g1apV2LhxI95//31jX4Z02OJERERSYHAiIqqQcp/j9PTTT2PJkiW4ffs2Zs+ejW+++QYdOnRAmzZtsHr1agiCUOo+Fi5ciLFjx2LkyJFo3rw5VqxYAUdHR6xevdrg+keOHEGXLl3wf//3f/D398fLL7+M0NDQUlupKhW2OBERkRQYnIiIKqTcwSkvLw+bNm3Cq6++irfffhvt27fHN998g4EDB+L999/H0KFDS9w+NzcXp0+fRlBQUEExcjmCgoJw9OhRg9s8++yzOH36tC4oXbt2DTt37kTv3r3L+zIsj8GJiIikoA1OmZlAfr60tRARWSEbYzeIj4/HmjVr8P3330MulyMsLAyLFi1C06ZNdev0798fHTp0KHE/d+/ehVqthqenp95yT09PXLx40eA2//d//4e7d+/iueeegyAIyM/Px/jx40vsqpeTk6N3DpZKpSrLyzQfdtUjIiIpaIcjB4D0dP6AR0RkJKNbnDp06IDLly9j+fLluHXrFj7//HO90AQAAQEBeP31101WpNb+/fsxb948fPXVV4iPj8eWLVuwY8cOfPjhh8VuEx0dDVdXV93k6+tr8rrKTBDY4kREJKGDBw+ib9++8PHxgUwmw7Zt2/QeFwQBs2bNgre3NxwcHBAUFITLly+Xul9jBzqShK0tUKOGOM/uekRERjM6OF27dg27du3CoEGDYGtra3AdJycnrFmzpsT91K5dGwqFAqmpqXrLU1NT4eXlZXCbmTNnYvjw4RgzZgxatWqF/v37Y968eYiOjoZGozG4TVRUFDIyMnTTjRs3yvAqzSQrC9C2frHFiYjI4rKzsxEYGIhly5YZfHz+/PlYsmQJVqxYgePHj8PJyQnBwcEljt5q7EBHkuJ5TkRE5WZ0cEpLS8Px48eLLD9+/DhOnTpV5v3Y2dmhXbt2iIuL0y3TaDSIi4tD586dDW7z4MEDyOX6JSsUCgAodjAKpVIJFxcXvUky2tYme3vA0VG6OoiIqqlevXrho48+Qv/+/Ys8JggCFi9ejBkzZqBfv35o3bo11q1bh9u3bxdpmSrM2IGOJMXgRERUbkYHp4kTJxpstbl16xYmTpxo1L4iIyPx9ddfY+3atbhw4QImTJiA7OxsjBw5EgAQFhaGqKgo3fp9+/bF8uXLsWHDBiQmJiI2NhYzZ85E3759dQGqUit8fpNMJm0tRESkJzExESkpKXqDFrm6uqJTp07FDlpUnoGOAPH8W5VKpTdZBIMTEVG5GT04xPnz5/H0008XWd62bVucP3/eqH0NGTIEd+7cwaxZs5CSkoI2bdpg165dugEjkpKS9FqYZsyYAZlMhhkzZuDWrVuoU6cO+vbti48//tjYlyENnt9ERFRppaSkAIDBQYu0jz2pPAMdAeL5t3Pnzq1gxeWgDU7p6ZZ/biIiK2d0cFIqlUhNTUX9+vX1licnJ8PGxujdISIiAhEREQYf279/v959GxsbzJ49G7Nnzzb6eSoFbXDi+U1ERNVaVFQUIiMjdfdVKpVlBi9iixMRUbkZ3VXv5Zdf1g24oJWeno73338fL730kkmLq3K0XfXY4kREVOloByYyZtCi8gx0BEh4/i2DExFRuRkdnD7//HPcuHEDfn5+6N69O7p3746AgACkpKRgwYIF5qix6mBXPSKiSisgIABeXl56gxapVCocP3682EGLyjPQkaQYnIiIys3ovnV169bFn3/+ie+++w5nzpyBg4MDRo4cidDQ0GKHJ6fHePFbIiJJZWVl4cqVK7r7iYmJSEhIQM2aNVGvXj1MmTIFH330ERo1aoSAgADMnDkTPj4+CAkJ0W3To0cP9O/fX9fNPDIyEuHh4Wjfvj06duyIxYsX6w10VKkwOBERlZvxJyVBvE7TuHHjTF1L1ccWJyIiSZ06dQrdu3fX3deeZxQeHo6YmBi8++67yM7Oxrhx45Ceno7nnnsOu3btgr29vW6bq1ev4q728xylD3RUqTA4ERGVm0wo7gJIpTh//jySkpKQm5urt/zVV181SWHmolKp4OrqioyMDMtf06lLF+DIEeCHH4CBAy373ERElYCkn8GVmMXel19/BXr3Btq2BeLjzfc8RERWwpjPX6NbnK5du4b+/fvj7NmzkMlkugvPyh5fl0itVpej5GqCLU5ERCQlNzfxli1ORERGM3pwiMmTJyMgIABpaWlwdHTEX3/9hYMHD6J9+/ZFhg+nJ/AcJyKicrlx4wZu3rypu3/ixAlMmTIFK1eulLAqK8SuekRE5WZ0cDp69Cg++OAD1K5dG3K5HHK5HM899xyio6Px5ptvmqPGqiE/v+BAxRYnIiKj/N///R/27dsHQLxQ7UsvvYQTJ05g+vTp+OCDDySuzopog1NGBsAeIkRERjE6OKnVajg7OwMQr19x+/ZtAICfnx8uXbpk2uqqkvv3xVuZDKhZU9paiIiszLlz59CxY0cAwKZNm9CyZUscOXIE3333HWJiYqQtzppogxMghiciIiozo89xatmyJc6cOYOAgAB06tQJ8+fPh52dHVauXIn69eubo8aqQdtNz90dsCnXYIZERNVWXl4elEolAGDv3r26gYiaNm2K5ORkKUuzLnZ2gKMj8OCB2AuCP+QREZWZ0S1OM2bMgEajAQB88MEHSExMxPPPP4+dO3diyZIlJi+wyuDAEERE5daiRQusWLECv//+O2JjY9GzZ08AwO3bt1GrVi2Jq7MyPM+JiKhcjG76CA4O1s03bNgQFy9exP379+Hu7q4bWY8M4MAQRETl9umnn6J///747LPPEB4ejsDAQADA9u3bdV34qIzc3YFbtxiciIiMZFRwysvLg4ODAxISEtCyZUvd8pps6i8dW5yIiMqtW7duuHv3LlQqFdwLnaczbtw4ODo6SliZFWKLExFRuRjVVc/W1hb16tXjtZrKgy1ORETl9vDhQ+Tk5OhC0/Xr17F48WJcunQJHh4eEldnZRiciIjKxehznKZPn473338f97WjxFHZsMWJiKjc+vXrh3Xr1gEA0tPT0alTJyxYsAAhISFYvny5xNVZGQYnIqJyMTo4LV26FAcPHoSPjw+aNGmCp59+Wm+iYrDFiYio3OLj4/H8888DAH744Qd4enri+vXrWLduHQcmMhaDExFRuRg9OERISIgZyqgG2OJERFRuDx480F1DcM+ePRgwYADkcjmeeeYZXL9+XeLqrAyDExFRuRgdnGbPnm2OOqo+BicionJr2LAhtm3bhv79+2P37t146623AABpaWlwcXGRuDorow1O6emSlkFEZG2M7qpH5cSuekRE5TZr1ixMnToV/v7+6NixIzp37gxAbH1q27atxNVZGbY4ERGVi9EtTnK5vMTrNXHEPQMEgS1OREQV8Nprr+G5555DcnKy7hpOANCjRw/0799fwsqsEIMTEVG5GB2ctm7dqnc/Ly8Pf/zxB9auXYu5c+earLAqJTsbePRInGeLExFRuXh5ecHLyws3b94EADz11FO8+G15MDgREZWL0cGpX79+RZa99tpraNGiBTZu3IjRo0ebpLAqRdvapFQCTk7S1kJEZIU0Gg0++ugjLFiwAFlZWQAAZ2dnvP3225g+fTrkcvY8LzMGJyKicjE6OBXnmWeewbhx40y1u6ql8PlNJXRzJCIiw6ZPn45Vq1bhk08+QZcuXQAAhw4dwpw5c/Do0SN8/PHHEldoRQoPDqHRAAydRERlYpLg9PDhQyxZsgR169Y1xe6qHp7fRERUIWvXrsU333yDV199VbesdevWqFu3Lt544w0GJ2O4uYm3ggCoVAX3iYioREYHJ3d3d73BIQRBQGZmJhwdHfHtt9+atLgqgyPqERFVyP3799G0adMiy5s2bYr79+9LUJEVs7cXp0ePxO56DE5ERGVidHBatGiRXnCSy+WoU6cOOnXqBHdt8z/pY4sTEVGFBAYGYunSpViyZIne8qVLl6J169YSVWXF3N2B5GQxOAUESF0NEZFVMDo4jRgxwgxlVHEMTkREFTJ//nz06dMHe/fu1V3D6ejRo7hx4wZ27twpcXVWqHBwIiKiMjH6jNA1a9Zg8+bNRZZv3rwZa9euNUlRVQ676hERVUjXrl3x999/o3///khPT0d6ejoGDBiAv/76C//73/+kLs/6cGQ9IiKjGR2coqOjUdtAy4mHhwfmzZtnkqKqHLY4ERFVmI+PDz7++GP8+OOP+PHHH/HRRx/h33//xapVq6QuzfowOBERGc3o4JSUlIQAA/2h/fz8kJSUZJKiqhy2OBERUWXC4EREZDSjg5OHhwf+/PPPIsvPnDmDWrVqmaSoKoctTkREVJkwOBERGc3o4BQaGoo333wT+/btg1qthlqtxm+//YbJkyfj9ddfN0eN1o8tTkREVJkwOBERGc3oUfU+/PBD/PPPP+jRowdsbMTNNRoNwsLCeI6TIfn5BQcmtjgRERllwIABJT6enp5umUKqGgYnIiKjGR2c7OzssHHjRnz00UdISEiAg4MDWrVqBT8/P3PUZ/3u3xevzg4A7MpIRGQUV1fXUh8PCwuzUDVVCIMTEZHRjA5OWo0aNUKjRo1MWUvVpD2/yd0dsCn3201EVC2tWbNG6hKqJgYnIiKjGX2O08CBA/Hpp58WWT5//nwMGjTIJEVVKRwYgoiIKhsGJyIioxkdnA4ePIjevXsXWd6rVy8cPHjQJEVVKRwYgoiIKhsGJyIioxkdnLKysmBnZ1dkua2tLVQqlUmKqlLY4kRERJWNNjilpxech0tERCUyOji1atUKGzduLLJ8w4YNaN68uUmKqlLY4kRERJWNNjhpNEBmprS1EBFZCaNHK5g5cyYGDBiAq1ev4sUXXwQAxMXFYf369fjhhx9MXqDVY4sTERFVNg4OgFIJ5OSI3fVcXKSuiIio0jM6OPXt2xfbtm3DvHnz8MMPP8DBwQGBgYH47bffULNmTXPUaN3Y4kRERJWRuzuQkiIGJ15ShIioVEZ31QOAPn364PDhw8jOzsa1a9cwePBgTJ06FYGBgaauz/qxxYmIiCojDhBBRGSUcgUnQBxdLzw8HD4+PliwYAFefPFFHDt2zJS1VQ1scSIisir+/v6QyWRFpokTJxpcPyYmpsi69vb2Fq66HNzcxFsGJyKiMjGqq15KSgpiYmKwatUqqFQqDB48GDk5Odi2bRsHhigOW5yIiKzKyZMnoVardffPnTuHl156qcRrFbq4uODSpUu6+zKZzKw1mgRbnIiIjFLm4NS3b18cPHgQffr0weLFi9GzZ08oFAqsWLHCnPVZPwYnIiKrUueJHgKffPIJGjRogK5duxa7jUwmg5eXl7lLMy0GJyIio5S5q96vv/6K0aNHY+7cuejTpw8UCoU566oasrOBhw/FeXbVIyKyOrm5ufj2228xatSoEluRsrKy4OfnB19fX/Tr1w9//fWXBassJwYnIiKjlDk4HTp0CJmZmWjXrh06deqEpUuX4q62NYUM074/dnZAjRrS1kJEREbbtm0b0tPTMWLEiGLXadKkCVavXo2ffvoJ3377LTQaDZ599lncvHmz2G1ycnKgUqn0JotjcCIiMkqZg9MzzzyDr7/+GsnJyfjPf/6DDRs2wMfHBxqNBrGxscjkBfSKKjwwhDX0dyciIj2rVq1Cr1694OPjU+w6nTt3RlhYGNq0aYOuXbtiy5YtqFOnDv773/8Wu010dDRcXV11k6+vrznKLxmDExGRUYweVc/JyQmjRo3CoUOHcPbsWbz99tv45JNP4OHhgVdffdUcNVovnt9ERGS1rl+/jr1792LMmDFGbWdra4u2bdviypUrxa4TFRWFjIwM3XTjxo2Klms8BiciIqOUezhyQOyeMH/+fNy8eRPff/+9qWqqOjgUORGR1VqzZg08PDzQp08fo7ZTq9U4e/YsvL29i11HqVTCxcVFb7I4BiciIqNUKDhpKRQKhISEYPv27abYXdXBFiciIquk0WiwZs0ahIeHw8ZGfwDasLAwREVF6e5/8MEH2LNnD65du4b4+HgMGzYM169fN7qlyuIYnIiIjGLUdZzISGxxIiKySnv37kVSUhJGjRpV5LGkpCTI5QW/O/77778YO3YsUlJS4O7ujnbt2uHIkSOV//qGDE5EREZhcDIntjgREVmll19+GYIgGHxs//79evcXLVqERYsWWaAqEyscnASBgxgREZXCJF31qBgMTkREVFlpg5NaDWRlSVsLEZEVYHAyJ3bVIyKiysrREbC1FefZXY+IqFQMTubEFiciIqqsZDKe50REZAQGJ3NiixMREVVm2uCUni5pGURE1oDByVzUauD+fXGeLU5ERFQZscWJiKjMGJzM5f59cZQiAKhVS9paiIiIDGFwIiIqMwYnc9Ge3+TmVnDyLRERUWXC4EREVGYMTuaiDU48v4mIiCorBiciojJjcDIX7cAQPL+JiIgqKzc38ZbBiYioVAxO5sKhyImIqLJjixMRUZkxOJkLhyInIqLKjsGJiKjMGJzMhS1ORERU2TE4ERGVGYOTubDFiYiIKjsGJyKiMmNwMhe2OBERUWXH4EREVGYMTubCFiciIqrsCgcn7UXbiYjIIAYnc2GLExERVXba4JSXBzx4IG0tRESVXKUITsuWLYO/vz/s7e3RqVMnnDhxoth1u3XrBplMVmTq06ePBSsuA14Al4iIKrsaNQCFQpxndz0iohJJHpw2btyIyMhIzJ49G/Hx8QgMDERwcDDS0tIMrr9lyxYkJyfrpnPnzkGhUGDQoEEWrrwEDx4U/HLHFiciIqqsZDKe50REVEaSB6eFCxdi7NixGDlyJJo3b44VK1bA0dERq1evNrh+zZo14eXlpZtiY2Ph6OhYuYKTtrXJ1hZwdpa2FiIiopIwOBERlYmkwSk3NxenT59GUFCQbplcLkdQUBCOHj1apn2sWrUKr7/+OpycnAw+npOTA5VKpTeZXeGBIWQy8z8fERFReTE4ERGViaTB6e7du1Cr1fD09NRb7unpiZSUlFK3P3HiBM6dO4cxY8YUu050dDRcXV11k6+vb4XrLhUHhiAiImvB4EREVCaSd9WriFWrVqFVq1bo2LFjsetERUUhIyNDN924ccP8hXEociIishYMTkREZWIj5ZPXrl0bCoUCqampestTU1Ph5eVV4rbZ2dnYsGEDPvjggxLXUyqVUCqVFa7VKGxxIiIia8HgRERUJpK2ONnZ2aFdu3aIi4vTLdNoNIiLi0Pnzp1L3Hbz5s3IycnBsGHDzF2m8djiRERE1kIbnNLTJS2DiKiyk7TFCQAiIyMRHh6O9u3bo2PHjli8eDGys7MxcuRIAEBYWBjq1q2L6Ohove1WrVqFkJAQ1KpVS4qyS8YWJyIishZscSIiKhPJg9OQIUNw584dzJo1CykpKWjTpg127dqlGzAiKSkJcrl+w9ilS5dw6NAh7NmzR4qSS8eL3xIRkbVgcCIiKhPJgxMAREREICIiwuBj+/fvL7KsSZMmEATBzFVVgLarHluciIiosmNwIiIqE6seVa/SYlc9IiKyFm5u4i2DExFRiRiczIGDQxARkbVgixMRUZkwOJmaWg3cvy/Os8WJiIgqOwYnIqIyYXAytX//BTQacZ7BiYiIKjttcMrJAR4+lLYWIqJKjMHJ1LTnN7m6Ara20tZCRERUGmdnQDt6LVudiIiKxeBkajy/iYiIrIlczgEiiIjKgMHJ1DiiHhERWRue50REVCoGJ1PjxW+JiMjaMDgREZWKwcnUePFbIiKyNgxORESlYnAyNXbVIyIia8PgRERUKgYnU+PgEEREZG0YnIiISsXgZGpscSIislpz5syBTCbTm5o2bVriNps3b0bTpk1hb2+PVq1aYefOnRaq1oQYnIiISsXgZGpscSIismotWrRAcnKybjp06FCx6x45cgShoaEYPXo0/vjjD4SEhCAkJATnzp2zYMUmwOBERFQqBidTY4sTEZFVs7GxgZeXl26qXcLn+RdffIGePXvinXfeQbNmzfDhhx/i6aefxtKlSy1YsQkwOBERlYrBydTY4kREZNUuX74MHx8f1K9fH0OHDkVSUlKx6x49ehRBQUF6y4KDg3H06NESnyMnJwcqlUpvkhSDExFRqRicTOnBA3EC2OJERGSFOnXqhJiYGOzatQvLly9HYmIinn/+eWRmZhpcPyUlBZ6ennrLPD09kZKSUuLzREdHw9XVVTf5+vqa7DWUizY4padLWgYRUWXG4GRK9+6Jt7a2gIuLtLUQEZHRevXqhUGDBqF169YIDg7Gzp07kZ6ejk2bNpn0eaKiopCRkaGbbty4YdL9G40tTkREpbKRuoAqpfDFb2UyaWshIqIKc3NzQ+PGjXHlyhWDj3t5eSE1NVVvWWpqKry8vErcr1KphFKpNFmdFcbgRERUKrY4mRIHhiAiqlKysrJw9epVeHt7G3y8c+fOiIuL01sWGxuLzp07W6I803FzE28fPgRyciQthYiosmJwMiUODEFEZNWmTp2KAwcO4J9//sGRI0fQv39/KBQKhIaGAgDCwsIQFRWlW3/y5MnYtWsXFixYgIsXL2LOnDk4deoUIiIipHoJ5ePqWtBTgq1OREQGMTiZEluciIis2s2bNxEaGoomTZpg8ODBqFWrFo4dO4Y6j38QS0pKQnJysm79Z599FuvXr8fKlSsRGBiIH374Adu2bUPLli2legnlI5eL4QlgcCIiKgbPcTIltjgREVm1DRs2lPj4/v37iywbNGgQBg0aZKaKLMjdXRxVj8GJiMggtjiZEluciIjIWnGACCKiEjE4mRJbnIiIyFoxOBERlYjByZTY4kRERNaKwYmIqEQMTqbE4ERERNaKwYmIqEQMTqbErnpERGStGJyIiErE4GQqGg1w7544zxYnIiKyNgxOREQlYnAylX//FcMTwOBERETWh8GJiKhEDE6moj2/ycUFsLOTthYiIiJjMTgREZWIwclUeH4TERFZMwYnIqISMTiZCkfUIyIia8bgRERUIgYnU2GLExERWTMGJyKiEjE4mQpbnIiIyJppg9ODB0BurrS1EBFVQgxOpsLgRERE1szVtWCerU5EREUwOJkKu+oREZE1UygKwlN6uqSlEBFVRgxOpsIWJyIisnY8z4mIqFgMTqbCFiciIrJ2bm7iLYMTEVERDE6mwhYnIiKydmxxIiIqFoOTqbDFiYiIrB2DExFRsRicTOHhQyA7W5xnixMREVkrBiciomIxOJnCvXvirY2N/nCuRERE1oTBiYioWAxOpqDtple7NiCTSVsLERFReTE4EREVi8HJFDgwBBERVQUMTkRExWJwMgUODEFERFUBgxMRUbEYnEyBLU5ERFQVMDgRERWLwckU2OJERERVAYMTEVGxGJxMgS1ORERUFTA4EREVi8HJFNjiREREVYE2OGVlAXl50tZCRFTJMDiZAluciIioKnBzK5hPT5eqCiKiSonByRS0wYktTkREZM1sbABnZ3Ge3fWIiPQwOJlC4QvgEhERWTOe50REZBCDU0VpNMC9e+I8gxMREVk7BiciIoMYnCoqPR1Qq8V5BiciIrJ2DE5ERAYxOFWU9vwmZ2dAqZS2FiIioorSBicODkFEpIfBqaI4FDkREVUlbHEiIjKIwamiOBQ5ERFVJdohyRmciIj0MDhVFFuciIioKmGLExGRQQxOFcUWJyIiqkoYnIiIDGJwqihe/JaIiKoSBiciIoMYnCqKF78lIqoyoqOj0aFDBzg7O8PDwwMhISG4dOlSidvExMRAJpPpTfb29haq2AwYnIiIDGJwqih21SMiqjIOHDiAiRMn4tixY4iNjUVeXh5efvllZGdnl7idi4sLkpOTddP169ctVLEZMDgRERlkI3UBVo+DQxARVRm7du3Sux8TEwMPDw+cPn0aL7zwQrHbyWQyeHl5mbs8y2BwIiIyiC1OFcUWJyKiKisjIwMAULNmzRLXy8rKgp+fH3x9fdGvXz/89ddfJa6fk5MDlUqlN1Ua2uCkUgFqtbS1EBFVIgxOFcUWJyKiKkmj0WDKlCno0qULWrZsWex6TZo0werVq/HTTz/h22+/hUajwbPPPoubN28Wu010dDRcXV11k6+vrzleQvlogxMApKdLVgYRUWUjEwRBkLoIS1KpVHB1dUVGRgZcXFwqtrNHjwAHB3H+/n39gw0RERVh0s9gM5swYQJ+/fVXHDp0CE899VSZt8vLy0OzZs0QGhqKDz/80OA6OTk5yMnJ0d1XqVTw9fWtPO9LjRpAdjZw+TLQsKHU1RARmY0xxyWe41QR2m56CkXBldaJiMjqRURE4JdffsHBgweNCk0AYGtri7Zt2+LKlSvFrqNUKqFUKitapvm4u4vBiec5ERHpsKteRRQ+v0kmk7YWIiKqMEEQEBERga1bt+K3335DQECA0ftQq9U4e/YsvL29zVChhXCACCKiIiQPTsuWLYO/vz/s7e3RqVMnnDhxosT109PTMXHiRHh7e0OpVKJx48bYuXOnhap9Ai9+S0RUpUycOBHffvst1q9fD2dnZ6SkpCAlJQUPHz7UrRMWFoaoqCjd/Q8++AB79uzBtWvXEB8fj2HDhuH69esYM2aMFC/BNBiciIiKkLSr3saNGxEZGYkVK1agU6dOWLx4MYKDg3Hp0iV4eHgUWT83NxcvvfQSPDw88MMPP6Bu3bq4fv063KTqJseL3xIRVSnLly8HAHTr1k1v+Zo1azBixAgAQFJSEuTygt8d//33X4wdOxYpKSlwd3dHu3btcOTIETRv3txSZZsegxMRURGSBqeFCxdi7NixGDlyJABgxYoV2LFjB1avXo333nuvyPqrV6/G/fv3ceTIEdja2gIA/P39LVmyPg5FTkRUpZRlvKT9+/fr3V+0aBEWLVpkpookwuBERFSEZF31cnNzcfr0aQQFBRUUI5cjKCgIR48eNbjN9u3b0blzZ0ycOBGenp5o2bIl5s2bB7VU15ngUORERFQVMTgRERUhWYvT3bt3oVar4enpqbfc09MTFy9eNLjNtWvX8Ntvv2Ho0KHYuXMnrly5gjfeeAN5eXmYPXu2wW0MDflqwhch3rLFiYiIqhIGJyKiIiQfHMIYGo0GHh4eWLlyJdq1a4chQ4Zg+vTpWLFiRbHbmPUig2xxIiKiqojBiYioCMmCU+3ataFQKJCamqq3PDU1FV5eXga38fb2RuPGjaFQKHTLmjVrhpSUFOTm5hrcJioqChkZGbrpxo0bpnsRbHEiIqKqSDvoUnq6lFUQEVUqkgUnOzs7tGvXDnFxcbplGo0GcXFx6Ny5s8FtunTpgitXrkCj0eiW/f333/D29oadnZ3BbZRKJVxcXPQmk2GLExERVUVscSIiKkLSUfUiIyMRHh6O9u3bo2PHjli8eDGys7N1o+yFhYWhbt26iI6OBgBMmDABS5cuxeTJkzFp0iRcvnwZ8+bNw5tvvinNC2CLE5WTWq1GXl6e1GUQmZytra1erwCyUgxORERFSBqchgwZgjt37mDWrFlISUlBmzZtsGvXLt2AEU9eK8PX1xe7d+/GW2+9hdatW6Nu3bqYPHkypk2bZvniBYEXwCWjCYKAlJQUpLP7C1Vhbm5u8PLygkwmk7oUKi8GJyKiImRCWS5aUYWoVCq4uroiIyOjYt32/v0XqFlTnH/4ELC3N02BVKUlJycjPT0dHh4ecHR05BdLqlIEQcCDBw+QlpYGNzc3eHt7F1nHZJ/BVUyle19SUgBvb0AmA/LzAblVjSVFRFRmxnz+StriZNW0rU01ajA0UZmo1WpdaKpVq5bU5RCZhYODAwAgLS0NHh4e7LZnrbQtToIAZGQU3Cciqsb4E1J5cWAIMpL2nCZHR0eJKyEyL+3fOM/js2JKJfA4BLO7HhGRiMGpvDgwBJUTu+dRVce/8SqC5zkREelhcCovtjgREVFVxuBERKSHwam82OJERERVGYMTEZEeBqfyYosTVTNHjx6FQqFAnz59pC6FiCyBwYmISA+DU3mxxYmqmVWrVmHSpEk4ePAgbt++LVkdubm5kj03UbXC4EREpIfBqbx48VuqKEEAsrOlmYy8fFtWVhY2btyICRMmoE+fPoiJidF7/Oeff0aHDh1gb2+P2rVro3///rrHcnJyMG3aNPj6+kKpVKJhw4ZYtWoVACAmJgZubm56+9q2bZve4AJz5sxBmzZt8M033yAgIAD2j4f/37VrF5577jm4ubmhVq1aeOWVV3D16lW9fd28eROhoaGoWbMmnJyc0L59exw/fhz//PMP5HI5Tp06pbf+4sWL4efnB41GY9T7Q1QlMTgREenhdZzKS9tVjy1OVF4PHojXAZNCVhbg5FTm1Tdt2oSmTZuiSZMmGDZsGKZMmYKoqCjIZDLs2LED/fv3x/Tp07Fu3Trk5uZi586dum3DwsJw9OhRLFmyBIGBgUhMTMRd7Q8PZXTlyhX8+OOP2LJli+66QNnZ2YiMjETr1q2RlZWFWbNmoX///khISIBcLkdWVha6du2KunXrYvv27fDy8kJ8fDw0Gg38/f0RFBSENWvWoH379rrnWbNmDUaMGAE5L/ZJxOBERPQEBqfyYlc9qkZWrVqFYcOGAQB69uyJjIwMHDhwAN26dcPHH3+M119/HXPnztWtHxgYCAD4+++/sWnTJsTGxiIoKAgAUL9+faOfPzc3F+vWrUOdQi28AwcO1Ftn9erVqFOnDs6fP4+WLVti/fr1uHPnDk6ePImaNWsCABo2bKhbf8yYMRg/fjwWLlwIpVKJ+Ph4nD17Fj/99JPR9RFVSQxORER6+LNqeXFwCKooR0ex5UeKyYiL8F66dAknTpxAaGgoAMDGxgZDhgzRdbdLSEhAjx49DG6bkJAAhUKBrl27Vuit8vPz0wtNAHD58mWEhoaifv36cHFxgb+/PwAgKSlJ99xt27bVhaYnhYSEQKFQYOvWrQDEboPdu3fX7Yeo2mNwIiLSwxan8sjJATIzxXm2OFF5yWRGdZeTyqpVq5Cfnw8fHx/dMkEQoFQqsXTpUjg4OBS7bUmPAYBcLofwxPlWeXl5RdZzMvA+9e3bF35+fvj666/h4+MDjUaDli1b6gaPKO257ezsEBYWhjVr1mDAgAFYv349vvjiixK3IapWGJyIiPSwxak8tN30FArgiRPbiaqS/Px8rFu3DgsWLEBCQoJuOnPmDHx8fPD999+jdevWiIuLM7h9q1atoNFocODAAYOP16lTB5mZmcjOztYtS0hIKLWue/fu4dKlS5gxYwZ69OiBZs2a4d8nvty1bt0aCQkJuH//frH7GTNmDPbu3YuvvvoK+fn5GDBgQKnPTVRtMDgREelhi1N5aINTrVoATyKnKuyXX37Bv//+i9GjR8PV1VXvsYEDB2LVqlX47LPP0KNHDzRo0ACvv/468vPzsXPnTkybNg3+/v4IDw/HqFGjdINDXL9+HWlpaRg8eDA6deoER0dHvP/++3jzzTdx/PjxIiP2GeLu7o5atWph5cqV8Pb2RlJSEt577z29dUJDQzFv3jyEhIQgOjoa3t7e+OOPP+Dj44POnTsDAJo1a4ZnnnkG06ZNw6hRo0ptpSKqVhiciIj08Ft/eXAocqomVq1ahaCgoCKhCRCD06lTp1CzZk1s3rwZ27dvR5s2bfDiiy/ixIkTuvWWL1+O1157DW+88QaaNm2KsWPH6lqYatasiW+//RY7d+5Eq1at8P3332POnDml1iWXy7FhwwacPn0aLVu2xFtvvYXPPvtMbx07Ozvs2bMHHh4e6N27N1q1aoVPPvlENyqf1ujRo5Gbm4tRo0aV4x0iqsK0PSoyMgAO0U9EBJnw5AkGVZxKpYKrqysyMjLg4uJSvp1s2ACEhgJduwL795u0Pqq6Hj16hMTERL1rEZH0PvzwQ2zevBl//vmn1KVUGSX9rZvkM7gKqpTvy8OHBQPJpKcDBn5AISKydsZ8/rLFqTw4FDmR1cvKysK5c+ewdOlSTJo0SepyiCofBwdAqRTn2V2PiIjBqVw4FDmR1YuIiEC7du3QrVs3dtMjKg7PcyIi0mFwKg+2OBFZvZiYGOTk5GDjxo1FznsioscYnIiIdBicyoMtTkREVB0wOBER6TA4lQdbnIiIqDpgcCIi0mFwKg+2OBERUXXA4EREpMPgVB5scSIiouqAwYmISIfByViCwAvgEhFRpZKba6YdMzgREekwOBkrIwPIzxfna9WSthYiK9GtWzdMmTJFd9/f3x+LFy8ucRuZTIZt27ZV+LlNtR+iykoQgPr1gbZtgTffBDZtAm7fNtHOGZyIiHRspC7A6mhbm5ycxIsDElVhffv2RV5eHnbt2lXksd9//x0vvPACzpw5g9atWxu135MnT8LJyclUZQIA5syZg23btiEhIUFveXJyMty1X/7M7OHDh6hbty7kcjlu3boFpfbioURmdP06cOuWOCUkAF9+KS6vXx947jlxev55oEkTQCYzcucMTkREOgxOxuLAEFSNjB49GgMHDsTNmzfx1FNP6T22Zs0atG/f3ujQBAB1LPj/x8vLy2LP9eOPP6JFixYQBAHbtm3DkCFDLPbcTxIEAWq1GjY2/Jiv6vz9xdB0+DDw++/AoUPAmTPAtWvitG6duF6tWgUh6rnnxBYqO7tSds7gRESkw656xuLAEFSNvPLKK6hTpw5iYmL0lmdlZWHz5s0YPXo07t27h9DQUNStWxeOjo5o1aoVvv/++xL3+2RXvcuXL+OFF16Avb09mjdvjtjY2CLbTJs2DY0bN4ajoyPq16+PmTNnIi8vD4B4Mdu5c+fizJkzkMlkkMlkupqf7Kp39uxZvPjii3BwcECtWrUwbtw4ZGVl6R4fMWIEQkJC8Pnnn8Pb2xu1atXCxIkTdc9VklWrVmHYsGEYNmwYVq1aVeTxv/76C6+88gpcXFzg7OyM559/HlevXtU9vnr1arRo0QJKpRLe3t6IiIgAAPzzzz+QyWR6rWnp6emQyWTYv38/AGD//v2QyWT49ddf0a5dOyiVShw6dAhXr15Fv3794OnpiRo1aqBDhw7Yu3evXl05OTmYNm0afH19oVQq0bBhQ6xatQqCIKBhw4b4/PPP9dZPSEiATCbDlStXSn1PyDJ8fIBBg4AlS4D4eDHn7NoFzJgBdOsG2NsD9+4BP/0ETJ0KPPMM4OYGvPgiMGsWsGcPkJlpYMfa4JSaCiQmAjk5FnxVRESVC3+KNBZbnMhEBAF48ECa53Z0LFuXHRsbG4SFhSEmJgbTp0+H7PFGmzdvhlqtRmhoKLKystCuXTtMmzYNLi4u2LFjB4YPH44GDRqgY8eOpT6HRqPBgAED4OnpiePHjyMjI0PvfCgtZ2dnxMTEwMfHB2fPnsXYsWPh7OyMd999F0OGDMG5c+ewa9cuXShwdXUtso/s7GwEBwejc+fOOHnyJNLS0jBmzBhERETohcN9+/bB29sb+/btw5UrVzBkyBC0adMGY8eOLfZ1XL16FUePHsWWLVsgCALeeustXL9+HX5+fgCAW7du4YUXXkC3bt3w22+/wcXFBYcPH0b+43Mmly9fjsjISHzyySfo1asXMjIycPjw4VLfvye99957+Pzzz1G/fn24u7vjxo0b6N27Nz7++GMolUqsW7cOffv2xaVLl1CvXj0AQFhYGI4ePYolS5YgMDAQiYmJuHv3LmQyGUaNGoU1a9Zg6tSpuudYs2YNXnjhBTRs2NDo+sgyXFyA4GBxAsTBI+LjxdYobavU/fvAvn3iBAByOdCmTUH3vueeA7y15/ImJYl9/wDx+PfUU0Dduvq3heednS3+momIzE6oZjIyMgQAQkZGRvl28OmnggAIwvDhpi2MqryHDx8K58+fFx4+fCgIgiBkZYl/SlJMWVllr/vChQsCAGHfvn26Zc8//7wwbNiwYrfp06eP8Pbbb+vud+3aVZg8ebLuvp+fn7Bo0SJBEARh9+7dgo2NjXDr1i3d47/++qsAQNi6dWuxz/HZZ58J7dq1092fPXu2EBgYWGS9wvtZuXKl4O7uLmQVegN27NghyOVyISUlRRAEQQgPDxf8/PyE/Px83TqDBg0ShgwZUmwtgiAI77//vhASEqK7369fP2H27Nm6+1FRUUJAQICQm5trcHsfHx9h+vTpBh9LTEwUAAh//PGHbtm///6r9++yb98+AYCwbdu2EusUBEFo0aKF8OWXXwqCIAiXLl0SAAixsbEG171165agUCiE48ePC4IgCLm5uULt2rWFmJiYYvf/5N96YRX+DK6iLP2+qNWCcP68IPz3v+LhLCDA8GdFgwYaIbzh78KHNRcIn9m8J3yJicI3GCV8i/8TfsAA4Rf0FvbiReEQnhVO4WnhHJoLVxEg3KrRWLjX+Bkh+8VXhPzwUYIwY4YgrFghCD//LAh//CEId+4IgkZjkddKRFQSYz5/2eJkLLY4UTXTtGlTPPvss1i9ejW6deuGK1eu4Pfff8cHH3wAAFCr1Zg3bx42bdqEW7duITc3Fzk5OXB0dCzT/i9cuABfX1/4+PjolnXu3LnIehs3bsSSJUtw9epVZGVlIT8/Hy4uLka9lgsXLiAwMFBvYIouXbpAo9Hg0qVL8PT0BAC0aNECCoVCt463tzfOnj1b7H7VajXWrl2LL774Qrds2LBhmDp1KmbNmgW5XI6EhAQ8//zzsLW1LbJ9Wloabt++jR49ehj1egxp37693v2srCzMmTMHO3bsQHJyMvLz8/Hw4UMkJSUBELvdKRQKdO3a1eD+fHx80KdPH6xevRodO3bEzz//jJycHAwaNKjCtVZmy5Ytw2effYaUlBQEBgbiyy+/LLEFdfPmzZg5cyb++ecfNGrUCJ9++il69+5twYqNI5cDzZqJ07hx4rJbt8SWKG2r1J9/AlevynAVzwF4zrgnyALw9+MJgC1yYY9HsMcjOOAh7HEP9rLbsLfToIZtDpxtH8HF7hGc7XLhosyBs30eXBzy4OKYD2dHNVxqaODspIGLi9iY5eIqg5OzHHJHe0CpFPsiGrq1sSmYFIqS540eOYOIqhsGJ2PxHCcyEUdHoNCpNRZ/bmOMHj0akyZNwrJly7BmzRo0aNBA90X7s88+wxdffIHFixejVatWcHJywpQpU5BrwgvLHD16FEOHDsXcuXMRHBwMV1dXbNiwAQsWLDDZcxT2ZLiRyWTQaDTFrr97927cunWryGAQarUacXFxeOmll+BQwiicJT0GAHK5eDqqIAi6ZcWdc/XkaIVTp05FbGwsPv/8czRs2BAODg547bXXdP8+pT03AIwZMwbDhw/HokWLsGbNGgwZMqTMwdgabdy4EZGRkVixYgU6deqExYsXIzg4GJcuXYKHh0eR9Y8cOYLQ0FBER0fjlVdewfr16xESEoL4+Hi0bNlSgldQPnXrAkOGiBMgXn3j6FFx0InUVODRo6LTw4eGlgt49AjIzy8IInmwQx7skIlCP3YIAHIeT+UggwY1kAUXqOCMzEK39+GMTDgjEwqoIUAGAbLHT1lwW3SZHIJcDsjEW0GmAGSygmWygschl0EuAxQKAXI5oJADCvnjeYUAhRyQK2RQyAUoFGI2kytkRedtZAX3bcRJLgdk6nzINPmQqdWQa/Igy88Xl2mXF76vzocsPw8ydT7k6jzI1Hni/fxCjz1+XCZoINgpATs7CHZKw/O2dobn7ZSAra24rq0dYGcLwfbxvK2tGD51/zaPGy2188Uu185Df7mBbXUNoYbuF7oV+xmUsO6T92UyyBUyyOSPbxVyw/cf38ptZJDJ5ZDbyMV1bORF1pEpHj+uUUOmzgfyCv0baP89Ck3If2J5Xq7+43lPPKbOh1wOyG0VkNuIzyW3VUBmoxCXGZps5JDZ2uj/mPDkpP0RQfuH+sQkyBVQQwGNTAG1zKZgvtCtbl6QF8xrZNBoAI0Gj/+PlPg0RSa5vPL8rsHgZCxe/JZMRCYTR7W3BoMHD8bkyZOxfv16rFu3DhMmTNCd73T48GH069cPw4YNAyCes/T333+jefPmZdp3s2bNcOPGDSQnJ8Pb2xsAcOzYMb11jhw5Aj8/P0yfPl237Pr163rr2NnZQa1Wl/pcMTExyM7O1gWMw4cPQy6Xo0mTJmWq15BVq1bh9ddf16sPAD7++GOsWrUKL730Elq3bo21a9ciLy+vSDBzdnaGv78/4uLi0L179yL7145CmJycjLZt2wJAkWHXi3P48GGMGDEC/fv3ByC2QP3zzz+6x1u1agWNRoMDBw4gKCjI4D569+4NJycnLF++HLt27cLBgwfL9NzWauHChRg7dixGjhwJAFixYgV27NiB1atX47333iuy/hdffIGePXvinXfeAQB8+OGHiI2NxdKlS7FixQqL1m5Krq5Az57iZBzxsyE/33DYevQIeKTKxcOb9/Dw9r/ITs+DSiUgUwWosmTIzJJDlS2HKtsGmQ9toHpki8xHtlDlKJGZq4Qq1x5qQQEBcmTCRT+MVZT295GSP0qs2yOpCyApyaCBvIRJBgEayAtCkG5e2sigq0imKXor08AGaqz6OAXB7waatQ4GJ2Npu+qxxYmqkRo1amDIkCGIioqCSqXCiBEjdI81atQIP/zwA44cOQJ3d3csXLgQqampZQ5OQUFBaNy4McLDw/HZZ59BpVIVCSCNGjVCUlISNmzYgA4dOmDHjh3YunWr3jr+/v5ITExEQkICnnrqKTg7Oxe5jtLQoUMxe/ZshIeHY86cObhz5w4mTZqE4cOH67rpGevOnTv4+eefsX379iKtC2FhYejfvz/u37+PiIgIfPnll3j99dcRFRUFV1dXHDt2DB07dkSTJk0wZ84cjB8/Hh4eHujVqxcyMzNx+PBhTJo0CQ4ODnjmmWfwySefICAgAGlpaZgxY0aZ6mvUqBG2bNmCvn37QiaTYebMmXqtZ/7+/ggPD8eoUaN0g0Ncv34daWlpGDx4MABAoVBgxIgRiIqKQqNGjQx2pawqcnNzcfr0aURFRemWyeVyBAUF4ejRowa3OXr0KCIjI/WWBQcHl3jh5ZycHOQUGqFOpVJVrPBKyMYGqFFDnIqyA+D9eDKOIIjhS6USRwIsfPvkskKNCrpfrGUQAI0GMkGctPMQNJAVnn98X7u88DaCWgONWoBGrYE6X4A6T4BGLUCtFqDOB9T5he6r8XgeUOcDGo0AtVom3leLv8Kr1dD9Kq/WQGzdKjRpoHg8LxNvITdwXwZB99W34L4A2eN5GQQBkAkCZNAYfA8KXqe6YPnj++J8wa24rrpgXhA/V7QteCjUqgdZ4eVi617BfHHr6O9HJivUYqTdoNBNkTtFWigMr69toNIIMgiCTLwFoBHk4nI8Xv74/dNAXC5Au65MXBfax8R1NY/fe2jfe92/if597WstbtI9Lmjb6GSFnt/4wbEFyKGG3Gy/DWgDjvhXqz9fOJTlw0YXztRQ6P1NGKKBAhookKf9M3jyzwFAruofk7+eJzE4Gevrr8WO4I9/9SWqLkaPHo1Vq1ahd+/eeucjzZgxA9euXUNwcDAcHR0xbtw4hISEICMjo0z7lcvl2Lp1K0aPHo2OHTvC398fS5YsQc9CP3O/+uqreOuttxAREYGcnBz06dMHM2fOxJw5c3TrDBw4EFu2bEH37t2Rnp6ONWvW6AU8AHB0dMTu3bsxefJkdOjQAY6Ojhg4cCAWLlxY7vdl3bp1cHJyMnh+Uo8ePeDg4IBvv/0Wb775Jn777Te888476Nq1KxQKBdq0aYMuXboAAMLDw/Ho0SMsWrQIU6dORe3atfHaa6/p9rV69WqMHj0a7dq1Q5MmTTB//ny8/PLLpda3cOFCjBo1Cs8++yxq166NadOmFfmSvnz5crz//vt44403cO/ePdSrVw/vv/++3jqjR4/GvHnzdK0wVdXdu3ehVquLBGlPT09cvHjR4DYpKSkG109JSSn2eaKjozF37tyKF1wNyWTi9ecdHIDy/d4hA6B4PBFZN0H8HUA3PXn/yam0xzWagu5xhbvKPTmvt0wmiMHocZDW/SpgaCpcgHZeECCoNVDnacTVtLf5AvLzBPHHiXxBt0x3+8Sy+kENzP5+y4TCnearAZVKBVdXV2RkZBh9YjlRRTx69AiJiYkICAiAvb291OUQGeX3339Hjx49cOPGjVJb50r6W6/sn8G3b99G3bp1ceTIEb2WtXfffRcHDhzA8ePHi2xjZ2eHtWvXIjQ0VLfsq6++wty5c5GammrweQy1OPn6+lba94WIqKoy5rjEFiciIipWTk4O7ty5gzlz5mDQoEHl7tJoLWrXrg2FQlEk8KSmpsLLy8vgNl5eXkatDwBKpbJIV1IiIqrcjO8cSURE1cb3338PPz8/pKenY/78+VKXY3Z2dnZo164d4uLidMs0Gg3i4uKKPberc+fOeusDQGxsbJU+F4yIqDpiixMRERVrxIgRRc4Vq+oiIyMRHh6O9u3bo2PHjli8eDGys7N153eFhYWhbt26iI6OBgBMnjwZXbt2xYIFC9CnTx9s2LABp06dwsqVK6V8GUREZGIMTkRERIUMGTIEd+7cwaxZs5CSkoI2bdpg165dum6KSUlJumtrAcCzzz6L9evXY8aMGXj//ffRqFEjbNu2zaqu4URERKXj4BBEFsLBIai6sObBIaTC94WISBrGfP7yHCciC6tmv1VQNcS/cSIiqooYnIgsxNbWFgDw4MEDiSshMi/t37j2b56IiKgq4DlORBaiUCjg5uaGtLQ0AOLFWGWyIpc2J7JagiDgwYMHSEtLg5ubGxQKXmCUiIiqDgYnIgvSXtdFG56IqiI3N7cSr2FERERkjRiciCxIJpPB29sbHh4eyMvLk7ocIpOztbVlSxMREVVJDE5EElAoFPxySURERGRFODgEERERERFRKRiciIiIiIiISsHgREREREREVIpqd46T9sKMKpVK4kqIiKof7WcvL5Krj8cmIiJpGHNcqnbBKTMzEwDg6+srcSVERNVXZmYmXF1dpS6j0uCxiYhIWmU5LsmEavazn0ajwe3bt+Hs7Fyui4+qVCr4+vrixo0bcHFxMUOF5sG6Lcsa67bGmgHWbWkVrVsQBGRmZsLHxwdyOXuLa/HYxLrNzRprBli3pVlj3ZY8LlW7Fie5XI6nnnqqwvtxcXGxmj+owli3ZVlj3dZYM8C6La0idbOlqSgem1i3pVhjzQDrtjRrrNsSxyX+3EdERERERFQKBiciIiIiIqJSMDgZSalUYvbs2VAqlVKXYhTWbVnWWLc11gywbkuz1rqrOmv9d2HdlmONNQOs29KssW5L1lztBocgIiIiIiIyFluciIiIiIiISsHgREREREREVAoGJyIiIiIiolIwOBEREREREZWCwclIy5Ytg7+/P+zt7dGpUyecOHFC6pJKFB0djQ4dOsDZ2RkeHh4ICQnBpUuXpC7LKJ988glkMhmmTJkidSmlunXrFoYNG4ZatWrBwcEBrVq1wqlTp6Quq0RqtRozZ85EQEAAHBwc0KBBA3z44YeobOPGHDx4EH379oWPjw9kMhm2bdum97ggCJg1axa8vb3h4OCAoKAgXL58WZpiCymp7ry8PEybNg2tWrWCk5MTfHx8EBYWhtu3b0tXMEp/rwsbP348ZDIZFi9ebLH6qChrOjZVheMSwGOTufHYZD7WeFwCKsexicHJCBs3bkRkZCRmz56N+Ph4BAYGIjg4GGlpaVKXVqwDBw5g4sSJOHbsGGJjY5GXl4eXX34Z2dnZUpdWJidPnsR///tftG7dWupSSvXvv/+iS5cusLW1xa+//orz589jwYIFcHd3l7q0En366adYvnw5li5digsXLuDTTz/F/Pnz8eWXX0pdmp7s7GwEBgZi2bJlBh+fP38+lixZghUrVuD48eNwcnJCcHAwHj16ZOFK9ZVU94MHDxAfH4+ZM2ciPj4eW7ZswaVLl/Dqq69KUGmB0t5rra1bt+LYsWPw8fGxUGVkiLUdm6z9uATw2GQJPDaZjzUel4BKcmwSqMw6duwoTJw4UXdfrVYLPj4+QnR0tIRVGSctLU0AIBw4cEDqUkqVmZkpNGrUSIiNjRW6du0qTJ48WeqSSjRt2jThueeek7oMo/Xp00cYNWqU3rIBAwYIQ4cOlaii0gEQtm7dqruv0WgELy8v4bPPPtMtS09PF5RKpfD9999LUKFhT9ZtyIkTJwQAwvXr1y1TVCmKq/nmzZtC3bp1hXPnzgl+fn7CokWLLF4biaz92GRNxyVB4LHJUnhssgxrPC4JgnTHJrY4lVFubi5Onz6NoKAg3TK5XI6goCAcPXpUwsqMk5GRAQCoWbOmxJWUbuLEiejTp4/ee16Zbd++He3bt8egQYPg4eGBtm3b4uuvv5a6rFI9++yziIuLw99//w0AOHPmDA4dOoRevXpJXFnZJSYmIiUlRe9vxdXVFZ06dbKq/5+A+H9UJpPBzc1N6lKKpdFoMHz4cLzzzjto0aKF1OVUa1Xh2GRNxyWAxyZL4bGp8rCG4xJgmWOTjVn2WgXdvXsXarUanp6eess9PT1x8eJFiaoyjkajwZQpU9ClSxe0bNlS6nJKtGHDBsTHx+PkyZNSl1Jm165dw/LlyxEZGYn3338fJ0+exJtvvgk7OzuEh4dLXV6x3nvvPahUKjRt2hQKhQJqtRoff/wxhg4dKnVpZZaSkgIABv9/ah+zBo8ePcK0adMQGhoKFxcXqcsp1qeffgobGxu8+eabUpdS7Vn7scmajksAj02WxGNT5WAtxyXAMscmBqdqZOLEiTh37hwOHTokdSklunHjBiZPnozY2FjY29tLXU6ZaTQatG/fHvPmzQMAtG3bFufOncOKFSsq9cFp06ZN+O6777B+/Xq0aNECCQkJmDJlCnx8fCp13VVNXl4eBg8eDEEQsHz5cqnLKdbp06fxxRdfID4+HjKZTOpyyMpZy3EJ4LHJ0nhskp61HJcAyx2b2FWvjGrXrg2FQoHU1FS95ampqfDy8pKoqrKLiIjAL7/8gn379uGpp56SupwSnT59GmlpaXj66adhY2MDGxsbHDhwAEuWLIGNjQ3UarXUJRrk7e2N5s2b6y1r1qwZkpKSJKqobN555x289957eP3119GqVSsMHz4cb731FqKjo6Uurcy0/wet9f+n9uB0/fp1xMbGVupf9X7//XekpaWhXr16uv+f169fx9tvvw1/f3+py6t2rPnYZE3HJYDHJkvjsUla1nRcAix3bGJwKiM7Ozu0a9cOcXFxumUajQZxcXHo3LmzhJWVTBAEREREYOvWrfjtt98QEBAgdUml6tGjB86ePYuEhATd1L59ewwdOhQJCQlQKBRSl2hQly5digyp+/fff8PPz0+iisrmwYMHkMv1PwoUCgU0Go1EFRkvICAAXl5eev8/VSoVjh8/Xqn/fwIFB6fLly9j7969qFWrltQllWj48OH4888/9f5/+vj44J133sHu3bulLq/ascZjkzUelwAemyyNxybpWNtxCbDcsYld9YwQGRmJ8PBwtG/fHh07dsTixYuRnZ2NkSNHSl1asSZOnIj169fjp59+grOzs65PraurKxwcHCSuzjBnZ+cifd2dnJxQq1atSt0H/q233sKzzz6LefPmYfDgwThx4gRWrlyJlStXSl1aifr27YuPP/4Y9erVQ4sWLfDHH39g4cKFGDVqlNSl6cnKysKVK1d09xMTE5GQkICaNWuiXr16mDJlCj766CM0atQIAQEBmDlzJnx8fBASEiJd0Si5bm9vb7z22muIj4/HL7/8ArVarfs/WrNmTdjZ2VW6muvVq1fkIGprawsvLy80adLE0qUSrO/YZI3HJYDHJkvjsUmamivrcQmoJMcmk47RVw18+eWXQr169QQ7OzuhY8eOwrFjx6QuqUQADE5r1qyRujSjWMOQr4IgCD///LPQsmVLQalUCk2bNhVWrlwpdUmlUqlUwuTJk4V69eoJ9vb2Qv369YXp06cLOTk5UpemZ9++fQb/lsPDwwVBEId9nTlzpuDp6SkolUqhR48ewqVLl6QtWii57sTExGL/j+7bt69S1mwIhyOXnjUdm6rKcUkQeGwyJx6bpKm5sh6XSqvbEHMcm2SCUMkuwUxERERERFTJ8BwnIiIiIiKiUjA4ERERERERlYLBiYiIiIiIqBQMTkRERERERKVgcCIiIiIiIioFgxMREREREVEpGJyIiIiIiIhKweBEVE3IZDJs27ZN6jKIiIgA8LhE1ofBicgCRowYAZlMVmTq2bOn1KUREVE1xOMSkfFspC6AqLro2bMn1qxZo7dMqVRKVA0REVV3PC4RGYctTkQWolQq4eXlpTe5u7sDELsrLF++HL169YKDgwPq16+PH374QW/7s2fP4sUXX4SDgwNq1aqFcePGISsrS2+d1atXo0WLFlAqlfD29kZERITe43fv3kX//v3h6OiIRo0aYfv27eZ90UREVGnxuERkHAYnokpi5syZGDhwIM6cOYOhQ4fi9ddfx4ULFwAA2dnZCA4Ohru7O06ePInNmzdj7969egeg5cuXY+LEiRg3bhzOnj2L7du3o2HDhnrPMXfuXAwePBh//vknevfujaFDh+L+/fsWfZ1ERGQdeFwieoJARGYXHh4uKBQKwcnJSW/6+OOPBUEQBADC+PHj9bbp1KmTMGHCBEEQBGHlypWCu7u7kJWVpXt8x44dglwuF1JSUgRBEAQfHx9h+vTpxdYAQJgxY4buflZWlgBA+PXXX032OomIyDrwuERkPJ7jRGQh3bt3x/Lly/WW1axZUzffuXNnvcc6d+6MhIQEAMCFCxcQGBgIJycn3eNdunSBRqPBpUuXIJPJcPv2bfTo0aPEGlq3bq2bd3JygouLC9LS0sr7koiIyIrxuERkHAYnIgtxcnIq0kXBVBwcHMq0nq2trd59mUwGjUZjjpKIiKiS43GJyDg8x4mokjh27FiR+82aNQMANGvWDGfOnEF2drbu8cOHD0Mul6NJkyZwdnaGv78/4uLiLFozERFVXTwuEeljixORheTk5CAlJUVvmY2NDWrXrg0A2Lx5M9q3b4/nnnsO3333HU6cOIFVq1YBAIYOHYrZs2cjPDwcc+bMwZ07dzBp0iQMHz4cnp6eAIA5c+Zg/Pjx8PDwQK9evZCZmYnDhw9j0qRJln2hRERkFXhcIjIOgxORhezatQve3t56y5o0aYKLFy8CEEcW2rBhA9544w14e3vj+++/R/PmzQEAjo6O2L17NyZPnowOHTrA0dERAwcOxMKFC3X7Cg8Px6NHj7Bo0SJMnToVtWvXxmuvvWa5F0hERFaFxyUi48gEQRCkLoKoupPJZNi6dStCQkKkLoWIiIjHJSIDeI4TERERERFRKRiciIiIiIiISsGuekRERERERKVgixMREREREVEpGJyIiIiIiIhKweBERERERERUCgYnIiIiIiKiUjA4ERERERERlYLBiYiIiIiIqBQMTkRERERERKVgcCIiIiIiIioFgxMREREREVEp/h8F65P0hoMmOgAAAABJRU5ErkJggg==\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "y_pred = model.predict(valid_ds)\n",
        "\n",
        "# Get the true labels\n",
        "y_true = np.array(valid_labels)\n",
        "\n",
        "# Generate confusion matrix\n",
        "cm = confusion_matrix(y_true, np.argmax(y_pred, axis=1))\n",
        "\n",
        "# Print the confusion matrix\n",
        "print(cm)\n",
        "print(\"\")\n",
        "# Plot the confusion matrix\n",
        "plt.imshow(cm, cmap='Blues')\n",
        "plt.colorbar()\n",
        "plt.title('Confusion Matrix')\n",
        "plt.xlabel('Predicted Label')\n",
        "plt.ylabel('True Label')\n",
        "plt.show()\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 594
        },
        "id": "bhr9Ay3eNCWV",
        "outputId": "588cb33d-b1e6-462d-fefb-7496c1143185"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "24/24 [==============================] - 1s 36ms/step\n",
            "[[32 22 35 39 27]\n",
            " [31 28 27 29 26]\n",
            " [20 34 36 26 36]\n",
            " [38 27 32 22 28]\n",
            " [34 30 23 32 36]]\n",
            "\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 2 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        " def paths_to_dataset(audio_paths):\n",
        "    path_ds = tf.data.Dataset.from_tensor_slices(audio_paths)\n",
        "    return tf.data.Dataset.zip((path_ds))\n",
        "\n",
        "def predict(path, labels):\n",
        "    test = paths_and_labels_to_dataset(path, labels)\n",
        "\n",
        "\n",
        "    test = test.shuffle(buffer_size=batch_size * 8, seed=shuffle_seed).batch(\n",
        "    batch_size\n",
        "    )\n",
        "    test = test.prefetch(tf.data.experimental.AUTOTUNE)\n",
        "\n",
        "\n",
        "    test = test.map(lambda x, y: (add_noise(x, noises, scale=scale), y))\n",
        "\n",
        "    for audios, labels in test.take(1):\n",
        "        ffts = audio_to_fft(audios)\n",
        "        y_pred = model.predict(ffts)\n",
        "        rnd = np.random.randint(0, 1, 1)\n",
        "        audios = audios.numpy()[rnd, :]\n",
        "        labels = labels.numpy()[rnd]\n",
        "        y_pred = np.argmax(y_pred, axis=-1)[rnd]\n",
        "\n",
        "    for index in range(1):\n",
        "            print(\n",
        "            \"Speaker:\\33{} {}\\33[0m\\tPredicted:\\33{} {}\\33[0m\".format(\n",
        "            \"[92m\",y_pred[index],\n",
        "                \"[92m\", y_pred[index]\n",
        "                )\n",
        "            )\n",
        "\n",
        "            print(\"Speaker Predicted:\",class_names[y_pred[index]])"
      ],
      "metadata": {
        "id": "Z4H3gf3nMB0F"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "path = [\"../input/speaker-recognition-dataset/16000_pcm_speeches/Jens_Stoltenberg/1013.wav\"]\n",
        "labels = [\"unknown\"]\n",
        "try:\n",
        "    predict(path, labels)\n",
        "except:\n",
        "    print(\"Error! Check if the file correctly passed or not!\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "3iH1MX02MDo5",
        "outputId": "112c13b5-b46c-4067-8169-51c580d54822"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "1/1 [==============================] - 0s 348ms/step\n",
            "Speaker:\u001b[92m 2\u001b[0m\tPredicted:\u001b[92m 2\u001b[0m\n",
            "Speaker Predicted: Jens_Stoltenberg\n"
          ]
        }
      ]
    }
  ]
}