day_survey_data.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "261e95ca",
   "metadata": {},
   "source": [
    "### Import packages:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "01308029",
   "metadata": {},
   "outputs": [],
   "source": [
    "# import dva_sdhdf_combine\n",
    "import imp\n",
    "import os\n",
    "import subprocess\n",
    "import h5py\n",
    "import numpy as np\n",
    "from astropy.time import Time\n",
    "import matplotlib.pyplot as plt\n",
    "from scipy.interpolate import griddata\n",
    "import datetime\n",
    "import matplotlib.dates as mdates\n",
    "from matplotlib.dates import HourLocator as HourLocator\n",
    "from matplotlib.dates import MinuteLocator as MinuteLocator\n",
    "from mpl_toolkits.axes_grid1 import make_axes_locatable\n",
    "from astropy import units as u\n",
    "from astropy.time import TimeDelta\n",
    "from ipywidgets import interact\n",
    "\n",
    "#### Change the directory to where the files are located\" ####\n",
    "day ='25'\n",
    "directory = '../DVA/Data_Files/DVA_Day_Surveys/'\n",
    "\n",
    "### Change the scan details to your current scan\n",
    "df = 0.5        \n",
    "dt = 6.9444431574083865e-06\n",
    "\n",
    "#TODO: actually do the scan properties definition in the beginning\n",
    "##############################################################"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "132afaa7",
   "metadata": {},
   "source": [
    "### Read in the file listing azimuth scan start and stop times:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "7fdd04b8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1052 2022-07-04T03:57:53.110 2022-07-04T04:15:55.184\n",
      "2565 2022-07-04T04:20:37.406 2022-07-04T04:38:39.310\n",
      "2566 2022-07-04T04:40:22.266 2022-07-04T04:58:24.003\n",
      "1271 2022-07-04T05:03:42.716 2022-07-04T05:21:44.818\n",
      "1272 2022-07-04T05:23:27.291 2022-07-04T05:41:29.292\n",
      "2857 2022-07-04T05:48:35.269 2022-07-04T06:06:37.317\n",
      "0124 2022-07-04T06:11:19.190 2022-07-04T06:29:21.101\n",
      "1637 2022-07-04T06:34:03.920 2022-07-04T06:52:06.005\n",
      "0342 2022-07-04T06:57:23.897 2022-07-04T07:15:25.930\n",
      "1927 2022-07-04T07:21:55.804 2022-07-04T07:39:58.034\n",
      "1928 2022-07-04T07:42:16.530 2022-07-04T08:00:18.319\n",
      "2001 2022-07-04T08:03:48.814 2022-07-04T08:21:51.062\n",
      "2002 2022-07-04T08:24:09.373 2022-07-04T08:42:11.545\n",
      "2075 2022-07-04T08:45:41.821 2022-07-04T09:03:44.188\n",
      "2148 2022-07-04T09:07:50.625 2022-07-04T09:25:52.832\n",
      "2149 2022-07-04T09:27:35.229 2022-07-04T09:45:37.044\n",
      "2150 2022-07-04T09:47:56.026 2022-07-04T10:05:57.828\n",
      "2151 2022-07-04T10:07:40.752 2022-07-04T10:25:42.662\n",
      "2152 2022-07-04T10:27:25.410 2022-07-04T10:45:27.414\n",
      "2153 2022-07-04T10:47:46.110 2022-07-04T11:05:48.028\n",
      "0858 2022-07-04T11:10:30.298 2022-07-04T11:28:32.281\n",
      "0859 2022-07-04T11:30:50.747 2022-07-04T11:48:52.934\n",
      "2372 2022-07-04T11:53:35.348 2022-07-04T12:11:37.677\n"
     ]
    }
   ],
   "source": [
    "scan_id = []    # The scan id number\n",
    "scan_start = []  # Start time of the scan (UTC)\n",
    "scan_stop = []   # Stop time of the scan (UTC)\n",
    "\n",
    "# Read in the data and store it in arrays:\n",
    "with open(directory+'DVAsurvey_phase1_day0'+day+'.txt') as fp:\n",
    "    for line in fp:       \n",
    "        scan_id.append(int(line.split()[0]))\n",
    "        scan_start.append(line.split()[1]+'T'+line.split()[2][0:12])\n",
    "        scan_stop.append(line.split()[3]+'T'+line.split()[4][0:12])\n",
    "        \n",
    "# Print out the scan numbers with their start and stop times:\n",
    "for i in range(0,len(scan_id)):\n",
    "    print(f\"{scan_id[i]:04}\",scan_start[i],scan_stop[i])\n",
    "\n",
    "# Convert start and stop times to Modified Julian Day (MJD).\n",
    "# This is needed for plotting and for selecting out data collected\n",
    "# between particular times:\n",
    "scan_start_mjd = Time(scan_start, format='isot',scale='utc').mjd\n",
    "scan_stop_mjd  = Time(scan_stop,  format='isot',scale='utc').mjd\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3adbc96b",
   "metadata": {},
   "source": [
    "## Read in scan files and stich them together:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "4737412e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1052\n",
      "<HDF5 file \"dva_survey_raw_scan_1052.h5\" (mode r)>\n",
      "2565\n",
      "<HDF5 file \"dva_survey_raw_scan_2565.h5\" (mode r)>\n",
      "2566\n",
      "<HDF5 file \"dva_survey_raw_scan_2566.h5\" (mode r)>\n",
      "1271\n",
      "<HDF5 file \"dva_survey_raw_scan_1271.h5\" (mode r)>\n",
      "1272\n",
      "<HDF5 file \"dva_survey_raw_scan_1272.h5\" (mode r)>\n",
      "2857\n",
      "<HDF5 file \"dva_survey_raw_scan_2857.h5\" (mode r)>\n",
      "124\n",
      "<HDF5 file \"dva_survey_raw_scan_0124.h5\" (mode r)>\n",
      "1637\n",
      "<HDF5 file \"dva_survey_raw_scan_1637.h5\" (mode r)>\n",
      "342\n",
      "<HDF5 file \"dva_survey_raw_scan_0342.h5\" (mode r)>\n",
      "1927\n",
      "<HDF5 file \"dva_survey_raw_scan_1927.h5\" (mode r)>\n",
      "1928\n",
      "<HDF5 file \"dva_survey_raw_scan_1928.h5\" (mode r)>\n",
      "2001\n",
      "<HDF5 file \"dva_survey_raw_scan_2001.h5\" (mode r)>\n",
      "2002\n",
      "<HDF5 file \"dva_survey_raw_scan_2002.h5\" (mode r)>\n",
      "2075\n",
      "<HDF5 file \"dva_survey_raw_scan_2075.h5\" (mode r)>\n",
      "2148\n",
      "<HDF5 file \"dva_survey_raw_scan_2148.h5\" (mode r)>\n",
      "2149\n",
      "<HDF5 file \"dva_survey_raw_scan_2149.h5\" (mode r)>\n",
      "2150\n",
      "<HDF5 file \"dva_survey_raw_scan_2150.h5\" (mode r)>\n",
      "2151\n",
      "<HDF5 file \"dva_survey_raw_scan_2151.h5\" (mode r)>\n",
      "2152\n",
      "<HDF5 file \"dva_survey_raw_scan_2152.h5\" (mode r)>\n",
      "2153\n",
      "<HDF5 file \"dva_survey_raw_scan_2153.h5\" (mode r)>\n",
      "858\n",
      "<HDF5 file \"dva_survey_raw_scan_0858.h5\" (mode r)>\n",
      "859\n",
      "<HDF5 file \"dva_survey_raw_scan_0859.h5\" (mode r)>\n",
      "2372\n",
      "<HDF5 file \"dva_survey_raw_scan_2372.h5\" (mode r)>\n"
     ]
    }
   ],
   "source": [
    "t_set = []\n",
    "az_set = []\n",
    "dec_set = []\n",
    "ra_set = []\n",
    "el_set = []\n",
    "noise_set = []\n",
    "trim_flag = []\n",
    "\n",
    "scan0 = f\"{scan_id[0]:04}\"\n",
    "\n",
    "# Use one of the scans to get the list of frequencies:\n",
    "file = h5py.File(directory+'dva_survey_raw_scan_'+scan0+'.h5','r')\n",
    "freq = file['data']['beam_0']['band_SB0']['frequency'][::12]/1e6\n",
    "\n",
    "# Create empty arrays for the power data:\n",
    "RR_set_raw = np.empty([0,len(freq)])\n",
    "LL_set_raw = np.empty([0,len(freq)])\n",
    "reRL_set_raw = np.empty([0,len(freq)])\n",
    "imRL_set_raw = np.empty([0,len(freq)])\n",
    "\n",
    "# Loop through all the scans in the \"scan_num\" list:\n",
    "for i in scan_id:\n",
    "    print(i)\n",
    "    # select the file:\n",
    "    file = h5py.File(directory+'dva_survey_raw_scan_'+f\"{i:04}\"+'.h5','r')\n",
    "    print(file)\n",
    "    \n",
    "    # access the correct location in the file structure:\n",
    "    dataset = file['data']['beam_0']['band_SB0']['scan_0']\n",
    "    \n",
    "    # Add the position and time data to the corresponding arrays:\n",
    "    # dec_set = np.concatenate([dec_set,dataset['metadata']['declination']])\n",
    "    # ra_set = np.concatenate([ra_set,dataset['metadata']['right_ascension']])\n",
    "    # el_set = np.concatenate([el_set,dataset['metadata']['elevation']])\n",
    "    # az_set = np.concatenate([az_set,dataset['metadata']['azimuth']])\n",
    "    t_set = np.concatenate([t_set,dataset['metadata']['utc']])\n",
    "    noise_set = np.concatenate([noise_set,dataset['metadata']['noise_state']]) #This is a \"mask\" for noise regions 1 = noise 0=all good\n",
    "    # trim_flag = np.concatenate([trim_flag,dataset['metadata']['trim_scan_flag']])\n",
    "    \n",
    "    # Add the spectrometer power data to the corresponding arrays:\n",
    "    freq_channel_increment = 12 #TODO: I'll have to change this to 1 once I am sure I'm reading the data correctly\n",
    "    RR_set_raw = np.concatenate([RR_set_raw,dataset['data'][:,0,::freq_channel_increment]],axis=0)\n",
    "    LL_set_raw = np.concatenate([LL_set_raw,dataset['data'][:,1,::freq_channel_increment]],axis=0)\n",
    "    reRL_set_raw = np.concatenate([reRL_set_raw,dataset['data'][:,2,::freq_channel_increment]],axis=0)\n",
    "    imRL_set_raw = np.concatenate([imRL_set_raw,dataset['data'][:,3,::freq_channel_increment]],axis=0)\n",
    "    \n",
    "t_set_plt = Time(t_set, format='isot',scale='utc').mjd"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "29db1ea5",
   "metadata": {},
   "source": [
    "### Import Leo's functions for RFI Excision"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e85baeba",
   "metadata": {},
   "source": [
    "# NEW RFI_Excision functions (WORK IN PROGRESS)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "b9cd4790",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1052\n",
      "<HDF5 file \"dva_survey_raw_scan_1052.h5\" (mode r)>\n",
      "2565\n",
      "<HDF5 file \"dva_survey_raw_scan_2565.h5\" (mode r)>\n",
      "2566\n",
      "<HDF5 file \"dva_survey_raw_scan_2566.h5\" (mode r)>\n",
      "1271\n",
      "<HDF5 file \"dva_survey_raw_scan_1271.h5\" (mode r)>\n",
      "1272\n",
      "<HDF5 file \"dva_survey_raw_scan_1272.h5\" (mode r)>\n",
      "2857\n",
      "<HDF5 file \"dva_survey_raw_scan_2857.h5\" (mode r)>\n",
      "124\n",
      "<HDF5 file \"dva_survey_raw_scan_0124.h5\" (mode r)>\n",
      "1637\n",
      "<HDF5 file \"dva_survey_raw_scan_1637.h5\" (mode r)>\n",
      "342\n",
      "<HDF5 file \"dva_survey_raw_scan_0342.h5\" (mode r)>\n",
      "1927\n",
      "<HDF5 file \"dva_survey_raw_scan_1927.h5\" (mode r)>\n",
      "1928\n",
      "<HDF5 file \"dva_survey_raw_scan_1928.h5\" (mode r)>\n",
      "2001\n",
      "<HDF5 file \"dva_survey_raw_scan_2001.h5\" (mode r)>\n",
      "2002\n",
      "<HDF5 file \"dva_survey_raw_scan_2002.h5\" (mode r)>\n",
      "2075\n",
      "<HDF5 file \"dva_survey_raw_scan_2075.h5\" (mode r)>\n",
      "2148\n",
      "<HDF5 file \"dva_survey_raw_scan_2148.h5\" (mode r)>\n",
      "2149\n",
      "<HDF5 file \"dva_survey_raw_scan_2149.h5\" (mode r)>\n",
      "2150\n",
      "<HDF5 file \"dva_survey_raw_scan_2150.h5\" (mode r)>\n",
      "2151\n",
      "<HDF5 file \"dva_survey_raw_scan_2151.h5\" (mode r)>\n",
      "2152\n",
      "<HDF5 file \"dva_survey_raw_scan_2152.h5\" (mode r)>\n",
      "2153\n",
      "<HDF5 file \"dva_survey_raw_scan_2153.h5\" (mode r)>\n",
      "858\n",
      "<HDF5 file \"dva_survey_raw_scan_0858.h5\" (mode r)>\n",
      "859\n",
      "<HDF5 file \"dva_survey_raw_scan_0859.h5\" (mode r)>\n",
      "2372\n",
      "<HDF5 file \"dva_survey_raw_scan_2372.h5\" (mode r)>\n",
      "[b'2022-07-04T03:57:53.200004Z' b'2022-07-04T03:57:53.800004Z'\n",
      " b'2022-07-04T03:57:54.400004Z' ... b'2022-07-04T12:11:36.400004Z'\n",
      " b'2022-07-04T12:11:37.000004Z' b'2022-07-04T12:11:37.600004Z']\n"
     ]
    }
   ],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "b826cf9e",
   "metadata": {},
   "source": [
    "### Read in the times when the noise source was turned on, and mask this out in the power data:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "618d761c",
   "metadata": {},
   "outputs": [
    {
     "ename": "FileNotFoundError",
     "evalue": "[Errno 2] No such file or directory: '../DVA/Data_Files/DVA_Day_Surveys/noise_mini_survey_part1.txt'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mFileNotFoundError\u001b[0m                         Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-10-1faa98045d52>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      2\u001b[0m \u001b[0mt_noise2\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;33m[\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      3\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 4\u001b[1;33m \u001b[1;32mwith\u001b[0m \u001b[0mopen\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mdirectory\u001b[0m\u001b[1;33m+\u001b[0m\u001b[1;34m'noise_mini_survey_part1.txt'\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;32mas\u001b[0m \u001b[0mfp\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m      5\u001b[0m     \u001b[1;32mfor\u001b[0m \u001b[0mline\u001b[0m \u001b[1;32min\u001b[0m \u001b[0mfp\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      6\u001b[0m         \u001b[0mt_noise1\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mline\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0msplit\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m0\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m+\u001b[0m\u001b[1;34m'T'\u001b[0m\u001b[1;33m+\u001b[0m\u001b[0mline\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0msplit\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m0\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;36m12\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mFileNotFoundError\u001b[0m: [Errno 2] No such file or directory: '../DVA/Data_Files/DVA_Day_Surveys/noise_mini_survey_part1.txt'"
     ]
    }
   ],
   "source": [
    "t_noise1 = []\n",
    "t_noise2 = []\n",
    "\n",
    "with open(directory+'noise_mini_survey_part1.txt') as fp:\n",
    "    for line in fp:       \n",
    "        t_noise1.append(line.split()[0]+'T'+line.split()[1][0:12])\n",
    "        t_noise2.append(line.split()[2]+'T'+line.split()[3][0:12])\n",
    "\n",
    "t_noise1_plt = Time(t_noise1, format='isot',scale='utc').mjd\n",
    "t_noise2_plt = Time(t_noise2, format='isot',scale='utc').mjd\n",
    "\n",
    "# Buffer time (in seconds) around data points where noise source\n",
    "# is being turned on or off:\n",
    "t_buff = 1./(3600.*24.)\n",
    "\n",
    "# Make copies of the arrays in which noise will be masked out:\n",
    "RR_set = RR_set_raw.copy()\n",
    "LL_set = LL_set_raw.copy()\n",
    "reRL_set = reRL_set_raw.copy()\n",
    "imRL_set = imRL_set_raw.copy()\n",
    "\n",
    "print(len(LL_set))\n",
    "\n",
    "# #Extract masks TODO: Currenct my Get_RFI_Excision_Mask only works for a single frequency\n",
    "# time_steps = 30\n",
    "# threshold = 4\n",
    "# RR_mask = Get_RFI_Excision_Mask(t_plt, RR_set, time_steps, threshold)\n",
    "# LL_mask = Get_RFI_Excision_Mask(t_plt, LL_set, time_steps, threshold)\n",
    "# reRL_mask = Get_RFI_Excision_Mask(t_plt, reRL_set, time_steps, threshold)\n",
    "# imRL_mask = Get_RFI_Excision_Mask(t_plt, imRL_set, time_steps, threshold)\n",
    "\n",
    "# Loop through times when noise source was turned on and replace\n",
    "# data values with NaN at those times:\n",
    "for i in range(0,len(t_noise1)):\n",
    "    wnoise_sub_rem = np.where( (t_plt >= t_noise1_plt[i]-t_buff) & (t_plt <= t_noise2_plt[i]+t_buff) )[0]\n",
    "    RR_set[wnoise_sub_rem,:] = np.nan\n",
    "    LL_set[wnoise_sub_rem,:] = np.nan\n",
    "    reRL_set[wnoise_sub_rem,:] = np.nan\n",
    "    imRL_set[wnoise_sub_rem,:] = np.nan"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "336510ee",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "d5a6e09201a148ccb42518f0de11e235",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "interactive(children=(Checkbox(value=True, description='waterfall_enabled'), Output()), _dom_classes=('widget-…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<function __main__.DVA_Visualization(waterfall_enabled)>"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#TODO: Maybe I could create an interactive plot that if I tick a box I could flip to a power vs frequency plot or power vs time plot\n",
    "#I should have a knob for changing frequency and time\n",
    "#I could also introduce a vertical line to show which slice I'm currently at to help navigating through the data\n",
    "df = freq[1]-freq[0]\n",
    "\n",
    "def DVA_Waterfall_View(scan_id, show_all_scans):\n",
    "    #TODO: Add another DVA_Waterfall interactive_function such that I can change between LL_Set, RR_set, etc...\n",
    "    power_min = 70\n",
    "    power_max = 78\n",
    "    if not show_all_scans:\n",
    "        w = np.where(np.array(scan_num) == scan_id)[0][0]\n",
    "        t1_plt = scan_start_mjd[w]\n",
    "        t2_plt = scan_stop_mjd[w]\n",
    "        ######################################\n",
    "        wplot = np.where( (t_plt <= t2_plt) & (t_plt >= t1_plt) )\n",
    "\n",
    "        time_plot = t_plt[wplot]\n",
    "\n",
    "        fig,axs = plt.subplots(1,1,figsize=(15,10)) \n",
    "        fs = 16\n",
    "\n",
    "        im = axs.imshow(10.*np.log10(LL_set[wplot].T),aspect='auto',vmin=power_min,vmax=power_max,origin='lower',\n",
    "                    extent=[time_plot[0],time_plot[-1],freq[0],freq[-1]])\n",
    "\n",
    "        divider = make_axes_locatable(axs)\n",
    "        cax = divider.append_axes('right', size='2%', pad=0.05)\n",
    "        cbar = fig.colorbar(im, cax=cax, orientation='vertical')\n",
    "        cbar.ax.tick_params(labelsize=fs) \n",
    "        cbar.set_label('Power (dB)', fontsize=fs)\n",
    "\n",
    "        axs.set_xlim(time_plot[0],time_plot[-1])\n",
    "        axs.set_ylim(freq[0],freq[-1])\n",
    "        axs.tick_params(axis='both', labelsize=fs)\n",
    "        axs.xaxis.set_major_formatter(mdates.DateFormatter('%H:%M:%S'))\n",
    "        axs.fmt_xdata = mdates.DateFormatter('%H:%M:%S')\n",
    "        axs.set_xlabel('Time (UTC)',fontsize=fs)        \n",
    "        axs.set_ylabel('Frequency (MHz)',fontsize=fs)\n",
    "    else:\n",
    "        fig,axs = plt.subplots(1,1,figsize=(15,10)) \n",
    "        fs = 16\n",
    "\n",
    "        im = axs.imshow(10.*np.log10(LL_set.T),aspect='auto',vmin=power_min,vmax=power_max,origin='lower',\n",
    "                    extent=[t_plt[0],t_plt[-1],freq[0],freq[-1]])\n",
    "\n",
    "        divider = make_axes_locatable(axs)\n",
    "        cax = divider.append_axes('right', size='2%', pad=0.05)\n",
    "        cbar = fig.colorbar(im, cax=cax, orientation='vertical')\n",
    "        cbar.ax.tick_params(labelsize=fs) \n",
    "        cbar.set_label('Power (dB)', fontsize=fs)\n",
    "\n",
    "        axs.set_xlim(t_plt[0],t_plt[-1])\n",
    "        axs.set_ylim(freq[0],freq[-1])\n",
    "        axs.tick_params(axis='both', labelsize=fs)\n",
    "        axs.xaxis.set_major_formatter(mdates.DateFormatter('%H:%M:%S'))\n",
    "        axs.fmt_xdata = mdates.DateFormatter('%H:%M:%S')\n",
    "        axs.set_xlabel('Time (UTC)',fontsize=fs)        \n",
    "        axs.set_ylabel('Frequency (MHz)',fontsize=fs)\n",
    "\n",
    "def DVA_Cross_Sections(scan_id, freq_chosen, time_idx, freq_cross_section):\n",
    "    freq_measured = np.where(abs(freq-freq_chosen)<df)[0][0]\n",
    "    \n",
    "    w = np.where(np.array(scan_num) == scan_id)[0][0]\n",
    "    t1 = scan_start[w]\n",
    "    t2 = scan_stop[w]\n",
    "    t1_plt = scan_start_mjd[w]\n",
    "    t2_plt = scan_stop_mjd[w]\n",
    "    \n",
    "    wplot = np.where((t_plt>=t1_plt) & (t_plt<=t2_plt))\n",
    "    \n",
    "    polarized_set = Get_Polarized_Set(reRL_set, imRL_set, freq_measured)\n",
    "    time_steps = 30\n",
    "    threshold = 4\n",
    "    polarized_mask = Get_RFI_Excision_Mask(t_plt[wplot], polarized_set[wplot], time_steps, threshold)\n",
    "    LL_set_with_polarized_mask = Apply_RFI_Excision_Mask(polarized_mask, LL_set[wplot])\n",
    "    \n",
    "    fs = 12\n",
    "    fig, axs = plt.subplots(1,1,figsize=(12,6))\n",
    "    axs.scatter(ra_set_deg[wplot], dec_set[wplot],s=2,c=10.*np.log10(LL_set[wplot,freq_measured]),\n",
    "                cmap='viridis',vmin=70.5, vmax=71.5)\n",
    "    axs.set_xlabel('RA (deg.)',fontsize=fs)\n",
    "    axs.set_ylabel('dec (deg.)',fontsize=fs)\n",
    "    axs.tick_params(axis=\"x\", labelsize=fs)\n",
    "    axs.tick_params(axis=\"y\", labelsize=fs)\n",
    "    axs.set_xlim(360,0)\n",
    "    axs.set_ylim(0,90)\n",
    "    axs.set(aspect='equal')\n",
    "    axs.grid()\n",
    "    \n",
    "    \n",
    "    fig,axs1 = plt.subplots(1,1,figsize=(16,6))  \n",
    "    # TODO: use the log of LL_set_clean\n",
    "\n",
    "    if(freq_cross_section):\n",
    "        time_chosen = int(time_idx/len(LL_set_with_polarized_mask)) #NOTE: I have no idea what 100 actually means\n",
    "        axs1.plot(freq, LL_set_with_polarized_mask[time_chosen,:], label = 'LL_set with polarized mask')   #I need to plot freq vs power\n",
    "        axs1.vlines(freq_chosen, 0 , 100e9, color = 'red')\n",
    "        axs1.set_ylim(0, np.max(LL_set_with_polarized_mask[time_chosen,:]))\n",
    "        axs1.set_xlabel('Frequency',fontsize=fs)\n",
    "        axs1.set_ylabel('Power',fontsize=fs)\n",
    "    else:\n",
    "        # axs.plot(t_plt_one_scan,wplot[0])\n",
    "        axs1.plot(t_plt[wplot], LL_set[wplot,freq_measured][0], label = 'LL_set unmasked RFI')\n",
    "        axs1.plot(t_plt[wplot], LL_set_with_polarized_mask[:,freq_measured], label = 'LL_set with polarized mask')\n",
    "        axs1.plot(t_plt[wplot], polarized_set[wplot], label = 'polarized set')\n",
    "        axs1.set_ylim(0, np.nanmax(LL_set_with_polarized_mask[:,freq_measured]))\n",
    "        axs1.vlines(t_plt[time_idx], 0 , 100e9, color = 'red')\n",
    "\n",
    "        axs1.xaxis.set_major_formatter(mdates.DateFormatter('%H:%M:%S'))\n",
    "        axs1.fmt_xdata = mdates.DateFormatter('%H:%M:%S')\n",
    "        axs1.set_xlabel('Time (UTC)',fontsize=fs)\n",
    "        axs1.set_ylabel('Power',fontsize=fs)\n",
    "        axs1.legend()\n",
    "\n",
    "def DVA_Visualization(waterfall_enabled):             #TODO: use t_plt, polarized_plot, ymasked as inputs on this function so I can use it at different locations\n",
    "    if waterfall_enabled:\n",
    "        interact(DVA_Waterfall_View, scan_id = (2,12), show_all_scans = False)\n",
    "    else:\n",
    "        interact(DVA_Cross_Sections, scan_id = (2,12), freq_chosen = (350, 1000, df), freq_cross_section = False, time_idx = (0,len(t_plt)-1))\n",
    "\n",
    "\n",
    "interact(DVA_Visualization, waterfall_enabled = True)\n",
    "\n",
    "#TODO: I could try to figure out if I could zoom in on time, and adjust the dec vs RA plot accordingly\n",
    "#TODO: plot power in DB"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2744f954",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "input starting frequency: 850\n",
      "closest frequency measured: 849.75\n",
      "possible RFI events: 4\n",
      "confirmed RFI events: 4\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Text(0, 0.5, 'Frequency (MHz)')"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAA7oAAAJcCAYAAADXbthGAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8QVMy6AAAACXBIWXMAAAsTAAALEwEAmpwYAACg00lEQVR4nO3dd7wtWVnn/89zTnfTjYBNVEBJwgQQQadVECQoP0EJCgKKYAsoWX8qiuDob0QBMQxJkdAqgoMIiMCADlnARBCRFhqU2AwqNKHJdLr3PL8/ap9796ldYVXVqqq1qr7v1+u+7r17165aVbXC81Q0d0dERERERERkKfbmLoCIiIiIiIhITEp0RUREREREZFGU6IqIiIiIiMiiKNEVERERERGRRVGiKyIiIiIiIouiRFdEREREREQWRYmuiIiIiIiI1DKzN5mZ1/x59Waa6zVMc+bUZT5l6gWKiIiIiIhIVh4OXKn02S2BJwOvKH3+xIrPvjhSuWop0RUREREREZFa7v7e8mdm9iDgUuCFpa8+7O5vnaRgDXTpsoiIiIiIiAQzszOAewGvdPcL5y5PFSW6IiIiIiIi0sU9gCsCz6v47olmdszMPm9mrzCzm05cNgDM3edYbjJOs8v56XzV3MUQEREREREJcjFf5lK/xADuePuv8s9ceHzQ/P7xny85D7h466Nz3P2cuunN7DXAzYFru/uxzWfXBH4FeC3wKeC/AP8duBrwbe7+vkGF7Gj1ie6V7Cr+7fbdcxdDREREREQkyNv8DXzBLzSAs252ur/9NdcZNL/9a37gH939rJBpzexawMeAp7n7I1um/XrgPOAV7n6/QYXsSJcui4iIiIiISKj7UeSRVZctH+HuHwP+FvjWsQtVpqcui4iIiIiIZMqBAw6mXOTZwLnufm7g9EZRzEnpjK6IiIiIiIi0MrOzgJsQcDZ3M/11gFsBbxuzXFV0RldERERERCRbznGf7Izu2cAx4AXlL8zsSRQnUt9C8TCq/wz8InAA/PpUBTykRFdEREREREQamdmpwH2AV7v7BRWTnAc8DLg/xauHPg38FfCr7v6vU5XzkBJdERERERGRTBX36I5/C6y7XwZcveH75wDPGb0ggXSProiIiIiIiCyKzuiKiIiIiIhkbOKnLmdBZ3RFRERERERkUXRGV0REREREJFOOc9wnf01t8nRGV0RERERERBZFZ3RFREREREQyNsVTl3OjM7oiIiIiIiKyKEp0RUREREREZFF06bKIiIiIiEimHDiuS5d36IyuiIiIiIiILIrO6IqIiIiIiGRMD6PapTO6IiIiIiIisig6o2tgp6xvM/jByEd9/GDg73VUSkREIjObuwQieTKdG0vO8ZP/dOC4Yucd68vwdhjs789diMlZzFWuTJoDF9AzIR6cqA9NxKemzkukuzmTmgmDQttT8jaIAnhZqwn7DtNBpujsYm3TNqtPdG1vj70zTp+7GHnpmWR6l2TtoDkR3WnafRLBlmWkoNM2iyn1M/5LM1WgvYCEaPRgaa/nvuhTrp7LSipgTLFOjdmeUlzfLmLWnT7bOXD7da7jfderb3uPbch+Cf1t27Zvm8/A7z207UyxLZbi/NOO/FeR1a7VJ7rs7WFf9VVzlyItfRLAgITssPsJSt5CEq3QZKlXEpzGGdTBXXZKCWUi2zRZKQTQSzmz1XVbhgZHbdunZbmtwXtIOboE5ikFfTHL0ret9C3DQgLvKIlG3XdVn1ctr2q6is8Oyp9VVfvAeXnT+rQ1pzH3X+C8vWmymn1auc7lj0rT7CynZR+ELCOoHFXLPrHMluQ5neY1i4OPr++K1K6U6O7v4VdacKIbM7nokjCGTNsyjbWVPbQ8scs9takTxDG3QYrbV9IXO9iMdQYkZF4hywqYJjhJCV3mFKYoR4xlxDrIlMp239axTI1JIdQnhkOSzvI8g+dVUY4uiR+0H00eeZ92StTqylKzT8KTTGucZqeMFdu4NUmumqamPI2fn5hXgm1tDlubwXG9R7fC6hPdS658Cuff4+pzF2NWFtoueraf2vlXfF45bYffd11e0O/qTNGfBCyjsdxdtlHgZ1aVrA7cl33Wofd0kXSqL0PqXsN3/X/X8GXgenVuLx3nL+1674NUdCh/67q2HTgd0Me0L7vl+xPzmWiHJVQvbKyLimZYx8n2Xx99itbxN93GvN2JQ34fvoyE98WUtBlarT7RPeNKl3DjO71/7mJM5iDw8OGBVx8iPKg5zFY13/Jn5f97+Xuap69axs48AsoB9X1D2/YpLy+GPsssn+QtT9O0XbxmuqP/Dvu+9vO631FSM8+qiSu3fXASHGe/NcY5IeXb+X/50HmHaQOWYdu/aSpLy7J2go8eB5MmS8oi1oleyVHTNug6r8DvYx50iaJrPajYF9ZYPwOn9YBpAuYTMv+d6UK+bylP8Pcdda3XQQctj2yvcuddM6+6z8vzD5yu8/YPPZDbMH1ffQ6eBK/71jpUbe/6feBHpzs4Op1T2j5e+ruqjOXPDprLdqQcFd9Vfn9i3tUfL9mRKx8djivx3bH6RPeY7/HZSy4/dzGS0JRwNSV4fZPLtsQ3fBpap2n6vHG9a79pNjQhrl+H9ml3/1/93ZF5hSSmtb+tWXbt/Ks/311gxf+rftM0bV+xE+jWAKxLwlu9/BiBYnmeQdPXfXb4+/qv4uiz3wN+0/sMYEgStfOb+q0U62xi52l76lXetuC4S6LfMUHt/Num6SqmHXL1TJ1oZxa7HJDomHiFHowIT962Pw9MpNvKUTNN7XQ7v4vXoEIPgjRvr4oklN2EdWf6toR1M92Jz6qS1ab5lst2pDw1iW/pu/L8duZZZQ3PBVnBKg61+kT3+GdP5bMvufbcxZjdFJchhg0c3afZuTWky/K6LnsEscvZ9axB6KXItfPuEiT0SQIgOKCY9FLOwGX1TVRqB3Gv/k/tJYKD5t/j+xPzD5tuNiNchhh1nRMO0qKsZ2s/1jBBlzpd1S5q5l3dv3VvJ7ED8MnbUsznXzScZWvexy3zbt3GzV+3Lr/NZJeh96xLtfW2arzf/azyGSk7iWfYvDqXse07yOKtGVOwSy878W9nlSe1W60+0T31sxfztS9Zz6XLSUj5PpccxA6AhzyZOUJZZnuFUh9jDq5Dt0OEsiX9OqsUnkodUVKvCEpIlDrYt18a0BcOfrd707yrFzja8qZ6+npGPf/05npjQk7jseB+bO4iJG/1iS62h52u9+jOJqVOdQlHCAdsz14BZoSAMmq4n1J9immis3uV+yKlV1RNba2vWxpiYF2tv4+5Zz3sUZ4+faHBdGNIaPlSPZgy0btrdTBpmKwOQq+UfWm7LRnHx79ZKDurT3QPzjiVi258zbmLkaYeAcIYD0UJvryo02XUETvwOfKADuUffFnwkEsMA+rQ0Cc5LkZKr7EY08LOzK5exIMw4W8AiHRpbUvfHTRO5P76ujrB75Zue89pz9cVtc27dbnNiz25/OH90WpfdbPS1U6Jv+tycxcheUp0TzG+co3Vb4ZdI99/2Prb3r9rLtDYr1Lqq9c9WGPc4zbFfZ599+2ReWQSMPYIgDonpJ3ew9ht1tEDuJQCo0yqUG56H0QM+Vnf5xNAY59R+7uWJD7mg8KmfnVNUNtumKS2n6p9j23V/Ae8a7XumYQ93pdb85KJTvOY02iJdsTZJnOgdWEO3ruQq45GtPoMzxz2L1HEA+M9vGloMNAaALT9vssZ15mqwuAgZ+wgEfoFiodin9k9lFrT3RnMuxXQrUds0fGMRJeAw3ae/LbSaGXkJCT5B3dVGeFy+pgHIsPOxkaYR6fxJZ0dXdmSQ9p3S1zdNdHsPn3DwveMup3a2u8N6NvmT+J61quxyz37dlm+7YeGOUk/w3A2SnSPOad/Rjdzl0U5utxjFp2XO+Sy4YSCjjrTvXs09gOu4s6uytRnQMpGv1wt1uwjl3P+oC5M/yfJd7kUNaQcgfPrEKEM6hcy6PdOiF3WSLeZTN739F3eCH1U536vywmnLvPuMG2UPku3XPSy2su6J2LHMurPZ6JE98DZv0iJbpvoA3uEw06jJYE5BYIpW/h2rB2+pxrYR1xOU2CYU9gS/f7vxvvR28rSdCtBxHtBIz4zYO6DSZNYwzpGtNP+B/ZDgxOhgES68xKUnEkmyq+B0sOodinRPX7AKRd+ee5iLMfcQcPcy8+RtlkeUg++5ihfzLrb5QFvXQ7UxXwn6ZDpm6zlerdc+7qEzuj20lCO3iWc4wxrKtuzq1zrvbQ7fnzuEiRv9Ykul1yKf/Tf5i6FzG2i1x30soTXHtXQ6wskW3Mlh2t+3dOWMd9b26EQc5cgH0t5VZeo3ifEDy47+W90RrfK6hNdd+fg4ovnLoa0yfVIag6UbIqIyJhcZ55EZHqrT3Tt9Muxf4MbzV2MNAw9Qt4nYRrxHYSdLi+MsLzZRHlwWM95LHEbp1imOimd7c9pu81AVy9MKIWzvUs00uXCFv01ZjownvRVahKNXXDqkf8f5PK0yAmtPtE9fsYpfP4brzJ3MWYV/V24FZ9VPtSk/OaSqpi9PE3AfOrLUDEdDHttTl+RArFuD9tpm9fA1zjFehVHz4Qg6Ve0zPQU821RHiy0wARi9nqjBFjGMFKy1zmO7pAcBz+YqtO7w4c+LGvQz6cRa18PyI2jPF05h22dGP/8qe0TrdzqE13fg2Onr/vIV98EZydAbEwurXa63fl4w/fW/vvastQlydW9a/D7dyeMUzslKwMOYBTLavrtgIMDY71TF9J7r+7GJO9Jbllur1kkdMI4WCKJ42wJdCLrnwyd3eukd2IXup0Dwq0xEt5BiVjiVWju1ycNXr7aaG9eCq11j+6u1Se6eIRLXDMyVgLRnBR1/J3ZkWCt3ImWm/GJ771hoqoZ7Xxf+m+H4x9TvYbDGw4YNAlK2svrX56Ht23g4keNxXJgv70jjpYkJBP0hw8+oydImfR3s59pbTNi+RbzWp8ZVmOUbTfHAZ+Y6xE7keh4bmD2xHXg6mdxVrdFa396vH99G755FtLfzUGbrtXqE10D9vSMhG4GX0IZMlFdIuX1g05bbztih+BDuvqY8UzNvHy/33KPnhFsWMfAdQg9S+47/+hr+ghlaKA9/rg1U9SW+4A8QTsdLKMEudc2CDpIY2Hz7tL/tSV2Ea64qPi230wj6X0GtOPPOi+n8/y7TV9pylcZDTwQGfN2ppPzDJgw5rzKcryyaCLlGO34kOvPF2r1ie6xy8HnbrTiijFGXDRgnku7ZHWo4O0x5Ix70+9DL1sPLMuQ+8E7TTOhSc88jnoWcbx5TyJm+XvMq1cA12s53X8TJJH933n9RgnsR1p+32WMqFMi2HZRVNP3Pb7rO7/WdZrqkucBgvuTvuNt461mgcvoGh/0iSfaytBBKm0upuPnrTh/CbT6RPcbr/4p3v6wZ8xdDBGRVscr3l94UBEBHFQcAj9eEThVTQdwvCGqOGgJwJp+O0Sfg/pV63ziuw7Lqbqqr3K6UgR9vBRxH1RE2FX3VFU9ObNquqb7sQ4C773QPV3rsl/RPvdKl9psT1Oefm+TLWx/vrf5977t/u6wFh7esXLi/yc+t9Lnm/9vPj/x/60zVSd/s7f5ezOt3tXb6nAMORw3tseAw/7y8LPDvvywzz/x/9L0h33pdi067DNPTLvVzxz2i9v94fb32/3fTp9a+n9TP7eGvu1B7/zkkf/rqcu7Vp/oiojkoiqQq7oqvfJTjX8iUqm6F5HlORxDTu7xrX2vMSI7V9CDvFop0RUREREREcmUnrpcTdd5iIiIiIiIyKIo0RUREREREZFF0aXLIiIiIiIi2TKOBz6EcE20RURERERERGRRdEZXREREREQkUw4c6PzlDm0RERERERERWRSd0RUREREREcmYXi+0S2d0RUREREREZFF0RldERERERCRT7nrqchVtEREREREREVkUndEVERERERHJ2IHu0d2hM7oiIiIiIiKyKDqjKyIiIiIikikHjuv85Q5tEREREREREVkUndEVERERERHJlp66XEVbRERERERERBZFZ3RFREREREQy5cCBzl/u0BYRERERERGRRVGiKyIiIiIiIouiS5dFREREREQydtxt7iIkZ/WJ7ru/eFW+4a8eMHcxsmFd25B52GTByw+bX+hyj867809GEbyOjfOIu7zQMoUut+86xtg2YxujGu1FqRPxt10O+8MjDfx953PQ83extmys9R+7DN6wwlW/r/4s9LdVCwlcRnURK39fu6ygGSasZ5XqNcZ27GNi1fap+ra2tlFZitJvdupY6f9HlrH9Xd18ymXy0t/l3zctv2n9vObfG1b126bdkmNbGujjn33a3EVI3uoT3ctd4NzoSZfOXYz0DLmovVuWFTRZp1htr2dgmUqmuz1UxyxSj/XrHCP33YYz3UQxyz7vsche5ey1nO6/qdSzDc4pej4YsW4lkKtOqneO0ZpVDlzOQc8DdAsLwKPUxwF9RLT2kMyY30PHul7Wq07u1P/AA+DRjtpFms+CfOZzJzeKYxzXHak7Vp/oXvMGF/KYl/zp3MVIyp4ddP7NPmG/2Q/oqdqWHzKPLtOdXG6+vWjXs0bHO2RBodMedHh/W5fl7/5WHXmb0PYo+cml/k9dB7v29236jIOhYpc1li7lahsv2+a11/D9fsO82+fbbL/j0DN1a9sPmaYmQa8q637FWLtX8fvK6UpzLC+3/H3xWcW8LY8+K0ffdsdPz12E5K0+0b3iHtzuDAWFw8XsyEK6ehGpp8BC5pZ7HdQ4JCJ56XLCYS20RURERERERGRRVn9GV0REREREJFdOPre2TElbRERERERERBZFZ3RFREREREQy5Zjeo1tBZ3RFRERERERkUXRGV0REREREJGMHOn+5Q1tEREREREREFkVndEVERERERDLlDsf1Ht0d2iIiIiIiIiKyKDqjKyIiIiIiki3jAD11uUxndEVERERERGRRlOiKiIiIiIjIoujSZRERERERkUw5ehhVFW0RERERERERWRQluiIiIiIiIhk7zt6gP23M7E1m5jV/Xl3zm2dvvn9+9BUOoEuXRUREREREpMnDgSuVPrsl8GTgFeWJzew7gPsCXxi/aNWU6IqIiIiIiGTKMQ583NcLuft7y5+Z2YOAS4EXlj4/FTgHeALwkFEL1kCXLouIiIiIiEgwMzsDuBfwSne/sPT1o4B94EmTF2yLzuiKiIiIiIhkLOQ+28juAVwReN72h2b2DcAvA3d290vNxj3T3ESJroiIiIiIyLpdzczesfX/c9z9nIbpzwY+Cbyq9PmzgJe6+xtjF7ArJboiIiIiIiKZcuBg+Ht0P+3uZ4VMaGbXAu4APM3dj219fj/gW4H/MrQwMUx+jtvMbmVmrzWzT5rZF8zsnWb2wNI0NzGzl5rZf5jZl83sPDP7OTM7pTTd6Wb222b2cTO7yMzeYma3mXaNREREREREVuN+FHnkicuWzewKFE9g/k3gYjM708zO3Ex36ub/p05ZyEkTXTP7JuD1wKnAg4AfBP4B+EMze9hmmmsBbwJuAPwMcFfg5cBvUzy5a9sfbubzP4C7AB8HXmNmNx91RURERERERJJgHB/4p6OzgXPd/dytz64GXB34deCzW3++Hrj35t93HryqHUx96fIPUzyB667u/qXNZ68zs5tRbLBnUiSsVwNu5e7v30zzV5sbm88GHg2w+c2PAA909z/afPZm4Dzg14C7TbNKIiIiIiIiy2dmZwE3AR5Z+uoTwO0rfvJC4N0UJyzfM27pjpo60T0NuAy4qPT554Arb00Duy8X/hxHz0DfbTOvFx1+4O7HzOyFwGPM7HLufkmcYouIiIiIiKQn0j26oc4GjgEvOFIG94sprso9wswuBi5w953vxjb1PbrP3fz9O2Z2rc212g8Cvht4yua7PwM+DTzdzK5vZlcys7sDP8rRdzHdBPiIu3+ltIzzKJLlG461EiIiIiIiImuyucf2PsCr3f2CucvTZtIzuu7+HjO7HfAy4OGbjy8DHuruL9xMc4GZ3RL438CHD38KPNbdf2trdlehuNa77MKt7yuZ2YOBBwNc59p68LSIiIiIiOSrx322nbn7ZRT34Xb5zfXGKU27SbM8M7sR8OcUZ10fSnEJ8/cDzzKzi939T8zs6sBLgS8D9wQ+A3wX8Mtmdom7/+bh7CgS4J3FtJVj806ocwDOutnpVfMQERERERGRTE19OvPXKc7g3mVzRADgDWZ2VeBpZvanwC8A1wOu6+6HZ2zfZGb7wOPM7A/d/dMUZ26vU7GMw3t9L6z4TkREREREZDHcbcp7dLMx9Ra5KcWjqC8rff524KrANTbTfHAryd2e5lRO3nt7HnB9M7t8abobA5cCH4xZcBEREREREcnD1InuJ4Cbm9lppc+/HbiY4izsJ4AbmtmVK6YB+PfN36+gSHzvdTiBmZ0C/BDwWj1xWUREREREZJ2mvnT56RRPVX6lmT2D4h7du1E8vesp7n6pmT0LuC/wWjP7bYp7dG8H/DzwMnf/GIC7v8vMXgQ8dfMEsI8ADwOuv/m9iIiIiIjI4h3Xpcs7Jt0i7v4S4PuAywF/QPFgqlsDjwAetZnmrcB3Ap8CnkZx5vYewK+xm8A+APgj4PHAXwJfD9zJ3d859rqIiIiIiIhImiZ/t467vwp4Vcs0b6VIiNvmdRHwyM0fERERERGRVXHgYILXC+VG57hFRERERERkUSY/oysiIiIiIiKxmO7RrbD6RPf8S6/AA/7vd85djNnt4d2mt/bp9+yg8fv9hnk0ladtviFl26d5Hn3nm6oDT+9yluMLuqCkz/YNfd9dyKVIxwOWH7K8Xusx86VSIeteJXj7t8y/bf2bft8678B16/vuxCn2Xd91rPrcS5+Vy1/+Tfn/O79vm76lTOX5VU1TN10xbeXHwb+PLXQ5bfu0abXqllH/efd5tX3XNt8+8xtb1/Ke/GF4uUPXMagoHbdX7/XbmVGk+WTiP774e3MXIXmrT3QvOn4q77vwa+YuRnKsQ1IXkgCGdHlN82lbRkh5uyaqSmzHm+fcQUMXQ9Y75Ldttaw1qByQLIXsh9BgvMs8x9R1+TH2UXtQ3bQPhs2763R9yjBU5/UPSBZ3fraThNZPvFOeI9M2zKeqbJXlb/lN2+/7TBNDzLbbmO3Wf2V1ZWhthAO/PzHdfP3XqCHHkHkP+G3oOgVv9XzDsnFcdvIgp5PmSY25rT7RxVUxKm22SUiyV3dGpUuyDM39V3kZXffYnjnHO/6mbj5L1HVfxVpeDttzf+Dvx+xfxkoqc+wT+5Y5tAYGJcQRztCGn1ULmqz3/GMa+0xhl7OEdUl99bRxzzK2/bb6B2m3xZj1KepokPh2S8HYB7hAeenoTu1+deLaKNFl/jMQKdtJMLskJl0vXRkp6THz3pc3zmFI8tf7zHlp+ww9gx52aXuHqwYSHy6nPlCwba6DBakdpBianHf5fXDiFnhILvwS5Z7JfKL935T7DPoF3X3KmOr2TslcfWZq/VYsMWvc0G001jaec5xN1adPPXoKZ0m3hMWiRNdgf09HRFK1xo4tJLCqG0jqttb2HNvmv2fePk3jtycPkDTtv/IymgbHkIRh1gBmxsD2eMfVjnXQIMYVEmPoe99pl4Qm1pnZsRLclHrNMa4O6JtIznmgoO8Z+FzsTdQFDo0Jxuy3Ukui+26r426D1iVGmw85IC/TnJXP3eoT3VPsgKuc8ZW5izGr2GcymgLNPg9maVrmkAe9dOkfUruUM7Q8c51ZSG17DdU/sB4+7771f8z7So9OFzRZVH33R8jv+t4z2/i7Hn1b62aNsC6jirzs3n3ZBJcKR93OC+s7B0kscUyd9a06fbZzz2VFP3mx8uZy2bGTN1c5trjYKwYlunsHXOVyy050g88adExQ255YWX4SaNMTMpvm1fSkzabf7Vf8NqTcJ5a79e+6o5tTdSrR7nFrvYew+2/7JmIQ+ByWCNs4dsLf5x69nYfpVB2w7vggnO3pOz2cp+IHleUOfFBQ5fwrJ5qgvQx9uE/Xh+F02Ebhv6+etPZBPS2/6zzNWGIsu2Md6hRXd06KN8vo+LNDq87j1rzuY+h7HKjr7/osZ0C3r7ytxTFdqtxm9Ymu4Zyxf9ncxZjFkNdmVN3zupPYVk3T8XUQXZPnkHm0fd6aDE54CDHm5ZRDHpQTcjCgy/xiXtbZdb5DxDoQ0PYak92Ed/vAT5xpW58mWzHvqrI2/b52WWPo8viAIQljxDO6nZLnw49D6nif7Z1C4hHUfgc85HDEpLf1IETbIlLY/kOk+sTgXstLJLsa60hIjNWLtYkS2dTZKm2/A92ju2P1ie7l9o5x3TM+M3cxZhHjxdJdkr7Q5YUmOF1uuu975jWVy0C6PmCg/d2VzfNr269tD/dqnX+Eqwy6iP0wsrr1i31wp+nATt0VEU3v+uxyVUXoO0L7HARpMmebm/LezzEvh49l6lsf5ng1VOhyu5RtyIGdVB5k1bUcoesc4/aBYqIu+2PgQQjpLpF6vHj7esZQm9UnuqfYca52yhfnLkbW9JS38bQljFWOBz/ptX3ebfNqm0fwwY0eCW2MAzWhmq9u2C1HVQBebidNSeb2tHWJ73aZjjclxzWJbjn5PzLvhtsF6qap+yzku9z0aZdLMtZVLTEfzjX0ChdoX8/YDzCLIVaiHGNfjHHFT+8rsSIm4lMY/+qk4fOPfTAglW2fk729k3vBPf5B/SVYfaJ7me9zwWVfPXcxZGXGvPy5TwLYZdBb8pn0WGfOqxKhqn3elGyW51/+/ZBEtestA1Vlq5pv2zykm7Vvw7HPlHfth3PYH30f9lPebqFP3a2aLmQ77Tc996LvOvT6VbUc9jXESQ6nvk1ojKtS1pokr/HNJF2tPtG96PhpvPsL15q7GCJZyyUoGKLLWbwhZ4Ji3FNet/yu866bf5ffhwj9fSqv7xijHKkELGNv4zX0FTnq85rF2O9CD2kDsd/R3mf6FHRtRzGvlohxNUTXZY75+5zt7+VXd6e2+kT3mO/x2UsuP3cxRILlOCgv1RjBxpCHhoV8H1J7Yr9yLHVDk8y+bTLGlovdH6TwfuTU+rhUDkLE0Ck5bZi2LnGt21ZV8wr+rGJZe1admNeVuXFdQs9eT3zn7lhXHAwdQ0IO+oaUPcVL/3NTrpPaTrtWn+i6w8XHVr8ZBkm9YS0hEJ9a6vt0SjHrT9dLtro9AGe8oGHs8K6p7GMkGV3WPjQIbitn2NmqoEX12iZLSh67rkvo/q6db0397H2AY8Z9ceA2eV2YIsntmuAGnRme+ZFUbcsvJ5Mh6xSy//fMG8eIPTt5OKxuuqpUuJwgB5V3s46p9V+pWNJBuLGsPsM7frDHFy++3NzFSN6QYL/XEw97tN2hCUkuCXGsV7X0Xd/ey4+0fXPZT6EmG6YWtt2CtCWfTd/V/bbic6uYUdXvq6ZrWlb959XzafpN3+mGGpxk0m37VB0sCD3L2OVspFEd5IecOQzpw8bcP4flbksepkyK+ya5XRLZPmeoQ38/ix7FaVqH7cS577o2H0Tt94RgHXivt71lHFv9gxKrrD7RBTh+XBUjVL+ktctZqfHKEiVBTLTD7Z20dv7BBNs8sVgi1NIS8BNS3B/Bm9oaEwZvmJdVZq++0waM3U1k5vj2jFuTXjvxu9JUnZPjtnUOmXcsxXZonwZ2H6525H9eHYAftrnt9T3uFdvGbScBtoqzVuVI4HA+VYnh9hK259KURIYmmFMY417X6gMP3RLOE9N0uFx56DKzTHIJP4MbPL8enX2fs8pd1c1TCTCkOUCnRYkusK/3UJ3QHqyn16gWm2CsWKyz1rJOfRK4WGdC2xYdEgiOfVY29BLp2ELL2+fsbtPv6la362WtfZYd+v3O9BOPtTH2Tdv3fZLNrvfiQvWZ6J2DGlvft91PukfzpbxrUNtW5owJ171LgN2+PPT1kmuy+kTXrP4x9zlK4Xr9WGWIEYylsD2apPL01uD7EEeY59DfhEq9Lsh6pHh2KBW9+o2OwXaXviC1fiylutM3yQk9M3v0N92WdVBzFUDV963zChj5UtgvXfdH96dTh++3PnH13PdE58i0zVqtPtFdmqkf6hJ7GUOS25jrl8KgVaf/WZy4yeyQ9yw2Ln/CS59E+hpyhmftZ4eatCUolb+p6LUaf9v0oJ1S4Fi+pLpJ+VLnFMzR97UuM/A+wiPzibAaOSVSfQ4GnPztOAnvngXuN5xjkZdd//t1X5HppX+n1PekYvWJ7oHDJZetfjMkT5cnz0eXEfcz/OFofX847YPjWucZfY4Jy6SfGqtNj3rPb8+AuE+RBh1sS/yg2tj3ZQ+Vw5U3qW/DshjbNM48Bs+i53LTr1N9feWy0+YuQvJWn+H5gXHZpavfDJXGelBRa5AVsOCggLzLCswUoE7+gKyh275tWRH2bdByUhSybi3TWNN61/22aZ6N3zVc/RFhXaL9JiGTxksjLivZ1jWwYFVVunEz9sqCe/xmS45dm5D8AYxsqP5HdXDp/tb/9NTlKsrwDoxjX9FmaJRSIjVk3l2noyXxiKB17l3H1hgJypAEaOD3vWKJueKPLpc0DtkuNd81Lr1HUjx43w6dPgGzxbLKfgo9d0CnzTfWtF3LEXG5yZt4fcZpxhntlBSLmmKZliDDcXZqq8/w9i8yvvqfder/iE6J4IB5tSY9TfdYNf2ueb4hy+48vzGNmPwFr1uMBHWubT7T/musv1Um3med5hU4vy5mb1dJWdfGiJmYNs6r6QKJnr8rftsyQZdjw1MnAIHLay1XzfeVvwv8LPS3wcugZV/1XMexRKkLY9W90GmnqvtKnAHYu+zo/0MenLY2SnQvcq7y3kvmLkaS4iVBNRM0JqsNXzY9e6Dhd+HrM2HQOcKiOidYB4EPqeqUFHWYeOj2zuBZFJ33SdmQ369g+0oiul4115ow1n9fm8BUlaH+ZcQV862aZ/XvByVRTeUaoFvyEr4Nd9bVGr637c/L87bq76zu8+p/1y5v52XIDeWs+H5n+WUj5RG9kr6W+hP9IFCXgxtBywlYad0q0Ggv9KlfK7b6RPfgVOOiq586dzEmMegMSoyzQ32T0JEvt+yVhMx8AqbzgwZjbYco27t9mpPzS+dMVxJnIAMPSgyRxHquxVK3dexLfhsex18flNclp1XT1s2jbpnDzugOuo0ucuBeuy49z6TuTFOXwJZ+G/xdx8S1ab610zRMW2fShCrymdi+Z+9j/f7kfAZuxIUntVW2+xL3bk+JX4vVJ7rHruB84rY6ZVFphHvygu55jXGvYKdkKt7N+6MnCQO2TW3Zaj/f3Ved5hHz3tLQ75doinFrjWPj0LrU8fe9+4acL+PvW69iXV4bMq+2ID6kICNc1hnT4Ng3pPKOmQy1DBrt8+5y30z4pCJzO3763CVI3+oT3cudfhk3vNHH5y5G8vq8myv0N6GvNAmdX9eyzpU7dS5nw/R186r7TfnEYNV05c+qllHediHzKT6rLFZteUPqyJwnf4cciO766oPQ6buWqe8rGFJ+dUPX1yWFTt9W19rmE2s5Xec3dDldxLoqt6l+VZ5g7LDcLnW3ezvtNHnHeafb5tpMVfY15KuDj9X17DeG9Ddj9DVrfv2knXb8yP/11OVdq090JUz5pd4hSVrVi8Crftc08G13YCEvFj9w6/0C8qlftL1fU87a0tdMf+BWOy+oHgQOH0h/cp2P/r74TdX+C19G0+cn59eSEDR+221Zc5giqBt7rfu2pzkd1qvQ7X84VWhfVE5iynVvez5Vgd3R72PcENhtH+2Wt9PPexvaHsY8eNNt2m7l6LOMuY1d1thVLsd+anYdttmRsVrbOhnpRT3pUaIrtcZI/OoGo7pldR1sqxK+0ARoCQPl1Ml6nVTKMbYxaszQbTc04U9t3w1fn2HLOPFd08G+7cS1w/zdrbKPO0yOq7+rOljYvqyj0/uR5Uxp8G14PfrpsZPYGElh6knwkN3WZ2wdez83abglPCnx1ne+q3mWEHfNaX9Pt162WX2i61hygd0ahZ797SP1ACKmpjO7faQ+CI1Zvlj1b+pL+EOW17TVtl8/33cbRD27HriP68q633L2dXsZVUmxmVdfFVHzeWU5ahLWukR294zx0fKUpy+Xt+n7o9PWfpWEqS6nn+oy/1i/H9OUCe2Yl44PSVZT2z9jHigImXfbpgwtX5f1SG0fpOrIQU7lM5VWn+geO77HJ794hbmLsUopdWRL7BrS2brjSPFS5bLu94jGnW/se0G7zncsvc5EBt3n3XBmt+N8a8vY8fL/5oXXLz+oLInonXCHjiEj3bfbd+BI8gDD0OS9z286bet57pFOKU45NMWl82NeBTFkm6a4P+Z07LjuyW2z+kT34LI9vvQJJbqVYg/GbR3UkKcyhsw/ZB5Dpx9b3z4+9HehCUzw/AKn67Ls3Iy9zzaCnmg+cBnRfjuG3ts5bLsNfpVZy/d7IeWP3Y5TETm5jPK6kxjLOTK/5svbo5pq9/fKbrv/xPskNzG3QWbNKZpYSWXK9TFzB8eOJroHa9wILVaf6HJg7F20siMiIwxOzc9TOfGol7B5dv2cw4Gw6pLBhnKFfJ+rCEFzY+I0NOgPnebEtPPsqFEPHk+UAMOA9UgpmY1cBzpvk4gHd4LXZKwypib0lFDbONQ22cDxoFwFKyevrVg9xqeJRWliI8QXVjFB77KmfkZwjjrRu8H0na9Ek9tBzRko0V2bAUeyq18WXxo0ytM0/H/nKG3bb+uW27rMqhvvquYZsKwWfS8pGu3SwgFn+YKLNNJlpKMsd6pFDDpTOuLA1WtfRS+FrEVoVe58pU1NpQzt14eMCTXLbuz7h17NFMngyz5Dj0cMvPqq9edBV2+FrWsKl5HnfjluCttwreyUkw+jctJ7mGQKlOhKoaJtHGkvTUmp7X7mVYloU9BQOb/SdxXlsaoybn1mFeXY6ZS3ptn5qjagyntg6m2lnWise1I715rY99jOcS/umE2lR/Fag8q2s0s9DojV/qSpLE3zC044xtv4Me/LK39XNe/daUr/3/p3+aE329Nu/7v8wKKj3zUvb69h3Kj6fd1nVfOuM+bD90LmvdfQmOvWoW6+XT6vW+6eVT9xtmld2tZz6DZu2kYisX3qtEvnLkLylOga+H77ZIsTckQ79GxsUyK7vazydAFJblMiazv/r5h2e5ZHyrwd+JSK2/Bd1TSyTGM9cKnv2fuxHmx18geRkvmJD4Z0bottZ5M6tvnu08eZT9t3R6YLmqq/0OQgdJs0JaBVywtNQrc/b5pH03TbiUxbubp8Vp73UHVJYNhvA5LerglsbbLaLYmte7NA1/m3LSd0uXLU8ZUeDJ/Lfqn+HvjKbsUMoET3lAP2r37x3KUYzZBLfJoSwLbv65LF2mm25rNXOx/ffF+93NDApby8qu+HHnkXGXxmYMDvhwTMY9fx1F9ZFUsu6zllOZvqZVXCEZpMNSWj1dMfXVZVEtN1HnXzqZpX0zzq5FKfutpnGe8BDdk/c19Wepw4SVDTepzSYRWVlA2nwwrtVp/onnbqca5zjQvnLsZoug6OXS9NCjlaHXIpUnnAbw1kWgKb6t/EOUJcOe1CgxBp1hSoDg16q+pUOSgMaX8hvykfFW4qZ9W0Ib9LRdenUh4PCMZC5hk0n8BAuE/AOkeQ3aVfbEp46uZTVxe71N2qaWvnWzeGdEzgu85jSsc7to+QZCVknm3zaWs/oe06pB32nffYepW9Q7sP6VcO3IKyq6Dl2vHg5Q5e1hq43qNbZfWJ7p45Z5xy2dzFmEXwS74j3R/TJwGunS7waHqfy5m6HGXX5UzL1O0gR0viF5Cw1k3XJ9kNCebHCvhPljHddtE1kIduZx5qg9GtxXYJnHMOzKt0aVtDD6o0/b7xINWAxDW07g+5tHhUXeo61rgeh+2mbptst8XyfMptrrwvy+2iXBfq2sD2fELbVui8x9ar7FvjQ1sSdDi2NCWeofPrs9xDXRPfNZ9osITH2lSsPtE9xQ4487SL5i5GsoYMxl2TwK5ngvp2bjEDjKb7UVJMgmOcbYu1/VIfnIZeUjfkPrfQclT9/jAA2g6KyoHZge/v1IXj5eXaAQd1DzDY+ryqTs1x6LAtKRoqtN73TaC6SjZRysCQSybbfhu8V2Z8OEifgz2HQrddaCLWljTGuqKiS5kql5HJmbJYlydvG7ruXZJeWM7l7FNz0j7IOZfVJ7p7dsCVTl3uPbpy0tQPSei7vBgJcveDBqFBfNh8uwxUc97LOqVYg3fo+tYFdYcJYduAWJvklsuTyBHly3w/KNkdchawcvrKq1AqrjgJnK6YtvvTZEPq19gHA9p0STSaAva2YLnutyfOMNrRwzpNiV9TYteWMMZOCscyJDjuWvbYSWnXJGyMRLBPOdYq5nitbS4hVp/oHvgeX7js9LmLkYy1dRypHf2KlTR0GUzGuFR7yvub135mK8UrB6YQ82BO1wSyy5N0Q38f437Ttt/UGSsBHuuy66H3azb9vmkMDL6HMVCq4+1YyWDZmOuvBx31k/N4mstB7zGl2qfMafWJ7kXHTuF9n7nG3MXI0tSvEZGT+j4Zt/zE6pjL6TLIDH2ybyoD2pBBpUv76bKc0PkedNyEubb3trpW1ya6vhe0y/Sh711t+rxpmSG/HeN3ZVMGXTGXNWZdTykQ7bufY773t/X1Py0HbcZ6B/HcY0yng9Ut26jPQb4+7yJufqp6hAe2JTLup2Tuq0FysPpE9/jxPT7/xcvPXQyRXvqGTLHfPbo7/26zL34z7iDWVKa+77Y9Oo/2lW5cTs3v6+ZbO6uK6ZuXW/Nx2/p03WZjBPhd6kzL4hvrX20yXPVhTSLcZZmBr3wLnl/H+chyhdeRbnWwavrKz0r/rzwQ1PCqwJO/a19W6Pzbpq8zZjPqk2iGboOQB4G2vSM66I0bgbdrxEy212b76hUnrQNpqVh9oosbB5fO91AIkV5idfI9+8RBSWnkfnjMoL1XAtzym9oEsu53tQlw+LSV8+6RdLf+rs90sYXWh9J0O8WtTUI7LrdP0tp12Sfm2fUAVrfJk6a4t5+Qt8D0qKvBB3YqE9Gw33ZJups+b5pX1/nE0Db/uqKGJsAhBw6qpivPv+17iHP1Ssj2Xmvie9mB8pc2SnQPDL6szTCadfY905kpUD2Ye1CZYr07n/TueQa0y+dbyzj8V+Wu6JDY1u7Kvolw23wn0vnAdluB23ZvYzLQtuwB8z4xD+/f3U7Vj0xRJyKe0ZikDk/dTnpsHie8DvZebs/24wPbbefp5tB3HUMPvlUelQgrR9BVLR0PSLQf0Gv+fk0uvUyJbhtleA52qVpNEpQUxzFBdbZpFjKvzpfmNn/dKaGsiCqHJLSVm7Jjgtsa9A9tv3W/H6MeVM6z4pLvoOB+4PcEbrrW+VjlP7M3Vr0KMHgz5jymdVx5D/lRjPZEh2MZGV3hEL5O3b+rnXflGfaA+dYup9v8OjePoUeeltQvHjo4ulK6dHmXEl1JR27tc4ogJrdtElOqQWLPcrnVjNN1R8RL01aOX4FnVoOK3HbJdYdpkzEwsG4+Sxt+NqI+0IxcJugXDE7dz4xZfyIFeqOdzU2p7fTcVIPP7oYuP8JBJAg469tjnqOIuew+Z9c73n4RbT4EnqWd+zKhFK05RgykRBdUUVKVep+WU71JfVsGSmWc6xtLd/pdUBDRvkG6HzXv+oP5DAq4gy/XKy+z5bK8roloyO8DLwXsE2DuTDrh/o/xELhoSpUppaLNItaDzQZcWtznAXEnf9v8fTFR/708az7cKXFvnzZkW7XeNxxhHn2nXbO9/ZMP93JMZ3QrKNE15+By+b43LAvqr2bTet9oZlqrUoy6NsIm63RGoWsZRrm0d87rPSMvLzTR3fl/+cErpckaks+dIO3Id/XL2flqZz79H9xTN22I0KAz11dQDZVUwt5irCfi902Emh8Q1fBdw7JCHkzUNZGaM/Hq+lpACCtvrO0UNJ/WKbrNb455pejf9pS/tFl9onvTMz/N27//nLmLISIiIiIiEuTbzvjckf8f5HRJ1kT0pmERERERERFZlNWf0RUREREREcmW66nLVVaf6F7GAZ88/uW5izGb0FP6+w2XQ+w13PRT9bu9mqXu18ynavq9mvLsmy5SEBERERFZu9Unuue//6rc/04PnLsYWfExH8s5Rp66lreLZ7Ceo9YdkVAx+5mhdTpym9AB/fEt4fk20etJnycmbfQaF4aWf0FjUbJtfkHbOFXv//Dvnfi3ozO6VVaf6Poll3LwwfPnLkZ0tqQOZk9naZdiQbUyvoP0n57oOT1etiSJPnGCviyBtVyGDNrjEIPqSex6HLNtKl4Y38LbRk7sK5fMXYTkrT7RNTNsf3/uYojI2mUQoK06iUohUR5LzLqXexB8eDAng/aYnLHbyAz7ZO4DZLMeXJyyLWd8EDUlOqO7a/WJrixY7gHXELkGaUtOJtYu1zop3aS+n9vGhZT7oC7JQMrrsW3m+jJ3Ittmu3yTJL1jxE1KYmVGSnRluVIPuHKUeFAgCZviwJPafKspA/skL3XvU0dSOWiaa/+bcLvsUkfHaDvJtJFU6rj05pjO6FZQogv5Dh4ibWYKMFI/Sp6LWYKgnAOescqeSKCeW7vKrby1Jrq9KZmkRyolvX9S7re3+4GUt6EskhJdyVMigWcuJgk4Bzx1cxRDXjXlMwQNB7sBQNf9lnQglrNyEDlR/7OYRFGCrG1/J9NfpZwkLk1VHU+lHiyA64zuDiW6oKRJspJsMHTgaSW7cySrM2uqG8FB5ZT9YZ8Ac+H9dbLtW9ql1P91VXGgbWwhdX2SZHjhfcoJqSb06vNkREp0zbD9lXRyazLDoC3E2e45B4sJSzKB0hPvkxWSYCRZp2JaU180xbr2GB9SqmMpnIEetD3U3y5POs0jWUp0YdgljjLMWGfd1hSgTGmKAwhrPUihOpuvxOrsVAF5rOWklMwAaotj6bpdE2tXydXT1KjdzODoNj9Q5rtDiS6s8hJHWbHEgoehpjzKPmqgM3S/KMiYz9TbvqWuZB+Q51KXdZD8pDHiqJj1YGHj3mC5tDGRgZTo4uoAh1Bnma6R6/VkCWZC9xU1rvGI93kFJS4h+3vM9qqgfzq6AnFcGteaVfU1U7b/Pkm19ul8NDZMwh29XqiCEl0Zpm8ypUEnS6MktwklsoM0rcfAJPhwuw8+UzfGA8MUxEgX6vvzF7oPxzrY2tTn6Aq98anPl4wo0cU08Magji89h2d9Ig781uX+j9AgRw/IKIzdD6XWRtXviqQv1SvelNDOp7ztUxtbVkyvF9qlRNdQoC0LN0P9PnBdXtmHkr905H6f65ok8DTcE1JNDFOmpDVvdftPCfDimNmbgNvWfP0ad7+Tmf034AnATYGrAp8D3gk8zt3fMkU5tynRlWVYUlCaUtDWlxK2/CypDcm61NXdOfrSw75PCW+4qoRIyW+alLwmzKa4R/fhwJVKn90SeDLwis3/zwQ+CDwX+DhwDeBngTeb2a3d/e1jF3KbEl0M9nTqSRKSY76hoGS4lAIIHagYl5KgcexcUjlDPT5MrtWGBlJcJtJq4m7G3d+7UwSzBwGXAi/cTPMG4A2laV4NfBr4UUCJ7uQ0ICUr+9dkJGa8JyUPDEqWFvhP0KeM2jbU7qrFaj/7/bbvlK/SykK535j7YJEfqO1UmXu/yDqt8AD81PfomtkZwL2AV7r7hQ2Tfhm4BLhskoJtUaIrSVBCO40u23nSoFoHm2pN0jbU/sJsb6cZks66urDaBLhLvzHFwTQldHnLcRxa2kHimFbRHmevs/cArgg8r/yFme1RnAW5JvCYzcd/MF3RCkp0QR1FqBEHgaGBmhLl+LRNV2StidJCqK0GaDiLvtoDBZK/HJNzGYUT5T26VzOzd2z9/xx3P6dh+rOBTwKvqvjuxcAPbv79SeD7qi59HpsSXQkX44DASJ1yU6CiIHBE2rZxKeAWmdzOGKF+rZtE+y0dwDgq61go57KPKf5m+bS7nxW0aLNrAXcAnubuxyom+QXgN4GvBx4B/IWZ3cHd31Ex7WiU6EociRxVzLojz1E5kND2D6MATCQt6rv6m/mS/jpD44FUEuXVxjVrXe++fPLmdz9gj4rLlgHc/cPAh4F/MLO/AN4DPB6402QlRIluIZEkLTer7XylXiKBgeRFV2TI7NR3SYn6npmpTabubOBcdz+3bUJ3v9TM/hm4+eilKlGia+rMRERii3U2pDyf1ffXa1//mBRIj0t1Veqo7Y3iYKKHU5nZWcBNgEcGTn954CzgX8csVxUlup7O5SmpWX1AKbJyKfaNoWVabP/Vtv5LWu8E65900Hf/LakOSzXt49ydDRwDXlD+wsyeDVwIvIPi3bnXBX6S4unLPzphGQElugU9dbmSM/J20SXjjRYbqMusUkxexzBkPbNueyvZv2NaSxuJKWqb6bL9c26rIhkys1OB+wCvdvcLKiZ5G/ATwIOBrwL+ffPZj7v7uycr6IYSXXyVL5WOZsh7ymIeYFhg0jxXsJV1kC+1FLyH0z3Dy6K6P762bTxau9lertqmrJgDPvz1Qu3Lcb8MuHrD988BnjN6QQIp0cVW8lLphUvxrHymyXfMoFBJwfQU1I9L21eOSHHsGWqEsWtouwkaS9Q222lMlpVRogvZJiSLk0PA0OXs//Ee80/toMvAttE1uFFi3ExJ1oRS7490JVK71PrTXCRY9ytvpVLs1l3NGJLc2JtaebJgHExwRjc3SnT11OVWkwXXezbNAJtygBijbDGDu7r9MVKAUVfX1tZGldBOYO5gPuV+aCnG3sZKpOc1dxuey4xn3Ccbi5vKs7J4QIZRouvgxxVwTG7KIG9tSYOXTiWPMSjUna0eKfAb/cFoImNTYrs82qcSW8gYOlWCX5FQj30QVpeoD6NNs0uJrh5GtSu1lrLWo7bR9Nx+fY4al5PsoXTkdhidcZqOxpF5pTZuifSxPYbOPf4dTD9+uIasbtTttVKiCxogp5J6wppToDpFAtNlf411r1SObXPu4GRbrDq9toQ5p75g6XLsA0RimPs9xF36wVhjROpxYuKmeOpybpToOmpYS6MgdXp929ASHyayxMA89pl6kTlpzJelqBpD5xiDNEbMRH1ZGyW6oMRI8rDEs2oKOEXmM8aBpqW2acUJaVvi+Biib3tTfV6Grd3vrjO6VZTo4ssdmGNa4pm33Iw5MK01SFgLBTVxLK2drGXsU/1fPu1jEamgRFfCrCUgWqM9U5AwBbWhBdDleTIPvXJM5rK21/vl5Wi/oPfo7lKiK7J2SsA6U9ApItk60IHNIHP08wkmlbVbYW9hV7jkSKFIKyW6IguiBExEJHFKNPNwmHRONa4mmOQ2KtdjJb6zUwi4S4mugx/X5WiTUCe4DArS1k3tWNZM/d/65JaAzmWstqExRwZQogs6BNJV304/9QAhx8409W06xNLa5VKCpSXXub5y7Dtkl+q2SHrULoPpqcu7lOhKdzknIE3Jxpo605z3Ya6GbvOlJMpLtKa+Q0REJBNKdN0VpCzY0u5ZXfzTD3VmrN7C6vKolt5OliqlOq64YB4aA0QkotUnus7ykiHpIJcnDm/eY5xKXR0t4Y4ZXCpgWq9E2onMZKIkNZX+OEW9x4hY+079fxp0wGhcW32QY7p0ucLqE11jBWfJAq1y0N7Tvu+jXFeSbENrG2AV2EmKEmuHs45zuRxYPTRgfOy7naONJV3r3dr7z8TaqUgskye6ZnYr4FeAmwOnAx8Enu7uzylNdwvgscAtgFOBDwNPcPcXbk1zOvA44H7AmcC7gEe7+1+PvBqLNHWyssrEeqGm3JdJJtUpUKCyGOobe0opkfTM26Ptjb89KxLpGHW/1xih/lMWIKEeMBlBie4m6bwTRdJ5LeAM4NPAvwJvBl7u7p8NmM83Aa8H3go8CPgKcE/gD83scu7+zM10dwZeBrwA+BHgUuDGFInxtj8E7gw8iiIRfgTwGjO7pbu/K2TdZD4hg5ECPilbS51QQp+HtdTHSaSUqG7LPWntI2SdbeBZ0Kr9HeEqq6o2qf5UZJ0aE10z+zHg54GbAF8A/hn4AHARcBXg24EfBX7PzF4M/Kq7f6Rhlj8M7AN3dfcvbT57nZndDDgbeKaZXRH4I+AZ7v4zW799falsN6NIgh/o7n+0+ezNwHnArwF3a151yYEGpwwD6VSD1cz4GMdmdam+pKxr/Zyqr+mb0OWaIA9NYLsYsU9S/JC27GKbBHnpP7pHd1dtomtm5wLXAP6YIgl9l1fUSjP7auAuwH2B88zsAe7+oprZngZcRpEob/sccOXNv+8FXB14UkvZ77aZ14llufsxM3sh8JjNGeJLWuahh1E10CCRhq77IUp9HhpARg7wfIXJs40RAB6PP8tkTBmcD6GDDfEM3ZZj9yu51MkxTVTfFa9MS3Gz5KKpF/4j4Pru/mh3/6eqJBfA3T/v7n/i7t8H3JIiaa3z3M3fv2Nm1zKzM83sQcB3A0/ZfHdr4ELgpmb2bjM7ZmYfM7NfMbP9rXndBPiIu3+ltIzzKBLqGzaUQwK4e68/Mq/ZB/wISa4f+JE/a1TeBm1/Vs8P+v2Z2oGf/CPz2jMdeBiLtu1iKM7LiA/8s0C1Z3Td/aldZ+bu5wLnNnz/HjO7HcX9tw/ffHwZ8NCth0xdC7g8xf25jwP+EbgD8P9RPHDqZzfTXQWoui/4wq3vK5nZg4EHA5zO5RVwDFUazKbuBGdP7BLUtk1a99GgAGXreFTPtnXkkJbkewlkqlI501ZuH0oM4tP4Po+J63YWbwKY2ewJqtqizCD0YVS3Af6vu59f8d0VgW8OedKxmd0I+HOKs64PpbiE+fuBZ5nZxe7+JxRnmU8Hfsndn7z56ZvM7KrAI8zsse7+eYo3A1W1mtbezd3PAc4BuNLeVVxB5EAHIwSNHQbF0M5bA99Jk22L/fjLmX2wnkVF5p9q0JBaf5pKUhuiaZ8qCS6kWu9jGLvtzNkWRnrwVJ01Jr6TjI1Ttr/UxpIkHd0fukd3V+jrhd4EfNnMfsTdX1n67sbAG6mMxHb8OsUZ3Lu4+2Wbz96wSWKfZmZ/Cnxm8/nrSr99LUVyfBPg7ynO3F6nYhmH9/peWPGdjGG7M4o1kI5wNLhtEFjDQLgEKe6nWZLvujYxdyLQ1gfEDl5ySmSHGGO/jp08z10Xc7OWunzosH5McBCnax+dwjgz+0FdJbWyAF3eo/su4KVm9gvu/pS2iWvcFDh3K8k99HaKJyhfg+JsL+yerT3sdQ5bw3nA3c3s8qX7dG9M8TqiD/YsowwR2ll1HdAn6HBHecrtXBZy9ieFYCPEYTlnD0wg3QT40NqC+UMpBnJLeTjZWuvUUqTSN21ZVDwQU4r9mJyQQgiSmi6J7s8BtwF+28z+E/AI9841/hPAzc3sNHe/dOvzbwcupjgL+3KKe3PvBLxna5o7bqY5/OwVwK9SPKX5eQBmdgrwQ8BrQ564LDNSZzmu40wT/E1839WhVBPgpBLespB9lWDAmZyE+q4lPoSs19PGh+6TFBLluQ9O5lSXEmqDIpK2Loku7v4/zexfgT8Brm9m9+64vKcDfwa80syeQXGP7t2A+wBP2SS/7zGz5wK/ZmZ7wDspHkb1E8DjDt+/6+7vMrMXAU81s1OBjwAPA65P8aojkXU7DAbGDOJmuqcwyUQyVTkFsDk4bE8JBNujvIJqjfxg/mRX7bRZAu1NJGXF61I1JpR1SnQB3P2VZvadwP8G/g54QoffvsTMvg94NPAHFA+d+hDwCODZW5M+BPh34KeArwHOBx7p7k8rzfIBm+U/nuKJzOcCd3L3d3ZdL5HFCgkQxgjyFLjJks2dGEl3TX2hEqllU3sdh9qNJK5zogvFa4TM7Nspkt3ndvztq4BXtUxzKfDLmz9N010EPHLzR2R+oYNpaoNDauURGVsOge9az9iOdZBse5+P3Oct8bLyJslcXZBDu14Sbe+ZbbU7B3RGd0doovs84FPbH7j7BWZ2W+BpwH+OXTCRLClhFMlDW1tNIYBbWbLUyYx97dqS2BCh22T0hFhjsKyK+qI2QYmuuz+g5vNLKF75ky/XoCUi+UnmDMpSKZESiU51ezk0BkkOel26vDg6AjiOFM6IyDzW2KYmru91AWNWwUeXbZZBnZotiM9g20gAjZmSER20SEBpF+g5nbtqE10zOyD8nLi7u5JmOSr14EtBxXi0bWczZ/DROcmO0EckFWxN2ecpojkp0deNLUrq47mISIWm5PTXOZro7gG/CDwH+PiYhRKZhAbu7pTApiWxOuzH5y7BAEoc8zX2vltrIp1Y/zKI2resgar5jtpE192PPPHYzPYpEt1n6PU9Iis1xbt5pbCkILOKAk/JxXZdHTPpTeF9vrn1O+pHRKSBLjcWke5yC4ZklwJEke76tJsuyfFS+1b1NyIjM1yvF9qhRBfUAQ+x1ku6pJ7ak4jISeoTRURmoURXhok9gCtxnp6CMBEREZG8KZzb0SfR1WaU8SjpEhERERGRgZpeL/TH5Y82fz/OzC4sfefu/mNRSyYiIiIiIiLNHN2jW6HpjO5t2D17+1HgJhXT6jSciIiIiIiIJKHp9ULXm7AcIiIiIiIi0kfmpx3N7DTgHsCdgFsA1wJOBz4D/CvwZuBF7v7e0HnqYVQiIiIiIiIyOTO7PPAo4CeBKwPvA94OfAq4CLgKcH3gEcAvm9nfAv/d3f+ubd5KdEVERERERLKW7T26HwI+AfwP4MXu/pm6Cc3sVsD9gNeY2c+5+7ObZtz0MKr/26GA7u7X7TC9iIiIiIiIrNvD3P3lIRNuzuL+nZk9Frhe2/RNZ3S/DvgC8BrgKyELFxERERERkYlleo9uaJJb+s0FwAVt0zUlun8M3J3ihuCXAn/s7m/sWhARERERERGRKe3VfeHu9we+luLG32sBrzOzj5rZ483sP01UPhEREREREVkoM7uumT3EzH7SzK67+ew7zewtZvZlMzvfzB7Zdb61iS6Au1/k7s939zsC1wF+D7gb8D4ze6uZ/WCflREREREREZFIfOCfmZjZtwLnAs8Efgd4j5ndCXgV8FXAXwBfBn7bzO7dZd6Nie42d/8Pd/8t4CzgiZu/79tlYSIiIiIiIiIbjwU+ANyI4mrivwBeALzC3b/J3X8I+EaKW2l/usuMgxNdM7uFmT0D+A/gZ4E/A57UZWEiIiIiIiISkQNuw/7M51uA33D3D7n7J4H/DpwJPO9wAnf3zf//c5cZN75H18xuQPGuovsB3wD8LfBoinccfbHLgkRERESkxDJ896Vn+nhXEUnR1wD/tvX/j23+/lRpuk8BV+4y46b36P4tcEvggxRPYH6+u5/fZeYiIiIi0kBJo4hEkHlX4jX/HqTpjO53ULxH9wLge4Dvsfqjju7ut41VqMnleDRVZEyZ95YiIiIyspjxswXfTSmHjs9dgKjOMrMrbP69R5HsfquZnbk1zY27zrQp0f1rsn31sIgMspSDP0rYZY2W0n5jUT8gMtzQfmXERNb2VtrnHZT+n3dX97tAeUc+c+vfvvm+01rWJrrufrsuM8qWge3vz12K2fhB3q1CpNHSxj4vj2pTL3/B/UUOyaHOePSTwa6d1Nz9SIpS69vm7o8m7GtWm6TKttuPNePGh1Gtg606eLCl5fhrH8BXXJcX60idHr/BNh78UjzSiwI5ScvSBn4RAeZ+cnJv7v7msebd9DCqa7r7x7vO0My+1t0/MaxYIj0p0VuWlBOEqa6G6Funex70UVImIiIiS9B0RveDZvYHwDPd/V+aZmJmZwB3B34BeAnw+HhFFJETlISkI/l9obM2shK6BUdEVuloHGKZdoVm9pwOk7u7/3joxE2J7m2A3wLOM7N/Bv4GOJfiHUaXULzH6AbAtwHfRXFL9G8BT+5Q2DQkH7CKyNI1PNU+H3sZXFFxsPLbGzLlTfdQagwXGY8OJMn4voujD5k6E/hq4BjwGeCqFDnr54HPdplx08Oo/hH4bjP7FuBBwF2AnyxNdjHwNoozuX/i7l/ssnCR3CwiGZF1yyEZHdNc668Ee5Ap+t7GZFpkraY6kKSEehgn26cuu/v1Dv9tZrcG/hR4CPDn7n7czPaBewL/E7hfl3m3PozK3d8JPGyz8GsA1wJOp8iwz3f3y7osMDWGkpfFW3tgL+ujPm0+dcmS+qHknWg1OighMr19jVtdWdYZWK0nA0909xcffuDux4EXmdnVgKdSXE0cpNNTl939k8Anu/xGFkgB2/yUyIikSW0zrjnOsmqMm4cOMExHdXwZjow3lu1Tl0tuCnyw5rsPAN/YZWZ6vZCZGnyqFDCKDKO+bXwKzsc15TigS5fnpf5qfRTnya5PAPcGXlvx3Q8DF3SZmRJdgH09nVSkkYL5ecwY+OmWjkLrfZspBOdqn3GozucjhXYnImN4KvAUM7sm8GcUie3XUCS/dwR+psvMlOhKFhR075r0wSltQYUC7XhGDuDUlrrpu72Sap9lS26vSoBEZK0WcFGKuz/NzL4E/ArwvVtffQx4kLt3eRWREl1MgZ/IYAouk6Y+blzZPa1X7VUGUH+yLtn1b5I9d//Dzbt1vw64JvBx4N+8R2VUoovp0uU2PvPR/0QfOZ9C56+AQ+SoFNqlpCPbPlLvBpbYesZSXdqQ+t+ZLWjzb5Laj23+9BaU6JrZE4Bz3P2jQxYmmbKOR/9jJ8blAX/mxDeFjjzb4E2ylUK9F6mSTH+o5DRPXWOcMUxxQqGufkaMqbbbosYMCWVmd3f3l3X8zTWB67r7W5umCz2j+/8Cjzaz1wLPAv7Cfe7TfBEtaFUWIdEzuIeSCapklRQ8iCTaDyc+do0m9wR/7TFg1f6LUJeTbKNLU97E+XZBv2dmjwWeCbzY3S+sm9DMvhP4UeC+wM8CURLdrwXuBzwYeDnw72b2B8AfuPu/B84jUb7ewUlkRkrYVmLMBx/pXlNAAaXMLIcYKvdkfGraXplYzH66IfDzwK8Bv2tm7wPOBT4FXAJcGbgBcBbw1cBfA/+Pu/9924yDEl13/zLwbODZZvatwEOBRwG/ZGZ/CTzb3V/dda1ERGThlIwOpkRWZAAlbbIGDniedd3dvwL8mpk9EbgHxWuEbgFcCzgd+AzwL8DTgBe5+7+Ezrvzw6jc/R+AfzCzx1C83+j7gbuZ2UeBJwHPXNRlzZIODVbTGvkovYJ3EWm01j4/hXtGJV8KwSVT7n4Z8KLNnyg6J7pm9g3AQ4D7A2cCL6NIeO9K8ZLfm1Fc4ixrs9agZKm0P0UkZWMnhKn0gWMcFNStI+1yuCS7SkoHSpR0T8oyrbJjCn3q8j5wd4oE9/bABRQ3DD/b3f9jM9kLzexvgN9Eie46pBIEiKxdSoGNSCpSG6NSuoolZlmWmjSnVn9CpZSga2ySmYWe0f134OoUN//eB3iZux+rmO6fgCtGKpukKNeOf+002MwvlbaTUrA9p7nbRCr1IXdjBfVznIlaasK4Tf3P+Pa1jVdjOU9dHk1oovtnwDPc/X1NE7n72wBF1EugICxfcwfwZWuvS1MEdlPs8wXtx6j3hw+ZV6wHdeWaPHRN7Kqe4F23CQPm3fzk9/3NMjuUsW9yvMQEN9c6GSK1MVZWbNp2ZmZvAm5b8/Vr3P1OZvbdwAOAW1I8TOo/gNcCv+Lun5ykoFtCn7r8U2MXZD62qABOViDlQXaNbWmqgC72fs9gX836wLKhyx6SxMZe7zm3Y1MS11Suqt9VbdO611dtz7umDIf1qzHh3bMRzxovMME91HXdckqMc73vNOXYQXLxcOBKpc9uCTwZeMXm/w8FrgA8HvgwcCPgV4E7mtk3ufuXJiorEH6P7qOBr6tKeM3sd4CPuftvxy7cZNT4RQoZJD8n5BQYlQ3tcwbsp2jJY47bP+arjoas/+AkOqdtX1PWtuTxcBs1JUzu9ft0OwEub+/SPFsT3pBkNyT56ZPYpnS/Zag+9XPJSf9cdur9SAm6YujVcPf3lj8zswcBlwIv3Hz0cHf/1NYkbzaz9wNvBu4NPKdu/mZ2GvAw4A3u/p4YZQ69dPkBFK8OqvIuipf85pnoGpkFDZnKcbBeglzqdo5JU5sZktleSWyMbZ/Tu3JTSPRjtMuc24x78zbYHi+q1vMwKWpKYLfrZPmsb00S3ZjwNiW7bQlEaBK3lHFyKeuRoi59x1Rn1avq/9TJby6xzsimfuqymZ0B3At4pbtfCFBKcg/9w+bvazfNz90vNbPfoHiPbhShie51gA/UfPdh4LpxiiOLpU4obzkH1WOLOaCncKa2j8NEIoeEty7467r9+l6SC+GJQFN9GPMMWMi2iLX8kG3Rtqy67+sua274TfN9uzUO+4C6hDfgMmogrP3PkURq/M7L2GPBlEms6l7q7kHxEOLntUx3eF9v47Oetqa5AcUDkAcLTXS/Qn0W/nXAJTEKIxlbQiKky29kDCMM1LMmtU2aEouupk6aYyVuZvHmdbznfAbXj0jlH7odgs+EBta7lvm1JrmHbbku2awaQ8rJ79B9s199NrpRqv3F3DTm96PkM10+eN9czczesfX/c9z9nIbpzwY+CbyqbgIzuyLwVIoE9uUBZfgfwNPM7B/d/d0B0zcKTXT/BniUmb3E3U8ktWZ2OeDnNt/LUqQ2KGowklRNOOAnm9yOJdekOfaZ1j77PeX7HYeWrWu9GGNbtCW820KS3z5y7A80lodRIinz+bS7nxUyoZldC7gD8LSaV85iZqcAf0pxsvRWddOVPJriYVb/ZGbnAx/n6NFXd/e6Jz/vCE10Hwv8PfB+M3s+xXt1rw3cD7gqcP/QBSYpxwEjR2MOchoYJENJJK8xE4EU1qdKzKQ5RaleMj7Wdh9QZ3tdmgzxLhnO9Ym9fa0luVUMkqwkxtmxzLtq96N4wVvlZctmdvjdHYA7u/s/B873OLDz0Ku+Ql8vdK6Z3R74nxSZ9h5wAPwt8IPufm6sAknCEnu9SfTOa8mdoYwn5bNnI9tJGla8LfqK0o8dPz58HiPonVSOZa6HJK0huV1aQqvEdRaLTkrH5kS76yTQ2cC5DTngs4AfAu7p7m8Inam73y5C2U4IPaOLu78duM3mCVtXBj7r7hfFLIwkZkkP2VHnKWMZWrcSSQaSS0pWQtu9h9Sf6ruGxBaWldwqsZ2UEtq8mdlZwE2AR9Z8/yTgJ4Afc/eXT1i0HcGJ7qFNcqsENwdzD0KRBg53H94ploNJdbL9KCjPipIoWaS2sWXuRHh77F1S0jt3TFGm5DSYEsstS94W03V9ZwPHgBeUvzCzR1MkwM8BPmBmt9j6+lPu/qG2mZvZtSmeAXUbiltk7+ru7zGznwHe4u5vCy1ocKJrZjegeNHvdYDTS1+7u/946LzSYul13rmZYLCJkuwenWH4tCl0ioklLNknUOVAWAHTpBR0rdvo/UdKiXDOSe8csdHEfbH6ograJtLAzE4F7gO82t0vqJjkezd/P3DzZ9vzaHmuk5ndhOIhx8eBtwDfDJy2+fq6wLcBPxJa3qBE18y+H/gzintzP8nu64Qyj3rlhIQC/mQGoKnPBieaRCaV3MYOVGPPL6F2FFsy7VKyVVeHJutjyu1zqsQ3JHGcKhme+wD/RH2k+ivyS1xTfbheko7uW5ugK3P3y4CrN3x/u4GLeBLFq4juCFwMXLr13d8Dv9llZqFndB8PvAm4r7t/qssCkmdgp+zPXQqRkxK95zOpgGE/obJItZTqy6GUDtbIjtn6mE1/ksbBvLzikVnHhRT7mJQpgZQ83Bq4j7t/yczKHeIFwNd2mVloonsD4OcWl+RC0VGe0vlW5eWaY6Afc5lLf61IFQ3+ItXUNo5KIrGrMcO+Supg3tooCZuP6v1yJNyld9AUuF+Njs+JCs3w/oXiZmBZuroOb8yAaHuZsZezPXiuMemVdVGwONya+gkFuBJTzv2P2oJIKt4OPAB4ZcV39wb+rsvMQhPdXwCeamZvc/cPd1lA8py0j2ovQSrbN3QQziXQzTmoOKTgYhqptMEc9G1XqsvLp3ZUUF1fDu3LvJV33zK6qMcBrzez11I81dmBO5jZTwN3p3gSc7DQRPexFGd032dmHwAuLH3v7n7bLgtOigYv2baEBLKrOQY7DbD9de2ztK2npe29TH32q+KLvKkt11vwQxdlPu7+ZjP7AeCpFK8oAvgN4HzgB7q8WgjCE93jwL92mXFW1JGF0YCdvtTqcmrlWYrydlXbTIu76r4UVA+mF7M/HLtvzbl+hDytXMnwZMyneeryFNz9L4G/NLMbAtcAPuPuvfLQoEQ3wqOiZQlidsg5d+4iqRnzPnfpR/uhmvp+kZNS7yeGttcp31kti2BmV3D3LwG4+weBDw6Znx43bGjgXSodSexPg1O+Dvuz1AMoWSedIRPJh8aRtJV3jy+i//usmb0DeCPwV8DfuXunJy1vC050zezawM9R3AR8VeCu7v4eM/sZ4C1dr5kWGZ2SNVkzBfzpUxDZTvVYuhpSZ3Jtk2on67TM3f5w4PbA/YHHAJea2dspkt43UuScl4bOLCjRNbObAH9Dca/uW4BvBk7bfH1d4NuAHwldaFL01OX0qMNeF515T9tS2mOS/XzNttVBOpF5LKW/2zb3GLvEbZqM8vM65ilFTO7++8DvA5jZjYHbAd9FkQD/f8DFwFeFzi/0jO6TgPcBd9wsYDuT/nvgN0MXKNIqyYB0AmsZDOYedHOVe/2IXf7Unzw9pB+L1UaUMIssz1Rj6Nh9Zu5jmkzho8CHgesDNwCuRpGHBgtNdG8N3Mfdv2Rm+6XvLgC+tstCZcHUcUmbGMH3GpPlMQ4ATdlecz+AlWP552onSrBFxjO0fYX2C7H7PL0tQAKY2XdRnMG9PfCtFInt3wB/AvwE8E9d5hea6B40fHc1oPdNwrPTw6jyt8akZ2ypB6qply8FIe1CgYaMQQm2dKW+aDpNEf2otI/jO7pNF/J6odcDXwGeDTwSeIe7H+87s9BE9+3AA4BXVnx3b+Dv+hZAZIcS1/lt7wMFj3la+n5TPyFl6rfmpWQ1D1PtJ51Ekn5eRvHg45+hOKv7RjN7A/A37v7FrjMLTXQfB7zezF4LvIDiEMIdzOyngbtvCpQnPYwqPccD94c60Xmovcgcyu095UQmhSQ81f4x1/4jhXKnUAaRUKqv49t5vdAspYjK3X8QwMxuTpHo3h74ceDyZvZO4A3u/kuh8wtKdN39zWb2A8BTgedsPv4N4HzgB/J+tZDD8d5nxKXK3t40y0mtE40RWKa2TiKpmPvhU13mV07ChyS+YyasY827aV/1WebY/WLX+Q8pz8Fs142KyOIsN2Z093cB7zKzZwC3BR4FfDfFfbtxE93NAv8S+EszuyFwDeAz7v6vXQotKxFrIJ8qYY5FSapIOuraY9/kbnt+Xeexnfh2TXqHLLfLvFPTp2xdzvJ3mX/XskyRzMbad6me+Zd5pNwnSDNfxj26ZnYKcAuKM7nftfn3acCngT+jeJdusOBE95C7fxD4YNffiXSmI98i7XI7IDS3voHcdkIwJBgMvTVDjhojAB9jjMktUUihvEq255dCPdjiiZUnWcvcTJ8Dztj8/dfALwBvdPf39JlZUKJrZme3TePuf9ynACKjUmcpqRsa5IUG60qIh6nrS3I6eyedrDHYtjmSzjGvWugixT4yw/5l8naT8vMapraMTfErwF8B7/IIlSn0jO5zaz7fLoASXUnDCoMTydhhfR07wCsHTCkGdSkaO9BMsL9aY4InBXefJ9mdW6r94WG5xuyHYl2tcmJ2R+vP6P1JCg//k2jc/Ukx5xea6F6/4rOrAncBfgS4X7QSzUGD+njmGDDXOEjPSe0njqkS3kO6NaCfFdT3VSY6Mq+561zqBwK3yzNV0httljXzXEFfOrrypl3IJjWzawI/R/EQqqsAnwHeBDzZ3T/RZV6hT13+aMXHHwXeaUUNfiRFwityVIyObO4BUJpp/wxTbiMa/EVkLVIdP+qSyRQS4BTKIIlItP0MYGb/Cfhb4Ezg7yieC/W1wE8DZ5vZd7r7B0Ln1/lhVBX+hiLRFRlHOfBPdWCUeSlBFJESXYY9zOhn90P3Tyrjvq6EkaQcbT9LeOoy8JvA54Fvc/fzDz80s+sCr918f4/QmcVIdG8BfCnCfETCKHCRFVCALjISPbwmmHe5FnKkeyXNbPxxP5VEWkRuDzx0O8mF4upiM3ss8IwuMwt96vL/qPj4NOAbgTsDT++yUBHJhxIuEZnV3Imp6yxeJStdQjtkPzUkyV3GoN5noDXOiaTiNOCLNd99cfN9sNAzuo+t+OwSivt0nwA8sctCRQ4piRKRxZs7UZNulNjWKye3sVS1kR5niGPEFHoYm8is3gX8lJm9yv1kZ7x5JtTDN98HC30Y1XLvfHclW9FMFcylFoSs8YFbYwU7koaUX9eQS9KYWj91KJXxLrc+ryv1kcPN1NY7Xa69FimPCWtWrqrLqLq/BvwF8D4zexHwcYqHUd0LuBHFlcTBYtyjK0syxcASOwCcMnAbbfvEOZodTVsQOnQfKghMWy7J5NTGTl5TSUKnsLR7LtWnjS/Vg0cpi1Uv5xwTlGSviru/2szuAjwe+CWKR0s78I/AXdz9tV3mF3qP7nU6FvL/dpl+dgrq8hYjoAkNulLrcFM+K6LAbx3maBNz9dmhdbpvQB6rPS8lYU65fysr73P1f/HF3KapJM2p15MEYh5dSt5ggZvGzK4GvMndzzKzywNXBj7r7l/pM7/QM7rn0+2E+H73oszF0+nw1iS1zn2BnYWsXAIBymjGXrehifTs/ZvGtNkprijM3hZqpFquviL3iVGTyxQS1cW+e3hr23q+rxcys33g/wN+BrgicNzMXgn8uLv/+5B5hya6D6M4ffwF4MXABRTXS98buALFA6kuGVIQWZGlDTAiqVhycjul0O2Y6tVA6mOPUtI5Hz9QfYxphD5+cFIbO5FdbFIqDR4K/A/gTcA/ADcA7k6Rdz5gyIxDE93/CrwTuLtvPbnJzH4NeDnwX939Z4cURFbkMOjQ4CfSnZLZdKSyL1JNuFOhsUaWYKT+pumBrEFJcOwHch7owFQ4b/xvRh4E/L67P+TwAzN7CPB0M3uIu1/ad8ahie59gPt7qTW4u5vZs4DnAkp0pZuqo+wKSESOSiWZarCme6iSfEp/BnVEJGmpHiyauW1P1t8FLGdN48wK3QD4+dJnLwKeCVwX+EDfGYcmulcArl7z3TWAr+pbAFkZJbIi7RJOXNYebMRY/ySTZZE1S7jPlYL6zQrLeb3QFSguU972xc3fVxwy49BE903Ar5vZ+9z9Hw4/NLNvo7g/901DCjEvU/KVKg08IqNZe8IakwKw/Kj+p0vtSWSVrm1mN9j6//7W55/bntDdPxw609BE9yeB1wNvNbOPUTyM6muArwc+svle1mTCJHS2gGSpgZCCCJHOFHznS0ltXrS/pqW+bRmMfJ+6vPGSms9fXvFZ8Nt9ghJdd/+Imf0X4P7ALYBrAu8B3gI8z90vC12gZGjiM6uTD3JrG1Rjr68GSVmBWP2Sgso4lAyJxBGzLal/k54GPVm5SegZXTbJ7O9v/iyLLpGdXFJBivv6kt2YtO1EgiXV94nIOo2UkKp/m1h5c2d6nMHdnzfWvIMTXQAz+ybgNsBVgWe7+yfM7IbABe7+xeZfy5Jl37kp2RVZNr2bcT30ehKRZop3ZCWCEl0zuxzwfOAeFMcPHHgl8Angt4D3A48ZqYySgZDLVZJPhue85Cb1bSPLoGRPcqYEVkSkmmd/j+4oQs/oPgG4A/CjwOsoHkZ16FXAw8k50U31/WlzmeGl5LEln1SXLfm+ltz2Re6UzM5PCZlIf+rD8qYxf0La1m1CE937AL/s7i8ws/KTrj4CXC90gWZ2K+BXgJsDpwMfBJ7u7s+pmf7ZwIOBP3H3+5W+Ox14HHA/4EzgXcCj3f2vQ8sjFcZK/Ce8F3rqByJkl1hPKbckPud9qQBxXnMnuLm1ta5ybpu5U9+yDCm2oRTLlIuF3KM7ptBE96rA+2q+2wMuFzKTzT2+rwfeCjwI+ApwT+APzexy7v7M0vTfAdyX3ZcIH/pD4M7Ao4APA48AXmNmt3T3d4WUSUawwod75fCkQSXjgcbal1Ns/9BES0Frf3Mns4cy6HOiq1pn9WvT6Fvv1dekZcx+o29bXGNfFos2XavQRPcjwC2Bv6r47tuAfw2czw9TvPvoru7+pc1nrzOzmwFnAycSXTM7FTiH4rLph5RntPnNjwAPdPc/2nz2ZuA84NeAuwWWaZWJmaxPDsl4iqIdIBh7+3cpZwrJWt8AOIWyx6R2OUzd9lMCnIaltVeRpHjjfyU80f1j4L+b2fnASzefuZndHvhZ4LGB8zkNuAy4qPT554Arlz57FEVS/CQqEl2KRPYy4EWHH7j7MTN7IfCYzRniSwLLJSJSKeYBglHPqoeWM5UEYE0BsJLZ6W1v81TqvMgc1P/IioUmur8F3Az4X8AfbD77W4p7bF/o7r8bOJ/nAg8DfsfMnkBx6fK9gO+meNAVAGb2DcAvA3d290trgsObAB9x96+UPj+PIqG+4ebfshK6NFckQDnoUbsZn7axHErtUt4lHnBSYheX+i/JWFCi6+7HgR82s98D7ghcA/gM8Gp3f3Powtz9PWZ2O+BlFE9qhuKs7EPd/YVbkz4LeKm7v7FhdlcBPlvx+YVb31cyswdTPOCK0/euEFR2CTdawjl2Z5taABJDTkGMgpN5LHG7pxaYpdq3zLmdlljvctRUN+ccPxKrH1Pd+pPEAfspy5Bq35iNo/tKrxfa1ZromtlpFA+Peoy7vxb4m74LM7MbAX9Ocab1oRSXMH8/8Cwzu9jd/8TM7gd8K/Bf2mZH9dXorS3U3c+huP+Xrz71GqoWkUTroGPNRx1ovG0wRcAzdL8nFhjJjOZ8aNHY/U4KgXAMc62H+olwe3vTJ7sT75/Unl3RVp4kEuE+FI/JTFoT3c2lw9cHjkVY3q9TnMG9i7tftvnsDWZ2VeBpZvZK4MnAbwIXm9mZm2n2gFM3///y5rcXAtepWMbhvb4XVnwnFZLrOJs6+tweuCPxJBaQSGbcp3/y9RjBnZ483Ez9RFyHdXiq8bStLkfev8nFP1OYYp2V2M5D3d+O0Ht0Xwd8D9VPXe7ipsC5W0nuobdTPEH5xsDVKRLiXy9N8/XAvYG7Ay+nOCt8dzO7fOk+3RsDl1K8n7edrbSjy5WCGBHpa6pk99DYSe+hrv1iamOe+vX0levvXAeSx6i7qde/1NorKJGVbIQmur8LPN/MTqFIMj9O6biBu384YD6fAG5uZqe5+6Vbn387cDHwXuD2Fb97IfBuilcNvWfz2SuAX6V4mNXzADbl+yHgtZ2euJxiJ5Ka1AeCnlK7bCkWHbwRqTHXw7imSnpDLLTfkwks8UopjZfdHRzM34/JUY7O6FYITXQPHzj1SIrXCVXZD5jP04E/A15pZs+guEf3bsB9gKe4+xeAN5V/ZGYXAxe4+4nv3P1dZvYi4Kmbd+5+hOKJztcH7htQFumiz0AwQTC11ER1qNS2ixLv8aW2z1O1UxfH2G5t9X1IsqDgcnxLTOZEYovZTjR+9aTt1iY00X1AjIW5+0vM7PuAR1O8puh04EPAI4Bn95jlAyjO8j4eOBM4F7iTu78zfBamwGFbzI4rckAZPZA/UAdRay9uYqokLGFraAdb9Tl2Xaw8iNNnGaEHg9aWJCvplCY51ulYxmobEfvI2cb+NYxrsJPn6qnLu2oTXTP7LuDt7v4ld39erAW6+6uAV3X8zfVqPr+I4izzI4eXbMUyCSQOA8poHWdVMrf0zjFyApur6HUpR0uv69vK6xqxHWzXoUFXLkzxkKlM+vrVmaMfWspVNmu+hHaOp2J3MOn4uqbxTDppOqP7OuCWFA+Kwsz2KC4r/nF3/8D4RZuKJ91RZG+Ejm7Uy2D3FzL4S5DcLqmOGjh0TfaWFEgcrsvMVy601r81H4iRcYXUrVz6x6Vf5TB1jBrparwY42twn6qD+AUNGTuaEt1yrTHg1sAVxyvOTBRMTC+XAVRkLD36nS6BQ/Sj6XWBRM4JcFXZJwyYlnRFQW4HjSRArFf9pUwnOtqF7uvcTmwsgTZPq9B7dEXiCu0Q1cnJUsW6t7N29s1tZ9RbACQJChJl1WNoDmdrx5Djq58WdNBvTrpHd5cSXV/WUfW5jBZQad+0W3MgszQT7stebVbtUXKkPjK+lJJI7d+j9htegpJCH16ViGsfykjaEt1rm9kNNv/e3/rsc+UJA9+jKws1xcECnZ2oEXPbaxtLE9WPNKQQrE5hbfUtpeRxbHPt2yXXqTnuu+7TF62pno+ufD/1PKVIWVui+5KKz15eM23Ie3TTY0qgZAVSreMa8Kaje9GWI9X2LMNM1UZT6HfLCdJUdXoJ9x2ncqArlXKINGhKdKO8Ozd91nyZh3S39IB6jM49xQF2jmAoxe0wlqmDhLb9ufR2G1MKiYJMbyltJMZ6xG4DXfpD3So1H22jdDk6o1uhNtGN+e7c5K0puB4qpJMbOwicO9hYUn0Ze18taVvFNuOTLCsl/k7G2cyV1KrthJky8C7XhTW3l6p1n6qtTPHOaTlKCa5kSg+jkm7mHkzcdTYlhjn349x1KBVTP3k8hYNUcpTawnBjbsO2NqP2kk8dzqWcqQrZfkqGJUFKdA11gDnRvpqPXiMT2WZ7TvUe2u22o4BE1qjr+KHxZnwaVxakYl+qDY1ra/saeq1uFSW6oI5WRObTtf+JkRjrfYeyBCkG0YonZCop1v8prHW9pRclusVjl+cuhIhImNmvltzqL6c6Gy35UwKYhrXGO2tdb1kXDck7lOgaus8mdTqDJHJSSvdK7St4FFm0uRPEuZffwnUAJ5jpwGh8qn6tlOiijmqISTqusQc6JdKFxAOKxRmz3sXel2oj7dR+RNpN2E4U26VF+2N8pqF6hxJdUIAygC/iZLj2v8xh3HoX9SCU+shFGysA1Rmc/CWVnKgf6k/bbqG0X9so0dU9usNUbTud/RGZneuyYpmZ6qCckFuclVt555TSwZC1KW96hd87lOhKfBogREREZCyKM+JRoioLpkTXgP1FXH8bRpeSSUqWcPZfAZdI/hTsi8ShMXE+CwipYlOiC+tqlGNcSraEZCVlSz44saa2V2dtAbYelCVjmas/UT82nNqxiIxAia4Ml8sgn+tAurZESKrl0s6mpu2yK6W+Lpf9k0s5l0rbX2QY11OXqyjRNcNPWcmlywdzF0BERMZihwluwkmDJ1w2mdhKQi+R0ag/baVEF9ZTUfbnLgBpnWmQeNbShuagNiOBXK+akFzlMIakUkaNCVJHVWOHEl2ZVt+BQh17HKkM1BIu1j5TGxKRqaQy1qRSjpiWuE5daCyTDpToSh7W3rHnSvut3VSDtvaFiKQg0b5Il9VnQvvpBC9tCt2ju0uJrsgaaaBIh87YLpvaWj7UhrpJrG4rURUZl5m9Cbhtzdevcfc7mdkVgV8BzgK+BbgicHt3f9MkhSxRogvJddYSjwY+WY2R67plnASoH5AgqiciIk0eDlyp9NktgScDr9j8/6rAA4F3Aq8D7jFZ6SqsPtF1Yz1PXRY5lHHSIjVGDtL1oCMRiUZjUD96e0atnA/G9rVzqfLIm8Dd37tTBrMHAZcCL9x89FF3v8rmuzugRHdupqO4qVhhJzUb1XnpQ/VGZN1ijdND+5K1xgtN52UWlASvMWnNkZmdAdwLeKW7XwjgntbOU6Ir6SgPfGm1FZFlULK6XOozJXeqw/0t6OLExiuIFpTQD5XAw6juQXEP7vMmX3IgJbq2W1HWQE9mE0mMElBpoyQgLdofsiapjFH7cxdg0a5mZu/Y+v857n5Ow/RnA58EXjVusfpTortSCRwFanfYqSqYkCVIJUiQfHWtQ+o749L2lCXQWLRMTox7dD/t7meFTGhm1wLuADzN3Y8NXvJIlOh6okmenKROOX0KANuVt1HC9XqNV7mkJsq4lHAdS1ZTX6btKWulup+oWffL/SgumE/2smVQoisJyTa43htQ8IO0EsTewbXONHXnPknwMFu7GtIucjFi+822P8xEbV+ngD5taxw7Eq+T6qtmVN720zaPs4Fz3f3cSZfakRJdmVWSHeSUAXrosiZKiLf3x6hXOqz9svQlJrhrSGzLYq1zYge81qCqfejqrgwknvQtXZIxm0zOzM4CbgI8cu6ytFGiK70surNrCzrHCOgTDHQnSXq7BC2pJ8UzBmA6a5uJBNu5nFTXjpQAyxIsOm4TjEn7qrOBY8ALKsti9r3AVwE33Xx0WzO7GvBld5/0wVVKdFf61GUZYIXB6mRnepvoSD6QSH+lBDfcCvuLpWlrc0qEx5NEfyciJ5jZqcB9gFe7+wU1kz0TuO7W/x+7+fujwPVGK1wFJboi0klI4KHAr78sArsDV7IbKmQ7KRnOWhZtVkSWb4KhxN0vA67eMs31xi9JGCW6eupyKw3i0pXqzAqknJzlloTnVl6REbmu3pmVpX6bkEgHSnSlVdcDAatLchSkSk5STlBj6bOOaseyoUQrEdoN42jpHseq/0qgx6dtvEuJru7RXTcFt7I2qvMijZqCRSXBkr3QKhw5Z1LbkTko0QV8f2/uIiyWji7JWmlQ3zLGpsi4a1G/mK8++059gWRJ1TYvTtbj4liU6IIac50IDUaXwMhcVh9cLn31p16/iF1OXd1Uv7ZMVft19f2TTE91bnm0S1sp0ZV6qTSgithPQYJkbUnVN8W2OEbC2Gc1Oz/fIP62VPI8nMabmcSoutp1J8XqC9QeJCNKdCX9Tivx4skIlhScp96+lmiubV6utwns+sYkbUHNTKSS6vhJsfqjLuOzxr9J6S0yu5ToGmqImdHDw8Y3e2epNrkosdvs7PWzTtd6O/cBnSU0s1TrgkhqqtrK2H2Au8ZzmZUSXZQ4iZR1bRPJJh4rtfQ+LYX1i1LnFQCGqzsooE0oMg31V+lTLLZDiS6o8cpyzHSGSIlxHCkkcKOYso+dqA0sdl+lSuN0VtTHyxTUD0sbJboiS2I2/+WQAeoGp6UHR4sclFNLQPqWJ4N2I5KLufq6pY8hclTd/l7kWBtA9X+XEl1JlwLP1Vnr4JQ1tVOZUmoHVmQcPfsVjSHx5Zg85VhmGYcSXRnfRIGwOrZuJgkIFJSmSclpOtRG0rU3dwEW6CBwOrWLehP33+VYIdlYa43jWnmVV7gJ2ijRlfGVB6yROqPQxC3ZTnqgyY9kpxCIpBqIhgZzc4m175YcWKRQvyWuVPuLNRmyD1LvV6cy8+0ZQ2KNUeOvNfbZK1zlrpToyvTMZg04FhyaSypWE1BrlJV1a3xPsZxgMZKs1fSrY5m/rir+GpEv90TOEEp01yrBAWPWgGH+/j896jBFJhUlGVgBJZf50T7LQEa7SPWpoO3QTokuJJn0rUkSDTVmfDnH6ig+Fsle375wqQlyEmODyBpk1tSW2ud1tbPbtFl2KNE102CaiWw6tomKmUy9TaQYIp1l0qW0SaYvkCNSHLNUVzrIaVMNrWrpVVWRKJToQl6dWVeZdl4pBgi1+j4gY+CVBEO2UbRgZ4S2o0Csu6zaS0piVDVt+myonYyzDZLtsxMt1ihC1jXT6q9222Br2xi6R7eKEt2lm7qjj9TIhgyck3eKGVz6PlogUrepBz2VUT21ZGRI01JVn9QY/eCa+qtkE9o6Tbsms1XpZGFVMrt6NyVtm1arT3QdNaKotjblXAHAzv5cWKefBW3z+albS5/20fhG7osUP2RKY5Qs0YoOvIVafaILrCfYmLj+Dw0AoiXKue3fhfVTazrj0dWoQXLoZs+tfYh00bd+q9sSEcmeEl3QgJaorknAYhKquROPyJtRZzwmos0sEs92e1rI0CIisjZKdGUxlFB1V3lwQJtx1dSOlm0xBwSnVG4S2oTjUfczHtXbxdPDqHYp0RVZsT5JjQLlPCmBFThZD9SOB9DZ3v7UDc0n83qrPquCtkmr1Se6xeO4VVFEspRa0004iFM/JzKChNt81tRdSYkO1lbY3iaO2k2F1Se6gCqGiMShvkTmpDgwa2MG8skf6EqgeMlvo0BKCEVOUqIrIrIySwnohlhkMLjE3brA3VRnVe1y4lVd07YNXddF9oErZwdzlyA9SnTdV9UBiohIooGvgpRqe3MXYLilJRVJth/pZI59uLR2IOlTogsKLkRiWEAwKiswZX8/USC5+Cdtbu0zTz1OrgnkbZGn2yVpCY7JOkASWXl7avPuUKIrInHETCASHKAlYakcrJwwiFt8cltje72TTHqb6oDOZsmUYveLGpclQ0p0RWQeTQHh8emKIZKjJJO8FCm5zJfO/o2ra9tI5YCi1FrrAdAmSnRFcqUgoLMxBwElHhKFEjNZg5nHryUmBJ3HoLH3gfoySYASXVkfJYirpWS02pKCvuz3cc79kwJbCZFAHXdbVr8Hxfok1f912c/qO4ZzkmhbqVGiC6oYIrJqVcFRrkFgruVehFme4jr5IhWUD5FQvDVW3Qntg5JKSueWUL2QZVGiKyLTW2ugmNFgvsQzHrPIaJ8nre5pxgM3b69kI3SfrrWfW7lUE1j158unfbxLiS6qGCJdDR7IFfzPSn3ehMrJjup+P+XtFimJHNIWWvtB7WtJSOi4rfFBlkSJrgMHatWSmZmPGGsgjExnftajz75WwrQrgW2ifnBjgv5r9rOkc/XRCd4OoHqfMO2bHUp00Qusx+IK3sejKpuOGNU8Zh+kdrc8bftUY1gc2ozN6qphn/rXsZ8qJ1fRE99U+80u5ZqoHzjc9skkvGvu/1a86qGU6KKETGQwNaF0hAz66vPGt+bgK1dzNIupqklKTT5C/9OWZCX3qp3EJJGkrmybyzyU6Iqs1VyBj5KsfmIGBQowRNKwlO4wsX49iUQuRWvo+1ewilUM1fsqSnRF1mKqOCSxgGcxDrfrnIGKBtF6qvbrpP5uXdaQKE5Nm1RGpEQXFKCI9KEAb3pzB1kxd/nSgpulrc/ccule5m6T0s3QcWuqcW8N9WoFqzgp93XUm46U6BoK2EVEppZbt6v4YVpr2N65tYElOEwEUo/76sq3lERmIash6VOiKyIi0qYcdypQk6Hq6lDiOVi2Uk9uQ1StQ47Jb+eHhY1SisXRPbq7lOiKiOQidqCWY4CUihxj5hR2d47bTbpbQlKZizVs6xWsYi/aLq2U6JLAi8gzls3RIwX001jDgLsk2l/pmKKPynF3q46KAInGqmqfaVGou0OJrgyy3fEmnfRud8ZKeuPQACcSj9rTKiWZvCQu6Vijo6z2f8591N7cBZC5KNGVaNo67GQGp5w7axGRRCloH1mfYP0geilm5zptNa0c20rZAttBlWTi7IQo0ZXJjBkEqXGLtMsqEZF1mSKYHvmsjqeYEOyPO3ub4gqpcpIyxXZe45VfKdZfkYGU6MoiKIAXEZlY6oHxRJcrJpngTmR73UdLeqv249hn6Fa8TyVTDhys8ABNCyW6IlNb0gCq+15E8tc1aVh5u19zYttkkqT30MrroIiEUaILy0o8RCYIACYL9JbeNBd28HWSyxglPiUNO5TMDtO0/dRPiIxETWuHEl2RnCQSkJr7NIFgjE47RjE1eARZY3KgoH2Z6vbrGut4bNqGeVEfJzlTorsWiSRIshwhg18SAY3GaBnRFHVcgWY6lrQvkuifU6bNA656krTSvtGDWXcp0QUlgSIjWVJQWLaKwX8Fq5jDgZByXVtyu5LpVNWjLPu1DIucDW1byZwSXZlUloOoyFopn0qS+tGMaFeJiMxGia4ZvqeRKAoFxRLbXE0z87qsM37TmT3p1PC1Y/Z90ibV4iXUbWTXh3Utbqp1YKDk297C7FS73NrNBJToSjzq32QphtTlmcaZ2QPDsd9r2dVEt6QcbvfRA7wV9a9JBMsJFGFyMdd5YHdUVwdm6+diLzZ0fhnUwyTaq0iN1Se6jhrpVGYPxEWmMGZ30tCExurHgtvtgp51kOSYcLgbEixabKF1btT9VFeEFWz/XkYe3meNH+YMXTI4U6zYbj7l3a2HUe1afaIr00kyeBRJ3JEgYoYm5Irs05JaIDNj9Zjlye9Ni1xTU5moHq42we0rxzKLjEiJLqxrcEqBOmKRYLNfwte1f1T7XpfEz3xO9s5vOLotEln/6CZu3242X7Jbtw/Vx0mKHNXNCkp0QRVDRJKXzeVhSw3wJVuTJruHYjTXsYqcSVdyaPbbMnZ+GLccIjIeJboikrVsEkARkS7UtY1Kt1NNQJt4VOWLSBQP7Zr88SFmdisze62ZfdLMvmBm7zSzB259/91m9nwz+5CZXbT5+5lmdo2KeZ1uZr9tZh/fTPsWM7vNtGskWbOM/whQBCu5/xGRONTGZFXmjkMUp0jiJj2ja2bfBLweeCvwIOArwD2BPzSzy7n7M4GHAlcAHg98GLgR8KvAHc3sm9z9S1uz/EPgzsCjNtM+AniNmd3S3d81zVpJZxl3fj7rg1fKH8xSDGnT44BqrEA8maO5KRQj0fahpGtdkmmTHWRdRzMuushgqb3mLwFTX7r8w8A+cNethPV1ZnYz4GzgmcDD3f1TW795s5m9H3gzcG/gOQCb3/wI8EB3/6PNZ28GzgN+DbjbBOsjZVPfBrWiQW1N65qqoEf3D91PA+LiwwA1WnCdX4x+Ut+yx35Ib8ykQX1AvQnrao7JaxdD1m/yJFltQkQaTJ3ongZcBlxU+vxzwJUBSknuoX/Y/H3trc/utpnXiw4/cPdjZvZC4DGbM8SXRCq3tJlwsFHCJ1Ob9N105fo9whni4EBWbS3YJAF+1W5bwz5KLK+c9UnAiZrtLPCK3i8t0kb90q6pE93nAg8DfsfMnkBx6fK9gO8GfrThd7fd/P2+rc9uAnzE3b9SmvY8ioT6hpt/S0xLTmj3FjRSHuTV2ekl5w1GqJZZX5qYilTqbOgxi5UHQLHrvNpQYtZdvUWkxqSJrru/x8xuB7wMePjm48uAh7r7C6t+Y2ZXBJ5KkeS+fOurqwCfrfjJhVvfVzKzBwMPBrjc6WcGln7FJhrPJ0tsl5TQ1qlaxwSSXyW07ZK/YiH19jNSPR90j/zAIk2apMZaVGLVJKvLcUVWYO0H32I40jPpPbqVpn4Y1Y2AP6c40/pQikuYvx94lpld7O5/Upr+FOBPKS5ZvpW7H9v+mp4Xcrn7OcA5AFe80tepWiQyhh8GkqMH+m2BcOqBfFkCCaysyBj1ra7NLaVuD7wcPSTRihY0Ztb9bVNCKpIPtdfhFjJCjmrqS5d/neIM7l3c/bLNZ28ws6sCTzOzP3X3AwAz2wOeB9wBuLO7/3NpXhcC16lYxpW3vg+jtpaUurN+k53pWkpwnRidzZVaibe56HV37MvR096c4TQ2L1sm9XTqM49JJ4AJF00cdJZ8x9SJ7k2Bc7eS3ENvp3iC8jWAT2w+exbwQ8A93f0NFfM6D7i7mV2+dJ/ujYFLgQ9GLbnMri3YTP6Sz5VSgtuNuepySrKsv6o/o1tqG83twXsxpHYJbV15Jk2AR1zUUtuOpGnqRPcTwM3N7DR3v3Tr828HLmZzFtbMngT8BPBj7v7ymnm9guL9uveiOPN7eKnzDwGv1ROX10cJQpq0TyRnqr8yliwPooxprLbWepA840aeQdHVh05HfcquqRPdpwN/BrzSzJ5BcY/u3YD7AE9x90vN7NHAIynel/sBM7vF1u8/5e4fAnD3d5nZi4CnmtmpwEconuh8feC+k62RJEXJrohEl9t9+6TZD84ehE14ifzs65qh0epsgm1BRKYx9VOXX2Jm3wc8GvgD4HTgQ8AjgGdvJvvezd8P3PzZ9jzg/lv/fwDwBODxwJnAucCd3P2dIxRfEpdiYCdbMkwWkpP4vazZmrlurqXvGrqeg5PHCR965qZkF1ZQt2P0HerXRUYz9Rld3P1VwKsavr9dh3ldRHH295GDyrT0jljWYwXJZIrtdbKANsX9m1KQlsj2ma2O5nwJ5qGG+yVH2677xYxjt+OEWsa6TNknxVpWIn2XZGbnPnf1OmWTJ7rJMfB9dTBz0NHu9KSYRALJB/BuJDvAjN7OVhCgjdouZq7bc7T5xjo54/ZItv8rS7SvGSpaXzVmn5TSgb2R6YCdlJnZm4Db1nz9Gne/02a6KwO/DfwAcAbwFuBn3f3dExTzCCW6MpuYnaiS5npJBm9LHMj6rNMEAWvo/l9zG5qkjUxc55Ns9xtTlG3R9Tm1/jNSPxZSL2bfrws8sLfE/m+VHOxg9KU8HLhS6bNbAk+meEgwZmabf18f+Cngs8AvAm80s5u7+7+NXsotSnRBDXABZgvqhg7wqnvrltD+TzkxWgpt4+loW0+oph8bIyk9sl8XemY7GQmNT1XUxqfn7u8tf2ZmD6J4resLNx/dDbg18F3u/sbNNG+heGjwLwD/7zSlLSjRRY1FBkh8IBDpTVU7DsXi3a2l7s2xnhPWx8rYKubyt8bf2c/0ygmKqWc08cEfMzuD4jWvr3T3Czcf3w34j8MktyiWf97MXgl8P0p0RUQkiAKK9GkfiZx05IxsvNlmcdlzopSYygD3AK5I8VacQzcB3lMx7XnA2WZ2BXf/0hSFAyW6Rae7N3chRDKhQGE+CkZEhkupD0upLHOYuE9TQpcZ7a92O09dHjzHq5nZO7b+f467n9Mw/dnAJzn6Np2rAOdXTHt4xvfKgBLdKbkuPxUJU2oqpnukkqP+TNaiV/9T1zzG6srW2kWm3g2lXr4F0xiVtE+7+1khE5rZtYA7AE9z92PbX1Hd882y45XoikhvGrBEWqiJnBT7PbUN/U/nJDhkP/Upv/Z/u4S2kcY0ydnEJx/uR3FN7PNKn19IcVa37Mqbvz87ZqHKlOhCUp2syNK4bg1YrAleZSBLMuFY62bxz6YOKH8OV79MkuRFXsSs40vMdUm8eiTb1ye+3RbubOBcdz+39Pl5wPdUTH9j4P9OeX8uKNHFTYF4apLtUDOSVJ3WgaT0RAoOkqpnshjRxoCE+p5REu8hRt42UfqGCGXM5gztSMWMdYDF94laf5fYxpMw0QE1MzuL4qFTj6z4+hXAA8zstu7+5s30VwLuCrxgkgJuWX2iK+lR8JwQDSLLNNKTT0ViWNIYcCSgT6Q/nX37jp1k55LcTsDN4l1NEPHBR13roE6AJOds4BjViesrgLcAzzezR1FcqvyLFDXotyYr4YYSXRmHxpksKCBI12SXOirpnZ6aXZb69JezJ5Wyeof1NvqYMuWtCPtNX05WjOR4efye4ICAmZ0K3Ad4tbtfsFMm9wMzuwvwP4FnAKdTJL63d/ePjV/Co5Toyq4FBmFK6DKU6i6baFCtqrOjJ791z0qUcKnW20xk2VdnWOTJqD9JxnbbyuGe8WBqf5Ny98uAq7dMcyHwwM2fWSnRBTWSFVhUp74ly6Aw1DJ3WfoWXKVytOg2ngpt4vFMuW01ZgSL2a8sNb7KjeHaFxWU6GIKJAZQo5qXtv+6qK+SE1QVFskT2K+W67CSwLbLwoSv+SpTzCJTU6Irg6iDE5mOuaeV7CZUFJGUpJCw9pVi2bNNvlNUtX9nuCVHMaFMQYmuTGaKAF0dpyxd3zo+SvtTc+svwWRC4lFiJlnp0h/Fej1dSgdts1XahoqBdyjRBQUcsc3YztRxttPBgHXSfm83af8xdHeoqztJVVuWLLW2nlp5aqR4ZUJ0a1jHgZToSnx9Gp4Clck0BfNKhmTNQup/MgfTqoqaSNGiUpcka1fXBhbQ3leRjE5JMdwOJbqSBnV2YUbuw+YO4pVoZyCXXTRSVR6rjkZpe7nsmxmpj0nH3ONNdha4ubpc4q+kWPpQoiuSk9Q6+hmf3rgEswbdS4/3p16/gVVXCVhG1rqrInfPoXV+sePCQldrLLrvvYKX/n0wV0HSpURXRHZpQBlFEslMAkVYpPJ2VRC7HGozhe3tMGH9ruo3F5H8zl2vFrAJRdoo0YX5OxuRAEkkSTIf7f68KPFdjhlfx5KskPUfsc5rPIxAm3ABju5EtYtdSnRxVQw5StVBRGJby8Oj1mKG17FkZ63rLSLJUKIry6KBVURyEbu/WkPirD5eEmIR7on0veHzEAH01OUKSnRBA6fIQDEGexGpFhwIr3QsU/+ToZXW1Sp2fO4CzLx86U0P6Gq3+kTXXIPkXHQUM23JtQt16JK6sV5plFpbXDr1NcnSrWb1ej+gK7Mn1Esd1xndCqtPdGU+Ct4WQH2q5E5B17qoz8raIp62vHZqgzIhJbqgRjczHaGVNZgsQJspDkz5Co3kDqqpy1sP5WUyhhX0IYoNO3J0RreCEl3pZZYOKKX2O2VZ1hwoLWjdR38XZMRZpZy09tFnfUZJjkfuN5YeGCZ/Ni/x4smC9KlrM3UPS++XJG1KdFEjTEZOu2F7kIlR7rUFSGtb3xpd+57GQD9i+5n04SihdSGn/mEkax+rplr/bO51FEnM2vuo2aV29VIClOiCBicZRknbSdoWo7IDdVbZUZtIX6lZKVjPkNqZiFRQoisiwynIGGbKuFoxfH9jXi6oNjSeuer82tvalHV6jdtafcaO5G9vkMkp0XXW2UFKM/WV3agNTSeTbT3V+/08hWA6Rhnatpf6pH7mbC/aZzKm2HV7AfV17VdjrH39qyjRRS9cnsOkwWkfqhOyMEvt5/quV9Q+KKQMQ5c3dP+l3ufGtNC6LjKqVNvNmvouiU6JrsxiOzhNPuntqsv6pDqwyOIctrOlJrxNZu9j5l7+2ugBZyLLoXYaTmd0dyjRJYEgSMaRw37NoYyyKOrvItF2zN/U+1AxqIjIpJToGgpYRGQcC+tb9KAPyVEy9621NZ9EiikiGXJAb2bYoURXRGQszmKSXSW5kis3SyfZbZJCE8tgM4mIhFKiq6cur1sKgYUsW+r9S2AbyCJREJFhxh4TU+lGUilHyhQfZcZ1j24FJbqs8+EssWV735/2vaQohVfmiIwp1zGjZOlXOkQ/wFXeXGP1P+rXhtM7wGUBlOhKsGyTWZHcTB2kqW3L1LbreMb1LzQRTD0hnu2KjcPNMtc7YZUQ70q7qkoTndHdoUQXJXAism52MHcJpjdrv68xp7Ci7aBL/1vMVReWWgdV3UQAJbqydksd5HKnQbpVMrdcpBrAt5xBi7X9eiXMTctOpU9KpRxVEq1yWUl5/04g9TPsZZ0PlIy1eqm2vVTLNbbyeqc6Hs9Iia6sm/qEMFPHBKnGIAnVl75nJKMnyJkFjCEmP9ub4iZMqK7LCKbavynWbXSGPVgum6mpnuWyDjIKJbokdGYkcbrEe8X0UIrCAtavUzvOuW9cwL6SzOTcXpoMaUu5bpMU+49ct+XcUtyXsWyvm96jW0mJrgSb9VI/ycOC3hsraF/KMikW7Gas7ZVy/6I6IrIISnRR4rUmOZ29V70UkVXJqH+WCFLY3xpnZTEcfIVPlmyhRNdQR9fVDINTkglqzHt8Ku5znGqdoyfUU5/VzaH9plh/pTvtx8VKcoyRQYLGNu13yZnqbyslutJd3eAxUoObJACZ+8EUnZ+oGC+7296+WZxFzqGMZRO3GSnRdl4NJaxyaM11IYuxXGQCSnQdBUEJmH1AWuCTY/so74feg2Ws/Vm1/LnrSkxLWpfMzd4HiWRMiZVIAuY+aZMgJboowBGpM3vbmHv5a6YBcxo6yJY0JXCJ0/5JepycPYaQ1VOiKyKyJEpQ87Kk/bXApP0wUFfCm6jD5rOm/ZNol6GkdmZ6vVAlJbqAqWIsmgKUkS0wuE1CZglQ7kGO+okI5qyzI/dDudfvxdP+EZEKSnQd7Lh6yBSMFWiOGv7sLTM67rQvYgW3a0qYZ05iFbTvSnWbKAEPlOqBoVz6tVS3H+m2zbVRX5SBhNvxXJTowjqOBGbQQUV7ENKU+lwNkEFyPMvlenUddC6BYlkiA46CxLzF3H9Z9KlLk0g/kJLs+qQ5rvpLME4I3W/qZyQlSnQhiyQwV7N2eAkOFLlJ4tVDKwgUkwr8dCvHOBLoj5KqZ1JN7U8grB4k0KdUUT8zoxXES10p0ZVgsx+lS7RTXwsNXolTgJw27Z9sqe/rZ/aYYenUp4iqQCslupKPLp26kmJJXQZBigL8MAro86Z6Po6m7ao2IxKb64xuBSW6EiyrYEAPGJM1U/WfVGPfqIBeZEdW8YQ00kELSZkSXZbdSFc7mKx1vUVqmI70DuZ9HoyWwmZf8BgnIvNabZyZGgcODuYuRXKU6KJGKjK5XAPvjPuKqiRNyW+7XsntlBIvnoiIyFyU6ELWwauUWOlvkZjGrlcT90UhSdzSk+FkEtlEirEoGVbdlNpbMm1DlkHVaXwJ9R+pUKIry+KoM5V81dXdGceucrCbUiDeRzLBeyLFWJwJq2fubaHNEtYvmfYu47RN7V5poURXlif/sbmgDlwgufqswHEAbbpxJXhFxKElJI0h1D/IpNbRrMKtpJ/pQomuSKrUX8lYFItK7jLrH5UARqBNmLbM2qSsgxJdEZEcKMiTtVHgvDzqx5YrwVtvRJTogjremS359U4p0FPFRUQkCW3jkeKB5dE+nYjDgQK+MiW6Br6vVpgLJcXdORMluwl1sEruRUQy1LXvVkwgIg2U6Mqssk9ch953NdGDA9q2c5TEcK9mITMkwDnVKyXlIjXa2rHazrJl1I+LzM7B/WDuUiRHia6T1JmopNQlLhFlH+Sv9Ql3ajPR5JSUL032/c/aqe1kS/2eiExBia7UUzIjIgumYFtkAhMcNC9T2x6HDg4mplzPFbfvUKIrIiIiIkfNkKA2UfI6P+0DyY0SXQM/ZW/uUuQnw0t2dSRSpMIajwAnFsCHUIApSdN7gkXml2FsPjYluga+9jy3T7uIPKhNkYSeCBTVEciMkjvgkmHSl5JJE1AlE8F0YCB/yfWVCzB7u5h7+Uuj7dlKia4k8ZLvcuc76gAXEiwqGZaRzB5oBFpakJnkdlfi2ijJfSaTGbL/l9Z/hUi+vaRevty5w4GeulymRFfqbXdKEw8afTrsqAObAtBayQ+mEsUK40SRo9TXTS9Sx6NxKkEaVOLTNm2lRFfCzJj0hoo1sKV6JDi7gTu38opMKdF+Jmvqc/KnfTgN9T/LpKsRdyjRBXWsh0Lbx9K2V2m9s0soD+VabpE1UnsVkbmk2P8oR5MRKNEFfK0PYyl3KivdDCkyHZUTWQzXrRC9Jd0XJly0JKkZrEevh5xGL8XylbaZ6x7dHUp010ydSno2g4MC40LSQa4AqqtJyGkXdGzSMetX9P4kgQc5Jifxurim/mrW8XOOzbzmdie1Vp/oul4vlBRb+8Go9YzBQSqDEg1m0pXaVTrG2hcB/cKYSc6RpEL1rbc1JaJjW922XNnq7nLdo1th9YkuoMYxpq5H73XQQUREBpr6oOnqkooxKEYfh6qmrJgSXRnXkA5Wg14+NJCuk9qoJGrOg6arvzKpr1TGkRT6tVS2RSQ6iTGObB+eOiElupKeFAaZpVFnKGNQvRLZ4ftzl2AkGpvXTf192hw4UCMtU6IL6rxzpU43K7q0bxx6YJdINfU5kaW0OVMqS6o0NKyAGkIbJboyD7XNRVFAOZ9Y214Js6RG/UpCtCvyM9U+09CRDtd9E2VKdLH1vkdXRGRDSYWI1NpOZtRVyDbVB0mYEl1QI10rHYWUKamfkb7UV0lKDuuj+rQk6IFEK7a17x1w3aO7Q4murJcGB5GoUgi4bInjfOh2XeK6y/QSaMcSbrvPS6EPHmwJ6yDJUKIrIsEWMYjKok1RR5NNptU+RVYtpG+adBxXnzQdd92jW0GJrkgGskwwcyzzEqWalGUsVntMNmGW3rLsqzdWWx9TW++R69CoZ4AnrP85t7Xcmdn3AY8BvgU4AN4P/IK7/9Xm+5sDvwHcevP9m4BHuvsHpy6rEl2RDIQGIEl1/HVlTqmMS5BakCbBkmqvsnpD6mPWSfIK2uGofc0M2099Z7Up7tE1s4cAT9/8eRywB9wcuPzm+xsBfwO8B7gvRa75K8Bfm9nN3f2ToxdyixJdkQWZMtjoPdDkHBCJTEFBXFzqc0anxCNh2jcSiZldD3gq8Ch3f+rWV6/Z+vejgePA97r75za/exvwQeDngV+YoKgnKNGVNCgQiSuT+xQVHMkiJVivU21rkxycm2vd1z6uJVrnRBZr/Ht0H0hxKfKzGqa5BfCWwyQXwN3/zczeA9ydiRPdvSkXJiIiItNKNcmFtMsmA2i/iizRrYF/AX7YzD5kZsfM7INm9oitaY4Dl1b89hLgG8zs9CkKesjc133I0cw+BXx07nJsXA349NyFEKmh+impUx2VlKl+SspUP/NzXXe/OoCZvZpiHw5xOnDx1v/PcfdzDv9jZv8CXIsiaf3vwIeAewEPBX7G3Z9mZi8GvgO4vrtftvndFYGPAV8NXMvdPz6wnMFWn+imxMze4e5nzV0OkSqqn5I61VFJmeqnpEz1U9qY2fuBGwE/6O4v3fr8VcA3A9ekSHL/FngO8D8obpN9EvADwD7wte5+wVRl1qXLIiIiIiIi0uQzm79fV/r8tcDXANd0978DHgHcE/g34HzgTOB5FJc0XzhFQQ8p0RUREREREZEm59V8fnhX/gGAuz8DuAbwjcB13P0OFJc8v+3wcuapKNFNyzntk4jMRvVTUqc6KilT/ZSUqX5Km5dt/r5j6fM7Av/m7p84/MDdL3H389z9Y2Z2U+AOwDMnKucJukdXREREREREapmZAW8Abgb8EvBhikuUHwQ8wN2fa2ZfBzwM+HuKh1b9N4oHV73a3X9o8jIr0RUREREREZEmZnYl4IkUCe6VKV439Bvu/oLN918D/Alwc+CKFE9m/kPgae5+bPLyKtEVERERERGRJdE9uhtm9vVm9hIz+7yZfcHMXmpm1ylN89/M7NVm9u9mdrGZfcLM/o+Z3TJwGc81M6/489SKaW9tZn9vZhdtlvNkMzsjcDlVy3Azu3lpuj0z+0UzO3+zPuea2Q+GLEOmtdL6+Ugze6WZfXzz/WND5i/TW1v9NLP/ZGZPM7N/NrMvberoK8zsZiHLkGmtsH5e0cxebGYfNLMvm9nnzOxtZna/kGXItNZWPyt+c5/NNP8WsgyRLk6ZuwApMLPLA39FcS35jwEOPB54o5l9k7t/eTPpmcAHgecCH6d4otjPAm82s1u7+9sDFvcp4G6lz468ONnMvoni0d2vAe4CXB/4beDaQOj17c8Fnl367P2l/z8O+HmK6+z/Efhh4M/M7C7u/n8ClyMjW3H9fBDwBeDlFC8jlwSttH5+D3B7itclvJNi3X4BeJuZ3crd/zFwOTKyldbP04BjFJcXng9cbjPv/2VmV3f3pwQuR0a20vq5vbwzgacAn6j6XmQwd1/9H+CngePADbc+uz7FQPHIlt9ekaKD+t2A5TyX4qlkbdO9DPgAcOrWZ2dTdIDfEvB7Bx7fMs01NuX+1dLnbwD+ee59oj9H9snq6udmur3N36dsfvPYufeF/lTup9XVT+BqbG792frsq4HPAn889z7RnyP7ZXX1s+G3bwHePfc+0Z8j+2TV9ZPiSc+vCS2f/uhP1z+6dLlwN+Ct7v7Bww/c/SPA3wHf3/LbL1N0NFHeC2VmpwJ3Al7sR9819WKKFy23lSfUHSmO+j6/9PnzgZua2fUjLUeGW2P9xN0PYs1LRrW6+unun3Z3L332eYqzFteOsQyJZnX1s8FniLQuEs1q66eZ3Qq4H/CImPMV2aZEt3AT4D0Vn58H3Lj8oRX3tp66uYfi6ZuP/6A0zflm9qaKeV7DzD5tZsfM7P1m9mgz29/6/huA08vlcfeLKZ5cdqI8Zna7zX0N969YzsPM7BIz+4qZ/ZWZfWfFOl9CcSlMeZ2pWm+ZzRrrp+RD9bOY31WAbwTe1zatTGq19dMKp5jZVc3swRQHuJ9aNa3MZpX1c5NUnwP89naSLxKb7tEtXIXikrOyCykenV32YuDwoU2fBL7P3d9bmuYYxeUo295FcS/seRSdyd0p7qG5EfATW2WhoTxX2fq/b5ZRPvP1fOAvgP8Args8CvgrM/t/3P1NW8v5XPmsxGYZ2+WQ+a2xfko+VD8LvwsYSiRSs+b6+QiKegnFWb+fdvc/rli2zGet9fPRFPeOP7FiWSLxzH3tdAp/KC7JeGLF508AjlV8fgPgW4F7UNzT+jngrJ7LfgpFh3Gjzf9vtfn/HSum/TvgDT2WcUXgo8Dfbn32+8DHK6a90Wb5Pzr3ftGfE/tkdfWz9L3u0U34z9rr52aaX9ws94Fz7w/92dk3q62fwNWBsyguR30GRWLykLn3if4c2Uerq5/ADYGLgDttffZcdI+u/ozwR5cuFz5L9RnMK1NxZMvdP+zu/+DuLwW+l+Ko2uN7LvtPN3+ftfm76Yzqlbe+D+buXwT+kqJzPHQhcGUzs4plbJdD5rfG+in5WHX9NLOHAr8O/LK7P6fr/GV0q62f7v4pd3+Hu7/a3R8O/C/gf24uG5U0rLF+/g7Fk6bfamZnbp68fBrF1fZnWuCrjERCKNEtnEdxn0TZjYHyJSFHuPulwD9THKHq4zDRPLyE+EMU984eKY+ZnU5xJK+xPC3L2b5M+TyKy0a+oTTd4T0YfZcj8a2xfko+Vls/zexHKc6UPcndn9Bz3jKu1dbPCu8ArgB8Tc/lSHxrrJ83Br6PIpE//HMf4Fqbf+tyZolGiW7hFcAtzOwGhx+Y2fUoLuN4RdMPrXgH2lkUHUQfP0LRAfwDnOi4Xg3c28y276G+J0Vi2liemjJeCbgz8Latj19NccnMfUuT3w94jxdP/ZM0rLF+Sj5WWT/N7O7AHwF/4O4/36v0MoVV1s8atwW+RHEWUNKwxvr5wxTvId/+8xrg05t/Px2RWOa+djqFP8BXUTx9+N0Uj0+/G3Au8GHgClvTPZviSNMPUgwYZwNvpzgC9p2leX6QrfsZKG7K/2vg4cD3AHcFnkNxI/8zS7+9OcX9Cy8Fvhv4cYpLRv6sNN1tKR46cPbWZz9Pcf/tjwC3o3gB+bspktpyGX8DuBh45GbaZ27Kc9e594n+qH5SDOD3BO5NMRi/ePP/ewKXn3u/6M966ydwm03f+U7gO4BbbP355rn3if6svn4+hOIgzH0387kH8MJNP/roufeJ/qy7ftZsh+eie3T1Z4Q/sxcglT/AdYA/B74AfBF4OXC90jQPBP6e4l10h49bfwFw04r5nQ+8aev/V9nM86Ob315EEST9JLBX8fvbULzc/WLgAooneV6+NM3tNgPX/bc+uyvFQwM+TfGUxc9QHIX7topl7AO/vCnTJRSXwNxz7n2hP6qfm2mfu/l91Z/rhW47/VH9jF0/gcc21M3z594f+rP6+vkdwP8BPk4xtv878HrgznPvC/1R/azZBs9Fia7+jPDH3B0RERERERGRpdA9uiIiIiIiIrIoSnRFRERERERkUZToioiIiIiIyKIo0RUREREREZFFUaIrIiIiIiIii6JEV0RERERERBZFia6IiGTBzDzgz/lmdr3Nv+8/d5kPmdm1zezLZnbW1mfnm9nza6Z/7GYdTjGz5wau++02v72amT3RzN6zWeZXzOzdZvYbZnbNzTRnmNnHzexeU6y/iIjI1E6ZuwAiIiKBbln6/8uAc4HHbn12CfDxzbQfmqZYQR4HvNHd39Hzt8/a+v9PAD8O3Bo4vvX5e83sxsBrAQN+Bzhc3jcDDwH+M3B3d7/IzH4LeKKZvdzdL+tRLhERkWQp0RURkSy4+1u3/29mlwCfLn++UfXZLMzsa4D7AXfv83t3/xBbSbuZ3Wnzz7e5+7Gtz08B/hy4GPgOd//k1mzeYGZPBb5367PnAr+xKdeL+5RNREQkVbp0WUREFqXq0uXN5b//ZmZnmdnfm9lFZvavZnbnzfeP3FxK/AUz+99mdvXSPE8xs180s38xs0vM7D/M7ElmdnpAke4PfBF4TcTVrHIP4L8AjykluQC4+zF3f+XW/z+7KdNPjFwuERGRySnRFRGRtbgS8MfAH1Ccxfwk8Odm9iTg9sAjgJ/Z/Pv3Sr99PvDLwAuAOwNPpLh8+E8Clnsn4C3bZ19HcgeKS5n/T4ff/DVw28CEXUREJBu6dFlERNbiisBD3f2vAczsPyju8b0LcGN3P775/BuBnzKzfXc/bmbfCfwQ8GPu/sebeb3ezC4Enm9mN3f3d1Ut0MwM+HbgKWOu2MbXA59y9690+M0/AacB3wL8/SilEhERmYHO6IqIyFp8+TDJ3fiXzd+vP0xytz4/Bbjm5v93Ai6lOPt7yuEfioc+AdymYZlnAmcAnxpa+JEclutas5ZCREQkMiW6IiKyFp/b/o+7X7r552dL0x1+fng57zUoznp+Cbhs68/hfbBXbVjm4TwuqfjuGLBf87t9wDn6VOU2HwOubmaX7/CbizZ/n9HhNyIiIsnTpcsiIiLNPkPxJOPvrPn+P1p+C3Dliu8+Sf2Z1GtRXIbsQSUsvB54EMWTlf888DdX2fz96Q7LERERSZ7O6IqIiDR7NcWZ2a9293dU/KlNdDdnjT8C3KDi6zcCtzCzI8mumZ1Bkay+sWM5Xwr8K/Cb5adGb+Z7yuFTprdcf/P3v3ZcloiISNJ0RldERKSBu7/JzP4UeImZPRl4O3AAXA/4PuDR7v7+hln8NfBtFZ8/jeLVQ39vZr8OfAC4NvBzFE+IflzHch4zs3sArwPeZWZPA96x+fpmwIMp7j/+y62ffTvw7+7+4S7LEhERSZ0SXRERkXb3A34KeCDwSxT33J5P8R7aC1p++yLgbDO7nruff/ihu3/SzG4J/CrwWODqwOeBNwNnu/t5XQvp7u81s5sBP0+RRD8WMIok+qUUyfW2OwMv7LocERGR1Fm3239ERESkCzPbo0g0/8jdHz93eQ6Z2bdTvFLov7ackRYREcmOEl0REZGRmdl9gScD1+/4ntvRmNnLgM+6+wPnLouIiEhsunRZRERkfC+guP/2esB75y0KmNnpwD8Bvz93WURERMagM7oiIiIiIiKyKHq9kIiIiIiIiCyKEl0RERERERFZFCW6IiIiIiIisihKdEVERERERGRRlOiKiIiIiIjIovz/B4lMrxkBhgkAAAAASUVORK5CYII=",
      "text/plain": [
       "<Figure size 1080x720 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "time_steps = 30\n",
    "slope_threshold = 10000 #This number needs to be adjusted in order to correctly filter out non-RFI NOTE: 5000 works\n",
    "LL_Set_RFI_Regions = Find_RFI_Regions(t_plt, LL_set, time_steps, slope_threshold, 850) #Returns an array of [freq, df, time, dt]\n",
    "\n",
    "first_RFI_region = LL_Set_RFI_Regions[3]\n",
    "\n",
    "#Try plotting the first RFI_Region\n",
    "\n",
    "power_min = 69\n",
    "power_max = 75\n",
    "\n",
    "t1_plt = first_RFI_region[2] - first_RFI_region[3]\n",
    "t2_plt = first_RFI_region[2] + first_RFI_region[3]\n",
    "\n",
    "freq1 = first_RFI_region[0] - first_RFI_region[1]\n",
    "freq2 = first_RFI_region[0] + first_RFI_region[1]\n",
    "######################################\n",
    "rfi_start_idx = find_nearest_idx(t_plt, t1_plt)\n",
    "rfi_end_idx = find_nearest_idx(t_plt, t2_plt)\n",
    "\n",
    "f_plt_start_idx = find_nearest_idx(freq, freq1)\n",
    "f_plt_end_idx = find_nearest_idx(freq, freq2)\n",
    "\n",
    "RFI_duration_time = t_plt[rfi_start_idx: rfi_end_idx]\n",
    "\n",
    "RFI_freq_bandwith = freq[f_plt_start_idx: f_plt_end_idx]\n",
    "\n",
    "\n",
    "fig,axs = plt.subplots(1,1,figsize=(15,10)) \n",
    "fs = 16\n",
    "\n",
    "im = axs.imshow(10.*np.log10(LL_set[rfi_start_idx: rfi_end_idx,f_plt_start_idx: f_plt_end_idx].T),aspect='auto',vmin=power_min,vmax=power_max,origin='lower',\n",
    "            extent=[RFI_duration_time[0],RFI_duration_time[-1],RFI_freq_bandwith[0],RFI_freq_bandwith[-1]])\n",
    "\n",
    "divider = make_axes_locatable(axs)\n",
    "cax = divider.append_axes('right', size='2%', pad=0.05)\n",
    "cbar = fig.colorbar(im, cax=cax, orientation='vertical')\n",
    "cbar.ax.tick_params(labelsize=fs) \n",
    "cbar.set_label('Power (dB)', fontsize=fs)\n",
    "\n",
    "axs.set_xlim(RFI_duration_time[0],RFI_duration_time[-1])\n",
    "# axs.set_ylim(RFI_freq_bandwith[0],RFI_freq_bandwith[-1])\n",
    "axs.tick_params(axis='both', labelsize=fs)\n",
    "axs.xaxis.set_major_formatter(mdates.DateFormatter('%H:%M:%S'))\n",
    "axs.fmt_xdata = mdates.DateFormatter('%H:%M:%S')\n",
    "axs.set_xlabel('Time (UTC)',fontsize=fs)        \n",
    "axs.set_ylabel('Frequency (MHz)',fontsize=fs)\n",
    "\n",
    "#TODO: I don't think it's clear which region this method is flaggin as RFI\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ade17336",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "input starting frequency: 900\n",
      "closest frequency measured: 899.75\n",
      "possible RFI events: 2\n",
      "confirmed RFI events: 2\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Text(0, 0.5, 'Frequency (MHz)')"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1080x720 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "time_steps = 30\n",
    "slope_threshold = 10000 #This number needs to be adjusted in order to correctly filter out non-RFI NOTE: 5000 works\n",
    "LL_Set_RFI_Regions = Find_RFI_Regions(t_plt, LL_set, time_steps, slope_threshold, 900) #Returns an array of [freq, df, time, dt]\n",
    "\n",
    "first_RFI_region = LL_Set_RFI_Regions[0]\n",
    "\n",
    "#Try plotting the first RFI_Region\n",
    "\n",
    "power_min = 70\n",
    "power_max = 78\n",
    "\n",
    "t1_plt = first_RFI_region[2] - first_RFI_region[3]\n",
    "t2_plt = first_RFI_region[2] + first_RFI_region[3]\n",
    "\n",
    "freq1 = first_RFI_region[0] - first_RFI_region[1]\n",
    "freq2 = first_RFI_region[0] + first_RFI_region[1]\n",
    "######################################\n",
    "rfi_start_idx = find_nearest_idx(t_plt, t1_plt)\n",
    "rfi_end_idx = find_nearest_idx(t_plt, t2_plt)\n",
    "\n",
    "f_plt_start_idx = find_nearest_idx(freq, freq1)\n",
    "f_plt_end_idx = find_nearest_idx(freq, freq2)\n",
    "\n",
    "RFI_duration_time = t_plt[rfi_start_idx: rfi_end_idx]\n",
    "\n",
    "RFI_freq_bandwith = freq[f_plt_start_idx: f_plt_end_idx]\n",
    "\n",
    "\n",
    "fig,axs = plt.subplots(1,1,figsize=(15,10)) \n",
    "fs = 16\n",
    "\n",
    "im = axs.imshow(10.*np.log10(LL_set[rfi_start_idx: rfi_end_idx,f_plt_start_idx: f_plt_end_idx].T),aspect='auto',vmin=power_min,vmax=power_max,origin='lower',\n",
    "            extent=[RFI_duration_time[0],RFI_duration_time[-1],RFI_freq_bandwith[0],RFI_freq_bandwith[-1]])\n",
    "\n",
    "divider = make_axes_locatable(axs)\n",
    "cax = divider.append_axes('right', size='2%', pad=0.05)\n",
    "cbar = fig.colorbar(im, cax=cax, orientation='vertical')\n",
    "cbar.ax.tick_params(labelsize=fs) \n",
    "cbar.set_label('Power (dB)', fontsize=fs)\n",
    "\n",
    "axs.set_xlim(RFI_duration_time[0],RFI_duration_time[-1])\n",
    "# axs.set_ylim(RFI_freq_bandwith[0],RFI_freq_bandwith[-1])\n",
    "axs.tick_params(axis='both', labelsize=fs)\n",
    "axs.xaxis.set_major_formatter(mdates.DateFormatter('%H:%M:%S'))\n",
    "axs.fmt_xdata = mdates.DateFormatter('%H:%M:%S')\n",
    "axs.set_xlabel('Time (UTC)',fontsize=fs)        \n",
    "axs.set_ylabel('Frequency (MHz)',fontsize=fs)\n",
    "\n",
    "#TODO: I don't think it's clear which region this method is flaggin as RFI\n"
   ]
  }
 ],
 "metadata": {
  "interpreter": {
   "hash": "ad2bdc8ecc057115af97d19610ffacc2b4e99fae6737bb82f5d7fb13d2f2c186"
  },
  "kernelspec": {
   "display_name": "Python 3.8.8 ('base')",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}