morse-decoder-detector-dl.ipynb

{
 "metadata": {
  "kernelspec": {
   "name": "python3",
   "display_name": "Python 3",
   "language": "python"
  },
  "language_info": {
   "name": "python",
   "version": "3.10.13",
   "mimetype": "text/x-python",
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "pygments_lexer": "ipython3",
   "nbconvert_exporter": "python",
   "file_extension": ".py"
  },
  "colab": {
   "provenance": [],
   "gpuType": "T4",
   "toc_visible": true
  },
  "accelerator": "GPU",
  "kaggle": {
   "accelerator": "gpu",
   "dataSources": [
    {
     "sourceId": 7969221,
     "sourceType": "datasetVersion",
     "datasetId": 4689038
    }
   ],
   "dockerImageVersionId": 30674,
   "isInternetEnabled": true,
   "language": "python",
   "sourceType": "notebook",
   "isGpuEnabled": true
  }
 },
 "nbformat_minor": 5,
 "nbformat": 4,
 "cells": [
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "![](assets/demo_output_cropped.png) ",
   "id": "eec962f53602f4a9"
  },
  {
   "cell_type": "markdown",
   "source": [
    "# ECE 046211 - Technion - Deep Learning\n",
    "\n",
    "## Project - DSP in Deep Learning – CW (carrier wave) Detector + Decoder"
   ],
   "metadata": {
    "collapsed": false
   },
   "id": "2133a2c652acd009"
  },
  {
   "cell_type": "markdown",
   "source": [
    "<img src=\"https://img.icons8.com/bubbles/50/000000/upload-to-cloud.png\" style=\"height:50px;display:inline\">\n",
    "\n",
    "### Summary\n",
    "\n",
    "---\n",
    "* **General**\n",
    "    * Implementation in pytorch\n",
    "    * Digital signal processing from scratch\n",
    "    * Generating training samples (morse signals -> spectrogram) on-the-fly with various hyperparameters\n",
    "    * Morse signals varies in **pitch** (main frequency), **length** (number of chars), **signal amplitude**, noise amplitude (**SNR** [dB]), morse **dit\\dah length**\n",
    "    * Used **TensorBoard** for local training tracking\n",
    "    \n",
    "* **Part 1: LSTM-RNN morse decoder**\n",
    "    * input: spectrogram [shape: (dynamic, 21)] + target string, output: string\n",
    "    * Model size: 740,395 parameters\n",
    "    * trained on ~50,000,000 morse chars\n",
    "    * Average CER (Character Error Rate) <2% on SNR above -5dB\n",
    "    * loss function: CTCLoss\n",
    "        * The Connectionist Temporal Classification loss. Calculates loss between a continuous (unsegmented) time series and a target sequence.\n",
    "    * Train loss: 0.15\n",
    "    * Fixed vs Dynamic pitch (main frequency) - Model training on fixed frequency performed better in evaluation\n",
    "       \n",
    "* **Part 2: FASTER RCNN (resnet50) morse object detection**\n",
    "    * input: spectrogram [shape: (dynamic, 21)] , output: bounding box, scores, labels\n",
    "    * Bounding box prediction\n",
    "    * Trained on ~1,000,000 spectrogram's\n",
    "    * Model size:\n",
    "        * Total number of parameters: 41,299,161\n",
    "        * Number of trainable parameters: 41,076,761\n",
    "    * Accuracy: IoU-x axis 97%\n",
    "    * loss function: [RPN Loss Function](https://towardsdatascience.com/review-faster-r-cnn-object-detection-f5685cb30202), combines:\n",
    "        * classification loss over 2 classes\n",
    "        * regression loss of bounding boxes\n",
    "    * Train loss: 0.12, Validation loss: 0.3  "
   ],
   "metadata": {
    "collapsed": false
   },
   "id": "702007b2bcf0c8c1"
  },
  {
   "cell_type": "markdown",
   "source": [
    "<img src=\"https://img.icons8.com/bubbles/50/000000/information.png\" style=\"height:50px;display:inline\">\n",
    "\n",
    "### Morse Code\n",
    "\n",
    "---\n",
    "\n",
    "Morse code is a method of transmitting text information using a series of short and long signals, called \"dits\" and \"dahs\" respectively. The basic unit of time measurement in Morse code is the \"dit,\" and the \"dah\" is equal to three dits in duration. The spacing between dits and dahs within a character is equal to one dit. The spacing between characters within a word is equal to three dits, and the spacing between words is equal to seven dits.\n",
    "\n",
    "Here's an image that illustrates the structure of Morse code:\n",
    "\n",
    "<img src=\"assets/International_Morse_Code.png\" style=\"height: 200px;\"/>\n",
    "\n",
    "The image shows the relative timing of dits, dahs, and the spacing between them. As you can see, a \"dah\" is three times longer than a \"dit,\" and the spacing within a character is one dit, between characters is three dits, and between words is seven dits.\n",
    "\n",
    "For example, the letter \"A\" is represented by \".-\" in Morse code, which corresponds to a dit (left) followed by a dah (right). The letter \"Q\" is represented by \"--.-\", which corresponds to two dahs (right, right), a dit (left), and a dah (right)."
   ],
   "metadata": {
    "collapsed": false
   },
   "id": "ec9902b7e0ed1bff"
  },
  {
   "cell_type": "markdown",
   "source": [
    "# Imports"
   ],
   "metadata": {
    "id": "54d4435245ddac68"
   },
   "id": "2e74b85322dde4cf"
  },
  {
   "cell_type": "code",
   "source": [
    "import numpy as np\n",
    "from scipy.io import wavfile\n",
    "from IPython.display import Audio\n",
    "import logging\n",
    "import sys\n",
    "from scipy import signal\n",
    "import torch\n",
    "import os\n",
    "from torch.utils.tensorboard import SummaryWriter\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "import torch.optim as optim\n",
    "from torch.utils import data\n",
    "from itertools import groupby\n",
    "# !pip install Levenshtein # uncomment in Colab\n",
    "from Levenshtein import distance\n",
    "import matplotlib.patches as patches\n",
    "import torchvision\n",
    "from torchvision.models.detection.faster_rcnn import FastRCNNPredictor\n",
    "from tqdm import tqdm\n",
    "from matplotlib import pyplot as plt\n",
    "import pickle\n",
    "import random\n",
    "import warnings\n",
    "\n",
    "# Configs\n",
    "logging.basicConfig(\n",
    "    format='%(asctime)s [%(levelname)s] %(name)s - %(message)s',\n",
    "    level=logging.DEBUG,\n",
    "    datefmt='%Y-%m-%d %H:%M:%S',\n",
    "    stream=sys.stdout,\n",
    ")\n",
    "log = logging.getLogger('')\n",
    "logging.getLogger(\"matplotlib\").setLevel(logging.INFO)\n",
    "logging.getLogger(\"librosa\").setLevel(logging.INFO)\n",
    "warnings.filterwarnings(\"ignore\", message=\".*complex*\")\n",
    "\n",
    "%load_ext tensorboard"
   ],
   "metadata": {
    "id": "98c30cc252db74b0",
    "execution": {
     "iopub.status.busy": "2024-03-28T20:20:14.656648Z",
     "iopub.execute_input": "2024-03-28T20:20:14.657601Z",
     "iopub.status.idle": "2024-03-28T20:20:14.671189Z",
     "shell.execute_reply.started": "2024-03-28T20:20:14.657564Z",
     "shell.execute_reply": "2024-03-28T20:20:14.670322Z"
    },
    "trusted": true,
    "ExecuteTime": {
     "end_time": "2024-04-02T07:02:23.338707Z",
     "start_time": "2024-04-02T07:02:07.359675Z"
    }
   },
   "id": "c2dd0c1c27e8e1d1",
   "outputs": [],
   "execution_count": 1
  },
  {
   "metadata": {},
   "cell_type": "code",
   "outputs": [],
   "execution_count": null,
   "source": "",
   "id": "24a52dd5e6caf2d1"
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-04-10T10:22:20.289945Z",
     "start_time": "2024-04-10T10:22:20.266938Z"
    }
   },
   "cell_type": "code",
   "source": [
    "from torchmetrics.text import CharErrorRate\n",
    "preds = [\"bright\"]\n",
    "target = [\"buy_it\"]\n",
    "cer = CharErrorRate()\n",
    "cer(preds, target)"
   ],
   "id": "ac997bbcf92a8cde",
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor(0.6667)"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 4
  },
  {
   "cell_type": "markdown",
   "source": [
    "# Morse"
   ],
   "metadata": {
    "id": "f927a219b95d36a6"
   },
   "id": "e5b015734e36f24f"
  },
  {
   "cell_type": "markdown",
   "source": [
    "## Morse Utils"
   ],
   "metadata": {
    "id": "77db0b15a2d56e44"
   },
   "id": "f6beae8cce1ac2c0"
  },
  {
   "cell_type": "code",
   "source": [
    "MORSE_CODE_DICT = {\n",
    "    'A': '.-',\n",
    "    'B': '-...',\n",
    "    'C': '-.-.', \n",
    "    'D': '-..',\n",
    "    'E': '.',\n",
    "    'F': '..-.',\n",
    "    'G': '--.',\n",
    "    'H': '....',\n",
    "    'I': '..',\n",
    "    'J': '.---',\n",
    "    'K': '-.-',\n",
    "    'L': '.-..',\n",
    "    'M': '--',\n",
    "    'N': '-.',\n",
    "    'O': '---',\n",
    "    'P': '.--.',\n",
    "    'Q': '--.-',\n",
    "    'R': '.-.',\n",
    "    'S': '...',\n",
    "    'T': '-',\n",
    "    'U': '..-',\n",
    "    'V': '...-',\n",
    "    'W': '.--',\n",
    "    'X': '-..-',\n",
    "    'Y': '-.--',\n",
    "    'Z': '--..',\n",
    "    '1': '.----',\n",
    "    '2': '..---',\n",
    "    '3': '...--',\n",
    "    '4': '....-',\n",
    "    '5': '.....',\n",
    "    '6': '-....',\n",
    "    '7': '--...',\n",
    "    '8': '---..',\n",
    "    '9': '----.',\n",
    "    '0': '-----',\n",
    "    '.': '.-.-.-',\n",
    "    ',': '--..--',\n",
    "    '?': '..--..',\n",
    "    '=': '-...-',\n",
    "    '+': '.-.-.',\n",
    "}\n",
    "ALPHABET = \" \" + \"\".join(MORSE_CODE_DICT.keys())\n",
    "num_tags = len(ALPHABET)\n",
    "sr = 2000 # sample rate, affect spectrum size\n",
    "\n",
    "def get_spectrogram(samples, sr):\n",
    "    \"\"\"\n",
    "    Calculate the spectrogram of a time series signal with sample rate sr\n",
    "    :param samples: time domain signal\n",
    "    :param sr: sample rate\n",
    "    :return: \n",
    "    \"\"\"\n",
    "    _, _, sxx = signal.spectrogram(samples, nperseg=int(0.02 * sr) , noverlap=0)\n",
    "    return sxx\n",
    "\n",
    "\n",
    "def aggregate_cer(prev_cer, prev_total_chars, y, y_pred):\n",
    "    \"\"\"\n",
    "    Calculate new CER (Character Error Rate) given previous CER and new data points [y, y_pred]\n",
    "    :param prev_cer: previous CER, from .0 to 1.0\n",
    "    :param prev_total_chars: total chars (int)\n",
    "    :param y: series of chars (tokens)\n",
    "    :param y_pred: target chars\n",
    "    :return: new CER\n",
    "    \"\"\"\n",
    "    new_cer = prev_cer\n",
    "    new_total_chars = prev_total_chars\n",
    "\n",
    "    for i in range(len(y)):\n",
    "        a = prediction_to_str(y[i])\n",
    "        b = prediction_to_str(torch.argmax(y_pred[i], 1))\n",
    "        new_cer = calculate_levenshtein_distance(new_cer, new_total_chars, a, b)\n",
    "        new_total_chars += max(len(a), len(b))\n",
    "\n",
    "    return new_cer, new_total_chars\n",
    "\n",
    "\n",
    "def calculate_levenshtein_distance(prev_cer, prev_total_chars, original, predicted):\n",
    "    \"\"\"\n",
    "    Calculate CER based on Levenshtein distance\n",
    "    :param prev_cer: 0.0 to 1.0\n",
    "    :param prev_total_chars: int\n",
    "    :param original: target string\n",
    "    :param predicted: predicted string\n",
    "    :return: \n",
    "    \"\"\"\n",
    "    d = distance(original, predicted)\n",
    "    new_total_chars = prev_total_chars + max(len(original), len(predicted))\n",
    "\n",
    "    return (prev_cer * prev_total_chars + d) / new_total_chars\n",
    "\n",
    "\n",
    "def calculate_cer(prev_cer, prev_total_chars, original, predicted):\n",
    "    \"\"\"\n",
    "    Computes the Character Error Rate (CER) between the original and predicted strings\n",
    "    :param prev_cer: \n",
    "    :param prev_total_chars: \n",
    "    :param original: \n",
    "    :param predicted: \n",
    "    :return: new CER\n",
    "    \"\"\"\n",
    "    # Convert strings to lists of characters\n",
    "    original_chars = list(original)\n",
    "    predicted_chars = list(predicted)\n",
    "\n",
    "    # Get the length of the longer string\n",
    "    max_length = max(len(original_chars), len(predicted_chars))\n",
    "\n",
    "    # Initialize counters\n",
    "    errors = 0\n",
    "\n",
    "    # Iterate over the characters and count errors\n",
    "    for i in range(max_length):\n",
    "        try:\n",
    "            if original_chars[i] != predicted_chars[i]:\n",
    "                errors += 1\n",
    "        except IndexError:\n",
    "            # If the string is shorter, consider the remaining characters as errors\n",
    "            errors += 1\n",
    "\n",
    "    if errors > 0:\n",
    "        log.error(original, predicted, errors)\n",
    "\n",
    "    return (prev_cer * prev_total_chars + errors) / (prev_total_chars + max_length)\n",
    "\n",
    "def find_one_first_element(ndarrays):\n",
    "    \"\"\"\n",
    "    Find the first and last array that contains ones (bounding the activity in a spectrogram)\n",
    "    :param ndarrays: spectrogram\n",
    "    :return: \n",
    "    \"\"\"\n",
    "    first_index = -1\n",
    "    last_index = -1\n",
    "    for i, arr in enumerate(ndarrays):\n",
    "        if arr[0] == 1:\n",
    "            if first_index == -1:\n",
    "                first_index = i\n",
    "            last_index = i\n",
    "    return first_index, last_index\n",
    "\n",
    "\n",
    "def accumulated_length(array_list, start_index, end_index):\n",
    "    \"\"\"\n",
    "    Given a list of time-series values (represents morse chars), return the accumulated length in the time domain\n",
    "    :param array_list: \n",
    "    :param start_index: \n",
    "    :param end_index: \n",
    "    :return: \n",
    "    \"\"\"\n",
    "    acc_length_start = 0\n",
    "    for i in range(start_index):\n",
    "        acc_length_start += len(array_list[i])\n",
    "\n",
    "    acc_length_end = acc_length_start\n",
    "    for i in range(start_index, end_index + 1):\n",
    "        acc_length_end += len(array_list[i])\n",
    "\n",
    "    return acc_length_start, acc_length_end\n",
    "\n",
    "\n",
    "def get_signal_bbx(signal_array, spec_time_len, signal_len, pitch):\n",
    "    \"\"\"\n",
    "    Get signal boundary box\n",
    "    :param signal_array:\n",
    "    :param spec_time_len:\n",
    "    :param signal_len:\n",
    "    :return: x_start, y_start, x_end, y_end\n",
    "    \"\"\"\n",
    "    activity_array_start_idx, activity_array_end_idx = find_one_first_element(signal_array)\n",
    "    time_domain_start_idx, time_domain_end_idx = accumulated_length(signal_array, activity_array_start_idx,\n",
    "                                                                    activity_array_end_idx)\n",
    "    alpha = signal_len // spec_time_len\n",
    "    bbx_idx_start_x = time_domain_start_idx // alpha\n",
    "    bbx_idx_end_x = time_domain_end_idx // alpha\n",
    "\n",
    "    main_freq_idx = pitch*2 // 100\n",
    "    return bbx_idx_start_x, main_freq_idx, bbx_idx_end_x, main_freq_idx+1\n",
    "\n",
    "\n",
    "def apply_noise_to_signal(signal, SNRdb):\n",
    "    \"\"\"\n",
    "    Apply noise to signal\n",
    "    :param signal: \n",
    "    :param SNRdb: specific SNR (Signal to Noise ratio)\n",
    "    :return: \n",
    "    \"\"\"\n",
    "    signal_power = np.mean(abs(signal ** 2))\n",
    "    sigma2 = signal_power * 10 ** (-SNRdb / 10)  # calculate noise power based on signal power and SNR\n",
    "    noise = np.sqrt(sigma2 / 2) * (np.random.randn(*signal.shape) + 1j * np.random.randn(*signal.shape))\n",
    "    return signal + noise\n",
    "\n",
    "def get_dot(ref, apply_random_length_dots):\n",
    "    if apply_random_length_dots:\n",
    "        scale = np.clip(np.random.normal(1, 0.2), 0.5, 2.0)\n",
    "        return int(ref * scale)\n",
    "    else:\n",
    "        return int(ref)\n",
    "\n",
    "def get_dash(ref, apply_random_length_dots):\n",
    "    if apply_random_length_dots:\n",
    "        scale = np.clip(np.random.normal(1, 0.2), 0.5, 2.0)\n",
    "        return int(3 * ref * scale)\n",
    "    else:\n",
    "        return int(3 * ref)\n"
   ],
   "metadata": {
    "id": "a6b6140ecf98869d",
    "execution": {
     "iopub.status.busy": "2024-03-28T22:59:41.849626Z",
     "iopub.execute_input": "2024-03-28T22:59:41.850500Z",
     "iopub.status.idle": "2024-03-28T22:59:41.872340Z",
     "shell.execute_reply.started": "2024-03-28T22:59:41.850470Z",
     "shell.execute_reply": "2024-03-28T22:59:41.871411Z"
    },
    "trusted": true,
    "ExecuteTime": {
     "end_time": "2024-04-02T07:02:41.448155Z",
     "start_time": "2024-04-02T07:02:41.413336Z"
    }
   },
   "id": "c63ab2923004d52",
   "outputs": [],
   "execution_count": 3
  },
  {
   "cell_type": "markdown",
   "source": [
    "## Morse Generator"
   ],
   "metadata": {
    "id": "3975c073629dba46"
   },
   "id": "969687db1be978b0"
  },
  {
   "cell_type": "code",
   "source": [
    "def generate_morse_sample(sr=2000, text_len=10, pitch=950, wpm=18, snrDB=1, amplitude=100, s=None, apply_random_length_dots = True):\n",
    "    \"\"\"\n",
    "    Generate morse sample\n",
    "    :param apply_random_length_dots: \n",
    "    :param sr: \n",
    "    :param text_len: \n",
    "    :param pitch: \n",
    "    :param wpm: \n",
    "    :param snrDB: \n",
    "    :param amplitude: \n",
    "    :param s: specific string\n",
    "    :return: <time domain signal, frequency domain spectrogram, morse string, spectrogram bounding box>\n",
    "    \"\"\"\n",
    "    assert pitch < sr / 2  # Nyquist\n",
    "\n",
    "    # Common morse spacing [https://en.wikipedia.org/wiki/Morse_code]\n",
    "    ref = (60 / wpm) / 50 * sr\n",
    "\n",
    "    # Create random string that doesn't start or end with a space\n",
    "    if s is None:\n",
    "        s1 = ''.join(random.choices(ALPHABET, k=text_len - 2))\n",
    "        s2 = ''.join(random.choices(ALPHABET[1:], k=2))\n",
    "        s = s2[0] + s1 + s2[1]\n",
    "\n",
    "    time_domain_signal = []\n",
    "    time_domain_signal.append(np.zeros(5 * get_dot(ref, apply_random_length_dots)))\n",
    "\n",
    "    # dat\\dit space = 1 dot, char space = 3 dots, word space = 7 dots\n",
    "    for c in s:\n",
    "        if c == ' ':\n",
    "            time_domain_signal.append(np.zeros(7 * get_dot(ref, apply_random_length_dots)))\n",
    "        else:\n",
    "            for m in MORSE_CODE_DICT[c]:\n",
    "                if m == '.':\n",
    "                    time_domain_signal.append(np.ones(get_dot(ref, apply_random_length_dots)))\n",
    "                    time_domain_signal.append(np.zeros(get_dot(ref, apply_random_length_dots)))\n",
    "                elif m == '-':\n",
    "                    time_domain_signal.append(np.ones(get_dash(ref, apply_random_length_dots)))\n",
    "                    time_domain_signal.append(np.zeros(get_dot(ref,apply_random_length_dots)))\n",
    "\n",
    "            time_domain_signal.append(np.zeros(2 * get_dot(ref, apply_random_length_dots)))\n",
    "\n",
    "    time_domain_signal.append(np.zeros(5 * get_dot(ref, apply_random_length_dots)))\n",
    "    time_domain_signal_ = time_domain_signal.copy()\n",
    "    time_domain_signal = np.hstack(time_domain_signal)\n",
    "\n",
    "    # Modulation\n",
    "    t = np.arange(len(time_domain_signal)) / sr\n",
    "    sine = np.sin(2 * np.pi * t * pitch)\n",
    "    time_domain_signal = sine * time_domain_signal\n",
    "\n",
    "    # Add noise\n",
    "    time_domain_signal = apply_noise_to_signal(time_domain_signal, snrDB)\n",
    "    time_domain_signal *= amplitude / 100\n",
    "    time_domain_signal = np.clip(time_domain_signal, -1, 1)\n",
    "    time_domain_signal = time_domain_signal.astype(np.float32)\n",
    "\n",
    "    # calculate spectrum\n",
    "    spec = get_spectrogram(time_domain_signal, sr=sr)\n",
    "\n",
    "    # calculate spec boundaries\n",
    "    bbx = get_signal_bbx(time_domain_signal_, spec.shape[1], len(time_domain_signal), pitch)\n",
    "\n",
    "    return time_domain_signal, spec, s, bbx"
   ],
   "metadata": {
    "id": "7a24cbc9a2fe62a8",
    "execution": {
     "iopub.status.busy": "2024-03-28T22:57:46.134626Z",
     "iopub.execute_input": "2024-03-28T22:57:46.135262Z",
     "iopub.status.idle": "2024-03-28T22:57:46.150745Z",
     "shell.execute_reply.started": "2024-03-28T22:57:46.135230Z",
     "shell.execute_reply": "2024-03-28T22:57:46.149850Z"
    },
    "trusted": true,
    "ExecuteTime": {
     "end_time": "2024-04-02T07:02:46.359428Z",
     "start_time": "2024-04-02T07:02:46.335387Z"
    }
   },
   "id": "44a8ff173cb2e22f",
   "outputs": [],
   "execution_count": 4
  },
  {
   "cell_type": "markdown",
   "source": [
    "## Example generating 1 signal"
   ],
   "metadata": {
    "id": "84904b9ba97beea0"
   },
   "id": "53d914f5ad1ce270"
  },
  {
   "cell_type": "code",
   "source": [
    "# Params\n",
    "sr = 2000\n",
    "length = random.randrange(1, 8)\n",
    "pitch = random.randint(2, 19) * 50\n",
    "wpm = 18\n",
    "snrDB = random.randrange(-10, 10)\n",
    "amplitude = random.randrange(50, 200)\n",
    "\n",
    "time_domain_signal, spec, y, bbx = generate_morse_sample(sr, length, pitch, wpm, snrDB, amplitude, \"YOUTUBE\")\n",
    "log.info(f\"pitch: {pitch}, wpm: {wpm}, snrDB: {snrDB}, amplitude: {amplitude}, str: {y}, bbx: {bbx}\")\n",
    "\n",
    "# Display spectrogram\n",
    "min_value = np.min(spec)\n",
    "max_value = np.max(spec)\n",
    "normalized_spectrum = (spec - min_value) / (max_value - min_value)\n",
    "\n",
    "fig, ax = plt.subplots(1, figsize=(16, 8))\n",
    "plt.pcolormesh(normalized_spectrum)\n",
    "# rect = patches.Rectangle(\n",
    "#     (bbx[0], bbx[1]),\n",
    "#     bbx[2]-bbx[0],\n",
    "#     bbx[3]-bbx[1],\n",
    "#     linewidth=4,\n",
    "#     edgecolor='red',\n",
    "#     facecolor=\"none\",\n",
    "# )\n",
    "# # Add the patch to the Axes\n",
    "# ax.add_patch(rect)\n",
    "# plt.text(\n",
    "#     bbx[0], bbx[1],\n",
    "#     s=y + '| morse' + \" \" + str(int(100*1)) + \"%\",\n",
    "#     color=\"white\",\n",
    "#     fontsize=16,\n",
    "#     verticalalignment=\"top\",\n",
    "#     bbox={\"color\": 'red', \"pad\": 0},\n",
    "# )\n",
    "plt.show()\n",
    "\n",
    "# Save file\n",
    "filename = f'./assets/test.wav'\n",
    "time_domain_signal = np.int16(time_domain_signal / np.max(np.abs(time_domain_signal)) * 32000)\n",
    "wavfile.write(filename, sr, time_domain_signal)\n",
    "Audio(filename)"
   ],
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 702
    },
    "id": "48d8e89e0790b22",
    "outputId": "713fde84-077e-4c26-d6e9-e9dcdfd18a6c",
    "execution": {
     "iopub.status.busy": "2024-03-28T21:38:02.621788Z",
     "iopub.execute_input": "2024-03-28T21:38:02.622877Z",
     "iopub.status.idle": "2024-03-28T21:38:02.852546Z",
     "shell.execute_reply.started": "2024-03-28T21:38:02.622834Z",
     "shell.execute_reply": "2024-03-28T21:38:02.851562Z"
    },
    "trusted": true,
    "ExecuteTime": {
     "end_time": "2024-04-02T13:29:10.238673Z",
     "start_time": "2024-04-02T13:29:10.110451Z"
    }
   },
   "id": "bec109a4c16e7b67",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2024-04-02 16:29:10 [INFO] root - pitch: 100, wpm: 18, snrDB: -7, amplitude: 187, str: YOUTUBE, bbx: (19, 2, 234, 3)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 1600x800 with 1 Axes>"
      ],
      "image/png": "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\n"
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<IPython.lib.display.Audio object>"
      ],
      "text/html": [
       "\n",
       "                <audio  controls=\"controls\" >\n",
       "                    <source src=\"data:audio/wav;base64,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\" type=\"audio/wav\" />\n",
       "                    Your browser does not support the audio element.\n",
       "                </audio>\n",
       "              "
      ]
     },
     "execution_count": 230,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 230
  },
  {
   "cell_type": "markdown",
   "source": [
    "# Models"
   ],
   "metadata": {
    "collapsed": false
   },
   "id": "cade18711f007db7"
  },
  {
   "cell_type": "markdown",
   "source": [
    "## Decoder: LSTM RNN\n",
    "\n",
    "Long Short-Term Memory (LSTM) is a type of Recurrent Neural Network (RNN) architecture that has been widely used for sequence-to-sequence tasks, such as machine translation, speech recognition, and, in our case, decoding Morse code from a spectrogram.\n",
    "\n",
    "**Spectrogram Representation**\n",
    "\n",
    "Before feeding the data into the LSTM, we need to represent the Morse code signal as a spectrogram. A spectrogram is a visual representation of the spectrum of frequencies in a signal as they vary with time. It is a 2D image-like representation, where the x-axis represents time, the y-axis represents frequency, and the intensity of each pixel represents the energy or amplitude of the signal at that particular time and frequency.\n",
    "\n",
    "**LSTM Architecture**\n",
    "\n",
    "The LSTM network is designed to process sequential data, such as the spectrogram representation of Morse code. It consists of a series of interconnected memory cells, which are capable of maintaining and updating their internal state over time. This allows the LSTM to selectively remember or forget information from previous time steps, making it well-suited for tasks that require long-term dependencies.\n",
    "\n",
    "Our LSTM architecture typically consists of the following components:\n",
    "\n",
    "1. **Input Layer**: This layer receives the input data, which in our case is the spectrogram of the Morse code signal.\n",
    "2. 3 More **Dense Layers**\n",
    "3. Dropuout Layer after most of the Dense Layers\n",
    "2. **LSTM Layer**: One LSTM layer to process the input sequence\n",
    "4. **Output Layer**: The final layer produces the predicted output sequence, which is the decoded text.\n",
    "\n",
    "**Training and Decoding**\n",
    "\n",
    "During training, the LSTM network is fed with pairs of spectrogram representations and their corresponding text transcriptions. The network learns to map the input spectrograms to the correct text sequences by adjusting its weights and biases through backpropagation and optimization algorithms like stochastic gradient descent.\n",
    "\n",
    "During decoding (inference), the trained LSTM model takes a new spectrogram as input and generates the predicted text sequence by iteratively processing the input and updating its internal state. Techniques like beam search or greedy decoding can be employed to find the most likely text sequence given the input spectrogram.\n",
    "\n",
    "**Advantages of LSTM for Morse Code Decoding**\n",
    "\n",
    "LSTM networks are well-suited for decoding Morse code from spectrograms due to the following reasons:\n",
    "\n",
    "1. **Sequence Processing**: LSTM can handle variable-length input sequences, making it suitable for processing Morse code signals of different durations.\n",
    "2. **Long-Term Dependencies**: LSTM can capture long-term dependencies in the input data, which is important for correctly decoding Morse code characters that may be separated by various timing gaps.\n",
    "3. **Robustness to Noise**: LSTM networks can learn to be robust to noise and variations in the input data, which is crucial for decoding Morse code signals that may be corrupted by environmental factors or imperfect transmission.\n",
    "\n",
    "Overall, the LSTM architecture, combined with the spectrogram representation of Morse code signals, provides a powerful and effective approach for decoding Morse code sequences from audio or radio signals.\n"
   ],
   "metadata": {
    "collapsed": false
   },
   "id": "8d59d51a8960dc70"
  },
  {
   "cell_type": "markdown",
   "source": [
    "### Tokenizer"
   ],
   "metadata": {
    "id": "c95f2cc5f7c41689"
   },
   "id": "b726325126356b6d"
  },
  {
   "cell_type": "code",
   "source": [
    "# 0: blank label\n",
    "tag_to_idx = {c: i + 1 for i, c in enumerate(ALPHABET)}\n",
    "idx_to_tag = {i + 1: c for i, c in enumerate(ALPHABET)}"
   ],
   "metadata": {
    "id": "f7aae072e7218ba4",
    "execution": {
     "iopub.status.busy": "2024-03-28T20:21:48.207236Z",
     "iopub.execute_input": "2024-03-28T20:21:48.207968Z",
     "iopub.status.idle": "2024-03-28T20:21:48.212709Z",
     "shell.execute_reply.started": "2024-03-28T20:21:48.207937Z",
     "shell.execute_reply": "2024-03-28T20:21:48.211659Z"
    },
    "trusted": true,
    "ExecuteTime": {
     "end_time": "2024-04-02T07:03:08.383451Z",
     "start_time": "2024-04-02T07:03:08.366910Z"
    }
   },
   "id": "b1d124518fa7e9fb",
   "outputs": [],
   "execution_count": 11
  },
  {
   "cell_type": "markdown",
   "source": [
    "### Utils"
   ],
   "metadata": {
    "id": "8f256aed3e7b1f67"
   },
   "id": "665344c1f576bc68"
  },
  {
   "cell_type": "code",
   "source": [
    "def prediction_to_str(seq):\n",
    "    \"\"\"\n",
    "    LSTM tokenize output to string\n",
    "    :param seq: \n",
    "    :return: predicted utf-8 string\n",
    "    \"\"\"\n",
    "    if not isinstance(seq, list):\n",
    "        seq = seq.tolist()\n",
    "\n",
    "    seq = [i[0] for i in groupby(seq)]  # remove duplicates\n",
    "    seq = [s for s in seq if s != 0]  # remove blanks\n",
    "    seq = \"\".join(idx_to_tag[c] for c in seq)  # convert to string\n",
    "    seq = seq.rstrip()\n",
    "\n",
    "    return seq\n",
    "\n",
    "\n",
    "def get_training_sample(*args, **kwargs):\n",
    "    \"\"\"\n",
    "    Generate training morse sample\n",
    "    :param args: \n",
    "    :param kwargs: \n",
    "    :return: <spectrogram, tokenized target string>\n",
    "    \"\"\"\n",
    "    _, spec, y, _ = generate_morse_sample(*args, **kwargs)\n",
    "\n",
    "    spec = torch.from_numpy(spec)\n",
    "    spec = spec.permute(1, 0)\n",
    "\n",
    "    y_tags = [tag_to_idx[c] for c in y]\n",
    "    y_tags = torch.tensor(y_tags)\n",
    "\n",
    "    return spec, y_tags\n",
    "\n",
    "\n",
    "def collate_fn_pad(batch):\n",
    "    \"\"\"\n",
    "    Batching helper\n",
    "    :param batch: \n",
    "    :return: \n",
    "    \"\"\"\n",
    "    xs, ys = zip(*batch)\n",
    "\n",
    "    input_lengths = torch.tensor([t.shape[0] for t in xs])\n",
    "    output_lengths = torch.tensor([t.shape[0] for t in ys])\n",
    "\n",
    "    seqs = nn.utils.rnn.pad_sequence(xs, batch_first=True)\n",
    "    ys = nn.utils.rnn.pad_sequence(ys, batch_first=True)\n",
    "\n",
    "    return input_lengths, output_lengths, seqs, ys"
   ],
   "metadata": {
    "id": "e03c2cc147b30235",
    "execution": {
     "iopub.status.busy": "2024-03-28T20:21:50.098168Z",
     "iopub.execute_input": "2024-03-28T20:21:50.098967Z",
     "iopub.status.idle": "2024-03-28T20:21:50.108282Z",
     "shell.execute_reply.started": "2024-03-28T20:21:50.098938Z",
     "shell.execute_reply": "2024-03-28T20:21:50.107434Z"
    },
    "trusted": true,
    "ExecuteTime": {
     "end_time": "2024-04-02T07:03:09.840571Z",
     "start_time": "2024-04-02T07:03:09.817305Z"
    }
   },
   "id": "7cdf80104e2bdcc0",
   "outputs": [],
   "execution_count": 12
  },
  {
   "cell_type": "markdown",
   "source": [
    "### Model Architecture"
   ],
   "metadata": {
    "id": "7ec79507a88b908f"
   },
   "id": "6f7476ffe1da8181"
  },
  {
   "cell_type": "code",
   "source": [
    "class LSTMRnn(nn.Module):\n",
    "    def __init__(self, num_tags, spectrogram_size):\n",
    "        super(LSTMRnn, self).__init__()\n",
    "\n",
    "        num_tags = num_tags + 1  # 0: blank\n",
    "        hidden_dim = 256\n",
    "        lstm_dim1 = 256\n",
    "\n",
    "        self.dense1 = nn.Linear(spectrogram_size, hidden_dim)\n",
    "        self.dropout1 = nn.Dropout(0.1)\n",
    "        self.dense2 = nn.Linear(hidden_dim, hidden_dim)\n",
    "        self.dense3 = nn.Linear(hidden_dim, hidden_dim)\n",
    "        self.dropout2 = nn.Dropout(0.1)\n",
    "        self.dense4 = nn.Linear(hidden_dim, lstm_dim1)\n",
    "        self.lstm1 = nn.LSTM(lstm_dim1, lstm_dim1, batch_first=True)\n",
    "        self.dense5 = nn.Linear(lstm_dim1, num_tags)\n",
    "\n",
    "    def forward(self, x):\n",
    "        x = F.relu(self.dense1(x))\n",
    "        x = self.dropout1(x)\n",
    "        x = F.relu(self.dense2(x))\n",
    "        x = self.dropout2(x)\n",
    "        x = F.relu(self.dense3(x))\n",
    "        x = F.relu(self.dense4(x))\n",
    "        x, _ = self.lstm1(x)\n",
    "        x = self.dense5(x)\n",
    "        x = F.log_softmax(x, dim=2)\n",
    "        return x\n",
    "\n",
    "    def count_parameters(self):\n",
    "        return sum(p.numel() for p in self.parameters() if p.requires_grad)"
   ],
   "metadata": {
    "id": "526e82f9d4e1ff38",
    "ExecuteTime": {
     "end_time": "2024-04-02T07:03:11.906318Z",
     "start_time": "2024-04-02T07:03:11.892296Z"
    }
   },
   "id": "ce36626e74536d5a",
   "outputs": [],
   "execution_count": 13
  },
  {
   "cell_type": "markdown",
   "source": [
    "### Dataset"
   ],
   "metadata": {
    "collapsed": false
   },
   "id": "ca4de58e1f6af71a"
  },
  {
   "cell_type": "code",
   "source": [
    "class Dataset(data.Dataset):\n",
    "    \"\"\"\n",
    "    Custom PyTorch dataset for lstm morse decoder task\n",
    "    Generates data samples in runtime\n",
    "    \"\"\"\n",
    "    def __init__(self, number_of_samples=2048, sr=2000, explicit_snr=None):\n",
    "        self.length = number_of_samples\n",
    "        self.sr = sr\n",
    "        self.explicit_snr = explicit_snr\n",
    "\n",
    "    def __len__(self):\n",
    "        return self.length\n",
    "\n",
    "    def __getitem__(self, index):\n",
    "        length = random.randrange(10, 20)  # 10,20\n",
    "        pitch = 950\n",
    "        wpm = 18\n",
    "        amplitude = random.randrange(50, 200)\n",
    "        if self.explicit_snr != None:\n",
    "            snrDB = self.explicit_snr\n",
    "        else:\n",
    "            snrDB = random.randrange(-10, 10)\n",
    "            \n",
    "        return get_training_sample(self.sr, length, pitch, wpm, snrDB, amplitude, None, None)"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2024-04-01T06:35:37.384564Z",
     "start_time": "2024-04-01T06:35:37.380053Z"
    }
   },
   "id": "cbec4fc275815fb1",
   "outputs": [],
   "execution_count": 192
  },
  {
   "cell_type": "markdown",
   "source": [
    "### Training\n",
    "launch tensorboard with CLI\n",
    "tensorboard --logdir C:/Users/Maor/Desktop/dev/tensorboard/morse-dl/runs"
   ],
   "metadata": {
    "id": "b59204188012c80d"
   },
   "id": "840a60ba9c304866"
  },
  {
   "cell_type": "code",
   "source": [
    "tf_board_log_dir_path = \"C:/Users/Maor/Desktop/dev/tensorboard/morse-dl/runs\"  # path without hebrew unicode chars\n",
    "batch_size = 64\n",
    "spectrogram_size = generate_morse_sample(sr=2000)[1].shape[0]\n",
    "\n",
    "device = torch.device('cuda') if torch.cuda.is_available() else torch.device('cpu')\n",
    "writer = SummaryWriter(tf_board_log_dir_path)\n",
    "\n",
    "# Set up trainer & evaluator\n",
    "model = LSTMRnn(num_tags, spectrogram_size).to(device)\n",
    "log.info(\"Number of params\", model.count_parameters())\n",
    "\n",
    "# Lower learning rate to 1e-4 after about 1500 epochs\n",
    "optimizer = optim.Adam(model.parameters(), lr=0.001, betas=(0.9, 0.999))\n",
    "ctc_loss = nn.CTCLoss()\n",
    "\n",
    "train_loader = torch.utils.data.DataLoader(\n",
    "    Dataset(number_of_samples=2048),\n",
    "    batch_size=batch_size,\n",
    "    collate_fn=collate_fn_pad,\n",
    ")\n",
    "\n",
    "random.seed(0)\n",
    "\n",
    "# run_date = datetime.now().strftime(\"%Y-%m-%d_%H-%M-%S\")\n",
    "run_date = '2024-03-31_23-29-30'\n",
    "epoch = 1100\n",
    "epochs = epoch + 0\n",
    "losses = []\n",
    "\n",
    "# Resume training\n",
    "if epoch != 0:\n",
    "    model.load_state_dict(torch.load(f\"models/{run_date}_{epoch:06}.pt\", map_location=device))\n",
    "    # state_dict = torch.load(f\"models/{run_date}_{epoch:06}.pt\")\n",
    "    # model.dense1.weight = torch.nn.Parameter(state_dict[\"dense1.weight\"])\n",
    "    # model.dense1.bias = torch.nn.Parameter(state_dict[\"dense1.bias\"])\n",
    "    # model.dense2.weight = torch.nn.Parameter(state_dict[\"dense2.weight\"])\n",
    "    # model.dense2.bias = torch.nn.Parameter(state_dict[\"dense2.bias\"])\n",
    "    # model.dense3.weight = torch.nn.Parameter(state_dict[\"dense3.weight\"])\n",
    "    # model.dense3.bias = torch.nn.Parameter(state_dict[\"dense3.bias\"])\n",
    "    # model.dense4.weight = torch.nn.Parameter(state_dict[\"dense4.weight\"])\n",
    "    # model.dense4.bias = torch.nn.Parameter(state_dict[\"dense4.bias\"])\n",
    "    # model.dense5.weight = torch.nn.Parameter(state_dict[\"dense5.weight\"])\n",
    "    # model.dense5.bias = torch.nn.Parameter(state_dict[\"dense5.bias\"])\n",
    "    # model.lstm1.weight_ih_l0.data = torch.nn.Parameter(state_dict[\"lstm1.weight_ih_l0\"])\n",
    "    # model.lstm1.weight_hh_l0.data = torch.nn.Parameter(state_dict[\"lstm1.weight_hh_l0\"])\n",
    "    # model.lstm1.bias_ih_l0.data = torch.nn.Parameter(state_dict[\"lstm1.bias_ih_l0\"])\n",
    "    # model.lstm1.bias_hh_l0.data = torch.nn.Parameter(state_dict[\"lstm1.bias_hh_l0\"])\n",
    "    log.info(f'Model has been loaded from prev state of epoch: {epoch}')\n",
    "\n",
    "model.train()\n",
    "while epoch < epochs:\n",
    "    train_loss = 0\n",
    "    curr_cer = 1.0\n",
    "    total_chars = 0\n",
    "\n",
    "    for (input_lengths, output_lengths, x, y) in train_loader:\n",
    "        x, y = x.to(device), y.to(device)\n",
    "\n",
    "        optimizer.zero_grad()\n",
    "        # print(x.shape)\n",
    "        y_pred = model(x)\n",
    "\n",
    "        m = torch.argmax(y_pred[0], 1)\n",
    "        curr_cer, total_chars = aggregate_cer(curr_cer, total_chars, y, y_pred)\n",
    "        y_pred = y_pred.permute(1, 0, 2)\n",
    "\n",
    "        loss = ctc_loss(y_pred, y, input_lengths, output_lengths)\n",
    "        loss.backward()\n",
    "        optimizer.step()\n",
    "\n",
    "        train_loss += loss.item()\n",
    "\n",
    "    writer.add_scalar(f\"training/{run_date}_loss\", train_loss / len(train_loader), epoch)\n",
    "    writer.add_scalar(f\"training/{run_date}_lvstn\", curr_cer * 100, epoch)\n",
    "    if epoch % 10 == 0:\n",
    "        torch.save(model.state_dict(), f\"models/{run_date}_{epoch:06}.pt\")\n",
    "\n",
    "    losses.append(train_loss / len(train_loader))\n",
    "    log.info(\n",
    "        f'Epoch #{epoch}| (e.g. target: {prediction_to_str(y[0])}, pred: {prediction_to_str(m)}), loss: {loss.item():2f}, CER: {curr_cer * 100:1f}% on {total_chars} chars')\n",
    "    epoch += 1"
   ],
   "metadata": {
    "id": "11b47e23310bae3e",
    "outputId": "12a71227-f481-4b30-d407-50c87202c352",
    "ExecuteTime": {
     "end_time": "2024-04-01T06:28:53.402906Z",
     "start_time": "2024-04-01T06:28:53.331901Z"
    }
   },
   "id": "8dfc545e083e38c",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2024-04-01 09:28:53 [INFO] root - Model has been loaded from prev state of epoch: 1100\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\Maor\\AppData\\Local\\Temp\\ipykernel_31128\\3015226362.py:56: ComplexWarning: Casting complex values to real discards the imaginary part\n",
      "  time_domain_signal = time_domain_signal.astype(np.float32)\n",
      "--- Logging error ---\n",
      "Traceback (most recent call last):\n",
      "  File \"C:\\Users\\Maor\\AppData\\Local\\Programs\\Python\\Python39\\lib\\logging\\__init__.py\", line 1083, in emit\n",
      "    msg = self.format(record)\n",
      "  File \"C:\\Users\\Maor\\AppData\\Local\\Programs\\Python\\Python39\\lib\\logging\\__init__.py\", line 927, in format\n",
      "    return fmt.format(record)\n",
      "  File \"C:\\Users\\Maor\\AppData\\Local\\Programs\\Python\\Python39\\lib\\logging\\__init__.py\", line 663, in format\n",
      "    record.message = record.getMessage()\n",
      "  File \"C:\\Users\\Maor\\AppData\\Local\\Programs\\Python\\Python39\\lib\\logging\\__init__.py\", line 367, in getMessage\n",
      "    msg = msg % self.args\n",
      "TypeError: not all arguments converted during string formatting\n",
      "Call stack:\n",
      "  File \"C:\\Users\\Maor\\AppData\\Local\\Programs\\Python\\Python39\\lib\\runpy.py\", line 197, in _run_module_as_main\n",
      "    return _run_code(code, main_globals, None,\n",
      "  File \"C:\\Users\\Maor\\AppData\\Local\\Programs\\Python\\Python39\\lib\\runpy.py\", line 87, in _run_code\n",
      "    exec(code, run_globals)\n",
      "  File \"c:\\users\\maor\\appdata\\roaming\\jetbrains\\dataspell2021.3\\projects\\workspace\\venv\\lib\\site-packages\\ipykernel_launcher.py\", line 17, in <module>\n",
      "    app.launch_new_instance()\n",
      "  File \"c:\\users\\maor\\appdata\\roaming\\jetbrains\\dataspell2021.3\\projects\\workspace\\venv\\lib\\site-packages\\traitlets\\config\\application.py\", line 1043, in launch_instance\n",
      "    app.start()\n",
      "  File \"c:\\users\\maor\\appdata\\roaming\\jetbrains\\dataspell2021.3\\projects\\workspace\\venv\\lib\\site-packages\\ipykernel\\kernelapp.py\", line 725, in start\n",
      "    self.io_loop.start()\n",
      "  File \"c:\\users\\maor\\appdata\\roaming\\jetbrains\\dataspell2021.3\\projects\\workspace\\venv\\lib\\site-packages\\tornado\\platform\\asyncio.py\", line 215, in start\n",
      "    self.asyncio_loop.run_forever()\n",
      "  File \"C:\\Users\\Maor\\AppData\\Local\\Programs\\Python\\Python39\\lib\\asyncio\\base_events.py\", line 596, in run_forever\n",
      "    self._run_once()\n",
      "  File \"C:\\Users\\Maor\\AppData\\Local\\Programs\\Python\\Python39\\lib\\asyncio\\base_events.py\", line 1890, in _run_once\n",
      "    handle._run()\n",
      "  File \"C:\\Users\\Maor\\AppData\\Local\\Programs\\Python\\Python39\\lib\\asyncio\\events.py\", line 80, in _run\n",
      "    self._context.run(self._callback, *self._args)\n",
      "  File \"c:\\users\\maor\\appdata\\roaming\\jetbrains\\dataspell2021.3\\projects\\workspace\\venv\\lib\\site-packages\\ipykernel\\kernelbase.py\", line 513, in dispatch_queue\n",
      "    await self.process_one()\n",
      "  File \"c:\\users\\maor\\appdata\\roaming\\jetbrains\\dataspell2021.3\\projects\\workspace\\venv\\lib\\site-packages\\ipykernel\\kernelbase.py\", line 502, in process_one\n",
      "    await dispatch(*args)\n",
      "  File \"c:\\users\\maor\\appdata\\roaming\\jetbrains\\dataspell2021.3\\projects\\workspace\\venv\\lib\\site-packages\\ipykernel\\kernelbase.py\", line 409, in dispatch_shell\n",
      "    await result\n",
      "  File \"c:\\users\\maor\\appdata\\roaming\\jetbrains\\dataspell2021.3\\projects\\workspace\\venv\\lib\\site-packages\\ipykernel\\kernelbase.py\", line 729, in execute_request\n",
      "    reply_content = await reply_content\n",
      "  File \"c:\\users\\maor\\appdata\\roaming\\jetbrains\\dataspell2021.3\\projects\\workspace\\venv\\lib\\site-packages\\ipykernel\\ipkernel.py\", line 422, in do_execute\n",
      "    res = shell.run_cell(\n",
      "  File \"c:\\users\\maor\\appdata\\roaming\\jetbrains\\dataspell2021.3\\projects\\workspace\\venv\\lib\\site-packages\\ipykernel\\zmqshell.py\", line 540, in run_cell\n",
      "    return super().run_cell(*args, **kwargs)\n",
      "  File \"c:\\users\\maor\\appdata\\roaming\\jetbrains\\dataspell2021.3\\projects\\workspace\\venv\\lib\\site-packages\\IPython\\core\\interactiveshell.py\", line 2961, in run_cell\n",
      "    result = self._run_cell(\n",
      "  File \"c:\\users\\maor\\appdata\\roaming\\jetbrains\\dataspell2021.3\\projects\\workspace\\venv\\lib\\site-packages\\IPython\\core\\interactiveshell.py\", line 3016, in _run_cell\n",
      "    result = runner(coro)\n",
      "  File \"c:\\users\\maor\\appdata\\roaming\\jetbrains\\dataspell2021.3\\projects\\workspace\\venv\\lib\\site-packages\\IPython\\core\\async_helpers.py\", line 129, in _pseudo_sync_runner\n",
      "    coro.send(None)\n",
      "  File \"c:\\users\\maor\\appdata\\roaming\\jetbrains\\dataspell2021.3\\projects\\workspace\\venv\\lib\\site-packages\\IPython\\core\\interactiveshell.py\", line 3221, in run_cell_async\n",
      "    has_raised = await self.run_ast_nodes(code_ast.body, cell_name,\n",
      "  File \"c:\\users\\maor\\appdata\\roaming\\jetbrains\\dataspell2021.3\\projects\\workspace\\venv\\lib\\site-packages\\IPython\\core\\interactiveshell.py\", line 3400, in run_ast_nodes\n",
      "    if await self.run_code(code, result, async_=asy):\n",
      "  File \"c:\\users\\maor\\appdata\\roaming\\jetbrains\\dataspell2021.3\\projects\\workspace\\venv\\lib\\site-packages\\IPython\\core\\interactiveshell.py\", line 3460, in run_code\n",
      "    exec(code_obj, self.user_global_ns, self.user_ns)\n",
      "  File \"C:\\Users\\Maor\\AppData\\Local\\Temp\\ipykernel_31128\\2709595738.py\", line 10, in <module>\n",
      "    log.info(\"Number of params\", model.count_parameters())\n",
      "Message: 'Number of params'\n",
      "Arguments: (740395,)\n"
     ]
    }
   ],
   "execution_count": 163
  },
  {
   "cell_type": "markdown",
   "source": [],
   "metadata": {
    "id": "2d264e8356d0225b"
   },
   "id": "272ab58d25984ef8"
  },
  {
   "cell_type": "markdown",
   "source": "### Evaluation loop vs SNR",
   "metadata": {
    "id": "8a62f3dbe418a973"
   },
   "id": "87ca24c733e18613"
  },
  {
   "cell_type": "code",
   "source": [
    "snrs = [-15, -10, -5, 0, 5, 10, 15]\n",
    "cers = []\n",
    "val_losses = []\n",
    "\n",
    "for i in range(len(snrs)):\n",
    "    print('Validating model for snr: ', snrs[i])\n",
    "\n",
    "    val_loader = torch.utils.data.DataLoader(\n",
    "        Dataset(number_of_samples=2048, sr=2000, explicit_snr=snrs[i]),\n",
    "        batch_size=batch_size,\n",
    "        collate_fn=collate_fn_pad,\n",
    "    )\n",
    "    val_loss = 0.0\n",
    "    curr_cer = 1.0\n",
    "    total_chars = 0\n",
    "\n",
    "    model.eval()\n",
    "    with torch.no_grad():\n",
    "        for (input_lengths, output_lengths, x, y) in val_loader:\n",
    "            x, y = x.to(device), y.to(device)\n",
    "\n",
    "            # Forward pass\n",
    "            y_pred = model(x)\n",
    "\n",
    "            # Compute loss\n",
    "            m = torch.argmax(y_pred[0], 1)\n",
    "            curr_cer, total_chars = aggregate_cer(curr_cer, total_chars, y, y_pred)\n",
    "            y_pred = y_pred.permute(1, 0, 2)\n",
    "\n",
    "            loss = ctc_loss(y_pred, y, input_lengths, output_lengths)\n",
    "            val_loss += loss.item()\n",
    "\n",
    "    val_losses.append(val_loss/len(val_loader))\n",
    "    cers.append(curr_cer)"
   ],
   "metadata": {
    "id": "c6ab003ccb7a548",
    "ExecuteTime": {
     "end_time": "2024-04-01T06:29:50.250257Z",
     "start_time": "2024-04-01T06:29:01.388064Z"
    }
   },
   "id": "6bb442478096df24",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Validating model for snr:  -15\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\Maor\\AppData\\Local\\Temp\\ipykernel_31128\\3015226362.py:56: ComplexWarning: Casting complex values to real discards the imaginary part\n",
      "  time_domain_signal = time_domain_signal.astype(np.float32)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Validating model for snr:  -10\n",
      "Validating model for snr:  -5\n",
      "Validating model for snr:  0\n",
      "Validating model for snr:  5\n",
      "Validating model for snr:  10\n",
      "Validating model for snr:  15\n"
     ]
    }
   ],
   "execution_count": 164
  },
  {
   "cell_type": "markdown",
   "source": [
    "### Visualize"
   ],
   "metadata": {
    "id": "8ef156632d6c68e1"
   },
   "id": "6acdf92d006a09ec"
  },
  {
   "cell_type": "code",
   "source": [
    "plt.plot(snrs, val_losses, color='blue')\n",
    "plt.scatter(snrs, val_losses, marker='x', color='red')\n",
    "plt.xlabel('SNR')\n",
    "plt.ylabel('Validating Loss')\n",
    "plt.title('LSTM RNN Validating Loss vs SNR')\n",
    "plt.show()\n",
    "\n",
    "plt.plot(snrs, [100*c for c in cers], color='blue')\n",
    "plt.scatter(snrs, [100*c for c in cers], marker='x', color='red')\n",
    "plt.xlabel('CER')\n",
    "plt.ylabel('CER %')\n",
    "plt.title('LSTM RNN Validating CER vs SNR')\n",
    "plt.show()"
   ],
   "metadata": {
    "id": "17fd95da5aced9b",
    "outputId": "1327f6a9-6c0b-4a7a-e468-4ceef9c611f7",
    "ExecuteTime": {
     "end_time": "2024-04-01T06:32:07.950249Z",
     "start_time": "2024-04-01T06:32:07.674682Z"
    }
   },
   "id": "d59a40f1519b9be",
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ],
      "image/png": "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\n"
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ],
      "image/png": "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\n"
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "execution_count": 166
  },
  {
   "cell_type": "markdown",
   "source": [
    "## Detection: Faster R-CNN\n",
    "Faster R-CNN (Faster Regions with Convolutional Neural Networks) is an object detection algorithm that builds upon the success of its predecessors, R-CNN and Fast R-CNN. It was introduced in the 2015 paper [\"Faster R-CNN: Towards Real-Time Object Detection with Region Proposal Networks\"](https://arxiv.org/abs/1506.01497) by Shaoqing Ren, Kaiming He, Ross Girshick, and Jian Sun.\n",
    "\n",
    "The key innovation in Faster R-CNN is the introduction of a **Region Proposal Network** (RPN), which is a fully convolutional network that generates region proposals (bounding boxes) for objects in the input image. This contrasts with previous approaches that relied on external region proposal algorithms like selective search, which were computationally expensive and slow.\n",
    "\n",
    "The Faster R-CNN architecture consists of two main components:\n",
    "\n",
    "1. **Region Proposal Network (RPN)**: This is a lightweight convolutional neural network that takes an input image and outputs a set of object proposals or regions of interest (RoIs). The RPN works by sliding a small window over the input feature map and outputting multiple region proposals for each window location. These proposals are then filtered and ranked based on their objectness score, which is the probability that a region contains an object of interest.\n",
    "\n",
    "2. **Object Detection Network**: This is a Fast R-CNN network that takes the proposed RoIs from the RPN and performs object classification and bounding box regression. It extracts features from each RoI using a RoI pooling layer and then passes these features through fully connected layers to predict the class and refine the bounding box coordinates.\n",
    "\n",
    "The key advantages of Faster R-CNN are:\n",
    "\n",
    "1. **Speed**: By integrating the region proposal step into the network, Faster R-CNN can process images much faster than its predecessors, enabling real-time object detection.\n",
    "2. **Accuracy**: The RPN and the shared convolutional features used for both region proposal and object detection improve the overall accuracy of the system.\n",
    "3. **End-to-End Training**: The entire Faster R-CNN network can be trained end-to-end, making the training process more efficient and effective.\n",
    "\n",
    "Faster R-CNN has been widely adopted and has inspired numerous subsequent object detection algorithms, such as Mask R-CNN for instance segmentation and RetinaNet for dense object detection.\n",
    "\n",
    "We will use 'fasterrcnn_resnet50_fpn' varient (original model), read more here [\"PyTorch FASTER R-CNN\"](https://pytorch.org/vision/0.16/models/faster_rcnn.html)"
   ],
   "metadata": {
    "id": "c1175cc07be845ad"
   },
   "id": "2edef4d20e0b0c2a"
  },
  {
   "cell_type": "markdown",
   "source": [
    "### Utils"
   ],
   "metadata": {
    "id": "dd055d12afe7f871"
   },
   "id": "e4f228b33cd34368"
  },
  {
   "cell_type": "code",
   "source": [
    "def spectrum_to_img(spec):\n",
    "    '''\n",
    "    Transform spectrum to grey-image, ready for training in resnet50 model\n",
    "    \n",
    "    :param spec: ndarray (shape: [H, W])\n",
    "    :return: normalized torch image (shape: [1, H, W])\n",
    "    '''\n",
    "    # Normalize the spectrum (min-max scaling)\n",
    "    min_value = np.min(spec)\n",
    "    max_value = np.max(spec)\n",
    "    normalized_spectrum = (spec - min_value) / (max_value - min_value)\n",
    "\n",
    "    # Adapt dimension for resnet50\n",
    "    normalized_spectrum = np.expand_dims(normalized_spectrum, axis=-1)\n",
    "    normalized_spectrum = torch.from_numpy(normalized_spectrum).permute(2,0,1)\n",
    "\n",
    "    return normalized_spectrum\n",
    "\n",
    "\n",
    "def get_training_sample_bbx(*args, **kwargs):\n",
    "    '''\n",
    "    Used in NN dataset to generate sample with bounding box of the morse content\n",
    "    :param args: generate_morse_sample args\n",
    "    :param kwargs: \n",
    "    :return: torch image (shape: [1, H, W]) and bounding box (list[x_start, y_start, x_end, y_end])\n",
    "    '''\n",
    "    _, spec, morse_str, bbx = generate_morse_sample(*args, **kwargs)\n",
    "    spec = spectrum_to_img(spec)\n",
    "\n",
    "    return spec, bbx, morse_str\n",
    "\n",
    "\n",
    "def inference(img, model_, detection_threshold=0.5):\n",
    "    '''\n",
    "    Infernece of a single input image from resnet\n",
    "\n",
    "    inputs:\n",
    "      img: input-image as torch.tensor (shape: [C, H, W])\n",
    "      model: model for infernce (torch.nn.Module)\n",
    "      detection_threshold: Confidence-threshold for NMS (default=0.7)\n",
    "\n",
    "    returns:\n",
    "      boxes: bounding boxes (Format [N, 4] => N times [xmin, ymin, xmax, ymax])\n",
    "      labels: class-prediction (Format [N] => N times an number between 0 and _num_classes-1)\n",
    "      scores: confidence-score (Format [N] => N times confidence-score between 0 and 1)\n",
    "    '''\n",
    "    model_.eval()\n",
    "\n",
    "    img = img.to(device)\n",
    "    outputs = model_([img])\n",
    "\n",
    "    boxes = outputs[0]['boxes'].data.cpu().numpy()\n",
    "    scores = outputs[0]['scores'].data.cpu().numpy()\n",
    "    labels = outputs[0]['labels'].data.cpu().numpy()\n",
    "\n",
    "    boxes = boxes[scores >= detection_threshold].astype(np.int32)\n",
    "    labels = labels[scores >= detection_threshold]\n",
    "    scores = scores[scores >= detection_threshold]\n",
    "\n",
    "    return boxes, scores, labels\n",
    "\n",
    "\n",
    "def plot_image(img, boxes, scores, labels, dataset, morse_str, save_path=None):\n",
    "    '''\n",
    "    Function that draws the BBoxes, scores, and labels on the image.\n",
    "\n",
    "    inputs:\n",
    "      img: input-image as numpy.array (shape: [H, W, C])\n",
    "      boxes: list of bounding boxes (Format [N, 4] => N times [xmin, ymin, xmax, ymax])\n",
    "      scores: list of conf-scores (Format [N] => N times confidence-score between 0 and 1)\n",
    "      labels: list of class-prediction (Format [N] => N times an number between 0 and _num_classes-1)\n",
    "      dataset: list of all classes [\"background\", \"morse\"] => Format [N_classes]\n",
    "    '''\n",
    "    # Preprocessing\n",
    "    img = img.permute(1,2,0).numpy()\n",
    "    img = np.squeeze(img, axis=-1)\n",
    "    class_labels = np.array(dataset)\n",
    "\n",
    "    # Plotting\n",
    "    fig, ax = plt.subplots(1, figsize=(16, 8))\n",
    "    plt.pcolormesh(img)\n",
    "    for i, box in enumerate(boxes):\n",
    "\n",
    "        # BBX\n",
    "        class_pred = labels[i]\n",
    "        conf = scores[i]\n",
    "        rect = patches.Rectangle(\n",
    "            (box[0], box[1]),\n",
    "            box[2]-box[0],\n",
    "            box[3]-box[1],\n",
    "            linewidth=4,\n",
    "            edgecolor='red',\n",
    "            facecolor=\"none\",\n",
    "        )\n",
    "        ax.add_patch(rect)\n",
    "\n",
    "        # Add vertical lines\n",
    "        ax.axvline(x=box[0], color='r', linestyle='--', linewidth=3, alpha=0.5)\n",
    "        ax.axvline(x=box[2], color='r', linestyle='--', linewidth=3, alpha=0.5)\n",
    "\n",
    "        # Add the label\n",
    "        plt.text(\n",
    "            box[0], box[1],\n",
    "            s='\"' + morse_str + '\" | ' + class_labels[int(class_pred)] + \" \" + str(int(100*conf)) + \"%\",\n",
    "            color=\"white\",\n",
    "            fontsize=14,\n",
    "            verticalalignment=\"top\",\n",
    "            bbox={\"color\": 'red', \"pad\": 0},\n",
    "        )\n",
    "\n",
    "    # Used to save inference phase results\n",
    "    if save_path is not None:\n",
    "        plt.savefig(save_path)\n",
    "\n",
    "    plt.show()\n",
    "\n",
    "\n",
    "def collate_fn(batch):\n",
    "    return tuple(zip(*batch))"
   ],
   "metadata": {
    "id": "63272d9fae3625cb",
    "execution": {
     "iopub.status.busy": "2024-03-28T20:22:16.920867Z",
     "iopub.execute_input": "2024-03-28T20:22:16.921231Z",
     "iopub.status.idle": "2024-03-28T20:22:16.926791Z",
     "shell.execute_reply.started": "2024-03-28T20:22:16.921202Z",
     "shell.execute_reply": "2024-03-28T20:22:16.925897Z"
    },
    "trusted": true,
    "ExecuteTime": {
     "end_time": "2024-04-02T07:27:58.891635Z",
     "start_time": "2024-04-02T07:27:58.866104Z"
    }
   },
   "id": "c92e273c0bed5d7e",
   "outputs": [],
   "execution_count": 213
  },
  {
   "cell_type": "markdown",
   "source": [
    "### Generate and Plot 1 example"
   ],
   "metadata": {
    "collapsed": false
   },
   "id": "422ed4baf852e536"
  },
  {
   "cell_type": "code",
   "source": [
    "sr = 2000\n",
    "\n",
    "# Random params\n",
    "length = random.randrange(1, 7)\n",
    "pitch = random.randint(2, 19) * 50\n",
    "wpm = 18\n",
    "snrDB = random.randrange(-10, 10)\n",
    "amplitude = random.randrange(50, 200)\n",
    "\n",
    "# Generate\n",
    "spec, bbx, morse_str = get_training_sample_bbx(sr, length, pitch, wpm, snrDB, amplitude)\n",
    "\n",
    "# Plot\n",
    "plot_image(spec, [bbx], [1.0], [1], ['background', 'morse'], morse_str)"
   ],
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 110
    },
    "id": "31366734189a3736",
    "outputId": "91b21069-8632-41dd-cea5-48a5582d1b06",
    "execution": {
     "iopub.status.busy": "2024-03-28T23:02:10.979132Z",
     "iopub.execute_input": "2024-03-28T23:02:10.979998Z",
     "iopub.status.idle": "2024-03-28T23:02:11.198870Z",
     "shell.execute_reply.started": "2024-03-28T23:02:10.979963Z",
     "shell.execute_reply": "2024-03-28T23:02:11.197920Z"
    },
    "trusted": true,
    "ExecuteTime": {
     "end_time": "2024-04-02T12:41:04.645148Z",
     "start_time": "2024-04-02T12:41:04.522018Z"
    }
   },
   "id": "7d3d2dc3ff75d73",
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<Figure size 1600x800 with 1 Axes>"
      ],
      "image/png": "iVBORw0KGgoAAAANSUhEUgAABRQAAAKTCAYAAABo9IQGAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy88F64QAAAACXBIWXMAAA9hAAAPYQGoP6dpAABzXElEQVR4nO3debgdVZko/Lf2mRIgA2FICDOCRFHBBolxxIYr0rYtaKNy6QZx+vpr6CtGbaXbCbU7rf0paEtD218Lem2vyr2CQ9soIoN+TAKi4BABGRsSBklCpjPt+v7Y5JBjTmqtw659zsnJ7/c8+0l2Ve1Vb1WtWlXrPTUUZVmWAQAAAACQoTHZAQAAAAAA2w4JRQAAAAAgm4QiAAAAAJBNQhEAAAAAyCahCAAAAABkk1AEAAAAALJJKAIAAAAA2bonO4A6NJvNePDBB2PWrFlRFMVkhwMAAAAA25SyLOOJJ56IhQsXRqNRfQ3itEgoPvjgg7H33ntPdhgAAAAAsE27//77Y6+99qqcZlokFGfNmhURES+JP4ru6JnkaDIUiTvNy+bExJEyEXGm5pFjIuKoYR5FV1dymnJ4uO35pAPZRupfjm1kWVLbvmyW6UISy5Kcx0TUrYips09Tr6myXafCPp+zLqbKsrZbRsayFo3qO0MmrO1heqphP2j7+LittH8R0eip7to1BwbaD2MbOd+YkLZpW2oj29yXsvoxqfPZCdoPpsw6nwom6pxle7Et1b829vmhGIwfx3dH8mxVpkVCcdNtzt3RE93FNEgoxhTZqScizjpO0iYkjhoSikXGgbiW9ZEKZBupfzm2kWVJbfuyyEgoJpYlPY8JemTuVNmnqddU2a5TYZ/PWhdTZFnbLSPnxDnxqJkJa3uYnmrYD9o+Pm4z7V9Eo0gkFLPONxJhbCPnGxPSNm1LbWSb+1JePyZVvyYooThV1vlUMFHnLNuLban+tbPPP7kr5zxOcDvamwAAAACAdk2LKxRhquoph2NJPBgREUWzlb+/rtgzBjP+ygcAAPB0bN4P2XQd0XWxUD8EqI2EInRQV5Sxb6yJiIiibB3IbywWxuBkBgUAAExrm/dDomzdunhjsYd+CFAbtzwDAAAAANkkFAEAAACAbBKKAAAAAEA2CUUAAAAAIJuEIgAAAACQTUIRAAAAAMgmoQgAAAAAZJNQBAAAAACySSgCAAAAANkkFAEAAACAbBKKAAAAAEA2CUUAAAAAIJuEIgAAAACQrXuyA4DpbDiKWBk7tr4UjZFhAAAAnTK6H1KMDAOoi4QidNBg0RXfj/0iIqJodE1uMAAAwHZh837IpgsbAOqkZQEAAAAAskkoAgAAAADZJBQBAAAAgGwSigAAAABANglFAAAAACDbuBKKy5Ytixe84AUxa9as2H333eP444+P5cuXj5pm48aNcfrpp8cuu+wSO+20U7z+9a+PlStXVpZblmV86EMfij322CNmzpwZxxxzTNxxxx3jXxqYYnrK4TiyfKj1aT4YRzYfjJ5yeLLDAgAAprFR/ZDywTiy1A8B6jWuhOLVV18dp59+elx//fVx+eWXx+DgYLzyla+MdevWjUzzrne9K7797W/HxRdfHFdffXU8+OCD8brXva6y3E9+8pPx2c9+Ni644IK44YYbYscdd4xjjz02Nm7c+PSWCqaIrijj4Phd61O2Pl1RTnZYAADANKYfAnRa93gmvuyyy0Z9v+iii2L33XePm2++OV72spfF6tWr49/+7d/iK1/5SvzhH/5hRERceOGF8axnPSuuv/76eOELX7hFmWVZxrnnnhsf+MAH4rWvfW1ERHzpS1+K+fPnx6WXXhpvetObnu6yAQAAAAA1a+sZiqtXr46IiHnz5kVExM033xyDg4NxzDHHjEyzaNGi2GeffeK6664bs4y77747VqxYMeo3c+bMicWLF2/1N/39/bFmzZpRHwAAAACg88Z1heLmms1mnHnmmfHiF784nvOc50RExIoVK6K3tzfmzp07atr58+fHihUrxixn0/D58+dn/2bZsmVx9tlnbzmiaLQ+W1M2tz5u0+8TGr29leOb/Rm3aafiyJGKtY551FFGHRJxFF1diZ9PzKX9RXfPlsPKIorm78VXVU+LRKwTsU0y9oM69qV2t2tERDnc+efAjLVdxxtDLXEm1ulErIus7ZrQ6EkfdpqDQ9UTJOpOqp3OmkeOqdJGTsTxoA51xNnustRQh7cpba6volGkZ5Fqe6bK8WAitv1U2dcSUse1HOXQYA2RTA2NHXaoHN9cv36CIknIqF+1HNtSYUzAPp8XSHUZZTMRRx1xZixH6pGFOe1beh4554BP9jHKZkSMf/3XcZ45UednyTauhvOR1PqoY7vm1NHkdqlhX0stS84xpTkwUF3GFDnfSOZ6EssRkd7nc+JMrY+s/MYEnZM87bOr008/PW6//fb46le/Wmc8Wc4666xYvXr1yOf++++f8BgAAAAAYHv0tBKKZ5xxRnznO9+JK6+8Mvbaa6+R4QsWLIiBgYFYtWrVqOlXrlwZCxYsGLOsTcN//03QVb/p6+uL2bNnj/oAAAAAAJ03roRiWZZxxhlnxCWXXBI//OEPY//99x81/vDDD4+enp644oorRoYtX7487rvvvliyZMmYZe6///6xYMGCUb9Zs2ZN3HDDDVv9DQAAAAAwOcaVUDz99NPjy1/+cnzlK1+JWbNmxYoVK2LFihWxYcOGiGi9TOWtb31rLF26NK688sq4+eab47TTToslS5aMesPzokWL4pJLLomIiKIo4swzz4yPf/zj8a1vfStuu+22OOWUU2LhwoVx/PHH17ekAAAAAEDbxvVSlvPPPz8iIo466qhRwy+88MJ485vfHBER55xzTjQajXj9618f/f39ceyxx8Y///M/j5p++fLlI2+Ijoj467/+61i3bl284x3viFWrVsVLXvKSuOyyy2LGjBlPY5EAAAAAgE4ZV0KxLNNvk5kxY0acd955cd5552WXUxRFfPSjH42PfvSj4wkHAAAAAJhgT/stzwAAAADA9kdCEQAAAADIJqEIAAAAAGSTUAQAAAAAso3rpSzA+DQjYlX0bTEMAACgU5pRxOot+iHFJEUDTEcSitBBA0V3fLvrmZMdBgAAsB0ZKLriW3HgZIcBTGNueQYAAAAAskkoAgAAAADZJBQBAAAAgGwSigAAAABANglFAAAAACCbtzxDB3WXw/Hs8tFRw35Z7BpDRdckRQQAAEx33WUznh2/1w+JXWOocE0RUA8JReig7ijj0PLhUcN+U+wSQ5MUDwAAMP11RzMOjUdGDftNzIshNykCNdGaAAAAAADZJBQBAAAAgGwSigAAAABANglFAAAAACCbhCIAAAAAkE1CEQAAAADIJqEIAAAAAGSTUAQAAAAAskkoAgAAAADZuic7gFqVzYhobn180X7+tBwabLuMoqur/TiaZWImiWUtK9ZTjYrunuowhofbnkdyXeQsa2p95dSdseZTNiPKVnzlk+PL5mCURSLmrYWRqDt1rM+c9TURceSU0e6+lKw7OXHkrK8a9oOiUSTKSBaQnMdEtAvNgYH0RG3uj1n1L7WsNRwvstQxn4lozyfomNGuZNuUsc8ny8g4D0ju8znnEjWs80Zvb2IW1esjp42to41MziNju2UUUjk6a1nriGMqnJ9lzCO1XeuoG1OljHLDxmQZ7aplX6rjeJEoI9VmREQ0+6vXV+p8JSKibCbi6MnooiaWJet8o815TFj7VsN8Nh2Xip4Z0Si2PEY1N/a3H0Pq/CxjWVPbPme71tFfT0ntK3XUvyKnm1NH3WizX5dz3t3YYYfqMgZytlkN/dyEiTjm5B2Dk5MkTUQdjXCFIgAAAAAwDhKKAAAAAEA2CUUAAAAAINv0eoYiTDFlRGzc9ACMsjEyDAAAoFPKiOh/srtfFJu6/elnXALkklCEDuovuuPi4lkREVHW8XRVAACAhP6iO74eB0dERKNn5iRHA0xHbnkGAAAAALJJKAIAAAAA2SQUAQAAAIBsEooAAAAAQDYJRQAAAAAgm7c8Qwd1lc04MB6PiIiybEZExJ0xN4YLuXwAAKAzWv2QVRER0Rjui4iIOxvz9EOA2kgoQgf1RDOObD4UERFltBKK98bsGHZxMAAA0CE90Ywjo9UPKYZ7IiLinsYc/RCgNloTAAAAACCbhCIAAAAAkE1CEQAAAADIJqEIAAAAAGSTUAQAAAAAskkoAgAAAADZJBQBAAAAgGwSigAAAABANglFAAAAACCbhCIAAAAAkE1CEQAAAADIJqEIAAAAAGSTUAQAAAAAskkoAgAAAADZuic7AJjONhbd8T+7nhMREeXw8CRHAwAAbA82Ft3xP+OQiIho9M6c5GiA6cgVigAAAABAtul1hWLRaH22OrqoZx6V0lehlc2y/TjKZvtltCu5LiLKocH2Z9PV1VYc5VDGuqplfSbizJFalomoOxnbtY79oA5T4arPxg47JKdprl9fPUHOvtTmsjZ60s19c2AgEUT7+0lyf47263nOukrFkbW+E9st55iTmk/e+krEkVFGch6JtryW7ToRx7WMeSSPGXXsrxllJOtoxvG1OThUPUFifdRxDM86pqRMQN2o43hSdPdkzCixznPCSLU9NbRvjd7eyvHJ40VOHDltfeq8aKLa+9Q8Etu+jjhztNvONvs3th9DDeuzjvqV/H0dx+iMfb6WdjQh6xjc5vGgDjl1I9UGNvpmZMwoUc9T9SvnON+sXp852yQ1Tc5+UId2z1lylrWOvlBKVl8nsR9MxLlqLXUjtT9Hu/W8EZHZHXOFIgAAAACQTUIRAAAAAMgmoQgAAAAAZJtez1CEKaZRNmPveCIiIsonHwpyf8yKZh3PlAIAABjD5v2QTdcR6YcAdZJQhA7qjWa8rHl/RESU0XqI68VxcGx0cTAAANAhm/dDomi9hObixrP0Q4DaaE0AAAAAgGwSigAAAABANglFAAAAACCbhCIAAAAAkE1CEQAAAADINu6E4jXXXBOvec1rYuHChVEURVx66aWjxhdFMebnH//xH7da5kc+8pEtpl+0aNG4FwYAAAAA6KxxJxTXrVsXhx56aJx33nljjn/ooYdGfb7whS9EURTx+te/vrLcQw45ZNTvfvzjH483NAAAAACgw7rH+4PjjjsujjvuuK2OX7Bgwajv3/zmN+MVr3hFHHDAAdWBdHdv8VsAAAAAYGrp6DMUV65cGf/xH/8Rb33rW5PT3nHHHbFw4cI44IAD4uSTT4777rtvq9P29/fHmjVrRn0AAAAAgM7raELxi1/8YsyaNSte97rXVU63ePHiuOiii+Kyyy6L888/P+6+++546UtfGk888cSY0y9btizmzJkz8tl77707ET4AAAAA8Hs6mlD8whe+ECeffHLMmDGjcrrjjjsuTjzxxHje854Xxx57bHz3u9+NVatWxde//vUxpz/rrLNi9erVI5/777+/E+EDAAAAAL9n3M9QzPWjH/0oli9fHl/72tfG/du5c+fGM5/5zLjzzjvHHN/X1xd9fX3thggAAAAAjFPHrlD8t3/7tzj88MPj0EMPHfdv165dG3fddVfsscceHYgMAAAAAHi6xp1QXLt2bdx6661x6623RkTE3XffHbfeeuuol6isWbMmLr744njb2942ZhlHH310fO5znxv5/p73vCeuvvrquOeee+Laa6+NE044Ibq6uuKkk04ab3gAAAAAQAeN+5bnm266KV7xileMfF+6dGlERJx66qlx0UUXRUTEV7/61SjLcqsJwbvuuiseffTRke8PPPBAnHTSSfHYY4/FbrvtFi95yUvi+uuvj91222284cGUsjG64uLGooiIKIeHR4YBAAB0yub9kCgaI8MA6lKUZVlOdhDtWrNmTcyZMyeOKk6I7qJnq9MVjaL9mRXVF3WWQ4Ntl5GlbLZfRrtylqOGOIuuxIGvjm1Sg1ScmxKK1YW0WTfqqBcZMSSXdYLW+VTQ2GGH5DTN9eurJ5iAfanR25ucpjkw0NY8ciT354gom20eljLW1UTsrznHnNR86lhfOWUk55HYp2vZrhNwvMjarsmZdPR9dk/Npo52NhXrRJxLTJdzngxF99bPQUcklqWWtqeG/aDRU33NQc7xIhlHu219q5D246ihXUht+5x51NFPmYh2dqpot37VcozO2OeTbXUN54BZx/mJ6C9NwPEx53w2tb6S7VcNy5FTv1LbbSLOy7O0ecyJmJj9IKuvMziUnk8bMeTIWV/JupGzHKlYK9b5UDkYV5WXxOrVq2P27NmVxUzMWTEAAAAAMC1IKAIAAAAA2SQUAQAAAIBsEooAAAAAQLZxv+UZyNcom7FbbIiIiLJsPdj5kdghmkUNLwgCAAAYw+b9kIhW36PVD3FNEVAPCUXooN5oxiubd0dERBmtNy1dHAfHRrseAADQIZv3Q+LJixkubjwrNrpJEaiJ1gQAAAAAyCahCAAAAABkm173XZbNiCdvKx17dCJ/Wm79t08ZHldIT2s+E/Fci4x5NGb0VY5vbthQOT5rPhnrvGyWiQkG24sh6lnWcnjLulGWwyO3OtehaKSevdiVLGOsOMerHEqs8+1Ic/369gvJanuqNWbOrJ4gY7s3ensrx+fUneT+WoNGT/WhqzkwkCxjIuLMmUfRVb3P1rK/poqoof7VEee0UsdxfiqUkVE3aqnDiThS88iaTw3Lmoxhgo6NqTYwtaw5cTYHh6pn0d2TLCM1n1q2a4Z2y8hZ1mT9yTnfTYVZxz6/rchY1naP43WcB9Syz2dss9T52dbOe0b1Q8riqWGdepb7BNS/nHXe9rat5bwoZzaJOKfKPp+YRzmUEUMN+Y3UMSPn/H8izgVSsvpTNRz7Un3DyvzGONaDKxQBAAAAgGwSigAAAABANglFAAAAACCbhCIAAAAAkE1CEQAAAADIJqEIAAAAAGSTUAQAAAAAskkoAgAAAADZJBQBAAAAgGwSigAAAABANglFAAAAACBb92QHANNZf3TFt+MZWwwDAADolFH9kKIxMgygLhKK0EFlUcSqmDHZYQAAANuRUf2Qwo2JQP20LAAAAABANglFAAAAACCbhCIAAAAAkE1CEQAAAADI5qUs0EFFWcac6B81bHX0RVkUkxQRAAAw3Y3uh7SuI9IPAeokoQgd1BfD8Zq4a9Swi+Pg2GjXAwAAOmRUP6RsJREvLhbphwC1ccszAAAAAJBNQhEAAAAAyCahCAAAAABkk1AEAAAAALJJKAIAAAAA2SQUAQAAAIBsEooAAAAAQDYJRQAAAAAgm4QiAAAAAJCte7IDqFXRaH22OrpI/L4nOYtyaHC8UW05m66u6nkMD2cUksgFl81xRLSVIgaH2i4jJbUuIjLWRw3rorlhQ3KaiZCsG4n6l7M+61hfRXf1vpJVh2uoo13zdq4cP/y7x9ueR0pqXUREclmLvr50Ef39leObG6vH17G+s+pXYj5lTvOWM58poN39NSJvfbQdR87+OAGScTbLdCGp+pUoI+uYk4qjhn0pp4xk3Ui15RMlGUf7x4M69pOUOtqdiTp/S82nHB5Ix5GcSWKbDGWcK9Sxz9cgec6SaKtrOafJ2V9TZeS0PRPQP0iGMFXa2YS8c+bEOV4N+2uO5kAN+3RKou4k+9FRQ58tIho91emJqbAuIiJ9bp/RP0iurwnYD6aMOs6LMqTq8UScb2Sp41xhIvaVcIUiAAAAADAOEooAAAAAQDYJRQAAAAAgm4QiAAAAAJBter2UBaaYgeiK78d+WwwDAADolFH9kCdf8jDgeiKgRhKK0EHNooiVseNkhwEAAGxHRvVDct5cDDBOWhYAAAAAIJuEIgAAAACQTUIRAAAAAMgmoQgAAAAAZPNSFuiksowZMTxq0MboiiiKSQoIAACY9kb1Q1rXEemHAHWSUIQOmhHDcWIsHzXs4jg4Ntr1AACADhnVDylbScSLi0X6IUBt3PIMAAAAAGSTUAQAAAAAskkoAgAAAADZJBQBAAAAgGwSigAAAABANglFAAAAACCbhCIAAAAAkE1CEQAAAADIJqEIAAAAAGSTUAQAAAAAskkoAgAAAADZJBQBAAAAgGwSigAAAABAtnEnFK+55pp4zWteEwsXLoyiKOLSSy8dNf7Nb35zFEUx6vOqV70qWe55550X++23X8yYMSMWL14cN95443hDAwAAAAA6rHu8P1i3bl0ceuih8Za3vCVe97rXjTnNq171qrjwwgtHvvf19VWW+bWvfS2WLl0aF1xwQSxevDjOPffcOPbYY2P58uWx++67jzdEmDIGohHXxF5bDAMAAOiUUf2QojEyDKAu404oHnfccXHcccdVTtPX1xcLFizILvPTn/50vP3tb4/TTjstIiIuuOCC+I//+I/4whe+EO9///u3mL6/vz/6+/tHvq9ZsyZ7XjCRmkUj7o05kx0GAACwHRnVDykkEoH6jTuhmOOqq66K3XffPXbeeef4wz/8w/j4xz8eu+yyy5jTDgwMxM033xxnnXXWyLBGoxHHHHNMXHfddWP+ZtmyZXH22WdvOaJsRkRzq3GVzURDWg5Wj4+YOo1xufXlrG0WQ4n1kbMuEnGWw+MIaKthFG3Po+jqqi6jWaYLqWGblMPtrZAJizNRN4runoxCqrdbjuHHV7ddRrtS9S8iojlQvV3L9evrCmfqy2k3EtM0B4eqf57Yn3NktU017Et1tD3tthu1HNcy1kXbcUZEo7e3cnyqbuQsa9GYgONWRh1Nrq+c+jcB5yzJc4UMteyziX0lua/l1M86zr2mwLlCPW1kOobkNsk4fqbP3TPWZ2KaWupGmzG0Aml/WdPLkg4jKXVun3MuWoN2t1vWdi0SyzIB/bGIeupo8vjZvzExj+Qs2j9GR6T3gxr6n7VIxJFzbGzssEPl+OaG6m3SmlF77VtEuv5MSBuZc36WiCNrWdvNb9TQltdyDpihlu2SofYzzVe96lXxpS99Ka644or4xCc+EVdffXUcd9xxMbyVBXr00UdjeHg45s+fP2r4/PnzY8WKFWP+5qyzzorVq1ePfO6///66FwMAAAAAGEPtVyi+6U1vGvn/c5/73Hje854Xz3jGM+Kqq66Ko48+upZ59PX1JZ/LCAAAAADUr+P3whxwwAGx6667xp133jnm+F133TW6urpi5cqVo4avXLlyXM9hBAAAAAA6r+MJxQceeCAee+yx2GOPPcYc39vbG4cffnhcccUVI8OazWZcccUVsWTJkk6HBwAAAACMw7hveV67du2oqw3vvvvuuPXWW2PevHkxb968OPvss+P1r399LFiwIO66667467/+6zjwwAPj2GOPHfnN0UcfHSeccEKcccYZERGxdOnSOPXUU+OII46II488Ms4999xYt27dyFufYVs1oxyKE2P5qGEXx8GxsejI+5AAAABG9UOKwVbf4+LuQ6JfPwSoybhbk5tuuile8YpXjHxfunRpRESceuqpcf7558fPf/7z+OIXvxirVq2KhQsXxitf+cr42Mc+NuqZh3fddVc8+uijI9/f+MY3xiOPPBIf+tCHYsWKFXHYYYfFZZddtsWLWgAAAACAyTXuhOJRRx0VZVludfz3vve9ZBn33HPPFsPOOOOMkSsWAQAAAICpqePPUAQAAAAApg8JRQAAAAAgm4QiAAAAAJBNQhEAAAAAyCahCAAAAABkk1AEAAAAALJJKAIAAAAA2SQUAQAAAIBsEooAAAAAQDYJRQAAAAAgm4QiAAAAAJBNQhEAAAAAyNY92QHAdDYYjbgx9thiGAAAQKds3g9pdPVGRMSQfghQIwlF6KDhohHLY95khwEAAGxHNu+HNBozJjkaYDryJwoAAAAAIJuEIgAAAACQTUIRAAAAAMgmoQgAAAAAZJNQBAAAAACyecszdFBfORSvjbtGDftmPCP6C7seAADQGZv3Q4qhVt/jW10H64cAtdGaQAcVEdEXQ1sMAwAA6JTN+yFFObmxANOTW54BAAAAgGzT6grForsniqLnaf++HM6ZqFk5ujFzZrKI5oYNleOL7vQylEOD1RMUiVxxYjmyyqhBLcs6EfPIWBdjzacoiyiaXa15NDMqWGq71LBNiq6u6hCG03HWUUZSTh2dCIl13hwYSBbR6JtROT5nfSWnmYD1VTbTf96up25Ul5GaR866yFmWlGQcGeqIo4YgkpOkt2vGfGpov9pdXznHk0Zvb3UZOW1k6rhTx/46AcfoWo45jfR1+bUcM5LzSE1Qw3lRDWXkrK/kLBL7a85xK6Vrp52S0wyvXVs5PqfdqKPtSbYbqXP7RJsQUc86TcrYH9s9Z65jn2/0pLuX6bY8fXxNths17K+p/bGOOpxzLpGsX1td1kZEmdmmJNZXznZtDg5VT5Cxzpv9G6vjqGN/TLXDGdukjr5jDLW/vlKyzpsSsdZyrjoBfdxU3cmSiqOOc9mcc57E+pqIHEouVygCAAAAANkkFAEAAACAbBKKAAAAAEA2CUUAAAAAIJuEIgAAAACQTUIRAAAAAMgmoQgAAAAAZJNQBAAAAACySSgCAAAAANkkFAEAAACAbBKKAAAAAEC27skOAKazoSjiZ8XuERFRxtCTw+TxAQCAztm8H9JotLr9w1FMZkjANCOhCB00VHTFz4v5ERFRNgcnORoAAGB7MFR0xc/jyYRiV+8kRwNMRy6VAgAAAACySSgCAAAAANkkFAEAAACAbBKKAAAAAEA2CUUAAAAAIJu3PEMH9ZZDcWzzt60v5XBERFwW+8dA0TWJUQEAANNZbzkUr4q7IyKiGGp1+7/X9YwYKKQAgHpoTaCDGhExN/ojIqKM4SeHlZMYEQAAMN01ImJO2eqHFOVQ699JjAeYftzyDAAAAABkk1AEAAAAALJJKAIAAAAA2SQUAQAAAIBsEooAAAAAQDYJRQAAAAAgm4QiAAAAAJBNQhEAAAAAyNY92QHUqRwejrLYeo60aBSJAprpmVSUHxFRDg6ly0goh4fTYXR1JSZIxDmUsaztxpAxn3JoMFlGo7e3cnwztc7L9DySMurGWMtalkNRRnp7btL2smZI1a+unXZqu4xyw4ZkGan6UzbTf+9IlpGqX4n95MlA2i6jOTCQnk+bcSTXRUa7MiFqWOdls6yeRUbbFKn9so7tmrOsKTUcl7LKSIbR/jqvow6mjil1tKGp7Zp37Ktue1JxRqTXeZYatn1S6nwjZ7snymj0pE9Xk+sr1a5MkSayju1eDtdQh1NxFIlz6ojkdk2el8fUOHbVcgyvQc52K7oSbWD/xuoCamgzctbXhJyzpI6NOcfoZBnp/TV5zlxDv2+rZZTNiCifnGboyX83RrMYo01NLOuE7QcTEUfqnLqRccyp4RwveU5SRz8lY58uunuqi8jor0+E5L4yAesrta6y5pEhdU5SZJwXpY6xde3TrlAEAAAAALJJKAIAAAAA2SQUAQAAAIBsEooAAAAAQLZp9VIWmGqGo4jlMW+LYQAAAJ2iHwJ0moQidNBg0RU3xh6THQYAALAd0Q8BOs0tzwAAAABANglFAAAAACCbhCIAAAAAkE1CEQAAAADINu6E4jXXXBOvec1rYuHChVEURVx66aUj4wYHB+N973tfPPe5z40dd9wxFi5cGKeccko8+OCDlWV+5CMfiaIoRn0WLVo07oUBAAAAADpr3G95XrduXRx66KHxlre8JV73uteNGrd+/fq45ZZb4oMf/GAceuih8fjjj8c73/nO+JM/+ZO46aabKss95JBD4gc/+MFTgXV7ATXbvp5yOF4R948admXsHYNF1yRFBAAATHf6IUCnjTtrd9xxx8Vxxx035rg5c+bE5ZdfPmrY5z73uTjyyCPjvvvui3322WfrgXR3x4IFC8YbDkxpXVHG/Fi3xbDBSYoHAACY/vRDgE7r+DMUV69eHUVRxNy5cyunu+OOO2LhwoVxwAEHxMknnxz33XffVqft7++PNWvWjPoAAAAAAJ3X0YTixo0b433ve1+cdNJJMXv27K1Ot3jx4rjooovisssui/PPPz/uvvvueOlLXxpPPPHEmNMvW7Ys5syZM/LZe++9O7UIAAAAAMBmOpZQHBwcjDe84Q1RlmWcf/75ldMed9xxceKJJ8bznve8OPbYY+O73/1urFq1Kr7+9a+POf1ZZ50Vq1evHvncf//9Y04HAAAAANSrI28+2ZRMvPfee+OHP/xh5dWJY5k7d24885nPjDvvvHPM8X19fdHX11dHqAAAAADAONR+heKmZOIdd9wRP/jBD2KXXXYZdxlr166Nu+66K/bYY4+6wwMAAAAA2jDuhOLatWvj1ltvjVtvvTUiIu6+++649dZb47777ovBwcH40z/907jpppvi3//932N4eDhWrFgRK1asiIGBgZEyjj766Pjc5z438v0973lPXH311XHPPffEtddeGyeccEJ0dXXFSSed1P4SAgAAAAC1GfctzzfddFO84hWvGPm+dOnSiIg49dRT4yMf+Uh861vfioiIww47bNTvrrzyyjjqqKMiIuKuu+6KRx99dGTcAw88ECeddFI89thjsdtuu8VLXvKSuP7662O33XYbb3gAAAAAQAeNO6F41FFHRVmWWx1fNW6Te+65Z9T3r371q+MNAwAAAACYBB17yzMAAAAAMP1IKAIAAAAA2SQUAQAAAIBsEooAAAAAQDYJRQAAAAAg27jf8gzkG44i7o3ZWwwDAADoFP0QoNMkFKGDBouuuCb2nuwwAACA7Yh+CNBp0yuhWDYjorn10cOJ3xcZd4CXWy8/ax45EvPIm09ighqWtWikq0+Zmk/OsjbL9sqoYVnr0OibkZym2b+x43EkY9jYn5ym6OpKTND+0xSS84iIcmiwcnxj5szq3w8MpOfRrF6Wrp12TJfRX71Om4NDyTKK7p7qeQzX0fhUa/Sk9/lmxjpNKqqXtdFbXTdS9aIuqfrV3LAhWUa6nqf3g/T+1vn1lVX/EnHm1K9IrK/kPp3R1jd6exNFJI5JEVEkNlst+0mG1LJEd/U6b65fn5xH0Uhc7ZLYnyPSdbCO9m0i2sgsiTqYc66QKiN1TKljf62lbmTIORdISS1vLfNItAt1nNPk9DEm6vhXJWtZE+ura+7cZBnDq1a1F0dWf6t6pU/UeVHyfDbjPDLdh61e1tT5cET6mFNLP6eOfl2qfcvZZjWc0yTP/zPqaKqeZ52zJNrqdAk1mIC+eET77f1UaGMj8vqwdfTHc3iGIgAAAACQTUIRAAAAAMgmoQgAAAAAZJNQBAAAAACyTa+XssAU01MOx5J4MCIiGsOtBxVf19grBlNP7AcAAHiaesrhWNJ8oPXlyZde6IcAdZJQhA7qijL2jTUREVE0W7vbDY09JzMkAABgmmtEGfs0Vz35rfWu3htCPwSoj1ueAQAAAIBsEooAAAAAQDYJRQAAAAAgm4QiAAAAAJBNQhEAAAAAyCahCAAAAABkk1AEAAAAALJJKAIAAAAA2SQUAQAAAIBsEooAAAAAQDYJRQAAAAAgm4QiAAAAAJBNQhEAAAAAyNY92QHAdDYcRayMHSMioih6IiKiGcVkhgQAAExzzShiZbHTk9/KkWEAdZFQhA4aLLri+7FfREQ0umdMbjAAAMB2YbDoisu7n9H6UjYnNxhgWnLLMwAAAACQTUIRAAAAAMgmoQgAAAAAZJNQBAAAAACySSgCAAAAANm85Rk6qKccjufHwxER0RjuiYiInzb2iMGiazLDAgAAprGecjie33yo9aUsIyLip40F+iFAbSQUoYO6ooyD43cREVE0W7vbzxoLJjMkAABgmmtEGc9sPvbkt1ZC8Wcxf/ICAqYdtzwDAAAAANm2rysUi0T+tGy2X0ZOGF3Vl5mXw8Ptz6O7p3oeQ4MZhVQva3NgYDwhPW1ZsVYWkN6uE7FNNpVRNgeiWWwlpsQ6b/T2Vs+kUSTjaG7srxyftaypdZqxzsvEbBp91XU4Il03ysGh6vHNMjmP1LIMr12XLCJVv1Ljc+Jo9FQ351n7a6p9y2j/Gn0zquPo35gOI7UsiTqctc/X0EaWiXXamDkzWUYk9rdmog4/WUj16NT6yDmu1VBGkWifcpa1SLVPyTjS7VuqXajj+JkjtS9ltdWpY1t/9b6U1TYlFL01tOU1tNUTcZzP0TVrVuX4Oo4p6QLa3+dTx/CIdDtbx/lZXhtZLdVWD69d2/Y8yqH2lzVru3dXHz/LgcS+ltG+JfeljP01dc4yvHpNsox2Falz6oiIxHE+59wq1ZbnnLuXzcT+uLXtVg5FbPpt48n9vmiM2QaUw4llyWg3kud4dZxvZJiQ9j4RZx395GQbGhnLkrE+U+1oHft8Hds1qYZzr9T6zGmHk+ujhpxT3jqvbs+rlqUomzmnzBHhCkUAAAAAYBwkFAEAAACAbBKKAAAAAEA2CUUAAAAAIJuEIgAAAACQTUIRAAAAAMgmoQgAAAAAZJNQBAAAAACySSgCAAAAANkkFAEAAACAbBKKAAAAAEC27skOAKazZhSxOvpaX4riyWEAAACd04yIVUWrH1IUXRERUU5iPMD0I6EIHTRQdMW34sDWl8IFwQAAQOcNFN3x7eKgiIgounsmORpgOpLhAAAAAACySSgCAAAAANkkFAEAAACAbBKKAAAAAEA2CUUAAAAAIJu3PEMHdZfNeHY8+uS3Vv7+l7FLDBVdkxcUAAAwrXWXw/Hs8rGIiCiGW32PXzZ20w8BaiOhCB3UHc04NB5pfSmLiIj4TTEvhiYxJgAAYHrrjjIOLR9ufWm2LmxY3thVPwSojVueAQAAAIBsEooAAAAAQDYJRQAAAAAgm4QiAAAAAJBt3AnFa665Jl7zmtfEwoULoyiKuPTSS0eNL8syPvShD8Uee+wRM2fOjGOOOSbuuOOOZLnnnXde7LfffjFjxoxYvHhx3HjjjeMNDQAAAADosHEnFNetWxeHHnponHfeeWOO/+QnPxmf/exn44ILLogbbrghdtxxxzj22GNj48aNWy3za1/7WixdujQ+/OEPxy233BKHHnpoHHvssfHwww+PNzwAAAAAoIPGnVA87rjj4uMf/3iccMIJW4wryzLOPffc+MAHPhCvfe1r43nPe1586UtfigcffHCLKxk39+lPfzre/va3x2mnnRbPfvaz44ILLogddtghvvCFL4w3PAAAAACgg2p9huLdd98dK1asiGOOOWZk2Jw5c2Lx4sVx3XXXjfmbgYGBuPnmm0f9ptFoxDHHHLPV3/T398eaNWtGfQAAAACAzuuus7AVK1ZERMT8+fNHDZ8/f/7IuN/36KOPxvDw8Ji/+fWvfz3mb5YtWxZnn332+AMsm+P/zTgVjaKOQtLTJJalHBpsP47EPIqurowiyrbm0ZpRYn3UsF3L4eG2y0jZtL6K7t5oFGPves3+rT8aICKiOTBQe1xbyFifZWJ1dc2dmyxjeHX7fwho7LBD5fjm+vWV47v3WJCcx/Ajj1WOL3p7kmWU/f2V4xszZ6bLSNXRxPju3XZNzqO5rnp9pdZnRHqbNPpmJMsoE/W8MaOvcnxzY/X6jkivz0Zvb9tlRKr9y4mjJ32YTrWzRaO6jDralZxjXz3tbPVxJ3Xsy9nXmhs2VI4vutP7fKqORsbxc3j16uo4Mspod1mSy5Exj6x2I9Eu5JzTNGbuVD1BUV1Hc+JM1eHu+bsny2g+vqpyfM6+lJomdYyuRca5apFqvzLahFT7ltNWp9q4cnCocnzXrFnJeZQDiTralV5fqXOFZiLOiIhGTh+i6vc1rM+s+cydUzm+/N2qdBk7Vm+X5tq11eMzzhXq6AslJdqmiIjmhur+wdbjaIyUXw4PPfnvxmhupR/StkT9yzmnSdavjDqePN+YgL5lHf35rDhS07TZJkRMTD+5lvWVIbUsqX06Z110zalu31Lnd60ZdT5vVZdt8i3PZ511VqxevXrkc//99092SAAAAACwXag1obhgQetqn5UrV44avnLlypFxv2/XXXeNrq6ucf2mr68vZs+ePeoDAAAAAHRerQnF/fffPxYsWBBXXHHFyLA1a9bEDTfcEEuWLBnzN729vXH44YeP+k2z2Ywrrrhiq78BAAAAACbHuB+gsHbt2rjzzjtHvt99991x6623xrx582KfffaJM888Mz7+8Y/HQQcdFPvvv3988IMfjIULF8bxxx8/8pujjz46TjjhhDjjjDMiImLp0qVx6qmnxhFHHBFHHnlknHvuubFu3bo47bTT2l9CAAAAAKA2404o3nTTTfGKV7xi5PvSpUsjIuLUU0+Niy66KP76r/861q1bF+94xzti1apV8ZKXvCQuu+yymDHjqQdu33XXXfHoo4+OfH/jG98YjzzySHzoQx+KFStWxGGHHRaXXXbZFi9qgW1NGRH9T+5mRacegAwAALCZMiI2jrzMrBgZBlCXoizLbb5dWbNmTcyZMyeOitdGd5F++2JbEm8gquMtz8k3I7cmans+7ZpOb3meCDlvt0295bmON3Ul1bA+63jLc86bBlNvTfSW583mMSf9rNmJeMtzDGe8RTzxRtciUTey3tyYkPV25dSb4jLeBpxc1hra2dRxqZa3POfEWcNbAtt9+9729pbndutoHW95ztnu9bzlObFtt5G3POesr9S2z3kbcFINbw5N1p8a3vKc9bbzRBuXOt/IOs5PwFuec/oHqWVJtgkZ/Zg6jhndu+9WOX446y3P1ecbqbc819Hfyql/yWNGRt14+m95fkpOO1o9k/b7IBP1lue2268p8pbnWs6t6ug7TkRfeyK2a0YZU+YtzxOgalmHysG4cvgbsXr16uT7SrbJtzwDAAAAAJNDQhEAAAAAyCahCAAAAABkk1AEAAAAALJJKAIAAAAA2dKvWgKetq6yGQfGqoiIaDRbb967s5gXwxPxtmYAAGC71FU248Dy8YiIKMvW29/vjLn6IUBtJBShg3qiGUfGQxERUQy3drd7uufGsIuDAQCADumJZhxZPhgREWUMR0TEvTFbPwSojdYEAAAAAMgmoQgAAAAAZJNQBAAAAACySSgCAAAAANkkFAEAAACAbBKKAAAAAEA2CUUAAAAAIJuEIgAAAACQTUIRAAAAAMgmoQgAAAAAZJNQBAAAAACySSgCAAAAANkkFAEAAACAbBKKAAAAAEC27skOAKazjUV3/M84JCIiGj0zJjkaAABge7Cx6I7/2fXciIgoy8FJjgaYjravhGLR/gWZRVdX5fhyeDhdSNlMzKTzF46mliMiomyWbY1/cqLqOLp72i6jbFavr6JRpGeR2G5Z6ytRRjmUPpA3+tpLOhYH75+cZvi25YlC0vWva87syvHNJ55IltGYWb2sZX9/RhzzEvOYWT2P9RuS80htt8ZB6XUed91TObq5IR1H0deXnk/VPFavSU6T3A8y9tfm+vWV4xu9vckyknUw1fak2tgMjQP2TU7T/O291eMHBtLzmVG9XYsDM+K4/TeJKRLtVw3HnKxjX2o+GdstddxJ1dEyY5t0zZpVXUbGsqb26cYOOyTLSC5LRhypY1fq+Jizvhqp9ZVoEyIiGjvtWDl+eNWqZBnl4FDl+OT+mFH/km1gYn/OiSN13IqIKA7ar3qCn/8qWUZyHqnz3YxzwDrKiEjU84ztlmpnU3WnXN9+IqZotH/sK9Knom2fi+ZskVqOGQOJdZqxXZvrqtuW1P6a0z9ItU3NteuSZSTrV0Y7m+yHZKyv7oMPrBw/9JvfVsdQQ3+qmVgXT84oPU27ajhPTMnqOw61309OTdPs35gsI9n25PTXE5L94Dq2SQ1l5B2Xqg2vXl05vo48TKMnncbL6YfUwS3PAAAAAEA2CUUAAAAAIJuEIgAAAACQTUIRAAAAAMi2fb2UBSZYo2zG3tF6QUlRth7Aen/MiuZEPHAYAADYLm3eD2n0PxIREQ/07qIfAtRGQhE6qDea8bJ4ICIiiiffRn1xY1FsdHEwAADQIb3RjJc174+IiGJNK7H4v3dZHP1FxlvHATLIagAAAAAA2SQUAQAAAIBsEooAAAAAQDYJRQAAAAAgm4QiAAAAAJBNQhEAAAAAyCahCAAAAABkk1AEAAAAALJJKAIAAAAA2SQUAQAAAIBsEooAAAAAQDYJRQAAAAAgm4QiAAAAAJBNQhEAAAAAyNY92QHAdLYxuuLiODgiIopG18gwAACATtkYXXFxY1FERDR22TciIvqLnskMCZhmJBShk4oiNj65mxWFRCIAADABNuuHdDV6JzkYYDpyyzMAAAAAkE1CEQAAAADIJqEIAAAAAGSTUAQAAAAAsnkpC3TQu8qb4qB4vPVlqIiIiMFoREQx9g+GtzI8U3FHX3KasrmxrXlERBRrql8wUw4PpwtpJpa1Wabj+F2iCSsTZaTGR0RZVi9Lcfd16TIGEus8HUZ6fWUsS1KqiJzqmYpjoL06HhEj+9LWY2i2PYvinmuT05QD/YkJMma0sXpZijtr2KdTcdRQdbIKKVPbvoYyaljWYl3131rLnH0t0X6l5hERUTYT9Tir3UiMz2iqU4qhxPGgmZ5JsSpRxlBGoKnjZ3K7ZazQRNtTPJR+6UFZJtqNjem6kTrWl+WGZBlJqXY2Qy37Uh0NVNFm3aijjUwdw3PiqEMt5wo11I06ziNTYaTqcMZiFAPtt2+11K+n3XyV0fPkgaD4bat9umPGgvjswj/KmClAmoQidND+sToOitX5P2j3PG99m7/PVUMnNNnRzTFYQxntqqHflqWO9dWuOvo6E9BfqsVU2a517NPbyjqvQx3LWkf7NhXmkWOqrK+hGsqYiHqemkciV5glp62fqGN9u6bCcStiarSBU2VdTBV1tBvtbtc6/igzUeqowwOtf4YKNygC9dGiAAAAAADZtq8rFGu4DS59u1XGPFJ/Gcooo+juqS5iqPrSraxbCSZAKs4cRVf17QgTVsZY22Swhts7AQAA2tTs644N+87dYnjP8ur+Z+IJQC119HETfbK82+HbvGaqhr54lkSczf72H1PV9rqIjHVeR44lQ7v5j1YhbdbRjPVZNKr7/3XkYZqD7d/aURVH6pFfm3OFIgAAAACQbfu6QhGmgKGZEWsXzRhz3GNDO1X+dtfutZXj731wfnL+3Q9Xl5GjnL1j5fj9DliRLOORoVmV4/fsWZMsY21Z3YSta1Y/uP53/dXLERHR/evqvw4Wvem/UC44pPo5moOJ5YiIWN+sftj/jKL6r3Ibmuk4Z3VVL+vGMl3GcFn9d6r+ZnpZ9+p9vHL8PT+dXV1AzkPnEw/pL3rTL1fY89nVcXYX6b/upfb5xx9KLGtEdD+S2qenwgPEItJPwM+Js90y0leND+xZvU322u3RZBkpPRl1I7XP/24g3X71dFXPZ8Ng9T699w7VdTwiopF4yNj6RDscEdFbVP+lfc3wzGQZZWLb9t+WuoKi/f1kaFE6zkZRHcchGev8tvuqj/XpNiFH+/vSjs+rLmNe17pkGalzhXmJ86KIiHvW71pdRl91HF1Fum50Jx4K2NtIX03y8EB1ez+rO3210sbEsX7jbXW8pav9trx8VnW70NeVXl+79TxROX6wrL7S7Ynhsc/FNzezUX1uNbsr/cDlhwbnVo5f2LMqWUZf4qqoNVt56c9Ov94Y3RP1TGhguyShCBNs7UF98ZP/s9+Y4y5+7MjK375p1+srx7/7k3+RnP9u/+9PktOkDCw5rHL8Z/7ln5JlXPS7F1eO/8DuP06WcUP/3MrxP12/X+X4b9x3aHIe8/74zsrx3XssTJbxV//n8srxKxInmxERv9ywZ+X4/foeqRx/x4Z0svlFs6qX9c7+dBmpE/R7189LlvHBPf+jcvy7DjqqcnxzYCA5j9RtE117Va/viIj3f+OblePndaXfnPB/Vh9eOf4/PvXyZBlzv3RD9QQTdCtKyoTcxpRY1pzHW9z/lsWV4z9yyleSZaTs1p3+g8ltG/euHH/Jfx2WLGOPHavn84tHFlSO/9gh30rOY4ei+k0kP9u4T7KMvXt+Vzn+ytWLkmUMJZIH9y5O9Kpr2E8e+9TByWl26qteX1cdUt2uRES85W+rj/U7X5RoE3LUcNvX4f+zep8+Yc7NyTK++Fj1ucIJO6fLOPPnb6wc/7oDflY5foeu9Nt2UsnRvXsfS5bxbw+9rHL8S3auPkZHRNyxYffK8Xcurk7UTUQ7HBEx+E/7Vo7fd1Y6sX5q4jxxxdDcyvE3PHFAch4H71D9B/KX7nBHsozPrDymcvx7538/WcZ+3dXnVj/ZOHaC9gXH3x1zf17H26IAxuaWZwAAAAAgm4QiAAAAAJBNQhEAAAAAyCahCAAAAABkk1AEAAAAALJJKAIAAAAA2SQUAQAAAIBstScU99tvvyiKYovP6aefPub0F1100RbTzpgxo+6wAAAAAIAadNdd4E9+8pMYHh4e+X777bfHf/tv/y1OPPHErf5m9uzZsXz58pHvRVHUHRYAAAAAUIPaE4q77bbbqO//8A//EM94xjPi5S9/+VZ/UxRFLFiwIHse/f390d/fP/J9zZo14w8UJkA51kAPGgAAADppjD5HGS7cAerT0dTGwMBAfPnLX463vOUtlVcdrl27Nvbdd9/Ye++947WvfW384he/qCx32bJlMWfOnJHP3nvvXXfoUI+x6r0rcAEAgE7SDwE6rKMJxUsvvTRWrVoVb37zm7c6zcEHHxxf+MIX4pvf/GZ8+ctfjmazGS960YvigQce2OpvzjrrrFi9evXI5/777+9A9AAAAADA76v9lufN/du//Vscd9xxsXDhwq1Os2TJkliyZMnI9xe96EXxrGc9K/7lX/4lPvaxj435m76+vujr66s9XgAAAACgWscSivfee2/84Ac/iG984xvj+l1PT088//nPjzvvvLNDkQEAAAAAT1fHbnm+8MILY/fdd49Xv/rV4/rd8PBw3HbbbbHHHnt0KDIAAAAA4OnqSEKx2WzGhRdeGKeeemp0d4++CPKUU06Js846a+T7Rz/60fj+978fv/3tb+OWW26JP/uzP4t777033va2t3UiNJhY5RjveR5rGAAAQF30Q4AO68gtzz/4wQ/ivvvui7e85S1bjLvvvvui0Xgqj/n444/H29/+9lixYkXsvPPOcfjhh8e1114bz372szsRGkyoMd+j1pzoKAAAgO3KGH2OIiQUgfp0JKH4yle+Msqt/PXjqquuGvX9nHPOiXPOOacTYQAAAAAANevYMxQBAAAAgOlHQhEAAAAAyCahCAAAAABkk1AEAAAAALIV5dbenrINWbNmTcyZMyeOitdGd9HT0XkVXV2V48vh4YxCEnncMv0a4KK7ejnLocF0HNNEaptMmDG262cGvxfPit+NGjY0M2LtohljFvHY0E6Vs9i1e23l+HsfnJ8IMqL74eoycpSzd6wcv98BK5JlPDI0q3L8nj1rkmWsLavfK7Wu2Vc5/nf91csREdH9642V44vedJuz4JDVleMHE8sREbG+2Vs5fkZRvc9vaKbjnNVVvawby3QZw2V1+9bfTC/rXr2PV46/56ezqwvIOawVY76D/anRvdXrOyJiz2dXx9ldpI8HqX3+8YcSyxoR3Y+k9umpcpivXud5cbZbRur3EQN7Vm+TvXZ7NFlGSk9G3Ujt878bSLdfPV3V89kwWL1P771DdR2PiGiM9RrRzaxPtMMREb3FUOX4NcMzk2WUiW3bf1vq3Kr9/WRoUTrORlEdxyEZ6/y2+6qP9ek2IUf7+9KOz6suY17XumQZqXOFeYnzooiIe9bvWl1GX3UcXUW6bnRH9b7W26iu4xERDw9Ut/ezuquP0RERGxPH+o23pZZlItrhiPJZ1e1CX1d6fe3W80Tl+MGyun/wxPDY5+Kbm9moPrea3bUhWcZDg3Mrxy/sWZUsoy/Rd1zTHHub7PTrjdH9eyH+cvZe8ZdLzthi2p7v35SMI6mOPu5E9LVTauiLZ80mtSwZcSS1uy5y1BFnhlryH+3W0Yz1WTSq28isOpyeSXqaNrbLUDkYV8U3Y/Xq1TF7dvWxqSNveQa2rntDxNyfjn1SODfSJ4tVnhf3tvX7bKsfqx7/03QRO0aijAw7R/WBY+eoPtHbK1a1HUMMZEyTsT7I9+wa6k6yv9OfUUYN23WHqE4e7J0YTwf8V6J+/dfEhDEncTzYI9J/dJkK2j2uRUTsGunE05Tw64mZzYQd69v18/aLmJXVGFc7LB5oP5AJkDpnmVZ+NdkBTFy78ox4pOPzmNvxOQCMzS3PAAAAAEC27eoKxTouTa7jMtg6LgtOXtKbiCN1KW5E+nLcrp2qbwuLiGhuaP+vrWWz+lKiVJw5t0Sn5pG3zcaKY6rcaggAAGzPiqFm9D26Zf8s2dOp4dbZnL54HY/tSt42nZhHVt+xzb54a5JEfzzjUW7JOLaR26Ynqm60ncvJWJ9lc4rcZt5GPqgom2OnNsbgCkUg3777tp5P9+EPT3YkAAAAwCTZrq5QhIl2X8yOXWNDdEczdo6BVkLunnsiPvKRiLPPbiXmPvKRiP32i7j3yWcibZpmcwMDEStXRvzoRxH/8A8Rt90W8c53Rpx7bsSFF0a85S1jB/Dyl0f88IcRN98csWRJxPBwKyF40UURp50Wceqprf8fdVTE1Vd3ZB2wmd12i3jrWyMOP7z12X//1vDEC0LiiCNa9eVFL4ro6Wlt/09/OuLii8eefsGCiI9/POKP/ihi551bdetLX4r45Ccjhn7vQed77hnxT//Uqivr1kV8/esRf/u3Ef1jPLfqRz9qTfOqV20x6rcxJzYW3VHPizcSUusr56UsiUmKmemHtZcb2n82XGp1Zf3FdjDnQZ7tmgovVMkpo33JFy1lPEy7HE79BXwcAW11Jhnrq5H4u3Hq6vycOFP7Y2oeEVF0VcdZNjP+Ep9cH6mdLWNhU1cEpNZ3RBSJOHKWtdihun0q16fuDsnZsO2/lGUCdtc8ibpR9KQe9J/e52t5CH9G/UlK7m913DnT/oZNtbPl75+rPB2pNiFnn0/tjzllpOS8Ry51xd1W2qaiLGPXcn3rS0+r23//zOqXFAGMh4QidNDn4vlxYiyPebEh/jjuGd+P77wz4stfbv1/p50iXvjCiP/+3yNe97qIo4+O+MxnIl772lZi8BvfiPjOd0b/fscdW8nG/v6IU07J6gTTYc9+dsSyZa0T1DvuaCXndky8qfWooyK+972IjRsjvvrViCeeiHj961uJv3e/u5VY3Nz8+RE33BCx114Rl1zSms/LXx7xd38XceSREccf/9S0jUar3hx4YKuu7L57q8yenlbCenP/9/8d8fznRzznOWOG+ameJXFnY15NtwqkOn/Vh65yMKMjkoijceCBySKav7ozPZ+EVCehsesuyTKGHnyo7TiSatiuE1FGslOfkdzq3n1BdRlr0w/yb66tfvNszu1UyXkMpBPJjZk7VI4vx/rDwWay4kxM09yYfqlG16zqN/k2161PltHuLWw5yftmf/UfEVLrOyKiSCSNch4V0zjomZXjh39e/caLrNv5UucMObfzpdZ5xuN36pDaV7rn7Vb9+9XVbxOOiChmVL+1eHj16mQZOfUnJbVPT9jbRRO65+9ROb752O/ankfqXCB1LhGR3h9z2o06ks2NRBtZbqWO95WDceLgL1pfdt05IiIunv+i5PwAckkowlR1552tq9I297GPRXzgA63k0CteEfHmN0f8/OcR//qvEYccEvG7zU7APvWp1hVwZ54Z8esJevUk1X71q4iXvSzipz+NWLu29X3Roq1P39XV2rbNZut3P/tZa/hHPxpx440Rf//3Ef/7f0fcd99Tv/nEJyL22SfiL/4i4l/+5anhX/lKxEknRbzpTa3EZEQrwXjYYREnn9waH9GK621vG51QXLiwlQj94Ae3vHoWAACA7Y5nKMK25J/+qfXvC17Q+ve++1oJwwULIs4//6npXvnKiP/r/2rd7vyZz0x4mKOUZcSVV7aSUv/+7xGPPBKxZk3ryrhNt/wuWtS6mu6xx1rjLr64dbXcWP74j1vLtWpVxPr1EbfeGvGud215lcym5z1eeGGr/G98I+LRR1vD9t23Nc3zn9+a1733tq4AfPjhVqLub/5my/nutlvrasA77mhN+8gjrWTeIYfkr4uHH27dNpy4emnEH/5h6+rBr3zlqWRiRGsd/f3fR/T1tW5b32SnnSLe+MaIu+4anUyMiHj/+1v/vv3tTw3be+/Wvzff/NSwm26K2GGH1vJu8s//HPGb30x+XQIAAGBKcIUidNBAdMX3Y7/YL1aP/5bnKps/F+aii1q3sb7hDa2k3H/+Z8T/+/9GrF7duh16Kth554gf/zhixYqIL34x4pnPjHjNa1qJvte+tpVku/nmiC98ofVswT/904h581q3dm/uXe9qJfUee6yVZFu3LuJP/qQ17KUvbd0O/vsOPDDi+utbzx286KKIXXZpPZPy0EMjrr22dSv4N7/ZSirOndu6Lfkd72gl7DY54ICIq65qJeC+972ISy9tJTxf//qIY49txXnjjfWvt6OOav37/e9vOe5732v9+/KXt65cjWg9J3PGjIjLL99y+vvua12p+uIXt251bjYj7r+/Ne75z49Yvrz1/z/4g1ai9pFHWt9PPLH1LMYjjkg/SwgAgClhMLri8u4nH+GyS+uPyIMN3X+gPloU6KBmUcTK2DFmlU8+2+Tee0c/wPnss7e8rbnKX/5l69/fT1694x2tF3acd17ENde0El+nnTb6VthNNp//F7/Y+nTaoYe2kn7vfvdTw847r7U8P/pR68U0n/3sU+O+852IV7+6lej66U9bww44oHU778qVreTWAw+0hv/t30b84AcRJ5wQ8Wd/9tRzJzd5yUta6/gjHxk9/N3vbiXfXvvaiG99a/S4efNGf//SlyL22KOVPNw8uffxj7eu6PvXf20tY90OOqj17x13bDlu5crW8xQ3TZOaftPwRYtaV2jefXerHv3sZ62rGV/0oohdd21d4fi5z7Wmnzu3tV3+n/+ndWs9AADbhGbRiJXFTq0vfXMnNRZgenLLM0xVBx7Yegv0hz/cejvv1Ve3/r9hQyuJtrmHH27d4jxvXutqxW9+s3U13lTxxBOtZz9u7n/9r9a/jz02OpkY8dQz/jZP0v33/956WcinPvVUMjGidbXh+97X+v+b37zlvB96qPXMya0Z64Hbmz+L8rDDWlf1ffGLW14peMcdrWTi8543vlufc82Z0/p3aw9zX7PmqWlyp998umazdaXoD3/YSsa+9KUR55wT8dd/3Rr/qU+1tt3ZZ7eSlVdc0VrfK1Y8NQ0AAADbHVcowlR14IFPXVU3MNC6Iu3f/z3iH/4h4vbbt5z+kktab/ddvPip5+VNFXfcsWXi7qEn30w71pVvm8YtXPjUsOc/v/XvVVdtOf1117XKP+ywLcf97GcRg2O8/fPrX289f/KSSyK+9rXWbcLXXBPx4IOjp3vhC1v/zp/fSuj+vk0vVVm0KOIXv9hy/FR3//2tqzt/36aX/hx9dKv+XXpp698//uPWFaLLlrWucrz44omOGAAAgEkmoQhT1WWXRRx33Ph+sylpN9ZVd5Np05VxmxsaSo/r6Xlq2OzZrX9Xrhx7HitXRuy559jDx3Ljja1nFP7N37SufnzLW54a/r73PZW43HT78x//ceuzNTvuuPVxT9emKw03vwpxc7NnRzz++Pim33y6rZkxI+Lzn2890/Kqq1q3ej/72a3boq+7rnWl5lFHtZ5pKaEIAACw3XHLM7Bt2JR4nD9/7PHz54+dnNz8BTa/78c/br1wZOedWwmyT30q4rnPjfiP/3jqDdSbyjzjjNbzJ7f2+dKXnvaibdWmZyFu/pzETebPj5g1a/TzEqum3zS8v3/sZ2tu7uyzWwnS97yn9f3gg1v/3nrrU9P89KdPXZ0JAADAdkVCETqpLGNGORR9MTzZkWz7Nr2cZdObjze3eHHEzJmjE17jsXFj6xmV73lP6+3OO+wQ8d/+W2vcDTe0/l2y5OmV3Y6rr279+8pXbjnu2GNHTxPRept1f/9TsW9un31aCcD/7/9rvdl6aw47rHXl4V/91ZZXMvb1jf5/VbIWAIDJU5bRVw62PsMD0Tc84NwNqJWEInTQjBiOE2N5HBP3THYo276vfKX1LMSlS1tvXN6kp6f19ueI8b2I5oUvHJ0g22TTFZAbN7b+/clPWom6k06KeMMbtpy+KCJe9rL8+Y7HFVdE3HVX65bszV9QM3t261bt/v7RV0Y+8UTrhTbPeEbrJT2bW7as9e+//uvW59doRPzbv0V897sR/+f/PDX8V79q/ftHf9T6t6urleTcNBwAgCmlL4bixMFftD4rr40TV14bfc0xnisO8DR5hiKwbfjtb1vPNvz0p1svcvn61yPWrWu9pXjRotZLQ7785fzy3ve+1otHrrmm9XKRjRsj/uAPIo45ppXEu+SSp6Y96aSIK69svbzlzDMjbrml9ZzKffZpXbm4226tKyRzXHjhU//flBjdfNg//EPE8uWt/w8PR7ztbRHf+14rzq9+tZU0fP3rI/bbL+Ld7464997R5b///a3l+ud/bi3LnXdGvPzlrTi/9a2n3qA9lne/u5WMfM1rRg//wQ9aL5y54IJWIvbQQyOe9axWHAAAAGx3JBSBbcc557QSZEuXRvzZn0X09kb85jet75/97PjKOv/81i29ixe3Em5F0Xq24N/9XWs+Tzzx1LT33NN6y/TSpRHHHx9x2mmtZN9DD7USff/7f+fP981vrh520UVPJRQjWi9FeclLWs81fOMbW1dk3nZbKyH69a9vWdaKFa1l+vjHI1796lZy8N57Iz7wgYhPfnLrcR1wQOut4u9+95Zvui7LiNe+tpVQfPvbIx57rLUuvvGN7MUGAABg+pBQhKnm3ntbya2n4xWvqDeWOmxtWaqW8+qrtz7u299ufVJS6/H73299cq1aFfGhD7U+7Xg62/YnP3nqduMcK1a0rmwcj9/+tvpN1XfdNfazGQEAANjueIYiAAAAAJBNQhEAAAAAyCahCBOgP7pjOJ7mbcwwxQ1EI1YXY7wxGwAAgGnJMxRhAqyLnri0OChmxHBc3tg/BoquMadr9PZWllM2h6tntP9eyViav7orOc3WzFy1Y/zhR74Ud91Sxh3z/nSr05Vr1yXLKnoSzU93unkaXr2meh5d1X8zaeyyS3Ie5eOrquex267JMmJgoHr8+g3JIobXr6+OI7GsRWPsOjdqmjmzK8eXW1nfq4u+eKSoeP4iAAAA04qEIkyQ9UVvrI+I3xY7x8Zi7F2v0VV9lVcZiYTiDnsk42gWv0tOs1VrIm776Leje/fdInp22/o8GjOSRRVdPdUT5CQUt5KYHZlHYnxX7+7JeTQbiaRk3/xkGRH9lWPL/rXJEoYTVwCmljUnodjonVc5vtlwyAAAAMAtzwAAAADAOEgoAgAAAADZJBQBAAAAgGwSigAAAABANglFAAAAACCbhCIAAAAAkK17sgOA6WwgGnFN7BUREUWjZ2QYAABApwxGV/yoe7/Wl533bA1r6P4D9SnKsiwnO4h2rVmzJubMmRNHxWuju+jp6LyK7uryy6HBjs5/uim6upLTlMPDExBIDUm+slk9i4xlLXp7qydIrIvmwEByHqllzdomiXreNW/nZBnDj6+uHN/oyTjhScTa3NhfPY/U+o6IZv/GyvE56ytZvxJ1J2c+qf2k6OtLz6NRHWeZU78SmoNDyWmS2767enxz/frxhDSmVFsfEVGk4sxou8pm4hCcUTdSZSTrzlQ5btXRDidnUSSnSe1LOe1Gqm3K2ZdSx4NU+xaRXt5U3cjZX7t23KFy/PC6GvbHjO2WauOaG6rb8px9rdE3o3r8Lulj39BDKyvHp9ZnRMY6reF8JNk25UjE0TVrVrqI/kQ9z2g3kvv0jOq6k7O/JtvhjHOa5oYNleMbM2cmy4iiel+p4/hYh2Q7mnM8SO2zqfYtsb4j0ucCWeeAKV05y5rYHxPbPaKGbT8BfaWIjHOWjLYpdcxo97wpYgqdO02EGvoxKVl9stQ5SU4cbS5LY4f0MXoi+iFZ9a+NfXaoHIyrykti9erVMXv27MppXSoFAAAAAGSTUAQAAAAAskkoAgAAAADZJBQBAAAAgGwSigAAAABANu+Nhw6aUQ7FibE8IiKK4Vb+/uLGothY2PUAAIDO6CsH48TBX0RERFm23gp7cRysHwLUxhWKAAAAAEA2CUUAAAAAIJuEIgAAAACQTUIRAAAAAMgmoQgAAAAAZJNQBAAAAACySSgCAAAAANkkFAEAAACAbBKKAAAAAEA2CUUAAAAAIJuEIgAAAACQTUIRAAAAAMgmoQgAAAAAZJNQBAAAAACydU92ADCdDUYjbow9IiKiaDRGhgEAAHTKUHTFT7r2ioiI5uDGiNAPAeoloQgdNFw0YnnMi4iIouia5GgAAIDtwXDRiOVdu0ZERLNYP8nRANORP1EAAAAAANkkFAEAAACAbBKKAAAAAEC22hOKH/nIR6IoilGfRYsWVf7m4osvjkWLFsWMGTPiuc99bnz3u9+tOywAAAAAoAYduULxkEMOiYceemjk8+Mf/3ir01577bVx0kknxVvf+tb46U9/Gscff3wcf/zxcfvtt3ciNAAAAACgDR15y3N3d3csWLAga9rPfOYz8apXvSre+973RkTExz72sbj88svjc5/7XFxwwQWdCA8mTF85FK+Nu1pfmkVERHyrOCj6Cy9YBwAAOqOvHIo/Gfx1RESU5WBERHwznqEfAtSmI1co3nHHHbFw4cI44IAD4uSTT4777rtvq9Ned911ccwxx4waduyxx8Z111231d/09/fHmjVrRn1gKioioi+Goi+GYkY5HDPK4SgmOygAAGCaK0f6IZs++iFAnWr/88TixYvjoosuioMPPjgeeuihOPvss+OlL31p3H777TFr1qwtpl+xYkXMnz9/1LD58+fHihUrtjqPZcuWxdlnn1136BOnSORxy+bElDEFlMPD7ReSWhdZgSTWV848xpymEVHmH7qbG/uzpx0zhK6u5DSpdV4OtV93mmvWJqcpGtXrpTk4lC4jsSyNnuomrhwaTM4jJacON3qrt0vZTNev1PpIbfucutFcv75yfNb+mthXUtskIqLo66sc39ywsa0YcuTUjdT6aMyoXo6IiHJgQ3UZvb0ZcQwkJki0QRnrK7W/1tKW13HsS80iI86uuXMrxw+vTv8Rs2iWiQkylqOG+tXcUF2/Uuuja6edkvMYXlvd3jdmzkyWUcycUTm+XFe9HBHp9ivVBpYZVbjZX932lA8/mi4kNY/ENmvNaPLP8VJtQkv1Oh9eu66G+aQ3XJFoR8uBRBuasb+WQ9V1o7HjDskyisRxPqdu5BwzqoPIaJtqqH/NxDpv9FW3CRE1nCtkqOXYl1hfRZlxfpZxTjzmrMuhKMvWbzfVjUbvjtFV9Gwx7fC6RBuasc/XcS5Qpo6fGfUv2Z4n6nkd/YMsiThyzt2T/alU+5ajhn5y6vw/q9+XOo7n9GHbXJbUuUaWOs67O91Wj+O3tV+heNxxx8WJJ54Yz3ve8+LYY4+N7373u7Fq1ar4+te/Xts8zjrrrFi9evXI5/7776+tbAAAAABg6zr+AIW5c+fGM5/5zLjzzjvHHL9gwYJYuXLlqGErV66sfAZjX19f9CX+KgUAAAAA1K8jz1Dc3Nq1a+Ouu+6KPfbYY8zxS5YsiSuuuGLUsMsvvzyWLFnS6dAAAAAAgHGqPaH4nve8J66++uq455574tprr40TTjghurq64qSTToqIiFNOOSXOOuuskenf+c53xmWXXRaf+tSn4te//nV85CMfiZtuuinOOOOMukMDAAAAANpU+y3PDzzwQJx00knx2GOPxW677RYveclL4vrrr4/ddtstIiLuu+++aDSeymO+6EUviq985SvxgQ98IP7mb/4mDjrooLj00kvjOc95Tt2hAQAAAABtqj2h+NWvfrVy/FVXXbXFsBNPPDFOPPHEukMBAAAAAGrW8WcoAgAAAADTh4QiAAAAAJBNQhEAAAAAyCahCAAAAABkk1AEAAAAALJJKAIAAAAA2bonOwCYzoaiiJ8Vu0dERFEUI8MAAAA6ZfN+SFdXX0REDLueCKiRhCJ00FDRFT+PJxOKDYlEAACg8zbvh3R17zDJ0QDTkT9RAAAAAADZJBQBAAAAgGwSigAAAABANglFAAAAACCbhCIAAAAAkM1bnqGDesuheFXc3frSbL3l+XvF/jFQ2PUAAIDO2Lwf0hjojYiI7/UcpB8C1EZrAh3UiIg5ZX9ERBTRSig2ikkMCAAAmPY274c0ymZERBRRTmJEwHTjlmcAAAAAIJuEIgAAAACQTUIRAAAAAMgmoQgAAAAAZJNQBAAAAACySSgCAAAAANkkFAEAAACAbN2THUCtikbrszVlM/37lFQZGYqurupZDGXMo4Y4UorunuoQhgYzCmk/Z100iuo4hofbnkctxtomZTMiyie/VC9HRHpZGzvsUDl++IknkvOoY5s0ensrxzf7N7Y9jyxFdR1tDgwkfj8xf1NJxZHa1yIivc+X1XUnq26k1NBGJrdJRETONB2WquMREc3BoerxGzakZ5RYp1nrK6FslpXjU8ekHEV3um4k2+qc49oEHPuaqX0lI4bUcTzVlkdENNevrxzfNWdOsoxGYtun2urhtWuT80hpbuxPT5SYpjFzRrKI5LnVRJwrZNSNnLYlKdUWJ+JItQl5ZaT3+dQ5Tda+lNpsOcelRFud7h+k11eq/jVz9qXEsjRmzkwWkXXcqQoh43iQ3CY1zCfrPDJ1btXmOXVERNlf3TZltSuJ7Vo2E/WzNVH1LLZyHlmUZRRP7qvlk/tBObwxmkXGPH8/hIxlTbbDGW1PLf3kNtvICZNqZzOqV2qarH06tV2SfZD0+qyjT5bKPeS1X9UrLHnciomYRz3n/7XkcjK4QhEAAAAAyCahCAAAAABkk1AEAAAAALJJKAIAAAAA2SQUAQAAAIBs0+stzzDFDEcRy2NeREQUT769ajjjbc8AAABP13AUsbyY9+S3cmQYQF0kFKGDBouuuDH2iIiIopF+zTwAAEC7BouuuLHYs/WlbE5uMMC05JZnAAAAACCbhCIAAAAAkE1CEQAAAADIJqEIAAAAAGSTUAQAAAAAsnnLM3RQTzkcr4j7W1+arfz9VcU+MVh44zMAANAZPeVwHFXe2/pSlhGhHwLUS0IROqgrypgf6yIioihbCcWuoozByQwKAACY1rqijAVlqx+yKaGoHwLUyS3PAAAAAEA2CUUAAAAAIJuEIgAAAACQTUIRAAAAAMgmoQgAAAAAZJNQBAAAAACySSgCAAAAANkkFAEAAACAbBKKAAAAAEA2CUUAAAAAIJuEIgAAAACQTUIRAAAAAMgmoQgAAAAAZOue7ABgOhuOIu6N2RERURSNkWEAAACdMhxF3FvMefJbc2QYQF2mVUKx6OqKouja6vhyqFldQJkYHxFlM3FRZzGNLvrMWB8TMY+iqzdRRNn2PJKeZhmDRVdcE3s/+e3JulFGRLmVmBPzGV677mnFMZ55ZBUxNFg5vtFbvc0iIpoDA9Vl9M1ou4yia+vtQURG3alJalma/RvTZSTWaWpd5Ci6eyrHl8PD6TJS67yOMiZgu2Wtz0R7n1qfEellzYmjaFR3DlLrK7U/58hZ1gk5pqSOwTnH+UQdTW2z1myq13lz/fpkGSnDa55ITpMTa5XGzJnpiVLLmrMvJbZLOZCuo6l1nmzfatgPGjvskJwmeRyfCvtJjpw4i1S7kD4e1CJVv5LHpYw4azn/r55PTh1t9xictR/U0M5GWUNSKzGfojfRfg0NJWeRPLZlbPc62paunXaqHD+8du2Ywwci4urYIyJGn0eOufaL1LlCTj+5/T5Zcj45+1q77WgN88jqx6TO/7Pa2epYs86ZU/OpY5+vQ2pZM/oY7cqaRw3bpI6+UDvns0XZzD5ET6PsFwAAAADQaRKKAAAAAEA2CUUAAAAAIJuEIgAAAACQTUIRAAAAAMg2rd7yDFNNTzkcS+LBJ7+18vfXxcIYrHgbOQAAQDs274c0hlvd/usae+mHALWRUIQO6ooy9o01rS9lERERNxZ7xOAkxgQAAExvm/dDirKVRLwh9pzMkIBpxi3PAAAAAEA2CUUAAAAAIJuEIgAAAACQrfaE4rJly+IFL3hBzJo1K3bfffc4/vjjY/ny5ZW/ueiii6IoilGfGTNm1B0aAAAAANCm2hOKV199dZx++ulx/fXXx+WXXx6Dg4Pxyle+MtatW1f5u9mzZ8dDDz008rn33nvrDg0AAAAAaFPtb3m+7LLLRn2/6KKLYvfdd4+bb745Xvayl231d0VRxIIFC+oOBwAAAACoUcefobh69eqIiJg3b17ldGvXro1999039t5773jta18bv/jFL7Y6bX9/f6xZs2bUBwAAAADovI4mFJvNZpx55pnx4he/OJ7znOdsdbqDDz44vvCFL8Q3v/nN+PKXvxzNZjNe9KIXxQMPPDDm9MuWLYs5c+aMfPbee+9OLQIAAAAAsJmOJhRPP/30uP322+OrX/1q5XRLliyJU045JQ477LB4+ctfHt/4xjdit912i3/5l38Zc/qzzjorVq9ePfK5//77OxE+AAAAAPB7an+G4iZnnHFGfOc734lrrrkm9tprr3H9tqenJ57//OfHnXfeOeb4vr6+6OvrqyNMAAAAAGAcar9CsSzLOOOMM+KSSy6JH/7wh7H//vuPu4zh4eG47bbbYo899qg7PAAAAACgDbVfoXj66afHV77ylfjmN78Zs2bNihUrVkRExJw5c2LmzJkREXHKKafEnnvuGcuWLYuIiI9+9KPxwhe+MA488MBYtWpV/OM//mPce++98ba3va3u8AAAAACANtSeUDz//PMjIuKoo44aNfzCCy+MN7/5zRERcd9990Wj8dTFkY8//ni8/e1vjxUrVsTOO+8chx9+eFx77bXx7Gc/u+7wAAAAAIA21J5QLMsyOc1VV1016vs555wT55xzTt2hwKQbjiJWxo6tL0UxMgwAAKBTNu+HFEWr29/UDwFq1LGXsgARg0VXfD/2a30pOvpSdQAAgIgY3Q9pdPVObjDAtCTDAQAAAABkk1AEAAAAALJJKAIAAAAA2SQUAQAAAIBsEooAAAAAQDZveYYO6imH4/nx8JPfioiI+GnMj8Gia/KCAgAAprXN+yGN4Va3/6eNBfohQG0kFKGDuqKMg+N3rS9lK6H482L3GJzEmAAAgOlt835IUbaSiD+L+ZMZEjDNTKuEYjk0uClnM6aiuyf5+/RMmuOMaizt/1Wo0dtbOb45MFBdQJG+271slm2XUYfm4FB7BdQRZy3bvdysrK2Ul4q1ljjaVw4PV49P1Z1I1+G8QKrXR2OnOZXjh9c80X4MGZr9GyvHF13pNiG5H0xEPc+of2V11cgLI1G/poqiUXHAibxjSnKaOtrqCWg3so6fE2EiljWjfUvK2V8nYH9MtT3NDRuS80jJad9ScWbVr8Q6TZWRc0xKnVs1N1S39a1AOl9HU8uSU4fLoRrirGNZazgvSh6Xpsi5V/KYknFoLPr6qstYv7769zn7aw1tYB3H+Xbbr7y2KdGfmiDDa9dWT7DVOtyIys7xZmo5jif2lVRfvLY4UmrY55P1L9UXz1HDuULWOk+dK6TapubEnNPUYiLyFzUsS9vHrYw4quZRjqND5xmKAAAAAEA2CUUAAAAAIJuEIgAAAACQTUIRAAAAAMgmoQgAAAAAZJNQBAAAAACySSgCAAAAANkkFAEAAACAbBKKAAAAAEA2CUUAAAAAIJuEIgAAAACQTUIRAAAAAMjWPdkBwHTWjCJWR98WwwAAADqlGRGri1Y/pCi6IiKinMR4gOlHQhE6aKDoim/FgZMdBgAAsB0ZKLrjW3FQREQ0unT7gfq55RkAAAAAyCahCAAAAABkk1AEAAAAALJJKAIAAAAA2SQUAQAAAIBsXvcEHdRdNuPZ8eioYb+MXWOokMsHAAA6o7scjmfHYxER0Wh2RUTEL4tdY6jomsywgGlEQhE6qDuacWg8MmrYb2JeDLk4GAAA6JDuKOPQ8uGIiCiarb7H8q5dYmgygwKmFVkNAAAAACCbhCIAAAAAkE1CEQAAAADIJqEIAAAAAGSTUAQAAAAAskkoAgAAAADZJBQBAAAAgGzdkx3ARCqHBic7hIioJ47mwECbQTTbjmHCbEuxtmu6LGvGcrRdhzMMr17d8XnUoRwenuwQIiKinBphTA1F+u9tE7LdpkubMJ1sS9skEetE7PMT1r61uV3qOCZNlfPMiTi+5qhl20/E/lbHPGooo479sbl+fZsxbDsnAu3Gui0ta9LW6l/ZjIiy9d8nl7ccHohmMTnHsVrayCmzv24b54B1rPNp1T+YAudFtZhC56KuUAQAAAAAskkoAgAAAADZJBQBAAAAgGwSigAAAABANglFAAAAACDbdvWWZ5hoZUT0/95uVk5OKAAAwHZCPwToNAlF6KD+oju+HgdPdhgAAMB2RD8E6DS3PAMAAAAA2SQUAQAAAIBsEooAAAAAQDYJRQAAAAAgm4QiAAAAAJDNW56hg7rKZhwYq0YNuzPmxnAhlw8AAHSGfgjQaRKK0EE90Ywj46FRw+6N2THs4mAAAKBD9EOATtOaAAAAAADZJBQBAAAAgGwSigAAAABANglFAAAAACCbhCIAAAAAkE1CEQAAAADIJqEIAAAAAGSTUAQAAAAAskkoAgAAAADZJBQBAAAAgGwSigAAAABAto4lFM8777zYb7/9YsaMGbF48eK48cYbK6e/+OKLY9GiRTFjxox47nOfG9/97nc7FRoAAAAA8DR1JKH4ta99LZYuXRof/vCH45ZbbolDDz00jj322Hj44YfHnP7aa6+Nk046Kd761rfGT3/60zj++OPj+OOPj9tvv70T4QEAAAAAT1NRlmVZd6GLFy+OF7zgBfG5z30uIiKazWbsvffe8Vd/9Vfx/ve/f4vp3/jGN8a6deviO9/5zsiwF77whXHYYYfFBRdcsMX0/f390d/fP/J99erVsc8++8RL4o+iO3rqXhx42vpiKE6IO0YNuyQOiv7onqSIgCxFxt/bymbn4wAAeBr0Q4CnYygG48fx3Vi1alXMmTOnctraW5OBgYG4+eab46yzzhoZ1mg04phjjonrrrtuzN9cd911sXTp0lHDjj322Lj00kvHnH7ZsmVx9tlnbzH8x+E2aaae720x5DeTEAUwLrX/qQ0AYGLphwBP1xNPPDHxCcVHH300hoeHY/78+aOGz58/P37961+P+ZsVK1aMOf2KFSvGnP6ss84alYBctWpV7LvvvnHfffclFxgmw5o1a2LvvfeO+++/P2bPnj3Z4cAW1FGmOnWUqUz9ZKpTR5nq1FGmsu2pfpZlGU888UQsXLgwOe02eb1zX19f9PX1bTF8zpw5037jsm2bPXu2OsqUpo4y1amjTGXqJ1OdOspUp44ylW0v9TP3Qr3aX8qy6667RldXV6xcuXLU8JUrV8aCBQvG/M2CBQvGNT0AAAAAMDlqTyj29vbG4YcfHldcccXIsGazGVdccUUsWbJkzN8sWbJk1PQREZdffvlWpwcAAAAAJkdHbnleunRpnHrqqXHEEUfEkUceGeeee26sW7cuTjvttIiIOOWUU2LPPfeMZcuWRUTEO9/5znj5y18en/rUp+LVr351fPWrX42bbropPv/5z2fNr6+vLz784Q+PeRs0TAXqKFOdOspUp44ylamfTHXqKFOdOspUpn6OrSjLsiPvsvzc5z4X//iP/xgrVqyIww47LD772c/G4sWLIyLiqKOOiv322y8uuuiikekvvvji+MAHPhD33HNPHHTQQfHJT34y/uiP/qgToQEAAAAAT1PHEooAAAAAwPRT+zMUAQAAAIDpS0IRAAAAAMgmoQgAAAAAZJNQBAAAAACyTYuE4nnnnRf77bdfzJgxIxYvXhw33njjZIfEdmjZsmXxghe8IGbNmhW77757HH/88bF8+fJR02zcuDFOP/302GWXXWKnnXaK17/+9bFy5cpJipjt3T/8wz9EURRx5plnjgxTR5ls//Vf/xV/9md/FrvsskvMnDkznvvc58ZNN900Mr4sy/jQhz4Ue+yxR8ycOTOOOeaYuOOOOyYxYrYXw8PD8cEPfjD233//mDlzZjzjGc+Ij33sY7H5+w3VTybSNddcE695zWti4cKFURRFXHrppaPG59TH3/3ud3HyySfH7NmzY+7cufHWt7411q5dO4FLwXRWVUcHBwfjfe97Xzz3uc+NHXfcMRYuXBinnHJKPPjgg6PKUEfppFQ7urm/+Iu/iKIo4txzzx01fHuuo9t8QvFrX/taLF26ND784Q/HLbfcEoceemgce+yx8fDDD092aGxnrr766jj99NPj+uuvj8svvzwGBwfjla98Zaxbt25kmne9613x7W9/Oy6++OK4+uqr48EHH4zXve51kxg126uf/OQn8S//8i/xvOc9b9RwdZTJ9Pjjj8eLX/zi6Onpif/8z/+MX/7yl/GpT30qdt5555FpPvnJT8ZnP/vZuOCCC+KGG26IHXfcMY499tjYuHHjJEbO9uATn/hEnH/++fG5z30ufvWrX8UnPvGJ+OQnPxn/9E//NDKN+slEWrduXRx66KFx3nnnjTk+pz6efPLJ8Ytf/CIuv/zy+M53vhPXXHNNvOMd75ioRWCaq6qj69evj1tuuSU++MEPxi233BLf+MY3Yvny5fEnf/Ino6ZTR+mkVDu6ySWXXBLXX399LFy4cItx23UdLbdxRx55ZHn66aePfB8eHi4XLlxYLlu2bBKjgrJ8+OGHy4gor7766rIsy3LVqlVlT09PefHFF49M86tf/aqMiPK6666brDDZDj3xxBPlQQcdVF5++eXly1/+8vKd73xnWZbqKJPvfe97X/mSl7xkq+ObzWa5YMGC8h//8R9Hhq1atars6+sr/9f/+l8TESLbsVe/+tXlW97yllHDXve615Unn3xyWZbqJ5MrIspLLrlk5HtOffzlL39ZRkT5k5/8ZGSa//zP/yyLoij/67/+a8JiZ/vw+3V0LDfeeGMZEeW9995blqU6ysTaWh194IEHyj333LO8/fbby3333bc855xzRsZt73V0m75CcWBgIG6++eY45phjRoY1Go045phj4rrrrpvEyCBi9erVERExb968iIi4+eabY3BwcFR9XbRoUeyzzz7qKxPq9NNPj1e/+tWj6mKEOsrk+9a3vhVHHHFEnHjiibH77rvH85///PjXf/3XkfF33313rFixYlQdnTNnTixevFgdpeNe9KIXxRVXXBG/+c1vIiLiZz/7Wfz4xz+O4447LiLUT6aWnPp43XXXxdy5c+OII44YmeaYY46JRqMRN9xww4THDKtXr46iKGLu3LkRoY4y+ZrNZvz5n/95vPe9741DDjlki/Hbex3tnuwA2vHoo4/G8PBwzJ8/f9Tw+fPnx69//etJigpaDc+ZZ54ZL37xi+M5z3lORESsWLEient7Rw6Qm8yfPz9WrFgxCVGyPfrqV78at9xyS/zkJz/ZYpw6ymT77W9/G+eff34sXbo0/uZv/iZ+8pOfxP/4H/8jent749RTTx2ph2Md99VROu39739/rFmzJhYtWhRdXV0xPDwcf/d3fxcnn3xyRIT6yZSSUx9XrFgRu++++6jx3d3dMW/ePHWWCbdx48Z43/veFyeddFLMnj07ItRRJt8nPvGJ6O7ujv/xP/7HmOO39zq6TScUYao6/fTT4/bbb48f//jHkx0KjLj//vvjne98Z1x++eUxY8aMyQ4HttBsNuOII46Iv//7v4+IiOc///lx++23xwUXXBCnnnrqJEfH9u7rX/96/Pu//3t85StfiUMOOSRuvfXWOPPMM2PhwoXqJ0AbBgcH4w1veEOUZRnnn3/+ZIcDEdG6e+szn/lM3HLLLVEUxWSHMyVt07c877rrrtHV1bXFG0hXrlwZCxYsmKSo2N6dccYZ8Z3vfCeuvPLK2GuvvUaGL1iwIAYGBmLVqlWjpldfmSg333xzPPzww/EHf/AH0d3dHd3d3XH11VfHZz/72eju7o758+ero0yqPfbYI5797GePGvasZz0r7rvvvoiIkXrouM9keO973xvvf//7401velM897nPjT//8z+Pd73rXbFs2bKIUD+ZWnLq44IFC7Z4keXQ0FD87ne/U2eZMJuSiffee29cfvnlI1cnRqijTK4f/ehH8fDDD8c+++wz0ne69957493vfnfst99+EaGObtMJxd7e3jj88MPjiiuuGBnWbDbjiiuuiCVLlkxiZGyPyrKMM844Iy655JL44Q9/GPvvv/+o8Ycffnj09PSMqq/Lly+P++67T31lQhx99NFx2223xa233jryOeKII+Lkk08e+b86ymR68YtfHMuXLx817De/+U3su+++ERGx//77x4IFC0bV0TVr1sQNN9ygjtJx69evj0Zj9KlzV1dXNJvNiFA/mVpy6uOSJUti1apVcfPNN49M88Mf/jCazWYsXrx4wmNm+7MpmXjHHXfED37wg9hll11GjVdHmUx//ud/Hj//+c9H9Z0WLlwY733ve+N73/teRKij2/wtz0uXLo1TTz01jjjiiDjyyCPj3HPPjXXr1sVpp5022aGxnTn99NPjK1/5Snzzm9+MWbNmjTwzYc6cOTFz5syYM2dOvPWtb42lS5fGvHnzYvbs2fFXf/VXsWTJknjhC184ydGzPZg1a9bIMz032XHHHWOXXXYZGa6OMpne9a53xYte9KL4+7//+3jDG94QN954Y3z+85+Pz3/+8xERURRFnHnmmfHxj388DjrooNh///3jgx/8YCxcuDCOP/74yQ2eae81r3lN/N3f/V3ss88+ccghh8RPf/rT+PSnPx1vectbIkL9ZOKtXbs27rzzzpHvd999d9x6660xb9682GeffZL18VnPela86lWvire//e1xwQUXxODgYJxxxhnxpje9KRYuXDhJS8V0UlVH99hjj/jTP/3TuOWWW+I73/lODA8Pj/Sf5s2bF729veooHZdqR38/yd3T0xMLFiyIgw8+OCK0ozHZr5muwz/90z+V++yzT9nb21seeeSR5fXXXz/ZIbEdiogxPxdeeOHINBs2bCj/8i//stx5553LHXbYoTzhhBPKhx56aPKCZrv38pe/vHznO9858l0dZbJ9+9vfLp/znOeUfX195aJFi8rPf/7zo8Y3m83ygx/8YDl//vyyr6+vPProo8vly5dPUrRsT9asWVO+853vLPfZZ59yxowZ5QEHHFD+7d/+bdnf3z8yjfrJRLryyivHPPc89dRTy7LMq4+PPfZYedJJJ5U77bRTOXv27PK0004rn3jiiUlYGqajqjp69913b7X/dOWVV46UoY7SSal29Pftu+++5TnnnDNq2PZcR4uyLMsJyl0CAAAAANu4bfoZigAAAADAxJJQBAAAAACySSgCAAAAANkkFAEAAACAbBKKAAAAAEA2CUUAAAAAIJuEIgAAAACQTUIRAAAAAMgmoQgAAAAAZJNQBAAAAACySSgCAAAAANn+f8YMok4DYizVAAAAAElFTkSuQmCC\n"
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "execution_count": 228
  },
  {
   "cell_type": "markdown",
   "source": [
    "### Dataset"
   ],
   "metadata": {
    "collapsed": false
   },
   "id": "338d603f7024d549"
  },
  {
   "cell_type": "code",
   "source": [
    "class DatasetBBX(data.Dataset):\n",
    "    \"\"\"\n",
    "    Custom PyTorch dataset for bounding box detection task in morse\n",
    "    Generates data samples in runtime\n",
    "    \"\"\"\n",
    "    def __init__(self, number_of_samples=4096, sr=2000, explicit_snr=None):\n",
    "        self.length = number_of_samples\n",
    "        self.sr = sr\n",
    "        self.explicit_snr=explicit_snr\n",
    "\n",
    "    def __len__(self):\n",
    "        return self.length\n",
    "\n",
    "    def __getitem__(self, index):\n",
    "        target = {}\n",
    "\n",
    "        # Generate random parameters for the sample\n",
    "        length = random.randrange(1, 8)\n",
    "        pitch = random.randint(2, 19) * 50\n",
    "        wpm = 18\n",
    "        amplitude = random.randrange(50, 200)\n",
    "        if self.explicit_snr != None:\n",
    "            snrDB = self.explicit_snr\n",
    "        else:\n",
    "            snrDB = random.randrange(-10, 10)\n",
    "\n",
    "        spec, bbx, _ = get_training_sample_bbx(self.sr, length, pitch, wpm, snrDB, amplitude, None, True)\n",
    "\n",
    "        # Store the bounding box and label in the target dictionary\n",
    "        target[\"boxes\"] = torch.Tensor([bbx]).float()\n",
    "        target[\"labels\"] = torch.LongTensor([1])\n",
    "\n",
    "        return spec, target"
   ],
   "metadata": {
    "id": "8d8c9be72b5b2c29",
    "execution": {
     "iopub.status.busy": "2024-03-28T23:03:06.082110Z",
     "iopub.execute_input": "2024-03-28T23:03:06.082497Z",
     "iopub.status.idle": "2024-03-28T23:03:06.090912Z",
     "shell.execute_reply.started": "2024-03-28T23:03:06.082468Z",
     "shell.execute_reply": "2024-03-28T23:03:06.090003Z"
    },
    "trusted": true,
    "ExecuteTime": {
     "end_time": "2024-04-02T07:11:27.745940Z",
     "start_time": "2024-04-02T07:11:27.724361Z"
    }
   },
   "id": "370d42db68fd5314",
   "outputs": [],
   "execution_count": 48
  },
  {
   "cell_type": "markdown",
   "source": [
    "### Training"
   ],
   "metadata": {
    "id": "43a1e075e6622189"
   },
   "id": "46358481a5f32df4"
  },
  {
   "cell_type": "markdown",
   "source": [
    "#### Hyperparameter"
   ],
   "metadata": {
    "id": "3f4abec0f902b291"
   },
   "id": "ae36613af1671f5e"
  },
  {
   "cell_type": "code",
   "source": [
    "SEED = 42\n",
    "NUM_EPOCHS = 50\n",
    "LR = 0.005\n",
    "LR_MOMENTUM=0.9\n",
    "LR_DECAY_RATE=0.001\n",
    "LR_SCHED_STEP_SIZE = 0.1\n",
    "LR_SCHED_GAMMA = 0.1\n",
    "BATCH_SIZE = 64\n",
    "NUM_TEST_IMAGES = 5\n",
    "OUTPUT_DIR = 'faster_rnn_outputs'"
   ],
   "metadata": {
    "id": "4f508c6753e66ee5",
    "execution": {
     "iopub.status.busy": "2024-03-28T23:04:25.128783Z",
     "iopub.execute_input": "2024-03-28T23:04:25.129503Z",
     "iopub.status.idle": "2024-03-28T23:04:25.134581Z",
     "shell.execute_reply.started": "2024-03-28T23:04:25.129470Z",
     "shell.execute_reply": "2024-03-28T23:04:25.133646Z"
    },
    "trusted": true,
    "ExecuteTime": {
     "end_time": "2024-04-02T07:11:30.085636Z",
     "start_time": "2024-04-02T07:11:30.065002Z"
    }
   },
   "id": "7ed17b7eeab8b271",
   "outputs": [],
   "execution_count": 49
  },
  {
   "cell_type": "markdown",
   "source": [
    "#### Model init"
   ],
   "metadata": {
    "id": "52bedd4c11ece79d"
   },
   "id": "308008fc2d383da"
  },
  {
   "cell_type": "code",
   "source": [
    "device = torch.device('cuda') if torch.cuda.is_available() else torch.device('cpu')\n",
    "\n",
    "# Classes\n",
    "labels = ['background', 'morse']\n",
    "num_classes = len(labels)\n",
    "\n",
    "# Model\n",
    "model = torchvision.models.detection.fasterrcnn_resnet50_fpn(min_size=50, max_size=550) # 1 up to 9 morse chars max img size is ~550\n",
    "in_features = model.roi_heads.box_predictor.cls_score.in_features\n",
    "model.roi_heads.box_predictor = FastRCNNPredictor(in_features, num_classes)\n",
    "model.to(device)\n",
    "\n",
    "# Optimizer\n",
    "params = [p for p in model.parameters() if p.requires_grad]\n",
    "optimizer = torch.optim.SGD(params, lr=LR, momentum=LR_MOMENTUM, weight_decay=LR_DECAY_RATE)\n",
    "\n",
    "# Dataset\n",
    "dataset = DatasetBBX()\n",
    "dataset_test = DatasetBBX()\n",
    "torch.manual_seed(SEED)\n",
    "\n",
    "# learning rate scheduler\n",
    "lr_scheduler = torch.optim.lr_scheduler.StepLR(optimizer, step_size=LR_SCHED_STEP_SIZE, gamma=LR_SCHED_GAMMA)\n",
    "\n",
    "# data loaders\n",
    "data_loader = torch.utils.data.DataLoader(\n",
    "    dataset, batch_size=BATCH_SIZE, shuffle=True,\n",
    "    # num_workers=4,\n",
    "    collate_fn=collate_fn)\n",
    "\n",
    "data_loader_test = torch.utils.data.DataLoader(\n",
    "    dataset_test, batch_size=1, shuffle=False,\n",
    "    # num_workers=4,\n",
    "    collate_fn=collate_fn)"
   ],
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "844864f0d6609f4",
    "outputId": "d4e796cd-b5b4-4a87-9882-e702d777d2fb",
    "execution": {
     "iopub.status.busy": "2024-03-28T23:04:37.144136Z",
     "iopub.execute_input": "2024-03-28T23:04:37.144851Z",
     "iopub.status.idle": "2024-03-28T23:04:37.896937Z",
     "shell.execute_reply.started": "2024-03-28T23:04:37.144819Z",
     "shell.execute_reply": "2024-03-28T23:04:37.895706Z"
    },
    "trusted": true,
    "ExecuteTime": {
     "end_time": "2024-04-02T07:11:33.290710Z",
     "start_time": "2024-04-02T07:11:32.318477Z"
    }
   },
   "id": "7ffc43d400b9d788",
   "outputs": [],
   "execution_count": 50
  },
  {
   "cell_type": "markdown",
   "source": [
    "#### Training functions"
   ],
   "metadata": {
    "id": "9929889e54fe378c"
   },
   "id": "d15e08d403f0637b"
  },
  {
   "cell_type": "code",
   "source": [
    "def train_one_epoch(model, optimizer, data_loader, device):\n",
    "    '''\n",
    "    train the model over one epoch.\n",
    "    '''\n",
    "    train_loss_list = []\n",
    "    tqdm_bar = tqdm(data_loader, total=len(data_loader))\n",
    "    \n",
    "    for idx, data in enumerate(tqdm_bar):\n",
    "        optimizer.zero_grad()\n",
    "        images, targets = data\n",
    "\n",
    "        images = list(image.to(device) for image in images)\n",
    "        targets = [{k: v.to(device) for k, v in t.items()} for t in targets]  # targets = {'boxes'=tensor, 'labels'=tensor}\n",
    "\n",
    "        losses = model(images, targets)\n",
    "        loss = sum(loss for loss in losses.values())\n",
    "        train_loss_list.append(loss.detach().cpu().numpy())\n",
    "\n",
    "        loss.backward()\n",
    "        optimizer.step()\n",
    "        tqdm_bar.set_description(desc=f\"Training Loss: {loss:.3f}\")\n",
    "\n",
    "    return train_loss_list\n",
    "\n",
    "\n",
    "def evaluate(model, data_loader_test, device):\n",
    "    '''\n",
    "    validate the model\n",
    "    '''\n",
    "    val_loss_list = []\n",
    "    tqdm_bar = tqdm(data_loader_test, total=len(data_loader_test))\n",
    "\n",
    "    for i, data in enumerate(tqdm_bar):\n",
    "        images, targets = data\n",
    "\n",
    "        images = list(image.to(device) for image in images)\n",
    "        targets = [{k: v.to(device) for k, v in t.items()} for t in targets]\n",
    "\n",
    "        with torch.no_grad():\n",
    "            losses = model(images, targets)\n",
    "        loss = sum(loss for loss in losses.values())\n",
    "        loss_val = loss.item()\n",
    "        \n",
    "        val_loss_list.append(loss_val)\n",
    "        tqdm_bar.set_description(desc=f\"Validation Loss: {loss:.4f}\")\n",
    "        \n",
    "    return val_loss_list\n",
    "\n",
    "\n",
    "def plot_loss(train_loss, valid_loss):\n",
    "    '''\n",
    "    plot training and valdiation losses and save them in `output_dir'\n",
    "    '''\n",
    "    \n",
    "    figure_1, train_ax = plt.subplots()\n",
    "    figure_2, valid_ax = plt.subplots()\n",
    "\n",
    "    train_ax.plot(train_loss, color='blue')\n",
    "    train_ax.set_xlabel('Iteration')\n",
    "    train_ax.set_ylabel('Training Loss')\n",
    "\n",
    "    valid_ax.plot(valid_loss, color='red')\n",
    "    valid_ax.set_xlabel('Iteration')\n",
    "    valid_ax.set_ylabel('Validation loss')\n",
    "\n",
    "    figure_1.savefig(f\"{OUTPUT_DIR}/train_loss.png\")\n",
    "    figure_2.savefig(f\"{OUTPUT_DIR}/valid_loss.png\")"
   ],
   "metadata": {
    "id": "e86e16df87d12e57",
    "execution": {
     "iopub.status.busy": "2024-03-28T23:04:41.743986Z",
     "iopub.execute_input": "2024-03-28T23:04:41.744879Z",
     "iopub.status.idle": "2024-03-28T23:04:41.758845Z",
     "shell.execute_reply.started": "2024-03-28T23:04:41.744845Z",
     "shell.execute_reply": "2024-03-28T23:04:41.757958Z"
    },
    "trusted": true,
    "ExecuteTime": {
     "end_time": "2024-04-02T07:11:35.952949Z",
     "start_time": "2024-04-02T07:11:35.932885Z"
    }
   },
   "id": "df221e613fa2df03",
   "outputs": [],
   "execution_count": 51
  },
  {
   "cell_type": "markdown",
   "source": [
    "#### Load checkpoint\n",
    "epoch 541 checkpoint available at: https://we.tl/t-Bk8Sfvh2bR [320 MB]"
   ],
   "metadata": {
    "collapsed": false
   },
   "id": "3b67f1cfadd2c409"
  },
  {
   "cell_type": "code",
   "source": [
    "checkpoint_files = [f for f in os.listdir(OUTPUT_DIR) if f.endswith('.pth')]\n",
    "if checkpoint_files:\n",
    "    # Last checkpoint file\n",
    "    checkpoint_files.sort()\n",
    "    latest_checkpoint = os.path.join(OUTPUT_DIR, checkpoint_files[-1])\n",
    "    checkpoint = torch.load(latest_checkpoint)\n",
    "    model.load_state_dict(checkpoint['model_state_dict'])\n",
    "    optimizer.load_state_dict(checkpoint['optimizer_state_dict'])\n",
    "    start_epoch = checkpoint['epoch']\n",
    "    loss_dict = checkpoint['loss_dict']\n",
    "else:\n",
    "    start_epoch = 0\n",
    "    loss_dict = {'train_loss': [], 'valid_loss': []}"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2024-04-02T07:23:54.622638Z",
     "start_time": "2024-04-02T07:23:53.829937Z"
    }
   },
   "id": "d1b1f676e7bafd90",
   "outputs": [],
   "execution_count": 197
  },
  {
   "cell_type": "code",
   "source": [
    "# Count the total number of parameters\n",
    "total_params = sum(p.numel() for p in model.parameters())\n",
    "log.info(f\"Total number of parameters: {total_params}\")\n",
    "\n",
    "# Count the number of trainable parameters\n",
    "trainable_params = sum(p.numel() for p in model.parameters() if p.requires_grad)\n",
    "log.info(f\"Number of trainable parameters: {trainable_params}\")"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2024-04-02T07:23:56.410350Z",
     "start_time": "2024-04-02T07:23:56.388264Z"
    }
   },
   "id": "7a5a849a0013d8ec",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2024-04-02 10:23:56 [INFO] root - Total number of parameters: 41299161\n",
      "2024-04-02 10:23:56 [INFO] root - Number of trainable parameters: 41076761\n"
     ]
    }
   ],
   "execution_count": 198
  },
  {
   "cell_type": "markdown",
   "source": [
    "#### Train"
   ],
   "metadata": {
    "id": "5d3462636bd06cb5"
   },
   "id": "4c00c10f3d12d3d5"
  },
  {
   "cell_type": "code",
   "source": [
    "for epoch in range(start_epoch, start_epoch + NUM_EPOCHS):\n",
    "    log.info(\"----------Epoch {}----------\".format(epoch+1))\n",
    "\n",
    "    # Train the model for one epoch\n",
    "    train_loss_list = train_one_epoch(model, optimizer, data_loader, device)\n",
    "    loss_dict['train_loss'].extend(train_loss_list)\n",
    "\n",
    "    lr_scheduler.step()\n",
    "\n",
    "    # Run evaluation\n",
    "    valid_loss_list = evaluate(model, data_loader_test, device)\n",
    "    loss_dict['valid_loss'].extend(valid_loss_list)\n",
    "\n",
    "    if epoch % 10 == 0:\n",
    "        # Save model\n",
    "        ckpt_file_name = f\"{OUTPUT_DIR}/epoch_{epoch+1}_model.pth\"\n",
    "        torch.save({\n",
    "            'epoch': epoch+1,\n",
    "            'model_state_dict': model.state_dict(),\n",
    "            'optimizer_state_dict': optimizer.state_dict(),\n",
    "            'loss_dict': loss_dict\n",
    "        }, ckpt_file_name)\n",
    "\n",
    "    plot_loss(loss_dict['train_loss'], loss_dict['valid_loss'])\n",
    "\n",
    "# Store the losses after the training in a pickle\n",
    "with open(f\"{OUTPUT_DIR}/loss_dict.pkl\", \"wb\") as file:\n",
    "    pickle.dump(loss_dict, file)\n",
    "\n",
    "log.info(\"Training Finished !\")"
   ],
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 1000
    },
    "id": "8e04700b64ae7eae",
    "outputId": "599aed50-daa2-4277-8b0f-c1aefcea34ab",
    "execution": {
     "iopub.status.busy": "2024-03-28T23:04:56.869015Z",
     "iopub.execute_input": "2024-03-28T23:04:56.870039Z",
     "iopub.status.idle": "2024-03-29T00:38:42.262969Z",
     "shell.execute_reply.started": "2024-03-28T23:04:56.870005Z",
     "shell.execute_reply": "2024-03-29T00:38:42.261850Z"
    },
    "trusted": true
   },
   "id": "7ff96b0b6a1b24bf",
   "outputs": [],
   "execution_count": null
  },
  {
   "cell_type": "markdown",
   "source": "### Evaluate",
   "metadata": {
    "collapsed": false
   },
   "id": "8b83c72073f4e1e0"
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-04-02T07:11:45.712067Z",
     "start_time": "2024-04-02T07:11:45.691985Z"
    }
   },
   "cell_type": "code",
   "source": [
    "def IoU_loss_x_axis_only(pred_box, gt_box):\n",
    "    \"\"\"\n",
    "    Calculates modified Intersection-over-Union loss considering only x-axis overlap.\n",
    "  \n",
    "    Args:\n",
    "        pred_boxes: numpy array of predicted bounding boxes (format: [x1, y1, x2, y2])\n",
    "        gt_boxes: numpy array of ground truth bounding boxes (same format)\n",
    "  \n",
    "    Returns:\n",
    "        Modified IoU loss (float)\n",
    "    \"\"\"\n",
    "    # Calculate overlap width\n",
    "    overlap_width = np.maximum(0, np.minimum(pred_box[2], gt_box[2]) - np.maximum(pred_box[0], gt_box[0]))\n",
    "\n",
    "    # Union width based on wider box (modify as needed)\n",
    "    union_width = np.maximum(pred_box[2] - pred_box[0], gt_box[2] - gt_box[0])\n",
    "\n",
    "    # Calculate modified IoU loss (1 - IoU_x)\n",
    "    iou_loss = 1.0 - np.mean(overlap_width / np.maximum(union_width, 1e-10))\n",
    "    return iou_loss"
   ],
   "id": "5f5fb07eea7a4726",
   "outputs": [],
   "execution_count": 54
  },
  {
   "cell_type": "code",
   "source": [
    "random.seed(SEED)\n",
    "num_images = NUM_TEST_IMAGES\n",
    "\n",
    "plot = True\n",
    "num_of_samples = 1\n",
    "\n",
    "eval_loss = []\n",
    "model.eval()\n",
    "for i in range(num_of_samples):\n",
    "    x = random.randint(0, (dataset_test.__len__()-1))\n",
    "    img, target = dataset_test.__getitem__(x)\n",
    "    img = img.to(device)\n",
    "    box, scores, labels = inference(img, model)\n",
    "    if len(box) > 0:\n",
    "        iou_loss = IoU_loss_x_axis_only(box[0], target[\"boxes\"][0].numpy())\n",
    "    else:\n",
    "        iou_loss = 1.0\n",
    "    eval_loss.append(iou_loss)\n",
    "    if plot:\n",
    "        log.info(f'IoU-x loss = {iou_loss}')\n",
    "        plot_image(img.cpu(), box, scores, labels, ['background', 'morse'],'')\n",
    "print(f'Final IoU-x loss = {np.mean(eval_loss)}')"
   ],
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "sa3HuG6phBD2",
    "outputId": "260d91f7-c053-43ec-fada-b7c5666adfc7",
    "execution": {
     "iopub.status.busy": "2024-03-29T00:41:33.769367Z",
     "iopub.execute_input": "2024-03-29T00:41:33.770382Z",
     "iopub.status.idle": "2024-03-29T00:42:12.182549Z",
     "shell.execute_reply.started": "2024-03-29T00:41:33.770344Z",
     "shell.execute_reply": "2024-03-29T00:42:12.181385Z"
    },
    "trusted": true,
    "ExecuteTime": {
     "end_time": "2024-04-02T07:26:01.334566Z",
     "start_time": "2024-04-02T07:26:01.083200Z"
    }
   },
   "id": "e3433ad6f5bfd005",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2024-04-02 10:26:01 [INFO] root - IoU-x loss = 0.05405405405405406\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 1600x800 with 1 Axes>"
      ],
      "image/png": "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\n"
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Final IoU-x loss = 0.05405405405405406\n"
     ]
    }
   ],
   "execution_count": 210
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-03-31T17:04:15.666586Z",
     "start_time": "2024-03-31T16:59:52.137296Z"
    }
   },
   "cell_type": "code",
   "source": [
    "# per SNR\n",
    "snrs = [-15, -10, -5, 0, 5, 10, 15]\n",
    "ious = []\n",
    "num_of_samples = 1000\n",
    "\n",
    "for i in range(len(snrs)):\n",
    "    log.info(f'Evaluating model for snr: {snrs[i]}')\n",
    "\n",
    "    dataset_test = DatasetBBX(explicit_snr=snrs[i])    \n",
    "    data_loader_test = torch.utils.data.DataLoader(\n",
    "        dataset_test, batch_size=1, shuffle=False,\n",
    "        collate_fn=collate_fn)\n",
    "\n",
    "    eval_loss = []\n",
    "    model.eval()\n",
    "    for i in range(num_of_samples):\n",
    "        x = random.randint(0, (dataset_test.__len__()-1))\n",
    "        img, target = dataset_test.__getitem__(x)\n",
    "        img = img.to(device)\n",
    "        box, scores, labels = inference(img, model)\n",
    "        if len(box) > 0:\n",
    "            iou_loss = IoU_loss_x_axis_only(box[0], target[\"boxes\"][0].numpy())\n",
    "        else:\n",
    "            iou_loss = 1.0\n",
    "        eval_loss.append(iou_loss)\n",
    "\n",
    "    ious.append(np.mean(eval_loss))"
   ],
   "id": "b722dc0ce3511443",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2024-03-31 19:59:52 [INFO] root - Evaluating model for snr: -15\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\Maor\\AppData\\Local\\Temp\\ipykernel_31128\\3015226362.py:56: ComplexWarning: Casting complex values to real discards the imaginary part\n",
      "  time_domain_signal = time_domain_signal.astype(np.float32)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2024-03-31 20:00:27 [INFO] root - Evaluating model for snr: -10\n",
      "2024-03-31 20:01:00 [INFO] root - Evaluating model for snr: -5\n",
      "2024-03-31 20:01:39 [INFO] root - Evaluating model for snr: 0\n",
      "2024-03-31 20:02:13 [INFO] root - Evaluating model for snr: 5\n",
      "2024-03-31 20:02:48 [INFO] root - Evaluating model for snr: 10\n",
      "2024-03-31 20:03:23 [INFO] root - Evaluating model for snr: 15\n"
     ]
    }
   ],
   "execution_count": 153
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-03-31T17:08:00.372136Z",
     "start_time": "2024-03-31T17:08:00.283066Z"
    }
   },
   "cell_type": "code",
   "source": [
    "plt.plot(snrs, ious, color='blue')\n",
    "plt.scatter(snrs, ious, marker='x', color='red')\n",
    "plt.xlabel('SNR')\n",
    "plt.ylabel('IoU-x Loss')\n",
    "plt.title('Faster-RCNN IoU-x Loss vs SNR')\n",
    "plt.ylim(0, 0.5)\n",
    "plt.show()"
   ],
   "id": "9caccb4cf349e5f0",
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ],
      "image/png": "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\n"
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "execution_count": 159
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": [
    "# Demo\n",
    "Example on how we can use both models - one for decoding the morse information, and the other for detecting morse in the frame"
   ],
   "id": "69f8abd3fd332155"
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "## Utils",
   "id": "e156d6428a35225b"
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-04-02T07:15:41.760569Z",
     "start_time": "2024-04-02T07:15:41.744693Z"
    }
   },
   "cell_type": "code",
   "source": [
    "def plot_decode_detect(img, boxes, scores, labels, dataset, original_str, predicted_str):\n",
    "    '''\n",
    "    Function that draws the BBoxes, scores, and labels on the image.\n",
    "\n",
    "    inputs:\n",
    "      img: input-image as numpy.array (shape: [H, W, C])\n",
    "      boxes: list of bounding boxes (Format [N, 4] => N times [xmin, ymin, xmax, ymax])\n",
    "      scores: list of conf-scores (Format [N] => N times confidence-score between 0 and 1)\n",
    "      labels: list of class-prediction (Format [N] => N times an number between 0 and _num_classes-1)\n",
    "      dataset: list of all classes [\"background\", \"morse\"] => Format [N_classes]\n",
    "    '''\n",
    "    # Preprocessing\n",
    "    img = img.permute(1,2,0).numpy()\n",
    "    img = np.squeeze(img, axis=-1)\n",
    "    class_labels = np.array(dataset)\n",
    "\n",
    "    # Plotting\n",
    "    fig, ax = plt.subplots(1, figsize=(16, 8))\n",
    "    plt.pcolormesh(img)\n",
    "    for i, box in enumerate(boxes):\n",
    "        # box[1] += 1\n",
    "        # box[3] += 1\n",
    "        \n",
    "        # BBX\n",
    "        class_pred = labels[i]\n",
    "        conf = scores[i]\n",
    "        rect = patches.Rectangle(\n",
    "            (box[0], box[1]),\n",
    "            box[2]-box[0],\n",
    "            box[3]-box[1],\n",
    "            linewidth=4,\n",
    "            edgecolor='red',\n",
    "            facecolor=\"none\",\n",
    "        )\n",
    "        ax.add_patch(rect)\n",
    "\n",
    "        # Add vertical lines\n",
    "        ax.axvline(x=box[0], color='r', linestyle='--', linewidth=3, alpha=0.5)\n",
    "        ax.axvline(x=box[2], color='r', linestyle='--', linewidth=3, alpha=0.5)\n",
    "\n",
    "        # Add the label\n",
    "        plt.text(\n",
    "            box[0], box[1],\n",
    "            s='predicted <' + predicted_str + '> ' + class_labels[int(class_pred)] + \" \" + str(int(100*conf)) + \"%\",\n",
    "            color=\"white\",\n",
    "            fontsize=14,\n",
    "            verticalalignment=\"top\",\n",
    "            bbox={\"color\": 'red', \"pad\": 0},\n",
    "        )\n",
    "        plt.text(\n",
    "            box[0], box[3],\n",
    "            s='target <' + original_str + '>',\n",
    "            color=\"white\",\n",
    "            fontsize=14,\n",
    "            verticalalignment=\"bottom\",\n",
    "            bbox={\"color\": 'darkred', \"pad\": 0},\n",
    "        )\n",
    "\n",
    "    plt.show()\n",
    "    \n",
    "    \n",
    "def spec_to_lstm(spec):\n",
    "    spec_ = torch.from_numpy(spec)\n",
    "    spec_ = spec_.permute(1, 0)\n",
    "    return spec_"
   ],
   "id": "4b8952c7a2a2d663",
   "outputs": [],
   "execution_count": 93
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "## init models",
   "id": "84a1dc7f9e86b088"
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-04-02T07:27:34.779397Z",
     "start_time": "2024-04-02T07:27:33.141081Z"
    }
   },
   "cell_type": "code",
   "source": [
    "device = torch.device('cuda') if torch.cuda.is_available() else torch.device('cpu')\n",
    "\n",
    "# init decoder\n",
    "run_date = '2024-03-26_01-45-23'\n",
    "# run_date = '2024-03-31_23-29-30'\n",
    "epoch = 3950\n",
    "spectrogram_size = generate_morse_sample(sr=2000)[1].shape[0]\n",
    "model_lstm = LSTMRnn(num_tags, spectrogram_size).to(device)\n",
    "model_lstm.load_state_dict(torch.load(f\"models/{run_date}_{epoch:06}.pt\", map_location=device))\n",
    "model_lstm.eval()\n",
    "print(f\"models/{run_date}_{epoch:06}.pt\")\n",
    "\n",
    "# init detector\n",
    "labels = ['background', 'morse']\n",
    "num_classes = len(labels)\n",
    "model_resnet = torchvision.models.detection.fasterrcnn_resnet50_fpn(min_size=50, max_size=550) # 1 up to 9 morse chars max img size is ~550\n",
    "in_features = model_resnet.roi_heads.box_predictor.cls_score.in_features\n",
    "model_resnet.roi_heads.box_predictor = FastRCNNPredictor(in_features, num_classes)\n",
    "\n",
    "checkpoint_files = [f for f in os.listdir(OUTPUT_DIR) if f.endswith('.pth')]\n",
    "checkpoint_files.sort()\n",
    "latest_checkpoint = os.path.join(OUTPUT_DIR, checkpoint_files[-1])\n",
    "checkpoint = torch.load(latest_checkpoint)\n",
    "model_resnet.load_state_dict(checkpoint['model_state_dict'])\n",
    "optimizer.load_state_dict(checkpoint['optimizer_state_dict'])\n",
    "model_resnet.to(device)\n",
    "print(latest_checkpoint)"
   ],
   "id": "ce0194c92c3f0720",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "models/2024-03-26_01-45-23_003950.pt\n",
      "faster_rnn_outputs\\epoch_541_model.pth\n"
     ]
    }
   ],
   "execution_count": 212
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "## Generate, Decode & Detect",
   "id": "aa38c0ff364a0326"
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-04-02T13:27:14.193283Z",
     "start_time": "2024-04-02T13:27:13.801396Z"
    }
   },
   "cell_type": "code",
   "source": [
    "# Params\n",
    "# ----------------------------------------------------------------\n",
    "sr = 2000\n",
    "length = random.randrange(1, 7)\n",
    "pitch = 950 # random.randint(2, 19) * 50\n",
    "wpm = 18\n",
    "snrDB = random.randrange(-5, 10)\n",
    "amplitude = random.randrange(100, 300)\n",
    "\n",
    "# Generate random morse sample\n",
    "# ----------------------------------------------------------------\n",
    "time_domain_signal, spec, target_str, bbx = generate_morse_sample(sr, length, pitch, wpm, -5, amplitude, \"YOUTUBE\")\n",
    "log.info(f\"pitch: {pitch}, wpm: {wpm}, snrDB: {snrDB}, amplitude: {amplitude}, str: {target_str}, bbx: {bbx}\")\n",
    "\n",
    "# Decode\n",
    "# ----------------------------------------------------------------\n",
    "spec_lstm = torch.from_numpy(spec).permute(1, 0).unsqueeze(0).to(device) # preprocess for lstm\n",
    "with torch.no_grad():\n",
    "    y_pred_lstm = model_lstm(spec_lstm)\n",
    "predicted_str = prediction_to_str(torch.argmax(y_pred_lstm[0], 1))\n",
    "\n",
    "# Detect\n",
    "# ----------------------------------------------------------------\n",
    "spec_frnn = spectrum_to_img(spec) # preprocess for faster-rcnn\n",
    "with torch.no_grad():\n",
    "    \n",
    "    bbx, scores, labels = inference(spec_frnn, model_resnet)\n",
    "\n",
    "# Plot\n",
    "# ----------------------------------------------------------------\n",
    "plot_decode_detect(spec_frnn.cpu(), bbx, scores, labels, ['background', 'morse'], predicted_str, target_str)"
   ],
   "id": "9d19f466ac555aeb",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2024-04-02 16:27:13 [INFO] root - pitch: 950, wpm: 18, snrDB: 3, amplitude: 164, str: YOUTUBE, bbx: (17, 19, 257, 20)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 1600x800 with 1 Axes>"
      ],
      "image/png": "iVBORw0KGgoAAAANSUhEUgAABRQAAAKTCAYAAABo9IQGAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy88F64QAAAACXBIWXMAAA9hAAAPYQGoP6dpAADG60lEQVR4nOzdeZwdVZ338W/Vvb1l686+QHYg7KsKiAoICpFBZFNxYXHB8RE3UAd8EBAZedAZRUeEGUZAREeEUWTEiQqyKCDIEmSHhOxJZ+/udKe3e6uePyrd6fM7p/tWh4QI/Xm/XnlB1a1TderUOadO/bqWKE3TVAAAAAAAAACQQ7yzMwAAAAAAAADg9YOAIgAAAAAAAIDcCCgCAAAAAAAAyI2AIgAAAAAAAIDcCCgCAAAAAAAAyI2AIgAAAAAAAIDcCCgCAAAAAAAAyK24szOwPSRJopUrV2rkyJGKomhnZwcAAAAAAAB4XUnTVJs2bdKUKVMUxwPfg/iGCCiuXLlSU6dO3dnZAAAAAAAAAF7Xli1bpl133XXAZd4QAcWRI0dKkt5Re4qKUVXv/KS9Y9DriopVznRa6vaWietqnemko6vyitPE3U6h4K931EhnutzU4qaJK999mZbL7oxo8E+1x9VV3ryks7Pyes0++uut9mcW3XKw5RKZMpGk0opVg95O0l1yZ1TIa0hhxHB/vdtQx7xjZITqhi3vYL2sqRlwvd4x3Ea2fEP7Y+cF98nKsY9WcsT+znTxiZfcdXT568jTRuI6tyyTze3u74E6liapO50j/952bdmadUpSVHDzmwT20U9Tufxtfm1ekq4c/VyObRem7eJMl5eu8NIUxo9ztz1xtDv9N/c4S/LbtDmuoTLIc4xsukrtN7ht03eH1hEPq3OX6XL7rG2pTyH2uEbmfCZJ5eYWb15fRXN8JClpbXWnTd8Y6p9s3Y2r/CGJ1wbMcQ6VZXHyJGe6vHa9m2Y7laVV2HeON6/8zIvOdJ76VDRtpGTaiB2nSFJ6yJ7ujEef9fNX755Pozq3zin1+5u0rc2Ztn1hqI/KM97xkphyKO4+y1um9PIrFdfjMW0xrjV9bOgcUaHOhdZr23i8125eElsXbJuIAmOvcuvmAbeTqz8KqNi/B86Llepu6agDvDTFe58cOCM5xpLB8bIZj6Ud7vgmNN6x7cae50P1v9zq1n+vPuXos0L9TaWytOcDSUrazT7lGMcWJ010psvrNnjLVOoP84xJ4xHD3O00NVdcT65xoh0XhvrLcWPcGeaYlFY2+uutoLjLZG9euXFNxbxY3j7n6C+3RaF+lDMdOocXZ05zpkuLlvorqnTNmKfOTXHPv2mDfx2XLlrmTNvxQnC8tg1jLy9vu83w12vGB+XmTWYBf59t3+2Nw3OcM0LL2OMo89RlqF1VGi/kkR6+n7vZh58e9Dq2VXGM236TdvecF4qxFEx/E6obdqxi+//C5PFemtKylQOmiar8elkpDhCKHZTb3LwF65i9JuisfI72+vIcdc6ry33OnSV168/6bW+cbSBviIBiz2POxahKxWjrICmJBj/QiiITUAzE8OLIDMSiwAnCYwZIUWCAFJsLPZOXPI9zp7bybEtAMQoE5KKBL9a3LFVhvf5gWZFbBW25RHEgSBZaT4XtJF7ZbUNAMVgug69j3jEyQnXDG1TlqJeWdwy3kS3f0P7YecF9snLso5UU3WBI0ZRBaB152ojfxkvm98AFvekH8uTf364t20BA0ZRlkmM7ecrf5tfmJV8/V3nbBdOmbT+XLWPKv2BOeME+oEJAMVAGeY6RTVep/Ya3bYIAOepc6qWpvNk87HGNAv1G6Jj0VYxDfaFtM+YCOdh/2rwFLs69emcCioGytPnLc17fHgoF/3zln8cr16eiPe956wj0P6YvDJ0n7TkssscxFFCM3AGq7QtDfVSe8Y6/HbccioGyrHTuD7KBj1zniIHrXGi9to3HOeqCzUvouEam/PP0JXlU7N9DAcVKddfWQcn5I39QjrFkcLzsHUc3/6HxTqXyl0Ln24Ev4vL0WaE6Vqksc43Dc4xjK/WF/eXPTZMjoJirLg+8z/nGvpX7e8Vm29vQb3h9sELnkcptz9/nyv3ltvD69sA+VzqvZPMq7VOeOuduJw30hWmF8UJ4vDb4sZeXtxx58csuEITx8m+XyBFQDCzjXWea/n6bj2sFdvxQaQy4Pdn2a8cYoWsPW05p4Frcrsfuk70WyRYaeKwVBfr7SnGAUOwgMnnLU8e8viN47W03VLnO+XW5zzJbNpkn/sRHWQAAAAAAAADk9oa4QxGVVaVlHS73Vt6HNUXdee4cAwAAAAAAEPEFZAgoDhEFpZqeuu9eeDSarB3zJikAAAAAAPBGVFCq6XLf2fmoiC8MNTzyDAAAAAAAACA3AooAAAAAAAAAciOgCAAAAAAAACA3AooAAAAAAAAAcuOjLENQWd1KVNKIdKOqAlUgTvx5Sdpll/JXnCYDbjdOqgKZcb8CFZn1Rl0dXpJSunHQ20nSsjujQl5DCuXOwHr9/FWSVth2lIbi/O68NC35SyTVA67XP4bbxpZvastW/j6G98lbs1mHv4/edjatcKYLyXqzjq2vBe5WjTqi4TnyAQAAAAAABkJAcYgpq1vrtUBSqkO0SEoDC+WJO4XSVRL65FOlz0C1baftbA+bd9B6LT8+l8/2iRdWti3lu637VMkT9wwiC7EeLLxH7ardQZkBAAAAAGBo4JHnISZRSVKqqUceqS+lqd566aU7O0vbxfE33qgvpalGTZ/+mmwvKhT0kb/+VReUy5p65JH95+uGG/SlNNXBn/9877xCTY0O/tzn9MEHHtBn1q3TFzo69Klly3Tirbdq6tFHB9fTc7yOv/HGfrdll+kpk7z/9jnrLEnSJxct0pfSgSPGoWX2Oessb50XlMs6b+NGffCBB7Tv2WcH15Unb9tDQYmq5N9lCgAAAAAABoc7FIFtkJbL+u1HP6qPPvGEjr/xRt20//7qbm11lpl1wgna95xztPSPf9QT3/ueJKlh9mydctddGjNnjpoWLtSLv/iFOpuaVD9rlmadcILmvP/9eurf/113f+YzSsuv7ra+BXfcoZbFi515U486SlOPOkov33GH1s6f7/y2xkxvqyV3360Vf/6zJCkqFjVq6lTNPukkHX/jjRq79966/ytf8dJsXrdO83/wg+2yfQAAAAAAsGMRUARyigoFTTzoIDU+9pgkacMLL+jPX/2qjv7ud3X0d7+r33/yk73L1o4erXf/x3+os7lZ/7vlzrzqUaN06rx5Gr3bbnr48sv10Ne/rjTZ+q7B4ZMn63133KEDPvUpdTY364F/+qdXld8Fv/61Fvz61868tyoLKi644w49++Mfv6r192fJ3Xfr0auucuaNmj5dZz/zjA767Gf14CWXqNThvnuyfd06PfT1r+da/5g5c9S2erU6m5q2V5YBAAAAAMAg8MjzEPTWSy/VB+67L/v/yy5zHi3teWR49O676x1XXaWPPv549lhue7s+9uKLevuVV6pquP9hiw/ce6++lKYq1NToiG98Q59YsEBf7OpyHqne/eST9ZG//lWf37xZn25s1Lv/4z9U09CgTy5apE8uWuStM66q0iFf/KI++vjj+nxrqz7X0qIPPvCAZp94orPcJxct6n2c9tzFi3v35QP33rtdymvCQQfpqO98R/+4fLneff31zm+PX321lt57r/b/xCc0c+7c3vnH/OAHGjFliv74+c9r07JlkqQ3f/nLGr3bbnrullv04KWXOsFESWpbtUq/OvFEta9frzddcIEaZs/eLvn/e9CyZIk2vPiiirW1qh458lWta88PflCfXrVK773tNs0+8UTFRf4uAgAAAADAa4kr8SFo2X336ZmbbtK+Z5+tZffdp2VbgouSeu/62v2UU7Tfxz+uZffeq2X33acojjX5sMN06IUXauqRR+rn73iHkpL/Fd6T/vu/Nf6AA7Ro3jx1NjWpeUugcN9zztHxN9ygzuZmPXfzzepsbtas97xHp//hD4qrqpR0u1/6KFRX69R58zTt6KO1+skn9fSPfqS4qkqzTjhBJ995p+457zw9ec01krKg3r5nn60JBx6ox6++uncfms3jvoMxYsoU7f2Rj2jvj35U4/bdV5LU+Pjjmr9lm33NO/tsnfX00zruP/9TN+27r6YefbT2+tCH9LK5C3Dfc86RJD38jW/0u93Na9bob9dfr0MvvFD7nH22Hvza17Z5H/6ejJo2TWPmzFHLsmXavHbtq1rXK3fdpQkHHaTZ732v9jjtNG1eu1Yv/Pzneu4nP1HjX/+6nXIMAAAAAAD6Q0BxCFp2//2S1BtQDD1q+txPfqLHvvMdL9B3+Ne+piMuv1xz3v9+Pf+zn3nphk+Zoh/vv786Nm7snVdTX693fu976mpt1U/e9CY1LVggSfrTV7+q0373O01605u84N/hl1yiaUcfrYcvv1wP9rnLsWrECH3gj3/Ukf/6r3rpl79U26pVeuJ739OEAw/sDSi2LFmyTeVSNXy4dj/lFO390Y9q2jvfqbhQUPPixfrLN7+p537yE2144YVgupalS3XvF76g42+4QXN//GNNPvRQbV6zRn8499zeZUZNm6aRu+yiTcuXa+NLLw2Yj6X33KNDL7xQUw4/fJv2Y2ebfuyxKtZmX1KOikWN3HVXzX7ve9Xd1qZ5/XyYpW7cuH4/ELT+hRf04q239k43PvaY7njf+1Q7erTmfOAD2vujH9XBn/2sDv7sZ7X+hRf03E9+oudvuUUtS5du930DAAAAAAAEFNGP1pUrg/Of/MEPdMTll2v6sccGA4oPXXqpE0yUpN1OOknVI0fq8e99rzeYKGUfNvnzxRdr+jHHuCuJIh3w6U9r44IFTjBRkrpbW/XQ5ZfrlP/5H+1xyim9dylusyjS9GOO0d5nnqndTz5Z1SNGqH3DBj39ox/p+Vtu0fI//SnXap658UbtdtJJ2u2kkyRJd5x8snMn3rBJkySp9/HngfQsM2Ly5MHuzd+F6cceq+nHHuvMK3d366nrrtO6p58Ophk2bpzeetllwd9evuMOJ6DYo2PjRj113XV66rrrVD9zpvb+yEe014c/rLf/8z/rbd/4hpY/8ICevflmvXT77eratOlV7xcAAAAAAMgQUBwiyoq0OhoupVKUM82+55yjfc4+W+P23Vc19fWKC4Xe34ZPmRJMs+rRR7154w84QJJ6v/zrLP/IIyqbuyDHzJmjujFj1LZyZfCutbrx47Pl9twz5570b5+PflRztzyW/Mpdd+npH/1IC3/zG+/OzDweuPBC7XbSSVr1yCNacMcdrzpvr1cPXHjh1o+yRJFGTJ6s3d73Ph31r/+qWe95j24++GB1tbQ4ada/8IJu3Guvbd5m86JFevgb39DD3/iGJr3lLdr7Ix/Rfp/4hKYedZRmn3iifn3KKa9mlwAAAAAAW5QVabWGe/MwtBBQHCK6o4J+r5kaqY16a/pcxeXf+f3v6+DPflYtS5dq4Z13qm3VKpU7OyVlH3Ip1tQE021evdqbVz1qVPbbmjV+gjRV+7p1zqzaMWMkSeP23bf3/YUhoY/DDNamFSvUsXGjakeP1uTDD9emFSvUvn69lj/wwKDXVWpvd/7b1+bGRknSyKlTK66nZ5nWVat65/V8wCWKB/iO0pbf7MdeBqs3fRRJaRpcJorjfNtJU7WuXKn5P/yhhk+erMMvvlgHnXeeHvnmN19VHvvTMHu2Zh5/vGYcd5yq6upU7u7u91F1AAAAAMDgZfGFGTs7G9jJCCjCM2z8eB30mc9ozVNP6WeHH+4EyIZNnNjvo6n96bkbbdiECf6PUaS6cePUumKFt/xLt9+uO08/ffA7MAhL77lH106apNknnqi9P/pR7Xv22Trg3HPVsnSpnv/Zz/T8T3+qdc8886q307J0qTatWKGRu+6q0XvsMeB7FKdteQR85cMP987rbG6WJNWNHdtvumHjxjnLbqu+27LB3h61Y8YMejurHnlEkjTpzW9+Vfmz6saN054f/KD2+vCHNeWwwyRJq594Qvd+8Yt6/mc/CweyAQAAAADANhvgdie8kSXlsiQp6vMYc4/6WbMUxbGW3n23d7fdrm9/+6C3tfappyRJuxxxhPfb5Le8RYWqKmfe+uefV2dzsya+6U2Ki/li3ukA+1NJuatLL/33f+uO971P102ZonvOO09tjY069MILdfbTT+usp57Sm7/8ZY3cdddBr7uvZ2+6SZJ02P/9v/0uM2z8eO33iU8oKZd7l5ekDS++qFJnpya9+c397uPkLR9xWfe3v72qfPa857C/j8KM339/VY8YobWD3E7t6NGSKtxlmVPVsGHa84wzdMpdd+kfV67UMf/2bxq566569KqrdOM+++gnhxyix6++mmAiAAAAAAA7AAHFIapjwwZJ4Udwe76SPOWtb80ee91ixC676O1XXjnobS349a/VtWmT9vv4x1U/a1bv/KhQ0BHf+Ia3fFoua/6116p+xgwd+S//EgwqjttnHw3b8i7FvvszKscjxQNpX79eT15zjX566KH60Zw5+ss//7OqR43Skd/6ls5dskRzb755m9f9129/W02vvKJ9zjxTh3/ta15gbdjEiXrfr3+tYePG6bF//Vc1LVzY+1u5s1Mv/uIXGjZhgg6/+GJv3eP23Vf7f+IT6mxp0cu/+tU251GSnt3yTskjLr9cNfX1zm+F6mq941vfypYbRFkUamp04P/5P5K0TY+T97X3Rz6iT69erX/42c+06zveoRf+67/0i2OP1b9Pm6YHLrxQ65+r/Eg/AAAAAADYdjzyPERteOEFbVqxQnt+8IMqd3Zq0/LlUprqiX/7N7U1Nuql22/XHqedpo8+9piW3nOPhk2cqFn/8A9aes89Gr3bboPaVmdzs+49/3wdd/31+ujjj+uFn/9cXc3Nmvme92TbXrHCex/fQ5deqokHH6xDPv95zTrhBC1/4AFtXrNGI3bZReP3208TDjxQPz3ssN4vKS/94x/15i9/We/6j//Qy//93+pua1PLkiV67pZbtrmMNr70kv588cX688UXa+qRR2rvM89Uw+zZ27y+zuZm/ffxx+uUu+7SEZdfrr3PPFOLf/c7dTY3q2HWLM064QRVjxypp/7jP/Snr37VS3//BRdo8qGH6q2XXaZZ//APWn7//Sp1dGj0Hnto9nvfqyiKdNeHP/yqH3le+sc/6vGrr9YhX/iCPv7SS1pw551qa2xU3dixmvWe92jU9Ol66Ze/1DM33hhMP/3YY1WsrZWU3Y04bNIkzZw7V6OmTtXqJ5/U/B/+0EtTN25c8AM8PeZfd13v+zlHzZihlQ89pOd+8hO9/Mtfqnvz5le1vwAAAAAAYHAIKA5RaZLo16ecoiOvukp7nnGGarZ8OOW5W25RV0uL/vfss9W8eLH2OPVUHbTl4yyPf+c7evSqqzRnG95r+PR//qc6N27UoV/9qvY9+2x1Njdr4Z136oF/+iedu2SJczeelD2G/N9z52q/j39ce595pvY49VQVamq0efVqrX/uOf3huut6H82VpEXz5un+L39Z+33yk3rTBReoUF2tZffd96oCin0tu/9+Lbv//lf9uO7Gl1/Wj/ffXwf84z9qj9NO014f+pCqhg/X5rVrtWjePD113XVa+sc/BtNuXrtWt7z5zXrTF7+o3d73Pu3/qU+pUF3dGwB+7F/+RWvmz39V+etx7xe/qOUPPKD9zz1Xu510kmoaGtTd2qq1f/ubHrr88iyY2M8HW6Yfe6ymH3ts73RXa6s2vvyynrruOj3+3e8GP1ozbNy4Ad/N+fIdd/QGFB/55jf1l1f54RkAAAAAALDtojTtJyoQcOWVV+qXv/ylXnjhBdXV1emtb32rrrrqKs2ZM6d3mY6ODl1wwQX6+c9/rs7OTh133HH64Q9/qIkTJ/a73jRNdemll+r6669XU1OTjjjiCF177bXafffdc+WrpaVF9fX1emfdB1SMqnvnJ4HARSVR0X2fX1rq9paJ6+qc6aSjs/KKUzcAEnoPXlw/ypkub3TvNIviyp9h73mXYJ9EkqSqtKyDtFqFtFWjNL9yfl8jDbNn6xMLFuiFW2/Vbz74wZ2dHbzBPVx4l1oS9zHunjbSV1xX60wn5i7IuLpaVpq4XWmo76jErteuU/L7jqSrq+J687xb1ObX5iXPdvJsuzDdfS1BeckyL01hwnhnOpk0xp2eH/hyt+lj7XENlUGeY2TTeX1sMJHZtum7Q+uIhw1zl+ly87Yt9SnEHtfInM8kqVzhLueiOT6SlGxqdafN+TeucduU5NepuMr/G6fXBsxxDpVlccpkZ7q8xv241PYqS6uw/17evPLfnnem89SnomkjJdNG7DhFktK37OPOeNh/x23BjDGiYebYB4aDaWubM237wlAflWe84yUx5VCc4z8JUXpxQcX1eExbjGtr3O0G+rVKdS60XtvG43328JLYumDbRFTtH9eyKf88fUkeFfv3wHmxUt0tHXOwl6Z492MDZySwnVzj5REj3CRmHJ50dvibMu3GnudD9b/c6vZrXn3K0WeF+ptKZWnPB5KUtJt9CtVLozh5kjNdXrveW6ZSfxhsv7YcRgx3t9PUVHE9dp/zbCfYX443Hys072UvrVjpr7eC4q67ePPKqxor5sXy9jlHf7ktCub1RKFzeHHWDGe69Mpif0Wh9thXnjq3yxQ3yeiR/moWLnWm7XghOF7bhrGXl7c9Znnz0tXu+KDc3GIW8PfZ9t1e/5njnBFaxh7Hvq8dk8LtqtJ4IY/0bQe6m/3z/Nxps/iC+776JzVB3VG+bxoUzcdG7RgjFGMpmP4mVDfsemz/X5jix6VKS5cPmCYK9PeVYk0Fc66SpHKbebIuVMfsNUGnKYdAXff68hx1zqvLfc6dpbRb9+nXam5u1qhRo2xSx6DuULz//vv1mc98Rm9+85tVKpX01a9+Ve9+97v13HPPafjw7OB+8Ytf1F133aXbbrtN9fX1Ou+883TKKafowQcf7He93/rWt/T9739fP/7xjzVz5kx97Wtf03HHHafnnntOtbX+RQgG7/PpYzpYa7ReiX6zE7Zf09Cg0ubNKvfpdIu1tTr6u9+VJC24446dkCsMNV8qP6p6mZNcGgjUt5t5thPuqhzc7+8OzgHlWW/J5i3HdvJkxa7H5mVb9kfy8hstN0HTkn9BH611T01pszlVJf7ForeT9riGsp9nn2x55ylMu23vHB5YR7s98dv92cbyt8xxjUqBQUk68MA92hAIaNkBnW0znaHAga1zA252S5qKMxStsXXMDLK2V1na7b78sDcvTc1gM0d9ilaZoFdqBpLeOiT97c/udOK/CiJqMX1fqz0mgXJJbAA3z8WvWU8ovxXSRIsf8pdIQ+2+0mrNtjts28zVOVZer/17xsvmeChQF0ybiLr9crKvg8nVl+RRqX8PnRftpmySR//iJYnSVm9exe3kqD/RJhNoyhMEtueiNtvnBnJi+0Kb31x9VmDFlfoBez6QAnW18rGP1tqbJEr58tdXqP2aWbZvSdPAdirtc47thHY52mDGByYIk6aD/2NotDrwR2Mv8Lot44eQV38+ijbZ8vfP4dHyCucVqZ/26CxQOS/m/Kv1geCgDY7Y9host20Ye9m8Lfb7ZXW7dTVNbNkFtmvHM14bynHOCJ37N9mysnXZb1cVxwt5zH/EZK0tvFxApFTj5J7bntBE/YvePPh84HVrUAHFefPmOdM33XSTJkyYoMcff1zveMc71NzcrB/96Ef62c9+pne+852SpBtvvFF77bWX/vKXv+iwww7z1pmmqa6++mpdfPHFOumkkyRJN998syZOnKg77rhDH+Sute1imjZpvNr9sehrZOqRR+q4H/1Ii3//e21aulR148Zp2jvfqfqZM7Xknnv0wq237qScYSiZpWb1f690H5Uayo6JR/x9rXdH5SXPWMeO27fHDWU7an+2l9eqc7blsC03OG3L8djGuM022TE3IFa2vV7nWqmNhMppk3/nkcce6227ue21sQ2xw1xeq3aWpy5sj7a4rXbEOaE5Rx3cXralrHZEee+o88r2qqc7qi98repunvLdEfu4bQ9k7Dx5yn8b4kzb5O+57LbXeWVHtfttaUfb47hu2rAdVrLVNLVUXghvKK/qhXDNW26pHjMmexzt8ccfV3d3t47t8/60PffcU9OmTdPDD/t/uZekRYsWqbGx0UlTX1+vQw89tN80nZ2damlpcf7h79u6Z5/Vkj/8QbsccYQO+tzntOeHPqSu1lb9+eKL9csTTthhd4wAAAAAAABg+9rmj7IkSaIvfOELOuKII7TvvvtKkhobG1VdXa2GhgZn2YkTJ6qxsTGwFvXOt+9YHCjNlVdeqa9//et+njq6lERbA1PeuyvevK+XpvCS+x4H+95C730GklQw7w7J8V4H+36Fwi6T/WXWmb8QmFvAC7u670mQpKRxrTvDvten53n/9khKpTpJBb32NyY0LVig35xxxmu8VWCrgrL6DwAAAADY3iLF1dV+7GOk/z5N+15I733K48d5aZIW887uwLuQK73nsrxytZfGez+4udnJbleSCmNGO9OReVVfutl/x6J9l3NUDLyL17wWoDBxgpuXjU2BvDS4y0w2+/PSIn875pF/552WSZeU8+bVbQ4ofuYzn9EzzzyjP/858D6CHeyiiy7S+eef3zvd0tKiqVP9YBt8oyR9XNLgP1cDvL7VKav/AAAAAADg1dmmgOJ5552n3/zmN3rggQe066679s6fNGmSurq61NTU5NyluHr1ak2aNCmwJvXOX716tSZPnuykOfDAA4NpampqVFNTE/wNlY3a8q9dsRapQdHe7gt0Ozb5ZRvVuX8xCD2hPG24G8Zeus6NjKc1/kthahfaFw2ZFZsvOUnSrru7d2Uu2my+8GY/4CCpeo3ZThR4+bn3xTn3bs/26YH72xJ3PaNGuNtp6/Zf7JyYF/MOr3b/alIX+y+EWdfhlkOh2X/JcfU49+Ugmzvc41i7aPu84KtztlsOadkvy+oadx9KZfNl4sCHIBSZY192lynU+C8jrl5S4cMV5i8vKyT/hd3BO4zNBwKqzHEMpEkrfP0uCn19rsZ8PMJ8xbFjhv91sMgUQ9VIv75MqNnkTK/c7N5pPaHO/V2SNnS5dazU7L7MfdgY/88Q46rc9ZRSv+2tf9q0mxxfq7cvou4a69bl8jC/AxpW5/41b1jBbVfr2/2yHF1Xub3WFd3yrYrcY1+I/OPe/Jz5C6X9emvgL5ZRbOqHmR6/j/+X0XXd7j4VbBsKKCXxgNOSVFVw97G9283/hDo/L81PuW08Kpo+KvQFT/OBgGBbzPGVOi+J+cqn9zEDmzdJ1Xu4eZlY9L+SmZi3xKzudv/a3rnCP0fEG81Xes1XAtPuwAvAzHmvc4r5amzit6HaVabP6gy8yMr8Fdz+Bbxjtv9l2eE17npsDbPnM0nqanbba2z6qF1qm7w0Sza5dyEEz1feh0Pcyagm8CEFUw5evQx92TrHBz68uxDMlyhDedl1b3eMtKjdHbukG/2PHU2ctNGZbmx3/yzWUOP3JRs2mb6uys//ONOGi6Yfa+7263IhdpfZ3OXuY80i/xyddpt6OMKtY1FH5ReupaUcX9O159KuQLsa7u5TtNk933ofwJHUtYebpq7KXW9Nwd/n5jVu+Vev84+Rv09unava1++jNrW6ZTdhlPu6p/WdfvutXmTG7qFy8RpS5Q+apXuZ8jYfMSlO9l9WZ8ek1kEN/h1Ddizw5LrAW7ALbgZrX7EflMjxIRF7fgq0X9myM31H6PzVMd3ckVWoPHYpmY9sVE32X5K3ucvtK6qL7ra7Wv38V5liKWwKvXzPzV/XLPecYcdDklRKzfh+lfma+kZ/vBDZa3j78a/AebFjtnteHDvc/3DI+lbT95nyrnvFr5fecbNjsdAF717uPpZTc70SGBfq+cov+4yqbT9mzl92bBPIn73jLHQuku1/atz11sz260ZTu9sXjqrNynLXBRtU2/H3/EJmvBYGFVBM01Sf/exn9atf/Ur33XefZs6c6fx+yCGHqKqqSvfcc49OPfVUSdKLL76opUuX6vDDDw+uc+bMmZo0aZLuueee3gBiS0uLHnnkEX3605/ehl1CXotVr89H71T1te7j1y89ONNbtjDHDRwkgQua/3fQL53pi352pjPdOcPvoHY/+0l3hh2473eAl+bin93sTH/+2Q+4q/jDGC/N5Bv+5s4I3F6cbHL3MTafen/hwjlemsh86esdb3nOmZ6/ZoqXpr3T7dwP2WWZMz1nhD+o+tmLb3KmR9ztB0emfnihM/3Uy9Pc9X72WS/Ntry78pV/3sOZthePkjR95hpnet0mdyDQtsEf+EZF99hHLe4Jrn5mk5dm8pfMYN5+rW3NOi+NPfb2uEuBW+4nuG0kbfHTJB0DvxnZ3uIuSZru1o/ycwuc6QUXvMVLUr3RrXPjDvNfDfHx6Q8609965t3O9Kf28u8sv335Qc500x/dPwLtf9LzXpoPTXC/6rm25N8D+ovD9nKmIxtcCwT3bfBp5Slun9S8n38Rd8BeS5zpfUetdPPx4sFempP2eNqZfnz9rt4yc+rdujypxr2IG1HwB6j3HOu2kWSKGyxJn3rRSxMPNxfapr589LbHvDT/tcqtH6OqK79xfIO56NzY7rfFicPd+v38avci7py9/Pcb33uAe+wL5tUnqvcfdUnXuh9xKAfaovfYSmflfSyOd+uuDdRHDf6rTHa5we0rPjXhPm+ZzYnbd//n6nc400u+6Z8jan/7uDNdGO/+oa20KvBqF3PeW3KB2093t/vnrz2udvufeElgvePcR3PKC9028/Jl+3lJDpyx3Jm2AcSOsp+XpXdPd6ZHvNX9I+BFe/yvl+b8B9xXosw57xlvGfuHnMQ+qrOre86TpNIi97U23mtsAl+ttsHBUJ0rTp3lrmaRW5aFyf65/2u/usOZ/vxz7kcHu39rHk+S9InP/I8zfc3zRzrTx8/0++VfP+B+XTOa4J+bPri325+MNtGGe9bu6aVpqHYDY081uvs4/Tz/2ajSylVuXvbd35kuLFjhpbHsI3EhhSlu352s8sdRyf5u+yw87Y6Zym1+EHvFVe75a68J7vlg5nD/QzS/v8n9AOWUn/jHyL5eyY59J/2n30f9+a9uXs456n5n+vZFB3ppdvmMe74qB/obO96JTVDDtjNJKv3ALe/O69y6MP5z/qN1dkyq2O3XFhx3vZcmNn/EOf2n/+jnpd7N/x6fMufKHH+EKgw356eZ/lggWuEeexvsCZ2/Xvmse+1bavDLcv893GuADd9z+89J57/ipXl6pTsmnTLarU8r/rqLl2bC4245jHp4ibeMvSZY8W33nLHXOLcMJGldhzuG6L7azVvN/zzqpSlONk8Vmj63tNrfzsuXHOJMv/+Ax71lbn3M7fuKw93y3v1T7hhb8o9bXOfuTygIH/3Qffy0pdMdp4yqCQQu3+Xvk1WYavqxZW7/GNtHciXJBF9L5rqnONmvC2mzqavT3GM240d++/39S27/8/bZWf95yTl3avZzgWstDCmD+ijLZz7zGd1yyy362c9+ppEjR6qxsVGNjY1qb88GGfX19fr4xz+u888/X/fee68ef/xxnXPOOTr88MOdLzzvueee+tWvfiVJiqJIX/jCF3TFFVfozjvv1NNPP60zzzxTU6ZM0fve977tt6cAAAAAAAAAXrVB3aF47bXXSpKOOuooZ/6NN96os88+W5L03e9+V3Ec69RTT1VnZ6eOO+44/fCHP3SWf/HFF3u/EC1JX/nKV9TW1qZzzz1XTU1Netvb3qZ58+ap1jxSAgAAAAAAAGDnGvQjz5XU1tbqmmuu0TXXXJN7PVEU6fLLL9fll18+mOwAAAAAAAAAeI0N6pFnAAAAAAAAAEMbAUUAAAAAAAAAuRFQBAAAAAAAAJAbAUUAAAAAAAAAuRFQBAAAAAAAAJAbAcUhIo0if578eQAAAAAAAP1J40B8IRBzwBsbAUUAAAAAAAAAuRFQBAAAAAAAAJAbAUUAAAAAAAAAuRFQBAAAAAAAAJAbAUUAAAAAAAAAuRFQHCrSNDTzNc8GAAAAAAB4HUsCsYRgzAFvZAQUh4jQB9z5qDsAAAAAABgM4guQCCgCAAAAAAAAGAQCigAAAAAAAAByI6AIAAAAAAAAIDcCigAAAAAAAAByI6AIAAAAAAAAIDcCigAAAAAAAAByi9I0TXd2Jl6tlpYW1dfX66joZBWjqt75Uex+uDx9875e2sJLS53p8sZm9/dRI/0NFtw4bNraVjGPSVeXM12ctqu/zLoN7vTmzW6a6VP9NI1r3byUy850VFWUJF3d/lvtla53fmtXrEVqULR3tTO/Y1ONt52ozl1vqNZMG+7mf+m68W6amsRLU7tws5ljVjxiuJdm193dfV60eay7QHPRS1O9xmwn8j9q75WdOc7t0+u8NErc9Ywa4W6nrdstW0lKUjfN8Gq3btTF3V6adR1uORSaC94y1eM6nOnNHe5xrF1ky3rbdM52yyEt+2VZXePuQ6ns5jcpBf6WEZljX3aXKdSU/O0sMWlsxez209hjb4/7lrlukipzHANp0tSv3+5mA/tc4643bXePYceMEf56zC5VjfTry4SaTc70ys317u917u+StKHLrWOl5ipnetiYdi/NuCp3PaXUb3vrnzbtJvbri89dpmusW5fLw/wOaFhdpztdcNvV+na/LEfXVW6vdUW3fKsi99gXIv+4Nz9X60yn1W5ZarNfllFs6oeZHr9Pq5dmXbe7TwXbhgJKSTzgtCRVFdx9bO928z+hzs9L81NuG4+Kpo8q+H2WSm5lDrZF224qtDNJiqpMeSemXGzeJFXv4eZlYrHZWyYxf4Nd3e2ODzpX+OeIeKM7Pug5J/dIu/32a897nVPc/KeJ34ZqV5k+q7PLW0ZFs+1Ot810zB7mJRle467H1jB7PpOkrma3vcamj9qltslLs2TTOGc6eL6y/buZjGr89puacvDqZWAwk9r6EqhzUa1p4x1uWYbysuve7hhpUbs7dkk3mnoraeKkjc50Y/soZ7qhxu9LNmwyfV2Vn/9xpg0XTT/W3O3X5ULsLrO5y93HmkX++TbtNvVwhFvHoo5APbXrKIXO0S5b3mlXoF0Nd/cp2uyeb9PEL6euPdw0dVXuemsK/j43r3HLv3qdf4z8fXLrXNW+fh+1qdUtuwmjWpzp9Z1++61eZMbuoXLxGlI04M+SlO5lynu1O12c7Jat5I9JrYMaVgfmunl5ct1Ef5GCm8HaV+w1WeXzYmTPT4H2K1t2pu8Inb86pptryELlsUtplVtOVZPd3yVpc5fbV1QX3W13tfr5rzLFUtjkr9eWVdcs95xhx0OSVErN+H6Vm7d4oz9eiGpMXTBtL3Re7JjtnhfHDvevvde3mr7PlHfdK3699I6bHYuFLnj3cvexnJrrlcC4UM+H2p4rqrb9mDl/2bFNIH+pue4JnYtk+58ad701s/260dTu9oWjarOy3HXBBtV2uOt7XmP0hZrjvdhHYaQfU7GxDns8iuPdsYEkJS1unbLbkaTYlKVdxmvzkgpjGtwZpmztdiUpsucVOzYIjPft2Csq+tdOdpl4nDteSDY2eWnikW79Tya7cRi9tMjfjqkvhfqtY4xS0qW7N9yo5uZmjRo1yiZ1+HuAIaNOifbWBum5HbP+sVry6lfSusGf96Q7eYBWvPrthNixwSs7ZjN5TNXGyguFxmI7wsuv0Xb+nlQeB1QWGtP65xnX4vUVFshngvwAojVFfgDFsXI7bbvytaGvcdu23de0PG1oO/HKMk/9seVip+f7Scap8h+zXiu72Bn2OjsQ289lW/7kWam8Q3Xw6cFvZpT8i5OK8tQFe957afCbCap0DBZsn/5mW4zV0soLVRK6Pra2tR5alQ59KC9m7LJ/nk7VnNcnqSW8XB8z9OqPY8XzwbYKjem2hzzH3r8WrGyb2t52aEfPDD7JrtvrHJenz32+wu876DAfvD2uK0LsOWH7/P1dWrIdCmIHlWUuL+6g9eZpr9bCygUxfXsUVuW/We6w6+aK5VL57y+DX6fk1/dtGA9haOORZwAAAAAAAAC5vaHuUIxrqxVHW29xjXab7vxefsQPuUez3GWiZvevv0mb/2equNa9Vds+HpOWKt+CkKz1/4Jpb1X1brU1jzdLUtzg3oJaWrPOmS6Mzh51jDoL23ZnEAAAAAAAwACimmrFM6dJi5e7PwQeH4+K7uPWNqZSWuffdVqc7L76IFnlP6IXj3JjKrF95cumwC3r5jHoso3VhF65M32Wu8hz5nHGwGueknb38bTihPHeMvbRe/uIs12H5D86HS1xn4Ioh9IM9LqHPHfrbsEdivj7lKbSvfe68268MZs/fXo4zd+Te+8Nv3cDAAAAAADgde4NdYci+re02KCxSZuKaVmjt+W9T28El14qXXaZdNRR0v337+zcbB8nnSTdcYd0zz3SsceGl9ljD+nJJ6W1a6X99pM2bXmn3YEHSp/7nHTkkdLkyVJXl/Tyy9Kdd0rf+57UEnhX0733ZuU3Y4a0pJ932fRdRpIWL86/P4sXSzNnSmedJd10U3a8vv718LL9LbNo0dZt9+jslFaulP7wB+mb3/Tz3lM3BjJQXrDj1NRIX/6ydMYZ0qxZUnu79Je/SFdcIT30UDjNccdJX/qS9KY3ZekXLMj+IPG973kv/1ZDg/Sd70jveU/2R4Df/la64AKpqclf709/Ku2/v3TQQd4HRV5RvTqi7JRaGu/+ZbS4xn2PpPdCcslbX64X4+f5QIn9CFHgwwP+is20/QtrIC+R+fCM/RhGOHNmMvCS7NSUi30puf09y4t5sbl9wbv96EaOvGUrqpAk9MJ0W972Y3Gh/Nu/pIc+3GINtx+7CLw4KfRhKOf3ypvxXvhe8NcZ/tBVhQ3l2LZ3XG0dC33wyZa/aQ/ex5CkwEv5A5mpcFyDH3sp27ZnPqRTHfioTKVjH/rDpe07Ah+h89qAXSRPE7EfKAy8/N9+HMjefWI/npgt45ZTqF+wx8j7eEFd4CN65YE/UJKrLufol72PIAT6G/skk62HwX7arsYWXeA4e31S6INy5gMNtrzDH8uydcxOBo5rpfNVqM7Z+hEoS+/cY+tC6IMHdp/tx7K2pV8eFqhzth8O5b/CB9lCefHrYY4Pz9j8lwP7aM+vec499htW9e7HU+JNgY9SJLb8zXYDdc4by+Sol97HEKsCYQ/v43A5xkgV+ktbJ6VAWY70P6IUtbn1pWL/I3nH3utLgucIM+3Vy8rnlaiQlWWUphqbbHmf95b2urTG/5AK3tgIKA4RPxz1dp3WNl9jks16T0eltyn/nbroIun//T9pxQ76CMvr0a9/Lf34x1lw7bzzpB/8wP09jrPfa2uls8/eGkz82teyAFmpJP3ud9IvfiHV1WWBwMsvlz79aem975Uee+zV5a+pKRyou+yy7Lerr/aX3x5KpSzg1KOhQTr0UOncc6VTTpEOPlhatsxPd/vt0jP9vA39vvu2T96QX01NFiw/4gjpqaeka6/NjuWpp2Z/FDj11CwA3tdnPyt9//tSc7P0y19mderYY7Og4eGHS+9/v7v8T34ivfvd0s03ZwOmM8+Uxo3LgvV9zZ0rfeADWV4CA/x/KR6mBdEYSdK6973Z+W3s9W7gszh5qpc+3dDkzrAD39BFaWflt217FxE50iQmaGRf8xHKSzzJfWSjtLRyPx2bfYzM140lqbzB/dBAcewE9/f1/ocIClN3daaTle5XfZJAsM0GNoLBzQqBssKECd48+4U/G2wI5n/saGe6tHrNgNuVpHjPfdztvOx/5CSyx9EKXHjbAETJPAIU+mpjubnCBz0CgU1bF7wvLUsqTJ7kbme5+zhPKCBnHwuyj1fFde4XGSUpsoGBQHAnbTd/mLUXkN1+H1FuNR9RMgGW4kTv00ZK1vivunF+z/F1y9AX1m0b8Op7IPhjj4k99ukMP//RK+551gviBeqkfdWQfXRNkqJh7sV4abnb3xR2m+OnaXIfcSuvcvuFeIS/HVuXvS+HBo5zcYrp3wPHKFnntiP7R6bE1i/5/Y9tM6H2G09y+6S0KfD1evOqp9gc13Kz/8dlr47l6T8D5eD8Hgoi2fIO9N3FiZOdaa8u1Lv9qSSVN7rlUBzjfkG1bM/H8r8AWzJtM95jby+N/apqqAxiE/yOTJ9kz4FS4DHRHK/aKoxxy8Eed0mKzaOXlfofyW8D3Ycf4kzXPuhfc5ZbzVfmzXk9afE/JGjHMuVNoWVM/276l8h8KVeSUvMoaTmwbcs7X5m6W5jgf428vNoty/LB+3nLVD3lPi6bmH20+yf554CC+eOi/SOgJP8Pm2YdobZo23y85WvANWm3Tmubn83cUndvH3uov028oRFQHEI6o6K6FPhL7+tFY2P2b6jbddfsAmflloupz31OOvroLNg6b152N1aPr3xFOuywLHDXExD7P/8nCxouXCidcIL0ovmM27nnStdcI/3v/2Z3Yi0378AYjObm8F19PQHFHXXHX6kUXvcPfiB95jPSJz6R3ZVo3X67dOut+bZx2GHZnXLYcc47Lwvg/eIX2R2KPRf2V1whPfGEdP310h//KPUMTidPlr71LWnDhqzuLt0SVCkUsmN7+ulZULDnGE+aJP3DP0j/9/9md65K2V2y3/iGNHGitHrLe1mGD8+CmddcIz3yyGu2+wAAAMDfq84tT+co7gl45njkAG8ovENxiOiMqnT78IN0d92Wv9oeeWR2m/Sll2YX7Pfemz3iunFjduE9e7a/kkWLsn/19dK//Vt2sd7dnd0d12O//aT/+q8s2NXZmV2cf//70pgx4Yx9/OPS009njzEuXSpddVV2V1LIQO9QfPvbpV/9Kgs4dnRk6/rv/872Tcr2r+dOufvuy9aTptn+9DV+fHYn08svZ+tZuzYrj33cuz96HXFEtr7WVmndOunnP88CftvbiBFZOd9zT/a47pv73AHV0pLdfVhXl92N2HO7+z77ZPv8/PPShRdm8xoapCuvzI7NiSf6wURJ+o//yI7DuHHSP//z9t+XnWnevOy/47bD7fgPP5yV38UX+49Yvxo979+srs7Kf8kSafPm7G7RY47Jlhk1KguOrliRtZ2HHnLrRF/77JMF0Favzur0K69I3/1uuE1WauOTJmXB6ZdeyvK0caP03HNZsG2U+4EoVVVJX/yi9PjjWftoaZEeeCCrd3n13CV42WXuXUKvvCLdcIM0YYJ02mlb58+dm92N+5//uTWYKGV3WfUEkD/96a3zp265k+Txx7fO67krd9q0rfO++c3s7sWvfjV/3gEAAIA3qJ74wu3DD9LtYw/T7WMPU2cceP0L3tC4Q3GoO+yw7FHiefOyAMI++0gnn5wF6A47zA+41dRkdwSNGJE9algqbb2L58QTszuJkiR7FHfZMmnvvbNHEI87LnvktO8jrRdfnN0J1NiY3WnU3Z3dPbTXXoPbh899LguQtLdnQcWlS6VddpHe9rYs2PDgg9m79qTskd6bbtr6Xr+++Zk1KwsOTp2aPQZ8xx1ZwOLUU7P8H3OM9OijW5d/5zuzu/iSJAvYrFyZLfPgg1mg5dWKY+ld75I++lHpfe/L7pJqbs6Chk884S57773Z8fv857O7Ev/lX7JHOOM4S9/zmONpp2WBn//6ryzQ2J9vf1s6/3zpgx+U/vEfs7J9I3j3u7P/2vLbFpdfLn34w1kd/vrXpT//OXt89he/CL9/crBuvTUL0N95ZxYs/vCHpd/8Jgti/8d/ZAHH227LguAf+EDWhmfOdLd9xBFZXa6uzgLjixdnj/1+4QvZnXmHHSatN18x66+N19VldXvGDOn3v8/aWnV1ts2PfjSrcz3brq7O8nP00dn7O3/0oyzAeMIJ2TrPOy+726+SSVsecbT9UN9573zn1vadZ/m3vjXLX1fX1sfeDzooKycpexxe2hqQPPTQ7K7W975XajOPLAIAAADAEEVAcag7/njpU5/KAhQ9zj1X+vd/zz5g8N73ustPnpy9y+yII7K7nXqMGZMFU9aty37re3fQBz6Q3bl3+eVZ8E/K7oC85JLscdqDD87uBJSyO5H6Bu0q2X//7I7CVauy7dqPbUze8m6VH/84C4T0BBRDH2W5+eZs+eOOywImPa64Irtr6frrpQMOyOZFUVZmxaL0jndkgZYet9ySBX+21f77Z+9x+9CHtn4s5fe/z8r3zjvdcu/rwguzvF92WRYYPvjgLNDV9+6rt741++899wych+bmLOh2xBHSIYdkwbLXk2LRfaR51CjpLW/Jgmk//3l2rENOO03ac8/wb9ddtzV4LmXrv/TSrEw/8pHs3XzXX5/dkXvnndnxmjcv+BL0XMaOzerC5i3vk+p51+Xdd2cfl/nQh7aue/787FHfj388C65LWR296aYsEG3r9FVXZYHnq67KHv/uq782/g//kAXdv/vdLNjc1/Dh2R8EelxySRZMvPxy9ziMGJEFK//1X7P3G65aNXAZrFsn7b57FrS0AfCZM7P/7rGHu3zf30LLV1Vl+/HCC9kfM+66K2sns2ZtfYfinXdmx7pYzI7pL36RfawFAAAAACCJR57x4ovZBXNf11+fPdJ4wgnhR0O/8hU/qHXmmdljkhdd5AYTpexOq8cfz+526/GhD2UX9t/5ztZgopR9NKTvxzQq+dSnsvejXXxx+KvDlQIWPQ48MAug/PjHbuBFyh5/vv76LLjT8+jz296WBUV/8xs3mChlj0WGvso2kMmTsy/LPvVU9u+CC7L9Oe88acqUrXd/9hdMlLLfzjwzuyvxIx/JgqDf+Ia7TM8dXKEPklg9y/QEZV9PisUssNrz7/zzs2P27LNZfezvy3Wnneam6/uvp+yshx7K3ks5eXJ2J+ldd2WP6v7mN9ldq1dfvfWut8H4v/93azBRyu4w7OqSRo/OvmDcN1D5X/+V/bcn4C1l9Xm33bJAmK3Tl1+e3ZnY0w6tUBvvEbpbta1t64vnoyh7rHjBAv89la2t2bZrarKP41Tyv/+b/feSS9wvH86YIZ1zTvb/DQ1b5//+91nb+/jH3VcPFApuXvqm+ehHs/I76aSsnf30p1sf8b7ooqz9ff7z2d3Kv/pVtv8bNmR3ZIa+EAsAAAAAQwB3KA51Dz7ofXJeaZrN32OPLEDR92629vbsnYfWYYdl/z300PD7F2trs0czx47NAhk9gY8//clfNjSvP295S/ZfGzAZrJ78T5wY/lhHz11re+6ZBaUGyv/SpVkwLnSXVH8efDBbfvXqLHh1yy3ZR1MG669/ze78+sAHsi85b+vdca93HR3ZI7o9hg/PgsFXXpkFhT77Wf+L2FIW9M77URaruzt71P/Xv86C66efnj0u/vnPZ/8OOED629/yr2/+fHc6TaU1a6Rhw/yAcE/gfMqUrfMOOij7b+jr1G1tWcD5uOOkOXPcL1v318YfeCALkF54YbYvv/lNdqevvXNwzpzsjuWVK8NtafyWrwj2dydoX9/9blaXP/jBbPk//nHrV54XL87+v++7FRcvzt53eMkl2T788pfZ3bbHHJO9E3HJkuwdrH3TbNyYvYPU2nPP7I8D//iP2R895s3L5r3//Vk5X3111l6//e3K+wEAAAAAbzAEFIe6vo9whubX17vz16wJL9/zgYfzzht4e8OHZwHFnvWG1tdfnkLq67PgQN47EfvTk/9/+IfsX3+GD9+6Xan/8li9enABxWeeyZafODF7DH3duiyw1fMI52D03EEWupOs5yvZPR+jGEjPMn3LticQM9CdWT2/9Q3aDNb23k5bW/Yo/SmnZI/ZX3FF9l6/HfFuyOrq7HHf44/fekfr0qVZYGswNm3y55VK4fcz9gSO+95t2PORlP7aU89xtR9T6a9Ot7RkgffLL8/u5DvhhGz+0qXZF8avvTab7mlL++6b/etPT1saSGtrdqflJZdk73Y977wsf9ddlwU0//QnP7+XXprdYf3Zz2aByFIpe2T/jDOyx90H2se+rr8+W/+Pf5wFSY87Lruj83/+J/v9kEOyj84QUAQAAAAwBPG81hBRSMvao3u1ppc2uD9MnBhO0DPfBkHs3Yw9eoIc++6bPfLY37+ex6F71jthQv/bzqOpKQssvdrHcnvyf955A+e/5917A+VfGtw+SNm7KnffPXtEeeLE7O65lSuzx2fPOCO7K217eOih7L89XwvuT3199phuZ6f7Dsae/R47tv+0PY/JDzaA1teO2k5zc/aYf329++697eEd78jePdrYmN0F+a53ZY/SvvOd2V1xoUfyd6SeOt1fXex5hNsGKPtr41J2Z+Q552R3GR54YPZodBxLP/zh1lca9Kzv9tsHbksf+1i+/Whuzl4BMGtW9qj01KnZXZI9d0L3fJW5r5/+NAt+Dh+eHesTTsgewd599yxI3/NRpv58+tPZHZ6f+lQ2PWdO9t++d40++WTW79iALAAAAPAG1xNf2KN7tfZoX6k92leqkA7Rp+OGMAKKQ0RRid7cuVT7dDe6PxxxRHZx31cUZR+aSJLsfX55PPJI9t/DD8+3fM963/52/7fQvP70fMCl5+u9A+m5i6tQ8H/bnvmfNi3fHYDWggXZnVizZmXBqZtuyo7Dz36W3WX2k59kd72F8p/X7bdnd76dcsrWIEnIBRdkjwzfeqt7F1/Po7D9ldOYMVnQZsmSV/el40rb6fvbYB4jlrJ3EErb5/13++6bPUa9ZEn2+O/HPpbVpQ99KAvYfexj2Re4d4Ynn8z+e9RR/m/DhklvelP2jsYXXxz8utM0awPf/nYW8Ja2fsDp+eezIOCb3pS9y3JH6fnwUc9dh5Wcdlr26oVKj7RPmZId00svDX/l3v7/QAFYAAAA4A2oJ77w5s6lenPrQr25daGKBBSHHAKKQ92cOdInP+nO++Qns/l33ZX/kdsbb8wCSP/8z9Lee/u/19Vl71fs8bOfZY8inn/+1neqSdLIkdkHVvK67rpsPVdckQXyrL53Lm7YcndmKNj3179Kf/lLFhx5//v936MoC/L1+POfpVdeyR6PPuIId9lvfvPVB1L+9Kfsa9uTJmX5ue++7F1y//u/0ooVW98dOVhNTdnHPmpqskc3d9/dX+ZjH8s+RrFuXbZsXz/9aRaY/fKXpV12cX+LoizAVFXV/1eU81q0KCuDgw/e+oGMvo45Jnvstme5vN73vixgu2GD+97AbTF/fhb4vPDC7D18F1yQ1a25c7M7E3fE49SD8eCDWZD6Pe/x70i9+OLsDs//+q/+P1Bj7b33wHcU93zEpVzOHn+eMSP7cEmoLeyzj9vuBzJypD/vC1/I7gD95S/9OxRDy++5Z/Zl6ebm7PHsgfzwh1m59XwtW8q+CC1lZdnjPe/J2mLo0XQAAAAAeIPjHYpD3bx50ve/n10cP/tsdqF/4onZRwg+//n861m3LgvG3XZbdufSvHnZRXhNTRZYOPLI7HHbuXOz5RcuzN7Fdvnl2R1mv/hFFhg89dRsOs8HG6QsKPSFL2T78Oyz0h13ZHeLTZqUBQDvuit7z5mU3SmWJFnAb599suBCU5N0zTXZ72eckS1z663ZOp94IgsKTZuW3Q03fvzWD32kaRbw++1vpbvvztKsXJk93jp5clYGfb+4u606O7Myve22LAD0oQ9lX6Xt74vDefzbv2Xr6vlwxbx52V1ltbXZ3WwHHpg9tvve92bvG+zrpZeyLwz/679Kzz2XfYBkyZLssc93vUvaa6/sOH/zm69mrzOf+ET2IZCbbso+mvHoo1mwav/9szs1N2/OyiL04Zli0f0gSM9HWY4/PqsDn/1sOJB22mn9170XXnDvbhs/PguY3Xxz+CMmO1uaZuX2u99l9fS227Jjdfjh2TseFyzIgqF5vetdWcD4wQezerB+fRacfe97s3bS046krOwPPjjrQ044ITuOa9ZkQej99svq2GGHuV9478+KFVm7fPnlbJ+OOiq7+/Gvf82+5mz9679m2/7rX7PA8e67Z31akmQBZVun+zr99KwvfMtb3HdzvvRSFsy/7LLs8fXJk7PyuOCCfGUHAAAAAG8wBBSHur/8Jbu774orpM99LgvO3HFH9m40+7hfJb/9bfbesS9/WTr22OyCu60tu4C/8cbsy8V9feMbWRDui1/M3lW2Zk32+OIllwzu7q5rrskCixdckAUsR4zI1vXII1mgssfzz2fvf7vggiygVFubvUutJxCyeHGW//PPzwIP55yTlceqVVlA5Pbb3e3ec09259cVV2SBiPb2bN7pp7/6O/RC1q3LAqff//6rf1z30kuzYODnPpcFe487TurqyoJMl14qfe97/b+b8Oqrs7vzPve57DiPG5cF9154ISu7a67J1vVqvfRSFnj60peyIM9552X7vWKF9J//mQW3+vsSdrGYBX96dHdnwatf/lL6znekhx8OpzvttOxfyB13uAHFqVNf3YdnXgsPPpgF7i65JHstQH191uauvjqrt+vX51/X736X/XHgHe/IHpkfMSI7FrfeKn3rW+7Xnru6srb48Y9LZ56Z/aGgpiZ7dP+557I7i/MGYW+5JQuAHnNMFlDsCWr/27+F69nvf58FhU8/PbtbsbExu7P2m9/M7iruT0ND1ra+8x3/C9tSdqfstddmj1q3t0tXXeXexQgAAAAAQwgBRWRBh6OPrrxcnq8Wv/SS/wj1QH70o+yfZd/rKGUBvnPOCa/n/vuzf5XcfPPAwb6mpiz4csklldclZY8+h95Rl6c8X42BAlkDlVNfTzyR3cG2Le67L/u3rULHN6SxMQsefelL+dc9mK9r9/j617N/g7GjgokD1Z2B9q2/Mn3mmfBj/INd/wsvbL3bN48kyb6UfP31+dOE/J//M7jlb7/dD/7n0dQ08Med1q7tP9gMAAAAAEMM71AEAAAAAAAAkBsBRQAAAAAAAAC5EVAcYjpUVFk5HzcFAFTUpVjNqtnZ2QAAAACA1wzvUBxiNsfV+nXVXqp9cJX+MPw96o6KSgrvcpZJA6+Giwpu7Dkq+lUnLZXcZcw73ZJS4Gu8ZmN2O/GMqV6S8sIl/noGmbfChPH+MmNGutMvL3bzMnGin2btOmc6MV8OtvsjSWnZ3ee4qspdIPAuvMR8fCKuzRG8KFd+x180yt1nmXJKOztDqdxlTBrJ38fCmAZ3gY4OL025bbMz7e1jkvo5GTHcnWHyW97sb6cwfRd3mSUr/GUaRjnTqcmbt10p+2BI3+xuavWXMeKaancVptyiSX49TZb5+fVEA7fXtNv/mElk6mHSETr2rrja5t+vC/FMtw2ny1e72x1W56VJW9vcZUz+y+3+cfX6joZ6ZzppCnxkyPQ/ob4vrnHLJQ30Y82q0dooUCcAAAAA4A2KgOIQtDmq1uaoWq8UxqozqlISucGSNAoEbqKCO12o8pZJyyaYFpuAYuQHGyQTQDHbiesmeSnKUUtgPX3XEchb5OatWD3Bz8mwBpPG3U6hxg8oJrGb/yRyAzV2f7L1ugGJOHaDMjYYlK3XDaDEsR+E8TcUCOAacVWDm0RuOaXdfuDGBjztcZf8fSxWjTPr9b/iXY42uXnz9tGvl3GVCQKX3PyWIzcwJUnFWrdOlUz9z/I7xplOYjc4aLebbdzNXzmq9pcx4kKtuwqZulEbqv85voBuA4oFGxTzg4WRqYdJju3Escl/4teFuM790ElacPuBuMoPxCVmvVHBBBQDx8y2tUL1WJPGb4u2/wn1fXFcY5YJ9WMAAAAAMLTwyDMAAAAAAACA3AgoAgAAAAAAAMiNgCIAAAAAAACA3AgoAgAAAAAAAMiNgCIAAAAAAACA3PjK8xDRGVXppyPeLElKO/wvvAIAAAAAAFTSN76gMQ07NS/YebhDEQAAAAAAAEBuUZqm6c7OxKvV0tKi+vp6HTv+4yrG1b3z084uZ7lyc7OfOHJjqlGhMOC0JCmOnMmkvd39ubpaVmTmlVtb/dXW1bnrNXcSFqdO8dKUli53pgv19WbDbl4lqdzU5M1z1jFypDcvae9wVxv761XRveHV7k/a5R4PSSpv2uRue7893QUWufsnSeW2ze6MNHGzMXasl8Zuu9za5i3jrWfWDGc6Wb7ST1IuDzgdUmhocPNijoctN0lKu0vuOgJ/BSpvcNdj6248YrifprnF3Y7Jf2Gf3f00z75sMpd4y9h2VRg+zJm2dVuS0lK3uwrbFmtqvDS2Xtq82LKWpGjiODfJ2vV+Xmz+ymYfQ/tsxGPHONOlVY3+Qqac4iq3DSWBNhPX1FbMSyids9lQvxYN/PelUJqks6PiMoXpU53pdP1GN011lb9e0z5t+y1MGO+lKTWucaZtWUaBdlVucfufUFlW6sfSxD+FxrV+Xe0rVP+LY0a7Mwru8UiaTV7lH2e7z5L8OjZqhDOddrntLsSWU2g79hxn9zFUJtFYd59LS1d4y9htxQ2Vz3EyfV1p4SJnujhxgpekbOpliO0fvT4qVP4VzgmhtmrP44kdL1Roq5LfnwbZuhEau5jjZvOS55xnt1Mc75+jk03uekP9vT1f6bD9nMlCkzsWkyQtM+dtU1+SzWY8ERBq47avsP1ysA+2aYaZ82KOvBSn7epMl1eurridYP4N2z7tuFaSf1437Sw0rrJ1qtJ5XgqMq3L0sfF0t1xKLy700thxqy3/aKTbN0pSec06k7kc5/693XFTumCJnxdbLt2mXKr886K9homK7jLBsjTlXdhlsreMvY7wM+v3N8UJ7jiqZMoprjPjFPnnUjv2DY5LjFC7Ku42y13GtHk7TgnlJTb7k6zy25Wth4X6UW6aQPuNTDmUN1Q+z9hyCPWx9tjbehkqy9iMm5I1a/317jHTXeb5BRXzUmm8H+0yyU+zzi2HtLPyk3O2TwqOSU39sOVkxz9SoN3bMVFgjJGsM9cNpgwqjcGl8DjKprNjldA4pWDGUelmt5xCZRtP3cWdYfpuez6WKl9vhdhjVDDXRZK88Zp3rV0MjDdN/5+2Bc5XFc6DofGaHbcWRpvxZmC8HJn6LrPPycYmP43pF6JAH+uNN+12Sm5cILgt20YC7bfz6AOc6dpHtl7jl9Iu3dN0s5qbmzVq1Cib1MEdigAAAAAAAAByI6AIAAAAAAAAIDcCigAAAAAAAABy4yvPQ0ScJpqaZO9fKafZe4iWaaSSHO9iAgAAAAAAkLbEF+S+Z5v4wtBDQHGIqFJZb+96RZKUKHux6m2aow5uUgUAAAAAADlVK9E75H7YifjC0MPRBgAAAAAAAJAbAUUAAAAAAAAAuRFQBAAAAAAAAJAbAUUAAAAAAAAAuRFQBAAAAAAAAJDboAOKDzzwgE488URNmTJFURTpjjvucH6Poij479vf/na/67zsssu85ffcc89B7wwAAAAAAACAHWvQAcW2tjYdcMABuuaaa4K/r1q1yvl3ww03KIoinXrqqQOud5999nHS/fnPfx5s1gAAAAAAAADsYMXBJpg7d67mzp3b7++TJk1ypn/961/r6KOP1qxZswbOSLHopQUAAAAAAADw92WHvkNx9erVuuuuu/Txj3+84rIvv/yypkyZolmzZunDH/6wli5d2u+ynZ2damlpcf4BAAAAAAAA2PF2aEDxxz/+sUaOHKlTTjllwOUOPfRQ3XTTTZo3b56uvfZaLVq0SG9/+9u1adOm4PJXXnml6uvre/9NnTp1R2QfAAAAAAAAgLFDA4o33HCDPvzhD6u2tnbA5ebOnavTTz9d+++/v4477jj99re/VVNTk37xi18El7/ooovU3Nzc+2/ZsmU7IvsAAAAAAAAAjEG/QzGvP/3pT3rxxRd16623DjptQ0OD9thjDy1YsCD4e01NjWpqal5tFgEAAAAAAAAM0g67Q/FHP/qRDjnkEB1wwAGDTtva2qqFCxdq8uTJOyBnAAAAAAAAALbVoAOKra2tmj9/vubPny9JWrRokebPn+98RKWlpUW33XabPvGJTwTXccwxx+gHP/hB7/SXvvQl3X///Vq8eLEeeughnXzyySoUCjrjjDMGmz0AAAAAAAAAO9CgH3l+7LHHdPTRR/dOn3/++ZKks846SzfddJMk6ec//7nSNO03ILhw4UKtW7eud3r58uU644wztH79eo0fP15ve9vb9Je//EXjx48fbPbQj04VdVvt/pKkpKNZktShws7MEgAAAAAAeJ3pUEG3aY43D0PLoAOKRx11lNI0HXCZc889V+eee26/vy9evNiZ/vnPfz7YbGCwokidqpIklaMd9upMAAAAAADwRhZF6thxn+TA68QO/cozAAAAAAAAgDcWAooAAAAAAAAAciOgCAAAAAAAACA3AooAAAAAAAAAcuMtmkNEnCYan7RJkspp9t+1GqYkinZmtgAAAAAAwOtInKYar83OPOILQw8BxSGiSmW9q+slSVKiDknSbZrDl5kAAAAAAEBu1Srr3VrszCO+MPTwyDMAAAAAAACA3AgoAgAAAAAAAMjtjXU/anWVFFf3TqabWp2fCyNGeEnKre4yUaHamU66uipuNq5206joF2tUU+POaNvsLZOabdn1pq1t/noLBWc6MftTGDc2Wy6JpO5s2XjkyOy3EZNUjKtUXrPOXalZpyRFsfsuhJ519FVav96dUU7cdVRXeWkKDQ3ujEXLncm0u+SlUWrWa8tgs1+2ldYh+eWdLF/pTgfqQjxsmJuXUiC/RmKOY8GUZSj/tryT5k3eMl45dHa40wfN8dIUnlk4YF7TlxYFZrpl59V/+fW9bPd5dL2Xprxho7vMmNHOtC03SYqr3LZmj1EoTaHGzW8UBf6uYvap3NTkTBdnzfCSpBvcZcpr3fZQnDLZ345RWrnKzVvRbzNpuexMxyOGe8vEti50dLoLBPbZrserT5v8OmfX4/VzktefRKb8E9NPS367Ss16k6ZmPyt2O2Z/bP3KFjL5D/V9Zl5qFwj0Jd466mqd6UJgO7b/V+zmzR53SSrUj3KmbT2V/PZZ3uiWXTzcLWtJSk19iWvd8vfyGlpPe7ubJgmUk+nHirNn+Mtsdtdj24itK5KkphZ3vbtMcaaTQF1IS93uemtqKy6TlgY+F0lSZPNnjmNx5jQvjcwxkmkiNh9BgTZeMMfIHsdoeJ2XJml2yzJN3BYQ6qPivWa7y6xc6y5Q9uuC10fZ6YDiUne95cbVfl7sOdq0xWh3v/yTJ59311Hr92u27Oy5pzDKHyMlZtxnz/Wh+uPV75Jbf0J1obi7W/6lBZXP4zLvuwq1K29sYvJbHDfG345Zb8mcF+Nhftnac01x4gRvmbTb3e/klSVmAb+OeeN7sz+hMbY99rb+hM4r6QI3L4npCyWpYM9p7e54TXZa/ni5bNqmHadLUmHCeGe6tHS5t0xc57Z7O+4O1f+kxYwHTHmHxrHeudT2JdWB86K9BgiN10w52LzY/l+S0gZzPdhh2lHgOi41xyTtdPsorw+TFJn8B8d0pg0XxrrtKDRGsvXQnrOjUJ9l1pMErq+KazaYDZnyjrwRkH9esetd0ejnJXRt1zdvOa69Q/XF1rG4QjlJ/jmusKtbX+zYPqjglpPdrhRoE6FzdL17bWSPfWH8WH+9Jn/22s9eY0ryxlWpmfb6I/nXWz35j9KSolL2WzQmy388fjcV4mppxRo3TeC8WFrwirtaO5YPtXkzhrD7HFpPvPfu7u+NJvYhv69OWuzgKzCODfTvznYCbd4bA41r8NPZ89Ewt59Olizz0sTjx7nLbGxyfx/rn6OrfvdXN2t9yruc5hhr9qw795IAAAAAAAAAhjwCigAAAAAAAAByI6AIAAAAAAAAIDcCigAAAAAAAAByI6AIAAAAAAAAIDcCigAAAAAAAAByI6AIAAAAAAAAIDcCigAAAAAAAAByI6AIAAAAAAAAIDcCigAAAAAAAAByI6AIAAAAAAAAILfizs4AXhtdUVG/GbZvNlEo9M4DAAAAAADIq0sF/U9xjiQpGrtLNi+q2plZwk5ARGmISKNIzYVh2cSWgCIAAAAAAMBgpFGkZtVKkqLi8J2cG+wsPPIMAAAAAAAAIDcCigAAAAAAAAByI6AIAAAAAAAAIDcCigAAAAAAAABy46MsQ0SUphqVtG+Zyj7K0hLXKY2inZcpAAAAAADwuhKlqUapM/v/UpskqaUwjPjCEENAcYioTkv6h83PZBNxdmPq7SMOViefdgcAAAAAADlVq6wTSy9KkqL1jZKk28Yfps6oemdmC68xHnkGAAAAAAAAkBsBRQAAAAAAAAC5EVAEAAAAAAAAkBsBRQAAAAAAAAC5EVAEAAAAAAAAkBsBRQAAAAAAAAC5EVAEAAAAAAAAkBsBRQAAAAAAAAC5EVAEAAAAAAAAkFtxZ2dgeyqtXC1FVb3ThdH1zu9JS6ufKHJjqmm5POjtxg3udsobmrxlyl3dznRh+DBvmaSj081LyU0TdVfJKuw+y13HkuXOdGn1GklSMS0pUVvPmrI8ta5RKSoqKhTc7Xa6+QgJLRMV3fzZ/CedHV6a4tixznS5tc2ZjuLI347Jb1Rd7W6nw89bXOVW9cKIEd4y5bbNA27b7p8kxePGONPpxmZ3AZNXSUqaW9zpzWa7ge1E9SPdvJp1hPIb23L5y1NemrKp/7ac4vpRXpp0w0Z3uzU13jKVpOY4S1Jx/DhnurRuQ44VJc5kPMxtV7ZsJXnHJNnY5K/W9APeepev9NIk3aUB85Y0mbqhQDsyxyOq8rvoeHSDM11aucpfxhz74gS3bFXy+zlbVqn9vavLS+MpJ96sdNVqZzqaON6ZjlO7Jb/8bX3P03+WTT0NtXlvHe3tFZexx0iRn3+7nuKI4c50qc2vC/GBe7rTre7+RCv84yzbP9q8BdiyTVoD50XL1stAv9ZzrunNWk2tm6bW7yfsOTkN9GvF8e45wm47aQ+cV0waldy2Gdv2IEmNa9315qjvXh8bSBPbY2TLf+ESP80ot656/ZEpW0mKzTkiad7kLWPbXmTHHIH67x9rk5fAcU1ffMVNkacs6+rc7db5+xiZsVZqxlqFse75WJJSUz/Sze4+Jk8+76UpmvO6xjR4yySLljrT8Qg3/+Vmv41Xakehc2l5k3scY1OXQ20xWbLM37Zh65Dt/+05T5IK9ab8zXEtNzX5G7L7bMdVpm+UpII5JySb/D4q2m26O+PFRQNuV/LHirLn7MD4355XCuYYhcrfKu66izcvNftkx16hupCaY2TPg6ndH0mK7flq8OeIKHC+jcwYwpZTHGi/duxVHDPamS6Zc7bkl28hUF/sud72JaWVjf56V5u2Z8e+o9z+NFvGHZtH1e50cdfJXhp7TabEHy/YNhEaK3rrNedKry+p8sc7pY3rnOlwWTZV3LYVmeuEpNEd8wXPpWZ8bPuWYoN/7VFa4+bf9j+Sf+zTUqBNGLZfsG0zdL2bmuMY2bFv6o+FbZ9qx/KSVFrhXlt414OhPspcWxcnTnCTrFvvpYlMuXjtN3Dt0e+1dlqWtvTZ6bqsLaYbFimJin7ZLvOvnew+ejEJE0uQpLTN9FGBftiWd7rAHWt512ySinN2c9OYcWG5JTCuMtv2+j7bBwfWE7X516p2bFU2Y+zi5EleGtvX2TFqqdFdhyQVZ7jn0qTPNVucSqocEsqWzbcYAAAAAAAAABBQBAAAAAAAADAIBBQBAAAAAAAA5EZAEQAAAAAAAEBub6iPsqB/XSro95qRTWx5KXMX8WQAAAAAADAIXYr1+3hmNrHl4yzEF4YeAopDRBJFWq0tX/TK8ZU3AAAAAAAAK4lirVbPV8X9r1tjaCCyBAAAAAAAACA3AooAAAAAAAAAciOgCAAAAAAAACA3AooAAAAAAAAAcuOjLENFmqpW5S0TWRy5QwUpinZengAAAAAAwOtL3/hCmn2UhfjC0ENAcYioVVmn68VsIs0a+W3RnuqgCgAAAAAAgJxqVdbpyfPZRJpKkm6LiS8MNTzyDAAAAAAAACA3AooAAAAAAAAAciOgCAAAAAAAACA3AooAAAAAAAAAciOgCAAAAAAAACA3AooAAAAAAAAAciOgCAAAAAAAACA3AooAAAAAAAAAciOgCAAAAAAAACA3AooAAAAAAAAAciOgCAAAAAAAACA3AooAAAAAAAAAciOgCAAAAAAAACC3QQcUH3jgAZ144omaMmWKoijSHXfc4fx+9tlnK4oi59/xxx9fcb3XXHONZsyYodraWh166KF69NFHB5s1AAAAAAAAADtYcbAJ2tradMABB+hjH/uYTjnllOAyxx9/vG688cbe6ZqamgHXeeutt+r888/Xddddp0MPPVRXX321jjvuOL344ouaMGHCYLOIgC7FekC7ZhNR3DsPAAAAAAAgry7FeiCelk2kSe88DC2DDijOnTtXc+fOHXCZmpoaTZo0Kfc6v/Od7+iTn/ykzjnnHEnSddddp7vuuks33HCDLrzwQm/5zs5OdXZ29k63tLTk3tZQlUSxlqg+m4ho6AAAAAAAYPCc+IKSnZoX7DyDDijmcd9992nChAkaPXq03vnOd+qKK67Q2LFjg8t2dXXp8ccf10UXXdQ7L45jHXvssXr44YeDaa688kp9/etf939IE/WtzFFdnfNzXPYretLa6q6i1O2mqa72t1MoBPPV3zqColo/XbnsbmbUSJMm8tM0rnWmk/Z2N0mxyt90lXvY0+7SgNNSYJ8Cy0Sxm780SZ3puCawz11dZoZ7jJIut0wk/5jYfQ6JQsfRKM6c5s7Y5NaN8oaNXprS0uVu3sw+puUOL01hdL0zXd7Y7Kbp9NNo1Wp3OvXrclQw5WLKNgrU28LYMW4as88aPtxLE5tjn7S2ecvY+lIY6dblciBNbOpLYYS77aTdL5e05JZD2ucPDVK4/pfXrHO3W+vfQR2bu6pL69e7eat3j6EkxXLroVf/60d5aVQybc/uY9HvotOWTc506Lgmtn2aNF67C4hN/5nnDxG2b5Gksulji8OHuXnpcI+ZJEV1pq8w9b3cttnfuFnG9hNp4rcZr74E+onE5M87R9hyCqRJmt0/etk+QJLK819w82LKSalbnyS/7wix+xSbOhVqV7E9R5i6bM9V2Ybc+hFPHOduZ7Xb7kLrCZ5vh5ly2NDkTBb2281LUnr6RWe6OGa0m5c1fl4S0++G8mLzG5l+wpatJMW7THa3s2KVu47AcU12n+rOeMSce2J/LJA0uXUhGuH33aWFi5zpwogR7gKB/Nu+pDjeHcuV1rp9Y4htI7Z9ZDNNOXT546jSpAZnOlqyzJm29VSSCqYdBfsOIzXbThYs8paJzTnNngdD4x3LnqPVGegLbf8eantGxbGkpHKzW19sfkP9QmTKJR5l6k8gje2Xo6K7nfIadwwr+efKOHTuaXTbcGTqZbqq0Uti26uq3fFBqP2W129w12uPWSBv8QS37ysvX+ktUzD9Qtmco0P7bK9pbJri5IlemmSdm3/bt0uBfsxcayRN/k0btu4Wzf6kTf65ybYR71xq+3r55+i05F972HR2meB5xV6vmP1JTNlKUmTqh70mKATqj22vtt/IErrHOh3vnq/SBUv9NJHf1/VVWr3GT2LGw7bNSJJMn5pHaYVbv22fFex/7DjWjMPTQD9trzFDY+o0cG3hrCNQx+wxihrM+CxwLpIZTyabTX5DfZatY6E+1hyjwvRdnWl7Dpf8vrtzX3f8UP14jvG+bfOhvjzHdYPHjB9C11vRcLdf89tZk5fGnuO863fJOx+VzTkh1C+UFy5xpguzp7vbGeu2TUlKVrjrtXUh1K9VGmNLfp9UNHG0JFAu9rrZigLjh9Jid5+L47eev+KkSwoM10K2+61qxx9/vG6++Wbdc889uuqqq3T//fdr7ty5KvczCFq3bp3K5bImTnRPhBMnTlRjoz8gkKSLLrpIzc3Nvf+WLRt8BwgAAAAAAABg8Lb7HYof/OAHe/9/v/320/7776/Zs2frvvvu0zHHHLNdtlFTU1PxvYwAAAAAAAAAtr8d/jK9WbNmady4cVqwYEHw93HjxqlQKGj1aveRztWrVw/qPYwAAAAAAAAAdrwdHlBcvny51q9fr8mTJwd/r66u1iGHHKJ77rmnd16SJLrnnnt0+OGH7+jsAQAAAAAAABiEQT/y3Nra6txtuGjRIs2fP19jxozRmDFj9PWvf12nnnqqJk2apIULF+orX/mKdtttNx133HG9aY455hidfPLJOu+88yRJ559/vs466yy96U1v0lve8hZdffXVamtr6/3qM1692rSk05Pns4k0iyPfVrW3OiP/oxUAAAAAAAAhtWlJp8v9EN5tmqOOaId89xd/pwZ9tB977DEdffTRvdPnn3++JOmss87Stddeq7/97W/68Y9/rKamJk2ZMkXvfve79Y1vfMN55+HChQu1bt3WL7R94AMf0Nq1a3XJJZeosbFRBx54oObNm+d9qAUAAAAAAADAzjXogOJRRx2lNO3/c/W/+93vKq5j8eLF3rzzzjuv945FAAAAAAAAAH+fdvg7FAEAAAAAAAC8cRBQBAAAAAAAAJAbAUUAAAAAAAAAuRFQBAAAAAAAAJAbAUUAAAAAAAAAuRFQBAAAAAAAAJAbAUUAAAAAAAAAuRFQBAAAAAAAAJAbAUUAAAAAAAAAuRFQBAAAAAAAAJAbAUUAAAAAAAAAuRFQBAAAAAAAAJBbcWdnAK+NbsV6NJoiSYoKBUlSSYWdmSUAAAAAAPA6061Yj2qyNw9DCwHFIaIcxXoxGitJigocdgAAAAAAMHjlKNaLGrOzs4GdjBAyAAAAAAAAgNwIKAIAAAAAAADIjYAiAAAAAAAAgNwIKAIAAAAAAADIjYAiAAAAAAAAgNz43O8QUZOW9N7kJUlSpIIk6c7iHHVGVAEAAAAAAJBPTVrSSVrozPu1ZhNfGGI42kNEJKlW5WwiTbfMTftbHAAAAAAAwBNJqlHJm4ehhUeeAQAAAAAAAOT2hrpDsThurIpxde90aWWj83thxPDK6xg71pkuNzV5yxTqR7kz7PSatYE09e56m5v9ZcaMdmd0dTuTUV2tl6a0dt2A21GSZGnTbkWd2eFOy1v+klBOpKistFx2t1MoeNuJq6vdGUW/6qSdne4ikye6Cwyr89IkS5d785y8FKv87SRpxWU81e4y5Q0b/W11uPlPS93eMn4iNyZvyzK0jvJG99hHsf1bjl/+tryjg/b0s/LCEnctw4a5vwfKX0V3W9Hmdmc6Xb/BS1LetMlfj5cZt1y8utva5q+3ucWZjmtrnOnCmAY/jcmfrQtxoM3b7ZTbNnvLqLXVXa9pE0kgjV0mLXe521m73ktj9ykxdVCy0/kUhrvHPu12/3poj09Q5NZLv576yqbcJCk29bC0Zp23jMfUMdv/2D4gy5/bRhKzz3GOfU7a2715tk4Vd5niTJcbV/srShN3vV1uXYha/Px756cqsz8b/Tpn20go//aY2Hoa6u+9/sZbaWLnSKavS00dTDo7/DSG7T8lqbx8pTMdm/WW//a8l8Zri+Z4hM6lsalT9piF1pu0u/tkj4cklRYscmeYvITaYnG5aSN2XGL6MEmKzDkuGjXKWyZuc+tHsO+z6zXtPjXniOB4wZSD1/+EFMy5NFD+hecWO9OJKbvidLdtSlLa5J5vY9OuQn1JYtqMNzaTlJq+2pZTFKgLdtyXq18zx9XWuRB7TMotgXO2KTtb3205ZXlx81t5LCOltkmb+m/PD5KU2LHAiBH+ejeb+mHOV8nh+3lp9PDTJo0Zp+Q4x0VVlcebpSXLnOnihPHeMqkpu9j0ScnmQH9v8mfrT2nlKj+NWSYeOTKQY1fUYK4jin4bt2P30gp326GytMcxsn356jWBzFTuF+x5rzh+nLuA3R9JpZfdRzSLs2aYBfw+K93Q5Ex7Y5vGQP7tWCB07WH7DjM+Dp07C6Ys08S0q8A1mq27dn8kv41btt/LErnHyJZLGhiXFHeZ7M4w/Zo/Fvb7x9B1XMW8dfrrjUe6ZVk27Tfec7a/3gVL3c2YPrfQ0OAlseft0PVhVDDnBDNe9q7FA+upfuRFd501/rnIXhPb68O0y89bWjLjqC37HKWpomRLOU/O+rpo0j6KCtWKnl1g1uu3X+9cas499hwoSYVJuzjTSaDtxaaO2WMSjO/Y/rHFHQukmwLXOPY6zlyXhq6ZvT4q9seBJdsfBs4JldhtB8f7Rt/zb5LmiINswR2KAAAAAAAAAHIjoAgAAAAAAAAgNwKKAAAAAAAAAHIjoAgAAAAAAAAgNwKKAAAAAAAAAHIjoAgAAAAAAAAgNwKKAAAAAAAAAHIjoAgAAAAAAAAgNwKKAAAAAAAAAHIjoAgAAAAAAAAgNwKKAAAAAAAAAHIr7uwM4LVRVqy/FSdJktK0e8u8aGdmCQAAAAAAvM6UFOmpaEI2MXJ6Ni/ifrWhhoDiEFGKCvpbcbIkKS137uTcAAAAAACA16NSVNDfegKKo2bu3MxgpyGEDAAAAAAAACA3AooAAAAAAAAAciOgCAAAAAAAACA3AooAAAAAAAAAciOgCAAAAAAAACA3vvI8RFSnJR3X/bIkKS2XJEm/i2epK6IKAAAAAACAfKrTko5LF2UTqzdJkn43/mB1xVU7MVd4rRFNGiIipapPOiRJaVraMg8AAAAAACC/WFJD2plNlDZn89J052UIOwWPPAMAAAAAAADIjYAiAAAAAAAAgNwIKAIAAAAAAADIjYAiAAAAAAAAgNwIKAIAAAAAAADIjYAiAAAAAAAAgNwIKAIAAAAAAADIjYAiAAAAAAAAgNyKOzsD21VdjRTX9E4Whg9zfk5LJS9JVF3tTJebW5zpwq5TvDSlJcvcdWxsdtOMGe2lSdva3WVGjvSXaW1zpuPRDe4CZn8kqdDe4ealaA7puCwvUdIlrR+e/f+WNPHwkYqjKiXrNpiMJH7eEjf2nG7e7C3j6e5206z106RJ6kzHI0a4v3d1+es1abx1lsvevPKGjc50VCh4y0RVxQGnQ9uNamuc6bTdHOcZ0/38rVvvTtt9DOQtMcdZjz7jr9fUZRXMMbPrCPDKYHS9v5Ctp6YMJCmqMeWy2S2XUPnHo9xjXzbtSq2tXpri2LHOdGm9W7ZJp7/Ptu2lnZ1+XsaPc5dpcPMWrWvy0iRNbt9RnOr2HUnjGj9N8yZvnrthvy1GxSp3HV1+fbd1Khox3F3AHMNsIVNfbH8Z+X9/sm0trqn112vWU5w9w5kuL3b7U0mKRwXqXd/tmn5akpJut31GcTTgOqRA/of5fWxi+rpy4+qK67X1OzZ1LqoxbVVSeb3bR8UF95gF+yzb5k3/I/n1Jap2p5X6/Vra5fbdto0ngTZj23zy8iJ3HYGyjSeMd6bLy5Z7y3jn4JKp782mn5B/XrF9SXHSBC9N0uL2L3nqjxXV+fW/WD/KzZs5RkmgLttzZ7mpqeK2Y7NPpVcWV05j6k8SON9GRXefyqYfjuvq/BWbcUgS6Lu97cRu/1IO5CU2fVBsy9uUmyRFdhxo6m4U+fU/3nVXd0aovzT5tWVXsH2uAv2jrWOJP0a1/Y89f5U3+eeQtOSeNwr1fn+atLnrTUtu2Xl9i6Q0cddr+4V48kQ/jenXbN9XXm/Gn/L75XKgjdt9sssUnnjJSxOZthjqU63S2nXOtK3LwX7NtqvAeT4e745dIjM+88Z8ktJut37YPip0/rVlmQbGFDL9vR0vFwPH1Z5XYtvOOvxzhO37opFmXBUa+5p9Do2J7H4npr1Gk9zxnBRoE6YMElMGofzZ8X/BXjPIv/YLXZ/YfsyOvWxZh9Zjx3z2HChJcdmUXagumH1MzHGMA/to+77QPlppk9tebd0OXldMdMcLybIV3jLxOLddlVe74+5QHUsnumlk+qRog3+OTm3bM/2yvRaR/NhA6Nxvr4PsecaOzbIMmvGO6aOKNX5ZllY1unlraHC3Uwpsx262p59LI6k7K9d0ZVbe6arnlUZF7xwXKv/CWBMzsWOKwLi2tGipMx2sl8tXusuMHeMuEBp7mfFwusktyyQ0xq5Q/4tTJntpSqvc64joLft6yxTMOToa5pZLac1aPy8VrslCYzzv2q/POtK0clvu3VbuJQEAAAAAAAAMeQQUAQAAAAAAAORGQBEAAAAAAABAbgQUAQAAAAAAAOT2xvooC/qVKNZLdVteDFpq650HAAAAAACQV6JYLxWyD9sk5exjLmUN/qN2eH0joDhEdMdF/XXEbtlEV9NOzQsAAAAAAHh96o4KerSwqyQpifyvu2No4BY1AAAAAAAAALkRUAQAAAAAAACQGwFFAAAAAAAAALkRUAQAAAAAAACQ26ADig888IBOPPFETZkyRVEU6Y477uj9rbu7W//0T/+k/fbbT8OHD9eUKVN05plnauXKlQOu87LLLlMURc6/Pffcc9A7AwAAAAAAAGDHGvRXntva2nTAAQfoYx/7mE455RTnt82bN+uJJ57Q1772NR1wwAHauHGjPv/5z+u9732vHnvssQHXu88+++juu+/emrEiH6DenqqSko5seS6baN8sSbq/djd1R5QzAAAAAADIpyot66jyYklSmnZLku7VNHVHhZ2YK7zWBh1Nmjt3rubOnRv8rb6+Xn/4wx+ceT/4wQ/0lre8RUuXLtW0adP6z0ixqEmTJg02O8gpVqKJ3c3ZRLljy7x0J+YIAAAAAAC83sRKNDFplSSlaUmSVIhSde/MTOE1t8Pfodjc3KwoitTQ0DDgci+//LKmTJmiWbNm6cMf/rCWLl3a77KdnZ1qaWlx/gEAAAAAAADY8XZoQLGjo0P/9E//pDPOOEOjRo3qd7lDDz1UN910k+bNm6drr71WixYt0tvf/nZt2rQpuPyVV16p+vr63n9Tp07dUbsAAAAAAAAAoI8dFlDs7u7W+9//fqVpqmuvvXbAZefOnavTTz9d+++/v4477jj99re/VVNTk37xi18El7/ooovU3Nzc+2/ZsmU7YhcAAAAAAAAAGDvkixw9wcQlS5boj3/844B3J4Y0NDRojz320IIFC4K/19TUqKamZntkFQAAAAAAAMAgbPc7FHuCiS+//LLuvvtujR07dtDraG1t1cKFCzV58uTtnT0AAAAAAAAAr8KgA4qtra2aP3++5s+fL0latGiR5s+fr6VLl6q7u1unnXaaHnvsMf30pz9VuVxWY2OjGhsb1dXV1buOY445Rj/4wQ96p7/0pS/p/vvv1+LFi/XQQw/p5JNPVqFQ0BlnnPHq9xAAAAAAAADAdjPoR54fe+wxHX300b3T559/viTprLPO0mWXXaY777xTknTggQc66e69914dddRRkqSFCxdq3bp1vb8tX75cZ5xxhtavX6/x48frbW97m/7yl79o/Pjxg80eAAAAAAAAgB1o0AHFo446Smma9vv7QL/1WLx4sTP985//fLDZAAAAAAAAALAT7LCvPAMAAAAAAAB44yGgCAAAAAAAACA3AooAAAAAAAAAciOgCAAAAAAAACA3AooAAAAAAAAAchv0V57x+pQo1tKacdlEd9uWedFOzBEAAAAAAHi9SRRraVyf/X9UkiSViS8MOQQUh4juuKg/jdormyg17dS8AAAAAACA16fuqKAHijMkSUmpc+dmBjvNGyugGEXZvy3Sri7n56S75CcpFJzpuK7WmS4tWVZxs4X6URWXKXd2uNsJLBPV1DjTyaZWd4GNTX6aYcOc6TRN3N/XbfQ3NLzOmSxOGDfwdiWlnW4nEZvtSlKyebM73drm5sWUrSSlpW53mdEN7u9r1vrb6Wx381Ljr9cqjBntbqeqylumtHqNM10cO9b9ff16f8X2uFZXu7+bOihJabnsTCdmGVsng8xxlqSoym3O5Vb3OHp5C/DSmLyGE/nL2GNv8xsV/fJPWgbOry03SSo3t7hpbF3Ydzd/O0+96KaprfGXWbvOnWGnRwz30sS7TjYz3FZu26okRcPNvMQtp/Jav87Z4xyFjlHkbjsx5RQUpe6k3HoYKn/vGJn2HEoXbXD7pMKYBi9Nyey37aPSxM2rJEWx+xdRW8cS01YlP/9R7PfMcZ3bX9r6HjqvFEz9sO2hMGqEvx1TD8tNTW7eQm2mze1zg32HaXtJe8eAv4dEo0z5m+1KUmG86S+XrnCm44LfT5eXr3S3k6OPKq1w0xQnTwos5B6T8sZmZzpPewjV96gw8DJpoC6kpl+zbSR0Li1vaBowb8G6sGp1xWW89mn6CW9agXZj+5Z293wsSVHgvFcxb7afyJH/qNpdprzaHy8URtc70/Goke46x7tjA0lKXl4y4HYkKe0yx9Gce1LbzpSj/ANsH1XetGnA7UqBY5b4bTzUV1dix4Fef9PhX0xGY93yTU3djkf4fWFixyE5linOmO5up8lt85I/xrBlUJww3ktTUeqfi/xl/PJPAuf2vuz5TAr0HQ0NzrQdD0mBc2en3zYj0ya8cV8ojR1vtmzylvHyYsbhpRWr3HUG9tmWXaG+3lvEbrtoz0VPv+DnZfZMdzPrNpjt+sfV1n/bB6jgt2d7zEJjF49dJlR/bL9r+5JAmjxt3o53InNOC453KtRD2wdLgWuwze7+ROYYSlKystGZDp2jk/VmfGnyFkqTLnD7e3uMksD52J4TbH8fHIuVzXVQYLxTNuPjeKRpm/XutCRppNs/prVm7LtouZfE9nU2/4VQn2v69+C535y3YzMWjia6/VGWv6XuDNOeo2LlUFUwvmPHZza2EbqONn1hYs4jweNq2l6amPHnGnP9KKlgt/P4894yqaljkSnLwiS/LG1dtmPh4rRdvDTe2LFPHxCnXZJ/Kg3iHYoAAAAAAAAAciOgCAAAAAAAACA3AooAAAAAAAAAciOgCAAAAAAAACC3N9ZHWdCvqrSkw7p6XtaZvQj2L8NmqTuiCgAAAAAAgHyq0rIOV/axvCjJYgoPR7uo237FDm9oRJOGiFipppW2fD0qzg77o+lMKfBRNQAAAAAAgJCCUk1X9mXvKM2CiI9GU1T5m+J4I+GRZwAAAAAAAAC5EVAEAAAAAAAAkBsBRQAAAAAAAAC5EVAEAAAAAAAAkBsBRQAAAAAAAAC5EVAEAAAAAAAAkBsBRQAAAAAAAAC5EVAEAAAAAAAAkBsBRQAAAAAAAAC5EVAEAAAAAAAAkBsBRQAAAAAAAAC5EVAEAAAAAAAAkBsBRQAAAAAAAAC5FXd2BvDaSBRpdWFkNlGsyuZF0U7MEQAAAAAAeL0pK9JqDc8mokLvPAwtBBSHiO6oqLtr52QTw+t2bmYAAAAAAMDrUndU0O81Q5IUxVU7NzPYaXjkGQAAAAAAAEBuBBQBAAAAAAAA5EZAEQAAAAAAAEBuBBQBAAAAAAAA5EZAEQAAAAAAAEBufOV5iKhKyzqwe3k2EdVIkubXTVV3RBUAAAAAAAD5VKVlHaQ1kqQoKUiSnowmqTsq7Mxs4TVGNGmIiJVoj+612cSWIOLfaneVop2YKQAAAAAA8LpSUKo52iBJitIsiPi3aKK6d2am8JrjkWcAAAAAAAAAub2h7lAsLV0hRVW901HBvd02rq3x0kTV1e6MctmZLIwY4acZ6c4rr1nrTKdmHZIU19W502NGe8uUV5v1lNz4fnGXKV4adXU5k6W160xms5hxMS0pSduzbSdZOaTapDSqUrllk79ew5Zl2tnpLRObsowb6t28Na6pmKY0xS2XwvoNfpphwwbMazy8zpvXvf9Md71/espbplDv5jdpbXPXW+evNzXlb499eY05HpKUJv485+d0wN8l/3hIUrm1dcBlEpNXSYqKVc50XFPr/m7bhyS1t1dcr78h87eLkv+3K6+OmbK07SG03njEcDfNcwu9JF77jPzbdOP6Ue6MsW69LL3wspemaPJS2rDRXWeV392Wm1vc6Xce5EwX7mn00qRdbn5D5VKpLEP9mi2HZPNmZzqUf3vso9gvy0JDg7+tPkpr1/tpzHEsrzdlmaMvt23T1vWQUN+ddLh9XXH6VPf3xUu8NOVNbp+aa9smv/YY2fadrXgb/iZo+p88eSutWl1xmcT0dd4xCvRZBdPOSuv9uhC3uvXQ5jcJnCMic46wxzUq+fU0MvU7VJftPqS2L9zkn0ttvSxMmugu0OGfS1N77jF5C9VTBWZZxfHj3PV0mb6js6PiOuw5Ozjese23qaniem07C50nvTaRo53ZffTGO6srj0u8cpIUmfpt22/ovOKf2ysftLTkloM/Tgn0C3Yrpj5JlfsXb38UaHumvqSB8Y5t4/acFzqvRPvPcdf77AJvGW980NTsTpvzl+S38Xi420+UNzR5aSoJtsUcy6RJyZku7LmbM508/1LF9dqyDI0LrWiYP44trVzlLmOOc7i/cecVd3PH2MnSFf52TP9ux5u2PgVNm+zPe9o99hrttpEocFzLS5Y70944Kse51esnAtdF/noCZRm7y9i8hK49bP9i+8LCyJFeEq8fKwT20azXngejgn9NEI0b40zH7e5xLJuxcCh/acltDwr0JfYcERyT2j7JnvsDbSQe0+Cuw1yrxmb/JKm00h+b92X7PUlK5kxzl1nqn3sSU1ej8WPd7b7sX9MUTT2MNrvjknK7364iU+dU7bb58kbTphQYE/XW7VhKs9+imuy8GA8bqUJU5bWJ8oJF/nrtecU7zn6bKZi+O5o43lumtNDdVtTgHpNivd9G1OaWnW0zwfGOrYdm7BLv7Z7PJClqNtfroXGgKTt7fk2W+mkKU8z4ssr05dU5rkX65CVNc1zfb8EdigAAAAAAAAByI6AIAAAAAAAAIDcCigAAAAAAAAByI6AIAAAAAAAAIDcCigAAAAAAAAByI6AIAAAAAAAAIDcCigAAAAAAAAByI6AIAAAAAAAAIDcCigAAAAAAAAByI6AIAAAAAAAAIDcCigAAAAAAAAByK+7sDOC1kUhqjmokSXFcK0lKFe3EHAEAAAAAgNcb4guQCCgOGV1RUXdqd0lSoWbkTs4NAAAAAAB4PeobXyjWjd7JucHOwiPPAAAAAAAAAHIjoAgAAAAAAAAgNwKKAAAAAAAAAHIjoAgAAAAAAAAgNwKKAAAAAAAAAHLjK89DRDEta2+tlyQVulslSc8VJ6gUFXZmtgAAAAAAwOuIE1/oapckPV81kfjCEENAcYgoKtUB6RpJUlyqkSS9WBynkmjwAAAAAAAgHye+0L1JkvRS1XjiC0MMjzwDAAAAAAAAyI2AIgAAAAAAAIDcCCgCAAAAAAAAyI2AIgAAAAAAAIDcBh1QfOCBB3TiiSdqypQpiqJId9xxh/N7mqa65JJLNHnyZNXV1enYY4/Vyy+/XHG911xzjWbMmKHa2lodeuihevTRRwebNQAAAAAAAAA72KADim1tbTrggAN0zTXXBH//1re+pe9///u67rrr9Mgjj2j48OE67rjj1NHR0e86b731Vp1//vm69NJL9cQTT+iAAw7QcccdpzVr1gw2ewAAAAAAAAB2oEEHFOfOnasrrrhCJ598svdbmqa6+uqrdfHFF+ukk07S/vvvr5tvvlkrV6707mTs6zvf+Y4++clP6pxzztHee++t6667TsOGDdMNN9ww2OwBAAAAAAAA2IG26zsUFy1apMbGRh177LG98+rr63XooYfq4YcfDqbp6urS448/7qSJ41jHHntsv2k6OzvV0tLi/AMAAAAAAACw4xW358oaGxslSRMnTnTmT5w4sfc3a926dSqXy8E0L7zwQjDNlVdeqa9//eve/EJDvQpRde90NHyYu0CSeGmS9Ruc6Xj8OGe63LjaS5O2bQ7mq3e7xSo/TXfJ3e7add4y8Yjh7rab3UBpsmGjv96uroHzUihk/01TRUm8JS/d2X/L7Uqibi9NwZabJG1Zz9bMBMpys1suyYYmZzqu8qtbPGG8O73Efcy9tGmTnxe7jupqd0Z3wVum8Ken3OmxY7xlktY2d7pC2UpScdIEZ7q8Zq2bt9oaL413zKLKcf141IiKy6jLPZZlU0+D9bLkpimMaXDXYdpHMG81tf48k9/yxuYBtytJkTmOaVd7xW0X6ke56zB1zOsDJCUr3b7I1ltJijo73Rktrc5kPCyw3gp1NR450p9p6lxxidvGk8B24sluXxmtXustY+tYYcSIAX/PVuTWw8i2+UA9jeLIXW+SesuUm5r8bVWQtLuvyPDq6fRd/TQrw+eYHlG1X/+j2N0n209Lfr9VWrLMXYctp9C2TTmVlq2snKZcdvNh+zlJUY3bv5RNfZIkpX5f7fwcaIuW3XYSKifTpyamL1TJT6N6t00UJo/zFkleccs73mu2M11+2h8n2LIrjhntLjC63ktTWrjYz58RF805zLSJ1GxXkmTKqmzaq60bUo46VeGYSlJh3Fh/phljpKvc8U2oL086+39dTX95sefSQkODMx3qE7xtB8rFts/irBnu72v8cVVkjllxvFsuySa3b5f8/jEtB/pL28eaOhXV1XlJks1uu7fHOdR/2vN2uaXymMjry3OUpRUc/5j1xoF9rMjWF9umJCVPPuduNtAebLmk9pwd2rTZp6TDTWPrhiSV7TjWjOmSdn+cYo9jYb85/jIvLnKnF7v9XOh8W5wyyc2buT4J9eXldesrrteWr60v9lpE8suqvGjpgOsIbdvLb54xxoIl/nqtNveYhPple52Tlk09DLRF2xfaNhK6xrHbLowKjAPtud6MFUNjy9iM6bzxfegcErtt3o5/JCkyY3e77ajaX295kXtMbL9Q2GNPL03y/EI3jWlXkbkWkaSiGe/bc6nkn0fsMQrVSxsHsHUjtB3LHld7DpSk+NlXnOlSq3/usW0xWe6eM0LXHqXlKyouY3n9v72mD5zXU9OMesaFUSpF5S3xhS3lnSSblURFfz2BNh43uMdVk9xxYPps4Dscs6e52X/mRW+RSuOo7mn+eLPwqHvuse23OG0Xf0Vldx8jc+zLT/t5K86e4UyHzrdeH2WOWXDsbs5p9lrDjlMkKTbtqtQnPpWkla8PeteTe8m/IxdddJGam5t7/y1btqxyIgAAAAAAAACv2nYNKE6alP31bPVq969mq1ev7v3NGjdunAqFwqDS1NTUaNSoUc4/AAAAAAAAADvedg0ozpw5U5MmTdI999zTO6+lpUWPPPKIDj/88GCa6upqHXLIIU6aJEl0zz339JsGAAAAAAAAwM4x6Hcotra2asGCBb3TixYt0vz58zVmzBhNmzZNX/jCF3TFFVdo991318yZM/W1r31NU6ZM0fve977eNMccc4xOPvlknXfeeZKk888/X2eddZbe9KY36S1veYuuvvpqtbW16Zxzznn1ewgAAAAAAABguxl0QPGxxx7T0Ucf3Tt9/vnnS5LOOuss3XTTTfrKV76itrY2nXvuuWpqatLb3vY2zZs3T7W1W1+UunDhQq1bt/Wljx/4wAe0du1aXXLJJWpsbNSBBx6oefPmeR9qwbZLJXWo4M0DAAAAAAAYjM6ecFIU+BgThoRBBxSPOuoopWn/oagoinT55Zfr8ssv73eZxYsXe/POO++83jsWsf11RkXdVth7Z2cDAAAAAAC8jnVGRd1W3BJfCHzFGUMDRx4AAAAAAABAbgQUAQAAAAAAAORGQBEAAAAAAABAbgQUAQAAAAAAAORGQBEAAAAAAABAboP+yjNenwppot3Sjc68BdFolfkiEwAAAAAAyCmLL2zIJrbEFBZEY4gvDDEEFIeIKiV6S7rSmbckqleZm1QBAAAAAEBORSV6c9ITX4gkSYuLDcQXhhiONgAAAAAAAIDcCCgCAAAAAAAAyI2AIgAAAAAAAIDcCCgCAAAAAAAAyI2AIgAAAAAAAIDcCCgCAAAAAAAAyI2AIgAAAAAAAIDcCCgCAAAAAAAAyI2AIgAAAAAAAIDcCCgCAAAAAAAAyI2AIgAAAAAAAIDcCCgCAAAAAAAAyI2AIgAAAAAAAIDcCCgCAAAAAAAAyK24szOA10ZHVNRPCvvt7GwAAAAAAIDXsc6oqFuK+2cTEfepDVVRmqbpzs7Eq9XS0qL6+nodpZNUjKp65xf2neMsly5c6qVN2tud6eKUye4C5XLF7ZfXrXe3E0gTFQoVlymMHFlxmUrrLbe2ub/HkZfGrjeurnamk64uL02eZWxeomKVO13lx6/Lra3udoYNc7ezefM25cUqjh1rZhS8ZZKWTQOuI+no9OYVRtc702l7h5vG1C/JL5d4xHB3gUCTTO0+huqG6ciTTjcvttwkKR7d4K52/caB8yYptcek4Jdl2l1yp3PU5cJw99inSeJMJ6Zs84jraisuE82a6s9b65ZDafWaiuspjh/nTJc3uOuw7SObaU6+pr1GgWMWFd125NUNSeVNbl2Oa9xysHVD8vuf7dGXSH779PqFQLlE5rglZn9C5WL7jtL69d4y3nbMtu06pEBZ5uh/CiNGuMuYviNUL21Zpp0mTSBvtq8I9Td52p5VaGhw12HbXqAuKDF5sf1PKP8lt58InntMOnvsE1NPpcA+p25fEmyLdh2J3w/HtTXujMiUQ6Dvtn1oae26itvelnNcpXXkWk/gYqAwyu0XEnPODpWTV962zYf6ErOeeK/ZfvZWrnWmt6WN2+2E8hKb9hs639q2Vpgxzd3OajevoTTePtv6FUjj5TV0nM35txA6j3d1O9O2z/XavOQfVzte2+SPoSqeIwJ1ztbTULnEY0Y706WVjQPmVZKKE8a7ada4x6hQ747nJKlsxoV2nGLHsJLff4bKpbDbTHfGOne8UG5q8tLYsvL6scA+RzVu2UWBspQZUyRNze7voXOISRNVuW283GzWISmuq3O3Y8+Leep/oL7E5trC1v/i7BlemrTRHdNFtp/b2OSnMeu1fXs03D/HJaa/t21GCp/DnO2ExrHmXGPHgcFzqSl/e87OVuTWoVzXoaaOxePd663SkmVeGjvelDmGaaBMvH3KEbzyxniBsrRjXbuM7SuzmaYvNP1aaFzu1f/QeC3H+clbrzlf2W3bawap8vjenrMlKS255ZDrus7GNQJlaWMDtlxCeclzfRuZ8rZ9Uqi/T9rc61svb6E4gOkH7LWqjRNI/vVhYZfJ3jKlpcudaXuNafMqBWImpo0UzXlT8vufeJdJW/OQdOruRf+m5uZmjRo1ykvrpBvwVwAAAAAAAADog4AiAAAAAAAAgNwIKAIAAAAAAADIjYAiAAAAAAAAgNz4yvMQEaeJpip7MXSaZi9SXaaRSvgiEwAAAAAAyKlvfKEH8YWhh4DiEFGtRO9Isi9tpcq+TnWb5qiDm1QBAAAAAEBO1Ur0DrlfJCa+MPRwtAEAAAAAAADkRkARAAAAAAAAQG4EFAEAAAAAAADkRkARAAAAAAAAQG4EFAEAAAAAAADkRkARAAAAAAAAQG4EFAEAAAAAAADkRkARAAAAAAAAQG4EFAEAAAAAAADkRkARAAAAAAAAQG4EFAEAAAAAAADkRkARAAAAAAAAQG4EFAEAAAAAAADkRkARAAAAAAAAQG7FnZ0BvDY6VNBt8Z6SpLRc7p0HAAAAAACQV4cKuk1zvHkYWggoDhVRpI4thzuNop2cGQAAAAAA8LrUJ76AoYtHngEAAAAAAADkRkARAAAAAAAAQG4EFAEAAAAAAADkRkARAAAAAAAAQG68RXOIiNNE49UuSUrT7CvPazVMCR9oAQAAAAAAOcVpqvHa7MwjvjD0EFAcIqqV6N3JIklSqkSSdJvm8GUmAAAAAACQW7XKercWO/OILww9PPIMAAAAAAAAILc3VPg4rqtVHFX3Tker1jm/l9vbvTSFMaOd6dLKVc50ceIEL03S1OKuY/IkdzurGgN5q3Om0yTxlkm7ut00u5j1Llnm5yVJ3TRV7iFNe3+PpS23H0dxIftvoVpx5FeBeNgwfzub3duZFQVi0XZe6u5jWi5XTBOPH+umWd7p56Wry19P33UE8l9uanKmC2PHDLgOSYpqapzpYmC9aank5q3DzW9UrPLzV1frzjDrKLe2BtK49SdUBnaZuLranW6o99LI1MN41Ag3Lxs2VtyOAsc1Lbl12bajdLPfFpW6ddmrczkU6t19TLu7vWXike4+Jq/47arc3uHOMPW0MGpkxbzEI91lkk2bvGWiYmym3fZYbgmkid3HCILtyjJtMSoUvEXKJn9xjVtPQ3XOrifpLnnLeFkx+S3MnOYvZPeptc3dbtHvt2wbt/mPqv22aPe5bLYjBfpus4+hskxNWdllgsesbI6R6TtsXiW/jW+LQkODNy+19d/UHwXOG0mX2/cVzXmx1LjG3/Zot70Wa8d6y6Qdbl7SNrfvCJV/PNztq8vNzRXTpOZcKoXOV+YRHnPM4qlTvCTlxW7/Yo9r+ua9vTTJX5422zX9RCj/ps+N9pjpLVNsNWW5scndbuDcY+d557RQXU5NH2XyZks6pPzMS948b79tv1w/yl+R7S/tOTpQlnafC1N39de7bLm73nUb3HUExpte3zdixIC/S/54xp4XK42HJCnt9MdRdlvpJlN/crSR1PSXcaj8TX9p+zF7zpakwm7uOSFa649DLDv2DZ2LkmZ328XdZrkLFAN9iTmO3vgsMBZOc4yXk0VL3ekK5wwpUH9MeZfWr/fSFMw5oryx2V/GjLtjc12UmLodyp/tY4tj/b7ctoniOHccHhpvetcItTXeIl5bM2nS0HrtOdmcZ0L9mh1D2DFdwYyfJSke3eCmyTGms3U3CuyzLSvbNr1xuvzrk9A4Ng30WyazgVnuvGTNOm8Zj0lj96c4ze9zk6Vun2vLTfLbSFRw63/ousKOo+wyobL0xuqmLoTqv22fxdn+Obr0yhJ326aNR4HyL9n6ba+9336Ql6bwyLPevL6Szg5/Zui631tkS3whrlIUFb1zTxQYs3YfvLszXfXkAjfNpEAcZsGiinmzddk7JqMD18Smf7dj+ZDQdUNfSXOLN8+21/KKVd4yxfHj3DR2XF7240je+NKOvexYXn6b6RtrKqf+NXR/uEMRAAAAAAAAQG4EFAEAAAAAAADkRkARAAAAAAAAQG4EFAEAAAAAAADkRkARAAAAAAAAQG4EFAEAAAAAAADkRkARAAAAAAAAQG4EFAEAAAAAAADkRkARAAAAAAAAQG4EFAEAAAAAAADktt0DijNmzFAURd6/z3zmM8Hlb7rpJm/Z2tra7Z0tAAAAAAAAANtBcXuv8K9//avK5XLv9DPPPKN3vetdOv300/tNM2rUKL344ou901EUbe9sAQAAAAAAANgOtntAcfz48c70//t//0+zZ8/WkUce2W+aKIo0adKk3Nvo7OxUZ2dn73RLS8vgMzrEdKqg/4l3zybiLGDbpcJOzBEAAAAAAHi96VRB/6PZkqQoruqdh6Flh75DsaurS7fccos+9rGPDXjXYWtrq6ZPn66pU6fqpJNO0rPPPjvgeq+88krV19f3/ps6der2zvobThpFaopq1RTVqnnLv5Q7QQEAAAAAwCD0jS/0/CO+MPTs0IDiHXfcoaamJp199tn9LjNnzhzdcMMN+vWvf61bbrlFSZLorW99q5YvX95vmosuukjNzc29/5YtW7YDcg8AAAAAAADA2u6PPPf1ox/9SHPnztWUKVP6Xebwww/X4Ycf3jv91re+VXvttZf+/d//Xd/4xjeCaWpqalRTU7Pd8wsAAAAAAABgYDssoLhkyRLdfffd+uUvfzmodFVVVTrooIO0YMGCHZQzAAAAAAAAANtqhz3yfOONN2rChAk64YQTBpWuXC7r6aef1uTJk3dQzgAAAAAAAABsqx1yh2KSJLrxxht11llnqVh0N3HmmWdql1120ZVXXilJuvzyy3XYYYdpt912U1NTk7797W9ryZIl+sQnPrEjsjZkRWmqem35MnaavSy1RTW8OBUAAAAAAOTWN74QpWVJUjPxhSFnhwQU7777bi1dulQf+9jHvN+WLl2qON56Y+TGjRv1yU9+Uo2NjRo9erQOOeQQPfTQQ9p77713RNaGrBqVdWLycjaRZv+5rbC3OnfsazQBAAAAAMAbSI3KOlELJUlRUpAk3RbvpQ7iC0PKDjna7373u5WmafC3++67z5n+7ne/q+9+97s7IhsAAAAAAAAAtrMd9g5FAAAAAAAAAG88BBQBAAAAAAAA5EZAEQAAAAAAAEBuBBQBAAAAAAAA5EZAEQAAAAAAAEBuBBQBAAAAAAAA5EZAEQAAAAAAAEBuxZ2dge0p6ehSEqVbp9vbK6Ypb2x2pgv19c502tHpb6ery51escpdx/BhfhqTl8KE8X5m6ke6217R6KYZM9pLkrZ3+Otxft+y3TSR0qxsomJ22KPqKkVRldLukpumq9tbT1xT606P9fOSrN84cF5MuUlS1/GHuOu95yl3gUP29tJEjz/nphlpyq3TP2aKTOy8utpbJB4x3J1RrNw8yuvXu5spFNzp6iovjZe/HNux9cduJ7RMoaHB/b15k5cmtnWubeB1SFK6ebM7I5AXL3+lsruOsjst+eVSMMdVsf/3j9Tsc9Lm5i20ncS0mcLoem+ZyLSB2LRpux1JirrdY223Ezxmnab9mmmvDCSVN7nHsTBihLeMbdNKE28Zy7bxPNIkdaYL9aO8ZZLWtgGXKS9a6qUpTAz0j33TmHVuyYw7bdp8JL8tRkV3XrBemn7LW8b2LZIKDe5x885FJXN8JEWm/4lMv5Cs9ftPu+3CuAZvkWRjkzNt82+PT7aQW5ZevxZoizZNssHdbhRHXhLv/OufVpQ0twyYl2Abb67c9ixvPYE2k5i+LzbnkXT1Wi+Nrcullea8/vRCfzuBsuoreF6xx/X5BX5eTH9ebjHnhMA+2/6l3No6YN4kv11JldtMXOXW9zjQlyhyyyXd3G6m/X453nWKO8PUy1AaW05pU7O3TFxX5y7T7Z4z/DIIHKPA+NJLUzLnIlvnAvXflm+wXzPzvDYSOq9Hbn8fmWNW3uCPAW052foU1fvnOLW6x7W0xm9XVnH32e561673lrHj5fLiZW5ea2v8NKacvOMeGNcm5vxbnDzRX2adm794mBljBOqll7fQWNcuk7ht2tYnSZIZ73jjzeHuPkt+v1wcP879vSXQT9hzhF0m0C8oHThvkn/dVm5222soL4UJbn5Lq1Y707Y/kqTItD07LiwtW+lvxyzjjc0UaONmLBZqV974xjTX4PWvLd8kcI4z9dk7Z5jjHtyW2Y5tM5KUmPNIfPA+znTpiWe9NHnGa7Yfi8c0uAsExi6lFe5xK5rr8yTQ/9ty8tYZ6gtt371mnbdMcbeZ7naWrnDTBLZlx1bxCNMe/vSkl8Yeea//D7ZFN1XP/kRprKhs0seRoihSPHaMm5dAXx7/yb3uj6a65+zSy/4YyfKupST/PGjqbrreP0d4ebPnL9NvSFJijqPtJ0LXi8XZM5xpey7KJTBes31SNMy0vRr/HFeocttV2Ynl5L/vkDsUAQAAgP/f3v0HV1Xf+R9/nXNvchN+JCFAfiEgKkJV1H79gbRbdUZGsH47xfbrWNZZreO6s7vQ0bJ1d+nYqrs7w4xOp92uTt39Y8vO7FpbZqpuHbf7ZbXi1xG1aq1iKwUEAkpAwCQkQHLvOZ/vH5HI5wfJAZLchDwfMxk553w+53zO53x+nbc3uQAAAMiMgCIAAAAAAACAzAgoAgAAAAAAAMiMgCIAAAAAAACAzAgoAgAAAAAAAMjsjPqWZ5xYr2L937jv26Piir5v+Slq8G++BAAAAAAAOKaoWOtz53j7ML4QUBwn0ijWXk2UJMVx9SCpAQAAAAAAfH3xhUnlLgbKjBAyAAAAAAAAgMwIKAIAAAAAAADIjIAiAAAAAAAAgMwIKAIAAAAAAADIjC9lGS+MUZUSSVJkipKkHuWlKCpnqQAAAAAAwFhijAqfxBeO6VGO+MI4Q0BxnKhSopvT9yRJUW/fY19XeZF6VFHOYgEAAAAAgDGkoEQ3J7+z9q3LXdD3oSWMG/zKMwAAAAAAAIDMCCgCAAAAAAAAyIyAIgAAAAAAAIDMCCgCAAAAAAAAyIyAIgAAAAAAAIDMCCgCAAAAAAAAyIyAIgAAAAAAAIDMCCgCAAAAAAAAyIyAIgAAAAAAAIDMCCgCAAAAAAAAyIyAIgAAAAAAAIDMCCgCAAAAAAAAyIyAIgAAAAAAAIDMCCgCAAAAAAAAyCxf7gJgZPQq1ovxTElSnC9IkorKlbNIAAAAAABgjCkq1v+LZ3n7ML6cWQFFk0pK+zfjQpV1OJ400cuSHjpkn+Joz6B54mr7vKbHzqPKCi9PzslT2tPmpzl8xNqOZjTZed7bEihLtZ0nZwcJc2e19P979yf/Tds++uQfffVlksTOc/ZM7zrJ9p12WT7c46VRFDubkb1dWellqd5o31NSLNl53nzPy+OWN2lvt7bzLc1ennT/ATtPoP6jvP3c4vo6azv4zOrsNObIUaewxr+OUw/pEfu5u+eUpKSj0z5HoeClMYcP29tuuzSpPIm9r/cLF1nbVb/d4WVJnfqPvBT+PZYOfjx4WdzrOHXpPndJyjdMs/O02/UUyuNK3LJJij97gbUdffCRfd6OjkHPm2+x+2/SttdL4/ZXtz+7dSBJ8SDtR/LvOzd5sp3AbRuS0t5eO8+UWrusWerSaaeSlJ9Wb22X9h+0tt3xVJJKH3xol2XSJLusR/3ym1LqbBed7cB057TDuMJP4/a1xJkzgpx7ip2xMO3q9rKknV0Dli1fP8XL49Z3ad9+L41bv25/DY3LSbczliR228i77UlS3hkvzcd2H3Hbl+S3jdS5riTl5sy2tktb37e24/91oZfHvPmuncYprzdOy++LbnsKytvtJdQ2Imdcdq8TBdq/nPbt9ecZ/hynnbsGLJskyWmHudoaazvULo3z3Lx6CowLuelT7fMesPt8KI+7L/SMvLI467NQ+0m3t1rbeadsSYe95pCk1JkTQuNC6qxV3HE5rvX7iDnoPEdnjA3Vv3eODOOwe97QHOeud/z69+cVd42nHv8ZueIJE6xt9x6NMx9IUlRhly0/7zz/xPvtezJ77Pk1tEZKnPbjjo1JlzMGB0SR3Yfc+wtJAuOyN/dPqXMy+eNP6tR3lvKmzvjjtlNJMiVn3e2ULVQWkzpr26n2/JQGnqs7p3nzeob2FOKOCzlnrgyulzvtsTpX48wRRXv9EOKtZQLjhJz2Euy/7rvTRHsdqCOhVbbNrYOQnDNeeu8I8ttHlvN644K7vnfbigLtv90eF1L3nPLfKU2gKt01dKltn7Xt1kGoLO7cE1q7BApnlyPQz9x6SQLjfe5AoN8MUhZvTeHMcXEgj/tc3f7sjQGSctMbrO1jdZtK2q6+vuz2gdRZo+YapnvnVa+zVnfWwu4zlfx1U+S8C0pSzwx7fVP5+lY7j7P+lKRkh71eiJx1lGn333HcuoyPi7tIkpw1iCSVtu2wtkPt0rjxkMn2eBn1+mOUGw/JOfOKaQ+8u2ZYU2RBCBkAAAAAAABAZgQUAQAAAAAAAGRGQBEAAAAAAABAZgQUAQAAAAAAAGRGQBEAAAAAAABAZmfWtzzjhAppUf+n43VJkin2fbPUuvyF6oloAgAAAAAAIJsqU9LN5j1JUlTq+5zautwFxBfGGT6hCAAAAAAAACAzAooAAAAAAAAAMiOgCAAAAAAAACAzAooAAAAAAAAAMiOgCAAAAAAAACAzAooAAAAAAAAAMiOgCAAAAAAAACAzAooAAAAAAAAAMiOgCAAAAAAAACAzAooAAAAAAAAAMiOgCAAAAAAAACAzAooAAAAAAAAAMiOgCAAAAAAAACAzAooAAAAAAAAAMsuXuwAYGaUo1q8nzJEkmSMf9+0jngwAAAAAAE5CUbFei5olSXGck0R8YTwioDhOJFFOfyg0SZLSTzo8AAAAAADAyUiiWJs1VZIUx4SVxitCyAAAAAAAAAAyI6AIAAAAAAAAIDMCigAAAAAAAAAyG/KA4gMPPKAoiqyf+fPnD5hn3bp1mj9/vqqqqrRgwQI9++yzQ10sAAAAAAAAAENgWD6heOGFF2rPnj39Py+99NIJ07788stavny57rzzTv3mN7/RsmXLtGzZMm3atGk4igYAAAAAAADgNAzL1/Hk83k1NTVlSvuP//iPWrp0qe69915J0t///d9r/fr1euSRR/TYY48NR/HGpUJa1JcOvSVJMqVuSdJ/5uapJ+IbmQAAAAAAQDYFU9KXtVWSFJX6Pqf2n7nziS+MM8PyCcUtW7aopaVF55xzjm699Va1traeMO3GjRu1ePFia9+SJUu0cePGE+bp6elRZ2en9YPBFdJS34/p+wEAAAAAADgZkdQfVyio7wfjz5CHjxcuXKi1a9dq3rx52rNnjx588EF94Qtf0KZNmzR58mQvfVtbmxobG619jY2NamtrO+E11qxZowcffNDbn582Vfm4sn/bHO2xjift7V4es3CBfY4PDtgJktTLExl7X1xbc8KyHtMzf4a1XfHqYT9Rap/XtH1kbecmTfKyJN32eeIK+5EmO3dJkvKmpFQdkqQo+iSOXCrKREZRLmeftMMP0HppsojseHV65IiXxI1ox5WV1nbac9TPU6iy0/T22glKgw9mJjX+zlLR3nbuOVc/xcsSTZhgn/eIXV5T9Mti3PI69eQdV6D+A+3SPY8rnlrv7Uv22W0s/z+vW9tZpoU41C47OgbME+Ur/H2DtTHj37M5bLepeNJEezvnjzlunqipwb/WEbstJAcO2ud12mlf8ew2ZToPWdu5hul+nh57jPKea+Ce4wb709+lD/Z4ady2kByyy5Jv9O85cuolOfixfTzwfEyS+Nd20zh9IjfR7jNuP5P89uH2o6jSbz+xc960q2vAc0h+2w31vaSr2ymcXbfumCtJ5pB9bbcsIW5d5s8529ouvb/Dy+M+k1xgLkqdZx9XV9vHnXkydN6o0h5zQ3OpO2+4zyM/faqfJ2/XXXo4MC867Tt2xtyo13+ubvuJ6uvs67R+4OUx7vgf4J7XLW+uttY/r1O/7nwV6kNu+46MM69v9/8nrVv+nDMWSlLqtOWo2n6uofFGyjlJ7HEuNC6kznjp3mPont26iwr+GOu2F7duQ3I19hzgzRlVBT9TFFmb6RF/HZKf0WxtJ3vsNavp9duTW1dumuB6wW2X7jwfeGap0xeDzyhwrcF45U8GPi5JpsWZ97bafSaK/XVL6qxro0B7j9y1otMWosBY7o5BpY/s9b47Nkr+utXt88G1TGy3n9C4rGn2ejLZut3OU1fn53HL5q6PA2tAd63irpEkqXTArgevLwbmW7fdpRPtfhRaI7lC7wSDCZ3XPU/s9F+F1vvOPbnrlOC82DvwGOuusyQp55Y3OMY6nHVgqJ5C7e54oTVecsBe08Xu+C//HrwWFVqTVjlrrwzjsjv+GGdOzgfet9x1R2i8cef6nDtnnGO/i0tStGmLvT3DXmNHWwLrEoc3x4XWE07/DI6XTjuMnfuJQ+9JRffddfB3Sre8bnvKNfrvK+679bFxLjKRojQ6tvPTMkQ5RRX2eUt7/NiOt953yhZqp5H7XJ14iSQVuuzn5q690h3+vBK7cSpnLE87/bW8+xzd9Vk8d46Xx2zb4VzHH7v990O7XkLjTX76NGs7/dBeP0cFf70TWquciiH/hOINN9ygm2++WRdffLGWLFmiZ599Vu3t7frZz342ZNdYvXq1Ojo6+n927do1ZOcGAAAAAAAAcGLD/gvudXV1Ov/887V169bg8aamJu3du9fat3fv3gH/BmOhUFAhEGUFAAAAAAAAMLyG5W8oHq+rq0vbtm1Tc3Nz8PiiRYv03HPPWfvWr1+vRYsWDXfRAAAAAAAAAJykIQ8ofutb39KGDRu0Y8cOvfzyy7rpppuUy+W0fPlySdJtt92m1atX96e/++679ctf/lLf+9739N577+mBBx7Q66+/rpUrVw510QAAAAAAAACcpiH/lefdu3dr+fLlOnDggKZPn64/+qM/0iuvvKLp0/v+wGdra6vi4/745Oc+9zk9/vjjuu+++/Ttb39bc+fO1VNPPaWLLrpoqIsGAAAAAAAA4DQNeUDxiSeeGPD4Cy+84O27+eabdfPNNw91UQAAAAAAAAAMsWH/G4oAAAAAAAAAzhwEFAEAAAAAAABkRkARAAAAAAAAQGYEFAEAAAAAAABkRkARAAAAAAAAQGYEFAEAAAAAAABkli93ATAySor1W02XJEVR7pN9UTmLBAAAAAAAxpiSIv02apAkRbm+sFLC59XGHQKK40QpivW2Punwca7MpQEAAAAAAGNRKcrp7f6AYmWZS4NyIYQMAAAAAAAAIDMCigAAAAAAAAAyI6AIAAAAAAAAIDMCigAAAAAAAAAyI6AIAAAAAAAAIDO+5XmcqDSJlmp730baF0f+72iOeiOaAAAAAAAAyKbSlLTE9MUXomJfTOG/8+cSXxhneNrjRCyjWvVIkiLTF1CMo3KWCAAAAAAAjDWxpDrTF1+QKUmSIpnyFQhlwa88AwAAAAAAAMiMgCIAAAAAAACAzAgoAgAAAAAAAMiMgCIAAAAAAACAzAgoAgAAAAAAAMiMgCIAAAAAAACAzAgoAgAAAAAAAMgsX+4CDKXS/gNSVPHpjsiOl+bmn+fliXbvt7bNxx328aqClyft6LTTFOw0prfo5alot8+r1HhpksOHre38uXPs4ztavTz5mS32jgnV9vb7O/vKaGJFSa7v3xMmSJLiSdOViyuU7LPrIDn4sXedKJeztk2SDJrGy1Py68Wtu6h2srWdtn7g5Ul7jg54neTAQS+PcevbpF6a3Ny59nm2vG8fr6vzyxKoK+sygXryrh05Zev1s8TVVc4O//8FxDlnX2JfJw3US1xtt5ekq8s+XlnpF8YRFfw07jNx+2KwLcSRvSNvD0+mx69L09Njn8Otp0/a+vHSg+32ju07/bI49x0750m6ur08sTNWRJMn2XnOmuZf563N1rbbTkPtp7Tb7hNxocpLk/YGGtHxxz9u98vi9EW3baRHjvgncp6r9wwD55XTTkPjZe4se1wzbtut8KeuxB27nbKE2pxx6ylTf3X6WT5Qlg6nLPkKaztUFre+FWhjXtGc8rr9QfLbbnrEGT8Dz8w9r5snDtS/2+ai5gb7+Pt+PwuOj4Pw2uX7u7w07j2V3t9hH3eexyeZ7OtkuEd3TkictYHkj925msleGi9Pw3Rr2zj9NQq0OeUm2mncdiq//G77d8e9T05kbebraq3t0kcHvCwmLdl5GuyxL9kfyOOWJXCPbvtOjzrjf2j8qbSfdekju2+G5nVv/gop2n3YbctRoP2YHrt8abe95gtd1z2vtxZI/LWMNy4E+pk3tzvjstvnpfC4ZZ1iqj/HlTb9wdp216zumlvy7zHULpP2dnuHu8YI3HPqjKluH48n2X1I8tcUxmlzqbNul6Sc039Da1I55c/NPMvOs2u3l8VvC/ZYaIp2vwvlCY5RTv167bIYGC8d0XZ7XZKG2oq7XnDfnQJtzuvTob7pjt0TnTnvLHsukqS4da99ihnN9vGiX/6ksc7efu0dO09gvXkqBls/SIG+6NRBeshey0tSbuoU+zqBcdgdD43bvgPzSuK2F+eZxTX2nCFJsTOPmLZ99nZp8LbsvTtJSj7YYydx29hv3xv8vNvtNYXbN6Vw/xxMPNd+p9euD7007jq7tKfN2s7Pt99TJcnstu/ZOM/ee/+VlJvkvJ84z9B0HvLyuGNhf7s0kVT6pF0cq0tTlImMt6Y+lfeV4BznvjcExvvEqbvc3HPs41t3eHkit106fcSbfxV473RjElu2e3ncucZ7F5G8OFFUW2OfIzTHOeN77LxLuWvhvhPbfTp/zuxPy5X2SO+7GcL4hCIAAAAAAACAzAgoAgAAAAAAAMiMgCIAAAAAAACAzAgoAgAAAAAAAMiMgCIAAAAAAACAzM6ob3nGiaWK9IdoqiQpquz7lsk08G1dAAAAAAAAJ5Iq0h/ivviCMX3fPJwoGigLzkAEFMeJYpTTa7kZkqS4amqZSwMAAAAAAMaivvjCWZIkY4plLg3KhY+oAQAAAAAAAMiMgCIAAAAAAACAzAgoAgAAAAAAAMiMgCIAAAAAAACAzAgoAgAAAAAAAMiMb3keJypMomvTnZKkqHufJGnDhLkqRjQBAAAAAACQTYVJdG2yQ5Jk0kSS9EI0S8UoV8ZSYaQRTRonYhk1mi5JUpSkffuMkaJylgoAAAAAAIwlx8cXZPriC7nIqFjGMmHk8SvPAAAAAAAAADIjoAgAAAAAAAAgMwKKAAAAAAAAADIjoAgAAAAAAAAgMwKKAAAAAAAAADIjoAgAAAAAAAAgMwKKAAAAAAAAADIjoAgAAAAAAAAgMwKKAAAAAAAAADIjoAgAAAAAAAAgMwKKAAAAAAAAADIjoAgAAAAAAAAgMwKKAAAAAAAAADLLl7sAGBmpIrVGtZKkKD+5b18UlbNIAAAAAABgjEkVqTWukyQZU5IkJSK+MN5ExhhT7kKcrs7OTtXW1mpx/R3Kx5X9+9MjR6x08eRJXt7SnGZrO/eHVjtBb9HLY3p77fPOnGEnqAjEaQ+2B0puSzsO2edtbnTKYl9XkpJ9+63t3JTaQa9T2n/Q3mFS+7qFKi+PKdn1EOUr/BM75/EOJ4m3L6qstLbdZ5arq/PyJO3t1nZcXe0k8K+jvP1M0iNHvSS5msnODvsDvMnHHV6eKJeztt16CvHK6wR208OH/UyRXZY40MbSQPs4Xv6sGd6+pG2fvePS+fb2W+95eeJJE+3rHjrkpXHL67WxyU5dS0o6Op1TDD4huedxz5Gvn+LlMc3TrO10QqWf5rV37B3O/YTKFhUKdtkmTrCv09nlX8ftV8453PbVl6dkn/doj5fG64tu+6myryNJpmifN3LaWJQPtDmnH4XavztW5OrrrO0kMDbG1fYY5N6zUn/a8tq/UwfBMcsRGqNiZ4xy79EEyuJeO+e200CfyU+dam2XDhywzxEaC532firy06d6+0r7PrJ3ZGg/3tid4Z7dNNGEai+NUrsujTMnp12BfuU8x/zZs+08H+7xL+O0/yxjrNc2Am3B7UduPeVntHh5Sh+2Wds5Z8yNQvN8t31ed56U/PHF5Y7tkpQesuvXHZOS7sB85cjPmWVtl97f4V/7sxfY19m6yy+LM96443BoDnSfkZzyu89DkvIN0+0dofFysj2+Rx99bB93xyz5c4A7lrjtVJJKO516GGRsl6T8tHr7uoFnFMV2PnceyTL/ev3BXdvInze8ZxjoZ/GUOmvbXedKft3lau0+kXT467V4gv3M3DV2snO3l8ebg536D7Y5Zw2d9vjrTbddeucJPNfQmGQVLbT2dc4TmqPducdb0wXmfnccHnTO1uBtIVj+DO3dHR9Nj7MmCq2j3PWO094jp61Iflt13wlytTVeHm8cDpQ/qnTWJokz54XWJc49u9dxn2lQrb8OL22334Hd5xp6j07222sV970unmG/Z0tSsn2nte3OncE1tvu+FVp7uTKsA6OJ9rjlPle3DiT/Pc0dWxRo/247dOtJkqIme+5JWz8Y+Dry14puPYWu44737tgSu3OgJNPujKluu1Wg7gYZs/oK6MxFzniZn3uulyV15sUsbcEd+0J16Y4duan2XGoO++uFyHnX88abQFsofWQ/s1A9BcfD4y8ze6a3L/3AXju65wid0419HB/jKplePX/kp+ro6FBNjT++HY9feQYAAAAAAACQGQFFAAAAAAAAAJkRUAQAAAAAAACQGQFFAAAAAAAAAJkRUAQAAAAAAACQWYav38GZoMKUdFXPDklSYrolSRvVomLkf/sZAAAAAABASIUp6arevm/tTk3ftyATXxh/CCiOE7GMZpU+lvRph38talZxoEwAAAAAAADHiWU0O2mXJKXmqCTiC+MRv/IMAAAAAAAAIDMCigAAAAAAAAAyI6AIAAAAAAAAILMhDyiuWbNGV1xxhSZPnqyGhgYtW7ZMmzdvHjDP2rVrFUWR9VNVVTXURQMAAAAAAABwmoY8oLhhwwatWLFCr7zyitavX69isajrr79e3d3dA+arqanRnj17+n927tw51EUDAAAAAAAAcJqG/Fuef/nLX1rba9euVUNDg9544w1dffXVJ8wXRZGampqGujgAAAAAAAAAhtCw/w3Fjo4OSVJ9ff2A6bq6ujR79mzNnDlTX/7yl/Xuu++eMG1PT486OzutHwAAAAAAAADDb1gDimma6p577tHnP/95XXTRRSdMN2/ePP3rv/6rnn76af37v/+70jTV5z73Oe3evTuYfs2aNaqtre3/mTlz5nDdAgAAAAAAAIDjDGtAccWKFdq0aZOeeOKJAdMtWrRIt912my699FJdc801+vnPf67p06frn//5n4PpV69erY6Ojv6fXbt2DUfxAQAAAAAAADiG/G8oHrNy5Uo988wzevHFF3XWWWedVN6Kigp99rOf1datW4PHC4WCCoXCUBQTAAAAAAAAwEkY8k8oGmO0cuVKPfnkk3r++ec1Z86ckz5HkiR655131NzcPNTFAwAAAAAAAHAahvwTiitWrNDjjz+up59+WpMnT1ZbW5skqba2VtXV1ZKk2267TTNmzNCaNWskSX/3d3+nq666Suedd57a29v18MMPa+fOnfrTP/3ToS4eAAAAAAAAgNMw5AHFH/3oR5Kka6+91tr/4x//WF//+tclSa2trYrjTz8c+fHHH+uuu+5SW1ubpkyZossuu0wvv/yyLrjggqEuHgAAAAAAAIDTMOQBRWPMoGleeOEFa/v73/++vv/97w91UXCcVJH25ib3/TvqC+YmispZJAAAAAAAMMakirQ3PhZfyEkivjAeDduXsmB0KUZ5/U/1fElSqftgmUsDAAAAAADGomKU1/qq8yVJyZGOMpcG5TLkX8oCAAAAAAAA4MxFQBEAAAAAAABAZgQUAQAAAAAAAGRGQBEAAAAAAABAZgQUAQAAAAAAAGTGtzyPExUm0aW9uyVJiTkkSfqNGlX85CveAQAAAAAABlNhEn22+IEkKTHdkogvjEcEFMeJWKnOL+6TJKXmiCTp7ahBxXIWCgAAAAAAjCmxUp1f+kiSlJqjkogvjEdnVEDRFHtlok+3o5wdHU8OfOzliT9ut7ajyZPtc0aRPM55zb79TkGMlyXpPuykSb00bnnTvfvs7aM9Xp58/RRru/SRXZZj50xNSSbt6+hxbY0kKVfbonxcodLOXYOWLZ4wwU7S6w8VJrXvO6pwmleS+Hl6e4Pl7c/S0emXpVA1YNkU+88sdeo/dssmKe3q8vYNVDZJMoF7sjP5f1UgPXJkwDS5ujr/PKWSvV1Z4SXJaaK9o2jnMe0dfvHce3pni13WwP25z9Wrf0nGKa97z+bIUS+PK3b74uHDXpq0q9vOU223jdLBQJ8/dMjeMdgzlJRvanBO4j9X496jc960x7/nuLLS2o4q7Oca5f12anr8ccCVc+rOHZPcftd3bfta7ngTV/v9ypSccSDQ3r0+4oypUaC/RlPrre1kx077eKAv5iba7TBx+rNXVvn1bwJNIQ3UlZ1p8LE8qipY26H/b2uc8+SnT7PLERgLvboL1b9z325/TQ4c9M/rlt+t79Sf4+LqaufCznwQGj+dccI487EkyekD8awZ9nm3+/0hcp5ryWk/+eYmL0/a5sy3gz13+XNesI05Y5J33cAY5bap1B37AmOhW/9uHUhS6oy73prDGU8leeOjVy+h9p+3x7HS9lb/vA7jzD2hedxt7+49xoHx0m2H7riWc9ZQklT66IB93kBdxok9RpX2feQWNlAWu65ykyY5F3bmefn3bNJ4wOOSpLpaezswdiSDrL2Ut8csyW+H7nM2Rb/87tzv3nM01a//ZPeHA15H8uerpNOe13O1Th3IXwemu/dY26G+6s637nwWahtu2w2NN951nPbjjaeSTDrIuBCQq6+xzxF4j3DLG7nr/cB1Blv7htYYXltwnpH7DKXwvOFKnHHLzWN6nTV3QJZ7jmrtuhx0nNan71v9ZQ2M924fjpsb7TxOf5CkqGC3O7dflQ7YY5jkvztFoXc9pw+49xRaf3rvAM6YW9r6vpfH7dPeh9kCZXPHVFMafE3tjmPBZ+Rsu+t9E5gX3fp2x740MBbK7RPuu6CknBtzcNYYoXca7xzOnBbq8/npdvnTQ/Z6ufSBPTZKUq7GeSf75LzGFPvXcsf6XpSvVBzlZS6Za+f59buDlt8d+9LWD7w0kZMmLgTGYfe9x6mHUFt2xzV3fRxd+hk/z++2+de2TuKPlW5dBuMjgfZxvDQwLrjrZTlr0tB4mnTYsYHQ3JMFf0MRAAAAAAAAQGYEFAEAAAAAAABkRkARAAAAAAAAQGYEFAEAAAAAAABkRkARAAAAAAAAQGYEFAEAAAAAAABkRkARAAAAAAAAQGYEFAEAAAAAAABkRkARAAAAAAAAQGYEFAEAAAAAAABkRkARAAAAAAAAQGYEFAEAAAAAAABkli93ATAyUkntUUGSFOeqJUlGURlLBAAAAAAAxhqjSB1RVd9GZD7Zh/GGgOI40Rvl9YtoriQpV9NS5tIAAAAAAICxqDfK6xcV8/s2krS8hUHZ8CvPAAAAAAAAADIjoAgAAAAAAAAgMwKKAAAAAAAAADIjoAgAAAAAAAAgMwKKAAAAAAAAADLjW57HibxJdIE5IEmKjySSpN9XtagU5cpZLAAAAAAAMIbkTaIL0o/6Nj75luffxdOJL4wzBBTHibyMLjH7JEnR0SOSpD8UmujwAAAAAAAgs5xSXZy09W2kRpK0OZ6mUhnLhJHHrzwDAAAAAAAAyIyAIgAAAAAAAIDMCCgCAAAAAAAAyIyAIgAAAAAAAIDMCCgCAAAAAAAAyIyAIgAAAAAAAIDMCCgCAAAAAAAAyCwyxphyF+J0dXZ2qra2VtdGNykfVXx6wKSDZ46cmGqWPKNIlMtZ2yZJgumqTEk3a7O1b53m6WiU9+sg5FTqZTTX7XDd86lc27mO+0ylwHMtZ/lHkazt//QvVKa2HHrO4+C5jinj4RmdSvsfzeP/EBmx8aecxsFzHBJZ6mk46nK4xp8zcVyjLQ+f0VS3p9IXszjT3oNGs1Mdf8ZQfWd61yuXk6h/O74QSZLWRfP74gtDUP9RvsLbZ0rF0z7vUCnbOnAE5uiSKeoFPa2Ojg7V1NQMmJZPKAIAAAAAAADIjIAiAAAAAAAAgMwIKAIAAAAAAADIjIAiAAAAAAAAgMwIKAIAAAAAAADILF/uAmBkGEk9zuMe81/vDQAAAAAARpQVX4ii/n0YXwgojhM9UV4/07xyFwMAAAAAAIxhVnwh4hdfxyuePAAAAAAAAIDMCCgCAAAAAAAAyIyAIgAAAAAAAIDMCCgCAAAAAAAAyIyAIgAAAAAAAIDM+JbncSJnUp2ndmvfVtUp4RuZAAAAAABARnZ8IZIkbdUU4gvjDAHFcaJCqa7UHmvfTtUo4UOqAAAAAAAgIyu+YPoCijujWuIL4wxPGwAAAAAAAEBmBBQBAAAAAAAAZEZAEQAAAAAAAEBmBBQBAAAAAAAAZEZAEQAAAAAAAEBmBBQBAAAAAAAAZEZAEQAAAAAAAEBmBBQBAAAAAAAAZEZAEQAAAAAAAEBmBBQBAAAAAAAAZEZAEQAAAAAAAEBmwxZQfPTRR3X22WerqqpKCxcu1GuvvTZg+nXr1mn+/PmqqqrSggUL9Oyzzw5X0QAAAAAAAACcomEJKP70pz/VqlWrdP/99+vNN9/UJZdcoiVLlmjfvn3B9C+//LKWL1+uO++8U7/5zW+0bNkyLVu2TJs2bRqO4gEAAAAAAAA4RZExxgz1SRcuXKgrrrhCjzzyiCQpTVPNnDlT3/jGN/S3f/u3XvpbbrlF3d3deuaZZ/r3XXXVVbr00kv12GOPeel7enrU09PTv93R0aFZs2bpj/S/lY8qPk1o0sELGzkx1Sx5RpEol7O2TZIE0xVU0k3aYu17UnPVo7xfByGnUi+juW6H655P5drOddxnKgWeaznLP4pkbf+nf6EyteXQcx4Hz3VMGQ/P6FTa/2ge/4fIiI0/5TQOnuOQyFJPw1GXwzX+nInjGm15+Iymuj2VvpjFmfYeNJqd6vgzhuo707teuZxE/dvxhUiS9KTOV0+UH5L6j/IV3j5TKp72eYdK2daBIzBHl1TUS3pW7e3tqq2tHTBtfkivLKm3t1dvvPGGVq9e3b8vjmMtXrxYGzduDObZuHGjVq1aZe1bsmSJnnrqqWD6NWvW6MEHH/T2v6RnpJMNjw55OHWEnUS7/W9vzx/6/jNcdTCa67acZRvs2lme6Wiu25E0UnNvueqb5zz6jYdndCr3OB7qZZSs/YfVeHiOQyFLPQ1HXY7H9dupOhPvabQYTXVbrr5YzuucaU613sZSfY/m9cNJ1qMfX9g8dM+iNETnGS7leo4j2NYPHTo08gHF/fv3K0kSNTY2WvsbGxv13nvvBfO0tbUF07e1tQXTr1692gpAtre3a/bs2WptbR30hgGcus7OTs2cOVO7du1STU1NuYsDnJHoZ8Dwo58BI4O+Bgw/+hmGkjFGhw4dUktLy6BphzygOBIKhYIKhYK3v7a2lg4EjICamhr6GjDM6GfA8KOfASODvgYMP/oZhkrWD+oN+ZeyTJs2TblcTnv37rX27927V01NTcE8TU1NJ5UeAAAAAAAAQHkMeUCxsrJSl112mZ577rn+fWma6rnnntOiRYuCeRYtWmSll6T169efMD0AAAAAAACA8hiWX3letWqVbr/9dl1++eW68sor9YMf/EDd3d264447JEm33XabZsyYoTVr1kiS7r77bl1zzTX63ve+pxtvvFFPPPGEXn/9df3Lv/xLpusVCgXdf//9wV+DBjB06GvA8KOfAcOPfgaMDPoaMPzoZyiXyBgzLN8T88gjj+jhhx9WW1ubLr30Uv3whz/UwoULJUnXXnutzj77bK1du7Y//bp163Tfffdpx44dmjt3rh566CF98YtfHI6iAQAAAAAAADhFwxZQBAAAAAAAAHDmGfK/oQgAAAAAAADgzEVAEQAAAAAAAEBmBBQBAAAAAAAAZEZAEQAAAAAAAEBmZ0RA8dFHH9XZZ5+tqqoqLVy4UK+99lq5iwSMWQ888ICiKLJ+5s+f33/86NGjWrFihaZOnapJkybpq1/9qvbu3VvGEgOj34svvqgvfelLamlpURRFeuqpp6zjxhh997vfVXNzs6qrq7V48WJt2bLFSnPw4EHdeuutqqmpUV1dne688051dXWN4F0Ao99gfe3rX/+6N8ctXbrUSkNfAwa2Zs0aXXHFFZo8ebIaGhq0bNkybd682UqTZb3Y2tqqG2+8URMmTFBDQ4PuvfdelUqlkbwVYNTK0s+uvfZab0778z//cysN/QzDacwHFH/6059q1apVuv/++/Xmm2/qkksu0ZIlS7Rv375yFw0Ysy688ELt2bOn/+ell17qP/bNb35Tv/jFL7Ru3Tpt2LBBH374ob7yla+UsbTA6Nfd3a1LLrlEjz76aPD4Qw89pB/+8Id67LHH9Oqrr2rixIlasmSJjh492p/m1ltv1bvvvqv169frmWee0Ysvvqg/+7M/G6lbAMaEwfqaJC1dutSa437yk59Yx+lrwMA2bNigFStW6JVXXtH69etVLBZ1/fXXq7u7uz/NYOvFJEl04403qre3Vy+//LL+7d/+TWvXrtV3v/vdctwSMOpk6WeSdNddd1lz2kMPPdR/jH6GYWfGuCuvvNKsWLGifztJEtPS0mLWrFlTxlIBY9f9999vLrnkkuCx9vZ2U1FRYdatW9e/7/e//72RZDZu3DhCJQTGNknmySef7N9O09Q0NTWZhx9+uH9fe3u7KRQK5ic/+Ykxxpjf/e53RpL59a9/3Z/mv/7rv0wUReaDDz4YsbIDY4nb14wx5vbbbzdf/vKXT5iHvgacvH379hlJZsOGDcaYbOvFZ5991sRxbNra2vrT/OhHPzI1NTWmp6dnZG8AGAPcfmaMMddcc425++67T5iHfobhNqY/odjb26s33nhDixcv7t8Xx7EWL16sjRs3lrFkwNi2ZcsWtbS06JxzztGtt96q1tZWSdIbb7yhYrFo9bn58+dr1qxZ9DngFG3fvl1tbW1Wv6qtrdXChQv7+9XGjRtVV1enyy+/vD/N4sWLFcexXn311REvMzCWvfDCC2poaNC8efP0F3/xFzpw4ED/MfoacPI6OjokSfX19ZKyrRc3btyoBQsWqLGxsT/NkiVL1NnZqXfffXcESw+MDW4/O+Y//uM/NG3aNF100UVavXq1Dh8+3H+Mfobhli93AU7H/v37lSSJ1UEkqbGxUe+9916ZSgWMbQsXLtTatWs1b9487dmzRw8++KC+8IUvaNOmTWpra1NlZaXq6uqsPI2NjWpraytPgYEx7ljfCc1lx461tbWpoaHBOp7P51VfX0/fA07C0qVL9ZWvfEVz5szRtm3b9O1vf1s33HCDNm7cqFwuR18DTlKaprrnnnv0+c9/XhdddJEkZVovtrW1Bee9Y8cAfCrUzyTpj//4jzV79my1tLTo7bff1t/8zd9o8+bN+vnPfy6JfobhN6YDigCG3g033ND/74svvlgLFy7U7Nmz9bOf/UzV1dVlLBkAAKfna1/7Wv+/FyxYoIsvvljnnnuuXnjhBV133XVlLBkwNq1YsUKbNm2y/t42gKF1on52/N/3XbBggZqbm3Xddddp27ZtOvfcc0e6mBiHxvSvPE+bNk25XM77xrC9e/eqqampTKUCzix1dXU6//zztXXrVjU1Nam3t1ft7e1WGvoccOqO9Z2B5rKmpibvy8ZKpZIOHjxI3wNOwznnnKNp06Zp69atkuhrwMlYuXKlnnnmGf3qV7/SWWed1b8/y3qxqakpOO8dOwagz4n6WcjChQslyZrT6GcYTmM6oFhZWanLLrtMzz33XP++NE313HPPadGiRWUsGXDm6Orq0rZt29Tc3KzLLrtMFRUVVp/bvHmzWltb6XPAKZozZ46ampqsftXZ2alXX321v18tWrRI7e3teuONN/rTPP/880rTtH/xCODk7d69WwcOHFBzc7Mk+hqQhTFGK1eu1JNPPqnnn39ec+bMsY5nWS8uWrRI77zzjhXAX79+vWpqanTBBReMzI0Ao9hg/SzkrbfekiRrTqOfYTiN+V95XrVqlW6//XZdfvnluvLKK/WDH/xA3d3duuOOO8pdNGBM+ta3vqUvfelLmj17tj788EPdf//9yuVyWr58uWpra3XnnXdq1apVqq+vV01Njb7xjW9o0aJFuuqqq8pddGDU6urq6v+/xVLfF7G89dZbqq+v16xZs3TPPffoH/7hHzR37lzNmTNH3/nOd9TS0qJly5ZJkj7zmc9o6dKluuuuu/TYY4+pWCxq5cqV+trXvqaWlpYy3RUw+gzU1+rr6/Xggw/qq1/9qpqamrRt2zb99V//tc477zwtWbJEEn0NyGLFihV6/PHH9fTTT2vy5Mn9f4uttrZW1dXVmdaL119/vS644AL9yZ/8iR566CG1tbXpvvvu04oVK1QoFMp5e8CoMFg/27Ztmx5//HF98Ytf1NSpU/X222/rm9/8pq6++mpdfPHFkuhnGAHl/prpofBP//RPZtasWaaystJceeWV5pVXXil3kYAx65ZbbjHNzc2msrLSzJgxw9xyyy1m69at/cePHDli/vIv/9JMmTLFTJgwwdx0001mz549ZSwxMPr96le/MpK8n9tvv90YY0yapuY73/mOaWxsNIVCwVx33XVm8+bN1jkOHDhgli9fbiZNmmRqamrMHXfcYQ4dOlSGuwFGr4H62uHDh831119vpk+fbioqKszs2bPNXXfdZdra2qxz0NeAgYX6mCTz4x//uD9NlvXijh07zA033GCqq6vNtGnTzF/91V+ZYrE4wncDjE6D9bPW1lZz9dVXm/r6elMoFMx5551n7r33XtPR0WGdh36G4RQZY8xIBjABAAAAAAAAjF1j+m8oAgAAAAAAABhZBBQBAAAAAAAAZEZAEQAAAAAAAEBmBBQBAAAAAAAAZEZAEQAAAAAAAEBmBBQBAAAAAAAAZEZAEQAAAAAAAEBmBBQBAAAAAAAAZEZAEQAAAAAAAEBmBBQBAAAAAAAAZEZAEQAAAAAAAEBm/x+nmRB/XGK2jAAAAABJRU5ErkJggg==\n"
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "execution_count": 229
  },
  {
   "cell_type": "markdown",
   "source": [
    "# Other stuff"
   ],
   "metadata": {
    "collapsed": false
   },
   "id": "698541de514af309"
  },
  {
   "cell_type": "markdown",
   "source": [
    "## For Kaggle \\ Colab"
   ],
   "metadata": {
    "collapsed": false
   },
   "id": "b90baecc2402ec10"
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "# Free space in Kaggle\n",
    "import os\n",
    "\n",
    "for the_file in os.listdir('/kaggle/working/faster_rnn_outputs'):\n",
    "    if the_file != 'epoch_50_model.pth' and the_file != 'loss_dict.pkl':\n",
    "        os.unlink(os.path.join('/kaggle/working/faster_rnn_outputs', the_file))"
   ],
   "metadata": {
    "collapsed": false
   },
   "id": "ae20e115c25e725"
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "# Move files from input to output in Kaggle\n",
    "import shutil\n",
    "\n",
    "src_path = r\"/kaggle/input/faster-rnn-epoch-50/epoch_50_model.pth\"\n",
    "dst_path = r\"/kaggle/working/faster_rnn_outputs/\"\n",
    "\n",
    "shutil.copy(src_path, dst_path)\n",
    "print('Copied')"
   ],
   "metadata": {
    "collapsed": false
   },
   "id": "bb13f732a9fb4c82"
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "outputs": [],
   "source": [
    "# Mount google drive in Colab\n",
    "from google.colab import drive\n",
    "\n",
    "drive.mount('/content/drive')"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2024-03-29T21:34:43.177849800Z",
     "start_time": "2024-03-29T21:34:42.909033600Z"
    }
   },
   "id": "2518f9aee3cf0922"
  }
 ]
}