ECG_MIT_1D_dataprocessing_125Hz.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "35289461-5c34-40d3-b74d-21d2f38f9cb3",
   "metadata": {},
   "source": [
    "# 0. Data Preprocessing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "e2090790-bc82-46ef-a4c7-c244c25f2fba",
   "metadata": {},
   "outputs": [],
   "source": [
    "# !pip install wfdb\n",
    "\n",
    "# Handle data path\n",
    "from pathlib import Path\n",
    "\n",
    "# Read and display data from Physionet\n",
    "import wfdb\n",
    "import pprint\n",
    "import collections\n",
    "from IPython.display import clear_output\n",
    "\n",
    "# Data manipulation and plotting\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "from scipy.signal import resample\n",
    "from scipy.signal import butter,filtfilt\n",
    "\n",
    "# Divide data into train and test set and save to HDF5\n",
    "import h5py\n",
    "import os\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn import preprocessing\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "c9cd08a1-44e5-4900-a1fd-923fc2af527a",
   "metadata": {},
   "outputs": [],
   "source": [
    "raw_data_path = Path('./data/mit-bih-arrhythmia-database-1.0.0')\n",
    "# main directory that store data\n",
    "data_dir = Path('./data')\n",
    "os.makedirs(data_dir, exist_ok=True)\n",
    "\n",
    "# directory that store original MIT-BIH data\n",
    "\n",
    "mit_arrh_dir = raw_data_path\n",
    "os.makedirs(mit_arrh_dir, exist_ok=True)\n",
    "\n",
    "# directory that store processed data\n",
    "process_dir = data_dir / 'processed_data'\n",
    "temp_dir = process_dir / 'temp'\n",
    "os.makedirs(process_dir, exist_ok=True)\n",
    "\n",
    "raw_data_dir = process_dir\n",
    "os.makedirs(raw_data_dir, exist_ok=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "38ac0035-9a45-4e2c-ac2e-ac7c85aed4d0",
   "metadata": {},
   "outputs": [],
   "source": [
    "def translate_beat_type(beat_type_arr, peak_loc_arr):\n",
    "    n_type = ['N', 'L', 'R', 'e', 'j']\n",
    "    s_type = ['A', 'a', 'J', 'S']\n",
    "    v_type = ['V', 'E']\n",
    "    f_type = ['F']\n",
    "    q_type = ['/', 'f', 'Q']\n",
    "    \n",
    "    not_used = ['B', 'r', 'n', '?']\n",
    "    \n",
    "    encoded_label = []\n",
    "    peak_loc_label = []\n",
    "    ignored_label = []\n",
    "    \n",
    "    for beat_type, peak_loc in zip(beat_type_arr, peak_loc_arr):\n",
    "        if beat_type in n_type:\n",
    "            encoded_label.append(0)\n",
    "        elif beat_type in s_type:\n",
    "            encoded_label.append(1)\n",
    "        elif beat_type in v_type:\n",
    "            encoded_label.append(2)\n",
    "        elif beat_type in f_type:\n",
    "            encoded_label.append(3)\n",
    "        elif beat_type in q_type:\n",
    "            encoded_label.append(4)\n",
    "        else:\n",
    "            ignored_label.append(beat_type)\n",
    "            continue\n",
    "        peak_loc_label.append(peak_loc)\n",
    "        \n",
    "        \n",
    "            \n",
    "    encoded_label = np.array(encoded_label)\n",
    "    peak_loc_label = np.array(peak_loc_label)\n",
    "\n",
    "    return encoded_label, peak_loc_label, ignored_label\n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "69cc0d70-9057-4d6c-a2c2-f47674b7dc84",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Progress: [##################################################] 100.0%\n"
     ]
    }
   ],
   "source": [
    "## Noted: This part of data is done incorrectly. The dataset should be split in train and test using records as follow instead of random split. The reason for this is from the paper:\n",
    "## How the Choice of Samples for Building Arrhythmia Classifiers ImpactTheir Performances\n",
    "## Train dataset record number: 101, 106, 108, 109, 112, 114, 115,116, 118, 119, 122, 124, 201, 203, 205, 207, 208, 209, 215,220, 223, and 230,\n",
    "## Test dataset record number: 100, 103, 105, 11, 113, 117, 121, 123, 200, 202, 210, 212, 213,214, 219, 221, 222, 228, 231, 232, and 234\n",
    "## read data and annotation\n",
    "\n",
    "file = open(mit_arrh_dir/'RECORDS')\n",
    "record_list = file.read().splitlines()\n",
    "file.close()\n",
    "# progress bar to check if the program running\n",
    "def update_progress(progress):\n",
    "    bar_length = 50\n",
    "    if isinstance(progress, int):\n",
    "        progress = float(progress)\n",
    "    if not isinstance(progress, float):\n",
    "        progress = 0\n",
    "    if progress < 0:\n",
    "        progress = 0\n",
    "    if progress >= 1:\n",
    "        progress = 1\n",
    "        \n",
    "    block = int(round(bar_length * progress))\n",
    "\n",
    "    clear_output(wait = True)\n",
    "    text = \"Progress: [{0}] {1:.1f}%\".format( \"#\" * block + \"-\" * (bar_length - block), progress * 100)\n",
    "    print(text)\n",
    "    \n",
    "bad_labels = []\n",
    "with h5py.File(raw_data_dir / 'mit_raw_data.h5', 'w') as file:\n",
    "    for i in range(len(record_list)):\n",
    "        summary = wfdb.rdrecord(str(mit_arrh_dir / record_list[i])).__dict__\n",
    "        \n",
    "        ## only get the second signal which is ii - chest ECG\n",
    "        anno = wfdb.rdann(str(mit_arrh_dir / record_list[i]), extension='atr', summarize_labels=True).__dict__\n",
    "        peaks = anno['sample']\n",
    "        labels = anno['symbol']\n",
    "        encoded_labels, peak_labels, ignored_label = translate_beat_type(labels, peaks)\n",
    "        bad_labels += ignored_label\n",
    "        \n",
    "        file.create_dataset('data/{:03d}'.format(i), data=summary['p_signal'][:, 0])\n",
    "        file.create_dataset('peak/{:03d}'.format(i), data=peak_labels)\n",
    "        file.create_dataset('label/{:03d}'.format(i), data=encoded_labels)\n",
    "        \n",
    "        update_progress((i+1) / float(len(record_list)))\n",
    "        \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "d49e5cb5-6ff0-4eba-922e-8dbe8d1c91f6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0 1 2 3 4]\n",
      "Counter({0: 90631, 4: 8043, 2: 7236, 1: 2781, 3: 803})\n",
      "109494\n",
      "109494\n",
      "109494\n"
     ]
    }
   ],
   "source": [
    "import collections\n",
    "\n",
    "def check_data_group(file):\n",
    "    data_group = file['data']\n",
    "    total = len(data_group.keys())\n",
    "    index = 0\n",
    "    total = []\n",
    "    peaks = []\n",
    "    for key in data_group.keys():\n",
    "        temp_data = list(file['label/{}'.format(key)])\n",
    "        total += temp_data\n",
    "        temp_data = list(file['peak/{}'.format(key)])\n",
    "        peaks += temp_data\n",
    "    \n",
    "    print(np.unique(total))\n",
    "    print(collections.Counter(total))\n",
    "    print(len(total) - collections.Counter(total)[5])\n",
    "    print(len(peaks))\n",
    "    print(len(total))\n",
    "\n",
    "with h5py.File(raw_data_dir / 'mit_raw_data.h5', 'r') as file:\n",
    "    check_data_group(file)\n",
    "    \n",
    "        \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "5fd3d5ed-163b-435c-9906-80d5e641a234",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Progress: [##################################################] 100.0%\n"
     ]
    }
   ],
   "source": [
    "def butter_highpass_filter(data, cutoff, fs, order):\n",
    "    nyq = 0.5 * fs\n",
    "    normal_cutoff = cutoff / nyq\n",
    "    # Get the filter coefficients \n",
    "    b, a = butter(order, normal_cutoff, btype='high', analog=False)\n",
    "    y = filtfilt(b, a, data)\n",
    "    return y\n",
    "\n",
    "# progress bar to check if the program running\n",
    "def update_progress(progress):\n",
    "    bar_length = 50\n",
    "    if isinstance(progress, int):\n",
    "        progress = float(progress)\n",
    "    if not isinstance(progress, float):\n",
    "        progress = 0\n",
    "    if progress < 0:\n",
    "        progress = 0\n",
    "    if progress >= 1:\n",
    "        progress = 1\n",
    "        \n",
    "    block = int(round(bar_length * progress))\n",
    "\n",
    "    clear_output(wait = True)\n",
    "    text = \"Progress: [{0}] {1:.1f}%\".format( \"#\" * block + \"-\" * (bar_length - block), progress * 100)\n",
    "    print(text)\n",
    "\n",
    "filtered_ecg_data = []\n",
    "ecg_peak_annotations = []\n",
    "\n",
    "with h5py.File(raw_data_dir / 'mit_raw_data.h5', 'r') as file:\n",
    "    ## only get the second signal which is ii - chest ECG\n",
    "    data_group = file['data']\n",
    "    total = len(data_group.keys())\n",
    "    index = 0\n",
    "    for key in data_group.keys():\n",
    "        temp_data = file['data/{}'.format(key)]\n",
    "        filter_data = butter_highpass_filter(temp_data, 0.25, 360, 2)\n",
    "        filtered_ecg_data.append(filter_data)\n",
    "        temp_peak = file['peak/{}'.format(key)][:]\n",
    "        ecg_peak_annotations.append(temp_peak)\n",
    "        update_progress((index+1) / float(total))\n",
    "        index += 1\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "bdee631e-ceba-407b-b195-d79b123c876a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Progress: [##################################################] 100.0%\n"
     ]
    }
   ],
   "source": [
    "def normalize(arr):\n",
    "    arr_range = np.ptp(arr)\n",
    "    arr_min = np.min(arr)\n",
    "    norm_arr = (arr - arr_min) / float(arr_range)\n",
    "    return norm_arr\n",
    "\n",
    "ecg_data_norm = []\n",
    "for i in range(len(filtered_ecg_data)):\n",
    "    signal = normalize(filtered_ecg_data[i])\n",
    "    ecg_data_norm.append(signal)\n",
    "    update_progress( (i + 1) / float(len(filtered_ecg_data)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "3a51e7bf-0e8b-4d53-90c5-f860b09e1f2b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Progress: [##################################################] 100.0%\n"
     ]
    }
   ],
   "source": [
    "## resample signal from 360 Hz to 125 Hz\n",
    "def ecg_resample(data, input_freq, output_freq):\n",
    "    data_len = len(data)\n",
    "    resample_data_len = int(data_len / float(input_freq) * float(output_freq))\n",
    "    resample_data = resample(data, resample_data_len)\n",
    "    \n",
    "    return resample_data\n",
    "\n",
    "ecg_data_resample = []\n",
    "for i in range(len(ecg_data_norm)):\n",
    "    signal = ecg_resample(filtered_ecg_data[i], 360, 125)\n",
    "    ecg_data_resample.append(signal)\n",
    "    update_progress( (i + 1) / float(len(filtered_ecg_data)))\n",
    "    \n",
    "ecg_peak_loc_resample = []\n",
    "for i in range(len(ecg_peak_annotations)):\n",
    "    loc_resample = [int(x / float(360/125.)) for x in ecg_peak_annotations[i]]\n",
    "    loc_resample = np.array(loc_resample)\n",
    "    ecg_peak_loc_resample.append(loc_resample)\n",
    "    update_progress((i+1)/float(len(ecg_peak_annotations)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "857c7090-ff2b-4425-8c86-08fef06aef63",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "48 48\n"
     ]
    }
   ],
   "source": [
    "print(len(ecg_data_resample), len(ecg_peak_loc_resample))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "2f5401f7-9775-46f4-afcf-48072fad2592",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Progress: [##################################################] 100.0%\n"
     ]
    }
   ],
   "source": [
    "def find_local_peak_location(beat_locs, ecg_sample, sample_freq):\n",
    "    interval = 10 * sample_freq\n",
    "    max_length = len(ecg_sample)\n",
    "    correct_locs = []\n",
    "    try:\n",
    "        for i in range(len(beat_locs)):\n",
    "            start_base_line = beat_locs[i] - interval / 2\n",
    "            stop_base_line = beat_locs[i] + interval / 2\n",
    "            \n",
    "            # left end of data\n",
    "            if start_base_line < 0 :\n",
    "                stop_base_line += abs(start_base_line)\n",
    "                start_base_line = 0\n",
    "\n",
    "            # right end of data\n",
    "            if stop_base_line >= max_length :\n",
    "                start_base_line -= abs(stop_base_line - max_length)\n",
    "                stop_base_line = max_length\n",
    "\n",
    "            # local mean base line\n",
    "            base_line = np.mean(ecg_sample[int(start_base_line):int(stop_base_line)])\n",
    "            \n",
    "            local_sample = None\n",
    "            \n",
    "            # left end of data\n",
    "            if beat_locs[i] - 2 < 0:\n",
    "                local_sample = ecg_sample[beat_locs[i] : beat_locs[i] + 5]\n",
    "            \n",
    "            # right end of data\n",
    "            elif beat_locs[i] + 3 > max_length:\n",
    "                local_sample = ecg_sample[beat_locs[i] - 5: beat_locs[i]]\n",
    "            \n",
    "            # normal case\n",
    "            else:\n",
    "                local_sample = ecg_sample[beat_locs[i] - 2: beat_locs[i] + 3]\n",
    "                \n",
    "            diff = [abs(x - base_line) for x in local_sample]\n",
    "            max_loc = np.argmax(diff)\n",
    "            new_loc = beat_locs[i] - 2 + max_loc\n",
    "            correct_locs.append(new_loc)\n",
    "    except:\n",
    "        ## error case print stuff\n",
    "        print(beat_locs[i])\n",
    "        print(local_sample)\n",
    "        print(base_line)\n",
    "        print(diff)\n",
    "        print(max_loc)\n",
    "    correct_locs = np.array(correct_locs)\n",
    "    return correct_locs\n",
    "\n",
    "## Apply to the rest of the data\n",
    "ecg_correct_peak_location = []\n",
    "index = 0\n",
    "for data, peak in zip(ecg_data_resample, ecg_peak_loc_resample):\n",
    "    corrected_loc = find_local_peak_location(peak, data, 125)\n",
    "    ecg_correct_peak_location.append(corrected_loc)\n",
    "    index += 1\n",
    "    update_progress((index)/ float(len(ecg_data_resample)))\n",
    "\n",
    "# with h5py.File(raw_data_dir / 'mit_raw_data.h5', 'r') as file:\n",
    "#     ## only get the second signal which is ii - chest ECG\n",
    "#     data_group = file['peak']\n",
    "#     total = len(data_group.keys())\n",
    "#     index = 0\n",
    "#     for key in data_group.keys():\n",
    "#         temp_peak_data = file['peak/{}'.format(key)]\n",
    "#         corrected_loc = find_local_peak_location(temp_peak_data, ecg_data_norm[int(key)], 360)\n",
    "#         ecg_correct_peak_location.append(corrected_loc)\n",
    "#         index += 1\n",
    "#         update_progress((index)/ float(len(ecg_data_norm)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "82cc2e5f-83ed-4b77-964a-cf6d7679f590",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "48\n"
     ]
    }
   ],
   "source": [
    "print(len(ecg_correct_peak_location))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "4bdab7e3-7a52-4e74-837e-d0b965c66fb7",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAY0AAAEWCAYAAACaBstRAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8qNh9FAAAACXBIWXMAAAsTAAALEwEAmpwYAABOwklEQVR4nO2dd3gcxdnAf696sSy527ItV4wxLrhgY6rp2HRCaAZCGoEACZDwUUJI6CQEEggJhARCQksCCQQI3YBpNmCMbQzuvfciW5Ys6eb7Y8vtne6kO+luRj7N73n03N7eat/Z2dl55y0zK0opLBaLxWJJhCzTBbBYLBbLvoNVGhaLxWJJGKs0LBaLxZIwVmlYLBaLJWGs0rBYLBZLwlilYbFYLJaEsUrDkhAiMkFEVpsuR7oRkUdE5Oemy+EhIpNF5M1Gfk/qvojIeyLyvdSUrvUiIstF5DjT5chErNIwiNuw94jIrsDfQ4Hfe4jIYyKyTkQqRWS+iNwqIsXu7yIiV4rIHBGpEpH1bqdwnrmr2ncQkUtE5MPgPqXUZUqp202VKRql1NNKqRO87yKiRGSgyTLFoq0MKixWabQGTlVKtQv8XQkgIh2BaUAhMF4pVQIcD5QBA9z/fRC4GvgJ0AnoCdwMnKT1CvYBRCTHdBks6cfeZw0opeyfoT9gOXBcnN/uAL4EsuL8PgioB8YkIe8G4PmofQ8AD7rb3wbmAZXAUuAHgeMmAKsD3xUwMPD9CeCOwPdTgFnAduBjYHgj5ToU+AzY4X4e6u4/D5gRdew1wEvudj7wG2AlsAF4BCgMlhe4HlgPPBl1ngOAarcOdwHbo68jcI7/AzYC64AzgEnAQmArcFPgnFluHS8BtgD/AjrGueapwDfc7cPd+pzkfj8OmOVuXwJ86G6/7x632y3zuYEy/iRQxm83UtfvAXcDn7r1/d9gGYFD3Pu1HZgNTAj8FrN9AMXAHiDklmsXUB5Ddinwd2ATsAJngJPl3sftwNDAsV3cc3Ztqj3hPEfXA3OAGiCHwLMFjMUZgG136+chIM/97Q/AfVHlfBm42nT/0Fr/jBegLf/RuNKYDtzayP9eBixPUl4foApo737Pdh+iQ9zvJ+NYMQIc5R47yv1tAgkqDWCU24GNc2V8y73W/Bhl6ghsAy5yH/bz3e+dgCK3g9ovcPxnwHnu9u+Al9xzlLgP+92B8tYBv3I7pcIYsi/B7ZDjXId3jluAXOD7OB3eM668A3EUT3/3+Kvd+9bLlfkn4Nk49+I24Pfu9k04iuZXgd8eiFXGGPXulfE2t4yT3PvWIY7c94A1wFCczv7fwFPubz1xlN0knM78ePd7l2TbRxzZf8dRUiVAXxzF+133t8eBOwPHXgG8nkh7crdnAb0JDxqWE1Yao3GUYY4rdx6uUsBRKGtxB2dAZ/e6upnuH1rrn/ECtOU/t2HvwhkBeX/fd39bBFzWyP/eDEyP2rfaPUc10CfO/30IXOxuHw8saUTGi8CP3e2ITiFG5/UE4c72YeD2qHMtAI6KIeMi4NOofdOAS9ztp4Bb3O39cJRIkdtx7QYGBP5vPLAsUN69QEEj13cJTSuNPUC2+73Eve5xgeM/B85wt+cBxwZ+6wHUAjkxZB8LzHG3Xwe+591PHCvkrFhljFHvXhlzAvs24g4EYsh9D7gn8H2IW0/ZOKP1aIvsDeBbybaPGMdm41gBQwL7fgC8524fBywN/PYR4XbaaHvCeY6+E+PZijcguxp4IfB9HnC8u30l8Gq867B/ysY0WgFnKKXKAn9/dvdvwel04tHgd6VUL5yRUj5OpxqLZ3BG8wAXuN8BEJGJIjJdRLaKyHacEWfnZC8Ix6L5iYhs9/5wRoHlMY4tx3FVBFmBM+qNVd4XlVJVOO6LIuDzgIzX3f0em5RS1c0of5AtSql6d3uP+7kh8PseoJ273Qd4IVCeeTjur24xzjsNGCQi3YCDcEbhvUWkM87o9/0ky1gX+F4VKFMsVgW2V+BYKJ3d8n8z6r4djtvOWtg+OgN5RN7r4H1+BygUkXEi0genTl5wf0ukPQWvKQIRGSQir7iJIjuBu6LK/TfgQnf7QuDJBK+pTWKVRuvlbeBMEYl3j94BeonImCTP+xwwQUR6AWfiKg0RycdxVfwGxzQvA14lvvKpwum0PboHtlfhuBqCyrBIKfVsjPOsxekUglTguFAA3gQ6i8hBOMrDU3KbcTrsAwMySpVSwc5SxSl7or8nyypgYtR1Fyil1kQf6Cq+z4EfA3OVUntxfPXX4lh/m1NctiC9A9sVONbQZrf8T0aVv1gpdU8C7aOputzsygnea/8+K6VCODGg83EGB68opSrd4xJpT43JfxiYj+PmbI/jDgy266eA00VkBE6s68UmrqVNY5VG6+V+oD3wN3fkhYj0FJH7RWS4UmoBjs/8HyJyvIgUikg2TlA5LkqpTTguir/iuHLmuT/l4Vgom4A6EZkInBDzJA6zgAtEJFtETsLxcXv8GbjMHTWKiBSLyMkiUhLjPK/ijLgvEJEcETkXx2XyilveOuB54F6c2MVb7v6QK+e3ItI1UD8nNnb9UWzAUbx5SfxPYzwC3Bm4X11E5PRGjp+K4w6Z6n5/L+p7LDYA/VtYzgtFZIiIFOHEQp53ramngFNF5ET3vha4qbS9aLp9bAA6iUhpLIHu+f+FUz8lbh1d68r0eAYnuD+ZgAVMcu0pFiXATmCXiAwGLo8q22qcWNmTwL+VUnsansLiYZWGeV6OmqfxAoBSaiuOAqgFPhGRSmAKTsbLYvd/r8BJu70fJ5NnNXA7zoO3shGZz+D4kP0H0x3V/Qjnwd6GM9p7qZFz/Bg4FSeGMpnA6EwpNQMnaPyQe67FOL75BiiltuBkxvwEx+X2f8ApUSNtr7zPRblhrnfPPd11O7wN7N9ImaN5B/gKWC8iqRjZP4BTZ2+692s6TvA2HlNxOrT343yPxS9xBhLbReScZpbzSZzYzXqgAOe+o5RaBZyOMxLfhDPCvw4nSNxo+1BKzQeeBZa6ZYvlirwKJw61FCe29gxOANw7xyfu7+XAa4H9CbenOPzULW8ljgL6Z4xj/gYMw7qmmkSUSrWFbrFYLPsWInIkjtXT17ViLXGwlobFYmnTiEgujuX8F6swmsYqDYvF0mYRkQNwXKw9cOb9WJrAmHtKRApwfLf5OJNunldK/cJIYSwWi8WSECaVhgDFSqldrnn4Ic5EoelGCmSxWCyWJjG2uJdytNUu92uu+9eoBuvcubPq27dvmktmsVgsmcXnn3++WSnVpekjm8boipDuvILPgYHAH9yUu+hjLgUuBaioqGDGjBl6C2mxWCz7OCISvepCszEaCFdK1SulDsJZ4G2siAyNccyjSqkxSqkxXbqkRFFaLBaLpZm0iuwppdR2nNmw9j0QFovF0ooxpjTcJRbK3O1CnBm/802Vx2KxWCxNYzKm0QNnOYRsHOX1L6XUKwbLY7FYLJYmMJk9NQcYaUq+xWKxWJKnVcQ0LBaLxbJvYJWGxWKxWBLGKg2LxWKxJIxVGhaLxWJJGKs0LBaLxZIwVmlYLBaLJWGs0rBYLBZLwlilYbFYLJaEsUrDYrFYLAljlYbFYrFYEsYqDYvFYrEkjFUaFovFYkkYqzQsFovFkjBWaVgsFoslYazSsFgsFkvCWKVhsVgsloSxSsNisVgsCWOVhsVisVgSxioNi8VisSSMVRoWi8ViSRirNCwWi8WSMFZpWCwWiyVhrNKwWCwWS8JYpWGxWCyWhLFKw2KxWCwJY5WGxWKxWBLGKg2LxWKxJIxVGhaLxWJJGKs0LBaLxZIwVmlYLBaLJWGs0rBYLPsuTz8NfftCVpbz+fTTpkuU8VilYbFkOjo7Vt2yLr0UVqwApZzPSy+1iiPNWKVhsWQyOjtWV1ZoxUrWF3dMfyf+s59BVRVfd+nHI2O/4eyrqnL2ZxqtyKKySsNiMYGuTsDtWBd36sXPTvghISR9Hasr60/jzuKQK/7Gsg7l6e3EV64EYNJ3fs89R3+7wf60obsDb2UWlVUaFotudHYCbgd66Zk38/TISSzrWB6xPx2yPug7CoC17bukTxZARUVy+1OBiQ7cVcYfVwznhSETnH0GLSqrNCwW3bidwOaiUt4aONbZl65OQGfHGnVOlU5ZAHfeCUVFkfKKipz96cK9d3O7DWBV+67OvnR34K7SveD8u7jm1J822K8bqzT2dVqRr9OSIO7DfvE5t/H9b9zCnpz8iP0ppUHHKunrWKNkAentxCdPhkcf9b+qPn2d75Mnp0ce+PfolEse4IjLH2+wPy2YsKgaITOVRlvpSAOm8u6cfD2mcibXra5rcx/25R0cV1F9VlbE/pTiday5Oc738vL0dayerMICAKRbt/R34oFzq6VL0ysLzHTgupVxE2Se0mhlQaO04prKbw0cy4HXPs8XPQal11TO5LrVeW0mRuQDBjjbU6akvROXww4FQD31dPo78QAhpZo+qKWY6MCjLCr69Em/Mm4EY0pDRHqLyLsiMk9EvhKRH6fkxG5H+tzQY1ntBeJ0BI1MjMBdk/jDviMBmFW+f8T+lOPW7Y78Yt7Y7xBnX6akOLrX9mGfEVTmFTr70nVtbiegXAtDevc22gmkGh19tzG5pjrw4PmXLzfaVkxaGnXAT5RSBwCHAFeIyJAWn3XlSqqzc7nu5Gs494J7IvanDVMjcNckluinJV2msluHV55+PT8462bWlXSK2L9Ps3Ilm4tKufC8O7ny9Osj9qeFyZOh0B2xfvVVxigMk2ixNKBVdeAmMKY0lFLrlFIz3e1KYB7Qs8Unrqgg5I7gthaWRuxPG+4otTKvkLsmfJua7Bw9I3CdQU7w63BVaXcAqr0AbrrqVqf1VlFBdU4eAIs6V0TsTzfaOjsgkNNksTSLVhHTEJG+wEjgkxi/XSoiM0RkxqZNm5o+2Z13Eioqdv7Xe0DS7XN0R6O/O3wyj477Bs8NOz5if9pwTWUpaQeA6tgxvaayq6S8eg1JGpWUbuvtzjuRgoLIfWluN8qtRx3duGiQYRq9yrftYlxpiEg74N/A1UqpndG/K6UeVUqNUUqN6dKlS9MnnDwZ9eCDzrlRenyO7mi0JjsXgJCkMRsmmsmT4TvfcbZvuSX9mSqPPorkOJk4qrxn+urWtd6WdOzJVadeR21Wdnqtt8mT4R7PnSlag42Z1teJIQ2VafXYWjGqNEQkF0dhPK2U+k+qzqvOOcc5f0l7PT5HdwTuKQtRISMpcUrHUzN5MjKgv7M95e301a1rpV036WpeHnIUs3sMitifDuTMMwFQvXtraTfe7dJy39oAthb1kGNKsIgI8BgwTyl1fyrPrUKejFSetRHczkW9MBeArHS7iaIQzc4HcSs2lM6ntKICVqygLisbgJxQfXh/mvDai+4+3OqM1GDdU3owaWkcBlwEHCMis9y/Sak4sdd4tHalkyejzj/fkXvXXVozKnR3dl69plWea735SqO+zuiEpnSgoj61yMzgfjWTr601YczSUEp9SJr6dV9paHaueo02K8Ojjr6SSmd35yrdug+qAMjp3g3+7zY9MQbNjg4dI2Qt1qFhrJtPD8aURjrxHgzdAbmwstIrV7eO8txhaX9GJ0+mbv17sGk3OW+9CV3bpVVcRk9Kc8lkF04GX1qrwnj2VDow4p4i7GbQbeFoGfnHkqdBXF29IyRbg/mmvUP1AuEaLRudl5iJFpsl05WG5s7bk5ulXWloGvlHy9PQKdRr9KeEs5m0iXQF6hOVyR1r5l5Z6yJDlYbzqd3SMCRXN971hULpl1Vb7wjR4a/2lUbaJXly3EmSOkf/GmXpzurLZIXYmshMpREyE1vwOrYsQ7Wq65Hx6rVew0PqWRo6rs1Up6PDYvMVvY6gO/os0QisztBCZioNY+4p51P7vAn3U1ef57nfdLiOwpZG2kX57SaT52lk8mg8kzPDWhMZqjScT3OBcM2CDQXCdXRAYcWUflm6Ox2v+nR25Jncr2q3bNooGao0zLinjAXCDVk2WiyNkM7RvyH3lNaYRmZmakHbsTRMz0fJSKXhVaruzlQZUla68SeKaXhK9cY0NAgxRNg61CdTtytMV2dqutM23U4zUmm4bnDtM7PDM8INzdPQlnLrfOoIhHvojGnosjg8KTo7Vx2K3kN75rImgabDQqbjUhmpNEzP0zAU0tAuT4d7yhvV6fBX656n4V+b1tG/Plm6R+S6xJnutE3Lz2iloRt/nkaG+6ey/HWMMtXS0ItOqZk6+xz0XZtp95CO+VGNkZFKI9x565XrNSZTCxbqGtn57imNjVfHpeme3BeWm5kdue7OVZc80yN90/IzUml4bhPdsQVlyC2mf2l0ffM0wlEGfe4pXYRjGumX5d0zrfGTDA2Em6bVKg0R6aazIKnEVMqtdyt1WxrhGbia5Gmcp+GRye4pHXcu05csgbZkaRgV36ilMVtE3hKR74hIqbYSpQBTk/tMNSZTIRTTD0+qCc8Iz8wALuh6d4fzqX/k3zZiGqYtqsaURk/gN8ARwEIReVFEzhWRQj1Faz6mX8KUYX1pA3yXUYaNWvUm3AZnhKdfloSXDUg7Oq8riLU09BBXaSil6pVSbyilvg30Bv4KnAEsE5GnNZWvWZhasNAfqeoVq33tKQ8d4sLBaX3pvbrRmdGkd8mSzLTYlOHsJdNKK6FAuFJqL/A1MA/YCQxJZ6Faiuml0bV3Phrfb+EKcj4yLqahT1YQHfJ0zgg3MfvckafLPWXa0mjFSkNEKkTkOhGZCbwCZAOnK6VGaildMzGVxeR12tpvqW4fvIE1mnRaNbrJ1IymTI0NmfY+m3Z/x31HuIh8jBPXeA64VCk1Q1upWoi3vIU5S0OzXPdT11pbJhqtjg7I9KRQK6tlWEtDD3GVBnAj8L4yHapvBuFJdmYC4abGIrou10ggXIMMU9lTOtF5baY7t3Rh+rpMV2tcpaGUmgogIv2Aq4C+weOVUqelu3DNxdQ8DQ9TPvFMXbYBNF2bivjQRqbO0jb1fpJMkRNXvlnxjVoaHi8CjwEvA4bzBhLD9EhRf3Z6W5h5q8M9pU1UlNzMHP3rbidtxT1lmkSURrVS6sG0lySFhJdGNxQIN5SfrnvBtkzzj/udgaGVBHSQabP4I+TpkmPa0mjFMQ2PB0TkF8CbQI23Uyk1M22laiHG3VNt4A1wuuVp9E4ZSKDIzJGr7hF5W7E0TDeXRJTGMOAi4BjC7inlfm+VmH6DnrGYhi55UZ9aZGq0NPS/hyX9Mkx0NDamkZkkojTOBPq7E/z2CcKT+wwtI6JVamCkqvmp0Tu5L/2yzA02NFybIdepTnS1R9OWhmkSmRE+GyhLczlSSnhpdDPyTQUAdVsaOsnkyX1a1tXSGPfSKStCriY5ptd+Mq2zErE0ugHzReQzImMarT7l1ph/SjOm3ACZ555yPnUnUGTacuXGEkI0VaRpS8NUzNQjEaXxi7SXIsUYSoIxMuktKE/fMgr6tYaOB8XUO961uN58WWkX1UBmpskzPdI3Lb9JpeFN8tuXaGvZU2H3lG53QGb1QKZiGnpcbwZSbTM0eypTs90Sxb7uNQ3otzT0ugNMzUBPN5m8YKHOjDdj7UKTXOMxDbPiM1NpmHJPYagzDU/u0ytPJzpEhq8rE00N90OLgtKbmBGWqwfjMY3WvDT6vop595RueYYmE+qUpXWeRvplBdFajzpkZKgl6mFcaRiVnkBMQ0QOA34J9HGPF0Appfqnt2jNx9Q8DQ/9KbeeXD3ydLvDQFOqqPtpakn9tMpIv4iGMjP1fRqme23DJJI99RhwDfA5UJ/e4qSGemMjRkNmeRsIhOuZy2Cm3WiJaWjMkzYX0tAVCNciptXKT0Rp7FBKvZb2kqQQ08uI6H5qwtkqmuVpRE9Mw0u51b3QpT4ZWjpWA/N4QF+7NO2eMu2gSkRpvCsi9wL/YV9ZsDBk5uH3MJdyqwcTk7f0LCOSdhFx5Oq7tkye3Nd2AuFGxSekNMa5n2MC+xQpWLBQRB4HTgE2KqWGtvR8Hn5MQ7d7ynD2lC6MzAjXIMN0u9EiS58oc2uwpRnTKbemSWRy39FplP8E8BDw91Se1BsJGJunoVmesdeUZlhvZ2xGuMYFC3UQHjxlZu9q+rpM12pcpSEiFyqlnhKRa2P9rpS6v6XClVLvi0jflp4nGuMpt4YS1PUtIxL5qUemPl+87qXRtS5YmNGB8MySE1d+K3ZPFbufJToKEg8RuRS4FKCioiKh/zFtPmZ8TMNAq9U5T0M3mbfKrangkB4xuhZGjEerXbBQKfUn9/NWfcWJWY5HgUcBxowZk1BtmXqZjj8CNxTT0G5paA2Ep1+GsZiGTlkaLQ39gfDMjWmYdokFycwZ4abfp6FZnvYFCw34rPWkpZqyNDJz9K993pC2lHP9dRlUVKb1R2YqDW/EaKoAumfCapVmKKahoU5NvU9DBzrvWSa/zArMWxptWmmIyLPANGB/EVktIt9NxXmNuac0xxYayM3gkZaezs5MAoXW2szQd3foxETsK8LSaK0xDQ8R6QbcBZQrpSaKyBBgvFLqsZYKV0qd39JzxMJ4IFx3TCOkV16mxjQyeYSsdW6NqcFThskJYnpCYZBELI0ngDeAcvf7QuDqNJUnJXgxDVPBI2PvCNf2Ehr3U4s0X2raJZiap6Hj2nTO0jYWCNc2uc9w9tQ+4J7qrJT6FxACUErV0coXLtSdguphwtdvVK7OQLjW7KnMnaehE/0LaGqSY8Q9tW9ZGrtFpBPuPRGRQ4AdaS1VC/EeflNuqkwdYfnyDBjoOmMautGTGeZ+ZvQaXnrk6HYHQ+S1mdYfiaw9dS3wEjBARD4CugBnp7VULURpdtc0kK9Znv73aeiRo1um8i2N9Msyhc7UZf3tJHPdU63J0khk7amZInIUsD+Ou3eBUqo27SVrAfWGTAxTa+7onqdhYmFGHddmbO0pnYHwDHWF6ZRr4vJUxHbrz566OGrXKBFBKZXSRQZTie6Rt2lMra6baS9hMubO1Oqg0kdrmsWcSoyknAdcYqarNRH31MGB7QLgWGAmKV6ZNpVonyEdhf5lRPQG/s287lWHDFPze/TJ0BMb0iAkllxNcoxM7gtcnWlVnIh76qrgdxEpBZ5MW4lSgIlODYJZTJoD0xn+kILeAK7+pdH1ydBSj76stIsyMlPa9OQ+0zRnRngVsF+qC5JK6g0pDQ9jlkYG+3R14L/xUftLmDKrRnWujGBiprSJDjwUoRxbf0zjZcL3PwsYAvwrnYVqKX5Mw5R7Src8X2AGB8J1jFrdT1OvCU4nRlyKWuJQ+i0N068GMD3ESCSm8ZvAdh2wQim1Ok3lSQmm3FMYkqvf0tAfM9KaPZV5OsNQxo/eOSH6YnqaBEXI1K8c45FITGOqjoKkEm/yjam6NRXT0D1PI/NGremXEQu9gXC9HXm6aStzJkxbF0Eae91rJbHLKoBSSrVPW6laSH34CTGCuewpTe4pLVKiZGpM+8nE1GWd1rfWda6Cloa2tae0iImSGRTaSmMaSimjr3ltCaZSbs1ZNprlGUk5TD+ZbGn4snTI0DhmazOWhoq9bYJEYhoAiEhXnHkaACilVqalRCnA1GS3sHy9gnXHNPBHkhpjGhpkmZ7fk050XlFI4wPYVgLhEdepXXokTabcishpIrIIWAZMBZYDr6W5XC3C1Cq3HvrdU65cvWIzb4Tsfep2T2m8OJ1ZaDpoKym3pq2LIInM07gdOARYqJTqhzMj/KO0lqqF1Bt6n4apUIr+N/e5n3rEaRNmekl9HTJ0BsK1uKcCPbiu9m9ibbvW5J5KRGnUKqW2AFkikqWUehc4KL3FahmG4+DGRqoZHQjX2dlpH2zodPPpkKFvEGMmvqBibqeTfWpyH7BdRNoB7wNPi8hGnPkarRb9Pv5IdPvEdT84mTpRTOdM5oiOR7O8dKNzcm19RGeadnGOzCjrRse8ntaTO5WYpXE6ztIh1wCvA0uAU9NZqJbiu6c0yzX1HgG/DetyT/mfGkfIGmTo9DrozqA0EQjXYmkEV39NvzgA6iPiKHrYp96nAVwKPOfOAv9bmsuTEsKdaBuLaWiTF/mZKYQ03sB6U21Tg1xTk/u0uYpC0TLTb2rsazGN9sAbIvKBiFwhIt3SXaiWorsTDcuN3tArV9dDY6J+9c6aTj8RLg4d8RqtE+70tY/IetSDboUP0e5Ms1qjSaWhlLpVKXUgcAVQDkwVkbfTXrIWYCqmodlL5FPn2ujaLA1NckK6O1a/3aRflon5BZB5qcsRbhsTMQ09Io3HMYIkszT6RmA9sAXomp7ipAbP56h/DSgzykp3CqAui0p3x6pzvovujseEy0jPIpPhbW3zNAyk+ZpQjvFIZHLf5SLyHjAF6Ax8Xyk1PN0FawnGXsJkSFnVhfRer675DBGZMWmW5cjQmGGk+fWdOuNQOp87E3MmTCiqVqQzEgqE9wGuVkrNSnNZUoYp95Splz/pzhbT1QFFZhjpG7XquH+6/eL1Jkb/mt1T2lJuDcg05c6MRSJLo9+goyCpxNTS6CFDqb51mmfA60r/0+3CCd+/9EvTHQjXOZCq1xhjM7EmU8jwjHDTNOd1r62e8Ig/s91EHsYsjTRL1D260nn/dF5bKKS0ZobpHMRET7TTgYnsqUjl2Mqzp/ZFTE2zr9c4Ug1SV6/XtPKztdLe2YW3dXZAekbj+kbI2l1hGusx0tefuYFwE8oxHhmpNHT6piPlahzOBdAZDAyFlLYsI92uhzqN9Rhxz9LcUHXKaiBPoywjHbimh91Emm884ioNEfmuiFwX+L5GRHaKSKWIXK6neM3D1HsRdHY6seQmer0tGbXXBob/6X5IdQccdfqqtVoamjscne5SE64iE4FwU31LLBqzNC4DHg983+i+4rULcH5aS9VCQoZiC6YC4Ym6A5RS3P3aPPrd+CpH/vpd1mzf02xZOtBvaXhuNw2jcY2Ns07jaFwplVRs6Ou1O/lg0aYWyfO3Ezj+9bnrWiTPkRnYTuD4W/47l3982rJ31kVaVK03ppHlLonu8RyAUqoaKExrqVqIqZcStfYA/KKNu/jT1KUArNxaxckPfpC0rNr64EOa5kC4qZhG2iXp9YvrtKCSncMw6cEPuOixT6murW+WvPpAG2mqIvfWhbjsqZlc9Nin4Thgs2Qm3oHX1of4+7QV3PCfL5stD6IUf4vO1HIaUxqlwS9KqbsARCQL6JTOQrWUkKHOW2cA0CPRpTY2VdZwwm/fB2BAl2IAdu6pTVpexMOWwHUu2bSLjTurqalLvlNoTmpvS+55MiPkmrp6npuxiuufn8OOZtRjpIujaYGfLN3CCb+dyrLNu5OWVZekD/7P7y/lnD9NY9aq7c2QlXhnvKsm/IaFl2evTVoWJOd6+/fM1f72Z8u3NUseJGclzlu309+eubIFMpNczvertTuYsXxrs+U1RmNK400RuSPG/tuAN9NSmhSRjKWxYstuRt3+FofcNYWd1ck//EFMLMmeiK9TKcV9by4A4JD+HXnj6iO5+eQDCCnYtntvUvKSeUjnr9/JsfdNZexdU7ixGSOtZIKc1bX1nP/odAb+7DW+WrsjaVlBeYl0rI99uIzrnp/DP2es4tlmuB6SjTPc8/p8Fm7YxSvN6FyTDRbf+eo8Pl22lTP+8BF79ian7JOZ6R502bwyZ11ScsIyEr+2+99a6G83t41A9EAtPkopTnso/JLT52asarbMuvrEe5VnP13JyQ9+yNmPTOPBKYuaLTMejSmN64ABIrJYRP7t/i0GBgI/TXlJUkgoQa1RVx9iwm/eY+vuvazfWc3/mtlwPUxYGol0CB8u3sw/PnMa7JPfHUdOdhb9OjvWxrIt8Ueu26v2snTTroh9tQma5jv21HL1P2b53/8zc03SbpJk0imfmr6CaUu3UB9STF/avBFWMvGalVuq/O0125KPDSXTuX6xchtfrNwOwJ8/WJp0R57Mciz3u4MLjyVR978pkrE0/vHZKkZVlHHqiHKWbk5OjkeiFtvmXTVsqqzhxomD6VqSz9cBCyBpmQkq4Y2VNf722H4dmb++MjUyG7mLldW1EQO0oKJMFXGVhlJqt1LqfOAE4An370Sl1HlKqebdYU3srU9sRuo78zeiFBzctwMACzc0/6ZC8llbzXXbBAk+pG9+vYFf/Heu/33LrhqueMbx4QLcMHEwudnOLfeUxtJN8ZXGKb//kGPumxphjQTdU8s2747rG35h5mrmr6/k8gkDuHHiYAAWJFm/iWap1NaHeHn2WrqW5AOwYWd1UnI8EnVP1daHeP2r9eTnZFGQm8WqbVWN/0MMkunIX5mzjrzsLO4/ZwQ7q+uSdhvVJzhKVUrxyPtOzOvv3xkLwLodydVlov7+DTurWbxxF5OG9aC8rIANO2qa5VpMVM8vcDvsA8tLGdSthCWNtPumqI8czcTl02XO4OX5y8bTt1MRa5uReOKRaDJDsO2P6F1Gx+K8ZsuMR2MptyeKyNlKqaVKqZfdvyUiMllEjk95SVLI3rrEsmDmrnFM1L9/Zxz7dythdTNGjEES7XTq6kNc+69ZjL1rCpc8/lnC56+srm3gP48eHf9t2goApi7cxOg73vatp9F9OnDZUQP843p3LCI7S1jWyAjPq49xd08Jlz0g7+15G7njf/Ma/N+qrVX88uWvKcnP4boT9mfSsB4AfJakjzXR7KnX5q5n9uodfOvQvlR0LGJ9kh2dR6LuxYfeWcz2qlquPX4QR+/flZVbm6E0krBq3p2/kbH9OnJIfyeUmGxcoy7BNOmlm3ezty7EbacfyOAeJQCs25HcM5FowHbOaufZO6h3GZ2L89lbH6KyJvm3SCfqKvLcUYN7lNC5XR5bd9c0cnQyMmNLDYUUf3h3MV1L8hlZ0YHyskI2Vtb4fVOyJGLdKKX48/vLAHj2+4cwYVAXtlXtpbYFQf9YNOaeuhWYGmP/FJy4Rqulpq5pS2PLrhoefGcx/bsUU5iXTc8Ohc1yM3gopRJ2Sy3auIv/zFwDwLSlW/hydWL+1aN/M5URt74ZMbqvjTGKXLW1im89/qn//dQR5Tz9vXERx+RmZ1HRsShuBxRUuHvrQn6jjfatvvX1hojv89bt5IhfvwvAr88eTlaW0KtDId3bFzBzRXKBwEQzjL5YuY3C3Gx+cGR/urXPT6ulUVsf4vnPVzO2b0d+cNQAencsYvW2PUm73hIdkd//5gKWbt7N0YO70qUkH5HkLalEl6A49j7ncR/Ws5TOxfnkZgtrtzff0ohHTV09N73wJVkCQ8rb07nEGQ1v2ZVcfC1aXrxqrK6t55GpS+nTqYjO7fLpUJzHtt3Nj18GL/HOGIMmgK/X7WT++kouHt+H7CyhvKwQpWj2gCaR2OXyLVX8c8YqBncv4eC+HehSko9SsDXJuGVTNKY0ipRSDRKalVLrgeJUCBeRk0RkgRs3SXphxN01dXy+YitbdkWOGva6Lp/GHv7nPncyKb53eH8AenUoZHUz3AweyaThrQj4w7OzhFfmNB3cVEqx2b3Obz8Rtk6q9jYcnR3x63fJct9Aed7BvfnduQdRkJvd4Lj+nYvjuqe8zJbeHZ3saq/hRY9aKqtr2V1Tx1drd/DspyuZ+ICTxjusZykTXQtDROjbuShpSy74nPzq9flxXXkzlm9jWM9ScrKz6Na+oNlKw8tQqQuF4o4Ib3v5a9Zs30PX9o4rrH/nYvbWhZq0NlZtrYpQ9ol0rnX1IZ75dCXDe5XyrfF9yM3OolNxPhsr419fdW19AzdIRIcTR+x9gVjGiF5lZGUJ3UsLkn4mgtf192krWLyxoUty8cZdbKqs4dQR5RTl5dCp2KnL6Oc4mljPVVAhPjl9Rcx4z1PTV7B1917+70THTdqpOI9dNXVNuoa/XruTR6YuaVCuoOX23OerG7hoN++q4ZTffwjASUO7A9CrzHmOmpobVbW3jgenLGoQXw1mT9384twGKcpKKX73thO/uPusYeRkZ9HFddduqmy+VRWLxpRGgYg0WAVXRHJJwTwNEckG/gBMBIYA54vIkGTOcfRv3uMbD09j8l8+idjvxTRWbq3ipN+93+D/Vm6p4p7X5tOxOI8LxlUA0LOskJ3Vdc3OoErUR11TV88Vz8wEYPYtJ9C7Q2FCk+yCbqkPFm32H6B46Z5/+85YFt05kbvOHEZ2Vux3GPfrXMzyLbsDkyEVT01fwcad1X4HP6xnKRBueNGd3c7qOsbdNYWTH/zQD8B9/4h+PPP9SMumvLSwUf/4jj21jL97Cn/9aJm/L1rW85+vjv43ZizfypdrdnDcEOe9YN3bF7B+Z3WTinvJpl0NjvGe/e1VtQz75RsN/mdXTR1PTnfcf98+rB8AB/RoD8SP14RCitG3v8URv36XZz8LZ88EO7svVm6PGRs6448fsXnXXk4bUU6OG4tyLKn4ncC5f5rGofe8w5tfrQ9cV/y2qZTibx8v5/fvLAbg8UvGkOW2lyE92vsu3Fg89M4irv7HFxH1GH3PzvnT9Ijvu2rqOPlBp0O96piBAHRq51gam5uwNE576CMujHrWg/KWbd7NrS9/FfH79KVbfBfqMYOdNtLB9fNvr2r8WZ/04Afc89p8Rt8R+aLS3TWRHXaV24FX7a1j7podnPGHcMZUrw5FAJQnqDQuefwz7n9rod9HeAQV//qd1bw2N6xUqmvr+d7fZvDfWc7g02uTJpTGf4A/i4hvVbjbj7i/tZSxwGI3ZrIX+AdwejIn8LITorMSgqPE4G/LNu/myWnLOfJex33iBYMhfHMTdVE5K4fGfli2NdIY352/yT+2tCiXHk10ph5eR3FQ7zIgrCxiKY2rj9uPI/brQm52lt8BxKJfl2Kqa0Osd0fmUxdu4uYX5zL2rim+xXDUoC4AvpUTKzsmmG9/15nDuGHiAZQU5EYc06PM6czjjbCnL93Cuh3V3Pry1/4xe6M60mj3RSikeGDKIorzsrnwkD4AdC8toLo2xM498f3j/5m5mmPvm8ozUamywdFcTV0wDqBYtbWKcx6ZBsD3Du/H6D5O8kTPDk5nEC/IOW/9Tra4Vlowbz5YD//7ch33vDY/4v++WLmNuWucDJ+jB4dflNmYJbW3LsRs19X54qw1MWW9t2Aju937taumjvMenc4vXgp3tAf17uBvD+lRyvItVXEn3v3mzYW8OGstN70QztaJdqMEXSM1dfVc8OewEhnQpR0Ands5ndvmRiyNyupavlyzgw8Xb+aFL8KDhz1RZQs+71t37+Vi1037k+MHUZjnWNsdi/IalK0pgs/67qjYS5WrRO55bT6n/P5Df8B18fg+voXfvbQAERqNIQJ8GmgjlYEBbPRzs7cuRGV1LXe/Oo8L//IJU+ZvBGDKT47yZXZx67Uxy7Q5NPY+jZuBO4AVIrLC3VcBPAb8PAWyewLBxOXVwLjog0TkUuBSgIqKCn9/8IYX5majlEJEqKsPNciouPofX1BTF+K1ueHRV++OhTw8eZT/vZf78K/etsfX1PG4+PFPeX/hJs4d05tfne28xDB4U1+evZZRFWX+aDSIN4nJC0r3KC3gk2VNB4i/cCcGHbFfZ2at2s7qbXsoK8proDTysrO44uiBTZ4PIjOovl67k+/9fUbE78cd0I1x/ZzgqzdaqYph/g/uXsKxB3TlqmP2i+kGA+hRWkh9SLGxspoepQ0N1WCnu2bbHio6FTVwvW2rinzIb//f13ywaDMH9+1AUZ7TlLuXFgCwalsVpUWlMcviTbK6940FnD26F/k5TpmjOzylFE99spKfvxjOSMvOEr5/ZH//e6fiPPJysuIq/uWbHfdOWVFuhCsw2v312XLHzXr+n6ezcIPTsZTk5/DSVYdHDG56lhXy2bKthEKqwYBgkesKyhLHZec/E4HrWrhhFz98eiZ3nDHUjz15fH3biX49AvTt7AykVmypYv/uJQ3qxuPZT1dx0yRnoFAfY1ARCikWbKhk8l8+8Z/b+befhIhTfq8OG3PxBevukfeWcubIXkDD9rh5Vw1bdtXw/qJNXPPP2f7+q47dz9/2LI3GlEa062rnnjpKi5yB0K4opXFIIFHEY/YtJ/jHAxTkZjOydxnTlmxpcGyQTsV5/iBj3Y5qf/AVHUvcW6+4+PFP/VRsgEuP7O8rYnAGGPk5WX57ShWNpdzWuS9g6g1c4v5VKKVuUEq1bBacQ6whcINhqFLqUaXUGKXUmC5duvj7vfzxI/brzJ7aet/UjB6dArw4a22EwgB49UdH0LV9gf/dGzGuScCH+/5CJ9Tzz8Bknehn5clpK4hmyrwN/O9Lx6y8wU1D7V7a+Ajc4z9frGFQt3a+j3SV+4B5llGh21nfcuoQP622KQZ2dRrYT5+b7SuM88f2Ji/H+f97zx4eNnHdUWCsYOW9Z4/guhMHx1UYAOVlTl3HC6wGZ856nV9VTcMHF+CDRZu4/vk5/PWj5U75T9jfP2ZouaMovmzEreKVYXtVLe8v3Ozvj74HN70wN0JhADx32Xi6BdqNiFBeWhDX0ljuzoOZOLQHCzdU+q7AyprIR2j1tj2c+Lv3Ix7wJ74zNkJhAAzrVUplTV3M+TVeB3LBuAo2Vtb4z0R1VMc6deGmCIXx3cP7sfCOiREKA6B/Z6d9xEqW+GCRU2+DXWXitYtYiRn9b3qViQ984HfS1x4/KKKt5GRnMahbu4g20PDaHEV/8vAeLNuy21da0VbQ6m17GH3H2xEK4/5zRkQc09N1FS1vZI6S93x5lvamXeF2G2vg5HFAj/Y8PHlUhMLw2L97Ccu3xO9fKqtr2bJ7LycM6QZEurKi2+bPX5wboTA6Fedx06QDIo7Jy8niwPL2jT4LzaGxlNv/A1BK7QEGK6W+dLcRkbtSIHs1jkLy6AU0GhEOjgyWbAwrDYC1bmpgUyltfTsV8cbVRzZwn3QqznNz7ht3T8Xr3KPdNtGNef2Oar77N6dj9nLgAXqUOSPwxkxzcB7ckb07+G40b27Aoo276FKST7sC54HPzY7vjoqma0kBP5wwwHdPAdx91nA++9lxzL7lBDoU51Gcn0PH4jx/DsvaGCmYQ8obt8wA37qITuFcuKGSPXvreXn2Ok460FGIi917WxVVh/+euZqRt73JRY996ivsl648jHH9w6vaVHQsIidL/Ic+mrr6EDOWb/VlBScvRncG3kzvnmWF/Pvy8Sy/52RGVXQgmsZcjCu27KZLST5DepRQUxfylW+0+2zL7r0RPv0HzjvId4EF8dyTs6PmaiileH3uenp3LGTCIMed5XWK2+PEvS47agCf33wcPz9liD9QCOJZGtGd67bde7nPnTQ22Y0JeqPjaNdNNCce2I0fBUb9HoO7t2908tuU+Rvp36WYkb3L2FsXYme1I6exDjwvO4uHJ4/irFG9Ivb36lBIh6LcRrMWvQ7ZUxqeK1wpFdMlPHFod2bcfByv/fgIPwEkmoqOxWzdvTeu2+nrtY7SPMKVGRyIRLvhPM47uDfTbjyGV398RMzf9+ta0mCCbktpzD11HvBrd/tG3AULXU4Cbmqh7M+A/USkH7DGlXdBY/+wZvsetlftpawojzlrdlCcl82Yvh0BWLe9mgPLS/0OJz8ny/dLv3TlYQzqVtLoSFhE6NupuMkceK+D7VKSz+ZdNdTVh8jJzmrg2qiuC/lpuG/P2+AHiSePq+DIQWGLqYc7al23o9ofwYZCivveWsC/Zqzm/nNGMLh7ezZV1tCzQyGlhY6yu+vV+Rw+sAvPf76aorxs8t2HPlErw+Pa4wexYWcNX67Zzi9OPRDAl+Fx2MDOvDJnHdefNJjnZqymS0m+767667cPjhtoD+IFAj9btpVThpcD8N9Za/jxP2bxwwkD2FNbz6kjyvls+VZ/NFYVowMKxoue+PbBDO9VFvF7VpbQtSQ/QhEGWbChkp3VdZw0tDsfLdnsj+aUUuyIEYuaOLQ7D184utFr61FWwPQYbodQSPHFyu3s17UdvTs6HfDKrVV0a18Q0XEEufusYZx4YPe4k7L6dS4mO0si3DXX/nMW//nCiWGM79+JHq5V58U+Yrl9HvvWGI49oFuj11VSkEvndnksDzwToZDimPveY1tVLZcc2tePgXgZRrHmWhw5qAtDerTn/LG9qXDrIZrB3Ut4/vPVbN5VQ+d2+dSHFI9/uIzPlm9lbL+OfLBoM+eP7R0I7lZTWpgbszN94LyDOG1Eue/+ikZEGNarzI//gOPWeuDtRWzeVcM1xw/i+c9X07OskMPdQanX3uetq2THnlpG9CoNx4+uOMxX5o3Rp1O4DRxYXsqqrVUcde+7hBS8ec2RvLtgEzlZwmnDy7n1pa8ilEasuMTtpx/IWaN6UZwfvxsf0LWYf85IbcptY0pD4mzH+p40Sqk6EbkSeAPIBh5XSn3VxL9x0G1vcfsZQ/nfnHUcsV8X+nZyzPeFGys5bkg3Pz5wzOCuvDZ3PT+cMKBBxxKPQd1KIhYV+3rtTq58dibfHN2b7x/Rj5zsLF8pHdy3A69+uZ6tVXvpWlLQwG2zdfde+t34asS+Eb3LuPPMYRH7vAd8xZbdfsN746v1/OHdJQD+bG4Im9WnjSjnpdlrmeSuUnvigd15250vkZOk0sjJzuK+KPM9msuPGsDLs9cy7i7Hd/ujYwbyoJttU9SIIg5SWpjLEft15iO3c/1k6RZ+7C4z8sf3nGvt06nIVUjOAxJvFHnYwE78cfLoBsrNo1tpZLB4yaZdPDltBUV52fRwYx6jKjrQs6zQfzD31NY3cG0+8e2DmbB/V5qivLSQDZU11IcU2VnCw+8t4VevhwPbFx7Sx1caq7ZWcXDfjqzauocsCacVf2t8H3583KAmZ/DmZmdRXlbgK4LK6lpfYQD07VzcIGsmOsj+6EWjm1QY/vkCA6lQSHHmwx/7intIj/Z+5pPnBaisbqg0fn/eyJjumiBeHHH+ukoO3y+fd+dv5M5XnaynN922PaRHe//aNu6sYUCXdvxvzjpyssJxmwfPH8lpI8qbvK5hPdvzp6lLqa6tJztLOOl37/uWnufKvuqYgXQrcdrLvHWVnH4Q/nInw1ylMaJXaUIKA8Lu4Cuensm7P53A+4s2+fffW0x0wv5dKC3KpVv7goh6f2p6ZNLG3WcN4/yxFTSFJzOVNNbDqDjbsb43C6XUq0qpQUqpAUqpOxP9v5+/OJcde2o5/aByOhbnMbh7CR+4vumv1+6komMR7V33U1ac0UYsBnVrx+pte6isrmXO6u1MevADlm7aza9en891z8+hPqT4ePFmcrOFYwc7D93mSqehbUlghul1Ad97WGYJpYW5vo/43QUbufxpJ90u2tXkxV0ePH8kJw8Pm8D3fXOE/3KkvCTcU4kypLw9IyvK/O/BQHAySmpErzKWbd5NTV19RPps305FnDainAN6tKdr+wLfFbBm+x7fgvJYeMdEnv7eIXEVBjhpt8G01Kue+YInPl7OH99bws//64xLencspGdZoZ/p4k1S9GJDpx9UnpDCAKejrg8pPlnmKMSgwhjSoz0Xj+9Drw6FiOBbUR8t2RxhcV40vm/CSz50KyngpdlreWXO2ogF8U4dUc4tpwyhU3E+WULc1NxYrqjGrm2p23m9OGuN7xa74ugBnD6y3C+z555asD4yLvH9I/o1qTAgHBv527TlEUkZJQXhce3Iig50dTvxC/7yCR8v2cLKrVWc6LoaAYYm4Cp1jiulLqT476w1vDt/Y8x033H9OtG+0JH/yNQlXPHMTK585gsA+nR0Y01J9C/7dW1Hh6Jclm+pot+Nr/KzF5x4WV7gGfrmaMdj37dzEa9+uZ5563b6AwRPYQIJKQwgIjCeKhqzNEaIyE4cq6LQ3cb9XhD/39JH307FVHRtx6KNu+jfudhvLIf078QTHy9n2C/foLK6jolDu/v3srGU02g83/hP/jW7gXvjhS/W8II7ojukf0cqXFPTi0XEmul5yaF9Gd6rlC/X7ODKowfSqV1+g2Nys7MY268jM5ZvZdXWKr79V2fi3o+P3Y/vH9mfN+auZ8r8DSgFQ3uGs4H+cMEohvdcQs8OhWRlie8bzclKzxt8X/jhYXy8eDMDuraLiAclE0MZ3KOE+pBi/5tfpygvm/5dinnrmqMi3FtdS/JZ6Pq2F26oZL9u7fzU0+K87IQ6vG7tC3h/oZPavGB9ZYPF6Y4a1AURoWeHQqbM38i0JVv452erKCnI4ZjBXfnvrLVJ1eMpw3tw7xvzufAvn/ju0rH9OnLTpAPoWVaIiJCfk037glwenLKI52asYt2Oak4bUc57C5ykioLcxOV5deB1YJOGdef+cyIncIYUPPTuYg4d4LTpH04Y4Ft0eUko+qHl7Xn+89UcfOfbvuXy4fVH+7E1j3vfWMBZo3ry/OerKc7LZrdrJZ48vOlRP0CndvkcO7grb329IcLV9+UvTyQUUqzZvofeHSMz6rz5WbedfqCfYJKoQhzpxqau/3c4XdizwD5dtpUPF29i/IBOiAjXnbg/976xwJ9wl50lvksomSGaiPDmNUdx8J3heR+3nnYgF4/vw1PTV/DGVxs49oCu7jUN5dj7pvqp7wC3nDKEq579IgmJzlSCio5FNEzLaT6NZU9lK6XaK6VKlFI57rb3vemhQxooKcjhrWuPYvGdE3njmiN9heCtbeSZxkEtnITO4OC+HTl/bAVvfr2BOat3MK5fRxbccRJ/uGBUxHHnHVzh55Z76ynNXbODorzwQzu4ewk/P2UIZ43qxS9OPTCmwvAY06cDy7dU+Rkt547pzTXHD6Jdfg7fGN2LP04ezcMXjqZdlO/yB0cN8OMDnnmenQZLw+PQgZ0jMoeAhOIZHocEAtZVe+u544yhDf6/czsnHvHU9BV8sGgzg7qGUz3f+emEhOSM69eR3XvreWDKIh6e6nSUz182nnd/OoFHLhzF7y8YCYSTJs7/83Q+XrKFM0f29EfOySjDgtxshvUsI6ScReryc7J47FtjOKh3WcTocKKb+eYFzT1/OSTXkXuxJ4+7zxreIF539XFOsPkCt2Md3is84EjG0vBSWz2F8ZtvjmigMDzG3/0OG3bWRLg7c5JoH9e7GYVeXGTajccAzsDPc+8V5eVwyymRc4CDPv1E67F7aQG3nx6ux+OHdOOEA7uTnSWMH9CJ604c7LfNK44e6FtCANNvPNYflCZhaACOtXDDxMGUFOTw6EWj+dahfRERLhrfl6e+N86/jwO6tOOPgSkBJw/r0SDtORGys4SXrzo86f9rjMYsjVZLtEtkbD/nHRHn/3k6N0wczJGDuoRHBUne1UnDuvPspysRcfyG+TnZnDy8ByE10tfyxx7QlcLcbDoV5/H7dxZTXuaMWIf1LPVjKr/6xvCEO9QxfSOzZG46+YA4R8bHS5tP9npbSjKB987t8nnxisM44w8fcdaonhw6oHODYzx3xM1uquvxQ7r5PvtEZZ14YHeG9mzvv0vg5GE9fAsgmMI6Yf8u/pLxAB2K8vyBR06Syvfq4/bj7XkbKMrL5qUrD2+QnQdw55nD2Fsf4pXZ6/jTRaMZ06ej/1syFvH+3UtYdOdEvl67k+L87JiuuquPG8Qf3l1Mbb0iN1s4ZnA4hpGM0gi6lrqW5PONUT0bHPP5zcdFzJoOThBMpjkO6lbCg+eP5EfPfkFpYW7M+TwA3zm8Hyu3VjFjxVauPX5QxG/JtMcLD+lDUV6OE9MY2r3RY//3oyN49tOVdG6X56wB5u5Pxv3tcdlRAyIWD43HpGE9uGBcBaGQ4u6zhvnx1GRpzJXbHPZJpRGL/buXMPPn4cV3vWUaknkYAQ4f2Jmp102gT6fI/PhTR5QzrGcpK7ZW+R3C7WcM5YdPz/Qzo350zH6+0kimMQ3vVcaYPh2YsWIbD5x3UItucnMacUtIZiQJTsroG1cf6WeSRHPx+D4sWF/JS7PXsl/XdhHpi4kqxKwsYXRFB9+tdeSghsoJ4KShPfjtuSP8nP5hPUv52HWNJOvmG9qzlOX3nNzoMdlZwn3fHMFtpw+lXX5OxDpeyd633OwsRjQRgP3tuQcxe9V2bpp0QEQmUbIZdn+5eAxbd+/lrFE9Y2YkdWqXz9vXHsXlT33O3vqQv0Q9JH9dp40oZ2TvMn/2djx+eVrYSghOxEvG0hYRvjG6V9MH4tw7b9UB53+dzySbf9LcFZU40xrIGKURjRepT7bRikgDheHRt3MxfaNGqh5j+3bknIN783//nuPITeK5zM3O4vnLD02qnPFIU0gjLsm4pzwaM7NLCnL59dmOlXbx+D4RvyVzbVcfN4iCvGwGdmnHmSMbjo49zhzZi5G9O1CUn03XkgKmLXWURjLuqWQQEd/NGJSQDgvxlOHlvvsySLJK47ghTWdaDezajjevORIgQrE0ZxDTO05abjwkUJO6LW1peSJp4rL0XlpcMldpeO6aNHaiRXk5zLvtJEQaPhy6R/ym5KZDXkFuNr8996AG+5NRUB2K87hxYmJuvuBAwJOQbOpycwh2rqJR2TdH0SdCLCsk3SNxR254O13X1kCm11K0Pm6tQ2tksNJw3VNp7kTjmdG6Gm802pWGxuvUcW2eiGTdbi1F533TORrX0T4iJpTpujQDOqO1WBqanRn6aK57KlUY0hna5eqUp0dpiD5ZgW2d9ajzkdB5z3TJg/C9ay0duU4yVmn4gXBjnbchZZXJI2QN16bLQoXIDkdnPeq1DrWJAvRZUToHF75MbZIaJ4OVhvPZVtxEpuTqHbWmX4bXbvT44vWPkB1Z2kRpt9h0P3ZalUYrMWsyVml4I0ZTFW1OWemWl1kPTXNTtVtKpnXkHjpEBWXoet5NuKdah8rIaKXhfJrqvE0NCjIhe8okyrc0MrceMzmmoYsMa/ZJkblKww2F687b9mgrbjFTMaN0o/u6Mq0jNyFLJ+FlRDJT2TdGxioN751IbWXE78vVfEdbi5811eiPDWVmR56pgwpvnobWrLdW4qDKXKXh+hnayojflNxM7RR0xzR0oje9NzPr0bc0DMg0TcYqDTtPQ5e8VtKSU0xmXpVDJqfc6iZT239jZK7SMJQF49FWLJxMfWhS8paxVoqNaaQOnZeX7MrL6SKDlYbzaWqkY8osz+R5GjrwrscbdGQimZreq5Pw851Zk1sTIWOVhh/TsNlTGSUv3bSWYGM60Zrem6E9jIl5Gqb6smgy9JYGYhptZJKdh/4ZsXrlWVpOpqb36kTX+zSCpOtVzsnSOkqRBkKGJml5mJKr28LJ1E4hk7Epty3Hs0h1WqatRGdkrtJQfsqtGfltRVllms4IxzTMliOd2EB4y/EmD+vsyK2lkWbq6j2lYeYSdb+PwUP/TObM6hQy62piYwPhLccbVOi0NGwgPM3sdd+/XJBj5hJ1x1JMLGuQyagMTrrVO/tcmyiteMowpNEktUojzeytc5RGfm7jL6jPNFpLw7JYIHMtjeJ8p1/ZVVOnTWZrebQzVmnU1NUDkG/I0tCN155aS8PaV2kLMQ2dZKjOoH1hLgA799Rqk9lavAgZ26P6lkZbURpug2otDWtfxdZfasnU+mxf4CqNan2WRmshY3tUT2nktRGl4WEtjdRgDQ1LY/TqUAjAD47sb7gk+skxXYB04QXC25rSsDGNlmFrz5IIBbnZLL/nZNPFMELG9qg1tZ57qm0EwsMxDdvtpQIb07BYYpOxSuOUET0AKGwj2VNWV6QILxBuHVQWS0wy1j11++lDuf6kwW3GPZWbnUVtfb3pYuzztIUFCy2WlpCxPWpOdhZlRXmmi6GNf19+KFcdM5CCNmJZpRtd7qmBXdvpEWSxpIiMtTTaGgf0aM8BPdqbLsY+j24332s/PkLrrOJM5YufH09dyNajDqzSsFgMkmtqRc0089dLDubjJZu1yetQ3Ha8CuP6dTQq3yoNiyWAjWikhqMHd+XowV1NFyPjWHb3JNNFsErDYolFJr/u1bLv0hpm2GembWyQj244ho9uOMZ0MSzN5IQDuwMwYf/MGyV/7/B+NvBuaTHW0kgxPcsKTRdBC/+49BBWbNltuhgp56DeZRk70/fmU4Zws+lCWPZ5jFgaIvJNEflKREIiMsZEGSwt45D+nTj34ArTxbBYLJox5Z6aC5wFvG9IvsVisViagRH3lFJqHrSOoI6l9fPrs4fTo7TAdDEsFgv7QExDRC4FLgWoqLDukLbIOWN6my6CxWJxSZvSEJG3ge4xfvqZUuq/iZ5HKfUo8CjAmDFjbB6kxWKxGCRtSkMpdVy6zm2xWCwWM9h5GhaLxWJJGFMpt2eKyGpgPPA/EXnDRDksFovFkhymsqdeAF4wIdtisVgszce6pywWi8WSMFZpWCwWiyVhrNKwWCwWS8JYpWGxWCyWhLFKw2KxWCwJY5WGxWKxWBLGKg2LxWKxJIxVGhaLxWJJGKs0LBaLxZIwVmlYLBaLJWGs0rBYLBZLwlilYbFYLJaEsUrDYrFYLAljlYbFYrFYEsYqDYvFYrEkjFUaFovFYkkYqzQsFovFkjBWaVgsFoslYazSsFgsFkvCiFLKdBkSRkQqgQWmy9FK6AxsNl2IVoKtizC2LsLYugizv1KqJBUnyknFSTSyQCk1xnQhWgMiMsPWhYOtizC2LsLYuggjIjNSdS7rnrJYLBZLwlilYbFYLJaE2deUxqOmC9CKsHURxtZFGFsXYWxdhElZXexTgXCLxWKxmGVfszQsFovFYhCrNCwWi8WSMEaVhog8LiIbRWRu1P6rRGSBiHwlIr8O7L9RRBa7v50Y2D9aRL50f3tQRETndaSCVNSFiBSJyP9EZL57/D26ryMVpKpdBH5/Kfpc+wopfEbyRORREVnoto9v6LyOVJDCujjf7S/miMjrItJZ53WkgmTqQkQ6ici7IrJLRB6KOj75vlMpZewPOBIYBcwN7DsaeBvId793dT+HALOBfKAfsATIdn/7FBgPCPAaMNHkdZmqC6AIONo9Jg/4oK3WReD/zgKeCZ5rX/pL4TNyK3CHu50FdDZ9bSbqAmdu2kbv+oFfA780fW1proti4HDgMuChqPMk3XcatTSUUu8DW6N2Xw7co5SqcY/Z6O4/HfiHUqpGKbUMWAyMFZEeQHul1DTl1MLfgTO0XEAKSUVdKKWqlFLvusfuBWYCvbRcQApJRV0AiEg74FrgDi0FTwOpqgvgO8Dd7vEhpdQ+N1M6RXUh7l+xO6puD6zVUf5UkkxdKKV2K6U+BKqDBze372yNMY1BwBEi8omITBWRg939PYFVgeNWu/t6utvR+zOBZOvCR0TKgFOBKToKqoHm1MXtwH1Alb5iaiGpunDbAsDtIjJTRJ4TkW4ay5tOkqoLpVQtTuf6JY6yGAI8prPAaSReXcSjWX1na1QaOUAH4BDgOuBf7ogglq9NNbI/E0i2LgAQkRzgWeBBpdRSHQXVQFJ1ISIHAQOVUi/oK6I2km0XOTgW50dKqVHANOA3msqabpJtF7k4SmMkUA7MAW7UVNZ0E68u4tGsvrM1Ko3VwH+Uw6dACGfhsdVA78BxvXBGCquJdMF4+zOBZOvC41FgkVLqd7oKqoFk62I8MFpElgMfAoNE5D2tJU4fydbFFhxry1Ogz+H4wzOBZOviIACl1BLXJfMv4FCtJU4f8eqiseOT7jtbo9J4ETgGQEQG4QR0NwMvAeeJSL6I9AP2Az5VSq0DKkXkEFerXgz810jJU8+LJFEX7nF3AKXA1QbKm05eJLl28bBSqlwp1RcnCLhQKTXBRMHTwIskVxcKeBmY4P7/scDXmsucLl4kuWdkDTBERLq4/388ME93odPEi8Sui5g0u+/UFe2P9YfjQlkH1OJove+6F/oUMBcnkHtM4Pif4WRBLCAQ5QfGuMcvAR7Cnem+L/2loi5wRgoK5yGY5f59z/S1mWoXgd/7su9mT6XqGekDvI/jjpkCVJi+NoN1cZn7jMzBUaadTF+bhrpYjhM43+UeP8Tdn3TfaZcRsVgsFkvCtEb3lMVisVhaKVZpWCwWiyVhrNKwWCwWS8JYpWGxWCyWhLFKw2KxWCwJY5WGZZ9ERMpE5IeB7+Ui8nwa5JwmIjek+rzpREQmiMgrpsthyUxsyq1ln0RE+gKvKKWGmi5La0NEJgA/VUqdYrgolgzEWhqWfZV7gAEiMktE7hWRvt67BUTkEhF5UUReFpFlInKliFwrIl+IyHQR6egeN8B9n8LnIvKBiAyOFuKe6yF3+wn3nQMfi8hSETk7xvHF4rzTZLaIzBWRc939o91F5D4XkTfcFUYRkYEi8rZ7/Ey3TOJe01xx3nXgnWOCiLwnIs+L806Mp721hUTkJHffhzjLwVssaSHHdAEslmZyAzBUKXUQ+JZHkKE4i9IV4CyLfb1SaqSI/BZnuYTf4azRdZlSapGIjAP+iLsMQyP0wFmWZDDOUhXRLrGTgLVKqZPdcpW6i+T9HjhdKbXJVQJ34ixX/jTOctYviEgBzkDuLJw1kkbgrB30mYi8755/JHAgzhpBHwGHicgM4M9u2RcD/2ziGiyWZmOVhiVTeVcpVYmzts4OnOUiwFkSe7g479o4FHgusBBofgLnfVEpFQK+ltjLi38J/EZEfoXjPvtARIbiKLG3XFnZwDoRKcFZrvsFAKVUNYCIHA48q5SqBzaIyFTgYGAnzlpSq93jZuEskbILWKaUWuTufwq4NJFKsliSxSoNS6ZSE9gOBb6HcNp9FrDds1Saed4GS0srpRaKyGhgEnC3iLyJs7rsV0qp8cFjRaR9HBmNLWcdlF9P+Bm2wUmLFmxMw7KvUgmUNPeflVI7gWUi8k0AN44woqWFEpFyoEop9RTOOytG4SyY10VExrvH5IrIgW4ZVovIGe7+fBEpwllY8FwRyXZXYz0SdxXjOMwH+onIAPf7+S29DoslHlZpWPZJlFJbgI/cYPG9zTzNZOC7IjIb+ArnFaEtZRjwqes6+hnOe7n3AmcDv3JlzSL8DoeLgB+JyBzgY6A7jmUyB+cd1+8A/6eUWh9PoOvWuhT4nxsIX5GC67BYYmJTbi0Wi8WSMNbSsFgsFkvCWKVhsVgsloSxSsNisVgsCWOVhsVisVgSxioNi8VisSSMVRoWi8ViSRirNCwWi8WSMP8PngLdXWu5wzoAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 432x288 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "## plot another sample\n",
    "\n",
    "sample_num = 14\n",
    "sample_freq = 125.\n",
    "ecg_sample = ecg_data_resample[sample_num]\n",
    "time_in_second = np.arange(0, len(ecg_sample)) / sample_freq\n",
    "\n",
    "beat_loc_sample = ecg_correct_peak_location[sample_num]\n",
    "beat_value = np.take(ecg_sample, beat_loc_sample, axis=0)\n",
    "beat_location_in_second = beat_loc_sample / sample_freq\n",
    "\n",
    "plt.plot(time_in_second, ecg_sample)\n",
    "plt.scatter(beat_location_in_second, beat_value, c='r')\n",
    "plt.xlim(1600, 1610)\n",
    "plt.xlabel('time in second')\n",
    "plt.ylabel('ECG value in mV')\n",
    "plt.title('ECG value over time with beat overlay')\n",
    "plt.show()\n",
    "plt.clf()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "212c6b13-e96a-4e36-b504-5cc446b1b07d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Progress: [##################################################] 100.0%\n",
      "Data length: 48 Label length: 48\n"
     ]
    }
   ],
   "source": [
    "## Extract signal beat by beat\n",
    "\"\"\"\n",
    "    ecg_data - ecg value for all record\n",
    "    ecg_peak_annotations - beat location for all record\n",
    "    beat_type_annotations - beat label for all record\n",
    "\"\"\"\n",
    "\n",
    "## We only looking to classify these 5 type from 0 to 4\n",
    "accepted_labels = [0, 1, 2, 3, 4]\n",
    "\n",
    "def check_for_array_overflow(end_position, max_len):\n",
    "    if end_position > max_len:\n",
    "        end_poistion = max_len\n",
    "    return end_position\n",
    "\n",
    "bad_label = []\n",
    "## extract beat signal starting from peak of the beat to 1.2 * period where period is the interval between beat\n",
    "def extract_beats(ecg_values, beat_locs, beat_labels, accepted_labels):\n",
    "    signals = []\n",
    "    labels = []\n",
    "    max_len = len(ecg_values)\n",
    "    # skip last beat since there is no follow-up beat after it\n",
    "    for i in range(len(beat_locs) - 1):\n",
    "        ## only handle beat with N, V, Q, S, F label\n",
    "        if beat_labels[i] in accepted_labels:\n",
    "            start = beat_locs[i]\n",
    "            ## get 1.2 * interval between beat\n",
    "            period = int((beat_locs[i+1] - beat_locs[i]) * 1.2)\n",
    "            end = start + period\n",
    "            end = check_for_array_overflow(end, max_len)\n",
    "            \n",
    "            signals.append(ecg_values[start: end])\n",
    "            labels.append(beat_labels[i])\n",
    "        else:\n",
    "            bad_label.append(beat_labels[i])\n",
    "    \n",
    "    return signals, labels\n",
    "\n",
    "# progress bar to check if the program running\n",
    "def update_progress(progress):\n",
    "    bar_length = 50\n",
    "    if isinstance(progress, int):\n",
    "        progress = float(progress)\n",
    "    if not isinstance(progress, float):\n",
    "        progress = 0\n",
    "    if progress < 0:\n",
    "        progress = 0\n",
    "    if progress >= 1:\n",
    "        progress = 1\n",
    "        \n",
    "    block = int(round(bar_length * progress))\n",
    "\n",
    "    clear_output(wait = True)\n",
    "    text = \"Progress: [{0}] {1:.1f}%\".format( \"#\" * block + \"-\" * (bar_length - block), progress * 100)\n",
    "    print(text)\n",
    "    \n",
    "ecg_signals = []\n",
    "ecg_labels = []\n",
    "\n",
    "\n",
    "beat_type_annotations = []\n",
    "with h5py.File(raw_data_dir / 'mit_raw_data.h5', 'r') as file:\n",
    "    ## only get the second signal which is ii - chest ECG\n",
    "    data_group = file['label']\n",
    "    total = len(data_group.keys())\n",
    "    index = 0\n",
    "    for key in data_group.keys():\n",
    "        temp_peak_data = file['label/{}'.format(key)][:]\n",
    "        beat_type_annotations.append(temp_peak_data)\n",
    "        index += 1\n",
    "        update_progress((index)/ float(total))\n",
    "        \n",
    "    \n",
    "\n",
    "for i in range(len(ecg_data_norm)):\n",
    "    signal, label = extract_beats(ecg_data_resample[i], ecg_correct_peak_location[i], beat_type_annotations[i], accepted_labels)\n",
    "    ecg_signals.append(signal)\n",
    "    ecg_labels.append(label)\n",
    "    update_progress((i + 1) / float(len(ecg_data_norm)))\n",
    "    \n",
    "## check if the data and label have equal length\n",
    "print('Data length:', len(ecg_signals), 'Label length:', len(ecg_labels))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "4374b6b8-8857-42f2-9a92-bfe7b0eb393b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 1080x360 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "## plot one of the extract beat with length of 1.2 period\n",
    "beat = ecg_signals[0][115]\n",
    "# sampling frequency 360 Hz\n",
    "time_in_seconds = np.arange(len(beat)) / 360.\n",
    "\n",
    "plt.rcParams[\"figure.figsize\"]= 15, 5\n",
    "plt.plot(time_in_seconds, beat)\n",
    "plt.xlabel('time in second')\n",
    "plt.ylabel('ECG value in mV')\n",
    "plt.title('ECG value for one beat')\n",
    "plt.show()\n",
    "plt.clf()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "70dd3bfc-b304-4315-b049-a4b03930d677",
   "metadata": {},
   "source": [
    "# 1. Data split"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4e61750c-434a-4fb4-8f01-238083364401",
   "metadata": {},
   "source": [
    "## 1.1 Inter-patient split"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "b2e62a13-aefa-4da1-a350-e5587b0b1c3c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 1080x360 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import copy\n",
    "ecg_signals_zeropad = copy.deepcopy(ecg_signals)\n",
    "\n",
    "for i in range(len(ecg_signals)):\n",
    "    for j in range(len(ecg_signals[i])):\n",
    "\n",
    "        zero_pad_max_length = 1024\n",
    "        pad_length = zero_pad_max_length - len(ecg_signals[i][j])\n",
    "        if pad_length <=0:\n",
    "            zero_pad_data = ecg_signals[i][j][:zero_pad_max_length]\n",
    "        else:\n",
    "            zero_pad_data = np.pad(ecg_signals[i][j], (0,pad_length),'constant')\n",
    "        ecg_signals_zeropad[i][j] = zero_pad_data\n",
    "        \n",
    "\n",
    "## plot a zero padded signal\n",
    "ecg_sample = ecg_signals_zeropad[10][100]\n",
    "\n",
    "# sampling frequency 125 Hz\n",
    "time_in_second = np.arange(len(ecg_sample)) / 125.\n",
    "\n",
    "plt.plot(time_in_second, ecg_sample, c='b', label='125 Hz')\n",
    "plt.xlabel('time in second')\n",
    "plt.ylabel('ECG value in mV')\n",
    "plt.title('Zero padded ECG signal for one beat')\n",
    "plt.legend()\n",
    "plt.show()\n",
    "plt.clf()\n",
    "\n",
    "# ecg_signals_zeropad: 48 patients x number_of_beats x 256\n",
    "# ecg_labels: 48 patients x number_of_beats\n",
    "\n",
    "## Split train and test datasets with record number\n",
    "## Train dataset record number: 101, 106, 108, 109, 112, 114, 115,116, 118, 119, 122, 124, 201, 203, 205, 207, 208, 209, 215,220, 223, and 230,\n",
    "## Test dataset record number: 100, 103, 105, 110, 113, 117, 121, 123, 200, 202, 210, 212, 213,214, 219, 221, 222, 228, 231, 232, and 234\n",
    "\n",
    "train_record_list = [101, 106, 108, 109, 112, 114, 115, 116, 118, 119, 122, 124, 201, 203, 205, 207, 208, 209, 215, 220, 223, 230]\n",
    "test_record_list = [100, 103, 105, 110, 111, 113, 117, 121, 123, 200, 202, 210, 212, 213,214, 219, 221, 222, 228, 231, 232, 233, 234]\n",
    "train_indices = [i for i in range(len(record_list)) if int(record_list[i]) in train_record_list]\n",
    "test_indices = [i for i in range(len(record_list)) if int(record_list[i]) in test_record_list]\n",
    "\n",
    "train_signals = [ecg_signals_zeropad[i][:][:] for i in train_indices]\n",
    "train_labels = [ecg_labels[i][:] for i in train_indices]\n",
    "test_signals = [ecg_signals_zeropad[i][:][:] for i in test_indices]\n",
    "test_labels = [ecg_labels[i][:] for i in test_indices]\n",
    "\n",
    "train_data = [beat_signal for patient in train_signals for beat_signal in patient]\n",
    "train_labels = [beat_label for patient in train_labels for beat_label in patient]\n",
    "test_data = [beat_signal for patient in test_signals for beat_signal in patient]\n",
    "test_labels = [beat_label for patient in test_labels for beat_label in patient]\n",
    "\n",
    "train_data = np.array(train_data)\n",
    "train_labels = np.array(train_labels)\n",
    "test_data = np.array(test_data)\n",
    "test_labels = np.array(test_labels)\n",
    "\n",
    "# TODO:\n",
    "# Save ECG 1D data sets\n",
    "with h5py.File(process_dir / 'ECG_MIT-BIH_processed_data_interpatient_125Hz.h5', 'w') as file:\n",
    "    train_set_d = file.create_dataset(\"train_data\", data=train_data)\n",
    "    train_set_l = file.create_dataset(\"train_labels\", data=train_labels)\n",
    "    test_set_d = file.create_dataset(\"test_data\", data=test_data)\n",
    "    test_set_l = file.create_dataset(\"test_labels\", data=test_labels)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "a53ef9f6-aa89-4327-94ac-7c5a78d16c36",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train data length: (50999, 1024)\n",
      "Train label length: (50999,)\n",
      "Counter({0: 45845, 2: 3788, 1: 943, 3: 415, 4: 8})\n",
      "Test data length: (49690, 1024)\n",
      "Test label length: (49690,)\n",
      "Counter({0: 44238, 2: 3221, 1: 1836, 3: 388, 4: 7})\n"
     ]
    }
   ],
   "source": [
    "from collections import Counter\n",
    "\n",
    "# Double check saved data\n",
    "# read data from h5 file\n",
    "file = h5py.File(process_dir / 'ECG_MIT-BIH_processed_data_interpatient_125Hz.h5', 'r')\n",
    "train_set_d = file['train_data'][:]\n",
    "train_set_l = file['train_labels'][:]\n",
    "test_set_d = file['test_data'][:]\n",
    "test_set_l = file['test_labels'][:]\n",
    "file.close()\n",
    "\n",
    "## Check length\n",
    "print('Train data length:', train_set_d.shape)\n",
    "print('Train label length:', train_set_l.shape)\n",
    "print(Counter(train_set_l))\n",
    "print('Test data length:', test_set_d.shape)\n",
    "print('Test label length:', test_set_l.shape)\n",
    "print(Counter(test_set_l))\n",
    "\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "24e779b8-2291-4a35-9bd3-7bd1476f7c36",
   "metadata": {},
   "source": [
    "## 1.2 Intra-patient split"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "a0d02d95-735a-4888-b65e-d9183e3df094",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "109446 109446\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 1080x360 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import copy\n",
    "ecg_signals_zeropad = copy.deepcopy(ecg_signals)\n",
    "\n",
    "for i in range(len(ecg_signals)):\n",
    "    for j in range(len(ecg_signals[i])):\n",
    "\n",
    "        zero_pad_max_length = 1024\n",
    "        pad_length = zero_pad_max_length - len(ecg_signals[i][j])\n",
    "        if pad_length <=0:\n",
    "            zero_pad_data = ecg_signals[i][j][:zero_pad_max_length]\n",
    "        else:\n",
    "            zero_pad_data = np.pad(ecg_signals[i][j], (0,pad_length),'constant')\n",
    "        ecg_signals_zeropad[i][j] = zero_pad_data\n",
    "        \n",
    "\n",
    "## plot a zero padded signal\n",
    "ecg_sample = ecg_signals_zeropad[10][100]\n",
    "\n",
    "# sampling frequency 125 Hz\n",
    "time_in_second = np.arange(len(ecg_sample)) / 125.\n",
    "\n",
    "plt.plot(time_in_second, ecg_sample, c='b', label='125 Hz')\n",
    "plt.xlabel('time in second')\n",
    "plt.ylabel('ECG value in mV')\n",
    "plt.title('Zero padded ECG signal for one beat')\n",
    "plt.legend()\n",
    "plt.show()\n",
    "plt.clf()\n",
    "\n",
    "\n",
    "# ecg_signals_zeropad: 48 patients x number_of_beats x 2520\n",
    "# ecg_labels: 48 patients x number_of_beats\n",
    "\n",
    "## Split train and test datasets 80/20 stratified by class type\n",
    "from sklearn.model_selection import StratifiedShuffleSplit\n",
    "\n",
    "ecg_signals_zeropad_flatten = np.array([x for xs in ecg_signals_zeropad for x in xs])\n",
    "ecg_labels_flatten = np.array([x for xs in ecg_labels for x in xs])\n",
    "\n",
    "print(len(ecg_signals_zeropad_flatten), len(ecg_labels_flatten))\n",
    "\n",
    "sss = StratifiedShuffleSplit(n_splits=5, test_size=0.2, random_state=0)\n",
    "for train_index, test_index in sss.split(ecg_signals_zeropad_flatten, ecg_labels_flatten):\n",
    "    train_signals, test_signals = ecg_signals_zeropad_flatten[train_index], ecg_signals_zeropad_flatten[test_index]\n",
    "    train_labels, test_labels = ecg_labels_flatten[train_index], ecg_labels_flatten[test_index]\n",
    "    \n",
    "train_data = np.array(train_signals)\n",
    "train_labels = np.array(train_labels)\n",
    "test_data = np.array(test_signals)\n",
    "test_labels = np.array(test_labels)\n",
    "\n",
    "# Save ECG 1D data sets\n",
    "with h5py.File(process_dir / 'ECG_MIT-BIH_processed_data_intrapatient_125Hz.h5', 'w') as file:\n",
    "    train_set_d = file.create_dataset(\"train_data\", data=train_data)\n",
    "    train_set_l = file.create_dataset(\"train_labels\", data=train_labels)\n",
    "    test_set_d = file.create_dataset(\"test_data\", data=test_data)\n",
    "    test_set_l = file.create_dataset(\"test_labels\", data=test_labels)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "b8d4f5f3-03b2-4b7e-80ff-2cd15b23c985",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train data length: (87556, 1024)\n",
      "Train label length: (87556,)\n",
      "Counter({0: 72471, 4: 6431, 2: 5789, 1: 2223, 3: 642})\n",
      "Test data length: (21890, 1024)\n",
      "Test label length: (21890,)\n",
      "Counter({0: 18118, 4: 1608, 2: 1447, 1: 556, 3: 161})\n"
     ]
    }
   ],
   "source": [
    "from collections import Counter\n",
    "\n",
    "# Double check saved data\n",
    "# read data from h5 file\n",
    "file = h5py.File(process_dir / 'ECG_MIT-BIH_processed_data_intrapatient_125Hz.h5', 'r')\n",
    "train_set_d = file['train_data'][:]\n",
    "train_set_l = file['train_labels'][:]\n",
    "test_set_d = file['test_data'][:]\n",
    "test_set_l = file['test_labels'][:]\n",
    "file.close()\n",
    "\n",
    "## Check length\n",
    "print('Train data length:', train_set_d.shape)\n",
    "print('Train label length:', train_set_l.shape)\n",
    "print(Counter(train_set_l))\n",
    "print('Test data length:', test_set_d.shape)\n",
    "print('Test label length:', test_set_l.shape)\n",
    "print(Counter(test_set_l))\n",
    "\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ba95cfef-636d-49f5-a998-c1fdad9b88a3",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}