{ "cells": [ { "cell_type": "markdown", "id": "68ff9f10-1223-4f09-a504-8bbf8ca2495c", "metadata": {}, "source": [ "# Flagging\n", "\n", "This notebook shows how to use flags in dysh, as well as reminding on the concept of flagging vs. masking.\n", "\n", "In dysh there are four sources of flags: a .flag file, user generated flags, flags generated from the SDFITS metadata (at present these only flag VEGAS channels known to be bad, i.e. [VEGAS spurs](https://dysh.readthedocs.io/en/latest/reference/glossary.html#term-VEGAS-spurs)), and the FLAGS column of the SDFITS binary table. The GBT does not produce data with a FLAGS column; however, dysh will write the FLAGS column if using ``GBTFITSLoad.write(flags=True)`` which is the default.\n", "\n", "* Reading flags from a .flag file is controlled by the ``skipflags`` argument of ``GBTFITSLoad``. By default this is set to False, as the default flags in a .flag file are VEGAS spurs, and those get flagged instead by looking at the SDFITS metadata. If you have generated flags in a .flag file, it must have the same name as the SDFITS file that it applies to but instead of ending in .fits it must end in .flag, and you must set ``skipflags=False`` when calling ``GBTFITSLoad``. Lines in a flag file with IDSTRING ``VEGAS_SPUR`` are ignored by default, even if ``skipflags==True``. \n", "\n", "* Flags generated from the metadata are applied during the calibration process, e.g., when calling ``GBTFITSLoad.getsigref``. For any of the calibration routines, the flagging of VEGAS spurs is controlled by the keyword ``flag_vegas``. By default it is set to True, meaning that VEGAS spurs will be flagged. Once data is calibrated and VEGAS spur flags generated, these can be reverted in two ways. The first is to ignore all flags during calibration using ``apply_flags=False``, the second is to clear all flags using ``GBTFITSLoad.clear_flags`` and repeat the calibration using ``flag_vegas=False``.\n", "\n", "* Flags in the FLAGS column are always read in if present and will be applied in a calibration method if ``apply_flags=True`` or if you call ``GBTFITSLoad.apply_flags``. These flags can be cleared with ``GBTFITSLoad.clear_flags``.\n", "\n", "\n", "This notebook will explain how to generate your own flags using dysh, and show some examples of the two points above.\n", "\n", "## Dysh commands\n", "\n", "The following dysh commands are introduced (leaving out all the function arguments):\n", "\n", " filename = dysh_data()\n", " sdf = GBTFITSLoad()\n", " sdf.flags.show()\n", " sdf.flags.clear()\n", " sdf.flag()\n", " sdf.clear_flags()\n", " sb = sdf.getps()\n", " sb.plot()\n", " sb.plot().write()\n", "\n", "## Loading Modules\n", "We start by loading the modules we will use for this example. \n", "\n" ] }, { "cell_type": "code", "execution_count": 2, "id": "307976bc-facc-4066-a51b-baa376f1c3aa", "metadata": {}, "outputs": [], "source": [ "# These modules are required for working with the data.\n", "from dysh.fits.gbtfitsload import GBTFITSLoad\n", "from dysh.util.selection import Selection\n", "from dysh.log import init_logging\n", "import numpy as np\n", "\n", "# These modules are used for file I/O\n", "from dysh.util.files import dysh_data\n", "from pathlib import Path\n", "import tarfile\n", "\n", "# We also do some matplotlib here\n", "import matplotlib.pyplot as plt" ] }, { "cell_type": "markdown", "id": "3af012ae-ded1-4fad-a7a2-c845d52d2ed7", "metadata": {}, "source": [ "## Setup\n", "dysh uses a logger to communicate. If you are working in the command\n", "line, then the logging is setup for you. If you are working in a\n", "jupyter lab instance, then you need to set it up. You can do so using\n", "the init_logging function imported above. As an argument, init_logging\n", "takes a number, the verbosity level. level 0 is for error messages\n", "only, 1 for warning, 2 for info and 3 for debug. Here we set it to\n", "level " ] }, { "cell_type": "code", "execution_count": 3, "id": "cfd7d832-4ca9-450e-a296-de2bdcd6f125", "metadata": {}, "outputs": [], "source": [ "init_logging(2)\n", "\n", "# also create a local \"output\" directory where temporary notebook files can be stored.\n", "output_dir = Path.cwd() / \"output\"\n", "output_dir.mkdir(exist_ok=True)" ] }, { "cell_type": "markdown", "id": "c636f392-8911-4680-b162-9c9c5898325c", "metadata": {}, "source": [ "## Data Retrieval\n", "\n", "This time we download the data from a tar.gz file and then unpack it locally in the current \"data\" directory." ] }, { "cell_type": "code", "execution_count": 3, "id": "b3f37b50-3d5b-411f-bab7-913ccef466be", "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "12:12:57.766 I url: http://www.gb.nrao.edu/dysh//example_data/rfi-L/data/AGBT17A_404_01.tar.gz\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "AGBT17A_404_01.tar.gz already downloaded\n" ] } ], "source": [ "filename = dysh_data(example=\"rfi-L/data/AGBT17A_404_01.tar.gz\")" ] }, { "cell_type": "code", "execution_count": 4, "id": "1274c6fa-c49f-4e9f-a6f1-b6bcbe7d6981", "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "/usr/lib64/python3.11/tarfile.py:2303: RuntimeWarning: The default behavior of tarfile extraction has been changed to disallow common exploits (including CVE-2007-4559). By default, absolute/parent paths are disallowed and some mode bits are cleared. See https://access.redhat.com/articles/7004769 for more details.\n", " warnings.warn(\n" ] } ], "source": [ "# Unpack.\n", "with tarfile.open(filename) as targz:\n", " targz.extractall('./data/') \n", " targz.close() " ] }, { "cell_type": "markdown", "id": "378da2ce-3f5c-44fe-a692-23cda7afe9cd", "metadata": {}, "source": [ "## Data Loading\n", "\n", "After unpacking the data we load it. Notice how `dysh` tells us that it found an empty .flag file." ] }, { "cell_type": "code", "execution_count": 5, "id": "feb1f1dd-0f13-4ad7-a015-13bae16f4252", "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "/export/home/fornax/psalas/trunk/dysh/src/dysh/util/selection.py:1377: UserWarning: Pandas doesn't allow columns to be created via a new attribute name - see https://pandas.pydata.org/pandas-docs/stable/indexing.html#attribute-access\n", " self._flag_file_rep = []\n", "12:12:57.906 W No flag rules found in file data/AGBT17A_404_01.raw.vegas/AGBT17A_404_01.raw.vegas.A.flag\n", "12:12:57.914 I Index loaded from .index file (44/93 columns). Missing columns (TCAL, WCS, calibration metadata, etc.) will be automatically loaded from FITS file when first accessed.\n" ] } ], "source": [ "sdfits = GBTFITSLoad(\"./data/AGBT17A_404_01.raw.vegas\", skipflags=False)" ] }, { "cell_type": "markdown", "id": "92293746-91ea-47f6-b276-c0ade5738184", "metadata": {}, "source": [ "What flags were loaded?" ] }, { "cell_type": "code", "execution_count": 6, "id": "e950c32c-d645-4653-838a-85b161324a73", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ " ID TAG OBJECT BANDWID DATE-OBS ... SUBOBSMODE FITSINDEX CHAN UTC # SELECTED\n", "--- --- ------ ------- -------- ... ---------- --------- ---- --- ----------\n" ] } ], "source": [ "sdfits.flags.show()" ] }, { "cell_type": "markdown", "id": "207dbfad-a4c0-4f48-befc-865590049922", "metadata": {}, "source": [ "The above shows that the .flag file was empty, so no flags were loaded.\n", "\n", "Now, lets look at the summary." ] }, { "cell_type": "code", "execution_count": 7, "id": "efd9571f-a01e-4756-9164-a91af211b930", "metadata": {}, "outputs": [ { "data": { "text/html": [ "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
SCANOBJECTVELOCITYPROCPROCSEQNRESTFREQ# IF# POL# INT# FEEDAZIMUTHELEVATION
19A1236066600.0OnOff11.4204061261164.580548.3795
20A1236066600.0OnOff21.4204061261164.601248.4338
" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "sdfits.summary()" ] }, { "cell_type": "markdown", "id": "89540fb2-1435-4029-aa29-b0b7320fd8b1", "metadata": {}, "source": [ "## Data Inspection\n", "\n", "There are two scans, a pair of position switched observations. We will calibrate it and see how the data looks like.\n", "\n", "We start by looking at the time average of the calibrated data." ] }, { "cell_type": "code", "execution_count": 8, "id": "aee7db22-4b42-45ee-b2c4-8e53e30f4f1a", "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "12:12:58.347 I Ignoring 1 blanked integration(s).\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "5f827c1c94424e3ca147b454e403264b", "version_major": 2, "version_minor": 0 }, "text/plain": [ "VBox(children=(HBox(children=(Button(description='Clear All Regions', style=ButtonStyle(), tooltip='Clear all …" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# Calibrate the data.\n", "ps_scanblock = sdfits.getps(scan=19, plnum=0, ifnum=0, fdnum=0)\n", "\n", "# Compute the time average.\n", "ps = ps_scanblock.timeaverage()\n", "\n", "# Plot.\n", "ps.plot(xaxis_unit=\"chan\");" ] }, { "cell_type": "markdown", "id": "c13b36c1-a2ec-4134-a808-bb5c248c2d86", "metadata": {}, "source": [ "There is radio frequency interference (RFI) for channels above ~2300. We will plot a waterfall to see if the RFI is confined in time.\n", "This is done using the `plot` method of a `ScanBlock`." ] }, { "cell_type": "code", "execution_count": 9, "id": "fffb3c6d-47cc-47a2-9a05-74ea4288cafb", "metadata": {}, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "b2ad4b2e056c4a46be3b99d6dac255ee", "version_major": 2, "version_minor": 0 }, "text/plain": [ "VBox(children=(HBox(children=(Button(description='Clear All Regions', style=ButtonStyle(), tooltip='Clear all …" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "psp = ps_scanblock.plot()" ] }, { "cell_type": "markdown", "id": "c2e699ab-74ff-4c92-86fa-18f311097e2b", "metadata": {}, "source": [ "The RFI is confined to integrations 42 to 52, and it affects channels >2300. We will flag this range. Since the RFI shows as negative, it is also likely that this is present in the off scan, `scan=20`. The central frequency of the RFI is 1.381 GHz, which is a notorious GPS signal that shows up intermittendly." ] }, { "cell_type": "code", "execution_count": 10, "id": "c8b9ab2f-739d-4ab2-be65-665745ddcbd5", "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "12:12:59.850 I Ignoring 1 blanked integration(s).\n", "12:13:00.184 I Ignoring 1 blanked integration(s).\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "44f12e3fd952490cbe76aa8034cd320c", "version_major": 2, "version_minor": 0 }, "text/plain": [ "VBox(children=(HBox(children=(Button(description='Clear All Regions', style=ButtonStyle(), tooltip='Clear all …" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "tp_scanblock = sdfits.gettp(scan=[19,20], plnum=0, ifnum=0, fdnum=0)\n", "tp_scanblock.plot();" ] }, { "cell_type": "markdown", "id": "50c2cea4-e6d4-40aa-9a97-789f33e491f3", "metadata": {}, "source": [ "So it turns out the RFI is only in the OFF, explaining the negative signal. Although it is possible to flag just those integrations, and get slightly better S/N, we leave this as an excerize for the reader.\n", "\n", "Although the current plot gives a good overview, another more interactive view can be done using a FITS file. You will need to emply common 3rd party tools such as \n", "[ds9](https://sites.google.com/cfa.harvard.edu/saoimageds9) ,\n", "[QFitsView](https://www.mpe.mpg.de/~ott/QFitsView/)\n", "or \n", "[carta](https://cartavis.org/) .\n", "Here is an example how to create a subsection of the figure above." ] }, { "cell_type": "code", "execution_count": 11, "id": "3ecde282-a708-4476-a423-57c78fda5d82", "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "12:13:00.820 I Wrote /export/home/fornax/psalas/trunk/dysh/notebooks/examples/output/A123606_waterfall.fits with size 60 x 250\n" ] } ], "source": [ "psp.write(output_dir / 'A123606_waterfall.fits', avechan=4, chan=[3000,4000], overwrite=True)" ] }, { "cell_type": "markdown", "id": "f3870773-6df5-464b-9bb4-73a0fdad8f40", "metadata": {}, "source": [ "## Data Flagging\n", "\n", "We use the `GBTFITSLoad.flag` method to generate flags." ] }, { "cell_type": "code", "execution_count": 12, "id": "e3e42916-bad2-484b-b0c8-9bfd0cfa4cf8", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ " ID TAG SCAN INTNUM CHAN # SELECTED\n", "--- --------- ---- ----------------------------- ------------- ----------\n", " 0 09f59a8b1 20 [42,43,44,45,...,49,50,51,52] [[2300,4096]] 44\n" ] } ], "source": [ "sdfits.flags.clear()\n", "sdfits.flag(scan=20, \n", " channel=[[2300,4096]], \n", " intnum=[i for i in range(42,53)])\n", "sdfits.flags.show()" ] }, { "cell_type": "markdown", "id": "a3f66985-eaa5-429c-a362-96f40ad4d30e", "metadata": {}, "source": [ "Careful readers might notice there is no channel 4096, since channels are numbered 0 to 4095 here. However, in this context of flagging it does no harm.\n", "\n", "We repeat the calibration after generating the flags." ] }, { "cell_type": "code", "execution_count": 13, "id": "0f84857c-3308-4245-9cb5-e8b8906601d1", "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "12:13:01.154 I Ignoring 1 blanked integration(s).\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "8996bbc07b4f4d8b969f79249b29e93c", "version_major": 2, "version_minor": 0 }, "text/plain": [ "VBox(children=(HBox(children=(Button(description='Clear All Regions', style=ButtonStyle(), tooltip='Clear all …" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "pssb = sdfits.getps(scan=19, plnum=0, fdnum=0, ifnum=0, apply_flags=True)\n", "\n", "pssb.plot();" ] }, { "cell_type": "markdown", "id": "6c4f59c3-7f06-4b50-b7b5-24f2557d92ad", "metadata": {}, "source": [ "The channels and times affected by RFI have been flagged. We can time average to generate the final spectrum without the RFI." ] }, { "cell_type": "code", "execution_count": 14, "id": "ad2637e7-f420-4c36-be2a-dbf6629b98d3", "metadata": {}, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "b102b4a0f02d4255af40c09af21e170e", "version_major": 2, "version_minor": 0 }, "text/plain": [ "VBox(children=(HBox(children=(Button(description='Clear All Regions', style=ButtonStyle(), tooltip='Clear all …" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "ps = pssb.timeaverage()\n", "ps.plot(xaxis_unit=\"chan\");" ] }, { "cell_type": "markdown", "id": "2debf76f-0a0d-4062-b23d-00c02d4ada5c", "metadata": {}, "source": [ "## Removing Flags\n", "\n", "To remove flags from the `GBTFITSLoad` object use the `clear_flags` method." ] }, { "cell_type": "code", "execution_count": 15, "id": "6a96b98e-8bd9-4959-a190-800ad10d6c4d", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ " ID TAG OBJECT BANDWID DATE-OBS ... SUBOBSMODE FITSINDEX CHAN UTC # SELECTED\n", "--- --- ------ ------- -------- ... ---------- --------- ---- --- ----------\n" ] } ], "source": [ "sdfits.clear_flags()\n", "sdfits.flags.show()" ] }, { "cell_type": "markdown", "id": "1ee9cbe0", "metadata": {}, "source": [ "## Statistics-based Flagging\n", "\n", "We can assume that any significant increase in the standard deviation of the raw spectra is due to heavy RFI. Below, we will calculate $\\mu + 3\\sigma$ for each of the 8 individual switching states, and flag any integrations breaching that threshold. Here $\\mu$ is the mean, and $\\sigma$ the standard deviation.\n", "\n", "The last integration has been blanked by VEGAS, and is not plotted below." ] }, { "cell_type": "code", "execution_count": 16, "id": "e4e07a10", "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "/export/home/fornax/psalas/trunk/dysh/.venv/lib64/python3.11/site-packages/traitlets/traitlets.py:1385: DeprecationWarning: Passing unrecognized arguments to super(Toolbar).__init__().\n", "NavigationToolbar2WebAgg.__init__() missing 1 required positional argument: 'canvas'\n", "This is deprecated in traitlets 4.2.This error will be raised in a future release of traitlets.\n", " warn(\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "22c2c452abbb46188be53a2057962ddb", "version_major": 2, "version_minor": 0 }, "image/png": "iVBORw0KGgoAAAANSUhEUgAAAoAAAAHgCAYAAAA10dzkAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjgsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvwVt1zgAAAAlwSFlzAAAPYQAAD2EBqD+naQAAnMFJREFUeJzs3XmcFPWd+P/Xp6r6ZC7GYQQEuQYFBA1gENQEDB5LiC7GEGI2JIpugl/9squBb9a4a9zVSDTGL/5cj40YyfoVEoLHgsbEE0iickgQAt44gDII6MAwzPRRVZ/fH1Vd083MMDMcM9D9fs6jHn1VVX+6p7v6Xe/PpbTWGiGEEEIIUTCMri6AEEIIIYToXBIACiGEEEIUGAkAhRBCCCEKjASAQgghhBAFRgJAIYQQQogCIwGgEEIIIUSBkQBQCCGEEKLASAAohBBCCFFgJAAUQgghhCgwEgAKIYQQQhQYCQCFEEIIIQqMBIBCCCGEEAVGAkAhhBBCiAIjAaAQQgghRIGRAFAIIYQQosBIACiEEEIIUWAkABRCCCGEKDASAAohhBBCFBgJAIUQQgghCowEgEIIIYQQBUYCQCGEEEKIAiMBoBBCCCFEgZEAUAghhBCiwEgAKIQQQghRYCQAFEIIIYQoMBIACiGEEEIUGAkAhRBCCCEKjASAQgghhBAFRgJAIYQQQogCIwGgEEIIIUSBkQBQCCGEEKLASAAohBBCCFFgJAAUQgghhCgwEgAKIYQQQhQYCQCFEEIIIQqMBIBCCCGEEAVGAkAhhBBCiAIjAaAQQgghRIGRAFAIIYQQosBIACiEEEIIUWAkABRCCCGEKDASAAohhBBCFBgJAI+SzZs3c8UVV9CnTx+UUixZsqRD22/atImLL76Y0tJSevTowbe+9S127tx5jEorhBBCiEImAeBRUl9fz8CBA5k3b95hbX/ZZZfRrVs3Vq9ezR//+Ec++OADrr322qNbSCGEEEIIJAA8asaMGcPPf/5zvvGNb7T4+FtvvcXEiROJx+P069ePW2+9Fdu2Adi9ezdbtmzhn//5nzn99NMZNWoUV199NW+++WZnvgQhhBBCFAgJADvBZ599xle+8hXOOecc3nrrLR5//HEWLlzIvffeC0BFRQVDhw5lyZIlpFIp6urqePbZZ5k8eXIXl1wIIYQQ+UgCwE7wn//5n5x22mnceeedDB48mC9/+cvMmTOHX/3qVwAopXjxxRd54403iMfjlJWVYVkWDz74YBeXXAghhBD5SALATrBhwwbWrl1LUVFRsPzzP/8zW7ZsAUBrzQ033EC/fv144403ePXVV/n000+ZOXNmF5dcCCGEEPnI6uoCFIqvfe1r/PznP2/xsRUrVvA///M/7Nu3j+LiYgDuu+8+zj33XO644w569+7dmUUVQgghRJ6TALATjBgxgt/+9rcMHDgQw2iedK2trQW8quAMy/L+NYlEonMKKYQQQoiCIVXAR0kqlWL9+vWsX78egOrqatavX8/OnTu54YYb2LVrF9dccw1vvfUWmzdvZv78+dxyyy0AjBs3juLiYmbOnMk777zDX//6V+bMmcOwYcMYMGBAF74qIYQQQuQjCQCPkh07djBy5EhGjhwJwJw5cxg5ciQPP/wwFRUVvPzyy+zYsYPzzjuPcePG8dhjjzFs2DAAevbsye9//3u2bdvGmDFjuPjiiykvL2fZsmU5WUEhhBBCiKNBaa11VxdCCCGEEEJ0HskACiGEEEIUGAkAhRBCCCEKjASAQgghhBAFRoaBOQKu67Jjxw6Ki4uls4YQQghxgtBas3//fnr37t3i8GyFQALAI7Bjxw769u3b1cUQQgghxGHYvn07ffr06epidAkJAI9AZtaO7du3U1JS0sWlEUIIIUR71NXV0bdv3+B3vBBJAHgEMtW+JSUlEgAKIYQQJ5hCbr5VmBXfQgghhBAFTAJAIYQQQogCIwGgEEIIIUSBkTaAx5jWGtu2cRynq4siDsE0TSzLKuj2IEIIIQqHBIDHUCqVoqamhoaGhq4uimiHeDxOr169CIfDXV0UIYQQ4piSAPAYcV2Xjz76CNM06d27N+FwWLJLxymtNalUit27d/PRRx8xePDggh0YVAghRGGQAPAYSaVSuK5L3759icfjXV0c0YZYLEYoFGLr1q2kUimi0WhXF0kIIYQ4ZiTNcYxJJunEIf8rIYQQhUJ+8YQQQgghCowEgEIIIYQQBUYCQJGjoaGBOXPm0K9fP2KxGFVVVdx0003N1pswYQI33HDDET2XUoolS5Yc0T4O5Xe/+x2DBw8mGo1y7rnnsmnTpmP2XEIIIcSJRAJAkWPWrFk899xzLFiwgE2bNnH//ffT2NjY1cXqsA0bNnDllVdyzTXX8Oabb9K3b18mT55MMpns6qIJIYQQXU4CQJHj6aefZvbs2VxwwQUMHDiQSZMm8dBDDwWPT5gwAaUUK1as4IEHHkAphVKKBQsWBOvce++9jBgxgng8TkVFBTNmzKCuri54PLMNwNSpU4Pb1dXVwTrV1dVMmTKF4uJievXqxfXXX9+h8RTnz5/PyJEj+Zd/+RfOOOMMfvnLX/LJJ5/w/PPPH/6bI4QQB6mrq+Pll1/m448/7uqiCNEhJ3QAuHnzZq644gr69OlzWNWJmzZt4uKLL6a0tJQePXrwrW99i507dx6j0nrjzTWk7E5ftNbtLmNxcTEvvfRSq5myp556ipqaGsaNG8fVV19NTU0NNTU1TJs2LVintraWO+64g40bN/Lss8+yatUqbrzxxuDxzDYAjzzySHC7b9++gDeEziWXXEJ5eTmrV69m2bJlrFmzhtmzZ7f7dbz55pucd955we3S0lLOPPNM1q5d2+59CCFEa7TWvPXWWzz44IP86U9/YvHixTLjkzihnNDjANbX1zNw4ECuvPJKpk6d2uHtL7vsMs4880xWr17NgQMH+P73v8+1117Ls88+ewxKC41ph2G3/vGY7PtQNv/HJcTD7ftX33///UyfPp3KykrGjx/P5MmTmT59ejCWYXl5OQDhcJh4PE7Pnj2b7eP2228Prg8aNIiZM2cyd+7c4L7sbcrKyprtY9GiRRw4cID58+cHQ7PcfvvtTJkyJcg6tmX37t1UVFTw1FNP8YMf/IB169ZRUVHB7t272/U+CCFEa+rr63n22Wd55513gvvq6urYvHkzI0aM6MKSCdF+J3QAOGbMGMaMGXNY2+7evZstW7bwq1/9itNPPx2Aq6++mjvuuONoFvGEc+mll7J9+3b+8Ic/sHz5cm699VbmzZvHmjVrKCoqatc+XnnlFX7605/y9ttvU1dXh23bHZpebcOGDdTU1FBSUhLc57ouiUSCmpoaevfu3e59lZSU0K9fPyKRSLu3EUKI1mzevJlnn32WhoYGDMNgwoQJ2LbNypUree211xg+fHiXzPq0detWNmzYwEUXXSQD2Yt2OaEDwCNRUVHB0KFDWbJkCePGjSORSPDss88yefLkY/acsZDJ5v+45Jjt/1DP2xHFxcVMnTqVqVOncttttzFo0CAWL17MjBkz2tx269atTJ48mWuvvZa7776b0tJSFi1axF133dWhMowePZqFCxc2u7+ysrJd2/fo0YM9e/Zw4YUXBtW+e/bs4Ytf/GKHyiGEEACNjY38/ve/Z+PGjQCcfPLJTJkyhV69enHgwAFee+01ampq2Lp1K/379+/Ush04cIDf/OY3NDY20rdvX77whS906vOLE1PBBoBKKV588UWmTJlCPB7HdV0mT57Mgw8+2Oo2yWQyp21cdseG9j5ne6tijxc9evSgvLyc/fv359wfDoexbbvZ+mvXriWVSjFv3jxM0ws8M+39DhYKhVrcx4gRI1iwYAE9e/Zsd9bxYKNHj+Yvf/lLcHvfvn1s2LCBf/u3fzus/QkhCtf777/P0qVL2b9/P0opzj//fMaPH49lecfzbt26cdZZZ/Hmm2/y2muvdXoA+Mc//jEYrUFGOhDtdUJ3AjkSWmtuuOEG+vXrxxtvvMGrr77Kp59+ysyZM1vdZu7cuZSWlgZLptNCPrnssst47LHH2LRpE++++y4/+tGP2LFjBxMnTsxZr6qqipUrV7Jt2zYSiUTQ+Hnw4MG4rsvDDz/Mli1bePTRR1m8eHGLz1VVVcWyZcuora0lkUgEnVWuvPJKysvLmTZtGmvWrOG9995j4cKFXHfdde1+Hddccw1//etf+dnPfsamTZv4/ve/zymnnMKkSZMO850RQhSiv/zlLzzxxBPs37+fk046iWuuuYaJEycGwV/GuHHjAHjvvffYs2dPp5Xvww8/ZMOGDcHtlk6qhWhJwQaAK1as4H/+53947LHHOPvssxk/fjz33Xcfjz32GDt27Ghxm5tvvpl9+/YFy/bt2zu51MfeuHHjmDdvHmPHjmXMmDGsXLmSZ555huHDh+esN2fOnKAaPRaL8fjjjwNw5plnct9993HnnXcyfPhwli5dyi233NLic82bN49169ZRWVlJLBZj69atAEQiEV544QWi0SgXXXQRo0aN4p577mHIkCHtfh1nnXUWixYtYv78+YwaNYrt27fz7LPPSltAIUS7JRIJVqxYAXhtzmfOnEmfPn1aXLeiooLTTjsNgNdff71TypdOp4NOi5kOc+l0ulOeW5z4Tqz6yMNQX1/Pnj17qKioyKlOrK2tBchprJs5o0skEi3uKxKJ5H0AcfPNN3PzzTe3ud6AAQNYuXJli4/NmjWLWbNm5dyXPQxMxsUXX8zbb7/d6v6ffPLJdpS4dZl2jEIIcTjeeustUqkUFRUVTJo0qc3OHeeeey7vvfceb731Fl/5ylfo1q3bMS3fihUrqK2tpbi4mKqqKv76179KBlC02wmdAUylUqxfv57169cD3uDB69evzxnLb8mSJQwYMKDZGIHjxo2juLiYmTNn8s477/DXv/6VOXPmMGzYMAYMGNCZL0MIIcRxxnVdVq1aBcA555zTrp69/fr1o1evXti2zZo1a45p+T799FNee+01AL761a8GwaZkAEV7ndAB4I4dOxg5ciQjR44EvGrJkSNH8vDDD7e5bc+ePfn973/Ptm3bGDNmDBdffDHl5eUsW7asS7rwCyGEOH58+OGHfP7550QiEc4888x2baOU4txzzwVgzZo1xywYc12XZcuW4bouQ4YMYejQoYRCIUDaAIr2O6GrgPv379/mLBdXXXUVV111VYuPnXfeea1WYwohhChcmezfqFGjOtT0Z9iwYbz44ovU1dWxYcMGRo8efdTLtnbtWj7++GPC4XDQsS3ThEkygKK9TugMoBBCCHG07dmzhw8++ACgw2OHmqbJ2LFjAa8ziOu6R7VsmbmHASZOnEhpaSmAZABFh0kAKIQQQmRZvXo1AKeddlow/WVHZLKG2YHk0fL888+TTCY55ZRTcoJTyQCKjpIAUAghhPAlEomgY+E555xzWPuIRqOMGjUKIOiocTS88847vP322xiGwaWXXhoM/QJNGUAJAEV7SQAohBBC+NavXx8M/TJw4MDD3k+m53B1dXWrsyF1RDKZ5Pe//z3gjWLRs2fPnMczGUCpAhbtJQGgEEIIgde7NlP9296hX1pTVlbGGWecARydLOArr7xCXV0d3bt3Z/z48c0elwyg6CgJAIUQQgjggw8+6PDQL4eSGRJm06ZN7Nu377D3s2PHjiAw/drXvkY4HG62jmQARUdJACiEEEJw+EO/tDYcWe/evenXr1/OoNId5bouv//979FaM3z4cAYNGtTiepIBFB0lAaDI0dDQwJw5c+jXrx+xWIyqqipuuummZutNmDCBG2644YieSynVbIaWoyWRSHD11VczbNgwDMM44rIKIfLbnj17+PDDD4GODf3SuOkzau5czb4Xqlt8PJMFfPPNN2loaOhwud56661gzL+LL7641fVkGBjRURIAihyzZs3iueeeY8GCBWzatIn777+fxsbGri5WhzmOQzgcZvbs2Zx11lldXRwhxHEuU8V6+umnt3volwPrPuWzJzbj7k+x/9XtpPc0P1YOHjyYyspKkskkS5cubXPygmyNjY28+OKLAIwfP56SkpJW15VhYERHSQAocjz99NPMnj2bCy64gIEDBzJp0iQeeuih4PEJEyaglGLFihU88MADKKVQSrFgwYJgnXvvvZcRI0YQj8epqKhgxowZ1NXVBY9ntgGYOnVqcLu6ujpYp7q6milTplBcXEyvXr24/vrrO3T23K1bN/7rv/6LGTNmBAOlCiFES7KHfhkzZky7tqn/yyfULn4PXFBREzTsf3lbs/UMw2DKlCkYhsE777zD2rVr212uV199lYaGBioqKtockiY7A9iRIFMULgkAO5PWkDrQ+UsHDgbFxcW89NJLJJPJFh9/6qmnqKmpYdy4cVx99dXU1NRQU1PDtGnTgnVqa2u544472LhxI88++yyrVq3ixhtvDB7PbAPwyCOPBLf79u0LQCqV4pJLLqG8vJzVq1ezbNky1qxZw+zZsw/nXRdCiEPqyNAvWmvqXt7G3mVbACg6rzc9rh0BQMP6XaR3NT9R7d27NxdeeCEAf/zjH9m1a1ebZdq5cydr1qwBYNKkSUGGrzWZx7XWOI7T5v6FOKHnAj7hpBvgzt6d/7w/3gHhbu1a9f7772f69OlUVlYyfvx4Jk+ezPTp04nH4wBB1Ug4HCYejzcbiwrg9ttvD64PGjSImTNnMnfu3OC+7G3Kysqa7WPRokUcOHCA+fPnBwOd3n777UyZMiXIOgohxNGQ3UGjraFftNbse+4j6v/8CQAlF55K8cRTUUoRHXYSic2fUffyNk66ckizbceOHcuHH37Ihx9+yJIlS/jHf/zHIGvX0vNkOn4MGzas1Y4f2bL3Zdt2mwGjEJIBFDkuvfRStm/fzvz58+nbty+33noro0ePpr6+vt37eOWVV5g4cSK9e/emqKiIOXPmdGj7DRs2UFNTQ0lJCUVFRRQVFXH55ZeTSCSOyoCqQgiR8cEHH1BbW0skEjlke2HtaGqXvB8Ef6VfG0jJhf2CgLHkwlMBaNywm/TOA822z1QFd+vWjV27dgVt+1qyYcMGtm3bRigUOmTHj2z2x03PKe0ARXvIKUJnCsW9bFxXPG8HFBcXM3XqVKZOncptt93GoEGDWLx4MTNmzGhz261btzJ58mSuvfZa7r77bkpLS1m0aBF33XVXh8owevRoFi5c2Oz+ysrKDu1HCCEOJXvol5bG1wPQtsvni96hcdNnoKD7FafR7eyTc9YJ9y4iNqKCxo17vCzgPwxttp/i4mKmTJnCE088werVq6mqquK0007LWSeRSATB4Ze+9CXKysrafA3O/hSf//dmLG1gK1d6Aot2kQCwMynV7qrY40WPHj0oLy9n//79OfeHw+EWDzJr164llUoxb948TNMEaDVrFwqFWtzHiBEjWLBgAT179qSoqOgovAohhGhu//79bQ794qYcPnt8M8n394KpOOnKIcSGV7S4bsnEU2n82x4aN+4htaOecO/mx6/BgwczduxY3njjDZ555hmuu+46iouLg8dXrFhBfX095eXlwRAyh6K1pvbpD3AbbMyIiY0rGUDRLlIFLHJcdtllPPbYY2zatIl3332XH/3oR+zYsYOJEyfmrFdVVcXKlSvZtm0biUQiaHQ8ePBgXNfl4YcfZsuWLTz66KMsXry4xeeqqqpi2bJl1NbWkkgkgp5rV155JeXl5UybNo01a9bw3nvvsXDhQq677roOvZbNmzezfv166uvr2bNnD+vXr+eDDz44jHdFCJGPMiMLxOPxVod+2fvU+yTf34sKG1RcdUarwR9AqGc3Ymf2AKDupeY9gjMuvPBCTj75ZBoaGnj66adxXReAXbt28cYbbwDt6/gB0LB+N4nNnwFg+T/pkgEU7SEBoMgxbtw45s2bx9ixYxkzZgwrV67kmWeeYfjw4TnrzZkzh4qKCoYOHUosFuPxxx8H4Mwzz+S+++7jzjvvZPjw4SxdupRbbrmlxeeaN28e69ato7KyklgsxtatWwGIRCK88MILRKNRLrroIkaNGsU999zDkCHNG1Yfyle/+lVGjhzJm2++yW9/+1tGjhzJtddeexjvihAiH2UCpdYCLWdfkoYNuwGouOoMooO7t7nPkomngoLE5s9Ifby/xXUsy+Ib3/gGlmWxZcsWXn/99ZyOH6effjqDBw9u87mcuiR7/8fLYKqIiam9n3TJAIr2UFoGDDpsdXV1lJaWsm/fvmYDdCYSCT766CMGDBhANBrtohKKjpD/mRCFpbq6mgULFnDSSSfxv//3/272+L4Xt7L/5W2E+5dQObP9A8p//tt3afjrLqJDyqm46oxW11u7di3PPvsshmFw7rnn8uc//xnLsrj++uvp3v3QwabWms9+vZnEO58TOqWISL8S/nvt03xu1POd73yHqqqqdpe3EB3q97tQSAZQCCFEQTpUBlA7LgfW7ASgaGyvDu23eOKpYEDinc9JbW85CwheZ7ehQ4fiui5//vOfATj//PPbDP4AGt7cReKdz8FUlH/zNC8DKFXAogMkABRCCFGQDhUAJt7+HLcuhdEtdMh2fy0JVcSIj/R6Ce97cWur6ymluPTSS4MMVFlZGeedd17b5d6XZO8yr+q35KJ+hE7uhgobWFIFLDpAAkAhhBAF6VABYP0b3ugF3b54Msrq+E9lyVf6ggHJ92pJbq1rdb14PM43v/lNBg4cyNe//vVWB4fO0FpT++T76KRDuG8xxV/qA4CyTEzMnNclxKFIACiEEKIgZQKlg4Ou9O4Gkh/sBQXdxnSs+jfDOilGt9HeLEd1h8gCAvTp04fvfve7nHrqqW3ut2HNpyTfqwVL0X3qaSjTG4hahY2gF7BkAEV7SAAohBCiIGUCpYMzgAdWeW3/oqeXY5Uffoew4gv6gqlIfrCX5JZ9h19Qn12bYO9z3hzEpRf3J1TZNMi/sgwsyQCKDpAAUAghREFqqQpYpx0OvPkpAN062PnjYFZ5NJgxpO6lQ2cB26JdTe2S97yq334lFJ1/Ss7jKmzIMDCiQyQAFEIIUZBaCgAb3tqDbrQxyyJET2u7N25bii841csCbtlH4v3aw97PgdU1JD/chwoZdP/GYJShch5XIVMGghYdIgGgEEKIgtRSAFj/hjdfe7exvZoFWYfDKosEw8js+0M12u340Lv2viT7fv8RACWX9CfUo/n87ipkBJ1AJAMo2kMCQCGEEAXp4E4gqY/3k/64HkwVVN0eDcUX9EWFTdKf1NP4tz0d3n7f8x+hUy7hU4spOrd3i+uoUNMwMJIBFO0hAaAQQoiCdHAnkMzQL7HhFZhF4aP2PGZRmOIve2326l7Yinbcdm+brN5H4/rdoKDsskGtZiVVyJQMoOgQCQBFjoaGBubMmUO/fv2IxWJUVVVx0003NVtvwoQJ3HDDDUf0XEoplixZckT7aM3TTz/Nl7/8Zbp370737t35u7/7OzZs2HBMnksIcWLKrgJ2G20a3/Lm/e3ozB/tUfSlUzC6hbD3NHJg7aft2ka7mr3LvF6/8dEnE+5T3Oq6RsiQNoCiQyQAFDlmzZrFc889x4IFC9i0aRP3338/jY2NXV2sDvvzn//M3//93/Pyyy/z+uuv0717dy666CI+++yzri6aEOI4kR0AHlj3KTrtYp0cJ9z/6M8Na0Qsir/SF4C6l7bhppw2t2l481PSn9SjIialf9f/kOt6bQClF7BoPwkARY6nn36a2bNnc8EFFzBw4EAmTZrEQw89FDw+YcIElFKsWLGCBx54AKUUSikWLFgQrHPvvfcyYsQI4vE4FRUVzJgxg7q6ppHwM9sATJ06NbhdXV0drFNdXc2UKVMoLi6mV69eXH/99TQ0NLT7dfziF7/ghz/8IaNGjWLIkCE8+OCD7Nq1K5hvUwghcgJAv/q3aGyv4Ph0tBWd0wuzewR3f4r613Yccl03YbPvj9UAlFx4aptV0l4bQH8cQAkARTtIANiJtNY0pBs6fdG6/b3OiouLeemll0gmky0+/tRTT1FTU8O4ceO4+uqrqampoaamhmnTpgXr1NbWcscdd7Bx40aeffZZVq1axY033hg8ntkG4JFHHglu9+3rnR2nUikuueQSysvLWb16NcuWLWPNmjXMnj37cN52APbu3QvQrknWhRCFIagqrU1j725EhQ3iIyuP2fMpy6Dkon4A7F/+MW5D64Fa3UvbcOvTWD1iFI1rueNHzr5DZpABTKUkABRtaz4BojhmGu1Gzll4Tqc/76pvryIeaj5sQEvuv/9+pk+fTmVlJePHj2fy5MlMnz6deNzbvry8HIBwOEw8Hqdnz57N9nH77bcH1wcNGsTMmTOZO3ducF/2NmVlZc32sWjRIg4cOMD8+fMxDCPY55QpU4KsY0f9+Mc/ZsyYMZx//vkd3lYIkZ8yVaXOR/uBIuIjKzGix/ZnMf6FSvav+Bj70wb2r/iY0kkDmpdrV0OQISz72sD2zUVsKSzltwGUDKBoB8kAihyXXnop27dvZ/78+fTt25dbb72V0aNHU19f3+59vPLKK0ycOJHevXtTVFTEnDlzOrT9hg0bqKmpoaSkhKKiIoqKirj88stJJBJB5rAj7r77bpYvX87ixYuDgFIIITIZQOdjr51zt3OOfuePgylDUXpJfwD2/2UHzr7mtS37ntsCriY6pJzo6eXt269SWIYXvKbT0glEtE0ygJ0oZsVY9e1VXfK8HVFcXMzUqVOZOnUqt912G4MGDWLx4sXMmDGjzW23bt3K5MmTufbaa7n77rspLS1l0aJF3HXXXR0qw+jRo1m4cGGz+ysrO1Y98+CDDwYBYL9+/Tq0rRAivwVtALUi3K+EcO+iTnne6NBywv1KSG2to+7lbXT/+uDgscZ3Pifxbi2YitKvDezQfkMhC1ywbckAirZJANiJlFLtroo9XvTo0YPy8nL279+fc384HG5xqIG1a9eSSqWYN28epuk1SG4taxcKhVrcx4gRI1iwYAE9e/akqOjwD8i/+tWv+Nd//VdefPFFhg8fftj7EULkp8zxx8Q44nl/O0IpRemk/ux+eAMH1u6k6EunEOoRR9su+571hn0pOu8UQhUdO3m3zBC4kgEU7SP1YSLHZZddxmOPPcamTZt49913+dGPfsSOHTuYOHFiznpVVVWsXLmSbdu2kUgkcBxvSIPBgwfjui4PP/wwW7Zs4dFHH2Xx4sUtPldVVRXLli2jtraWRCIRdFa58sorKS8vZ9q0aaxZs4b33nuPhQsXct1117X7dTzxxBPccMMNPPbYY5xyyins3LmTnTt3npBD2gghjo10MgWAZVrEh1d06nNH+pcSHVIOrjc4NED9azuw9zRiFIUo8YeM6YhQ2JvRxHYkABRtkwBQ5Bg3bhzz5s1j7NixjBkzhpUrV/LMM880y6DNmTOHiooKhg4dSiwW4/HHHwfgzDPP5L777uPOO+9k+PDhLF26lFtuuaXF55o3bx7r1q2jsrKSWCzG1q3eQTASifDCCy8QjUa56KKLGDVqFPfccw9Dhgxp9+t45JFHaGxsZMqUKfTq1StYfvvb3x7mOyOEyDdBFXAkhAp1/s9hySX9QUHjxj00vvM5dS9vA6D07wYcVmeUzIwmMhC0aA+lOzJGiMhRV1dHaWkp+/bto6Qkd+DQRCLBRx99xIABA4hGo11UQtER8j8TorD87M65JFJJvhn5MsNu/kqXlOHz375Lw193gaHA1YT6FFH5v77Q6pRvh7LtgTX8avdzAPzbv/1b0AxHNHeo3+9CIRlAIYQQBSlTVZrJnHWFkov6gekFf3Do+X7bkqkCBskCirZJACiEEKLgaK2x/bbLoS4MAK3yaDD3cHxUJZFTDz8bZYWaXodMByfaIr2AhRBCFJzsDJllhQ6x5rFX+tUBRKrKiA4+spmKjLCJqQ0c5UoGULRJAkAhhBAFJycADHVtAKhMg9jQk458PyETCwMHVzKAok1SBSyEEKLgBAGgBjOUH50lVMjAxHstkgEUbZEAUAghRMHJHgTayKMA0NLez7pkAEVbJAAUQghRcIIxADFQ1uH1uj3eeBlACQBF+0gAKIQQouBkAiQTE2Xlx0+h1wZQqoBF++THp14IIYTogCADqI08CgAlAyjaLz8+9UIIIUQHZLcBzKcAMNMGUDKAoi358akXR01DQwNz5syhX79+xGIxqqqquOmmm5qtN2HCBG644YYjei6lFEuWLDmifbTmqaee4uyzz6a0tJTS0lK+8pWvsHr16mPyXEKIE092AEgXzAN8LGT3ApYMoGhLfnzqxVEza9YsnnvuORYsWMCmTZu4//77aWxs7OpidVhpaSm33HILq1at4s033+SMM87gkksuYc+ePV1dNCHEcaCpDWA+ZQC9cQBBMoCibfnxqRdHzdNPP83s2bO54IILGDhwIJMmTeKhhx4KHp8wYQJKKVasWMEDDzyAUgqlFAsWLAjWuffeexkxYgTxeJyKigpmzJhBXV1d8HhmG4CpU6cGt6urq4N1qqurmTJlCsXFxfTq1Yvrr7+ehoaGdr+OiRMncvnllzNkyBCqqqq488472bt3L+vWrTv8N0cIkTeCDKDOp04gBqaWDKBon/z41J8gtNa4DQ2dvmit213G4uJiXnrpJZLJZIuPP/XUU9TU1DBu3DiuvvpqampqqKmpYdq0acE6tbW13HHHHWzcuJFnn32WVatWceONNwaPZ7YBeOSRR4Lbffv2BSCVSnHJJZdQXl7O6tWrWbZsGWvWrGH27NmH87aTSqV48MEHicViDBs27LD2IYTIL7nDwOTHT6EKGZIBFO0mU8F1It3YyLujRnf6856+7k1UPN6ude+//36mT59OZWUl48ePZ/LkyUyfPp24v315eTkA4XCYeDxOz549m+3j9ttvD64PGjSImTNnMnfu3OC+7G3Kysqa7WPRokUcOHCA+fPnYxhGsM8pU6YEWcf22LdvH6eccgqNjY1UVlbyyiuv0KdPn3ZtK4TIb7mdQGQcQFF48uO0Rxw1l156Kdu3b2f+/Pn07duXW2+9ldGjR1NfX9/ufbzyyitMnDiR3r17U1RUxJw5czq0/YYNG6ipqaGkpISioiKKioq4/PLLSSQSQeawPYqLi1m/fj1vvPEGkydPZsaMGXz++eft3l4Ikb/yMQNohGUcQNF+kgHsRCoW4/R1b3bJ83ZEcXExU6dOZerUqdx2220MGjSIxYsXM2PGjDa33bp1K5MnT+baa6/l7rvvprS0lEWLFnHXXXd1qAyjR49m4cKFze6vrKxs9z4Mw6CqqgqAs88+m8GDB/Poo48yZ86cDpVFCJF/gk4g2kDlUS9gmQpOtJcEgJ1IKdXuqtjjRY8ePSgvL2f//v0594fD4RbPMNeuXUsqlWLevHmYpncm2lrWLhQKtbiPESNGsGDBAnr27ElRUdFReBXee28YBgcOHDgq+xNCnNiaqoC7vhOI1prPd3xM2ck9Ma3QYe8nuwpYMoCiLRIAihyXXXYZl19+OWPGjMGyLH71q1+xY8cOJk6cmLNeVVUVy5cvZ9u2bVRWVhIKhTBNk8GDB+O6Lg8//DCTJk3i1VdfZfHixS0+V1VVFcuWLeOSSy4hFosRiURQSnHllVfy05/+lGnTpnHbbbdRWlrK2rVr+dOf/pTTI/lQMlXXw4YNI51O88gjj1BdXc2ll156xO+REOLElzMOYBcGgI31+/nDA/eyZd0aIt26UXX2WAafcy79RozECoc7tK/sqeDSKckAikPLj7y3OGrGjRvHvHnzGDt2LGPGjGHlypU888wzDB8+PGe9OXPmUFFRwdChQ4nFYjz++OMAnHnmmdx3333ceeedDB8+nKVLl3LLLbe0+Fzz5s1j3bp1VFZWEovF2Lp1KwCRSIQXXniBaDTKRRddxKhRo7jnnnsYMmRIu1+H67r8n//zfzjrrLM499xzWbNmDcuWLWP06M7vhCOEOP4cD1PB7fzwff7fv/wTW9atASB54ACbVrzMM3ffzkPf/wee+/9+zvurXiOdTLRrf94wMFIFLNpH6Y6MESJy1NXVUVpayr59+ygpKcl5LJFI8NFHHzFgwACi0WgXlVB0hPzPhCgczzzzDOvXr+eL6UFc+I+XEelf2mnPrbXmrRefZ/mvf4lj25Sd3Iuv/fOPSCcSvLf6L7y/6jXqP/8sWN+KRBj4hbM5+7Kv06vq9EPu98//+iQvh/5G31P6cM0/XtsZL+eEdKjf70IhVcBCCCEKTlfNBJJKNPLiL/+Td/6yAoCqL47lkuv+mWg3r71zn2HDueC7/0jNB+/y3qrXeH/Va9Tt/pT3Vv2Fj95axw8eWkAk3q3FfSulsEzvZ91OSxtAcWgSAAohhCg4TcPAmJ3WC/izj7ex9N65fP7JdpRh8OV/uJrRk6c0G9tUGQa9TxtK79OGMv47M9j10Yc8e99d7N1Zw7uv/4kzJ/5dq89hWSFwpQpYtE3aAAohhCg4TVPBdU4G8O0/vcr/+/GNfP7Jdoq6l/PNn8zl7K9d3ubA9kopTh5YFQR9m5a/fMj1LcvPAEovYNEGCQCFEEIUnNyZQI7tT+HKJx7j9//5C+xkklNHfIHpd/1/9BlyRof2MfRLF6AMgx3vvc3nOz5udb2QHwCmbckAikM7oQPAzZs3c8UVV9CnTx+UUixZsqRD22ut+dnPfsbAgQOJRCIMGjSIp59++hiVVgghxPEi00buWA8Ds/OD91iz9EkAxl5xJVf8+N+Jl5Z1eD9F3csZ8AVvFINNK1rPAlohbxxByQCKtpzQAWB9fT0DBw5k3rx5h7X9T37yE+655x7uuOMO3n77bRYuXEi/fv2ObiGFEEIcdzJt5KxjOBC01po/LVoAwLAvf4XzvvkPGIZ52Ps7Y7w3Huvmla/guk6L64QyAaAjAaA4tBO6E8iYMWMYM2bMYW174MABfvGLX/DII4/w7W9/G4CBAwcezeIJIYQ4TnVGG8CtG/7Ktr9twLQszvvmd454fwNHn0O0qJj6zz9j24b19P9C83FNMwGg47q4rothnNB5HnEMFewnY82aNTQ0NOC6LsOGDaNv375897vf5bPPPmt1m2QySV1dXc4ihBDixGNnhoExDJR56I4Yh0O7LisXLgDgC5dMpqRH++cxb40VCjHkvPEA/K2VauBQuGkqOakGFodSsAFgTU0NhmEwd+5c/u///b8sWrSIt956i+9973utbjN37lxKS0uDpW/fvp1YYiGEEEdLMAyMeWwqwt55/U/srt5COBZnzJRvHrX9Dp9wIQAfrHmdRH19s8ezA0AZCkYcSsEGgK6fHv+Xf/kXLrnkEs4//3x+9rOf8dxzz7F3794Wt7n55pvZt29fsGzfvr1zCy2EEOKoSPsBYOgYBICOneYvv/Wmx/zipV8nXnL0ZhmpHDCIilP746TTvPv6ymaPG2ELQ3sZTckAikMp2ACwoqICgNNOOy24L9MG8JNPPmlxm0gkQklJSc6SbxoaGpgzZw79+vUjFotRVVXFTTfd1Gy9CRMmcMMNNxzRcx1Oz+3D8fTTT6OUOuLyCiHyR6aTRGbcvKNpw0t/YN+nO4mXljF68pSjum+lVNAZ5G/LX2r+eMjAwutoIhlAcSh5HwDW19dTXV1N/UGp8jPPPBOALVu2BPdt27YNgD59+nReAY8zs2bN4rnnnmPBggVs2rSJ+++/n8bGxq4u1mHbuXMnN998M8OGDevqogghjhOO46C1BsA8ygFgKtHIG0/9FoBx3/g2oWMwr/iwL12AYZrs/OA9Pvt4W85jKmx4Q9sgGUBxaCd0AJhKpVi/fj3r168HoLq6mvXr17Nz585gnSVLljBgwIBmmaZevXrx1a9+lZ/85Ce89tprvPXWW/zrv/4rl156KaWlnTcp+PHm6aefZvbs2VxwwQUMHDiQSZMm8dBDDwWPT5gwAaUUK1as4IEHHkAphVKKBQsWBOvce++9jBgxgng8TkVFBTNmzMjpMJPZBmDq1KnB7erq6mCd6upqpkyZQnFxMb169eL666+noaGhw69nxowZ/Nu//Rs9evTo+JshhMhL2YFRyAodYs2Oe/PZZ2jYt5eynr0Y8ZWLj+q+M+KlZQwYeTbQPAuoLANLez/tkgEUh3JCB4A7duxg5MiRjBw5EoA5c+YwcuRIHn744XZt/+tf/5qRI0fyd3/3d1x44YVUVVXxq1/96piVV2tNOul0+pI5022P4uJiXnrpJZLJZIuPP/XUU9TU1DBu3DiuvvpqampqqKmpYdq0acE6tbW13HHHHWzcuJFnn32WVatWceONNwaPZ7YBeOSRR4LbmU41qVSKSy65hPLyclavXs2yZctYs2YNs2fP7tD7/eCDD2IYBv/wD//Qoe2EEPktOwC0QkcvA9iwby9rlj0FwPnf+u5Rzy5mO8PvDPL2n17FdZrGBFRhE1OqgEU7nNDjAPbv37/N4Oaqq67iqquuavGxiooKfvvb3x6DkrXMTrn88p9WdNrzZXz/vvGEIu0bfPT+++9n+vTpVFZWMn78eCZPnsz06dOJx+MAlJeXAxAOh4nH4/Ts2bPZPm6//fbg+qBBg5g5cyZz584N7svepqysrNk+Fi1axIEDB5g/f34whtXtt9/OlClTgqxjW959913uuOMO1qxZ067XLYQoHJnAyNAKI3T4AzMf7I2nf0s60cjJA6s47Zzzjtp+WzJw5NnEiks4sLeW6g3rGDjyi4CfAZQqYNEOJ3QGUBx9l156Kdu3b2f+/Pn07duXW2+9ldGjRzdrQ3kor7zyChMnTqR3794UFRUxZ86cDm2/YcMGampqKCkpoaioiKKiIi6//HISiUSQOTwU13X5zne+w3/8x39wyimntPt5hRCFIRgCBhNlHZ0xAPft2slbLzwPwJeuvAp1jAdgNq0QQ790AQCbXm2qBs5uAygZQHEoJ3QG8ERjhQ2+f9/4LnnejiguLmbq1KlMnTqV2267jUGDBrF48WJmzJjR5rZbt25l8uTJXHvttdx9992UlpayaNEi7rrrrg6VYfTo0SxcuLDZ/ZWVbQ+mWldXx9q1a9m4cWPQ8zeVSvHnP/+ZZ555ho8/bn0idSFE/gtmAeHozQLyl8VP4Do2/c4cSb8zv3BU9tmWM8ZPZN3v/4cP31xF4/46YsUlqJCJpb2spmQAxaFIANiJlFLtroo9XvTo0YPy8nL279+fc384HG7x4LJ27VpSqRTz5s3DNL3X2lrWLhQKtbiPESNGsGDBAnr27ElRUVGHy1xSUsLbb7+dc993v/tdTjvtNG677bYO708IkV+O9jRwu6q38PaflwPwpStbn0zgULTW7Wrekq2y/0Aq+w9iV/WHvPOXFYz8u0sxQpIBFO0jAaDIcdlll3H55ZczZswYLMviV7/6FTt27GDixIk561VVVbF8+XK2bdtGZWUloVAI0zQZPHgwruvy8MMPM2nSJF599VUWL17c4nNVVVWxbNkyLrnkEmKxGJFIBKUUV155JT/96U+ZNm0at912G6Wlpaxdu5Y//elPOT2SW2MYBkOGDMm5Lx6PU1ZWRlVV1eG/OUKIvJCdAeQoBIB/XvRr0JrTx32Jkwd27BijtWbdH7ey7g9bsSImpT1i/hL3LitjlFTEiHZrubfyGRMmsmvBh2xa8TIj/+5SCEkbQNE+0gZQ5Bg3bhzz5s1j7NixjBkzhpUrV/LMM88wfPjwnPXmzJlDRUUFQ4cOJRaL8fjj3qj3Z555Jvfddx933nknw4cPZ+nSpdxyyy0tPte8efNYt24dlZWVxGIxtm7dCngDbr/wwgtEo1EuuugiRo0axT333NMsqBNCiMORyYx5bQCP7Gfw47f/xkfr38QwTc771vQObevYLq88/g5vPLOFVMKhYV+Kmg/28c7rO1m1dAsvPLqJ381dy6M//BPzf7iSlb95r9k+hpw3HsO0+HTLB+zeVu1lALX0AhZtkwygyHHzzTdz8803t7negAEDWLmy+TRE4A0mPWvWrJz7soeBybj44oubVdVm7//JJ59sR4nbZ/ny5UdtX0KIE1tOG8DQkQWAry9ZBMCIr1xM9569271d4kCaP/xyI5+8uxel4PxvDubkAaXU7W5k3+4G9u1qZN+eRvbtaqShLkXygM3G5R9z5gV9KDs5HuwnXlLKoNFjeH/1a2xa/hLnXjBNMoCiXSQAFEIIUVCOVhvAT97ZzLa/vYVhWoyZMrXd2+3b3chzD7xF7c4GQhGTS/5xOP2GnwTAyf2bTzGaStg8//BGPn6nlvfXfsoXJw/IefyMCRN5f/VrvP3n5Yyd+E2ZCk60i1QBCyGEKChNw8AcWQD4xlO/AbwArKSi7REKAHZu2ceTd6+ldmcDRd0jfH3OqCD4a004anH6WG+81PfXfNps/Nv+Z40mXlpGw7691Gx5R6aCE+0iAaAQQoiCksmMecPAHN44gDUfvEv1W+tQhsGYv29f9u/9tZ/yzL1/pXF/moq+RXzjR2dT0ae4XdsOPKsHZsigdmcDez7OHVfVtCxOGeLNd15XuzsYBkYygOJQJAAUQghRUJraAJqH3Qv4jSe97N+wL32FspObz4iUTWvN2uereWH+Jhzbpf+ZFVz+w1F0K4u0+/nCMYv+I7xM4furP232eCTeDYBksqEpA5iSAFC0TgJAIYQQBeVI2wB+uuUDtqxbg1IG51zedvbvz797n1X/swWAs77Sl0kzRxCOdrwJ/uAvngx4mUTt5lYDR/zpOhOJ+qATiGQAxaFIACiEEKKg5LQBPIxewJm2f0POH0/3XoeebvLzmgNseMWbfejL3zqN8785GMM4vGrnfsNPIhw1qa9NUvPhvpzHwjE/A9h4AFP5VcCSARSHIAGgEEKIgnIkU8Htqt7CB2veAKU45/Jvtrn+Wy9vB2DAWRWMmNCn44XNYoVMBo7sAXidQbJlMoCpRCOW4WUXJQAUhyIBoBBCiIKS2wmkYz+Dq576LQCnjz2fk07pe8h1G+pSvPvGTgC+cNGph1HS5jLVwB+s24XjuMH9YT8ATDYcIGT5AaBUAYtDkABQCCFEQQmqgHXHZgLZs30r761+DYCxX5/W5vobl3+MY7ucPKCEXoNKD6+wB+lzendixSES9Wk+frs2uD/oBNLQgGV6AaAMAyMORQJAIYQQBSW3Crj97fFWPb0YtGbwOedScWr/Q66bTjlsXOG1/fvChaei1OG1+zuYYRpUjfY7g2RVA0f8NoCphgNYIT8DaEsGULROAkCRo6GhgTlz5tCvXz9isRhVVVXcdNNNzdabMGECN9xwwxE9l1KKJUuWHNE+WrNgwQKUUjnLhAkTjslzCSFOLNkBYHuHgfnsk+2885o3/eXYr3+rzfXfea2G5AGbkopo0G7vaMlUA29Zvxs75QBNbQCTDQ2EQiFAMoDi0GQqOJFj1qxZvPbaayxYsIB+/frx7rvvsnTp0q4u1mGJx+N8+OGHwe1wONyFpRFCHC8Opxfwaj/7N+jsc6jsP/CQ67quZr3f+eOsiacedq/f1vQcWEJxeZT9nyeo3vgZVaMrCQdVwE0ZQAkAxaFIBlDkePrpp5k9ezYXXHABAwcOZNKkSTz00EPB4xMmTEApxYoVK3jggQeC7NqCBQuCde69915GjBhBPB6noqKCGTNmUFdXFzye2QZg6tSpwe3q6upgnerqaqZMmUJxcTG9evXi+uuvp6GhoUOvRSlFz549g6W8vPzw3hQhRF4JOoG0cxzA2p07ePsvK4D2Zf8+ems3dbsbicQthp7b68gK2wKlVNOYgH41cHYv4JDlZwAdCQBF6yQA7ERaa9KJRKcvB88beSjFxcW89NJLJJPJFh9/6qmnqKmpYdy4cVx99dXU1NRQU1PDtGlNDaJra2u544472LhxI88++yyrVq3ixhtvDB7PbAPwyCOPBLf79vV61KVSKS655BLKy8tZvXo1y5YtY82aNcyePbtD73djYyP9+/fn1FNP5dvf/jaffPJJh7YXQuSn7JlAbCfF/s/2oF231fVXP/M7tOsyYOTZ9Bw0uM39r39xGwDDx59CKGIenUIfJBMAbv3bZyQb0kEvYLTG9INa23U6dPwXhUWqgDuRnUzy/33vG53+vLN+vYRQNNqude+//36mT59OZWUl48ePZ/LkyUyfPp24f3DJZNHC4TDxeJyePZtPgXT77bcH1wcNGsTMmTOZO3ducF/2NmVlZc32sWjRIg4cOMD8+fMxDCPY55QpU4KsY1uGDBnCE088wbBhw/jkk0+45ZZbuOiii1i/fr1UBQtR4LLbAP7m339E7f4arFCY0pN7UtazF2Un96Ts5N6UndwTKxpl88pXgPZl/2o+3MfOLXUYljricf8O5aRTutG9Vzdqaw6wZf1uhozrhWFauI6dU+Vs23bQJlCIbBIAihyXXnop27dv5w9/+APLly/n1ltvZd68eaxZs4aioqJ27eOVV17hpz/9KW+//TZ1dXXYtt2hoGvDhg3U1NRQUlIS3Oe6LolEgpqaGnr37t3mPsaOHcvYsWMBOPPMMxk+fDj9+vXjpZde4qtf/Wq7yyKEyD9Nw8AYNDZ4zVPsdIrPPt7GZx9va3GbfmeOpPdpQ9rcdyb7d/o5PelW2v65fjtKKcVpXzyZVUu38P6aTxl6bm8i8TiN++sws06S0+m0BICiRRIAdiIrEmHWr49Nr9e2nrcjiouLmTp1KlOnTuW2225j0KBBLF68mBkzZrS57datW5k8eTLXXnstd999N6WlpSxatIi77rqrQ2UYPXo0CxcubHZ/ZWVlh/aT0bdvXyoqKti6dethbS+EyB/ZGUBH25Se3JNv3HIHe3fuYO+nO/3LGvburGHfp95AzudPm97mfvd+2sCWt3YD8IWJR2fg50MZ/MVKVi3dwsfv1NJQlyIS70bj/jq0clFaoZWWjiCiVRIAdiKlVLurYo8XPXr0oLy8nP379+fcHw6HWzywrF27llQqxbx58zBNr+1Lpr3fwUKhUIv7GDFiBAsWLKBnz57tzjq2Zffu3Xz22Wf079//qOxPCHHiyp4JxNUO0W5FfrVv8yYt2nVxXRfTavvn8q1XtoOGfiNOorx3t6Ne7oOV9ohT2b+EXdV1fPDmp0E7QAcbC4M0jswGIlolnUBEjssuu4zHHnuMTZs28e677/KjH/2IHTt2MHHixJz1qqqqWLlyJdu2bSORSOA43lhUgwcPxnVdHn74YbZs2cKjjz7K4sWLW3yuqqoqli1bRm1tLYmszipXXnkl5eXlTJs2jTVr1vDee++xcOFCrrvuuna/jltvvZXnn3+eLVu28MYbb/DNb36TIUOGNHsdQojC0zQMjImjbcKxeKvrKsNoV/DXWJ/inde8k92RFx777F/GaVm9gTOzgdiu7Y1xiAwFI1onAaDIMW7cOObNm8fYsWMZM2YMK1eu5JlnnmH48OE5682ZM4eKigqGDh1KLBbj8ccfB7z2dvfddx933nknw4cPZ+nSpdxyyy0tPte8efNYt24dlZWVxGKxoHo2EonwwgsvEI1Gueiiixg1ahT33HMPQ4a03f4mY9++fVxzzTUMGTKEyy+/nF69evHHP/5ROoAIIYKgyMBrKxeOxY54n39b8Ql22qXHqcX0Pq3siPfXXlVnV6IUfscTr7mP7aSw8GpgJAMoWiNVwCLHzTffzM0339zmegMGDGDlypUtPjZr1ixmzZqVc1/2MDAZF198MW+//Xar+3/yySfbUeKW3Xfffdx3332Hvb0QIj+5rhvUWGR6yx4qA9gedtph43J/2reL+h61ad/ao1tphN6ndeeTd2tJHPCzfk4SUxugJAAUrZMMoBBCiIKRXSWa6S17pAHgu2/spHF/mqLyCINGHV5HtSNx2hivGrj+c28sw7STDDKAUgUsWiMBoBBCiIKRHRApvwo4cgRVwNrVrH/Jn/btK30xzc7/WR34hR4YpiLR4D13Kp0I2gBKBlC0RgJAIYQQBSMTACqtAC9jdiQZwC3rd7P30wbCMYth57c9RumxEO0W4pTTylDKawOYSiewtHQCEYcmAaAQQoiC0dQD2BsCBmiaRq2DHNvl9ac/BODMC/oQjnZds/pYSRiU18ktmWzAlE4gog0SAAohhCgYBw8CDRA5zAzg31Z8wr7djcRKwoy8uPOGfmlJJBZqygCmGrBkGBjRBgkAhRBCFIzsQaAd17t+OFXAiQNp1jz3EQDnXDqgS7N/AOGYCX4AmEjUBwGgZABFayQAFEIIUTCCDKA2sIMAsOOdQNY+X02ywaa8dzeGntc1bf+yhWMWyq8CTiQOYGrpBSwOTQJAIYQQBaOpCtjEdg4vA7hvdwMbX/XG/TvviqpgPMGuFIlZTRnARskAirZJACiEEKJgZHcCsZ0k0PEA8PWnP8R1NH2HlXPqGScd9TIejuwMYGNDnXQCEW2SAFAIIUTByO4EkrZTAEQ60Au45oO9fLhuN0p52b/jRTgrA5h2kk3DwKSlCli0TAJAkaOhoYE5c+bQr18/YrEYVVVV3HTTTc3WmzBhAjfccMMRPZdSiiVLlhzRPg5l8+bNTJo0iaKiIkpLS7n44ouP2XMJIU4MmYyYpZt6Abe3DaDWmr88+QEAQ8/txUmnFB2bQh6GSMwCQoDC0XbTQNDJVJeWSxy/ZC5gkWPWrFm89tprLFiwgH79+vHuu++ydOnSri5Wh+3atYvx48dz0UUXsXz5csrKyli/fn1XF0sI0cWyM4Cua6MMAyscade2H6zdxacf1WFFTMZcNvBYFrPDwlELpRRKRdA6gaWkClgcmmQARY6nn36a2bNnc8EFFzBw4EAmTZrEQw89FDw+YcIElFKsWLGCBx54wD/gKBYsWBCsc++99zJixAji8TgVFRXMmDGDurq64PHMNgBTp04NbldXVwfrVFdXM2XKFIqLi+nVqxfXX389DQ0N7X4dDz74ICeddBL/7//9P84++2yqqqr4xje+cfhvjBAiL2R3AnG0TSQWD45Hh9wu7QSDPo+6+FS6lbYvaOwskbifz/HbAVqG3ws4JQGgaJkEgJ1Ia42bcjp90Vq3u4zFxcW89NJLJJPJFh9/6qmnqKmpYdy4cVx99dXU1NRQU1PDtGnTgnVqa2u544472LhxI88++yyrVq3ixhtvDB7PbAPwyCOPBLf79u0LQCqV4pJLLqG8vJzVq1ezbNky1qxZw+zZs9v9OpYvX86XvvQlvvvd71JZWcno0aP53e9+1+7thRD5KXsYGAen3bOAbHj1Y/Z/nqBbWYQvXNS1gz63JBzLBIBeYJrpmSwZQNEaqQLuRDrtsuPW1zr9eXv/x7mosNmude+//36mT59OZWUl48ePZ/LkyUyfPp24f5AsLy8HIBwOE4/H6dmzZ7N93H777cH1QYMGMXPmTObOnRvcl71NWVlZs30sWrSIAwcOMH/+fAzDCPY5ZcqUIOvYlpqaGtatW8e1117LH//4R1588UWmTZtG//79+eIXv9iu90IIkX+yB4J2td2uHsCN9SnefH4rAGP/fiChdh5PO5MVNlCGCjKApjJBSwAoWicBoMhx6aWXsn37dv7whz+wfPlybr31VubNm8eaNWsoKmpfg+dXXnmFn/70p7z99tvU1dVh2zbhcLjdZdiwYQM1NTWUlJQE97muSyKRoKamht692x501XVdKisr+cUvfoFSipEjR/Lkk0/yxBNPSAAoRAHLHgbGcR1cx+Ktl7fTvWecsp5xirtHvUAqy5pnq0k12lT0LeL0c5qf9B4PlFKEYybJuggaMJTyAkAZCFq0QgLATqRCBr3/49wued6OKC4uZurUqUydOpXbbruNQYMGsXjxYmbMmNHmtlu3bmXy5Mlce+213H333ZSWlrJo0SLuuuuuDpVh9OjRLFy4sNn9lZWV7dq+oqKCsrKynGzhwIED+eSTTzpUDiFEfjl4LuC9u2z+/Lv3g8etsEH3nt3o3jNO955x4qURNq30jhvnXVHVLDg8nkRiFvszGUD/PpkJRLRGAsBOpJRqd1Xs8aJHjx6Ul5ezf//+nPvD4XCLB5a1a9eSSqWYN28epum91kx7v4OFQqEW9zFixAgWLFhAz5492511PNhZZ53Fq6++mnPftm3bGDNmzGHtTwiRH4IMoDaxtQ2EMS2Dkooo+3Y1Yqdcdm/bz+5tuce8/iNOos+Q8i4ocft5g0F7bQCV8tp+SwAoWiOdQESOyy67jMcee4xNmzbx7rvv8qMf/YgdO3YwceLEnPWqqqpYuXIl27ZtI5FI4DgOAIMHD8Z1XR5++GG2bNnCo48+yuLFi1t8rqqqKpYtW0ZtbS2JRCLorHLllVdSXl7OtGnTWLNmDe+99x4LFy7kuuuua/fruPrqq3n//fe57bbb+OCDD3j44Yd54403+Id/+IfDfGeEEPng4AygUmGKT4ry7dvG8v37x/Pt285h0swRjJ0ykNPH9qSyXzEn9SnivKmDu7jkbQtHmwaDVv7x1HYkABQtkwBQ5Bg3bhzz5s1j7NixjBkzhpUrV/LMM88wfPjwnPXmzJlDRUUFQ4cOJRaL8fjjjwNw5plnct9993HnnXcyfPhwli5dyi233NLic82bN49169ZRWVlJLBZj61avkXUkEuGFF14gGo1y0UUXMWrUKO655x6GDBnS7tdxzjnn8MQTT7Bo0SKGDx/Of/7nf7Jo0SLOPvvsw3xnhBD5ILsTiKMdUBHCUa+2wjS96t+BX+jB6L/rz4VXDWPqzV/kW/86hrLKjk0X1xUi8abp4HBdANISAIpWKN2RMUJEjrq6OkpLS9m3b19OhwWARCLBRx99xIABA4hGo11UQtER8j8TIv8tXLiQ9957j/PTQ9j9yevs0pX0O2sSU24a1dVFO2IvLdjMphV/xG54mfOH/APPq3cB+MlPftKu0RMKyaF+vwuFZACFEEIUjJxxALUDKkwomh/N4bPbAOqstn+ZJjpCZJMAUAghRMFoGgbGmwkEFSYUObE657UmErOCcQBdp2n8PxkLULREAkAhhBAFI2cuYL8TSKYN4InOmw/YywDa6QR+R2DpCSxaJAGgEEKIgpHJhll+L+B8ygCGY2aQAUynk5j+aICSARQtkQBQCCFEwTi4DaBSkbxsA5hMNWD5P/GSARQtkQBQCCFEwWiqAjZx/QxgvlQBe20A/SpgJ4np/8RLBlC0RAJAIYQQBSN3IGgHlU9VwHEL8KqAbdfG0t7rkgygaIkEgEIIIQpGUy9gvw0gYUJ5lAFUSoEK4+i0ZADFIUkAKIQQoiBorZtmAtFGUxVwJH/aAAIoFcHRdtAGUAJA0RIJAIUQQhSE7AGRDa3QykQpI28ygJkAEMI42saUKmBxCBIAihwNDQ3MmTOHfv36EYvFqKqq4qabbmq23oQJE7jhhhuO6LmUUixZsuSI9tGaCRMmoJRqtlx//fXH5PmEEMe/7EBIaQ2G12EinCe9gK2QgWEoUBFsNy0ZQHFI+fGpF0fNrFmzeO2111iwYAH9+vXj3XffZenSpV1drA576qmnSKVSwe1du3YxcuRIrrjiii4slRCiKwUBoAa0iyIEkDedQJRShGMWiX1hHJ0I2gBKBlC0RDKAIsfTTz/N7NmzueCCCxg4cCCTJk3ioYceCh7PZNZWrFjBAw88EGTWFixYEKxz7733MmLECOLxOBUVFcyYMYO6urrg8cw2AFOnTg1uV1dXB+tUV1czZcoUiouL6dWrF9dffz0NDQ3tfh3l5eX07NkzWP7whz/Qr18/LrjggsN/c4QQJ7Sg/R8GrnbQfo/ZfKkChsxg0BEcncaSgaDFIUgA2Im01qRSqU5ftNbtLmNxcTEvvfQSyWSyxcefeuopampqGDduHFdffTU1NTXU1NQwbdq0YJ3a2lruuOMONm7cyLPPPsuqVau48cYbg8cz2wA88sgjwe2+ffsCkEqluOSSSygvL2f16tUsW7aMNWvWMHv27MN52wGYP38+V111VRB4CiEKz8E9gJU/a0a+ZAChaTBorw2gZABF66QKuBOl02nuvPPOTn/eH//4x4TD4Xate//99zN9+nQqKysZP348kydPZvr06cTjccDLrAGEw2Hi8Tg9e/Zsto/bb789uD5o0CBmzpzJ3Llzg/uytykrK2u2j0WLFnHgwAHmz5+PYRjBPqdMmRJkHTti+fLlfPjhh1x11VUd2k4IkV9y5wF2vGnTFITC+RMARuIWqLC0ARRtOqEzgJs3b+aKK66gT58+R9ShIJ1Oc/bZZ6OUYs+ePUe5lCeWSy+9lO3btzN//nz69u3LrbfeyujRo6mvr2/3Pl555RUmTpxI7969KSoqYs6cOR3afsOGDdTU1FBSUkJRURFFRUVcfvnlJBKJIHPYEY888ggXXnghp556aoe3FULkj6Zp4Ex/HuAIobCJMvKnZiAczcoAZqqAUxIAiuZO6AxgfX09AwcO5Morr2Tq1KmHvZ9///d/p1u3bkexZC0LhUL8+Mc/PubP09LzdkRxcTFTp05l6tSp3HbbbQwaNIjFixczY8aMNrfdunUrkydP5tprr+Xuu++mtLSURYsWcdddd3WoDKNHj2bhwoXN7q+srOzQfj7//HOefPJJfv3rX3doOyFE/smdBcSrAs6n9n+QmQ7OGwjaylQBJ1NtbCUKUZcFgE888QTPP/889fX1uK6b81h7e52OGTOGMWPGHFE5XnvtNZYtW8bPf/5zVq5ceUT7aotSqt1VsceLHj16UF5ezv79+3PuD4fDLbYrWbt2LalUinnz5mGa3oG1taxdKBRqcR8jRoxgwYIF9OzZk6KioiMq/+OPP063bt2YMmXKEe1HCHHiy1SFWllVwPkyBExGpg2gRjfNBCIZQNGCLqkC/tnPfsYPfvADEokEzz//PFprtmzZwvLlyzuc4TkS9fX1XHXVVfzyl7884QKzY+Wyyy7jscceY9OmTbz77rv86Ec/YseOHUycODFnvaqqKlauXMm2bdtIJBLBAKuDBw/GdV0efvhhtmzZwqOPPsrixYtbfK6qqiqWLVtGbW0tiUQi6Kxy5ZVXUl5ezrRp01izZg3vvfceCxcu5Lrrruvw63nkkUf49re/TSQS6fC2Qoj80mIGMI86gIA/GLTyjneZH3hpAyha0iUB4H/913+xaNEilixZQjgc5r777uNvf/sb1157bdDJoDP80z/9E5dddhnnnHNOu9ZPJpPU1dXlLPlm3LhxzJs3j7FjxzJmzBhWrlzJM888w/Dhw3PWmzNnDhUVFQwdOpRYLMbjjz8OwJlnnsl9993HnXfeyfDhw1m6dCm33HJLi881b9481q1bR2VlJbFYjK1btwIQiUR44YUXiEajXHTRRYwaNYp77rmHIUOGdOi1vP7662zatKldVddCiPzXYhvAPAwAM72blT8ARDolvYBFc12S+66pqeGss84CIBqNkkgkALjuuus499xzufvuu495GZYuXcqf/vQn3nrrrXZvM3fuXP793//9GJaq6918883cfPPNba43YMCAVqvMZ82axaxZs3Luyx4GJuPiiy/m7bffbnX/Tz75ZDtK3Lpx48Z1aAgcIUR+O7gXsCJEOC/bAHoZQOV6xz9bMoCiBV2SAezduzfbtm0DoF+/fvz5z38G4OOPP86Zq/FYeuWVV9iyZQvdu3cnGo1y8cUXA9CnTx8efvjhFre5+eab2bdvX7Bs3769U8oqhBDiyB08DiAqQigP2wAGAaD22tenbQkARXNd8sn/yle+whNPPMH555/PNddcw6xZs/jNb37DX//6V77xjW8c1eeqr69nz549VFRU5HQo+PGPf8zMmTOD26tXr+Z73/sey5cvb7WqMRKJSFsyIYQ4QWXPBOLoFKhuedkLOFMFjN/BUtoAipZ0SQD4y1/+Msj0XXfddZSXl/OXv/yFr3/96/zgBz9o935SqRSbN28ObldXV7N+/fpg+i+AJUuWcPXVV/PYY4/lDARcWVmZ0+Fk586dgNcxoays7AhenRBCiONRUxtAvwpYhQnnYRvATAYQ1/udlZlAREu6JAA0DCOY4QFg2rRpOVOJtdeOHTsYOXJkcHvOnDkA/OQnP+G222474nIKIYTIH82rgPOxF7CJUgaoUFMbQEcCQNFclwSAGzZs4OGHH2bbtm00NjY2a6j/yiuvtGs//fv3b7OR/1VXXdWuKcAmTJhwTDoMSCeEE4f8r4TIb02dQEwc7aDytQ2gdw20lwFMSwAoWtAln/zJkyczfvx4Lr30UqLRaFcU4ZjLzL7R0NBALBbr4tKI9mhoaAA6PnOKEOLEkN0G0PUzgHnZCxhQKtJUBdxJnSvFiaVLAsDS0lL+1//6X5x77rld8fSdwjRNysrK2LVrFwDxeByl8me+yXyitaahoYFdu3ZRVlYWzGAihMgvQRWwNnBwATPvOoGYIQPDVKDCaJ0JACUDKJrrkgDwH//xH/nyl79MZWVlixnALVu2dEGpjr5MR5RMECiOb2VlZcH/TAiRf7LHAbTxpucMRfKrClgpRThmkdgbQfuBn0bjOI6c3IocXfLJ/8lPfsIPf/hDvvKVr+RtFTB4X8RevXpRWVkp3fCPc6FQSA6OQuS57AAw0+I333oBQ9Ng0NptqvpNp9NyjBM5uiQA/PrXv86YMWO44IILCmIOXtM05YsnhBBdLGcqOH8ehHyrAoam6eC0bqr6laFgxMG6JABcsGABv/71r5vdr7VGKdVps4EIIYQoHJmaGG8YGK9NdjjPegFD01iAjrYxtYGjXKmFEs10ySf/o48+6oqnFUIIUcCyq4Advw4438YBhKbZQBw3iUUYB1cygKKZLgkA+/Xr1xVPK4QQooDlBoD5XAVs+hnAekxigC0ZQNFMlwSAAwYMaHVIlEgkQr9+/fjOd77Dd77znU4umRBCiHyVPQyMzrQBDOdjANhUBWxpA5S0ARTNGW2vcvRNnTqV3bt3M3bsWK655hquueYaxowZQ21tLX//93/PkCFDmDVrFj//+c+7onhCCCHyUM5MIJiEIibKyL/xWTOdQGydxsQLcCUDKA7WJRnAN954g0cffZRvfvObOff/9re/5aGHHmL58uVceOGF3HjjjcH8vkIIIcSRyJkJBCsv2/9B0zAwjmtj+XkeCQDFwbokA7hmzRpGjBjR7P7hw4ezatUqAM444ww++eSTzi6aEEKIPJXdBtDNw1lAMrwMYATHTWP6P/NSBSwO1iUB4KhRo/jf//t/s3nzZrTWaK3ZtGkT//RP/8To0aMBWL9+PaecckpXFE8IIUQeyp0KzsrLIWAgkwEM+20ApQpYtKxLAsD//u//5sCBAwwfPpxwOEw4HObMM8+koaGB//7v/wa8WTT+4z/+oyuKJ4QQIs84joPruoDXBlDncRVwJgNoa1sygKJVXXL6M2jQIF5//XU2bdrE+++/D8DgwYM544wzgnWmTJnSFUUTQgiRh7InGLDwMoD5XAXsZQDTxKQNoGhFl+a/zzjjjJygTwghhDgWsgMgAwOtQnk5DzBkBoK2cFyNKVXAohVdUgXcmj179jBw4MCuLoYQQog8k6kCNbQCrdEqQihP2wCGY97rcjCCXsB2SgJAkeu4CgAdx2Hr1q1dXQwhhBB5JncWEBulwnlcBey9LhcjaAOYTkoAKHJ12unPf//3fzNt2jQikUjQ0eNg+/bt66ziCCGEKCA5Q8BoG1Q4bzuBWCET0zLQKoypvYGu06lUF5dKHG86LQD8p3/6J7761a8SiUS46qqrKCkpaTYdnNa6s4ojhBCigGTawFmYONoBIoQj+VkFDF4WsFFFUP7PalqqgMVBOu3TX1tbm3P7vffeo7KyMue+nTt3yth/QgghjrogA6gNXO2glMrbKmBo6gls+IkVCQDFwbqkDeCgQYOwrOaxp1JKsoBCCCGOumAQaAwcvCFhwnkcAEb8sQAN/yfVTss4gCJXl+S/M2P/Hay0tJTHHnusk0sjhBAi3+W2AfSionxtAwhNGUAyGUBbMoAi13HTCziVShGNRvne977X1UURQgiRZ3KqgPFmBMnXYWAgEwBGUP7sJzIOoDhYlwSADz74YNATOJ1OM3nyZGKxGEOHDmXz5s1dUSQhhBB5LBMAmZg4flYsn6uAM9PBKdd7rTIVnDhYlwSA9913H6eeeioAixcv5vXXX+c3v/kNw4YN46abbuqKIgkhhMhjueMA5n8VcCSoAvYygBIAioN1Sf5727ZtwYwfK1as4JprrmHq1KmMGDGCcePGdUWRhBBC5LGcTiBBAJjfVcBKRUB7HV7SjgSAIleXZAB79OjBpk2bcF2XV155hQkTJgDeOIDSC1gIIcTRljsMjHdfPlcBR/w2gPhtAG0JAMVBuuT053vf+x5XXHEF5eXlaK2ZOHEiAK+//jpDhw7tiiIJIYTIY00ZQNMfBCa/q4DDMROlwuB6r1YCQHGwLgkAb7/9dr7whS+wdetWLr/8cqLRKADhcJgf//jHXVEkIYQQeaypE4iBi8KKmChDtbHViSvTC1hnAkDXaWMLUWi6rAHEFVdc0ey+73znO11QEiGEEPkudxzA/K7+hUwbwDDa9V63q11c18UwjpvR30QXk0+CEEKIvJc7DqCR19W/0NQGUOumql8ZC1BkkwBQCCFE3ssdBsbI63mAAcJRC7DQTlPVrwwFI7JJACiEECLvZbJfFiYuhh8g5a9I3EIphQsY2mvrKBlAkU0CQCGEEHkvpw0gBZABjHkBrqO9oBckAyhySQAohBAi7wXDwGgDBzPv2wCaloEZMnDwgl6QDKDIJQGgEEKIvJc7DIxFOM8DQPCygI5WWFoygKI5CQCFEELkvdwA0CSU520AwesJ7GBgSQZQtEACQCGEEHkvnUoBYPqdQPK9DSB4Yx06GFIFLFokAaAQQoi8Z9t+L2DttYvL9zaA4FUBuxjSCUS0SAJAIYQQeS+dzu4FTN4PAwPeUDCOtjC1ZABFcxIACiGEyHuOPyByZiq4wskAmkEbQMkAimwSAAohhMh7mQDQ0iYOOu/nAgYvALSxMP0q4HRKMoCiSf7nwIUQQhQ0rTWO6wKFlQGMxCxcZWFlZgLxO8IIAZIBFEIIkeeyqz5N/E4gBdAGMBy1cAg19QJOSgZQNJEAUAghRF7LDgAtPwNYKFXASkWa5gKWKmCRRQJAIYQQeS0TACoNCoULhCL5nwGMxCxQYQzt3ZYqYJFNAkAhhBB5LRMAmpgoFI6mMAaCjpl+BtC7LVXAIpsEgEIIIfJa9jRwgJ8BzP8AMBIPgYqgtBcBppPJLi6ROJ5IACiEECKvZTKAFgaOdrHCBoahurhUx144ZgKhIABMSQAoskgAKIQQIq8FVcDawNW6IHoAQ6YTiEL5nUBSMhOIyCIBoBBCiLyW3QbQQRdE9S94ASDQVAWclk4gookEgEIIIfJapg1gIQ0BA2CaBlbIQPmdQOy0TAUnmkgAKIQQIq81ZQCNgukAkhGOWV6vF8B2JAAUTSQAFEIIkdey2wA62psho1CEY1bQBtB2nS4ujTieSAAohBAiryUTjUAmA6gKKgMYiVtoCQBFCyQAFEIIkdeSjV4A6A0DowpiEOiM7Ayg47pdXBpxPJEAUAghRF5LNGYygCYuEC6AaeAywtGmDKCDBICiiQSAQggh8loqkQD8NoAUxjRwGZGYCW5mBhSNK1lA4ZMAUAghRF5L+gFgZhiYQmoDGI5ZaN30ejMdYoSQAFAIIUReS6W8KdAyw8AUyjiA4A8Do5uqvCUAFBkSAAohhMhr6ZQ3A0ZmGJhCmQoOvADQwQw6gqRlOjjhkwBQCCFEXktlAkBM3AKaCg4gErNwMbH8n3vJAIoMCQCFEELkNTtrKjgvA1g4AWAmA2j6P/eSARQZJ3QAuHnzZq644gr69OmDUoolS5a0e9va2lpmzpzJgAEDiMViDBo0iJ/+9KfSQ0oIIfJMJugJ2gAW0DAwXgYwhIUX9EoGUGSc0N+C+vp6Bg4cyJVXXsnUqVM7tO2nn37KZ599xgMPPMCQIUPYuHEj3/ve93Bdl3/7t387RiUWQgjR2WzHmwHD1AZ2gWYALW2AahoTUYgTOgAcM2YMY8aMOaxthwwZwu9+97vg9sCBA/ne977HU089JQGgEELkEcf2AkALgySF1wvYIYTpZwAbDxzo4hKJ48UJHQAebXv37qV79+6tPp5MJkkmk8Hturq6ziiWEEKII+D4c+CamN44gAXUC9irAlZBJ5DGhvouLpE4XpzQbQCPpo0bN/Kb3/yGH/7wh62uM3fuXEpLS4Olb9++nVhCIYQQhyMzB66JgYMmFC6cn75QzMTRYPqDQScbGrq4ROJ4UTjfgkPYuXMnU6ZM4Yc//CGTJ09udb2bb76Zffv2Bcv27ds7sZRCCCEOh+tqwGsDqAwDwyycnz7TNCBkBBnAxAEJAIWncPLgrdizZw8XXnghF154IXfeeech141EIkQikU4qmRBCiKMhM7aDhYEKFU7wl2HFTHQmAGyQTiDCk/ffhPr6eqqrq6mvb97uoba2losuuojRo0fz8MMPd0HphBBCHGt+AhATA1VA1b8ZVtQKhoFJNSbbWFsUihP6m5BKpVi/fj3r168HoLq6mvXr17Nz585gnSVLljBgwIBmYwTW1dVx8cUXU1lZydy5c/n000/ZuXMnu3fv7syXIIQQ4hjzZ0HDwsQIFU4P4IxwPIThvwmppASAwnNCVwHv2LGDkSNHBrfnzJkDwE9+8hNuu+22Q267bt061q5dC8App5wS3N+vXz+qq6uPelmFEEJ0Pse2QXm5DlMbGJETOu9xWCIxC6fOnws4meri0ojjxQkdAPbv3x+t9SHXueqqq7jqqqua3T9hwoQ2txVCCHFiSxw4AMoLfkwMzPAJ/bN3WMIxi4SfAbTTMhOI8BTeqZAQQoiC0Vi/P7huYmBGCrAKOGYFVcASAIoMCQCFEELkrQMSABKOWSjt/dzb/qwoQkgAKIQQIm8l/BEgTG2gUJixwgsAIzET5WcAM7OiCCEBoBBCiLyVmfvW9H/uCmkauIxwLITyX7/juG2sLQqFBIBCCCHyVmOjFwBmZsKwYoUXAHoZwBAAaTuNnU53cYnE8UACQCGEEHkrM/etqQs3AAzHLBRhAFyl2PXRh11cInE8kABQCCFE3ko0elOfmRhorQkXYBvAcMwi7HrTmKZNRc3773RxicTxQAJAIYQQeSuVSABgYuIAoVioawvUBcIxi7DjBYC2CdvffbuLSySOBxIACiGEyFvJZCYANHA1hKKFlwGMxCxMHSKsvervjz/a0sUlEscDCQCFEELkrVTCm/vW0gYuECrQcQAdoFhHATjQ0MD+z/Z0baFEl5MAUAghRN5KpbwA0MTA0RCOFGAnkKiJo6FIxwBwQxFpBygkABRCCJG/0qkUABamlwEswCpgwzTAUhQHAWCYHe9JAFjoJAAUQgiRt9L+mHdBBrAAA0AAQmZQBazDEXZIBrDgSQAohBAibwUBoDZw0QXZBhDACBlZGcAIuz76UAaELnASAAohhMhbtm0Dfi9gpbzq0AJkhI2cDKCdTrO7WnoDF7LC/CYIIYQoCI7tAP5cwIbq4tJ0HSNqBRlAbZhgmNIOsMBJACiEECIvaa2xXS8AtDDRhfyLF7OwMIlpf0o4aQdY8Ar56yCEECKP2ckkKC/rZ2oDjML9yVNF3gwoRX41sAwFIwr32yCEECKvJRsb0Mr7mbPwhkIpVFZxGK01JZlq4HCE/Xt2U//5Z11cMtFVJAAUQgiRl1KNDeAHgCYGqkA7gACE4yGSWYNBR7pXAEg1cAEr3G+DEEKIvJZqaEAbTQEgVuH+5EViFgm3aTo4o6gYQDqCFLDC/TYIIYTIa8nGhqw2gCYqVLg/eeGYRULroCewbXhT4tVIAFiwCvfbIIQQIq+lDmoDaBRwABiJexnATBvAhmQSDXz60Qc4tgwIXYgK99sghBAir6UaG4OevyYGRrhwf/LKTo6T0JpuOoJC4bou4dJynHSaXTIgdEEq3G+DEEKIvJbKqQI2MMKFOQ0cQElFjLRSGBgUmV4WsHv/gYBUAxcqCQCFEELkpVRjY1YVsFnQAaBhKKyyCNDUEzh+cm9AOoIUKgkAhRBC5KX62s9yqoDNSOEGgACxyjgARY7XE9gqLgGg5oN3u6xMoutIACiEECLv1O3exd9efQmdqQLGwCrwALC4b5F3aXuZQMewUMqgbvcu6ms/78qiiS4gAaAQQoi88+qvH8FOJVGmF/RZ2sCMWl1cqq7VvV9Jzmwg+/bvp6LvqYC0AyxEEgAKIYTIKx/9dS0frHkdDANNUwbQjBV2BrC8TzFJ3TQY9N69e+l12hBAZgQpRBIACiGEyBt2Os0rC/4LgC9c8rXgfhMTq8AzgN3KwiQhGAy6rq6OkwedBkCNBIAFRwJAIYQQeWPtsqfYu7OGbt3LGXXpFcH9JgaheGEHgEopdMQkRhhTmWitKerdB4BPP5QBoQuNBIBCCCHyQt3uXax6ejEA478zAzMUAsDQCgNFKBbqyuIdF4ziMApF3PCygDoUIVpUjJ1Osbv6oy4unehMEgAKIYTIC5mOH32GDWfIeeOxbRvwsn8AVoFnAAFC3b32f3Enqx3g4NMBaQdYaCQAFEIIccL7aP2bfLDmdZRhMPHqmSilSKe9Ks0gACzwYWAA4id7YwHG/KFgamtrmwJA6QlcUCQAFEIIcUKz02leeexhAEZNuoyKU/t792cygNr7qVOW/OQV9fHHAszKAPYePBSAmvdlQOhCIt8GIYQQJ7Sg40dZd8Z949vB/ZkA0MLP/EkAGMwGUobXBrC2tpaeVaeBUtTt/pQDe2u7sniiE8m3QQghxAkrp+PH9GuIxOPBYwe3AVQh+ckzi8MAlOumADASj1PRtx8AO957u8vKJjqXtIg9ClY88SuK4t1QSoFSKKVQhuHd1ho7ncZOJrFTSdKpJHYq5d9OkU4lUUphWhaGFcK0LG8JhTBNC8O/rQwDZRgY/mXTdRNlGGjXxXUcXMdBu45/3cV1HbTrol03ZzuU8rZXmf0ptKu9dbWL67qgNa6/rXZdDMvCCof9JUIoHMm5bVoWjmPj2g6uY+M6Do5t+2WxcR2XcCxGrKSEeEkpseLS4Ho4Fvfer1a4roOTTuM6Tpv/D8MwMUMhDLPj7X1c1yuzaVod3l67LulUklRjI3YqRSQeJ9qtCGXIj44Qx8rBHT+yNQsATfkuGkVhNFDiZwAbGhpIJpP0Gnw6e7ZVs+O9dxg85tyuLaToFBIAHgUbXnyeaEiGFzgShmkRKykhFI5g22lc28ZJp3H8S63dDu9TKaMpmA6FvADWCqEMA9exvX37+3f969nPY5hNAW8oEsEKAl6v8XQ6kSCVaPAuGxtJJxMtFYJoUTGxomKixcXEikuIFZUQKynBMM3gNWae37HT/mKjXdd/7mjw/KFIBCu4HcaxbdKJBOlkknQygZ1M5NxGKaLdioh0KyJW5F1Gi4qJdisiWlREOBbHsdNe+RMJUolG0olGUpnXlGhEa43lv4dmKOxfD2OGLKxQGDMU8t6XUDh4PPO+ebfDoEBrDVqjtXeiAfgnHNp7q3JOTszgxET5JyquncZOp733LJ3GTqf8y7T/P0zjui6OY6MdB8dx0I4TnBi5rhucnBktnFBlAnXtakAHZcspr1/WQzFN0zuZC2VO6EJNn0PLO+TmfvbSOE7T5911nGD9zPsbvO+WhRkO+++P8k7gMiec/kmnUgau65Coryd5oJ6EvyTrm66nGg6gDKPpcx1qOpHL/O+A4HOU/ZnK3LZTqeAENbMYWa/XMLPvs3LvM03M7O+i4wTfgeCE0bZxXRfTChGK+iec0aj/ffC+A599vK1Zx49smU4gljbQgDJbP8ksFMr0xgKMJMEkhEPabwc4hI0v/7Fw2gG6Hf9NyTcSAB4FZ3/tCuKxCNqx0U4KHBttp9BOGhwbKxrHinXDinUjFCv2bofDWJGod6DVOisISAc/DtlBQSYL5/oZOu3YuHYabafRju39mJmG98NgmhimhWEYGKYZZLK88nnru44NrnepHQetXZQVQYViGOEYhCLevpTys4wK17aDrKWdSmFnZzPTKRzb9g/s3oG+6bpXHqUg1dhI4/46GurqaNxfR2PdPtLJBK5jc+AoT0autYudTmGnU4e1vevYpBptUo0NHdpOKQMzHMJOJkFrEvvrSOyvg5rDKoYQog2jvnwuFdEE7PkATAuMEJgh7IZ9gDcLiKuALcuhsRYa93qXCf9SmRAtgWgpREogWuZdz9xnhpvWbdwLDZ/712uh8XPvPmWAFQEr2vJlKA7hbt4SKfavF3lLpMhbL7k/a78tLHYCXAe0411mX9cOaBcM//Ublv9eWFn3meCkMfkqmjLCdohGK83eRT+gV2IHUMmn725k1b9MxLXiaCuKtuK4ZhRtRXHNCNoI49op3FQCJ53ETadw7BRu1smM0hrDNLBMr6bJNA1M08S0vEvDNFHKO9nzFiPrtn+J8m6CV7OGfzf4d4J/TomrFZrM9cz9GuWmMd0khpPwl0ZMuwHDPkDDgf2d9fE8bkkAeBSM2/rvlJgJcO32bWCG/YNBkXcQMEzvi6u1f5m1oL0vt5PyFtu/1G1XhR4RZfgHwsxBsRTCce8gFY5C3D+whaL+AS4OKP8guds/wO71Dlr1/oE27QdSVhRKo1ARh1CMtBEjQYwGN4pNCMtQmKbC8C9NwwguDaUhtR9S9d7BMulfppuCNBeF4xo4WuFY3XCsIv/SW7QZxQiFMUMRzHAEIxTBCkcxwlHMSBQjFMVN1pOur8U+sBe7oQ67oR47UY/deAA70QDaIRwOE4p42cFwNEI42o1QPI4V7YYKd8OxbRLJFI2NaRoTaRIJm8akQ2PSpTHpoLXCsEysTEYklJ0pCqNMC9s1SLuKtKOwHUi7mrStsW1N2nYxTUXIMglZJlZIETINQpbyFhPQDsmGBIlEkkRjikQyTSKRJpm0SaQckmmNZRmEQyahkEUoEibsv55QNEYo6lXNO6kETsoP9NMpnJQX8Nu2jW07ONrAcRW2C7YDtuPiOC522m41a+Zlq5pue9m2tj+ahmH42TEv25TJSBqmgWl4+zSVxsgs2kXhYOBl9FytveYOGlz/F8R1dVMmEh0sZF1X+N9Rr/AHvxrvNeD9ADmuwnXBdsF1NY4LjqtxXA0a//MMpgGG0lhKYxgaE6/Mjr8P21VN152mfbguXjYVml4HuWUKGzZR0ybiX2auR/xLjcLWBrZrZF2awW2AkOEQMlxCymm6bjhYysUyXFytcLXyvmva8K8bB91WuBjebRXCURYuFg4mGoWhU5huCkPbTf8zdPA/tLXCdk3SrkHaL1/aNUlr77J7uJFxO+6GB+c2+6zYjAAuxMRAuyn476+3/QErAKHU6aQYTcSN00gDtXtrOU2/S9TsTsIJ8eePYnif5kZ/ORyZDNsx/q3qkBBQCpSSSKeBD7q4PF1LAsCjIbUfIlkHX2V4AV4o5gV76QZIHfACN2gK5hJ7O7+sZtg/O246S8YIeT9oqXpI7PMCWe165TsWZbQT3uLvO+QvxUeyz0zTHivqnxlnpjTaC85e7xiU7NguYy3daQFFB92X9Jd9uXebQDd/afZA/OA7gbS/tPd4m2miaPtLCzXQORQQ9Ze2uECDv7T0vC2+OS1ztPKfXgchSmvNPTPxlYvyzodQwdm9qTSmcjGkFq9FmfcuE0PnvE9GyMsyhTOZp7j3PU8nwG6EdGPT9YNPZIMT1m7eMS1U4l23Irknp04663oK7KS/3wPtfxFWDIp6QLdK6NYDulV4ryjtHzPSjVmXDd6lkwLnJK/cru2Vw02Da2P7P3EWBuBCj6EQK4NYdy/LF+vu3daud+xL1HnHpWSdf9u/z0766/rrx8uzbpd7J8ngrWcnsi6zrqcbINXgHWdT9d5vQtK/TO33ymCGvf1lypi9RMu8/5syvaSBMvzMnpl7X877YDcdD10bHBvMEKGNA0lthbgbZS+wd8g/oMb9jEnvbeW9DZtQTgrDTaGcZLAYdgLleItphTBCEYxwBDMUxQjHMCMxjEgcMxwHw8ROp7yMoJ3GSWc3cfGaZHjNQdym5AeZphaZpiKZz7UOPtdN93n3KOV9zjPZQcO/TynvWKONMK4ZwTHCaCOMo0K4/glIfSINT7/Q/s9mHpIA8Gj4wUooP9k/OMa9oKqlXzgn7X/ZM4v/5dduVuo7ayErHW5FwIx4+7Yi3oEiWLKeL5MTJ+sSvH0ZZuu/vBlaewfVZJ1/MNwHSf8gmG70fiCCA1r2Aa7Rex3BQbV784NYpMRbJ535wWlougwO6sncsgeX/kFCKe9HLOIv0RL/un9p+m0x7aSfHaw7KFtY573ndhKcgw/WWZehuFf+7B+JaFnTazJC/gG9vvn/M3XAe0yZfoDtV8Fkgm3Dv1+7XkbXTjT9YGZfDy6Tfub34MuU9/lo9hxZz2Va3ufG8j87ZgSssP9ZCnuPpxv9H6P9B72Weu89UyorAIh7P0Khbk2XptX03ibqvMvkfv+zU4eZqPPKlPl+hONNJ0gh/7phgpNC+a/btBNZ703Sfx/STT/uflOLINjIfM6zq9TCRX5VW1FT0KMyZwqqeX2SUs3/V5n3KHOyFGyf9X1B5153naYf4Zzr/m1o+h8El/7/w4p4z5/50c78iAev278dvJ8xL2gKxVChOISi/mXsoOrFyKG/99mctPeZAP94doQ/E67T8ucqVe+9lm49vKWo0itvW8eo9tKa9J9WwiuveuMARrvB9W8cnX0fbVp773trvx1HmdFQDVu3U5TpCayLod84BvYbx8CLjvnTHxfq6urgtru7uhhdSgLAo6F8IJSUtL2eGfIDiLJjVxaljuwAopT3QxmOQ3HPo1euzmb5P6rdTurqkojO4Nh+RkR6eR4xM9R0InU0GJn2de04Rh5NSmE7XjWkiQHHcwcQpbyTgU5ilngnBKV+ALh3795Oe25x/JAAUAhx4jvSLJXIS03DwJgyCHSWzFiAZdprD1JbW+t1muiE7KM4fsg3QgghRF76+OOPASjSEZkGLotZ4g8GrbwMYCqVorHxcDt7iBOVfCOEEELknbq6OrZu3QpAf6dSAsAsmQCwmzIxHO96ba1MAVdo5BshhBAi72zatAmAEl1GEVGZBi6LUeQNzm4oheV41cDSDrDwyDdCCCFE3vnb3/4GQA/nZAAMCQADylQY3byOPmHX6xAiGcDCI98IIYQQeaW2tpZPPvkEpRQnpXoAYIQ7Pjd4Pst0BIm60hO4UEkAKIQQIq9kqn/79+9PKO1luoyIBIDZgnaAblNPYFFYJAAUQgiRVzLVv8OGnYHyp48wJQOYw/AzgMFg0BIAFhwJAIUQQuSNPXv2sHPnTgzDoGrA4OBHzpQMYI5MBrC74c1LuXfvPlzXPdQmIs9IACiEECJvZKp/Bw4ciGVEgimzpQ1grkwAWBGNezMYug779+/v4lKJziQBoBBCiLyRqf4dPnw4qYSNkZnq2ZJZLrKZxV7v326mhSFDwRQkCQCFEELkhU8//ZTdu3djmiZDhgwhnXAw8QI/GQcwVyYDGEZjOtIRpBDJN0IIIUReyGT/qqqqiEajpJNOkAGUuYBzGX4AaCSdIACUDGBhkW+EEEKIE57WOmj/N3z4cAA/A+iRqeBymUUhUKA0hP2hYD7/7PMuLpXoTPKNEEIIccKrqanh888/x7IsTjvtNABSyew2gPJzl02ZRjAbSLHZDYA9uyUALCTyjRBCCHHCy1T/nnbaaUQiXgeHdMIJfuQkAGwuMxtIj5ISQKqAC418I4QQQpzQWqr+BUgnHUzJALYq0xHk5JIyABoS9di23YUlEp1JvhFCCCFOaB9//DH79u0jHA4zePDg4P5EfRpDegG3KjMbyEnxOGjv/dm3b19XFkl0IvlGCCGEOKFlqn+HDBlCKOS1a3vnjRreenl7VgZQxgE8WDAfsGVIT+ACdEIHgJs3b+aKK66gT58+KKVYsmRJh7avra3lW9/6FkVFRVRWVnLrrbceo5IKIYQ4FlzXDap/zzjjDLTWrP39R7y84G1cVxPJTAEnVcDNZALAkKsxbS8A3P3pnq4skuhEJ/Q3or6+noEDBzJv3rzD2v773/8+GzduZPny5TzyyCPce++9/Nd//dfRLaQQQohjZuvWrdTX1xONRhkwYCDL/987rFr6EQCjLjmVaNwCpA1gSzKdQGiwiYa8nsA7P9ndhSUSncnq6gIciTFjxjBmzJjD2nbPnj089dRTLF26lLPPPpuzzz6b6667joceeogf/OAHR7mkQgghjoVM9u/0007nj/+1iW2bPkcp+NK00xgxoQ87NnoBjQSAzZklXm9ppy5FSXEpdQ3bZSiYAlKw34i//vWvuK7LeeedF9z35S9/mY0bN5JMJlvcJplMUldXl7MIIYToGo7jsHnzZgA+3xRm26bPsUIGk2aOYMSEPgDotAtIANiSTCcQpz7FSRXlAOyr29uFJRKd6YTOAB6J3bt3Y1kWZWVljBo1igsuuIBvfOMbuK7L559/Tq9evZptM3fuXP793/+92f1P/nwtJcWlWGEDK2xihQxvCZsYlsK1NY7tekvabbru3681KJVZlDc6u1IoBfiXWoN2XRztoLWDo21cXFzXu63RgLdeS7TWaFd7+9Hec7quBq39S1CGQhkKwwDDMPzrCsP07ldegcg0pVZ+oVXWfVr7zwH+8/kF8i+skEkkHiYSCxGNhYjGw0S6hYnFw8SKwphhEzftYjsuru1ipx1cR2PbjvdeOS5aaUCjlYvGBaXx/lxAY1oGkWiYcMQiEgsTjoaJxsKEIyEsywoWpZS375SDnXa9y5SLnXa9/0XW68+8B6bpvS9aa9IJh1TCJp1wSCcdUknbv8/BSTuEYyFiRSGiRSFixSGi3cLEikKY7eiN6PrvnRG8715bJ9u2cRwnuFRKYVkWpmkGi2HID50oDB999BENDQ0YOkTjJ1HixSEm/6+zOHmAN66d1hpt+wGg9AJuxiz2OszgaHpWnsRb26AhWd+1hRKdpmADwGx9+/alsrKyzfVuvvlmbrrppuB2XV0dffv25f3ESqI6ghcF+YEYOud28/uzH8umvGCM3B5rWnmBzlGVOR6aLTzm+svRlgD2H4P9Hg6tQCsUBkoboL1LheE91gaFCrYB1ezSD4OzAlbvUpkaw/TmYNLaxcX1fqj8S8gNclGu/7lp5//ff03epR+0ZwL1TNCetRjKe82GYWDgBZCGMlDK9B9TTYG91sGCBtcP8C3L9JaQhRUyCYUtb4l4i0KhXRfX9U44XMe7rl2N62ZOglTzBSM4GbLTDul0GjttYzs2tm17JwaOFwyjwVBm1mJ5lzTdl/Meqqzvpv9dVUqhDANDZU6GvOfPnBAppdCut65Xfu87HZzsaO/kyTRNTMsMLi3LxDQtLMt7zDANDMP0TzC899s0Df95DO9zoTMneJnr/qL9+9zM/8LF1VnXXRfXcb0TklSadMr2lrSNnXa89892vJOLrBMcwzD8S++2RvsnGja2473PruvguDaOXy6FgcL0Fv+7o7R/XZso/3WZhveam05UDEwr92QlcxLrXQS3gnKapve/Ma2mk7Htuz4EINxYQfeTu/G1G86itEes6X/sn9yCZABbokwDoyiEW5+md0V3ABydYt26dQDYtu1952w7WBzHwTCM4MQz+zJzPXPSmkkABMeMrPta/L5nH5cMo+m75J/YHnyZvQTfU6XA9b6nobDlJWIOOinWWlOXSHfKe3w8K9gAsEePHti2zd69e/mf//kfAJYtW4ZhGJSXl7e4TSQSCUaYz6atJO5Reyd1JgZsg4FSBigDrY3mXyBDYdCUVVTgZ+v8O32ZL2oQr2TKoLPu8n75/Vsq60CtMyFOcD07bAp+XjMZwawfKW/xrrfn1TZRGJmgAMN7H7Tyn9kP3IJgyssQauUt4OYWUGk/e+h2qARH1ZGMTJEJUg8ODJVG47T+Ocr8K48mOZaeeBx/Odr/u8zXMUNnPdcxUhw+mbIxFqve2oyhwUBjKI1pawb46/zm6T9Rl0yxr9GmrjFNXWOKusY0+xtTmApKoxalUZPSiHdZErEoiZiUREyiBiQSKRKJJIlEimQiTTKRJJVMkUymSSfTOFrjonBQ/ktWuNq/9I/LsbBFPGwSC1vEwqa/ePdFLZO01iRsl4StabQ1Sdul0dE02i6Nfo2R69po2wv0cVxcx0G7LjgOWuvghClz3FeGkXNbOw5uOo1O22g7zTcrx9IjXMrv71+IGmShDZulS5ceu39WV9DgnZz7H0ytSCYSXVmi40LeB4D19fXs2bOHiooKioqKgvu/8IUvYBgGf/nLX5g8eTIAK1euZMSIES0GeYcy/pVXKTJNlNaozNmN1t6X3zAxtIvhagztYGrtHR40wboZ2q/+1eReApiOg2k73qXjHDJucFGkDZO0YWEbJmnTwlYmjmHiKKNpybrtKkXYtYnYaaJOioiTIuJ410Nu8yN32jCxDQvbtHAMC8c0cQ0TXAdcF+W6GFpjatd7/f7rNrSL0hrDfw8M/PdMea9fK5XzHuogqlTBe+S/g96SOdNEBdeBpufUGpSBa4TACJG2otiWBdoB5eIqL9vmGArXMnEs/7UoheOVEserk8dV3vO6GGjD/5UzlDd+ql92bfiLMjC0/3rdzKULysRVEVwjjNIKw7UxXBflOhiOg6EdDMfGcB3vM6RCaNMCFQEzDEYEzBDaioIV8d4F7aBx0HjNArTSuNoLer0QWOFqhcbE9U8YtDLQyruNYeAaCm0a/usxgteBqfwzdu2VX3uL0i64btOJgWGijRCuYaENE8e0cA3vs+Ga/mFGa5R2/WSbd6l0UzQanFio7PwPfkCL9366/uL/fy3/M2b6nxlHaRwDbOUlsB0DHAWOob0fYZ35tHifsyBWCU54VNP/UmU+X951/P9/0wlSJrukg/u8BzKfBXL3ozJJ56yTvMxrDX6XMidXXlmVv1HmJEfpzGvwawqyM9Va5bwW5boYrovhf7ZMx8Zw0piOjeWk/dfln0Qq0/9M+NcNE7QKjjem6x1/vP2kMR3vc6qU670mA1wTXEMFi2MqXMPANUx/MbIuvSX7O6uC9zLzPvuXmRPXzP8m+K57l0X7E5z/51uxljSPZFW4CL56LwAj/+P64LMmmsTG9oaeI7hw9we8WHQGtSfpptoQnTnJzqolwfA/s00n1lplai0y92XL/h8fXLOVW0PWlADxv1N+857cWhC/ZiTzbVRN67bK/2LorHW0dSyquE4sJ3QAmEqlggbAANXV1axfv56ePXvSs2dPAJYsWcLVV1/NY489xlVXXRWs26NHD77+9a/zf/7P/+Hkk09mx44dPPTQQ/ziF7/ocDl0o00Im4iTJuSk/bCh6xhoIq5NxD12U/qEXMcLDO2WO8x0mJcibP2xnOqhju7bAdf7cYikZJR7IfKFqxSuYaINRcoIByeRmUCeaAlFgHZtGuNFTbUjQfMH7zbKwFUEGTzHz9w5GmyU17rYtMC0UJaFClkYloURCmGGLMyQ5WfYdJAIUNr1T3q8RbsutqtxHO8yc91xNbbr4joaQ4GlwFQaU3mtc0wy1zXKa6DtX5oo079uGijDBL+qU/u1Nto/rga1NBqUZWJYIYywhWmF0EXFAIRHnctXw9s54BZ7Vb+Oi+1obNtrk+24GsfROK5GmSaG37zB8N8L07QwQ2FMy0KZpnfiieFfKv+9NXC1d0Lq+M0VHNfxLrXrvx/eYqCx0N57oBSm1v574Z28GdpFuw7atXHdFNrxmiu4TgrHSeO4NkY4ghGJYUUiGOEoRiiCGQ5jhEI0RqTa4oQOAHfs2MHIkSOD23PmzAHgJz/5Cbfddlub2//yl79k5syZjB8/nng8zk033XRYQ8Ccs+IlyruXAX41ZzqNbmzETSTR6ZRXzWqaTV9c02y6zPT+yHxZ/S9qJhjSfpZFWRYorx1SsJ1/MPAaSNnoVAqdTuOmUuBf6nQanU5DOo12HLTtoO20V11gO2jH9rZ1XYxoFBWNYsRiGNEoRKPocAQ3EsW2QjiOJpVMkUoksRNJ0skU6USSdDKJnUihbYd4LEQ8GiYWDdMtGiIc9g+YmbIapn/AVUHZVfbr8N/DdNqmMeXQkLJJJG0akt7tpG0TD5kUhU3vMmISDxmYhmp63wwj573KZA3SGlKuImE7JNPefpMpf0nbJJNpkmmvvVQ8ZNA9YlIW86qCikJeRi+T4dTaOwiivKxZ9vWUCwnby8m5rt+cUvsLfmZYNx2kg8XVTf9/1+v40phI0tiYItGYpLExSTKR8qugvMVAYxlgKeVfgqnAMpR33VBYIYtQOORdhkzCoRBWxCIUChGyTNK2Q8J/HzKXqbRNMu2QTKZRShGyTMJhk3DI8pem64Zp0KAN9ruKOltR5xjsdWBvGmrTUJvShAxNkQlFhqZYabqZLt2UJqYc4solbPjZLv8HvOnzgffjrCGVtkkk0yRTaa8KLpn2/39p0kmvGq844n02isImxWGTbmGTorBBt5BBzFK4ysDxs7suYGPgoLCVwvGzE8rrIeVdahdc7YUA/qVhmJimwjQM70fQv+61S1K4rvbazPntG23H+3G3/TaQaI1lGoRMhWUoQoaBZSr/toGZyV76Hwnbr02wM1WKGozM/9k0vP+1obz/tVJYJoQMAyMcQlmhIGBRlgWW/33MPp5kv980dT4Lmopkn5hlXdfaa0OGaXqff8PwL02UZTZ9r6FpX1n79TphOeA43vEpe7Ht4LpX/hAqHG5+abbUgLmJvaeRnfesxYhFGLVudYeP7YVg3wvV7H9lOyVjv0z3KVVdXZxOU1dXBz++tquL0aVO6ACwf//+Tb1MW3HVVVflZP6yde/end/+9rdHXA7LbGpgqpRChcMQDmOWHvGu2y8UQvlTIB36kHhiCAFx4KSjuM8w0O0o7q81UaCkE55HiBOdYZreSVo4fEz2Lz2A25YZDNrZn+rikojOJt8KIYQQeSkIAKUHcKsy08G5dRIAFhr5VgghhMhLEgC2zZAMYMGSb4UQQoi81BQAHsl4S/ktmA5uf6rNJlUiv0gAKIQQIi9p2w9oJAPYKrOoaTYQt+HYjRwhjj/yrRBCCJGXZB7gtinLwOjmBYGOtAMsKPKtEEIIkZ+kF3C7NHUEOUrjuooTgnwrhBBC5CXpBNI+0hGkMMm3QgghRF6SALB9MhlAqQIuLPKtEEIIkZckAGwfGQy6MMm3QgghRF6SALB9JANYmORbIYQQIi9legEj4wAeUiYD6EoGsKBIACiEECIvuQfSgGQA22JIBrAgybdCCCFE3kl/eoADaz8FINK/pItLc3wLqoBlNpCCIgGgEEKIvKJdzedL3gdHEx1aTnTYSV1dpOOaWeQFgDIbSGGRAFAIIUReqf/zJ6S370dFTbpPqUIpaQN4KN5sIBYg7QALiQSAQggh8kZ6TyP7XtgKQNnkgZilkS4u0YnBLPbeJ2kHWDgkABRCCJEXtKupXfIe2C6RqjLiZ5/c1UU6YTR1BJHp4AqFBIBCCCHywoFVNaSq61Bhg+5fHyxVvx0gg0EXHgkAhRBCnPDszxPse/4jAEonDcAqj3ZxiU4sMhh04ZEAUAghxAlNa03tU++jUy7h/iV0O6dXVxfphJMJAF0JAAuGBIBCCCFOaA1rPyX5wV6wDLpfMRhlSNVvR0kVcOGRAFAIIcQJy9mXZO9zWwAovbgfoR7xLi7RiUlmAyk8VlcXIJ9orcHVaEeDo9GOCy5ggDINMBXKVGCoY9I42Xt+/OfNlMP1Lt2s0d111oVufn9wn869qRRe2Q3lvRbDey0Y/utSyttI+9tq3bR7/4q3rdH0PhzmmXrmtaK19zyZ66729mv573ceNwLXrgZFXr9GIQ5Fa03t0x+gEw6hvsUUnX9KVxfphHXwbCByXMl/EgAeBTt++gZ1VhycDkyhYzQFg15ACCi8IEoBZN2H8gIerZsCqyD4wQv2XN2x5z9eZIJjQ6EsP4j0X5fOCvDQBwd97dy/ZaAsLyDMLF5geKiNFIQMjLCBCpuosIkRMVEhAxXxbitDodOuvzho27+eddkmP0jXjgbbzQnYteN6JxFZga3WTdeD168IAmpl+YG11XQ7O1DPCdxV5j7/fXZ17onDwZ8pP/hHqeBEIAg+s/ef9bnOeV6DnPuC64qm8qis15R9JXM7+31xssprNwX+RsRERUyMqH8Zsbz/WcTECJuA/znKvJfZJyrBd8t/3Zn3IOsSTdP72uL7baAy9SqZ16RU5mtMGx+8jvFPqoLPBeQcH3TK8RfvM+pmrqccdNrN/Qxly9x28T7PWQu2i7a1d9tx/ffA8L4bme/XQd83Fcp6PJRZx79uKLTj7RN/n9r2/7eZS9X8pDPzGbN3N5J453MwFeXfkKrfI5E9G0jDm7tQlvI/9/jHH/874Oqmk3hTef//rOstn3i3dMD2jwsq61ji3x3clzleZB8n/ONWi9+lg+46WgmHfCUB4FGgUy6oViISPynWTOZHJbOPY1Iy/B/ezI+SauVg3/TFC75T6qD1M6+jtQDhcLmgXS9Y0sdi+CnbRdugcY7Bzo8DmqbXmMzT1yhEG8JfrmR/aRKnoQFHO9iuHVzaro2rXRzteIvrNLsOYCgjWExlolCYhndpKANXu2g0rnZxtXfMylzXWuPiXWoygbl3Pfs+AEVTgJR9PSOzv+xtM8+dfX/m+YBgnbZk1ne1i4uL6/qX/nOeG+lDOGl6YynmIVdp/v/27j84ivruA/j7u7t3l+TOhB8hQiDBhyYGmlwYClPHR+uItT61aJ1CFXGswKDFPk6llHSqdIR0fCjOFIVCxxmnrToWsUiLIk5/joUCqfwQg2LCjwKZQu3FkmBCCMn92P08f+ztekeC3iWnR7j3a2Znb3fv9j77ud3vfva7d4mlLFiaoDPSle1wso4FYAb873/9H1CgEFMmYiqGmLIQUzGYsCBKoETBEB06dBiiQRfdnhYdBnRookFBwYAOj+aFRxnwah4YmgceZcBQBkTBPuBVvEG4YBxBBGFE0GuF0YswwhJGrxVGFFG3YdCUBkMZ8OgeeDR7MDQDHs0DXdNhieU2mE7jGLNiiEkMpmVCU5r9Ov2j13niMfqUDwYMRCWKqBVFxIogIhFEzI+mo2YUmtLggxdeeOARwx7DA694YMCABwagK2hKQal4z4rSoJSCpmsAFGKIIYoYYlYUUcQQkShiEkVUYohKFJZlQTMVdEuLj3UYlg6vGPDEBwDQVXwbdANezRvfJi+8mh1PnuWF1/TAZ3rgs7zwWvZjr+mBEiCsIggjirBm57wHYZxXPehBL8KIQGDfRlFKQcE+saj456BgX5GKJrB0gWiA6HDH9pUr3N4PpRQ0Tbd7uTTNnacsBbEsqBigTAXEt12ZgLKUvf3K3t80aO7+pkOHLhp00WBpFiwlMFX8ZKDZj01lwlLx28yioCQ+hoIWHyt7x4RYJqyYfUIRK96LaVkQS6BMQIMGDwzo0O2x0t1pJzY7T8ouapV9TWX3ndknSCcm5zgzlRV/bE/rosFnepHnDj7kmR7kmT74TC+8lv25Jx43oj46gYoCLGUfY5ayp0UJLM1+nmh2PLpl71O6aNCtxMGe58YtAKDcaQUAovq/JrzgAvKjb2b0vUhUYsdrv4U4b5Mwz96OiBZFWI8irCLo1SLoVWH0aL3oUWH0qF6IArR4caMpDRp0aEq5n4VA4vu4/VpnH+9FLyIqipgy48eTB17LPq68Yh87HssDn3jc5T4rPl8M+CyP/RrxwBAdURVzB7cN1cz4Z223Xbpo0ERBF90dO/vy+94PsC70EmIbeQE0WP8z/L/x5c5r7EIJFixlwYyPLVjxNkKgQ4NHDOiiwRADHtFhiAFD9Hj72l9PW+I+7hzZdhui4aP2JN5aQpP4GAqaaPF5GvT4dPyIgpbGTxk0UdBEBywgL+odTKouCywAM6Ajvxvw2VdXztVkIlFiN3AYwD/Zdm5NZYAlll2UWQP/km+v2QtEBxGEABH08/6J7UXihexg/i+5Qvp7uABJnYV6fPgsmPFhMPlNl1ONJO5jAz2PsjWhLNOVbg+aDkMZ0DXdvvDVDHeZoRl2L59mTzsXZE5vnimm25YLBKZlj53nac4FqXPREr9wcS/sAHee08OnnLspTvEOJPcWxnv1nHVcbL2J723fQU2OQaG/witZ4joSez2VUtAmaNiJY0m5cfLpdCDYzwc0ZUFXCkrFoCuBUmb8NVF3+xJ7RUWSezLd7U7IR2IunMdJvZ8X9Ig6n1ni4Hx+lljwwgOf8sIHnzv2wgOv8iDWHQXWZGa/G6qUiGSovMg9Z8+eRVFRETo7O1FYWOjOv7AR+biD0tmJo/GeMndImI5ZsaTnAx8dLM68xN68/sYAELNi7voS3ycmdq+f23Bqdq+j22jGG1OB9IktcX2WWMk9gwk9jYlx9HfQOrckTMtMul3j3r6J36qxxHIbJ0PrG+PFGn+nIXNiiJgRhM2wOyROR8xIUiOS2Hg5DZpSCj7dB6/mhVe3B5/ug0fzwKf7Lrqt7klFTFiWlXS7yrRMt7c1cb7zOqeHNnHa2a4Lt9PJg4JyY07cpsR43BMU+t6eSpVP97l58OrepLx4NI97InV6mJ19ztl/nF7qxIY/cQyxT6rOyQqI37K74AR44ckj6YQL+cRt+rhbhW6+LljHhbfwLrY8cX5izi+cp6CSctdfPgH0Of7c49qMQiDJx6LTHsSPSed4TvwsEvc7p81JjMEZG5phj5Xhblt/p5GL5TsxH077l3g8JO3zlgUoJBUj7lhL3vedx0SpuNj5O5fwmv1TkHiSSpnn04mF+uf3+LMdAhERUdbwcomIiIgox7AAJCIiIsoxLACJiIiIcgwLQCIiIqIcwwKQiIiIKMewACQiIiLKMSwAiYiIiHIMC0AiIiKiHMMCkIiIiCjHsAAkIiIiyjEsAImIiIhyDAtAIiIiohzDApCIiIgoxxjZDmAoExEAwNmzZ7McCREREaXKOW875/FcxAJwENrb2wEAZWVlWY6EiIiI0tXV1YWioqJsh5EVLAAHYcSIEQCAkydP5uwOlElnz55FWVkZTp06hcLCwmyHM+Qxn5nFfGYW85lZzGd6RARdXV0oLS3NdihZwwJwEDTN/gplUVERD7gMKiwsZD4ziPnMLOYzs5jPzGI+U5frHTf8EQgRERFRjmEBSERERJRjWAAOgs/nw/Lly+Hz+bIdymWB+cws5jOzmM/MYj4zi/mkdCnJ5d9AExEREeUg9gASERER5RgWgEREREQ5hgUgERERUY5hAUhERESUY1gADpCI4LHHHkNJSQkCgQDmzJmDzs7ObIc1JDQ3N2PWrFkYN24clFL47W9/m7R8+/btqK2thc/nQ21tLXbs2JGlSIeGFStWIBgMwu/3o7S0FPfffz/a2tqSnsOcpqe+vh4TJ05EQUEBrrzyStx7770IhULucuZz4BYtWtTnuGc+0zNv3jwopZKG+vp6dznzSalgAThATz/9NFavXo1f/vKX2L59O9599108+OCD2Q5rSDh37hwmTJiANWvW9Fn2wQcf4Pbbb8f06dPR2NiI6dOn4/bbb8fp06c/+0CHiDfffBM//OEPsX//fmzevBlvvfUWZs+e7S5nTtM3YcIEPP3002hqasIf//hHvP/++7jzzjsBMJ+D8Ze//AXvvPNO0jzmc2BuvvlmhEIhd6irqwPAfFIahAYkGAxKXV2dO/3666+LruvS1taWxaiGHgCyadMmd/rJJ5+UkpISMU1TRERM05SSkhJZvXp1liIcejZv3iwApKOjQ0SY00x47bXXRCklPT09zOcAtbe3S0VFhRw9ejTpuGc+0zd37lyZMWNGv8uYT0oVewAHIBwOo6mpCdddd50774YbboBpmmhsbMxiZEPf/v37ce2117r/Z1nTNFx//fV46623shzZ0NHR0YH8/Hz3D8Iyp4Nz5swZvPDCC6ipqUFeXh7zOUAPPvggFi5ciMrKyqT5zOfA7Nq1CyUlJZg0aRIeffRR9Pb2AmA+KXUsAAegvb0dlmWhuLgYixcvxrRp03DFFVfA6/Wym32QTp8+jeLiYuzZswcjRozA3r17UVxczLym6Ny5c1i5ciUeeugh5OXlAWBOB+r1119HIBDAyJEj8a9//Qt//vOfATCfA/HrX/8a//znP7F48eI+y5jP9H3ta1/Db37zG7zxxht45JFH8Ktf/QoPPfQQAOaTUmdkO4ChrqSkBOXl5dkO47JTUFCA8ePHw+/3ZzuUISMWi+Gee+5BaWkpVqxY0Wc5c5oe5ztUJ0+exLJly7Bo0SJs3LjRXc58pubUqVNYsmQJtm3bBl3XL/o85jN1d911l/s4GAzCMAx861vfwtq1a935zCd9EhaAAzBy5Ehomoa2tjY8+uijAICuri5EIhGMGjUqy9ENbaNGjUJbWxuCwaB7O72trY15/QSWZeG+++5DKBTCG2+8Aa/X6y5jTgfG7/ejsrISlZWVuPrqq1FeXo66ujrmM0379+9HW1sbpk6dmjT/nnvuwebNm5nPDJgyZQpEBCdPnmQ+KWW8BTwAPp8P1dXVaGhocOft2LEDuq5jypQpWYxs6Js6dSrefPNNWJYFwC5sGhoaMG3atCxHdukSESxYsADNzc3405/+hMLCwqTlzOngOT1X3d3dzGeabr75ZjQ3N+PAgQPuAACrVq3CqlWrmM8MOHz4MJRSKC8vZz4pddn+FcpQ9fOf/1z8fr9s2bJF9u3bJ5///Ofl7rvvznZYQ0I4HJbGxkZpbGwUAPLTn/5UGhsbJRQKSSgUkkAgIA8//LA0NTXJww8/LIWFhfKf//wn22Ffsr797W9LeXm5HDx40M1hKBSSWCwmIsKcpqmrq0u++93vyrZt26SlpUV2794tX/nKV6SsrEy6urqYzwxAwq+Amc/0dHV1yfe+9z1paGiQlpYW2bp1q5SXl8uCBQtEhPmk1LEAHCDLsuRHP/qRFBcXS0FBgcyePVs+/PDDbIc1JLS0tAiAPsPy5ctFRGTbtm1SU1MjXq9XgsGg/O1vf8tuwJe4/nIJQFpaWtznMKep6+npkZkzZ8rYsWPF6/VKSUmJzJw5Uw4fPuw+h/kcHFzw55+Yz9SdP39epk+fLsOHDxePxyMTJkyQpUuXyvnz593nMJ+UCiUiko2eRyIiIiLKDn4HkIiIiCjHsAAkIiIiyjEsAImIiIhyDAtAIiIiohzDApCIiIgox7AAJCIiIsoxLACJiIiIcgwLQCKiT8mrr74KpVS2wyAi6oMFIBFlxLx586CU6jOk6/nnn0cgEPgUIsys+vp61NTUfOxzbr31VoRCoc8oov5FIhHk5+fj3//+N3bu3ImqqqqsxkNElwYWgESUET/72c8QCoWwZMkSVFVVIRQKZb34yTafz4fRo0dnNYa3334bo0ePRmlpKRoaGnD99ddnNR4iujSwACSijCgqKsLo0aMRCARgGAZGjx6dVPxs374dSim89NJLqKysRGFhIRYuXAjLsgDYPX9KKcyfPx/d3d1uD+KNN96Y9D6bNm1CTU0N8vPzUV1djZdffjlp+R/+8AdUVFSgoKAA8+bNw2233YZ58+YlPceZ/8wzz6CsrAz5+fmYM2cOAOD48eO44447cOWVVyIvLw+TJ0/G1q1b3dfW19dDKYUf//jHaGpqcuNMfI9du3Z9Yi/oxo0bUVVVBa/Xi6qqKmzatClp+VVXXYWlS5fitttuQ0FBAaZNm4Zjx46l9FkkamhowHXXXec+ZgFIRACAbP8zYiK6vCxfvlyqq6v7zN+2bZsAkFtuuUXee+892bRpkyilZOvWrSJi/5P7UCgka9askYKCAgmFQhIKhaS9vd1dx1//+lfx+/3ywgsvyPHjx2XDhg2Sl5cnu3fvFhGRtrY28fv9snjxYjl8+LAsXbpUDMOQuXPnJsUyd+5cGTt2rHz1q1+VvXv3SlNTk/ziF78QEZHdu3fL448/Lvv27ZPjx4/LihUrRNd1OXHihIiIdHV1SSgUkiVLlkhVVZUbZ0dHh7v+SCQioVBInnvuOemvmW1ubhZN02TlypVy5MgRWblypei6LocPH3afM378eBk1apS8+uqr8t5770ltba3MmjUr5c/hO9/5jhQVFYnX6xWfzydFRUWiaZr4/X4JBoMpr4eILk8sAIkooz6pANy5c6c7r7a2VpYtW5b0vOeee078fn+/677xxhvlkUceSZp39913y8KFC0VEZN26dVJSUiKxWExEREzTlNLS0n4LwMLCwqSi7eOMGDFCnnnmmZS2M9Err7zSbwH4/e9/X77whS8kzZs6daosWbLEnR4/frwsWLDAnX7qqaekvLw8pXhFRE6fPi3Hjh2TQCAgO3bskC1btsi4ceOkpaVFTp06lfJ6iOjyxFvARPSZqqiocB8PHz4cZ86cSfm17777LlavXo1AIOAOv/vd73DixAkAwD/+8Q9MmjQJuq4DADRNw6RJk/pdVzAYRFFRUZ/53d3d+MEPfoBJkyZh2LBhCAQC+PDDD3Hu3Ll0NvNjHTt2DMFgMGne5MmT+9ziHUyuiouL0draitLSUnzpS1/CwYMHMWPGDFx11VUYN27c4DaAiIY8I9sBEFFuMYzkZkdE0np9fX09vvnNbybNy8/PTzuOYcOG9Tu/rq4Ov//977F27VpUVVXBMAxce+217ncVP0sDzdWLL76IhQsXIhaLIRaLIRAIIBwOQ9M0rF+/Hs3NzSgvL/80QiaiIYI9gER0SfF6vYjFYv0uCwaDOHHiBCoqKpKGsWPHAgAqKytx6NAhmKYJALAsC4cOHUrr/Xft2oX58+fjjjvuwMSJExEIBNDe3p5WnJ/kc5/7HA4ePJg075133knq8RuMr3/96zhw4ABqamqwbt067NmzB0op/P3vf8eBAwdQWlqakfchoqGLBSARZURnZydaW1tx7tw5xGIxtLa2orW1Ne31VFRUIBwOY8uWLejp6UEkEnGXLVu2DM8//zxWrVqFo0ePYt++fXj88cexfv16AMCcOXPQ3d2Nuro6HDlyBI899lhat00B4Oqrr8bWrVtx8OBBvP3227jvvvuQl5fXb5wtLS3Ys2cPent7EY1G3WVnzpxBa2srOjo6AMDNhXMbecGCBWhsbMQTTzyBo0eP4oknnkBjYyPuv//+dNPVryuuuAJlZWVobm7GrFmzcPr0aVRWVmLq1KmoqKjo07NIRLmHBSARZcSiRYswZswYPPnkkzhy5AjGjBmDMWPGpL2eL37xi1i8eDEeeOABFBQU4JZbbnGX3XTTTdiwYQNefPFFBINBzJgxA3v37nX/uPHIkSPx8ssv47XXXsOUKVPQ2tqKm266CT6fL+X3f+qppzBs2DBcc801mDlzJu69995+e8y+8Y1v4M4778Stt96K/Px8PPDAA+6ymTNnYsyYMZg/fz4AuLlYtWoVAKC6uhrr16/Hs88+i+rqajz77LPYsGEDJk6cmHa+Lmbv3r0YP348SkpKsH37dtxwww0ZWzcRDX1K0v0CDhHREDJ58mTMnj0bS5cuzXYoRESXDN4HIKLLytq1a1FbW4vy8nJs2bIFhw4dwl133ZXtsIiILiksAInosnLy5En85Cc/QWdnJ6qqqvDKK69k7McVRESXC94CJiIiIsox/BEIERERUY5hAUhERESUY1gAEhEREeUYFoBEREREOYYFIBEREVGOYQFIRERElGNYABIRERHlGBaARERERDmGBSARERFRjvl/C6SQ9txPGv8AAAAASUVORK5CYII=", "text/html": [ "\n", "
\n", "
\n", " Figure\n", "
\n", " \n", "
\n", " " ], "text/plain": [ "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "#Get raw spectra and standard deviations\n", "specs = sdfits.rawspectra(0,0)\n", "stdevs = np.std(specs,axis=1)\n", "\n", "\n", "#Organize into scan and switching state.\n", "#There are 2 scans for the target and reference pointings, 2 calibration diode states, and 2 polarizations.\n", "stdevs = np.reshape(stdevs, (2,-1,4))\n", "\n", "nrows = stdevs.shape[1]\n", "\n", "#Inspect the data (last integration is removed, it has issues)\n", "for scan in range(2):\n", " for sw_state in range(4):\n", " plt.plot(stdevs[scan,:-1,sw_state],label=f'State {(4*scan)+sw_state}')\n", " \n", "plt.xlabel('Integration #')\n", "plt.ylabel('sigma')\n", "plt.legend()\n", "plt.show()" ] }, { "cell_type": "markdown", "id": "1cc1b7bf", "metadata": {}, "source": [ "We can see that the 4 states corresponding to the OFF scan have a significant jump corresponding to the GPS L3 RFI. It does not appear to start until the 40th integration, so we will use that as our cutoff to calculate the statistics of the good data, and the thresholds to flag by." ] }, { "cell_type": "code", "execution_count": 17, "id": "ff6985a4", "metadata": {}, "outputs": [], "source": [ "flag_mask = np.zeros(stdevs.shape)\n", "cutoff = 40\n", "\n", "mean = np.nanmean(stdevs[:,:cutoff,:],axis=1)\n", "spread = 3 * np.nanstd(stdevs[:,:cutoff,:],axis=1)" ] }, { "cell_type": "markdown", "id": "02813c6f", "metadata": {}, "source": [ "Now we create our flagging mask of zeros and ones, where a one corresponds to a flag to be applied." ] }, { "cell_type": "code", "execution_count": 18, "id": "2c150694", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[176, 178, 185, 186, 187, 190, 191, 194, 195, 198, 199, 201, 202, 203, 206, 207, 208, 209, 210, 211, 214, 215, 216, 217, 218, 219, 222, 223, 226, 227, 230, 231, 234, 235, 236, 237, 238, 239, 240, 242, 416, 417, 418, 419, 420, 421, 422, 423, 424, 425, 426, 427, 428, 429, 430, 431, 432, 433, 434, 435, 436, 437, 438, 439, 440, 441, 442, 443, 444, 445, 446, 447, 448, 449, 450, 451, 484, 486]\n" ] } ], "source": [ "flag_mask = np.zeros(stdevs.shape)\n", "\n", "mean = np.expand_dims(mean,axis=1)\n", "spread = np.expand_dims(spread,axis=1)\n", "\n", "flag_mask[stdevs > mean+spread] = 1\n", "flag_mask = flag_mask.flatten()\n", "\n", "flag_rows = np.where(flag_mask==1)[0].tolist()\n", "print(flag_rows)" ] }, { "cell_type": "markdown", "id": "f591df7a", "metadata": {}, "source": [ "We apply the flags using the \"row\" keyword, and see that the RFI is removed, along with a drop in the exposure time to 112 seconds instead of the original 150." ] }, { "cell_type": "code", "execution_count": 19, "id": "efe82013", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Exposure: 112.15101951854204 s\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "f21e85f6b8734964af0070ea08edb854", "version_major": 2, "version_minor": 0 }, "text/plain": [ "VBox(children=(HBox(children=(Button(description='Clear All Regions', style=ButtonStyle(), tooltip='Clear all …" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "sdfits.flag(row=flag_rows)\n", "\n", "\n", "ps = sdfits.getps(plnum=0, ifnum=0, fdnum=0).timeaverage()\n", "print(f\"Exposure: {ps.meta['EXPOSURE']} s\")\n", "\n", "ps.plot();" ] }, { "cell_type": "markdown", "id": "abc66330-e709-464e-b48d-c3c646e58c56", "metadata": {}, "source": [ "## Flags vs. Masks\n", "\n", "A few words on flagging vs. masking. Flagging sets the rule.\n", "``apply_flags`` or calibrating with ``apply_flags=True`` (the default) sets the data mask.\n", "By default ``GBTFITSLoad`` will not read flag files. The keywords ``skipflags=`` and ``flag_vegas=`` control which flags are applied. ``flag_vegas`` can also be given as a parameter to any calibration routine, as below with ``gettp``.\n", "\n", "\n", "For a given spectrum the `stats` function\n", "reports the number of \"nan\", which should be the number of channels that were masked as a result of flagging.\n", "\n", "**Note:** If you change the ``Spectrum.mask`` attribute, it will be reflected in the plot, but *not* in the flags of the ``Spectrum`` if you write it out. \n", "Such a mask change should be considered temporary; to correctly change both the mask and the flag, use a flagging operation." ] }, { "cell_type": "code", "execution_count": 4, "id": "a246c300-707b-469d-ba2e-090a84c75cf7", "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "12:14:06.506 I Loaded 2 FITS files\n", "12:14:06.508 I Index loaded from .index file (44/93 columns). Missing columns (TCAL, WCS, calibration metadata, etc.) will be automatically loaded from FITS file when first accessed.\n", "12:14:06.838 I Using TSYS column\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "3bb4b8f3a359444d9de4bf230a7ecce0", "version_major": 2, "version_minor": 0 }, "text/plain": [ "VBox(children=(HBox(children=(Button(description='Clear All Regions', style=ButtonStyle(), tooltip='Clear all …" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "sdf1 = GBTFITSLoad(dysh_data(test=\"AGBT22A_325_15\"))\n", "sp1 = sdf1.gettp(scan=281, ifnum=0, plnum=0, fdnum=8, flag_vegas=True).timeaverage()\n", "sp1.plot();" ] }, { "cell_type": "markdown", "id": "a12a6eaa-c8af-4e53-ac2d-d73d8167b505", "metadata": {}, "source": [ "Looking carefully in this plot, you will see numerous \"gaps\" in the spectrum, where the so-called [VEGAS spurs](https://dysh.readthedocs.io/en/latest/reference/glossary.html#term-VEGAS-spurs) were automatically flagged. \n", "Using the ``stats`` function you will see there are 31 in this spectrum of 1024 channels. \n", "These are \"nan\" values in the spectrum, and the ``sp1.mask`` array has been set appropriately.\n", "\n", "In the corresponding AGBT22A_325_15.raw.vegas.A.flag file you will see the following:\n", "\n", "```\n", "[header]\n", "created = Tue Aug 20 09:38:32 2024\n", "version = 1.0\n", "created_by = sdfits\n", "[flags]\n", "#RECNUM,SCAN,INTNUM,PLNUM,IFNUM,FDNUM,BCHAN,ECHAN,IDSTRING\n", "*|281|*|*|0|8|0,32,64,96,128,160,192,224,256,288,320,352,384,416,448,480,544,576,608,640,672,704,736,768,800,832,864,896,928,960,992|0,32,64,96,128,160,192,224,256,288,320,352,384,416,448,480,544,576,608,640,672,704,736,768,800,832,864,896,928,960,992|VEGAS_SPUR\n", "*|281|*|*|0|10|0,32,64,96,128,160,192,224,256,288,320,352,384,416,448,480,544,576,608,640,672,704,736,768,800,832,864,896,928,960,992|0,32,64,96,128,160,192,224,256,288,320,352,384,416,448,480,544,576,608,640,672,704,736,768,800,832,864,896,928,960,992|VEGAS_SPUR\n", "\n", "\n", "```\n", "\n" ] }, { "cell_type": "code", "execution_count": 5, "id": "c667850a-6c48-464c-8a7d-b344694d9b8e", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "{'mean': ,\n", " 'median': ,\n", " 'rms': ,\n", " 'min': ,\n", " 'max': ,\n", " 'npt': 1024,\n", " 'nan': np.int64(31)}" ] }, "execution_count": 5, "metadata": {}, "output_type": "execute_result" } ], "source": [ "sp1.stats()" ] }, { "cell_type": "markdown", "id": "def3ee66-70eb-41ee-91bc-87d30602b6f5", "metadata": {}, "source": [ "Repeating this while ignoring all the flags (``apply_flags=False``) will show a contiguous spectrum and no masked channels." ] }, { "cell_type": "code", "execution_count": 6, "id": "229ec5bc-9e91-4660-8f52-f2cd9c20b747", "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "12:14:12.364 I Using TSYS column\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "f7493519ffbe481bad0c73160d463807", "version_major": 2, "version_minor": 0 }, "text/plain": [ "VBox(children=(HBox(children=(Button(description='Clear All Regions', style=ButtonStyle(), tooltip='Clear all …" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/plain": [ "{'mean': ,\n", " 'median': ,\n", " 'rms': ,\n", " 'min': ,\n", " 'max': ,\n", " 'npt': 1024,\n", " 'nan': np.int64(0)}" ] }, "execution_count": 6, "metadata": {}, "output_type": "execute_result" } ], "source": [ "sp2 = sdf1.gettp(scan=281, ifnum=0, plnum=0, fdnum=8, apply_flags=False).timeaverage()\n", "sp2.plot()\n", "sp2.stats()" ] }, { "cell_type": "markdown", "id": "5bdcd5b2-c213-4619-b0f3-9e213d0fae68", "metadata": {}, "source": [ "## Final Stats\n", "\n", "Finally, at the end we compute some statistics over a spectrum, merely as a checksum if the notebook is reproducible.\n", "\n" ] }, { "cell_type": "code", "execution_count": 23, "id": "69f4a41e-7519-4463-b38f-b69824b8cc46", "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "12:13:05.727 I rms is OK (no unit was given, assumed K)\n" ] } ], "source": [ "ps.check_stats(0.02860246)" ] }, { "cell_type": "code", "execution_count": null, "id": "738fef17-e81c-4c43-b39a-01fb2a3728d1", "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.12.13" }, "widgets": { "application/vnd.jupyter.widget-state+json": { "state": {}, "version_major": 2, "version_minor": 0 } } }, "nbformat": 4, "nbformat_minor": 5 }