From 4fbf731ecda94d99154f4c6cef197bb08caf270e Mon Sep 17 00:00:00 2001 From: astrofle Date: Mon, 16 Sep 2024 21:54:39 -0400 Subject: [PATCH 01/95] Add: custom colors to css --- docs/source/_static/css/custom.css | 104 ++++++++++++++++++++++++++--- 1 file changed, 94 insertions(+), 10 deletions(-) diff --git a/docs/source/_static/css/custom.css b/docs/source/_static/css/custom.css index 15a41eca..961ef3bc 100644 --- a/docs/source/_static/css/custom.css +++ b/docs/source/_static/css/custom.css @@ -1,11 +1,95 @@ /* Remove width restriction on content so that diagrams - are more visible */ - .wy-nav-content { - max-width: none; - } - - /* Override the logo/searchbar background color; - it conflicts with the logo color */ - .wy-side-nav-search { - background-color: #C6B9D2; - } +are more visible */ +.wy-nav-content { + max-width: none; +} + +/* Override the logo/searchbar background color; + it conflicts with the logo color */ +.wy-side-nav-search { + background-color: #C6B9D2; +} + +.black { + color: black; +} + +.gray { + color: gray; +} + +.grey { + color: gray; +} + +.silver { + color: silver; +} + +.white { + color: white; +} + +.maroon { + color: maroon; +} + +.red { + color: red; +} + +.magenta { + color: magenta; +} + +.fuchsia { + color: fuchsia; +} + +.pink { + color: pink; +} + +.orange { + color: orange; +} + +.yellow { + color: yellow; +} + +.lime { + color: lime; +} + +.green { + color: green; +} + +.olive { + color: olive; +} + +.teal { + color: teal; +} + +.cyan { + color: cyan; +} + +.aqua { + color: aqua; +} + +.blue { + color: blue; +} + +.navy { + color: navy; +} + +.purple { + color: purple; +} From 39df7d6498af84b2d950484630ea159f738eef97 Mon Sep 17 00:00:00 2001 From: astrofle Date: Mon, 16 Sep 2024 21:55:15 -0400 Subject: [PATCH 02/95] Add: grid for documentation sections --- docs/source/index.rst | 83 +++++++++++++++++++++++++++++++++++++++---- 1 file changed, 77 insertions(+), 6 deletions(-) diff --git a/docs/source/index.rst b/docs/source/index.rst index f3841dac..873b6e8a 100644 --- a/docs/source/index.rst +++ b/docs/source/index.rst @@ -11,8 +11,85 @@ It is intended to replace `GBTIDL Date: Mon, 16 Sep 2024 21:59:06 -0400 Subject: [PATCH 03/95] Add: sphinx-design extension --- docs/source/conf.py | 1 + 1 file changed, 1 insertion(+) diff --git a/docs/source/conf.py b/docs/source/conf.py index f53bf87e..fda6e5c9 100644 --- a/docs/source/conf.py +++ b/docs/source/conf.py @@ -58,6 +58,7 @@ "sphinxcontrib.mermaid", "numpydoc", "sphinx_inline_tabs", + "sphinx_design", ] numpydoc_show_class_members = True From ed500154b3a10a84a2cefe350a2473247bea2a22 Mon Sep 17 00:00:00 2001 From: astrofle Date: Mon, 16 Sep 2024 22:01:49 -0400 Subject: [PATCH 04/95] Add: sphinx-design extension --- requirements.txt | 1 + 1 file changed, 1 insertion(+) diff --git a/requirements.txt b/requirements.txt index ed124203..2b62c49e 100644 --- a/requirements.txt +++ b/requirements.txt @@ -525,6 +525,7 @@ sphinx-autobuild==2021.3.14 # via dysh (pyproject.toml) sphinx-book-theme==1.1.3 # via dysh (pyproject.toml) +sphinx-design==0.6.0 sphinx-inline-tabs==2023.4.21 # via dysh (pyproject.toml) sphinxcontrib-applehelp==1.0.7 From 6932fdbf0181ec454ba06a821c4a20cdc2c3ce0a Mon Sep 17 00:00:00 2001 From: astrofle Date: Mon, 16 Sep 2024 22:03:37 -0400 Subject: [PATCH 05/95] Add: sphinx-design extension --- pyproject.toml | 1 + 1 file changed, 1 insertion(+) diff --git a/pyproject.toml b/pyproject.toml index 8bda1dc5..4b7def3a 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -50,6 +50,7 @@ dev = [ "sphinx-autobuild", "sphinx-inline-tabs", "sphinx-book-theme", + "sphinx-design", "sphinxcontrib-mermaid", "nbformat", "nbclient", From 65df2fe867b89f142cb4983826f54a84bc6247d9 Mon Sep 17 00:00:00 2001 From: astrofle Date: Tue, 17 Sep 2024 11:55:57 -0400 Subject: [PATCH 06/95] Updates: structure for reference material --- docs/source/getting_started/install.rst | 38 ----------- docs/source/modules/index.rst | 11 ---- .../{ => reference}/modules/dysh.fits.rst | 0 .../{ => reference}/modules/dysh.plot.rst | 0 .../{ => reference}/modules/dysh.spectra.rst | 0 .../{ => reference}/modules/dysh.util.rst | 0 docs/source/reference/modules/index.rst | 65 +++++++++++++++++++ 7 files changed, 65 insertions(+), 49 deletions(-) delete mode 100644 docs/source/getting_started/install.rst delete mode 100644 docs/source/modules/index.rst rename docs/source/{ => reference}/modules/dysh.fits.rst (100%) rename docs/source/{ => reference}/modules/dysh.plot.rst (100%) rename docs/source/{ => reference}/modules/dysh.spectra.rst (100%) rename docs/source/{ => reference}/modules/dysh.util.rst (100%) create mode 100644 docs/source/reference/modules/index.rst diff --git a/docs/source/getting_started/install.rst b/docs/source/getting_started/install.rst deleted file mode 100644 index 077407f1..00000000 --- a/docs/source/getting_started/install.rst +++ /dev/null @@ -1,38 +0,0 @@ -******************* -Installing ``dysh`` -******************* - -``dysh`` requires Python 3.9+ and recent versions of -`astropy `_, -`numpy `_, -`scipy `_, -`pandas `_, -`specutils `_, and -`matplotlib `_. - -With `pip` from PyPi -==================== - -``dysh`` is most easily installed with ``pip``, which will take care of -any dependencies. The packaged code is hosted at the `Python Packaging -Index `_. - -.. code:: - - $ pip install dysh - -.. warning:: - `dysh` is currently in development and the above command will install the latest stable version of `dysh` which might not reflect the contents of the documentation. For beta testing please see :ref:`beta-install`. - -From github -=========== - -To install from github without creating a separate virtual environment: - -.. code:: - - $ git clone git@github.com:GreenBankObservatory/dysh.git - $ cd dysh - $ pip install -e . - -If you wish to install using a virtual environment, which we strongly recommend if you plan to contribute to the code, see :doc:`installation instructions for developers <../for_developers/install>`. diff --git a/docs/source/modules/index.rst b/docs/source/modules/index.rst deleted file mode 100644 index f2ea3fc3..00000000 --- a/docs/source/modules/index.rst +++ /dev/null @@ -1,11 +0,0 @@ -**************** -Modules and APIs -**************** - -.. toctree:: - :maxdepth: 2 - - dysh.fits - dysh.spectra - dysh.plot - dysh.util diff --git a/docs/source/modules/dysh.fits.rst b/docs/source/reference/modules/dysh.fits.rst similarity index 100% rename from docs/source/modules/dysh.fits.rst rename to docs/source/reference/modules/dysh.fits.rst diff --git a/docs/source/modules/dysh.plot.rst b/docs/source/reference/modules/dysh.plot.rst similarity index 100% rename from docs/source/modules/dysh.plot.rst rename to docs/source/reference/modules/dysh.plot.rst diff --git a/docs/source/modules/dysh.spectra.rst b/docs/source/reference/modules/dysh.spectra.rst similarity index 100% rename from docs/source/modules/dysh.spectra.rst rename to docs/source/reference/modules/dysh.spectra.rst diff --git a/docs/source/modules/dysh.util.rst b/docs/source/reference/modules/dysh.util.rst similarity index 100% rename from docs/source/modules/dysh.util.rst rename to docs/source/reference/modules/dysh.util.rst diff --git a/docs/source/reference/modules/index.rst b/docs/source/reference/modules/index.rst new file mode 100644 index 00000000..1d295cd2 --- /dev/null +++ b/docs/source/reference/modules/index.rst @@ -0,0 +1,65 @@ +**************** +Modules and APIs +**************** + +.. grid:: 1 2 2 2 + + .. grid-item-card:: + :shadow: md + :margin: 2 2 0 0 + + **fits** + + .. button-link:: dysh.fits.html + :color: primary + :outline: + :click-parent: + + Go to dysh.fits + + .. grid-item-card:: + :shadow: md + :margin: 2 2 0 0 + + **spectra** + + .. button-link:: dysh.spectra.html + :color: primary + :outline: + :click-parent: + + Go to dysh.spectra + + .. grid-item-card:: + :shadow: md + :margin: 2 2 0 0 + + **plot** + + .. button-link:: dysh.plot.html + :color: primary + :outline: + :click-parent: + + Go to dysh.spectra + + .. grid-item-card:: + :shadow: md + :margin: 2 2 0 0 + + **util** + + .. button-link:: dysh.util.html + :color: primary + :outline: + :click-parent: + + Go to dysh.util + +.. toctree:: + :maxdepth: 2 + :hidden: + dysh.fits + dysh.spectra + dysh.plot + dysh.util From 58b437474854f5b9fa4b7f9a901436103ffa8a7e Mon Sep 17 00:00:00 2001 From: astrofle Date: Tue, 17 Sep 2024 11:56:41 -0400 Subject: [PATCH 07/95] Updates: getting started documentation --- docs/source/getting_started/index.rst | 40 +++++++++++++++++++++++---- 1 file changed, 35 insertions(+), 5 deletions(-) diff --git a/docs/source/getting_started/index.rst b/docs/source/getting_started/index.rst index da8e5312..d54ff516 100644 --- a/docs/source/getting_started/index.rst +++ b/docs/source/getting_started/index.rst @@ -2,10 +2,40 @@ Getting Started *************** -Here's how you get started +Installing ``dysh`` +=================== -.. toctree:: - :maxdepth: 2 +``dysh`` requires Python 3.9+ and recent versions of +`astropy `_, +`numpy `_, +`scipy `_, +`pandas `_, +`specutils `_, and +`matplotlib `_. - install - tutorials/index +We strongly recommend the use of a virtual environment for installing `dysh`. + +With `pip` from PyPi +-------------------- + +``dysh`` is most easily installed with ``pip``, which will take care of +any dependencies. The packaged code is hosted at the `Python Packaging +Index `_. + +.. code:: + + $ pip install dysh + +.. warning:: + `dysh` is currently in development and the above command will install the latest stable version of `dysh` which might not reflect the contents of the documentation. + For beta testing please see :ref:`beta-install`. + +From GitHub +----------- + +Installing from GitHub will allow you to install the latest, albeit unstable, version of `dysh`. +To install the main branch of `dysh` with all extra dependencies from GitHub: + +.. code:: + + $ pip install "dysh[all] @ git+https://github.com/GreenBankObservatory/dysh" From 0b0160be74a0ba0a8d6a2604e27b5206220e7799 Mon Sep 17 00:00:00 2001 From: astrofle Date: Tue, 17 Sep 2024 11:59:45 -0400 Subject: [PATCH 08/95] Updates: table of contents order --- docs/source/index.rst | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/docs/source/index.rst b/docs/source/index.rst index 873b6e8a..3af0abab 100644 --- a/docs/source/index.rst +++ b/docs/source/index.rst @@ -92,10 +92,10 @@ Contents :hidden: whatsnew/0.3.rst - background/index getting_started/index + background/index examples/index - modules/index + reference/index for_beta_testers/index for_developers/index From f5909b0d624ecf5b9e2f7915c2a6bee4e6cb67d6 Mon Sep 17 00:00:00 2001 From: astrofle Date: Tue, 17 Sep 2024 12:03:51 -0400 Subject: [PATCH 09/95] Moved: sdfits file documentation to reference material --- docs/source/index.rst | 1 - .../source/{background => reference}/sdfits_files/gbt_sdfits.rst | 0 docs/source/{background => reference}/sdfits_files/index.rst | 0 3 files changed, 1 deletion(-) rename docs/source/{background => reference}/sdfits_files/gbt_sdfits.rst (100%) rename docs/source/{background => reference}/sdfits_files/index.rst (100%) diff --git a/docs/source/index.rst b/docs/source/index.rst index 3af0abab..653ad75c 100644 --- a/docs/source/index.rst +++ b/docs/source/index.rst @@ -93,7 +93,6 @@ Contents whatsnew/0.3.rst getting_started/index - background/index examples/index reference/index for_beta_testers/index diff --git a/docs/source/background/sdfits_files/gbt_sdfits.rst b/docs/source/reference/sdfits_files/gbt_sdfits.rst similarity index 100% rename from docs/source/background/sdfits_files/gbt_sdfits.rst rename to docs/source/reference/sdfits_files/gbt_sdfits.rst diff --git a/docs/source/background/sdfits_files/index.rst b/docs/source/reference/sdfits_files/index.rst similarity index 100% rename from docs/source/background/sdfits_files/index.rst rename to docs/source/reference/sdfits_files/index.rst From 6970c3d0f6085357b64f84ef7fe9b19f7b439916 Mon Sep 17 00:00:00 2001 From: astrofle Date: Tue, 17 Sep 2024 12:43:56 -0400 Subject: [PATCH 10/95] Add: section headings for tables --- .../reference/sdfits_files/gbt_sdfits.rst | 17 +++++++++++++---- 1 file changed, 13 insertions(+), 4 deletions(-) diff --git a/docs/source/reference/sdfits_files/gbt_sdfits.rst b/docs/source/reference/sdfits_files/gbt_sdfits.rst index 32694006..4118b1aa 100644 --- a/docs/source/reference/sdfits_files/gbt_sdfits.rst +++ b/docs/source/reference/sdfits_files/gbt_sdfits.rst @@ -9,7 +9,10 @@ The single-dish FITS (SDFITS) convention is used for observer-facing GBT data. T HDU 0 (PRIMARY) --------------- -.. list-table:: Header +Header +^^^^^^ + +.. list-table:: :widths: 25 25 50 :header-rows: 1 @@ -38,7 +41,10 @@ HDU 0 (PRIMARY) HDU 1 (SINGLE DISH) ------------------- -.. list-table:: Header +Header +^^^^^^ + +.. list-table:: :widths: 25 25 50 :header-rows: 1 @@ -91,7 +97,10 @@ HDU 1 (SINGLE DISH) - "SINGLE DISH" - The name of this binary table extension -.. list-table:: Data +Data +^^^^ + +.. list-table:: :widths: 20 20 20 40 :header-rows: 1 @@ -630,4 +639,4 @@ Flag files indicate the data that should be ignored. For example, these flags ca Other Resources =============== -The full SDFITS documentation for GBO can be found here: `The GBT SDFITS Project Wiki `_ +The full SDFITS documentation for GBO can be found on `the GBT SDFITS Project Wiki `_. However, this page is out of date and requires a login to view. From 65ccbff1cd68f7d627269c8f6a95e584e19a8d06 Mon Sep 17 00:00:00 2001 From: astrofle Date: Tue, 17 Sep 2024 12:52:04 -0400 Subject: [PATCH 11/95] Add: reference documentation for coordinates module --- docs/source/reference/modules/dysh.coordinates.rst | 14 ++++++++++++++ 1 file changed, 14 insertions(+) create mode 100644 docs/source/reference/modules/dysh.coordinates.rst diff --git a/docs/source/reference/modules/dysh.coordinates.rst b/docs/source/reference/modules/dysh.coordinates.rst new file mode 100644 index 00000000..37389e18 --- /dev/null +++ b/docs/source/reference/modules/dysh.coordinates.rst @@ -0,0 +1,14 @@ +Spatial and Velocity Coordinates and Reference Frames +===================================================== + +.. automodule:: dysh.coordinates + :members: + :undoc-members: + :show-inheritance: + +Core Functions and Classes +-------------------------- +.. automodule:: dysh.coordinates.core + :members: + :undoc-members: + :show-inheritance: From 9cb8886d758958b98c4ea341f779b4c9b9e3daa0 Mon Sep 17 00:00:00 2001 From: astrofle Date: Tue, 17 Sep 2024 13:03:21 -0400 Subject: [PATCH 12/95] Add: coordinates module to reference material index --- docs/source/reference/modules/index.rst | 14 ++++++++++++++ 1 file changed, 14 insertions(+) diff --git a/docs/source/reference/modules/index.rst b/docs/source/reference/modules/index.rst index 1d295cd2..eb36da62 100644 --- a/docs/source/reference/modules/index.rst +++ b/docs/source/reference/modules/index.rst @@ -43,6 +43,19 @@ Modules and APIs Go to dysh.spectra + .. grid-item-card:: + :shadow: md + :margin: 2 2 0 0 + + **coordinates** + + .. button-link:: dysh.coordinates.html + :color: primary + :outline: + :click-parent: + + Go to dysh.coordinates + .. grid-item-card:: :shadow: md :margin: 2 2 0 0 @@ -62,4 +75,5 @@ Modules and APIs dysh.fits dysh.spectra dysh.plot + dysh.coordinates dysh.util From 2d57ed5c2e7b62d67cf03ce3cd01b5682007677d Mon Sep 17 00:00:00 2001 From: astrofle Date: Tue, 17 Sep 2024 13:31:01 -0400 Subject: [PATCH 13/95] Add: tutorial section for documentation with position switch tutorial --- docs/source/index.rst | 1 + docs/source/tutorials/index.rst | 27 + .../source/tutorials/psw/positionswitch.ipynb | 940 ++++++++++++++++++ 3 files changed, 968 insertions(+) create mode 100644 docs/source/tutorials/index.rst create mode 100644 docs/source/tutorials/psw/positionswitch.ipynb diff --git a/docs/source/index.rst b/docs/source/index.rst index 653ad75c..8240cd7e 100644 --- a/docs/source/index.rst +++ b/docs/source/index.rst @@ -93,6 +93,7 @@ Contents whatsnew/0.3.rst getting_started/index + tutorials/index examples/index reference/index for_beta_testers/index diff --git a/docs/source/tutorials/index.rst b/docs/source/tutorials/index.rst new file mode 100644 index 00000000..0e0b15c7 --- /dev/null +++ b/docs/source/tutorials/index.rst @@ -0,0 +1,27 @@ +.. _tutorials: + + +############################################ +:octicon:`mortar-board;2em;orange` Tutorials +############################################ + +Learning-oriented lessons take you through a series of steps to complete a project. +Most useful when you want to get started reducing your data. + + +.. card-carousel:: 2 + + .. card:: Position Switched (psw) Data + :link: psw/positionswitch.html + + - Calibrate the data. + + + Keys: *L-Band*, *psw* + + +.. toctree:: + :maxdepth: 4 + :hidden: + + psw/positionswitch diff --git a/docs/source/tutorials/psw/positionswitch.ipynb b/docs/source/tutorials/psw/positionswitch.ipynb new file mode 100644 index 00000000..96c909af --- /dev/null +++ b/docs/source/tutorials/psw/positionswitch.ipynb @@ -0,0 +1,940 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "8c8138ef-e687-444e-95b1-9797654f3f62", + "metadata": {}, + "source": [ + "# Position-Switched Data Reduction\n", + "----------------------------------\n", + "\n", + "This notebook shows how to use `dysh` to calibrate an OnOff observation.\n", + "It retrieves and calibrates position-switch scans using `GBTFITSLoad.getps()`, which returns a `ScanBlock` object. OffOn observations can be reduced the same way." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "b4967550-2ca1-4931-b53b-6f9868718490", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [ + "import" + ] + }, + "outputs": [], + "source": [ + "from pathlib import Path\n", + "import astropy.units as u\n", + "from dysh.util.download import from_url\n", + "from dysh.fits.gbtfitsload import GBTFITSLoad" + ] + }, + { + "cell_type": "markdown", + "id": "87669763-8d96-4521-9e81-f69d7213e133", + "metadata": {}, + "source": [ + "## Data Retrieval\n", + "\n", + "Download the example SDFITS data, if necessary." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "6bc88bc5-986d-4eae-b1c7-6398cc9ddd5a", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [ + "wget" + ] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Starting download...\n", + "AGBT05B_047_01.raw.acs.fits already downloaded at /home/sandboxes/psalas/Dysh/dysh/notebooks/examples/data\n" + ] + } + ], + "source": [ + "url = \"http://www.gb.nrao.edu/dysh/example_data/positionswitch/data/AGBT05B_047_01/AGBT05B_047_01.raw.acs/AGBT05B_047_01.raw.acs.fits\"\n", + "savepath = Path.cwd() / \"data\"\n", + "filename = from_url(url, savepath)" + ] + }, + { + "cell_type": "markdown", + "id": "e0bf5028-e5b2-43c3-9a0c-6416dc02e2ec", + "metadata": {}, + "source": [ + "## Data Loading\n", + "\n", + "Next, we use `GBTFITSLoad` to load the data, and then its `summary` method to inspect its contents." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "93a62e3a-c95d-475b-8602-b5b8b7934733", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [ + "load" + ] + }, + "outputs": [], + "source": [ + "sdfits = GBTFITSLoad(filename)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "90d482e1-3953-49da-9be6-49605ae9cf64", + "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", + " \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", + " \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", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
SCANOBJECTVELOCITYPROCPROCSEQNRESTFREQDOPFREQ# IF# POL# INT# FEEDAZIMUTHELEVATIO
051NGC52914386.0OnOff11.4204051.42040512111198.34311218.64274
152NGC52914386.0OnOff21.4204051.42040512111198.93057118.787219
253NGC52914386.0OnOff11.4204051.42040512111199.33049118.356075
354NGC52914386.0OnOff21.4204051.42040512111199.91572518.492742
455NGC52914386.0OnOff11.4204051.42040512111200.30423718.057533
556NGC52914386.0OnOff21.4204051.42040512111200.89060318.186034
657NGC52914386.0OnOff11.4204051.42040512111202.32754817.385267
758NGC52914386.0OnOff21.4204051.42040512111202.91916117.494902
\n", + "
" + ], + "text/plain": [ + " SCAN OBJECT VELOCITY PROC PROCSEQN RESTFREQ DOPFREQ # IF # POL \\\n", + "0 51 NGC5291 4386.0 OnOff 1 1.420405 1.420405 1 2 \n", + "1 52 NGC5291 4386.0 OnOff 2 1.420405 1.420405 1 2 \n", + "2 53 NGC5291 4386.0 OnOff 1 1.420405 1.420405 1 2 \n", + "3 54 NGC5291 4386.0 OnOff 2 1.420405 1.420405 1 2 \n", + "4 55 NGC5291 4386.0 OnOff 1 1.420405 1.420405 1 2 \n", + "5 56 NGC5291 4386.0 OnOff 2 1.420405 1.420405 1 2 \n", + "6 57 NGC5291 4386.0 OnOff 1 1.420405 1.420405 1 2 \n", + "7 58 NGC5291 4386.0 OnOff 2 1.420405 1.420405 1 2 \n", + "\n", + " # INT # FEED AZIMUTH ELEVATIO \n", + "0 11 1 198.343112 18.64274 \n", + "1 11 1 198.930571 18.787219 \n", + "2 11 1 199.330491 18.356075 \n", + "3 11 1 199.915725 18.492742 \n", + "4 11 1 200.304237 18.057533 \n", + "5 11 1 200.890603 18.186034 \n", + "6 11 1 202.327548 17.385267 \n", + "7 11 1 202.919161 17.494902 " + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "sdfits.summary()" + ] + }, + { + "cell_type": "markdown", + "id": "e84c5009-96f4-489d-bc9d-89de390d53c9", + "metadata": {}, + "source": [ + "## Data Reduction\n", + "\n", + "### Single Scan\n", + "\n", + "Next we calibrate one scan of the position switched observations. We will start with scan 51, a single spectral window and polarization.\n", + "\n", + "If you don't want to calibrate, add, `calibrate=False`." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "684126da-97d4-4afb-8625-43160340cab1", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [ + "getps", + "test" + ] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " ID TAG OBJECT BANDWID DATE-OBS DURATION EXPOSURE TSYS TDIM7 TUNIT7 CTYPE1 CRVAL1 CRPIX1 CDELT1 CTYPE2 ... IFNUM PLNUM FDNUM INT INTNUM NSAVE HDU BINTABLE ROW PROC _OBSTYPE _SUBOBSMODE CHAN UTC # SELECTED\n", + "--- --- ------ ------- -------- -------- -------- ---- ----- ------ ------ ------ ------ ------ ------ ... ----- ----- ----- --- ------ ----- --- -------- --- ---- -------- ----------- ---- --- ----------\n", + " ID TAG SCAN IFNUM PLNUM # SELECTED\n", + "--- --------- -------- ----- ----- ----------\n", + " 0 76f386e98 [51, 52] 0 0 44\n" + ] + } + ], + "source": [ + "ps_scan_block = sdfits.getps(scan=51, ifnum=0, plnum=0)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "5deaae0c-e70b-4758-ae10-f11c6f66cc3b", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [ + "print_tsys", + "test" + ] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "T_sys = 19.36\n" + ] + } + ], + "source": [ + "print(f\"T_sys = {ps_scan_block[0].tsys.mean():.2f}\")" + ] + }, + { + "cell_type": "markdown", + "id": "b25c2499-a8c1-434a-b75e-d3bf25e223e7", + "metadata": {}, + "source": [ + "#### Time Averaging\n", + "\n", + "To time average the contents of a `ScanBlock` use its `timeaverage` method. Be aware that time averging will not check if the source is the same. \n", + "\n", + "By default time averaging uses the following weights: \n", + "$$\n", + "\\frac{T^{2}_{sys}}{\\Delta\\nu\\Delta t}\n", + "$$\n", + "with $T_{sys}$ the system temperature, $\\Delta\\nu$ the channel width and $\\Delta t$ the integration time. In `dysh` these are set using `weights='tsys'` (the default)." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "e0a33c19-576b-46e8-9a57-f34b8f85f6aa", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [ + "timeaverage", + "test" + ] + }, + "outputs": [], + "source": [ + "ta = ps_scan_block.timeaverage(weights='tsys')" + ] + }, + { + "cell_type": "markdown", + "id": "38898654-c1da-4a02-91d2-b4f488f18af7", + "metadata": {}, + "source": [ + "#### Plotting\n", + "\n", + "Plot the data and use different units for the spectral axis." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "40747f0b-d63d-45fa-8910-fef56fe5c751", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [ + "plot1", + "test" + ] + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "ta.plot()" + ] + }, + { + "cell_type": "markdown", + "id": "d83e0206-a79f-44c7-bd2b-a45516720e75", + "metadata": {}, + "source": [ + "Change the spectral axis units to km/s and the y-axis to mK, while also showing the spectra between 3600 and 5300 km/s, with the y-axis range between -100 and 1000 mK." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "6c07cf19-3a5d-47a9-9a10-ccd9f305efb9", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [ + "plot2", + "test" + ] + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "ta.plot(xaxis_unit=\"km/s\", yaxis_unit=\"mK\", ymin=-100, ymax=1000, xmin=3600, xmax=5300)" + ] + }, + { + "cell_type": "markdown", + "id": "1fa13098-104d-42f8-bf16-11d8b46ed0b9", + "metadata": {}, + "source": [ + "Switch back to GHz as the spectral axis unit." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "5fa6773c-b8e1-45ee-867c-b044df994f91", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "ta.plot(xaxis_unit=\"GHz\", ymin=-100, ymax=1000, yaxis_unit=\"mK\")" + ] + }, + { + "cell_type": "markdown", + "id": "0988ba2f-7ed0-4386-b4a5-7635537b8c5f", + "metadata": {}, + "source": [ + "#### Baseline Subtraction\n", + "The following code cells show how to subtract a polynomial baseline from the data. This example uses an order 2 polynomial, and excludes the regions between 3800 and 5000 km/s, where a line is detected. The use of `remove=True` will remove the best fit baseline model from the spectrum.\n", + "\n", + "\n", + "For a polynomial model one may need to normalize the frequency axis in channel space using `normalize=True`, to prevent poorly conditioned fits, but this will not allow you to undo the fit." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "d4c4526b-2e78-4f0f-85ff-0a4e3694a1e5", + "metadata": { + "editable": true, + "scrolled": true, + "slideshow": { + "slide_type": "" + }, + "tags": [ + "baseline", + "test" + ] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "EXCLUDING [Spectral Region, 1 sub-regions:\n", + " (1397103816.4779327 Hz, 1402626103.134255 Hz) \n", + "]\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "WARNING: The fit may be poorly conditioned\n", + " [astropy.modeling.fitting]\n" + ] + } + ], + "source": [ + "kms = u.km/u.s\n", + "ta.baseline(model=\"poly\", degree=2, exclude=[3800*kms,5000*kms], remove=True)" + ] + }, + { + "cell_type": "markdown", + "id": "5ac09df0-0025-4bef-a779-b9896f5232fd", + "metadata": {}, + "source": [ + "When we plot the spectrum again, it has been baseline subtracted." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "43a07117-7088-43e5-927c-0c7ead1eb4fd", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "ta.plot(xaxis_unit=\"km/s\", yaxis_unit=\"mK\", ymin=-500, ymax=500)" + ] + }, + { + "cell_type": "markdown", + "id": "57f451bc-f27e-4e69-a735-009fedaf68f1", + "metadata": {}, + "source": [ + "We can inspect the best fit baseline coefficients." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "219e21a8-91cb-405e-82fc-249143c219ae", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [ + "test" + ] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Model: Polynomial1D\n", + "Inputs: ('x',)\n", + "Outputs: ('y',)\n", + "Model set size: 1\n", + "Degree: 2\n", + "Parameters:\n", + " c0 c1 c2 \n", + " K K / Hz K / Hz2 \n", + " ------------------ ---------------------- --------------------\n", + " 1.6463452183080192 -9.793516886548451e-10 -7.1325412756222e-37\n" + ] + } + ], + "source": [ + "print(ta.baseline_model)" + ] + }, + { + "cell_type": "markdown", + "id": "01f5ca58-05ad-4124-8527-40ab2cd073fa", + "metadata": {}, + "source": [ + "And save the figure." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "3a7e4887-ba55-447a-9274-8275e9896d39", + "metadata": {}, + "outputs": [], + "source": [ + "output_dir = Path.cwd() / \"output\"\n", + "ta.savefig(output_dir / \"baselined_removed.png\")" + ] + }, + { + "cell_type": "markdown", + "id": "4b17e8e8-e39a-4934-8cf5-94342b3fbe44", + "metadata": {}, + "source": [ + "---" + ] + }, + { + "cell_type": "markdown", + "id": "3462f31f-f69e-48db-96f5-33f4071a384b", + "metadata": {}, + "source": [ + "#### Using Selection\n", + "\n", + "The following code shows how to calibrate scan 51 using selection. At this time selection does not know about signal and reference scan pairs, so the selection must include both scans, otherwise the calibration will fail." + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "1786d5c3-3701-4199-b4a3-80a14dc92f5b", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " ID TAG SCAN IFNUM # SELECTED\n", + "--- --------- -------- ----- ----------\n", + " 0 2c4cf7b1b [51, 52] 0 88\n" + ] + } + ], + "source": [ + "sdfits.select(scan=[51,52], ifnum=0)\n", + "sdfits.selection.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "56e22004-a5cd-4064-a1eb-edaf6afe88f4", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " ID TAG SCAN IFNUM # SELECTED\n", + "--- --------- -------- ----- ----------\n", + " 0 2c4cf7b1b [51, 52] 0 88\n", + " ID TAG SCAN IFNUM PLNUM # SELECTED\n", + "--- --------- -------- ----- ----- ----------\n", + " 0 2c4cf7b1b [51, 52] 0 88\n", + " 1 4a182f785 [51, 52] [0] 0 44\n" + ] + } + ], + "source": [ + "sb = sdfits.getps(plnum=0)" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "4281fdea-ab00-47e5-aca0-cc23b43224a7", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "ta2 = sb.timeaverage(weights='tsys')\n", + "ta2.plot(xaxis_unit=\"GHz\", ymin=-100, ymax=800, yaxis_unit=\"mK\", title=\"PLNUM=0\")" + ] + }, + { + "cell_type": "markdown", + "id": "e7a4ef5f-2bf3-4bfc-8177-8a7ad793b014", + "metadata": {}, + "source": [ + "We can calibrate the other polarization, with the scan numbers already selected." + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "6a1bff52-fc5c-437e-9da0-787f17029b77", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " ID TAG SCAN IFNUM # SELECTED\n", + "--- --------- -------- ----- ----------\n", + " 0 2c4cf7b1b [51, 52] 0 88\n", + " ID TAG SCAN IFNUM PLNUM # SELECTED\n", + "--- --------- -------- ----- ----- ----------\n", + " 0 2c4cf7b1b [51, 52] 0 88\n", + " 1 4a182f785 [51, 52] [0] 1 44\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "sb = sdfits.getps(plnum=1)\n", + "ta3 = sb.timeaverage(weights='tsys')\n", + "ta3.plot(xaxis_unit=\"GHz\", ymin=-100, ymax=800, yaxis_unit=\"mK\", title=\"PLNUM=1\")" + ] + }, + { + "cell_type": "markdown", + "id": "339576f4-7317-4791-aca4-b52f9f8f1153", + "metadata": {}, + "source": [ + "#### Polarization Average\n", + "Average the polarizations and plot the result." + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "6f9c51ab-7a04-4def-b8f8-58f6cb308660", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "avg = ta2 + ta3\n", + "avg *= 0.5\n", + "avg.plot(ymin=-100, ymax=800, yaxis_unit=\"mK\", xaxis_unit=\"GHz\")" + ] + }, + { + "cell_type": "markdown", + "id": "387bc886-512b-490f-9bd0-ade391e08327", + "metadata": {}, + "source": [ + "### All Scans\n", + "\n", + "Now we leverage the power of `dysh` to calibrate and time average all of the scans in the data.\n", + "\n", + "We start by clearing the selection, so all of the scans are available." + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "56a50d07-ea90-4c46-990f-012d3f7a733c", + "metadata": {}, + "outputs": [], + "source": [ + "sdfits.selection.clear()" + ] + }, + { + "cell_type": "markdown", + "id": "4d1a49f2-8279-4b26-b4c4-9e69ca7ed569", + "metadata": {}, + "source": [ + "Then, make a `ScanBlock` for spectral window 0 and polarization 0. Time average the scans in the `ScanBlock` into a single `Spectrum` and then remove a baseline." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "b11a2291-9cfd-40c4-9450-9f4e056155e4", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " ID TAG OBJECT BANDWID DATE-OBS DURATION EXPOSURE TSYS TDIM7 TUNIT7 CTYPE1 CRVAL1 CRPIX1 CDELT1 CTYPE2 ... IFNUM PLNUM FDNUM INT INTNUM NSAVE HDU BINTABLE ROW PROC _OBSTYPE _SUBOBSMODE CHAN UTC # SELECTED\n", + "--- --- ------ ------- -------- -------- -------- ---- ----- ------ ------ ------ ------ ------ ------ ... ----- ----- ----- --- ------ ----- --- -------- --- ---- -------- ----------- ---- --- ----------\n", + " ID TAG SCAN IFNUM PLNUM # SELECTED\n", + "--- --------- -------------------------------- ----- ----- ----------\n", + " 0 76f386e98 [51, 52, 53, 54, 55, 56, 57, 58] 0 0 176\n" + ] + } + ], + "source": [ + "ps_scan_block_0 = sdfits.getps(ifnum=0, plnum=0)\n", + "ps_ta_0 = ps_scan_block_0.timeaverage(weights='tsys')\n", + "ps_ta_0.baseline(model=\"poly\", degree=2, exclude=[3800*kms,5000*kms], remove=True)" + ] + }, + { + "cell_type": "markdown", + "id": "3bcf3877-5398-4225-8d51-6833e89acd0b", + "metadata": {}, + "source": [ + "Now plot and compare with the result for a single scan." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "1ead1ef4-61eb-4080-801d-e0728990674a", + "metadata": {}, + "outputs": [], + "source": [ + "ta.plot(ymin=-400, ymax=400, yaxis_unit=\"mK\", xaxis_unit=\"GHz\")\n", + "ps_ta_0.plot(ymin=-400, ymax=400, yaxis_unit=\"mK\", xaxis_unit=\"GHz\")" + ] + }, + { + "cell_type": "markdown", + "id": "361b044d-6f40-4cc0-9c16-9f88376cfaca", + "metadata": {}, + "source": [ + "The rms in the second Figure is almost half that of the first Figure. That is because there are four pairs of position switched scans in the data, so that results in a factor of $\\sqrt{4}$ reduced noise when we average all the data." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "8a12633b-ed26-44ec-bf55-2ad4ee59e546", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.0" + }, + "toc": { + "base_numbering": 0 + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} From 788b484b9a4eb02f0705dd70d83172f98e2a3215 Mon Sep 17 00:00:00 2001 From: astrofle Date: Tue, 17 Sep 2024 13:31:37 -0400 Subject: [PATCH 14/95] Add: index for reference section --- docs/source/reference/index.rst | 48 +++++++++++++++++++++++++++++++++ 1 file changed, 48 insertions(+) create mode 100644 docs/source/reference/index.rst diff --git a/docs/source/reference/index.rst b/docs/source/reference/index.rst new file mode 100644 index 00000000..a9f80fe7 --- /dev/null +++ b/docs/source/reference/index.rst @@ -0,0 +1,48 @@ +.. _references: + + +##################################################### +:octicon:`tools;2em;sd-text-primary` Reference Guides +##################################################### + + +.. grid:: 1 2 2 2 + + .. grid-item-card:: + :shadow: md + :margin: 2 2 0 0 + + **Modules** + + dysh modules and functions + + .. button-link:: modules/index.html + :color: primary + :tooltip: Reference materials for dysh modules + :outline: + :click-parent: + + Modules + + .. grid-item-card:: + :shadow: md + :margin: 2 2 0 0 + + **SDFITS files** + + SDFITS files + + .. button-link:: sdfits_files/index.html + :color: primary + :tooltip: Reference materials for SDFITS files + :outline: + :click-parent: + + SDFITS files + +.. toctree:: + :maxdepth: 3 + :hidden: + + modules/index + sdfits_files/index From 3f873046bba4101ef84a72ef5506e50700ddced3 Mon Sep 17 00:00:00 2001 From: astrofle Date: Tue, 17 Sep 2024 15:38:38 -0400 Subject: [PATCH 15/95] Fix: missing space between code-block and code --- docs/source/for_developers/git_workflows.rst | 1 + 1 file changed, 1 insertion(+) diff --git a/docs/source/for_developers/git_workflows.rst b/docs/source/for_developers/git_workflows.rst index cdd261f5..a98b8ab7 100644 --- a/docs/source/for_developers/git_workflows.rst +++ b/docs/source/for_developers/git_workflows.rst @@ -55,6 +55,7 @@ In the directory you want to work in, set up the repo: To check out a branch called {{branch-name}}, just do .. code-block:: bash + $ git checkout {{branch-name}} Current development is done in the `main` branch. To set up your own development branch called `{{your-name}}-devel`, do the following: From ea42c20416c86061ffa7a81020bf22dbbba36d70 Mon Sep 17 00:00:00 2001 From: astrofle Date: Tue, 17 Sep 2024 15:39:49 -0400 Subject: [PATCH 16/95] Fix: missing line break between toc options and contents --- docs/source/reference/modules/index.rst | 1 + 1 file changed, 1 insertion(+) diff --git a/docs/source/reference/modules/index.rst b/docs/source/reference/modules/index.rst index eb36da62..a2c05f05 100644 --- a/docs/source/reference/modules/index.rst +++ b/docs/source/reference/modules/index.rst @@ -72,6 +72,7 @@ Modules and APIs .. toctree:: :maxdepth: 2 :hidden: + dysh.fits dysh.spectra dysh.plot From 407699325730339d60f8a5b9a8a5a58878b3bc05 Mon Sep 17 00:00:00 2001 From: astrofle Date: Tue, 17 Sep 2024 15:40:39 -0400 Subject: [PATCH 17/95] Remove: background section --- docs/source/background/gbo_context.rst | 22 ---------------------- docs/source/background/img/.gitkeep | 0 docs/source/background/index.rst | 11 ----------- 3 files changed, 33 deletions(-) delete mode 100644 docs/source/background/gbo_context.rst delete mode 100644 docs/source/background/img/.gitkeep delete mode 100644 docs/source/background/index.rst diff --git a/docs/source/background/gbo_context.rst b/docs/source/background/gbo_context.rst deleted file mode 100644 index c394d61a..00000000 --- a/docs/source/background/gbo_context.rst +++ /dev/null @@ -1,22 +0,0 @@ -************************** -Context Within GBO Systems -************************** - -Background -========== - -GBTIDL ------- - -`GBTIDL` is the current software used to calibrate SDFITS files from the GBT. - -Requirements -============ - -At its core, `dysh` needs to read in an SDFITS file and ultimately output calibrated data. - -.. mermaid:: - - flowchart LR - A[SDFITS File] --> B[Dysh] - B --> C[Output Data] diff --git a/docs/source/background/img/.gitkeep b/docs/source/background/img/.gitkeep deleted file mode 100644 index e69de29b..00000000 diff --git a/docs/source/background/index.rst b/docs/source/background/index.rst deleted file mode 100644 index c546dc11..00000000 --- a/docs/source/background/index.rst +++ /dev/null @@ -1,11 +0,0 @@ -********** -Background -********** - -Why does this exist? - -.. toctree:: - :maxdepth: 2 - - gbo_context - sdfits_files/index From 1e1ae311123fee8234ed678e9c75f1617d788c64 Mon Sep 17 00:00:00 2001 From: astrofle Date: Tue, 17 Sep 2024 15:56:11 -0400 Subject: [PATCH 18/95] Fix: docstrings --- src/dysh/coordinates/core.py | 53 +++++++++++++++++++----------------- 1 file changed, 28 insertions(+), 25 deletions(-) diff --git a/src/dysh/coordinates/core.py b/src/dysh/coordinates/core.py index aaeb927c..16a288f3 100644 --- a/src/dysh/coordinates/core.py +++ b/src/dysh/coordinates/core.py @@ -342,28 +342,29 @@ def sanitize_skycoord(target): # @todo version that takes a SpectralCoord def topocentric_velocity_to_frame(target, toframe, observer, obstime): """Compute the difference in topocentric velocity and the velocity in the input frame. + Parameters ---------- - target: `~astropy.coordinates.SkyCoord` - The sky coordinates of the object including proper motion and distance. Must be in ICRS - target: `~astropy.coordinates.SkyCoord` - The sky coordinates of the object including proper motion and distance. Must be in ICRS + target: `~astropy.coordinates.SkyCoord` + The sky coordinates of the object including proper motion and distance. Must be in ICRS + target: `~astropy.coordinates.SkyCoord` + The sky coordinates of the object including proper motion and distance. Must be in ICRS - toframe: str - The frame into which `coord` should be transformed, e.g., 'icrs', 'lsrk', 'hcrs'. - The string 'topo' is interpreted as 'itrs'. - See astropy-supported reference frames (link) + toframe: str + The frame into which `coord` should be transformed, e.g., 'icrs', 'lsrk', 'hcrs'. + The string 'topo' is interpreted as 'itrs'. + See astropy-supported reference frames (link) - observer: `~astropy.coordinates.EarthLocation` - The location of the observer + observer: `~astropy.coordinates.EarthLocation` + The location of the observer - obstime: `~astropy.time.Time` - The time of the observation + obstime: `~astropy.time.Time` + The time of the observation Returns ------- - radial_velocity : `~astropy.units.Quantity` - The radial velocity of the source in `toframe` + radial_velocity : `~astropy.units.Quantity` + The radial velocity of the source in `toframe` """ if not isinstance(target.frame, coord.ICRS): @@ -389,8 +390,7 @@ def get_velocity_in_frame(target, toframe, observer=None, obstime=None): done: * If proper motions attributes of `target` are not set, they will be set to zero. - * Similarly, if distance attribute of `target` is not set, it will - be set to a very large number. + * Similarly, if distance attribute of `target` is not set, it will be set to a very large number. * This is done on a copy of the coordinate so as not to change the input object. toframe: str @@ -438,12 +438,13 @@ def veltofreq(velocity, restfreq, veldef): restfreq: `~astropy.units.Quantity` The rest frequency veldef : str - Velocity definition from FITS header, e.g., 'OPTI-HELO', 'VELO-LSR' + Velocity definition from FITS header, e.g., 'OPTI-HELO', 'VELO-LSR'. Returns ------- - frequency: `~astropy.units.Quantity` - The velocity values converted to frequency using `restfreq` and `veldef' + frequency: `~astropy.units.Quantity` + The velocity values converted to frequency using `restfreq` and `veldef`. + """ vdef = veldef_to_convention(veldef) @@ -546,7 +547,7 @@ def __new__(cls): def gbt_location(): """ Create an astropy EarthLocation for the GBT using the same established by GBO. - See: page 3: https://www.gb.nrao.edu/GBT/MC/doc/dataproc/gbtLOFits/gbtLOFits.pdf + See page 3 of https://www.gb.nrao.edu/GBT/MC/doc/dataproc/gbtLOFits/gbtLOFits.pdf latitude = 38d 25m 59.265s N longitude = 79d 50m 23.419s W height = 854.83 m @@ -554,9 +555,9 @@ def gbt_location(): Note these differ from astropy's "GBT" EarthLocation by several meters. Returns - ---------- - gbt : `~astropy.coordinates.EarthLocation` - astropy EarthLocation for the GBT + ------- + gbt : `~astropy.coordinates.EarthLocation` + astropy EarthLocation for the GBT """ gbt_lat = 38.4331291667 * u.deg gbt_lon = -79.839838611 * u.deg @@ -582,9 +583,10 @@ class Observatory: This can be used for instance in transforming velocities between different reference frames. - Example usage - ------------- + Examples + -------- .. code-block:: + obs = Observatory() print(obs['GBT']) print(obs['ALMA']) @@ -592,6 +594,7 @@ class Observatory: Alternatively, you can treat Observatory like a dict: .. code-block:: + gbt = Observatory["GBT"] """ From 8e8de0403918f0e3e6334b5516b6b66253d9dcba Mon Sep 17 00:00:00 2001 From: astrofle Date: Tue, 17 Sep 2024 15:58:51 -0400 Subject: [PATCH 19/95] Add: ignore outputs in example and adds buttons to navigation bar --- docs/source/conf.py | 16 +++++++++++++++- 1 file changed, 15 insertions(+), 1 deletion(-) diff --git a/docs/source/conf.py b/docs/source/conf.py index fda6e5c9..d0a271a5 100644 --- a/docs/source/conf.py +++ b/docs/source/conf.py @@ -102,7 +102,7 @@ # List of patterns, relative to source directory, that match files and # directories to ignore when looking for source files. # This pattern also affects html_static_path and html_extra_path . -exclude_patterns = [] +exclude_patterns = ["examples/output"] # The name of the Pygments (syntax highlighting) style to use. pygments_style = "sphinx" @@ -121,11 +121,25 @@ # documentation. # html_theme_options = { + "repository_url": "https://github.com/GreenBankObservatory/dysh", + "repository_branch": "main", "logo": { "image_light": "_static/icon/dysh_logo_lightmode.png", "image_dark": "_static/icon/dysh_logo_darkmode.png", }, + # "show_toc_level": 2, + "use_source_button": True, + "use_issues_button": True, + "use_download_button": True, + "use_sidenotes": True, "show_toc_level": 2, + "icon_links": [ + { + "name": "GitHub", + "url": "https://github.com/GreenBankObservatory/dysh", + "icon": "fa-brands fa-github", + }, + ], } # Add any paths that contain custom static files (such as style sheets) here, From 24890770294c2cc45149c22ed47503c414b1af89 Mon Sep 17 00:00:00 2001 From: astrofle Date: Fri, 20 Sep 2024 15:38:24 -0400 Subject: [PATCH 20/95] Docs: redistribute examples --- docs/source/examples | 1 - docs/source/how-tos/examples | 1 + docs/source/how-tos/index.rst | 7 +++++++ docs/source/tutorials/examples | 1 + docs/source/tutorials/index.rst | 14 ++++++++++---- notebooks/examples/index.rst | 15 --------------- 6 files changed, 19 insertions(+), 20 deletions(-) delete mode 120000 docs/source/examples create mode 120000 docs/source/how-tos/examples create mode 100644 docs/source/how-tos/index.rst create mode 120000 docs/source/tutorials/examples delete mode 100644 notebooks/examples/index.rst diff --git a/docs/source/examples b/docs/source/examples deleted file mode 120000 index dc9f6698..00000000 --- a/docs/source/examples +++ /dev/null @@ -1 +0,0 @@ -../../notebooks/examples/ \ No newline at end of file diff --git a/docs/source/how-tos/examples b/docs/source/how-tos/examples new file mode 120000 index 00000000..d4789f2c --- /dev/null +++ b/docs/source/how-tos/examples @@ -0,0 +1 @@ +../../../notebooks/examples/ \ No newline at end of file diff --git a/docs/source/how-tos/index.rst b/docs/source/how-tos/index.rst new file mode 100644 index 00000000..88c835e2 --- /dev/null +++ b/docs/source/how-tos/index.rst @@ -0,0 +1,7 @@ +.. _howtos: + +########################################### +:octicon:`terminal;2em;green` How-To Guides +########################################### + +Practical step-by-step guides to help you achieve a specific goal. Most useful when you're trying to get something done. diff --git a/docs/source/tutorials/examples b/docs/source/tutorials/examples new file mode 120000 index 00000000..d4789f2c --- /dev/null +++ b/docs/source/tutorials/examples @@ -0,0 +1 @@ +../../../notebooks/examples/ \ No newline at end of file diff --git a/docs/source/tutorials/index.rst b/docs/source/tutorials/index.rst index 0e0b15c7..3990e31a 100644 --- a/docs/source/tutorials/index.rst +++ b/docs/source/tutorials/index.rst @@ -11,17 +11,23 @@ Most useful when you want to get started reducing your data. .. card-carousel:: 2 - .. card:: Position Switched (psw) Data - :link: psw/positionswitch.html + .. card:: Position Switched Data + :link: examples/positionswitch.html - Calibrate the data. + .. card:: Frequency Switched Data + :link: examples/frequencyswitch.html - Keys: *L-Band*, *psw* + - Calibrate the data. + .. card:: Sub Beam Nod Data + :link: examples/subbeamnod.html .. toctree:: :maxdepth: 4 :hidden: - psw/positionswitch + examples/positionswitch + examples/frequencyswitch + examples/subbeamnod diff --git a/notebooks/examples/index.rst b/notebooks/examples/index.rst deleted file mode 100644 index 9aef2736..00000000 --- a/notebooks/examples/index.rst +++ /dev/null @@ -1,15 +0,0 @@ -********************* -Examples for GBT Data -********************* - -.. toctree:: - :glob: - :maxdepth: 1 - - frequencyswitch - positionswitch - metadata_management - subbeamnod - smoothing - velocity_frames - dataIO From 8f4583ab3da5ad88cab09e6f5cab7a969ee3ab92 Mon Sep 17 00:00:00 2001 From: astrofle Date: Fri, 20 Sep 2024 16:00:47 -0400 Subject: [PATCH 21/95] Add scanblock section --- docs/source/explanations/index.rst | 14 + docs/source/explanations/scanblock/index.rst | 5 + docs/source/index.rst | 11 +- .../source/tutorials/psw/positionswitch.ipynb | 940 ------------------ 4 files changed, 25 insertions(+), 945 deletions(-) create mode 100644 docs/source/explanations/index.rst create mode 100644 docs/source/explanations/scanblock/index.rst delete mode 100644 docs/source/tutorials/psw/positionswitch.ipynb diff --git a/docs/source/explanations/index.rst b/docs/source/explanations/index.rst new file mode 100644 index 00000000..a7bebfce --- /dev/null +++ b/docs/source/explanations/index.rst @@ -0,0 +1,14 @@ +.. _explanations: + +############################################### +:octicon:`repo;2em;purple` Explanation Material +############################################### + +Big-picture explanations of higher-level concepts. Most useful for building understanding of a particular topic. + + +.. toctree:: + :hidden: + :maxdepth: 3 + + scanblock/index diff --git a/docs/source/explanations/scanblock/index.rst b/docs/source/explanations/scanblock/index.rst new file mode 100644 index 00000000..c7c4ee2f --- /dev/null +++ b/docs/source/explanations/scanblock/index.rst @@ -0,0 +1,5 @@ +.. _scanblocks: + +######### +ScanBlock +######### diff --git a/docs/source/index.rst b/docs/source/index.rst index 8240cd7e..29b5f6c8 100644 --- a/docs/source/index.rst +++ b/docs/source/index.rst @@ -6,7 +6,7 @@ `Green Bank Observatory `_ and the Laboratory for Millimeter-Wave Astronomy (LMA) at the `University of Maryland (UMD) `_. -It is intended to replace `GBTIDL `_, GBO's current spectral line data reduction package. +It is intended to replace `GBTIDL `_, GBO's current spectral line data reduction package. Contents =============== @@ -24,7 +24,7 @@ Contents Most useful when you want to get started reducing your data. - .. button-link:: examples/index.html + .. button-link:: tutorials/index.html :color: primary :outline: :click-parent: @@ -79,7 +79,7 @@ Contents contribute. - .. button-link:: references/index.html + .. button-link:: reference/index.html :color: primary :outline: :click-parent: @@ -94,7 +94,8 @@ Contents whatsnew/0.3.rst getting_started/index tutorials/index - examples/index + how-tos/index + explanations/index reference/index for_beta_testers/index for_developers/index @@ -119,4 +120,4 @@ Dev Team | Peter Teuben (UMD) | Pedro Salas (GBO) | Evan Smith (GBO) -| Thomas Chamberlain (GBO) +| Thomas Chamberlin (GBO) diff --git a/docs/source/tutorials/psw/positionswitch.ipynb b/docs/source/tutorials/psw/positionswitch.ipynb deleted file mode 100644 index 96c909af..00000000 --- a/docs/source/tutorials/psw/positionswitch.ipynb +++ /dev/null @@ -1,940 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "8c8138ef-e687-444e-95b1-9797654f3f62", - "metadata": {}, - "source": [ - "# Position-Switched Data Reduction\n", - "----------------------------------\n", - "\n", - "This notebook shows how to use `dysh` to calibrate an OnOff observation.\n", - "It retrieves and calibrates position-switch scans using `GBTFITSLoad.getps()`, which returns a `ScanBlock` object. OffOn observations can be reduced the same way." - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "id": "b4967550-2ca1-4931-b53b-6f9868718490", - "metadata": { - "editable": true, - "slideshow": { - "slide_type": "" - }, - "tags": [ - "import" - ] - }, - "outputs": [], - "source": [ - "from pathlib import Path\n", - "import astropy.units as u\n", - "from dysh.util.download import from_url\n", - "from dysh.fits.gbtfitsload import GBTFITSLoad" - ] - }, - { - "cell_type": "markdown", - "id": "87669763-8d96-4521-9e81-f69d7213e133", - "metadata": {}, - "source": [ - "## Data Retrieval\n", - "\n", - "Download the example SDFITS data, if necessary." - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "6bc88bc5-986d-4eae-b1c7-6398cc9ddd5a", - "metadata": { - "editable": true, - "slideshow": { - "slide_type": "" - }, - "tags": [ - "wget" - ] - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Starting download...\n", - "AGBT05B_047_01.raw.acs.fits already downloaded at /home/sandboxes/psalas/Dysh/dysh/notebooks/examples/data\n" - ] - } - ], - "source": [ - "url = \"http://www.gb.nrao.edu/dysh/example_data/positionswitch/data/AGBT05B_047_01/AGBT05B_047_01.raw.acs/AGBT05B_047_01.raw.acs.fits\"\n", - "savepath = Path.cwd() / \"data\"\n", - "filename = from_url(url, savepath)" - ] - }, - { - "cell_type": "markdown", - "id": "e0bf5028-e5b2-43c3-9a0c-6416dc02e2ec", - "metadata": {}, - "source": [ - "## Data Loading\n", - "\n", - "Next, we use `GBTFITSLoad` to load the data, and then its `summary` method to inspect its contents." - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "93a62e3a-c95d-475b-8602-b5b8b7934733", - "metadata": { - "editable": true, - "slideshow": { - "slide_type": "" - }, - "tags": [ - "load" - ] - }, - "outputs": [], - "source": [ - "sdfits = GBTFITSLoad(filename)" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "id": "90d482e1-3953-49da-9be6-49605ae9cf64", - "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", - " \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", - " \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", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
SCANOBJECTVELOCITYPROCPROCSEQNRESTFREQDOPFREQ# IF# POL# INT# FEEDAZIMUTHELEVATIO
051NGC52914386.0OnOff11.4204051.42040512111198.34311218.64274
152NGC52914386.0OnOff21.4204051.42040512111198.93057118.787219
253NGC52914386.0OnOff11.4204051.42040512111199.33049118.356075
354NGC52914386.0OnOff21.4204051.42040512111199.91572518.492742
455NGC52914386.0OnOff11.4204051.42040512111200.30423718.057533
556NGC52914386.0OnOff21.4204051.42040512111200.89060318.186034
657NGC52914386.0OnOff11.4204051.42040512111202.32754817.385267
758NGC52914386.0OnOff21.4204051.42040512111202.91916117.494902
\n", - "
" - ], - "text/plain": [ - " SCAN OBJECT VELOCITY PROC PROCSEQN RESTFREQ DOPFREQ # IF # POL \\\n", - "0 51 NGC5291 4386.0 OnOff 1 1.420405 1.420405 1 2 \n", - "1 52 NGC5291 4386.0 OnOff 2 1.420405 1.420405 1 2 \n", - "2 53 NGC5291 4386.0 OnOff 1 1.420405 1.420405 1 2 \n", - "3 54 NGC5291 4386.0 OnOff 2 1.420405 1.420405 1 2 \n", - "4 55 NGC5291 4386.0 OnOff 1 1.420405 1.420405 1 2 \n", - "5 56 NGC5291 4386.0 OnOff 2 1.420405 1.420405 1 2 \n", - "6 57 NGC5291 4386.0 OnOff 1 1.420405 1.420405 1 2 \n", - "7 58 NGC5291 4386.0 OnOff 2 1.420405 1.420405 1 2 \n", - "\n", - " # INT # FEED AZIMUTH ELEVATIO \n", - "0 11 1 198.343112 18.64274 \n", - "1 11 1 198.930571 18.787219 \n", - "2 11 1 199.330491 18.356075 \n", - "3 11 1 199.915725 18.492742 \n", - "4 11 1 200.304237 18.057533 \n", - "5 11 1 200.890603 18.186034 \n", - "6 11 1 202.327548 17.385267 \n", - "7 11 1 202.919161 17.494902 " - ] - }, - "execution_count": 4, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "sdfits.summary()" - ] - }, - { - "cell_type": "markdown", - "id": "e84c5009-96f4-489d-bc9d-89de390d53c9", - "metadata": {}, - "source": [ - "## Data Reduction\n", - "\n", - "### Single Scan\n", - "\n", - "Next we calibrate one scan of the position switched observations. We will start with scan 51, a single spectral window and polarization.\n", - "\n", - "If you don't want to calibrate, add, `calibrate=False`." - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "684126da-97d4-4afb-8625-43160340cab1", - "metadata": { - "editable": true, - "slideshow": { - "slide_type": "" - }, - "tags": [ - "getps", - "test" - ] - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - " ID TAG OBJECT BANDWID DATE-OBS DURATION EXPOSURE TSYS TDIM7 TUNIT7 CTYPE1 CRVAL1 CRPIX1 CDELT1 CTYPE2 ... IFNUM PLNUM FDNUM INT INTNUM NSAVE HDU BINTABLE ROW PROC _OBSTYPE _SUBOBSMODE CHAN UTC # SELECTED\n", - "--- --- ------ ------- -------- -------- -------- ---- ----- ------ ------ ------ ------ ------ ------ ... ----- ----- ----- --- ------ ----- --- -------- --- ---- -------- ----------- ---- --- ----------\n", - " ID TAG SCAN IFNUM PLNUM # SELECTED\n", - "--- --------- -------- ----- ----- ----------\n", - " 0 76f386e98 [51, 52] 0 0 44\n" - ] - } - ], - "source": [ - "ps_scan_block = sdfits.getps(scan=51, ifnum=0, plnum=0)" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "id": "5deaae0c-e70b-4758-ae10-f11c6f66cc3b", - "metadata": { - "editable": true, - "slideshow": { - "slide_type": "" - }, - "tags": [ - "print_tsys", - "test" - ] - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "T_sys = 19.36\n" - ] - } - ], - "source": [ - "print(f\"T_sys = {ps_scan_block[0].tsys.mean():.2f}\")" - ] - }, - { - "cell_type": "markdown", - "id": "b25c2499-a8c1-434a-b75e-d3bf25e223e7", - "metadata": {}, - "source": [ - "#### Time Averaging\n", - "\n", - "To time average the contents of a `ScanBlock` use its `timeaverage` method. Be aware that time averging will not check if the source is the same. \n", - "\n", - "By default time averaging uses the following weights: \n", - "$$\n", - "\\frac{T^{2}_{sys}}{\\Delta\\nu\\Delta t}\n", - "$$\n", - "with $T_{sys}$ the system temperature, $\\Delta\\nu$ the channel width and $\\Delta t$ the integration time. In `dysh` these are set using `weights='tsys'` (the default)." - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "id": "e0a33c19-576b-46e8-9a57-f34b8f85f6aa", - "metadata": { - "editable": true, - "slideshow": { - "slide_type": "" - }, - "tags": [ - "timeaverage", - "test" - ] - }, - "outputs": [], - "source": [ - "ta = ps_scan_block.timeaverage(weights='tsys')" - ] - }, - { - "cell_type": "markdown", - "id": "38898654-c1da-4a02-91d2-b4f488f18af7", - "metadata": {}, - "source": [ - "#### Plotting\n", - "\n", - "Plot the data and use different units for the spectral axis." - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "id": "40747f0b-d63d-45fa-8910-fef56fe5c751", - "metadata": { - "editable": true, - "slideshow": { - "slide_type": "" - }, - "tags": [ - "plot1", - "test" - ] - }, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "ta.plot()" - ] - }, - { - "cell_type": "markdown", - "id": "d83e0206-a79f-44c7-bd2b-a45516720e75", - "metadata": {}, - "source": [ - "Change the spectral axis units to km/s and the y-axis to mK, while also showing the spectra between 3600 and 5300 km/s, with the y-axis range between -100 and 1000 mK." - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "id": "6c07cf19-3a5d-47a9-9a10-ccd9f305efb9", - "metadata": { - "editable": true, - "slideshow": { - "slide_type": "" - }, - "tags": [ - "plot2", - "test" - ] - }, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "ta.plot(xaxis_unit=\"km/s\", yaxis_unit=\"mK\", ymin=-100, ymax=1000, xmin=3600, xmax=5300)" - ] - }, - { - "cell_type": "markdown", - "id": "1fa13098-104d-42f8-bf16-11d8b46ed0b9", - "metadata": {}, - "source": [ - "Switch back to GHz as the spectral axis unit." - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "id": "5fa6773c-b8e1-45ee-867c-b044df994f91", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "ta.plot(xaxis_unit=\"GHz\", ymin=-100, ymax=1000, yaxis_unit=\"mK\")" - ] - }, - { - "cell_type": "markdown", - "id": "0988ba2f-7ed0-4386-b4a5-7635537b8c5f", - "metadata": {}, - "source": [ - "#### Baseline Subtraction\n", - "The following code cells show how to subtract a polynomial baseline from the data. This example uses an order 2 polynomial, and excludes the regions between 3800 and 5000 km/s, where a line is detected. The use of `remove=True` will remove the best fit baseline model from the spectrum.\n", - "\n", - "\n", - "For a polynomial model one may need to normalize the frequency axis in channel space using `normalize=True`, to prevent poorly conditioned fits, but this will not allow you to undo the fit." - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "id": "d4c4526b-2e78-4f0f-85ff-0a4e3694a1e5", - "metadata": { - "editable": true, - "scrolled": true, - "slideshow": { - "slide_type": "" - }, - "tags": [ - "baseline", - "test" - ] - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "EXCLUDING [Spectral Region, 1 sub-regions:\n", - " (1397103816.4779327 Hz, 1402626103.134255 Hz) \n", - "]\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "WARNING: The fit may be poorly conditioned\n", - " [astropy.modeling.fitting]\n" - ] - } - ], - "source": [ - "kms = u.km/u.s\n", - "ta.baseline(model=\"poly\", degree=2, exclude=[3800*kms,5000*kms], remove=True)" - ] - }, - { - "cell_type": "markdown", - "id": "5ac09df0-0025-4bef-a779-b9896f5232fd", - "metadata": {}, - "source": [ - "When we plot the spectrum again, it has been baseline subtracted." - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "id": "43a07117-7088-43e5-927c-0c7ead1eb4fd", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "ta.plot(xaxis_unit=\"km/s\", yaxis_unit=\"mK\", ymin=-500, ymax=500)" - ] - }, - { - "cell_type": "markdown", - "id": "57f451bc-f27e-4e69-a735-009fedaf68f1", - "metadata": {}, - "source": [ - "We can inspect the best fit baseline coefficients." - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "id": "219e21a8-91cb-405e-82fc-249143c219ae", - "metadata": { - "editable": true, - "slideshow": { - "slide_type": "" - }, - "tags": [ - "test" - ] - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Model: Polynomial1D\n", - "Inputs: ('x',)\n", - "Outputs: ('y',)\n", - "Model set size: 1\n", - "Degree: 2\n", - "Parameters:\n", - " c0 c1 c2 \n", - " K K / Hz K / Hz2 \n", - " ------------------ ---------------------- --------------------\n", - " 1.6463452183080192 -9.793516886548451e-10 -7.1325412756222e-37\n" - ] - } - ], - "source": [ - "print(ta.baseline_model)" - ] - }, - { - "cell_type": "markdown", - "id": "01f5ca58-05ad-4124-8527-40ab2cd073fa", - "metadata": {}, - "source": [ - "And save the figure." - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "id": "3a7e4887-ba55-447a-9274-8275e9896d39", - "metadata": {}, - "outputs": [], - "source": [ - "output_dir = Path.cwd() / \"output\"\n", - "ta.savefig(output_dir / \"baselined_removed.png\")" - ] - }, - { - "cell_type": "markdown", - "id": "4b17e8e8-e39a-4934-8cf5-94342b3fbe44", - "metadata": {}, - "source": [ - "---" - ] - }, - { - "cell_type": "markdown", - "id": "3462f31f-f69e-48db-96f5-33f4071a384b", - "metadata": {}, - "source": [ - "#### Using Selection\n", - "\n", - "The following code shows how to calibrate scan 51 using selection. At this time selection does not know about signal and reference scan pairs, so the selection must include both scans, otherwise the calibration will fail." - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "id": "1786d5c3-3701-4199-b4a3-80a14dc92f5b", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - " ID TAG SCAN IFNUM # SELECTED\n", - "--- --------- -------- ----- ----------\n", - " 0 2c4cf7b1b [51, 52] 0 88\n" - ] - } - ], - "source": [ - "sdfits.select(scan=[51,52], ifnum=0)\n", - "sdfits.selection.show()" - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "id": "56e22004-a5cd-4064-a1eb-edaf6afe88f4", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - " ID TAG SCAN IFNUM # SELECTED\n", - "--- --------- -------- ----- ----------\n", - " 0 2c4cf7b1b [51, 52] 0 88\n", - " ID TAG SCAN IFNUM PLNUM # SELECTED\n", - "--- --------- -------- ----- ----- ----------\n", - " 0 2c4cf7b1b [51, 52] 0 88\n", - " 1 4a182f785 [51, 52] [0] 0 44\n" - ] - } - ], - "source": [ - "sb = sdfits.getps(plnum=0)" - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "id": "4281fdea-ab00-47e5-aca0-cc23b43224a7", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkUAAAHHCAYAAACx7iyPAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8g+/7EAAAACXBIWXMAAA9hAAAPYQGoP6dpAABwVklEQVR4nO3dd1hT59sH8G9YYQYEBUTBrYjiwoXauii4Wq12aK1iXa1Fq9JqpXWPYu1ba91tf1ato1Vba6ttVVy4cKE4wD0KKsMFEZQwkvcPSyQSIAlJThK+n+vKVXPOyTn3OQXOnec8z/2IFAqFAkRERESVnJXQARARERGZAiZFRERERGBSRERERASASRERERERACZFRERERACYFBEREREBYFJEREREBIBJEREREREAJkVEREREAJgUEREREQFgUkRERrRmzRqIRCLly97eHg0bNsTYsWORnp4OADhw4ABEIhF+/fXXMvdVtI+vv/661OOcOnVKuWzYsGFwdnYudX/Ozs4YNmyY8n1RHCKRCOvXr1f7mY4dO0IkEqFp06ZlxqqNP//8E61atYK9vT38/PwwY8YMFBQU6G3/RFQ6JkVEZHSzZ8/GunXrsHTpUnTo0AErVqxAcHAwnjx5ovW+vvrqK50+pyl7e3ts3LixxPJbt27h6NGjsLe319ux/vnnH/Tr1w9ubm5YsmQJ+vXrh7lz52LcuHF6OwYRlc5G6ACIqPLp2bMnWrduDQAYOXIkPDw8sHDhQvzxxx+oXr26xvtp0aIFEhISsHLlSkRGRhok1l69euHPP//E/fv3UbVqVeXyjRs3wsvLCw0aNMCjR4/0cqxPPvkEzZo1w+7du2Fj8+zPs0QiwRdffIHx48fD399fL8chIvXYUkREguvWrRsA4ObNm1p9rmPHjujWrRsWLFiAp0+fGiI09O3bF2KxGFu2bFFZvnHjRrz11luwtrbWy3GSkpKQlJSE0aNHKxMiAPjwww+hUCjKfZxIRBXHpIiIBHf9+nUAgIeHh9afnTlzJtLT07FixQp9hwUAcHR0RN++ffHzzz8rl509exaJiYl455131H4mKysL9+/fL/eVnZ2t/MyZM2cAQNmCVsTHxwc1a9ZUriciw2FSRERGV5Q03L59G5s2bcLs2bPh4OCAPn36aL2vl156CV27dsVXX31lsNaid955B4cPH0ZKSgoAYMOGDahbty7at2+vdvu+ffuiWrVq5b7Gjh2r/ExqaioAqH18WL16ddy9e9cAZ0ZExbFPEREZXUhIiMr7WrVqYcOGDahRowauXr2q9f5mzpyJzp07Y+XKlZg4caK+wlQKDQ2Fu7s7fvnlF3zyySf45ZdfMHTo0FK3//rrrzXqZ+Tj46P8d1FCJxaLS2xnb28PqVSqQ+REpA0mRURkdMuWLUPDhg1hY2MDLy8vNGrUCFZWujdcv/zyy+jatSsWLFiADz74QOf9iEQitcttbW3x5ptvYuPGjWjbti1SUlJKfXQGAEFBQVof28HBAQAgk8lKrMvNzVWuJyLDYVJEREbXtm3bEn1nKmrGjBno0qULvvvuO7i5uZVYb29vD5lMBoVCUSL5USgUyM3NLXN4/TvvvIOVK1di5syZaN68OQICAkrd9uHDh8jLyys3ZgcHB7i6ugJ4/tgsNTUVvr6+Ktulpqaibdu25e6PiCqGfYqIyCJ07twZXbp0wZdffqm2b1GtWrVQUFCg7NRd3LVr11BYWIhatWqVuv9OnTrBz88PBw4cKLOVCAD69++P6tWrl/saP3688jMtWrQAAJWCkwBw9+5d3L59W7meiAyHLUVEZDFmzpyJLl264Pvvvy+xrmfPnvjss8+wdOlSLFq0SGXdsmXLlNuURiQSYfHixThz5gyGDBlSZhy69Clq0qQJ/P398f333+P9999XDvVfsWIFRCIR3njjjXL3R0QVw6SIiEzSb7/9hkuXLpVYHh4eXuLxUpHOnTujc+fOiI2NLbGuRYsWGDlyJL799ltcvXoVr7zyCgAgJiYGf//9N0aOHInmzZuXGVPfvn3Rt2/fcmPXpU8R8Kw692uvvYbQ0FAMHDgQFy5cwNKlSzFy5Eg0btxYp30SkeaYFBGRSfrll1/ULu/SpUupSRHwrLWoa9euatd99913CAwMxI8//oioqCgAQKNGjbB48WJERERUPOgK6tOnD7Zu3YpZs2Zh3LhxqFatGj777DNMnz5d6NCIKgWRQqFQCB0EERERkdDY0ZqIiIgITIqIiIiIADApIiIiIgJgxklRYWEhpk2bhjp16sDBwQH16tXDnDlzULyLlEKhwPTp01G9enU4ODggJCSkxBQCDx8+xODBgyGRSODm5oYRI0aoTNJIRERElYPZJkVffvklVqxYgaVLl+LixYv48ssvsWDBAixZskS5zYIFC7B48WKsXLkSx48fh5OTE8LCwpCbm6vcZvDgwUhMTERMTAx27NiBgwcPYvTo0UKcEhEREQnIbEef9enTB15eXli1apVy2YABA+Dg4ID169dDoVDAx8cHH3/8MT755BMAz2bm9vLywpo1azBw4EBcvHgRAQEBOHnypHLKgZ07d6JXr164ffu2SmE1IiIismxmW6eoQ4cO+P7773HlyhU0bNgQZ8+exeHDh7Fw4UIAwM2bN5GWlqYyG7erqyvatWuHuLg4DBw4EHFxcXBzc1OZgykkJARWVlY4fvw4Xn/9dZVjyuVy3Lp1C7a2tipzJ4nFYrUzWxMREZHxyWQylcmVFQoF8vPzUbt27TInnzbbpGjKlCmQSqXw9/eHtbU1CgsLMW/ePAwePBgAkJaWBgDw8vJS+ZyXl5dyXVpaGjw9PVXW29jYwN3dXblNcXfv3kW9evUMcTpERERkYCkpKahZs2ap6802Kdq8eTM2bNiAjRs3okmTJkhISMCECRPg4+OD8PBwgxzTxcUFAJCUlKT8N1CxlqKCQjlazI4pc5sLs8J02rcxSKVS+Pr6IiUlBRKJROhwLBavs3HwOhsPr7VxFF1n3wmblcviorrBxd5WwKgM78WWosePHyMgIEDl3q2O2SZFkyZNwpQpUzBw4EAAQGBgIP79919ER0cjPDwc3t7eAID09HRUr15d+bn09HTlbNPe3t7IyMhQ2W9BQQEePnyo/HxxRY/MatSoobdf4oJCOazEjmVuYw5/MCQSiVnEae54nY2D19l4eK2No/h9RiKRWHxS9CKpVAoAKl1f1DHb0WdPnjwp8VzQ2toacrkcAFCnTh14e3tj7969yvVSqRTHjx9HcHAwACA4OBiZmZmIj49XbrNv3z7I5XK0a9fOCGdBREREpsJsW4peffVVzJs3D35+fmjSpAnOnDmDhQsXYvjw4QCeZYMTJkzA3Llz0aBBA9SpUwfTpk2Dj48P+vXrBwBo3LgxevTogVGjRmHlypXIz8/H2LFjMXDgQI48IyIiqmTMNilasmQJpk2bhg8//BAZGRnw8fHB+++/rzKb9OTJk5GTk4PRo0cjMzMTnTp1ws6dO2Fvb6/cZsOGDRg7diy6d+8OKysrDBgwAIsXLxbilMySWCzGjBkzOPrOwHidjYPX2Xh4rY2j6DqvyS1/WzLjOkVCkEqlcHV1RVZWll77FNX//J8yt7k1v7dejkVERJVT7Sl/Kf99fmZopexTpMn922z7FBERERHpE5MiIiIiIjApIiIiIgLApIiIiKhSYUfi0jEpIiIiIgKTIiIiIiIATIqIiIiIADApIiIiIgLApIiIiIgIAJMiIiIiIgBMioiIiIgAMCkiIiIiAsCkiIiIiAgAkyIiIqJKRcGS1qViUkREREQEJkWCE4lEQodAREREYFJkNhRs7yQiIjIoJkVmIGrreQRH78PR6/eFDoWIiMhiMSkyAz+fSEaaNBfv/HBc6FCIiIgsFpMiIiIiIjApIiIiIgLApIiIiIgIAJMiIiIiIgBMioiIiIgAMCkiIiKqXFj2rlRMioiIiIjApIiIiIgIAJMiIiIiIgBMioiIiIgAMCkiIiIiAmDGSVHt2rUhEolKvCIiIgAAubm5iIiIgIeHB5ydnTFgwACkp6er7CM5ORm9e/eGo6MjPD09MWnSJBQUFAhxOkRERCQws02KTp48idTUVOUrJiYGAPDmm28CACZOnIjt27djy5YtiI2Nxd27d9G/f3/l5wsLC9G7d2/k5eXh6NGjWLt2LdasWYPp06cLcj5EREQkLLNNiqpVqwZvb2/la8eOHahXrx46d+6MrKwsrFq1CgsXLkS3bt0QFBSE1atX4+jRozh27BgAYPfu3UhKSsL69evRokUL9OzZE3PmzMGyZcuQl5cn8NkRERGRsZltUlRcXl4e1q9fj+HDh0MkEiE+Ph75+fkICQlRbuPv7w8/Pz/ExcUBAOLi4hAYGAgvLy/lNmFhYZBKpUhMTCzzeFKpVOUlk8kMc2JERESkNZlMVuJerQmLSIq2bduGzMxMDBs2DACQlpYGOzs7uLm5qWzn5eWFtLQ05TbFE6Ki9UXryuLr6wtXV1flKzo6Wj8nQkREZGCKSlDSOjo6WuU+7evrq9HnbAwcl1GsWrUKPXv2hI+Pj1GOl5KSAolEonwvFouNclwiIiIqX1RUFCIjI5XvpVKpRomR2SdF//77L/bs2YOtW7cql3l7eyMvLw+ZmZkqrUXp6enw9vZWbnPixAmVfRWNTivapjQSiUQlKaoIkV72QkREREXEYrFODRZm//hs9erV8PT0RO/evZXLgoKCYGtri7179yqXXb58GcnJyQgODgYABAcH4/z588jIyFBuExMTA4lEgoCAAOOdABEREZkEs24pksvlWL16NcLDw2Fj8/xUXF1dMWLECERGRsLd3R0SiQTjxo1DcHAw2rdvDwAIDQ1FQEAAhgwZggULFiAtLQ1Tp05FREQEH4cRERFVQmadFO3ZswfJyckYPnx4iXXffPMNrKysMGDAAMhkMoSFhWH58uXK9dbW1tixYwfGjBmD4OBgODk5ITw8HLNnzzbmKRAREZGJMOukKDQ0FAqF+l709vb2WLZsGZYtW1bq52vVqoW///7bUOERERGRGTH7PkVERERE+sCkiIiIiAhMioiIiIgAMCkiIiKqVErpiktgUkREREQEgEkREREREQAmRWbnYU6e0CEQERFZJCZFZubT384JHQIREZFFYlJkZmKS0oUOgYiIyCIxKSIiIiICkyIiIiIiAEyKiIiIiAAwKSIi0srOC2mY/OtZ3LyfI3QoRKRnNkIHQERkLp7mFeKD9fEAgMNX7+NoVHeBIyIifWJLERGRhjKfPq8TdjcrV8BIiHTHWT5Kx6SIiIiICEyKiIiIiAAwKRKcSCR0BERERAQwKSIi0piCnTGILBqTIiIiIiIwKSIi0lmOrEDoEIhIj5gUERFp6HGuahL07qrjAkVCRIbApIiISAOygkKELTqosuxMcibkcnY0IrIUTIqIiDSwKzFd7XKOICWyHEyKiIg0UFAoFzoEIr1QcBhlqZgUEREREYFJEREREREAJkVEREREAJgUEREREQFgUkREREQEwMyTojt37uDdd9+Fh4cHHBwcEBgYiFOnTinXKxQKTJ8+HdWrV4eDgwNCQkJw9epVlX08fPgQgwcPhkQigZubG0aMGIHs7GxjnwoREREJzGyTokePHqFjx46wtbXFP//8g6SkJHz99deoUqWKcpsFCxZg8eLFWLlyJY4fPw4nJyeEhYUhNzdXuc3gwYORmJiImJgY7NixAwcPHsTo0aOFOCUiMmGsR0Rk+WyEDkBXX375JXx9fbF69Wrlsjp16ij/rVAosGjRIkydOhV9+/YFAPz000/w8vLCtm3bMHDgQFy8eBE7d+7EyZMn0bp1awDAkiVL0KtXL/zf//0ffHx8jHtSREREJBizbSn6888/0bp1a7z55pvw9PREy5Yt8cMPPyjX37x5E2lpaQgJCVEuc3V1Rbt27RAXFwcAiIuLg5ubmzIhAoCQkBBYWVnh+PHS5zSSSqUqL5lMZoAzJNLdtYzHiNp6Dgev3BM6FIvHOnhEpkcmk5W4V2vCbJOiGzduYMWKFWjQoAF27dqFMWPG4KOPPsLatWsBAGlpaQAALy8vlc95eXkp16WlpcHT01NlvY2NDdzd3ZXbqOPr6wtXV1flKzo6Wp+nRlRhb6yMw88nUjD0xxOsXktEKirDX4To6GiV+7Svr69GnzPbx2dyuRytW7fGF198AQBo2bIlLly4gJUrVyI8PNygx05JSYFEIlG+F4vFBj0ekbYyn+QLHYLFYW5JZD6ioqIQGRmpfC+VSjVKjMy2pah69eoICAhQWda4cWMkJycDALy9vQEA6emqkzimp6cr13l7eyMjI0NlfUFBAR4+fKjcRh2JRKLyYlJERERkOsRicYl7tSbMNinq2LEjLl++rLLsypUrqFWrFoBnna69vb2xd+9e5XqpVIrjx48jODgYABAcHIzMzEzEx8crt9m3bx/kcjnatWtnhLMgIiIiU2G2j88mTpyIDh064IsvvsBbb72FEydO4Pvvv8f3338PABCJRJgwYQLmzp2LBg0aoE6dOpg2bRp8fHzQr18/AM9alnr06IFRo0Zh5cqVyM/Px9ixYzFw4ECjjTwTVWCcr0KhqNDniUhzcdcfCB0CERmY2bYUtWnTBr///jt+/vlnNG3aFHPmzMGiRYswePBg5TaTJ0/GuHHjMHr0aLRp0wbZ2dnYuXMn7O3tldts2LAB/v7+6N69O3r16oVOnTopEytT9mv8bbSaE4PFe6+WvzERVdiW+NtCh0BEBma2LUUA0KdPH/Tp06fU9SKRCLNnz8bs2bNL3cbd3R0bN240RHgG9cmWswCAhTFX8FH3BgJHQ0REZP7MtqWIiMgUpD/OLX8jIjILTIqIiCpg+h+JQodARHrCpIiIqAJSHj4ROgQi0hMmRURERERgUkREVK5fTiQLHQKR3rA6e+mYFBERlSH+34eYsvW80GEQkREwKSIiKsP+S/eEDoHIYsnlCsRdf4CHOXlChwKASREREREJ5PtDNzDoh2N4dclhFMqFf67HpIiIiIgEMf+fSwCAO5lPkXRXKnA0TIqILB47VRoWr6/5yJYV4MTNhybRIkGmiUkRERFZPIVCgbe/i8Nb38Xh692XhQ6HTBSTIiKiFzzMyUPk5gQsjLkidCikJ49lBUj87/HM8gPXBY6GTJVZTwhLRGQIM/5MxPazdwEAgTVcBY6GiIyFLUVERC8oSogA4PydLAEjISJjYlJkYRQKBTsR6oFCoUDi3Sw8ySsQOhQycQrw943MC39mS8ekyAzJS0l6HufmI2RhLF5esB93M58aPaaIjafRZ8kh3LqfY9RjG8Lao7fQe/Fh9Fl8uNTrTZbpjpF/d4joGZFI6AiYFJmlH4/cVHmf/ODZLN2L9lzF9Xs5uJP5FFFGmpZAoVDgbEom1hy9hb/OpeLCHSkiNp42yrENaeb2JADAjfs5SEoVvnYGGc+0bReEDoGIBMKkyAzN/euiyvteiw8BAFIePlEuu34v2yix7DiXir7LjmD2jiTlskQTKMClT3supuPfB+bf+kWayXicq9X2rFNEZDmYFFmAbNmzfi+a/G3edykdw9ecxNFr9/Vy7HE/n9HLfkzZoj1XEbIwFjky9i8yF3K5AqN+OoWQhbFG+4JAROaPSZGF2H85AzFJ6eVuN3zNKey7lIF3/nfcCFFZjvxCBQ5e4cSg5mLH+VTEJKXjWkY2PlgXL3Q4RGQmmBRZiPdWnxQ6BCKTUfxR8tWMbGw+lYKCQrmAERFRcU/zCrE7MU3oMEpgUkREFm/yr+fw84nkEssL5Qos3XcV38RcQT6TJpOyZO9VvL78CM7fZp0oSzRl6zmMNsFWXCZFRFQpTPsjscSy3+Jv4/92X8G3e6/ip7h/BYiK1Lmb+RRfx1zBmeRMvL78iNDhkAH8kXC3/I0EwKSIiAQjdA2obQl3lP/ecipFwEiouAfZecp/F7BOGBkRkyIiEsRf51LRck4MZm9PKn9jPcl4nIsfD9/ETT0WGDWFgnP6djr5EaL/uaisgUYWhnlmqZgUWSiFAjh45R4OXM6AgoVUKjVj/t/X5mctYuNpZD3Nx49HbiI3v9CAUT03au0pzN6RhF7fHip1m0upj7XapyX+evVffhTfxd7AoB+OCR0KkVExKbJQdzKfYuiPJzBs9UkcufZA6HDIwikUCnywLh4d5+/DuduZWn9ebqTM4ux/nXaflpKE/RZ/W+vHNRaYEyndyXyKuOsPELk5AWdTMoUOh8jgmBRVAl/uvCR0CJVWZZlQ9vC1+9iZmIa7WbkY9L35ti58vOWs0CGYnEE/HMPW03fQdxk7PJNhmcKjaCZFRAbya/xtNJ+1Gx9Vgqrf6VKZ8t85ecZ5FFYauVyB+9my8jckInoBkyKq1DafTMEH6+JxNV27fiSa+GTLWeQXKvDn2bvIepKv9/2biq2nb+OTCrawLNh5GU/1kEzlFchR97O/sfrIrQrvi4SjsOiHklQaU+jYb7ZJ0cyZMyESiVRe/v7+yvW5ubmIiIiAh4cHnJ2dMWDAAKSnq06DkZycjN69e8PR0RGenp6YNGkSCgoqx+MOAjKf5GHyb+ewMzENAw38yKewlD4zaVm5Zt8RPnJzxR85rTl6C8v2X6vwfjZzWD2R2fr9zJ3yNzIws02KAKBJkyZITU1Vvg4fPqxcN3HiRGzfvh1btmxBbGws7t69i/79+yvXFxYWonfv3sjLy8PRo0exdu1arFmzBtOnTxfiVAyK37rUe5CTp/bfpdH38+7vYq+jffRejPrJeFVdc/MLVZKw3PxCZD4p/9yN4ae4WxXeR/H6Npow83yUyKKYwq+jWSdFNjY28Pb2Vr6qVq0KAMjKysKqVauwcOFCdOvWDUFBQVi9ejWOHj2KY8eetQjs3r0bSUlJWL9+PVq0aIGePXtizpw5WLZsGfLyTOMmUVldv5eN7EowI330P886wO+5mF7mvFzXMrJV5vLS1fEbD9B67h68vvwo5HIFpLn56DB/H9p+sRcX7uh3KoVdJjinUXlEptDLkwwmv4DTuFD5zDopunr1Knx8fFC3bl0MHjwYycnP5jaKj49Hfn4+QkJClNv6+/vDz88PcXFxAIC4uDgEBgbCy8tLuU1YWBikUikSE0tOB1CcVCpVeclk7NT5om1n7ujUR2T72bvo/nUsun99AHn8I4aElEyELIxF56/2Vzgxevv7Y8iWFSAhJRO7k9Kx4sB1PMzJQ16BHO/reQ6i99fF48a9bL3uUxNHr9/XeNvc/ELE3XheriJbZh79vmKS0hG5KQFXDNAPzlJFbT2PoLl7hA6DyqHPryUymazEvVoTZpsUtWvXDmvWrMHOnTuxYsUK3Lx5Ey+99BIeP36MtLQ02NnZwc3NTeUzXl5eSEt79g02LS1NJSEqWl+0riy+vr5wdXVVvqKjo/V3YhZiwqYEnUoBjPtvpFa6VKb31oZrGY/x59m7kBUYZnRUfqEcv5+5jRM3H5ZYdyX9MdYcuan1o6oJvzy7HnIFMF+PpRWkufl4nPs8CbhngNFaR65pnqDoy3E117408/9RvZ4pD5/qdExj9gkrKJRj1E+nsPXMHfRfftRoxzVnBYVytZMBk2WLjo5WuU/7+vpq9DkbA8dlMD179lT+u1mzZmjXrh1q1aqFzZs3w8HBwaDHTklJgUQiUb4Xi8UGPV5FCdVvYs3RW5j5WhOdP1+oxzmPcmQFCFl4EAAwrlt9fBzaSOd9Pc0rhIOddYnla4/ewty/LgIADk7qqrKuqCP3oav3sWpYG42PlV/4/BoUFiqgUCj4mEdP1hy9ZZD9KhQKFMgVsLUu/TtnxuNcjP85Ae7Odvj27RawsbZCtqwAx288QHA9Dzjaqf/TXLywZGV4xKwPptBPxdRUhmsSFRWFyMhI5XupVKpRYmS2LUUvcnNzQ8OGDXHt2jV4e3sjLy8PmZmZKtukp6fD29sbAODt7V1iNFrR+6JtSiORSFRepp4UaTqFglyuQH4ZfVvM2Ylbz1sQluzTfZTTNzFX0HTmLizcfbnEuqKECAD+SFA/imLvpQydj70zMQ0d5+/D6eRHOu+jVBr8lVx79Bbe/i4OCRpWNp7z10X8ePhmxeIyM3kFcry69DDafbEXSXdLb67/bOsFxN14gL/OpeLnk89GzH244TRGrD2FyE0sIMkO8FRRYrG4xL1aExaTFGVnZ+P69euoXr06goKCYGtri7179yrXX758GcnJyQgODgYABAcH4/z588jIeH6TiomJgUQiQUBAgNHjN6Tr93KwMOZKmdskP3iCbl8fQIf5+0yiVkRp5v2VhLe/ixOkvwoAfLv3KgrlCiyuQGKljqb3gLtZuXhzZZxejinS4gn+49x8zPgzEcdvPkQ/DSsb5xXIMXtHEuKuW/Y0M8X/3206lYILd6R4mJOHUT+dKvUzh6/dU/77Yuqz5OnglWfLdpphJ3VzxD6LzxXKFThwOaNCEyWnPHxiEV+qzTYp+uSTTxAbG4tbt27h6NGjeP3112FtbY1BgwbB1dUVI0aMQGRkJPbv34/4+Hi89957CA4ORvv27QEAoaGhCAgIwJAhQ3D27Fns2rULU6dORUREhMm3/Ohi8d6rpa5bGXsdL3+1H7cePMG9x7IKF+IzlNPJj/DDoZs4fvMhRpZxw6mIG/eyseaIabdu6OOxorYP4HJkuvfD0rTzc3mPBfckpaPLV/ux4sB1nWMxtHvSXOW/72Tq1keJKk6Tfl5NZ+7CumP/GiEa07fh+L8YtvokQhbGQpqr/YCDTSeT8dKC/ei79EiZ1768RPTG/RykZgn7e2O2SdHt27cxaNAgNGrUCG+99RY8PDxw7NgxVKtWDQDwzTffoE+fPhgwYABefvlleHt7Y+vWrcrPW1tbY8eOHbC2tkZwcDDeffddDB06FLNnzxbqlARx5Nr9Eh1Oiz9qMpY5O5LKnVvpVrFvMTfu5eh9GDkAhH5zEDO3J+l9v8VFbT2H3SbWGmAOtaxG/nQKtx484Vx+VKaDV+6hzby9iNp6rszt8grkmLbtgpGiMm3T/3g24rpQrsDO89r/bfr0t/MAgKRUKS6mqh8VOWLNSbSYvRtbT98utQTJtYxsvLxgP9KyctWuNwaz7Wj9yy+/lLne3t4ey5Ytw7Jly0rdplatWvj777/1HZpZGfy/4zp/9t5j/YxYOn87C6t06HvSZ8lhXJrTA/a2JTs960rbGdJLU9Zefj6Rgp9PGK/y8rNvbiVbYdhfWz9u3NP9kYO22NemfEN/PAHg2e/Zh13qw9vVXuCIKhd1LdmJd7OU/SkjN58ts3p9fqECC2MuY8EbzQ0WY1nMtqWIDOt+tgzf7rmK4zfU9wcplCs07lsCPCvI+PXuyxj38xn8cz5VZV1FHjPoo6ihKThx86HBSgWoo+0INn23JJn71CZkHrJlBXqtfUO6efHx+/Vyvkjo68upLsy2pYgMa+KmBBy6+qwvSOKsMDiJVX9Ubt7P1iiZuZv5FFWdxej+daxy2fazd3F2eihcHW3L/KxeO+0Z+HesosOji1rsPuxSD+93rgdXh7KvjT4Uv1kYK0dRKBQY9dMpXLijWSE1WUEhpm9LNIvHe2QZrmVk48udl/BSg6oYGlxb6HBKUCgUyCuUQ2xTegu5QqFA8sMn+HbvVbzcoBr6taxhsHgMMZm2kJgUkVpFCRHwrCWnoZeLTvvpMH8fAmu4llieJs0tNyma9Os5ZMsK8F7HOgBM4XGP+gBO3nqIoatO6OUIyw9cx4PsPHz5RjO97K8sxVuLiqcc+YVyzP/nEgrlCkT18i/zj6+2Dly+hz0XNS9L8MPBG9hk4ZO8Ct1o9jSvELFX7qFN7SrwcNbPIJN/H+Rgzo4kBNVyx5gu9Sq8vz1J6QgJ8Cp/Qz0Ysuo4UrNyEZOUjtAAb5N6/KZQKDD0xxPKv88r3w1Cj6aqJWTSsnIx9MfjuJL+bITu1tN30LlhNYPFNNXC+mXx8RkZ3PkKdIietT2pzBajitxP9HUzeueHY3iqYS0oTRQlAQqFQm8jMdKlmndcXHv0FlYdvok1R2/hf4f0OxJP235o+y/fK3ebW/dz8NbKOEz/w3z+OGtTDsHQpm67gA/WxysLjFaUQqHAgBVHsediBr7ceUmnloQXfzUNNdpUndRinXwNMRJqxYHreOu7OJ0GiiSkZKp8Yf1gfcnpeaK2nlMmREXSH2v++69tq6xc6Kxez5gUkSAK5M8SnQxpbrk37PAftW+Fmf/PJYR+E4v4fw0/kq541ekiS/aVXgJBU+N/SYC+Hq1/9N/0KUVevCUX7+OzO+l5UdN/Ljzr/5UuNfz8fllPdZt77P118Thx6yF+irP84dW6XqOy/Hb6NgDgaoZ+an99vPks7mc/n86mIrVvLE1q1lN8ufMSTtx8iLe/077emCaP6TX5EmpheYxeMSkiQUz57TySHzxBh/n7MOPPsifgPXr9AXZeSMXBKyXr3Yxce6pEXY07mU+xMvY6rqRnY8CK//7wvJAFqKvFUVYFYm2pS5S09efZu6Wue+u7OBTKFdhx7i6+2nUJWU/KvllqMyeYOlN+K3t4s6bK+xaqSz+yyybQp6FoxI2h7zVDfyx9tOjW07cR+k0stp1RX0195p+J6PntIYOUslCJo5TjC0GhKL9TrzEVn18vR4cJs8nwmBSRIM7fycKMPy9oPMrgg/Wn8buaP7bJD5+UqLP0KEd10tU9SarTuQAlJwMFgO3nSk9CnjGdr1cnbj7Eoj1XMHbjGSzbfx0zt5edWFbUpTTjJB5PtCgS+Tg3H4evGn/SWXVmlpPY68uLj0WKi9x8FlfSszFhU0KJdYl3s7Dm6C1cTJVi0A/6eUxmSPp6uDhl6zmELTpYoX3kF8px+Op9lQmUdVEoV+AtHVqHtFXRVqBPfzuvVYFYS2t1YlJUiTw1sW8m+uqHU96NceRPp3D+tuq3443HtZ81W58tSfrwV7HSBsUTRl2GuytKfWO63l11Au+u0r3Olj6ZemXk4sXwHuc+ewTzR8IdDPze8DfpJfuuGbXcRHHnble8VeyLvy/i3VXH8W4FaroBwCkBiuIWebEY4qMneWW2ypY2d2NlwNFnlUjj6Tt1/mzxG+2s7Uk4eLX8DrCmZLMeRjDpe74zQ9l0svxzFYk0G81XXodgbUsRlJevjV53CgoFsGxwK1RzKXsk1FkNJ6Yl9cb/kmCU45y/86w464dd6mv8GW37Tp27nYmtp+9gYNvyZ0HX1uojtwAAZ29nQS5XwMpKt3Ysda3i38Veh4u9LdrUroI6VZ1gY13xdgp1v2LDVp9Ued/z20PwdXfAnsjOakeXpgpYUVpoTIqoXFlP89Fj0SHIFQqEd6iNNUdvCR2SWnkFcvxyMhl3M0v+Qhdo0MfHUpqBp2w9b5TjnE5+hME/6Lelpqjv09Rt5/HdkNYWVeTxSV4Bjt14gHZ1PF5YU/Ics2UFcBZr9uc5/t9H2KXltDHyCvTgLy0xyJEVIEbNo2oAWLbvGm4/ego3B1tMCmtUbvHQ99eVHFVVlteWPiskq+8Wuxfj1HdZkOhij/E7N6yGtcPblthGoVAg/t9HGiVMq4/cxMMXug+UJuXhU/wWfwfvtPPTPGANqLtG5vR7zKSoEpulYT+UL/+5pOzMqs+aFGX1j9DFumP/Ys4O9fOWpWkwJL1QbjozPBvjsUZxCsWzx6sOdtYqw3dvPcgp9bFB+I8n9FqKoLi4688qqSeXUrF8gRnOfzbhlwTsTkpHN3/PEutOJz9Sef/17suY8WoTjfY7YMVRrWNpNmu31p8BgMH/O4bLadn4cVhrNKvpprLu89/PY1uC+n55OXmFykfWjbxd0LdFyWKCcrkCU/+4gPuPZTr/XOljsmRDUCgU5U5lFHtFfev7yVuPlH2RpvT0L3Mfs7SctzGngkVnLRH7FFViRc3C5bl+T7/JSxFNv9FoauHuyxX6/A96rslTEcduGLb/gUhU8tFY4+k7kSMrwL8Pnicij3MLcPia+j5bRX1TtKHNLStbVqAytLu45Qeua31soRWVOth3KaPEt+n+y1UTG01/N3N1TB50rcB+5NoD3M+WqU2US0uIXqRuFCnwrF/cxuPJKiUhTNkfCXfQ+av9+N+hGzh89X6ZfTZP3HyIfZfKL1p6KU2KRXuuqExfVHzSWnUDRAxBk5b1IqaZhuqOLUVULkv7oS/y6EnFk7IXR7oZVQX/x6hr5m4yY1fFdqon0twCNJtpGrFUVNbTfOwod2SjbpoK9P9LmluAvsuOwMPJDt8NCYKtHvrCJJhBHzGFAoi7fh+rDt9UTnA696+LAIDu/p5YNayN2s9Fbj6r0f57LDoE4FntqEOTu+kh4vLdVTNd0+qjNzE+pIFRjm9qmBRRuUz9cXDywyfYfCpF6xwhSg99b/osOVzhfZij+9naFXMslCvw5c5LWKNhCwgAvRWuFJJcrkBzHR9VJd7NQuaTfATX9Si1c29pJS1SHj6Br7ujTsfVVFFH9x8P38TbbTTv4JwjK8CG4/+iha8bmviUnAKoLAqFAgt2XcbNezmY3bcJPCXGn4LjnVIeJ+/VoCVIU8XrGWnqp7hbWn9m3t8XceBKybgzy6l7ZsmYFFG5DFFFV98m/6p9ccFreqjgq8mkuKYo9vK9Cs1zpU0xxyX7ruHG/Rz8dS61/I0tzLZShjY/0aA8Ru/FzxLuea83xeB2tbQ67qztifhfuPpWC32L/ucSvo65ovH2OxPTsPO/juFJs8PgaKf5bejQ1ftY8d+j06f5hWo7JutKVlBYonSH6UzGUrYzyY8w/Q/damUdufZAr7EkpUqxYNdlhDT2hK+7I7Yn3EVgTe2SXyGxTxGRmXqxE/Jf51LV9mtQ15awLeEu8gp071iuzaSuACpNQvRiq6ou9bBe9Pnv2g9u2HMxA0N/PIEH/7Xo6aPCell0/Vm6quVgi+JTWJTWMVlXERtO442Vxh3gUJZxP5/ByVsPNZqL7PXl2ne2r4itp28jaut5pGY9LTGybPKv53Dwyj1M/yMR760+ia1n7mjdAVxIbCkiMlMvPjqJ2Hgag7So0/LiiCfSvzMa9JMx1OPpg1fuYfqfiVj2TitsOqlZcpb1JB8SB2FuC5pMFiw1YKu1Jom+Jv+rvt1zFf9cSMXsvk3Rto67zvFsP3sX28uY6kcodzKfKvtIXcswUKV7AR+ds6WISEc7L5he68fPJzQvUploYhW6LZHQQ8QPXn7WmlJ8RGFZHuph8IEu8gvlykdqZfnu4A29H7tAh/n2SvMgW4Zv9lzBpbTHRpnSAyg52bOhFe92cPKW5X2xYlJEpKMP1p8WOgSN/F8FSxWQYRmjxe7fUuo9vUifCYImNp9KQdg3B3WeO67v0sMVLgx4ooKTJRdXWpkKQxYvLGviaNIekyIiC/ddrP6/XVNJZ1MyVeaj05S+i5iqo2mL1Zz/hpcby4bjybic/hgbdOx7dfZ2llato+pYwCBHQRm6v5qxsU8REZEeDF9zEg+ErFulBwf13HlZn/ouO6J2+eK9Vw12zBdreT0opxSFZaUHzxW1dKmbnkXfRXiFxpYiIiI9MHRCVJH5yiyBIScATinl8eKLT72m/aHdSMD4f82/z83j3Hz0XnwYod8c1KgzvLljUkREZAauGGqkD6FfKa1Q01/o67RXy1IU760+AUB9C4u5+OLvi0hKleJqRrbG82WaMyZFREQm7lnNIeM8pjCH6Tb0rbRWPm1bp17sUC3VYX5AU1O8z9aOSlBvjH2KiIhM3MEr99TOUWUIo9fFG+U4lmj9MfUdxg05+szYXjwXc63qXxq2FBERmQGdpqXR4amNtvPaCS1Nmmu0Y5WX2vx45Kba5XezjBcjVQyTIiIiIlJRWsvksv3XjByJcTEpIiKyUI9zC7QujGhBT3qoAqZsPa92uSVWsS6OSRERkQVbc/SW0CGYNHWTKJfGfMeQae/GPcMXFTVFTIqIiKjSWrJP8+KPujSi1Z7ylw6fEt7tR5bVgVpTOidF+fn5SElJweXLl/Hwof7mjtHF/PnzIRKJMGHCBOWy3NxcREREwMPDA87OzhgwYADS09NVPpecnIzevXvD0dERnp6emDRpEgoKzH8IJRERaebs7SyNt7WkUWSayCsw7lx4pkCrpOjx48dYsWIFOnfuDIlEgtq1a6Nx48aoVq0aatWqhVGjRuHkyZOGilWtkydP4rvvvkOzZs1Ulk+cOBHbt2/Hli1bEBsbi7t376J///7K9YWFhejduzfy8vJw9OhRrF27FmvWrMH06dONGj8REZEp2ncpvfyNLIzGSdHChQtRu3ZtrF69GiEhIdi2bRsSEhJw5coVxMXFYcaMGSgoKEBoaCh69OiBq1cNNx9NkezsbAwePBg//PADqlSpolyelZWFVatWYeHChejWrRuCgoKwevVqHD16FMeOHQMA7N69G0lJSVi/fj1atGiBnj17Ys6cOVi2bBny8ixrLhciIqq4yjbTSkFlO2FoUbzx5MmTOHjwIJo0aaJ2fdu2bTF8+HCsWLECa9aswaFDh9CgQQO9BapOREQEevfujZCQEMydO1e5PD4+Hvn5+QgJCVEu8/f3h5+fH+Li4tC+fXvExcUhMDAQXl5eym3CwsIwZswYJCYmomXLlqUeVyqVqrwXi8UQi8V6PDMiIiJhFZpxUiSTySCTPa+59eJ9uzQatxT9/PPPpSZExRUUFOCDDz7A8OHDNd21Tn755RecPn0a0dHRJdalpaXBzs4Obm5uKsu9vLyQlpam3KZ4QlS0vmhdWXx9feHq6qp8qYuBiIjInMkF6kO19cydCu8jOjpa5T7t6+ur0ee06lP0zTfflLn+8ePHCAsL02aXOklJScH48eOxYcMG2NvbG/x46o6flZWlfEVFRRk9BiIiIkNKvKNZ64opioqKUrlPp6SklP8haJkUffbZZ/jpp5/UrsvJyUGPHj3w4MEDbXapk/j4eGRkZKBVq1awsbGBjY0NYmNjsXjxYtjY2MDLywt5eXnIzMxU+Vx6ejq8vb0BAN7e3iVGoxW9L9qmNBKJROXFR2dERGRp/ndY/bQl5kAsFpe4V2tCq6Ro3bp1eP/99/Hnn3+qLM/JyUFYWBju3buH/fv3a7NLnXTv3h3nz59HQkKC8tW6dWsMHjxY+W9bW1vs3btX+ZnLly8jOTkZwcHBAIDg4GCcP38eGRkZym1iYmIgkUgQEBBg8HMgIiIi06JxR2sAeOONN5CZmYlBgwbhr7/+QpcuXZQtROnp6YiNjUX16tUNFauSi4sLmjZtqrLMyckJHh4eyuUjRoxAZGQk3N3dIZFIMG7cOAQHB6N9+/YAgNDQUAQEBGDIkCFYsGAB0tLSMHXqVERERLDlh4iIqBLSKikCgJEjR+Lhw4fo27cv/vjjD0yfPh13795FbGwsfHx8DBGjTr755htYWVlhwIABkMlkCAsLw/Lly5Xrra2tsWPHDowZMwbBwcFwcnJCeHg4Zs+eLWDUREREJBSRQscSnVOmTMFXX32F2rVr48CBAxr37DZnUqkUrq6uyMrK0vj5pCbMtQw8ERGRIdya31uv+9P0/q1VS1HxitAAYGtri6pVq2L8+PEqy7du3arNbomIiIgEp1VS5OrqqvJ+0KBBeg2GiIiISChaJUWrV682VBxEREREgtK6o3WR3NxcnDt3DhkZGZDLn8+kKxKJ8Oqrr+olOCIiIiJj0Skp2rlzJ4YMGaK2UKNIJEJhYWGFAyMiIiIyJq2KNxYZN24c3nrrLaSmpkIul6u8mBARERGROdIpKUpPT0dkZGSJCVWJiIiIzJVOSdEbb7yBAwcO6DkUIiIiIuHo1Kdo6dKlePPNN3Ho0CEEBgbC1tZWZf1HH32kl+CIiIiIjEWnpOjnn3/G7t27YW9vjwMHDkAkEinXiUQiJkVERERkdnRKij7//HPMmjULU6ZMgZWVTk/giIiIiEyKThlNXl4e3n77bSZEREREZDF0ymrCw8OxadMmfcdCREREJBidHp8VFhZiwYIF2LVrF5o1a1aio/XChQv1EhwRERGRseiUFJ0/fx4tW7YEAFy4cEFlXfFO10RERETmQqekaP/+/fqOg4iIiEhQ7ClNREREBC2SouTkZK12fOfOHa2DISIiIhKKxklRmzZt8P777+PkyZOlbpOVlYUffvgBTZs2xW+//aaXAImIiIiMQeM+RUlJSZg3bx5eeeUV2NvbIygoCD4+PrC3t8ejR4+QlJSExMREtGrVCgsWLECvXr0MGTcRERGRXmncUuTh4YGFCxciNTUVS5cuRYMGDXD//n1cvXoVADB48GDEx8cjLi6OCRERERGZHa1Hnzk4OOCNN97AG2+8YYh4iIiIiATB0WdEREREYFJEREREBIBJEREREREAJkVEREREAJgUEREREQHQce6zF6WnpyMpKUn5SkxMxMWLF5Genq6P3RMREREZXIWSok6dOuHq1atwc3NDo0aN4O/vjy1btmDHjh1o0KCBvmIkIiIiMrgKJUU+Pj6Qy+WIjo5G586dAQBbtmxB27Zt9RIcERERkbFUqE/R5s2b8d1332HRokUIDQ3F8ePHIRKJ9BVbmVasWIFmzZpBIpFAIpEgODgY//zzj3J9bm4uIiIi4OHhAWdnZwwYMKDE47zk5GT07t0bjo6O8PT0xKRJk1BQUGCU+ImIiMi0aJUU7dmzBwqFQmVZYGAgfv/9d3zxxReYNWsW0tPTcfz4cb0GqU7NmjUxf/58xMfH49SpU+jWrRv69u2LxMREAMDEiROxfft2bNmyBbGxsbh79y769++v/HxhYSF69+6NvLw8HD16FGvXrsWaNWswffp0g8dOREREpkekeDHLKYO1tTVSU1Ph6elZ6jZHjhzB9OnTIRKJsGfPHr0EqSl3d3d89dVXeOONN1CtWjVs3LhROR3JpUuX0LhxY8TFxaF9+/b4559/0KdPH9y9exdeXl4AgJUrV+LTTz/FvXv3YGdnV2L/UqkUrq6uyMrKgkQi0Vvctaf8pbd9ERERmbtb83vrdX+a3r+1ainSJH/q2LEj9u7di88//1ybXVdIYWEhfvnlF+Tk5CA4OBjx8fHIz89HSEiIcht/f3/4+fkhLi4OABAXF4fAwEBlQgQAYWFhkEqlytam0kilUpWXTCYzzIkRERGR1mQyWYl7tSYMVqeoa9euhtq10vnz5+Hs7AyxWIwPPvgAv//+OwICApCWlgY7Ozu4ubmpbO/l5YW0tDQAQFpamkpCVLS+aF1ZfH194erqqnxFR0fr76SIiIioQqKjo1Xu076+vhp9TuvRZytWrECnTp3QqlUrVKlSRetA9alRo0ZISEhAVlYWfv31V4SHhyM2Ntbgx01JSVFpfhOLxQY/JhEREWkmKioKkZGRyvdSqVSjxEjrpGjp0qWYNWsWRCIRfH190apVK5WXt7e3trvUmZ2dHerXrw8ACAoKwsmTJ/Htt9/i7bffRl5eHjIzM1Vai9LT05XxeXt748SJEyr7KxqdVt45FI14IyIiItMjFot1arDQ+vFZYmIibt++jT///BMjRoyAQqHADz/8gD59+qBGjRqoUaOG1kHoi1wuh0wmQ1BQEGxtbbF3717lusuXLyM5ORnBwcEAgODgYJw/fx4ZGRnKbWJiYiCRSBAQEGD02ImIiEhYWrUUFdUg8vHxgY+PD3r3ft47/MGDB4iPj0dCQoJeAyxNVFQUevbsCT8/Pzx+/BgbN27EgQMHsGvXLri6umLEiBGIjIyEu7s7JBIJxo0bh+DgYLRv3x4AEBoaioCAAAwZMgQLFixAWloapk6dioiICD4OIyIiqoS0SorKGn3m4eGB0NBQhIaGVjgoTWRkZGDo0KFITU2Fq6srmjVrhl27duGVV14BAHzzzTewsrLCgAEDIJPJEBYWhuXLlys/b21tjR07dmDMmDEIDg6Gk5MTwsPDMXv2bKPET0RERKZFqzpFu3fvRufOnSttSwrrFBERERmeUHWKtGopMlYrEBEREZGxGaxOEREREZE5YVJEREREBCZFRERERACYFBEREREBYFJEREREBIBJEREREREAJkVEREREAJgUEREREQFgUkREREQEgEkREREREQAmRUREREQAmBQRERERAWBSRERERASASRERERERACZFRERERACYFBEREREBYFJEREREBIBJEREREREAJkVEREREAJgUEREREQFgUkREREQEgEkREREREQAmRUREREQAmBQRERERAWBSRERERASASRERERERACZFRERacxbbCB0CERkAkyIiIi0tH9xK6BCIyACYFBERaclLYo9Pe/gLHQYR6ZnZJkXR0dFo06YNXFxc4OnpiX79+uHy5csq2+Tm5iIiIgIeHh5wdnbGgAEDkJ6errJNcnIyevfuDUdHR3h6emLSpEkoKCgw5qkQERGRCTDbpCg2NhYRERE4duwYYmJikJ+fj9DQUOTk5Ci3mThxIrZv344tW7YgNjYWd+/eRf/+/ZXrCwsL0bt3b+Tl5eHo0aNYu3Yt1qxZg+nTpwtxSkRkJhRQCB0CERmA2fYW3Llzp8r7NWvWwNPTE/Hx8Xj55ZeRlZWFVatWYePGjejWrRsAYPXq1WjcuDGOHTuG9u3bY/fu3UhKSsKePXvg5eWFFi1aYM6cOfj0008xc+ZM2NnZCXFqREREJACzbSl6UVZWFgDA3d0dABAfH4/8/HyEhIQot/H394efnx/i4uIAAHFxcQgMDISXl5dym7CwMEilUiQmJpZ6LKlUqvKSyWSGOCUiIiLSgUwmK3Gv1oRFJEVyuRwTJkxAx44d0bRpUwBAWloa7Ozs4ObmprKtl5cX0tLSlNsUT4iK1hetK42vry9cXV2Vr+joaD2eDREREVVEdHS0yn3a19dXo8+Z7eOz4iIiInDhwgUcPnzYKMdLSUmBRCJRvheLxUY5LhEREZUvKioKkZGRyvdSqVSjxMjsW4rGjh2LHTt2YP/+/ahZs6Zyube3N/Ly8pCZmamyfXp6Ory9vZXbvDgareh90TbqSCQSlReTIiLTN6itZt8UNdXVv5pe90dE+iMWi0vcqzVhtkmRQqHA2LFj8fvvv2Pfvn2oU6eOyvqgoCDY2tpi7969ymWXL19GcnIygoODAQDBwcE4f/48MjIylNvExMRAIpEgICDAOCdCRGbJ31uCpe+0FDoMItIjs02KIiIisH79emzcuBEuLi5IS0tDWloanj59CgBwdXXFiBEjEBkZif379yM+Ph7vvfcegoOD0b59ewBAaGgoAgICMGTIEJw9exa7du3C1KlTERERwdYfIipXn2Y+QodARHpktn2KVqxYAQDo0qWLyvLVq1dj2LBhAIBvvvkGVlZWGDBgAGQyGcLCwrB8+XLlttbW1tixYwfGjBmD4OBgODk5ITw8HLNnzzbWaRAREZGJMNukSKEov3iavb09li1bhmXLlpW6Ta1atfD333/rMzQiMkFWIpHQIRCRiTPbx2dERJqytRZhfPcGQodBRCbObFuKiIg0sSfyZTiJbeApsdd5H28G1cSW+NvK914uuu+LiEwXkyIismj1PV002q53YHX0beGD0eviS6z7on8g2tX1wOGr99C9sReqOHEKICJLxKSIiAjPJnmt5+msdp2ttRXeCKqJN4Jqql1PRJaBfYqIiIiIwKSIiIiICACTIiIiIiIATIqIiAAAGpQ+IyILx6SIiIiICEyKiIiIiAAwKSIiAsDHZ0TEpIiIKpHPevkLHQIRmTAmRURUaYx+uR76NKuudl39Ugo3ElHlwYrWRFSpVHUWq7xvXF0CRztrRHStj7tZTwWKiohMAZMiIqpURCLV9/+Mf0n57zoeTqhZxQG3HzE5IhKKi71wqQkfnxER/cfKSoRtER2xdnhboUMhIgEwKaokvng9UK/78/fWbOZxIlMjgqjM9VWdxejcsJqRoiEiU8KkqJIY2MZXr/uzs+GPDhERWRbe2UgnrOlC5urFPkVEREWYFBEA4KUGVbXaXoHKnRW92txH6BCoDPa2VvBzd8S3A1sIHQoRmRGOPqskyvt2XLOKo0GOW81FjHuPZQbZt1D2RHZG3apO2H72rtChUCnCO9RGVM/GatfZWD//ZbC2YrMRET3HliIyqCC/KkKHoHf1PZ1hpcPNtLSigZZqYkhDoUNQ6/2X60H8X5+41cPaCBwNkXo13ByEDkEw2j650CcmRWRQ9rb8ESuy9J1WQodgNCIRMD6kgdBhqOXuZIdDk7ti14SX8TJHmRGZnOl9mgh2bN6xSCcOttYabfdpT841ZQx/fdRJ6BBUONkJ+2TezrrsP22eEns0YlkJ0pCTnWZ/70g/3BxtBTs2kyICADhq8Uvfvq47XtOwo3F1V8tqAt44sl2FPv9B53p6ikRVEx9Xg+zXHDmLbTDypbpCh0FEZohJUSUheqGndetaVTCuW30Az57ftqntrtF+LswKw8+j2qNnoP76x7TwddPbvgytQ/2KPev2kojL38gCKASq2RA7qQsOTe4KVwfjfdOsW83JaMciIsNiUlRJ/TqmAz4ObYQrc3ti3Yh2CA3wwksNqsJLIkZogFepn3MW20AkKq8msHYGBNVESOPSj2lJBrX1EzoEi1bLwwlVnOyMeswVg4NQRcDm/rLs/6SL0CEQmRUmRRaqqBWoPEWVqa2sRFg3oh3ipnTH5B6NDBlaCe+09cPXbzY36jGFYq9hXyxdvN9ZP4+Mfv0gWC/7qSwaebvg2Gfd4S2xFzoUFeO61Uedqk4Y0r6W0KGYvck9Kk/fyE8r0bmqw6TIQul687WyEqG+pwt+HNZab7EE1Sp7WL61lQiujrYqtZR6m+DwdWM+ktHFhO76GQLfurY7Wvq56WVfY7oYpg+VqRHbWONHExveb1tOZ3PSTHT/QLzTrvK08FZ1Nm5Lq6nhbw2p1c2/5OOsle/qNqR83Yi2+GV0e60+U83Z9Pre/Damg9AhlMnBBEfIfNStAUIaewodhlEE+EiEDkFFRbp1mWqNKSEMausnWIIZ3V+/E3lrQpMfm/8NLftL8/dDgvQTjADMNik6ePAgXn31Vfj4+EAkEmHbtm0q6xUKBaZPn47q1avDwcEBISEhuHr1qso2Dx8+xODBgyGRSODm5oYRI0YgOzvbiGdhPtaPaIceTZ+33rjYl99qMqxDbQCAo50N2tf1KHd7U68tXN/TWegQzI6DnTWGBtcWOgzS0viQBpDYc8IDoZlqH8TyWv9Dm3gbKRL9M9ukKCcnB82bN8eyZcvUrl+wYAEWL16MlStX4vjx43ByckJYWBhyc3OV2wwePBiJiYmIiYnBjh07cPDgQYwePdpYp2Bw1V2f9XFo6KX/m7mdjRV+HlWy9ae5rxtWvtsKk8Ia4ZMw4/ZNooqbZID/Zy9+8zzxeXe0q6PZaEdtfN5L/bQe9JyNlUjjyuqm2PJIZGhm+1WgZ8+e6Nmzp9p1CoUCixYtwtSpU9G3b18AwE8//QQvLy9s27YNAwcOxMWLF7Fz506cPHkSrVs/awpcsmQJevXqhf/7v/+Dj4/5T/j565gOiElM08vweXVzpwXXK9n6IwJUWpQqon+rGth6+g6AZ8UJo/++hJZ+bliy75pe9q+phl7OmCJQEUp3Jzs8zMkrc5vZfcuv/lrf0xnXMspvBX23nf475b44PN/TxR6D29fC8ZsP9XqcJjVM6/GVqXqxPIc+DWrrh32X0pEutaz5DoXwZuuaQodQKZltUlSWmzdvIi0tDSEhIcplrq6uaNeuHeLi4jBw4EDExcXBzc1NmRABQEhICKysrHD8+HG8/vrrpe5fKpWqvBeLxRCLTasPjMTBFjXcHDCsYx2hQ9GYlUgEebEb6KzXmqClrxta+lVBEx9XrP+vcKKxk6LdEzsb9XhF7G2tEBfVDY2m7iyxrru/J6J6+ePfB0/QpVHZfXa+GxIEhUKBD9af1vjYDT1dcCY5U9uQlYSpUlR5DQ2uhZ/i/tVoW02rM+tSeCO6fyAUiqa4ly3D7sR0TN12Qet9AICLvQ0e5xaUuU0LXze09HPD6iO3dDqGqTNUoVdjcbSzxpO8QsGOL5PJIJM9T85fvG+Xxmwfn5UlLS0NAODlpdpZ2MvLS7kuLS0Nnp6qNxMbGxu4u7srtymNr68vXF1dla/o6Gg9Rq8fb7Qq+S2jfd1njyzef9lw1X4r8iX0f+HPElRbaxE+7FoPLva2GBJcG01rVM5qzdYiEcQ2qjewUS/VwfoR7bBscCvU93RB98Ze5c703sRHAm17bLWvp7/HW0yQDGvlu60wNFjzFr6PQxtpVcFeWyKRCJ4u9nhXx1IADb2cNXqMW8vDETNeNewcWe4VqHlV3lQzZfH3dlGOIO5spvPzje+u+9yH+mjMjI6OVrlP+/r6avQ5i0yKDC0lJQVZWVnKV1RUlNAhlWBrXfKnau3wtvgjoqNB61BU5Ge5SyNP/Dm2I/ZGdoGnS+k1X6b2bgyRCBjYRrMfcnPyduuyz8nOxgqdGlQ1aL0joGIjl4TS0Mv05zIzxOzfPZpWh41VyT/lpd1YqrmIETelu86jSYtzEbAz9sA2hu+EXPwS9myqeefhBp7O2FKBel+dilXON0SfUG3VcFOdrsnWpvzUoSIJpT5ERUWp3KdTUlI0+pxFJkXe3s9+eNPT01WWp6enK9d5e3sjIyNDZX1BQQEePnyo3KY0EolE5WVqj85KI7axRnNfN1iV07IgpGY13eDn4VjmNiNfqouzM0Ixf0AzrfdvTlOK6Lfvh36ynJ9HtceMVwP0si99q6rnMg5/fdQJg9r66bWYZSMDJW61PBxRT4vpRlwdbVGtjC8emuqgpl+hsajr02hI0f0Dy+zMv/SdlvCW2GNSWCPERHZGc183neqt9WzqjYmvaFcSwdB13V4sDOsstkG4Fq2TQhCLxSXu1ZqwyKSoTp068Pb2xt69e5XLpFIpjh8/juDgZ3/ggoODkZmZifj4eOU2+/btg1wuR7t2FZv0kwxPokFJAHVW6OHbcZEBah5RGsJXbzxP/sobomvIApNVncVoW0fzyYCV1ORjppuWP9fExxXR/QPRWsN5ATVhqD7OIpEIv0d01PM+9bo7vRKi9cTN0Q6jXq5bautYn2Y+OPZZd0R0fT6bwOzXmuCVAC+tij+ueDcITmLtW+BWv9cGoQFeaF5Ts+4G2iTo76j5uzOrb1Oc+Ly7xvswF2abFGVnZyMhIQEJCQkAnnWuTkhIQHJyMkQiESZMmIC5c+fizz//xPnz5zF06FD4+PigX79+AIDGjRujR48eGDVqFE6cOIEjR45g7NixGDhwoEWMPBOKIUe2VNSQ9rVQ3dWh/A01pGsC8usHwWjl54bpfVRbXJqV8sesf6ua+N/Q1tg+thNqVim7FW3Ne4arqrxjXKdy+y8VKb6VohL1Kir+/3D72E4l1uv7sWTx/oHaflGwMeEW4/L8/dFLyn8HVDfcqMOK/jnzcBbjh6Gt8cXrhi3CKALQtZEnvh/aWuPJvbVhU0r/KCsT/nuvK7NNik6dOoWWLVuiZcuWAIDIyEi0bNkS06dPBwBMnjwZ48aNw+jRo9GmTRtkZ2dj586dsLd/3mS8YcMG+Pv7o3v37ujVqxc6deqE77//XpDzMXWW8KOv7uY8rENttK5VBW3ruKNDPQ/U8nDEfANXkW1d2x1bP+yI4Z1URwaufa+t2u2trUQICfBCoAbfAFv6lSyqJhKJ9HIz9v6v7pUpJ75CW/luEEZ2qoM177XR6P+Xrn7/sAO+HxKEj0N1rysVWMNV2eJi6J95baj7WZ33elOV96XdpLUxMaShbo+CzTDHf7FPkDbmaFDyQx0zvEwAzHhIfpcuXUrUPylOJBJh9uzZmD17dqnbuLu7Y+PGjYYIz6hmvBqAWduTVJaZ6w+ksUkcbPFrsek7FAoFzt7O0uizbWpXwY9HbgIA+rbwwR8JdysUi7FndzcWTROy74YE4f118aWuf6edHzYeT9ZTVIbh4+aAqX0M0+dKYm+Dua8Hopa7I5pr0TeueF+r4v31rKxE2D6uE1Izc1G7qhOmbD2vdUzlDdtfN6Itxv+SUG6trfLY2+h/YMH4kAbYfrZiv7NC0OVvzeYPgtFx/j6djjfYALXLyqNLOQh9MduWInpOyJFC2swMXrxvjKnSphWkR1NvfNC5Hl5vWaPEozBdGepRk7F/RHQ5nls5jyNnvWbY4dfGUJFGNltrK7zW3EerhAgARr1cB7U8HOHqYIsVg1XnpBLbWKN2VfUdtDUJtbyf15caVMOpz0PK3Ia0M6df0/I3eoG6BoQJIZoNmS8amNPjv6k7ivelLOtnxFzbk822pYhMw+b3g/HyV/uV78v6RahnYXOHiUQiZaVruVz/aYcQf1RMtf+Pk511pZv1fdZrTTDjz0Tle20TqqL7oKOdDfZ93AX5hXKDl3JQR5fRrs1quin/3bWR6dfpqegEqLU9HHHrwRMs0GBErbq+Yx3qPR/CX6OKZo/KOjeqhu+GBEEEYHQZLbRFFg9qifN3sjTuyG2uKtdfGdI7Pw/HCv2StDXAHFilMWSLmmmmEqaL3ZLKF96hNvq20M+gD2srkSAJka5a+Lrh816N8UZQTXz5RjOT/f3qFeiN/Z90qfAEqDs+egkHPumCt9TUXlP3d+vFVp63i31ucLta5U7YCjx7RBXWxFvj2O1srBBUq4rG/blM9f9ZeZgUUYWFFStqFqblH4cVg/U3RF5TxWuN6OumQ6VrUyzxLWvqAnbgpuJGvVwX//dm8zILuQrNWWyDOqU8ftSGrbWo1MeY6vi80HG6+KhQOxsr/FasnySgPrHSx6+bo13Jh02D2qovQKvpRMRC4+Mz0kwZv0AjO9VFhlQGkQgY1rG2Vrv10HPBPU2Ed6gNN8dnc8PVq2ZZj/TUMVaq0crPDafVzJcmsbfFP+NfwsVUKXrpYXJiMg5NklRjdYi19HRZ21bsmho+IjM0BztrfPVGM0z69Zxy2aQw9TMm/N+bzbHjXKqxQtMZkyKqMDsbK8zUoBPsi3/YRhtwDray2NlY4c1yptOwNK3UDNUviz7rOQFA4+oSNDZgPRl9Vp02JGO2hplrw5sxH7u0rq3d70VFvN3aF5tOaTbVhJACi801qcm0NG+29lVJijSdV++VAC/cz5apnXhayJ9dPj6zUObQKfWzMkrmV8RHpUxEqOkfWyHvJW6Oz4flV5PorxWtqMZQkdAAr1K2fKZ9XXe8GaRdxe6K3swq8odQn1WnTYmpzUFnjJvV/73Z3PAH+U91VwcM61DbKMea2qcxpvcJ0EsCX61YC7umBVU11bi6BLNea4K3WtfE1zr8v9D0Z/aHoa3x+4f6rcKuD6Z/56RyvfgzaA5D3w3p1WbV8d2QIGwc1Q52GkxcKKSqzs+SoO7+ngCAiK714eFkBwdbayx7R7/9rd4r9mizvHmjRCIRvjLgzUndYxczbdiosLL6WakS9goNaV+rxE3yxQKkFbFicCvsGNfJ6PMTdv3vd089/V1zF3tbDO9UB61ru2Plu6qj1bStLt7AywXDOtRGA0/nEv2H9CG8Q20seKM5PDUsuTLqpWc/B018JLC3Ne2/ueXh4zMLVNk7rIpEIq07fAvlz7GdcOTafeUIEFcHWxyZ0g15hXKd53d7UdGoo49DG+FRTh4c7KwxpH2tEgU/1Qlp7Ik9FzMwWIu5mwDTa+EwZaZaBqG4sCZemNOvKQ5dvaeyXJ8T3DbydkFdA/bxq+Joi0dP8g22f230aOqNdSPaYtPJFLzW3EenCt2adFkwlsk9/NG5oSea+bqa/f2HSRGRgHzcHEr0b7K3ta7Q8OmmNSS4cEcK4Fn/Kff/KmU7i22waGBLrfa14t0gJN2Vommxfgal/ckzxp9CZ7ENsmUFKss06fdgKjrVr4rvD94osfz/3myOT7acFSCiipE42KCRlwsupz9WmYfN1OwY1wkOdtbo/nVshffVto479l7KAAA0rEBS+FKDanipgeFqME3vE4DlB67j49CGBjtGEVtrK3Qq5/dQ34/5DIVJEWlErIfHUEJ/g6gsrRdLBrXCe6tPwNvVHutGtKvQvmytrTSuoGyMy/vH2I7YduYOXmvug8PX7iPprhSTwnSf/8vYXm5YDZ/18scXf19SWd6/ZQ14ScQYsuqEQJHpRiQSYdP77XH2dhY6lPNI1lBm9W2CN1fGlblN0xquuJP5VC/H+6J/ID5YH48qjnYYGlxbL/s0hOGd6uC9jrUhEomQ/OCJ0Y//4oTZttZWmNOvKf44cweTe6gfoWYKmBRRqZa+0xIf/XwGAT4SrUcvCal47mUe3030q05VJ+z/pEu5SWjzmq4az/Omb018So5E0yRnrlfNWTkJagM9ProxptEv1yuRFFlZiQzaamBIbo526NzQsLGX9bPRupxChf1b1tBrLF4Se5PsIKyOkF9EX2nshZZ+briano1V4a0BPOuXNqR9+XOpWQsYt3n3iCK1tO20V5o+zXxw/LMQ/BHRSfBWHmPSZeSetZUI7YxYnbs8mvz/Wju8bYkOn8ZSu6oTFr5VsiN3j2J9wVzElvudbXKP561brzU3/QKiptzK+uLPehVH/fTFo4qxshJh65gOODU1BO3qat6KuCq8tU5Tw+gLkyIL0KdZdSwZ9KyvSFVnO/QM1F8n42ouYrN5Fqwvjau7oIWvG0QiqL1xl+anEW2xY1wnrSfsFIqbox16NPVWVvUW21jBRU+duzXRv1XJIf9zX2+KHk28MaxDbfRoah6d5XUxolMdzOnbBN8PCUITn9KnySley8vYE+Ia+3uQvvKuocG1Szy6ASpnq3ERoTrzi0TaTS9jZ22F7o3LLhdiaJb7VawSWPpOS/i5O8JLYo9Xm/ugkbcLvF3tIbYxnzmODK1j/arY91+nSH9vzR63iEQi/DamAx5kyzQekgo8m3G8aQ1XmFsOObdfU3SsXxXt6rgbPQF2d7LDw5w8AICniz2qOoux8r/JNSf/an4djzUltrHGEA36ozSt4YqfR7XH49x8hAh8szAn47rVx9y/LgIA3tCy3hZVbkyKzFifZqrN7hUZCWFJin9LnN8/EBEbT8PdyU6rYeXWViKtEiJz5mJvi7f0UOFbl0csP49qj9k7EvFSg2rwdXdUWRdczwObT90GALzWQr/9Qoyld7Pq+KuCUxuUV1OquIiu9bBs/3UAzyoGV1ZDg2vD2koEN0dbdKhvPqMT1XEs9hhZXQsY6ReTIjIaQ7dBNK/pip6B1VG1WLVXT4k9tnyg/+JmVJKT+HkLpZuG/Toaebtgw8j2atf1bV4Dl1If40FOHqJ6me5olbJ83qtxhZMibYzt2gBVHO1Qs4qDXqdVKcp33RzsytzOVNjZWOG9jhUvLDm8U+2KB1NBo16qg3VxtyDNLVB2WNZWeRPC1nBzwJ3Mp2hjxGlPTBWTIrIYWz7oYPIVrC1ZRNf6OHc7C0/zCvXSgdvKSoQoA00FYywSI3+zd7CzxsiX9FMvSF2fosCarujTrDqO3XiAJYP0W3Hdt4pj+RsZ2Qg9VuzWlYu9LQ5/2g05sgKDtV7/OiYYsZfvKYvIVmZMiszU1N7mfbMgy+PmYIejU7rhaX4hPF0qx6NHffthaGusPXoLI18S/mZcmqXvtIJcrtDrCKEBrWoa/AuNl8Qeni5iZDyWqUx5UxZT6Z/pJLaBkwFHY1Z3dcDAttpVrTcIE+iPyaTITJnCNxhTYw7TJViymu4OcLG3NeoINkvzSoCXYH2B3gyqiS3xtzXqe6fvIdN1qzmVuV4fI+GsrUTYPq4TziRnoqu/edaEIsNjUmSGHGytK1XdIDItbo62qO3hiFsPnuC15j6o7eGIdnU99DZXGwljwRvN8EGXeqhbtWSCYsp1il5UVqheEvsSpR7qeDw/XztrK+QVyg0UGZkDJkVkNP7VXWBva4XcfDne72y68yRVlJNdyV8rbwsaySYSifDrmA44m5KJTg2qmswjBqoYkUiEesUmZBWZwrMMI/DzcMSs15rgxK2HeDOoJoatPil0SHpnRjmt4NgrlYxGbGONmImdsWJwK0S+YvhJCoUyt19T2Fo/v6E42lnjh6G6jRoxVVWdxeje2IsJUTmEnK7AlLxq4lW7wzvUxrJ3WsHP3fQ6e5NxsaWIjMrX3bFEPRpLU7uqE45M6QYAqOJoh9z8QvazqaQc7KzRO7A6/rmQitl9mwodjmDm9G2CWu6O+P3MHb1NzEqak9iXvNVXlpZAbTEpIjKA4qOvdJlLjSzH0ndaQpobaHaF9+xtn//c2tlU7Abq5miHT8IaITe/EP87fLOioZGWPIrVbqOy8a81EZEBiUQis0uIAGDhWy0gEj2bYPozPdWLYt8WMnVsKSIiohKa1nBF7CddYWdjBW9XYQcKlPeoJ6yJF3YlpgMAWviWPsEumTZTeKDHpIiIiNTy8zCP/n/zXg+ErbUVfN0d0bWRp9DhkBljUkRERGatqrMYS9+p+LQjrP9G7FNERESCYusOmQomRQCWLVuG2rVrw97eHu3atcOJEyeEDomIyOJNCmuEpe+0RICPROhQiAAwKcKmTZsQGRmJGTNm4PTp02jevDnCwsKQkZEhdGhERBal+ES3K98NQkTX+ujTzLQLO1oqPilUr9InRQsXLsSoUaPw3nvvISAgACtXroSjoyN+/PFHoUMjLbF6MJFpq+7qgJiJL+PnUe0R1kSYiW+JylKpO1rn5eUhPj4eUVFRymVWVlYICQlBXFxcqZ+TSqUq78ViMcRiFscSwub3g7Fg5yX0bVkDNiySSGTyGni5oIGW+VBX/+d9jqb09NdzRGSJZDIZZDKZ8v2L9+3SVOq7yP3791FYWAgvL9XfUC8vL6SlpZX6OV9fX7i6uipf0dHRhg6VStG2jjt+HdMBQ9rXEjoUIjIQVwdb7Il8GSvfDcKITnXK/4COfNye12Pq06y6wY5D6rXyq6K3fUVHR6vcp319fTX6XKVuKdJVSkoKJJLnHQPZSkREZFj1PV1Q39PFoMcQ21jjn/Ev4dSth3itRQ2DHoueqeYixr3Hz1p0nNXM0aarqKgoREZGKt9LpVKNEqNKnRRVrVoV1tbWSE9PV1menp4Ob2/vUj8nkUhUkiJjm9yjkWDHJiKyZI2rS9C4OkfDGYvYxjAPrHTt1lKpH5/Z2dkhKCgIe/fuVS6Ty+XYu3cvgoODBYysbO/yUREREZHeVeqWIgCIjIxEeHg4WrdujbZt22LRokXIycnBe++9J3RopeKs60REVBEcq6tepU+K3n77bdy7dw/Tp09HWloaWrRogZ07d5bofG0qqgs8MSMREZGlqvRJEQCMHTsWY8eOFTqMcjXwdMYPQ1sLHQYREZFF4nMYMzK1TwBqV3USOgwiIiK9MLWau0yKiIiIiMCkiIiIiAgAkyKzYmKtjERERBaFSRERERERmBQRERFVOiJT6+FsIpgUEREREYFJEREREQlEoRA6AlVMioiIiIjApIiIiIgIAJMiIiIiIgBMioiIiIgAMCkiIiKqdExlQL6pVQZgUkREREQEJkVEREREAJgUmRUTK+dARERkUZgUEREREYFJEREREREAJkVEREREAJgUEREREQFgUkRERFTpmEp9IE4IS0RERGSCmBQRERERgUkRERERCcRUHuMVYVJEREREBCZFRERERACYFBEREREBYFJERERU6YhMrTOPiWBSRERERAQmRVRBMpkMM2fOhEwmEzoUi8brbBy8zsbDa20cRdeZNGOWSdG8efPQoUMHODo6ws3NTe02ycnJ6N27NxwdHeHp6YlJkyahoKBAZZsDBw6gVatWEIvFqF+/PtasWWP44CugRU03oUMoQSaTYdasWfzDZmC8zsbB62w8vNbGUXSdSTNmmRTl5eXhzTffxJgxY9SuLywsRO/evZGXl4ejR49i7dq1WLNmDaZPn67c5ubNm+jduze6du2KhIQETJgwASNHjsSuXbuMdRpac3W0FToEIiIii2UjdAC6KMp6S2vZ2b17N5KSkrBnzx54eXmhRYsWmDNnDj799FPMnDkTdnZ2WLlyJerUqYOvv/4aANC4cWMcPnwY33zzDcLCwox1KkRERGQizDIpKk9cXBwCAwPh5eWlXBYWFoYxY8YgMTERLVu2RFxcHEJCQlQ+FxYWhgkTJpS6X8V/M9fduXMHUqlUuVwsFkMsFuscr1z2RKPtih/TVBTFZIqxWRJeZ+PgdTYeXmvjKLq+L95nTOW6F+TmQC7LBQDInmTrLS6ZTKbyaPbx48cAnt/HS2ORSVFaWppKQgRA+T4tLa3MbaRSKZ4+fQoHB4cS+y26qAEBAYYIu1yuiwQ5rEZ8fX2FDqFS4HU2Dl5n4+G1No6URW+pvDfF+8k6AOvU94rRm8ePH8PV1bXU9SaTFE2ZMgVffvllmdtcvHgR/v7+RoqoJB8fH1y/fh22trYqNR4q2lJERERE+vNiS5FCoUB+fj58fHzK/JzJJEUff/wxhg0bVuY2devW1Whf3t7eOHHihMqy9PR05bqi/xYtK76NRCJR20oEAFZWVhrHQERERObFZJKiatWqoVq1anrZV3BwMObNm4eMjAx4enoCAGJiYiCRSJSPvoKDg/H333+rfC4mJgbBwcF6iYGIiIjMi1kOyU9OTkZCQgKSk5NRWFiIhIQEJCQkIDs7GwAQGhqKgIAADBkyBGfPnsWuXbswdepUREREKB9zffDBB7hx4wYmT56MS5cuYfny5di8eTMmTpwo5KkRERGRQESK8rpim6Bhw4Zh7dq1JZbv378fXbp0AQD8+++/GDNmDA4cOAAnJyeEh4dj/vz5sLF53jh24MABTJw4EUlJSahZsyamTZtW7iM8IiIiskxmmRQRERER6ZtZPj4jwzh48CBeffVV+Pj4QCQSYdu2bWVuf/jwYXTs2BEeHh5wcHCAv78/vvnmG5VtCgsLMW3aNNSpUwcODg6oV68e5syZU26tCEtmiOv8+PFjTJgwAbVq1YKDgwM6dOiAkydPGvAszIO217q4I0eOwMbGBi1atCixbtmyZahduzbs7e3Rrl27EgM7KhtDXOeK7NNSGeI6R0dHo02bNnBxcYGnpyf69euHy5cv6zdwM8KkiJRycnLQvHlzLFu2TKPtnZycMHbsWBw8eBAXL17E1KlTMXXqVHz//ffKbb788kusWLECS5cuxcWLF/Hll19iwYIFWLJkiaFOw+QZ4jqPHDkSMTExWLduHc6fP4/Q0FCEhITgzp07hjoNs6DttS6SmZmJoUOHonv37iXWbdq0CZGRkZgxYwZOnz6N5s2bIywsDBkZGfoK2+wY4jrruk9LZojrHBsbi4iICBw7dgwxMTHIz89HaGgocnJy9BW2WeHjM1JLJBLh999/R79+/bT6XP/+/eHk5IR169YBAPr06QMvLy+sWrVKuc2AAQPg4OCA9evX6zNks6SP6/z06VO4uLjgjz/+QO/evZXbBAUFoWfPnpg7d66eozZP2lzrgQMHokGDBrC2tsa2bduQkJCgXNeuXTu0adMGS5cuBQDI5XL4+vpi3LhxmDJlioGiNx/6us667rOyMMR1BoB79+7B09MTsbGxePnll/UXsJlgSxHpzZkzZ3D06FF07txZuaxDhw7Yu3cvrly5AgA4e/YsDh8+jJ49ewoVptl78ToXFBSgsLAQ9vb2Kts5ODjg8OHDQoRo1lavXo0bN25gxowZJdbl5eUhPj5eZYogKysrhISEIC4uzphhmr2yrjPpj7bXOSsrCwDg7u5uyLBMlsnUKSLzVbNmTdy7dw8FBQWYOXMmRo4cqVw3ZcoUSKVS+Pv7w9raGoWFhZg3bx4GDx4sYMTmqbTr7OLiguDgYMyZMweNGzeGl5cXfv75Z8TFxaF+/foCR21erl69iilTpuDQoUMqI1WL3L9/H4WFhWqnCLp06ZKxwjR75V1n0g9tr7NcLseECRPQsWNHNG3a1AgRmh7+NFKFHTp0CNnZ2Th27BimTJmC+vXrY9CgQQCAzZs3Y8OGDdi4cSOaNGmChIQETJgwAT4+PggPDxc4cvNS1nVet24dhg8fjho1asDa2hqtWrXCoEGDEB8fL3DU5qOwsBDvvPMOZs2ahYYNGwodjsXidTYOXa5zREQELly4ULlbmBVEagBQ/P7771p/bs6cOYqGDRsq39esWVOxdOnSEts0atSooiFaBH1d5yLZ2dmKu3fvKhQKheKtt95S9OrVq6IhWozyrvWjR48UABTW1tbKl0gkUi7bu3evQiaTKaytrUvsZ+jQoYrXXnvNsCdgJvRxnbXdZ2Wk7+scERGhqFmzpuLGjRsGjty0saWI9Eoul6tMwvfkyRNYWal2XbO2toZcLjd2aBblxetcxMnJCU5OTnj06BF27dqFBQsWCBCdeZJIJDh//rzKsuXLl2Pfvn349ddfUadOHdjZ2SEoKAh79+5VdnCVy+XYu3cvxo4dK0DU5keT60wVp+l1VigUGDduHH7//XccOHCg0l9/JkWklJ2djWvXrinf37x5EwkJCXB3d4efnx+ioqJw584d/PTTTwCe1Wrx8/ODv78/gGc1NP7v//4PH330kXIfr776KubNmwc/Pz80adIEZ86cwcKFCzF8+HDjnpwJMcR13rVrFxQKBRo1aoRr165h0qRJ8Pf3x3vvvWfckzMx2lxrKyurEv0oPD09YW9vr7I8MjIS4eHhaN26Ndq2bYtFixYhJyenUl9rQ1zn8vZZGRniOkdERGDjxo34448/4OLigrS0NACAq6trqZOjWzShm6rIdOzfv18BoMQrPDxcoVAoFOHh4YrOnTsrt1+8eLGiSZMmCkdHR4VEIlG0bNlSsXz5ckVhYaFyG6lUqhg/frzCz89PYW9vr6hbt67i888/V8hkMiOfnekwxHXetGmTom7dugo7OzuFt7e3IiIiQpGZmWnkMzM92l7rF82YMUPRvHnzEsuXLFmi8PPzU9jZ2Snatm2rOHbsmGFOwEwY4jqXt8/KyBDXWd3+AChWr15tsPMwZaxTRERERATWKSIiIiICwKSIiIiICACTIiIiIiIATIqIiIiIADApIiIiIgLApIiIiIgIAJMiIiIiIgBMioiIiIgAMCkiIiIiAsCkiIgqoS5dumDChAlCh6GVBw8ewNPTE7du3RIshoEDB+Lrr78W7PhEhsakiMhCiUSiMl8zZ84UOkS90ibR2bp1K+bMmWPYgPRs3rx56Nu3L2rXrq2yPC0tDePHj0f9+vVhb28PLy8vdOzYEStWrMCTJ08AAMOGDUO/fv1K7PPAgQMQiUTIzMzUKIapU6di3rx5yMrKquDZEJkmG6EDICLDSE1NVf5706ZNmD59Oi5fvqxc5uzsLERYgsrLy4OdnR3c3d2FDkUrT548wapVq7Br1y6V5Tdu3EDHjh3h5uaGL774AoGBgRCLxTh//jy+//571KhRA6+99pre4mjatCnq1auH9evXIyIiQm/7JTIVbCkislDe3t7Kl6urK0QikcoyZ2dnyGQyfPTRR/D09IS9vT06deqEkydPKvfRpUsXjB07FmPHjoWrqyuqVq2KadOmofg80uXtAwDkcjkWLFiA+vXrQywWw8/PD/PmzVOui46ORp06deDg4IDmzZvj119/Vfl8ly5d8NFHH2Hy5Mlwd3eHt7e3SkvXsGHDEBsbi2+//VbZEnbr1i1l/BMmTEDVqlURFham3F/xVqWy4lOnV69eCA8PV77fv38/qlatisLCQs3/B2nh77//hlgsRvv27VWWf/jhh7CxscGpU6fw1ltvoXHjxqhbty769u2Lv/76C6+++qpWx7l165baVsUuXboot3n11Vfxyy+/6OO0iEwOkyKiSmzy5Mn47bffsHbtWpw+fRr169dHWFgYHj58qNxm7dq1sLGxwYkTJ/Dtt99i4cKF+N///qfVPqKiojB//nxMmzYNSUlJ2LhxI7y8vAAA0dHR+Omnn7By5UokJiZi4sSJePfddxEbG6sS69q1a+Hk5ITjx49jwYIFmD17NmJiYgAA3377LYKDgzFq1CikpqYiNTUVvr6+ys/Z2dnhyJEjWLlypdrrUFZ86tSoUQN37txRvu/cuTOePn2KY8eOaXrptXLo0CEEBQWpLHvw4AF2796NiIgIODk5qf2cSCTS6ji+vr7K65eamoozZ87Aw8MDL7/8snKbtm3b4sSJE5DJZNqfCJGpUxCRxVu9erXC1dVVZVl2drbC1tZWsWHDBuWyvLw8hY+Pj2LBggUKhUKh6Ny5s6Jx48YKuVyu3ObTTz9VNG7cWON9SKVShVgsVvzwww8l4srNzVU4Ojoqjh49qrJ8xIgRikGDBinfd+7cWdGpUyeVbdq0aaP49NNPVbYZP368yjadO3dWtGzZssRxi29bVnylmTFjhqJRo0Yqyzw8PBRbt27VeB/FXb9+XfHHH3+Uur5v376K4cOHqyw7duyYAkCJY3p4eCicnJwUTk5OismTJysUCoUiPDxcYW1trVxe9LK3t1cAUDx69KjEMZ8+fapo166dok+fPorCwkLl8rNnzyoAKG7duqXTuRKZMvYpIqqkrl+/jvz8fHTs2FG5zNbWFm3btsXFixeVy9q3b6/S4hAcHIyvv/4ahYWFGu3j4sWLkMlk6N69e4kYrl27hidPnuCVV15RWZ6Xl4eWLVuqLGvWrJnK++rVqyMjI6Pc83yxheVFZcVXmhdbihISEpCZmYng4GCN91HcP//8g8ePH5fa/+fp06ewt7fXaF8nTpyAXC7H4MGDVVpzunbtihUrVqhse/z4cbz77rtq9zN8+HA8fvwYMTExsLJ6/lDBwcEBAJSduIksCZMiIjKoopuoOtnZ2QCAv/76CzVq1FBZJxaLVd7b2tqqvBeJRJDL5eUev7RHS5rEV5oaNWogOzsbUqkUzs7OmDhxIgYPHgxvb28AwLlz5xAREQGpVIq6devil19+wcCBAyEWi3H9+nU8fPgQmzZtQuvWrREbG4tp06bBw8MDmzZtwuHDh0vEXLVqVTx69EhlWf369SESiVQ6zwNA3bp11Z6Xk5MT6tevr7Ls9u3bas9v7ty52LVrF06cOAEXFxeVdUWPRatVq6bJpSIyK+xTRFRJ1atXT9nXpkh+fj5OnjyJgIAA5bLjx4+rfO7YsWNo0KABrK2tNdpHgwYN4ODggL1795aIISAgAGKxGMnJyahfv77Kq6hPkKbs7Ox06uhcVnylKUrgbt++jU8//RRpaWlYsmQJACA3NxcDBw7E//73P5w9exY+Pj7YsGEDzp07h1atWuHkyZOYPXu2st5P586d0axZM8TExODMmTNqk7iWLVsiKSlJZZmHhwdeeeUVLF26FDk5OVqfd2l+++03zJ49G5s3b0a9evVKrL9w4QJq1qyJqlWr6u2YRKaCLUVElZSTkxPGjBmDSZMmwd3dHX5+fliwYAGePHmCESNGKLdLTk5GZGQk3n//fZw+fRpLlixR3tA12Ye9vT0+/fRTTJ48GXZ2dujYsSPu3buHxMREjBgxAp988gkmTpwIuVyOTp06ISsrC0eOHIFEIlEZ4VWe2rVr4/jx47h16xacnZ01HnZfXnzqFCVFH3/8Ma5cuYKDBw9CIpEAALZt24aePXuiUaNGAAB/f3+kpKQgNzcXH3/8MQCgcePGWLdunco1frH+UHFhYWGIiorCo0ePUKVKFeXy5cuXo2PHjmjdujVmzpyJZs2awcrKCidPnsSlS5fKfXT4ogsXLmDo0KH49NNP0aRJE6SlpQGAShmDQ4cOITQ0VKv9EpkLJkVEldj8+fMhl8sxZMgQPH78GK1bt8auXbtUbrxDhw7F06dP0bZtW1hbW2P8+PEYPXq0VvuYNm0abGxsMH36dNy9exfVq1fHBx98AACYM2cOqlWrhujoaNy4cQNubm5o1aoVPvvsM63O5ZNPPkF4eDgCAgLw9OlT3Lx5U+PPlhWfOlWrVoVYLMa///6L2NhYlUd/Fy9eVGlpS0xMRI0aNdCkSRNYW1sDAE6fPo3AwEAAz1qbfHx8yowvMDAQrVq1wubNm/H+++8rl9erVw9nzpzBF198gaioKNy+fRtisRgBAQH45JNP8OGHH2p8DQDg1KlTePLkCebOnYu5c+cql3fu3BkHDhxAbm4utm3bhp07d2q1XyJzIVIoihUcISIqpkuXLmjRogUWLVokdChmY+XKlbh+/Tq++uorJCQkYOjQoYiIiMDChQtx4cIFSKVSdOvWDVu3bkW9evVw5MgRLFq0CFu2bClzv3/99RcmTZqECxcuqHR8NqYVK1bg999/x+7duwU5PpGhsU8REZEeDRkyBElJSWjatCnGjh2LTZs24dy5c+jVqxeCgoLQpUsXzJ8/X9lfp2nTprhx4wYCAwNL9Bsqrnfv3hg9erTKqDdjs7W1VfadIrJEbCkiolKxpUg/XnrpJWzcuFHrzuNEZFxMioiIDKxu3bq4ceOG0GEQUTmYFBERERGBfYqIiIiIADApIiIiIgLApIiIiIgIAJMiIiIiIgBMioiIiIgAMCkiIiIiAsCkiIiIiAgAkyIiIiIiAEyKiIiIiAAwKSIiIiICwKSIiIiICADw/3eLs5qQsUScAAAAAElFTkSuQmCC", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "ta2 = sb.timeaverage(weights='tsys')\n", - "ta2.plot(xaxis_unit=\"GHz\", ymin=-100, ymax=800, yaxis_unit=\"mK\", title=\"PLNUM=0\")" - ] - }, - { - "cell_type": "markdown", - "id": "e7a4ef5f-2bf3-4bfc-8177-8a7ad793b014", - "metadata": {}, - "source": [ - "We can calibrate the other polarization, with the scan numbers already selected." - ] - }, - { - "cell_type": "code", - "execution_count": 18, - "id": "6a1bff52-fc5c-437e-9da0-787f17029b77", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - " ID TAG SCAN IFNUM # SELECTED\n", - "--- --------- -------- ----- ----------\n", - " 0 2c4cf7b1b [51, 52] 0 88\n", - " ID TAG SCAN IFNUM PLNUM # SELECTED\n", - "--- --------- -------- ----- ----- ----------\n", - " 0 2c4cf7b1b [51, 52] 0 88\n", - " 1 4a182f785 [51, 52] [0] 1 44\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "sb = sdfits.getps(plnum=1)\n", - "ta3 = sb.timeaverage(weights='tsys')\n", - "ta3.plot(xaxis_unit=\"GHz\", ymin=-100, ymax=800, yaxis_unit=\"mK\", title=\"PLNUM=1\")" - ] - }, - { - "cell_type": "markdown", - "id": "339576f4-7317-4791-aca4-b52f9f8f1153", - "metadata": {}, - "source": [ - "#### Polarization Average\n", - "Average the polarizations and plot the result." - ] - }, - { - "cell_type": "code", - "execution_count": 19, - "id": "6f9c51ab-7a04-4def-b8f8-58f6cb308660", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "avg = ta2 + ta3\n", - "avg *= 0.5\n", - "avg.plot(ymin=-100, ymax=800, yaxis_unit=\"mK\", xaxis_unit=\"GHz\")" - ] - }, - { - "cell_type": "markdown", - "id": "387bc886-512b-490f-9bd0-ade391e08327", - "metadata": {}, - "source": [ - "### All Scans\n", - "\n", - "Now we leverage the power of `dysh` to calibrate and time average all of the scans in the data.\n", - "\n", - "We start by clearing the selection, so all of the scans are available." - ] - }, - { - "cell_type": "code", - "execution_count": 20, - "id": "56a50d07-ea90-4c46-990f-012d3f7a733c", - "metadata": {}, - "outputs": [], - "source": [ - "sdfits.selection.clear()" - ] - }, - { - "cell_type": "markdown", - "id": "4d1a49f2-8279-4b26-b4c4-9e69ca7ed569", - "metadata": {}, - "source": [ - "Then, make a `ScanBlock` for spectral window 0 and polarization 0. Time average the scans in the `ScanBlock` into a single `Spectrum` and then remove a baseline." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "b11a2291-9cfd-40c4-9450-9f4e056155e4", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - " ID TAG OBJECT BANDWID DATE-OBS DURATION EXPOSURE TSYS TDIM7 TUNIT7 CTYPE1 CRVAL1 CRPIX1 CDELT1 CTYPE2 ... IFNUM PLNUM FDNUM INT INTNUM NSAVE HDU BINTABLE ROW PROC _OBSTYPE _SUBOBSMODE CHAN UTC # SELECTED\n", - "--- --- ------ ------- -------- -------- -------- ---- ----- ------ ------ ------ ------ ------ ------ ... ----- ----- ----- --- ------ ----- --- -------- --- ---- -------- ----------- ---- --- ----------\n", - " ID TAG SCAN IFNUM PLNUM # SELECTED\n", - "--- --------- -------------------------------- ----- ----- ----------\n", - " 0 76f386e98 [51, 52, 53, 54, 55, 56, 57, 58] 0 0 176\n" - ] - } - ], - "source": [ - "ps_scan_block_0 = sdfits.getps(ifnum=0, plnum=0)\n", - "ps_ta_0 = ps_scan_block_0.timeaverage(weights='tsys')\n", - "ps_ta_0.baseline(model=\"poly\", degree=2, exclude=[3800*kms,5000*kms], remove=True)" - ] - }, - { - "cell_type": "markdown", - "id": "3bcf3877-5398-4225-8d51-6833e89acd0b", - "metadata": {}, - "source": [ - "Now plot and compare with the result for a single scan." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "1ead1ef4-61eb-4080-801d-e0728990674a", - "metadata": {}, - "outputs": [], - "source": [ - "ta.plot(ymin=-400, ymax=400, yaxis_unit=\"mK\", xaxis_unit=\"GHz\")\n", - "ps_ta_0.plot(ymin=-400, ymax=400, yaxis_unit=\"mK\", xaxis_unit=\"GHz\")" - ] - }, - { - "cell_type": "markdown", - "id": "361b044d-6f40-4cc0-9c16-9f88376cfaca", - "metadata": {}, - "source": [ - "The rms in the second Figure is almost half that of the first Figure. That is because there are four pairs of position switched scans in the data, so that results in a factor of $\\sqrt{4}$ reduced noise when we average all the data." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "8a12633b-ed26-44ec-bf55-2ad4ee59e546", - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.9.0" - }, - "toc": { - "base_numbering": 0 - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} From e5d0d1e72d3b0d2c9af81320530f3bce2bf928a0 Mon Sep 17 00:00:00 2001 From: astrofle Date: Sat, 21 Sep 2024 03:58:51 -0400 Subject: [PATCH 22/95] Docs: use mermaid 11.2 --- docs/source/conf.py | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/docs/source/conf.py b/docs/source/conf.py index d0a271a5..83a9e822 100644 --- a/docs/source/conf.py +++ b/docs/source/conf.py @@ -76,6 +76,11 @@ # TODO: These appear to have no effect mermaid_verbose = True +# Mermaid configuration +# https://github.com/mgaitan/sphinxcontrib-mermaid +mermaid_version = "11.2.0" +mermaid_params = ["--theme", "dark"] + # Add any paths that contain templates here, relative to this directory. templates_path = ["_templates"] From 1a4a791bf724f9755b066a2571d257be7ebe90c9 Mon Sep 17 00:00:00 2001 From: astrofle Date: Sat, 21 Sep 2024 03:59:43 -0400 Subject: [PATCH 23/95] Add: ScanBlock diagram by Evan --- docs/source/explanations/scanblock/index.rst | 37 ++++++++++++++++++++ 1 file changed, 37 insertions(+) diff --git a/docs/source/explanations/scanblock/index.rst b/docs/source/explanations/scanblock/index.rst index c7c4ee2f..1d4988e4 100644 --- a/docs/source/explanations/scanblock/index.rst +++ b/docs/source/explanations/scanblock/index.rst @@ -3,3 +3,40 @@ ######### ScanBlock ######### + +.. mermaid:: + + flowchart TD + + subgraph newLines[GBTFITSLoad + 50 Scans + Position Switching + Dual Linear Polarization + 1 Beam + 4 Frequency Windows + 100 integrations each + ] + + + + + end + + + newLines -- getps( scan=45, plnum=1, ifnum=0 ) --> ScanBlock1 + newLines -- gettp( scan=[17,18,19], intnum=np.r_[50:100], ifnum=2 ) --> ScanBlock2 + + + + subgraph ScanBlock1[ScanBlock] + psscan["spectra.scan.PSScan
scans = 44,45
plnum = 1
ifnum = 0
intnum = (0,100)"] + end + subgraph ScanBlock2[ScanBlock] + tpscan1["spectra.scan.TPScan
scan=17
plnum = 0
ifnum = 2
intnum=(50,100)"] + tpscan2["spectra.scan.TPScan
scan=18
plnum = 0
ifnum = 2
intnum=(50,100)"] + tpscan3["spectra.scan.TPScan
scan=19
plnum = 0
ifnum = 2
intnum=(50,100)"] + + end + + ScanBlock1[Scan Block] -- timeaverage() --->spectrum1[Spectrum] + ScanBlock2[Scan Block] -- timeaverage() --->spectrum2[Spectrum] From e41c3a7e80ef36c227922b056f83a451322f62fc Mon Sep 17 00:00:00 2001 From: astrofle Date: Wed, 25 Sep 2024 12:36:47 -0400 Subject: [PATCH 24/95] Add: grid for current how-to guides --- docs/source/how-tos/index.rst | 74 +++++++++++++++++++++++++++++++++++ 1 file changed, 74 insertions(+) diff --git a/docs/source/how-tos/index.rst b/docs/source/how-tos/index.rst index 88c835e2..88e10c80 100644 --- a/docs/source/how-tos/index.rst +++ b/docs/source/how-tos/index.rst @@ -5,3 +5,77 @@ ########################################### Practical step-by-step guides to help you achieve a specific goal. Most useful when you're trying to get something done. + + +.. grid:: 1 2 2 2 + + .. grid-item-card:: + :shadow: md + :margin: 2 2 0 0 + + :octicon:`rocket;3em;green` **Velocity Definitions and Rest Frames** + + How to change velocity definitions and reference frames + + .. button-link:: examples/velocity_frames.html + :color: primary + :outline: + :click-parent: + + Velocity & Frames + + + .. grid-item-card:: + :shadow: md + :margin: 2 2 0 0 + + :octicon:`file;3em;green` **Metadata Management** + + How to interact with the metadata of an SDFITS file + + .. button-link:: examples/metadata_management.html + :color: primary + :outline: + :click-parent: + + Metadata Management + + + .. grid-item-card:: + :shadow: md + :margin: 2 2 0 0 + + :octicon:`pulse;3em;green` **Smoothing** + + How to smooth data + + .. button-link:: examples/smoothing.html + :color: primary + :outline: + :click-parent: + + Smoothing + + .. grid-item-card:: + :shadow: md + :margin: 2 2 0 0 + + :material-outlined:`save;3em;green` **Data IO** + + How to read and save data + + .. button-link:: examples/dataIO.html + :color: primary + :outline: + :click-parent: + + Data IO + +.. toctree:: + :maxdepth: 4 + :hidden: + + examples/velocity_frames + examples/metadata_management + examples/smoothing + examples/dataIO From 390972f914286a692ebdf13e064d3431549bca49 Mon Sep 17 00:00:00 2001 From: astrofle Date: Wed, 25 Sep 2024 14:16:34 -0400 Subject: [PATCH 25/95] Add: sdfits explanation page --- docs/source/explanations/index.rst | 44 +++++++++++++++++++++++ docs/source/explanations/sdfits/index.rst | 7 ++++ 2 files changed, 51 insertions(+) create mode 100644 docs/source/explanations/sdfits/index.rst diff --git a/docs/source/explanations/index.rst b/docs/source/explanations/index.rst index a7bebfce..3c9841c2 100644 --- a/docs/source/explanations/index.rst +++ b/docs/source/explanations/index.rst @@ -6,9 +6,53 @@ Big-picture explanations of higher-level concepts. Most useful for building understanding of a particular topic. +dysh +==== + +.. grid:: 1 2 2 2 + + .. grid-item-card:: + :shadow: md + :margin: 2 2 0 0 + + :octicon:`container;3em;green` **ScanBlock** + + What is a ScanBlock? + + .. button-link:: scanblock/index.html + :color: primary + :tooltip: Details of what is a ScanBlock + :outline: + :click-parent: + + ScanBlock + + +SDFITS +====== + +.. grid:: 1 2 2 2 + + .. grid-item-card:: + :shadow: md + :margin: 2 2 0 0 + + :octicon:`file;3em;green` **SDFITS** + + What are SDFITS files? + + .. button-link:: sdfits/index.html + :color: primary + :tooltip: SDFITS details + :outline: + :click-parent: + + SDFITS + .. toctree:: :hidden: :maxdepth: 3 scanblock/index + sdfits/index diff --git a/docs/source/explanations/sdfits/index.rst b/docs/source/explanations/sdfits/index.rst new file mode 100644 index 00000000..a57d6d7b --- /dev/null +++ b/docs/source/explanations/sdfits/index.rst @@ -0,0 +1,7 @@ +.. _sdfits-explanation: + +############ +SDFITS Files +############ + +This section is empty for now, but you can check the column definitions :ref:`here `, or the SDFITS convention as defined in `AIPS++ `_ or at `ADASS IX `_, or `the registered SDFITS convention `_. From 963cde8c8ed2a3ca70fac004b6a351e1d8668093 Mon Sep 17 00:00:00 2001 From: astrofle Date: Wed, 25 Sep 2024 14:16:55 -0400 Subject: [PATCH 26/95] Fix: adds custom labels to avoid duplicates --- docs/source/reference/sdfits_files/gbt_sdfits.rst | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/docs/source/reference/sdfits_files/gbt_sdfits.rst b/docs/source/reference/sdfits_files/gbt_sdfits.rst index 4118b1aa..66bd4e80 100644 --- a/docs/source/reference/sdfits_files/gbt_sdfits.rst +++ b/docs/source/reference/sdfits_files/gbt_sdfits.rst @@ -1,3 +1,5 @@ +.. _sdfits-reference: + **************** GBT SDFITS Files **************** @@ -9,6 +11,8 @@ The single-dish FITS (SDFITS) convention is used for observer-facing GBT data. T HDU 0 (PRIMARY) --------------- +.. _primary-sdfits-header: + Header ^^^^^^ @@ -41,6 +45,8 @@ Header HDU 1 (SINGLE DISH) ------------------- +.. _singledish-sdfits-header: + Header ^^^^^^ From b9ce5bfda2456cf2ef10c56a22cfadec08758a47 Mon Sep 17 00:00:00 2001 From: astrofle Date: Thu, 26 Sep 2024 15:30:31 -0400 Subject: [PATCH 27/95] Add: notebook illustrating the need to align spectra before averaging --- notebooks/examples/align_spectra.ipynb | 337 +++++++++++++++++++++++++ 1 file changed, 337 insertions(+) create mode 100644 notebooks/examples/align_spectra.ipynb diff --git a/notebooks/examples/align_spectra.ipynb b/notebooks/examples/align_spectra.ipynb new file mode 100644 index 00000000..51cc660f --- /dev/null +++ b/notebooks/examples/align_spectra.ipynb @@ -0,0 +1,337 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "9359fc63-3229-4fd3-8631-09c181e6a27b", + "metadata": {}, + "source": [ + "# Aligning Spectra\n", + "\n", + "This notebook shows why it is necessary to shift spectra before they can be stacked together.\n", + "\n", + "The use case is that for radio recombination lines, altough other lines could also be used for the example.\n", + "\n", + "## Use Case\n", + "Observations of radio recombination lines benefit from averaging multiple transitions together, as the line properties change \"slowly\" with frequency (how slow, is a matter of debate and not the topic of this example). For this example we will look at what would happen if we were to stack two transitions together without shifting (aligning) them before." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "2845830c-b401-44b3-a6b1-ed1c30c706df", + "metadata": {}, + "outputs": [], + "source": [ + "%matplotlib widget" + ] + }, + { + "cell_type": "code", + "execution_count": 53, + "id": "e34b86e9-6438-4e84-8503-d6dd1699e243", + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "from astropy import units as u\n", + "from dysh.fits.gbtfitsload import GBTFITSLoad" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "cf801734-2ba0-48cd-a664-3ca15ce58890", + "metadata": {}, + "outputs": [], + "source": [ + "path = \"/home/dysh/acceptance_testing/data/\"\n", + "file1 = f\"{path}/AGBT18B_014_02/AGBT18B_014_02.raw.vegas\"" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "fb10b18f-4510-4707-ad2a-70a1ec2b4d79", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Loaded 8 FITS files\n" + ] + } + ], + "source": [ + "sdf = GBTFITSLoad(file1)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "62f47e96-7553-48c9-9dfb-032d2af60897", + "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", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
SCANOBJECTVELOCITYPROCPROCSEQNRESTFREQDOPFREQ# IF# POL# INT# FEEDAZIMUTHELEVATIO
06W43G92.02OffOn15.7649695.9315464231117.57556427.647278
17W43G92.02OffOn25.7649695.9315464231117.17271627.302879
\n", + "
" + ], + "text/plain": [ + " SCAN OBJECT VELOCITY PROC PROCSEQN RESTFREQ DOPFREQ # IF # POL # INT \\\n", + "0 6 W43G 92.02 OffOn 1 5.764969 5.93154 64 2 3 \n", + "1 7 W43G 92.02 OffOn 2 5.764969 5.93154 64 2 3 \n", + "\n", + " # FEED AZIMUTH ELEVATIO \n", + "0 1 117.575564 27.647278 \n", + "1 1 117.172716 27.302879 " + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "sdf.summary()" + ] + }, + { + "cell_type": "markdown", + "id": "17ac95ab-15f2-4f45-80cd-cc9d6ca0f001", + "metadata": {}, + "source": [ + "For simplicity we will only use two spectral windows, 27 and 28, which we know have good data in them." + ] + }, + { + "cell_type": "code", + "execution_count": 60, + "id": "d076291b-e69e-4018-ac95-718a7fa3c350", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/sandboxes/psalas/Dysh/dysh/src/dysh/spectra/core.py:393: RuntimeWarning: Mean of empty slice\n", + " meandiff = np.nanmean(calon[chrng] - caloff[chrng])\n", + "/home/sandboxes/psalas/Dysh/dysh/src/dysh/spectra/core.py:393: RuntimeWarning: Mean of empty slice\n", + " meandiff = np.nanmean(calon[chrng] - caloff[chrng])\n" + ] + } + ], + "source": [ + "pssb = sdf.getps(ifnum=[27,30], plnum=0)" + ] + }, + { + "cell_type": "markdown", + "id": "1d1b09e3-969d-40db-89bc-f933756423e2", + "metadata": {}, + "source": [ + "Now we will drop the edge channels, and then fit an order 2 baseline to line free channels. To end we will drop line free channels so we can focus on the emission lines." + ] + }, + { + "cell_type": "code", + "execution_count": 61, + "id": "3e51cc62-4ffc-4f3b-b934-bc2b42d63306", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "EXCLUDING [Spectral Region, 1 sub-regions:\n", + " (5464064707.706556 Hz, 5466252941.541311 Hz) \n", + "]\n", + "EXCLUDING [Spectral Region, 1 sub-regions:\n", + " (5716228475.37819 Hz, 5718517695.075638 Hz) \n", + "]\n" + ] + } + ], + "source": [ + "s = slice(150,1900)\n", + "exclude = [30*u.km/u.s, 150*u.km/u.s]\n", + "\n", + "ta1 = pssb[0].timeaverage().smooth(\"gauss\", 4)[150:1900]\n", + "ta1.baseline(model=\"cheby\", degree=2, remove=True, exclude=exclude)\n", + "ta2 = pssb[1].timeaverage().smooth(\"gauss\", 4)[150:1900]\n", + "ta2.baseline(model=\"cheby\", degree=2, remove=True, exclude=exclude)\n", + "\n", + "s = slice(0*u.km/u.s, 200*u.km/u.s)\n", + "ta1 = ta1[s]\n", + "ta2 = ta2[s]" + ] + }, + { + "cell_type": "markdown", + "id": "6e9a8da0-c986-444a-9c58-10884fbb9cf6", + "metadata": {}, + "source": [ + "Next, we plot the spectra as a function of velocity and as a function of channel." + ] + }, + { + "cell_type": "code", + "execution_count": 67, + "id": "e5ff3d24-63bd-49f6-a7b6-76a150f41c22", + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "8dcb1827f1fe422a97e7555712bc94a8", + "version_major": 2, + "version_minor": 0 + }, + "image/png": "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", + "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": [ + "plt.figure(dpi=150)\n", + "\n", + "plt.subplot(211)\n", + "plt.title(\"In Velocity\")\n", + "plt.plot(ta1.spectral_axis.to(\"km/s\").value, ta1.flux, label=f\"IF={ta1.meta['IFNUM']}\")\n", + "plt.plot(ta2.spectral_axis.to(\"km/s\").value, ta2.flux, label=f\"IF={ta2.meta['IFNUM']}\")\n", + "plt.legend()\n", + "plt.xlabel(\"Velocity (km/s)\")\n", + "\n", + "plt.subplot(212)\n", + "plt.title(\"In Channels\")\n", + "plt.plot(ta1.flux)\n", + "plt.plot(ta2.flux)\n", + "plt.xlabel(\"Channel\")\n", + "\n", + "plt.gcf().supylabel(\"Antenna temperature (K)\")\n", + "\n", + "plt.tight_layout()\n" + ] + }, + { + "cell_type": "markdown", + "id": "3ba825a2-2ca3-4d8a-8ebc-456eaf337f13", + "metadata": {}, + "source": [ + "The difference is subtle, but the top panel shows that the spectral line is well aligned in velocity, whereas the bottom panel shows that the line centroids are slightly misaligned. If we were to average the two spectra toegether, the resulting line would look artificially broader than it is!" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "cdf33158-62c0-4f66-a27d-f35fd22b12ea", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.0" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} From 256fec89de8e004b1a48ed7d4e72f4205dee95cf Mon Sep 17 00:00:00 2001 From: astrofle Date: Thu, 26 Sep 2024 15:30:31 -0400 Subject: [PATCH 28/95] Add: notebook illustrating the need to align spectra before averaging --- notebooks/examples/align_spectra.ipynb | 337 +++++++++++++++++++++++++ 1 file changed, 337 insertions(+) create mode 100644 notebooks/examples/align_spectra.ipynb diff --git a/notebooks/examples/align_spectra.ipynb b/notebooks/examples/align_spectra.ipynb new file mode 100644 index 00000000..51cc660f --- /dev/null +++ b/notebooks/examples/align_spectra.ipynb @@ -0,0 +1,337 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "9359fc63-3229-4fd3-8631-09c181e6a27b", + "metadata": {}, + "source": [ + "# Aligning Spectra\n", + "\n", + "This notebook shows why it is necessary to shift spectra before they can be stacked together.\n", + "\n", + "The use case is that for radio recombination lines, altough other lines could also be used for the example.\n", + "\n", + "## Use Case\n", + "Observations of radio recombination lines benefit from averaging multiple transitions together, as the line properties change \"slowly\" with frequency (how slow, is a matter of debate and not the topic of this example). For this example we will look at what would happen if we were to stack two transitions together without shifting (aligning) them before." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "2845830c-b401-44b3-a6b1-ed1c30c706df", + "metadata": {}, + "outputs": [], + "source": [ + "%matplotlib widget" + ] + }, + { + "cell_type": "code", + "execution_count": 53, + "id": "e34b86e9-6438-4e84-8503-d6dd1699e243", + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "from astropy import units as u\n", + "from dysh.fits.gbtfitsload import GBTFITSLoad" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "cf801734-2ba0-48cd-a664-3ca15ce58890", + "metadata": {}, + "outputs": [], + "source": [ + "path = \"/home/dysh/acceptance_testing/data/\"\n", + "file1 = f\"{path}/AGBT18B_014_02/AGBT18B_014_02.raw.vegas\"" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "fb10b18f-4510-4707-ad2a-70a1ec2b4d79", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Loaded 8 FITS files\n" + ] + } + ], + "source": [ + "sdf = GBTFITSLoad(file1)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "62f47e96-7553-48c9-9dfb-032d2af60897", + "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", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
SCANOBJECTVELOCITYPROCPROCSEQNRESTFREQDOPFREQ# IF# POL# INT# FEEDAZIMUTHELEVATIO
06W43G92.02OffOn15.7649695.9315464231117.57556427.647278
17W43G92.02OffOn25.7649695.9315464231117.17271627.302879
\n", + "
" + ], + "text/plain": [ + " SCAN OBJECT VELOCITY PROC PROCSEQN RESTFREQ DOPFREQ # IF # POL # INT \\\n", + "0 6 W43G 92.02 OffOn 1 5.764969 5.93154 64 2 3 \n", + "1 7 W43G 92.02 OffOn 2 5.764969 5.93154 64 2 3 \n", + "\n", + " # FEED AZIMUTH ELEVATIO \n", + "0 1 117.575564 27.647278 \n", + "1 1 117.172716 27.302879 " + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "sdf.summary()" + ] + }, + { + "cell_type": "markdown", + "id": "17ac95ab-15f2-4f45-80cd-cc9d6ca0f001", + "metadata": {}, + "source": [ + "For simplicity we will only use two spectral windows, 27 and 28, which we know have good data in them." + ] + }, + { + "cell_type": "code", + "execution_count": 60, + "id": "d076291b-e69e-4018-ac95-718a7fa3c350", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/sandboxes/psalas/Dysh/dysh/src/dysh/spectra/core.py:393: RuntimeWarning: Mean of empty slice\n", + " meandiff = np.nanmean(calon[chrng] - caloff[chrng])\n", + "/home/sandboxes/psalas/Dysh/dysh/src/dysh/spectra/core.py:393: RuntimeWarning: Mean of empty slice\n", + " meandiff = np.nanmean(calon[chrng] - caloff[chrng])\n" + ] + } + ], + "source": [ + "pssb = sdf.getps(ifnum=[27,30], plnum=0)" + ] + }, + { + "cell_type": "markdown", + "id": "1d1b09e3-969d-40db-89bc-f933756423e2", + "metadata": {}, + "source": [ + "Now we will drop the edge channels, and then fit an order 2 baseline to line free channels. To end we will drop line free channels so we can focus on the emission lines." + ] + }, + { + "cell_type": "code", + "execution_count": 61, + "id": "3e51cc62-4ffc-4f3b-b934-bc2b42d63306", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "EXCLUDING [Spectral Region, 1 sub-regions:\n", + " (5464064707.706556 Hz, 5466252941.541311 Hz) \n", + "]\n", + "EXCLUDING [Spectral Region, 1 sub-regions:\n", + " (5716228475.37819 Hz, 5718517695.075638 Hz) \n", + "]\n" + ] + } + ], + "source": [ + "s = slice(150,1900)\n", + "exclude = [30*u.km/u.s, 150*u.km/u.s]\n", + "\n", + "ta1 = pssb[0].timeaverage().smooth(\"gauss\", 4)[150:1900]\n", + "ta1.baseline(model=\"cheby\", degree=2, remove=True, exclude=exclude)\n", + "ta2 = pssb[1].timeaverage().smooth(\"gauss\", 4)[150:1900]\n", + "ta2.baseline(model=\"cheby\", degree=2, remove=True, exclude=exclude)\n", + "\n", + "s = slice(0*u.km/u.s, 200*u.km/u.s)\n", + "ta1 = ta1[s]\n", + "ta2 = ta2[s]" + ] + }, + { + "cell_type": "markdown", + "id": "6e9a8da0-c986-444a-9c58-10884fbb9cf6", + "metadata": {}, + "source": [ + "Next, we plot the spectra as a function of velocity and as a function of channel." + ] + }, + { + "cell_type": "code", + "execution_count": 67, + "id": "e5ff3d24-63bd-49f6-a7b6-76a150f41c22", + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "8dcb1827f1fe422a97e7555712bc94a8", + "version_major": 2, + "version_minor": 0 + }, + "image/png": "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", + "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": [ + "plt.figure(dpi=150)\n", + "\n", + "plt.subplot(211)\n", + "plt.title(\"In Velocity\")\n", + "plt.plot(ta1.spectral_axis.to(\"km/s\").value, ta1.flux, label=f\"IF={ta1.meta['IFNUM']}\")\n", + "plt.plot(ta2.spectral_axis.to(\"km/s\").value, ta2.flux, label=f\"IF={ta2.meta['IFNUM']}\")\n", + "plt.legend()\n", + "plt.xlabel(\"Velocity (km/s)\")\n", + "\n", + "plt.subplot(212)\n", + "plt.title(\"In Channels\")\n", + "plt.plot(ta1.flux)\n", + "plt.plot(ta2.flux)\n", + "plt.xlabel(\"Channel\")\n", + "\n", + "plt.gcf().supylabel(\"Antenna temperature (K)\")\n", + "\n", + "plt.tight_layout()\n" + ] + }, + { + "cell_type": "markdown", + "id": "3ba825a2-2ca3-4d8a-8ebc-456eaf337f13", + "metadata": {}, + "source": [ + "The difference is subtle, but the top panel shows that the spectral line is well aligned in velocity, whereas the bottom panel shows that the line centroids are slightly misaligned. If we were to average the two spectra toegether, the resulting line would look artificially broader than it is!" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "cdf33158-62c0-4f66-a27d-f35fd22b12ea", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.0" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} From a7ba971cd3a39ebd6aba930e0be2cf010d7059bd Mon Sep 17 00:00:00 2001 From: astrofle Date: Wed, 9 Oct 2024 20:46:15 -0400 Subject: [PATCH 29/95] Add: Spectrum.shift method --- src/dysh/spectra/spectrum.py | 72 ++++++++++++++++++++++++++---------- 1 file changed, 53 insertions(+), 19 deletions(-) diff --git a/src/dysh/spectra/spectrum.py b/src/dysh/spectra/spectrum.py index 59755f8e..a2a397af 100644 --- a/src/dysh/spectra/spectrum.py +++ b/src/dysh/spectra/spectrum.py @@ -37,7 +37,7 @@ from ..log import HistoricalBase, log_call_to_history from ..plot import specplot as sp from ..util import minimum_string_match -from . import baseline, get_spectral_equivalency +from . import baseline, fft_shift, get_spectral_equivalency # from astropy.nddata import StdDevUncertainty @@ -386,7 +386,7 @@ def stats(self, roll=0, qac=False): def decimate(self, n): """ - Decimate a `Spectrum` by n pixels. + Decimate the `Spectrum` by n pixels. Parameters ---------- @@ -395,8 +395,8 @@ def decimate(self, n): Returns ------- - s : Spectrum - The decimated Spectrum. + s : `Spectrum` + The decimated `Spectrum`. """ if not float(n).is_integer(): @@ -422,7 +422,7 @@ def decimate(self, n): @log_call_to_history def smooth(self, method="hanning", width=1, decimate=0, kernel=None): """ - Smooth or Convolve a spectrum, optionally decimating it. + Smooth or Convolve the `Spectrum`, optionally decimating it. Default smoothing is hanning. @@ -467,8 +467,8 @@ def smooth(self, method="hanning", width=1, decimate=0, kernel=None): Returns ------- - s : Spectrum - The new, possibly decimated, convolved spectrum. + s : `Spectrum` + The new, possibly decimated, convolved `Spectrum`. """ nchan = len(self._data) # decimate = int(decimate) # Should we change this value and tell the user, or just error out? @@ -524,6 +524,52 @@ def smooth(self, method="hanning", width=1, decimate=0, kernel=None): return s + def shift(self, s, wrap=False, fill_value=np.nan, method="fft"): + """ + Shift the `Spectrum` by `s` channels in place. + + Parameters + ---------- + s : float + Number of channels to shift the `Spectrum` by. + wrap : bool + If `True` allow spectrum to wrap around the edges. + If `False` fill channels that wrap with `fill_value`. + fill_value : float + If `wrap=False` fill channels that wrapped with this value. + method : "fft" + Method used to perform the fractional channel shift. + "fft" uses a phase shift. + """ + + ishift = int(np.round(s)) # Integer shift. + fshift = s - ishift # Fractional shift. + # Apply integer shift. + new_data = np.roll(self.data, ishift, axis=0) + if not wrap: + if ishift < 0: + new_data[ishift:] = fill_value + else: + new_data[:ishift] = fill_value + + if fshift != 0: + # Apply fractional shift. + new_data = fft_shift(new_data, fshift, pad=False, window=True) + + # Update data values. + self._data = new_data + + # Update metadata. + applied_shift = ishift + fshift + self.meta["CRPIX1"] += applied_shift + + # Update WCS. + self.wcs.wcs.crpix[0] += applied_shift + + # Update `SpectralAxis` values. + new_spectral_axis_values = self.wcs.spectral.pixel_to_world(np.arange(self.flux.shape[-1])) + self._spectral_axis = self.spectral_axis.replicate(value=new_spectral_axis_values) + @property def equivalencies(self): """Get the spectral axis equivalencies that can be used in converting the axis @@ -1082,18 +1128,6 @@ def _copy_attributes(self, other): for k, v in vars(self).items(): if k not in IGNORE_ON_COPY: vars(other)[k] = deepcopy(v) - # other.add_history(self._history) - # other.add_comment(self._comments) - - # other._target = self._target - # other._observer = self._observer - # other._velocity_frame = self._velocity_frame - # other._obstime = self._obstime - # other._baseline_model = self._baseline_model - # other._exclude_regions = self._exclude_regions - # other._mask = self._mask - # other._subtracted = self._subtracted - # other._spectral_axis = self.spectral_axis def __add__(self, other): op = self.add From d226382dc6583f8f92a648b6b3db4883219e13dd Mon Sep 17 00:00:00 2001 From: astrofle Date: Wed, 9 Oct 2024 21:27:48 -0400 Subject: [PATCH 30/95] Add: option to fix the random number generator seed for fake_spectrum --- src/dysh/spectra/spectrum.py | 14 ++++++++++++-- 1 file changed, 12 insertions(+), 2 deletions(-) diff --git a/src/dysh/spectra/spectrum.py b/src/dysh/spectra/spectrum.py index a2a397af..d1956a53 100644 --- a/src/dysh/spectra/spectrum.py +++ b/src/dysh/spectra/spectrum.py @@ -854,7 +854,7 @@ def _copy(self, **kwargs): return s @classmethod - def fake_spectrum(cls, nchan=1024, **kwargs): + def fake_spectrum(cls, nchan=1024, seed=None, **kwargs): """ Create a fake spectrum, useful for simple testing. A default header is created, which may be modified with kwargs. @@ -864,6 +864,14 @@ def fake_spectrum(cls, nchan=1024, **kwargs): nchan : int, optional Number of channels. The default is 1024. + seed : {None, int, array_like[ints], SeedSequence, BitGenerator, Generator}, optional + A seed to initialize the `BitGenerator`. If None, then fresh, unpredictable entropy will be pulled from the OS. + If an int or array_like[ints] is passed, then all values must be non-negative and will be passed to + `SeedSequence` to derive the initial `BitGenerator` state. One may also pass in a `SeedSequence` instance. + Additionally, when passed a `BitGenerator`, it will be wrapped by `Generator`. If passed a `Generator`, it will + be returned unaltered. + The default is `None`. + **kwargs: dict or key=value Metadata to put in the header. If the key exists already in the default header, it will be replaced. Otherwise the key and value will be @@ -874,7 +882,9 @@ def fake_spectrum(cls, nchan=1024, **kwargs): spectrum : `~dysh.spectra.Spectrum` The spectrum object """ - data = np.random.rand(nchan) * u.K + + rng = np.random.default_rng(seed) + data = rng.random(nchan) * u.K meta = { "OBJECT": "NGC2415", "BANDWID": 23437500.0, From 5bdb7553a94e7c54f1bbd027d5e594b970504bc6 Mon Sep 17 00:00:00 2001 From: astrofle Date: Wed, 9 Oct 2024 22:18:59 -0400 Subject: [PATCH 31/95] Add: test for Spectrum.shift --- src/dysh/spectra/tests/test_spectrum.py | 35 ++ testdata/gshift_box.fits | 539 ++++++++++++++++++++++++ 2 files changed, 574 insertions(+) create mode 100644 testdata/gshift_box.fits diff --git a/src/dysh/spectra/tests/test_spectrum.py b/src/dysh/spectra/tests/test_spectrum.py index 40695b11..0610dd8d 100644 --- a/src/dysh/spectra/tests/test_spectrum.py +++ b/src/dysh/spectra/tests/test_spectrum.py @@ -3,6 +3,7 @@ import astropy.units as u import numpy as np import pytest +from astropy.io import fits from dysh.fits.gbtfitsload import GBTFITSLoad from dysh.spectra.spectrum import IGNORE_ON_COPY, Spectrum @@ -391,3 +392,37 @@ def test_smooth_and_slice(self): assert np.sqrt(fwhm**2 - sss.meta["FREQRES"] ** 2) == pytest.approx( abs(self.ss.meta["CDELT1"]) * self.ss.meta["FWHM"], abs=abs(self.ss.meta["CDELT1"]) / 9.0 ) + + @pytest.mark.filterwarnings("ignore:Beware:UserWarning") + def test_shift(self): + """Test the shift method against the results produced by GBTIDL""" + + # Prepare test data. + filename = get_project_testdata() / "TGBT21A_501_11/TGBT21A_501_11_ifnum_0_int_0-2_getps_152_plnum_0.fits" + sdf = GBTFITSLoad(filename) + nchan = sdf["DATA"].shape[-1] + spec = Spectrum.fake_spectrum(nchan=nchan, seed=1) + spec.data[nchan // 2 - 5 : nchan // 2 + 6] = 10 + org_spec = spec._copy() + # The next two lines were used to create the input for GBTIDL. + # sdf["DATA"] = [spec.data] + # sdf.write("shift_testdata.fits") + + # Apply method to be tested. + shift = 5.5 + spec.shift(shift) + + # Load GBTIDL answer. + with fits.open(get_project_testdata() / "gshift_box.fits") as hdu: + table = hdu[1].data + gbtidl = table["DATA"][0] + + # Compare. + # Ignore the edge channels to avoid edge effects. + diff = (spec.data - gbtidl)[10:-10] + assert np.all(abs(diff) < 1e-4) + + assert spec.meta["CRPIX1"] == org_spec.meta["CRPIX1"] + shift + assert spec.spectral_axis[0].to("Hz").value == ( + org_spec.spectral_axis[0].to("Hz").value - spec.meta["CDELT1"] * shift + ) diff --git a/testdata/gshift_box.fits b/testdata/gshift_box.fits new file mode 100644 index 00000000..58f676e5 --- /dev/null +++ b/testdata/gshift_box.fits @@ -0,0 +1,539 @@ +SIMPLE = T /Written by IDL: Wed Oct 9 21:23:56 2024 BITPIX = 8 / NAXIS = 0 / EXTEND = T /File contains extensions DATE = '2024-10-10' / ORIGIN = 'NRAO Green Bank' /origin of observation TELESCOP= 'NRAO_GBT' /the telescope used GUIDEVER= 'GBTIDL ver2.10.1' /this file was created by gbtidl FITSVER = '1.9 ' /FITS definition version END XTENSION= 'BINTABLE' /Binary table written by MWRFITS v1.13 BITPIX = 8 /Required value NAXIS = 2 /Required value NAXIS1 = 131834 /Number of bytes per row NAXIS2 = 1 /Number of rows PCOUNT = 0 /Normally 0 (no varying arrays) GCOUNT = 1 /Required value TFIELDS = 83 /Number of columns in table COMMENT COMMENT *** End of mandatory fields *** COMMENT EXTNAME = 'SINGLE DISH' CTYPE4 = 'STOKES ' COMMENT COMMENT *** Column names *** COMMENT TTYPE1 = 'OBJECT ' / TTYPE2 = 'BANDWID ' / TTYPE3 = 'DATE-OBS' / TTYPE4 = 'DURATION' / TTYPE5 = 'EXPOSURE' / TTYPE6 = 'TSYS ' / TTYPE7 = 'DATA ' / TTYPE8 = 'TDIM7 ' / TTYPE9 = 'TUNIT7 ' / TTYPE10 = 'CTYPE1 ' / TTYPE11 = 'CRVAL1 ' / TTYPE12 = 'CRPIX1 ' / TTYPE13 = 'CDELT1 ' / TTYPE14 = 'CTYPE2 ' / TTYPE15 = 'CRVAL2 ' / TTYPE16 = 'CTYPE3 ' / TTYPE17 = 'CRVAL3 ' / TTYPE18 = 'CRVAL4 ' / TTYPE19 = 'OBSERVER' / TTYPE20 = 'OBSID ' / TTYPE21 = 'SCAN ' / TTYPE22 = 'OBSMODE ' / TTYPE23 = 'FRONTEND' / TTYPE24 = 'TCAL ' / TTYPE25 = 'VELDEF ' / TTYPE26 = 'VFRAME ' / TTYPE27 = 'RVSYS ' / TTYPE28 = 'OBSFREQ ' / TTYPE29 = 'LST ' / TTYPE30 = 'AZIMUTH ' / TTYPE31 = 'ELEVATIO' / TTYPE32 = 'TAMBIENT' / TTYPE33 = 'PRESSURE' / TTYPE34 = 'HUMIDITY' / TTYPE35 = 'RESTFREQ' / TTYPE36 = 'DOPFREQ ' / TTYPE37 = 'FREQRES ' / TTYPE38 = 'EQUINOX ' / TTYPE39 = 'RADESYS ' / TTYPE40 = 'TRGTLONG' / TTYPE41 = 'TRGTLAT ' / TTYPE42 = 'SAMPLER ' / TTYPE43 = 'FEED ' / TTYPE44 = 'SRFEED ' / TTYPE45 = 'FEEDXOFF' / TTYPE46 = 'FEEDEOFF' / TTYPE47 = 'SUBREF_STATE' / TTYPE48 = 'SIDEBAND' / TTYPE49 = 'PROCSEQN' / TTYPE50 = 'PROCSIZE' / TTYPE51 = 'PROCSCAN' / TTYPE52 = 'PROCTYPE' / TTYPE53 = 'LASTON ' / TTYPE54 = 'LASTOFF ' / TTYPE55 = 'TIMESTAMP' / TTYPE56 = 'QD_XEL ' / TTYPE57 = 'QD_EL ' / TTYPE58 = 'QD_BAD ' / TTYPE59 = 'QD_METHOD' / TTYPE60 = 'VELOCITY' / TTYPE61 = 'FOFFREF1' / TTYPE62 = 'ZEROCHAN' / TTYPE63 = 'ADCSAMPF' / TTYPE64 = 'VSPDELT ' / TTYPE65 = 'VSPRVAL ' / TTYPE66 = 'VSPRPIX ' / TTYPE67 = 'SIG ' / TTYPE68 = 'CAL ' / TTYPE69 = 'CALTYPE ' / TTYPE70 = 'TWARM ' / TTYPE71 = 'TCOLD ' / TTYPE72 = 'CALPOSITION' / TTYPE73 = 'BACKEND ' / TTYPE74 = 'PROJID ' / TTYPE75 = 'TELESCOP' / TTYPE76 = 'SITELONG' / TTYPE77 = 'SITELAT ' / TTYPE78 = 'SITEELEV' / TTYPE79 = 'IFNUM ' / TTYPE80 = 'PLNUM ' / TTYPE81 = 'FDNUM ' / TTYPE82 = 'INT ' / TTYPE83 = 'NSAVE ' / COMMENT COMMENT *** Column formats *** COMMENT TFORM1 = '32A ' / TFORM2 = 'D ' / TFORM3 = '22A ' / TFORM4 = 'D ' / TFORM5 = 'D ' / TFORM6 = 'D ' / TFORM7 = '32768E ' / TFORM8 = '16A ' / TFORM9 = '6A ' / TFORM10 = '8A ' / TFORM11 = 'D ' / TFORM12 = 'D ' / TFORM13 = 'D ' / TFORM14 = '4A ' / TFORM15 = 'D ' / TFORM16 = '4A ' / TFORM17 = 'D ' / TFORM18 = 'I ' / TFORM19 = '32A ' / TFORM20 = '32A ' / TFORM21 = 'J ' / TFORM22 = '32A ' / TFORM23 = '16A ' / TFORM24 = 'D ' / TFORM25 = '8A ' / TFORM26 = 'D ' / TFORM27 = 'D ' / TFORM28 = 'D ' / TFORM29 = 'D ' / TFORM30 = 'D ' / TFORM31 = 'D ' / TFORM32 = 'D ' / TFORM33 = 'D ' / TFORM34 = 'D ' / TFORM35 = 'D ' / TFORM36 = 'D ' / TFORM37 = 'D ' / TFORM38 = 'D ' / TFORM39 = '8A ' / TFORM40 = 'D ' / TFORM41 = 'D ' / TFORM42 = '8A ' / TFORM43 = 'I ' / TFORM44 = 'I ' / TFORM45 = 'D ' / TFORM46 = 'D ' / TFORM47 = 'I ' / TFORM48 = 'A ' / TFORM49 = 'I ' / TFORM50 = 'I ' / TFORM51 = '16A ' / TFORM52 = '16A ' / TFORM53 = 'J ' / TFORM54 = 'J ' / TFORM55 = '22A ' / TFORM56 = 'D ' / TFORM57 = 'D ' / TFORM58 = 'I ' / TFORM59 = 'A ' / TFORM60 = 'D ' / TFORM61 = 'D ' / TFORM62 = 'E ' / TFORM63 = 'D ' / TFORM64 = 'D ' / TFORM65 = 'D ' / TFORM66 = 'D ' / TFORM67 = 'A ' / TFORM68 = 'A ' / TFORM69 = '8A ' / TFORM70 = 'E ' / TFORM71 = 'E ' / TFORM72 = '16A ' / TFORM73 = '32A ' / TFORM74 = '32A ' / TFORM75 = '32A ' / TFORM76 = 'D ' / TFORM77 = 'D ' / TFORM78 = 'D ' / TFORM79 = 'I ' / TFORM80 = 'I ' / TFORM81 = 'I ' / TFORM82 = 'J ' / TFORM83 = 'J ' / END NGC2415 AvZ À2021-02-10T07:38:37.50@õ6à@eO`@10ràÀÀÀÀÀÀ?@ÅÔ? ê? +Ïš?%g>°õì?#tÃ?hµ>÷$Ä>•ž>ÄIP?*/^>Ö6?î¸? ¦_>À):>–4Û>‡³8>ž½O>`Qh?k?Q×>»}Ö?<âô?{*«?X3Ö?!ê´>Ò›¸>Mß?ãÿ?C|§>™ö>¹8À?6–E?0ë?G#°>óèE>‰^½?I\>~y¼>¯«L?Bk$?;DR>Ó%»? Ê&?/Áo>þ0?%X®>âJ}>ôDØ?BŠ(?=øk>öj>ý|U?_Ž=ãá¬>ð¦›?^EW?_¡ò?-5á>¾Å‚>~Ö>¤ÐŸ?0É/?Hî?D4>màh>Ú€µ?98G?f1–§¢?4”?(Š,?Fõ>š]\>«wr?ObÐ?_¢$?[(?Hö>à$t?id>øÔÞ?³î>ã§>á™Ñ?£">„G>°ŽM?¤>ßí>‘nW>P¾(=úŒ>µ¯ó>‚›Q>½4¨?É(? ô˜?3³À?”?&Ôº?@‡Ž?9 j?‚>âßî>¸8?î?"Ö>s¹b>+Ì>L|?}É??Y{>Ðdì>yâÌ>̘6? ½0?:â?KÓ?7…Ú?JÔ? +ÏT>ͱ:>ÔZÐ>q,>UF>zçF>™µn>ŸG>à<ö?H ö?`ö{?G=?GÂN?+Öj?B@=?Or=?<‘> ¡>I>¸~ª>&> Uh?)Y? 4?|?*K>¢vÖ?Y»?3Õ>¦8ÿ?–>ö¾?>Ú/ê>ï½}>‘d!>œÄô? +´z?±¾?-à?O]x?'Tv? +X>ÓTM>­!ï?/§?†?Pf?en8? ôB? +˜?W +>¾Öã>çoÇ>ƒf>rŒœ?AT? br?`?ž@>œ[&?«¬>ñ¸>Þô?,Qj?!"P? ûµ?<~¢?3N'?:Èœ>÷gµ?`D>ÉR]>fÎp>Õ|>ÚKt>œ5Ü>%ùÌ>ÌŸ>ñ¶£?B?3rt?;?Mx†?+¥þ>Þ”? q-?@ì> À?ˬ?B¨È?'*?'tõ?>¥Ý¢=¿>Þ]L?#²â>±&;?Z˜?2>¦Pj>¦Î7>ÛÊÿ?ˆØ>JD=³˜Ð=àNd>8Â>»Ìd>ûÓ†?3 ?w~.?`#?; +Ú?@“§?hÙ>öbÞ=NM>>aêÒ>±¿>àÿð>·ä>‘>:Uø>Ö;"?4•>?"ƒ²>¡ªd>]Z +??^>ÖF>‰z¨>Tª=-»P>¾œ>¢¦v>Þ^^?._x?R>1>ÝŽd>ë/Ò=FHˆ?À†?`kZ? aÔ>f=|>„Ý>·jY?G¶?)îf>h š?1 ?KÀT>º/ò=ÏðD>˜W\>¼f>´m?%mð>ž(">Ó-a?NÇÔ?ZF’?K.–?/{ >Ü•¯=³Š0<æóÀ?¾[?Oè?LǬ?%pd? dØ>Õö›=ÏÅd>cyÊ>ÓÀ¼?B½?(¤>ì‰>úó??HÂá?5À?&òD>æ8Â>QF>õy ?Ç">ßA9>ým?.‰ø?N6Ë?V >§c…=;À> ÒD>#ÿ¯î>1mF>W¹|>³éþ>µLT=:Ó=™FL>/;þ>ØYJ?3ýP? +gX>ƒüE?ð?Mü°>Ùš>è†D?Wÿ>üÈe>̨Í>×Aä>TÊ®>½Ÿx?Sß>þÌ{?kì>»×q?.Ñ?ï¨?Pò?:¥>Î|W>n>,>¨³&>Ýʱ>ýäâ?šª>~•ü>ã>ã,K>Ù…ø?Uˆ±?]ÝÎ?N}Ø>Íû>—gŠ>â'¯? +Q´?÷V?6>ã9>ˆÚð>çœ">ý­>„/? ›¼?Vž?CǦï¸>ÞeA?j°>áAœ>'?&>‘>Ê?õ…?»?0Šò?6 >ªû?%?&w:>ºëk>ˆù?âŒ?w×ý?O^Ø>æ “>ÿ‘>ðýn>ƒ`ª>ß‚>ô§À>¸{Õ?-^[?±^>Æ S>«jí=__8>×¾?wž?]Ê$?N4Ò>çŽ">µq¤?bÈ>Ôw‰?;d?€>ÐûÓ>Çß‘>¢–•>ñ‹>±S>Ul>³úë>⮿?#ˆ?:µÝ?³`?9Ç? +›>ˆR>‚|–>†ôd>­èä?ÏJ>¯®>Öpi?&†j>ô_Ð?+P›?g5R? +[>-j?v? n¢>æœw? èG>¦Î>çgø?A«²>ð0^=h|ø>æé?µˆ>¤¶?#T?; >ñ6Ø?ZA?]“?;Ü"?6g$?F/Î?µŸ>à4?8jC?Xóú?eF„?k3¼>ýô&>eäì>Ô‰¾?.H¹?*/›>¬fr>{6>îš? „F>Ï3= ``>s«Š>Úîð>á‹?!‡+? J>¼ +?-8 ?Z^.?k‚>ü—>è?¸??Òð? »b>bÆ=¡¦l>ò s>×rr>ARØ>'8?ÆÈ?î>V±–>jeb>°ÉÚ?9B?·8?®#?Bƒ?5ÇÚ?Rº.?„>ã£>ñ(p?.ø0?Þ>ˆ&â>úK>÷CÜ?K? Á{>å­¹?;w?L6>êt%?.Ô„>ÛÊG>U¥Ö?$8˜?uÃÌ?~Þp?‹…>Õ« +?e‡€?kh±?OWÂ?0¾4?3w‡?$¾²?.÷#?'¸>¹Å>ãž>ÿ¤¦?[]Ê>å®:?h?x>ì9Ò?‚,>Žér>H}N=û-@=ßt=—u=‰|ð>îqä?1ÿé>žmH>¤øÕ? +]?Æ>²¼Z>Š[?*‚?"@º>Ù¾þ?;íW?þS>ñìz?ÀÆ?#¤?|>ä²D>çÕ9?ql?g½Ð?D>?N\ý?\ÏŠ?Eœ>?`Þ±?ÝÛ?!P?2¶²>àî>©nÒ?û +?u?»¬>ë{>Œ¢Õ>¿3¦>¡—=ü¦ð>ʯ?b7[?@Ž>7(>†W|>T¾>»‘f?b²>è.?=T:?c1þ?c”r?onê?C-@? G²>‰ð‚=i± >žqˆ?3›j?'Æ>V—ì=¼«Ü>ÿî>îû >*æÀ>w»¸>â3Ô?=I¦? >ÌØ?æ >÷È„?ˆN?5Ù™?[Ö>µL>˜´>–Ÿ?'ðÄ?gD?>ƒ>¾‘£>àøâ>øQk>p^> Du?+½?XM?qý[?,î²>šÃ”>6Hh>†8?#e?\?G?MT¾>ã©å>ÐÙì?:“Ö?dYG? ûJ>õ!M?Qæ^?øÀ>çà?"Ûâ?,RT>œ Æ??$>ÚO¥>™É>Ù´>äÜ1?ep? k:?y¤?(kˆ?]«z?dm?/Ìý?jV?è>¯Òß>ëK¿?NO¸?bÝ? ~`>ux?Çs?=½ ?K¼œ>ý·z>ÿ1?)Ó>¯ëÇ>˜Ô?*Âœ?Ì—?öÔ>5àN?ã>Ãdº<Ùì@<è>íeï?ú+>œLä?SE?˜?‰2?Q>¥â>°äj>– =ØR>ñ'k?c³´?(Ö?‚Z?IÌ¢?É}? +t†?@Î>Õ"º=µ2L>ä2??>Ì>Ýí¿>þr?Ub`?â>«£‡>`óÀ>É">¼ì>£fó?Wv?´P>£<ô>« ½?5=`>áßü>´¼a?:Y}>þ‡;? +–Ç?vÑ?Uè™?L_~?%r>æpü?R?à>ò5>Ü´?Ä>?v‡?:û?8âØ?eÄ>ÐÈ2?4 Ð?GŽ=²ì?èÚ?x~Ò?Ûì?Ät? ',?¹Þ?lùµ>ì‘Ë9¢¤>$Øx?">¼?`ûê?^×? \H?Ö”>¤à–>„«G?×:?f ?"/B>±7?äV?2c×>”=> ¢Ù?@O?C">Úe˜?Åå?V{>²„|>á”V?j× ?kBd>Ô^ >hÑ\? 8R?=öå?5Ïñ>‰µÌ>ÿÃ%?vI"?9ðQ>‡ú>ã/Ô?L*?^i>ùŽü>RÂD>ÀJ>8v>Ùë„? yË>:Í&=”›Œ>òð?9 >Ê~t>ëù“>ÓÜ>Ç–?/Û]>£É>{å.? ¦ê?>ÝÖ?:£}?Lï?Qç~?WàB?-•\>ZâÒ=Îߤ>v±€>*TÖ=‚ZX>£q˜>É >ƒPä?‘b?M—„?^6?³l?%Ÿ?L~ì?Í~> l2>ÝlE>îYH>^“†>“dt>>€x>i•¸>}@(>Uô>o;€>Õ>gÔ>” £?í"?…h? ¦?i0 ??l>šŒ>Ѩé?ÂP>‹þ0>æ¯Î?M»6?'5æ>½cü? ï?*Tu>âs>Ër=? Å?CÒ>ÈÂc=ÆÁœ??„?i?ì?Q›ä?a-ý?up€?+î”?ÍÑ?57^?äå? –j>û\L?‹r?%§‚>‹ê’=…™Ä>ª¤>Ý_¥?År?ô>ij?)ÿ?A?ø?6Uè?^õN>㌜> üø>—#¸?%ï?@>ÆO>ö+ë>Èܲ?­>Úèl=ïÂè?´\?:÷ë?›0>ãjÈ>z ">µ?;Àþ?LÚ?7í?Ijî?q¢?p­?{N×?Qú>óc¼>ﾶ>ø-û?º>õc>+©?*¯\?%Ý?s|>´p >/¼? ã’?Qîª?ÇÃ>Ý×c?&*ñ?H]¨?P¹j?Ïù>~ST>á÷?hž? XW>È‚¸>€¼À? p? 0|?Ä”>ÉPc>þÓÊ?$ë>£'^?7¥ü?FÌ>^‡ê>©O›>áì>Y¬(?E?IÎ_?ü>f>Nq8?!ñ?˜•>òSâ>Ûù²>É\¢?-T?ö¶>½Cà?1À>ñÒX>•­&>&eâ>¨p×?FŸ—>ðŸl>ØÕ§?pWÈ?>0?@Çû?X´¥?¾n?&F>ê°«?V0>èn>ñ–?qT?$?RéJ?rÒ>_n>²þ>>Âä>«òA? Ñè?Q/Ä?Oû>õÆÌ?)RF>íq‘> ’ë±>x¢?áf?À2>Š¥Ð?7z>õÖÜ>ë zg>³w">öŒÐ?9½?_F`?#?\—>Úý÷?(k¨?/Â?! ×?F…X?J†?#¿>Á §>ÇWý?,C?f †?eq?!K?"´Y?JQ? S>³5}>IÈ>ö’8>è‰>»I®?1K¶?;n?"wÆ>Þé§>= +r=›?¼=À> WP>ÌGÐ>ÿ‰J>žˆÕ>~¹Œ>Âx?!ÆL?>…“>¬a>„j>ª%£??cd¬?6Òõ?$’.?6"Ž?B2 ? S–>sÓB>÷I*?_{:?o >Ž?‚}>å™S?æ>âÔ~>w7X>Ì&”?1íN?T8°?/·?_­?7>ÑßF>º²i=ð¸>Ü7?E|ü?;¥? +?.‹È?`·Š?qSz?_äØ?J?ðn>üO?h…?iJ? Åã?'âÎ>‰Xù>™q>ÔÔ>±â>_ š?œ2?n7A? —5>“a>Üô?ªÞ?A´ ?&Û?­‘?6>H>Èôõ?|?"?+|?K‚P>ÈÖì>æ£?-éÿ?Q>óeö? ›>¹™Ç>‡$ô?=c? à>™ê>‹œp>ñeD>å/ë>Ùýg?Ðó??–.>×)@>J‡P?Vt>œÜÃ>õ¶Ø?PkÆ? øû>ðÇâ>™‰™=¾8>½+g?Oðj?_EF>ϼÂ<3±>ä»? Ù€?ÅY?>Q?c=þ?t!ˆ?)” >ÊÓ?<½È?^>·Ög>ô†¤?If>Ê]y>†­ð>í,?®§?Ÿx??#9$??àß?n«}?tf=Ò¼>øX?<d?KbX?7B¾>šýy=¼E$>ÓŠ>Û¿ø>³üé?=È?$X ?[‚3?ý>¯#æ?!Å$>ö<>,À=Ñ7? QF?a˜>ý¦×=¶Dˆ>©š>û[ê>Š>UMª>­Ô >Í?q?%&ù?Bz?9~‚?kJì?jÆ?3p?&H?Þ½>„ o>ú¯h?…>«r? #û?<óþ?*_„?8"?<ë,?=0ã?%Ox?Fªè>ê-ý>•o›>Ž¸³=«ä$=¢D>çàª?B`>ÑY?)¤°?öh‘>‘v>ŽxJ>£Ýñ>ß~?3ú?+þ#>—P?fg?+„>WU"> À>¬2¶>Q6¢=™R¤>bLz>¢<‘>ÇÁ>½ª>›”^>Ê |>ίp? ®?ID>ÊŽè=£ÉX>$>gíî>´’®? y¨?>Jk?N„?Iݪ? Ô”?L‘¨?T1¦?2d>³þ>SÒ>ù€©?_E? Ì?CØ?Udš?e/?4Ä)?pšú?*‡Æ>ÞJr>•Tµ=ò#h>l×Â>–n£>_>Ê™Â?]>?Rˆ?Jþò?eŠ„?B Â?”H>ßdM>Ú-`>ÓêÃ>t…²>¨nM?߆?)\?*L? ¼z>!œ=Ñí(>¿„>Ú!Ü>ðIw?Kw>áJÿ>±ºY>l7}>©úÁ?J?Û?[Ø?aoÉ?šó?n\?IqÐ>·òµ> ll=Ø@>µÀ€?#rˆ?5[O?9Ìô?GZ>§—’>êR>¼R²>¦¤´>Û„>hò?Þg?mâ±?T°M>>¯E÷>Õòr>fMJ>9U>”>?Dñ?Àö>™ïŒ>¡zé>å7¡?ï?,D">ÈZî=³·È>ÑÅÐ?ìè?6nž>ç=Ç>Z›D>Èž>ìKØ>Úq? ªR>Û.)=‡_|>Exö>Mú>mƒr? >§r >†Áë??¹?´>’œY>ÈÏ{?DÇ@?Ó{>ÀIØ?ÎN?M@H?,Ö?¹E?„F?.'¨?oOv?.`>´Vþ>Ó¡Ý?=J–? ’¾>©¯Í?¯?1ë >Æ8(>¥PI? +uÄ>À›Ò?+Ù†? 3(>Î!‹>éƒá?…'?=1 >ðuÜ>³j>ÁÉ›?82>ì[E>·îÚ>ÕU>%xâ?ö‚>ëq>Ì’>ÍûF>‡ë"?iÎ>¾9>ôö}?q¾>¯—>µWf?l$?Ò®>÷6=û¿x>î" >õl…>§ >ýÈ‘>ù4¼>îað>ó}Œ? ò¤?ê=™¬”=Yüh>ŸƒŸ?ç?5Sé?hÉJ?+¦’?nX?>ÅÌv>tÅ–?™Ž?èî>ø ¢?\j?Cà@?!Ç>ÄX}?0‘o>öÛy>ÿ­W?6…‚>ž? +š?4?é>Û(à? ýê?cã?qø>-6¢>áúT?9fM?€t? +Ï?LÆ*?gß +å>©%4?Ò??l–?3¿? Î’?-LÞ>Í1•=vôh=6yÀ=ƒL>@a>>NØ>£¢©?ûi?AZ>c(ü>†bÄ>¬H=> >Ê` ?a¿›>õkþ>ºCu>¸2>›Õ?´æ?Ã?JÓŽ?QŠ_>¼yº?è?É>Ñý™>÷ìâ? á>å{p>XjÒ>Òµù?Cj?CÐÉ? x>œ´Y?+>àÕÎ>µý´>Ôým>ïá&? Î?"—è?àP>ª+ô=ågè>ž~„>ÛOº=Ì$>D&Ì>¥AÎ>ö»å>þ“m>£¹²? 4ò?6}®>Ò.Ð>¸*Û?Dÿõ?l<¤?d ? Š? ~?_‚>•–B>ƒ§u>ªÚ?&lr?8gó>¨‚Æ>ýÌã?(bx?Ù?Xƒ?[´¬?%þl?‘ö>®¬>~Ò–?à?B3t?*ÎB?..5??+ö?,šŽ>t–ä>àØ#>Ó V?‰?Káþ>¯›=fzà>£­ª>ªO´<ó¢>r“4>Ú®?'v>ñU2>ýÞ(?$^þ? öM?ßæ=¡¤>}–Ú>§§ˆ>­5î?& +?^ÐÐ>÷ëH>!N>”Bæ>n•:>¦î>†zú=õçè>År>|–,?8œD? ö”?O~?¬?D?O*?8t ?)Mî?,Hf?Gêª?]?éB>µE2>]Ž:>¬7Å>Áߟ>\Êr?Ù½?MîÈ?™?1´Ä?17Ö>åü1? +?(`R>Ð.¸>€­‚>ç2—>Á¬¡? +²>õ¹o>â6Ü?rå¾?MÝ>Ë·?ÿŸ?!¢È?Óp?Mn>€°?÷x?WÌ="¸>Ø<»?Kù5? +½ +>©? å?%Mø? Ù?ö¢?8-:?w>Ù´>Ú¿?>†Ç9>Ÿ¬%?ê ?7s>ä(¡>Ý{§>ÿ°q?—§>È,>˜ác>Ù;f>ŒØ=«`> ×>Ë¡Þ?P>Øî0=ÎT>â[P>ÂÉ}>ŠS,>ºý!>ú­>tÃæ?ü…?*©À>Bµž?µ¾? +*Q>Þfn?5²¬?.‚S?A®ÿ>õÕR=À5À>m7€>æR²>¨"º?;ü>í¦›>’àÉ?‘Þ>Tu>ÒB?~Ê>ξ|>žJü>Œ…<>ÚR¥? –@>¡DL>cÍ2>ꀴ?9Êç-8?@wL?1æ¾?3¦ö?N¸?B°??ð¼?0ýˆ?URè?;>­X?%„¼?"rŽ?<Â>ø4L>¥p–>âD¨>¦ÿ#>z?Úÿ?UÆ?C?QT?6N¾?F±>Ìîþ>)Ê?A~?;¨=?Ϧ>Âap>y>5«|>ˆÆï>å^>íbu?Yþ?h>êSV?@T¤>ý¢l>£yÅ?66>â¤?ÝÐ>ûJç>ì“Z?Ù·>—ûZ>Õ#R>ô„?¨T>¥¨I>Ù‰Þ?-œ?:·? ²´>‘\?6}8?MI¬?“¨>óã&?5íf>æ®Y>ü“Ÿ?>‡?$!N?'A¢?(ç`>î">y™Ä??diÜ?DrM>ŒƒI>Ïè@?7†>Ê¥ƒ>*<„>»î>§J?~?x¦?^i?MPY?LB>MkZ>Ônl?E£Ó?@-.>àÐò=¬H\>—¥ì>¸è>V² >ÊÀ‚>´…ú?(„?"Ùö>Ø'È?FÚ;?UIÊ?æð?)ß>õóà>ÏB=~h>´S?,p2?)LL?-¼?ñ(?D€˜?6c²>ÎÖ>9Øô>§§\?R>øê®>ÊI¶>¸ú²?Ûf?N¢?ø +? +>ütÔ?½5?-*+>üê°?&Š¸>¨S°>¬‡>¢Â>ƒcC? ¼?Ab?4=¹‚°>°¶°>ñjŸ>Ü`b>ÌQÛ>ôC>ÒQ7>›í¾?%ŸM?W¶ó?k6>Ön?EŸæ? ü>ò_¨?J>2?Z3â?;®ø>ìI»?ÓL>ëÔå>Jîl>Ÿ»Í>ùo‘>àÔ?ÿ~? Ö>†õÁ>úUè?ik2?âú>ÕÉ>ý6? ú¡>¾S >òg8?j£s>÷…ü>ć,>ÿ®î>„c?•¶?Pö?)œP?Dd?A\H?v>Ó† >¸æ>®Hp>¡Š¤>|=x?cŽ>ꎤ>éb¢?;û¦?7†Ô? ÷ò>Þmà>bv²>Ñ&Þ?bÏÄ?Q™>ëh¸?'È3?4ƒ4?BfÓ>àƒ6>Éà>v-A>ƒ @>Í6‚>°JÝ>¼Ý?A}5>ÌÒæ>æÁ5?bZ³>Õa>–º>“»„>€> b>§nÒ>­–#=o„˜?ÑÒ?gé?;y±?<ßÞ?ü>˜¬>R±? ‡V?C¯?=wØ?øñ>è’À? ¿À?,Yp>Ì`>« …?4@ú?x?x=±b=°­@>‹±Ú?6ÓG?7rD>ÏáL?Ç +?á$>Âë?9î?dý">ÿ=‹>SE¼>¶)?kˆ?<ÚÖ?xè>êR>¦Û—>Û‡Ì?4Žt?’9>¡&Õ>S=c°=õÜœ>Œ³ß?T? +>Š¡ >yP?¢P?N= >â‹^?}t?i9R??ªô>üç×>××Ì>½Ø•?¥z?J?ì?Rm±>ó¹={Eð>©»\?(~?G9>íÞ&?7+:?>a>Íww>Ãs>Ë•¢>ëà…?C2?#øl?Yuž??¡Ì>u“>…AR?É”?$Z\?aDö?æ‚?bú?¬^> +>–;)>ÖÓ?&»ß>” í?{æ?î§>NÊ>ÖŠó>»w>˜cJ?cÀ?89>¾z[>ÅPï>Óí>ã±>Š7ý>Ü{j>Ù¾>ýÙŽ>óØ?ZÒ?J¼™>ÍýÊ>¦6.>™E=àTX>u*P?^Š?+q?ùò>¶;m>i6¸>þ´Å?ÀP>Ïnp>JÚ:=²>þE?,yo?'ä±?úB>Òɦ>Ö©Q?†&?¿’>ºUÄ?Dœ³?ZÄ ?$lD>çä>çô>‰˜=aµ >Yýz>%’Ö> Þþ>§Ê³?#9N?i5X>ío>d—²?&Æ?:bœ>ë¡é=Ž»à>Æî>’â”>AŽ>Eêø>åÿn>åöw>I>>h°À>¼¦œ>§ Ú>«n¨?9?œ?bûœ?Gý’?Xf¤?q0?;¶.?Eü?(L>Ý2’?=qå?8ž>è!m? +†?˜â>ŠU>t>æ¢?ÂÚ?XOü?1f>€ˆ6=®ŠD><8ž>Î1{>¡+Î>jõ>d> ]l=ësÈ=Üt$>ø¨ô?.ì=ú $>ðêz?hÌ›Ú=¾a´>‘ª=æ©>˜®ç>…Ò»>غØ?vØ>˜`> +Ô>¦èV?.ß?0ŒÞ>ËM%?´?+x? Íi?@R?N¥>ÂÝ“>Ϭû>ý6€?öÍ?/«? Õ½>²6¦=qè ?ì?Ð<šb>Î?6ß?=?Cƒ&?\Ü?Bý§?RŒ¤?`ƒY?xr?#ù“?a—?u–?>ȼ?Kc8>þJ>Ncþ>ÇDÏ>¾T>¥…J>î-Ž>èb¥?Zt°?+——>៤?ñÈ>²¦V>ä$¾?:xO?> +`?T>‚L>q>|>ƒsJ>IÅØ>Ö¶>QÊl>Ç©û>­‚¨>¹š>U?â>iì?¢†>ú ý>Þ˜º?2~?(»–?9Zñ?[n?+Û>žN«>8­>w)ô?n©?´,=ã} >Dv?ƒ˜?f•Ü?Od€?LÇÙ? êš?­²?I<>8Ÿ?'h?G@ö?Næª?gÓ ?Ô`>–ÃÆ?6ý +?Yhs?AÁª>ÚIî?á:?FŽþ>¬s4>´­ê?B/?:=>?Bè¶?z-ä?3¥w?:UT?b0?Y>/ߌ=`½>‰%ð?'çÆ>ä]8>”Ú?c?irÚ? §?"¾?9¦Ê>µ¯>šŽ>š¥Ñ>ùÔ‚? ÞŒ>ï´S?Ð?ìð>õDŽ>Íä¾>—çl>GÈ>Ðú§>¶4ž>¹\d?AŽ ?HL?8±?M®?,É>Ò¶µ>Ä9J>L2>aF<>ó‘>ùú²>}ïh=¸xT>^S>°þ…>mK>£:>«€í>:Z¦>þK??D ?K°Ð?LœZ?f>÷5ô?7L?"ƒ ?$j’?%÷#?°ÿ?5χ?1>tZ>?”>­0>íøv>°!š>oÆÄ>“ܹ>㸤>¢zª>r“? T?DÞî?+“ ?;jò?XÝZ?E$¦>é¤Ç>£yÞ>ˆ”>³^¾>ÿ-»?ûª?Ç¢=§]Ü>x0W>ŒŸ>>³g­?}`>c:>ì>RCÄ>a¨?I}?J¶\?-È?5î>ŒCh>€}C?H&?{×>Hõ>eP? †2?‰N>¯•*>èeq?1(”>Ϲ>¡?„?•Â>…fÈ?²Ž?1Îr>17=‹ƒð>äÛ¶? wT>žb>“Î?$jü?;Ø?.–ù?ZÞx?I8?JùÖ??À?,œ>¦œ,>Q­P>Ên¨? Õ?=,¬?O_3?$‚>­àw=?êt>»ðª?4Ì®>ù½œ>¾8Ž?1ù +>ÔVm?>_?&­j?‹Ü?g¥>Ïûµ?-=Þ?TPð?Ÿ>Š>Ü^8?*/P>«¦@>}ß?Kax?ÊÉ>Öˆ?JB?%ã?Åþ?aO>ï(>$Aœ>‡}?¨~?F`³>²ÚÉ>€|>£?"Ë?r0?_¤ö>ôQ“>l`†>ØQ<>½œ'?wÄ?,”¼?¹î?.tÂ>ý°o>l¬˜>ñ†??0¤j>…>™>Ž?þ>ˆT>&hâ?{? êÓ>¨Û>¡×‰>ßî? Š>Û‚7?‡Ý?)1?&ñ? õN>½Ö…>‰_Ì=áŸ$>¤s,>óú¹>vQû>©»À? ½ý?/§|>¢ý>8?KØ? µD>Ϭ|? %ú>ôÞZ>b&>ï]?]‹? ( =°yÌ>â8?5>ÏNY>Ï>›â>²‡>?ƒä?k ³?OèÝ?^8?'fB>B>ÆüÕ>â—(>òW>ÇTK>E*>ÿú/?Py?ž>y/ä?9·?0{>o ?êä?Ý´?+KE?"…‹>´Â>#>|ôÒ?>->?wÉX>èp~;Žû= •P>î*9? Ör>™÷Ä?hD? ö#>²ò? l8?OÎf? /Z>:Ex>B•Š?1®?AÏ$?1Æ3>ÿ!?y?ò>èR>ØÄÁ>²þÀ?&Ø$>è’n?÷?lo’?EJ?;ôz? K>4În>W‰ˆ>láÎ>b¤ž?B >õ?B=Îî„>à‹P?ca?-i¤>•3`?á>õ7É>6óú?þä?Eˆ?@8Ý?׈?œ˜>ÿcö?^™?Ut?]{û?[ð?@ýQ>æÐx>à U>¢Aø>ù«2?`ɲ?(3œ?-¿´?]v?]£?¹c>Óˆ=ˆàx>Ø -?éæ>™÷Ø>ä¯?7ë`?_·j?'??/Pš? +È> zà>&–>Þq">ë+g?)ùÄ?HE•? 3R?) ¶?"³>®°¿>6i`>©ô >·=¨>fÂ>F?¯Y?YyR?™b>dL¸=ôÆE=†>Žá">´v >¡H>¿[ó?³?;>ª?a¦¤>élÉ>¦ã¿>ñeé>F ®>†W?HØ?b¬=r{0=Ç @>¤ˆ>®Õ´>ø é>ô!D?Ê?©Ö=â³¼?Kî?&Ô>Ñ-ç>ÝòE=ÎC>ÈÉ ?<N?7ب?LÑ?—Þ?Æ(>–Šá>ö+x>£Á›>Ô<Ì?FŠ4?M¬S?E˜»?€>Ó">½U>ê­¢?]rÃ?6ÐÐ>ÿ·+?Ñn?UqT>ø4>ÏtŠ?YPe? Ü¡>tõª>ÄD–? ¤ˆ?’?0>öÄP>Îâ=>¹··>ó¸¥?LÁˆ?y" +?0üH>GÝ$>©Ö?M–?uÑ«?R²æ??n>`2®>ˆ:„?9~?1]?0DX?<5°>ãé >œNº>ü>ó q>ö®â? + û>¸ÂV=3Ǹ>b"?­x?uÞ>ðN,>è_? Â?T ^>ñqb>ÁpS?þ">“7’=^‡@>燼?I>³>Úè5>·„?A~?6 ? µO?%P“?›N?6Z¾?ª@>n7‚>"ºž>‹¡H>ÆD>Ôê]>¬L>£Þu>ÿ»X>È“?œ²?)·ú? —Å?GÂ?k®?Esh>Ÿ?>£¤Æ>ú–Ü>…D»>ßb>Æ=Í>äŸt?F}Ê>ë†=óé€?Ã">ô +>Ì¢?IÒ?´M>û9{?5Ñ?qÎ?4((>Ï“l>¯ý=±2Ä=ú^”>:.=L&>§òô?VçŠ?>ËO?'‚€?jº?xr>s¾˜>ß#1>¦ôŠ>ö“>?'µ>¯IU?H:? ¼…=d?Ð>ÒÍF?¨¾? Ñ>± n=%>=œ>œJL>Ü0u>Ü’ˆ>ƒ3˜? ú? ÈA>žP>¹„*?•¼?:g?¿¼? B>ÝYD?<°à?5öº? +oÈ>¾Ö«>• ·?'”?;Ï?ªd?6Á>Ášd>•Yk>†Šµ=+Q°>Èv>êĺ=÷Üä>æ¥?¦ª>ü“Ê>hÉ\>Z“®>Â<°fð>ƒ¨ý>¯ÝÆ>žH?-8ž?]§?O[Y?b ?M§?}*>u×î>Î6å>Ù#V>JÈ>“DÀ?F?ldâ?K>›;’>ßÍ>‡ãÆ<’Œ >—S¦? m? ø(?E©ª>þ!`?ÎÈ? ´¬?~? Œ>ƒ\Ç?aE>òƒ5>uþ>G>–{ ?q¿?K¹>æ +?G÷>Ø$ú=öYô?$î?B+û>º¸>¨0>äº?äÐ?U7ì? +Œî?*fN?™‘>óÉï?Cà>Ÿéå>ûMY?Ј?*3Z>»A÷?*ª?`>ÇaŸ?!aÊ?>Ü}(?,A|?RøX?@¦_?4‰>ËZº>7B?)>¶\f?€Ö?MÙÅ>ÄO.=ÕÏÐ=ì¥=êc<>Á#•>°—Þ>|Òø>³Bk>î¼Â?0êv?,ÈÈ?®?,ü?*K&?$@¥>¶7‰>f>³lô?6ö?CÆ?4êÂ?AÓü>ÔQÁ>ð¦>äþŒ>UF?†j>… ü>¶kÂ>µ$&=„ÑH>Àäã?QÙ?)Y‰?/.?cžö?Y®ò?í.?0hN?¤>e|v>築?CN? Õ>œ­>1j6=S€>^ôø>_`•=3K°>Ècø?Z*Î?$ >pä >5"À>_2ú>Š£K>¬(? ï$?55/>Í…¦>àKÐ?X«? +ó?é²?+,>“çO>IpÂ?¨‡?}4?cce? œ>fóÖ?>?Sú¦?Cœ&>´€ž<ÿ’ð>°f>™¼S>Õ5?i–„?z96?j‰Ú>ݾ²=J€?Š?GÉ^>£?’=`åh=7 +?OA?S?{:?\»œ?#Z²?"î?mÌv?Y–=Î+t?šï?aj¤?U}?=^*?Q¶•?0rþ?$~?O‰´?o™>»È>?êœ?ʆ?f3?It>ø¥µ? +Î?¢’>ÒÅ)>Ï>–þÔ? ¸ê?)—ø?Qìˆ?pØ'?_9æ>Éüz>MøF?"|?P°á>â½>@»}?-Aù?oÂþ?j˜¢?zÈ>]0?!vö?n-¡?r=?T›j?5Æ>ò >÷(¾>ø¾C? ì¤?=E>á|¤>YV> „ú=þÙL? ð?&Tk>î2È>´ê?,?w¬š?>¢ß?9³æ?x\?U$ü>Ê–>Ήê>×q?ø±?k î?<,>Lv?VÝ>èú’? +3ü?.Ö ?ì|? –v? Ùb?Mþ ?M¿?Œ¸>·Äñ>“‹?°?±>i°Ô>EŸº>ª?S$§?B9>ŒÝx>8Zˆ?Çt>Ñ¥/>ª­_>âïw>2@>Õ¸6? p>^D>Øù†?Rà>Ä»>JZZ? $G?Nð¤?žr?zL?•d?p~?X`³?jF?S(?¼(>åo”?L²$?U¬h>ºf°>¤Ñ³?CDÜ>è¦E=àŽh> ?û>Ǽq?2ÈŽ? (=Ø£$>Ö÷s>½®Q>¶ +p?"ˆ?‘Ó>øƒ¤>ãÐß>×7Ð>Ái >¼œD>¨œL>nPz>º‰©?…Ò?x*?»?'ƒ`?a§•>÷xo>__.>çr>ãW>TBÔ>Æ‘˜>c >rÞ>‰¹1>€?j>ž`>öt=•» >˜èä>„Dh>JXN>hàL>»E?0C–>Ë*¢>y;Æ?dE>Ö–Æ>íB|?>Î]?L¸¢?I…¨>ŸŒ,>[là?;?Ž>×d>šý>õT»>ÖŠž>ê1½?ýZ>Ò·?C‘D?Aõ?=->õ$õ>v?×Â>Í+>×ZA?1}b? ¾?$ >Å«+>ï ?Ô¹>Ø!×>öñ=y¬(>x?NJ?$9Ø?P ?*"Í>ùhl?e>è³?´?MBÒ>åĵ>Ø->ì÷_>o™>ß*5?¹f?Ÿ²>̘??X†>äµ|=6Ø=ÕÏD>³sv?0å?aÌ>B=È? âóâü>€zk>D¨è=ð+h>Ús">Õy’>ÈjW? Qþ?ì^?•>>vŒ´=2å >Ó‹`?[) >òª>D—8>¸C?5W>?'ŸÅ>ëÉe>”'ÏÎ?Ê?%;V>ŠÊý>Ì2À>í'? +‘¡?tÝ7?züc?}ª>½X.??!?CR0>®|>jŒ>òÓa? U>…pF>¶ÿÐ?7¸º?Fݳ>ð{8>e}P>Ç$>@fÀ>Û|?DMš?tˆ>û²ÿ?^E­?'aî?ú?g\Ï?Ñ\>ÀÓ4?:À‚?h==®>´>¸—Õ?Nê?@Ôô?Hg¢?HŸ˜?8£?&?;ß0?A±>ÊMã?Ò\>À¨¼>ƒYO>¾d>G#>}Žšš1¼>×ƨ?y?$¶®?Z¬?0+î>ãI>û>?w=Hh?®ø?öü>˜Ê´>ØyA>Ÿ+>Ãýl?5<ü?(??N2&?5Y%>Áv,>ËÁI?%i?=~M?UÚt?%ä?",ã?-n%>6ú>£aÑ?Pq#?Ô¨?D¼?d­P?'z? wÒ?ß¾>ï¦?7]>±¦> `c>ÚÞ@>eô\>÷N?V>’,??&2—?/Ú>Àí?!zb?Àt?%½`?:Z>Õ³>´1ý>š§?&Yå??eÏ>Šw=h >Û@´?Xµa?qkö?=Ü> ? <?T¿b?UÈG>ùý>êðb?B®?T¦?,@? ’D>Ö8'>õõ>Á@æ>Ù”°?IŠg>ú‰^>•.>©?ì3?VR?tm3?AO™>Õl€>KÔž>Ù.À?-ôÈ>ËKÆ>Àܯ>ì?$ö>ãk¤>=>=+z>©îP>Ϻ2>ê‚)? 3w>Ï©[?&?$f³>¯šq>vp’>ýìû?ÿP? &b>žc?Ed?0eþ?e?DÑ<>ë¥=píð>ß÷#>Ü”H<¾¬ ?V?üÄ>Ýý?rÍh?-dÂ?¼>·b°? Ñà?xjŠ?áÂ>)¡>Ôý ?j=z?>?|À?gì?‹È>@E>Då6>sÁ@>µé>¡›ó>‚ÌÕ>çaÛ? ´?Pwö?£È?÷ì?eu>K®? Ö¶?<Ñì?ÇX?M–~?U$ ?C‡–? >¢Õ™>Ò„j>çi‹>Ž°Û>ê¡0?B0>?XËM?I /?h>ÞàÓ>¾ƒr?ég?K»ú>Ñ í>ªò*?@zL?a`¤?¯È?«0?Yª?9,ž?BUd?øü?7d?j¢ƒ?ïˆ?H@?&»N?&Ž(?Sˆ>ý7¸>µ~ˆ?ô??\bh?NS:?I’Ö?)' ?J#?uÑ£?0A£>¡@Â?õe?8ú?=½b?Kï4>¨Ö»=pëH>Íì4?ø>–á>øEÓ>ì\:>šFD>¾ÿÝ?Ás?@+J?T’??!ÅÌ?Iö>Û­œ?*Äð? u¨?ý?'=…g„>¹i@>ÎKj>ýÆÁ?- ò>Ò•>¶ˆs>aTf>îÙ˜>ü P>!º? ‚Þ?8ˆ?ê×?ö?.9#??>RÞ">½? cü?»Ò?JÔ¼?F]>À‚^>/?²?mú>„üù?"œ?7«?×°?PP?i¥Ì>Üï\>z +L?^é>Ó|Æ>ã´>öXy?Bb ?_@”?ðÇ<º/?h?_UR>Å>ž>¾|Ì?*"c?)d ?B›d?Hë?$ >ï2¦>Š£»?²Ž?;‹„>¯D8>ëgÔ?+Ä[?!æ?=-2?@‚>ü¶Ê>qv|=Å/$>ŸLZ>ÆI¬>>¢>ü,Ò?&£?çT?Oã>àÿ>ÿd?F­>Û¢Ë>Ò@ÿ>¶®v>ˆ²i>ö˜W>̪i>£¼>¹TÆ? à=?˜>ùH’>¿ô@>XX°>ïÏ>ßï>é…´?0u2?/aš?)½û?J>éÛ'>z¶&>_(æ>õ3ç>ÞÏ0>ïs?9Ÿ>÷">þª‹? ü?ã2?¹©>Ò¯y?Š?B?PëK?•A?^Á?M?"üä?Sϲ? =ÖÎè>Æ`>ãy5>&H>¬>üÞQ?3ïV>²×ó>jÐ?}°?C”ž?Û~?NOL?)‡ >>¶à>²Å!?$„?-¶?@p`?V"Ö>¶Ã>¸BÄ>¸TF>œãÑ?5ž>|Æ =¶‘,> #>Àö>_õH>ºò?N$ˆ>öÐâ>Ê´3?D†>–É;?l?^¾Ì?t϶?xVŠ?Ÿ=4åx>ÁOM?G2z>å–]>³©?Ïp?,Œ>Š U>€¤“>£ž¼> S¼>!œ>„þÚ>ìžÏ?)Lº?)„z>õŒ>ä¢ð>µQ3>Ü/Ò?^¸?Z:Ù??à?%Úp?+„?L >°øœ?“?&b?8‹?Ck–?“>’¬Ï=å~h>ö4£?´–?.Nó?HÝ >Þ’>~ÄÌ>Šø˜>}é(>ÖY>œÅ>§VØ?µû?%Æj?fö&?:(>m>œT>îá? b?Wê?q÷>?$7>ï\? l?>”’>øZÊ>è”.?3t> MÎ?N6?+r ? +gÛ?&†> e>Ø©g>Çêù>sx>+L>¿ ?X$F>ìDF=úÛd?Íî?@4l>·!Ö>6%¾>k}6=ñŒ=£ð=ÿw”>ž¾l?%sÖ?%1.?^?Eþm?X'¢>ã=-H>üFJ?Î0?Ú8? ?|¬?/;n>SŸf?Š;?¦3="} >׸î?: >/w \@¨>„ ,>`=6?žÐ?U“r?>>Ø?$Ìq?AyF?#À¡?$¦—? À0?µé?3(? ÕØ?,’?Hã>¤‰±>Ýó—>…ã>ª)¹>šmº>ãÜ?«²?´d?yá>ÖžÁ?*…?Ø”?AÏ>ù>ÿu?òT>{þº>ólQ?H>‡Í>«.h?=\>à´H>Hy(>•õ>Þ?Et8>æ9\>üçâ?³?Ù#>ãbÙ>’"j?˜?ä?Æí?;°$?ZÕ?M ¥>Ë"”>ñ™Ô?P? å÷?2PŠ?J;c??™_>Í]ô>Ÿ?þ?_Ñ>½S'?ôû?6Þ?CH>ÆY>±È>Äè¹>˜·>««£>õ(†>ø¤?"‹F?T”h?]ǘ?MñG??.>ÖN>O÷v>½'?‘×>4 >ó X?Õª>¡Î>ÔéX?CÇF?EO¾?4U{>ŸÄš>†Ç¨?CÊâ?7<‹>º:í>ØÞŠ?úü>êá9?Z?TgÀ>Ýh>=,Õ8>Ÿ>’ê=ÞL¸? iÌ?qÜû?o5´>ún²>õ¦ú?1ÿU?KâK?"c–?®j>ðÓm=¹ ?3¼?92>¯Ež>êe‚?L<>åf>?YB>|XÈ=`>ú ”?i9?)…”>²2ß>.9¤? „*?E¬œ>ƒ6M>œ‚§?6i +?nØ?&:c?Fb=uxx>ºs&? +ª\>Ñ8û?&„?QÁt?eÓ^?Lº:?'œ>–»™>k£‚?E2?Is˜?!Ë">¸È>ììà?½»>›î€?=‹?&Ìm>Ƨ?7%? F>ºž=>׉†>Éb>ÒøÐ?5òk?lÊ>Гª>¥™v>¤ Ñ<ÓùÐ>ªÝ?ô¬>È2>J3>ÂéB?Ô*?Ïç>džT?!?C«1>ÁŒR>¥Ü>ÇË>rLD>ßùz?@Üô?9´>â9>”óÞ>Ûcu>öúî>“ÿ>­+$>ËUs>ÒÏ>Â{•>é§o? ¸?(Jì?—4?!¹>?T"S?0]N>fˆÜ>ÌÍ(?·?š?V˜>ì +¸>`(?è?ee>å‡6>éF?>¼0?û>7âX>ìíµ?Sš’>Þ‘> YÁ??Mü?LQÂ>ܶš>ÿj>ž2œ>Ö 4>†j">°æ¯>¹´x=ú“ì>Œ%?;æ€? Kl>"Âz>³Co?=‚¸?60>¡Â >É€G>ë—µ>Q +†>¿ä\?¿š?2äª?.õ>‚ªÊ>oa4>ÐVµ>Ŧ>²È•?Üã?>=?-¢’”]>ɼ˜>çz,>òE?[A@?jf>?]Ú>¹+Õ>çÚ?]h?îV>¿Œb>ñgç? J?4Mð?dLH?cËî?mÓ¦?IȤ>÷`r?[Ö?KŸ|?K“?&Ö>¸² >ÝV ?UÊœ?-Æ0?(Þ0??$Ý>ÒA¤?Êv?^a—?\Ôý?KÍ…?-Œâ?Ô>Ê»a>êÏÁ?Ñ?S¶?C7ã>Šúê>T£>ÜX?+:?3*É>ÄDö>ɤ@?AåL?2nÒ?-•É?5j$> ü?ÿ?~‚>…”>îù??XB?˜?Šù?Ol>Æ’‚>~™¶?.¤–?*=?)Ò?¬Ù?p?O' >¶—f=?Ê>×±@?MÄ€?ãÖ>™Õ?ŸU?jˆ?n±Ì?¼>¬p©>šR—>Ä,0?è>u~~=Ó»4?…n?g›b?i¨Ì?o!ˆ?6Íê?8=? ê­?0?°>õ£P>¡[>ÕÁ ?3ˆ>ÓE´>®}T>¼>ŸÊ>ÁL&?=º?=>Y0ï>Œ[¸>cS°>÷2:>¾v>ª|9?›Z>‡Ò¶>þ~Ø?=jý>€õä>—eu>õ>l³>ßkê?Xc?L…F?jl?&ìú>Üv{=Ȩ>Óþz>Ä›&>Ø*?Ô|?#í8?lßž?Üh>Éí>Ï9>“Å>ê]î>ÏV? £L>¼‚ô>›mÊ?D ?d'?2;Ÿ?!º>ÑX>¸ä?’?’@>îͶ?í¤>ƪ`>ÊËd>µD>ö,?A>ˆ?@ر?A{Ù?.–>Ø! =_i§=nÿ>÷Wü>èj=I‘=ÙÑ=¢Q®>HÉ>ì„Á?Ebí? ³|=£c?¨?êG>Õî?[k`?(¡™?3"ä?*²>[{¹?öc?F(¸>õf’>'>#ì>îr›?L>ÖcX>®—>Æ\>Hcô>¶û”?„D?30†?YÔ’?L ?S¿?2,?Fã5?˜œ>|ô¡>Îd>›>µßJ>û)C?Ôç?K;>ßë? + p?g¶Ã?EÈ?Þ6>iÄp?ë@>ñü…=xf>¿&ì>ؘÃ>½CI? U>é`?U.>þe>óƒÂ?ë(?)¿Š? Ð’>3(>’Š>ˆƒa>‚¿’>­Ó?b²?=[?=\†?+à">×£>M{¢? ¾ä?O${>Ñ„ö>m>áô”?m£>}éZ>+‹>àÎw?4æ?oC>L›d>«¼>²»=?ê¢?5%)>À)¶>²˜t?È›>Çê>Ù%&?3:à>üöÒ>€¿?>j/Õ>f½p?PÕ?DÎ?WUp?*Û>p¶Ñ=û{:>³‚K>³>Ïr?¡Ã>Âpj>çÚÞ>ÂH?dÜ>ÜUq>ê€? 1=¼‘N>?Õ?À¸?q¥Ž?-">¬ÅY?Ff>ÄÂÜ>êß?Û >±â$>n+d>äÞ>¥›ä>Óð„?S ‹è>¶Ú|? ÈÎ>X™Æ>ºàN>yäU? +J»?1Ç8?ûj?7qø>öž™>ä/A?»>åÞ£>lÝj>óºÏ?.”>þ"g>ö‰,>Ùàâ?+á?mÇ¢?WdŸ>Åù>L? &+?¢d?0½û? +¶?Úø?$>Á¤g>µÒ?ªw>ãž«>í‚“?D£>Ú#X>õõw>Øù@>mmó?$$? Î>ØàÆ?¾r>uZ­>EWŽ?;°t?_v=Ì¿ê=»g?>Œ?ø>Ó7´>Hs=’¬À=™>ÅåŠ>ÉV? ˆÄ².?Î?\Zo?º¼>ëξ? ?H] ?töÒ?[ÇY>ÝA4>Ààò>¯D>vÔØ?¸?L·*? Š>³±?8?S+;?_Ls?B¸Ô?ð†>©Ð‡?º£?8·4>¨8>w¹d?D:?!Y˜?P·?føÚ?.tÎ>³ØÌ>·˜?>“ >óÛU>%ÿ?>²r2?_…>Þh=ýŠY? F?Zeê?½œ?Õ?\$º?r¯Ö?{§k?D°>ý‡>¢ßn>®«Ö>µI›>œ*Â>ÈGâ>É®¦>»’?P,>ù¡Ð>Â">–>²t?j¾>åòr>kl? ¹ä?L[?^\.>èÖš?Oœ?5›„?#<Â?w×Ç?5—à>ñß>÷—*?=°r?A’?~©? œÊ?-Ó?72,?6Èü?'¦??W>Ų¬>Úí0? Ø?ü>«0Ö=rëä>×"?CIN>ÙRî>Ýíª?^‚ ?t/ª?C½€>«­ >ìþ„?&ð¼uz>(N=iÿ—>çý ?oêá>ýQº>ÄK >û‘?Á¼?p=x?5ö˜>ÌQÅ?'nò?´?‘?r»"? ´>”gm?Ï >þ¤×>íàÈ?-S?1à`?kË`?gáq?BÚ?+æ?W>öÞ’>ד©>B–j>÷d¸?J?'>]8ð>?,=DÝ/>¦â>¿CB>o=¥ô>ÒI#?L M>á­P>ÊA_? “>®1?2£ª?+Aò>µæ?>Û?Rö>ЉÈ?!ÝÂ>½ºT>ðÅ ?=W>´è >ÔQè?ž>­cò?CŒ>Å- >Ì@è?0ó˜?#›:?>Pû?P +»?^À¶?q*>Ò”ž? ¿¾?¡ò?HÎu?ì >çÀ?r;>¹ÇZ?r?@´K>­’>>DP> +Ôò>(üí>`"g>õL@?N±%?¡ù>Ò]«>׺H>¾>EP?t¥?!áì?7ê>úpÍ? ,?cÔz?)=–|>ÓóŒ?A?#ê>œ¨·>iØ>ÍÎÖ?‘*?¯ö>Úz? †r?9'¼>óD`>a¨$>Æw¨?6ß÷?ná?‘÷>׳h?Áõ>Ž>È°œ?>Ÿ?/>D€•>eDt>¤«?’f?I+Ð?1—Z?À&>÷ÉÃ?*ë®>ÃÓ¹>Û†`?Oe­>»„>º¤Ñ? *®>L³>Æé?6#¾?)G<>ð¶˜>[šÐ>#h>žR>°¨H>¬¡Ø>®QÎ? bZ?6PY?0ö>ùVÊ>ßuÅ?Mˆ?6¿?¤æ?+hˆ?Q +?Ô?,0f?tê0?V/~?@–>i]†>VbT?"wD?Ds´>ÛÊÂ?7ø?!œX? 2Œ?[Š¶?T:ä?3”t>þ¼ ?°?Î? ïÍ>Æ"’>f÷>?ç÷>óX&>Áó?W?!yÖ?~¨?›’>Áæã>à4>§Õ¸>+jl?R.?(~>—É?2‚?\]5?©‡>¬ˆ¼>ÀÚr>‹ç->ŠÍ„?óô?aÃØ?1îX?ÿz?ô?‚?BÎÊ?¬=?UF?`?Oíx?8Û*>Øœ¾>![>–:˜>¯Nº?è†>ðŽü>Ir[>¶aˆ?*.ü?$±Ž?}ÿ?¬¿>·6Ã>æºf>£Œ”>}DT>ªZ.>î>³â:>ãZ?Dñ–?91¤>÷ÝŒ?A&?ÒÖ>¨oŠ>…>‡=Ã{T>²%˜?é>°T†>—æ³>Ôð>³œV>‚¼*>'¸> õp=Ä¢¤>Aþ§>Ššü>¤Á?ØŠ?)š6?>9³?*l>Íý? “Ê?tÛÆ? Œ>;,?$?~#>â=1?=˜©?/þ>öiÔ>û{\?$¼?.ô?N‹?]ú>©u<îsÎ> »0>–>ˆ•J?–>µÎb>‹v”?2á¢?$3&?o“?K"°?$¥>m˯>E=ú@æ> ™?êž?=ÞÄ?2µ–?JUÞ?< ¬>õ$¨>²Þ&>¼ët>w±ò>ëàz>ÓøZ>×b.?0 +?CÕ ?"D2? `?Wou?$hô?g? ýH><>ž}>ãA? +£b>ÊÌÎ=7Öê>HŸr>°g‡?m§?Vj¼?-{*?!£–?A|>ÆÿÙ>­D>Lpþ?të>í¼Ù9f>Þõ?Pûm?MÆü?EýZ?CÆ>ãÑñ>¨¤º>ò>â´Ô>ÜsÞ>…~Z>N> à>rËÆ?ƒ¸?7U˜>×-2?Ò?%’ >Çx +? :?@J>¦DÆ>§ w>ñJ +?<… ?Vjâ?T•?5’>÷Ö">å°>>Œ*Y?÷Ê>îúD>9ìŠ>ƒÏÑ>Çf?yì>ßê{>`@>Qª)>’t>¶è?'Ô?ZŸ”?JÄ >¯Ë@>H¾>îc\?0[‚?¬¯?Ê´?Ddö?&'š?Ó$>ž‡Ì=hŽ?s?JQ>Éq ? Š›>ÖåE?k*?·(?\l?$Ø?¸ >ù8D= 7=ÃŽå>A^?æÂ>ìò=ýb>Ùa¾?'0È>›–>Ód?‘ª?&¾‡?>Ef?]ÇZ??•?I´>äQº>Jç"?Èž?W>·z? ’>·vG>Îcº? ™?"R?3ÇS>u9>Æt +?;¾?Q‘¿?d#'?-ü€?.Ô(>öˆ? +æ?Z6ì?"€>„x*>båª>ÆÑx>þ“Þ?Wï}?%¤?6ç?T³<>ÐLç>Óö? öR>Ò¢ >N£b> ݘ?ø¦?.…5?þæ?)ª~>ó˜>WŸ?ut?BX>V† >øÉ?;Ù>Gš>ÄZ>èü¦>Eï8>D»Ø>å0Û>ñOž>2êô>”=ì>Îmè>ZÕ>ªØÜ>Üût>è³G?,ñL?,ò?-Cô>äE0>Ä x>Úm= ñW>¾%ó?B"÷? Aj>»f?&üÊ>ó^>’Ï6?D?1xü?1:Ø>°•>öâ!?U£ÿ?C^C?;uØ?‘÷? 5 ?S†3?€?úâ>ÉÆ?Fè8>éVˆ>ŸÆÒ>µßN> °H>‹@6>êýô?D?;g?=#é7n>‰»>ŽYô? B?6¸>›œ]? +8·>ñÚ€=Éé=>×ôî?î>Á5 >Ù~à>Êãä>}Gh>êØ?@Ò"?Li?*‚ü?3íb? °–?-½ï?OÒ,>Ü;à>ù=‘:>1 +>îÆÖ?Gî?_Y2?K#°>é¿ä?Ù·?h:J?V/>¿Ÿ´>ryº>§/m?áÈ?fx>Û Þ>¤”ú?PãH?@·Z?2Þ/?];Å?#^>êk¸>˜T0>„lú>‡¹Ã?=È?:˜v?E¹ž?-J=? +€R?IÖ >ÖCÂ>õ®>†?.!¼?lHo>ëÚØ?å»?QJ>>ª @>½Ep?KÑ?aÂ>‘>—¿_>ùÜt?7Ó°?=w:?\·Þ? ¯>Ý ?2`Æ>ßë—?Ô?;ô?3Ãþ?xk$?p¤ ?.ýX>¶¬H>ÞL3?X”>ì;l>±¸ú? +™¾?Kjþ?L ”?60Ô>•>w>÷´>õý0=©T‹?t~?C8·? ì?@Á¬??¼? %>ý«>ïd€>þ ¢>‘P>Lî>Ù =8 r>÷9ª?EÎ:>Ðo°>ëšg?!c5>‘Aà? +„´? T\=@“û>Â,>6÷†=n>°’>É´>°ïì>ÌM¤?¢?~¸>²GØ?%~?¨³?Ƽ?Òp>­îý>ÓÊr>×5?">Ö,ˆ>‹^0>ò:>wÝâ?9Ü?2Ì?J†¿?y( +?Pô>:ª?`ú?±¼>ã£c>û_>¨>”’¨?ºj?FÌ“?EP>V9>ç¨á?!FL?n?bq?*¨ ?bä?S|Ú?µ>ŠOŒ>yÔ>Ϊ^>÷Ë>‚ò>¸[r>ûÈB>ìq?2*’?!ê>äî’>¡æx<Û¸Œ>¹’>tø0>¾Lš?ö,>ºp>¿Wù>«ˆÉ>`®6?Ï%?"ùÜ?¤ª>â h>ç6?\¬À?Pb?P$d?i½‚?Mž—?±)?µ‰>Ì¿Â?è>ãfÊ>ÄÉ×?eö? %.?mÕ?è}?"øæ?C0E>¨Ø«>]'t>Dµ>À›è?Qç–?p”v?D#æ>åÏZ>ê%>ûqÈ>µŒ?Ú?'6 ?$ B?<™a?3uµ?DG~?®?kæ?8¶?Mš?*íœ>÷^?'”2?#„(?m >ÕÀ +?Åð?Q©Ð?"i?2w²?Gef>à“@>`c(>÷öZ?M¥ê?Eð>oª„>øœ(?H»¸>—c>?Ì ?+ °?&5F>ßq >â…N>îÂt?¤è>Ñd>U¦>8 C>éñà?åz>òµn?¸ +>ò‚ð>â‚Ù? pï?#Æ?[ ´??Gx?¤"?dMÿ?E”þ>Áá_>Ôî“?6ïš>ÙÏŽ>uÛ©>“ļ>§Óv>·[>ì?*˜•?\œ>Ev’>¼ À>³mq>a‹?‘?"&8?5£+?dƒd?"yL?;5?MØr?Z˜n?Su8?' ?(oð?ü~>¹rà? ƒ>>«¬?ùÒ?*Æd>ÑŠ>ûêü?Í„>ê5À?”>ÿƒc>ص +> =¨Î=‘‰Ù>´Ž?ø‹>ß »>¶#t?#š?Sóí>ý°ˆ>–™à?)Á–?-'>Úç ?"¡¦>òJ@>àË>ßü~? {~?#Hr?3ã¡?3,>¦v? õ>½£/>W,n=°wŽ>êä?ä=§m>šBý>Ë£>nú?ˆÔ?8+>¾¡>@ž>·€T?;£p?(y¤?6 ??µ>ñ#ð>È™•?Të÷?Têa?4>ÌÁé>®ó”>¹8ž>ØÄ?Ýr>„Ð>6…>Ÿ6è>Š<ô>aÈX?/52?h‡>Éú6>áë>íÀ7?lÔà>è×8=Ðݸ>ÅÀÚ>ÁøÒ>c¯ì?!ˆ?>q?,6;>¬­š=õ“l>(¿H>«1š?+M?‚8?&ïÔ>㉺=ÒY=Ñqã>u#>–l?{? +DŠ>óøy>ä˜Ç> L'>’ý2?èš?rò ?Oîœ?,J? Râ?9ŸÍ>œ<>b$>r6â>òÙ˜?Æò>‰?Á?lÚ?&Ä?*j@?Cþ?X‡t?;æ,>èxœ>\>"=´.…>0xb>!qÔ=0c +>b'Ä>Ø>YÎ>¢—Ô>¶9>ö&¾>Þðx>‡&°>èâ`>Çk'>`c2>…h>=“ðø>Ù± ?Kó€?NX??ù?=hF?"–>åõX>þQ>‡Z©>é[ˆ?] F?k2?l'Û?c¯`?võ–?1É’>^Þb>žÄ0?+æL?aIÈ?¾p>ë?&¨x?h>ðÙï?eÔ?ÚÖºÊüÐ=Ð'š>Ccü>tœŽ>âÀ|?Eæ?.p2>›£ž>­Jè>”à8?ѧ?S„>ß'—?B’Ô?6~•>ôR(? ‘?B¨ˆ>õ5~>Ãò~?É,>g˜?==?o2>?ŠÁ>“-??´È?\SÓ?­Ü>Š…?ÒØ?P[Y>ý +>œïV?NÔ?Qïì> ¤<>Ÿqv?7ýö?$×;>œÿ,>yÁ2>ÛŠã?©Ô>¢Ÿp>Vsú>ÖÍ >¸9ž>Ár=iIO>œ@>ˆõ¨=}¡D>]‡>®t$>Ñüž>Ýq>i´>ö7„?fp8? 2?$“?c¯ ?b•‡?ºt>·ÂŠ?@ûb?>Î*?,¨=?/'s?7(}?2ü¸?%ôñ>á:š>µÖ> WB>M,?x?Iáì? î”?õ?mü¢?;¾à>™Ùp?í?C D>ÉŽ >Ð=H?ÑK>ŠLz>˜Gþ>§B=<1z>â3ˆ?´-?2Ö?b>a>ë%®>»¿Õ?9;×? +P>¯þµ?ņÆ>°$? G¡?)Úò>ÛóÁ?%†?p£1?TT‘>ÝY)>É…>Û5‘>ûµ?-+C?-C*?-o©?"Ĭ?Xȼ?9¿0?5«8?(d(>…=F?£^?[*ž>³sœ>ðËP?SšÞ>·~>rÒ´?EQ:?3 ?-º?2²?Åä?XrÆ?:ü? +R?',B?PÖ>Ëšƒ>ï n?%æì?h¿§? 2[?^Ö?m°>ÈF>tÚ>Æû?)&|>è>Ãå@?/.z?fy>ž{H>û,u?/ÿü?hÕ„?2´> RG>Ý=è³a>XØd>¢EÜ=Õü|>Øuì?dYr?Û'>8Ú?ýš?d·Ü?'^>ÚÄd>ß4?+2>ßا=Ø0`=Åñ>?È–>øô>–ì>?1Ðh?ˆh?):6?,§Ø? E>øh>ØHà>÷ÂT>¤Ã=?g"? +O¢?>fú?evÄ>Úžä>Í[ª>çà >ˆ=.>M·p=VÌ>Ü×â?ùÏ?(\™?Bצ?,rÄ?j´?~á¾?:ê†?Ù@>³§Ž>ÈP¼?hü?i?/1:?  ?*¥^?PF?>K„>¶_ü>Øp?3V²?PŸÉ?,¼Î>Þ]?¯T?…À=‹â=Ëü½>°ë¢? ~˜?5Ç?I3Ž0o>ùQ?9JÚ>°Ø¾>ÀpÀ?:Ö?^ŒY>ÖKz>£Žp?%¶>ôe>Ö—ô>ÓðÀ>ؤ:?+Í>×BÆ> {@>¬Œ?Ùà>ì€ê>K?5[?)G"?ÃÓ>àǶ?4h»>ìÉJ>áW ?0XÀ>Waš>¿cõ>ßU`>ŸŽv>ç±?.P ?P§?Gîú?dlÏ?D¼?M#†? |2>÷jZ?8ô‚?K†f?Ngæ?-´?­“?Úß?ÄB>¿Ï>u»>¬P?6Â?1nð?OiF?IY€?8_?–>å¨>ã©X?P´ª?QÏI?V'T>µG—=Wã¨>=†>ƒÃl>Ýj>´™¤? Ïz?Í>[®h>ÕµE?P?‹ë>‡ñ¸>XV +?zN?Eë?d)\?»ó?­«?mh?0>à{K>Î+À?•(?U#Ö?YD ?2.>ǘh?D?HÏœ?;Â?6©›>ËWæ?½¹?hZ£?) ?Cí?¿l?»Ò?3r>ät?W´?!çú>"Hi>û@l?E! +>ʱZ> "¨>?#Í>ì‹~? :>Ò€>ê°n?4‡¾?øê? š-?Z ®?DV> Hæ>ÛD?.ºj?O‚?¸˜? ¦¶?mc:? ÁÐ?É¢?n³?º>æ}Â?!D4>º`9>wóo>¶»X? #—?e€Æ>ý8ü>Ü2ˆ?:d@?)~?:Å"?>o¦?DßÊ?ÖÛ?,Z?Ó€? ~?@ |>§NO> [>±£`>ô¿8?@G€?+ñJ?Mô?l’K?W‰ï?U|¿?qgÆ?hîž>é½*> ?y? :Â?:r? 9ê>ô‹Ì?P”l?gØv?ÌJ>L,>Á@.?+d?6Æ“?al†?2ÙÐ?—? 2X?)î¾>Ó!n?fÞ?!x>n6>‰)>ì>÷ɺ>bͦ>¦‹?* {?X=X>îàö>‚wB>« ô>—vÙ>Š#‚?í<>ÒÄy>÷)R>Ù%Ž>‚öÿ?4t?Gƒ‚?%:î>@¸X>Þ-?]–ø?'<%?n?_¤ù>ÿ›$?åx>èf>AȤ>×è¹?ª\?Xù*?mb¸?L +Ç?FpÜ?_È >ØDp>ð4¢?¶ð>Ò=Ä>’h;>ÆlÊ?'ÝX??)?"]?F>§ïÛ>‹;º>¡ Ø>vjb>,žÆ>Né>—º?~¹?Sñ|?˜Ž>ÈÑâ?)‰>ù׆>¶ƒN?2¶?U~?íò>ÑIÐ>×\ï>ÑÌU?$Êø? š>ÂS +>ô%°?õÛ?#z>‹>Ê´ç?1Ú4>ÿ0%>uÂ[=©>ï?>F*>ÿ)ž?))?-¤Ä>]ö>°r?ß¾? ¨?mt>¶·j>• Ý?„ê?)’ü?Mý?;dU?KÝœ?À§>—*>¢0Ð>±ï~?hß?Q”¬>ýYñ>B >üÅ$?ž´?)hÊ?0:z?=r ?W ò?æB>ä·”> ˜H??d' ?n÷®?9‚C?;F>ë>õ>1ú>?Žã>–Gø>˜”Š>œ'N>¨éG>ÿ—f?a’.?‡a?C|?*÷r?¦N?Íì>“Úí=ä³…>$”>ܱ +?0»>·=N>íAš?tôˆ?C[¸?Q ÷?S>qâ>.“Ö>Òè?S?nXÆ?JÙÊ?—|>†²ò>>“~¬>’›D?Z?ï=ÜXN=ÌþÞ=Áòë<ä=˜=‹™ó>é&Ø?B"å>¾ˆ(>’I? Ž®?3Ô?0¶Ü??ùb?w$?MF—?2؈?>Úk?aÒ?K&;>¹§x>ï?üè>ã¼>{EV>ð¾`?W ?H$*>ùmÖ?.wZ?X¶Æ?UÎx?yÞ?2\ì?l¸>ý…¤>æ• ? T>ê8¢>³E‘?!­Ê?JÉä>â«Œ=î÷>ù7"?(ù?#Œ?#¸ì>=#’?þ?)öp? >ñ$Z>îpž?,X–?^Æ?Sã>ù—M?FÞF>¨Ïê?T?eÞî>ôèÆ>ßÄ¥?Ml4?$KÒ>\ B=.^<ûö?¾â?D>>‡)><¥Ð\>¬H?5) ?WC >þV:>™ò>ˆ?Qú?mu?¦‰?Ío?D•o?61À?5„>F…>P>Ô>ƒs?È&>÷­þ>“݃?Ú´?I6?7s/?&¶,?Nò_?yML?PÞä?„O>ËŸ¼?¦F?AN?øŠ? À?9!‚? à?¹?K~~?j^? +:x?WWT>äu>>Ü>}“>ÄÔ&>Ý–>䧮? M?H??#»?1’=?pC„?gZ?Ty}?Mo??ÒÞ?O~?"¥ˆ?p£>õ8>(1ô?¿ê?DÛ.?-¼š?fö?Q¼P?ô?Ù?R}R?Þ> X >ìL >Ñ™=h²x>€hW>‡™y?™K?B ê>ÎÛ>+¯>zÕ?Þv>âVª>ÜJø?‚>±‹Î? à?-–†>Í×|>‹~Ï>BÏß>å”´>ôÎå>t ]>´]?$Ås>þ©>•ò>)¢I>i» ?1S?fj?\~ó>þz>ˆ)&>RyM>t£? O¦>Þzh?_d?@Ù>Ì—{>ŽG ?fÞ? ]d>…·>¥Ó&>­"˜>ä<1?„‘>®1>TÑÊ> +Oä=ýå>‚pB>Àg¶?½˜?:i>,Å¥>"I>6É>FM^>ÙuP>ÉÌZ>2"†>¬ùü?5u?Q)Ž?O>Ñ-~?%Õ +?7#U>Ø?Î?¿À?mzì?eJf?9Ê?EÜi?j$"?#=&?#ØR?O©>üC”? ×~? 4°>$‰¾=Ù”î=ÉÏN=XJ&>u>£…>” +g>™~°>çà–?9œÌ>Üôt?a?/7>Þ2>šæv?#Û¨?<6?°0?,÷-?Hô¦?ø?K(>×ò—=ñ‡È>¥¯d>Ã#›>Ec¸?8?XŸ¨?¸Ê>ºÉ>5@*>ïAß? T)?R?"2?”‚?ló)?A¦¨?Z§Ì?<ƒx>ÓÜ!>TŽ->ø­±?Á= +>®+>©¼Ö=ÉYm>j<¬>•o>7 Å>˜(u>Þ§&>Ę,? ¥À>àðˆ?2t>÷Ÿ”>bëº? ´?(¡è?(¸ ?Vd§?.[L>͇Â?5H]?æ²>2y>ʈ?I´²? ¹Î> „H>º û¾¶>iϾ>í†ü>šR'>8»>­O>˜Uì>·¿Ñ?.´?üp?=-p?¶¬>݇K>³R¼>¼€S>´àŽ>ÒÙt>ì~™>›À?0Æ?WH> Ž>Þ¹ì?)³ü?>¨W?HÊ? ?MæD?Jì¾?±4?„€?D…?k/?<¢j?f¬B?i0ó?nóÿ?+V>õéz?? î?IÖ=­#û=ÈÔ²>ªâl>¸2]>É_>Ú@D>„l>™,>_Kª?"?1†È>¬¬>8á>ln ?´t>îÈ,?~ ?XÚ?B²ô?/6”?5ûê?Ô>¬:T>…Å£>“=¶>êN>àê?;ž*?%÷>í×o?Dý«?HîO?4j?F¿J>Þ1?ƒv?#_O?:¾?*îÞ>£'.>â°>Ø2>ðü«>Áäp>ž2?.µ|>ï=÷¯w>¬‰u?H2¬?sOº?œ€?L?ch>¬¶´>¬È¶>ë²ê?`òB?ü?#'.?QúÓ?2“†?CSÿ?_“‰?OYø?,EŸ>êBô?Â&?Yåý?Z|¶?Lùû>×Fþ>ÜËþ?+2>ºuÖ>ik2?$oÚ?~°–?C¨P>âBò?Öˆ>¼_Ò>õUø?5l2>{9Â>l ø?Œó>À™x>å×?#“¾>Ôh>Í(@>éßL>õ€ø>¨>(>Ý—†>ë°u?$¸Ú?ú,>XÁd>Í›¯?:ËF?[åì?)ö>Ì$¦?Ù&?>?7AÀ?Av>›‹^>ûÀ2>èJ¤>a3´>ƒÊ>ï|Ä?PZÓ?LtÌ?³2?ýB?Z!ä?Âd>¢|$?œ?^X?Ô>ê¤Z? b>œäð>—œ ?Aï?Yó?MÏ?\–ä?Bù4?3Ñt?bñ@?f~‚?5DÂ>ôK†>ñåà?2ôÂ?j;å?›>ÀgŽ?Á>ÇР>i?z?&H??v? oß?OHŒ>Æú>ê9Ë?&´D?*?1Wö?m]±?,Ó†? :ý>Ïä˜>˜„? +«‹>”Þe>pðþ?»]>ÊÙ;>@?Г>¸â>Ý‹5? è?7!?R‚‰?)?7ÛÐ?<›j>Òï>æK©>ÒKV>¦>Óø´?3æ¾?FÍ]>Î÷ >|Œ?µ??ï>¡‹>h€>‚‡N>ÑŒÐ?]—Ô?e²0?Jæ>@Ö>ýig?l&$?¢`<Œ>Ô·Ö?7"?Pû?M,p? ç-? +Û?/bî?X\?er?F@>ìÒ>@N>ÂýÞ?'Šð>Ë_`>šLh?EF?ý¨?$Ô?!®>—3<>à ô? 7 >Ù¹·?/">¯’O>ÖÍ?&8x>µüþ>KI>Ò†a?8ß½?WŠ˜?(Ô@>ºI“>­8ó>ø8j?."p>Éht>ŒŽ?!uŸ>²îZ?äˆ?{Ó¾?iuõ?lV‚? +?S?!%â>­é>Nmà>÷"È?M#Î?I­T?x›?].u?)¨?¾n>¿ É>›©¤?““?‹ú?(™?.ë¤>~Z2=ý&>Å X?$ô;?T²?($d?mÔ>ÌDü>‚±>¼øñ?.A?‘Ú>º£è?3‰>¹¥¢>t‰>?3•›?šŠ>é?(? n?D«?káN? i¬>yÅ$>öþl?[@¨?À +? ® ?h!²? 3‡>Ð$,>ë%T>Œ«B>« Ì>§·>?Ã>¾k¥?"›r>Ê˾>·¸N?LÀÝ?bTÚ?OKû?´0>A>ZCÔ>Ñ—ð>«$w>O>Q~ +>MÞ=Íyœ= É=pœ >»7>»vú=µrÊ>}\>ù0?3ç”?FƒÔ? z>¢£*>™?“š?'ø(>©,¶?Ú’?j”=ÊG>®>6?N{y?t}?P« >ø‚à>kuà>üfâ?Ä>ùâÛ?Mžô?'à&?ϯ?úv>¾`?)‡B?‹¡? E?+Gš??E“S??¦–?˜>¤5Š?“ú? Iì?%£?]'H?Suš?H;??^?æ>É'œ>”± ?4g=?9ïµ>ס0>à±>¶Žñ=ä@>?æø>1>H>¢s?'³C?¥ö>·¸><Ý>ª7?@òW?c# ? c€>‡>ã" ?:ñì>ÿ×l?¿F?_ +?SÐ.>ÄvŒ?@ÐŽ>Ɉð>±ÙJ>ÆBÔ?l~?Ëò>”<&?#N?W¼Ì?CÿF> Ð¹>FÒ? ^?–­>L-B>¾2>Üx ?;z?g%„?G·œ?1Š? Æ>˜ +O>Þ%í>Ô}¤>C6^>†#K>ÎK°?MGÞ?ZwÒ?]½?D†? Û?2ê¨? Z>³æ? x?Z¨=•îw>)u¬>ÞÞ?è?Hš·>õ‚‹><6>ÐO>‹Öø>¸´ü?0šV?[ ö?;ˆÀ?¤ž?&Ñ?0Ø>¤Ù=Ñ1¾>íÝø?78>»†ã>æÈú?’µ>@Ò©>y$ê>©¬G>×”ö>üVî>d°¿=Òu>íèË?*V>õé?/‘P?7A`>Îó>ã#º>ÑÇ>ÕL>—fh>í^>ó55>q#þ>Åáº>Ò“¶>þÌ—?6b’?}‰®?]X±>Æ™8>\~þ?4¤ü?}í®?4½Æ?8ˆ?aëd?=²>ø7ª?)ªC? Ë{>Ñ~ï?39>Ø>Æ‹ˆ?±à>ž2ª? ›?%>Ix‘>þ Ò?q:é?*¸î?º‹?9¼óxk>ùŒÜ?*‘»? +é?6;?ë? j^?†^?,x!?*Gr?Ôò>£oN>œ¢>9ê>³ß?N>~ùý>ú|*?6àÖ>ø¨á>kà'>÷!4?¸9=®L^>Ñ‹o>ô±º>×~?Tœ>ñýÆ>vœ?JW?Û,?è»?Z0?*‹@??4Z?Tê>ßD>°Ð¬?’–>þëö?ƒ?¤N>”Ê@>ÁW?'„>儾>$ ?’?Rê%?B?S¬>¬è>p?U>Ú8´>7ð?.²J?€>'Öó>C±Y>RÀ>>ß>ç†Ã>¯[À?1µ +?”> Û>=8>ºp©È¶>Í+°?@Z>¹±³>šq?ô‹?TR>Üe^>“Û“>h‹á>€r&>[HSŒ>néF>ç²±>ý$>1Q>‚Ùž>»¡+>/Ï5>È Á?^nR?4Lë>–ÉÐ>uØ?^¼?i¿n?\ÇÜ?Žæ>æù5?Ü>¶pN>üç?7Ãö?U…>û† +?”?_¦°>Ú_È>ûü4?WÉC?Á?פ?,4(?/.O?g‡?°>Ž_?4ªG?!«g>I;@?X®>ÝÈ>ã¢? ›Î>‰V"?)”ü>ÙØ>Êûd>äî”>·g?TT>Æ¡’?'ì?B >Îæø>/1*>‘ +ê>Õïž>½IA>ÎôÇ>ÒhÚ>CTŠ>à[¡?5ì6?A?D»£>³0å>NöØ>S÷">ßµP>Ñ~>o >xqø>Óƒ¡>ôj>¹û˜>ÍÊ>—;_>Ýw ?1>ŠAR>Œ(†>Ûpp>Š‡ü=øNf>¡'B>ù c>ì—®>ÉÑr>L›Ù=Ð:>õW>và>Â0`>•€>û»÷?sW²?Qu‰?MÛ.?_ À?(,?¶>æf>û>p?3µ?ÆB>Úmà?]j?,H´?+çz?!»t>ê²?@jÖ?ÅŽ?Ñ>ãAÀ>Ý“P?A»Õ>û[¨>}ÕP>öÊË?a>òEw?%pô>éY>‘ŠD>Ê, ?[?>q¸>¨Êî>¹->Ø߀>ÕQ>.GQ>i^ >å×0>€o¦>étˆ?-÷­?Ž>îÔ?0>×9>%Sz>‡±Ó>Ö!f?e¼>ñ^|?y8?6$Q?>¤?SôE?m«W>ð„Æ>ÏQâ?bÅÜ?-Ö?ãÆ>þ,>(0æ>…HÎ>mJl=_é›?ÑC?l–V?U®Ì>Íó>Ì?]ø?A^«?CÀ?Nâæ>¨‚>/ ?5Ö?+.?ãê?íÚ?%}‡>àŠo?*\>ÿu>Ž%¤>=ÁB?p?xø?„?dP?Dp?Bå?Lÿú?&þ>ÚøN?G9^?Kë>Îäs>êªR?S¥Ü?;:?zG>înþ>²{ ?‹f?>`.?'@;?Ç·?‚cv¼>Ía?Uú?F}Ò>û>`\¢?>Þ?PyL>éÔ×=úJÂ>0q>öÞ²?AG8?H>ê»Ð?C8¯?iNZ?a£r??¼E?·|?*†j?QV?«À>ÂÖ>î©?[.ø>°û>´ãr?()¯?VÐ?$…à>ÆåÍ=‘tn>}.>`> ZV>ö6ô?ÐI>è£Æ>ÐêN? 2>ñÄ¿>—¥å? ÷J?(¢?UØ2?RÖ„>ÔSh>Ýæ?#[B>´à8?Îb?KfÙ?"ëî?(†?V#ž?L?:sô? 0š? TZ>ùç>Ûˆ>°æª>zC>6Š=Î"?¢?mº?.ó|?1·”?c/ò?"+â?602?$åñ>á[Ä?K¿Ô?d?-î?ôu>³Àæ?\‚?õq>¯¼ >ÙÂœ>»ºÀ=ünZ?ë?p>_ê?öV? +]f>ñ$½>WTò>²|>º/>Gý²>agº>„ÀØ?<Å9? >²">ÿô?>Ø?i=Ö?-?œ>ûðº?7õh?~—|?oÄÚ?UÓî?NÕ>?h)¥?f,†>Ýá=,èW>öÄÜ?eD?5â?3o×>U>ÄEB>¤^>'=T?ªè?6? +Ó3? Ë>"n>“3I?rü?;±=ëˆò>û~?w*0?/,\>àÎî?Œã?:"n?1w?$šÇ?ä+>Õ¡–>|a8?ø©?5"j?'º^>íi¢?¥à?U£X>–Æê>ŸÞ>Ò¼ø>tüN>¿­>fý¡<é.>€…i?áÿ?  ¹>²Ù®=Ðð>§o·? ,>Ãlþ>²Šþ?$œ?[÷|?q¬>ø9q=’ Ò>/›¡? š ?]m?r#?ä>º/n>¾Âà>¢?!-?P®Á?%¹?@?Ý?Hƒý?Ï¥?Üþ?’J>ÖôÑ?T]K?@y<>÷Ûx?*ID?Ï–?"œÀ?uO;?(Ѻ>F²>Šý¥>ŒxR>z.ó?\?C¨j>ÛI>(ñ„>»"x>ùî>Þ~>ý8 ?,Å¥?úÙ>ç1@>uËx=¦f?‹r?*>¢û–>ÛXø?N?XÐ?NÓ>±rÜ>óÞø>Q>W•Æ?w]>Ö]ø>¿s‚?E Y?#5?|ì?@¨j?­?;Ò±? >õq?gø¢?ø>Ûjè?-8>ã+Ê>ä0>óêÔ?RC?R/?-JB>0L>Ö{Z?F«£? 8þ>QÁR>÷ƒ¤?Iòp?\?$s¶?&¾?>·¸?e¾0?¡ñ=ÿ˜>ýžf?k¼v?=°.>åVž?!?@:à?Nfþ?lÑ?TÈx?¢ô>äOñ?XF?wô>§? Ð>ò÷Õ>ñ–Ø?ƒ¤?Hï¤? +cü>”·î>ö’?XÎ(>Òµz>Èmþ>ÉŸJ>ˆ¾>ᥙ>®rM? ã>ÿ@`>3žÊ=f!k>ÏŠ®?Fc~>þ¼r>˜ç?…â>µƒ>Þœ(?2‘ï>ÿ‘6>R¦¥>èƒh>ÿ÷Û>â®h?G{ù?5’ä? 'ó>Ûð?;º?H¹§>é?çB?2 ¨?à?*"?!2ì>Ôl¶>Ý­¾?÷^>Ûˆæ? r?EhÐ? +27=ÛÔT>„äG>ßä?Fì?Å>äsi>ð€V>kn>…¯?9 ?3?£?Ü +? +ª>vV>ñíÀ?Zv½>ÍÐ@? +ç–?qg?s>É¡ì?9Õ¬?„Õ>¿+?-f¤?H8Å?7?exø?_4ˆ?-´Ð>üœ?$‹´?l–=ËwR>ï>N>ë—Þ?e? +2Ê<™9Ï=¬7Ô>ü#?PZ’>Ïè>Ójž>ú— +?˜?u¡>xŸ>3$Ì?Ví?Åñ>»íF?@Np?Pò?sß?:^?8»d?ý>ŧp> >k±>©>>YÒ>ãpÈ?²Š?7=¼|à>>ææ> ¶?¤>‘Úâ=·¯†?â6?ÀE=Ô´?uÏ?|ø?sê ?.ŸÃ>´OÊ>}»6??R?Kç‰>Ý—´?Éì?By«>Ö¡´>¨” ?P°?Bˆ>¿÷>à ª?-uÊ>Ó¬>>^®Î>¢O,>¡}"? 3ß>ÔzØ>ب>¾Mj>û8Û??Â?X&>È6>Û´=?;V~?H?>n>±Ÿ +>4s?ÑI?Ð=…Ñu>Ý[F?bÀ‡>ø¯Ö>•±m?ÿ‹š>‰ªd?vÊ?$©>¨œ?e`>Îa.>V]È>§áÞ?/?¸¨?­„?"†Ø>éÑ(?-vê?Pö?{ö?+ô?LR>ô‰~>ŸÄë>AH> x¾>Ûšz>òÌr>Üäú?j/°>ýú>6á¼>ŠWO>˜>µT¢>a¼Þ>Oø>È{>ðN:?C€?Yqº>èÆ4>š‚†?±T>Æ­Ž?`ö?%F>¹>Éú1?%T6?Vé?+%æ>øu,?3Ú¾?O‹? +ν>b”>XÊ>š¬×?,ü0?¿é=äNF> T›>•<Ú>íIÌ>“2>Õ…+>ò6è?ü.?™>Ðw—?^" >ß,”=Ñ΋>ñ•5?^v(?M4:?>Žó?J·:?j?£?5P†>ï||>”È ? n?ÊŒ>a÷@>Á{?0wÄ?+Æ>‰^´? Ú?)ÿê>aê>»^Ã>ÞÕ$>T”V>Õ¾?@×C?UÉÇ?-h>Có +?ð?X»v?!Í™>ˆ@C>(Ä? ¢Œ?*Ž^>mm>] >Ãøf>²v>Ärd>i0>,Ü">›™†>ÈϬ?—þô„>ËrÊ>ÊË>µN<>Øxò>¼TÞ>àJh?3Ñ?é#>[==÷ƒ»?RÀ?g–U?/Çb>?>ç}?4‘e?%Xr?'ž¤?ã?§&?\æ?€(Æ? ļ=‚’=Í.n>3§¶?QP?)?†>ê6Ä?IK?GÆž>áˆí?*?ð\>†'f>ád??óîª?E?EçÆ?ft? Ê?oUÈ?Rf>ÿ0>#8>aŽ¤?Ý>Å)Ô>Ù·ç?+Í|?&„?&èš>Þ¯?§Þ?Ì÷>ì?e?S±œ?R{»?Rö>¹cj>§>½tB>ZÌ>p©B>ˬ¢?=·;? >r( >™R?‘ø?5Á6>ø¿¦>'(O>W‚>˜?%‹6?RæÔ>çÝÂ?ø?MÒ?3óÜ?,À?(Öd>µåÔ>‰g‰>ÙîÛ>TE¨>ÁŠÚ?Z'ø?`qø?1l*?@‹ƒ>ñòæ>Š™à>…eW>¤z>k¸n>•>*æÌ> ‹>u.?õß?US~?pˆ?9Í?1VV?'¹x>ùÑ?C’>?Ìx>9æ>š—?+ù ?(äà>†N=Ý÷>²äF>³Î¸=Á 6>Y}ì>Ž|R?Ÿþ?5!œ>Ë>³Œì>/êŽ>؈y?"‰«?>ÍÀ?~P¢?=x?»Ò?a;?^Å"?Ž?ö2? i”>"4[=ÿºŽ>ôQH?<ô>®êT>ëÇ@?2Ü>x«¾=î->ŸíÖ?,¼E?…Ç> œ¼>(\t>ãÉ?'?Fàÿ?BÝA>ÜtÃ>œ:>óÎ? +˜?.gŒ? !*?ç>’üs>YŒ¸?>?B‹k>眺>.o<>÷9Ý?!ø>»È >±?/ +?7r?,Ê*?CÌm?F)D?H?Md¾>²þi>yyÀ?"º`?P‚A?Õ=Ñ´>Àr”?;L>¾fØ>õ•>?%4Ø>÷fµ>´Òî>Ç2¬?1Œ4?:ü>øÙZ?D®?#âK??F>˜ 0>ܧÞ?1wû?Žâ>¢O6>>ª8 >À-'=Ö‘g>/GÀ>º´t?€ï?!µ6>ª;Å>qFó>r­F?D?^ù,?BN8? ×R>µdË?Rc?8Æþ>¥Lb>¯¼?Œ,>Ý•z>ÒÛ>ƒÞµ>ÞZž‰E? Uš? ’?,‚&>©þÀ>Û}µ?–Ó>ûˆK?^g ?cÂ@?Iáþ?.3D?]ø?¬€>Ù-Ö?>6ð?FUD?t‚œ>ü_>«2?¢†>¶œ>faX>.=·ª0>•>¸Þš>C4 >øìó>Æî>ø5[?!e>¤Ô=±Uu>¼0Â?/¢~?Lì?ø?VÖy?@´ž?³:?ßž>x€j>Èkä?&X>Š¶‰>çž>Üt@>¥8+? æ?£ >û”>õ;?6>·ì?:®þ?òì>Ç£Ò? +ÂZ?)þ?óž?·?(Ú>¨.ê>ùð>ЗÍ>îàà>ÐK<§Ac= °Ï>Õÿ? >î>t„h? ØÍ?&Œ>ª^>®Tl>ªTì>ØšF>³|5>ÑMõ>’•>Ñ>%I†>;Ž>»Oi>Ééf?#ÿ¯?•>²nl?B1j?Oå¬>×%V?ž?ˆ>¤»?< b?3ô?<‚Ì?a?4J×?™Ø?:¸Ú?á>Œ#Æ>oßž>üÀª>ç‚?â?gø?ÆX>¥·L?˜ü>ìô>Eàú>¥ÐQ?$ÙØ?°>ü~œ?Atf?F0A>ÊñK>ƒ«ª>Ôê)>ý†? D?6óî>Å:z>ëaÅ?9Ñ‚?RÕ®?y„?;ê¥?2DÉ?]g?P‰ð>éIN>œ‹G?á?/¾1?UÄ>œÖ|>v†>æ Ì?-î?/”ä>ØÝ}>ÿü?Kn +>°Ò? +áp?yl×?XIæ>»DÐ>×ë?QKî?4î?:Ž>äÜC>Ñj?Jxö?Gÿ~?&>Ê™Ô>Ñj·?á”?Éõ?…ø?'V€?i—:?3|À?'“ž?"#?/Y?lv>Ãz>þ0ˆ?/Ü8>å¿Ô?Â>œ•†>¶c¶?V£?kÑ”?\Áh>êG:>rÕ? ÊO?cØ/>÷Øn>’å>È$ø>ŸtL?í7>ÑIJ?î?9À>Öíh? +”J?P´ö?7¦®?à©?2±?H ¹?\â?*ª?Q²?1¹º?_à?NÌi>¦Èl=ðâÚ>S:>ý;+?k!"?b˜>0½€?~¬?<œ‡?=¦Q?@¯Ò?xã?%F—?P]þ?/„þ>ï®>ú’9>È!J? •>ÍîÂ>ß•ä>ÞÒr>°V†?U?2,>Š +6>-ÿ÷>l®&>E_ >psv>^€n? %‘? ü‰?&>ÿö¤=à†¡>ä@è>Þv¼>ý#>ܦ>þQÍ?%ú>ù,¶?ß4>äÚÆ?."{>׌@>äçp?%Ór>åN?&€ú?jå2? +X>Ú†K?_Ò?ß[? l?aZ¥?\W²?JÄH>É’Ú>Š+Z>Þyý>öHî>†Ä?<ˆ.?À>÷…ë=÷Ñ>ÿ$ ?Qâ?Ý>gðL>LQö>ÿê9>¥Q>ß(f?8Ûš?+»?_µÐ?1F(>û3ò?6Ú€>æSb?y¹?IÌ]?$(€>úÊz>PþH>`‚Ä>ãµÁ?0H?>@U>ÞÄz>H“>E(>ÏMl>¸ÓJ>þ=?&˜>ÿìA>–m–>ÃG&?ª‹?!6H>ºœ>cŽW>ïS‚?&i³>Õzï?¨/?XÄ?sXx>ùqL>Ýæ.?1Äø>õ—â?çÀ?=>l?Gsê?&&±>øç>Œ™>«–ê>÷*Z?|Ð? €+?vª?nMn?3V¤>Ö*">âTc>…#/?ê?_>•hÖ>Æ1¾?ó¥?“´>¢–>f•>©1Â>¾Ó>ÕêS>vù¤?!?j©>‘qY?6ÿ4?0—R?îä>È™f>·Á.?F[&?k&?(?.Ë>ã ô>Ð^D? Ù?òX?\Ãà?@´·?'»Â>ÍWX>ëGô>ÉW>®? +Åd>ñ>ËÃÔ>Ë©{>áxB?aò>ê÷>úZP?CL? ,;??#€?H >¤ç?,Âv?]Ù”?=öø?îx?5L‡?-ó>Ëä7?éÔ?¿`?#e6?*Õ!?·‚?GêE?Fò >öÀæ?A¸?Hj>g&>èòò>ïñÏ>Ôx>êÖ2=3v >•(>ÙxÎ?¶ ?‡p>1Ã_>Á~B?-g>ØÆå?N?/—l>Ê9,>ÏŒ(>Í{¿>F²>¾Òl>•“Ð=_®ª>~û?$–t?'Åà>²ï?\Ö?é>¥"J? ö>âî?5m¸?O™t?Â0?yL?x>¸r>Š°Þ>Ñ,?7¨,>ñ0L=ã(]>Ú¼?ù[>˜~A?3¿C?×|<‘¡Ö>1µÎ>ÜLÛ?¸‚>Z>ôZ?dâ>†Œè>o P>Ž.?9>ð]ô=V£T>µ (?Gá?HÐB>žè=Ò¨>W®9>gú(>—S>~;ø?¸m?s€»>û.>Ó.?Éì?H(ü>Ä*>„Ö¼?5ž?Yb¾?K)4?iâ>õ\?A¿À?.ø¨>€áD>÷Ùò??>>rOì>‰Ã.? Ç.?4Ö%>Qd? a?R0 +?V8þ?d9d?î×>F>‘#y>‹m]>ßÌG>·_º>¹°Ô?T¬6?ßf?ÎT?s‚>È=d?EÝP>Êù{>ýz?JÊ1?&íÖ?Qþ?LdZ>é?>‡ý?Ó?eCÚ?Fü>¤eP?V.?)nˆ>ú ‹?k¾?$ïà>Ï®A>°ÿ€?Z¿¤??ëé?õ >Ò÷>¼o>ÉAr>·Â>ö~I?ÿ>>ÛÕ?0UR?G€?!JÜ>ñ ¸>ˆ]?C>Åé3>÷¸Z>÷3è>­ÿ?2®Ú?F<æ>¶¶>ˆe*>\A£>³èu>§€À>»½ ?CEh?%/>ÝGl?J$”?Sv? 1€?5£ü?0a½>ä'Œ>X=¼ç>æ$x?OB ?^Êœ?íS>Å+–?©*?q0?6®?Q³d> ’>xL$?Æ>ø¿Û?¤’?J––>åWÈ>e¢?’?—²?*¶Ì? +"S=óô>̤²?Ôˆ?-÷>÷¬@>M™ >ëNX>áçX>œ1n>Žnå>^µÖ>i—Æ>°Á€?r>ÍÜ?\?tt>ˆßÆ?#õ'?pGb?zFŸ?Z"°?BO?Ì.?pz>ÜGn>¹>ØÒŒ>œÿæ>Š2©=~qŒ=´¹n>–h?bí?fâ>-ò¦=²?>†U >ÝXj>åû@?ß^>Øþj>~T6?" ª?G'>¨($>Ö¶>èÚ8?Q?1?d›‹?,¬Ú>À»ã?'Q&?R•Þ?^N2?2„b?"ªÔ?o ?I†ž>¯8@>8±>Ä*4>óTã>ðW?ä†>ñÖ²>Å?>y×>¸O¡?-Ý->À&$?Y??1œ(?•^>ß{Ø>æ >ÁôD>wd>œ‹à?¿A?ohD?I!Œ>ÝÝ>"â>p­¤>…Ð¥>U°Þ>¾Ã,?ž~?,|?1gD?öÊ>LÕ=ÿò>~îþ>-Y=j÷=m5ø= qÌ>ž¨÷>ïî>?&}´?QÖ? ‘">b«,>§¸V?IcØ?({¶?)Ç?9o2>®‡Á>ݹè?@Ûy>ë9¦?Û?+l>Á÷ ? ?F:@>íö>}©?Ù’?‘Ô?6‹ž?Sα>Ç*=ë–ü>‡ä%?åØ?…?& ²?;e?Cöð?p¦\?:»®>í](>ü >à•D?-‹L?†¹?:¼¦?)Ît>â|?"ÿ>ÓÅ:>Á:°>âþøT?ß>ʹ¸>ƒ´?Œ?1g ?,ýÇ?kõ·?/~>Ûª?J´à?ŠD>[Á‚>Ú?‚>«¢=·—¢=À|.?ˆÃ?qœ²?s +D?2+>‚ÙQ>ÐUk?'<>Ò­Þ>•ýµ>iÁ> G¨?ó?R6?5n¨?O¾?ÿ?>cÝe>‚òD?K>?1!?VÍz?QH>­Çò>wô­?&j4?]`?jÑ?©©>ËR?'e>Ü)Ñ>`¼¦>ÃØ>¥HT?)ò?YÈÙ?c…>?hë–?e®>ý–y?k[¨?+ÎR>уÚ>¼ Ê> Š«?'5>±§V>úÆG?8jê>z}=̲˜?¶H?aöE?d°Ý?8ÎÞ?¥>íD>ˆ\>õt?FŠÖ? Z¼>?ÄF>B\>4ñ@>Ìöi>ÁÔ™>–=Ü?ó(? îŒ? +#>³e-? ²+?Ba6?ç?$Z?9™°?½ì?!/>ËÒ>áʪ?¢ø?MðT?9êF?'¹(?miy?eßj?Æ”>®Ä‰?&žÒ>éÂ>[”?6"b>ò›>¥=?Ä×>åàL?¾ƒ?H¤??Ç>¸J(>å‚/?[$u?'ÿb?,aà?{>œÛ>óâÒ>Ý~J? +b{?\É?Ïö>˜ ~?ŸØ>¥ýù>èsY>úÁ_=ÕÞ9>äÎ>ÌÔ?¡¸?ã!>¬¨>ç N?+Óñ?h©N?*®>ªº>>v0ò>C|N>à¸?‹Î?Ãù? ¥±?)Y?GS7?'/®?­;?êT?UíÔ?gã&?z§,?G;¨?'Ɉ>Åâ©>™? A>?X¸¢?N >à¢s>–²¶?Bp¶?l,|?pµ?Qˆ?1ª²>Ü#>{éM??Ä>¬¾>Š >‚”>±.ð>êOž?N¬?Zëe?2ï±?;¿£>òŠ\>wéÅ=ýj?£Ä>í ˜=âëŠ? +ÀŸ?eÐð?*œ˜?¬h>ᶪ>¿ÙÍ?Ðä?5]?E6@>û™`?À?cŸ¸?‹y?2z­?0¿®? Ñp>ÙóI?}V?KW?z&Ž?f0!>ÕMù>:¸é>$„ã>†&ÿ?Ò¢?OTê?"b™>Øb?Nš?U¢à??C‹?k£>ùH]>ž€L?M>ÿÌÊ?"›>¾Æ>¶Â>Á9V>àÜ?v +?3QÄ>óíì?Ÿ`?qÇí>Ðë>á1ò?0†³?@7"?;ïø>Júã>Íǘ?(rH>•2Þ=í¤>È×$?2½ì>ݘ¥=´V>>$ª}>|;¬>ö>¼…‚? 5n?nCÆ?*§&>€ÒÔ?tŸ?*>îË?M]æ>äãÊ=+›ö> ³Z>SW=¿t?Ñþ?GÑ^>šóÌ<ÈsÜ>ì³Ï?!S>™,>¬‡º? ôÆ>æÞ8>*FT=«Ðp?~2?%">Ê)¬>«Ö >'ÿ>í­$>ÿÏÆ> ec>\îþ>`*n>FƒÚ>Úøj>«Á´>´^J??°>»*³?+?OÄ?<">"K?¦?f\"?XW +?HD>¤âŽ>€{.>ˆ˜7=Ó½=ëÙý>ƒû>ðs÷>‘Öv?hœ?Mœ?’?! +?.íÌ?%Ú>ƒ?@eû?RØÚ?.R?U¡?/m=øyÓ>SR]?ñl?rÚ?!r?3“n?Δ>š_®=–4?:B>þ¼>K>=Eð>e+ø>ˆ¦¯>˜¿Ž?3\?G[?P +?™‡>¦˜Z?4¿Z?7 ¸? î>™ån>Jeê?(Tò?>Gñ>ŠÆ>¾Sf>¸h=¸`>F+.>]Ù>À>4!>¬ˆz>ÀíP?…z?1¶~>à±F?_M?ñç?µŸ?)œ">«]|>p ‚>ö 8?Y×x?;o‰?,^ô?ñP>•z8>ìù>évœ>R­>¢f>k2>?ŸX?,a>Þ0‘=äØ >„O??4Ò?J=à?: 6?Fô²?Ñc?Uê?)ŒL?4p°?ƒ]=ü\Ž>“–¢??9d9?Caº?1ì?"¨>xª>ý²r?0æ8>²è?¢Î?W©£>÷g(=Áíi>Ó$¢?>0l>ÞG0=ô 0>¼à?n >Ì7o? '4?Að>±µ>¥ >þëÃ?"¶O?"¤l?.´º>¨üú>¸Æ>Ш[>$tI>Á? °7>Ø‘¼?N<>ûö ><ˆº>Wö>ºëU>ñÿæ>ÀÛç>ü±È?er?uò?1ý?<>›„? dÈ>û&e>”Xo>!‚D>Ämö?B?n*?j€¬?vö?1‘a?¿?®Î?aF>ýÎ>—ùÏ?P?8¦?dÇÎ?SÕ?Yå?PÒ¨?ÿ~>¢¥>Joy>¤e&>ð›à?H‡Ý>ø›š>ìZ?(ˆÚ>× +Š?œ>À½Ð> +¦?: >üÓô>B^> +÷ú=¡´>êc?:H^? š¬>¼<>ÔX?#Ô+>  :?\j?¨¼>#h–=®3„>ýº>|·">Ÿ¨÷>"U’=ŽÍþ? å'?}ýÊ?qŠ?\G@>ï¬>ÛÐr?Ú>EÒ˜=§äx=óÙÓ>ïñ‹>×Ýá>Ùø¶?a|?:ÿ? (V?E¬T?Cš?d?F´¤?l’>ü3«>¥Ð>Ï« ?KN?>ÅÂ>þwŽ>пÒ>w,à>ÚìÂ? z>ƒ>ðP¢? 9>š>„P¸?%®?_¾?Ec?"ï’?1=? +|F?õ=? ˜>xÕØ>oˆ>‚08?%óÁ?K ?Wp ?yd?uÖÙ?R(>Õ;T>p3·?¹?J£L>Þù“>‚¦‡>òY`>ò +>WáÛ>Wªp?¹?LÆD?6æN?HÉs>ù%^=?eð>± `>Øv>²ƒñ?B®?ò>O>Ö•?Qw?‚Ì=}\)>>”q>dÍ`>y >£ßN>÷G€?|?:œl?Þ=‰Ä.=ºÏn>¸ÿÊ?£B>–¿ê>™¼ä>¢ëm>Ö¹æ?+÷>„p=$c~=õZ>³Ç0?: ª>ö+j>qÐl>Ùé? ´ÿ?Ú@>Õýv?IŒ?,2?U¬?9b?Q‡Ú?5ç0>:›G>àa ?Sb?ts>´á˜>ß5ì>–O +¼~¬ä>½íc?Ò?üŽ>ľƒ?wþ?"`=ýz¸>“‘£>ìÆ6?¦?V2?@°?né?7 +Ô>æ&¢>®9 +>î"â?v>õÄÖ>Éî¸>Íå? ^ù?:¸S?5f¾?+7m?Ÿ…>ôVÝ?AW?4AZ>šö>í•?/×¹>ÞƒÖ>€Iä>\ `? +{S?=õŒ?ñX>°›Ð>ùNg?'œ8>ÂÜž>ô€?2>Ôf_?Ô?$ã>š]!>{ð}? 4?4h? M·?BB?@ÌÄ?]±Ï?H7Û?Ë·? ??]<?AÍÕ?LmL?&It? £¤?Hƒj?4u?U?Vê\?M±\??áš?Œ“>øìþ?Aø¦?Vá?*x>Æå?†?7–>·+Œ>9r>º£H>þ1c>™¿‚=óŒÞ>À?nÍJ^?¿%?)Õ­?rá?¬>× Ï>õ³^?Ô¶?çÚ?%¤>Îy:>È^=â>³H>¦cã?Lm?ÁÖ>¾>êQ²>%ì(>ײ?F¡ê>¥Â>2}?»–?,ÔR?'¿>º‰=¶7»?‡z?$Ì®>•Í>’çY>ï?öù>ßÜ·>É->™5»>õà>óµ)>Ö«o?œŒ? Š0?*pï?lÊ1?;¾>ä.t?1^È?2?ð·?0Ž>âÝF>Ø^?EÆ?‡Ã?^?@ m? X\>÷á…>è€&>Þ Þ>ÒÒ>Äóè>Ù n>Añ„?ýt?ó>‘Ûµ? )~?0 å>ÿ°A?uÎ?ç½?="Ì? ” >þ¥@>¦ÛŒ>á*Ž>ÇÞ>»Û«?6¶>Ð5<>Eø>¨òT?FÕv?iÁ„>ö0>L]˜>É£? ¬í?SŠ?3C>±õD>‘Wï? SÒ?P ?g0>®ö>šöl? ¹(?j>Æ:Ú>Nºj?Õð?jz´?Eü?@%?6á?'OÊ>ýûï=²}=ãÊØ=×ÙÌ>þ=D?ZX?FjT?$r?/)>?:ÍZ?Q“Ô?pe+?6˜>ØØÁ??ã?A‘é?H°]?E`È?D‹^?BZ?¶>Í[9?5V>ï"ç>†«¦>«Œ\=îáI>9æZ>·Uó?* ´?Eý>¿èð?Õ?ìl>Ä8V?"<„>ÓªZ?#Î$?BP?0?(›a>¼ =ûhø>Ù£=>ä×ó>‚‘¶>É[l>ß:ã? X¨?8Î?)Î=>£¥œ>RQ•ô>¨8>¯Ÿ?ž¦?[>Ò!±??ý¨?Ö>Â9r?ã~?³º >‚ X>͘~>†/ä?Ô¿?-Q´?3™ç?$ˆê>ïˆN>èùy>öÿ>‰'=ë¼=ƼL>µÐ?6ÓÌ?vP>¾ ¥>¦t>×5Ö>«ß¼=šm>üwØ?Vd?*“„?Rcæ>ã›6>æ½@?Rlã>øëZ>ï™B?[ü%?X"ê?\3¸?g9T?è‚>ßE>Ï6®>„<Ë?5™}?j3??“r?hÍ?$.?%´v>RÊ"=áLP>É€Æ?c?8kf?1µ˜>äb>>Ì?Ø>‡ýð>§8=¢6?ªÐ?-ìÙ>‘¶>ÆüÙ?#ž?æa?[Ð6?óÿ>Êq>áâ?#´? v”>ââö>ú-º?¡V>ç¤i>Ê:h?9)D?I^">äÓ’>2Ÿd>h§>Õt?Veb?Ex>šr2>®Üô?-¨?.—F?ïH?Ax>ü>&>Ó£ú?4?Ô?;œV?L|p>¤² >ËØ?? >Á•N>¼"?ö†?8š}?^¨?eW'?m_Z?G”??D>­ßÔ>Ï@æ?:µž?SEF?#Y>NÐ=ÓAö?fÕ?dÁ:?s(?õV?{a?aH?0*f>д’>âQ>ÑHg>¡=ðø=š²—=Äæ2>è'‚?62Ž?FŒ? Ò>*÷>˜yÒ?%Œ–?>>þb?VÄ? àÕ>¤ÃJ?a>•:²?L>ò'U>èu|?$¸*?˜?E—‰?GÞ ?GxÔ>ªò>fOt>¾t¸>ô®>™Š>°„D?[O?,#^?ào?O}0?¤ž>òr?¶?%mÔ?ÑÚ>ÖF>©F>>t¦>©<>?Öá>ì2#>ǯÌ>T«>ÐY>‚<=àÿð>ÜEM?1xb?'\>ä›>µ|è>æÕ?5?:,?–>¸ÎN>ŠMH>ñ>ž?UˆÎ?IÔe?+¯ >Ò¡[>rg>ä1^?0 >?O ä>Ò§ˆ>Î#>Ü#?*Û,>ýæ:>I |?W"?î>ŽÎª=ÑT=Ì“>°áï>Ç>¾Óâ>â2¾?:P˜>þãq7£4>³ÿh?[{œ>þj +>ãH7>þØÅ=°Íñ>?LŽ> +3ò>„–£?â>½yä>Ô¢Š?^ð)?8ƒ >^ò=¢a(>Îô?Uö +?D0=áîÝ>‚Ñ(?.:?<5>ü×>‘Á>ýþÆ>½ê>í(t?$Er>0z>$t>ºã>µÒ>è| >³fH? â>êìZ>šå?lÞ?/¥ï?”>oì>â¿@>êÕn=û|~=Q¤Ü=³ > ¢? ÉA?0ʘ?R‹g>Ö|s>-)Ý>³ef>€Àz>óK\?!°Ì>€¹¬>άj?<œ]?r¬?$P>ÅO-=|óþ>º®˜>¯—>¯fã? 9e?,Êw>ÝËN=<Ò>ž\>i¼ˆ?)yê?,>¾1t>á³ó>5¤>#}(>}¢6>¸€>L­¾>îyO?^†Q?$dœ>‹-=¶h„=Øà.>ìL$?Wš?&Ê¿>ô§æ?(4½?^ö?'ä?Z? ¢>º*ü>â·N?.õ^>¼ÎÖ>ž2?í?1? 7÷>À>Sæß>Îd©? 9©>›¹v=ˆ*=>þ´ü?¿£?¢h?…>I-ì=ú¾~=¹¶÷>V^Ö>‘„§?CÎ>×G>½¯ ?5·š?ÊÌ>ød>¦õÀ>vån?C>øÖ>Ëî–?0-g?ZÉä>÷7Œ>“®u>¢V?>ônl?s\?š=s†À>mÆ?c„?4ˆ>îÄ’>êÞ4?2uô?`vÇ?²>öŽ?BÂ"?o3>ù¦>ó">ø˜?´?N@ž?‘|=âŸYºþ¬€>ð#~?o1ø?gø?:~—?Áb>ÿC>·o?#Ó??a¡>Åy >óð>½ >Å>öšØ>õB¾??+;”?O¶^?_ªˆ?HL?2»¸??‹G?0Ql?TL˜?+–? ;ó?^ê?x§0?Z¢>Hz:>¹X–>Çç??-ZH>òü>ë–€>ý,.>üȾ?sï6?3åþ>¤Óz>8”>\úÆ?Ÿã?2Ã(?4%0?Q[ž?\i?SÉÄ>Ï~æ>±gÎ?(Ó²? \‰?0r?ZD?¹õ?7gÀ?)cw?2›œ?ÿ–?"g?ìJ>úý&>Œ†Õ>ÆÖ?RÖ¦?x 2>úœ>d!Ñ? >¬¹¸>Í×?ŸÒ>‹Èi>/O=ì;|=çk>ñ¬â?‰ >¸n>r{m>¸Ôõ?àö?^Œ?=éÃ>îj¹>Τ&?±µ?3*?>ì5?>I®>½:3>ì÷>§ÃI>º->߀??Åä?IC`?»x>ôȽ>Æÿv>¹#Ì?--?;—$?$¢?Rù?Ü>ç3$?Hr,?’t>6ã>-¶>˜,<>‘€¾>Ï…Þ? ì>òçÑ>²ÿæ>Ô¹'?%ƒ>¼‚>ÜØj>ö k?ïÊ?7&A?í“?Fáš?s@´?,À®>žl>Ïw~>¦C='I0>vü>¢-&?z>Æ`T>ño?,Eô>šâ?ã¡?I¢?Dý.?jÈ?g7/?På?)ƒž?aŠ?I£3?b&>ñ(¦?p>ãüÆ>ÀOÔ>Ã+0>ˆ»6>ø-Ó>©6.>ÂíV?$Ž³>•<þ>›oM>Úà›?xÀ?J¢Å>ÝiÀ?šÞ?gÓy?6 ã>–ô(>¼PG? „N? +n>»ä =Ç(H>WŽ>°Õì?%›|? +Bž>ZC}> c>r{6?~?‰x?b(?R›^?¦ +>º)r>Þ/Z>ÙÈ?d?:zG?4Ê>õÂ>õ«þ?B}?Q>š¤Œ?Çø?ò>€Ôœ>$:é>³)>êî>ð$?®f?)€?(¢ˆ>×ì? R?H“^>ÕÙì?™à?EãZ?Lk?8d"?´¬?¿A>¸Õˆ?!|>ôÜ>½»?‹è?ÝË>µ!Ü? ~³?A©-?yà?ã"?ü‹>íPÞ?óà>ÉV(>Çf>á/Ø?"ÇÎ>þà>³ÝÄ?.Ü>ìñ8>ŠÛ,?Â?NïÝ?6˜c>ôR>·¼”>Á0þ>¶°? Q*>¾xb>LÉ*?-¨?h?!t>†©J>a&Ê>Ý +?š??ò«>ÏNz>Âß^?&ÃÑ?$˜>ìœ?(eÖ? >×K{?2ž?'϶?fZ?ú?1F>}i˜>…¿‚?2‘? w®>Ô¬ä?CžX?@]>€n>Ñ~Ã>Ö ä>)f¬> H>sc>‚Ià?¥¿?£j>»å\>•‹>ümx?«ÏN? P?f¾e?.cÄ>³(>[èæ>‡D<>ÜXR?F.?smÎ?Ž>3Äp>‹ÊÄ?¼?@-.? +†ƒ>»²>³c>Æò¾?Õµ?PŠ ?e¬È?E&´?ùR>¾M>C›A>ø‡±?XN>à.">Ë0µ>ŒcÖ?4€¦?>p[>­ëð??qÌv?P>å—Ÿ=øW=Âs:=…`¢>ý+_?6?È>ÿ48>ÍH>gè0>¤˜>µóä? Ø&?L½†??ê!?[;Ë?w”V?KÚ!?¿l>×]%>›*Ò>Ùê(?åÎ?)ïÄ?S(?,ø>Zòj>® >/ê>ñU>·>æ2ô?Iè?ZKl?)–>óç4? +†V>Œ^> Ã ?hÕ>õÈr?Ü?Q¨*?R›J?n?›?5è?M?=æ\?ˆ>ŠZ´?œ7?I ò?4,õ?= 6>Çïè=ƒÊX>6ü÷>èšb???@>i?®†?'²¾?H"H>ñO„>‡öu>ë¢?4ˆ¹?íw>ÝÔ">{ž1=É…?ö}?¸C>M>5‡X>ntZ?ö?D)>º†›>ÛýÎ?_¸ +?s6d?s—>Œ=0?%jq>íS½? \®Ðš?)ÿ‚?4¥H?„ê?ñ?A2?/^‰>zk–>öÉ?#²à>‰ìë>øl ?+ÿo?^ƒ?”W?0Í>߇Ê> Åæ>È0?c€>–÷À>Ë×L>¯]Ã>µ›? XN?'ÄX?<Ô?¬†?;«(>áĺ?Ä*?*([>ƒ'”>é¸D?.ª¶>‹l>¶€>æ}V?‘˜>ñR¦? ¤H?1¢>ÈV„>Ì'¥>Á) ?$CØ?`¡œ?Z,œ?NOÀ?\>ã#?6ÝÜ?9Á?)*?DÌ?Wɘ?FÉ?½I>ÈS2?&~ +?'¸6?6—N>ìŒ>ßE ?AÖ?8y’?òh>ö˜#?:ˆ+?[Ýp?|†J?5¸$>¿àü?%S?xî?l‚?[$?^ÕF?3€š?Øî?2~?9Š?)z>˜âU>Û¾F?+‘Y>{©ö>¤Fä?>?´õ>Á ÷>R'ü?'K=??؈>¢Â>ñ¨D?bL{?k€ª?qø!? Ÿ¡>ó|Ä?R®(?]­>:´=ÝŠ?$Y$?cï?ƒ°?f=¯¥¨>·,>1$o>EA’>}2>Zż>¬í?YC>”ƒh>¾í»>ÒZD?¸|>ôó.>ÞÃ?Gg?S'8?âÏ=~U,>׌:?/Ñß>öQY>Z =Bò©>ŒÒ?>ç×>‰æ=Ô›K=¤-2>¬>ãê™?"7Ê?! +>*]>~,>–2Ø>üü? +»R>wuù=›O >˜YP?+Z?¨ìJ?Ðë>ã¯=P¹>泟? ØÚ? ?9L?Bê?p?@? VÌ>¶‘:?/?,4d?bPþ?Ò®>È1Ú?G‚? >ËÎö?)î??$¿n?:ˆ?`QØ?÷`>Ùö¾?T>?jÞð?*½ö?F î?úo>Î>?²W=ëZ>§;?I<8?“W>xÍ?¨µ? Êv?,Õ?#qŠ? ±´?2Ý?T$Å?Qó?3×?à!>Ýûh>椠0Ã>—T??br ?PQ?›v>ý*À?3e¢?@ ? ¯n?ÝF>|~ô>™“œ?<ÉÄ?U‰}?/ˆ§>Ì:ƒ>•PÖ>µBÈ>¦ê*?eH>¼9€>Æ¥~?G½¨?*ÂJ>Ç–ú>€å ?(¼?0€À> µV>ï}?*ã>à^]?4? +>ò}µ>Â…À>ãÒ?ã?"`r>½Ba>ÈÐ>¡F–>ë¼?;D?VQX?>ö¨??n?_=$?H†|?&X#?Z%>º¶€?/£r?W+>áØ¢>ïãÐ>*9 >TåL><Éq>ÒŒ>Ê÷8>1žD>•V´?:´?C0É? +D7>Ü,>Ñ‘l>ê.•>×2,>…?2Ú+? « >®P>Ö,>³?5Ù]?^T? 9Œ?4ŸØ?EÝ–?CKW? +.p>¦N>Õž?`qØ>í«°>~ao>—ÖU<Ù¤º<˜\[?µj?Í>s“°?x‰>ù{L>Ýv(?/hp?1›Î>òWb>(¾ö>È\ú>è˜?Ån?Z\´?$ZT>õ‡Ô>ݯ >™ö‘>•Aé>žÀT>ù9?˜ ?‰=M0Ø>"[Ö?4T?5'J?Hí#?U4Â>×"ò=ëªþ>Ý‚?&øO?3¦D?YÔJ?'O&? +•T?/Îî>õ¸Š> =# +=Ù1™>R»l>=¯>²¹¥?+¶§?)ß>Ãò‡?½ +?S\>¦ð>Â>l]Ÿ> ¸e>ÅJ¼>ÈFè>a•ý?od>îNy?§ð?!Á>¥ª?Ý”?,J¬?0!Þ?Q@î? ÷{>å‘Î>Ï„I>y)é?äm?0?$·à>§D$>ïÔ¤?/;ë?ݾ>ý¢B>ºY°=†d=Þן>º­ì?o?ös?W?RÒ$?EH>þž”>ùÍò>¨Üò>‹úâ>ÇŠ>p¶+>3à>óhõ? +„?¾¡?‰¶>½~=æÏJ>–æ>o>¾N?L<>àØn>Å ?!+?Qr?=nD?DÀB?6[>Ží>`rY>Gž>>xÊî>ôÇh?Š*>â +1?ïæ>ž«ù>Ì"?+{l>©ÓÌ>×m?,ë>UrÎ=7“>˜í?V4?)¤>ì´ß>½$í? A)>ÊÖ˜? +?1§"?QœÉ?%,F?ý?.úÂ>½yÔ> ç?Nò?Y»Ä?#>}-”>;6>óž!?mö>¼°?;YR?zŸ6?z0?©ú>Iè0>w¶µ>¤w >¿›Þ?5Á>?Oâ>¿j>¹Ü?A™!? Š½>=>¬ƒ? ŒA?5ß?!Tp?F¬?1À6>³+¥>uúò>i†F>Á*Ÿ?0¤”?0ï¨>“„é< ¨= àÄ>vðE?¤v>þŠ? L?Z̪? \h>ìYÚ?·…>·.´?A‚>ÑÒÊ=ø©>³#&?,]?Gʈ?:Å•?Y>p?X +$?ß >¸sà>/0S>x½î>œ}’?¬?6ž­?>Þ•?gÍ>§«8?,© ?+‹Z?=ö?Ÿö>¿¤?QÓ£? Ï>±Ìa>ØD€?!˨?‘O¼¨>ÒP>¿«V>” ?6È?J‚·>é‡w>™œÉ>®œ°>µ˜t?1×?"/Ã?6…?Þ†?–¶? +¾>Ä?<Ê?Ÿ?‚G>é 4? ×Ã?î>¦n¦?Ó¦?rlü>ê½þ>.’Ï>ñx?6Î>¿#Z>…Â>ŽÜº=ã;³>ùo‰?-‘ž>\‡ª>…„>òFš? ”à?$`U?¨>ζ$>½&ð? L|? Ø?e«?HVŠ>î’>‰!°=ëœ=[ȃ>3">ú­\?.î¨>Õþß=ö¶ô>Ò>º®>ê‘N?C$ +?qè?˜>ôõ”>Ï×.?Q˜ ? +·h>4˜>Ü€Þ?*‹Ì?yV¨?KGù>Ï"¾>é®>»‰Œ>0£Ý>¨cî?&‚W?.ÄK?ûŠ?Oz?¿’>ÃxR>¦Ö?>Wv@>Îv?H$?<>Õž>V9h>â¤ü?‘¥$?GZ?UYž>·Ãv>cÞ>ト>ðeÔ>o¡®=ÎÛ2>‹‘n>YW†>…4~>Ö\ >1ù¯>ÕÏ? ¾ ?dš?óÖ>gR?!¨?üB>Rx>¾9¦>W¢<©þP>Þc?sÈ?•À?ÞŒ?2ox?Î?¶z>Ò1Ü>ô¤Ò>sE|>{Gè?_`>øµL>Û + ?4Tn? Á? SB>¾»Â>ÖÖ>â1<¾ÿ">ŒØz>Ó«Ì?#¸?GÊÜ?Øv>Èé²>fà? (1>åÌÏ>Ö4?,¬>’îõ?€Ú?¼¸>ªì? ¯"?TØX?Jœ>ñDþ>Ú¦>BJé>ék?«Ì|Þ>”™Š>v§?Ã?%"m>ÄÍ8>f•O>™ËÔ>¡0¼>ÝÖ°?4Ôj>³9¿=í“>ºÊÀ?)Åá>¦pk>)ê²>¼œN>»n¤>«%¾>!J>¥¥??E1°>Ùó,>Àd#?D?b?Q a?]A'?JîD?š²>É7Æ? ŠŽ??±]>ÿìç>û?Å£?&1C?<ñ>½úŽ=+{>ýéL?" +Ò>Pƒ’=*>>£r–>¼ +>0rt>ÂÚ\>¥p`=ôüª>æÔ²>¶áÖ>‘å€?>Åb>ÛÚZ>)û²>–Ü&>¥þÆ>l«º=Œ¿k>ä€ô?Œ|?Ä?_2t? (>>˜e?›î>å¥>yË? È +?<(…?`L +?%º?'°?[]¬?]µI?K²æ?ÑE>“ÓÚ>f`q?4Ê?>“r?ASÊ?Koâ?- d?7צ?OR}?>¨.?B#/?CŽ?ËôYµ>÷Ò«>ºâã>¾Iƒ?í0>¼²€>ß_=æ¥Ê=¹}>z×ô?'R? BO>¿a?>®B?\†?1r8?<<>ÂvØ=ûi”>ÉÒ>¬ÀJ?Žp?½†>6‘¸=®¦&?Ô*?FçŽ?;¯Þ>ßÆ>à ã?4,?¿6>˜áÿ?  ?8O=‘>¸ð1?BžÎ?*1p>¢{>%)q>ñïE>ç‹x>‰¨é>ï_Ò>”ûü>Ù2>¿Ò>ç2¤>©™\>ÃÊ?0ìÎ? +ɧ>ÕÔ>÷F>Ý>|ã:?Úˆ?YÉ}?})ˆ?@ß@>üëÀ?=2ë?\M>é$>¬Þ>t">R¼h>“˜ƒ>¶a²?B ?ïk2?jÆ?``?"¢>{’ü>Kä®?0?Y<Å?Pý><Ê>o\ +?-ƒ?!r0?%¦6?N¦ð?(A?÷(>ø?!YÌ?;~?â>½ñI>½Pù?Qéú?ð·>¶>ÇúZ>ù? ÏÎ>Ëø?l?*ýÿ>Ö½Â?ŒP?90–>òÒª>óÍÀ?>åU.>ö(Ú>݈;=äÖ¤>ÊTP?Øv?-ÜA? Ñâ>ÖA4?.Ïã?Õ?.‘s?% y?£e?k ?JË?…â>³ù‘>º#x?Ÿ?`ô?<÷œ?È>–^D>ø4ó>Az>îÜ…>ñiÜ=•¬Õ>7~Š?z˜>Û.? 0??ì˜?9¡®?4IJ?& +>›©%>šæ>ôG0>ê¡x?´Â>“h“>'>°Õý>µÔ®?³p? :>˜Ls>Š¢õ?)2å?<ð>k¹f?$d:>áÞÖ=¾ýJ?ù²?0|V?r?Rÿ³?bŠ8?PæÜ?t?~.?`µ>ì&|>ëI’?òø>™íY>£1ƒ?‘ì>Ö>ÝtP?WÖ>ì32>;†¾>Ýâš>æëS>ãæß?AûŠ?MÇß?nÇ?™õ?ò>ã">nš">¯?=¾¦>ù ?ù?f¼ò?søä?l “?bB?¸>?ŒÄ?iOh?6?':>Øj +=Óªè>H|c>µ:@>»ž€>k!Ñ=×ë =L±>dnp>á8ž>µÚj>4óZ>ƒ¦>ÇSÌ?=5æ?_Pl?DŸ4?»x>ÂÇÊ>Àül>ÆÏk? !?Hü?OÈv>îg>Žè?Ë=>Òî@=¬é–>VÜ>©\>?ä¤?:ïÃ>Œ >ý¦K>þÃÂ>.×>À0:>­Ú>¯d?ÜÛ>¿Ž(=œ}ì>îò?cøð?l$? ‹\>Í’=œô??Så?<žˆ>俪?o²?<>ž?7>ø?(°„?8Ìc? +¸¾>²`{>)y'>ðÙô?Ðb>­Ô§?=ú?®°> Y? >"?lYó?9ý¢?35Â?3¦>ív¾>ãjW?F.­?®>où1?2¿?+ ?øB=¦=z>Ê2>àS>?È?á?Y¥d? +Ø? åÝ?WiC?UŒ?$Fª? R?ëx?lÈî?m€?]1ö>ù1? ‹ ? ^>­?¹(>ÀäÄ>÷Öò?qeA?qr?g ?5{ì>Éêð>U6=OÆ‚>ƒÒÈ? 9Œ>¡Uú>·†±?5‚?-QF? ¯•>äVv?5ý6?‹ú>¼yz?wî? ²•>ˆ(?`‚? “ò>Í*{?J @? Z[?‹š?u°§?8Y=?#Gl?8 å>­Hè>k[ê?=*Ý?5þò>º¹ >þŠ>ù—ý¦F>‰px>¶Ì?..>? µE>óûî??Næ?ª¬?É’>³„>¸jÄ>°Æ¾>6à?Óv?O{n?8ãê?=ÎR??ƒy?,+Æ?`Æ?$¿>Õ²´>ÜØ>çš>Wæº>l½À>ÚŒ:?2>‘¬>úü?:¾À?…­>”E•>¹Â>-¦ò>)3Ò>éE?ÛÙ>¥">ü1y?,oW>óBÔ>áV>¦¥>8 Ä=hP3>¡­b>äèˆ>cÎÔ>í˜>ßò->‰60?X†>àÊ? Ѿ?m?_ÿ=RÌB=™›>Éï">Þ%Ò> ®>q¡?ª?RÜh?_ï>#¨V>¥»b>â*p>Ù]L?*Œ¿?Hª—?ý5?:M¶?Ö>Áµ:?ÊR>ècÔ>É[˜?#<>ÿúÚ>ÌÒv>Í;>¤î >£°.>(á3>h°j?!€?\Ý”?[ùÐ?E +n?*R|?DÀö>ýÄ“=×6˜>˜ò¸>Û¦>¾SÒ>¾—>[Y?7 ?9Ä>å +Í?»n?!•?1=û?nŽ?'ëê>·±ƒ>OŸ?.³·?€nÌ?v¨?6¯P?<ê†?IãÚ?,n?µ«?$‡>?6 ª?5Ž~>ˆÛ:Õ=°>Y>”ÉR>â +?C©R?7Ò•>Öív>¶w>@;¶? h?Q-â?6r#?A¢&?kq"? æ->øö? ¢? h>øNŒ>Þ80>ÜÅý=xÆ[>ã’>ž!?ÉØ>òÊy>Ó¡F?2Êf?n4”?X´¸? øN=Èìà>ç‰6?'6F?'p6??"ïÀ?t ø?94>Õ1Æ>–Î>Jîò>®¤:?JS@?LÑó>Þ’²?‡ï?(,¶>•Ší>Æ–?¢>ßÁ>°c’?¸^?õ¦?`Ä>阢?l6>þ'ª>vH?pá?FSä>ªA¶>àšb?47,?õ?I×?Mg?*z?0›?U>®?Çu?B…‚?löX? K¸=þ½T>„·>½â>y‘¯?²³>ù‡c>¡*Ž>…=Á>DcF>Òc?"BN?çB>ÎQº?0’Ù?#½¢>ãÄ?'Õ&?¨¤>µêÂ=û”™>Un”>¿Èø?/ƒ¦?$h?%&l?[€ð?‚Ö>¤}2>s¿ü>YU*??QÂ?/è!>ý-Y?á¿?QEV>é“>¡òH>¿ó’? F–?Aò?4Õ”?²J>á†Ø|@>?V€>榘>¡t=įS?û?u”"?8ö¸>ƒ?V>ùÉa?Áé>”`>“V>;o +>%ëˆ>ŒJn>ÄV^> Ÿ>GC`>„?ü>£ú>­'|?Ô’?" + +?L?GýÐ?¢ñ? +µ¥>ýÁÒ>?e}>Eh?p¼?½ ?C¯h?&€J?7R>ø%`>‹>¡N1>dz…>“MN>üßÊ?ïZ?èq>Ñu‚?#ÕÞ?5JÐ? +7|?9÷f?1$Ö>‡¾>Âm +?8§Œ>ÆÉf=›ÎÍ>ây?0Ó¢?.'°?U"C? à ?´?;}>Éó!?$7N>ú5>¿¼x>À.>ëjþ?(±3>+§>Þ&>Ö”¶>¦|>èã?®>ö(?žÎ>Àöþ>=€ä>§‡>øYµ?#Uî>¹ÄF>Ág_>çÄ>±åb>÷òþ?¾æ?&d>ôE?4Ô?EU(>¿òâ>ø<ˆ?^5°?Oæ>×ξ?ªÎ?b1ƒ?g;T?»—? ¯’?B)é?:Î>Ô—ö>Ô+c>þDm?1 a>ÁËç>ünÚ?8Š˜>ôoÀ>ç$f?GzÑ?0ƒ>>âšV?/•¨?L7û>ïÙŠ>Jv>…(x>ßH?×ò?Aœ?/Y?0à?º¯>¸u¥>ä â>ï>+">üƒf>öjö>öŽ›?>Ñ?]†#?_Ö]>ß(ã>£|4>Ïd‰>^0à?"?eä^>àP>Ûè? #G>¾|?è>È“e>X¬>çË?È6?*Ið>¦LÚ=mK=†ÊÝ>€C?š?CÔ®?¿q?Ô?\5ü?kMØ>ê”ä>Œlÿ>é¼?™2?:,?\Ib?$. >ý'ò?Cºš?`}¢?"™p>¡Ò¤?R?Pkü?{T>¤Ïý?$c?(J>hº>îæX?¥4>yt&=J>>ÓhÓ?:3Š?ã8>óÜ?,.T?+ç\?AÒÔ?n? %?-&¾?,h?+Áú>±}¬>–^^>õÔ>—9«=ñ +>¯ih>è-3>Ô6D?„Ü?/ïc>î +¬>±ü>¨pÀ>øŠ?d@?t2Ê?.ÝB>^iF>¸ä?I>g•‘>p–+?)-‚>íÉ®? iV?Y8>ò…ý>T3Þ=’ב>Çñj>ñç±>ºd>£8V? ìü>ûõ«>J3>Ƨ>X|D>¸¤?K]?¢b>i¬=ÎuT>lâ?³?6†²? HY?OÏ +?tu?\q¨?$è>ßpR>€âÕ>Un>_ö>¾sM>u£%<dŽ>«Qþ?‹&>øà?*ƒè?\f©?@áÄ>¡nB=I¿>l0?x·>ûwN?+?%I"?Ú6>¯ëL>ã)…?CýÌ?êä?6ò?Yö>_]—>Ù>ˆ6y>GpÄ?(=ê?S`\?))#?78?Fd†?*óÊ?õª>£F>‘?1g¼?Lë?È8?·?8<–>ƒ8>ùŒ?87@? Ý”?e(?õ>扡?5VØ?A X?¹Ø>R=Ê>âïê>ÂyA>³{|?K•Œ? jl>cú>î>ðB©?¯`>`ªë>Å“t>~>, >s³q>Ê ÿ?@‚>ûR›>“Å>ã¿?S*Þ?Z"Ô? À>qk^=˜H<ÖÒ=æ4>!ß0>Ê~Í>§õÞ>Ø™j?:4€?DIÖ?iiû?0½?¦Ì??_"? Uò>r¡ >#Þ#>ôšç ?&ÙZ>ýí*>%p?®§?(dx?,ù’?.T=¯£°=‰äÁ=ÛäØ>ĉ?w?%Q?3TÆ?FÕJ>ËæH>éÊŽ?&ûf?<»â?Ž?ï6?2ž’>‘'z>üÉ‹?&{ý?”g??ƒl?.Öæ? ç|?:"?>ÀŒ?©Ž>¦a>=­?îh?ðÉ>ÿ™ >ã}(>FÝç?‘?Ô?.ú?&½ž?Dü^?>cÚ>€)o<éâ>ªÓ?!ô? 8p?G#?Fne?3±6?7uÇ?,æx>½_ >£¡ô>Aý’>Z¤Ù?é?:8? *ƒ>“š>Ä9º>€öŸ>äQ÷?µŒ?(•4?”>³à>¦N&?oþ>õ6>ÆyÕ>ÃØ>Sªh>©2>B¿¶>ÔqÈ?Úb? Cï?#h>ùÞ>ºüö>ã=ž?Ð,?PŽ>†d>fÅx>á`“?8ë +>èñ>nC°>Y +ý=ø#H>}6æ?|ú?ºI>úD.>ë—š>ß>¸ª<>È>º"?5­A?`‚#?fù??HZ> +8¼=Þ=©]Ö>´uj>ŠšG>S]?ŽŽ>á­ >w:=P* >êp?s¦ ?:Ý2?h? Ã(>ªËi>2_>÷¯?/¤C?:?/õ¬?&Z”>g >’‰â>íl>æëZ>æÍŽ>wÊV>„XW>>9º=$P=?ó?Uá|?NÀ(?é£>¡®>>«Y.>Ša?˜? Í*=ÂwÞ>ÈQê?çþ>F›>·ä?1üî? è>ÇÕ–>{ È>Ðnˆ? ç >Î|•>òÎ[?Uñ‚?kíZ?ŽÓ=µì,»ˆ’à>’Vc?/ï>°µÐ>“[™>þ8 +?Cã¼?V>qv>Ì×>âþN>Ø:¦?Óe>Ô?6f +?7¼œ?f>ƒ@? a®?hx†?wk ?l?"#F>õ†?NH?MÕ°?ÿ‚ª=”O>’Hˆ>Á\?Ù›?E„ˆ?R¥>²Ø¾>bš>Ú ?Cu?ú>­ãJ>¢ºr?N>ú8F>¤->Ílv>Îç,>ó>,x>†À?$ï +?=>2S0>Kç¨> ²>×ðâ?F×v>Éåš>Ô ?F]>Ìý$=æ +=ô‹b>³Œ>øC +>õ2«>ÜOÓ>¹—>äÈx>‹º2=¡2>š>>ûp?`Í-?½h>k‡?’?B'»?x>§ n>ý>¶JÞ>ŽI;?->’5‚>¬×C>¾äP=Æh`?Êv?|-? ©>§8]?<?!„à>ÑgÆ>†8?S?Z0>Cs€>¹hT? ª>ÛôÜ?‚?æÑ>óé*?PWø>ýõ[>'¹ã>öÖ>Å‚R=Í Æ>j)b>ÎÒ¬>’ãZ>„D>”îï>·Ò?)³1?-!,>ïB?7Œõ?pà"?vD‘?H®>±Ö<><@Ù>dʽ?¼?l´Î?†>ðc4>÷I^>r’²>¾Úƒ??S3?qøâ?RD? %>ëI,?u>ø" >°Ê>†åL>ñè? Š®?&Ó’? ž@>½­>øô?*“>·®Z?Aþ?C²F>’Ok>ÕÏ6?T—*?÷?(/"?>HÄ>ÁªZ>Þ3>›Z=÷.Æ>æi1?è>·ò$>`•ð>¢ô"?Fª +?2;Ì?ÿf>ÌòÀ>©7Ã?6àA>öƉ?B?.iK?3òþ?] È?A.¢?/Þl?9ˆL?P$*?*š–?6á?@ƒò>¤¢Z>¬Ý?‡>÷l?‹>ú~È?bð>ù È?¼t>ó7ü=€HI>¯RQ>Æp*>Á V?0­?7á +?$—?>*ž?\'ä?ªr?,p?!>ü8> Ç@>‹éÆ?ç*?T>ï‘b>ÓÇå>û>á¢>­wU>”>À,?Aê?0óž>—M>Ú °?0ÂÜ?E¶x?"_Ì?¶¨?OÔV?-š?6n?™«?/Äl>Sè=×=>~-í?'3Ð?Gpl?PP?Í>=!æ>Aû0>4K‚>•œ? 0U?º?(Ø¢?`Øp?UþÒ>ü$>8ü>I[(>ò³^?UÂê?&€?-hŽ?”˜? Ÿ¨>ê{d>F >Û¿F?2îØ?‹x? :,? ôÊ>ÛÝ>Ðoz>öâ>œhò>>}>ñæ’?q ? ¸?üD?q­J?Kò>Û=&>—ãÏ>E?l?< ?RV?e^u?+^þ>aS >Kö7? ±?Mr? ¤X?,ùÄ? +à¶>§ñT>øˆ?Òf?ÙN?+áè? $_?+ÁÕ?*öô>¼¨]>Ö°U?Amô?WÉ°>Æd¼ªNÜ>è6p?0‚´?+£™?U1†?]¹B?d'â?P»?Zv¡?YÌ‚?Ã? KÌ>Û n>Á›{?>Û…ó1?—¤??#> ïý»u"H>ËÃ?>Œ>v&O>F™X?"T?<¨(>ùj?Iá?\å’?!Uh>Kq >Í]M?^z‘?fð?_? œ,?>˺?!ŒÊ>È…À>­Ã¿>é&?…†?“Q>«%Ð?#sP?cï0?Plð>»f!>ñ2h?R‡â?AãÒ>²öó>ðµ?xwÌ? 2 ? • ?/K\>sJ>@B>ßO?O·®?zÒ?8œ +>Êà²?þ¥>íõ >šíX>ôå…?)iH?)`ž>”>’aÊ?N¾Â>ü}’>]ÃÌ>bÖZ>L©.>¤à>Ï#>ßr@>Êà¾>Ð š?@¤Î?I>é"ƒ> +£>Ëwž?Ü >w{<>{ªq>ÐjZ?¹(?¸>’b=àõH>xVà>ùö>Öö>ØÕ¨>P ¼>*ü‡>Õ? +ù"?X†p?K2ê>áø}>meË?Va?²“>Œð>%¶>Éå–?!:?u>ôÐh?'­9?S¸¤?Tƒá?1P>sÀ>HÃD>í"(>»?ÞŽ? +O>.«²>båè>hš>»‘Þ?:¯Ì?mÝá?%ØÀ>Ò.?å?'5ñ?3 +P?Ël>€Ä‰?rÏ>÷9œ¼¹´>a6:>ô¬T>§’>§,J>ß¹D>~@Z>Ö'„?1‰Àé¤<ïû>Ÿ>²h <õ „>:¿ð>œkõ?‚?U÷Ô?!ÃÆ>§™ +=É+V>Ãð +? +Î>Ná¦>ò÷æ?nì0?J‰‚>–¬~>!¨> Î¢>ÿè€?CZH>䲓>õÈŽ?%î¨>E²=>@m7>spq>“ü>µâV>í(î?8Ô?/.?øÔ>Âþ6>‘Âë?Q?K°>º^X>ÛÌ¢>Ðwv=Ÿ’G=çÿª=’Ù«>h¾?+ÅY?B?¯Ê?-ÜÓ?-€’?&z?ª`>èId=ÎJ/?P>ܤÔ>E:>©m”>› ^?sj?@ID>™¦ª<®fí>+ÌF>”Q ?øø?=B>ö§®>/ôñ>¦WÞ??§ü?¦h>NŒ,>³ 0>ð§?B°?{K6?\ò†?9•s>­z>ËD?T›?)Ý?[®>ç}=ó‹Ù=…p?— ?qY£?[gS>ñq>>6 À>rÈÈ> @ª>ö$?«|>­2^? Žh>©EÍ>KWÜ>r#6>ˆÛ?I?TË ?Hµ>Ê™>ÀU>Ê#>¾–>ª}~?"î”?7 +×?US>Ž¶l? ”Î?"ÓT>ŠÃ> +Û?-‚?K(>Ç~>Ó_â>‡¼|>“/==ãö>ùr2?'Ò>§ñ^? ‚?P#°>±ã»=æ€>“‹?6®? ×)>ù‹÷?[J?°À>Ãôs>ƒg>”6?3âà?G ¹>ø>{•7?ŠW?>ëî>Í o>Ë’:?A©€?tìÝ?>§Ô? èó?E;?oš?AF?5c6?5 x? +2Ö>ßÓÈ? +¢þ?b=?[*0?QŠù?sè>"²v>Èpÿ´>аØ>r{»>ãŒ?#Œ?4÷×>äDÊ>Â…ó>¯÷‚=­È‹>Ëþ?æ?´f?*W>ó–³>Ä'r>cø¨>عä?æ>¼m‹?¢ >”’2>|42?+±–?mIì?">ŸÛN?ú?j?’C>Ån >Ÿ·õ>Ø3>Ú—¼?À}?–´?áL? #¼>ö4X? +÷?>…N|>¡n>u“y>°Œ0>•Ã©>Ý‚?Dý<>ÝH|> ò>ñã´>×dJ>El?¡>ק}>ú Ÿ?Zöÿ>â-Ø>D^î>"ŠÞ>ë*S?\|à?t‰0?ÓÚ?Ì–?;’>š(¹>T>6b:>Þ•[?>£î?Q‰ð>üÓ¶>ó«"?<{2>Ìü>¯ž|>c‰z>ü î?<—>ÉdÞ>ä4?9ã«?P+f>åÙJ>zÉe>j6>¡ÊŽ?4°>ë$?eh?næ¾?=>ŒˆH>÷ÿf>Ãæñ>õͪ?.hü?Ìš?[s?0ˆ>ÓR>è7ª?rN?3y(>Íw?? +³?F·t?!e?Pz?!;Z>E´Ÿ>¸žß?H"ø?™)=Žbª>Ë(Î?, ã?P¤?…¾?cÿÌ?—>¯Üí?:`>Í'Ô>s–Ê=Š»>µCâ?”]>ÎqF?aü>Üž7;M˜>¤8ý>æ¶>µg>÷ªÜ?#õ·? á`?3‡¸>ýbà>Æ?ˆ?&,É?E¶>ß?">’ªí??·?, ³>Sk+>|ý´>’òk>Ýî™?ZR?kéf?F‹?\(,?&3Â>ïÄ›?’ð?Û±?®@?5qË? +¶ç>Ú§2?(ƒR>ý9î>®A>¬ÇL>±:ž?¬˜?ýø>µè?6”?+à>òp?AöÚ?\Å'?_àš?X<|?Eº?H0ö?%Š?Ø?'¸ª>Üx?>?B"´?'ÆH>ÂŽ•?"Q¼?* Æ>‰L?¶±?C÷>©˜=%Yø>Œkû?Ÿ?;„>­¡>ÁcX>»*“? +ÿ?6ÂS?.d?hXD?B®H?î²>ªAˆ>‰ó#?Bk?(æ„> ô=ÇÉü?æx?bwö?Tðf?5­>3íe>ƒs›?×e?7– >ã®Ò?¤B?#pb?3 É?#x>Õ^?ÒÕ?̦?9@B>ß½?€0?4Ýâ? ÄB>„ç³=R)û? 2È?Rá¦>ÑNÊ>|,œ>|$ >Mí©>ãèÚ?3ü?8~Ü?|>ÛÑô?8~N?Wý?8næ>ò <>ÚÙÒ? 0?cÖ?X2>²ñü>Îÿé?c1 ?4®>Œ•>>÷ð¼?UfÂ?ekÅ?>Ë>×W?p´?@0V?­Ô>¤Íh>ƒï—>iM†=ÏØ>"©>U >ë¤H?>Œ>´Tö?x>?ÿ`>šoð??Jr>ˤ8> C´>  >sV>€Úò?Aˆ? c®>îŠW>ï—>î¾…?O +F?d«l?\¡?-¯>»~(>@‚V>³˜H>üÓ®>ãÒà>ñ`ì?3ÓÖ?~¦?€ô?¢?kâ?V¶Y?wñ?JÝì>éýœ>qâ>D>Ýh?J*?[Ð>³šj>¡»2>Ì›X?+äì?p?ó2?tª²?Gó>æ$Ê>ç”t?EÓÚ?T†?<³>ÜÂ[?â?Cð^>Ô$>ŸSh? {|>ý£â>YÐÄ? ú”?Íò>õŽ?éØ?"Yì?™>xÊÀ>ß1?#‚?@0f?iå´>ßþ(=s i>þG.?j4?QíÚ?62È?]xœ?¾Ð=áÔE=x ?>MÈ?£F?r·¼>÷~C>8fó? Þ5?}?æd?nœ.>ÖÇB>9X©?Æ?K®òò>šé1=J¦ä>è ý?u ?BV¶>ãÂŒ?*Èü?=˹>ûJ>ãmí>q¿ =æ>3Т>ôY?E~ö?m $>Ý¢»>°F¡>åQ¤>øœÍ?Kx@>ð~F>Ö;?4R>σ:?÷†?j >Æ+Ò?>“1>hÀÔ>­Sf>ë?©Ô?6-#?¸Î?¢>á7,?íX?zøÿ?wÌ>Ê­»?LZî>ðA>vZÞ?*¢l?8ż? Œ?LŒ×>ø‘X=ØÑg?bž?y0?<â?Cv?Ѧ>6M>eJ=î7">vÆ?&®?[¯>·«û>ã´?<®F?n8^?"×>‰Ë»>ˆMù>:ƒëuId>ó\©>ðˆž>ña!?/(é>þk&=}ìÔ>ÛÜ2?`l?°ú?"¥>Ê 8?/óæ?:ƒ8>öC”>q:>ÁÂc>äò<>Ômb?(tJ?RDÉ?õZ>²ÖX>€ªÂ=ýäR=úlM>°„`>ëpÐ>öÔæ>âR‹>Q[i>}¶ ?2ît?!±>]¹ü? £?[¯/?P>ä“Ê>퀚?3 ù?Å6?@ v?jn>ç±G=÷ÚÆ?”æ?) í> 24>!b(? q°?P^>Oêx>{€ª>¶ÔR>é[ >ï{è?Ÿ˜?.ª°>í…>‹…?5¨ +?NxÆ?` >í¾³>“ô> >ÿ z?F•è?8à®?P—’?=W’?2>ÂÄö?" –?D?fº?büV?.•~?ÿ?6ò?ÍP>Ї? œ”?WKŽ>ÀŸT?H3?Äœ>ŸQ|?æ¸>¢Ð$=K€ˆ?øJ?¸?%|?g¹®?¤ô=Óv#>r¤a>¼u¤>¡ðð>$h>ºg,?ˆ +>&íˆ=çK•>ÿÅä?+Úð>®Ô ?÷æ?i˜ ?Çü>Àê?(·:?Ú¾?4óþ>Á ¸>õø>ý)¾>“M?)ßz>ãx@>kC>㥪?±L>[0y?S?†ü?"Ãè?ÁD=¹†ì=†-=Ä5>Áz=Èrû>Gʼ>²sº>ÅH±?&Oî?'lç?? +¶?pJ±?+nð>Î<>èÒ?dÃ>?UAë?$TP>° =ÏFÂ=é÷>&)÷>Ó„Ž?B-N>ÚU >™ëU>Ñ…? N?@P†>ŽQ\>rÔ?ËÂ>ÿJ?X?Gê³?7PO?EÔ?AFT?Xê>Äà˜?íz>ü\?;¸?f >Ú³=•X«>ïÂ?J‹>Ö{è> +¥ >óD? –n>ó >Ö©T?Z-?b\>ôáx?Æ2?N‘“?$ï´?­Ô?*¨T>úÊ—=ã–\>=F¤>Ö¡}>‚ŠI>ö ”?I¥ü?4¶è?MÍ@?L:Ú?Ø?Ïô?j|{?SÕ?Œ>ÚÉr>é2«?Ñ°>÷æŸ>˜Gº?Ý(?"¢&>{‰<>°“Ò?ÿ:>ùN>zÚ>Þ‚º?)q>”ˆ(>¨ë²?ˆ?Ú?5ö¸?5f>þÿ>å>º^b>m0â> rà>uF9>¯R&>½²„>øÄ&?Y\>Üœh=³t²>ÀìY>Ý:>~bG>öË^>Øc²>?°>ÌCê>MÀ>kJ—>iïÆ=¡p;>Ê&>ŸùE>ÑÞ ? kT>¦.Š>Âø÷?[>Êî@? ?=Íl?u¹8?{uH?ôx? 9f?Š">€ÌÖ>\?? r^>·ó>¬¡=è—,>þïÃ?Xë¨?5~?`>¿Å >ò~Q?µE>2(g>˜PF>Ÿ‰È>æc>´Û=OQ«>ò_O?\šÜ?«­>`h0>Ï.j?gnö?``? +­?dlÞ?vÊ?œ>ÐÎô?@‹{?Å"=èèî=øl?¸Õ?2Z>¿£*>`>¹ÎÀ?-B°>é>‚eÐ?!ã–? +^>Ô„Ä?ÌK?„e>ç–¡>¯°?/ê?‡Ž>Þ¢|>ÙµŠ>Ìá•>Ä ‚>š8ñ>$X_=¥,­>Ë÷ö>¥à>ã•&?@B~?4 ?çþ>ï‹¿>ͧh?ìŒ?k“Þ?6þ>ö©Á?<˜t?*Gª>¸5>ͯÄ>Ë:>ÒIŽ?A??w¹?÷>ÛÆú=Ng;>sR?6aá?t{A? D>#j >¢ÞŽ?$€?P|?_Ô¢?/ò>]ç¯?Sý? æ=>ŸëH>Úì? ÂØ?]Æ? ¨æ>Žoy>œäî??Rh ?nCŠ?Xl?8º>™ì&? pÆ?!Ä >ÍÍ–?%YŒ?VÏ?]>ïöT>²6?Gt[?T•õ?”j? 3ˆ>º[|=øØ$>´4þ>ÝS<>Bth>W<”>hÁÀ>=2>ßÄÌ?&.C?L81>óÙ€?)G?>ÔÜ?>Uz„>ªG7?Mbz?MÐ>¢÷L=ûð\>‹)8?š?m`"?9¶f? nò>Í”²>¹z"?…¦>ðf?#Rö>ûn»>ˆÿ\?-àö?Ž =² o> Š”?>‰É?)‚œ?% Ä>óžn>i§ì>Tå’>á +Ã?@.>Uܱ>™Š ?73?™†?Cw >éoý>òq¨?-†?äN? <ì>ÕíÒ?1Öî?>Yv?(ÝJ>ú¹œ>Ì@’?3|?Hå4>ùÛ>g\2>‰qß? U!?jéV?ÒL>ÚX}>Ú >3N>aT¨>éùæ>¢R)>Ñ@Ì? >Q_¤>óæÌ?@&Œ>³ +¼=Ãœ0>ðÃ|?SSn?N?h>ÝaÑ> !a>µ->CxV>ñ>Û Ã>©ý>Ú\n?$ÊÎ?)&Ô?Tð>¿2ó>ê87?CÆH?50¤? l> à>òïŒ>íK>0Y>³Ü©>ž¿?Aµ^Â?`?Tƒ—>Âá@>0ïd>ÍѺ?'Ih>þwN?’? .ü?#Áæ>ú´>̉à?’'>¡K?œ? +9'>öUB?"Û¸>ã¦ä?0?gW(?\{n? \¥>²ìò?gÕ>úiØ>ø\ ?!ùÆ?9‡6?]>Ê&>ë6=ò‚j=µ„@=ðß>â®?D·ä>Ä{î>->4œ>›J?/äl>é¢=÷4ú? >çéR>éJQ?F; >öV¶>kË4>Áç2>êM0>¥ð.?Ÿ?MD?/ðz?€;0?~»K>öRP>Wþž?âä?˜Ï>‰D[>â}*>ñ]>f%ì>©Óž> ›É?"e?9Åt? Po>™è*>ëH?x0:?6þ>ðnÃ>Çœ”>þ`1>ÉË7>—]Â?Ì>?%¢>¡Þn>×?0Ì>§Á¥>ˆbÕ?â@?¼»>Kæ}? |R?×W? ¾ß?(‡Ò?ØI?Û‘>ßÂ>Ý>ž@=¤I>¹À?#æz?\¥%?UJØ?æê>¡QÖ>’kP?8O ?tæ§?8¾´>‚1½>úÞ¸?h–S?Xëº?YÊ?Ž,>Âç>?ö >°^I>ÄX>x{§>ò¤ë?4¨b>·xö>ð³4?DÝ·?¼R>—9a>Ma§=À¸Â>ƒÌ°?8h¸?ÄI=ò…«>Ý—Þ?kß²?!=>™óz>,¢ƒ>©õ]? Š?ÐX>Áþî><©$?, Š? ˜>é»z>ðXŽ> A|>˜k{=@à>T—²>ø­i>¨pÂ>ýY0>üä>ÍÞ¢>ÎÇ^>ù5¾?±>u>XC>žpŸ>¦Çà?¸ß>¸iÔ>ÖFP?8ר>Àÿ3>‹T¢>òÍÊ>œâ¦=àu,>öø>ðàì?àå>=Ó`>Ø>­|>JŠ>õà\?V؆>«mt>ƒµ¬>°×¸>Ö•?'š*?KQš>òþð>Œã¾>0ã?>÷¸^? «=›5=œ—>Ô§•>Ëîo=˜ý¼>=´ú>Ö­6>¯“Š>„_ +>VF?¦?fÍ?-Ér>Äq–? þ?ª>¥.>¡ 0?êª?ä=É8¶>õ{N?8Ì.?8?†à>j·$>–ou>Ë~h>l“ü?üP?A`V>ˆÃ{>õèH>ô]¢>¹0e?0V¼>›[T>|²¬?/‡f>×ÏÊ>zÞÒ>»#T>Mn=|çQ>Øx›?i"–?*’b>Ä2€>–¹ä?4H?b_U?nW¤?®>¦DN>Ö€º>ñ$Œ>ý'>ñ–H>ºýÚ?Cj?p ®? ó<>ÿ>¨?C8>ÝÛò?­.>¸¿>‚=>žþÚ?ñ~?xlu?~^>–\->¥Lx?‹?>ñòæ>Í?Yû?›>Ÿæ~>”YT?$Ú˜>ïâ>ÇØ?4T>ÜG=>TÜ>˜õu>ÕÏî>V =>Š)£?Ö{>Öôb>À!>äf„?3VZ?+Ï>½ô¸? +?Buð>íy"?#_•?M#?ž>‚À=²s€>®‰þ?ª¼>ÉÁ> §= ±1>Îá?±Ö?DV¾?i0?6–?¸?$>È>¸ùt>+!«= †[? $?KÄÉ>›a9>ãrú?óG?³q?>ï…ÞÄ>xz>ή‚>©Â¬?<²?7•4?£ë>§›,>a>lht?} ?%6ø>F>Š¿D??|?X>_˜Z>Ñ·°?xö>ôû>_{ê>ÚÁ²>Þ¬´>´hÏ?5çL>þ‡¼>+Ö®?&=?=Çœ?ý¿(?<Àk>öp$>4º·>(ó?`?²z?8€ ?¶ð?/ë‹>¢‘5>è‚"?$Ã?U¤>ôoü=Ù¨T>•ö?*Ä\?k??¸?/(>U5r>Ñ{Z?\¿\?ž|=é[¬>•@c?Ü?NµT?Iø¤>û ~?©z?;óâ¶>âÈ>ó'°>ë¦S>­Åº?zñ?Jfò?0Û?M†½?]>6­•=GãW=”„Ý>üzž?muà?fÊ?H>¨y>üH8>¬ÔP>{-Ÿ?0$ü?3B>§)œ>ÊOj>ð#>ítš>ü©Ô>($>¡Ž >Î7¥>’²>µÄ,>=çz?[f?Í$>?,È>ùà>äd?+ct>ö2>·>ˆòJ>æø¤>úø?$¾@?Z~Z>ÿ¡=©°L>¤)2>ù¥O>¾ÕG?¥µ?FHÌ?BºÈ?e>À/6?s-?C–?#‹¶? J?Lv>?>b˜?&Ùª?$éR?Ê÷?o?-¸>%¥>œüÒ>¹˜¸>Š±6>nGØ>CñË?²? +’V>É;?¼–>úä>qã?P‚?,4d>¦(>O§?ž|?\r?ïå>F +ü>ø>ˆµ >¯•¯>Ͷ>>®ÔH=›«>CÎL>Î5L>¯˜–>بX>¿t>;r?©?9×>§nœ>‡ñ,>Ë!?(`Ñ>ôǤ>þÄ?:->¿$¶>Ïê?(ª¦?-¯V>±¾ >‰=9>²¤Ð?0?i|€?gnl?HéÙ>З>ûx!?xÐ>Ö‡4?Kç? <>’>íû>ôÿ|>˜v?n^?)•Â>ŠÑ >ë7Ü?;®^=ÇÔ>®'ì>Ó&>âŠ?NZ>?I6>·ü >KSÄ?%ÄÊ?/îY?5¨Ê?c±¨?[_z>ｘ¼xѨ>‰$>ûzŽ?'‰­?6jR?>d?B©.?'Üö?Úa>ƒb®>º¶ú?ír?…>ù®”>‘·×>Õù>—î>ó«Ð?Ç>•ŽÎ>ˆe‹?p>ãG˜?ç?M´? Ö>°Mí>KXh=·‚E>l¤@>Ì7„?œi?C€>ÑlŒ>BêŽ? Ÿ¹?Z&š?1+>¶‚Ð>æ?P?O?<À?]þ¡? Ìš?j3?W:>©¬>®;à>À!>«Æ>ÕÒÆ>ž;Ž? A?<³„>߀r>ÿÒÿ?:‚8?,?!ê‘>¹œX?áX?He>ïñp?¦6?IßÚ?Äy>¸~>žŒ(>¼Ó¢?©>ß•à=ëûÝ>Ö)Ä>¥4Í>‘w>`uˆ>¦›®>WK“>Œæä?M ?$šv>¨×A>ûÌÖ?Fhf?4V:?"Õè>g˜*>bo»?)-=?Ed>ÔPh>]Ÿ>¼Ñx>¤VZ?ú¯?UÖV?/·ô%º?úæ? Òv?1#b?>èû?1Öˆ>Âöæ?a&? +}¸>¥Z?"ç?B>±¤ä>€}X>º©>ë],>.¾¶?ÄX?D¸ò?@D3?×Ä>Ùã?!í2>Òš? +ÐF?.Œ?"|?‚)Õ?Òì>Òzè?=®?#˜è>–¶ > j(>î¡Ä?-TØ?E ?-Ô?<ƒ>@jx>^qR?«>?Q;±?'‰ +>z?“=à¾?Õ¤?q™Z>ï9ð>žEh?>Ó³? €?$—?ñØ>ÎqE>›˜þ?71¤?R¤Î>ò—6>Åû,?Nf4?tûœ?3 ˜>Óy>¿ó¦?´‚?%l?.?Ov?9ð?N-»?;éÞ>Ám"? +*†>ë¬>Œ‘>¡‰…? ˜?=Þx? +!>/.?Ɔ>ú@¾>B>î?Ò?O3’?*… ? ¿?>[0? Sß>hì>œ,>î´`>¤ +>Ór¶>ÛâÊ=ú£S?S?|Dú?Þˆ>Óƒv>ÙÍÖ>–C?(E8?D{?U]•?Z5°? À?/Á°??‡t?BXÒ?lv¼ScD>ûçÝ?.J>»›*>Ëä´=ˆ_&>2:Ë? u^?J( ?)>é2v?0Ϭ?'nV>°¥2>¯=?6ÁB>ïg?9Ö?7«ô>ÕsÅ>ðä>úÌ>>L’>×Í>õVä=q|>MB6>¹_è?-ú?sÆÐ?CÐä?EÏ\?@Æ>¾$¶?@Žn?&2>ç?:e>¨1œ?)E?=x?Ýv>Çš?&“«?ã=ù¨$?Òs?PŒ?Kº? ¿›>sS>žü >|¹>æ^÷?n?ëó?6è}>¿XÞ?».?'¸?‹ø?V“ø?hvº?1Þ>NVr>RÌ ?Ž?'½Œ>ÿOº>‹¶H?9?Lp>Ú?c*L?6-ø>Ú©>Ò 0>¦å?ÙR? >å +.>°üÒ>Ñ‹É?/ W?Z)z?IF>ÃVv=Ú²Ý?OÊ?A?$ëœ>î¥?w?+¼>u”Ã>½ >¼‡‰>î¿x?Ú6?µ¿?5ÚÐ?$§?H'6?|hÉ?!p>É}Â?3j?FP?M¢>ª»d>n«J>å >ã#²?3¼>ëÌB>“6?\—?Ä]>Á®‘>Þ]>Òv˜?!C±?%²Ð>²©U>M ^>ÌÓ°?U<? ‘q?s4?H *>↤>–`,>·b\>gä"=qõ>µÓ?%ƒí>Ñ°q>›+,?Ñ·?[z2?C„ê>¬v„>Üå >ââ*>†º×?Š¤?±Ü>P8*>q°®>ª•×>¥¹>öQt?!ܨ?±a?Ï>Ƨ??-?Y5Ô?5b>ï†>ú@À$? +ó–?gØ?ê€?°h>1xS>¸‘§>è,Õ? @Ö?ARd?ÓR?Û?=™?BÕ"?ö,>‹BR>'˜?ˆ +?¸e>âU?cµ‚?ZÞ:?Œ>œBL>“ +º>¤j>ÀRþ>Êé}>’Â<>òÚ>Óë?Δ?€Â>æ_ê>ð÷P?8ô6?!›R>ü&ñ>ÿu>ˆ ˜>QÝÜ>½Ž˜>©Öâ>Ýã? •Œ?G™æ?¡Ë? Òß>ø©?÷¦?2†–>ȲR?? Ç$>VÏÇ>«ìÊ?AÆ?Wó×?Ïz>ÛÞ?þ ?8O>?Ð? §ð>‡]Š>9]>?D>ó°>°¼¬>Á¾š>˲? + ?*ä?Vج?,éŒ>¤·6>> d?x$?[Ñ\?)×>éN\>¿ªD>}°”>‡–²?‡e?&Ñœ?Í>Øÿ>Ô´P>Œ<>Ǿ”>ßÝû>à:l>±m>íà¤?_Zæ?ZÅ?.’„?ø?;®?\ +Œ?!›¼>ï0>:È><2¸?Ö?;h >Úi>HQ>ì?¢?Yô=øsò>ßc€>æOÀ>V<Ü?C°?k¿õ?!‘">x-¼>TFl?z2?È>Qž\>þ,?VåŒ?l=êO >)™>¥­>äÆ|?ð?4ÞÆ?SgY?LÎ>ìŠ?*v?b(Ø?>Ÿg6?!˜?.n? ²?&ÏY>~Ç>öLÅ?]É2?}@?"z¶?3Îf>†W=U½>FfÇ>µ*Æ>áŽ>Šõx>Â0t?_®? >Íwê>Œ-Ú>Á¬´>àƒp?5ùŽ? ì>bwØ>¡­>Ï?1Í?3Â>FÎ>>2ýY?d)?pK€>î²´? ê¼?XÛÈ?:¬’?Cº§?Hú?DG?ô>Òm~>ßõJ? f?]ý>^==«9;>™}S?"ñ‡? _? ¸?j$Ü>úbÞ>ÄXÀ?\ˆ„?ê¨>¸ºv>ë>åf¨?#`?`ß¹?dÈ‚>ïâð?›?LtH?P@²?,>>­8>¦.Ô>´?l?#y*?2~Ò>¼­¾? +<ã>Ô +>6’?;?52>÷7Ç>£²>²·\>ò¬Z?Q›>‹&>`K,?9ì?@8?&G?#ù>µ½>$%Ã>Ø·4?:t»?f¤>…öp>ºÒ…?")?!€g?+Úƒ?M@?X ?^æ?;%^>Ç*?‡?=8??9è?$G"? JÛ>²žÑ>÷¨>ÍÒ?S.?SÒz>³È >˜&è>ÿYà?¬W>ûY>‰C­>{ï9>ð§¸?l®>£æq>¥ñy>è¬?28?‡°>8¹>$pt> 0=- >?L? ]d?Az?S î?[}©?`Æó? JÒ>7©Ì=ƽ>TÐ>è°†>A?%x?1™Æ>½[(>Ë=M>Š>@>ÆgÎ>² ø? +k?9g?Œ²>øIn>¨Œ˜?,ß>?%„=ÒzÆ>®Ç>¾}=¤Æ^>¤ßö>±Y> W^>ô-Î>é;?ig?C&æ?Ê(?€©?@¾>ŠÆ>M6l>fÛŽ>¼Äù?9%ª?¹¯>†Y>ªE?*X>¾f>,‰6? ÒC?.>È`^>Ë>>êÃI>ÑáÈ?†»?mñò?&>Öâ >ç–>¶Êƒ>ãÖ¨>Þ·~?4?îÄ>ø1~?P?Ot¦?L×>þi?@%Ó? c1?ÛF? Ç\>­~2>m÷¤>†>{JN?3g†?zØ‚?Ài>.^{>]Wˆ>%—r>5˜1>» ù>ÌÐ*>2 f>þn“? :º>Án? Hd?ø>ïŒ>O‚ +>¡„?L3Þ?N]Õ?b>ã•?Ù´?*½6?þƒ>¥uŒ>1Ê>šÞÜ>'?$>þŸr>ÎKÈ?=Ã|>ÈÈ9>»e®?ìŒ?Be"?2/ô>ÓzÄ?(ü¯?*wà>ßê?¶Ò?2Zô?IGO>üäè=ä h>s‘??‚>ˆ+Ú>ÕFò>”Êÿ?Ž?°>d>Hœ? óŽ?^S˜? ž=>±bÃ?À®?) ã>¢…‡>ë*º>ì,G>o{j>ñUj?,—>ÁQª>l[ù>î²ö>§@Ñ=º³ö>åF?Q?Ýœ?'ãË?!A?0 ­?B´>áQÚ>gä¡?Ó?a .>ÓÿÎ>Øž?0?0>?IM>†åû?"/–>øðµ=Ùó>õâ? ~>Í)¹?ò>—]z>âØe>Ö¡r>¦>—ÎQ=š^–=ùè =¯§.? Ô?%ž>§Rç?1:?[µÚ?QL"?+Î>ðLP>’Ix>ñèB2>óK?· ?™È?F&Ä>Ï]ù>³ÔÌ>˜û[?×?u>?ê%?_ÆŒ?[:? >xo›>˜.>¡5>ÉS¼>í» ?R`?GŸØ>°Y>¯c >ÌL=Ì«?Oå?=><'ž>ÈñO>¾Ú>¢–û?Bô?LG? b>ÚÕÎ?5¤>é>ÇûL?”,>ï¢Ü?×\?³·>xè£=Ž¥õ?H¾? wÀ>à,}?0¿Ž>ðØ?!V?1º8?AƒB?èN>ëk>’]}>ZŽ?W‰?@|ª?G«j??‘‚> ¥>vÈ>&>†Ó¹>õ¤(>̃?….?ú?óV?TÈ>)î§>¦‹?±Ê?*®F?L&Ð?]Œ?‚þ?7Û3>ªüÜ>ñàî?Bw@?B ?:ÔQ>Ù]t>>fÚ>‚=½{Ö>¡ÆC?Oeè?N§»?S¦Ó?1÷Š>Xä>¹¥p?Sxè?TÎá?9,? ‡P?{É>ž”>>gÙ>Ó48?; ô?&^>°žÎ>™ßÉ>øµü?;ÌHX>tt>ãî>´¤’>¤›4>:˜Ä>Ô ß?P+t?é–>sŽ>F]Œ>ÿyü>Ãæ>>†º[?í³>ü>˜?G;?9ņ?iH?.oø?D^k?+¦ý>ŸÊ–>HzR? 9ê>ý±y>$·ï>¿¢ ?(¾”>ó{/>ñ¼_??¢œ>è >v7k>aË=¥Íô>ö2¸?:£Ð>}ƒ!>š¡è>ߪ™? á»?9`7?n¾?â›? —è?2'?*UL?«b?%¦B>¡o|>ò³§?@üä>³bŒ>›™>ÏT´>¯CÎ>—¶>Ý×T?\Ç?H>âSë?7„.>þ¾¸>ªv?# +?'”Â?Klø?•¸?Ë ? êÎ>H…? ß">Úáõ> m +>¬Æ?î’>ó=>䌓>Ó’,>Jh@?5-ø?@×ä?(¥p?Y]?¯Ü>çF«?2Š?4iV?ŒÀ>ˆÁ?¤Š>éµ=bd?>P¨Ã?2½Œ?]ï†?á?-û`>ï?¸ž?s•? +0Š>¥OO>ˆóF?Ì?5{>•³(>ô?WÁ?%Ä>ä¨?1ù†?TŽ?FòD?3‘²?M ?Næø?_H?¢š>å{ü>t =þý>­ûe0={vÉ>ýYÀ>ýy°>e²>»>ñ?/ª>†NS>A´Y=û«>ü??t?!Ql?dÛ?CÞŽ>½k>U^*?eF>èöh>£E>§P>GB>Aš?(=²?y`°?Ð>òf4?;¸ò>ÛÄ`>侞?C³? :”>±…¸>’þÞ>gl˜?8 +?8¼T?¾Å?›?·|?$¯±? 'œ?$U;>ãèÅ>%ìJ>VcP>÷ ?@'?^/»?JFâ>¹d">‹•6>r¶±=et©? +ö„>þ`.>j§>ÛÆ¿>ãM ?T\>‡:˜>Øx?6Kÿ? ¯?¼?!]}?:…È>ßÛ +>×ýÄ?]@>‡Ó}>JF>¼ß>”© ?©¾?&V?++?‘?u>Ö*N>U,„?eÛ?5zô?Ÿü>˜Òy>JY>>} s>Ñ„>†`ó? ?A5J?.>Ø;?Mª? É?%æß>Àr€>Á1?X7q?@G?–p?,*B?Th,?h_œ>û‰=ê· >Éçd?>ÌB?Æ;>ÿt.?¥ +>­ÿã>ð¦5?-êä>ž7¶>Kß?Cq?Ò¬>ñ.r>ÕTõ>Ÿ2>žâ?Ò?AÝ"?w0?2…?Dø)?7G!?J!T?F`Í>¸eê=Ê_b?ëÅ?P¶j?#à0?7 +‡?Ì"?õá?Í©>×¹Œ>Õ]Ð>¦,Ž?*0Ð?gÌ~?Q,ì?[¦Š?W¥¨?Åš>É’=÷æû>ê· ?| ,>ýcÊ>y¹Ú?jM?P?Ð?¶<>:mb?"?Â!>"œ)?"Ó?z»ì?+T>™Ë­>óû?ƒÔ>Ñë¤>ûýt>‘+Ä=âÆd>½Á˜? + ?8 Ò?E@?VNÄ?kÞ?TŽ?1Šr?+¬Â?ñ4?=H–>¤¦? g@?&]«>–>¦é>ä/?<Ô?b\Ò>ñhB>U<Š?×?B?Ð?:h??7Ž¹?H·ô>¬i6>·\y>ËçJ?aq?õò?"ß>éL'>Ã_H>äc·>ëç?.5ˆ?G¦Æ?8.É?&_r?8…D>ð"'=Åy¢>þê?2+¬?&l>üx¨><8?#[?bî¡?`»i?M¸>Ïü>Ô;>´øñ?M ½?u8Ü?ek4?el¾?\p–?ów>Ù>óö›?¶l>÷p>û ? vº>·¤‡>µDÚ>êoY?Zˆ?fp?"­ê?n>Ï­0>Šžw>Ș ?-?`ä,?eðŽ>ác%<4&>Æ©Ú?Z~ ?^èŽ?1»Œ?>µT>ê£Ä>à 6>䥞>ã,ƒ?Ó8>î„T?"„?Då +?"d(>} L=öc¹>55„>çøb?Z,>ƒ(ü>à|b?–Æ>sÄ>Ã%‚>ß«´>F>œÐ?t>>ý@u>‘6b>¸~>–¯²>Ç,>À:Æ?"7@?2=¡?!¿??Aª?r?´?)#-?6ñî?< ]>±Àß>ŠWâ?(‚?¡âN?Ã?)Ò=µÝB>5 G?‚;? +·è>1TÕ>É'¸>´ÙÀ>š´h>ë×=>IÄï>*û>ýŒš?JØ?4B>ú7>»Š?WDö?%¥Ê>Þ?Cµ“>öÌ–>‘ ?!E?+9)>ýe`> >ÀÔ„?Còh?/Þd?¼?&…">¶¹jÛ>F2? e~>ÒX¤>º?*Tr>¹%¢? 6)?ñ>¥ ã?Kœ?$ ‚>–Yˆ? g)?H+?96>ýr?r¶? àÃ?,¶?_p?/ >×BR>Çvü?B>ôW&?'´è? t>„ß¡?$t£?8*=Øý>´ý¶>ÿj%?Tþ?/->ˆ¯¢>©Ýž?SÇ?;ºø>©Ð>ÏR¸>¢->)0Ý>¯µ¾?X±?8ã)>Ïš¸>ëz>ܱ¼?.Zi>ì¿è?š€?LX®?¤ø?%¾?Ý0>sé.>N3Ó>®³">º¬A? ôÎ?»‚>—?î>²ZZ?Ò¬?R:v>¿„Ê>°ª(?PÐ? k>%Ì®>ƒ>ÅVR?ùÎ?8¦?8Sä>ËÞÈ>ŽU÷?/œ?ALd>¯Æ>‰ç&>iõ€>ÛØ>ä˜B>´,?h`>uØä>ßs|>øŸz>ƒò-?!cø?lSt?'›?(‚Ó?]VÁ?fz?§º?ñÐ?Ìh?(2o?Ë8:2->'ëÔ>ôÜî?Þ?=í\?ï'>ZÜÐ>y2á?æò?µ’?çÜ?ðÍ>ï¤:>шF=®pC>XÖ>® ^?ÎH?uî?MñØ?¦>¤S9>¹Û(>Ù¤>ÛÍ”? Î>Í®Ê>‹hr>×\n>Å”>¶äþ?Kä«?9R? +#P?àŒ?€V?T±?1Q?+Æ? +$>ç ì?OØ?,Ln?'‡¦?¿ø?"6?"ø>›Æ”>W &>åû6?$µa?úà>²Ø@>»Yð?CÈ´?MœF>Å[ =’€>ôÎã?-næ?<å4>ù‡;>ŠåØ>ü£{?(8N?å>òšÆ?ñP?4:á?/ÚW?,s”?[b>˜å6>*l>®i? +{T>‚`j>š8>—6=õnÖ>úÙ™?5pr>ßÜö?QË?Žp=Ø'>ø±5?Í? ç?n +s?këþ?"à>V¿$>bÜ‹?uÌ>ßÕÄ>¹ÍL>ÀÈú>*4Ü>Ž„>¥Ã…?+þr? ?Ã? -ó?^"?œö>É«¬?O¶2? ®=áʘ?`+?yQ?MÏ.?—¡?0¸Í?z(>^½ò?(?Ö>>|n°?"®¨?Ö­>*è#>ÍÈ>Õòþ>‡>A(¾?lm?L>÷|?>ìŸ{>áYœ>à„>Ç8>>a? Ag? +Z?4È>ö°Œ>’“;>‰ÆM€Ù>Áv¥=þ0’>ÅZî?`<\?sé?I¡(?xÆ?->¨¤*=»¸f>æJ¸?B­>Ñ–Ê>öÊ„?Y”’?6!t?/ƒÊ?6™%>Ñwþ>…MZ>ø@>ñ? dI>àK>æ>íÑ^?1ýW>ãH@<¢^=ÖU‘>ÛbX?ZL?Æ +>ì×Ò>¹?)§N>¼Ð>;ð>9tø? +œ>ð7>Ù˜æ>õ{L>&|s>'‡u>•@ê?¡U>ïý«>Âßü>ÂÐ>ø >–Â3>ÂÆò>ØÞ>r»N>´g°?&Ô?<›>?w¢?6'ß>ëL>ñé¾>ÝÀ>:‚‹à>p%A>rŒÌ?8ª?/Ià>ô >¶>›m‘>‰Ô:>¬á“>Ä‘w> +u=ú&>˜É¥>²÷v>Á{?‡@? 5_?G À>ôº>»#Ü?E©:>à¢Ú=½‹\=zˆl>æ¹Î?^Ë:>ÙœT>Mþ¢>ˆ$Û>z>¬ ¼>D(ð>Pqn?3ˆ?B>weV?pÙ?pé?.åô>‘¦Ì>Ñòg>ÐA?€?%†A?R?5§q>Ï`5>üÒt?‡~>f1Æ>‰½Z>ІÆ>DI<Œ2æ? )Í?$j>¹>¬u¬>³±F>‰9Ü>Vb>¨Þê?!åà?y}?­Ê>fX?™€?:eˆ?š>‚ ->PŽ÷>¼yœ>²—>ô> >’T;<²9d>êÄn?XTé?bŠ?B‚Æ>ü5?»î>Ùôz=ì2Ò>œv\?ÿ¦?žþ?[ +? ˆ> Ü›>Ä{º? í?2H?Â>ÿó(>³ij>žd˜> Q>ÜÎY??>ãZú>Í)ÚîÄ>eØ¢?ô?mÁ\?<ã\>Êè‚? úk? +Ðð? »?UŠü?]?š?¤>ÐS>ª¬@=NóT>âd?;‚L? îK?.5>Ý·˜<¬$ë>U`>ž+Ç?& ?#ˆ>ˆKb>Š +ª>“Ì‘>¿NÄ?!qÆ?B»H?õš?f9>úë®>ر†?id? ø2? €2?h×@?<É-?G â?Ò>ÈßF?$ ?€?EjU?-p4? –?23?Lë*?Hõœ?E¡>?(rc>…¶?iB?wÓš?¿-»³@¢lA"ƒfA†A 'Añ:A ìA Añ8A &šAˆ}A"r¤@¦þé>˜u²?/-æ?fÇ?JPê?8Æ“>þžn>èd>ðç?Dl?ƒÔ>‚£d?þ?%Š?*ƒ×?P>Ó?kä¤?Z)l?W_6?Ha?,±ì?ûp>`{°>´è>›…ü>ô:h?LNt?L¸*?f¯ ?&Â>Ñx˜>Ô†ü>áUŠ?@»ò?4˜§>Ñ>Â>¿€ ?ëd?xö?PõÑ?’>ß¼L>â2&>*ø>ØÉ0?@’?-îY>·uÀ<<¯>–c€>äª?)”?G,>ÀÙ >^bØ>Èýô>•m¸=®@>Ý'Þ>ý º>ðkl>¦ö>¬ÝÜ>Ævœ>ª¡?+°—?Jf>çë¶?%‘¢?Lß? ««>¹^>Óš>rÉ€>Ò!\?5ì–>ø˜º>äM&?1èÓ>­ò =åÙp> x >†š>úÔ@?!·t>üÖ >‹´„?”?&è>æi¦>Ï=Â>AlH>žH>|Lx?G3?QŠ¥?\ãö?9‚>Ô.>»g?ãÖ>Ÿ¿>`À¸?t¶?Á5>Gò\>ƒ@>í„@?!>¢œÆ>| (?k¢? ú? ?\'?‚º;õ)>ñç ?>æ +?5l™?,.ª>ʸ|>ý#Ä>ðBl?"Ð?-¿È>žG>iQ=Ó)>wÍ>  è?7˜?&×ô>“t>>”Àd?B"?O|A?_ +ê?QS +?‡=>œa4?^L? d#>Ú„>ì4`?³š?žæ>Ø@î>×ïP?(My?!”?  ?žL?ã>?kx>´\Ô?(g?†ü=½¨€>Ö/(>êÒ0>ñ>Y‘à>—Š?M=?j2Ú?äÒ>à“Ž>Ë3Ð?ó°?W–,>ã]b> €X>b¤L?(½d?O´.>ØX?´Ü?¾œ>Ku >û€?P ¼?pƒŠ>ýÞ2>àN?Xàõ?K—¥?gŠî>ö^p>= +p>¹œâ>ÿÒ?!’ì?F/o?1O(>î&?/n†?5ö>D¼ ?àÄ>áBÞ>T>Ø?G>Ò ä>ÿ¹¸>÷|h>)O ?±'? +uä>Š2€?“d?o?6ƒ6?¨j=¦À>ãà”>éîT=¸áÀ=’ =çJà>Gmˆ?Lþ?7C¸?Ò¯>ónÆ>¸­?U?S-ö?WÍh?Gºé?:Æ>ܽ>æó€?ëÙ?J£á>ûU = Î >%Ôè?Cb? +T?åŠ?á×? ò>?â”>êx?1Žt?2Lj?hÁþ?-ƒ>ðG?Ìé?:h€? zö>µûŠ>”Él>†Ÿ?-Î>«2†>_°|?±?VI?_Á?/é>ôÀ>Ï­~?î2?ÍÌ? +>>¡ >í|€?¶º?kî?bô?4Ü?M(>! È>®ï„? +M>¿¨? }B?J€*?Tª>’{Â>ž”?fx>ÚÆð>ý,?Evº?#~?Gšõ>ï·\=æ¹Ð? *?Dñï?@°ˆ?-T>Á¹p?¨œ>øwx?ª÷?%¬>a›|>Æ0?#ÿß?!º:>¼P>»vX>Ê~´=!€? +]?UÙª?1ƒi?}w> Yü>ÚŒÄ?Tgj?_Ob? Âh>2 +°>‚0Ø>ý$>Í<ø>T>òh>½ô\>  (?D¸ò? –<>=Ê\>—*?""F?C6m?.n•?RÓ?%{ò>øÏÜ>à˜f?Ê?PÒ?.Á?Qåœ?B4=’^P> ç„=ëÝ`=‘ >1ô>=š=Ø@>wkl>Â,l?€?wØå?í">äe|?8«>¿Ûˆ>Ôî>ýã˜>†sZ>˜ü?3Ù?® >ïkü?^ˆ>»Ü>Iû¨=ÿ3ˆ>’¬ò?ùÐ?Ò7>äY?“ò>ä`@>©ã`?®?q¸>î¡>ÿ?”>ä>–Ê>ofè>ÄRH? š?<ž?€I?J"?·á>ù >ؼ>u¬è>êìÜ>Ž Ä? u?tÐÎ?IÕõ?$º,?Z/˜>ü‚<>ãÛž?.ãŠ>JH>L>½RN>á:0>Š¸ >6x>¶:>— +>ßk¨?,¯I?¼(?"ûÓ?HHT>àÄ>Öóô?'ù>˜;f> L>Щ"?™L?;Yj?P>¼>¼Â>ë%8>é†>ž2ø?E­¬?pà>¦~?1 »? +8?ª²?óŒ?r?¾¥?cD?TçØ>æY~>Ößì>„ø(>õJº? +*>ÄaŒ?Av‘?’z>À>Ù—?)3)?%Sv>»§À>‚2L>‘1n?%Q¨?'¾ò?i|?iaÃ?©9?;"?|”p?`¼?A¦œ>þ.T>‘cl?ÑŠ?T?fç4?céê?HÐ|>üÏ*>ÅGp?8Ô†?têO?²?ÜÐuþ>‡fx?º?1Z`?'@b?¨k?:ߺ?/ >mOt>3òä>˜3R?2H>Þ¹`?*9Ã?Bë?˜æ?û>Û.†>䊤>V{l=´}=ú>xO\>=š¼>áP¸>Ýš>ö>ä}Ú?"aû?s£à>úu<>Êõ,?*ó£n>X¯„>*H>×%€?1—€? ì&>ÒÞè?ñ’?áõ>¶Ä?/s[>¯\ö>Ùœ>°äà>·%H?4P¸?-Ç?*?p?\aâ?Vnî? Ã>Ñ´r?.¸Ï?Y‚>áš>¸)æ>ü›@>Ù>$Ð>Èâž?Íb?ð ?D|Ú?Sæ?T¤|?!Ì‹?.†?^[}?…‘>$4=ƒÈ =ýf8>«Œ?+,?0G>‰à?|h>édÔ=˜V0?^²?@>->²|>N Ð>£Æ>ëÄ>»/ >b¨?ã?3f>•d=æÎÐ>,¼? Éê>÷ÔÂ>݆R>ì#z>*~ô>ƒux>§÷t>·%J?ÏN?:F ?-«?%Ê’>ÞÄÔ>—ê?'´?0â+?íÏ?Eþd? üí>h±ð>íK”?+©?±D?Qu0?h)?šÐ>Á§†?-T?5Ær>´7Ì>q~>”¯p? +"x?b>Ž6@>Éçx?2\Ä?YW°>Çξ>F>úÚ?¼ ?0•d?u}&? t? ž?ƒ>Uˆ?ÔÎ>ë +¾=µÓÐ=§¾@?‹?i\!? ²?[•?ñ>ä´?ð?àˆ>÷ÔÎ= Fð>ˆPÒ?- ?¯Â>”¡¾>Î>õÂL>MQ„>B™Ü?!è>Ä8?pæ?7G\?¹ ?m?dÐD?/l¬? 'T>p>ø(>?:Ýð?"Ö??,·g>B=¾]`> >«âÌ>ûeT?5.²?"¼&>›7´>xè>Äf<>¹Áì>ã>˜$>nÀ?¿3?i´?8-Õ>­é?ðÏ>ÝÆR>\jd?¼L>ÝQ>=º >Çû8>ç{\>é~?#?¤v?;ûª?´F>ÊlV?{?'€œ?1? °>Ú˜>/ ? rD?L•8>öY$?ï´?#×Ø?!ÀÐ?Jú>ÙL‚>¯ >Ò‹@?\×s?k±J?€H?Ù>Š¿æ>5ãè>“°2?B“|?`ö¾?`¾¦?|>1°?º>?Nà¦?/>Ž^*=“ð>õ8²?Bv¼?Lã?EÆ>¯ >Ûg>¤]ˆ>N=IÌà>Ýì>>ä)l>æF$>ÑU†>Æ£?Èá>³w¨>Eð€>\¸>ð +>é.>Vi?)ÓÌ?Š.>ÂÒ2>ü7à>s©Ø?~Ë?xhº?÷C? ¦‘?÷±?Ú®? —€>^‡°? +Žà?Š.?¨ì?s?c +w?ðÒ>v=ˆ>†’Ô?$BÖ?}i?G¾?ͯ>O¨p>)9Ä>c˜?]Ú?+@P??x?Œ“>v©8?7Œ?9ÿa?+ä>È’T?ÜË?7%Ä?ž?/˜j?Kãt?,Já>=©”>Žvž?Pà?˶>š—d=SH =[å€>ƒ.˜>ÿñô?ƒ>ï ?K?CÚ¦>¢Âp?–N?q 6?@ˆ>>ÁK >ëq>Ñùv>¦>©½.>#Âø>ùîÚ>±1P>Æ¡$?>ß>Ãú>p> F>´­Ï>èˆ,>òæ²=ó½€>Êö¼?CRU?h ˆ>õ$l?ÀT?h¡©>æ9:>ˆT>ùÎ? Š±?,´?5—†?;E°>Éw¸>é#p?ûn>¢œ>«z>»Ît>‚êè?ùÚ?}Ô>ØñN?Ò/?7Û?"oK?,û]?9aÐ>·&T? X¸?²L>¹y`>f à>¤8>ó(\>öØP>…n@>õí”?(‹O?C”V?eŠÍ?“Z>=¨l>HûÈ=íßà=¢©>Ü>,5È>“`:?Ç>ùôÊ>>Âh>üph?Å#=§> >6ÂH>_»>Z!$?¿???!(?B£>«¨:?=(Ú?•é>¬>ä¬\>©ª>Ñ<\?8õý?C¢Æ?TÕà?8{>X™h>µYÜ? 8 >ÏÛŒ>Ÿ]$?1}Ê?$ìé>FH>Æ­P?\o®?`‘.?@à;>ÒÁ:=ñç@>öb?)Kx?!žÜ>ßúˆ?OO?W^å>º­F>N(?3~?•(>+Ï@?ß>?7Ⱦ?'ýl>ù°>Óß|>«îf>®~D?›E? $~>`È>bKX>­oª>oå? +Sí?nÙ?IþH>ðg?%ê²?YžŒ?Fz>›IP>-cÔ>÷™?dä'?DZ?-aÀ>Í„>3Ñè>#0t>™5¶?Ü/>óØ? +ÖÎ>ŸÎ>œÏ*?1‚>ÄÛ¶>Ý„Ø?ã>S@d>i?J.?›?;› >ÿ?‹Ä>÷u>¡Ìˆ>Ά=€¹`>W¨¤?2Ѭ?y»¾?@ ï>É{>ÌðX?ò?‘w>·´^>áýÌ?{¾>xÒð>ÈÓ|>ùú?ò?¾o?3e–?$»Ó>hT€>,i =ö >м>ÿX?Aº¯? È? +oŠ>ÎÞD?[ù?*#Ð?­´? +:X>Á¢º>Ÿ”? w?C>Ûÿ¨>.´È>Ææø>ï>ÀeÊ>Uµ>‡h>ß¾?Nu‹?0§‡?û­?X|?c]!>æ…@>Öp>ïŽ=ãk>É¥À?E*?BÛ†? ë ? )?ö0P>ëoŒ>‚S<>¡®\?Ckù?×q>«øj>Ìž >ãø?#’?rRq?$´<ÿ9€>ø>±[n>„s>P,?§Á>Ä&¼>¼±ê?ÌÆ>ш8=±î°;BÊ>ljH>ù»L>ƒT?˜?Ø? —?tÎÂ?Ck? +&·? ™>>‹Å|>²<ä>ÙÓš?7¡ö?] 7?lŸ²?a™?;¼‚>ı? Ó®?%Ä>'1°=™Ÿ@>Ä? +£*?bÞì?qgã?‡>¨]`?þ>ÿß$>›†Ä>ãœL>ÝÄ=ßg>À>러>´Î¸>Ƈ@?8}ò?Pœ?$?(êN?):_? Â>®šÆ>¦Ñ >ÏÆ? ¿J?QËÅ?KŶ?wA£?7¾—>¾òT>{ >— +Z?%?QX…?*:>Å÷d>Š¶ª>ÇNÔ?:Ìn>ýÌ=Wð >Ø*?\ûV?‚)>(? +…ì>ùWh>· Z?.1>è)Î>×RØ?4NG>‎=‘…ð>å]˜?/­n? $?$7ª?”á>ó˜ä?&G”?j `>Û´>ÙÃÈ?¹Þ>×kn?>€A?"<Ü>÷~j?5“>ð +>¢uª?(â?4'é?k)"?ZÝo?Dž~?)¾?8ÑÍ?í0>²ê„Ò>âTà?T?[ -?P>î`?$ºî?/Ķ? .>o…8?$ZÀ?)à{?.ü?m%>áH? I?iñÍ?/]d>ÆV`>}%ˆ>¬>„J¤>…yp>ÎœH?J¢.?2?z«?D€?*à >¸ü?¤»?¹_>ð@¡²?º??JÓ?JŸŽ?D ß?³>˜“ˆ>,üÐ= >¢ß¤ð®>äF?&?g]?š4>{Ò˜?â? è?)q÷?D– ?GEA?uHx?>D?Ýd?¯1>¸ÇÈ?we?8&Ì?@L?T>B?%Xü>wá°?äý?G¡e?6Ó¶?$°x?%Aë?D¢æ>¤ÇÊ>ÚÈ?J÷¨?‚Z?F? ˜?8¨?] ? +ñ@??ÿÚ>ö6t>울>|CÔ>é ?ÌÔ>ä‚? K¦>qrÜ>=øH>裸>4>‹1Þ?¬‡?9Éö?a&Ç?mAÈ?l׬? +o€>Õ$?&TÚ>í¹>½1ê>¬Æl=ð¯=ž¯`>–yà>û\^>ÊÎä?'†?6íF?4™ù?Ñ:?ü>ðÞh?Þò>ÙØv>Àø?”%>‡r>Dœ >/d>gÍ>ïø?GÎ>â°(?(,º?]º(?[ Û?u­b?:Cð?;*R?[¿Ä?X|?`‚9>ê`?„¨}´?*“?rT>úP>7‚“>Š½>î‹p?`¤>—»Ø?·Ç?ì‚>‚t>ú3Z>ø5è?43Š?4ãP?¯v>wø>y@>¸Qø> ü>@P?X?1…ž>•nð>•mª>Ú °>¥(?/š ?…T>í«Ú?PÆŒ?`"p?[Ò??™?§'?g¾?jV©?:°Ó?4Ì>ÁÀ>®‘Ê?F÷¸?G=k„à>Ÿ¾(?`¶>£ed>»X?ñ?_üô?T½o?<^Á?µc>ß„4?@ +?VǾ?(Ê>>·H>ÞÈ?šÈ?K²>´×î>¾³ô?’?2åº?0ù!?;76? ?06?Á>ýDè>ßv$>¢Ô>®$>Í&º?(‹N?èJ?g>™áp=»žÀ=ß*°>6I<>âëv>éŒÚ>\TÐ>ô+n?f:,?^R>ñP? }>ùñ”=ŸQ€?8N?€F?–9>ï—x>ö¨Ä?£>Üœ`?"|›?"È>ĺ¬?Ø?âÄ>çe?E'¯>½F>óÈZ?ý>sƒ¨>ëYˆ?¬–>ó3D?p>Є®>Ðdü?/î?ö>ô&´?#$ð>:ë?ëI?AúÛ>”Ùê=áð=¡S@>á¨t>û‰Ü>õ'Ô?-ë>Å+`>›D>î€p?5úk?4kì>Û" ?/OÒ?•ô>k +ì?\Ú>ßüB>í,š?l–Z?5ãÚ?*µ^?ï>H%¤>ü(p?io?Dû<>¨Ž=¤²0>)8?²?²¸>ƒ¶ì?(W?3¹>È$Ì=Éç`=ÏfÐ>tg`?&‘-?CV?Mº5?Dù >Ú\>(3ø>ÂD>w÷8>÷]Ü>êŠü>ìx~?HÉ-?‚—?2?+p¦>Ûf˜=Ù+>üœ>pƈ=ïmP=6`>ü ?0Bô?Æ}?åq?G|?.Ãà?‘‰?/-H?7Ê’?5À¹?&?Ò>¢»¬?,è>ÿNÆ>yh>ð¥ˆ>ö¢>ÅÆ> x>Œ:à?< ?gÒü?NÆY?R4z?8¡>õRP>Àü>ï\>ñˤ?ƒ‘?JÏ>Yx>¶~l>†ÎP>ÿ‘¾?ou>âQ >‹9|?!¶?/ú>ô÷L>«ñ®?*Þ¬?óm=]Þ@>© ? +'Ç?“"?, ?%ø=?Y?5?Þ>É@=ä˜>_Ñ >ëh¢>Ä>À‡$?$_†?ݾ? ?L%·>ùý0>˜X(?U»Ÿ?8>¸¤t?zÜ>½L>£Yl?­Z>¨cÔ=†¬Ð>Bòä?)³?ÀÔ?9ÿ?Aˆ?º >Z@? +i—>ðá¦>´8>h1 =Çð>)ñ¨>ZÄô?û?4$€4>n9ð>Îlè>ï ?4׫?r?le˜>ó²˜>Úè>:>ýÍô?WŽ(?cÀ?,LÂ?ö>5ð=b€>ú7L?ZÀÎ>ÆúV=à `>aP>§ÐT>ÚŒÌ?ïâ?M5Â?HPF>¨KÔ>r¡¨>~^È=ˆ×à=êßp>JS>„N†>Þ:Ô>ï±>&EH>Oï?¥Ž>ø¥(>8I`>«>È>Úà?ƒ?xKV?;@Ú>¢ª,=í°=þsð>L>\¥ ? ¢±? +¢®?&­'?$­î>pl>š¬>¢N>/¸p?h?q³2?i²8>Û ˆ>Ÿ>+âx=ÇÂ@=U>ÐÑÀ>Ùp >€>æ$>˜i0>ç”>¬ù®>ÆŸº>íþ ?\?-jŒ>œR(>¨˜¼>ªâH>žæ?(o´?F5'?aàÛð?(`>5+È=òô?ϼ>ÝáP>÷žÊ?ev/>ê=Ô? ”? îÎ?4Â?ÑÄ>Ÿ$>¦Ì¤>Õ +¶>é£ä>™ä$>ÙQº>ÔQT>”_<=ýÒø>D»ü>NBX>Ëü@?T¬X?\¬ô>ܨ˜>uIX?ù?0Ka?q«? +C?CÖÙ?GG;?ei>Lh>u`?ƒð?^þa?Þ¤?P®?Ĩ?^k?Id¢>ÇO¼>´TŒ?/4>î‰P>—(ä?Q?6H>¢þ?™›?=F>¸º>¾KÀ?+V?a/”?jC:?IÝ€>þ¼ä>Û ?IK?hQT?Æ >\>ÌyŽ?L?VŸç>ÿ÷Ü>eÐ>ôçØ?/¢$?²>Ó ´>ëÛ? ´õ>õ\>ÔxÔ>¢zâ>œæ”>š†*>)€^P>Àa ?2”?Sf>^(>ïž?vI°?Â?±¦?mæ?U.>ÐDÊ>àIR?5©Ð?-c?“ƒ?mð>ÓØ?óF>â’>Õ–>Âéø>nQX>ÎÝ>aŒ>¢Ö?6rå?5ñô>·É^>­ü†>¸p>ׇ ?øÎ? |ü?IPD?<µø? ¹l?#†Ÿ>÷Ó?’? ¥?´Ï?sËR?CB£>¯·Š=Ù‚à>µA$>°õ€? ?S?–}>i…¸>ö¤ ?)7?#¡H>Æ€<>FIH?¡ü?wa?'eÁ?½j?J…V?·9?7 §?u=œ?j/h? +ê=³>n(?Òð>Â} >º­Þ?D|Ë?"ð­>œ¿J?‡,?j¾Ž?$¹>£2|?->?>œZ?8­>›>˜Ð>¨ (???É>‘[:>~zÈ>+«¸>QÑÈ?x?™Ú>ð®°?2Ž?»o>6Ò>¢†®>à‰J?>Lj?`Æø?X˺>ê>ݤ?C‚>Ä"Œ?@;3?%Í÷?$^z?++2>î0†?+¯È?:JÒ?Zp?_¾Ô>×<€?!‰?O–„?!´Z?ý^?05??FÝ?:mb>·ª`>Ö¢?`Òü?RäÖ>¿/d? Ø?NaÀ?b?;\Æ?*!í>ýë¤?ßÇ?= ?¥p>¹Áp?CÅ?:eˆ?(Æû?l ü?l°Px ?»õ?˜k>‹;¸>nu$>ÕX?2ˆÀ?m®x?j4?9q>ú¢>Ë>g¹Ð?ì >ú~?½T>ÙèÔ>îpÀ?-Q´>ÊA”>¤t?>1? Úƒ>Š<?’?~Â>aTÄ=úwø>¬Ën>¹á>Ú‰^>¹×$>Ø¡”?-r?FU?SdÁ?D´~>ó>¿„? â?49g>†‡¬>ÆU²?DˆÆ?Y$>p«ä>Ü^À?éÏ?‘þ?}Ö=ÄU0>ÿn„?^¿?;Z?G³^?=< ? sœ>êø¨>Œ"? –?Qrk?N²?“©?3Š&?± >Å6”>ã²Ö>©öÀ>úõ¢?kܨ?>¸ >ʈ¤>!Áè>Ý"‚>ájÀ=Ò >ÙÎd?˜·>óE>Ÿät>Å ?LÌ?Ä>zˆ> €>½>õB”>¶€Î>Û=8?5 ? üÃ?1??Qb>ï•Ž>4(>üö?_ü>ÄOR>é È>çì? jj?K >þ=¬? Å?=ª?+l>jè>÷N6?qý?MŠ ?“F?Œê>ã2h>YŠ˜>¼?«f?]?$¾~>Ïdì=‚›P>ëܲ?SÀï?¡’?+&n?jŠÈ?n8>Þ™ ? q6>å_~>£œØ?¬ ?CF>ðÒà>Λø?uÜ?$>äs>Œ%4>©?7íí?¡*?Ñ>î'¼=—TP>1Õ€>G|>í V?^&å?«>Î6Ä? +n?&‘Ó>ËåÐ>›­|>çâª>†up>å‡r>Ÿ_À>ÁÕˆ?DÇ_?!²1>Ö¦Ð>ɶÖ>Ôæ²>ùÖ>ß*¦?&¨?X΂?H§h?5Qp>¤ ê>âKô>íw=¹@>ˆÕd?ë>ïIº?!Œó?^.$?@Ùý>³ÃÀ=J ? +æn?xò?Oj7?"ÌG?©>ÉŠž>î‹,?2f0?@{•?2s¹>ø)$? ÕÞ?:žª?Ü´?Cå(?cÅ"?Mh_>Ë;”=É-ð=î† >žÔ>Šëœ>úÑx?"bœ>®t0?«B?']q?Ûš?<ˆ>Û8>)¼=éfp?ž?BÀŸ?+Z>׈–>„…,?˜ö?B§²?:>>’Çô=¶wÐ>ð±z?? q?P9w?,ó#? `c>³6P>u²P?1„ö?A§q?CIH?pÐ?—.?8öð>±Ìf=îå°>Lg0?'ˆÊ?[ʪ?ZÐ??6¡Ä?®ô\>׃(>®©œ?Ðþ>æì=˜£>?#€?,ì*?K[>yô,>Ì°´?*Ë,?k>ïBl?`݉?wæd?@2>§.|>ØCØ>¤T°>/ä>ÝÚ@?.Þ>Ý?uv?;{¸?6Ç??ªÁ?Ãø?Þ¸?‹å?è¢?Kè’?&uD?'ŠÙ?L ä?O³Y? „Ñ?ÂX?}¦>†¶?d¼>µ™>»»@?yž>|Q´>²™¬?0:ª>ér=ØÃ@?*ŽJà>†ê=»3à>b>žP¸>îìÊ>Éa$?ÊD?/??–y>×…Ö>Ô‘L?Dÿf?Uš?2Ï>ƉH>„ÆT>+Ü„>5`˜> …>À6Æ?".“?£‘? l?.£>?>ªN?7ÿ?À?QÚ?Qp0?*ß–>¦Q8=ô€>:x>˜ >NÄ?rÉ?H? ­? Õ_?ph>¶Ïø>£m~>Ímô?Eïü?&È•>¡_Ð>Â8l?µë>¸»>Žœ>U%ˆ>‹¥^?!“J?) +>›?Ø’>ÔjÞ>w€>À>ð>GÈ?eN?kG$?^O?5ÕÀ?&wú?4˜í?!h +>ÝÒ4?˜¨?JÂÖ?…?@a‡?@ê? o°?´.>h2>¯¢Ø?2¶]>ÿ¨ì>± þ>‹ðæ>¶ed>ßT?$a“?€.$?‡^<ßnÀ>Øà4?âô>6¢>¡¸?7{8?Ò>þï¤?wŽ>¥©?p³?-ûì?Xž>][Ì= õ`>ÎH=¤¡p> ãÌ=îi@>ùmà?Rî>×SH>¿ËÄ?.Ø?'? Ój?2t?!ÝG>üJ>¾:|>ÚpÔ?$§ >ñŽ>º>>Ï’P>hSü?‘â?8Z?MÄ,?G•À?t>½º¶>¨uœ?§ä?'Ž²?|È>Êš¸>)s>B×T>‹Ej> +Ê4=|5€=b_`?Ÿ?A°=øšè>iNl>À•Ø>þˆ>Qˆp>§:d=ñ]`>ʨ?[§î?&Ù¼>®N?#h?3<=ê‘€?k=?:×0?6v?`Ê?4çä?=Q?×#?M?F”"?M >ŸÉ`>ÞÂø>û¸>Ø.(?-Ka?ܨ>!BŒ>öd¶?*ê¤>îy@?! +ï?Mžá>ÄÆ>¼1^?&Œ?B°V?V’>ËL">æˆÔ?)Rò>íX>¡ƒL>ÀÊ>²s˜<î>¸×´?6 ?"¼>ýÿ¸>âXœ>=‘ô=§…à>=¦Ž0>{Ù¬?8g?qº©? ç”?(³?2œh>öȆ?FQ¬?Oâ?!1`?(f²>É«X>:wP>Ð_? —>“”¼a>å¡?uÌQ?&N>«]? œ‚?v|?(Qê?ENä>åÛ|>“nš>â™@?:N?'|>ÔX>þ*H?Rxî?!V£>·û +>nA>™(>”š>‚-`>Ú®$?Mÿ’?aÙv?/¾z>•T?û-?Cš¶?N ?q6> E>Î[j>ÌrH?”?ZB¹>Ùû®>ˆê¬>U)à>–NB?"ôx>¬h°>ÄZ’>ÄýŽ>€>A÷€>Ü4¶?/5‚?Ä>š$b>Æx>Áúuj?(«#>ût’?B¦‰?íˆ>*K?qì>óä ?–í?$Þ[>Á_þ>í¾?T?G¸@?EÚ!?3¯>Idp<ë˜À>áaÐ?Ypè?ÌÃ?(Hà?¤š>í8?Z$è?2]F?‡ª?)ÆX>Ûå,>NÌ>ŸÃÀ?fx?a +?7¢š>o‹ ?Æs?.åÿ>ÐBº>¢Âø>?X˜? š›>í²D>¯iP??ðä>÷ãà>è r?O™v>ñ{Ä=½Ì°>¡E ≯|>}0>ꃤ>šç²? gò?MÁ?2=?.2T?IþO?Wuð? +è> @>õ-d?¤=Þ Ð>Óî(?K?ÙØ?‚/è?Oc€>Ñ™œ>'¹ >” >Z? IW?.Hu>íz>©mÚ>Ì6?8h8?9 R?².>µ8’>øœ>ù =.7`>¼îv>Ï/2=¿Ù€=PA >´\>¸¼>&k0>ß/X?Š·?$) ? +o@>{HH=åö=Î~P>ðÁP?Oî>Ð +”>ÿ“@>ùë¼>Í?q>Hð> >þ«Â?|ø?!? ?BÜ®?‰Þ>¨Ò„=Ø7P>oð>ˆXö>Ò ü>ß—ð>ñÖJ>ø>„Š¬?S¤?'¹,>£¬Ü>. ¸>¼d>v¬=}wÀ? + Î?k?€}?¶?²@?S¶x? Ó?é¾?T¬¾>ÛAÈ>Ñ6?Ý–>Ú<>Œ#?:n?Tôî?Eoö>Ò¿?êš?W ‘?.&>Ófþ>õ‘>?9e>­ +p> -ä?zÀ>ÖÒÀ<ê>Ífî? Ôl>Ĉ>–aì?F‰>ý´>:³Ø? à\?W‚?yì>e€>ïÎ>Çßà>¸‰¾?"}>ÀÜô?u?8e ?<0? ð?JÅS>þÙ¢?ö?²>…VÐ=pÌ>í˜h?D™Š>ïæ?oz?G§‚?XZ?XÊ?%·n? ª?Sm?DWÉ?>ßã? ^>Ìð?7`? í>Ø6P?4¶?ös?B†J?pY>Ý#š>äq?è>ö±–>„>3@à>óúÄ?«¶>s)à>(Ð0>‡õ(>¢>RÐ>ËE.?TÕ ? ýs>º^ð?K¢? »f>ƒU>Ô_¨>º¿>£ÄP>× +”?+|?_{`?# ¼>î&>l?>Ë^ +?32W?$Q›?HËÜ?^¯µ?ïe? ?LrV?#Èn>èl >ñ­L??ä¡?q¹?`Ä{?>ý·?)Õ&>ýJx>ÈM +>éî€?‡þ?OöJ?"'k>’ò>­ù$?+˜À?W'¦?·=? Ö+>—ˆx>ë|L?5¹>± Š? êÅ>Â,>ìwà>ä—:>–÷´>ð¢¨?N×ê?MÖ?N?—?a¢R?^>Þ>ìßÔ?æ8?ñJ>†¸ð>Žp>©|Ü?0 Ê>å¶,>Îd>*Ƽ?ƒª?¡8>¤ƒ >š+>§Œ>vK„>ºÒ„?"H>ýÙˆ>ÿ|?Ds?"¡ú>¸;ˆ>bFh?þ#?aî|>òIÀ>u~`?Þ½?_„?É>“ô>>ÞH`>¹Äd>u˜?ì\>æÝÚ>†Ëô?¶¤?Kò?\,C?. +¯?F†ê? úÐ?"þš? ’)>»à>€œX>–óB>î½â?FÑ?D}ü?P¡?sT>¢Kü?Þ>¼d?ÝÈ?ñ>¾`?dœ? ¬>ýÉŽ?l>ô&l>=@Ü>•^’>Ë?qL?Aç>éô?o”=áSÐ>ó¸?`·&?š>}IŒ?þ&?NÌ1>˜gü>‰Áü>¯3L>Ϊú?FІ?%?)<Â?Š=øüÀ>dµH>Gƨ>RöÄ>Ùá:>€~X>킼?T>’Þ>ùâ>Ô®`>…@>ñ>ù—¶>Ê%h?Q~Á?1<|?1S?9">Üý¸>òú>“q =é” ?Ÿç?aí¢?gv#?p”V?t:?=›È>²A´>·ì>ž=n® =Û+°=Ï%ð>Ã!?I¢¼?ºÔ>®«?;*?]V7>í(>Ä*ˆ?"_å>Ó¯>@p¼> ò?5b?1d?G?ÿk?,ê +?=äÔ?. 6?`tp?FyM?9î>ë¨|><óˆ>÷¶‚>Õd8>¥³V>À¡ >ãyN>îz(>ÐÒ?EÔ?sÒÞ?FT>ãóJ>Œ]P>˜¬|?ž¦?` +ê?gˆ’?sš?3’&>ß¿¼>©J$>Á·è?J@Ü?\ª”?Dè|?^%´?,VÜ>°Ð >›¹ì>Ëš>ÓÎ$>€EÔ>Ÿ&„?E"ã?( ´>êzT?#9Ø>´ D=0\À>ãZì>ü\(>äÐ?I’’? +ý?xÕ?XPò?/ª>ÁFè?7Ûm?3 É>¥È¤>!À>%yÀ=~÷>ÕÚà>óNš>Ã:¶>öy">H-Ô>%È°>ùÞx?Km?"ª>é¼>†Át>jh>òŠ?-Ü^?EH?$þ?? 6?™d>ÂǨ?Ò'?(Å.?Q Ò?Õ~>‰0.?6KÍ?_¼/>»Ó$=úúÀ>Ç/´?8¾?q + ?lXÖ?G¥*?â.?ºÆ?^›?h¦¨?'i¸?2C?d¤?ACÊ?û~?>¨?Ugf>â«>6‡ >ª;´>ÀÀt>ÒýH>ÈwZ?àê>ìy¬?W-?0j>»?"?Hl>üE‚>kÇ>àÐÎ?DÇ>î!n?ÄÐ?-¥î?þˆ?&/4>–‹„>­=È>òæ&?Ca?\ü¾?c¬]?^ü?ë +?úâ?4^”>ˆÈ>M]p>¢PZ?PÞ? ›¤?'š ?:Wt>p®0>§!@>´O¾?Õ>óxÔ>lip?'8Œ? ‰? +Œ?R\?Ô^>¾J¢?q‡?Qº>[>˜>¬²Ø>å7 ?ºJ>Ðzò>\¼?p? +§?Ý×?kÎŽ?S,@?>çT? ¥ >Êæ„>ôýä>Ÿ“Ä=ú p=˜G°>{ˆ0>FÅ >¿sŽ>± >ÜÛÈ?nB?Ô?XF0?:¿Ý?`ZÂ??Ð:>²"T>˜³ø?%×í?¼<>\?>| +è?jž?œ>™“œ>ú¹œ?jØ&?{ßT?ÊØ>ÎÍ2?$Œ??I>æÆx>$º>ùÝä?;Ô@>Ôô¼?\ ??L`>Û½â>ý >x,È?+üS?G?;#´?¤É>Ú?nè>³“ì>×`L?$0>ƒ>¿z?Kò?þ?0€ì?õÞ=éF ?,?[]J?@²ì? [z?+*Ì>ø?X>:zð?&yt?m!°?N˜?V_r?zŽ.?P=3>µ®¶;‡¨>Ù\Ò?e/õ?\*é?2>’–ð?Fª?>´t?²t>Ž8=QŸ >ÂV”>Ô­Ì>‚ûü>FÛ=ãMð>r à>ô'X>µÆŒ»é,>ï¸P?bä”?ZÞ€?põ/?S +>FW>’E$>;=È>ʳ°?H0>sì¤>ã¤>лœ>Ξ,>Á.>ÁØ>îCâ>Ðâ>‘÷D?6?I.è>õmx>Æñ?X°?3C7?4ˆx>ƒ$Ä>,[˜>â >b|?Aâ>¹:È<ìf@>²ñÐ?:0À>ìp°>ænŽ?.?€°>úÖ=ëf=5€>pµ>æÎ>¨¨‚>œ;0>úk”>ª`>«±4?7¢?MâÁ? ^?6Ž?e?$ñ,>µ ê>a÷H>ú·¸?'?4?ö=Ž >») ?8wÊ?^>²s‚>´ìâ2>Ííî>šÊ? + Æ?L`ï?Bà\?"µ>‰Yl=Ò >oaÔ>F¨H>½áˆ?8o"?‘>ö-¾?-ëÜ?Mp?bÙ??*(J?ŽÊ>¿éÈ>„^?£*?"Ø>Òû*>ܼò?9ýÈ? +dk>¦Þx>¦·Ð>µûL>¿ø>Õ›Ò>þÆÈ?x >ÑJ?vO>ô6ò=Õ^ð>ŠâD>à´ ?%i®?m"¯?e¾8?$\¸?3ží?<ÿ>žÆÊ>´h?*[®?„ë>|Å>¥±è>¥uˆ>&kP>¨wÌ>5bÈ>R¥à?÷4>¹–ø>Mž0?18?*2>‡ÏŽ<¢€=îÀ>mSÀ?#Tê?"K>«÷ ?©|?3&Ž?ü?5G°?%|?K?B›?êF?PÌ?W»v?Ú÷>Ic >“$à>'ãø=@>_ü>’¸>ÉÐ">]™Ä>›=Ð?2ß?<Ÿž?&až>ý~>¯à>ªZ0>Åo¨?n½?@HV?WyF?ò>¯x? ÉÆ?ÿÖøx?+\?Qͦ?(n­?)?×?Zö> Ú¼=ÎP=):`>šqH?3?8\?8T¡?=!ï??7\?®>áÜ?*ö?RÂ?¬´??»Æ>‰ß²>2-?{Â?s.D?Kå[?R?vt?~–? ?ñ?;?Ô)>ÃP?&eÑ>áÞ8>þYV?Z‚?lò?QL]?`|ä?5Æd>¯/À>Í °?3ÿß?_´ø?OšP>ºÎ,>×TJ?:p?BÒ?BÓ?ðþ>¸ž¤>ÇÀ>ø<Œ>”tP?Ý? /? +O`? >óÇ?Nj«?bÁ5?yʘ?X׊?2ö1?K'?<&D>ö†Ò>Ú¨©,t>˾>øcð?mÄ? +`Ó>»Ø?“ù?oö?"Ë>òÕ$>bå >öQì?)¡8>¡—$>`°>É h>¬AØ?÷‹?ž>¥£h>º¦Œ?4Ì\?õx?G Ð>§Ö=¦e@>Ó„?0nL?9Ír?6ôò? f>n˜>ßa?L>€˜>漌?1pÈ>¨KF?!š?1I?/kü?4­€>ôêt>·l>Žºt>GX>ÁÜ?XÍb?$Š:? q–?Ÿ-?‡Ÿ?">ÎMº?!ëŠ?5>ÐÔ?Ý—>ü\\>ÁÊx>ìé„>þ"˜=Ö`=ò À=º)<ñG>*!ø>ðø?=0¸?8…þ>™|>xæ@>nd>Çýt>ÿØp>û(?ç">†f<>`¹à>n:(> Ãœ>ü¦Œ??ïT>Þö>´sà>³4´>¾»<>ÀÜ>èÐ>¨>Þ¨>ø¾Ä>@¬?rX?~[>­¢?æ>—5Þ>‡P?2JO?LkI?9V×>Ùsì>èEž>óP?È?i.ð?WÚ?E.C>ܪ„>¶"?=%Þ?dòR?XÉÅ?у>ùáØ?,@.>Ô&0? +¬u?QA ?Pÿ>Øĸ>¬>—jH>œ¹¼>åŒÖ>µX¼>Òtø>þt4>Ô8?6W?%|¡?/¹0? >?¯…?â²>¦YH?%ƒ’? fY>‰r‚>D¦P>· +>è´ð>öÀ?—·L>È.´>¥±>ûîÀ? ù>;Àà>ÖF>í9ž>Ú£?F>9?f£¾?Sè(?·À?0³h?Ä>œý>ÖL>é˜l>Åjð>=R? +‡?X|>1^t>ë?¤? )? +Q?QÜ4?N¢½„b>½MH>†èà>È5œ?!é? ­è?N= ?S>’?2ì?D`>‰±ˆ>…ô>üà?J|?%Ú€>¾bÊ>ˆr?*jæ?{$>øÙÄ=º)p>Ìl? §‰?TT|?x°ü?%¬??nf>>–#Ø> t¸>kª8>Ȧ>bè>W×Ì>ti8?,á" ?&ÑT?_™?-Pô?$H?Sƒ.?EsÀ?(û?7Hì?(F¶?7˜b?Ib?—ª>ìD>ÿ l?~+„? Ä?*?Rù?>H>g=ØK >sÞü>¦‡Ô?!ª? / ? j?Xã/?@ža?r>ìÕ4?K?  >Pel>¦ ð?3ìá? %P>TD>à×ü>²RN>¯·è? ">Ë«„? +O ?^Å?RL>*o>Œ¹Ô?,4È?°Ú>ð4l>öþ4?#{?aì™?K1ô>ׄx>F}@?*òW?f+??"ï´>Õ®¸>€$>÷j`? +ŠØ>ðú?¢î>ì-Ô>:ød>­‰T>Órt>gq˜>¹š°?# >? +ð>³¬?;®?/R>A*4>‘sÀ?‚D>…€>iø°>úÔ>æ@ô?^.·?aIx?#g¨?÷?ß>› N>ëÔ ?Ö´?'ä‘?4¯|?J]???R?;Oæ?…¥>;Þà=³ëp>ÛâF?),h?3â>ÆÛ$=Àô>¦=¸?ß2>ÒYp?˜b?c@þ?i™?|yà?7Ù$>¯÷ö>Ù.?yã?$±K?L}ë?&~Ÿ>j?f?aÁ?:¨? »¢>ξ?T ?Xšú?íæ>üY¾>ªjê>÷HÔ{F? õ?‚¢>žÇ>UR@>¡¡î>„¸>ÇÖ >ë B>‰&>íL>ÄÑ(?Ú>òVÔ>‚Lö>s °?Aþ?)ÿr?*H>?3¼>;nÐ>öé?@o°?<Ïä>ý¡ >Pì>‹] >¼o¤>÷ÞT>¸Tœ>é 0?CÛx?,I¨?5V?BW)?³l>ÿUð>Þ¼D>š¯>ÿÝŠ? >¯iø>´d$?“n>×æœ?v>?Kü>ãÎ?7×~>ÛÜà>²“l?ØY>ƒÞ|>¸€$?J†>ˆYÐ>ÎŒ@>Ç¥‚=b*€>¸>Ö™´?.|?aŽò>î«8;f”>èfä?A]s>Š6H>û•î?Bê?/|?Ní¦?B!>ÙB´>øuh?/ì«>Ÿüø>ãFt>ÖâŒ>x >³ñì?,Ïy?'ýë>èm¨?ë ?>¢”?01N?7²[?â>øãÎ>â…^=èD€>ýsê?YYÞ?We‰?+0?-í?^®Ÿ?V¢þ>Þ%p?½Ï?: +Þ>מ>§Mê?!ˆ?)Q}>ÆvD>´«j? Tr>¹Ðð=äÉ>á)Ø?Sg>ñGD?*W?^À?Dšf?Š?«™?ɼ>ÒÙ?"Ÿ?0ª>7W,>+· >Ÿ’d?•s?FÊò?/ˆ?!åÊ?c ÷?3šu>¬Û¬>­X>Šs>?37˜?69s>ðf=—PP>ìåè?>¹>¿|?ÏÚ?§B>›{>è[J>q‰>‰Ml?‘?:Žü>¾ >ô?mLò?{ed?1ì +? ˆ"?'ÎÆ?ù?(?ó ¾>»a?:.>œCÐ>VH>¢,?+c†?]? ñ¢?[*>õ¿v>ý…?PX»?ft¤?Ô< eÀ>4¶ø?"T?%†r?[`?~…??>ùŸ">ê—À?G±Ä>â¯D>ì"~>ôx>îð4?JF†?jÑÊ?p>_œ|>¶$6? +Ã>ã«ü>–6D?,¨6?eÔ? ž¼? Tž?2Ö?/™š?Õ??“æ>Õ& >ò–? k¯>À~=½‡>ä&Ð? òÚ?#Ùx?5ñ`> îN>±h8?-@Æ?6ýÌ?.b ?wé?=p¬?V¥?:o>ð”>ı,?N‰?J¾$?+ð?$‰Ë?%е?8M,?Œñ>·iº?Êæ>Òo|>å¨?9?ç > >UŒ?Úš?N|q>¿ŒP>›x>KX˜>‚Ýl?(>Ên¤>ñ +?Tœ?hÃ?>ñR?.Ý—?]»?3bõ?~>ì.€> àD?Z¤? +Ø™>é´Ž?_Û@?Må¦>ÉùD>©et?$‘ÎE ?3¬?<Æ?>•R€>Á)?Þí>Ÿ¹&>Ø>°$>´­ê>åS0>…ŸÜ>P>>à>u§°>ÆÊ>‰N>îv? nÜ>¢æx?\@?Zz›?!cÙ?;žT?_½©4>-ªÌ== >W+¤>Ïp4?ØÜ?LI?¹Ã>[ Ø=/@>­K¬>¦®°>uh>çÊ”>Ì +Ö>Œ¼”>T:@>é58?&À?+gx>ÏuÐ>‘4Þ?b`>°æ? ó.?&Ën? + 2?A@›?0¶ƒ>ðÿÔ=é?P>•(>—·¸=¸?cÌ?V/¨?@;¶?$ X>nÕt>ùaH?XÈ?û>—6H=…Là=g  =È~Ð>+è?-(?FQÊ? È >H@=#ù =¿°>ÝÊ$>ÅL&>v p>·_p>öOP>ä @>Ô¥@>èˆ>›)¦>‡n¤>Ý?>ØZø?6F?(a!>ãʤ?G?y?&Ž?$)¢>ûÖ?þ8?0¾?Ë=?%Ç?Î?4^…?âˆ=Ô%@>#¥>­ûœ>ý"~?@Š? +¾>õÞŠ>ÜrÀ>ãGP?W4ý?õ>·Ûè?†?6Ê?Ï~>Š ? Ôü?[˜¶>øA >ÿgª>û+4>½ÅH?8Öp?IŸ‹?8í¼? G¾>àéV>K<<ˆRÀ>ýå°>øLD=¹•°?^¥?FÑÅ?BU¢?_!">Ü>Îq8?5Ž?!3n>…R>ÆL€?ÌÂ>ý%8>Ô=¶Ð>´¸>Ä¡>¯è>÷Ø<>‚N<µ€>¬ˆ?1‰?>™ö??µÏ?>«¬?ái>½ì>쮄?Ü2>àrÐ>…ëÈ?­Ü>î·0>–>‚Ü­çü>Âi?³>Í@P?ŠÒ?Î>ÿê"?,ÚT?d'„?S +õ?!ä?-C>ˆ`>²û4?Íñ? ÿ#?:Ä|?;e>æ•V>Áµv>ð >€û6>†õx>/–Ì>’N?4j>ürt>(sä>Ë’.?3ÆN?,q8>× Ü>]#d>©Fœ>ìÃD?im?ps?bÞ-?Ce[?N¿„?kñ>½'`>›Îø>ÆŠÐ?#˜Õ?-¨?%Æ>ïtÊ>¢?Â>Æ?f?#©b>£:>|õÌ? í?7(>¯rj?+>]?ð«>›Ž&>°è?$¹V?d®Ÿ?(/r>„Yp=¥Ö0? ¡v?Ü?Ü´? jï>šµÆ>Üv€?À¢?)/ >ųØ=¤O`=þè˜?Ýk?4Iµ> x>”õ>>ÍZ=ÄI >2Ñ ?%…?Gò)?+ð>ßÊ>…]X>Y,>á˜B?G`t?kž>ïº\>íd4>— |>)»˜=¬êÐ>á©œ>éŒÞ>Ž°>Ô€?N§ª? §=5% >§>·›@>’ž?˜?FèÞ?v"?Ÿ¸?EÌ?pðò>ùt(>•ü,>ÒÞì>sZÈ>±<>çÉÐ>ßšÄ>Ó̤?Ë~>þè¨>w0P=Û¢@=»à>¨\,>ù½d?.•Î>ýrT>ÖÂÔ?Féü?6ªI>‘D>[O>ÖÁ€>}P=+ >Xjl>ç[t>£h>w8>DÙh=•$@>ßø>®‘ä>æÎ0>¿Éü?,o?8+Ä>rNh>: +ø>jÎx>ÿ¨"?Zv4?jÛ?}r>Xó`>©åF>ý?Î>åFŒ?xþ?)4>êf˜>ï‡l?+F>‘Bä>”œ>Å!´>†ßÖ>™Ä>ŸÎ?f?`p6>×½º>þ$?ŠD?1îì>ûÔÀ?)Y{?eÊ1?ASÜ?† +?7±?;Ѥ?Jˆ4?@J–?d>þË°?:¸"?Y‚Ð?IÑ_?8aà>Ÿ„Z>Œè´>È\f>8h>$Æ>€ƒ€>ÉÖØ>èÕ>’Ûz>DÈ?&¾?‘L>…‹>ü7h?X`Ž?ö?3Þ?l‡>áÛ>e¸?9?¨?ÿ^?^½þ?-DL>œ¯p>á3ª?QŒ>æ*ä>Ùîà?8cJ?5?`ó?[R–?:#Ò? VA>±H¤>ly¬=ŸoÐ>´ ¦>µ!>°Uü>åßÆ>ë“<>Õw>ñ¦,?/€>ô¥N>À—Š?I?Dùò?&³ò?ß?gl?J^Ï? +Ò +?>Õß?A&p?*g±?!Œ¨ p>àâF>Ú¦,? +?3Œ?2¿?žb?2ÔÕ?ì ?°˜?5QF>¼‚¦=ôL@>û*¾?7¬>Ö\T>ëç?r?(hu?):¢>µm~>ëÚ¦?0@P?=í¨? Ò>€åP>kƤ>§¬ +>½žÐ? j>ÔïÐ?Ü6?Xeò>Æn> !”>èâV?‹v?&º€?²^?cê?v,?„V?'0>ð š?,ñ,?MHp?9râ?ó>‡/ˆ>Ó,Þ?Yez?_f¾?#X~>ˆd=Œ>B0(?'ÒÌ?ˆÂ>¥£€>’Û|>ž‰`>÷ˆ>Ãiî?ÜÐ>üð\?ñN?kø}?+…d?2´?¡µ><­p=¿‘`?~ú>äîr>|6>R‹|>³]’?@QŽ>îª>ÞØ?',ž>´|>W̸>G€>Ž@>ÀÙü>qŒP=ÜJP=‡gà>Гb>Ãrª>/j¼>k°È>˜ ?&³>ùø<áÿÀ>ßÚ>úæ(>ÈÊÄ?9@n?$‚?$s?r>²úî?"ˆ°>Ól>¼ ?Uò_?NÒ~>¶Cð>¯Ü?,.µ?X;Œ?6Aº?üƒ?lÝ>«Ñô>¼(>»§®>I•È>߸?N>ʬ~?|Ô?9Ÿ$?1ŒÔ?L?(3À>¤V0>›T?±>ÍY>‘Ð>ªüÌ?½è?>²3>­úT>Ö¢~?,ã?ë>?åÚ?ôª?/P ?§n>¥dŠ>è6>äO”>÷æÀ?cýV?U¥X>ÖÙ0?4Ÿ>÷xü>Ñr?*Œx?*¤>æ?>>½H?8%t>Ñ'<Þr@>÷.Ô?OC>ùkÐ>íØ>•\¨?C@v?S5²?Y¤é?s»¢? .>¾]Ü>ÒËì=èòÀ>§ï´?;ŽÔ?J!?5U¨?è?#z? …>Û'j?Në‚?v…÷?k +¼?X{7?^ˆŒ?— >L‚€>€è>¡Mt>‡x˜?‡<>Î[???wf?r÷?:ãw? ÅÚ>ÊÑ\>¦Ð&>è|X>ÈL>Ø=L>°l>þDˆ>Ú€>œ¾ö?@x¦?eóô?C¨W?&+P>‘cØ>B>ÓÙˆ>‰Ú,>›P>Ú¢?"œ?s[5?1xe?&Ÿâ?P²?X¦ø?CÈH?îm?>É2˜>1Œ<> ›>^Ì>“·ì>dž„>À€`>ø? à?A >ÁÑ$>>“X>þì?5<>¬Üò?“Œ?:Žø>Éâ¼>Œ>K¬Ì>øŽÌ>¶ûP>Ûô¢?.!µ?1E&?*›ã>Èc@?J?;Ðà>ʳÊ=õ¨P=k` >‚Nœ>zèà>yÎØ>Á8h?&g/? GŠ?Aß?Õž>¸`>¢ýÔ>88>HÞ>—Ád>Rjà=”p>Ž½€?7©¡?SAà>»’‚>І†?Z,®?™N?žÒ>à(°=®¯P?û?,Ï>¿¤8? L¶?R÷ë?::Œ>º5= >Ò˜ô?B÷?ö>¤†œ>­ª6?9Æh?d? ?Öô?1ší>á«Œ>õ$>/qà>¦j?"I?fVº? 4?h\? _>›>ì?V¶?ø>! €=ûjx?Õ?-%¦>‡¨b?Éý>úÁ”>~ÇÈ?+¢?j_>ø¨>Cp=ö`<¯ÆÀ>Ö¯˜? žœ>Ð!?2?Qê>è?^v>Ïô>¢±œ>ƒx‚>ð†”>ªY\=£s@=éK ?zÉ?o§O?l›?Aô?(DÀ?/0?`Ó>Ât>¨í">Ì)š>¬>Ï"à?7«>Þ¿”>«R>ådf?9i¶?¼>_ À>O™Ü>!@ >ämº?7È}?SßP?`pù?*71?'#?=³q>¨¼?ÃM>èf`>·0H? Yv>íÚ >šð>Éi >öö>%ê >J;”>8­h>Ä1ü?U ^?leW?^>Ë?`©>è«à>˜D¼?=Ù ?8¿?%…ô?(Tä?¤T?:ä|?ßÚ>ü¹?H?$‚¦?P2?3¢?ZÓ?X³º?*w/? ÈN>e >Ú—¢?Vz>óï°>¹Iv>¶.Ê=t² >ÑYH?"[”>‰Ç^>úüø? é>›B?ý4?VÐ;?’«>\.`>ŸE? ù>³1€>YˆØ>„á¨??Iþ3?XI>íÞ&>8"?AÐ>ÌñÐ>x8>Ç€>âc?À;>¼l>ÇР?S&‰?q!?=»>wx> ?7+?Qäa>â-? ?!æL>Äžt?b? 8?J»·>ô•l>“6?*yh?: ?GÑ!?¤>ÆZ>…>Ð>­ÆŒ?K±?C€> o ?8?@Gª?6wk?%¼>¦Ê?˜p>ùÆè>5ÎX?%¼? ¡Ð? ®Œ?@‚? +çÒ>‰rÀ>ø¡.?tLt?<(@?6¡?;ÌÈ>Ū>îä°? é?*X? ZÌ>R–È>^uÄ?6?‘?&¾?>‹ÿ>Àã4=í•€>Þ¾>?;¾=?ûv>²>Yn@>óÙÐ>Ê9? ã?b>Pø=ÛÀ=õq>À¾Î?Lþ?2·¢?l•V?9I,?P‹>ÞÖl>ÚòÌ??¾§?a&?/[>Æp8>êµ¼?,{©?Ó>+n(>’±?)¹»?:^S?¹>†T=š"ð=™Ð>¸AÊ?F™4?{žÒ?@>ÌÈ$?¾>Φ˜>Æ¥„?5ü?e—V?dâ•?Oqã>ñ¬€?3Z?e>Z>õxZ? •`?ðÈ>ƒ¨:>A¿\>2q¼>ÊAø>—–>§ð.>–}p>«šŽ?d?ŠÄ>èk8>—Ù€?¢¬?ˆÂ>ăØ>ü§?"ó>†pÐ>øJº?Y‘¹?5|?»Ù? ,>¼3X>‘Ç? ýî?h£?Eï5>ÙÓV>k(¨>q“ì?Ûž?œ6>†H>LÖ=ª›P>ð`>Õmœ>Ë™ð?—?Õï?*Ú~?îb?ü÷?4â?Dð`?LD8?¬ ?8qÏ? +ºh>»åÆ?"hÍ?RØ£?C¯?B¶£?\&L? ™è>yyä>Ìl?JL~>íOš>bH= +‰€>÷Ì?$y? +Uò>ÊS>•< >Øäh? +•Ò>à*&>üsl?,Ìh?õß?5W?¿¬?#È>”!ò>=!|>Êð>øÚB>ªx2>ÙöØ?GIx?4ê>†à?2E?d’f?C§?žº>òÄÀ»¥®=çQ€>¦|à>®Íì>ØT>ûöì>î‚Ü>/¨ˆ?3n ?%Û>>!“Ø>Bñ¤?ã?D\>>òb? Ä?±Æ? „?;"5?¹¼>…t<¬»À>ª÷ü?.9e?3¬ó?>[Q?CÒ^>ñ‚à?Ï,?W©Z?3$?2ˆ?è> w„?(¾„?žŸ>B#Ü>¤W„>A0À>Èu¬?1æ?G‰.?~cp>è¸Ê>÷¸?dr?‰F>ÅÏê? !|>ß*8>•ŒP>§ü˜? ·Ü?xˆ?–”>×i¦?Wj+?h'D?.ñÛ>÷´ ? f`?H_}?/ú*>z$>"¼>Üø†?(žõ?T­x?;öf>¦Á@>®•Ò>ÝuÎ>‡™l>Ú5L>ó…ò? C?CYð>åg<>œa®?Ú>Î/>ãìÔ?)ES>ë¹? ? ÿÐ? Ò>ü¶?œz?+P£?@'Ï?*>ßqž? 1 ? u°?¸>Ü-ê>ÃÈ@>ýŠ?Bøp?"¬É>ÙI¸>ßÇ(?ñz>¯í`>Ц>âŠH>Ð8>Ì;°?=„Ø?áá>[Á>´¯ >µø˜>¿F?-Ij?K>“]„>`Â$>´,0? ù?æn>»µŒ?+5?)áî>‡Õ”>ç +6? `?#‚þ?¦<>è ?'a‡>Žv¤>Éx?oñ?\´>}$ø?)Ð?ëÆ?ùB> v€>Ð4€? …º?=¾0?(j>³ì?([Ö>ïÍ8? >ð‘”>ú‹p>éç>ƒ`? ,ö>’„(>‚Ëü>‹Š€=¦=à>oód>ä€T>Ä~¸>‡¬X? oò?²,>†iü>½?0?8Zœ?R%±?d²ù?³>V#€>‰ÂÂ?_•?6>“ÎP>³˜? +ô†?Gy?P[ž>íýè>Î>n? Ì?r?bËC?{U?@@?}»?MY?2P?AÏ?ŠZ?¢t?T¹Þ>ÃT|=9å>ýl6?{Ê)?%Î?ôÂ>µ¢Ü>Ê +Ø?v>¨a¼?5P>ì`>ž>×pì>h >Šýª>­D(>úþd?O¿ª?Øk? +s?YÐ?-«Ï>äç>YžÐ>à‚ >å{š>¬D>²ÑT>ƒd>ð¨>ÌÕÐ?2®^?CÔ8?Zÿ>ó6à>þ,|?M ò>Õx&?ß?#±L?|0?$x>Úæ >P4(>>r>ê;Ä>¢ÀÔ>ëÞX?Dª;>ó.>æš?T.?M†>ñS¬>†HT>N@°>彸>¼Á`?vÊ?nûâ?Ÿƒ>õNÈ?aÕ>â d>E-´>i8>lt>t >…fˆ>—ªÌ>˜…¬? µ? )–>ìýÌ>úªp?N)?:”Ï?-Ò>ûX?*BD>÷œÖ>x&l>Û,>Ž¢?g/? Ò?zm>òê?§Ì>ëü¶=5S€>ÿ™h?%á¾? «ã?-Û>¥4=ûVÈ? óÖ?V*>Àµ?–º?6?ŸP>Ðö¸>ìõ@?Lš ?- f?Qúú?6Õ>´þ?/"z? +U“? lü?j¨I?`à?D?%Uê?þç?*®â? ·ì>Ì>GG(>²ñÀ?/óÀ>Å64>ã}$?EV->Î&Ô=«µÀ?g²?2=шà>ú82?.Ó>‹È@>ÒØt?6n¸>¶äž>VX?"??¶¬?Gâ¨?f +?1ÐÚ?+?Tÿ?Di?ky >ŠçÄ>“ +Ä>½l?×n?U¿ø?n°Â?]Õt>ÆW>¼$`? V,>À©D>ëÞÒ>§å<>Į̂>Ù >a@>ë2€>ÚÉð>Ó~&?eˆt?€à>¼r>Ñ—ò?=‚?5,ƒ?`?Gk:?9£$>²Bn>í£€>Þ³V> X\? ït?Q6??4>©Îö>Á¶>öC¬>Gó¼>¬Å¬?/;b>ÐUÀ=°Ó°? ìÙ?"b^>Þe†>Œgè>W¬>˜å²>'@>,M >4P>çª >ûn¤?~w?[JÕ?l¾ã?%°ó?2O?;Î?Z_é?G ˆ?E*Î>ðœà>]8>Ò¦†>fúì>!X>›¯ž>Žç”>]å¨>¾ +~>¢ø€>ÎÖ@?.Æ>ñ¨?î5?C>÷°>—yö>qÅL>år?G>Q€>“2´?8^›?J¤B>ñà”>æ?Ô5>ïCz? æu>ô„€>ߌ ?+w–?B*>q@H>ÐIð>ý}H>”Ý>F}H>±jØ?1Ô?PÏ:?&Â? +??’¾>·á€>Ù°@?{?H¬?ù/?&yp?Bv?Y6l?R³È?Yš1?YMâ?;}Á?;oI?'4?:#?]H1?Rxµ?@~‘?0”ß?Ýø>¶²¨>±˜?Þ?D +£?1…?2ù?sÌ>ÌòÈ>Ö‡x>ð¯˜>ð]$>7”´?Lê?ë&>‰Ð>ò^?zb>|€ˆ>å„? ÚG?0=ª>ø´z? çÄ?kK +?õ?Þn?^Òd??Ì?C^?]:ö?ÂE>˜1º?03?!>ÖÃ<>ù˜>8Y >w:È>Æ ? pÆ>ÀTL=·AÐ=Îäð>2‘€>¤|¾>¤º +?7ç?Q\>͵ä>‰òÔ>ò©>•R(>Š†?)‚æ?vå>Þª?[Á…?lã¦?2n>Ÿ:>#†¼>íÚ˜?T³??!Gå?s?1Ãô>Í×4?µf?K¬›??D°>Ï>ô>_>’¯Ø=Šuð>Ö1$?/ž>Å?EPú?wOÊ?šú>ëö¬>åÊp?gš? >Ø×?š?+V?UêÈ>­a¼><„Ø>î\v?Alw?"¼>ç/Þ?BÚ?`>3>üÔø>úç’?©‚>Ý$,>‘¬´='Ž`>‹€(>Á¶?$Ò3?% º?,ò$?'ò>¡Ž\>™Œì>ÑÕü?P&^?NfÞ>î&>ªò0>½›<>F•|>¯á¢>™1X? B?9b>Ô‡T? ?KŒ¸>é²ü>íÚp>úýò>¿rb>ûV~?ç +>œ4?Ë?YÚ½>ÏÒè?@? ö9>™=Œ>Ȇd>аì?*¢>ñK˜>Žª?6“&>é­r>Ÿáx? +>ƒ¿2>oœ>‡¬>æ#´?1ò?/1!?-Dþ?(?XFô?F½?;nÿ?¦>¿`ž?.Dœ>Óg=†Éà>GÌ€>`@4>Иâ?TíÜé¸>2éh>Ïån?î?-W†>×xx>Äö>ù¸,?úÊD>ì0?~? ‰À?:÷:>Ú|=fH>Ø›ð?‡n>ù€?L…?dPj?tÊ¡?H°;?F†Ô?nxD?(ɾ>À(?¨ +?OD^?.ÓH>Êr>ÃkÈ?6ih?v?°i>ßü^?,Í€?k?I=5>ïz?‰ >£½>õx?ŠÕ>"ø>§ÖP>è‚Œ>ÿ’?L²>¢"à=˜q>ìù|>íÌð=·ì@>=5?ƒr?4›½>íåp>÷'P>¯IÀ>¢ì(?Bàq?;»> –ð>³.?çp?RÇQ?}T†? C$>K¶à?, æ?@$>9ä>›<><Þ¨?W?p~?+Ü„>ðF??|µ?8G·?íø>¥å¼>]24>ÏÈ®?+‰H?30î>üûh>˜½˜>ÈÐ>ÖØx>¬,?%^+?-ú´?vF>êßJ?’ ?A×k>-p>¥þÔ>÷*Ô?!„®?ð=ôÐ?‡²?J ?EìV?câ? nÒ>þ5ð?4™Ç?a£©?j`ý>àÑž>ýßÄ>ï d>ÿ˜ì?:ÒØ>Ïýb? Œ>Î$>ØD¢?oÐ>·—”>3`>þuB?¼Þ>†¾$>ÜrJ?O?1'Ð>ä®H>P!D?eT?>o?9ï?F\ý? c.>—PN>uÒ¼?æ¶?}›³?Xø¥?,…?@Ú?Ì,?X?Â4?6>ó×–? ¥z?¦k>ª£<>+.>ù²ø?d¢?j[?,ÛS?9#¸?{´>Ìjò>ëM¼>Å +~>Ŧ>—”>Ÿ½$>¼>id>ã<$>´9°>„D˜>IÿÌ>ƒ’?0’?¾>]Ï„>L7x>½S°?!`8>áö¨>Õôü>µRp>s¶è?™ò?3ª¸>à?0?º?^Mg?;†f?;6€?UФ>ªx>ɘ?-&?»‹Ä>áõä?¾ì>žÄÜ>úÆ>|„?ß?/vK>k¾<>·|¶? îç?úÈ? ÃS>ñü?Ø>Ô\>ã¬P?:‹0??¨ú?Y•:?Ä?vƒ>²ûx>×$?:”Ø?Y†½?å>UŸ ? ýa?Éš>l³@>`á`>¢¯þ?™ +?VB?!f>Ç.D>Š4è?g?0ÉD>¶«œ>ý6œ?j¿u?k“ ?Az>÷YD>ÕX>Š® ? +@>ùíæ=¤ˆ°>1‡4?0/&?&¦v>F¯È=Ú´ >û%Ä>û`ö>ŸØ>i.Ô>‰šd? +?ºú>»â\>˜k@?#?Áº>¢·?L.h?Jƒ±>ê]>äšt?Ìž>öl>¡V>xT=ðˆð>(*8>üêÈ?/ª? ‰Ø?XT(?-Ue>yo¸>8¤>ÔYü?Põ?4+Ò?8•`?X“†? °=µyp? +ö?8àÝ?%ó+?*’>Ãdl>Öp?4?M,? {?Juø?õ>Ë€ð?)¨>œ>brÀ>¡^h>½ªÐ? <>à¾>h>è>ƒæ>º_ž>Ü}Ä>ÌgÌ?!È??H¸¾? Ãä>ˆ%=Ö[ð>‹g >à$?žà?Ih¦?:&†?<&ˆ?Þ4>×Íü>·¼0?†ª?0™>”N@>„,Ô>í(à>æ0à>›ø°>¶»>Âä?ª\?-Žþ>Þ!¸>Ü7f?'_?$Á{?.Vb?^y²>Öˆ=’›=ƒp>¬Þð?Éþ?5?&&?EŸ>âêˆ>º¿^?Bl­>ÝÕÈ=têà=•O°>cmÌ?µn?Rè>Çå?-w>òº”=ƒÿ>V3`>&ë >ó˜^>ßßF>þ`@?AÆl?KZ?"Ú? <Î?Àf?q’>yð>ñå"??'ö? œ/>P’Ø=ëÒð>‡ˆ? +Þˆ>Å.L>³xÚ>¸&t>'·p?#Ñ>úŽ€>Ð?s.?1gÉ?°K?eql>þ× >Ç9Ž? |>„ø>à*`?J>>à†€?.Yþ?iŠŠ?Ø°?¡g?L³¨?/k>¦µØ>=Sh>gk@?»Î?+!è>æ"À>Ü)T>Ž‹V= ‰À=š|Ð=æGÀ>T +`?!‰?3L>uà? j‰?(>Õz<>Ô¿t>´–>sE(>ÍF€?Äž>æù`>ìÉà>”¾&>§&þ?;ˆN>ö5¤>û;(?'9·?.uÌ?Nî?Zm?u—,?"*ª>(>–dè>u4,>·Hô>µ~Ø?YE>ÄWx>N@>Àd>sÀ= >Ëþ,?3–>¾¡œ?´*?5ã? J?6R\>ÀýH9R>†ù.? +XË?Hz?#¡Ž>Éžè? hŒ>¶ >§í?'ŠR?]>áð>bœX>ÀƒØ>®oH?•?Pu?ž?iº? ¦?oˆ?:$>³-Ä?]J>ó¯n>Žl¤?Ë„?.k¨? } ? +n>²(ì>6À?Á¬? ¸¬>Ï,¸?+Kˆ?YM¶?†ì>º€Â>þjô>÷˜? í’?U>øÁÐ>ã ?S3¹?3$Á?3Ä…? =>ª$œ>KÁÈ>—zª>z ?p?ýš>Ž]:>Òó¶?rV?Üö>»,&>Éñ?6tœ>òÕr>ƒT>…@Ê>·K|?aÆ>“oÜ? +—À?nŸ?@zì?E¦?råœ?=ñ¤?5ò”?=>à?/?FU>¢Ý0>W- >› +Œ? +pæ>âgùÏ ?"œ?°>è¸h?^T>…˜Z=Ž£ >EÏÐ>ˆ>š*d>‡Ü¬>Óè?;ô½?6|ý?ÅX>Ì®h>Å—Ü? b?4ÜZ?¼n?þ?P[?c¸€?Œž> P>‡óL>Ð^>ÿÅÀ>ÿõœ>'D>¯³,? áH?W:Ä>àx.>ܯ^?3W¢?$‡a>þŒ>ïÿD>ç¥$>é4?ÜŽ?W¦°>ÀWT>À8>¦á?¶Ö>ßù`><ªô>Û8>ÆêØ>Œ€>¹aÈ>ýãH?9ï°?29?dÊû?@Æ?l¼?9!0?©8>¥°¼=ö]Ð> +è(>¼X˜?õÕ?Â>¥»´>zX`>²:ð>Ûéò>ïäà?]­?U¯ø?WÀ? Ý>Ef >ª¸Ô?3¿Æ?B`>f¾>Y…p>Šm|>d`>÷ P>à¿`>ó>©5œ?Ö@>ß'$>KÎà>ê„„?"êb?Aan?bMä>Ñub>†ul>¯7ò>°”à?*á²?$?ð>Ѽ>f1à>‘Í ?.(*?f?Kö>ØL&>—º?#¾î>äj¬? D¾?oKB?(QZ?* +S>çUÔ>“m +>ùRL>ìh>ìùà?P?4¼>£à>¹ +P?2â|?$J”?C +¤?k\>š”n?ö?'sñ?6šà?V\ ?¸? b>>úR>Ð>·‡¼>¶eè>ü"|?.Ü>Öz>O{„?Åj?Ã>ËgT?!xŠ?Ôï>Ÿ½Ö=ß >^}$>¸ÁÌ>l",>;ËÜ>Nr@?Ä?#?&D?>N®?+¨?,žÏ?MCÞ?¡>D‘<¨/€>¾é„?-Œn>æz&>>€¨?"(? •F>í]&?g >ßT?7 ? +€ì>Äm,>Ê|>Šì`>çò,?AƒK?,DT>³hŠ>¾N? —??'gU?âD>p­ > Ô0? gI??Šh?+©E?SÀ ?'<>âÈ?+ø?&¹>Jh„>‹¡è>ÎB?1–?F·:>ýô>Ûpê>Ô:(?ãÊ?(H‡?f&?"‘ñ?Jùb?#(>Nµ >^´`>ƒ‡À>³7?&Y¢?KÆl?7,>¬ì"?"ƒ™?_N>þãÀ?jZÚ?ˆÐ?\ø>ÿÖü>á" ?+—_>vëè>þÄÈ>úlÄ>Ïš,>Óœ>ãDø?i=?Dp5?:´›?Ñ?Ð? +7u>~Ý8>Éô.?BU?7ï@>ê£?'åõ?WŸ?I‰>Ø”>àt>ÐŽ„>£J`?Œ>¢l=¹øP=r>d?Äû>á÷Ä>Ü:T?í–?MÌ–?Ëh?Ãì?AS˜>³Wü>3>½ßü>¿[~>°HÊ?Š?'_à?Câu?Fæ|?rä?*‡¨? b>³2ü?}A?!uÉ?‡>ð|°>¹wp>ÏK°>­”¦>›!æ? ½(?³ÆŒ?,O>ÿÐŒ=Aÿ <“þÀ>ÃI°?eö`?L~æ>×Î`>Ñ´¤?8Ä‚?hþ†??¨ð?^W>}4@>4' >ï–Ì?áé>pÝ?g`?@9?8ö±?Zn?5É?ü’?:‡ð?ˆ€?ή?ô"È>ZÈ?Z~?l>º0ü?#u²?[?vÞ?h “?ÞC >³ïT?&°>߇l>ˆkÚ?,E?]¨>è½>H³¨>Å^Ú?,V?Wáþ?4i?ú”?ã>ÞÄ>­€?š?éd>–ó>•2¦>6(?&Þ?x@»?q;Ø?5Õ?*¤Æ?VÐ>¹0\>‡ÓØ?„>ü…ˆ>bšŒ? }?mR>õ9ä? wa?pHÝ >Á:L?(gˆ?W!?]ò? 5þ>õøÒ?¤Ã?.¾?&Z?Q1÷?hë†?5îŒ>—A>i4ð?#c?Zn?1š’?Ýò?0B?EF?3ž>jP=ó§à?w>ʆÀ>¸Œ?d7_?J?Z>ÑŒ>!íH=4åÀ?@ß?Z‚]?7Ž>éH`>:¨ü?f,?`æJ?C­>·Ä<>â§ø?MZ~?+.³>ŽÔÞ>]´`>÷Ô ?,œ? r>À+Ùœ>à à?æ>̓l>y +ˆ>ÎHè>ÂÉ|>ʼnø>í¤>Ú̸?Ò>æ†>NH?*?KY>Ö¢€?`Ü?c$?FÖg?JCï>¯.4=Ïxp>Cé8>îæ&>êA@>1-€>‘$4>Æíú?2Á÷?Ùê>çz`?%`4?ƒâ>Ú ">Fð?Ea?P[Ž?0Î?/Íp?>ˆ?@2¿?Û¤>ñ +?.@ +?6“a? áÐ>hÃd>Íž$>½ª>µ´??Xê>ʽp?›y?8‹W>ÓÞœ>ƒ2€?%’–? Ò?¶Ì?A>÷¥>€µ@=ÉD>tZ8?¿ª?O·N?AØ{>œO`>ÿJv?(ún>CÅø>šdx>íRˆ>ΧÌ>WP?Œ?k|q?A0Ø>Ó3,>d`È>ñ¾*?2(?ˆ#>¼Ž>˜*Z>¡X>?;x–?B='>Îˬ>Èz=‚4À? 9? ¼r?$÷?4þ>gP>ÂÓ?OX¾?!Ã=ð P>Ù> >Ë"è>–…þ?$vë?I±G?yØ>ÿ|F=ÐéP>°cè>š™¤>¹ÑJ?Rë?@’>‹ =g>@>ø%>ï |> µÜ>4D>ÛjŠ@>XnX>áo?6}*?HSÄ?L¨?&Çr>ÜÝŒ?s–?3º÷?Lf?jÂ>ø€ú>€jt>øôZ>ûgô>çߊ?<G?¢0?N¨>ú‰> ¿°>Q >aLˆ>Vú=ç€>÷“ä?PìÞ? b >«l>°Ã ?¬t?HËü?4œª?5²?‘g? Š>÷ux>ì£D? –>¡v‚>ŽyÀ>Ï $>œ>ｨ?9 ?(E>Ô L>ºÏ¸?8c$>ö&Þ>IpL? äâ?+á.?Ú†>Å(¤>¼=«Òp?±Ô?qÐÈ?;œä>Îcx>ÌP„?'Î?b>Z§P¢£?$e—>Ýì,>¾E >|°|=÷_@?&¥?Dü?5{ä?;ñb?1qÆ?Šœ>ø0?;«@>ÛiÈ=×Ì0=Žè@=ÝMð>ì# ?Aö²>É^,>`> šÈ>ê Ø?'†´>íÏ>Ê–T>5±È=’ > °°?Æ’>¾ÜV>Ví¸>é€â?z?(Ko>ìêì>Ú >jxô>¢Uä>õè0>õ¢”?‘é?U&œ?…i>?Ð>±]D?.•ô? ñ?‹È?Q0ö?g" ??%Î2?Â:>‹ô4>óêÌ>ƈB>ÍÙ>™f>¥]r>Öõ†?,“ì?*úô?¡?:ÂÜ? ú?#n?"zÃ?:Qž?j#?' Q? +¶è>‚~È>ª™,>”f˜>´t¼?"â–?!¾¾>¥˜>”LÌ>ªË8>cý˜>ÇÝÌ>ßB\?N?³W>2˜>úòŠ>ì <> o€?.X?4!\?Gg*?T~·?2§>Ü(X?)+?*+>6è;ß9=W'€?¨Ã?tÌN?8^?#Ñ'?n2s?Z¼? ó? ç»>ïþ?>Ñ?L‰>?céî? ? >†¦d?2ª2?/¬Ô>á¯~?â´>ò5h>Ïù>šÊV>|C¬?¼\?LÈ?Wz ?+„ß?VÄô??ƒÂ?%ÅÅ?Ažv?Hè?xv?&Î)>—€?É"?V‰ã?Ú(>΂ˆ?Ãü?+¬>e14>`Œ8>ùpL?0S#>¦¦ô=ƒ >q¼H?=Ö?<Ük?jÌ?Ö¾>;>Ç9 ?Ñ>Š"=õ$>ýZª>ˇ0>Ü4?1 ³>³Íœ>Ï`Þ?K?Èý?]ª?(6>ùeR?U >ö…ü? +b3?)˜Ö>ò9ð>æ9˜?²>á ? + ²>Áý(=?À>ž x>¯ûP?el?Z>a÷„?éŒ?EµÞ>þ»¬>šœ?2j›?5÷`?5Q§?` +3?Z€?bæ?Wmp?dÒ#?mIâ? \ì=‘ð>Z¯>YËl=W—À>²Ïd?I¾î?-_ä?ƒ°?n8V?1ÿ'>|°Ä=æ¶Ð=„´€>ÒA??%²?¬>QwŒ>àV<>åÃb=ô?>_>߈?=.!?H>þðP?&!9? W@?6c? D>[ã€=ó >!²\?Q°>ûòì?¤Í?¬ö>¼È?7Ç?8 >¾*>‚ð?d?A†à>ÀÅè>1Ìð>~gŒ>ŽO(?îêœ>´4Ò?8Ÿf?&™2>Ë”.?’?¢>ÃÀ> ü>¸ Â>£›J>Èø ?+ED>òPz>–Ãô>û ®>©ðz>óÞ?i÷[?um?wT–?>•P?M +?Ek? |?uï?E«Ì?QЮ?h~ï?9ù¾>ª¥L=u >¿-ä?&R€?3°Í?$÷Î?D>ÕžŠ>õŽ?)Êó?*h>è¤?o—?33"?3{©?–ä>9ˆÀ>} >È:p>l8„>“yÄ>ìJ?9–>þ4>e>ìÀ?Qö;?X7¸?P 3?<)–?Kï?VQ?Ø?9"X?"'Ó?{`?\Þi?EF®>óª^>ûl???kë{?g°>ƒg0>£|Ø>Èêô?5Û€?G $>ïì>dí? »º?]†?Ž>_x=y>ìp˜?5i@?3>©?R–A>Ûað>Ì¢?†X?³h?V¾l>ôE$>‰¶r>ÿˆ? +£?E¾>Dpx>eþ >Lǘ>úæ˜>­»`>˹š?9‰?@ú|?jÙÈ?>M?UL?08>î=Ü?Ïë??w?N)N>ö¿>>P@>N|>§÷6?=L? T>Øàš>Ž¢p>‹„?àŽ>ùÖ”>¸ú>°Ä?·õ?=fØ?P¡I??M>ªyh? \c?u+>8ùø> ™È>wãÈ>¬ì=n >Ù;Z>ÿ°>® Ú?ð˜?¸J?1„?'X ?2ì?B5? êW>`q„>õ”?,à.>Ø}È?H®?­Ð>Jõ=ŠÀ=ìÇ€=‚]°>h¤>L‰À>úïP?x}ô?'¾®>†ÉÐ>×Oh? 2#>hæø>õˆx?pb½?K§¢?/e3?»Ì>-Ñ>ÏZÄ?µæ>ùœ|>Â2?e‘?C¨?4(?Î2?Ó¦?!)?à>Ù"„>ý 4?Aa‹?K%_>±J>ñâ8? Šk? ´?3¦%>T3¨>|?8?'Žþ? ?oÉ?<›Ž? ì„>éÿØ>iÐ>Xœ€>ÄêÔ?5Oº>ûÎ(>ܯ?Q¦?¢"?Ј? Bº?* L?êì>šÉ$?å‘?Eâ ?à>üÚ?Ýî?)û±?[oÔ?^©?þ³? +£ë?R¼U?B\0>Çs >äÞ?5q€?FPä?&bÀ?^¿?;Y>?.ø|?5JL?Ê>ðÍ >•z>þY~?‘? +Ðÿ>ºÜ¬>÷ún?JÒi>§V=Ä >Èš”??—˜>·çX>ÄX?B£Ø?$Ù>«<@>ÀD?å?O;k?{Y‹?{½>võ€?%gš? ±<>˜þ?;¾ƒ?.Mò>š[ü= z >‚i>ª÷4=ø0=îòp>:ãœ?nÈ?vŒø?@F>/¶=•m@=É›`? +ò?Gv„>‹Ç >áè(?,×>ÔöØ>”bÂ?&¾?Gî> ?+Ò?8M)>ûUL>¡Ml>/Óè>Œ»>ÃN,?=É?fu">بì> +l?6{?8>ždø>pó?­è?P‚?èŽ>wÈ(?s>ûÙð>¥PH?!Ô°>ÌI>¹>3vÐ?$X>ûY¸>ê·´?$Ý>ÞQ>ýÕ¼?7>ט>æ;d?Ú¦?'¥2?+ŸÝ?(X?Mx©?˜ˆ>j€>Â\l?– ?4ª˜?«¦>†ð>Å9>²Åà>qQ˜>îVü>LJx>–Ý >c`>4nÌ?úu>Ðêì>Ô h?¥¤?DÂ?:3·>Ëéì>½,ì?­€>®ÀT=¿¸à>@ÆP>¦–ø>ƒÃ^?”Ï?C€Î?@-Ê>îÊ>‘?6V^?Kq-?Qto>í5L>Ìg0?Q‘V?!~?(èÑ?D#ù?ê×>ÜG¤>°>^>š? '?-½å>ìIB>¼mš?X3?f\?€?74?,?/†?1âÌ>¤ˆ>ñï¨?u‰>Ò¼d>t@>D ?2Ž?*gƒ?#…‡>áW&>³Ú?4¯–?;Á¼>ã À>Uòœ?=Ž?,´n>Ÿ ô>#>à>M¹Ü>’>Ô?"“H?r?þ?>–V>î‹°>ñS0?#îE>õ2>÷þÌ?þ?†è>ðÞÖ>x¨L>þ˜à?Ì>>àEL>®ïÄ?"0V?IE>É3†>ùÓà>ú8>“´?'è >ÝöÈ>Ñ>½ÀØ>wÁà>²}ô>Áˆà>ºú¾?*_?\ô»?!3s?i.?B^Ò?1yñ? žê?Ré0?#°?Sœ?)í>Ôgd>ȇD?+£à>ç£Ò>Ü2>gx?Ý?8l> >µæ?þÙ?ª™?~>ÿäø>Àì? êÑ>±LÈ>é¸`?Aie? +ž>Ï!ô>z‹>ÀT >ñZB>TÖ˜>W·l? A$>âÊ>éŠ ?.@?CK?n7Ì? ”¡=„ð?Æð?Hü?%ä†?8Èu?ï”>Ò#ü?/\Ž?BO?F3Þ?µø=ú\>ô/ø>øŽr>¨£€? ì>„«†=Ü;°>‰è?Ê>ù™^><–È=ËáÐ>Γ?P¯Ü? •ö>¢;x>ú‰Œ>Ìÿp?!ô?bD?;V?Döž?Kßî>ø\–>×?¼?üÍ>ñö8>·6\?"üC?˱>ÆÎÚ?X>ã£^>Ì‘,>ûH?4¦ä?)Åz>ëø>¾JX>ú»„>Û}Ê>=8>Pþ\>Ñ’ò>ó5r?Îœ?'ï!? 9¦?W¦4?r7–?ìF>þ³~?+Òâ?IÜ?KÀ´?(˜@>éËØ>¢F”>ªÞ€>ÕÄ?"¨G?E‡ü?F¡o?téb?f½?G´v>¨/L>ཤ?HWŒ?oG>Ò‰?8±U?aùq?ºn?q??qº?ö ?!`~?G÷v?”KÎ>ÍËô?ôR>ò’ +=íßp=èh>ÈkN?DT{?7A2?*Œg>ÿtÌ?É?žè>útÔ?+¸?%êí?!tª?( ?«Y>\>Î7„>­c>Ñn¾?U_> Þ¼>Üd>¿ø>Ïɘ>Èž6>t >àל>ý³ê?10?;zî?}-? +ä?T·>üÿ=Õøà>­˜8? dÁ>ïìð?2À_?_1=Émð=Ž(`? +¤?q±w?qõq?çt>¼Ýh?QÿK?ý7>"¦¬> €>ŽÕÜ>¶Ã´?"H?A á?.Ô>¤¡Ð>zôð>wÒT>•ì>œ¬ü>‹<>iB>`>õ6¼>þŽ>Ît>ççd>Á-X>?è>ó)€?Cö?@Ñj?!S¦>Î…p>HØ? h6>ÿÏ€>Ì‘Ø?W¡Ð?Q°I?åô>Qã >:õà>Í%>ù‚?,Ÿ¾?4? Þ ?tò?àï° ?+²f?XÙØ?[?[¾Ì?#€>ÃŒ?'B?h o?Gº(>½]&>óV,?:s’?L,°?g[>Â,?©®>¿zR>ë´Z?;à.?j¿?æC?#ôJ?%p?×B>´NL>¹h?ïÈ?ç>²ðT>9wH?™Ù?Ï?øÉ?^ú>¾Þp>ö R?4=?b,'?(¤ +?"¬?N">åãÀ>›ú?=„þ>þ<>:À?'¥_>Á ¤>7H>TÒ>’O°>âø¬?/Ŧ? Âv>A¡h?›?qeß?U’?hº>Ò¾h>¤Ø”>3 >x>*š„>ál>þÄ? +¦;>¢ñ@>JT=àA ?‘ý?å.=ø°>.<0? ±û?=gJ >¿H>aƒ>ò±Œ>È}> ? ܘ?,»t>·ùÆ>­AF>÷øô>KM>2–€>û}ä>¯Ä >CŒ>¥Œ\>‚a2>‚´>Õp?'øî>ÿ…Ô>”µ>õz|?±ˆ>Dz¬?#ø|?`ˆ>àËÄ>µ(´?3)c>ÿG®>†Hv>vhˆ?"Ï?P¿‡>ÆpŒ>À9X>š –>è@=ý{Ð>}¸è>Çô|> 6„=¢‹>¼Áð>æO¬>èD¨?! P?SÃõ? g>¢@x>°1,? +Œ^?]Ã&?rï»?rt—?f¡[>äÑ\>6Ùð>ÿU’?R>VÅÄ=O5`>³È?*ä ?ÿd>«î¬>8>Š~à>R>iÀL>|>„ÛÈ?†?+°/>áÓÌ>²XÜ?ô\?!¹>ób? Ý^>º²H?­}?ÁÙ>q¥¸>É}D>ËÄ>Z >Ú{è? œ¾>ƒ¬–<)í€=Zx`>´8È?O76?SŸ?W?¡>Pï?+CW?Y2e>óÛf>*ž>·W¨>ñ*Þ>’ǘ> è>õV?\Ã>ù#‚=Õß?_“>昴>ÑÒZ>εä>2‰?$˜ô?2Ô>…Ä?$ >Ïל> +\>¹Ev>€°h=ضÀ>—æä>Ì^ô>áÒ¢>£ê$>¯ ¨?@Ÿ2>ØT¼>É´À?Û>;½>¨ü˜>‹Ì>;„?q?GŒ>”k¦>X‹ ? +dÚ?ò„=ñDÀ=´>¸û¤?)G¿?UÉT?)c“>sºl? °,?jº8??*?a?+v8>ÒhÐ>Qph? ˆt?›t?³{?Wî>¼²N>z¿t?[?U=? ¦?KÝ?\!>ìG>Ž“L>ò>L?'#á?G~>î8Î>¾»(>’—P>• +ê>­Eð>ï Œ?N[?'»ß>ùÁ ?+Dº>íîH>†ˆò>£Á4>Öð?%ìþ>¾zè>²žF?YÎ?[æG>Û—l>°hœ?6èr?5å>ñ—’?Ú?'òp?1L?Ö >Ü¡Ð>él¼>*3Œ>Y"È?øô>ð7ž>Ó5 ?OÖp>í>Þžô?J`?˜È?(¶h?/´d?3ÎÄ>áR +?Í>µX>ñ£>?cE$?Kÿþ?SÂ8?t™#?K{Ÿ?Æ?/«E?,R>Ý’†>ÌãØ?1Ï? ì->ÐÃ$>³¤$? ?vc>?d¶V?Hå¦>ÓÍþ=¸²à?VK?Ž>DH>î¥&>õw>Ü# >ºçÎ>·a ?HÀ>º;Ä>ˆ«@>Ùl>ÖÙ°>Ý¥f>úÜ? z?bÊ?H"¤?q>ÚEì>ÿ0r?(«¬>áÆX?%äF?)Á>‘'Ð? -(?7„ê? 4‘>âb:>@*@>ÎZ¶?GÚÙ?d™?Woñ?$Èy> +>”'>à?—?/Õô>¬¬¨>„ù>¤Ë´>BØ\>t ? d?QwÊ?Z}K>í³¨>’ª¤?Z4>ˆ3€>Þà?ÙZ>þîŒ> ‘d=`>žÞl?3½˜?„è? B»>ÞX”>ùº?BEº?1ÏÒ?¬G>dë>„oÀ?õ¦>ñÙô>8»h>Õ³.>Ì@\?Œ<>øÉd>Ô½$?I\>ö¬>²Ö?9;?#û=?%>ÖX<>¬ýb>¬Öt?EP?kT÷>ðe0>Ãv?6án?6ÔÀ?*Ql? †÷?ZæX?)+§>õgü?eE>ãmB>ÏÈ?7Ç?D6T>Ø;|>$o0=ó)P> ˆ>Ž,>x],=ø{ >ñæx?U +?B?fyX?n>UOp>ò¸>ˤ(>+t>˹:?m >éˆÌ?ò>öÌ&>Yö¸?9(4?L“Œ?(TI?C#S?SˆØ?óz>ûÌ>­b>½ò˜?e¬?Òþ>Ȳ>óý2?K<ú? |Ä?'zï? >æ> úÌ>Ÿ-? Ó?O^">ÛØX> äà>‘ÕP?0)Õ?[…¼>ý¬P>‚´>Ï€f>6V>¸,?'{é?÷/?ÓÌ?=¹?©>Ö€>ÞTÎ?>€ž?D?"Â%?0U?­ý>ê +?2 >Û[,?%ÍÙúŽ>Úqx>Ú²¼?B%Ì?<^–?&?1‰f?å¨>!è>ž,?t0>â è?¸3>ç˜?ª‘?6{à>‘u<>ÔU¶>ã¸f>¨y°>¶$Ú>Þ®Ø?!>Ýöª>èŒ?öQ?”ˆ>ôf¸>²‰š?-¥>?>>VÜ4>–Ê>QA˜>§04>1È>ÝéZ?:Õ´?%Ï?‡?9¶?ä±?b>ÿô>ã–@>³Ä,?T”?Aà >¼SÎ<Ø|>]ó4>Ü\2>šö‚>µNŒ?óø?¨>ûZØ>²Ò¬>Óœ>Ù?TP¿>õ»¶>¿“`?(éU?= ?/O+?>¢?D~j? '‰?<½>>óN„?Y¨‰?ŽV?-7]?ˆ‘>ÊS°?\>?‹B>­c`>Ÿ.ä>&ð>ƒ¥Ä?¤µ>ûÌ–>Ó@è?gŠ>Ÿô’>èð>¶øh>¬Ì?/Êf>×ãŒ?4¢?l$>&>ƒ“´? ³Ð?k¢:? |?ÅD?B|·>™šä?–Õ?E<>én?WL?L>? +æ>HŒ<€j€>¯½X?Ss?Ø;=Ý>id”>‚™4?5 ?ñÔ?&%$?O.? â%?¯x?D~Å?,º?â?P=>óð?ùo? sÈ>–þ@>œ;,>~§Ì>¶}ð?S>ß)œ?0®?2‚Ì?¹Š?VÅX?=n¦>ó§,?A>µ(È>¸ô?G˜?:•>³œ8?>Ø? +`>¿œ>uãˆ?l?>¢’?JÑö>ùlX>g œ?]Â?‘,>óŒð>ö§²?(È>Äžx?'ÑÚ?Lý’?:P8>Ûé> ó€?)aè?7>y;œ? Îð?9û§>Úí¨>ÒC0>å@p?±°?]_’?- Ø?½?A-¼?mÓ?Lÿ0?{>‘ L>b=Ø?&þD?‘">»‡?JdÎ?6F>³F´>µ'D>Ö">€HL>yw`?_«>Ï-:>è¤P>æCÈ=£À<è×>!-D?µ™?0{?2ÿÒ?IÿÌ?ûŠ?LET?*–? 4 ?÷«>c,>.aà>( à? Ò?fÿ?S?UÛw?3w? %×?ÿq?,›?ZL>ïe =ÔÀp>`>£"?·å?Ž>Ü>Ì>«h`?Œ>òžœ>–]? °š?=ªF>²n>‚È>Ï-0>àц>Ìtš??úc?'%Ÿ>ÝU„?!n?8 ?Š:>ÃÒ>F¸>ì©>àŽ´>Ïþ˜>ÅÍÀ>ŽÈà>—EH>? ˜>ãª*>ŒÉ´>f p>ÀDÔ>›1.? ê>äÐä>„ˆ?9 +?Mº¸?(.º>Ÿÿ.=¾Ì>ªÐb?7¸¢?Kï>ò«B>ò ?TT$?](?gº;?l?P?-˜>ê_@>X! >à˜?Ë?®?^k¨>öÑ>À>ØÀÜ?]T ?nAR?+Á?,K?M-n?KÅ¡>û? >½@>ðgB? Sn>ô‰.?CÓ'?@€É?]Ž ?n½¥?<tC¨>ÃÉ–?_‚A?NHß? ëO? ?öN?$H`?ó•>„¾>T»h>k +H>…%è>ä4>¾@¸>Ë‚ ?$µð?Íì? W>ñ¬‚?'?H?\À?t?{ ¢? >¯³>…f4>®v?<0š?W½r?Gö®?4s?Z¾[?Q‘d>à¾?YH?TIç?1>âì~>¨‘è? +dp? Ž>>è7¸>S™¨>²(?SLÎ?g8P>ðL>¬x¨?JH¤?kž}?DH6>¨Kø>áO$?Lä¦?J/þ?4P‚?E]?qÂ>öÈ?-µr?5ÓÜ>í:L>"¤>ç&P?"íA?LB£?$SV>½Â¨?U>¬í,>‰3¬?êq? +|?!Ýò?eS¢?=Üø?™Y> Þê>êÌ?R–ê>ÀuØ>íŒä?7Î>×/†>ãŒØ>õvø>Ø‹">çaô?cN¶?H©Ý>­%¾>›gœ?L#?-.ø?",7?6 >·Ôò>ÀÀ®>«¢<ÖÄÀ>¡£ô>Ì{¬>†æ>¡œ?>Ê_ˆ>—}^>¡Vh>ÛaD?gFª?&%H>Š³¤? 8n?>?*y;?æh?'å?!KR?Õf?<ºZ?/Ϙ>qÕ>8AX?ž«?+8>å~l?@¶]?Wɼ?/ïx?'©p?H¸>?—?®ƒ?7›˜?†´£˜>×Ú?.¥*?f›Ž?’µ>ݨ=„ð>->JMP?%¨>à8œ=Ó? +ÏÂ?i¤ö?jM ?N[D?Vd¥?!K>Ma?èL?h'4??e¸?"§ >‰€Ú>“lò?c:>óxX?4 +?I¸?u.>¦(ô>©r&?! à?VÔ?9$? +šŒ>l è>H(Ô?"c?%„ž>ðö>Šub>ʼ¶?@e?i?@™+>ø2j>ùL>þ)Ä>ZV8>µãÀ>û1Ü?)¶¾>í_è>ò`?+ä’?V{7?AÂ>Áyè>­tž?2i?Y.?ÖÎ>Oý4?xÝ>ò£L>E¾à?$G?)3¿>µLx>Š÷N>¾$J?E.?3x¢?.±®?*‡>ÖãT>Ëèš?DÊ>™Ôœ>fLì?9‡?6>? lL? Ù\?/ph>ô¼>îkÎ?"*v? ·y?UêC?JÏt?4œÚ?N¢°?E8>ηÀ?Lr?(q?0 >>±I|>?4æh?"-€?Eþ?»>Aüð> GÐ>\”0>8 >Û›à?„T>߬?O†?AÕ? v>þ”Ü>œº>dÆ>2¼<>ÑŸV?H7Æ>â à>â&˜? °>Ñú>äÞ> +¸>ù«D?<?5Û?&¢?¾È>‘Õ>øvr?R§Íä>ù{ât>™²¼?:Ö?@|>Ü«ð¼[T€>Çex?i&?5 >¸(>ò@¬?íæ?K)>þ~? Q?9 ¯>• J>ùÁ@>ò÷˜>ñ¨>äÐ?¦á? Ø?/X>㩶>îP$?ZŽ>w"(? +ð>üT¢>;„„>ÐÎL?.q†?!í>Ý+>’óž> ¤l=P€>”P>ܽ? ^ò>çYB>._ô>$¾X>sfx>‰Ö†?$?4ã$?Jt¢?\T|>úâÌ>«p=èj@?ur?J²ä?ƒ>û¸>Í°¨>¹o`>„L¤<©F€>)>ô4H?Péh? tT>*É >ƒ¦0?–?1@>ýÔ€>‡ÃÒ>¦LÐ? t?_‹?r–\?J}ƒ>¶£Ô>Î[\? ¬?%q?…p>ÍŸÈ?$çÚ?{9?ò?€?¦?W?à>×Þz>Š‹ž>Þ”T>ŠD´>x° >~Œ`>3Ð>Š2ä>æ”X>¥ºx? +ðŽ?Q¿?V?z?ßê?)?KV>¯jZ?û?:°?`z?5ûô>¹D4>„Vœ>„X>³Ÿà>¾â^>,“`>õé$?95>Ñ•À>?Zô?/?T.Í>¹?š>®ˆ>vž>Œ†h>È”>…Ä=Ìà>–¯d>¥¬>”`>¿*>Y{Œ>”%Ð?9º? 4Ä?/ÒÌ??P ? +»@>Å´¾>ŠöÌ>­ˆò>|6`=Ž§Ð>lP ?4ž€?rÏ?;·c?Gv>ýÚˆ>¬Rô?$sv?gDæ?|L>·Z>ãÒŒ>Ïã >«Y”>‹ÓH?Ãà?[®g??¯B?8<?®â?F£?2ÂÐ>Æ¡P?Š>í{°>ß8n>úé¼>“ $>G¨¨>œO˜?#Ü>ö}>²L>éLV>—çÀ=Øt>ý(>M>”û&>¢·=Ñ`>Úvˆ?ã~>î–$>ÂBÂ>«¼?/±$?7aØ>Õx>ÒQ0?LS?>ÉÅ>÷F$? +ݺ? ?m?GB«?' Y? €Ú>š1,>{Mp>V„È>ð¦?/ƒ>n>Ž„Ô?Ñk>Á³L>’o|>ßcÔ>¢ED?0ÒG?gEh?5Ë>Í ô>Ð >­q>²–>ᦪ? ?"ª?Ö´>æ<>¥NÎ>5ä?3ñÄ?’µ>Èá¶>ðwà?öd?X^¦?ˆ2>—?4Í>ç¨>¾>-¦€>Ⱥ0?C4ý?øE>þδ>÷¹Ü>ÿH´?NÞ>Ý[>Å™˜?FQ8?äƒ>ŒgÞ>Ÿ((>Ä®?"Áº?`>Å¿:>¯ø>Cü>N>€•Ø?2ˆ?v¦ª?vC>âçv?OÊ0>Ö ,>û P?kD >ñKf>t20>´*Ø>x˜? + L?fO;?Y^h??7ñ2º>Ü3ö?€?W>á™’?7 ?< ?+6#>ÉDh>zML>¬,r?>"?kÀ¨>V“?:Î?%Ä–? µ^?4€Q?"‘¤? á»?)5^? X>`>@>ÊHô>ÆÐ?8â?kŇ?eIW?9ÂÂ?4þ€?]x’?F›á?I' +?/F ?'j?P]D>õ4L>â)4?Sš?é`>÷šP?€ß? 3l>Äñ<;Ö×>ïå >Û³ >—“$?K3ó>ø-?—U? +ÄŒ>I·ö>„uœ>Ú„8?M?$‡ê?f?%!«>‡C>î…Æ?X1?é7?%¹¼?`Y+>âm(=™? åJ?(B˜>@Up>”¿à>Ž7œ>— ? Ú²?'ËÙ?O»ú?cAà>ÊPÜ>ÿ¿¢?Of??:/?MJ>¬û^?2”? IÞ>””¬>ô?l?š5>ÃϦ>¸ŠN>R0>!>§÷? +x>ÿ9°>îš4>Û=b>¡˜¸>¨þ¬?4nV>ÿµ>lµ¨?(ýü?-¡>ës">Íód>µûh?\ž?byé?Lm>áH>U.ˆ>Òûb>¡c">Þ¤>P\`=ð +`>×[Ž?4u¶>šý >üg¨?Yó{>¹-<=Ȭ=÷Å€>ˆ»>?tè?8U.?"ÀŒ>ŽÒä>}…¨>\ú >¯Ï?°Ç>˜å€?Ù?N,%?B¥>÷ ¸>`Ì>âÍZ?$rä?Eyv?¸=>Ø;Ò>ô<>=Òˆ>‹™l>©žŒ>—8? ?PF¡?Yϳ?=Ó?$Õn? ”(?'–?? è?[ü°?.Û5? Vi?)’ä?8á|>Ù‡4=uR@>ÿ ? }? ôê? ˆ>Ó¨>VÈ>hÏ4?)Î?(¢?'ƒ8?]Š>Ó¸Æ>°Ç>õM?'Ò[?-èõ?Øÿ>©qÈ=„ €>žæ8>Üôî>ið>­ä>¢ Z>§”4?, ê>ú@>ªÝ +?Ø>Ùè>öRÔ? +’¨?('ñ?‹ˆ>s°Ð?º>ä@8>¢xŠ>ã+¬>¥ÐÆ>ö,h>Ç(p?&Ú?U §>õN˜? †? ?f?{øÐ?C™`>“ž=á¡°>©Qæ?X?15Ö?F)L>Ë¢D>˜²>âÐ> Üì>ž”˜? Ç?$8?!tÞ?õ>‰Z:>Wô>ûIú?þ>²¹´>^ü<>®Ž´>Ì9„>ÝØ?ú?LŒ?UI>ùT>†œ>ûä?LRŸ?Y·ñ?4„~? ;ì>ñ¬P>rê >šä>>Çšf>‚š8?°>ý³X=‚üà>Ëà? ‡œ>¤6H>è]®?@At?3Rí>·Ñ>œªà>ÈùV?=Ç? «¦?X>¹ø>”Z®?£¼?i’?1ô¬>õØ>ûÍ >²Wü?ª>?5è ?KX?N+Q>ãèf?ÓH?t¨T?Px¶?‘?3b>?^ÿ³?E5?E€!?".>g/l?%0?]ó?9ö÷>É}>#ô4>±  >Í^p?W?[tÈ?+Ë?'ì?c-?cåß? +¼ã>üͦ?+€?k?7*¼?Td@>àt>¬h>ÍCR?ò?]^_?Qûb>¿¢œ>QLì>’4? +@>ÅÕ?Ò ?^{? ž±>°—Ê>Cò¤>ÛPÆ>òè„>×LN>¼uÔ>§¹<>úyl>LÔ=š>ôˆ?W!ž>Ñ >ïï\?$„¾>{âä?V +?*þº?%ÿa?q!N? >ù8æ>ó€Ž>è€=‘ >¦õº?ˆÕ?›%?ZÄy?Tl>çñ¬>ƒ8=èð>3Dð>œü>,T>yó¤>üþ–>¾¤>Š ?A*?5€>ñp®?‰P?Wd…? ñª>s!€>'l=üà>ÓAœ?m;ó?[ìœ?fH?6¬?`š?&'/? 9¦>ÿ4>€î>?òÈ?غ?Q?gR?GÂÜ?C©î?"Þø? B|?.+Â?"|d?IÀ?hª>‹(t>ÎYª>à9¸?"À—?7Öµ>µÏ”>¨@>ŸÑÌ>¯ªä>0y(>ø™d?oN??Z1?)*?`E?\–.?1V>Äg,>¢PÚ>®¨„>¹Ž4>¢Â>"0=ò1€>Ñ ?…?C >ݬ>¯ ø>‡ì?) ›? ¤>ŸG†>Ìà>¯q\?r?-§Ÿ?áÊ?5k>ów¤>°å>÷à>•¸>gkð?)ÃR>ù Œ>² ?Ej?%¸ó? 1z>î^>i0>”µ>¶þV>˜†>Rû?»ÿ?<‹Ú?¯ˆ>ߌ>«rˆ=Ù<`>Ñ €?µ&>{Hì=÷0?¾Ž>öqœ>j>Q5 =êN°>ˆC¨>åGD>ãUd>V˜À>ÄØP>ïýÊ?¹¸?>äüœ>À߀?&Éî?JÐé?JѸ?u¾À?LÛ„?Kùª>ü7D<+>üº?G)²?›?!)ú?D1%?eÌ?yÐ?ÿl?)±«??*?*(>‘F8>m€ä? •b>°±Œ>â|¨¼T?«ê?ªZ>ƒW¢?˜M>ýXŽ>q§¸?*§¦?i¼?\»Ê?cض? ZÒ?áÒ?qh?8æÊ>؈V>÷+,?á? ¬5?M”*?UŸ¿>Ý9,>Ðp ?N4G?z>ãÿ°?G2>¡ÌÚ>’N>>¦:Š>x}Ì>ž­ˆ?5hn?Ò>o¸>ïüÖ>°3 ?6?d›&>ätœ=­«p>¤>t?#Äâ?[’à?ìÉ>ð¶¬?v3n?#XT>’ìÌ>ôýB? +ª\>n«°>™c8?E˜A?vƒ>ï_z>°zh?æA?$ƒÊ?;RF>Æä`>HÄ=§P0<渀>ÕÈ>ãõl>¨¡$>º’H>bšÐ>À…Ê>³ñè>Š™(>Éð8>Ü·p>s‚d>¿­Ü?SôÚ?8ð@>!ä>¿%h>é©þ?‚U?(-„?*&M>èÖn=eÖÀ=ÆÖ>“?ê›? QÖ?4*B?3ß­?°Ä?7²?Z£N?:5{?ºh?TÞ?*Úî>éÐ?#šj?µµ>h¡8>/&h>Ö*þ>‰²`>û?S(7?6Þ?7êi?!j?"‰?/ê?P&Ú?Ê|>$|h>óBŒ?W=×?O>©?h"p?Eóã?+²—?>Òâ?-·?*bÙ>³,<>18>¢Ø>­“Ä>ªžB>¶at?Í?(ÂZ?$?@Ñ>?Z-r>¼l>Û’~?+…/>Ú@:>ñ·ì? +nó>ë¹â>šDL>b©ˆ>u¢?"þ? gÑ>te€>µ60?!½5?'6H>é?Z?¬0?Pà?s‚ž?vuŽ?Aù;>¹-8=Ðp>‘p0>”ð>ãš„?2F>ªú>Ý6 ?3Æ>‘¬ú>¦Ä? á(?ù,>ÿ?‚>©i´>ñÎ?MÓV?K“š>¦;¤<ˆÐ€>pK >Èj^?¼N?JN>Îù8>³í¸?+¢Ñ?Mý>Ë„T>ÄŽ´>8[¤?ƒ\>ýwˆ={€>…°Ø>â·¢>é³Ì>ÞV”?#§©?D³?&·û?Aò–>ÎA´>µ¸L?Â?9Ât?‰?!ö©?ká?¿f>7Ö>ëy8?sz|?@Æ>²Î?.`Ò>þ?ì>ü½ ?/±æ>ÍÊ>Ø…Ü?Uˆ?Nnä>øOB>…T?\?j£º?¯F?¢>òÿ€?èŒ?>+Õ>Ñ\>þ+B?3Ò>Šy\>`0?/¢>ð@>þê|?z>Ô(?¹Y?G°? +ú÷>X&$?½Ö?42$?!}>ø”? ä?;*>þ¢@?Ã>¿^œ>HLà?ÛU>çHœ=Ïa€>$&è>•>ßÓn?²v?ò?h>} °?áZ?2á>ú2D>ÿb\?’Ñ?’J>µêh>Öl>Ÿ”>¾Ú>˜¥Ì> ¤‚?ü+>úf>G˜?t?Pÿ`>çAº?™ë?3·?&‹´>ºuˆ>ÙR?TC?·x>ÐâL?t{>édô>È„¨?6_²?%‰¤? Wu?öŽ?Э>ûV¬? H?h`c?,ëE>½F|?Œ>ÿ»>>óùF?)SZ?7¸?oÍü?üö>ð±¦?i6>é¡$>À+H>§·˜>s¸>ª1Š?˜L?+Fƒ? (? ë>ü÷¼?ÕÆ?B0?Ï«>”V>»l¼?Yü:>öf‚<íë=gÙ@=n§€>UQÜ?®Ö?8b??ïb?"€Ü?fæ?Cd‰? ¨>VÏx>Œø?:¢?zI>(Â>®×”>ò§à>YoØ>8É >ô"Ð?¤>~'ø>Æml?Wg?VY? þ>Ql>pPH>Ø?K¢?--Þ?\ ß?dc?Cœ?&‚ô>; >”‹>ø:ð>Js˜>ï€>ÁV^>xO¸>¢$ô?JÞ?!SX>À.*??Tóè?qe?y8Ú?U¸? º?:?1Ã?=ëü>¡'`>¿ÙÌ? Kc?&q‚?l>i$$=ÿoÀ>kcŒ>O |>ÝÁh? g0>"ŽP>ïû2?EÅ|?WP?f©"?'Ûã?5n?4E®?:E?3(>ÚÈŒ>„º>ù¨l>¦ì|>¡Ãà?-º?œ~>¬ R>áË ?3xn?-”ˆ>åÚ(>š4Ø>Ý>¬Å?CÐ?5v?è +>ÀÁü?8ä>Ãm>,¼ì>©i">ä˜? yw?>åKè?(…?hÊ>Ä=º?Õ>Îà*?G$>Òø >Íéê? Ê‚>úÐ(?›¼>û®Ô?EØ?"I=óxÀ>Âë`>ÌŒD>÷Eˆ?8óÉ? ? øÆ??5V>ïˆ:rp=ëOÐ>ú/°>èï>í œ?[v"?MqÝ?ó£?Ýp>”å0>×Æì>Üú¶>E9 ?Ð?Z­? Ž¢?!?Nûš?C]?ppè?tØ?-j+>[#T=Ä@>ãF>ëEZ>œj”>Ó¦´>Þ–?’Y?/Œ}?h>Ÿ?^Ú?{>ò¦P>éÅH?О>¥k>j¬>çcð?$‰›>>>ñ@?(hø?;1?Aiè? ¯À>Ý°œ?7ÁŸ>Õºì>üöÐ?=Ž>ýùˆ?3Åï? À>¢ßD>Prh>ç›^?GàÁ?FÛ<>»7º=»jp>‘À>ñÄ>ÿ‰$>vf>¿ñ >ûâ$>δ ?é6?B^e?$¦Ì>Š€®>Êêð>¹ó@>L\>‰Ô>ëH2?Y «>ùš:=Â)0>K€>ûQ¼?i Œ??¬ƒ>•õ>õ+`>Õ×>÷å?n¯?ÕR?U?Ê">f`@>‹)ø>M¿d>û(?P>Åqˆ>ï¥`>ð¶>¡Òª>¥ +T?[êè? +?º>@ˆ?%¶g?mN8?9¢É?ô×>Ÿ¦â>øpò?qkG?JA²?\ï>ý´Ì>„6®>‡úŒ>}Ô˜>´™ü>¦=Úp>³]°?)ýA?Jt?>Qñ?6¢>µ?úd?€íl?>ñô?Ac·?<Å4?&fP>Þ[ü?“?k€^?dï?@ŸÇ?FÁ4=_úÀ>8μ? ãg?Ò¸>ìb?e">³ù*?^>Ø~¤>ä¥Ä?H©&?M©œ>ôŒ>§_>æ!J?¦¼?NKÚ?BÝO>åì >ÜE°?7W? @n>̵$>¤ÑÜ>Ïã2>Î]Ä>N’? "–?!Ü>x(>{@>—Ìâ=êÓà=·>>l—X>@(>²èB>àVX>åŒP?$'í>¦ÄÒ=£÷=éð=Q<€>™åö>ÜýÌ>ý.Ì>±¦ä<°Â@>Är„?&6Ð>…j^>mÈ>ž…|>“³œ>Ö"Î?½">ºa|?éj?n©?4Çj?*1ª}Þ>¡>…íþ?%_O?*‚->h]h>Žà@?*×Öú>ͯ<>âu?1vº>ÏdÐ=©ã>Îv?O/Ô?Gáæ?/`>K-è>¹ëø?:“'?Mí6>äëÀ=·â0=üÖp>hB¨?¤~?Q¿*?r¥€?YIÒ?W9,?ZéÍ?R>Øaô>YG4>éÒl?.?Î?,û>“Ò>¬-€?.G¿?{b)?SÄ ?58’>Çç¢>óÂ? +Íá>³Ÿ¤? øž>”¼°> ;>Ö)°?CÀ²>êà\>¯#D?]”?"7Ü> *8>ó`Þ?)aF>÷ç|>ÆÕþ?²L? ‹>‚ø??ɤ?á‘>Çnº>GÒ >ÆÊ6>¬¦ì>@Ü>Þ°Ê>ÀJˆ>°Ð`?;A7?P²? Xã>P¸P>—d´? “z?Cš?Qü?GŒ?ÌX>Ë€>| °>èä?Äè>t@˜>P'°>¯cî>SÀP? Jˆ?J¯Š?=õ ?ÿç>·<„>í°?:Á*?/+ë?0èÑ>û{²>Á3Þ?"âÖ>Ç.’>¢>žU:?D£I??÷¨?êt>ûóð>Ñì>‘’>3h?Ý?\ÄÄ?5 ?ŠÈ?„ü?Òs>ìsÎ?ë¹?<`°? Id?0Ó?bYª?]¬?Š°>®ó`>l=å >Ê/?:×>8/(>©*?>bè?Q®q?F>•íŒ>Kd¸>û ?_øõ?ÜJ>‹|N>á³p?fz>âþX>ñþ„?$Zò?¸?,©@?úA?ûT?%î>“e;ý¬>Š¬˜?½ >—1¼>DÇ0?}ª?2³d>¼¥¼>|0È>ô(>áŠÈ?³‘>¤ä >a‰L>¦V>˜ºp>ë}ð?*ø?+ ¥?4-¿>éAÈ>"0P>Êx°?-/ì?'˜>¥²€>A™ð>ÆRâ?5ò5?+úû>oXˆ>ÁÉ(>Ñ?²>ûi4?<±†?Fm>í.Ô>È>Úü˜?°4>¢þ=úø>µ€¶>ØÚ?.ª?Lx?1yú? `>º‡ ?#u?eïü>ækÎ?¡p?&1#>ýj?6zÏ?%}t>Å2?ìÁ>Ô)Ü?ª?7Â*?.ò¥?+ÿ¼>?(=õe>SNL>ãÿø?Piü?ø> œ°=5ðÀ>“÷Ä?,uÃ?Uµ—?(>?IÂ?Rüæ?G¨ÿ>ijf? 7<>ûËê>? ? { >ÖEb? Ó$?Eo>¿Ó|>“ˆ?tÐ?.X>…Š>í¶|?fyƒ?Ò>¿^?/³?½>SP>æNÞ?nö? fT?‹—?$áã?N?a¸¢?BšY?9~¿>Ö¿<=ŠS>ì•¢?%[^??¹Ù?W ?Qˆ³?a¾b?-ž¼?f>Æ:„>Ò±*>Ãû6? $?kP.?7å?=Ħ?ê”>”±Ô>IK0>s0>"=L>ƒT¼>¿=D?$ |?oò?.Lð>Ö]þ>å5Ü?!S&?BbZ?Ò=?7”?1åî>Þœ>Úiì>¢Ú¦>È>8gh=g4€?ÇV>î`=w’€=ßt`>€ßx>­{ø>PïŒ>jÅð>f™>Óƒœ>Ô½ü>M±>á¤l>ðÚð>±×”?å`?,>œB>´>É2p? Xà>êr>Ó¬>ëˆ`? F?æÌ?2l>³5ê>ÉÜ?`?=Œ>ÖŒ>Ш>ðò?3]ë?Yè-?bŠv?s˜>”F>¡Ž.>–y?Iß?=ð^?8”f?B©Œ?·X>¾Ü?g~?>Eú?M|5?Mïœ?6Š>Ôš¨? °"?XwÜ>ä(Þ>¬æ>ÍÄR>dM`>/Öˆ>é)x>Ü¡˜>‰²ˆ>˜+À>"Ä€>–ƒú?%&1? OÔ>X >ÏÏ>²Š8>›"h>ê4>„„®>?ß@? Èx?8†Ì>ˆ~>Ôòž?=þ_?( ?¨¥>ôÒ°?H¦œ?%ȶ>÷rú?Tá¾?N*>°pè>¬B$>ËÂ>Ù°ä>WŒ?7¼?]0?BÁ>Á)Æ>6C?6Ö?m`ó?@™û>éÉè?,J>âMÄ>²H?ÎØ>Õ–>}P>ù³„?üP?DÑ9?hò?‚:?)§²? +;g>µÄh>Ê~">¢RÐ>Q“H>)/ø>6È>^à>‘„¤>o±>Ÿ¬?3Ñf?Q^? +«†>êø8?•>®1?.ÊD?^žM?^Bò>ý¬>¹cÈ?>at?2Ðf>Ípø>ì˜>…š?&W~>¼ *>©Z°?¿–?øW?Dã?wl²?Ðä?r¢?kâ?*À°>ÔLt?0³>ôú">²Õš?4ž>’cH>9‰@>û<Ü?.S„>Ω,>ý÷à?G³S?D£â?3?&¤§?\@?9µÜ?éâ? „‚>ú ?ä÷?+÷X>Ræà>Ÿ>¤?­?ì®?k8?«?Ø?¥L?"½ô?4QO?%ÇŽ?¼Ó>äÈ?¸?`¾?©o?÷Ä>††„>ñF~>¶,È>µO>û6Ž>×3˜>»±Æ>´v>¢é ?¾”?%5(>‹HÌ>Ê‘Š?2Çþ?15>­ˆ>ë<>þu<>ŒŠ¢?¸´?0ý0>Æx?Ì?_>«é>ªA@>$RX>?aêä>ø',? ã@?fèá? 7©>¹Á¨?)œ?3œÈ?ACŒ? +ß>ʧD>Õut? v?ZêÈ? ì;>9"Ø? ¢—?f$?+]L>n˜ >êý’? ¨Ü>í´ì?:5?Ÿ >ƒ'æ? L&?‰8>“æ´?°>ê0j>˜ÄÜ>ÿHÂ?;ñV?Z¸Ú?(lš?=ÏÒ?F„¾?-? +ú ?(@.?bÍ?â>Å4ü?6½Ì?Kh¶?0z??ó¢?Y+£?\ ¢?.ÒÐ>Òe">×Îh?Gåà>Û¥è>Ž +Ð?-ë?æ»>†BÌ>¸(<>Â^`>‚Û¨?/ˆ?0Á>†ºˆ=¨ p>ß›n?P ®?(|²?1+8?ž?xˆ?? â°?ÙY>#¯À>•ë©ä>ɵ>åÌ>¸[n>–·Ð>è>År*>ŸÓ$>´\>¸KD?B¨w´>닼?CSC?h\?;tþ>ÙWd?#“>ò]X>¹L? +¼S>ûÉ<>ÔÇT?.…?¬æ>Ds¨>¡Y¸?ÐX?XŒ@?lÆ?Gѳ>Ç4è?9ž?4á>ÿ‘ü?F¦"?Qø>Ôn >(¾4>äwâ?§J>h™P? +º¨?<ª>ù*?þå? ªñ?0'>üÈ>üò ?øî>Ÿ¸ä?4l ??Z.>¸>GíÈ?kg>ùƒ¼>²îÜ?ȶ>›>­¬þ?-*’?%ÁÄ?uî>ghÔ>&Jø>ÍB|>¥L>„Zˆ?í‡?gä>ùŸh>ä?Òã? Óü?t¯?hvj?c€=?^I>© >Ñ{>äȸ?;Þ?EÕ?z?  ?D’ ?)?,?„Ç?Ì>­X4=â’Ð?VÁ?"È@>Ñ×V?óR>ø¯Ø?TÜ?4”?+æL?cIx>달>¥ÃF>ÞŒ˜>‰à>ÃŒ?& ª?dïT?Q¾“?#¥>Â4ð?6?yîR?»Û>²¤Ê>ç¼?,ô?fz>†PN>ø(à?)óŽ?–?&>©2€>›º8>õi¨?ò(?è7>ä*”?”? +B+>m­ä=µð@>Š÷4>–Åì>sïˆ?^?7~>*q>¢šþ>·´¸?Ô“?_G??¾à>˜Ì>.¢>ˆr?"v®8B?. +?cÄ?5y&?:<=?&>·f|?]>°7`>%¸>IÙh>/ñø>1(>©•?<£,>ê>¡êÐ?=?&hr?)OÚ?4˜b>áëù­8>"ÇÀ>iY?íb?Bƒx>ÓaL>y>é‚?#¡‰?>>Ç6^>ÀóÄ?'à>§˜>ÎcV>ùN?/ì?=+|?8R?J¹Ë?@>küp>Äü‚?[Á»?Wâœ?PuÃ?jÑ?Y‰Ü?-bž>Ê÷¬>ùé>ëH4>ˆ­?K¤>éí°>¬]˜?B¹Ô?E ù?E¾?,6?û®?)6?±?'6?nód?z»ù?3g¾>ÛÂt?±T>µh>d3è?&N?HuT?M¤o?Fd?â>ýÆ`?Zø`?`D=þëÐ>žÖ´>ÄYT?Ýþ>çt‚>¸Çz?Yd€?>y+??%t?@á8?¿8?îÞ?MÊ>ÆŠ?)½ú?gŸ¶?cÌn?H¬ð?Yœ¡¼>åê`>Ó2 >êм>ÿÚ,?p?Q¯¿?+õê>—&Ô=•€=É‚P>ÔW8?Kàí?OF?Jûª?e‰?1?Yºá?Zé¨?%Æ°?1ªH?CÍÎ?6?}aù?í6>¾}$>ï$Š>Wò¤?ÃÜ? +Õ*=m÷ >ƒ¸¨>«³À=ÎöÀ>`ñÌ>ßï|?‹4?.=?ËP?d”?1¡é?ià?VŒ?ôt>ßX?D"ú?&?jU?+ž?,—õ?iX®>Òf? ?1Ä’? w8?7>õÐ?C"M?M[|>´k€>ëºt?UæB>ÔS¬=†->—x>õ>l>“À8>+ù°?*V?2ß>sÙ亠`>Q.˜?Û¸?B£È?H`“?/º„?h®>y­ ? O?#>³èð>¦ÕÔ>‹E$>¯¸>½T¬>Òa~>aàô>¤eš>ñ[0>½ ^?9ÆR? èj>Є6>âzp>¡Sœ?$Ö>Æ©>±ÀÜ>ÄV? ì?mçB?7ËÙ>…,>—a$>¦ F=ÂHP>ð‡â?@6å?Q¿ü?qèö?X;Õ?E ?j8?<†Ô?C˶>¥T¸>ÿ¿H?#F?%Ug?Ls"?EŒ>ó½(?”¢?v8f?+T‡? +v»?]¾r?'Ù^>dQx>@ À>   ?+Sà?(Ý>Ó~´>”*¨>µOD>ænŒ>ð.¦?ÚäH>2H€?¥S?Ryú?5‘“?R¯ž?lÃ>{ëX>½÷P>„ft?VŒ?£¨>Z T>€yP>G°>!—”?Ê ?TB@?PX(>Ì5Ö>õìéì=þä >¨\? ³u? Qà?ì»>ʯ\>¸>À?L±$?W +B?0'¢>¬¾ø=™@>íú`?Kz>¾b>o0>µ~l=Þ„P>†Ä˜>¬È>’ù ?+Ó?ZD‚?WbË?báº?;Ë ?e?(NÞ>˜EH>õ£œ?3Vª>æXü? }Ù>¿|r>qí„?KÒ>èÛÈ>¬êÐ?»>íu°>„U`?Y??<”å?3vä>Ð)Ä>·Äš?~&>÷æJ>§´¨>óÌ0?4í?ú>æwF>ãç>¦0’>´ÿô=IŸ >ëì?j>ˆù:>+ð>ƒH’?2ß>ôÝp=g <ÄlÀ>ï& ?DsI?²=>¶7Ê>×”¼?Dö‹?fî?fÈ>Ê?”=Üî >Ä>€ÍÚ>#g`=öã€>Áí>ïkÀ?Hu?%ùÅ>ÍÄ?(ï3?GQ$?2›r?"><{ >q>–e²>C’>L>Yd?%Ç%?8¾¥>¬6€>)]x>mÚ >ÞÆü>ðl>ðɲ?!1e?.¸?1öã?\TÊ?á„>}R>–dœ>µ"b>Áè>ELè?#À?5á.>ã Ö?8Ê?&ðp>ýZ?ør?%»>ÎÝD>¯ŒÆ?…–>Œ>y0¼?ˆØ>âŠ>:ª >rèL?ÉJ?)Jð?,íP?h^º?!ŽØ>ÏÓø>¦X„>Âè<>î^¨?.×?O=¤?(> Ó >Ö¯‚>½Lè>íü?MÕ¯?Sö?m‡'?=ÌoD¨>Æ×ü?>f>ÀG”>ð;À>ç\h>òâô?õú>†öp>±Û¬>† Ä>!jD?Þ?ã¨?þÂ?üj>ª>œ?Jž$?M?6+d?(<>Ÿ=v>Qòx>x+È>:á>šEh>þã¶?lŽ?Z´?-à‚>žÏ€?û™?"?×ú?o‡§?b>î$>³>õ^?OB?Òù? +b´?M¯?0Ùû?š†>º]l?'$æ?]P>„(²?ò?KVÞ?GÐÔ>ð >¶æ0?%Oª?^ÔD?¸M>ðà?.ç?(:?M2†?X8ð?PwP?YŒ’?:SE>È? Iî?EeÖ>Úuf>±qH?2ß?{¤?5?vo>Pø=D €=»1>¤ÏL>«‘¼>Øad?¹T?Vª>¼óÐ>¯ê¸?,>Šÿ>«d„?Ñ,?–>??çì?:.>Þ/d>(_h>=h? I">Õ>V>¹m*>Ì”>A¯p>”?Ü¢?(n¼>¸ â>…oh>}>Ö­\>®´¨?4”?jÐt?C±V>ÔLP>²Øn>ˆ[l>Ê+Œ?…>»ý\?{d?At?ù¢>Ó-H>:Bœ=ÿâÐ=ã€0>ä”`>Ô‹|>„H?ž>Ìì>ÆiÚ>†H>ßÃÄ?>&?l?õ?B?@ì>â\”>OÉ@=à•>ò©?G‚?Yõ4>ú1L>›î\>ÀQæ>»Õ€?2µº?kKt?A¼R>ÏÈ>碘>Û:¤>SXØ>;'ü>ä?yº>ÞÎ> ”>( À? h>ÔH|=hE€>£4>½·(>ñǪ?X"”?l¬±?Ct²>Ç_>ÝVd>ÜWÂ>P8>ÉýZ>åÚ>g\>̼>â? ?œ(>ò?Dµ?Z$­?v[t>ü«N>@(<>Ùƒ|? ñë?7Z ?¾>z¶€>™|>S¶À>¼~?=¸°aì?xä?¨¬>©PØ>[(>ùL¼?8Sã?›?:B´?+—€>÷ò>È‹l>ÚÏX??;?.ªÕ?/èÉ?Z,Õ? J¶>t(?9?\ ?_òÏ?OH?G?1Î^>s‚„>lK? ??i?0t²?+-~?&ô©?É|?&á?W±?=¬ ?7±ò?€#â?¯8?§Ô?_Ë‚?lƒ?Fãë?s?-Š?OФ?O%•?%s>¹:T>œÂü>ßï²>ŠL=‡€?Éh?j«%>Ëx¬>Ñ,>Ï='ûà=ëÁÀ>VÆÀ?ä›>ôŒØ>žD8>‘ÍÄ=’C`? p°?rÀâ?G§?HÒò?/|ß> ü>à”®>ÄI>ð‘,?]Þ?F©N?H­p?Uc>ýÒô>X¢Ð>"qP>Ÿc¾>ò4>ª@?ÀŒ>ÕcP>Žr$?˜&>ùÈ? º¬?[}£?/?!d¦?#­>ÌxT?4¡ú?gÿÂ?ðV>B.ä>w@?"cæ?cÇ…?Pƒ*>¾§D>êkt?J¥‹?€’>­ó>îNœ>áÒ?-?ÜÝ?$(p?I53>¼Ø@>¾‚ì>gÄ>ç«:?r~=OÏ`>ð{@?`2?F²å?E"?S­W?Z´å?Î=ž"0=?q`=‘"p? Ï{?~>7(>‡Z’? + h?>Õ°>=>ÄMœ?Ý>œ:ô>üŸ<>è@? 4?:V¤>’78>eh>op=ô×À>Ô>ˆÐ>”Ü?!C*?V?)=$>^÷¸?j‹?{ „>ùú,>›O4>ÊIè?|Æ>ðã?ÁH?'=®™p>Š?5›²>óHè<¡ÛÀ>´H?®?‚?a?–÷>ó_P?FÐ+?,Ôf>·7ô>²Š"?$õ3?|µ>Ì×@?sþ?*ù©>O,`<">Ã:°?XÕ8>ëb>ÐŒ>Ö…P>‘…d?|D?&k?\ܵ>ýg >28>ɳˆ?c>­ïD>Bà?„Ë>íšÊ>9‰ô>™xX>ÆœÎ>œ@;ï8>#â ?ïÇ>éŸ>sQx?ÊÚ?V^G?6¤º>‘NÎ>”²¨>ˆˆx=½Ð>³h?sL? Uí>ÈP>®m$>€¢ˆ>çjà?]äÖ?4«ð>Éx4>†k>xM8?s?l >÷D=å×P>‘,R>êÝÀ>Þ!r>÷øÜ>‚›l>™Ë\>Øö>=ö\¸>¢WT>™¹â>‘s”>Š­Ø>Äc ?h +„??Ì?;O?g>÷gd>ûIÜ?9 _?O¬?H´J?&›t?+?1.ç?)3Û>wð´>~>ä>±öf?%ñó?J ?+ÿ?*´>øVÆ>õé>Ç R>¦€>Ÿ§h=«ÀÐ=Ë P?¼Ž?hl@?é^?r×?'ª>Áƒ,?BÝ>Ú¤Ô>}ÌÐ?C¯?jñý>çê¬=ÿÒ°>^\=°Òà>êè>ûï´>­´ø>zº¼?tI??À>€:>¾ª>©Ø¤>ä| ? lç=Ð?¨(?_†>ù2Î?†{>ÛÑ?¬ò?KY4>åh^>G>nÇp>„ÖH>ír:>¶•l?g4>ûäú>‘aÞ?&8? +‰ü>À}j>@Ø=ºƒ=é*Ð>ˆ}²>ãmø?@.?=žp?C§­?ráO?bŽŽ?QÂÊ?d ^?_†?4Ò? Ò>ë>¶Çä>â:ä? å7?¦?¶¦?QMÖ?jöî?K¸?Iƒr? ÞŠ>9’ð?+(?B1×?%Ì°?6Œ²>¾p²?Y5?D•¼>Ä)Ø? +Å?=rR?LÅÀ?'9i>_¬>öâ>áf<>»,>º.>ó¿0?Dl÷? cÏ>Ý'>ï)Ä>½ET?¥)? gM>±,ž>Bß<Ëì€>Œ'>Ï”>y×X>›n>`\ä>å4Ú?¾h?Ó¬?Ñ>=ù? ¶¾?¨p>¯â†>ùD¨?Ü?E>Ýœ?Èn?\Ö>Ѓ>ž^Ü>ÒùÊ> ÿ¤> Øà?GÜ?$FV>ÁE>áì´?+ªÀ?îÄ>¦ ? r?»>ÅrP>¬Ñ>í.0>Ç!&=«ö0>»’?lÏ>¤«´>t‰>“àæ>–<¬>½û¼?5Œ?g´=e? öÖ?‘»>«ÿ|?>‘??&• >Ïœ¬?…:?2É?%£>Š ,>‡Š`? ø’?É>ôô.?#º4?-úí>Òâ¢>$bD>7ò¨? d?YÐï?Tw?g?Ö?“ô?Òé>ÿ=‹«à=2îÀ>´¹ô>·Ý<<Æ€>\‹À>Í ˜?op>ñZ>]b?ün?_Eä?"*?lÓ>æ‘ø>Î×¾?>  >Cx¸>ñðl?J›F?ªÌ>B?dò?ˆ“?j?J>ŒüŒ? ÀX>âª>Ô†?#ØH>‡xl? -2?«„>è1#òl>ˆ}¤>Ñ à>±Ï˜?8Ë?'‹>fó,>ah<>½3H?1<^?õûä>ÊÚJ>~@>"ßð>Ì>˜û|:w°?=`?VGh?/³\?R?têX?v¥%?y4?´>[r?¹x?¿>ç6>î>ͦØ>a¼(>aè?„å>ïÈ>´÷,?†>»”˜?jÊ?>Xz? S?K>÷[>!X?0~N?†>ãý>?_dd?"þµ?7?iÕÿ?`¬>½fH?TìR?:·>½}|>'¹H>¹z¤>æéø?¢þ?Ç›> LÌ>ë>üÃx>¹(>ô4Î>² ô>[à>‘“0>û’>±Yú> `˜>êä8?Ü>ÊrD?ƒŸ? +A?.y>ògH>yˆp?/¿x?Oûh>Á>>ÙÚ>ã 4>U×4?(ì«?(>wæ0>;>ªÔê>èüÌ?A¾ß?0?™„?%8b?NUþ?@x?>ÒÇ@>ºÜ?ú‰>ï‰&?(Ô£?V$=æ5p>iÌü>ˆ4ˆ?A@?,6>gí>”•@?=5¶??Í?ž‚>ÿÏZ>‹h >AiÐ?&?7„Ô>Ûå¬>è(à?¡&>í¤æ>,·€>;¢>é ø>à-´?çü>ëh„>­oâ?|·>éÑœ?O +?oU_?ºh>ωŽ?>ï„R>0”œ?Ú>Ò|\?µ´?`y?Ð> ­ˆ>bl˜=æÝ >öŒNx>Ô`D>äo¢=ì¿À>øÄ>Î\t>‡€?' +Ä?Oë>5Nˆ>±C >ãH >ö@?Xœ>øÝH>ð‰Ð?jª +?THä?+CÖ?>äÈ?¥{? bL>Ê€¬>݈^?â?6 +? ˜Z>à¦D?yŸ?‡M?¨r?RŸ?Aåa>¼? À'?·c?D*?ùJ=×7€>wF¬?2iå?m>»ÊØ?1/¸>ñK|>§5z>é-">]ý>,>í¹ä?!00?#Fî?Ã?ÊÑq‚>øwF?¦„?Mc?¹V>"à>„LÔ>k&>˜Óp? ‚>®¯€>ºJj?3%å?;P>y¼>é `?rÜ?Ùb?‰Ž>â¶?%£¬?@H ?2x>¢†6>YiÌ>>Žp?¾J>øÀ>ã¾ ?_Ò?[š,>ßgè>å”>ÁQ>L>§#>Î,ì?ñ>?Rƒj>Úû> ýð?/´?L´Ó?$«?…`?XV>ܳ|? ¹ú?2v>äÚ>ŸÂ>L(>Ѷ?*»ä?2•Ø? @è>-õØ?Ôž>íl>¢ö +?FrÕ?B>ã$¸?-š­?ÏÜ>üÔ?¦?2Á>ØØ$? ˆè?@_>¥«²?/üF?)Œ?®M>½ö¸?¿Î>ÉÏè=ß1 >”n.>Ü“p?N$?2}>¯Ò>•ž?%t.?HÏè>ÌH¶>m”>­,>Î?NqL?lÿú?:Þ¤?MÈ?ÆD?Ð?)g3?!IL? Ó?Qs?^v‹?l?ø?l"=­30>{(>Ú?5Ä?DÞ’?%Œ}>S“à>4»x>´Ø>•‘B>ÕÌ?TÛ>£ö¾>ö¬>Âh>Ðév?ݼ?+°>¬æ˜?7J?\SF?Žr>¢uH>¿Áø>ÓZP?â’?Â0>ÿ=l? +¤ê?;ÂÀ?Väu?T ˜?Ú‹>èsˆ?/€>ÉÚj>Õ+?4WR?Ga¨?$_†>èÂÀ?…Ò>ùçh?Ð`>Û“˜??B? ˆ>¡z>ü>ÌÏÔ>ÏQl?0¨û?;µ/>š›ô>Ùè?&ëý?—?E>¯s$>é¢?#¶(?N7?$.>O„ô> ÿŒ?‹F?1OÊ>²b>ý‡?GDÚ?Nú¸>¨v˜>›#4>½[Æ=g²À<ê‘€>O‚>V¯ ={J >ã£0?8‡2>É6ü=¸{€>þîÂ?#K¤>©®º?(:D?Jâ-?3`3?W^ö>à¬T>úÇd?·Î>–>É>€X>¨aÒ?6ù?L°l?Ö(>Ö@N>Ÿ56>…Ð?ƒ?1¬’?2\Ä>ùtü?>@?8Z>ÁÄŒ>¥Æº?¶?=K’?h£?g8?˜®? _Ì>Ò,à>¨|Ø>©Ö?á??ê&>>èc`?k‰y>ôãà>T>”·?$Hõ?d*Ë??>]>ði¼?vÓÔ?5N>¬ZT>öa¤>ÝǤ>¡Zø>wU >ÀŠ ?‡Œ?^8]?]þ½?WEz?L®ê? q¸>Ó6*>¢¬>ÊŠ^?M _?f?9Œ2?›Ç>‹@>FP>¼÷ð? +ü@>Ó$4>·Ì>µ€ê?óú?x÷A?N§?%Ï&>ÐdT>–P¾? r?TŽp>ä° >È>¾>°k >³®?3cŠ?Q™>Q²p>‡ü”?<×í?/þ‚>`†H>¨Ãô>ÀFH?0ù?"yŠ>(ô>¶;ü>¿Mh>¿Z¶?!ì?:“f>³Ô>ÙÁ¢?Uƒ4?’«>sèœ? ü¦?]?õ×>ê²>IaÌ>ÄÍÔ>_eh>ä¾Â?E‘ø>²â>t€ ?8¯¸? ·<>ì×?²Ç?Ë?Æ>À/¼?sï>÷#¬>Ÿ<?/xø?9ç¯>èPX>¬ä>—nª>Å D>¹zâ>Pý”>«8>’X>§SÔ?C=n>ÝNæ>ÿp>÷7ˆ<À@>Ð>ä>ÐÉB=½9P={>àr¨?^>ó ={Ià=N >òp(?Pà»?4d2>Ü1,>Ž Ì?0è?zìð?7{,?%º?*ìð?5ÌT?9IZ>£5f?¼Æ?j™>õ­È>%a=àh>  +D?3̦?l'r?j3ú?UÂ? +|ô>Êà?qN>¾\>ø?X?$>»f">§–À>¥ >¼ë^>æ!*>á3¶>÷„>ÉË6>ÿÔj?6E>|~x=Vë`>és„?_~Ü?KB¦?>*·>ø´p=à5Ð>k„>¨Œ?)i¦?»´>ž|?HŠ?Bê?G Ô>ÊÜT<¯.@>V{x>Ï d?5 Ê?N»ë?!†h?Z`#?¥û>[Ë>,B >%W¤?çø?›>¸8>­Ä>à?ë¨?BgÍ?9¹ ?'Š?®à>ç|>%*€>¹— >ÁS>¡£¨?‚O>ÿoX=˜P>ʹF?"1>|(P>-*Œ?"ñ>ôj¼¼VW>À‚ ?]ð>þ_~>Åäœ>ÌŠ(>‘\>Æã?Û?Æš?omt>ï•°>¨ç”?6Ni?I?7j>üÕT>Õ@¬? ÷?|î>¯>²?+Îi>ë\<‘¼€? l¨? +óÍ>»Í<>¼Ãü>Ó`,?'Û?" À?(õÇ?$÷?JWŽ>ßi<>üä>Þ?°Ï>ü·ø>½ÚP>â{(>ó~”>ö¼? ¸F>ðsô>ÌÒ>÷«¸>êXH>r,>E,?M ?ÏŸ?ÿ?/ËÎ?»Â>ÑL>ÐKP?ZB?>±?¹R>|`>…{Ä=þ»Ð>™œ?T½?t’>å¾È>^£x>-A¤>Ënø>Ë(L>M¿X? .p?`”¨?Q,?@Aü?;KŠ?«?y*?D}ž?MŽJ>äyZ>¾ ?«Ì?cE“?®>s) >M­ >Ü’’?aKù?V/5?!Jv>¼2?;V?c±î>ÝWò>žû4?"‹¤>ûó>EèP>ÌÀ?>šI?ƒP>é?šÅª>“Óâ>Öl>§ct?‹Ö?*«>x–>Å&\?+ +a?D>³…¼>\ØÔ>ý0?0“2>ò.˜>vi0>hŽ>½Ðº?HÎ?q†É? ñ÷>ÚZ>ûUz?'úì>»•¸>_ ?Mm?S°»? ¢4>ïÐ?ô¨>Œý$=½G?ÆL? ‘µ>˜±T?2ô´?l“?]f>c¸ >—èÖD>nuè>˜Ñ>—qÌ?‡Á>ä&h>ÉþJ?,RT?D,´? Ä?&]¯?VÒ>Áë@>ñ•(?¼ý? êø>þ­x?xâ>úI=ù=½€€=3€>—ÝT>ƒÊ–=«ÊÐ>öâì?b…Ê?RÛ>‹ã>öQ˜>` >Úõ°?;1Î?Gf>ŽÂ²? c@?sç‡?CsW?5‚>×Ñô>LÉp?Ï€>®ö =JÏ`>•¬?BÔ?6.š>¦ >ߦ\>õé>”“f>s³X>"Â8<èR>%ô?(*~?‚ ? ì?—ã?i†>–æä>õ>çfè?,’ä?YþM>ÆNv>h7Ü?ÑR?XŒ)?OZ>î|>ð;Æ>ÆsV>Ô>¯Ã`>ð.ì>æêà>–—ª=§]@?IÀ? _(>Ó_T??Î??Ýr?>Iˆ>Ú1Â? ²´?¤>srX>ú:´?ÃÍ?"9L?E^?Rz?@pÅ?86D?Fb>¸Ûà>o? û¾?gx(?P©V?EP4?%¹>§çX? Pu?8æ> =•ö0=ºj@>Là?’Ù?FÎ?$^'?+¿Z>Kd?®£?Áè?¶Õ>³oä>·BÊ>³â>´ÒX>Àœ>ƼÜ>)6Ô>aV>§UV?Û@?Q >Ùx >Œßb>kÎ?X?W™m?i ? ˜2>ÎÚ>×;ä>¿è?!Ç?)&A?2¯ó>ðYp?ãP?ð,>ÆC*?»ì? ¸á>ÙBü>•©¸>éi„>ˆÔ`>Mux>ñ ¤>ÇA°? Ú?Kô?ÆÚ?24\?P»?v†?ý•?_»?Wáò?5‹Í?_±ß?®©>‹+Î?>Þæ¶>|âØ?'žW?ï>dnp>ߺ>™9‚>ÉŽ? ¦>ƒÍ¼>2_P?*?ckA?<—n?G€0?-á?^€? +¯´>¶Èd>ÀOn?ÌL?/•>Öòt>‚’Ö?Á–?!H`?Ay ? h>çÜ>È,>Ž_0>¹Xü? Cí?«Š;ƒ5>°Ð?óÅ?;È?CÅÝ?<ñí?jû(?Ø>[¿ì>¹Èj?+Ô?Ö?º`?bX?g¦g?VM4?†Ž>ÿ+T?2V0?B>¬Ü> öÀ=Qã€>œ†ª>×f¬?#¹?KÀC?'{:?1Í(?eÔ?#§>©¹ø>ì—X?$Õ >ÇÛ&>Å‘°?C?4{‡?4q•?HZñ?Té˜?Jb?/\?šæ=‰PÐ>ë£h>íç>•|~>­º=§þ`=Lú >ÀâÔ?;ÿñ>á©$>™<î>ºH4>}>Òü>Ð^|=Ô>À´$?9Mš?Zª >ÿß=hš@? p?DF>ñP?'@ú?e´?=ŒÍ>ÚЮ?éï?h%Ž?#Çö>×Ì >̓ª>°îÜ>¿%Ò>¬Â>7À>§$>Ì4Ê?i?qõ¦>ÿ•h>²í~?<8S?[T\?sUÔ?&Î>vÎ>ì*>ØšÀ=Á÷À>E (?.?=Â?@"–?WIÅ?në¾?(|Ä>“ó~?RÆ>ãå=8_`>ú£Ö?l º?'»¸>àrT?&åÊ>Áxz>yôà?*’Ä?sÌ>¬‰0? ·?1Á?Ž¦>~fì>n׈>ÀšJ>VÚ=¼è€>¦²??8Z?i˜‚?²??¨?a1Ä>Þ¥:>Ðn?0É„>±Òd>÷Ù€?Zµú? ÁÃ>»‚¢?;íU?[­)?Wô>õ°è>· p>ì±> ²¸>ÕI´?QYÄ?U1? ­ä>¶ÈL>ÊU¼>òp?)ö?£b?V†?3žÚ>†¥2>òë>?>`Ç? +Ÿ?/e?:D>úé:>iɘ>ü¥¼?ëì> h>ì<>À*„>õÐÄ?fØ?lª?$üD>®Þ>ú2Š>É„ô>µãŽ>Â{t>Ä?&°? ÆÇ? ûf?TZ8?NÞJ?c&?Si? eø?KÔm?xç~>ôÀ>˜ÇL>¬·¾=‰ü€>¦? ?<û6? Bp>†ó">©Þô>ºH$?ø«??$P>Í}t=­ >¹Kš>²>¹sÈ?MGâ?Dà>¤[Ô>Û×L>Ê…> Ô¬?è>°¦D?W?&•?3§u? >ë<ô?-×?o’³?NQu?*Éb?R±¦?vS ?]C >ÏYX>üD(?Ãè?ãÀ?â­>©1à>Ò¦‚?$?>ü >ãв>^ïà=›| = ²p>Ö*>šð= × >´n?¡š>¼}f>´ü‚>–`®>IÿT>¥?Ô>˜ø¤>Ÿ ð>´AŒ?4>Ê„?Í.? +àÀ>°?#Ž?)JR>óÐ ?‚¯?]/?#”˜?l¨?J?27c?'U‡>øåø>ZP>‡¢n? +ÕJ?&aw>ãNà?üj?K}G?Nº>#͈>‰L°>ó›r>PD<&ç€?ôÐ?ãŒ>âIˆ>ïÁ>)Ý(>ÌË?.¯¾?;˜>fÛ=«=阀>1rø>Éè?<2C?Eé˜? @â>‰x>î>p?ÃH>g¾€=LJð>ŠNŒ>»@ü>SØ=e€=—y>4?†Ò?¶ >Ph??&z?n¿y?lUÓ?Heº?‹>ðó?ææ?~?ý2>ý¾‚=hOà>ô_?'ï4?+ÿ=?h?4ñ?/·?ZÐü>èÈ–>«|Ø?F}¢?j.†?€ö\?ÔÏ=}' >‹P>dߘ>Þʘ>Ôš>Ð^ ?!ì>cÝ>€Îþ?µ>¯ >.Z(>·Sl?$*H?`ŠÆ?1S?›R?çŒ? +¡­>³?„?$© ?Òà?ÑÜ?OË?fÐ>ÂV0>дˆ>Íè>~…> Œ8>›%ô?8eú?LÞ?K²:>ÌE€>5%P>°$>ü‰?\Œ”?(ª?§Ì?õÒ>¬¨?'(?@ >žP¨> ´>GïL>µzl>Ãœ>•Óh>àC€>ž>Ôºø?5kn?!ö>¶¬>ÃbZ>Ùï>¬wl>¬´Ø?yi>Ѳ >žá>È4|>™w"?&Tc?Qp ?´â>ãa?&ÓA?Ê>?$?[–E?Yóÿ?[Ù?3î>ò”?›ø>z`>[GD>èÁ”>ùÊØ?Å:?ê>•^ü>K-P>žÿÈ? ¹ð?<“¼?]ø•?B.N>Ï þ=£Ñ0>Pq>)±œ><Žð?1c?>.Õð?,T?5›?5„?X›å?1(*?5Ph?¼>œ¯È>¼­Ì?3p8?çl?£ö?U™þ?m®?bA?]Së?^’„?4k±?Ñ?##|?5·ž>Ù×r? +°ä?]ÏÄ?40? Î×?%ïl?1/T?N¥?ÓT?Šº>€4=¶Fð>¸ê>Èíü>ªC6>€>¶=6îà>{1>jØX>µ/$?[Ì?hTD?l˜j?LÜ?Jã"?SŤ>Ù>Ö>Q¤>dWà?9†?lAJ?nÉÍ?$|Û?% >üñ>íœæ>xñH>¾ûZ=¼7@?;™?,‘ö?äš>ÃU„>‚În>Á]¶>!‡œ>¥?°?ÞÖ>­Zd>K]0?Uq?N5¼>ãbª=õ½Ð>ú'à?O:>Û‰ì>ŸÁ?/ü>ÞÕà>< ,?d >ü¿n>_ëp?+10?B;??Mûf?/H>³­N>¶˜¦?Þ?dÖ?É®? Ò›?¸¿>û€R?L·@?Òh?V:?+è?Oì^?¡ü? æ>ïDR>¿p>¸×Ž=°¦€>ÈŠ?Ë?CKt?.¸>·Ç€?.nX?4¹J>Á5Ü?Ð? +^?.ü?K.>Àªè>„ÚÄ>¼éü>€œ>Ú2>ÌÈ>>3Œ?éî?"®?ù~?Rçk?‚œ>Ó]Ž>àpˆ>ßzÜ>Óž¬?5 ü>ô4Ð=øl°>ËÈx?}_?Dg?*Í?j;?qò=Ót@>­>ŽÀ>Þ+t>rUô=MM =Å +€>Ëãà?1$f? V*>ñbð>ö—H>ÄßWþ?(^?-–l?:U?jè£?'˜?c ?P=Ú?^ +¶?Äá>õ¿¤?MÆ2?F?-e¶?3à? Ú>Î(>šL>óüŒ>Ð?2­°?,´–?(´?ê?Ã?zÎ>°ŒÄ?l>úÿ? …ü?Zç?¯8?¯È?Llš?-õl?!`>ŠV¼>·$>Ƴª>Ï×*?[׌?„G>úüR?¹º>¦vP?ŽV?=8æ>ù¢x>Ù¾? ´>ö8?°ò?EÙÅ?!³ >¼v€>ï^>ðFt>Ýâ>g¯Ô>OzØ>þ¾ð?V›ƒ?S6ð>݇h>@óœ>‰¿,>·r>ÌÞ$?¨Î?\…„>ÛÀÐ>S¤˜>þrl?- R?On>ÄÎ>Ä>aOH?²Ì?ì>ŸX=9|>íŸ^?Nrû>Þî–=þô@? sf?=åV>–’X?_?,¡©?| >ât,>¶0°?ç?.z›?F>»0>äóð?x?!Œ„?*[2>ÿßn?î~? :V?2˜¥?r\?F{®?V/¹?gµ¾?Ll?ÝÄ>ü1ˆ?-d?¦þ>Õp>çUÈ?6¥>3E >»ð„?P}B?p«â? p”> (> 3ð>ÖÕ®>ˆ2>\>¡2t>õœ8>а? ?›¼?+£? 5²?j?U׈??Eä?>š^?Wh¸?7)>ÌŠæ?`??¦’? 2n>x’\>æO@??WÈ>ØÐœ?°Í>÷Îl=»¢€? ¢?Cy=?•™?:¹"?x0?.K>Ý­,>šgô>t´Ä>J >M`ä>Ä&>y,l>Œ ?+Ñ?S>Ë_–?ú¿?€t> d”> +h¸>•>’ɘ>¦€F>ï£`> ?§?\7ª?VUL>´íT>Èã?÷V? ™–?"Q`>×.‚>ì`?=ˆ?C]Å?Ð`?-Ñp?&?6*?8dð?*Þû?X: ?XIJ?u¬v? ¨X>V1p?¿N>ÎÓ6>åæÎ>¦žD>à®L?€D>szô>æ=`?iR>OJ0>×þ¼>øIx=ŠŒð>­´ ?1>ŒrŒ>+´0?ÕT>ôºV>û¢?j¿>õ'j>*¨4>Ð>ëc¸?7ÐÚ?Ô<îZ>R±> À>)q`>Á)0>¤¨^>Œâd? v>Äã€?#ñ?e³¨?n%?xd? &>øåX>Öùˆ>Ò?*p9?ˆ˜?4’ö?)>²s>çðN?N1?L9|?J®>Ьà?R¡þ?xú>ÍíP>ÃJ +='k@>§mô?:T?(É?8¡6?502?E:|?oì?2Äb>qcÐ>­aØ?>ÊEX>x1L>'À>2sØ>ˆ^º?zð>ÿ ¬>Üûv?SøÊ>îΰ>Ç®Þ?IHh? èÒ?#-f?\í>î]0?ÊÎ?$¨ >ÊÄØ>«;Ì?æF?No$?ñ>½?ª?,þ´?v7R?+>>&½ø>¹h>Ü}Z=¯” ?,†?oÃ?ÍŽ?Rm?,u–?\k)?lÆ>Ñe>õ,¨?R>š.´?Çþ?@+1>ëúx?³ü?3B>í’Ü?X’B?¨¼>ø?•\>U°>–^¼>Ÿ;–=Vpà? +î¤?2à>^ç´=Þè >€9ì>£¡>Ô‡b>ÿ`>©Å(=ðÇp>»F?”Ó>ÃÈÌ>ô¯?3‰&?P;T>Æ«„>Þ7Ê?ë >Ñ"<>Êd>µ€ì>½$L>Ps> ˆp>Ö ®? +a>ëü‚?6ý?¿ >ñG˜?FŒµ??ÉF?Q—?H%_?fY­>â>>&È?)‡Ž?K°¼>“ê>·U,>ÖBl? N6?_žr>ó>ôÒb?J4™?TÎÎ?>nx?˜Œ?Q\N?í5>^™ü?) H?Ê$>ËU?0–>ê[(>Ž¹$>—|¸>cÝè>îëP>Äþ,>SvØ>Ó©†?,;">Û²Ì>oWŒ?(VÂ?Ë0?18?3(n>ï°>™án>c¸ì>íÎ,? +À>£"Â>}J°>„,? F>ç´<Öy€>_uˆ>Þæî>‘íð>×ÇD?HÐT? +$*>KÊÄ?å÷?D¨?3?G‚‘>Õ‚ü?ˆ$?Oƒ…>Õ­>ºžD>Ϲ?À¤?WLÀ?}î>Çsà>$Nø>æ9Ü? +Z[?—}?f+a?Vï?2T>•ð¸=²þ`?Æ@? ª=ßР>÷˜œ?e ô?Mö7>ܲ >åUâ> Ù>¦Í¬?)µï>Ì<>|;ð>Ú7´?n8>ûÎÌ>ðø>–é4?S2>¬ëˆ>0Ÿ€? €?@¼¢?gª?!«…?5ߌ?n±Ú?mVp?ÞZp>ÃÒÌ?6ã ?'a$>²Pø>ê½?Kæž?ygZ?:±n?.cv?æð>Å£>øT?4Ä?3)v>§H„?¯p?Mâp?=ß2?6?š>û5Ì?ÿÎ?Ø)>g¯>Æðà?I{>É‹â>\bÈ>>ëÈ>v? ¼ç?Üè>ªôn?6¦>âOÌ>#ùh?)?X|±?–<>S!”>þs¬?³/>• ¸?$Žˆ?+€>WA¨>”Ø>ð>vq\=Ï$à=Ö5>V¥ÄÈ>Ÿnè?i’>ÿ¾(?!Sž?ObT?þV>€Ø´>@@Ø>ØŒ>¶×¾> 8>âŽ@?“Ì> P4? +ön?€>ÎBä?Râ\?C!x?´?<ºt>öìÒ?BF?HÜl?ÐÆ?EùÄ?h ?6->þ^b?&0?ªÒ>EÂà>êüÀ?Ft?•«?Iël?~º>ŽH>S\(?Ûç? +¨Ý?ðò>õ³˜>Ý»h?/µº?;‚"?nÌ>ûp¢>«ç˜?;›7?â"?m6?XA?sü“>ø^ì>±U`?+r?*“ß?;¥?'ü‘?60ë>夠>@°h>]™Ø<‘7>Χš?ÿi? +žT?*MD>¸w,>éª?µ„>º©>©ü>€€P>êìÖ?ý~>ý-¨?1,V?OT~?UBÐ?¯p?å?PÀ>܆>«ƒ >ÞÂ>Ù)à?˜?!@Ž?6ˆ?@Ük?@c>¾²>b÷˜>„²(>$è>6Tä?'þ°?ÿ‹>÷i?M¾é?I=Z?vÌ¿?/a´>Âz>Œ9@?R"?"¸E?û|?Yà!?gñ?]b?VÜ,?:º?!P?IŠ>áè¬?GÈ?4»ù>ˆt>d-h>Ùw„?,ñ‰? +–•>HÇ ?žø?F€g?Bˆ>ç +œ?1K>ò9,>Z¼ =Ì?à>­ål>†Gr<’“€>•‚>Ò&p?˶?oî~?" M>ɬ8>æ˜@?2Äù?7²>íÕ? µæ>ÏÆ>Æp>Ñ>™ð>뺨?G?.«?=e?#åä>¤Ú>ó¼?-²>Ðä>T>ó1?tä>å†>Èô>d(è>2|ð>©u¸>ãTè>ü³¤?Q&¶?<Q>‡”>QÓ>Ù=´?F?TfÙ?Ö“>chÐ>2è>¸õä>©·ð>œ©‚?»å?5¾?Ex¬?=‘ˆ?!¶’?D5>é%(>Q‹È?î?:`Â?Fa?Q?4?$"e>‹oØ>€‡ê>º„?Ûx??NP?0$?Ué?@>M×=£I@>üÆ>Â{,>¸ÇÐ?(|?{ ?Q€?¹œ>Ç4à>>ƒ4?Û–?$ ?&yX?u+˜?94>β>ÕŠ>ßx:?>¶‹?@?>Ô¨’>|ã¸>œÊÔ?,z?*© ?+…@?7í?®€?³Ä?$?†?*¬n>ë…î>ÿݨ?Ñ,>ðͨ>æÅ>U{x>¿p=ú>Ëà(>¸c´>zÃP?†>°m>•ˆ> M´>m¼Ü?=á–?@ôÁ?©Â>Á$<>ö‹>ëù\>Š±v>ðØ>ÿˆ¤??Û?dñd?´Ç>•ôø?5ÿ?1Ô9>†Æz>ãL?P“ü?IÂY?÷Ë?.Î?e“>þYH>~’¬>Ùðd>½õœ?)cñ?6wÄ?CÞL?ÿš? +C&?&\d> +˜t>­ÅÞ>Õ¤>5Ã\>¡Eô>Â>À>b½x=̯À<–ó>,Ï>æÚ¤>Öè?!Tx?J›:?.°l?@âà?î¢>çO8?rÞ?a?(L??Ñ?W?'ûì?M÷N?g|÷?&ý?#BÐ?f®??2?H ?:¸?A¯¾>©Çt>h…Ô?=P?ùM>à_,?J1þ?Hâ?ÅT?S·?‘î>£r@?!æ>ð©8>Ç>ä?ê?§·?.íî>Îc”>vx`?²7>ÀW<=ÿí>»¼? ó?=s>úÆè>”aŽ>>U8>þ´~? >œl>h`>æ¡Ô?2>Ž?"%•?1‚? >ˆp$>gfˆ>Þ¶ì>ÆÀ +>ö9Ü>îÖš?5±?ø€¼½å>³ž?XŽØ?>8]8>‹êH?Þ²? ·\?W2?:ÿ?!±ã>ì?}Â?' \>ÔâŒ>+¨>w?#~?Xª?!Qí?¾ò?Cú?UR(?2øI>Ôµx?ÓŠ?I™Ê?MB!?sÖm?ñŠ>ah>Ò²>»ª>š:¼?:ö? Ôz? [ü?FY$? *y>ù[¸?®^>ûˆ´>áÕ ?ÇÀ?_áK?(kÛ>ÕÞd>_Íp? œd?Dh*>ò"R?A;?3~«?Mj¶?qÚj?$m>J„@=ñÖ>à ´>¾À>è?ô?K.->ÄlÄ>¿0>¸­X?"x?í®?5dv?kØ?V'(>áÁÖ>Q”`>ÿœ>¯J>su°>¢DÜ?2v? ¬F>¾´’?6Î?·>ðy¬?D_¸?Êî?³ê?Wª ?j¾>º%Ø>¿4>¢*È?¿¬? —>G9Œ>ðçŒ?FB?z¸?Mÿú>õŒ¬>Ðu >²Ô>zNÔ?5®Ý?£º>ä>:à>á d>ñ >™%?QÀ?G=>¤_6>¦ž@>ö4X>y8,>ÎÃØ>®ñ°>’Ü?9¶`?Íø>®PÈ>‹àF>=Ï>¨ü0>ÍSè>•2> +Ó`>òÝÂ?Kºv?fSþ? ¤H>Æ…ä>ÿv>þ^?3”À??]Ž>ú!>ï†?O9 ?iw?IøÌ>÷Ìø>>H= >ZžØ>‹_Ø?m8?QŒl>¬D>3Q8>®¤ˆ? Ö?8[?#hm?.ã?T«¯?âÒ?Æ€?…Þ>V >Åtè?J)?€¿)?L(2?¾Ì? ›Ð>‘B¨=ÒD€>»ßà?2q0?CŒL@=;Ô@>—Òh>ìk ?Ï´?f ?$él?æ?Gh¦?T1?0>J?/£?(QŠ?\$k? y†?©Â>Ý\”>ªr˜> À?+½?U‹€?Nbö?*ú?Š2?ñö?* +I?C'ˆ?â?M>>öÀ?Ô?D%â?"h?¿L>¡©Ê?(Ì–? gÞ?Râ?N¦Ý>“<>ë??TXd?mæþ?Ê”>îq8?IK8?Jc‘?W²;?Iñ >Ë“â>5H>Œ¦,?ªj>óBô>û¾®>ÿ&Œ>Þ$>óôì>Õ”Ä?R¨Àçð>i|è>ÓÌ? 9¿>çHð?.öm?¡4>ÌÐ>ÐëÐ? ár>ø¤ö>=Ú?X?Ê‚>Réð>dØ>-P?óx?%Wð>ä‚?*Q‚?L*?O„,?n ?¨çô? $?5Çn>ô—ü>eãä=¼° =+è ?šÜ?G÷Å?Hp?CB?0R?V,\?bR2?D;ö?;r²?>‚>íN? 3<>¡¼`>3°>ÕîL?NP¾?Ð>‚«l>Èðd>Žå>ç­n?Ra?Pðˆ?+ä>Ðé°?´?@j>ÒÜ>¨(,>¶¾P?®>Ö§À?2(,?ë>ø•0?Ì.>¶å„>Ô¶>×£j? ð>³2? J?LeP?^“? >§KŽ>æ`?ö?h>œ„8>À!|??¬? 7P?:?x?I.Æ?Mo‰?ù^>ý ¼?"€¬>|„>˜n >¼äÖ>³ôö>Ùn>k,À>£™Ì>’cÔ> Úz>¾¤>Þ÷Œ?Û?(þ?5È(?8Ú?j`Ü?vn'?=;Ü>ñP´?ób?$a€>ÀÞ?ã˜>ìN>ÙþÚ?!3N>^C>³bÄ? Ú>ð^x?-\?<ê6?#~S?M)5?¢>Ò¤À?x?&yX?>Hx?j ?FêZ?±>Ð h?£>»§h>fþ˜>€%P>šÄ>ñ@Ê?3R?lìí?&,>WØ>©.ˆ?@0?QÐg?Na†>ÖáX>kUØ?²b?¤_?#y…?7ï>òKÊ>Þ,¶>¶=ô>îÈ<>Ê“À>Š•&>èåŒ?5>ìõ$>ûx€>šÉ½”h?%?jà=Ÿdð?Áœ?:¿F>óŽ|>ÐhÄ>Z*>²z²>m>ëX?÷z?Y}>㸘>pœä?’? £>ûž’?¥—?)Tß>ò0¾>â $?.ï>¦òš>3ªø>'4=Ia@?Î +>ìfv>Ùml?qä? ½,>ß—X=Œ‹ð=¤Ö>ÈÔÆ? ¢#>§rà>±+h?Í4>ë°ð>ãE,?ŠŒ>Ë“Ö?¢,?ž&>þÜ>£<Ì>©/Ä>Ù¼d>Y¦?"¡Z?uÈ?gY?yh?>Îln>Ö1p>ìgj>ŠlÊ?aï?jWR?mÙ[?iê®>éú>Û`>˜’?l+?\>Ç•˜?8î^>ÄÉ°?Ø?uŠ?->Þ¼ˆ>¹Š¨>™T?>°?# E? +a>÷µ¤?PT?o‹Ü?í|>»T? _õ?³q>Aù°>’Ø?4ßz?[ i>ãdÈ>mð°>¦Pü>Ýœ?ÿq?ï >BÑ0>è¸L?#»>ÈDü>ô|>ÆCÔ>×OH?+š@>ÝâJ>[?t=,w>Št>ÑEÜ?9í?• >mCü>±5? ¼>‡ÿh=fð>ß Œ?HBˆ?Bî>ñÖ>¦Óà>¡ë>(~à?yw?;–>Äj´>Nœ`>÷3Ü?UQ¤>â{>õæ†?2ªS? +h ?*µ?j<Â?W×£? Õ0>O,ì>Nü?³Â>¢ÿD>ýÉ>?I ¸?F·>ªÄ >Ÿ>õ—„>ýÃl>»±>ÍÔ¦>¤½Z>/IH>­¦|>ê»´>©òd?(i?DÖ”?1‰?"N>ÛÜ?*cé?`7?)þÏ?>©:>²hÔ>¬e>?*Ò{?>},?#>b?;é«?¶ù>y;|>óàÆ?Zâ?ÇÛ>¡ €?Fà?À?+‰Y?8t_?PHŸ?nQÄ?­Ð>ߟä?L´?€J?¸š?WHÛ?4V? kÙ>ºs2>Y‘ >í6?wŠ?@@(?Áè>ê,´?<‘¢?8ËF?GW?K¶°?U³ï?QJ•?Gt’>¤j„?Ñç?I ‚>í½h?7œ¸?7¡:>¾Ü¼?®ø>ê­N>î?MFÐ?@BÔ>Â|>ƒHì>¤4˜>bØ= †`>P>>ê†Ð>šä(>Í À?K%™?'Fº>sž¨>ž|®>Ñ+4>½Ì€>êÀ¬>¹Ï>ãT¤?âW?<­g?´>>Ú >ßhÜ?2E>üØ> ´>Ú +8? Ó?¯5?CÔ?æ8>Õ ˆ? Úú?¿×? +n>û[:?>T,? ?¦©?tÛL?cÝ¿?0€Š>¶ðÈ>ÆùN>¦Yº>1LP?ÎÈ?p¼U? +¶Ý>µu’>Õø>½>d>ñà@>Â3€>PÌt=@=À>…¤V>°xH=›šÐ>ýŽ?rù?a\«?&>­0þ>Ñð>ºU†>›Š<>ŽmB> +‹Ø>ù½?!A>ËO>–e†>ëL>Ã68>Ëd>¿h‚? •6?Bmj?.cŒ>ÛnP=­Åð>H P>!$€?â?Só?8Ü?QÔ +?l?M):?7‘`?¤ª>T‘¬>ÿI˜?)€>Œ­2>ˆ:T?ÓS?i>=P>Òc<>úå¦>UÚ >öKÊ?,­.?'ªÌ>ÊËR>£ ¬>à_l?$Û¤?-O >P/>M >0Õà=cà?^?BÔ>š$=y–à> A8>„ŠÈ>®sÔ?638?1Ë>NcD=úêø>‹˜8>>‘ä>†è"?8÷Ä?D"?%O¼?(Tà?C?· >¬ò>Σ¸>Õð?ìE?Z"x?6´">çt>Ц?eb>ËC"?4@?M„à?]gž?]Ê…?>F>njð?(¤?_>?æT>¤“t>§ô?3î>¡´">Ò¨?Í>ZÉ8? Z?0t\>o~ø?*?ÿÄ>ÀD°?ü?JXh?`Û#?ie?a‘`>ê >±,n>µü>˜%?àh?Dë»?o0#>üöì>[¢Ô?%BØ?W¾Þ?)ëN>·ÅÄ>ýžÔ?# +á>¸^¬>´¼(>Èþ”>Š‹è=ól =S@>.ǘ>™Mô? gC?.n`?5Í??§=þ@>ÆuÞ? +Y´?J.?9õ3?0óD>Ípx>ðä$?2…Ö>ôì2>‚õ@>µb¸?A(T>üü=d–€6X>Ajh>ů\??d ?CNW?6U)>®?*6?Ì>{o$? j(>üMP>€|>‹æ^>¢=x>V>ïóˆ?\w¨? a—>7 > E?-T”?¬=¦|>3ø?²q?W×’>½š=áÐ>Òb¸? _?7‚K?¯O? +Ÿ«?lžî>â¬0>ò° ?pqâ?itu?R~>£.Þ>ëq®>¶u>ÚÇ2>ÞFF? hÕ?¤c>~Uà>ën?88@?.´Ä>Å] > Xì?†D>Ù=|>ñ=ª?U¿e?/‰®? +ãÂ>ðQ¬>àP?OÁ~?Y¨’>úHp>½n,?Âä?Hܘ>çÆ?ÉF?FžO>™GÈ>v´ì>}î>P?À>§åŽ?‘?Qr?d? ¢‚>âö0>nÅX?3Ê?\j$?EzÓ>ó@œ>»¹*>ô:Z>HnÌ>ÓŨ>úW$>š>ƒÔ? +f?c°¾?GÔŠ?©?/2þ?S?§?Z„>¼ì=é`>Î ?%…R>ª;d>‘˜>Ïr<>Xk =°µÐ>j>!g°>L ?!`?aû>mLØ?ÑÈ?%1Ã?@1L?IKÕ>éÐ?+Ѫ?&ó¥>;oè>?H>–6Ü>Nˆð?O?D«b>ÍKü>:^ >V_€>áT?i>È«??)’@>p›>Ž (>ù†(>ÉäL>’> ??.-î? +?}ô>‚~>æäˆ>ðt¶>‚«??Š?î“? +Ü$?K$+?;o&>ä[à>ÔÌ?'+«>ÜÎ>é??_zQ?vNÓ?;t?¸ê?@²ˆ?H|V?`>½30>õÓœ?,‹>”9¬>®8>€(>Ï_L? é”?…X?=õd?7Ä?Fäª?;‡ ?5¢?H?`Á¾?Xz?Dœœ>Åá†>6(>ob@>A¸>WRÈ?2?>å>XOø>|,?g‹?:æâ?¹x?,6`>òþ>îhÒ>ô¶=¸Ð>óQÆ?Sà? i%?Nš?aû|? —®>Q >À˜?º¥> b$?úø? Â?q¿?|Ô?2 [?´*?a?Bª?$…?ºM?…=?.{H>Ñ>5>ðIü>ÁZT=&à=]À>¼äŒ?7 +? Ö>âSÔ=xÂ@?À>ðñl>"¬À>½õä>bT$>kH?Hò?S'j? ±b>ÇB†?@V ??Ù>î[¨>­¤4>à(À?=Æ|?hx>¿X>Íæl>†šL>¡n>Ã=˜?Öì?-ÿ?ÔÜ?kÅ?>Ü%?AÅ>°ñÖ>¹ðÃ\?ç\?9”F>ÇóÆ?bp?â?Ç;?(A>¯sD>ÿÍš?d>Ç«p>¥„˜>ÂH>”>t>mà?5í?]Í?D°r>â—Ò>¦/V>ð·ê>Æ•?tw?`€?m+Õ? ð:>“…Œ>ã:ö>§òÜ>Øfn?è¬?#”ˆ?(m‹>æ:l?(³Ê?4vq?6è”?j< +>ᢖ>¢â? ž?>þ*F>éºÈ?41Ð?8ŠÌ?&/î>ªT¤>Ò>겸>F»È? ?4>Ø l>ï >>…þð?ÛJ?c¨ ?Gi>½[T?·€?åÚ>‘>P>·á?¥?8Ð>¯ÃÊ?F@\?êM>cú >Ä.¸>ÊxF?a+>Ëc¤? ×?Pµ? óµ>ü§²>Ä‘ ? cb?Rn(?E*®? ÛO?‡œ>ööè>¸hº?U®?$4Ê?qNñ?µh?+×?rÒÖ?ôµ=]y@>•m?q?&#Ø?$/>ãþŒ?™r??áP>úEö>šø>Ñýv>’.Z>ê™>ð>•¡D>1•Ø>½¨?À?\9P?.ÁÉ>]*X>mrh?ÊÂ?Ô)>ïWÔ>ÜÖÄ>âøL?È5ä>7ìè>_Æ >>í ?‘8?8±>wF>`4€?5a>çÎT>¦½p?9dN?›æ?VC?Pve?Vª¤? >Ä!Ì?+A`?;Ç?!½#?g„?*ì?Fmé?t7i>ûp$>(U˜>Úœ>³”D> ˆø?{2?Áœ>ºb?6u>?¿a>ʆ?[Œ>P<>¤8?(¾>·6d>6h¸>õdL?Eàz? $>jp>*:0>Bè>ž]ä>ƽV>Þ^b>Ã^\?¿î?"ÃÐ?#»í?~5>Œ‘Ø>ΗÜ>èi€>Äq(>½F>§t>?&¦?TÊì>Îu=É@>­¨?›Ì>Î5|>£J$? +ûº>ч? 3?!™ú>fh>›B€?@δ?-·¤>‡F¬>ìà?-ÚL?03m?T,”>ïfÌ>°Ûø>Š€$>…8f?f?8n?PéZ?=|>ðªÄ>sÁ>p¶¼>(>ïë ?…*>™IŠ?‘D?@؇?RØ?û8?2íd>¡Ò|> Ž?X?Cù> +ïÜ>‰MX>ru€>‰î>¥þP>ÎOÄ?o¸?óE>œ“=ÛP0>kÎÌ>ÊgÈ?1[—?@„ö?6þ›?cb4?P|? 0?2V³?Út>—&v>‹Æ? Ý?okK?mÈp?;1@>š%ú>ÄDä?AÀ*?L Ô?Jžj?®Ÿ>¹ ¸?(ãr>éà=jœÀ>Gu>ÍO>u$>»Ñ,??ð„?!ý>{›h>Ðe²?pX?(«§?Ø>}Oh>­`?4?"²{?(µH>Ò²t>°Ð˜?¡_?,¢Û?OV¬?iÚâ?Ì÷? ‰ä>×k"=² >½ÖÀ?Mâz?U¦å>Èœ>G¯X?u?KaÓ? ¼?a¨?#Æ`>«>KÈ?i¸?nÏX?X"->±¡´»‰¯?‰’?ÿ’? +L?ûª>Î ´?:L˜?&`? ö:?bÖ¢?dˆÒ?ïÌ?P¼>ðßþ>öÈ@?b£z?;ÿ,>¤äd>­²ê? +>b?[ù>¦”>á 2? $?"°Ô>ù˜Œ>ø >ëÁ8>úaŽ>ŽW¤>" =¿À>/î8?-ª?9™@?)™@?ž>ad?ð?\7r?R»>*zÀ>Çæ>ìð8>(D°=ƒç€>Þ(?b±i?I/?@z?þ>=®™ ?sh?¿ +>Ï®Ü?]k?vìú?wUŒ?N¯H?.êB>ìf€=ß +>—™4>—ïP>ŠŠì> ç¢>'ÑÜ>÷äÖ>¹Á„>,4Ð>i`? Ϧ?C˼?4T>Âiø=¢DP>õ¯À?‡§?›€>õ_>Ž9€?g¢>ô?È>„­>î—È?Î?,ÆÐ?RŸ'?IEÛ?Y7ú?6¥©>ãš>±yÔ>ÐE8>-ƒÀ?ŠÎ?="?kÚ?>d‚?^lP?Ò»>ò\4?&Ýv>÷À>Y28=ŽOÀ?O?/v?5ƒ?!Ó?  ~?p?&˜)?–?uã ?i=??—&?Oc“?{Ûo?¾ú>íL?4Où?4n¬?>WX>úd>&l0=JwÀ(32768,1,1,1) Ta FREQ-OBSAÔæHÊ1™˜@РÀ†Z ÀRA @\HUž&GDEC @AŸ«=¤ƒÿúMichael Fanelli unknown ˜OnOff:PSWITCHON:TPWCAL Rcvr1_2 ?÷HYÀOPTI-HEL@ÍÐ2Y™òAÔæHÊ1™˜@䎼åŠk@qß9T6Yà@E á< ²Š@pæf`@…ÁÔûï?î^5@AÕ*jýìÌÍAÕ*jýìÌÍ@†Z À@Ÿ@FK5 @\33333@Ažø + Date: Thu, 10 Oct 2024 11:10:23 -0400 Subject: [PATCH 32/95] Refactor: code used to shift spectra now lives in spectra.core --- src/dysh/spectra/core.py | 118 +++++++++++++++++++++++- src/dysh/spectra/scan.py | 35 +------ src/dysh/spectra/spectrum.py | 23 +---- src/dysh/spectra/tests/test_spectrum.py | 2 +- testdata/gshift_box.fits | 2 +- 5 files changed, 126 insertions(+), 54 deletions(-) diff --git a/src/dysh/spectra/core.py b/src/dysh/spectra/core.py index a32668b0..cfb35bec 100644 --- a/src/dysh/spectra/core.py +++ b/src/dysh/spectra/core.py @@ -3,6 +3,7 @@ """ import warnings +from copy import deepcopy import astropy.units as u import numpy as np @@ -14,11 +15,12 @@ ) from astropy.modeling.fitting import LinearLSQFitter from astropy.modeling.polynomial import Chebyshev1D, Hermite1D, Legendre1D, Polynomial1D +from scipy import ndimage from specutils import SpectralRegion from specutils.fitting import fit_continuum from ..coordinates import veltofreq -from ..log import log_function_call +from ..log import log_function_call, logger from ..util import minimum_string_match, powerof2 @@ -680,3 +682,117 @@ def smooth(data, method="hanning", width=1, kernel=None, show=False): # the boundary='extend' matches GBTIDL's /edge_truncate CONVOL() method new_data = convolve(data, kernel, boundary="extend") return new_data + + +def data_ishift(y, ishift, axis=-1, remove_wrap=True, fill_value=np.nan): + """ + Shift `y` by `ishift` channels, where `ishift` is a natural number. + + Parameters + ---------- + y : array + Data to be shifted. + ishift : int + Amount to shift data by. + axis : int + Axis along which to apply the shift. + remove_wrap : bool + Replace channels that wrap around with `fill_value`. + fill_value : float + Value used to replace the data in channels that wrap around after the shift. + + Returns + ------- + new_y : array + Shifted `y`. + """ + + new_y = np.roll(y, ishift, axis=axis) + + if remove_wrap: + if ishift < 0: + new_y[ishift:] = fill_value + else: + new_y[:ishift] = fill_value + + return new_y + + +def data_fshift(y, fshift, method="fft", pad=False, window=True): + """ + Shift `y` by `fshift` channels, where |`fshift`|<1. + + Parameters + ---------- + y : array + Data to be shifted. + fshift : float + Amount to shift the data by. + abs(fshift) must be less than 1. + method : "fft" | "interpolate" + Method to use for shifting. + "fft" uses a phase shift. + "interpolate" uses `scipy.ndimage.shift`. + pad : bool + Pad the data during the phase shift. + Only used if `method="fft"`. + window : bool + Apply a Welch window during phase shift. + Only used if `method="fft"`. + """ + + if abs(fshift) > 1: + raise ValueError("abs(fshift) must be less than one: {fshift}") + + if method == "fft": + new_y = fft_shift(y, fshift, pad=pad, window=window) + elif method == "interpolate": + new_y = ndimage.shift(y, [fshift]) + + return new_y + + +def data_shift(y, s, axis=-1, remove_wrap=True, fill_value=np.nan, method="fft", pad=False, window=True): + """ + Shift `y` by `s` channels. + + Parameters + ---------- + y : array + Data to be shifted. + s : float + Amount to shift the data by. + axis : int + Axis along which to apply the shift. + remove_wrap : bool + Replace channels that wrap around with `fill_value`. + fill_value : float + Value used to replace the data in channels that wrap around after the shift. + method : "fft" | "interpolate" + Method to use for shifting. + "fft" uses a phase shift. + "interpolate" uses `scipy.ndimage.shift`. + pad : bool + Pad the data during the phase shift. + Only used if `method="fft"`. + window : bool + Apply a Welch window during phase shift. + Only used if `method="fft"`. + """ + + ishift = int(np.round(s)) # Integer shift. + fshift = s - ishift # Fractional shift. + + logger.debug(f"Shift: s={s} ishift={ishift} fshift={fshift}") + + if ishift != 0: + # Apply integer shift. + y_new = data_ishift(y, ishift, axis=axis, remove_wrap=remove_wrap, fill_value=fill_value) + else: + y_new = deepcopy(y) + + if fshift != 0: + # Apply fractional shift. + y_new = data_fshift(y_new, fshift, method=method, pad=pad, window=window) + + return y_new diff --git a/src/dysh/spectra/scan.py b/src/dysh/spectra/scan.py index 77ba6b36..1bdb7903 100644 --- a/src/dysh/spectra/scan.py +++ b/src/dysh/spectra/scan.py @@ -11,7 +11,6 @@ from astropy import constants as ac from astropy.io.fits import BinTableHDU, Column from astropy.table import Table, vstack -from scipy import ndimage from dysh.spectra import core @@ -28,11 +27,6 @@ ) from .spectrum import Spectrum -# from typing import Literal - - -# from astropy.coordinates.spectral_coordinate import NoVelocityWarning - class SpectralAverageMixin: @log_call_to_history @@ -1659,37 +1653,12 @@ def do_fold(sig, ref, sig_freq, ref_freq, remove_wrap=False, shift_method="fft") """ """ chan_shift = (sig_freq[0] - ref_freq[0]) / np.abs(np.diff(sig_freq)).mean() logger.debug(f"do_fold: {sig_freq[0]}, {ref_freq[0]},{chan_shift}") - ref_shift = do_shift(ref, chan_shift, remove_wrap=remove_wrap, method=shift_method) + # ref_shift = do_shift(ref, chan_shift, remove_wrap=remove_wrap, method=shift_method) + ref_shift = core.data_shift(ref, chan_shift, remove_wrap=remove_wrap, method=shift_method) # @todo weights avg = (sig + ref_shift) / 2 return avg - def do_shift(data, offset, remove_wrap=False, method="fft"): - """ - Shift the data of a numpy array using roll/shift - - @todo use the fancier GBTIDL fft based shift - """ - - ishift = int(np.round(offset)) # Integer shift. - fshift = offset - ishift # Fractional shift. - - logger.debug("FOLD: {ishift=} {fshift=}") - data2 = np.roll(data, ishift, axis=0) - if remove_wrap: - if ishift < 0: - data2[ishift:] = np.nan - else: - data2[:ishift] = np.nan - # Now the fractional shift, each row separate since ndimage.shift() cannot deal with np.nan - if method == "fft": - # Set `pad=False` to avoid edge effects. - # This needs to be sorted out. - data2 = fft_shift(data2, fshift, pad=False) - elif method == "interpolate": - data2 = ndimage.shift(data2, [fshift]) - return data2 - kwargs_opts = {"verbose": False} kwargs_opts.update(kwargs) _fold = kwargs.get("fold", False) diff --git a/src/dysh/spectra/spectrum.py b/src/dysh/spectra/spectrum.py index d1956a53..a0996cb2 100644 --- a/src/dysh/spectra/spectrum.py +++ b/src/dysh/spectra/spectrum.py @@ -37,7 +37,7 @@ from ..log import HistoricalBase, log_call_to_history from ..plot import specplot as sp from ..util import minimum_string_match -from . import baseline, fft_shift, get_spectral_equivalency +from . import baseline, get_spectral_equivalency # from astropy.nddata import StdDevUncertainty @@ -524,7 +524,7 @@ def smooth(self, method="hanning", width=1, decimate=0, kernel=None): return s - def shift(self, s, wrap=False, fill_value=np.nan, method="fft"): + def shift(self, s, remove_wrap=False, fill_value=np.nan, method="fft"): """ Shift the `Spectrum` by `s` channels in place. @@ -542,29 +542,16 @@ def shift(self, s, wrap=False, fill_value=np.nan, method="fft"): "fft" uses a phase shift. """ - ishift = int(np.round(s)) # Integer shift. - fshift = s - ishift # Fractional shift. - # Apply integer shift. - new_data = np.roll(self.data, ishift, axis=0) - if not wrap: - if ishift < 0: - new_data[ishift:] = fill_value - else: - new_data[:ishift] = fill_value - - if fshift != 0: - # Apply fractional shift. - new_data = fft_shift(new_data, fshift, pad=False, window=True) + new_data = core.data_shift(self.data, s, remove_wrap=remove_wrap, fill_value=fill_value, method=method) # Update data values. self._data = new_data # Update metadata. - applied_shift = ishift + fshift - self.meta["CRPIX1"] += applied_shift + self.meta["CRPIX1"] += s # Update WCS. - self.wcs.wcs.crpix[0] += applied_shift + self.wcs.wcs.crpix[0] += s # Update `SpectralAxis` values. new_spectral_axis_values = self.wcs.spectral.pixel_to_world(np.arange(self.flux.shape[-1])) diff --git a/src/dysh/spectra/tests/test_spectrum.py b/src/dysh/spectra/tests/test_spectrum.py index 0610dd8d..dfbe4a17 100644 --- a/src/dysh/spectra/tests/test_spectrum.py +++ b/src/dysh/spectra/tests/test_spectrum.py @@ -420,7 +420,7 @@ def test_shift(self): # Compare. # Ignore the edge channels to avoid edge effects. diff = (spec.data - gbtidl)[10:-10] - assert np.all(abs(diff) < 1e-4) + assert np.all(abs(diff) < 5e-4) assert spec.meta["CRPIX1"] == org_spec.meta["CRPIX1"] + shift assert spec.spectral_axis[0].to("Hz").value == ( diff --git a/testdata/gshift_box.fits b/testdata/gshift_box.fits index 58f676e5..ae24d1de 100644 --- a/testdata/gshift_box.fits +++ b/testdata/gshift_box.fits @@ -1,4 +1,4 @@ -SIMPLE = T /Written by IDL: Wed Oct 9 21:23:56 2024 BITPIX = 8 / NAXIS = 0 / EXTEND = T /File contains extensions DATE = '2024-10-10' / ORIGIN = 'NRAO Green Bank' /origin of observation TELESCOP= 'NRAO_GBT' /the telescope used GUIDEVER= 'GBTIDL ver2.10.1' /this file was created by gbtidl FITSVER = '1.9 ' /FITS definition version END XTENSION= 'BINTABLE' /Binary table written by MWRFITS v1.13 BITPIX = 8 /Required value NAXIS = 2 /Required value NAXIS1 = 131834 /Number of bytes per row NAXIS2 = 1 /Number of rows PCOUNT = 0 /Normally 0 (no varying arrays) GCOUNT = 1 /Required value TFIELDS = 83 /Number of columns in table COMMENT COMMENT *** End of mandatory fields *** COMMENT EXTNAME = 'SINGLE DISH' CTYPE4 = 'STOKES ' COMMENT COMMENT *** Column names *** COMMENT TTYPE1 = 'OBJECT ' / TTYPE2 = 'BANDWID ' / TTYPE3 = 'DATE-OBS' / TTYPE4 = 'DURATION' / TTYPE5 = 'EXPOSURE' / TTYPE6 = 'TSYS ' / TTYPE7 = 'DATA ' / TTYPE8 = 'TDIM7 ' / TTYPE9 = 'TUNIT7 ' / TTYPE10 = 'CTYPE1 ' / TTYPE11 = 'CRVAL1 ' / TTYPE12 = 'CRPIX1 ' / TTYPE13 = 'CDELT1 ' / TTYPE14 = 'CTYPE2 ' / TTYPE15 = 'CRVAL2 ' / TTYPE16 = 'CTYPE3 ' / TTYPE17 = 'CRVAL3 ' / TTYPE18 = 'CRVAL4 ' / TTYPE19 = 'OBSERVER' / TTYPE20 = 'OBSID ' / TTYPE21 = 'SCAN ' / TTYPE22 = 'OBSMODE ' / TTYPE23 = 'FRONTEND' / TTYPE24 = 'TCAL ' / TTYPE25 = 'VELDEF ' / TTYPE26 = 'VFRAME ' / TTYPE27 = 'RVSYS ' / TTYPE28 = 'OBSFREQ ' / TTYPE29 = 'LST ' / TTYPE30 = 'AZIMUTH ' / TTYPE31 = 'ELEVATIO' / TTYPE32 = 'TAMBIENT' / TTYPE33 = 'PRESSURE' / TTYPE34 = 'HUMIDITY' / TTYPE35 = 'RESTFREQ' / TTYPE36 = 'DOPFREQ ' / TTYPE37 = 'FREQRES ' / TTYPE38 = 'EQUINOX ' / TTYPE39 = 'RADESYS ' / TTYPE40 = 'TRGTLONG' / TTYPE41 = 'TRGTLAT ' / TTYPE42 = 'SAMPLER ' / TTYPE43 = 'FEED ' / TTYPE44 = 'SRFEED ' / TTYPE45 = 'FEEDXOFF' / TTYPE46 = 'FEEDEOFF' / TTYPE47 = 'SUBREF_STATE' / TTYPE48 = 'SIDEBAND' / TTYPE49 = 'PROCSEQN' / TTYPE50 = 'PROCSIZE' / TTYPE51 = 'PROCSCAN' / TTYPE52 = 'PROCTYPE' / TTYPE53 = 'LASTON ' / TTYPE54 = 'LASTOFF ' / TTYPE55 = 'TIMESTAMP' / TTYPE56 = 'QD_XEL ' / TTYPE57 = 'QD_EL ' / TTYPE58 = 'QD_BAD ' / TTYPE59 = 'QD_METHOD' / TTYPE60 = 'VELOCITY' / TTYPE61 = 'FOFFREF1' / TTYPE62 = 'ZEROCHAN' / TTYPE63 = 'ADCSAMPF' / TTYPE64 = 'VSPDELT ' / TTYPE65 = 'VSPRVAL ' / TTYPE66 = 'VSPRPIX ' / TTYPE67 = 'SIG ' / TTYPE68 = 'CAL ' / TTYPE69 = 'CALTYPE ' / TTYPE70 = 'TWARM ' / TTYPE71 = 'TCOLD ' / TTYPE72 = 'CALPOSITION' / TTYPE73 = 'BACKEND ' / TTYPE74 = 'PROJID ' / TTYPE75 = 'TELESCOP' / TTYPE76 = 'SITELONG' / TTYPE77 = 'SITELAT ' / TTYPE78 = 'SITEELEV' / TTYPE79 = 'IFNUM ' / TTYPE80 = 'PLNUM ' / TTYPE81 = 'FDNUM ' / TTYPE82 = 'INT ' / TTYPE83 = 'NSAVE ' / COMMENT COMMENT *** Column formats *** COMMENT TFORM1 = '32A ' / TFORM2 = 'D ' / TFORM3 = '22A ' / TFORM4 = 'D ' / TFORM5 = 'D ' / TFORM6 = 'D ' / TFORM7 = '32768E ' / TFORM8 = '16A ' / TFORM9 = '6A ' / TFORM10 = '8A ' / TFORM11 = 'D ' / TFORM12 = 'D ' / TFORM13 = 'D ' / TFORM14 = '4A ' / TFORM15 = 'D ' / TFORM16 = '4A ' / TFORM17 = 'D ' / TFORM18 = 'I ' / TFORM19 = '32A ' / TFORM20 = '32A ' / TFORM21 = 'J ' / TFORM22 = '32A ' / TFORM23 = '16A ' / TFORM24 = 'D ' / TFORM25 = '8A ' / TFORM26 = 'D ' / TFORM27 = 'D ' / TFORM28 = 'D ' / TFORM29 = 'D ' / TFORM30 = 'D ' / TFORM31 = 'D ' / TFORM32 = 'D ' / TFORM33 = 'D ' / TFORM34 = 'D ' / TFORM35 = 'D ' / TFORM36 = 'D ' / TFORM37 = 'D ' / TFORM38 = 'D ' / TFORM39 = '8A ' / TFORM40 = 'D ' / TFORM41 = 'D ' / TFORM42 = '8A ' / TFORM43 = 'I ' / TFORM44 = 'I ' / TFORM45 = 'D ' / TFORM46 = 'D ' / TFORM47 = 'I ' / TFORM48 = 'A ' / TFORM49 = 'I ' / TFORM50 = 'I ' / TFORM51 = '16A ' / TFORM52 = '16A ' / TFORM53 = 'J ' / TFORM54 = 'J ' / TFORM55 = '22A ' / TFORM56 = 'D ' / TFORM57 = 'D ' / TFORM58 = 'I ' / TFORM59 = 'A ' / TFORM60 = 'D ' / TFORM61 = 'D ' / TFORM62 = 'E ' / TFORM63 = 'D ' / TFORM64 = 'D ' / TFORM65 = 'D ' / TFORM66 = 'D ' / TFORM67 = 'A ' / TFORM68 = 'A ' / TFORM69 = '8A ' / TFORM70 = 'E ' / TFORM71 = 'E ' / TFORM72 = '16A ' / TFORM73 = '32A ' / TFORM74 = '32A ' / TFORM75 = '32A ' / TFORM76 = 'D ' / TFORM77 = 'D ' / TFORM78 = 'D ' / TFORM79 = 'I ' / TFORM80 = 'I ' / TFORM81 = 'I ' / TFORM82 = 'J ' / TFORM83 = 'J ' / END NGC2415 AvZ À2021-02-10T07:38:37.50@õ6à@eO`@10ràÀÀÀÀÀÀ?@ÅÔ? ê? +SIMPLE = T /Written by IDL: Thu Oct 10 10:23:24 2024 BITPIX = 8 / NAXIS = 0 / EXTEND = T /File contains extensions DATE = '2024-10-10' / ORIGIN = 'NRAO Green Bank' /origin of observation TELESCOP= 'NRAO_GBT' /the telescope used GUIDEVER= 'GBTIDL ver2.10.1' /this file was created by gbtidl FITSVER = '1.9 ' /FITS definition version END XTENSION= 'BINTABLE' /Binary table written by MWRFITS v1.13 BITPIX = 8 /Required value NAXIS = 2 /Required value NAXIS1 = 131834 /Number of bytes per row NAXIS2 = 1 /Number of rows PCOUNT = 0 /Normally 0 (no varying arrays) GCOUNT = 1 /Required value TFIELDS = 83 /Number of columns in table COMMENT COMMENT *** End of mandatory fields *** COMMENT EXTNAME = 'SINGLE DISH' CTYPE4 = 'STOKES ' COMMENT COMMENT *** Column names *** COMMENT TTYPE1 = 'OBJECT ' / TTYPE2 = 'BANDWID ' / TTYPE3 = 'DATE-OBS' / TTYPE4 = 'DURATION' / TTYPE5 = 'EXPOSURE' / TTYPE6 = 'TSYS ' / TTYPE7 = 'DATA ' / TTYPE8 = 'TDIM7 ' / TTYPE9 = 'TUNIT7 ' / TTYPE10 = 'CTYPE1 ' / TTYPE11 = 'CRVAL1 ' / TTYPE12 = 'CRPIX1 ' / TTYPE13 = 'CDELT1 ' / TTYPE14 = 'CTYPE2 ' / TTYPE15 = 'CRVAL2 ' / TTYPE16 = 'CTYPE3 ' / TTYPE17 = 'CRVAL3 ' / TTYPE18 = 'CRVAL4 ' / TTYPE19 = 'OBSERVER' / TTYPE20 = 'OBSID ' / TTYPE21 = 'SCAN ' / TTYPE22 = 'OBSMODE ' / TTYPE23 = 'FRONTEND' / TTYPE24 = 'TCAL ' / TTYPE25 = 'VELDEF ' / TTYPE26 = 'VFRAME ' / TTYPE27 = 'RVSYS ' / TTYPE28 = 'OBSFREQ ' / TTYPE29 = 'LST ' / TTYPE30 = 'AZIMUTH ' / TTYPE31 = 'ELEVATIO' / TTYPE32 = 'TAMBIENT' / TTYPE33 = 'PRESSURE' / TTYPE34 = 'HUMIDITY' / TTYPE35 = 'RESTFREQ' / TTYPE36 = 'DOPFREQ ' / TTYPE37 = 'FREQRES ' / TTYPE38 = 'EQUINOX ' / TTYPE39 = 'RADESYS ' / TTYPE40 = 'TRGTLONG' / TTYPE41 = 'TRGTLAT ' / TTYPE42 = 'SAMPLER ' / TTYPE43 = 'FEED ' / TTYPE44 = 'SRFEED ' / TTYPE45 = 'FEEDXOFF' / TTYPE46 = 'FEEDEOFF' / TTYPE47 = 'SUBREF_STATE' / TTYPE48 = 'SIDEBAND' / TTYPE49 = 'PROCSEQN' / TTYPE50 = 'PROCSIZE' / TTYPE51 = 'PROCSCAN' / TTYPE52 = 'PROCTYPE' / TTYPE53 = 'LASTON ' / TTYPE54 = 'LASTOFF ' / TTYPE55 = 'TIMESTAMP' / TTYPE56 = 'QD_XEL ' / TTYPE57 = 'QD_EL ' / TTYPE58 = 'QD_BAD ' / TTYPE59 = 'QD_METHOD' / TTYPE60 = 'VELOCITY' / TTYPE61 = 'FOFFREF1' / TTYPE62 = 'ZEROCHAN' / TTYPE63 = 'ADCSAMPF' / TTYPE64 = 'VSPDELT ' / TTYPE65 = 'VSPRVAL ' / TTYPE66 = 'VSPRPIX ' / TTYPE67 = 'SIG ' / TTYPE68 = 'CAL ' / TTYPE69 = 'CALTYPE ' / TTYPE70 = 'TWARM ' / TTYPE71 = 'TCOLD ' / TTYPE72 = 'CALPOSITION' / TTYPE73 = 'BACKEND ' / TTYPE74 = 'PROJID ' / TTYPE75 = 'TELESCOP' / TTYPE76 = 'SITELONG' / TTYPE77 = 'SITELAT ' / TTYPE78 = 'SITEELEV' / TTYPE79 = 'IFNUM ' / TTYPE80 = 'PLNUM ' / TTYPE81 = 'FDNUM ' / TTYPE82 = 'INT ' / TTYPE83 = 'NSAVE ' / COMMENT COMMENT *** Column formats *** COMMENT TFORM1 = '32A ' / TFORM2 = 'D ' / TFORM3 = '22A ' / TFORM4 = 'D ' / TFORM5 = 'D ' / TFORM6 = 'D ' / TFORM7 = '32768E ' / TFORM8 = '16A ' / TFORM9 = '6A ' / TFORM10 = '8A ' / TFORM11 = 'D ' / TFORM12 = 'D ' / TFORM13 = 'D ' / TFORM14 = '4A ' / TFORM15 = 'D ' / TFORM16 = '4A ' / TFORM17 = 'D ' / TFORM18 = 'I ' / TFORM19 = '32A ' / TFORM20 = '32A ' / TFORM21 = 'J ' / TFORM22 = '32A ' / TFORM23 = '16A ' / TFORM24 = 'D ' / TFORM25 = '8A ' / TFORM26 = 'D ' / TFORM27 = 'D ' / TFORM28 = 'D ' / TFORM29 = 'D ' / TFORM30 = 'D ' / TFORM31 = 'D ' / TFORM32 = 'D ' / TFORM33 = 'D ' / TFORM34 = 'D ' / TFORM35 = 'D ' / TFORM36 = 'D ' / TFORM37 = 'D ' / TFORM38 = 'D ' / TFORM39 = '8A ' / TFORM40 = 'D ' / TFORM41 = 'D ' / TFORM42 = '8A ' / TFORM43 = 'I ' / TFORM44 = 'I ' / TFORM45 = 'D ' / TFORM46 = 'D ' / TFORM47 = 'I ' / TFORM48 = 'A ' / TFORM49 = 'I ' / TFORM50 = 'I ' / TFORM51 = '16A ' / TFORM52 = '16A ' / TFORM53 = 'J ' / TFORM54 = 'J ' / TFORM55 = '22A ' / TFORM56 = 'D ' / TFORM57 = 'D ' / TFORM58 = 'I ' / TFORM59 = 'A ' / TFORM60 = 'D ' / TFORM61 = 'D ' / TFORM62 = 'E ' / TFORM63 = 'D ' / TFORM64 = 'D ' / TFORM65 = 'D ' / TFORM66 = 'D ' / TFORM67 = 'A ' / TFORM68 = 'A ' / TFORM69 = '8A ' / TFORM70 = 'E ' / TFORM71 = 'E ' / TFORM72 = '16A ' / TFORM73 = '32A ' / TFORM74 = '32A ' / TFORM75 = '32A ' / TFORM76 = 'D ' / TFORM77 = 'D ' / TFORM78 = 'D ' / TFORM79 = 'I ' / TFORM80 = 'I ' / TFORM81 = 'I ' / TFORM82 = 'J ' / TFORM83 = 'J ' / END NGC2415 AvZ À2021-02-10T07:38:37.50@õ6à@eO`@10ràÀÀÀÀÀÀ?@ÅÔ? ê? Ïš?%g>°õì?#tÃ?hµ>÷$Ä>•ž>ÄIP?*/^>Ö6?î¸? ¦_>À):>–4Û>‡³8>ž½O>`Qh?k?Q×>»}Ö?<âô?{*«?X3Ö?!ê´>Ò›¸>Mß?ãÿ?C|§>™ö>¹8À?6–E?0ë?G#°>óèE>‰^½?I\>~y¼>¯«L?Bk$?;DR>Ó%»? Ê&?/Áo>þ0?%X®>âJ}>ôDØ?BŠ(?=øk>öj>ý|U?_Ž=ãá¬>ð¦›?^EW?_¡ò?-5á>¾Å‚>~Ö>¤ÐŸ?0É/?Hî?D4>màh>Ú€µ?98G?f1–§¢?4”?(Š,?Fõ>š]\>«wr?ObÐ?_¢$?[(?Hö>à$t?id>øÔÞ?³î>ã§>á™Ñ?£">„G>°ŽM?¤>ßí>‘nW>P¾(=úŒ>µ¯ó>‚›Q>½4¨?É(? ô˜?3³À?”?&Ôº?@‡Ž?9 j?‚>âßî>¸8?î?"Ö>s¹b>+Ì>L|?}É??Y{>Ðdì>yâÌ>̘6? ½0?:â?KÓ?7…Ú?JÔ? ÏT>ͱ:>ÔZÐ>q,>UF>zçF>™µn>ŸG>à<ö?H ö?`ö{?G=?GÂN?+Öj?B@=?Or=?<‘> ¡>I>¸~ª>&> Uh?)Y? 4?|?*K>¢vÖ?Y»?3Õ>¦8ÿ?–>ö¾?>Ú/ê>ï½}>‘d!>œÄô? ´z?±¾?-à?O]x?'Tv? From 0d03ccf0ce17420569533268a20e7c1f02f80dda Mon Sep 17 00:00:00 2001 From: astrofle Date: Thu, 26 Sep 2024 15:30:31 -0400 Subject: [PATCH 33/95] Add: notebook illustrating the need to align spectra before averaging --- notebooks/examples/align_spectra.ipynb | 337 +++++++++++++++++++++++++ 1 file changed, 337 insertions(+) create mode 100644 notebooks/examples/align_spectra.ipynb diff --git a/notebooks/examples/align_spectra.ipynb b/notebooks/examples/align_spectra.ipynb new file mode 100644 index 00000000..51cc660f --- /dev/null +++ b/notebooks/examples/align_spectra.ipynb @@ -0,0 +1,337 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "9359fc63-3229-4fd3-8631-09c181e6a27b", + "metadata": {}, + "source": [ + "# Aligning Spectra\n", + "\n", + "This notebook shows why it is necessary to shift spectra before they can be stacked together.\n", + "\n", + "The use case is that for radio recombination lines, altough other lines could also be used for the example.\n", + "\n", + "## Use Case\n", + "Observations of radio recombination lines benefit from averaging multiple transitions together, as the line properties change \"slowly\" with frequency (how slow, is a matter of debate and not the topic of this example). For this example we will look at what would happen if we were to stack two transitions together without shifting (aligning) them before." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "2845830c-b401-44b3-a6b1-ed1c30c706df", + "metadata": {}, + "outputs": [], + "source": [ + "%matplotlib widget" + ] + }, + { + "cell_type": "code", + "execution_count": 53, + "id": "e34b86e9-6438-4e84-8503-d6dd1699e243", + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "from astropy import units as u\n", + "from dysh.fits.gbtfitsload import GBTFITSLoad" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "cf801734-2ba0-48cd-a664-3ca15ce58890", + "metadata": {}, + "outputs": [], + "source": [ + "path = \"/home/dysh/acceptance_testing/data/\"\n", + "file1 = f\"{path}/AGBT18B_014_02/AGBT18B_014_02.raw.vegas\"" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "fb10b18f-4510-4707-ad2a-70a1ec2b4d79", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Loaded 8 FITS files\n" + ] + } + ], + "source": [ + "sdf = GBTFITSLoad(file1)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "62f47e96-7553-48c9-9dfb-032d2af60897", + "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", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
SCANOBJECTVELOCITYPROCPROCSEQNRESTFREQDOPFREQ# IF# POL# INT# FEEDAZIMUTHELEVATIO
06W43G92.02OffOn15.7649695.9315464231117.57556427.647278
17W43G92.02OffOn25.7649695.9315464231117.17271627.302879
\n", + "
" + ], + "text/plain": [ + " SCAN OBJECT VELOCITY PROC PROCSEQN RESTFREQ DOPFREQ # IF # POL # INT \\\n", + "0 6 W43G 92.02 OffOn 1 5.764969 5.93154 64 2 3 \n", + "1 7 W43G 92.02 OffOn 2 5.764969 5.93154 64 2 3 \n", + "\n", + " # FEED AZIMUTH ELEVATIO \n", + "0 1 117.575564 27.647278 \n", + "1 1 117.172716 27.302879 " + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "sdf.summary()" + ] + }, + { + "cell_type": "markdown", + "id": "17ac95ab-15f2-4f45-80cd-cc9d6ca0f001", + "metadata": {}, + "source": [ + "For simplicity we will only use two spectral windows, 27 and 28, which we know have good data in them." + ] + }, + { + "cell_type": "code", + "execution_count": 60, + "id": "d076291b-e69e-4018-ac95-718a7fa3c350", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/sandboxes/psalas/Dysh/dysh/src/dysh/spectra/core.py:393: RuntimeWarning: Mean of empty slice\n", + " meandiff = np.nanmean(calon[chrng] - caloff[chrng])\n", + "/home/sandboxes/psalas/Dysh/dysh/src/dysh/spectra/core.py:393: RuntimeWarning: Mean of empty slice\n", + " meandiff = np.nanmean(calon[chrng] - caloff[chrng])\n" + ] + } + ], + "source": [ + "pssb = sdf.getps(ifnum=[27,30], plnum=0)" + ] + }, + { + "cell_type": "markdown", + "id": "1d1b09e3-969d-40db-89bc-f933756423e2", + "metadata": {}, + "source": [ + "Now we will drop the edge channels, and then fit an order 2 baseline to line free channels. To end we will drop line free channels so we can focus on the emission lines." + ] + }, + { + "cell_type": "code", + "execution_count": 61, + "id": "3e51cc62-4ffc-4f3b-b934-bc2b42d63306", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "EXCLUDING [Spectral Region, 1 sub-regions:\n", + " (5464064707.706556 Hz, 5466252941.541311 Hz) \n", + "]\n", + "EXCLUDING [Spectral Region, 1 sub-regions:\n", + " (5716228475.37819 Hz, 5718517695.075638 Hz) \n", + "]\n" + ] + } + ], + "source": [ + "s = slice(150,1900)\n", + "exclude = [30*u.km/u.s, 150*u.km/u.s]\n", + "\n", + "ta1 = pssb[0].timeaverage().smooth(\"gauss\", 4)[150:1900]\n", + "ta1.baseline(model=\"cheby\", degree=2, remove=True, exclude=exclude)\n", + "ta2 = pssb[1].timeaverage().smooth(\"gauss\", 4)[150:1900]\n", + "ta2.baseline(model=\"cheby\", degree=2, remove=True, exclude=exclude)\n", + "\n", + "s = slice(0*u.km/u.s, 200*u.km/u.s)\n", + "ta1 = ta1[s]\n", + "ta2 = ta2[s]" + ] + }, + { + "cell_type": "markdown", + "id": "6e9a8da0-c986-444a-9c58-10884fbb9cf6", + "metadata": {}, + "source": [ + "Next, we plot the spectra as a function of velocity and as a function of channel." + ] + }, + { + "cell_type": "code", + "execution_count": 67, + "id": "e5ff3d24-63bd-49f6-a7b6-76a150f41c22", + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "8dcb1827f1fe422a97e7555712bc94a8", + "version_major": 2, + "version_minor": 0 + }, + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA8AAAALQCAYAAABfdxm0AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8g+/7EAAAACXBIWXMAABcSAAAXEgFnn9JSAAEAAElEQVR4nOydd3Qc1dnGn9kqadW7bNkycgVjG1NtqikBA6F/tAQCoSRACCGQ0BICJJBACIQWIDSbEkoA02LTscFgbOPei2xLVi+r7b3M98fsztw7MyutmiVZ7+8cH0/f2dXuzDz3eYsgiqIIgiAIgiAIgiAIgtjPMQz2CRAEQRAEQRAEQRDEvoAEMEEQBEEQBEEQBDEiIAFMEARBEARBEARBjAhIABMEQRAEQRAEQRAjAhLABEEQBEEQBEEQxIiABDBBEARBEARBEAQxIiABTBAEQRAEQRAEQYwISAATBEEQBEEQBEEQIwISwARBEARBEARBEMSIgAQwQRAEQRAEQRAEMSIgAUwQBEEQBEEQBEGMCEgAEwRBEARBEARBECMCEsAEQRAEQRAEQRDEiIAEMEEQBEEQBEEQBDEiIAFMEARBEARBEARBjAhIABMEQRAEQRAEQRAjAhLABEEQBEEQBEEQxIiABDBBEARBEARBEAQxIiABTBAEQRAEQRAEQYwISAATBEEQBEEQBEEQIwISwARBEARBEARBEMSIgAQwQRAEQRBpM2fOHAiCgHvvvXewTwXA0DsfgiAIYmhDApggCIIgesG9994LQRAgCMI+e83vvvtOfs133nkn7f3+8pe/QBAEmM1mtLa2DuAZDi0ee+wx3HvvvVi3bt1gnwpBEAQxRCABTBAEQRDDhGOOOQaTJ08GALz00ktp7SOKIubPnw8A+PGPf4yysrKBOr1BYezYsZg8eTKKi4s16x577DHcd999JIAJgiAIGdNgnwBBEARBEOlz9dVX47bbbsNnn32GpqYmjBo1qsvtv/76a+zevRsAcNVVV+2LU9ynvPLKK4N9CgRBEMQwghxggiAIghhG/OxnP4PJZEIsFsPLL7/c7fZJp7iiogJnnHHGQJ8eQRAEQQxpSAATBEEQRD+zZMkSLj+4pqYGV111FcaMGQOr1YrKykpce+21aGxs7PGxy8rK8OMf/xgAMG/evC63dbvdePfddwEAV1xxBYxGo7wuHo/jP//5D8444wyUlZXBYrGgpKQEp556Kt544w2Iotjjc0uyYMECOdzaYrHI5/zee+91u6/dbsef//xnHHXUUSgsLERGRgbGjRuHU089Fc888wxcLhe3vV4RrGR+dl1dHQDg5z//ufz3YP8uzz77LARBQGFhIYLBYMpzisfjGDduHBXbIgiC2A8gAUwQBEEQA8jixYsxc+ZMzJs3Dy6XC/F4HI2NjXjhhRdw5JFH9koEX3311QCAnTt34ttvv0253VtvvQW/3w+AD3/u7OzEiSeeiMsuuwwff/wx2trakJWVhY6ODnz++ef4yU9+gnPPPRfhcLhH5xUOh3HJJZfgggsuwMKFC9HR0YHs7Gx0dHRg4cKFOP/88/GTn/wEkUhEd//PPvsMEydOxD333IOVK1fC4/EgOzsbTU1N+Pzzz3HDDTdg8eLF3Z5HdnY2ysrKYDBIjzm5ubkoKyvj/gHAT3/6U2RnZ8PhcHRZVOyzzz5DXV0djEaj/NkTBEEQwxMSwARBEAQxgFxwwQU46aSTsHXrVrjdbvh8Prz11lvIyclBU1MT7rzzzh4f8/TTT5dzf7sqhpVcd9xxx2HixIkAgFgshvPPPx/ffPMNDjnkEHz00Ufw+XxwOp3wer14+eWXUVpaig8//BC33357j87rrrvuwltvvQVBEHD33XfDbrejs7MTHR0duOuuuwAAb7zxBu6++27NvmvXrsU555wDh8OBqVOnYtGiRfD7/ejo6EAgEMCqVatw6623Iicnp9vz+N3vfoeWlhaMGTMGAPD444+jpaWF+wcAOTk5uOyyywAAzz//fMrjJdedfvrp8jEJgiCIYYpIEARBEESPueeee0QAot6tdPHixfK6E088UYzFYpptnnjiCRGAmJmZKUYikR6//p133ikCELOzs0WPx6NZv2XLFvkc5s+fLy9/5ZVXRADilClTRKfTqXvsVatWiYIgiBaLRWxtbeXWnXDCCSIA8Z577uGWNzQ0iCaTSQQg3nnnnbrHveWWW0QAotlsFpuamrh1xx57rAhAnDhxYsrz0iPV+YiiKFZVVYkAxHnz5qXcf926dfLntG3bNs36lpYW0Ww2iwDEDz/8MO3zIgiCIIYm5AATBEEQxABy1113yaG4LOeccw4AIBAIYOfOnT0+bjKk2ev14u2339asT+YH5+Tk4MILL5SXv/jiiwCA66+/Hnl5ebrHPuywwzB16lSEw+G0Qo4B4N1330U0GkVGRgbuuOMO3W3++Mc/wmq1IhKJcCHHbCj3X//615TnNRDMmDEDs2fPBgA899xzmvXz5s1DJBJBZWUlFREjCILYDyABTBAEQRADyFFHHaW7nG1f1NnZ2ePjTpgwAccffzwAbRh0NBrFq6++CgC45JJLkJWVBUAKf16+fDkAqVBUeXl5yn/bt28HALmQVHesWrUKAHDEEUcgNzdXd5uCggIcfvjh3PYAsGzZMgCA0WjE6aefntbr9SfXXXcdAKmlEpv3LIoiXnjhBQBS3jVbRIwgCIIYnpAAJgiCIIgBJFXOqslkkqdTFYXqjmRBpm+//ZZzkRctWiTnubJFmzo7OxEKhQAADocDra2tKf8lzylZRKs72traAACjR4/ucrvKykpuewDyuRYXF8Nms6X1ev3JRRddhMLCQnR0dGDBggXy8q+++gq7du2C0WjENddcs8/PiyAIguh/SAATBEEQxDDl//7v/2S3lW2JlJyeOnUq50DHYjF5+uOPP4Yoit3+2xdtf5JtiQaLjIwMXHnllQD4MGi2+FVSuBMEQRDDGxLABEEQBDFMycrKwqWXXgpACt+NxWJoa2vDwoULAfCtjwCgqKhIdp7TDW1Ol9LSUgBAQ0NDl9sl1ye3B4Dy8nIAQEdHB3w+X7+eV7r88pe/hCAIWLJkCWpqatDR0SH3Lf7lL385KOdEEARB9D8kgAmCIAhiGJMMcW5sbMSnn36KV199FZFIBGazGZdffjm3rdlsxpFHHgkA+Oijj/r1PNjcXpfLpbuN0+nkcoWTHH300QAkh/rjjz/ut3NKFh8TRbHbbSdNmoSTTjoJoiji+eefl/OBx4wZMyh5yQRBEMTAQAKYIAiCIIYxRxxxBKZNmwZACn1Ohj+fddZZKCkp0Wz/i1/8AoCUJ7xo0aIuj92T4lwXXHABTCYTgsEgHnroId1t/vrXvyIUCsFsNuOCCy6Ql7MFve666y643e60X7crkuHhTqczre2TxbDmz58vh0JfddVVVPyKIAhiP4IEMEEQBEEMc5Iu8IIFC7B582ZumZrLLrsMp5xyCkRRxHnnnYf7778fTU1N8nqfz4fFixfjV7/6Faqrq9M+h9GjR+M3v/kNAODBBx/EPffcIwtPp9OJu+++Gw8//DAA4JZbbkFFRQW3/+OPP46MjAzs3LkTxxxzDD755BO5EFcsFsMPP/yA6667Dl988UXa53TwwQcDAN555x04HI5utz/33HNRXl6OtrY2bN++nYpfEQRB7IeQACYIgiCIYc5ll10Gi8WCeDwOQBKjp512mu62RqMR7777Ln784x8jHA7j7rvvxujRo5GXl4eCggLk5OTgpJNOwtNPP93jfNy//vWvuOiiiyCKIv785z+jqKgIhYWFKCoqwv333w8AuPTSS/GXv/xFs+8hhxyCDz74AHl5edi0aRNOP/102Gw2FBcXIzMzE0ceeST+/e9/w+v1pn0+v/jFLyAIApYtW4aSkhKMGjUK48aNw7hx43S3N5lMnOCl4lcEQRD7HySACYIgCGKYU1RUhHPPPVeev+KKK7oM283NzcVHH32ERYsW4eKLL8bYsWMRCoXg9/sxevRonHrqqfjb3/4m9wJOF4vFgrfeegvvvPMOTj/9dBQVFcHj8aCoqAinn346FixYgNdffx1ms1l3/1NPPRU7d+7EH/7wB8ycOROZmZnw+XyyoP/3v/+Nk046Ke3zOf7447Fw4UKccsopyM/PR2trK+rq6rosAHbhhRfK01T8iiAIYv9DENOpDEEQBEEQBDECeOSRR/C73/0OY8aMwZ49eyj/lyAIYj+DHGCCIAiCIAhIucbPPPMMAODaa68l8UsQBLEfQgKYIAiCIIgRTzwexz333INdu3bBZrPJFaEJgiCI/QvTYJ8AQRAEQRDEYPHOO+/gd7/7HTo7O+HxeAAA9913n24LKYIgCGL4QwKYIAiCIIgRi9frRV1dHcxmM6ZMmYIbb7wRv/rVrwb7tAiCIIgBgopgEQRBEARBEARBECMCygEmCIIgCIIgCIIgRgQkgAmCIAiCIAiCIIgRAQlggiAIgiAIgiAIYkRAApggCIIgCIIgCIIYEZAAJgiCIAiCIAiCIEYEJIAJgiAIgiAIgiCIEQH1Ad7PKC8vh8/nw9ixYwf7VAiCIAiCIAiCIHqM3W7HkUceiQ8//LDfj00O8H6Gz+dDJBIZ7NMgCIIgCIIgCILoFT6fD7t27RqQY5MDvJ+RdH43b948yGdCEARBEARBEATRc6ZOnTpgxyYHmCAIgiAIgiAIghgRkAAmCIIgCIIgCIIgRgQkgAmCIAiCIAiCIIgRAQlggiAIgiAIgiAIYkRAApggCIIgCIIgCIIYEZAAJgiCIAiCIAiCIEYE1AaJIAiCIEYAoigCAARBGOQzIQhiJCCKonzdIUYugiAMufsOCWCCIAiC2M/Za/fj6pd/gCAAL15xBMYUZg32KREEsR8Sj8fhcrngcDgQCoUG+3SIIYLVakVBQQHy8vJgMAx+APLgnwFBEARBEAPKGz/sxc42L3a0evHairrBPh2CIPZDRFFES0sLWlpaSPwSHKFQCC0tLWhtbR0SUQHkABMEQRDEfk67R3kYbXQEBvFMCILYX/F4PHC5XACA0tJS5Obmwmg0DvJZEYNNLBaD2+1GW1sbnE4nbDYbcnNzB/WcSAATBEEQxH6OLxSVp1kxTBAE0V+43W4AQGFhIYqKigb5bIihgsFgQFFREaLRKDo7O+HxeAZdAFMINEEQBEHs53gZAdzhJQFMEET/4/f7AQA5OTmDfCbEUCT5vfD5fIN8JiSACYIgCGK/hxxggiAGElEUEYvFAEgFjwhCTfJ7EYvFBj0PmAQwQRAEQezn+EIxedodjCIYiXWxNUEQRM9gBc1Qa3lDDA3Y7wUJYIIgCIIgBhQ2BBoA7L7wIJ0JQRAEQQwuJIAJgiAIYj/HF+YFMIVBEwRBECMVEsAEQRAEsZ/jC5EAJgiCIAiABHCXrF69Gg8++CDOP/98VFZWQhCEPuU1OBwO/OY3v0FVVRWsViuqqqpw8803w+l09t9JEwRBEARDKBpDJMbnW1ElaIIgiH1DKv2QXJ7q35w5c/r9XOrq6vDkk09i7ty5KC8vh9lsRnFxMebOnYsPP/xQd5/58+d3e66CIOCVV17p9/MdKKgPcBf85S9/wQcffNAvx+ro6MDs2bNRU1OD6upqnHvuudi8eTMef/xxfPzxx/j+++9RWFjYL69FEARBEEnYAlhJyAEmCIIYGlxxxRW6y6dMmdLvr/XTn/4U3333HaxWK2bNmoXy8nLs3r0bn376KT799FP89re/xaOPPsrtM2HChJTn6HK58P777wMAjj322H4/34GCBHAXzJ49G9OnT8cRRxyBI444AuPGjUMo1LuHhptvvhk1NTU4//zz8dZbb8Fkkj76m266CU8++SRuueUWzJ8/vx/PniAIgtjv8bYD3z8F5I8BDr8a0HEZ1OHPAAlggiCIocK+fP6vrKzEk08+iSuuuILr17xw4UKce+65+Oc//4m5c+fi1FNPldcde+yxKcXtM888g/fffx/HHHMMqqurB/z8+wsSwF1w++2398txmpub8cYbb8BiseDpp5+WxS8APPzww3jzzTfx2muv4e9//ztKS0v75TUJgiCIEcA3DwMr/y1NF08CDjhes4m6AjRAIdAEQRAjkTfffFN3+ZlnnomrrroKzz33HN544w1OAHfFa6+9BgC4/PLL++0c9wWUA7wP+OSTTxCPx3HcccehrKyMW2e1WnHWWWchFoth0aJFg3SGBEEQxLCkbQszvVV3E3KACYIgiO6YMWMGAKCpqSmt7ffs2YNly5bBYrHgoosuGshT63dIAO8D1q9fDwA49NBDddcnl2/YsGGfnRNBEASxHxDxM9MB3U30HOB2coAJgiAIht27dwMAysvL09o+6f6eeeaZKCgoGLDzGggoBHofsHfvXgBS3L0eyeV1dXX77JwIgiCI/QBW9Eb1Ra1eEawOcoAJgtiHiKIId1A7GDfUyc0w9akDTH8yZ84cfP311z3aZ968ebjyyiu73c7pdMpVnM8555y0jj1cw58BEsD7BK/XCwDIysrSXW+z2QAAHo8n7WNOnTpVd/muXbswfvz4Hp4hQRAEMSxhHeBoKgc4olnmC8fgC0Vhs9JjAEEQA487GMWM+z4b7NPoMevvORV5meYBfY1UAnvPnj0YN26cPD937lxuPh0mTJiQ1nbXXXcd2tvbMWvWLJx33nndbr9y5Urs2LEDhYWFOPPMM3t0TkMBuvMRBEEQxHAlDQfYq+MAA1IhLBLABEEQg0uqFkPZ2dnc/B133DEgr//QQw/hrbfeQmFhIf7zn/+k5Xgn3d+LLroIFotlQM5rIKE73z4g+QX2+/26630+HwBw5ci7Y/PmzbrLUznDBEEQxH4IJ4CDupvoFcECJAFcVWQbiLMiCIIg0mQw26C+9tpruPPOO2Gz2bBw4cK0WhlFo1G89dZbAIZn+DNAAnifMHbsWABAQ0OD7vrk8qqqqn12TgRBEMR+AFcEq2cCmCpBEwSxr8jNMGH9Pem11hlK5GYMHan04IMPYtu2bT3a55prrknZw/d///sffv7zn8NsNmPBggWYNWtWWsf87LPP0NbWhurqahx99NE9Op+hwtD5q+7HJMuKr1mzRnd9cvn06dP32TkRBEEQw5xYBIgz4jaFA6xXBRogAUwQxL5DEIQBz6Xd3/nkk096XARrzpw5ugL466+/xoUXXghRFPH666+n3fcXUMKfL7vssh6dy1CCBPA+YO7cuTAYDFi6dCna2tpQWloqrwuFQvjoo49gNBpxxhlnDOJZEgRBEMOKiCqtpoch0O3ecH+fEUEQBDFALFmypF+Os2bNGpx99tkIhUJ46aWXcMEFF6S9r9frxQcffABgeAtg6gPcjzz11FOYMmUK7rzzTm55RUUFLr30UoTDYdxwww2IRpWHkdtuuw3t7e247LLLOGFMEARBEF2i7vub0gFWimBZjMptnxxggiCIkcX27dsxd+5cuN1uPP7442m1SGJZsGAB/H4/Zs2ahYkTJw7MSe4DyAHugoULF+Ivf/mLPB8OS6PlbIz83XffLZf/7ujowPbt29Hc3Kw51mOPPYbly5fj3XffxZQpU3D44Ydj8+bN2LRpEyZOnIhHH310gN8NQRAEsV+hcYBT9QFWBl3HFGZiV7tUeJEEMEEQxMjikksuQXt7O0pKSrB69WpdATxlypSUFaeHc+9fFhLAXdDe3o4VK1ZolrPL2tvb0zpWcXExVq5ciXvvvRfvv/8+3nvvPZSVleGmm27Cfffdh/z8/P46bYIgCGIkoHaA1fMJfGFFAB9QbJMFcIeXBDBBEMRIwuFwAJD0y8svv6y7zQknnKArgJubm/HVV1/BbDbj4osvHtDzHGhIAHfBlVde2aPQgHvvvRf33ntvyvWFhYV44okn8MQTT/T95AiCIIiRjSYEWiVowz5g99dAMA5A6us4jml7RA4wQRDEwCOKYo+WDyS1tbW93reiooJL4xzOUA4wQRAEQQxHwj5+PqoSxG9cCrx5KZ7w/h4GxAEAVUVZ8mq7LzQoD2AEQRAEMZiQACYIgiCI4UhXDnA0DOyR2mWMQxOqhFYAwFjGAQ5G4vCHYyAIgiCIkQQJYIIgCIIYjnTVBinCu8M5kLYdU5DJLbdTKySCIAhihEECmCAIgiCGI5oiWIwAVoVH5wqSAM7NNKMgyywvt/soD5ggCIIYWZAAJgiCIIjhSFcOcJhflwtJEGdbTSjKtsrL+9sBrrP7cPs7GzD/uz39elyCIAiC6C+oCjRBEARBDEfUDrAYA2IRwGgGwl5uVa7gh9EgwGoyoNBmkZf3twP8wMKt+GyLlG98yNgCHDImv1+PTxAEQRB9hRxggiAIghiO6PX9TbrAKnc4B37YLEYIgoDibFYA968DvKnRJU9vbXb367EJgiAIoj8gAUwQBEEQ3RCMxIZeyyB1CDSgVILWyQHOtkpBX0W2gQmBjsVFtDK9he1eyi8mCIIghh4kgAmCIAiiCz7b3ILD7/8Ccx9bCn84Otino6DnACeXqQUwfLAlBDAXAt2PIrXDG0IsLjLzVGGaIAiCGHqQACYIgiCILnjl+zp4Q1Fsb/Xgy61tg306Cj10gJMCeKBCoFtcQW6+gxxggiAIYghCApggCIIgusAViMjT7mCkiy33Mbo5wPoOcA6YEOg+VoH+alsrjv7bl7ju1dWc49tMApggCIIYBpAAJgiCIIguCERi8nQoEh/EM1GhK4ATojOi5wAbAQBFfawC/fCnO9DkCuKTzS1YvtsuL29x8efT3y2WCIIgCKI/IAFMEARBEF0QCCsCOBiNdbHlPkYvBDplDrASAl3EhEB3+sI9Ku4Vi4vY1aa0WGJd32Y3OcAEQRDE0IcEMEEQBEF0QSg6DB3gMC+OcwUfcnSqQEdiItzB9At7NTkDCMeUz8DpV1xedQ6wwx9BNDaEPi+CIIhBQBAECIKQcnmqf3PmzOn3c6mrq8Ott96K448/HpWVlcjIyEB2djZmzpyJBx54AD6fL+W+DocDv/nNb1BVVQWr1YqqqircfPPNcDqd/X6eA41psE+AIAiCIIYyrAMcig4hQafjAO9obIfX6sChYS+3PAcB2QHOyzTDaBDk/F27N4S8THNaL7mng384cvqVnGh1DjAgOcyluRlpHZsgCGIkcsUVV+gunzJlSr+/1saNG/Hoo4+ivLwcU6ZMwXHHHQeHw4Hly5fjj3/8I9544w0sXboUBQUF3H4dHR2YPXs2ampqUF1djXPPPRebN2/G448/jo8//hjff/89CgsL+/18BwoSwARBEASRAlEUEWREbzAylEKgtQ7wU59twofxXCyf2IlyZnmOEEAy8tlgEFCQZZFDlO2+MKpL0ntJjQAOpHaAAakVEglggiCI1MyfP3+fvdZhhx2GTZs2YerUqdxyt9uN888/H19++SUeeOAB/OMf/+DW33zzzaipqcH555+Pt956CyaTJCFvuukmPPnkk7jlllv26fvoKxQCTRAEQRApiMRErtLx0HKAtQLYKkiCtLm9Q7OuwKjk5HKtkHpQrEotgB0JB1gURbS4tQK4N0W2CIIgiIGhoqJCI34BIDc3F/feey8A4KuvvuLWNTc344033oDFYsHTTz8ti18AePjhh1FSUoLXXnsNbW1DqE1gN5AAJgiCIIgUBFSOb2iIF8GyQhKkIb9Hsy5fULYvyu5dJWi1AHYlBLDDH0FYZ3CACmERBEEMD8xmKRXGYrFwyz/55BPE43Ecd9xxKCsr49ZZrVacddZZiMViWLRo0T47175CApggCIIgUhBSC+AhXgTLCsnNzYDWjc0TFPFaaOtdL+Bau9oBTjjOLp2CXD08NkEQBDE4+P1+PPDAAwCAM888k1u3fv16AMChhx6qu29y+YYNGwbwDPsXygEmCIIgiBQMWQc4HgeiegJYcmRt0Dqv2WAcYBvfCikdwtE46jt51zlZBEsv/xcA2skBJgiC6BfmzJmDr7/+ukf7zJs3D1deeaVmucPhwG9/+1sAQHt7O1asWAG73Y5zzz0Xv/vd77ht9+7dCwCorKzUfY3k8rq6uh6d22BCApggCIIgUqAVwIPvAMfiIgzRALRNNYCMRA5wpqAVngUGRTCzOcDphinXO/yIq1oGuwKSANarAA2QA0wQRAJRBIKuwT6LnpORB+i0MOpP9FokAcCePXswbtw4eX7u3LncfDpMmDBBd7nP58PLL7/MLbvooovw1FNPITMzk1vu9UpdBbKysnSPZbPZAAAejzb1ZqhCApggCIIgUhBUhTzv6yrQb67ciw2NLvzy+GpUFdmwucmFq+b/gDKTDx/qbK84wFpBWpmpiNHehEDvadf2h/SGoghH4ykdYMoBJggCgCR+H6oa7LPoObfXAZn5A/oSqdogZWdnc/N33HFHv71mZWUlRFGEKIpoaGjA559/jj/84Q+YNm0aFi1alDLceX+BBDBBEARBpIDtAQzsWwd4a7MbdyzYCABodATw8lVH4oWle9DqDsEIJ6DTXSgjkQOcpRMCLYTc8nRvimCp83+TuAIRzgEeW5iFvYlQaXKACYIgumYw2wcJgoAxY8bgqquuwrRp0zB79mz8/Oc/x7p162RnOinE/X5t4UVAcpMBICcnZ9+cdD9AApggCIIgUhCMDl4RrK3NimBduacTsbiILU3SMr0QZ0BygKsLLbAmcnM5gsrx2BDodHOAd3foC2CnP4wWtxJeffDoXFkAkwNMEATRPzz44IPYtm1bj/a55pprcOyxx6a17RFHHIHJkydjw4YN2LNnD6qrqwEAY8eOBQA0NDTo7pdcXlU1fBx+EsAEQRAEkYKgygFWC+KBhHVPA5EYdrV7satdysVKOr1qrEIEVx1RCujVSWHy74qYEOhOXxixuAijoes8t9pUAljlAB88Og+LNrbI70EUxZQ5bgRBjBAy8qRw4uFGRt5gn4HMJ5980uMiWHPmzElbAANAcXExAKkwVlIAz5gxAwCwZs0a3X2Sy6dPn96jcxtMSAATBEEQRAo0RbC6cIBFUUQoGkeG2dgvr92hCk3+34ZmRBNVqDJ1QpwBSRiX5qUQm4wALmQc4LgoubhF2Va9vWTUPYCTOHxhLgf44FHKA2M4Foc7GEVeprnLYxMEsZ8jCAOeS7u/s2TJkgE9vtvtxtq1ayEIAg444AB5+dy5c2EwGLB06VK0tbWhtLRUXhcKhfDRRx/BaDTijDPOGNDz60+oDzBBEARBpEBdBCtVGyRPMIIf/fMbHH7/F/hya2u/vHanKn/2g3WN8nSmkMIBRgRjslOIdEYA51hNsBiVR4DuwqAD4Rjn8o7KUxKQ6x0B+BmnfEpFDucm2ykMmiAIYkjwwgsvYPfu3ZrljY2N+MlPfgKPx4MzzzyTE7kVFRW49NJLEQ6HccMNNyAajcrrbrvtNrS3t+Oyyy7j9hnqkANMEARBEClQO8BqQZzk400tqGmTwpNf/r4OJx9Y1ufXtqtEaZ1dKUCS0gEWwijP7F4AC4KAomyLLGo7vGFM7OKUl+5sl6ctJgMOGpWHpsS+m5uU41qMBhTbrCi0WdDuCcnHri5JfWyCIAhi3/Daa6/h2muvxUEHHYQpU6bAbDajvr4eq1evRigUwtSpU/Hcc89p9nvsscewfPlyvPvuu5gyZQoOP/xwbN68GZs2bcLEiRPx6KOPDsK76T3kABMEQRBECtRtj0LRGERR1GzX7FTc0Q5P/zieagHMkioHOMcYgyUW0F2HEN+Ds9CWXiVoURTxryW75PkTJ5egiNl3fb1Tnh5blAWDQUBxNttmiRxggiCIocDvf/97XHXVVQCAxYsX491338X27dsxa9YsPPHEE1i9ejUqKio0+xUXF2PlypX49a9/jXA4jPfeew8ulws33XQTVq5cicLCwn39VvoEOcAEQRAEkQK1AI6LQCQmwmLi82zZaseugE4F5p4Q8gK7voLJHQCQrbtJqhDobFMUiOi3qmAdYABczm9XIdDf77JzIveGOROwaGOzPL+L6Q9cVZgFgK8yTZWgCYIYyegNmna1fCA588wzceaZZ/Zq38LCQjzxxBN44okn+vms9j3kABMEQRBECtR9gAH9PGBW5Ln7KoDfvQb47+V4Pngr8uDV3STboAjWGHMrzzJEgDCzj8Dc5lUCuNjGitTUAvhfS2rk6eMmFmPGmHzkZ1l0t60qsgEA5xB3dWyCIAiC2NeQACYIgiCIFOi1PQpFtTm27UzYsycURSze85H9SCyOrZvXAzs+BgAUCh6cbNC2ncjJMGFSgVJp2ina5OlMIQqEGQc4u1yZDrqBuHLuXAh0Cpd2fb0T39XY5fnr54wHAORn6Vd1HlecdIAVd5kcYIIgCGIoQQKYIAiCIFIQCGvFrjosGtCKPE+wZy5wLC7iqvk/4H+vP8Utn2Ncz80fb1iPe2zv42CLEoLsFJUwaYsYBsJMu6JcNpdL5NzhdEKg2VDnmWPzMbu6CABQkEIAJx3gcqZK9CebWkgEEwRBEEMGEsAEQRAEkQI9savnAKvDfLvLA67v9OOal3/A799ej3ZPCM99sxtLd3bgbOMybrvjDBthQBzZ8OMR89N4xfIQ/s/3OqZ2fCxv42TyhM1imA+BzlEVM2HCoIuyWQdYXwBvYio8n3FwBQRByn3Oy9QPgR5XJDnAcw8uR4ZZesSw+8L4w3sbByXfjSAIgiDUUBEsgiAIgkiBrgBWtUIKhGPwhqLcsu4E8JNf7cQXW9sAAMt22dHuCWGysBeTDQ3cdgWCF6caV+EO4xsYZ9DvL+xgHGBDLMQXwcrIB8w2IJJwhYMuAGMASHm6BXDjWMMmNHiO1BxXFEVsbnLL8weNypWn9UKgjQYBo/IzAQCVBVm48/QDcc+HmwEAn25uxfvrGnHezMoUnwhBEARB7BtIABMEQRBECtR9gAEmL7hpHdC2BR2j5mq2cQeimmUs6xJVlQ2I4yLvKxhnaEW2Qb990ePmp2FN0fYIAOYcMhnYuBYAIMRCUhXpJBYbkJGnEsASJdYo3rXci2pDC2p9FUDsTMCoPBY0u4Jw+hUhP5URwAU6RbAqCzJhNiqBZZfPqsJnW1rkHOKHPt6Ocw8ZLbvIBEEQBDEYUAg0QRAEQaRATwCHInFgzzfACycD71+P7IU3aLbpygGOxUXU2SWX9keGVfiN6T2cY1yGk41r5W32iiXydFfiFwBMtiLVSXcq05YsSQDLJ684uuM2PoFqQ4s0jWZEWjZzh2Hd39H5mVzlZz0HOJn/m8RgEPDAudPk+RZ3sNuBAYIgCIIYaEgAEwRBEEQKghFtvm/M3wm8dx0Ql8RcQd3HmCns5LZJCmC9vNdGR0DOI55l2KpZHxcF/Cnyc81y76ijETnpXu1JZhXw836lajMsNiAzX5n3SIIXzeuRs+55brfA7uXc/GYm/5cNfwaADLNRzvFNksz/ZRlbmAWTQXF8O3xUDIsg9kfYyA7K9yf0YL8Xgx0JRAKYIAiCIFKgzQEWMX7FHwF3I7f0t6Z3uHlXIIKVezpx1F+/xDlPfctVWd7VroQoH2HeI0/HDZKr+nLsVCyJz0CrmK8c0JSB7AuegrlqlvYkM7sQwGYbUDxRmW/dBMRjwEe/gSDy7y1e/wM3zzrAU1UCGADyVYWwxhZqBbDBIKjaLVFPYILYHxEEAUaj1J4tFKKBLkJL8nthNBpJABMEQRDEUEUtgE82rEFFwyea7Y43bsThwjZ53hWI4MVvd6PNE8L6Bhfufn+TvK6mTRLAJkQxSVQEcMM57+CQ4L9xX/QKAAI+is1WXmDOnUDReGDUIYBBVb4jIx8A8zDhUznA5dOV+eYNUvh2kxJuLW/awvcc3sIJ4Dz15pow6HGqEOgkbLulVP2GCYIY/mRlSYNgHo9nkM+EGIokvxc2m/69Yl9CRbAIgiAIIgXqHOATDeuUmbFHA2IMqF8BAPit6V38NPIHAIA7GMGnm5WqzQs3NuPvoShsVpPsAE8W6mFBIlfYYEbJxCPhxGJ5n4ejF6NTzMWPjpyGmcfcKC00ZwLl03gBa84CTBlANFFESx0CnX+QMt+6Cdi9RJ6tN47BmFg9ACDLvQsIOIHMfDh8YTQ6laJcB5VrH1g0ArhY6wADQDHTbqkjRb9hgiCGP7m5ufB4POjs7ITJZEJubq7sChMjl1gsBrfbjc5OqT5FTk7OIJ8RCWCCIAiC0LLsSaBuGarDx2INxsmLRwmMuDzwx0DZVOCVcwAAxxg3IysShB8ZcAUiyDQbOQH93tpGXDarShbAMwy7lWOVH4zMrCyU5FjR7pFc0hAseDp2Do6ZehTAhotVHqkSwJmAyaoI4GTFZ0ASwGVTAcEAiHGpRdL6N+XV3+fOha3zDRQK0jm5d63AWsuhiDC9ju/P+A9GPX01cPSNwEl/lJezIdCCILU+0qOIC4EmB5gg9ldycnKQl5cHl8uFtrY2tLW1DfYpEUOM/Pz8ISGAKQSaIAiCIFia1gKf/RHYvggPGJ7lVnECOK8SqDqGW58LSXw6fGGlXVKC+ctqIYqiHAI9XdjFHPhQAECVTh5tUbaq5VDlEfy8OUsSwXpYbFIl6OLJyjJvizzZmn8o1sfHy/NvvLcAV7y0Ete8sgoAUAg3foJFEKIBYOmjQFAJiy6wKQ7wqLxMZJj1nR4+BJocYILYXxEEAeXl5SgvL4fVau1+B2LEYLVaUV5ejrKyskHP/wXIASYIgiAInrpl8uSBhr0oQydaUQgAGCV0KNvlVQJGM0KwyK2KsoUAIAK7231QF0KtafPiw/VNcCR663IO8OjDAEiFpFbVObj92CJSAIAxKgEMSA6wHuZE6HLFdKBdVXHanIVA8TSs3TERJxrXAwAmhLdzm1QIdhiQeCNiDOjcLeUhA8hjHGC9AlhJWAFvpyrQBLFfYzAYUFBQgIKCAoiiSBWhCQiCMCRELwsJYIIgCIJgaVrHzR5t2Iz34schB37kCkpeLPLGAAA8YiasgiSAcyCtb3EHdQ/910WSCM1EEJMM9cqK0ZIDPEZHSBZmqQRwfpXk6HZsl9zf0ilSDrAelqQAngFseItfV3k4CnJsWCoqDvBMw04AIpJFtUoFJ7+PvUYWwAePVipDHzFOVYmaodimiPOOHjjAn2xqwVs/7MXFR4zB3IMr0t6PIIihwVAUPgQBkAAmCIIgCJ7m9dxsUgBz7q/RCmQVwx+OwitmoFiQeubahCDQheHR6pYc0KlCLYzJDc02oHgSAK2TWpBlhsmoylYSBOCiV4C1rwITTwUy8roQwInjVczQrht7NIqyLVjHhEAXCl6MFdqwVywDABxg9fDvp1NxredOLceffnwQ3MEIrjmuOuV75hzgNHOAg5EYfv/2enhCUazY04ljJhQjJ8Pc/Y4EQRAE0Q0kgAmCIAgiScgLdOzgFh1t3AxERYxWhz8bDOjwBOGFkn+bjQDUzKouRCgax9q9TnkZF/486hDAIOXPVhXxAlgT/pykdApw2gPKfEoBnC39Xz5Nu67qaBRFrXAjG7viFRhvaAYAHCFsx+2Xno7yPCsO2rEB+I7Zx67kLZuMBlx17AH6r8vA5QCnWQW6xRWEJxQFAPjDMWxucmNWdVFa+xIEQRBEV1ARLIIgCIJI0rIRagt3tGBHldCqLYAFoN0b4gRwjuDXHLI0JwO3/mgyt+wgQ50yM2qmPKl2gFnx2CXmFALYnDheRh5QwIhVgwmoPEKu0LwyPkVedZRhKw4Zm4/DqgqRGe4AR+cudEvIAzYBmq0C7fRHEInFuc394ajmEG0e3ine1Ojq/nUJgiAIIg1IABMEQRBEkuZ1uouPNmxWOcBS/m+7JwSvqIhPG7S5v6U5VhwzoQhHjiuUl3HHKpogT5bkWJFhVm7NRakcYDV6DrBg5ItjsWHQo2YCliw5PHl5/EB51dGmrRiVlzieR6kYDYBzgHX57gngwbHAS3OBqCRi1VWsHYwL/Lu312PqPZ/i3g83c9u0efjPcSMrgL/8C/DiaUDtt12fC0EQBEHoQAKYIAiCIJIw+b8ilOItxxg26zrAHSoHuMCoFcBluRkQBAG3nDpJXlYB7bEAqWgM6wJrWiClQq8KtCWb7x884WRlevIZAJQQ6+Xxg+RVlWiD4EoU6PK28scMdAL+Tv1zEEXg20elfsP1y4FtCwEAWRYTsixKi6RkIazd7V68s7oBogi8/H0t3MGIvE2bm3eAZQHctA5Y+g/p+J//Sf88CIIgCKILSAATBEEQRBKmAnRb5Wny9GzDZlQK7fL84hYLjnnwK/zx/U3wiooALjJrc1xLcyVxOqu6CJccMQYC4hhlZFod5Y7mtucEsC3NEGiTTh/gZAXoJIf8FDj9YeBHfwFm/woAYDUZkWM1oRWF2B0vV7ZNuqselQAGuEJYHO5GIMC8ry3vy5N6rZCW7VIGAUQRaHQo+dOtKgd4d7sPnmAE6NipLHTWgyAIgiB6CglggiAIghBFIOyTWgsl2Fn9M8REyUEtEjyYLijC76VNMTQ6JcHWnQNckqOI2AcvmI4Nvz8UZlFxO5HHC+DzD5UcYZNBwOnTypEWeg7wuGP4eYMROOoXwDE3cdvrhUGj9lvpM1E7wEDqMOhWPowZOz6TPlPwQt6ecIC/323nNm9yKgK43a2tFr25yc2fT8itfx4EQRAE0QUkgAmCIIiRzY5Pgb9VAv+YJIXvAoDZhuacqVgnKvm5ZiEmT9fHlXxe1gHONWiFW2kOn5+bE2REnCVHKlDFcMa0Ciz53Rwsu+MkTCnPRVqYVQ6wYACO/31auyYLbS2PT1UW1i4Fgk4gptO2KFUhrNZN/Hw0AOz8DABQzDjAHd4QRFHECpUAbmQEsLoIFgBsaHBiwzZlgALRIBBNv68wQRAEQQAkgAmCIIiRztcPAWGv9C9J+TQEo8CSmE7/XADNotKSxwdF4OYK2jZIyRBoGXejMs3k/7KMK7ahNDdFZWc9BNXtfNpFQMlk/W1VFNl0HGDnXqBhlf4O6TrAALD5/cRr8K2QdrZ55VzgJLwADiIHfEXtJ7+qQc0eVfg1+zcjCIIgiDQgAUwQBEGMXIJuLu9X5oDjEYjEsCR+iGZVu5iLECTRKAjAjAlj5HXZKgGcaZZybDlcDcq0Kvy510RVjumc29PeNRkC3YYCNBmZ89n4jv4O9hr95XoCeOdnQNjP5wB7Q/h+l12zKZsDfKnrRWzMuAbPmx9Bsi2VJxhFKRz8TkFqj0QQBEH0DBLABEEQxMhl73JATIQ2Z+QDx94CzLkLOOY3CEbi2CSOQ7vIhyE3icXy9JHjCnHuUUoP3SyRF8CluVYIbCVmgBfAuf0kgKtPUKYPvxoorE571wMrlPdnLzlKWZGo4gwAMDLVqDt3c31+AQCRIF+gSkhUfY74gZrPuX7Gdm9YVwAnc4BDQT8uE/8HAPiRcTWqhWZ5m1LBye8U8nTxzgiCIAhCi6n7TQiCIAhiaBCKxmA1GbvfMF1qv1Gmxx0LnHKPPBuIxCDCgG/iM3CBcam8vJERwIU2i9RuKEGmyIftluboFKdKIwS6x0z5MXD2k5KjfeQverTrhYeNQYsriGhcxKSyk4GPFkgrwoy4HH04sHeZNB1yA74OILtEWd+xXRlIMFqBSacBWz+U5pvWorj4cJxtWIaTjWvwreMCfO4ZqzmPZAi0o3EHypl86/HmTuwOjwIAlAgqx5cEMEEQBNFDyAEmCIIghjyiKOLq+T9g2j2f4YWlKdrw9IZkux8AGHcctyoQlkSYOg+4icn/LbBZAKvioFpjPm5bdQEsAICLEcD95QAbjMChPwOOvhEwpdk7OEGmxYjb5k7BXWccCGvVLP2NSqdIDnkSdSGslk38tmVMQS1HLSoEJx4xP4NzjMvwa8eDcPq1xavaPCGEo3H4mrZzyw8vlCprWxBBgcDn/DocWieZIAiCILqCBDBBEAQx5Nnc5MaX29oQjsXx2Bc7EYuL3e/UHUEX0LxemT+AF8ChqCSAv4lPR5y5XbIh0IVZFsCaI89bYrwDXLKvHOD+omg8L3STZJcBhQco8+oevGz+b9nBQAGzbeceVAS2y1W0xxraUSVIlbDZ8GtRBFpcQUTamFBqAHPHxJCXacasshjUrK/Zm977IgiCIIgEJIAJgiCIIU870xbHG4pid3s/VP+t+15pe5RZCJQcyK1OOsAuZGO3TXGBt4pK+K7kACsh0MZ4CGZE5fkydSXnWBTwKDmtQ04ACwJQeYR2eXYZf64ulfBkWyCVTeXFsqMW+QF++8OEHQCAcw8ZxYWJNzj9MKrc5SqzA+v+9CO8cmGV5rS21TV184YIgiAIgocEcDcEAgH86U9/wqRJk5CRkYFRo0bhqquuQmNjY/c7M4wbNw6CIKT8t23btgF6BwRBEMMfhypkdn2DC4gEgFXzpFY76qJM6VCr5PVi3LGAgb8lBiKK4/j5AbdjYexI/DNyAb6PHyQvL7SZOQcYAGxQCmFpcoA9zYroBoDcUT0/74FGTwDnlAN5SrVrrpCXKGoFcME4ZT7ohK1tLXe4www7UZxtweWzqzAqX+lh3OQMIsOzh39td5NUSMzTojktp8MOlz8CAPhmRzteWLpbnicIgiAIPagIVhcEg0GcdNJJWL58OSoqKnDOOeegtrYW8+bNw//+9z8sX74c1dXpV9oEgCuuuEJ3eV5eXn+cMkEQxH6JUyVq1tc78X/+/wJf3ict+Om7wMRTenZQTgAfp1kdjChCNV40Eb+K3KzZpiCLL4IFANlCEE4xB4CIyZ7vgR9cwPRLJKeYDX/OKgLMmRhyVB6uXaZxgBkB7G0F/EwubtnBifdmAyJSTrRhz2LucIcaduCGOROQZTFhdEEm1tU7AUitkPL8dfxrJ3Omva3a0xICsPtCaPME8bOXVgIAdrZ68dD/TU/vvRIEQRAjDhLAXXD//fdj+fLlmD17Nj777DNkZ0sPOY8++ihuvfVWXHXVVViyZEmPjjl//vz+P1GCIIj9HHXRpA0NTsCjCFjPzqX4NjgVcyaXItOSRpXooBto2ajMjztWswnrAOdlmnUPU2SzSgWoGLGXjQAOFXbgbvNrOHhJomdu/Q/A+f8emBZI/c3ow7TLcspTC+DG1cx2owBbIke6YBzQlsgNVvXrnSw04IAZ+dLLMQ6w3d6B3Ggn/9ruRJizjgDOgR/uYBQfrlNCod9aVY8HL5imbT9FEARBEKAQ6JSEw2E89dRTAIB//etfsvgFgFtuuQXTp0/H119/jdWrV6c6BEEQBNFPOFQO8NZmD+KMCPti1WZc/581+PUba9I7YONqJRQ5Iw8omaLZJMQI4NwUArjAlljOhEFfYPke71juw0xDjbLhxrclIccVwGJCiocSmflA8WRmgQDYSlKHQDesUqYrGfHM5gGrMAgiMlqlvxUrgEV7jXbjkEtqd6QTAp0tBOAORGAx8Y8zre6QZluCIAiCAEgAp+S7776Dy+XC+PHjMXPmTM36//u//wMAfPTRR/v61AiCIEYczgAvgMOxOESX4vplRRwAgK93tENMkQ/sCUawcEMzdrZ6gPqVyorKIzT5vwDvAGeZjbCatNsU2hIthxgBfHnGtzAIqnMQY8CaV/gWSHlD1AEG+DzgrCLAaOYFcMituLqNjAAezYRPs3nAeiT+BqwAtrpStLhyNwPeNs3iHATg9Qcx0b0clYKyflOjS7MtQRAEQQAUAp2S9eul1hiHHnqo7vrk8g0bNvTouA8//DB27doFq9WKqVOn4rzzzkNJSUnfTpYgCGI/Rx0CnQM/jBGlEnSh4AYARGIifOEYsq3K7U0URXywrgkPLNqKdk8IJoOATZO+h1yfecxRuq/JCuBMiySAQ1ElL9hqMiDTnAi3ZipBZ4SYfNiCcYCjVppe/TJQweSmDtUQaEDKA173mjSdWyH9bysGjFYglnBXXQ1S/nPjWn6/JN0K4BUAwBXByvXXAXoR7O4GwKvjACOAvI2PY+qu53GWxYjjQo+jFYXY1OTCKQeVdfMmCYIgiJEICeAU7N0rtWyorNRvUZFcXldXp7s+Fbfddhs3/9vf/hZPPvkkrrrqql6cJUEQxMhAXQSrQrBz84XwyNMOX1gWwKIo4vrX1uCTzYp4isVjMLKupV7VY/BFsDLMBljNRiCotDgqtFmUPFNVJWiZ438PfHQzEI8AnibAx7iYQ60FEsvB5wNLH5FE7mE/l5YJgnTOyTZFrgZAMALhxGcvGICKQ5RjFOiEQNtKlc+gYRUQj2F0gSKAq9Cs3QeQwsf1HGDBj/IWqcCWRYjhGMMmLIgfTw4wQRAEkRISwCnweiVnISsrS3e9zWYDAHg8Ht31as4++2yceOKJOOyww1BSUoLdu3fjpZdewuOPP45rrrkGRUVFOOecc9I+v6lTp+ou37VrF8aPH5/2cQiCIIYD6jZIFQJfKKlYUASP0x/BmEJpele7jxO/ADBeaII5wog2vaJPAIJhxQHO0AmBLsiyKDOWFAJ41KHAgWcBmxdI83FFQKN4ov4+Q4GMPOCmdVJ15xzGSeUEcD3ga1fWlRzIOeG6OcAHnw+sfF4KCQ97AHsNcosnIdtqgjcUxQGCIoAjohFmIfE3cDXoV4FGAJkhJd83T5AKkW1qdPf4LRMEQRAjA8oB3kc88cQTOO+88zB27FhkZmZi6tSpeOSRR/DMM89AFEXcfvvtg32KBEEQQ5buHOA8wQ8TJHHJiuXaDp/mWIcZdiozpQcBGbm6r8mGQGeYjcgw87G5cv4vkNoBzqsEjriaXyYYgWNuBsqHeKseo4kXv4C2EFaqAljJbQXVY0bFDL73sacZgiAk8oBFVDMCeKuRKcTVspEfPEhQIHiRFXUqL5kQwC3uINo9VAiLIAiC0EICOAXJqs9+v193vc8n3WRzclI89KTJ1VdfjdLSUmzfvh21tbVp77d582bdf+T+EgSxvxGJxeENKeJHELQCGAAKEmHQrADe2+mHFWEIUMKZDxUYATzmyJSvGY0rhawydRzgbgWwNVcS11XHSH2ABSMw8VTg+mXAj+6T3shwQ90KKVUBLAAwWYBcVZh30QSlTRIA+DoAANMr81ACJ7KFoLxqRxZTgLKJyTNmyBf4AY48KPObmigMmiAIgtBCAjgFY8eOBQA0NDTork8ur6qq6tPrGAwGWbQ2N6fIfSIIghjBqN3fI6oKMQpaAVwkeDTbm2qXYJX1enxt+S3yEwL5UNYBrtQK4Dq7D/O/q+WWdS+As6EhKRYFQeoB/MdW4KdvA6XalkvDBlYAd+wAWrco85WHa7cvUN0jiyZILZWSJATwHadPwXXTlMV2MQcVk5njse2jjMznriKXEcSbKQ+YIAiC0IEEcApmzJgBAFizRr+nZHL59Ol9D2FzOKT2Hcm8YoIgCEKBrQBtMRpw8oGlKFflAANAUSIPmHWAD278L3KEAMYa2nFx5krkwYuJBkZMqRzgTY0unPzI13hg0VZueaZFGwLN5QDrOcDqIldG/V7Cwwr2PTWvl3J5AakatE4vZS4POLMQyCpUCWAph7go24qrpymfZ05ZNY6ZmeL+Wpg60ol1gDeSACYIgiB0IAGcgmOOOQZ5eXnYtWsX1q1bp1n/zjvvAADOOuusPr3O5s2bsX37dmRlZWHKlGHsChAEQQwQbA/g/CwzjplQjFE6IdBFyRBonyKAM0Md8vRB2X5MEpionswCoLCaO8ZbP9Rzoc8AcNzEYt0iWIU2RtBadfKIh3KV597C5gCzjD4UMOj0L2IrQRdNkP7nQqCZIlquennSUlSVuk2U6m/GnR7jAFMhLIIgCEIPEsApsFgsuPHGGwEAv/rVr+ScXwB49NFHsWHDBpxwwgk47DCl6MdTTz2FKVOm4M477+SOtWjRInz11Vea19iwYQMuvPBCiKKIa665BhZL6rAugiCIkQoraAuyLDiwPAejDFoHONkL2JEIgY7HRdhiTnl9VaYfRQIjinIruTxcURSxeLvSaueMaeV48tKZePEKqU2S1aRygNkQaEsXIdD7E3kpROnMn+kvn/JjKfcZAKaeJ/2fpc0BBgA4FQGMvDFAdqmyL0vl4YiZdT5vAPmMA9zoDOC7mg7d7QiCIIiRC7VB6oI//vGP+OKLL7Bs2TJMnDgRxx13HOrq6rBixQqUlJTgpZde4rbv6OjA9u3bNbm8K1euxH333YeqqirMmDEDWVlZ2L17N9asWYNoNIo5c+bgwQcf3JdvjSAIYtjAOsB5WWYYwy5kQlvht0gWwJJgbvOEkA+vvL7c6OPaJcFWxO1f0+ZFgyMgz9971lSU5mbI8xlmlQPcbQh0Crd0OGPOlASsnxGWBeMUcaumZBJw0xrA06qEm7Mh0OxxXIw7n1eZcJR5Nx4VM4Cjfon48n/DGPFCTZ7gw8TSbOxsk9b96vU1+OjGYzGmUL+lIUEQBDHyIAe4CzIyMrB48WLcfffdyMrKwvvvv4+6ujpceeWVWLNmDaqrU4dhsZx22mm46qqrkJubi++++w7vvPMOampqcOyxx+L555/HF198gczMzAF+NwRBEMMTNge4IMsMuBp1tyuCO7G9JJjrO1zIFZRK/tkxJwrB9G5nhRjAub8Hj87lxC/QjQOsJ4BThfAOdwyqsfNjfyu1TEpFwThg7FGK266TAwxAK4ABbZGyS98ELLaUbafyBB8evegQOVzd6Y/g2ldWIcD0dCYIgiBGNuQAd0NmZib+/Oc/489//nO3295777249957Nctnz56N2bNnD8DZEQRB7P84mKrO+ZkWviIwQ6HAt0FqaWni1lvCnSgSCuR5MasYbCOir7YpAvjEyaWa41tVDnBRulWg9zeyigBvizI/49Ke7a/TBgmiyOUAIz/hns+4BKhfLuVrX7ZA7iEsZOTpHtqKCKaVWfDQBdNx81vrAADbWjx4f10jLj1ybM/OkyAIgtgvIQeYIAiCGNKwbY3ybeYuBDDvAHd2tHDrTcFOLgc4nKGEQLuDEayqdcjzJ07RCmB1Feh8LgRaXQRLkMXafsfMnyrTZ/wDMFl7tj/rAIfcQCQIBJ1AmAlpToaPH/5z4DcbgJvWSoW2EhgzdIqOJQk4ce7M0Tj3EOXzp4rQBEEQRBJygAmCIIghDR8CbeFCoDvFbBQKknBKhkB7Q1GEo3G47bwANgSdKBMUkes3FyAp3b7d2SFXfy60WTCjMl9zHmwV6ByrCRa2KrQ6JDenYv9oe6THEddKYcimTGD6RT3fn3WAASkPOKD8XWDKlFzmJOpewgCEDP0QaACSmM6twGFVBXh/nRQFUNOmzRcmCIIgRibkABMEQRBDGs4BzuQd4M2i0maHdXedgTACTiWkOclEQQmL9hrzpWM0ufDkVzXy8hMmlcBoENS7cgKYy/8FtFWg99fwZwAwWYDDrgRmXMxV0U5/fyvvmPs6VBWgK7s/boocYABAwAkAGF+q/E12kQAmCIIgEpAAJgiCIIY0DsYBzs/ic4BnHnmCsk7wwYQoAEk0R7zaXsH5giKEXIZ8PPbFDpz15LfY2qyI51MOLNM9DzYEWiuAbQCbUbw/C+D+QJ0HrFcAqyus+jnAAGQ3eQIjgO2+MNdOiyAIghi5kAAmCIIghjSsA6yuAp097jBu24JE26NGZwDmkANdscufice+2Ik402nngkMrcca0ct3tS3KUXNcxBarK/YLAu5Kp+uUSEupK0C6VA9wdXTnAQScAoCTbitwMJdOrpp1cYIIgCIIEMEEQBDHEcQYYBzjDyIul4kmAWenxmgyD3tjgkqtCp2J1u+LoZpqNmP/zI/DIRTMgpAi/PW1qOU49qAzTRufh+jnjtRtwAng/7AHcn3QpgNP47NIIgRYEgcKgCYIgCA1UBIsgCIIYsgQjMQQjcXm+SLQDMSaUtWAckFUMuPYCSFSCFoENDU6cLqQWPEHRjA1tUXm+usSGOTqtj1gyzEY897PDU2+QVaSEZxeM6/JYIx62yJWvnQ+Bzu+jAE44wAAwoSQba/dK81QIa/+lvtOP8rwMmI3k6xAE0T10pSAIgiCGLGz4MwDkBpkWSLZSqf+uTRFTyUrQ6+pdKEBqB7gDedjBCKKKvMyU26bN7BslN3rsbGD8SX0/3v4M6wD77T3PAe6mDVISNg9YHQIdjsYRicVBDG/+tbgGx/19MU5+5GuEorHBPh2CIIYB5AATBEEQQxa2AFaWxQiLq05ZmXRZGTGVDIHu8IZQaEktgO1iLvxh5WF5VH5G3092xsXA1HN73hd3JMIKYHcj4GFaVvUiBzguCjAIiWRu1gFmBTAz4LFmrwNXvrQSNqsJb183G5UFShg9Mbx4Z7U0eLK3048Vuztx/KSSbvYgCGKkQw4wQRAEMWRxqHsAO2qVlUkBnKVUFC5kWiHlI3XIq13kHcR+cYABEr/pwlaBbl4PIFmJTABy0yggZuX/fg0iczzGAR5fogjgRmcAgWAI2PA21n4yH55gGM2uID5Y1wRi+OIJKlEi7mCkiy0JgiAkSAATBDHy2PUV8MwxwMJbAVHsfnti0HAxIdB5mWZeABcmegBzIdCK69tVEaxOqAVwPzjARPqwDnCAqdadXZbeIILKAd4pMq4xc7wxhVmwJPo3iyLg+O5FYME1uLrpXpxpWAEAsHuHcHukoGuwz2DI4wspkRzeYLSLLQmCICRIABMEMfL48s9A6ybghxeAhh8G+2yILnCwLZBsZsCxR1nZRQi0CVHkCv6Ux+3QOMAkgPcpthRhqun2T1Y5wDXiKGWGCYE2GgRUF9vkeaHmC3n6aMMmAMCBTQuAF08DNr+X3mvvK/73W+DBscD7Nwz2mQxZYnERgQgjgEMkgAmC6B4SwARBjDzYgjv2XYN3HkS3sCHQ+ZnqEOikA6xUby4VJPcvH74uj6sOgR6V308h0ER6sCHQLOlWz1Y5wDUiEzbNhEAD4FohWR075enRgh358ODc5seA+uXARzcD8SFSRCnoAlbNk6bX/Qfwdw7u+QxR/GFe8LJuMEEQRCpIABMEMfIIKnmi8LYO3nkQ3dLpUwRwmTUsVQxOkhRLuRXKNgkBXNBND2BWAAsCUJZLDvA+JbMQgE6/5Wn/l97+1hwE8ycAAJrFQmyOj1PWBZ1cakMyD9iCCPKDyuDXKMGOaqEZZkSU/VRCMx4XYfeG0jolhy+MX/1nDa5/bXXa+6TE3QwlLxqcq00osIXsAMAXJgeYIIjuIQFMEMTIIhIEYszDaR8FsN0b4kQa0b/sZlrXHJTBiBNThpQvCgA5SvhrKZwQEEch2wLJou0Zy+YAF2db5TxRYh9hNAFZhfyysmnApLnp7S8I6DzrZfw9chGuDN+GdjFPWRcLA5GAPDsx4QAfIDTDAKXtUYVgxxihjT+uT5kPRWM444mlOPyBL/DC0t3dntKbP9Rj4cZmfLypBa8ur+t2+y7xNHOzDS1tEKlegQZ1yDOFQBMEkQ50xycIYmShLirTBwG8us6B2X/7Ckf99Qus2evofgeix+xkWtdMsnYoKwrGAYbELYxxgM1CDMVwI591gAuqAIOZOy6bAzyK8n8Hh4DqN3P87yQ7Pk2yKibh6di52C6OhRs2fiXjmB48WhLHEwS+2nO2EMRUg0qo+trlyW92dGBbiweiiLQEbb1DyTmv7eg6BL9b2LZQAG559Vt8uJ6qVavxq0KeqQgWQRDpQAKYIIiRhVoAe3ovgD9a34RwLI5ITMR7axr7eGKEGn84ikan4uSNAePWsbmi1hzO5S0TOvkK0FmFmpxTO+MYlpMAHhwy8vn5A8/u0e7ZVpM8HYIFIViUlUwe8LiiLORmmDDRwOT+JzjKsJVf4FMGWXa0Kt+hdKI8fIz7yBZv6xUqB9gmBPGbN9f17Zj7IWrH10cOMEEQaUACmCCIkUXIzc/3wQF2MgWa2jzBXh+H0Gd3u09O5cwwG5AXZAYZ1MWSGBe4XHCggA2BziriegUDQCcUwdxvPYCJnnHoz5TpC+crjn6amIwGTgT7jUyoO+MuC4KAGWPyMUHQDlIdLOzhFzAO8PYW5TvkCUYRi3cdgswWYGKvDb1CdV3KhjQQFI3F9bYesaiLYPVXCLQ/HMXbq+qxuo4ie/pCbYcPt7y1Ds9+vYtC+Ikhhan7TQiCIPYj1MVk+iCA3Uy4Xbunj0VvhhHtnhAyzAbkZJi737gP7GxTBEh1cTYMzlplZbICdJLcUUDHDgBAudCJAkEJnUZWEWBTHmS9yOTcwlH55AAPCifcDuRUSIMXB53Tq0PkZphk0RM05QKxRJE01e985ph8TKjThhAbBdVDeQoBDACeYAT5WRakgnUfO/sqgHUcYADY3urB1FF5enuMSHwDVATrH5/uwEvf7YEgAF/ecgKqS7K734nQcP/CLfhiqxS5U11sw6lTywf5jAhCghxggiBGFuoQ6JAbCKfuF9sVnqAS5tje16qvw4QvtrTiqL9+gVl//RJ19j7mOXZDDZP/O7EsG+jU6QGchCmEVSF0oipTCZ1WO8BOgRcQ5AAPEpYsYNZ1vRa/ALhBmLCJdYCd3HaHjM5GtZBGDm1CAIejcexiCrABgCvQdVgzK76cvr6GQPM5wEkHeO1eZ9+OO4h056D3BnXIc3+1Qfp6hyTaRBH4oZZaUPUW9vv6zmptCgJBDBYkgAmCGFkE3dplvXSBPSoHeCSEeL35Qz3iouS8LNrY0v0OfWBnKyOAizMAV72ysosQ6GtmZOBHVYw7ncnnAHuM+dyu5AAPX3IzlUC2qIUZ2FA5wIdkO2ER0hBHXkkA19p9iKoEmzvQtbvIht96QlFE+hKurHKAs4XhK4DjcRFXvLQSh/z5M3ywrn9rJagFcH+EQIuiiAaHMoDW3cAHoY/dG4KdyZ1fsr0drr7mxhNEP0ECmCCIkYXaAQb6RQAHI3F4RkABFrYolTMwsO2fahgH7uAcHxBnPt+CKn7jHEUAWwOtEAKMa5NVxAlgn6mA25Uc4OFLAROSHM9gBLDKAS70d9/GCIDsAKvDn4HuhZC6IrGjt2HQoqhxgG2QQqDXDsNq86vqHPh6Rzs8wSj+tbimX4+t7gPcH1Wg270hhKLK4AUJ4N7BRvAAQDgWx6JNzSm2Joh9CwlggiBGFv0ogN2qB6ORkAfcyLR6GciWI6FoDHV25bUmZLBFrYoBs0q05ioh0HA3A347s30hcNB5gFESS+vyT5VXGQSgNMfar+dO7DsuOXIMLCYDirMtGF3BfAd8qv6+7dvlSbfYxYBHQgCzFaCTdBsCrRoAc/bW7Qo4pF7GDLZECPTuDh8cw6zvOFtBu9nVv8UC1Z95IBLrc6g16/4CJIB7S40qhQAA3l9L3RKIoQEJYIIgRhbqKtBAr1ohxeMivKqCK/u7APYEI1zhL09fBPDe5cDeFUCKsPHaDr/8IGsyCCg3OJWVjNuru8zdyA9qZBUBxROAW7cDv1mPXaWnyKtKczJgMtKtcLhy0pQy/PCHU7DsjpORVTFZWdGmam/ECODv4genPmCiDVJPHWBRFDUFmHotVD1alyxbUITjugZn7447SAQjikvrCUYRjvZfJWu9old9LYRV38nXhHB1E/pO6MOmsCRZsacTTc6AztYEsW+huz5BECOLfnKAveGoRrvt7wK4ycm7N2wRsB6x5QPgpdOAl04Fti3U3YQNnzug2AaTj/kb5ZRpd2Ad4LAXiCQeYg1moHiSNJ1VCBSMQ26mkh9cQfm/w568TDMsJgNQPl1Z2LIJiDPhsR2KAP4mzmynJuIDwr4eO8CBSAxq47HXIdB6AhiKaFg7zFrzBCL9FBqugzrsHOh7L2BygPsHdRG5JB+uT6MYHUEMMCSACYIYWegK4J4Xc1KHPwMjQQDzD4a9doDXvaFM7/xMdxO2BdLEsmxeFOTotNKwlQCCUbt81CFStWGGshxF9I4rsqV1ysQwoPQgAII0HfHxVcMddfLk9vgY2MUcpCLobEVdp7YyvLuLAR+96sOO3oZAe7TXIxvjAC/e3o5tLW7EU4T6hqKxIVWQL6DK07V7+08A6xW9IgE8NGAd4EPG5MvT39V07NPzWFfvxO3vbMDi7W3db0yMGEgAEwQxstCtAt3zG6Oe+GsbZgLY4Qv36GGxoR8EcDwWg6/mW+Yg+oMPOxkHeEJJNr+dXgi0wagvjMfO0iw6d+ZoTBudhzGFmbj62AO0+xDDE2s2UDRemW/ZIP0fdHFVoRtQCq81dT/S+oY63cj8roSQ3u+osz9DoBkHeGOjC3MfW4pzn/4OflW47+dbWnHYX77A6Y8v7bMQ7C/UDnCvPxcd1EWwAMCbohVSLC6mVZm7wcEPfnhIAPcYTzCCFrcyaHPJEWPkab3oioFCFEXc+PoavLWqHte/thodI6RdIdE9JIAJghi2fLKpGf9aXNOzEXo9BziFCOsKPfE3nBzg99Y24ND7P8cJDy/GunpnWvtoHeCePxhuXr8StjjzAKTzsA8ANYx7MKEsp3sHGNAXxmNnaxYV2iz46NfH4pvfn4iDR+dp9yGGL1wY9EbpfyfTPsuUgSX3XoSq6sncbmFBKYTWuXcL7jPNw+9Nb8IKRax1dZ3RcyKdbKhvJCgVt0oHnZoENgRhs/ARDhsaXPh8C7/tc9/sgjcUxbYWDxZuHBoVd0MqAWz39d91Ui/fV684X4sriDn/WIyj/vplt5W0yQHuO2wKi81ixPGTSuT5Vndon7VD6vCG5b9nMBLH8t32bvYgRgokgImhgSimLIbTK5rXAzVfAvH+K7ZBDC0+XN+E615bg4c/3Y4HFm5Jf0fdEOjeOMA6IdDDZHTZG4rizx9tgShKDwg/n7cyZb4WS6PqwbA3bZ/itd/xC3QEsDcU5UKgJ5fldO8AA1wvYJkxWgc4iSAIXZ4rMQwpn6ZMywJ4r7IsbwyyrGYgr1JeFBcF1FsU5/jw9XfjCtPn+JXpQ5xt/F5erpf2kETPbZVDoB21wCOTgEemALuXdP8edItgBbDoN8fhl8dXoyJPCeFXFxra06G4l+rftCsQwdNLavC/DfswB9Nnx8y6l3CKYbW8qD8dYL3PXW8w4v11jajvDKDTF8ar39dp1ieJx0XNdc4ViPRLSHmLK4jfvLkWf120tc+Vqoc6rAAeX5qNirwM5GQoPbt3tO0bF3hvp4+bX7mnM8WWxEiDBDAx+Nh3Ac8cDTx3AuDqhxL59T8Az80BXjsfWP6vvh+vj6zZ68CdCzZi2a59m/eyP9PpC+OmN9bK819u7YGA1asC7WvjC+akgV4+4HBxgF/5vpbLT3T4I/jZiyvR6u66RUmTM4BxQjOmCnsAiPCGoinzEFOR3foDv8DXDsT4z3LdXqdcUCgnw4SJpeoQ6FQO8Ch+vngyYCvq0fkRwxxdB5gRwPljpf8ZAdyMQrQJyvfEKCrXghutSpG2rgSwXiiuXAV6/VvSwFs0CKz9T/fvQSciJVsIoKrIhjvPOBCXHDFWXr67QxEa/nCUC/Hc084//D/2xQ78/ZPtuPH1tfvOCfviTzix8Vm8YHkEkwXp79C/Aji9IljptmJq84QQVoVJR+Oi7t+3J0RjcVz7yip8sK4Jz32zG2/9UN/9TsMYVgBPKM2GIAiYVKbk3e+rMGi2lR5AAphQIAFMDD4/vAi0bZFc27Wv9f14a18FxMQNbMenfT9eH4jHRdzw2hq8sXIvrpr/A9o8/dsDcaRy//94xzdtJzIWlSoEqxHjfN/YNBiuIdDeUBTPfbNbs7zD6ULt/GuBN37CFQxiye7chCXWW7HQ+gecY/gOothNy5HdXwPf/lNx2EURpY7V2u1UVbhX1SkPKYeOLYAhGgBCjHOfrgNcpQ1/JvZzWAfY2yJ99/QEcNlUedGWeBXaRf1QeI+lVJ7uaQh0stpx2MkM7KZzndERwBmISNcvANUlSuG2XW2KyFWH7tbaeQG8oUH5DX29o7378+gP6pUBr8MMOwEA9n7NAU6vDRL79+kqBFud/5ukr2HQ85fVYmOj8vl/tqXnaTfDCbUABoBJZdnysh06bcYGArUA3tbi4VMTiBELCWBi8HExI6G9aEfDIYrAzs+V+RQP8vsKTygqF4IIRuJ4YemebvYYgrRsBNq2DfZZyCzd2Y4Fa/lIgSKbJb2d1e6vwFwCe5gHrCeA7b4QomkUWRlMXl5WC2fC/bVZjLjqGKkI1I8Ny3FU54fA9oXAf3+mccQjsTgOCSyX588wrgTQRSEsRx3w6nnAF/cCi34vLXPWISes8+Ct+uxXM21eDq8qUFXpFgBbKXTJHc3P6+T/Evs5OWX896NlI+Bk7gNJAVx9IuqnXo/PY4fhoeglaI3pV4WOZSq5i7IICmtFkp7r6PRH8NK3e/D1ms3KQqYYly7xeOqq9GFJNIwvUYTEng6fHE6r7l9ba/dzERqsg72pUScVZCDwK5FPJXACADr7sQq0ngOsNxjB5gV3dPH69QMggOs7/Xjksx3csu932bn+yPsbbBHDiaXSb4t3gLtPuekP9upUc/+hdui3EYvHxR5HVxE9gwQwMfiwI+JhX+rt0qFtC+Bh8pvcDZrwyn2Juv3De2sbh1fuz7ZFwLPHAk8fBez5ZrDPBgDwpk7omN4Djy7cw6cA5CmVKXs6+KIXAi2K/Rve199sanThmSW75PkrjxmHkw+UxMJhBqVPKprXAavnc/u2uILIhvIwUSo4AXQhgBtXA8lQ0rpE3m/d9/rbupXfbCwuYu1epzx/2LgCXiBnlwJGE3RRO8M6FaCJEQCXB7xB3wEWBDhn34lrI7eiRqxEczQbeuQZFbfQHYxC/O4J4MExwKvnczUmfDohsp3+MJ79eheKE8IPgH4NAha/HYin+E2FJNFwQLENyfT1cCwuu5bqh/1wNI4ml+IKsyJuc5N74FslxWOAX4nmSF4z+usaGY7GNeHKgH4RLHaAwuEPpxyobOgM6C7viwC+76MtmkrYoej+W5ApGIlxAwmKA6wI4J37KAe4zq59plwxxD/3FlcQJz6yBIfd/3naBSqJnkMCmBh8fExurF54ak9g3V9ACm118YLp+W9248dPLsVH+6AZuzo8q90TwuJtw6gX3dYPlentnwzeeTB06IQZ+8Np9r1kWyBl5AK5TM5oTwVwQP8hdci0Qgo4uMJytR0+XDlvpTxYkGM14Zpjq5GfZQYAlAiqB/Mv7wO8ilvb5AzABiWEvyTxMOsNpXgwZH/XvnYgGgL2LtPflhG421rc8jkaDYLUPzKdCtCA1AfWlJk4wQOB/KrU2xL7LxWqPGBOACvfidxMZSClMaIvgHOY/ruxeBxY+qgkUHd9KQ3yJEjlALd5QigG89sKOPXPOeQBFt4KzJsrL4oYMxEUzco2iftjpsWI0fmZ8uJksat6HfG2p0MRAOygXacv3GUubL8QcABQrkHJa0Z/VYFWDzDLeNukz3LJg/IgBTtI2tVApTqMPElvBbA3FMUXW5V7S3G2Um18yfaBCUNfXefAda+uxls/7NVdr34u2dTowgtLd/dbilaDIyDfekwGAWMKpO/qRCYEusMbhn0fFI3Uc4BX1g7tPOA3Vu5Fnd0Phz+Chz8dOtF3+xskgInBhwmRQqiPo4JqAQxwYdCt7iD+9vFWbGp0494PNw/4CLhe4YzXVgxuWHaPYJ03veJRg4BeflcsLiIUTSP0mHVfrHmSm5ikxyHQ+g9EQ6IS9LKngL9XA8+fCMSicPjC+NlLK+XQP6NBwGOXHIICmwWFifDxKkE1ABB0AV/9RZ5tdAaQIygPh1I4owh3KgfYp3q4czcCjUrhMp+oPAiyAnfr9m243fQGfmRYhamjcpFlMaVXARqQCl5d+jow6wbgwvkAVXkembAO8J6lfORHvlJAKjdDEZcd8VzdQ2Uy/Xfz4YUQZMInO5VoitQ9d0VZ+AGQfld69511rwM/vADYa+RFXkspvFCELnt/ZMOgk3nAeg/7tQkBHIrGEIzw18jNTQN8TWcHwdBHB1gUgdYtQET5e3hT1B84sulV6bNc8jepJgi0UUKprtP9HQK9l8lBtZoMuPmUifL8QOVh/+G9jfhkcwvuXLBR44C+9O0eTL/3M1z63HLE4iIcvjAueW457l+4Fbf+d32/vD5biK0o2wKTUZIaJdlWFGQpv7mBDoP2haK64e6bGl3pR40NAlubld/l97vsw6K2yHCEBDAxuMRjfG/EvoRAB11A/XLtcketPLm73SdXl7X7wpoHgv5GHfYESDe9vXb9m+yQg3VF9QYnBjqETge9nC9Af7BBAyuAM/L4EOjOnuVnpwr9HRI3qxX/lqIfmtYCdd/i/oVbuYfjv18wHScfWAYAKMiyQEAcYwWdyIStH8mTTc4AshkxYBWiyIc3dQi0T3U8VyPgUD7j1fFJyjpG4B664hZcb/oIz5r/ibmliWtDug4wAIw/CZj7N6B0StfbEfsvbO43+z00ZXCDXmxbFjv0BbAl6kNWov+uZpCIuWakeqDOQQAZAiOe4hEgonP9b9/OzxtMWFF2CbxiGgI44QDrFXDanRDAehErA54HrCr4VZyIMnH4Iz2vlfDZH4FnZgNPHi7nYPtTfOZzOv+rzHx0EwDtAIU9RR4w6wBbTcojclcVwLuCve6OKczCiVOU79+eDp9uiG5fSf7N46LUhYLlhaW7EY2L+H63HSv3dGJdvVP+7i7fbe+XvFNWALOOtyAImLgPw6DZz95iMiA38XuPi3ydiaHGdqZCdlwEPtk0NPp572+QACYGl4BTqdgM9C0EevcS/dwppgBKs4sPb9LL4+xP9FwBUQSW7BgmYdCcA6y6WW34L/D3A4C3Lu+dEG7dDKx4jguzTYdUD5qpHRgG1sXOyANKJivz7T0LNWK/O6zROOgCWBS5Ijo1Ndvx7poGef53p07CBYcpLWAyzEaMNXv4h/QkAYccQtjoDMAm8L+fMsGR0glXuz9o3cT9vlfFmc8+mbffuAbVwU0AAKMg4kTDusT6NB1gggCk1IaSA7XL88ZwP1aT0QBbQtx2pKgCbYh4kZcpuVaaQSJmQCfVABzn/ibRywNmI6GOug64dTu+zT8LPig9f9nfz/hSphJ0uxeiKGqKYAGKA6x3r9vcNNACmL8GJKNGAHBt2LolHlNqErgb5F7KennXqfCqBk47dBzgWFxEk1O5xk2pUAZFunSAu7j/sX+TsYVZGJ2fKbV1S9DfYdDBSAxhJhpqa7Ny3xZFkUvRqbXzAjwSE9HRD+HpbJoSK4ABvhL09gGuBM1WgB5TkIkjDyiU5z9ctw97YfcAfziqieT43wYSwAMBCWBicFHdIJNFPnrFrsX6y5kQaPbmBvR+VDddUuUodVWFcsgQDQMBJldGLYC/+YckkLZ+CNSv7NmxAw5g3unAx78HFlzbo11TCd0u2/Ek4RzgXP4huX17j4Q863yy+XipBHDKfLWe4moAPr4dWPeG/vqQB4gp368lqzbI01NH5eK6E8ZrdpmakapHtShXnm10BjkHGJBCGuXPIewD1rwK1CXyfNUh0MlCWAC8Yga2i4z7nhC4/u9f4Hap9q3j1gPo3gEmCECKBFDDhD8nyU2IWy7UmEEI+7oQwLXyZKqBuRLoiEy9PGCmWBRKDwJsxfAGo6oQaOX+WF2sCInd7T50+sK6gnCP7ABr73WbGvdtCLRViCIP0vn0KAy6bQs/ON4hVVROa9AzgbpWgZ4AbnUHEWUc0IMYAZzyWWH7J8Ajk4HX/k9uU8WyVyWAAWDOZKWy+NKd/SuA1QMdbDitNxTl3l+t3YdaVTRaSz/khbPPN2oBPJl1gAc4BHpvpyLuq4ps+PF0pebHh+sb0dZN3/vBYGerV/MYsrK2E61D8FyHO/tMAEejUTQ3N2PDhg1YuXIldu3aBbd7aOQUEoOI2iXqiwPsZlrjVByiTDMPKU2qi/tAO8CpXAHXcOhDpy4KpRbA7Hr2s0+HxjWKGK39Nm3hGY+LKT/TVKHRHOoQ6BImDDfs4aoRr6rtxC9eWYX/6lSdBvgcYDYcUS2ARVHElfNW4uB7P8XTS2rQJyIB4JVzgRXPAu9fJ+XEqVENKpn90t9JEIAHzpsm52OxTLQo+zjzp/IrE4XDGh1+LgcYAErhVD6Hrx4APrwRmHcG0LZVRwArFaDrxRK0iAXKOk8zEHTBsvVdbhdr4wrpoZINgc4mAUykQboCWM4D1s8XF8Je5Fm7D4FOJcbSd4CZcOGsIgCSYPGJ3TvAdl8YG1KEM9c7AojE4roOZos7qCsE+8qXW1tx4bPLsHqr9npX2ptCWKoB1j3b1+HNlXtTurJu8AXNoj6HJt1JbxCadUfzMs0oz1U++5QO8LePSvfCms+BXV9pVusJ4JljlWtfk7N/hY061J11gB0+/j3Udfg1bmN/nA8XAp3DtyhkQ6C3t3o0dVjcwQg+3dzS577LAO8Ajy3MwpnTK+S/aSQm4pXvh149Fj1XXBSBRRvJBe5vBlQAf/3117jzzjtx9NFHw2azobKyEjNnzsTs2bMxadIkFBQUoLKyEj/5yU/w73//G3b70C5NTgwAagc47O19Xinbm7H8YGXa2ZUDPLCFEPwp+vw5B9h57he6EsCiyA9W+Hv422UGJRCP8O5HF6hd3lwmh09d2VKXoCoEOiMPyGEqQTNh0Le9swGfbWnFne9t1HxvAN4B7koAb25yY8n2dsTiIp5evKtvhdcWPwDYdyrzbToC2Mf/LcoFKdfp8llVUkVlHQ4wKM6WI7MKMCsP1wi6IIoimpxBrgo0IIVAyy1HapcmlopSyyz14BbzW28QS9EiKuFoCLqA1fNhiqkevsIeqY0NOcBET6k6GjCq+oPnj9FsxlaCXnvwXYgLJuyKs2H2IoozpOv4WIPKAfa1ya5sKgFcrK6uDuj3AmavobZiANI1hguBZlI4SrKtXA7z10wo7YTSbBgSej4Wl0KjUxWrG4hCWH94bxN+qHVg085dmnUlvSmE1fADN9tZtwl3LNiIF7/Vr9ugFsDB5u2abfS6CbDX7pIcK/KY70ZKQdbNQLCeAGaLr/V3MSb1oH6HNyS/L4dq4F0dAg0ALS7tva6ncALYxjvAU8oVAewKRDgHWhRFXPLv5fjlq6vxsxdX9LlIqfqzNxsNuPKYcfKy11bUpffcsA9h83/Z1CoKg+5/+l0Au91uPProo5gyZQpOOukk/P3vf8fy5csRiUQgiqLmX1NTE958803ccMMNqKysxE9/+lN8++23/X1axFBF/ZAcj0rtUnoDK8hKGRfLb5fFm0YAD7ADHEhxcXX2JP9JB1EUUdPmQaSnhUR6groqMiuAoyE+3zpNASvDCmAg7RZEape3lBmhTyscjnFe6vwm6fPj8oClByVvKCoXEonFRexo5UdlI7E450RXlyiCUd1Kgi1M4w1Fe18lun4l8P2/+GVsAbkEQRf/WZYJDhw5rhC3zU1dFGoMlH3aTaOk8HDlgAhF4whEopoQ6BI2BJo9F3tNl1XD68USdCAPcVG5w8e/fVx/4x2f8r9tygEm0sGSxRfDAnTbYrFiZG35RVh05vc4I/w3bptSi3S9Hqt2gAF5gJUNPy7NUR769Rxgn0s1YCiKug6wJxiFhyuCpfwOBEHgBt6WbFfEeXWxDZUFWfJ8rd2XMoS3vwtheYIRtCTCNQugvQaUJnoid/rCUnRH01og1s39sH4FNzteaAIgcoWMktXsAcAM/hobad2qOWSHjgDnBHC2FXlMxeKUAphN2wrw98FYXOSu/2OLpL9JNjNw0e8CWOc8t7VIf4dOlQCus/tRr2r71B+tsbgQaJUDnJ9l4XKg2Z687d4QtiRCttc3uPrcUYF1gKsSn/2lR4yVi9o5/RG8u7pBd19Aes7a2erhcqoHGtYBZkO219U7B75v9wij3wRwNBrF448/jvHjx+P3v/89duzYgezsbJx00km466678Pbbb2Px4sVYv349duzYgeXLl2PRokX417/+hZ/97GeYNGkSQqEQ3njjDZxwwgk488wzsWWLjrtB7F/oCafeVoJm9ysaDxiZkcdEHnCzUx0CPbCjf6xgMxuVh/2+OsB3vbcJpzz6Dc5+6rueV9NMF69aALsVd14dqt4XB1jntVyBCJ78cicWrGngLvrsw4LZKHAtFXoaAv3KGgce/HgbUMIIw3bpQUk9Kq4OC/Oqvjfsg2irO8Sds/qBolcVwONx4MNf8wXjAN3fT1MTf0OfkOnFG7+YhWyrSbNtkrKYMrrcZCyXnPEkQRf84RisiMAsqAYgBIfyG2K/A01r0RX1YgliMKIDyusYAsr+SwyzlI03vaNMC0bZHSOIblGHQXeRAwxIA6KOqBUhmBERjfLyYksYVoRRDp3KsYkwaHYArrJAEa16OcCNLSo3J+TmBxTZEGg2B1h13WWvO6yTNqYwC+OKlUG53e2+lAJuxZ5e9ERtWA188CtpcEpFq1sRLYU6AljuBewJAa+eCzw3B3j1vNSRX74OoHM3tyhf8KFIdWx20MEq8kJPTOQMs+g5wOzgZWmuVc79BlILYJEdGFZdj1vcQURiyvsakxiUYK/F6ntJX9Gryr8tEQbtVAnggKpgFtBfAjh1ESwAOKpaif5hv3/qc+/w9D5VLBqLo5ExPJICOC/LjIsOVyJB3u+iGNadCzbiR//8Bmc+sbTfzAZvKIr//lCfsgDdNkYAn8jkiqfd6pFIm34TwAcddBBuueUWuN1unH322Xj77bfR3t6Ozz//HPfffz8uuOACnHDCCZg2bRomTJiAI488EnPnzsX111+P+fPnY+vWrdi+fTvuvvtuVFdX4+OPP8aMGTPw6quv9tcpEkMRdQg0IBfd6TGsALbm8A87zjq4gxF4VKOtA14EiwmBrshTHmT6kgMcicXx9iopL3Vrsxvr6p29PlZXxNzqvrii8hmr84H7KoA9vLPy4Mfb8MjnO3DLf9fjh1rloZN9yLRZTVKP2OQppBPKxLiSbtjw8cZmXQe4zq7Oi+JHydkbtSAAE5nKloFIjAutVxcVUR87Leq+069SHdA+vNrb+Bt6drgDRnR94ywKK/vsFct4ARxywxeKIgfa0LgyIZEDHAnwrV2aN2i2ZakXpVYgrWK+Zt13salomXiJsoDpi4rsMsBg1OxDELqkI4AZN84diCbuCQJXfKrAFEKl0A6DoCPSEtcyLyeAFfdVzwFua5Oud9FYHCt22/nfrGCQf3+SAGZDoHkBPIFx0ljGFmahmhHAtXYfF+3ECnTnzuWo+eZNqdJyuiy4Flj7GvD2zzX5zGxhoSJBey9P5gDHnPVK2kTtUo3IlVGFPyeRXGCFEkYAZ4K/vxr0BLCOu6hxgBMC2IworvC+BCy6jXu/jXYXhBhzHFVEDjvYWZJjRWbCeWRD18OxOELRfiqQCP2otmQhrE5f9887fS2CJYpi9wL4gCJ5esVuuzxgrB4M6IsD3OQMIsYU/GJ/kycfqLSiUkdsJXH6w/hv4jlrZ5u3+7ZJzRukQWqmdaAef3p/E257dwMueGaZprCV3RviPrtDmVxxoGdF34ju6TcBXFdXh1/84heoqanBe++9hwsuuAAWi6X7HRkmTpyI++67Dzt37sQbb7yByZMnY8+envXmJIY2q+scuOE/q/FOMuxEHQIN9L4SNCuAzVlAARPu5qjTuL/AviiCpVywKvKUB5m+OMB1dh9XyXFn28BUUnS26hR/SgpfjQOcqoqwDqLYpQMsiiI+36LMb2hwytOcALaYYLMqYiitlhhM7p1bzEKTK4hQAVMIq30bIIqoVTvAXbTPyraYUGSzwML0jGS3V4+o13X6AW8bV528Wza8qb9cxwH2dqoGLsSY/u8sScCJzKjyUFcTLdF1gNUtkACgFA5pMEB9HrGuH1zqRWlku1Us0Kx7PXYyps86VXJ71eSUdXlcguAoOxgYd5w0XT1HN39c7QAnB0VZ4VloCun3yQYAxx6IopjaAdbJAW5qaUE8LuLejzbj4ueW46aXvlBWZhbIgzzeYJTvA6y67p41o0IO52QZU5gpO16ANOjGDsqdMa0CMyrzMEOowXuWP2HCV7+E+O0/uWOkDLcM+4DORG5vxKe5jrUygqJQ0AmBTghgi0v1bJeqk0CK5eMNvAAuS6TDGBCHVdXSzeLUFuOy+8KanrfaHGDpu/Er0/v4mfgBsPLfwLIn5W3eXaYalFRdB9UtkJLYVNE4aUUvpYleXZNkWLHaAdZDfa/rKb5wjCs41p0D3OQKyr2X1Q5wX1oK1jEVoMtzM5BhVn4nOWwOdgoH/tuaDrBfD3UalIb3bwDWvAK8c1WXrR0XrJXyxIOROJ5ezH8v2fzfgiwz950BUhdV7SvxuDgiw6v7TQDX1NTgmWeewZgx2iITveHiiy/Gxo0bcfXVV/fL8Yihwe3vbsCijS24490N0kijrgPcixBoUZRuxkks2UDBOGXeWadbyGjAi2AxF6xRTKscVyDS64bzNW3K+7zB+AGO/uYyuS9iv6KXl5sUwOpBip44wAGHNj/Uqzxc7u7wcTlE7DTrsmRbTbAxDnBPc4A9kG4udcZKfr23VROm3FXueE6GCYIgcAMc7Ci6uvd0vGE18OiBwOMzgO0fd3/OkQCw5UNlfsxRyrSOAxzx6Dyoe5q1y5KwvUxFK+qC2RoB7Atr838B6WHWG4zonkdXKA5wIbe8XczF9vzjcOC4UcCoQ7Q7TjytR69DjHAMBuDy94BfLgUuW6C7CZsD7A5E5N82KzzzDCFtBegknXsQisa5h+XuHGAh6MJ/V9XjteV7AQDWMLNNIvw5FI0hHIunLIKVfJ1HLzpEc/yxhVlcxFGbO8RFO+VlmnHH6Qfi35Z/wphwtYWv/gJA6iN76XPLccQDX+LrHToP8urBNJUDrIRAiyiAVjSUJHKAbV61AF6h2VZazghgg3K9VzvAxdlWCAKQAa3Iy/TshQW8KI7FRc1ANFsFujTXitxMM0yI4idGprrznqXy5A87ePEvqgSwXgEsAMgyG7kCR/0ZBq03qL+r3YtwNJ5W4bFWd7DXzyYAH1puEPjc7CSlORlchMLyRB6wulVVXwQwe88eU8i3OONC0ENRXfGn7s/cpQCORaQ+94DUglAn4kAPdQsqNv93UlkODAYBmYxwHygB/OW2Nkz8w8c49C+f4+fzetjSchjTbwK4v4QviyAIGD16dL8flxgcAuEYahJuZTQuStM+HeHUmxDoWJjPobLY+IInjlouHyTJwBfBYkOglQcZUdTP1UmHXe3SZzheaMRt5rdQ5V0vhWb1M0ZfFwJY4wD3QACp3V+AK7i1UpWT1sm0y2CrQNusRm4kPb0cYCYEWpQeSHZ5LIBNCYlC+zatA6yKHmD/dkkHif37NnMCmN/3ivq7E99VUWod1B3bP1YefC3ZwMzLlHWqz90fjsIc1PlbdCWAmVYue8VSdAYigJUvguUPxTQtkAAgQ4hADLp69Pe3iznwJx7q1Q7wf2NzcPLBYyAIAnDgWcqKnArgrCeAE25P+3UIAgBgNAMV01OGzrNVoN3BiJzryQrPXEOQF8BsITZHraaQUVLsCIhrclUBIE/w4Y/vb5LnC5lQ4Q4xB9e9uhpfbpUGsnwpimAlmXtwOX590gR53mwUUFmQhdJcxXlr9QS5e11uphmzqwvlCvFJ4nERH65vwve77ejwhvCMXts29aC1SgAnB/9y4YdF0F6Tkw5wQWAvv0Iv1DkWBZrWKOfHDICpBXC21Yhsi0lXAAuIY5ygTumRxN73u+zyICUfAp2B3AwzTjWsks9ZeoMbgHgMdXYf2jr455eol/9sWAE8hhHABoOAbGbw1hPqv+cQvbSuSEzErnZvWsU3IzERHT1pUaWCDeEttFlgNAi62+nlAatrsvSlRRd73y3P4wUwm/YQiWlza0VR1Az+7GjpItLO1wGAEdFpDgirw81ZkZ2sls1HuQ2MYeMKRBCNi+j0hXv9XDoc6dcq0M3NfS/T/Ytf/KIfzoQYijQ6+dGuNk8KB7g3IdBq19hi4x1gR53GiQMGPgeYDcsty83gRn2dgd7lAe9KDCJMFpgQZXtNz3K40sAS1Bn9TwoxvRzgdENo9AQw4zZrBTDrACvvUcoBZkdHu7lwx+OaHGBAcpxRyhbC2q5xgFtc/Kg4e5NI5nOxjkuylUQ8LnJ5PgLiKIkzn2vrxq7PGQA2vKVMH3g2kMsMCqputFua3NzDtHLCOtdmUZRynvd8LS+qE8vg9EV0HWCbjgMMALZQO8QeRAAk3V8AaIUigOOigDdiJ+GgUQnxPesG4Ix/AGc9Dvx6DXDYFZKjRxD9COsAuwJROSqIdYBtQoAPga4+UZl27oUvoDyoC4L0cD+pLBsF8MIkaPPvcwU/l8bCOqVr2g34ZHMLbviPJPw8XRTBSvLbUybhyqPHoSDLjJtPmYQMs1EOCQakarftqh63aOMrIzvEbOxq92LtXqe8rMGh85tXD1qrc4ATIdB64c+A4oiXRlQtg9q2aO8r7kautoBrwrnytFoAZ1lMsFlNyIS+aJogaFsU3fHuBlz6/HKc+I8laHEFNSHQGWYjfmb6kt8p4gc6duLzLa2aqJh0HWBAVQm6Xx1g/WNta3Gn3XqqqzxguzeE/3tmGU5/fCl26rii3eX/JuHygPdI3yljxzbcbXoVxxik+2JfHGD2vluey58H+9kDWjNiS7Nb89p6PYtlVEU84z47drZ6EFS1wVTv36LKAWYd4Mnl0n1QqXMiouz7vwAvnQ7U6+fF9xb2OZhNCdnf6deniVNPPRVOp7PX+//yl7/Eiy++2H8nRAwp1DfTdndQP3S2NyHQ6gcDi40veOJu1G3w3m9VoONx4H+3AC+eJlXITMC2Qcq2mriqkr1thZR0gCsFRkh1l+fZU+IxZIR0/japHOBokC+C1BVdOMCiKGLFbjtK4MSYhONiZ27aPnUINOsAdxceFPZyVZST7UVqO3xcJeho61Y0q25M4VicGxVnbxjJfKJyxgFuSjxA2H1hrgroVKGWP6esbioa+zqAGiY/cMbFQBYTNuznHZyNjS4U6T14qltaiSLw/vXAv44EVs+XF9eJZfCEoohaeAfYF9IPgQaAQjgQ8fREAEv5vxajAavjE+Xln8UPR4NYqhT2MVmBI68FDrtSamlDEANAEfOQ3uZWnFIv4wDbwAtgsfoE5QDxCMKdSuV1m8UEs9GAhTcdh4+uVL7fLHng73GcAxznC1v5xNRFsJIYDALuPXsq1v7pVPzqRMkNLlGJj2RbNyDhgO3kKzgHYMHqOgfWM0UV2zwh7UO/TzUwquppnAyBLmREfYxpd5Yn+GFFGJVxVfVdMQ40ruaXseLamot2m1KwsFLogJVxe6X7gREZgr7Im6ASzIDUageQ8jE/WNeIMFPptzTHCrTvwCzDZu3Bmtfhsy2tyBb4+4Qp7JKeBRKkygFOnm+S/myF5GGcfnbAfVuLR9MHmIXdVu9ZKclry/diVZ0DW5vd+O1/12nzqNkWSF0JYMYBru8MoMkZwPEb7sTVpo/xvPlR5MLbJwHMinh2MAgAMs1GsMa0+vPXC/13BSJciDyHl087+mrNVvzon9/glEe/5p5Z2GeB5DGTvy+ptaXy+04W1kwO8h8q7MTorS8Ce5cBX96nfx69hI0OySMB3Ds2b96MM844A35/z6uc3nDDDXj++ef783SIIYZaADtdDil0WU2KUe4uCSvfuRAsqHeGAJtSQh4hN9oc2mIknv4Kga79Blj1IlC/HPjsD/JiNmcjy2JEPiuAe+E+i6KIXe3Sg0yloBK8XYW59hRfBwx6lYNT5QAD6ecB6zrA0g2kwRFAtnsnvrP+Gkutv8Vphh9g9+oLYJvVBBvjAHebA8w8uMVFQXaA93T4gGKlEFa4dTtnZhfAjftNLyL+xZ/lfpVcCLTsAGtzgNUj6XMM6/lz6q7nde23Smh/drlU0CeTEcAhlxQmmGBjo4t78JRxqx7+lv4DWP+GZrN18fEAAL9Ryc+SHGD9EGhA6usZ9qQu+rEnzheuSjrABxTbUCNW4vLwHbg/8lPcFvkFBIFv7UIQAw1bsMruC8uhk2zocWbczwngcNGB0u8xga9lpzydZTECDathfv8XGL19vu5r5gj8MxL7m3Ugh1vHtUFSO6RdYDEZUMTkX7LtbvIyzcDOz7ntsxHEd7vsXCGecDSubf/TTQh00nljRX2dyF8DKgQ7KqFTq0DtbLHHzshDs6EUIVG63hoEEdWCcs/LshqR3YUDrC6apWY504/WbBSkz2jNy7rbButWYVVtp2ZQ0IC4dE2GJKrYwdsuHeB+FMDs4OwBTJ5tQ2egSwF8UIUy6NnSRSGsdfXKoOumRrdS0DQBmwNcnJ26EG5FXib3mazf3YgSv/Q7yhJCGC8096kKdAvTjosdnAak9MquWlGp83+TsA4th6peyu69UnRegyOAr7Yp3/OgTrVvR8IIsfvCnCGTzJFOCmAuAsW+S/88eglbCydX5Y7vz/SrAM7MzMSKFStw3nnnIRJJ/+H+xhtvxLPPPgsAuPLKK/vzlIghhFoAB50pior04CYvw7jGXtGKp5fUyMVEkvid2htuvxXBYi9IjWtkocTmAGdajMjLUm4I6VRkVNPqDsk3S84BBrQuX1/QK4AFpHaAgfQdaD0BHPYAYR9W7unEaYYf5Nyxc43fqkKgeQc4i8sB7uZvyQwQtCMPMUg3llq7jwsrjqvE3K9N7+My05coX/8vYJNUSMcT1DrAbAh0MtxeHXY/x6gSwIn3nRK2NcjoQ6U8xiy+cBTbeqOmoQ1Zgs5DA/vd2LYI+Op+ZT67HOIBx+OR2CX4JH4kAMAr8gLYH4rCBn1XoExwaHLfWDaJB3Dz9WIJBAEYVyw9/CyNT8cLsTPhhg2VBZlctU6CGGjKcjO4Hu1J14ltg5Tp3s1VFnZljEY4V4kwWvDlt/L0GLNX6mu78W1gLdPG0cQU1erCAe4UeQHMOtFSFEv6BYpKVc5XknzBB+xdzi2zIYBPNjVxrWMAvq8vgC6LYImiiLakA8xEorShAJ2iMrB1mLBTNzQcDaoCPCoBbPfHUCsqAw9sGLTNYkJ2hn4OMACMVg8Yq2Db7RVnW2EwCMBuJT1ke1wplujdswpxEbqV8ZP1ENg0mgwTUNr2HeBSwrBZAZZu3mW7J4Rfvb4GJz2yRL9AGfiotqmjlFSWeodfFltqbBYjDma2TdULWBRFbGzkBzz+/ul27n7Y4Q3BgDj+aHoV17X8qUuxNr5Euc8E2vmCYgWCp48OsPK3qcjT/g7YStBsDrY7GMGaOva7oDyzpSyEpWrjyKY0fM8MrAR1otT2JCIz9jARGnmZZrl4WDIEmhs083f06DrQHS4Kge47CxYsgNlsxhdffIGf/OQnaZXVvummm/D0008DAK644goKgd6PUReh0q1WC/Q5BNovZmBdvQswZ0hFgxLEdFyqfiuCxT4UxEJyFUDeATZxDrBmZD0NkuHPgJ4A7kcHOIUADvud0oTeIEW6hZD0BDAAeFqwck8n5zRWCJ3whqJyn0TeATZyVaC7rZDoVj6fFqb6cIc3DK9Rufkbg7yTfbhhuzKTqPSonwPMF8ESRZHL8cmDFzMFxSmSSYjTFlcQD3+6DZ9sYsQqU6EZBQkhackGDMxNKpEHHAjH4GhP4XIkBXDACbx3HX/MG76HcMVHeDvzIsQTtwSXyLgVITd84RiyUznAghNxvWJ2CcqnzOLm68VSFGZZUGjThsdNLM3RLCOIgcRoELgK/UlY4WnoUK4BTtGGzqgFdTFlgLUorlz/b4i9IruAHMVKOHSOEMCPJhfh2csOBSA97CdxqAQwVwSL7cWeBmWJ3MdceHGSYQ2yEoNYRa3LpLQZBqMgwhTTCh91r1JNpA8jUh3+iBxGXMSIALuYgzam4N2RBp2e5oBUCIsJIdYIYG8YNeIoedFPjV9CSEQq2RJdATJThECPSghgNtSXhR1cLc2xSufB9CD/T+xkeTrHuRUGxHV7owdc0n2Zzf99MPM1GP5zPvDM0XKLnJweOsDr6504+6lvsXBDM3a3+/DAwi2627EO8IEVynepps3LRQGMYu5XY4tsqMjXL+LI0uIOcl0ZAEnw/mvxLm7+JMNaXGP6GFOc3/CDrSryGUMALr7tYqHggSsQ6VWP5GAkxol9dQg0wH/+7P18dZ1Dzs8vyDLjx9OV71u6DnC+oDynsZEFwuZ38LHlDtxg/EBelhS+u5lnu+oSm1QIEooDnANGAMfCuiaELxTFxf/+HnMeXsylMnQHhUD3A6eddhpeeeUVCIKABQsW4Je//GWX299888146qmnAACXX3455s2b15+nQwwxGhx82JeYyjHsVQi08lDghxU1bR7pYs+4wDmiNjcyHI1rChX0CnVYWPMGAHzVviyLEflZfcsBVgSwqBMC3UMH2NMi5Sy/cAqXt9zVsdzOhMjV+xulEwIdiwCuBv113lasrO1ENnOhL0tUKU26wD51EaxUFRLDfv5BCgA8ijhUVx+uDymCzxJ2yQ9VAuJ87lgijNqt4wCzYVb+cAzuYJR7kDjBsEFuOcK/b2kg6L6PNuNfi3fh+v+sVoqLsIMFhQkBLAicC7yxRhLJW5rdKNCpOAtAee+b31Mezi3ZwKVvyscqYMIlHXHmoTvhAKfKAS4VHF0Ofhw+60Ruvl4sQaHNgoIs7Y1Wzv8liH0IGwadhBWeAlMpvUUsxFfb2rDBpVwzSiFdpw4XtuHkkKpoUhImzQIAnr94Ek6bWg6bxcg5Rp3I5bbjimAB6d0fQx4gEkRpjhVGxPCB5W68ZPkH/m1+FABga/had7dsnSgPTd6jKgfY77bj8hdX4Fevr+Gq57MOcKeYi3ZRGWQ80sAU4Ko8EkBClQYcnOhUC+AOXwgfxo6WF802bsHPjFIod5ZFJwTapFyTy+CAETGMytP+rdWU5FgBdwMQVa55C2Oz5AFCqxhEtdCkGxXT2Cxda9uZfsjnRhYl3o9TSj8BMEGsw48Mq2BErNsiWMt323Hhv7/n7ic7Wr26KVzsvYkNa1YPEM8Yky9PVxVmqQZw9a/1Gxt0BnYAvPp9LSKJgY8Ob5gvUNaSutAj+zxk9vBFyvIhfc/t3p5HyrWpohZKcxgB3L4d2PIB8i3K8wH7+e9gRO70ynzuM0zpAKsEMBvRsbvdhzZ3EBBFFHx9Nw407MVt5rcwXZAGDWplAaz8dqqLlftgss5JrnoAWuf5+aP1TVixpxO1dj+e/Tr9MOnLm/+KF80P4yHTcxgT3t39DvsJ/V5S86KLLsIzzzwDURTx4osv4vbb9dtW3HLLLXjiiScAAD/96U/x8sv6uRbE/oM6BNqQ6qG5N1WgmQJMfmQgEhOlixUjgJMj0lYT/7XvFxdYXRikRRLAga5ygHshgJNFEgrh0Ya69tQB/iGRs9zwA/DCSUAN8+Dm1RfAPo9TmuhtDrCrQXYeRAioEZXQY19nE/Z0+LjCIqWJh5bkTdCjCoHO1guBXvc68OAY4Nlj+JtECgcYAPb4FTfSiBhyEyJ8us3Ff84Jscq3QZLOoTDLAotR+W61uIJocQVxoFCHl8x/x6OWp/U/k8Rnnay+KorAqmQIVmetsl2BEkoctebL0/M/X4NYXMSWZjdfeZV5+IPfLuUbsxWlZ17GVb9mBWlHlNk3UQSLywHOUUbFSwUnDHqtlxII5dPQmiUVr9ker0S9WIqibAsKsrT5YRMo/5cYBCrztUXWuP67ceVa3Sbm44Wle7DZwwhgwQkBcfzZzDzHMD1rAQB5lZCFHgAEnRAEqWVRVyHQIZgRYx/Vurs/7l0BPDIFeGQSpphbMUlowAEG6QH9OOMmlJn9MLZv1d1VL6RX4wCrHrzb2lqxdGcHFm5oxu3vbJCXcwIYuWhDvjyfPB8AwKiZXBFCNK9TpnUc4E/jR+Dj2BHy4jtMb2Cc0Cw5wFZVCHSR0h7KKIgohRNVRd0X1CvJsXK9XJvEQtiRh/aMcfKy6cJu3aiYtlbpPtPpS3F/r/sOaN2M3+y6Fs9bHsVvTe906wC/9UM9594m2dToRjwu4oN1jfhkUwtC0RiCEWW7iWU5XHh/kpwME2ZVK89Gh1UVcK2CUjnAm5jw5+MmFsOSeJbyhWPYkBDHHd4Qfx9y1mkHoxPkZyr3gAw/L4CTv4nehEGzAr442yqfJ1yNwDPHAP/9Ga4MvCJvw37+O1qV39eksmxMKld+jzvbvPo9klVFsJLiPcn3u+1AJAATc5+8JNFbek9i0IgtUlfNhIZn6jnAgO6gM9v7uE7VyaIrDgyuw8nGtbjYtISLRtnfGZCeEtdeey3+9re/QRRF/OMf/8BDDz3Erb/11lvx2GOPAQAuvfRSvPLKKzpHIfYngpGY5kKWFXXqb8yOcG9+H3jkQGDBL7vMeQj4lAuzT5TEzJZmN2BTquwmL8oHFNu4m0K/5AGrR+OaNyAcjXOtLrIsJj4HuBdtkHQrQCeIuLou8qGBDa8FgNcvBnYtlqY9+iHQQa9TmkjDAda9UTCOpt1QhPq48vfxdkjOMDuqbhREFMMlFxNhQ6DzhABy4srf3Z90h5c/IxWOatsCvPNz5bUZB7hF5QBvdxq5B9ZkJeW5ZU7+/H1JAax1gA0GgXOBm10BNDn8eNb8T5xkXAeTXlExAPC0IhYXuYIftXYfEA1LLkSSQkUA2+PKDdIQcqDFHURdh48LO+QeKgGgfiWw93tlfvrF3GrWAbazAjgeRTTk5dsgFY2XJ8vggDHIV6OWEYxAZgE6zn8TN4VvxE/Cf0AcBsRFIE/HAR5PDjAxCOg5wCG2EBxDi1iITl8YbWK+vKxMcOAgYS8OMjB5jJe+xe9YPIlvLxZwAgDG5lu4nOBOqNMABIQMfEpCl6x9Rbo+B1040vkxKgT+ujzd0gK079DdVS/Ko00TAs3f6wIe5UF8J1PFVh0C3SCWQJeiCUD5NGW+VemPrBXAIQAC/hi5Ch2i5MxlCmH8yvgBbFajlAPMhkBnFXKD4KOEDlQV6f9dWUpyMoAOxYneFZcG/Oqsios/zbBHVwC77NKAZrLglKaYZPt24MObYBSle9mNpg+6FcDq6LkkW/a2YsdL18L07pW477XP8PYqProqP9OM0Trh/QVZFlxy5Bjc+qNJuPmUibh8dhUXEt3qDurevzcwAvioAwoxk3GRk6G+HZ4QX4gxFk45OM86wLYAP+iejIrojQBmU4/K85hUm9pv5cGsGSEl6o29n7Mu76SyHExk7kn+cEyTygdAYxgUCh6cOFn5vi/f3akpFndMorp4rV4IdLJ4WSQIm1mSabmCKvVBp4VoJ1NXRjNwlQpRRL6onJs5r7yLjfcvBqyp4u23347bbrsNoijirrvuwgsvvAAA+N3vfod//vOfAICLL74Yr732mhzrTuy/NOlcNLhRQoEpfMOKqyUPSsJlw5vSA3wK2PZb/sTI/ZYmN9dmJvl6o/Mzud6PA+MAb0RAdVPLVDnArj44wHoFPSKOHgpgdZhzPAJ8LQ1WicwFvZlxS6OBFH2AAU4A/+mDTZh276d4ZokqDGfnZ/LkXrGUywsLJ85f/VBRLnSiM9GCKCmAZwo7cebnJ2HSf2ZhlkHKhfKFo1LdgRbFhcCeb5RCJowD3CoWyo3mAaC20889KCVvvrOyVXnqOg4wm0tUrsoD9rk7UGVQjtEiFuAfkQvxdux45pgt6PSFueIzdR1+wLlXadskGIC8MfL6+oDyOgXwoM7uw95OP/+byh3NF4L77nFluniS5LwwsA5wc4jPz40H3PzDcdnB8uRooQOWYAr331YMGAw4aPwB+DB+NOyQBIA/HNV3gEkAE4NAZaFOWKxF/7uY7F3NplGUCk6MYau0lhwITDwF+PknQGG1VL39wLM0/bUBYEJOBAYmNUKdAwwAERMj2roLgWbcqOJIM0apBPDxxk1S8b0kViXEU93WB+i+CFauoC/O1CHQ78aOlwsPchRVA+XK9QQtKQSwNVceCLUjD/PMygDeeEMTbBYTqottyGQdYFMmV+BwlGDXVGNm7wNJ1A7wbrECALBVqJaXHWzYgxKL9h7ud0rPAkkBrHHuYmGgcRW3SDcEOh4DPr8HeOdqxDv3younjlL+XqbtH2JKw9s407gS15s+xMeblHuc0SAgy2JEZYHW8S6wWWA1GfHrkyfKfaPZe1ckJnJt/wCpABbrAB88Oo9zkZfvtiMQjsEXjml70aeo+8EK4LywVkQC6FUlaL4HMBvN5JQns5nB82RkWTzOtyKaVJYDm9XEDZBp8oBFUeMA5wk+nHGw0u9+xW67RgBXGdowXmhEbYcPkVicyxmvLsmW0pX+fgCu3XolrAhr8811Iu4cTNSB3RdOL3864IAZyvcvI39UFxvvXwyYAAaABx98ENdeey1EUcT111+Ps88+G48+KuWgXHjhhSR+RxDq8GcAKGIvknlKhUUuxIsdWetMndPgdjnl6WTo2uYmF5crmRyVHFuUlbIAQq9RC+CQC6EOPpdCkwPcwyJYnmBEfhjRc4AFX4rKzanQK3SVqDocdyuf++54hbI+6T7oOsDSg1GbO4hXvq+DLxzDY1/sUITdjk+B5UoY8NLIFLRDeSCMJV5T7UKUCw45BNobikJAHO9Z74Ep5ochFsQFhm+kcxaBYFBn1HPhLUAkCJF1gFGA4ycpI7R7Onx8uLzgllrygC/MIfo64A+FuRAxtmgEl0flDMDsVvaPmzJxXOQpPBU7j89B9rRqRmtr7T7eoc+rBEySYHT6w9jlUwRqgeBFfacfezv9/G/KVgTkMH+7GqbtyfSLNdVgChlB2hEUAKPyGkLQxYdAV0yX8+HMQgxWUTl/n8A8rNukhwBBEPCrExXX+GezxmlygEtzrCOqAAcxdBijIxJgTSGAE7/dpBAGgGK4MFZgrqf5icGqqtnATWuBK/8HZOQCmfnKNomH8QNsym8nJJr40OsEURNzfqoHaQ2MQM0JtWgc4BNiTBRIdjknEJNRHmyP1FYmlxVhv6bfe4HamUrAiiA7crFXLMO60nO1GxZNAMqmMi/I9N3VCYGWz7VUiYjJgw+ZZiNmjy/icoADsHDPFhWCHTPH5ssO2wmTSnDygYpQSVKSzQvgXYnCW9+5lW1HCx0oMWujuCI+O0RRlOtW5KX4fFh0HeCVzwHfPQZsegcXBd6UF8+dqjh0oVbFpZ5kaJAG/RPkZpgSIfZ6DrD2OpuTYUYOk1LUrOoFrC6ANU0lgFfXOWTnNX0BrNxzimOqSsp9CIFucSn7cAWwmO+TLeqWa30kByAaHAEEmJowyQHZC3M242PL7fib6XnsaVQZDWGv5jdhgIijRymDPbs7fOjs1D6znW5YCV84hrV7nXKPYEGAFKb/7T+BiB+lvh04ybBW0zpNLwfYrhq0UOdC6xFjitGGRSOy84u72Hr/YkAFMAA8++yzuPDCCxGLxbBw4UIAwPnnn4/XX38dRiO1uxgp6AngQrZgT0GVMs1WuWTFcKriSQB8XuVYgUQI9NZmD+KcAyxdUA+syOVKvbt7UY2ZIxbVzceINSktb8xGAWajQVUEq2ch0GyRhHEm7ehfRsjO9YRl+a6mA49+voMP39ELc/a1A/EYRMYdTo5+A4Ax4pVcVt0cYOkzYMNwQsk+kq4G4D2lKF6kcBKejf6YCyMUEuHF6sIikgOshECfaVjBrT/FuEaeDjh1cpftNcDq+Zzj3SIW4tgJyndjT7sPMaa/boHgRUVuBrLdNeyRIIgxLF67Tb5J5luBqeHNsiPOjqJvafagLK7cXMT8KpTlSQ+y7PuGtwWBujW42/QqDhOkarN1dj9EtgVSwTh58outbXAwLUXy4UWd3Y/6Tj//m8oqBnJShDNNv0iziH0YcfjCnFtlDLv4v0tWEZwW/WN35jCh10wKwq9PmoibT5mI2+dOwTkzR3G/BYDcX2Lw0HPJDBm5OlsC0Syppy37GzYIIqYbmN8rO6DLouMAj7Eq12SpB7CgCVv1ZSoiFW36+bsyjDOU4WtEhcDfm8bGmDDtkkmc0E/+xg+rUsQ99xCtE3aZhSCM0DpNRWAdYMllXVV1jfZ888ZwESXwtigP92yLpYxcdDBu4JhRilOVJ/hhMEj51OVZipveGjBoHOC8TDM+/PWxeP2ao/DsZYfp9h0vzbVyxbiSAnh3QPmeFMGNApN2wDU75kaHNyzX+FC3vNIjHNS5n35yhzx5sXGxPH3awcp11xhR9iuFg6t8nHzGGVOo4wDrRN8AwGhGLLNteQC+ANaovAwUZVsxc2y+XPfCH47JPW8L1cUYnXyLI+U8pHM0IYriOP9MU9inEOgULZASaQcAYGBqfSQHINjw58qCTLkA1RWup3GgoR6Xmhbj/BUXA01rlWOmSBcbbQ1yv+PttfWabc4wSlGNX25TjjE6PxMZJgPQoXSMKBGcOjnAXTvAANDm0TEEVAQ6FUFvRx5yU3w39kf6VQDv3btX86++vh4PPPAADj30UIiiiGOOOQYPPfQQGhsbdbffu3dv9y9EDDsandowKS5cM58VwImLUDTEFR9Rl8lnCfmVYyVH0L2hKFdQpEhww4woZgW+wWGCMrrb5xDoQCcAbb6MsVWpfpjs5ZbHFH3oaRskLjTHohXcAkQ5R5WlxRXEz+f9gCe+3KkUKYkE9Ft1iHHAb4eBOU4tlAeNrHiil2AXOcDqapMOf1gKv032qzVnYcuxTyKADC4E2hqURkjVhVjKhU555D8UCuFW03+59W4oN/iwI0UhsK0fQogrgwPBjFJMG608jHpCUXxeq6wvghsXHjYKBsYFSLJ0rdJ+Yl7+PFhfO1NqbxENcxVG19U7uLBIQ0GV1F4D4N433E2Y+vUvcLXpY7xm+RtGoQOBSAwBZnSfLYD1yaYWTgAXCF6s3etMhJ4xvylbCVA+XftZjDsOyB+rWVzIVoH2R1QC2MOHpltz4MwapzlGSDTDUs4KYMVlzzAbcfMpk3D9nPGwmox8CwyAy7UiiH1JaY5VUyzImEIAzz5EciuDsCJsUu4vMw3M75VJV+DIyFemEw/jFWZFaCTDn8+czkRuAGjJZhzSRlXFfjXMg7HR34YDhC66AxRPBqzKe8gRArBZjLh+jhKt0eYJKi0tU3RuUD+cWxHm2hEl35eYXYaVJRfIy1szqqXe5tllXLqSnAfMCOCgKQchphDUoZOVa2K+4JNrhByQrzzWNvoExHOVwYhRgl0unnj0hGJkWoxSuKmKUjOft+rPkUKf7aLynbAKURTGtJ9HPjzo8IZ65ACbA6rjOPWfdQptFkwszZYHD9nPvVRwctsmo9z0HWB9kTOZCQffpgr1Zfv/TquU7g0ZZiMOGZsvL//fBklMaQoppXKAE89DZXBoOiQkj9HRixDoFiZCqyxFCDSgmCLJKMAdbXz+LwAg4EB+SBGJRdFWqXtGotNHqpaR8Ns5h7ypRbvdQYY6VAktWLxNeU6oLsmWvnuMq1wALx+BBXSbAwzwTngqgoxp0C7mcVEA+zv9+k4POOCALtcLgoBly5Zh0qRJXW4TjfZDSCoxpNBzgMvYC3ahklsju4tql5FpIq8mHFAuXH4mhKw2kInkbbUQHvza/D7GfrkA9wA42Hwc/hS5su9FsNThzwnM7RsBzAag9HJTt0ESRTHtNIAuewAn2fIBsPJ5qWDSxf8BzBnY2OiSezP+UNspvab6oi0Ylb6QHTthiCkXTkdmFZDQ6tlCAHs6vCjsogq0P8QLYKc/DLQyPQtPuA27UAnAzrkotrB0QVfnupQJDqz2hRGOxnEevuIriAIYBTsExCHCkLoQ2N7l8qRXzEB+YREKbBZUFmTK3822WI58RTyyLI7jZpqBZdoR1Pr6OgAHw4IIDnF/lXiTe4GmNSjPGydv1+ENY4xJ+TsJBVUoiiUFsPK+0b5NlvCZQhi3mN/B7yLXIdS2S5H2iQJYvlAU3+xsRyFYAezB6kTVaD4EuhiYcYkUtt6yCYj4JEF6+t91PyL2u+nwh4F85WHPHPHwoenWHHizxwHOZdwx3IZcFB16NrDjP9KC8SfpvhYALh8eIAeYGDwMBsl1rWUqp5oz9QXwWcccCoyWrtnmbyuADuk3N5oNNU4pgLUOcIlREUj2hFA8YlwhnvtGcZTteSoBLIr6DW0jQc3g5MGGWv1zAYCSydwD/G0njsYdx54Mtv5RJCbC4Y9IA2QpBHCu4IeTGWxWR/F4E62cMs1GrKi+EfHWLThY2IPPii/H5YD0XsqmAnsS9RpaNwPVczgB7IpnAYlcRUEAysuUQQITopJgsNgwNkcAEpfdve4YZtrK5etohWBHtugD1n0gRZ1VHokJQiN+Z3oLJsTxr+g58CALJWHGiDHbUDpqHOBqhxPZiImCLNayg9rBhQLBi3ZPSM4Bzk3DAbaEVAPam97lZpsSdTgq8jIgCAKmjc7D0p0d3KBkthCEDQH4Ep91ss5JuiHQACP6oG35s3pPB04z/IAIjJg2SokgmlVdhJV7pPNfu9cJCyLalj0pBHCyEKJeTZN8eGFAvFcOMJu3zkZlqdMHCuHGHlTIIdA7mQrQE8sS96M2nZ7VsRCw9SOgYnoXArgTlQVKFXKRcZ9ZTjCsxyutiqtfXWzjW4FB6ius+R6pog5FUZQitxha0iiEFWHS3ZyGfBgM6T2P7g/0qwMsimK//BtKBAIB/OlPf8KkSZOQkZGBUaNG4aqrrkJjY2oxlgqHw4Hf/OY3qKqqgtVqRVVVFW6++WaugNP+CiuAi7MtMCGKMjCVY0sPVKaTIdBh1ShiFyHQcSaEKMbkS233KCOdBYIHp1mUAkkXGJfif5a7IDhr03wXKhy10gNHCgGc1amIvmQpe/ahPxoX4QtrQ8dSwfYALooqF92YyFywPrlDypWu+UIqogCghWkJEIrGpTweNmwnqwjIY0LsmCJSIdEEX5biAOcggN1tnhQOcCcQj8Mf5gcUOn0RPpe79CA0Jr4PbA5wTswJK8LIEHhnvAJSESxfKIqzjN9DjVmIoQTSjS3GXMzZ0DdZ3EPK4Us+FDx56Uwcngj3Y6uvHl9pgLFD58YHoCjxWsfm2yEwx4W7iQ+3gmqgIn8sirMTAphpCaLmfMNSHCjUwcB+LxMO8Dc72hGOxuFUhUAnBzj4EOgiKQf+zEeAqz8FrvsWuPw9oHii7utyDrAqBNoadfMPtZZsBPOqoSa7oBSmyacBV/wP+Om7mkrTLCajgcv5pQrQxGCiDoO22vQEsABDThnOOWQ0zjlkNIRUKQZphUA7AfDdEByJa9C4oiz88njp95VpNuKoY09R9vO1p74XBrSRQWyBGw3FkzgHOM8QQk6GGbkZJmSYlcdDuUaBjusEaEUeG8UTFwUpFzfxXsxZebgkfDemhV7AsowTlJ3YMOhkHjATpdQZU4RcYZYFxiy+kn/SUS/PVJ4h20NG7A7ly/OjBDvy3r8MeP86YN7pwENVyH7haNxo+gDXmT7CLaa3kZthgtXJhLMXT8DUSum1RBi4Ps3c9T9BvuBFozMgR0Kl4wBnhvm/m3f1m9x8clB4VCKkdnrCgVU776wLrAhg/SJYerAFwdhiT++sbkBF3Yf4t+WfeMnyD5wsKEW8ZlXzLQXZntYyKQRwboYJRoOgK4CNgohc+HpcBCseF9Hm9mOi0AAD4ilDoAHGAdYJgZ5Umvgs2rZAl2SKUhcOMNum0RjWr94+w8DXthlfohXAJYILNnXby8RgVFIzeUJRrusIkF4l6KhbcZ89xoIuttz/6FcHeN68ef15uEEnGAzipJNOwvLly1FRUYFzzjkHtbW1mDdvHv73/+ydd3gU1frHv7M927LplQQIIfRepRcpIoggKqCCiGIXuYp6FUS593rt5ee9chUFKxawIQiCgCJIlSJILwFCIKT3TbJ7fn/M7s6Z3dk0skkg7+d5eNidemYyO+d8z9t++AHbtm1Dy5a+g0AlMjMz0bdvXxw/fhwtW7bE+PHjcfDgQbz55pv48ccf8fvvvyM0NLTqA12hpHECuGtCCA4dOifLfImIFOmzww44yhUswOcUZ77LKpwQKoo90znNYyIAV/6g/dkaTHVtF4ICmLw6rBaqi+h2ZimAYTW7oK1vAz89LSYRGTRXWm6J8bhO6UsyEIRSlMDgsQB7J/nJLS6TvSQBiNcOAVBzy5mUnTAEBdA5pft5iCWig3Dat42uF7d3Tb+03BJE8ILUHA1og0QrJiArXH8JNmiMwXBpPmgFBy5ePA8ll28wB2DPkyWRAFzWRF5wm6Nw3iXKM7zKESUKvp1JlCsGuNBegWgo15uNEzLFY/GZrRP6AEd+9ElQcYGFegYFXRNCsPy+a3A2uxhpa/cDYgguVMVZgJ9amRGCeDNuTigAeA/p/DREJ8oFcDOZAE5EeKE48LjEW4C9UAkMT2qWwVjkWwJp79lcAPJMsSGC9DsJ9bYA1wDeLS6/tAJOfbBnhjTEkQmVmvub662o4Ga33QQFR4i/zxYDqnXOid3i8cGWU2gdZUbP5lfv+49o/DTzygRtMIrxuLJ3nSkCUHPvcD7JHI/NjwVYlgRLfI8InCUnm1kgCGLc5mMjUzAoJQJJEWaEWg1imJA7ljJtt/I5/Fho/RKRIs927cplIAgCIi0GT2bajAI72sb4P36wUCS/TVwiqmLowVxvEoNODZND7NcYVPLkT3wirAt/irVjSyXRkFkRBLjEVZhZJyYF1Bql93tpLhAcJ0uCVcr0WH9eB7e0DhMKgLOSN5D3RO716m34zDxLlgALYcnoECeJ3kxm9fQBSoSgUCakqhMDbHLkwuFkUKsEpB7eg8Qced9jEUqghsMTU9oxzuZZzhMl5OCUK2eHuz59hKsOLl9H2J8LNG8BTsstcSXeLMW8bw/gOZXUppSSPYBrZNUtIQQ6tUqahFWqI1t4UUygppOLcUEQEBykRayfKgIhQiEuFtgU1/kjs8iO/6pfxbXqP7DF0R5RlpHSSr8u0OVwKGSABiCLuS9hOsm1352U1Z8ALsn2xBADoheVmwIW5PnbdRHkArhFuBk4KV8Wz2eYd1OchRfXHMaXO8/i3kFJGNE+ymeTC37qOfPw3oBF2qbVB9epAJ42bVpdHq7B+cc//oFt27ahb9+++Omnn2A2ix3Fa6+9hr/97W+YMWMGNm3aVK1jzZ49G8ePH8eECRPwxRdfQKMRb/3DDz+M//u//8OcOXOwdOnSAF1Jw2KvcMgySXZNsKHgsNSROk1R+DNLhc6ynRSsjOVFYhypUf4jPZdTDCNnnUqOj/YI4G0XJLGsFhiCnL6dkbW05tZ8/PGh+H/hBekzINZe5WKHrCgWBbBW/Htr1CpY9BrPjGNucTnieQ146Sjw+WRR7N/6KdBqOLD9f2A/L8RDJZ0xG/chnpstrdAYccQejw447dtG1yyi90swLacEXUq4l7YlSiwX4SZdsgBfYjbojDbZ/vkZlcTpF2ejyC4X+YX5uXJrviUaaS6xbYdO1hk0V4hXE7NA21FUVoFmXnFObuKETOxhyVDxmbAtMUBkO5+SExcQIis0D4gDzmYdW3sEMIqzlF2fIAnga8xeHV/+eYSb9FCrBFfmaya3AIckIixH57nuIpUZJqdySZNB6v3yOQaXBdhdZzMHvAW4AACDDhXyAZGxhgLYyypg15jhfiqi4TXw1ZvRqm1X4DevgwTVrAOdP7YdbuuTgGahRmjVAc/JSBB+8baUWY060TrK1931tviafQedTkENldmPZVghBpi3qubAgtjgIBi04oTpNUncbziuuySAz/8BtB/ve3yFxDh+MQSL7ecswPx7Osqq9whgjyXJj7eT1csSGaGTXDH5rNZBWjUcTkmI8XXdZaWQLh12iRXpJZhRJh0nzOTKUG+wSQLYnWOiQurvSqDDqmMOPMS5LVdGhJCHvvpTcgEc3hodYiXLPR8HrIRRsOPUBenvEKZRqBvrRRjyUVRWAatODeevLytuY0YJYm3iPXBbgL0rJkQi1/PZytWnj7cF4SSX1CrEpOwCHR8SBJNO7fFM++t8Pp79/iBKyh2waKW/sYoTkgatGqNbahF88nvscyahZ6wGUHoMc1Plnn4ubEFaxNmVn6sQFOBUmQNF9gqZmAQky6d3CFnmxQu41pUYs5/6IFBwEghy5aXwtgC7JlQK7RU4k13siTEXBC4khxPAa509MF7tCvvJOqlYAslDcRZMEVKiX22F9Nv61dkRY1wJsJJU6bCiEPmuPr1lhAnYKbcAJygIYGdRpqfM5Ms/HfHEZfNUxwVaVSzd+xJd08kADdRDFugrlbKyMrz99tsAgP/85z8e8QsAc+bMQadOnfDLL79g9+4qElIASE9Px7Jly6DT6fDf//7XI34B4OWXX0ZERAQ++eQTZGT4+SFd4aTnlrrzU0AQgM7xNsRyA+q/iq2Y8P5++U5lRcqZhhVcv1Kzi2XumS1iI6FxxTGkFmtQxirPNm4p9xNP6w/G5EkqOMEIa5w4K+3C7f5k1EttCObib2SJsEpygGW3isK1ohRYv0CcCPhpHoSyAoxX/4a2whkkqKT22s3xuMj8iA5XFkHvl2BabrHcJdkcDZilZEW4JAm/DGZDkMnimcEHgNIs7m8gqOVCqyjTxwW6Io9LTCWoAFOErC40786r5AplFOwQ7HnIy82VuwHFdpM+uvbTcC9zWKLlVgUXF1koerdQuGd8zdyiLNl9YFzSqHAhD9e2i4I13ytBVn4aVCrBk8wpHPmyRDCwJSDMLJUWyhJ83Y1OOhUGzsYwsYQKgGOuJB18vJ1OcMCEUt97x19PNTDp1LJEQCUqaZKAryXK1HpAo0dkbCKcWvlEQk3PCYhJP0j8Eg2Nd6ykNUjrWwvY2+KrZAG2xsq9d3h4AeyOR+REZTazoEW412/KTZz0vkPaH8rb1EQAh6eIHTJf7onrcyO55EEZHhdo5eOHC3mYp/kYL2jeQyjyEW/iRC6TC2CTTro3RXy+iPAUsT8BXLVy5WOrC3ZpvzCza7KOt6i7xQ3n8VMKHVJzy5ABBdfOLlOBaSuB+7biYngfz+JR6l1yF9TwZERaDWJtYMBTy7wyMi5KfV4EL4B73wuM/Bcw5jU4ukoGo1ChAIUlZcCqOWhxfpXiMa1CkccFOibYgMQwo09pnEhBCivjK13EeT3b/izAgiCgNecG/cGWU55kWDJ365Ic2X4v6hbjee2HWBH0T/y9mxOK5HCZoIsyPX8vm1Erm9TnCfVTCmnbySx0W7gOo9/c7BP3mnfxlOw7znBhU14xwO5EW4WlFTKrfbMQoxi2xpjMBXqdo4e0sz0PKMlBWa6Ud6SQe9ZRnC3z7jNwAvigswWKNdJz1Eklttli0Ih1i71coEMF37Gwyp4HDSqgRQXKKhyyElhuquMCrS2V7n2Zoeb995UMjTr8sGXLFuTl5SEpKQldu3b1WX/TTTcBAFauXFnlsdasWQOn04kBAwYgKko+Y6zX6zF27Fg4HA6sXr26bhrfyOBL70RbDYizBckG66crwuCAGqWMm5UsK/SNAQbw2+69PsvOZMktwGZLMOcOInjiqvxhq6jBoAEQX94V/Mwr7/sVLovzcsdGuV2gAd9EWADEovfL75LXOr7wJ7DtHdEl3EULIR0dTbme7w5rM3lNWZ6cU4CjXNECLHNJtkTJLRlc5u0MZoPNqIOTHwhy9XShN8tdbc9ugzHHy3LKWcRhigQTVDIBzFsz/XWE0UIOMi9yNXUhALHS79It0HQl0iTSz2eB5Wm+96ZAG6FY+kIu5C/JrABCCylWrX+ME6/d3Fme2AvwJGmbd307dE2wYWZHbmZaHwwEhUgDNwCXnPKBVB4z4s7yuchjXjFbrkzKxWUVOJst3rdcyAfJIUIhrlFx9TMj2gBa33qilSEIgmxgVCRI9yiGn9J3D5gFASrveGJj03KhIq4efASwQSu3jgK+FmCLrwVY5S8BFiCPAS7KAAovAae3eBalsXD0UpqcA0QLsJvze8Q+w5tKBLCdeVn9IlzJSPl3O+d1FWWR3h+epEJ+XKAf1SzHXZofMVmzETO0azG6tXRM3gJs0KpkokDmAq01yPMTnObcS3QWZBZLwsqdS0E+oZAr/l8u9S3ukojnmcLAPmU00GIgENUe4T0meBb3KfgJuHRE2s7Vpg6x4iSkPwtwhUqa3HQWSW7toWpurGCOBPo+APS8C2ru2QkT8qD7/XVgtxRGuNPZWvY3s6IYMa4qA4Ig4M1bu8Kmkvft8hhg6T57l0IK9RMDDMjjgNce5MrzBHF/K14AO50wpG4CAGicdqiOKAt4Txzw4VXAy0nAm52Ak5tgM+oUJ74B5UzQjDHc+u425BSX4/CFAqw+IK/8UJLlZSQ56yqb6KjwGVOGuaomVDiZrMyTx/256JIsrn6bsy3yGfeeyD6Jslzp/KcE7rdfnO2p/gEABof028qDCRkWaXJ+esIlxAQb8PR1baFiFX5jpr25R70KB/V3Yqf+fiTvfh7tvELhLuSVKuZVOptdjPV/XURBablYPtOFwxjhs+3VDAlgP+zbJ9Zw7datm+J69/L9+/crrg/Usa5EzuVIM4dxtiBEWPSyF945JgqPQnAvFnuhvB6wi59+341jXtkJU7OKYeQtgzoTbustlVXKVuiwcsOlv4WJFSmeyy95lbgAmyLkAtg1QxuklV6ENqVSSLs+AE787Hu8X+QZexOFDLTVc51FSAv/AthZAZaTqhgD7GMBNim/+EQBrIXAlQQJ4+v16Sxyq9+6+Zjyx2RMV6/xLFLxLkKWaOSVlMtKJfEWYH/ZraOFbORlSK7q+YJVVhvX/TwZ7NK9WbyvBJ+f8f3bWyMTlDNv80K+okS0QgCi1Tqxn9QWVT4szgL5RAAA5Ivf+7UKxzf398O9nbgBp8uCHM5ZgNMccgG819kKqSwaj5Q/KFteEJwCp5PhRIb0jKo1OjC9dG02FKCf6oC0U8shvtdXDWRxwFx5Kd4CLPCiwEcAN60ZZOLqwccFOkgjt44C1bMA+0uABXhi+QGIORe+vMMzwVmsi0C3ITfhrv5+qmnEdBbfRYAoVLk6oR4qiQHe7mwjXxDuyrvB/57tUt8aaZXeVZ56onwSLC5shrdQPaj+BgMTpXtZxPXrBq1a5spa5OUtJEuExWXuhyFYJoLCTNWzALuTb6V7C2BBJZaDc6FuN9bzWVWSJSVNDE4AIkS33Q6usnmZSgJYa0K5nq8jX8B95sYW/AQI1+eGoQDBf0rid7czGdPLnpBVC7AKxWiRswVYfC3w2xvoEmuGnsn79ijOAmwxSP2P9+SOdw12npQoZYNBhI6vB83l4sg7KzcI8DVyedyibvv/xP9L84CPbkAb1VlZ/5LqjPR8ltUC/vVlYOn1OLxjreywu07LrdEV3iWk3M+Rl/UXkCfsOnwmHc9oPsbjms+REuF69jnrLzNFwGEMRyrjJr2yTkDgPDhyzFL5MJTILcBGJv1G8pkRWcHSsz7cmobfnxqGW3sliJZyp9fvwg+PapZDJzgQIeRhQM7XWKl7Gv1UUg4Xe4XTM8ZkjOGLnWcw5q3NGPDSRsz8aBcmvbMVQeXS35KZfCf0rmbqTAB36tQJX3/9dV0dDufPn8eDDz6IF198sc6OWRPc9Yjj45U7M/fy1FTlAt+BOtaVyHUdY/DdA/3wnyndcP+QJJj0GiSopReee3aWd5V65stteHed74RArJDlKfni5kx2EYyQC+C+SWGeOE++FrCbkuie8uzJfPKkqvBTow+ArwB2uQ3xFmDeBTq3xCWyjq+XjsEJG1kdZADNhItI5OJkNeGt5CV1vChOP+yTlOqclwU4zWHFr+nKqe8zEAJbkA4qTgBH89m79WZFq9/1amnwopPFG0fLPAIAcTbUjb+Z4CghB8Vcjd88dYhsoBkniKWQgsqk/TOYDUeYb73b2AQ/iev8xa+GtJAnnCm6pJwZsvCCOMvsJpf7PYeIEzJh3Mz7BadNtvte1goGrQp/6HrglfJJnuXPHYrGI1/s9bg/A2J8khAkTXyECQVyC3DLwcrXUgV8bFi+UxrEagTOrY0fMId5CeAaxgATRGMhwqyXZT4OM+l9XaCt3gJYIWTBXwIsQJwwanWt9P2MVEbM2H8WHri2nU+sowedySPGACjXA67EArzLmYIiJolaT+JJmQDmLMCcAJYswNwEZaif9yggsyTLXKB1cgHsXTIPYVxiPS4ZIwxWTy14AFIoCfcOlCzAkii0uwSwjwU4rodcPFtjxWXe3PC2x529vSsOWNEFWm8G49rCCytZFmjeYm2S2tRCSJfVAn6w7GEUIUg2CRkiFCPkl6eBczvE8KgM7n3vQhYDHMQLYOk4Jp0aeo3/sDDeBdqNTqOCkflxgfaeiOFisKHihHbOadGlOHWLbPOHUh+WhQodYM09n90TCSVpB4AN/wBOb0bk+kfAe9254+XdCPlyizByTonjHa8EWIA8Yde4829gpuZHPKD5HsPyvxUXcvG/QmRbdIwLxmnG/eYzj8oEZEUYN8lUnA0TF/pm5vLP5MOE3NBO0rbu0maAj/tzZWgF+e9HLTBcq/IKHXC5QS/efApPrPgTBzlX6fSLF6Bh0phFMEeiKVFnAvjQoUOYNGkSunTpgkWLFiE7Wzlba1X8+uuvmDlzJpKSkvDOO+/A6fQTTxBgCgvFF7jR6JtCHgBMJnHQXlCgkPEugMdy0759e8V/J06cqHrnesZi0KJzMxvGdIrB0DbiDFO8Suqo01wWYL5+76WsLOTlyYUuIMZ6HkqXfsCnM4uw/WSWV4kWEwRBwFSXFThbyQU6PBmZfEdWkC6+gC4dUXYt48mrTAB7uUC7Y4B5F2iuY8pzu0Dnc4m4+tzv9/CJQgYiyyQXH11UsnJ8k4ui876JnEQLsCRK/74uA29uU07Rn8FsomDnBknRAvfb1pmB+J4++8VyQjaIs8rCEo3zufJZaz6jsT8LcAyyZSWOCjShHqsqAMQJlxCCQqi5LN+XmA0FMOKsU27dTklOgSIaneiq7E1kW8DEdQxFl6QyHTzMKbes53KeAjbxWbQZdXCX2fOeuNjjTEKU1YDm4Sa87bgRt5c9iellc7HcMRAr953H5mPSfUyOlE889Ff9CZt7oKXSAM37oTbwrnHZTj8u1PwETbhXJmiyABNXKCqVgBn9ROtr35ZhaB1lVnCB9hLASsmuKrMAA8C1z0HMLs2hCQK6z6i6kXFcONbFA77r/ZQpAoDzCMN3Dtd7wRIDNO8vfpa5QHNJsDgXaE8McBEnsMM4a5c3nCXZOwkWLwrKHE5ZdmL+nY5yueU0g0ukGe4OJVFKKqbgAp3unScjScFDpu318u99HwRaSqEv7kzQii7QegtUnKDlM/ObOcufTHRzFuBEleQlVcgMSIfY3nwmTQ63MJZA8LjGMrG2uxeyGGDOBbpdjPQct1QK/+FQsgAPTI6AivubojRPGidlHvXZ3gOf2CzntDjO8rJuBjmk4+Yzo0xgui3AfH8bVn4BHQQpzjfLq0yS4O2ZBYiZvxUEcLhKPH6ycA7XOzd5lidlbhA/8BPdke3QwVsAn9sBFR8Cxyf58iqDxMdr5zETCsK5tK9FGdK4sgYCWAnemg6IbtD7zubixTW+Y8FwLpt5GVPDYGlaE9h1JoD//PNPXHfdddi/fz8eeOABxMbGYuzYsXjppZewadMm5OT4ipmysjIcPnwYH330ER544AE0b94cQ4YMwQcffACr1Yr/+7//w9y5cxXORlzRMIYoJnXUaUzsCAq5jtKEElmRdzexQhYOXZAy993z8S6U24vlJZVcHfpN3eJh0KoUOyxtRCuZ63B57nlgxV3Af3oBS64TxbCjXIzB/e0NoIJLtJBbAxdojwWYc4FWigHO517aSUMl9zQvWqvOwVgqiVdNRCvka7xEB9exVmT4dk7FpXYwbib/tN0inwzguMSCRcHODQR5NyvozeJA4cb/Af3nSNsgBxpX/UlLOTcoM0fL4n9Vgjye1eanZmK0kA1VkTRIKNaGyQaawUIxWgjSzG+ZoPPMnh/irMAOJiC5stJlSjGsEW3kScKcFfL4NB7+78gn/XAN7NQqwSMyvQXwXmcrRFkMSHDFa212dsImZxe4B8sr90nHTo6yyKytvMUd8T19B+7VxMa5QGdVBClvxA+YvS3A3rU5CeIKYu6oNtj9zHB8dndvMUyiqhhgndF30izY1+tERlR7MQETT5fJMougX7iwD9m7xk2xf8PDeRaG31KeAu5aBzywQ7QoA15JsHgXaE4AF9jhtBfLRak/AWyKlIUU+STB8rJwF9kr8OKaw7jhP1uwv8imeMg8ZsSJS9IxPTGtsrJSueL/Ci7Q55lXdlulEJEOE6V3W1RHYNh82er4ECMm90pAjqDQV+rM0Fqkc9ggid4gLvYTBu796CdL/ykWDfc7n7cAt9F5TQ7neCV7glcMMDfR3irSgmfHtsOwNpFYMM43MSRPmFkvC9UBgOs7hPnmPXG7FFcmgHmres4p/8nbINaLfrdijCxkzeNK7mV0GKGWKjtkcUmwyiqcCOI9ztyc2e6TARqQLPWPab6UjSGtWXvF3xJfCcJlAZa5QHNu+gUsCKZILnyhJAcmnVtiMVmt7HwYoTaFy3/Pbo+OOhbAxzMK8dCyPZ4awTHBBs8kB/+8ZCJYzHzfhKizMkht2rTBypUrsXHjRrz44otYt24dVq1aJUvspFarYbPZoNfrkZOTg5ISucBhjCE2NhazZs3C7NmzYbHUbhBXF7izPhcXFyuuLyoSH+bqtLEuj+Xm4EEFCxREy3Cjp+gS9JBeWpILtDTgNgp2uVXXRayQicPp+WCMYe7yfTh6sRChkM8AurMwBxu1uHdQEnI2+t7XoCi3ABY7kfILh6A9sEJceXab6NZzbgew5klxmbMcGPi4+LkmLtCCrws0HwOcW1ImumzxrmvWWKDdDcCv8vhfAPL6g2odENwMBsNx/FLaCYPU+1FqaY78jncgcuvzAABNjq9HQBjyIfDlJZjN2x7BrQsRRVFlFmCVGuh8q3gdv70mNk1giBZycI5FINiRJU21WaKQliH97lOircjLqHxGGhBF98VyeN5YJfowcaCl1nlidbtwBeWzYIN7EHGIJWIExM4lTxOGUI3/+CeYwn0HFpFtRUsDdy6c/EV5f96Sr+ACDYiulZmFZTjBYj3LjjjjkQsLIqx6vzP0fJH7VpFmIFsSwDH836SW7s8AEMp1gBfL/FmAeRfoVmI8HXNZcRTKwhDElQSfqb3KLNCAmAjLzr2Xq7IAA8CQvwMHlovuooIK6H1f9RrHn1+p/mglMcAvzxiN2KSOYuZnHp2yCzQfA1zhZMi+dB4yyebPBVqllrtA8xZgndon4/vO09lSORd7CT5WOOTBbKnNXRNsUqKmKizAar0RKHWLShd6KxCv4O5sSwCm/yAKkU63ABq9zyYvTOgIe38j8F+5OIbeIgoaFxEeYcGglwlg5RhgHt7CmM8lROQneAEoJkqyCCUwohTFMMgEMADc2a8F7uznJ77cizbRFvx2XBxX6dQqDGup4L3oLklZmQBOvAb44yMxzr2iVF4yMnkk0PcB7N+3C6/stOOoMx4XEIYbVZs9m7hdlA2F8sRWI1S78RpuBiC3AB+9WIAopRpMZ7cp/s1NKEEv4RBGcoIaAATmBI6tk7lAI6ItWhvM+MDJ9XEOaRy7xdkBraO43ydzwOgsgiAABmaHjnNXzmcmBGnV4gSB++94/Geg/Y21EsBbHe1wjVq0VscIWVwpRuAfq6RrUAnAm7d2xRc7z+LIxQKEQ3pvZbJgT+mspkKdJ8EaMmQI1qxZgxMnTuCpp55C165doVKpwBhDRUUFMjMzkZaWhuLiYjDGwBhDZGQkJk2ahG+++QapqamYN29eg4pfAEhIEGdxz53zLbvDL09MTFRcH6hjXRVws3n5LAj5LgtgEaQOx4wSmBQswFHIQVGpHev+uojVf4rupkbBSyhzZYgeGZaM24d3l6/XBMEYGidzHValbpZvk3tGnj7/wDcodzhxPKMQrLIkWMYwxSzQQX5igHOKyr2SKQmilaGDlJWyXB8KJ1OQqCHNAZUa1iAt7imfg+llj2PH0M/xfwek+2jIP+mzG+8mVcCCUAIDimFAMZN3+E4mIAtW0WLNiR7eSns4m+HEJVcHrzXIXIXdpa4i+ZhhS4wsBrhbgg05zI8A5gY3MUK2TPyXGSIAlUosO+Wii0rqONK5DMt7nJKloshSifUXUHbhjWgjDhr5AQs/4OXjXl2ZoOF0yidKONc+dybog6wFDiTdjdOmTphXficA0e1wUvd4hBi1MOrUmNhNeTDdOsoinz3mqWUCLEDunXCxzHcACEAugHVG0QMAgmhBqc7gnyCuFHjrqHfJNzfeVuHq/AaC44ApXwJtrgcmLpYyMlcFf66CdN/1/ESql3t2XEIr5eR//O/ZWQ5UiILCotdIrsYAzp2SrGFlGgvsej8W69J8uQWYE8B6jQpqlSAO/l3wMYnbMw1gKl+7zNE8aaj68NBk6Tq8LcCMySyVrWLFd/ZR1gyfVAxDoS4CGPVvQO1noB/bFeg5s1IPGn2wwiSf3iKLX04RxDGdGSVQcWE5svYaQ8VqBl7wYj2f846KqUiTb+gnU7C7f+ddoGsKnwl6QHI4LPAdi3nigCsTwNY4IKG39P3YT9Ln6A5Ay0HIbX8HfnV2xgWIz5O8xr04trCWyXO0tFGd9eRC4WPDD57Pk0/Qu0nfp/x7ATBfqzTlAjHpFp81OrIN4kOMSIVyje/Vjt6IjoqWEtUBEEqyYdJpfOpkFyBIHBO2kBKxYe+nwPm98vup8FtQ4ienJO7DhAK0CVPe75FhrdGrRSgSw8QxMu8CncmCZWPTpkDAskA3b94c//znP7Fr1y5kZ2fj559/xscff4zXXnsN//rXv/C///0PX3/9NQ4fPoz09HR8/vnnuOGGG6BWV16ztb7o3Fn0z//jD2WXDffyTp06Ka4P1LGuCjhhUGaOw4SuooiRW4BLYVawAKsFhijk4D+bJGtf50jux641icLIhSAICI+MhYzQlhBUKuRqpMGM/oJX5sK8M3IX1oyDmP3eagx/7ReUXDqtfF2GYDGOtAoLcGywdJ0nLhWC5XEdmzkKW0/l4fFfyvCqdhZ+cXTCzKL7PDFB8usQhZ3FoIEdOmxydkUms2BjJnf+imyYvV6+vNsL74Z7icldu7JghQNqBAdp5XGfHNvPl2H0m5uxdMspMd0+N/hzu+JEcOeDOUrmAt0pPhj5gh8BzMXTxAsZsuNUBLn+dtz5unIC+CKXYGqTswuWVozADmcKCvs/pXwuN94DXEEtZTr2lyAiaaj02e2WWJAuT2Bm4yzAnIVpY+wsvBD9OnYw8VojrXo0CzVix9PDsePp4fjXhA6yZwcQE5I0CwkShWezPrJ1FVqzvF5oDeFjgM+X+OkMvQeHIxYCT50Dbvqg1ucliEYJ/6xbomV9i7Scs/oEhfhmjvZHy0HArZ+KE0fVhRe1BRekxDmAOOnGC2CuTByCQsXJKiW82+uyAguCgI5xUp+g/usbz+dd9mb4aI9vWBsA0U2ay7jrdoEO0qo9wpV3gz6TLfVPZU4BDos0qenG7QrcMS4Yg1O4iUiZBThHnoAJQJtm0jv7mYq7sKz/T0BXL/fzmqIzyTJgAxCfEy7eta0qFQBDMOf2KraX62NVapSofd2pTznF50mvUckswCH2agpg5EIlMFm95WpTUQZ8MhFP/XkdPg96EY8YfsDf+keKkxrelOSIbsJFl3zXuTGFA80HKq+L7gjAtyYxnxPEbQGOcvqeY4RKtNoW2CtQ6kr0efTMeZh5g4hbQDorgBMbFZvRQXXa8/mLisHSiiwuuVdiP8AQDINWDa0lSl7vF2KJsd36XjDqdfLEbMXZMOrUnnEgAJQyLezQicm7Ok+WPCmYE1gyWu7ZEcPFCbuo0Pj+jtc7u8uSuvYJt/tskxBqxP1DxDGjWwBHCGQBDjgWiwVDhgzB1KlTMXv2bDz55JO4++67MX78eLRuXc2Zz3qmX79+CA4OxokTJ7B3716f9cuXLwcAjB071medN6NGjYJKpcLmzZuRkZEhW2e327Fy5Uqo1Wpcd911ddL2Rg9nAQ6PTfLEGvEzxWaUwqQ06wjRDXrf2VzP96EtuZqoOpPvDt5WPVcpikKtJHYELhMeANEC7BXrazz7CywohtHp1am5cVsIuU4uWKEOcLtYSUxmFZUhP0M6T6E+ElPf346vdp/D/xUMwrTyJ/FLRXuccSrMOoe5BbD00jqXU4JzzhBZts+WLtcpd/IlXgBfgs3z2TsOOIPZYNCqxBe1HwFchCCUVTixYOVfuPuj3XBa+czMmQhCKay8Jd8SIxPAzUKN8g6Dh6t7aRVKkCJwdYDdlmau5iZfQ9gt7EOMWoxqH4MFFdPxj8jXkNx1sPK53HjH4YW2lFzhTAoCOKojEMllfnS7QPNu1MYw2SCTzwSdVVQmZVgFEGkRz6VVi/Uy9Ro1+rWSi/KW4SZo1CrRmjDtexS2u9WzTt1urH/rRjXgByMXStTKM9BK1pHqDvoJ4kpC5yWAleDd/gPtAcGL7YpSeWIfe55UvgcAYrtw7fIVlR60Xn2mXRI7HeNtAAAdytHyolR+5htnf2xNq6RUC2dtcye35DNsm7lEWLwABoBio4IAdiWDenColxXbuwxSuXzM0D5R/jcz6uvAwOLtDQSIrvJRUviZTShCLLLkGaB1Zp93c4nW5nN4twv0kJRIWQywynuM4kd4ztd+jH36mVCtelQ+QeJNSY7v+lO/AsfXQ23PQR+2D4/iM7T76VbZMyHbvyp3XWOoWGtZiWjR4ONdkolPWhqMIqjhUKwOwccBZ7vigC+ek/pdh6CRJ+g8t6PSpjqYgJcrbkGFT2SoAIz8p+dbYrhZHgcMYJOzM0JCXUYK3iPMVQpJHv8rPssGrUocW4x+Wdqei19H27GeSQKeHIM8y/wlFoxzLFzm0dg5uNB7Nzw4tJUn/MCdZ4R3gb6EYLH0WxOC6gD7QafT4cEHxXqcDzzwgCdOFwBee+017N+/H4MGDUL37tIg/e2330abNm3w1FNyK1NMTAwmT56MsrIy3H///aiokF5kc+fOxaVLl3DbbbchMrKJpCDP41zBbc08blZFsiRYpfKZPA7vIP8esXzMlsIst7dVzzXjVqSv5H5nn5S3E8Ag1T7Zi7hC0MkK1TP3eRSzQLteLNvfRegvz6CTVXqeLp2XXtp784yKfdYZptBW13VYOFenU5lFAAScYtJAaaZmNR5Rr0CfSHFwxJdKkFuApc/udZ54ZT8uYfxM6PpDF8FHicUJmTKxDQgoM4Qho0ASfHG2IGjNyslAYI2Fk7N48KUSmNsa66fkiPtaEkKNeHtKV6ydPRAr7rtGFI6V4T1Zwmd1NHsNegAxoysn+j0C+CKXPdIroRnvVphZaBdrHLqIsspnlgFxIMTTms/SqdHDPGkRMPkLYMQ/IYz6t28ba0AInwW6pFzZnbqWCbYI4oqDd9/k6sbK4GNhvZPC1TXGUHlpGa6cnSxDs6AGOtwk/g8ArUf7P6ZKJRf6XPyu2wI8TPUHTE7RGlfM9Fjt6I3jBZUMlrlSNIUuzy7e7Zm3AKdmyQVwjs43zjofRrSMMOHatl4TwbwFuDRXLiAAdGguF8CZBWWoE0xefZbeAgSFIFcnta+tKlVm+ZNZf10ouZG7XaBHdYhGoaAwoV8FHVSnRZfl3UuUa/JmHAY+GAW82Bz4arp8HZ+3wrP9X8pCtzhbrJrhD0Et/n3iuvlOsmhNYnlBwMftlrcAqwSGFkI6jIKvRbO7cAzBLhfprMIylDucKMqU2l9hivZ4yQFQrAPMc5zFIRPBOGvtKl/RfbrMmyIxzIjTXgJ4laM34mwurwA+kWZxFkx6jew5cFv1Pb+H5OGi2OVpORi48V3FsoJ8nWQAOKlNBiDIMp23NsgnLBLDjB5PS/G7+PfwcYEOaloW4KYl92vIM888g/Xr12Pr1q1ITk7GgAEDkJqaiu3btyMiIgIffCB3+cvMzMSRI0eQnu4ba/DGG29g27ZtWLFiBdq0aYMePXrg4MGDOHDgAJKTk/Haa6/V12U1PHxsZHAzhJtEAcu7QJuEUlkSrFKmhUEQXUp5S1+01YAEM9fJeCctAXw7K9eARbDEgCvXJ+fMNvlsOoABqj+xUrjG8z1bG4XMUhXaCeJLt0QXKs7X+qsDfGID8KOYSOtJ0wlMgVj2ouiSZAE+ViruKwjAwhs6oF+rcJzOKoJ+629A6ibF6+BjfU5misL6FItGB5wGAIxT/w6ogWPOc7gWj8higHkBnOmVLVtMgOV6IfoRPZER4WhebsRp1yDmkioCbjkYK2Qhio//NUfiYmGFTOBHBxtgCA4Hp8kldGaoItvISwu5UFtcHZAfi0uGy7IdH2qERq1CikJtQ0W8J0t4Aeyd7bXDRKDVMHlCLLcLNF8+IaqdbDfeBTqz0C4r7+G2APMMaSMX3smRXs+4IAApo3z2qw0h3GAkr6QcjpuW4NcPnkLfi597fn/umXuCuOqJ6Qzc8Z0YDtPxJuVtOk4CDn0vitH+jwa2PYIgWoHdeSgK0iUPFN792Rgmlii7/3fRVZYP01BCb5biHd2JsM7vxeCfZ+FznQAj1xevcfZEEYLAKgT/I0june2e2DbolAVwplcZmwtCFLyzoeQzE4a3jYJKJchX8N5Dzgp5EjCVBmZjEKKseo+XzaAUhUnM2uBtAXZ5wORYUmDLEicl2gpncIxx/RMv1l2UG0LBGeGQw8zIdVlAW0dZUJbSAricypaHV0khMYwBW94U6+m6w3P++lbMW+H2EFBKrAYA2b4Zp1GSI0/6qNaLya7cGMPE51WtFZNhHV8nrYtq7wknsOg1sqRNhQgCU2khuNrYkSt5VMgMcEIFqyBW/kgSzuMP1hqZRXYczxAQ7swCXI+ZNiQeCG1enbsEAPiTieOpSzGD0SJ/p7gwKMQnG3himAmpXJy2nWnxs7MbbrEZpet2U5wFk76FTwZoQJ4XBiNfEDNVF2UArYYDt3wCaIMUc5LsLw4Fn87rgqktUChmOu8GcaIiBpkApGfvgSGtZJP/IUYtzHoNwpn08GULNtkkVVOALMCVYDAYsHHjRsybNw9GoxHffvstUlNTMX36dPzxxx9oWVk5FS/Cw8OxY8cOPPTQQygrK8M333yDvLw8PPzww9ixYwdCQ31neq5a+CRStmaelPveZZD4JFjHmDR7xVthB6dEQCjjBbDCjKm3i61LOOpDY323daPQEQQLxRjDlZu5KETI2pXrLo+gEAMcpFMDJzd5lqc4pV7NycUAX3DN4k3ulYDb+iSiRbgJQ1IicU0Pr0RegKIL9ElXQqrDTt9SHImlYjZAPu4jTx2GpAjxnvlYgGGTZgT9uNBd36O1mJHYRZZGmhn1sQCbo2TW3xCjFnqNGhabn2QqegsQ0dZncQVTQecuORGpnPU8g7MA1wjvDieCc28O9cqgOfIF8X8uERcKLgCOCp/6gTy8C/TxjCKUO6QZgUgFC3BMcJCnBiUAdIjztSTUFbwFmDEgz6HHd6F3YbD9Nfy7/FasSfmHOJghiKZCy8FA92nKfQsgip/bvwHu3wrE1MPkkIWzPhVwk4N8DWD3eywiBWg9suqwCH7i2F0K6efnoc06jD6qQ+ikkkTICodoCS+GHhXMzxDSnRUekgCWWYB1/gfaZ5y+HkH5MGJgsoJ45V2gAXmiI1cyzPen9cSQlAg8PCwZnePr6N3pI4DF93NxqPSub6dKRYSGc8n2bisAR5C8v+EzQDcLDcLNAzp471IzDv8gfb6wH1j/rDw3BSB/hgp8J5sBKJZcQkmOWC3DDVczGYDc8ODtBs3FSwuCIJZalJbAyVk+O3LPXhoLl1lfEwQxpDCrsAx/puUhBlICLFVwnMfKXB3+dLpC49pPBRL6ipPhE97zKY3YPMyIfVxizXXObihCEGJtrr7bSwCbfSzA4ntEJjZtzcTJqpk/A1OXi+IXUCzLeLRc/uwVhIr30l1NBQCsZRloGyM+k53ig2XWX0C85wmhRtlYsFgXppwk7yqGLMBVEBQUhOeffx7PP/98ldsuWLAACxYs8Ls+NDQUb731Ft566606bOEVRlEmkMMJ4OBmCNeKg+5izp3WLJTIkmAdYQno6LJoxgtS7MvglEigZKd0PKVBilorurCc3yN2VK5BSnBoNOxMA71QSSyTF+PUUmbocywCPzja4wb1VgDAIes1iAVkM73izB8TXaDP75Uuu+wiAAZAgIGrW5fOQhFq0mHuSK86wN4vcrXe43pr4WbTC0rFa/nSMRgD1fsRL1xCnMtlXFeeDxNKZHV8O7dNwSG7CScuFSnGAHsswAnXiG5LfB1IAOGhYbCmSZ3Xec4NJ1bIlNcMtkTjkszaKf69I4PNyGdGubsY4BLAvvWQMxEMk8El1OK6oajVWJiOr5Rtc8lV47nGAtjbW4C3ALcdK9aELrwgdozugaiVm0hhDnHyhC+f4C2AvSzAbgxald/Mnf8Y3xELf/gLbWMsGNS6jqwYClj0GmhUgqfkUk5xGYrKHLiAMCxyjMMz8W19y6gQBFF/+MsE7W0Brgl8DH9ZAVBWrFjrPI2F4Xene9JRQB5MCPPrRiXCJ8Fy410LmOeo3TcnRKnKjB7NFXJFqLXyfomvjewSER3igrHkzl6VtrHGePcTrgkEFtUecGnCtkIqTujaAe7hhYIFmHl5HJ10CeAQo1ac2FZwm1bEHKVsvb10GMg8LnoDnNvpux4QrY5u/FqAfatJiAKYc4FOGS3P8sw/gy28wge8YlttRq2snq9gDAOKxLZ04ATwORaBEujRyVW+srnqArTOCiQcfAeFxSVQq7j2W2N9J63dWGK9qm9IAjgmIgyYsUZ5PwAJYUb85OyO18snIlrIxmsVkwAA8SFu0cpdd1Gm6ALNJSJ1W4AN3tZWU7jvc6XgAn3SKQ8RcER3AQ5lyVyghfxzWH5vX+xOzUHXBJti6FdiaBDCsvnKGn5C0a5iSAAT9YPTCWx4Htj2jjxTY3AzhAmiIOCTH4QhXxYDXGxLAQp+BSAJYK1aQL9WYcBuTpRp/Qieie8D+z4X3UtcFuHYkCBksBA04wS1Eg4mQM0VSXeT6gjDOmd3jLMvBIOAHkJ3DANknZZaYDChFEatSiaANY5iBKMIeTAj1HHJXbIWF1koHhuRItbe5fF+kYe28LgQedf7A8TkVreUzYcAJ47op3lq0MUKWbIJhAE9u2L1LnF/7yzQGYyzAGsNQNIQ+YwyAOjNsvMf4wYvJsGOZIGLo7ZEyxM+uepM9mweitxNJl8BrDPLLbAuMlkwzO4BlCCgZOw72PnKGQxW7/Nsc6G2Ajg4HuIfg4nPEh9DZIkGHv4DcDrkseY6VyIvd1mIczvkSUMi5VZsPgaYp3tiiN8Z2C7NbFhxX+Atr4IgwGbUeYR5TlEZisukCSJzJQNXgiDqAX+1gHn3X+9kflXBh7jYC4HULXJ3VhcfVIyCk3MczGdGhAlVCGC3BZiz+lb2HjlQ7Ct0WzaL9RUMboJskgCWWYCDFDevE3wswOL908VKWXsThQw00+RwAthXzKq8jnPaKQrgZu5+q7oCOKyV/Fnga7MfWQWEPwJc+FN530JOAPuzACu5QBekyzNRJ/YX+2x3DDkvBKM7iWKuxGWh5TOUA67xjvg3VAmAYAoDXMOUDoJ0jjQWjlK1NFmTIGRgkvoX9Dr5vriAf0SslViAw5JkAtjBBPzFRMf7uJDKn5vEMBMYVHjTIc/eHud2geZFbHEWTAaNJxcMIP5mBEHM8l0lChbgcywCn1YMw2T1BpxLuhUh0QkAsmQWYOSlwaTXYGCrMOXM9QBa2ypktYkrmqAAJhdoon44uw347XW5+I3pAliiEWrSQRDk8ahxQiZUkNyoxgwfJlsHMPRsHirOkpZXEQMMiC+8oU/LkppEW4NwEQqzyl6scvZRdPU6ZrcBELCfJeFP1hKnXfG33p2WFcUwFZ+R144FkKzPhQYViOCCgPK04bixq4K7cVCIPBMzJ8wsldT7Y1AhnXsxDrRlIlyQxJk+vIVHwGZ6CeBLzCZziUVrhThTnUWWOOFEoR4lTNqni4oLYDJHe8W7igOj3i3DYA31U1tRwQJ8iQXLLAimICNmlT+K1Y5ecDIBX1QMRpbLml1jAWyJBgbNFev2jvyXWNaKR6NXTrTGu0Ef42KdrPE+rm+8BZhncOvGkQSPjwPOLipDoV3qJI0kgAmiYQmEBdg7Cdbx9Z6vGfHXYpx9IaaU/R0fOOTJtPg6tf5w5/YwVNMCfCDfAKaWvyM7t/IN6fHAW1b5++Fdqqgu8RMDbItL9iSGVAkMnR0HpW0UXKDVFi8BzGopgPlsx0GhQN8HpO+HV4n/V0cA8yKaT+7IJUbzcH6vJLJVGnFSnp+o54WgSg1c9zIQnCDWWY7pIjsU7wJt1msgcBZiPgFWGgtHqUV6FhKFi7hGxd1jHmusKCCV7iGfuA7AMRaPUuhhNWiqLAVk9qqP7UZygeauuygTJp3aywJsgkGjrp67sYIFOB9GPF1xF9rZP0D+sBcR5zovP85Dfhrww6PAC3HAhn/6HAMAUgzSuNPONFAZqx4LX22QACbqB94l1BAMDHkGmPY9IAhQqwSEGnUyAeztlhzWUpoxNAjliEAebuvjSpXBv5z9xWkpEGsz4KJX3KsSvzk74IWKyT7LzzjkM2aebJZqLZycJdoqFMGYecBn/54hRZ6afW66tG8nT47gRhCAEC41SJj0ArdU8cJOY1I7ZyZIAwSm0gKWGI/b7SVvF2iEyOJV0XokPKZqN3qzTACn59tlM5FtVFzCM0s0MhQswABgC1MQf3qz2IGZ5eL4ErPJLAgGrQqx4SG4v3w2OtoX44mKewAAapWAmGDfmNoqGfJ3YPafQI87q78PV44Jhzh3bC/rLyDGvynN/nonu2oo+EmP3OJyFNul32JlsXsEQdQD3rWA3cgEcA2tOXqvGGBOABvajsB+loStzg5gXkPGk1y1AaiVJ/aKIC6vrgt0gd2Jcq9awL3aVBLLyQvL/PqyAHu7QIsTCKFmAw4zSaC1KOeyJyu4QGutXhl9XfezWYiRO241hFJMZ7GcTuvRwJQvxcRsbs7uEF3DL3JCMZ5zCXe7QDsdcjHMlXVSpIyz/Ie2FN3R+SzoXv02Ot4EPPonMOZVnzAa3uPNYtCK7tQKpLFwqMKkyf9E4SLaCgqZqwFpUlrJCswdA5Dcn+NCqjdh7s6i7MagVSHU3W96W4D1vhZgxTGeEl4WYCcTPB4VpdCjWYjRY3mWCWB7PrDrA9E49OtLijWjWzkkq/4xFg+rt9dhE4AEMFE/8CWFUsYAgx6XzcyFm/XIQrCsmLcHQSW+TLkO5PObY3FdR1fnW8bX2qu+AI4ONuAik79g+LJGbs6ySHwsXI+TkSNky3lhCYj1DCsc4oyoUydZa8PUJVCl+5Yj6GguQLQgJW3IYhaM615JYrXYbtJnrkauPwuwe8DBlyaKyfnD81mwNQNUao+AvsDCkKcWZwEvMhsusBCEmrhBjTnStzC7zksA55X43BepodG4yCXBkmU8VqoF7LZKeFmB1dZI2QysIAi4d5CrtBWkQU+szVB12aO6Inm49Jl3f/bKAA2I7Q33sgLH2YKQFNE4aunKLMDFZSgu4yzAOrIAE0SDYqmOAK6pBZh791w8ICt7Y20/SjaRyCdifqNiIn5w9MEnupuATpzo4nC/k3kBbK6iHm8akyYDi2FA69hKrFO8sJTFANfQ+6cm+HGB1qhVOKX2I9YVLMB6m1wkui3AnjwPKhVgsHrv5ovBCvS+B5jyOdCsp+hy7JmUZcDWtyXvO0ElT1jlFr3FWfLKF1UJYJ7w1uL/ve8VPdXM0UCnW6q9O18L2GLQiEmoFCy351gEzDGSyA4X8tFC8OO27c7NoRQHHOolgJlLANuqN2mS6OVZFmcLkiy6sjJIma46wHILcLWzLRuCwU+AFCLIMwll0WtgDdIgwqKHRiUgE1aUMT/H3fOJz6KYYil++4CzeZWW76sREsBE/cALYIXSNWFmHZxQeVxXZejM4oyhTZpZTdJynX0tBbBeo0ahTi7Wtjt9Y07PsggMTI7Eqf4vYZ9TFFq7nck4D/kgo8LJcD5X7GQqOAEcoS2Rxf+6aanLQQwvgFXh6NOykoHL4CeBrrcBAx8H2t7gWexPAD96bTKMOjWy1FxnncHNAttEi7K7+Hk5NHg1ZB6+0VyH+8pmowIauQUY8E1m4WUBLi13+hfAwc2QkS+5QMtq3iq4+nisEl6ZoG/o39XHfWhCt3gpCYWLGrs/Xw4dJipbQPxkqfZ2oRrSJqLRZGAM5f7mYhIszgJcxcCVIIgAw8cAF1wQ07U7nfI+1ttCWRV8DDDvwRKeAtgS0DXB5lnEJ+FLZdF4sPxhfBU8Q9HCWSbo4HAFZhq00nCzMgswAPyRL/WfZRpL5e9GXljyiY3qNQZYmkBINyRBEYX7ExTTBkedoqXyZ0dXFCEIc65tjb5J3DigOm7Qei+RLAhAmzHS913vS5/DW3v6fgCSAOYnU7RGIKR51efljwmIIWaPHQMePSD3WKsCbxdoqLVA8gif7dJYOGLimwMafkLGNz8LAMDksq4rWYC9XKD/dI3rvMcQ/vC2AMssx7z3RWkezFomy2+Sx0yy30KlqNSy59udQAsQSzwKLg/KGJsBDCpPFREf9nwiVqfgMOdIY8GDrLlnHNiUIAFM1A95nCusrZnPardFLEPJJdk9O80JYFnB9loKYAAoN8pnYH9xystYVDAxhva6jtEIsdkwqexZ3Gh/DlPKnoaSa9KpLLEtZRppQBGhLgbS9/lsG41MRAuSkFcFx/nWOeSxxgI3/AcY+owssYG/mbvBKZHYM/9a3HndAMX17g6K33+3szXmV0zHH0zs0EK9BTAnvAEAOotPEi5ZMgYXf7HmQFQHXKquBVitE+NtAR8LsMbiGy+sVavw0NBWsmVB2np8oQeF+BazBxRdoAEg2MvdqLHE/wJyd7ScojIU28kCTBCNBt4C7LCLyffW/l1ees1WScysEno/3ietRM+Wh4YmIyXKgmuSwvDEaN9JYqtBo1gr3q6SBIWsDnAV75HjZVIfojbaKt1W1neUcnk2tLUIf6kupgjJwmqOlsQWgHMhveFU8mRTELJBOi0eNL2KW8uewX3ls/HMmLZ4eFhylfv5oHDvZQKYz70S3VH05nLjdoHm43/NUTWbRHELYEC871WV3fIiIUwSdrFuK6xXzhE70yITVrSKslavvJHa9Yx5W4B1FvH34fIQKGBBOORyW6+uBbh5uLcFmHvWvO5biFDoUwfYb0I3JTjjQAGT2seL9fYx4jOSDj8GlIJ0eR1mpwPCBSks76CzucyQ0VSoFwF87tw5zJkzB+3bt4fZbIZGI3/55eTk4F//+hdeeOEFVFRUvyQNcQVRDQsw4E8Au0QtP2uZy5VSugwBXGGVxPgFFiIKNY50FgaVWoPh7aIQbtKjDFrsYcmwQzlewp0Iq0wrdUgdhJNyt1gX1rILaKbJ9XwPj61+zToefxbgcLMeeo0aulA/gyHX/eRjiLOLyjyllAAFARzfA+hxl5hgZPDfAbXG58V5XsECPK9sGoornLJSB+4kWAB8BTDvkuedCdo7tsjFhG7y50qxbEYg6TpV/l1QKybxAoAzWfJyUte0qqHLYgAJ5QRwRoEdZQ4pGR1ZgAmigQkKkXubrH4M2P6O9L35AHlSpOqgUxBQANBqKACgbYwVax8diM/u7oOkCDO852mtQVpfKyQAh0bqj5txVrKqLMCHmNQvB0VU0S8qWFYBBNYFWq0BbvkEuOYhYPJnsmSJY4f0w1qhr+8+Ci7QgiDgpSl90aLHSCya3hczByiEQPm7Ph6Fe4+Ea5RDi6I6yC3YShZgS3TN4sgjWle9TSWM6hCNMZ1i0DXBhvsGuyzorYaLybVcpLEwqFVq0bNLwa35d0c7FDHX76IL1xd7i2VDsDjhM+7/4Gg5BI+V34tSV5x6VRmg3Xh7l8mEs84kS8BmY3ledYCN1XeBBmThDAWcBZj/PT0xug3GdY5FcFQlv5U/PpI+Z53wZE53MAGHWAKirQGcMGqkBHw6f926dbj55puRn58PxkRXBW93lpCQEHz77bfYvXs32rdvj3HjxgW6WUR94qiQx+YE+7cAX1ISwHolC7A/AVyzOMqSyO7YdLYzeqsO4c2KCTjnJd7OsggMSI6A1aCFuhouqqddwqZULQ0oejj3c1u4SuwAUOWdw/C4UMB1a2zR1XcZ4lEqKaFWccXl/VkDQuQu0ACQnlcq2yTMO9uhIADXvyZmdFSJL3FvAZwG+T382tEfu1kKjl2UZ5Lkk2D5pPvnZ7S9rahmZWupVq3ChzN64e6PdiHcpMMNXWIVtwsYLQaJmTPzXZM9Ya0kK7YXXRNCcDpL6hQbk2WVj8dKyymRrWtM7SSIJokgiDXI3X3ggRXSupguwK2f1bxWt5IF2BwtimkvtGoVoqwGWV9hNWgUY1XNlmDc0CIWRp1aVt2gqom0X5yd8WHFtehpykC7YU9X3nYFYSk2NIAu0AAQ20X858WA5AiU3/0i8J7XvfMjZLs0s6FLM+V14n61tACrNWJSrH2fyZdHd5RPItvzgfJSsb69m5pagMOSq96mEvQaNf4zpZt8YZANSOwHnPoFgOj+3DzcBK1apWgBXu3shXkV0/HF+GCEdb9RWuEtlt3PS8eboOowERufWQO4Ko5U2wLs4wLttZ8xzDMOsDryfGKA42uSTNLIW4A5F2junC3CTXhrcldgbZKnfBQAoOPNwJ9fip+PrhWTYYU0l3kknlXHo3ureIzuIK8v3BQIqAX47NmzuOmmm5CXl4exY8di+fLlCAlRtsrMmDEDjDGsWrUqkE0iGoLCC/LkCtY4n00i3C7QsPnur+gC7UcA13DWNzrEhOnlT6CjfTGWOYbhAguTJeI6yyIxxpVsy6hTK8ZuqLnpcLcFOJ9/UTk463czLvtiwQXEg8u6qHBfqoNGrfLJzhtm0knu1P6Oa2survbjQm3QqvwLHpV0Pm8BfNwZh3JXMoYiZsC/y8UM2kcuSlkjrQaN3A3Ie6aa79CNoUDLIeLn8BRRWPphUOsIHHxuJDY9PgQxwQEeAHmjUgNdpkjfFQZHbmYOaAGDVgVBAD6a0cvvdg0Bb/VPy5ULYMoCTRCNAIvCYNWWANz2dfWSJnmjJKD6PuB3As87u77VoFU8hibIijdv7YoXJnSSWX2VJm359w6DCs9W3Imdgz6q9D0KoGEswFWgjesEtBwsX+hPqFdFlQJY8D/xz7tBu4nu6BvDXJQhzwBtifafSE3w6gMsMbV75qpDx5s8H/ewVujfyiXKFSzAh5wJuKhrjtBet8ifW0us3GOCe14EQcB1HcWQglaRZrSPrd512Ixa2binmXf2aK4Ot8WeDi1Xbzef1d4FWhYDrGSt9vYEuO5ladzMHMCqx8ScAel7PZs073ANPpnZu/qZqa8iAiqAX331VRQUFODmm2/Gt99+iwkTJkCnU3YdHTlyJABg586dgWwS0RDkcvG/xnDFOqqVukC7O1Y+qULuWTHxB+Bx5QBQYxdod0deASkRFF8b2BbbymNJFAQBYSbfAUHbGKnjd5dCSi3yE0+Rch33hQFcHIbioKaaeJdCkmUZ1hmVOzOPBVi5rUrXqoRBq4KOy7aciWA8UX439pmuwVzdU8hw3c8jFyQBHOntbuOdBMu7Q7/1M+D2b4C7f5aJbyW0ahV01SkyHwj6PQK0uV7MYjnwcb+btY8NxtYnh2HX08MxsHWE3+0aAr4MEp8BWq9R1V9WbYIg/MPHAbvpN1s28K4R3u9bg63SMnCxXpYyi0Gj7Ibrpz9WcoHuGOcr9Ia1rUZuBH/CUtPALp2DnpQ+awzK7sjVwVsAW7w8m/QWWU4QGUlD5fWQzdGiB5VGJ584KMyQu0CbI8XzqhTGBsFeE+rhl+f+XCldbgNG/AOn2t2PkOF/w99GuM6lIIAPswS0iVFImKZSyceOXs/Lazd3wbcP9MMPD/Wvdv8mCALuGdgSggD0SAxBtwSvvy3nPm4uOiNbVYAaukBbpXEh7yHZTCnJZ/sb4clN0326eK1DnpHWH18HHPxGnpPGu7JHEyKg/mxr166FIAhYuHBhldu2aNECer0ep06dqnJb4gqjivhfoJpJsHjXaYddnLW0RIt1C723rSbeHTkAnFUnINYpZmceOXggwL0Uw8w6H6tY94QQHEgTY3zPZBej3OHE0TwVFCvZJfQR3YvcCSec5eL/guqyXkQWgwYXuDDjcIuXeA2Ol5fJ0Jo8othfDLFP/K8fBEGANUiLzEIpwdXXzoEQEqfgZHo+UCA27K/zUgOjrF7tq8wCDIgiPmlotdrToOjNwK2fVmvT6t7f+ibETz3AquL2CIKoJ8xeAjgoBOjsW6u+2ni/b3vPUrYKu/B2FfUXA+yvP1ayAHeOD8YvRyX/zTbRFsRXpy5rI7QAAwAS+4riY8/HQJ/7/VrTq8RbAEekyLNdV/J3gs4ItBoGHP5B/B7dQVpnjgJKc8XPhRleSbCiRTd6Y5jcNRoQc4fwHniBFMAqFXDNQ2gBQCZ5vVygzzgjUAgj2kT7seCGtAAyj4qfvZ4XlUqo3AXdDw8MaYXbeifCGqTxFd2c+7ih4LTncwnToQza6meBBoBud8B58FuczSzA544hnsWKFuCI1sDM9UDmMaCdK2Fpp5uBfcuAkxvF7z/OBYo4P+kmLIADOp1/5swZBAUFITm5evEBZrMZRUVFVW9IXFnwGaD9CGC3BbjSGGCDVS6Ucs8AFWVyYWeumTVNKfD/p8g7gaiOQPsJYs1ivp0KoqVrQojHAlrhZFix+xzO2xU6O0Eluh8pxEAj4RrfONga4C1ivcvs+JwzJNETJ6ZVqxRnJGsi0JRS6Bt1arTgsiXuPC2VfJIlwAIUBHDjqInbFAn1I4CNTdBFiiAaJd7xmT1mKHpWVRurl1Wx16xKN/eeOLYatMpusH7EmdJkWrvYYFlyrWvbKSc79D2Yn1jVQMcAV4dBjwOz9wN97q39MXwEsFdSyMoEMCA+G27ajZc+87k0Ci96JcFy3Xvve6vS+HqqBVIA+8OWIHPFPsREC2+bGD/3IpK7Z94W7Msg2KhVLtHFedzpMqXs7LkQxzU1sgCHNAd7YBcGl72Gk0z8ndqMWh+vPw/xPYAuk6X3gTtvi9sjghe/gDgmbaIEVACrVCo4nc6qNwRQUVGB/Px8WK0BiiUgGg6ZBVhB/IGzAEPBTYifRfaOAy5Il29bQzfi6GCDT74QbWIf4L7fgElLpFT6LsLMvsI21haEflwW39fWHZXFAHsITxFdwpQmAZRidWqA98swwrud3ue0yRNuKQlYJbHvD6UU+ka9WuYaVOGU6vVFeluovd3YamjJJ+oOi0Hjk+UVqLp0CUEQ9YR3DGfPuy/veMHxYnm92K5iduMqXKkv1wXaqCAAoqx6JEdKAmZkewU3byVCmvvUdQXQOARwXaBkAeZRuu88rYYBd28Apq0Eut4mLZeVQrrkawEGfEOn9BbfifrLzABdK9RaWTlNdxkjvxbg3veJRoaEa0TX4EDD3TdV9gnP55NOcXxqqOFkslqtgo6rnlPdesUeQlsCw55VXl6dJGtXKQEVwImJibDb7Thz5kyV2/76668oLy+vtrWYuIKohgXYoFXDrNfgElP4MfIznN61gPns0qaIGrsZadUqH7GYEu1ffPlkRYZoKR3VQeqsMwrssmQFHmK7iv8rCuDrfJfVAO843nAfAaxgAeb3V5hNrIkFWFEAazXonqgc9xThLYBVavmLuKpZbSJgqFSCoht0Y3XZJogmR+tRkkWnzwOyOMFaM/Bx4J5NyvXMvYi1eSXBClJOguVvIlOlEnw8SsLNevzzxg4Y2iYSC8a2QweFmGBFBEHMduvNVSuAa2gBBoC47kCLgfLs4FztYmQek9cKdseYe1uA9VZfb62GsAADQLM+no9bHe0BACnRfu6FNQaY8aP4z9vbIRD48Uo4xkTrc40swO5Dcl4TPkm3qkPf+4FJH8oni1x1vpsqARXAw4eLN3fRokWVbldeXo6nn34agiBg9GjFyEniSoa3ANuULcCAWAvODh3y4TVrLLMAc8ItJxXIT5O+1/LFFuM1m50S5X9GNVwhMVS4WYfhbaNkVrN8pjDz7RHAXvcgqoM4i30Z+LhAW7xdoCu3ACvFAYcqiH1/KApgnRrtY4OhV0hIFaVUc47vWEkANyh8KSQ3k3v7KadFEET9Yo0BHtwlWvVGVJ1jpa7xiQE2aEXBqfLqRypJSuntBh1q0qFH81B8ML0npverovavN52akgD2sgDXNgMzHy524U/ps0ojJaX0rgVssMoTVuosl5W887K49jn81WI65pbfjR2sLRJCjYqx5Q2CnxrKxy9DAPMTRjW2ALtpPx54YAcwYTEw8gVg2PzaHecqIaAC+NFHH4VOp8Orr76K999/X3GbP/74A8OHD8f27dthsVhw//33B7JJRENQjSRYAPDvCR3x2d29YQrzitHQ+3OB9rIA17KMUCxX0kGtEpAU6b/T9rYAq1UCrAYtwsx69GqhnK5eOpEfC3DK5Vl/AaUY4BpagBUEbF24QOs0KnSOt/ms83GBBrw6VnKBbkgcnLs6ANzeJxHjOtdzXWWCIPxjayZa9arIih8IgoO0aBku9pMWg0YckAuCrztuJROZvFgRS+5dxnWEJYlWTp6GToJVV/Du7jqLOFGs4+5rbSeL+VrAlw7Jl7uzSitZgPkM5JFtal5zuq6wRMNw3T/xlVNMDDWiujHj9YGfElLHnOLYr0ZlkNyHlAngy3i21Vqg0yTRItzEDQ0Bd4FevHgxHA4H7rnnHkRFRSEnJwcAcM011yAuLg49e/bE5s2bodFo8NFHHyE8vAbFt4nGT2meWGjdjZ8YYECsZ3tNUjjUVq/YH14M8dn/sk96CeDaDdCjOQHcItwEvcb/y8k7BjiUq7c7iotZ8okBFtRSBkZvAXyZ8b+ArwuzrwCuIgZY0QW6+u7k/izAANBNwQ3apwwSIPcOqA83JcIvnbhJi5YRJsy7vl3DNYYgiEaFIAh4e0o3zOjXAu/d0UOy5vpk76/MAiz1s2EmvXIyoZrg7QatvkpCNsJbi8k4BbVYZk8QACPvLVVLCzDvAs3DC2OfGGAr0Hok0HyAuD9f6qkBaBlhxvcP9Mebt3bBYyNTqt6hvgiAC3TrKOm31TXBVqtmEXIC7i8wdepUREZG4oEHHsDx48c9y7dt2+b53KpVKyxatAhDh14BZU6ImsFbf9V6v64hMrxLPPCdaliS/Ng5p6XvtRRNfOKNTlXEHXlbRfnvI9pHY8FKMeNfgbcFOLKt5JIV0Ua8xsILYgr6OkhDX6UF2BQhJuHKPCLWEQyXx9orukDXJAu0goAO0orH7KEkgJUswP0fBbJOiJMkba6v9rmJuueegS1x9GIBws16vH5Ll4arq0wQRKOkXawV82O9Jsa83XEr8eThk+op5daoMR0mAGue4M7tX3xfUQgCMPkzoKxIuiZjmFSKqLYC2OxHAPMWXh8LsEXMszL9B4CxhrP+cnSMD0bH+EaWyEnBApzFLMiG+LeqaRIsAHjqurYIN+vRNsYim6Amak+9OMxfe+21OHLkCH799Vds2bIF58+fh8PhQHR0NPr164chQ4ZAraYSG1cluV4JsPwVbOexeLmyeGeBFtQAcwDMCZz5XVpXSxfoG7vGYeuJTGQXleGR4ZUnYfMWlnzHHWsLQudmNuw7m4sKaFCuDoLW4aoZHNtF2klrAO5aC5zcJCYzqYNOhBewKkFBvKpUwJTPgUMrgeSRPsnCAuEC7Z7h97YAm/Ua5ZqysV2B+7ZU+5xE4OgQF4w1swc2dDMIgriS0HsJkUrK2fEu0HWSYM8cKWb73f4OENkOiO12+cdsTPCCnneL9q6gUF38CmAuplcpBthNIxC/jRaDTRqnujjGJC+82liA42xBWDCufV20jnARUAH80UcfAQBGjhyJqKgoDBo0CIMGDQrkKYnGRjUyQPvgYwHmOlG1VhTBOafE7+5C7kCtkzEE6dR4e0r1OkvvjtrbTfjJUW3w0LI9iLUZoLbbgAKXAI7pIj9QSPM6Tcdv0UsCNNSkg1qpjk1oS9GFSgFFF+gazMorCWi3C3SoSYeW4SaczBRrfCtafwmCIIgrGx8X6EoswJwADqtBuE2ljHpBrLlrjfMpYXhV0e0O4MQG8X63HVe7Y3iX0nLTYQK3jYIFmKgalUosF8XV3D3mlAw0tRHARN0T0DfE9OnTodFokJubG8jTEI2ZatQA9sFSSQwwILpBuwUwTy0twDVBp1HBatAgv7RCbIqXIO6bFIadTw8T45m+6CFaXFVaICmw7v2dmgVDp1ahzOFE75aV13BUwrsOsFYtwFKDjIpKFmC3CzQAdE8M8QhgnxJIBEEQxJVPDVyg+cnk6OA66hME4bIrKlwRtB0LzDksGgdqm+1a7dtno9s0oHl/6bu3Bbi27tZNEWO4XAAzaXxq0FJIUWMgoAI4NFTM6mo0XiXZ+IiaU80M0DLMlbhAA0BoEoD1vvvVRS3EahBu1vsVwACkZB5jXhMtv/E95LHLASDSYsCX9/bF3jM5uKFLzScCLF4W4FCTrkZJSSpzgQaAoW0i8dVu8Vno0sxW4/YRBEEQjRxvgVRJHO4tPZth1Z/p0KgE3NyjmpPjhITZjwW3JlhigIJ06fuIf8jXB4UAgkoMNwPIAlwTTOGApH9lLtC1yQJN1D0BFcBt2rTB9u3bUVhYCLOZypo0SUYsBHrMEIVwVDUzyXoLYO84IiUxabDVW9KLCIu+etZMcyQw8LF6aRMgCsvaikurVxKsmmSABoBghbqxQVyih1EdorFwfAdcKrDjrv41rPFIEARBNH68BVIlgqltjBVbnxwKlSAoh+wQgSdlNLDrA1Hk3rbC14KvUonlCYszxe/eNYkJ/3glwjrOu0BfTskvos4IuAv01q1bsXjxYsyePTuQpyIaK9bYmmdnDksCwpKBrGNAwjW+Lj6hLRXOE3j3ZzdTeidgd2oOwsw6jOoQXfUOVwDeMbw1SYAF+ApoADByWT4FQcDtfRJ9tiEIgiCuEnxcoCuflNaqyRW0QRn5AhDXQ6wK0ayX8ja2ZpIA9jZOEP7hBHCpxopLkCYPKAa4cRBQATxz5kysXbsWTzzxBHQ6He655x5oNFdxYgKiblCpgRlrgdQtQNIQ3/WKArj+6sbe0CUOA5IjYDForpoO3NcCXDMBbNZroFYJcDiZZxm95AmCIJoQvAu0oAY0CvXeicaD1gB0nVr5NgPnAj88CsR1l8cHE5XDJRArsCQBhZKXA42NGgcBVaMzZsyA2WyGXq/HQw89hPnz56Nnz56IjIz0W/ZIEAS8//77gWwWcSVgCgPa+cluaEsEVBrAWSEtq0cBDNRR2YZGhHcW6JpenyAIsBo0yCkuByAmeSC3NoIgiCYEL4D1ZiqVczXQ5jrRVZr+ljUjsZ/nY2bMYIALtaYY4MZBQAXw0qVLIQgCGBOtQtnZ2Vi7dq3itu7tSAATVaLWiCI4+4S0rB5doK9GLtcFGhATYbkFsElHnh4EQRBNCt4FupIM0MQVBonfmtNiIDB1OVCchYuafsAf+z2r9Jqrw3PwSiego9Q77rijRplkCaLahCV5CeD6tQBfbeg1Kk8ZJaBmNYDd8JmgKckDQRBEEyOmC6DWAw67/5hSgmgKCAKQfC0AwHgq27PYoFVBRd5xjYKAW4AJIiB4xwHXUwmkqxVBEGAxaJBVVAagdhZg3opsJAFMEATRtLBEAXeuBs7tBDre3NCtIYhGQazNAEEAGANibbWs20zUOeSnSFyZhHqVQiIX6MumdZQFv5/MgiAAKdE1L3gvF8D0aiEIgmhyxPcQ/xEEAQCIDzHiyVFtsO6vi3hwaKuGbg7hgkapxJVJmLcFmFygL5fnbmiP9349iV4tQtEivOY1lYPJAkwQBEEQBCFj1qAkzBqUVPWGRL1BApi4MonqAKi0gLMcCG4mzz5J1IrWURa8PKlzrfcnAUwQBEEQBEE0dgIqgFu2VKjXWgWCIODEiRNVb0g0bSzRwLi3gL++B/rcR1kKGwHNw4yez/Ehxkq2JAiCIAiCIIiGIaAC+PTp09Xaji+VRFmjiWrTZYr4j2gU3NAlDjtO5SCvpAwzB7Ro6OYQBEEQBEEQhA8BFcBLliypdH1eXh62b9+Or7/+GmazGc8//zyMRrIcEcSViEGrxqs3196FmiAIgiAIgiACTUAF8LRp06q13aFDh3Dttdfi008/xaZNmwLZJIIgCIIgCIIgCKKJomroBgBA27Zt8Z///Adbt27FG2+80dDNIQiCIAiCIAiCIK5CGoUABoAxY8ZAp9Ph448/buimEARBEARBEARBEFchjUYAazQa6PV6ygBNEARBEARBEARBBIRGI4CPHj2KgoICaLXaqjcmCIIgCIIgCIIgiBrSKARwWloapk+fDkEQ0KNHj4ZuDkEQBEEQBEEQBHEVEtAs0DNmzKh0fWlpKc6ePYudO3eivLwcgiDgscceC2STCIIgCIIgCIIgiCaKwBhjgTq4SqWCIAiozinMZjPeeOONKkUzUTkWiwXl5eVISkpq6KYQBEEQBEEQBEHUmDNnziAhIQEHDx6s82MH1AJ8xx13QBAE/yfXaBASEoLOnTtj7NixsFqtgWxOk8BkMqGoqKihm+GDO7kZCfP6g+55w0D3vf6he17/0D1vGOi+1z90z+sfuucNQ2O77yaTKWBtCagFmCDctG/fHgACMotDKEP3vGGg+17/0D2vf+ieNwx03+sfuuf1D93zhqEp3fdGkQSLIAiCIAiCIAiCIAJNQAXwjBkzMGfOnGpvP3fuXNx1110BbBFBEARBEARBEATRVAmoAF66dCk+//zzam//1VdfYenSpYFrEEEQBEEQBEEQBNFkaVQu0BSOTBAEQRAEQRAEQQSKRiWAMzMzYTQaG7oZBEEQBEEQBEEQxFVIwOsAR0dH4/z585Vul5eXh8WLF+Pxxx9Hp06dsHfv3kA1iSAIgiAIgiAIgmii1Gkd4Oeeew7PP/+8bNnFixehVqurtb8gCJg4cWJdNokgCIIgCIIgCIIgANSxAAbkcbyCIFQ7rlen0+H222/Hk08+WddNIgiCIAiCIAiCIIi6dYFOTU3F6dOnAYhCeOjQoQgNDcWKFSv87qNSqWC1WtG6dWsEBQXVVVMIgiAIgiAIgiAIQkZAY4CbN2+OqKgobN++PVCnIAiCIAiCIAiCIIhqEVABTBAEQRAEQRAEQRCNhUZVBokgCIIgCIIgCIIgAkW9CuCMjAz88ccf2Lx5M3799Ve//4irh5KSEsyfPx+tW7eGwWBAbGwsZsyYgbS0tIZu2hVLcXExvv32W9x1111ISUmBwWCAyWRC586d8fzzz6OwsNBnnwULFkAQBL//KPlc1QwePLjSe7hmzRrF/ZYuXYpevXrBbDYjNDQU1113HbZu3VrPrb8y2bRpU6X33P2Prz5Az3r12L17N/79739jwoQJiI+P99yfqqjN87xlyxZcd911CA0NhdlsRq9evfDRRx/V1aVcMdTknjudTmzevBlz585F9+7dYbFYoNfrkZSUhHvvvRenTp1S3K+q30yfPn0CeYmNjpo+55fz/qDnXKKm97067/mhQ4fK9qFnXaI240I3TfWdXudZoJV4++238dZbb+HEiRNVbisIAioqKuqhVUSgKS0txdChQ7Ft2zbExMTghhtuwOnTp7FkyRL88MMP2LZtG1q2bNnQzbzi+Oyzz3D33XcDANq2bYtx48YhPz8fW7duxbPPPotly5bhl19+QWRkpM++/fr1Q6tWrXyWd+/ePeDtvlqYOHEizGazz/K4uDifZbNnz8abb76JoKAgjBgxAqWlpVi3bh1++uknLF++HOPHj6+HFl+5REdHY9q0aYrrHA4HPvnkEwDAgAEDfNbTs145CxcuxHfffVejfWrzPK9YsQK33HILnE4nBg4ciPDwcPz888+YNm0a9u/fj1deeaWOrqjxU5N7fvLkSQwcOBCA+DsYOnQo1Go1duzYgf/973/47LPPsHr1avTv319x/6SkJMV1SUlJtb+AK5DaPOdAzd8f9JzLqel99/eeB4BVq1YhMzNT8T0P0LMO1H5c2KTf6SzA3HLLLUylUjFBEKr9j7g6ePrppxkA1rdvX1ZQUOBZ/uqrrzIAbNCgQQ3XuCuYpUuXsnvuuYf99ddfsuXnz59nXbt2ZQDY5MmTZeueffZZBoAtWbKkHlt6dTFo0CAGgJ06dapa269bt44BYGFhYezo0aOe5Vu3bmU6nY7ZbDaWk5MTmMY2AVavXs0AsGbNmjGn0+lZTs969fj3v//N5s2bx77//nuWnp7O9Ho9q2xIUJvnOSsri1mtVgaArVixwrP8woULrFWrVgwA27hxY11fWqOlJvf8+PHj7Nprr2U///yz7PkuLS1l06dPZwBYQkICKysrk+23ceNGBoBNmzYtkJdyxVDT57w27w96zn2p6X33R05Ojmdf/r3DGD3rPLUZFzb1d3pABfCyZcuYIAjMZrOxFStWsOLiYiYIAouJiWEOh4OlpaWxpUuXsuTkZBYREcE2bNgQyOYQ9YjdbmfBwcEMAPvjjz981nfq1IkBYLt27WqA1l29bN26lQFger2e2e12z3ISBZdPTQXw6NGjGQD2+uuv+6x7+OGHGQD2yiuv1G0jmxBTpkxhANiTTz4pW07Peu2oaoBam+f5xRdfZADYDTfc4LPP119/zQCw66+//nKbfsVSW1FQXFzs6V83bdokW0eioHICIYDpOa+a2j7r7777LgPA+vTp47OOnvXq4W9c2NTf6QGNAV66dCkEQcDChQsxYcIEWZ1flUqF2NhYTJs2DX/88QeaNWuG8ePH4/jx44FsElFPbNmyBXl5eUhKSkLXrl191t90000AgJUrV9Z3065qOnfuDACw2+3Iyspq4NY0XUpKSrBhwwYA0rPOQ8//5VFUVORxr7v99tsbuDVXP7V9nletWuV3nzFjxsBgMGD9+vUoLS2t6yZf1QQFBaF169YAgPPnzzdwawh6zgOHO8yF3vO1R2lcSO/0AMcA79mzBwBw2223yZY7nU7Zd7PZjLfffhv9+vXDiy++iPfeey+QzSLqgX379gEAunXrprjevXz//v311qamwMmTJwEAWq0WoaGhPus3bNiAvXv3orS0FPHx8Rg9ejTFRNaQ999/H1lZWVCpVGjdujXGjx+PhIQE2TZHjhyB3W5HREQE4uPjfY5Bz//l8fXXX6OoqAhdu3ZFu3btFLehZ73uqO3zXFk/oNPp0KFDB+zatQtHjx5Fp06dAtDyqxOn04nU1FQAYnywEseOHcNTTz2FrKwshIeHo3///hg1ahRUKir+UR1q8v6g5zwwnDlzBps3b4ZWq8Utt9zidzt61itHaVxI7/QAC+Dc3FxYLBbYbDbPMq1Wi6KiIp9t+/btC6PRiPXr1weySUQ9cebMGQBQ/GHxy92dOFE3vPnmmwCAUaNGQa/X+6z/+OOPZd/nzZuHiRMnYunSpYqJnQhf/vGPf8i+P/bYY5g3bx7mzZvnWVbV828ymWCz2ZCTk4OCggJYLJbANfgqpDpWAXrW647aPM/5+fnIy8urdL/4+Hjs2rULqampjX6w1JhYtmwZMjIyEBERgWuuuUZxm61bt/pkcu3YsSNWrFiB5OTk+mjmFU113x/0nAeOTz/9FIwxjB49GmFhYX63o2e9f2kwNwABAABJREFUcpTGhfROD3AZpLCwMJ+05zabDcXFxcjNzVXc58KFC4FsElFPuFOuG41GxfUmkwkAUFBQUG9tutpZvXo13n//fWi1WixcuFC2rlWrVnjllVdw8OBBFBYW4uzZs/j0008RFxeHFStWkHtRNRg4cCA+/vhjnDhxAsXFxThy5Aj++c9/QqPRYP78+Z5OBqj6+QfoN1Bb0tPT8fPPP0OtVmPy5Mk+6+lZr3tq8zzzZTeoH6g7zp49i9mzZwMAnn/+eZ+JzuDgYDz++OPYtm0bsrKykJWVhZ9//hl9+vTBn3/+iREjRngGsYQvNX1/0HMeOKqa6KRnvWr8jQvpnY7AZoHu0aMHU6lUsgzAgwYNYiqVin399deybXfv3s0EQWChoaGBbBJRT9x9990MAHv66acV1x87dowBYMnJyfXcsquTQ4cOsZCQEAaAvfHGG9Xe7/z58ywsLIwBYL///nsAW3j1snbtWgaA2Ww2VlxczBhj7NNPP2UAWL9+/fzuFxcXxwCwtLS0+mrqVYE7i/yoUaNqtB8965VTWZKa2jzPaWlpDAADwMrLyxX3mTp1KgPAPv3008u/gCuQmiYGKiwsZD169GAA2Pjx42t0roqKCjZgwAAGgP3rX/+qaVOvGmqbjMnf+4Oe8+pR0/u+e/duT79aWlpao3PRsy5S2biQ3ukBToLl9hHfuXOnZ9mYMWPAGMNjjz2GnTt3ory8HLt27cK0adMgCAL69esXyCYR9YTbRai4uFhxvdsNnlw/L5+0tDSMGjUKOTk5mDNnDh555JFq7xsTE4M777wTALBmzZpANfGqZsSIEejRowdyc3Oxfft2AFU//wD9BmpLbZOi0LNee2rzPPNuotQPXD7l5eWYNGkSdu3ahf79++Ozzz6r0f5qtRpPPPEEAGDt2rWBaOJVjb/3Bz3ngcH9np80aZJiOFdl0LNe9biQ3ukBdoF2i92vvvrKs+y+++5DXFwcTp06hT59+sBgMKB37944ePAgNBoNnn766UA2iagn3EmBzp07p7jevTwxMbHe2nQ1kp2djREjRiA1NRV33nlnrQqQu2Nk0tPT67p5TQbve1jV819UVITc3FyEhIRcER1FY+HQoUPYs2cPzGYzxo8fX+P96VmvHbV5nq1WK4KDgyvdj/qB6uF0OjFt2jT8+OOP6NKlC1auXCmrqlFd6Pm/PJTuHz3ndY/D4cDnn38OwDeJbnVpys96dcaF9E4PsAC+7rrrsHHjRs+sGSDOIGzYsAF9+/YFE+sQgzGGhIQEfP311+jdu3cgm0TUE+6063/88Yfievfyxh4k35gpLCzE6NGj8ddff2HChAl47733fGLuq0NOTg4AKXaDqDne9zAlJQV6vR6XLl1CWlqaz/b0/NcOd2KaCRMmVBq75A961mtHbZ/nyvqB8vJyHDhwAAaDwVPSh1DmoYcewrJly9C6dWusXbtWlli0JtDzf3n4u3/0nNctP//8M9LT05GYmIgBAwbU6hhN9Vmv7riQ3ukBFsAajQaDBg1Cz549ZcuTk5OxZcsWnDlzBlu2bMGBAwdw6tQpjBkzJpDNIeqRfv36ITg4GCdOnMDevXt91i9fvhwAMHbs2Hpu2dWB3W7HDTfcgB07dmDkyJFYtmwZ1Gp1jY/DGMM333wDwH/JKqJyLl26hM2bNwOQ7mFQUBCGDh0KADIPGDf0/NccxpjH7bM2iazoWa89tX2e3X26ez3PDz/8gNLSUgwfPhwGg6Gum3zV8Mwzz+C///0vEhISsG7dOkRGRtb6WCtWrABAz39tqOz9Qc953eJ2f77ttttqNakPNM1nvSbjQnqnI7BJsFJTU1lqaiorKSkJ5GmIRsrTTz/NALBrrrmGFRYWepa7k9gMGjSo4Rp3BVNRUcFuvPFGBoANGDCAFRUVVbp9RkYGe/vtt1l+fr5seUFBAZs1axYDwKKjo6s8TlNmy5Yt7JtvvmEVFRWy5adOnWL9+vVjANi4ceNk69atW8cAsLCwMHb06FHP8q1btzK9Xs9sNhvLycmpj+ZfFfzyyy8MAIuLi2MOh0NxG3rWa09VSWpq8zxnZWUxq9XKALAVK1Z4ll+8eJG1atWKAWAbN26s60u5Yqjqnr/22mueZ5a/55Xx+uuvszNnzsiWOZ1OtmjRIqbRaJggCGzXrl2X1e4rmcrueW3fH/ScV011k2AVFRUxs9nMALDDhw9Xui096xI1HRcyRu90gTHGAiWuVSoVVCoVzpw5g9jY2ECdhmiklJaWYvDgwdi+fTtiYmIwYMAApKamYvv27YiIiMC2bdvQsmXLhm7mFcebb77pKYNx4403wmq1Km73yiuvIDw8HKdPn0aLFi1gNpvRs2dPxMTE4NKlS/jjjz+QlZUFm82GH374gRLQVcLSpUtx5513Ijo6Gt26dYPNZkNqaip2796N0tJStG/fHhs2bPCxzsyePRtvvvkmjEYjrr32WpSVlWHdunVgjGH58uW1imNtqtxzzz1477338Pjjj+Oll15S3Iae9eqzatUqWVmMHTt2gDEmC0OaN2+ezDOrNs/zihUrcPPNN4MxhsGDByMsLAzr169Hbm4u5syZg1dffTWg19mYqMk937t3L7p16wbGGPr27evXpXDmzJno37+/53vz5s1x7tw5dOvWDS1atEBpaSn+/PNPnDp1CiqVCm+++SYefPDBwF1kI6Mm9/xy3h/0nMupzfsFAD777DNMnToVPXv2xI4dOyo9Bz3rEjUdF7pp0u/0QKpri8VCZY2aOMXFxWzevHksKSmJ6XQ6Fh0dzaZPn87Onj3b0E27Ynn22Wc9qegr+3fq1CnGGGP5+fnsiSeeYIMGDWJxcXFMr9czo9HI2rdvz/72t7+xc+fONewFXQH89ddf7L777mPdunVjERERTKPRsODgYNanTx/26quvesofKbFkyRLWvXt3ZjQamc1mY6NGjWJbtmypx9Zf+ZSWlnrKOezbt8/vdvSsV58lS5ZU+Q5ZsmSJ4n41fZ5/++03NmrUKGaz2ZjRaGQ9evRgS5cuDdCVNV5qcs83btxYrfe899/orbfeYtdffz1r0aIFM5lMTKfTscTERHbbbbexHTt21P9FNzA1ueeX+/6g51yitu+X0aNHMwDszTffrPIc9KxL1HRcyNNU3+kBtQB36tQJx44dQ2FhYa3iEwmCIAiCIAiCIAiirghoEqzx48ejrKwMq1evDuRpCIIgCIIgCIIgCKJKAmoBLioqQrdu3VBYWIgff/yRSn4QBEEQBEEQBEEQDUZABfBHH32EzMxMLFiwAKWlpRg1ahT69euHyMjISl2i77jjjkA1iSAIgiAIgiAIgmiiBDwLtLuGF2OsWvW8BEFARUVFoJpEEARBEARBEARBNFE0gTx4QkJCrYtYEwRBEARBEARBEERdElALMEEQBEEQBEEQBEE0FgKaBZogCIIgCIIgCIIgGgskgAmCIAiCIAiCIIgmQUBjgHkyMzOxceNGpKamori4GPPnz6+vUxMEQRAEQRAEQRBE4GOAKyoq8MQTT+C///0vysrKPMsdDofnc05ODlq2bImSkhIcPnwYzZs3D2STCIIgCIIgCIIgiCZIwF2gJ02ahDfeeANlZWVo3749NBpfo3NISAimTJmCsrIyfPnll4FuEkEQBEEQBEEQBNEECagA/vzzz/Hdd98hMjISu3btwv79+xEaGqq47aRJkwAAGzduDGSTCIIgCIIgCIIgiCZKQAXwkiVLIAgCXn75ZXTt2rXSbXv16gVBEPDXX38FskkEQRAEIWPKlCkQBAELFy6sctsdO3ZAEARERUWhoqKixudasGABBEHA0qVLa9HS2rN06VIIgoAFCxbU63mVqKioQEpKCnr16iVb3pjaCACtW7euVUjWnj17IAgCXnrppbpvFEEQBHHZBFQA79mzBwAwceLEKrc1Go0IDg5GRkZGIJtEEARBEDJuv/12AMCnn35a5baffPIJAGDy5MmKIT1XGtOnT4cgCNi0aVO9nfN///sfjh492miErhKHDx/GsWPHMHbs2Brv27VrV4wbNw4vvPACsrOzA9A6giAI4nIIqADOy8tDcHAwgoKCqrW90+mEIAiBbBJBEARByBgxYgSioqJw5MgR7Ny50+92FRUV+OKLLwBIovlK4cYbb8ShQ4fw4IMPNmg77HY7nn/+eXTq1AnXXXddg7alMr7//nsAqJUABoCnnnoKubm5ePHFF+uyWQRBEEQdEFABHBISgry8PJSWlla5bXp6OvLz8xEVFRXIJhEEQRCEDLVajcmTJwOQLLxK/PTTT8jIyEDbtm3RvXv3+mpenRAcHIw2bdogPDy8QduxfPlyZGRk4I477mjQdlTFypUrYbFYMHjw4Frt36dPH7Rq1QoffPCBrAIGQRAE0fAEVAB369YNQPUSW33wwQcAgL59+waySQRBEAThw2233QYA+OKLL2Rl+njcLtLubd2sWbMGY8aMQUREBPR6PVq2bIk5c+YgKyurRm3IysrC448/juTkZBgMBoSGhmLUqFH46aefKt3n6aefRseOHWEymWC1WtGxY0fMnTsX6enpnu2U4msFQcCHH34IABgyZAgEQfD8O336NB588EEIgoB3333X7/lTUlKgUqlw8uTJal3j4sWLIQgCbr311mpt7+bVV1+FSqVCmzZtcPbsWZ9rOnHiBG6++WaEh4fDarVi9OjRnpwiFRUV+Ne//oXWrVvDYDCgVatW+M9//uP3XJmZmfj9998xcuRI6HQ6z/IDBw7gtttuQ8uWLWEwGBAREYEuXbpg9uzZsnvtZvLkycjMzMQ333xTo2slCIIgAktABfDUqVPBGMO8efNQWFjod7s1a9Zg4cKFEAQB06ZNC2STCIIgCMKH7t27o23btrh48SLWrVvns76oqAjfffcdBEHA1KlTPcuffPJJjB49GuvXr0dKSgrGjRsHjUaD119/Hb1798bFixerdf60tDT06tULr7zyCsrKyjB+/Hh07doV69evx8iRI/H666/77HPo0CF06dIF//rXv5CZmYmRI0di+PDhYIzh5Zdfxvbt2ys957Rp05CUlAQAGDlyJKZNm+b5ZzabMWvWLADAe++9p7j/L7/8gqNHj2LYsGFo2bJlldeYn5+PzZs3o1WrVoiLi6tyezd///vf8dhjj6F79+747bff0KxZM9n6U6dOoVevXjhw4ACGDx+O5s2bY82aNRg8eDAuXLiAm266CS+99BLat2+PwYMH4+zZs3jwwQf9Xtfq1avhcDgwbtw4z7Ldu3ejZ8+e+PTTT2GxWHDDDTegT58+KC8vx5tvvokjR474HMdtPV61alW1r5UgCIKoB1gAcTqdbODAgUwQBNa+fXv2f//3fyw0NJSpVCr2008/sXfffZeNHTuWqdVqJggCGzduXCCbQxAEQRB++de//sUAsKlTp/qs++ijjxgANmjQIM+yL7/8kgFgHTp0YMeOHfMsdzqdbP78+QwAu+WWW2THefbZZxkAtmTJEtny66+/ngFgU6ZMYXa73bN88+bNzGg0MrVazfbs2eNZXl5ezlJSUhgANnv2bNk+jDF24MABdvz4cc/3JUuWMADs2WeflW03bdo0BoBt3LhR8Z5cc801DIDs3G6mTp3KALAvvvhCcV9vfvzxR881KuHdRofDwe655x4GgA0ZMoTl5+crbg+APfnkk8zpdDLGxPs/ffp0BoC1a9eOdejQgWVkZHj2W79+PQPAEhMTFdsxceJEplarWWZmpmfZHXfcwQCwV155xWf7Q4cOsfPnz/ssz8vLYyqViiUkJFR6XwiCIIj6JaACmDHGsrOz2aBBg5ggCEylUin+EwSBXXvttaygoCDQzSEIgiAIRVJTU5kgCMxkMrHCwkLZuhEjRjAA7L333vMs69y5MwPA/vzzT59jOZ1O1qVLF6ZWq9mlS5c8y5UE8IkTJxgAZjabWVZWls+x5syZwwCwmTNnepZ98cUXDABr3749q6ioqPLaaiuA3cL//vvvly3Pzs5mBoOBRURE+Ihvf7z44osMAHvuueeqbKPdbmeTJk1iANj48eNZaWmp3+1btmzJysrKZOv27dvnEcfr16/32bdr164MADt16pRsud1uZxaLhQ0YMEC2fPTo0QwA27t3b7Wu1U1cXBwDwLKzs2u0H0EQBBE4AuoCDYiJsDZs2IAPP/wQAwYMgE6nAxOFN9RqNfr27YulS5dizZo1MJvNgW4OQRAEQSiSkJCAgQMHoqioCN9++61n+cWLF/Hzzz/DYDBg0qRJAICMjAzs27cPycnJ6NChg8+xBEFAv3794HA4sHv37krP+9tvvwEARo0ahdDQUJ/17ozTmzdv9ixbv349AGDmzJlQq9U1u9AaMGnSJISFheHTTz9FcXGxZ/knn3yC0tJSTJs2TRYnWxnuMochISGVbldUVITrr78eX331FaZPn47ly5dDr9f73X7w4MHQarWyZW6XbK1Wq5jIyr3eO3Z348aNKCgo8Mn+7E569sADD2DTpk3VrgHt/nteunSpWtsTBEEQgSfgAhgAVCoVbr/9dmzatAlFRUXIyMhAeno6iouL8dtvv+GOO+6ASlUvTSEIgiAIv7jFJp8NetmyZXA4HBg7diyCg4MBAKdPnwYAHDt2TJY8iv/nTrSUmZlZ6TnPnz8PAGjevLnievfytLQ0zzJ3Iih3DG+gMBgMmDZtGvLy8vDVV195li9evBiAKMCrS15eHgDAYrFUut0bb7yBdevW4brrrsMHH3xQpcBXiid2T6hHR0cr7u9eb7fbZctXrlwJALL4XwB4/PHHMXjwYGzZsgVDhgxBSEgIRowYgTfffNNzXUpYrVYAQG5ubqXXQBAEQdQfmvo+oUqlavAyDARBEAShxE033YQHH3wQ69evR0ZGBiIjIz1imK/963Q6AYgCa+TIkZUeMzEx8bLaJAjCZe1/ucyaNQuvv/463nvvPUybNg07duzA/v37MXDgQKSkpFT7OO7Jg4KCgkq3Gz16NH799Vf89NNPWLFiBW666aZKt69sAr2mk+srV65EcnKyz3VZrVZs2LABW7ZswcqVK7Fp0yZs2LAB69atwwsvvIDNmzcjOTnZ53hucWyz2WrUDoIgCCJw1LsAdjgcyM7OBiC6BgXSdYsgCIIgakJwcDDGjRuHL7/8EsuWLcPIkSOxe/duhIeHY9SoUZ7t4uPjAQDh4eFYunTpZZ0zNjYWAJCamqq43m1t5i2d7kzIJ06cuKxzV4fWrVtjyJAh2LBhAw4dOuTJnnzPPffU6DiRkZEA4BkD+KNbt254+umnMWLECEyePBkqlQoTJkyoXeNrwL59+3DmzBn87W9/U1wvCAL69++P/v37AxBdumfPno1ly5bh6aefxpdffumzT05ODgAgIiIicA0nCIIgakS9+B0XFRXh1VdfRc+ePWE0GhEdHY3o6GgYjUb07NkTr776aqVlkgiCIAiivnDX+f300089tX9vueUWWZxpfHw82rRpg7/++gtHjx69rPO5BdWaNWsUXWXdFugBAwZ4lg0fPhwA8P7773us0bXBHb9bVUzrvffeCwB47bXX8PnnnyMkJAQTJ06s0bk6d+4MAIolg7zp3bs31qxZg6CgINx666347rvvanSu2vD9998DgE/8rz8iIyM9dZUPHDjgsz4/Px/nz59HQkJClXHPBEEQRP0RcAG8d+9edOjQAXPnzsXu3btRXl7uSYJVXl6O3bt3Y+7cuejYsSP27NkT6OYQBEEQRKWMGjUK4eHh2LlzJxYtWgRA7v7sZt68eXA6nZg4cSL27t3rsz4rK8tvrVmeli1bYsyYMSgoKMAjjzyC8vJyz7rff/8d77zzDtRqNR544AHP8gkTJqB169Y4cOAA5s6dK9sHAA4ePIiTJ09WeW639bkqUTp+/HhER0dj8eLFKCwsxO233w6DwVDl8XmuueYaqNVq7Ny5s1rb9+3bF2vWrIFer8fNN9/sic8NFCtXrkRoaKhnQoJn0aJFOHXqlM/y1atXA4BPbWIA2LlzJxhjGDRoUN03liAIgqg1ARXA6enpGD58OFJTU6HVajFlyhQsXrwYP/74I3788UcsXrwYU6dOhU6nQ2pqKq699lpPMhCCIAiCaAi0Wi1uvfVWAGICq+TkZPTu3dtnuylTpuDvf/87Dhw4gO7du6N79+64+eabMWnSJHTr1g1RUVF4/PHHq3XO//3vf2jRogU++ugjJCcnY/LkyRg+fDgGDBiAoqIivPTSS+jSpYtne41GgxUrViA6OhqvvvoqEhMTMXHiREyYMAEdO3ZEhw4dsH///irPO3bsWAiCgMceewzjx4/HzJkzMXPmTGRlZfnckxkzZni+19T9GRCTXw0YMADHjx/HuXPnqrXPNddcgx9//BFarRY33XQTVq1aVePzVof09HTs2rULo0ePVgzNWrRoEVq2bIn27dvjpptuwq233oouXbrg0UcfhcFgwPz583322bRpEwBgzJgxAWkzQRAEUTsCKoCff/55ZGdnIzExEXv37sUnn3yCGTNmYOTIkRg5ciRmzJiBjz/+GHv37kViYiJycnKwcOHCQDaJIAiCIKqEt/i6XaKV+Oc//4lffvkFEydOxIULF/Dtt99i48aNcDgcuO+++zxutVURFxeHnTt34m9/+xs0Gg2+/vpr7N69G8OGDcPatWsxZ84cn306dOiAffv24bHHHoPFYsHq1auxYcMGCIKAJ554An369KnyvN27d8cnn3yCdu3a4aeffsL777+P999/XzFR1dChQwGIltn27dtX67q8ufvuuwGImbWrS//+/bF69WpotVpMnDgRa9asqdW5K+OHH34AY8wn+7ObhQsXYsaMGRAEAT///DNWrlyJkpISzJw5E3v37kW/fv189lm2bBnCw8Nx44031nl7CYIgiNojMMZYoA6emJiIc+fOYe3atZ54JX+sX78eI0aMQHx8PM6cOROoJhEEQRAEUQtmzZqFd999F0uWLMH06dNrdQy73Y7ExERERkZWy0JdX4wdOxZr165FZmamp3TR5fD777/jmmuuwdy5c/Hiiy/WQQsJgiCIuiKgAthgMECj0VQ7wZXZbIbD4UBJSUmgmkQQBEEQRA1JTU1F27ZtYTKZcObMGQQFBdX6WP/973/xwAMPYOXKlbj++uvrsJW156WXXkJwcDBmzZpVJ8e74YYb8Ouvv+LEiRMIDQ2tk2MSBEEQdUNABXCzZs2Qn59faZF4HqvVCpvNRhZggiAIgmgEvPzyy9i/fz/WrVuHixcv4o033sAjjzxyWcesqKhA+/btYbVaq50Q60piz5496NatG1588UXMnTu3oZtDEARBeBHQOsDDhg3Dxx9/jN27d6N79+6Vbrtr1y4UFhbWuKwCQRAEQRCBYdWqVfjll18QGxuLZ599Fg8//PBlH1Oj0VSrFNKVSteuXRFA2wJBEARxmQTUAnz8+HF069YNrVq1wrp16xAWFqa4XXZ2NoYPH46TJ09i165daNWqVaCaRBAEQRAEQRAEQTRRAiqAz5w5g23btmHWrFnQarW47777MGTIEMTFxQEA0tLSsHHjRixatAjl5eX43//+p1hqAgASEhIC1UyCIAiCIAiCIAiiCRBQAaxUS682CIKAioqKOjkWQRAEQRAEQRAE0TQJaAxwXWlriqUhCIIgCIIgCIIgLpeACuBTp04F8vAEQRAEQRAEQRAEUW0C6gJNEARBEARBEARBEI0FVUM3gCAIgiAIgiAIgiDqAxLABEEQBEEQBEEQRJMgoDHAPFu3bsX+/fuRk5OD8vLySredP39+PbWKIAiCIAiCIAiCaCoEPAb4xx9/xP33348zZ85Uex+HwxHAFhEEQRAEQRAEQRBNkYBagDds2IBx48Z5BG2rVq0QFRUFjabeDM8EQRAEQRAEQRAEASDAFuBBgwZh8+bN6NmzJ5YtW4aWLVsG6lQEQRAEQRAEQRAEUSkBFcAWiwXFxcU4evQokpKSAnUagiAIgiAIgiAIgqiSgArg0NBQOJ1O5ObmBuoUBEEQBEEQBEEQBFEtAloGqW3btigpKUFpaWkgT0MQBEEQBEEQBEEQVRJQAXzvvfeivLwcn3zySSBPQxAEQRAEQRAEQRBVEvAySNOnT8fy5cuxePFi3HrrrYE8FUEQBEEQBEEQBEH4JeACGAAWLFiAhQsXIiEhAT169IDFYvHfIEHA+++/H+gmEQRBEARBEARBEE2MgAvg9957D48//jgKCgpQ2akEQQBjDIIgeOoGEwRBEARBEARBEERdoQnkwb/77jvMmjULAGAymdC3b19ERUVBownoaQmCIAiCIAiCIAjCh4BagPv164fff/8do0aNwhdffFGp6zNBEARBEARBEARBBJKACuDg4GAUFhbi3LlziImJCdRpCIIgCIIgCIIgCKJKAloGSavVIjg4mMQvQRAEQTQAgiBAEARs2rSpoZtyRTF9+nQIgoDp06c3dFMIgiCIOiagArhz584oKChAQUFBIE9DEARBEHXOggULPAKyodm/fz+eeOIJ9OrVC1FRUdDpdAgODka7du0wbdo0fPfddygvL2/oZhIEQRBEoyegAviRRx6Bw+HAf//730CehiAIgiCuSgoKCjB16lR06dIFL730Enbu3IlLly7BZDLBbrfj0KFD+OijjzB+/Hi0bdsW27dvb+gmEwRBEESjJqACeNy4cZg/fz7mzZuHf//73ygpKQnk6QiCIAjiqiEnJwd9+/bFZ599BgC49dZb8csvv6C0tBQ5OTkoLS1FWloaFi9ejE6dOuHEiRP4/fffG7jVBEEQBNG4CWg9oqFDhwIQSyA9/fTTWLhwIdq1a1dpNmhBEPDzzz8HslkEQRAE0eiZOnUqDh48CI1Gg88++wyTJk3y2SY2NhZ33XUXZsyYgUWLFjUKd22CIAiCaMwE1AK8adMmbNq0CXl5eWCMoaSkBLt37/Ys9/ePIAiCIBozmzZtksUHHz9+HDNmzECzZs2g1+sRHx+Pu+++G2lpabU6/o8//ogff/wRADB//nxF8csjCALuu+8+3HPPPX63KSgowDPPPIM2bdogKCgIYWFhuP766yt1mz5w4AAWLFiAoUOHIikpCUFBQbBarejatSueeeYZZGZm+t23efPmEAQBS5cuRVlZGV5++WV07twZJpMJwcHBGDp0KNasWVPpNbkTeNWm7W5WrVqFiRMnIi4uDnq9HiEhIRg4cCDeeecdlJWVVbm/El988QVGjx6NqKgoaLVa2Gw2JCcnY9y4cfjPf/6D0tLSWh2XIAiCCDwBtQA/++yzgTw8QRAEQTQ4GzduxLhx41BYWAiLxQKn0+lxTV69ejV27NiBuLi4Gh3z7bffBiCWE5wzZ06191OplOe109PT0a1bNxw/fhwGgwEqlQrZ2dlYtWoV1q1bh5UrV2LEiBE++11//fVITU0FABgMBhiNRuTk5GDv3r3Yu3cvli5dip9//hkpKSl+21RYWIiBAwdi+/bt0Gq10Ov1yM/Px8aNG7Fp0yYsXrwYM2bM8Lt/bdteUlKCO+64A8uXL/css1qtyMvLw+bNm7F582Z89NFHWL16NUJCQvye35sZM2ZgyZIlnu9msxnl5eU4fvw4jh8/jpUrV2LMmDFo3rx5tY9JEARB1COMIAiCIAgfnn32WQaAKXWVGzdu9KwLCQlh48aNY4cOHWKMMWa329kXX3zBLBYLA8Buv/32Gp23vLycmc1mBoDddNNNl3UNfBvbtWvHNmzYwBwOB3M6nWzHjh0sJSWFAWCJiYnM4XD47H/HHXewpUuXstTUVM8yu93O1q9fz3r16sUAsG7duimeOzEx0XPuuLg49u2337KysjLGGGOHDx9mffr0YQCY2Wxmubm5dd722267jQFgLVu2ZJ9++inLy8tjjDFWUlLCvvvuO9ayZUsGgI0fP95n32nTpjEAbNq0abLlmzdvZgCYSqViL774IsvKyvKsy8zMZGvXrmXTpk1jaWlpiveEIAiCaHhIABMEQRCEAtUVwEOGDFEUYG+99RYDwIKCglh5eXm1z3v8+HHPsf/5z39e1jW4jxMREcEuXrzos37//v2ebX777bcaHbugoIBFRUUxAGzz5s0+690CWK/XeyYHeDIyMpjBYGAA2CeffFKnbf/1118ZABYZGcnOnDmj2P6zZ88yk8nEALA9e/bI1vkTwC+++CIDwEaMGKF4TIIgCKLxE9AYYIIgCIK42vn73/+u6Hp8ww03ABBdcY8dO1bt42VlZXk+h4aGXn4DAdxzzz2IjIz0Wd6xY0e0aNECgFhruCaYzWYMGjQIAPDbb7/53e6mm25CmzZtfJZHRESgb9++VZ67Nm1///33AYiJxJo1a6Z43Pj4eAwZMgQAsHbtWr/n57HZbACAS5cuweFwVGsfgiAIonER0BhgN8XFxVi8eDHWrl2L1NRUlJSU4MSJE571eXl5WLVqFQRBwOTJk+ujSQRBEARRJ/Tu3VtxeWxsrOdzdnZ2fTVHEX9tBMR2njp1ym8bf/jhB3z88cfYuXMnLl68iOLiYp9tzp07V+tzA5Xfn9q0fcuWLQBEIewuI6VEXl4eAHjinKti2LBhMBgM2LNnDwYMGIC77roLQ4cO9QhxgiAIovETcAG8d+9e3HDDDTh37hwYYwDgU6bBarXiH//4B44cOYKoqChP+SSCIAiCaOz4K+2n0UhdbHl5ebWPFxYW5vlcV8K5svKD7nZ6t9HpdOK2227DsmXLZNuGhIRAp9MBEAVkaWkpioqK6vTcl7v/+fPnAQD5+fnIz8/3u78bJVGvRFJSEhYvXox7770Xv//+u6fuckREBIYMGYIpU6Zg3LhxVI6KIAiiERNQF+isrCyMGTMGZ8+eRbdu3fDKK6/AarX6bCcIAu666y4wxvD9998HskkEQRAE0ahJTEyE2WwGAOzZs6fB2vH+++9j2bJlUKvVmD9/Po4dOwa73Y7s7GxcuHABFy5cwE033QQAngnuxoLbPfmdd94BE/OdVPpv6dKl1T721KlTkZqaikWLFuGWW25Bs2bNcOnSJXz55ZcYP348Bg0aVC3RTRAEQTQMARXAr7/+OtLT0zFs2DBs374dc+bMQVBQkOK2Y8aMAQDPbCpBEARBNEU0Gg0GDhwIAFi3bl2l1tVA8vnnnwMAZs6cieeeew6tWrXyiXW+cOFCQzStSqKjowFU37W5poSGhmLWrFn4/PPPcebMGRw/fhxPPvkkBEHA5s2bsWDBgoCclyAIgrh8AiqAV65cCUEQ8NJLL/mtTegmJSUFWq1WFhtMEARBEE2RBx54AIDoYvzaa69Vez+n01lnbTh79iwAoGvXrorrCwsLsX379jo7X13Sr18/AGL8cn2QlJSEF154AVOmTAEgTlwQBEEQjZOACuCTJ09Cp9OhS5cuVW4rCAKsViu5DREEQRBNnuuuuw4jRowAADz//PNYvnx5lfu8++67eO+99+qsDcHBwQCAffv2Ka5fuHAhCgoK6ux8dck999wDADhw4ADeeeedSrctKipCWVlZtY5rt9srXe/2cqtq0p8gCIJoOAL6hnY6ndBoNNVKBsEYQ2FhIUwmUyCbRBAEQRBXBJ999hnatm2LiooK3HzzzZg6dSo2b94sS/iUnp6ODz/8EN27d8esWbNQUlJSZ+cfNWoUAOC9997Du+++6xGJFy5cwKOPPoqXXnpJlrCrMTFo0CDceeedAERr+qOPPoqTJ0961tvtdmzbtg1z585FYmIiMjIyqnXcBx98EDfffDNWrFgh26ewsBCLFi3CRx99BEAK6yIIgiAaHwHNAh0XF4cTJ04gIyNDsYYfz86dO2G329G2bdtANokgCIIgrgjCwsKwbds23H333fjqq6/w2Wef4bPPPoMgCLDZbCgpKUFpaaln+7Zt22LAgAF1dv6//e1vWL58OQ4fPoxZs2bhvvvug9VqRV5eHhhjmDVrFkpLS/Hhhx/W2TnrkkWLFkGtVmPx4sV444038MYbb8BsNkOr1SIvL0/mLl7drM3l5eX46quv8NVXXwEQayFrNBrk5uZ6tunfvz+efvrpOr0WgiAIou4IqAV48ODBAIAlS5ZUue1zzz0HQRBw7bXXBrJJBEEQBHHFYLVa8cUXX2DPnj147LHH0KNHD4SHh6OgoABarRZt27bFtGnT8MMPP+DPP/9E9+7d6+zcNpsNW7duxezZs9G8eXOo1WpoNBoMHjwYy5Ytw6JFi+rsXIFAp9Phvffew9atWzF9+nQkJSXB4XCgsLAQkZGRGDx4MObPn4/9+/cjLi6uWsecN28e3nrrLdx4441o06YNNBqN53jXXnstPvjgA2zatIm82QiCIBoxAgtg7YKDBw+ic+fOMJlMWLFiBYYPH46YmBhkZGR4ShRcvHgRc+bMwbJly6DX63HkyBEkJCQEqkkEQRAEQRAEQRBEEyWgAhgAXnrpJU9pgK5du+Kvv/6C3W7HLbfcgtTUVOzevRvl5eVgjGHRokWexBUEQRAEQRAEQRAEUZcEXAADwPvvv4/HHnsMeXl50okFAe5T22w2vPHGG7jjjjsC3RSCIAiCIAiCIAiiiVIvAhgQMySuWLECW7Zswfnz5+FwOBAdHY1+/fph0qRJnnILBEEQBEEQBEEQBBEI6k0AEwRBEARBEARBEERDEtAs0L/++iu2bdtW7e137NiBX3/9NYAtIgiCIAiCIAiCIJoqAbUAq1QqxMTEIC0trVrbt2jRAmfPnkVFRUWgmkQQBEEQBEEQBEE0UQJqAQaAmupr8sgmCIIgCIIgCIIgAkHABXBNKCoqglarbehmEARBEARBEARBEFchjUYAHzlyBJmZmYiMjGzophAEQRAEQRAEQRBXIZq6PNh3332H7777TrYsLy8PM2bM8LsPYwy5ubnYvHkzBEHAgAED6rJJBEEQBEEQBEEQBAGgjpNgPffcc3juuecgCEKtYnkjIiKwefNmtG7duq6aRBAEQRAEQRAEQRAA6tgC3KVLF0ybNs3z/cMPP0RQUBBuvvlmv/uoVCpYrVZ06NABEydOhM1mq8smNTmio6NRVFSEhISEhm4KQRAEQRAEQRBEjTlz5gxMJhMuXLhQ58cOeBmk6OhonD9/PlCnILywWCwoLy9HUlJSQzeFIAiCIAiCIAiixpw4cQJarRYFBQV1fuw6tQB7s3HjRuh0ukCegvDCbfk9ePBgA7eEIAiCIAiCIAii5rRv3z5gxw6oAB40aFAgD08QBEEQBEEQBEEQ1abRlEEiCIIgCIIgCIIgiEBCApggCIIgCIIgCIJoEpAAJgiCIAiCIAiCIJoEJIAJgiAIgiAIgiCIJgEJYIIgCIIgCIIgCKJJQAKYIAiCIBo5ZRVOHLlQAMZYQzeFIAiCIK5oSAATBEEQRCPG4WQY89ZmjHzjV8z77kBDN4cgCIIgrmhIABMEQRBEI+ZQej6OZRQCAFbsTiMrMEEQBEFcBiSACYIgCKIRk19a7vlcUu5AcZmjAVtDEARBEFc2mvo4yYULF/DBBx/gt99+w7lz51BUVOR3BlsQBJw4caI+mkUQBEEQjZ5iu1zwZhbaYdLXS/dNEARBEFcdAe9Bv/nmG0ybNq1K0eteJwhCoJtEEARBEFcMRWUVsu+ZhXYkhpkaqDUEQRAEcWUTUAH8119/YcqUKbDb7RgzZgzGjBmD+++/H8HBwXj11Vdx4cIFrF+/Hps2bUJ4eDgWLFgAk4k6dYIgCIJwU+RjAS5roJYQBEEQxJVPQAXw66+/Drvdjttuuw0fffQRAOD+++9HUFAQZsyYAQD4+9//jh9//BGTJk3Chx9+iN9++y2QTSIIgiCIK4oiu68FmCAIgiCI2hHQJFibNm2CIAh46qmnKt1u9OjRePXVV7Fz50688cYbgWwSQRAEQVxR+LhAF5AFmCAIgiBqS0AFcFpaGjQaDdq2betZJggC7Hbf2evbb78darUan3/+eSCbRBAEQRBXFN4W4KwisgATBEEQRG0JqAu0TqeDVquVLTObzcjLy0NFRQU0Gun0RqMRFouFMkATBEEQBEdRmW8WaIIgCIIgakdALcCxsbHIz8+H0+n0LGvevDkYY9i3b59s25ycHOTm5qKsrPG4du3evRv//ve/MWHCBMTHx0MQhMvKUp2Tk4NHHnkEiYmJ0Ov1SExMxOzZs5Gbm1t3jSYIgiCuKnxigMkFmiAIgiBqTUAFcOvWrVFRUYHDhw97lvXr1w+MMbzyyiuybZ955hkAQEpKSiCbVCMWLlyIp556Ct988w3S0tIu61iZmZno1asX3nrrLWg0GowfPx4WiwVvvvkmevfujezs7DpqNUEQBHE14ZMFmlygCYIgCKLWBFQADxs2DIwxrFmzxrPs3nvvhUqlwpdffokOHTpg6tSp6NSpExYtWgRBEDzZoRsDffv2xbx58/D9998jPT0der2+1seaPXs2jh8/jgkTJuDIkSP44osvcODAATz00EM4evQo5syZU4ctJwiCIK4WfC3AnAC2FwDLJgMfjAIyj9dzywiCIAjiykNgjLFAHfzixYt48sknkZycjL///e+e5W+//TYeffRROBzyWe3Jkyfj008/DVRzLhuDwQC73Y6a3rL09HTEx8dDo9HgzJkziIqK8qyz2+1o1qwZsrOzcf78eURGRl5WG9u3bw8AOHjw4GUdhyAIgmgc3PD2b9h3Lk+27Mg/RkGvUQO7lgA/zBYX9pwJjHm1/htIEARBEHVMIDVNQJNgRUVFYcmSJT7LH3zwQQwfPhzLly/H2bNnERwcjFGjRmHo0KGBbE6DsWbNGjidTgwYMEAmfgFAr9dj7Nix+OCDD7B69WpMnz69YRpJEARBNEoKvSzAAJBdVIaY4CCgIF1aWHChHltFEARBEFcmARXAldGmTRtP3O/VjjvhV7du3RTXd+vWDR988AH2799fn80iCIIgrgCKvbJAA2IirJjgIKC8WFpYXlKPrSIIgiCIK5OAxgATImfOnAEAxMfHK653L09NTa23NhEEQRBXBkoWYE8pJF70VlByLIIgCIKoigazADclCgsLAYi1jpUwmUwAgIKCgmof0+0X782JEyeQlJRUwxYSBEEQjRHGmLIFWFEAkwWYIAiCIKqiXgTwiRMn8OWXX2L//v3Izs5GeXm5320FQcDPP/9cH80iCIIgiEaNvcIJh9M38WJmoasWMO8CTRZggiAIgqiSgAvg5557Dv/4xz/gdDqrlT1ZEIRAN6neMZvNAIDi4mLF9UVFRQAAi8VS7WP6y4jmzzJMEARBXHl4l0Byk6VkAaYYYIIgCIKokoAK4E8//RTPPfccACA2NhYjR45EbGwsNJqm5XmdkJAAADh37pzievfyxMTEemsTQRAE0fgpsvu6PwO8CzRZgAmCIAiiJgRUif7nP/8BAIwbNw5ffvkldDpdIE/XaOncuTMA4I8//lBc717eqVOnemsTQRAE0fgpKlO2AEsu0HwMcGk9tIggCIIgrmwCmgX6wIEDEAQB//3vf5us+AWAUaNGQaVSYfPmzcjIyJCts9vtWLlyJdRqNa677roGaiFBEATRGPHnAq2cBIsEMEEQBEFURUAFsCAIsFqtiI2NDeRpGg1vv/022rRpg6eeekq2PCYmBpMnT0ZZWRnuv/9+VFRIA5q5c+fi0qVLuO222xAZGVnfTSYIgiAaMUolkAB/SbBIABMEQRBEVQTUBbpNmzbYu3cv7HY79Hp9IE8VEFatWoWFCxd6vpeViQOOPn36eJbNmzcPY8aMAQBkZmbiyJEjSE9P9znWG2+8gW3btmHFihVo06YNevTogYMHD+LAgQNITk7Ga6+9FuCrIQiCIK40+BJIJp0aRa7v2UV2OJwMat4C7KwAHBWAumnl2SAIgiCImhBQC/DMmTNRXl6Or776KpCnCRiXLl3C9u3bPf/cWaz5ZZcuXarWscLDw7Fjxw489NBDKCsrwzfffIO8vDw8/PDD2LFjB0JDQwN5KQRBEMQVCG8BTggzeT47GZBbXCa3AANkBSYIgiCIKhBYdWoTXQbjx4/Hr7/+im+//RYDBw4M5KkISGWQ/JVJIgiCIK4clm45hQUr/wIADEmJwJYTWSircAIA1s4eiJT3WgKOMmmHx08CpjDxc+ElYPsiICwJ6DKlvptOEARBELUmkJomoH5Szz//PDp37ozNmzdjyJAh6NevH3r37l1lvdv58+cHslkEQRAEcUVQxLtA6zUIM+mQnidaebMKiuTiFwAqOJfoTS8Au94XP4clA816Brq5BEEQBNHoCagAXrBgAQRBAAAwxvDbb79hy5YtVe5HApggCIIg5FmgTToNQoySAM7PL/Ddga8FfOFP6XP6XhLABEEQxP+zd97hclT1/3/P9nJ3b+/3ptx0EhJCEkJvImJBRAQ7IGADREV/Igo2/CqiolJEVEJVBKnSSyCUhBTSe7k3t/eyve+c3x+zO+ecmdlbcu+mntfz5MnM7Ozs7N7dmfM+708RIM8C+Mwzz1QFsEAgEAgEgrHBCWC7BaUFtKVgMBjQP4EtipUI0+WYPx+nJxAIBALBEUdeBfCKFSvyeXiBQCAQCI5q+BBoM0rcjAAOGQhg1gFOhOiyEMACgUAgEADIcxVogUAgEAgEB47WAWYFcDhkFALNOMBshegRBHBPIIbP3LsSF979PtoGI8PuKxAIBALBkYwQwAKBQCAQHKaENX2AS1xUAEcjIf0T2DZIbAh03MAtZnhsdQs2tfmwtcOPR1e3HPD5CgQCgUBwuJPXEGiBQCAQCAQHjtYBNploXY2YoQDOhEDL8pgc4OYBum/HUHSYPQUCgUAgOLI5KAJ4xYoVePzxx7FlyxYMDg4imUzm3FeSJDQ2Nh6M0xIIBALBMYQvksDOriBOmloCs+nIKNDICmCXzQKXzayuJ6MGAjhbBCupCWMeRQh0lv5QfJg9BQKBQCA4ssmrACaE4KqrrsIjjzyiro+EqBotEAgEgokmmkjj3D++g8FwAl85eRJ+/ZnjD/UpjYpwggrgArsFNgvNXErEwvonZB3gcQjgwXBimD0FAoFAIDiyyasAvvvuu/Hwww8DABYtWoRPf/rTqKmpgcUiIq8FAoFAcPDY2DqkCrvlO3vx688c2vMZLZE4zQF22c3wOqzqejoe1t/Fs0WwEhp3OCOA46k0unwxTClzqw8RQtDtpwJ4QAhggUAgEBzF5FWJPvjgg5AkCddccw3uv//+fL6UQCAQCAQ5iSapkIyn5EN4JmMjFOcdYLYKtJ0YhCpnHeCExh2OBRBNpPHRP72D9qEovnfeDHzvvJkAgEA0xX0mQ5EE0jI5YsLEBQKBQCAYC3mtAr1nzx4AwO23357PlxEIBAKBYFg4AcwsH86k0jInTN12C4qcVmR1qQMGAjibA5zQhECn41i5qx3tmQJXT29oVx/qZsKfAYAQRQQLBAKBQHA0klcB7HA4UFRUhOLi4ny+jEAgEAgEwxJLUiF5pDjAbAskQGmDZDJJKM60QnLCQKSqDrC+QFZ3T4+6PBSmxSi1AhgQecACgUAgOHrJqwA+/vjjEQgEEAoZVKoUCAQCgeAgEWNc35RMkEof/iI4whTAApQq0ADUMGinZBQCnRGz2iJYAPr6e9XlUDyFZOYz6DEQwKIStEAgEAiOVvIqgK+//nqk02ksW7Ysny8jEAgEAsGwxDRhz4nDUAA39oXwyxe2Y/lOxallWyDZzCa1AnSxezgHOCNmtTnAAPxD/dx6IKq4wD1+4QALBAKB4NghrwL4c5/7HK677jrcdNNNePTRR/P5UgKBQCAQ5EQb9hxPHn4C+AdPbsaDK5vxrcfWo7k/jDBTAdptp/1/SzMC2DAHWBXA+siroH+AW/dlBLBRCPRASAhggUAgEByd5LUK9FVXXQUAcLlcuPLKK3HrrbdiyZIl8Hg8OZ8jSRIeeOCBfJ6WQCAQCI4xopp82sMtDziZlrGl3ZdZJnhlWzcW1BWqj2fDnwE2BNpApCazAlgfAp0IDXHr/qwDHNALadEKSSAQCARHK3kVwA899BAkSQIhBADQ2tqK1tZWw32z+wkBLBAIBIKJRhsCHU8dXpWgu3wxyISuv7GjG9MrCtT1Aju9XZceYAi0B7wo9keyAtjIARY5wAKBQCA4OsmrAL788sshSaKPoEAgEAgOLbHU4e0Atw3x4nRjmw8tA1TEupgQaJoDPFwRLL0A9oLf5osqAlpUgRYIBALBsUTeHWCBQCAQCA41seThnQPcNsgLYEKAp9bTXr2sA5wNgXYYhUAP5wBLegc4lZYNKz6LHGCBQCAQHK3ktQiWQCAQCASHA4dTCPS+3iA6fFFum9YBBoBd3UF1ua7YpS6Xuu0AcjnA2T7ARg4w/xq+aBJ9oTgI0e2KgbAIgRYIBALB0YkQwAKBQCA46tEL4IPjAN+1fC/OuOMt/GtNCwDgxS2dOO/Od3H6795Si14BQNtgNMcRAJfNjK+fMVVdLxkuBziZOY6RANY4wL5IEt0GLZAAUQRLIBAIBEcveQ2BZvnf//6H1157DS0tLYhGo1i+fLn6WDgcxubNmyFJEk455ZSDdUoCgUAgOEbQhUAfBAd4IBTHn9/cA5kAt724A5ecWIdnNnQAUEKcn9nQgfl1RQCMHeAsv7n4eDSU04JYtAr0WB1gflsgmuQqQLtsZkQy1bJ9mfBoi1nMkwsEAoHg6CLvAritrQ2f/exnsWHDBgBQKz2z2Gw2fPGLX0R7eztWrVqFpUuX5vu0BAKBQHAMoXOAD0IOcJefVnaOJWU09oWwp4eGNW/O4QBPKXWheUARxJctrsNnFtZyxy12WwEADsMq0JnjJPWC2iPxLrMvmuQqQM+p9mJ9C22VNBhJoMLjGOYdCgQCgUBw5JHXqd1wOIzzzz8f69evR21tLa677jq43W7dflarFVdffTUIIXj22WfzeUoCgUAgOAY5FFWgtZWUN7T60D5EReiOzgCSaRmRRIorRHXvl0/E5xfX49qzp+FXF83THdduMcNjtxxADrCmCnQkwQngqWVuOKx0WCAqQQsEAoHgaCSvAvjee+/F7t27ceKJJ2Lnzp246667UFBQYLjvRRddBABYuXJlPk9JIBAIBMcgow2B7g/F8UHjAGTZoDLUGNEKyJe2dGrOQcaeniAniq1mCbOrvPjd5+bjRxfMhsNqhhElbuuY+wBrc4D90STXAqnK61ALbAGiErRAIBAIjk7yKoCffvppSJKEO++809D5ZZk3bx7MZjP27NmTz1MSCAQCwTFINDGyA+yPJnHOH1bgi/9Yjf97eee4X1NbSGrN/kHdPlvb/VwLpJoiJ8wmSbeflkq3BJNkINKTwwhgRDiH168Jga702lFaYMt5/gKBQCAQHA3kVQDv3r0bZrMZp5122oj7ms1mFBUVwefz5fOUBAKBQHAMonV8jXKAP2gcQDCWAgC8saNn3K85pBGQRu2GNmsEcD3T7mg4qhw5QrjTceWFDASwS4rjxFoaheWLJNHBuM9VhU6UuhkBbNAfWCAQCASCI528CuB4PA6n0wmz2TiES0skEoHDIQpuCAQCgWBiGU0INJuHG4glx/2ao3FQt3b40MaI0PoS56iOXeEcJoc5GTUsggUAVy8pVZdTMkErI74nl7pQwoRAixxggUAgEByN5FUAV1ZWIhQKjcrV3b59O6LRKOrr6/N5SgKBQCA4BhlNH2A25zUQTYIYWbZjYDA8soO6qyuIxr6Qul5X7AJifuDNXwCr7jG2jQGU53KAASA6BMD4eWdOsnHrbKpzfbGLC4HuFznAAoFAIDgKyasAPv300wEATzzxxIj73nHHHZAkCeecc04+T0kgEAgExxjJtIyUpqiVoQBmBKtMgHBifL2Ch8K5XeRsmm9KJlixu0/dPqnEBbzxc+D9PwGv/xTY+l/D55fZ6bklJSv/YGSAW40T+rg1EYDbpo/KKvfY4bSZuRDo0Qh4gUAgEAiONPIqgK+99loQQvCLX/wC27ZtM9wnkUjg5ptvxqOPPgpJkvDtb387n6ckEAgEgmMMrfsLAHGDbf2anNdAdGxh0LJM8N8P2/D8pg7IMuEENYvHbsGC+iLDxyZ5TcDWp+iGHc8b7ldsTanLIUnTXYERwDKR0EuY14r5UeTiXWAAmFyi5B6XMAK42x/T7ScQCAQCwZGOJZ8HP/XUU/Gd73wHd999N04++WRccMEFCIWUUK+f/OQnaGlpwZtvvon+/n4AwC233ILjjjsun6ckEAgEgmMMbf4vYOwAa0N+A7EkajB8Tm4iJcNmUeaSf/vKTvzjvf0AAJkQDEWMBfSMygLMryvCxlaf7rGGofeBRJBuaHoHSCUAi00Jh97wMLD5CcxPUlc3QuwotjhoCyRGAEdghx9u1CPjMscDKHSWoMNH846BjPMMYHIp7diwud2Pt3f14pzZFcN+BgKBQCAQHEnkVQADwJ///Gd4vV7cfvvteOaZZwAAkiThd7/7HQCAEAKLxYJbb70Vt956a75PRyAQCATHGEYOcMJQAGsd4JRuH5Zbn9uGx9e24hPHV+MLS+pV8QsAb+/qw1DEOId2ZqUHJzeU4qFVzdz2Sq8dBXv/oznRINC2BiifBTx/PbD3NQBAGbNLmNgAi50RwLTdUhR2BAhTWTrmR6GzUndO9RkBvGhyMU6oL8KmNh8A4CfPbsXr3z8THodV9xyBQCAQCI5E8i6AJUnCbbfdhmuuuQYPPfQQVq5cic7OTqTTaVRVVeG0007DVVddhYaGhnyfikAgEAiOQYwqPo9UBAsYPgS6NxDDo6tbAAD/29yJ/23u5B7f3unPVb8KMyo9+NjcSnz/vJlYua8f4UQKTqsZN5xeCem51/RP2PYU0PgW4Gs1PF5YtoFYnJDgVzYwDnCYOBCSqKurhEBTMVsOH661PI8FgZMB3AizScIdn5uPT971HpJpgi5/DLe/sgv/d/HxOT8LgUAgEAiOJPIugLNMnjwZP//5zw/WywkEAoFAACBXCDQvihMpGX6N4B2uFdK+3hDOMm3GZ8zv48n02fhAnss93jxA2wtZzRLKCuzoyuTUzqn2QJIkfPe8GfjueTOAF28Etj8LvF+j9PHVsv6hYd9flNggm21QS1txIdAOwFEIZLV9zI9CpyKAzUhjme0OHG9qBra+BixaCkw5DTMrPfjOuTNw5xt7AABPftiGWz55HJwGxbMEAoFAIDjSyGsRrNbWVnR0dIx6/87OTrS2Gs9wCwQCgUBwIESNimBpHGCjnrfDOcCBfavwgPX3uNi8Esusv0cFhrjH00zV6WKXDf/vY7NQ6LTigrlVOHkq7cWL3l3Ahw8A0UGghykWOeUM4xf2VOs2RWFHyuSgGzQ5wLaCYvpYLIDCjAN8pfk1RfxmaXpbXfzWWdMgZSpVJ9MEvUFREEsgEAgERwd5FcBTpkzBSSedNOr9TzvtNBEKLRAIBIIJxbgKNC+Atfm/ABCIKTnAu7oDGGIFcjyIkzb+GBZJOYZTSuAG+wtYUFdo+Polbhs+e2IdNt76Ufztq4tgyvZAAoD2dcYnffbNQNEkflvV8cBXn9XtGoUNSYmp7MwKYGKHu5jJ+fW3ochpQw36caNF02Kp/UN10WYxochJQ6UHDCYIBAKBQCA4EsmrAAaUIlf53F8gEAgEguEYTQi0kcALRJO45629uODP7+Gjf3oHXf5M5eRXf4ySOB/d9GXLW3j+q1O5PrpZsq2FOOGbpXMDs2MDUD4HOPU7wORTgekfpY9JJuDTdwNlswBHEf/+YEeCEcBEEwLtrp9Pd+7agkKnFT+3PgK3pBH9HRsAmX5WbEukwZAQwAKBQCA4Osi7AB4LsVgMFstBS0sWCAQCwTGAoQOsCYHuDxo5wEn87Z0m5fFQArc8uw3o3gpsfEzdJ00UUSulE8B7f0RdiUt3nBIDUazSsZ4un3oDcN1q4PxfA5IELLoCMGeee8YPgZqFgMkE1C3hDhElNsRB3Vo5zBTBgh3Vs5Yyb6odtalWfMz8IXTE/cDAXnW11G1Xl41CxAUCgUAgOBI5bARwZ2cn+vr6UFpaOvLOAoFAIBCMktEI4IGwXgAHIwmE4rQV0vJdvUi2UuG4T67Bbamv0idseARzPRFoMXKFAQDJGNCzna7XLuIfr14AfHsVcNVrwLk/pdvr+dSiKOyIyVQAS4wDDKsLxVWTAXe5umlm87/U5R5ShF7HVLo/EwZNhTuB1L0JiPJ5zgKBQCAQHIlMqN367rvvYsWKFdy2UCiEX/3qVzmfQwiBz+fDyy+/DEIIli5dmnNfgUAgEAjGinEOsCYEWhPi+33Lf/GN/a9ioeVc/Cb1ZXX7vn27MCezvIU04AlyHn7ufhVSuBeQkzjR2ox/o4Y7VnEuAdyzDZAzAtviACrm6PcpmwFgBr+tbjH/XmBFhFABbJLpe3G6CxU3uXoBsO9NAEDlfppHvE6ejZkl1ajozPQwbl8HLFTeb0mBLfNZPIVL1z8LbC8CbtgIuEqM349AIBAIBEcAEyqA3377bfzyl7+EJNE8p3A4jF/+8pcjPpcQAofDgZtvvnkiT0kgEAgExzjGOcD8tj6mCFYRgviO+TmYCME3LC/hkfT5aCeKg9rdulcVwJ2kFFUlhZCKJgPhXgBAjV1fOTqnA9zB5P9WLwDMVuP9tNTyArhaGkR/zPh27vEW0eNnBLApFVUfXyPPxrSa6UBnRhR3UAc4e94Xmj5QNsR8wN43gAWfH915CgQCgUBwGDKhAnjKlCk466yz1PV33nkHVqsVp5xySs7nmEwmeL1ezJs3D1dccQWmT58+kackEAgEgmOcUYVAMw7wPFMzTBItyHiqaRueTJ8DAHCEu5BtuNtBytBQ5gZMBeq+5QYCOKcDzOb/1pw44vtQcXi51QSxoCNEDO/oxUWZytRV8/UPQnGAr2lYBGR1b892IBEGbG5VAFdKTOjzYOOIpyfLBJIEbjJcIBAIBILDhQkVwFdccQWuuOIKdd1kMqGkpARvv/32MM8SCAQCgSB/xFJGAlhbBZo6wMdL+7nHTjNtVwVwjdSvbu8kZZhR5gbCHnVbqVWfS5yzCBZbAVqb/zsSH/0V8MbPIBMJy9IX4Mvm5Ya7VWTralQv0D3mJy7IZbNRO2MhYCsAEiGAyEDnJmDKaSgpsMOFGF8temB4AbyzK4BrHv4QdqsJj3/9ZFR6HcPuLxAIBALBwSavJZcffPBBOJ3OfL6EQCAQCATDYhQCnUwTpGUCc6Y1UX+QdYCbuH1PNW0HQCCBoFqiBaY6SCk+Vl4ApKgj65VikCSA7ejHVlOmJxUA+mnFZdSOwQEGgFOux05pOq5/oQONpBZxGIvsitJMvm7xFMBeqFR6zhCvWYonvnIaLFarUmG6+T3lgfZ1wJTTUOq2oULSFL4awQF+5IMWdPiUEOuHVjXjpgtmj+19CQQCgUCQZ/JaBfqKK67AZZddls+XEAgEAoFgWKIGIdAAkMiEQRNCOAd4ntTM7Vcu+XHNzDhOKErAJtFjdZFSTC1zA3YaAm1JhVGlcT2L3Qa5vV2bAGRUsqNQ6QE8FkxmWKefhUZSCwBcGyQOm1v5X5KAaj4MumLeOTQ8m22t1LoagOJcV8DHH2+giVf3GrLiFwC2dfhz7icQCAQCwaHisGmDJBAIBAJBPjDKAQZoGHQglkIyrYg6L0KYbOrV7buYbMO1C6nL6iNuhOHEtHI3YKch0IgHUV/M9wIudhm4s7276HL1AkWgjhG2uFac5BDAVuZctGHQk0+jy1OY5ZZVgJzOOMA+/jlxPxDuR/tQBKsa+yHLvBjuC8RworQHc6VmbO8MgAwjlsdFIpyf4woEAoHgqCevIdBZVqxYgccffxxbtmzB4OAgkkl9kZAskiShsXHkIhsCgUAgEIyGuEEINEALYfUzFaAXmFsM950V3YD66nnqegcpAwCUe+waARxAXYkTa5uV1UKnFVazwVyzv40uF08Z+U0YUOi0wiQBMgFiOUKgYaPuNCeArS5+vf5kwGRR2jLF/UD3VhRXztcLYAC9Ldtx/hMxRBJpXHfONPy/j9Ew5yWB1/Er+90AgK9Gf4zuwOmoLpzgVKi3fwu8ewcw+5PA5x+b2GMLBAKB4KgnrwKYEIKrrroKjzzyiLo+EqJqpEAgEAgmkpwOcFJGtz+GTiZs9yR7K5DRyyHiQIEUAwDU+tbDEjhb3a+TlGHx5GLlnsWKzHgI9dXUdc1ZACvQQZe9dWN7QxlMJgnFLhsGwomRQ6ABYPp5gLMYiA4B8y/j2y7ZC5RK1O1rlfXm92CtOQF1Vn0Y8/atGxFJzAQAvL69RxXAaZngrOT7apXsK8yvYXvHVRMrgGUZWPkXpVjXzheUolyl0ybu+AKBQCA46smrAL777rvx8MMPAwAWLVqET3/606ipqYHFclCMZ4FAIBAIDKtAA0qRpgdX7edSWuebm1UB/FT6THzZvBxWKQ1bKgjsfFHdL+Guwc2fyDifdqYtUTyIhnIqOrX5wCp+RgAX1o7l7XCUuBUBHCM5hLaziC67SoBr1wB9O4FJp+r3nXI6I4DfB079DmotQSDF7xbu2gNAEcBd/pi6fSAcxywTdbbPMG3Fg22dOO+4ygN4ZzmIDgJMH2NEBoUAFggEAsGYyHsVaEmScM011+D+++/P50sJBAKBQGBINGEsgP+1pkUVv1OkLhQijNmEpuCslWfjOFMLTpJ2Kxs6PlQf++QZS4DJmQrLbAh0IoSPza3CkinFaOwL4xtn5Shu5W+ny97xCWAgRxGsmhP1x/ZUKv+MmHI68P6dynImD7jS5NPtZvXTKtmheAqBWBJehxUD/T2Yw7SJsksp2BpfBbBwLG9peEI9/Ho8MHHHFggEAsExQV4F8J49ewAAt99+ez5fRiAQCASCnBi1QQJoDvAppu14zPobmCXCuZ1byVS8k16Ak0y79U8uZMKW7WwIdBAOqxn//dapkGUCk8kgrUdOA8Eu42ONkawANswBPveWsRXXmsTmAQeA7i0oIz7dbvVyF7fe6YvCW2VFrH2rbt+Z/ctx+ysX48Utnbj27On40tJJoz8fI4Ld/Ho8OL7jCQQCgeCYI69VoB0OB4qKilBcXJzPlxEIBAKBICe5QqCzXGp+RxG/DD7iRhupwAp5gfGTChkhp6kCncVQ/AKKiCPMOU2AA5zQzmdPPg2Ydu7YDmZzA7WL6Pr+91AsD+p2myx1Q23hBKDLlwmD7tmu23dJeiP+9c5WtA9F8fP/bYM/krsIJocsA/vf5atlA8IBFggEAsG4yasAPv744xEIBBAKhfL5MgKBQCAQ5CRXFWgFgpNNO3RbX00vASBhB5mMfhTpn8Y5wBoBPFLBR7YAlrMEsLly7zsC2VZIUWLnHzjnpwfUWglTTqfLjW/BndYXwXJLca4/cKdfycm1D+zU7WuXUviIaQMAIJkmeGNnj24fQ9b+HXj4QuCvS4FuxlnWCWDhAAsEAoFgbORVAF9//fVIp9NYtmxZPl9GIBAIBIKc5KoCDQCTpF7USIzL+cUn8PSsP+KW1FUAAAITNtoX808yWYECJo/WxghgkJF71LL5v+MogAUAp05X2jFtIQ2I2jI5yXM/y/f1HQusAG5+j3soItHiXlMlGoqcdYC9gT3qtgChov58M82dfnUbHz6dkx3P0+U9r9LloBDAAoFAIBgfeRXAn/vc53DdddfhpptuwqOPPprPlxIIBALBEUS3P4YNrUOQ5ZHb440XVgC7bGbusVNY97dsFjDrAvTVnIMUE1K813Myf0BvDWBibp+sAwyMLMq4AlgHnv8LAEunluA/3zgZf/nKKbBevwa44kXgs38/8APWLgKQcY5lmhDtJy7skum5TjFRAdzpjwJyGuURWkDs3+mPqMszJeX9ftq0Cv/XdCmST39rZJd8YB9dDnTSZeEACwQCgWCc5LUI1lVXKTPoLpcLV155JW699VYsWbIEHo8n53MkScIDDzyQz9MSCAQCwSGkwxfFOb9fgURaxo8/PhvfOit/bWwIIYgyArjQaUWEqQrNhT9PPQMA4HXwFZV7yk8BBsw0b7ewnn8Ri11xheVMfmtihLSfwMS0QAKUe+bJDaV0g7diXMeDoxAon620SmLoJcVolCtxokUpCKZzgIeaYSeKEywTCX115wHdLwAAJpn6UOI040fyf1ApDQFbHwcWfTW3Sx3zA+Feus62jBI5wAKBQCAYJ3kVwA899BAkSQLJzPS2traitbXVcN/sfkIACwQCwdHNQyv3I5FW8nJvf2VXXgVwMk3AmsyFTivTu5bwDnAm/LfQyQvggqIyoP4koPUDZUORRgBLklIJOjqkrI8kyiaoBVLeqFtsIICL0EaouJ5h96kVszv9UaBnm/pYM6nEqSefDjynrNuQxJenJVC3j7ZIQusHuQUw6/4CvAMsqkALBAKBYJzkVQBffvnlkA6kCMdhRDQaxW9/+1v85z//QWtrK0pKSnDBBRfgtttuQ23t6AcuU6ZMQUtLS87Hd+7cidmzZ0/EKQsEAsFhzWCYrwQcjqfgtufndqStAO1lxO0UqRtV0hB9cPLpmX34cykvsAPzP08FMJsnm8XuYQTwWBzg8YVA54X6k4CNfNpSL4rQCeo0L/AGgUyqc5c/BtK9LRs4jV1kEurKygB3ORDuAwBc5OELjaVa1uQegAw08uvs5xXq5R+LCQdYIBAIBGMj7w7wkUwsFsO5556L1atXo7q6GhdddBGam5vx4IMP4sUXX8Tq1avR0NAwpmNeccUVhtsLCwsn4pQFAoHgsKfEzTusO7oCWDKlZOwHSieB136qiKzzbzMUk9oCWKy7y7m/5XOAgnIA+hDoCq8DmHel0iYIUIpMabF76fKIOcCHuQCuW6Lb1EeK0EHK1PWSFBWiiZSMWPsWODPru+RJWOixA8VTVAHc4PuAP2D7WqRSKfzmlT3o8kfxk0/MQX1JpnCW1gGODgKJCJQCY5rPVjjAAoFAIBgjeRXARzq//vWvsXr1apxyyil4/fXXUVBQAAC488478YMf/ABXXXUVVqxYMaZjHumTAgKBQDBeAtEUt7613X9gAnjrU8Da+5VlVynwyT/odtG2QGLF7ckmJsw3k/8L8C4xAJR77EqY8/zLcp+LrYB50YwoS8aADx8AWlYBi68Cpn8ESMX5/NbDMQS6bJYi6JlQ7l5ShE5CHWAp1I0iO+CLZzZ0b1Ef20XqUeq2A8VTgfZ1AABT6yruJSxxH95buwbLVvoAAL5IEo9/I1NsTCuAASCYo3q0EMACgUAgGCN5rQI9FmRZxgsvvIDPfOYzh/pUAACJRAL33HMPAODee+9VxS8A3HjjjZg/fz7eeecdrF+//lCdokAgEByR+KIJbn1bB+01G4gl8YfXduOf7zUhPVKFaCbvFP27DXdhC2A5rCY4rPS2t9jEPGcyzUf1OgxCoEeCrQSdCAE7XwDuWQK89hNg14vAk1coxZ3YcF5ISkXpww2TCag9kdvUS4rQTegkhURkzPVEAABl8MMZoXm6LfZZsFlMigOcJc3/zQFg2+o31OUPmgboA/179ecU6NCHPwNCAAsEAoFgzBxyAbx37178+Mc/Rl1dHT7zmc/ghRdeONSnBABYuXIl/H4/pk2bhoULF+oe/9znPgcAh835CgQCwZGCL8LnAG9lBPB9Kxpxz9v78OuXduK17d3ap/KwYjLcb7hLjBPAZtgtShukKgygVmJE1yTa6qjIZUNtkRLQW+6xo7rIMfx5ALwAbloBPPEVwM8UfUwEgS1P8uHPBZWAmXebDxs0YdB9KELKZEfSScOgj3Mpf7cTTNSx7SbFIFlRXzJ12Jc4QeInLYbCCaU9kjYHGFA+t5DB90EIYIFAIBCMkUMSAh2JRPDkk0/igQcewKpVSlhUtlL0nDlzDsUp6di8eTMA4MQTTzR8PLt9y5Ytho/n4ve//z0aGxtht9sxd+5cXHzxxSgvLx/fyQoEAsERhD/KC+DGvhAiiRRcNgvW7h9Ut2/v9OMTx1frnt/UF8K/1rTi622NqMpuzCmAaQi0w2KGPeMAn2iiLmPYWQu3Rz0SzCYJ9391EZ7f1IFPHF+tiuZhsTMh0E3vGO+z7p/A6d+n6+NsgZRXNAL4srMW4XszToD1zUlAVPmsp9mGAFRjgYkK1s3yNCVkHOAdYAOmxfjCWDu7Aji1Igkkw/qdAx36fsuAEqadTimfbTwAnPxt4/0EAoFAIMhwUAXw6tWr8cADD+DJJ59EKKRUySSEYPbs2bj00ktx6aWXYt68eQfzlHKSbddUV2dcoCS7fbjKzkb86Ec/4ta///3v4+6771Z7JgsEAsHRjlYAywTY0RnA4iklaOyjFZS1TnE8lcbfVjTh3rf3IZGWcZW9A2rp4cgAIMtK+C5DTBMCbbcojy9iBHCwfCHcmnOcV1uIebVjKE7IFsFiCzVNPh1oeV9Z7tuluMBZDsf83yy1iwEp0/vYbMPFZ5+kCMvCOqBzAwBgklmZrDhBog7wJnk6DRkvHt4Brog3oxAh+KFMHuzoCuBUc4fxzoFOpUexDgJs+hfw6k2ZdQk46/+N+m0KBAKB4Ngj7wK4r68PjzzyCJYtW4Zdu3YBoG6vJElYt24dFi1alO/TGDNZge5yuQwfd7uV4VIwOLrwq09/+tM455xzsGjRIpSXl6OpqQnLli3DX/7yF1xzzTUoLS3FRRddNOrzmzt3ruH2xsZGTJuWv56aAoFAMF60whZQwqAbygu4x3waofzD/27BC5uVXFMTZFSCaWFE0kDMB7j4Ylq5QqBZBzhRra96PGZyuY5TzwTMFiUsGgAal9PHDscK0FncpcD5vwbW/QNY8nX6/gppD+RK0gcJMucAbyLTMC/rABdUAhYHkIqpj/cTZaKgTFIKbC007cUKWUkz2tEZAJwG+b+A4gAzx+HIfrYA0LVp9O9RIBAIBMckeckBJoTgpZdewiWXXIK6ujr86Ec/ws6dO+FwOPCFL3wBr776qrrv4RLynG/uuusuXHzxxZg0aRKcTifmzp2LP/7xj7jvvvtACMFNN9008kEEAoHgCCeWTHOFqbJs7fCjqY/vn+tnxLAsEy4nuAJDsEh8hWejMOioTgCbYEcCc6X96nbTpJPG/D50sFWgWQrrgCXXGD9WY5xic9hwyrXADRuV/7Mwor041YsGqQteKQoAkImELXIDDYE2mXRh0E2kGhvlGer6cRKNotrRFeDzf+2M4xvoAEI9xufJVo2O+kb11gQCgUBw7DKhDnBjYyOWLVuGhx9+GF1dXSCEQJIknH766bj88stx2WWXweM5MnJzslWfI5GI4ePhsJKjNN73c/XVV+OWW27B7t270dzcjClTpozqedu3bzfcnssZFggEgsOBQFTv/gJKJeimPj73cyhCKwf3BuNIpKjgrZYGoSPSD2Amt4ltg+SwmmC3mnC81ASbpAjjCLHDXb9grG9DTy4HuLBOqTDtraVFu2we4OybgOM/N/7XPdgwArgg1o2FTAGsPaQOYTipAAYUAdy3S13dL1cjAvp41gkGgH29IaTL9kLNuJ5yOrD7JWU50AnkKgrOiuaYb2zvRyAQCATHHBMqgGfMmAFJkkAIwdSpU3H55Zfj8ssvx9Spw+cBHY5MmjQJANDe3m74eHb75MmTx/U6JpMJ06ZNQ29vL7q6ukYtgAUCgeBIRBvWnGVfbwgb23z8vowD3D7ET0ZWsxWcs4T7dJtiqTSmSR1wIwaHpQx2i5kLf95CGrCkwDjVZUwMJ4DNFuCSfwIrfgtUzAXOuBEoqBj/ax4KGAFsDXXgDGcLkGnrvElW0m9qi5jPU5MHvJ9UwQLqypcyAjglE6T6GAHccBYVwJEBIG383eGKZgkHWCAQCAQjkJcc4BtuuAF33HEHbDZbPg5/UFiwQHEENmzYYPh4dvv8+fPH/VpDQ0oeWzavWCAQCI5WWFFb7rEjlZYxFElCJsCLmzu5fdliWW2jEsA0BDoYS+LBlc3Ys2EFltuVokjLYjfDbrmcK4C13TQbJ5sk3aHGTC4BnC10NflU4IqjoG0ekwMsJUL4VOFOINPFap9tNj4+uwqLJhfT/Q1CoFnXtxS0BZYEGZYA0zpq0imAZAJIxsWP0+fB7uXXswgHWCAQCAQjMKE5wHa7HYQQ3H333aipqcF1112H1atXT+RLHDROO+00FBYWorGxEZs2bdI9/tRTTwEALrzwwnG9zvbt27F79264XC7Mnj17XMcSCASCwx1W1Ba7rDhpKi1aFYynuH1D8RSSaUX8tA1GuceMQ6CpKP7Ny7tw5xt7MMv/vrptcewD2M0S5wA3OY47sDeixUgAu8sB6yh6CB9JuMuUwlYZzH6aw3vLN76K+76yCGZ2QkHTC7iJVGOA0IrZrANcDj/MhPkOlExVCmkZUTrdeHsilNspFggEAoEAEyyAu7q6cNddd2H+/PkYHBzEfffdh9NOOw2zZs3Cb37zG7W10JGAzWbD9ddfDwC47rrr1JxfALjzzjuxZcsWnHXWWVwF63vuuQezZ8/GzTffzB3r5ZdfxltvvaV7jS1btuDSSy8FIQTXXHPNEe2YCwQCwWjwMXm9RU4bTm4oHXb/rGBuG6QO8Owqz7Ah0GmZ4NVtXQCAEtBK/VNdUTilOMol6jr2FkzQxKORAD6cqzwfKJJk/L6cxUC5wWdZQrsSEMmCVlKpVoIGgFKJ/n1qJaaImaNI+UyNWkXZCgCPvj+0igiDFggEAsEwTKgALioqwvXXX4+NGzdi/fr1+Pa3v43CwkLs3bsXt956KxoaGnDuuefiwQcfnMiXzRu33HILli5dilWrVmHGjBn4/Oc/j5NPPhk/+MEPUF5ejmXLlnH79/f3Y/fu3ejq6uK2r127Fh/5yEcwZcoUXHTRRfjiF7+IpUuXYtGiRdi5cyfOPvts3H777QfzrQkEAsEhgXWAC13WEQVwVjCzIdDHVXtRY+QAZ0Kgt3X4MZQJtS4xUYHlSftRkPJxT5EmKhfXqAr00SiAAeP3ddI3lFxnLWXTgXmXAJIZgcXXIQErBkAFcAkCkKC4/DXspEY21Npboz/mzAtyh5wDIgxaIBAIBMOSlzZIALBw4ULce++96OrqwqOPPoqzzjoLhBCsWLEC11xDW0K8/vrrSKVSwxzp0OFwOPD222/j1ltvhcvlwnPPPYeWlhZceeWV2LBhAxoaGkZ1nI997GO46qqr4PV6sXLlSjz11FPYt28fTj/9dPzjH//Am2++CafTmed3IxAIBIceNge4yGnFrEoPilzWEfdvH6Ih0MfVeFGVswo08M4eWgyr3sH0jg33w5WkzxskBfC6J+jaa+gA1+u3HQ1oBbDVDSz9Vu79P7cM+EkHyDm3AAAGCG1vZJFkVNlimFLqQg3jAMfcGeGrFcAlDcAnfj+8ABYOsEAgEAiGIS9FsFjsdju+/OUv48tf/jL279+vtklqb28HIQSXXHIJCgsLcdFFF+HSSy/F+eefD4sl76c1apxOJ371q1/hV7/61Yj7/uIXv8AvfvEL3fZTTjkFp5xySh7OTiAQCI4sfFEmBNplhckk4aQpJXh9h3GPV18kiVRaRpefCtnjqlyowJB+54wD/C4jgKstYSD7ktFBOBPUZRwghSgeRnyPiWMlBBoA3BrXfPHXAFeJ8b5ZrE4UmBSnNwgnEsSstqKa6ojgJ186ERvvv0/d/e1uGy4gBBITQg0A+NKTymsJB1ggEAgEB0jeHGAjpk6dittuuw0tLS14+eWX8dnPfhYWiwU+nw+PPPIILrzwQlRW5ih4IRAIBIIjHtYBLnQq4nO4MGhfNIkufwxpmTaBneuJwCwZNIUN9yMQS3LtlLyEqRRMZLiD+9XVQXhQ7J6g2gtmK1ccCsDRK4CLNe3/Trl+VE+zmE1w28wAJAyAusB1tjDm1Rbi3Oq4um2jvwDbOwNK+HT9UiWX+GuvAGUzlB2EAywQCASCA+SgCuAskiThggsuwFNPPYWOjg784Q9/wJw5c0AIgc/nOxSnJBAIBIKDAJ8DrIjPpQ253UNfJMEVwKrw2OGNG7vFiAxg1d5eVSyXuKywxH3cLg7fHnW5n3hR7JrA4oNaUeY9SgXwzI8Dtsx7PfNHgHeYglQaPA5l0oOtBF1tUfK0a5kc4A5Sjn29IcBdClz9OnDDBqWVVBYHfb4O4QALBAKBYBgOiQBmKSsrw4033oht27Zh1apVuPrqqw/1KQkEAoEgT7ACuCjjAM+p8nJ5wA1ltCe6L5LkCmDVl7ggBWm/4Da5nB6cpLFuZ5O6et40FySZb4ljG6QCeEJDoAG9AD5aHWBPJXDDRuAb7wDn/GRsT3UoKU6sAC43h5QFf7u6rZOUoqkvlPtA9mEEcNQgPF4gEAgEggyHXACznHzyyfj73/9+qE9DIBAIBHmCK4KVEZ8mk4SffHwOvA4LPnl8Nc6dTXNMfdEEVwCrvtgJ+DvU9d2kDrJE60as3LxbXT633qx7fcsg7QE8QLwomkgHmK0EbbYpfYCPVgrKgZoTlLZIYyArgPuZStDlUgCIhzjh2kHK0Ngf1j1fRYRACwQCgeAAOXyqTQkEAoHgqEfbBzjLZUvqceniOkiShHvf3sfsn0QoRjsF1Je4gAAVwJ2kDHFbMZxxpfCVR/YDqIbHbsEpBpG5UpK6yQPwomSicoAB3pX01gKmw2qO+bAgGwI9SNhWSH7O/U0QM/pQiKa+AxTAIgRaIBAIBMMg7s4CgUAgOCikZYIAI2azRbCySBk3kd3ujybRxjjAdcVOTix1kxIMMW5iqRRAldeB+76yCIUYJoQWQMRajNqiCWxBx4qyozX8eZwYhUAXyrwA7iKlIDBhf38IsmxQ7AwYIQTaNxGnKhAIBIKjFCGABQKBQHBQCET5fNzCHPm3bD6wL5LkimDVF7sAX4u63kbK0SvT0OOZBTG8+YOzcPqMMiBCiyoZceV5S+C2T2AglJ0JgT5aewCPE29mcmOAmbTwyEOAv01d7yRlAIBYUkZXIAZDhAMsEAgEggNECGCBQCAQHBTYAlgmCfDkEJ9sZebuQAy9Qdoep77YCQw2q+utpALtcVo0a6orhoLscUcQwPNnTR/L6Y9M8RS6XDFnYo99lKDmABPaBsmd9HECeNBKc8BzFsISDvARw/qWQfxvcyfiqfShPhWBQCAAIASwQCAQCA4SvijfA9hkMi6gxIZA9zHi1yQBVbYIkAiq21pJBfpk6gZWmeljiAwOf0LustGe+uhY8nXguIuA4y8DFn9tYo99lOA1aIPkSA5yIdBxd426zOYBD4YTeG9vH5JpWTjARwjbO/245L4PcMPjG/H3d5pGfoJAIBAcBEQRLIFAIBAcFLgCWMNUXy7KERrdUF4Aq5+GPweIE0PwcGKqVArQJwznAEtmwFE08kmPBU8lcNkjE3vMowyjHGBbwg8M7lfXpaJ6QKlppjrA0UQaH//Lu+gJxHHxwlr86fMnABYHkMqESJttQDrz/RJtkA4b1jTRSajV+wfwHcw4hGcjEAgECsIBFggExyaRQSCdHHk/wYTh1zjAucgljk+oLwKGmtX1NlIBQMIgk09aSEYpgN1lokrzIUAVwNCEMHdtVhedZZPV5aZMK6T1LUPoCSjRAG/u7FEeZF3gUiacPRkBUnSyRccH9wJPXg50bzuAdyAYC5EELXoXiosQaIFAcHgg7v4CgeDYY/tzwB9nAX+aN3KYrGDCYHsADyeA3TYzLAbh0Qvqi4Ah6hS2kEoAvJtYkGLcv+GcwKO5R+9hjMeu/N1jsCNM7PSBNA11L6lpUJezIdDNAzQUOhRPKdWhWQFcNpN/oVxh0B0bgNd+Aux4Hnj1x3R7MgaQHBWnDxWyDOx/F+jfO/K+hynhBBW9kXhqmD0FAoHg4CEEsEAgOPZY/5ASLhnqBrY/e6jP5piBFcC5wpwBpR2S0eMn1BXpCmABwAChQsieYCY0RnKABQedrAMM8BMXLDWTaJhshy+KaCKNVqYSOCFAKJHiBXBJA2BisrpyFcJq/5Aud29R/t/6FPC7KcDfz1KE8OHC6r8CD18I3LME6Nt9qM/mgGBFb1gIYIFAcJggBLBAIDj2YIVRsOvQnccxBhsCXTSMAwzow6BtFhNmVXm4EOjWjAPci2J1mzk6QEPbhxPALiGADwUeB/27D6BQv0NhParLS2Gz0OHJ/v4wmvvD3G7BWIqvBO2p4nO6cznAfbuYffyIhYaAlX8GUlElDHvfG6N/M/lm9yuZBQLsW35IT+VAYR3gkBDAAoHgMEEIYIFAcOwRZ/JEQz2H7jyOMXqD1F0brggWoBfIc2u8iihiQqCzDnAPoQJYAgGC3YpNOKwDLEKgDwVeJ3Vp+40c4CVXw2ySMLWUtrZq6g+hZSDC7RaMJZWK2wBgtgOzPgE4i9THE6EcqQ39e7jVi3/7JOK9++iGwGE0IcZOziVytIM6zImyIdCJNMjhFmYuEAiOSYQAFggExx4xP10OGgvgWDKNp9e3Y2OrqCg7UbAtbaaWuYfZUx8ifUJ9kRKeGuhUt2UFcBw2DJECunOwC4gHAZlxnNy0t6yyLhzgQwHrAA9qBbCjCFhyDQBgegX9e+7qCqJl0MABPunrwLfeB76/HSiqR8pWpD7+5HtbjU+AdYABzCb7YZejdEO4b/RvRsNAKI5/vNuE9S0TUFeAZCZyssSDufc9jAkzRbBSMkE8JR/CsxEIBAIFIYAFAsGxBSG8AA51G+525xt78IP/bsYl961CY9+R6b4cTsgyQVM//RynlRcMszdQ6OQd4hPqiwBfKwDFQSKSGZ2kVH28m3GBEejUuL8SUKZpvyIc4ENCgZ06wHFowuBPvlbN651bS8Xxmzt7EEvywimQDaevOh4oUP6WbTH6ndnb0qZ/8cigTuCeZOIF8XgE8I+f2Yr/e3knvvSPNejwRUd+wnDEg0CSEf1HqAMc0VR+FnnAAoHgcEAIYIFAcGyRCAGEGUyHeg13W92kCCiZ0GXBgdPpj3IiZmr58A6wtgj0groiLv8XhXWQJSqmekgJfSzYxVf3dhbpBa9wgA8JZpOkiuAOovkbLP2Guji/tkhd3tWtdz+DMb2Q6k851eVChHWPGxWSWmrayW8YhwB+Y4cSTRJPyfjr2/tG2HsEgpqJufiRKYBZBxhQwqAFAoHgUCMEsEAgOLaIBfj1UC8g6wdl7AC7PzhMT1HBqGDDn6u8Ds4JNKJtiM/5nFzq4gSwVDKVC6fVOcBRRgC7SvWCVzjAh4xsJejX5cVIZl3gj/0GcNK/4bxa4wrRWYIxfQ/vgbRLXS6UwoglNb9rTfgzADSYNEIz3D/s646WnV2BkXcaDm1xviPVAdYI3okohPXEulZ89z8bsaNznJ/xMcbynT04+TfL8Y1HPkQyLULRBcc2QgALBIJjCzb8GQBI2rAXMDvA7gsdRq1RJhhCCN7d04dXt3UjlcdBERtGPq1iePcXAD57Yp26PLnUBUmSuAJYKJ7CFVTqhtYBZlx7Z4m+6rNwgA8ZWQG8n1TjtoZ/Ad98DzjlOm6fIpcNk0pcRk8HAAQMHOCepENdLpTCCGhF8mhaCYWNI0JGIi3zxZ0a+wwc6LGgc4CPzBzgiM4BHp8AbuoL4cfPbMXzmzrxs+e3jetYxxp3vrEH3YEYXt/Rg+c3dY78BIHgKEYIYIFAcGyhFcCAYR7wseIAr9jTh8uXrcW3HluPJz9sz9vrcAJ4hPxfAPj0ghp8fF4VFtQX4f6vLlI2siHQxVPg5RxgRgAHNAJYOMCHFaxzL3trgOr5hvsdX2fQJimDVtym0jI6Y4wARhiBqEZsGTjAOg7QAdY6m/5okquAPGa0DnCeBTAhBNs6/PpJg3GizQEOxccXAr29M4BsIel9ojbDqEnLBHt76Of14hYhgAXHNkIACwSCY4u4QdicphVSIiVz1Ur7Q/F8n9Uh453dNOdxzf785To39lJHrGGECtAA4LCacd9XFuH5607D7KpMOOwg6wBPVZ1EQBsC3aEXwC5aMAtmO2AbWYQL8oOX+buxYljL/NrcAlibA9wyGMGgTHOAvUYOsKYFkiHxgFJtfIwYFXfa3mkw2TZatA5wnkOg/7J8Lz519/s48463J0wEE0J0OcDjLYLFFhcLRJOirdIoaR+KIMFE+Ly/tx9D4aN3YlcgGAkhgAUCwbGFkQOsaYWkzS88mgVwJzOgDBmElU4UXAXoigMQn4RkqkBnKJ7MOcD6IlisAC4GCuvpemEdIGmqbAkOGjVFTsNlLcM6wFH+N7q3JwQ/oRMrigPM7BMLKBMjoyEydhfYKLd1U5tvzMdR0TnA+RXAr2xVBLcvksT7eycmDzqekqGJDB+/AB6i1yuZTExO8bGAtpNBSiZ4dbtxBwSB4FhACGCBQHBsYRgCzQtg7aCqP3T0zpR3+anbFczTYDIYS6InQCcRRhMCrUPbFsZbC6+T6SlrYhzeVAwYaKTrrlKgbjEw92Jl+eybx/76ggnj6tOnYvHkYnxkdgUuXlibc795Y3CA9/UGMcD0Fa6WBngBzLq/VjfiFk/uEzyAStBGQmxL+zgcYM01Kd8OcCRJz39wgpxBI7E7kQ4wYJwLLtDTZJCTLsKgBccyw5fhFAgEgqONmE+/LaR1gPlBVSieQjSRhtNmzuOJHRq6/Pl3gNnBl8tmRpXXAWx4BBjYB5xyPVBQMfJB2L+RZAZcZfA6qFNl85YBCTuQzgjtjg10f3eF4vhe+pDiJAv395DSUF6Ap7596oj7eR1WTC1zY3+/fvCujdLY2xvCXkLFdKEUQWqoDUBmG1sAq3wWgv4Q7KkcebUHkAds9NvZ3O4b83FUjKpAyzJgyo9vEU3Q8NiJCo01ankUHmcbJNYBBpRIgNphoggECka97D9oHEBfMI5yj/0QnJFAcGgRDrBAIDi20LZBAkYUwMDRGQYdT6U5dztf4YTs4Kuh3A1T8zvA/74DrPwLsPxXozsIKwg8VYDJxFWBri50KduzsG5x7SK6LMTvEcXxOVxg7W90b08IARSgnekt7BhgqgSzDnD5LPhslblfNEdv8OEwcjZbBiIHJiYJ0ecAA3l1geNMy6jBSB4F8DiuMYQQvQMcndiiXUcrbA2GLDIBXt3WZbC3QHD0IwSwQCA4tjiAHGAA6DsKBXC3ny/2Y/S+R8Pu7uCwA1tOAJcVALtfpQ92bhzdi7CCICN0G5hQ6jnVHsBrEE7rLAHKZ43uNQSHHYun0OJmk0tpWyS2UFNaJup3bIc8Wd3uGWKqPnP541MxaBkm6uAAQqBzpQ/85uWdWLtf32aNEIKt7X60DUb0T4r5lDB+LXkUwLEUI4AnKgTaoOXReARwIJrSTdKJEOjRwV6DZ1fR8P9NbeMI0x8DoXgKly9bi0/e9R729ByZLb0ERxdCAAsEgmOLUeQAGzrAwcNfAPujSTy3sYMrbDUcWjclFE+Nuarq3cv34mN/fhdn3PF2TgHNhkBPKy8AWlbSBwOjzEPjHOBqAMDH51Xhm2c24JIT63DtOdMBb7X+eZNOFq7vEcxli+vxmRNqcMaMMtz88TnqdvY32jYYUau27yBUAJcEcwjgoknok4bpA30AAjiXsPvv+nZcdv8HeOD9/dz2Jz9sw4X3vI8zf/82dnZpolKM3F8gb4WwUmkZyTT93U+UANa2QAJyh0C3D0WwrcM/7PWn3aefLBAO8Mj4IgkMMH/TCxfUqMv7eg+OGH12Qzve3dOH7Z0B/PH1UfTjFgjyjMgBFggEhy0PrdyPl7d24+ozpuJjc6tGfsJoGEUbJKNQ4MO9EJYsE3ztwbXY0OqD22bGE988ZdgiQgDQ5eNdpmSaIJ6S4bCOPtf52U1KZd3BcAIr9/Xjgnl6Ebq3lw7cZxUToIcJTY0OAqk4YBkhD83AAbaaTbj5E3OY7TkEsOCIxWE1489fWAhAEUlZIok0UmkZFrOJ+35tl6eoy5WRvfRAGgHcY+J7Xg8QD0qljBgIdgNPfAXo2gx86k/A9PNGPE82B9hlMyOekpFmSiC/v2ELri5cD8w4H3B48eIWZUKHEOCVrV2YU00LeOnyf7Mk8iNWYkzLNwAYmqAQ6NE6wHt6grjgz+9CJsAdl8zHZUvqdfsA+vxfQJn0mwhkmcBkOjonyhqZCUiP3YJTptGCgft6QyCEQMrzJCH7G127f/CgvKZAMBzCARYcHoR6D6jwiCGEAGv/AbzxcyCcv76mgvzy5o4e/OKFHVjbPIifPrt14vo9GjnAiRDnrhiGQB/mDvCbO3uwodUHQHFZrn543YhOMFsAK8tY84AHmIkBX0T/uQViSS78bj7ZDRB+wJ3T8eL20eQAG+Gt0W+bNHKxJcGRAVv1G6AuMPv9YkOgy1LdQNQHJKNAmMnrLZqETsJUDQewWZ5GV7Y9Bex8QRHNr46uYniIEXufWViLt35wFq47RzmmDUn8ZvD7wNNXA09eDoAXcy2aMOide3L0K47nRwBHNa7sUHhiRGU0kYYFKfza8gCWWe/AVKnL8PqyfGev2i7plWFyUrURKwDG3bOYEIKfPrsVs299Fb99eee4jnW4wqWgVBRgOtOGLpxIc50A8gUb6j8USXKiXCA4FAgBLDj0NK8E/jgbuHMO0LF+/Mfb+QLw8g+BlX8GVvx2/McbI4980Ixz/7AC/3i36aC/9tFCLJnG9Y/TKr79oQQSaXmYZ4zl4DlynhgX+EgrgkUIwb1v7+O29QTiuOqhdYglc1dd7dQNfAhC0RHcn92vAituB4I9SKZlzoHxGbgxW9r8yM5dFDqtqB7aoNtndAKYdYANnF6j7RYnUL1g5GMLjggKbBYumj37O2ULTfntVfATmiuMnm2Ar42umyyApxrtMi+AN8nTjV+0P4cY1cA6wAV2CyaXunHVaVMBADOkdlQjMxnbtAJyOo12Rsw1D/AC+K11W4xfJE8h0NprxETmAJ9v+hBfsSzHueZN+I7l2RELYw0M89pGDnAgOr4c4Je2duFfa1qRSMu4/90mXV2EowE+BcUNr8OqVOLPsK83f7nlWVo1kzzrW/R58QLBwUQIYMGhZ8sTAEkD6QSw/dnxH489Rvva8R9vDMRTafzm5Z1o6g/j/17eid3dotjDgXDfikbEkrzg1boUB8xoBLBhCPThK4Df39ePzQY9R3d1B/H6jh6DZyh0MYNwM9L4t/X/MOm+BmDdA8ZPGGgEHv+CMrH06o91oZI6B3jzE5j00hfxMdM6AMAJ9UWQ2j7QHzc4ijzgA3GA6xYDFtvIxxYcEZhMEgpsNHMr6/6xLmBdsQs7mDBodG/lw5+9tYDZgvZkIfbLSiXoDlKKDWTGuM6NFXEFduUcS9w2FDqtKJd8zJ4EA4P9SDBhxy0DVKDIMoE7kSMHOU9FsLQCOJpMT8j1NhJPo0Giv9vpUodhCDTrCg8Mk2oy0Q5wKJ7CbS/u4La9v2+CItEOI1gHONuDnXWB9+ZZABNC0K6ZvFjXPJTX1xQIRkIIYMGhhw19NmpRMxbSKaDxLbo+1DK+442RYCzFCbfHVh/c159w5DTw4TJg1T1AwqBaaR7o9EVx3zuNuu3j7R+pwn7HLHQW/Eh1gAkhuOct6v6eObMc586mFW4Nq8xm6GRygE827cCp5h0wyQngpRuB/r36J3RtBpCxc9vW6EIl/ax7HAsAL3wXk3xr8Tvr32FBCkvqXMZRHiM5wNq2MAU5BLDWARb5v0cdHgcVwNnfKVsJuK7YyRXCUgQwcx0umgQACCUJrkr+CHckP48rEjehi5SM7gQIATo3Ab18uCwr4twZASxJEqaWuVEu8ZNTPb38pJQvkoQvM5kUjKdQKeUQB3kKgdZONgIT0wopnEihVKLX23LJbxgCzTvA8ZzpLoYCeBw5wH95cw96Avx1/b29Yy+AdrjDC2A3AF4A59sB7gvG1SJ1Wda3HL4CWJYJ1rcMTVgkhODwRAhgwaEnwgjg8c5wd6xXWkhkifmUHDAoM8UTlkeaA+2s+Utbu7iZ/iOO7c8CL34feP2nwIc5XMEJZuW+fsPPLDIRPWqTMSDNDHhKmbBHphVSyMBVOFyLYN3/bhPWMG1Wrj9nOmqKqLD3DTOQ7WRygKdJGhf25R8C2t8LOwAP9WAgxA9IOQfY3waklMeLpDAqMYTTXa1KpIeWXEV/smjbwow2BFoI4KMONg9YdYCjWgeYEcBdWzQFsJTHwok09pNq/DV9EfaROvSTYQrGpZlrz87/AX8/C/jryUDTO+pmVth57FSkN5S5UQ4fd7j+fn2f4ZZMGHTQ70ONlKN2Rb4EcEo/uXhA/Ys1RBJplEj0nMvgRzSuv7ayxbJiSdkwTBqAzkUEDrwIVttgBMtWNuu2v7+3H7I88eMEQkjexx9GJNMyWpkQeyMHON+VoLXhzwCwvz982NbV+Pn/tuOS+1bhgj+/OyG/A8HhiRDAgkMP6wAnxlkYYe/r+m2+Fty1fC8W/PJ1fPWBtXm9CUUNcqmW78wdgnrY07aGLo+2X+s4ydXXcUIcYG34c9lMujySA3wY3qyf39SB21+hrV5On16Gk6aWoNhpwemmrZghtWPIoDAVoAzY2fc5WdIMyptWANuf4bexA3A5hdAQ/xxOAGtaydSYBjA7sdX4jYzkALOPm6yAK4dbZ7EB0z6iLBdNFgWwjkJGcoBri5zYTqao66RvJzDA5MdnHGBtKG4ALiRJjurn7MTs9ufo8s7/qYtGDjAAQwfYP6gXwM0DYeC5a1H7txlYYKL1IzpRbnweE4hRuPNEuF+RRAoloA6wVUrDmtA7fyFNuySjMOhIImV4Tob3C1kGnr4G+PPxfM9xhjX7B9Uq3ZVeO7IFoAfCCezQtqUaJ4FYEhf/dRVO/93b2NjKv39CCNY1D3Jh8I+ubsHXH/kQG1rH75IOhBJIMYK+vkTJj5+hCYHO57iobcg4CulwdIEJIXhuo9LZoDcYx4tbRtmmT3DEIQSw4NDDOsDjLfKx7w3dJjLUjL+/2wRClPyeXXnMyzWauX58XZvBnkcIrPDIk/ugJZfTGzFoqTFm2BZIJitQPIWuMy6kkQAOxlPDFpQ62Gzr8OP//ZcWy5lc6sJfvnACAOD0vifwmO23eM12E1w+4yI+XZpwwkmSwUTN6z9TBpNZNAPw+GAHt84VwdJUdV9YGIajn8m3c9Mwba4X8FAL8PCFSrXc7ISYtgfwcO0zPv8Y8IV/A1e/AdhcufcTHJF4HNQBzlZrD3I5wE7sIzWIE2U/SU4B+5bTAxRNgiwT3bWawIRBeIxflL32DTXT5UHa2zfMiLgCRqRPLdcL4JBPXwAo0LYd2PQvSOCFyJb0FOY8Dk4OMDAxrZAi8TRtLZWhKD2EpKagofaa3x/WTzZ2DkVwvmkdLjG9Cyvo/oYh0E1vAVv/qzj/j3/e8NzYllpLppRgQX2Ruj7RecCPftCCTW0+dPiiuHwZX5fkwZXNuPRvH+DcP76Dfb1BNPWF8LPnt+GNHT245dltOY44etjUnQK7RW1xxzrAvkhy2OJj46Vt0LgbwYfNh18hrJ5AnKsB8sq2URRoFByRCAEsOLSkk7wrN54+h8GeTI4iT6x3Pzc7n8+QFiOR9t7ePsPcpSOCEONUGAng3l3jz9vWvmQOoRuJT7AD7PACJVPpOpPzmqsV0OESsiXLBLc8t02tjF3ssuLBK5egtEDppTt16H0AgEkimO43KDoFfQXoyUYCONCu/Mui+Q6kAnzoMjcY1TjAJ3jDfC7mlNPoMjvR8vL/A/a/C+x4nhbjMugBnBObC5j9ScBTOfx+giMSLyMusxWA2UrA5R47TGYb1sqz6JNSzPW3aJIuUifLEMkhgNmJn6H9hstBrgo0dZIVB9jHHS4a1Ic4h/v4ehHdpBh3JC/DblJnfB4TiNHnMREOcDiRQonE3x8qpCHdtVx7vR00cICj217C321/wh9tf8MV5tfU7YZFsDo38esp/XWbFWX1JS6cMYM67ROdB/zmztzRRdnH0jLBa9t7sKMroGae7OkJjjscmxW2pQU2ZtmOEjddz2ceMFuHgv39rjsMBfCeHv4et7ppAAOHaf0PwfgQAlhwaIloBgLjmeHe96bh5mgvX1ApV4jtRGA0k04IsCnTn/WIIzSMA7zqbuCvS4E/zwMiB3Aj2/kC8MRXeHcGuYVueCIcYDY/3FEIlM+m63271ZzXXJVFD5dCWE9taMemNp+6/pcvLERDOZ3Rd6XoY664PtwSANcjWIKMSdoQ6CzspEFcM9kR1BbzYQauGgE83eHni9LVM/m5WYHra+XTGJpWZB4fRQVowTGBkQPM/l69Tiu8Tgvek483PkDRpJzXkjIpR4X47H0p6gOiTNimr1UpFAhtFWh6jlNK3SgDf9xkWB/6GfXR398meRpOjt+Lv6Y/gzBhCvXlKQonblAEa0JygON8CDQAlMOvm+TU/j0GDBxgd9NL6vL5NppKEYqn9CJRe40Y1LckZMNy64qdOHNGmbq+bv/Q2Kpgx/xKhfwc1BQ6uXWudRyTNtI6EOHyZVMyMXTDxwIr3krdfEX86eV8GHS+YN/ThQtopf7N7X7s7Tm8OmVoBbBMgDeG6aQgOHIRAlhwaNEK4PHkADe/T5eZ6r5EUwk6OI62CSORq3iHb6TeqocjhPACRyt+tj2t/B/zA3v1oefDEgsAz3xTEcHPfpMrMpNrcDohbZAYMUcchXwOcCIIBDohy4RzJOwWepnUFsJKywSrGvsPau/IYOsWzHnxYvzT+nt4EMEnj6/GmTPLuX3scTrALkwZh/OxIdAV8MEhMb8LO1MQiBPA/ODAHKbfDy/C+JH8T6Rf+hGQCCMR4AcNtak2IMpMlExaSpcTQeXYGx4B2BDQtjVKlMhoegALjgm0OcCxZJormud1WOF1WPGePF//5EwP4FyTbGVSjmiW7LWPdX8BQE4B/nak0jLnoroZB9htt6DSpBHWmcKMLKkQnTAaZJzoMBjxNIECmBCiTtgaOsATEAJNYgHYJP7YFZJPF/Ic1vw9jAoOFg1sUpenm+iEGCEGbevSmnt8327d8diewvXFLiyoL1KLlyXSMjfBOCyBLuDO44C7TwTWP2y4C/t9AHiRxU4atg5GdOHCPf7xCmDWAbZzj02vpAK4MY8CmC1edv7cKsyuot/vhz9oztvrHghGTrgIgz46EQJYcGjR5AmOK8SLHVzXLVEXLYFWbjej/M6JIpcAPtBKlYeUeIAPHdQOvtjQ54ixyMpJ/14gmZnsCPdxbqFRn0hgoopg0XNe25XG5x7aAZltqdO3C5Fkmit+PKXUTU9b4wD/4fXd+NI/1uCcP6xAbzD/InhXaw/My87H8diL88wbcbFtDX7yyTn8TrIMCyOAi9ODhgVO2BDoKSYmRM9cBBTW0h3Zv7MmQsMepa7VV8xv4grLGzCvux/48EEM9PD5wa7eDXTFbAcqjwckZmDob88IYIZESElrGEsItOCohq0CHYwndddzr9MCj9OKXaQefdrKzpkewLkm2f6UvMT4RbP3JTb/N8tQs+7a5GEcYCQiKABfBMgl6+9ztoRPXR6EV10OEkYAT1AIdCIl4+K/rsIJv3odT69vN4xcOtAQ6A+bB3H5srX453tNsMb1Tne55NOFPGvXdUWwwv0oidFaGiXpPrhB7026POCU5lrcz9dBSKZldPn5EGir2YTJZbRmwKhzoPe8Qv8uW5403EX7/nYzdUjYIoWKAOa/K92B8d1XWAe5rCC3A7xbUxslHE/hruV78c/3mpBKH3gni0SK/6wnlbhw5alT1PVnNnQcVuMjrQMMAKsa+w+rcxRMDEIACw4tWuGUCPFFd8YC6x5XzlUX3ZEOSKDHzKcAzuVSHpEXT014K+JBvi0OOxjTOvkjoXVSmFDrXJMIE9IGiXEzB1IOfNgyhF7HFPp4325dhMAUZlCkzQF+LTMzHE2m8c7u/PaPfGZDO1b943twMQO/i+sjqC3iw+sQ80Ei9DOswKDeIQE41/pEj09d7rVUK+Hh6vFyO8DuBP39zjAxucLdWxAb4mfNpSQzsCuqB8wWoIDJ0133AFeJW6X5feEAC1Q8mhxgNvzZbJLgtJrhdVhAYNKHQasVoI2vMY+lz8Mb6RPxRvpE7JGZSaDsxM/gfv2ThvbrBA7n+IX1qQWFUlh9Lw6rMgwrAf1t8Q4wGwI9MQL4vb192NTmQywpY9nK/cZ9gA9QAP/8f9vx7p4+/PqlnfD169ubVUg+7vNPpmVd2ztdCHT7Ot1x5trp9VZ3f01qqg5rHOAuXwzZqGlJgto2zm2j361cdSB0cBPBxvdBNkcdoGIzlkxz7nunP4qmPv5vPF4BzDnAbt4Bnl1Nv2db2n2c0H10dQvufGMPfv3STvxv84FXQu70RXWf9UUn1KLIpUwSRRJp/PfDw6NQKCEEe3vo55+ttZhME7y9K0eKkOCIRQhgwaElbHDD0N68RgsrgCuoK2YhCZQzOVi58jsnglzFVfw5WtGMBl8kgX+tacH2zhz5afkipAn7kVP8zHp8PAK4mV9ne/AyAw+nlQ4kR+sA+6NJ3LV8L/6ztlXvfDJiLkAUYdtpZXqG9u3iJkjsFhOqmfwt1gEmhHCDE+3M/URCCMFLLz2LK02vcNsXVFr1O2uiKiolH3wGIYWsKJ5tp8/pkqoAO3WghhPA3jSNuigG/T6kh1phiQ3zncj0YuXc3A1M+KCJDkTRslI4wAIVbQ4w+3v1OiyQJEl1id9Na8Kg1R7A9DkmpqD4AArx9eQPcT35EdoIU6U8+73XTtwBigPM/JYcVhMsZmZoFdIPnL0ZR7i+2IXJJUqECVssaihXCPQEOcBs/v9QOGF43xoKj/2eRQjhQki1BbAAxQFWP/9kFMk1y/AR03puH534buMrJwPAXBu9Juju6UlN0cl+XgCz+b+VHgfsFuU+w06uhEY7Uc5eE6PGtTC0k6q7My6jVrgToi9O2O3XvJcxwuUAaxzghfXFsGR+AOFEmuuQsaOT/u22tB/42IP9rKu9ymfttJnx+SX16vZHPmjJWeyryx/FIx80Y3//OFtkjgJtBeizmNSixr78hYgLDg1CAAsOLUahswd6k2cFsKcacNJeoWyLl0ORAzweB/jHT2/FT5/dhkv/9kHeqhCv2tePO9/Yw1er1jrAAL3ZyzINYQbGL4BZB5hxB8o9dMY6OsoiWPe+vQ93vrEHP35mK1bs0biyTB5zAMrAswlMlVWNAPY4LKjw0nPoYQRvMJ7i/t5tQ+MbqAxHtz+KG5P/gEniBwmmmEEfRU3xKbuURNCnH4Szjvok0MfbUJnbAdZUaS+R6d+9mGl3khhoQQmGGTQVZwSwlxZEQZoZ9J7xA7rcsoqvRC0c4GMabQ4wG/6aFb7ejEheKc/jn5xxgNlrTKXXwe1iNkn4yJwK3nnNfu+NHODB/ZoK0Bb+cYOohqwDXFfsxORSZSKuhJlAYtsxhfJQBKuXuY/kau82bA7wYBPw93OAhz7FTWJHEmnEGTe3RNKfbzl8dMLg/T/B9foP8IDtjzjVRFv+6HKADQTwDCYPWOuw6gXwPi6yjJ2srC+hEwxs/+ZcqTg6tJFQBukm2qiz3d1BEEL4vuk56B5vDnA4dw6w02bGvFp6rWfbErET0X3jKP7I5jTXldBoqq+ePFl1WFsHI2gxmECWZYKvPbgOP3t+Oz5//wcT0oZwX28QNz65CY+ubtE9xoY/V3jsmMScb66xneDIRQhgwUFF58gZCacDDfNiBbDNTQfZAOolKgryGwJNj21hrIUDFcCyTLBijyJOIok01uwfo9AcBb3BGK58cB3uWr4XP3qKaSOldYABOgDTTlKMsQp0vJ+vypkOGDvArAAerQPM3sTX7tecl4EDvD3FiLC+XQgyBcs8DiuqmAFyd4AOBHo1oWmteXSAW3eswVyT/oZt+LkbTCpFNf16Af6GXpWmg8n9cgUvgNniZ5oBeDl8yBatKmZCOO2RbrilYQZN2f7LRm5u+WzgtO9SFzgRAggTIikc4GMaL+MAB2JJzv3LimOvU/m/D0XodMygTy6dBoB3gKsLeQE8udSFJVNKNMIzhP5QHIGuffoT0jjAbp0Azu0A1xW7MKVMmYhjJ5CGiJKbWe6xcw4w0aahHCC9zHXsuMRWfGL/b7BU2sntMxROGNYOAACs/hvQuQFofg/Y9Ji6WevclkLvAFdIPnotb3xL3X6BiYY5c21n0imQTqZ+QIapEr2maR3gUEgjvFNRwE9rgbBFmeqKqchh/3a6dnxv/gL442xg9X38dvaaKKcMJym0nSf80SR6AvFR5Rn3TGAIdJmmCjQALJlSrC6va6YTqqwDPp42QKwDzArKumIXil30fIzGSLu6g6or3RuMY2fX+Fsu/vqlnXhmQwdufW4b1rfwE8isAJ5Z6YHTRiPQRhTAiQjwr0uBv50OdG0Z93kK8o8QwIKDQlomuObhD7H0N8vxJltSXlsECxiHA8w8z+qig2wcRAHMzFBWMQOrAxXA3YEYl5/V2GsQBpQc3w1yV1dQ7Se7dv8g0tlQpKCRAM7cgLR/I6O/4zCk+nknJe6jOUZsL+UKRgAb9Vg2otNHP4+WAc3nxQjgIJSb8cZoBfd40k/FoMdh4QRwDxOepp2ZH5MA3v8u8OGyUU/22LYbF1fhWrJkMfhbJIfaddvYz7M4QQeTjalyjQPsU/4nRDe4s0spFEL5jIsk+l5MGCGP3ygEOsviq5QJrJoT9Y9Z3fy5CY45uD7AsZQmBJp3gAHgmdKvA+4KYPJpwOxPAeCjH4pcNriZge6sSg9ObihFCHSwHvAP4YbH1sAdM7gmanKA9Q5w7hzgumIn6jOigHVLB4iSgvDdj8wAsVM3WCJpNQ0lLRNs7/QjeQAFirIF+9yI4h/WP+KkoRdxr+0vsIC+j5RMDGsHAOD7efvptWNAI4CNHOACKYZ4OHMfGaATCieaaB/2wXCChsT2bOPrB2SoTzMCWHN/bes1mChm+ryzoqy+mE4wsH87LgS6Yz3w/p+Udmxv/EwRO1m0gtcgDNoo6mx3T3B0DvA4BDAhhEvb0TrAALB4Co2UW9dMCyayf3ujqtyjhXPbmckGYJjPO8P7+/hopolo1bSCqdWxbCU/DmHD92dUFsBlpec3YgTatqeUFn7dW4FVd436fNa3DGFbhx9tgxFdLrwgvwgBLDgovLu3D2/u7EFvMI6736I3IkMH+EAFMHuTtBXQQTaASSY6CDlYIdBs778DFcBNfbyA28fmoRACPHkF8Nta4J07Duj42nNLpgnNDzMqSJS92WuF21hCoFMJOKP8QDLNiM5wjhDoXIVrWBIpGT1MNebmfs3AycAB3hOwgbipCDYP0IqhBXYLKpmJjL5QXJ0g0A5M+oLx0bVq6tgAPHIR8OL3geW/HHn/dAoN3a+qq7tKP0ofM3SA9X8L9vPNknVhvAjDkaSfy65EmXEIdCquOBwaKiQfrEjBK40hBDwbnaENZ7Y4gfmfV5annK5/3snfopVJBMckbA5wIiVzaSGqAGYqRa81LwR+uAf42suAVfkts9EkLpsZRYwTNaPSg9lVHjgL6G9gS1M7ulr2wCwZOKIxPxJB+pvTO8D666gXVAArk3yEi6AYyoRA15e48MXTj+Oe2zeoTHB99z8b8cm73sdn/7oqZ/5kLrIh0OeaNsIrKdfIMinAFeIChukFzE6yMdfUQU3xqtIcbaWkUI9y7WIm8GZLrXBCuaamZEJdXSb8OXvNBoCqVLs60aYVwEM+g/QLphAWK8rYsNyCXCHQ65bR5XQC6KHh2joBrLkmx1N8WHiW3d0Bvm96DsbTYi+sCUnX5gADwOLJ1AHuDcbVkOVQnH6m2u4HY4E9/+oiPtqCc9zj+jHSe3v5yVyjFkXjoUfz2WodYNdYHGA2PcI3+qJeVz64Fp+6+32cccfbukrcgvwiBLDgoNDMFDBgw48MncMDCYFOJfgcQl0INCuAD04V6MoJcICb+vnPgrsB9O0GdjyniJL37jzg6tnac2vOuqaGDnA2BNpg1nu0r+9v0zuEmUFiIiWrbjQAlBewOcAji8ueQIyLEGwdjPBhfDE2B1gZ+EQSaaRLaT9g+xCdoNE6wGmZzqgbhaa1D43CBX7xezSkd+3fR95//woUZopNJYgZ/nmX08eMiq4Y/KZMmnD2FFN5lc2PjxA7OlJeJK20PYY6wM2Rf1gpDaEIY/zNFuUQwPMuAZxFyvKCLwDmzICt5kTgiheBj/xsbK8jOOrIhjdnYQs6qSHQXKXopG7SJKxxbGuYgflx1V5IkoTpdTQ6IRL0YRJzDwnYq0Fs9DeyZesmeg6jcIAdUhJ2JDCn2otyjx0eRGFl+uVmq0B7HRZ85fTZSDNDtadX7YY/ksSLW5RJra0d/jEX6MkK4FNM27ntBZpJLK2jqxIxFsDa9kUlBiHQAGCK9AEDjdw2iyRjgYmmxqxrHsLvX9uFgd3vq9teTJ8MGcrf0kKSqMtEdrEhxkPhBGIRg8+DKYTFh0Ab5wCHshOu0SHa8z5L50a6rJ2w11yTc403dneHuBZIuQjFU8NWpCaEoG0wYhgJwIYuSxK4kOMspQV2TCunrf7WZVKIWEfWF0keUKQBAG5CukqTb+8x+rwzxJJpXQrTXoMWReOBPTdtBegZFQVcCHSuAqcq7O98lIaALBPub6u9thmSiExIGoRACGDBQYIdpAxGErTc/kQVwUpqQl1tbk0INDN4yZcDTAhkRryzuWXBWIqGFo8BrQPc1Beis/1sRdJUNGcFypHQC+CMiBuLA0xkGio7ArHeJt02c6ZViFbk8jnAI09ccEW8oAweuEEc5wDTm37QM01dLgjQsLwCuxVuu4W7UWdntI1m5kcVBt21eeR9GBIbHleXV8gnoG4609olFePD8QDD35Q1wv8tI8k0rEjhc+Z38E3Li+r2VlIBQELMTMMu46EhJd85bjyYrcAQl784InYv4My4DloBvPgqulw+C7hhE/CNd4CvvwVMPWP0ryE4anFazVx9BTacVS2C5eTzhLVEOAfYgu+cOwN1xU6cf1wlzpujRIPMnUrbILkR4yaKeq01CDjo470tu+i+o3CAAeD2T05GfYkLFR47Vy05TSS1QJ/HYYXbYUXKTF3KnS0d2KbpCNATGL1Dl5ZJRhgRnGPmr0Vu8Ne0sTvAI4dAA4A10suFP2c5UaLRN19/5EPc+3Yj9jfSbRvJdPSaaLTONElJnWEd4Hf29MEOg/PuU44TS6a5ImBsWG4B075KdSQ3/0e5v7J0bqLLOgeYT0vJKYB7AvBFR3aAgeFd4Bv+swln3PE2vvLPNbp+vWzoconLBrPJOHpmiUEY9Ii9mUcBIYT7bmoLzhVwVbeTymf5ny8DD30KW7du1jnnow2BJoTgpS1deHFL57DREey59Qb5CtAzKsboALOTzKMci4USKU7Lsqkbhmx7BrijAbjvVH2hN8GYEQJYcFBghQkhmRulLBuHcB6AAO4f1BzH5gYKaZn9CvjUXsDaghQTQioB/P0s3Nt2Mb5kXg5AP9upDdMaDU2a0v/xlEw/S18rv3NQH+Y6GnQCOPuaw1WBNvobjbIQVsf+nbpt9lgfQIhaeOR001Z8xfwGqhz03EZThbHDoBIzlwdskAMMAL3OqepyYZgK9KyjxLr52dBno9ysEVshaatfA0B6mO9FIgLznpfU1VfNZ6GmSiMatTdbAwfYEeNdqGg8iXutf8EfrPfjQvNqdXtrpvVLxEQnB7p6enHSb5bjmw+sMDzFCsnHtUDSYdLc1IsmU0eufBZQkQnxnPExoFaT91tYC9ScIMKeBSqSJHETY3sY18YoB1hXIRjQFK0y48yZ5Xj/pnPx98sXqy2MvIU0NLRAimIyI4DbSYXSLzsD6w6zg3oAhg4wAFw8W/mNlXvsXOixDwWQM0OzrCNkclC3ua+/X3Xp1G2h0YfJDoTikAkwR2pFtcQfR+sAG/YCTsb46z8z8akrgsUI+5SJ/s3ssRwCmMkDzuIm9LX8xI0eG72vT88UwmInOd7a1QunUQG+/t0AIdxYxGySuInqAjv93oTjaWWw8uEy6OjaRJe1k8E6B9j4+t7YG4ZvlK2mchXCGgwn8EKmR++a/YN4QtNPl3WASwwKYGXR5gHHUzKSaV44HkgYtD+a5PJaK5mOCoDWcU8BGx8Ddr0INL8H0+p7dcdrH4qOqhbIY6tbcN2/N+D6f2/Ef9fTz0RrQiRSshohxpoNZQV2FLqsYxTAzHgpOjSqiDjt5Iju2qFlzf3KZEzvDmD3K8PvKxgRIYAFB4UOH38B7wvFlRsnMbiojDEE+s9v7sHn71lON5htgNkKuErVTRZJhidTeTORkhFPTXBJ+/3vAF2bYUEa11qeB6AMbNgJ1wMJg24yCG1Tw6B1AtggZHkUaHsUtwyEldnFuEEeVdYFNAqHHWXYz1DHHt02M0kC0SFE4inMllrxmO23+LX1QczeTW+Co2lL0enTC2A1Dzge4iIFBphem+0m2gqpOEYLRnkcFiDYg79Hf4hXbDdhitSlDkaMBiWtgyPMyu59Q78txwAZANC7A+aM+xAhdvRVnw3J6lCKQWXRTjwY/B3cCb6YiO3d3+J883rdfm/LJyinJNEBtzdTsMc3ZFBwC0oIdK19mB6NTE9uAFxqAkxmxd29+g3gskeE0BWMitoiGrbK5gBnJ6wKmVDCrDhKpmXc+fpu/PblnZwD6LLlGHTa6PWhAFFMZkTuvlS50i4sA+sOF9gtQPc24N6lwD/P46oPc2Qm4+wWM+rsTIQUoT24s0Le4qDb7HIU//2QL2rXOwYHOPvezzFt1D3mRgxWM/0NGlYp1kaYMJOK2mJJnLAvoFE2zni/oQBeaNqHbFX5LNkcZUBpXedz0clK6gAr94ZUWsY7e/rgNHKAo0NAZJCbpKwudHA9m92MAxyOp4DW1UC//n6Fvl008kabDhTRCmDjAmnRZHrY3rbsBHpXDgd4uyYS4E9v7OWcW74FUm4BvIjJA27sCxuK3QMRwD0++v5sFhMKnfxkaIE2BLqPRlLIRi3HkKMQKEMqLeO+FTS8/uWtdFxk1EYp2+KpmZkon1qmTI6z14YRi2Cx9/FRRsSxpojLZobVPIIkY397OSJLBKNHCGDBQUErTPqC8dyCaYwO8MOrmuECc3G2ZcSBowhp0BtaKROONeF5wIz7Wif1owhBuO1mLhRvrAI4lkzrQnoBpiE7W4lTcw5jwTAEOpeYVkOgjQTw6CpB57qxIdSDUDyFRSY64CjsXqMujyYH2OjzUh1g5vNJERMGQIvctCWo4HOl/MgOwjwOC7D2fjQk92COqQ1XmF8fXwj0vjf124zaTWVhPqv9pAozasozJ0ln7EfjABelmG3bnkHxelqlcjNmAGf+CD+0/AT/SZ8DAAgyrVeUli0EBZLxeyuXfJheMMx3u+YEzclM5tetTqD+JLVAkUAwErVM3iaLtg8woEx4xpJpLHt/P+56ax/uf7cJ7zD9wVnRw2Gn1wS3FEMdI4C3R0uwJ1GmrrMOsNcK4OmrlcF8O23tA4CG/gNA1Eef72AEcKYAls1sgsOqnJvk4MW49jo3lv7w2QrQ55g36R4rQJTrXjBo5FBqry85imA5EIeLcWKDXlpnwZ0cAAb5HGBAuUdPkfjrYbZlFKAUwYp4qZCeZVImArKTHBvbfPBHk3Agx+fhb+P6tQ9blTieUqo/Z5l0Cp14JLJS7ZcQpTUVi+Z6rIgcgsvMb+NHzudRbqPntiNHWx+b2YQF9fT+lMsB3t7JP78/FMff36URTAMjVIDOom0FZhRJNeZK0Gvux/QH5uAe610ACCq9dkiaCU62p3conuSKR1kTdMK1yEV/z3t7h0+3eX1HDzqZe/P6liHV+TUSwK2ZlC+2Ts2UUuXvPGoHWE4DYX6SOWdEXDKqhi+z41DPSO4vwP3Wxtp5Q6BHCGBB3okl07obdF8wnvsHPAYB7I8mMRRJwi0xN4hscRKTCSETHTiwBTkmXABrLn5zTc1wWi3cjOdYBXDLQMSw1sGEOsCJMOQQ/3doHYggHRhBABuGQI/sAKdlgoKIvictACDYjUgijQLQm68twlSHTqRy96XMYCSA1ZzmAG211IsiNcwQAJqjdEBtRVI9B4/Dqgx0MtRJ/egOxJBKy4Yz4kYh0Gv3D+Kzf12J3724CWT/u/qTNgo1z8KETLeQSsytyThB7ECavdESYvh3KJR9QDqlVHJ+6Qfq9r1yLb5v/Tlw7k+xxX0ySOYz8cvUYbZIMmYWS/ja4jLtYQEoIdCTXcOEYFYeD0jMraZ4cu59BYJRUFOUQwCrfYB5p6kvGMdzmzqNnpLbAWbaD5VY4pjhpAPv/ckSbPDT30ilRAfrS3qf4JwsFZMFKKbuJTuYrWEiKIayBbDYgjg2Xoxr6R1JAAd7kHj9lyBb/oueQBxFCOJESR9uXCBFUeGhYsioMq/uvp0IKdcW8CHQ2orSseJZ6rI3NcAVwYoT+l4XMedlRhoeJiw7ADcSpbPV9YWmfTjPtF69t76fqRrskHLcawMdnLir00yk6EJyB5jPqPoEoIrWXyCdG/HgOzsgEU2oq4EDfIZpK+6w/gOXx/6Fmx3P8K+RwWGl18i6Yif3Hc+VA6wVwADwj3eb1PFW/wg9gOlrm7nXN7qPjtkBfvf3MKej+JR5NeZKzaj06Cc43cxvLxRLAX4qgLPfn0qvHWfNLFe3j5QH/KCmtVEonlL7B8cMqnFnxwdsulm2N/eo+wCH+/le9YBxHvBQM/Dn+cBv64HGtzgHeMT8X4Ar4jmmzhsjkU4pIv4YQwhgQd4xunj3hxK5HcMxhEBnBYeLLd5howOTQdDQsRLOAZ7gQliaQcFcqRkum5kTwL4xCmCj8GdgOAE8Rgd4sAn4wyzc2/MlXGt+DlnXM5GW4evNUcY/VxEswLj9jkywal+/OoO9q8uPOlBxzQ58EOpFKJ6CmxnwmKMDsEH53GQCw3YSLMqNm+AkaSemS4o7YOQA95AS7nmNIRsAOjud/a4U2C1ALx3Mlkl+9ARi6Mvk0WlpG4roRPpvX9mJTa2DGPrgUcN+lqwDvK83iI/8cQUuunclBkJxpJlBYiupxHFZAZzLAY75AVn/PTNDViZp9ryq7h8lNlyT/IE60Gfby/hlfmB49mQHTq+nDkKK0FtHBXyotQ3jfHuqAC8tGMQWpxMIDoTaHAI4+x12WM2cuLn37X3qIFhLQS4HmBGdtnQElrhPXe8hxehIFanrFZLyWBUGcGLT34yPZ7LyE1dMiGSVmQ6+B4nyutyAmBHjbujFSW9Qc4/1tQI7X1SdprYnfwjbqjshPXMN4s1rscS027ClkxsxLlc0YtR6zui+nRHzbMgtW9grIrlBCmmaSUOykWtbuFymuf9sHnCB5r0GiAty7SKgdrG67bfWf8IUVe49WRHjZBzgIcJUtPe3c65ohSYnlXWAI4k0SB8T/lw2HahZqK527vwAf311E7TIGgEciCVxpfk1df2ziRcAKG2fbrMsU0PR59ZQx7euxHVAIdCAElr9+g7lnsKHQOd2gAFwY5V2Iwd4DFEGSCc5U6BB6uLqaGThi2ClOAc421d+TrUXMyvp95+t1KxlW4cf65r1qTprMtWko4k0Jkk9+KXlQVxseg8AHR+wDvDUsqwDzH4fhpmANwpHNhKoG/8FhHuVe/SjF3O569pJOx2pOJBm/gajjLgbFftXAL8qBX4/HfjXpRN33MMcIYAFeccoL3NMDvBAo1JkyoBs2xmueqWVhjX1pZlZfEYAGxVGGRc6B7gFTo0AHqsDzM5IsoOSxr6QMhMY1Vzoh3MSjdj6FJAIwooUfmR9Ej+3PKIWCvOPJIBH6QD/9uWd+NI/1+CcP6zAYDiBprZ2rl/sVtJAdw51I5JIoUBTibSCcVeGm4UlROlh/DXzq3jSfhtett2M00xbDR3gblIMu4Ve/joDCW5wmp19LjLHuBy+MvjR7Y9xkzo2Jm8nkkjrWoeU963GSvsNuN36T+MTZ/5ud7y6G419YWxu8+GJD9sQ76MCuB2VmF6RGcw5GQHMVh1lflNEMiNAqAhI+TuAzU+o66/KS9BCquDKCAB28OdPSoiBfueWVpu5sPcuE20RUykNocw0zKSVuxw46RvKcvkcoOHs3PsKBKMgdwg0/Q5/9kQquP6zLndfztE4wFr6UIheUqSue6Qo3Ijih9b/wprOXN9YsQsAILTFF8AJ4FLm95PtAcyFRDJi3GPQb5uLsIoMAn89BXjiy8DLP1ReuZWmknRufhMzpHbtIQAoDnAZkytqWHnf6L6deS+sA8ymHIUsRTB5ac50MZhq/OZivCdTZ3WuqVldztYfAACZSAjCiXKPC/jMfSBmRVCVS37cRJYhlZZVEcPmADeSGnqe/nau9ZC2LVCBpoI36Wcc4LKZXDqH1LWJm6zNEg/2YXObD9f9awOeXNeGYCyFMHjxV44h/NX6Z3zV8ib+Zv0zihHAZYvp9/Wjcyq4UHSjEOhwPKXmEJuR5lzSdRnBx4dA53aAAaDISR83DoEegwDWjAXqpV5DB5jtriBFB7hq214pCitSmF5eQO97UCaJc/HwqmbD7dnPI5ZM42eWR3CF5Q38yXYfpkkdaBmIQJYJWpjoLaMQ6GEn4A0FsIED3L6WW037aDTciCHQMc0EXngCHeBQHwCijGOZ1IyjHSGABXmn3UgAh4bLAWaKHKy4Hbj7ROCeRYZl37M5l2zVRzmTpxOIJdHHhHJOstML3MFwgJ1WXgCPtQo0W5Xw3Nm09cNQJAlflz5/aswOcIAPCfya5TV816KEZ0UGmTBliXFIhnWA9Rf8V7crM9GRRBrv7+tHoo+GJ4XhwC6ZVvREsAfheFrXiqMK9LhcIay2dcCO/6mhO4PhBGJJGeeblLwtm5TGv2y/RTwagi+S0AjgEiycVKSud/ljIEzRtKx7URbjw6myDjA7IJlS5uJuXmwecDyVxnfSj+iqrXKOaMYBjiXTeHcvnUhp6gvD5GtW16MFk2iRjFwOMDMrTFylnNMda98K7H1dXX82fbpyqIwAYGfj9/aGECB0ImlBucQJ4KiXTlw4pQRK4sYDagCKAD7tBuCHe4FvrwIswzsRAsFI1OUMgabX20sX1Y2qplruHGBjAdxHvEjBggF4+UgIyYezTJvojh/5GfCRn9P1uRcDjiK6zgw0i5n0HLUHMOsIsfnI0IshLgS6bQ2doNz9CkAIKplr6AypA9NNxuHgBYii1M20njNygLW5jgAQ8yOWTHMTlGzKUcBUCGvFLKSJ/g/SZanFTpmmRcyU2tU+8Wz+bwhOEJhQ5rEB5TMRP/sW9bFPmVYjONiN5v4wJMiwMyHQTTJTNT/QodwLMhRpBDAbAu1FSOlXnKVsphIGnaEy0Ypy6B1YOTSI7/5nI17a2oUfP7MFO7oCCBNe/H3FshwNJuW6b5eSmG1qw7mzK/HC9afjkatOwpeWTmYcYGLYcWBXdwCEAN+3PIXt9qvwC8uD6mNZF5SbkHCPwQH26SN6xpQDrBnbTZJ6dRWgAf7zdsX045ciBDGjsgAzGAHcOhgxzOUFgJX76P3vU/Pp331tprVTPJXGHBOd0D5OakHLQBid/ihXrXpKpggWGwINDFOHZLQOcNEkbrWind6PDUOgQ33A/neVMY62DeFEhkCz519QkXu/owwhgAV5x8gB7tcWwbIwNwi2qMTmTA9UX6tyIdDQlqm6yw4KwkS50HYMRbmKmpMdrACeaAeYF8ANUhdciI3TAaYic8mUYq4QRE+bPn9rzDnABhftL5nfAgA+B5gNWc1ehLWVLwHdBVmWCScUe/1RTG/+l7reZ6lBL6EuCQl1IxxP6Yot1Vt99CWyN6B9y4Fl5wNPfhV49/cAgM5MpfFTzDu453/H8mymsBe9wXaTEpw0lQreSCKNtJOuZ9t3FIf4nsVOKQESD6GRmZyo9DowqYSKRTYPuD8Yx3SJDja3OxcDX/g3cPK36UEzDvD7e/sRS9KbcPfAEBxRWlxHZv8OnAPMCGDmeyi5y9AD+vla1/1NDY+O2MqwUp4HgM5ys7Pxy3f2cgK4zMK3Pimono4QM6hz9m9DTtyZ3OGCCsAkbjmC8ZMzB5i53taXuHDaNOO8dZacDrDFrm/hBajXLBkm9KFI3T5J6kU5E/aL6R8FTvsucO4twImXK/87aJgrmwNcILMCWLln5XKAjUKgg7EUFQXsdTgyAPhaOUE4w9Sutg8CgE5mkkwbAm3oAOcIgdZGvrAh0IPEi/q6SXiGnK17artUjd2kDnJGHLukuFpVe2oBff1Apm1dWSaU13bqtYhk7vUmiaCxqRHBeAoOTQXoJsIIYH87V9m62MX/fW0WE2yZyKBpEiPIbB6goBIom6EWwjJD5go2ZjHFhtSoI5kobYVYJxsArjLzLWy8iKDQacXxdYU4c2Y5zCYJVYUOfMP8ArbYr8ENsb8hqenxu70zACtS+Jb5f3BISUxt+jfKoQjfDp9SKI3LAR7BAS5kPotxO8Ca8VC91KfrAQzwk66Fcf34pUQKYnpFASaVuNRIK5nAsHr2YDjBFb+6/tzp6gTYYDiBxr4QogkZhWAi66QgWgYjtFMElJzj7DXBZaUC2IIUosEcha0MxlIpI4dW4+JO7aPdS3QOcNQH/HUp8PCFwCs38QWwgIkNgWYntYQAFggmDsMQ6JAmBJqtDMv1GGR+9H59GFurmgPM5PyklQv9np4gnwPMhJkFJtwB5mfFTRJBgW83L4AjY3tN9iLfUF6A6eV0EBTobtI/IdQztkIGBoK5DH6YkYY5zJT0L5tBl7MXcCMHWHPT6w/FuV6CVfufwYIBeuPfW34eepkBpBzoRjiR1oVATzL76EskMsUaHvssLTqRmSTpyMxaczlfAL5hfgmD+zdB1oRAL6wv4sKXo1Z6LsWZEOjCoL5VR7nkw+Y2ek5Vwwjgob4OOCU6CPml7YfA7E8CBTSEOOsAv7lTcxMdbFYXE8QMVznzGxmFAyy5SuEzUwFgH6S5zHsqLlArpGcLkbDhfx2+qDrgBKD8DpmJqarycnRaaMiexOQmsQNqmKz8oF8gmADcdgs3IZhFG8J62ZJ63T66Y+USwADnvGbpYSbt2DDoEyTmWiGZAU+10ubrzP8HfPpuoLAuZwi0K0WXsyHQnCPEtEFiQ4tZ1DBobYhy62pudYbUobYPAoBN8nR12S1FuVBZwxxgw4G9D4OM2PI4LNx59qYLYLOY8G7N1YgR/u/WgmpE4UAzoSHSx5vb8NNPzMGsIvr6AeKGSaJhyyazGWEzdenX71LuidoWSKwAJv52+Jj7sNYBBuh3aBrrkpfNUFq0mczchDD7OWZxkgisoMLdF0lyogvQh7HXWEOq8M5SaQ7iJ9bH4ZWi+Kr5DfR38Pf87R0BeBCBXaKvtbiIvs6apgGuKvdYcoCNi2CNxQHmv4OTpF5dvjXA/16LEjkEcLkHFrMJDeU0mm9Pj/43wOZDl7ptmFXpwSwmd3jt/iHE4zEUMEXkSqQgfJEkNrf71G3Z8GcAsJhNsJlNKEYA79m/h+q/zwVe/Yk+Jc+glWHMb9DeUCNi64KbUA7ltXU5wPvfoZNZu17SC+Do0MQVrmLP3y0EsEAwYeSsKMheJDmXMWS87NeHWbZlc4CZi9pAQrmQ7O4Ocr1eiwm9gEyoAyzLhrNx1r5tmiJYo7+BDIYT3I16apkbk0qpIJG0BbAAgKTR3t6GKx9cix88uXnkXscGs5YmiaAEQTjjbOgXI4DHkAPMFu5okDpxfvPv1fV18kz0zPsGN4CUg4oDrK1yWmOmOa7RRBrY8iT/uplKyR2+GGxIoljiz80qpVG86X4Eeuhn1oMSTCsv4PKsgiYq1EqkII6vLYTTp3fay+DHlnblu1SMAD4dfAJnSpsM33eYmagIEBd2+ExKIQ0PHewh2AN573JcvvVK/NTymJqH7QzT820n5agrYUIyR+EAw12GgNXYAdtSegE9VMYBLtDMQAcI02s45udCsEwOLybPnG947O0yU+nWXS56+wrygrYQlsdugdnEf9fOP66SuwYvqNNPxuQMgQYMw6B5AUyXlR62Gbw1gNlAWOdwgG1xeo0zDIEuoy2Esjmy5R4759aqhbA01+F0yypu3S3F4WZShjbLtK2QB1HVYQX4KsUqOR1gRmy5bVwItNWrDKpnzJiNh9If457aJCuTgbsIDQ/909kWfP3MBkx28Q5waYGd+xunrHRiYFezMkHu1LRA4nKAg90IRun1WesAA/T70MA6wMznr0a0AJhkMu7hXqSpgF0o6R1Llmqr/nHHnhe49e72Zm59e5cfHk201NJyOmZ4Y0cPV6hx5Bxg+lmwE9dZBsNxtZ3QiGjSoWqkflS69b8zVgCXpPTjkUmOmOpMz6qiv8UdBtWvt3XQbcfVeCFJEk6aSu+Ta/cPIBXhRWR2ovud3XS8ky2AlcVpM+Mi8ypUS4OQ5BSw+l7gwY/z41EDMyEZNJoo4l/fBILzzR8CMHCA2T7Z0UF9CDSRJy5flzU8Cspz73eUIQSwIO9kQ1NZfJEkZHawzrZGyeYAp+J8RVuNAJZlolYrZG963VHla727O6i2lAAAr+xHGfz4heUhnLD/72OqNj0sMR8g6wcKpp4tnEsxlhBotgK012FBqdvGOQKuHK2Enn13Hbbv3ovXNuzBcxtztBsCFNGeo5F6ueRDUZq5gZUaCOBR5AB3+enExxfMb8NGlL/RICnADYnvoKrYi7CNDiZMod5MESx+wqSKLYIViQBv/4Z/XckEpJPo9EVRZpCTBQDe/o3wpOgN6bhZszGp1MX3vAT9rpQigItOqDFsZ1ImBdScrJ9ZH8UZrffiC3t/gGmZsEI27yo5QHOI20g5QvGUUoSFdYDDvUj87/s4Do34uuVlXGx6HwAwCfTv00oqUV/CDPhzOsDMTddVhr3uRfoPo3YxWiw0h9edDYHW5CCxvYAVAcz8ze0e2Ctnw4itrAA+hsKpBAcXrQA2qqLqsJpx7dmKwPM4LPjVRfN0+7jtwzjANr0A7mXSCnpYB5gVwEzFY/6E6P7q4DWdgpmpMJ29DrEpCailv+M6qR9zPFHc8sk5qPBQsdobyNwDNQKYtPAOMEsXKeEEfYEppqmEbFQEyzgHeIBxCEvcNnxkKj23JXOU683SqSW4L/VpLr1ic0q59++UqQC29O0EANQ46T0zQFycOAcAiSk0Zkko134HE3EDsw1hB3WAJZJGqcz2l9WLwmxEAOfulk1ndqACQduzOIt2ElbrAGupshi4+luf4la7+qhISaZl7OkO6e6VxxfS9Ve20XOzmU3898kAo4gKFpmACx8fFk0UglkiqIJ+4oSddK0i+sdneui47rhqOtlh1P6JdYDn1SoTTYsm0+/H7p4QZLZgJGiY/tpmeg+dohHALpsZsyRN9GHHh8DjX6TrBg4wMcrR1bq4AD5uUgrU6XKAmQ4QSMUMX2PC8oCPUQd4FJ2XBYIDhxBi6AADAPEzAq2UucFk3UWtyNII4N5gXC1cwOYAd4QVAbyrO4jJTAi0J+3Hdy1P46uWN4FOAPe/BXzuAa61wQGRq5p11xYUNrACePSuc5Mm/FmSJLXHJQB4DApGAMDc9iewzvEGQsSBh1oeBZZMMtwP0UFOtA+SApRkbtpV0qCaAwuAd4DTcWViwigHOO5X2h+YlffMTnxMkugF9oHUJ9CFUlR47ZBdFcjWOTEng4hHwyjQhIdVgF7kK/Y9yVVlBqDMhAa70DEUVduRaJlm4j+vmy47GwBQwwjgDf1mZIfHJVIQZ88uAJbrJxHKpOxNjOAs02YAgASCRaY9aEzXcgNBydeiLrcTZeDUMhBGSQXjAMspOIJ0vx9Y/4uX4iereXAA0EoqML+YCUkepQPcXrQEX+65GSeZduHcBjeOn1INLLoSkeX0Oa7MwEg7QNI7wMzf3O7hwjJZnkifjSsd76Ak3Q8sutJwH4FgvGjzgHNVUf3GmQ34yJxKlHvsnBucxW4ZxgcwCIHuzuEAF7EuX2GO0GsjB1hTzX/IyAH21igh1Zk6Bq98rgCYVYun1rdjV7fyu+wLGQtgy4BBT+IM++QarkKxR4pBYhzxsFHRH8MQaD8G06wAtqPcRMVrSbFyvVpQX4SoxYtvJG/Et83/w9RTL8bulaUAZM4BRo9SU6DCSu8hQbh0eaw2TwkyEaSqyORygK1OFNi8GPTT+1uDqRNfNb2BAimKwhZZuY5tfBTo2AAs/SY8DqUiNS+AGQeYmdSrzHG/KQY/dvFqnFot5SbN/dTXCrTxExeD/XTiYXXTABJpGR4Tf6+c5jCe1C8tsEEaIRLH6LehJbblOaDjVWDJNcCU03LvaBAl4A63AZjBbWMnW2ol/cTKFCf9+7NtorZ3+kEI4d4TK4rnZtoFcvns8RRIjJ+I0PaqBvgQaEBxgGdGDYo8dm9R7ol2D0ioB9pPVzLqA2wggJeY9sCKlH4Cj3WAATXSjSPSD2CmfvtYYQVwQWXu/Y4yhAM8AtFoFD/72c8wc+ZMOBwO1NTU4KqrrkJHxzDuWg6Ghobw3e9+F5MnT4bdbsfkyZPxve99Dz6fb+JP/DBhIJzgqutlcy4diMMcZW6kFcfR5UQIIEQvsjQCOBv+DAAeE50p7E9Y0dQXQoePL4LlTPn4MLXBRuCfHwX2vTn2N5aIAJseB9rWGs+IA0DvDhQyE9ZjqQLNVoBuyMxIsrOlxQlG0DFtn86NvaHsK8UwufOl3C/AhOzEiBX7mTyp2ZJGYJbyNy3EQ7ndc0aMsQ4w28qokyjFpso9dhB3uVr8BABskV5dldMymR6zuIcP51Pxt6PTH+VeB6UzIJv0M/zEUQi7UxlkVhXSQfSGPjrwm+yMojzWbPhS5RkBXA6fOqgCgBpJ+T6zoYDWIP3OtmUEcOtgBLB7AYtxIZ9aaQBXmF/DZGbSoIVUoJ5t/eJi+4n6aS4QO/BwlaLIZcNK+Xj8KXUpXq39jlKIp7COq+6aLfShDYFOse6XkQDWfi+g5Cr3oBj/OPFZ4Ae7gcVfM3yPAsF4qdO0QjKsogpAkiRMryhQB/isa5p9PCc2vQDuYxzgPknb6ihDLgfYKAeYEaxxYlUFKdvSCQDnAqNDqXRfbuQA55qQNWAfqUWIifQoQJRzxBMpmS++lIwZT35qimCVum26iBFAceQX1hdhtXwcrkj+GM9YP6WOD3ayAtjXAsQCKDHTe0iAuFCucYALCmkEUTbMmAuBtiqiuYvQAoe3WP6Fay3/w+XmN2B+8ivAI58Gtv5XGQ+8+mNUW4KwIMVNQKJsJp5e346vPrAG+8L6Yk5aipj8ZwkyV83aiBKiEUbbntbtE/Apf1d/NIkfP70VAODRHLcwPcB9J7KwNSpyUWjghrN4EEH18u8C258Bnv2WMkbLhZEzaSDg3EyV5ez9k6Wa6S+fFbWA0gmDrYwdjCW5minzqj3AjudR2/k6AOU8I4kUJE3IcIlBPr02BNplNWFmjrZhrY3ble9vSB8JwKY1AFA+LwMBbJeSmC21Dh8CDQCDfEcKAGP6reckneL/XiIEWgAAsVgM5557Lm677TaEQiFcdNFFqK+vx4MPPoiFCxeiqcmgEFEO+vv7cdJJJ+Guu+6CxWLBZz7zGXg8HvzlL3/B0qVLMTiYo7rcEQ5bTbDAbkFdJoyzVmJ+uJKZd4CJrLQ80oqsQKfyY83QOkAvjuUOuj0MB57fpMzeDjIh0FY5xlW/BKCEWK9/eMzvC2/dBjz3LWDZx4Dm99XNjWzLhXSCu7GNOgTa1wpz2yq1FcS0MgfQtRlFZuX5bkS5qqHcwIjBG27O/RrMBbuXFKGPCeVj+zDCUQgw7YEAAPEAiFEOMMBdSNmKjKwz24siSJJSzbOowIkBJvTYFuvVhXUVpwfUvFh7zHiygfha0ToY4R3gwlqYKufo9pU8NCfswgXVtFIkcx5VlhDQu9PwtbJFK2ab+LCobLsmNgTaHaXftzaiOAetAxElL9aTe6b1OsvzmG+iIVA95mpuNptzgMHcWDUOcDHzHDannG1XknWAtSFwZ81nQ98DBgJ4GrSETF7MrSnEFafPGPb9CQTjRR8CPbqANm2I47AY5AAnXfR7nc4VLjiaEOhYIFM/gl4zlWuQckHy2DWCno1UygjgCqa3aq4c4OFoJDUIMb3C3YjpqmJzhbByVZ6N+riCSyUFNr5OhI1+5ic30PvJ27voJF87KQdhJxx6d8AtM4Ur4daJO1sBvQ5mHWC26CCsTpQV2NFJqFBm2+DoIDKWJtagXuqDTcq8b8kEn6MONz+7Fe/t7cejW4cXswAfAu1BFCZp+NzZQqIJ6dWEPwNAJKC08vnZ89vUqDqviZ8sloLdOGlKCbetrthpGPqvO4cRHOAaqR/mbI9rfyuQHOZzMBJmBgLYYjbBaTXDiZhhcbcyExW1xW4bF7G1ncn53dlFn1tgt2BS58vAk5ej4e1rcan5HQBKPrsU5wVohVk/jplcyk8W1FuG+KJlTHTH7Y+9hM/8+TVICd5ZBgBHKsBPEiSjfEof0xJpgamRn8CLDOp/x4YO8ASEQEf6kZ0kAHBMhUALATwMv/71r7F69Wqccsop2LNnD5544gmsWbMGf/zjH9HX14errrpq1Mf63ve+h3379uGzn/0sdu/ejSeeeALbtm3Dd77zHezZswc33nhjHt/JoYOtAF1b5FRncNnZvpirSh9OmQjpCy2RNCfcWAe4yExvelHY8dR6ZcZuCPwAxiEZiNDA2N18NL6VOSeZtmoC0EHKECVUdBQyIUqheErXykBH0wrgniX4f53fxw2Znryf7LwLuP9MXPjep+FEjJ88MNuA6gWGhypP6KtmqwTp7HYvitHPOOXHSTQcFwVVSusa1g2MDEJiwt2ShCluwQyQulUBTFABOhvaQ4pR4rLBajah2GXDAKGhTe54H6wSM+CC0n6gNBOq5IgxF3w7MyPctR++SBLlrAAuqAQqDW78XjpJMbemEPd+6UQ4rCYMMJ+BO+3XCGDqEmVDoLV5Qdlev75oUi0WUsQ49e2ZQZjaJ5jNA9ZQKEU4dznhncI7VY5Cvj9z1nnX5ACzopYXwHTCKNsGafHkEsyrVT6DH10wC1NqmcmcmF8zoC1QBrVefqBfUl6Nl244g8utFgjyQW2xNgR65BBOADhvzhgGeAYh0JZCOoFmK6rVPQ5A1+9ThauITpSJJeaaydWs0AoSrQNMCOdmq1WgxzAo3kdquRBoF6JwWflhIdcKKZfjFPNnJv6U616pWyuA6ee4tIEKtM3trCCRgMq5dLVnGySm8I9RDjCYHOCsA8yFQFuyApgXhfS8MhMOzLV4ceR9Pvy5aDIah1KqU92eGHkChQ2B1rZAQmYCls0f96QZt3DN/WoIOIs9HcK/17aqk/sA8OnZmu9nqBsXL6TfyY/NrcRLN5zBFZDKRdEIAljrNmfvOXt7gmgfDAFv/hJ4+holfHuUDjCgRB4Zub+AfmLgOC4MOsAs+5l9vDAxLTM/kcmxjSVlnQNbLAXBiT8oUQosM0AnTEKOam68NUXqQWjAOB3NDE3vXq37O+1cdXGhaR+X4oZBA3MtZwj0OGHDn61uw2ve0YoQwDlIJBK45557AAD33nsvCgrol+LGG2/E/Pnz8c4772D9+vUjHqurqwuPP/44bDYb/vrXv8JioV/03//+9ygvL8djjz2G3l7jioJHMmz+b02RQ53BZUXc5qAHzX4CVmQgHjQOs2XCoFuZdjMFTAh0mDjU103CgqhphB/0WPvnEgL4GPEzRENTBuDl2sdoc3+GDYMebAKevEIpeADgSvNrKIUfk/crVY+dsR6cbNqJOjZXprAe8BoPwibJHYgnc+QdMxMJfaSQc4CnmpjQr6yLxzohQb71Qwczu87e+Loyf4NiBOlsOhTHOfs9KCmwwQf69+FCuxkqpUEABK4kc8GvPVFdHOpU3NKKbEIYkFsAMw4wAHzi+Go8+c1TYPfS0B8pHlRyfLJU04rHZZIfdosJn5/E35yrMzdxki0WIssoT9PftOoAZ7+3Bg7pSvNJ+vMFYCmdwm+QJG7wh+igUlSH6XUMTxWKnHQyhi1gwjnAGQFss5jw3LWnYcevPoZrz57OD9ajQ3oHGOCLwwAaZ1ogyB/aHGBvjhxgLVecOgXH1xbCapbwm4uPH35nbREsyQx3CRVLrtIcTm9OB1hThTrm5+5pg0wLN52jzTrAMR8w2MSHQAfjSnsWbbXYYdgn1yLIOMAWpGElSa4lT5itBJ1rwB3z49Pd92Cj/Zu42vyyEq3ChUDT93XipGKu/Zy6i8UEib1ed2/jREMALs49BsCFlGcd4FI7M4FqdepCoNXjmYqAm5qBnw0Cl/xT3T49vB4LmOgblM1EOzPZzk7Y5mKmN6lGKBQywpHYPcC3V+Ltpf/E5Ykf07eR8ivRAGv/AbzyI8NjehHGn96gfYdPmlKCM+o1EwLBbpx3XCWeufZU/Pdbp+BvX1k0qtxeILcDXJlpX6StzYHoEJ7Z0I6P/uld/O7O3wPv36mEkr/9m5EFcN8eYONjQDyoRAZKxt8rW4IPIz6OCYNmRS9bAXpujZczNRaZ9qoRZESTby/JKfz8PPpb/fg8/aT01DQVwAOuBqCEFnmcLPVwk/sDxMOldHGfAyuALQ4k6k5RVxdIjfyElzb8GQCSBoXUIoNKZGTTOwde1PUYrQANCAGck5UrV8Lv92PatGlYuFBfJOlzn/scAOCFF17QPabl1VdfhSzLOOOMM1BZyQ967XY7LrzwQqTTabz88ssTc/KHEbwAdqozuKwAbidlWNk0wOdbJULGuUbMYKF9kB6b7QMcAe8+Je36PC027wnBbuXmM1oig8YXIwADxMsVD3KmAlzbhpxh0PEg8PiXuN6QRVIYP7c+AokJm5kk9XIFpVBUD3iMncQCKYb+zhzhXqwDTIrQjxw39ezMOCuAA7xIbWcF8Mq7gFV3Ix0ZQk/GkWDDkmPEyoWylbhs8DGDPqNWCIBSmMuNGKwy/Ts/00Pfd2pQeZ+cA+ypAqqGd4CzzK8rwpPf/xS/sf1Dujz1THWxwRnBy989g5sZBqgDDChh0CTYCRvTD7KdzQEGdA5wipjw77pbMFR7lu78KkoNhCVbCToyqITiZ3sju0qBkmlcm49cDjDbB9ViNtEQSHawHugCN1Oedd+1ecAu/W9NIMgHpW4bHIxbaVQF2gi7xYz/XX8aNv7sfHxpaQ6nVt1ZI4ALKvHRuXQC7YwTZvORGFlyCWCTmYtcwcA+YMMj6uoeQsMrdY62s4hPFercyFeBDsZHdH+DEn0/aXsR+uFFGPxEQlaUZOEKYRkVwAKA9nX4dPQ5FEsh3Gp9DCUuK+3mAHD3dofVjLm1+gJ6BXYLf73u2c6Jhqs+cgKO17axYkLKsw5wHWvQGoRAZ9lbsFhpVWUyAZNOUSfvzCSFb5qZcV35TLXbBAD0Q3/uALgJyQsabGqEAucAO4oAVwms08/hRLmJpIHG5cDLP6T7Fk4CFn5VXfVKEfSHEjAjDRuS+PbZ02DSjpHC/UA6iRMnFWPJlJIRC1+x5KoCnS0K5dWkJsmRQdz4pFIEch6YdoEd64cXwJFBJXXs+euA+89CjTWMGmY8yEaUSZrOEvOqmBDoHA7wvJpCbiLYK0VoDq9B26ArTvDgp5+Ygy8sqcdPPqFPmapP0Yi4XsdUoIR2UJhi6lZrggBADymBH8wXkK06zXyXw5IbvR4a7TDd1MnniRsJYCN6dwD3nKTksf9hBvDfr+VM3cpJiDFUjqHwZ0AI4Jxs3qz8sE888UTDx7Pbt2zZYvh4vo51pBFLplUBWFvsNHSAO0mZEp7Chl4kwmNygO0yvTiHiabIiVt/81snMy1cSDp3ISsjtFWIGQZIIecAS7EAN7OaUwCv/TvQp79wfdr8Abc+SerlWy+UNCjVQXPga89xMQyxArgYfTlmtUnB8A5whNh58dy5AXj9FiSe/Y4aBlzJFKZS+v5K6veg2G3DECOAK9PGURDV0iAnbmWY8PoQFZD2iHJOFaMJgc7xeVkcbiUEKEuaKaYylYrSItmHaaVOoG83f1gpioLMTWwglECoh4YxDRCPOjHTHYhh1b5+bAnwEzW7ST3qqioQu/Bv3PY18mxdwR8Aege4aQV/viYT1+bDxzjAXBEsm8EAHuAFsLbIR/a3WqYVwHqnRSDIB5IkcS5wrirQuZ5bMEJbGAD6cEBPFT41vxpPf/tUvHD96ThjZqW+aqqjyDB3WIVNWXnuWq7V2mPp89RlQ0dbEwbNOsADoTjSwxTFGSQF6HTSirGmilkwSRIisPOuVSLIXRMirAPM3ifZ648mjLTcGuOvn5piYifUF+nOz223ABVMCHTfbk40zJlqUFmbc4CV8UKNmzkXqytnCHRb8VK6YrYAsz5BTzcTsZSGGZj/BU4As6kyHEW0laMz5Ued6gBTASxlzre22IkAXEiw6UPrH6LL3jrgyheAKhqh4EUEdVIfVtpvwFr7dTjNuZ+PygEAEON2OaPA47AatmzPFoXSOsB7W2gU3HQ2ZLx/r2FbSMT8SiRRyyraum+wET8L/Zp7/h7CTB6xQnrnizjvfyfjJdvNKEAEHb4o/JEkEikZe3vpWHFurVdxRRkWmxTn3JTQR0eYogP4+pkNuP2S+ajf+EfgT8cDa/6uPl6ToBF+nTaNAJa6uXFJHynk6s4kgsrvZU9PED9/cqW6vStux22rYvAxZomjbzM9qdEK4KYV1ChKRpQCZY9cpHTjGC1sO8xjrG2hEMA5aG1VRE5dnfFMbnZ7S0uL4eP5OtaRxm8/Ox+7b7sAq358Lr6wZJKaA8wK4A5SpjRZZ8THm5saEQ4Z9HTNCOBYMo2ebNEPANY0FcNaB9heqP9Rb5Un8wU3gl26fXLChj9r6IeX63GImH90ArhzE93HlduVmCT1YApbnbJkWk4HGAASPVSkbWgdwvX/3oDnN3XwAhhF6M8hgIPWjKDJ4QCH4eAqbWcxd6xTl/kCWMqgKVu8pdRtg58Jga4ixjfvSmkI5UyP36C5SK2qDCATakx4AeypUlxSTcgzvJp1FiMBZy8EqmgINJIRJTw6pe9vXSXRQljhbhpG104q1IkgQoAv/XMNHtnKP3+TPB3TygtQUVGNC5O3o494kSYS/pM6B/VGVTy1rZCa3qbrDWcD4Gf1hxgHOJrUF8HSoQ3XzGK2AZbMwJt1pLTnJBDkmRkV9NqhDYmeELRVoD3VkCQJiyYXUzdSe/3N1QIpy1k30WVmYqm/5hw0EeXaJEl8ZIYKK4DbP0SFl97rZAIEcuQjAkAXKUW/m/5epYo5mUkAicsDRjzEvXYoVwh0ib4IXpYyonEAbW5uNacAZsQF4n7+vmx0PTJwgCucrAB2oMxjNwyBHqjUtPGZc6Fun6e9XwWq5nEh0FE4ENFMsgMAiqkARmRQdYALtQ4wgOpCBwAJg6yb3Mq0PVp0BVA8hXvPXimMS0zvokoaQpEUgm3TI8bh7gYViUeD2SQZ9gpuKFf+dtoc4E276QQvlzPNTIakicR/VkMtQPdW7jizkjtwteUVdX0b20c+GVaKRwHAqrthSoYx19SCL5iVe932Lj+6/TF1sh0ApnrSus9lUUYA25IGY8qsyG5aAbz3B8XgeO1mRazLaZTH6Li8zTqF+95XSj5uPNZLiriUrsBgD0LxFK5+eB2GBulvJwAX3t83gM0yPZbUwUScjVYAGxHqAfzD1H/Rwk5qCQEsAIBQSJlRcrmMy8e73cpFIRg0CNPN47GyzJ071/BfY2PjyE8+yFjMJtQUOVHithk6wIoATiCQphfK97bvR2+/QRhNRgD/ZfletcCe1QxITEVCdwG9qVR47LB59XkNLXIV0m5m4BLsVsKC1/0T6B/h4jPMxWWAeBFgQ2BGK4CZGct3iy9BnBiLEp0DXDq8AJYGlNCkRErG1x5chxe3dOEHT25GmhGxfaQIvSgyfH6PnLkBcwKY5tcEiROvpE/Sna810gNLJvyXL4ClvA7rALOzoLU5coGqMMj03wUC5hK1nRIAuKU4ShDk9lGdGW0Y9DCOOdwGArhidkYYM9PjjW/r9wMNgx4Mx5Hob1a391sqUVPET8z0MnnXALCJTMO08gKYTRKCRbNxdvxPODl+L56Vz0B9scG1gw2B7t7K3zSnnQMAKGYc4GgyjVhG+LJ5fTkdYHsOp4P9LggHWHAIueEjM7CgvgifnF+N84/LfR08YLS/AaNrrXZb0QgCeOoZwMwLdJvji7+lLld6HDCZDOw41j3u34MCu4X7/YaGjFNIAKX93LbazysC3VMDLP226oJzKUHxINxML+BsvYBgLMkXwTKoAp+lOKW5jmsmEhbW61MlCuxmwF3GtfXjnEQjAazLASaodvEOcKnbhh4UI8243HvlWtiKNbUzGs7mznOdPBOP2y4BwHezAHK4wGzhs+igmgPsBSuAlffgsJqxZEoxf5yIwWfLCmBEMrUwMoR6DRxgjL2mCfsWDFohzaxUrvceTT2T9k5lzGJHAvWS8cT1IDxoJYyoGmo2LPDF8iHR9LXNhkEztVY+alZq7+zoDKCTabdY7rHDHtGfy2JJMQIcKYPPK9yvzEov/xXdJqeUQqdDzbASJZJBJhJaTUrNlTjomG6xiZoMfSjiHOCIrxe//N92tA1GuXowAeJGOJHGJsJMIHdsUP4nBBgY5zjeP4bCrmzEgAiBFgjyR1mBHWak1ZYxgHJj7g8lEJHoTTgaDqCt2+Ci6m/Hmzt6cN8KeoH4/AkVkAh1tM5bQGeR59Z4DQflzaQSCaadBYKdwJNfBV76AfDgBUqf31gAePJy4NGL+QvKMA6wkgPMOsC+MQvgzfEqvCvPN9xtstTDF8EqmQZYeedjp0xvxI6ActN4e3ev+topWdaEQOd2gNuSmRs0OxAM8g7wOjIbZ8X/hB0Xv6Zul0BQlQl95hxgknWAaQ4wW6nbJTFhcwxVmhDoXuLFEDzc7PI8035YwORyZwWwNgx6WAdYHy6PijlKiBwbSs+GGzNUq72AEyA+OnPss9egppD/O/VpBPBGeTqmlysDsPoSF8Jwoi8zMZFtH8bBhiBuf4YulzSogzFtXpc/U6E6zvTmHlUINAsrgL11fD9jl3CABQePuTWFeP6603Dvl07kCjdNGLoQaIPJM50DnCP/l+W8XwASc76Vx6N24cfwtdOmoLbIiZs+Psv4eeyxYz4gGePCoKO+3OGvXaQU6aLJwHe3AN/fBlTMVnt/hwkzOZcIcb2Aw4kUvv/EJhz/i9exq5GpTquN/mCwRRghbnEo10+G+hKnUimawWWzKNb3qCpoZ7cV0ZeRZHz9pHI0FDKfq1VJu0rBokYfAcD78jy92LM6gFOuBwB0kFLcmPw2ggkCWSZo92kEsFEecNEoHGBGsN/1xYUoLM0xGVtiIIClCMokxtmMDEy4ADYqhJWtIK1tT1hAlNeeInXDnKPN0xDxoNvM/D56tvHFJRlCxIHn0qfi+fRpCLHfx8iA0n+aGbMslnajFH7s6g5ynUZqCh2GXT0mmfpQgSEUEIO0usgAsOtFtbWYyp7XlRzbDC2kAv6UGX3hJFplKhTnm6gwbyflXE2T7Y3N+G+mIwk7EZJNk9vEOMBo/1ARv8Gu4VtM5cLE/MbG0tmEC4EWRbAEgFr1ORIx/iKGw8qX2eMZubz8RB4ry/bt2w3/TZuWe1b2cKDcY0cFfLBIdADeQcowEIpzF70CxNBuIIBlXxtufHKTuj69ogA3n8ffML94xhwsnVqCSSUuXH/uDENR00KqEHMws129u4A2pVw+wn1KAY5N/wJ2PK/MBL51m7or8Q2TAww+B1jnAEcMBHA6xYUtbfa78XJ6qX4/KG2csp8dkUz4y4YkPvLHFdh+3I1Iw4RV6ePw59Rn1f2Lo4oIe3o9zZ0uQBTmFL1p9JJixGBH2qqvlr0vmtmWMwRaucl3oxQ99gZuBrEWyoz2JCt1ZbMCOJcDnIsqaYgrNtGRVNpXsC7wCRIza2p10XNmHWCT1VjkZjFyMMszhTHY2dH97xg+vZrpBWwN0ImSiKsO82r5Adx+UqXmP7fIFfC7pqIwI1jrGMe30GnlewSq58qITaYtFRrOURcdVjNXKGgokuAKYAHQ9f1UsTqVz0sL+10wmbg8NRRP1e8vEByp6EKgjRxgjYgZKQQaUCbVFjNtFM/8ISBJ+PmFc7Hyx+fi4oU5RLQ23zjUjUqmF3BsBAHscViV36xJmfRyqw4wGwLN5wA394fx7EZlQB3xMYPlokn8oJuFzcHUfoZQcrC1YdBqTjYrJFmMIlIYQQkAPz23BhJzb4PVBYfVjAK7BdvkKermN+RFxkWfzroJmz6zHB+L/w5tpBLheAr9objaAilLv5EDzFQHRmRALcZVCH0INABUFzpRV5dD7Bs6wGGUagVwzCAEelwOMP+ZOK1mVHocsFlMOgc42+qJD3/mGYQXPYXMZP6ul5Q2SVlu2IR/zP8PlsT+innxB/C95PVIwMq1A0NkQCfozBLBueaNaBuMoEttt5hJgwgYn89i026+0FSWcB+w/Db99n1vKJXIM+wh9Ygk0tjZFUAzMe5x/1b6hEwv78z776VjpRleatJkTRI2BBrhXqBl5YGFP5ttwPSP0nWmVs6IcCHQxu/raGX0VSOOMSZNUi5M7e3GX6Ts9smTc1ys83SsI51Krx2nlIaRvSf0Ey9isGMwnEDQRGdk3YjCTvQXK1Pch3QsCMAJl82Mv33lRLgZNxkAvJ5CPPFNWmIeQ7zgCRGHUv3SXg5VQjB94wAAvhZFBGcge1+HJMu4Z0Ujzt21HcflKK44QDxcFWjE/NxNZSCc0D8p1EOr9wLYGnRjFxZhkBQovWBLGpQwIKZCNABEnDX409vNAIBP9i1GjfMhdCYtaGBuSGWpbgz6g3h7Nx0YsY5sipgwkLlgE3c54ONnSD8csGHPfzfj3K4Q1BIhTAVsdtJiKJJQwv8yZfVrpH6AAJNsQWSLdGfDfrMOsNdhQUjKMfHjrVVvfFXSIMqZFkcdKWUA0klKMR3K+z3BxNw4CiqhVvSYdApgtitFWWoXKQPAXBgUTENFpmBaQTlgNL4saVD79mVzgAfCCbgi9Kad8tbh62c0YHd3EFazhNpiJx5b3YorEz/C+eYP8Vz6dEyro59DPeP41hu5vwBQu9h4eyb/N0uxy6YOEnyRJBcWDQzjAEuSMgDTtj7Rtob52P8Br9+qtKWadLLxsQSCIxFtMSsjB1g7aByNAwwAH78DqD5BuebM+vjonmPOTOBlf5PBbkyvLMDaZuW6E2EEcK+tHhVML/hOUoLZmsJaagg00wpJ6wDv71fuw1ak0CAxObn/v737jpOqPPsG/jvTd8rObC8sfQu9SxFhAZVqo6jRYIslURNN1EejBuU1MTGJMWrU533iq5KYvOojBl/7o8YOGgvBAgq4IE3KssCyvd7vH2dmzn3KzM6sbGN+38/Hj0w/u2fPnHPd13Vfty9HDeislkaSl8qLsa7ouP4h/PMrbXujZddWGWB3ejRo17E71QA7suZw4xFADoAd6vkp2+/CnYe+j2r4sbF9INa1j8ItFuW+sNngyClBLdRAv7apFbsOm69DLJdCyh2pVsO0NgAQ0eZJVnOAtR/a4nzjz9P+7qQA2Kc0IU+aToT6Q4jOA5N1cg4wEOmkLlCs7EG18AOePNhsCgqDHgSO6jPAISWBAFgE0FR0EnDkEfUOKaMKdxDIGITmjDZUQt9Q8hAC6I9wYNagv76LmGv7GLcfmq/LABcE4wXAW/T7IuLzp6UsqKJWZog2NfB+/8Ho074S/dEQDoDtFgHwJ+0l2IcsNDq0fRZS1Cy522HDKYPdQPjHj0yTO4R0rG8vxoTItcuLNwDDFmlv6gpYr4ZilDdKP38+qQwwS6DJYOxYda7N+vXrLR+P3D9mjHWpale9V1+nKAp+NVv7gohk8Kpqm3FYmgPsU5rgh7nJEKCVmV584iAU5wb0yy040swnSkPGb4fIA6DgqEO639iBuXoXDu7WWvsr9VVo3bMe97/xNQpRCSuNigcN8JgywAOkBkZbD+i/zL7YU43b//Zq9PZh4Ucj3KiBFxe3rUD7nNuA5c/ov9zC9tr1pbzfNqgXLbtELlqFemjb0Y63P/gQLW3aiVIOgA8iCBH+GlAMF3INwoVXK+qx+pPd+Pf+NliRl9A4Ut+iu/iLLG6vmwMMfQZYURS0pZnngwEA8rSOoAGlAcNs2shxpGRbXoJpvLx2o5ypSS8Ezn8SmP5TYPF/Wn9WRKIZYJk08hr5mY/UNCDQLGdLBiI/6MHfLpuCxy6ZjOVT1cGuT0Uxft/6PWwVRRiao10ozizRSpFmSP/WGVIOLLpHn4VRbOocQ4mxE7S8BrDdpsAdr3TUY5HpMAYF/ScDl/4PMP83sGwjStRXmQLgY5QBBtTz1IQLEg9+rT6vZp86zSesVVrSZF2Dfju+FdmmTtmRALjOOAdYqgqJNICaY/s3QpEAwuEBiiahPdY0CXmpPIsMMACMGxDS3Y5WomRYJAJifQ6gDyobjmhNk4Do9KAsvxvfiALc0PIjPNam/r5jLfujWwKqqRW7pOUWI9OyLUugPUEgb0T0prtqE7L9bn3W0ZCxtgyA5eZihp9bt15u01FtfqysZp+aATycfFPVUJoTNzj+G6+7b8RHnqvwdOu1wFt3YWDIjoChBDoSTBbb4gfAWcWT1GDXKH8UEKMbe61Nnht9yLLvykzb56g+egTfVGnXf4UhQwm09LkTbFusM8ByCXDpPGDgidrtcPDZIuz4f23TUd/chk17j+IbYf4eeLFNHfz1BLXzdWY4S/69E/ojIJdAS9PkftmiLXWFyi/VRlwRhnM5APV8bzweCscBQWlOe6IZ4LZWfadtlkATAEyfPh3BYBAVFRXYsGGD6fHVq1cDAE4/3dw50Gj+/Pmw2Wx49913ceCAPoXU1NSE559/Hna7HQsXLozxDscXb4N2ctwTDmBqmlpR2aTPAPsMX7gRkSBjVlk4IJHnS7gsymkNQU2kfOWwPU7DniM7Ub9f34ig8ctX4Wyt0y4CDKptIQAwZYCHF2hf5l/urYEIj9o2trThR3/7BAf2aHNI9knLNTRnj4Bt5vVq8JtpLi3dpVjPH2qBQ9d44pN/f6R7PFfKpEYysnabAltAH+BFliwCDE1SJPLcsSMNLbqLP7WhlYC/RTtpHxAhpIVL0iKCmTECy9AA3eDFaEX7PUXmzzZ4tUGADEUaXDBmZYbOAU79X5YDCTrGADgtQ+uMaNUhMWcYMOik6M1IBthdsxP28HzkNqHAnT1I97KyvADy0vWdRIuljraj+gXxxOVTcffZY3HtyYZGU7ITLgUuWKN1Xx61zLA8iXpRE3G4vkXfAMtpj79WpGVX7MSnahD1acayW6v+AQHDd01HTbC+KzkIr9mnrnsaZpeyZZ+3D9Ytb7RHZJvWFrYuga6FV2qCtSu83OAyu1QlNew0wBPEkfYY1SkdlEADwFhDCfTB2nCZkFUGOF4ALAeVjUcMAbAaaGT7zdleYyVMhJz9bhf6QevJg9XvWVMTLMWuBttyv4l9n6NfRlr8DLDVdBy5uZjLr58rbmSVHdz6KnDvGOC+Meo8VitCADveB3bprw1CXifOsmvL9QwSu4G3foPTxLumEugQatEvlKZfAsngEAIYUZSlDyojwr8rn0UA3OSSzmH1Vfqy6TC30oIZymf4984j0ftMJdBDZ0X/OVzZBVuMucpR/ScDJXNNdz/StgDbRCHqm1vDJdDmAPiltskAgPRM7fsgpNTAYVNwRflQ3ZJecqPUf4sSrM8+w7wt/nzg5NvM97vTzX83hePVirmIRJtg1avXaFHMABMAuFwu/PjHakOEq6++OjpPFwDuuecefPbZZygvL8fEidqyBA888ACGDRuGm2++WfdeBQUFOO+889Dc3IyrrroKra3aBeiNN96IyspKLF++HLm5KfLHJzWR2iNl8A40aSddn9IIv2KdAS5UquB3OzA+MoIcKX8CrANgQ2ffHeEvL7kphlH9vq3RQDvCVvFPXZfiNsWpC7QOK+pJutrQBXpYuImEDe1Y0fxHtD0wBdj+Dv78zjbsPtwQ7RwMAJWKtq0LRkkBbsYg0zZ+1Wz995LuceAbaBdql9SvwlOuOzDTpq4zl2Nal1edZ2rMAMudoXUlcpJaXQa42RQAB1EHW7s27/mACCEn4NYFXRPLYgSl7oA6Vy5MbrRRGV57uNXfz/QyAJ2fy2Ickc8ZrmU1rQLghb/XjbxG9mV2vVaO/Y3IR1ZIf8GkKIouywtAlwEGgGlDs7BsYhE8zhglyhGDZwI//Ry49HXgLHOGO8OnXfQeqW8xLIHUwXtPuhS67tcAA2BKHf4cbQ3wkrnWTd4yh2jTAtL7df1FpC4A3ouy/EB0ibUQtDmhu0UunmibA0C9OP8WcTLAhhJofzgb60YzvM0HkYmjmGXboD1n3HkAgMoWfWd7bbvkANi6x4Oxr0FjS3gakNUc4IQzwIf1A+LhDHC2Xz/Y6LLbYk79MP6ONu/TgsxRhUEMzvaZ5wC7/ep5Qu6HsO8LlOb69V2gTRlgi4ybHABHpqEkK9IU9F8WFU9VFcBfTlebfT5yCrD5lehDQY9DV7EVUSx2mJpgZSi1KM7xYogt9tJbtbYQBmZ61XOUUfh3ZZUBbvPIS/xVxWw8OsP2ua6iqSDo0QfAA7XBabeSwNq4hePVLLCkOS0Xf2pdDEAdQK6orDPNAY6UPwNAdq52fGYqNVg6oUjtCC4HwHKjVAAfDb1GP3AdKAQueUkdYDfOs/ekm69TCsfrp14cTTADLJc/O30xpyscrxgAx/GLX/wCU6ZMwbp161BSUoJzzz0XU6dOxfXXX4+cnBw8+uijuucfPHgQmzdvxt695i+Ee++9F0OHDsUzzzyDYcOG4Xvf+x5Gjx6N+++/HyUlJbjnnnu668fqeVI5y0G7drEgB1l+NMAnlUAbl8o5cWgWnPbwn69cAm012mwYLYt8ee1oirHMCwD7t5/oGnUBQNqB9RihaGVF1a48XYAWWQ/XuA5wlt+NnIAbp9o+wWL7WjiqNqPptV/iobfUIClfCoBPmjgGz//4JDxz5TRcc7LUZdMiAP53nXXH3YJgGipdWiA61LYXU2xf4U6H+veq78ocAhDu/ui3ygCr5oy17vipywBblEDnScF2k3DgCPzR+b8Rs0YNQIOwGI13+YEc626oleESaFtGjGyLMSuTKOPIamT+L2C+WBl7nnpiT9d+5nSlHj40oF+Llq3eIop0nVojyssMAXDudzj5uP1A/xNM3VYBcwm0fgmkDtpAjDsP+OE7usZaxgsEouPaBWuAH70HnPek9ePuAHD2Y8C47wPLHo3fY+BYMGSAPU57dD3kTKkKpkoEcGvrpRjf+L9xVctP1Zcagk7rZZCOwut2IANH8Zb7OnzkuRrPulbAqaiBRrUjGxgyG0II7GqwLiPWlVXGuai+cpYW7P3gpEHqP75LBrjhiNoxOCKaAdZ//wa9zpiVL26HLTqgAKhVWxFFGWlYecZI+DMN1VeRSgE5AN6/EVeWD0a2QwrIjT+HZQBsONd2JgCO2P6O+juJ+PIF4D9PBL55V7tvq5YlznXUw6WYpztlKTWmDHAQtRiXXou0SIMPAM2ukO45aSF1DrF1AKxmgI0DDgBgk5MW9VX6Emgpy65bEhKRDLCU/Swch2ZbEuuDF4wDskvV/8L2T/1FdIpAZBWFvSILzUIbQJGblhb1065JMlCDK8vDA/y6DLA+AHalZ6uD166A+vNd/II6EKIoWnVXhNuwsonDowbKcga4sRposuh4bVQnBcApVv4MMACOy+Px4M0338SKFSvg9Xrx7LPPYseOHbj44ouxfv16DBnSQTmlJDs7Gx9++CF+8pOfoLm5GWvWrEF1dTWuueYafPjhh8jMTKHlQ6T5CbUe7URSJ5VhedEIn6KNOG4W2pdKkVKJmaXSwaoLgC1Gm12+aDMMQF0DGAC2NsTuPuxuN88VUUQ7vufQ1n/db8sFcrU5P5GA0TgHGEJgeEE6xktNmlr2b46OeA9yakGiLViE0UVBTByYqT9BW3TX3dJqnWnIC3qwLzDSdH9/WyXcaNYFwJXhLHgwzWk6GUc6No/rH8KkEyxKmKAvnVNLoOUA+CAGubWMhLqkj2IKBkty/aixaoTlDqhf7BYiJdBK/mjrQQ9/J9cENZb8SvvXVD4991fq/305ulHafOUQSqCdsDeL/qagHwBmFOdET/4DMr0oSI+RTfmOMrxyCbR+DnDMBliygjHAhc8CV74PXLku+TmLRH2Zza4GNlZNmCJKTgXOeqh7msAZMsAAMKIwHYBABrRgLbK83GFpvqopA+yJNMHSl0D7XHacZV8brWgZYNPmFr+dNgew2VFRWYcDzQl8Z8UogQaAa+aUYOXpI/Dg+RMwbUj4uzctw1x6HmtNcsCiBFrOAGtNsGQZMeb/Amp1jk/6XtwjNVkqyvCivDQHdy6frX9R5GeU+laguQZDHAcRlOedmppgWUwxkecAAwkGwDGmsbS3Altf026/9Rug1VBZJwVB2RbZXwBIb682ZYDdSivGO7+J3t4rMnEooB+wzswJ/63mjtAHcoo92lvDqgTaGZAGoo0Z4EhFBoCBNm3+rtOuIMfdrlYBRDe8H6o95iqxFmFxLIcGqhUeigIs/T/A8DOAeb9By/Alpqe2wY71jnEA1ITHc21q01Wfy45hQ7RrNZfShkGB8PlWCoCrDStfBDxO9bx68y51sE2uAjBek3iC+vvyR6vN4Py5yS+FlMINsAAGwB1KS0vDHXfcga+//hpNTU3Yu3cvHnvsMRQVmTs9rly5EkIIrFq1yvK9MjMzcf/992Pnzp1oamrCzp07cd999yEUCnXtD9FbtLcDW/5HXQw9TJ7DKZdhBZQGXROsrYYAuDxmAKwfWQOgfqGFO+vVpxVgg1C/XPbUtFvPcYxjqk1rlrWzLQs44TL1hO0J4mmhlpvp5gCLNqC5DsPzAxitaGso+tuq4QmPnI4PSSeWWGvUGjLArcKG3cJ6xC4v4MauvJPxu5ZzsbptZrQhFqBmZfNhXQJtLBuuUkIoykjDQ9+fAF/eYHzVbs621hlLoKXRe5/ShHFurRpiv2EN4AhFUdDusShHjxEAtwh7tMw8LzcPOP0+mC4AOpsBNl6QyJ/ff4q6vwvHAxc9r5Uh2WxqyVJYoVKFMkU7YW8VAywzwEGvE49dfAKumDkEf75wojpS3gVCaXIGuEUXAPs6ygDL8kboL/CIqPvJTbDCDXxGFQYRQIMue2ecp6ooiJY2R/ismmA118LrdqDcZr1e6z/a1Gze2q8P4igSqFqJEwCnuey4ePpgLBpToA34Wq0F3OkmWNYZYNMawAbGTHlEdD12Y+Y2kuV2B/Tn6l0fAdIUoI5LoBVzv49EAmDj+8q+ekH9f0sjcOBL8+NSEJQlrANgX9N+uJVW0/0ljVpX56/bC3HQpQ828wvC18k2Q3PGnLLo4IRVCbQ3JAVjtQf0wZyUTS5AFVxowffsb+Bl189he12aM6vYAH8ear3m65ZdVtdOheO0fxeMBc59HJh2Fbxu67+FR/NuwaZJv8Ky5tujiYSQ1wXFmwkhX4/UV6lzrmPMAQbUaWvqNivmRpLGaReeoD5A7h/OPtvs+uvHRBphyQGw1RSv4xwDYOoeLQ3Ao/OA/3uObgSyNaB9OUXmdQJAoeOorglWlU8rCxpkr0J/qbNyhyXQALD4z8CFz2HjmS+jCerJb291o/WyFga60XHJlsYMiMwhwA1bgeu+wkct6omrxlDeos4D9mG0tGA6oAZKg7N9yG6XOjvGCoDTC3Vrsu4SOWiNsYpZftCDgC8ND7WdiRtafoR92mJPKFQOor9N+9KLBNFWJdBXn34S3rphFgpDaQh4HPhn+3jTZ5lKoNMy0GrXLqbGK1rWOxJszx9l/p270y0GIlx+ywBY/TtRTxJFGWnA6GXAGX/SP8k4ip4oT0ibx+zy60vaFAVY9AfgirfMJV3SPOBByj5daZajYCTcDuvs0aRBmbhl4XAMy4+T4fiO5G6nagCsXcikJZIBJqLewyIDPLIwHZnSGrFtQtH3ooAa/BoH2QJWyyA11SLd3oKpNi24iXTbf6p1Ft4/mg0hhBoAC4sBZ6MYc4DjMs4D7nQTrPAcYMMAZLwMMCAtyWQQXZ/dOHAu90WQzxlyqTFg/jlcfnWJvohgUXSbY77GSry+DF+/rga/lV9qc4NlUhAUbK0yPw7AcdTchAoAco78O/rvClGI3Yr++mVgf2kgo1SqHJKaYlmVQAeypGuEys367R44De2Kun/sikCJshv/y/EXFIsdwEcPa8/z5wF2BxoC5gB4v8iEcBh+z4Xm6xsg9jkyIzMX7eMvxBYpOZPhcwI2OxR5Pm9dlVqV0K6ddxts+uvUWAMu6gYYkgPudGDCRcDw04GyhcBJP9Mek6ZjoXq3Ot/7kP66U0e3BjADYKKuse1tYPeH+vvGL4cnXSt1qZTW1stur9I1PWrP0UpRs8QhoFWbd9JhCTSgzo0cUo6cbO0gr6xtQrvVshYGT7eV6+bDRmxvzVTX9bU70eZIQ3OrWtLcAgfa5S/XxmqM9h5GumEOTaFShTPH5kOpkeaMp5vLdQCoo3vS8hA7LLoQRuSme3Ql4s1e7WQyUDmAAmgnuchIaKbPZfoCTMsshCM8z9ppt+E92wmmzzI1wVIUHHVp2deyVm19v2njRuLNG2Zh2lBzsJueYTEi6/arWVbDHJhKaV9EL0gmXAAsfQQonADMWWHZNTshiqK+z7jvA2evij+yLpMGLmbaPov+7TYJJ0qG9ezyZnK3U2MJdKwLPSLqpeRB28ZqoLkeIwrTkWkofxaGyzurQMO6C3QN8g6vhyfcNKhWeDC76R6MaXwYN7VegabWdhysbcYH26pMcxktdaaxznfJALdaBMB+YwAcPwNsVZab4XVq2Uq7Ux+YyAPveTECYEca4DBUAimKPgucZTFwm1AAHAQmXBh+T5u6dKIzfC3UXAtsfxvY97n2fLlUVgqA/S3atcGWdu1aRGlrtvxY5wHtPb8W/fCv6pDu8cEDpeBzzLnA7FuBEy4Hyn8evdvqdx0cOkkbGJCDX18O4Amixa+db+faP7ZucBU+JzcHBpkeqobPnFktGGd+D8SeJtQvI01tbiWJ/l3JTarqD+qyvwAQDOmvgdLT4lRimTLA6ep95/4NOO8J/WfJSyF98hjwpwnA/eOBijes31sOjhNIBh1vGABT9zgsHWiZQ4FLXgbOeABZ0twcOchU5NbsAE6eORPt4ayfDUJf3tFRF2hJflA70QsBNLg7HvX6UgzAVc3XoBX6L8I9Igc7wmvQyZ11AehPWo3VGNS0xfS+hcpBLC5x6UYGY2aAAV1p1fY4AXB+ugezSnNw99ljcdP8YRg4RJuXM8m2WTewEOnCneF1meeAGObR7nAPQ5XQjzTLGeCjja1obWtHlUN7n8xWbY5OKKc/Bmdb7x+71VwoV0C9QJAajQHaGsAep00/t2v0MuCKN4GZN1h+RsIGTFHn85Wc2vFzI6T5wXNs2qj4VtEPJ5V1cj7yMaLLADe0oF5qgpXmTKIEmoh6ni8XuikftfsQ8DgxLF0bFD4szBlBqyyT5TrAzTXI2a8FbuvaR6IFDl3Z5mub9uNoYys+bpfmfGbFWK7NFSc7GYtxLeC4GWApEDVmgB2RAFgf8AY7yABbleVGB1sj5MBVnqOcLy2FJE33ijmYKp/7rCqXjPOGrbgDwLxfAwt+Dyz/B1B8ClB8svb4Vy/oA+DiU7R/t9RFkwjeJi0j+JWwaEZmoEjl3RWiEK8dyo4uvVWpZMHtkc73NhtQfiOw6G5dwyV1KT7taXabgpzMLGDILPMHhquzbNL5doHtQ/PzgOi1VFvQ3FW8Bl4opk7K4yzfxmm3wWk3T0/qF0pDyOuEx6mFUdEAWG6mWWcIgB1pyMvS/z0bO6LrWDXBikVOoHwbuQ4RwDt3Wz4dez/V/i1XLqQIBsDUPeSAdfAMtQRGUZAljcwehQ9NwuKLQLFhTPFAKPIIlbwunJwBdsYfkfY47bqAoKJBPzpdazOfrHeJXHwshuGOluW6+3eIXOyoUrO6clmp+kFyAHwEjn0bTO87Pr0WA51HtDvc6fFLmYZqJ7S328fGfNrgbC8URcGyiUW4ctZQ2KVOyVOkOcyH7FnRcvBMv0udkxMp7Q0NNHVg9nvdeNNQBl1nWB/4aGMr9iFGN8F4I4zGMh9A+10YtiNSKVCU4Y2/hm13GnFm9J/yAMN220CM7vcdungeA6Yu0MwAE/Vddoc++KpRBxlHBLVz0CGYzyN+iwywP1YJ9J63ozetzjWrP1F7HHwlBuCO0J3AwruBBXdZb29Xl0DLAWL9IctlkPxuB1wOi0Al1ltaLD139iRD3xddACxdR8QKJGIFslL/CLn7sPa6BM4fnvC1w5QrgKHhBl3DTtMe3/wy8O0G7faQWdAPoqhZYHu9lg3e2t7PVEUQT0V7IXaLXNzV+j1saB+CNQU/Teh1Npuim5uen+5Ru3BbNVsMr7HtyNYGCkptMZo9RYJBi2qwOptfX8aeMcj6GiQszeLvoV9GGhRFQWFQO3YyfZEMsNzF2hAAe4Lon6G/boobAFtlgGMJFlnfv2MtcHCr/r66g/rlkgpiX1MerxgAU/eQ29hLB2mWTz4RKZalxupi8AoUeVRYDoDlE16chhsR+VK33U8O67+I3mgZZXx6tEz4r21z8b9bT0eTcOLvrSdjH7KiAXCDFFQoCqDo5iVV608+YROCddE5XADiZ38BYPLl+Gr6H3FJ83/gLcNFyZ/OG4+Rhen48exiFOcaLn50a/NqJU57Fa1UOTNyQXDu34Gz/wJc9rpa5iVJ9zjxzzZ9AKwrnYMaYO1qj9HR3Li8g8wyAA7vS8M84Mrw+sRFhpNIj8ofbXkCackerltSoyfI891a2gQqa7RMUYfLIBFR72MxD3iKW6uyshmzW7AugY52gZa/x+sPwnVY693wdrt5Csf6nUe09xg5F5h8eezpO11dAi2fa+WmPkB0QFxRFORIg+0dzQEOpukfv2T6IFww1RCUy79jeeA62N862I2VAZ7yQ/X52aXA2HPNj3d2DnDpXK3Uua5SPwWtcLw+AAz/3pRarWJrHzLR4o6xzQZHRRoOhM/Lf247HWc1/wrNxYmvFiCXQUfLikvnm58Y/rtQEpniFN4H9swBukagANBgD+h//hjlzxFW58nIdhaEtGMnmlyRM8D1VaYAeECmPlFjNTgVZcwAx/t7iHUMAsD6v+pvy9lfXw5LoIm6jNzGXgrIsgylSZEvUZ1IUCuPCh/R1uNNpgQa0JdBf3hQ//nvGE72bbBhr4h8USq4q/U8lDX9Bbe2XgoA2HkoHABLJdBpTjsU+Uuq4bD+yyZskPOQftH2jgJguxNNw5aEs7BaUOV12XH62EK8eM0M3DDPYt1c6fct+6ZN+5LO8IW/uD3pwMizLBsipKc58W67NrrdIFy6+biAulD8thaLYHbAiUD/yTF/NNMoJ6Dtd0MAHCmBdvRwYGky/gLTXVmDe35U1Xgx9620rEdCyyARUe8iX6zW7APW/Qmlu56O3lUyxrwck1UJdKQCRF6BQVbRXoDdIv40oVmR9cxjVS91KgOcTAAsnW9a6vSPSQ2lhuRo2zEoK/42zSjRzo2XTB+E204bYa42Kluo/btkrvZvRVHPoUaxfoahs9VGmld/aD0QnGgJtFFaBjDoJOvn543Un+MjSyHVaM0bDyKkD/Lj2CYKYVyJoTQv8dJ3OQCMBpTpBWpPD1kw/HeRSACcrZbk+zwefCv0U6wabAGtezLQ4dJ+xvOkTdGuI6cXa7+jyYPD1zFycF1nDoDlJq5+tyP+ILnx2iheCXQwTgC84f8CrdJcbvmatGCsuft0CuDwP3UPuQRaCsgyfYYA2CoDHBlBlk+KsUqgEzjZFkgB8KbWAkSm9la0F+DLdv2Jt8aVi7bG2EFCZA6w3FgozWnXn+z2rAeaa4wvhbvuW317/44CYFiPFBoHEUxilMV83aJ9SRv3g+XbpDlRCy8ub74Oy+2v45m2Gai3yABvbghBN11asQELfxf/CzZuCbQhAxwOgHVLYfUGo5ai9eWb4RDavKjSsd2wLmgHHHYbAh4HahrVEkkGwER9nLzM2/sP6ksZc4YjWP5juNd+gKZwY0bAOgOc5XNjYJYXh6vqTI8B8afaAOp5Y2xRSL0R68K8M3OAPelqM6n9n6vva1yDXffcUOzHpAD4pvnDAHyFEYXpWqASw+ljCpHtd8PlsGHSwAzrqTZjzlXn7Lr9pj4VmP5TYP3j+gZO8bbTEef8m1AGOMbvfthpwLa39PdlDlHPrf5c4EC403ftAbUpipQB/sH8aXB9vQ44ZO5fYlQhzNcuZfmJ73c5A1woN5YqWwh8u167HS6Btvp7EFCgnLwC+OcdaqAcHpTwuh3YJvIwANr85kZnQO2kbHeqzbZGnxN3+4ydoPPTPXCGG4T+YPpg5AY8yPQ5tbWs4zXB8gQxqjAImwK0C6A4t4MKCVMGOF4AbJHssDnUPjP1B4EtL2vTtYwBcApiAExdr6VRt9i6HJAZuzPGLIEGEgyAOy63ypNKoHeIfPyy5fuYbduAB9vOMq2tW5vWDzhqfAdNNAMsB8AuQwAsnYDabG7Y28MlqNV79AMD8cpXwmJdxMQVIwCWf9bMDuZEAdpada+1T8Jr7ZOi92f7XThYq44s7jnSgO2tmfoAeMJFHTdYMAbATq/a+RpQT9RpmUDDIQBAbr8hWBQqwOIJMea79BRvJqr6n4q8nS8BAI4IHwr6dbIb9TGW4XVpAXC1tgwZS6CJ+iA5AywHvxmDgAufheLNQEHQg2+qtOlBVucOu03BIxedgFe/2AO8Y/6YJ9tmx92M8tIcLXvl8kPNAuobWHYqAwwAZz+mZq1K5sa/6I8VINocumk8o/oF8filU6yfa3ypTdFl9iwpCtDfvDICADVDOXoZ8NlT0nZ2cqm777IMUtlC4CVDU8jIuVhuell7AGiq0U0nmzF+FLDXojmlha+F/trF47Shv7FpWBw50iD+QLk8uGwB8OavtNuRAE9eazkiczAw43r1esPl19YZdjmwU+QB+CL61GZHQB10mHhxQttnHCjuJ02/8jjtWDbRcC1iaoJ1RLvtCWJAlhd3nz0W7209iEtndHCNYFpyK8FqiIiRS4DP/1v997o/AcNOVxuSMQBmCTR1AznLCUWX6TQ2ozCW1AJIIAMszwHu+EtXzgADwCNti7C85Va83z4S1fDpGoI0W6whJztY24zaptboXGAgnE2VR3ul4N9eInVfbGsC9n6m3U4gAxywWJTd2OHSxJNu+aW5SyptCyUSAKdZz5sqkJpAbNlfg29FNna1q8G18OUCJ99m+Tod4yinPJChKGr3SJsTGDILK6+8CA9+f4Jlp86ell1+ZfTfrf2n95qyolCMOW9sgkXUB1kt32dzqB2Aw4/lG85zsRrtFOf6cdWcMlMDybeVSbo1Tq2mnMweJgVRNpt1INaZOcCAWsJ6yu3AwGnxn2d3WGeZO2iI2eVOuk5/O8ZSQh0yBsCKxWV7rCA52M9cRhwJgI0l0FL2F4pdDeK85kGARotGpfuc+uuk0ryAac3peH4wfTCyfC6M7hfE6WOl66C8kVqpcsYgrSGmy4fmNH1pvpIX7t/iy44Gv4CakNhhKONvcSQ3GJFmGCg2Ln9komuCZS6BBoAlE4pwz7njMLKwgwGOZJpgKYp+iauJlwCTfqDd3v0RsH6VulyYvDILA2CiLiI3wAoU6EZlXQ5bNLMIAEedMZbDAfQBcM1ebS3gJOcAyxngCJ/Ljld/NhOXzxgCm9Q1uS04wPTcDK9T11FyZ1U91u88HL09tigU+4Q0eKY+GD2orZOrW8Q8Bo/TZroQ6TADDFhmgSNBasDQITOWWBdQ8oDC1v21aIcN57Xcij/aLoZy6avW83uNTIu9Gy5opl4J3LwLuPD/qRdavZR96ExgycPAiT9B9jn39fTmRMUa4GAGmKgPsmpYM2qpbh1ZuTstYJ0B1pGbSQJ40n227naJYU6nTQFmlhgCJKtS3M6UQCfLqsGUs4MgpavlDgNGnKXdHlzeufcxXkv4883BfbzVI4Yt0t/OswiAaw/o5v/Cn6ueZy3mAAvjElUADqcN0t1OZv4vAJxYnI0Pbz0Fz//kJP26wIoCnP8UcM5fgcve0F07OnMMS0bFqDJzOWz4VtEfL63xsqgWfHEywJa8hgC44Yh2O5GMviwtQxuIcHqtB79kkYRDej9gzi/UAST57/C1lcDXr+u3x9h1PUX03itJOn7IZb4hc0ZVLoNuSbOY1xkZQQ4W6Uc/I+8rj64lcLItCJq/vIpz/SjNC+DWRSPgHaLN2xT9Jpmem+V369rYbztYqwuAJwwMxf6SKxxvXZJscwBF5s8yUhTFNA+4wznAgOn33iLs2Av1Szojgfm/QOzF2uU5O1/uVevFd4tcvB5allizCsAiALbIGvT0BU2ixpwDzP1VQhn97hKr6ynnABP1QVYXwVOv0t2Uu9MCCQTABt+kjdTdHlWoD24nDMgwD6xZZac6WwKdDKv5tQ7zQHe3O+N+YMqVwOxfAMNP79x7GK8lfNkWZbFxrnuMnxurBFrOAPvDc8wtMsBp2YZzus2BpoA+gCpLMgAGELsRVFqGOm/Vp/+ZlQzDdkQywBYqnfoAuMWZXBBqnAPcL9RBdYH8e2uu1XcnTzYAttmBsx5SpwKc8af4+xoApl8LXPsp8JNPtAGMBb/VEi9N1cAzl2rPT9EGWAADYOoOugZY5uBPbsAk/Hmmx6MnULtTP0/2yA51fnF4biiAjkfHoF8GKUI3uj37F8DUq4EFv4OjeI7l9o6Qylae2/AttlVq85AnDMiw/pJTbOrJxyoAHjQj9jIJBsYLmSx/8hngb0UW2sOHf8IBsEUG2GW3YYR0YXS0UVuLMieQwHZFOD36Ue3uyBqkkFCM8nUGwER9kN9wniscDxSO092Vb8wAW0yf0ZEDpQufM2W9CkNpuoE0XflzhPHi3OYAHEmcBzrL6pza0yXQgHodsOAuoPw/TMsKJszlU0uSI/y5FgPGccpis0u1Jk9jztU6BRtLoOUMcOQ6ymdRkWfMAGcOQdCv/12XJtEAq9OMjbDyYwfAB1z9cUiog+r7RQitnthr/lqJNwfYkjFzvneD9FgnmneWzgO+/7Q6rzwRGYP0CYNAvjqdwEqKlj8DDICpO+iWQDKfqOQMpj3dorRLng9qnAdcIy0jBCWhADg9zWFa2Lw0T/qMQB4w/9fAlB8iy28OljO9LpwyXDt5vLpJGznN8rnUNd6sAuCc4eocZauTtbFMKQ6/4UKmwznAgOkzd+kaYCV2YraaA5zmsmPCgJDl83OTCYAB/Um9o1FOSgpLoImOI74c/Vy/aT82PaUwmGQGeOHd6rzVs/8CDCnXl6JCPU9PGawGRC67DQtHW5yrjYGYy9c92SWr7GpfqRjqiKLoryd8OcllgBUFWPowcON2YMmftfuNJdC1+8yPWWSATeWy2aXINFyDdCYDnDS5us0e254AACDKSURBVMwTjLncIwA4PV5c1fJTPNE6G1c3XwO3K7FB/wi3w5gB7uBvy+HWD+LL2XXDqhbdZuIlaldwow7WQD6eMQCmrifPAbb4kpIzsoHMfHOTB/nL3RgAy+vo+vMSGmVVFMXUIKQk1/oLOz3NYZpzm+l3YVZprmXJzvgB4SUTrALgyAi9VQAsrynYAVMGOKE5wPrfu9wA67tkgL0uO4Zk+y0vrpLKAAP6RlidbZxClqxKoB02xbIagoh6ObtDLXWEol7Ujlxieopxqo/VOsD6J4SzROE1bI0N8jK8Lvx6yWj8YtFw/O2yKRicbVHabAzEuquSZ/jp5pLn3pABPlZ0AbBFCXQiHaaNvTjkaruWeqBqm/RYJANsFQAb+qJklyJLuoZI9ziQl94NWf/B5YAz/Dc44qy4Ay1elwMftI/Aza2X42MxDB5ncpVPNY0tutsdBsCAdfYcAHJKk/rsY8ZmA879G3D2KnX5LkD9Oyo+uWe2pxfg8D91vRhrAEd8b/IAvPj5PthtwDmTBwFf5upHI2NlgA/v0AfAScy5zE/3YPtBrWy5JM864FIUBRk+FyprmqL3ZflcCHqdmDI4E+sqqnTPnzAwpP7DMgAeb/4ZIvfHW8DcIGAxMt+huBngzs8BTnPZYbMpGNc/hHe3HtQ9lpNIabbuzULavxNYzooSZ5UBvvjEQQgmmP0nol7m5NuAmf8RM9NpXO0g2TnAxuqQLJ8LmT4XLpsRb01eiwxwd/Ckq0vmbFyj3ec8jgb3jBngVkNH6Xgl0LF4s9RkgwivFb3vc+2xQOw5wPBmqefnSPPR7FJk12vn+tK8gPW6yceaPwe4cq26lvFQ81Q13VMN10zGOb0dOVSnD4ATer03Czj8jf6+9KKerW5TFGDkYnXQbO+natM8q6WTUgQzwNS1hOhwDvDwgnS8f/McrL1pDobk+LUv3wh3rAD4G/0SS8kEwNLFgddlN3XMlGUZMqSRpZtOGW6erzxhQPjLxKopRyQANv4Okih/BqzmACcSAOsHHnZLGWBj+VIssTLAgJr5NsoJJHkBoiuBZgB8LBmXQZo4MAM3LeihUiwiOjbilPmGvE6cMEj9Ti3O9SeWtZIY5wAnVClkDMS683s8Ms81or3V+nl9kbzubVZxciXQsdjs+veplpaWjGSArVZw8KSr84oj+k3AglH5CKY5oSjAhScOMr+mq2QOVq+fOih3N87h9SSw6kW81yf2IovBg9xecs61O9Wmqykc/ALMAFNXq6tU17uNsCr/BeC0S19IxkZYcjZQbnxwaBtwdK92Oz3xLKocAJfk+uOuWZdpOPFHAs5TR+Thjhc2Re+32xSMKQqP1BpHwm0OdU07wJwFt5qXEYexC3RCGdxAvroN4YuCzmSArTIIkbnU4/uHTI8lXQKdPxr48jn137kjknstxTU0RzuGsnwuPHj+BP0xR0THFUVR8OjFJ+D9iipMGZKV1LqsAMxzgDsTAHdnJU/xKfrbO97vvs/uauU3qs0+M4cApfP1lW92d+cbjfnz1Gs0o0gvFbtTHcxvPKI95g6o88XfuwcYMgvIKUMugPdvnoPaplbkJjvw3Q2Mf8vuJEugrzm5BM99qv7Of3ZKgiXMVuXjPTX/lywxAKauJc//dacn1unYGADLo5uRuQuAekI4oAWgyWSAJ0gZy2lDLb6oJMYAOJIB7p/pxbD8AL7aVwMAGF4Q0MrG7E51fkpLuMw6d7g2ShnsBww9Gaj4J1C6IOkvRXkuV4bXCUcigYzNDoxaBnz2JCraC/CZ0AYSEp0D7LDb4Hc7UNukjaxHFogfdywC4Ck/VMuqXH51TUs6ZvpnenHPOWPxwbYqXDZjiGkOPBEdfwIeJ+aO7LgxpBVj0BCrkZ6OqQS6GwNgh0tdTeGbd9Xbky/vvs/uankjgYue127LmdnvUlIbqyOxfA3myzYEwEE1EP/e33Uv8bocvbaponE+u7EJakeKc/14+doZ2H24AeWlCXZxNmbpASCnLKnPpa7VO/9a6fjRQfmzJWMnZ/kk6s/Vzz/Z9aH2WBIZ4FOG5+JXZ43CobpmXDJ9UNznGke+5YB4waiCaAA83RhIe4JaAGzstPf91WoGO3NI0l0y5fksCS2BFHHWf2Jt9lL84KU6tEE7ARgD/HjSPfoA2Bs+kWT4XBic7dPNq046APYEgVPvSO41lLAlE4qwZEKCxyARpTS57DPgccCVSNloT5ZAA8CyR4EnzwdaG9Wut8cruROz1coZibJadtKRpr/fmw1Ufa3d7oMrNPgMgXmyTbAAdare8IIk5lozA9zrMQCmrtXBEkiWTBlg6SSqKGrQuO8z9bZcXp3EiUBRFCyfOrDjJwLINHRZlgPGK2YOwb6jjWhubceVs4bqX5gW0pZpisz/jbDZgOzihLdXFpSWI0qoLE36zPaC8WjCh7q7MxIsgQbUpZC+rW6M3pYvksb3D0UDYK/Lbmo8QUREfYOcAU54kNTUBbqbmmBF+HOBy17v3s/sCf0mAhMuAr55D5j9i86/j98im3nCpWo2PUIO5Bwe/WN9hDEz7XF2w/QfqwxwdoLl09QteIVKXetYZ4ABfQAsS6IEOhnGJlHyxUCay47fLBlt/cJhp6kl2u5g0vN84zlleB7ufPFLNLS04azxiWe9AeulMJLLAOtfL3dDHD8ghH/8W21Klp1sB2giIuo1+mdoywhZLnlkpSdLoFOJogBn3P/d38dYAp05FJh9q/4+OZDrTLfpXuC7lkB3irEJVqAgsSmA1G0YAFPXam3Qmi/FWahcx28IgI2jylmGTGtEoGsCYDnL6nPZEy+fmX0LUDJX7eBoNdLaSflBDz64+WRU1TWpXbOTYGxkpSj6jHJHjEshyRngU0fk466Xv0JdcxtOHp5rfCkREfURU4dk4vIZg/HVvhrcMDfBuYumDDAD4F4tYKiaO+shwGVYP1nOAPfB8mfAPJ+9MyXQyX+oIQBm+XOvwwCYutbp9wGL7gFq9pkXqo9FzuQqdvOXbqZFAOzN6rJ1/wZkaieEogxvnGcaKArQ/4Qu2CIg6HV2ag1XYwAcSnPCnkR3UHMGWHu//KAHr/x0Jr6urMWM4viNxYiIqPdSFAW3LkqyG39PzwGm5BSfAvhygboDwKxbgAFTzc+RM5nGDH8fYVoGqVsywIYSaAbAvQ4DYOp6Nrva+ThRwX7qYt0b1wCTLjG3+LfKAHdR+TMAjCxMx8UnDsLarw/ipgV9u4ufMYBNtAN09PWGbLGxlKh/phf9M5MYJCAiouODJ6i/zQxw7+bNBH7yMVB/SF1T10rucO3ffXQOq7kJVg/MAWYH6F6HATD1TmevUjPHVguxy2sBRyTRATpZiqJg5Rkju+z9u5PbYYPTrqClTQBIfA3giHRP7BJoIiJKYT3dBIuS5wmaBy5kQ2apjbaqtgKzbu62zTqWeqQE2h1Qqx5bw01DGQD3OgyAqfeyCn4BtXGDKwA012j3dWEG+HiiKAoCHicO1TUDOAYZYAbAREQEqNVadre2OkMfnTNKEkUByv+jp7fiO+mRJliKAow5F1j/FyB3BFDUNdPhqPO6oQ6A6BhTFCDLkAVmAJwweR5w0hlgQwDMDDAREUXJ2UQGwNQLmJdB6qbrltPvA676ALjibcCefM8W6loMgKlvMjbC6sIS6OONLgD2J1sCzQCYiIhiGL1M/X9wANBvUs9uCxEAv6kEuptCH0VR51D3wbWTUwFLoKlvMjbCMrbzp5gCbi2ITT4DrP/KSHPyK4SIiMLm/RoYex6QXcILf+oVsvwu5Kd7sO9oI/pnpiHgYTaWGABTX2VshMUMcMKmF2fh/W1VAIATi7M6eLYeM8BERBSTogAFY3p6K4iinHYb/s9Fk/DyF3tx2pjCpJZ+pOMXA2Dqm0wl0MwAJ+qKmUMxKNuHgmAaRhbG6f5oIcg5wERERNSHjOoXxKh+yV3v0PGNATD1Tfmj1G7QdZVAwTg220iCy2HDaWM61zTMmAHutmYSRERERETHAANg6ptcPuDC54CKfwIjzurprUkZAY8DQ7J92HawDjkBN/LSPT29SURERERECWMATH1X3gj1P+o2NpuC/7pgIp779FvMG5kPl4ON5ImIiIio72AATERJKckL4Pq5ZT29GURERERESWP6hoiIiIiIiFICA2AiIiIiIiJKCQyAiYiIiIiIKCUwACYiIiIiIqKUwACYiIiIiIiIUgIDYCIiIiIiIkoJDICJiIiIiIgoJShCCNHTG0HHTiAQQEtLC4YOHdrTm0JERERERJS0iooKOJ1O1NTUHPP3Zgb4OOPz+eB0Ont6M3QqKipQUVHR05tBncT917dx//Vt3H99G/df38b917dx//VtTqcTPp+vS96bGWDqciNHjgQAbNy4sYe3hDqD+69v4/7r27j/+jbuv76N+69v4/6jWJgBJiIiIiIiopTAAJiIiIiIiIhSAgNgIiIiIiIiSgkMgImIiIiIiCglMAAmIiIiIiKilMAu0ERERERERJQSmAEmIiIiIiKilMAAmIiIiIiIiFICA2AiIiIiIiJKCQyAiYiIiIiIKCUwACYiIiIiIqKUwACYiIiIiIiIUgIDYOoyDQ0NuO2221BaWgqPx4PCwkL84Ac/wJ49e3p60wjArFmzoChKzP9eeeUVy9etWrUKkydPht/vR2ZmJhYuXIh169Z189anjk8++QR33XUXlixZgqKiouj+6Uhn9tPatWuxcOFCZGZmwu/3Y/LkyfjrX/96rH6UlJTs/lu5cmXc4/LnP/95zNdy/x1b9fX1ePbZZ3HppZeirKwMHo8HPp8PY8eOxR133IHa2tqYr+Xx1/M6s/94/PUu99xzD5YsWYKSkhIEg0G43W4MHDgQF154IT7//POYr+PxRx0SRF2goaFBTJ06VQAQBQUF4pxzzhGTJ08WAEROTo6oqKjo6U1MeeXl5QKAWLp0qbjoootM/3322Wem11x77bUCgEhLSxNnnnmmmDdvnnA4HMJut4s1a9Z0/w+RAs4880wBwPRfPJ3ZT6tXrxZ2u10oiiLKy8vF0qVLRSgUEgDE9ddf3wU/WWpIdv/dfvvtAoCYPn265XH53//935av4/479h5++OHo/ho+fLg4++yzxbx580QgEBAAxLBhw8T+/ftNr+Px1zt0Zv/x+OtdsrKyhMfjEZMnTxaLFy8WixcvFqWlpQKAcDqd4vnnnze9hscfJYIBMHWJW2+9VQAQ06ZNEzU1NdH7//CHPwgAory8vOc2joQQWgC8ffv2hJ7/2muvCQAiKytLbNmyJXr/unXrhMvlEqFQSBw+fLhrNjaF3XXXXWLFihXiueeeE3v37hVutztuANWZ/VRVVSXS09MFAPHMM89E79+3b58oLi4WAMSbb755rH+0lJDs/otcgD/22GMJfwb3X9dYtWqVuOKKK8SmTZt093/77bdi/PjxAoA477zzdI/x+Os9OrP/ePz1Lu+9955oaGgw3f/ggw8KACIvL0+0tLRE7+fxR4liAEzHXFNTkwgGgwKAWL9+venxMWPGCADi448/7oGto4hkA+AFCxYIAOKPf/yj6bFrrrlGABB33333sd1IMukogOrMfvrtb38rAIgzzzzT9Jp//OMfAoA47bTTvuumk+h4/3XmApz7r/utW7dOABBut1s0NTVF7+fx1zfE2n88/vqOoUOHCgDi008/jd7H448SxTnAdMytXbsW1dXVGDp0KMaPH296fNmyZQCA559/vrs3jTqpoaEBb7zxBgBt/8m4T3uHzu6nF198MeZrFi1aBI/Hg9dffx2NjY3HepPpGOD+635jx44FADQ1NaGqqgoAj7++xGr/dRb3X89wOp0AAJfLBYDHHyXH0dMbQMefTz/9FAAwYcIEy8cj93/22Wfdtk0U2yOPPIKqqirYbDaUlpbirLPOwoABA3TP2bx5M5qampCTk4OioiLTe3Cf9g6d3U/xjlmXy4VRo0bh448/xpYtWzBmzJgu2HIyeuONN7BhwwY0NjaiqKgICxYswMSJEy2fy/3X/bZt2wZAvQjPzMwEwOOvL7HafzIef73b448/js2bN6OkpAQlJSUAePxRchgA0zG3c+dOALD8ApLv37FjR7dtE8X2q1/9Snf7hhtuwIoVK7BixYrofR3tU5/Ph1AohMOHD6OmpgaBQKDrNphi6sx+Onr0KKqrq+O+rqioCB9//DF27NjBC4Bu8vjjj+tur1ixAkuXLsWqVavg9/uj93P/9Yz77rsPADB//ny43W4APP76Eqv9J+Px17v8/ve/x8aNG1FXV4cvv/wSGzduRGFhIZ544gnY7XYAPP4oOSyBpmMusrSA1+u1fNzn8wEAampqum2byGzmzJl4/PHHUVFRgfr6emzevBl33nknHA4HbrvttugFAtDxPgW4X3uDzuwneSkQHrM9r7i4GHfffTc2btyI2tpa7Nq1C3//+9/Rr18/PPPMM7jgggt0z+f+634vvfQSHnnkETidTvzyl7+M3s/jr2+Itf8AHn+91f/8z//gL3/5C1avXo2NGzdi4MCBeOKJJ3RZeR5/lAwGwEQp6o477sDy5csxZMgQpKWlobS0FLfccgueffZZAOp6iA0NDT27kUQpZvny5bj++usxYsQI+Hw+FBUV4fzzz8dHH32ErKwsPPvss/jggw96ejNT1ldffYXly5dDCIHf//730bmk1Dd0tP94/PVOr7/+OoQQOHz4MN555x2UlJSgvLwcd955Z09vGvVRDIDpmIuUB9XX11s+XldXBwAsk+2l5s6di0mTJuHIkSP417/+BaDjfQpwv/YGndlPcjkfj9neq6CgAJdccgkA4JVXXonez/3Xffbs2YP58+fj8OHDuO6663DttdfqHufx17t1tP/i4fHXO4RCIcyYMQMvvfQSJk6ciBUrVuCjjz4CwOOPksMAmI65SAOl3bt3Wz4euX/gwIHdtk2UnEhTib179wLoeJ/W1dXhyJEjyMjI4EmiB3VmP6WnpyMYDMZ9HY/Z3sF4XALcf93l0KFDmDt3Lnbs2IFLLrkEd999t+k5PP56r0T2X0d4/PUeTqcT5557LoQQ0a7OPP4oGQyA6ZiLlBStX7/e8vHI/Wwm0HsdPnwYgDb3paysDG63G5WVldizZ4/p+dynvUNn91O8Y7alpQVffPEFPB4PSktLu2CrKVHG4zKC+69r1dbWYsGCBdi0aROWLFmChx9+GIqimJ7H4693SnT/dYTHX++SnZ0NAKisrATA44+SwwCYjrnp06cjGAyioqICGzZsMD2+evVqAMDpp5/ezVtGiaisrMS7774LQFsWIC0tDXPmzAEAPP3006bXcJ/2Dp3dT4sWLdI9LnvhhRfQ2NiIU045BR6P51hvMiVICIE1a9YAMC/Xwf3XdZqamnDmmWfiww8/xLx583RdZ414/PU+yey/eHj89T5vv/02AGDo0KEAePxRkgRRF7j11lsFAHHiiSeK2tra6P1/+MMfBABRXl7ecxtHYu3atWLNmjWitbVVd//27dvF9OnTBQBxxhln6B577bXXBACRlZUltmzZEr1/3bp1wu12i1AoJA4fPtwdm5/S3G63iPfV3Zn9VFVVJdLT0wUA8cwzz0Tv379/vyguLhYAxJtvvnmsf5SUFG//HThwQDzwwAPi6NGjuvtramrED3/4QwFA5Ofni7q6Ot3j3H9do7W1VSxevFgAEDNmzDD93q3w+Os9kt1/PP56l/fee0+8/PLLoq2tTXd/c3OzuP/++4XNZhNpaWli586d0cd4/FGiGABTl2hoaBBTpkwRAERBQYE455xzordzcnJERUVFT29iSnvssceiJ/OFCxeK888/X0yfPl14PB4BQIwcOVLs37/f9Lprr71WABBer1eceeaZYsGCBcLhcAi73S7WrFnT/T9ICnjhhRfElClTov8piiIA6O574YUXdK/pzH5avXq1sNlsQlEUMXv2bLFs2TIRCoUEAHHdddd1w096fEpm/23fvl0AEH6/X8yePVucf/754tRTTxVZWVkCgAiFQuK9996z/Bzuv2Pv3nvvFQAEALF48WJx0UUXWf5XWVmpex2Pv94h2f3H4693iVynZGdni3nz5onzzz9fzJ07VxQUFAgAwuPxiKeeesr0Oh5/lAgGwNRl6uvrxYoVK8TQoUOFy+US+fn54uKLLxa7du3q6U1LeZs2bRJXXnmlmDBhgsjJyREOh0MEg0ExdepU8Yc//EHU19fHfO1jjz0mJk6cKLxerwiFQmL+/Pli7dq13bj1qSVyERDvv8cee8zydcnup/fee0/Mnz9fhEIh4fV6xaRJk8SqVau66CdLDcnsv6NHj4qbbrpJlJeXi379+gm32y28Xq8YOXKkuP7668Xu3bvjfhb337F1++23d7jvAIjt27ebXsvjr+clu/94/PUu27ZtE7fccouYPn26KCgoEE6nU/h8PjFy5Ejxk5/8RGzdujXma3n8UUcUIYRItmyaiIiIiIiIqK9hEywiIiIiIiJKCQyAiYiIiIiIKCUwACYiIiIiIqKUwACYiIiIiIiIUgIDYCIiIiIiIkoJDICJiIiIiIgoJTAAJiIiIiIiopTAAJiIiIiIiIhSAgNgIiIiIiIiSgkMgImIiIiIiCglMAAmIiIiIiKilMAAmIiIqJeqq6vDPffcg9mzZyMvLw8ulwsZGRmYNm0abrvtNuzcuTP63IsvvhiKouCtt97quQ3uYStXroSiKFi1alVPbwoREfVSjp7eACIiIjJbt24dli5din379sHr9WLq1KnIy8tDdXU1PvroI3zwwQf43e9+hxdeeAGnnHJKT28uERFRn8AAmIiIqJfZsGEDTj75ZDQ2NuKmm27CihUr4PP5oo+3t7fj2WefxY033ojdu3f34JYSERH1LQyAiYiIehEhBC644AI0NjZi5cqVuP32203PsdlsWLJkCU4++WTs2rWrB7aSiIiob+IcYCIiol7klVdewRdffIGioiLceuutcZ8bDAYxatQo0/3vvPMO5syZg0AggPT0dCxatAibNm0yPe/IkSP405/+hHnz5mHgwIFwu93IysrC/Pnz8dprr1l+5qxZs6AoCr755hs8++yzmDp1Knw+HzIzM3HeeedZZqTl+cmJbpv8+1i0aBFycnLgdrsxZMgQXHfddaiqqor7uyEiIrLCAJiIiKgXefHFFwEAZ599NhyO5Au1nn/+ecyZMwf19fVYuHAhCgoK8NJLL2HmzJnYt2+f7rkffPABrrnmGmzZsgVlZWVYvHgxysrK8Oqrr2LevHl49NFHY37OQw89hGXLliEtLQ0LFy6E3+/Hk08+iTlz5qChoeE7bxsA/PznP8eCBQvw+uuvo6ysDGeccQYcDgf++Mc/YsqUKdi/f3/Svx8iIkptDICJiIh6kQ0bNgAAJkyY0KnX33vvvVi9ejU++OADPPXUU9i0aROWLl2KqqoqPPTQQ7rnlpWV4f3338f27dvx6quv4sknn8S6devwySefIBgM4mc/+xlqa2stP+fBBx/Eu+++izfffBNPP/00vvrqK5x44onYunUrnnjiie+8bU8//TR++9vfYtSoUdi4cSPee+89PP3009i8eTNuu+02VFRU4Nprr+3U74iIiFIXA2AiIqJeJFLam5OT06nXn3feeTjrrLOit+12O26++WYAamm0bPDgwZg6darpPcaPH4+rr74aR48exZtvvmn5OT/72c8wbdq06G2v14vrrrvO8nM6s2133nknAOCJJ55AcXFx9H5FUbBy5UqMGzcOq1evxsGDBy0/i4iIyAqbYBERER1H5s6da7qvtLQUALB3717TY21tbfjnP/+JdevWYe/evWhqagIAbN26Vff/7/o5ybzmwIED+PTTT1FSUmI5x1lRFEyfPh0bNmzAJ598gnnz5ll+HhERkREDYCIiol4kKysLAFBZWdmp1xcVFZnuCwQCABANbiN2796N0047DZ9++mnM96upqfnOn5Psa7755hsAavCtKErMbQPADDARESWFATAREVEvMm7cOKxduxbr16/H8uXLk369zZb47KbLLrsMn376KZYuXYobb7wRZWVlCAQCsNls+POf/4wf/vCHEEJ8589J9jXt7e0AgPz8/A6zuwMHDkx6O4iIKHUxACYiIupFFi1ahAcffBBPP/00fve733WqE3Qi6urq8NprryEvLw9PPfUU7Ha77vFt27Z1yecmIpIpzs7OxqpVq3psO4iI6PjDJlhERES9yPz58zFy5Ejs3r072ggqlqNHj2Ljxo2d+pzq6mq0t7ejoKDAFPy2tLRgzZo1nXrfY6GoqAjDhg3Dpk2bsGXLlh7bDiIiOv4wACYiIupFFEXB3/72N3g8HqxcuRI333wz6urqdM8RQuC5557DpEmT8NFHH3Xqc3JzcxEMBvHFF19g7dq10fvb2tpw00039XjguWLFCrS3t2Pp0qXRpaFkVVVVePjhh7t/w4iIqE9jCTQREVEvM27cOLz++utYunQp7rrrLtx///2YNm0a8vLyUF1djY8//hj79++Hx+NB//79O/UZDocDN954I2699VaUl5djzpw5yMzMxL/+9S/s378fV199NR588MFj/JMl7vzzz8fGjRvx61//GhMnTsS4ceMwdOhQCCFQUVGBzz77DH6/H5dffnmPbSMREfU9DICJiIh6oenTp+Prr7/Gf/3Xf+H555/HZ599hsOHD8Pv96OsrAw/+tGPcNlll1l2Vk7ULbfcgqKiItx7771Yu3Yt0tLScNJJJ+GOO+7A+vXrj+FP0zl33nkn5s2bhwceeABr167F559/jvT0dPTr1w9XXnklzj777J7eRCIi6mMUEau9IxEREREREdFxhHOAiYiIiIiIKCUwACYiIiIiIqKUwACYiIiIiIiIUgIDYCIiIiIiIkoJDICJiIiIiIgoJTAAJiIiIiIiopTAAJiIiIiIiIhSAgNgIiIiIiIiSgkMgImIiIiIiCglMAAmIiIiIiKilMAAmIiIiIiIiFICA2AiIiIiIiJKCQyAiYiIiIiIKCUwACYiIiIiIqKUwACYiIiIiIiIUgIDYCIiIiIiIkoJDICJiIiIiIgoJTAAJiIiIiIiopTAAJiIiIiIiIhSAgNgIiIiIiIiSgkMgImIiIiIiCglMAAmIiIiIiKilMAAmIiIiIiIiFICA2AiIiIiIiJKCQyAiYiIiIiIKCUwACYiIiIiIqKU8P8BPa1Ybbz4isMAAAAASUVORK5CYII=", + "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": [ + "plt.figure(dpi=150)\n", + "\n", + "plt.subplot(211)\n", + "plt.title(\"In Velocity\")\n", + "plt.plot(ta1.spectral_axis.to(\"km/s\").value, ta1.flux, label=f\"IF={ta1.meta['IFNUM']}\")\n", + "plt.plot(ta2.spectral_axis.to(\"km/s\").value, ta2.flux, label=f\"IF={ta2.meta['IFNUM']}\")\n", + "plt.legend()\n", + "plt.xlabel(\"Velocity (km/s)\")\n", + "\n", + "plt.subplot(212)\n", + "plt.title(\"In Channels\")\n", + "plt.plot(ta1.flux)\n", + "plt.plot(ta2.flux)\n", + "plt.xlabel(\"Channel\")\n", + "\n", + "plt.gcf().supylabel(\"Antenna temperature (K)\")\n", + "\n", + "plt.tight_layout()\n" + ] + }, + { + "cell_type": "markdown", + "id": "3ba825a2-2ca3-4d8a-8ebc-456eaf337f13", + "metadata": {}, + "source": [ + "The difference is subtle, but the top panel shows that the spectral line is well aligned in velocity, whereas the bottom panel shows that the line centroids are slightly misaligned. If we were to average the two spectra toegether, the resulting line would look artificially broader than it is!" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "cdf33158-62c0-4f66-a27d-f35fd22b12ea", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.0" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} From 35324e12151926d95131e31f9879ed03a3be7482 Mon Sep 17 00:00:00 2001 From: astrofle Date: Wed, 9 Oct 2024 20:46:15 -0400 Subject: [PATCH 34/95] Add: Spectrum.shift method --- src/dysh/spectra/spectrum.py | 72 ++++++++++++++++++++++++++---------- 1 file changed, 53 insertions(+), 19 deletions(-) diff --git a/src/dysh/spectra/spectrum.py b/src/dysh/spectra/spectrum.py index 59755f8e..a2a397af 100644 --- a/src/dysh/spectra/spectrum.py +++ b/src/dysh/spectra/spectrum.py @@ -37,7 +37,7 @@ from ..log import HistoricalBase, log_call_to_history from ..plot import specplot as sp from ..util import minimum_string_match -from . import baseline, get_spectral_equivalency +from . import baseline, fft_shift, get_spectral_equivalency # from astropy.nddata import StdDevUncertainty @@ -386,7 +386,7 @@ def stats(self, roll=0, qac=False): def decimate(self, n): """ - Decimate a `Spectrum` by n pixels. + Decimate the `Spectrum` by n pixels. Parameters ---------- @@ -395,8 +395,8 @@ def decimate(self, n): Returns ------- - s : Spectrum - The decimated Spectrum. + s : `Spectrum` + The decimated `Spectrum`. """ if not float(n).is_integer(): @@ -422,7 +422,7 @@ def decimate(self, n): @log_call_to_history def smooth(self, method="hanning", width=1, decimate=0, kernel=None): """ - Smooth or Convolve a spectrum, optionally decimating it. + Smooth or Convolve the `Spectrum`, optionally decimating it. Default smoothing is hanning. @@ -467,8 +467,8 @@ def smooth(self, method="hanning", width=1, decimate=0, kernel=None): Returns ------- - s : Spectrum - The new, possibly decimated, convolved spectrum. + s : `Spectrum` + The new, possibly decimated, convolved `Spectrum`. """ nchan = len(self._data) # decimate = int(decimate) # Should we change this value and tell the user, or just error out? @@ -524,6 +524,52 @@ def smooth(self, method="hanning", width=1, decimate=0, kernel=None): return s + def shift(self, s, wrap=False, fill_value=np.nan, method="fft"): + """ + Shift the `Spectrum` by `s` channels in place. + + Parameters + ---------- + s : float + Number of channels to shift the `Spectrum` by. + wrap : bool + If `True` allow spectrum to wrap around the edges. + If `False` fill channels that wrap with `fill_value`. + fill_value : float + If `wrap=False` fill channels that wrapped with this value. + method : "fft" + Method used to perform the fractional channel shift. + "fft" uses a phase shift. + """ + + ishift = int(np.round(s)) # Integer shift. + fshift = s - ishift # Fractional shift. + # Apply integer shift. + new_data = np.roll(self.data, ishift, axis=0) + if not wrap: + if ishift < 0: + new_data[ishift:] = fill_value + else: + new_data[:ishift] = fill_value + + if fshift != 0: + # Apply fractional shift. + new_data = fft_shift(new_data, fshift, pad=False, window=True) + + # Update data values. + self._data = new_data + + # Update metadata. + applied_shift = ishift + fshift + self.meta["CRPIX1"] += applied_shift + + # Update WCS. + self.wcs.wcs.crpix[0] += applied_shift + + # Update `SpectralAxis` values. + new_spectral_axis_values = self.wcs.spectral.pixel_to_world(np.arange(self.flux.shape[-1])) + self._spectral_axis = self.spectral_axis.replicate(value=new_spectral_axis_values) + @property def equivalencies(self): """Get the spectral axis equivalencies that can be used in converting the axis @@ -1082,18 +1128,6 @@ def _copy_attributes(self, other): for k, v in vars(self).items(): if k not in IGNORE_ON_COPY: vars(other)[k] = deepcopy(v) - # other.add_history(self._history) - # other.add_comment(self._comments) - - # other._target = self._target - # other._observer = self._observer - # other._velocity_frame = self._velocity_frame - # other._obstime = self._obstime - # other._baseline_model = self._baseline_model - # other._exclude_regions = self._exclude_regions - # other._mask = self._mask - # other._subtracted = self._subtracted - # other._spectral_axis = self.spectral_axis def __add__(self, other): op = self.add From 6347f9cd6f08f9f76eac93329c4ccca49f873d3c Mon Sep 17 00:00:00 2001 From: astrofle Date: Wed, 9 Oct 2024 21:27:48 -0400 Subject: [PATCH 35/95] Add: option to fix the random number generator seed for fake_spectrum --- src/dysh/spectra/spectrum.py | 14 ++++++++++++-- 1 file changed, 12 insertions(+), 2 deletions(-) diff --git a/src/dysh/spectra/spectrum.py b/src/dysh/spectra/spectrum.py index a2a397af..d1956a53 100644 --- a/src/dysh/spectra/spectrum.py +++ b/src/dysh/spectra/spectrum.py @@ -854,7 +854,7 @@ def _copy(self, **kwargs): return s @classmethod - def fake_spectrum(cls, nchan=1024, **kwargs): + def fake_spectrum(cls, nchan=1024, seed=None, **kwargs): """ Create a fake spectrum, useful for simple testing. A default header is created, which may be modified with kwargs. @@ -864,6 +864,14 @@ def fake_spectrum(cls, nchan=1024, **kwargs): nchan : int, optional Number of channels. The default is 1024. + seed : {None, int, array_like[ints], SeedSequence, BitGenerator, Generator}, optional + A seed to initialize the `BitGenerator`. If None, then fresh, unpredictable entropy will be pulled from the OS. + If an int or array_like[ints] is passed, then all values must be non-negative and will be passed to + `SeedSequence` to derive the initial `BitGenerator` state. One may also pass in a `SeedSequence` instance. + Additionally, when passed a `BitGenerator`, it will be wrapped by `Generator`. If passed a `Generator`, it will + be returned unaltered. + The default is `None`. + **kwargs: dict or key=value Metadata to put in the header. If the key exists already in the default header, it will be replaced. Otherwise the key and value will be @@ -874,7 +882,9 @@ def fake_spectrum(cls, nchan=1024, **kwargs): spectrum : `~dysh.spectra.Spectrum` The spectrum object """ - data = np.random.rand(nchan) * u.K + + rng = np.random.default_rng(seed) + data = rng.random(nchan) * u.K meta = { "OBJECT": "NGC2415", "BANDWID": 23437500.0, From 311f225d1601a7b89a8fbe5aa330a6ce9f201cae Mon Sep 17 00:00:00 2001 From: astrofle Date: Wed, 9 Oct 2024 22:18:59 -0400 Subject: [PATCH 36/95] Add: test for Spectrum.shift --- src/dysh/spectra/tests/test_spectrum.py | 35 ++ testdata/gshift_box.fits | 539 ++++++++++++++++++++++++ 2 files changed, 574 insertions(+) create mode 100644 testdata/gshift_box.fits diff --git a/src/dysh/spectra/tests/test_spectrum.py b/src/dysh/spectra/tests/test_spectrum.py index 40695b11..0610dd8d 100644 --- a/src/dysh/spectra/tests/test_spectrum.py +++ b/src/dysh/spectra/tests/test_spectrum.py @@ -3,6 +3,7 @@ import astropy.units as u import numpy as np import pytest +from astropy.io import fits from dysh.fits.gbtfitsload import GBTFITSLoad from dysh.spectra.spectrum import IGNORE_ON_COPY, Spectrum @@ -391,3 +392,37 @@ def test_smooth_and_slice(self): assert np.sqrt(fwhm**2 - sss.meta["FREQRES"] ** 2) == pytest.approx( abs(self.ss.meta["CDELT1"]) * self.ss.meta["FWHM"], abs=abs(self.ss.meta["CDELT1"]) / 9.0 ) + + @pytest.mark.filterwarnings("ignore:Beware:UserWarning") + def test_shift(self): + """Test the shift method against the results produced by GBTIDL""" + + # Prepare test data. + filename = get_project_testdata() / "TGBT21A_501_11/TGBT21A_501_11_ifnum_0_int_0-2_getps_152_plnum_0.fits" + sdf = GBTFITSLoad(filename) + nchan = sdf["DATA"].shape[-1] + spec = Spectrum.fake_spectrum(nchan=nchan, seed=1) + spec.data[nchan // 2 - 5 : nchan // 2 + 6] = 10 + org_spec = spec._copy() + # The next two lines were used to create the input for GBTIDL. + # sdf["DATA"] = [spec.data] + # sdf.write("shift_testdata.fits") + + # Apply method to be tested. + shift = 5.5 + spec.shift(shift) + + # Load GBTIDL answer. + with fits.open(get_project_testdata() / "gshift_box.fits") as hdu: + table = hdu[1].data + gbtidl = table["DATA"][0] + + # Compare. + # Ignore the edge channels to avoid edge effects. + diff = (spec.data - gbtidl)[10:-10] + assert np.all(abs(diff) < 1e-4) + + assert spec.meta["CRPIX1"] == org_spec.meta["CRPIX1"] + shift + assert spec.spectral_axis[0].to("Hz").value == ( + org_spec.spectral_axis[0].to("Hz").value - spec.meta["CDELT1"] * shift + ) diff --git a/testdata/gshift_box.fits b/testdata/gshift_box.fits new file mode 100644 index 00000000..58f676e5 --- /dev/null +++ b/testdata/gshift_box.fits @@ -0,0 +1,539 @@ +SIMPLE = T /Written by IDL: Wed Oct 9 21:23:56 2024 BITPIX = 8 / NAXIS = 0 / EXTEND = T /File contains extensions DATE = '2024-10-10' / ORIGIN = 'NRAO Green Bank' /origin of observation TELESCOP= 'NRAO_GBT' /the telescope used GUIDEVER= 'GBTIDL ver2.10.1' /this file was created by gbtidl FITSVER = '1.9 ' /FITS definition version END XTENSION= 'BINTABLE' /Binary table written by MWRFITS v1.13 BITPIX = 8 /Required value NAXIS = 2 /Required value NAXIS1 = 131834 /Number of bytes per row NAXIS2 = 1 /Number of rows PCOUNT = 0 /Normally 0 (no varying arrays) GCOUNT = 1 /Required value TFIELDS = 83 /Number of columns in table COMMENT COMMENT *** End of mandatory fields *** COMMENT EXTNAME = 'SINGLE DISH' CTYPE4 = 'STOKES ' COMMENT COMMENT *** Column names *** COMMENT TTYPE1 = 'OBJECT ' / TTYPE2 = 'BANDWID ' / TTYPE3 = 'DATE-OBS' / TTYPE4 = 'DURATION' / TTYPE5 = 'EXPOSURE' / TTYPE6 = 'TSYS ' / TTYPE7 = 'DATA ' / TTYPE8 = 'TDIM7 ' / TTYPE9 = 'TUNIT7 ' / TTYPE10 = 'CTYPE1 ' / TTYPE11 = 'CRVAL1 ' / TTYPE12 = 'CRPIX1 ' / TTYPE13 = 'CDELT1 ' / TTYPE14 = 'CTYPE2 ' / TTYPE15 = 'CRVAL2 ' / TTYPE16 = 'CTYPE3 ' / TTYPE17 = 'CRVAL3 ' / TTYPE18 = 'CRVAL4 ' / TTYPE19 = 'OBSERVER' / TTYPE20 = 'OBSID ' / TTYPE21 = 'SCAN ' / TTYPE22 = 'OBSMODE ' / TTYPE23 = 'FRONTEND' / TTYPE24 = 'TCAL ' / TTYPE25 = 'VELDEF ' / TTYPE26 = 'VFRAME ' / TTYPE27 = 'RVSYS ' / TTYPE28 = 'OBSFREQ ' / TTYPE29 = 'LST ' / TTYPE30 = 'AZIMUTH ' / TTYPE31 = 'ELEVATIO' / TTYPE32 = 'TAMBIENT' / TTYPE33 = 'PRESSURE' / TTYPE34 = 'HUMIDITY' / TTYPE35 = 'RESTFREQ' / TTYPE36 = 'DOPFREQ ' / TTYPE37 = 'FREQRES ' / TTYPE38 = 'EQUINOX ' / TTYPE39 = 'RADESYS ' / TTYPE40 = 'TRGTLONG' / TTYPE41 = 'TRGTLAT ' / TTYPE42 = 'SAMPLER ' / TTYPE43 = 'FEED ' / TTYPE44 = 'SRFEED ' / TTYPE45 = 'FEEDXOFF' / TTYPE46 = 'FEEDEOFF' / TTYPE47 = 'SUBREF_STATE' / TTYPE48 = 'SIDEBAND' / TTYPE49 = 'PROCSEQN' / TTYPE50 = 'PROCSIZE' / TTYPE51 = 'PROCSCAN' / TTYPE52 = 'PROCTYPE' / TTYPE53 = 'LASTON ' / TTYPE54 = 'LASTOFF ' / TTYPE55 = 'TIMESTAMP' / TTYPE56 = 'QD_XEL ' / TTYPE57 = 'QD_EL ' / TTYPE58 = 'QD_BAD ' / TTYPE59 = 'QD_METHOD' / TTYPE60 = 'VELOCITY' / TTYPE61 = 'FOFFREF1' / TTYPE62 = 'ZEROCHAN' / TTYPE63 = 'ADCSAMPF' / TTYPE64 = 'VSPDELT ' / TTYPE65 = 'VSPRVAL ' / TTYPE66 = 'VSPRPIX ' / TTYPE67 = 'SIG ' / TTYPE68 = 'CAL ' / TTYPE69 = 'CALTYPE ' / TTYPE70 = 'TWARM ' / TTYPE71 = 'TCOLD ' / TTYPE72 = 'CALPOSITION' / TTYPE73 = 'BACKEND ' / TTYPE74 = 'PROJID ' / TTYPE75 = 'TELESCOP' / TTYPE76 = 'SITELONG' / TTYPE77 = 'SITELAT ' / TTYPE78 = 'SITEELEV' / TTYPE79 = 'IFNUM ' / TTYPE80 = 'PLNUM ' / TTYPE81 = 'FDNUM ' / TTYPE82 = 'INT ' / TTYPE83 = 'NSAVE ' / COMMENT COMMENT *** Column formats *** COMMENT TFORM1 = '32A ' / TFORM2 = 'D ' / TFORM3 = '22A ' / TFORM4 = 'D ' / TFORM5 = 'D ' / TFORM6 = 'D ' / TFORM7 = '32768E ' / TFORM8 = '16A ' / TFORM9 = '6A ' / TFORM10 = '8A ' / TFORM11 = 'D ' / TFORM12 = 'D ' / TFORM13 = 'D ' / TFORM14 = '4A ' / TFORM15 = 'D ' / TFORM16 = '4A ' / TFORM17 = 'D ' / TFORM18 = 'I ' / TFORM19 = '32A ' / TFORM20 = '32A ' / TFORM21 = 'J ' / TFORM22 = '32A ' / TFORM23 = '16A ' / TFORM24 = 'D ' / TFORM25 = '8A ' / TFORM26 = 'D ' / TFORM27 = 'D ' / TFORM28 = 'D ' / TFORM29 = 'D ' / TFORM30 = 'D ' / TFORM31 = 'D ' / TFORM32 = 'D ' / TFORM33 = 'D ' / TFORM34 = 'D ' / TFORM35 = 'D ' / TFORM36 = 'D ' / TFORM37 = 'D ' / TFORM38 = 'D ' / TFORM39 = '8A ' / TFORM40 = 'D ' / TFORM41 = 'D ' / TFORM42 = '8A ' / TFORM43 = 'I ' / TFORM44 = 'I ' / TFORM45 = 'D ' / TFORM46 = 'D ' / TFORM47 = 'I ' / TFORM48 = 'A ' / TFORM49 = 'I ' / TFORM50 = 'I ' / TFORM51 = '16A ' / TFORM52 = '16A ' / TFORM53 = 'J ' / TFORM54 = 'J ' / TFORM55 = '22A ' / TFORM56 = 'D ' / TFORM57 = 'D ' / TFORM58 = 'I ' / TFORM59 = 'A ' / TFORM60 = 'D ' / TFORM61 = 'D ' / TFORM62 = 'E ' / TFORM63 = 'D ' / TFORM64 = 'D ' / TFORM65 = 'D ' / TFORM66 = 'D ' / TFORM67 = 'A ' / TFORM68 = 'A ' / TFORM69 = '8A ' / TFORM70 = 'E ' / TFORM71 = 'E ' / TFORM72 = '16A ' / TFORM73 = '32A ' / TFORM74 = '32A ' / TFORM75 = '32A ' / TFORM76 = 'D ' / TFORM77 = 'D ' / TFORM78 = 'D ' / TFORM79 = 'I ' / TFORM80 = 'I ' / TFORM81 = 'I ' / TFORM82 = 'J ' / TFORM83 = 'J ' / END NGC2415 AvZ À2021-02-10T07:38:37.50@õ6à@eO`@10ràÀÀÀÀÀÀ?@ÅÔ? ê? +Ïš?%g>°õì?#tÃ?hµ>÷$Ä>•ž>ÄIP?*/^>Ö6?î¸? ¦_>À):>–4Û>‡³8>ž½O>`Qh?k?Q×>»}Ö?<âô?{*«?X3Ö?!ê´>Ò›¸>Mß?ãÿ?C|§>™ö>¹8À?6–E?0ë?G#°>óèE>‰^½?I\>~y¼>¯«L?Bk$?;DR>Ó%»? Ê&?/Áo>þ0?%X®>âJ}>ôDØ?BŠ(?=øk>öj>ý|U?_Ž=ãá¬>ð¦›?^EW?_¡ò?-5á>¾Å‚>~Ö>¤ÐŸ?0É/?Hî?D4>màh>Ú€µ?98G?f1–§¢?4”?(Š,?Fõ>š]\>«wr?ObÐ?_¢$?[(?Hö>à$t?id>øÔÞ?³î>ã§>á™Ñ?£">„G>°ŽM?¤>ßí>‘nW>P¾(=úŒ>µ¯ó>‚›Q>½4¨?É(? ô˜?3³À?”?&Ôº?@‡Ž?9 j?‚>âßî>¸8?î?"Ö>s¹b>+Ì>L|?}É??Y{>Ðdì>yâÌ>̘6? ½0?:â?KÓ?7…Ú?JÔ? +ÏT>ͱ:>ÔZÐ>q,>UF>zçF>™µn>ŸG>à<ö?H ö?`ö{?G=?GÂN?+Öj?B@=?Or=?<‘> ¡>I>¸~ª>&> Uh?)Y? 4?|?*K>¢vÖ?Y»?3Õ>¦8ÿ?–>ö¾?>Ú/ê>ï½}>‘d!>œÄô? +´z?±¾?-à?O]x?'Tv? +X>ÓTM>­!ï?/§?†?Pf?en8? ôB? +˜?W +>¾Öã>çoÇ>ƒf>rŒœ?AT? br?`?ž@>œ[&?«¬>ñ¸>Þô?,Qj?!"P? ûµ?<~¢?3N'?:Èœ>÷gµ?`D>ÉR]>fÎp>Õ|>ÚKt>œ5Ü>%ùÌ>ÌŸ>ñ¶£?B?3rt?;?Mx†?+¥þ>Þ”? q-?@ì> À?ˬ?B¨È?'*?'tõ?>¥Ý¢=¿>Þ]L?#²â>±&;?Z˜?2>¦Pj>¦Î7>ÛÊÿ?ˆØ>JD=³˜Ð=àNd>8Â>»Ìd>ûÓ†?3 ?w~.?`#?; +Ú?@“§?hÙ>öbÞ=NM>>aêÒ>±¿>àÿð>·ä>‘>:Uø>Ö;"?4•>?"ƒ²>¡ªd>]Z +??^>ÖF>‰z¨>Tª=-»P>¾œ>¢¦v>Þ^^?._x?R>1>ÝŽd>ë/Ò=FHˆ?À†?`kZ? aÔ>f=|>„Ý>·jY?G¶?)îf>h š?1 ?KÀT>º/ò=ÏðD>˜W\>¼f>´m?%mð>ž(">Ó-a?NÇÔ?ZF’?K.–?/{ >Ü•¯=³Š0<æóÀ?¾[?Oè?LǬ?%pd? dØ>Õö›=ÏÅd>cyÊ>ÓÀ¼?B½?(¤>ì‰>úó??HÂá?5À?&òD>æ8Â>QF>õy ?Ç">ßA9>ým?.‰ø?N6Ë?V >§c…=;À> ÒD>#ÿ¯î>1mF>W¹|>³éþ>µLT=:Ó=™FL>/;þ>ØYJ?3ýP? +gX>ƒüE?ð?Mü°>Ùš>è†D?Wÿ>üÈe>̨Í>×Aä>TÊ®>½Ÿx?Sß>þÌ{?kì>»×q?.Ñ?ï¨?Pò?:¥>Î|W>n>,>¨³&>Ýʱ>ýäâ?šª>~•ü>ã>ã,K>Ù…ø?Uˆ±?]ÝÎ?N}Ø>Íû>—gŠ>â'¯? +Q´?÷V?6>ã9>ˆÚð>çœ">ý­>„/? ›¼?Vž?CǦï¸>ÞeA?j°>áAœ>'?&>‘>Ê?õ…?»?0Šò?6 >ªû?%?&w:>ºëk>ˆù?âŒ?w×ý?O^Ø>æ “>ÿ‘>ðýn>ƒ`ª>ß‚>ô§À>¸{Õ?-^[?±^>Æ S>«jí=__8>×¾?wž?]Ê$?N4Ò>çŽ">µq¤?bÈ>Ôw‰?;d?€>ÐûÓ>Çß‘>¢–•>ñ‹>±S>Ul>³úë>⮿?#ˆ?:µÝ?³`?9Ç? +›>ˆR>‚|–>†ôd>­èä?ÏJ>¯®>Öpi?&†j>ô_Ð?+P›?g5R? +[>-j?v? n¢>æœw? èG>¦Î>çgø?A«²>ð0^=h|ø>æé?µˆ>¤¶?#T?; >ñ6Ø?ZA?]“?;Ü"?6g$?F/Î?µŸ>à4?8jC?Xóú?eF„?k3¼>ýô&>eäì>Ô‰¾?.H¹?*/›>¬fr>{6>îš? „F>Ï3= ``>s«Š>Úîð>á‹?!‡+? J>¼ +?-8 ?Z^.?k‚>ü—>è?¸??Òð? »b>bÆ=¡¦l>ò s>×rr>ARØ>'8?ÆÈ?î>V±–>jeb>°ÉÚ?9B?·8?®#?Bƒ?5ÇÚ?Rº.?„>ã£>ñ(p?.ø0?Þ>ˆ&â>úK>÷CÜ?K? Á{>å­¹?;w?L6>êt%?.Ô„>ÛÊG>U¥Ö?$8˜?uÃÌ?~Þp?‹…>Õ« +?e‡€?kh±?OWÂ?0¾4?3w‡?$¾²?.÷#?'¸>¹Å>ãž>ÿ¤¦?[]Ê>å®:?h?x>ì9Ò?‚,>Žér>H}N=û-@=ßt=—u=‰|ð>îqä?1ÿé>žmH>¤øÕ? +]?Æ>²¼Z>Š[?*‚?"@º>Ù¾þ?;íW?þS>ñìz?ÀÆ?#¤?|>ä²D>çÕ9?ql?g½Ð?D>?N\ý?\ÏŠ?Eœ>?`Þ±?ÝÛ?!P?2¶²>àî>©nÒ?û +?u?»¬>ë{>Œ¢Õ>¿3¦>¡—=ü¦ð>ʯ?b7[?@Ž>7(>†W|>T¾>»‘f?b²>è.?=T:?c1þ?c”r?onê?C-@? G²>‰ð‚=i± >žqˆ?3›j?'Æ>V—ì=¼«Ü>ÿî>îû >*æÀ>w»¸>â3Ô?=I¦? >ÌØ?æ >÷È„?ˆN?5Ù™?[Ö>µL>˜´>–Ÿ?'ðÄ?gD?>ƒ>¾‘£>àøâ>øQk>p^> Du?+½?XM?qý[?,î²>šÃ”>6Hh>†8?#e?\?G?MT¾>ã©å>ÐÙì?:“Ö?dYG? ûJ>õ!M?Qæ^?øÀ>çà?"Ûâ?,RT>œ Æ??$>ÚO¥>™É>Ù´>äÜ1?ep? k:?y¤?(kˆ?]«z?dm?/Ìý?jV?è>¯Òß>ëK¿?NO¸?bÝ? ~`>ux?Çs?=½ ?K¼œ>ý·z>ÿ1?)Ó>¯ëÇ>˜Ô?*Âœ?Ì—?öÔ>5àN?ã>Ãdº<Ùì@<è>íeï?ú+>œLä?SE?˜?‰2?Q>¥â>°äj>– =ØR>ñ'k?c³´?(Ö?‚Z?IÌ¢?É}? +t†?@Î>Õ"º=µ2L>ä2??>Ì>Ýí¿>þr?Ub`?â>«£‡>`óÀ>É">¼ì>£fó?Wv?´P>£<ô>« ½?5=`>áßü>´¼a?:Y}>þ‡;? +–Ç?vÑ?Uè™?L_~?%r>æpü?R?à>ò5>Ü´?Ä>?v‡?:û?8âØ?eÄ>ÐÈ2?4 Ð?GŽ=²ì?èÚ?x~Ò?Ûì?Ät? ',?¹Þ?lùµ>ì‘Ë9¢¤>$Øx?">¼?`ûê?^×? \H?Ö”>¤à–>„«G?×:?f ?"/B>±7?äV?2c×>”=> ¢Ù?@O?C">Úe˜?Åå?V{>²„|>á”V?j× ?kBd>Ô^ >hÑ\? 8R?=öå?5Ïñ>‰µÌ>ÿÃ%?vI"?9ðQ>‡ú>ã/Ô?L*?^i>ùŽü>RÂD>ÀJ>8v>Ùë„? yË>:Í&=”›Œ>òð?9 >Ê~t>ëù“>ÓÜ>Ç–?/Û]>£É>{å.? ¦ê?>ÝÖ?:£}?Lï?Qç~?WàB?-•\>ZâÒ=Îߤ>v±€>*TÖ=‚ZX>£q˜>É >ƒPä?‘b?M—„?^6?³l?%Ÿ?L~ì?Í~> l2>ÝlE>îYH>^“†>“dt>>€x>i•¸>}@(>Uô>o;€>Õ>gÔ>” £?í"?…h? ¦?i0 ??l>šŒ>Ѩé?ÂP>‹þ0>æ¯Î?M»6?'5æ>½cü? ï?*Tu>âs>Ër=? Å?CÒ>ÈÂc=ÆÁœ??„?i?ì?Q›ä?a-ý?up€?+î”?ÍÑ?57^?äå? –j>û\L?‹r?%§‚>‹ê’=…™Ä>ª¤>Ý_¥?År?ô>ij?)ÿ?A?ø?6Uè?^õN>㌜> üø>—#¸?%ï?@>ÆO>ö+ë>Èܲ?­>Úèl=ïÂè?´\?:÷ë?›0>ãjÈ>z ">µ?;Àþ?LÚ?7í?Ijî?q¢?p­?{N×?Qú>óc¼>ﾶ>ø-û?º>õc>+©?*¯\?%Ý?s|>´p >/¼? ã’?Qîª?ÇÃ>Ý×c?&*ñ?H]¨?P¹j?Ïù>~ST>á÷?hž? XW>È‚¸>€¼À? p? 0|?Ä”>ÉPc>þÓÊ?$ë>£'^?7¥ü?FÌ>^‡ê>©O›>áì>Y¬(?E?IÎ_?ü>f>Nq8?!ñ?˜•>òSâ>Ûù²>É\¢?-T?ö¶>½Cà?1À>ñÒX>•­&>&eâ>¨p×?FŸ—>ðŸl>ØÕ§?pWÈ?>0?@Çû?X´¥?¾n?&F>ê°«?V0>èn>ñ–?qT?$?RéJ?rÒ>_n>²þ>>Âä>«òA? Ñè?Q/Ä?Oû>õÆÌ?)RF>íq‘> ’ë±>x¢?áf?À2>Š¥Ð?7z>õÖÜ>ë zg>³w">öŒÐ?9½?_F`?#?\—>Úý÷?(k¨?/Â?! ×?F…X?J†?#¿>Á §>ÇWý?,C?f †?eq?!K?"´Y?JQ? S>³5}>IÈ>ö’8>è‰>»I®?1K¶?;n?"wÆ>Þé§>= +r=›?¼=À> WP>ÌGÐ>ÿ‰J>žˆÕ>~¹Œ>Âx?!ÆL?>…“>¬a>„j>ª%£??cd¬?6Òõ?$’.?6"Ž?B2 ? S–>sÓB>÷I*?_{:?o >Ž?‚}>å™S?æ>âÔ~>w7X>Ì&”?1íN?T8°?/·?_­?7>ÑßF>º²i=ð¸>Ü7?E|ü?;¥? +?.‹È?`·Š?qSz?_äØ?J?ðn>üO?h…?iJ? Åã?'âÎ>‰Xù>™q>ÔÔ>±â>_ š?œ2?n7A? —5>“a>Üô?ªÞ?A´ ?&Û?­‘?6>H>Èôõ?|?"?+|?K‚P>ÈÖì>æ£?-éÿ?Q>óeö? ›>¹™Ç>‡$ô?=c? à>™ê>‹œp>ñeD>å/ë>Ùýg?Ðó??–.>×)@>J‡P?Vt>œÜÃ>õ¶Ø?PkÆ? øû>ðÇâ>™‰™=¾8>½+g?Oðj?_EF>ϼÂ<3±>ä»? Ù€?ÅY?>Q?c=þ?t!ˆ?)” >ÊÓ?<½È?^>·Ög>ô†¤?If>Ê]y>†­ð>í,?®§?Ÿx??#9$??àß?n«}?tf=Ò¼>øX?<d?KbX?7B¾>šýy=¼E$>ÓŠ>Û¿ø>³üé?=È?$X ?[‚3?ý>¯#æ?!Å$>ö<>,À=Ñ7? QF?a˜>ý¦×=¶Dˆ>©š>û[ê>Š>UMª>­Ô >Í?q?%&ù?Bz?9~‚?kJì?jÆ?3p?&H?Þ½>„ o>ú¯h?…>«r? #û?<óþ?*_„?8"?<ë,?=0ã?%Ox?Fªè>ê-ý>•o›>Ž¸³=«ä$=¢D>çàª?B`>ÑY?)¤°?öh‘>‘v>ŽxJ>£Ýñ>ß~?3ú?+þ#>—P?fg?+„>WU"> À>¬2¶>Q6¢=™R¤>bLz>¢<‘>ÇÁ>½ª>›”^>Ê |>ίp? ®?ID>ÊŽè=£ÉX>$>gíî>´’®? y¨?>Jk?N„?Iݪ? Ô”?L‘¨?T1¦?2d>³þ>SÒ>ù€©?_E? Ì?CØ?Udš?e/?4Ä)?pšú?*‡Æ>ÞJr>•Tµ=ò#h>l×Â>–n£>_>Ê™Â?]>?Rˆ?Jþò?eŠ„?B Â?”H>ßdM>Ú-`>ÓêÃ>t…²>¨nM?߆?)\?*L? ¼z>!œ=Ñí(>¿„>Ú!Ü>ðIw?Kw>áJÿ>±ºY>l7}>©úÁ?J?Û?[Ø?aoÉ?šó?n\?IqÐ>·òµ> ll=Ø@>µÀ€?#rˆ?5[O?9Ìô?GZ>§—’>êR>¼R²>¦¤´>Û„>hò?Þg?mâ±?T°M>>¯E÷>Õòr>fMJ>9U>”>?Dñ?Àö>™ïŒ>¡zé>å7¡?ï?,D">ÈZî=³·È>ÑÅÐ?ìè?6nž>ç=Ç>Z›D>Èž>ìKØ>Úq? ªR>Û.)=‡_|>Exö>Mú>mƒr? >§r >†Áë??¹?´>’œY>ÈÏ{?DÇ@?Ó{>ÀIØ?ÎN?M@H?,Ö?¹E?„F?.'¨?oOv?.`>´Vþ>Ó¡Ý?=J–? ’¾>©¯Í?¯?1ë >Æ8(>¥PI? +uÄ>À›Ò?+Ù†? 3(>Î!‹>éƒá?…'?=1 >ðuÜ>³j>ÁÉ›?82>ì[E>·îÚ>ÕU>%xâ?ö‚>ëq>Ì’>ÍûF>‡ë"?iÎ>¾9>ôö}?q¾>¯—>µWf?l$?Ò®>÷6=û¿x>î" >õl…>§ >ýÈ‘>ù4¼>îað>ó}Œ? ò¤?ê=™¬”=Yüh>ŸƒŸ?ç?5Sé?hÉJ?+¦’?nX?>ÅÌv>tÅ–?™Ž?èî>ø ¢?\j?Cà@?!Ç>ÄX}?0‘o>öÛy>ÿ­W?6…‚>ž? +š?4?é>Û(à? ýê?cã?qø>-6¢>áúT?9fM?€t? +Ï?LÆ*?gß +å>©%4?Ò??l–?3¿? Î’?-LÞ>Í1•=vôh=6yÀ=ƒL>@a>>NØ>£¢©?ûi?AZ>c(ü>†bÄ>¬H=> >Ê` ?a¿›>õkþ>ºCu>¸2>›Õ?´æ?Ã?JÓŽ?QŠ_>¼yº?è?É>Ñý™>÷ìâ? á>å{p>XjÒ>Òµù?Cj?CÐÉ? x>œ´Y?+>àÕÎ>µý´>Ôým>ïá&? Î?"—è?àP>ª+ô=ågè>ž~„>ÛOº=Ì$>D&Ì>¥AÎ>ö»å>þ“m>£¹²? 4ò?6}®>Ò.Ð>¸*Û?Dÿõ?l<¤?d ? Š? ~?_‚>•–B>ƒ§u>ªÚ?&lr?8gó>¨‚Æ>ýÌã?(bx?Ù?Xƒ?[´¬?%þl?‘ö>®¬>~Ò–?à?B3t?*ÎB?..5??+ö?,šŽ>t–ä>àØ#>Ó V?‰?Káþ>¯›=fzà>£­ª>ªO´<ó¢>r“4>Ú®?'v>ñU2>ýÞ(?$^þ? öM?ßæ=¡¤>}–Ú>§§ˆ>­5î?& +?^ÐÐ>÷ëH>!N>”Bæ>n•:>¦î>†zú=õçè>År>|–,?8œD? ö”?O~?¬?D?O*?8t ?)Mî?,Hf?Gêª?]?éB>µE2>]Ž:>¬7Å>Áߟ>\Êr?Ù½?MîÈ?™?1´Ä?17Ö>åü1? +?(`R>Ð.¸>€­‚>ç2—>Á¬¡? +²>õ¹o>â6Ü?rå¾?MÝ>Ë·?ÿŸ?!¢È?Óp?Mn>€°?÷x?WÌ="¸>Ø<»?Kù5? +½ +>©? å?%Mø? Ù?ö¢?8-:?w>Ù´>Ú¿?>†Ç9>Ÿ¬%?ê ?7s>ä(¡>Ý{§>ÿ°q?—§>È,>˜ác>Ù;f>ŒØ=«`> ×>Ë¡Þ?P>Øî0=ÎT>â[P>ÂÉ}>ŠS,>ºý!>ú­>tÃæ?ü…?*©À>Bµž?µ¾? +*Q>Þfn?5²¬?.‚S?A®ÿ>õÕR=À5À>m7€>æR²>¨"º?;ü>í¦›>’àÉ?‘Þ>Tu>ÒB?~Ê>ξ|>žJü>Œ…<>ÚR¥? –@>¡DL>cÍ2>ꀴ?9Êç-8?@wL?1æ¾?3¦ö?N¸?B°??ð¼?0ýˆ?URè?;>­X?%„¼?"rŽ?<Â>ø4L>¥p–>âD¨>¦ÿ#>z?Úÿ?UÆ?C?QT?6N¾?F±>Ìîþ>)Ê?A~?;¨=?Ϧ>Âap>y>5«|>ˆÆï>å^>íbu?Yþ?h>êSV?@T¤>ý¢l>£yÅ?66>â¤?ÝÐ>ûJç>ì“Z?Ù·>—ûZ>Õ#R>ô„?¨T>¥¨I>Ù‰Þ?-œ?:·? ²´>‘\?6}8?MI¬?“¨>óã&?5íf>æ®Y>ü“Ÿ?>‡?$!N?'A¢?(ç`>î">y™Ä??diÜ?DrM>ŒƒI>Ïè@?7†>Ê¥ƒ>*<„>»î>§J?~?x¦?^i?MPY?LB>MkZ>Ônl?E£Ó?@-.>àÐò=¬H\>—¥ì>¸è>V² >ÊÀ‚>´…ú?(„?"Ùö>Ø'È?FÚ;?UIÊ?æð?)ß>õóà>ÏB=~h>´S?,p2?)LL?-¼?ñ(?D€˜?6c²>ÎÖ>9Øô>§§\?R>øê®>ÊI¶>¸ú²?Ûf?N¢?ø +? +>ütÔ?½5?-*+>üê°?&Š¸>¨S°>¬‡>¢Â>ƒcC? ¼?Ab?4=¹‚°>°¶°>ñjŸ>Ü`b>ÌQÛ>ôC>ÒQ7>›í¾?%ŸM?W¶ó?k6>Ön?EŸæ? ü>ò_¨?J>2?Z3â?;®ø>ìI»?ÓL>ëÔå>Jîl>Ÿ»Í>ùo‘>àÔ?ÿ~? Ö>†õÁ>úUè?ik2?âú>ÕÉ>ý6? ú¡>¾S >òg8?j£s>÷…ü>ć,>ÿ®î>„c?•¶?Pö?)œP?Dd?A\H?v>Ó† >¸æ>®Hp>¡Š¤>|=x?cŽ>ꎤ>éb¢?;û¦?7†Ô? ÷ò>Þmà>bv²>Ñ&Þ?bÏÄ?Q™>ëh¸?'È3?4ƒ4?BfÓ>àƒ6>Éà>v-A>ƒ @>Í6‚>°JÝ>¼Ý?A}5>ÌÒæ>æÁ5?bZ³>Õa>–º>“»„>€> b>§nÒ>­–#=o„˜?ÑÒ?gé?;y±?<ßÞ?ü>˜¬>R±? ‡V?C¯?=wØ?øñ>è’À? ¿À?,Yp>Ì`>« …?4@ú?x?x=±b=°­@>‹±Ú?6ÓG?7rD>ÏáL?Ç +?á$>Âë?9î?dý">ÿ=‹>SE¼>¶)?kˆ?<ÚÖ?xè>êR>¦Û—>Û‡Ì?4Žt?’9>¡&Õ>S=c°=õÜœ>Œ³ß?T? +>Š¡ >yP?¢P?N= >â‹^?}t?i9R??ªô>üç×>××Ì>½Ø•?¥z?J?ì?Rm±>ó¹={Eð>©»\?(~?G9>íÞ&?7+:?>a>Íww>Ãs>Ë•¢>ëà…?C2?#øl?Yuž??¡Ì>u“>…AR?É”?$Z\?aDö?æ‚?bú?¬^> +>–;)>ÖÓ?&»ß>” í?{æ?î§>NÊ>ÖŠó>»w>˜cJ?cÀ?89>¾z[>ÅPï>Óí>ã±>Š7ý>Ü{j>Ù¾>ýÙŽ>óØ?ZÒ?J¼™>ÍýÊ>¦6.>™E=àTX>u*P?^Š?+q?ùò>¶;m>i6¸>þ´Å?ÀP>Ïnp>JÚ:=²>þE?,yo?'ä±?úB>Òɦ>Ö©Q?†&?¿’>ºUÄ?Dœ³?ZÄ ?$lD>çä>çô>‰˜=aµ >Yýz>%’Ö> Þþ>§Ê³?#9N?i5X>ío>d—²?&Æ?:bœ>ë¡é=Ž»à>Æî>’â”>AŽ>Eêø>åÿn>åöw>I>>h°À>¼¦œ>§ Ú>«n¨?9?œ?bûœ?Gý’?Xf¤?q0?;¶.?Eü?(L>Ý2’?=qå?8ž>è!m? +†?˜â>ŠU>t>æ¢?ÂÚ?XOü?1f>€ˆ6=®ŠD><8ž>Î1{>¡+Î>jõ>d> ]l=ësÈ=Üt$>ø¨ô?.ì=ú $>ðêz?hÌ›Ú=¾a´>‘ª=æ©>˜®ç>…Ò»>غØ?vØ>˜`> +Ô>¦èV?.ß?0ŒÞ>ËM%?´?+x? Íi?@R?N¥>ÂÝ“>Ϭû>ý6€?öÍ?/«? Õ½>²6¦=qè ?ì?Ð<šb>Î?6ß?=?Cƒ&?\Ü?Bý§?RŒ¤?`ƒY?xr?#ù“?a—?u–?>ȼ?Kc8>þJ>Ncþ>ÇDÏ>¾T>¥…J>î-Ž>èb¥?Zt°?+——>៤?ñÈ>²¦V>ä$¾?:xO?> +`?T>‚L>q>|>ƒsJ>IÅØ>Ö¶>QÊl>Ç©û>­‚¨>¹š>U?â>iì?¢†>ú ý>Þ˜º?2~?(»–?9Zñ?[n?+Û>žN«>8­>w)ô?n©?´,=ã} >Dv?ƒ˜?f•Ü?Od€?LÇÙ? êš?­²?I<>8Ÿ?'h?G@ö?Næª?gÓ ?Ô`>–ÃÆ?6ý +?Yhs?AÁª>ÚIî?á:?FŽþ>¬s4>´­ê?B/?:=>?Bè¶?z-ä?3¥w?:UT?b0?Y>/ߌ=`½>‰%ð?'çÆ>ä]8>”Ú?c?irÚ? §?"¾?9¦Ê>µ¯>šŽ>š¥Ñ>ùÔ‚? ÞŒ>ï´S?Ð?ìð>õDŽ>Íä¾>—çl>GÈ>Ðú§>¶4ž>¹\d?AŽ ?HL?8±?M®?,É>Ò¶µ>Ä9J>L2>aF<>ó‘>ùú²>}ïh=¸xT>^S>°þ…>mK>£:>«€í>:Z¦>þK??D ?K°Ð?LœZ?f>÷5ô?7L?"ƒ ?$j’?%÷#?°ÿ?5χ?1>tZ>?”>­0>íøv>°!š>oÆÄ>“ܹ>㸤>¢zª>r“? T?DÞî?+“ ?;jò?XÝZ?E$¦>é¤Ç>£yÞ>ˆ”>³^¾>ÿ-»?ûª?Ç¢=§]Ü>x0W>ŒŸ>>³g­?}`>c:>ì>RCÄ>a¨?I}?J¶\?-È?5î>ŒCh>€}C?H&?{×>Hõ>eP? †2?‰N>¯•*>èeq?1(”>Ϲ>¡?„?•Â>…fÈ?²Ž?1Îr>17=‹ƒð>äÛ¶? wT>žb>“Î?$jü?;Ø?.–ù?ZÞx?I8?JùÖ??À?,œ>¦œ,>Q­P>Ên¨? Õ?=,¬?O_3?$‚>­àw=?êt>»ðª?4Ì®>ù½œ>¾8Ž?1ù +>ÔVm?>_?&­j?‹Ü?g¥>Ïûµ?-=Þ?TPð?Ÿ>Š>Ü^8?*/P>«¦@>}ß?Kax?ÊÉ>Öˆ?JB?%ã?Åþ?aO>ï(>$Aœ>‡}?¨~?F`³>²ÚÉ>€|>£?"Ë?r0?_¤ö>ôQ“>l`†>ØQ<>½œ'?wÄ?,”¼?¹î?.tÂ>ý°o>l¬˜>ñ†??0¤j>…>™>Ž?þ>ˆT>&hâ?{? êÓ>¨Û>¡×‰>ßî? Š>Û‚7?‡Ý?)1?&ñ? õN>½Ö…>‰_Ì=áŸ$>¤s,>óú¹>vQû>©»À? ½ý?/§|>¢ý>8?KØ? µD>Ϭ|? %ú>ôÞZ>b&>ï]?]‹? ( =°yÌ>â8?5>ÏNY>Ï>›â>²‡>?ƒä?k ³?OèÝ?^8?'fB>B>ÆüÕ>â—(>òW>ÇTK>E*>ÿú/?Py?ž>y/ä?9·?0{>o ?êä?Ý´?+KE?"…‹>´Â>#>|ôÒ?>->?wÉX>èp~;Žû= •P>î*9? Ör>™÷Ä?hD? ö#>²ò? l8?OÎf? /Z>:Ex>B•Š?1®?AÏ$?1Æ3>ÿ!?y?ò>èR>ØÄÁ>²þÀ?&Ø$>è’n?÷?lo’?EJ?;ôz? K>4În>W‰ˆ>láÎ>b¤ž?B >õ?B=Îî„>à‹P?ca?-i¤>•3`?á>õ7É>6óú?þä?Eˆ?@8Ý?׈?œ˜>ÿcö?^™?Ut?]{û?[ð?@ýQ>æÐx>à U>¢Aø>ù«2?`ɲ?(3œ?-¿´?]v?]£?¹c>Óˆ=ˆàx>Ø -?éæ>™÷Ø>ä¯?7ë`?_·j?'??/Pš? +È> zà>&–>Þq">ë+g?)ùÄ?HE•? 3R?) ¶?"³>®°¿>6i`>©ô >·=¨>fÂ>F?¯Y?YyR?™b>dL¸=ôÆE=†>Žá">´v >¡H>¿[ó?³?;>ª?a¦¤>élÉ>¦ã¿>ñeé>F ®>†W?HØ?b¬=r{0=Ç @>¤ˆ>®Õ´>ø é>ô!D?Ê?©Ö=â³¼?Kî?&Ô>Ñ-ç>ÝòE=ÎC>ÈÉ ?<N?7ب?LÑ?—Þ?Æ(>–Šá>ö+x>£Á›>Ô<Ì?FŠ4?M¬S?E˜»?€>Ó">½U>ê­¢?]rÃ?6ÐÐ>ÿ·+?Ñn?UqT>ø4>ÏtŠ?YPe? Ü¡>tõª>ÄD–? ¤ˆ?’?0>öÄP>Îâ=>¹··>ó¸¥?LÁˆ?y" +?0üH>GÝ$>©Ö?M–?uÑ«?R²æ??n>`2®>ˆ:„?9~?1]?0DX?<5°>ãé >œNº>ü>ó q>ö®â? + û>¸ÂV=3Ǹ>b"?­x?uÞ>ðN,>è_? Â?T ^>ñqb>ÁpS?þ">“7’=^‡@>燼?I>³>Úè5>·„?A~?6 ? µO?%P“?›N?6Z¾?ª@>n7‚>"ºž>‹¡H>ÆD>Ôê]>¬L>£Þu>ÿ»X>È“?œ²?)·ú? —Å?GÂ?k®?Esh>Ÿ?>£¤Æ>ú–Ü>…D»>ßb>Æ=Í>äŸt?F}Ê>ë†=óé€?Ã">ô +>Ì¢?IÒ?´M>û9{?5Ñ?qÎ?4((>Ï“l>¯ý=±2Ä=ú^”>:.=L&>§òô?VçŠ?>ËO?'‚€?jº?xr>s¾˜>ß#1>¦ôŠ>ö“>?'µ>¯IU?H:? ¼…=d?Ð>ÒÍF?¨¾? Ñ>± n=%>=œ>œJL>Ü0u>Ü’ˆ>ƒ3˜? ú? ÈA>žP>¹„*?•¼?:g?¿¼? B>ÝYD?<°à?5öº? +oÈ>¾Ö«>• ·?'”?;Ï?ªd?6Á>Ášd>•Yk>†Šµ=+Q°>Èv>êĺ=÷Üä>æ¥?¦ª>ü“Ê>hÉ\>Z“®>Â<°fð>ƒ¨ý>¯ÝÆ>žH?-8ž?]§?O[Y?b ?M§?}*>u×î>Î6å>Ù#V>JÈ>“DÀ?F?ldâ?K>›;’>ßÍ>‡ãÆ<’Œ >—S¦? m? ø(?E©ª>þ!`?ÎÈ? ´¬?~? Œ>ƒ\Ç?aE>òƒ5>uþ>G>–{ ?q¿?K¹>æ +?G÷>Ø$ú=öYô?$î?B+û>º¸>¨0>äº?äÐ?U7ì? +Œî?*fN?™‘>óÉï?Cà>Ÿéå>ûMY?Ј?*3Z>»A÷?*ª?`>ÇaŸ?!aÊ?>Ü}(?,A|?RøX?@¦_?4‰>ËZº>7B?)>¶\f?€Ö?MÙÅ>ÄO.=ÕÏÐ=ì¥=êc<>Á#•>°—Þ>|Òø>³Bk>î¼Â?0êv?,ÈÈ?®?,ü?*K&?$@¥>¶7‰>f>³lô?6ö?CÆ?4êÂ?AÓü>ÔQÁ>ð¦>äþŒ>UF?†j>… ü>¶kÂ>µ$&=„ÑH>Àäã?QÙ?)Y‰?/.?cžö?Y®ò?í.?0hN?¤>e|v>築?CN? Õ>œ­>1j6=S€>^ôø>_`•=3K°>Ècø?Z*Î?$ >pä >5"À>_2ú>Š£K>¬(? ï$?55/>Í…¦>àKÐ?X«? +ó?é²?+,>“çO>IpÂ?¨‡?}4?cce? œ>fóÖ?>?Sú¦?Cœ&>´€ž<ÿ’ð>°f>™¼S>Õ5?i–„?z96?j‰Ú>ݾ²=J€?Š?GÉ^>£?’=`åh=7 +?OA?S?{:?\»œ?#Z²?"î?mÌv?Y–=Î+t?šï?aj¤?U}?=^*?Q¶•?0rþ?$~?O‰´?o™>»È>?êœ?ʆ?f3?It>ø¥µ? +Î?¢’>ÒÅ)>Ï>–þÔ? ¸ê?)—ø?Qìˆ?pØ'?_9æ>Éüz>MøF?"|?P°á>â½>@»}?-Aù?oÂþ?j˜¢?zÈ>]0?!vö?n-¡?r=?T›j?5Æ>ò >÷(¾>ø¾C? ì¤?=E>á|¤>YV> „ú=þÙL? ð?&Tk>î2È>´ê?,?w¬š?>¢ß?9³æ?x\?U$ü>Ê–>Ήê>×q?ø±?k î?<,>Lv?VÝ>èú’? +3ü?.Ö ?ì|? –v? Ùb?Mþ ?M¿?Œ¸>·Äñ>“‹?°?±>i°Ô>EŸº>ª?S$§?B9>ŒÝx>8Zˆ?Çt>Ñ¥/>ª­_>âïw>2@>Õ¸6? p>^D>Øù†?Rà>Ä»>JZZ? $G?Nð¤?žr?zL?•d?p~?X`³?jF?S(?¼(>åo”?L²$?U¬h>ºf°>¤Ñ³?CDÜ>è¦E=àŽh> ?û>Ǽq?2ÈŽ? (=Ø£$>Ö÷s>½®Q>¶ +p?"ˆ?‘Ó>øƒ¤>ãÐß>×7Ð>Ái >¼œD>¨œL>nPz>º‰©?…Ò?x*?»?'ƒ`?a§•>÷xo>__.>çr>ãW>TBÔ>Æ‘˜>c >rÞ>‰¹1>€?j>ž`>öt=•» >˜èä>„Dh>JXN>hàL>»E?0C–>Ë*¢>y;Æ?dE>Ö–Æ>íB|?>Î]?L¸¢?I…¨>ŸŒ,>[là?;?Ž>×d>šý>õT»>ÖŠž>ê1½?ýZ>Ò·?C‘D?Aõ?=->õ$õ>v?×Â>Í+>×ZA?1}b? ¾?$ >Å«+>ï ?Ô¹>Ø!×>öñ=y¬(>x?NJ?$9Ø?P ?*"Í>ùhl?e>è³?´?MBÒ>åĵ>Ø->ì÷_>o™>ß*5?¹f?Ÿ²>̘??X†>äµ|=6Ø=ÕÏD>³sv?0å?aÌ>B=È? âóâü>€zk>D¨è=ð+h>Ús">Õy’>ÈjW? Qþ?ì^?•>>vŒ´=2å >Ó‹`?[) >òª>D—8>¸C?5W>?'ŸÅ>ëÉe>”'ÏÎ?Ê?%;V>ŠÊý>Ì2À>í'? +‘¡?tÝ7?züc?}ª>½X.??!?CR0>®|>jŒ>òÓa? U>…pF>¶ÿÐ?7¸º?Fݳ>ð{8>e}P>Ç$>@fÀ>Û|?DMš?tˆ>û²ÿ?^E­?'aî?ú?g\Ï?Ñ\>ÀÓ4?:À‚?h==®>´>¸—Õ?Nê?@Ôô?Hg¢?HŸ˜?8£?&?;ß0?A±>ÊMã?Ò\>À¨¼>ƒYO>¾d>G#>}Žšš1¼>×ƨ?y?$¶®?Z¬?0+î>ãI>û>?w=Hh?®ø?öü>˜Ê´>ØyA>Ÿ+>Ãýl?5<ü?(??N2&?5Y%>Áv,>ËÁI?%i?=~M?UÚt?%ä?",ã?-n%>6ú>£aÑ?Pq#?Ô¨?D¼?d­P?'z? wÒ?ß¾>ï¦?7]>±¦> `c>ÚÞ@>eô\>÷N?V>’,??&2—?/Ú>Àí?!zb?Àt?%½`?:Z>Õ³>´1ý>š§?&Yå??eÏ>Šw=h >Û@´?Xµa?qkö?=Ü> ? <?T¿b?UÈG>ùý>êðb?B®?T¦?,@? ’D>Ö8'>õõ>Á@æ>Ù”°?IŠg>ú‰^>•.>©?ì3?VR?tm3?AO™>Õl€>KÔž>Ù.À?-ôÈ>ËKÆ>Àܯ>ì?$ö>ãk¤>=>=+z>©îP>Ϻ2>ê‚)? 3w>Ï©[?&?$f³>¯šq>vp’>ýìû?ÿP? &b>žc?Ed?0eþ?e?DÑ<>ë¥=píð>ß÷#>Ü”H<¾¬ ?V?üÄ>Ýý?rÍh?-dÂ?¼>·b°? Ñà?xjŠ?áÂ>)¡>Ôý ?j=z?>?|À?gì?‹È>@E>Då6>sÁ@>µé>¡›ó>‚ÌÕ>çaÛ? ´?Pwö?£È?÷ì?eu>K®? Ö¶?<Ñì?ÇX?M–~?U$ ?C‡–? >¢Õ™>Ò„j>çi‹>Ž°Û>ê¡0?B0>?XËM?I /?h>ÞàÓ>¾ƒr?ég?K»ú>Ñ í>ªò*?@zL?a`¤?¯È?«0?Yª?9,ž?BUd?øü?7d?j¢ƒ?ïˆ?H@?&»N?&Ž(?Sˆ>ý7¸>µ~ˆ?ô??\bh?NS:?I’Ö?)' ?J#?uÑ£?0A£>¡@Â?õe?8ú?=½b?Kï4>¨Ö»=pëH>Íì4?ø>–á>øEÓ>ì\:>šFD>¾ÿÝ?Ás?@+J?T’??!ÅÌ?Iö>Û­œ?*Äð? u¨?ý?'=…g„>¹i@>ÎKj>ýÆÁ?- ò>Ò•>¶ˆs>aTf>îÙ˜>ü P>!º? ‚Þ?8ˆ?ê×?ö?.9#??>RÞ">½? cü?»Ò?JÔ¼?F]>À‚^>/?²?mú>„üù?"œ?7«?×°?PP?i¥Ì>Üï\>z +L?^é>Ó|Æ>ã´>öXy?Bb ?_@”?ðÇ<º/?h?_UR>Å>ž>¾|Ì?*"c?)d ?B›d?Hë?$ >ï2¦>Š£»?²Ž?;‹„>¯D8>ëgÔ?+Ä[?!æ?=-2?@‚>ü¶Ê>qv|=Å/$>ŸLZ>ÆI¬>>¢>ü,Ò?&£?çT?Oã>àÿ>ÿd?F­>Û¢Ë>Ò@ÿ>¶®v>ˆ²i>ö˜W>̪i>£¼>¹TÆ? à=?˜>ùH’>¿ô@>XX°>ïÏ>ßï>é…´?0u2?/aš?)½û?J>éÛ'>z¶&>_(æ>õ3ç>ÞÏ0>ïs?9Ÿ>÷">þª‹? ü?ã2?¹©>Ò¯y?Š?B?PëK?•A?^Á?M?"üä?Sϲ? =ÖÎè>Æ`>ãy5>&H>¬>üÞQ?3ïV>²×ó>jÐ?}°?C”ž?Û~?NOL?)‡ >>¶à>²Å!?$„?-¶?@p`?V"Ö>¶Ã>¸BÄ>¸TF>œãÑ?5ž>|Æ =¶‘,> #>Àö>_õH>ºò?N$ˆ>öÐâ>Ê´3?D†>–É;?l?^¾Ì?t϶?xVŠ?Ÿ=4åx>ÁOM?G2z>å–]>³©?Ïp?,Œ>Š U>€¤“>£ž¼> S¼>!œ>„þÚ>ìžÏ?)Lº?)„z>õŒ>ä¢ð>µQ3>Ü/Ò?^¸?Z:Ù??à?%Úp?+„?L >°øœ?“?&b?8‹?Ck–?“>’¬Ï=å~h>ö4£?´–?.Nó?HÝ >Þ’>~ÄÌ>Šø˜>}é(>ÖY>œÅ>§VØ?µû?%Æj?fö&?:(>m>œT>îá? b?Wê?q÷>?$7>ï\? l?>”’>øZÊ>è”.?3t> MÎ?N6?+r ? +gÛ?&†> e>Ø©g>Çêù>sx>+L>¿ ?X$F>ìDF=úÛd?Íî?@4l>·!Ö>6%¾>k}6=ñŒ=£ð=ÿw”>ž¾l?%sÖ?%1.?^?Eþm?X'¢>ã=-H>üFJ?Î0?Ú8? ?|¬?/;n>SŸf?Š;?¦3="} >׸î?: >/w \@¨>„ ,>`=6?žÐ?U“r?>>Ø?$Ìq?AyF?#À¡?$¦—? À0?µé?3(? ÕØ?,’?Hã>¤‰±>Ýó—>…ã>ª)¹>šmº>ãÜ?«²?´d?yá>ÖžÁ?*…?Ø”?AÏ>ù>ÿu?òT>{þº>ólQ?H>‡Í>«.h?=\>à´H>Hy(>•õ>Þ?Et8>æ9\>üçâ?³?Ù#>ãbÙ>’"j?˜?ä?Æí?;°$?ZÕ?M ¥>Ë"”>ñ™Ô?P? å÷?2PŠ?J;c??™_>Í]ô>Ÿ?þ?_Ñ>½S'?ôû?6Þ?CH>ÆY>±È>Äè¹>˜·>««£>õ(†>ø¤?"‹F?T”h?]ǘ?MñG??.>ÖN>O÷v>½'?‘×>4 >ó X?Õª>¡Î>ÔéX?CÇF?EO¾?4U{>ŸÄš>†Ç¨?CÊâ?7<‹>º:í>ØÞŠ?úü>êá9?Z?TgÀ>Ýh>=,Õ8>Ÿ>’ê=ÞL¸? iÌ?qÜû?o5´>ún²>õ¦ú?1ÿU?KâK?"c–?®j>ðÓm=¹ ?3¼?92>¯Ež>êe‚?L<>åf>?YB>|XÈ=`>ú ”?i9?)…”>²2ß>.9¤? „*?E¬œ>ƒ6M>œ‚§?6i +?nØ?&:c?Fb=uxx>ºs&? +ª\>Ñ8û?&„?QÁt?eÓ^?Lº:?'œ>–»™>k£‚?E2?Is˜?!Ë">¸È>ììà?½»>›î€?=‹?&Ìm>Ƨ?7%? F>ºž=>׉†>Éb>ÒøÐ?5òk?lÊ>Гª>¥™v>¤ Ñ<ÓùÐ>ªÝ?ô¬>È2>J3>ÂéB?Ô*?Ïç>džT?!?C«1>ÁŒR>¥Ü>ÇË>rLD>ßùz?@Üô?9´>â9>”óÞ>Ûcu>öúî>“ÿ>­+$>ËUs>ÒÏ>Â{•>é§o? ¸?(Jì?—4?!¹>?T"S?0]N>fˆÜ>ÌÍ(?·?š?V˜>ì +¸>`(?è?ee>å‡6>éF?>¼0?û>7âX>ìíµ?Sš’>Þ‘> YÁ??Mü?LQÂ>ܶš>ÿj>ž2œ>Ö 4>†j">°æ¯>¹´x=ú“ì>Œ%?;æ€? Kl>"Âz>³Co?=‚¸?60>¡Â >É€G>ë—µ>Q +†>¿ä\?¿š?2äª?.õ>‚ªÊ>oa4>ÐVµ>Ŧ>²È•?Üã?>=?-¢’”]>ɼ˜>çz,>òE?[A@?jf>?]Ú>¹+Õ>çÚ?]h?îV>¿Œb>ñgç? J?4Mð?dLH?cËî?mÓ¦?IȤ>÷`r?[Ö?KŸ|?K“?&Ö>¸² >ÝV ?UÊœ?-Æ0?(Þ0??$Ý>ÒA¤?Êv?^a—?\Ôý?KÍ…?-Œâ?Ô>Ê»a>êÏÁ?Ñ?S¶?C7ã>Šúê>T£>ÜX?+:?3*É>ÄDö>ɤ@?AåL?2nÒ?-•É?5j$> ü?ÿ?~‚>…”>îù??XB?˜?Šù?Ol>Æ’‚>~™¶?.¤–?*=?)Ò?¬Ù?p?O' >¶—f=?Ê>×±@?MÄ€?ãÖ>™Õ?ŸU?jˆ?n±Ì?¼>¬p©>šR—>Ä,0?è>u~~=Ó»4?…n?g›b?i¨Ì?o!ˆ?6Íê?8=? ê­?0?°>õ£P>¡[>ÕÁ ?3ˆ>ÓE´>®}T>¼>ŸÊ>ÁL&?=º?=>Y0ï>Œ[¸>cS°>÷2:>¾v>ª|9?›Z>‡Ò¶>þ~Ø?=jý>€õä>—eu>õ>l³>ßkê?Xc?L…F?jl?&ìú>Üv{=Ȩ>Óþz>Ä›&>Ø*?Ô|?#í8?lßž?Üh>Éí>Ï9>“Å>ê]î>ÏV? £L>¼‚ô>›mÊ?D ?d'?2;Ÿ?!º>ÑX>¸ä?’?’@>îͶ?í¤>ƪ`>ÊËd>µD>ö,?A>ˆ?@ر?A{Ù?.–>Ø! =_i§=nÿ>÷Wü>èj=I‘=ÙÑ=¢Q®>HÉ>ì„Á?Ebí? ³|=£c?¨?êG>Õî?[k`?(¡™?3"ä?*²>[{¹?öc?F(¸>õf’>'>#ì>îr›?L>ÖcX>®—>Æ\>Hcô>¶û”?„D?30†?YÔ’?L ?S¿?2,?Fã5?˜œ>|ô¡>Îd>›>µßJ>û)C?Ôç?K;>ßë? + p?g¶Ã?EÈ?Þ6>iÄp?ë@>ñü…=xf>¿&ì>ؘÃ>½CI? U>é`?U.>þe>óƒÂ?ë(?)¿Š? Ð’>3(>’Š>ˆƒa>‚¿’>­Ó?b²?=[?=\†?+à">×£>M{¢? ¾ä?O${>Ñ„ö>m>áô”?m£>}éZ>+‹>àÎw?4æ?oC>L›d>«¼>²»=?ê¢?5%)>À)¶>²˜t?È›>Çê>Ù%&?3:à>üöÒ>€¿?>j/Õ>f½p?PÕ?DÎ?WUp?*Û>p¶Ñ=û{:>³‚K>³>Ïr?¡Ã>Âpj>çÚÞ>ÂH?dÜ>ÜUq>ê€? 1=¼‘N>?Õ?À¸?q¥Ž?-">¬ÅY?Ff>ÄÂÜ>êß?Û >±â$>n+d>äÞ>¥›ä>Óð„?S ‹è>¶Ú|? ÈÎ>X™Æ>ºàN>yäU? +J»?1Ç8?ûj?7qø>öž™>ä/A?»>åÞ£>lÝj>óºÏ?.”>þ"g>ö‰,>Ùàâ?+á?mÇ¢?WdŸ>Åù>L? &+?¢d?0½û? +¶?Úø?$>Á¤g>µÒ?ªw>ãž«>í‚“?D£>Ú#X>õõw>Øù@>mmó?$$? Î>ØàÆ?¾r>uZ­>EWŽ?;°t?_v=Ì¿ê=»g?>Œ?ø>Ó7´>Hs=’¬À=™>ÅåŠ>ÉV? ˆÄ².?Î?\Zo?º¼>ëξ? ?H] ?töÒ?[ÇY>ÝA4>Ààò>¯D>vÔØ?¸?L·*? Š>³±?8?S+;?_Ls?B¸Ô?ð†>©Ð‡?º£?8·4>¨8>w¹d?D:?!Y˜?P·?føÚ?.tÎ>³ØÌ>·˜?>“ >óÛU>%ÿ?>²r2?_…>Þh=ýŠY? F?Zeê?½œ?Õ?\$º?r¯Ö?{§k?D°>ý‡>¢ßn>®«Ö>µI›>œ*Â>ÈGâ>É®¦>»’?P,>ù¡Ð>Â">–>²t?j¾>åòr>kl? ¹ä?L[?^\.>èÖš?Oœ?5›„?#<Â?w×Ç?5—à>ñß>÷—*?=°r?A’?~©? œÊ?-Ó?72,?6Èü?'¦??W>Ų¬>Úí0? Ø?ü>«0Ö=rëä>×"?CIN>ÙRî>Ýíª?^‚ ?t/ª?C½€>«­ >ìþ„?&ð¼uz>(N=iÿ—>çý ?oêá>ýQº>ÄK >û‘?Á¼?p=x?5ö˜>ÌQÅ?'nò?´?‘?r»"? ´>”gm?Ï >þ¤×>íàÈ?-S?1à`?kË`?gáq?BÚ?+æ?W>öÞ’>ד©>B–j>÷d¸?J?'>]8ð>?,=DÝ/>¦â>¿CB>o=¥ô>ÒI#?L M>á­P>ÊA_? “>®1?2£ª?+Aò>µæ?>Û?Rö>ЉÈ?!ÝÂ>½ºT>ðÅ ?=W>´è >ÔQè?ž>­cò?CŒ>Å- >Ì@è?0ó˜?#›:?>Pû?P +»?^À¶?q*>Ò”ž? ¿¾?¡ò?HÎu?ì >çÀ?r;>¹ÇZ?r?@´K>­’>>DP> +Ôò>(üí>`"g>õL@?N±%?¡ù>Ò]«>׺H>¾>EP?t¥?!áì?7ê>úpÍ? ,?cÔz?)=–|>ÓóŒ?A?#ê>œ¨·>iØ>ÍÎÖ?‘*?¯ö>Úz? †r?9'¼>óD`>a¨$>Æw¨?6ß÷?ná?‘÷>׳h?Áõ>Ž>È°œ?>Ÿ?/>D€•>eDt>¤«?’f?I+Ð?1—Z?À&>÷ÉÃ?*ë®>ÃÓ¹>Û†`?Oe­>»„>º¤Ñ? *®>L³>Æé?6#¾?)G<>ð¶˜>[šÐ>#h>žR>°¨H>¬¡Ø>®QÎ? bZ?6PY?0ö>ùVÊ>ßuÅ?Mˆ?6¿?¤æ?+hˆ?Q +?Ô?,0f?tê0?V/~?@–>i]†>VbT?"wD?Ds´>ÛÊÂ?7ø?!œX? 2Œ?[Š¶?T:ä?3”t>þ¼ ?°?Î? ïÍ>Æ"’>f÷>?ç÷>óX&>Áó?W?!yÖ?~¨?›’>Áæã>à4>§Õ¸>+jl?R.?(~>—É?2‚?\]5?©‡>¬ˆ¼>ÀÚr>‹ç->ŠÍ„?óô?aÃØ?1îX?ÿz?ô?‚?BÎÊ?¬=?UF?`?Oíx?8Û*>Øœ¾>![>–:˜>¯Nº?è†>ðŽü>Ir[>¶aˆ?*.ü?$±Ž?}ÿ?¬¿>·6Ã>æºf>£Œ”>}DT>ªZ.>î>³â:>ãZ?Dñ–?91¤>÷ÝŒ?A&?ÒÖ>¨oŠ>…>‡=Ã{T>²%˜?é>°T†>—æ³>Ôð>³œV>‚¼*>'¸> õp=Ä¢¤>Aþ§>Ššü>¤Á?ØŠ?)š6?>9³?*l>Íý? “Ê?tÛÆ? Œ>;,?$?~#>â=1?=˜©?/þ>öiÔ>û{\?$¼?.ô?N‹?]ú>©u<îsÎ> »0>–>ˆ•J?–>µÎb>‹v”?2á¢?$3&?o“?K"°?$¥>m˯>E=ú@æ> ™?êž?=ÞÄ?2µ–?JUÞ?< ¬>õ$¨>²Þ&>¼ët>w±ò>ëàz>ÓøZ>×b.?0 +?CÕ ?"D2? `?Wou?$hô?g? ýH><>ž}>ãA? +£b>ÊÌÎ=7Öê>HŸr>°g‡?m§?Vj¼?-{*?!£–?A|>ÆÿÙ>­D>Lpþ?të>í¼Ù9f>Þõ?Pûm?MÆü?EýZ?CÆ>ãÑñ>¨¤º>ò>â´Ô>ÜsÞ>…~Z>N> à>rËÆ?ƒ¸?7U˜>×-2?Ò?%’ >Çx +? :?@J>¦DÆ>§ w>ñJ +?<… ?Vjâ?T•?5’>÷Ö">å°>>Œ*Y?÷Ê>îúD>9ìŠ>ƒÏÑ>Çf?yì>ßê{>`@>Qª)>’t>¶è?'Ô?ZŸ”?JÄ >¯Ë@>H¾>îc\?0[‚?¬¯?Ê´?Ddö?&'š?Ó$>ž‡Ì=hŽ?s?JQ>Éq ? Š›>ÖåE?k*?·(?\l?$Ø?¸ >ù8D= 7=ÃŽå>A^?æÂ>ìò=ýb>Ùa¾?'0È>›–>Ód?‘ª?&¾‡?>Ef?]ÇZ??•?I´>äQº>Jç"?Èž?W>·z? ’>·vG>Îcº? ™?"R?3ÇS>u9>Æt +?;¾?Q‘¿?d#'?-ü€?.Ô(>öˆ? +æ?Z6ì?"€>„x*>båª>ÆÑx>þ“Þ?Wï}?%¤?6ç?T³<>ÐLç>Óö? öR>Ò¢ >N£b> ݘ?ø¦?.…5?þæ?)ª~>ó˜>WŸ?ut?BX>V† >øÉ?;Ù>Gš>ÄZ>èü¦>Eï8>D»Ø>å0Û>ñOž>2êô>”=ì>Îmè>ZÕ>ªØÜ>Üût>è³G?,ñL?,ò?-Cô>äE0>Ä x>Úm= ñW>¾%ó?B"÷? Aj>»f?&üÊ>ó^>’Ï6?D?1xü?1:Ø>°•>öâ!?U£ÿ?C^C?;uØ?‘÷? 5 ?S†3?€?úâ>ÉÆ?Fè8>éVˆ>ŸÆÒ>µßN> °H>‹@6>êýô?D?;g?=#é7n>‰»>ŽYô? B?6¸>›œ]? +8·>ñÚ€=Éé=>×ôî?î>Á5 >Ù~à>Êãä>}Gh>êØ?@Ò"?Li?*‚ü?3íb? °–?-½ï?OÒ,>Ü;à>ù=‘:>1 +>îÆÖ?Gî?_Y2?K#°>é¿ä?Ù·?h:J?V/>¿Ÿ´>ryº>§/m?áÈ?fx>Û Þ>¤”ú?PãH?@·Z?2Þ/?];Å?#^>êk¸>˜T0>„lú>‡¹Ã?=È?:˜v?E¹ž?-J=? +€R?IÖ >ÖCÂ>õ®>†?.!¼?lHo>ëÚØ?å»?QJ>>ª @>½Ep?KÑ?aÂ>‘>—¿_>ùÜt?7Ó°?=w:?\·Þ? ¯>Ý ?2`Æ>ßë—?Ô?;ô?3Ãþ?xk$?p¤ ?.ýX>¶¬H>ÞL3?X”>ì;l>±¸ú? +™¾?Kjþ?L ”?60Ô>•>w>÷´>õý0=©T‹?t~?C8·? ì?@Á¬??¼? %>ý«>ïd€>þ ¢>‘P>Lî>Ù =8 r>÷9ª?EÎ:>Ðo°>ëšg?!c5>‘Aà? +„´? T\=@“û>Â,>6÷†=n>°’>É´>°ïì>ÌM¤?¢?~¸>²GØ?%~?¨³?Ƽ?Òp>­îý>ÓÊr>×5?">Ö,ˆ>‹^0>ò:>wÝâ?9Ü?2Ì?J†¿?y( +?Pô>:ª?`ú?±¼>ã£c>û_>¨>”’¨?ºj?FÌ“?EP>V9>ç¨á?!FL?n?bq?*¨ ?bä?S|Ú?µ>ŠOŒ>yÔ>Ϊ^>÷Ë>‚ò>¸[r>ûÈB>ìq?2*’?!ê>äî’>¡æx<Û¸Œ>¹’>tø0>¾Lš?ö,>ºp>¿Wù>«ˆÉ>`®6?Ï%?"ùÜ?¤ª>â h>ç6?\¬À?Pb?P$d?i½‚?Mž—?±)?µ‰>Ì¿Â?è>ãfÊ>ÄÉ×?eö? %.?mÕ?è}?"øæ?C0E>¨Ø«>]'t>Dµ>À›è?Qç–?p”v?D#æ>åÏZ>ê%>ûqÈ>µŒ?Ú?'6 ?$ B?<™a?3uµ?DG~?®?kæ?8¶?Mš?*íœ>÷^?'”2?#„(?m >ÕÀ +?Åð?Q©Ð?"i?2w²?Gef>à“@>`c(>÷öZ?M¥ê?Eð>oª„>øœ(?H»¸>—c>?Ì ?+ °?&5F>ßq >â…N>îÂt?¤è>Ñd>U¦>8 C>éñà?åz>òµn?¸ +>ò‚ð>â‚Ù? pï?#Æ?[ ´??Gx?¤"?dMÿ?E”þ>Áá_>Ôî“?6ïš>ÙÏŽ>uÛ©>“ļ>§Óv>·[>ì?*˜•?\œ>Ev’>¼ À>³mq>a‹?‘?"&8?5£+?dƒd?"yL?;5?MØr?Z˜n?Su8?' ?(oð?ü~>¹rà? ƒ>>«¬?ùÒ?*Æd>ÑŠ>ûêü?Í„>ê5À?”>ÿƒc>ص +> =¨Î=‘‰Ù>´Ž?ø‹>ß »>¶#t?#š?Sóí>ý°ˆ>–™à?)Á–?-'>Úç ?"¡¦>òJ@>àË>ßü~? {~?#Hr?3ã¡?3,>¦v? õ>½£/>W,n=°wŽ>êä?ä=§m>šBý>Ë£>nú?ˆÔ?8+>¾¡>@ž>·€T?;£p?(y¤?6 ??µ>ñ#ð>È™•?Të÷?Têa?4>ÌÁé>®ó”>¹8ž>ØÄ?Ýr>„Ð>6…>Ÿ6è>Š<ô>aÈX?/52?h‡>Éú6>áë>íÀ7?lÔà>è×8=Ðݸ>ÅÀÚ>ÁøÒ>c¯ì?!ˆ?>q?,6;>¬­š=õ“l>(¿H>«1š?+M?‚8?&ïÔ>㉺=ÒY=Ñqã>u#>–l?{? +DŠ>óøy>ä˜Ç> L'>’ý2?èš?rò ?Oîœ?,J? Râ?9ŸÍ>œ<>b$>r6â>òÙ˜?Æò>‰?Á?lÚ?&Ä?*j@?Cþ?X‡t?;æ,>èxœ>\>"=´.…>0xb>!qÔ=0c +>b'Ä>Ø>YÎ>¢—Ô>¶9>ö&¾>Þðx>‡&°>èâ`>Çk'>`c2>…h>=“ðø>Ù± ?Kó€?NX??ù?=hF?"–>åõX>þQ>‡Z©>é[ˆ?] F?k2?l'Û?c¯`?võ–?1É’>^Þb>žÄ0?+æL?aIÈ?¾p>ë?&¨x?h>ðÙï?eÔ?ÚÖºÊüÐ=Ð'š>Ccü>tœŽ>âÀ|?Eæ?.p2>›£ž>­Jè>”à8?ѧ?S„>ß'—?B’Ô?6~•>ôR(? ‘?B¨ˆ>õ5~>Ãò~?É,>g˜?==?o2>?ŠÁ>“-??´È?\SÓ?­Ü>Š…?ÒØ?P[Y>ý +>œïV?NÔ?Qïì> ¤<>Ÿqv?7ýö?$×;>œÿ,>yÁ2>ÛŠã?©Ô>¢Ÿp>Vsú>ÖÍ >¸9ž>Ár=iIO>œ@>ˆõ¨=}¡D>]‡>®t$>Ñüž>Ýq>i´>ö7„?fp8? 2?$“?c¯ ?b•‡?ºt>·ÂŠ?@ûb?>Î*?,¨=?/'s?7(}?2ü¸?%ôñ>á:š>µÖ> WB>M,?x?Iáì? î”?õ?mü¢?;¾à>™Ùp?í?C D>ÉŽ >Ð=H?ÑK>ŠLz>˜Gþ>§B=<1z>â3ˆ?´-?2Ö?b>a>ë%®>»¿Õ?9;×? +P>¯þµ?ņÆ>°$? G¡?)Úò>ÛóÁ?%†?p£1?TT‘>ÝY)>É…>Û5‘>ûµ?-+C?-C*?-o©?"Ĭ?Xȼ?9¿0?5«8?(d(>…=F?£^?[*ž>³sœ>ðËP?SšÞ>·~>rÒ´?EQ:?3 ?-º?2²?Åä?XrÆ?:ü? +R?',B?PÖ>Ëšƒ>ï n?%æì?h¿§? 2[?^Ö?m°>ÈF>tÚ>Æû?)&|>è>Ãå@?/.z?fy>ž{H>û,u?/ÿü?hÕ„?2´> RG>Ý=è³a>XØd>¢EÜ=Õü|>Øuì?dYr?Û'>8Ú?ýš?d·Ü?'^>ÚÄd>ß4?+2>ßا=Ø0`=Åñ>?È–>øô>–ì>?1Ðh?ˆh?):6?,§Ø? E>øh>ØHà>÷ÂT>¤Ã=?g"? +O¢?>fú?evÄ>Úžä>Í[ª>çà >ˆ=.>M·p=VÌ>Ü×â?ùÏ?(\™?Bצ?,rÄ?j´?~á¾?:ê†?Ù@>³§Ž>ÈP¼?hü?i?/1:?  ?*¥^?PF?>K„>¶_ü>Øp?3V²?PŸÉ?,¼Î>Þ]?¯T?…À=‹â=Ëü½>°ë¢? ~˜?5Ç?I3Ž0o>ùQ?9JÚ>°Ø¾>ÀpÀ?:Ö?^ŒY>ÖKz>£Žp?%¶>ôe>Ö—ô>ÓðÀ>ؤ:?+Í>×BÆ> {@>¬Œ?Ùà>ì€ê>K?5[?)G"?ÃÓ>àǶ?4h»>ìÉJ>áW ?0XÀ>Waš>¿cõ>ßU`>ŸŽv>ç±?.P ?P§?Gîú?dlÏ?D¼?M#†? |2>÷jZ?8ô‚?K†f?Ngæ?-´?­“?Úß?ÄB>¿Ï>u»>¬P?6Â?1nð?OiF?IY€?8_?–>å¨>ã©X?P´ª?QÏI?V'T>µG—=Wã¨>=†>ƒÃl>Ýj>´™¤? Ïz?Í>[®h>ÕµE?P?‹ë>‡ñ¸>XV +?zN?Eë?d)\?»ó?­«?mh?0>à{K>Î+À?•(?U#Ö?YD ?2.>ǘh?D?HÏœ?;Â?6©›>ËWæ?½¹?hZ£?) ?Cí?¿l?»Ò?3r>ät?W´?!çú>"Hi>û@l?E! +>ʱZ> "¨>?#Í>ì‹~? :>Ò€>ê°n?4‡¾?øê? š-?Z ®?DV> Hæ>ÛD?.ºj?O‚?¸˜? ¦¶?mc:? ÁÐ?É¢?n³?º>æ}Â?!D4>º`9>wóo>¶»X? #—?e€Æ>ý8ü>Ü2ˆ?:d@?)~?:Å"?>o¦?DßÊ?ÖÛ?,Z?Ó€? ~?@ |>§NO> [>±£`>ô¿8?@G€?+ñJ?Mô?l’K?W‰ï?U|¿?qgÆ?hîž>é½*> ?y? :Â?:r? 9ê>ô‹Ì?P”l?gØv?ÌJ>L,>Á@.?+d?6Æ“?al†?2ÙÐ?—? 2X?)î¾>Ó!n?fÞ?!x>n6>‰)>ì>÷ɺ>bͦ>¦‹?* {?X=X>îàö>‚wB>« ô>—vÙ>Š#‚?í<>ÒÄy>÷)R>Ù%Ž>‚öÿ?4t?Gƒ‚?%:î>@¸X>Þ-?]–ø?'<%?n?_¤ù>ÿ›$?åx>èf>AȤ>×è¹?ª\?Xù*?mb¸?L +Ç?FpÜ?_È >ØDp>ð4¢?¶ð>Ò=Ä>’h;>ÆlÊ?'ÝX??)?"]?F>§ïÛ>‹;º>¡ Ø>vjb>,žÆ>Né>—º?~¹?Sñ|?˜Ž>ÈÑâ?)‰>ù׆>¶ƒN?2¶?U~?íò>ÑIÐ>×\ï>ÑÌU?$Êø? š>ÂS +>ô%°?õÛ?#z>‹>Ê´ç?1Ú4>ÿ0%>uÂ[=©>ï?>F*>ÿ)ž?))?-¤Ä>]ö>°r?ß¾? ¨?mt>¶·j>• Ý?„ê?)’ü?Mý?;dU?KÝœ?À§>—*>¢0Ð>±ï~?hß?Q”¬>ýYñ>B >üÅ$?ž´?)hÊ?0:z?=r ?W ò?æB>ä·”> ˜H??d' ?n÷®?9‚C?;F>ë>õ>1ú>?Žã>–Gø>˜”Š>œ'N>¨éG>ÿ—f?a’.?‡a?C|?*÷r?¦N?Íì>“Úí=ä³…>$”>ܱ +?0»>·=N>íAš?tôˆ?C[¸?Q ÷?S>qâ>.“Ö>Òè?S?nXÆ?JÙÊ?—|>†²ò>>“~¬>’›D?Z?ï=ÜXN=ÌþÞ=Áòë<ä=˜=‹™ó>é&Ø?B"å>¾ˆ(>’I? Ž®?3Ô?0¶Ü??ùb?w$?MF—?2؈?>Úk?aÒ?K&;>¹§x>ï?üè>ã¼>{EV>ð¾`?W ?H$*>ùmÖ?.wZ?X¶Æ?UÎx?yÞ?2\ì?l¸>ý…¤>æ• ? T>ê8¢>³E‘?!­Ê?JÉä>â«Œ=î÷>ù7"?(ù?#Œ?#¸ì>=#’?þ?)öp? >ñ$Z>îpž?,X–?^Æ?Sã>ù—M?FÞF>¨Ïê?T?eÞî>ôèÆ>ßÄ¥?Ml4?$KÒ>\ B=.^<ûö?¾â?D>>‡)><¥Ð\>¬H?5) ?WC >þV:>™ò>ˆ?Qú?mu?¦‰?Ío?D•o?61À?5„>F…>P>Ô>ƒs?È&>÷­þ>“݃?Ú´?I6?7s/?&¶,?Nò_?yML?PÞä?„O>ËŸ¼?¦F?AN?øŠ? À?9!‚? à?¹?K~~?j^? +:x?WWT>äu>>Ü>}“>ÄÔ&>Ý–>䧮? M?H??#»?1’=?pC„?gZ?Ty}?Mo??ÒÞ?O~?"¥ˆ?p£>õ8>(1ô?¿ê?DÛ.?-¼š?fö?Q¼P?ô?Ù?R}R?Þ> X >ìL >Ñ™=h²x>€hW>‡™y?™K?B ê>ÎÛ>+¯>zÕ?Þv>âVª>ÜJø?‚>±‹Î? à?-–†>Í×|>‹~Ï>BÏß>å”´>ôÎå>t ]>´]?$Ås>þ©>•ò>)¢I>i» ?1S?fj?\~ó>þz>ˆ)&>RyM>t£? O¦>Þzh?_d?@Ù>Ì—{>ŽG ?fÞ? ]d>…·>¥Ó&>­"˜>ä<1?„‘>®1>TÑÊ> +Oä=ýå>‚pB>Àg¶?½˜?:i>,Å¥>"I>6É>FM^>ÙuP>ÉÌZ>2"†>¬ùü?5u?Q)Ž?O>Ñ-~?%Õ +?7#U>Ø?Î?¿À?mzì?eJf?9Ê?EÜi?j$"?#=&?#ØR?O©>üC”? ×~? 4°>$‰¾=Ù”î=ÉÏN=XJ&>u>£…>” +g>™~°>çà–?9œÌ>Üôt?a?/7>Þ2>šæv?#Û¨?<6?°0?,÷-?Hô¦?ø?K(>×ò—=ñ‡È>¥¯d>Ã#›>Ec¸?8?XŸ¨?¸Ê>ºÉ>5@*>ïAß? T)?R?"2?”‚?ló)?A¦¨?Z§Ì?<ƒx>ÓÜ!>TŽ->ø­±?Á= +>®+>©¼Ö=ÉYm>j<¬>•o>7 Å>˜(u>Þ§&>Ę,? ¥À>àðˆ?2t>÷Ÿ”>bëº? ´?(¡è?(¸ ?Vd§?.[L>͇Â?5H]?æ²>2y>ʈ?I´²? ¹Î> „H>º û¾¶>iϾ>í†ü>šR'>8»>­O>˜Uì>·¿Ñ?.´?üp?=-p?¶¬>݇K>³R¼>¼€S>´àŽ>ÒÙt>ì~™>›À?0Æ?WH> Ž>Þ¹ì?)³ü?>¨W?HÊ? ?MæD?Jì¾?±4?„€?D…?k/?<¢j?f¬B?i0ó?nóÿ?+V>õéz?? î?IÖ=­#û=ÈÔ²>ªâl>¸2]>É_>Ú@D>„l>™,>_Kª?"?1†È>¬¬>8á>ln ?´t>îÈ,?~ ?XÚ?B²ô?/6”?5ûê?Ô>¬:T>…Å£>“=¶>êN>àê?;ž*?%÷>í×o?Dý«?HîO?4j?F¿J>Þ1?ƒv?#_O?:¾?*îÞ>£'.>â°>Ø2>ðü«>Áäp>ž2?.µ|>ï=÷¯w>¬‰u?H2¬?sOº?œ€?L?ch>¬¶´>¬È¶>ë²ê?`òB?ü?#'.?QúÓ?2“†?CSÿ?_“‰?OYø?,EŸ>êBô?Â&?Yåý?Z|¶?Lùû>×Fþ>ÜËþ?+2>ºuÖ>ik2?$oÚ?~°–?C¨P>âBò?Öˆ>¼_Ò>õUø?5l2>{9Â>l ø?Œó>À™x>å×?#“¾>Ôh>Í(@>éßL>õ€ø>¨>(>Ý—†>ë°u?$¸Ú?ú,>XÁd>Í›¯?:ËF?[åì?)ö>Ì$¦?Ù&?>?7AÀ?Av>›‹^>ûÀ2>èJ¤>a3´>ƒÊ>ï|Ä?PZÓ?LtÌ?³2?ýB?Z!ä?Âd>¢|$?œ?^X?Ô>ê¤Z? b>œäð>—œ ?Aï?Yó?MÏ?\–ä?Bù4?3Ñt?bñ@?f~‚?5DÂ>ôK†>ñåà?2ôÂ?j;å?›>ÀgŽ?Á>ÇР>i?z?&H??v? oß?OHŒ>Æú>ê9Ë?&´D?*?1Wö?m]±?,Ó†? :ý>Ïä˜>˜„? +«‹>”Þe>pðþ?»]>ÊÙ;>@?Г>¸â>Ý‹5? è?7!?R‚‰?)?7ÛÐ?<›j>Òï>æK©>ÒKV>¦>Óø´?3æ¾?FÍ]>Î÷ >|Œ?µ??ï>¡‹>h€>‚‡N>ÑŒÐ?]—Ô?e²0?Jæ>@Ö>ýig?l&$?¢`<Œ>Ô·Ö?7"?Pû?M,p? ç-? +Û?/bî?X\?er?F@>ìÒ>@N>ÂýÞ?'Šð>Ë_`>šLh?EF?ý¨?$Ô?!®>—3<>à ô? 7 >Ù¹·?/">¯’O>ÖÍ?&8x>µüþ>KI>Ò†a?8ß½?WŠ˜?(Ô@>ºI“>­8ó>ø8j?."p>Éht>ŒŽ?!uŸ>²îZ?äˆ?{Ó¾?iuõ?lV‚? +?S?!%â>­é>Nmà>÷"È?M#Î?I­T?x›?].u?)¨?¾n>¿ É>›©¤?““?‹ú?(™?.ë¤>~Z2=ý&>Å X?$ô;?T²?($d?mÔ>ÌDü>‚±>¼øñ?.A?‘Ú>º£è?3‰>¹¥¢>t‰>?3•›?šŠ>é?(? n?D«?káN? i¬>yÅ$>öþl?[@¨?À +? ® ?h!²? 3‡>Ð$,>ë%T>Œ«B>« Ì>§·>?Ã>¾k¥?"›r>Ê˾>·¸N?LÀÝ?bTÚ?OKû?´0>A>ZCÔ>Ñ—ð>«$w>O>Q~ +>MÞ=Íyœ= É=pœ >»7>»vú=µrÊ>}\>ù0?3ç”?FƒÔ? z>¢£*>™?“š?'ø(>©,¶?Ú’?j”=ÊG>®>6?N{y?t}?P« >ø‚à>kuà>üfâ?Ä>ùâÛ?Mžô?'à&?ϯ?úv>¾`?)‡B?‹¡? E?+Gš??E“S??¦–?˜>¤5Š?“ú? Iì?%£?]'H?Suš?H;??^?æ>É'œ>”± ?4g=?9ïµ>ס0>à±>¶Žñ=ä@>?æø>1>H>¢s?'³C?¥ö>·¸><Ý>ª7?@òW?c# ? c€>‡>ã" ?:ñì>ÿ×l?¿F?_ +?SÐ.>ÄvŒ?@ÐŽ>Ɉð>±ÙJ>ÆBÔ?l~?Ëò>”<&?#N?W¼Ì?CÿF> Ð¹>FÒ? ^?–­>L-B>¾2>Üx ?;z?g%„?G·œ?1Š? Æ>˜ +O>Þ%í>Ô}¤>C6^>†#K>ÎK°?MGÞ?ZwÒ?]½?D†? Û?2ê¨? Z>³æ? x?Z¨=•îw>)u¬>ÞÞ?è?Hš·>õ‚‹><6>ÐO>‹Öø>¸´ü?0šV?[ ö?;ˆÀ?¤ž?&Ñ?0Ø>¤Ù=Ñ1¾>íÝø?78>»†ã>æÈú?’µ>@Ò©>y$ê>©¬G>×”ö>üVî>d°¿=Òu>íèË?*V>õé?/‘P?7A`>Îó>ã#º>ÑÇ>ÕL>—fh>í^>ó55>q#þ>Åáº>Ò“¶>þÌ—?6b’?}‰®?]X±>Æ™8>\~þ?4¤ü?}í®?4½Æ?8ˆ?aëd?=²>ø7ª?)ªC? Ë{>Ñ~ï?39>Ø>Æ‹ˆ?±à>ž2ª? ›?%>Ix‘>þ Ò?q:é?*¸î?º‹?9¼óxk>ùŒÜ?*‘»? +é?6;?ë? j^?†^?,x!?*Gr?Ôò>£oN>œ¢>9ê>³ß?N>~ùý>ú|*?6àÖ>ø¨á>kà'>÷!4?¸9=®L^>Ñ‹o>ô±º>×~?Tœ>ñýÆ>vœ?JW?Û,?è»?Z0?*‹@??4Z?Tê>ßD>°Ð¬?’–>þëö?ƒ?¤N>”Ê@>ÁW?'„>儾>$ ?’?Rê%?B?S¬>¬è>p?U>Ú8´>7ð?.²J?€>'Öó>C±Y>RÀ>>ß>ç†Ã>¯[À?1µ +?”> Û>=8>ºp©È¶>Í+°?@Z>¹±³>šq?ô‹?TR>Üe^>“Û“>h‹á>€r&>[HSŒ>néF>ç²±>ý$>1Q>‚Ùž>»¡+>/Ï5>È Á?^nR?4Lë>–ÉÐ>uØ?^¼?i¿n?\ÇÜ?Žæ>æù5?Ü>¶pN>üç?7Ãö?U…>û† +?”?_¦°>Ú_È>ûü4?WÉC?Á?פ?,4(?/.O?g‡?°>Ž_?4ªG?!«g>I;@?X®>ÝÈ>ã¢? ›Î>‰V"?)”ü>ÙØ>Êûd>äî”>·g?TT>Æ¡’?'ì?B >Îæø>/1*>‘ +ê>Õïž>½IA>ÎôÇ>ÒhÚ>CTŠ>à[¡?5ì6?A?D»£>³0å>NöØ>S÷">ßµP>Ñ~>o >xqø>Óƒ¡>ôj>¹û˜>ÍÊ>—;_>Ýw ?1>ŠAR>Œ(†>Ûpp>Š‡ü=øNf>¡'B>ù c>ì—®>ÉÑr>L›Ù=Ð:>õW>và>Â0`>•€>û»÷?sW²?Qu‰?MÛ.?_ À?(,?¶>æf>û>p?3µ?ÆB>Úmà?]j?,H´?+çz?!»t>ê²?@jÖ?ÅŽ?Ñ>ãAÀ>Ý“P?A»Õ>û[¨>}ÕP>öÊË?a>òEw?%pô>éY>‘ŠD>Ê, ?[?>q¸>¨Êî>¹->Ø߀>ÕQ>.GQ>i^ >å×0>€o¦>étˆ?-÷­?Ž>îÔ?0>×9>%Sz>‡±Ó>Ö!f?e¼>ñ^|?y8?6$Q?>¤?SôE?m«W>ð„Æ>ÏQâ?bÅÜ?-Ö?ãÆ>þ,>(0æ>…HÎ>mJl=_é›?ÑC?l–V?U®Ì>Íó>Ì?]ø?A^«?CÀ?Nâæ>¨‚>/ ?5Ö?+.?ãê?íÚ?%}‡>àŠo?*\>ÿu>Ž%¤>=ÁB?p?xø?„?dP?Dp?Bå?Lÿú?&þ>ÚøN?G9^?Kë>Îäs>êªR?S¥Ü?;:?zG>înþ>²{ ?‹f?>`.?'@;?Ç·?‚cv¼>Ía?Uú?F}Ò>û>`\¢?>Þ?PyL>éÔ×=úJÂ>0q>öÞ²?AG8?H>ê»Ð?C8¯?iNZ?a£r??¼E?·|?*†j?QV?«À>ÂÖ>î©?[.ø>°û>´ãr?()¯?VÐ?$…à>ÆåÍ=‘tn>}.>`> ZV>ö6ô?ÐI>è£Æ>ÐêN? 2>ñÄ¿>—¥å? ÷J?(¢?UØ2?RÖ„>ÔSh>Ýæ?#[B>´à8?Îb?KfÙ?"ëî?(†?V#ž?L?:sô? 0š? TZ>ùç>Ûˆ>°æª>zC>6Š=Î"?¢?mº?.ó|?1·”?c/ò?"+â?602?$åñ>á[Ä?K¿Ô?d?-î?ôu>³Àæ?\‚?õq>¯¼ >ÙÂœ>»ºÀ=ünZ?ë?p>_ê?öV? +]f>ñ$½>WTò>²|>º/>Gý²>agº>„ÀØ?<Å9? >²">ÿô?>Ø?i=Ö?-?œ>ûðº?7õh?~—|?oÄÚ?UÓî?NÕ>?h)¥?f,†>Ýá=,èW>öÄÜ?eD?5â?3o×>U>ÄEB>¤^>'=T?ªè?6? +Ó3? Ë>"n>“3I?rü?;±=ëˆò>û~?w*0?/,\>àÎî?Œã?:"n?1w?$šÇ?ä+>Õ¡–>|a8?ø©?5"j?'º^>íi¢?¥à?U£X>–Æê>ŸÞ>Ò¼ø>tüN>¿­>fý¡<é.>€…i?áÿ?  ¹>²Ù®=Ðð>§o·? ,>Ãlþ>²Šþ?$œ?[÷|?q¬>ø9q=’ Ò>/›¡? š ?]m?r#?ä>º/n>¾Âà>¢?!-?P®Á?%¹?@?Ý?Hƒý?Ï¥?Üþ?’J>ÖôÑ?T]K?@y<>÷Ûx?*ID?Ï–?"œÀ?uO;?(Ѻ>F²>Šý¥>ŒxR>z.ó?\?C¨j>ÛI>(ñ„>»"x>ùî>Þ~>ý8 ?,Å¥?úÙ>ç1@>uËx=¦f?‹r?*>¢û–>ÛXø?N?XÐ?NÓ>±rÜ>óÞø>Q>W•Æ?w]>Ö]ø>¿s‚?E Y?#5?|ì?@¨j?­?;Ò±? >õq?gø¢?ø>Ûjè?-8>ã+Ê>ä0>óêÔ?RC?R/?-JB>0L>Ö{Z?F«£? 8þ>QÁR>÷ƒ¤?Iòp?\?$s¶?&¾?>·¸?e¾0?¡ñ=ÿ˜>ýžf?k¼v?=°.>åVž?!?@:à?Nfþ?lÑ?TÈx?¢ô>äOñ?XF?wô>§? Ð>ò÷Õ>ñ–Ø?ƒ¤?Hï¤? +cü>”·î>ö’?XÎ(>Òµz>Èmþ>ÉŸJ>ˆ¾>ᥙ>®rM? ã>ÿ@`>3žÊ=f!k>ÏŠ®?Fc~>þ¼r>˜ç?…â>µƒ>Þœ(?2‘ï>ÿ‘6>R¦¥>èƒh>ÿ÷Û>â®h?G{ù?5’ä? 'ó>Ûð?;º?H¹§>é?çB?2 ¨?à?*"?!2ì>Ôl¶>Ý­¾?÷^>Ûˆæ? r?EhÐ? +27=ÛÔT>„äG>ßä?Fì?Å>äsi>ð€V>kn>…¯?9 ?3?£?Ü +? +ª>vV>ñíÀ?Zv½>ÍÐ@? +ç–?qg?s>É¡ì?9Õ¬?„Õ>¿+?-f¤?H8Å?7?exø?_4ˆ?-´Ð>üœ?$‹´?l–=ËwR>ï>N>ë—Þ?e? +2Ê<™9Ï=¬7Ô>ü#?PZ’>Ïè>Ójž>ú— +?˜?u¡>xŸ>3$Ì?Ví?Åñ>»íF?@Np?Pò?sß?:^?8»d?ý>ŧp> >k±>©>>YÒ>ãpÈ?²Š?7=¼|à>>ææ> ¶?¤>‘Úâ=·¯†?â6?ÀE=Ô´?uÏ?|ø?sê ?.ŸÃ>´OÊ>}»6??R?Kç‰>Ý—´?Éì?By«>Ö¡´>¨” ?P°?Bˆ>¿÷>à ª?-uÊ>Ó¬>>^®Î>¢O,>¡}"? 3ß>ÔzØ>ب>¾Mj>û8Û??Â?X&>È6>Û´=?;V~?H?>n>±Ÿ +>4s?ÑI?Ð=…Ñu>Ý[F?bÀ‡>ø¯Ö>•±m?ÿ‹š>‰ªd?vÊ?$©>¨œ?e`>Îa.>V]È>§áÞ?/?¸¨?­„?"†Ø>éÑ(?-vê?Pö?{ö?+ô?LR>ô‰~>ŸÄë>AH> x¾>Ûšz>òÌr>Üäú?j/°>ýú>6á¼>ŠWO>˜>µT¢>a¼Þ>Oø>È{>ðN:?C€?Yqº>èÆ4>š‚†?±T>Æ­Ž?`ö?%F>¹>Éú1?%T6?Vé?+%æ>øu,?3Ú¾?O‹? +ν>b”>XÊ>š¬×?,ü0?¿é=äNF> T›>•<Ú>íIÌ>“2>Õ…+>ò6è?ü.?™>Ðw—?^" >ß,”=Ñ΋>ñ•5?^v(?M4:?>Žó?J·:?j?£?5P†>ï||>”È ? n?ÊŒ>a÷@>Á{?0wÄ?+Æ>‰^´? Ú?)ÿê>aê>»^Ã>ÞÕ$>T”V>Õ¾?@×C?UÉÇ?-h>Có +?ð?X»v?!Í™>ˆ@C>(Ä? ¢Œ?*Ž^>mm>] >Ãøf>²v>Ärd>i0>,Ü">›™†>ÈϬ?—þô„>ËrÊ>ÊË>µN<>Øxò>¼TÞ>àJh?3Ñ?é#>[==÷ƒ»?RÀ?g–U?/Çb>?>ç}?4‘e?%Xr?'ž¤?ã?§&?\æ?€(Æ? ļ=‚’=Í.n>3§¶?QP?)?†>ê6Ä?IK?GÆž>áˆí?*?ð\>†'f>ád??óîª?E?EçÆ?ft? Ê?oUÈ?Rf>ÿ0>#8>aŽ¤?Ý>Å)Ô>Ù·ç?+Í|?&„?&èš>Þ¯?§Þ?Ì÷>ì?e?S±œ?R{»?Rö>¹cj>§>½tB>ZÌ>p©B>ˬ¢?=·;? >r( >™R?‘ø?5Á6>ø¿¦>'(O>W‚>˜?%‹6?RæÔ>çÝÂ?ø?MÒ?3óÜ?,À?(Öd>µåÔ>‰g‰>ÙîÛ>TE¨>ÁŠÚ?Z'ø?`qø?1l*?@‹ƒ>ñòæ>Š™à>…eW>¤z>k¸n>•>*æÌ> ‹>u.?õß?US~?pˆ?9Í?1VV?'¹x>ùÑ?C’>?Ìx>9æ>š—?+ù ?(äà>†N=Ý÷>²äF>³Î¸=Á 6>Y}ì>Ž|R?Ÿþ?5!œ>Ë>³Œì>/êŽ>؈y?"‰«?>ÍÀ?~P¢?=x?»Ò?a;?^Å"?Ž?ö2? i”>"4[=ÿºŽ>ôQH?<ô>®êT>ëÇ@?2Ü>x«¾=î->ŸíÖ?,¼E?…Ç> œ¼>(\t>ãÉ?'?Fàÿ?BÝA>ÜtÃ>œ:>óÎ? +˜?.gŒ? !*?ç>’üs>YŒ¸?>?B‹k>眺>.o<>÷9Ý?!ø>»È >±?/ +?7r?,Ê*?CÌm?F)D?H?Md¾>²þi>yyÀ?"º`?P‚A?Õ=Ñ´>Àr”?;L>¾fØ>õ•>?%4Ø>÷fµ>´Òî>Ç2¬?1Œ4?:ü>øÙZ?D®?#âK??F>˜ 0>ܧÞ?1wû?Žâ>¢O6>>ª8 >À-'=Ö‘g>/GÀ>º´t?€ï?!µ6>ª;Å>qFó>r­F?D?^ù,?BN8? ×R>µdË?Rc?8Æþ>¥Lb>¯¼?Œ,>Ý•z>ÒÛ>ƒÞµ>ÞZž‰E? Uš? ’?,‚&>©þÀ>Û}µ?–Ó>ûˆK?^g ?cÂ@?Iáþ?.3D?]ø?¬€>Ù-Ö?>6ð?FUD?t‚œ>ü_>«2?¢†>¶œ>faX>.=·ª0>•>¸Þš>C4 >øìó>Æî>ø5[?!e>¤Ô=±Uu>¼0Â?/¢~?Lì?ø?VÖy?@´ž?³:?ßž>x€j>Èkä?&X>Š¶‰>çž>Üt@>¥8+? æ?£ >û”>õ;?6>·ì?:®þ?òì>Ç£Ò? +ÂZ?)þ?óž?·?(Ú>¨.ê>ùð>ЗÍ>îàà>ÐK<§Ac= °Ï>Õÿ? >î>t„h? ØÍ?&Œ>ª^>®Tl>ªTì>ØšF>³|5>ÑMõ>’•>Ñ>%I†>;Ž>»Oi>Ééf?#ÿ¯?•>²nl?B1j?Oå¬>×%V?ž?ˆ>¤»?< b?3ô?<‚Ì?a?4J×?™Ø?:¸Ú?á>Œ#Æ>oßž>üÀª>ç‚?â?gø?ÆX>¥·L?˜ü>ìô>Eàú>¥ÐQ?$ÙØ?°>ü~œ?Atf?F0A>ÊñK>ƒ«ª>Ôê)>ý†? D?6óî>Å:z>ëaÅ?9Ñ‚?RÕ®?y„?;ê¥?2DÉ?]g?P‰ð>éIN>œ‹G?á?/¾1?UÄ>œÖ|>v†>æ Ì?-î?/”ä>ØÝ}>ÿü?Kn +>°Ò? +áp?yl×?XIæ>»DÐ>×ë?QKî?4î?:Ž>äÜC>Ñj?Jxö?Gÿ~?&>Ê™Ô>Ñj·?á”?Éõ?…ø?'V€?i—:?3|À?'“ž?"#?/Y?lv>Ãz>þ0ˆ?/Ü8>å¿Ô?Â>œ•†>¶c¶?V£?kÑ”?\Áh>êG:>rÕ? ÊO?cØ/>÷Øn>’å>È$ø>ŸtL?í7>ÑIJ?î?9À>Öíh? +”J?P´ö?7¦®?à©?2±?H ¹?\â?*ª?Q²?1¹º?_à?NÌi>¦Èl=ðâÚ>S:>ý;+?k!"?b˜>0½€?~¬?<œ‡?=¦Q?@¯Ò?xã?%F—?P]þ?/„þ>ï®>ú’9>È!J? •>ÍîÂ>ß•ä>ÞÒr>°V†?U?2,>Š +6>-ÿ÷>l®&>E_ >psv>^€n? %‘? ü‰?&>ÿö¤=à†¡>ä@è>Þv¼>ý#>ܦ>þQÍ?%ú>ù,¶?ß4>äÚÆ?."{>׌@>äçp?%Ór>åN?&€ú?jå2? +X>Ú†K?_Ò?ß[? l?aZ¥?\W²?JÄH>É’Ú>Š+Z>Þyý>öHî>†Ä?<ˆ.?À>÷…ë=÷Ñ>ÿ$ ?Qâ?Ý>gðL>LQö>ÿê9>¥Q>ß(f?8Ûš?+»?_µÐ?1F(>û3ò?6Ú€>æSb?y¹?IÌ]?$(€>úÊz>PþH>`‚Ä>ãµÁ?0H?>@U>ÞÄz>H“>E(>ÏMl>¸ÓJ>þ=?&˜>ÿìA>–m–>ÃG&?ª‹?!6H>ºœ>cŽW>ïS‚?&i³>Õzï?¨/?XÄ?sXx>ùqL>Ýæ.?1Äø>õ—â?çÀ?=>l?Gsê?&&±>øç>Œ™>«–ê>÷*Z?|Ð? €+?vª?nMn?3V¤>Ö*">âTc>…#/?ê?_>•hÖ>Æ1¾?ó¥?“´>¢–>f•>©1Â>¾Ó>ÕêS>vù¤?!?j©>‘qY?6ÿ4?0—R?îä>È™f>·Á.?F[&?k&?(?.Ë>ã ô>Ð^D? Ù?òX?\Ãà?@´·?'»Â>ÍWX>ëGô>ÉW>®? +Åd>ñ>ËÃÔ>Ë©{>áxB?aò>ê÷>úZP?CL? ,;??#€?H >¤ç?,Âv?]Ù”?=öø?îx?5L‡?-ó>Ëä7?éÔ?¿`?#e6?*Õ!?·‚?GêE?Fò >öÀæ?A¸?Hj>g&>èòò>ïñÏ>Ôx>êÖ2=3v >•(>ÙxÎ?¶ ?‡p>1Ã_>Á~B?-g>ØÆå?N?/—l>Ê9,>ÏŒ(>Í{¿>F²>¾Òl>•“Ð=_®ª>~û?$–t?'Åà>²ï?\Ö?é>¥"J? ö>âî?5m¸?O™t?Â0?yL?x>¸r>Š°Þ>Ñ,?7¨,>ñ0L=ã(]>Ú¼?ù[>˜~A?3¿C?×|<‘¡Ö>1µÎ>ÜLÛ?¸‚>Z>ôZ?dâ>†Œè>o P>Ž.?9>ð]ô=V£T>µ (?Gá?HÐB>žè=Ò¨>W®9>gú(>—S>~;ø?¸m?s€»>û.>Ó.?Éì?H(ü>Ä*>„Ö¼?5ž?Yb¾?K)4?iâ>õ\?A¿À?.ø¨>€áD>÷Ùò??>>rOì>‰Ã.? Ç.?4Ö%>Qd? a?R0 +?V8þ?d9d?î×>F>‘#y>‹m]>ßÌG>·_º>¹°Ô?T¬6?ßf?ÎT?s‚>È=d?EÝP>Êù{>ýz?JÊ1?&íÖ?Qþ?LdZ>é?>‡ý?Ó?eCÚ?Fü>¤eP?V.?)nˆ>ú ‹?k¾?$ïà>Ï®A>°ÿ€?Z¿¤??ëé?õ >Ò÷>¼o>ÉAr>·Â>ö~I?ÿ>>ÛÕ?0UR?G€?!JÜ>ñ ¸>ˆ]?C>Åé3>÷¸Z>÷3è>­ÿ?2®Ú?F<æ>¶¶>ˆe*>\A£>³èu>§€À>»½ ?CEh?%/>ÝGl?J$”?Sv? 1€?5£ü?0a½>ä'Œ>X=¼ç>æ$x?OB ?^Êœ?íS>Å+–?©*?q0?6®?Q³d> ’>xL$?Æ>ø¿Û?¤’?J––>åWÈ>e¢?’?—²?*¶Ì? +"S=óô>̤²?Ôˆ?-÷>÷¬@>M™ >ëNX>áçX>œ1n>Žnå>^µÖ>i—Æ>°Á€?r>ÍÜ?\?tt>ˆßÆ?#õ'?pGb?zFŸ?Z"°?BO?Ì.?pz>ÜGn>¹>ØÒŒ>œÿæ>Š2©=~qŒ=´¹n>–h?bí?fâ>-ò¦=²?>†U >ÝXj>åû@?ß^>Øþj>~T6?" ª?G'>¨($>Ö¶>èÚ8?Q?1?d›‹?,¬Ú>À»ã?'Q&?R•Þ?^N2?2„b?"ªÔ?o ?I†ž>¯8@>8±>Ä*4>óTã>ðW?ä†>ñÖ²>Å?>y×>¸O¡?-Ý->À&$?Y??1œ(?•^>ß{Ø>æ >ÁôD>wd>œ‹à?¿A?ohD?I!Œ>ÝÝ>"â>p­¤>…Ð¥>U°Þ>¾Ã,?ž~?,|?1gD?öÊ>LÕ=ÿò>~îþ>-Y=j÷=m5ø= qÌ>ž¨÷>ïî>?&}´?QÖ? ‘">b«,>§¸V?IcØ?({¶?)Ç?9o2>®‡Á>ݹè?@Ûy>ë9¦?Û?+l>Á÷ ? ?F:@>íö>}©?Ù’?‘Ô?6‹ž?Sα>Ç*=ë–ü>‡ä%?åØ?…?& ²?;e?Cöð?p¦\?:»®>í](>ü >à•D?-‹L?†¹?:¼¦?)Ît>â|?"ÿ>ÓÅ:>Á:°>âþøT?ß>ʹ¸>ƒ´?Œ?1g ?,ýÇ?kõ·?/~>Ûª?J´à?ŠD>[Á‚>Ú?‚>«¢=·—¢=À|.?ˆÃ?qœ²?s +D?2+>‚ÙQ>ÐUk?'<>Ò­Þ>•ýµ>iÁ> G¨?ó?R6?5n¨?O¾?ÿ?>cÝe>‚òD?K>?1!?VÍz?QH>­Çò>wô­?&j4?]`?jÑ?©©>ËR?'e>Ü)Ñ>`¼¦>ÃØ>¥HT?)ò?YÈÙ?c…>?hë–?e®>ý–y?k[¨?+ÎR>уÚ>¼ Ê> Š«?'5>±§V>úÆG?8jê>z}=̲˜?¶H?aöE?d°Ý?8ÎÞ?¥>íD>ˆ\>õt?FŠÖ? Z¼>?ÄF>B\>4ñ@>Ìöi>ÁÔ™>–=Ü?ó(? îŒ? +#>³e-? ²+?Ba6?ç?$Z?9™°?½ì?!/>ËÒ>áʪ?¢ø?MðT?9êF?'¹(?miy?eßj?Æ”>®Ä‰?&žÒ>éÂ>[”?6"b>ò›>¥=?Ä×>åàL?¾ƒ?H¤??Ç>¸J(>å‚/?[$u?'ÿb?,aà?{>œÛ>óâÒ>Ý~J? +b{?\É?Ïö>˜ ~?ŸØ>¥ýù>èsY>úÁ_=ÕÞ9>äÎ>ÌÔ?¡¸?ã!>¬¨>ç N?+Óñ?h©N?*®>ªº>>v0ò>C|N>à¸?‹Î?Ãù? ¥±?)Y?GS7?'/®?­;?êT?UíÔ?gã&?z§,?G;¨?'Ɉ>Åâ©>™? A>?X¸¢?N >à¢s>–²¶?Bp¶?l,|?pµ?Qˆ?1ª²>Ü#>{éM??Ä>¬¾>Š >‚”>±.ð>êOž?N¬?Zëe?2ï±?;¿£>òŠ\>wéÅ=ýj?£Ä>í ˜=âëŠ? +ÀŸ?eÐð?*œ˜?¬h>ᶪ>¿ÙÍ?Ðä?5]?E6@>û™`?À?cŸ¸?‹y?2z­?0¿®? Ñp>ÙóI?}V?KW?z&Ž?f0!>ÕMù>:¸é>$„ã>†&ÿ?Ò¢?OTê?"b™>Øb?Nš?U¢à??C‹?k£>ùH]>ž€L?M>ÿÌÊ?"›>¾Æ>¶Â>Á9V>àÜ?v +?3QÄ>óíì?Ÿ`?qÇí>Ðë>á1ò?0†³?@7"?;ïø>Júã>Íǘ?(rH>•2Þ=í¤>È×$?2½ì>ݘ¥=´V>>$ª}>|;¬>ö>¼…‚? 5n?nCÆ?*§&>€ÒÔ?tŸ?*>îË?M]æ>äãÊ=+›ö> ³Z>SW=¿t?Ñþ?GÑ^>šóÌ<ÈsÜ>ì³Ï?!S>™,>¬‡º? ôÆ>æÞ8>*FT=«Ðp?~2?%">Ê)¬>«Ö >'ÿ>í­$>ÿÏÆ> ec>\îþ>`*n>FƒÚ>Úøj>«Á´>´^J??°>»*³?+?OÄ?<">"K?¦?f\"?XW +?HD>¤âŽ>€{.>ˆ˜7=Ó½=ëÙý>ƒû>ðs÷>‘Öv?hœ?Mœ?’?! +?.íÌ?%Ú>ƒ?@eû?RØÚ?.R?U¡?/m=øyÓ>SR]?ñl?rÚ?!r?3“n?Δ>š_®=–4?:B>þ¼>K>=Eð>e+ø>ˆ¦¯>˜¿Ž?3\?G[?P +?™‡>¦˜Z?4¿Z?7 ¸? î>™ån>Jeê?(Tò?>Gñ>ŠÆ>¾Sf>¸h=¸`>F+.>]Ù>À>4!>¬ˆz>ÀíP?…z?1¶~>à±F?_M?ñç?µŸ?)œ">«]|>p ‚>ö 8?Y×x?;o‰?,^ô?ñP>•z8>ìù>évœ>R­>¢f>k2>?ŸX?,a>Þ0‘=äØ >„O??4Ò?J=à?: 6?Fô²?Ñc?Uê?)ŒL?4p°?ƒ]=ü\Ž>“–¢??9d9?Caº?1ì?"¨>xª>ý²r?0æ8>²è?¢Î?W©£>÷g(=Áíi>Ó$¢?>0l>ÞG0=ô 0>¼à?n >Ì7o? '4?Að>±µ>¥ >þëÃ?"¶O?"¤l?.´º>¨üú>¸Æ>Ш[>$tI>Á? °7>Ø‘¼?N<>ûö ><ˆº>Wö>ºëU>ñÿæ>ÀÛç>ü±È?er?uò?1ý?<>›„? dÈ>û&e>”Xo>!‚D>Ämö?B?n*?j€¬?vö?1‘a?¿?®Î?aF>ýÎ>—ùÏ?P?8¦?dÇÎ?SÕ?Yå?PÒ¨?ÿ~>¢¥>Joy>¤e&>ð›à?H‡Ý>ø›š>ìZ?(ˆÚ>× +Š?œ>À½Ð> +¦?: >üÓô>B^> +÷ú=¡´>êc?:H^? š¬>¼<>ÔX?#Ô+>  :?\j?¨¼>#h–=®3„>ýº>|·">Ÿ¨÷>"U’=ŽÍþ? å'?}ýÊ?qŠ?\G@>ï¬>ÛÐr?Ú>EÒ˜=§äx=óÙÓ>ïñ‹>×Ýá>Ùø¶?a|?:ÿ? (V?E¬T?Cš?d?F´¤?l’>ü3«>¥Ð>Ï« ?KN?>ÅÂ>þwŽ>пÒ>w,à>ÚìÂ? z>ƒ>ðP¢? 9>š>„P¸?%®?_¾?Ec?"ï’?1=? +|F?õ=? ˜>xÕØ>oˆ>‚08?%óÁ?K ?Wp ?yd?uÖÙ?R(>Õ;T>p3·?¹?J£L>Þù“>‚¦‡>òY`>ò +>WáÛ>Wªp?¹?LÆD?6æN?HÉs>ù%^=?eð>± `>Øv>²ƒñ?B®?ò>O>Ö•?Qw?‚Ì=}\)>>”q>dÍ`>y >£ßN>÷G€?|?:œl?Þ=‰Ä.=ºÏn>¸ÿÊ?£B>–¿ê>™¼ä>¢ëm>Ö¹æ?+÷>„p=$c~=õZ>³Ç0?: ª>ö+j>qÐl>Ùé? ´ÿ?Ú@>Õýv?IŒ?,2?U¬?9b?Q‡Ú?5ç0>:›G>àa ?Sb?ts>´á˜>ß5ì>–O +¼~¬ä>½íc?Ò?üŽ>ľƒ?wþ?"`=ýz¸>“‘£>ìÆ6?¦?V2?@°?né?7 +Ô>æ&¢>®9 +>î"â?v>õÄÖ>Éî¸>Íå? ^ù?:¸S?5f¾?+7m?Ÿ…>ôVÝ?AW?4AZ>šö>í•?/×¹>ÞƒÖ>€Iä>\ `? +{S?=õŒ?ñX>°›Ð>ùNg?'œ8>ÂÜž>ô€?2>Ôf_?Ô?$ã>š]!>{ð}? 4?4h? M·?BB?@ÌÄ?]±Ï?H7Û?Ë·? ??]<?AÍÕ?LmL?&It? £¤?Hƒj?4u?U?Vê\?M±\??áš?Œ“>øìþ?Aø¦?Vá?*x>Æå?†?7–>·+Œ>9r>º£H>þ1c>™¿‚=óŒÞ>À?nÍJ^?¿%?)Õ­?rá?¬>× Ï>õ³^?Ô¶?çÚ?%¤>Îy:>È^=â>³H>¦cã?Lm?ÁÖ>¾>êQ²>%ì(>ײ?F¡ê>¥Â>2}?»–?,ÔR?'¿>º‰=¶7»?‡z?$Ì®>•Í>’çY>ï?öù>ßÜ·>É->™5»>õà>óµ)>Ö«o?œŒ? Š0?*pï?lÊ1?;¾>ä.t?1^È?2?ð·?0Ž>âÝF>Ø^?EÆ?‡Ã?^?@ m? X\>÷á…>è€&>Þ Þ>ÒÒ>Äóè>Ù n>Añ„?ýt?ó>‘Ûµ? )~?0 å>ÿ°A?uÎ?ç½?="Ì? ” >þ¥@>¦ÛŒ>á*Ž>ÇÞ>»Û«?6¶>Ð5<>Eø>¨òT?FÕv?iÁ„>ö0>L]˜>É£? ¬í?SŠ?3C>±õD>‘Wï? SÒ?P ?g0>®ö>šöl? ¹(?j>Æ:Ú>Nºj?Õð?jz´?Eü?@%?6á?'OÊ>ýûï=²}=ãÊØ=×ÙÌ>þ=D?ZX?FjT?$r?/)>?:ÍZ?Q“Ô?pe+?6˜>ØØÁ??ã?A‘é?H°]?E`È?D‹^?BZ?¶>Í[9?5V>ï"ç>†«¦>«Œ\=îáI>9æZ>·Uó?* ´?Eý>¿èð?Õ?ìl>Ä8V?"<„>ÓªZ?#Î$?BP?0?(›a>¼ =ûhø>Ù£=>ä×ó>‚‘¶>É[l>ß:ã? X¨?8Î?)Î=>£¥œ>RQ•ô>¨8>¯Ÿ?ž¦?[>Ò!±??ý¨?Ö>Â9r?ã~?³º >‚ X>͘~>†/ä?Ô¿?-Q´?3™ç?$ˆê>ïˆN>èùy>öÿ>‰'=ë¼=ƼL>µÐ?6ÓÌ?vP>¾ ¥>¦t>×5Ö>«ß¼=šm>üwØ?Vd?*“„?Rcæ>ã›6>æ½@?Rlã>øëZ>ï™B?[ü%?X"ê?\3¸?g9T?è‚>ßE>Ï6®>„<Ë?5™}?j3??“r?hÍ?$.?%´v>RÊ"=áLP>É€Æ?c?8kf?1µ˜>äb>>Ì?Ø>‡ýð>§8=¢6?ªÐ?-ìÙ>‘¶>ÆüÙ?#ž?æa?[Ð6?óÿ>Êq>áâ?#´? v”>ââö>ú-º?¡V>ç¤i>Ê:h?9)D?I^">äÓ’>2Ÿd>h§>Õt?Veb?Ex>šr2>®Üô?-¨?.—F?ïH?Ax>ü>&>Ó£ú?4?Ô?;œV?L|p>¤² >ËØ?? >Á•N>¼"?ö†?8š}?^¨?eW'?m_Z?G”??D>­ßÔ>Ï@æ?:µž?SEF?#Y>NÐ=ÓAö?fÕ?dÁ:?s(?õV?{a?aH?0*f>д’>âQ>ÑHg>¡=ðø=š²—=Äæ2>è'‚?62Ž?FŒ? Ò>*÷>˜yÒ?%Œ–?>>þb?VÄ? àÕ>¤ÃJ?a>•:²?L>ò'U>èu|?$¸*?˜?E—‰?GÞ ?GxÔ>ªò>fOt>¾t¸>ô®>™Š>°„D?[O?,#^?ào?O}0?¤ž>òr?¶?%mÔ?ÑÚ>ÖF>©F>>t¦>©<>?Öá>ì2#>ǯÌ>T«>ÐY>‚<=àÿð>ÜEM?1xb?'\>ä›>µ|è>æÕ?5?:,?–>¸ÎN>ŠMH>ñ>ž?UˆÎ?IÔe?+¯ >Ò¡[>rg>ä1^?0 >?O ä>Ò§ˆ>Î#>Ü#?*Û,>ýæ:>I |?W"?î>ŽÎª=ÑT=Ì“>°áï>Ç>¾Óâ>â2¾?:P˜>þãq7£4>³ÿh?[{œ>þj +>ãH7>þØÅ=°Íñ>?LŽ> +3ò>„–£?â>½yä>Ô¢Š?^ð)?8ƒ >^ò=¢a(>Îô?Uö +?D0=áîÝ>‚Ñ(?.:?<5>ü×>‘Á>ýþÆ>½ê>í(t?$Er>0z>$t>ºã>µÒ>è| >³fH? â>êìZ>šå?lÞ?/¥ï?”>oì>â¿@>êÕn=û|~=Q¤Ü=³ > ¢? ÉA?0ʘ?R‹g>Ö|s>-)Ý>³ef>€Àz>óK\?!°Ì>€¹¬>άj?<œ]?r¬?$P>ÅO-=|óþ>º®˜>¯—>¯fã? 9e?,Êw>ÝËN=<Ò>ž\>i¼ˆ?)yê?,>¾1t>á³ó>5¤>#}(>}¢6>¸€>L­¾>îyO?^†Q?$dœ>‹-=¶h„=Øà.>ìL$?Wš?&Ê¿>ô§æ?(4½?^ö?'ä?Z? ¢>º*ü>â·N?.õ^>¼ÎÖ>ž2?í?1? 7÷>À>Sæß>Îd©? 9©>›¹v=ˆ*=>þ´ü?¿£?¢h?…>I-ì=ú¾~=¹¶÷>V^Ö>‘„§?CÎ>×G>½¯ ?5·š?ÊÌ>ød>¦õÀ>vån?C>øÖ>Ëî–?0-g?ZÉä>÷7Œ>“®u>¢V?>ônl?s\?š=s†À>mÆ?c„?4ˆ>îÄ’>êÞ4?2uô?`vÇ?²>öŽ?BÂ"?o3>ù¦>ó">ø˜?´?N@ž?‘|=âŸYºþ¬€>ð#~?o1ø?gø?:~—?Áb>ÿC>·o?#Ó??a¡>Åy >óð>½ >Å>öšØ>õB¾??+;”?O¶^?_ªˆ?HL?2»¸??‹G?0Ql?TL˜?+–? ;ó?^ê?x§0?Z¢>Hz:>¹X–>Çç??-ZH>òü>ë–€>ý,.>üȾ?sï6?3åþ>¤Óz>8”>\úÆ?Ÿã?2Ã(?4%0?Q[ž?\i?SÉÄ>Ï~æ>±gÎ?(Ó²? \‰?0r?ZD?¹õ?7gÀ?)cw?2›œ?ÿ–?"g?ìJ>úý&>Œ†Õ>ÆÖ?RÖ¦?x 2>úœ>d!Ñ? >¬¹¸>Í×?ŸÒ>‹Èi>/O=ì;|=çk>ñ¬â?‰ >¸n>r{m>¸Ôõ?àö?^Œ?=éÃ>îj¹>Τ&?±µ?3*?>ì5?>I®>½:3>ì÷>§ÃI>º->߀??Åä?IC`?»x>ôȽ>Æÿv>¹#Ì?--?;—$?$¢?Rù?Ü>ç3$?Hr,?’t>6ã>-¶>˜,<>‘€¾>Ï…Þ? ì>òçÑ>²ÿæ>Ô¹'?%ƒ>¼‚>ÜØj>ö k?ïÊ?7&A?í“?Fáš?s@´?,À®>žl>Ïw~>¦C='I0>vü>¢-&?z>Æ`T>ño?,Eô>šâ?ã¡?I¢?Dý.?jÈ?g7/?På?)ƒž?aŠ?I£3?b&>ñ(¦?p>ãüÆ>ÀOÔ>Ã+0>ˆ»6>ø-Ó>©6.>ÂíV?$Ž³>•<þ>›oM>Úà›?xÀ?J¢Å>ÝiÀ?šÞ?gÓy?6 ã>–ô(>¼PG? „N? +n>»ä =Ç(H>WŽ>°Õì?%›|? +Bž>ZC}> c>r{6?~?‰x?b(?R›^?¦ +>º)r>Þ/Z>ÙÈ?d?:zG?4Ê>õÂ>õ«þ?B}?Q>š¤Œ?Çø?ò>€Ôœ>$:é>³)>êî>ð$?®f?)€?(¢ˆ>×ì? R?H“^>ÕÙì?™à?EãZ?Lk?8d"?´¬?¿A>¸Õˆ?!|>ôÜ>½»?‹è?ÝË>µ!Ü? ~³?A©-?yà?ã"?ü‹>íPÞ?óà>ÉV(>Çf>á/Ø?"ÇÎ>þà>³ÝÄ?.Ü>ìñ8>ŠÛ,?Â?NïÝ?6˜c>ôR>·¼”>Á0þ>¶°? Q*>¾xb>LÉ*?-¨?h?!t>†©J>a&Ê>Ý +?š??ò«>ÏNz>Âß^?&ÃÑ?$˜>ìœ?(eÖ? >×K{?2ž?'϶?fZ?ú?1F>}i˜>…¿‚?2‘? w®>Ô¬ä?CžX?@]>€n>Ñ~Ã>Ö ä>)f¬> H>sc>‚Ià?¥¿?£j>»å\>•‹>ümx?«ÏN? P?f¾e?.cÄ>³(>[èæ>‡D<>ÜXR?F.?smÎ?Ž>3Äp>‹ÊÄ?¼?@-.? +†ƒ>»²>³c>Æò¾?Õµ?PŠ ?e¬È?E&´?ùR>¾M>C›A>ø‡±?XN>à.">Ë0µ>ŒcÖ?4€¦?>p[>­ëð??qÌv?P>å—Ÿ=øW=Âs:=…`¢>ý+_?6?È>ÿ48>ÍH>gè0>¤˜>µóä? Ø&?L½†??ê!?[;Ë?w”V?KÚ!?¿l>×]%>›*Ò>Ùê(?åÎ?)ïÄ?S(?,ø>Zòj>® >/ê>ñU>·>æ2ô?Iè?ZKl?)–>óç4? +†V>Œ^> Ã ?hÕ>õÈr?Ü?Q¨*?R›J?n?›?5è?M?=æ\?ˆ>ŠZ´?œ7?I ò?4,õ?= 6>Çïè=ƒÊX>6ü÷>èšb???@>i?®†?'²¾?H"H>ñO„>‡öu>ë¢?4ˆ¹?íw>ÝÔ">{ž1=É…?ö}?¸C>M>5‡X>ntZ?ö?D)>º†›>ÛýÎ?_¸ +?s6d?s—>Œ=0?%jq>íS½? \®Ðš?)ÿ‚?4¥H?„ê?ñ?A2?/^‰>zk–>öÉ?#²à>‰ìë>øl ?+ÿo?^ƒ?”W?0Í>߇Ê> Åæ>È0?c€>–÷À>Ë×L>¯]Ã>µ›? XN?'ÄX?<Ô?¬†?;«(>áĺ?Ä*?*([>ƒ'”>é¸D?.ª¶>‹l>¶€>æ}V?‘˜>ñR¦? ¤H?1¢>ÈV„>Ì'¥>Á) ?$CØ?`¡œ?Z,œ?NOÀ?\>ã#?6ÝÜ?9Á?)*?DÌ?Wɘ?FÉ?½I>ÈS2?&~ +?'¸6?6—N>ìŒ>ßE ?AÖ?8y’?òh>ö˜#?:ˆ+?[Ýp?|†J?5¸$>¿àü?%S?xî?l‚?[$?^ÕF?3€š?Øî?2~?9Š?)z>˜âU>Û¾F?+‘Y>{©ö>¤Fä?>?´õ>Á ÷>R'ü?'K=??؈>¢Â>ñ¨D?bL{?k€ª?qø!? Ÿ¡>ó|Ä?R®(?]­>:´=ÝŠ?$Y$?cï?ƒ°?f=¯¥¨>·,>1$o>EA’>}2>Zż>¬í?YC>”ƒh>¾í»>ÒZD?¸|>ôó.>ÞÃ?Gg?S'8?âÏ=~U,>׌:?/Ñß>öQY>Z =Bò©>ŒÒ?>ç×>‰æ=Ô›K=¤-2>¬>ãê™?"7Ê?! +>*]>~,>–2Ø>üü? +»R>wuù=›O >˜YP?+Z?¨ìJ?Ðë>ã¯=P¹>泟? ØÚ? ?9L?Bê?p?@? VÌ>¶‘:?/?,4d?bPþ?Ò®>È1Ú?G‚? >ËÎö?)î??$¿n?:ˆ?`QØ?÷`>Ùö¾?T>?jÞð?*½ö?F î?úo>Î>?²W=ëZ>§;?I<8?“W>xÍ?¨µ? Êv?,Õ?#qŠ? ±´?2Ý?T$Å?Qó?3×?à!>Ýûh>椠0Ã>—T??br ?PQ?›v>ý*À?3e¢?@ ? ¯n?ÝF>|~ô>™“œ?<ÉÄ?U‰}?/ˆ§>Ì:ƒ>•PÖ>µBÈ>¦ê*?eH>¼9€>Æ¥~?G½¨?*ÂJ>Ç–ú>€å ?(¼?0€À> µV>ï}?*ã>à^]?4? +>ò}µ>Â…À>ãÒ?ã?"`r>½Ba>ÈÐ>¡F–>ë¼?;D?VQX?>ö¨??n?_=$?H†|?&X#?Z%>º¶€?/£r?W+>áØ¢>ïãÐ>*9 >TåL><Éq>ÒŒ>Ê÷8>1žD>•V´?:´?C0É? +D7>Ü,>Ñ‘l>ê.•>×2,>…?2Ú+? « >®P>Ö,>³?5Ù]?^T? 9Œ?4ŸØ?EÝ–?CKW? +.p>¦N>Õž?`qØ>í«°>~ao>—ÖU<Ù¤º<˜\[?µj?Í>s“°?x‰>ù{L>Ýv(?/hp?1›Î>òWb>(¾ö>È\ú>è˜?Ån?Z\´?$ZT>õ‡Ô>ݯ >™ö‘>•Aé>žÀT>ù9?˜ ?‰=M0Ø>"[Ö?4T?5'J?Hí#?U4Â>×"ò=ëªþ>Ý‚?&øO?3¦D?YÔJ?'O&? +•T?/Îî>õ¸Š> =# +=Ù1™>R»l>=¯>²¹¥?+¶§?)ß>Ãò‡?½ +?S\>¦ð>Â>l]Ÿ> ¸e>ÅJ¼>ÈFè>a•ý?od>îNy?§ð?!Á>¥ª?Ý”?,J¬?0!Þ?Q@î? ÷{>å‘Î>Ï„I>y)é?äm?0?$·à>§D$>ïÔ¤?/;ë?ݾ>ý¢B>ºY°=†d=Þן>º­ì?o?ös?W?RÒ$?EH>þž”>ùÍò>¨Üò>‹úâ>ÇŠ>p¶+>3à>óhõ? +„?¾¡?‰¶>½~=æÏJ>–æ>o>¾N?L<>àØn>Å ?!+?Qr?=nD?DÀB?6[>Ží>`rY>Gž>>xÊî>ôÇh?Š*>â +1?ïæ>ž«ù>Ì"?+{l>©ÓÌ>×m?,ë>UrÎ=7“>˜í?V4?)¤>ì´ß>½$í? A)>ÊÖ˜? +?1§"?QœÉ?%,F?ý?.úÂ>½yÔ> ç?Nò?Y»Ä?#>}-”>;6>óž!?mö>¼°?;YR?zŸ6?z0?©ú>Iè0>w¶µ>¤w >¿›Þ?5Á>?Oâ>¿j>¹Ü?A™!? Š½>=>¬ƒ? ŒA?5ß?!Tp?F¬?1À6>³+¥>uúò>i†F>Á*Ÿ?0¤”?0ï¨>“„é< ¨= àÄ>vðE?¤v>þŠ? L?Z̪? \h>ìYÚ?·…>·.´?A‚>ÑÒÊ=ø©>³#&?,]?Gʈ?:Å•?Y>p?X +$?ß >¸sà>/0S>x½î>œ}’?¬?6ž­?>Þ•?gÍ>§«8?,© ?+‹Z?=ö?Ÿö>¿¤?QÓ£? Ï>±Ìa>ØD€?!˨?‘O¼¨>ÒP>¿«V>” ?6È?J‚·>é‡w>™œÉ>®œ°>µ˜t?1×?"/Ã?6…?Þ†?–¶? +¾>Ä?<Ê?Ÿ?‚G>é 4? ×Ã?î>¦n¦?Ó¦?rlü>ê½þ>.’Ï>ñx?6Î>¿#Z>…Â>ŽÜº=ã;³>ùo‰?-‘ž>\‡ª>…„>òFš? ”à?$`U?¨>ζ$>½&ð? L|? Ø?e«?HVŠ>î’>‰!°=ëœ=[ȃ>3">ú­\?.î¨>Õþß=ö¶ô>Ò>º®>ê‘N?C$ +?qè?˜>ôõ”>Ï×.?Q˜ ? +·h>4˜>Ü€Þ?*‹Ì?yV¨?KGù>Ï"¾>é®>»‰Œ>0£Ý>¨cî?&‚W?.ÄK?ûŠ?Oz?¿’>ÃxR>¦Ö?>Wv@>Îv?H$?<>Õž>V9h>â¤ü?‘¥$?GZ?UYž>·Ãv>cÞ>ト>ðeÔ>o¡®=ÎÛ2>‹‘n>YW†>…4~>Ö\ >1ù¯>ÕÏ? ¾ ?dš?óÖ>gR?!¨?üB>Rx>¾9¦>W¢<©þP>Þc?sÈ?•À?ÞŒ?2ox?Î?¶z>Ò1Ü>ô¤Ò>sE|>{Gè?_`>øµL>Û + ?4Tn? Á? SB>¾»Â>ÖÖ>â1<¾ÿ">ŒØz>Ó«Ì?#¸?GÊÜ?Øv>Èé²>fà? (1>åÌÏ>Ö4?,¬>’îõ?€Ú?¼¸>ªì? ¯"?TØX?Jœ>ñDþ>Ú¦>BJé>ék?«Ì|Þ>”™Š>v§?Ã?%"m>ÄÍ8>f•O>™ËÔ>¡0¼>ÝÖ°?4Ôj>³9¿=í“>ºÊÀ?)Åá>¦pk>)ê²>¼œN>»n¤>«%¾>!J>¥¥??E1°>Ùó,>Àd#?D?b?Q a?]A'?JîD?š²>É7Æ? ŠŽ??±]>ÿìç>û?Å£?&1C?<ñ>½úŽ=+{>ýéL?" +Ò>Pƒ’=*>>£r–>¼ +>0rt>ÂÚ\>¥p`=ôüª>æÔ²>¶áÖ>‘å€?>Åb>ÛÚZ>)û²>–Ü&>¥þÆ>l«º=Œ¿k>ä€ô?Œ|?Ä?_2t? (>>˜e?›î>å¥>yË? È +?<(…?`L +?%º?'°?[]¬?]µI?K²æ?ÑE>“ÓÚ>f`q?4Ê?>“r?ASÊ?Koâ?- d?7צ?OR}?>¨.?B#/?CŽ?ËôYµ>÷Ò«>ºâã>¾Iƒ?í0>¼²€>ß_=æ¥Ê=¹}>z×ô?'R? BO>¿a?>®B?\†?1r8?<<>ÂvØ=ûi”>ÉÒ>¬ÀJ?Žp?½†>6‘¸=®¦&?Ô*?FçŽ?;¯Þ>ßÆ>à ã?4,?¿6>˜áÿ?  ?8O=‘>¸ð1?BžÎ?*1p>¢{>%)q>ñïE>ç‹x>‰¨é>ï_Ò>”ûü>Ù2>¿Ò>ç2¤>©™\>ÃÊ?0ìÎ? +ɧ>ÕÔ>÷F>Ý>|ã:?Úˆ?YÉ}?})ˆ?@ß@>üëÀ?=2ë?\M>é$>¬Þ>t">R¼h>“˜ƒ>¶a²?B ?ïk2?jÆ?``?"¢>{’ü>Kä®?0?Y<Å?Pý><Ê>o\ +?-ƒ?!r0?%¦6?N¦ð?(A?÷(>ø?!YÌ?;~?â>½ñI>½Pù?Qéú?ð·>¶>ÇúZ>ù? ÏÎ>Ëø?l?*ýÿ>Ö½Â?ŒP?90–>òÒª>óÍÀ?>åU.>ö(Ú>݈;=äÖ¤>ÊTP?Øv?-ÜA? Ñâ>ÖA4?.Ïã?Õ?.‘s?% y?£e?k ?JË?…â>³ù‘>º#x?Ÿ?`ô?<÷œ?È>–^D>ø4ó>Az>îÜ…>ñiÜ=•¬Õ>7~Š?z˜>Û.? 0??ì˜?9¡®?4IJ?& +>›©%>šæ>ôG0>ê¡x?´Â>“h“>'>°Õý>µÔ®?³p? :>˜Ls>Š¢õ?)2å?<ð>k¹f?$d:>áÞÖ=¾ýJ?ù²?0|V?r?Rÿ³?bŠ8?PæÜ?t?~.?`µ>ì&|>ëI’?òø>™íY>£1ƒ?‘ì>Ö>ÝtP?WÖ>ì32>;†¾>Ýâš>æëS>ãæß?AûŠ?MÇß?nÇ?™õ?ò>ã">nš">¯?=¾¦>ù ?ù?f¼ò?søä?l “?bB?¸>?ŒÄ?iOh?6?':>Øj +=Óªè>H|c>µ:@>»ž€>k!Ñ=×ë =L±>dnp>á8ž>µÚj>4óZ>ƒ¦>ÇSÌ?=5æ?_Pl?DŸ4?»x>ÂÇÊ>Àül>ÆÏk? !?Hü?OÈv>îg>Žè?Ë=>Òî@=¬é–>VÜ>©\>?ä¤?:ïÃ>Œ >ý¦K>þÃÂ>.×>À0:>­Ú>¯d?ÜÛ>¿Ž(=œ}ì>îò?cøð?l$? ‹\>Í’=œô??Så?<žˆ>俪?o²?<>ž?7>ø?(°„?8Ìc? +¸¾>²`{>)y'>ðÙô?Ðb>­Ô§?=ú?®°> Y? >"?lYó?9ý¢?35Â?3¦>ív¾>ãjW?F.­?®>où1?2¿?+ ?øB=¦=z>Ê2>àS>?È?á?Y¥d? +Ø? åÝ?WiC?UŒ?$Fª? R?ëx?lÈî?m€?]1ö>ù1? ‹ ? ^>­?¹(>ÀäÄ>÷Öò?qeA?qr?g ?5{ì>Éêð>U6=OÆ‚>ƒÒÈ? 9Œ>¡Uú>·†±?5‚?-QF? ¯•>äVv?5ý6?‹ú>¼yz?wî? ²•>ˆ(?`‚? “ò>Í*{?J @? Z[?‹š?u°§?8Y=?#Gl?8 å>­Hè>k[ê?=*Ý?5þò>º¹ >þŠ>ù—ý¦F>‰px>¶Ì?..>? µE>óûî??Næ?ª¬?É’>³„>¸jÄ>°Æ¾>6à?Óv?O{n?8ãê?=ÎR??ƒy?,+Æ?`Æ?$¿>Õ²´>ÜØ>çš>Wæº>l½À>ÚŒ:?2>‘¬>úü?:¾À?…­>”E•>¹Â>-¦ò>)3Ò>éE?ÛÙ>¥">ü1y?,oW>óBÔ>áV>¦¥>8 Ä=hP3>¡­b>äèˆ>cÎÔ>í˜>ßò->‰60?X†>àÊ? Ѿ?m?_ÿ=RÌB=™›>Éï">Þ%Ò> ®>q¡?ª?RÜh?_ï>#¨V>¥»b>â*p>Ù]L?*Œ¿?Hª—?ý5?:M¶?Ö>Áµ:?ÊR>ècÔ>É[˜?#<>ÿúÚ>ÌÒv>Í;>¤î >£°.>(á3>h°j?!€?\Ý”?[ùÐ?E +n?*R|?DÀö>ýÄ“=×6˜>˜ò¸>Û¦>¾SÒ>¾—>[Y?7 ?9Ä>å +Í?»n?!•?1=û?nŽ?'ëê>·±ƒ>OŸ?.³·?€nÌ?v¨?6¯P?<ê†?IãÚ?,n?µ«?$‡>?6 ª?5Ž~>ˆÛ:Õ=°>Y>”ÉR>â +?C©R?7Ò•>Öív>¶w>@;¶? h?Q-â?6r#?A¢&?kq"? æ->øö? ¢? h>øNŒ>Þ80>ÜÅý=xÆ[>ã’>ž!?ÉØ>òÊy>Ó¡F?2Êf?n4”?X´¸? øN=Èìà>ç‰6?'6F?'p6??"ïÀ?t ø?94>Õ1Æ>–Î>Jîò>®¤:?JS@?LÑó>Þ’²?‡ï?(,¶>•Ší>Æ–?¢>ßÁ>°c’?¸^?õ¦?`Ä>阢?l6>þ'ª>vH?pá?FSä>ªA¶>àšb?47,?õ?I×?Mg?*z?0›?U>®?Çu?B…‚?löX? K¸=þ½T>„·>½â>y‘¯?²³>ù‡c>¡*Ž>…=Á>DcF>Òc?"BN?çB>ÎQº?0’Ù?#½¢>ãÄ?'Õ&?¨¤>µêÂ=û”™>Un”>¿Èø?/ƒ¦?$h?%&l?[€ð?‚Ö>¤}2>s¿ü>YU*??QÂ?/è!>ý-Y?á¿?QEV>é“>¡òH>¿ó’? F–?Aò?4Õ”?²J>á†Ø|@>?V€>榘>¡t=įS?û?u”"?8ö¸>ƒ?V>ùÉa?Áé>”`>“V>;o +>%ëˆ>ŒJn>ÄV^> Ÿ>GC`>„?ü>£ú>­'|?Ô’?" + +?L?GýÐ?¢ñ? +µ¥>ýÁÒ>?e}>Eh?p¼?½ ?C¯h?&€J?7R>ø%`>‹>¡N1>dz…>“MN>üßÊ?ïZ?èq>Ñu‚?#ÕÞ?5JÐ? +7|?9÷f?1$Ö>‡¾>Âm +?8§Œ>ÆÉf=›ÎÍ>ây?0Ó¢?.'°?U"C? à ?´?;}>Éó!?$7N>ú5>¿¼x>À.>ëjþ?(±3>+§>Þ&>Ö”¶>¦|>èã?®>ö(?žÎ>Àöþ>=€ä>§‡>øYµ?#Uî>¹ÄF>Ág_>çÄ>±åb>÷òþ?¾æ?&d>ôE?4Ô?EU(>¿òâ>ø<ˆ?^5°?Oæ>×ξ?ªÎ?b1ƒ?g;T?»—? ¯’?B)é?:Î>Ô—ö>Ô+c>þDm?1 a>ÁËç>ünÚ?8Š˜>ôoÀ>ç$f?GzÑ?0ƒ>>âšV?/•¨?L7û>ïÙŠ>Jv>…(x>ßH?×ò?Aœ?/Y?0à?º¯>¸u¥>ä â>ï>+">üƒf>öjö>öŽ›?>Ñ?]†#?_Ö]>ß(ã>£|4>Ïd‰>^0à?"?eä^>àP>Ûè? #G>¾|?è>È“e>X¬>çË?È6?*Ið>¦LÚ=mK=†ÊÝ>€C?š?CÔ®?¿q?Ô?\5ü?kMØ>ê”ä>Œlÿ>é¼?™2?:,?\Ib?$. >ý'ò?Cºš?`}¢?"™p>¡Ò¤?R?Pkü?{T>¤Ïý?$c?(J>hº>îæX?¥4>yt&=J>>ÓhÓ?:3Š?ã8>óÜ?,.T?+ç\?AÒÔ?n? %?-&¾?,h?+Áú>±}¬>–^^>õÔ>—9«=ñ +>¯ih>è-3>Ô6D?„Ü?/ïc>î +¬>±ü>¨pÀ>øŠ?d@?t2Ê?.ÝB>^iF>¸ä?I>g•‘>p–+?)-‚>íÉ®? iV?Y8>ò…ý>T3Þ=’ב>Çñj>ñç±>ºd>£8V? ìü>ûõ«>J3>Ƨ>X|D>¸¤?K]?¢b>i¬=ÎuT>lâ?³?6†²? HY?OÏ +?tu?\q¨?$è>ßpR>€âÕ>Un>_ö>¾sM>u£%<dŽ>«Qþ?‹&>øà?*ƒè?\f©?@áÄ>¡nB=I¿>l0?x·>ûwN?+?%I"?Ú6>¯ëL>ã)…?CýÌ?êä?6ò?Yö>_]—>Ù>ˆ6y>GpÄ?(=ê?S`\?))#?78?Fd†?*óÊ?õª>£F>‘?1g¼?Lë?È8?·?8<–>ƒ8>ùŒ?87@? Ý”?e(?õ>扡?5VØ?A X?¹Ø>R=Ê>âïê>ÂyA>³{|?K•Œ? jl>cú>î>ðB©?¯`>`ªë>Å“t>~>, >s³q>Ê ÿ?@‚>ûR›>“Å>ã¿?S*Þ?Z"Ô? À>qk^=˜H<ÖÒ=æ4>!ß0>Ê~Í>§õÞ>Ø™j?:4€?DIÖ?iiû?0½?¦Ì??_"? Uò>r¡ >#Þ#>ôšç ?&ÙZ>ýí*>%p?®§?(dx?,ù’?.T=¯£°=‰äÁ=ÛäØ>ĉ?w?%Q?3TÆ?FÕJ>ËæH>éÊŽ?&ûf?<»â?Ž?ï6?2ž’>‘'z>üÉ‹?&{ý?”g??ƒl?.Öæ? ç|?:"?>ÀŒ?©Ž>¦a>=­?îh?ðÉ>ÿ™ >ã}(>FÝç?‘?Ô?.ú?&½ž?Dü^?>cÚ>€)o<éâ>ªÓ?!ô? 8p?G#?Fne?3±6?7uÇ?,æx>½_ >£¡ô>Aý’>Z¤Ù?é?:8? *ƒ>“š>Ä9º>€öŸ>äQ÷?µŒ?(•4?”>³à>¦N&?oþ>õ6>ÆyÕ>ÃØ>Sªh>©2>B¿¶>ÔqÈ?Úb? Cï?#h>ùÞ>ºüö>ã=ž?Ð,?PŽ>†d>fÅx>á`“?8ë +>èñ>nC°>Y +ý=ø#H>}6æ?|ú?ºI>úD.>ë—š>ß>¸ª<>È>º"?5­A?`‚#?fù??HZ> +8¼=Þ=©]Ö>´uj>ŠšG>S]?ŽŽ>á­ >w:=P* >êp?s¦ ?:Ý2?h? Ã(>ªËi>2_>÷¯?/¤C?:?/õ¬?&Z”>g >’‰â>íl>æëZ>æÍŽ>wÊV>„XW>>9º=$P=?ó?Uá|?NÀ(?é£>¡®>>«Y.>Ša?˜? Í*=ÂwÞ>ÈQê?çþ>F›>·ä?1üî? è>ÇÕ–>{ È>Ðnˆ? ç >Î|•>òÎ[?Uñ‚?kíZ?ŽÓ=µì,»ˆ’à>’Vc?/ï>°µÐ>“[™>þ8 +?Cã¼?V>qv>Ì×>âþN>Ø:¦?Óe>Ô?6f +?7¼œ?f>ƒ@? a®?hx†?wk ?l?"#F>õ†?NH?MÕ°?ÿ‚ª=”O>’Hˆ>Á\?Ù›?E„ˆ?R¥>²Ø¾>bš>Ú ?Cu?ú>­ãJ>¢ºr?N>ú8F>¤->Ílv>Îç,>ó>,x>†À?$ï +?=>2S0>Kç¨> ²>×ðâ?F×v>Éåš>Ô ?F]>Ìý$=æ +=ô‹b>³Œ>øC +>õ2«>ÜOÓ>¹—>äÈx>‹º2=¡2>š>>ûp?`Í-?½h>k‡?’?B'»?x>§ n>ý>¶JÞ>ŽI;?->’5‚>¬×C>¾äP=Æh`?Êv?|-? ©>§8]?<?!„à>ÑgÆ>†8?S?Z0>Cs€>¹hT? ª>ÛôÜ?‚?æÑ>óé*?PWø>ýõ[>'¹ã>öÖ>Å‚R=Í Æ>j)b>ÎÒ¬>’ãZ>„D>”îï>·Ò?)³1?-!,>ïB?7Œõ?pà"?vD‘?H®>±Ö<><@Ù>dʽ?¼?l´Î?†>ðc4>÷I^>r’²>¾Úƒ??S3?qøâ?RD? %>ëI,?u>ø" >°Ê>†åL>ñè? Š®?&Ó’? ž@>½­>øô?*“>·®Z?Aþ?C²F>’Ok>ÕÏ6?T—*?÷?(/"?>HÄ>ÁªZ>Þ3>›Z=÷.Æ>æi1?è>·ò$>`•ð>¢ô"?Fª +?2;Ì?ÿf>ÌòÀ>©7Ã?6àA>öƉ?B?.iK?3òþ?] È?A.¢?/Þl?9ˆL?P$*?*š–?6á?@ƒò>¤¢Z>¬Ý?‡>÷l?‹>ú~È?bð>ù È?¼t>ó7ü=€HI>¯RQ>Æp*>Á V?0­?7á +?$—?>*ž?\'ä?ªr?,p?!>ü8> Ç@>‹éÆ?ç*?T>ï‘b>ÓÇå>û>á¢>­wU>”>À,?Aê?0óž>—M>Ú °?0ÂÜ?E¶x?"_Ì?¶¨?OÔV?-š?6n?™«?/Äl>Sè=×=>~-í?'3Ð?Gpl?PP?Í>=!æ>Aû0>4K‚>•œ? 0U?º?(Ø¢?`Øp?UþÒ>ü$>8ü>I[(>ò³^?UÂê?&€?-hŽ?”˜? Ÿ¨>ê{d>F >Û¿F?2îØ?‹x? :,? ôÊ>ÛÝ>Ðoz>öâ>œhò>>}>ñæ’?q ? ¸?üD?q­J?Kò>Û=&>—ãÏ>E?l?< ?RV?e^u?+^þ>aS >Kö7? ±?Mr? ¤X?,ùÄ? +à¶>§ñT>øˆ?Òf?ÙN?+áè? $_?+ÁÕ?*öô>¼¨]>Ö°U?Amô?WÉ°>Æd¼ªNÜ>è6p?0‚´?+£™?U1†?]¹B?d'â?P»?Zv¡?YÌ‚?Ã? KÌ>Û n>Á›{?>Û…ó1?—¤??#> ïý»u"H>ËÃ?>Œ>v&O>F™X?"T?<¨(>ùj?Iá?\å’?!Uh>Kq >Í]M?^z‘?fð?_? œ,?>˺?!ŒÊ>È…À>­Ã¿>é&?…†?“Q>«%Ð?#sP?cï0?Plð>»f!>ñ2h?R‡â?AãÒ>²öó>ðµ?xwÌ? 2 ? • ?/K\>sJ>@B>ßO?O·®?zÒ?8œ +>Êà²?þ¥>íõ >šíX>ôå…?)iH?)`ž>”>’aÊ?N¾Â>ü}’>]ÃÌ>bÖZ>L©.>¤à>Ï#>ßr@>Êà¾>Ð š?@¤Î?I>é"ƒ> +£>Ëwž?Ü >w{<>{ªq>ÐjZ?¹(?¸>’b=àõH>xVà>ùö>Öö>ØÕ¨>P ¼>*ü‡>Õ? +ù"?X†p?K2ê>áø}>meË?Va?²“>Œð>%¶>Éå–?!:?u>ôÐh?'­9?S¸¤?Tƒá?1P>sÀ>HÃD>í"(>»?ÞŽ? +O>.«²>båè>hš>»‘Þ?:¯Ì?mÝá?%ØÀ>Ò.?å?'5ñ?3 +P?Ël>€Ä‰?rÏ>÷9œ¼¹´>a6:>ô¬T>§’>§,J>ß¹D>~@Z>Ö'„?1‰Àé¤<ïû>Ÿ>²h <õ „>:¿ð>œkõ?‚?U÷Ô?!ÃÆ>§™ +=É+V>Ãð +? +Î>Ná¦>ò÷æ?nì0?J‰‚>–¬~>!¨> Î¢>ÿè€?CZH>䲓>õÈŽ?%î¨>E²=>@m7>spq>“ü>µâV>í(î?8Ô?/.?øÔ>Âþ6>‘Âë?Q?K°>º^X>ÛÌ¢>Ðwv=Ÿ’G=çÿª=’Ù«>h¾?+ÅY?B?¯Ê?-ÜÓ?-€’?&z?ª`>èId=ÎJ/?P>ܤÔ>E:>©m”>› ^?sj?@ID>™¦ª<®fí>+ÌF>”Q ?øø?=B>ö§®>/ôñ>¦WÞ??§ü?¦h>NŒ,>³ 0>ð§?B°?{K6?\ò†?9•s>­z>ËD?T›?)Ý?[®>ç}=ó‹Ù=…p?— ?qY£?[gS>ñq>>6 À>rÈÈ> @ª>ö$?«|>­2^? Žh>©EÍ>KWÜ>r#6>ˆÛ?I?TË ?Hµ>Ê™>ÀU>Ê#>¾–>ª}~?"î”?7 +×?US>Ž¶l? ”Î?"ÓT>ŠÃ> +Û?-‚?K(>Ç~>Ó_â>‡¼|>“/==ãö>ùr2?'Ò>§ñ^? ‚?P#°>±ã»=æ€>“‹?6®? ×)>ù‹÷?[J?°À>Ãôs>ƒg>”6?3âà?G ¹>ø>{•7?ŠW?>ëî>Í o>Ë’:?A©€?tìÝ?>§Ô? èó?E;?oš?AF?5c6?5 x? +2Ö>ßÓÈ? +¢þ?b=?[*0?QŠù?sè>"²v>Èpÿ´>аØ>r{»>ãŒ?#Œ?4÷×>äDÊ>Â…ó>¯÷‚=­È‹>Ëþ?æ?´f?*W>ó–³>Ä'r>cø¨>عä?æ>¼m‹?¢ >”’2>|42?+±–?mIì?">ŸÛN?ú?j?’C>Ån >Ÿ·õ>Ø3>Ú—¼?À}?–´?áL? #¼>ö4X? +÷?>…N|>¡n>u“y>°Œ0>•Ã©>Ý‚?Dý<>ÝH|> ò>ñã´>×dJ>El?¡>ק}>ú Ÿ?Zöÿ>â-Ø>D^î>"ŠÞ>ë*S?\|à?t‰0?ÓÚ?Ì–?;’>š(¹>T>6b:>Þ•[?>£î?Q‰ð>üÓ¶>ó«"?<{2>Ìü>¯ž|>c‰z>ü î?<—>ÉdÞ>ä4?9ã«?P+f>åÙJ>zÉe>j6>¡ÊŽ?4°>ë$?eh?næ¾?=>ŒˆH>÷ÿf>Ãæñ>õͪ?.hü?Ìš?[s?0ˆ>ÓR>è7ª?rN?3y(>Íw?? +³?F·t?!e?Pz?!;Z>E´Ÿ>¸žß?H"ø?™)=Žbª>Ë(Î?, ã?P¤?…¾?cÿÌ?—>¯Üí?:`>Í'Ô>s–Ê=Š»>µCâ?”]>ÎqF?aü>Üž7;M˜>¤8ý>æ¶>µg>÷ªÜ?#õ·? á`?3‡¸>ýbà>Æ?ˆ?&,É?E¶>ß?">’ªí??·?, ³>Sk+>|ý´>’òk>Ýî™?ZR?kéf?F‹?\(,?&3Â>ïÄ›?’ð?Û±?®@?5qË? +¶ç>Ú§2?(ƒR>ý9î>®A>¬ÇL>±:ž?¬˜?ýø>µè?6”?+à>òp?AöÚ?\Å'?_àš?X<|?Eº?H0ö?%Š?Ø?'¸ª>Üx?>?B"´?'ÆH>ÂŽ•?"Q¼?* Æ>‰L?¶±?C÷>©˜=%Yø>Œkû?Ÿ?;„>­¡>ÁcX>»*“? +ÿ?6ÂS?.d?hXD?B®H?î²>ªAˆ>‰ó#?Bk?(æ„> ô=ÇÉü?æx?bwö?Tðf?5­>3íe>ƒs›?×e?7– >ã®Ò?¤B?#pb?3 É?#x>Õ^?ÒÕ?̦?9@B>ß½?€0?4Ýâ? ÄB>„ç³=R)û? 2È?Rá¦>ÑNÊ>|,œ>|$ >Mí©>ãèÚ?3ü?8~Ü?|>ÛÑô?8~N?Wý?8næ>ò <>ÚÙÒ? 0?cÖ?X2>²ñü>Îÿé?c1 ?4®>Œ•>>÷ð¼?UfÂ?ekÅ?>Ë>×W?p´?@0V?­Ô>¤Íh>ƒï—>iM†=ÏØ>"©>U >ë¤H?>Œ>´Tö?x>?ÿ`>šoð??Jr>ˤ8> C´>  >sV>€Úò?Aˆ? c®>îŠW>ï—>î¾…?O +F?d«l?\¡?-¯>»~(>@‚V>³˜H>üÓ®>ãÒà>ñ`ì?3ÓÖ?~¦?€ô?¢?kâ?V¶Y?wñ?JÝì>éýœ>qâ>D>Ýh?J*?[Ð>³šj>¡»2>Ì›X?+äì?p?ó2?tª²?Gó>æ$Ê>ç”t?EÓÚ?T†?<³>ÜÂ[?â?Cð^>Ô$>ŸSh? {|>ý£â>YÐÄ? ú”?Íò>õŽ?éØ?"Yì?™>xÊÀ>ß1?#‚?@0f?iå´>ßþ(=s i>þG.?j4?QíÚ?62È?]xœ?¾Ð=áÔE=x ?>MÈ?£F?r·¼>÷~C>8fó? Þ5?}?æd?nœ.>ÖÇB>9X©?Æ?K®òò>šé1=J¦ä>è ý?u ?BV¶>ãÂŒ?*Èü?=˹>ûJ>ãmí>q¿ =æ>3Т>ôY?E~ö?m $>Ý¢»>°F¡>åQ¤>øœÍ?Kx@>ð~F>Ö;?4R>σ:?÷†?j >Æ+Ò?>“1>hÀÔ>­Sf>ë?©Ô?6-#?¸Î?¢>á7,?íX?zøÿ?wÌ>Ê­»?LZî>ðA>vZÞ?*¢l?8ż? Œ?LŒ×>ø‘X=ØÑg?bž?y0?<â?Cv?Ѧ>6M>eJ=î7">vÆ?&®?[¯>·«û>ã´?<®F?n8^?"×>‰Ë»>ˆMù>:ƒëuId>ó\©>ðˆž>ña!?/(é>þk&=}ìÔ>ÛÜ2?`l?°ú?"¥>Ê 8?/óæ?:ƒ8>öC”>q:>ÁÂc>äò<>Ômb?(tJ?RDÉ?õZ>²ÖX>€ªÂ=ýäR=úlM>°„`>ëpÐ>öÔæ>âR‹>Q[i>}¶ ?2ît?!±>]¹ü? £?[¯/?P>ä“Ê>퀚?3 ù?Å6?@ v?jn>ç±G=÷ÚÆ?”æ?) í> 24>!b(? q°?P^>Oêx>{€ª>¶ÔR>é[ >ï{è?Ÿ˜?.ª°>í…>‹…?5¨ +?NxÆ?` >í¾³>“ô> >ÿ z?F•è?8à®?P—’?=W’?2>ÂÄö?" –?D?fº?büV?.•~?ÿ?6ò?ÍP>Ї? œ”?WKŽ>ÀŸT?H3?Äœ>ŸQ|?æ¸>¢Ð$=K€ˆ?øJ?¸?%|?g¹®?¤ô=Óv#>r¤a>¼u¤>¡ðð>$h>ºg,?ˆ +>&íˆ=çK•>ÿÅä?+Úð>®Ô ?÷æ?i˜ ?Çü>Àê?(·:?Ú¾?4óþ>Á ¸>õø>ý)¾>“M?)ßz>ãx@>kC>㥪?±L>[0y?S?†ü?"Ãè?ÁD=¹†ì=†-=Ä5>Áz=Èrû>Gʼ>²sº>ÅH±?&Oî?'lç?? +¶?pJ±?+nð>Î<>èÒ?dÃ>?UAë?$TP>° =ÏFÂ=é÷>&)÷>Ó„Ž?B-N>ÚU >™ëU>Ñ…? N?@P†>ŽQ\>rÔ?ËÂ>ÿJ?X?Gê³?7PO?EÔ?AFT?Xê>Äà˜?íz>ü\?;¸?f >Ú³=•X«>ïÂ?J‹>Ö{è> +¥ >óD? –n>ó >Ö©T?Z-?b\>ôáx?Æ2?N‘“?$ï´?­Ô?*¨T>úÊ—=ã–\>=F¤>Ö¡}>‚ŠI>ö ”?I¥ü?4¶è?MÍ@?L:Ú?Ø?Ïô?j|{?SÕ?Œ>ÚÉr>é2«?Ñ°>÷æŸ>˜Gº?Ý(?"¢&>{‰<>°“Ò?ÿ:>ùN>zÚ>Þ‚º?)q>”ˆ(>¨ë²?ˆ?Ú?5ö¸?5f>þÿ>å>º^b>m0â> rà>uF9>¯R&>½²„>øÄ&?Y\>Üœh=³t²>ÀìY>Ý:>~bG>öË^>Øc²>?°>ÌCê>MÀ>kJ—>iïÆ=¡p;>Ê&>ŸùE>ÑÞ ? kT>¦.Š>Âø÷?[>Êî@? ?=Íl?u¹8?{uH?ôx? 9f?Š">€ÌÖ>\?? r^>·ó>¬¡=è—,>þïÃ?Xë¨?5~?`>¿Å >ò~Q?µE>2(g>˜PF>Ÿ‰È>æc>´Û=OQ«>ò_O?\šÜ?«­>`h0>Ï.j?gnö?``? +­?dlÞ?vÊ?œ>ÐÎô?@‹{?Å"=èèî=øl?¸Õ?2Z>¿£*>`>¹ÎÀ?-B°>é>‚eÐ?!ã–? +^>Ô„Ä?ÌK?„e>ç–¡>¯°?/ê?‡Ž>Þ¢|>ÙµŠ>Ìá•>Ä ‚>š8ñ>$X_=¥,­>Ë÷ö>¥à>ã•&?@B~?4 ?çþ>ï‹¿>ͧh?ìŒ?k“Þ?6þ>ö©Á?<˜t?*Gª>¸5>ͯÄ>Ë:>ÒIŽ?A??w¹?÷>ÛÆú=Ng;>sR?6aá?t{A? D>#j >¢ÞŽ?$€?P|?_Ô¢?/ò>]ç¯?Sý? æ=>ŸëH>Úì? ÂØ?]Æ? ¨æ>Žoy>œäî??Rh ?nCŠ?Xl?8º>™ì&? pÆ?!Ä >ÍÍ–?%YŒ?VÏ?]>ïöT>²6?Gt[?T•õ?”j? 3ˆ>º[|=øØ$>´4þ>ÝS<>Bth>W<”>hÁÀ>=2>ßÄÌ?&.C?L81>óÙ€?)G?>ÔÜ?>Uz„>ªG7?Mbz?MÐ>¢÷L=ûð\>‹)8?š?m`"?9¶f? nò>Í”²>¹z"?…¦>ðf?#Rö>ûn»>ˆÿ\?-àö?Ž =² o> Š”?>‰É?)‚œ?% Ä>óžn>i§ì>Tå’>á +Ã?@.>Uܱ>™Š ?73?™†?Cw >éoý>òq¨?-†?äN? <ì>ÕíÒ?1Öî?>Yv?(ÝJ>ú¹œ>Ì@’?3|?Hå4>ùÛ>g\2>‰qß? U!?jéV?ÒL>ÚX}>Ú >3N>aT¨>éùæ>¢R)>Ñ@Ì? >Q_¤>óæÌ?@&Œ>³ +¼=Ãœ0>ðÃ|?SSn?N?h>ÝaÑ> !a>µ->CxV>ñ>Û Ã>©ý>Ú\n?$ÊÎ?)&Ô?Tð>¿2ó>ê87?CÆH?50¤? l> à>òïŒ>íK>0Y>³Ü©>ž¿?Aµ^Â?`?Tƒ—>Âá@>0ïd>ÍѺ?'Ih>þwN?’? .ü?#Áæ>ú´>̉à?’'>¡K?œ? +9'>öUB?"Û¸>ã¦ä?0?gW(?\{n? \¥>²ìò?gÕ>úiØ>ø\ ?!ùÆ?9‡6?]>Ê&>ë6=ò‚j=µ„@=ðß>â®?D·ä>Ä{î>->4œ>›J?/äl>é¢=÷4ú? >çéR>éJQ?F; >öV¶>kË4>Áç2>êM0>¥ð.?Ÿ?MD?/ðz?€;0?~»K>öRP>Wþž?âä?˜Ï>‰D[>â}*>ñ]>f%ì>©Óž> ›É?"e?9Åt? Po>™è*>ëH?x0:?6þ>ðnÃ>Çœ”>þ`1>ÉË7>—]Â?Ì>?%¢>¡Þn>×?0Ì>§Á¥>ˆbÕ?â@?¼»>Kæ}? |R?×W? ¾ß?(‡Ò?ØI?Û‘>ßÂ>Ý>ž@=¤I>¹À?#æz?\¥%?UJØ?æê>¡QÖ>’kP?8O ?tæ§?8¾´>‚1½>úÞ¸?h–S?Xëº?YÊ?Ž,>Âç>?ö >°^I>ÄX>x{§>ò¤ë?4¨b>·xö>ð³4?DÝ·?¼R>—9a>Ma§=À¸Â>ƒÌ°?8h¸?ÄI=ò…«>Ý—Þ?kß²?!=>™óz>,¢ƒ>©õ]? Š?ÐX>Áþî><©$?, Š? ˜>é»z>ðXŽ> A|>˜k{=@à>T—²>ø­i>¨pÂ>ýY0>üä>ÍÞ¢>ÎÇ^>ù5¾?±>u>XC>žpŸ>¦Çà?¸ß>¸iÔ>ÖFP?8ר>Àÿ3>‹T¢>òÍÊ>œâ¦=àu,>öø>ðàì?àå>=Ó`>Ø>­|>JŠ>õà\?V؆>«mt>ƒµ¬>°×¸>Ö•?'š*?KQš>òþð>Œã¾>0ã?>÷¸^? «=›5=œ—>Ô§•>Ëîo=˜ý¼>=´ú>Ö­6>¯“Š>„_ +>VF?¦?fÍ?-Ér>Äq–? þ?ª>¥.>¡ 0?êª?ä=É8¶>õ{N?8Ì.?8?†à>j·$>–ou>Ë~h>l“ü?üP?A`V>ˆÃ{>õèH>ô]¢>¹0e?0V¼>›[T>|²¬?/‡f>×ÏÊ>zÞÒ>»#T>Mn=|çQ>Øx›?i"–?*’b>Ä2€>–¹ä?4H?b_U?nW¤?®>¦DN>Ö€º>ñ$Œ>ý'>ñ–H>ºýÚ?Cj?p ®? ó<>ÿ>¨?C8>ÝÛò?­.>¸¿>‚=>žþÚ?ñ~?xlu?~^>–\->¥Lx?‹?>ñòæ>Í?Yû?›>Ÿæ~>”YT?$Ú˜>ïâ>ÇØ?4T>ÜG=>TÜ>˜õu>ÕÏî>V =>Š)£?Ö{>Öôb>À!>äf„?3VZ?+Ï>½ô¸? +?Buð>íy"?#_•?M#?ž>‚À=²s€>®‰þ?ª¼>ÉÁ> §= ±1>Îá?±Ö?DV¾?i0?6–?¸?$>È>¸ùt>+!«= †[? $?KÄÉ>›a9>ãrú?óG?³q?>ï…ÞÄ>xz>ή‚>©Â¬?<²?7•4?£ë>§›,>a>lht?} ?%6ø>F>Š¿D??|?X>_˜Z>Ñ·°?xö>ôû>_{ê>ÚÁ²>Þ¬´>´hÏ?5çL>þ‡¼>+Ö®?&=?=Çœ?ý¿(?<Àk>öp$>4º·>(ó?`?²z?8€ ?¶ð?/ë‹>¢‘5>è‚"?$Ã?U¤>ôoü=Ù¨T>•ö?*Ä\?k??¸?/(>U5r>Ñ{Z?\¿\?ž|=é[¬>•@c?Ü?NµT?Iø¤>û ~?©z?;óâ¶>âÈ>ó'°>ë¦S>­Åº?zñ?Jfò?0Û?M†½?]>6­•=GãW=”„Ý>üzž?muà?fÊ?H>¨y>üH8>¬ÔP>{-Ÿ?0$ü?3B>§)œ>ÊOj>ð#>ítš>ü©Ô>($>¡Ž >Î7¥>’²>µÄ,>=çz?[f?Í$>?,È>ùà>äd?+ct>ö2>·>ˆòJ>æø¤>úø?$¾@?Z~Z>ÿ¡=©°L>¤)2>ù¥O>¾ÕG?¥µ?FHÌ?BºÈ?e>À/6?s-?C–?#‹¶? J?Lv>?>b˜?&Ùª?$éR?Ê÷?o?-¸>%¥>œüÒ>¹˜¸>Š±6>nGØ>CñË?²? +’V>É;?¼–>úä>qã?P‚?,4d>¦(>O§?ž|?\r?ïå>F +ü>ø>ˆµ >¯•¯>Ͷ>>®ÔH=›«>CÎL>Î5L>¯˜–>بX>¿t>;r?©?9×>§nœ>‡ñ,>Ë!?(`Ñ>ôǤ>þÄ?:->¿$¶>Ïê?(ª¦?-¯V>±¾ >‰=9>²¤Ð?0?i|€?gnl?HéÙ>З>ûx!?xÐ>Ö‡4?Kç? <>’>íû>ôÿ|>˜v?n^?)•Â>ŠÑ >ë7Ü?;®^=ÇÔ>®'ì>Ó&>âŠ?NZ>?I6>·ü >KSÄ?%ÄÊ?/îY?5¨Ê?c±¨?[_z>ｘ¼xѨ>‰$>ûzŽ?'‰­?6jR?>d?B©.?'Üö?Úa>ƒb®>º¶ú?ír?…>ù®”>‘·×>Õù>—î>ó«Ð?Ç>•ŽÎ>ˆe‹?p>ãG˜?ç?M´? Ö>°Mí>KXh=·‚E>l¤@>Ì7„?œi?C€>ÑlŒ>BêŽ? Ÿ¹?Z&š?1+>¶‚Ð>æ?P?O?<À?]þ¡? Ìš?j3?W:>©¬>®;à>À!>«Æ>ÕÒÆ>ž;Ž? A?<³„>߀r>ÿÒÿ?:‚8?,?!ê‘>¹œX?áX?He>ïñp?¦6?IßÚ?Äy>¸~>žŒ(>¼Ó¢?©>ß•à=ëûÝ>Ö)Ä>¥4Í>‘w>`uˆ>¦›®>WK“>Œæä?M ?$šv>¨×A>ûÌÖ?Fhf?4V:?"Õè>g˜*>bo»?)-=?Ed>ÔPh>]Ÿ>¼Ñx>¤VZ?ú¯?UÖV?/·ô%º?úæ? Òv?1#b?>èû?1Öˆ>Âöæ?a&? +}¸>¥Z?"ç?B>±¤ä>€}X>º©>ë],>.¾¶?ÄX?D¸ò?@D3?×Ä>Ùã?!í2>Òš? +ÐF?.Œ?"|?‚)Õ?Òì>Òzè?=®?#˜è>–¶ > j(>î¡Ä?-TØ?E ?-Ô?<ƒ>@jx>^qR?«>?Q;±?'‰ +>z?“=à¾?Õ¤?q™Z>ï9ð>žEh?>Ó³? €?$—?ñØ>ÎqE>›˜þ?71¤?R¤Î>ò—6>Åû,?Nf4?tûœ?3 ˜>Óy>¿ó¦?´‚?%l?.?Ov?9ð?N-»?;éÞ>Ám"? +*†>ë¬>Œ‘>¡‰…? ˜?=Þx? +!>/.?Ɔ>ú@¾>B>î?Ò?O3’?*… ? ¿?>[0? Sß>hì>œ,>î´`>¤ +>Ór¶>ÛâÊ=ú£S?S?|Dú?Þˆ>Óƒv>ÙÍÖ>–C?(E8?D{?U]•?Z5°? À?/Á°??‡t?BXÒ?lv¼ScD>ûçÝ?.J>»›*>Ëä´=ˆ_&>2:Ë? u^?J( ?)>é2v?0Ϭ?'nV>°¥2>¯=?6ÁB>ïg?9Ö?7«ô>ÕsÅ>ðä>úÌ>>L’>×Í>õVä=q|>MB6>¹_è?-ú?sÆÐ?CÐä?EÏ\?@Æ>¾$¶?@Žn?&2>ç?:e>¨1œ?)E?=x?Ýv>Çš?&“«?ã=ù¨$?Òs?PŒ?Kº? ¿›>sS>žü >|¹>æ^÷?n?ëó?6è}>¿XÞ?».?'¸?‹ø?V“ø?hvº?1Þ>NVr>RÌ ?Ž?'½Œ>ÿOº>‹¶H?9?Lp>Ú?c*L?6-ø>Ú©>Ò 0>¦å?ÙR? >å +.>°üÒ>Ñ‹É?/ W?Z)z?IF>ÃVv=Ú²Ý?OÊ?A?$ëœ>î¥?w?+¼>u”Ã>½ >¼‡‰>î¿x?Ú6?µ¿?5ÚÐ?$§?H'6?|hÉ?!p>É}Â?3j?FP?M¢>ª»d>n«J>å >ã#²?3¼>ëÌB>“6?\—?Ä]>Á®‘>Þ]>Òv˜?!C±?%²Ð>²©U>M ^>ÌÓ°?U<? ‘q?s4?H *>↤>–`,>·b\>gä"=qõ>µÓ?%ƒí>Ñ°q>›+,?Ñ·?[z2?C„ê>¬v„>Üå >ââ*>†º×?Š¤?±Ü>P8*>q°®>ª•×>¥¹>öQt?!ܨ?±a?Ï>Ƨ??-?Y5Ô?5b>ï†>ú@À$? +ó–?gØ?ê€?°h>1xS>¸‘§>è,Õ? @Ö?ARd?ÓR?Û?=™?BÕ"?ö,>‹BR>'˜?ˆ +?¸e>âU?cµ‚?ZÞ:?Œ>œBL>“ +º>¤j>ÀRþ>Êé}>’Â<>òÚ>Óë?Δ?€Â>æ_ê>ð÷P?8ô6?!›R>ü&ñ>ÿu>ˆ ˜>QÝÜ>½Ž˜>©Öâ>Ýã? •Œ?G™æ?¡Ë? Òß>ø©?÷¦?2†–>ȲR?? Ç$>VÏÇ>«ìÊ?AÆ?Wó×?Ïz>ÛÞ?þ ?8O>?Ð? §ð>‡]Š>9]>?D>ó°>°¼¬>Á¾š>˲? + ?*ä?Vج?,éŒ>¤·6>> d?x$?[Ñ\?)×>éN\>¿ªD>}°”>‡–²?‡e?&Ñœ?Í>Øÿ>Ô´P>Œ<>Ǿ”>ßÝû>à:l>±m>íà¤?_Zæ?ZÅ?.’„?ø?;®?\ +Œ?!›¼>ï0>:È><2¸?Ö?;h >Úi>HQ>ì?¢?Yô=øsò>ßc€>æOÀ>V<Ü?C°?k¿õ?!‘">x-¼>TFl?z2?È>Qž\>þ,?VåŒ?l=êO >)™>¥­>äÆ|?ð?4ÞÆ?SgY?LÎ>ìŠ?*v?b(Ø?>Ÿg6?!˜?.n? ²?&ÏY>~Ç>öLÅ?]É2?}@?"z¶?3Îf>†W=U½>FfÇ>µ*Æ>áŽ>Šõx>Â0t?_®? >Íwê>Œ-Ú>Á¬´>àƒp?5ùŽ? ì>bwØ>¡­>Ï?1Í?3Â>FÎ>>2ýY?d)?pK€>î²´? ê¼?XÛÈ?:¬’?Cº§?Hú?DG?ô>Òm~>ßõJ? f?]ý>^==«9;>™}S?"ñ‡? _? ¸?j$Ü>úbÞ>ÄXÀ?\ˆ„?ê¨>¸ºv>ë>åf¨?#`?`ß¹?dÈ‚>ïâð?›?LtH?P@²?,>>­8>¦.Ô>´?l?#y*?2~Ò>¼­¾? +<ã>Ô +>6’?;?52>÷7Ç>£²>²·\>ò¬Z?Q›>‹&>`K,?9ì?@8?&G?#ù>µ½>$%Ã>Ø·4?:t»?f¤>…öp>ºÒ…?")?!€g?+Úƒ?M@?X ?^æ?;%^>Ç*?‡?=8??9è?$G"? JÛ>²žÑ>÷¨>ÍÒ?S.?SÒz>³È >˜&è>ÿYà?¬W>ûY>‰C­>{ï9>ð§¸?l®>£æq>¥ñy>è¬?28?‡°>8¹>$pt> 0=- >?L? ]d?Az?S î?[}©?`Æó? JÒ>7©Ì=ƽ>TÐ>è°†>A?%x?1™Æ>½[(>Ë=M>Š>@>ÆgÎ>² ø? +k?9g?Œ²>øIn>¨Œ˜?,ß>?%„=ÒzÆ>®Ç>¾}=¤Æ^>¤ßö>±Y> W^>ô-Î>é;?ig?C&æ?Ê(?€©?@¾>ŠÆ>M6l>fÛŽ>¼Äù?9%ª?¹¯>†Y>ªE?*X>¾f>,‰6? ÒC?.>È`^>Ë>>êÃI>ÑáÈ?†»?mñò?&>Öâ >ç–>¶Êƒ>ãÖ¨>Þ·~?4?îÄ>ø1~?P?Ot¦?L×>þi?@%Ó? c1?ÛF? Ç\>­~2>m÷¤>†>{JN?3g†?zØ‚?Ài>.^{>]Wˆ>%—r>5˜1>» ù>ÌÐ*>2 f>þn“? :º>Án? Hd?ø>ïŒ>O‚ +>¡„?L3Þ?N]Õ?b>ã•?Ù´?*½6?þƒ>¥uŒ>1Ê>šÞÜ>'?$>þŸr>ÎKÈ?=Ã|>ÈÈ9>»e®?ìŒ?Be"?2/ô>ÓzÄ?(ü¯?*wà>ßê?¶Ò?2Zô?IGO>üäè=ä h>s‘??‚>ˆ+Ú>ÕFò>”Êÿ?Ž?°>d>Hœ? óŽ?^S˜? ž=>±bÃ?À®?) ã>¢…‡>ë*º>ì,G>o{j>ñUj?,—>ÁQª>l[ù>î²ö>§@Ñ=º³ö>åF?Q?Ýœ?'ãË?!A?0 ­?B´>áQÚ>gä¡?Ó?a .>ÓÿÎ>Øž?0?0>?IM>†åû?"/–>øðµ=Ùó>õâ? ~>Í)¹?ò>—]z>âØe>Ö¡r>¦>—ÎQ=š^–=ùè =¯§.? Ô?%ž>§Rç?1:?[µÚ?QL"?+Î>ðLP>’Ix>ñèB2>óK?· ?™È?F&Ä>Ï]ù>³ÔÌ>˜û[?×?u>?ê%?_ÆŒ?[:? >xo›>˜.>¡5>ÉS¼>í» ?R`?GŸØ>°Y>¯c >ÌL=Ì«?Oå?=><'ž>ÈñO>¾Ú>¢–û?Bô?LG? b>ÚÕÎ?5¤>é>ÇûL?”,>ï¢Ü?×\?³·>xè£=Ž¥õ?H¾? wÀ>à,}?0¿Ž>ðØ?!V?1º8?AƒB?èN>ëk>’]}>ZŽ?W‰?@|ª?G«j??‘‚> ¥>vÈ>&>†Ó¹>õ¤(>̃?….?ú?óV?TÈ>)î§>¦‹?±Ê?*®F?L&Ð?]Œ?‚þ?7Û3>ªüÜ>ñàî?Bw@?B ?:ÔQ>Ù]t>>fÚ>‚=½{Ö>¡ÆC?Oeè?N§»?S¦Ó?1÷Š>Xä>¹¥p?Sxè?TÎá?9,? ‡P?{É>ž”>>gÙ>Ó48?; ô?&^>°žÎ>™ßÉ>øµü?;ÌHX>tt>ãî>´¤’>¤›4>:˜Ä>Ô ß?P+t?é–>sŽ>F]Œ>ÿyü>Ãæ>>†º[?í³>ü>˜?G;?9ņ?iH?.oø?D^k?+¦ý>ŸÊ–>HzR? 9ê>ý±y>$·ï>¿¢ ?(¾”>ó{/>ñ¼_??¢œ>è >v7k>aË=¥Íô>ö2¸?:£Ð>}ƒ!>š¡è>ߪ™? á»?9`7?n¾?â›? —è?2'?*UL?«b?%¦B>¡o|>ò³§?@üä>³bŒ>›™>ÏT´>¯CÎ>—¶>Ý×T?\Ç?H>âSë?7„.>þ¾¸>ªv?# +?'”Â?Klø?•¸?Ë ? êÎ>H…? ß">Úáõ> m +>¬Æ?î’>ó=>䌓>Ó’,>Jh@?5-ø?@×ä?(¥p?Y]?¯Ü>çF«?2Š?4iV?ŒÀ>ˆÁ?¤Š>éµ=bd?>P¨Ã?2½Œ?]ï†?á?-û`>ï?¸ž?s•? +0Š>¥OO>ˆóF?Ì?5{>•³(>ô?WÁ?%Ä>ä¨?1ù†?TŽ?FòD?3‘²?M ?Næø?_H?¢š>å{ü>t =þý>­ûe0={vÉ>ýYÀ>ýy°>e²>»>ñ?/ª>†NS>A´Y=û«>ü??t?!Ql?dÛ?CÞŽ>½k>U^*?eF>èöh>£E>§P>GB>Aš?(=²?y`°?Ð>òf4?;¸ò>ÛÄ`>侞?C³? :”>±…¸>’þÞ>gl˜?8 +?8¼T?¾Å?›?·|?$¯±? 'œ?$U;>ãèÅ>%ìJ>VcP>÷ ?@'?^/»?JFâ>¹d">‹•6>r¶±=et©? +ö„>þ`.>j§>ÛÆ¿>ãM ?T\>‡:˜>Øx?6Kÿ? ¯?¼?!]}?:…È>ßÛ +>×ýÄ?]@>‡Ó}>JF>¼ß>”© ?©¾?&V?++?‘?u>Ö*N>U,„?eÛ?5zô?Ÿü>˜Òy>JY>>} s>Ñ„>†`ó? ?A5J?.>Ø;?Mª? É?%æß>Àr€>Á1?X7q?@G?–p?,*B?Th,?h_œ>û‰=ê· >Éçd?>ÌB?Æ;>ÿt.?¥ +>­ÿã>ð¦5?-êä>ž7¶>Kß?Cq?Ò¬>ñ.r>ÕTõ>Ÿ2>žâ?Ò?AÝ"?w0?2…?Dø)?7G!?J!T?F`Í>¸eê=Ê_b?ëÅ?P¶j?#à0?7 +‡?Ì"?õá?Í©>×¹Œ>Õ]Ð>¦,Ž?*0Ð?gÌ~?Q,ì?[¦Š?W¥¨?Åš>É’=÷æû>ê· ?| ,>ýcÊ>y¹Ú?jM?P?Ð?¶<>:mb?"?Â!>"œ)?"Ó?z»ì?+T>™Ë­>óû?ƒÔ>Ñë¤>ûýt>‘+Ä=âÆd>½Á˜? + ?8 Ò?E@?VNÄ?kÞ?TŽ?1Šr?+¬Â?ñ4?=H–>¤¦? g@?&]«>–>¦é>ä/?<Ô?b\Ò>ñhB>U<Š?×?B?Ð?:h??7Ž¹?H·ô>¬i6>·\y>ËçJ?aq?õò?"ß>éL'>Ã_H>äc·>ëç?.5ˆ?G¦Æ?8.É?&_r?8…D>ð"'=Åy¢>þê?2+¬?&l>üx¨><8?#[?bî¡?`»i?M¸>Ïü>Ô;>´øñ?M ½?u8Ü?ek4?el¾?\p–?ów>Ù>óö›?¶l>÷p>û ? vº>·¤‡>µDÚ>êoY?Zˆ?fp?"­ê?n>Ï­0>Šžw>Ș ?-?`ä,?eðŽ>ác%<4&>Æ©Ú?Z~ ?^èŽ?1»Œ?>µT>ê£Ä>à 6>䥞>ã,ƒ?Ó8>î„T?"„?Då +?"d(>} L=öc¹>55„>çøb?Z,>ƒ(ü>à|b?–Æ>sÄ>Ã%‚>ß«´>F>œÐ?t>>ý@u>‘6b>¸~>–¯²>Ç,>À:Æ?"7@?2=¡?!¿??Aª?r?´?)#-?6ñî?< ]>±Àß>ŠWâ?(‚?¡âN?Ã?)Ò=µÝB>5 G?‚;? +·è>1TÕ>É'¸>´ÙÀ>š´h>ë×=>IÄï>*û>ýŒš?JØ?4B>ú7>»Š?WDö?%¥Ê>Þ?Cµ“>öÌ–>‘ ?!E?+9)>ýe`> >ÀÔ„?Còh?/Þd?¼?&…">¶¹jÛ>F2? e~>ÒX¤>º?*Tr>¹%¢? 6)?ñ>¥ ã?Kœ?$ ‚>–Yˆ? g)?H+?96>ýr?r¶? àÃ?,¶?_p?/ >×BR>Çvü?B>ôW&?'´è? t>„ß¡?$t£?8*=Øý>´ý¶>ÿj%?Tþ?/->ˆ¯¢>©Ýž?SÇ?;ºø>©Ð>ÏR¸>¢->)0Ý>¯µ¾?X±?8ã)>Ïš¸>ëz>ܱ¼?.Zi>ì¿è?š€?LX®?¤ø?%¾?Ý0>sé.>N3Ó>®³">º¬A? ôÎ?»‚>—?î>²ZZ?Ò¬?R:v>¿„Ê>°ª(?PÐ? k>%Ì®>ƒ>ÅVR?ùÎ?8¦?8Sä>ËÞÈ>ŽU÷?/œ?ALd>¯Æ>‰ç&>iõ€>ÛØ>ä˜B>´,?h`>uØä>ßs|>øŸz>ƒò-?!cø?lSt?'›?(‚Ó?]VÁ?fz?§º?ñÐ?Ìh?(2o?Ë8:2->'ëÔ>ôÜî?Þ?=í\?ï'>ZÜÐ>y2á?æò?µ’?çÜ?ðÍ>ï¤:>шF=®pC>XÖ>® ^?ÎH?uî?MñØ?¦>¤S9>¹Û(>Ù¤>ÛÍ”? Î>Í®Ê>‹hr>×\n>Å”>¶äþ?Kä«?9R? +#P?àŒ?€V?T±?1Q?+Æ? +$>ç ì?OØ?,Ln?'‡¦?¿ø?"6?"ø>›Æ”>W &>åû6?$µa?úà>²Ø@>»Yð?CÈ´?MœF>Å[ =’€>ôÎã?-næ?<å4>ù‡;>ŠåØ>ü£{?(8N?å>òšÆ?ñP?4:á?/ÚW?,s”?[b>˜å6>*l>®i? +{T>‚`j>š8>—6=õnÖ>úÙ™?5pr>ßÜö?QË?Žp=Ø'>ø±5?Í? ç?n +s?këþ?"à>V¿$>bÜ‹?uÌ>ßÕÄ>¹ÍL>ÀÈú>*4Ü>Ž„>¥Ã…?+þr? ?Ã? -ó?^"?œö>É«¬?O¶2? ®=áʘ?`+?yQ?MÏ.?—¡?0¸Í?z(>^½ò?(?Ö>>|n°?"®¨?Ö­>*è#>ÍÈ>Õòþ>‡>A(¾?lm?L>÷|?>ìŸ{>áYœ>à„>Ç8>>a? Ag? +Z?4È>ö°Œ>’“;>‰ÆM€Ù>Áv¥=þ0’>ÅZî?`<\?sé?I¡(?xÆ?->¨¤*=»¸f>æJ¸?B­>Ñ–Ê>öÊ„?Y”’?6!t?/ƒÊ?6™%>Ñwþ>…MZ>ø@>ñ? dI>àK>æ>íÑ^?1ýW>ãH@<¢^=ÖU‘>ÛbX?ZL?Æ +>ì×Ò>¹?)§N>¼Ð>;ð>9tø? +œ>ð7>Ù˜æ>õ{L>&|s>'‡u>•@ê?¡U>ïý«>Âßü>ÂÐ>ø >–Â3>ÂÆò>ØÞ>r»N>´g°?&Ô?<›>?w¢?6'ß>ëL>ñé¾>ÝÀ>:‚‹à>p%A>rŒÌ?8ª?/Ià>ô >¶>›m‘>‰Ô:>¬á“>Ä‘w> +u=ú&>˜É¥>²÷v>Á{?‡@? 5_?G À>ôº>»#Ü?E©:>à¢Ú=½‹\=zˆl>æ¹Î?^Ë:>ÙœT>Mþ¢>ˆ$Û>z>¬ ¼>D(ð>Pqn?3ˆ?B>weV?pÙ?pé?.åô>‘¦Ì>Ñòg>ÐA?€?%†A?R?5§q>Ï`5>üÒt?‡~>f1Æ>‰½Z>ІÆ>DI<Œ2æ? )Í?$j>¹>¬u¬>³±F>‰9Ü>Vb>¨Þê?!åà?y}?­Ê>fX?™€?:eˆ?š>‚ ->PŽ÷>¼yœ>²—>ô> >’T;<²9d>êÄn?XTé?bŠ?B‚Æ>ü5?»î>Ùôz=ì2Ò>œv\?ÿ¦?žþ?[ +? ˆ> Ü›>Ä{º? í?2H?Â>ÿó(>³ij>žd˜> Q>ÜÎY??>ãZú>Í)ÚîÄ>eØ¢?ô?mÁ\?<ã\>Êè‚? úk? +Ðð? »?UŠü?]?š?¤>ÐS>ª¬@=NóT>âd?;‚L? îK?.5>Ý·˜<¬$ë>U`>ž+Ç?& ?#ˆ>ˆKb>Š +ª>“Ì‘>¿NÄ?!qÆ?B»H?õš?f9>úë®>ر†?id? ø2? €2?h×@?<É-?G â?Ò>ÈßF?$ ?€?EjU?-p4? –?23?Lë*?Hõœ?E¡>?(rc>…¶?iB?wÓš?¿-»³@¢lA"ƒfA†A 'Añ:A ìA Añ8A &šAˆ}A"r¤@¦þé>˜u²?/-æ?fÇ?JPê?8Æ“>þžn>èd>ðç?Dl?ƒÔ>‚£d?þ?%Š?*ƒ×?P>Ó?kä¤?Z)l?W_6?Ha?,±ì?ûp>`{°>´è>›…ü>ô:h?LNt?L¸*?f¯ ?&Â>Ñx˜>Ô†ü>áUŠ?@»ò?4˜§>Ñ>Â>¿€ ?ëd?xö?PõÑ?’>ß¼L>â2&>*ø>ØÉ0?@’?-îY>·uÀ<<¯>–c€>äª?)”?G,>ÀÙ >^bØ>Èýô>•m¸=®@>Ý'Þ>ý º>ðkl>¦ö>¬ÝÜ>Ævœ>ª¡?+°—?Jf>çë¶?%‘¢?Lß? ««>¹^>Óš>rÉ€>Ò!\?5ì–>ø˜º>äM&?1èÓ>­ò =åÙp> x >†š>úÔ@?!·t>üÖ >‹´„?”?&è>æi¦>Ï=Â>AlH>žH>|Lx?G3?QŠ¥?\ãö?9‚>Ô.>»g?ãÖ>Ÿ¿>`À¸?t¶?Á5>Gò\>ƒ@>í„@?!>¢œÆ>| (?k¢? ú? ?\'?‚º;õ)>ñç ?>æ +?5l™?,.ª>ʸ|>ý#Ä>ðBl?"Ð?-¿È>žG>iQ=Ó)>wÍ>  è?7˜?&×ô>“t>>”Àd?B"?O|A?_ +ê?QS +?‡=>œa4?^L? d#>Ú„>ì4`?³š?žæ>Ø@î>×ïP?(My?!”?  ?žL?ã>?kx>´\Ô?(g?†ü=½¨€>Ö/(>êÒ0>ñ>Y‘à>—Š?M=?j2Ú?äÒ>à“Ž>Ë3Ð?ó°?W–,>ã]b> €X>b¤L?(½d?O´.>ØX?´Ü?¾œ>Ku >û€?P ¼?pƒŠ>ýÞ2>àN?Xàõ?K—¥?gŠî>ö^p>= +p>¹œâ>ÿÒ?!’ì?F/o?1O(>î&?/n†?5ö>D¼ ?àÄ>áBÞ>T>Ø?G>Ò ä>ÿ¹¸>÷|h>)O ?±'? +uä>Š2€?“d?o?6ƒ6?¨j=¦À>ãà”>éîT=¸áÀ=’ =çJà>Gmˆ?Lþ?7C¸?Ò¯>ónÆ>¸­?U?S-ö?WÍh?Gºé?:Æ>ܽ>æó€?ëÙ?J£á>ûU = Î >%Ôè?Cb? +T?åŠ?á×? ò>?â”>êx?1Žt?2Lj?hÁþ?-ƒ>ðG?Ìé?:h€? zö>µûŠ>”Él>†Ÿ?-Î>«2†>_°|?±?VI?_Á?/é>ôÀ>Ï­~?î2?ÍÌ? +>>¡ >í|€?¶º?kî?bô?4Ü?M(>! È>®ï„? +M>¿¨? }B?J€*?Tª>’{Â>ž”?fx>ÚÆð>ý,?Evº?#~?Gšõ>ï·\=æ¹Ð? *?Dñï?@°ˆ?-T>Á¹p?¨œ>øwx?ª÷?%¬>a›|>Æ0?#ÿß?!º:>¼P>»vX>Ê~´=!€? +]?UÙª?1ƒi?}w> Yü>ÚŒÄ?Tgj?_Ob? Âh>2 +°>‚0Ø>ý$>Í<ø>T>òh>½ô\>  (?D¸ò? –<>=Ê\>—*?""F?C6m?.n•?RÓ?%{ò>øÏÜ>à˜f?Ê?PÒ?.Á?Qåœ?B4=’^P> ç„=ëÝ`=‘ >1ô>=š=Ø@>wkl>Â,l?€?wØå?í">äe|?8«>¿Ûˆ>Ôî>ýã˜>†sZ>˜ü?3Ù?® >ïkü?^ˆ>»Ü>Iû¨=ÿ3ˆ>’¬ò?ùÐ?Ò7>äY?“ò>ä`@>©ã`?®?q¸>î¡>ÿ?”>ä>–Ê>ofè>ÄRH? š?<ž?€I?J"?·á>ù >ؼ>u¬è>êìÜ>Ž Ä? u?tÐÎ?IÕõ?$º,?Z/˜>ü‚<>ãÛž?.ãŠ>JH>L>½RN>á:0>Š¸ >6x>¶:>— +>ßk¨?,¯I?¼(?"ûÓ?HHT>àÄ>Öóô?'ù>˜;f> L>Щ"?™L?;Yj?P>¼>¼Â>ë%8>é†>ž2ø?E­¬?pà>¦~?1 »? +8?ª²?óŒ?r?¾¥?cD?TçØ>æY~>Ößì>„ø(>õJº? +*>ÄaŒ?Av‘?’z>À>Ù—?)3)?%Sv>»§À>‚2L>‘1n?%Q¨?'¾ò?i|?iaÃ?©9?;"?|”p?`¼?A¦œ>þ.T>‘cl?ÑŠ?T?fç4?céê?HÐ|>üÏ*>ÅGp?8Ô†?têO?²?ÜÐuþ>‡fx?º?1Z`?'@b?¨k?:ߺ?/ >mOt>3òä>˜3R?2H>Þ¹`?*9Ã?Bë?˜æ?û>Û.†>䊤>V{l=´}=ú>xO\>=š¼>áP¸>Ýš>ö>ä}Ú?"aû?s£à>úu<>Êõ,?*ó£n>X¯„>*H>×%€?1—€? ì&>ÒÞè?ñ’?áõ>¶Ä?/s[>¯\ö>Ùœ>°äà>·%H?4P¸?-Ç?*?p?\aâ?Vnî? Ã>Ñ´r?.¸Ï?Y‚>áš>¸)æ>ü›@>Ù>$Ð>Èâž?Íb?ð ?D|Ú?Sæ?T¤|?!Ì‹?.†?^[}?…‘>$4=ƒÈ =ýf8>«Œ?+,?0G>‰à?|h>édÔ=˜V0?^²?@>->²|>N Ð>£Æ>ëÄ>»/ >b¨?ã?3f>•d=æÎÐ>,¼? Éê>÷ÔÂ>݆R>ì#z>*~ô>ƒux>§÷t>·%J?ÏN?:F ?-«?%Ê’>ÞÄÔ>—ê?'´?0â+?íÏ?Eþd? üí>h±ð>íK”?+©?±D?Qu0?h)?šÐ>Á§†?-T?5Ær>´7Ì>q~>”¯p? +"x?b>Ž6@>Éçx?2\Ä?YW°>Çξ>F>úÚ?¼ ?0•d?u}&? t? ž?ƒ>Uˆ?ÔÎ>ë +¾=µÓÐ=§¾@?‹?i\!? ²?[•?ñ>ä´?ð?àˆ>÷ÔÎ= Fð>ˆPÒ?- ?¯Â>”¡¾>Î>õÂL>MQ„>B™Ü?!è>Ä8?pæ?7G\?¹ ?m?dÐD?/l¬? 'T>p>ø(>?:Ýð?"Ö??,·g>B=¾]`> >«âÌ>ûeT?5.²?"¼&>›7´>xè>Äf<>¹Áì>ã>˜$>nÀ?¿3?i´?8-Õ>­é?ðÏ>ÝÆR>\jd?¼L>ÝQ>=º >Çû8>ç{\>é~?#?¤v?;ûª?´F>ÊlV?{?'€œ?1? °>Ú˜>/ ? rD?L•8>öY$?ï´?#×Ø?!ÀÐ?Jú>ÙL‚>¯ >Ò‹@?\×s?k±J?€H?Ù>Š¿æ>5ãè>“°2?B“|?`ö¾?`¾¦?|>1°?º>?Nà¦?/>Ž^*=“ð>õ8²?Bv¼?Lã?EÆ>¯ >Ûg>¤]ˆ>N=IÌà>Ýì>>ä)l>æF$>ÑU†>Æ£?Èá>³w¨>Eð€>\¸>ð +>é.>Vi?)ÓÌ?Š.>ÂÒ2>ü7à>s©Ø?~Ë?xhº?÷C? ¦‘?÷±?Ú®? —€>^‡°? +Žà?Š.?¨ì?s?c +w?ðÒ>v=ˆ>†’Ô?$BÖ?}i?G¾?ͯ>O¨p>)9Ä>c˜?]Ú?+@P??x?Œ“>v©8?7Œ?9ÿa?+ä>È’T?ÜË?7%Ä?ž?/˜j?Kãt?,Já>=©”>Žvž?Pà?˶>š—d=SH =[å€>ƒ.˜>ÿñô?ƒ>ï ?K?CÚ¦>¢Âp?–N?q 6?@ˆ>>ÁK >ëq>Ñùv>¦>©½.>#Âø>ùîÚ>±1P>Æ¡$?>ß>Ãú>p> F>´­Ï>èˆ,>òæ²=ó½€>Êö¼?CRU?h ˆ>õ$l?ÀT?h¡©>æ9:>ˆT>ùÎ? Š±?,´?5—†?;E°>Éw¸>é#p?ûn>¢œ>«z>»Ît>‚êè?ùÚ?}Ô>ØñN?Ò/?7Û?"oK?,û]?9aÐ>·&T? X¸?²L>¹y`>f à>¤8>ó(\>öØP>…n@>õí”?(‹O?C”V?eŠÍ?“Z>=¨l>HûÈ=íßà=¢©>Ü>,5È>“`:?Ç>ùôÊ>>Âh>üph?Å#=§> >6ÂH>_»>Z!$?¿???!(?B£>«¨:?=(Ú?•é>¬>ä¬\>©ª>Ñ<\?8õý?C¢Æ?TÕà?8{>X™h>µYÜ? 8 >ÏÛŒ>Ÿ]$?1}Ê?$ìé>FH>Æ­P?\o®?`‘.?@à;>ÒÁ:=ñç@>öb?)Kx?!žÜ>ßúˆ?OO?W^å>º­F>N(?3~?•(>+Ï@?ß>?7Ⱦ?'ýl>ù°>Óß|>«îf>®~D?›E? $~>`È>bKX>­oª>oå? +Sí?nÙ?IþH>ðg?%ê²?YžŒ?Fz>›IP>-cÔ>÷™?dä'?DZ?-aÀ>Í„>3Ñè>#0t>™5¶?Ü/>óØ? +ÖÎ>ŸÎ>œÏ*?1‚>ÄÛ¶>Ý„Ø?ã>S@d>i?J.?›?;› >ÿ?‹Ä>÷u>¡Ìˆ>Ά=€¹`>W¨¤?2Ѭ?y»¾?@ ï>É{>ÌðX?ò?‘w>·´^>áýÌ?{¾>xÒð>ÈÓ|>ùú?ò?¾o?3e–?$»Ó>hT€>,i =ö >м>ÿX?Aº¯? È? +oŠ>ÎÞD?[ù?*#Ð?­´? +:X>Á¢º>Ÿ”? w?C>Ûÿ¨>.´È>Ææø>ï>ÀeÊ>Uµ>‡h>ß¾?Nu‹?0§‡?û­?X|?c]!>æ…@>Öp>ïŽ=ãk>É¥À?E*?BÛ†? ë ? )?ö0P>ëoŒ>‚S<>¡®\?Ckù?×q>«øj>Ìž >ãø?#’?rRq?$´<ÿ9€>ø>±[n>„s>P,?§Á>Ä&¼>¼±ê?ÌÆ>ш8=±î°;BÊ>ljH>ù»L>ƒT?˜?Ø? —?tÎÂ?Ck? +&·? ™>>‹Å|>²<ä>ÙÓš?7¡ö?] 7?lŸ²?a™?;¼‚>ı? Ó®?%Ä>'1°=™Ÿ@>Ä? +£*?bÞì?qgã?‡>¨]`?þ>ÿß$>›†Ä>ãœL>ÝÄ=ßg>À>러>´Î¸>Ƈ@?8}ò?Pœ?$?(êN?):_? Â>®šÆ>¦Ñ >ÏÆ? ¿J?QËÅ?KŶ?wA£?7¾—>¾òT>{ >— +Z?%?QX…?*:>Å÷d>Š¶ª>ÇNÔ?:Ìn>ýÌ=Wð >Ø*?\ûV?‚)>(? +…ì>ùWh>· Z?.1>è)Î>×RØ?4NG>‎=‘…ð>å]˜?/­n? $?$7ª?”á>ó˜ä?&G”?j `>Û´>ÙÃÈ?¹Þ>×kn?>€A?"<Ü>÷~j?5“>ð +>¢uª?(â?4'é?k)"?ZÝo?Dž~?)¾?8ÑÍ?í0>²ê„Ò>âTà?T?[ -?P>î`?$ºî?/Ķ? .>o…8?$ZÀ?)à{?.ü?m%>áH? I?iñÍ?/]d>ÆV`>}%ˆ>¬>„J¤>…yp>ÎœH?J¢.?2?z«?D€?*à >¸ü?¤»?¹_>ð@¡²?º??JÓ?JŸŽ?D ß?³>˜“ˆ>,üÐ= >¢ß¤ð®>äF?&?g]?š4>{Ò˜?â? è?)q÷?D– ?GEA?uHx?>D?Ýd?¯1>¸ÇÈ?we?8&Ì?@L?T>B?%Xü>wá°?äý?G¡e?6Ó¶?$°x?%Aë?D¢æ>¤ÇÊ>ÚÈ?J÷¨?‚Z?F? ˜?8¨?] ? +ñ@??ÿÚ>ö6t>울>|CÔ>é ?ÌÔ>ä‚? K¦>qrÜ>=øH>裸>4>‹1Þ?¬‡?9Éö?a&Ç?mAÈ?l׬? +o€>Õ$?&TÚ>í¹>½1ê>¬Æl=ð¯=ž¯`>–yà>û\^>ÊÎä?'†?6íF?4™ù?Ñ:?ü>ðÞh?Þò>ÙØv>Àø?”%>‡r>Dœ >/d>gÍ>ïø?GÎ>â°(?(,º?]º(?[ Û?u­b?:Cð?;*R?[¿Ä?X|?`‚9>ê`?„¨}´?*“?rT>úP>7‚“>Š½>î‹p?`¤>—»Ø?·Ç?ì‚>‚t>ú3Z>ø5è?43Š?4ãP?¯v>wø>y@>¸Qø> ü>@P?X?1…ž>•nð>•mª>Ú °>¥(?/š ?…T>í«Ú?PÆŒ?`"p?[Ò??™?§'?g¾?jV©?:°Ó?4Ì>ÁÀ>®‘Ê?F÷¸?G=k„à>Ÿ¾(?`¶>£ed>»X?ñ?_üô?T½o?<^Á?µc>ß„4?@ +?VǾ?(Ê>>·H>ÞÈ?šÈ?K²>´×î>¾³ô?’?2åº?0ù!?;76? ?06?Á>ýDè>ßv$>¢Ô>®$>Í&º?(‹N?èJ?g>™áp=»žÀ=ß*°>6I<>âëv>éŒÚ>\TÐ>ô+n?f:,?^R>ñP? }>ùñ”=ŸQ€?8N?€F?–9>ï—x>ö¨Ä?£>Üœ`?"|›?"È>ĺ¬?Ø?âÄ>çe?E'¯>½F>óÈZ?ý>sƒ¨>ëYˆ?¬–>ó3D?p>Є®>Ðdü?/î?ö>ô&´?#$ð>:ë?ëI?AúÛ>”Ùê=áð=¡S@>á¨t>û‰Ü>õ'Ô?-ë>Å+`>›D>î€p?5úk?4kì>Û" ?/OÒ?•ô>k +ì?\Ú>ßüB>í,š?l–Z?5ãÚ?*µ^?ï>H%¤>ü(p?io?Dû<>¨Ž=¤²0>)8?²?²¸>ƒ¶ì?(W?3¹>È$Ì=Éç`=ÏfÐ>tg`?&‘-?CV?Mº5?Dù >Ú\>(3ø>ÂD>w÷8>÷]Ü>êŠü>ìx~?HÉ-?‚—?2?+p¦>Ûf˜=Ù+>üœ>pƈ=ïmP=6`>ü ?0Bô?Æ}?åq?G|?.Ãà?‘‰?/-H?7Ê’?5À¹?&?Ò>¢»¬?,è>ÿNÆ>yh>ð¥ˆ>ö¢>ÅÆ> x>Œ:à?< ?gÒü?NÆY?R4z?8¡>õRP>Àü>ï\>ñˤ?ƒ‘?JÏ>Yx>¶~l>†ÎP>ÿ‘¾?ou>âQ >‹9|?!¶?/ú>ô÷L>«ñ®?*Þ¬?óm=]Þ@>© ? +'Ç?“"?, ?%ø=?Y?5?Þ>É@=ä˜>_Ñ >ëh¢>Ä>À‡$?$_†?ݾ? ?L%·>ùý0>˜X(?U»Ÿ?8>¸¤t?zÜ>½L>£Yl?­Z>¨cÔ=†¬Ð>Bòä?)³?ÀÔ?9ÿ?Aˆ?º >Z@? +i—>ðá¦>´8>h1 =Çð>)ñ¨>ZÄô?û?4$€4>n9ð>Îlè>ï ?4׫?r?le˜>ó²˜>Úè>:>ýÍô?WŽ(?cÀ?,LÂ?ö>5ð=b€>ú7L?ZÀÎ>ÆúV=à `>aP>§ÐT>ÚŒÌ?ïâ?M5Â?HPF>¨KÔ>r¡¨>~^È=ˆ×à=êßp>JS>„N†>Þ:Ô>ï±>&EH>Oï?¥Ž>ø¥(>8I`>«>È>Úà?ƒ?xKV?;@Ú>¢ª,=í°=þsð>L>\¥ ? ¢±? +¢®?&­'?$­î>pl>š¬>¢N>/¸p?h?q³2?i²8>Û ˆ>Ÿ>+âx=ÇÂ@=U>ÐÑÀ>Ùp >€>æ$>˜i0>ç”>¬ù®>ÆŸº>íþ ?\?-jŒ>œR(>¨˜¼>ªâH>žæ?(o´?F5'?aàÛð?(`>5+È=òô?ϼ>ÝáP>÷žÊ?ev/>ê=Ô? ”? îÎ?4Â?ÑÄ>Ÿ$>¦Ì¤>Õ +¶>é£ä>™ä$>ÙQº>ÔQT>”_<=ýÒø>D»ü>NBX>Ëü@?T¬X?\¬ô>ܨ˜>uIX?ù?0Ka?q«? +C?CÖÙ?GG;?ei>Lh>u`?ƒð?^þa?Þ¤?P®?Ĩ?^k?Id¢>ÇO¼>´TŒ?/4>î‰P>—(ä?Q?6H>¢þ?™›?=F>¸º>¾KÀ?+V?a/”?jC:?IÝ€>þ¼ä>Û ?IK?hQT?Æ >\>ÌyŽ?L?VŸç>ÿ÷Ü>eÐ>ôçØ?/¢$?²>Ó ´>ëÛ? ´õ>õ\>ÔxÔ>¢zâ>œæ”>š†*>)€^P>Àa ?2”?Sf>^(>ïž?vI°?Â?±¦?mæ?U.>ÐDÊ>àIR?5©Ð?-c?“ƒ?mð>ÓØ?óF>â’>Õ–>Âéø>nQX>ÎÝ>aŒ>¢Ö?6rå?5ñô>·É^>­ü†>¸p>ׇ ?øÎ? |ü?IPD?<µø? ¹l?#†Ÿ>÷Ó?’? ¥?´Ï?sËR?CB£>¯·Š=Ù‚à>µA$>°õ€? ?S?–}>i…¸>ö¤ ?)7?#¡H>Æ€<>FIH?¡ü?wa?'eÁ?½j?J…V?·9?7 §?u=œ?j/h? +ê=³>n(?Òð>Â} >º­Þ?D|Ë?"ð­>œ¿J?‡,?j¾Ž?$¹>£2|?->?>œZ?8­>›>˜Ð>¨ (???É>‘[:>~zÈ>+«¸>QÑÈ?x?™Ú>ð®°?2Ž?»o>6Ò>¢†®>à‰J?>Lj?`Æø?X˺>ê>ݤ?C‚>Ä"Œ?@;3?%Í÷?$^z?++2>î0†?+¯È?:JÒ?Zp?_¾Ô>×<€?!‰?O–„?!´Z?ý^?05??FÝ?:mb>·ª`>Ö¢?`Òü?RäÖ>¿/d? Ø?NaÀ?b?;\Æ?*!í>ýë¤?ßÇ?= ?¥p>¹Áp?CÅ?:eˆ?(Æû?l ü?l°Px ?»õ?˜k>‹;¸>nu$>ÕX?2ˆÀ?m®x?j4?9q>ú¢>Ë>g¹Ð?ì >ú~?½T>ÙèÔ>îpÀ?-Q´>ÊA”>¤t?>1? Úƒ>Š<?’?~Â>aTÄ=úwø>¬Ën>¹á>Ú‰^>¹×$>Ø¡”?-r?FU?SdÁ?D´~>ó>¿„? â?49g>†‡¬>ÆU²?DˆÆ?Y$>p«ä>Ü^À?éÏ?‘þ?}Ö=ÄU0>ÿn„?^¿?;Z?G³^?=< ? sœ>êø¨>Œ"? –?Qrk?N²?“©?3Š&?± >Å6”>ã²Ö>©öÀ>úõ¢?kܨ?>¸ >ʈ¤>!Áè>Ý"‚>ájÀ=Ò >ÙÎd?˜·>óE>Ÿät>Å ?LÌ?Ä>zˆ> €>½>õB”>¶€Î>Û=8?5 ? üÃ?1??Qb>ï•Ž>4(>üö?_ü>ÄOR>é È>çì? jj?K >þ=¬? Å?=ª?+l>jè>÷N6?qý?MŠ ?“F?Œê>ã2h>YŠ˜>¼?«f?]?$¾~>Ïdì=‚›P>ëܲ?SÀï?¡’?+&n?jŠÈ?n8>Þ™ ? q6>å_~>£œØ?¬ ?CF>ðÒà>Λø?uÜ?$>äs>Œ%4>©?7íí?¡*?Ñ>î'¼=—TP>1Õ€>G|>í V?^&å?«>Î6Ä? +n?&‘Ó>ËåÐ>›­|>çâª>†up>å‡r>Ÿ_À>ÁÕˆ?DÇ_?!²1>Ö¦Ð>ɶÖ>Ôæ²>ùÖ>ß*¦?&¨?X΂?H§h?5Qp>¤ ê>âKô>íw=¹@>ˆÕd?ë>ïIº?!Œó?^.$?@Ùý>³ÃÀ=J ? +æn?xò?Oj7?"ÌG?©>ÉŠž>î‹,?2f0?@{•?2s¹>ø)$? ÕÞ?:žª?Ü´?Cå(?cÅ"?Mh_>Ë;”=É-ð=î† >žÔ>Šëœ>úÑx?"bœ>®t0?«B?']q?Ûš?<ˆ>Û8>)¼=éfp?ž?BÀŸ?+Z>׈–>„…,?˜ö?B§²?:>>’Çô=¶wÐ>ð±z?? q?P9w?,ó#? `c>³6P>u²P?1„ö?A§q?CIH?pÐ?—.?8öð>±Ìf=îå°>Lg0?'ˆÊ?[ʪ?ZÐ??6¡Ä?®ô\>׃(>®©œ?Ðþ>æì=˜£>?#€?,ì*?K[>yô,>Ì°´?*Ë,?k>ïBl?`݉?wæd?@2>§.|>ØCØ>¤T°>/ä>ÝÚ@?.Þ>Ý?uv?;{¸?6Ç??ªÁ?Ãø?Þ¸?‹å?è¢?Kè’?&uD?'ŠÙ?L ä?O³Y? „Ñ?ÂX?}¦>†¶?d¼>µ™>»»@?yž>|Q´>²™¬?0:ª>ér=ØÃ@?*ŽJà>†ê=»3à>b>žP¸>îìÊ>Éa$?ÊD?/??–y>×…Ö>Ô‘L?Dÿf?Uš?2Ï>ƉH>„ÆT>+Ü„>5`˜> …>À6Æ?".“?£‘? l?.£>?>ªN?7ÿ?À?QÚ?Qp0?*ß–>¦Q8=ô€>:x>˜ >NÄ?rÉ?H? ­? Õ_?ph>¶Ïø>£m~>Ímô?Eïü?&È•>¡_Ð>Â8l?µë>¸»>Žœ>U%ˆ>‹¥^?!“J?) +>›?Ø’>ÔjÞ>w€>À>ð>GÈ?eN?kG$?^O?5ÕÀ?&wú?4˜í?!h +>ÝÒ4?˜¨?JÂÖ?…?@a‡?@ê? o°?´.>h2>¯¢Ø?2¶]>ÿ¨ì>± þ>‹ðæ>¶ed>ßT?$a“?€.$?‡^<ßnÀ>Øà4?âô>6¢>¡¸?7{8?Ò>þï¤?wŽ>¥©?p³?-ûì?Xž>][Ì= õ`>ÎH=¤¡p> ãÌ=îi@>ùmà?Rî>×SH>¿ËÄ?.Ø?'? Ój?2t?!ÝG>üJ>¾:|>ÚpÔ?$§ >ñŽ>º>>Ï’P>hSü?‘â?8Z?MÄ,?G•À?t>½º¶>¨uœ?§ä?'Ž²?|È>Êš¸>)s>B×T>‹Ej> +Ê4=|5€=b_`?Ÿ?A°=øšè>iNl>À•Ø>þˆ>Qˆp>§:d=ñ]`>ʨ?[§î?&Ù¼>®N?#h?3<=ê‘€?k=?:×0?6v?`Ê?4çä?=Q?×#?M?F”"?M >ŸÉ`>ÞÂø>û¸>Ø.(?-Ka?ܨ>!BŒ>öd¶?*ê¤>îy@?! +ï?Mžá>ÄÆ>¼1^?&Œ?B°V?V’>ËL">æˆÔ?)Rò>íX>¡ƒL>ÀÊ>²s˜<î>¸×´?6 ?"¼>ýÿ¸>âXœ>=‘ô=§…à>=¦Ž0>{Ù¬?8g?qº©? ç”?(³?2œh>öȆ?FQ¬?Oâ?!1`?(f²>É«X>:wP>Ð_? —>“”¼a>å¡?uÌQ?&N>«]? œ‚?v|?(Qê?ENä>åÛ|>“nš>â™@?:N?'|>ÔX>þ*H?Rxî?!V£>·û +>nA>™(>”š>‚-`>Ú®$?Mÿ’?aÙv?/¾z>•T?û-?Cš¶?N ?q6> E>Î[j>ÌrH?”?ZB¹>Ùû®>ˆê¬>U)à>–NB?"ôx>¬h°>ÄZ’>ÄýŽ>€>A÷€>Ü4¶?/5‚?Ä>š$b>Æx>Áúuj?(«#>ût’?B¦‰?íˆ>*K?qì>óä ?–í?$Þ[>Á_þ>í¾?T?G¸@?EÚ!?3¯>Idp<ë˜À>áaÐ?Ypè?ÌÃ?(Hà?¤š>í8?Z$è?2]F?‡ª?)ÆX>Ûå,>NÌ>ŸÃÀ?fx?a +?7¢š>o‹ ?Æs?.åÿ>ÐBº>¢Âø>?X˜? š›>í²D>¯iP??ðä>÷ãà>è r?O™v>ñ{Ä=½Ì°>¡E ≯|>}0>ꃤ>šç²? gò?MÁ?2=?.2T?IþO?Wuð? +è> @>õ-d?¤=Þ Ð>Óî(?K?ÙØ?‚/è?Oc€>Ñ™œ>'¹ >” >Z? IW?.Hu>íz>©mÚ>Ì6?8h8?9 R?².>µ8’>øœ>ù =.7`>¼îv>Ï/2=¿Ù€=PA >´\>¸¼>&k0>ß/X?Š·?$) ? +o@>{HH=åö=Î~P>ðÁP?Oî>Ð +”>ÿ“@>ùë¼>Í?q>Hð> >þ«Â?|ø?!? ?BÜ®?‰Þ>¨Ò„=Ø7P>oð>ˆXö>Ò ü>ß—ð>ñÖJ>ø>„Š¬?S¤?'¹,>£¬Ü>. ¸>¼d>v¬=}wÀ? + Î?k?€}?¶?²@?S¶x? Ó?é¾?T¬¾>ÛAÈ>Ñ6?Ý–>Ú<>Œ#?:n?Tôî?Eoö>Ò¿?êš?W ‘?.&>Ófþ>õ‘>?9e>­ +p> -ä?zÀ>ÖÒÀ<ê>Ífî? Ôl>Ĉ>–aì?F‰>ý´>:³Ø? à\?W‚?yì>e€>ïÎ>Çßà>¸‰¾?"}>ÀÜô?u?8e ?<0? ð?JÅS>þÙ¢?ö?²>…VÐ=pÌ>í˜h?D™Š>ïæ?oz?G§‚?XZ?XÊ?%·n? ª?Sm?DWÉ?>ßã? ^>Ìð?7`? í>Ø6P?4¶?ös?B†J?pY>Ý#š>äq?è>ö±–>„>3@à>óúÄ?«¶>s)à>(Ð0>‡õ(>¢>RÐ>ËE.?TÕ ? ýs>º^ð?K¢? »f>ƒU>Ô_¨>º¿>£ÄP>× +”?+|?_{`?# ¼>î&>l?>Ë^ +?32W?$Q›?HËÜ?^¯µ?ïe? ?LrV?#Èn>èl >ñ­L??ä¡?q¹?`Ä{?>ý·?)Õ&>ýJx>ÈM +>éî€?‡þ?OöJ?"'k>’ò>­ù$?+˜À?W'¦?·=? Ö+>—ˆx>ë|L?5¹>± Š? êÅ>Â,>ìwà>ä—:>–÷´>ð¢¨?N×ê?MÖ?N?—?a¢R?^>Þ>ìßÔ?æ8?ñJ>†¸ð>Žp>©|Ü?0 Ê>å¶,>Îd>*Ƽ?ƒª?¡8>¤ƒ >š+>§Œ>vK„>ºÒ„?"H>ýÙˆ>ÿ|?Ds?"¡ú>¸;ˆ>bFh?þ#?aî|>òIÀ>u~`?Þ½?_„?É>“ô>>ÞH`>¹Äd>u˜?ì\>æÝÚ>†Ëô?¶¤?Kò?\,C?. +¯?F†ê? úÐ?"þš? ’)>»à>€œX>–óB>î½â?FÑ?D}ü?P¡?sT>¢Kü?Þ>¼d?ÝÈ?ñ>¾`?dœ? ¬>ýÉŽ?l>ô&l>=@Ü>•^’>Ë?qL?Aç>éô?o”=áSÐ>ó¸?`·&?š>}IŒ?þ&?NÌ1>˜gü>‰Áü>¯3L>Ϊú?FІ?%?)<Â?Š=øüÀ>dµH>Gƨ>RöÄ>Ùá:>€~X>킼?T>’Þ>ùâ>Ô®`>…@>ñ>ù—¶>Ê%h?Q~Á?1<|?1S?9">Üý¸>òú>“q =é” ?Ÿç?aí¢?gv#?p”V?t:?=›È>²A´>·ì>ž=n® =Û+°=Ï%ð>Ã!?I¢¼?ºÔ>®«?;*?]V7>í(>Ä*ˆ?"_å>Ó¯>@p¼> ò?5b?1d?G?ÿk?,ê +?=äÔ?. 6?`tp?FyM?9î>ë¨|><óˆ>÷¶‚>Õd8>¥³V>À¡ >ãyN>îz(>ÐÒ?EÔ?sÒÞ?FT>ãóJ>Œ]P>˜¬|?ž¦?` +ê?gˆ’?sš?3’&>ß¿¼>©J$>Á·è?J@Ü?\ª”?Dè|?^%´?,VÜ>°Ð >›¹ì>Ëš>ÓÎ$>€EÔ>Ÿ&„?E"ã?( ´>êzT?#9Ø>´ D=0\À>ãZì>ü\(>äÐ?I’’? +ý?xÕ?XPò?/ª>ÁFè?7Ûm?3 É>¥È¤>!À>%yÀ=~÷>ÕÚà>óNš>Ã:¶>öy">H-Ô>%È°>ùÞx?Km?"ª>é¼>†Át>jh>òŠ?-Ü^?EH?$þ?? 6?™d>ÂǨ?Ò'?(Å.?Q Ò?Õ~>‰0.?6KÍ?_¼/>»Ó$=úúÀ>Ç/´?8¾?q + ?lXÖ?G¥*?â.?ºÆ?^›?h¦¨?'i¸?2C?d¤?ACÊ?û~?>¨?Ugf>â«>6‡ >ª;´>ÀÀt>ÒýH>ÈwZ?àê>ìy¬?W-?0j>»?"?Hl>üE‚>kÇ>àÐÎ?DÇ>î!n?ÄÐ?-¥î?þˆ?&/4>–‹„>­=È>òæ&?Ca?\ü¾?c¬]?^ü?ë +?úâ?4^”>ˆÈ>M]p>¢PZ?PÞ? ›¤?'š ?:Wt>p®0>§!@>´O¾?Õ>óxÔ>lip?'8Œ? ‰? +Œ?R\?Ô^>¾J¢?q‡?Qº>[>˜>¬²Ø>å7 ?ºJ>Ðzò>\¼?p? +§?Ý×?kÎŽ?S,@?>çT? ¥ >Êæ„>ôýä>Ÿ“Ä=ú p=˜G°>{ˆ0>FÅ >¿sŽ>± >ÜÛÈ?nB?Ô?XF0?:¿Ý?`ZÂ??Ð:>²"T>˜³ø?%×í?¼<>\?>| +è?jž?œ>™“œ>ú¹œ?jØ&?{ßT?ÊØ>ÎÍ2?$Œ??I>æÆx>$º>ùÝä?;Ô@>Ôô¼?\ ??L`>Û½â>ý >x,È?+üS?G?;#´?¤É>Ú?nè>³“ì>×`L?$0>ƒ>¿z?Kò?þ?0€ì?õÞ=éF ?,?[]J?@²ì? [z?+*Ì>ø?X>:zð?&yt?m!°?N˜?V_r?zŽ.?P=3>µ®¶;‡¨>Ù\Ò?e/õ?\*é?2>’–ð?Fª?>´t?²t>Ž8=QŸ >ÂV”>Ô­Ì>‚ûü>FÛ=ãMð>r à>ô'X>µÆŒ»é,>ï¸P?bä”?ZÞ€?põ/?S +>FW>’E$>;=È>ʳ°?H0>sì¤>ã¤>лœ>Ξ,>Á.>ÁØ>îCâ>Ðâ>‘÷D?6?I.è>õmx>Æñ?X°?3C7?4ˆx>ƒ$Ä>,[˜>â >b|?Aâ>¹:È<ìf@>²ñÐ?:0À>ìp°>ænŽ?.?€°>úÖ=ëf=5€>pµ>æÎ>¨¨‚>œ;0>úk”>ª`>«±4?7¢?MâÁ? ^?6Ž?e?$ñ,>µ ê>a÷H>ú·¸?'?4?ö=Ž >») ?8wÊ?^>²s‚>´ìâ2>Ííî>šÊ? + Æ?L`ï?Bà\?"µ>‰Yl=Ò >oaÔ>F¨H>½áˆ?8o"?‘>ö-¾?-ëÜ?Mp?bÙ??*(J?ŽÊ>¿éÈ>„^?£*?"Ø>Òû*>ܼò?9ýÈ? +dk>¦Þx>¦·Ð>µûL>¿ø>Õ›Ò>þÆÈ?x >ÑJ?vO>ô6ò=Õ^ð>ŠâD>à´ ?%i®?m"¯?e¾8?$\¸?3ží?<ÿ>žÆÊ>´h?*[®?„ë>|Å>¥±è>¥uˆ>&kP>¨wÌ>5bÈ>R¥à?÷4>¹–ø>Mž0?18?*2>‡ÏŽ<¢€=îÀ>mSÀ?#Tê?"K>«÷ ?©|?3&Ž?ü?5G°?%|?K?B›?êF?PÌ?W»v?Ú÷>Ic >“$à>'ãø=@>_ü>’¸>ÉÐ">]™Ä>›=Ð?2ß?<Ÿž?&až>ý~>¯à>ªZ0>Åo¨?n½?@HV?WyF?ò>¯x? ÉÆ?ÿÖøx?+\?Qͦ?(n­?)?×?Zö> Ú¼=ÎP=):`>šqH?3?8\?8T¡?=!ï??7\?®>áÜ?*ö?RÂ?¬´??»Æ>‰ß²>2-?{Â?s.D?Kå[?R?vt?~–? ?ñ?;?Ô)>ÃP?&eÑ>áÞ8>þYV?Z‚?lò?QL]?`|ä?5Æd>¯/À>Í °?3ÿß?_´ø?OšP>ºÎ,>×TJ?:p?BÒ?BÓ?ðþ>¸ž¤>ÇÀ>ø<Œ>”tP?Ý? /? +O`? >óÇ?Nj«?bÁ5?yʘ?X׊?2ö1?K'?<&D>ö†Ò>Ú¨©,t>˾>øcð?mÄ? +`Ó>»Ø?“ù?oö?"Ë>òÕ$>bå >öQì?)¡8>¡—$>`°>É h>¬AØ?÷‹?ž>¥£h>º¦Œ?4Ì\?õx?G Ð>§Ö=¦e@>Ó„?0nL?9Ír?6ôò? f>n˜>ßa?L>€˜>漌?1pÈ>¨KF?!š?1I?/kü?4­€>ôêt>·l>Žºt>GX>ÁÜ?XÍb?$Š:? q–?Ÿ-?‡Ÿ?">ÎMº?!ëŠ?5>ÐÔ?Ý—>ü\\>ÁÊx>ìé„>þ"˜=Ö`=ò À=º)<ñG>*!ø>ðø?=0¸?8…þ>™|>xæ@>nd>Çýt>ÿØp>û(?ç">†f<>`¹à>n:(> Ãœ>ü¦Œ??ïT>Þö>´sà>³4´>¾»<>ÀÜ>èÐ>¨>Þ¨>ø¾Ä>@¬?rX?~[>­¢?æ>—5Þ>‡P?2JO?LkI?9V×>Ùsì>èEž>óP?È?i.ð?WÚ?E.C>ܪ„>¶"?=%Þ?dòR?XÉÅ?у>ùáØ?,@.>Ô&0? +¬u?QA ?Pÿ>Øĸ>¬>—jH>œ¹¼>åŒÖ>µX¼>Òtø>þt4>Ô8?6W?%|¡?/¹0? >?¯…?â²>¦YH?%ƒ’? fY>‰r‚>D¦P>· +>è´ð>öÀ?—·L>È.´>¥±>ûîÀ? ù>;Àà>ÖF>í9ž>Ú£?F>9?f£¾?Sè(?·À?0³h?Ä>œý>ÖL>é˜l>Åjð>=R? +‡?X|>1^t>ë?¤? )? +Q?QÜ4?N¢½„b>½MH>†èà>È5œ?!é? ­è?N= ?S>’?2ì?D`>‰±ˆ>…ô>üà?J|?%Ú€>¾bÊ>ˆr?*jæ?{$>øÙÄ=º)p>Ìl? §‰?TT|?x°ü?%¬??nf>>–#Ø> t¸>kª8>Ȧ>bè>W×Ì>ti8?,á" ?&ÑT?_™?-Pô?$H?Sƒ.?EsÀ?(û?7Hì?(F¶?7˜b?Ib?—ª>ìD>ÿ l?~+„? Ä?*?Rù?>H>g=ØK >sÞü>¦‡Ô?!ª? / ? j?Xã/?@ža?r>ìÕ4?K?  >Pel>¦ ð?3ìá? %P>TD>à×ü>²RN>¯·è? ">Ë«„? +O ?^Å?RL>*o>Œ¹Ô?,4È?°Ú>ð4l>öþ4?#{?aì™?K1ô>ׄx>F}@?*òW?f+??"ï´>Õ®¸>€$>÷j`? +ŠØ>ðú?¢î>ì-Ô>:ød>­‰T>Órt>gq˜>¹š°?# >? +ð>³¬?;®?/R>A*4>‘sÀ?‚D>…€>iø°>úÔ>æ@ô?^.·?aIx?#g¨?÷?ß>› N>ëÔ ?Ö´?'ä‘?4¯|?J]???R?;Oæ?…¥>;Þà=³ëp>ÛâF?),h?3â>ÆÛ$=Àô>¦=¸?ß2>ÒYp?˜b?c@þ?i™?|yà?7Ù$>¯÷ö>Ù.?yã?$±K?L}ë?&~Ÿ>j?f?aÁ?:¨? »¢>ξ?T ?Xšú?íæ>üY¾>ªjê>÷HÔ{F? õ?‚¢>žÇ>UR@>¡¡î>„¸>ÇÖ >ë B>‰&>íL>ÄÑ(?Ú>òVÔ>‚Lö>s °?Aþ?)ÿr?*H>?3¼>;nÐ>öé?@o°?<Ïä>ý¡ >Pì>‹] >¼o¤>÷ÞT>¸Tœ>é 0?CÛx?,I¨?5V?BW)?³l>ÿUð>Þ¼D>š¯>ÿÝŠ? >¯iø>´d$?“n>×æœ?v>?Kü>ãÎ?7×~>ÛÜà>²“l?ØY>ƒÞ|>¸€$?J†>ˆYÐ>ÎŒ@>Ç¥‚=b*€>¸>Ö™´?.|?aŽò>î«8;f”>èfä?A]s>Š6H>û•î?Bê?/|?Ní¦?B!>ÙB´>øuh?/ì«>Ÿüø>ãFt>ÖâŒ>x >³ñì?,Ïy?'ýë>èm¨?ë ?>¢”?01N?7²[?â>øãÎ>â…^=èD€>ýsê?YYÞ?We‰?+0?-í?^®Ÿ?V¢þ>Þ%p?½Ï?: +Þ>מ>§Mê?!ˆ?)Q}>ÆvD>´«j? Tr>¹Ðð=äÉ>á)Ø?Sg>ñGD?*W?^À?Dšf?Š?«™?ɼ>ÒÙ?"Ÿ?0ª>7W,>+· >Ÿ’d?•s?FÊò?/ˆ?!åÊ?c ÷?3šu>¬Û¬>­X>Šs>?37˜?69s>ðf=—PP>ìåè?>¹>¿|?ÏÚ?§B>›{>è[J>q‰>‰Ml?‘?:Žü>¾ >ô?mLò?{ed?1ì +? ˆ"?'ÎÆ?ù?(?ó ¾>»a?:.>œCÐ>VH>¢,?+c†?]? ñ¢?[*>õ¿v>ý…?PX»?ft¤?Ô< eÀ>4¶ø?"T?%†r?[`?~…??>ùŸ">ê—À?G±Ä>â¯D>ì"~>ôx>îð4?JF†?jÑÊ?p>_œ|>¶$6? +Ã>ã«ü>–6D?,¨6?eÔ? ž¼? Tž?2Ö?/™š?Õ??“æ>Õ& >ò–? k¯>À~=½‡>ä&Ð? òÚ?#Ùx?5ñ`> îN>±h8?-@Æ?6ýÌ?.b ?wé?=p¬?V¥?:o>ð”>ı,?N‰?J¾$?+ð?$‰Ë?%е?8M,?Œñ>·iº?Êæ>Òo|>å¨?9?ç > >UŒ?Úš?N|q>¿ŒP>›x>KX˜>‚Ýl?(>Ên¤>ñ +?Tœ?hÃ?>ñR?.Ý—?]»?3bõ?~>ì.€> àD?Z¤? +Ø™>é´Ž?_Û@?Må¦>ÉùD>©et?$‘ÎE ?3¬?<Æ?>•R€>Á)?Þí>Ÿ¹&>Ø>°$>´­ê>åS0>…ŸÜ>P>>à>u§°>ÆÊ>‰N>îv? nÜ>¢æx?\@?Zz›?!cÙ?;žT?_½©4>-ªÌ== >W+¤>Ïp4?ØÜ?LI?¹Ã>[ Ø=/@>­K¬>¦®°>uh>çÊ”>Ì +Ö>Œ¼”>T:@>é58?&À?+gx>ÏuÐ>‘4Þ?b`>°æ? ó.?&Ën? + 2?A@›?0¶ƒ>ðÿÔ=é?P>•(>—·¸=¸?cÌ?V/¨?@;¶?$ X>nÕt>ùaH?XÈ?û>—6H=…Là=g  =È~Ð>+è?-(?FQÊ? È >H@=#ù =¿°>ÝÊ$>ÅL&>v p>·_p>öOP>ä @>Ô¥@>èˆ>›)¦>‡n¤>Ý?>ØZø?6F?(a!>ãʤ?G?y?&Ž?$)¢>ûÖ?þ8?0¾?Ë=?%Ç?Î?4^…?âˆ=Ô%@>#¥>­ûœ>ý"~?@Š? +¾>õÞŠ>ÜrÀ>ãGP?W4ý?õ>·Ûè?†?6Ê?Ï~>Š ? Ôü?[˜¶>øA >ÿgª>û+4>½ÅH?8Öp?IŸ‹?8í¼? G¾>àéV>K<<ˆRÀ>ýå°>øLD=¹•°?^¥?FÑÅ?BU¢?_!">Ü>Îq8?5Ž?!3n>…R>ÆL€?ÌÂ>ý%8>Ô=¶Ð>´¸>Ä¡>¯è>÷Ø<>‚N<µ€>¬ˆ?1‰?>™ö??µÏ?>«¬?ái>½ì>쮄?Ü2>àrÐ>…ëÈ?­Ü>î·0>–>‚Ü­çü>Âi?³>Í@P?ŠÒ?Î>ÿê"?,ÚT?d'„?S +õ?!ä?-C>ˆ`>²û4?Íñ? ÿ#?:Ä|?;e>æ•V>Áµv>ð >€û6>†õx>/–Ì>’N?4j>ürt>(sä>Ë’.?3ÆN?,q8>× Ü>]#d>©Fœ>ìÃD?im?ps?bÞ-?Ce[?N¿„?kñ>½'`>›Îø>ÆŠÐ?#˜Õ?-¨?%Æ>ïtÊ>¢?Â>Æ?f?#©b>£:>|õÌ? í?7(>¯rj?+>]?ð«>›Ž&>°è?$¹V?d®Ÿ?(/r>„Yp=¥Ö0? ¡v?Ü?Ü´? jï>šµÆ>Üv€?À¢?)/ >ųØ=¤O`=þè˜?Ýk?4Iµ> x>”õ>>ÍZ=ÄI >2Ñ ?%…?Gò)?+ð>ßÊ>…]X>Y,>á˜B?G`t?kž>ïº\>íd4>— |>)»˜=¬êÐ>á©œ>éŒÞ>Ž°>Ô€?N§ª? §=5% >§>·›@>’ž?˜?FèÞ?v"?Ÿ¸?EÌ?pðò>ùt(>•ü,>ÒÞì>sZÈ>±<>çÉÐ>ßšÄ>Ó̤?Ë~>þè¨>w0P=Û¢@=»à>¨\,>ù½d?.•Î>ýrT>ÖÂÔ?Féü?6ªI>‘D>[O>ÖÁ€>}P=+ >Xjl>ç[t>£h>w8>DÙh=•$@>ßø>®‘ä>æÎ0>¿Éü?,o?8+Ä>rNh>: +ø>jÎx>ÿ¨"?Zv4?jÛ?}r>Xó`>©åF>ý?Î>åFŒ?xþ?)4>êf˜>ï‡l?+F>‘Bä>”œ>Å!´>†ßÖ>™Ä>ŸÎ?f?`p6>×½º>þ$?ŠD?1îì>ûÔÀ?)Y{?eÊ1?ASÜ?† +?7±?;Ѥ?Jˆ4?@J–?d>þË°?:¸"?Y‚Ð?IÑ_?8aà>Ÿ„Z>Œè´>È\f>8h>$Æ>€ƒ€>ÉÖØ>èÕ>’Ûz>DÈ?&¾?‘L>…‹>ü7h?X`Ž?ö?3Þ?l‡>áÛ>e¸?9?¨?ÿ^?^½þ?-DL>œ¯p>á3ª?QŒ>æ*ä>Ùîà?8cJ?5?`ó?[R–?:#Ò? VA>±H¤>ly¬=ŸoÐ>´ ¦>µ!>°Uü>åßÆ>ë“<>Õw>ñ¦,?/€>ô¥N>À—Š?I?Dùò?&³ò?ß?gl?J^Ï? +Ò +?>Õß?A&p?*g±?!Œ¨ p>àâF>Ú¦,? +?3Œ?2¿?žb?2ÔÕ?ì ?°˜?5QF>¼‚¦=ôL@>û*¾?7¬>Ö\T>ëç?r?(hu?):¢>µm~>ëÚ¦?0@P?=í¨? Ò>€åP>kƤ>§¬ +>½žÐ? j>ÔïÐ?Ü6?Xeò>Æn> !”>èâV?‹v?&º€?²^?cê?v,?„V?'0>ð š?,ñ,?MHp?9râ?ó>‡/ˆ>Ó,Þ?Yez?_f¾?#X~>ˆd=Œ>B0(?'ÒÌ?ˆÂ>¥£€>’Û|>ž‰`>÷ˆ>Ãiî?ÜÐ>üð\?ñN?kø}?+…d?2´?¡µ><­p=¿‘`?~ú>äîr>|6>R‹|>³]’?@QŽ>îª>ÞØ?',ž>´|>W̸>G€>Ž@>ÀÙü>qŒP=ÜJP=‡gà>Гb>Ãrª>/j¼>k°È>˜ ?&³>ùø<áÿÀ>ßÚ>úæ(>ÈÊÄ?9@n?$‚?$s?r>²úî?"ˆ°>Ól>¼ ?Uò_?NÒ~>¶Cð>¯Ü?,.µ?X;Œ?6Aº?üƒ?lÝ>«Ñô>¼(>»§®>I•È>߸?N>ʬ~?|Ô?9Ÿ$?1ŒÔ?L?(3À>¤V0>›T?±>ÍY>‘Ð>ªüÌ?½è?>²3>­úT>Ö¢~?,ã?ë>?åÚ?ôª?/P ?§n>¥dŠ>è6>äO”>÷æÀ?cýV?U¥X>ÖÙ0?4Ÿ>÷xü>Ñr?*Œx?*¤>æ?>>½H?8%t>Ñ'<Þr@>÷.Ô?OC>ùkÐ>íØ>•\¨?C@v?S5²?Y¤é?s»¢? .>¾]Ü>ÒËì=èòÀ>§ï´?;ŽÔ?J!?5U¨?è?#z? …>Û'j?Në‚?v…÷?k +¼?X{7?^ˆŒ?— >L‚€>€è>¡Mt>‡x˜?‡<>Î[???wf?r÷?:ãw? ÅÚ>ÊÑ\>¦Ð&>è|X>ÈL>Ø=L>°l>þDˆ>Ú€>œ¾ö?@x¦?eóô?C¨W?&+P>‘cØ>B>ÓÙˆ>‰Ú,>›P>Ú¢?"œ?s[5?1xe?&Ÿâ?P²?X¦ø?CÈH?îm?>É2˜>1Œ<> ›>^Ì>“·ì>dž„>À€`>ø? à?A >ÁÑ$>>“X>þì?5<>¬Üò?“Œ?:Žø>Éâ¼>Œ>K¬Ì>øŽÌ>¶ûP>Ûô¢?.!µ?1E&?*›ã>Èc@?J?;Ðà>ʳÊ=õ¨P=k` >‚Nœ>zèà>yÎØ>Á8h?&g/? GŠ?Aß?Õž>¸`>¢ýÔ>88>HÞ>—Ád>Rjà=”p>Ž½€?7©¡?SAà>»’‚>І†?Z,®?™N?žÒ>à(°=®¯P?û?,Ï>¿¤8? L¶?R÷ë?::Œ>º5= >Ò˜ô?B÷?ö>¤†œ>­ª6?9Æh?d? ?Öô?1ší>á«Œ>õ$>/qà>¦j?"I?fVº? 4?h\? _>›>ì?V¶?ø>! €=ûjx?Õ?-%¦>‡¨b?Éý>úÁ”>~ÇÈ?+¢?j_>ø¨>Cp=ö`<¯ÆÀ>Ö¯˜? žœ>Ð!?2?Qê>è?^v>Ïô>¢±œ>ƒx‚>ð†”>ªY\=£s@=éK ?zÉ?o§O?l›?Aô?(DÀ?/0?`Ó>Ât>¨í">Ì)š>¬>Ï"à?7«>Þ¿”>«R>ådf?9i¶?¼>_ À>O™Ü>!@ >ämº?7È}?SßP?`pù?*71?'#?=³q>¨¼?ÃM>èf`>·0H? Yv>íÚ >šð>Éi >öö>%ê >J;”>8­h>Ä1ü?U ^?leW?^>Ë?`©>è«à>˜D¼?=Ù ?8¿?%…ô?(Tä?¤T?:ä|?ßÚ>ü¹?H?$‚¦?P2?3¢?ZÓ?X³º?*w/? ÈN>e >Ú—¢?Vz>óï°>¹Iv>¶.Ê=t² >ÑYH?"[”>‰Ç^>úüø? é>›B?ý4?VÐ;?’«>\.`>ŸE? ù>³1€>YˆØ>„á¨??Iþ3?XI>íÞ&>8"?AÐ>ÌñÐ>x8>Ç€>âc?À;>¼l>ÇР?S&‰?q!?=»>wx> ?7+?Qäa>â-? ?!æL>Äžt?b? 8?J»·>ô•l>“6?*yh?: ?GÑ!?¤>ÆZ>…>Ð>­ÆŒ?K±?C€> o ?8?@Gª?6wk?%¼>¦Ê?˜p>ùÆè>5ÎX?%¼? ¡Ð? ®Œ?@‚? +çÒ>‰rÀ>ø¡.?tLt?<(@?6¡?;ÌÈ>Ū>îä°? é?*X? ZÌ>R–È>^uÄ?6?‘?&¾?>‹ÿ>Àã4=í•€>Þ¾>?;¾=?ûv>²>Yn@>óÙÐ>Ê9? ã?b>Pø=ÛÀ=õq>À¾Î?Lþ?2·¢?l•V?9I,?P‹>ÞÖl>ÚòÌ??¾§?a&?/[>Æp8>êµ¼?,{©?Ó>+n(>’±?)¹»?:^S?¹>†T=š"ð=™Ð>¸AÊ?F™4?{žÒ?@>ÌÈ$?¾>Φ˜>Æ¥„?5ü?e—V?dâ•?Oqã>ñ¬€?3Z?e>Z>õxZ? •`?ðÈ>ƒ¨:>A¿\>2q¼>ÊAø>—–>§ð.>–}p>«šŽ?d?ŠÄ>èk8>—Ù€?¢¬?ˆÂ>ăØ>ü§?"ó>†pÐ>øJº?Y‘¹?5|?»Ù? ,>¼3X>‘Ç? ýî?h£?Eï5>ÙÓV>k(¨>q“ì?Ûž?œ6>†H>LÖ=ª›P>ð`>Õmœ>Ë™ð?—?Õï?*Ú~?îb?ü÷?4â?Dð`?LD8?¬ ?8qÏ? +ºh>»åÆ?"hÍ?RØ£?C¯?B¶£?\&L? ™è>yyä>Ìl?JL~>íOš>bH= +‰€>÷Ì?$y? +Uò>ÊS>•< >Øäh? +•Ò>à*&>üsl?,Ìh?õß?5W?¿¬?#È>”!ò>=!|>Êð>øÚB>ªx2>ÙöØ?GIx?4ê>†à?2E?d’f?C§?žº>òÄÀ»¥®=çQ€>¦|à>®Íì>ØT>ûöì>î‚Ü>/¨ˆ?3n ?%Û>>!“Ø>Bñ¤?ã?D\>>òb? Ä?±Æ? „?;"5?¹¼>…t<¬»À>ª÷ü?.9e?3¬ó?>[Q?CÒ^>ñ‚à?Ï,?W©Z?3$?2ˆ?è> w„?(¾„?žŸ>B#Ü>¤W„>A0À>Èu¬?1æ?G‰.?~cp>è¸Ê>÷¸?dr?‰F>ÅÏê? !|>ß*8>•ŒP>§ü˜? ·Ü?xˆ?–”>×i¦?Wj+?h'D?.ñÛ>÷´ ? f`?H_}?/ú*>z$>"¼>Üø†?(žõ?T­x?;öf>¦Á@>®•Ò>ÝuÎ>‡™l>Ú5L>ó…ò? C?CYð>åg<>œa®?Ú>Î/>ãìÔ?)ES>ë¹? ? ÿÐ? Ò>ü¶?œz?+P£?@'Ï?*>ßqž? 1 ? u°?¸>Ü-ê>ÃÈ@>ýŠ?Bøp?"¬É>ÙI¸>ßÇ(?ñz>¯í`>Ц>âŠH>Ð8>Ì;°?=„Ø?áá>[Á>´¯ >µø˜>¿F?-Ij?K>“]„>`Â$>´,0? ù?æn>»µŒ?+5?)áî>‡Õ”>ç +6? `?#‚þ?¦<>è ?'a‡>Žv¤>Éx?oñ?\´>}$ø?)Ð?ëÆ?ùB> v€>Ð4€? …º?=¾0?(j>³ì?([Ö>ïÍ8? >ð‘”>ú‹p>éç>ƒ`? ,ö>’„(>‚Ëü>‹Š€=¦=à>oód>ä€T>Ä~¸>‡¬X? oò?²,>†iü>½?0?8Zœ?R%±?d²ù?³>V#€>‰ÂÂ?_•?6>“ÎP>³˜? +ô†?Gy?P[ž>íýè>Î>n? Ì?r?bËC?{U?@@?}»?MY?2P?AÏ?ŠZ?¢t?T¹Þ>ÃT|=9å>ýl6?{Ê)?%Î?ôÂ>µ¢Ü>Ê +Ø?v>¨a¼?5P>ì`>ž>×pì>h >Šýª>­D(>úþd?O¿ª?Øk? +s?YÐ?-«Ï>äç>YžÐ>à‚ >å{š>¬D>²ÑT>ƒd>ð¨>ÌÕÐ?2®^?CÔ8?Zÿ>ó6à>þ,|?M ò>Õx&?ß?#±L?|0?$x>Úæ >P4(>>r>ê;Ä>¢ÀÔ>ëÞX?Dª;>ó.>æš?T.?M†>ñS¬>†HT>N@°>彸>¼Á`?vÊ?nûâ?Ÿƒ>õNÈ?aÕ>â d>E-´>i8>lt>t >…fˆ>—ªÌ>˜…¬? µ? )–>ìýÌ>úªp?N)?:”Ï?-Ò>ûX?*BD>÷œÖ>x&l>Û,>Ž¢?g/? Ò?zm>òê?§Ì>ëü¶=5S€>ÿ™h?%á¾? «ã?-Û>¥4=ûVÈ? óÖ?V*>Àµ?–º?6?ŸP>Ðö¸>ìõ@?Lš ?- f?Qúú?6Õ>´þ?/"z? +U“? lü?j¨I?`à?D?%Uê?þç?*®â? ·ì>Ì>GG(>²ñÀ?/óÀ>Å64>ã}$?EV->Î&Ô=«µÀ?g²?2=шà>ú82?.Ó>‹È@>ÒØt?6n¸>¶äž>VX?"??¶¬?Gâ¨?f +?1ÐÚ?+?Tÿ?Di?ky >ŠçÄ>“ +Ä>½l?×n?U¿ø?n°Â?]Õt>ÆW>¼$`? V,>À©D>ëÞÒ>§å<>Į̂>Ù >a@>ë2€>ÚÉð>Ó~&?eˆt?€à>¼r>Ñ—ò?=‚?5,ƒ?`?Gk:?9£$>²Bn>í£€>Þ³V> X\? ït?Q6??4>©Îö>Á¶>öC¬>Gó¼>¬Å¬?/;b>ÐUÀ=°Ó°? ìÙ?"b^>Þe†>Œgè>W¬>˜å²>'@>,M >4P>çª >ûn¤?~w?[JÕ?l¾ã?%°ó?2O?;Î?Z_é?G ˆ?E*Î>ðœà>]8>Ò¦†>fúì>!X>›¯ž>Žç”>]å¨>¾ +~>¢ø€>ÎÖ@?.Æ>ñ¨?î5?C>÷°>—yö>qÅL>år?G>Q€>“2´?8^›?J¤B>ñà”>æ?Ô5>ïCz? æu>ô„€>ߌ ?+w–?B*>q@H>ÐIð>ý}H>”Ý>F}H>±jØ?1Ô?PÏ:?&Â? +??’¾>·á€>Ù°@?{?H¬?ù/?&yp?Bv?Y6l?R³È?Yš1?YMâ?;}Á?;oI?'4?:#?]H1?Rxµ?@~‘?0”ß?Ýø>¶²¨>±˜?Þ?D +£?1…?2ù?sÌ>ÌòÈ>Ö‡x>ð¯˜>ð]$>7”´?Lê?ë&>‰Ð>ò^?zb>|€ˆ>å„? ÚG?0=ª>ø´z? çÄ?kK +?õ?Þn?^Òd??Ì?C^?]:ö?ÂE>˜1º?03?!>ÖÃ<>ù˜>8Y >w:È>Æ ? pÆ>ÀTL=·AÐ=Îäð>2‘€>¤|¾>¤º +?7ç?Q\>͵ä>‰òÔ>ò©>•R(>Š†?)‚æ?vå>Þª?[Á…?lã¦?2n>Ÿ:>#†¼>íÚ˜?T³??!Gå?s?1Ãô>Í×4?µf?K¬›??D°>Ï>ô>_>’¯Ø=Šuð>Ö1$?/ž>Å?EPú?wOÊ?šú>ëö¬>åÊp?gš? >Ø×?š?+V?UêÈ>­a¼><„Ø>î\v?Alw?"¼>ç/Þ?BÚ?`>3>üÔø>úç’?©‚>Ý$,>‘¬´='Ž`>‹€(>Á¶?$Ò3?% º?,ò$?'ò>¡Ž\>™Œì>ÑÕü?P&^?NfÞ>î&>ªò0>½›<>F•|>¯á¢>™1X? B?9b>Ô‡T? ?KŒ¸>é²ü>íÚp>úýò>¿rb>ûV~?ç +>œ4?Ë?YÚ½>ÏÒè?@? ö9>™=Œ>Ȇd>аì?*¢>ñK˜>Žª?6“&>é­r>Ÿáx? +>ƒ¿2>oœ>‡¬>æ#´?1ò?/1!?-Dþ?(?XFô?F½?;nÿ?¦>¿`ž?.Dœ>Óg=†Éà>GÌ€>`@4>Иâ?TíÜé¸>2éh>Ïån?î?-W†>×xx>Äö>ù¸,?úÊD>ì0?~? ‰À?:÷:>Ú|=fH>Ø›ð?‡n>ù€?L…?dPj?tÊ¡?H°;?F†Ô?nxD?(ɾ>À(?¨ +?OD^?.ÓH>Êr>ÃkÈ?6ih?v?°i>ßü^?,Í€?k?I=5>ïz?‰ >£½>õx?ŠÕ>"ø>§ÖP>è‚Œ>ÿ’?L²>¢"à=˜q>ìù|>íÌð=·ì@>=5?ƒr?4›½>íåp>÷'P>¯IÀ>¢ì(?Bàq?;»> –ð>³.?çp?RÇQ?}T†? C$>K¶à?, æ?@$>9ä>›<><Þ¨?W?p~?+Ü„>ðF??|µ?8G·?íø>¥å¼>]24>ÏÈ®?+‰H?30î>üûh>˜½˜>ÈÐ>ÖØx>¬,?%^+?-ú´?vF>êßJ?’ ?A×k>-p>¥þÔ>÷*Ô?!„®?ð=ôÐ?‡²?J ?EìV?câ? nÒ>þ5ð?4™Ç?a£©?j`ý>àÑž>ýßÄ>ï d>ÿ˜ì?:ÒØ>Ïýb? Œ>Î$>ØD¢?oÐ>·—”>3`>þuB?¼Þ>†¾$>ÜrJ?O?1'Ð>ä®H>P!D?eT?>o?9ï?F\ý? c.>—PN>uÒ¼?æ¶?}›³?Xø¥?,…?@Ú?Ì,?X?Â4?6>ó×–? ¥z?¦k>ª£<>+.>ù²ø?d¢?j[?,ÛS?9#¸?{´>Ìjò>ëM¼>Å +~>Ŧ>—”>Ÿ½$>¼>id>ã<$>´9°>„D˜>IÿÌ>ƒ’?0’?¾>]Ï„>L7x>½S°?!`8>áö¨>Õôü>µRp>s¶è?™ò?3ª¸>à?0?º?^Mg?;†f?;6€?UФ>ªx>ɘ?-&?»‹Ä>áõä?¾ì>žÄÜ>úÆ>|„?ß?/vK>k¾<>·|¶? îç?úÈ? ÃS>ñü?Ø>Ô\>ã¬P?:‹0??¨ú?Y•:?Ä?vƒ>²ûx>×$?:”Ø?Y†½?å>UŸ ? ýa?Éš>l³@>`á`>¢¯þ?™ +?VB?!f>Ç.D>Š4è?g?0ÉD>¶«œ>ý6œ?j¿u?k“ ?Az>÷YD>ÕX>Š® ? +@>ùíæ=¤ˆ°>1‡4?0/&?&¦v>F¯È=Ú´ >û%Ä>û`ö>ŸØ>i.Ô>‰šd? +?ºú>»â\>˜k@?#?Áº>¢·?L.h?Jƒ±>ê]>äšt?Ìž>öl>¡V>xT=ðˆð>(*8>üêÈ?/ª? ‰Ø?XT(?-Ue>yo¸>8¤>ÔYü?Põ?4+Ò?8•`?X“†? °=µyp? +ö?8àÝ?%ó+?*’>Ãdl>Öp?4?M,? {?Juø?õ>Ë€ð?)¨>œ>brÀ>¡^h>½ªÐ? <>à¾>h>è>ƒæ>º_ž>Ü}Ä>ÌgÌ?!È??H¸¾? Ãä>ˆ%=Ö[ð>‹g >à$?žà?Ih¦?:&†?<&ˆ?Þ4>×Íü>·¼0?†ª?0™>”N@>„,Ô>í(à>æ0à>›ø°>¶»>Âä?ª\?-Žþ>Þ!¸>Ü7f?'_?$Á{?.Vb?^y²>Öˆ=’›=ƒp>¬Þð?Éþ?5?&&?EŸ>âêˆ>º¿^?Bl­>ÝÕÈ=têà=•O°>cmÌ?µn?Rè>Çå?-w>òº”=ƒÿ>V3`>&ë >ó˜^>ßßF>þ`@?AÆl?KZ?"Ú? <Î?Àf?q’>yð>ñå"??'ö? œ/>P’Ø=ëÒð>‡ˆ? +Þˆ>Å.L>³xÚ>¸&t>'·p?#Ñ>úŽ€>Ð?s.?1gÉ?°K?eql>þ× >Ç9Ž? |>„ø>à*`?J>>à†€?.Yþ?iŠŠ?Ø°?¡g?L³¨?/k>¦µØ>=Sh>gk@?»Î?+!è>æ"À>Ü)T>Ž‹V= ‰À=š|Ð=æGÀ>T +`?!‰?3L>uà? j‰?(>Õz<>Ô¿t>´–>sE(>ÍF€?Äž>æù`>ìÉà>”¾&>§&þ?;ˆN>ö5¤>û;(?'9·?.uÌ?Nî?Zm?u—,?"*ª>(>–dè>u4,>·Hô>µ~Ø?YE>ÄWx>N@>Àd>sÀ= >Ëþ,?3–>¾¡œ?´*?5ã? J?6R\>ÀýH9R>†ù.? +XË?Hz?#¡Ž>Éžè? hŒ>¶ >§í?'ŠR?]>áð>bœX>ÀƒØ>®oH?•?Pu?ž?iº? ¦?oˆ?:$>³-Ä?]J>ó¯n>Žl¤?Ë„?.k¨? } ? +n>²(ì>6À?Á¬? ¸¬>Ï,¸?+Kˆ?YM¶?†ì>º€Â>þjô>÷˜? í’?U>øÁÐ>ã ?S3¹?3$Á?3Ä…? =>ª$œ>KÁÈ>—zª>z ?p?ýš>Ž]:>Òó¶?rV?Üö>»,&>Éñ?6tœ>òÕr>ƒT>…@Ê>·K|?aÆ>“oÜ? +—À?nŸ?@zì?E¦?råœ?=ñ¤?5ò”?=>à?/?FU>¢Ý0>W- >› +Œ? +pæ>âgùÏ ?"œ?°>è¸h?^T>…˜Z=Ž£ >EÏÐ>ˆ>š*d>‡Ü¬>Óè?;ô½?6|ý?ÅX>Ì®h>Å—Ü? b?4ÜZ?¼n?þ?P[?c¸€?Œž> P>‡óL>Ð^>ÿÅÀ>ÿõœ>'D>¯³,? áH?W:Ä>àx.>ܯ^?3W¢?$‡a>þŒ>ïÿD>ç¥$>é4?ÜŽ?W¦°>ÀWT>À8>¦á?¶Ö>ßù`><ªô>Û8>ÆêØ>Œ€>¹aÈ>ýãH?9ï°?29?dÊû?@Æ?l¼?9!0?©8>¥°¼=ö]Ð> +è(>¼X˜?õÕ?Â>¥»´>zX`>²:ð>Ûéò>ïäà?]­?U¯ø?WÀ? Ý>Ef >ª¸Ô?3¿Æ?B`>f¾>Y…p>Šm|>d`>÷ P>à¿`>ó>©5œ?Ö@>ß'$>KÎà>ê„„?"êb?Aan?bMä>Ñub>†ul>¯7ò>°”à?*á²?$?ð>Ѽ>f1à>‘Í ?.(*?f?Kö>ØL&>—º?#¾î>äj¬? D¾?oKB?(QZ?* +S>çUÔ>“m +>ùRL>ìh>ìùà?P?4¼>£à>¹ +P?2â|?$J”?C +¤?k\>š”n?ö?'sñ?6šà?V\ ?¸? b>>úR>Ð>·‡¼>¶eè>ü"|?.Ü>Öz>O{„?Åj?Ã>ËgT?!xŠ?Ôï>Ÿ½Ö=ß >^}$>¸ÁÌ>l",>;ËÜ>Nr@?Ä?#?&D?>N®?+¨?,žÏ?MCÞ?¡>D‘<¨/€>¾é„?-Œn>æz&>>€¨?"(? •F>í]&?g >ßT?7 ? +€ì>Äm,>Ê|>Šì`>çò,?AƒK?,DT>³hŠ>¾N? —??'gU?âD>p­ > Ô0? gI??Šh?+©E?SÀ ?'<>âÈ?+ø?&¹>Jh„>‹¡è>ÎB?1–?F·:>ýô>Ûpê>Ô:(?ãÊ?(H‡?f&?"‘ñ?Jùb?#(>Nµ >^´`>ƒ‡À>³7?&Y¢?KÆl?7,>¬ì"?"ƒ™?_N>þãÀ?jZÚ?ˆÐ?\ø>ÿÖü>á" ?+—_>vëè>þÄÈ>úlÄ>Ïš,>Óœ>ãDø?i=?Dp5?:´›?Ñ?Ð? +7u>~Ý8>Éô.?BU?7ï@>ê£?'åõ?WŸ?I‰>Ø”>àt>ÐŽ„>£J`?Œ>¢l=¹øP=r>d?Äû>á÷Ä>Ü:T?í–?MÌ–?Ëh?Ãì?AS˜>³Wü>3>½ßü>¿[~>°HÊ?Š?'_à?Câu?Fæ|?rä?*‡¨? b>³2ü?}A?!uÉ?‡>ð|°>¹wp>ÏK°>­”¦>›!æ? ½(?³ÆŒ?,O>ÿÐŒ=Aÿ <“þÀ>ÃI°?eö`?L~æ>×Î`>Ñ´¤?8Ä‚?hþ†??¨ð?^W>}4@>4' >ï–Ì?áé>pÝ?g`?@9?8ö±?Zn?5É?ü’?:‡ð?ˆ€?ή?ô"È>ZÈ?Z~?l>º0ü?#u²?[?vÞ?h “?ÞC >³ïT?&°>߇l>ˆkÚ?,E?]¨>è½>H³¨>Å^Ú?,V?Wáþ?4i?ú”?ã>ÞÄ>­€?š?éd>–ó>•2¦>6(?&Þ?x@»?q;Ø?5Õ?*¤Æ?VÐ>¹0\>‡ÓØ?„>ü…ˆ>bšŒ? }?mR>õ9ä? wa?pHÝ >Á:L?(gˆ?W!?]ò? 5þ>õøÒ?¤Ã?.¾?&Z?Q1÷?hë†?5îŒ>—A>i4ð?#c?Zn?1š’?Ýò?0B?EF?3ž>jP=ó§à?w>ʆÀ>¸Œ?d7_?J?Z>ÑŒ>!íH=4åÀ?@ß?Z‚]?7Ž>éH`>:¨ü?f,?`æJ?C­>·Ä<>â§ø?MZ~?+.³>ŽÔÞ>]´`>÷Ô ?,œ? r>À+Ùœ>à à?æ>̓l>y +ˆ>ÎHè>ÂÉ|>ʼnø>í¤>Ú̸?Ò>æ†>NH?*?KY>Ö¢€?`Ü?c$?FÖg?JCï>¯.4=Ïxp>Cé8>îæ&>êA@>1-€>‘$4>Æíú?2Á÷?Ùê>çz`?%`4?ƒâ>Ú ">Fð?Ea?P[Ž?0Î?/Íp?>ˆ?@2¿?Û¤>ñ +?.@ +?6“a? áÐ>hÃd>Íž$>½ª>µ´??Xê>ʽp?›y?8‹W>ÓÞœ>ƒ2€?%’–? Ò?¶Ì?A>÷¥>€µ@=ÉD>tZ8?¿ª?O·N?AØ{>œO`>ÿJv?(ún>CÅø>šdx>íRˆ>ΧÌ>WP?Œ?k|q?A0Ø>Ó3,>d`È>ñ¾*?2(?ˆ#>¼Ž>˜*Z>¡X>?;x–?B='>Îˬ>Èz=‚4À? 9? ¼r?$÷?4þ>gP>ÂÓ?OX¾?!Ã=ð P>Ù> >Ë"è>–…þ?$vë?I±G?yØ>ÿ|F=ÐéP>°cè>š™¤>¹ÑJ?Rë?@’>‹ =g>@>ø%>ï |> µÜ>4D>ÛjŠ@>XnX>áo?6}*?HSÄ?L¨?&Çr>ÜÝŒ?s–?3º÷?Lf?jÂ>ø€ú>€jt>øôZ>ûgô>çߊ?<G?¢0?N¨>ú‰> ¿°>Q >aLˆ>Vú=ç€>÷“ä?PìÞ? b >«l>°Ã ?¬t?HËü?4œª?5²?‘g? Š>÷ux>ì£D? –>¡v‚>ŽyÀ>Ï $>œ>ｨ?9 ?(E>Ô L>ºÏ¸?8c$>ö&Þ>IpL? äâ?+á.?Ú†>Å(¤>¼=«Òp?±Ô?qÐÈ?;œä>Îcx>ÌP„?'Î?b>Z§P¢£?$e—>Ýì,>¾E >|°|=÷_@?&¥?Dü?5{ä?;ñb?1qÆ?Šœ>ø0?;«@>ÛiÈ=×Ì0=Žè@=ÝMð>ì# ?Aö²>É^,>`> šÈ>ê Ø?'†´>íÏ>Ê–T>5±È=’ > °°?Æ’>¾ÜV>Ví¸>é€â?z?(Ko>ìêì>Ú >jxô>¢Uä>õè0>õ¢”?‘é?U&œ?…i>?Ð>±]D?.•ô? ñ?‹È?Q0ö?g" ??%Î2?Â:>‹ô4>óêÌ>ƈB>ÍÙ>™f>¥]r>Öõ†?,“ì?*úô?¡?:ÂÜ? ú?#n?"zÃ?:Qž?j#?' Q? +¶è>‚~È>ª™,>”f˜>´t¼?"â–?!¾¾>¥˜>”LÌ>ªË8>cý˜>ÇÝÌ>ßB\?N?³W>2˜>úòŠ>ì <> o€?.X?4!\?Gg*?T~·?2§>Ü(X?)+?*+>6è;ß9=W'€?¨Ã?tÌN?8^?#Ñ'?n2s?Z¼? ó? ç»>ïþ?>Ñ?L‰>?céî? ? >†¦d?2ª2?/¬Ô>á¯~?â´>ò5h>Ïù>šÊV>|C¬?¼\?LÈ?Wz ?+„ß?VÄô??ƒÂ?%ÅÅ?Ažv?Hè?xv?&Î)>—€?É"?V‰ã?Ú(>΂ˆ?Ãü?+¬>e14>`Œ8>ùpL?0S#>¦¦ô=ƒ >q¼H?=Ö?<Ük?jÌ?Ö¾>;>Ç9 ?Ñ>Š"=õ$>ýZª>ˇ0>Ü4?1 ³>³Íœ>Ï`Þ?K?Èý?]ª?(6>ùeR?U >ö…ü? +b3?)˜Ö>ò9ð>æ9˜?²>á ? + ²>Áý(=?À>ž x>¯ûP?el?Z>a÷„?éŒ?EµÞ>þ»¬>šœ?2j›?5÷`?5Q§?` +3?Z€?bæ?Wmp?dÒ#?mIâ? \ì=‘ð>Z¯>YËl=W—À>²Ïd?I¾î?-_ä?ƒ°?n8V?1ÿ'>|°Ä=æ¶Ð=„´€>ÒA??%²?¬>QwŒ>àV<>åÃb=ô?>_>߈?=.!?H>þðP?&!9? W@?6c? D>[ã€=ó >!²\?Q°>ûòì?¤Í?¬ö>¼È?7Ç?8 >¾*>‚ð?d?A†à>ÀÅè>1Ìð>~gŒ>ŽO(?îêœ>´4Ò?8Ÿf?&™2>Ë”.?’?¢>ÃÀ> ü>¸ Â>£›J>Èø ?+ED>òPz>–Ãô>û ®>©ðz>óÞ?i÷[?um?wT–?>•P?M +?Ek? |?uï?E«Ì?QЮ?h~ï?9ù¾>ª¥L=u >¿-ä?&R€?3°Í?$÷Î?D>ÕžŠ>õŽ?)Êó?*h>è¤?o—?33"?3{©?–ä>9ˆÀ>} >È:p>l8„>“yÄ>ìJ?9–>þ4>e>ìÀ?Qö;?X7¸?P 3?<)–?Kï?VQ?Ø?9"X?"'Ó?{`?\Þi?EF®>óª^>ûl???kë{?g°>ƒg0>£|Ø>Èêô?5Û€?G $>ïì>dí? »º?]†?Ž>_x=y>ìp˜?5i@?3>©?R–A>Ûað>Ì¢?†X?³h?V¾l>ôE$>‰¶r>ÿˆ? +£?E¾>Dpx>eþ >Lǘ>úæ˜>­»`>˹š?9‰?@ú|?jÙÈ?>M?UL?08>î=Ü?Ïë??w?N)N>ö¿>>P@>N|>§÷6?=L? T>Øàš>Ž¢p>‹„?àŽ>ùÖ”>¸ú>°Ä?·õ?=fØ?P¡I??M>ªyh? \c?u+>8ùø> ™È>wãÈ>¬ì=n >Ù;Z>ÿ°>® Ú?ð˜?¸J?1„?'X ?2ì?B5? êW>`q„>õ”?,à.>Ø}È?H®?­Ð>Jõ=ŠÀ=ìÇ€=‚]°>h¤>L‰À>úïP?x}ô?'¾®>†ÉÐ>×Oh? 2#>hæø>õˆx?pb½?K§¢?/e3?»Ì>-Ñ>ÏZÄ?µæ>ùœ|>Â2?e‘?C¨?4(?Î2?Ó¦?!)?à>Ù"„>ý 4?Aa‹?K%_>±J>ñâ8? Šk? ´?3¦%>T3¨>|?8?'Žþ? ?oÉ?<›Ž? ì„>éÿØ>iÐ>Xœ€>ÄêÔ?5Oº>ûÎ(>ܯ?Q¦?¢"?Ј? Bº?* L?êì>šÉ$?å‘?Eâ ?à>üÚ?Ýî?)û±?[oÔ?^©?þ³? +£ë?R¼U?B\0>Çs >äÞ?5q€?FPä?&bÀ?^¿?;Y>?.ø|?5JL?Ê>ðÍ >•z>þY~?‘? +Ðÿ>ºÜ¬>÷ún?JÒi>§V=Ä >Èš”??—˜>·çX>ÄX?B£Ø?$Ù>«<@>ÀD?å?O;k?{Y‹?{½>võ€?%gš? ±<>˜þ?;¾ƒ?.Mò>š[ü= z >‚i>ª÷4=ø0=îòp>:ãœ?nÈ?vŒø?@F>/¶=•m@=É›`? +ò?Gv„>‹Ç >áè(?,×>ÔöØ>”bÂ?&¾?Gî> ?+Ò?8M)>ûUL>¡Ml>/Óè>Œ»>ÃN,?=É?fu">بì> +l?6{?8>ždø>pó?­è?P‚?èŽ>wÈ(?s>ûÙð>¥PH?!Ô°>ÌI>¹>3vÐ?$X>ûY¸>ê·´?$Ý>ÞQ>ýÕ¼?7>ט>æ;d?Ú¦?'¥2?+ŸÝ?(X?Mx©?˜ˆ>j€>Â\l?– ?4ª˜?«¦>†ð>Å9>²Åà>qQ˜>îVü>LJx>–Ý >c`>4nÌ?úu>Ðêì>Ô h?¥¤?DÂ?:3·>Ëéì>½,ì?­€>®ÀT=¿¸à>@ÆP>¦–ø>ƒÃ^?”Ï?C€Î?@-Ê>îÊ>‘?6V^?Kq-?Qto>í5L>Ìg0?Q‘V?!~?(èÑ?D#ù?ê×>ÜG¤>°>^>š? '?-½å>ìIB>¼mš?X3?f\?€?74?,?/†?1âÌ>¤ˆ>ñï¨?u‰>Ò¼d>t@>D ?2Ž?*gƒ?#…‡>áW&>³Ú?4¯–?;Á¼>ã À>Uòœ?=Ž?,´n>Ÿ ô>#>à>M¹Ü>’>Ô?"“H?r?þ?>–V>î‹°>ñS0?#îE>õ2>÷þÌ?þ?†è>ðÞÖ>x¨L>þ˜à?Ì>>àEL>®ïÄ?"0V?IE>É3†>ùÓà>ú8>“´?'è >ÝöÈ>Ñ>½ÀØ>wÁà>²}ô>Áˆà>ºú¾?*_?\ô»?!3s?i.?B^Ò?1yñ? žê?Ré0?#°?Sœ?)í>Ôgd>ȇD?+£à>ç£Ò>Ü2>gx?Ý?8l> >µæ?þÙ?ª™?~>ÿäø>Àì? êÑ>±LÈ>é¸`?Aie? +ž>Ï!ô>z‹>ÀT >ñZB>TÖ˜>W·l? A$>âÊ>éŠ ?.@?CK?n7Ì? ”¡=„ð?Æð?Hü?%ä†?8Èu?ï”>Ò#ü?/\Ž?BO?F3Þ?µø=ú\>ô/ø>øŽr>¨£€? ì>„«†=Ü;°>‰è?Ê>ù™^><–È=ËáÐ>Γ?P¯Ü? •ö>¢;x>ú‰Œ>Ìÿp?!ô?bD?;V?Döž?Kßî>ø\–>×?¼?üÍ>ñö8>·6\?"üC?˱>ÆÎÚ?X>ã£^>Ì‘,>ûH?4¦ä?)Åz>ëø>¾JX>ú»„>Û}Ê>=8>Pþ\>Ñ’ò>ó5r?Îœ?'ï!? 9¦?W¦4?r7–?ìF>þ³~?+Òâ?IÜ?KÀ´?(˜@>éËØ>¢F”>ªÞ€>ÕÄ?"¨G?E‡ü?F¡o?téb?f½?G´v>¨/L>ཤ?HWŒ?oG>Ò‰?8±U?aùq?ºn?q??qº?ö ?!`~?G÷v?”KÎ>ÍËô?ôR>ò’ +=íßp=èh>ÈkN?DT{?7A2?*Œg>ÿtÌ?É?žè>útÔ?+¸?%êí?!tª?( ?«Y>\>Î7„>­c>Ñn¾?U_> Þ¼>Üd>¿ø>Ïɘ>Èž6>t >àל>ý³ê?10?;zî?}-? +ä?T·>üÿ=Õøà>­˜8? dÁ>ïìð?2À_?_1=Émð=Ž(`? +¤?q±w?qõq?çt>¼Ýh?QÿK?ý7>"¦¬> €>ŽÕÜ>¶Ã´?"H?A á?.Ô>¤¡Ð>zôð>wÒT>•ì>œ¬ü>‹<>iB>`>õ6¼>þŽ>Ît>ççd>Á-X>?è>ó)€?Cö?@Ñj?!S¦>Î…p>HØ? h6>ÿÏ€>Ì‘Ø?W¡Ð?Q°I?åô>Qã >:õà>Í%>ù‚?,Ÿ¾?4? Þ ?tò?àï° ?+²f?XÙØ?[?[¾Ì?#€>ÃŒ?'B?h o?Gº(>½]&>óV,?:s’?L,°?g[>Â,?©®>¿zR>ë´Z?;à.?j¿?æC?#ôJ?%p?×B>´NL>¹h?ïÈ?ç>²ðT>9wH?™Ù?Ï?øÉ?^ú>¾Þp>ö R?4=?b,'?(¤ +?"¬?N">åãÀ>›ú?=„þ>þ<>:À?'¥_>Á ¤>7H>TÒ>’O°>âø¬?/Ŧ? Âv>A¡h?›?qeß?U’?hº>Ò¾h>¤Ø”>3 >x>*š„>ál>þÄ? +¦;>¢ñ@>JT=àA ?‘ý?å.=ø°>.<0? ±û?=gJ >¿H>aƒ>ò±Œ>È}> ? ܘ?,»t>·ùÆ>­AF>÷øô>KM>2–€>û}ä>¯Ä >CŒ>¥Œ\>‚a2>‚´>Õp?'øî>ÿ…Ô>”µ>õz|?±ˆ>Dz¬?#ø|?`ˆ>àËÄ>µ(´?3)c>ÿG®>†Hv>vhˆ?"Ï?P¿‡>ÆpŒ>À9X>š –>è@=ý{Ð>}¸è>Çô|> 6„=¢‹>¼Áð>æO¬>èD¨?! P?SÃõ? g>¢@x>°1,? +Œ^?]Ã&?rï»?rt—?f¡[>äÑ\>6Ùð>ÿU’?R>VÅÄ=O5`>³È?*ä ?ÿd>«î¬>8>Š~à>R>iÀL>|>„ÛÈ?†?+°/>áÓÌ>²XÜ?ô\?!¹>ób? Ý^>º²H?­}?ÁÙ>q¥¸>É}D>ËÄ>Z >Ú{è? œ¾>ƒ¬–<)í€=Zx`>´8È?O76?SŸ?W?¡>Pï?+CW?Y2e>óÛf>*ž>·W¨>ñ*Þ>’ǘ> è>õV?\Ã>ù#‚=Õß?_“>昴>ÑÒZ>εä>2‰?$˜ô?2Ô>…Ä?$ >Ïל> +\>¹Ev>€°h=ضÀ>—æä>Ì^ô>áÒ¢>£ê$>¯ ¨?@Ÿ2>ØT¼>É´À?Û>;½>¨ü˜>‹Ì>;„?q?GŒ>”k¦>X‹ ? +dÚ?ò„=ñDÀ=´>¸û¤?)G¿?UÉT?)c“>sºl? °,?jº8??*?a?+v8>ÒhÐ>Qph? ˆt?›t?³{?Wî>¼²N>z¿t?[?U=? ¦?KÝ?\!>ìG>Ž“L>ò>L?'#á?G~>î8Î>¾»(>’—P>• +ê>­Eð>ï Œ?N[?'»ß>ùÁ ?+Dº>íîH>†ˆò>£Á4>Öð?%ìþ>¾zè>²žF?YÎ?[æG>Û—l>°hœ?6èr?5å>ñ—’?Ú?'òp?1L?Ö >Ü¡Ð>él¼>*3Œ>Y"È?øô>ð7ž>Ó5 ?OÖp>í>Þžô?J`?˜È?(¶h?/´d?3ÎÄ>áR +?Í>µX>ñ£>?cE$?Kÿþ?SÂ8?t™#?K{Ÿ?Æ?/«E?,R>Ý’†>ÌãØ?1Ï? ì->ÐÃ$>³¤$? ?vc>?d¶V?Hå¦>ÓÍþ=¸²à?VK?Ž>DH>î¥&>õw>Ü# >ºçÎ>·a ?HÀ>º;Ä>ˆ«@>Ùl>ÖÙ°>Ý¥f>úÜ? z?bÊ?H"¤?q>ÚEì>ÿ0r?(«¬>áÆX?%äF?)Á>‘'Ð? -(?7„ê? 4‘>âb:>@*@>ÎZ¶?GÚÙ?d™?Woñ?$Èy> +>”'>à?—?/Õô>¬¬¨>„ù>¤Ë´>BØ\>t ? d?QwÊ?Z}K>í³¨>’ª¤?Z4>ˆ3€>Þà?ÙZ>þîŒ> ‘d=`>žÞl?3½˜?„è? B»>ÞX”>ùº?BEº?1ÏÒ?¬G>dë>„oÀ?õ¦>ñÙô>8»h>Õ³.>Ì@\?Œ<>øÉd>Ô½$?I\>ö¬>²Ö?9;?#û=?%>ÖX<>¬ýb>¬Öt?EP?kT÷>ðe0>Ãv?6án?6ÔÀ?*Ql? †÷?ZæX?)+§>õgü?eE>ãmB>ÏÈ?7Ç?D6T>Ø;|>$o0=ó)P> ˆ>Ž,>x],=ø{ >ñæx?U +?B?fyX?n>UOp>ò¸>ˤ(>+t>˹:?m >éˆÌ?ò>öÌ&>Yö¸?9(4?L“Œ?(TI?C#S?SˆØ?óz>ûÌ>­b>½ò˜?e¬?Òþ>Ȳ>óý2?K<ú? |Ä?'zï? >æ> úÌ>Ÿ-? Ó?O^">ÛØX> äà>‘ÕP?0)Õ?[…¼>ý¬P>‚´>Ï€f>6V>¸,?'{é?÷/?ÓÌ?=¹?©>Ö€>ÞTÎ?>€ž?D?"Â%?0U?­ý>ê +?2 >Û[,?%ÍÙúŽ>Úqx>Ú²¼?B%Ì?<^–?&?1‰f?å¨>!è>ž,?t0>â è?¸3>ç˜?ª‘?6{à>‘u<>ÔU¶>ã¸f>¨y°>¶$Ú>Þ®Ø?!>Ýöª>èŒ?öQ?”ˆ>ôf¸>²‰š?-¥>?>>VÜ4>–Ê>QA˜>§04>1È>ÝéZ?:Õ´?%Ï?‡?9¶?ä±?b>ÿô>ã–@>³Ä,?T”?Aà >¼SÎ<Ø|>]ó4>Ü\2>šö‚>µNŒ?óø?¨>ûZØ>²Ò¬>Óœ>Ù?TP¿>õ»¶>¿“`?(éU?= ?/O+?>¢?D~j? '‰?<½>>óN„?Y¨‰?ŽV?-7]?ˆ‘>ÊS°?\>?‹B>­c`>Ÿ.ä>&ð>ƒ¥Ä?¤µ>ûÌ–>Ó@è?gŠ>Ÿô’>èð>¶øh>¬Ì?/Êf>×ãŒ?4¢?l$>&>ƒ“´? ³Ð?k¢:? |?ÅD?B|·>™šä?–Õ?E<>én?WL?L>? +æ>HŒ<€j€>¯½X?Ss?Ø;=Ý>id”>‚™4?5 ?ñÔ?&%$?O.? â%?¯x?D~Å?,º?â?P=>óð?ùo? sÈ>–þ@>œ;,>~§Ì>¶}ð?S>ß)œ?0®?2‚Ì?¹Š?VÅX?=n¦>ó§,?A>µ(È>¸ô?G˜?:•>³œ8?>Ø? +`>¿œ>uãˆ?l?>¢’?JÑö>ùlX>g œ?]Â?‘,>óŒð>ö§²?(È>Äžx?'ÑÚ?Lý’?:P8>Ûé> ó€?)aè?7>y;œ? Îð?9û§>Úí¨>ÒC0>å@p?±°?]_’?- Ø?½?A-¼?mÓ?Lÿ0?{>‘ L>b=Ø?&þD?‘">»‡?JdÎ?6F>³F´>µ'D>Ö">€HL>yw`?_«>Ï-:>è¤P>æCÈ=£À<è×>!-D?µ™?0{?2ÿÒ?IÿÌ?ûŠ?LET?*–? 4 ?÷«>c,>.aà>( à? Ò?fÿ?S?UÛw?3w? %×?ÿq?,›?ZL>ïe =ÔÀp>`>£"?·å?Ž>Ü>Ì>«h`?Œ>òžœ>–]? °š?=ªF>²n>‚È>Ï-0>àц>Ìtš??úc?'%Ÿ>ÝU„?!n?8 ?Š:>ÃÒ>F¸>ì©>àŽ´>Ïþ˜>ÅÍÀ>ŽÈà>—EH>? ˜>ãª*>ŒÉ´>f p>ÀDÔ>›1.? ê>äÐä>„ˆ?9 +?Mº¸?(.º>Ÿÿ.=¾Ì>ªÐb?7¸¢?Kï>ò«B>ò ?TT$?](?gº;?l?P?-˜>ê_@>X! >à˜?Ë?®?^k¨>öÑ>À>ØÀÜ?]T ?nAR?+Á?,K?M-n?KÅ¡>û? >½@>ðgB? Sn>ô‰.?CÓ'?@€É?]Ž ?n½¥?<tC¨>ÃÉ–?_‚A?NHß? ëO? ?öN?$H`?ó•>„¾>T»h>k +H>…%è>ä4>¾@¸>Ë‚ ?$µð?Íì? W>ñ¬‚?'?H?\À?t?{ ¢? >¯³>…f4>®v?<0š?W½r?Gö®?4s?Z¾[?Q‘d>à¾?YH?TIç?1>âì~>¨‘è? +dp? Ž>>è7¸>S™¨>²(?SLÎ?g8P>ðL>¬x¨?JH¤?kž}?DH6>¨Kø>áO$?Lä¦?J/þ?4P‚?E]?qÂ>öÈ?-µr?5ÓÜ>í:L>"¤>ç&P?"íA?LB£?$SV>½Â¨?U>¬í,>‰3¬?êq? +|?!Ýò?eS¢?=Üø?™Y> Þê>êÌ?R–ê>ÀuØ>íŒä?7Î>×/†>ãŒØ>õvø>Ø‹">çaô?cN¶?H©Ý>­%¾>›gœ?L#?-.ø?",7?6 >·Ôò>ÀÀ®>«¢<ÖÄÀ>¡£ô>Ì{¬>†æ>¡œ?>Ê_ˆ>—}^>¡Vh>ÛaD?gFª?&%H>Š³¤? 8n?>?*y;?æh?'å?!KR?Õf?<ºZ?/Ϙ>qÕ>8AX?ž«?+8>å~l?@¶]?Wɼ?/ïx?'©p?H¸>?—?®ƒ?7›˜?†´£˜>×Ú?.¥*?f›Ž?’µ>ݨ=„ð>->JMP?%¨>à8œ=Ó? +ÏÂ?i¤ö?jM ?N[D?Vd¥?!K>Ma?èL?h'4??e¸?"§ >‰€Ú>“lò?c:>óxX?4 +?I¸?u.>¦(ô>©r&?! à?VÔ?9$? +šŒ>l è>H(Ô?"c?%„ž>ðö>Šub>ʼ¶?@e?i?@™+>ø2j>ùL>þ)Ä>ZV8>µãÀ>û1Ü?)¶¾>í_è>ò`?+ä’?V{7?AÂ>Áyè>­tž?2i?Y.?ÖÎ>Oý4?xÝ>ò£L>E¾à?$G?)3¿>µLx>Š÷N>¾$J?E.?3x¢?.±®?*‡>ÖãT>Ëèš?DÊ>™Ôœ>fLì?9‡?6>? lL? Ù\?/ph>ô¼>îkÎ?"*v? ·y?UêC?JÏt?4œÚ?N¢°?E8>ηÀ?Lr?(q?0 >>±I|>?4æh?"-€?Eþ?»>Aüð> GÐ>\”0>8 >Û›à?„T>߬?O†?AÕ? v>þ”Ü>œº>dÆ>2¼<>ÑŸV?H7Æ>â à>â&˜? °>Ñú>äÞ> +¸>ù«D?<?5Û?&¢?¾È>‘Õ>øvr?R§Íä>ù{ât>™²¼?:Ö?@|>Ü«ð¼[T€>Çex?i&?5 >¸(>ò@¬?íæ?K)>þ~? Q?9 ¯>• J>ùÁ@>ò÷˜>ñ¨>äÐ?¦á? Ø?/X>㩶>îP$?ZŽ>w"(? +ð>üT¢>;„„>ÐÎL?.q†?!í>Ý+>’óž> ¤l=P€>”P>ܽ? ^ò>çYB>._ô>$¾X>sfx>‰Ö†?$?4ã$?Jt¢?\T|>úâÌ>«p=èj@?ur?J²ä?ƒ>û¸>Í°¨>¹o`>„L¤<©F€>)>ô4H?Péh? tT>*É >ƒ¦0?–?1@>ýÔ€>‡ÃÒ>¦LÐ? t?_‹?r–\?J}ƒ>¶£Ô>Î[\? ¬?%q?…p>ÍŸÈ?$çÚ?{9?ò?€?¦?W?à>×Þz>Š‹ž>Þ”T>ŠD´>x° >~Œ`>3Ð>Š2ä>æ”X>¥ºx? +ðŽ?Q¿?V?z?ßê?)?KV>¯jZ?û?:°?`z?5ûô>¹D4>„Vœ>„X>³Ÿà>¾â^>,“`>õé$?95>Ñ•À>?Zô?/?T.Í>¹?š>®ˆ>vž>Œ†h>È”>…Ä=Ìà>–¯d>¥¬>”`>¿*>Y{Œ>”%Ð?9º? 4Ä?/ÒÌ??P ? +»@>Å´¾>ŠöÌ>­ˆò>|6`=Ž§Ð>lP ?4ž€?rÏ?;·c?Gv>ýÚˆ>¬Rô?$sv?gDæ?|L>·Z>ãÒŒ>Ïã >«Y”>‹ÓH?Ãà?[®g??¯B?8<?®â?F£?2ÂÐ>Æ¡P?Š>í{°>ß8n>úé¼>“ $>G¨¨>œO˜?#Ü>ö}>²L>éLV>—çÀ=Øt>ý(>M>”û&>¢·=Ñ`>Úvˆ?ã~>î–$>ÂBÂ>«¼?/±$?7aØ>Õx>ÒQ0?LS?>ÉÅ>÷F$? +ݺ? ?m?GB«?' Y? €Ú>š1,>{Mp>V„È>ð¦?/ƒ>n>Ž„Ô?Ñk>Á³L>’o|>ßcÔ>¢ED?0ÒG?gEh?5Ë>Í ô>Ð >­q>²–>ᦪ? ?"ª?Ö´>æ<>¥NÎ>5ä?3ñÄ?’µ>Èá¶>ðwà?öd?X^¦?ˆ2>—?4Í>ç¨>¾>-¦€>Ⱥ0?C4ý?øE>þδ>÷¹Ü>ÿH´?NÞ>Ý[>Å™˜?FQ8?äƒ>ŒgÞ>Ÿ((>Ä®?"Áº?`>Å¿:>¯ø>Cü>N>€•Ø?2ˆ?v¦ª?vC>âçv?OÊ0>Ö ,>û P?kD >ñKf>t20>´*Ø>x˜? + L?fO;?Y^h??7ñ2º>Ü3ö?€?W>á™’?7 ?< ?+6#>ÉDh>zML>¬,r?>"?kÀ¨>V“?:Î?%Ä–? µ^?4€Q?"‘¤? á»?)5^? X>`>@>ÊHô>ÆÐ?8â?kŇ?eIW?9ÂÂ?4þ€?]x’?F›á?I' +?/F ?'j?P]D>õ4L>â)4?Sš?é`>÷šP?€ß? 3l>Äñ<;Ö×>ïå >Û³ >—“$?K3ó>ø-?—U? +ÄŒ>I·ö>„uœ>Ú„8?M?$‡ê?f?%!«>‡C>î…Æ?X1?é7?%¹¼?`Y+>âm(=™? åJ?(B˜>@Up>”¿à>Ž7œ>— ? Ú²?'ËÙ?O»ú?cAà>ÊPÜ>ÿ¿¢?Of??:/?MJ>¬û^?2”? IÞ>””¬>ô?l?š5>ÃϦ>¸ŠN>R0>!>§÷? +x>ÿ9°>îš4>Û=b>¡˜¸>¨þ¬?4nV>ÿµ>lµ¨?(ýü?-¡>ës">Íód>µûh?\ž?byé?Lm>áH>U.ˆ>Òûb>¡c">Þ¤>P\`=ð +`>×[Ž?4u¶>šý >üg¨?Yó{>¹-<=Ȭ=÷Å€>ˆ»>?tè?8U.?"ÀŒ>ŽÒä>}…¨>\ú >¯Ï?°Ç>˜å€?Ù?N,%?B¥>÷ ¸>`Ì>âÍZ?$rä?Eyv?¸=>Ø;Ò>ô<>=Òˆ>‹™l>©žŒ>—8? ?PF¡?Yϳ?=Ó?$Õn? ”(?'–?? è?[ü°?.Û5? Vi?)’ä?8á|>Ù‡4=uR@>ÿ ? }? ôê? ˆ>Ó¨>VÈ>hÏ4?)Î?(¢?'ƒ8?]Š>Ó¸Æ>°Ç>õM?'Ò[?-èõ?Øÿ>©qÈ=„ €>žæ8>Üôî>ið>­ä>¢ Z>§”4?, ê>ú@>ªÝ +?Ø>Ùè>öRÔ? +’¨?('ñ?‹ˆ>s°Ð?º>ä@8>¢xŠ>ã+¬>¥ÐÆ>ö,h>Ç(p?&Ú?U §>õN˜? †? ?f?{øÐ?C™`>“ž=á¡°>©Qæ?X?15Ö?F)L>Ë¢D>˜²>âÐ> Üì>ž”˜? Ç?$8?!tÞ?õ>‰Z:>Wô>ûIú?þ>²¹´>^ü<>®Ž´>Ì9„>ÝØ?ú?LŒ?UI>ùT>†œ>ûä?LRŸ?Y·ñ?4„~? ;ì>ñ¬P>rê >šä>>Çšf>‚š8?°>ý³X=‚üà>Ëà? ‡œ>¤6H>è]®?@At?3Rí>·Ñ>œªà>ÈùV?=Ç? «¦?X>¹ø>”Z®?£¼?i’?1ô¬>õØ>ûÍ >²Wü?ª>?5è ?KX?N+Q>ãèf?ÓH?t¨T?Px¶?‘?3b>?^ÿ³?E5?E€!?".>g/l?%0?]ó?9ö÷>É}>#ô4>±  >Í^p?W?[tÈ?+Ë?'ì?c-?cåß? +¼ã>üͦ?+€?k?7*¼?Td@>àt>¬h>ÍCR?ò?]^_?Qûb>¿¢œ>QLì>’4? +@>ÅÕ?Ò ?^{? ž±>°—Ê>Cò¤>ÛPÆ>òè„>×LN>¼uÔ>§¹<>úyl>LÔ=š>ôˆ?W!ž>Ñ >ïï\?$„¾>{âä?V +?*þº?%ÿa?q!N? >ù8æ>ó€Ž>è€=‘ >¦õº?ˆÕ?›%?ZÄy?Tl>çñ¬>ƒ8=èð>3Dð>œü>,T>yó¤>üþ–>¾¤>Š ?A*?5€>ñp®?‰P?Wd…? ñª>s!€>'l=üà>ÓAœ?m;ó?[ìœ?fH?6¬?`š?&'/? 9¦>ÿ4>€î>?òÈ?غ?Q?gR?GÂÜ?C©î?"Þø? B|?.+Â?"|d?IÀ?hª>‹(t>ÎYª>à9¸?"À—?7Öµ>µÏ”>¨@>ŸÑÌ>¯ªä>0y(>ø™d?oN??Z1?)*?`E?\–.?1V>Äg,>¢PÚ>®¨„>¹Ž4>¢Â>"0=ò1€>Ñ ?…?C >ݬ>¯ ø>‡ì?) ›? ¤>ŸG†>Ìà>¯q\?r?-§Ÿ?áÊ?5k>ów¤>°å>÷à>•¸>gkð?)ÃR>ù Œ>² ?Ej?%¸ó? 1z>î^>i0>”µ>¶þV>˜†>Rû?»ÿ?<‹Ú?¯ˆ>ߌ>«rˆ=Ù<`>Ñ €?µ&>{Hì=÷0?¾Ž>öqœ>j>Q5 =êN°>ˆC¨>åGD>ãUd>V˜À>ÄØP>ïýÊ?¹¸?>äüœ>À߀?&Éî?JÐé?JѸ?u¾À?LÛ„?Kùª>ü7D<+>üº?G)²?›?!)ú?D1%?eÌ?yÐ?ÿl?)±«??*?*(>‘F8>m€ä? •b>°±Œ>â|¨¼T?«ê?ªZ>ƒW¢?˜M>ýXŽ>q§¸?*§¦?i¼?\»Ê?cض? ZÒ?áÒ?qh?8æÊ>؈V>÷+,?á? ¬5?M”*?UŸ¿>Ý9,>Ðp ?N4G?z>ãÿ°?G2>¡ÌÚ>’N>>¦:Š>x}Ì>ž­ˆ?5hn?Ò>o¸>ïüÖ>°3 ?6?d›&>ätœ=­«p>¤>t?#Äâ?[’à?ìÉ>ð¶¬?v3n?#XT>’ìÌ>ôýB? +ª\>n«°>™c8?E˜A?vƒ>ï_z>°zh?æA?$ƒÊ?;RF>Æä`>HÄ=§P0<渀>ÕÈ>ãõl>¨¡$>º’H>bšÐ>À…Ê>³ñè>Š™(>Éð8>Ü·p>s‚d>¿­Ü?SôÚ?8ð@>!ä>¿%h>é©þ?‚U?(-„?*&M>èÖn=eÖÀ=ÆÖ>“?ê›? QÖ?4*B?3ß­?°Ä?7²?Z£N?:5{?ºh?TÞ?*Úî>éÐ?#šj?µµ>h¡8>/&h>Ö*þ>‰²`>û?S(7?6Þ?7êi?!j?"‰?/ê?P&Ú?Ê|>$|h>óBŒ?W=×?O>©?h"p?Eóã?+²—?>Òâ?-·?*bÙ>³,<>18>¢Ø>­“Ä>ªžB>¶at?Í?(ÂZ?$?@Ñ>?Z-r>¼l>Û’~?+…/>Ú@:>ñ·ì? +nó>ë¹â>šDL>b©ˆ>u¢?"þ? gÑ>te€>µ60?!½5?'6H>é?Z?¬0?Pà?s‚ž?vuŽ?Aù;>¹-8=Ðp>‘p0>”ð>ãš„?2F>ªú>Ý6 ?3Æ>‘¬ú>¦Ä? á(?ù,>ÿ?‚>©i´>ñÎ?MÓV?K“š>¦;¤<ˆÐ€>pK >Èj^?¼N?JN>Îù8>³í¸?+¢Ñ?Mý>Ë„T>ÄŽ´>8[¤?ƒ\>ýwˆ={€>…°Ø>â·¢>é³Ì>ÞV”?#§©?D³?&·û?Aò–>ÎA´>µ¸L?Â?9Ât?‰?!ö©?ká?¿f>7Ö>ëy8?sz|?@Æ>²Î?.`Ò>þ?ì>ü½ ?/±æ>ÍÊ>Ø…Ü?Uˆ?Nnä>øOB>…T?\?j£º?¯F?¢>òÿ€?èŒ?>+Õ>Ñ\>þ+B?3Ò>Šy\>`0?/¢>ð@>þê|?z>Ô(?¹Y?G°? +ú÷>X&$?½Ö?42$?!}>ø”? ä?;*>þ¢@?Ã>¿^œ>HLà?ÛU>çHœ=Ïa€>$&è>•>ßÓn?²v?ò?h>} °?áZ?2á>ú2D>ÿb\?’Ñ?’J>µêh>Öl>Ÿ”>¾Ú>˜¥Ì> ¤‚?ü+>úf>G˜?t?Pÿ`>çAº?™ë?3·?&‹´>ºuˆ>ÙR?TC?·x>ÐâL?t{>édô>È„¨?6_²?%‰¤? Wu?öŽ?Э>ûV¬? H?h`c?,ëE>½F|?Œ>ÿ»>>óùF?)SZ?7¸?oÍü?üö>ð±¦?i6>é¡$>À+H>§·˜>s¸>ª1Š?˜L?+Fƒ? (? ë>ü÷¼?ÕÆ?B0?Ï«>”V>»l¼?Yü:>öf‚<íë=gÙ@=n§€>UQÜ?®Ö?8b??ïb?"€Ü?fæ?Cd‰? ¨>VÏx>Œø?:¢?zI>(Â>®×”>ò§à>YoØ>8É >ô"Ð?¤>~'ø>Æml?Wg?VY? þ>Ql>pPH>Ø?K¢?--Þ?\ ß?dc?Cœ?&‚ô>; >”‹>ø:ð>Js˜>ï€>ÁV^>xO¸>¢$ô?JÞ?!SX>À.*??Tóè?qe?y8Ú?U¸? º?:?1Ã?=ëü>¡'`>¿ÙÌ? Kc?&q‚?l>i$$=ÿoÀ>kcŒ>O |>ÝÁh? g0>"ŽP>ïû2?EÅ|?WP?f©"?'Ûã?5n?4E®?:E?3(>ÚÈŒ>„º>ù¨l>¦ì|>¡Ãà?-º?œ~>¬ R>áË ?3xn?-”ˆ>åÚ(>š4Ø>Ý>¬Å?CÐ?5v?è +>ÀÁü?8ä>Ãm>,¼ì>©i">ä˜? yw?>åKè?(…?hÊ>Ä=º?Õ>Îà*?G$>Òø >Íéê? Ê‚>úÐ(?›¼>û®Ô?EØ?"I=óxÀ>Âë`>ÌŒD>÷Eˆ?8óÉ? ? øÆ??5V>ïˆ:rp=ëOÐ>ú/°>èï>í œ?[v"?MqÝ?ó£?Ýp>”å0>×Æì>Üú¶>E9 ?Ð?Z­? Ž¢?!?Nûš?C]?ppè?tØ?-j+>[#T=Ä@>ãF>ëEZ>œj”>Ó¦´>Þ–?’Y?/Œ}?h>Ÿ?^Ú?{>ò¦P>éÅH?О>¥k>j¬>çcð?$‰›>>>ñ@?(hø?;1?Aiè? ¯À>Ý°œ?7ÁŸ>Õºì>üöÐ?=Ž>ýùˆ?3Åï? À>¢ßD>Prh>ç›^?GàÁ?FÛ<>»7º=»jp>‘À>ñÄ>ÿ‰$>vf>¿ñ >ûâ$>δ ?é6?B^e?$¦Ì>Š€®>Êêð>¹ó@>L\>‰Ô>ëH2?Y «>ùš:=Â)0>K€>ûQ¼?i Œ??¬ƒ>•õ>õ+`>Õ×>÷å?n¯?ÕR?U?Ê">f`@>‹)ø>M¿d>û(?P>Åqˆ>ï¥`>ð¶>¡Òª>¥ +T?[êè? +?º>@ˆ?%¶g?mN8?9¢É?ô×>Ÿ¦â>øpò?qkG?JA²?\ï>ý´Ì>„6®>‡úŒ>}Ô˜>´™ü>¦=Úp>³]°?)ýA?Jt?>Qñ?6¢>µ?úd?€íl?>ñô?Ac·?<Å4?&fP>Þ[ü?“?k€^?dï?@ŸÇ?FÁ4=_úÀ>8μ? ãg?Ò¸>ìb?e">³ù*?^>Ø~¤>ä¥Ä?H©&?M©œ>ôŒ>§_>æ!J?¦¼?NKÚ?BÝO>åì >ÜE°?7W? @n>̵$>¤ÑÜ>Ïã2>Î]Ä>N’? "–?!Ü>x(>{@>—Ìâ=êÓà=·>>l—X>@(>²èB>àVX>åŒP?$'í>¦ÄÒ=£÷=éð=Q<€>™åö>ÜýÌ>ý.Ì>±¦ä<°Â@>Är„?&6Ð>…j^>mÈ>ž…|>“³œ>Ö"Î?½">ºa|?éj?n©?4Çj?*1ª}Þ>¡>…íþ?%_O?*‚->h]h>Žà@?*×Öú>ͯ<>âu?1vº>ÏdÐ=©ã>Îv?O/Ô?Gáæ?/`>K-è>¹ëø?:“'?Mí6>äëÀ=·â0=üÖp>hB¨?¤~?Q¿*?r¥€?YIÒ?W9,?ZéÍ?R>Øaô>YG4>éÒl?.?Î?,û>“Ò>¬-€?.G¿?{b)?SÄ ?58’>Çç¢>óÂ? +Íá>³Ÿ¤? øž>”¼°> ;>Ö)°?CÀ²>êà\>¯#D?]”?"7Ü> *8>ó`Þ?)aF>÷ç|>ÆÕþ?²L? ‹>‚ø??ɤ?á‘>Çnº>GÒ >ÆÊ6>¬¦ì>@Ü>Þ°Ê>ÀJˆ>°Ð`?;A7?P²? Xã>P¸P>—d´? “z?Cš?Qü?GŒ?ÌX>Ë€>| °>èä?Äè>t@˜>P'°>¯cî>SÀP? Jˆ?J¯Š?=õ ?ÿç>·<„>í°?:Á*?/+ë?0èÑ>û{²>Á3Þ?"âÖ>Ç.’>¢>žU:?D£I??÷¨?êt>ûóð>Ñì>‘’>3h?Ý?\ÄÄ?5 ?ŠÈ?„ü?Òs>ìsÎ?ë¹?<`°? Id?0Ó?bYª?]¬?Š°>®ó`>l=å >Ê/?:×>8/(>©*?>bè?Q®q?F>•íŒ>Kd¸>û ?_øõ?ÜJ>‹|N>á³p?fz>âþX>ñþ„?$Zò?¸?,©@?úA?ûT?%î>“e;ý¬>Š¬˜?½ >—1¼>DÇ0?}ª?2³d>¼¥¼>|0È>ô(>áŠÈ?³‘>¤ä >a‰L>¦V>˜ºp>ë}ð?*ø?+ ¥?4-¿>éAÈ>"0P>Êx°?-/ì?'˜>¥²€>A™ð>ÆRâ?5ò5?+úû>oXˆ>ÁÉ(>Ñ?²>ûi4?<±†?Fm>í.Ô>È>Úü˜?°4>¢þ=úø>µ€¶>ØÚ?.ª?Lx?1yú? `>º‡ ?#u?eïü>ækÎ?¡p?&1#>ýj?6zÏ?%}t>Å2?ìÁ>Ô)Ü?ª?7Â*?.ò¥?+ÿ¼>?(=õe>SNL>ãÿø?Piü?ø> œ°=5ðÀ>“÷Ä?,uÃ?Uµ—?(>?IÂ?Rüæ?G¨ÿ>ijf? 7<>ûËê>? ? { >ÖEb? Ó$?Eo>¿Ó|>“ˆ?tÐ?.X>…Š>í¶|?fyƒ?Ò>¿^?/³?½>SP>æNÞ?nö? fT?‹—?$áã?N?a¸¢?BšY?9~¿>Ö¿<=ŠS>ì•¢?%[^??¹Ù?W ?Qˆ³?a¾b?-ž¼?f>Æ:„>Ò±*>Ãû6? $?kP.?7å?=Ħ?ê”>”±Ô>IK0>s0>"=L>ƒT¼>¿=D?$ |?oò?.Lð>Ö]þ>å5Ü?!S&?BbZ?Ò=?7”?1åî>Þœ>Úiì>¢Ú¦>È>8gh=g4€?ÇV>î`=w’€=ßt`>€ßx>­{ø>PïŒ>jÅð>f™>Óƒœ>Ô½ü>M±>á¤l>ðÚð>±×”?å`?,>œB>´>É2p? Xà>êr>Ó¬>ëˆ`? F?æÌ?2l>³5ê>ÉÜ?`?=Œ>ÖŒ>Ш>ðò?3]ë?Yè-?bŠv?s˜>”F>¡Ž.>–y?Iß?=ð^?8”f?B©Œ?·X>¾Ü?g~?>Eú?M|5?Mïœ?6Š>Ôš¨? °"?XwÜ>ä(Þ>¬æ>ÍÄR>dM`>/Öˆ>é)x>Ü¡˜>‰²ˆ>˜+À>"Ä€>–ƒú?%&1? OÔ>X >ÏÏ>²Š8>›"h>ê4>„„®>?ß@? Èx?8†Ì>ˆ~>Ôòž?=þ_?( ?¨¥>ôÒ°?H¦œ?%ȶ>÷rú?Tá¾?N*>°pè>¬B$>ËÂ>Ù°ä>WŒ?7¼?]0?BÁ>Á)Æ>6C?6Ö?m`ó?@™û>éÉè?,J>âMÄ>²H?ÎØ>Õ–>}P>ù³„?üP?DÑ9?hò?‚:?)§²? +;g>µÄh>Ê~">¢RÐ>Q“H>)/ø>6È>^à>‘„¤>o±>Ÿ¬?3Ñf?Q^? +«†>êø8?•>®1?.ÊD?^žM?^Bò>ý¬>¹cÈ?>at?2Ðf>Ípø>ì˜>…š?&W~>¼ *>©Z°?¿–?øW?Dã?wl²?Ðä?r¢?kâ?*À°>ÔLt?0³>ôú">²Õš?4ž>’cH>9‰@>û<Ü?.S„>Ω,>ý÷à?G³S?D£â?3?&¤§?\@?9µÜ?éâ? „‚>ú ?ä÷?+÷X>Ræà>Ÿ>¤?­?ì®?k8?«?Ø?¥L?"½ô?4QO?%ÇŽ?¼Ó>äÈ?¸?`¾?©o?÷Ä>††„>ñF~>¶,È>µO>û6Ž>×3˜>»±Æ>´v>¢é ?¾”?%5(>‹HÌ>Ê‘Š?2Çþ?15>­ˆ>ë<>þu<>ŒŠ¢?¸´?0ý0>Æx?Ì?_>«é>ªA@>$RX>?aêä>ø',? ã@?fèá? 7©>¹Á¨?)œ?3œÈ?ACŒ? +ß>ʧD>Õut? v?ZêÈ? ì;>9"Ø? ¢—?f$?+]L>n˜ >êý’? ¨Ü>í´ì?:5?Ÿ >ƒ'æ? L&?‰8>“æ´?°>ê0j>˜ÄÜ>ÿHÂ?;ñV?Z¸Ú?(lš?=ÏÒ?F„¾?-? +ú ?(@.?bÍ?â>Å4ü?6½Ì?Kh¶?0z??ó¢?Y+£?\ ¢?.ÒÐ>Òe">×Îh?Gåà>Û¥è>Ž +Ð?-ë?æ»>†BÌ>¸(<>Â^`>‚Û¨?/ˆ?0Á>†ºˆ=¨ p>ß›n?P ®?(|²?1+8?ž?xˆ?? â°?ÙY>#¯À>•ë©ä>ɵ>åÌ>¸[n>–·Ð>è>År*>ŸÓ$>´\>¸KD?B¨w´>닼?CSC?h\?;tþ>ÙWd?#“>ò]X>¹L? +¼S>ûÉ<>ÔÇT?.…?¬æ>Ds¨>¡Y¸?ÐX?XŒ@?lÆ?Gѳ>Ç4è?9ž?4á>ÿ‘ü?F¦"?Qø>Ôn >(¾4>äwâ?§J>h™P? +º¨?<ª>ù*?þå? ªñ?0'>üÈ>üò ?øî>Ÿ¸ä?4l ??Z.>¸>GíÈ?kg>ùƒ¼>²îÜ?ȶ>›>­¬þ?-*’?%ÁÄ?uî>ghÔ>&Jø>ÍB|>¥L>„Zˆ?í‡?gä>ùŸh>ä?Òã? Óü?t¯?hvj?c€=?^I>© >Ñ{>äȸ?;Þ?EÕ?z?  ?D’ ?)?,?„Ç?Ì>­X4=â’Ð?VÁ?"È@>Ñ×V?óR>ø¯Ø?TÜ?4”?+æL?cIx>달>¥ÃF>ÞŒ˜>‰à>ÃŒ?& ª?dïT?Q¾“?#¥>Â4ð?6?yîR?»Û>²¤Ê>ç¼?,ô?fz>†PN>ø(à?)óŽ?–?&>©2€>›º8>õi¨?ò(?è7>ä*”?”? +B+>m­ä=µð@>Š÷4>–Åì>sïˆ?^?7~>*q>¢šþ>·´¸?Ô“?_G??¾à>˜Ì>.¢>ˆr?"v®8B?. +?cÄ?5y&?:<=?&>·f|?]>°7`>%¸>IÙh>/ñø>1(>©•?<£,>ê>¡êÐ?=?&hr?)OÚ?4˜b>áëù­8>"ÇÀ>iY?íb?Bƒx>ÓaL>y>é‚?#¡‰?>>Ç6^>ÀóÄ?'à>§˜>ÎcV>ùN?/ì?=+|?8R?J¹Ë?@>küp>Äü‚?[Á»?Wâœ?PuÃ?jÑ?Y‰Ü?-bž>Ê÷¬>ùé>ëH4>ˆ­?K¤>éí°>¬]˜?B¹Ô?E ù?E¾?,6?û®?)6?±?'6?nód?z»ù?3g¾>ÛÂt?±T>µh>d3è?&N?HuT?M¤o?Fd?â>ýÆ`?Zø`?`D=þëÐ>žÖ´>ÄYT?Ýþ>çt‚>¸Çz?Yd€?>y+??%t?@á8?¿8?îÞ?MÊ>ÆŠ?)½ú?gŸ¶?cÌn?H¬ð?Yœ¡¼>åê`>Ó2 >êм>ÿÚ,?p?Q¯¿?+õê>—&Ô=•€=É‚P>ÔW8?Kàí?OF?Jûª?e‰?1?Yºá?Zé¨?%Æ°?1ªH?CÍÎ?6?}aù?í6>¾}$>ï$Š>Wò¤?ÃÜ? +Õ*=m÷ >ƒ¸¨>«³À=ÎöÀ>`ñÌ>ßï|?‹4?.=?ËP?d”?1¡é?ià?VŒ?ôt>ßX?D"ú?&?jU?+ž?,—õ?iX®>Òf? ?1Ä’? w8?7>õÐ?C"M?M[|>´k€>ëºt?UæB>ÔS¬=†->—x>õ>l>“À8>+ù°?*V?2ß>sÙ亠`>Q.˜?Û¸?B£È?H`“?/º„?h®>y­ ? O?#>³èð>¦ÕÔ>‹E$>¯¸>½T¬>Òa~>aàô>¤eš>ñ[0>½ ^?9ÆR? èj>Є6>âzp>¡Sœ?$Ö>Æ©>±ÀÜ>ÄV? ì?mçB?7ËÙ>…,>—a$>¦ F=ÂHP>ð‡â?@6å?Q¿ü?qèö?X;Õ?E ?j8?<†Ô?C˶>¥T¸>ÿ¿H?#F?%Ug?Ls"?EŒ>ó½(?”¢?v8f?+T‡? +v»?]¾r?'Ù^>dQx>@ À>   ?+Sà?(Ý>Ó~´>”*¨>µOD>ænŒ>ð.¦?ÚäH>2H€?¥S?Ryú?5‘“?R¯ž?lÃ>{ëX>½÷P>„ft?VŒ?£¨>Z T>€yP>G°>!—”?Ê ?TB@?PX(>Ì5Ö>õìéì=þä >¨\? ³u? Qà?ì»>ʯ\>¸>À?L±$?W +B?0'¢>¬¾ø=™@>íú`?Kz>¾b>o0>µ~l=Þ„P>†Ä˜>¬È>’ù ?+Ó?ZD‚?WbË?báº?;Ë ?e?(NÞ>˜EH>õ£œ?3Vª>æXü? }Ù>¿|r>qí„?KÒ>èÛÈ>¬êÐ?»>íu°>„U`?Y??<”å?3vä>Ð)Ä>·Äš?~&>÷æJ>§´¨>óÌ0?4í?ú>æwF>ãç>¦0’>´ÿô=IŸ >ëì?j>ˆù:>+ð>ƒH’?2ß>ôÝp=g <ÄlÀ>ï& ?DsI?²=>¶7Ê>×”¼?Dö‹?fî?fÈ>Ê?”=Üî >Ä>€ÍÚ>#g`=öã€>Áí>ïkÀ?Hu?%ùÅ>ÍÄ?(ï3?GQ$?2›r?"><{ >q>–e²>C’>L>Yd?%Ç%?8¾¥>¬6€>)]x>mÚ >ÞÆü>ðl>ðɲ?!1e?.¸?1öã?\TÊ?á„>}R>–dœ>µ"b>Áè>ELè?#À?5á.>ã Ö?8Ê?&ðp>ýZ?ør?%»>ÎÝD>¯ŒÆ?…–>Œ>y0¼?ˆØ>âŠ>:ª >rèL?ÉJ?)Jð?,íP?h^º?!ŽØ>ÏÓø>¦X„>Âè<>î^¨?.×?O=¤?(> Ó >Ö¯‚>½Lè>íü?MÕ¯?Sö?m‡'?=ÌoD¨>Æ×ü?>f>ÀG”>ð;À>ç\h>òâô?õú>†öp>±Û¬>† Ä>!jD?Þ?ã¨?þÂ?üj>ª>œ?Jž$?M?6+d?(<>Ÿ=v>Qòx>x+È>:á>šEh>þã¶?lŽ?Z´?-à‚>žÏ€?û™?"?×ú?o‡§?b>î$>³>õ^?OB?Òù? +b´?M¯?0Ùû?š†>º]l?'$æ?]P>„(²?ò?KVÞ?GÐÔ>ð >¶æ0?%Oª?^ÔD?¸M>ðà?.ç?(:?M2†?X8ð?PwP?YŒ’?:SE>È? Iî?EeÖ>Úuf>±qH?2ß?{¤?5?vo>Pø=D €=»1>¤ÏL>«‘¼>Øad?¹T?Vª>¼óÐ>¯ê¸?,>Šÿ>«d„?Ñ,?–>??çì?:.>Þ/d>(_h>=h? I">Õ>V>¹m*>Ì”>A¯p>”?Ü¢?(n¼>¸ â>…oh>}>Ö­\>®´¨?4”?jÐt?C±V>ÔLP>²Øn>ˆ[l>Ê+Œ?…>»ý\?{d?At?ù¢>Ó-H>:Bœ=ÿâÐ=ã€0>ä”`>Ô‹|>„H?ž>Ìì>ÆiÚ>†H>ßÃÄ?>&?l?õ?B?@ì>â\”>OÉ@=à•>ò©?G‚?Yõ4>ú1L>›î\>ÀQæ>»Õ€?2µº?kKt?A¼R>ÏÈ>碘>Û:¤>SXØ>;'ü>ä?yº>ÞÎ> ”>( À? h>ÔH|=hE€>£4>½·(>ñǪ?X"”?l¬±?Ct²>Ç_>ÝVd>ÜWÂ>P8>ÉýZ>åÚ>g\>̼>â? ?œ(>ò?Dµ?Z$­?v[t>ü«N>@(<>Ùƒ|? ñë?7Z ?¾>z¶€>™|>S¶À>¼~?=¸°aì?xä?¨¬>©PØ>[(>ùL¼?8Sã?›?:B´?+—€>÷ò>È‹l>ÚÏX??;?.ªÕ?/èÉ?Z,Õ? J¶>t(?9?\ ?_òÏ?OH?G?1Î^>s‚„>lK? ??i?0t²?+-~?&ô©?É|?&á?W±?=¬ ?7±ò?€#â?¯8?§Ô?_Ë‚?lƒ?Fãë?s?-Š?OФ?O%•?%s>¹:T>œÂü>ßï²>ŠL=‡€?Éh?j«%>Ëx¬>Ñ,>Ï='ûà=ëÁÀ>VÆÀ?ä›>ôŒØ>žD8>‘ÍÄ=’C`? p°?rÀâ?G§?HÒò?/|ß> ü>à”®>ÄI>ð‘,?]Þ?F©N?H­p?Uc>ýÒô>X¢Ð>"qP>Ÿc¾>ò4>ª@?ÀŒ>ÕcP>Žr$?˜&>ùÈ? º¬?[}£?/?!d¦?#­>ÌxT?4¡ú?gÿÂ?ðV>B.ä>w@?"cæ?cÇ…?Pƒ*>¾§D>êkt?J¥‹?€’>­ó>îNœ>áÒ?-?ÜÝ?$(p?I53>¼Ø@>¾‚ì>gÄ>ç«:?r~=OÏ`>ð{@?`2?F²å?E"?S­W?Z´å?Î=ž"0=?q`=‘"p? Ï{?~>7(>‡Z’? + h?>Õ°>=>ÄMœ?Ý>œ:ô>üŸ<>è@? 4?:V¤>’78>eh>op=ô×À>Ô>ˆÐ>”Ü?!C*?V?)=$>^÷¸?j‹?{ „>ùú,>›O4>ÊIè?|Æ>ðã?ÁH?'=®™p>Š?5›²>óHè<¡ÛÀ>´H?®?‚?a?–÷>ó_P?FÐ+?,Ôf>·7ô>²Š"?$õ3?|µ>Ì×@?sþ?*ù©>O,`<">Ã:°?XÕ8>ëb>ÐŒ>Ö…P>‘…d?|D?&k?\ܵ>ýg >28>ɳˆ?c>­ïD>Bà?„Ë>íšÊ>9‰ô>™xX>ÆœÎ>œ@;ï8>#â ?ïÇ>éŸ>sQx?ÊÚ?V^G?6¤º>‘NÎ>”²¨>ˆˆx=½Ð>³h?sL? Uí>ÈP>®m$>€¢ˆ>çjà?]äÖ?4«ð>Éx4>†k>xM8?s?l >÷D=å×P>‘,R>êÝÀ>Þ!r>÷øÜ>‚›l>™Ë\>Øö>=ö\¸>¢WT>™¹â>‘s”>Š­Ø>Äc ?h +„??Ì?;O?g>÷gd>ûIÜ?9 _?O¬?H´J?&›t?+?1.ç?)3Û>wð´>~>ä>±öf?%ñó?J ?+ÿ?*´>øVÆ>õé>Ç R>¦€>Ÿ§h=«ÀÐ=Ë P?¼Ž?hl@?é^?r×?'ª>Áƒ,?BÝ>Ú¤Ô>}ÌÐ?C¯?jñý>çê¬=ÿÒ°>^\=°Òà>êè>ûï´>­´ø>zº¼?tI??À>€:>¾ª>©Ø¤>ä| ? lç=Ð?¨(?_†>ù2Î?†{>ÛÑ?¬ò?KY4>åh^>G>nÇp>„ÖH>ír:>¶•l?g4>ûäú>‘aÞ?&8? +‰ü>À}j>@Ø=ºƒ=é*Ð>ˆ}²>ãmø?@.?=žp?C§­?ráO?bŽŽ?QÂÊ?d ^?_†?4Ò? Ò>ë>¶Çä>â:ä? å7?¦?¶¦?QMÖ?jöî?K¸?Iƒr? ÞŠ>9’ð?+(?B1×?%Ì°?6Œ²>¾p²?Y5?D•¼>Ä)Ø? +Å?=rR?LÅÀ?'9i>_¬>öâ>áf<>»,>º.>ó¿0?Dl÷? cÏ>Ý'>ï)Ä>½ET?¥)? gM>±,ž>Bß<Ëì€>Œ'>Ï”>y×X>›n>`\ä>å4Ú?¾h?Ó¬?Ñ>=ù? ¶¾?¨p>¯â†>ùD¨?Ü?E>Ýœ?Èn?\Ö>Ѓ>ž^Ü>ÒùÊ> ÿ¤> Øà?GÜ?$FV>ÁE>áì´?+ªÀ?îÄ>¦ ? r?»>ÅrP>¬Ñ>í.0>Ç!&=«ö0>»’?lÏ>¤«´>t‰>“àæ>–<¬>½û¼?5Œ?g´=e? öÖ?‘»>«ÿ|?>‘??&• >Ïœ¬?…:?2É?%£>Š ,>‡Š`? ø’?É>ôô.?#º4?-úí>Òâ¢>$bD>7ò¨? d?YÐï?Tw?g?Ö?“ô?Òé>ÿ=‹«à=2îÀ>´¹ô>·Ý<<Æ€>\‹À>Í ˜?op>ñZ>]b?ün?_Eä?"*?lÓ>æ‘ø>Î×¾?>  >Cx¸>ñðl?J›F?ªÌ>B?dò?ˆ“?j?J>ŒüŒ? ÀX>âª>Ô†?#ØH>‡xl? -2?«„>è1#òl>ˆ}¤>Ñ à>±Ï˜?8Ë?'‹>fó,>ah<>½3H?1<^?õûä>ÊÚJ>~@>"ßð>Ì>˜û|:w°?=`?VGh?/³\?R?têX?v¥%?y4?´>[r?¹x?¿>ç6>î>ͦØ>a¼(>aè?„å>ïÈ>´÷,?†>»”˜?jÊ?>Xz? S?K>÷[>!X?0~N?†>ãý>?_dd?"þµ?7?iÕÿ?`¬>½fH?TìR?:·>½}|>'¹H>¹z¤>æéø?¢þ?Ç›> LÌ>ë>üÃx>¹(>ô4Î>² ô>[à>‘“0>û’>±Yú> `˜>êä8?Ü>ÊrD?ƒŸ? +A?.y>ògH>yˆp?/¿x?Oûh>Á>>ÙÚ>ã 4>U×4?(ì«?(>wæ0>;>ªÔê>èüÌ?A¾ß?0?™„?%8b?NUþ?@x?>ÒÇ@>ºÜ?ú‰>ï‰&?(Ô£?V$=æ5p>iÌü>ˆ4ˆ?A@?,6>gí>”•@?=5¶??Í?ž‚>ÿÏZ>‹h >AiÐ?&?7„Ô>Ûå¬>è(à?¡&>í¤æ>,·€>;¢>é ø>à-´?çü>ëh„>­oâ?|·>éÑœ?O +?oU_?ºh>ωŽ?>ï„R>0”œ?Ú>Ò|\?µ´?`y?Ð> ­ˆ>bl˜=æÝ >öŒNx>Ô`D>äo¢=ì¿À>øÄ>Î\t>‡€?' +Ä?Oë>5Nˆ>±C >ãH >ö@?Xœ>øÝH>ð‰Ð?jª +?THä?+CÖ?>äÈ?¥{? bL>Ê€¬>݈^?â?6 +? ˜Z>à¦D?yŸ?‡M?¨r?RŸ?Aåa>¼? À'?·c?D*?ùJ=×7€>wF¬?2iå?m>»ÊØ?1/¸>ñK|>§5z>é-">]ý>,>í¹ä?!00?#Fî?Ã?ÊÑq‚>øwF?¦„?Mc?¹V>"à>„LÔ>k&>˜Óp? ‚>®¯€>ºJj?3%å?;P>y¼>é `?rÜ?Ùb?‰Ž>â¶?%£¬?@H ?2x>¢†6>YiÌ>>Žp?¾J>øÀ>ã¾ ?_Ò?[š,>ßgè>å”>ÁQ>L>§#>Î,ì?ñ>?Rƒj>Úû> ýð?/´?L´Ó?$«?…`?XV>ܳ|? ¹ú?2v>äÚ>ŸÂ>L(>Ѷ?*»ä?2•Ø? @è>-õØ?Ôž>íl>¢ö +?FrÕ?B>ã$¸?-š­?ÏÜ>üÔ?¦?2Á>ØØ$? ˆè?@_>¥«²?/üF?)Œ?®M>½ö¸?¿Î>ÉÏè=ß1 >”n.>Ü“p?N$?2}>¯Ò>•ž?%t.?HÏè>ÌH¶>m”>­,>Î?NqL?lÿú?:Þ¤?MÈ?ÆD?Ð?)g3?!IL? Ó?Qs?^v‹?l?ø?l"=­30>{(>Ú?5Ä?DÞ’?%Œ}>S“à>4»x>´Ø>•‘B>ÕÌ?TÛ>£ö¾>ö¬>Âh>Ðév?ݼ?+°>¬æ˜?7J?\SF?Žr>¢uH>¿Áø>ÓZP?â’?Â0>ÿ=l? +¤ê?;ÂÀ?Väu?T ˜?Ú‹>èsˆ?/€>ÉÚj>Õ+?4WR?Ga¨?$_†>èÂÀ?…Ò>ùçh?Ð`>Û“˜??B? ˆ>¡z>ü>ÌÏÔ>ÏQl?0¨û?;µ/>š›ô>Ùè?&ëý?—?E>¯s$>é¢?#¶(?N7?$.>O„ô> ÿŒ?‹F?1OÊ>²b>ý‡?GDÚ?Nú¸>¨v˜>›#4>½[Æ=g²À<ê‘€>O‚>V¯ ={J >ã£0?8‡2>É6ü=¸{€>þîÂ?#K¤>©®º?(:D?Jâ-?3`3?W^ö>à¬T>úÇd?·Î>–>É>€X>¨aÒ?6ù?L°l?Ö(>Ö@N>Ÿ56>…Ð?ƒ?1¬’?2\Ä>ùtü?>@?8Z>ÁÄŒ>¥Æº?¶?=K’?h£?g8?˜®? _Ì>Ò,à>¨|Ø>©Ö?á??ê&>>èc`?k‰y>ôãà>T>”·?$Hõ?d*Ë??>]>ði¼?vÓÔ?5N>¬ZT>öa¤>ÝǤ>¡Zø>wU >ÀŠ ?‡Œ?^8]?]þ½?WEz?L®ê? q¸>Ó6*>¢¬>ÊŠ^?M _?f?9Œ2?›Ç>‹@>FP>¼÷ð? +ü@>Ó$4>·Ì>µ€ê?óú?x÷A?N§?%Ï&>ÐdT>–P¾? r?TŽp>ä° >È>¾>°k >³®?3cŠ?Q™>Q²p>‡ü”?<×í?/þ‚>`†H>¨Ãô>ÀFH?0ù?"yŠ>(ô>¶;ü>¿Mh>¿Z¶?!ì?:“f>³Ô>ÙÁ¢?Uƒ4?’«>sèœ? ü¦?]?õ×>ê²>IaÌ>ÄÍÔ>_eh>ä¾Â?E‘ø>²â>t€ ?8¯¸? ·<>ì×?²Ç?Ë?Æ>À/¼?sï>÷#¬>Ÿ<?/xø?9ç¯>èPX>¬ä>—nª>Å D>¹zâ>Pý”>«8>’X>§SÔ?C=n>ÝNæ>ÿp>÷7ˆ<À@>Ð>ä>ÐÉB=½9P={>àr¨?^>ó ={Ià=N >òp(?Pà»?4d2>Ü1,>Ž Ì?0è?zìð?7{,?%º?*ìð?5ÌT?9IZ>£5f?¼Æ?j™>õ­È>%a=àh>  +D?3̦?l'r?j3ú?UÂ? +|ô>Êà?qN>¾\>ø?X?$>»f">§–À>¥ >¼ë^>æ!*>á3¶>÷„>ÉË6>ÿÔj?6E>|~x=Vë`>és„?_~Ü?KB¦?>*·>ø´p=à5Ð>k„>¨Œ?)i¦?»´>ž|?HŠ?Bê?G Ô>ÊÜT<¯.@>V{x>Ï d?5 Ê?N»ë?!†h?Z`#?¥û>[Ë>,B >%W¤?çø?›>¸8>­Ä>à?ë¨?BgÍ?9¹ ?'Š?®à>ç|>%*€>¹— >ÁS>¡£¨?‚O>ÿoX=˜P>ʹF?"1>|(P>-*Œ?"ñ>ôj¼¼VW>À‚ ?]ð>þ_~>Åäœ>ÌŠ(>‘\>Æã?Û?Æš?omt>ï•°>¨ç”?6Ni?I?7j>üÕT>Õ@¬? ÷?|î>¯>²?+Îi>ë\<‘¼€? l¨? +óÍ>»Í<>¼Ãü>Ó`,?'Û?" À?(õÇ?$÷?JWŽ>ßi<>üä>Þ?°Ï>ü·ø>½ÚP>â{(>ó~”>ö¼? ¸F>ðsô>ÌÒ>÷«¸>êXH>r,>E,?M ?ÏŸ?ÿ?/ËÎ?»Â>ÑL>ÐKP?ZB?>±?¹R>|`>…{Ä=þ»Ð>™œ?T½?t’>å¾È>^£x>-A¤>Ënø>Ë(L>M¿X? .p?`”¨?Q,?@Aü?;KŠ?«?y*?D}ž?MŽJ>äyZ>¾ ?«Ì?cE“?®>s) >M­ >Ü’’?aKù?V/5?!Jv>¼2?;V?c±î>ÝWò>žû4?"‹¤>ûó>EèP>ÌÀ?>šI?ƒP>é?šÅª>“Óâ>Öl>§ct?‹Ö?*«>x–>Å&\?+ +a?D>³…¼>\ØÔ>ý0?0“2>ò.˜>vi0>hŽ>½Ðº?HÎ?q†É? ñ÷>ÚZ>ûUz?'úì>»•¸>_ ?Mm?S°»? ¢4>ïÐ?ô¨>Œý$=½G?ÆL? ‘µ>˜±T?2ô´?l“?]f>c¸ >—èÖD>nuè>˜Ñ>—qÌ?‡Á>ä&h>ÉþJ?,RT?D,´? Ä?&]¯?VÒ>Áë@>ñ•(?¼ý? êø>þ­x?xâ>úI=ù=½€€=3€>—ÝT>ƒÊ–=«ÊÐ>öâì?b…Ê?RÛ>‹ã>öQ˜>` >Úõ°?;1Î?Gf>ŽÂ²? c@?sç‡?CsW?5‚>×Ñô>LÉp?Ï€>®ö =JÏ`>•¬?BÔ?6.š>¦ >ߦ\>õé>”“f>s³X>"Â8<èR>%ô?(*~?‚ ? ì?—ã?i†>–æä>õ>çfè?,’ä?YþM>ÆNv>h7Ü?ÑR?XŒ)?OZ>î|>ð;Æ>ÆsV>Ô>¯Ã`>ð.ì>æêà>–—ª=§]@?IÀ? _(>Ó_T??Î??Ýr?>Iˆ>Ú1Â? ²´?¤>srX>ú:´?ÃÍ?"9L?E^?Rz?@pÅ?86D?Fb>¸Ûà>o? û¾?gx(?P©V?EP4?%¹>§çX? Pu?8æ> =•ö0=ºj@>Là?’Ù?FÎ?$^'?+¿Z>Kd?®£?Áè?¶Õ>³oä>·BÊ>³â>´ÒX>Àœ>ƼÜ>)6Ô>aV>§UV?Û@?Q >Ùx >Œßb>kÎ?X?W™m?i ? ˜2>ÎÚ>×;ä>¿è?!Ç?)&A?2¯ó>ðYp?ãP?ð,>ÆC*?»ì? ¸á>ÙBü>•©¸>éi„>ˆÔ`>Mux>ñ ¤>ÇA°? Ú?Kô?ÆÚ?24\?P»?v†?ý•?_»?Wáò?5‹Í?_±ß?®©>‹+Î?>Þæ¶>|âØ?'žW?ï>dnp>ߺ>™9‚>ÉŽ? ¦>ƒÍ¼>2_P?*?ckA?<—n?G€0?-á?^€? +¯´>¶Èd>ÀOn?ÌL?/•>Öòt>‚’Ö?Á–?!H`?Ay ? h>çÜ>È,>Ž_0>¹Xü? Cí?«Š;ƒ5>°Ð?óÅ?;È?CÅÝ?<ñí?jû(?Ø>[¿ì>¹Èj?+Ô?Ö?º`?bX?g¦g?VM4?†Ž>ÿ+T?2V0?B>¬Ü> öÀ=Qã€>œ†ª>×f¬?#¹?KÀC?'{:?1Í(?eÔ?#§>©¹ø>ì—X?$Õ >ÇÛ&>Å‘°?C?4{‡?4q•?HZñ?Té˜?Jb?/\?šæ=‰PÐ>ë£h>íç>•|~>­º=§þ`=Lú >ÀâÔ?;ÿñ>á©$>™<î>ºH4>}>Òü>Ð^|=Ô>À´$?9Mš?Zª >ÿß=hš@? p?DF>ñP?'@ú?e´?=ŒÍ>ÚЮ?éï?h%Ž?#Çö>×Ì >̓ª>°îÜ>¿%Ò>¬Â>7À>§$>Ì4Ê?i?qõ¦>ÿ•h>²í~?<8S?[T\?sUÔ?&Î>vÎ>ì*>ØšÀ=Á÷À>E (?.?=Â?@"–?WIÅ?në¾?(|Ä>“ó~?RÆ>ãå=8_`>ú£Ö?l º?'»¸>àrT?&åÊ>Áxz>yôà?*’Ä?sÌ>¬‰0? ·?1Á?Ž¦>~fì>n׈>ÀšJ>VÚ=¼è€>¦²??8Z?i˜‚?²??¨?a1Ä>Þ¥:>Ðn?0É„>±Òd>÷Ù€?Zµú? ÁÃ>»‚¢?;íU?[­)?Wô>õ°è>· p>ì±> ²¸>ÕI´?QYÄ?U1? ­ä>¶ÈL>ÊU¼>òp?)ö?£b?V†?3žÚ>†¥2>òë>?>`Ç? +Ÿ?/e?:D>úé:>iɘ>ü¥¼?ëì> h>ì<>À*„>õÐÄ?fØ?lª?$üD>®Þ>ú2Š>É„ô>µãŽ>Â{t>Ä?&°? ÆÇ? ûf?TZ8?NÞJ?c&?Si? eø?KÔm?xç~>ôÀ>˜ÇL>¬·¾=‰ü€>¦? ?<û6? Bp>†ó">©Þô>ºH$?ø«??$P>Í}t=­ >¹Kš>²>¹sÈ?MGâ?Dà>¤[Ô>Û×L>Ê…> Ô¬?è>°¦D?W?&•?3§u? >ë<ô?-×?o’³?NQu?*Éb?R±¦?vS ?]C >ÏYX>üD(?Ãè?ãÀ?â­>©1à>Ò¦‚?$?>ü >ãв>^ïà=›| = ²p>Ö*>šð= × >´n?¡š>¼}f>´ü‚>–`®>IÿT>¥?Ô>˜ø¤>Ÿ ð>´AŒ?4>Ê„?Í.? +àÀ>°?#Ž?)JR>óÐ ?‚¯?]/?#”˜?l¨?J?27c?'U‡>øåø>ZP>‡¢n? +ÕJ?&aw>ãNà?üj?K}G?Nº>#͈>‰L°>ó›r>PD<&ç€?ôÐ?ãŒ>âIˆ>ïÁ>)Ý(>ÌË?.¯¾?;˜>fÛ=«=阀>1rø>Éè?<2C?Eé˜? @â>‰x>î>p?ÃH>g¾€=LJð>ŠNŒ>»@ü>SØ=e€=—y>4?†Ò?¶ >Ph??&z?n¿y?lUÓ?Heº?‹>ðó?ææ?~?ý2>ý¾‚=hOà>ô_?'ï4?+ÿ=?h?4ñ?/·?ZÐü>èÈ–>«|Ø?F}¢?j.†?€ö\?ÔÏ=}' >‹P>dߘ>Þʘ>Ôš>Ð^ ?!ì>cÝ>€Îþ?µ>¯ >.Z(>·Sl?$*H?`ŠÆ?1S?›R?çŒ? +¡­>³?„?$© ?Òà?ÑÜ?OË?fÐ>ÂV0>дˆ>Íè>~…> Œ8>›%ô?8eú?LÞ?K²:>ÌE€>5%P>°$>ü‰?\Œ”?(ª?§Ì?õÒ>¬¨?'(?@ >žP¨> ´>GïL>µzl>Ãœ>•Óh>àC€>ž>Ôºø?5kn?!ö>¶¬>ÃbZ>Ùï>¬wl>¬´Ø?yi>Ѳ >žá>È4|>™w"?&Tc?Qp ?´â>ãa?&ÓA?Ê>?$?[–E?Yóÿ?[Ù?3î>ò”?›ø>z`>[GD>èÁ”>ùÊØ?Å:?ê>•^ü>K-P>žÿÈ? ¹ð?<“¼?]ø•?B.N>Ï þ=£Ñ0>Pq>)±œ><Žð?1c?>.Õð?,T?5›?5„?X›å?1(*?5Ph?¼>œ¯È>¼­Ì?3p8?çl?£ö?U™þ?m®?bA?]Së?^’„?4k±?Ñ?##|?5·ž>Ù×r? +°ä?]ÏÄ?40? Î×?%ïl?1/T?N¥?ÓT?Šº>€4=¶Fð>¸ê>Èíü>ªC6>€>¶=6îà>{1>jØX>µ/$?[Ì?hTD?l˜j?LÜ?Jã"?SŤ>Ù>Ö>Q¤>dWà?9†?lAJ?nÉÍ?$|Û?% >üñ>íœæ>xñH>¾ûZ=¼7@?;™?,‘ö?äš>ÃU„>‚În>Á]¶>!‡œ>¥?°?ÞÖ>­Zd>K]0?Uq?N5¼>ãbª=õ½Ð>ú'à?O:>Û‰ì>ŸÁ?/ü>ÞÕà>< ,?d >ü¿n>_ëp?+10?B;??Mûf?/H>³­N>¶˜¦?Þ?dÖ?É®? Ò›?¸¿>û€R?L·@?Òh?V:?+è?Oì^?¡ü? æ>ïDR>¿p>¸×Ž=°¦€>ÈŠ?Ë?CKt?.¸>·Ç€?.nX?4¹J>Á5Ü?Ð? +^?.ü?K.>Àªè>„ÚÄ>¼éü>€œ>Ú2>ÌÈ>>3Œ?éî?"®?ù~?Rçk?‚œ>Ó]Ž>àpˆ>ßzÜ>Óž¬?5 ü>ô4Ð=øl°>ËÈx?}_?Dg?*Í?j;?qò=Ót@>­>ŽÀ>Þ+t>rUô=MM =Å +€>Ëãà?1$f? V*>ñbð>ö—H>ÄßWþ?(^?-–l?:U?jè£?'˜?c ?P=Ú?^ +¶?Äá>õ¿¤?MÆ2?F?-e¶?3à? Ú>Î(>šL>óüŒ>Ð?2­°?,´–?(´?ê?Ã?zÎ>°ŒÄ?l>úÿ? …ü?Zç?¯8?¯È?Llš?-õl?!`>ŠV¼>·$>Ƴª>Ï×*?[׌?„G>úüR?¹º>¦vP?ŽV?=8æ>ù¢x>Ù¾? ´>ö8?°ò?EÙÅ?!³ >¼v€>ï^>ðFt>Ýâ>g¯Ô>OzØ>þ¾ð?V›ƒ?S6ð>݇h>@óœ>‰¿,>·r>ÌÞ$?¨Î?\…„>ÛÀÐ>S¤˜>þrl?- R?On>ÄÎ>Ä>aOH?²Ì?ì>ŸX=9|>íŸ^?Nrû>Þî–=þô@? sf?=åV>–’X?_?,¡©?| >ât,>¶0°?ç?.z›?F>»0>äóð?x?!Œ„?*[2>ÿßn?î~? :V?2˜¥?r\?F{®?V/¹?gµ¾?Ll?ÝÄ>ü1ˆ?-d?¦þ>Õp>çUÈ?6¥>3E >»ð„?P}B?p«â? p”> (> 3ð>ÖÕ®>ˆ2>\>¡2t>õœ8>а? ?›¼?+£? 5²?j?U׈??Eä?>š^?Wh¸?7)>ÌŠæ?`??¦’? 2n>x’\>æO@??WÈ>ØÐœ?°Í>÷Îl=»¢€? ¢?Cy=?•™?:¹"?x0?.K>Ý­,>šgô>t´Ä>J >M`ä>Ä&>y,l>Œ ?+Ñ?S>Ë_–?ú¿?€t> d”> +h¸>•>’ɘ>¦€F>ï£`> ?§?\7ª?VUL>´íT>Èã?÷V? ™–?"Q`>×.‚>ì`?=ˆ?C]Å?Ð`?-Ñp?&?6*?8dð?*Þû?X: ?XIJ?u¬v? ¨X>V1p?¿N>ÎÓ6>åæÎ>¦žD>à®L?€D>szô>æ=`?iR>OJ0>×þ¼>øIx=ŠŒð>­´ ?1>ŒrŒ>+´0?ÕT>ôºV>û¢?j¿>õ'j>*¨4>Ð>ëc¸?7ÐÚ?Ô<îZ>R±> À>)q`>Á)0>¤¨^>Œâd? v>Äã€?#ñ?e³¨?n%?xd? &>øåX>Öùˆ>Ò?*p9?ˆ˜?4’ö?)>²s>çðN?N1?L9|?J®>Ьà?R¡þ?xú>ÍíP>ÃJ +='k@>§mô?:T?(É?8¡6?502?E:|?oì?2Äb>qcÐ>­aØ?>ÊEX>x1L>'À>2sØ>ˆ^º?zð>ÿ ¬>Üûv?SøÊ>îΰ>Ç®Þ?IHh? èÒ?#-f?\í>î]0?ÊÎ?$¨ >ÊÄØ>«;Ì?æF?No$?ñ>½?ª?,þ´?v7R?+>>&½ø>¹h>Ü}Z=¯” ?,†?oÃ?ÍŽ?Rm?,u–?\k)?lÆ>Ñe>õ,¨?R>š.´?Çþ?@+1>ëúx?³ü?3B>í’Ü?X’B?¨¼>ø?•\>U°>–^¼>Ÿ;–=Vpà? +î¤?2à>^ç´=Þè >€9ì>£¡>Ô‡b>ÿ`>©Å(=ðÇp>»F?”Ó>ÃÈÌ>ô¯?3‰&?P;T>Æ«„>Þ7Ê?ë >Ñ"<>Êd>µ€ì>½$L>Ps> ˆp>Ö ®? +a>ëü‚?6ý?¿ >ñG˜?FŒµ??ÉF?Q—?H%_?fY­>â>>&È?)‡Ž?K°¼>“ê>·U,>ÖBl? N6?_žr>ó>ôÒb?J4™?TÎÎ?>nx?˜Œ?Q\N?í5>^™ü?) H?Ê$>ËU?0–>ê[(>Ž¹$>—|¸>cÝè>îëP>Äþ,>SvØ>Ó©†?,;">Û²Ì>oWŒ?(VÂ?Ë0?18?3(n>ï°>™án>c¸ì>íÎ,? +À>£"Â>}J°>„,? F>ç´<Öy€>_uˆ>Þæî>‘íð>×ÇD?HÐT? +$*>KÊÄ?å÷?D¨?3?G‚‘>Õ‚ü?ˆ$?Oƒ…>Õ­>ºžD>Ϲ?À¤?WLÀ?}î>Çsà>$Nø>æ9Ü? +Z[?—}?f+a?Vï?2T>•ð¸=²þ`?Æ@? ª=ßР>÷˜œ?e ô?Mö7>ܲ >åUâ> Ù>¦Í¬?)µï>Ì<>|;ð>Ú7´?n8>ûÎÌ>ðø>–é4?S2>¬ëˆ>0Ÿ€? €?@¼¢?gª?!«…?5ߌ?n±Ú?mVp?ÞZp>ÃÒÌ?6ã ?'a$>²Pø>ê½?Kæž?ygZ?:±n?.cv?æð>Å£>øT?4Ä?3)v>§H„?¯p?Mâp?=ß2?6?š>û5Ì?ÿÎ?Ø)>g¯>Æðà?I{>É‹â>\bÈ>>ëÈ>v? ¼ç?Üè>ªôn?6¦>âOÌ>#ùh?)?X|±?–<>S!”>þs¬?³/>• ¸?$Žˆ?+€>WA¨>”Ø>ð>vq\=Ï$à=Ö5>V¥ÄÈ>Ÿnè?i’>ÿ¾(?!Sž?ObT?þV>€Ø´>@@Ø>ØŒ>¶×¾> 8>âŽ@?“Ì> P4? +ön?€>ÎBä?Râ\?C!x?´?<ºt>öìÒ?BF?HÜl?ÐÆ?EùÄ?h ?6->þ^b?&0?ªÒ>EÂà>êüÀ?Ft?•«?Iël?~º>ŽH>S\(?Ûç? +¨Ý?ðò>õ³˜>Ý»h?/µº?;‚"?nÌ>ûp¢>«ç˜?;›7?â"?m6?XA?sü“>ø^ì>±U`?+r?*“ß?;¥?'ü‘?60ë>夠>@°h>]™Ø<‘7>Χš?ÿi? +žT?*MD>¸w,>éª?µ„>º©>©ü>€€P>êìÖ?ý~>ý-¨?1,V?OT~?UBÐ?¯p?å?PÀ>܆>«ƒ >ÞÂ>Ù)à?˜?!@Ž?6ˆ?@Ük?@c>¾²>b÷˜>„²(>$è>6Tä?'þ°?ÿ‹>÷i?M¾é?I=Z?vÌ¿?/a´>Âz>Œ9@?R"?"¸E?û|?Yà!?gñ?]b?VÜ,?:º?!P?IŠ>áè¬?GÈ?4»ù>ˆt>d-h>Ùw„?,ñ‰? +–•>HÇ ?žø?F€g?Bˆ>ç +œ?1K>ò9,>Z¼ =Ì?à>­ål>†Gr<’“€>•‚>Ò&p?˶?oî~?" M>ɬ8>æ˜@?2Äù?7²>íÕ? µæ>ÏÆ>Æp>Ñ>™ð>뺨?G?.«?=e?#åä>¤Ú>ó¼?-²>Ðä>T>ó1?tä>å†>Èô>d(è>2|ð>©u¸>ãTè>ü³¤?Q&¶?<Q>‡”>QÓ>Ù=´?F?TfÙ?Ö“>chÐ>2è>¸õä>©·ð>œ©‚?»å?5¾?Ex¬?=‘ˆ?!¶’?D5>é%(>Q‹È?î?:`Â?Fa?Q?4?$"e>‹oØ>€‡ê>º„?Ûx??NP?0$?Ué?@>M×=£I@>üÆ>Â{,>¸ÇÐ?(|?{ ?Q€?¹œ>Ç4à>>ƒ4?Û–?$ ?&yX?u+˜?94>β>ÕŠ>ßx:?>¶‹?@?>Ô¨’>|ã¸>œÊÔ?,z?*© ?+…@?7í?®€?³Ä?$?†?*¬n>ë…î>ÿݨ?Ñ,>ðͨ>æÅ>U{x>¿p=ú>Ëà(>¸c´>zÃP?†>°m>•ˆ> M´>m¼Ü?=á–?@ôÁ?©Â>Á$<>ö‹>ëù\>Š±v>ðØ>ÿˆ¤??Û?dñd?´Ç>•ôø?5ÿ?1Ô9>†Æz>ãL?P“ü?IÂY?÷Ë?.Î?e“>þYH>~’¬>Ùðd>½õœ?)cñ?6wÄ?CÞL?ÿš? +C&?&\d> +˜t>­ÅÞ>Õ¤>5Ã\>¡Eô>Â>À>b½x=̯À<–ó>,Ï>æÚ¤>Öè?!Tx?J›:?.°l?@âà?î¢>çO8?rÞ?a?(L??Ñ?W?'ûì?M÷N?g|÷?&ý?#BÐ?f®??2?H ?:¸?A¯¾>©Çt>h…Ô?=P?ùM>à_,?J1þ?Hâ?ÅT?S·?‘î>£r@?!æ>ð©8>Ç>ä?ê?§·?.íî>Îc”>vx`?²7>ÀW<=ÿí>»¼? ó?=s>úÆè>”aŽ>>U8>þ´~? >œl>h`>æ¡Ô?2>Ž?"%•?1‚? >ˆp$>gfˆ>Þ¶ì>ÆÀ +>ö9Ü>îÖš?5±?ø€¼½å>³ž?XŽØ?>8]8>‹êH?Þ²? ·\?W2?:ÿ?!±ã>ì?}Â?' \>ÔâŒ>+¨>w?#~?Xª?!Qí?¾ò?Cú?UR(?2øI>Ôµx?ÓŠ?I™Ê?MB!?sÖm?ñŠ>ah>Ò²>»ª>š:¼?:ö? Ôz? [ü?FY$? *y>ù[¸?®^>ûˆ´>áÕ ?ÇÀ?_áK?(kÛ>ÕÞd>_Íp? œd?Dh*>ò"R?A;?3~«?Mj¶?qÚj?$m>J„@=ñÖ>à ´>¾À>è?ô?K.->ÄlÄ>¿0>¸­X?"x?í®?5dv?kØ?V'(>áÁÖ>Q”`>ÿœ>¯J>su°>¢DÜ?2v? ¬F>¾´’?6Î?·>ðy¬?D_¸?Êî?³ê?Wª ?j¾>º%Ø>¿4>¢*È?¿¬? —>G9Œ>ðçŒ?FB?z¸?Mÿú>õŒ¬>Ðu >²Ô>zNÔ?5®Ý?£º>ä>:à>á d>ñ >™%?QÀ?G=>¤_6>¦ž@>ö4X>y8,>ÎÃØ>®ñ°>’Ü?9¶`?Íø>®PÈ>‹àF>=Ï>¨ü0>ÍSè>•2> +Ó`>òÝÂ?Kºv?fSþ? ¤H>Æ…ä>ÿv>þ^?3”À??]Ž>ú!>ï†?O9 ?iw?IøÌ>÷Ìø>>H= >ZžØ>‹_Ø?m8?QŒl>¬D>3Q8>®¤ˆ? Ö?8[?#hm?.ã?T«¯?âÒ?Æ€?…Þ>V >Åtè?J)?€¿)?L(2?¾Ì? ›Ð>‘B¨=ÒD€>»ßà?2q0?CŒL@=;Ô@>—Òh>ìk ?Ï´?f ?$él?æ?Gh¦?T1?0>J?/£?(QŠ?\$k? y†?©Â>Ý\”>ªr˜> À?+½?U‹€?Nbö?*ú?Š2?ñö?* +I?C'ˆ?â?M>>öÀ?Ô?D%â?"h?¿L>¡©Ê?(Ì–? gÞ?Râ?N¦Ý>“<>ë??TXd?mæþ?Ê”>îq8?IK8?Jc‘?W²;?Iñ >Ë“â>5H>Œ¦,?ªj>óBô>û¾®>ÿ&Œ>Þ$>óôì>Õ”Ä?R¨Àçð>i|è>ÓÌ? 9¿>çHð?.öm?¡4>ÌÐ>ÐëÐ? ár>ø¤ö>=Ú?X?Ê‚>Réð>dØ>-P?óx?%Wð>ä‚?*Q‚?L*?O„,?n ?¨çô? $?5Çn>ô—ü>eãä=¼° =+è ?šÜ?G÷Å?Hp?CB?0R?V,\?bR2?D;ö?;r²?>‚>íN? 3<>¡¼`>3°>ÕîL?NP¾?Ð>‚«l>Èðd>Žå>ç­n?Ra?Pðˆ?+ä>Ðé°?´?@j>ÒÜ>¨(,>¶¾P?®>Ö§À?2(,?ë>ø•0?Ì.>¶å„>Ô¶>×£j? ð>³2? J?LeP?^“? >§KŽ>æ`?ö?h>œ„8>À!|??¬? 7P?:?x?I.Æ?Mo‰?ù^>ý ¼?"€¬>|„>˜n >¼äÖ>³ôö>Ùn>k,À>£™Ì>’cÔ> Úz>¾¤>Þ÷Œ?Û?(þ?5È(?8Ú?j`Ü?vn'?=;Ü>ñP´?ób?$a€>ÀÞ?ã˜>ìN>ÙþÚ?!3N>^C>³bÄ? Ú>ð^x?-\?<ê6?#~S?M)5?¢>Ò¤À?x?&yX?>Hx?j ?FêZ?±>Ð h?£>»§h>fþ˜>€%P>šÄ>ñ@Ê?3R?lìí?&,>WØ>©.ˆ?@0?QÐg?Na†>ÖáX>kUØ?²b?¤_?#y…?7ï>òKÊ>Þ,¶>¶=ô>îÈ<>Ê“À>Š•&>èåŒ?5>ìõ$>ûx€>šÉ½”h?%?jà=Ÿdð?Áœ?:¿F>óŽ|>ÐhÄ>Z*>²z²>m>ëX?÷z?Y}>㸘>pœä?’? £>ûž’?¥—?)Tß>ò0¾>â $?.ï>¦òš>3ªø>'4=Ia@?Î +>ìfv>Ùml?qä? ½,>ß—X=Œ‹ð=¤Ö>ÈÔÆ? ¢#>§rà>±+h?Í4>ë°ð>ãE,?ŠŒ>Ë“Ö?¢,?ž&>þÜ>£<Ì>©/Ä>Ù¼d>Y¦?"¡Z?uÈ?gY?yh?>Îln>Ö1p>ìgj>ŠlÊ?aï?jWR?mÙ[?iê®>éú>Û`>˜’?l+?\>Ç•˜?8î^>ÄÉ°?Ø?uŠ?->Þ¼ˆ>¹Š¨>™T?>°?# E? +a>÷µ¤?PT?o‹Ü?í|>»T? _õ?³q>Aù°>’Ø?4ßz?[ i>ãdÈ>mð°>¦Pü>Ýœ?ÿq?ï >BÑ0>è¸L?#»>ÈDü>ô|>ÆCÔ>×OH?+š@>ÝâJ>[?t=,w>Št>ÑEÜ?9í?• >mCü>±5? ¼>‡ÿh=fð>ß Œ?HBˆ?Bî>ñÖ>¦Óà>¡ë>(~à?yw?;–>Äj´>Nœ`>÷3Ü?UQ¤>â{>õæ†?2ªS? +h ?*µ?j<Â?W×£? Õ0>O,ì>Nü?³Â>¢ÿD>ýÉ>?I ¸?F·>ªÄ >Ÿ>õ—„>ýÃl>»±>ÍÔ¦>¤½Z>/IH>­¦|>ê»´>©òd?(i?DÖ”?1‰?"N>ÛÜ?*cé?`7?)þÏ?>©:>²hÔ>¬e>?*Ò{?>},?#>b?;é«?¶ù>y;|>óàÆ?Zâ?ÇÛ>¡ €?Fà?À?+‰Y?8t_?PHŸ?nQÄ?­Ð>ߟä?L´?€J?¸š?WHÛ?4V? kÙ>ºs2>Y‘ >í6?wŠ?@@(?Áè>ê,´?<‘¢?8ËF?GW?K¶°?U³ï?QJ•?Gt’>¤j„?Ñç?I ‚>í½h?7œ¸?7¡:>¾Ü¼?®ø>ê­N>î?MFÐ?@BÔ>Â|>ƒHì>¤4˜>bØ= †`>P>>ê†Ð>šä(>Í À?K%™?'Fº>sž¨>ž|®>Ñ+4>½Ì€>êÀ¬>¹Ï>ãT¤?âW?<­g?´>>Ú >ßhÜ?2E>üØ> ´>Ú +8? Ó?¯5?CÔ?æ8>Õ ˆ? Úú?¿×? +n>û[:?>T,? ?¦©?tÛL?cÝ¿?0€Š>¶ðÈ>ÆùN>¦Yº>1LP?ÎÈ?p¼U? +¶Ý>µu’>Õø>½>d>ñà@>Â3€>PÌt=@=À>…¤V>°xH=›šÐ>ýŽ?rù?a\«?&>­0þ>Ñð>ºU†>›Š<>ŽmB> +‹Ø>ù½?!A>ËO>–e†>ëL>Ã68>Ëd>¿h‚? •6?Bmj?.cŒ>ÛnP=­Åð>H P>!$€?â?Só?8Ü?QÔ +?l?M):?7‘`?¤ª>T‘¬>ÿI˜?)€>Œ­2>ˆ:T?ÓS?i>=P>Òc<>úå¦>UÚ >öKÊ?,­.?'ªÌ>ÊËR>£ ¬>à_l?$Û¤?-O >P/>M >0Õà=cà?^?BÔ>š$=y–à> A8>„ŠÈ>®sÔ?638?1Ë>NcD=úêø>‹˜8>>‘ä>†è"?8÷Ä?D"?%O¼?(Tà?C?· >¬ò>Σ¸>Õð?ìE?Z"x?6´">çt>Ц?eb>ËC"?4@?M„à?]gž?]Ê…?>F>njð?(¤?_>?æT>¤“t>§ô?3î>¡´">Ò¨?Í>ZÉ8? Z?0t\>o~ø?*?ÿÄ>ÀD°?ü?JXh?`Û#?ie?a‘`>ê >±,n>µü>˜%?àh?Dë»?o0#>üöì>[¢Ô?%BØ?W¾Þ?)ëN>·ÅÄ>ýžÔ?# +á>¸^¬>´¼(>Èþ”>Š‹è=ól =S@>.ǘ>™Mô? gC?.n`?5Í??§=þ@>ÆuÞ? +Y´?J.?9õ3?0óD>Ípx>ðä$?2…Ö>ôì2>‚õ@>µb¸?A(T>üü=d–€6X>Ajh>ů\??d ?CNW?6U)>®?*6?Ì>{o$? j(>üMP>€|>‹æ^>¢=x>V>ïóˆ?\w¨? a—>7 > E?-T”?¬=¦|>3ø?²q?W×’>½š=áÐ>Òb¸? _?7‚K?¯O? +Ÿ«?lžî>â¬0>ò° ?pqâ?itu?R~>£.Þ>ëq®>¶u>ÚÇ2>ÞFF? hÕ?¤c>~Uà>ën?88@?.´Ä>Å] > Xì?†D>Ù=|>ñ=ª?U¿e?/‰®? +ãÂ>ðQ¬>àP?OÁ~?Y¨’>úHp>½n,?Âä?Hܘ>çÆ?ÉF?FžO>™GÈ>v´ì>}î>P?À>§åŽ?‘?Qr?d? ¢‚>âö0>nÅX?3Ê?\j$?EzÓ>ó@œ>»¹*>ô:Z>HnÌ>ÓŨ>úW$>š>ƒÔ? +f?c°¾?GÔŠ?©?/2þ?S?§?Z„>¼ì=é`>Î ?%…R>ª;d>‘˜>Ïr<>Xk =°µÐ>j>!g°>L ?!`?aû>mLØ?ÑÈ?%1Ã?@1L?IKÕ>éÐ?+Ѫ?&ó¥>;oè>?H>–6Ü>Nˆð?O?D«b>ÍKü>:^ >V_€>áT?i>È«??)’@>p›>Ž (>ù†(>ÉäL>’> ??.-î? +?}ô>‚~>æäˆ>ðt¶>‚«??Š?î“? +Ü$?K$+?;o&>ä[à>ÔÌ?'+«>ÜÎ>é??_zQ?vNÓ?;t?¸ê?@²ˆ?H|V?`>½30>õÓœ?,‹>”9¬>®8>€(>Ï_L? é”?…X?=õd?7Ä?Fäª?;‡ ?5¢?H?`Á¾?Xz?Dœœ>Åá†>6(>ob@>A¸>WRÈ?2?>å>XOø>|,?g‹?:æâ?¹x?,6`>òþ>îhÒ>ô¶=¸Ð>óQÆ?Sà? i%?Nš?aû|? —®>Q >À˜?º¥> b$?úø? Â?q¿?|Ô?2 [?´*?a?Bª?$…?ºM?…=?.{H>Ñ>5>ðIü>ÁZT=&à=]À>¼äŒ?7 +? Ö>âSÔ=xÂ@?À>ðñl>"¬À>½õä>bT$>kH?Hò?S'j? ±b>ÇB†?@V ??Ù>î[¨>­¤4>à(À?=Æ|?hx>¿X>Íæl>†šL>¡n>Ã=˜?Öì?-ÿ?ÔÜ?kÅ?>Ü%?AÅ>°ñÖ>¹ðÃ\?ç\?9”F>ÇóÆ?bp?â?Ç;?(A>¯sD>ÿÍš?d>Ç«p>¥„˜>ÂH>”>t>mà?5í?]Í?D°r>â—Ò>¦/V>ð·ê>Æ•?tw?`€?m+Õ? ð:>“…Œ>ã:ö>§òÜ>Øfn?è¬?#”ˆ?(m‹>æ:l?(³Ê?4vq?6è”?j< +>ᢖ>¢â? ž?>þ*F>éºÈ?41Ð?8ŠÌ?&/î>ªT¤>Ò>겸>F»È? ?4>Ø l>ï >>…þð?ÛJ?c¨ ?Gi>½[T?·€?åÚ>‘>P>·á?¥?8Ð>¯ÃÊ?F@\?êM>cú >Ä.¸>ÊxF?a+>Ëc¤? ×?Pµ? óµ>ü§²>Ä‘ ? cb?Rn(?E*®? ÛO?‡œ>ööè>¸hº?U®?$4Ê?qNñ?µh?+×?rÒÖ?ôµ=]y@>•m?q?&#Ø?$/>ãþŒ?™r??áP>úEö>šø>Ñýv>’.Z>ê™>ð>•¡D>1•Ø>½¨?À?\9P?.ÁÉ>]*X>mrh?ÊÂ?Ô)>ïWÔ>ÜÖÄ>âøL?È5ä>7ìè>_Æ >>í ?‘8?8±>wF>`4€?5a>çÎT>¦½p?9dN?›æ?VC?Pve?Vª¤? >Ä!Ì?+A`?;Ç?!½#?g„?*ì?Fmé?t7i>ûp$>(U˜>Úœ>³”D> ˆø?{2?Áœ>ºb?6u>?¿a>ʆ?[Œ>P<>¤8?(¾>·6d>6h¸>õdL?Eàz? $>jp>*:0>Bè>ž]ä>ƽV>Þ^b>Ã^\?¿î?"ÃÐ?#»í?~5>Œ‘Ø>ΗÜ>èi€>Äq(>½F>§t>?&¦?TÊì>Îu=É@>­¨?›Ì>Î5|>£J$? +ûº>ч? 3?!™ú>fh>›B€?@δ?-·¤>‡F¬>ìà?-ÚL?03m?T,”>ïfÌ>°Ûø>Š€$>…8f?f?8n?PéZ?=|>ðªÄ>sÁ>p¶¼>(>ïë ?…*>™IŠ?‘D?@؇?RØ?û8?2íd>¡Ò|> Ž?X?Cù> +ïÜ>‰MX>ru€>‰î>¥þP>ÎOÄ?o¸?óE>œ“=ÛP0>kÎÌ>ÊgÈ?1[—?@„ö?6þ›?cb4?P|? 0?2V³?Út>—&v>‹Æ? Ý?okK?mÈp?;1@>š%ú>ÄDä?AÀ*?L Ô?Jžj?®Ÿ>¹ ¸?(ãr>éà=jœÀ>Gu>ÍO>u$>»Ñ,??ð„?!ý>{›h>Ðe²?pX?(«§?Ø>}Oh>­`?4?"²{?(µH>Ò²t>°Ð˜?¡_?,¢Û?OV¬?iÚâ?Ì÷? ‰ä>×k"=² >½ÖÀ?Mâz?U¦å>Èœ>G¯X?u?KaÓ? ¼?a¨?#Æ`>«>KÈ?i¸?nÏX?X"->±¡´»‰¯?‰’?ÿ’? +L?ûª>Î ´?:L˜?&`? ö:?bÖ¢?dˆÒ?ïÌ?P¼>ðßþ>öÈ@?b£z?;ÿ,>¤äd>­²ê? +>b?[ù>¦”>á 2? $?"°Ô>ù˜Œ>ø >ëÁ8>úaŽ>ŽW¤>" =¿À>/î8?-ª?9™@?)™@?ž>ad?ð?\7r?R»>*zÀ>Çæ>ìð8>(D°=ƒç€>Þ(?b±i?I/?@z?þ>=®™ ?sh?¿ +>Ï®Ü?]k?vìú?wUŒ?N¯H?.êB>ìf€=ß +>—™4>—ïP>ŠŠì> ç¢>'ÑÜ>÷äÖ>¹Á„>,4Ð>i`? Ϧ?C˼?4T>Âiø=¢DP>õ¯À?‡§?›€>õ_>Ž9€?g¢>ô?È>„­>î—È?Î?,ÆÐ?RŸ'?IEÛ?Y7ú?6¥©>ãš>±yÔ>ÐE8>-ƒÀ?ŠÎ?="?kÚ?>d‚?^lP?Ò»>ò\4?&Ýv>÷À>Y28=ŽOÀ?O?/v?5ƒ?!Ó?  ~?p?&˜)?–?uã ?i=??—&?Oc“?{Ûo?¾ú>íL?4Où?4n¬?>WX>úd>&l0=JwÀ(32768,1,1,1) Ta FREQ-OBSAÔæHÊ1™˜@РÀ†Z ÀRA @\HUž&GDEC @AŸ«=¤ƒÿúMichael Fanelli unknown ˜OnOff:PSWITCHON:TPWCAL Rcvr1_2 ?÷HYÀOPTI-HEL@ÍÐ2Y™òAÔæHÊ1™˜@䎼åŠk@qß9T6Yà@E á< ²Š@pæf`@…ÁÔûï?î^5@AÕ*jýìÌÍAÕ*jýìÌÍ@†Z À@Ÿ@FK5 @\33333@Ažø + Date: Thu, 10 Oct 2024 11:10:23 -0400 Subject: [PATCH 37/95] Refactor: code used to shift spectra now lives in spectra.core --- src/dysh/spectra/core.py | 118 +++++++++++++++++++++++- src/dysh/spectra/scan.py | 34 +------ src/dysh/spectra/spectrum.py | 23 +---- src/dysh/spectra/tests/test_spectrum.py | 2 +- testdata/gshift_box.fits | 2 +- 5 files changed, 125 insertions(+), 54 deletions(-) diff --git a/src/dysh/spectra/core.py b/src/dysh/spectra/core.py index a32668b0..cfb35bec 100644 --- a/src/dysh/spectra/core.py +++ b/src/dysh/spectra/core.py @@ -3,6 +3,7 @@ """ import warnings +from copy import deepcopy import astropy.units as u import numpy as np @@ -14,11 +15,12 @@ ) from astropy.modeling.fitting import LinearLSQFitter from astropy.modeling.polynomial import Chebyshev1D, Hermite1D, Legendre1D, Polynomial1D +from scipy import ndimage from specutils import SpectralRegion from specutils.fitting import fit_continuum from ..coordinates import veltofreq -from ..log import log_function_call +from ..log import log_function_call, logger from ..util import minimum_string_match, powerof2 @@ -680,3 +682,117 @@ def smooth(data, method="hanning", width=1, kernel=None, show=False): # the boundary='extend' matches GBTIDL's /edge_truncate CONVOL() method new_data = convolve(data, kernel, boundary="extend") return new_data + + +def data_ishift(y, ishift, axis=-1, remove_wrap=True, fill_value=np.nan): + """ + Shift `y` by `ishift` channels, where `ishift` is a natural number. + + Parameters + ---------- + y : array + Data to be shifted. + ishift : int + Amount to shift data by. + axis : int + Axis along which to apply the shift. + remove_wrap : bool + Replace channels that wrap around with `fill_value`. + fill_value : float + Value used to replace the data in channels that wrap around after the shift. + + Returns + ------- + new_y : array + Shifted `y`. + """ + + new_y = np.roll(y, ishift, axis=axis) + + if remove_wrap: + if ishift < 0: + new_y[ishift:] = fill_value + else: + new_y[:ishift] = fill_value + + return new_y + + +def data_fshift(y, fshift, method="fft", pad=False, window=True): + """ + Shift `y` by `fshift` channels, where |`fshift`|<1. + + Parameters + ---------- + y : array + Data to be shifted. + fshift : float + Amount to shift the data by. + abs(fshift) must be less than 1. + method : "fft" | "interpolate" + Method to use for shifting. + "fft" uses a phase shift. + "interpolate" uses `scipy.ndimage.shift`. + pad : bool + Pad the data during the phase shift. + Only used if `method="fft"`. + window : bool + Apply a Welch window during phase shift. + Only used if `method="fft"`. + """ + + if abs(fshift) > 1: + raise ValueError("abs(fshift) must be less than one: {fshift}") + + if method == "fft": + new_y = fft_shift(y, fshift, pad=pad, window=window) + elif method == "interpolate": + new_y = ndimage.shift(y, [fshift]) + + return new_y + + +def data_shift(y, s, axis=-1, remove_wrap=True, fill_value=np.nan, method="fft", pad=False, window=True): + """ + Shift `y` by `s` channels. + + Parameters + ---------- + y : array + Data to be shifted. + s : float + Amount to shift the data by. + axis : int + Axis along which to apply the shift. + remove_wrap : bool + Replace channels that wrap around with `fill_value`. + fill_value : float + Value used to replace the data in channels that wrap around after the shift. + method : "fft" | "interpolate" + Method to use for shifting. + "fft" uses a phase shift. + "interpolate" uses `scipy.ndimage.shift`. + pad : bool + Pad the data during the phase shift. + Only used if `method="fft"`. + window : bool + Apply a Welch window during phase shift. + Only used if `method="fft"`. + """ + + ishift = int(np.round(s)) # Integer shift. + fshift = s - ishift # Fractional shift. + + logger.debug(f"Shift: s={s} ishift={ishift} fshift={fshift}") + + if ishift != 0: + # Apply integer shift. + y_new = data_ishift(y, ishift, axis=axis, remove_wrap=remove_wrap, fill_value=fill_value) + else: + y_new = deepcopy(y) + + if fshift != 0: + # Apply fractional shift. + y_new = data_fshift(y_new, fshift, method=method, pad=pad, window=window) + + return y_new diff --git a/src/dysh/spectra/scan.py b/src/dysh/spectra/scan.py index 77ba6b36..58bf8a07 100644 --- a/src/dysh/spectra/scan.py +++ b/src/dysh/spectra/scan.py @@ -11,7 +11,6 @@ from astropy import constants as ac from astropy.io.fits import BinTableHDU, Column from astropy.table import Table, vstack -from scipy import ndimage from dysh.spectra import core @@ -28,11 +27,6 @@ ) from .spectrum import Spectrum -# from typing import Literal - - -# from astropy.coordinates.spectral_coordinate import NoVelocityWarning - class SpectralAverageMixin: @log_call_to_history @@ -1659,37 +1653,11 @@ def do_fold(sig, ref, sig_freq, ref_freq, remove_wrap=False, shift_method="fft") """ """ chan_shift = (sig_freq[0] - ref_freq[0]) / np.abs(np.diff(sig_freq)).mean() logger.debug(f"do_fold: {sig_freq[0]}, {ref_freq[0]},{chan_shift}") - ref_shift = do_shift(ref, chan_shift, remove_wrap=remove_wrap, method=shift_method) + ref_shift = core.data_shift(ref, chan_shift, remove_wrap=remove_wrap, method=shift_method) # @todo weights avg = (sig + ref_shift) / 2 return avg - def do_shift(data, offset, remove_wrap=False, method="fft"): - """ - Shift the data of a numpy array using roll/shift - - @todo use the fancier GBTIDL fft based shift - """ - - ishift = int(np.round(offset)) # Integer shift. - fshift = offset - ishift # Fractional shift. - - logger.debug("FOLD: {ishift=} {fshift=}") - data2 = np.roll(data, ishift, axis=0) - if remove_wrap: - if ishift < 0: - data2[ishift:] = np.nan - else: - data2[:ishift] = np.nan - # Now the fractional shift, each row separate since ndimage.shift() cannot deal with np.nan - if method == "fft": - # Set `pad=False` to avoid edge effects. - # This needs to be sorted out. - data2 = fft_shift(data2, fshift, pad=False) - elif method == "interpolate": - data2 = ndimage.shift(data2, [fshift]) - return data2 - kwargs_opts = {"verbose": False} kwargs_opts.update(kwargs) _fold = kwargs.get("fold", False) diff --git a/src/dysh/spectra/spectrum.py b/src/dysh/spectra/spectrum.py index d1956a53..a0996cb2 100644 --- a/src/dysh/spectra/spectrum.py +++ b/src/dysh/spectra/spectrum.py @@ -37,7 +37,7 @@ from ..log import HistoricalBase, log_call_to_history from ..plot import specplot as sp from ..util import minimum_string_match -from . import baseline, fft_shift, get_spectral_equivalency +from . import baseline, get_spectral_equivalency # from astropy.nddata import StdDevUncertainty @@ -524,7 +524,7 @@ def smooth(self, method="hanning", width=1, decimate=0, kernel=None): return s - def shift(self, s, wrap=False, fill_value=np.nan, method="fft"): + def shift(self, s, remove_wrap=False, fill_value=np.nan, method="fft"): """ Shift the `Spectrum` by `s` channels in place. @@ -542,29 +542,16 @@ def shift(self, s, wrap=False, fill_value=np.nan, method="fft"): "fft" uses a phase shift. """ - ishift = int(np.round(s)) # Integer shift. - fshift = s - ishift # Fractional shift. - # Apply integer shift. - new_data = np.roll(self.data, ishift, axis=0) - if not wrap: - if ishift < 0: - new_data[ishift:] = fill_value - else: - new_data[:ishift] = fill_value - - if fshift != 0: - # Apply fractional shift. - new_data = fft_shift(new_data, fshift, pad=False, window=True) + new_data = core.data_shift(self.data, s, remove_wrap=remove_wrap, fill_value=fill_value, method=method) # Update data values. self._data = new_data # Update metadata. - applied_shift = ishift + fshift - self.meta["CRPIX1"] += applied_shift + self.meta["CRPIX1"] += s # Update WCS. - self.wcs.wcs.crpix[0] += applied_shift + self.wcs.wcs.crpix[0] += s # Update `SpectralAxis` values. new_spectral_axis_values = self.wcs.spectral.pixel_to_world(np.arange(self.flux.shape[-1])) diff --git a/src/dysh/spectra/tests/test_spectrum.py b/src/dysh/spectra/tests/test_spectrum.py index 0610dd8d..dfbe4a17 100644 --- a/src/dysh/spectra/tests/test_spectrum.py +++ b/src/dysh/spectra/tests/test_spectrum.py @@ -420,7 +420,7 @@ def test_shift(self): # Compare. # Ignore the edge channels to avoid edge effects. diff = (spec.data - gbtidl)[10:-10] - assert np.all(abs(diff) < 1e-4) + assert np.all(abs(diff) < 5e-4) assert spec.meta["CRPIX1"] == org_spec.meta["CRPIX1"] + shift assert spec.spectral_axis[0].to("Hz").value == ( diff --git a/testdata/gshift_box.fits b/testdata/gshift_box.fits index 58f676e5..ae24d1de 100644 --- a/testdata/gshift_box.fits +++ b/testdata/gshift_box.fits @@ -1,4 +1,4 @@ -SIMPLE = T /Written by IDL: Wed Oct 9 21:23:56 2024 BITPIX = 8 / NAXIS = 0 / EXTEND = T /File contains extensions DATE = '2024-10-10' / ORIGIN = 'NRAO Green Bank' /origin of observation TELESCOP= 'NRAO_GBT' /the telescope used GUIDEVER= 'GBTIDL ver2.10.1' /this file was created by gbtidl FITSVER = '1.9 ' /FITS definition version END XTENSION= 'BINTABLE' /Binary table written by MWRFITS v1.13 BITPIX = 8 /Required value NAXIS = 2 /Required value NAXIS1 = 131834 /Number of bytes per row NAXIS2 = 1 /Number of rows PCOUNT = 0 /Normally 0 (no varying arrays) GCOUNT = 1 /Required value TFIELDS = 83 /Number of columns in table COMMENT COMMENT *** End of mandatory fields *** COMMENT EXTNAME = 'SINGLE DISH' CTYPE4 = 'STOKES ' COMMENT COMMENT *** Column names *** COMMENT TTYPE1 = 'OBJECT ' / TTYPE2 = 'BANDWID ' / TTYPE3 = 'DATE-OBS' / TTYPE4 = 'DURATION' / TTYPE5 = 'EXPOSURE' / TTYPE6 = 'TSYS ' / TTYPE7 = 'DATA ' / TTYPE8 = 'TDIM7 ' / TTYPE9 = 'TUNIT7 ' / TTYPE10 = 'CTYPE1 ' / TTYPE11 = 'CRVAL1 ' / TTYPE12 = 'CRPIX1 ' / TTYPE13 = 'CDELT1 ' / TTYPE14 = 'CTYPE2 ' / TTYPE15 = 'CRVAL2 ' / TTYPE16 = 'CTYPE3 ' / TTYPE17 = 'CRVAL3 ' / TTYPE18 = 'CRVAL4 ' / TTYPE19 = 'OBSERVER' / TTYPE20 = 'OBSID ' / TTYPE21 = 'SCAN ' / TTYPE22 = 'OBSMODE ' / TTYPE23 = 'FRONTEND' / TTYPE24 = 'TCAL ' / TTYPE25 = 'VELDEF ' / TTYPE26 = 'VFRAME ' / TTYPE27 = 'RVSYS ' / TTYPE28 = 'OBSFREQ ' / TTYPE29 = 'LST ' / TTYPE30 = 'AZIMUTH ' / TTYPE31 = 'ELEVATIO' / TTYPE32 = 'TAMBIENT' / TTYPE33 = 'PRESSURE' / TTYPE34 = 'HUMIDITY' / TTYPE35 = 'RESTFREQ' / TTYPE36 = 'DOPFREQ ' / TTYPE37 = 'FREQRES ' / TTYPE38 = 'EQUINOX ' / TTYPE39 = 'RADESYS ' / TTYPE40 = 'TRGTLONG' / TTYPE41 = 'TRGTLAT ' / TTYPE42 = 'SAMPLER ' / TTYPE43 = 'FEED ' / TTYPE44 = 'SRFEED ' / TTYPE45 = 'FEEDXOFF' / TTYPE46 = 'FEEDEOFF' / TTYPE47 = 'SUBREF_STATE' / TTYPE48 = 'SIDEBAND' / TTYPE49 = 'PROCSEQN' / TTYPE50 = 'PROCSIZE' / TTYPE51 = 'PROCSCAN' / TTYPE52 = 'PROCTYPE' / TTYPE53 = 'LASTON ' / TTYPE54 = 'LASTOFF ' / TTYPE55 = 'TIMESTAMP' / TTYPE56 = 'QD_XEL ' / TTYPE57 = 'QD_EL ' / TTYPE58 = 'QD_BAD ' / TTYPE59 = 'QD_METHOD' / TTYPE60 = 'VELOCITY' / TTYPE61 = 'FOFFREF1' / TTYPE62 = 'ZEROCHAN' / TTYPE63 = 'ADCSAMPF' / TTYPE64 = 'VSPDELT ' / TTYPE65 = 'VSPRVAL ' / TTYPE66 = 'VSPRPIX ' / TTYPE67 = 'SIG ' / TTYPE68 = 'CAL ' / TTYPE69 = 'CALTYPE ' / TTYPE70 = 'TWARM ' / TTYPE71 = 'TCOLD ' / TTYPE72 = 'CALPOSITION' / TTYPE73 = 'BACKEND ' / TTYPE74 = 'PROJID ' / TTYPE75 = 'TELESCOP' / TTYPE76 = 'SITELONG' / TTYPE77 = 'SITELAT ' / TTYPE78 = 'SITEELEV' / TTYPE79 = 'IFNUM ' / TTYPE80 = 'PLNUM ' / TTYPE81 = 'FDNUM ' / TTYPE82 = 'INT ' / TTYPE83 = 'NSAVE ' / COMMENT COMMENT *** Column formats *** COMMENT TFORM1 = '32A ' / TFORM2 = 'D ' / TFORM3 = '22A ' / TFORM4 = 'D ' / TFORM5 = 'D ' / TFORM6 = 'D ' / TFORM7 = '32768E ' / TFORM8 = '16A ' / TFORM9 = '6A ' / TFORM10 = '8A ' / TFORM11 = 'D ' / TFORM12 = 'D ' / TFORM13 = 'D ' / TFORM14 = '4A ' / TFORM15 = 'D ' / TFORM16 = '4A ' / TFORM17 = 'D ' / TFORM18 = 'I ' / TFORM19 = '32A ' / TFORM20 = '32A ' / TFORM21 = 'J ' / TFORM22 = '32A ' / TFORM23 = '16A ' / TFORM24 = 'D ' / TFORM25 = '8A ' / TFORM26 = 'D ' / TFORM27 = 'D ' / TFORM28 = 'D ' / TFORM29 = 'D ' / TFORM30 = 'D ' / TFORM31 = 'D ' / TFORM32 = 'D ' / TFORM33 = 'D ' / TFORM34 = 'D ' / TFORM35 = 'D ' / TFORM36 = 'D ' / TFORM37 = 'D ' / TFORM38 = 'D ' / TFORM39 = '8A ' / TFORM40 = 'D ' / TFORM41 = 'D ' / TFORM42 = '8A ' / TFORM43 = 'I ' / TFORM44 = 'I ' / TFORM45 = 'D ' / TFORM46 = 'D ' / TFORM47 = 'I ' / TFORM48 = 'A ' / TFORM49 = 'I ' / TFORM50 = 'I ' / TFORM51 = '16A ' / TFORM52 = '16A ' / TFORM53 = 'J ' / TFORM54 = 'J ' / TFORM55 = '22A ' / TFORM56 = 'D ' / TFORM57 = 'D ' / TFORM58 = 'I ' / TFORM59 = 'A ' / TFORM60 = 'D ' / TFORM61 = 'D ' / TFORM62 = 'E ' / TFORM63 = 'D ' / TFORM64 = 'D ' / TFORM65 = 'D ' / TFORM66 = 'D ' / TFORM67 = 'A ' / TFORM68 = 'A ' / TFORM69 = '8A ' / TFORM70 = 'E ' / TFORM71 = 'E ' / TFORM72 = '16A ' / TFORM73 = '32A ' / TFORM74 = '32A ' / TFORM75 = '32A ' / TFORM76 = 'D ' / TFORM77 = 'D ' / TFORM78 = 'D ' / TFORM79 = 'I ' / TFORM80 = 'I ' / TFORM81 = 'I ' / TFORM82 = 'J ' / TFORM83 = 'J ' / END NGC2415 AvZ À2021-02-10T07:38:37.50@õ6à@eO`@10ràÀÀÀÀÀÀ?@ÅÔ? ê? +SIMPLE = T /Written by IDL: Thu Oct 10 10:23:24 2024 BITPIX = 8 / NAXIS = 0 / EXTEND = T /File contains extensions DATE = '2024-10-10' / ORIGIN = 'NRAO Green Bank' /origin of observation TELESCOP= 'NRAO_GBT' /the telescope used GUIDEVER= 'GBTIDL ver2.10.1' /this file was created by gbtidl FITSVER = '1.9 ' /FITS definition version END XTENSION= 'BINTABLE' /Binary table written by MWRFITS v1.13 BITPIX = 8 /Required value NAXIS = 2 /Required value NAXIS1 = 131834 /Number of bytes per row NAXIS2 = 1 /Number of rows PCOUNT = 0 /Normally 0 (no varying arrays) GCOUNT = 1 /Required value TFIELDS = 83 /Number of columns in table COMMENT COMMENT *** End of mandatory fields *** COMMENT EXTNAME = 'SINGLE DISH' CTYPE4 = 'STOKES ' COMMENT COMMENT *** Column names *** COMMENT TTYPE1 = 'OBJECT ' / TTYPE2 = 'BANDWID ' / TTYPE3 = 'DATE-OBS' / TTYPE4 = 'DURATION' / TTYPE5 = 'EXPOSURE' / TTYPE6 = 'TSYS ' / TTYPE7 = 'DATA ' / TTYPE8 = 'TDIM7 ' / TTYPE9 = 'TUNIT7 ' / TTYPE10 = 'CTYPE1 ' / TTYPE11 = 'CRVAL1 ' / TTYPE12 = 'CRPIX1 ' / TTYPE13 = 'CDELT1 ' / TTYPE14 = 'CTYPE2 ' / TTYPE15 = 'CRVAL2 ' / TTYPE16 = 'CTYPE3 ' / TTYPE17 = 'CRVAL3 ' / TTYPE18 = 'CRVAL4 ' / TTYPE19 = 'OBSERVER' / TTYPE20 = 'OBSID ' / TTYPE21 = 'SCAN ' / TTYPE22 = 'OBSMODE ' / TTYPE23 = 'FRONTEND' / TTYPE24 = 'TCAL ' / TTYPE25 = 'VELDEF ' / TTYPE26 = 'VFRAME ' / TTYPE27 = 'RVSYS ' / TTYPE28 = 'OBSFREQ ' / TTYPE29 = 'LST ' / TTYPE30 = 'AZIMUTH ' / TTYPE31 = 'ELEVATIO' / TTYPE32 = 'TAMBIENT' / TTYPE33 = 'PRESSURE' / TTYPE34 = 'HUMIDITY' / TTYPE35 = 'RESTFREQ' / TTYPE36 = 'DOPFREQ ' / TTYPE37 = 'FREQRES ' / TTYPE38 = 'EQUINOX ' / TTYPE39 = 'RADESYS ' / TTYPE40 = 'TRGTLONG' / TTYPE41 = 'TRGTLAT ' / TTYPE42 = 'SAMPLER ' / TTYPE43 = 'FEED ' / TTYPE44 = 'SRFEED ' / TTYPE45 = 'FEEDXOFF' / TTYPE46 = 'FEEDEOFF' / TTYPE47 = 'SUBREF_STATE' / TTYPE48 = 'SIDEBAND' / TTYPE49 = 'PROCSEQN' / TTYPE50 = 'PROCSIZE' / TTYPE51 = 'PROCSCAN' / TTYPE52 = 'PROCTYPE' / TTYPE53 = 'LASTON ' / TTYPE54 = 'LASTOFF ' / TTYPE55 = 'TIMESTAMP' / TTYPE56 = 'QD_XEL ' / TTYPE57 = 'QD_EL ' / TTYPE58 = 'QD_BAD ' / TTYPE59 = 'QD_METHOD' / TTYPE60 = 'VELOCITY' / TTYPE61 = 'FOFFREF1' / TTYPE62 = 'ZEROCHAN' / TTYPE63 = 'ADCSAMPF' / TTYPE64 = 'VSPDELT ' / TTYPE65 = 'VSPRVAL ' / TTYPE66 = 'VSPRPIX ' / TTYPE67 = 'SIG ' / TTYPE68 = 'CAL ' / TTYPE69 = 'CALTYPE ' / TTYPE70 = 'TWARM ' / TTYPE71 = 'TCOLD ' / TTYPE72 = 'CALPOSITION' / TTYPE73 = 'BACKEND ' / TTYPE74 = 'PROJID ' / TTYPE75 = 'TELESCOP' / TTYPE76 = 'SITELONG' / TTYPE77 = 'SITELAT ' / TTYPE78 = 'SITEELEV' / TTYPE79 = 'IFNUM ' / TTYPE80 = 'PLNUM ' / TTYPE81 = 'FDNUM ' / TTYPE82 = 'INT ' / TTYPE83 = 'NSAVE ' / COMMENT COMMENT *** Column formats *** COMMENT TFORM1 = '32A ' / TFORM2 = 'D ' / TFORM3 = '22A ' / TFORM4 = 'D ' / TFORM5 = 'D ' / TFORM6 = 'D ' / TFORM7 = '32768E ' / TFORM8 = '16A ' / TFORM9 = '6A ' / TFORM10 = '8A ' / TFORM11 = 'D ' / TFORM12 = 'D ' / TFORM13 = 'D ' / TFORM14 = '4A ' / TFORM15 = 'D ' / TFORM16 = '4A ' / TFORM17 = 'D ' / TFORM18 = 'I ' / TFORM19 = '32A ' / TFORM20 = '32A ' / TFORM21 = 'J ' / TFORM22 = '32A ' / TFORM23 = '16A ' / TFORM24 = 'D ' / TFORM25 = '8A ' / TFORM26 = 'D ' / TFORM27 = 'D ' / TFORM28 = 'D ' / TFORM29 = 'D ' / TFORM30 = 'D ' / TFORM31 = 'D ' / TFORM32 = 'D ' / TFORM33 = 'D ' / TFORM34 = 'D ' / TFORM35 = 'D ' / TFORM36 = 'D ' / TFORM37 = 'D ' / TFORM38 = 'D ' / TFORM39 = '8A ' / TFORM40 = 'D ' / TFORM41 = 'D ' / TFORM42 = '8A ' / TFORM43 = 'I ' / TFORM44 = 'I ' / TFORM45 = 'D ' / TFORM46 = 'D ' / TFORM47 = 'I ' / TFORM48 = 'A ' / TFORM49 = 'I ' / TFORM50 = 'I ' / TFORM51 = '16A ' / TFORM52 = '16A ' / TFORM53 = 'J ' / TFORM54 = 'J ' / TFORM55 = '22A ' / TFORM56 = 'D ' / TFORM57 = 'D ' / TFORM58 = 'I ' / TFORM59 = 'A ' / TFORM60 = 'D ' / TFORM61 = 'D ' / TFORM62 = 'E ' / TFORM63 = 'D ' / TFORM64 = 'D ' / TFORM65 = 'D ' / TFORM66 = 'D ' / TFORM67 = 'A ' / TFORM68 = 'A ' / TFORM69 = '8A ' / TFORM70 = 'E ' / TFORM71 = 'E ' / TFORM72 = '16A ' / TFORM73 = '32A ' / TFORM74 = '32A ' / TFORM75 = '32A ' / TFORM76 = 'D ' / TFORM77 = 'D ' / TFORM78 = 'D ' / TFORM79 = 'I ' / TFORM80 = 'I ' / TFORM81 = 'I ' / TFORM82 = 'J ' / TFORM83 = 'J ' / END NGC2415 AvZ À2021-02-10T07:38:37.50@õ6à@eO`@10ràÀÀÀÀÀÀ?@ÅÔ? ê? Ïš?%g>°õì?#tÃ?hµ>÷$Ä>•ž>ÄIP?*/^>Ö6?î¸? ¦_>À):>–4Û>‡³8>ž½O>`Qh?k?Q×>»}Ö?<âô?{*«?X3Ö?!ê´>Ò›¸>Mß?ãÿ?C|§>™ö>¹8À?6–E?0ë?G#°>óèE>‰^½?I\>~y¼>¯«L?Bk$?;DR>Ó%»? Ê&?/Áo>þ0?%X®>âJ}>ôDØ?BŠ(?=øk>öj>ý|U?_Ž=ãá¬>ð¦›?^EW?_¡ò?-5á>¾Å‚>~Ö>¤ÐŸ?0É/?Hî?D4>màh>Ú€µ?98G?f1–§¢?4”?(Š,?Fõ>š]\>«wr?ObÐ?_¢$?[(?Hö>à$t?id>øÔÞ?³î>ã§>á™Ñ?£">„G>°ŽM?¤>ßí>‘nW>P¾(=úŒ>µ¯ó>‚›Q>½4¨?É(? ô˜?3³À?”?&Ôº?@‡Ž?9 j?‚>âßî>¸8?î?"Ö>s¹b>+Ì>L|?}É??Y{>Ðdì>yâÌ>̘6? ½0?:â?KÓ?7…Ú?JÔ? ÏT>ͱ:>ÔZÐ>q,>UF>zçF>™µn>ŸG>à<ö?H ö?`ö{?G=?GÂN?+Öj?B@=?Or=?<‘> ¡>I>¸~ª>&> Uh?)Y? 4?|?*K>¢vÖ?Y»?3Õ>¦8ÿ?–>ö¾?>Ú/ê>ï½}>‘d!>œÄô? ´z?±¾?-à?O]x?'Tv? From 93c9f10f5074cd678c0923ae7a2e542c87fbbaf9 Mon Sep 17 00:00:00 2001 From: astrofle Date: Thu, 10 Oct 2024 11:40:51 -0400 Subject: [PATCH 38/95] Fix: remove matplotlib widget from notebook --- notebooks/examples/align_spectra.ipynb | 51 +++++++------------------- 1 file changed, 13 insertions(+), 38 deletions(-) diff --git a/notebooks/examples/align_spectra.ipynb b/notebooks/examples/align_spectra.ipynb index 51cc660f..5bddcd84 100644 --- a/notebooks/examples/align_spectra.ipynb +++ b/notebooks/examples/align_spectra.ipynb @@ -17,17 +17,7 @@ }, { "cell_type": "code", - "execution_count": 12, - "id": "2845830c-b401-44b3-a6b1-ed1c30c706df", - "metadata": {}, - "outputs": [], - "source": [ - "%matplotlib widget" - ] - }, - { - "cell_type": "code", - "execution_count": 53, + "execution_count": 1, "id": "e34b86e9-6438-4e84-8503-d6dd1699e243", "metadata": {}, "outputs": [], @@ -40,7 +30,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 2, "id": "cf801734-2ba0-48cd-a664-3ca15ce58890", "metadata": {}, "outputs": [], @@ -51,7 +41,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 3, "id": "fb10b18f-4510-4707-ad2a-70a1ec2b4d79", "metadata": {}, "outputs": [ @@ -69,7 +59,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 4, "id": "62f47e96-7553-48c9-9dfb-032d2af60897", "metadata": {}, "outputs": [ @@ -156,7 +146,7 @@ "1 1 117.172716 27.302879 " ] }, - "execution_count": 6, + "execution_count": 4, "metadata": {}, "output_type": "execute_result" } @@ -175,7 +165,7 @@ }, { "cell_type": "code", - "execution_count": 60, + "execution_count": 5, "id": "d076291b-e69e-4018-ac95-718a7fa3c350", "metadata": {}, "outputs": [ @@ -183,9 +173,9 @@ "name": "stderr", "output_type": "stream", "text": [ - "/home/sandboxes/psalas/Dysh/dysh/src/dysh/spectra/core.py:393: RuntimeWarning: Mean of empty slice\n", + "/home/sandboxes/psalas/Dysh/dysh/src/dysh/spectra/core.py:395: RuntimeWarning: Mean of empty slice\n", " meandiff = np.nanmean(calon[chrng] - caloff[chrng])\n", - "/home/sandboxes/psalas/Dysh/dysh/src/dysh/spectra/core.py:393: RuntimeWarning: Mean of empty slice\n", + "/home/sandboxes/psalas/Dysh/dysh/src/dysh/spectra/core.py:395: RuntimeWarning: Mean of empty slice\n", " meandiff = np.nanmean(calon[chrng] - caloff[chrng])\n" ] } @@ -204,7 +194,7 @@ }, { "cell_type": "code", - "execution_count": 61, + "execution_count": 6, "id": "3e51cc62-4ffc-4f3b-b934-bc2b42d63306", "metadata": {}, "outputs": [ @@ -245,30 +235,15 @@ }, { "cell_type": "code", - "execution_count": 67, + "execution_count": 7, "id": "e5ff3d24-63bd-49f6-a7b6-76a150f41c22", "metadata": {}, "outputs": [ { "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "8dcb1827f1fe422a97e7555712bc94a8", - "version_major": 2, - "version_minor": 0 - }, - "image/png": "iVBORw0KGgoAAAANSUhEUgAAA8AAAALQCAYAAABfdxm0AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8g+/7EAAAACXBIWXMAABcSAAAXEgFnn9JSAAEAAElEQVR4nOydd3Qc1dnGn9kqadW7bNkycgVjG1NtqikBA6F/tAQCoSRACCGQ0BICJJBACIQWIDSbEkoA02LTscFgbOPei2xLVi+r7b3M98fsztw7MyutmiVZ7+8cH0/f2dXuzDz3eYsgiqIIgiAIgiAIgiAIgtjPMQz2CRAEQRAEQRAEQRDEvoAEMEEQBEEQBEEQBDEiIAFMEARBEARBEARBjAhIABMEQRAEQRAEQRAjAhLABEEQBEEQBEEQxIiABDBBEARBEARBEAQxIiABTBAEQRAEQRAEQYwISAATBEEQBEEQBEEQIwISwARBEARBEARBEMSIgAQwQRAEQRAEQRAEMSIgAUwQBEEQBEEQBEGMCEgAEwRBEARBEARBECMCEsAEQRAEQRAEQRDEiIAEMEEQBEEQBEEQBDEiIAFMEARBEARBEARBjAhIABMEQRAEQRAEQRAjAhLABEEQBEEQBEEQxIiABDBBEARBEARBEAQxIiABTBAEQRAEQRAEQYwISAATBEEQBEEQBEEQIwISwARBEARBEARBEMSIgAQwQRAEQRBpM2fOHAiCgHvvvXewTwXA0DsfgiAIYmhDApggCIIgesG9994LQRAgCMI+e83vvvtOfs133nkn7f3+8pe/QBAEmM1mtLa2DuAZDi0ee+wx3HvvvVi3bt1gnwpBEAQxRCABTBAEQRDDhGOOOQaTJ08GALz00ktp7SOKIubPnw8A+PGPf4yysrKBOr1BYezYsZg8eTKKi4s16x577DHcd999JIAJgiAIGdNgnwBBEARBEOlz9dVX47bbbsNnn32GpqYmjBo1qsvtv/76a+zevRsAcNVVV+2LU9ynvPLKK4N9CgRBEMQwghxggiAIghhG/OxnP4PJZEIsFsPLL7/c7fZJp7iiogJnnHHGQJ8eQRAEQQxpSAATBEEQRD+zZMkSLj+4pqYGV111FcaMGQOr1YrKykpce+21aGxs7PGxy8rK8OMf/xgAMG/evC63dbvdePfddwEAV1xxBYxGo7wuHo/jP//5D8444wyUlZXBYrGgpKQEp556Kt544w2Iotjjc0uyYMECOdzaYrHI5/zee+91u6/dbsef//xnHHXUUSgsLERGRgbGjRuHU089Fc888wxcLhe3vV4RrGR+dl1dHQDg5z//ufz3YP8uzz77LARBQGFhIYLBYMpzisfjGDduHBXbIgiC2A8gAUwQBEEQA8jixYsxc+ZMzJs3Dy6XC/F4HI2NjXjhhRdw5JFH9koEX3311QCAnTt34ttvv0253VtvvQW/3w+AD3/u7OzEiSeeiMsuuwwff/wx2trakJWVhY6ODnz++ef4yU9+gnPPPRfhcLhH5xUOh3HJJZfgggsuwMKFC9HR0YHs7Gx0dHRg4cKFOP/88/GTn/wEkUhEd//PPvsMEydOxD333IOVK1fC4/EgOzsbTU1N+Pzzz3HDDTdg8eLF3Z5HdnY2ysrKYDBIjzm5ubkoKyvj/gHAT3/6U2RnZ8PhcHRZVOyzzz5DXV0djEaj/NkTBEEQwxMSwARBEAQxgFxwwQU46aSTsHXrVrjdbvh8Prz11lvIyclBU1MT7rzzzh4f8/TTT5dzf7sqhpVcd9xxx2HixIkAgFgshvPPPx/ffPMNDjnkEHz00Ufw+XxwOp3wer14+eWXUVpaig8//BC33357j87rrrvuwltvvQVBEHD33XfDbrejs7MTHR0duOuuuwAAb7zxBu6++27NvmvXrsU555wDh8OBqVOnYtGiRfD7/ejo6EAgEMCqVatw6623Iicnp9vz+N3vfoeWlhaMGTMGAPD444+jpaWF+wcAOTk5uOyyywAAzz//fMrjJdedfvrp8jEJgiCIYYpIEARBEESPueeee0QAot6tdPHixfK6E088UYzFYpptnnjiCRGAmJmZKUYikR6//p133ikCELOzs0WPx6NZv2XLFvkc5s+fLy9/5ZVXRADilClTRKfTqXvsVatWiYIgiBaLRWxtbeXWnXDCCSIA8Z577uGWNzQ0iCaTSQQg3nnnnbrHveWWW0QAotlsFpuamrh1xx57rAhAnDhxYsrz0iPV+YiiKFZVVYkAxHnz5qXcf926dfLntG3bNs36lpYW0Ww2iwDEDz/8MO3zIgiCIIYm5AATBEEQxABy1113yaG4LOeccw4AIBAIYOfOnT0+bjKk2ev14u2339asT+YH5+Tk4MILL5SXv/jiiwCA66+/Hnl5ebrHPuywwzB16lSEw+G0Qo4B4N1330U0GkVGRgbuuOMO3W3++Mc/wmq1IhKJcCHHbCj3X//615TnNRDMmDEDs2fPBgA899xzmvXz5s1DJBJBZWUlFREjCILYDyABTBAEQRADyFFHHaW7nG1f1NnZ2ePjTpgwAccffzwAbRh0NBrFq6++CgC45JJLkJWVBUAKf16+fDkAqVBUeXl5yn/bt28HALmQVHesWrUKAHDEEUcgNzdXd5uCggIcfvjh3PYAsGzZMgCA0WjE6aefntbr9SfXXXcdAKmlEpv3LIoiXnjhBQBS3jVbRIwgCIIYnpAAJgiCIIgBJFXOqslkkqdTFYXqjmRBpm+//ZZzkRctWiTnubJFmzo7OxEKhQAADocDra2tKf8lzylZRKs72traAACjR4/ucrvKykpuewDyuRYXF8Nms6X1ev3JRRddhMLCQnR0dGDBggXy8q+++gq7du2C0WjENddcs8/PiyAIguh/SAATBEEQxDDl//7v/2S3lW2JlJyeOnUq50DHYjF5+uOPP4Yoit3+2xdtf5JtiQaLjIwMXHnllQD4MGi2+FVSuBMEQRDDGxLABEEQBDFMycrKwqWXXgpACt+NxWJoa2vDwoULAfCtjwCgqKhIdp7TDW1Ol9LSUgBAQ0NDl9sl1ye3B4Dy8nIAQEdHB3w+X7+eV7r88pe/hCAIWLJkCWpqatDR0SH3Lf7lL385KOdEEARB9D8kgAmCIAhiGJMMcW5sbMSnn36KV199FZFIBGazGZdffjm3rdlsxpFHHgkA+Oijj/r1PNjcXpfLpbuN0+nkcoWTHH300QAkh/rjjz/ut3NKFh8TRbHbbSdNmoSTTjoJoiji+eefl/OBx4wZMyh5yQRBEMTAQAKYIAiCIIYxRxxxBKZNmwZACn1Ohj+fddZZKCkp0Wz/i1/8AoCUJ7xo0aIuj92T4lwXXHABTCYTgsEgHnroId1t/vrXvyIUCsFsNuOCCy6Ql7MFve666y643e60X7crkuHhTqczre2TxbDmz58vh0JfddVVVPyKIAhiP4IEMEEQBEEMc5Iu8IIFC7B582ZumZrLLrsMp5xyCkRRxHnnnYf7778fTU1N8nqfz4fFixfjV7/6Faqrq9M+h9GjR+M3v/kNAODBBx/EPffcIwtPp9OJu+++Gw8//DAA4JZbbkFFRQW3/+OPP46MjAzs3LkTxxxzDD755BO5EFcsFsMPP/yA6667Dl988UXa53TwwQcDAN555x04HI5utz/33HNRXl6OtrY2bN++nYpfEQRB7IeQACYIgiCIYc5ll10Gi8WCeDwOQBKjp512mu62RqMR7777Ln784x8jHA7j7rvvxujRo5GXl4eCggLk5OTgpJNOwtNPP93jfNy//vWvuOiiiyCKIv785z+jqKgIhYWFKCoqwv333w8AuPTSS/GXv/xFs+8hhxyCDz74AHl5edi0aRNOP/102Gw2FBcXIzMzE0ceeST+/e9/w+v1pn0+v/jFLyAIApYtW4aSkhKMGjUK48aNw7hx43S3N5lMnOCl4lcEQRD7HySACYIgCGKYU1RUhHPPPVeev+KKK7oM283NzcVHH32ERYsW4eKLL8bYsWMRCoXg9/sxevRonHrqqfjb3/4m9wJOF4vFgrfeegvvvPMOTj/9dBQVFcHj8aCoqAinn346FixYgNdffx1ms1l3/1NPPRU7d+7EH/7wB8ycOROZmZnw+XyyoP/3v/+Nk046Ke3zOf7447Fw4UKccsopyM/PR2trK+rq6rosAHbhhRfK01T8iiAIYv9DENOpDEEQBEEQBDECeOSRR/C73/0OY8aMwZ49eyj/lyAIYj+DHGCCIAiCIAhIucbPPPMMAODaa68l8UsQBLEfQgKYIAiCIIgRTzwexz333INdu3bBZrPJFaEJgiCI/QvTYJ8AQRAEQRDEYPHOO+/gd7/7HTo7O+HxeAAA9913n24LKYIgCGL4QwKYIAiCIIgRi9frRV1dHcxmM6ZMmYIbb7wRv/rVrwb7tAiCIIgBgopgEQRBEARBEARBECMCygEmCIIgCIIgCIIgRgQkgAmCIAiCIAiCIIgRAQlggiAIgiAIgiAIYkRAApggCIIgCIIgCIIYEZAAJgiCIAiCIAiCIEYEJIAJgiAIgiAIgiCIEQH1Ad7PKC8vh8/nw9ixYwf7VAiCIAiCIAiCIHqM3W7HkUceiQ8//LDfj00O8H6Gz+dDJBIZ7NMgCIIgCIIgCILoFT6fD7t27RqQY5MDvJ+RdH43b948yGdCEARBEARBEATRc6ZOnTpgxyYHmCAIgiAIgiAIghgRkAAmCIIgCIIgCIIgRgQkgAmCIAiCIAiCIIgRAQlggiAIgiAIgiAIYkRAApggCIIgCIIgCIIYEZAAJgiCIAiCIAiCIEYE1AaJIAiCIEYAoigCAARBGOQzIQhiJCCKonzdIUYugiAMufsOCWCCIAiC2M/Za/fj6pd/gCAAL15xBMYUZg32KREEsR8Sj8fhcrngcDgQCoUG+3SIIYLVakVBQQHy8vJgMAx+APLgnwFBEARBEAPKGz/sxc42L3a0evHairrBPh2CIPZDRFFES0sLWlpaSPwSHKFQCC0tLWhtbR0SUQHkABMEQRDEfk67R3kYbXQEBvFMCILYX/F4PHC5XACA0tJS5Obmwmg0DvJZEYNNLBaD2+1GW1sbnE4nbDYbcnNzB/WcSAATBEEQxH6OLxSVp1kxTBAE0V+43W4AQGFhIYqKigb5bIihgsFgQFFREaLRKDo7O+HxeAZdAFMINEEQBEHs53gZAdzhJQFMEET/4/f7AQA5OTmDfCbEUCT5vfD5fIN8JiSACYIgCGK/hxxggiAGElEUEYvFAEgFjwhCTfJ7EYvFBj0PmAQwQRAEQezn+EIxedodjCIYiXWxNUEQRM9gBc1Qa3lDDA3Y7wUJYIIgCIIgBhQ2BBoA7L7wIJ0JQRAEQQwuJIAJgiAIYj/HF+YFMIVBEwRBECMVEsAEQRAEsZ/jC5EAJgiCIAiABHCXrF69Gg8++CDOP/98VFZWQhCEPuU1OBwO/OY3v0FVVRWsViuqqqpw8803w+l09t9JEwRBEARDKBpDJMbnW1ElaIIgiH1DKv2QXJ7q35w5c/r9XOrq6vDkk09i7ty5KC8vh9lsRnFxMebOnYsPP/xQd5/58+d3e66CIOCVV17p9/MdKKgPcBf85S9/wQcffNAvx+ro6MDs2bNRU1OD6upqnHvuudi8eTMef/xxfPzxx/j+++9RWFjYL69FEARBEEnYAlhJyAEmCIIYGlxxxRW6y6dMmdLvr/XTn/4U3333HaxWK2bNmoXy8nLs3r0bn376KT799FP89re/xaOPPsrtM2HChJTn6HK58P777wMAjj322H4/34GCBHAXzJ49G9OnT8cRRxyBI444AuPGjUMo1LuHhptvvhk1NTU4//zz8dZbb8Fkkj76m266CU8++SRuueUWzJ8/vx/PniAIgtjv8bYD3z8F5I8BDr8a0HEZ1OHPAAlggiCIocK+fP6vrKzEk08+iSuuuILr17xw4UKce+65+Oc//4m5c+fi1FNPldcde+yxKcXtM888g/fffx/HHHMMqqurB/z8+wsSwF1w++2398txmpub8cYbb8BiseDpp5+WxS8APPzww3jzzTfx2muv4e9//ztKS0v75TUJgiCIEcA3DwMr/y1NF08CDjhes4m6AjRAIdAEQRAjkTfffFN3+ZlnnomrrroKzz33HN544w1OAHfFa6+9BgC4/PLL++0c9wWUA7wP+OSTTxCPx3HcccehrKyMW2e1WnHWWWchFoth0aJFg3SGBEEQxLCkbQszvVV3E3KACYIgiO6YMWMGAKCpqSmt7ffs2YNly5bBYrHgoosuGshT63dIAO8D1q9fDwA49NBDddcnl2/YsGGfnRNBEASxHxDxM9MB3U30HOB2coAJgiAIht27dwMAysvL09o+6f6eeeaZKCgoGLDzGggoBHofsHfvXgBS3L0eyeV1dXX77JwIgiCI/QBW9Eb1Ra1eEawOcoAJgtiHiKIId1A7GDfUyc0w9akDTH8yZ84cfP311z3aZ968ebjyyiu73c7pdMpVnM8555y0jj1cw58BEsD7BK/XCwDIysrSXW+z2QAAHo8n7WNOnTpVd/muXbswfvz4Hp4hQRAEMSxhHeBoKgc4olnmC8fgC0Vhs9JjAEEQA487GMWM+z4b7NPoMevvORV5meYBfY1UAnvPnj0YN26cPD937lxuPh0mTJiQ1nbXXXcd2tvbMWvWLJx33nndbr9y5Urs2LEDhYWFOPPMM3t0TkMBuvMRBEEQxHAlDQfYq+MAA1IhLBLABEEQg0uqFkPZ2dnc/B133DEgr//QQw/hrbfeQmFhIf7zn/+k5Xgn3d+LLroIFotlQM5rIKE73z4g+QX2+/26630+HwBw5ci7Y/PmzbrLUznDBEEQxH4IJ4CDupvoFcECJAFcVWQbiLMiCIIg0mQw26C+9tpruPPOO2Gz2bBw4cK0WhlFo1G89dZbAIZn+DNAAnifMHbsWABAQ0OD7vrk8qqqqn12TgRBEMR+AFcEq2cCmCpBEwSxr8jNMGH9Pem11hlK5GYMHan04IMPYtu2bT3a55prrknZw/d///sffv7zn8NsNmPBggWYNWtWWsf87LPP0NbWhurqahx99NE9Op+hwtD5q+7HJMuKr1mzRnd9cvn06dP32TkRBEEQw5xYBIgz4jaFA6xXBRogAUwQxL5DEIQBz6Xd3/nkk096XARrzpw5ugL466+/xoUXXghRFPH666+n3fcXUMKfL7vssh6dy1CCBPA+YO7cuTAYDFi6dCna2tpQWloqrwuFQvjoo49gNBpxxhlnDOJZEgRBEMOKiCqtpoch0O3ecH+fEUEQBDFALFmypF+Os2bNGpx99tkIhUJ46aWXcMEFF6S9r9frxQcffABgeAtg6gPcjzz11FOYMmUK7rzzTm55RUUFLr30UoTDYdxwww2IRpWHkdtuuw3t7e247LLLOGFMEARBEF2i7vub0gFWimBZjMptnxxggiCIkcX27dsxd+5cuN1uPP7442m1SGJZsGAB/H4/Zs2ahYkTJw7MSe4DyAHugoULF+Ivf/mLPB8OS6PlbIz83XffLZf/7ujowPbt29Hc3Kw51mOPPYbly5fj3XffxZQpU3D44Ydj8+bN2LRpEyZOnIhHH310gN8NQRAEsV+hcYBT9QFWBl3HFGZiV7tUeJEEMEEQxMjikksuQXt7O0pKSrB69WpdATxlypSUFaeHc+9fFhLAXdDe3o4VK1ZolrPL2tvb0zpWcXExVq5ciXvvvRfvv/8+3nvvPZSVleGmm27Cfffdh/z8/P46bYIgCGIkoHaA1fMJfGFFAB9QbJMFcIeXBDBBEMRIwuFwAJD0y8svv6y7zQknnKArgJubm/HVV1/BbDbj4osvHtDzHGhIAHfBlVde2aPQgHvvvRf33ntvyvWFhYV44okn8MQTT/T95AiCIIiRjSYEWiVowz5g99dAMA5A6us4jml7RA4wQRDEwCOKYo+WDyS1tbW93reiooJL4xzOUA4wQRAEQQxHwj5+PqoSxG9cCrx5KZ7w/h4GxAEAVUVZ8mq7LzQoD2AEQRAEMZiQACYIgiCI4UhXDnA0DOyR2mWMQxOqhFYAwFjGAQ5G4vCHYyAIgiCIkQQJYIIgCIIYjnTVBinCu8M5kLYdU5DJLbdTKySCIAhihEECmCAIgiCGI5oiWIwAVoVH5wqSAM7NNKMgyywvt/soD5ggCIIYWZAAJgiCIIjhSFcOcJhflwtJEGdbTSjKtsrL+9sBrrP7cPs7GzD/uz39elyCIAiC6C+oCjRBEARBDEfUDrAYA2IRwGgGwl5uVa7gh9EgwGoyoNBmkZf3twP8wMKt+GyLlG98yNgCHDImv1+PTxAEQRB9hRxggiAIghiO6PX9TbrAKnc4B37YLEYIgoDibFYA968DvKnRJU9vbXb367EJgiAIoj8gAUwQBEEQ3RCMxIZeyyB1CDSgVILWyQHOtkpBX0W2gQmBjsVFtDK9he1eyi8mCIIghh4kgAmCIAiiCz7b3ILD7/8Ccx9bCn84Otino6DnACeXqQUwfLAlBDAXAt2PIrXDG0IsLjLzVGGaIAiCGHqQACYIgiCILnjl+zp4Q1Fsb/Xgy61tg306Cj10gJMCeKBCoFtcQW6+gxxggiAIYghCApggCIIgusAViMjT7mCkiy33Mbo5wPoOcA6YEOg+VoH+alsrjv7bl7ju1dWc49tMApggCIIYBpAAJgiCIIguCERi8nQoEh/EM1GhK4ATojOi5wAbAQBFfawC/fCnO9DkCuKTzS1YvtsuL29x8efT3y2WCIIgCKI/IAFMEARBEF0QCCsCOBiNdbHlPkYvBDplDrASAl3EhEB3+sI9Ku4Vi4vY1aa0WGJd32Y3OcAEQRDE0IcEMEEQBEF0QSg6DB3gMC+OcwUfcnSqQEdiItzB9At7NTkDCMeUz8DpV1xedQ6wwx9BNDaEPi+CIIhBQBAECIKQcnmqf3PmzOn3c6mrq8Ott96K448/HpWVlcjIyEB2djZmzpyJBx54AD6fL+W+DocDv/nNb1BVVQWr1YqqqircfPPNcDqd/X6eA41psE+AIAiCIIYyrAMcig4hQafjAO9obIfX6sChYS+3PAcB2QHOyzTDaBDk/F27N4S8THNaL7mng384cvqVnGh1DjAgOcyluRlpHZsgCGIkcsUVV+gunzJlSr+/1saNG/Hoo4+ivLwcU6ZMwXHHHQeHw4Hly5fjj3/8I9544w0sXboUBQUF3H4dHR2YPXs2ampqUF1djXPPPRebN2/G448/jo8//hjff/89CgsL+/18BwoSwARBEASRAlEUEWREbzAylEKgtQ7wU59twofxXCyf2IlyZnmOEEAy8tlgEFCQZZFDlO2+MKpL0ntJjQAOpHaAAakVEglggiCI1MyfP3+fvdZhhx2GTZs2YerUqdxyt9uN888/H19++SUeeOAB/OMf/+DW33zzzaipqcH555+Pt956CyaTJCFvuukmPPnkk7jlllv26fvoKxQCTRAEQRApiMRErtLx0HKAtQLYKkiCtLm9Q7OuwKjk5HKtkHpQrEotgB0JB1gURbS4tQK4N0W2CIIgiIGhoqJCI34BIDc3F/feey8A4KuvvuLWNTc344033oDFYsHTTz8ti18AePjhh1FSUoLXXnsNbW1DqE1gN5AAJgiCIIgUBFSOb2iIF8GyQhKkIb9Hsy5fULYvyu5dJWi1AHYlBLDDH0FYZ3CACmERBEEMD8xmKRXGYrFwyz/55BPE43Ecd9xxKCsr49ZZrVacddZZiMViWLRo0T47175CApggCIIgUhBSC+AhXgTLCsnNzYDWjc0TFPFaaOtdL+Bau9oBTjjOLp2CXD08NkEQBDE4+P1+PPDAAwCAM888k1u3fv16AMChhx6qu29y+YYNGwbwDPsXygEmCIIgiBQMWQc4HgeiegJYcmRt0Dqv2WAcYBvfCikdwtE46jt51zlZBEsv/xcA2skBJgiC6BfmzJmDr7/+ukf7zJs3D1deeaVmucPhwG9/+1sAQHt7O1asWAG73Y5zzz0Xv/vd77ht9+7dCwCorKzUfY3k8rq6uh6d22BCApggCIIgUqAVwIPvAMfiIgzRALRNNYCMRA5wpqAVngUGRTCzOcDphinXO/yIq1oGuwKSANarAA2QA0wQRAJRBIKuwT6LnpORB+i0MOpP9FokAcCePXswbtw4eX7u3LncfDpMmDBBd7nP58PLL7/MLbvooovw1FNPITMzk1vu9UpdBbKysnSPZbPZAAAejzb1ZqhCApggCIIgUhBUhTzv6yrQb67ciw2NLvzy+GpUFdmwucmFq+b/gDKTDx/qbK84wFpBWpmpiNHehEDvadf2h/SGoghH4ykdYMoBJggCgCR+H6oa7LPoObfXAZn5A/oSqdogZWdnc/N33HFHv71mZWUlRFGEKIpoaGjA559/jj/84Q+YNm0aFi1alDLceX+BBDBBEARBpIDtAQzsWwd4a7MbdyzYCABodATw8lVH4oWle9DqDsEIJ6DTXSgjkQOcpRMCLYTc8nRvimCp83+TuAIRzgEeW5iFvYlQaXKACYIgumYw2wcJgoAxY8bgqquuwrRp0zB79mz8/Oc/x7p162RnOinE/X5t4UVAcpMBICcnZ9+cdD9AApggCIIgUhCMDl4RrK3NimBduacTsbiILU3SMr0QZ0BygKsLLbAmcnM5gsrx2BDodHOAd3foC2CnP4wWtxJeffDoXFkAkwNMEATRPzz44IPYtm1bj/a55pprcOyxx6a17RFHHIHJkydjw4YN2LNnD6qrqwEAY8eOBQA0NDTo7pdcXlU1fBx+EsAEQRAEkYKgygFWC+KBhHVPA5EYdrV7satdysVKOr1qrEIEVx1RCujVSWHy74qYEOhOXxixuAijoes8t9pUAljlAB88Og+LNrbI70EUxZQ5bgRBjBAy8qRw4uFGRt5gn4HMJ5980uMiWHPmzElbAANAcXExAKkwVlIAz5gxAwCwZs0a3X2Sy6dPn96jcxtMSAATBEEQRAo0RbC6cIBFUUQoGkeG2dgvr92hCk3+34ZmRBNVqDJ1QpwBSRiX5qUQm4wALmQc4LgoubhF2Va9vWTUPYCTOHxhLgf44FHKA2M4Foc7GEVeprnLYxMEsZ8jCAOeS7u/s2TJkgE9vtvtxtq1ayEIAg444AB5+dy5c2EwGLB06VK0tbWhtLRUXhcKhfDRRx/BaDTijDPOGNDz60+oDzBBEARBpEBdBCtVGyRPMIIf/fMbHH7/F/hya2u/vHanKn/2g3WN8nSmkMIBRgRjslOIdEYA51hNsBiVR4DuwqAD4Rjn8o7KUxKQ6x0B+BmnfEpFDucm2ykMmiAIYkjwwgsvYPfu3ZrljY2N+MlPfgKPx4MzzzyTE7kVFRW49NJLEQ6HccMNNyAajcrrbrvtNrS3t+Oyyy7j9hnqkANMEARBEClQO8BqQZzk400tqGmTwpNf/r4OJx9Y1ufXtqtEaZ1dKUCS0gEWwijP7F4AC4KAomyLLGo7vGFM7OKUl+5sl6ctJgMOGpWHpsS+m5uU41qMBhTbrCi0WdDuCcnHri5JfWyCIAhi3/Daa6/h2muvxUEHHYQpU6bAbDajvr4eq1evRigUwtSpU/Hcc89p9nvsscewfPlyvPvuu5gyZQoOP/xwbN68GZs2bcLEiRPx6KOPDsK76T3kABMEQRBECtRtj0LRGERR1GzX7FTc0Q5P/zieagHMkioHOMcYgyUW0F2HEN+Ds9CWXiVoURTxryW75PkTJ5egiNl3fb1Tnh5blAWDQUBxNttmiRxggiCIocDvf/97XHXVVQCAxYsX491338X27dsxa9YsPPHEE1i9ejUqKio0+xUXF2PlypX49a9/jXA4jPfeew8ulws33XQTVq5cicLCwn39VvoEOcAEQRAEkQK1AI6LQCQmwmLi82zZaseugE4F5p4Q8gK7voLJHQCQrbtJqhDobFMUiOi3qmAdYABczm9XIdDf77JzIveGOROwaGOzPL+L6Q9cVZgFgK8yTZWgCYIYyegNmna1fCA588wzceaZZ/Zq38LCQjzxxBN44okn+vms9j3kABMEQRBECtR9gAH9PGBW5Ln7KoDfvQb47+V4Pngr8uDV3STboAjWGHMrzzJEgDCzj8Dc5lUCuNjGitTUAvhfS2rk6eMmFmPGmHzkZ1l0t60qsgEA5xB3dWyCIAiC2NeQACYIgiCIFOi1PQpFtTm27UzYsycURSze85H9SCyOrZvXAzs+BgAUCh6cbNC2ncjJMGFSgVJp2ina5OlMIQqEGQc4u1yZDrqBuHLuXAh0Cpd2fb0T39XY5fnr54wHAORn6Vd1HlecdIAVd5kcYIIgCGIoQQKYIAiCIFIQCGvFrjosGtCKPE+wZy5wLC7iqvk/4H+vP8Utn2Ncz80fb1iPe2zv42CLEoLsFJUwaYsYBsJMu6JcNpdL5NzhdEKg2VDnmWPzMbu6CABQkEIAJx3gcqZK9CebWkgEEwRBEEMGEsAEQRAEkQI9savnAKvDfLvLA67v9OOal3/A799ej3ZPCM99sxtLd3bgbOMybrvjDBthQBzZ8OMR89N4xfIQ/s/3OqZ2fCxv42TyhM1imA+BzlEVM2HCoIuyWQdYXwBvYio8n3FwBQRByn3Oy9QPgR5XJDnAcw8uR4ZZesSw+8L4w3sbByXfjSAIgiDUUBEsgiAIgkiBrgBWtUIKhGPwhqLcsu4E8JNf7cQXW9sAAMt22dHuCWGysBeTDQ3cdgWCF6caV+EO4xsYZ9DvL+xgHGBDLMQXwcrIB8w2IJJwhYMuAGMASHm6BXDjWMMmNHiO1BxXFEVsbnLL8weNypWn9UKgjQYBo/IzAQCVBVm48/QDcc+HmwEAn25uxfvrGnHezMoUnwhBEARB7BtIABMEQRBECtR9gAEmL7hpHdC2BR2j5mq2cQeimmUs6xJVlQ2I4yLvKxhnaEW2Qb990ePmp2FN0fYIAOYcMhnYuBYAIMRCUhXpJBYbkJGnEsASJdYo3rXci2pDC2p9FUDsTMCoPBY0u4Jw+hUhP5URwAU6RbAqCzJhNiqBZZfPqsJnW1rkHOKHPt6Ocw8ZLbvIBEEQBDEYUAg0QRAEQaRATwCHInFgzzfACycD71+P7IU3aLbpygGOxUXU2SWX9keGVfiN6T2cY1yGk41r5W32iiXydFfiFwBMtiLVSXcq05YsSQDLJ684uuM2PoFqQ4s0jWZEWjZzh2Hd39H5mVzlZz0HOJn/m8RgEPDAudPk+RZ3sNuBAYIgCIIYaEgAEwRBEEQKghFtvm/M3wm8dx0Ql8RcQd3HmCns5LZJCmC9vNdGR0DOI55l2KpZHxcF/Cnyc81y76ijETnpXu1JZhXw836lajMsNiAzX5n3SIIXzeuRs+55brfA7uXc/GYm/5cNfwaADLNRzvFNksz/ZRlbmAWTQXF8O3xUDIsg9kfYyA7K9yf0YL8Xgx0JRAKYIAiCIFKgzQEWMX7FHwF3I7f0t6Z3uHlXIIKVezpx1F+/xDlPfctVWd7VroQoH2HeI0/HDZKr+nLsVCyJz0CrmK8c0JSB7AuegrlqlvYkM7sQwGYbUDxRmW/dBMRjwEe/gSDy7y1e/wM3zzrAU1UCGADyVYWwxhZqBbDBIKjaLVFPYILYHxEEAUaj1J4tFKKBLkJL8nthNBpJABMEQRDEUEUtgE82rEFFwyea7Y43bsThwjZ53hWI4MVvd6PNE8L6Bhfufn+TvK6mTRLAJkQxSVQEcMM57+CQ4L9xX/QKAAI+is1WXmDOnUDReGDUIYBBVb4jIx8A8zDhUznA5dOV+eYNUvh2kxJuLW/awvcc3sIJ4Dz15pow6HGqEOgkbLulVP2GCYIY/mRlSYNgHo9nkM+EGIokvxc2m/69Yl9CRbAIgiAIIgXqHOATDeuUmbFHA2IMqF8BAPit6V38NPIHAIA7GMGnm5WqzQs3NuPvoShsVpPsAE8W6mFBIlfYYEbJxCPhxGJ5n4ejF6NTzMWPjpyGmcfcKC00ZwLl03gBa84CTBlANFFESx0CnX+QMt+6Cdi9RJ6tN47BmFg9ACDLvQsIOIHMfDh8YTQ6laJcB5VrH1g0ArhY6wADQDHTbqkjRb9hgiCGP7m5ufB4POjs7ITJZEJubq7sChMjl1gsBrfbjc5OqT5FTk7OIJ8RCWCCIAiC0LLsSaBuGarDx2INxsmLRwmMuDzwx0DZVOCVcwAAxxg3IysShB8ZcAUiyDQbOQH93tpGXDarShbAMwy7lWOVH4zMrCyU5FjR7pFc0hAseDp2Do6ZehTAhotVHqkSwJmAyaoI4GTFZ0ASwGVTAcEAiHGpRdL6N+XV3+fOha3zDRQK0jm5d63AWsuhiDC9ju/P+A9GPX01cPSNwEl/lJezIdCCILU+0qOIC4EmB5gg9ldycnKQl5cHl8uFtrY2tLW1DfYpEUOM/Pz8ISGAKQSaIAiCIFia1gKf/RHYvggPGJ7lVnECOK8SqDqGW58LSXw6fGGlXVKC+ctqIYqiHAI9XdjFHPhQAECVTh5tUbaq5VDlEfy8OUsSwXpYbFIl6OLJyjJvizzZmn8o1sfHy/NvvLcAV7y0Ete8sgoAUAg3foJFEKIBYOmjQFAJiy6wKQ7wqLxMZJj1nR4+BJocYILYXxEEAeXl5SgvL4fVau1+B2LEYLVaUV5ejrKyskHP/wXIASYIgiAInrpl8uSBhr0oQydaUQgAGCV0KNvlVQJGM0KwyK2KsoUAIAK7231QF0KtafPiw/VNcCR663IO8OjDAEiFpFbVObj92CJSAIAxKgEMSA6wHuZE6HLFdKBdVXHanIVA8TSs3TERJxrXAwAmhLdzm1QIdhiQeCNiDOjcLeUhA8hjHGC9AlhJWAFvpyrQBLFfYzAYUFBQgIKCAoiiSBWhCQiCMCRELwsJYIIgCIJgaVrHzR5t2Iz34schB37kCkpeLPLGAAA8YiasgiSAcyCtb3EHdQ/910WSCM1EEJMM9cqK0ZIDPEZHSBZmqQRwfpXk6HZsl9zf0ilSDrAelqQAngFseItfV3k4CnJsWCoqDvBMw04AIpJFtUoFJ7+PvUYWwAePVipDHzFOVYmaodimiPOOHjjAn2xqwVs/7MXFR4zB3IMr0t6PIIihwVAUPgQBkAAmCIIgCJ7m9dxsUgBz7q/RCmQVwx+OwitmoFiQeubahCDQheHR6pYc0KlCLYzJDc02oHgSAK2TWpBlhsmoylYSBOCiV4C1rwITTwUy8roQwInjVczQrht7NIqyLVjHhEAXCl6MFdqwVywDABxg9fDvp1NxredOLceffnwQ3MEIrjmuOuV75hzgNHOAg5EYfv/2enhCUazY04ljJhQjJ8Pc/Y4EQRAE0Q0kgAmCIAgiScgLdOzgFh1t3AxERYxWhz8bDOjwBOGFkn+bjQDUzKouRCgax9q9TnkZF/486hDAIOXPVhXxAlgT/pykdApw2gPKfEoBnC39Xz5Nu67qaBRFrXAjG7viFRhvaAYAHCFsx+2Xno7yPCsO2rEB+I7Zx67kLZuMBlx17AH6r8vA5QCnWQW6xRWEJxQFAPjDMWxucmNWdVFa+xIEQRBEV1ARLIIgCIJI0rIRagt3tGBHldCqLYAFoN0b4gRwjuDXHLI0JwO3/mgyt+wgQ50yM2qmPKl2gFnx2CXmFALYnDheRh5QwIhVgwmoPEKu0LwyPkVedZRhKw4Zm4/DqgqRGe4AR+cudEvIAzYBmq0C7fRHEInFuc394ajmEG0e3ine1Ojq/nUJgiAIIg1IABMEQRBEkuZ1uouPNmxWOcBS/m+7JwSvqIhPG7S5v6U5VhwzoQhHjiuUl3HHKpogT5bkWJFhVm7NRakcYDV6DrBg5ItjsWHQo2YCliw5PHl5/EB51dGmrRiVlzieR6kYDYBzgHX57gngwbHAS3OBqCRi1VWsHYwL/Lu312PqPZ/i3g83c9u0efjPcSMrgL/8C/DiaUDtt12fC0EQBEHoQAKYIAiCIJIw+b8ilOItxxg26zrAHSoHuMCoFcBluRkQBAG3nDpJXlYB7bEAqWgM6wJrWiClQq8KtCWb7x884WRlevIZAJQQ6+Xxg+RVlWiD4EoU6PK28scMdAL+Tv1zEEXg20elfsP1y4FtCwEAWRYTsixKi6RkIazd7V68s7oBogi8/H0t3MGIvE2bm3eAZQHctA5Y+g/p+J//Sf88CIIgCKILSAATBEEQRBKmAnRb5Wny9GzDZlQK7fL84hYLjnnwK/zx/U3wiooALjJrc1xLcyVxOqu6CJccMQYC4hhlZFod5Y7mtucEsC3NEGiTTh/gZAXoJIf8FDj9YeBHfwFm/woAYDUZkWM1oRWF2B0vV7ZNuqselQAGuEJYHO5GIMC8ry3vy5N6rZCW7VIGAUQRaHQo+dOtKgd4d7sPnmAE6NipLHTWgyAIgiB6CglggiAIghBFIOyTWgsl2Fn9M8REyUEtEjyYLijC76VNMTQ6JcHWnQNckqOI2AcvmI4Nvz8UZlFxO5HHC+DzD5UcYZNBwOnTypEWeg7wuGP4eYMROOoXwDE3cdvrhUGj9lvpM1E7wEDqMOhWPowZOz6TPlPwQt6ecIC/323nNm9yKgK43a2tFr25yc2fT8itfx4EQRAE0QUkgAmCIIiRzY5Pgb9VAv+YJIXvAoDZhuacqVgnKvm5ZiEmT9fHlXxe1gHONWiFW2kOn5+bE2REnCVHKlDFcMa0Ciz53Rwsu+MkTCnPRVqYVQ6wYACO/31auyYLbS2PT1UW1i4Fgk4gptO2KFUhrNZN/Hw0AOz8DABQzDjAHd4QRFHECpUAbmQEsLoIFgBsaHBiwzZlgALRIBBNv68wQRAEQQAkgAmCIIiRztcPAWGv9C9J+TQEo8CSmE7/XADNotKSxwdF4OYK2jZIyRBoGXejMs3k/7KMK7ahNDdFZWc9BNXtfNpFQMlk/W1VFNl0HGDnXqBhlf4O6TrAALD5/cRr8K2QdrZ55VzgJLwADiIHfEXtJ7+qQc0eVfg1+zcjCIIgiDQgAUwQBEGMXIJuLu9X5oDjEYjEsCR+iGZVu5iLECTRKAjAjAlj5HXZKgGcaZZybDlcDcq0Kvy510RVjumc29PeNRkC3YYCNBmZ89n4jv4O9hr95XoCeOdnQNjP5wB7Q/h+l12zKZsDfKnrRWzMuAbPmx9Bsi2VJxhFKRz8TkFqj0QQBEH0DBLABEEQxMhl73JATIQ2Z+QDx94CzLkLOOY3CEbi2CSOQ7vIhyE3icXy9JHjCnHuUUoP3SyRF8CluVYIbCVmgBfAuf0kgKtPUKYPvxoorE571wMrlPdnLzlKWZGo4gwAMDLVqDt3c31+AQCRIF+gSkhUfY74gZrPuX7Gdm9YVwAnc4BDQT8uE/8HAPiRcTWqhWZ5m1LBye8U8nTxzgiCIAhCi6n7TQiCIAhiaBCKxmA1GbvfMF1qv1Gmxx0LnHKPPBuIxCDCgG/iM3CBcam8vJERwIU2i9RuKEGmyIftluboFKdKIwS6x0z5MXD2k5KjfeQverTrhYeNQYsriGhcxKSyk4GPFkgrwoy4HH04sHeZNB1yA74OILtEWd+xXRlIMFqBSacBWz+U5pvWorj4cJxtWIaTjWvwreMCfO4ZqzmPZAi0o3EHypl86/HmTuwOjwIAlAgqx5cEMEEQBNFDyAEmCIIghjyiKOLq+T9g2j2f4YWlKdrw9IZkux8AGHcctyoQlkSYOg+4icn/LbBZAKvioFpjPm5bdQEsAICLEcD95QAbjMChPwOOvhEwpdk7OEGmxYjb5k7BXWccCGvVLP2NSqdIDnkSdSGslk38tmVMQS1HLSoEJx4xP4NzjMvwa8eDcPq1xavaPCGEo3H4mrZzyw8vlCprWxBBgcDn/DocWieZIAiCILqCBDBBEAQx5Nnc5MaX29oQjsXx2Bc7EYuL3e/UHUEX0LxemT+AF8ChqCSAv4lPR5y5XbIh0IVZFsCaI89bYrwDXLKvHOD+omg8L3STZJcBhQco8+oevGz+b9nBQAGzbeceVAS2y1W0xxraUSVIlbDZ8GtRBFpcQUTamFBqAHPHxJCXacasshjUrK/Zm977IgiCIIgEJIAJgiCIIU870xbHG4pid3s/VP+t+15pe5RZCJQcyK1OOsAuZGO3TXGBt4pK+K7kACsh0MZ4CGZE5fkydSXnWBTwKDmtQ04ACwJQeYR2eXYZf64ulfBkWyCVTeXFsqMW+QF++8OEHQCAcw8ZxYWJNzj9MKrc5SqzA+v+9CO8cmGV5rS21TV184YIgiAIgocEcDcEAgH86U9/wqRJk5CRkYFRo0bhqquuQmNjY/c7M4wbNw6CIKT8t23btgF6BwRBEMMfhypkdn2DC4gEgFXzpFY76qJM6VCr5PVi3LGAgb8lBiKK4/j5AbdjYexI/DNyAb6PHyQvL7SZOQcYAGxQCmFpcoA9zYroBoDcUT0/74FGTwDnlAN5SrVrrpCXKGoFcME4ZT7ohK1tLXe4www7UZxtweWzqzAqX+lh3OQMIsOzh39td5NUSMzTojktp8MOlz8CAPhmRzteWLpbnicIgiAIPagIVhcEg0GcdNJJWL58OSoqKnDOOeegtrYW8+bNw//+9z8sX74c1dXpV9oEgCuuuEJ3eV5eXn+cMkEQxH6JUyVq1tc78X/+/wJf3ict+Om7wMRTenZQTgAfp1kdjChCNV40Eb+K3KzZpiCLL4IFANlCEE4xB4CIyZ7vgR9cwPRLJKeYDX/OKgLMmRhyVB6uXaZxgBkB7G0F/EwubtnBifdmAyJSTrRhz2LucIcaduCGOROQZTFhdEEm1tU7AUitkPL8dfxrJ3Omva3a0xICsPtCaPME8bOXVgIAdrZ68dD/TU/vvRIEQRAjDhLAXXD//fdj+fLlmD17Nj777DNkZ0sPOY8++ihuvfVWXHXVVViyZEmPjjl//vz+P1GCIIj9HHXRpA0NTsCjCFjPzqX4NjgVcyaXItOSRpXooBto2ajMjztWswnrAOdlmnUPU2SzSgWoGLGXjQAOFXbgbvNrOHhJomdu/Q/A+f8emBZI/c3ow7TLcspTC+DG1cx2owBbIke6YBzQlsgNVvXrnSw04IAZ+dLLMQ6w3d6B3Ggn/9ruRJizjgDOgR/uYBQfrlNCod9aVY8HL5imbT9FEARBEKAQ6JSEw2E89dRTAIB//etfsvgFgFtuuQXTp0/H119/jdWrV6c6BEEQBNFPOFQO8NZmD+KMCPti1WZc/581+PUba9I7YONqJRQ5Iw8omaLZJMQI4NwUArjAlljOhEFfYPke71juw0xDjbLhxrclIccVwGJCiocSmflA8WRmgQDYSlKHQDesUqYrGfHM5gGrMAgiMlqlvxUrgEV7jXbjkEtqd6QTAp0tBOAORGAx8Y8zre6QZluCIAiCAEgAp+S7776Dy+XC+PHjMXPmTM36//u//wMAfPTRR/v61AiCIEYczgAvgMOxOESX4vplRRwAgK93tENMkQ/sCUawcEMzdrZ6gPqVyorKIzT5vwDvAGeZjbCatNsU2hIthxgBfHnGtzAIqnMQY8CaV/gWSHlD1AEG+DzgrCLAaOYFcMituLqNjAAezYRPs3nAeiT+BqwAtrpStLhyNwPeNs3iHATg9Qcx0b0clYKyflOjS7MtQRAEQQAUAp2S9eul1hiHHnqo7vrk8g0bNvTouA8//DB27doFq9WKqVOn4rzzzkNJSUnfTpYgCGI/Rx0CnQM/jBGlEnSh4AYARGIifOEYsq3K7U0URXywrgkPLNqKdk8IJoOATZO+h1yfecxRuq/JCuBMiySAQ1ElL9hqMiDTnAi3ZipBZ4SYfNiCcYCjVppe/TJQweSmDtUQaEDKA173mjSdWyH9bysGjFYglnBXXQ1S/nPjWn6/JN0K4BUAwBXByvXXAXoR7O4GwKvjACOAvI2PY+qu53GWxYjjQo+jFYXY1OTCKQeVdfMmCYIgiJEICeAU7N0rtWyorNRvUZFcXldXp7s+Fbfddhs3/9vf/hZPPvkkrrrqql6cJUEQxMhAXQSrQrBz84XwyNMOX1gWwKIo4vrX1uCTzYp4isVjMLKupV7VY/BFsDLMBljNRiCotDgqtFmUPFNVJWiZ438PfHQzEI8AnibAx7iYQ60FEsvB5wNLH5FE7mE/l5YJgnTOyTZFrgZAMALhxGcvGICKQ5RjFOiEQNtKlc+gYRUQj2F0gSKAq9Cs3QeQwsf1HGDBj/IWqcCWRYjhGMMmLIgfTw4wQRAEkRISwCnweiVnISsrS3e9zWYDAHg8Ht31as4++2yceOKJOOyww1BSUoLdu3fjpZdewuOPP45rrrkGRUVFOOecc9I+v6lTp+ou37VrF8aPH5/2cQiCIIYD6jZIFQJfKKlYUASP0x/BmEJpele7jxO/ADBeaII5wog2vaJPAIJhxQHO0AmBLsiyKDOWFAJ41KHAgWcBmxdI83FFQKN4ov4+Q4GMPOCmdVJ15xzGSeUEcD3ga1fWlRzIOeG6OcAHnw+sfF4KCQ97AHsNcosnIdtqgjcUxQGCIoAjohFmIfE3cDXoV4FGAJkhJd83T5AKkW1qdPf4LRMEQRAjA8oB3kc88cQTOO+88zB27FhkZmZi6tSpeOSRR/DMM89AFEXcfvvtg32KBEEQQ5buHOA8wQ8TJHHJiuXaDp/mWIcZdiozpQcBGbm6r8mGQGeYjcgw87G5cv4vkNoBzqsEjriaXyYYgWNuBsqHeKseo4kXv4C2EFaqAljJbQXVY0bFDL73sacZgiAk8oBFVDMCeKuRKcTVspEfPEhQIHiRFXUqL5kQwC3uINo9VAiLIAiC0EICOAXJqs9+v193vc8n3WRzclI89KTJ1VdfjdLSUmzfvh21tbVp77d582bdf+T+EgSxvxGJxeENKeJHELQCGAAKEmHQrADe2+mHFWEIUMKZDxUYATzmyJSvGY0rhawydRzgbgWwNVcS11XHSH2ABSMw8VTg+mXAj+6T3shwQ90KKVUBLAAwWYBcVZh30QSlTRIA+DoAANMr81ACJ7KFoLxqRxZTgLKJyTNmyBf4AY48KPObmigMmiAIgtBCAjgFY8eOBQA0NDTork8ur6qq6tPrGAwGWbQ2N6fIfSIIghjBqN3fI6oKMQpaAVwkeDTbm2qXYJX1enxt+S3yEwL5UNYBrtQK4Dq7D/O/q+WWdS+As6EhKRYFQeoB/MdW4KdvA6XalkvDBlYAd+wAWrco85WHa7cvUN0jiyZILZWSJATwHadPwXXTlMV2MQcVk5njse2jjMznriKXEcSbKQ+YIAiC0IEEcApmzJgBAFizRr+nZHL59Ol9D2FzOKT2Hcm8YoIgCEKBrQBtMRpw8oGlKFflAANAUSIPmHWAD278L3KEAMYa2nFx5krkwYuJBkZMqRzgTY0unPzI13hg0VZueaZFGwLN5QDrOcDqIldG/V7Cwwr2PTWvl3J5AakatE4vZS4POLMQyCpUCWAph7go24qrpymfZ05ZNY6ZmeL+Wpg60ol1gDeSACYIgiB0IAGcgmOOOQZ5eXnYtWsX1q1bp1n/zjvvAADOOuusPr3O5s2bsX37dmRlZWHKlGHsChAEQQwQbA/g/CwzjplQjFE6IdBFyRBonyKAM0Md8vRB2X5MEpionswCoLCaO8ZbP9Rzoc8AcNzEYt0iWIU2RtBadfKIh3KV597C5gCzjD4UMOj0L2IrQRdNkP7nQqCZIlquennSUlSVuk2U6m/GnR7jAFMhLIIgCEIPEsApsFgsuPHGGwEAv/rVr+ScXwB49NFHsWHDBpxwwgk47DCl6MdTTz2FKVOm4M477+SOtWjRInz11Vea19iwYQMuvPBCiKKIa665BhZL6rAugiCIkQoraAuyLDiwPAejDFoHONkL2JEIgY7HRdhiTnl9VaYfRQIjinIruTxcURSxeLvSaueMaeV48tKZePEKqU2S1aRygNkQaEsXIdD7E3kpROnMn+kvn/JjKfcZAKaeJ/2fpc0BBgA4FQGMvDFAdqmyL0vl4YiZdT5vAPmMA9zoDOC7mg7d7QiCIIiRC7VB6oI//vGP+OKLL7Bs2TJMnDgRxx13HOrq6rBixQqUlJTgpZde4rbv6OjA9u3bNbm8K1euxH333YeqqirMmDEDWVlZ2L17N9asWYNoNIo5c+bgwQcf3JdvjSAIYtjAOsB5WWYYwy5kQlvht0gWwJJgbvOEkA+vvL7c6OPaJcFWxO1f0+ZFgyMgz9971lSU5mbI8xlmlQPcbQh0Crd0OGPOlASsnxGWBeMUcaumZBJw0xrA06qEm7Mh0OxxXIw7n1eZcJR5Nx4VM4Cjfon48n/DGPFCTZ7gw8TSbOxsk9b96vU1+OjGYzGmUL+lIUEQBDHyIAe4CzIyMrB48WLcfffdyMrKwvvvv4+6ujpceeWVWLNmDaqrU4dhsZx22mm46qqrkJubi++++w7vvPMOampqcOyxx+L555/HF198gczMzAF+NwRBEMMTNge4IMsMuBp1tyuCO7G9JJjrO1zIFZRK/tkxJwrB9G5nhRjAub8Hj87lxC/QjQOsJ4BThfAOdwyqsfNjfyu1TEpFwThg7FGK266TAwxAK4ABbZGyS98ELLaUbafyBB8evegQOVzd6Y/g2ldWIcD0dCYIgiBGNuQAd0NmZib+/Oc/489//nO3295777249957Nctnz56N2bNnD8DZEQRB7P84mKrO+ZkWviIwQ6HAt0FqaWni1lvCnSgSCuR5MasYbCOir7YpAvjEyaWa41tVDnBRulWg9zeyigBvizI/49Ke7a/TBgmiyOUAIz/hns+4BKhfLuVrX7ZA7iEsZOTpHtqKCKaVWfDQBdNx81vrAADbWjx4f10jLj1ybM/OkyAIgtgvIQeYIAiCGNKwbY3ybeYuBDDvAHd2tHDrTcFOLgc4nKGEQLuDEayqdcjzJ07RCmB1Feh8LgRaXQRLkMXafsfMnyrTZ/wDMFl7tj/rAIfcQCQIBJ1AmAlpToaPH/5z4DcbgJvWSoW2EhgzdIqOJQk4ce7M0Tj3EOXzp4rQBEEQRBJygAmCIIghDR8CbeFCoDvFbBQKknBKhkB7Q1GEo3G47bwANgSdKBMUkes3FyAp3b7d2SFXfy60WTCjMl9zHmwV6ByrCRa2KrQ6JDenYv9oe6THEddKYcimTGD6RT3fn3WAASkPOKD8XWDKlFzmJOpewgCEDP0QaACSmM6twGFVBXh/nRQFUNOmzRcmCIIgRibkABMEQRBDGs4BzuQd4M2i0maHdXedgTACTiWkOclEQQmL9hrzpWM0ufDkVzXy8hMmlcBoENS7cgKYy/8FtFWg99fwZwAwWYDDrgRmXMxV0U5/fyvvmPs6VBWgK7s/boocYABAwAkAGF+q/E12kQAmCIIgEpAAJgiCIIY0DsYBzs/ic4BnHnmCsk7wwYQoAEk0R7zaXsH5giKEXIZ8PPbFDpz15LfY2qyI51MOLNM9DzYEWiuAbQCbUbw/C+D+QJ0HrFcAqyus+jnAAGQ3eQIjgO2+MNdOiyAIghi5kAAmCIIghjSsA6yuAp097jBu24JE26NGZwDmkANdscufice+2Ik402nngkMrcca0ct3tS3KUXNcxBarK/YLAu5Kp+uUSEupK0C6VA9wdXTnAQScAoCTbitwMJdOrpp1cYIIgCIIEMEEQBDHEcQYYBzjDyIul4kmAWenxmgyD3tjgkqtCp2J1u+LoZpqNmP/zI/DIRTMgpAi/PW1qOU49qAzTRufh+jnjtRtwAng/7AHcn3QpgNP47NIIgRYEgcKgCYIgCA1UBIsgCIIYsgQjMQQjcXm+SLQDMSaUtWAckFUMuPYCSFSCFoENDU6cLqQWPEHRjA1tUXm+usSGOTqtj1gyzEY897PDU2+QVaSEZxeM6/JYIx62yJWvnQ+Bzu+jAE44wAAwoSQba/dK81QIa/+lvtOP8rwMmI3k6xAE0T10pSAIgiCGLGz4MwDkBpkWSLZSqf+uTRFTyUrQ6+pdKEBqB7gDedjBCKKKvMyU26bN7BslN3rsbGD8SX0/3v4M6wD77T3PAe6mDVISNg9YHQIdjsYRicVBDG/+tbgGx/19MU5+5GuEorHBPh2CIIYB5AATBEEQQxa2AFaWxQiLq05ZmXRZGTGVDIHu8IZQaEktgO1iLvxh5WF5VH5G3092xsXA1HN73hd3JMIKYHcj4GFaVvUiBzguCjAIiWRu1gFmBTAz4LFmrwNXvrQSNqsJb183G5UFShg9Mbx4Z7U0eLK3048Vuztx/KSSbvYgCGKkQw4wQRAEMWRxqHsAO2qVlUkBnKVUFC5kWiHlI3XIq13kHcR+cYABEr/pwlaBbl4PIFmJTABy0yggZuX/fg0iczzGAR5fogjgRmcAgWAI2PA21n4yH55gGM2uID5Y1wRi+OIJKlEi7mCkiy0JgiAkSAATBDHy2PUV8MwxwMJbAVHsfnti0HAxIdB5mWZeABcmegBzIdCK69tVEaxOqAVwPzjARPqwDnCAqdadXZbeIILKAd4pMq4xc7wxhVmwJPo3iyLg+O5FYME1uLrpXpxpWAEAsHuHcHukoGuwz2DI4wspkRzeYLSLLQmCICRIABMEMfL48s9A6ybghxeAhh8G+2yILnCwLZBsZsCxR1nZRQi0CVHkCv6Ux+3QOMAkgPcpthRhqun2T1Y5wDXiKGWGCYE2GgRUF9vkeaHmC3n6aMMmAMCBTQuAF08DNr+X3mvvK/73W+DBscD7Nwz2mQxZYnERgQgjgEMkgAmC6B4SwARBjDzYgjv2XYN3HkS3sCHQ+ZnqEOikA6xUby4VJPcvH74uj6sOgR6V308h0ER6sCHQLOlWz1Y5wDUiEzbNhEAD4FohWR075enRgh358ODc5seA+uXARzcD8SFSRCnoAlbNk6bX/Qfwdw7u+QxR/GFe8LJuMEEQRCpIABMEMfIIKnmi8LYO3nkQ3dLpUwRwmTUsVQxOkhRLuRXKNgkBXNBND2BWAAsCUJZLDvA+JbMQgE6/5Wn/l97+1hwE8ycAAJrFQmyOj1PWBZ1cakMyD9iCCPKDyuDXKMGOaqEZZkSU/VRCMx4XYfeG0jolhy+MX/1nDa5/bXXa+6TE3QwlLxqcq00osIXsAMAXJgeYIIjuIQFMEMTIIhIEYszDaR8FsN0b4kQa0b/sZlrXHJTBiBNThpQvCgA5SvhrKZwQEEch2wLJou0Zy+YAF2db5TxRYh9hNAFZhfyysmnApLnp7S8I6DzrZfw9chGuDN+GdjFPWRcLA5GAPDsx4QAfIDTDAKXtUYVgxxihjT+uT5kPRWM444mlOPyBL/DC0t3dntKbP9Rj4cZmfLypBa8ur+t2+y7xNHOzDS1tEKlegQZ1yDOFQBMEkQ50xycIYmShLirTBwG8us6B2X/7Ckf99Qus2evofgeix+xkWtdMsnYoKwrGAYbELYxxgM1CDMVwI591gAuqAIOZOy6bAzyK8n8Hh4DqN3P87yQ7Pk2yKibh6di52C6OhRs2fiXjmB48WhLHEwS+2nO2EMRUg0qo+trlyW92dGBbiweiiLQEbb1DyTmv7eg6BL9b2LZQAG559Vt8uJ6qVavxq0KeqQgWQRDpQAKYIIiRhVoAe3ovgD9a34RwLI5ITMR7axr7eGKEGn84ikan4uSNAePWsbmi1hzO5S0TOvkK0FmFmpxTO+MYlpMAHhwy8vn5A8/u0e7ZVpM8HYIFIViUlUwe8LiiLORmmDDRwOT+JzjKsJVf4FMGWXa0Kt+hdKI8fIz7yBZv6xUqB9gmBPGbN9f17Zj7IWrH10cOMEEQaUACmCCIkUXIzc/3wQF2MgWa2jzBXh+H0Gd3u09O5cwwG5AXZAYZ1MWSGBe4XHCggA2BziriegUDQCcUwdxvPYCJnnHoz5TpC+crjn6amIwGTgT7jUyoO+MuC4KAGWPyMUHQDlIdLOzhFzAO8PYW5TvkCUYRi3cdgswWYGKvDb1CdV3KhjQQFI3F9bYesaiLYPVXCLQ/HMXbq+qxuo4ie/pCbYcPt7y1Ds9+vYtC+Ikhhan7TQiCIPYj1MVk+iCA3Uy4Xbunj0VvhhHtnhAyzAbkZJi737gP7GxTBEh1cTYMzlplZbICdJLcUUDHDgBAudCJAkEJnUZWEWBTHmS9yOTcwlH55AAPCifcDuRUSIMXB53Tq0PkZphk0RM05QKxRJE01e985ph8TKjThhAbBdVDeQoBDACeYAT5WRakgnUfO/sqgHUcYADY3urB1FF5enuMSHwDVATrH5/uwEvf7YEgAF/ecgKqS7K734nQcP/CLfhiqxS5U11sw6lTywf5jAhCghxggiBGFuoQ6JAbCKfuF9sVnqAS5tje16qvw4QvtrTiqL9+gVl//RJ19j7mOXZDDZP/O7EsG+jU6QGchCmEVSF0oipTCZ1WO8BOgRcQ5AAPEpYsYNZ1vRa/ALhBmLCJdYCd3HaHjM5GtZBGDm1CAIejcexiCrABgCvQdVgzK76cvr6GQPM5wEkHeO1eZ9+OO4h056D3BnXIc3+1Qfp6hyTaRBH4oZZaUPUW9vv6zmptCgJBDBYkgAmCGFkE3dplvXSBPSoHeCSEeL35Qz3iouS8LNrY0v0OfWBnKyOAizMAV72ysosQ6GtmZOBHVYw7ncnnAHuM+dyu5AAPX3IzlUC2qIUZ2FA5wIdkO2ER0hBHXkkA19p9iKoEmzvQtbvIht96QlFE+hKurHKAs4XhK4DjcRFXvLQSh/z5M3ywrn9rJagFcH+EQIuiiAaHMoDW3cAHoY/dG4KdyZ1fsr0drr7mxhNEP0ECmCCIkYXaAQb6RQAHI3F4RkABFrYolTMwsO2fahgH7uAcHxBnPt+CKn7jHEUAWwOtEAKMa5NVxAlgn6mA25Uc4OFLAROSHM9gBLDKAS70d9/GCIDsAKvDn4HuhZC6IrGjt2HQoqhxgG2QQqDXDsNq86vqHPh6Rzs8wSj+tbimX4+t7gPcH1Wg270hhKLK4AUJ4N7BRvAAQDgWx6JNzSm2Joh9CwlggiBGFv0ogN2qB6ORkAfcyLR6GciWI6FoDHV25bUmZLBFrYoBs0q05ioh0HA3A347s30hcNB5gFESS+vyT5VXGQSgNMfar+dO7DsuOXIMLCYDirMtGF3BfAd8qv6+7dvlSbfYxYBHQgCzFaCTdBsCrRoAc/bW7Qo4pF7GDLZECPTuDh8cw6zvOFtBu9nVv8UC1Z95IBLrc6g16/4CJIB7S40qhQAA3l9L3RKIoQEJYIIgRhbqKtBAr1ohxeMivKqCK/u7APYEI1zhL09fBPDe5cDeFUCKsPHaDr/8IGsyCCg3OJWVjNuru8zdyA9qZBUBxROAW7cDv1mPXaWnyKtKczJgMtKtcLhy0pQy/PCHU7DsjpORVTFZWdGmam/ECODv4genPmCiDVJPHWBRFDUFmHotVD1alyxbUITjugZn7447SAQjikvrCUYRjvZfJWu9old9LYRV38nXhHB1E/pO6MOmsCRZsacTTc6AztYEsW+huz5BECOLfnKAveGoRrvt7wK4ycm7N2wRsB6x5QPgpdOAl04Fti3U3YQNnzug2AaTj/kb5ZRpd2Ad4LAXiCQeYg1moHiSNJ1VCBSMQ26mkh9cQfm/w568TDMsJgNQPl1Z2LIJiDPhsR2KAP4mzmynJuIDwr4eO8CBSAxq47HXIdB6AhiKaFg7zFrzBCL9FBqugzrsHOh7L2BygPsHdRG5JB+uT6MYHUEMMCSACYIYWegK4J4Xc1KHPwMjQQDzD4a9doDXvaFM7/xMdxO2BdLEsmxeFOTotNKwlQCCUbt81CFStWGGshxF9I4rsqV1ysQwoPQgAII0HfHxVcMddfLk9vgY2MUcpCLobEVdp7YyvLuLAR+96sOO3oZAe7TXIxvjAC/e3o5tLW7EU4T6hqKxIVWQL6DK07V7+08A6xW9IgE8NGAd4EPG5MvT39V07NPzWFfvxO3vbMDi7W3db0yMGEgAEwQxstCtAt3zG6Oe+GsbZgLY4Qv36GGxoR8EcDwWg6/mW+Yg+oMPOxkHeEJJNr+dXgi0wagvjMfO0iw6d+ZoTBudhzGFmbj62AO0+xDDE2s2UDRemW/ZIP0fdHFVoRtQCq81dT/S+oY63cj8roSQ3u+osz9DoBkHeGOjC3MfW4pzn/4OflW47+dbWnHYX77A6Y8v7bMQ7C/UDnCvPxcd1EWwAMCbohVSLC6mVZm7wcEPfnhIAPcYTzCCFrcyaHPJEWPkab3oioFCFEXc+PoavLWqHte/thodI6RdIdE9JIAJghi2fLKpGf9aXNOzEXo9BziFCOsKPfE3nBzg99Y24ND7P8cJDy/GunpnWvtoHeCePxhuXr8StjjzAKTzsA8ANYx7MKEsp3sHGNAXxmNnaxYV2iz46NfH4pvfn4iDR+dp9yGGL1wY9EbpfyfTPsuUgSX3XoSq6sncbmFBKYTWuXcL7jPNw+9Nb8IKRax1dZ3RcyKdbKhvJCgVt0oHnZoENgRhs/ARDhsaXPh8C7/tc9/sgjcUxbYWDxZuHBoVd0MqAWz39d91Ui/fV684X4sriDn/WIyj/vplt5W0yQHuO2wKi81ixPGTSuT5Vndon7VD6vCG5b9nMBLH8t32bvYgRgokgImhgSimLIbTK5rXAzVfAvH+K7ZBDC0+XN+E615bg4c/3Y4HFm5Jf0fdEOjeOMA6IdDDZHTZG4rizx9tgShKDwg/n7cyZb4WS6PqwbA3bZ/itd/xC3QEsDcU5UKgJ5fldO8AA1wvYJkxWgc4iSAIXZ4rMQwpn6ZMywJ4r7IsbwyyrGYgr1JeFBcF1FsU5/jw9XfjCtPn+JXpQ5xt/F5erpf2kETPbZVDoB21wCOTgEemALuXdP8edItgBbDoN8fhl8dXoyJPCeFXFxra06G4l+rftCsQwdNLavC/DfswB9Nnx8y6l3CKYbW8qD8dYL3PXW8w4v11jajvDKDTF8ar39dp1ieJx0XNdc4ViPRLSHmLK4jfvLkWf120tc+Vqoc6rAAeX5qNirwM5GQoPbt3tO0bF3hvp4+bX7mnM8WWxEiDBDAx+Nh3Ac8cDTx3AuDqhxL59T8Az80BXjsfWP6vvh+vj6zZ68CdCzZi2a59m/eyP9PpC+OmN9bK819u7YGA1asC7WvjC+akgV4+4HBxgF/5vpbLT3T4I/jZiyvR6u66RUmTM4BxQjOmCnsAiPCGoinzEFOR3foDv8DXDsT4z3LdXqdcUCgnw4SJpeoQ6FQO8Ch+vngyYCvq0fkRwxxdB5gRwPljpf8ZAdyMQrQJyvfEKCrXghutSpG2rgSwXiiuXAV6/VvSwFs0CKz9T/fvQSciJVsIoKrIhjvPOBCXHDFWXr67QxEa/nCUC/Hc084//D/2xQ78/ZPtuPH1tfvOCfviTzix8Vm8YHkEkwXp79C/Aji9IljptmJq84QQVoVJR+Oi7t+3J0RjcVz7yip8sK4Jz32zG2/9UN/9TsMYVgBPKM2GIAiYVKbk3e+rMGi2lR5AAphQIAFMDD4/vAi0bZFc27Wv9f14a18FxMQNbMenfT9eH4jHRdzw2hq8sXIvrpr/A9o8/dsDcaRy//94xzdtJzIWlSoEqxHjfN/YNBiuIdDeUBTPfbNbs7zD6ULt/GuBN37CFQxiye7chCXWW7HQ+gecY/gOothNy5HdXwPf/lNx2EURpY7V2u1UVbhX1SkPKYeOLYAhGgBCjHOfrgNcpQ1/JvZzWAfY2yJ99/QEcNlUedGWeBXaRf1QeI+lVJ7uaQh0stpx2MkM7KZzndERwBmISNcvANUlSuG2XW2KyFWH7tbaeQG8oUH5DX29o7378+gP6pUBr8MMOwEA9n7NAU6vDRL79+kqBFud/5ukr2HQ85fVYmOj8vl/tqXnaTfDCbUABoBJZdnysh06bcYGArUA3tbi4VMTiBELCWBi8HExI6G9aEfDIYrAzs+V+RQP8vsKTygqF4IIRuJ4YemebvYYgrRsBNq2DfZZyCzd2Y4Fa/lIgSKbJb2d1e6vwFwCe5gHrCeA7b4QomkUWRlMXl5WC2fC/bVZjLjqGKkI1I8Ny3FU54fA9oXAf3+mccQjsTgOCSyX588wrgTQRSEsRx3w6nnAF/cCi34vLXPWISes8+Ct+uxXM21eDq8qUFXpFgBbKXTJHc3P6+T/Evs5OWX896NlI+Bk7gNJAVx9IuqnXo/PY4fhoeglaI3pV4WOZSq5i7IICmtFkp7r6PRH8NK3e/D1ms3KQqYYly7xeOqq9GFJNIwvUYTEng6fHE6r7l9ba/dzERqsg72pUScVZCDwK5FPJXACADr7sQq0ngOsNxjB5gV3dPH69QMggOs7/Xjksx3csu932bn+yPsbbBHDiaXSb4t3gLtPuekP9upUc/+hdui3EYvHxR5HVxE9gwQwMfiwI+JhX+rt0qFtC+Bh8pvcDZrwyn2Juv3De2sbh1fuz7ZFwLPHAk8fBez5ZrDPBgDwpk7omN4Djy7cw6cA5CmVKXs6+KIXAi2K/Rve199sanThmSW75PkrjxmHkw+UxMJhBqVPKprXAavnc/u2uILIhvIwUSo4AXQhgBtXA8lQ0rpE3m/d9/rbupXfbCwuYu1epzx/2LgCXiBnlwJGE3RRO8M6FaCJEQCXB7xB3wEWBDhn34lrI7eiRqxEczQbeuQZFbfQHYxC/O4J4MExwKvnczUmfDohsp3+MJ79eheKE8IPgH4NAha/HYin+E2FJNFwQLENyfT1cCwuu5bqh/1wNI4ml+IKsyJuc5N74FslxWOAX4nmSF4z+usaGY7GNeHKgH4RLHaAwuEPpxyobOgM6C7viwC+76MtmkrYoej+W5ApGIlxAwmKA6wI4J37KAe4zq59plwxxD/3FlcQJz6yBIfd/3naBSqJnkMCmBh8fExurF54ak9g3V9ACm118YLp+W9248dPLsVH+6AZuzo8q90TwuJtw6gX3dYPlentnwzeeTB06IQZ+8Np9r1kWyBl5AK5TM5oTwVwQP8hdci0Qgo4uMJytR0+XDlvpTxYkGM14Zpjq5GfZQYAlAiqB/Mv7wO8ilvb5AzABiWEvyTxMOsNpXgwZH/XvnYgGgL2LtPflhG421rc8jkaDYLUPzKdCtCA1AfWlJk4wQOB/KrU2xL7LxWqPGBOACvfidxMZSClMaIvgHOY/ruxeBxY+qgkUHd9KQ3yJEjlALd5QigG89sKOPXPOeQBFt4KzJsrL4oYMxEUzco2iftjpsWI0fmZ8uJksat6HfG2p0MRAOygXacv3GUubL8QcABQrkHJa0Z/VYFWDzDLeNukz3LJg/IgBTtI2tVApTqMPElvBbA3FMUXW5V7S3G2Um18yfaBCUNfXefAda+uxls/7NVdr34u2dTowgtLd/dbilaDIyDfekwGAWMKpO/qRCYEusMbhn0fFI3Uc4BX1g7tPOA3Vu5Fnd0Phz+Chz8dOtF3+xskgInBhwmRQqiPo4JqAQxwYdCt7iD+9vFWbGp0494PNw/4CLhe4YzXVgxuWHaPYJ03veJRg4BeflcsLiIUTSP0mHVfrHmSm5ikxyHQ+g9EQ6IS9LKngL9XA8+fCMSicPjC+NlLK+XQP6NBwGOXHIICmwWFifDxKkE1ABB0AV/9RZ5tdAaQIygPh1I4owh3KgfYp3q4czcCjUrhMp+oPAiyAnfr9m243fQGfmRYhamjcpFlMaVXARqQCl5d+jow6wbgwvkAVXkembAO8J6lfORHvlJAKjdDEZcd8VzdQ2Uy/Xfz4YUQZMInO5VoitQ9d0VZ+AGQfld69511rwM/vADYa+RFXkspvFCELnt/ZMOgk3nAeg/7tQkBHIrGEIzw18jNTQN8TWcHwdBHB1gUgdYtQET5e3hT1B84sulV6bNc8jepJgi0UUKprtP9HQK9l8lBtZoMuPmUifL8QOVh/+G9jfhkcwvuXLBR44C+9O0eTL/3M1z63HLE4iIcvjAueW457l+4Fbf+d32/vD5biK0o2wKTUZIaJdlWFGQpv7mBDoP2haK64e6bGl3pR40NAlubld/l97vsw6K2yHCEBDAxuMRjfG/EvoRAB11A/XLtcketPLm73SdXl7X7wpoHgv5GHfYESDe9vXb9m+yQg3VF9QYnBjqETge9nC9Af7BBAyuAM/L4EOjOnuVnpwr9HRI3qxX/lqIfmtYCdd/i/oVbuYfjv18wHScfWAYAKMiyQEAcYwWdyIStH8mTTc4AshkxYBWiyIc3dQi0T3U8VyPgUD7j1fFJyjpG4B664hZcb/oIz5r/ibmliWtDug4wAIw/CZj7N6B0StfbEfsvbO43+z00ZXCDXmxbFjv0BbAl6kNWov+uZpCIuWakeqDOQQAZAiOe4hEgonP9b9/OzxtMWFF2CbxiGgI44QDrFXDanRDAehErA54HrCr4VZyIMnH4Iz2vlfDZH4FnZgNPHi7nYPtTfOZzOv+rzHx0EwDtAIU9RR4w6wBbTcojclcVwLuCve6OKczCiVOU79+eDp9uiG5fSf7N46LUhYLlhaW7EY2L+H63HSv3dGJdvVP+7i7fbe+XvFNWALOOtyAImLgPw6DZz95iMiA38XuPi3ydiaHGdqZCdlwEPtk0NPp572+QACYGl4BTqdgM9C0EevcS/dwppgBKs4sPb9LL4+xP9FwBUQSW7BgmYdCcA6y6WW34L/D3A4C3Lu+dEG7dDKx4jguzTYdUD5qpHRgG1sXOyANKJivz7T0LNWK/O6zROOgCWBS5Ijo1Ndvx7poGef53p07CBYcpLWAyzEaMNXv4h/QkAYccQtjoDMAm8L+fMsGR0glXuz9o3cT9vlfFmc8+mbffuAbVwU0AAKMg4kTDusT6NB1gggCk1IaSA7XL88ZwP1aT0QBbQtx2pKgCbYh4kZcpuVaaQSJmQCfVABzn/ibRywNmI6GOug64dTu+zT8LPig9f9nfz/hSphJ0uxeiKGqKYAGKA6x3r9vcNNACmL8GJKNGAHBt2LolHlNqErgb5F7KennXqfCqBk47dBzgWFxEk1O5xk2pUAZFunSAu7j/sX+TsYVZGJ2fKbV1S9DfYdDBSAxhJhpqa7Ny3xZFkUvRqbXzAjwSE9HRD+HpbJoSK4ABvhL09gGuBM1WgB5TkIkjDyiU5z9ctw97YfcAfziqieT43wYSwAMBCWBicFHdIJNFPnrFrsX6y5kQaPbmBvR+VDddUuUodVWFcsgQDQMBJldGLYC/+YckkLZ+CNSv7NmxAw5g3unAx78HFlzbo11TCd0u2/Ek4RzgXP4huX17j4Q863yy+XipBHDKfLWe4moAPr4dWPeG/vqQB4gp368lqzbI01NH5eK6E8ZrdpmakapHtShXnm10BjkHGJBCGuXPIewD1rwK1CXyfNUh0MlCWAC8Yga2i4z7nhC4/u9f4Hap9q3j1gPo3gEmCECKBFDDhD8nyU2IWy7UmEEI+7oQwLXyZKqBuRLoiEy9PGCmWBRKDwJsxfAGo6oQaOX+WF2sCInd7T50+sK6gnCP7ABr73WbGvdtCLRViCIP0vn0KAy6bQs/ON4hVVROa9AzgbpWgZ4AbnUHEWUc0IMYAZzyWWH7J8Ajk4HX/k9uU8WyVyWAAWDOZKWy+NKd/SuA1QMdbDitNxTl3l+t3YdaVTRaSz/khbPPN2oBPJl1gAc4BHpvpyLuq4ps+PF0pebHh+sb0dZN3/vBYGerV/MYsrK2E61D8FyHO/tMAEejUTQ3N2PDhg1YuXIldu3aBbd7aOQUEoOI2iXqiwPsZlrjVByiTDMPKU2qi/tAO8CpXAHXcOhDpy4KpRbA7Hr2s0+HxjWKGK39Nm3hGY+LKT/TVKHRHOoQ6BImDDfs4aoRr6rtxC9eWYX/6lSdBvgcYDYcUS2ARVHElfNW4uB7P8XTS2rQJyIB4JVzgRXPAu9fJ+XEqVENKpn90t9JEIAHzpsm52OxTLQo+zjzp/IrE4XDGh1+LgcYAErhVD6Hrx4APrwRmHcG0LZVRwArFaDrxRK0iAXKOk8zEHTBsvVdbhdr4wrpoZINgc4mAUykQboCWM4D1s8XF8Je5Fm7D4FOJcbSd4CZcOGsIgCSYPGJ3TvAdl8YG1KEM9c7AojE4roOZos7qCsE+8qXW1tx4bPLsHqr9npX2ptCWKoB1j3b1+HNlXtTurJu8AXNoj6HJt1JbxCadUfzMs0oz1U++5QO8LePSvfCms+BXV9pVusJ4JljlWtfk7N/hY061J11gB0+/j3Udfg1bmN/nA8XAp3DtyhkQ6C3t3o0dVjcwQg+3dzS577LAO8Ajy3MwpnTK+S/aSQm4pXvh149Fj1XXBSBRRvJBe5vBlQAf/3117jzzjtx9NFHw2azobKyEjNnzsTs2bMxadIkFBQUoLKyEj/5yU/w73//G3b70C5NTgwAagc47O19Xinbm7H8YGXa2ZUDPLCFEPwp+vw5B9h57he6EsCiyA9W+Hv422UGJRCP8O5HF6hd3lwmh09d2VKXoCoEOiMPyGEqQTNh0Le9swGfbWnFne9t1HxvAN4B7koAb25yY8n2dsTiIp5evKtvhdcWPwDYdyrzbToC2Mf/LcoFKdfp8llVUkVlHQ4wKM6WI7MKMCsP1wi6IIoimpxBrgo0IIVAyy1HapcmlopSyyz14BbzW28QS9EiKuFoCLqA1fNhiqkevsIeqY0NOcBET6k6GjCq+oPnj9FsxlaCXnvwXYgLJuyKs2H2IoozpOv4WIPKAfa1ya5sKgFcrK6uDuj3AmavobZiANI1hguBZlI4SrKtXA7z10wo7YTSbBgSej4Wl0KjUxWrG4hCWH94bxN+qHVg085dmnUlvSmE1fADN9tZtwl3LNiIF7/Vr9ugFsDB5u2abfS6CbDX7pIcK/KY70ZKQdbNQLCeAGaLr/V3MSb1oH6HNyS/L4dq4F0dAg0ALS7tva6ncALYxjvAU8oVAewKRDgHWhRFXPLv5fjlq6vxsxdX9LlIqfqzNxsNuPKYcfKy11bUpffcsA9h83/Z1CoKg+5/+l0Au91uPProo5gyZQpOOukk/P3vf8fy5csRiUQgiqLmX1NTE958803ccMMNqKysxE9/+lN8++23/X1axFBF/ZAcj0rtUnoDK8hKGRfLb5fFm0YAD7ADHEhxcXX2JP9JB1EUUdPmQaSnhUR6groqMiuAoyE+3zpNASvDCmAg7RZEape3lBmhTyscjnFe6vwm6fPj8oClByVvKCoXEonFRexo5UdlI7E450RXlyiCUd1Kgi1M4w1Fe18lun4l8P2/+GVsAbkEQRf/WZYJDhw5rhC3zU1dFGoMlH3aTaOk8HDlgAhF4whEopoQ6BI2BJo9F3tNl1XD68USdCAPcVG5w8e/fVx/4x2f8r9tygEm0sGSxRfDAnTbYrFiZG35RVh05vc4I/w3bptSi3S9Hqt2gAF5gJUNPy7NUR769Rxgn0s1YCiKug6wJxiFhyuCpfwOBEHgBt6WbFfEeXWxDZUFWfJ8rd2XMoS3vwtheYIRtCTCNQugvQaUJnoid/rCUnRH01og1s39sH4FNzteaAIgcoWMktXsAcAM/hobad2qOWSHjgDnBHC2FXlMxeKUAphN2wrw98FYXOSu/2OLpL9JNjNw0e8CWOc8t7VIf4dOlQCus/tRr2r71B+tsbgQaJUDnJ9l4XKg2Z687d4QtiRCttc3uPrcUYF1gKsSn/2lR4yVi9o5/RG8u7pBd19Aes7a2erhcqoHGtYBZkO219U7B75v9wij3wRwNBrF448/jvHjx+P3v/89duzYgezsbJx00km466678Pbbb2Px4sVYv349duzYgeXLl2PRokX417/+hZ/97GeYNGkSQqEQ3njjDZxwwgk488wzsWWLjrtB7F/oCafeVoJm9ysaDxiZkcdEHnCzUx0CPbCjf6xgMxuVh/2+OsB3vbcJpzz6Dc5+6rueV9NMF69aALsVd14dqt4XB1jntVyBCJ78cicWrGngLvrsw4LZKHAtFXoaAv3KGgce/HgbUMIIw3bpQUk9Kq4OC/Oqvjfsg2irO8Sds/qBolcVwONx4MNf8wXjAN3fT1MTf0OfkOnFG7+YhWyrSbNtkrKYMrrcZCyXnPEkQRf84RisiMAsqAYgBIfyG2K/A01r0RX1YgliMKIDyusYAsr+SwyzlI03vaNMC0bZHSOIblGHQXeRAwxIA6KOqBUhmBERjfLyYksYVoRRDp3KsYkwaHYArrJAEa16OcCNLSo3J+TmBxTZEGg2B1h13WWvO6yTNqYwC+OKlUG53e2+lAJuxZ5e9ERtWA188CtpcEpFq1sRLYU6AljuBewJAa+eCzw3B3j1vNSRX74OoHM3tyhf8KFIdWx20MEq8kJPTOQMs+g5wOzgZWmuVc79BlILYJEdGFZdj1vcQURiyvsakxiUYK/F6ntJX9Gryr8tEQbtVAnggKpgFtBfAjh1ESwAOKpaif5hv3/qc+/w9D5VLBqLo5ExPJICOC/LjIsOVyJB3u+iGNadCzbiR//8Bmc+sbTfzAZvKIr//lCfsgDdNkYAn8jkiqfd6pFIm34TwAcddBBuueUWuN1unH322Xj77bfR3t6Ozz//HPfffz8uuOACnHDCCZg2bRomTJiAI488EnPnzsX111+P+fPnY+vWrdi+fTvuvvtuVFdX4+OPP8aMGTPw6quv9tcpEkMRdQg0IBfd6TGsALbm8A87zjq4gxF4VKOtA14EiwmBrshTHmT6kgMcicXx9iopL3Vrsxvr6p29PlZXxNzqvrii8hmr84H7KoA9vLPy4Mfb8MjnO3DLf9fjh1rloZN9yLRZTVKP2OQppBPKxLiSbtjw8cZmXQe4zq7Oi+JHydkbtSAAE5nKloFIjAutVxcVUR87Leq+069SHdA+vNrb+Bt6drgDRnR94ywKK/vsFct4ARxywxeKIgfa0LgyIZEDHAnwrV2aN2i2ZakXpVYgrWK+Zt13salomXiJsoDpi4rsMsBg1OxDELqkI4AZN84diCbuCQJXfKrAFEKl0A6DoCPSEtcyLyeAFfdVzwFua5Oud9FYHCt22/nfrGCQf3+SAGZDoHkBPIFx0ljGFmahmhHAtXYfF+3ECnTnzuWo+eZNqdJyuiy4Flj7GvD2zzX5zGxhoSJBey9P5gDHnPVK2kTtUo3IlVGFPyeRXGCFEkYAZ4K/vxr0BLCOu6hxgBMC2IworvC+BCy6jXu/jXYXhBhzHFVEDjvYWZJjRWbCeWRD18OxOELRfiqQCP2otmQhrE5f9887fS2CJYpi9wL4gCJ5esVuuzxgrB4M6IsD3OQMIsYU/GJ/kycfqLSiUkdsJXH6w/hv4jlrZ5u3+7ZJzRukQWqmdaAef3p/E257dwMueGaZprCV3RviPrtDmVxxoGdF34ju6TcBXFdXh1/84heoqanBe++9hwsuuAAWi6X7HRkmTpyI++67Dzt37sQbb7yByZMnY8+envXmJIY2q+scuOE/q/FOMuxEHQIN9L4SNCuAzVlAARPu5qjTuL/AviiCpVywKvKUB5m+OMB1dh9XyXFn28BUUnS26hR/SgpfjQOcqoqwDqLYpQMsiiI+36LMb2hwytOcALaYYLMqYiitlhhM7p1bzEKTK4hQAVMIq30bIIqoVTvAXbTPyraYUGSzwML0jGS3V4+o13X6AW8bV528Wza8qb9cxwH2dqoGLsSY/u8sScCJzKjyUFcTLdF1gNUtkACgFA5pMEB9HrGuH1zqRWlku1Us0Kx7PXYyps86VXJ71eSUdXlcguAoOxgYd5w0XT1HN39c7QAnB0VZ4VloCun3yQYAxx6IopjaAdbJAW5qaUE8LuLejzbj4ueW46aXvlBWZhbIgzzeYJTvA6y67p41o0IO52QZU5gpO16ANOjGDsqdMa0CMyrzMEOowXuWP2HCV7+E+O0/uWOkDLcM+4DORG5vxKe5jrUygqJQ0AmBTghgi0v1bJeqk0CK5eMNvAAuS6TDGBCHVdXSzeLUFuOy+8KanrfaHGDpu/Er0/v4mfgBsPLfwLIn5W3eXaYalFRdB9UtkJLYVNE4aUUvpYleXZNkWLHaAdZDfa/rKb5wjCs41p0D3OQKyr2X1Q5wX1oK1jEVoMtzM5BhVn4nOWwOdgoH/tuaDrBfD3UalIb3bwDWvAK8c1WXrR0XrJXyxIOROJ5ezH8v2fzfgiwz950BUhdV7SvxuDgiw6v7TQDX1NTgmWeewZgx2iITveHiiy/Gxo0bcfXVV/fL8Yihwe3vbsCijS24490N0kijrgPcixBoUZRuxkks2UDBOGXeWadbyGjAi2AxF6xRTKscVyDS64bzNW3K+7zB+AGO/uYyuS9iv6KXl5sUwOpBip44wAGHNj/Uqzxc7u7wcTlE7DTrsmRbTbAxDnBPc4A9kG4udcZKfr23VROm3FXueE6GCYIgcAMc7Ci6uvd0vGE18OiBwOMzgO0fd3/OkQCw5UNlfsxRyrSOAxzx6Dyoe5q1y5KwvUxFK+qC2RoB7Atr838B6WHWG4zonkdXKA5wIbe8XczF9vzjcOC4UcCoQ7Q7TjytR69DjHAMBuDy94BfLgUuW6C7CZsD7A5E5N82KzzzDCFtBegknXsQisa5h+XuHGAh6MJ/V9XjteV7AQDWMLNNIvw5FI0hHIunLIKVfJ1HLzpEc/yxhVlcxFGbO8RFO+VlmnHH6Qfi35Z/wphwtYWv/gJA6iN76XPLccQDX+LrHToP8urBNJUDrIRAiyiAVjSUJHKAbV61AF6h2VZazghgg3K9VzvAxdlWCAKQAa3Iy/TshQW8KI7FRc1ANFsFujTXitxMM0yI4idGprrznqXy5A87ePEvqgSwXgEsAMgyG7kCR/0ZBq03qL+r3YtwNJ5W4bFWd7DXzyYAH1puEPjc7CSlORlchMLyRB6wulVVXwQwe88eU8i3OONC0ENRXfGn7s/cpQCORaQ+94DUglAn4kAPdQsqNv93UlkODAYBmYxwHygB/OW2Nkz8w8c49C+f4+fzetjSchjTbwK4v4QviyAIGD16dL8flxgcAuEYahJuZTQuStM+HeHUmxDoWJjPobLY+IInjlouHyTJwBfBYkOglQcZUdTP1UmHXe3SZzheaMRt5rdQ5V0vhWb1M0ZfFwJY4wD3QACp3V+AK7i1UpWT1sm0y2CrQNusRm4kPb0cYCYEWpQeSHZ5LIBNCYlC+zatA6yKHmD/dkkHif37NnMCmN/3ivq7E99VUWod1B3bP1YefC3ZwMzLlHWqz90fjsIc1PlbdCWAmVYue8VSdAYigJUvguUPxTQtkAAgQ4hADLp69Pe3iznwJx7q1Q7wf2NzcPLBYyAIAnDgWcqKnArgrCeAE25P+3UIAgBgNAMV01OGzrNVoN3BiJzryQrPXEOQF8BsITZHraaQUVLsCIhrclUBIE/w4Y/vb5LnC5lQ4Q4xB9e9uhpfbpUGsnwpimAlmXtwOX590gR53mwUUFmQhdJcxXlr9QS5e11uphmzqwvlCvFJ4nERH65vwve77ejwhvCMXts29aC1SgAnB/9y4YdF0F6Tkw5wQWAvv0Iv1DkWBZrWKOfHDICpBXC21Yhsi0lXAAuIY5ygTumRxN73u+zyICUfAp2B3AwzTjWsks9ZeoMbgHgMdXYf2jr455eol/9sWAE8hhHABoOAbGbw1hPqv+cQvbSuSEzErnZvWsU3IzERHT1pUaWCDeEttFlgNAi62+nlAatrsvSlRRd73y3P4wUwm/YQiWlza0VR1Az+7GjpItLO1wGAEdFpDgirw81ZkZ2sls1HuQ2MYeMKRBCNi+j0hXv9XDoc6dcq0M3NfS/T/Ytf/KIfzoQYijQ6+dGuNk8KB7g3IdBq19hi4x1gR53GiQMGPgeYDcsty83gRn2dgd7lAe9KDCJMFpgQZXtNz3K40sAS1Bn9TwoxvRzgdENo9AQw4zZrBTDrACvvUcoBZkdHu7lwx+OaHGBAcpxRyhbC2q5xgFtc/Kg4e5NI5nOxjkuylUQ8LnJ5PgLiKIkzn2vrxq7PGQA2vKVMH3g2kMsMCqputFua3NzDtHLCOtdmUZRynvd8LS+qE8vg9EV0HWCbjgMMALZQO8QeRAAk3V8AaIUigOOigDdiJ+GgUQnxPesG4Ix/AGc9Dvx6DXDYFZKjRxD9COsAuwJROSqIdYBtQoAPga4+UZl27oUvoDyoC4L0cD+pLBsF8MIkaPPvcwU/l8bCOqVr2g34ZHMLbviPJPw8XRTBSvLbUybhyqPHoSDLjJtPmYQMs1EOCQakarftqh63aOMrIzvEbOxq92LtXqe8rMGh85tXD1qrc4ATIdB64c+A4oiXRlQtg9q2aO8r7kautoBrwrnytFoAZ1lMsFlNyIS+aJogaFsU3fHuBlz6/HKc+I8laHEFNSHQGWYjfmb6kt8p4gc6duLzLa2aqJh0HWBAVQm6Xx1g/WNta3Gn3XqqqzxguzeE/3tmGU5/fCl26rii3eX/JuHygPdI3yljxzbcbXoVxxik+2JfHGD2vluey58H+9kDWjNiS7Nb89p6PYtlVEU84z47drZ6EFS1wVTv36LKAWYd4Mnl0n1QqXMiouz7vwAvnQ7U6+fF9xb2OZhNCdnf6deniVNPPRVOp7PX+//yl7/Eiy++2H8nRAwp1DfTdndQP3S2NyHQ6gcDi40veOJu1G3w3m9VoONx4H+3AC+eJlXITMC2Qcq2mriqkr1thZR0gCsFRkh1l+fZU+IxZIR0/japHOBokC+C1BVdOMCiKGLFbjtK4MSYhONiZ27aPnUINOsAdxceFPZyVZST7UVqO3xcJeho61Y0q25M4VicGxVnbxjJfKJyxgFuSjxA2H1hrgroVKGWP6esbioa+zqAGiY/cMbFQBYTNuznHZyNjS4U6T14qltaiSLw/vXAv44EVs+XF9eJZfCEoohaeAfYF9IPgQaAQjgQ8fREAEv5vxajAavjE+Xln8UPR4NYqhT2MVmBI68FDrtSamlDEANAEfOQ3uZWnFIv4wDbwAtgsfoE5QDxCMKdSuV1m8UEs9GAhTcdh4+uVL7fLHng73GcAxznC1v5xNRFsJIYDALuPXsq1v7pVPzqRMkNLlGJj2RbNyDhgO3kKzgHYMHqOgfWM0UV2zwh7UO/TzUwquppnAyBLmREfYxpd5Yn+GFFGJVxVfVdMQ40ruaXseLamot2m1KwsFLogJVxe6X7gREZgr7Im6ASzIDUageQ8jE/WNeIMFPptzTHCrTvwCzDZu3Bmtfhsy2tyBb4+4Qp7JKeBRKkygFOnm+S/myF5GGcfnbAfVuLR9MHmIXdVu9ZKclry/diVZ0DW5vd+O1/12nzqNkWSF0JYMYBru8MoMkZwPEb7sTVpo/xvPlR5MLbJwHMinh2MAgAMs1GsMa0+vPXC/13BSJciDyHl087+mrNVvzon9/glEe/5p5Z2GeB5DGTvy+ptaXy+04W1kwO8h8q7MTorS8Ce5cBX96nfx69hI0OySMB3Ds2b96MM844A35/z6uc3nDDDXj++ef783SIIYZaADtdDil0WU2KUe4uCSvfuRAsqHeGAJtSQh4hN9oc2mIknv4Kga79Blj1IlC/HPjsD/JiNmcjy2JEPiuAe+E+i6KIXe3Sg0yloBK8XYW59hRfBwx6lYNT5QAD6ecB6zrA0g2kwRFAtnsnvrP+Gkutv8Vphh9g9+oLYJvVBBvjAHebA8w8uMVFQXaA93T4gGKlEFa4dTtnZhfAjftNLyL+xZ/lfpVcCLTsAGtzgNUj6XMM6/lz6q7nde23Smh/drlU0CeTEcAhlxQmmGBjo4t78JRxqx7+lv4DWP+GZrN18fEAAL9Ryc+SHGD9EGhA6usZ9qQu+rEnzheuSjrABxTbUCNW4vLwHbg/8lPcFvkFBIFv7UIQAw1bsMruC8uhk2zocWbczwngcNGB0u8xga9lpzydZTECDathfv8XGL19vu5r5gj8MxL7m3Ugh1vHtUFSO6RdYDEZUMTkX7LtbvIyzcDOz7ntsxHEd7vsXCGecDSubf/TTQh00nljRX2dyF8DKgQ7KqFTq0DtbLHHzshDs6EUIVG63hoEEdWCcs/LshqR3YUDrC6apWY504/WbBSkz2jNy7rbButWYVVtp2ZQ0IC4dE2GJKrYwdsuHeB+FMDs4OwBTJ5tQ2egSwF8UIUy6NnSRSGsdfXKoOumRrdS0DQBmwNcnJ26EG5FXib3mazf3YgSv/Q7yhJCGC8096kKdAvTjosdnAak9MquWlGp83+TsA4th6peyu69UnRegyOAr7Yp3/OgTrVvR8IIsfvCnCGTzJFOCmAuAsW+S/88eglbCydX5Y7vz/SrAM7MzMSKFStw3nnnIRJJ/+H+xhtvxLPPPgsAuPLKK/vzlIghhFoAB50pior04CYvw7jGXtGKp5fUyMVEkvid2htuvxXBYi9IjWtkocTmAGdajMjLUm4I6VRkVNPqDsk3S84BBrQuX1/QK4AFpHaAgfQdaD0BHPYAYR9W7unEaYYf5Nyxc43fqkKgeQc4i8sB7uZvyQwQtCMPMUg3llq7jwsrjqvE3K9N7+My05coX/8vYJNUSMcT1DrAbAh0MtxeHXY/x6gSwIn3nRK2NcjoQ6U8xiy+cBTbeqOmoQ1Zgs5DA/vd2LYI+Op+ZT67HOIBx+OR2CX4JH4kAMAr8gLYH4rCBn1XoExwaHLfWDaJB3Dz9WIJBAEYVyw9/CyNT8cLsTPhhg2VBZlctU6CGGjKcjO4Hu1J14ltg5Tp3s1VFnZljEY4V4kwWvDlt/L0GLNX6mu78W1gLdPG0cQU1erCAe4UeQHMOtFSFEv6BYpKVc5XknzBB+xdzi2zIYBPNjVxrWMAvq8vgC6LYImiiLakA8xEorShAJ2iMrB1mLBTNzQcDaoCPCoBbPfHUCsqAw9sGLTNYkJ2hn4OMACMVg8Yq2Db7RVnW2EwCMBuJT1ke1wplujdswpxEbqV8ZP1ENg0mgwTUNr2HeBSwrBZAZZu3mW7J4Rfvb4GJz2yRL9AGfiotqmjlFSWeodfFltqbBYjDma2TdULWBRFbGzkBzz+/ul27n7Y4Q3BgDj+aHoV17X8qUuxNr5Euc8E2vmCYgWCp48OsPK3qcjT/g7YStBsDrY7GMGaOva7oDyzpSyEpWrjyKY0fM8MrAR1otT2JCIz9jARGnmZZrl4WDIEmhs083f06DrQHS4Kge47CxYsgNlsxhdffIGf/OQnaZXVvummm/D0008DAK644goKgd6PUReh0q1WC/Q5BNovZmBdvQswZ0hFgxLEdFyqfiuCxT4UxEJyFUDeATZxDrBmZD0NkuHPgJ4A7kcHOIUADvud0oTeIEW6hZD0BDAAeFqwck8n5zRWCJ3whqJyn0TeATZyVaC7rZDoVj6fFqb6cIc3DK9Rufkbg7yTfbhhuzKTqPSonwPMF8ESRZHL8cmDFzMFxSmSSYjTFlcQD3+6DZ9sYsQqU6EZBQkhackGDMxNKpEHHAjH4GhP4XIkBXDACbx3HX/MG76HcMVHeDvzIsQTtwSXyLgVITd84RiyUznAghNxvWJ2CcqnzOLm68VSFGZZUGjThsdNLM3RLCOIgcRoELgK/UlY4WnoUK4BTtGGzqgFdTFlgLUorlz/b4i9IruAHMVKOHSOEMCPJhfh2csOBSA97CdxqAQwVwSL7cWeBmWJ3MdceHGSYQ2yEoNYRa3LpLQZBqMgwhTTCh91r1JNpA8jUh3+iBxGXMSIALuYgzam4N2RBp2e5oBUCIsJIdYIYG8YNeIoedFPjV9CSEQq2RJdATJThECPSghgNtSXhR1cLc2xSufB9CD/T+xkeTrHuRUGxHV7owdc0n2Zzf99MPM1GP5zPvDM0XKLnJweOsDr6504+6lvsXBDM3a3+/DAwi2627EO8IEVynepps3LRQGMYu5XY4tsqMjXL+LI0uIOcl0ZAEnw/mvxLm7+JMNaXGP6GFOc3/CDrSryGUMALr7tYqHggSsQ6VWP5GAkxol9dQg0wH/+7P18dZ1Dzs8vyDLjx9OV71u6DnC+oDynsZEFwuZ38LHlDtxg/EBelhS+u5lnu+oSm1QIEooDnANGAMfCuiaELxTFxf/+HnMeXsylMnQHhUD3A6eddhpeeeUVCIKABQsW4Je//GWX299888146qmnAACXX3455s2b15+nQwwxGhx82JeYyjHsVQi08lDghxU1bR7pYs+4wDmiNjcyHI1rChX0CnVYWPMGAHzVviyLEflZfcsBVgSwqBMC3UMH2NMi5Sy/cAqXt9zVsdzOhMjV+xulEwIdiwCuBv113lasrO1ENnOhL0tUKU26wD51EaxUFRLDfv5BCgA8ijhUVx+uDymCzxJ2yQ9VAuJ87lgijNqt4wCzYVb+cAzuYJR7kDjBsEFuOcK/b2kg6L6PNuNfi3fh+v+sVoqLsIMFhQkBLAicC7yxRhLJW5rdKNCpOAtAee+b31Mezi3ZwKVvyscqYMIlHXHmoTvhAKfKAS4VHF0Ofhw+60Ruvl4sQaHNgoIs7Y1Wzv8liH0IGwadhBWeAlMpvUUsxFfb2rDBpVwzSiFdpw4XtuHkkKpoUhImzQIAnr94Ek6bWg6bxcg5Rp3I5bbjimAB6d0fQx4gEkRpjhVGxPCB5W68ZPkH/m1+FABga/had7dsnSgPTd6jKgfY77bj8hdX4Fevr+Gq57MOcKeYi3ZRGWQ80sAU4Ko8EkBClQYcnOhUC+AOXwgfxo6WF802bsHPjFIod5ZFJwTapFyTy+CAETGMytP+rdWU5FgBdwMQVa55C2Oz5AFCqxhEtdCkGxXT2Cxda9uZfsjnRhYl3o9TSj8BMEGsw48Mq2BErNsiWMt323Hhv7/n7ic7Wr26KVzsvYkNa1YPEM8Yky9PVxVmqQZw9a/1Gxt0BnYAvPp9LSKJgY8Ob5gvUNaSutAj+zxk9vBFyvIhfc/t3p5HyrWpohZKcxgB3L4d2PIB8i3K8wH7+e9gRO70ynzuM0zpAKsEMBvRsbvdhzZ3EBBFFHx9Nw407MVt5rcwXZAGDWplAaz8dqqLlftgss5JrnoAWuf5+aP1TVixpxO1dj+e/Tr9MOnLm/+KF80P4yHTcxgT3t39DvsJ/V5S86KLLsIzzzwDURTx4osv4vbb9dtW3HLLLXjiiScAAD/96U/x8sv6uRbE/oM6BNqQ6qG5N1WgmQJMfmQgEhOlixUjgJMj0lYT/7XvFxdYXRikRRLAga5ygHshgJNFEgrh0Ya69tQB/iGRs9zwA/DCSUAN8+Dm1RfAPo9TmuhtDrCrQXYeRAioEZXQY19nE/Z0+LjCIqWJh5bkTdCjCoHO1guBXvc68OAY4Nlj+JtECgcYAPb4FTfSiBhyEyJ8us3Ff84Jscq3QZLOoTDLAotR+W61uIJocQVxoFCHl8x/x6OWp/U/k8Rnnay+KorAqmQIVmetsl2BEkoctebL0/M/X4NYXMSWZjdfeZV5+IPfLuUbsxWlZ17GVb9mBWlHlNk3UQSLywHOUUbFSwUnDHqtlxII5dPQmiUVr9ker0S9WIqibAsKsrT5YRMo/5cYBCrztUXWuP67ceVa3Sbm44Wle7DZwwhgwQkBcfzZzDzHMD1rAQB5lZCFHgAEnRAEqWVRVyHQIZgRYx/Vurs/7l0BPDIFeGQSpphbMUlowAEG6QH9OOMmlJn9MLZv1d1VL6RX4wCrHrzb2lqxdGcHFm5oxu3vbJCXcwIYuWhDvjyfPB8AwKiZXBFCNK9TpnUc4E/jR+Dj2BHy4jtMb2Cc0Cw5wFZVCHSR0h7KKIgohRNVRd0X1CvJsXK9XJvEQtiRh/aMcfKy6cJu3aiYtlbpPtPpS3F/r/sOaN2M3+y6Fs9bHsVvTe906wC/9UM9594m2dToRjwu4oN1jfhkUwtC0RiCEWW7iWU5XHh/kpwME2ZVK89Gh1UVcK2CUjnAm5jw5+MmFsOSeJbyhWPYkBDHHd4Qfx9y1mkHoxPkZyr3gAw/L4CTv4nehEGzAr442yqfJ1yNwDPHAP/9Ga4MvCJvw37+O1qV39eksmxMKld+jzvbvPo9klVFsJLiPcn3u+1AJAATc5+8JNFbek9i0IgtUlfNhIZn6jnAgO6gM9v7uE7VyaIrDgyuw8nGtbjYtISLRtnfGZCeEtdeey3+9re/QRRF/OMf/8BDDz3Erb/11lvx2GOPAQAuvfRSvPLKKzpHIfYngpGY5kKWFXXqb8yOcG9+H3jkQGDBL7vMeQj4lAuzT5TEzJZmN2BTquwmL8oHFNu4m0K/5AGrR+OaNyAcjXOtLrIsJj4HuBdtkHQrQCeIuLou8qGBDa8FgNcvBnYtlqY9+iHQQa9TmkjDAda9UTCOpt1QhPq48vfxdkjOMDuqbhREFMMlFxNhQ6DzhABy4srf3Z90h5c/IxWOatsCvPNz5bUZB7hF5QBvdxq5B9ZkJeW5ZU7+/H1JAax1gA0GgXOBm10BNDn8eNb8T5xkXAeTXlExAPC0IhYXuYIftXYfEA1LLkSSQkUA2+PKDdIQcqDFHURdh48LO+QeKgGgfiWw93tlfvrF3GrWAbazAjgeRTTk5dsgFY2XJ8vggDHIV6OWEYxAZgE6zn8TN4VvxE/Cf0AcBsRFIE/HAR5PDjAxCOg5wCG2EBxDi1iITl8YbWK+vKxMcOAgYS8OMjB5jJe+xe9YPIlvLxZwAgDG5lu4nOBOqNMABIQMfEpCl6x9Rbo+B1040vkxKgT+ujzd0gK079DdVS/Ko00TAs3f6wIe5UF8J1PFVh0C3SCWQJeiCUD5NGW+VemPrBXAIQAC/hi5Ch2i5MxlCmH8yvgBbFajlAPMhkBnFXKD4KOEDlQV6f9dWUpyMoAOxYneFZcG/Oqsios/zbBHVwC77NKAZrLglKaYZPt24MObYBSle9mNpg+6FcDq6LkkW/a2YsdL18L07pW477XP8PYqProqP9OM0Trh/QVZFlxy5Bjc+qNJuPmUibh8dhUXEt3qDurevzcwAvioAwoxk3GRk6G+HZ4QX4gxFk45OM86wLYAP+iejIrojQBmU4/K85hUm9pv5cGsGSEl6o29n7Mu76SyHExk7kn+cEyTygdAYxgUCh6cOFn5vi/f3akpFndMorp4rV4IdLJ4WSQIm1mSabmCKvVBp4VoJ1NXRjNwlQpRRL6onJs5r7yLjfcvBqyp4u23347bbrsNoijirrvuwgsvvAAA+N3vfod//vOfAICLL74Yr732mhzrTuy/NOlcNLhRQoEpfMOKqyUPSsJlw5vSA3wK2PZb/sTI/ZYmN9dmJvl6o/Mzud6PA+MAb0RAdVPLVDnArj44wHoFPSKOHgpgdZhzPAJ8LQ1WicwFvZlxS6OBFH2AAU4A/+mDTZh276d4ZokqDGfnZ/LkXrGUywsLJ85f/VBRLnSiM9GCKCmAZwo7cebnJ2HSf2ZhlkHKhfKFo1LdgRbFhcCeb5RCJowD3CoWyo3mAaC20889KCVvvrOyVXnqOg4wm0tUrsoD9rk7UGVQjtEiFuAfkQvxdux45pgt6PSFueIzdR1+wLlXadskGIC8MfL6+oDyOgXwoM7uw95OP/+byh3NF4L77nFluniS5LwwsA5wc4jPz40H3PzDcdnB8uRooQOWYAr331YMGAw4aPwB+DB+NOyQBIA/HNV3gEkAE4NAZaFOWKxF/7uY7F3NplGUCk6MYau0lhwITDwF+PknQGG1VL39wLM0/bUBYEJOBAYmNUKdAwwAERMj2roLgWbcqOJIM0apBPDxxk1S8b0kViXEU93WB+i+CFauoC/O1CHQ78aOlwsPchRVA+XK9QQtKQSwNVceCLUjD/PMygDeeEMTbBYTqottyGQdYFMmV+BwlGDXVGNm7wNJ1A7wbrECALBVqJaXHWzYgxKL9h7ud0rPAkkBrHHuYmGgcRW3SDcEOh4DPr8HeOdqxDv3younjlL+XqbtH2JKw9s407gS15s+xMeblHuc0SAgy2JEZYHW8S6wWWA1GfHrkyfKfaPZe1ckJnJt/wCpABbrAB88Oo9zkZfvtiMQjsEXjml70aeo+8EK4LywVkQC6FUlaL4HMBvN5JQns5nB82RkWTzOtyKaVJYDm9XEDZBp8oBFUeMA5wk+nHGw0u9+xW67RgBXGdowXmhEbYcPkVicyxmvLsmW0pX+fgCu3XolrAhr8811Iu4cTNSB3RdOL3864IAZyvcvI39UFxvvXwyYAAaABx98ENdeey1EUcT111+Ps88+G48+KuWgXHjhhSR+RxDq8GcAKGIvknlKhUUuxIsdWetMndPgdjnl6WTo2uYmF5crmRyVHFuUlbIAQq9RC+CQC6EOPpdCkwPcwyJYnmBEfhjRc4AFX4rKzanQK3SVqDocdyuf++54hbI+6T7oOsDSg1GbO4hXvq+DLxzDY1/sUITdjk+B5UoY8NLIFLRDeSCMJV5T7UKUCw45BNobikJAHO9Z74Ep5ochFsQFhm+kcxaBYFBn1HPhLUAkCJF1gFGA4ycpI7R7Onx8uLzgllrygC/MIfo64A+FuRAxtmgEl0flDMDsVvaPmzJxXOQpPBU7j89B9rRqRmtr7T7eoc+rBEySYHT6w9jlUwRqgeBFfacfezv9/G/KVgTkMH+7GqbtyfSLNdVgChlB2hEUAKPyGkLQxYdAV0yX8+HMQgxWUTl/n8A8rNukhwBBEPCrExXX+GezxmlygEtzrCOqAAcxdBijIxJgTSGAE7/dpBAGgGK4MFZgrqf5icGqqtnATWuBK/8HZOQCmfnKNomH8QNsym8nJJr40OsEURNzfqoHaQ2MQM0JtWgc4BNiTBRIdjknEJNRHmyP1FYmlxVhv6bfe4HamUrAiiA7crFXLMO60nO1GxZNAMqmMi/I9N3VCYGWz7VUiYjJgw+ZZiNmjy/icoADsHDPFhWCHTPH5ssO2wmTSnDygYpQSVKSzQvgXYnCW9+5lW1HCx0oMWujuCI+O0RRlOtW5KX4fFh0HeCVzwHfPQZsegcXBd6UF8+dqjh0oVbFpZ5kaJAG/RPkZpgSIfZ6DrD2OpuTYUYOk1LUrOoFrC6ANU0lgFfXOWTnNX0BrNxzimOqSsp9CIFucSn7cAWwmO+TLeqWa30kByAaHAEEmJowyQHZC3M242PL7fib6XnsaVQZDWGv5jdhgIijRymDPbs7fOjs1D6znW5YCV84hrV7nXKPYEGAFKb/7T+BiB+lvh04ybBW0zpNLwfYrhq0UOdC6xFjitGGRSOy84u72Hr/YkAFMAA8++yzuPDCCxGLxbBw4UIAwPnnn4/XX38dRiO1uxgp6AngQrZgT0GVMs1WuWTFcKriSQB8XuVYgUQI9NZmD+KcAyxdUA+syOVKvbt7UY2ZIxbVzceINSktb8xGAWajQVUEq2ch0GyRhHEm7ehfRsjO9YRl+a6mA49+voMP39ELc/a1A/EYRMYdTo5+A4Ax4pVcVt0cYOkzYMNwQsk+kq4G4D2lKF6kcBKejf6YCyMUEuHF6sIikgOshECfaVjBrT/FuEaeDjh1cpftNcDq+Zzj3SIW4tgJyndjT7sPMaa/boHgRUVuBrLdNeyRIIgxLF67Tb5J5luBqeHNsiPOjqJvafagLK7cXMT8KpTlSQ+y7PuGtwWBujW42/QqDhOkarN1dj9EtgVSwTh58outbXAwLUXy4UWd3Y/6Tj//m8oqBnJShDNNv0iziH0YcfjCnFtlDLv4v0tWEZwW/WN35jCh10wKwq9PmoibT5mI2+dOwTkzR3G/BYDcX2Lw0HPJDBm5OlsC0Syppy37GzYIIqYbmN8rO6DLouMAj7Eq12SpB7CgCVv1ZSoiFW36+bsyjDOU4WtEhcDfm8bGmDDtkkmc0E/+xg+rUsQ99xCtE3aZhSCM0DpNRWAdYMllXVV1jfZ888ZwESXwtigP92yLpYxcdDBu4JhRilOVJ/hhMEj51OVZipveGjBoHOC8TDM+/PWxeP2ao/DsZYfp9h0vzbVyxbiSAnh3QPmeFMGNApN2wDU75kaHNyzX+FC3vNIjHNS5n35yhzx5sXGxPH3awcp11xhR9iuFg6t8nHzGGVOo4wDrRN8AwGhGLLNteQC+ANaovAwUZVsxc2y+XPfCH47JPW8L1cUYnXyLI+U8pHM0IYriOP9MU9inEOgULZASaQcAYGBqfSQHINjw58qCTLkA1RWup3GgoR6Xmhbj/BUXA01rlWOmSBcbbQ1yv+PttfWabc4wSlGNX25TjjE6PxMZJgPQoXSMKBGcOjnAXTvAANDm0TEEVAQ6FUFvRx5yU3w39kf6VQDv3btX86++vh4PPPAADj30UIiiiGOOOQYPPfQQGhsbdbffu3dv9y9EDDsandowKS5cM58VwImLUDTEFR9Rl8lnCfmVYyVH0L2hKFdQpEhww4woZgW+wWGCMrrb5xDoQCcAbb6MsVWpfpjs5ZbHFH3oaRskLjTHohXcAkQ5R5WlxRXEz+f9gCe+3KkUKYkE9Ft1iHHAb4eBOU4tlAeNrHiil2AXOcDqapMOf1gKv032qzVnYcuxTyKADC4E2hqURkjVhVjKhU555D8UCuFW03+59W4oN/iwI0UhsK0fQogrgwPBjFJMG608jHpCUXxeq6wvghsXHjYKBsYFSLJ0rdJ+Yl7+PFhfO1NqbxENcxVG19U7uLBIQ0GV1F4D4N433E2Y+vUvcLXpY7xm+RtGoQOBSAwBZnSfLYD1yaYWTgAXCF6s3etMhJ4xvylbCVA+XftZjDsOyB+rWVzIVoH2R1QC2MOHpltz4MwapzlGSDTDUs4KYMVlzzAbcfMpk3D9nPGwmox8CwyAy7UiiH1JaY5VUyzImEIAzz5EciuDsCJsUu4vMw3M75VJV+DIyFemEw/jFWZFaCTDn8+czkRuAGjJZhzSRlXFfjXMg7HR34YDhC66AxRPBqzKe8gRArBZjLh+jhKt0eYJKi0tU3RuUD+cWxHm2hEl35eYXYaVJRfIy1szqqXe5tllXLqSnAfMCOCgKQchphDUoZOVa2K+4JNrhByQrzzWNvoExHOVwYhRgl0unnj0hGJkWoxSuKmKUjOft+rPkUKf7aLynbAKURTGtJ9HPjzo8IZ65ACbA6rjOPWfdQptFkwszZYHD9nPvVRwctsmo9z0HWB9kTOZCQffpgr1Zfv/TquU7g0ZZiMOGZsvL//fBklMaQoppXKAE89DZXBoOiQkj9HRixDoFiZCqyxFCDSgmCLJKMAdbXz+LwAg4EB+SBGJRdFWqXtGotNHqpaR8Ns5h7ypRbvdQYY6VAktWLxNeU6oLsmWvnuMq1wALx+BBXSbAwzwTngqgoxp0C7mcVEA+zv9+k4POOCALtcLgoBly5Zh0qRJXW4TjfZDSCoxpNBzgMvYC3ahklsju4tql5FpIq8mHFAuXH4mhKw2kInkbbUQHvza/D7GfrkA9wA42Hwc/hS5su9FsNThzwnM7RsBzAag9HJTt0ESRTHtNIAuewAn2fIBsPJ5qWDSxf8BzBnY2OiSezP+UNspvab6oi0Ylb6QHTthiCkXTkdmFZDQ6tlCAHs6vCjsogq0P8QLYKc/DLQyPQtPuA27UAnAzrkotrB0QVfnupQJDqz2hRGOxnEevuIriAIYBTsExCHCkLoQ2N7l8qRXzEB+YREKbBZUFmTK3822WI58RTyyLI7jZpqBZdoR1Pr6OgAHw4IIDnF/lXiTe4GmNSjPGydv1+ENY4xJ+TsJBVUoiiUFsPK+0b5NlvCZQhi3mN/B7yLXIdS2S5H2iQJYvlAU3+xsRyFYAezB6kTVaD4EuhiYcYkUtt6yCYj4JEF6+t91PyL2u+nwh4F85WHPHPHwoenWHHizxwHOZdwx3IZcFB16NrDjP9KC8SfpvhYALh8eIAeYGDwMBsl1rWUqp5oz9QXwWcccCoyWrtnmbyuADuk3N5oNNU4pgLUOcIlREUj2hFA8YlwhnvtGcZTteSoBLIr6DW0jQc3g5MGGWv1zAYCSydwD/G0njsYdx54Mtv5RJCbC4Y9IA2QpBHCu4IeTGWxWR/F4E62cMs1GrKi+EfHWLThY2IPPii/H5YD0XsqmAnsS9RpaNwPVczgB7IpnAYlcRUEAysuUQQITopJgsNgwNkcAEpfdve4YZtrK5etohWBHtugD1n0gRZ1VHokJQiN+Z3oLJsTxr+g58CALJWHGiDHbUDpqHOBqhxPZiImCLNayg9rBhQLBi3ZPSM4Bzk3DAbaEVAPam97lZpsSdTgq8jIgCAKmjc7D0p0d3KBkthCEDQH4Ep91ss5JuiHQACP6oG35s3pPB04z/IAIjJg2SokgmlVdhJV7pPNfu9cJCyLalj0pBHCyEKJeTZN8eGFAvFcOMJu3zkZlqdMHCuHGHlTIIdA7mQrQE8sS96M2nZ7VsRCw9SOgYnoXArgTlQVKFXKRcZ9ZTjCsxyutiqtfXWzjW4FB6ius+R6pog5FUZQitxha0iiEFWHS3ZyGfBgM6T2P7g/0qwMsimK//BtKBAIB/OlPf8KkSZOQkZGBUaNG4aqrrkJjY2oxlgqHw4Hf/OY3qKqqgtVqRVVVFW6++WaugNP+CiuAi7MtMCGKMjCVY0sPVKaTIdBh1ShiFyHQcSaEKMbkS233KCOdBYIHp1mUAkkXGJfif5a7IDhr03wXKhy10gNHCgGc1amIvmQpe/ahPxoX4QtrQ8dSwfYALooqF92YyFywPrlDypWu+UIqogCghWkJEIrGpTweNmwnqwjIY0LsmCJSIdEEX5biAOcggN1tnhQOcCcQj8Mf5gcUOn0RPpe79CA0Jr4PbA5wTswJK8LIEHhnvAJSESxfKIqzjN9DjVmIoQTSjS3GXMzZ0DdZ3EPK4Us+FDx56Uwcngj3Y6uvHl9pgLFD58YHoCjxWsfm2yEwx4W7iQ+3gmqgIn8sirMTAphpCaLmfMNSHCjUwcB+LxMO8Dc72hGOxuFUhUAnBzj4EOgiKQf+zEeAqz8FrvsWuPw9oHii7utyDrAqBNoadfMPtZZsBPOqoSa7oBSmyacBV/wP+Om7mkrTLCajgcv5pQrQxGCiDoO22vQEsABDThnOOWQ0zjlkNIRUKQZphUA7AfDdEByJa9C4oiz88njp95VpNuKoY09R9vO1p74XBrSRQWyBGw3FkzgHOM8QQk6GGbkZJmSYlcdDuUaBjusEaEUeG8UTFwUpFzfxXsxZebgkfDemhV7AsowTlJ3YMOhkHjATpdQZU4RcYZYFxiy+kn/SUS/PVJ4h20NG7A7ly/OjBDvy3r8MeP86YN7pwENVyH7haNxo+gDXmT7CLaa3kZthgtXJhLMXT8DUSum1RBi4Ps3c9T9BvuBFozMgR0Kl4wBnhvm/m3f1m9x8clB4VCKkdnrCgVU776wLrAhg/SJYerAFwdhiT++sbkBF3Yf4t+WfeMnyD5wsKEW8ZlXzLQXZntYyKQRwboYJRoOgK4CNgohc+HpcBCseF9Hm9mOi0AAD4ilDoAHGAdYJgZ5Umvgs2rZAl2SKUhcOMNum0RjWr94+w8DXthlfohXAJYILNnXby8RgVFIzeUJRrusIkF4l6KhbcZ89xoIuttz/6FcHeN68ef15uEEnGAzipJNOwvLly1FRUYFzzjkHtbW1mDdvHv73/+ydd3gU1frHv7M927LplQQIIfRepRcpIoggKqCCiGIXuYp6FUS593rt5ee9chUFKxawIQiCgCJIlSJILwFCIKT3TbJ7fn/M7s6Z3dk0skkg7+d5eNidemYyO+d8z9t++AHbtm1Dy5a+g0AlMjMz0bdvXxw/fhwtW7bE+PHjcfDgQbz55pv48ccf8fvvvyM0NLTqA12hpHECuGtCCA4dOifLfImIFOmzww44yhUswOcUZ77LKpwQKoo90znNYyIAV/6g/dkaTHVtF4ICmLw6rBaqi+h2ZimAYTW7oK1vAz89LSYRGTRXWm6J8bhO6UsyEIRSlMDgsQB7J/nJLS6TvSQBiNcOAVBzy5mUnTAEBdA5pft5iCWig3Dat42uF7d3Tb+03BJE8ILUHA1og0QrJiArXH8JNmiMwXBpPmgFBy5ePA8ll28wB2DPkyWRAFzWRF5wm6Nw3iXKM7zKESUKvp1JlCsGuNBegWgo15uNEzLFY/GZrRP6AEd+9ElQcYGFegYFXRNCsPy+a3A2uxhpa/cDYgguVMVZgJ9amRGCeDNuTigAeA/p/DREJ8oFcDOZAE5EeKE48LjEW4C9UAkMT2qWwVjkWwJp79lcAPJMsSGC9DsJ9bYA1wDeLS6/tAJOfbBnhjTEkQmVmvub662o4Ga33QQFR4i/zxYDqnXOid3i8cGWU2gdZUbP5lfv+49o/DTzygRtMIrxuLJ3nSkCUHPvcD7JHI/NjwVYlgRLfI8InCUnm1kgCGLc5mMjUzAoJQJJEWaEWg1imJA7ljJtt/I5/Fho/RKRIs927cplIAgCIi0GT2bajAI72sb4P36wUCS/TVwiqmLowVxvEoNODZND7NcYVPLkT3wirAt/irVjSyXRkFkRBLjEVZhZJyYF1Bql93tpLhAcJ0uCVcr0WH9eB7e0DhMKgLOSN5D3RO716m34zDxLlgALYcnoECeJ3kxm9fQBSoSgUCakqhMDbHLkwuFkUKsEpB7eg8Qced9jEUqghsMTU9oxzuZZzhMl5OCUK2eHuz59hKsOLl9H2J8LNG8BTsstcSXeLMW8bw/gOZXUppSSPYBrZNUtIQQ6tUqahFWqI1t4UUygppOLcUEQEBykRayfKgIhQiEuFtgU1/kjs8iO/6pfxbXqP7DF0R5RlpHSSr8u0OVwKGSABiCLuS9hOsm1352U1Z8ALsn2xBADoheVmwIW5PnbdRHkArhFuBk4KV8Wz2eYd1OchRfXHMaXO8/i3kFJGNE+ymeTC37qOfPw3oBF2qbVB9epAJ42bVpdHq7B+cc//oFt27ahb9+++Omnn2A2ix3Fa6+9hr/97W+YMWMGNm3aVK1jzZ49G8ePH8eECRPwxRdfQKMRb/3DDz+M//u//8OcOXOwdOnSAF1Jw2KvcMgySXZNsKHgsNSROk1R+DNLhc6ynRSsjOVFYhypUf4jPZdTDCNnnUqOj/YI4G0XJLGsFhiCnL6dkbW05tZ8/PGh+H/hBekzINZe5WKHrCgWBbBW/Htr1CpY9BrPjGNucTnieQ146Sjw+WRR7N/6KdBqOLD9f2A/L8RDJZ0xG/chnpstrdAYccQejw447dtG1yyi90swLacEXUq4l7YlSiwX4SZdsgBfYjbojDbZ/vkZlcTpF2ejyC4X+YX5uXJrviUaaS6xbYdO1hk0V4hXE7NA21FUVoFmXnFObuKETOxhyVDxmbAtMUBkO5+SExcQIis0D4gDzmYdW3sEMIqzlF2fIAnga8xeHV/+eYSb9FCrBFfmaya3AIckIixH57nuIpUZJqdySZNB6v3yOQaXBdhdZzMHvAW4AACDDhXyAZGxhgLYyypg15jhfiqi4TXw1ZvRqm1X4DevgwTVrAOdP7YdbuuTgGahRmjVAc/JSBB+8baUWY060TrK1931tviafQedTkENldmPZVghBpi3qubAgtjgIBi04oTpNUncbziuuySAz/8BtB/ve3yFxDh+MQSL7ecswPx7Osqq9whgjyXJj7eT1csSGaGTXDH5rNZBWjUcTkmI8XXdZaWQLh12iRXpJZhRJh0nzOTKUG+wSQLYnWOiQurvSqDDqmMOPMS5LVdGhJCHvvpTcgEc3hodYiXLPR8HrIRRsOPUBenvEKZRqBvrRRjyUVRWAatODeevLytuY0YJYm3iPXBbgL0rJkQi1/PZytWnj7cF4SSX1CrEpOwCHR8SBJNO7fFM++t8Pp79/iBKyh2waKW/sYoTkgatGqNbahF88nvscyahZ6wGUHoMc1Plnn4ubEFaxNmVn6sQFOBUmQNF9gqZmAQky6d3CFnmxQu41pUYs5/6IFBwEghy5aXwtgC7JlQK7RU4k13siTEXBC4khxPAa509MF7tCvvJOqlYAslDcRZMEVKiX22F9Nv61dkRY1wJsJJU6bCiEPmuPr1lhAnYKbcAJygIYGdRpqfM5Ms/HfHEZfNUxwVaVSzd+xJd08kADdRDFugrlbKyMrz99tsAgP/85z8e8QsAc+bMQadOnfDLL79g9+4qElIASE9Px7Jly6DT6fDf//7XI34B4OWXX0ZERAQ++eQTZGT4+SFd4aTnlrrzU0AQgM7xNsRyA+q/iq2Y8P5++U5lRcqZhhVcv1Kzi2XumS1iI6FxxTGkFmtQxirPNm4p9xNP6w/G5EkqOMEIa5w4K+3C7f5k1EttCObib2SJsEpygGW3isK1ohRYv0CcCPhpHoSyAoxX/4a2whkkqKT22s3xuMj8iA5XFkHvl2BabrHcJdkcDZilZEW4JAm/DGZDkMnimcEHgNIs7m8gqOVCqyjTxwW6Io9LTCWoAFOErC40786r5AplFOwQ7HnIy82VuwHFdpM+uvbTcC9zWKLlVgUXF1koerdQuGd8zdyiLNl9YFzSqHAhD9e2i4I13ytBVn4aVCrBk8wpHPmyRDCwJSDMLJUWyhJ83Y1OOhUGzsYwsYQKgGOuJB18vJ1OcMCEUt97x19PNTDp1LJEQCUqaZKAryXK1HpAo0dkbCKcWvlEQk3PCYhJP0j8Eg2Nd6ykNUjrWwvY2+KrZAG2xsq9d3h4AeyOR+REZTazoEW412/KTZz0vkPaH8rb1EQAh6eIHTJf7onrcyO55EEZHhdo5eOHC3mYp/kYL2jeQyjyEW/iRC6TC2CTTro3RXy+iPAUsT8BXLVy5WOrC3ZpvzCza7KOt6i7xQ3n8VMKHVJzy5ABBdfOLlOBaSuB+7biYngfz+JR6l1yF9TwZERaDWJtYMBTy7wyMi5KfV4EL4B73wuM/Bcw5jU4ukoGo1ChAIUlZcCqOWhxfpXiMa1CkccFOibYgMQwo09pnEhBCivjK13EeT3b/izAgiCgNecG/cGWU55kWDJ365Ic2X4v6hbjee2HWBH0T/y9mxOK5HCZoIsyPX8vm1Erm9TnCfVTCmnbySx0W7gOo9/c7BP3mnfxlOw7znBhU14xwO5EW4WlFTKrfbMQoxi2xpjMBXqdo4e0sz0PKMlBWa6Ud6SQe9ZRnC3z7jNwAvigswWKNdJz1Eklttli0Ih1i71coEMF37Gwyp4HDSqgRQXKKhyyElhuquMCrS2V7n2Zoeb995UMjTr8sGXLFuTl5SEpKQldu3b1WX/TTTcBAFauXFnlsdasWQOn04kBAwYgKko+Y6zX6zF27Fg4HA6sXr26bhrfyOBL70RbDYizBckG66crwuCAGqWMm5UsK/SNAQbw2+69PsvOZMktwGZLMOcOInjiqvxhq6jBoAEQX94V/Mwr7/sVLovzcsdGuV2gAd9EWADEovfL75LXOr7wJ7DtHdEl3EULIR0dTbme7w5rM3lNWZ6cU4CjXNECLHNJtkTJLRlc5u0MZoPNqIOTHwhy9XShN8tdbc9ugzHHy3LKWcRhigQTVDIBzFsz/XWE0UIOMi9yNXUhALHS79It0HQl0iTSz2eB5Wm+96ZAG6FY+kIu5C/JrABCCylWrX+ME6/d3Fme2AvwJGmbd307dE2wYWZHbmZaHwwEhUgDNwCXnPKBVB4z4s7yuchjXjFbrkzKxWUVOJst3rdcyAfJIUIhrlFx9TMj2gBa33qilSEIgmxgVCRI9yiGn9J3D5gFASrveGJj03KhIq4efASwQSu3jgK+FmCLrwVY5S8BFiCPAS7KAAovAae3eBalsXD0UpqcA0QLsJvze8Q+w5tKBLCdeVn9IlzJSPl3O+d1FWWR3h+epEJ+XKAf1SzHXZofMVmzETO0azG6tXRM3gJs0KpkokDmAq01yPMTnObcS3QWZBZLwsqdS0E+oZAr/l8u9S3ukojnmcLAPmU00GIgENUe4T0meBb3KfgJuHRE2s7Vpg6x4iSkPwtwhUqa3HQWSW7toWpurGCOBPo+APS8C2ru2QkT8qD7/XVgtxRGuNPZWvY3s6IYMa4qA4Ig4M1bu8Kmkvft8hhg6T57l0IK9RMDDMjjgNce5MrzBHF/K14AO50wpG4CAGicdqiOKAt4Txzw4VXAy0nAm52Ak5tgM+oUJ74B5UzQjDHc+u425BSX4/CFAqw+IK/8UJLlZSQ56yqb6KjwGVOGuaomVDiZrMyTx/256JIsrn6bsy3yGfeeyD6Jslzp/KcE7rdfnO2p/gEABof028qDCRkWaXJ+esIlxAQb8PR1baFiFX5jpr25R70KB/V3Yqf+fiTvfh7tvELhLuSVKuZVOptdjPV/XURBablYPtOFwxjhs+3VDAlgP+zbJ9Zw7datm+J69/L9+/crrg/Usa5EzuVIM4dxtiBEWPSyF945JgqPQnAvFnuhvB6wi59+341jXtkJU7OKYeQtgzoTbustlVXKVuiwcsOlv4WJFSmeyy95lbgAmyLkAtg1QxuklV6ENqVSSLs+AE787Hu8X+QZexOFDLTVc51FSAv/AthZAZaTqhgD7GMBNim/+EQBrIXAlQQJ4+v16Sxyq9+6+Zjyx2RMV6/xLFLxLkKWaOSVlMtKJfEWYH/ZraOFbORlSK7q+YJVVhvX/TwZ7NK9WbyvBJ+f8f3bWyMTlDNv80K+okS0QgCi1Tqxn9QWVT4szgL5RAAA5Ivf+7UKxzf398O9nbgBp8uCHM5ZgNMccgG819kKqSwaj5Q/KFteEJwCp5PhRIb0jKo1OjC9dG02FKCf6oC0U8shvtdXDWRxwFx5Kd4CLPCiwEcAN60ZZOLqwccFOkgjt44C1bMA+0uABXhi+QGIORe+vMMzwVmsi0C3ITfhrv5+qmnEdBbfRYAoVLk6oR4qiQHe7mwjXxDuyrvB/57tUt8aaZXeVZ56onwSLC5shrdQPaj+BgMTpXtZxPXrBq1a5spa5OUtJEuExWXuhyFYJoLCTNWzALuTb6V7C2BBJZaDc6FuN9bzWVWSJSVNDE4AIkS33Q6usnmZSgJYa0K5nq8jX8B95sYW/AQI1+eGoQDBf0rid7czGdPLnpBVC7AKxWiRswVYfC3w2xvoEmuGnsn79ijOAmwxSP2P9+SOdw12npQoZYNBhI6vB83l4sg7KzcI8DVyedyibvv/xP9L84CPbkAb1VlZ/5LqjPR8ltUC/vVlYOn1OLxjreywu07LrdEV3iWk3M+Rl/UXkCfsOnwmHc9oPsbjms+REuF69jnrLzNFwGEMRyrjJr2yTkDgPDhyzFL5MJTILcBGJv1G8pkRWcHSsz7cmobfnxqGW3sliJZyp9fvwg+PapZDJzgQIeRhQM7XWKl7Gv1UUg4Xe4XTM8ZkjOGLnWcw5q3NGPDSRsz8aBcmvbMVQeXS35KZfCf0rmbqTAB36tQJX3/9dV0dDufPn8eDDz6IF198sc6OWRPc9Yjj45U7M/fy1FTlAt+BOtaVyHUdY/DdA/3wnyndcP+QJJj0GiSopReee3aWd5V65stteHed74RArJDlKfni5kx2EYyQC+C+SWGeOE++FrCbkuie8uzJfPKkqvBTow+ArwB2uQ3xFmDeBTq3xCWyjq+XjsEJG1kdZADNhItI5OJkNeGt5CV1vChOP+yTlOqclwU4zWHFr+nKqe8zEAJbkA4qTgBH89m79WZFq9/1amnwopPFG0fLPAIAcTbUjb+Z4CghB8Vcjd88dYhsoBkniKWQgsqk/TOYDUeYb73b2AQ/iev8xa+GtJAnnCm6pJwZsvCCOMvsJpf7PYeIEzJh3Mz7BadNtvte1goGrQp/6HrglfJJnuXPHYrGI1/s9bg/A2J8khAkTXyECQVyC3DLwcrXUgV8bFi+UxrEagTOrY0fMId5CeAaxgATRGMhwqyXZT4OM+l9XaCt3gJYIWTBXwIsQJwwanWt9P2MVEbM2H8WHri2nU+sowedySPGACjXA67EArzLmYIiJolaT+JJmQDmLMCcAJYswNwEZaif9yggsyTLXKB1cgHsXTIPYVxiPS4ZIwxWTy14AFIoCfcOlCzAkii0uwSwjwU4rodcPFtjxWXe3PC2x529vSsOWNEFWm8G49rCCytZFmjeYm2S2tRCSJfVAn6w7GEUIUg2CRkiFCPkl6eBczvE8KgM7n3vQhYDHMQLYOk4Jp0aeo3/sDDeBdqNTqOCkflxgfaeiOFisKHihHbOadGlOHWLbPOHUh+WhQodYM09n90TCSVpB4AN/wBOb0bk+kfAe9254+XdCPlyizByTonjHa8EWIA8Yde4829gpuZHPKD5HsPyvxUXcvG/QmRbdIwLxmnG/eYzj8oEZEUYN8lUnA0TF/pm5vLP5MOE3NBO0rbu0maAj/tzZWgF+e9HLTBcq/IKHXC5QS/efApPrPgTBzlX6fSLF6Bh0phFMEeiKVFnAvjQoUOYNGkSunTpgkWLFiE7Wzlba1X8+uuvmDlzJpKSkvDOO+/A6fQTTxBgCgvFF7jR6JtCHgBMJnHQXlCgkPEugMdy0759e8V/J06cqHrnesZi0KJzMxvGdIrB0DbiDFO8Suqo01wWYL5+76WsLOTlyYUuIMZ6HkqXfsCnM4uw/WSWV4kWEwRBwFSXFThbyQU6PBmZfEdWkC6+gC4dUXYt48mrTAB7uUC7Y4B5F2iuY8pzu0Dnc4m4+tzv9/CJQgYiyyQXH11UsnJ8k4ui876JnEQLsCRK/74uA29uU07Rn8FsomDnBknRAvfb1pmB+J4++8VyQjaIs8rCEo3zufJZaz6jsT8LcAyyZSWOCjShHqsqAMQJlxCCQqi5LN+XmA0FMOKsU27dTklOgSIaneiq7E1kW8DEdQxFl6QyHTzMKbes53KeAjbxWbQZdXCX2fOeuNjjTEKU1YDm4Sa87bgRt5c9iellc7HcMRAr953H5mPSfUyOlE889Ff9CZt7oKXSAM37oTbwrnHZTj8u1PwETbhXJmiyABNXKCqVgBn9ROtr35ZhaB1lVnCB9hLASsmuKrMAA8C1z0HMLs2hCQK6z6i6kXFcONbFA77r/ZQpAoDzCMN3Dtd7wRIDNO8vfpa5QHNJsDgXaE8McBEnsMM4a5c3nCXZOwkWLwrKHE5ZdmL+nY5yueU0g0ukGe4OJVFKKqbgAp3unScjScFDpu318u99HwRaSqEv7kzQii7QegtUnKDlM/ObOcufTHRzFuBEleQlVcgMSIfY3nwmTQ63MJZA8LjGMrG2uxeyGGDOBbpdjPQct1QK/+FQsgAPTI6AivubojRPGidlHvXZ3gOf2CzntDjO8rJuBjmk4+Yzo0xgui3AfH8bVn4BHQQpzjfLq0yS4O2ZBYiZvxUEcLhKPH6ycA7XOzd5lidlbhA/8BPdke3QwVsAn9sBFR8Cxyf58iqDxMdr5zETCsK5tK9FGdK4sgYCWAnemg6IbtD7zubixTW+Y8FwLpt5GVPDYGlaE9h1JoD//PNPXHfdddi/fz8eeOABxMbGYuzYsXjppZewadMm5OT4ipmysjIcPnwYH330ER544AE0b94cQ4YMwQcffACr1Yr/+7//w9y5cxXORlzRMIYoJnXUaUzsCAq5jtKEElmRdzexQhYOXZAy993z8S6U24vlJZVcHfpN3eJh0KoUOyxtRCuZ63B57nlgxV3Af3oBS64TxbCjXIzB/e0NoIJLtJBbAxdojwWYc4FWigHO517aSUMl9zQvWqvOwVgqiVdNRCvka7xEB9exVmT4dk7FpXYwbib/tN0inwzguMSCRcHODQR5NyvozeJA4cb/Af3nSNsgBxpX/UlLOTcoM0fL4n9Vgjye1eanZmK0kA1VkTRIKNaGyQaawUIxWgjSzG+ZoPPMnh/irMAOJiC5stJlSjGsEW3kScKcFfL4NB7+78gn/XAN7NQqwSMyvQXwXmcrRFkMSHDFa212dsImZxe4B8sr90nHTo6yyKytvMUd8T19B+7VxMa5QGdVBClvxA+YvS3A3rU5CeIKYu6oNtj9zHB8dndvMUyiqhhgndF30izY1+tERlR7MQETT5fJMougX7iwD9m7xk2xf8PDeRaG31KeAu5aBzywQ7QoA15JsHgXaE4AF9jhtBfLRak/AWyKlIUU+STB8rJwF9kr8OKaw7jhP1uwv8imeMg8ZsSJS9IxPTGtsrJSueL/Ci7Q55lXdlulEJEOE6V3W1RHYNh82er4ECMm90pAjqDQV+rM0Fqkc9ggid4gLvYTBu796CdL/ykWDfc7n7cAt9F5TQ7neCV7glcMMDfR3irSgmfHtsOwNpFYMM43MSRPmFkvC9UBgOs7hPnmPXG7FFcmgHmres4p/8nbINaLfrdijCxkzeNK7mV0GKGWKjtkcUmwyiqcCOI9ztyc2e6TARqQLPWPab6UjSGtWXvF3xJfCcJlAZa5QHNu+gUsCKZILnyhJAcmnVtiMVmt7HwYoTaFy3/Pbo+OOhbAxzMK8dCyPZ4awTHBBs8kB/+8ZCJYzHzfhKizMkht2rTBypUrsXHjRrz44otYt24dVq1aJUvspFarYbPZoNfrkZOTg5ISucBhjCE2NhazZs3C7NmzYbHUbhBXF7izPhcXFyuuLyoSH+bqtLEuj+Xm4EEFCxREy3Cjp+gS9JBeWpILtDTgNgp2uVXXRayQicPp+WCMYe7yfTh6sRChkM8AurMwBxu1uHdQEnI2+t7XoCi3ABY7kfILh6A9sEJceXab6NZzbgew5klxmbMcGPi4+LkmLtCCrws0HwOcW1ImumzxrmvWWKDdDcCv8vhfAPL6g2odENwMBsNx/FLaCYPU+1FqaY78jncgcuvzAABNjq9HQBjyIfDlJZjN2x7BrQsRRVFlFmCVGuh8q3gdv70mNk1giBZycI5FINiRJU21WaKQliH97lOircjLqHxGGhBF98VyeN5YJfowcaCl1nlidbtwBeWzYIN7EHGIJWIExM4lTxOGUI3/+CeYwn0HFpFtRUsDdy6c/EV5f96Sr+ACDYiulZmFZTjBYj3LjjjjkQsLIqx6vzP0fJH7VpFmIFsSwDH836SW7s8AEMp1gBfL/FmAeRfoVmI8HXNZcRTKwhDElQSfqb3KLNCAmAjLzr2Xq7IAA8CQvwMHlovuooIK6H1f9RrHn1+p/mglMcAvzxiN2KSOYuZnHp2yCzQfA1zhZMi+dB4yyebPBVqllrtA8xZgndon4/vO09lSORd7CT5WOOTBbKnNXRNsUqKmKizAar0RKHWLShd6KxCv4O5sSwCm/yAKkU63ABq9zyYvTOgIe38j8F+5OIbeIgoaFxEeYcGglwlg5RhgHt7CmM8lROQneAEoJkqyCCUwohTFMMgEMADc2a8F7uznJ77cizbRFvx2XBxX6dQqDGup4L3oLklZmQBOvAb44yMxzr2iVF4yMnkk0PcB7N+3C6/stOOoMx4XEIYbVZs9m7hdlA2F8sRWI1S78RpuBiC3AB+9WIAopRpMZ7cp/s1NKEEv4RBGcoIaAATmBI6tk7lAI6ItWhvM+MDJ9XEOaRy7xdkBraO43ydzwOgsgiAABmaHjnNXzmcmBGnV4gSB++94/Geg/Y21EsBbHe1wjVq0VscIWVwpRuAfq6RrUAnAm7d2xRc7z+LIxQKEQ3pvZbJgT+mspkKdJ8EaMmQI1qxZgxMnTuCpp55C165doVKpwBhDRUUFMjMzkZaWhuLiYjDGwBhDZGQkJk2ahG+++QapqamYN29eg4pfAEhIEGdxz53zLbvDL09MTFRcH6hjXRVws3n5LAj5LgtgEaQOx4wSmBQswFHIQVGpHev+uojVf4rupkbBSyhzZYgeGZaM24d3l6/XBMEYGidzHValbpZvk3tGnj7/wDcodzhxPKMQrLIkWMYwxSzQQX5igHOKyr2SKQmilaGDlJWyXB8KJ1OQqCHNAZUa1iAt7imfg+llj2PH0M/xfwek+2jIP+mzG+8mVcCCUAIDimFAMZN3+E4mIAtW0WLNiR7eSns4m+HEJVcHrzXIXIXdpa4i+ZhhS4wsBrhbgg05zI8A5gY3MUK2TPyXGSIAlUosO+Wii0rqONK5DMt7nJKloshSifUXUHbhjWgjDhr5AQs/4OXjXl2ZoOF0yidKONc+dybog6wFDiTdjdOmTphXficA0e1wUvd4hBi1MOrUmNhNeTDdOsoinz3mqWUCLEDunXCxzHcACEAugHVG0QMAgmhBqc7gnyCuFHjrqHfJNzfeVuHq/AaC44ApXwJtrgcmLpYyMlcFf66CdN/1/ESql3t2XEIr5eR//O/ZWQ5UiILCotdIrsYAzp2SrGFlGgvsej8W69J8uQWYE8B6jQpqlSAO/l3wMYnbMw1gKl+7zNE8aaj68NBk6Tq8LcCMySyVrWLFd/ZR1gyfVAxDoS4CGPVvQO1noB/bFeg5s1IPGn2wwiSf3iKLX04RxDGdGSVQcWE5svYaQ8VqBl7wYj2f846KqUiTb+gnU7C7f+ddoGsKnwl6QHI4LPAdi3nigCsTwNY4IKG39P3YT9Ln6A5Ay0HIbX8HfnV2xgWIz5O8xr04trCWyXO0tFGd9eRC4WPDD57Pk0/Qu0nfp/x7ATBfqzTlAjHpFp81OrIN4kOMSIVyje/Vjt6IjoqWEtUBEEqyYdJpfOpkFyBIHBO2kBKxYe+nwPm98vup8FtQ4ienJO7DhAK0CVPe75FhrdGrRSgSw8QxMu8CncmCZWPTpkDAskA3b94c//znP7Fr1y5kZ2fj559/xscff4zXXnsN//rXv/C///0PX3/9NQ4fPoz09HR8/vnnuOGGG6BWV16ztb7o3Fn0z//jD2WXDffyTp06Ka4P1LGuCjhhUGaOw4SuooiRW4BLYVawAKsFhijk4D+bJGtf50jux641icLIhSAICI+MhYzQlhBUKuRqpMGM/oJX5sK8M3IX1oyDmP3eagx/7ReUXDqtfF2GYDGOtAoLcGywdJ0nLhWC5XEdmzkKW0/l4fFfyvCqdhZ+cXTCzKL7PDFB8usQhZ3FoIEdOmxydkUms2BjJnf+imyYvV6+vNsL74Z7icldu7JghQNqBAdp5XGfHNvPl2H0m5uxdMspMd0+N/hzu+JEcOeDOUrmAt0pPhj5gh8BzMXTxAsZsuNUBLn+dtz5unIC+CKXYGqTswuWVozADmcKCvs/pXwuN94DXEEtZTr2lyAiaaj02e2WWJAuT2Bm4yzAnIVpY+wsvBD9OnYw8VojrXo0CzVix9PDsePp4fjXhA6yZwcQE5I0CwkShWezPrJ1FVqzvF5oDeFjgM+X+OkMvQeHIxYCT50Dbvqg1ucliEYJ/6xbomV9i7Scs/oEhfhmjvZHy0HArZ+KE0fVhRe1BRekxDmAOOnGC2CuTByCQsXJKiW82+uyAguCgI5xUp+g/usbz+dd9mb4aI9vWBsA0U2ay7jrdoEO0qo9wpV3gz6TLfVPZU4BDos0qenG7QrcMS4Yg1O4iUiZBThHnoAJQJtm0jv7mYq7sKz/T0BXL/fzmqIzyTJgAxCfEy7eta0qFQBDMOf2KraX62NVapSofd2pTznF50mvUckswCH2agpg5EIlMFm95WpTUQZ8MhFP/XkdPg96EY8YfsDf+keKkxrelOSIbsJFl3zXuTGFA80HKq+L7gjAtyYxnxPEbQGOcvqeY4RKtNoW2CtQ6kr0efTMeZh5g4hbQDorgBMbFZvRQXXa8/mLisHSiiwuuVdiP8AQDINWDa0lSl7vF2KJsd36XjDqdfLEbMXZMOrUnnEgAJQyLezQicm7Ok+WPCmYE1gyWu7ZEcPFCbuo0Pj+jtc7u8uSuvYJt/tskxBqxP1DxDGjWwBHCGQBDjgWiwVDhgzB1KlTMXv2bDz55JO4++67MX78eLRuXc2Zz3qmX79+CA4OxokTJ7B3716f9cuXLwcAjB071medN6NGjYJKpcLmzZuRkZEhW2e327Fy5Uqo1Wpcd911ddL2Rg9nAQ6PTfLEGvEzxWaUwqQ06wjRDXrf2VzP96EtuZqoOpPvDt5WPVcpikKtJHYELhMeANEC7BXrazz7CywohtHp1am5cVsIuU4uWKEOcLtYSUxmFZUhP0M6T6E+ElPf346vdp/D/xUMwrTyJ/FLRXuccSrMOoe5BbD00jqXU4JzzhBZts+WLtcpd/IlXgBfgs3z2TsOOIPZYNCqxBe1HwFchCCUVTixYOVfuPuj3XBa+czMmQhCKay8Jd8SIxPAzUKN8g6Dh6t7aRVKkCJwdYDdlmau5iZfQ9gt7EOMWoxqH4MFFdPxj8jXkNx1sPK53HjH4YW2lFzhTAoCOKojEMllfnS7QPNu1MYw2SCTzwSdVVQmZVgFEGkRz6VVi/Uy9Ro1+rWSi/KW4SZo1CrRmjDtexS2u9WzTt1urH/rRjXgByMXStTKM9BK1pHqDvoJ4kpC5yWAleDd/gPtAcGL7YpSeWIfe55UvgcAYrtw7fIVlR60Xn2mXRI7HeNtAAAdytHyolR+5htnf2xNq6RUC2dtcye35DNsm7lEWLwABoBio4IAdiWDenColxXbuwxSuXzM0D5R/jcz6uvAwOLtDQSIrvJRUviZTShCLLLkGaB1Zp93c4nW5nN4twv0kJRIWQywynuM4kd4ztd+jH36mVCtelQ+QeJNSY7v+lO/AsfXQ23PQR+2D4/iM7T76VbZMyHbvyp3XWOoWGtZiWjR4ONdkolPWhqMIqjhUKwOwccBZ7vigC+ek/pdh6CRJ+g8t6PSpjqYgJcrbkGFT2SoAIz8p+dbYrhZHgcMYJOzM0JCXUYK3iPMVQpJHv8rPssGrUocW4x+Wdqei19H27GeSQKeHIM8y/wlFoxzLFzm0dg5uNB7Nzw4tJUn/MCdZ4R3gb6EYLH0WxOC6gD7QafT4cEHxXqcDzzwgCdOFwBee+017N+/H4MGDUL37tIg/e2330abNm3w1FNyK1NMTAwmT56MsrIy3H///aiokF5kc+fOxaVLl3DbbbchMrKJpCDP41zBbc08blZFsiRYpfKZPA7vIP8esXzMlsIst7dVzzXjVqSv5H5nn5S3E8Ag1T7Zi7hC0MkK1TP3eRSzQLteLNvfRegvz6CTVXqeLp2XXtp784yKfdYZptBW13VYOFenU5lFAAScYtJAaaZmNR5Rr0CfSHFwxJdKkFuApc/udZ54ZT8uYfxM6PpDF8FHicUJmTKxDQgoM4Qho0ASfHG2IGjNyslAYI2Fk7N48KUSmNsa66fkiPtaEkKNeHtKV6ydPRAr7rtGFI6V4T1Zwmd1NHsNegAxoysn+j0C+CKXPdIroRnvVphZaBdrHLqIsspnlgFxIMTTms/SqdHDPGkRMPkLYMQ/IYz6t28ba0AInwW6pFzZnbqWCbYI4oqDd9/k6sbK4GNhvZPC1TXGUHlpGa6cnSxDs6AGOtwk/g8ArUf7P6ZKJRf6XPyu2wI8TPUHTE7RGlfM9Fjt6I3jBZUMlrlSNIUuzy7e7Zm3AKdmyQVwjs43zjofRrSMMOHatl4TwbwFuDRXLiAAdGguF8CZBWWoE0xefZbeAgSFIFcnta+tKlVm+ZNZf10ouZG7XaBHdYhGoaAwoV8FHVSnRZfl3UuUa/JmHAY+GAW82Bz4arp8HZ+3wrP9X8pCtzhbrJrhD0Et/n3iuvlOsmhNYnlBwMftlrcAqwSGFkI6jIKvRbO7cAzBLhfprMIylDucKMqU2l9hivZ4yQFQrAPMc5zFIRPBOGvtKl/RfbrMmyIxzIjTXgJ4laM34mwurwA+kWZxFkx6jew5cFv1Pb+H5OGi2OVpORi48V3FsoJ8nWQAOKlNBiDIMp23NsgnLBLDjB5PS/G7+PfwcYEOaloW4KYl92vIM888g/Xr12Pr1q1ITk7GgAEDkJqaiu3btyMiIgIffCB3+cvMzMSRI0eQnu4ba/DGG29g27ZtWLFiBdq0aYMePXrg4MGDOHDgAJKTk/Haa6/V12U1PHxsZHAzhJtEAcu7QJuEUlkSrFKmhUEQXUp5S1+01YAEM9fJeCctAXw7K9eARbDEgCvXJ+fMNvlsOoABqj+xUrjG8z1bG4XMUhXaCeJLt0QXKs7X+qsDfGID8KOYSOtJ0wlMgVj2ouiSZAE+ViruKwjAwhs6oF+rcJzOKoJ+629A6ibF6+BjfU5misL6FItGB5wGAIxT/w6ogWPOc7gWj8higHkBnOmVLVtMgOV6IfoRPZER4WhebsRp1yDmkioCbjkYK2Qhio//NUfiYmGFTOBHBxtgCA4Hp8kldGaoItvISwu5UFtcHZAfi0uGy7IdH2qERq1CikJtQ0W8J0t4Aeyd7bXDRKDVMHlCLLcLNF8+IaqdbDfeBTqz0C4r7+G2APMMaSMX3smRXs+4IAApo3z2qw0h3GAkr6QcjpuW4NcPnkLfi597fn/umXuCuOqJ6Qzc8Z0YDtPxJuVtOk4CDn0vitH+jwa2PYIgWoHdeSgK0iUPFN792Rgmlii7/3fRVZYP01BCb5biHd2JsM7vxeCfZ+FznQAj1xevcfZEEYLAKgT/I0june2e2DbolAVwplcZmwtCFLyzoeQzE4a3jYJKJchX8N5Dzgp5EjCVBmZjEKKseo+XzaAUhUnM2uBtAXZ5wORYUmDLEicl2gpncIxx/RMv1l2UG0LBGeGQw8zIdVlAW0dZUJbSAricypaHV0khMYwBW94U6+m6w3P++lbMW+H2EFBKrAYA2b4Zp1GSI0/6qNaLya7cGMPE51WtFZNhHV8nrYtq7wknsOg1sqRNhQgCU2khuNrYkSt5VMgMcEIFqyBW/kgSzuMP1hqZRXYczxAQ7swCXI+ZNiQeCG1enbsEAPiTieOpSzGD0SJ/p7gwKMQnG3himAmpXJy2nWnxs7MbbrEZpet2U5wFk76FTwZoQJ4XBiNfEDNVF2UArYYDt3wCaIMUc5LsLw4Fn87rgqktUChmOu8GcaIiBpkApGfvgSGtZJP/IUYtzHoNwpn08GULNtkkVVOALMCVYDAYsHHjRsybNw9GoxHffvstUlNTMX36dPzxxx9oWVk5FS/Cw8OxY8cOPPTQQygrK8M333yDvLw8PPzww9ixYwdCQ31neq5a+CRStmaelPveZZD4JFjHmDR7xVthB6dEQCjjBbDCjKm3i61LOOpDY323daPQEQQLxRjDlZu5KETI2pXrLo+gEAMcpFMDJzd5lqc4pV7NycUAX3DN4k3ulYDb+iSiRbgJQ1IicU0Pr0RegKIL9ElXQqrDTt9SHImlYjZAPu4jTx2GpAjxnvlYgGGTZgT9uNBd36O1mJHYRZZGmhn1sQCbo2TW3xCjFnqNGhabn2QqegsQ0dZncQVTQecuORGpnPU8g7MA1wjvDieCc28O9cqgOfIF8X8uERcKLgCOCp/6gTy8C/TxjCKUO6QZgUgFC3BMcJCnBiUAdIjztSTUFbwFmDEgz6HHd6F3YbD9Nfy7/FasSfmHOJghiKZCy8FA92nKfQsgip/bvwHu3wrE1MPkkIWzPhVwk4N8DWD3eywiBWg9suqwCH7i2F0K6efnoc06jD6qQ+ikkkTICodoCS+GHhXMzxDSnRUekgCWWYB1/gfaZ5y+HkH5MGJgsoJ45V2gAXmiI1cyzPen9cSQlAg8PCwZnePr6N3pI4DF93NxqPSub6dKRYSGc8n2bisAR5C8v+EzQDcLDcLNAzp471IzDv8gfb6wH1j/rDw3BSB/hgp8J5sBKJZcQkmOWC3DDVczGYDc8ODtBs3FSwuCIJZalJbAyVk+O3LPXhoLl1lfEwQxpDCrsAx/puUhBlICLFVwnMfKXB3+dLpC49pPBRL6ipPhE97zKY3YPMyIfVxizXXObihCEGJtrr7bSwCbfSzA4ntEJjZtzcTJqpk/A1OXi+IXUCzLeLRc/uwVhIr30l1NBQCsZRloGyM+k53ig2XWX0C85wmhRtlYsFgXppwk7yqGLMBVEBQUhOeffx7PP/98ldsuWLAACxYs8Ls+NDQUb731Ft566606bOEVRlEmkMMJ4OBmCNeKg+5izp3WLJTIkmAdYQno6LJoxgtS7MvglEigZKd0PKVBilorurCc3yN2VK5BSnBoNOxMA71QSSyTF+PUUmbocywCPzja4wb1VgDAIes1iAVkM73izB8TXaDP75Uuu+wiAAZAgIGrW5fOQhFq0mHuSK86wN4vcrXe43pr4WbTC0rFa/nSMRgD1fsRL1xCnMtlXFeeDxNKZHV8O7dNwSG7CScuFSnGAHsswAnXiG5LfB1IAOGhYbCmSZ3Xec4NJ1bIlNcMtkTjkszaKf69I4PNyGdGubsY4BLAvvWQMxEMk8El1OK6oajVWJiOr5Rtc8lV47nGAtjbW4C3ALcdK9aELrwgdozugaiVm0hhDnHyhC+f4C2AvSzAbgxald/Mnf8Y3xELf/gLbWMsGNS6jqwYClj0GmhUgqfkUk5xGYrKHLiAMCxyjMMz8W19y6gQBFF/+MsE7W0Brgl8DH9ZAVBWrFjrPI2F4Xene9JRQB5MCPPrRiXCJ8Fy410LmOeo3TcnRKnKjB7NFXJFqLXyfomvjewSER3igrHkzl6VtrHGePcTrgkEFtUecGnCtkIqTujaAe7hhYIFmHl5HJ10CeAQo1ac2FZwm1bEHKVsvb10GMg8LnoDnNvpux4QrY5u/FqAfatJiAKYc4FOGS3P8sw/gy28wge8YlttRq2snq9gDAOKxLZ04ATwORaBEujRyVW+srnqArTOCiQcfAeFxSVQq7j2W2N9J63dWGK9qm9IAjgmIgyYsUZ5PwAJYUb85OyO18snIlrIxmsVkwAA8SFu0cpdd1Gm6ALNJSJ1W4AN3tZWU7jvc6XgAn3SKQ8RcER3AQ5lyVyghfxzWH5vX+xOzUHXBJti6FdiaBDCsvnKGn5C0a5iSAAT9YPTCWx4Htj2jjxTY3AzhAmiIOCTH4QhXxYDXGxLAQp+BSAJYK1aQL9WYcBuTpRp/Qieie8D+z4X3UtcFuHYkCBksBA04wS1Eg4mQM0VSXeT6gjDOmd3jLMvBIOAHkJ3DANknZZaYDChFEatSiaANY5iBKMIeTAj1HHJXbIWF1koHhuRItbe5fF+kYe28LgQedf7A8TkVreUzYcAJ47op3lq0MUKWbIJhAE9u2L1LnF/7yzQGYyzAGsNQNIQ+YwyAOjNsvMf4wYvJsGOZIGLo7ZEyxM+uepM9mweitxNJl8BrDPLLbAuMlkwzO4BlCCgZOw72PnKGQxW7/Nsc6G2Ajg4HuIfg4nPEh9DZIkGHv4DcDrkseY6VyIvd1mIczvkSUMi5VZsPgaYp3tiiN8Z2C7NbFhxX+Atr4IgwGbUeYR5TlEZisukCSJzJQNXgiDqAX+1gHn3X+9kflXBh7jYC4HULXJ3VhcfVIyCk3MczGdGhAlVCGC3BZiz+lb2HjlQ7Ct0WzaL9RUMboJskgCWWYCDFDevE3wswOL908VKWXsThQw00+RwAthXzKq8jnPaKQrgZu5+q7oCOKyV/Fnga7MfWQWEPwJc+FN530JOAPuzACu5QBekyzNRJ/YX+2x3DDkvBKM7iWKuxGWh5TOUA67xjvg3VAmAYAoDXMOUDoJ0jjQWjlK1NFmTIGRgkvoX9Dr5vriAf0SslViAw5JkAtjBBPzFRMf7uJDKn5vEMBMYVHjTIc/eHud2geZFbHEWTAaNJxcMIP5mBEHM8l0lChbgcywCn1YMw2T1BpxLuhUh0QkAsmQWYOSlwaTXYGCrMOXM9QBa2ypktYkrmqAAJhdoon44uw347XW5+I3pAliiEWrSQRDk8ahxQiZUkNyoxgwfJlsHMPRsHirOkpZXEQMMiC+8oU/LkppEW4NwEQqzyl6scvZRdPU6ZrcBELCfJeFP1hKnXfG33p2WFcUwFZ+R144FkKzPhQYViOCCgPK04bixq4K7cVCIPBMzJ8wsldT7Y1AhnXsxDrRlIlyQxJk+vIVHwGZ6CeBLzCZziUVrhThTnUWWOOFEoR4lTNqni4oLYDJHe8W7igOj3i3DYA31U1tRwQJ8iQXLLAimICNmlT+K1Y5ecDIBX1QMRpbLml1jAWyJBgbNFev2jvyXWNaKR6NXTrTGu0Ef42KdrPE+rm+8BZhncOvGkQSPjwPOLipDoV3qJI0kgAmiYQmEBdg7Cdbx9Z6vGfHXYpx9IaaU/R0fOOTJtPg6tf5w5/YwVNMCfCDfAKaWvyM7t/IN6fHAW1b5++Fdqqgu8RMDbItL9iSGVAkMnR0HpW0UXKDVFi8BzGopgPlsx0GhQN8HpO+HV4n/V0cA8yKaT+7IJUbzcH6vJLJVGnFSnp+o54WgSg1c9zIQnCDWWY7pIjsU7wJt1msgcBZiPgFWGgtHqUV6FhKFi7hGxd1jHmusKCCV7iGfuA7AMRaPUuhhNWiqLAVk9qqP7UZygeauuygTJp3aywJsgkGjrp67sYIFOB9GPF1xF9rZP0D+sBcR5zovP85Dfhrww6PAC3HAhn/6HAMAUgzSuNPONFAZqx4LX22QACbqB94l1BAMDHkGmPY9IAhQqwSEGnUyAeztlhzWUpoxNAjliEAebuvjSpXBv5z9xWkpEGsz4KJX3KsSvzk74IWKyT7LzzjkM2aebJZqLZycJdoqFMGYecBn/54hRZ6afW66tG8nT47gRhCAEC41SJj0ArdU8cJOY1I7ZyZIAwSm0gKWGI/b7SVvF2iEyOJV0XokPKZqN3qzTACn59tlM5FtVFzCM0s0MhQswABgC1MQf3qz2IGZ5eL4ErPJLAgGrQqx4SG4v3w2OtoX44mKewAAapWAmGDfmNoqGfJ3YPafQI87q78PV44Jhzh3bC/rLyDGvynN/nonu2oo+EmP3OJyFNul32JlsXsEQdQD3rWA3cgEcA2tOXqvGGBOABvajsB+loStzg5gXkPGk1y1AaiVJ/aKIC6vrgt0gd2Jcq9awL3aVBLLyQvL/PqyAHu7QIsTCKFmAw4zSaC1KOeyJyu4QGutXhl9XfezWYiRO241hFJMZ7GcTuvRwJQvxcRsbs7uEF3DL3JCMZ5zCXe7QDsdcjHMlXVSpIyz/Ie2FN3R+SzoXv02Ot4EPPonMOZVnzAa3uPNYtCK7tQKpLFwqMKkyf9E4SLaCgqZqwFpUlrJCswdA5Dcn+NCqjdh7s6i7MagVSHU3W96W4D1vhZgxTGeEl4WYCcTPB4VpdCjWYjRY3mWCWB7PrDrA9E49OtLijWjWzkkq/4xFg+rt9dhE4AEMFE/8CWFUsYAgx6XzcyFm/XIQrCsmLcHQSW+TLkO5PObY3FdR1fnW8bX2qu+AI4ONuAik79g+LJGbs6ySHwsXI+TkSNky3lhCYj1DCsc4oyoUydZa8PUJVCl+5Yj6GguQLQgJW3IYhaM615JYrXYbtJnrkauPwuwe8DBlyaKyfnD81mwNQNUao+AvsDCkKcWZwEvMhsusBCEmrhBjTnStzC7zksA55X43BepodG4yCXBkmU8VqoF7LZKeFmB1dZI2QysIAi4d5CrtBWkQU+szVB12aO6Inm49Jl3f/bKAA2I7Q33sgLH2YKQFNE4aunKLMDFZSgu4yzAOrIAE0SDYqmOAK6pBZh791w8ICt7Y20/SjaRyCdifqNiIn5w9MEnupuATpzo4nC/k3kBbK6iHm8akyYDi2FA69hKrFO8sJTFANfQ+6cm+HGB1qhVOKX2I9YVLMB6m1wkui3AnjwPKhVgsHrv5ovBCvS+B5jyOdCsp+hy7JmUZcDWtyXvO0ElT1jlFr3FWfLKF1UJYJ7w1uL/ve8VPdXM0UCnW6q9O18L2GLQiEmoFCy351gEzDGSyA4X8tFC8OO27c7NoRQHHOolgJlLANuqN2mS6OVZFmcLkiy6sjJIma46wHILcLWzLRuCwU+AFCLIMwll0WtgDdIgwqKHRiUgE1aUMT/H3fOJz6KYYil++4CzeZWW76sREsBE/cALYIXSNWFmHZxQeVxXZejM4oyhTZpZTdJynX0tBbBeo0ahTi7Wtjt9Y07PsggMTI7Eqf4vYZ9TFFq7nck4D/kgo8LJcD5X7GQqOAEcoS2Rxf+6aanLQQwvgFXh6NOykoHL4CeBrrcBAx8H2t7gWexPAD96bTKMOjWy1FxnncHNAttEi7K7+Hk5NHg1ZB6+0VyH+8pmowIauQUY8E1m4WUBLi13+hfAwc2QkS+5QMtq3iq4+nisEl6ZoG/o39XHfWhCt3gpCYWLGrs/Xw4dJipbQPxkqfZ2oRrSJqLRZGAM5f7mYhIszgJcxcCVIIgAw8cAF1wQ07U7nfI+1ttCWRV8DDDvwRKeAtgS0DXB5lnEJ+FLZdF4sPxhfBU8Q9HCWSbo4HAFZhq00nCzMgswAPyRL/WfZRpL5e9GXljyiY3qNQZYmkBINyRBEYX7ExTTBkedoqXyZ0dXFCEIc65tjb5J3DigOm7Qei+RLAhAmzHS913vS5/DW3v6fgCSAOYnU7RGIKR51efljwmIIWaPHQMePSD3WKsCbxdoqLVA8gif7dJYOGLimwMafkLGNz8LAMDksq4rWYC9XKD/dI3rvMcQ/vC2AMssx7z3RWkezFomy2+Sx0yy30KlqNSy59udQAsQSzwKLg/KGJsBDCpPFREf9nwiVqfgMOdIY8GDrLlnHNiUIAFM1A95nCusrZnPardFLEPJJdk9O80JYFnB9loKYAAoN8pnYH9xystYVDAxhva6jtEIsdkwqexZ3Gh/DlPKnoaSa9KpLLEtZRppQBGhLgbS9/lsG41MRAuSkFcFx/nWOeSxxgI3/AcY+owssYG/mbvBKZHYM/9a3HndAMX17g6K33+3szXmV0zHH0zs0EK9BTAnvAEAOotPEi5ZMgYXf7HmQFQHXKquBVitE+NtAR8LsMbiGy+sVavw0NBWsmVB2np8oQeF+BazBxRdoAEg2MvdqLHE/wJyd7ScojIU28kCTBCNBt4C7LCLyffW/l1ees1WScysEno/3ietRM+Wh4YmIyXKgmuSwvDEaN9JYqtBo1gr3q6SBIWsDnAV75HjZVIfojbaKt1W1neUcnk2tLUIf6kupgjJwmqOlsQWgHMhveFU8mRTELJBOi0eNL2KW8uewX3ls/HMmLZ4eFhylfv5oHDvZQKYz70S3VH05nLjdoHm43/NUTWbRHELYEC871WV3fIiIUwSdrFuK6xXzhE70yITVrSKslavvJHa9Yx5W4B1FvH34fIQKGBBOORyW6+uBbh5uLcFmHvWvO5biFDoUwfYb0I3JTjjQAGT2seL9fYx4jOSDj8GlIJ0eR1mpwPCBSks76CzucyQ0VSoFwF87tw5zJkzB+3bt4fZbIZGI3/55eTk4F//+hdeeOEFVFRUvyQNcQVRDQsw4E8Au0QtP2uZy5VSugwBXGGVxPgFFiIKNY50FgaVWoPh7aIQbtKjDFrsYcmwQzlewp0Iq0wrdUgdhJNyt1gX1rILaKbJ9XwPj61+zToefxbgcLMeeo0aulA/gyHX/eRjiLOLyjyllAAFARzfA+hxl5hgZPDfAbXG58V5XsECPK9sGoornLJSB+4kWAB8BTDvkuedCdo7tsjFhG7y50qxbEYg6TpV/l1QKybxAoAzWfJyUte0qqHLYgAJ5QRwRoEdZQ4pGR1ZgAmigQkKkXubrH4M2P6O9L35AHlSpOqgUxBQANBqKACgbYwVax8diM/u7oOkCDO852mtQVpfKyQAh0bqj5txVrKqLMCHmNQvB0VU0S8qWFYBBNYFWq0BbvkEuOYhYPJnsmSJY4f0w1qhr+8+Ci7QgiDgpSl90aLHSCya3hczByiEQPm7Ph6Fe4+Ea5RDi6I6yC3YShZgS3TN4sgjWle9TSWM6hCNMZ1i0DXBhvsGuyzorYaLybVcpLEwqFVq0bNLwa35d0c7FDHX76IL1xd7i2VDsDjhM+7/4Gg5BI+V34tSV5x6VRmg3Xh7l8mEs84kS8BmY3ledYCN1XeBBmThDAWcBZj/PT0xug3GdY5FcFQlv5U/PpI+Z53wZE53MAGHWAKirQGcMGqkBHw6f926dbj55puRn58PxkRXBW93lpCQEHz77bfYvXs32rdvj3HjxgW6WUR94qiQx+YE+7cAX1ISwHolC7A/AVyzOMqSyO7YdLYzeqsO4c2KCTjnJd7OsggMSI6A1aCFuhouqqddwqZULQ0oejj3c1u4SuwAUOWdw/C4UMB1a2zR1XcZ4lEqKaFWccXl/VkDQuQu0ACQnlcq2yTMO9uhIADXvyZmdFSJL3FvAZwG+T382tEfu1kKjl2UZ5Lkk2D5pPvnZ7S9rahmZWupVq3ChzN64e6PdiHcpMMNXWIVtwsYLQaJmTPzXZM9Ya0kK7YXXRNCcDpL6hQbk2WVj8dKyymRrWtM7SSIJokgiDXI3X3ggRXSupguwK2f1bxWt5IF2BwtimkvtGoVoqwGWV9hNWgUY1XNlmDc0CIWRp1aVt2gqom0X5yd8WHFtehpykC7YU9X3nYFYSk2NIAu0AAQ20X858WA5AiU3/0i8J7XvfMjZLs0s6FLM+V14n61tACrNWJSrH2fyZdHd5RPItvzgfJSsb69m5pagMOSq96mEvQaNf4zpZt8YZANSOwHnPoFgOj+3DzcBK1apWgBXu3shXkV0/HF+GCEdb9RWuEtlt3PS8eboOowERufWQO4Ko5U2wLs4wLttZ8xzDMOsDryfGKA42uSTNLIW4A5F2junC3CTXhrcldgbZKnfBQAoOPNwJ9fip+PrhWTYYU0l3kknlXHo3ureIzuIK8v3BQIqAX47NmzuOmmm5CXl4exY8di+fLlCAlRtsrMmDEDjDGsWrUqkE0iGoLCC/LkCtY4n00i3C7QsPnur+gC7UcA13DWNzrEhOnlT6CjfTGWOYbhAguTJeI6yyIxxpVsy6hTK8ZuqLnpcLcFOJ9/UTk463czLvtiwQXEg8u6qHBfqoNGrfLJzhtm0knu1P6Oa2survbjQm3QqvwLHpV0Pm8BfNwZh3JXMoYiZsC/y8UM2kcuSlkjrQaN3A3Ie6aa79CNoUDLIeLn8BRRWPphUOsIHHxuJDY9PgQxwQEeAHmjUgNdpkjfFQZHbmYOaAGDVgVBAD6a0cvvdg0Bb/VPy5ULYMoCTRCNAIvCYNWWANz2dfWSJnmjJKD6PuB3As87u77VoFU8hibIijdv7YoXJnSSWX2VJm359w6DCs9W3Imdgz6q9D0KoGEswFWgjesEtBwsX+hPqFdFlQJY8D/xz7tBu4nu6BvDXJQhzwBtifafSE3w6gMsMbV75qpDx5s8H/ewVujfyiXKFSzAh5wJuKhrjtBet8ifW0us3GOCe14EQcB1HcWQglaRZrSPrd512Ixa2binmXf2aK4Ot8WeDi1Xbzef1d4FWhYDrGSt9vYEuO5ladzMHMCqx8ScAel7PZs073ANPpnZu/qZqa8iAiqAX331VRQUFODmm2/Gt99+iwkTJkCnU3YdHTlyJABg586dgWwS0RDkcvG/xnDFOqqVukC7O1Y+qULuWTHxB+Bx5QBQYxdod0deASkRFF8b2BbbymNJFAQBYSbfAUHbGKnjd5dCSi3yE0+Rch33hQFcHIbioKaaeJdCkmUZ1hmVOzOPBVi5rUrXqoRBq4KOy7aciWA8UX439pmuwVzdU8hw3c8jFyQBHOntbuOdBMu7Q7/1M+D2b4C7f5aJbyW0ahV01SkyHwj6PQK0uV7MYjnwcb+btY8NxtYnh2HX08MxsHWE3+0aAr4MEp8BWq9R1V9WbYIg/MPHAbvpN1s28K4R3u9bg63SMnCxXpYyi0Gj7Ibrpz9WcoHuGOcr9Ia1rUZuBH/CUtPALp2DnpQ+awzK7sjVwVsAW7w8m/QWWU4QGUlD5fWQzdGiB5VGJ584KMyQu0CbI8XzqhTGBsFeE+rhl+f+XCldbgNG/AOn2t2PkOF/w99GuM6lIIAPswS0iVFImKZSyceOXs/Lazd3wbcP9MMPD/Wvdv8mCALuGdgSggD0SAxBtwSvvy3nPm4uOiNbVYAaukBbpXEh7yHZTCnJZ/sb4clN0326eK1DnpHWH18HHPxGnpPGu7JHEyKg/mxr166FIAhYuHBhldu2aNECer0ep06dqnJb4gqjivhfoJpJsHjXaYddnLW0RIt1C723rSbeHTkAnFUnINYpZmceOXggwL0Uw8w6H6tY94QQHEgTY3zPZBej3OHE0TwVFCvZJfQR3YvcCSec5eL/guqyXkQWgwYXuDDjcIuXeA2Ol5fJ0Jo8othfDLFP/K8fBEGANUiLzEIpwdXXzoEQEqfgZHo+UCA27K/zUgOjrF7tq8wCDIgiPmlotdrToOjNwK2fVmvT6t7f+ibETz3AquL2CIKoJ8xeAjgoBOjsW6u+2ni/b3vPUrYKu/B2FfUXA+yvP1ayAHeOD8YvRyX/zTbRFsRXpy5rI7QAAwAS+4riY8/HQJ/7/VrTq8RbAEekyLNdV/J3gs4ItBoGHP5B/B7dQVpnjgJKc8XPhRleSbCiRTd6Y5jcNRoQc4fwHniBFMAqFXDNQ2gBQCZ5vVygzzgjUAgj2kT7seCGtAAyj4qfvZ4XlUqo3AXdDw8MaYXbeifCGqTxFd2c+7ih4LTncwnToQza6meBBoBud8B58FuczSzA544hnsWKFuCI1sDM9UDmMaCdK2Fpp5uBfcuAkxvF7z/OBYo4P+kmLIADOp1/5swZBAUFITm5evEBZrMZRUVFVW9IXFnwGaD9CGC3BbjSGGCDVS6Ucs8AFWVyYWeumTVNKfD/p8g7gaiOQPsJYs1ivp0KoqVrQojHAlrhZFix+xzO2xU6O0Eluh8pxEAj4RrfONga4C1ivcvs+JwzJNETJ6ZVqxRnJGsi0JRS6Bt1arTgsiXuPC2VfJIlwAIUBHDjqInbFAn1I4CNTdBFiiAaJd7xmT1mKHpWVRurl1Wx16xKN/eeOLYatMpusH7EmdJkWrvYYFlyrWvbKSc79D2Yn1jVQMcAV4dBjwOz9wN97q39MXwEsFdSyMoEMCA+G27ajZc+87k0Ci96JcFy3Xvve6vS+HqqBVIA+8OWIHPFPsREC2+bGD/3IpK7Z94W7Msg2KhVLtHFedzpMqXs7LkQxzU1sgCHNAd7YBcGl72Gk0z8ndqMWh+vPw/xPYAuk6X3gTtvi9sjghe/gDgmbaIEVACrVCo4nc6qNwRQUVGB/Px8WK0BiiUgGg6ZBVhB/IGzAEPBTYifRfaOAy5Il29bQzfi6GCDT74QbWIf4L7fgElLpFT6LsLMvsI21haEflwW39fWHZXFAHsITxFdwpQmAZRidWqA98swwrud3ue0yRNuKQlYJbHvD6UU+ka9WuYaVOGU6vVFeluovd3YamjJJ+oOi0Hjk+UVqLp0CUEQ9YR3DGfPuy/veMHxYnm92K5iduMqXKkv1wXaqCAAoqx6JEdKAmZkewU3byVCmvvUdQXQOARwXaBkAeZRuu88rYYBd28Apq0Eut4mLZeVQrrkawEGfEOn9BbfifrLzABdK9RaWTlNdxkjvxbg3veJRoaEa0TX4EDD3TdV9gnP55NOcXxqqOFkslqtgo6rnlPdesUeQlsCw55VXl6dJGtXKQEVwImJibDb7Thz5kyV2/76668oLy+vtrWYuIKohgXYoFXDrNfgElP4MfIznN61gPns0qaIGrsZadUqH7GYEu1ffPlkRYZoKR3VQeqsMwrssmQFHmK7iv8rCuDrfJfVAO843nAfAaxgAeb3V5hNrIkFWFEAazXonqgc9xThLYBVavmLuKpZbSJgqFSCoht0Y3XZJogmR+tRkkWnzwOyOMFaM/Bx4J5NyvXMvYi1eSXBClJOguVvIlOlEnw8SsLNevzzxg4Y2iYSC8a2QweFmGBFBEHMduvNVSuAa2gBBoC47kCLgfLs4FztYmQek9cKdseYe1uA9VZfb62GsAADQLM+no9bHe0BACnRfu6FNQaY8aP4z9vbIRD48Uo4xkTrc40swO5Dcl4TPkm3qkPf+4FJH8oni1x1vpsqARXAw4eLN3fRokWVbldeXo6nn34agiBg9GjFyEniSoa3ANuULcCAWAvODh3y4TVrLLMAc8ItJxXIT5O+1/LFFuM1m50S5X9GNVwhMVS4WYfhbaNkVrN8pjDz7RHAXvcgqoM4i30Z+LhAW7xdoCu3ACvFAYcqiH1/KApgnRrtY4OhV0hIFaVUc47vWEkANyh8KSQ3k3v7KadFEET9Yo0BHtwlWvVGVJ1jpa7xiQE2aEXBqfLqRypJSuntBh1q0qFH81B8ML0npverovavN52akgD2sgDXNgMzHy524U/ps0ojJaX0rgVssMoTVuosl5W887K49jn81WI65pbfjR2sLRJCjYqx5Q2CnxrKxy9DAPMTRjW2ALtpPx54YAcwYTEw8gVg2PzaHecqIaAC+NFHH4VOp8Orr76K999/X3GbP/74A8OHD8f27dthsVhw//33B7JJRENQjSRYAPDvCR3x2d29YQrzitHQ+3OB9rIA17KMUCxX0kGtEpAU6b/T9rYAq1UCrAYtwsx69GqhnK5eOpEfC3DK5Vl/AaUY4BpagBUEbF24QOs0KnSOt/ms83GBBrw6VnKBbkgcnLs6ANzeJxHjOtdzXWWCIPxjayZa9arIih8IgoO0aBku9pMWg0YckAuCrztuJROZvFgRS+5dxnWEJYlWTp6GToJVV/Du7jqLOFGs4+5rbSeL+VrAlw7Jl7uzSitZgPkM5JFtal5zuq6wRMNw3T/xlVNMDDWiujHj9YGfElLHnOLYr0ZlkNyHlAngy3i21Vqg0yTRItzEDQ0Bd4FevHgxHA4H7rnnHkRFRSEnJwcAcM011yAuLg49e/bE5s2bodFo8NFHHyE8vAbFt4nGT2meWGjdjZ8YYECsZ3tNUjjUVq/YH14M8dn/sk96CeDaDdCjOQHcItwEvcb/y8k7BjiUq7c7iotZ8okBFtRSBkZvAXyZ8b+ArwuzrwCuIgZY0QW6+u7k/izAANBNwQ3apwwSIPcOqA83JcIvnbhJi5YRJsy7vl3DNYYgiEaFIAh4e0o3zOjXAu/d0UOy5vpk76/MAiz1s2EmvXIyoZrg7QatvkpCNsJbi8k4BbVYZk8QACPvLVVLCzDvAs3DC2OfGGAr0Hok0HyAuD9f6qkBaBlhxvcP9Mebt3bBYyNTqt6hvgiAC3TrKOm31TXBVqtmEXIC7i8wdepUREZG4oEHHsDx48c9y7dt2+b53KpVKyxatAhDh14BZU6ImsFbf9V6v64hMrxLPPCdaliS/Ng5p6XvtRRNfOKNTlXEHXlbRfnvI9pHY8FKMeNfgbcFOLKt5JIV0Ua8xsILYgr6OkhDX6UF2BQhJuHKPCLWEQyXx9orukDXJAu0goAO0orH7KEkgJUswP0fBbJOiJMkba6v9rmJuueegS1x9GIBws16vH5Ll4arq0wQRKOkXawV82O9Jsa83XEr8eThk+op5daoMR0mAGue4M7tX3xfUQgCMPkzoKxIuiZjmFSKqLYC2OxHAPMWXh8LsEXMszL9B4CxhrP+cnSMD0bH+EaWyEnBApzFLMiG+LeqaRIsAHjqurYIN+vRNsYim6Amak+9OMxfe+21OHLkCH799Vds2bIF58+fh8PhQHR0NPr164chQ4ZAraYSG1cluV4JsPwVbOexeLmyeGeBFtQAcwDMCZz5XVpXSxfoG7vGYeuJTGQXleGR4ZUnYfMWlnzHHWsLQudmNuw7m4sKaFCuDoLW4aoZHNtF2klrAO5aC5zcJCYzqYNOhBewKkFBvKpUwJTPgUMrgeSRPsnCAuEC7Z7h97YAm/Ua5ZqysV2B+7ZU+5xE4OgQF4w1swc2dDMIgriS0HsJkUrK2fEu0HWSYM8cKWb73f4OENkOiO12+cdsTPCCnneL9q6gUF38CmAuplcpBthNIxC/jRaDTRqnujjGJC+82liA42xBWDCufV20jnARUAH80UcfAQBGjhyJqKgoDBo0CIMGDQrkKYnGRjUyQPvgYwHmOlG1VhTBOafE7+5C7kCtkzEE6dR4e0r1OkvvjtrbTfjJUW3w0LI9iLUZoLbbgAKXAI7pIj9QSPM6Tcdv0UsCNNSkg1qpjk1oS9GFSgFFF+gazMorCWi3C3SoSYeW4SaczBRrfCtafwmCIIgrGx8X6EoswJwADqtBuE2ljHpBrLlrjfMpYXhV0e0O4MQG8X63HVe7Y3iX0nLTYQK3jYIFmKgalUosF8XV3D3mlAw0tRHARN0T0DfE9OnTodFokJubG8jTEI2ZatQA9sFSSQwwILpBuwUwTy0twDVBp1HBatAgv7RCbIqXIO6bFIadTw8T45m+6CFaXFVaICmw7v2dmgVDp1ahzOFE75aV13BUwrsOsFYtwFKDjIpKFmC3CzQAdE8M8QhgnxJIBEEQxJVPDVyg+cnk6OA66hME4bIrKlwRtB0LzDksGgdqm+1a7dtno9s0oHl/6bu3Bbi27tZNEWO4XAAzaXxq0FJIUWMgoAI4NFTM6mo0XiXZ+IiaU80M0DLMlbhAA0BoEoD1vvvVRS3EahBu1vsVwACkZB5jXhMtv/E95LHLASDSYsCX9/bF3jM5uKFLzScCLF4W4FCTrkZJSSpzgQaAoW0i8dVu8Vno0sxW4/YRBEEQjRxvgVRJHO4tPZth1Z/p0KgE3NyjmpPjhITZjwW3JlhigIJ06fuIf8jXB4UAgkoMNwPIAlwTTOGApH9lLtC1yQJN1D0BFcBt2rTB9u3bUVhYCLOZypo0SUYsBHrMEIVwVDUzyXoLYO84IiUxabDVW9KLCIu+etZMcyQw8LF6aRMgCsvaikurVxKsmmSABoBghbqxQVyih1EdorFwfAdcKrDjrv41rPFIEARBNH68BVIlgqltjBVbnxwKlSAoh+wQgSdlNLDrA1Hk3rbC14KvUonlCYszxe/eNYkJ/3glwjrOu0BfTskvos4IuAv01q1bsXjxYsyePTuQpyIaK9bYmmdnDksCwpKBrGNAwjW+Lj6hLRXOE3j3ZzdTeidgd2oOwsw6jOoQXfUOVwDeMbw1SYAF+ApoADByWT4FQcDtfRJ9tiEIgiCuEnxcoCuflNaqyRW0QRn5AhDXQ6wK0ayX8ja2ZpIA9jZOEP7hBHCpxopLkCYPKAa4cRBQATxz5kysXbsWTzzxBHQ6He655x5oNFdxYgKiblCpgRlrgdQtQNIQ3/WKArj+6sbe0CUOA5IjYDForpoO3NcCXDMBbNZroFYJcDiZZxm95AmCIJoQvAu0oAY0CvXeicaD1gB0nVr5NgPnAj88CsR1l8cHE5XDJRArsCQBhZKXA42NGgcBVaMzZsyA2WyGXq/HQw89hPnz56Nnz56IjIz0W/ZIEAS8//77gWwWcSVgCgPa+cluaEsEVBrAWSEtq0cBDNRR2YZGhHcW6JpenyAIsBo0yCkuByAmeSC3NoIgiCYEL4D1ZiqVczXQ5jrRVZr+ljUjsZ/nY2bMYIALtaYY4MZBQAXw0qVLIQgCGBOtQtnZ2Vi7dq3itu7tSAATVaLWiCI4+4S0rB5doK9GLtcFGhATYbkFsElHnh4EQRBNCt4FupIM0MQVBonfmtNiIDB1OVCchYuafsAf+z2r9Jqrw3PwSiego9Q77rijRplkCaLahCV5CeD6tQBfbeg1Kk8ZJaBmNYDd8JmgKckDQRBEEyOmC6DWAw67/5hSgmgKCAKQfC0AwHgq27PYoFVBRd5xjYKAW4AJIiB4xwHXUwmkqxVBEGAxaJBVVAagdhZg3opsJAFMEATRtLBEAXeuBs7tBDre3NCtIYhGQazNAEEAGANibbWs20zUOeSnSFyZhHqVQiIX6MumdZQFv5/MgiAAKdE1L3gvF8D0aiEIgmhyxPcQ/xEEAQCIDzHiyVFtsO6vi3hwaKuGbg7hgkapxJVJmLcFmFygL5fnbmiP9349iV4tQtEivOY1lYPJAkwQBEEQBCFj1qAkzBqUVPWGRL1BApi4MonqAKi0gLMcCG4mzz5J1IrWURa8PKlzrfcnAUwQBEEQBEE0dgIqgFu2VKjXWgWCIODEiRNVb0g0bSzRwLi3gL++B/rcR1kKGwHNw4yez/Ehxkq2JAiCIAiCIIiGIaAC+PTp09Xaji+VRFmjiWrTZYr4j2gU3NAlDjtO5SCvpAwzB7Ro6OYQBEEQBEEQhA8BFcBLliypdH1eXh62b9+Or7/+GmazGc8//zyMRrIcEcSViEGrxqs3196FmiAIgiAIgiACTUAF8LRp06q13aFDh3Dttdfi008/xaZNmwLZJIIgCIIgCIIgCKKJomroBgBA27Zt8Z///Adbt27FG2+80dDNIQiCIAiCIAiCIK5CGoUABoAxY8ZAp9Ph448/buimEARBEARBEARBEFchjUYAazQa6PV6ygBNEARBEARBEARBBIRGI4CPHj2KgoICaLXaqjcmCIIgCIIgCIIgiBrSKARwWloapk+fDkEQ0KNHj4ZuDkEQBEEQBEEQBHEVEtAs0DNmzKh0fWlpKc6ePYudO3eivLwcgiDgscceC2STCIIgCIIgCIIgiCaKwBhjgTq4SqWCIAiozinMZjPeeOONKkUzUTkWiwXl5eVISkpq6KYQBEEQBEEQBEHUmDNnziAhIQEHDx6s82MH1AJ8xx13QBAE/yfXaBASEoLOnTtj7NixsFqtgWxOk8BkMqGoqKihm+GDO7kZCfP6g+55w0D3vf6he17/0D1vGOi+1z90z+sfuucNQ2O77yaTKWBtCagFmCDctG/fHgACMotDKEP3vGGg+17/0D2vf+ieNwx03+sfuuf1D93zhqEp3fdGkQSLIAiCIAiCIAiCIAJNQAXwjBkzMGfOnGpvP3fuXNx1110BbBFBEARBEARBEATRVAmoAF66dCk+//zzam//1VdfYenSpYFrEEEQBEEQBEEQBNFkaVQu0BSOTBAEQRAEQRAEQQSKRiWAMzMzYTQaG7oZBEEQBEEQBEEQxFVIwOsAR0dH4/z585Vul5eXh8WLF+Pxxx9Hp06dsHfv3kA1iSAIgiAIgiAIgmii1Gkd4Oeeew7PP/+8bNnFixehVqurtb8gCJg4cWJdNokgCIIgCIIgCIIgANSxAAbkcbyCIFQ7rlen0+H222/Hk08+WddNIgiCIAiCIAiCIIi6dYFOTU3F6dOnAYhCeOjQoQgNDcWKFSv87qNSqWC1WtG6dWsEBQXVVVMIgiAIgiAIgiAIQkZAY4CbN2+OqKgobN++PVCnIAiCIAiCIAiCIIhqEVABTBAEQRAEQRAEQRCNhUZVBokgCIIgCIIgCIIgAkW9CuCMjAz88ccf2Lx5M3799Ve//4irh5KSEsyfPx+tW7eGwWBAbGwsZsyYgbS0tIZu2hVLcXExvv32W9x1111ISUmBwWCAyWRC586d8fzzz6OwsNBnnwULFkAQBL//KPlc1QwePLjSe7hmzRrF/ZYuXYpevXrBbDYjNDQU1113HbZu3VrPrb8y2bRpU6X33P2Prz5Az3r12L17N/79739jwoQJiI+P99yfqqjN87xlyxZcd911CA0NhdlsRq9evfDRRx/V1aVcMdTknjudTmzevBlz585F9+7dYbFYoNfrkZSUhHvvvRenTp1S3K+q30yfPn0CeYmNjpo+55fz/qDnXKKm97067/mhQ4fK9qFnXaI240I3TfWdXudZoJV4++238dZbb+HEiRNVbisIAioqKuqhVUSgKS0txdChQ7Ft2zbExMTghhtuwOnTp7FkyRL88MMP2LZtG1q2bNnQzbzi+Oyzz3D33XcDANq2bYtx48YhPz8fW7duxbPPPotly5bhl19+QWRkpM++/fr1Q6tWrXyWd+/ePeDtvlqYOHEizGazz/K4uDifZbNnz8abb76JoKAgjBgxAqWlpVi3bh1++uknLF++HOPHj6+HFl+5REdHY9q0aYrrHA4HPvnkEwDAgAEDfNbTs145CxcuxHfffVejfWrzPK9YsQK33HILnE4nBg4ciPDwcPz888+YNm0a9u/fj1deeaWOrqjxU5N7fvLkSQwcOBCA+DsYOnQo1Go1duzYgf/973/47LPPsHr1avTv319x/6SkJMV1SUlJtb+AK5DaPOdAzd8f9JzLqel99/eeB4BVq1YhMzNT8T0P0LMO1H5c2KTf6SzA3HLLLUylUjFBEKr9j7g6ePrppxkA1rdvX1ZQUOBZ/uqrrzIAbNCgQQ3XuCuYpUuXsnvuuYf99ddfsuXnz59nXbt2ZQDY5MmTZeueffZZBoAtWbKkHlt6dTFo0CAGgJ06dapa269bt44BYGFhYezo0aOe5Vu3bmU6nY7ZbDaWk5MTmMY2AVavXs0AsGbNmjGn0+lZTs969fj3v//N5s2bx77//nuWnp7O9Ho9q2xIUJvnOSsri1mtVgaArVixwrP8woULrFWrVgwA27hxY11fWqOlJvf8+PHj7Nprr2U///yz7PkuLS1l06dPZwBYQkICKysrk+23ceNGBoBNmzYtkJdyxVDT57w27w96zn2p6X33R05Ojmdf/r3DGD3rPLUZFzb1d3pABfCyZcuYIAjMZrOxFStWsOLiYiYIAouJiWEOh4OlpaWxpUuXsuTkZBYREcE2bNgQyOYQ9YjdbmfBwcEMAPvjjz981nfq1IkBYLt27WqA1l29bN26lQFger2e2e12z3ISBZdPTQXw6NGjGQD2+uuv+6x7+OGHGQD2yiuv1G0jmxBTpkxhANiTTz4pW07Peu2oaoBam+f5xRdfZADYDTfc4LPP119/zQCw66+//nKbfsVSW1FQXFzs6V83bdokW0eioHICIYDpOa+a2j7r7777LgPA+vTp47OOnvXq4W9c2NTf6QGNAV66dCkEQcDChQsxYcIEWZ1flUqF2NhYTJs2DX/88QeaNWuG8ePH4/jx44FsElFPbNmyBXl5eUhKSkLXrl191t90000AgJUrV9Z3065qOnfuDACw2+3Iyspq4NY0XUpKSrBhwwYA0rPOQ8//5VFUVORxr7v99tsbuDVXP7V9nletWuV3nzFjxsBgMGD9+vUoLS2t6yZf1QQFBaF169YAgPPnzzdwawh6zgOHO8yF3vO1R2lcSO/0AMcA79mzBwBw2223yZY7nU7Zd7PZjLfffhv9+vXDiy++iPfeey+QzSLqgX379gEAunXrprjevXz//v311qamwMmTJwEAWq0WoaGhPus3bNiAvXv3orS0FPHx8Rg9ejTFRNaQ999/H1lZWVCpVGjdujXGjx+PhIQE2TZHjhyB3W5HREQE4uPjfY5Bz//l8fXXX6OoqAhdu3ZFu3btFLehZ73uqO3zXFk/oNPp0KFDB+zatQtHjx5Fp06dAtDyqxOn04nU1FQAYnywEseOHcNTTz2FrKwshIeHo3///hg1ahRUKir+UR1q8v6g5zwwnDlzBps3b4ZWq8Utt9zidzt61itHaVxI7/QAC+Dc3FxYLBbYbDbPMq1Wi6KiIp9t+/btC6PRiPXr1weySUQ9cebMGQBQ/GHxy92dOFE3vPnmmwCAUaNGQa/X+6z/+OOPZd/nzZuHiRMnYunSpYqJnQhf/vGPf8i+P/bYY5g3bx7mzZvnWVbV828ymWCz2ZCTk4OCggJYLJbANfgqpDpWAXrW647aPM/5+fnIy8urdL/4+Hjs2rULqampjX6w1JhYtmwZMjIyEBERgWuuuUZxm61bt/pkcu3YsSNWrFiB5OTk+mjmFU113x/0nAeOTz/9FIwxjB49GmFhYX63o2e9f2kwNwABAABJREFUcpTGhfROD3AZpLCwMJ+05zabDcXFxcjNzVXc58KFC4FsElFPuFOuG41GxfUmkwkAUFBQUG9tutpZvXo13n//fWi1WixcuFC2rlWrVnjllVdw8OBBFBYW4uzZs/j0008RFxeHFStWkHtRNRg4cCA+/vhjnDhxAsXFxThy5Aj++c9/QqPRYP78+Z5OBqj6+QfoN1Bb0tPT8fPPP0OtVmPy5Mk+6+lZr3tq8zzzZTeoH6g7zp49i9mzZwMAnn/+eZ+JzuDgYDz++OPYtm0bsrKykJWVhZ9//hl9+vTBn3/+iREjRngGsYQvNX1/0HMeOKqa6KRnvWr8jQvpnY7AZoHu0aMHU6lUsgzAgwYNYiqVin399deybXfv3s0EQWChoaGBbBJRT9x9990MAHv66acV1x87dowBYMnJyfXcsquTQ4cOsZCQEAaAvfHGG9Xe7/z58ywsLIwBYL///nsAW3j1snbtWgaA2Ww2VlxczBhj7NNPP2UAWL9+/fzuFxcXxwCwtLS0+mrqVYE7i/yoUaNqtB8965VTWZKa2jzPaWlpDAADwMrLyxX3mTp1KgPAPv3008u/gCuQmiYGKiwsZD169GAA2Pjx42t0roqKCjZgwAAGgP3rX/+qaVOvGmqbjMnf+4Oe8+pR0/u+e/duT79aWlpao3PRsy5S2biQ3ukBToLl9hHfuXOnZ9mYMWPAGMNjjz2GnTt3ory8HLt27cK0adMgCAL69esXyCYR9YTbRai4uFhxvdsNnlw/L5+0tDSMGjUKOTk5mDNnDh555JFq7xsTE4M777wTALBmzZpANfGqZsSIEejRowdyc3Oxfft2AFU//wD9BmpLbZOi0LNee2rzPPNuotQPXD7l5eWYNGkSdu3ahf79++Ozzz6r0f5qtRpPPPEEAGDt2rWBaOJVjb/3Bz3ngcH9np80aZJiOFdl0LNe9biQ3ukBdoF2i92vvvrKs+y+++5DXFwcTp06hT59+sBgMKB37944ePAgNBoNnn766UA2iagn3EmBzp07p7jevTwxMbHe2nQ1kp2djREjRiA1NRV33nlnrQqQu2Nk0tPT67p5TQbve1jV819UVITc3FyEhIRcER1FY+HQoUPYs2cPzGYzxo8fX+P96VmvHbV5nq1WK4KDgyvdj/qB6uF0OjFt2jT8+OOP6NKlC1auXCmrqlFd6Pm/PJTuHz3ndY/D4cDnn38OwDeJbnVpys96dcaF9E4PsAC+7rrrsHHjRs+sGSDOIGzYsAF9+/YFE+sQgzGGhIQEfP311+jdu3cgm0TUE+6063/88Yfievfyxh4k35gpLCzE6NGj8ddff2HChAl47733fGLuq0NOTg4AKXaDqDne9zAlJQV6vR6XLl1CWlqaz/b0/NcOd2KaCRMmVBq75A961mtHbZ/nyvqB8vJyHDhwAAaDwVPSh1DmoYcewrJly9C6dWusXbtWlli0JtDzf3n4u3/0nNctP//8M9LT05GYmIgBAwbU6hhN9Vmv7riQ3ukBFsAajQaDBg1Cz549ZcuTk5OxZcsWnDlzBlu2bMGBAwdw6tQpjBkzJpDNIeqRfv36ITg4GCdOnMDevXt91i9fvhwAMHbs2Hpu2dWB3W7HDTfcgB07dmDkyJFYtmwZ1Gp1jY/DGMM333wDwH/JKqJyLl26hM2bNwOQ7mFQUBCGDh0KADIPGDf0/NccxpjH7bM2iazoWa89tX2e3X26ez3PDz/8gNLSUgwfPhwGg6Gum3zV8Mwzz+C///0vEhISsG7dOkRGRtb6WCtWrABAz39tqOz9Qc953eJ2f77ttttqNakPNM1nvSbjQnqnI7BJsFJTU1lqaiorKSkJ5GmIRsrTTz/NALBrrrmGFRYWepa7k9gMGjSo4Rp3BVNRUcFuvPFGBoANGDCAFRUVVbp9RkYGe/vtt1l+fr5seUFBAZs1axYDwKKjo6s8TlNmy5Yt7JtvvmEVFRWy5adOnWL9+vVjANi4ceNk69atW8cAsLCwMHb06FHP8q1btzK9Xs9sNhvLycmpj+ZfFfzyyy8MAIuLi2MOh0NxG3rWa09VSWpq8zxnZWUxq9XKALAVK1Z4ll+8eJG1atWKAWAbN26s60u5Yqjqnr/22mueZ5a/55Xx+uuvszNnzsiWOZ1OtmjRIqbRaJggCGzXrl2X1e4rmcrueW3fH/ScV011k2AVFRUxs9nMALDDhw9Xui096xI1HRcyRu90gTHGAiWuVSoVVCoVzpw5g9jY2ECdhmiklJaWYvDgwdi+fTtiYmIwYMAApKamYvv27YiIiMC2bdvQsmXLhm7mFcebb77pKYNx4403wmq1Km73yiuvIDw8HKdPn0aLFi1gNpvRs2dPxMTE4NKlS/jjjz+QlZUFm82GH374gRLQVcLSpUtx5513Ijo6Gt26dYPNZkNqaip2796N0tJStG/fHhs2bPCxzsyePRtvvvkmjEYjrr32WpSVlWHdunVgjGH58uW1imNtqtxzzz1477338Pjjj+Oll15S3Iae9eqzatUqWVmMHTt2gDEmC0OaN2+ezDOrNs/zihUrcPPNN4MxhsGDByMsLAzr169Hbm4u5syZg1dffTWg19mYqMk937t3L7p16wbGGPr27evXpXDmzJno37+/53vz5s1x7tw5dOvWDS1atEBpaSn+/PNPnDp1CiqVCm+++SYefPDBwF1kI6Mm9/xy3h/0nMupzfsFAD777DNMnToVPXv2xI4dOyo9Bz3rEjUdF7pp0u/0QKpri8VCZY2aOMXFxWzevHksKSmJ6XQ6Fh0dzaZPn87Onj3b0E27Ynn22Wc9qegr+3fq1CnGGGP5+fnsiSeeYIMGDWJxcXFMr9czo9HI2rdvz/72t7+xc+fONewFXQH89ddf7L777mPdunVjERERTKPRsODgYNanTx/26quvesofKbFkyRLWvXt3ZjQamc1mY6NGjWJbtmypx9Zf+ZSWlnrKOezbt8/vdvSsV58lS5ZU+Q5ZsmSJ4n41fZ5/++03NmrUKGaz2ZjRaGQ9evRgS5cuDdCVNV5qcs83btxYrfe899/orbfeYtdffz1r0aIFM5lMTKfTscTERHbbbbexHTt21P9FNzA1ueeX+/6g51yitu+X0aNHMwDszTffrPIc9KxL1HRcyNNU3+kBtQB36tQJx44dQ2FhYa3iEwmCIAiCIAiCIAiirghoEqzx48ejrKwMq1evDuRpCIIgCIIgCIIgCKJKAmoBLioqQrdu3VBYWIgff/yRSn4QBEEQBEEQBEEQDUZABfBHH32EzMxMLFiwAKWlpRg1ahT69euHyMjISl2i77jjjkA1iSAIgiAIgiAIgmiiBDwLtLuGF2OsWvW8BEFARUVFoJpEEARBEARBEARBNFE0gTx4QkJCrYtYEwRBEARBEARBEERdElALMEEQBEEQBEEQBEE0FgKaBZogCIIgCIIgCIIgGgskgAmCIAiCIAiCIIgmQUBjgHkyMzOxceNGpKamori4GPPnz6+vUxMEQRAEQRAEQRBE4GOAKyoq8MQTT+C///0vysrKPMsdDofnc05ODlq2bImSkhIcPnwYzZs3D2STCIIgCIIgCIIgiCZIwF2gJ02ahDfeeANlZWVo3749NBpfo3NISAimTJmCsrIyfPnll4FuEkEQBEEQBEEQBNEECagA/vzzz/Hdd98hMjISu3btwv79+xEaGqq47aRJkwAAGzduDGSTCIIgCIIgCIIgiCZKQAXwkiVLIAgCXn75ZXTt2rXSbXv16gVBEPDXX38FskkEQRAEIWPKlCkQBAELFy6sctsdO3ZAEARERUWhoqKixudasGABBEHA0qVLa9HS2rN06VIIgoAFCxbU63mVqKioQEpKCnr16iVb3pjaCACtW7euVUjWnj17IAgCXnrppbpvFEEQBHHZBFQA79mzBwAwceLEKrc1Go0IDg5GRkZGIJtEEARBEDJuv/12AMCnn35a5baffPIJAGDy5MmKIT1XGtOnT4cgCNi0aVO9nfN///sfjh492miErhKHDx/GsWPHMHbs2Brv27VrV4wbNw4vvPACsrOzA9A6giAI4nIIqADOy8tDcHAwgoKCqrW90+mEIAiBbBJBEARByBgxYgSioqJw5MgR7Ny50+92FRUV+OKLLwBIovlK4cYbb8ShQ4fw4IMPNmg77HY7nn/+eXTq1AnXXXddg7alMr7//nsAqJUABoCnnnoKubm5ePHFF+uyWQRBEEQdEFABHBISgry8PJSWlla5bXp6OvLz8xEVFRXIJhEEQRCEDLVajcmTJwOQLLxK/PTTT8jIyEDbtm3RvXv3+mpenRAcHIw2bdogPDy8QduxfPlyZGRk4I477mjQdlTFypUrYbFYMHjw4Frt36dPH7Rq1QoffPCBrAIGQRAE0fAEVAB369YNQPUSW33wwQcAgL59+waySQRBEAThw2233QYA+OKLL2Rl+njcLtLubd2sWbMGY8aMQUREBPR6PVq2bIk5c+YgKyurRm3IysrC448/juTkZBgMBoSGhmLUqFH46aefKt3n6aefRseOHWEymWC1WtGxY0fMnTsX6enpnu2U4msFQcCHH34IABgyZAgEQfD8O336NB588EEIgoB3333X7/lTUlKgUqlw8uTJal3j4sWLIQgCbr311mpt7+bVV1+FSqVCmzZtcPbsWZ9rOnHiBG6++WaEh4fDarVi9OjRnpwiFRUV+Ne//oXWrVvDYDCgVatW+M9//uP3XJmZmfj9998xcuRI6HQ6z/IDBw7gtttuQ8uWLWEwGBAREYEuXbpg9uzZsnvtZvLkycjMzMQ333xTo2slCIIgAktABfDUqVPBGMO8efNQWFjod7s1a9Zg4cKFEAQB06ZNC2STCIIgCMKH7t27o23btrh48SLWrVvns76oqAjfffcdBEHA1KlTPcuffPJJjB49GuvXr0dKSgrGjRsHjUaD119/Hb1798bFixerdf60tDT06tULr7zyCsrKyjB+/Hh07doV69evx8iRI/H666/77HPo0CF06dIF//rXv5CZmYmRI0di+PDhYIzh5Zdfxvbt2ys957Rp05CUlAQAGDlyJKZNm+b5ZzabMWvWLADAe++9p7j/L7/8gqNHj2LYsGFo2bJlldeYn5+PzZs3o1WrVoiLi6tyezd///vf8dhjj6F79+747bff0KxZM9n6U6dOoVevXjhw4ACGDx+O5s2bY82aNRg8eDAuXLiAm266CS+99BLat2+PwYMH4+zZs3jwwQf9Xtfq1avhcDgwbtw4z7Ldu3ejZ8+e+PTTT2GxWHDDDTegT58+KC8vx5tvvokjR474HMdtPV61alW1r5UgCIKoB1gAcTqdbODAgUwQBNa+fXv2f//3fyw0NJSpVCr2008/sXfffZeNHTuWqdVqJggCGzduXCCbQxAEQRB++de//sUAsKlTp/qs++ijjxgANmjQIM+yL7/8kgFgHTp0YMeOHfMsdzqdbP78+QwAu+WWW2THefbZZxkAtmTJEtny66+/ngFgU6ZMYXa73bN88+bNzGg0MrVazfbs2eNZXl5ezlJSUhgANnv2bNk+jDF24MABdvz4cc/3JUuWMADs2WeflW03bdo0BoBt3LhR8Z5cc801DIDs3G6mTp3KALAvvvhCcV9vfvzxR881KuHdRofDwe655x4GgA0ZMoTl5+crbg+APfnkk8zpdDLGxPs/ffp0BoC1a9eOdejQgWVkZHj2W79+PQPAEhMTFdsxceJEplarWWZmpmfZHXfcwQCwV155xWf7Q4cOsfPnz/ssz8vLYyqViiUkJFR6XwiCIIj6JaACmDHGsrOz2aBBg5ggCEylUin+EwSBXXvttaygoCDQzSEIgiAIRVJTU5kgCMxkMrHCwkLZuhEjRjAA7L333vMs69y5MwPA/vzzT59jOZ1O1qVLF6ZWq9mlS5c8y5UE8IkTJxgAZjabWVZWls+x5syZwwCwmTNnepZ98cUXDABr3749q6ioqPLaaiuA3cL//vvvly3Pzs5mBoOBRURE+Ihvf7z44osMAHvuueeqbKPdbmeTJk1iANj48eNZaWmp3+1btmzJysrKZOv27dvnEcfr16/32bdr164MADt16pRsud1uZxaLhQ0YMEC2fPTo0QwA27t3b7Wu1U1cXBwDwLKzs2u0H0EQBBE4AuoCDYiJsDZs2IAPP/wQAwYMgE6nAxOFN9RqNfr27YulS5dizZo1MJvNgW4OQRAEQSiSkJCAgQMHoqioCN9++61n+cWLF/Hzzz/DYDBg0qRJAICMjAzs27cPycnJ6NChg8+xBEFAv3794HA4sHv37krP+9tvvwEARo0ahdDQUJ/17ozTmzdv9ixbv349AGDmzJlQq9U1u9AaMGnSJISFheHTTz9FcXGxZ/knn3yC0tJSTJs2TRYnWxnuMochISGVbldUVITrr78eX331FaZPn47ly5dDr9f73X7w4MHQarWyZW6XbK1Wq5jIyr3eO3Z348aNKCgo8Mn+7E569sADD2DTpk3VrgHt/nteunSpWtsTBEEQgSfgAhgAVCoVbr/9dmzatAlFRUXIyMhAeno6iouL8dtvv+GOO+6ASlUvTSEIgiAIv7jFJp8NetmyZXA4HBg7diyCg4MBAKdPnwYAHDt2TJY8iv/nTrSUmZlZ6TnPnz8PAGjevLnievfytLQ0zzJ3Iih3DG+gMBgMmDZtGvLy8vDVV195li9evBiAKMCrS15eHgDAYrFUut0bb7yBdevW4brrrsMHH3xQpcBXiid2T6hHR0cr7u9eb7fbZctXrlwJALL4XwB4/PHHMXjwYGzZsgVDhgxBSEgIRowYgTfffNNzXUpYrVYAQG5ubqXXQBAEQdQfmvo+oUqlavAyDARBEAShxE033YQHH3wQ69evR0ZGBiIjIz1imK/963Q6AYgCa+TIkZUeMzEx8bLaJAjCZe1/ucyaNQuvv/463nvvPUybNg07duzA/v37MXDgQKSkpFT7OO7Jg4KCgkq3Gz16NH799Vf89NNPWLFiBW666aZKt69sAr2mk+srV65EcnKyz3VZrVZs2LABW7ZswcqVK7Fp0yZs2LAB69atwwsvvIDNmzcjOTnZ53hucWyz2WrUDoIgCCJw1LsAdjgcyM7OBiC6BgXSdYsgCIIgakJwcDDGjRuHL7/8EsuWLcPIkSOxe/duhIeHY9SoUZ7t4uPjAQDh4eFYunTpZZ0zNjYWAJCamqq43m1t5i2d7kzIJ06cuKxzV4fWrVtjyJAh2LBhAw4dOuTJnnzPPffU6DiRkZEA4BkD+KNbt254+umnMWLECEyePBkqlQoTJkyoXeNrwL59+3DmzBn87W9/U1wvCAL69++P/v37AxBdumfPno1ly5bh6aefxpdffumzT05ODgAgIiIicA0nCIIgakS9+B0XFRXh1VdfRc+ePWE0GhEdHY3o6GgYjUb07NkTr776aqVlkgiCIAiivnDX+f300089tX9vueUWWZxpfHw82rRpg7/++gtHjx69rPO5BdWaNWsUXWXdFugBAwZ4lg0fPhwA8P7773us0bXBHb9bVUzrvffeCwB47bXX8PnnnyMkJAQTJ06s0bk6d+4MAIolg7zp3bs31qxZg6CgINx666347rvvanSu2vD9998DgE/8rz8iIyM9dZUPHDjgsz4/Px/nz59HQkJClXHPBEEQRP0RcAG8d+9edOjQAXPnzsXu3btRXl7uSYJVXl6O3bt3Y+7cuejYsSP27NkT6OYQBEEQRKWMGjUK4eHh2LlzJxYtWgRA7v7sZt68eXA6nZg4cSL27t3rsz4rK8tvrVmeli1bYsyYMSgoKMAjjzyC8vJyz7rff/8d77zzDtRqNR544AHP8gkTJqB169Y4cOAA5s6dK9sHAA4ePIiTJ09WeW639bkqUTp+/HhER0dj8eLFKCwsxO233w6DwVDl8XmuueYaqNVq7Ny5s1rb9+3bF2vWrIFer8fNN9/sic8NFCtXrkRoaKhnQoJn0aJFOHXqlM/y1atXA4BPbWIA2LlzJxhjGDRoUN03liAIgqg1ARXA6enpGD58OFJTU6HVajFlyhQsXrwYP/74I3788UcsXrwYU6dOhU6nQ2pqKq699lpPMhCCIAiCaAi0Wi1uvfVWAGICq+TkZPTu3dtnuylTpuDvf/87Dhw4gO7du6N79+64+eabMWnSJHTr1g1RUVF4/PHHq3XO//3vf2jRogU++ugjJCcnY/LkyRg+fDgGDBiAoqIivPTSS+jSpYtne41GgxUrViA6OhqvvvoqEhMTMXHiREyYMAEdO3ZEhw4dsH///irPO3bsWAiCgMceewzjx4/HzJkzMXPmTGRlZfnckxkzZni+19T9GRCTXw0YMADHjx/HuXPnqrXPNddcgx9//BFarRY33XQTVq1aVePzVof09HTs2rULo0ePVgzNWrRoEVq2bIn27dvjpptuwq233oouXbrg0UcfhcFgwPz583322bRpEwBgzJgxAWkzQRAEUTsCKoCff/55ZGdnIzExEXv37sUnn3yCGTNmYOTIkRg5ciRmzJiBjz/+GHv37kViYiJycnKwcOHCQDaJIAiCIKqEt/i6XaKV+Oc//4lffvkFEydOxIULF/Dtt99i48aNcDgcuO+++zxutVURFxeHnTt34m9/+xs0Gg2+/vpr7N69G8OGDcPatWsxZ84cn306dOiAffv24bHHHoPFYsHq1auxYcMGCIKAJ554An369KnyvN27d8cnn3yCdu3a4aeffsL777+P999/XzFR1dChQwGIltn27dtX67q8ufvuuwGImbWrS//+/bF69WpotVpMnDgRa9asqdW5K+OHH34AY8wn+7ObhQsXYsaMGRAEAT///DNWrlyJkpISzJw5E3v37kW/fv189lm2bBnCw8Nx44031nl7CYIgiNojMMZYoA6emJiIc+fOYe3atZ54JX+sX78eI0aMQHx8PM6cOROoJhEEQRAEUQtmzZqFd999F0uWLMH06dNrdQy73Y7ExERERkZWy0JdX4wdOxZr165FZmamp3TR5fD777/jmmuuwdy5c/Hiiy/WQQsJgiCIuiKgAthgMECj0VQ7wZXZbIbD4UBJSUmgmkQQBEEQRA1JTU1F27ZtYTKZcObMGQQFBdX6WP/973/xwAMPYOXKlbj++uvrsJW156WXXkJwcDBmzZpVJ8e74YYb8Ouvv+LEiRMIDQ2tk2MSBEEQdUNABXCzZs2Qn59faZF4HqvVCpvNRhZggiAIgmgEvPzyy9i/fz/WrVuHixcv4o033sAjjzxyWcesqKhA+/btYbVaq50Q60piz5496NatG1588UXMnTu3oZtDEARBeBHQOsDDhg3Dxx9/jN27d6N79+6Vbrtr1y4UFhbWuKwCQRAEQRCBYdWqVfjll18QGxuLZ599Fg8//PBlH1Oj0VSrFNKVSteuXRFA2wJBEARxmQTUAnz8+HF069YNrVq1wrp16xAWFqa4XXZ2NoYPH46TJ09i165daNWqVaCaRBAEQRAEQRAEQTRRAiqAz5w5g23btmHWrFnQarW47777MGTIEMTFxQEA0tLSsHHjRixatAjl5eX43//+p1hqAgASEhIC1UyCIAiCIAiCIAiiCRBQAaxUS682CIKAioqKOjkWQRAEQRAEQRAE0TQJaAxwXWlriqUhCIIgCIIgCIIgLpeACuBTp04F8vAEQRAEQRAEQRAEUW0C6gJNEARBEARBEARBEI0FVUM3gCAIgiAIgiAIgiDqAxLABEEQBEEQBEEQRJMgoDHAPFu3bsX+/fuRk5OD8vLySredP39+PbWKIAiCIAiCIAiCaCoEPAb4xx9/xP33348zZ85Uex+HwxHAFhEEQRAEQRAEQRBNkYBagDds2IBx48Z5BG2rVq0QFRUFjabeDM8EQRAEQRAEQRAEASDAFuBBgwZh8+bN6NmzJ5YtW4aWLVsG6lQEQRAEQRAEQRAEUSkBFcAWiwXFxcU4evQokpKSAnUagiAIgiAIgiAIgqiSgArg0NBQOJ1O5ObmBuoUBEEQBEEQBEEQBFEtAloGqW3btigpKUFpaWkgT0MQBEEQBEEQBEEQVRJQAXzvvfeivLwcn3zySSBPQxAEQRAEQRAEQRBVEvAySNOnT8fy5cuxePFi3HrrrYE8FUEQBEEQBEEQBEH4JeACGAAWLFiAhQsXIiEhAT169IDFYvHfIEHA+++/H+gmEQRBEARBEARBEE2MgAvg9957D48//jgKCgpQ2akEQQBjDIIgeOoGEwRBEARBEARBEERdoQnkwb/77jvMmjULAGAymdC3b19ERUVBownoaQmCIAiCIAiCIAjCh4BagPv164fff/8do0aNwhdffFGp6zNBEARBEARBEARBBJKACuDg4GAUFhbi3LlziImJCdRpCIIgCIIgCIIgCKJKAloGSavVIjg4mMQvQRAEQTQAgiBAEARs2rSpoZtyRTF9+nQIgoDp06c3dFMIgiCIOiagArhz584oKChAQUFBIE9DEARBEHXOggULPAKyodm/fz+eeOIJ9OrVC1FRUdDpdAgODka7du0wbdo0fPfddygvL2/oZhIEQRBEoyegAviRRx6Bw+HAf//730CehiAIgiCuSgoKCjB16lR06dIFL730Enbu3IlLly7BZDLBbrfj0KFD+OijjzB+/Hi0bdsW27dvb+gmEwRBEESjJqACeNy4cZg/fz7mzZuHf//73ygpKQnk6QiCIAjiqiEnJwd9+/bFZ599BgC49dZb8csvv6C0tBQ5OTkoLS1FWloaFi9ejE6dOuHEiRP4/fffG7jVBEEQBNG4CWg9oqFDhwIQSyA9/fTTWLhwIdq1a1dpNmhBEPDzzz8HslkEQRAE0eiZOnUqDh48CI1Gg88++wyTJk3y2SY2NhZ33XUXZsyYgUWLFjUKd22CIAiCaMwE1AK8adMmbNq0CXl5eWCMoaSkBLt37/Ys9/ePIAiCIBozmzZtksUHHz9+HDNmzECzZs2g1+sRHx+Pu+++G2lpabU6/o8//ogff/wRADB//nxF8csjCALuu+8+3HPPPX63KSgowDPPPIM2bdogKCgIYWFhuP766yt1mz5w4AAWLFiAoUOHIikpCUFBQbBarejatSueeeYZZGZm+t23efPmEAQBS5cuRVlZGV5++WV07twZJpMJwcHBGDp0KNasWVPpNbkTeNWm7W5WrVqFiRMnIi4uDnq9HiEhIRg4cCDeeecdlJWVVbm/El988QVGjx6NqKgoaLVa2Gw2JCcnY9y4cfjPf/6D0tLSWh2XIAiCCDwBtQA/++yzgTw8QRAEQTQ4GzduxLhx41BYWAiLxQKn0+lxTV69ejV27NiBuLi4Gh3z7bffBiCWE5wzZ06191OplOe109PT0a1bNxw/fhwGgwEqlQrZ2dlYtWoV1q1bh5UrV2LEiBE++11//fVITU0FABgMBhiNRuTk5GDv3r3Yu3cvli5dip9//hkpKSl+21RYWIiBAwdi+/bt0Gq10Ov1yM/Px8aNG7Fp0yYsXrwYM2bM8Lt/bdteUlKCO+64A8uXL/css1qtyMvLw+bNm7F582Z89NFHWL16NUJCQvye35sZM2ZgyZIlnu9msxnl5eU4fvw4jh8/jpUrV2LMmDFo3rx5tY9JEARB1COMIAiCIAgfnn32WQaAKXWVGzdu9KwLCQlh48aNY4cOHWKMMWa329kXX3zBLBYLA8Buv/32Gp23vLycmc1mBoDddNNNl3UNfBvbtWvHNmzYwBwOB3M6nWzHjh0sJSWFAWCJiYnM4XD47H/HHXewpUuXstTUVM8yu93O1q9fz3r16sUAsG7duimeOzEx0XPuuLg49u2337KysjLGGGOHDx9mffr0YQCY2Wxmubm5dd722267jQFgLVu2ZJ9++inLy8tjjDFWUlLCvvvuO9ayZUsGgI0fP95n32nTpjEAbNq0abLlmzdvZgCYSqViL774IsvKyvKsy8zMZGvXrmXTpk1jaWlpiveEIAiCaHhIABMEQRCEAtUVwEOGDFEUYG+99RYDwIKCglh5eXm1z3v8+HHPsf/5z39e1jW4jxMREcEuXrzos37//v2ebX777bcaHbugoIBFRUUxAGzz5s0+690CWK/XeyYHeDIyMpjBYGAA2CeffFKnbf/1118ZABYZGcnOnDmj2P6zZ88yk8nEALA9e/bI1vkTwC+++CIDwEaMGKF4TIIgCKLxE9AYYIIgCIK42vn73/+u6Hp8ww03ABBdcY8dO1bt42VlZXk+h4aGXn4DAdxzzz2IjIz0Wd6xY0e0aNECgFhruCaYzWYMGjQIAPDbb7/53e6mm25CmzZtfJZHRESgb9++VZ67Nm1///33AYiJxJo1a6Z43Pj4eAwZMgQAsHbtWr/n57HZbACAS5cuweFwVGsfgiAIonER0BhgN8XFxVi8eDHWrl2L1NRUlJSU4MSJE571eXl5WLVqFQRBwOTJk+ujSQRBEARRJ/Tu3VtxeWxsrOdzdnZ2fTVHEX9tBMR2njp1ym8bf/jhB3z88cfYuXMnLl68iOLiYp9tzp07V+tzA5Xfn9q0fcuWLQBEIewuI6VEXl4eAHjinKti2LBhMBgM2LNnDwYMGIC77roLQ4cO9QhxgiAIovETcAG8d+9e3HDDDTh37hwYYwDgU6bBarXiH//4B44cOYKoqChP+SSCIAiCaOz4K+2n0UhdbHl5ebWPFxYW5vlcV8K5svKD7nZ6t9HpdOK2227DsmXLZNuGhIRAp9MBEAVkaWkpioqK6vTcl7v/+fPnAQD5+fnIz8/3u78bJVGvRFJSEhYvXox7770Xv//+u6fuckREBIYMGYIpU6Zg3LhxVI6KIAiiERNQF+isrCyMGTMGZ8+eRbdu3fDKK6/AarX6bCcIAu666y4wxvD9998HskkEQRAE0ahJTEyE2WwGAOzZs6fB2vH+++9j2bJlUKvVmD9/Po4dOwa73Y7s7GxcuHABFy5cwE033QQAngnuxoLbPfmdd94BE/OdVPpv6dKl1T721KlTkZqaikWLFuGWW25Bs2bNcOnSJXz55ZcYP348Bg0aVC3RTRAEQTQMARXAr7/+OtLT0zFs2DBs374dc+bMQVBQkOK2Y8aMAQDPbCpBEARBNEU0Gg0GDhwIAFi3bl2l1tVA8vnnnwMAZs6cieeeew6tWrXyiXW+cOFCQzStSqKjowFU37W5poSGhmLWrFn4/PPPcebMGRw/fhxPPvkkBEHA5s2bsWDBgoCclyAIgrh8AiqAV65cCUEQ8NJLL/mtTegmJSUFWq1WFhtMEARBEE2RBx54AIDoYvzaa69Vez+n01lnbTh79iwAoGvXrorrCwsLsX379jo7X13Sr18/AGL8cn2QlJSEF154AVOmTAEgTlwQBEEQjZOACuCTJ09Cp9OhS5cuVW4rCAKsViu5DREEQRBNnuuuuw4jRowAADz//PNYvnx5lfu8++67eO+99+qsDcHBwQCAffv2Ka5fuHAhCgoK6ux8dck999wDADhw4ADeeeedSrctKipCWVlZtY5rt9srXe/2cqtq0p8gCIJoOAL6hnY6ndBoNNVKBsEYQ2FhIUwmUyCbRBAEQRBXBJ999hnatm2LiooK3HzzzZg6dSo2b94sS/iUnp6ODz/8EN27d8esWbNQUlJSZ+cfNWoUAOC9997Du+++6xGJFy5cwKOPPoqXXnpJlrCrMTFo0CDceeedAERr+qOPPoqTJ0961tvtdmzbtg1z585FYmIiMjIyqnXcBx98EDfffDNWrFgh26ewsBCLFi3CRx99BEAK6yIIgiAaHwHNAh0XF4cTJ04gIyNDsYYfz86dO2G329G2bdtANokgCIIgrgjCwsKwbds23H333fjqq6/w2Wef4bPPPoMgCLDZbCgpKUFpaaln+7Zt22LAgAF1dv6//e1vWL58OQ4fPoxZs2bhvvvug9VqRV5eHhhjmDVrFkpLS/Hhhx/W2TnrkkWLFkGtVmPx4sV444038MYbb8BsNkOr1SIvL0/mLl7drM3l5eX46quv8NVXXwEQayFrNBrk5uZ6tunfvz+efvrpOr0WgiAIou4IqAV48ODBAIAlS5ZUue1zzz0HQRBw7bXXBrJJBEEQBHHFYLVa8cUXX2DPnj147LHH0KNHD4SHh6OgoABarRZt27bFtGnT8MMPP+DPP/9E9+7d6+zcNpsNW7duxezZs9G8eXOo1WpoNBoMHjwYy5Ytw6JFi+rsXIFAp9Phvffew9atWzF9+nQkJSXB4XCgsLAQkZGRGDx4MObPn4/9+/cjLi6uWsecN28e3nrrLdx4441o06YNNBqN53jXXnstPvjgA2zatIm82QiCIBoxAgtg7YKDBw+ic+fOMJlMWLFiBYYPH46YmBhkZGR4ShRcvHgRc+bMwbJly6DX63HkyBEkJCQEqkkEQRAEQRAEQRBEEyWgAhgAXnrpJU9pgK5du+Kvv/6C3W7HLbfcgtTUVOzevRvl5eVgjGHRokWexBUEQRAEQRAEQRAEUZcEXAADwPvvv4/HHnsMeXl50okFAe5T22w2vPHGG7jjjjsC3RSCIAiCIAiCIAiiiVIvAhgQMySuWLECW7Zswfnz5+FwOBAdHY1+/fph0qRJnnILBEEQBEEQBEEQBBEI6k0AEwRBEARBEARBEERDEtAs0L/++iu2bdtW7e137NiBX3/9NYAtIgiCIAiCIAiCIJoqAbUAq1QqxMTEIC0trVrbt2jRAmfPnkVFRUWgmkQQBEEQBEEQBEE0UQJqAQaAmupr8sgmCIIgCIIgCIIgAkHABXBNKCoqglarbehmEARBEARBEARBEFchjUYAHzlyBJmZmYiMjGzophAEQRAEQRAEQRBXIZq6PNh3332H7777TrYsLy8PM2bM8LsPYwy5ubnYvHkzBEHAgAED6rJJBEEQBEEQBEEQBAGgjpNgPffcc3juuecgCEKtYnkjIiKwefNmtG7duq6aRBAEQRAEQRAEQRAA6tgC3KVLF0ybNs3z/cMPP0RQUBBuvvlmv/uoVCpYrVZ06NABEydOhM1mq8smNTmio6NRVFSEhISEhm4KQRAEQRAEQRBEjTlz5gxMJhMuXLhQ58cOeBmk6OhonD9/PlCnILywWCwoLy9HUlJSQzeFIAiCIAiCIAiixpw4cQJarRYFBQV1fuw6tQB7s3HjRuh0ukCegvDCbfk9ePBgA7eEIAiCIAiCIAii5rRv3z5gxw6oAB40aFAgD08QBEEQBEEQBEEQ1abRlEEiCIIgCIIgCIIgiEBCApggCIIgCIIgCIJoEpAAJgiCIAiCIAiCIJoEJIAJgiAIgiAIgiCIJgEJYIIgCIIgCIIgCKJJQAKYIAiCIBo5ZRVOHLlQAMZYQzeFIAiCIK5oSAATBEEQRCPG4WQY89ZmjHzjV8z77kBDN4cgCIIgrmhIABMEQRBEI+ZQej6OZRQCAFbsTiMrMEEQBEFcBiSACYIgCKIRk19a7vlcUu5AcZmjAVtDEARBEFc2mvo4yYULF/DBBx/gt99+w7lz51BUVOR3BlsQBJw4caI+mkUQBEEQjZ5iu1zwZhbaYdLXS/dNEARBEFcdAe9Bv/nmG0ybNq1K0eteJwhCoJtEEARBEFcMRWUVsu+ZhXYkhpkaqDUEQRAEcWUTUAH8119/YcqUKbDb7RgzZgzGjBmD+++/H8HBwXj11Vdx4cIFrF+/Hps2bUJ4eDgWLFgAk4k6dYIgCIJwU+RjAS5roJYQBEEQxJVPQAXw66+/Drvdjttuuw0fffQRAOD+++9HUFAQZsyYAQD4+9//jh9//BGTJk3Chx9+iN9++y2QTSIIgiCIK4oiu68FmCAIgiCI2hHQJFibNm2CIAh46qmnKt1u9OjRePXVV7Fz50688cYbgWwSQRAEQVxR+LhAF5AFmCAIgiBqS0AFcFpaGjQaDdq2betZJggC7Hbf2evbb78darUan3/+eSCbRBAEQRBXFN4W4KwisgATBEEQRG0JqAu0TqeDVquVLTObzcjLy0NFRQU0Gun0RqMRFouFMkATBEEQBEdRmW8WaIIgCIIgakdALcCxsbHIz8+H0+n0LGvevDkYY9i3b59s25ycHOTm5qKsrPG4du3evRv//ve/MWHCBMTHx0MQhMvKUp2Tk4NHHnkEiYmJ0Ov1SExMxOzZs5Gbm1t3jSYIgiCuKnxigMkFmiAIgiBqTUAFcOvWrVFRUYHDhw97lvXr1w+MMbzyyiuybZ955hkAQEpKSiCbVCMWLlyIp556Ct988w3S0tIu61iZmZno1asX3nrrLWg0GowfPx4WiwVvvvkmevfujezs7DpqNUEQBHE14ZMFmlygCYIgCKLWBFQADxs2DIwxrFmzxrPs3nvvhUqlwpdffokOHTpg6tSp6NSpExYtWgRBEDzZoRsDffv2xbx58/D9998jPT0der2+1seaPXs2jh8/jgkTJuDIkSP44osvcODAATz00EM4evQo5syZU4ctJwiCIK4WfC3AnAC2FwDLJgMfjAIyj9dzywiCIAjiykNgjLFAHfzixYt48sknkZycjL///e+e5W+//TYeffRROBzyWe3Jkyfj008/DVRzLhuDwQC73Y6a3rL09HTEx8dDo9HgzJkziIqK8qyz2+1o1qwZsrOzcf78eURGRl5WG9u3bw8AOHjw4GUdhyAIgmgc3PD2b9h3Lk+27Mg/RkGvUQO7lgA/zBYX9pwJjHm1/htIEARBEHVMIDVNQJNgRUVFYcmSJT7LH3zwQQwfPhzLly/H2bNnERwcjFGjRmHo0KGBbE6DsWbNGjidTgwYMEAmfgFAr9dj7Nix+OCDD7B69WpMnz69YRpJEARBNEoKvSzAAJBdVIaY4CCgIF1aWHChHltFEARBEFcmARXAldGmTRtP3O/VjjvhV7du3RTXd+vWDR988AH2799fn80iCIIgrgCKvbJAA2IirJjgIKC8WFpYXlKPrSIIgiCIK5OAxgATImfOnAEAxMfHK653L09NTa23NhEEQRBXBkoWYE8pJF70VlByLIIgCIKoigazADclCgsLAYi1jpUwmUwAgIKCgmof0+0X782JEyeQlJRUwxYSBEEQjRHGmLIFWFEAkwWYIAiCIKqiXgTwiRMn8OWXX2L//v3Izs5GeXm5320FQcDPP/9cH80iCIIgiEaNvcIJh9M38WJmoasWMO8CTRZggiAIgqiSgAvg5557Dv/4xz/gdDqrlT1ZEIRAN6neMZvNAIDi4mLF9UVFRQAAi8VS7WP6y4jmzzJMEARBXHl4l0Byk6VkAaYYYIIgCIKokoAK4E8//RTPPfccACA2NhYjR45EbGwsNJqm5XmdkJAAADh37pzievfyxMTEemsTQRAE0fgpsvu6PwO8CzRZgAmCIAiiJgRUif7nP/8BAIwbNw5ffvkldDpdIE/XaOncuTMA4I8//lBc717eqVOnemsTQRAE0fgpKlO2AEsu0HwMcGk9tIggCIIgrmwCmgX6wIEDEAQB//3vf5us+AWAUaNGQaVSYfPmzcjIyJCts9vtWLlyJdRqNa677roGaiFBEATRGPHnAq2cBIsEMEEQBEFURUAFsCAIsFqtiI2NDeRpGg1vv/022rRpg6eeekq2PCYmBpMnT0ZZWRnuv/9+VFRIA5q5c+fi0qVLuO222xAZGVnfTSYIgiAaMUolkAB/SbBIABMEQRBEVQTUBbpNmzbYu3cv7HY79Hp9IE8VEFatWoWFCxd6vpeViQOOPn36eJbNmzcPY8aMAQBkZmbiyJEjSE9P9znWG2+8gW3btmHFihVo06YNevTogYMHD+LAgQNITk7Ga6+9FuCrIQiCIK40+BJIJp0aRa7v2UV2OJwMat4C7KwAHBWAumnl2SAIgiCImhBQC/DMmTNRXl6Or776KpCnCRiXLl3C9u3bPf/cWaz5ZZcuXarWscLDw7Fjxw489NBDKCsrwzfffIO8vDw8/PDD2LFjB0JDQwN5KQRBEMQVCG8BTggzeT47GZBbXCa3AANkBSYIgiCIKhBYdWoTXQbjx4/Hr7/+im+//RYDBw4M5KkISGWQ/JVJIgiCIK4clm45hQUr/wIADEmJwJYTWSircAIA1s4eiJT3WgKOMmmHx08CpjDxc+ElYPsiICwJ6DKlvptOEARBELUmkJomoH5Szz//PDp37ozNmzdjyJAh6NevH3r37l1lvdv58+cHslkEQRAEcUVQxLtA6zUIM+mQnidaebMKiuTiFwAqOJfoTS8Au94XP4clA816Brq5BEEQBNHoCagAXrBgAQRBAAAwxvDbb79hy5YtVe5HApggCIIg5FmgTToNQoySAM7PL/Ddga8FfOFP6XP6XhLABEEQxP+zd97hclT1/3/P9nJ3b+/3ptx0EhJCEkJvImJBRAQ7IGADREV/Igo2/CqiolJEVEJVBKnSSyCUhBTSe7k3t/eyve+c3x+zO+ecmdlbcu+mntfz5MnM7Ozs7N7dmfM+708RIM8C+Mwzz1QFsEAgEAgEgrHBCWC7BaUFtKVgMBjQP4EtipUI0+WYPx+nJxAIBALBEUdeBfCKFSvyeXiBQCAQCI5q+BBoM0rcjAAOGQhg1gFOhOiyEMACgUAgEADIcxVogUAgEAgEB47WAWYFcDhkFALNOMBshegRBHBPIIbP3LsSF979PtoGI8PuKxAIBALBkYwQwAKBQCAQHKaENX2AS1xUAEcjIf0T2DZIbAh03MAtZnhsdQs2tfmwtcOPR1e3HPD5CgQCgUBwuJPXEGiBQCAQCAQHjtYBNploXY2YoQDOhEDL8pgc4OYBum/HUHSYPQUCgUAgOLI5KAJ4xYoVePzxx7FlyxYMDg4imUzm3FeSJDQ2Nh6M0xIIBALBMYQvksDOriBOmloCs+nIKNDICmCXzQKXzayuJ6MGAjhbBCupCWMeRQh0lv5QfJg9BQKBQCA4ssmrACaE4KqrrsIjjzyiro+EqBotEAgEgokmmkjj3D++g8FwAl85eRJ+/ZnjD/UpjYpwggrgArsFNgvNXErEwvonZB3gcQjgwXBimD0FAoFAIDiyyasAvvvuu/Hwww8DABYtWoRPf/rTqKmpgcUiIq8FAoFAcPDY2DqkCrvlO3vx688c2vMZLZE4zQF22c3wOqzqejoe1t/Fs0WwEhp3OCOA46k0unwxTClzqw8RQtDtpwJ4QAhggUAgEBzF5FWJPvjgg5AkCddccw3uv//+fL6UQCAQCAQ5iSapkIyn5EN4JmMjFOcdYLYKtJ0YhCpnHeCExh2OBRBNpPHRP72D9qEovnfeDHzvvJkAgEA0xX0mQ5EE0jI5YsLEBQKBQCAYC3mtAr1nzx4AwO23357PlxEIBAKBYFg4AcwsH86k0jInTN12C4qcVmR1qQMGAjibA5zQhECn41i5qx3tmQJXT29oVx/qZsKfAYAQRQQLBAKBQHA0klcB7HA4UFRUhOLi4ny+jEAgEAgEwxJLUiF5pDjAbAskQGmDZDJJKM60QnLCQKSqDrC+QFZ3T4+6PBSmxSi1AhgQecACgUAgOHrJqwA+/vjjEQgEEAoZVKoUCAQCgeAgEWNc35RMkEof/iI4whTAApQq0ADUMGinZBQCnRGz2iJYAPr6e9XlUDyFZOYz6DEQwKIStEAgEAiOVvIqgK+//nqk02ksW7Ysny8jEAgEAsGwxDRhz4nDUAA39oXwyxe2Y/lOxallWyDZzCa1AnSxezgHOCNmtTnAAPxD/dx6IKq4wD1+4QALBAKB4NghrwL4c5/7HK677jrcdNNNePTRR/P5UgKBQCAQ5EQb9hxPHn4C+AdPbsaDK5vxrcfWo7k/jDBTAdptp/1/SzMC2DAHWBXA+siroH+AW/dlBLBRCPRASAhggUAgEByd5LUK9FVXXQUAcLlcuPLKK3HrrbdiyZIl8Hg8OZ8jSRIeeOCBfJ6WQCAQCI4xopp82sMtDziZlrGl3ZdZJnhlWzcW1BWqj2fDnwE2BNpApCazAlgfAp0IDXHr/qwDHNALadEKSSAQCARHK3kVwA899BAkSQIhBADQ2tqK1tZWw32z+wkBLBAIBIKJRhsCHU8dXpWgu3wxyISuv7GjG9MrCtT1Aju9XZceYAi0B7wo9keyAtjIARY5wAKBQCA4OsmrAL788sshSaKPoEAgEAgOLbHU4e0Atw3x4nRjmw8tA1TEupgQaJoDPFwRLL0A9oLf5osqAlpUgRYIBALBsUTeHWCBQCAQCA41seThnQPcNsgLYEKAp9bTXr2sA5wNgXYYhUAP5wBLegc4lZYNKz6LHGCBQCAQHK3ktQiWQCAQCASHA4dTCPS+3iA6fFFum9YBBoBd3UF1ua7YpS6Xuu0AcjnA2T7ARg4w/xq+aBJ9oTgI0e2KgbAIgRYIBALB0YkQwAKBQCA46tEL4IPjAN+1fC/OuOMt/GtNCwDgxS2dOO/Od3H6795Si14BQNtgNMcRAJfNjK+fMVVdLxkuBziZOY6RANY4wL5IEt0GLZAAUQRLIBAIBEcveQ2BZvnf//6H1157DS0tLYhGo1i+fLn6WDgcxubNmyFJEk455ZSDdUoCgUAgOEbQhUAfBAd4IBTHn9/cA5kAt724A5ecWIdnNnQAUEKcn9nQgfl1RQCMHeAsv7n4eDSU04JYtAr0WB1gflsgmuQqQLtsZkQy1bJ9mfBoi1nMkwsEAoHg6CLvAritrQ2f/exnsWHDBgBQKz2z2Gw2fPGLX0R7eztWrVqFpUuX5vu0BAKBQHAMoXOAD0IOcJefVnaOJWU09oWwp4eGNW/O4QBPKXWheUARxJctrsNnFtZyxy12WwEADsMq0JnjJPWC2iPxLrMvmuQqQM+p9mJ9C22VNBhJoMLjGOYdCgQCgUBw5JHXqd1wOIzzzz8f69evR21tLa677jq43W7dflarFVdffTUIIXj22WfzeUoCgUAgOAY5FFWgtZWUN7T60D5EReiOzgCSaRmRRIorRHXvl0/E5xfX49qzp+FXF83THdduMcNjtxxADrCmCnQkwQngqWVuOKx0WCAqQQsEAoHgaCSvAvjee+/F7t27ceKJJ2Lnzp246667UFBQYLjvRRddBABYuXJlPk9JIBAIBMcgow2B7g/F8UHjAGTZoDLUGNEKyJe2dGrOQcaeniAniq1mCbOrvPjd5+bjRxfMhsNqhhElbuuY+wBrc4D90STXAqnK61ALbAGiErRAIBAIjk7yKoCffvppSJKEO++809D5ZZk3bx7MZjP27NmTz1MSCAQCwTFINDGyA+yPJnHOH1bgi/9Yjf97eee4X1NbSGrN/kHdPlvb/VwLpJoiJ8wmSbeflkq3BJNkINKTwwhgRDiH168Jga702lFaYMt5/gKBQCAQHA3kVQDv3r0bZrMZp5122oj7ms1mFBUVwefz5fOUBAKBQHAMonV8jXKAP2gcQDCWAgC8saNn3K85pBGQRu2GNmsEcD3T7mg4qhw5QrjTceWFDASwS4rjxFoaheWLJNHBuM9VhU6UuhkBbNAfWCAQCASCI528CuB4PA6n0wmz2TiES0skEoHDIQpuCAQCgWBiGU0INJuHG4glx/2ao3FQt3b40MaI0PoS56iOXeEcJoc5GTUsggUAVy8pVZdTMkErI74nl7pQwoRAixxggUAgEByN5FUAV1ZWIhQKjcrV3b59O6LRKOrr6/N5SgKBQCA4BhlNH2A25zUQTYIYWbZjYDA8soO6qyuIxr6Qul5X7AJifuDNXwCr7jG2jQGU53KAASA6BMD4eWdOsnHrbKpzfbGLC4HuFznAAoFAIDgKyasAPv300wEATzzxxIj73nHHHZAkCeecc04+T0kgEAgExxjJtIyUpqiVoQBmBKtMgHBifL2Ch8K5XeRsmm9KJlixu0/dPqnEBbzxc+D9PwGv/xTY+l/D55fZ6bklJSv/YGSAW40T+rg1EYDbpo/KKvfY4bSZuRDo0Qh4gUAgEAiONPIqgK+99loQQvCLX/wC27ZtM9wnkUjg5ptvxqOPPgpJkvDtb387n6ckEAgEgmMMrfsLAHGDbf2anNdAdGxh0LJM8N8P2/D8pg7IMuEENYvHbsGC+iLDxyZ5TcDWp+iGHc8b7ldsTanLIUnTXYERwDKR0EuY14r5UeTiXWAAmFyi5B6XMAK42x/T7ScQCAQCwZGOJZ8HP/XUU/Gd73wHd999N04++WRccMEFCIWUUK+f/OQnaGlpwZtvvon+/n4AwC233ILjjjsun6ckEAgEgmMMbf4vYOwAa0N+A7EkajB8Tm4iJcNmUeaSf/vKTvzjvf0AAJkQDEWMBfSMygLMryvCxlaf7rGGofeBRJBuaHoHSCUAi00Jh97wMLD5CcxPUlc3QuwotjhoCyRGAEdghx9u1CPjMscDKHSWoMNH846BjPMMYHIp7diwud2Pt3f14pzZFcN+BgKBQCAQHEnkVQADwJ///Gd4vV7cfvvteOaZZwAAkiThd7/7HQCAEAKLxYJbb70Vt956a75PRyAQCATHGEYOcMJQAGsd4JRuH5Zbn9uGx9e24hPHV+MLS+pV8QsAb+/qw1DEOId2ZqUHJzeU4qFVzdz2Sq8dBXv/oznRINC2BiifBTx/PbD3NQBAGbNLmNgAi50RwLTdUhR2BAhTWTrmR6GzUndO9RkBvGhyMU6oL8KmNh8A4CfPbsXr3z8THodV9xyBQCAQCI5E8i6AJUnCbbfdhmuuuQYPPfQQVq5cic7OTqTTaVRVVeG0007DVVddhYaGhnyfikAgEAiOQYwqPo9UBAsYPgS6NxDDo6tbAAD/29yJ/23u5B7f3unPVb8KMyo9+NjcSnz/vJlYua8f4UQKTqsZN5xeCem51/RP2PYU0PgW4Gs1PF5YtoFYnJDgVzYwDnCYOBCSqKurhEBTMVsOH661PI8FgZMB3AizScIdn5uPT971HpJpgi5/DLe/sgv/d/HxOT8LgUAgEAiOJPIugLNMnjwZP//5zw/WywkEAoFAACBXCDQvihMpGX6N4B2uFdK+3hDOMm3GZ8zv48n02fhAnss93jxA2wtZzRLKCuzoyuTUzqn2QJIkfPe8GfjueTOAF28Etj8LvF+j9PHVsv6hYd9flNggm21QS1txIdAOwFEIZLV9zI9CpyKAzUhjme0OHG9qBra+BixaCkw5DTMrPfjOuTNw5xt7AABPftiGWz55HJwGxbMEAoFAIDjSyGsRrNbWVnR0dIx6/87OTrS2Gs9wCwQCgUBwIESNimBpHGCjnrfDOcCBfavwgPX3uNi8Esusv0cFhrjH00zV6WKXDf/vY7NQ6LTigrlVOHkq7cWL3l3Ahw8A0UGghykWOeUM4xf2VOs2RWFHyuSgGzQ5wLaCYvpYLIDCjAN8pfk1RfxmaXpbXfzWWdMgZSpVJ9MEvUFREEsgEAgERwd5FcBTpkzBSSedNOr9TzvtNBEKLRAIBIIJxbgKNC+Atfm/ABCIKTnAu7oDGGIFcjyIkzb+GBZJOYZTSuAG+wtYUFdo+Polbhs+e2IdNt76Ufztq4tgyvZAAoD2dcYnffbNQNEkflvV8cBXn9XtGoUNSYmp7MwKYGKHu5jJ+fW3ochpQw36caNF02Kp/UN10WYxochJQ6UHDCYIBAKBQCA4EsmrAAaUIlf53F8gEAgEguEYTQi0kcALRJO45629uODP7+Gjf3oHXf5M5eRXf4ySOB/d9GXLW3j+q1O5PrpZsq2FOOGbpXMDs2MDUD4HOPU7wORTgekfpY9JJuDTdwNlswBHEf/+YEeCEcBEEwLtrp9Pd+7agkKnFT+3PgK3pBH9HRsAmX5WbEukwZAQwAKBQCA4Osi7AB4LsVgMFstBS0sWCAQCwTGAoQOsCYHuDxo5wEn87Z0m5fFQArc8uw3o3gpsfEzdJ00UUSulE8B7f0RdiUt3nBIDUazSsZ4un3oDcN1q4PxfA5IELLoCMGeee8YPgZqFgMkE1C3hDhElNsRB3Vo5zBTBgh3Vs5Yyb6odtalWfMz8IXTE/cDAXnW11G1Xl41CxAUCgUAgOBI5bARwZ2cn+vr6UFpaOvLOAoFAIBCMktEI4IGwXgAHIwmE4rQV0vJdvUi2UuG4T67Bbamv0idseARzPRFoMXKFAQDJGNCzna7XLuIfr14AfHsVcNVrwLk/pdvr+dSiKOyIyVQAS4wDDKsLxVWTAXe5umlm87/U5R5ShF7HVLo/EwZNhTuB1L0JiPJ5zgKBQCAQHIlMqN367rvvYsWKFdy2UCiEX/3qVzmfQwiBz+fDyy+/DEIIli5dmnNfgUAgEAjGinEOsCYEWhPi+33Lf/GN/a9ioeVc/Cb1ZXX7vn27MCezvIU04AlyHn7ufhVSuBeQkzjR2ox/o4Y7VnEuAdyzDZAzAtviACrm6PcpmwFgBr+tbjH/XmBFhFABbJLpe3G6CxU3uXoBsO9NAEDlfppHvE6ejZkl1ajozPQwbl8HLFTeb0mBLfNZPIVL1z8LbC8CbtgIuEqM349AIBAIBEcAEyqA3377bfzyl7+EJNE8p3A4jF/+8pcjPpcQAofDgZtvvnkiT0kgEAgExzjGOcD8tj6mCFYRgviO+TmYCME3LC/hkfT5aCeKg9rdulcVwJ2kFFUlhZCKJgPhXgBAjV1fOTqnA9zB5P9WLwDMVuP9tNTyArhaGkR/zPh27vEW0eNnBLApFVUfXyPPxrSa6UBnRhR3UAc4e94Xmj5QNsR8wN43gAWfH915CgQCgUBwGDKhAnjKlCk466yz1PV33nkHVqsVp5xySs7nmEwmeL1ezJs3D1dccQWmT58+kackEAgEgmOcUYVAMw7wPFMzTBItyHiqaRueTJ8DAHCEu5BtuNtBytBQ5gZMBeq+5QYCOKcDzOb/1pw44vtQcXi51QSxoCNEDO/oxUWZytRV8/UPQnGAr2lYBGR1b892IBEGbG5VAFdKTOjzYOOIpyfLBJIEbjJcIBAIBILDhQkVwFdccQWuuOIKdd1kMqGkpARvv/32MM8SCAQCgSB/xFJGAlhbBZo6wMdL+7nHTjNtVwVwjdSvbu8kZZhR5gbCHnVbqVWfS5yzCBZbAVqb/zsSH/0V8MbPIBMJy9IX4Mvm5Ya7VWTralQv0D3mJy7IZbNRO2MhYCsAEiGAyEDnJmDKaSgpsMOFGF8temB4AbyzK4BrHv4QdqsJj3/9ZFR6HcPuLxAIBALBwSavJZcffPBBOJ3OfL6EQCAQCATDYhQCnUwTpGUCc6Y1UX+QdYCbuH1PNW0HQCCBoFqiBaY6SCk+Vl4ApKgj65VikCSA7ejHVlOmJxUA+mnFZdSOwQEGgFOux05pOq5/oQONpBZxGIvsitJMvm7xFMBeqFR6zhCvWYonvnIaLFarUmG6+T3lgfZ1wJTTUOq2oULSFL4awQF+5IMWdPiUEOuHVjXjpgtmj+19CQQCgUCQZ/JaBfqKK67AZZddls+XEAgEAoFgWKIGIdAAkMiEQRNCOAd4ntTM7Vcu+XHNzDhOKErAJtFjdZFSTC1zA3YaAm1JhVGlcT2L3Qa5vV2bAGRUsqNQ6QE8FkxmWKefhUZSCwBcGyQOm1v5X5KAaj4MumLeOTQ8m22t1LoagOJcV8DHH2+giVf3GrLiFwC2dfhz7icQCAQCwaHisGmDJBAIBAJBPjDKAQZoGHQglkIyrYg6L0KYbOrV7buYbMO1C6nL6iNuhOHEtHI3YKch0IgHUV/M9wIudhm4s7276HL1AkWgjhG2uFac5BDAVuZctGHQk0+jy1OY5ZZVgJzOOMA+/jlxPxDuR/tQBKsa+yHLvBjuC8RworQHc6VmbO8MgAwjlsdFIpyf4woEAoHgqCevIdBZVqxYgccffxxbtmzB4OAgkkl9kZAskiShsXHkIhsCgUAgEIyGuEEINEALYfUzFaAXmFsM950V3YD66nnqegcpAwCUe+waARxAXYkTa5uV1UKnFVazwVyzv40uF08Z+U0YUOi0wiQBMgFiOUKgYaPuNCeArS5+vf5kwGRR2jLF/UD3VhRXztcLYAC9Ldtx/hMxRBJpXHfONPy/j9Ew5yWB1/Er+90AgK9Gf4zuwOmoLpzgVKi3fwu8ewcw+5PA5x+b2GMLBAKB4KgnrwKYEIKrrroKjzzyiLo+EqJqpEAgEAgmkpwOcFJGtz+GTiZs9yR7K5DRyyHiQIEUAwDU+tbDEjhb3a+TlGHx5GLlnsWKzHgI9dXUdc1ZACvQQZe9dWN7QxlMJgnFLhsGwomRQ6ABYPp5gLMYiA4B8y/j2y7ZC5RK1O1rlfXm92CtOQF1Vn0Y8/atGxFJzAQAvL69RxXAaZngrOT7apXsK8yvYXvHVRMrgGUZWPkXpVjXzheUolyl0ybu+AKBQCA46smrAL777rvx8MMPAwAWLVqET3/606ipqYHFclCMZ4FAIBAIDKtAA0qRpgdX7edSWuebm1UB/FT6THzZvBxWKQ1bKgjsfFHdL+Guwc2fyDifdqYtUTyIhnIqOrX5wCp+RgAX1o7l7XCUuBUBHCM5hLaziC67SoBr1wB9O4FJp+r3nXI6I4DfB079DmotQSDF7xbu2gNAEcBd/pi6fSAcxywTdbbPMG3Fg22dOO+4ygN4ZzmIDgJMH2NEBoUAFggEAsGYyHsVaEmScM011+D+++/P50sJBAKBQGBINGEsgP+1pkUVv1OkLhQijNmEpuCslWfjOFMLTpJ2Kxs6PlQf++QZS4DJmQrLbAh0IoSPza3CkinFaOwL4xtn5Shu5W+ny97xCWAgRxGsmhP1x/ZUKv+MmHI68P6dynImD7jS5NPtZvXTKtmheAqBWBJehxUD/T2Yw7SJsksp2BpfBbBwLG9peEI9/Ho8MHHHFggEAsExQV4F8J49ewAAt99+ez5fRiAQCASCnBi1QQJoDvAppu14zPobmCXCuZ1byVS8k16Ak0y79U8uZMKW7WwIdBAOqxn//dapkGUCk8kgrUdOA8Eu42ONkawANswBPveWsRXXmsTmAQeA7i0oIz7dbvVyF7fe6YvCW2VFrH2rbt+Z/ctx+ysX48Utnbj27On40tJJoz8fI4Ld/Ho8OL7jCQQCgeCYI69VoB0OB4qKilBcXJzPlxEIBAKBICe5QqCzXGp+RxG/DD7iRhupwAp5gfGTChkhp6kCncVQ/AKKiCPMOU2AA5zQzmdPPg2Ydu7YDmZzA7WL6Pr+91AsD+p2myx1Q23hBKDLlwmD7tmu23dJeiP+9c5WtA9F8fP/bYM/krsIJocsA/vf5atlA8IBFggEAsG4yasAPv744xEIBBAKhfL5MgKBQCAQ5CRXFWgFgpNNO3RbX00vASBhB5mMfhTpn8Y5wBoBPFLBR7YAlrMEsLly7zsC2VZIUWLnHzjnpwfUWglTTqfLjW/BndYXwXJLca4/cKdfycm1D+zU7WuXUviIaQMAIJkmeGNnj24fQ9b+HXj4QuCvS4FuxlnWCWDhAAsEAoFgbORVAF9//fVIp9NYtmxZPl9GIBAIBIKc5KoCDQCTpF7USIzL+cUn8PSsP+KW1FUAAAITNtoX808yWYECJo/WxghgkJF71LL5v+MogAUAp05X2jFtIQ2I2jI5yXM/y/f1HQusAG5+j3soItHiXlMlGoqcdYC9gT3qtgChov58M82dfnUbHz6dkx3P0+U9r9LloBDAAoFAIBgfeRXAn/vc53DdddfhpptuwqOPPprPlxIIBALBEUS3P4YNrUOQ5ZHb440XVgC7bGbusVNY97dsFjDrAvTVnIMUE1K813Myf0BvDWBibp+sAwyMLMq4AlgHnv8LAEunluA/3zgZf/nKKbBevwa44kXgs38/8APWLgKQcY5lmhDtJy7skum5TjFRAdzpjwJyGuURWkDs3+mPqMszJeX9ftq0Cv/XdCmST39rZJd8YB9dDnTSZeEACwQCgWCc5LUI1lVXKTPoLpcLV155JW699VYsWbIEHo8n53MkScIDDzyQz9MSCAQCwSGkwxfFOb9fgURaxo8/PhvfOit/bWwIIYgyArjQaUWEqQrNhT9PPQMA4HXwFZV7yk8BBsw0b7ewnn8Ri11xheVMfmtihLSfwMS0QAKUe+bJDaV0g7diXMeDoxAon620SmLoJcVolCtxokUpCKZzgIeaYSeKEywTCX115wHdLwAAJpn6UOI040fyf1ApDQFbHwcWfTW3Sx3zA+Feus62jBI5wAKBQCAYJ3kVwA899BAkSQLJzPS2traitbXVcN/sfkIACwQCwdHNQyv3I5FW8nJvf2VXXgVwMk3AmsyFTivTu5bwDnAm/LfQyQvggqIyoP4koPUDZUORRgBLklIJOjqkrI8kyiaoBVLeqFtsIICL0EaouJ5h96kVszv9UaBnm/pYM6nEqSefDjynrNuQxJenJVC3j7ZIQusHuQUw6/4CvAMsqkALBAKBYJzkVQBffvnlkA6kCMdhRDQaxW9/+1v85z//QWtrK0pKSnDBBRfgtttuQ23t6AcuU6ZMQUtLS87Hd+7cidmzZ0/EKQsEAsFhzWCYrwQcjqfgtufndqStAO1lxO0UqRtV0hB9cPLpmX34cykvsAPzP08FMJsnm8XuYQTwWBzg8YVA54X6k4CNfNpSL4rQCeo0L/AGgUyqc5c/BtK9LRs4jV1kEurKygB3ORDuAwBc5OELjaVa1uQegAw08uvs5xXq5R+LCQdYIBAIBGMj7w7wkUwsFsO5556L1atXo7q6GhdddBGam5vx4IMP4sUXX8Tq1avR0NAwpmNeccUVhtsLCwsn4pQFAoHgsKfEzTusO7oCWDKlZOwHSieB136qiKzzbzMUk9oCWKy7y7m/5XOAgnIA+hDoCq8DmHel0iYIUIpMabF76fKIOcCHuQCuW6Lb1EeK0EHK1PWSFBWiiZSMWPsWODPru+RJWOixA8VTVAHc4PuAP2D7WqRSKfzmlT3o8kfxk0/MQX1JpnCW1gGODgKJCJQCY5rPVjjAAoFAIBgjeRXARzq//vWvsXr1apxyyil4/fXXUVBQAAC488478YMf/ABXXXUVVqxYMaZjHumTAgKBQDBeAtEUt7613X9gAnjrU8Da+5VlVynwyT/odtG2QGLF7ckmJsw3k/8L8C4xAJR77EqY8/zLcp+LrYB50YwoS8aADx8AWlYBi68Cpn8ESMX5/NbDMQS6bJYi6JlQ7l5ShE5CHWAp1I0iO+CLZzZ0b1Ef20XqUeq2A8VTgfZ1AABT6yruJSxxH95buwbLVvoAAL5IEo9/I1NsTCuAASCYo3q0EMACgUAgGCN5rQI9FmRZxgsvvIDPfOYzh/pUAACJRAL33HMPAODee+9VxS8A3HjjjZg/fz7eeecdrF+//lCdokAgEByR+KIJbn1bB+01G4gl8YfXduOf7zUhPVKFaCbvFP27DXdhC2A5rCY4rPS2t9jEPGcyzUf1OgxCoEeCrQSdCAE7XwDuWQK89hNg14vAk1coxZ3YcF5ISkXpww2TCag9kdvUS4rQTegkhURkzPVEAABl8MMZoXm6LfZZsFlMigOcJc3/zQFg2+o31OUPmgboA/179ecU6NCHPwNCAAsEAoFgzBxyAbx37178+Mc/Rl1dHT7zmc/ghRdeONSnBABYuXIl/H4/pk2bhoULF+oe/9znPgcAh835CgQCwZGCL8LnAG9lBPB9Kxpxz9v78OuXduK17d3ap/KwYjLcb7hLjBPAZtgtShukKgygVmJE1yTa6qjIZUNtkRLQW+6xo7rIMfx5ALwAbloBPPEVwM8UfUwEgS1P8uHPBZWAmXebDxs0YdB9KELKZEfSScOgj3Mpf7cTTNSx7SbFIFlRXzJ12Jc4QeInLYbCCaU9kjYHGFA+t5DB90EIYIFAIBCMkUMSAh2JRPDkk0/igQcewKpVSlhUtlL0nDlzDsUp6di8eTMA4MQTTzR8PLt9y5Ytho/n4ve//z0aGxtht9sxd+5cXHzxxSgvLx/fyQoEAsERhD/KC+DGvhAiiRRcNgvW7h9Ut2/v9OMTx1frnt/UF8K/1rTi622NqMpuzCmAaQi0w2KGPeMAn2iiLmPYWQu3Rz0SzCYJ9391EZ7f1IFPHF+tiuZhsTMh0E3vGO+z7p/A6d+n6+NsgZRXNAL4srMW4XszToD1zUlAVPmsp9mGAFRjgYkK1s3yNCVkHOAdYAOmxfjCWDu7Aji1Igkkw/qdAx36fsuAEqadTimfbTwAnPxt4/0EAoFAIMhwUAXw6tWr8cADD+DJJ59EKKRUySSEYPbs2bj00ktx6aWXYt68eQfzlHKSbddUV2dcoCS7fbjKzkb86Ec/4ta///3v4+6771Z7JgsEAsHRjlYAywTY0RnA4iklaOyjFZS1TnE8lcbfVjTh3rf3IZGWcZW9A2rp4cgAIMtK+C5DTBMCbbcojy9iBHCwfCHcmnOcV1uIebVjKE7IFsFiCzVNPh1oeV9Z7tuluMBZDsf83yy1iwEp0/vYbMPFZ5+kCMvCOqBzAwBgklmZrDhBog7wJnk6DRkvHt4Brog3oxAh+KFMHuzoCuBUc4fxzoFOpUexDgJs+hfw6k2ZdQk46/+N+m0KBAKB4Ngj7wK4r68PjzzyCJYtW4Zdu3YBoG6vJElYt24dFi1alO/TGDNZge5yuQwfd7uV4VIwOLrwq09/+tM455xzsGjRIpSXl6OpqQnLli3DX/7yF1xzzTUoLS3FRRddNOrzmzt3ruH2xsZGTJuWv56aAoFAMF60whZQwqAbygu4x3waofzD/27BC5uVXFMTZFSCaWFE0kDMB7j4Ylq5QqBZBzhRra96PGZyuY5TzwTMFiUsGgAal9PHDscK0FncpcD5vwbW/QNY8nX6/gppD+RK0gcJMucAbyLTMC/rABdUAhYHkIqpj/cTZaKgTFIKbC007cUKWUkz2tEZAJwG+b+A4gAzx+HIfrYA0LVp9O9RIBAIBMckeckBJoTgpZdewiWXXIK6ujr86Ec/ws6dO+FwOPCFL3wBr776qrrv4RLynG/uuusuXHzxxZg0aRKcTifmzp2LP/7xj7jvvvtACMFNN9008kEEAoHgCCeWTHOFqbJs7fCjqY/vn+tnxLAsEy4nuAJDsEh8hWejMOioTgCbYEcCc6X96nbTpJPG/D50sFWgWQrrgCXXGD9WY5xic9hwyrXADRuV/7Mwor041YsGqQteKQoAkImELXIDDYE2mXRh0E2kGhvlGer6cRKNotrRFeDzf+2M4xvoAEI9xufJVo2O+kb11gQCgUBw7DKhDnBjYyOWLVuGhx9+GF1dXSCEQJIknH766bj88stx2WWXweM5MnJzslWfI5GI4ePhsJKjNN73c/XVV+OWW27B7t270dzcjClTpozqedu3bzfcnssZFggEgsOBQFTv/gJKJeimPj73cyhCKwf3BuNIpKjgrZYGoSPSD2Amt4ltg+SwmmC3mnC81ASbpAjjCLHDXb9grG9DTy4HuLBOqTDtraVFu2we4OybgOM/N/7XPdgwArgg1o2FTAGsPaQOYTipAAYUAdy3S13dL1cjAvp41gkGgH29IaTL9kLNuJ5yOrD7JWU50AnkKgrOiuaYb2zvRyAQCATHHBMqgGfMmAFJkkAIwdSpU3H55Zfj8ssvx9Spw+cBHY5MmjQJANDe3m74eHb75MmTx/U6JpMJ06ZNQ29vL7q6ukYtgAUCgeBIRBvWnGVfbwgb23z8vowD3D7ET0ZWsxWcs4T7dJtiqTSmSR1wIwaHpQx2i5kLf95CGrCkwDjVZUwMJ4DNFuCSfwIrfgtUzAXOuBEoqBj/ax4KGAFsDXXgDGcLkGnrvElW0m9qi5jPU5MHvJ9UwQLqypcyAjglE6T6GAHccBYVwJEBIG383eGKZgkHWCAQCAQjkJcc4BtuuAF33HEHbDZbPg5/UFiwQHEENmzYYPh4dvv8+fPH/VpDQ0oeWzavWCAQCI5WWFFb7rEjlZYxFElCJsCLmzu5fdliWW2jEsA0BDoYS+LBlc3Ys2EFltuVokjLYjfDbrmcK4C13TQbJ5sk3aHGTC4BnC10NflU4IqjoG0ekwMsJUL4VOFOINPFap9tNj4+uwqLJhfT/Q1CoFnXtxS0BZYEGZYA0zpq0imAZAJIxsWP0+fB7uXXswgHWCAQCAQjMKE5wHa7HYQQ3H333aipqcF1112H1atXT+RLHDROO+00FBYWorGxEZs2bdI9/tRTTwEALrzwwnG9zvbt27F79264XC7Mnj17XMcSCASCwx1W1Ba7rDhpKi1aFYynuH1D8RSSaUX8tA1GuceMQ6CpKP7Ny7tw5xt7MMv/vrptcewD2M0S5wA3OY47sDeixUgAu8sB6yh6CB9JuMuUwlYZzH6aw3vLN76K+76yCGZ2QkHTC7iJVGOA0IrZrANcDj/MhPkOlExVCmkZUTrdeHsilNspFggEAoEAEyyAu7q6cNddd2H+/PkYHBzEfffdh9NOOw2zZs3Cb37zG7W10JGAzWbD9ddfDwC47rrr1JxfALjzzjuxZcsWnHXWWVwF63vuuQezZ8/GzTffzB3r5ZdfxltvvaV7jS1btuDSSy8FIQTXXHPNEe2YCwQCwWjwMXm9RU4bTm4oHXb/rGBuG6QO8Owqz7Ah0GmZ4NVtXQCAEtBK/VNdUTilOMol6jr2FkzQxKORAD6cqzwfKJJk/L6cxUC5wWdZQrsSEMmCVlKpVoIGgFKJ/n1qJaaImaNI+UyNWkXZCgCPvj+0igiDFggEAsEwTKgALioqwvXXX4+NGzdi/fr1+Pa3v43CwkLs3bsXt956KxoaGnDuuefiwQcfnMiXzRu33HILli5dilWrVmHGjBn4/Oc/j5NPPhk/+MEPUF5ejmXLlnH79/f3Y/fu3ejq6uK2r127Fh/5yEcwZcoUXHTRRfjiF7+IpUuXYtGiRdi5cyfOPvts3H777QfzrQkEAsEhgXWAC13WEQVwVjCzIdDHVXtRY+QAZ0Kgt3X4MZQJtS4xUYHlSftRkPJxT5EmKhfXqAr00SiAAeP3ddI3lFxnLWXTgXmXAJIZgcXXIQErBkAFcAkCkKC4/DXspEY21Npboz/mzAtyh5wDIgxaIBAIBMOSlzZIALBw4ULce++96OrqwqOPPoqzzjoLhBCsWLEC11xDW0K8/vrrSKVSwxzp0OFwOPD222/j1ltvhcvlwnPPPYeWlhZceeWV2LBhAxoaGkZ1nI997GO46qqr4PV6sXLlSjz11FPYt28fTj/9dPzjH//Am2++CafTmed3IxAIBIceNge4yGnFrEoPilzWEfdvH6Ih0MfVeFGVswo08M4eWgyr3sH0jg33w5WkzxskBfC6J+jaa+gA1+u3HQ1oBbDVDSz9Vu79P7cM+EkHyDm3AAAGCG1vZJFkVNlimFLqQg3jAMfcGeGrFcAlDcAnfj+8ABYOsEAgEAiGIS9FsFjsdju+/OUv48tf/jL279+vtklqb28HIQSXXHIJCgsLcdFFF+HSSy/F+eefD4sl76c1apxOJ371q1/hV7/61Yj7/uIXv8AvfvEL3fZTTjkFp5xySh7OTiAQCI4sfFEmBNplhckk4aQpJXh9h3GPV18kiVRaRpefCtnjqlyowJB+54wD/C4jgKstYSD7ktFBOBPUZRwghSgeRnyPiWMlBBoA3BrXfPHXAFeJ8b5ZrE4UmBSnNwgnEsSstqKa6ojgJ186ERvvv0/d/e1uGy4gBBITQg0A+NKTymsJB1ggEAgEB0jeHGAjpk6dittuuw0tLS14+eWX8dnPfhYWiwU+nw+PPPIILrzwQlRW5ih4IRAIBIIjHtYBLnQq4nO4MGhfNIkufwxpmTaBneuJwCwZNIUN9yMQS3LtlLyEqRRMZLiD+9XVQXhQ7J6g2gtmK1ccCsDRK4CLNe3/Trl+VE+zmE1w28wAJAyAusB1tjDm1Rbi3Oq4um2jvwDbOwNK+HT9UiWX+GuvAGUzlB2EAywQCASCA+SgCuAskiThggsuwFNPPYWOjg784Q9/wJw5c0AIgc/nOxSnJBAIBIKDAJ8DrIjPpQ253UNfJMEVwKrw2OGNG7vFiAxg1d5eVSyXuKywxH3cLg7fHnW5n3hR7JrA4oNaUeY9SgXwzI8Dtsx7PfNHgHeYglQaPA5l0oOtBF1tUfK0a5kc4A5Sjn29IcBdClz9OnDDBqWVVBYHfb4O4QALBAKBYBgOiQBmKSsrw4033oht27Zh1apVuPrqqw/1KQkEAoEgT7ACuCjjAM+p8nJ5wA1ltCe6L5LkCmDVl7ggBWm/4Da5nB6cpLFuZ5O6et40FySZb4ljG6QCeEJDoAG9AD5aHWBPJXDDRuAb7wDn/GRsT3UoKU6sAC43h5QFf7u6rZOUoqkvlPtA9mEEcNQgPF4gEAgEggyHXACznHzyyfj73/9+qE9DIBAIBHmCK4KVEZ8mk4SffHwOvA4LPnl8Nc6dTXNMfdEEVwCrvtgJ+DvU9d2kDrJE60as3LxbXT633qx7fcsg7QE8QLwomkgHmK0EbbYpfYCPVgrKgZoTlLZIYyArgPuZStDlUgCIhzjh2kHK0Ngf1j1fRYRACwQCgeAAOXyqTQkEAoHgqEfbBzjLZUvqceniOkiShHvf3sfsn0QoRjsF1Je4gAAVwJ2kDHFbMZxxpfCVR/YDqIbHbsEpBpG5UpK6yQPwomSicoAB3pX01gKmw2qO+bAgGwI9SNhWSH7O/U0QM/pQiKa+AxTAIgRaIBAIBMMg7s4CgUAgOCikZYIAI2azRbCySBk3kd3ujybRxjjAdcVOTix1kxIMMW5iqRRAldeB+76yCIUYJoQWQMRajNqiCWxBx4qyozX8eZwYhUAXyrwA7iKlIDBhf38IsmxQ7AwYIQTaNxGnKhAIBIKjFCGABQKBQHBQCET5fNzCHPm3bD6wL5LkimDVF7sAX4u63kbK0SvT0OOZBTG8+YOzcPqMMiBCiyoZceV5S+C2T2AglJ0JgT5aewCPE29mcmOAmbTwyEOAv01d7yRlAIBYUkZXIAZDhAMsEAgEggNECGCBQCAQHBTYAlgmCfDkEJ9sZebuQAy9Qdoep77YCQw2q+utpALtcVo0a6orhoLscUcQwPNnTR/L6Y9M8RS6XDFnYo99lKDmABPaBsmd9HECeNBKc8BzFsISDvARw/qWQfxvcyfiqfShPhWBQCAAIASwQCAQCA4SvijfA9hkMi6gxIZA9zHi1yQBVbYIkAiq21pJBfpk6gZWmeljiAwOf0LustGe+uhY8nXguIuA4y8DFn9tYo99lOA1aIPkSA5yIdBxd426zOYBD4YTeG9vH5JpWTjARwjbO/245L4PcMPjG/H3d5pGfoJAIBAcBEQRLIFAIBAcFLgCWMNUXy7KERrdUF4Aq5+GPweIE0PwcGKqVArQJwznAEtmwFE08kmPBU8lcNkjE3vMowyjHGBbwg8M7lfXpaJ6QKlppjrA0UQaH//Lu+gJxHHxwlr86fMnABYHkMqESJttQDrz/RJtkA4b1jTRSajV+wfwHcw4hGcjEAgECsIBFggExyaRQSCdHHk/wYTh1zjAucgljk+oLwKGmtX1NlIBQMIgk09aSEYpgN1lokrzIUAVwNCEMHdtVhedZZPV5aZMK6T1LUPoCSjRAG/u7FEeZF3gUiacPRkBUnSyRccH9wJPXg50bzuAdyAYC5EELXoXiosQaIFAcHgg7v4CgeDYY/tzwB9nAX+aN3KYrGDCYHsADyeA3TYzLAbh0Qvqi4Ah6hS2kEoAvJtYkGLcv+GcwKO5R+9hjMeu/N1jsCNM7PSBNA11L6lpUJezIdDNAzQUOhRPKdWhWQFcNpN/oVxh0B0bgNd+Aux4Hnj1x3R7MgaQHBWnDxWyDOx/F+jfO/K+hynhBBW9kXhqmD0FAoHg4CEEsEAgOPZY/5ASLhnqBrY/e6jP5piBFcC5wpwBpR2S0eMn1BXpCmABwAChQsieYCY0RnKABQedrAMM8BMXLDWTaJhshy+KaCKNVqYSOCFAKJHiBXBJA2BisrpyFcJq/5Aud29R/t/6FPC7KcDfz1KE8OHC6r8CD18I3LME6Nt9qM/mgGBFb1gIYIFAcJggBLBAIDj2YIVRsOvQnccxBhsCXTSMAwzow6BtFhNmVXm4EOjWjAPci2J1mzk6QEPbhxPALiGADwUeB/27D6BQv0NhParLS2Gz0OHJ/v4wmvvD3G7BWIqvBO2p4nO6cznAfbuYffyIhYaAlX8GUlElDHvfG6N/M/lm9yuZBQLsW35IT+VAYR3gkBDAAoHgMEEIYIFAcOwRZ/JEQz2H7jyOMXqD1F0brggWoBfIc2u8iihiQqCzDnAPoQJYAgGC3YpNOKwDLEKgDwVeJ3Vp+40c4CVXw2ySMLWUtrZq6g+hZSDC7RaMJZWK2wBgtgOzPgE4i9THE6EcqQ39e7jVi3/7JOK9++iGwGE0IcZOziVytIM6zImyIdCJNMjhFmYuEAiOSYQAFggExx4xP10OGgvgWDKNp9e3Y2OrqCg7UbAtbaaWuYfZUx8ifUJ9kRKeGuhUt2UFcBw2DJECunOwC4gHAZlxnNy0t6yyLhzgQwHrAA9qBbCjCFhyDQBgegX9e+7qCqJl0MABPunrwLfeB76/HSiqR8pWpD7+5HtbjU+AdYABzCb7YZejdEO4b/RvRsNAKI5/vNuE9S0TUFeAZCZyssSDufc9jAkzRbBSMkE8JR/CsxEIBAIFIYAFAsGxBSG8AA51G+525xt78IP/bsYl961CY9+R6b4cTsgyQVM//RynlRcMszdQ6OQd4hPqiwBfKwDFQSKSGZ2kVH28m3GBEejUuL8SUKZpvyIc4ENCgZ06wHFowuBPvlbN651bS8Xxmzt7EEvywimQDaevOh4oUP6WbTH6ndnb0qZ/8cigTuCeZOIF8XgE8I+f2Yr/e3knvvSPNejwRUd+wnDEg0CSEf1HqAMc0VR+FnnAAoHgcEAIYIFAcGyRCAGEGUyHeg13W92kCCiZ0GXBgdPpj3IiZmr58A6wtgj0groiLv8XhXWQJSqmekgJfSzYxVf3dhbpBa9wgA8JZpOkiuAOovkbLP2Guji/tkhd3tWtdz+DMb2Q6k851eVChHWPGxWSWmrayW8YhwB+Y4cSTRJPyfjr2/tG2HsEgpqJufiRKYBZBxhQwqAFAoHgUCMEsEAgOLaIBfj1UC8g6wdl7AC7PzhMT1HBqGDDn6u8Ds4JNKJtiM/5nFzq4gSwVDKVC6fVOcBRRgC7SvWCVzjAh4xsJejX5cVIZl3gj/0GcNK/4bxa4wrRWYIxfQ/vgbRLXS6UwoglNb9rTfgzADSYNEIz3D/s646WnV2BkXcaDm1xviPVAdYI3okohPXEulZ89z8bsaNznJ/xMcbynT04+TfL8Y1HPkQyLULRBcc2QgALBIJjCzb8GQBI2rAXMDvA7gsdRq1RJhhCCN7d04dXt3UjlcdBERtGPq1iePcXAD57Yp26PLnUBUmSuAJYKJ7CFVTqhtYBZlx7Z4m+6rNwgA8ZWQG8n1TjtoZ/Ad98DzjlOm6fIpcNk0pcRk8HAAQMHOCepENdLpTCCGhF8mhaCYWNI0JGIi3zxZ0a+wwc6LGgc4CPzBzgiM4BHp8AbuoL4cfPbMXzmzrxs+e3jetYxxp3vrEH3YEYXt/Rg+c3dY78BIHgKEYIYIFAcGyhFcCAYR7wseIAr9jTh8uXrcW3HluPJz9sz9vrcAJ4hPxfAPj0ghp8fF4VFtQX4f6vLlI2siHQxVPg5RxgRgAHNAJYOMCHFaxzL3trgOr5hvsdX2fQJimDVtym0jI6Y4wARhiBqEZsGTjAOg7QAdY6m/5okquAPGa0DnCeBTAhBNs6/PpJg3GizQEOxccXAr29M4BsIel9ojbDqEnLBHt76Of14hYhgAXHNkIACwSCY4u4QdicphVSIiVz1Ur7Q/F8n9Uh453dNOdxzf785To39lJHrGGECtAA4LCacd9XFuH5607D7KpMOOwg6wBPVZ1EQBsC3aEXwC5aMAtmO2AbWYQL8oOX+buxYljL/NrcAlibA9wyGMGgTHOAvUYOsKYFkiHxgFJtfIwYFXfa3mkw2TZatA5wnkOg/7J8Lz519/s48463J0wEE0J0OcDjLYLFFhcLRJOirdIoaR+KIMFE+Ly/tx9D4aN3YlcgGAkhgAUCwbGFkQOsaYWkzS88mgVwJzOgDBmElU4UXAXoigMQn4RkqkBnKJ7MOcD6IlisAC4GCuvpemEdIGmqbAkOGjVFTsNlLcM6wFH+N7q3JwQ/oRMrigPM7BMLKBMjoyEydhfYKLd1U5tvzMdR0TnA+RXAr2xVBLcvksT7eycmDzqekqGJDB+/AB6i1yuZTExO8bGAtpNBSiZ4dbtxBwSB4FhACGCBQHBsYRgCzQtg7aCqP3T0zpR3+anbFczTYDIYS6InQCcRRhMCrUPbFsZbC6+T6SlrYhzeVAwYaKTrrlKgbjEw92Jl+eybx/76ggnj6tOnYvHkYnxkdgUuXlibc795Y3CA9/UGMcD0Fa6WBngBzLq/VjfiFk/uEzyAStBGQmxL+zgcYM01Kd8OcCRJz39wgpxBI7E7kQ4wYJwLLtDTZJCTLsKgBccyw5fhFAgEgqONmE+/LaR1gPlBVSieQjSRhtNmzuOJHRq6/Pl3gNnBl8tmRpXXAWx4BBjYB5xyPVBQMfJB2L+RZAZcZfA6qFNl85YBCTuQzgjtjg10f3eF4vhe+pDiJAv395DSUF6Ap7596oj7eR1WTC1zY3+/fvCujdLY2xvCXkLFdKEUQWqoDUBmG1sAq3wWgv4Q7KkcebUHkAds9NvZ3O4b83FUjKpAyzJgyo9vEU3Q8NiJCo01ankUHmcbJNYBBpRIgNphoggECka97D9oHEBfMI5yj/0QnJFAcGgRDrBAIDi20LZBAkYUwMDRGQYdT6U5dztf4YTs4Kuh3A1T8zvA/74DrPwLsPxXozsIKwg8VYDJxFWBri50KduzsG5x7SK6LMTvEcXxOVxg7W90b08IARSgnekt7BhgqgSzDnD5LPhslblfNEdv8OEwcjZbBiIHJiYJ0ecAA3l1geNMy6jBSB4F8DiuMYQQvQMcndiiXUcrbA2GLDIBXt3WZbC3QHD0IwSwQCA4tjiAHGAA6DsKBXC3ny/2Y/S+R8Pu7uCwA1tOAJcVALtfpQ92bhzdi7CCICN0G5hQ6jnVHsBrEE7rLAHKZ43uNQSHHYun0OJmk0tpWyS2UFNaJup3bIc8Wd3uGWKqPnP541MxaBkm6uAAQqBzpQ/85uWdWLtf32aNEIKt7X60DUb0T4r5lDB+LXkUwLEUI4AnKgTaoOXReARwIJrSTdKJEOjRwV6DZ1fR8P9NbeMI0x8DoXgKly9bi0/e9R729ByZLb0ERxdCAAsEgmOLUeQAGzrAwcNfAPujSTy3sYMrbDUcWjclFE+Nuarq3cv34mN/fhdn3PF2TgHNhkBPKy8AWlbSBwOjzEPjHOBqAMDH51Xhm2c24JIT63DtOdMBb7X+eZNOFq7vEcxli+vxmRNqcMaMMtz88TnqdvY32jYYUau27yBUAJcEcwjgoknok4bpA30AAjiXsPvv+nZcdv8HeOD9/dz2Jz9sw4X3vI8zf/82dnZpolKM3F8gb4WwUmkZyTT93U+UANa2QAJyh0C3D0WwrcM/7PWn3aefLBAO8Mj4IgkMMH/TCxfUqMv7eg+OGH12Qzve3dOH7Z0B/PH1UfTjFgjyjMgBFggEhy0PrdyPl7d24+ozpuJjc6tGfsJoGEUbJKNQ4MO9EJYsE3ztwbXY0OqD22bGE988ZdgiQgDQ5eNdpmSaIJ6S4bCOPtf52U1KZd3BcAIr9/Xjgnl6Ebq3lw7cZxUToIcJTY0OAqk4YBkhD83AAbaaTbj5E3OY7TkEsOCIxWE1489fWAhAEUlZIok0UmkZFrOJ+35tl6eoy5WRvfRAGgHcY+J7Xg8QD0qljBgIdgNPfAXo2gx86k/A9PNGPE82B9hlMyOekpFmSiC/v2ELri5cD8w4H3B48eIWZUKHEOCVrV2YU00LeOnyf7Mk8iNWYkzLNwAYmqAQ6NE6wHt6grjgz+9CJsAdl8zHZUvqdfsA+vxfQJn0mwhkmcBkOjonyhqZCUiP3YJTptGCgft6QyCEQMrzJCH7G127f/CgvKZAMBzCARYcHoR6D6jwiCGEAGv/AbzxcyCcv76mgvzy5o4e/OKFHVjbPIifPrt14vo9GjnAiRDnrhiGQB/mDvCbO3uwodUHQHFZrn543YhOMFsAK8tY84AHmIkBX0T/uQViSS78bj7ZDRB+wJ3T8eL20eQAG+Gt0W+bNHKxJcGRAVv1G6AuMPv9YkOgy1LdQNQHJKNAmMnrLZqETsJUDQewWZ5GV7Y9Bex8QRHNr46uYniIEXufWViLt35wFq47RzmmDUn8ZvD7wNNXA09eDoAXcy2aMOide3L0K47nRwBHNa7sUHhiRGU0kYYFKfza8gCWWe/AVKnL8PqyfGev2i7plWFyUrURKwDG3bOYEIKfPrsVs299Fb99eee4jnW4wqWgVBRgOtOGLpxIc50A8gUb6j8USXKiXCA4FAgBLDj0NK8E/jgbuHMO0LF+/Mfb+QLw8g+BlX8GVvx2/McbI4980Ixz/7AC/3i36aC/9tFCLJnG9Y/TKr79oQQSaXmYZ4zl4DlynhgX+EgrgkUIwb1v7+O29QTiuOqhdYglc1dd7dQNfAhC0RHcn92vAituB4I9SKZlzoHxGbgxW9r8yM5dFDqtqB7aoNtndAKYdYANnF6j7RYnUL1g5GMLjggKbBYumj37O2ULTfntVfATmiuMnm2Ar42umyyApxrtMi+AN8nTjV+0P4cY1cA6wAV2CyaXunHVaVMBADOkdlQjMxnbtAJyOo12Rsw1D/AC+K11W4xfJE8h0NprxETmAJ9v+hBfsSzHueZN+I7l2RELYw0M89pGDnAgOr4c4Je2duFfa1qRSMu4/90mXV2EowE+BcUNr8OqVOLPsK83f7nlWVo1kzzrW/R58QLBwUQIYMGhZ8sTAEkD6QSw/dnxH489Rvva8R9vDMRTafzm5Z1o6g/j/17eid3dotjDgXDfikbEkrzg1boUB8xoBLBhCPThK4Df39ePzQY9R3d1B/H6jh6DZyh0MYNwM9L4t/X/MOm+BmDdA8ZPGGgEHv+CMrH06o91oZI6B3jzE5j00hfxMdM6AMAJ9UWQ2j7QHzc4ijzgA3GA6xYDFtvIxxYcEZhMEgpsNHMr6/6xLmBdsQs7mDBodG/lw5+9tYDZgvZkIfbLSiXoDlKKDWTGuM6NFXEFduUcS9w2FDqtKJd8zJ4EA4P9SDBhxy0DVKDIMoE7kSMHOU9FsLQCOJpMT8j1NhJPo0Giv9vpUodhCDTrCg8Mk2oy0Q5wKJ7CbS/u4La9v2+CItEOI1gHONuDnXWB9+ZZABNC0K6ZvFjXPJTX1xQIRkIIYMGhhw19NmpRMxbSKaDxLbo+1DK+442RYCzFCbfHVh/c159w5DTw4TJg1T1AwqBaaR7o9EVx3zuNuu3j7R+pwn7HLHQW/Eh1gAkhuOct6v6eObMc586mFW4Nq8xm6GRygE827cCp5h0wyQngpRuB/r36J3RtBpCxc9vW6EIl/ax7HAsAL3wXk3xr8Tvr32FBCkvqXMZRHiM5wNq2MAU5BLDWARb5v0cdHgcVwNnfKVsJuK7YyRXCUgQwcx0umgQACCUJrkr+CHckP48rEjehi5SM7gQIATo3Ab18uCwr4twZASxJEqaWuVEu8ZNTPb38pJQvkoQvM5kUjKdQKeUQB3kKgdZONgIT0wopnEihVKLX23LJbxgCzTvA8ZzpLoYCeBw5wH95cw96Avx1/b29Yy+AdrjDC2A3AF4A59sB7gvG1SJ1Wda3HL4CWJYJ1rcMTVgkhODwRAhgwaEnwgjg8c5wd6xXWkhkifmUHDAoM8UTlkeaA+2s+Utbu7iZ/iOO7c8CL34feP2nwIc5XMEJZuW+fsPPLDIRPWqTMSDNDHhKmbBHphVSyMBVOFyLYN3/bhPWMG1Wrj9nOmqKqLD3DTOQ7WRygKdJGhf25R8C2t8LOwAP9WAgxA9IOQfY3waklMeLpDAqMYTTXa1KpIeWXEV/smjbwow2BFoI4KMONg9YdYCjWgeYEcBdWzQFsJTHwok09pNq/DV9EfaROvSTYQrGpZlrz87/AX8/C/jryUDTO+pmVth57FSkN5S5UQ4fd7j+fn2f4ZZMGHTQ70ONlKN2Rb4EcEo/uXhA/Ys1RBJplEj0nMvgRzSuv7ayxbJiSdkwTBqAzkUEDrwIVttgBMtWNuu2v7+3H7I88eMEQkjexx9GJNMyWpkQeyMHON+VoLXhzwCwvz982NbV+Pn/tuOS+1bhgj+/OyG/A8HhiRDAgkMP6wAnxlkYYe/r+m2+Fty1fC8W/PJ1fPWBtXm9CUUNcqmW78wdgnrY07aGLo+2X+s4ydXXcUIcYG34c9lMujySA3wY3qyf39SB21+hrV5On16Gk6aWoNhpwemmrZghtWPIoDAVoAzY2fc5WdIMyptWANuf4bexA3A5hdAQ/xxOAGtaydSYBjA7sdX4jYzkALOPm6yAK4dbZ7EB0z6iLBdNFgWwjkJGcoBri5zYTqao66RvJzDA5MdnHGBtKG4ALiRJjurn7MTs9ufo8s7/qYtGDjAAQwfYP6gXwM0DYeC5a1H7txlYYKL1IzpRbnweE4hRuPNEuF+RRAoloA6wVUrDmtA7fyFNuySjMOhIImV4Tob3C1kGnr4G+PPxfM9xhjX7B9Uq3ZVeO7IFoAfCCezQtqUaJ4FYEhf/dRVO/93b2NjKv39CCNY1D3Jh8I+ubsHXH/kQG1rH75IOhBJIMYK+vkTJj5+hCYHO57iobcg4CulwdIEJIXhuo9LZoDcYx4tbRtmmT3DEIQSw4NDDOsDjLfKx7w3dJjLUjL+/2wRClPyeXXnMyzWauX58XZvBnkcIrPDIk/ugJZfTGzFoqTFm2BZIJitQPIWuMy6kkQAOxlPDFpQ62Gzr8OP//ZcWy5lc6sJfvnACAOD0vifwmO23eM12E1w+4yI+XZpwwkmSwUTN6z9TBpNZNAPw+GAHt84VwdJUdV9YGIajn8m3c9Mwba4X8FAL8PCFSrXc7ISYtgfwcO0zPv8Y8IV/A1e/AdhcufcTHJF4HNQBzlZrD3I5wE7sIzWIE2U/SU4B+5bTAxRNgiwT3bWawIRBeIxflL32DTXT5UHa2zfMiLgCRqRPLdcL4JBPXwAo0LYd2PQvSOCFyJb0FOY8Dk4OMDAxrZAi8TRtLZWhKD2EpKagofaa3x/WTzZ2DkVwvmkdLjG9Cyvo/oYh0E1vAVv/qzj/j3/e8NzYllpLppRgQX2Ruj7RecCPftCCTW0+dPiiuHwZX5fkwZXNuPRvH+DcP76Dfb1BNPWF8LPnt+GNHT245dltOY44etjUnQK7RW1xxzrAvkhy2OJj46Vt0LgbwYfNh18hrJ5AnKsB8sq2URRoFByRCAEsOLSkk7wrN54+h8GeTI4iT6x3Pzc7n8+QFiOR9t7ePsPcpSOCEONUGAng3l3jz9vWvmQOoRuJT7AD7PACJVPpOpPzmqsV0OESsiXLBLc8t02tjF3ssuLBK5egtEDppTt16H0AgEkimO43KDoFfQXoyUYCONCu/Mui+Q6kAnzoMjcY1TjAJ3jDfC7mlNPoMjvR8vL/A/a/C+x4nhbjMugBnBObC5j9ScBTOfx+giMSLyMusxWA2UrA5R47TGYb1sqz6JNSzPW3aJIuUifLEMkhgNmJn6H9hstBrgo0dZIVB9jHHS4a1Ic4h/v4ehHdpBh3JC/DblJnfB4TiNHnMREOcDiRQonE3x8qpCHdtVx7vR00cICj217C321/wh9tf8MV5tfU7YZFsDo38esp/XWbFWX1JS6cMYM67ROdB/zmztzRRdnH0jLBa9t7sKMroGae7OkJjjscmxW2pQU2ZtmOEjddz2ceMFuHgv39rjsMBfCeHv4et7ppAAOHaf0PwfgQAlhwaIloBgLjmeHe96bh5mgvX1ApV4jtRGA0k04IsCnTn/WIIzSMA7zqbuCvS4E/zwMiB3Aj2/kC8MRXeHcGuYVueCIcYDY/3FEIlM+m63271ZzXXJVFD5dCWE9taMemNp+6/pcvLERDOZ3Rd6XoY664PtwSANcjWIKMSdoQ6CzspEFcM9kR1BbzYQauGgE83eHni9LVM/m5WYHra+XTGJpWZB4fRQVowTGBkQPM/l69Tiu8Tgvek483PkDRpJzXkjIpR4X47H0p6gOiTNimr1UpFAhtFWh6jlNK3SgDf9xkWB/6GfXR398meRpOjt+Lv6Y/gzBhCvXlKQonblAEa0JygON8CDQAlMOvm+TU/j0GDBxgd9NL6vL5NppKEYqn9CJRe40Y1LckZMNy64qdOHNGmbq+bv/Q2Kpgx/xKhfwc1BQ6uXWudRyTNtI6EOHyZVMyMXTDxwIr3krdfEX86eV8GHS+YN/ThQtopf7N7X7s7Tm8OmVoBbBMgDeG6aQgOHIRAlhwaNEK4PHkADe/T5eZ6r5EUwk6OI62CSORq3iHb6TeqocjhPACRyt+tj2t/B/zA3v1oefDEgsAz3xTEcHPfpMrMpNrcDohbZAYMUcchXwOcCIIBDohy4RzJOwWepnUFsJKywSrGvsPau/IYOsWzHnxYvzT+nt4EMEnj6/GmTPLuX3scTrALkwZh/OxIdAV8MEhMb8LO1MQiBPA/ODAHKbfDy/C+JH8T6Rf+hGQCCMR4AcNtak2IMpMlExaSpcTQeXYGx4B2BDQtjVKlMhoegALjgm0OcCxZJormud1WOF1WPGePF//5EwP4FyTbGVSjmiW7LWPdX8BQE4B/nak0jLnoroZB9htt6DSpBHWmcKMLKkQnTAaZJzoMBjxNIECmBCiTtgaOsATEAJNYgHYJP7YFZJPF/Ic1vw9jAoOFg1sUpenm+iEGCEGbevSmnt8327d8diewvXFLiyoL1KLlyXSMjfBOCyBLuDO44C7TwTWP2y4C/t9AHiRxU4atg5GdOHCPf7xCmDWAbZzj02vpAK4MY8CmC1edv7cKsyuot/vhz9oztvrHghGTrgIgz46EQJYcGjR5AmOK8SLHVzXLVEXLYFWbjej/M6JIpcAPtBKlYeUeIAPHdQOvtjQ54ixyMpJ/14gmZnsCPdxbqFRn0hgoopg0XNe25XG5x7aAZltqdO3C5Fkmit+PKXUTU9b4wD/4fXd+NI/1uCcP6xAbzD/InhXaw/My87H8diL88wbcbFtDX7yyTn8TrIMCyOAi9ODhgVO2BDoKSYmRM9cBBTW0h3Zv7MmQsMepa7VV8xv4grLGzCvux/48EEM9PD5wa7eDXTFbAcqjwckZmDob88IYIZESElrGEsItOCohq0CHYwndddzr9MCj9OKXaQefdrKzpkewLkm2f6UvMT4RbP3JTb/N8tQs+7a5GEcYCQiKABfBMgl6+9ztoRPXR6EV10OEkYAT1AIdCIl4+K/rsIJv3odT69vN4xcOtAQ6A+bB3H5srX453tNsMb1Tne55NOFPGvXdUWwwv0oidFaGiXpPrhB7026POCU5lrcz9dBSKZldPn5EGir2YTJZbRmwKhzoPe8Qv8uW5403EX7/nYzdUjYIoWKAOa/K92B8d1XWAe5rCC3A7xbUxslHE/hruV78c/3mpBKH3gni0SK/6wnlbhw5alT1PVnNnQcVuMjrQMMAKsa+w+rcxRMDEIACw4tWuGUCPFFd8YC6x5XzlUX3ZEOSKDHzKcAzuVSHpEXT014K+JBvi0OOxjTOvkjoXVSmFDrXJMIE9IGiXEzB1IOfNgyhF7HFPp4325dhMAUZlCkzQF+LTMzHE2m8c7u/PaPfGZDO1b943twMQO/i+sjqC3iw+sQ80Ei9DOswKDeIQE41/pEj09d7rVUK+Hh6vFyO8DuBP39zjAxucLdWxAb4mfNpSQzsCuqB8wWoIDJ0133AFeJW6X5feEAC1Q8mhxgNvzZbJLgtJrhdVhAYNKHQasVoI2vMY+lz8Mb6RPxRvpE7JGZSaDsxM/gfv2ThvbrBA7n+IX1qQWFUlh9Lw6rMgwrAf1t8Q4wGwI9MQL4vb192NTmQywpY9nK/cZ9gA9QAP/8f9vx7p4+/PqlnfD169ubVUg+7vNPpmVd2ztdCHT7Ot1x5trp9VZ3f01qqg5rHOAuXwzZqGlJgto2zm2j361cdSB0cBPBxvdBNkcdoGIzlkxz7nunP4qmPv5vPF4BzDnAbt4Bnl1Nv2db2n2c0H10dQvufGMPfv3STvxv84FXQu70RXWf9UUn1KLIpUwSRRJp/PfDw6NQKCEEe3vo55+ttZhME7y9K0eKkOCIRQhgwaElbHDD0N68RgsrgCuoK2YhCZQzOVi58jsnglzFVfw5WtGMBl8kgX+tacH2zhz5afkipAn7kVP8zHp8PAK4mV9ne/AyAw+nlQ4kR+sA+6NJ3LV8L/6ztlXvfDJiLkAUYdtpZXqG9u3iJkjsFhOqmfwt1gEmhHCDE+3M/URCCMFLLz2LK02vcNsXVFr1O2uiKiolH3wGIYWsKJ5tp8/pkqoAO3WghhPA3jSNuigG/T6kh1phiQ3zncj0YuXc3A1M+KCJDkTRslI4wAIVbQ4w+3v1OiyQJEl1id9Na8Kg1R7A9DkmpqD4AArx9eQPcT35EdoIU6U8+73XTtwBigPM/JYcVhMsZmZoFdIPnL0ZR7i+2IXJJUqECVssaihXCPQEOcBs/v9QOGF43xoKj/2eRQjhQki1BbAAxQFWP/9kFMk1y/AR03puH534buMrJwPAXBu9Juju6UlN0cl+XgCz+b+VHgfsFuU+w06uhEY7Uc5eE6PGtTC0k6q7My6jVrgToi9O2O3XvJcxwuUAaxzghfXFsGR+AOFEmuuQsaOT/u22tB/42IP9rKu9ymfttJnx+SX16vZHPmjJWeyryx/FIx80Y3//OFtkjgJtBeizmNSixr78hYgLDg1CAAsOLUahswd6k2cFsKcacNJeoWyLl0ORAzweB/jHT2/FT5/dhkv/9kHeqhCv2tePO9/Yw1er1jrAAL3ZyzINYQbGL4BZB5hxB8o9dMY6OsoiWPe+vQ93vrEHP35mK1bs0biyTB5zAMrAswlMlVWNAPY4LKjw0nPoYQRvMJ7i/t5tQ+MbqAxHtz+KG5P/gEniBwmmmEEfRU3xKbuURNCnH4Szjvok0MfbUJnbAdZUaS+R6d+9mGl3khhoQQmGGTQVZwSwlxZEQZoZ9J7xA7rcsoqvRC0c4GMabQ4wG/6aFb7ejEheKc/jn5xxgNlrTKXXwe1iNkn4yJwK3nnNfu+NHODB/ZoK0Bb+cYOohqwDXFfsxORSZSKuhJlAYtsxhfJQBKuXuY/kau82bA7wYBPw93OAhz7FTWJHEmnEGTe3RNKfbzl8dMLg/T/B9foP8IDtjzjVRFv+6HKADQTwDCYPWOuw6gXwPi6yjJ2srC+hEwxs/+ZcqTg6tJFQBukm2qiz3d1BEEL4vuk56B5vDnA4dw6w02bGvFp6rWfbErET0X3jKP7I5jTXldBoqq+ePFl1WFsHI2gxmECWZYKvPbgOP3t+Oz5//wcT0oZwX28QNz65CY+ubtE9xoY/V3jsmMScb66xneDIRQhgwUFF58gZCacDDfNiBbDNTQfZAOolKgryGwJNj21hrIUDFcCyTLBijyJOIok01uwfo9AcBb3BGK58cB3uWr4XP3qKaSOldYABOgDTTlKMsQp0vJ+vypkOGDvArAAerQPM3sTX7tecl4EDvD3FiLC+XQgyBcs8DiuqmAFyd4AOBHo1oWmteXSAW3eswVyT/oZt+LkbTCpFNf16Af6GXpWmg8n9cgUvgNniZ5oBeDl8yBatKmZCOO2RbrilYQZN2f7LRm5u+WzgtO9SFzgRAggTIikc4GMaL+MAB2JJzv3LimOvU/m/D0XodMygTy6dBoB3gKsLeQE8udSFJVNKNMIzhP5QHIGuffoT0jjAbp0Azu0A1xW7MKVMmYhjJ5CGiJKbWe6xcw4w0aahHCC9zHXsuMRWfGL/b7BU2sntMxROGNYOAACs/hvQuQFofg/Y9Ji6WevclkLvAFdIPnotb3xL3X6BiYY5c21n0imQTqZ+QIapEr2maR3gUEgjvFNRwE9rgbBFmeqKqchh/3a6dnxv/gL442xg9X38dvaaKKcMJym0nSf80SR6AvFR5Rn3TGAIdJmmCjQALJlSrC6va6YTqqwDPp42QKwDzArKumIXil30fIzGSLu6g6or3RuMY2fX+Fsu/vqlnXhmQwdufW4b1rfwE8isAJ5Z6YHTRiPQRhTAiQjwr0uBv50OdG0Z93kK8o8QwIKDQlomuObhD7H0N8vxJltSXlsECxiHA8w8z+qig2wcRAHMzFBWMQOrAxXA3YEYl5/V2GsQBpQc3w1yV1dQ7Se7dv8g0tlQpKCRAM7cgLR/I6O/4zCk+nknJe6jOUZsL+UKRgAb9Vg2otNHP4+WAc3nxQjgIJSb8cZoBfd40k/FoMdh4QRwDxOepp2ZH5MA3v8u8OGyUU/22LYbF1fhWrJkMfhbJIfaddvYz7M4QQeTjalyjQPsU/4nRDe4s0spFEL5jIsk+l5MGCGP3ygEOsviq5QJrJoT9Y9Z3fy5CY45uD7AsZQmBJp3gAHgmdKvA+4KYPJpwOxPAeCjH4pcNriZge6sSg9ObihFCHSwHvAP4YbH1sAdM7gmanKA9Q5w7hzgumIn6jOigHVLB4iSgvDdj8wAsVM3WCJpNQ0lLRNs7/QjeQAFirIF+9yI4h/WP+KkoRdxr+0vsIC+j5RMDGsHAOD7efvptWNAI4CNHOACKYZ4OHMfGaATCieaaB/2wXCChsT2bOPrB2SoTzMCWHN/bes1mChm+ryzoqy+mE4wsH87LgS6Yz3w/p+Udmxv/EwRO1m0gtcgDNoo6mx3T3B0DvA4BDAhhEvb0TrAALB4Co2UW9dMCyayf3ujqtyjhXPbmckGYJjPO8P7+/hopolo1bSCqdWxbCU/DmHD92dUFsBlpec3YgTatqeUFn7dW4FVd436fNa3DGFbhx9tgxFdLrwgvwgBLDgovLu3D2/u7EFvMI6736I3IkMH+EAFMHuTtBXQQTaASSY6CDlYIdBs778DFcBNfbyA28fmoRACPHkF8Nta4J07Duj42nNLpgnNDzMqSJS92WuF21hCoFMJOKP8QDLNiM5wjhDoXIVrWBIpGT1MNebmfs3AycAB3hOwgbipCDYP0IqhBXYLKpmJjL5QXJ0g0A5M+oLx0bVq6tgAPHIR8OL3geW/HHn/dAoN3a+qq7tKP0ofM3SA9X8L9vPNknVhvAjDkaSfy65EmXEIdCquOBwaKiQfrEjBK40hBDwbnaENZ7Y4gfmfV5annK5/3snfopVJBMckbA5wIiVzaSGqAGYqRa81LwR+uAf42suAVfkts9EkLpsZRYwTNaPSg9lVHjgL6G9gS1M7ulr2wCwZOKIxPxJB+pvTO8D666gXVAArk3yEi6AYyoRA15e48MXTj+Oe2zeoTHB99z8b8cm73sdn/7oqZ/5kLrIh0OeaNsIrKdfIMinAFeIChukFzE6yMdfUQU3xqtIcbaWkUI9y7WIm8GZLrXBCuaamZEJdXSb8OXvNBoCqVLs60aYVwEM+g/QLphAWK8rYsNyCXCHQ65bR5XQC6KHh2joBrLkmx1N8WHiW3d0Bvm96DsbTYi+sCUnX5gADwOLJ1AHuDcbVkOVQnH6m2u4HY4E9/+oiPtqCc9zj+jHSe3v5yVyjFkXjoUfz2WodYNdYHGA2PcI3+qJeVz64Fp+6+32cccfbukrcgvwiBLDgoNDMFDBgw48MncMDCYFOJfgcQl0INCuAD04V6MoJcICb+vnPgrsB9O0GdjyniJL37jzg6tnac2vOuqaGDnA2BNpg1nu0r+9v0zuEmUFiIiWrbjQAlBewOcAji8ueQIyLEGwdjPBhfDE2B1gZ+EQSaaRLaT9g+xCdoNE6wGmZzqgbhaa1D43CBX7xezSkd+3fR95//woUZopNJYgZ/nmX08eMiq4Y/KZMmnD2FFN5lc2PjxA7OlJeJK20PYY6wM2Rf1gpDaEIY/zNFuUQwPMuAZxFyvKCLwDmzICt5kTgiheBj/xsbK8jOOrIhjdnYQs6qSHQXKXopG7SJKxxbGuYgflx1V5IkoTpdTQ6IRL0YRJzDwnYq0Fs9DeyZesmeg6jcIAdUhJ2JDCn2otyjx0eRGFl+uVmq0B7HRZ85fTZSDNDtadX7YY/ksSLW5RJra0d/jEX6MkK4FNM27ntBZpJLK2jqxIxFsDa9kUlBiHQAGCK9AEDjdw2iyRjgYmmxqxrHsLvX9uFgd3vq9teTJ8MGcrf0kKSqMtEdrEhxkPhBGIRg8+DKYTFh0Ab5wCHshOu0SHa8z5L50a6rJ2w11yTc403dneHuBZIuQjFU8NWpCaEoG0wYhgJwIYuSxK4kOMspQV2TCunrf7WZVKIWEfWF0keUKQBAG5CukqTb+8x+rwzxJJpXQrTXoMWReOBPTdtBegZFQVcCHSuAqcq7O98lIaALBPub6u9thmSiExIGoRACGDBQYIdpAxGErTc/kQVwUpqQl1tbk0INDN4yZcDTAhkRryzuWXBWIqGFo8BrQPc1Beis/1sRdJUNGcFypHQC+CMiBuLA0xkGio7ArHeJt02c6ZViFbk8jnAI09ccEW8oAweuEEc5wDTm37QM01dLgjQsLwCuxVuu4W7UWdntI1m5kcVBt21eeR9GBIbHleXV8gnoG4609olFePD8QDD35Q1wv8tI8k0rEjhc+Z38E3Li+r2VlIBQELMTMMu46EhJd85bjyYrcAQl784InYv4My4DloBvPgqulw+C7hhE/CNd4CvvwVMPWP0ryE4anFazVx9BTacVS2C5eTzhLVEOAfYgu+cOwN1xU6cf1wlzpujRIPMnUrbILkR4yaKeq01CDjo470tu+i+o3CAAeD2T05GfYkLFR47Vy05TSS1QJ/HYYXbYUXKTF3KnS0d2KbpCNATGL1Dl5ZJRhgRnGPmr0Vu8Ne0sTvAI4dAA4A10suFP2c5UaLRN19/5EPc+3Yj9jfSbRvJdPSaaLTONElJnWEd4Hf29MEOg/PuU44TS6a5ImBsWG4B075KdSQ3/0e5v7J0bqLLOgeYT0vJKYB7AvBFR3aAgeFd4Bv+swln3PE2vvLPNbp+vWzoconLBrPJOHpmiUEY9Ii9mUcBIYT7bmoLzhVwVbeTymf5ny8DD30KW7du1jnnow2BJoTgpS1deHFL57DREey59Qb5CtAzKsboALOTzKMci4USKU7Lsqkbhmx7BrijAbjvVH2hN8GYEQJYcFBghQkhmRulLBuHcB6AAO4f1BzH5gYKaZn9CvjUXsDaghQTQioB/P0s3Nt2Mb5kXg5AP9upDdMaDU2a0v/xlEw/S18rv3NQH+Y6GnQCOPuaw1WBNvobjbIQVsf+nbpt9lgfQIhaeOR001Z8xfwGqhz03EZThbHDoBIzlwdskAMMAL3OqepyYZgK9KyjxLr52dBno9ysEVshaatfA0B6mO9FIgLznpfU1VfNZ6GmSiMatTdbAwfYEeNdqGg8iXutf8EfrPfjQvNqdXtrpvVLxEQnB7p6enHSb5bjmw+sMDzFCsnHtUDSYdLc1IsmU0eufBZQkQnxnPExoFaT91tYC9ScIMKeBSqSJHETY3sY18YoB1hXIRjQFK0y48yZ5Xj/pnPx98sXqy2MvIU0NLRAimIyI4DbSYXSLzsD6w6zg3oAhg4wAFw8W/mNlXvsXOixDwWQM0OzrCNkclC3ua+/X3Xp1G2h0YfJDoTikAkwR2pFtcQfR+sAG/YCTsb46z8z8akrgsUI+5SJ/s3ssRwCmMkDzuIm9LX8xI0eG72vT88UwmInOd7a1QunUQG+/t0AIdxYxGySuInqAjv93oTjaWWw8uEy6OjaRJe1k8E6B9j4+t7YG4ZvlK2mchXCGgwn8EKmR++a/YN4QtNPl3WASwwKYGXR5gHHUzKSaV44HkgYtD+a5PJaK5mOCoDWcU8BGx8Ddr0INL8H0+p7dcdrH4qOqhbIY6tbcN2/N+D6f2/Ef9fTz0RrQiRSshohxpoNZQV2FLqsYxTAzHgpOjSqiDjt5Iju2qFlzf3KZEzvDmD3K8PvKxgRIYAFB4UOH38B7wvFlRsnMbiojDEE+s9v7sHn71lON5htgNkKuErVTRZJhidTeTORkhFPTXBJ+/3vAF2bYUEa11qeB6AMbNgJ1wMJg24yCG1Tw6B1AtggZHkUaHsUtwyEldnFuEEeVdYFNAqHHWXYz1DHHt02M0kC0SFE4inMllrxmO23+LX1QczeTW+Co2lL0enTC2A1Dzge4iIFBphem+0m2gqpOEYLRnkcFiDYg79Hf4hXbDdhitSlDkaMBiWtgyPMyu59Q78txwAZANC7A+aM+xAhdvRVnw3J6lCKQWXRTjwY/B3cCb6YiO3d3+J883rdfm/LJyinJNEBtzdTsMc3ZFBwC0oIdK19mB6NTE9uAFxqAkxmxd29+g3gskeE0BWMitoiGrbK5gBnJ6wKmVDCrDhKpmXc+fpu/PblnZwD6LLlGHTa6PWhAFFMZkTuvlS50i4sA+sOF9gtQPc24N6lwD/P46oPc2Qm4+wWM+rsTIQUoT24s0Le4qDb7HIU//2QL2rXOwYHOPvezzFt1D3mRgxWM/0NGlYp1kaYMJOK2mJJnLAvoFE2zni/oQBeaNqHbFX5LNkcZUBpXedz0clK6gAr94ZUWsY7e/rgNHKAo0NAZJCbpKwudHA9m92MAxyOp4DW1UC//n6Fvl008kabDhTRCmDjAmnRZHrY3rbsBHpXDgd4uyYS4E9v7OWcW74FUm4BvIjJA27sCxuK3QMRwD0++v5sFhMKnfxkaIE2BLqPRlLIRi3HkKMQKEMqLeO+FTS8/uWtdFxk1EYp2+KpmZkon1qmTI6z14YRi2Cx9/FRRsSxpojLZobVPIIkY397OSJLBKNHCGDBQUErTPqC8dyCaYwO8MOrmuECc3G2ZcSBowhp0BtaKROONeF5wIz7Wif1owhBuO1mLhRvrAI4lkzrQnoBpiE7W4lTcw5jwTAEOpeYVkOgjQTw6CpB57qxIdSDUDyFRSY64CjsXqMujyYH2OjzUh1g5vNJERMGQIvctCWo4HOl/MgOwjwOC7D2fjQk92COqQ1XmF8fXwj0vjf124zaTWVhPqv9pAozasozJ0ln7EfjABelmG3bnkHxelqlcjNmAGf+CD+0/AT/SZ8DAAgyrVeUli0EBZLxeyuXfJheMMx3u+YEzclM5tetTqD+JLVAkUAwErVM3iaLtg8woEx4xpJpLHt/P+56ax/uf7cJ7zD9wVnRw2Gn1wS3FEMdI4C3R0uwJ1GmrrMOsNcK4OmrlcF8O23tA4CG/gNA1Eef72AEcKYAls1sgsOqnJvk4MW49jo3lv7w2QrQ55g36R4rQJTrXjBo5FBqry85imA5EIeLcWKDXlpnwZ0cAAb5HGBAuUdPkfjrYbZlFKAUwYp4qZCeZVImArKTHBvbfPBHk3Agx+fhb+P6tQ9blTieUqo/Z5l0Cp14JLJS7ZcQpTUVi+Z6rIgcgsvMb+NHzudRbqPntiNHWx+b2YQF9fT+lMsB3t7JP78/FMff36URTAMjVIDOom0FZhRJNeZK0Gvux/QH5uAe610ACCq9dkiaCU62p3conuSKR1kTdMK1yEV/z3t7h0+3eX1HDzqZe/P6liHV+TUSwK2ZlC+2Ts2UUuXvPGoHWE4DYX6SOWdEXDKqhi+z41DPSO4vwP3Wxtp5Q6BHCGBB3okl07obdF8wnvsHPAYB7I8mMRRJwi0xN4hscRKTCSETHTiwBTkmXABrLn5zTc1wWi3cjOdYBXDLQMSw1sGEOsCJMOQQ/3doHYggHRhBABuGQI/sAKdlgoKIvictACDYjUgijQLQm68twlSHTqRy96XMYCSA1ZzmAG211IsiNcwQAJqjdEBtRVI9B4/Dqgx0MtRJ/egOxJBKy4Yz4kYh0Gv3D+Kzf12J3724CWT/u/qTNgo1z8KETLeQSsytyThB7ECavdESYvh3KJR9QDqlVHJ+6Qfq9r1yLb5v/Tlw7k+xxX0ySOYz8cvUYbZIMmYWS/ja4jLtYQEoIdCTXcOEYFYeD0jMraZ4cu59BYJRUFOUQwCrfYB5p6kvGMdzmzqNnpLbAWbaD5VY4pjhpAPv/ckSbPDT30ilRAfrS3qf4JwsFZMFKKbuJTuYrWEiKIayBbDYgjg2Xoxr6R1JAAd7kHj9lyBb/oueQBxFCOJESR9uXCBFUeGhYsioMq/uvp0IKdcW8CHQ2orSseJZ6rI3NcAVwYoT+l4XMedlRhoeJiw7ADcSpbPV9YWmfTjPtF69t76fqRrskHLcawMdnLir00yk6EJyB5jPqPoEoIrWXyCdG/HgOzsgEU2oq4EDfIZpK+6w/gOXx/6Fmx3P8K+RwWGl18i6Yif3Hc+VA6wVwADwj3eb1PFW/wg9gOlrm7nXN7qPjtkBfvf3MKej+JR5NeZKzaj06Cc43cxvLxRLAX4qgLPfn0qvHWfNLFe3j5QH/KCmtVEonlL7B8cMqnFnxwdsulm2N/eo+wCH+/le9YBxHvBQM/Dn+cBv64HGtzgHeMT8X4Ar4jmmzhsjkU4pIv4YQwhgQd4xunj3hxK5HcMxhEBnBYeLLd5howOTQdDQsRLOAZ7gQliaQcFcqRkum5kTwL4xCmCj8GdgOAE8Rgd4sAn4wyzc2/MlXGt+DlnXM5GW4evNUcY/VxEswLj9jkywal+/OoO9q8uPOlBxzQ58EOpFKJ6CmxnwmKMDsEH53GQCw3YSLMqNm+AkaSemS4o7YOQA95AS7nmNIRsAOjud/a4U2C1ALx3Mlkl+9ARi6Mvk0WlpG4roRPpvX9mJTa2DGPrgUcN+lqwDvK83iI/8cQUuunclBkJxpJlBYiupxHFZAZzLAY75AVn/PTNDViZp9ryq7h8lNlyT/IE60Gfby/hlfmB49mQHTq+nDkKK0FtHBXyotQ3jfHuqAC8tGMQWpxMIDoTaHAI4+x12WM2cuLn37X3qIFhLQS4HmBGdtnQElrhPXe8hxehIFanrFZLyWBUGcGLT34yPZ7LyE1dMiGSVmQ6+B4nyutyAmBHjbujFSW9Qc4/1tQI7X1SdprYnfwjbqjshPXMN4s1rscS027ClkxsxLlc0YtR6zui+nRHzbMgtW9grIrlBCmmaSUOykWtbuFymuf9sHnCB5r0GiAty7SKgdrG67bfWf8IUVe49WRHjZBzgIcJUtPe3c65ohSYnlXWAI4k0SB8T/lw2HahZqK527vwAf311E7TIGgEciCVxpfk1df2ziRcAKG2fbrMsU0PR59ZQx7euxHVAIdCAElr9+g7lnsKHQOd2gAFwY5V2Iwd4DFEGSCc5U6BB6uLqaGThi2ClOAc421d+TrUXMyvp95+t1KxlW4cf65r1qTprMtWko4k0Jkk9+KXlQVxseg8AHR+wDvDUsqwDzH4fhpmANwpHNhKoG/8FhHuVe/SjF3O569pJOx2pOJBm/gajjLgbFftXAL8qBX4/HfjXpRN33MMcIYAFeccoL3NMDvBAo1JkyoBs2xmueqWVhjX1pZlZfEYAGxVGGRc6B7gFTo0AHqsDzM5IsoOSxr6QMhMY1Vzoh3MSjdj6FJAIwooUfmR9Ej+3PKIWCvOPJIBH6QD/9uWd+NI/1+CcP6zAYDiBprZ2rl/sVtJAdw51I5JIoUBTibSCcVeGm4UlROlh/DXzq3jSfhtett2M00xbDR3gblIMu4Ve/joDCW5wmp19LjLHuBy+MvjR7Y9xkzo2Jm8nkkjrWoeU963GSvsNuN36T+MTZ/5ud7y6G419YWxu8+GJD9sQ76MCuB2VmF6RGcw5GQHMVh1lflNEMiNAqAhI+TuAzU+o66/KS9BCquDKCAB28OdPSoiBfueWVpu5sPcuE20RUykNocw0zKSVuxw46RvKcvkcoOHs3PsKBKMgdwg0/Q5/9kQquP6zLndfztE4wFr6UIheUqSue6Qo3Ijih9b/wprOXN9YsQsAILTFF8AJ4FLm95PtAcyFRDJi3GPQb5uLsIoMAn89BXjiy8DLP1ReuZWmknRufhMzpHbtIQAoDnAZkytqWHnf6L6deS+sA8ymHIUsRTB5ac50MZhq/OZivCdTZ3WuqVldztYfAACZSAjCiXKPC/jMfSBmRVCVS37cRJYhlZZVEcPmADeSGnqe/nau9ZC2LVCBpoI36Wcc4LKZXDqH1LWJm6zNEg/2YXObD9f9awOeXNeGYCyFMHjxV44h/NX6Z3zV8ib+Zv0zihHAZYvp9/Wjcyq4UHSjEOhwPKXmEJuR5lzSdRnBx4dA53aAAaDISR83DoEegwDWjAXqpV5DB5jtriBFB7hq214pCitSmF5eQO97UCaJc/HwqmbD7dnPI5ZM42eWR3CF5Q38yXYfpkkdaBmIQJYJWpjoLaMQ6GEn4A0FsIED3L6WW037aDTciCHQMc0EXngCHeBQHwCijGOZ1IyjHSGABXmn3UgAh4bLAWaKHKy4Hbj7ROCeRYZl37M5l2zVRzmTpxOIJdHHhHJOstML3MFwgJ1WXgCPtQo0W5Xw3Nm09cNQJAlflz5/aswOcIAPCfya5TV816KEZ0UGmTBliXFIhnWA9Rf8V7crM9GRRBrv7+tHoo+GJ4XhwC6ZVvREsAfheFrXiqMK9LhcIay2dcCO/6mhO4PhBGJJGeeblLwtm5TGv2y/RTwagi+S0AjgEiycVKSud/ljIEzRtKx7URbjw6myDjA7IJlS5uJuXmwecDyVxnfSj+iqrXKOaMYBjiXTeHcvnUhp6gvD5GtW16MFk2iRjFwOMDMrTFylnNMda98K7H1dXX82fbpyqIwAYGfj9/aGECB0ImlBucQJ4KiXTlw4pQRK4sYDagCKAD7tBuCHe4FvrwIswzsRAsFI1OUMgabX20sX1Y2qplruHGBjAdxHvEjBggF4+UgIyYezTJvojh/5GfCRn9P1uRcDjiK6zgw0i5n0HLUHMOsIsfnI0IshLgS6bQ2doNz9CkAIKplr6AypA9NNxuHgBYii1M20njNygLW5jgAQ8yOWTHMTlGzKUcBUCGvFLKSJ/g/SZanFTpmmRcyU2tU+8Wz+bwhOEJhQ5rEB5TMRP/sW9bFPmVYjONiN5v4wJMiwMyHQTTJTNT/QodwLMhRpBDAbAu1FSOlXnKVsphIGnaEy0Ypy6B1YOTSI7/5nI17a2oUfP7MFO7oCCBNe/H3FshwNJuW6b5eSmG1qw7mzK/HC9afjkatOwpeWTmYcYGLYcWBXdwCEAN+3PIXt9qvwC8uD6mNZF5SbkHCPwQH26SN6xpQDrBnbTZJ6dRWgAf7zdsX045ciBDGjsgAzGAHcOhgxzOUFgJX76P3vU/Pp331tprVTPJXGHBOd0D5OakHLQBid/ihXrXpKpggWGwINDFOHZLQOcNEkbrWind6PDUOgQ33A/neVMY62DeFEhkCz519QkXu/owwhgAV5x8gB7tcWwbIwNwi2qMTmTA9UX6tyIdDQlqm6yw4KwkS50HYMRbmKmpMdrACeaAeYF8ANUhdciI3TAaYic8mUYq4QRE+bPn9rzDnABhftL5nfAgA+B5gNWc1ehLWVLwHdBVmWCScUe/1RTG/+l7reZ6lBL6EuCQl1IxxP6Yot1Vt99CWyN6B9y4Fl5wNPfhV49/cAgM5MpfFTzDu453/H8mymsBe9wXaTEpw0lQreSCKNtJOuZ9t3FIf4nsVOKQESD6GRmZyo9DowqYSKRTYPuD8Yx3SJDja3OxcDX/g3cPK36UEzDvD7e/sRS9KbcPfAEBxRWlxHZv8OnAPMCGDmeyi5y9AD+vla1/1NDY+O2MqwUp4HgM5ys7Pxy3f2cgK4zMK3Pimono4QM6hz9m9DTtyZ3OGCCsAkbjmC8ZMzB5i53taXuHDaNOO8dZacDrDFrm/hBajXLBkm9KFI3T5J6kU5E/aL6R8FTvsucO4twImXK/87aJgrmwNcILMCWLln5XKAjUKgg7EUFQXsdTgyAPhaOUE4w9Sutg8CgE5mkkwbAm3oAOcIgdZGvrAh0IPEi/q6SXiGnK17artUjd2kDnJGHLukuFpVe2oBff1Apm1dWSaU13bqtYhk7vUmiaCxqRHBeAoOTQXoJsIIYH87V9m62MX/fW0WE2yZyKBpEiPIbB6goBIom6EWwjJD5go2ZjHFhtSoI5kobYVYJxsArjLzLWy8iKDQacXxdYU4c2Y5zCYJVYUOfMP8ArbYr8ENsb8hqenxu70zACtS+Jb5f3BISUxt+jfKoQjfDp9SKI3LAR7BAS5kPotxO8Ca8VC91KfrAQzwk66Fcf34pUQKYnpFASaVuNRIK5nAsHr2YDjBFb+6/tzp6gTYYDiBxr4QogkZhWAi66QgWgYjtFMElJzj7DXBZaUC2IIUosEcha0MxlIpI4dW4+JO7aPdS3QOcNQH/HUp8PCFwCs38QWwgIkNgWYntYQAFggmDsMQ6JAmBJqtDMv1GGR+9H59GFurmgPM5PyklQv9np4gnwPMhJkFJtwB5mfFTRJBgW83L4AjY3tN9iLfUF6A6eV0EBTobtI/IdQztkIGBoK5DH6YkYY5zJT0L5tBl7MXcCMHWHPT6w/FuV6CVfufwYIBeuPfW34eepkBpBzoRjiR1oVATzL76EskMsUaHvssLTqRmSTpyMxaczlfAL5hfgmD+zdB1oRAL6wv4sKXo1Z6LsWZEOjCoL5VR7nkw+Y2ek5Vwwjgob4OOCU6CPml7YfA7E8CBTSEOOsAv7lTcxMdbFYXE8QMVznzGxmFAyy5SuEzUwFgH6S5zHsqLlArpGcLkbDhfx2+qDrgBKD8DpmJqarycnRaaMiexOQmsQNqmKz8oF8gmADcdgs3IZhFG8J62ZJ63T66Y+USwADnvGbpYSbt2DDoEyTmWiGZAU+10ubrzP8HfPpuoLAuZwi0K0WXsyHQnCPEtEFiQ4tZ1DBobYhy62pudYbUobYPAoBN8nR12S1FuVBZwxxgw4G9D4OM2PI4LNx59qYLYLOY8G7N1YgR/u/WgmpE4UAzoSHSx5vb8NNPzMGsIvr6AeKGSaJhyyazGWEzdenX71LuidoWSKwAJv52+Jj7sNYBBuh3aBrrkpfNUFq0mczchDD7OWZxkgisoMLdF0lyogvQh7HXWEOq8M5SaQ7iJ9bH4ZWi+Kr5DfR38Pf87R0BeBCBXaKvtbiIvs6apgGuKvdYcoCNi2CNxQHmv4OTpF5dvjXA/16LEjkEcLkHFrMJDeU0mm9Pj/43wOZDl7ptmFXpwSwmd3jt/iHE4zEUMEXkSqQgfJEkNrf71G3Z8GcAsJhNsJlNKEYA79m/h+q/zwVe/Yk+Jc+glWHMb9DeUCNi64KbUA7ltXU5wPvfoZNZu17SC+Do0MQVrmLP3y0EsEAwYeSsKMheJDmXMWS87NeHWbZlc4CZi9pAQrmQ7O4Ocr1eiwm9gEyoAyzLhrNx1r5tmiJYo7+BDIYT3I16apkbk0qpIJG0BbAAgKTR3t6GKx9cix88uXnkXscGs5YmiaAEQTjjbOgXI4DHkAPMFu5okDpxfvPv1fV18kz0zPsGN4CUg4oDrK1yWmOmOa7RRBrY8iT/uplKyR2+GGxIoljiz80qpVG86X4Eeuhn1oMSTCsv4PKsgiYq1EqkII6vLYTTp3fay+DHlnblu1SMAD4dfAJnSpsM33eYmagIEBd2+ExKIQ0PHewh2AN573JcvvVK/NTymJqH7QzT820n5agrYUIyR+EAw12GgNXYAdtSegE9VMYBLtDMQAcI02s45udCsEwOLybPnG947O0yU+nWXS56+wrygrYQlsdugdnEf9fOP66SuwYvqNNPxuQMgQYMw6B5AUyXlR62Gbw1gNlAWOdwgG1xeo0zDIEuoy2Esjmy5R4759aqhbA01+F0yypu3S3F4WZShjbLtK2QB1HVYQX4KsUqOR1gRmy5bVwItNWrDKpnzJiNh9If457aJCuTgbsIDQ/909kWfP3MBkx28Q5waYGd+xunrHRiYFezMkHu1LRA4nKAg90IRun1WesAA/T70MA6wMznr0a0AJhkMu7hXqSpgF0o6R1Llmqr/nHHnhe49e72Zm59e5cfHk201NJyOmZ4Y0cPV6hx5Bxg+lmwE9dZBsNxtZ3QiGjSoWqkflS69b8zVgCXpPTjkUmOmOpMz6qiv8UdBtWvt3XQbcfVeCFJEk6aSu+Ta/cPIBXhRWR2ovud3XS8ky2AlcVpM+Mi8ypUS4OQ5BSw+l7gwY/z41EDMyEZNJoo4l/fBILzzR8CMHCA2T7Z0UF9CDSRJy5flzU8Cspz73eUIQSwIO9kQ1NZfJEkZHawzrZGyeYAp+J8RVuNAJZlolYrZG963VHla727O6i2lAAAr+xHGfz4heUhnLD/72OqNj0sMR8g6wcKpp4tnEsxlhBotgK012FBqdvGOQKuHK2Enn13Hbbv3ovXNuzBcxtztBsCFNGeo5F6ueRDUZq5gZUaCOBR5AB3+enExxfMb8NGlL/RICnADYnvoKrYi7CNDiZMod5MESx+wqSKLYIViQBv/4Z/XckEpJPo9EVRZpCTBQDe/o3wpOgN6bhZszGp1MX3vAT9rpQigItOqDFsZ1ImBdScrJ9ZH8UZrffiC3t/gGmZsEI27yo5QHOI20g5QvGUUoSFdYDDvUj87/s4Do34uuVlXGx6HwAwCfTv00oqUV/CDPhzOsDMTddVhr3uRfoPo3YxWiw0h9edDYHW5CCxvYAVAcz8ze0e2Ctnw4itrAA+hsKpBAcXrQA2qqLqsJpx7dmKwPM4LPjVRfN0+7jtwzjANr0A7mXSCnpYB5gVwEzFY/6E6P7q4DWdgpmpMJ29DrEpCailv+M6qR9zPFHc8sk5qPBQsdobyNwDNQKYtPAOMEsXKeEEfYEppqmEbFQEyzgHeIBxCEvcNnxkKj23JXOU683SqSW4L/VpLr1ic0q59++UqQC29O0EANQ46T0zQFycOAcAiSk0Zkko134HE3EDsw1hB3WAJZJGqcz2l9WLwmxEAOfulk1ndqACQduzOIt2ElbrAGupshi4+luf4la7+qhISaZl7OkO6e6VxxfS9Ve20XOzmU3898kAo4gKFpmACx8fFk0UglkiqIJ+4oSddK0i+sdneui47rhqOtlh1P6JdYDn1SoTTYsm0+/H7p4QZLZgJGiY/tpmeg+dohHALpsZsyRN9GHHh8DjX6TrBg4wMcrR1bq4AD5uUgrU6XKAmQ4QSMUMX2PC8oCPUQd4FJ2XBYIDhxBi6AADAPEzAq2UucFk3UWtyNII4N5gXC1cwOYAd4QVAbyrO4jJTAi0J+3Hdy1P46uWN4FOAPe/BXzuAa61wQGRq5p11xYUNrACePSuc5Mm/FmSJLXHJQB4DApGAMDc9iewzvEGQsSBh1oeBZZMMtwP0UFOtA+SApRkbtpV0qCaAwuAd4DTcWViwigHOO5X2h+YlffMTnxMkugF9oHUJ9CFUlR47ZBdFcjWOTEng4hHwyjQhIdVgF7kK/Y9yVVlBqDMhAa70DEUVduRaJlm4j+vmy47GwBQwwjgDf1mZIfHJVIQZ88uAJbrJxHKpOxNjOAs02YAgASCRaY9aEzXcgNBydeiLrcTZeDUMhBGSQXjAMspOIJ0vx9Y/4uX4iereXAA0EoqML+YCUkepQPcXrQEX+65GSeZduHcBjeOn1INLLoSkeX0Oa7MwEg7QNI7wMzf3O7hwjJZnkifjSsd76Ak3Q8sutJwH4FgvGjzgHNVUf3GmQ34yJxKlHvsnBucxW4ZxgcwCIHuzuEAF7EuX2GO0GsjB1hTzX/IyAH21igh1Zk6Bq98rgCYVYun1rdjV7fyu+wLGQtgy4BBT+IM++QarkKxR4pBYhzxsFHRH8MQaD8G06wAtqPcRMVrSbFyvVpQX4SoxYtvJG/Et83/w9RTL8bulaUAZM4BRo9SU6DCSu8hQbh0eaw2TwkyEaSqyORygK1OFNi8GPTT+1uDqRNfNb2BAimKwhZZuY5tfBTo2AAs/SY8DqUiNS+AGQeYmdSrzHG/KQY/dvFqnFot5SbN/dTXCrTxExeD/XTiYXXTABJpGR4Tf6+c5jCe1C8tsEEaIRLH6LehJbblOaDjVWDJNcCU03LvaBAl4A63AZjBbWMnW2ol/cTKFCf9+7NtorZ3+kEI4d4TK4rnZtoFcvns8RRIjJ+I0PaqBvgQaEBxgGdGDYo8dm9R7ol2D0ioB9pPVzLqA2wggJeY9sCKlH4Cj3WAATXSjSPSD2CmfvtYYQVwQWXu/Y4yhAM8AtFoFD/72c8wc+ZMOBwO1NTU4KqrrkJHxzDuWg6Ghobw3e9+F5MnT4bdbsfkyZPxve99Dz6fb+JP/DBhIJzgqutlcy4diMMcZW6kFcfR5UQIIEQvsjQCOBv+DAAeE50p7E9Y0dQXQoePL4LlTPn4MLXBRuCfHwX2vTn2N5aIAJseB9rWGs+IA0DvDhQyE9ZjqQLNVoBuyMxIsrOlxQlG0DFtn86NvaHsK8UwufOl3C/AhOzEiBX7mTyp2ZJGYJbyNy3EQ7ndc0aMsQ4w28qokyjFpso9dhB3uVr8BABskV5dldMymR6zuIcP51Pxt6PTH+VeB6UzIJv0M/zEUQi7UxlkVhXSQfSGPjrwm+yMojzWbPhS5RkBXA6fOqgCgBpJ+T6zoYDWIP3OtmUEcOtgBLB7AYtxIZ9aaQBXmF/DZGbSoIVUoJ5t/eJi+4n6aS4QO/BwlaLIZcNK+Xj8KXUpXq39jlKIp7COq+6aLfShDYFOse6XkQDWfi+g5Cr3oBj/OPFZ4Ae7gcVfM3yPAsF4qdO0QjKsogpAkiRMryhQB/isa5p9PCc2vQDuYxzgPknb6ihDLgfYKAeYEaxxYlUFKdvSCQDnAqNDqXRfbuQA55qQNWAfqUWIifQoQJRzxBMpmS++lIwZT35qimCVum26iBFAceQX1hdhtXwcrkj+GM9YP6WOD3ayAtjXAsQCKDHTe0iAuFCucYALCmkEUTbMmAuBtiqiuYvQAoe3WP6Fay3/w+XmN2B+8ivAI58Gtv5XGQ+8+mNUW4KwIMVNQKJsJp5e346vPrAG+8L6Yk5aipj8ZwkyV83aiBKiEUbbntbtE/Apf1d/NIkfP70VAODRHLcwPcB9J7KwNSpyUWjghrN4EEH18u8C258Bnv2WMkbLhZEzaSDg3EyV5ez9k6Wa6S+fFbWA0gmDrYwdjCW5minzqj3AjudR2/k6AOU8I4kUJE3IcIlBPr02BNplNWFmjrZhrY3ble9vSB8JwKY1AFA+LwMBbJeSmC21Dh8CDQCDfEcKAGP6reckneL/XiIEWgAAsVgM5557Lm677TaEQiFcdNFFqK+vx4MPPoiFCxeiqcmgEFEO+vv7cdJJJ+Guu+6CxWLBZz7zGXg8HvzlL3/B0qVLMTiYo7rcEQ5bTbDAbkFdJoyzVmJ+uJKZd4CJrLQ80oqsQKfyY83QOkAvjuUOuj0MB57fpMzeDjIh0FY5xlW/BKCEWK9/eMzvC2/dBjz3LWDZx4Dm99XNjWzLhXSCu7GNOgTa1wpz2yq1FcS0MgfQtRlFZuX5bkS5qqHcwIjBG27O/RrMBbuXFKGPCeVj+zDCUQgw7YEAAPEAiFEOMMBdSNmKjKwz24siSJJSzbOowIkBJvTYFuvVhXUVpwfUvFh7zHiygfha0ToY4R3gwlqYKufo9pU8NCfswgXVtFIkcx5VlhDQu9PwtbJFK2ab+LCobLsmNgTaHaXftzaiOAetAxElL9aTe6b1OsvzmG+iIVA95mpuNptzgMHcWDUOcDHzHDannG1XknWAtSFwZ81nQ98DBgJ4GrSETF7MrSnEFafPGPb9CQTjRR8CPbqANm2I47AY5AAnXfR7nc4VLjiaEOhYIFM/gl4zlWuQckHy2DWCno1UygjgCqa3aq4c4OFoJDUIMb3C3YjpqmJzhbByVZ6N+riCSyUFNr5OhI1+5ic30PvJ27voJF87KQdhJxx6d8AtM4Ur4daJO1sBvQ5mHWC26CCsTpQV2NFJqFBm2+DoIDKWJtagXuqDTcq8b8kEn6MONz+7Fe/t7cejW4cXswAfAu1BFCZp+NzZQqIJ6dWEPwNAJKC08vnZ89vUqDqviZ8sloLdOGlKCbetrthpGPqvO4cRHOAaqR/mbI9rfyuQHOZzMBJmBgLYYjbBaTXDiZhhcbcyExW1xW4bF7G1ncn53dlFn1tgt2BS58vAk5ej4e1rcan5HQBKPrsU5wVohVk/jplcyk8W1FuG+KJlTHTH7Y+9hM/8+TVICd5ZBgBHKsBPEiSjfEof0xJpgamRn8CLDOp/x4YO8ASEQEf6kZ0kAHBMhUALATwMv/71r7F69Wqccsop2LNnD5544gmsWbMGf/zjH9HX14errrpq1Mf63ve+h3379uGzn/0sdu/ejSeeeALbtm3Dd77zHezZswc33nhjHt/JoYOtAF1b5FRncNnZvpirSh9OmQjpCy2RNCfcWAe4yExvelHY8dR6ZcZuCPwAxiEZiNDA2N18NL6VOSeZtmoC0EHKECVUdBQyIUqheErXykBH0wrgniX4f53fxw2Znryf7LwLuP9MXPjep+FEjJ88MNuA6gWGhypP6KtmqwTp7HYvitHPOOXHSTQcFwVVSusa1g2MDEJiwt2ShCluwQyQulUBTFABOhvaQ4pR4rLBajah2GXDAKGhTe54H6wSM+CC0n6gNBOq5IgxF3w7MyPctR++SBLlrAAuqAQqDW78XjpJMbemEPd+6UQ4rCYMMJ+BO+3XCGDqEmVDoLV5Qdlev75oUi0WUsQ49e2ZQZjaJ5jNA9ZQKEU4dznhncI7VY5Cvj9z1nnX5ACzopYXwHTCKNsGafHkEsyrVT6DH10wC1NqmcmcmF8zoC1QBrVefqBfUl6Nl244g8utFgjyQW2xNgR65BBOADhvzhgGeAYh0JZCOoFmK6rVPQ5A1+9ThauITpSJJeaaydWs0AoSrQNMCOdmq1WgxzAo3kdquRBoF6JwWflhIdcKKZfjFPNnJv6U616pWyuA6ee4tIEKtM3trCCRgMq5dLVnGySm8I9RDjCYHOCsA8yFQFuyApgXhfS8MhMOzLV4ceR9Pvy5aDIah1KqU92eGHkChQ2B1rZAQmYCls0f96QZt3DN/WoIOIs9HcK/17aqk/sA8OnZmu9nqBsXL6TfyY/NrcRLN5zBFZDKRdEIAljrNmfvOXt7gmgfDAFv/hJ4+holfHuUDjCgRB4Zub+AfmLgOC4MOsAs+5l9vDAxLTM/kcmxjSVlnQNbLAXBiT8oUQosM0AnTEKOam68NUXqQWjAOB3NDE3vXq37O+1cdXGhaR+X4oZBA3MtZwj0OGHDn61uw2ve0YoQwDlIJBK45557AAD33nsvCgrol+LGG2/E/Pnz8c4772D9+vUjHqurqwuPP/44bDYb/vrXv8JioV/03//+9ygvL8djjz2G3l7jioJHMmz+b02RQ53BZUXc5qAHzX4CVmQgHjQOs2XCoFuZdjMFTAh0mDjU103CgqhphB/0WPvnEgL4GPEzRENTBuDl2sdoc3+GDYMebAKevEIpeADgSvNrKIUfk/crVY+dsR6cbNqJOjZXprAe8BoPwibJHYgnc+QdMxMJfaSQc4CnmpjQr6yLxzohQb71Qwczu87e+Loyf4NiBOlsOhTHOfs9KCmwwQf69+FCuxkqpUEABK4kc8GvPVFdHOpU3NKKbEIYkFsAMw4wAHzi+Go8+c1TYPfS0B8pHlRyfLJU04rHZZIfdosJn5/E35yrMzdxki0WIssoT9PftOoAZ7+3Bg7pSvNJ+vMFYCmdwm+QJG7wh+igUlSH6XUMTxWKnHQyhi1gwjnAGQFss5jw3LWnYcevPoZrz57OD9ajQ3oHGOCLwwAaZ1ogyB/aHGBvjhxgLVecOgXH1xbCapbwm4uPH35nbREsyQx3CRVLrtIcTm9OB1hThTrm5+5pg0wLN52jzTrAMR8w2MSHQAfjSnsWbbXYYdgn1yLIOMAWpGElSa4lT5itBJ1rwB3z49Pd92Cj/Zu42vyyEq3ChUDT93XipGKu/Zy6i8UEib1ed2/jREMALs49BsCFlGcd4FI7M4FqdepCoNXjmYqAm5qBnw0Cl/xT3T49vB4LmOgblM1EOzPZzk7Y5mKmN6lGKBQywpHYPcC3V+Ltpf/E5Ykf07eR8ivRAGv/AbzyI8NjehHGn96gfYdPmlKCM+o1EwLBbpx3XCWeufZU/Pdbp+BvX1k0qtxeILcDXJlpX6StzYHoEJ7Z0I6P/uld/O7O3wPv36mEkr/9m5EFcN8eYONjQDyoRAZKxt8rW4IPIz6OCYNmRS9bAXpujZczNRaZ9qoRZESTby/JKfz8PPpb/fg8/aT01DQVwAOuBqCEFnmcLPVwk/sDxMOldHGfAyuALQ4k6k5RVxdIjfyElzb8GQCSBoXUIoNKZGTTOwde1PUYrQANCAGck5UrV8Lv92PatGlYuFBfJOlzn/scAOCFF17QPabl1VdfhSzLOOOMM1BZyQ967XY7LrzwQqTTabz88ssTc/KHEbwAdqozuKwAbidlWNk0wOdbJULGuUbMYKF9kB6b7QMcAe8+Je36PC027wnBbuXmM1oig8YXIwADxMsVD3KmAlzbhpxh0PEg8PiXuN6QRVIYP7c+AokJm5kk9XIFpVBUD3iMncQCKYb+zhzhXqwDTIrQjxw39ezMOCuAA7xIbWcF8Mq7gFV3Ix0ZQk/GkWDDkmPEyoWylbhs8DGDPqNWCIBSmMuNGKwy/Ts/00Pfd2pQeZ+cA+ypAqqGd4CzzK8rwpPf/xS/sf1Dujz1THWxwRnBy989g5sZBqgDDChh0CTYCRvTD7KdzQEGdA5wipjw77pbMFR7lu78KkoNhCVbCToyqITiZ3sju0qBkmlcm49cDjDbB9ViNtEQSHawHugCN1Oedd+1ecAu/W9NIMgHpW4bHIxbaVQF2gi7xYz/XX8aNv7sfHxpaQ6nVt1ZI4ALKvHRuXQC7YwTZvORGFlyCWCTmYtcwcA+YMMj6uoeQsMrdY62s4hPFercyFeBDsZHdH+DEn0/aXsR+uFFGPxEQlaUZOEKYRkVwAKA9nX4dPQ5FEsh3Gp9DCUuK+3mAHD3dofVjLm1+gJ6BXYLf73u2c6Jhqs+cgKO17axYkLKsw5wHWvQGoRAZ9lbsFhpVWUyAZNOUSfvzCSFb5qZcV35TLXbBAD0Q3/uALgJyQsabGqEAucAO4oAVwms08/hRLmJpIHG5cDLP6T7Fk4CFn5VXfVKEfSHEjAjDRuS+PbZ02DSjpHC/UA6iRMnFWPJlJIRC1+x5KoCnS0K5dWkJsmRQdz4pFIEch6YdoEd64cXwJFBJXXs+euA+89CjTWMGmY8yEaUSZrOEvOqmBDoHA7wvJpCbiLYK0VoDq9B26ArTvDgp5+Ygy8sqcdPPqFPmapP0Yi4XsdUoIR2UJhi6lZrggBADymBH8wXkK06zXyXw5IbvR4a7TDd1MnniRsJYCN6dwD3nKTksf9hBvDfr+VM3cpJiDFUjqHwZ0AI4Jxs3qz8sE888UTDx7Pbt2zZYvh4vo51pBFLplUBWFvsNHSAO0mZEp7Chl4kwmNygO0yvTiHiabIiVt/81snMy1cSDp3ISsjtFWIGQZIIecAS7EAN7OaUwCv/TvQp79wfdr8Abc+SerlWy+UNCjVQXPga89xMQyxArgYfTlmtUnB8A5whNh58dy5AXj9FiSe/Y4aBlzJFKZS+v5K6veg2G3DECOAK9PGURDV0iAnbmWY8PoQFZD2iHJOFaMJgc7xeVkcbiUEKEuaKaYylYrSItmHaaVOoG83f1gpioLMTWwglECoh4YxDRCPOjHTHYhh1b5+bAnwEzW7ST3qqioQu/Bv3PY18mxdwR8Aege4aQV/viYT1+bDxzjAXBEsm8EAHuAFsLbIR/a3WqYVwHqnRSDIB5IkcS5wrirQuZ5bMEJbGAD6cEBPFT41vxpPf/tUvHD96ThjZqW+aqqjyDB3WIVNWXnuWq7V2mPp89RlQ0dbEwbNOsADoTjSwxTFGSQF6HTSirGmilkwSRIisPOuVSLIXRMirAPM3ifZ648mjLTcGuOvn5piYifUF+nOz223ABVMCHTfbk40zJlqUFmbc4CV8UKNmzkXqytnCHRb8VK6YrYAsz5BTzcTsZSGGZj/BU4As6kyHEW0laMz5Ued6gBTASxlzre22IkAXEiw6UPrH6LL3jrgyheAKhqh4EUEdVIfVtpvwFr7dTjNuZ+PygEAEON2OaPA47AatmzPFoXSOsB7W2gU3HQ2ZLx/r2FbSMT8SiRRyyraum+wET8L/Zp7/h7CTB6xQnrnizjvfyfjJdvNKEAEHb4o/JEkEikZe3vpWHFurVdxRRkWmxTn3JTQR0eYogP4+pkNuP2S+ajf+EfgT8cDa/6uPl6ToBF+nTaNAJa6uXFJHynk6s4kgsrvZU9PED9/cqW6vStux22rYvAxZomjbzM9qdEK4KYV1ChKRpQCZY9cpHTjGC1sO8xjrG2hEMA5aG1VRE5dnfFMbnZ7S0uL4eP5OtaRxm8/Ox+7b7sAq358Lr6wZJKaA8wK4A5SpjRZZ8THm5saEQ4Z9HTNCOBYMo2ebNEPANY0FcNaB9heqP9Rb5Un8wU3gl26fXLChj9r6IeX63GImH90ArhzE93HlduVmCT1YApbnbJkWk4HGAASPVSkbWgdwvX/3oDnN3XwAhhF6M8hgIPWjKDJ4QCH4eAqbWcxd6xTl/kCWMqgKVu8pdRtg58Jga4ixjfvSmkI5UyP36C5SK2qDCATakx4AeypUlxSTcgzvJp1FiMBZy8EqmgINJIRJTw6pe9vXSXRQljhbhpG104q1IkgQoAv/XMNHtnKP3+TPB3TygtQUVGNC5O3o494kSYS/pM6B/VGVTy1rZCa3qbrDWcD4Gf1hxgHOJrUF8HSoQ3XzGK2AZbMwJt1pLTnJBDkmRkV9NqhDYmeELRVoD3VkCQJiyYXUzdSe/3N1QIpy1k30WVmYqm/5hw0EeXaJEl8ZIYKK4DbP0SFl97rZAIEcuQjAkAXKUW/m/5epYo5mUkAicsDRjzEvXYoVwh0ib4IXpYyonEAbW5uNacAZsQF4n7+vmx0PTJwgCucrAB2oMxjNwyBHqjUtPGZc6Fun6e9XwWq5nEh0FE4ENFMsgMAiqkARmRQdYALtQ4wgOpCBwAJg6yb3Mq0PVp0BVA8hXvPXimMS0zvokoaQpEUgm3TI8bh7gYViUeD2SQZ9gpuKFf+dtoc4E276QQvlzPNTIakicR/VkMtQPdW7jizkjtwteUVdX0b20c+GVaKRwHAqrthSoYx19SCL5iVe932Lj+6/TF1sh0ApnrSus9lUUYA25IGY8qsyG5aAbz3B8XgeO1mRazLaZTH6Li8zTqF+95XSj5uPNZLiriUrsBgD0LxFK5+eB2GBulvJwAX3t83gM0yPZbUwUScjVYAGxHqAfzD1H/Rwk5qCQEsAIBQSJlRcrmMy8e73cpFIRg0CNPN47GyzJ071/BfY2PjyE8+yFjMJtQUOVHithk6wIoATiCQphfK97bvR2+/QRhNRgD/ZfletcCe1QxITEVCdwG9qVR47LB59XkNLXIV0m5m4BLsVsKC1/0T6B/h4jPMxWWAeBFgQ2BGK4CZGct3iy9BnBiLEp0DXDq8AJYGlNCkRErG1x5chxe3dOEHT25GmhGxfaQIvSgyfH6PnLkBcwKY5tcEiROvpE/Sna810gNLJvyXL4ClvA7rALOzoLU5coGqMMj03wUC5hK1nRIAuKU4ShDk9lGdGW0Y9DCOOdwGArhidkYYM9PjjW/r9wMNgx4Mx5Hob1a391sqUVPET8z0MnnXALCJTMO08gKYTRKCRbNxdvxPODl+L56Vz0B9scG1gw2B7t7K3zSnnQMAKGYc4GgyjVhG+LJ5fTkdYHsOp4P9LggHWHAIueEjM7CgvgifnF+N84/LfR08YLS/AaNrrXZb0QgCeOoZwMwLdJvji7+lLld6HDCZDOw41j3u34MCu4X7/YaGjFNIAKX93LbazysC3VMDLP226oJzKUHxINxML+BsvYBgLMkXwTKoAp+lOKW5jmsmEhbW61MlCuxmwF3GtfXjnEQjAazLASaodvEOcKnbhh4UI8243HvlWtiKNbUzGs7mznOdPBOP2y4BwHezAHK4wGzhs+igmgPsBSuAlffgsJqxZEoxf5yIwWfLCmBEMrUwMoR6DRxgjL2mCfsWDFohzaxUrvceTT2T9k5lzGJHAvWS8cT1IDxoJYyoGmo2LPDF8iHR9LXNhkEztVY+alZq7+zoDKCTabdY7rHDHtGfy2JJMQIcKYPPK9yvzEov/xXdJqeUQqdDzbASJZJBJhJaTUrNlTjomG6xiZoMfSjiHOCIrxe//N92tA1GuXowAeJGOJHGJsJMIHdsUP4nBBgY5zjeP4bCrmzEgAiBFgjyR1mBHWak1ZYxgHJj7g8lEJHoTTgaDqCt2+Ci6m/Hmzt6cN8KeoH4/AkVkAh1tM5bQGeR59Z4DQflzaQSCaadBYKdwJNfBV76AfDgBUqf31gAePJy4NGL+QvKMA6wkgPMOsC+MQvgzfEqvCvPN9xtstTDF8EqmQZYeedjp0xvxI6ActN4e3ev+topWdaEQOd2gNuSmRs0OxAM8g7wOjIbZ8X/hB0Xv6Zul0BQlQl95hxgknWAaQ4wW6nbJTFhcwxVmhDoXuLFEDzc7PI8035YwORyZwWwNgx6WAdYHy6PijlKiBwbSs+GGzNUq72AEyA+OnPss9egppD/O/VpBPBGeTqmlysDsPoSF8Jwoi8zMZFtH8bBhiBuf4YulzSogzFtXpc/U6E6zvTmHlUINAsrgL11fD9jl3CABQePuTWFeP6603Dvl07kCjdNGLoQaIPJM50DnCP/l+W8XwASc76Vx6N24cfwtdOmoLbIiZs+Psv4eeyxYz4gGePCoKO+3OGvXaQU6aLJwHe3AN/fBlTMVnt/hwkzOZcIcb2Aw4kUvv/EJhz/i9exq5GpTquN/mCwRRghbnEo10+G+hKnUimawWWzKNb3qCpoZ7cV0ZeRZHz9pHI0FDKfq1VJu0rBokYfAcD78jy92LM6gFOuBwB0kFLcmPw2ggkCWSZo92kEsFEecNEoHGBGsN/1xYUoLM0xGVtiIIClCMokxtmMDEy4ADYqhJWtIK1tT1hAlNeeInXDnKPN0xDxoNvM/D56tvHFJRlCxIHn0qfi+fRpCLHfx8iA0n+aGbMslnajFH7s6g5ynUZqCh2GXT0mmfpQgSEUEIO0usgAsOtFtbWYyp7XlRzbDC2kAv6UGX3hJFplKhTnm6gwbyflXE2T7Y3N+G+mIwk7EZJNk9vEOMBo/1ARv8Gu4VtM5cLE/MbG0tmEC4EWRbAEgFr1ORIx/iKGw8qX2eMZubz8RB4ry/bt2w3/TZuWe1b2cKDcY0cFfLBIdADeQcowEIpzF70CxNBuIIBlXxtufHKTuj69ogA3n8ffML94xhwsnVqCSSUuXH/uDENR00KqEHMws129u4A2pVw+wn1KAY5N/wJ2PK/MBL51m7or8Q2TAww+B1jnAEcMBHA6xYUtbfa78XJ6qX4/KG2csp8dkUz4y4YkPvLHFdh+3I1Iw4RV6ePw59Rn1f2Lo4oIe3o9zZ0uQBTmFL1p9JJixGBH2qqvlr0vmtmWMwRaucl3oxQ99gZuBrEWyoz2JCt1ZbMCOJcDnIsqaYgrNtGRVNpXsC7wCRIza2p10XNmHWCT1VjkZjFyMMszhTHY2dH97xg+vZrpBWwN0ImSiKsO82r5Adx+UqXmP7fIFfC7pqIwI1jrGMe30GnlewSq58qITaYtFRrOURcdVjNXKGgokuAKYAHQ9f1UsTqVz0sL+10wmbg8NRRP1e8vEByp6EKgjRxgjYgZKQQaUCbVFjNtFM/8ISBJ+PmFc7Hyx+fi4oU5RLQ23zjUjUqmF3BsBAHscViV36xJmfRyqw4wGwLN5wA394fx7EZlQB3xMYPlokn8oJuFzcHUfoZQcrC1YdBqTjYrJFmMIlIYQQkAPz23BhJzb4PVBYfVjAK7BdvkKermN+RFxkWfzroJmz6zHB+L/w5tpBLheAr9objaAilLv5EDzFQHRmRALcZVCH0INABUFzpRV5dD7Bs6wGGUagVwzCAEelwOMP+ZOK1mVHocsFlMOgc42+qJD3/mGYQXPYXMZP6ul5Q2SVlu2IR/zP8PlsT+innxB/C95PVIwMq1A0NkQCfozBLBueaNaBuMoEttt5hJgwgYn89i026+0FSWcB+w/Db99n1vKJXIM+wh9Ygk0tjZFUAzMe5x/1b6hEwv78z776VjpRleatJkTRI2BBrhXqBl5YGFP5ttwPSP0nWmVs6IcCHQxu/raGX0VSOOMSZNUi5M7e3GX6Ts9smTc1ys83SsI51Krx2nlIaRvSf0Ey9isGMwnEDQRGdk3YjCTvQXK1Pch3QsCMAJl82Mv33lRLgZNxkAvJ5CPPFNWmIeQ7zgCRGHUv3SXg5VQjB94wAAvhZFBGcge1+HJMu4Z0Ujzt21HcflKK44QDxcFWjE/NxNZSCc0D8p1EOr9wLYGnRjFxZhkBQovWBLGpQwIKZCNABEnDX409vNAIBP9i1GjfMhdCYtaGBuSGWpbgz6g3h7Nx0YsY5sipgwkLlgE3c54ONnSD8csGHPfzfj3K4Q1BIhTAVsdtJiKJJQwv8yZfVrpH6AAJNsQWSLdGfDfrMOsNdhQUjKMfHjrVVvfFXSIMqZFkcdKWUA0klKMR3K+z3BxNw4CiqhVvSYdApgtitFWWoXKQPAXBgUTENFpmBaQTlgNL4saVD79mVzgAfCCbgi9Kad8tbh62c0YHd3EFazhNpiJx5b3YorEz/C+eYP8Vz6dEyro59DPeP41hu5vwBQu9h4eyb/N0uxy6YOEnyRJBcWDQzjAEuSMgDTtj7Rtob52P8Br9+qtKWadLLxsQSCIxFtMSsjB1g7aByNAwwAH78DqD5BuebM+vjonmPOTOBlf5PBbkyvLMDaZuW6E2EEcK+tHhVML/hOUoLZmsJaagg00wpJ6wDv71fuw1ak0CAxObn/v737jpOqPPsG/jvTd8rObC8sfQu9SxFhAZVqo6jRYIslURNN1EejBuU1MTGJMWrU533iq5KYvOojBl/7o8YOGgvBAgq4IE3KssCyvd7vH2dmzn3KzM6sbGN+38/Hj0w/u2fPnHPd13Vfty9HDeislkaSl8qLsa7ouP4h/PMrbXujZddWGWB3ejRo17E71QA7suZw4xFADoAd6vkp2+/CnYe+j2r4sbF9INa1j8ItFuW+sNngyClBLdRAv7apFbsOm69DLJdCyh2pVsO0NgAQ0eZJVnOAtR/a4nzjz9P+7qQA2Kc0IU+aToT6Q4jOA5N1cg4wEOmkLlCs7EG18AOePNhsCgqDHgSO6jPAISWBAFgE0FR0EnDkEfUOKaMKdxDIGITmjDZUQt9Q8hAC6I9wYNagv76LmGv7GLcfmq/LABcE4wXAW/T7IuLzp6UsqKJWZog2NfB+/8Ho074S/dEQDoDtFgHwJ+0l2IcsNDq0fRZS1Cy522HDKYPdQPjHj0yTO4R0rG8vxoTItcuLNwDDFmlv6gpYr4ZilDdKP38+qQwwS6DJYOxYda7N+vXrLR+P3D9mjHWpale9V1+nKAp+NVv7gohk8Kpqm3FYmgPsU5rgh7nJEKCVmV584iAU5wb0yy040swnSkPGb4fIA6DgqEO639iBuXoXDu7WWvsr9VVo3bMe97/xNQpRCSuNigcN8JgywAOkBkZbD+i/zL7YU43b//Zq9PZh4Ucj3KiBFxe3rUD7nNuA5c/ov9zC9tr1pbzfNqgXLbtELlqFemjb0Y63P/gQLW3aiVIOgA8iCBH+GlAMF3INwoVXK+qx+pPd+Pf+NliRl9A4Ut+iu/iLLG6vmwMMfQZYURS0pZnngwEA8rSOoAGlAcNs2shxpGRbXoJpvLx2o5ypSS8Ezn8SmP5TYPF/Wn9WRKIZYJk08hr5mY/UNCDQLGdLBiI/6MHfLpuCxy6ZjOVT1cGuT0Uxft/6PWwVRRiao10ozizRSpFmSP/WGVIOLLpHn4VRbOocQ4mxE7S8BrDdpsAdr3TUY5HpMAYF/ScDl/4PMP83sGwjStRXmQLgY5QBBtTz1IQLEg9+rT6vZp86zSesVVrSZF2Dfju+FdmmTtmRALjOOAdYqgqJNICaY/s3QpEAwuEBiiahPdY0CXmpPIsMMACMGxDS3Y5WomRYJAJifQ6gDyobjmhNk4Do9KAsvxvfiALc0PIjPNam/r5jLfujWwKqqRW7pOUWI9OyLUugPUEgb0T0prtqE7L9bn3W0ZCxtgyA5eZihp9bt15u01FtfqysZp+aATycfFPVUJoTNzj+G6+7b8RHnqvwdOu1wFt3YWDIjoChBDoSTBbb4gfAWcWT1GDXKH8UEKMbe61Nnht9yLLvykzb56g+egTfVGnXf4UhQwm09LkTbFusM8ByCXDpPGDgidrtcPDZIuz4f23TUd/chk17j+IbYf4eeLFNHfz1BLXzdWY4S/69E/ojIJdAS9PkftmiLXWFyi/VRlwRhnM5APV8bzweCscBQWlOe6IZ4LZWfadtlkATAEyfPh3BYBAVFRXYsGGD6fHVq1cDAE4/3dw50Gj+/Pmw2Wx49913ceCAPoXU1NSE559/Hna7HQsXLozxDscXb4N2ctwTDmBqmlpR2aTPAPsMX7gRkSBjVlk4IJHnS7gsymkNQU2kfOWwPU7DniM7Ub9f34ig8ctX4Wyt0y4CDKptIQAwZYCHF2hf5l/urYEIj9o2trThR3/7BAf2aHNI9knLNTRnj4Bt5vVq8JtpLi3dpVjPH2qBQ9d44pN/f6R7PFfKpEYysnabAltAH+BFliwCDE1SJPLcsSMNLbqLP7WhlYC/RTtpHxAhpIVL0iKCmTECy9AA3eDFaEX7PUXmzzZ4tUGADEUaXDBmZYbOAU79X5YDCTrGADgtQ+uMaNUhMWcYMOik6M1IBthdsxP28HzkNqHAnT1I97KyvADy0vWdRIuljraj+gXxxOVTcffZY3HtyYZGU7ITLgUuWKN1Xx61zLA8iXpRE3G4vkXfAMtpj79WpGVX7MSnahD1acayW6v+AQHDd01HTbC+KzkIr9mnrnsaZpeyZZ+3D9Ytb7RHZJvWFrYuga6FV2qCtSu83OAyu1QlNew0wBPEkfYY1SkdlEADwFhDCfTB2nCZkFUGOF4ALAeVjUcMAbAaaGT7zdleYyVMhJz9bhf6QevJg9XvWVMTLMWuBttyv4l9n6NfRlr8DLDVdBy5uZjLr58rbmSVHdz6KnDvGOC+Meo8VitCADveB3bprw1CXifOsmvL9QwSu4G3foPTxLumEugQatEvlKZfAsngEAIYUZSlDyojwr8rn0UA3OSSzmH1Vfqy6TC30oIZymf4984j0ftMJdBDZ0X/OVzZBVuMucpR/ScDJXNNdz/StgDbRCHqm1vDJdDmAPiltskAgPRM7fsgpNTAYVNwRflQ3ZJecqPUf4sSrM8+w7wt/nzg5NvM97vTzX83hePVirmIRJtg1avXaFHMABMAuFwu/PjHakOEq6++OjpPFwDuuecefPbZZygvL8fEidqyBA888ACGDRuGm2++WfdeBQUFOO+889Dc3IyrrroKra3aBeiNN96IyspKLF++HLm5KfLHJzWR2iNl8A40aSddn9IIv2KdAS5UquB3OzA+MoIcKX8CrANgQ2ffHeEvL7kphlH9vq3RQDvCVvFPXZfiNsWpC7QOK+pJutrQBXpYuImEDe1Y0fxHtD0wBdj+Dv78zjbsPtwQ7RwMAJWKtq0LRkkBbsYg0zZ+1Wz995LuceAbaBdql9SvwlOuOzDTpq4zl2Nal1edZ2rMAMudoXUlcpJaXQa42RQAB1EHW7s27/mACCEn4NYFXRPLYgSl7oA6Vy5MbrRRGV57uNXfz/QyAJ2fy2Ickc8ZrmU1rQLghb/XjbxG9mV2vVaO/Y3IR1ZIf8GkKIouywtAlwEGgGlDs7BsYhE8zhglyhGDZwI//Ry49HXgLHOGO8OnXfQeqW8xLIHUwXtPuhS67tcAA2BKHf4cbQ3wkrnWTd4yh2jTAtL7df1FpC4A3ouy/EB0ibUQtDmhu0UunmibA0C9OP8WcTLAhhJofzgb60YzvM0HkYmjmGXboD1n3HkAgMoWfWd7bbvkANi6x4Oxr0FjS3gakNUc4IQzwIf1A+LhDHC2Xz/Y6LLbYk79MP6ONu/TgsxRhUEMzvaZ5wC7/ep5Qu6HsO8LlOb69V2gTRlgi4ybHABHpqEkK9IU9F8WFU9VFcBfTlebfT5yCrD5lehDQY9DV7EVUSx2mJpgZSi1KM7xYogt9tJbtbYQBmZ61XOUUfh3ZZUBbvPIS/xVxWw8OsP2ua6iqSDo0QfAA7XBabeSwNq4hePVLLCkOS0Xf2pdDEAdQK6orDPNAY6UPwNAdq52fGYqNVg6oUjtCC4HwHKjVAAfDb1GP3AdKAQueUkdYDfOs/ekm69TCsfrp14cTTADLJc/O30xpyscrxgAx/GLX/wCU6ZMwbp161BSUoJzzz0XU6dOxfXXX4+cnBw8+uijuucfPHgQmzdvxt695i+Ee++9F0OHDsUzzzyDYcOG4Xvf+x5Gjx6N+++/HyUlJbjnnnu668fqeVI5y0G7drEgB1l+NMAnlUAbl8o5cWgWnPbwn69cAm012mwYLYt8ee1oirHMCwD7t5/oGnUBQNqB9RihaGVF1a48XYAWWQ/XuA5wlt+NnIAbp9o+wWL7WjiqNqPptV/iobfUIClfCoBPmjgGz//4JDxz5TRcc7LUZdMiAP53nXXH3YJgGipdWiA61LYXU2xf4U6H+veq78ocAhDu/ui3ygCr5oy17vipywBblEDnScF2k3DgCPzR+b8Rs0YNQIOwGI13+YEc626oleESaFtGjGyLMSuTKOPIamT+L2C+WBl7nnpiT9d+5nSlHj40oF+Llq3eIop0nVojyssMAXDudzj5uP1A/xNM3VYBcwm0fgmkDtpAjDsP+OE7usZaxgsEouPaBWuAH70HnPek9ePuAHD2Y8C47wPLHo3fY+BYMGSAPU57dD3kTKkKpkoEcGvrpRjf+L9xVctP1Zcagk7rZZCOwut2IANH8Zb7OnzkuRrPulbAqaiBRrUjGxgyG0II7GqwLiPWlVXGuai+cpYW7P3gpEHqP75LBrjhiNoxOCKaAdZ//wa9zpiVL26HLTqgAKhVWxFFGWlYecZI+DMN1VeRSgE5AN6/EVeWD0a2QwrIjT+HZQBsONd2JgCO2P6O+juJ+PIF4D9PBL55V7tvq5YlznXUw6WYpztlKTWmDHAQtRiXXou0SIMPAM2ukO45aSF1DrF1AKxmgI0DDgBgk5MW9VX6Emgpy65bEhKRDLCU/Swch2ZbEuuDF4wDskvV/8L2T/1FdIpAZBWFvSILzUIbQJGblhb1065JMlCDK8vDA/y6DLA+AHalZ6uD166A+vNd/II6EKIoWnVXhNuwsonDowbKcga4sRposuh4bVQnBcApVv4MMACOy+Px4M0338SKFSvg9Xrx7LPPYseOHbj44ouxfv16DBnSQTmlJDs7Gx9++CF+8pOfoLm5GWvWrEF1dTWuueYafPjhh8jMTKHlQ6T5CbUe7URSJ5VhedEIn6KNOG4W2pdKkVKJmaXSwaoLgC1Gm12+aDMMQF0DGAC2NsTuPuxuN88VUUQ7vufQ1n/db8sFcrU5P5GA0TgHGEJgeEE6xktNmlr2b46OeA9yakGiLViE0UVBTByYqT9BW3TX3dJqnWnIC3qwLzDSdH9/WyXcaNYFwJXhLHgwzWk6GUc6No/rH8KkEyxKmKAvnVNLoOUA+CAGubWMhLqkj2IKBkty/aixaoTlDqhf7BYiJdBK/mjrQQ9/J9cENZb8SvvXVD4991fq/305ulHafOUQSqCdsDeL/qagHwBmFOdET/4DMr0oSI+RTfmOMrxyCbR+DnDMBliygjHAhc8CV74PXLku+TmLRH2Zza4GNlZNmCJKTgXOeqh7msAZMsAAMKIwHYBABrRgLbK83GFpvqopA+yJNMHSl0D7XHacZV8brWgZYNPmFr+dNgew2VFRWYcDzQl8Z8UogQaAa+aUYOXpI/Dg+RMwbUj4uzctw1x6HmtNcsCiBFrOAGtNsGQZMeb/Amp1jk/6XtwjNVkqyvCivDQHdy6frX9R5GeU+laguQZDHAcRlOedmppgWUwxkecAAwkGwDGmsbS3Altf026/9Rug1VBZJwVB2RbZXwBIb682ZYDdSivGO7+J3t4rMnEooB+wzswJ/63mjtAHcoo92lvDqgTaGZAGoo0Z4EhFBoCBNm3+rtOuIMfdrlYBRDe8H6o95iqxFmFxLIcGqhUeigIs/T/A8DOAeb9By/Alpqe2wY71jnEA1ITHc21q01Wfy45hQ7RrNZfShkGB8PlWCoCrDStfBDxO9bx68y51sE2uAjBek3iC+vvyR6vN4Py5yS+FlMINsAAGwB1KS0vDHXfcga+//hpNTU3Yu3cvHnvsMRQVmTs9rly5EkIIrFq1yvK9MjMzcf/992Pnzp1oamrCzp07cd999yEUCnXtD9FbtLcDW/5HXQw9TJ7DKZdhBZQGXROsrYYAuDxmAKwfWQOgfqGFO+vVpxVgg1C/XPbUtFvPcYxjqk1rlrWzLQs44TL1hO0J4mmhlpvp5gCLNqC5DsPzAxitaGso+tuq4QmPnI4PSSeWWGvUGjLArcKG3cJ6xC4v4MauvJPxu5ZzsbptZrQhFqBmZfNhXQJtLBuuUkIoykjDQ9+fAF/eYHzVbs621hlLoKXRe5/ShHFurRpiv2EN4AhFUdDusShHjxEAtwh7tMw8LzcPOP0+mC4AOpsBNl6QyJ/ff4q6vwvHAxc9r5Uh2WxqyVJYoVKFMkU7YW8VAywzwEGvE49dfAKumDkEf75wojpS3gVCaXIGuEUXAPs6ygDL8kboL/CIqPvJTbDCDXxGFQYRQIMue2ecp6ooiJY2R/ismmA118LrdqDcZr1e6z/a1Gze2q8P4igSqFqJEwCnuey4ePpgLBpToA34Wq0F3OkmWNYZYNMawAbGTHlEdD12Y+Y2kuV2B/Tn6l0fAdIUoI5LoBVzv49EAmDj+8q+ekH9f0sjcOBL8+NSEJQlrANgX9N+uJVW0/0ljVpX56/bC3HQpQ828wvC18k2Q3PGnLLo4IRVCbQ3JAVjtQf0wZyUTS5AFVxowffsb+Bl189he12aM6vYAH8ear3m65ZdVtdOheO0fxeMBc59HJh2Fbxu67+FR/NuwaZJv8Ky5tujiYSQ1wXFmwkhX4/UV6lzrmPMAQbUaWvqNivmRpLGaReeoD5A7h/OPtvs+uvHRBphyQGw1RSv4xwDYOoeLQ3Ao/OA/3uObgSyNaB9OUXmdQJAoeOorglWlU8rCxpkr0J/qbNyhyXQALD4z8CFz2HjmS+jCerJb291o/WyFga60XHJlsYMiMwhwA1bgeu+wkct6omrxlDeos4D9mG0tGA6oAZKg7N9yG6XOjvGCoDTC3Vrsu4SOWiNsYpZftCDgC8ND7WdiRtafoR92mJPKFQOor9N+9KLBNFWJdBXn34S3rphFgpDaQh4HPhn+3jTZ5lKoNMy0GrXLqbGK1rWOxJszx9l/p270y0GIlx+ywBY/TtRTxJFGWnA6GXAGX/SP8k4ip4oT0ibx+zy60vaFAVY9AfgirfMJV3SPOBByj5daZajYCTcDuvs0aRBmbhl4XAMy4+T4fiO5G6nagCsXcikJZIBJqLewyIDPLIwHZnSGrFtQtH3ooAa/BoH2QJWyyA11SLd3oKpNi24iXTbf6p1Ft4/mg0hhBoAC4sBZ6MYc4DjMs4D7nQTrPAcYMMAZLwMMCAtyWQQXZ/dOHAu90WQzxlyqTFg/jlcfnWJvohgUXSbY77GSry+DF+/rga/lV9qc4NlUhAUbK0yPw7AcdTchAoAco78O/rvClGI3Yr++mVgf2kgo1SqHJKaYlmVQAeypGuEys367R44De2Kun/sikCJshv/y/EXFIsdwEcPa8/z5wF2BxoC5gB4v8iEcBh+z4Xm6xsg9jkyIzMX7eMvxBYpOZPhcwI2OxR5Pm9dlVqV0K6ddxts+uvUWAMu6gYYkgPudGDCRcDw04GyhcBJP9Mek6ZjoXq3Ot/7kP66U0e3BjADYKKuse1tYPeH+vvGL4cnXSt1qZTW1stur9I1PWrP0UpRs8QhoFWbd9JhCTSgzo0cUo6cbO0gr6xtQrvVshYGT7eV6+bDRmxvzVTX9bU70eZIQ3OrWtLcAgfa5S/XxmqM9h5GumEOTaFShTPH5kOpkeaMp5vLdQCoo3vS8hA7LLoQRuSme3Ql4s1e7WQyUDmAAmgnuchIaKbPZfoCTMsshCM8z9ppt+E92wmmzzI1wVIUHHVp2deyVm19v2njRuLNG2Zh2lBzsJueYTEi6/arWVbDHJhKaV9EL0gmXAAsfQQonADMWWHZNTshiqK+z7jvA2evij+yLpMGLmbaPov+7TYJJ0qG9ezyZnK3U2MJdKwLPSLqpeRB28ZqoLkeIwrTkWkofxaGyzurQMO6C3QN8g6vhyfcNKhWeDC76R6MaXwYN7VegabWdhysbcYH26pMcxktdaaxznfJALdaBMB+YwAcPwNsVZab4XVq2Uq7Ux+YyAPveTECYEca4DBUAimKPgucZTFwm1AAHAQmXBh+T5u6dKIzfC3UXAtsfxvY97n2fLlUVgqA/S3atcGWdu1aRGlrtvxY5wHtPb8W/fCv6pDu8cEDpeBzzLnA7FuBEy4Hyn8evdvqdx0cOkkbGJCDX18O4Amixa+db+faP7ZucBU+JzcHBpkeqobPnFktGGd+D8SeJtQvI01tbiWJ/l3JTarqD+qyvwAQDOmvgdLT4lRimTLA6ep95/4NOO8J/WfJSyF98hjwpwnA/eOBijes31sOjhNIBh1vGABT9zgsHWiZQ4FLXgbOeABZ0twcOchU5NbsAE6eORPt4ayfDUJf3tFRF2hJflA70QsBNLg7HvX6UgzAVc3XoBX6L8I9Igc7wmvQyZ11AehPWo3VGNS0xfS+hcpBLC5x6UYGY2aAAV1p1fY4AXB+ugezSnNw99ljcdP8YRg4RJuXM8m2WTewEOnCneF1meeAGObR7nAPQ5XQjzTLGeCjja1obWtHlUN7n8xWbY5OKKc/Bmdb7x+71VwoV0C9QJAajQHaGsAep00/t2v0MuCKN4GZN1h+RsIGTFHn85Wc2vFzI6T5wXNs2qj4VtEPJ5V1cj7yMaLLADe0oF5qgpXmTKIEmoh6ni8XuikftfsQ8DgxLF0bFD4szBlBqyyT5TrAzTXI2a8FbuvaR6IFDl3Z5mub9uNoYys+bpfmfGbFWK7NFSc7GYtxLeC4GWApEDVmgB2RAFgf8AY7yABbleVGB1sj5MBVnqOcLy2FJE33ijmYKp/7rCqXjPOGrbgDwLxfAwt+Dyz/B1B8ClB8svb4Vy/oA+DiU7R/t9RFkwjeJi0j+JWwaEZmoEjl3RWiEK8dyo4uvVWpZMHtkc73NhtQfiOw6G5dwyV1KT7taXabgpzMLGDILPMHhquzbNL5doHtQ/PzgOi1VFvQ3FW8Bl4opk7K4yzfxmm3wWk3T0/qF0pDyOuEx6mFUdEAWG6mWWcIgB1pyMvS/z0bO6LrWDXBikVOoHwbuQ4RwDt3Wz4dez/V/i1XLqQIBsDUPeSAdfAMtQRGUZAljcwehQ9NwuKLQLFhTPFAKPIIlbwunJwBdsYfkfY47bqAoKJBPzpdazOfrHeJXHwshuGOluW6+3eIXOyoUrO6clmp+kFyAHwEjn0bTO87Pr0WA51HtDvc6fFLmYZqJ7S328fGfNrgbC8URcGyiUW4ctZQ2KVOyVOkOcyH7FnRcvBMv0udkxMp7Q0NNHVg9nvdeNNQBl1nWB/4aGMr9iFGN8F4I4zGMh9A+10YtiNSKVCU4Y2/hm13GnFm9J/yAMN220CM7vcdungeA6Yu0MwAE/Vddoc++KpRBxlHBLVz0CGYzyN+iwywP1YJ9J63ozetzjWrP1F7HHwlBuCO0J3AwruBBXdZb29Xl0DLAWL9IctlkPxuB1wOi0Al1ltaLD139iRD3xddACxdR8QKJGIFslL/CLn7sPa6BM4fnvC1w5QrgKHhBl3DTtMe3/wy8O0G7faQWdAPoqhZYHu9lg3e2t7PVEUQT0V7IXaLXNzV+j1saB+CNQU/Teh1Npuim5uen+5Ru3BbNVsMr7HtyNYGCkptMZo9RYJBi2qwOptfX8aeMcj6GiQszeLvoV9GGhRFQWFQO3YyfZEMsNzF2hAAe4Lon6G/boobAFtlgGMJFlnfv2MtcHCr/r66g/rlkgpiX1MerxgAU/eQ29hLB2mWTz4RKZalxupi8AoUeVRYDoDlE16chhsR+VK33U8O67+I3mgZZXx6tEz4r21z8b9bT0eTcOLvrSdjH7KiAXCDFFQoCqDo5iVV608+YROCddE5XADiZ38BYPLl+Gr6H3FJ83/gLcNFyZ/OG4+Rhen48exiFOcaLn50a/NqJU57Fa1UOTNyQXDu34Gz/wJc9rpa5iVJ9zjxzzZ9AKwrnYMaYO1qj9HR3Li8g8wyAA7vS8M84Mrw+sRFhpNIj8ofbXkCackerltSoyfI891a2gQqa7RMUYfLIBFR72MxD3iKW6uyshmzW7AugY52gZa/x+sPwnVY693wdrt5Csf6nUe09xg5F5h8eezpO11dAi2fa+WmPkB0QFxRFORIg+0dzQEOpukfv2T6IFww1RCUy79jeeA62N862I2VAZ7yQ/X52aXA2HPNj3d2DnDpXK3Uua5SPwWtcLw+AAz/3pRarWJrHzLR4o6xzQZHRRoOhM/Lf247HWc1/wrNxYmvFiCXQUfLikvnm58Y/rtQEpniFN4H9swBukagANBgD+h//hjlzxFW58nIdhaEtGMnmlyRM8D1VaYAeECmPlFjNTgVZcwAx/t7iHUMAsD6v+pvy9lfXw5LoIm6jNzGXgrIsgylSZEvUZ1IUCuPCh/R1uNNpgQa0JdBf3hQ//nvGE72bbBhr4h8USq4q/U8lDX9Bbe2XgoA2HkoHABLJdBpTjsU+Uuq4bD+yyZskPOQftH2jgJguxNNw5aEs7BaUOV12XH62EK8eM0M3DDPYt1c6fct+6ZN+5LO8IW/uD3pwMizLBsipKc58W67NrrdIFy6+biAulD8thaLYHbAiUD/yTF/NNMoJ6Dtd0MAHCmBdvRwYGky/gLTXVmDe35U1Xgx9620rEdCyyARUe8iX6zW7APW/Qmlu56O3lUyxrwck1UJdKQCRF6BQVbRXoDdIv40oVmR9cxjVS91KgOcTAAsnW9a6vSPSQ2lhuRo2zEoK/42zSjRzo2XTB+E204bYa42Kluo/btkrvZvRVHPoUaxfoahs9VGmld/aD0QnGgJtFFaBjDoJOvn543Un+MjSyHVaM0bDyKkD/Lj2CYKYVyJoTQv8dJ3OQCMBpTpBWpPD1kw/HeRSACcrZbk+zwefCv0U6wabAGtezLQ4dJ+xvOkTdGuI6cXa7+jyYPD1zFycF1nDoDlJq5+tyP+ILnx2iheCXQwTgC84f8CrdJcbvmatGCsuft0CuDwP3UPuQRaCsgyfYYA2CoDHBlBlk+KsUqgEzjZFkgB8KbWAkSm9la0F+DLdv2Jt8aVi7bG2EFCZA6w3FgozWnXn+z2rAeaa4wvhbvuW317/44CYFiPFBoHEUxilMV83aJ9SRv3g+XbpDlRCy8ub74Oy+2v45m2Gai3yABvbghBN11asQELfxf/CzZuCbQhAxwOgHVLYfUGo5ai9eWb4RDavKjSsd2wLmgHHHYbAh4HahrVEkkGwER9nLzM2/sP6ksZc4YjWP5juNd+gKZwY0bAOgOc5XNjYJYXh6vqTI8B8afaAOp5Y2xRSL0R68K8M3OAPelqM6n9n6vva1yDXffcUOzHpAD4pvnDAHyFEYXpWqASw+ljCpHtd8PlsGHSwAzrqTZjzlXn7Lr9pj4VmP5TYP3j+gZO8bbTEef8m1AGOMbvfthpwLa39PdlDlHPrf5c4EC403ftAbUpipQB/sH8aXB9vQ44ZO5fYlQhzNcuZfmJ73c5A1woN5YqWwh8u167HS6Btvp7EFCgnLwC+OcdaqAcHpTwuh3YJvIwANr85kZnQO2kbHeqzbZGnxN3+4ydoPPTPXCGG4T+YPpg5AY8yPQ5tbWs4zXB8gQxqjAImwK0C6A4t4MKCVMGOF4AbJHssDnUPjP1B4EtL2vTtYwBcApiAExdr6VRt9i6HJAZuzPGLIEGEgyAOy63ypNKoHeIfPyy5fuYbduAB9vOMq2tW5vWDzhqfAdNNAMsB8AuQwAsnYDabG7Y28MlqNV79AMD8cpXwmJdxMQVIwCWf9bMDuZEAdpada+1T8Jr7ZOi92f7XThYq44s7jnSgO2tmfoAeMJFHTdYMAbATq/a+RpQT9RpmUDDIQBAbr8hWBQqwOIJMea79BRvJqr6n4q8nS8BAI4IHwr6dbIb9TGW4XVpAXC1tgwZS6CJ+iA5AywHvxmDgAufheLNQEHQg2+qtOlBVucOu03BIxedgFe/2AO8Y/6YJ9tmx92M8tIcLXvl8kPNAuobWHYqAwwAZz+mZq1K5sa/6I8VINocumk8o/oF8filU6yfa3ypTdFl9iwpCtDfvDICADVDOXoZ8NlT0nZ2cqm777IMUtlC4CVDU8jIuVhuell7AGiq0U0nmzF+FLDXojmlha+F/trF47Shv7FpWBw50iD+QLk8uGwB8OavtNuRAE9eazkiczAw43r1esPl19YZdjmwU+QB+CL61GZHQB10mHhxQttnHCjuJ02/8jjtWDbRcC1iaoJ1RLvtCWJAlhd3nz0W7209iEtndHCNYFpyK8FqiIiRS4DP/1v997o/AcNOVxuSMQBmCTR1AznLCUWX6TQ2ozCW1AJIIAMszwHu+EtXzgADwCNti7C85Va83z4S1fDpGoI0W6whJztY24zaptboXGAgnE2VR3ul4N9eInVfbGsC9n6m3U4gAxywWJTd2OHSxJNu+aW5SyptCyUSAKdZz5sqkJpAbNlfg29FNna1q8G18OUCJ99m+Tod4yinPJChKGr3SJsTGDILK6+8CA9+f4Jlp86ell1+ZfTfrf2n95qyolCMOW9sgkXUB1kt32dzqB2Aw4/lG85zsRrtFOf6cdWcMlMDybeVSbo1Tq2mnMweJgVRNpt1INaZOcCAWsJ6yu3AwGnxn2d3WGeZO2iI2eVOuk5/O8ZSQh0yBsCKxWV7rCA52M9cRhwJgI0l0FL2F4pdDeK85kGARotGpfuc+uuk0ryAac3peH4wfTCyfC6M7hfE6WOl66C8kVqpcsYgrSGmy4fmNH1pvpIX7t/iy44Gv4CakNhhKONvcSQ3GJFmGCg2Ln9komuCZS6BBoAlE4pwz7njMLKwgwGOZJpgKYp+iauJlwCTfqDd3v0RsH6VulyYvDILA2CiLiI3wAoU6EZlXQ5bNLMIAEedMZbDAfQBcM1ebS3gJOcAyxngCJ/Ljld/NhOXzxgCm9Q1uS04wPTcDK9T11FyZ1U91u88HL09tigU+4Q0eKY+GD2orZOrW8Q8Bo/TZroQ6TADDFhmgSNBasDQITOWWBdQ8oDC1v21aIcN57Xcij/aLoZy6avW83uNTIu9Gy5opl4J3LwLuPD/qRdavZR96ExgycPAiT9B9jn39fTmRMUa4GAGmKgPsmpYM2qpbh1ZuTstYJ0B1pGbSQJ40n227naJYU6nTQFmlhgCJKtS3M6UQCfLqsGUs4MgpavlDgNGnKXdHlzeufcxXkv4883BfbzVI4Yt0t/OswiAaw/o5v/Cn6ueZy3mAAvjElUADqcN0t1OZv4vAJxYnI0Pbz0Fz//kJP26wIoCnP8UcM5fgcve0F07OnMMS0bFqDJzOWz4VtEfL63xsqgWfHEywJa8hgC44Yh2O5GMviwtQxuIcHqtB79kkYRDej9gzi/UAST57/C1lcDXr+u3x9h1PUX03itJOn7IZb4hc0ZVLoNuSbOY1xkZQQ4W6Uc/I+8rj64lcLItCJq/vIpz/SjNC+DWRSPgHaLN2xT9Jpmem+V369rYbztYqwuAJwwMxf6SKxxvXZJscwBF5s8yUhTFNA+4wznAgOn33iLs2Av1Szojgfm/QOzF2uU5O1/uVevFd4tcvB5allizCsAiALbIGvT0BU2ixpwDzP1VQhn97hKr6ynnABP1QVYXwVOv0t2Uu9MCCQTABt+kjdTdHlWoD24nDMgwD6xZZac6WwKdDKv5tQ7zQHe3O+N+YMqVwOxfAMNP79x7GK8lfNkWZbFxrnuMnxurBFrOAPvDc8wtMsBp2YZzus2BpoA+gCpLMgAGELsRVFqGOm/Vp/+ZlQzDdkQywBYqnfoAuMWZXBBqnAPcL9RBdYH8e2uu1XcnTzYAttmBsx5SpwKc8af4+xoApl8LXPsp8JNPtAGMBb/VEi9N1cAzl2rPT9EGWAADYOoOugZY5uBPbsAk/Hmmx6MnULtTP0/2yA51fnF4biiAjkfHoF8GKUI3uj37F8DUq4EFv4OjeI7l9o6Qylae2/AttlVq85AnDMiw/pJTbOrJxyoAHjQj9jIJBsYLmSx/8hngb0UW2sOHf8IBsEUG2GW3YYR0YXS0UVuLMieQwHZFOD36Ue3uyBqkkFCM8nUGwER9kN9wniscDxSO092Vb8wAW0yf0ZEDpQufM2W9CkNpuoE0XflzhPHi3OYAHEmcBzrL6pza0yXQgHodsOAuoPw/TMsKJszlU0uSI/y5FgPGccpis0u1Jk9jztU6BRtLoOUMcOQ6ymdRkWfMAGcOQdCv/12XJtEAq9OMjbDyYwfAB1z9cUiog+r7RQitnthr/lqJNwfYkjFzvneD9FgnmneWzgO+/7Q6rzwRGYP0CYNAvjqdwEqKlj8DDICpO+iWQDKfqOQMpj3dorRLng9qnAdcIy0jBCWhADg9zWFa2Lw0T/qMQB4w/9fAlB8iy28OljO9LpwyXDt5vLpJGznN8rnUNd6sAuCc4eocZauTtbFMKQ6/4UKmwznAgOkzd+kaYCV2YraaA5zmsmPCgJDl83OTCYAB/Um9o1FOSgpLoImOI74c/Vy/aT82PaUwmGQGeOHd6rzVs/8CDCnXl6JCPU9PGawGRC67DQtHW5yrjYGYy9c92SWr7GpfqRjqiKLoryd8OcllgBUFWPowcON2YMmftfuNJdC1+8yPWWSATeWy2aXINFyDdCYDnDS5us0e254AACDKSURBVMwTjLncIwA4PV5c1fJTPNE6G1c3XwO3K7FB/wi3w5gB7uBvy+HWD+LL2XXDqhbdZuIlaldwow7WQD6eMQCmrifPAbb4kpIzsoHMfHOTB/nL3RgAy+vo+vMSGmVVFMXUIKQk1/oLOz3NYZpzm+l3YVZprmXJzvgB4SUTrALgyAi9VQAsrynYAVMGOKE5wPrfu9wA67tkgL0uO4Zk+y0vrpLKAAP6RlidbZxClqxKoB02xbIagoh6ObtDLXWEol7Ujlxieopxqo/VOsD6J4SzROE1bI0N8jK8Lvx6yWj8YtFw/O2yKRicbVHabAzEuquSZ/jp5pLn3pABPlZ0AbBFCXQiHaaNvTjkaruWeqBqm/RYJANsFQAb+qJklyJLuoZI9ziQl94NWf/B5YAz/Dc44qy4Ay1elwMftI/Aza2X42MxDB5ncpVPNY0tutsdBsCAdfYcAHJKk/rsY8ZmA879G3D2KnX5LkD9Oyo+uWe2pxfg8D91vRhrAEd8b/IAvPj5PthtwDmTBwFf5upHI2NlgA/v0AfAScy5zE/3YPtBrWy5JM864FIUBRk+FyprmqL3ZflcCHqdmDI4E+sqqnTPnzAwpP7DMgAeb/4ZIvfHW8DcIGAxMt+huBngzs8BTnPZYbMpGNc/hHe3HtQ9lpNIabbuzULavxNYzooSZ5UBvvjEQQgmmP0nol7m5NuAmf8RM9NpXO0g2TnAxuqQLJ8LmT4XLpsRb01eiwxwd/Ckq0vmbFyj3ec8jgb3jBngVkNH6Xgl0LF4s9RkgwivFb3vc+2xQOw5wPBmqefnSPPR7FJk12vn+tK8gPW6yceaPwe4cq26lvFQ81Q13VMN10zGOb0dOVSnD4ATer03Czj8jf6+9KKerW5TFGDkYnXQbO+natM8q6WTUgQzwNS1hOhwDvDwgnS8f/McrL1pDobk+LUv3wh3rAD4G/0SS8kEwNLFgddlN3XMlGUZMqSRpZtOGW6erzxhQPjLxKopRyQANv4Okih/BqzmACcSAOsHHnZLGWBj+VIssTLAgJr5NsoJJHkBoiuBZgB8LBmXQZo4MAM3LeihUiwiOjbilPmGvE6cMEj9Ti3O9SeWtZIY5wAnVClkDMS683s8Ms81or3V+nl9kbzubVZxciXQsdjs+veplpaWjGSArVZw8KSr84oj+k3AglH5CKY5oSjAhScOMr+mq2QOVq+fOih3N87h9SSw6kW81yf2IovBg9xecs61O9Wmqykc/ALMAFNXq6tU17uNsCr/BeC0S19IxkZYcjZQbnxwaBtwdK92Oz3xLKocAJfk+uOuWZdpOPFHAs5TR+Thjhc2Re+32xSMKQqP1BpHwm0OdU07wJwFt5qXEYexC3RCGdxAvroN4YuCzmSArTIIkbnU4/uHTI8lXQKdPxr48jn137kjknstxTU0RzuGsnwuPHj+BP0xR0THFUVR8OjFJ+D9iipMGZKV1LqsAMxzgDsTAHdnJU/xKfrbO97vvs/uauU3qs0+M4cApfP1lW92d+cbjfnz1Gs0o0gvFbtTHcxvPKI95g6o88XfuwcYMgvIKUMugPdvnoPaplbkJjvw3Q2Mf8vuJEugrzm5BM99qv7Of3ZKgiXMVuXjPTX/lywxAKauJc//dacn1unYGADLo5uRuQuAekI4oAWgyWSAJ0gZy2lDLb6oJMYAOJIB7p/pxbD8AL7aVwMAGF4Q0MrG7E51fkpLuMw6d7g2ShnsBww9Gaj4J1C6IOkvRXkuV4bXCUcigYzNDoxaBnz2JCraC/CZ0AYSEp0D7LDb4Hc7UNukjaxHFogfdywC4Ck/VMuqXH51TUs6ZvpnenHPOWPxwbYqXDZjiGkOPBEdfwIeJ+aO7LgxpBVj0BCrkZ6OqQS6GwNgh0tdTeGbd9Xbky/vvs/uankjgYue127LmdnvUlIbqyOxfA3myzYEwEE1EP/e33Uv8bocvbaponE+u7EJakeKc/14+doZ2H24AeWlCXZxNmbpASCnLKnPpa7VO/9a6fjRQfmzJWMnZ/kk6s/Vzz/Z9aH2WBIZ4FOG5+JXZ43CobpmXDJ9UNznGke+5YB4waiCaAA83RhIe4JaAGzstPf91WoGO3NI0l0y5fksCS2BFHHWf2Jt9lL84KU6tEE7ARgD/HjSPfoA2Bs+kWT4XBic7dPNq046APYEgVPvSO41lLAlE4qwZEKCxyARpTS57DPgccCVSNloT5ZAA8CyR4EnzwdaG9Wut8cruROz1coZibJadtKRpr/fmw1Ufa3d7oMrNPgMgXmyTbAAdare8IIk5lozA9zrMQCmrtXBEkiWTBlg6SSqKGrQuO8z9bZcXp3EiUBRFCyfOrDjJwLINHRZlgPGK2YOwb6jjWhubceVs4bqX5gW0pZpisz/jbDZgOzihLdXFpSWI0qoLE36zPaC8WjCh7q7MxIsgQbUpZC+rW6M3pYvksb3D0UDYK/Lbmo8QUREfYOcAU54kNTUBbqbmmBF+HOBy17v3s/sCf0mAhMuAr55D5j9i86/j98im3nCpWo2PUIO5Bwe/WN9hDEz7XF2w/QfqwxwdoLl09QteIVKXetYZ4ABfQAsS6IEOhnGJlHyxUCay47fLBlt/cJhp6kl2u5g0vN84zlleB7ufPFLNLS04azxiWe9AeulMJLLAOtfL3dDHD8ghH/8W21Klp1sB2giIuo1+mdoywhZLnlkpSdLoFOJogBn3P/d38dYAp05FJh9q/4+OZDrTLfpXuC7lkB3irEJVqAgsSmA1G0YAFPXam3Qmi/FWahcx28IgI2jylmGTGtEoGsCYDnL6nPZEy+fmX0LUDJX7eBoNdLaSflBDz64+WRU1TWpXbOTYGxkpSj6jHJHjEshyRngU0fk466Xv0JdcxtOHp5rfCkREfURU4dk4vIZg/HVvhrcMDfBuYumDDAD4F4tYKiaO+shwGVYP1nOAPfB8mfAPJ+9MyXQyX+oIQBm+XOvwwCYutbp9wGL7gFq9pkXqo9FzuQqdvOXbqZFAOzN6rJ1/wZkaieEogxvnGcaKArQ/4Qu2CIg6HV2ag1XYwAcSnPCnkR3UHMGWHu//KAHr/x0Jr6urMWM4viNxYiIqPdSFAW3LkqyG39PzwGm5BSfAvhygboDwKxbgAFTzc+RM5nGDH8fYVoGqVsywIYSaAbAvQ4DYOp6Nrva+ThRwX7qYt0b1wCTLjG3+LfKAHdR+TMAjCxMx8UnDsLarw/ipgV9u4ufMYBNtAN09PWGbLGxlKh/phf9M5MYJCAiouODJ6i/zQxw7+bNBH7yMVB/SF1T10rucO3ffXQOq7kJVg/MAWYH6F6HATD1TmevUjPHVguxy2sBRyTRATpZiqJg5Rkju+z9u5PbYYPTrqClTQBIfA3giHRP7BJoIiJKYT3dBIuS5wmaBy5kQ2apjbaqtgKzbu62zTqWeqQE2h1Qqx5bw01DGQD3OgyAqfeyCn4BtXGDKwA012j3dWEG+HiiKAoCHicO1TUDOAYZYAbAREQEqNVadre2OkMfnTNKEkUByv+jp7fiO+mRJliKAow5F1j/FyB3BFDUNdPhqPO6oQ6A6BhTFCDLkAVmAJwweR5w0hlgQwDMDDAREUXJ2UQGwNQLmJdB6qbrltPvA676ALjibcCefM8W6loMgKlvMjbC6sIS6OONLgD2J1sCzQCYiIhiGL1M/X9wANBvUs9uCxEAv6kEuptCH0VR51D3wbWTUwFLoKlvMjbCMrbzp5gCbi2ITT4DrP/KSHPyK4SIiMLm/RoYex6QXcILf+oVsvwu5Kd7sO9oI/pnpiHgYTaWGABTX2VshMUMcMKmF2fh/W1VAIATi7M6eLYeM8BERBSTogAFY3p6K4iinHYb/s9Fk/DyF3tx2pjCpJZ+pOMXA2Dqm0wl0MwAJ+qKmUMxKNuHgmAaRhbG6f5oIcg5wERERNSHjOoXxKh+yV3v0PGNATD1Tfmj1G7QdZVAwTg220iCy2HDaWM61zTMmAHutmYSRERERETHAANg6ptcPuDC54CKfwIjzurprUkZAY8DQ7J92HawDjkBN/LSPT29SURERERECWMATH1X3gj1P+o2NpuC/7pgIp779FvMG5kPl4ON5ImIiIio72AATERJKckL4Pq5ZT29GURERERESWP6hoiIiIiIiFICA2AiIiIiIiJKCQyAiYiIiIiIKCUwACYiIiIiIqKUwACYiIiIiIiIUgIDYCIiIiIiIkoJDICJiIiIiIgoJShCCNHTG0HHTiAQQEtLC4YOHdrTm0JERERERJS0iooKOJ1O1NTUHPP3Zgb4OOPz+eB0Ont6M3QqKipQUVHR05tBncT917dx//Vt3H99G/df38b917dx//VtTqcTPp+vS96bGWDqciNHjgQAbNy4sYe3hDqD+69v4/7r27j/+jbuv76N+69v4/6jWJgBJiIiIiIiopTAAJiIiIiIiIhSAgNgIiIiIiIiSgkMgImIiIiIiCglMAAmIiIiIiKilMAu0ERERERERJQSmAEmIiIiIiKilMAAmIiIiIiIiFICA2AiIiIiIiJKCQyAiYiIiIiIKCUwACYiIiIiIqKUwACYiIiIiIiIUgIDYOoyDQ0NuO2221BaWgqPx4PCwkL84Ac/wJ49e3p60wjArFmzoChKzP9eeeUVy9etWrUKkydPht/vR2ZmJhYuXIh169Z189anjk8++QR33XUXlixZgqKiouj+6Uhn9tPatWuxcOFCZGZmwu/3Y/LkyfjrX/96rH6UlJTs/lu5cmXc4/LnP/95zNdy/x1b9fX1ePbZZ3HppZeirKwMHo8HPp8PY8eOxR133IHa2tqYr+Xx1/M6s/94/PUu99xzD5YsWYKSkhIEg0G43W4MHDgQF154IT7//POYr+PxRx0SRF2goaFBTJ06VQAQBQUF4pxzzhGTJ08WAEROTo6oqKjo6U1MeeXl5QKAWLp0qbjoootM/3322Wem11x77bUCgEhLSxNnnnmmmDdvnnA4HMJut4s1a9Z0/w+RAs4880wBwPRfPJ3ZT6tXrxZ2u10oiiLKy8vF0qVLRSgUEgDE9ddf3wU/WWpIdv/dfvvtAoCYPn265XH53//935av4/479h5++OHo/ho+fLg4++yzxbx580QgEBAAxLBhw8T+/ftNr+Px1zt0Zv/x+OtdsrKyhMfjEZMnTxaLFy8WixcvFqWlpQKAcDqd4vnnnze9hscfJYIBMHWJW2+9VQAQ06ZNEzU1NdH7//CHPwgAory8vOc2joQQWgC8ffv2hJ7/2muvCQAiKytLbNmyJXr/unXrhMvlEqFQSBw+fLhrNjaF3XXXXWLFihXiueeeE3v37hVutztuANWZ/VRVVSXS09MFAPHMM89E79+3b58oLi4WAMSbb755rH+0lJDs/otcgD/22GMJfwb3X9dYtWqVuOKKK8SmTZt093/77bdi/PjxAoA477zzdI/x+Os9OrP/ePz1Lu+9955oaGgw3f/ggw8KACIvL0+0tLRE7+fxR4liAEzHXFNTkwgGgwKAWL9+venxMWPGCADi448/7oGto4hkA+AFCxYIAOKPf/yj6bFrrrlGABB33333sd1IMukogOrMfvrtb38rAIgzzzzT9Jp//OMfAoA47bTTvuumk+h4/3XmApz7r/utW7dOABBut1s0NTVF7+fx1zfE2n88/vqOoUOHCgDi008/jd7H448SxTnAdMytXbsW1dXVGDp0KMaPH296fNmyZQCA559/vrs3jTqpoaEBb7zxBgBt/8m4T3uHzu6nF198MeZrFi1aBI/Hg9dffx2NjY3HepPpGOD+635jx44FADQ1NaGqqgoAj7++xGr/dRb3X89wOp0AAJfLBYDHHyXH0dMbQMefTz/9FAAwYcIEy8cj93/22Wfdtk0U2yOPPIKqqirYbDaUlpbirLPOwoABA3TP2bx5M5qampCTk4OioiLTe3Cf9g6d3U/xjlmXy4VRo0bh448/xpYtWzBmzJgu2HIyeuONN7BhwwY0NjaiqKgICxYswMSJEy2fy/3X/bZt2wZAvQjPzMwEwOOvL7HafzIef73b448/js2bN6OkpAQlJSUAePxRchgA0zG3c+dOALD8ApLv37FjR7dtE8X2q1/9Snf7hhtuwIoVK7BixYrofR3tU5/Ph1AohMOHD6OmpgaBQKDrNphi6sx+Onr0KKqrq+O+rqioCB9//DF27NjBC4Bu8vjjj+tur1ixAkuXLsWqVavg9/uj93P/9Yz77rsPADB//ny43W4APP76Eqv9J+Px17v8/ve/x8aNG1FXV4cvv/wSGzduRGFhIZ544gnY7XYAPP4oOSyBpmMusrSA1+u1fNzn8wEAampqum2byGzmzJl4/PHHUVFRgfr6emzevBl33nknHA4HbrvttugFAtDxPgW4X3uDzuwneSkQHrM9r7i4GHfffTc2btyI2tpa7Nq1C3//+9/Rr18/PPPMM7jgggt0z+f+634vvfQSHnnkETidTvzyl7+M3s/jr2+Itf8AHn+91f/8z//gL3/5C1avXo2NGzdi4MCBeOKJJ3RZeR5/lAwGwEQp6o477sDy5csxZMgQpKWlobS0FLfccgueffZZAOp6iA0NDT27kUQpZvny5bj++usxYsQI+Hw+FBUV4fzzz8dHH32ErKwsPPvss/jggw96ejNT1ldffYXly5dDCIHf//730bmk1Dd0tP94/PVOr7/+OoQQOHz4MN555x2UlJSgvLwcd955Z09vGvVRDIDpmIuUB9XX11s+XldXBwAsk+2l5s6di0mTJuHIkSP417/+BaDjfQpwv/YGndlPcjkfj9neq6CgAJdccgkA4JVXXonez/3Xffbs2YP58+fj8OHDuO6663DttdfqHufx17t1tP/i4fHXO4RCIcyYMQMvvfQSJk6ciBUrVuCjjz4CwOOPksMAmI65SAOl3bt3Wz4euX/gwIHdtk2UnEhTib179wLoeJ/W1dXhyJEjyMjI4EmiB3VmP6WnpyMYDMZ9HY/Z3sF4XALcf93l0KFDmDt3Lnbs2IFLLrkEd999t+k5PP56r0T2X0d4/PUeTqcT5557LoQQ0a7OPP4oGQyA6ZiLlBStX7/e8vHI/Wwm0HsdPnwYgDb3paysDG63G5WVldizZ4/p+dynvUNn91O8Y7alpQVffPEFPB4PSktLu2CrKVHG4zKC+69r1dbWYsGCBdi0aROWLFmChx9+GIqimJ7H4693SnT/dYTHX++SnZ0NAKisrATA44+SwwCYjrnp06cjGAyioqICGzZsMD2+evVqAMDpp5/ezVtGiaisrMS7774LQFsWIC0tDXPmzAEAPP3006bXcJ/2Dp3dT4sWLdI9LnvhhRfQ2NiIU045BR6P51hvMiVICIE1a9YAMC/Xwf3XdZqamnDmmWfiww8/xLx583RdZ414/PU+yey/eHj89T5vv/02AGDo0KEAePxRkgRRF7j11lsFAHHiiSeK2tra6P1/+MMfBABRXl7ecxtHYu3atWLNmjWitbVVd//27dvF9OnTBQBxxhln6B577bXXBACRlZUltmzZEr1/3bp1wu12i1AoJA4fPtwdm5/S3G63iPfV3Zn9VFVVJdLT0wUA8cwzz0Tv379/vyguLhYAxJtvvnmsf5SUFG//HThwQDzwwAPi6NGjuvtramrED3/4QwFA5Ofni7q6Ot3j3H9do7W1VSxevFgAEDNmzDD93q3w+Os9kt1/PP56l/fee0+8/PLLoq2tTXd/c3OzuP/++4XNZhNpaWli586d0cd4/FGiGABTl2hoaBBTpkwRAERBQYE455xzordzcnJERUVFT29iSnvssceiJ/OFCxeK888/X0yfPl14PB4BQIwcOVLs37/f9Lprr71WABBer1eceeaZYsGCBcLhcAi73S7WrFnT/T9ICnjhhRfElClTov8piiIA6O574YUXdK/pzH5avXq1sNlsQlEUMXv2bLFs2TIRCoUEAHHdddd1w096fEpm/23fvl0AEH6/X8yePVucf/754tRTTxVZWVkCgAiFQuK9996z/Bzuv2Pv3nvvFQAEALF48WJx0UUXWf5XWVmpex2Pv94h2f3H4693iVynZGdni3nz5onzzz9fzJ07VxQUFAgAwuPxiKeeesr0Oh5/lAgGwNRl6uvrxYoVK8TQoUOFy+US+fn54uKLLxa7du3q6U1LeZs2bRJXXnmlmDBhgsjJyREOh0MEg0ExdepU8Yc//EHU19fHfO1jjz0mJk6cKLxerwiFQmL+/Pli7dq13bj1qSVyERDvv8cee8zydcnup/fee0/Mnz9fhEIh4fV6xaRJk8SqVau66CdLDcnsv6NHj4qbbrpJlJeXi379+gm32y28Xq8YOXKkuP7668Xu3bvjfhb337F1++23d7jvAIjt27ebXsvjr+clu/94/PUu27ZtE7fccouYPn26KCgoEE6nU/h8PjFy5Ejxk5/8RGzdujXma3n8UUcUIYRItmyaiIiIiIiIqK9hEywiIiIiIiJKCQyAiYiIiIiIKCUwACYiIiIiIqKUwACYiIiIiIiIUgIDYCIiIiIiIkoJDICJiIiIiIgoJTAAJiIiIiIiopTAAJiIiIiIiIhSAgNgIiIiIiIiSgkMgImIiIiIiCglMAAmIiIiIiKilMAAmIiIqJeqq6vDPffcg9mzZyMvLw8ulwsZGRmYNm0abrvtNuzcuTP63IsvvhiKouCtt97quQ3uYStXroSiKFi1alVPbwoREfVSjp7eACIiIjJbt24dli5din379sHr9WLq1KnIy8tDdXU1PvroI3zwwQf43e9+hxdeeAGnnHJKT28uERFRn8AAmIiIqJfZsGEDTj75ZDQ2NuKmm27CihUr4PP5oo+3t7fj2WefxY033ojdu3f34JYSERH1LQyAiYiIehEhBC644AI0NjZi5cqVuP32203PsdlsWLJkCU4++WTs2rWrB7aSiIiob+IcYCIiol7klVdewRdffIGioiLceuutcZ8bDAYxatQo0/3vvPMO5syZg0AggPT0dCxatAibNm0yPe/IkSP405/+hHnz5mHgwIFwu93IysrC/Pnz8dprr1l+5qxZs6AoCr755hs8++yzmDp1Knw+HzIzM3HeeedZZqTl+cmJbpv8+1i0aBFycnLgdrsxZMgQXHfddaiqqor7uyEiIrLCAJiIiKgXefHFFwEAZ599NhyO5Au1nn/+ecyZMwf19fVYuHAhCgoK8NJLL2HmzJnYt2+f7rkffPABrrnmGmzZsgVlZWVYvHgxysrK8Oqrr2LevHl49NFHY37OQw89hGXLliEtLQ0LFy6E3+/Hk08+iTlz5qChoeE7bxsA/PznP8eCBQvw+uuvo6ysDGeccQYcDgf++Mc/YsqUKdi/f3/Svx8iIkptDICJiIh6kQ0bNgAAJkyY0KnX33vvvVi9ejU++OADPPXUU9i0aROWLl2KqqoqPPTQQ7rnlpWV4f3338f27dvx6quv4sknn8S6devwySefIBgM4mc/+xlqa2stP+fBBx/Eu+++izfffBNPP/00vvrqK5x44onYunUrnnjiie+8bU8//TR++9vfYtSoUdi4cSPee+89PP3009i8eTNuu+02VFRU4Nprr+3U74iIiFIXA2AiIqJeJFLam5OT06nXn3feeTjrrLOit+12O26++WYAamm0bPDgwZg6darpPcaPH4+rr74aR48exZtvvmn5OT/72c8wbdq06G2v14vrrrvO8nM6s2133nknAOCJJ55AcXFx9H5FUbBy5UqMGzcOq1evxsGDBy0/i4iIyAqbYBERER1H5s6da7qvtLQUALB3717TY21tbfjnP/+JdevWYe/evWhqagIAbN26Vff/7/o5ybzmwIED+PTTT1FSUmI5x1lRFEyfPh0bNmzAJ598gnnz5ll+HhERkREDYCIiol4kKysLAFBZWdmp1xcVFZnuCwQCABANbiN2796N0047DZ9++mnM96upqfnOn5Psa7755hsAavCtKErMbQPADDARESWFATAREVEvMm7cOKxduxbr16/H8uXLk369zZb47KbLLrsMn376KZYuXYobb7wRZWVlCAQCsNls+POf/4wf/vCHEEJ8589J9jXt7e0AgPz8/A6zuwMHDkx6O4iIKHUxACYiIupFFi1ahAcffBBPP/00fve733WqE3Qi6urq8NprryEvLw9PPfUU7Ha77vFt27Z1yecmIpIpzs7OxqpVq3psO4iI6PjDJlhERES9yPz58zFy5Ejs3r072ggqlqNHj2Ljxo2d+pzq6mq0t7ejoKDAFPy2tLRgzZo1nXrfY6GoqAjDhg3Dpk2bsGXLlh7bDiIiOv4wACYiIupFFEXB3/72N3g8HqxcuRI333wz6urqdM8RQuC5557DpEmT8NFHH3Xqc3JzcxEMBvHFF19g7dq10fvb2tpw00039XjguWLFCrS3t2Pp0qXRpaFkVVVVePjhh7t/w4iIqE9jCTQREVEvM27cOLz++utYunQp7rrrLtx///2YNm0a8vLyUF1djY8//hj79++Hx+NB//79O/UZDocDN954I2699VaUl5djzpw5yMzMxL/+9S/s378fV199NR588MFj/JMl7vzzz8fGjRvx61//GhMnTsS4ceMwdOhQCCFQUVGBzz77DH6/H5dffnmPbSMREfU9DICJiIh6oenTp+Prr7/Gf/3Xf+H555/HZ599hsOHD8Pv96OsrAw/+tGPcNlll1l2Vk7ULbfcgqKiItx7771Yu3Yt0tLScNJJJ+GOO+7A+vXrj+FP0zl33nkn5s2bhwceeABr167F559/jvT0dPTr1w9XXnklzj777J7eRCIi6mMUEau9IxEREREREdFxhHOAiYiIiIiIKCUwACYiIiIiIqKUwACYiIiIiIiIUgIDYCIiIiIiIkoJDICJiIiIiIgoJTAAJiIiIiIiopTAAJiIiIiIiIhSAgNgIiIiIiIiSgkMgImIiIiIiCglMAAmIiIiIiKilMAAmIiIiIiIiFICA2AiIiIiIiJKCQyAiYiIiIiIKCUwACYiIiIiIqKUwACYiIiIiIiIUgIDYCIiIiIiIkoJDICJiIiIiIgoJTAAJiIiIiIiopTAAJiIiIiIiIhSAgNgIiIiIiIiSgkMgImIiIiIiCglMAAmIiIiIiKilMAAmIiIiIiIiFICA2AiIiIiIiJKCQyAiYiIiIiIKCUwACYiIiIiIqKU8P8BPa1Ybbz4isMAAAAASUVORK5CYII=", - "text/html": [ - "\n", - "
\n", - "
\n", - " Figure\n", - "
\n", - " \n", - "
\n", - " " - ], + "image/png": "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", "text/plain": [ - "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …" + "
" ] }, "metadata": {}, @@ -301,7 +276,7 @@ "id": "3ba825a2-2ca3-4d8a-8ebc-456eaf337f13", "metadata": {}, "source": [ - "The difference is subtle, but the top panel shows that the spectral line is well aligned in velocity, whereas the bottom panel shows that the line centroids are slightly misaligned. If we were to average the two spectra toegether, the resulting line would look artificially broader than it is!" + "The difference is subtle, but the top panel shows that the spectral line is well aligned in velocity, whereas the bottom panel shows that the line centroids are slightly misaligned. If we were to average the two spectra together, the resulting line would look artificially broader than it is!" ] }, { From 1003348acfdfdf98f234461c8b372b3ea9b906bd Mon Sep 17 00:00:00 2001 From: astrofle Date: Thu, 10 Oct 2024 15:32:59 -0400 Subject: [PATCH 39/95] Add: find_shift method --- src/dysh/spectra/spectrum.py | 49 ++++++++++++++++++++++++++++++++++++ 1 file changed, 49 insertions(+) diff --git a/src/dysh/spectra/spectrum.py b/src/dysh/spectra/spectrum.py index a0996cb2..47e0c026 100644 --- a/src/dysh/spectra/spectrum.py +++ b/src/dysh/spectra/spectrum.py @@ -557,6 +557,55 @@ def shift(self, s, remove_wrap=False, fill_value=np.nan, method="fft"): new_spectral_axis_values = self.wcs.spectral.pixel_to_world(np.arange(self.flux.shape[-1])) self._spectral_axis = self.spectral_axis.replicate(value=new_spectral_axis_values) + def find_shift(self, other, units=None, frame=None): + """ + Find the shift required to align this `Spectrum` with `other`. + + Parameters + ---------- + other : `Spectrum` + Target `Spectrum` to align to. + units : {None, `astropy.units.Quantity`} + Find the shift to align the two `Spectra` in these units. + If `None`, the `Spectra` will be aligned using the units of + `other`. + frame : {None, str} + Find the shift in this reference frame. + If `None` will use the frame of `other`. + + Returns + ------- + shift : float + Number of channels that this `Spectrum` must be shifted to + be aligned with `other`. + """ + + if not isinstance(other, Spectrum): + raise ValueError("`other` must be a `Spectrum`.") + + if frame is not None: + if frame not in astropy_frame_dict.keys(): + raise ValueError( + f"`frame` ({frame}) not recognized. Frame must be one of {', '.join(list(astropy_frame_dict.keys()))}" + ) + else: + sa = self.spectral_axis.with_observer_stationary_relative_to(frame) + tgt_sa = other.spectral_axis.with_observer_stationary_relative_to(frame) + else: + sa = self.spectral_axis.with_observer_stationary_relative_to(other._velocity_frame) + tgt_sa = other.spectral_axis.with_observer_stationary_relative_to(other._velocity_frame) + + if units is None: + units = tgt_sa.unit + + sa = sa.to(units) + tgt_sa = tgt_sa.to(units) + + cdelt1 = sa[1] - sa[0] + shift = ((sa[0] - tgt_sa[0]) / cdelt1).value + + return shift + @property def equivalencies(self): """Get the spectral axis equivalencies that can be used in converting the axis From 49c0a0e366affc87c33966525560e989fa76d243 Mon Sep 17 00:00:00 2001 From: astrofle Date: Thu, 10 Oct 2024 15:33:23 -0400 Subject: [PATCH 40/95] Add: tests for find_shift method --- src/dysh/spectra/tests/test_spectrum.py | 37 ++++++++++++++++++++++++- 1 file changed, 36 insertions(+), 1 deletion(-) diff --git a/src/dysh/spectra/tests/test_spectrum.py b/src/dysh/spectra/tests/test_spectrum.py index dfbe4a17..42a6b1e1 100644 --- a/src/dysh/spectra/tests/test_spectrum.py +++ b/src/dysh/spectra/tests/test_spectrum.py @@ -393,7 +393,6 @@ def test_smooth_and_slice(self): abs(self.ss.meta["CDELT1"]) * self.ss.meta["FWHM"], abs=abs(self.ss.meta["CDELT1"]) / 9.0 ) - @pytest.mark.filterwarnings("ignore:Beware:UserWarning") def test_shift(self): """Test the shift method against the results produced by GBTIDL""" @@ -426,3 +425,39 @@ def test_shift(self): assert spec.spectral_axis[0].to("Hz").value == ( org_spec.spectral_axis[0].to("Hz").value - spec.meta["CDELT1"] * shift ) + + def test_find_shift(self): + """ + Test the find_shift method. + * Test that the shift with respect to itself is zero. + * Test that it can find an integer shift. + * Test that it can find a fractional shift. + * Test that it can find a shift in velocity units. + * Test that it can find a shift in a different frame. + """ + spec = Spectrum.fake_spectrum(seed=1) + + # Shift should be zero. + assert spec.find_shift(spec) == pytest.approx(0) + + chan_wid = np.mean(np.diff(spec._spectral_axis)) + + # Shift by one channel. + spec2 = spec._copy() + spec2._spectral_axis = spec2.spectral_axis.replicate(value=spec2.spectral_axis + chan_wid) + assert spec.find_shift(spec2) == pytest.approx(-1) + + # Shift by one and a half channels. + spec3 = spec._copy() + spec3._spectral_axis = spec3.spectral_axis.replicate(value=spec3.spectral_axis + chan_wid * 1.5) + assert spec.find_shift(spec3) == pytest.approx(-1.5) + + # Shift in velocity. + spec4 = spec._copy() + velo = spec4.spectral_axis.replicate(value=spec4.spectral_axis.to("km/s")) + dvel = velo[1] - velo[0] + spec4._spectral_axis = spec4.spectral_axis.replicate(value=velo + dvel * 0.5) + assert spec.find_shift(spec4) == pytest.approx(-0.5) + + # Shift in a different frame. + assert spec.find_shift(spec4, frame="lsrk") == pytest.approx(-0.5) From 9f2d5b2918844f69aa58123a16fa81560ad9ebe6 Mon Sep 17 00:00:00 2001 From: astrofle Date: Thu, 10 Oct 2024 16:28:35 -0400 Subject: [PATCH 41/95] Add: align_to method --- src/dysh/spectra/spectrum.py | 41 +++++++++++++++++++++++++++++++----- 1 file changed, 36 insertions(+), 5 deletions(-) diff --git a/src/dysh/spectra/spectrum.py b/src/dysh/spectra/spectrum.py index 47e0c026..7a3a4a0c 100644 --- a/src/dysh/spectra/spectrum.py +++ b/src/dysh/spectra/spectrum.py @@ -524,7 +524,7 @@ def smooth(self, method="hanning", width=1, decimate=0, kernel=None): return s - def shift(self, s, remove_wrap=False, fill_value=np.nan, method="fft"): + def shift(self, s, remove_wrap=True, fill_value=np.nan, method="fft"): """ Shift the `Spectrum` by `s` channels in place. @@ -532,11 +532,11 @@ def shift(self, s, remove_wrap=False, fill_value=np.nan, method="fft"): ---------- s : float Number of channels to shift the `Spectrum` by. - wrap : bool - If `True` allow spectrum to wrap around the edges. - If `False` fill channels that wrap with `fill_value`. + remove_wrap : bool + If `False` keep channels that wrap around the edges. + If `True` fill channels that wrap with `fill_value`. fill_value : float - If `wrap=False` fill channels that wrapped with this value. + If `remove_wrap=True` fill channels that wrapped with this value. method : "fft" Method used to perform the fractional channel shift. "fft" uses a phase shift. @@ -554,8 +554,11 @@ def shift(self, s, remove_wrap=False, fill_value=np.nan, method="fft"): self.wcs.wcs.crpix[0] += s # Update `SpectralAxis` values. + # Radial velocity needs to be copied by hand. + radial_velocity = deepcopy(self._spectral_axis._radial_velocity) new_spectral_axis_values = self.wcs.spectral.pixel_to_world(np.arange(self.flux.shape[-1])) self._spectral_axis = self.spectral_axis.replicate(value=new_spectral_axis_values) + self._spectral_axis._radial_velocity = radial_velocity def find_shift(self, other, units=None, frame=None): """ @@ -606,6 +609,34 @@ def find_shift(self, other, units=None, frame=None): return shift + def align_to(self, other, units=None, frame=None, remove_wrap=True, fill_value=np.nan, method="fft"): + """ + Align the `Spectrum` with respect to `other`. + + Parameters + ---------- + other : `Spectrum` + Target `Spectrum` to align to. + units : {None, `astropy.units.Quantity`} + Find the shift to align the two `Spectra` in these units. + If `None`, the `Spectra` will be aligned using the units of + `other`. + frame : {None, str} + Find the shift in this reference frame. + If `None` will use the frame of `other`. + remove_wrap : bool + If `True` allow spectrum to wrap around the edges. + If `False` fill channels that wrap with `fill_value`. + fill_value : float + If `wrap=False` fill channels that wrapped with this value. + method : "fft" + Method used to perform the fractional channel shift. + "fft" uses a phase shift. + """ + + s = self.find_shift(other, units=units, frame=frame) + self.shift(s, remove_wrap=remove_wrap, fill_value=fill_value, method=method) + @property def equivalencies(self): """Get the spectral axis equivalencies that can be used in converting the axis From 04357ec4e78cce00c00acca5040642778894af15 Mon Sep 17 00:00:00 2001 From: astrofle Date: Thu, 10 Oct 2024 16:29:09 -0400 Subject: [PATCH 42/95] Add: tests for align_to method --- src/dysh/spectra/tests/test_spectrum.py | 34 ++++++++++++++++++++++--- 1 file changed, 31 insertions(+), 3 deletions(-) diff --git a/src/dysh/spectra/tests/test_spectrum.py b/src/dysh/spectra/tests/test_spectrum.py index 42a6b1e1..260b1c11 100644 --- a/src/dysh/spectra/tests/test_spectrum.py +++ b/src/dysh/spectra/tests/test_spectrum.py @@ -26,14 +26,14 @@ def fit_gauss(spectrum): return g_fit -def compare_spectrum(one, other): +def compare_spectrum(one, other, ignore_history=False): """ """ for k, v in vars(one).items(): if k in IGNORE_ON_COPY: continue - # elif k in ["_data", "_mask", "_weights"]: - # assert np.all(v == vars(other)[k]) + if ignore_history and k == "_history": + continue elif k in ["_wcs"]: v.to_header() == vars(other)[k].to_header() elif k in ["_spectral_axis"]: @@ -411,6 +411,9 @@ def test_shift(self): shift = 5.5 spec.shift(shift) + # Internal tests. + assert np.all(np.isnan(spec[: int(np.round(shift))].data)) + # Load GBTIDL answer. with fits.open(get_project_testdata() / "gshift_box.fits") as hdu: table = hdu[1].data @@ -461,3 +464,28 @@ def test_find_shift(self): # Shift in a different frame. assert spec.find_shift(spec4, frame="lsrk") == pytest.approx(-0.5) + + def test_align_to(self): + """ + Tests for align_to method. + * Test that align_to itself does not change the spectrum. + """ + + spec = Spectrum.fake_spectrum(nchan=1024, seed=1) + org_spec = spec._copy() + + # Align to itself. + spec.align_to(spec) + compare_spectrum(spec, org_spec, ignore_history=True) + assert np.all((spec - org_spec).data == 0) + + # Align to a shifted version. + shift = 5 + spec.shift(shift) + assert np.all((spec.data[shift:] - org_spec.data[:-shift]) == 0.0) + + # Align to a shifted version with signal. + spec = self.ss._copy() + org_spec = spec._copy() + spec.shift(5.5) + assert spec.max().value == pytest.approx(org_spec.max().value, abs=0.06) From e29a8c36d6f9feb1bdf197549c4a415db4f86390 Mon Sep 17 00:00:00 2001 From: astrofle Date: Fri, 11 Oct 2024 09:32:32 -0400 Subject: [PATCH 43/95] Refactor: handling of frame for find_shift --- src/dysh/spectra/spectrum.py | 18 ++++++++---------- 1 file changed, 8 insertions(+), 10 deletions(-) diff --git a/src/dysh/spectra/spectrum.py b/src/dysh/spectra/spectrum.py index 7a3a4a0c..fae5e677 100644 --- a/src/dysh/spectra/spectrum.py +++ b/src/dysh/spectra/spectrum.py @@ -586,17 +586,15 @@ def find_shift(self, other, units=None, frame=None): if not isinstance(other, Spectrum): raise ValueError("`other` must be a `Spectrum`.") - if frame is not None: - if frame not in astropy_frame_dict.keys(): - raise ValueError( - f"`frame` ({frame}) not recognized. Frame must be one of {', '.join(list(astropy_frame_dict.keys()))}" - ) - else: - sa = self.spectral_axis.with_observer_stationary_relative_to(frame) - tgt_sa = other.spectral_axis.with_observer_stationary_relative_to(frame) + if frame is not None and frame not in astropy_frame_dict.keys(): + raise ValueError( + f"`frame` ({frame}) not recognized. Frame must be one of {', '.join(list(astropy_frame_dict.keys()))}" + ) else: - sa = self.spectral_axis.with_observer_stationary_relative_to(other._velocity_frame) - tgt_sa = other.spectral_axis.with_observer_stationary_relative_to(other._velocity_frame) + frame = other._velocity_frame + + sa = self.spectral_axis.with_observer_stationary_relative_to(frame) + tgt_sa = other.spectral_axis.with_observer_stationary_relative_to(frame) if units is None: units = tgt_sa.unit From 5269bc3554faf5b22968f0eff3ba95ee567224be Mon Sep 17 00:00:00 2001 From: astrofle Date: Fri, 11 Oct 2024 09:55:58 -0400 Subject: [PATCH 44/95] Add: self consistent test for align_to --- src/dysh/spectra/tests/test_spectrum.py | 11 +++++++++-- 1 file changed, 9 insertions(+), 2 deletions(-) diff --git a/src/dysh/spectra/tests/test_spectrum.py b/src/dysh/spectra/tests/test_spectrum.py index 260b1c11..b629e0f0 100644 --- a/src/dysh/spectra/tests/test_spectrum.py +++ b/src/dysh/spectra/tests/test_spectrum.py @@ -61,6 +61,7 @@ def setup_method(self): self.ss.meta["FREQRES"] = abs(self.ss.meta["CDELT1"]) self.ss.meta["FWHM"] = fwhm self.ss.meta["CENTER"] = self.ss.spectral_axis[mean].value + self.ss.meta["STDD"] = stdd def test_add(self): """Test that we can add two `Spectrum`.""" @@ -485,7 +486,13 @@ def test_align_to(self): assert np.all((spec.data[shift:] - org_spec.data[:-shift]) == 0.0) # Align to a shifted version with signal. + fshift = 0.5 spec = self.ss._copy() org_spec = spec._copy() - spec.shift(5.5) - assert spec.max().value == pytest.approx(org_spec.max().value, abs=0.06) + spec.shift(shift + fshift) + # The amplitude of the signal will decrease because of the sampling. + tol = np.sqrt( + (1 - np.exp(-0.5 * (fshift) ** 2 / spec.meta["STDD"] ** 2)) ** 2.0 + + (np.nanstd(spec.data[: len(spec.data) - 50])) ** 2.0 + ) + assert spec.max().value == pytest.approx(org_spec.max().value, abs=3 * tol) From 7267030b7fb3cdafbf0c4e6e5adb713f7eca9638 Mon Sep 17 00:00:00 2001 From: astrofle Date: Fri, 11 Oct 2024 12:09:52 -0400 Subject: [PATCH 45/95] Add: average_spectra function --- src/dysh/spectra/spectrum.py | 63 ++++++++++++++++++++++++++++++++++++ 1 file changed, 63 insertions(+) diff --git a/src/dysh/spectra/spectrum.py b/src/dysh/spectra/spectrum.py index fae5e677..909be8d0 100644 --- a/src/dysh/spectra/spectrum.py +++ b/src/dysh/spectra/spectrum.py @@ -1509,3 +1509,66 @@ def spectrum_reader_gbtidl(fileobj, **kwargs): # registry.register_writer("ipac", Spectrum, ascii_spectrum_reader_ipac) # registry.register_writer("votable", Spectrum, spectrum_reader_votable) # registry.register_writer("mrt", Spectrum, spectrum_reader_mrt) + + +def average_spectra(spectra, equal_weights=False): + """ + Average `spectra`. + + Parameters + ---------- + spectra : list of `Spectrum` + Spectra to be averaged. They must have the same number of channels. + No checks are done to ensure they are aligned. + equal_weights : bool + If `False` use the inverse of the variance, as computed from the radiometer equation, as weights. + If `True` all spectra have the same weight. + + Returns + ------- + average : `Spectrum` + Averaged spectra. + """ + + nspec = len(spectra) + nchan = len(spectra[0].data) + shape = (nspec, nchan) + data_array = np.empty(shape, dtype=float) + weights = np.empty(shape, dtype=float) + exposures = np.empty(nspec, dtype=float) + tsyss = np.empty(nspec, dtype=float) + xcoos = np.empty(nspec, dtype=float) + ycoos = np.empty(nspec, dtype=float) + + units = spectra[0].flux.unit + + for i, s in enumerate(spectra): + if not isinstance(s, Spectrum): + raise ValueError(f"Element {i} of `spectra` is not a `Spectrum`.") + if units != s.flux.unit: + raise ValueError( + f"Element {i} of `spectra` has units {s.flux.unit}, but the first element has units {units}." + ) + data_array[i] = s.data + weights[i] = core.tsys_weight(s.meta["EXPOSURE"], s.meta["CDELT1"], s.meta["TSYS"]) + exposures[i] = s.meta["EXPOSURE"] + tsyss[i] = s.meta["TSYS"] + xcoos[i] = s.meta["CRVAL2"] + ycoos[i] = s.meta["CRVAL3"] + + data_array = np.ma.MaskedArray(data_array, mask=np.isnan(data_array)) + data = np.ma.average(data_array, axis=0, weights=weights) + tsys = np.ma.average(tsyss, axis=0, weights=weights[:, 0]) + xcoo = np.ma.average(xcoos, axis=0, weights=weights[:, 0]) + ycoo = np.ma.average(ycoos, axis=0, weights=weights[:, 0]) + exposure = exposures.sum(axis=0) + + new_meta = deepcopy(spectra[0].meta) + new_meta["TSYS"] = tsys + new_meta["EXPOSURE"] = exposure + new_meta["CRVAL2"] = xcoo + new_meta["CRVAL3"] = ycoo + + averaged = Spectrum.make_spectrum(data * units, meta=new_meta) + + return averaged From 544a84c613f088efe6fc48bb3e9f453a6641d732 Mon Sep 17 00:00:00 2001 From: astrofle Date: Fri, 11 Oct 2024 12:10:14 -0400 Subject: [PATCH 46/95] Add: test for average_spectra function --- src/dysh/spectra/tests/test_spectrum.py | 13 ++++++++++++- 1 file changed, 12 insertions(+), 1 deletion(-) diff --git a/src/dysh/spectra/tests/test_spectrum.py b/src/dysh/spectra/tests/test_spectrum.py index b629e0f0..cedc8147 100644 --- a/src/dysh/spectra/tests/test_spectrum.py +++ b/src/dysh/spectra/tests/test_spectrum.py @@ -6,7 +6,7 @@ from astropy.io import fits from dysh.fits.gbtfitsload import GBTFITSLoad -from dysh.spectra.spectrum import IGNORE_ON_COPY, Spectrum +from dysh.spectra.spectrum import IGNORE_ON_COPY, Spectrum, average_spectra from dysh.util import get_project_testdata @@ -470,6 +470,8 @@ def test_align_to(self): """ Tests for align_to method. * Test that align_to itself does not change the spectrum. + * Test that aligning to a spectrum with a integer shift preserves the data. + * Test that aligning to a spectrum with a fractional shift preserves signal amplitude within errorbars. """ spec = Spectrum.fake_spectrum(nchan=1024, seed=1) @@ -496,3 +498,12 @@ def test_align_to(self): + (np.nanstd(spec.data[: len(spec.data) - 50])) ** 2.0 ) assert spec.max().value == pytest.approx(org_spec.max().value, abs=3 * tol) + + def test_average_spectra(self): + """ + Tests for average_spectra. + Although not a class method of `Spectra` it is included here to reuse the setup method of the test. + * Test that it does not crash. + """ + + avg = average_spectra((self.ps0, self.ps1)) From 3870463efc842f024990b27703499c8d09f4bd6c Mon Sep 17 00:00:00 2001 From: astrofle Date: Fri, 11 Oct 2024 12:11:25 -0400 Subject: [PATCH 47/95] Add: example notebook for spectral alignment --- notebooks/examples/align_spectra.ipynb | 311 +++++++++++++++++-------- 1 file changed, 210 insertions(+), 101 deletions(-) diff --git a/notebooks/examples/align_spectra.ipynb b/notebooks/examples/align_spectra.ipynb index 5bddcd84..b36a9b85 100644 --- a/notebooks/examples/align_spectra.ipynb +++ b/notebooks/examples/align_spectra.ipynb @@ -7,12 +7,12 @@ "source": [ "# Aligning Spectra\n", "\n", - "This notebook shows why it is necessary to shift spectra before they can be stacked together.\n", + "This guide shows how to align spectra before they can be averaged.\n", "\n", - "The use case is that for radio recombination lines, altough other lines could also be used for the example.\n", + "We use an observation with a mixed observing strategy; position switching and frequency switching.\n", + "In this case the on and off source observations also switch the signal in the frequency domain between a signal and a reference state, so there are four switching states: signal with the noise diode, signal without the noise diode, reference with the noise diode and reference without the noise diode.\n", "\n", - "## Use Case\n", - "Observations of radio recombination lines benefit from averaging multiple transitions together, as the line properties change \"slowly\" with frequency (how slow, is a matter of debate and not the topic of this example). For this example we will look at what would happen if we were to stack two transitions together without shifting (aligning) them before." + "We will calibrate the signal and reference states independently, using position switching. Then, we'll look at the calibrated spectra as a function of channel and vizualize the shift between the signal and reference states. Finally we will shift the reference state and average it with the signal state." ] }, { @@ -22,39 +22,62 @@ "metadata": {}, "outputs": [], "source": [ - "import numpy as np\n", + "from pathlib import Path\n", "import matplotlib.pyplot as plt\n", - "from astropy import units as u\n", - "from dysh.fits.gbtfitsload import GBTFITSLoad" + "from dysh.util.download import from_url\n", + "from dysh.fits.gbtfitsload import GBTFITSLoad\n", + "from dysh.spectra import average_spectra" ] }, { - "cell_type": "code", - "execution_count": 2, - "id": "cf801734-2ba0-48cd-a664-3ca15ce58890", + "cell_type": "markdown", + "id": "74f02c88-5632-4f64-abda-6e70f63ff0fd", "metadata": {}, - "outputs": [], "source": [ - "path = \"/home/dysh/acceptance_testing/data/\"\n", - "file1 = f\"{path}/AGBT18B_014_02/AGBT18B_014_02.raw.vegas\"" + "## Data Retrieval\n", + "\n", + "Download the example SDFITS data, if necessary." ] }, { "cell_type": "code", - "execution_count": 3, - "id": "fb10b18f-4510-4707-ad2a-70a1ec2b4d79", + "execution_count": 2, + "id": "cf801734-2ba0-48cd-a664-3ca15ce58890", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Loaded 8 FITS files\n" + "Starting download...\n", + "TGBT24B_613_04.raw.vegas.trim.fits already downloaded at /home/sandboxes/psalas/Dysh/dysh/notebooks/examples/data\n" ] } ], "source": [ - "sdf = GBTFITSLoad(file1)" + "url = \"http://www.gb.nrao.edu/dysh/example_data/mixed-fs-ps/data/TGBT24B_613_04.raw.vegas.trim.fits\"\n", + "savepath = Path.cwd() / \"data\"\n", + "filename = from_url(url, savepath)" + ] + }, + { + "cell_type": "markdown", + "id": "66d69520-58ac-46ac-be99-071c5812217c", + "metadata": {}, + "source": [ + "## Data Loading\n", + "\n", + "Next, we use `GBTFITSLoad` to load the data, and then its `summary` method to inspect its contents." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "fb10b18f-4510-4707-ad2a-70a1ec2b4d79", + "metadata": {}, + "outputs": [], + "source": [ + "sdf = GBTFITSLoad(filename)" ] }, { @@ -102,48 +125,48 @@ " \n", " \n", " 0\n", - " 6\n", - " W43G\n", - " 92.02\n", - " OffOn\n", + " 35\n", + " MESSIER32\n", + " -200.0\n", + " OnOff\n", + " 1\n", + " 1.420406\n", + " 1.420406\n", " 1\n", - " 5.764969\n", - " 5.93154\n", - " 64\n", - " 2\n", - " 3\n", " 1\n", - " 117.575564\n", - " 27.647278\n", + " 5\n", + " 1\n", + " 73.115543\n", + " 62.295527\n", " \n", " \n", " 1\n", - " 7\n", - " W43G\n", - " 92.02\n", - " OffOn\n", - " 2\n", - " 5.764969\n", - " 5.93154\n", - " 64\n", + " 36\n", + " MESSIER32\n", + " -200.0\n", + " OnOff\n", " 2\n", - " 3\n", + " 1.420406\n", + " 1.420406\n", + " 1\n", + " 1\n", + " 5\n", " 1\n", - " 117.172716\n", - " 27.302879\n", + " 72.308676\n", + " 59.322465\n", " \n", " \n", "\n", "" ], "text/plain": [ - " SCAN OBJECT VELOCITY PROC PROCSEQN RESTFREQ DOPFREQ # IF # POL # INT \\\n", - "0 6 W43G 92.02 OffOn 1 5.764969 5.93154 64 2 3 \n", - "1 7 W43G 92.02 OffOn 2 5.764969 5.93154 64 2 3 \n", + " SCAN OBJECT VELOCITY PROC PROCSEQN RESTFREQ DOPFREQ # IF # POL \\\n", + "0 35 MESSIER32 -200.0 OnOff 1 1.420406 1.420406 1 1 \n", + "1 36 MESSIER32 -200.0 OnOff 2 1.420406 1.420406 1 1 \n", "\n", - " # FEED AZIMUTH ELEVATIO \n", - "0 1 117.575564 27.647278 \n", - "1 1 117.172716 27.302879 " + " # INT # FEED AZIMUTH ELEVATIO \n", + "0 5 1 73.115543 62.295527 \n", + "1 5 1 72.308676 59.322465 " ] }, "execution_count": 4, @@ -160,7 +183,11 @@ "id": "17ac95ab-15f2-4f45-80cd-cc9d6ca0f001", "metadata": {}, "source": [ - "For simplicity we will only use two spectral windows, 27 and 28, which we know have good data in them." + "## Data Reduction\n", + "\n", + "### Position Switched Calibration\n", + "\n", + "We calibrate the signal and reference states independently." ] }, { @@ -168,20 +195,65 @@ "execution_count": 5, "id": "d076291b-e69e-4018-ac95-718a7fa3c350", "metadata": {}, + "outputs": [], + "source": [ + "# Signal.\n", + "ps_sig = sdf.getps(scan=35, sig=\"T\").timeaverage()\n", + "# Reference.\n", + "ps_ref = sdf.getps(scan=35, sig=\"F\").timeaverage()" + ] + }, + { + "cell_type": "markdown", + "id": "5d0d337f-68b5-4efb-a0f4-cc16eec85a74", + "metadata": {}, + "source": [ + "Plot the signal and reference spectra as a function of channel." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "0960e4d5-b2e1-4946-a9af-9d2816f2e43a", + "metadata": {}, "outputs": [ { - "name": "stderr", + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure()\n", + "plt.plot(ps_sig.flux)\n", + "plt.plot(ps_ref.flux)\n", + "plt.ylabel(f\"Antenna temperature ({ps_sig.flux.unit})\")\n", + "plt.xlabel(\"Channel\");" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "037dc86e-05f4-4b44-9018-bfc15bc0949e", + "metadata": {}, + "outputs": [ + { + "name": "stdout", "output_type": "stream", "text": [ - "/home/sandboxes/psalas/Dysh/dysh/src/dysh/spectra/core.py:395: RuntimeWarning: Mean of empty slice\n", - " meandiff = np.nanmean(calon[chrng] - caloff[chrng])\n", - "/home/sandboxes/psalas/Dysh/dysh/src/dysh/spectra/core.py:395: RuntimeWarning: Mean of empty slice\n", - " meandiff = np.nanmean(calon[chrng] - caloff[chrng])\n" + "Noise on the signal state 0.41 K\n", + "Noise on the reference state 0.40 K\n" ] } ], "source": [ - "pssb = sdf.getps(ifnum=[27,30], plnum=0)" + "print(f\"Noise on the signal state {ps_sig[5000:10000].stats()['rms']:.2f}\")\n", + "print(f\"Noise on the reference state {ps_ref[5000:10000].stats()['rms']:.2f}\")" ] }, { @@ -189,61 +261,97 @@ "id": "1d1b09e3-969d-40db-89bc-f933756423e2", "metadata": {}, "source": [ - "Now we will drop the edge channels, and then fit an order 2 baseline to line free channels. To end we will drop line free channels so we can focus on the emission lines." + "If we were to average the data, then the result would have the spectral line misaligned, since the averaging is done per channel. We can see this if we calibrate the data without separating the signal and reference states. This is lees than ideal because the signal gets reduced and the line shows up in two different places even though it is the same line." ] }, { "cell_type": "code", - "execution_count": 6, - "id": "3e51cc62-4ffc-4f3b-b934-bc2b42d63306", + "execution_count": 8, + "id": "95b851e3-75cb-4b7b-b943-f9dbce5033ad", "metadata": {}, "outputs": [ { - "name": "stdout", - "output_type": "stream", - "text": [ - "EXCLUDING [Spectral Region, 1 sub-regions:\n", - " (5464064707.706556 Hz, 5466252941.541311 Hz) \n", - "]\n", - "EXCLUDING [Spectral Region, 1 sub-regions:\n", - " (5716228475.37819 Hz, 5718517695.075638 Hz) \n", - "]\n" - ] + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" } ], "source": [ - "s = slice(150,1900)\n", - "exclude = [30*u.km/u.s, 150*u.km/u.s]\n", + "ps = sdf.getps(scan=35).timeaverage()\n", + "ps.plot(xaxis_unit=\"GHz\")" + ] + }, + { + "cell_type": "markdown", + "id": "bc32e74f-de9c-4175-a60f-dc2014a4cac1", + "metadata": {}, + "source": [ + "### Align Spectra\n", "\n", - "ta1 = pssb[0].timeaverage().smooth(\"gauss\", 4)[150:1900]\n", - "ta1.baseline(model=\"cheby\", degree=2, remove=True, exclude=exclude)\n", - "ta2 = pssb[1].timeaverage().smooth(\"gauss\", 4)[150:1900]\n", - "ta2.baseline(model=\"cheby\", degree=2, remove=True, exclude=exclude)\n", + "Instead, we must align the spectra before averaging. In this case we will shift the reference state spectrum to match the signal state spectrum." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "db03ff0a-944e-4af6-a568-f33b3c36b4fd", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkIAAAGwCAYAAABFFQqPAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8g+/7EAAAACXBIWXMAAA9hAAAPYQGoP6dpAAB5OklEQVR4nO3dd1gT9x8H8PclQABlKlNRwIF7K+IeWBy12lq1jrrt0tqW1jrq1l+xtra2arWtrda2arW1rjrq3nvvgSCi4maphJDc7w8kJGSQQEKIvF/Pk+chd9+7fHIkl8991wmiKIogIiIiKoEktg6AiIiIyFaYCBEREVGJxUSIiIiISiwmQkRERFRiMREiIiKiEouJEBEREZVYTISIiIioxHKwdQDFnUqlwu3bt+Hm5gZBEGwdDhEREZlAFEWkpaUhMDAQEonheh8mQvm4ffs2goKCbB0GERERFcDNmzdRvnx5g+uZCOXDzc0NQPaBdHd3t3E0REREZIrU1FQEBQWpf8cNYSKUj5zmMHd3dyZCREREdia/bi3sLE1EREQlFhMhIiIiKrGYCBEREVGJxUSIiIiISiwmQkRERFRiMREiIiKiEouJEBEREZVYTISIiIioxGIiRERERCUWEyEiIiIqsZgIERERUYnFRIiIiIhKLCZCRGTXnmUqbR0CEdkxJkJEZLdOJDxG9UmbMXX9eVuHQkR2iokQEdmtLzdfBgAs3h9v20CIyG4xESIiIqISi4kQEdktEaKtQyAiO8dEiIiIiEosJkJERERUYjERIiK7JbJljIgKqdgkQnv27EHXrl0RGBgIQRCwZs0a9TqFQoExY8agdu3aKFWqFAIDAzFgwADcvn3b6D6nTJkCQRC0HtWqVbPyOyGiosI8iIgKq9gkQk+ePEHdunUxf/58nXVPnz7FiRMnMHHiRJw4cQKrV6/G5cuX8corr+S735o1a+LOnTvqx759+6wRPhEREdkhB1sHkKNTp07o1KmT3nUeHh7YunWr1rJ58+ahSZMmSEhIQIUKFQzu18HBAf7+/haNlYiKCVYJEVEhFZsaIXOlpKRAEAR4enoaLXf16lUEBgYiNDQU/fr1Q0JCgtHycrkcqampWg8iIiJ6MdllIpSRkYExY8agT58+cHd3N1guPDwcS5YswebNm7FgwQLExcWhZcuWSEtLM7hNTEwMPDw81I+goCBrvAUiIiIqBuwuEVIoFOjVqxdEUcSCBQuMlu3UqRN69uyJOnXqICoqChs3bkRycjJWrlxpcJtx48YhJSVF/bh586al3wIRWUiWSmXrEIjIzhWbPkKmyEmCbty4gR07dhitDdLH09MTVatWxbVr1wyWkclkkMlkhQ2ViIrAiYRkW4dARHbObmqEcpKgq1evYtu2bShTpozZ+0hPT0dsbCwCAgKsECERERHZm2KTCKWnp+PUqVM4deoUACAuLg6nTp1CQkICFAoFXn/9dRw7dgx//PEHlEolkpKSkJSUhMzMTPU+2rdvj3nz5qmff/LJJ9i9ezfi4+Nx4MABvPrqq5BKpejTp09Rvz0iIiIqhopN09ixY8fQtm1b9fPo6GgAwMCBAzFlyhSsW7cOAFCvXj2t7Xbu3Ik2bdoAAGJjY/HgwQP1usTERPTp0wcPHz6Ej48PWrRogUOHDsHHx8e6b4aIiIjsQrFJhNq0aQPRyHz5xtbliI+P13q+YsWKwoZFRHbiTGIy6pT3tHUYRGRnik3TGBFRYSzeH2/rEIjIDjERIqIXwunEZFuHQER2qNg0jRERmcsHj3HUeQTkogPC7i+1dThEZIdYI0REdmu10xQAgEzIsm0gRGS3mAgRkd1yE57aOgQisnNMhIjIbgm8/TwRFRITISKyWx6sESKiQmIiRERERCUWEyEiIiIqsZgIERERUYnFRIiIiIhKLCZCREREVGIxESIiIqISi4kQEb0Qmkou2DoEIrJDTISI6IWwwmmGrUMgIjvERIiIiIhKLCZCREREVGIxESIiIqISi4kQERERlVhMhIiIiKjEYiJEREREJRYTISIiIiqxmAgRERFRicVEiIiIiEosJkJERERUYjERIiIiohKLiRAR2SVRFG0dAhG9AJgIEZFd0pcH3Up+VvSBEJFdYyJERHZJX33QlaS0Io+DiOwbEyEisktyRZbOst1X7tsgEiKyZ0yEiMgu/Xbwhs4y9hsiInMxESIiuzRz80WdZUyDiMhcTISI6IWhYo0QEZmJiRAR2SVBzzIV8yAiMhMTISJ6YbCPEBGZi4kQEdmlCMl5nWUqlQ0CISK7VmwSoT179qBr164IDAyEIAhYs2aN1npRFDFp0iQEBATAxcUFkZGRuHr1ar77nT9/PoKDg+Hs7Izw8HAcOXLESu+AiIrSUOkmnWUiu0sTkZmKTSL05MkT1K1bF/Pnz9e7ftasWfjuu++wcOFCHD58GKVKlUJUVBQyMjIM7vPPP/9EdHQ0Jk+ejBMnTqBu3bqIiorCvXv3rPU2iKiICHqSHvYRIiJzFZtEqFOnTpgxYwZeffVVnXWiKGLOnDmYMGECunXrhjp16mDp0qW4ffu2Ts2Rpq+//hrDhw/H4MGDUaNGDSxcuBCurq745ZdfDG4jl8uRmpqq9SCi4kdfZ2m3TF7kEJF5ik0iZExcXBySkpIQGRmpXubh4YHw8HAcPHhQ7zaZmZk4fvy41jYSiQSRkZEGtwGAmJgYeHh4qB9BQUGWeyNEZDH6aoQgspMQEZnHLhKhpKQkAICfn5/Wcj8/P/W6vB48eAClUmnWNgAwbtw4pKSkqB83b94sZPREZA36m8b01RMRERnmYOsAihuZTAaZTGbrMIioIFgjRERmsosaIX9/fwDA3bt3tZbfvXtXvS6vsmXLQiqVmrUNEdmPisJdnWUtHv9jg0iIyJ7ZRSIUEhICf39/bN++Xb0sNTUVhw8fRkREhN5tnJyc0LBhQ61tVCoVtm/fbnAbIrIfFSW6HaP9MhNsEAkR2bNi0zSWnp6Oa9euqZ/HxcXh1KlT8Pb2RoUKFfDhhx9ixowZqFKlCkJCQjBx4kQEBgaie/fu6m3at2+PV199FSNHjgQAREdHY+DAgWjUqBGaNGmCOXPm4MmTJxg8eHBRvz0iKgKeqmRbh0BEdqbYJELHjh1D27Zt1c+jo6MBAAMHDsSSJUvw6aef4smTJ3jrrbeQnJyMFi1aYPPmzXB2dlZvExsbiwcPHqif9+7dG/fv38ekSZOQlJSEevXqYfPmzTodqInoxVDu2WVbh0BEdkYQeXMeo1JTU+Hh4YGUlBS4u7vbOhwiyjHFw8DylKKNg4iKJVN/v+2ijxARERGRNTARIiIiohKLiRARERGVWEyEiIiIqMRiIkREREQlFhMhIiIiKrGYCBEREVGJxUSIiIiISiwmQkRERFRiMREiIiKiEouJEBEREZVYTISI6IXxQOT9AInIPEyEiOiF8UyU2ToEIrIzTISI6IURJLlv6xCIyM4wESIiIqISi4kQERERlVhMhIiIiKjEYiJEREREJRYTISIiIiqxHAqyUUJCAm7cuIGnT5/Cx8cHNWvWhEzGYatERERkX0xOhOLj47FgwQKsWLECiYmJEEVRvc7JyQktW7bEW2+9hR49ekAiYUUTERERFX8mZSyjRo1C3bp1ERcXhxkzZuDChQtISUlBZmYmkpKSsHHjRrRo0QKTJk1CnTp1cPToUWvHTUSk45ZYxtYhEJGdMalGqFSpUrh+/TrKlNE9yfj6+qJdu3Zo164dJk+ejM2bN+PmzZto3LixxYMlIgIAlUrUuorboGyKl6WH8FtWB4y1WVREZI9MSoRiYmJM2tmdO3fQsWPHQgVERJSfLefuoJPG8ww42SwWIrJvJnfmiY6ONrr+zp07aNOmTWHjISLK158rFms9DxLuAQAaSq7YIhwismMmJ0KLFy/G//73P73rcpIgHx8fiwVGRGRIoPBQ63m45BIAoIP0hC3CISI7ZvKosXXr1qFjx47w9vbGu+++q16elJSEtm3bwtvbG5s3b7ZKkEREmiRQ2ToEInpBmJwItWzZEitXrkSPHj3g5eWFN954Q50EeXh44L///kPp0qWtGSsREQAmQkRkOWZNqNilSxf88ssvGDx4MDIyMjBr1iyULl0a//33H9zc3KwVIxGRlkgJm8CIyDLMnlm6b9++SE5OxtChQ9GgQQNs27YNHh4e1oiNiEgvD+GJrUMgoheEyYlQ/fr1IQiC+rmjoyOSk5PRtm1brXInTvBKjYiIiOyDyYlQ9+7dtZ5369bN0rEQEZkkTLhp6xCI6AVhciI0efJka8ZBRGQyZ0Fh6xCI6AXBu6MSERFRiWVSItSxY0ccOnQo33JpaWn44osvMH/+/EIHRkRERGRtJiVCPXv2RI8ePVCjRg2MGTMGq1atwv79+3H8+HFs27YN3333HXr16oWAgACcOHECXbt2tXigwcHBEARB5zFixAi95ZcsWaJT1tnZ2eJxERERkf0yqY/Q0KFD0b9/f6xatQp//vknfvzxR6SkpAAABEFAjRo1EBUVhaNHj6J69epWCfTo0aNQKpXq5+fOnUOHDh3Qs2dPg9u4u7vj8uXL6ueao96I6MVw2rkx6mYctXUYRGSnTO4sLZPJ0L9/f/Tv3x8AkJKSgmfPnqFMmTJwdHS0WoA58t7HbObMmahUqRJat25tcBtBEODv72/t0IjIhpReocAdJkJEVDAF7izt4eEBf3//IkmC8srMzMTvv/+OIUOGGK3lSU9PR8WKFREUFIRu3brh/Pnz+e5bLpcjNTVV60FExZcoSG0dAhHZMbscNbZmzRokJydj0KBBBsuEhYXhl19+wdq1a/H7779DpVKhWbNmSExMNLrvmJgYeHh4qB9BQUEWjp6ILEkUzJ4gn4hITRBFUbR1EOaKioqCk5MT1q9fb/I2CoUC1atXR58+fTB9+nSD5eRyOeRyufp5amoqgoKCkJKSAnd390LFTUQWMiX3tj5Hyg9Gk8TFGutSbBAQERU3qamp8PDwyPf32+4upW7cuIFt27Zh9erVZm3n6OiI+vXr49q1a0bLyWQyyGSywoRIREVJsMuKbSIqJuzuDLJ48WL4+vqiS5cuZm2nVCpx9uxZBAQEWCkyIrIFUcI+QkRUcAVKhJKTk7Fo0SKMGzcOjx49ApB9s9Vbt25ZNLi8VCoVFi9ejIEDB8LBQbsya8CAARg3bpz6+bRp0/Dff//h+vXrOHHiBPr3748bN25g2LBhVo2RiIqWgzsvboio4MxuGjtz5gwiIyPh4eGB+Ph4DB8+HN7e3li9ejUSEhKwdOlSa8QJANi2bRsSEhIwZMgQnXUJCQmQSHLzusePH2P48OFISkqCl5cXGjZsiAMHDqBGjRpWi4+Iil7dqiHAWVtHQUT2yuzO0pGRkWjQoAFmzZoFNzc3nD59GqGhoThw4AD69u2L+Ph4K4VqG6Z2tiKiIqTRWRq9lgIrB2isY2dpIjL999vsprGjR4/i7bff1llerlw5JCUlmbs7IqLCKRtm6wiIyI6ZnQjJZDK9kwxeuXJFZ/ZnIiKr86xg6wiIyI6ZnQi98sormDZtGhQKBYDs21gkJCRgzJgx6NGjh8UDJCIyivcQJKJCMDsRmj17NtLT0+Hr64tnz56hdevWqFy5Mtzc3PC///3PGjESERnm6GLrCIjIjpk9aszDwwNbt27F/v37cfr0aaSnp6NBgwaIjIy0RnxEREREVmNWIqRQKODi4oJTp06hefPmaN68ubXiIiIiIrI6s5rGHB0dUaFCBSiVSmvFQ0RERFRkzO4j9Nlnn2H8+PHqGaWJiIiI7JXZfYTmzZuHa9euITAwEBUrVkSpUqW01p84ccJiwRERERFZk9mJUPfu3a0QBhEREVHRMzsRmjx5sjXiICIiIipyBbr7PBEREdGLwOwaIYlEAsHITK4cUUZERET2wuxE6J9//tF6rlAocPLkSfz666+YOnWqxQIjIiIisjazE6Fu3brpLHv99ddRs2ZN/Pnnnxg6dKhFAiMiIiKyNov1EWratCm2b99uqd0RERERWZ1FEqFnz57hu+++Q7ly5SyxOyKiAhNF0dYhEJEdMbtpzMvLS6uztCiKSEtLg6urK37//XeLBkdElNeVu2moamS9SgSkhsdzEBFpMTsR+uabb7QSIYlEAh8fH4SHh8PLy8uiwRER5RV7L91oIqRUiZBKmAkRkWnMToTatWuHoKAgvUPoExISUKFCBYsERkRUEMduPEKzSmVtHQYR2Qmz+wiFhITg/v37OssfPnyIkJAQiwRFRFRQtx4/s3UIRGRHzE6EDHVETE9Ph7Ozc6EDIiIyxsh8rs/Xs1mMiExnctNYdHQ0gOyTzKRJk+Dq6qpep1QqcfjwYdSrV8/iARIR5WePVw+0evy3rcMgIjtkciJ08uRJANk1QmfPnoWTk5N6nZOTE+rWrYtPPvnE8hESEeUjq9EwYCsTISIyn8mJ0M6dOwEAgwcPxrfffgt3d3erBUVEZJhu05eHa3az/BNRVtTBEJGdM3vU2OLFi60RBxFRgQmCxSbJJ6ISxuxECACOHTuGlStXIiEhAZmZmVrrVq9ebZHAiIhMldM/mt2kichcZl9GrVixAs2aNcPFixfxzz//QKFQ4Pz589ixYwc8PDysESMRkdqDdLnOMkGSfSoTIPIWG0RkFrMToc8//xzffPMN1q9fDycnJ3z77be4dOkSevXqxckUicjqvvrvss4yibpGSMTFO2lFHBER2TOzE6HY2Fh06dIFQPZosSdPnkAQBHz00Uf48ccfLR4gEZGmJ/Is3YUafYR+2R9XhNEQkb0zOxHy8vJCWlr2FVe5cuVw7tw5AEBycjKePn1q2eiIiPJQqnSbvnLuLcY+QkRkLrM7S7dq1Qpbt25F7dq10bNnT3zwwQfYsWMHtm7divbt21sjRiIiNZWePkCCOgVi/yAiMo/ZidC8efOQkZEBAPjss8/g6OiIAwcOoEePHpgwYYLFAyQi0iTRk+wIz2uEZIKeZjMiIiPMSoSysrKwYcMGREVFAQAkEgnGjh1rlcCIiPSRQKX++3LFvgiDdhu/FMoij4mI7JdZfYQcHBzwzjvvqGuEiIiKmmY/oCcugQAAaVa6ellZpBRxRERkz8zuLN2kSROcOnXKCqEYN2XKFAiCoPWoVq2a0W1WrVqFatWqwdnZGbVr18bGjRuLKFoishbNGqEbQd2zl0lyT2UC+wkRkRnM7iP03nvvITo6Gjdv3kTDhg1RqlQprfV16tSxWHB51axZE9u2bVM/d3AwHP6BAwfQp08fxMTE4OWXX8ayZcvQvXt3nDhxArVq1bJajERkXZqJjkri9HwZb7FBRAVjdiL0xhtvAABGjRqlXiYIAkRRhCAIUCqt1z7v4OAAf39/k8p+++236NixI0aPHg0AmD59OrZu3Yp58+Zh4cKFVouRiKyrlqAxT1DOsHkht8GMQ+iJyBxmJ0JxcbabrOzq1asIDAyEs7MzIiIiEBMTY3A264MHDyI6OlprWVRUFNasWWP0NeRyOeTy3Cn8U1NTCx03EVlOmCRR49nzW2tIWCNERAVjdiJUsWJFa8SRr/DwcCxZsgRhYWG4c+cOpk6dipYtW+LcuXNwc3PTKZ+UlAQ/Pz+tZX5+fkhKSjL6OjExMZg6dapFYyciK8lJgLRqhNhHiIhMV6DLqN9++w3NmzdHYGAgbty4AQCYM2cO1q5da9HgNHXq1Ak9e/ZEnTp1EBUVhY0bNyI5ORkrV6606OuMGzcOKSkp6sfNmzctun8iKhztRCf7FBbg4apeIhU4fJ6ITGd2IrRgwQJER0ejc+fOSE5OVvcJ8vT0xJw5cywdn0Genp6oWrUqrl27pne9v78/7t69q7Xs7t27+fYxkslkcHd313oQUfGhlQg9rwly8gpULwqXXCrqkIjIjpmdCM2dOxc//fQTPvvsM0ilUvXyRo0a4ezZsxYNzpj09HTExsYiICBA7/qIiAhs375da9nWrVsRERFRFOERkZX0lu7SePb8FObool4i1RheT0SUH7MTobi4ONSvX19nuUwmw5MnTywSlD6ffPIJdu/ejfj4eBw4cACvvvoqpFIp+vTpAwAYMGAAxo0bpy7/wQcfYPPmzZg9ezYuXbqEKVOm4NixYxg5cqTVYiQi66sliVf/nXNrDU3sI0RE5jA7EQoJCdE7oeLmzZtRvXp1S8SkV2JiIvr06YOwsDD06tULZcqUwaFDh+Dj4wMASEhIwJ07d9TlmzVrhmXLluHHH39E3bp18ddff2HNmjWcQ4joBafvXmRERIaYPWosOjoaI0aMQEZGBkRRxJEjR7B8+XLExMRg0aJF1ogRALBixQqj63ft2qWzrGfPnujZs6eVIiKi4kjCpjEiMoPZidCwYcPg4uKCCRMm4OnTp+jbty8CAwPx7bffqidbJCIqCq5OuqcwNo0RkTnMToQAoF+/fujXrx+ePn2K9PR0+Pr6WjouIqJ8hYd46yxjZ2kiMkeBEiEAuHfvHi5fvgwge3r7nL46RERFRdBzPw3tUWVERMaZ3Vk6LS0Nb775JgIDA9G6dWu0bt0agYGB6N+/P1JSUqwRIxGRXoKeO4tVlyTYIBIisldmJ0LDhg3D4cOH8e+//yI5ORnJycnYsGEDjh07hrffftsaMRIR6eXuUuBKbSIiAAVoGtuwYQO2bNmCFi1aqJdFRUXhp59+QseOHS0aHBGRMYK+tjEiIjOYXSNUpkwZeHh46Cz38PCAl5eXRYIiIiIiKgpmJ0ITJkxAdHS01l3ck5KSMHr0aEycONGiwRER2Ytr99IQs/EiHj3JtHUoRGQGs5vGFixYgGvXrqFChQqoUKECgOxZnWUyGe7fv48ffvhBXfbEiROWi5SIqBiLmrMXSpWIGw+fYuGbDW0dDhGZyOxEqHv37lYIg4jIvilV2RM5nr3F0bNE9sTsRGjy5MnWiIOI6IXgIGUHbiJ7Uqixp+np6VCptGdxdXd3L1RARET2zEHCRIjInpjdWTouLg5dunRBqVKl1CPFvLy84OnpyVFjRFTiSTikn8iumF0j1L9/f4iiiF9++QV+fn6cx4OIiszi/XEYbOsg8sFTIpF9MTsROn36NI4fP46wsDBrxENEZNDU9Rcw2NnWURin77YfRFR8md001rhxY9y8edMasRAREREVKbNrhBYtWoR33nkHt27dQq1ateDo6Ki1vk6dOhYLjoiIiMiazE6E7t+/j9jYWAwenNtSLwgCRFGEIAhQKpUWDZCIyB5UFJLwqnQf9ok9bR0KEZnB7ERoyJAhqF+/PpYvX87O0kREz61zmgAP4SkaPrsLoLOtwyEiE5mdCN24cQPr1q1D5cqVrREPEZERoq0DMMhDeAoAqJV13saREJE5zO4s3a5dO5w+fdoasRARGSUpxolQjuIfIRFpMrtGqGvXrvjoo49w9uxZ1K5dW6ez9CuvvGKx4IiINDUWLptUTqUSIeEMz0RkArMToXfeeQcAMG3aNJ117CxNRNb0mePv6r+/y+qOUQbK3Up+hiBv16IJSgcTMCJ7YnbTmEqlMvhgEkRE1iRoNDzdFb0Nlvt848WiCMcANo4R2ROzEyFNGRkZloqDiChfYULuZK5KI6ev28nPiiIcvZQqJkJE9sTsREipVGL69OkoV64cSpcujevXrwMAJk6ciJ9//tniARIR5XAScmudnaAwWM6WqYjIpjEiu2J2IvS///0PS5YswaxZs+Dk5KReXqtWLSxatMiiwRERGdJVetDWIRDRC8DsRGjp0qX48ccf0a9fP0ilUvXyunXr4tKlSxYNjojIkJrCDYPrRBtWCbFhjMi+mJ0I3bp1S+9kiiqVCgqF4apqIiJLchXktg6BiF4AZidCNWrUwN69e3WW//XXX6hfv75FgiIiKgyR9TJEZCKz5xGaNGkSBg4ciFu3bkGlUmH16tW4fPkyli5dig0bNlgjRiIinL+dgpoazzcom+JlA2WdVLYb0crO0kT2xewaoW7dumH9+vXYtm0bSpUqhUmTJuHixYtYv349OnToYI0YiYjQ5bt9Ws/jRT+DZdvLd1g7HCJ6QZhdIwQALVu2xNatWy0dCxGRyV5tUMHgumBlfNEFkoe/8Nhmr01E5jO7Rig0NBQPHz7UWZ6cnIzQ0FCLBEVElB9nNy+D62orzhZhJERkz8xOhOLj4/XeSkMul+PWrVsWCYqIKD9Zpfy1nr+ZOVb9dwXVzbzFrUK05Th9IrIIk5vG1q1bp/57y5Yt8PDwUD9XKpXYvn07goODLRqcppiYGKxevRqXLl2Ci4sLmjVrhi+++AJhYWEGt1myZAkGDx6stUwmk/HWIER2KEJyXut53iTktlimKMPBtgt3Mfqv05jzRn20rupTpK9NRJZjciLUvXt3ANl3mB84cKDWOkdHRwQHB2P27NkWDU7T7t27MWLECDRu3BhZWVkYP348XnrpJVy4cAGlSpUyuJ27uzsuX76sfi4IHNFBZI+6SA5pL1CptJ4KRTxkftjSYwCAgb8cQfzMLkX62kRkOSYnQqrnJ52QkBAcPXoUZcuWtVpQ+mzevFnr+ZIlS+Dr64vjx4+jVatWBrcTBAH+/v4G1xORfXDJM4GirecKKoVnyIQjFAUbc0JExYTZfYTi4uKKPAnSJyUlBQDg7e1ttFx6ejoqVqyIoKAgdOvWDefPnzdaXi6XIzU1VetBRLbXQ6o9fD5v05jMyE1YLS4jBeedh+KI7D29sRCR/TA7ESoOVCoVPvzwQzRv3hy1atUyWC4sLAy//PIL1q5di99//x0qlQrNmjVDYmKiwW1iYmLg4eGhfgQFBVnjLRBRIeVt5HZCVtG9eGJ2s5iXkI7e0p02vbcZERWOXSZCI0aMwLlz57BixQqj5SIiIjBgwADUq1cPrVu3xurVq+Hj44MffvjB4Dbjxo1DSkqK+nHzZtGMPiEi8+TtE9S+ZqBN4vjC8Sfe0IPIjtld4/bIkSOxYcMG7NmzB+XLlzdrW0dHR9SvXx/Xrl0zWEYmk0EmkxU2TCKytjzVMOU8nIrutfMMumDTGJH9spsaIVEUMXLkSPzzzz/YsWMHQkJCzN6HUqnE2bNnERAQYIUIiagopVdoq/XcQ1aEI0LzJD5Mg4jsV6FqhDIyMpCZmam1zN3dvVABGTJixAgsW7YMa9euhZubG5KSkgAAHh4ecHFxAQAMGDAA5cqVQ0xMDABg2rRpaNq0KSpXrozk5GR8+eWXuHHjBoYNG2aVGImo6GS5aM8b5GDDyzoVa4SI7JbZidDTp0/x6aefYuXKlXpvtaFv1mlLWLBgAQCgTZs2WssXL16MQYMGAQASEhIgkeSeDR8/fozhw4cjKSkJXl5eaNiwIQ4cOIAaNWpYJUYishKl7ogwndxDZZ1zjymYBxHZL7MTodGjR2Pnzp1YsGAB3nzzTcyfPx+3bt3CDz/8gJkzZ1ojRgCmtcHv2rVL6/k333yDb775xkoREVGR2TpZZ1HeU4JQhInQgdgHaFZkr0ZE1mR2ZfL69evx/fffo0ePHnBwcEDLli0xYcIEfP755/jjjz+sESMRlXSH5ussyjuh4mP3akUVDRbujtWORZUbyylVpSKLg4gKz+xE6NGjR+q7zLu7u+PRo0cAgBYtWmDPnj2WjY6IyAB3Z0et53InT9sEAgBpuTecThedbRcHEZnN7EQoNDQUcXFxAIBq1aph5cqVALJrijw9PS0aHFnXvbQM9P3pEDaevWPrUMiGMrNUSHj41NZhmC3I21XreVF208k7Pm3O1isG1xFR8WZ2IjR48GCcPn0aADB27FjMnz8fzs7O+OijjzB69GiLB0jmiXvwBC2+2IHfDt3It+z0DRdxIPYh3vvjRBFERsVVz4UH0OrLndh/7YGtQymU8BDjt9uxpjWnk9R/SziYnsiumN1Z+qOPPlL/HRkZiUuXLuH48eOoXLky6tSpY9HgyHyT1p5D4uNnmLjmHN5sWtFo2cdPMo2up5LhdGL2fftWHbuJ5pVtfx/BgqpYppTW87OJKahd3qNIXlulUQ8kEVRF8ppFYd/VB/jz2E1MfaUmvEsZn7BSFEUIAuvDyP4UembpihUromJF4z+4VHTkWS/OSdhe3U5+htj76WhZxcfWobwQlCoR0gJst/7MbaslQnlv7yFqVK7nXWcv5FlK7Lh4DxGVysDTNTvp6f/zYQCAo0TA173rGdx2+oYLWH/6NjZ/2CrfhImouClQIrR9+3Zs374d9+7dg0ql/cP7yy+/WCQwsr68o26KwqWkVDxIy0SLKqbVPKTLszDwlyPoVMsfw1qGWjk6y2g2cwcA4NchTdC6auGToZMJjxFcphS8rPwDU1yv5pcdvoE38yzLFKWw5c9tvTJKIC33uVaN0PPvlTxLiQu3U1G3vCckkuJ5bDV9/d8V/LDnOqoHuGPTBy211iUmP9O7zaHrDzF3x1Xsv5Y9p9yS/XGIfinM6rFawuMnmRi29Bheb1gefZpUsHU4FrXz8j2kZWThlbrWvf9eyjMFFuyKRbd6gageYJ3JlIuC2X2Epk6dipdeegnbt2/HgwcP8PjxY60H2VgxvxjtOGcv+v98GNfvpxst9yxTiUV7r2Py2vM4fuMxZvx7sYgitJwjcboTjppr79X7ePX7A2g1a6cFIjKuOP5U33z0FBPXntdZPiFrSL7bnrqZbIWIsvm4aY8MC5Pk3pxZguyLw/eXncSr3x/AvJ3XsOV8EsI/34YjcY+sFlNhrTt9GwBw8U6qzrq887ily7MAAG/8eEidBAHQuQdbcTZ3xzUcv/EY41aftXUoFjd48VGMWn4Sd1MzLLZPURQxcc05/HYwXr1s+oYLWLg7Fp2+3Wux17EFs2uEFi5ciCVLluDNN/Neo1FxYKlantQMBSSCgNIy69yXN+7BE4T6lDa4/uutl/HT3jirvLYhSw/G46/jiVgyuInB6n2lSoTUxKt7fXOAPnqSif3XHqBDDT84O+bf4LP94j0AQNrzH56SZvvFu3qXiyakbdZMOlIctWv6FGLu/1ICFe6kPMN/F7Jj/3lfHFKeZc+M3f/nw7gyo5NJr3HtXjre/Pkw3mtTCW9GBFsmcBM9kWehlMZ3X2OaJPxx+AY+++ccpnWrqbuhng+9PEuJNxcdQZMQb3wSFfa8mO37Ez3R+E69+fNh1AvyxMf51GbdTn6GH3bHYlDzEISULWW0bHGQ/FQBP3fLTOdw8PpD9SCcnM/juVspFtm3rZldI5SZmYlmzTinanFVmKn+r91Lw+hVp3HtXhrqTPkPtSZvwZG4R1a/s/bNR0+RpdRuYjX2I5alVOHC7VSoNM7Ov+yLw9/HE42+Tro8S2ubvCatPY8ziSmYu+Oq3vX30jLQYPpWTF57zujr5ND3Sm/8eBDvLz+Jr7Zc1ruNUiVi3enbuGWgKaKwrt1L0/oB0GTJHyZRFHEvzTJXo3WFaxbZjyUpUrSnnLgt5jb1CgCu33+ifq6ZN2ea0YdvwpqzuJOSobdGzBhjn3FNWUoVziamQPm8vObX/Kv/tD+fmueAz/7J/vxPMjGuf8/cwZH4R5i3M/v/uOxwAhrN2GbRH9FTN5Mxb8dVKJQF6yO59+oDzN2R/+ds2K/H8OvBG3h9wQHEP3iCN38+jIOxha/5tRZTvtJpGQrE5lNDn13uxb0YMzsRGjZsGJYtW2aNWMgCzElZ8uY3ry88iFXHE9H5u33qZb1+OIhVx4wnGABw5W4aUp7q3g/KEMnzb+ifRxPQctZOVP5sE6atv4DbzxMAY+9j7Oqz6PzdXnz3PGG5+egppm24gI9XnTa4za3kZ6g1eQtCx2/E2UTjJ+AMhf5bNSzeH4+UZwr8ejD/qQkA/UnplbvZJ5x/DczdtOzwDYxaflLdFGZObqJSiUiXZ6HjnD2YtfmSzvqj8Y8Q+fUedPh6t97t76fLTX6trRfu4uW5e3HtXm5HmbOJKXjwfB/TN1xEk/9tx6pjNw3twiR/HktEsJCUf0E9cpqorKHv4wVaz/N2kP5+V+6P6mMzvhc5biU/Q6xGMmWqbRfuosbkzfj3TP5zg01adx5d5+1DzMaLuH4/HUkazSiXk9K0yiY+LnhinncAx/h/zuLhk0y8PHcfBvxyxOTEzZju8/fjq/+u4ItNup97Q/R9t/K76LvwvNnw4ZNMjFh2AnuvPkCfnw6ZFWvO61y9m2ZWYmzOvg35YXcsak/eggMaU2U0mrEN7Wfvzjcx1bdbW9fqWYrZiVBGRga+/vprtG7dGu+//z6io6O1HlQ4x288Rsymi3iWWbD7JhWm9ib5+Qk775dz7ensWXNTnirw3/kk9XqVSsTOy/ew/9oDvPTNHjT631bTX+z592fM37nt87/sj1N3NDbmr+c1P/OeX8Fdf5D/D8a6U7fVf3edt89o0qY0cGK29lf+0ZNM/HXillYMgomvOnX9eTSYsRVzd1zFpaQ0fL8rVqfMprPZCcXtFP01NXuu3FcnMvkZvvQYzt1KxfvLTwEAziQmo+u8fWg0YxuA7P8lAHy+Mbdv14HYBwge+y++266/xk2fi3dS9R6BtmG++W7rB+v1WfQRtPvRtJFqJ+HGEofdV+4bXPfttqtoN3sXms/cgftpuv+LDIUS4/85i12X70GhVOGnPddx4XZ2LJlZKgxbegwZChVGLMt/brBlhxMAAIv2xaHdbP3JcY57emLR5/FTBdaeuoUMhRKiKGLL+SQkPjY8WeeeK/dxMp++XKIoIjVD//c1bw3Qon35N6dPWHMWMRv19zlcsFv3e2NIYfrfxGy6hA7f7EHtKVsgzyrcPfIys1RatbyaPwEP0zPx1ZbLeGvpMZy7lYKYTZeQJs9C30WHEf/8vJmTqPZYcACnbyZj8zlDFx7FvANqIZjdAeTMmTOoV68eAODcOe0mghclO7SlHgsOAABkUkmBRl9oflTP3UrBj3uuY3RUGAI8nDHj34toVqkMXqrpb9Y+76Rk4NTNZIz9+wwuJaWhZqA7XJ2kqF/BCz/uua4up1CKmLLuPCIqlUGUntfI2/xl9H2Y8J3Lep4sDPv1KKoIibgp+uB28jMEerrku23MpouY2UP/vFcrjyWiUbA3ejUK0lpu7sfbnP5aT+RZaDDdjEQyj8X74wEAP+y+rnf9mpO3cP52/k0RZxNT0LZa/klGjtTnfV80O8y2/WqX+m/NI9D3p+yh2F9vvYJR7avo7EulEiEIz88jyTeBTZ+iqaSB3podB8f8x4z1d9gKYACA7BFC6fIslJY5YMv5JLxU09/kYd6rTyRCoVShd+MKSHmmwMxNFxGTp8z/HHNHywoQccPITN2/HbyhdzShUiXim21X9GyR66c917HscAKWHU7ApJdr4H/Pf9DjZ3bB11u1t72XlgHfPJ26M7NU6LfoEOpX8DL6OgcK2Nzz26Eb+O3QDfQLr4AWlcviXRMma1136hYOXX+IEW0rA8hO9l5feABNQ8pgwss18NZvx7H1wl1sHNUSNQJzRyZdu5eGyK/3YHDzYK39KZQqOEgEvb9HOy7dxe+HshPAHg3K66yftfkyhjQPwdi/z6BDDX90qRNgMO4H6bnzsImiiJM3k1HZt7TOrV/yin/wRH3elGep0GPBAWx4P3eUXmqGAsN/PYaudQPRP5+54ACg+RfZSfO5qVE6fTr7LjqkPpfm9FnLcTT+ESqWyZ2dXZ6lQrf5+wEAWz5shTB/N9x4+ATlPF3gIJXo1OyJoqi3Y72m3w/dQJC3q0VGz1qT2YnQzp3WH71CwNV76fhpz3UcjnuEBf0bwFFqWuWdZgLRde4eiJDg+oN09AuviCUH4rHkQDziZ3YBYPpV3vX7T9D9+RcEAM4/vwI9Gq97xZ3zGrN71sWvB+OxoH9DlHuemGzV+CLeT5WrO5DqfR96koj1p29jgZ6ajhbiCSyWfQkAeHneQqwY3TPfTt4Jj7R/qPL22fn0rzMo7+WClKcKXLyTChGm185ovAkcuv4QDhIBjYJ1Zz2+ejcNh64/RJ8mFXDawFWxKclXfrWA+64+wId/ntJalvDwKf46fhODmofolFcoVVh+JAHBZUqhVZ4T2LlbKTh0XfdHUvP/FWdCDV1emVkqdPx2D0LLlsKigY2Bte8BcXuwwmmj3vJpoV3y3ec70vUIHvsvGlb0wvEb2Z9V71JOePQkE2NXn8Wl6R3x5ZbLqOpXOjvJeaqAzFGi1Yk9Q6FE9Mrs2p6I0LJYuCcWy4/cREyh+p/q/38lP81/glPNvmN5mzL+PqHdhB31zR6MjqqG8l4u6v/jtot3cTT+sd7vbl6G+pKZ4o/DCXrPWd9s1U30cpqaW1Qui2cKJbZeuItzt1Jx7lYqJrxcQ33emLr+PAI9XfBem0qo4ueGb7Zl1yzmXATkqDf1PzQM9sbSIU2Q8lSB73ddQ3ioN9pV88OQJcfyjX3x/nisOXUba07dRpc6uZ8zY/1oNp9Lwrt/nEB5LxfsG9PO6P7P5vm/nbuVik1n7+DnfXEY3DwE60/fxuG4Rzgc90idCImiiLk7rsHPXYYONbKT+AyFEg+fZKprDpcfTsB/F5IwpmPuzYeNnRoEQVCPFMzrj8M3sPT5/6VVVR+U93JR1yDmeJKn1SJDocTXW6+gfTVfhIeWwdnEFExYk11ZkvObU1xZZ0gQWUTO1d7Gs3fQrV45g+UOxj5ExTKuiL2frh4y/J50LYY5/IsemVMRe0+KOxrNIcN+PYbEx09x7V7uF/vjlfr71zggC/Mdv8NRVRgWKXM/zMHCHTwS3ZAK/SO/cvrrTF57HosGNgIAPNPoe/Pp32fw6d9n9G5rqM/A+8tP6l3eQ5o7dHOw/A/UmuyOKzM6wUEiQCIRIM9S4tRN7RP/oyeZiPpmD7rVD4Sfm7O6I6emnBqMHL0a6V5B5lCqRGw8ewcNK+ZeaT9Iz8QbP2b3H7gyoxOcHLR/GDp8s0e97ZT1Fwzu25g5265gzjbjTU2XknSv2rrN34fHTxU6J2UIwK8H4tXTFZT3csGmD1rCzVFAilzEy3P36ewLMHzCFUUgKSUD3+bTHLY/9gGu33+S28k4zvgNnLs3zv8O71IhO6icJAjI/r/n+O3gDfz8vCmlY80A1J32H9xkDjg7NQoqlYjhS4/BwyX36r7VlzvRNDT/23jkN6Hitov3kPj4Kcp7uRotp+nq3TRMXX9Bqx9PfvWNj58qMP6f7KbnnNoCczoTn0xI1ll285Hp96TT15xl7HNw/naqOl59+zj8fADF9ot3cWZKlMED8CRTiT1X7iNDoUTdaf8BAH7Ycx1HP4s0Ke6HGs3D7WbvwozutdCsUlm0N9J8OGlddsfx/PpSZY+W012eU3N27Ib2eSpDoYRcocKlpFR1jd+Yv8/iwrQoNJi+FRmK3P9nzu/F6wsPGo0hx45Ld7HxrP5msKUa/SD3GGjKVeX50v+8Lw4/7rmOH/dcx46PW+P4jeI7VUReZidCT548wcyZMw1OqHj9uv6qeTKP5mfsqZH+Qt3m7VPfIkHTp45/AgDGO/yB4YpP8OfR3Gx+m54hyXmvJp9Hgc6SI4iSHkOU9Jg6EaooJGGX7GMAQHCG8Y7zR+MfYdzqs/gwUrcpxJA/jiTodNY0Ju8cv0D2lzd65Qk0rOCJ6rG/wA1eAFqrS116vv9Zm/WP3tJn31UD9+LKysSKw/H4bP1VOGgMEdI8pgqlSisR0kxM9f3/ANNG/xhLgi4npeHcrRT8tFf3O5nTgTdvzcCCnbE4Ep97Akt8/Az/Lv4cve5+g5GZYwCYfxud95ef0HmdEwmPUcW3NJQqEauOJWp9JnssOIC/89mnqVMYGHP0+fssgxR8879oeKAFUuSl8ehJJlafSMT2S/fUZZ0hxxvSnTgTFwqgqtH91pbEA8/rEA1p8UV2zXpOgpKaocAYAxcGADDk16O4+Uj7RzZv3zhjV/9L9sfhvTaV8cGKU0Zj15Qzq7SmlmbMZ7X6eX83U+WtpQWAOlP+01mWmpGFr7ZcNjjJY468fXga/2+b1nNDNXCa/Yyu33+Cvj8dxjutjSfemv25FEqVVm3YPycT8dGfpzGtW03M33lNp7nSmHrT/kOGQqVVywNkHyvNJKggDCVBppi6/rxOP0vNmmBjfc4ePcmEi6MULk4FmS/eOsxOhIYNG4bdu3fjzTffREBAAPsFWcmjp5rtz7nLMxRKzN1xFe2r+6FBBS+DP6LqbZ+fjO+mZn9RS+EZ3pDuxBZVYySKhttt3fAUm2Rj4YNknXXhEtMnN0x5psDyIwmIe5Cu0+fGkIlrTBuero8M2V/OYUuPYrPTWFRLuAk8v6j/S9nayJb509vJWKUCvq6OHs+eYDJ+QJZK/1fK2NfEUNOWQqXClvO5J6tzt1JQq5zpt4yImmO8ViVvXD5IRuObaxCH1riP3JqtN+5+DQCY7/gd6sgX6Y3d0HsQRVHdlKrpte8PGIzp+I3HgGWmPtHhggw8e75z9Tw/Tl+hniQWbSWnMFAxVm9frb+dpqCmJPsquVrG4nxfp53kJHaoGuRbrtbkLbg0vSO+2XoF2y7eM1juTrLuZ0+zOTW7c73hTOir/65g8/mC//AVhYVmdFTWV4NrLs1ENz/mxPbD7liMbFcFKU8V2HD2ts50AznnYlPkJDtf5BkFuuWc/vm1ikre5khTPXqSiQbTt6KUkxTnp3W0bFCFYHYitGnTJvz7779o3ry5NeKh5zTn0XF7cgM4cxio/Tp+3HMd83fGYv7OWJPaXZV5BgZ+5vA7+jrsxChxNerm+VHL4Yk0bJaNhb+gvx9BfqmvHx4hA06oJYnDUVU1qCBgwO0ZSD7UBEAjvds4Igs9pbuxX1UTN8TcjtZ1hWt4z2EdPs/qq7XckDAhuxZGBgWqSUwZui0iTLiJeNEf8gLctEGZ+RTSpw/gDGCB4xwMV3yit5zESCZ08PpDOEOODMi0lnf6dq9WVfvLc/dh84ctsfPSfQxuHgzntBuY6PAbFmV1xh2U0dpW8wffB4+1EhtNmnOD/OD0NRpIrqGz9DC6ZObtDgy4C7pX7E+fN3eqRMAVGXgGJ437bmWP9nFysP2Vnw8e44BsFBwFJSYoBuN3ZQf1unqS7B+51tIzgIFuazlJEAC4Iv8fsppCPHYg/0QIyE5w8/thye96c9Tyk1qdd/W/jvGOrfkpzrNiFydf/XcFb7WqpG6Ws4b8OtUXN+nyLDyVZ6m7TOT0L1KpRDxTKLUm77QFs1/dy8sL3t75t5OTGRTPgL2zgSub0UbSCcdUVTFIugUbVE0RLwag656XAQC/HozD13G5s7kGj/03311rJ0Ii+jpkV217CE/xp9M0TFYMwiVR+z47cxy/N5IEqVBfyG2OcYICmcjtR1FeuId9sg/Vz1dltcJBVQ10xj7g3j6ckL6tt2ZmqHQjxjquyH5fGs1ta2WTAAAVhbvYomqEKsItfKgYoX7NK3fTTJplWFNV4SZ8hGTsV9VGJ8kRLHD6FqdVoeiWOcOk7WXIBB5cxR+xTrj/8BFy3m0H6QmDP6QHYx/qjMYSoIIICQLTzuGw82T8nNUJ07OyZ2zvJDmM5o/P4U+hLcoIqXgsloab8Awd52S/vmzbeAxx2IyhDtk1dC9nfq7e7zvSdRjruALvZn6A8sJ9fOa4DLMVr2Ou8jWj76uBJPsqW/NHPz85Uy6UfnYHF5yzb3sxWTEQvypfwgqnGRBFAX0Un8FWN/CQIRNyOGG240I4Ctkn3xmOi7USIXOZclNV/e9WhBOytL4vQPZ9oQrL0LxUltTrB9P6nhQXefsbFaWcGZhLkmPxhhPlXw/E4+/jiVrNuQ/T5Ri+9BhOJCTj8Pj2FpsBuyDMnkdo+vTpmDRpEp4+Nb3THBnw5CGwbQrw9zBgz5dA0lkscZqFc87D8Injquf9cHJPut6J21FHML2KFshuGvPBY5RBCjpIjmutC5dcwmbZWJ1t8s6JkqOKkIg45/54w2GXetnb0vVoIzkFL2RfbbaQaDdr9XTYAw8h98P/leMP2YkERDggCyFC9gk8Upo7zLa2cB39pVuh+d6rSW7iA4d/0Fl6BDGOuTVZL32j3fyT34+UD5Lxn2wM/nCKQahwG5MdlwIA6kquY5Hjl4iSHDG6PQCscZoEzGuEzWuX4Yc9pvWJG7zkKJ5m5ta+NJOcw3nZULwm2YNPHFYCAIY6bIIU2T/WC5y+RX+H7Vgvm4AlTrOwVjYJvzvFwB8P8bZ0A4Y4bFbvq5YkXuu1chLKLx1/wGeO2Unlx45/6Y1rmPRffOM4H4LOEHUR1YQExDv31d63g3afMAlUWP7jTDRNWKheNtXxV9QUbqCp5CIipBfQW7oLXSSHNF7D8P9IAhU6SXT7phTUOdlQyJCJqpL8JwXV5ADDI6YqCAVLXGY7LsQV54Eon2f7+Tvz/04rlC/uHC7WonUPtCI2fUPBBj/Ys3gjU0Y8y1Tq9GlrOGMbTjzvkL+pCBJ5Y8yuEZo9ezZiY2Ph5+eH4OBgODpqX92cOJH/vBH03D9vA9eMzx3TUpJ7VdNVeghdpYfQJ/MzHFRp3+cn58rXB8kY5bBaZxtT1BTiUUdi+KS8VfapzjLNH9gzqhBsVjbRKdNfqt1J8bLzIADARVUFVJck4P3MkWgkya3qXS+bAAB4KOq/m3EP6V78p2yELarGAIBQIfdL5CUY7mTtg2QcdX5P/XyHTLsZK1J6EpHSkwjLWIIukkPYraqLh/BAQ+EyXIRM7FPVBgBUl2R3PH9NuhfHVHk7zoqoIdzAXdEL4xyXY6uyoTrOGpM242OHVeggOa5utvvaaSGuqnJHBP7rNB4dM78w+B7edViHiib+EOdNCkOEO3BEFq6I2X21qgiJmOD4BwBgrVL7tjlnZcPgJuh2Rn3HYQO2KRvgI4e/sUD5CoKFJPS5rdtnphRyt/3C8Se98VXOWIosSOGOp0hFKQTiAQ44jzLpvRkyWTEQUx1/VT93FJSIkhzVqTUcKt2IFcq2eJanORLITu7HOS7Hh5nvYY2qhc76f2ST841DIqh0aktzRjcOlm7Bv8pwvOuwDl9kvYFrouHRiEQvgttWumWQpZidCHXv3t0KYZRQ+SRBANBbuktnWRvJKXUi5IdH+NnpK9SSxGN+1it4R7pePWzYHF5Ixb+y8WZvp6mOJA51JLozu1aS6M/2cxKKuU7z9K5vLDE8oquvdDu2qBpjqPRfrRoRRyjRT7oNPkKyzjYNJKbNaJyTqAFApYzf8Ldsavb2GQvxCLnJmb7ap3jnflrPX5fuwXRFf0x0/N3g61WR5I6uqSa5iUqC4dE2Ax0KPunizucj/WpnLMIA6X8Y7bhSve5Th5VaZfUlQTn+kk0DADSXGr7XlKuQfz+a16R7ESYkYqjDJozMfB8fOuQ3Vix/CaLuZJDfOc3HHVG7OX+i4+8G/yfjHJcDAOY4fY81Gc3hA/PvifWhw2p86LAaHeUzdZqeRQCrZVMAZDenhmUsKVD/NCJ7sfqk8RGEmtNa2IIgWvuOmnYuNTUVHh4eSElJgbu7/hqKApti+gggTQuzXkaA8AhtJKfgoacDq7mCM5bpNIHYgweiO8oKhesAmp9TqkrqzrTt5V/CBXJseF5jtUXZCFtVDfGV4w8Wfc27oif89CRylvJ+5kiDyWdR+kbRAx85mp/8XFGVQ9Vp+pseBo+fgcVOXxY4ph+yuuBth9y+d1uUjRAlzX8SPmP6ZH6GntLdeE2aPQfTb1mReNMht5a0nfwrXBcDC/UaRPbOGpMumvr7XaCu2snJyfjrr78QGxuL0aNHw9vbGydOnICfnx/KlTM88R/lSnz8FAWtEH/HYYNFY1nqqDtCyB5YOwkCckcUAdk1Sl86/qh+njO/kqVZMwkCDNfAFTU/Ax3ybUkzCQJgkf/vxw6rtJp+NZMgIrI9sztLnzlzBlWrVsUXX3yBr776CsnJyQCA1atXY9y4cZaO74WVM6FacdBKarvRFfbkFYnhuW/IfH0d8r/Brj7jFMMsHIl1aSZB+uyQfYJAGJisk4iszuxEKDo6GoMGDcLVq1fh7Jw73K1z587Ysyf/CdwomwsKfudiso2W0oJP9EiWc1w0/2bExd0XGjWNRCVReiHubVdYZidCR48exdtvv62zvFy5ckhKKt4zlxYnr0jta04OIrIeXys3hxIVd49t2GHa7ERIJpMhNVW3b8aVK1fg42P4lg2kbYR0ja1DIKJiwpRJGoleZBIL3D+wwK9t7gavvPIKpk2bBoUie0ZZQRCQkJCAMWPGoEePHhYP8EVVQaL/jr5EVHAOMHyD4uKMd2ykks6GeZD5idDs2bORnp4OX19fPHv2DK1bt0blypXh5uaG//3vf9aIkYjIJIHlKuRfqBjyLYYj6IiKkuZNhIua2cPnPTw8sHXrVuzfvx+nT59Geno6GjRogMjISGvER0RksjLVWgB2WNlqifnAiOzZE7ntanPNToSWLl2K3r17o3nz5lp3oM/MzMSKFSswYMAAiwZIRGSqDjX8gL22joKIzHU/Pf/Z6K3F7KaxwYMHIyVFd8r5tLQ0DB482CJBERHpkyK6Gl0vsLMNkV367eANm7222YmQKIoQ9JxtEhMT4eFRsFtGEBGZYqrCeI2zT2ndm6gSUfEnMTsbsRyTm8bq168PQRAgCALat28PB4fcTZVKJeLi4tCxY0erBElEBAC3RB/89U6EwfVlmAgR2SWJDatzTU6Ecu46f+rUKURFRaF06dLqdU5OTggODubweSKyqph330BoBe/8CxKRXZHaQyI0efJkAEBwcDB69+6tdXuNojR//nx8+eWXSEpKQt26dTF37lw0adLEYPlVq1Zh4sSJiI+PR5UqVfDFF1+gc+fORRgxEVlKaIWC3qqYiIozu5pQceDAgXB2dkZmZiYSExORkJCg9bCmP//8E9HR0Zg8eTJOnDiBunXrIioqCvfu3dNb/sCBA+jTpw+GDh2KkydPonv37ujevTvOneM9o4heVOdUwbYOgYjMZMsJFQVRFM2a2/3q1asYMmQIDhzQvhN3TidqpdJ6cwGEh4ejcePGmDdvHgBApVIhKCgI77//PsaOHatTvnfv3njy5Ak2bNigXta0aVPUq1cPCxcu1PsacrkccnnuML7U1FQEBQUhJSUF7u7ulnszU9ixnMhsU3RHrOYVNW4Btsh0zwfFXXDGMluHQGQzZUvLcGyCZecjTE1NhYeHR76/32bPIzRo0CA4ODhgw4YNCAgI0DuCzBoyMzNx/PhxjBs3Tr1MIpEgMjISBw/qv4HpwYMHER0drbUsKioKa9asMfg6MTExmDp1qkViJqKid1m0z9mliUqyBzacR8jsROjUqVM4fvw4qlWrZo14DHrw4AGUSiX8/Py0lvv5+eHSpUt6t0lKStJbPikpyeDrjBs3Tit5yqkRIiLbOhs2CrVtHQQRvXDMToRq1KiBBw8eWCOWYkEmk0Em4xBcouLGt26UrUMgIiuR2lNn6S+++AKffvopdu3ahYcPHyI1NVXrYS1ly5aFVCrF3bt3tZbfvXsX/v7+erfx9/c3qzwRFV9+ZUwbNl+2tBPuixbsz0dEVmfL4fNmJ0KRkZE4dOgQ2rdvD19fX3h5ecHLywuenp7w8vKyRowAsucqatiwIbZv365eplKpsH37dkRE6J9gLSIiQqs8AGzdutVgeSIqnn7O6gT41TCpbCWf0lirbJ5/QSIqNmx5exyzm8Z27txpjThMEh0djYEDB6JRo0Zo0qQJ5syZgydPnqjvcTZgwACUK1cOMTExAIAPPvgArVu3xuzZs9GlSxesWLECx44dw48//miz90BE5pue9SaGmlFeRNGfVfcoa6OV9GyRvy7Ri8AuZpbO0bp1a4PrrD0/T+/evXH//n1MmjQJSUlJqFevHjZv3qzuEJ2QkACJxg1LmjVrhmXLlmHChAkYP348qlSpgjVr1qBWrVpWjZNs76iqKhpLrtg6DCqEb7NeQx/pDixXtrV1KCZ5BvYtJCqojrVs12XF7EQor7S0NCxfvhyLFi3C8ePHrTqPEACMHDkSI0eO1Ltu165dOst69uyJnj17WjUma1injMAUxUCccH7HKvtfltUWtSVxqC2JN3mbiYpB2KuqjV2yj60Sk6UMyByDw6rqGOGwBqMc1tg6HDJDe/mXSBD9oHh+avomqwdQyNqdLxRvYIzjCpPLL8rqhGEOm3BOFYxaZnw/oqTHChAdEQGAp6ujzV67wPd73bNnDwYOHIiAgAB89dVXaNeuHQ4dOmTJ2EqsdcoIjFKMxCOY1uHzhsoXMYo+JpXtIv8cwRnLMD5rOLpmfm6wXP2MhdijrI03MifgjCoE+5U18ZuyA+LFANTKWIT1yqbYq6yFFvI5Jr1uXgeU2f09BmeOxgVVRbO336msi07yGL3rrosBkMMJX2f10lr+TuaHZr9OXi3l3xhcNz/rFbP3d1VVrjDhAAD6ZY7Lv9BzHeSz9C5PF50hFx0wKHO00e3viLkdlhdkdTX5dU2VKPqok6Bs2UmQgxkjSgY1C9ZqGlukzP+WOnOzuiM68x28LJ+BGVlvIjhjGV7O/Bw95ZPwbdarGJQ5Gp8phpgcg7mscSyJ7Ik533FLMysRSkpKwsyZM1GlShX07NkT7u7ukMvlWLNmDWbOnInGjRtbK84XzglVZfXfMxVvaK2LUfRFzg9ARMZcrXVfPC87RTEA4xVDkSK6YpRiJH5QvowhmZ/k+7p5pxHfomykU+ZTxXA8hjsGKMbhkKoGXsmcgX6K8eqY0uGK9xWj8KZiPDJE480ByWIpddKjaYBiLFrI52Cnqj6+zXrV4PbfKHRv5JsolsVgxRhcFE1PoFJFV2xWNcHfyhbYqmyAncq6OmWmK/ob3cdFVRBuirnzUv2a1UH9t0KU4susN/RtZtSnirfQLOM7rWXxKj8DpbUNzByDEZmjsF9l+uw6j0Q3vcvXKJujunwJdqnqo3HG97iiJ0HbrqyPm6KP+vkpjc9wXj9mdcFYxTC9o7feyJyARhkLtJbNUPRDD/lkyOGkU/7Pt5ri4Lj2Bl8rr061A7BU+RIAYK2yWZ7EKtcD0R1jFcNQM+NnzM7qhdWqVjgnhmqVOSpWwzdZPbFLVR9/KC07662mWDHQavsmsgcuToVuoCowkxOhrl27IiwsDGfOnMGcOXNw+/ZtzJ07N/8NSa9BmWPwVuZHaC3/GguV2leDySil/vsOymCa4k318wXKV9AgYyGWKDtimbI96sl/xGmxMgABO1QN8G3Wa+qyO5T18o3jHcWHeC9zlPp5/8xxWKXM2w9MgKHmiQfwwOIs3fldboll0Fs+EW3ls5Gq8X6A7CQwCw5IFH019p9rXlY39d8LlV3RWv41ZiteVy97I3NCvu8rr8Oq7AlAP1a8h+GKTzBcodu893M+NQfzs7prPdeMWvX82QZlOM6rKmJ4ZjRiVQEYlZnbjPuvUvvmwB3ks3BSrILbKIsNynD18n6Z49EoYwHaymcjVhWgE8eqrFYYrXgLu1V18a+qqc76TxXDdZbFKPpgUOaneAgP9JZPRKJYVmu9CAGq56eD+/DEOMUwAMDfyhbomzkeExWDMFSRt7ZI9+48h1XVMEExGJ9n9cMKZTv8nKV7TA+pauABPPB7Vm5ys0jZBcfFMJ2yABAeWgY+bub1v2lQpy7CMpbgA8UInXWd5DGolrEYjeQLsELZDk/gYvJ+F2V1MrhurzK372EPefZNqn/M6mLSfjnKjch2TE7BNm3ahFGjRuHdd99FlSpVrBlTiZCKUvhPlVuD1k7+Fd6WbsAmVRM8g7NW2X+V4Zjk+Jv6uWaTmZgnlz2rClH/PUTxKeKlfY3GIUKidWW/z4zahRxTswair3QHZIICAKAUBXSXT8d9eALIrr3yFR6jgeQaAN2T/glV9udJJQqoLl+MMkjFSIe16vU3RH/MVb6K9aoI3BD9dN6zLn1Jm/YylYF9NMhYiJqSePzmNFO9bK2yGWYq+uAOymiVPSOGYrWyBV6T7sP3z5O3kYoPkJ0gCNiamV3btj+jJvyFRzgvBqOLtJ96+6ti7p3UU8XcZPEWsmtdHoj670c3Oku339jvWe3R32E7vlL0xGplS7SUnMUpVSUIAHao6uO6Ro3DYbE6Wsi/Q7xz7mdjl0q7huy4GIY6GT8hFa4ABByA7gADJaQ6y97MHIdM5Lb1563p+FvZQv33hKwhWKjsqpEQW44gQKt2aUjmJ+gsPYKJikE636/WVX2w+8p9k/b7v6x+GOawSe+6JI1mw+NiGMIylkAOJ7wh3QF34ZnR/RqqtSoKwWVcEf/wqc1e35jZPesiPNQb0zdcwJbzd/PfwIhGFb1w7MZjC0WWa07vevjwz1MW3y8VHZNrhPbt24e0tDQ0bNgQ4eHhmDdv3gs9w3RRuy4GYkzWW9ilqqez7i68MdtjLMS+K/Pdzz5JQ5ws11erJkJT45AyOstuoyz6Zo5HX4n+/iOGjO2Ue5uV+8j90a4k/0OdBAFAEsrgtcxpmKl4A4dV1fCnso3Wfu7DE00y5qO2fBHkcMJtlMXvWe3xU1ZnjR8zAfFigE4StEtPE5cpDN1p+BHcsVdVR6esZhIUKZ+FTxXD8beyJT5VvIWX5TPwnVKzeU876XoID5wXQwAIWn1sNH2v7IZnohN+yeqotdzUH8gJWUNRKeM3zFO+iiw44H3FKPys7IJFyi5aSZA+v2Z1wHZVA53l2TV52u9lwfN+UBuUTbFLVVfnTu9KSPDXO7nzdG1VNcRUxZvok/kZ+mWOw/jnNU3ZhHyToL/fLdicX5+8pF27tEPVAJ8o3tFJggCgim9pk/ZZu5yH0SQ8b3Kd89ltIv/epP3r0zg4e262ng3LI6pmdpPpm011m4QHRJjfzw4ANn3QErN71TNrmwNj2yG6Q1X1c82/C2Je3/paz4e2yL2Ya1/dF+W9XPHDm43wy6BGWPGWbg2oqV6q6YdZr9fB1FdqFngfvnpqJrvXL4dX6lqnadNa+zXV261DMap9FUzvVvBjZjLz7v9uUSYnQk2bNsVPP/2EO3fu4O2338aKFSsQGBgIlUqFrVu3Ii0tzZpxlngffzQOQtX8bzEw5ZXaeNxyCtapmuld36O9/ir4hm26w7tydg2VsanOBzULRqCHMyqWcUXf8NybWw7N/ATHVVXQJ/MzrfKaX6CFylfQO3MSMp4PM25ZpSwuTc/+4b8HL60miglZQ/G/LON9dgBgjGI4tigbYXA+nXzzMmeemZyyPRuWx/jO1XBNLI+VyrYQIUEWHHBODMXiweH57CWbYCAFSxR9UEv+M6ZlDdBaHq14FykOZTBa8Ra+UvTEaMVbBvf974dt8GlH/c1L+vTJ/AyzFL0xOWsQmobqJsgAcHlGR6x6JwL+7tkJxE5VfTTOmI/3FSORBQe8nJnd+b5/5jj0kk+EElI0CvbGL4Ny+p4JWKzshIOqmtivqq1VSxMX01n9425Iw4qmzSadV5C3q8lly3m54PNXc2tCa5fTrolrWaUswkO8sWy48f+xysBnKkNjWH1O38C9ylqIVQVgTtZreE0+xeA+Z71eF78OaYLp3WthYf+GuDS9I6Z3166dK+fpgmndzJ8SZFCzYFQPcEfDiqZNhLv949bYFt0agZ4uGNW+Cmb3rIuJL9fAqPYFbyFoWaUsXq6j/WMf4JGbrGr+Nrar5ofgMtrN7OYY0jwEvRoFYWCzYOTXL3fxYP39XY98pr+fmLWmwDG238KMsmob5pNvmQvTojCuU3VEd6iKNyOCEft5/oMO7JXZo8ZKlSqFIUOGYN++fTh79iw+/vhjzJw5E76+vnjlFfNHzZB+xydE4t02lczerkfD8hD0nJCPqqqiScZ8qJz0d5YFgP+9Whujo8Kw65M2uDS9I8p56vadmPJKTRwY1x67PmkDd+fcL+JlsQJ6ZE7FQZX2lcMbTSpondjycnaUokyp7B9HJ6n5gxiXf/wq3lZE45CqutFyGch70jD/zDWwWTDeaqX/f9ImrPDNO5pNTc6O2ceif/eu8PgsFrNmzMI85atYpWyDH99siD+G6f4oV/N3x3ttKqN+BU+TXu+gqia+V3YDIGBQsxC9ZWQOUjQO9sah8e3VtTP34QUREq0T8T5VbRwRc/8HbU04HoIg4Ote9bCwf0P1slJOus1tBdWjQXmD60a1q4wJXapjWIsQ9G9aEX3DK2DnJ20wqFkwfnizoVbZeX0b4M+3I+Dm7IhejQzv01BzKwC0kc9GJ3kMXsuchkoZv+FNxXi0z5yNOVmv44SYXaNSztMFpye9pLWds6MErav6wNlRCkEQ4Oyoe3wqljE96dNU3iv3+11all3z2L2e4RqISj6lUVmj9qxHw/JatTc5tnzYCtc1fjS9S+l2gM8xv59uTaSg8euf97LB3cX0JsQONXKT7AAPZzhonF/OTjF+UWnK5xcAagRkd1N4o3EFreVV/UrjkJ4O/mWMHAt9NM9SfZpUgJss9/2/buTzDQA/5vkcawrQc27XVM7TBa55Oi/nvUBuZGICbaqa5fR3BSgKBR4+DwBhYWGYNWsWEhMTsXz5ckvFRADKlJahV6Psu97rS0g01SqX/WVsWNELjlKJ3t/4G6I/7sHwB7ecpws8XBwxom1lBHm7wtlRCgep4WRByHOpMqJtboLQubY/moZ648yUl+AolWByV+PVqn8MD0e7ar5Y/Z7+WixNMa/VxqXpHbGgXwPM6V0P/nqSrJyryEHNgjFOMRSXVEH4XNFPqylPi1sg+msMQe9cW3tir1/zdAY3VD2/99Pcif8iDNSw5ExzsCTrJb3rc4ztWA3xM7tk17oJAgRBwPRuNTG8ZQhequmP5pXLGt1enzA//Ulwv/AKeoeu5tQC5WhY0Rtnp7yEuJjOuPq/Tlq1EO2raf9wCIKAiS/nf0uMUjIHdKzlDz/37FqTZpXL4sDYdijn6YIxHQ38v0yk70c6R/RLYRjWMhQTXq6R/Z0BEFK2FKa8UhOBni5atT+iRrWEsdp7QzVCABAvBuCiWBEVy7hqJbwb3s/tM/XfR63gkecq38vVvB9Ofar6lcbeT9vi7dbaI+IGRASr/94a3Qrf9K6LL3vWxfXPOyMupmBX/8FlXBHm7waJxuepbGnt9/B2q1As6NcAf7/bTOtiKoerRjLskifxc3VywLqRpnUs/7pXbrN53v9MKZlDvrVCg5oFaz3PreXMVjfIEyufNwNHVCqDvZ+2xZUZnfD3u82w+r3m8PdwxsZRLdFC47taprT5/8+TEztgx8etEfNabZye/BIuz+iIA2Pb4ZMo47W/mongq/W1R4E6O0iNJkqmGNbS8Pcrr5Vv59/EbWryaQ2FSoRySKVSdO/eHevWrbPE7ui5kLKlcGR8e+z4xPBs3gDwy6DG+LRjmPpKVvP7/X7mSOxX1tQ7z9BHkVWxsH8DvNO6El5vqHt14eace0XQL7wCFg8yPD2Cv0dusvbl63Wx4q0IjZOc8bbfav7u+GVQY9QycEXwUWRVzOpRB6/VL4fXG5aHs6MUnWoHoHv9cnB2kMLJQf/HOPqlqliubI+OmV/gDsrg7VahGNVOY8j32ARgdCzw8UVM+iB3dFF1/9zO6M9EJ5wSs7fJ+RFsGlpG7w+FZnOMoSRyraoFGmd8jylZA/WeiEZHhWFoixD009MP5M2IYHzWJTe5CCmrv5mgWaXcJOwDjWYLP42kceZrtRHg4YwvX6+DKQb6TPw4QDc+N2dHCIIAR6lEK0HQV4U/tEUIvs9zxR9Z3Q+BHs46fVr+frcZRkeF4cvX6yDQ0wX7x7YrUI2ophqB7pAZ+Gzkp16Qp/pvfbUw+uTX3Pr5q7Wxe3RusixzkKCST2n136Vk2lfgiwc3NvjaeZMaY2Z0r40gb1etvjyzetTR+t4EeLjg1frl4SiVQCLJTrxHta+irl3MmxTntfLtCLQJ88GfGj94S4c0QaOKXlqfAe9SThjXuTo61Q4w2CTn4eKIZcPCsWxYOFz01BDWKe+p/rtdNf0/nq/UDYSbniRL0xtNKhhdXzNQe+qHyj7ZFxIb3m+BkW0rY9mwcHVNGpD9/XdykKBhRS/18hqB7vh9WDi+faMeutYN1Eo+c9+PBxb2160ZA4BR7avAq5QTQp9/TiQSATIHKQI9XeDsKMVPA7STs9+GNoFEAAZGVIQgCPj81dpoXrkMpnWrqb7YALK/r8EGzh+miqrpj42jWmot06z9WzuiOcZ3roadn7RBk5D8m7gNnceLgu2GKpBBH0XmnrB885yAvn2jHiasOZed9IiAh6sjfN2c8V6b3B94zdqa9apmWK/RX0jzx6tPkyD4ujujYy3dIdoAMKd3fYxcdgKj2ldB59r6y4ztVA3nb6eiTdX825wB4MTEDmgwfatJZSd0qY7mlcui+vPq516Ng3TKSCQCzkx+CSrFM+B5X2/NUUtRNf3Uo00EQUAVzVoR59zEq6qB2pKcEW0AIELzh1//j17Z0k54kJ6JyOp+iL2XjtspGShbWoYH6XJ1mZyO5C/V1J1SvkvtAJNPUMFlXBH34AkA7U6V77erAn8PF7Sp6oMgb1d8u/0qgOxq/Mjqvijn6YL21f20fggC9dQ6Vs6nE7F21bn+49Gxpj/ea1MJ3++KBZDdHPPTgIY6x6+8lytGtDU8L1FB1S7nUaCRQq5ODvjnvWY6zVHGUvpflS9hgMNWbFLqv2DI6VMX5ueGy3fT0LGWP1ycpDg3NUqrRk7mIIE8S2WwVhEAxnWqjot30rDnyn0MzFNz0bm2PzaeTQIA/DSgkfpHyEkqQdNQb6TLs/Re+OQV3aEqojtURcozhU7NTF5NQrzRJER7eohWVX3Q6vl5oapfaVy5m65T26pPhxp+6lq6/JQp5YTrn3fGg3Q5hv56DG2r+cLDxRE9jTRh5visc3Xsvnwft5Kf4eTEDoj8ejcePslEoIGm/JyPbK1yHgYv2gzpVq8cutUrh7+OJ+qsc3d2NJgE5CRAhnSo4Yc2YT7YdTl71GPLKj64PKOT+vj1Da+g/txVD3DH3dTscvl1DBANVH0ObRGCn/fF4e1WoRAEATXyJIvjO1fHJ6tOA8hOaDW7ElTxLY2r99LzeWXbYCJUjMTP7IKklAy9zT05utUrh651ArWqnvPSXNOiclm8Ui8Qn/51xux4KvuWxuYPWxkt807r7A+6PCv31ip5r2I1v1OaVwx1yhs/mQxradpVr7OjFHAsDURORVbmM9z/zxMA4Krn5F09wHAfKS1Dt2H/shmIfpw7f1Hec0PLKmWx9+oDravSzR+2wqmEZLSt5ovWVX2wcHes+hjdePQUn/51GndTc5OiIG8X3Hz0DP2bVkCQl6tZV2kze9TBlHXnMSAiGBEatUDOjlK9I4sEAXqvSIHsK9dZr9eBm8wB7/5xAgDgIDH+Y9Sumi+61AnITjbi9ScbEomATztWUydC2XEU3QyyeV+qVVUfdDNxJE79Cub1gYgVy6Fmxs948nxkWmR1P2y7qDvk+/dh4fjvQhK61cturiidpybo9OSXkKUS862J+mVgI9xJydDpGB7g4YJD49pDKhG05l8SBAHLhzdV/20qD5fC3/pg+fCm2H3lPjoZuOhqXrkM9l97iE61/E1Kgr7uVRfLjyTg047VIJEI8HV3xnqNZsa89L3fUjIH7B/bTv38z7eb4vudsRj5vNbYGmOYNKNY0K8Bftx7HTGv1Ya/hzPqlvfA6cQU9fqCjpAzdPxmvV4HTf63PTsOQbsJMi/NWjdNn3Wujp6NyqOqb+559O1WoTh7KwWfdqyGSj6l8Mmq7OUyR+04lg5tgoiYHWa8k6LDRMhG+jetgN8PJaif51QxGkuCchhLggDtKt3fh4VDpRLViZCfuzPKe7lAqRJRprTlbhIpc5Di9OSXIBF0O9W55jnRb/mwFbZdvGu0D0eBtPgQDgCONZFDIghwkErQONhba/6Ryr5uWPFWU73DYHOIABDUGE1Hr8G/TzPRaMa23OUa5vVtgP/OJyFK42aBZUvLEPm8bT64bCnM7JE7FD+4bCm0q+aH5UcS1B1Vt37UGvdS5ahQgA6vfu7OWNDf9Hb+/PpE5PRJWzSgERykQr5V1VKJgPl9s6v0P71/2uQ4ipLmwIFfBjVCu2qmzdptSKV8rtBzRj62rFIWPw1oiJBxG3XK+LjJ0C/c8HB3U5viHKQSrSRoQpfqWH3iFka2rQwvA51yizIJ1VSmtAyvGenc+32/hth24a7Wd8mY1xqUN7q/HF3rBmL96dt4x4Rm1sq+bvi6dz2TXr+gNA9/p9oB6KRR0752ZAuIooi4B09QsUwpo6N3C8LXLfe3RRAElPdyxeioMGy7eBcnE5IBANuiW2HVsUS83Vr/8ZJIBFTz164FGtc5d5CEKIoID/FGlkrUaU4N8HDBksGNMWjxUQu9I8thImQjn3WugQYVvFA9wB1erk4mJUCmKlNahkPj2sNVln1ClUgEzOheC+nyLAR6umDXJ20AGB8mXxCGrhxbVi6L7vUC1U1cYf5uCPM3sWamAMpqJHgDmwXD2VGq1W/G0FDxvKQSQWtfeWVXwes21xkz8eXqqFXOHZHVs3+QnR2lBUqCCkLfaEJ9ImuYnyyM6VgNt5Mz0FtP8yWQ/eN/P02OKD3NgVal8ZYLmwQBwJAWwcCu/MstHdKkyJOOYS1DTa5FLW48XBzRw4TmOnPN6V0PH0ZWQWgB+sPk7eTtl08/KVPkl+QKgpBvc5gl5HwyR7StjHdbV8KKozfRoKInKvu6aSU2Zu9XENQ1Wfo+/5qjayt4uyLhUfGYyJOJkI24OElNuqIpqLyJVX+NphKHAgxTLwyJRMCcN+rnX9AKHKUSrfduTDV/N1xKSkOXOtrV913rBuLW46c688sUhKuTg9HaAGsK8LRcsp1XmdIy/K5nSH+OHR+3RuLjZ+pk2F7JHAz/kJX3ckHi4+wZpHN+BH4a0AjDlx7D2hG8hYYtSCVCvrV4hrQN88VbrUJRxbc0Xq4TaJHOvB1q+KFllbKor9EZv7DMmYfwjcZBWH3illa/MolE0JoTrrDyuwD4uENVzN56BTN71Ebfnw4DyO68b0tMhKhYyak5sIX177dAyjOFTi3Q3D62SeIsZfGgxth79QF6m1l7ZUluzo6oHlD4vibmer1BeRyJe4RqVqyBzBFStpQ6EcrRoYYf4meadr8xKl4EQcD4QtSO6OMoleC3oaZNvmqqav5uJt8iZmaPOpjevZbJndGt4f32VfBW61Cti4oQn8KNYCssJkJUrPw2tAmmb7iAj18yfYZkS3GUSow2hdmrttV80dbAMOMXXc9G5VHJtxTC/K1fE/V+uyrYe/WB0YkciSztg8gqEAQBnUzsX2XLJCiHsZpVW2AiRMVKNX93/DGs4PcTItIkCEKBb9NhriYh2ZOIusl4WqWi4+rkYHiyWDIJv7FERBaib6ZkIirebF9HRkRERCWWbSZ1yMVEiIiIiIpczhQuVYtgMIMxbBojIiKiInd2ykuQK1Q2b1JmIkRERERFztXJAa76J0EvUmwaIyIyQ0f5TPyZ1QbNMr6zdShEZAGsESIiMsMlsQLGZL1l6zCIyEJYI0REREQlFhMhIiIiKrGYCBEREVGJxUSIiIiISiwmQkREZsi5Me843t+J6IXAUWNERGbY9EFLHL/xCJHV/YCd2ctUosCrSiI7xUSIiMgMPm4ydKwVYOswiMhCeBFDRFRIEkG0dQhEVEBMhIiIiKjEYiJERFRIKlGwdQhEVEBMhIiIiKjEsotEKD4+HkOHDkVISAhcXFxQqVIlTJ48GZmZmUa3a9OmDQRB0Hq88847RRQ1ERERFXd2MWrs0qVLUKlU+OGHH1C5cmWcO3cOw4cPx5MnT/DVV18Z3Xb48OGYNm2a+rmrq6u1wyWiEoadpYnsl10kQh07dkTHjh3Vz0NDQ3H58mUsWLAg30TI1dUV/v7+1g6RiIiI7JBdNI3pk5KSAm9v73zL/fHHHyhbtixq1aqFcePG4enTp0bLy+VypKamaj2IiIjoxWQXNUJ5Xbt2DXPnzs23Nqhv376oWLEiAgMDcebMGYwZMwaXL1/G6tWrDW4TExODqVOnWjpkIiIiKoYEURRt1rg9duxYfPHFF0bLXLx4EdWq5d7T59atW2jdujXatGmDRYsWmfV6O3bsQPv27XHt2jVUqlRJbxm5XA65XK5+npqaiqCgIKSkpMDd3d2s1yOiF9wUD42/U2wXBxHpSE1NhYeHR76/3zatEfr4448xaNAgo2VCQ0PVf9++fRtt27ZFs2bN8OOPP5r9euHh4QBgNBGSyWSQyWRm75uIiIjsj00TIR8fH/j4+JhU9tatW2jbti0aNmyIxYsXQyIxv3vTqVOnAAABAbxPEBEREdlJZ+lbt26hTZs2qFChAr766ivcv38fSUlJSEpK0ipTrVo1HDlyBAAQGxuL6dOn4/jx44iPj8e6deswYMAAtGrVCnXq1LHVWyGiF9Az0cnWIRBRAdlFZ+mtW7fi2rVruHbtGsqXL6+1LqeLk0KhwOXLl9WjwpycnLBt2zbMmTMHT548QVBQEHr06IEJEyYUefxE9GLLgBNcbB0EERWITTtL2wNTO1sRUQn0vLP0Y9ENXlMTbRwMEWky9ffbLprGiIiKM95zlch+MREiIiKiEouJEBEREZVYTISIiAqNbWNE9oqJEBFRIYlMhIjsFhMhIiIiKrGYCBEREVGJxUSIiKiQOBkbkf1iIkREVEjsI0Rkv5gIEREVEufnJ7JfTISIiAqJeRCR/WIiRERERCUWEyEiokJiHyEi+8VEiIiokJgIEdkvJkJERERUYjERIiIiohKLiRARUSEFCI9sHQIRFRATISIiIiqxmAgRERFRicVEiIiIiEosJkJERERUYjERIiIiohKLiRARERGVWEyEiIiIqMRiIkREREQlFhMhIiIiKrGYCBEREVGJxUSIiIiISiwmQkRERFRiMREiIiKiEouJEBEREZVYTISIiIioxGIiRERUSCpRsHUIRFRATISIiArpGZxsHQIRFRATISKiAtqlrAsA+E3ZwcaREFFB2U0iFBwcDEEQtB4zZ840uk1GRgZGjBiBMmXKoHTp0ujRowfu3r1bRBET0YvuXcUH6J85Dl9l9bJ1KERUQHaTCAHAtGnTcOfOHfXj/fffN1r+o48+wvr167Fq1Srs3r0bt2/fxmuvvVZE0RLRi+4ZnLFPVRt+nm62DoWICsjB1gGYw83NDf7+/iaVTUlJwc8//4xly5ahXbt2AIDFixejevXqOHToEJo2bWrNUImoBFGJoq1DIKICsqsaoZkzZ6JMmTKoX78+vvzyS2RlZRkse/z4cSgUCkRGRqqXVatWDRUqVMDBgwcNbieXy5Gamqr1ICIyRqliIkRkr+ymRmjUqFFo0KABvL29ceDAAYwbNw537tzB119/rbd8UlISnJyc4OnpqbXcz88PSUlJBl8nJiYGU6dOtWToRPSCY40Qkf2yaY3Q2LFjdTpA531cunQJABAdHY02bdqgTp06eOeddzB79mzMnTsXcrncojGNGzcOKSkp6sfNmzctun8ievE4Se2qcp2INNi0Rujjjz/GoEGDjJYJDQ3Vuzw8PBxZWVmIj49HWFiYznp/f39kZmYiOTlZq1bo7t27RvsZyWQyyGQyk+InopJtYf8GiNl0CfP6NLB1KERUQDZNhHx8fODj41OgbU+dOgWJRAJfX1+96xs2bAhHR0ds374dPXr0AABcvnwZCQkJiIiIKHDMREQ5OtYKQMdaAbYOg4gKwS76CB08eBCHDx9G27Zt4ebmhoMHD+Kjjz5C//794eXlBQC4desW2rdvj6VLl6JJkybw8PDA0KFDER0dDW9vb7i7u+P9999HREQER4wRERERADtJhGQyGVasWIEpU6ZALpcjJCQEH330EaKjo9VlFAoFLl++jKdPn6qXffPNN5BIJOjRowfkcjmioqLw/fff2+ItEBERUTEkiCKHOxiTmpoKDw8PpKSkwN3d3dbhEBERkQlM/f3mUAciIiIqsZgIERERUYnFRIiIiIhKLCZCREREVGIxESIiIqISi4kQERERlVhMhIiIiKjEYiJEREREJRYTISIiIiqxmAgRERFRicVEiIiIiEosu7jpqi3l3IotNTXVxpEQERGRqXJ+t/O7pSoToXykpaUBAIKCgmwcCREREZkrLS0NHh4eBtfz7vP5UKlUuH37Ntzc3CAIgsX2m5qaiqCgINy8eZN3tX+Ox0QXj4kuHhNdPCbaeDx0lcRjIooi0tLSEBgYCInEcE8g1gjlQyKRoHz58lbbv7u7e4n5UJqKx0QXj4kuHhNdPCbaeDx0lbRjYqwmKAc7SxMREVGJxUSIiIiISiwmQjYik8kwefJkyGQyW4dSbPCY6OIx0cVjoovHRBuPhy4eE8PYWZqIiIhKLNYIERERUYnFRIiIiIhKLCZCREREVGIxESIiIqISi4mQjcyfPx/BwcFwdnZGeHg4jhw5YuuQLGLKlCkQBEHrUa1aNfX6jIwMjBgxAmXKlEHp0qXRo0cP3L17V2sfCQkJ6NKlC1xdXeHr64vRo0cjKytLq8yuXbvQoEEDyGQyVK5cGUuWLCmKt2eSPXv2oGvXrggMDIQgCFizZo3WelEUMWnSJAQEBMDFxQWRkZG4evWqVplHjx6hX79+cHd3h6enJ4YOHYr09HStMmfOnEHLli3h7OyMoKAgzJo1SyeWVatWoVq1anB2dkbt2rWxceNGi7/f/OR3PAYNGqTzmenYsaNWmRfpeABATEwMGjduDDc3N/j6+qJ79+64fPmyVpmi/K7Y+nxkyvFo06aNzufknXfe0SrzohwPAFiwYAHq1KmjngAxIiICmzZtUq8vSZ8PqxOpyK1YsUJ0cnISf/nlF/H8+fPi8OHDRU9PT/Hu3bu2Dq3QJk+eLNasWVO8c+eO+nH//n31+nfeeUcMCgoSt2/fLh47dkxs2rSp2KxZM/X6rKwssVatWmJkZKR48uRJcePGjWLZsmXFcePGqctcv35ddHV1FaOjo8ULFy6Ic+fOFaVSqbh58+Yifa+GbNy4Ufzss8/E1atXiwDEf/75R2v9zJkzRQ8PD3HNmjXi6dOnxVdeeUUMCQkRnz17pi7TsWNHsW7duuKhQ4fEvXv3ipUrVxb79OmjXp+SkiL6+fmJ/fr1E8+dOycuX75cdHFxEX/44Qd1mf3794tSqVScNWuWeOHCBXHChAmio6OjePbsWasfA035HY+BAweKHTt21PrMPHr0SKvMi3Q8RFEUo6KixMWLF4vnzp0TT506JXbu3FmsUKGCmJ6eri5TVN+V4nA+MuV4tG7dWhw+fLjW5yQlJUW9/kU6HqIoiuvWrRP//fdf8cqVK+Lly5fF8ePHi46OjuK5c+dEUSxZnw9rYyJkA02aNBFHjBihfq5UKsXAwEAxJibGhlFZxuTJk8W6devqXZecnCw6OjqKq1atUi+7ePGiCEA8ePCgKIrZP5oSiURMSkpSl1mwYIHo7u4uyuVyURRF8dNPPxVr1qypte/evXuLUVFRFn43hZf3h1+lUon+/v7il19+qV6WnJwsymQycfny5aIoiuKFCxdEAOLRo0fVZTZt2iQKgiDeunVLFEVR/P7770UvLy/1MRFFURwzZowYFhamft6rVy+xS5cuWvGEh4eLb7/9tkXfozkMJULdunUzuM2LfDxy3Lt3TwQg7t69WxTFov2uFMfzUd7jIYrZidAHH3xgcJsX+Xjk8PLyEhctWlTiPx+WxqaxIpaZmYnjx48jMjJSvUwikSAyMhIHDx60YWSWc/XqVQQGBiI0NBT9+vVDQkICAOD48eNQKBRa771atWqoUKGC+r0fPHgQtWvXhp+fn7pMVFQUUlNTcf78eXUZzX3klLGH4xcXF4ekpCSt+D08PBAeHq51DDw9PdGoUSN1mcjISEgkEhw+fFhdplWrVnByclKXiYqKwuXLl/H48WN1GXs5Trt27YKvry/CwsLw7rvv4uHDh+p1JeF4pKSkAAC8vb0BFN13pbiej/Iejxx//PEHypYti1q1amHcuHF4+vSpet2LfDyUSiVWrFiBJ0+eICIiosR/PiyNN10tYg8ePIBSqdT6cAKAn58fLl26ZKOoLCc8PBxLlixBWFgY7ty5g6lTp6Jly5Y4d+4ckpKS4OTkBE9PT61t/Pz8kJSUBABISkrSe2xy1hkrk5qaimfPnsHFxcVK767wct6Dvvg135+vr6/WegcHB3h7e2uVCQkJ0dlHzjovLy+DxylnH8VFx44d8dprryEkJASxsbEYP348OnXqhIMHD0Iqlb7wx0OlUuHDDz9E8+bNUatWLQAosu/K48ePi935SN/xAIC+ffuiYsWKCAwMxJkzZzBmzBhcvnwZq1evBvBiHo+zZ88iIiICGRkZKF26NP755x/UqFEDp06dKrGfD2tgIkQW1alTJ/XfderUQXh4OCpWrIiVK1cW6wSFbOeNN95Q/127dm3UqVMHlSpVwq5du9C+fXsbRlY0RowYgXPnzmHfvn22DqVYMHQ83nrrLfXftWvXRkBAANq3b4/Y2FhUqlSpqMMsEmFhYTh16hRSUlLw119/YeDAgdi9e7etw3rhsGmsiJUtWxZSqVSnd//du3fh7+9vo6isx9PTE1WrVsW1a9fg7++PzMxMJCcna5XRfO/+/v56j03OOmNl3N3di32ylfMejP3//f39ce/ePa31WVlZePTokUWOU3H/nIWGhqJs2bK4du0agBf7eIwcORIbNmzAzp07Ub58efXyovquFLfzkaHjoU94eDgAaH1OXrTj4eTkhMqVK6Nhw4aIiYlB3bp18e2335bYz4e1MBEqYk5OTmjYsCG2b9+uXqZSqbB9+3ZERETYMDLrSE9PR2xsLAICAtCwYUM4OjpqvffLly8jISFB/d4jIiJw9uxZrR++rVu3wt3dHTVq1FCX0dxHThl7OH4hISHw9/fXij81NRWHDx/WOgbJyck4fvy4usyOHTugUqnUJ/+IiAjs2bMHCoVCXWbr1q0ICwuDl5eXuow9HqfExEQ8fPgQAQEBAF7M4yGKIkaOHIl//vkHO3bs0GnWK6rvSnE5H+V3PPQ5deoUAGh9Tl6U42GISqWCXC4vcZ8Pq7N1b+2SaMWKFaJMJhOXLFkiXrhwQXzrrbdET09Prd799urjjz8Wd+3aJcbFxYn79+8XIyMjxbJly4r37t0TRTF7yGeFChXEHTt2iMeOHRMjIiLEiIgI9fY5Qz5feukl8dSpU+LmzZtFHx8fvUM+R48eLV68eFGcP39+sRo+n5aWJp48eVI8efKkCED8+uuvxZMnT4o3btwQRTF7+Lynp6e4du1a8cyZM2K3bt30Dp+vX7++ePjwYXHfvn1ilSpVtIaLJycni35+fuKbb74pnjt3TlyxYoXo6uqqM1zcwcFB/Oqrr8SLFy+KkydPtslwcWPHIy0tTfzkk0/EgwcPinFxceK2bdvEBg0aiFWqVBEzMjJeyOMhiqL47rvvih4eHuKuXbu0hoM/ffpUXaaovivF4XyU3/G4du2aOG3aNPHYsWNiXFycuHbtWjE0NFRs1arVC3k8RFEUx44dK+7evVuMi4sTz5w5I44dO1YUBEH877//RFEsWZ8Pa2MiZCNz584VK1SoIDo5OYlNmjQRDx06ZOuQLKJ3795iQECA6OTkJJYrV07s3bu3eO3aNfX6Z8+eie+9957o5eUlurq6iq+++qp4584drX3Ex8eLnTp1El1cXMSyZcuKH3/8sahQKLTK7Ny5U6xXr57o5OQkhoaGiosXLy6Kt2eSnTt3igB0HgMHDhRFMXsI/cSJE0U/Pz9RJpOJ7du3Fy9fvqy1j4cPH4p9+vQRS5cuLbq7u4uDBw8W09LStMqcPn1abNGihSiTycRy5cqJM2fO1Ill5cqVYtWqVUUnJyexZs2a4r///mu1922IsePx9OlT8aWXXhJ9fHxER0dHsWLFiuLw4cN1TrIv0vEQRVHv8QCg9Tkuyu+Krc9H+R2PhIQEsVWrVqK3t7cok8nEypUri6NHj9aaR0gUX5zjIYqiOGTIELFixYqik5OT6OPjI7Zv316dBIliyfp8WJsgiqJYdPVPRERERMUH+wgRERFRicVEiIiIiEosJkJERERUYjERIiIiohKLiRARERGVWEyEiIiIqMRiIkREREQlFhMhIiIiKrGYCBGRXRIEAWvWrLF1GCYZNGgQunfvbuswiEgPJkJEVCwlJSXh/fffR2hoKGQyGYKCgtC1a1edm0QSERWGg60DICLKKz4+Hs2bN4enpye+/PJL1K5dGwqFAlu2bMGIESNw6dIlW4dIRC8I1ggRUbHz3nvvQRAEHDlyBD169EDVqlVRs2ZNREdH49ChQ+pyDx48wKuvvgpXV1dUqVIF69atU69TKpUYOnQoQkJC4OLigrCwMHz77bdar5PTZPXVV18hICAAZcqUwYgRI6BQKNRlgoOD8fnnn2PIkCFwc3NDhQoV8OOPP2rt5+bNm+jVqxc8PT3h7e2Nbt26IT4+3joHh4gsiokQERUrjx49wubNmzFixAiUKlVKZ72np6f676lTp6JXr144c+YMOnfujH79+uHRo0cAAJVKhfLly2PVqlW4cOECJk2ahPHjx2PlypVa+9u5cydiY2Oxc+dO/Prrr1iyZAmWLFmiVWb27Nlo1KgRTp48iffeew/vvvsuLl++DABQKBSIioqCm5sb9u7di/3796N06dLo2LEjMjMzLXtwiMjybHfjeyIiXYcPHxYBiKtXrzZaDoA4YcIE9fP09HQRgLhp0yaD24wYMULs0aOH+vnAgQPFihUrillZWeplPXv2FHv37q1+XrFiRbF///7q5yqVSvT19RUXLFggiqIo/vbbb2JYWJioUqnUZeRyueji4iJu2bJF/TrdunXL550TkS2wjxARFSuiKJpctk6dOuq/S5UqBXd3d9y7d0+9bP78+fjll1+QkJCAZ8+eITMzE/Xq1dPaR82aNSGVStXPAwICcPbsWYOvIwgC/P391a9z+vRpXLt2DW5ublrbZGRkIDY21uT3QkS2wUSIiIqVKlWqQBAEkzpEOzo6aj0XBAEqlQoAsGLFCnzyySeYPXs2IiIi4Obmhi+//BKHDx82eR+mlElPT0fDhg3xxx9/6MTn4+OT73sgIttiIkRExYq3tzeioqIwf/58jBo1SqefUHJyslY/IUP279+PZs2a4b333lMvs0YNTYMGDfDnn3/C19cX7u7uFt8/EVkXO0sTUbEzf/58KJVKNGnSBH///TeuXr2Kixcv4rvvvkNERIRJ+6hSpQqOHTuGLVu24MqVK5g4cSKOHj1q8Vj79euHsmXLolu3bti7dy/i4uKwa9cujBo1ComJiRZ/PSKyLCZCRFTshIaG4sSJE2jbti0+/vhj1KpVCx06dMD27duxYMECk/bx9ttv47XXXkPv3r0RHh6Ohw8fatUOWYqrqyv27NmDChUq4LXXXkP16tUxdOhQZGRksIaIyA4Iojk9E4mIiIheIKwRIiIiohKLiRARERGVWEyEiIiIqMRiIkREREQlFhMhIiIiKrGYCBEREVGJxUSIiIiISiwmQkRERFRiMREiIiKiEouJEBEREZVYTISIiIioxPo/Q+hb4ZTPufQAAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "ps_ref.align_to(ps_sig)\n", "\n", - "s = slice(0*u.km/u.s, 200*u.km/u.s)\n", - "ta1 = ta1[s]\n", - "ta2 = ta2[s]" + "plt.figure()\n", + "plt.plot(ps_sig.flux)\n", + "plt.plot(ps_ref.flux)\n", + "plt.ylabel(f\"Antenna temperature ({ps_sig.flux.unit})\")\n", + "plt.xlabel(\"Channel\");" ] }, { "cell_type": "markdown", - "id": "6e9a8da0-c986-444a-9c58-10884fbb9cf6", + "id": "1961a051-3c7a-4435-ab0a-b608b06c4145", "metadata": {}, "source": [ - "Next, we plot the spectra as a function of velocity and as a function of channel." + "Now the spectra are aligned and can be averaged together." ] }, { "cell_type": "code", - "execution_count": 7, - "id": "e5ff3d24-63bd-49f6-a7b6-76a150f41c22", + "execution_count": 10, + "id": "cdf33158-62c0-4f66-a27d-f35fd22b12ea", + "metadata": {}, + "outputs": [], + "source": [ + "ps_avg = average_spectra((ps_sig, ps_ref))" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "1b0c1152-0072-4bd9-9a11-0d5c5cd09fec", "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, "metadata": {}, @@ -251,38 +359,39 @@ } ], "source": [ - "plt.figure(dpi=150)\n", - "\n", - "plt.subplot(211)\n", - "plt.title(\"In Velocity\")\n", - "plt.plot(ta1.spectral_axis.to(\"km/s\").value, ta1.flux, label=f\"IF={ta1.meta['IFNUM']}\")\n", - "plt.plot(ta2.spectral_axis.to(\"km/s\").value, ta2.flux, label=f\"IF={ta2.meta['IFNUM']}\")\n", - "plt.legend()\n", - "plt.xlabel(\"Velocity (km/s)\")\n", - "\n", - "plt.subplot(212)\n", - "plt.title(\"In Channels\")\n", - "plt.plot(ta1.flux)\n", - "plt.plot(ta2.flux)\n", - "plt.xlabel(\"Channel\")\n", - "\n", - "plt.gcf().supylabel(\"Antenna temperature (K)\")\n", - "\n", - "plt.tight_layout()\n" + "ps_avg.plot(xaxis_unit=\"chan\")" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "8ef254f2-4323-453b-825d-3ba8e9d1938e", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Noise on the average 0.26 K\n" + ] + } + ], + "source": [ + "print(f\"Noise on the average {ps_avg[5000:10000].stats()['rms']:.2f}\")" ] }, { "cell_type": "markdown", - "id": "3ba825a2-2ca3-4d8a-8ebc-456eaf337f13", + "id": "320a0e99-9042-44a9-b3f1-2a43bff985b8", "metadata": {}, "source": [ - "The difference is subtle, but the top panel shows that the spectral line is well aligned in velocity, whereas the bottom panel shows that the line centroids are slightly misaligned. If we were to average the two spectra together, the resulting line would look artificially broader than it is!" + "The resulting spectrum shows only one peak, at the frequency of the line, and the noise is smaller than in the individual states where the spectra overlapped (channels below ~18000). The noise improvement is better than $\\sqrt{2}$ since shifting the reference spectrum for the alignment artificially lowers its noise." ] }, { "cell_type": "code", "execution_count": null, - "id": "cdf33158-62c0-4f66-a27d-f35fd22b12ea", + "id": "e4536016-0561-4c61-89c9-e1b9dc67abd8", "metadata": {}, "outputs": [], "source": [] From 44727d083a59ef14c430f82bf73e1ee5e54d4a30 Mon Sep 17 00:00:00 2001 From: Marc Pound <22331890+mpound@users.noreply.github.com> Date: Fri, 11 Oct 2024 10:20:53 -0700 Subject: [PATCH 48/95] set _flag, remove to-be-fixed code from execution --- src/dysh/fits/gbtfitsload.py | 34 +++++++++++++++++----------------- 1 file changed, 17 insertions(+), 17 deletions(-) diff --git a/src/dysh/fits/gbtfitsload.py b/src/dysh/fits/gbtfitsload.py index d74010bb..1c444fc6 100644 --- a/src/dysh/fits/gbtfitsload.py +++ b/src/dysh/fits/gbtfitsload.py @@ -818,23 +818,23 @@ def _construct_integration_number(self): idx = g.index intnumarray[idx] = intnums[i] self._index["INTNUM"] = intnumarray - # Wait until after INTNUM PR: - # self._flag["INTNUM"] = intnumarray - - # Here need to add it as a new column in the BinTableHDU, - # but we have to sort out FITSINDEX. - # s.add_col("INTNUM",intnumarray) - fits_index_changes = indices_where_value_changes("FITSINDEX", self._index) - lf = len(fits_index_changes) - for i in range(lf): - fic = fits_index_changes[i] - if i + 1 < lf: - fici = fits_index_changes[i + 1] - else: - fici = -1 - fi = self["FITSINDEX"][fic] - # @todo fix this MWP - # self._sdf[fi].add_col("INTNUM", intnumarray[fic:fici]) # bintable index??? + self._flag["INTNUM"] = intnumarray + + if False: + # Here need to add it as a new column in the BinTableHDU, + # but we have to sort out FITSINDEX. + # s.add_col("INTNUM",intnumarray) + fits_index_changes = indices_where_value_changes("FITSINDEX", self._index) + lf = len(fits_index_changes) + for i in range(lf): + fic = fits_index_changes[i] + if i + 1 < lf: + fici = fits_index_changes[i + 1] + else: + fici = -1 + fi = self["FITSINDEX"][fic] + # @todo fix this MWP + # self._sdf[fi].add_col("INTNUM", intnumarray[fic:fici]) # bintable index??? def info(self): """Return information on the HDUs contained in this object. See :meth:`~astropy.HDUList/info()`""" From 3497ad4f0e81ecc0b58f437802ba39d1c17e13fe Mon Sep 17 00:00:00 2001 From: astrofle Date: Fri, 11 Oct 2024 13:27:11 -0400 Subject: [PATCH 49/95] Fix: typo in notebook --- notebooks/examples/align_spectra.ipynb | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/notebooks/examples/align_spectra.ipynb b/notebooks/examples/align_spectra.ipynb index b36a9b85..29daee33 100644 --- a/notebooks/examples/align_spectra.ipynb +++ b/notebooks/examples/align_spectra.ipynb @@ -261,7 +261,7 @@ "id": "1d1b09e3-969d-40db-89bc-f933756423e2", "metadata": {}, "source": [ - "If we were to average the data, then the result would have the spectral line misaligned, since the averaging is done per channel. We can see this if we calibrate the data without separating the signal and reference states. This is lees than ideal because the signal gets reduced and the line shows up in two different places even though it is the same line." + "If we were to average the data, then the result would have the spectral line misaligned, since the averaging is done per channel. We can see this if we calibrate the data without separating the signal and reference states. This is less than ideal because the signal gets reduced and the line shows up in two different places even though it is the same line." ] }, { From ccdcd32dfbf098e80eb57055ddf304da685e475a Mon Sep 17 00:00:00 2001 From: "pre-commit-ci[bot]" <66853113+pre-commit-ci[bot]@users.noreply.github.com> Date: Mon, 14 Oct 2024 18:14:59 +0000 Subject: [PATCH 50/95] [pre-commit.ci] pre-commit autoupdate MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit updates: - [github.com/pre-commit/pre-commit-hooks: v4.6.0 → v5.0.0](https://github.com/pre-commit/pre-commit-hooks/compare/v4.6.0...v5.0.0) - [github.com/psf/black: 24.8.0 → 24.10.0](https://github.com/psf/black/compare/24.8.0...24.10.0) --- .pre-commit-config.yaml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml index c19064c9..de4e221b 100644 --- a/.pre-commit-config.yaml +++ b/.pre-commit-config.yaml @@ -6,7 +6,7 @@ default_language_version: # See https://pre-commit.com/hooks.html for more hooks repos: - repo: 'https://github.com/pre-commit/pre-commit-hooks' - rev: v4.6.0 + rev: v5.0.0 hooks: - id: trailing-whitespace exclude: '(notebooks|attic|benchmark|testdata)/.*' @@ -30,7 +30,7 @@ repos: - id: isort exclude: '(notebooks|attic|benchmark|testdata)/.*' - repo: 'https://github.com/psf/black' - rev: 24.8.0 + rev: 24.10.0 hooks: - id: black exclude: '(notebooks|attic|benchmark|testdata)/.*' From 46cbc2fba7450f478bcaacb399d80c4419905fec Mon Sep 17 00:00:00 2001 From: astrofle Date: Tue, 15 Oct 2024 10:41:34 -0400 Subject: [PATCH 51/95] Fix: add link to numpy docs in fake_spectrum --- src/dysh/spectra/spectrum.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/dysh/spectra/spectrum.py b/src/dysh/spectra/spectrum.py index 909be8d0..c2472066 100644 --- a/src/dysh/spectra/spectrum.py +++ b/src/dysh/spectra/spectrum.py @@ -929,7 +929,7 @@ def fake_spectrum(cls, nchan=1024, seed=None, **kwargs): nchan : int, optional Number of channels. The default is 1024. - seed : {None, int, array_like[ints], SeedSequence, BitGenerator, Generator}, optional + seed : {None, int, array_like[ints], `numpy.random.SeedSequence`, `numpy.random.BitGenerator`, `numpy.random.Generator`}, optional A seed to initialize the `BitGenerator`. If None, then fresh, unpredictable entropy will be pulled from the OS. If an int or array_like[ints] is passed, then all values must be non-negative and will be passed to `SeedSequence` to derive the initial `BitGenerator` state. One may also pass in a `SeedSequence` instance. From cd2dc6855bd2e12882030a767e944d7ee0e214f6 Mon Sep 17 00:00:00 2001 From: astrofle Date: Tue, 15 Oct 2024 11:48:26 -0400 Subject: [PATCH 52/95] Add: align option to align_spectra (Issue #402) --- src/dysh/spectra/spectrum.py | 21 +++++++++++++++++---- src/dysh/spectra/tests/test_spectrum.py | 12 +++++++++++- 2 files changed, 28 insertions(+), 5 deletions(-) diff --git a/src/dysh/spectra/spectrum.py b/src/dysh/spectra/spectrum.py index c2472066..8ad02a52 100644 --- a/src/dysh/spectra/spectrum.py +++ b/src/dysh/spectra/spectrum.py @@ -1511,9 +1511,10 @@ def spectrum_reader_gbtidl(fileobj, **kwargs): # registry.register_writer("mrt", Spectrum, spectrum_reader_mrt) -def average_spectra(spectra, equal_weights=False): +def average_spectra(spectra, equal_weights=False, align=False): """ - Average `spectra`. + Average `spectra`. The resulting `average` will have an exposure equal to the sum of the exposures, + and coordinates and system temperature equal to the weighted average of the coordinates and system temperatures. Parameters ---------- @@ -1523,6 +1524,9 @@ def average_spectra(spectra, equal_weights=False): equal_weights : bool If `False` use the inverse of the variance, as computed from the radiometer equation, as weights. If `True` all spectra have the same weight. + align : bool + If `True` align the `spectra` to the first element. + This uses `Spectrum.align_to`. Returns ------- @@ -1549,8 +1553,17 @@ def average_spectra(spectra, equal_weights=False): raise ValueError( f"Element {i} of `spectra` has units {s.flux.unit}, but the first element has units {units}." ) - data_array[i] = s.data - weights[i] = core.tsys_weight(s.meta["EXPOSURE"], s.meta["CDELT1"], s.meta["TSYS"]) + if align: + s_ = s._copy() + if i > 0: + s_.align_to(spectra[0]) + else: + s_ = s + data_array[i] = s_.data + if not equal_weights: + weights[i] = core.tsys_weight(s.meta["EXPOSURE"], s.meta["CDELT1"], s.meta["TSYS"]) + else: + weights[i] = 1.0 exposures[i] = s.meta["EXPOSURE"] tsyss[i] = s.meta["TSYS"] xcoos[i] = s.meta["CRVAL2"] diff --git a/src/dysh/spectra/tests/test_spectrum.py b/src/dysh/spectra/tests/test_spectrum.py index cedc8147..53431d69 100644 --- a/src/dysh/spectra/tests/test_spectrum.py +++ b/src/dysh/spectra/tests/test_spectrum.py @@ -26,7 +26,7 @@ def fit_gauss(spectrum): return g_fit -def compare_spectrum(one, other, ignore_history=False): +def compare_spectrum(one, other, ignore_history=False, ignore_comments=False): """ """ for k, v in vars(one).items(): @@ -34,6 +34,8 @@ def compare_spectrum(one, other, ignore_history=False): continue if ignore_history and k == "_history": continue + if ignore_history and k == "_comments": + continue elif k in ["_wcs"]: v.to_header() == vars(other)[k].to_header() elif k in ["_spectral_axis"]: @@ -504,6 +506,14 @@ def test_average_spectra(self): Tests for average_spectra. Although not a class method of `Spectra` it is included here to reuse the setup method of the test. * Test that it does not crash. + * Test that it does not crash whit alignment. """ + ps0_org = self.ps0._copy() + ps1_org = self.ps1._copy() + avg = average_spectra((self.ps0, self.ps1)) + + avg = average_spectra((self.ps0, self.ps1), align=True) + compare_spectrum(ps0_org, self.ps0, ignore_history=True, ignore_comments=True) + compare_spectrum(ps1_org, self.ps1, ignore_history=True, ignore_comments=True) From 11e388b01a601dc9e9d409b9c542e396bece19e6 Mon Sep 17 00:00:00 2001 From: Thomas Chamberlin Date: Tue, 15 Oct 2024 19:15:02 -0400 Subject: [PATCH 53/95] Fix some log statements (#404) --- src/dysh/fits/gbtfitsload.py | 4 +++- src/dysh/spectra/scan.py | 2 +- 2 files changed, 4 insertions(+), 2 deletions(-) diff --git a/src/dysh/fits/gbtfitsload.py b/src/dysh/fits/gbtfitsload.py index d74010bb..e2a974b8 100644 --- a/src/dysh/fits/gbtfitsload.py +++ b/src/dysh/fits/gbtfitsload.py @@ -1391,7 +1391,7 @@ def getfs( for k, v in preselected.items(): if k not in kwargs: kwargs[k] = v - logger.debug("scans/w sel:", scans, self._selection) + logger.debug(f"scans/w sel: {scans} {self._selection}") fs_selection = copy.deepcopy(self._selection) # now downselect with any additional kwargs logger.debug(f"SELECTION FROM MIXED KWARGS {kwargs}") @@ -1408,6 +1408,8 @@ def getfs( scanblock = ScanBlock() for i in range(len(self._sdf)): + logger.debug(f"Processing file {i}: {self._sdf[i].filename}") + df = select_from("FITSINDEX", i, _sf) for k in ifnum: _ifdf = select_from("IFNUM", k, df) # one FSScan per ifnum diff --git a/src/dysh/spectra/scan.py b/src/dysh/spectra/scan.py index 58bf8a07..49891404 100644 --- a/src/dysh/spectra/scan.py +++ b/src/dysh/spectra/scan.py @@ -1717,7 +1717,7 @@ def do_fold(sig, ref, sig_freq, ref_freq, remove_wrap=False, shift_method="fft") self._exposure[i] = self.exposure[i] self._add_calibration_meta() - logger.debug("Calibrated {nspect} spectra with fold={_fold} and use_sig={self._use_sig}") + logger.debug(f"Calibrated {nspect} spectra with fold={_fold} and use_sig={self._use_sig}") # tip o' the hat to Pedro S. for exposure and delta_freq @property From bf66119b88d3a2fd35b0705ca3189d39d60b4376 Mon Sep 17 00:00:00 2001 From: Thomas Chamberlin Date: Thu, 17 Oct 2024 18:48:32 -0400 Subject: [PATCH 54/95] Fix all(?) remaining invalid print->logger conversions (#407) --- src/dysh/fits/gbtfitsload.py | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/src/dysh/fits/gbtfitsload.py b/src/dysh/fits/gbtfitsload.py index e2a974b8..c10e5019 100644 --- a/src/dysh/fits/gbtfitsload.py +++ b/src/dysh/fits/gbtfitsload.py @@ -908,7 +908,7 @@ def gettp( # now downselect with any additional kwargs ps_selection._select_from_mixed_kwargs(**kwargs) _sf = ps_selection.final - logger.debug("SF=", _sf) + logger.debug(f"SF={_sf}") ifnum = uniq(_sf["IFNUM"]) plnum = uniq(_sf["PLNUM"]) scans = uniq(_sf["SCAN"]) @@ -938,9 +938,9 @@ def gettp( # df = select_from("CAL", TF[cal], df) # the rows with the selected sig state and all cal states tprows = list(_sifdf["ROW"]) - logger.debug("TPROWS len=", len(tprows)) - logger.debug("CALROWS on len=", len(calrows["ON"])) - logger.debug("fitsindex=", i) + logger.debug(f"TPROWS len={len(tprows)}") + logger.debug(f"CALROWS on len={len(calrows['ON'])}") + logger.debug(f"fitsindex={i}") if len(tprows) == 0: continue g = TPScan( From eb9837e1527bbbce1a04140ed8f443cfe4a9b457 Mon Sep 17 00:00:00 2001 From: astrofle Date: Mon, 21 Oct 2024 10:39:39 -0400 Subject: [PATCH 55/95] Docs: change How-to for Recipes --- docs/source/how-tos/index.rst | 6 +++--- docs/source/index.rst | 4 ++-- 2 files changed, 5 insertions(+), 5 deletions(-) diff --git a/docs/source/how-tos/index.rst b/docs/source/how-tos/index.rst index 88e10c80..defe7ef3 100644 --- a/docs/source/how-tos/index.rst +++ b/docs/source/how-tos/index.rst @@ -1,8 +1,8 @@ .. _howtos: -########################################### -:octicon:`terminal;2em;green` How-To Guides -########################################### +##################################### +:octicon:`terminal;2em;green` Recipes +##################################### Practical step-by-step guides to help you achieve a specific goal. Most useful when you're trying to get something done. diff --git a/docs/source/index.rst b/docs/source/index.rst index 29b5f6c8..7dba9adf 100644 --- a/docs/source/index.rst +++ b/docs/source/index.rst @@ -35,7 +35,7 @@ Contents :shadow: md :margin: 2 2 0 0 - :octicon:`terminal;3em;green` **How-To Guides** + :octicon:`terminal;3em;green` **Recipes** Practical step-by-step guides to help you achieve a specific goal. @@ -47,7 +47,7 @@ Contents :outline: :click-parent: - Go to How-To Guides + Go to Recipes .. grid-item-card:: :shadow: md From c5a692e0799f70e345a83aeb2f6fa5c8ef094e53 Mon Sep 17 00:00:00 2001 From: astrofle Date: Mon, 21 Oct 2024 11:40:03 -0400 Subject: [PATCH 56/95] Change: align_to and shift now return a copy --- src/dysh/spectra/spectrum.py | 28 ++++++++++++------------- src/dysh/spectra/tests/test_spectrum.py | 8 +++---- 2 files changed, 18 insertions(+), 18 deletions(-) diff --git a/src/dysh/spectra/spectrum.py b/src/dysh/spectra/spectrum.py index 8ad02a52..cf875aaf 100644 --- a/src/dysh/spectra/spectrum.py +++ b/src/dysh/spectra/spectrum.py @@ -542,23 +542,26 @@ def shift(self, s, remove_wrap=True, fill_value=np.nan, method="fft"): "fft" uses a phase shift. """ - new_data = core.data_shift(self.data, s, remove_wrap=remove_wrap, fill_value=fill_value, method=method) + new_spec = self._copy() + new_data = core.data_shift(new_spec.data, s, remove_wrap=remove_wrap, fill_value=fill_value, method=method) # Update data values. - self._data = new_data + new_spec._data = new_data # Update metadata. - self.meta["CRPIX1"] += s + new_spec.meta["CRPIX1"] += s # Update WCS. - self.wcs.wcs.crpix[0] += s + new_spec.wcs.wcs.crpix[0] += s # Update `SpectralAxis` values. # Radial velocity needs to be copied by hand. - radial_velocity = deepcopy(self._spectral_axis._radial_velocity) - new_spectral_axis_values = self.wcs.spectral.pixel_to_world(np.arange(self.flux.shape[-1])) - self._spectral_axis = self.spectral_axis.replicate(value=new_spectral_axis_values) - self._spectral_axis._radial_velocity = radial_velocity + radial_velocity = deepcopy(new_spec._spectral_axis._radial_velocity) + new_spectral_axis_values = new_spec.wcs.spectral.pixel_to_world(np.arange(new_spec.flux.shape[-1])) + new_spec._spectral_axis = new_spec.spectral_axis.replicate(value=new_spectral_axis_values) + new_spec._spectral_axis._radial_velocity = radial_velocity + + return new_spec def find_shift(self, other, units=None, frame=None): """ @@ -633,7 +636,7 @@ def align_to(self, other, units=None, frame=None, remove_wrap=True, fill_value=n """ s = self.find_shift(other, units=units, frame=frame) - self.shift(s, remove_wrap=remove_wrap, fill_value=fill_value, method=method) + return self.shift(s, remove_wrap=remove_wrap, fill_value=fill_value, method=method) @property def equivalencies(self): @@ -1554,12 +1557,9 @@ def average_spectra(spectra, equal_weights=False, align=False): f"Element {i} of `spectra` has units {s.flux.unit}, but the first element has units {units}." ) if align: - s_ = s._copy() if i > 0: - s_.align_to(spectra[0]) - else: - s_ = s - data_array[i] = s_.data + s = s.align_to(spectra[0]) + data_array[i] = s.data if not equal_weights: weights[i] = core.tsys_weight(s.meta["EXPOSURE"], s.meta["CDELT1"], s.meta["TSYS"]) else: diff --git a/src/dysh/spectra/tests/test_spectrum.py b/src/dysh/spectra/tests/test_spectrum.py index 53431d69..3a5f2fb2 100644 --- a/src/dysh/spectra/tests/test_spectrum.py +++ b/src/dysh/spectra/tests/test_spectrum.py @@ -412,7 +412,7 @@ def test_shift(self): # Apply method to be tested. shift = 5.5 - spec.shift(shift) + spec = spec.shift(shift) # Internal tests. assert np.all(np.isnan(spec[: int(np.round(shift))].data)) @@ -480,20 +480,20 @@ def test_align_to(self): org_spec = spec._copy() # Align to itself. - spec.align_to(spec) + spec = spec.align_to(spec) compare_spectrum(spec, org_spec, ignore_history=True) assert np.all((spec - org_spec).data == 0) # Align to a shifted version. shift = 5 - spec.shift(shift) + spec = spec.shift(shift) assert np.all((spec.data[shift:] - org_spec.data[:-shift]) == 0.0) # Align to a shifted version with signal. fshift = 0.5 spec = self.ss._copy() org_spec = spec._copy() - spec.shift(shift + fshift) + spec = spec.shift(shift + fshift) # The amplitude of the signal will decrease because of the sampling. tol = np.sqrt( (1 - np.exp(-0.5 * (fshift) ** 2 / spec.meta["STDD"] ** 2)) ** 2.0 From 84297e092f30b3eb5acd216bccfcd498fda84854 Mon Sep 17 00:00:00 2001 From: Marc Pound <22331890+mpound@users.noreply.github.com> Date: Mon, 21 Oct 2024 09:13:46 -0700 Subject: [PATCH 57/95] convert channel selection to mask --- src/dysh/util/core.py | 50 +++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 50 insertions(+) diff --git a/src/dysh/util/core.py b/src/dysh/util/core.py index 25b9825c..e7121673 100644 --- a/src/dysh/util/core.py +++ b/src/dysh/util/core.py @@ -14,6 +14,8 @@ # import pandas as pd from astropy.time import Time +ALL_CHANNELS = "all channels" + def select_from(key, value, df): """ @@ -325,3 +327,51 @@ def ensure_ascii(text: Union[str, list[str]], check: bool = False) -> Union[str, for c in text: clean_text.append(_ensure_ascii_str(c)) return clean_text + + +def convert_array_to_mask(a, length, value=True): + """ + This method interprets a simple or compound array and returns a numpy mask + of length `length`. Single arrays/tuples will be treated as element index lists; + nested arrays will be treated as *inclusive* ranges, for instance: + + `` + # mask elements 1 and 10 + convert_array_to_mask([1,10]) + # mask elements 1 thru 10 inclusive + convert_array_to_mask([[1,10]]) + # mask ranges 1 thru 10 and 47 thru 56 inclusive, and element 75 + convert_array_to_mask([[1,10], [47,56], 75)]) + # tuples also work, though can be harder for a human to read + convert_array_to_mask(((1,10), [47,56], 75)) + `` + + Parameters + ---------- + a : number or array-like + The + length : int + The length of the mask to return, e.g. the number of channels in a spectrum. + + value : bool + The value to fill the mask with. True to mask data, False to unmask. + + Returns + ------- + mask : ~np.ndarray + A numpy array where the mask is True according to the rules above. + + """ + + if a == _ALL_CHANNELS: + return np.full(length, value) + + mask = np.full(length, False) + + for v in a: + if isinstance(v, (tuple, list, np.ndarray)) and len(v) == 2: + # If there are just two numbers, interpret is as an inclusive range + mask[v[0] : v[1] + 1] = value + else: + mask[v] = value + return mask From ce72a66e3d9fa8883427d65da8a470d7c394449a Mon Sep 17 00:00:00 2001 From: Marc Pound <22331890+mpound@users.noreply.github.com> Date: Mon, 21 Oct 2024 09:14:17 -0700 Subject: [PATCH 58/95] apply flags work --- src/dysh/fits/gbtfitsload.py | 61 ++++++++++++++++++++++++++++++------ 1 file changed, 51 insertions(+), 10 deletions(-) diff --git a/src/dysh/fits/gbtfitsload.py b/src/dysh/fits/gbtfitsload.py index 95770fc4..428efa53 100644 --- a/src/dysh/fits/gbtfitsload.py +++ b/src/dysh/fits/gbtfitsload.py @@ -12,9 +12,16 @@ from dysh.log import logger from ..coordinates import Observatory, decode_veldef -from ..log import HistoricalBase, dysh_date, log_call_to_history, log_call_to_result +from ..log import HistoricalBase, log_call_to_history, log_call_to_result from ..spectra.scan import FSScan, NodScan, PSScan, ScanBlock, SubBeamNodScan, TPScan -from ..util import consecutive, indices_where_value_changes, keycase, select_from, uniq +from ..util import ( + consecutive, + convert_array_to_mask, + indices_where_value_changes, + keycase, + select_from, + uniq, +) from ..util.selection import Flag, Selection from .sdfitsload import SDFITSLoad @@ -211,6 +218,7 @@ def flags(self): @property def final_flags(self): + # this method is not particularly useful. consider removing it """ The merged flag rules in the Flag object. See :meth:`~dysh.util.SelectionBase.final` @@ -221,13 +229,9 @@ def final_flags(self): The final merged flags """ - all_channels_flagged = np.where(self._table["CHAN"] == "") - + # all_channels_flagged = np.where(self._table["CHAN"] == "")j return self._flag.final - def _set_flags(self): - self.final_flags - def filenames(self): """ The list of SDFITS filenames(s) that make up this GBTFITSLoad object @@ -629,6 +633,11 @@ def select_channel(self, chan, tag=None): """ self._selection.select_channel(tag=tag, chan=chan) + @log_call_to_history + def clear_selection(self): + """Clear all selections for these data""" + self._selection.clear() + @log_call_to_history def flag(self, tag=None, **kwargs): """Add one or more exact flag rules, e.g., `key1 = value1, key2 = value2, ...` @@ -739,6 +748,41 @@ def flag_channel(self, chan, tag=None): """ self._flag.flag_channel(tag=tag, chan=chan) + @log_call_to_history + def apply_flags(self): + """ + Set the channel flags according to the rules specified in the `flags` attribute. + This sets numpy masks in the underlying `SDFITSLoad` objects. + + Returns + ------- + None. + + """ + # Loop over the dict of flagged channels, which + # have the same key as the flag rules. + # For all SDFs in each flag rule, set the flag mask(s) + # for their rows. The index of the sdf._flagmask array is the bintable index + for key, chan in self._flag._flag_channel_selection.items(): + selection = self._flag.get(key) + # chan will be a list or a list of lists + # If it is a single list, it is just a list of channels + # if it is list of lists, then it is upper lower inclusive + dfs = selection.groupby(["FITSINDEX", "BINTABLE"]) + print(f"{key=} {chan=}") + # the dict key for the groups is a tuple (fitsindex,bintable) + for i, ((fi, bi), g) in enumerate(dfs): + chan_mask = convert_array_to_mask(chan, self._sdf[fi].nchan(bi)) + rows = g["ROW"].to_numpy() + self._sdf[fi]._flag_mask[bi][rows] = chan_mask + + @log_call_to_history + def clear_flags(self): + """Clear all flags for these data""" + for sdf in self._sdf: + sdf._init_flags() + self._flag.clear() + def _create_index_if_needed(self): if self._selection is not None: return @@ -760,9 +804,6 @@ def _create_index_if_needed(self): self._construct_procedure() self._construct_integration_number() - def _create_flagmask(self): - """Creates the mask which is NFILESxNINTxNCHAN which will be used for setting channel flags""" - def _construct_procedure(self): """ Construct the procedure string (PROC) from OBSMODE and add it to the index (i.e., a new SDFITS column). From 1cf5c7631529e2a02a04fa84def08cca228e2bec Mon Sep 17 00:00:00 2001 From: Marc Pound <22331890+mpound@users.noreply.github.com> Date: Mon, 21 Oct 2024 09:14:43 -0700 Subject: [PATCH 59/95] init_flags --- src/dysh/fits/sdfitsload.py | 27 ++++++++++++++++----------- 1 file changed, 16 insertions(+), 11 deletions(-) diff --git a/src/dysh/fits/sdfitsload.py b/src/dysh/fits/sdfitsload.py index a36c386b..1f571294 100644 --- a/src/dysh/fits/sdfitsload.py +++ b/src/dysh/fits/sdfitsload.py @@ -57,11 +57,11 @@ def __init__(self, filename, source=None, hdu=None, **kwargs): if doindex: self.create_index() # add default channel masks - self._flagmask = [] - # if doflag: - # for i in range(len(self._bintable)): - # nc = self.nchan(i) - # self._flagmask.append(np.full(nc, False)) + # These are numpy masks where False is not flagged, True is flagged. + # There is one 2-D flag mask arraywith shape NROWSxNCHANNELS per bintable + self._flagmask = None + if doflag: + self._init_flags() def __del__(self): # We need to ensure that any open HDUs are properly @@ -72,6 +72,15 @@ def __del__(self): except Exception: pass + def _init_flags(self): + """initialize the channel masks to False""" + self._flagmask = np.empty(len(self._bintable), dtype=object) + for i in range(len(self._flagmask)): + nc = self.nchan(i) + nr = self.nrows(i) + print(f"{nr=} {nc=}") + self._flagmask[i] = np.full((nr, nc), fill_value=False) + def info(self): """Return the `~astropy.HDUList` info()""" return self._hdu.info() @@ -444,7 +453,7 @@ def getspec(self, i, bintable=0, observer_location=None): meta["NAXIS1"] = len(data) if "CUNIT1" not in meta: meta["CUNIT1"] = "Hz" # @todo this is in gbtfits.hdu[0].header['TUNIT11'] but is it always TUNIT11? - logger.debug(f"Fixing CUNIT1 to Hz") + logger.debug("Fixing CUNIT1 to Hz") meta["CUNIT2"] = "deg" # is this always true? meta["CUNIT3"] = "deg" # is this always true? restfrq = meta["RESTFREQ"] @@ -472,7 +481,7 @@ def getspec(self, i, bintable=0, observer_location=None): for k, v, c in h.cards: if k == ukey: if bunit != v: - logger.info(f"Found BUNIT={bunit}, now finding {uKey}={v}, using the latter") + logger.info(f"Found BUNIT={bunit}, now finding {ukey}={v}, using the latter") bunit = v break if bunit is not None: @@ -865,7 +874,6 @@ def _update_binary_table_column(self, column_dict): self._bintable[0].data[k] = v # otherwise we need to add rather than replace/update else: - # print("ADDING {k}={v}") self._add_binary_table_column(k, v, 0) else: start = 0 @@ -904,7 +912,6 @@ def _update_binary_table_column(self, column_dict): def __getitem__(self, items): # items can be a single string or a list of strings. # Want case insensitivity - # @todo deal with "DATA" if isinstance(items, str): items = items.upper() elif isinstance(items, (Sequence, np.ndarray)): @@ -923,7 +930,6 @@ def __getitem__(self, items): return self._index[items] def __setitem__(self, items, values): - # @todo deal with "DATA" if isinstance(items, str): items = items.upper() d = {items: values} @@ -943,7 +949,6 @@ def __setitem__(self, items, values): else: iset = set(items) col_exists = len(set(self.columns).intersection(iset)) > 0 - # col_in_selection = if col_exists and "DATA" not in items: warnings.warn("Changing an existing SDFITS column") try: From 1d96a61fcb2e91a081185050a207ca058eff5f3c Mon Sep 17 00:00:00 2001 From: Marc Pound <22331890+mpound@users.noreply.github.com> Date: Mon, 21 Oct 2024 09:17:39 -0700 Subject: [PATCH 60/95] mostly documentation --- src/dysh/util/selection.py | 48 +++++++++++++++++++++++++++++++------- 1 file changed, 40 insertions(+), 8 deletions(-) diff --git a/src/dysh/util/selection.py b/src/dysh/util/selection.py index f4de01d0..d67d1d60 100644 --- a/src/dysh/util/selection.py +++ b/src/dysh/util/selection.py @@ -15,7 +15,7 @@ from ..log import logger # from ..fits import default_sdfits_columns -from . import gbt_timestamp_to_time, generate_tag, keycase +from . import ALL_CHANNELS, gbt_timestamp_to_time, generate_tag, keycase default_aliases = { "freq": "crval1", @@ -636,9 +636,11 @@ def _base_select_channel(self, chan, tag=None): Select channels and/or channel ranges. These are NOT used in :meth:`final` but rather will be used to create a mask for calibration or flagging. Single arrays/tuples will be treated as channel lists; - nested arrays will be treated as ranges, for instance + nested arrays will be treated as *inclusive* ranges. For instance: `` + # select channel 24 + select_channel(24) # selects channels 1 and 10 select_channel([1,10]) # selects channels 1 thru 10 inclusive @@ -649,6 +651,8 @@ def _base_select_channel(self, chan, tag=None): select_channel(((1,10), [47,56], 75)) `` + *Note* : channel numbers start at zero. + Parameters ---------- chan : number, or array-like @@ -829,6 +833,21 @@ def __deepcopy__(self, memo): warnings.resetwarnings() return result + def get(self, key): + """Get the selection/flag rule by its ID + + Parameters + ---------- + key : int + The ID value. See :meth:`show`. + + Returns + ------- + ~pandas.DataFrame + The selection/flag rule + """ + return self._selection_rules[key] + class Selection(SelectionBase): """This class contains the methods for creating rules to select data from an SDFITS object. @@ -932,9 +951,11 @@ def select_channel(self, chan, tag=None): Select channels and/or channel ranges. These are NOT used in :meth:`final` but rather will be used to create a mask for calibration or flagging. Single arrays/tuples will be treated as channel lists; - nested arrays will be treated as ranges, for instance + nested arrays will be treated as *inclusive* ranges. For instance: `` + # select channel 24 + select_channel(24) # selects channels 1 and 10 select_channel([1,10]) # selects channels 1 thru 10 inclusive @@ -945,6 +966,8 @@ def select_channel(self, chan, tag=None): select_channel(((1,10), [47,56], 75)) `` + *Note* : channel numbers start at zero. + Parameters ---------- chan : number, or array-like @@ -992,7 +1015,9 @@ def flag(self, tag=None, **kwargs): """Add one or more exact flag rules, e.g., `key1 = value1, key2 = value2, ...` If `value` is array-like then a match to any of the array members will be flagged. For instance `flag(object=['3C273', 'NGC1234'])` will select data for either of those - objects and `flag(ifnum=[0,2])` will flag IF number 0 or IF number 2. + objects and `flag(ifnum=[0,2])` will flag IF number 0 or IF number 2. Channels can be flagged + using keyword `chan`, e.g., `flag(object='MBM12',chan=[0,23])` will flag channels 0 through 23 *inclusive* + for object MBM12. Parameters ---------- @@ -1009,19 +1034,23 @@ def flag(self, tag=None, **kwargs): if chan is not None: self._check_numbers(chan=chan) self._base_select(tag, **kwargs) # don't do this unless chan input is good. + idx = len(self._table) - 1 if chan is not None: - idx = len(self._table) - 1 self._table[idx]["CHAN"] = str(chan) self._flag_channel_selection[idx] = chan + else: + self._flag_channel_selection[idx] = ALL_CHANNELS def flag_channel(self, chan, tag=None, **kwargs): """ Flag channels and/or channel ranges for all rows. These are NOT used in :meth:`final` but rather will be used to create a mask for - flagging. Single arrays/tuples will be treated as channel lists; - nested arrays will be treated as ranges, for instance + flagging. Single arrays/tuples will be treated as *channel lists; + nested arrays will be treated as *inclusive* ranges. For instance: `` + # flag channel 24 + flag_channel(24) # flag channels 1 and 10 flag_channel([1,10]) # flags channels 1 thru 10 inclusive @@ -1032,7 +1061,10 @@ def flag_channel(self, chan, tag=None, **kwargs): flag_channel(((1,10), [47,56], 75)) `` - Parameters + *Note* : channel numbers start at zero + + + Parameters ---------- chan : number, or array-like The channels to flag From cbd2ccd9ae47584de222c847d5576e5f5be4a3e9 Mon Sep 17 00:00:00 2001 From: Marc Pound <22331890+mpound@users.noreply.github.com> Date: Mon, 21 Oct 2024 10:51:29 -0700 Subject: [PATCH 61/95] flagmask propertly set. fix single channel flagging --- src/dysh/fits/gbtfitsload.py | 5 ++++- src/dysh/util/core.py | 2 +- src/dysh/util/selection.py | 4 ++++ 3 files changed, 9 insertions(+), 2 deletions(-) diff --git a/src/dysh/fits/gbtfitsload.py b/src/dysh/fits/gbtfitsload.py index 428efa53..e807bbc3 100644 --- a/src/dysh/fits/gbtfitsload.py +++ b/src/dysh/fits/gbtfitsload.py @@ -725,6 +725,8 @@ def flag_channel(self, chan, tag=None): nested arrays will be treated as ranges, for instance `` + # flag channel 128 + flag_channel(128) # flags channels 1 and 10 flag_channel([1,10]) # flags channels 1 thru 10 inclusive @@ -764,6 +766,7 @@ def apply_flags(self): # For all SDFs in each flag rule, set the flag mask(s) # for their rows. The index of the sdf._flagmask array is the bintable index for key, chan in self._flag._flag_channel_selection.items(): + print(f"{key=} {chan=}") selection = self._flag.get(key) # chan will be a list or a list of lists # If it is a single list, it is just a list of channels @@ -774,7 +777,7 @@ def apply_flags(self): for i, ((fi, bi), g) in enumerate(dfs): chan_mask = convert_array_to_mask(chan, self._sdf[fi].nchan(bi)) rows = g["ROW"].to_numpy() - self._sdf[fi]._flag_mask[bi][rows] = chan_mask + self._sdf[fi]._flagmask[bi][rows] = chan_mask @log_call_to_history def clear_flags(self): diff --git a/src/dysh/util/core.py b/src/dysh/util/core.py index e7121673..9413e98f 100644 --- a/src/dysh/util/core.py +++ b/src/dysh/util/core.py @@ -363,7 +363,7 @@ def convert_array_to_mask(a, length, value=True): """ - if a == _ALL_CHANNELS: + if a == ALL_CHANNELS: return np.full(length, value) mask = np.full(length, False) diff --git a/src/dysh/util/selection.py b/src/dysh/util/selection.py index d67d1d60..904ed142 100644 --- a/src/dysh/util/selection.py +++ b/src/dysh/util/selection.py @@ -672,6 +672,8 @@ def _base_select_channel(self, chan, tag=None): "You can only have one channel selection rule. Remove the old rule before creating a new one." ) self._check_numbers(chan=chan) + if isinstance(chan, numbers.Number): + chan = [int(chan)] self._channel_selection = chan self._addrow({"CHAN": str(chan)}, dataframe=self, tag=tag) @@ -1032,6 +1034,8 @@ def flag(self, tag=None, **kwargs): """ chan = kwargs.pop("chan", None) if chan is not None: + if isinstance(chan, numbers.Number): + chan = [int(chan)] self._check_numbers(chan=chan) self._base_select(tag, **kwargs) # don't do this unless chan input is good. idx = len(self._table) - 1 From f866853f2afd13b6ef5b8477211c467e345fb27c Mon Sep 17 00:00:00 2001 From: Marc Pound <22331890+mpound@users.noreply.github.com> Date: Mon, 21 Oct 2024 12:26:49 -0700 Subject: [PATCH 62/95] propagate apply_flags. fix nchan in sdfitsload --- src/dysh/fits/gbtfitsload.py | 72 +++++++++++++++++++++++++++++++----- src/dysh/fits/sdfitsload.py | 2 +- src/dysh/spectra/scan.py | 16 +++++++- 3 files changed, 79 insertions(+), 11 deletions(-) diff --git a/src/dysh/fits/gbtfitsload.py b/src/dysh/fits/gbtfitsload.py index e807bbc3..ce694dd7 100644 --- a/src/dysh/fits/gbtfitsload.py +++ b/src/dysh/fits/gbtfitsload.py @@ -896,6 +896,7 @@ def gettp( weights="tsys", bintable=None, smoothref=1, + apply_flags=False, **kwargs, ): """ @@ -918,6 +919,8 @@ def gettp( None or 'tsys' to indicate equal weighting or tsys weighting to use in time averaging. Default: 'tsys' bintable : int, optional Limit to the input binary table index. The default is None which means use all binary tables. + smooth_ref: int, optional + the number of channels in the reference to boxcar smooth prior to calibration **kwargs : dict Optional additional selection keyword arguments, typically given as key=value, though a dictionary works too. @@ -936,7 +939,7 @@ def gettp( else: _final = self._index scans = kwargs.get("scan", None) - debug = kwargs.pop("debug", False) + # debug = kwargs.pop("debug", False) kwargs = keycase(kwargs) if type(scans) is int: scans = [scans] @@ -997,6 +1000,7 @@ def gettp( bintable, calibrate, smoothref=smoothref, + apply_flags=apply_flags, ) g.merge_commentary(self) scanblock.append(g) @@ -1008,7 +1012,15 @@ def gettp( @log_call_to_result def getps( - self, calibrate=True, timeaverage=True, polaverage=False, weights="tsys", bintable=None, smoothref=1, **kwargs + self, + calibrate=True, + timeaverage=True, + polaverage=False, + weights="tsys", + bintable=None, + smoothref=1, + apply_flags=False, + **kwargs, ): """ Retrieve and calibrate position-switched data. @@ -1028,6 +1040,10 @@ def getps( bintable : int, optional Limit to the input binary table index. The default is None which means use all binary tables. (This keyword should eventually go away) + smooth_ref: int, optional + the number of channels in the reference to boxcar smooth prior to calibration + apply_flags : boolean, optional. If True, apply flags before calibration. + See :meth:`apply_flags`. Default: False **kwargs : dict Optional additional selection keyword arguments, typically given as key=value, though a dictionary works too. @@ -1136,6 +1152,7 @@ def getps( bintable=bintable, calibrate=calibrate, smoothref=smoothref, + apply_flags=apply_flags, ) g.merge_commentary(self) scanblock.append(g) @@ -1148,7 +1165,15 @@ def getps( @log_call_to_result def getnod( - self, calibrate=True, timeaverage=True, polaverage=False, weights="tsys", bintable=None, smoothref=1, **kwargs + self, + calibrate=True, + timeaverage=True, + polaverage=False, + weights="tsys", + bintable=None, + smoothref=1, + apply_flags=False, + **kwargs, ): """ Retrieve and calibrate nodding data. @@ -1172,6 +1197,10 @@ def getnod( bintable : int, optional Limit to the input binary table index. The default is None which means use all binary tables. (This keyword should eventually go away) + smooth_ref: int, optional + the number of channels in the reference to boxcar smooth prior to calibration + apply_flags : boolean, optional. If True, apply flags before calibration. + See :meth:`apply_flags`. Default: False **kwargs : dict Optional additional selection keyword arguments, typically given as key=value, though a dictionary works too. @@ -1203,8 +1232,8 @@ def get_nod_beams(sdf): if len(d1["FDNUM"].unique()) == 1 and len(d2["FDNUM"].unique()) == 1: beam1 = d1["FDNUM"].unique()[0] beam2 = d2["FDNUM"].unique()[0] - fdnum1 = d1["FEED"].unique()[0] - fdnum2 = d2["FEED"].unique()[0] + # fdnum1 = d1["FEED"].unique()[0] + # fdnum2 = d2["FEED"].unique()[0] return [beam1, beam2] else: # one more attempt (this can happen if PROCSCAN contains "Unknown") @@ -1337,6 +1366,7 @@ def get_nod_beams(sdf): bintable=bintable, calibrate=calibrate, smoothref=smoothref, + apply_flags=apply_flags, ) g.merge_commentary(self) scanblock.append(g) @@ -1362,6 +1392,7 @@ def getfs( weights="tsys", bintable=None, smoothref=1, + apply_flags=False, observer_location=Observatory["GBT"], **kwargs, ): @@ -1394,6 +1425,10 @@ def getfs( The default is 'tsys'. bintable : int, optional Limit to the input binary table index. The default is None which means use all binary tables. + smooth_ref: int, optional + the number of channels in the reference to boxcar smooth prior to calibration + apply_flags : boolean, optional. If True, apply flags before calibration. + See :meth:`apply_flags`. Default: False observer_location : `~astropy.coordinates.EarthLocation` Location of the observatory. See `~dysh.coordinates.Observatory`. This will be transformed to `~astropy.coordinates.ITRS` using the time of @@ -1487,6 +1522,7 @@ def getfs( use_sig=use_sig, observer_location=observer_location, smoothref=1, + apply_flags=apply_flags, debug=debug, ) g.merge_commentary(self) @@ -1510,6 +1546,7 @@ def subbeamnod( weights="tsys", bintable=None, smoothref=1, + apply_flags=False, **kwargs, ): """Get a subbeam nod power scan, optionally calibrating it. @@ -1532,6 +1569,10 @@ def subbeamnod( None to indicate equal weighting or 'tsys' to indicate tsys weighting to use in time averaging. Default: 'tsys' bintable : int, optional Limit to the input binary table index. The default is None which means use all binary tables. + smooth_ref: int, optional + the number of channels in the reference to boxcar smooth prior to calibration + apply_flags : boolean, optional. If True, apply flags before calibration. + See :meth:`apply_flags`. Default: False **kwargs : dict Optional additional selection keyword arguments, typically given as key=value, though a dictionary works too. @@ -1547,7 +1588,7 @@ def subbeamnod( else: _final = self._index scans = kwargs.get("scan", None) - debug = kwargs.pop("debug", False) + # debug = kwargs.pop("debug", False) kwargs = keycase(kwargs) logger.debug(kwargs) @@ -1658,6 +1699,7 @@ def subbeamnod( bintable, calibrate=calibrate, smoothref=smoothref, + apply_flags=apply_flags, ) ) calrows = {"ON": sgon, "OFF": sgoff} @@ -1673,9 +1715,17 @@ def subbeamnod( bintable, calibrate=calibrate, smoothref=smoothref, + apply_flags=apply_flags, ) ) - sb = SubBeamNodScan(sigtp, reftp, calibrate=calibrate, weights=weights, smoothref=smoothref) + sb = SubBeamNodScan( + sigtp, + reftp, + calibrate=calibrate, + weights=weights, + smoothref=smoothref, + apply_flags=apply_flags, + ) scanblock.append(sb) elif method == "scan": for sdfi in range(len(self._sdf)): @@ -1701,6 +1751,7 @@ def subbeamnod( weights=weights, calibrate=calibrate, smoothref=smoothref, + apply_flags=apply_flags, ) sigtp.append(tpon[0]) tpoff = self.gettp( @@ -1715,6 +1766,7 @@ def subbeamnod( weights=weights, calibrate=calibrate, smoothref=smoothref, + apply_flags=apply_flags, ) reftp.append(tpoff[0]) # in order to reproduce gbtidl tsys, we need to do a normal @@ -1730,7 +1782,8 @@ def subbeamnod( weights=weights, calibrate=calibrate, smoothref=smoothref, - ) # .timeaverage(weights=w) + apply_flags=apply_flags, + ) fulltp.append(ftp[0]) sb = SubBeamNodScan( sigtp, @@ -1738,6 +1791,7 @@ def subbeamnod( calibrate=calibrate, weights=weights, smoothref=smoothref, + apply_flags=apply_flags, ) sb.merge_commentary(self) scanblock.append(sb) @@ -2252,7 +2306,7 @@ def write( given as key=value, though a dictionary works too. e.g., `ifnum=1, plnum=[2,3]` etc. """ - debug = kwargs.pop("debug", False) + # debug = kwargs.pop("debug", False) logger.debug(kwargs) selection = Selection(self._index) if len(kwargs) > 0: diff --git a/src/dysh/fits/sdfitsload.py b/src/dysh/fits/sdfitsload.py index 1f571294..f3e27979 100644 --- a/src/dysh/fits/sdfitsload.py +++ b/src/dysh/fits/sdfitsload.py @@ -528,7 +528,7 @@ def nchan(self, bintable): Number channels in the first spectrum of the input bintable """ - return np.shape(self.rawspectrum(1, bintable))[0] + return np.shape(self.rawspectrum(0, bintable))[0] def npol(self, bintable): """ diff --git a/src/dysh/spectra/scan.py b/src/dysh/spectra/scan.py index 49891404..f115e0be 100644 --- a/src/dysh/spectra/scan.py +++ b/src/dysh/spectra/scan.py @@ -630,6 +630,7 @@ class TPScan(ScanBase): whether or not to calibrate the data. If `True`, the data will be (calon - caloff)*0.5, otherwise it will be SDFITS row data. Default:True smoothref: int the number of channels in the reference to boxcar smooth prior to calibration + apply_flags : boolean, optional. If True, apply flags before calibration. Notes ----- @@ -665,6 +666,7 @@ def __init__( bintable, calibrate=True, smoothref=1, + apply_flags=False, observer_location=Observatory["GBT"], ): ScanBase.__init__(self, gbtfits) @@ -674,6 +676,7 @@ def __init__( self._calstate = calstate self._scanrows = scanrows self._smoothref = smoothref + self._apply_flags = apply_flags if self._smoothref > 1: warnings.warn(f"TP smoothref={self._smoothref} not implemented yet") @@ -958,6 +961,7 @@ class PSScan(ScanBase): whether or not to calibrate the data. If true, data will be calibrated as TSYS*(ON-OFF)/OFF. Default: True smoothref: int the number of channels in the reference to boxcar smooth prior to calibration + apply_flags : boolean, optional. If True, apply flags before calibration. observer_location : `~astropy.coordinates.EarthLocation` Location of the observatory. See `~dysh.coordinates.Observatory`. This will be transformed to `~astropy.coordinates.ITRS` using the time of @@ -974,6 +978,7 @@ def __init__( bintable, calibrate=True, smoothref=1, + apply_flags=False, observer_location=Observatory["GBT"], ): ScanBase.__init__(self, gbtfits) @@ -984,6 +989,7 @@ def __init__( self._scanrows = scanrows self._nrows = len(self._scanrows["ON"]) self._smoothref = smoothref + self._apply_flags = apply_flags # print(f"PJT len(scanrows ON) {len(self._scanrows['ON'])}") # print(f"PJT len(scanrows OFF) {len(self._scanrows['OFF'])}") # print("PJT scans", scans) @@ -1197,6 +1203,7 @@ class NodScan(ScanBase): Default: True smoothref: int the number of channels in the reference to boxcar smooth prior to calibration (if applicable) + apply_flags : boolean, optional. If True, apply flags before calibration. observer_location : `~astropy.coordinates.EarthLocation` Location of the observatory. See `~dysh.coordinates.Observatory`. This will be transformed to `~astropy.coordinates.ITRS` using the time of @@ -1214,6 +1221,7 @@ def __init__( bintable, calibrate=True, smoothref=1, + apply_flags=False, observer_location=Observatory["GBT"], ): ScanBase.__init__(self, gbtfits) @@ -1221,6 +1229,7 @@ def __init__( self._scanrows = scanrows self._nrows = len(self._scanrows["ON"]) self._smoothref = smoothref + self._apply_flags = apply_flags self._beam1 = beam1 # @todo allow having no calrow where noise diode was not fired @@ -1441,6 +1450,7 @@ class FSScan(ScanBase): Whether to use the sig as the sig, or the ref as the sig. Default: True smoothref: int The number of channels in the reference to boxcar smooth prior to calibration. + apply_flags : boolean, optional. If True, apply flags before calibration. observer_location : `~astropy.coordinates.EarthLocation` Location of the observatory. See `~dysh.coordinates.Observatory`. This will be transformed to `~astropy.coordinates.ITRS` using the time of @@ -1459,6 +1469,7 @@ def __init__( shift_method="fft", use_sig=True, smoothref=1, + apply_flags=False, observer_location=Observatory["GBT"], debug=False, ): @@ -1472,7 +1483,7 @@ def __init__( self._smoothref = smoothref if self._smoothref > 1: print(f"FS smoothref={self._smoothref} not implemented yet") - + self._apply_flags = apply_flags self._sigonrows = sorted(list(set(self._calrows["ON"]).intersection(set(self._sigrows["ON"])))) self._sigoffrows = sorted(list(set(self._calrows["OFF"]).intersection(set(self._sigrows["ON"])))) self._refonrows = sorted(list(set(self._calrows["ON"]).intersection(set(self._sigrows["OFF"])))) @@ -1811,6 +1822,7 @@ class SubBeamNodScan(ScanBase): Whether or not to calibrate the data. smoothref: int the number of channels in the reference to boxcar smooth prior to calibration + apply_flags : boolean, optional. If True, apply flags before calibration. observer_location : `~astropy.coordinates.EarthLocation` Location of the observatory. See `~dysh.coordinates.Observatory`. This will be transformed to `~astropy.coordinates.ITRS` using the time of @@ -1831,6 +1843,7 @@ def __init__( reftp, calibrate=True, smoothref=1, + apply_flags=False, observer_location=Observatory["GBT"], **kwargs, ): @@ -1859,6 +1872,7 @@ def __init__( self._smoothref = smoothref if self._smoothref > 1: print(f"SubBeamNodScan smoothref={self._smoothref} not implemented yet") + self._apply_flags = apply_flags self._observer_location = observer_location self._calibrated = None if calibrate: From 4ea09d8d566b1b47695524a51922f5fb7a1af79d Mon Sep 17 00:00:00 2001 From: Marc Pound <22331890+mpound@users.noreply.github.com> Date: Mon, 21 Oct 2024 15:29:08 -0700 Subject: [PATCH 63/95] add masks to calibrated data --- src/dysh/fits/gbtfitsload.py | 18 ++++++++- src/dysh/fits/sdfitsload.py | 34 +++++++++++----- src/dysh/spectra/scan.py | 77 +++++++++++++++++++----------------- src/dysh/spectra/spectrum.py | 40 +++++++++++++------ 4 files changed, 108 insertions(+), 61 deletions(-) diff --git a/src/dysh/fits/gbtfitsload.py b/src/dysh/fits/gbtfitsload.py index ce694dd7..b16df87f 100644 --- a/src/dysh/fits/gbtfitsload.py +++ b/src/dysh/fits/gbtfitsload.py @@ -278,7 +278,7 @@ def index(self, hdu=None, bintable=None, fitsindex=None): return df # override sdfits version - def rawspectra(self, bintable, fitsindex): + def rawspectra(self, bintable, fitsindex, setmask=False): """ Get the raw (unprocessed) spectra from the input bintable. @@ -288,6 +288,8 @@ def rawspectra(self, bintable, fitsindex): The index of the `bintable` attribute fitsindex: int the index of the FITS file contained in this GBTFITSLoad. Default:0 + setmask : boolean + If True, set the mask according to the current flags. Defaultf:false Returns ------- @@ -933,7 +935,8 @@ def gettp( """ TF = {True: "T", False: "F"} - + if apply_flags: + self.apply_flags() if len(self._selection._selection_rules) > 0: _final = self._selection.final else: @@ -1060,6 +1063,9 @@ def getps( ScanBlock containing the individual `~spectra.scan.PSScan`s """ + + if apply_flags: + self.apply_flags() # either the user gave scans on the command line (scans !=None) or pre-selected them # with select_fromion.selectXX(). In either case make sure the matching ON or OFF # is in the starting selection. @@ -1244,6 +1250,8 @@ def get_nod_beams(sdf): return list(b) return [] + if apply_flags: + self.apply_flags() nod_beams = get_nod_beams(self) feeds = kwargs.pop("fdnum", None) if feeds is None: @@ -1452,6 +1460,9 @@ def getfs( """ debug = kwargs.pop("debug", False) logger.debug(kwargs) + + if apply_flags: + self.apply_flags() # either the user gave scans on the command line (scans !=None) or pre-selected them # with self.selection.selectXX() if len(self._selection._selection_rules) > 0: @@ -1583,6 +1594,9 @@ def subbeamnod( data : `~spectra.scan.ScanBlock` A ScanBlock containing one or more `~spectra.scan.SubBeamNodScan` """ + + if apply_flags: + self.apply_flags() if len(self._selection._selection_rules) > 0: _final = self._selection.final else: diff --git a/src/dysh/fits/sdfitsload.py b/src/dysh/fits/sdfitsload.py index f3e27979..0dd079e0 100644 --- a/src/dysh/fits/sdfitsload.py +++ b/src/dysh/fits/sdfitsload.py @@ -367,7 +367,7 @@ def _find_bintable_and_row(self, row): """ return (self._index.iloc[row]["BINTABLE"], self._index.iloc[row]["ROW"]) - def rawspectra(self, bintable): + def rawspectra(self, bintable, setmask=False): """ Get the raw (unprocessed) spectra from the input bintable. @@ -375,16 +375,23 @@ def rawspectra(self, bintable): ---------- bintable : int The index of the `bintable` attribute + setmask : bool + If True, set the data mask according to the current flags in the `_flagmask` attribute. If False, set the data mask to False. Returns ------- - rawspectra : ~numpy.ndarray - The DATA column of the input bintable + rawspectra : ~numpy.ma.MaskedArray + The DATA column of the input bintable, masked according to `setmask` """ - return self._bintable[bintable].data[:]["DATA"] + data = self._bintable[bintable].data[:]["DATA"] + if setmask: + rawspec = np.ma.MaskedArray(data, mask=self._flagmask[bintable]) + else: + rawspec = np.ma.MaskedArray(data, mask=False) + return rawspec - def rawspectrum(self, i, bintable=0): + def rawspectrum(self, i, bintable=0, setmask=False): """ Get a single raw (unprocessed) spectrum from the input bintable. @@ -394,18 +401,25 @@ def rawspectrum(self, i, bintable=0): The row index to retrieve. bintable : int or None The index of the `bintable` attribute. If None, the underlying bintable is computed from i - + setmask : bool + If True, set the data mask according to the current flags in the `_flagmask` attribute. Returns ------- - rawspectrum : ~numpy.ndarray - The i-th row of DATA column of the input bintable + rawspectrum : ~numpy.ma.MaskedArray + The i-th row of DATA column of the input bintable, masked according to `setmask` """ if bintable is None: (bt, row) = self._find_bintable_and_row(i) - return self._bintable[bt].data[:]["DATA"][row] + data = self._bintable[bt].data[:]["DATA"][row] + else: + data = self._bintable[bintable].data[:]["DATA"][i] + row = i + if setmask: + rawspec = np.ma.MaskedArray(data, mask=self._flagmask[bintable][row]) else: - return self._bintable[bintable].data[:]["DATA"][i] + rawspec = np.ma.MaskedArray(data, False) + return rawspec def getrow(self, i, bintable=0): """ diff --git a/src/dysh/spectra/scan.py b/src/dysh/spectra/scan.py index f115e0be..bac712af 100644 --- a/src/dysh/spectra/scan.py +++ b/src/dysh/spectra/scan.py @@ -11,15 +11,15 @@ from astropy import constants as ac from astropy.io.fits import BinTableHDU, Column from astropy.table import Table, vstack +from astropy.utils.masked import Masked from dysh.spectra import core from ..coordinates import Observatory from ..log import HistoricalBase, log_call_to_history, logger from ..util import uniq -from .core import ( +from .core import ( # fft_shift, average, - fft_shift, find_non_blanks, mean_tsys, sq_weighted_avg, @@ -132,12 +132,6 @@ def _validate_defaults(self): if type(self._scan) != int: raise (f"{self.__class__.__name__}._scan is not an int: {type(self._scan)}") - # class ScanMixin: - # """This class describes the common interface to all Scan classes. - ## A Scan represents one IF, one feed, and one or more polarizations. - # Derived classes *must* implement :meth:`calibrate`. - # """ - @property def scan(self): """ @@ -705,8 +699,8 @@ def __init__( self._refonrows = sorted(list(set(self._calrows["ON"]).intersection(set(self._scanrows)))) # all cal=F states where sig=sigstate self._refoffrows = sorted(list(set(self._calrows["OFF"]).intersection(set(self._scanrows)))) - self._refcalon = gbtfits.rawspectra(self._bintable_index)[self._refonrows] - self._refcaloff = gbtfits.rawspectra(self._bintable_index)[self._refoffrows] + self._refcalon = gbtfits.rawspectra(self._bintable_index, setmask=apply_flags)[self._refonrows] + self._refcaloff = gbtfits.rawspectra(self._bintable_index, setmask=apply_flags)[self._refoffrows] # now remove blanked integrations # seems like this should be done for all Scan classes! # PS: yes. @@ -1022,9 +1016,9 @@ def __init__( self._refoffrows = sorted(list(set(self._calrows["OFF"]).intersection(set(self._scanrows["OFF"])))) self._sigcalon = gbtfits.rawspectra(self._bintable_index)[self._sigonrows] self._nchan = len(self._sigcalon[0]) - self._sigcaloff = gbtfits.rawspectra(self._bintable_index)[self._sigoffrows] - self._refcalon = gbtfits.rawspectra(self._bintable_index)[self._refonrows] - self._refcaloff = gbtfits.rawspectra(self._bintable_index)[self._refoffrows] + self._sigcaloff = gbtfits.rawspectra(self._bintable_index, setmask=apply_flags)[self._sigoffrows] + self._refcalon = gbtfits.rawspectra(self._bintable_index, setmask=apply_flags)[self._refonrows] + self._refcaloff = gbtfits.rawspectra(self._bintable_index, setmask=apply_flags)[self._refoffrows] self._tsys = None self._exposure = None self._calibrated = None @@ -1060,8 +1054,11 @@ def calibrated(self, i): ------- spectrum : `~spectra.spectrum.Spectrum` """ + # @todo suppress astropy INFO message "overwriting Masked Quantity's current mask with specified mask." s = Spectrum.make_spectrum( - self._calibrated[i] * u.K, meta=self.meta[i], observer_location=self._observer_location + Masked(self._calibrated[i] * u.K, self._calibrated[i].mask), + meta=self.meta[i], + observer_location=self._observer_location, ) s.merge_commentary(self) return s @@ -1077,10 +1074,10 @@ def calibrate(self, **kwargs): self._status = 1 nspect = self.nrows // 2 - self._calibrated = np.empty((nspect, self._nchan), dtype="d") + self._calibrated = np.ma.empty((nspect, self._nchan), dtype="d") self._tsys = np.empty(nspect, dtype="d") self._exposure = np.empty(nspect, dtype="d") - tcal = list(self._sdfits.index(bintable=self._bintable_index).iloc[self._refonrows]["TCAL"]) + tcal = self._sdfits.index(bintable=self._bintable_index).iloc[self._refonrows]["TCAL"].to_numpy() # @todo this loop could be replaced with clever numpy if len(tcal) != nspect: raise Exception(f"TCAL length {len(tcal)} and number of spectra {nspect} don't match") @@ -1257,15 +1254,15 @@ def __init__( self._refonrows = sorted(list(set(self._calrows["ON"]).intersection(set(self._scanrows["OFF"])))) self._refoffrows = sorted(list(set(self._calrows["OFF"]).intersection(set(self._scanrows["OFF"])))) if beam1: - self._sigcalon = gbtfits.rawspectra(self._bintable_index)[self._sigonrows] - self._sigcaloff = gbtfits.rawspectra(self._bintable_index)[self._sigoffrows] - self._refcalon = gbtfits.rawspectra(self._bintable_index)[self._refonrows] - self._refcaloff = gbtfits.rawspectra(self._bintable_index)[self._refoffrows] + self._sigcalon = gbtfits.rawspectra(self._bintable_index, setmask=apply_flags)[self._sigonrows] + self._sigcaloff = gbtfits.rawspectra(self._bintable_index, setmask=apply_flags)[self._sigoffrows] + self._refcalon = gbtfits.rawspectra(self._bintable_index, setmask=apply_flags)[self._refonrows] + self._refcaloff = gbtfits.rawspectra(self._bintable_index, setmask=apply_flags)[self._refoffrows] else: - self._sigcalon = gbtfits.rawspectra(self._bintable_index)[self._refonrows] - self._sigcaloff = gbtfits.rawspectra(self._bintable_index)[self._refoffrows] - self._refcalon = gbtfits.rawspectra(self._bintable_index)[self._sigonrows] - self._refcaloff = gbtfits.rawspectra(self._bintable_index)[self._sigoffrows] + self._sigcalon = gbtfits.rawspectra(self._bintable_index, setmask=apply_flags)[self._refonrows] + self._sigcaloff = gbtfits.rawspectra(self._bintable_index, setmask=apply_flags)[self._refoffrows] + self._refcalon = gbtfits.rawspectra(self._bintable_index, setmask=apply_flags)[self._sigonrows] + self._refcaloff = gbtfits.rawspectra(self._bintable_index, setmask=apply_flags)[self._sigoffrows] self._nchan = len(self._sigcalon[0]) self._tsys = None self._exposure = None @@ -1303,7 +1300,9 @@ def calibrated(self, i): spectrum : `~spectra.spectrum.Spectrum` """ s = Spectrum.make_spectrum( - self._calibrated[i] * u.K, meta=self.meta[i], observer_location=self._observer_location + Masked(self._calibrated[i] * u.K, self._calibrated[i].mask), + meta=self.meta[i], + observer_location=self._observer_location, ) s.merge_commentary(self) return s @@ -1319,10 +1318,10 @@ def calibrate(self, **kwargs): self._status = 1 nspect = self.nrows // 2 - self._calibrated = np.empty((nspect, self._nchan), dtype="d") + self._calibrated = np.ma.empty((nspect, self._nchan), dtype="d") self._tsys = np.empty(nspect, dtype="d") self._exposure = np.empty(nspect, dtype="d") - tcal = list(self._sdfits.index(bintable=self._bintable_index).iloc[self._refonrows]["TCAL"]) + tcal = self._sdfits.index(bintable=self._bintable_index).iloc[self._refonrows]["TCAL"].to_numpy() # @todo this loop could be replaced with clever numpy if len(tcal) != nspect: raise Exception(f"TCAL length {len(tcal)} and number of spectra {nspect} don't match") @@ -1532,10 +1531,10 @@ def __init__( # @todo use gbtfits.velocity_convention(veldef,velframe) # so quick with slicing! - self._sigcalon = gbtfits.rawspectra(self._bintable_index)[self._sigonrows] - self._sigcaloff = gbtfits.rawspectra(self._bintable_index)[self._sigoffrows] - self._refcalon = gbtfits.rawspectra(self._bintable_index)[self._refonrows] - self._refcaloff = gbtfits.rawspectra(self._bintable_index)[self._refoffrows] + self._sigcalon = gbtfits.rawspectra(self._bintable_index, setmask=apply_flags)[self._sigonrows] + self._sigcaloff = gbtfits.rawspectra(self._bintable_index, setmask=apply_flags)[self._sigoffrows] + self._refcalon = gbtfits.rawspectra(self._bintable_index, setmask=apply_flags)[self._refonrows] + self._refcaloff = gbtfits.rawspectra(self._bintable_index, setmask=apply_flags)[self._refoffrows] self._nchan = len(self._sigcalon[0]) self._tsys = None self._exposure = None @@ -1573,7 +1572,9 @@ def calibrated(self, i): spectrum : `~spectra.spectrum.Spectrum` """ s = Spectrum.make_spectrum( - self._calibrated[i] * u.K, meta=self.meta[i], observer_location=self._observer_location + Masked(self._calibrated[i] * u.K, self._calibrated[i].mask), + meta=self.meta[i], + observer_location=self._observer_location, ) s.merge_commentary(self) return s @@ -1674,7 +1675,7 @@ def do_fold(sig, ref, sig_freq, ref_freq, remove_wrap=False, shift_method="fft") _fold = kwargs.get("fold", False) _mode = 1 # 1: keep the sig else: keep the ref (not externally supported) nspect = self.nrows // 2 - self._calibrated = np.empty((nspect, self._nchan), dtype="d") + self._calibrated = np.ma.empty((nspect, self._nchan), dtype="d") self._tsys = np.empty(nspect, dtype="d") self._exposure = np.empty(nspect, dtype="d") # @@ -1690,7 +1691,7 @@ def do_fold(sig, ref, sig_freq, ref_freq, remove_wrap=False, shift_method="fft") print("FS: shift=%g nchan=%d" % (chan_shift, self._nchan)) # tcal is the same for REF and SIG, and the same for all integrations actually. - tcal = list(self._sdfits.index(bintable=self._bintable_index).iloc[self._sigonrows]["TCAL"]) + tcal = self._sdfits.index(bintable=self._bintable_index).iloc[self._sigonrows]["TCAL"].to_numpy() if self._debug: print("TCAL:", len(tcal), tcal[0]) if len(tcal) != nspect: @@ -1885,7 +1886,7 @@ def calibrate(self, **kwargs): self._tsys = np.empty(nspect, dtype=float) self._exposure = np.empty(nspect, dtype=float) self._delta_freq = np.empty(nspect, dtype=float) - self._calibrated = np.empty((nspect, self._nchan), dtype=float) + self._calibrated = np.ma.empty((nspect, self._nchan), dtype=float) for i in range(nspect): sig = self._sigtp[i].timeaverage(weights=kwargs["weights"]) @@ -1911,7 +1912,11 @@ def calibrated(self, i): rfq = restfrq * u.Unit(meta["CUNIT1"]) restfreq = rfq.to("Hz").value meta["RESTFRQ"] = restfreq # WCS wants no E - s = Spectrum.make_spectrum(self._calibrated[i] * u.K, meta=meta, observer_location=self._observer_location) + s = Spectrum.make_spectrum( + Masked(self._calibrated[i] * u.K, self._calibrated[i].mask), + meta=meta, + observer_location=self._observer_location, + ) s.merge_commentary(self) return s diff --git a/src/dysh/spectra/spectrum.py b/src/dysh/spectra/spectrum.py index 8ad02a52..f50750df 100644 --- a/src/dysh/spectra/spectrum.py +++ b/src/dysh/spectra/spectrum.py @@ -1053,7 +1053,8 @@ def fake_spectrum(cls, nchan=1024, seed=None, **kwargs): @classmethod def make_spectrum(cls, data, meta, use_wcs=True, observer_location=None): # , shift_topo=False): - """Factory method to create a Spectrum object from a data and header. + """Factory method to create a Spectrum object from a data and header. The the data are masked, + the Spectrum mask will be set to the data mask. Parameters ---------- @@ -1166,18 +1167,31 @@ def make_spectrum(cls, data, meta, use_wcs=True, observer_location=None): ) obsitrs = None - s = cls( - flux=data, - wcs=wcs, - meta=meta, - velocity_convention=vc, - radial_velocity=target.radial_velocity, - rest_value=meta["RESTFRQ"] * u.Hz, - observer=obsitrs, - target=target, - ) - # s._history = [] - # s._comments = [] + if np.ma.is_masked(data): + print("data are masked") + s = cls( + flux=data, + wcs=wcs, + meta=meta, + velocity_convention=vc, + radial_velocity=target.radial_velocity, + rest_value=meta["RESTFRQ"] * u.Hz, + observer=obsitrs, + target=target, + mask=data.mask, + ) + else: + print("data are NOT masked") + s = cls( + flux=data, + wcs=wcs, + meta=meta, + velocity_convention=vc, + radial_velocity=target.radial_velocity, + rest_value=meta["RESTFRQ"] * u.Hz, + observer=obsitrs, + target=target, + ) # For some reason, Spectrum1D.spectral_axis created with WCS do not inherit # the radial velocity. In fact, they get no radial_velocity attribute at all! # This method creates a new spectral_axis with the given radial velocity. From 12b9f2b5e6e71647bf1296a064b8470da2a8bf89 Mon Sep 17 00:00:00 2001 From: Marc Pound <22331890+mpound@users.noreply.github.com> Date: Mon, 21 Oct 2024 17:08:39 -0700 Subject: [PATCH 64/95] working except for one dang failing test --- src/dysh/fits/tests/test_gbtfitsload.py | 19 ++++++++++++++++++- 1 file changed, 18 insertions(+), 1 deletion(-) diff --git a/src/dysh/fits/tests/test_gbtfitsload.py b/src/dysh/fits/tests/test_gbtfitsload.py index 7726d6a7..83067679 100644 --- a/src/dysh/fits/tests/test_gbtfitsload.py +++ b/src/dysh/fits/tests/test_gbtfitsload.py @@ -253,6 +253,7 @@ def test_gettp(self): 8: {"SCAN": 6, "IFNUM": 2, "PLNUM": 0, "CAL": False, "SIG": True}, } for k, v in tests.items(): + print(f"{k}, {v}") if v["SIG"] == False: with pytest.raises(Exception): tps = sdf.gettp(scan=v["SCAN"], ifnum=v["IFNUM"], plnum=v["PLNUM"], cal=v["CAL"], sig=v["SIG"]) @@ -269,7 +270,12 @@ def test_gettp(self): else: # CAL=True cal = tps[0]._refcalon.astype(np.float64) - assert np.all(tp.flux.value == np.nanmean(cal, axis=0)) + cal = cal.data + diff = tp.flux.value - np.nanmean(cal, axis=0) + # print(np.where(diff != 0)) + # print(diff[np.where(diff > 1e-8)]) + assert np.all(diff == 0) + # assert np.all(np.abs(diff) < 1e-8) # Check that selection is being applied properly. tp_scans = sdf.gettp(scan=[6, 7], plnum=0) @@ -433,6 +439,17 @@ def test_getps_smoothref(self): except KeyError: continue + def test_getps_flagging(self): + path = util.get_project_testdata() / "TGBT21A_501_11" + data_file = path / "TGBT21A_501_11.raw.vegas.fits" + sdf = gbtfitsload.GBTFITSLoad(data_file) + sdf.flag_channel([[10, 20], [30, 41]]) + sb = sdf.getps(scan=152, ifnum=0, plnum=0, apply_flags=True) + ta = sb.timeaverage() + print(np.where(ta.mask)) + expected_mask = np.hstack([np.arange(10, 21), np.arange(30, 42)]) + assert np.where(ta.mask)[0] == expected_mask + def test_write_single_file(self, tmp_path): "Test that writing an SDFITS file works when subselecting data" p = util.get_project_testdata() / "AGBT20B_014_03.raw.vegas" From 18a719f3498f1a473dcfa7b2fbe9e413f37e5d25 Mon Sep 17 00:00:00 2001 From: astrofle Date: Tue, 22 Oct 2024 10:57:00 -0400 Subject: [PATCH 65/95] Docs: add nodding and spectral alignment material --- docs/source/how-tos/index.rst | 16 ++++++++++++++++ docs/source/tutorials/index.rst | 4 ++++ 2 files changed, 20 insertions(+) diff --git a/docs/source/how-tos/index.rst b/docs/source/how-tos/index.rst index defe7ef3..84737709 100644 --- a/docs/source/how-tos/index.rst +++ b/docs/source/how-tos/index.rst @@ -71,6 +71,21 @@ Practical step-by-step guides to help you achieve a specific goal. Most useful w Data IO + .. grid-item-card:: + :shadow: md + :margin: 2 2 0 0 + + :material-outlined:`compare_arrows;3em;green` **Align Spectra** + + How to read and save data + + .. button-link:: examples/align_spectra.html + :color: primary + :outline: + :click-parent: + + Align Spectra + .. toctree:: :maxdepth: 4 :hidden: @@ -79,3 +94,4 @@ Practical step-by-step guides to help you achieve a specific goal. Most useful w examples/metadata_management examples/smoothing examples/dataIO + examples/align_spectra diff --git a/docs/source/tutorials/index.rst b/docs/source/tutorials/index.rst index 3990e31a..e10cc460 100644 --- a/docs/source/tutorials/index.rst +++ b/docs/source/tutorials/index.rst @@ -24,6 +24,9 @@ Most useful when you want to get started reducing your data. .. card:: Sub Beam Nod Data :link: examples/subbeamnod.html + .. card:: Nodding Data + :link: examples/nodding.html + .. toctree:: :maxdepth: 4 :hidden: @@ -31,3 +34,4 @@ Most useful when you want to get started reducing your data. examples/positionswitch examples/frequencyswitch examples/subbeamnod + examples/nodding From 025e5e15f4cc343c913bab23fa6e227cb0f18d41 Mon Sep 17 00:00:00 2001 From: Marc Pound <22331890+mpound@users.noreply.github.com> Date: Tue, 22 Oct 2024 11:11:28 -0700 Subject: [PATCH 66/95] ok except some failing tests due to spectrum averaging --- src/dysh/fits/tests/test_gbtfitsload.py | 15 +++++----- src/dysh/spectra/scan.py | 38 +++++++++++++++---------- src/dysh/spectra/spectrum.py | 10 ++++--- src/dysh/spectra/tests/test_scan.py | 2 ++ src/dysh/spectra/tests/test_spectrum.py | 1 + 5 files changed, 40 insertions(+), 26 deletions(-) diff --git a/src/dysh/fits/tests/test_gbtfitsload.py b/src/dysh/fits/tests/test_gbtfitsload.py index 83067679..7fcdb17c 100644 --- a/src/dysh/fits/tests/test_gbtfitsload.py +++ b/src/dysh/fits/tests/test_gbtfitsload.py @@ -262,6 +262,7 @@ def test_gettp(self): if v["CAL"]: assert np.all(tps[0]._refcalon[0] == tps[0].total_power(0).flux.value) tp = tps.timeaverage(weights=None) + print(tp.mask, " ALL ", np.all(tp.mask == False)) if v["CAL"] is None: cal = (0.5 * (tps[0]._refcalon + tps[0]._refcaloff)).astype(np.float64) elif not v["CAL"]: @@ -270,11 +271,11 @@ def test_gettp(self): else: # CAL=True cal = tps[0]._refcalon.astype(np.float64) - cal = cal.data + print(cal.mask, " CAL ALL ", np.all(cal.mask == False)) diff = tp.flux.value - np.nanmean(cal, axis=0) - # print(np.where(diff != 0)) - # print(diff[np.where(diff > 1e-8)]) - assert np.all(diff == 0) + print(np.where(diff != 0)) + print(diff[np.where(abs(diff) > 1e-8)]) + assert np.all(tp.flux.value - np.nanmean(cal, axis=0) == 0) # assert np.all(np.abs(diff) < 1e-8) # Check that selection is being applied properly. @@ -446,9 +447,9 @@ def test_getps_flagging(self): sdf.flag_channel([[10, 20], [30, 41]]) sb = sdf.getps(scan=152, ifnum=0, plnum=0, apply_flags=True) ta = sb.timeaverage() - print(np.where(ta.mask)) - expected_mask = np.hstack([np.arange(10, 21), np.arange(30, 42)]) - assert np.where(ta.mask)[0] == expected_mask + # average_spectra masks out the NaN in channel 3072 + expected_mask = np.hstack([np.arange(10, 21), np.arange(30, 42), np.array([3072])]) + assert np.all(np.where(ta.mask)[0] == expected_mask) def test_write_single_file(self, tmp_path): "Test that writing an SDFITS file works when subselecting data" diff --git a/src/dysh/spectra/scan.py b/src/dysh/spectra/scan.py index bac712af..36b4e793 100644 --- a/src/dysh/spectra/scan.py +++ b/src/dysh/spectra/scan.py @@ -25,7 +25,7 @@ sq_weighted_avg, tsys_weight, ) -from .spectrum import Spectrum +from .spectrum import Spectrum, average_spectra class SpectralAverageMixin: @@ -432,22 +432,29 @@ def timeaverage(self, weights="tsys", mode="old"): w = w.squeeze() else: w = weights - timeavg = np.array([k.data for k in self._timeaveraged]) - # Weight the average of the timeaverages by the weights. - avgdata = average(timeavg, axis=0, weights=w) - avgspec = np.mean(self._timeaveraged) - avgspec.meta = self._timeaveraged[0].meta - avgspec.meta["TSYS"] = np.average(a=[k.meta["TSYS"] for k in self._timeaveraged], axis=0, weights=w) - avgspec.meta["EXPOSURE"] = np.sum([k.meta["EXPOSURE"] for k in self._timeaveraged]) - # observer = self._timeaveraged[0].observer # nope this has to be a location ugh. see @todo in Spectrum constructor - # hardcode to GBT for now - s = Spectrum.make_spectrum( - avgdata * avgspec.flux.unit, meta=avgspec.meta, observer_location=Observatory["GBT"] - ) + if False: + timeavg = np.array([k.data for k in self._timeaveraged]) + # timeavg = np.ma.empty((np.shape(self._timeaveraged)[0],np.shape(self._timeaveraged[0])[0])) + # Weight the average of the timeaverages by the weights. + avgdata = average(timeavg, axis=0, weights=w) + print(f"{type(timeavg)=}, {type(avgdata)=}") + avgspec = np.ma.mean(self._timeaveraged) + print(f"{type(avgspec)=}") + avgspec.meta = self._timeaveraged[0].meta + avgspec.meta["TSYS"] = np.average(a=[k.meta["TSYS"] for k in self._timeaveraged], axis=0, weights=w) + avgspec.meta["EXPOSURE"] = np.sum([k.meta["EXPOSURE"] for k in self._timeaveraged]) + # observer = self._timeaveraged[0].observer # nope this has to be a location ugh. see @todo in Spectrum constructor + # hardcode to GBT for now + s = Spectrum.make_spectrum( + Masked(avgdata * avgspec.flux.unit, avgspec.mask), + meta=avgspec.meta, + observer_location=Observatory["GBT"], + ) + s = average_spectra(self._timeaveraged, equal_weights=True) s.merge_commentary(self) elif mode == "new": # average of the integrations - allcal = np.all([d._calibrate for d in self.data]) + allcal = np.all([d._calibrated for d in self.data]) if not allcal: raise Exception("Data must be calibrated before time averaging.") c = np.concatenate([d._calibrated for d in self.data]) @@ -1159,7 +1166,7 @@ def timeaverage(self, weights="tsys"): raise Exception("You can't time average before calibration.") if self._npol > 1: raise Exception("Can't yet time average multiple polarizations") - self._timeaveraged = deepcopy(self.calibrated(0)) + self._timeaveraged = self.calibrated(0)._copy() data = self._calibrated if weights == "tsys": w = self.tsys_weight @@ -1172,6 +1179,7 @@ def timeaverage(self, weights="tsys"): self._timeaveraged.meta["EXPOSURE"] = np.sum(self._exposure[non_blanks]) self._timeaveraged.meta["TSYS"] = self._timeaveraged.meta["WTTSYS"] self._timeaveraged._history = self._history + print("PS TA OBS ", self._timeaveraged._observer_location, self._timeaveraged._velocity_frame) return self._timeaveraged diff --git a/src/dysh/spectra/spectrum.py b/src/dysh/spectra/spectrum.py index f50750df..e2871d45 100644 --- a/src/dysh/spectra/spectrum.py +++ b/src/dysh/spectra/spectrum.py @@ -17,6 +17,7 @@ # from astropy.nddata.ccddata import fits_ccddata_writer from astropy.table import Table from astropy.time import Time +from astropy.utils.masked import Masked from astropy.wcs import WCS, FITSFixedWarning from ndcube import NDCube from specutils import Spectrum1D @@ -34,7 +35,7 @@ sanitize_skycoord, veldef_to_convention, ) -from ..log import HistoricalBase, log_call_to_history +from ..log import HistoricalBase, log_call_to_history, logger from ..plot import specplot as sp from ..util import minimum_string_match from . import baseline, get_spectral_equivalency @@ -1551,7 +1552,7 @@ def average_spectra(spectra, equal_weights=False, align=False): nspec = len(spectra) nchan = len(spectra[0].data) shape = (nspec, nchan) - data_array = np.empty(shape, dtype=float) + data_array = np.ma.empty(shape, dtype=float) weights = np.empty(shape, dtype=float) exposures = np.empty(nspec, dtype=float) tsyss = np.empty(nspec, dtype=float) @@ -1573,6 +1574,7 @@ def average_spectra(spectra, equal_weights=False, align=False): s_.align_to(spectra[0]) else: s_ = s + logger.debug(f"OBS LOCATION {s._observer_location}") data_array[i] = s_.data if not equal_weights: weights[i] = core.tsys_weight(s.meta["EXPOSURE"], s.meta["CDELT1"], s.meta["TSYS"]) @@ -1583,7 +1585,7 @@ def average_spectra(spectra, equal_weights=False, align=False): xcoos[i] = s.meta["CRVAL2"] ycoos[i] = s.meta["CRVAL3"] - data_array = np.ma.MaskedArray(data_array, mask=np.isnan(data_array)) + data_array = np.ma.MaskedArray(data_array, mask=np.isnan(data_array) | data_array.mask) data = np.ma.average(data_array, axis=0, weights=weights) tsys = np.ma.average(tsyss, axis=0, weights=weights[:, 0]) xcoo = np.ma.average(xcoos, axis=0, weights=weights[:, 0]) @@ -1596,6 +1598,6 @@ def average_spectra(spectra, equal_weights=False, align=False): new_meta["CRVAL2"] = xcoo new_meta["CRVAL3"] = ycoo - averaged = Spectrum.make_spectrum(data * units, meta=new_meta) + averaged = Spectrum.make_spectrum(Masked(data * units, data.mask), meta=new_meta) return averaged diff --git a/src/dysh/spectra/tests/test_scan.py b/src/dysh/spectra/tests/test_scan.py index 8afa0433..d5ea4972 100644 --- a/src/dysh/spectra/tests/test_scan.py +++ b/src/dysh/spectra/tests/test_scan.py @@ -61,10 +61,12 @@ def test_compare_with_GBTIDL_2(self, data_dir): data_path = f"{data_dir}/TGBT21A_501_11/NGC2782" sdf_file = f"{data_path}/TGBT21A_501_11_NGC2782.raw.vegas.A.fits" + print(f"{sdf_file=}") gbtidl_file = f"{data_path}/TGBT21A_501_11_getps_scans_156-158_ifnum_0_plnum_0_timeaverage.fits" sdf = gbtfitsload.GBTFITSLoad(sdf_file) ps_scans = sdf.getps(scan=[156, 158], ifnum=0, plnum=0) + print(np.shape(ps_scans[0]._calibrated), np.shape(ps_scans[1]._calibrated)) ta = ps_scans.timeaverage() hdu = fits.open(gbtidl_file) diff --git a/src/dysh/spectra/tests/test_spectrum.py b/src/dysh/spectra/tests/test_spectrum.py index 53431d69..14a671b6 100644 --- a/src/dysh/spectra/tests/test_spectrum.py +++ b/src/dysh/spectra/tests/test_spectrum.py @@ -269,6 +269,7 @@ def test_slice(self, mock_show, tmp_path): # Check additional object properties. # Not all of them make sense, since their shapes will be different. for k in spec_pars: + print(k) assert vars(trimmed)[k] == vars(self.ps0)[k] # Check that we can plot. trimmed.plot(xaxis_unit="km/s", yaxis_unit="mK") From 7ca707f3154d3df60b580094c3af1dee2af2e2f2 Mon Sep 17 00:00:00 2001 From: Marc Pound <22331890+mpound@users.noreply.github.com> Date: Tue, 22 Oct 2024 11:27:12 -0700 Subject: [PATCH 67/95] Update spectrum.py fix botched merge --- src/dysh/spectra/spectrum.py | 3 --- 1 file changed, 3 deletions(-) diff --git a/src/dysh/spectra/spectrum.py b/src/dysh/spectra/spectrum.py index cd32a1ae..a9cb71d2 100644 --- a/src/dysh/spectra/spectrum.py +++ b/src/dysh/spectra/spectrum.py @@ -1575,9 +1575,6 @@ def average_spectra(spectra, equal_weights=False, align=False): if i > 0: s_.align_to(spectra[0]) else: - s_ = s - - data_array[i] = s_.data s = s.align_to(spectra[0]) logger.debug(f"OBS LOCATION {s._observer_location}") data_array[i] = s.data From 60c790a9dc074bb0954a9a00f8300134e7a5f29d Mon Sep 17 00:00:00 2001 From: "pre-commit-ci[bot]" <66853113+pre-commit-ci[bot]@users.noreply.github.com> Date: Tue, 22 Oct 2024 18:27:34 +0000 Subject: [PATCH 68/95] [pre-commit.ci] auto fixes from pre-commit.com hooks for more information, see https://pre-commit.ci --- src/dysh/spectra/spectrum.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/dysh/spectra/spectrum.py b/src/dysh/spectra/spectrum.py index a9cb71d2..6ea7246a 100644 --- a/src/dysh/spectra/spectrum.py +++ b/src/dysh/spectra/spectrum.py @@ -1575,8 +1575,8 @@ def average_spectra(spectra, equal_weights=False, align=False): if i > 0: s_.align_to(spectra[0]) else: - s = s.align_to(spectra[0]) - logger.debug(f"OBS LOCATION {s._observer_location}") + s = s.align_to(spectra[0]) + logger.debug(f"OBS LOCATION {s._observer_location}") data_array[i] = s.data if not equal_weights: weights[i] = core.tsys_weight(s.meta["EXPOSURE"], s.meta["CDELT1"], s.meta["TSYS"]) From 89c20061bfee3d1b9b5288f5d6f285d9cf12c88c Mon Sep 17 00:00:00 2001 From: Marc Pound <22331890+mpound@users.noreply.github.com> Date: Tue, 22 Oct 2024 11:36:00 -0700 Subject: [PATCH 69/95] get rid of 3.9 --- .pre-commit-config.yaml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml index de4e221b..4fadf5b8 100644 --- a/.pre-commit-config.yaml +++ b/.pre-commit-config.yaml @@ -1,7 +1,7 @@ --- # See https://pre-commit.com for more information default_language_version: - python: python3.9 + python: python3.11 # See https://pre-commit.com/hooks.html for more hooks repos: From 0ac860b2ff08b87955513241f2bfef16a7a73d73 Mon Sep 17 00:00:00 2001 From: Marc Pound <22331890+mpound@users.noreply.github.com> Date: Tue, 22 Oct 2024 12:00:47 -0700 Subject: [PATCH 70/95] refix botched merge --- src/dysh/spectra/spectrum.py | 7 +++---- 1 file changed, 3 insertions(+), 4 deletions(-) diff --git a/src/dysh/spectra/spectrum.py b/src/dysh/spectra/spectrum.py index 6ea7246a..de972841 100644 --- a/src/dysh/spectra/spectrum.py +++ b/src/dysh/spectra/spectrum.py @@ -1573,11 +1573,10 @@ def average_spectra(spectra, equal_weights=False, align=False): ) if align: if i > 0: - s_.align_to(spectra[0]) - else: - s = s.align_to(spectra[0]) - logger.debug(f"OBS LOCATION {s._observer_location}") + s = s.align_to(spectra[0]) + logger.debug(f"OBS LOCATION {s._observer_location}") data_array[i] = s.data + data_array[i].mask = s.mask if not equal_weights: weights[i] = core.tsys_weight(s.meta["EXPOSURE"], s.meta["CDELT1"], s.meta["TSYS"]) else: From 50735ada494cd4d392cc4f2d630ac7128f361da4 Mon Sep 17 00:00:00 2001 From: Marc Pound <22331890+mpound@users.noreply.github.com> Date: Tue, 22 Oct 2024 12:03:50 -0700 Subject: [PATCH 71/95] remove equal weights --- src/dysh/spectra/scan.py | 15 ++++++++++++--- 1 file changed, 12 insertions(+), 3 deletions(-) diff --git a/src/dysh/spectra/scan.py b/src/dysh/spectra/scan.py index 36b4e793..d3bb14ab 100644 --- a/src/dysh/spectra/scan.py +++ b/src/dysh/spectra/scan.py @@ -440,6 +440,7 @@ def timeaverage(self, weights="tsys", mode="old"): print(f"{type(timeavg)=}, {type(avgdata)=}") avgspec = np.ma.mean(self._timeaveraged) print(f"{type(avgspec)=}") + print(f"{avgspec.mask=}") avgspec.meta = self._timeaveraged[0].meta avgspec.meta["TSYS"] = np.average(a=[k.meta["TSYS"] for k in self._timeaveraged], axis=0, weights=w) avgspec.meta["EXPOSURE"] = np.sum([k.meta["EXPOSURE"] for k in self._timeaveraged]) @@ -450,7 +451,9 @@ def timeaverage(self, weights="tsys", mode="old"): meta=avgspec.meta, observer_location=Observatory["GBT"], ) - s = average_spectra(self._timeaveraged, equal_weights=True) + + print(f"{self._timeaveraged[0].mask=}") + s = average_spectra(self._timeaveraged) s.merge_commentary(self) elif mode == "new": # average of the integrations @@ -1166,7 +1169,8 @@ def timeaverage(self, weights="tsys"): raise Exception("You can't time average before calibration.") if self._npol > 1: raise Exception("Can't yet time average multiple polarizations") - self._timeaveraged = self.calibrated(0)._copy() + print(f"{self.calibrated(0).mask=}") + self._timeaveraged = deepcopy(self.calibrated(0)) # ._copy() data = self._calibrated if weights == "tsys": w = self.tsys_weight @@ -1179,7 +1183,12 @@ def timeaverage(self, weights="tsys"): self._timeaveraged.meta["EXPOSURE"] = np.sum(self._exposure[non_blanks]) self._timeaveraged.meta["TSYS"] = self._timeaveraged.meta["WTTSYS"] self._timeaveraged._history = self._history - print("PS TA OBS ", self._timeaveraged._observer_location, self._timeaveraged._velocity_frame) + print( + "PS TA OBS ", + self._timeaveraged._observer_location, + self._timeaveraged._velocity_frame, + self._timeaveraged.mask, + ) return self._timeaveraged From 1a248aaad0e4593ec9497733accdc8ea547cf41d Mon Sep 17 00:00:00 2001 From: Marc Pound <22331890+mpound@users.noreply.github.com> Date: Tue, 22 Oct 2024 12:05:01 -0700 Subject: [PATCH 72/95] fix indexing --- src/dysh/fits/tests/test_gbtfitsload.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/dysh/fits/tests/test_gbtfitsload.py b/src/dysh/fits/tests/test_gbtfitsload.py index 7fcdb17c..c7d7b694 100644 --- a/src/dysh/fits/tests/test_gbtfitsload.py +++ b/src/dysh/fits/tests/test_gbtfitsload.py @@ -449,7 +449,7 @@ def test_getps_flagging(self): ta = sb.timeaverage() # average_spectra masks out the NaN in channel 3072 expected_mask = np.hstack([np.arange(10, 21), np.arange(30, 42), np.array([3072])]) - assert np.all(np.where(ta.mask)[0] == expected_mask) + assert np.all(np.where(ta.mask) == expected_mask) def test_write_single_file(self, tmp_path): "Test that writing an SDFITS file works when subselecting data" From 1d0a71f83cbd1cc0a8f21b2088f4a7ae8bb42cd4 Mon Sep 17 00:00:00 2001 From: Marc Pound <22331890+mpound@users.noreply.github.com> Date: Tue, 22 Oct 2024 17:18:03 -0700 Subject: [PATCH 73/95] fix test_slice test by adding observer location to spectral average --- src/dysh/spectra/scan.py | 5 +---- src/dysh/spectra/spectrum.py | 6 +++--- src/dysh/spectra/tests/test_spectrum.py | 13 ++++++++----- 3 files changed, 12 insertions(+), 12 deletions(-) diff --git a/src/dysh/spectra/scan.py b/src/dysh/spectra/scan.py index d3bb14ab..abb117b5 100644 --- a/src/dysh/spectra/scan.py +++ b/src/dysh/spectra/scan.py @@ -437,10 +437,7 @@ def timeaverage(self, weights="tsys", mode="old"): # timeavg = np.ma.empty((np.shape(self._timeaveraged)[0],np.shape(self._timeaveraged[0])[0])) # Weight the average of the timeaverages by the weights. avgdata = average(timeavg, axis=0, weights=w) - print(f"{type(timeavg)=}, {type(avgdata)=}") avgspec = np.ma.mean(self._timeaveraged) - print(f"{type(avgspec)=}") - print(f"{avgspec.mask=}") avgspec.meta = self._timeaveraged[0].meta avgspec.meta["TSYS"] = np.average(a=[k.meta["TSYS"] for k in self._timeaveraged], axis=0, weights=w) avgspec.meta["EXPOSURE"] = np.sum([k.meta["EXPOSURE"] for k in self._timeaveraged]) @@ -452,7 +449,6 @@ def timeaverage(self, weights="tsys", mode="old"): observer_location=Observatory["GBT"], ) - print(f"{self._timeaveraged[0].mask=}") s = average_spectra(self._timeaveraged) s.merge_commentary(self) elif mode == "new": @@ -1183,6 +1179,7 @@ def timeaverage(self, weights="tsys"): self._timeaveraged.meta["EXPOSURE"] = np.sum(self._exposure[non_blanks]) self._timeaveraged.meta["TSYS"] = self._timeaveraged.meta["WTTSYS"] self._timeaveraged._history = self._history + self._timeaveraged._observer_location = self._observer_location print( "PS TA OBS ", self._timeaveraged._observer_location, diff --git a/src/dysh/spectra/spectrum.py b/src/dysh/spectra/spectrum.py index de972841..c42a1312 100644 --- a/src/dysh/spectra/spectrum.py +++ b/src/dysh/spectra/spectrum.py @@ -1561,7 +1561,7 @@ def average_spectra(spectra, equal_weights=False, align=False): tsyss = np.empty(nspec, dtype=float) xcoos = np.empty(nspec, dtype=float) ycoos = np.empty(nspec, dtype=float) - + obs_location = spectra[0]._observer_location units = spectra[0].flux.unit for i, s in enumerate(spectra): @@ -1574,7 +1574,7 @@ def average_spectra(spectra, equal_weights=False, align=False): if align: if i > 0: s = s.align_to(spectra[0]) - logger.debug(f"OBS LOCATION {s._observer_location}") + data_array[i] = s.data data_array[i].mask = s.mask if not equal_weights: @@ -1599,6 +1599,6 @@ def average_spectra(spectra, equal_weights=False, align=False): new_meta["CRVAL2"] = xcoo new_meta["CRVAL3"] = ycoo - averaged = Spectrum.make_spectrum(Masked(data * units, data.mask), meta=new_meta) + averaged = Spectrum.make_spectrum(Masked(data * units, data.mask), meta=new_meta, observer_location=obs_location) return averaged diff --git a/src/dysh/spectra/tests/test_spectrum.py b/src/dysh/spectra/tests/test_spectrum.py index e922bd47..2ff5a03f 100644 --- a/src/dysh/spectra/tests/test_spectrum.py +++ b/src/dysh/spectra/tests/test_spectrum.py @@ -50,10 +50,10 @@ def setup_method(self): data_dir = get_project_testdata() / "AGBT05B_047_01" sdf_file = data_dir / "AGBT05B_047_01.raw.acs" sdf = GBTFITSLoad(sdf_file) - getps0 = sdf.getps(scan=51, plnum=0) - self.ps0 = getps0.timeaverage() - getps1 = sdf.getps(scan=51, plnum=1) - self.ps1 = getps1.timeaverage() + self.getps0 = sdf.getps(scan=51, plnum=0) + self.ps0 = self.getps0.timeaverage() + self.getps1 = sdf.getps(scan=51, plnum=1) + self.ps1 = self.getps1.timeaverage() self.ss = self.ps0._copy() # Synthetic one. x = np.arange(0, len(self.ss.data)) fwhm = 5 @@ -254,7 +254,10 @@ def test_slice(self, mock_show, tmp_path): meta_ignore = ["CRPIX1", "CRVAL1"] spec_pars = ["_target", "_velocity_frame", "_observer", "_obstime", "_observer_location"] s = slice(1000, 1100, 1) - + print(f"{self.getps0[0].timeaverage()._velocity_frame=}") + print(f"{self.getps0[0].timeaverage()._target=}") + print(f"{self.ps0._velocity_frame=}") + print(f"{self.ps0._target=}") trimmed = self.ps0[s] assert trimmed.flux[0] == self.ps0.flux[s.start] assert trimmed.flux[-1] == self.ps0.flux[s.stop - 1] From 2d89f3fb0cd9d4efd65c3e43d720d9470ea40473 Mon Sep 17 00:00:00 2001 From: Marc Pound <22331890+mpound@users.noreply.github.com> Date: Wed, 23 Oct 2024 08:43:45 -0700 Subject: [PATCH 74/95] fix failing test. rewrite interface of average_spectra so weights keyword is consistent with other methods --- src/dysh/spectra/scan.py | 2 +- src/dysh/spectra/spectrum.py | 30 +++++++++++++------------ src/dysh/spectra/tests/test_spectrum.py | 4 ++-- 3 files changed, 19 insertions(+), 17 deletions(-) diff --git a/src/dysh/spectra/scan.py b/src/dysh/spectra/scan.py index abb117b5..c9e362ce 100644 --- a/src/dysh/spectra/scan.py +++ b/src/dysh/spectra/scan.py @@ -449,7 +449,7 @@ def timeaverage(self, weights="tsys", mode="old"): observer_location=Observatory["GBT"], ) - s = average_spectra(self._timeaveraged) + s = average_spectra(self._timeaveraged, weights=weights) s.merge_commentary(self) elif mode == "new": # average of the integrations diff --git a/src/dysh/spectra/spectrum.py b/src/dysh/spectra/spectrum.py index c42a1312..6354fa3b 100644 --- a/src/dysh/spectra/spectrum.py +++ b/src/dysh/spectra/spectrum.py @@ -1529,7 +1529,7 @@ def spectrum_reader_gbtidl(fileobj, **kwargs): # registry.register_writer("mrt", Spectrum, spectrum_reader_mrt) -def average_spectra(spectra, equal_weights=False, align=False): +def average_spectra(spectra, weights="tsys", align=False): """ Average `spectra`. The resulting `average` will have an exposure equal to the sum of the exposures, and coordinates and system temperature equal to the weighted average of the coordinates and system temperatures. @@ -1539,9 +1539,12 @@ def average_spectra(spectra, equal_weights=False, align=False): spectra : list of `Spectrum` Spectra to be averaged. They must have the same number of channels. No checks are done to ensure they are aligned. - equal_weights : bool - If `False` use the inverse of the variance, as computed from the radiometer equation, as weights. - If `True` all spectra have the same weight. + weights: str + 'tsys' or None. If 'tsys' the weight will be calculated as: + + :math:`w = t_{exp} \times \delta\nu/T_{sys}^2` + + Default: 'tsys' align : bool If `True` align the `spectra` to the first element. This uses `Spectrum.align_to`. @@ -1556,7 +1559,7 @@ def average_spectra(spectra, equal_weights=False, align=False): nchan = len(spectra[0].data) shape = (nspec, nchan) data_array = np.ma.empty(shape, dtype=float) - weights = np.empty(shape, dtype=float) + wts = np.empty(shape, dtype=float) exposures = np.empty(nspec, dtype=float) tsyss = np.empty(nspec, dtype=float) xcoos = np.empty(nspec, dtype=float) @@ -1566,7 +1569,7 @@ def average_spectra(spectra, equal_weights=False, align=False): for i, s in enumerate(spectra): if not isinstance(s, Spectrum): - raise ValueError(f"Element {i} of `spectra` is not a `Spectrum`.") + raise ValueError(f"Element {i} of `spectra` is not a `Spectrum`. {type(s)}") if units != s.flux.unit: raise ValueError( f"Element {i} of `spectra` has units {s.flux.unit}, but the first element has units {units}." @@ -1577,20 +1580,19 @@ def average_spectra(spectra, equal_weights=False, align=False): data_array[i] = s.data data_array[i].mask = s.mask - if not equal_weights: - weights[i] = core.tsys_weight(s.meta["EXPOSURE"], s.meta["CDELT1"], s.meta["TSYS"]) + if weights == "tsys": + wts[i] = core.tsys_weight(s.meta["EXPOSURE"], s.meta["CDELT1"], s.meta["TSYS"]) else: - weights[i] = 1.0 + wts[i] = 1.0 exposures[i] = s.meta["EXPOSURE"] tsyss[i] = s.meta["TSYS"] xcoos[i] = s.meta["CRVAL2"] ycoos[i] = s.meta["CRVAL3"] - data_array = np.ma.MaskedArray(data_array, mask=np.isnan(data_array) | data_array.mask) - data = np.ma.average(data_array, axis=0, weights=weights) - tsys = np.ma.average(tsyss, axis=0, weights=weights[:, 0]) - xcoo = np.ma.average(xcoos, axis=0, weights=weights[:, 0]) - ycoo = np.ma.average(ycoos, axis=0, weights=weights[:, 0]) + data = np.ma.average(data_array, axis=0, weights=wts) + tsys = np.ma.average(tsyss, axis=0, weights=wts[:, 0]) + xcoo = np.ma.average(xcoos, axis=0, weights=wts[:, 0]) + ycoo = np.ma.average(ycoos, axis=0, weights=wts[:, 0]) exposure = exposures.sum(axis=0) new_meta = deepcopy(spectra[0].meta) diff --git a/src/dysh/spectra/tests/test_spectrum.py b/src/dysh/spectra/tests/test_spectrum.py index 2ff5a03f..e9f3e265 100644 --- a/src/dysh/spectra/tests/test_spectrum.py +++ b/src/dysh/spectra/tests/test_spectrum.py @@ -254,8 +254,8 @@ def test_slice(self, mock_show, tmp_path): meta_ignore = ["CRPIX1", "CRVAL1"] spec_pars = ["_target", "_velocity_frame", "_observer", "_obstime", "_observer_location"] s = slice(1000, 1100, 1) - print(f"{self.getps0[0].timeaverage()._velocity_frame=}") - print(f"{self.getps0[0].timeaverage()._target=}") + print(f"{self.getps[0].timeaverage()._velocity_frame=}") + print(f"{self.getps0[0]._target=}") print(f"{self.ps0._velocity_frame=}") print(f"{self.ps0._target=}") trimmed = self.ps0[s] From 2120b2ad21d4e26ce61aa530364ec1a1d8eebabf Mon Sep 17 00:00:00 2001 From: Marc Pound <22331890+mpound@users.noreply.github.com> Date: Wed, 23 Oct 2024 09:43:01 -0700 Subject: [PATCH 75/95] fix typo. remove prints etc --- src/dysh/fits/tests/test_gbtfitsload.py | 8 +- src/dysh/spectra/scan.py | 98 +++++-------------------- src/dysh/spectra/tests/test_spectrum.py | 5 -- 3 files changed, 19 insertions(+), 92 deletions(-) diff --git a/src/dysh/fits/tests/test_gbtfitsload.py b/src/dysh/fits/tests/test_gbtfitsload.py index c7d7b694..f47d8bd7 100644 --- a/src/dysh/fits/tests/test_gbtfitsload.py +++ b/src/dysh/fits/tests/test_gbtfitsload.py @@ -262,7 +262,6 @@ def test_gettp(self): if v["CAL"]: assert np.all(tps[0]._refcalon[0] == tps[0].total_power(0).flux.value) tp = tps.timeaverage(weights=None) - print(tp.mask, " ALL ", np.all(tp.mask == False)) if v["CAL"] is None: cal = (0.5 * (tps[0]._refcalon + tps[0]._refcaloff)).astype(np.float64) elif not v["CAL"]: @@ -271,13 +270,8 @@ def test_gettp(self): else: # CAL=True cal = tps[0]._refcalon.astype(np.float64) - print(cal.mask, " CAL ALL ", np.all(cal.mask == False)) - diff = tp.flux.value - np.nanmean(cal, axis=0) - print(np.where(diff != 0)) - print(diff[np.where(abs(diff) > 1e-8)]) + # diff = tp.flux.value - np.nanmean(cal, axis=0) assert np.all(tp.flux.value - np.nanmean(cal, axis=0) == 0) - # assert np.all(np.abs(diff) < 1e-8) - # Check that selection is being applied properly. tp_scans = sdf.gettp(scan=[6, 7], plnum=0) # Weird that the results are different for a bunch of channels. diff --git a/src/dysh/spectra/scan.py b/src/dysh/spectra/scan.py index c9e362ce..95fe5567 100644 --- a/src/dysh/spectra/scan.py +++ b/src/dysh/spectra/scan.py @@ -402,7 +402,7 @@ def calibrate(self, **kwargs): scan.calibrate(**kwargs) @log_call_to_history - def timeaverage(self, weights="tsys", mode="old"): + def timeaverage(self, weights="tsys"): r"""Compute the time-averaged spectrum for all scans in this ScanBlock. Parameters @@ -419,60 +419,12 @@ def timeaverage(self, weights="tsys", mode="old"): List of all the time-averaged spectra """ # warnings.simplefilter("ignore", NoVelocityWarning) - if mode == "old": - # average of the averages - self._timeaveraged = [] - for scan in self.data: - self._timeaveraged.append(scan.timeaverage(weights)) - if weights == "tsys": - # There may be multiple integrations, so need to - # average the Tsys weights - w = np.array([np.nanmean(k.tsys_weight) for k in self.data]) - if len(np.shape(w)) > 1: # remove empty axes - w = w.squeeze() - else: - w = weights - if False: - timeavg = np.array([k.data for k in self._timeaveraged]) - # timeavg = np.ma.empty((np.shape(self._timeaveraged)[0],np.shape(self._timeaveraged[0])[0])) - # Weight the average of the timeaverages by the weights. - avgdata = average(timeavg, axis=0, weights=w) - avgspec = np.ma.mean(self._timeaveraged) - avgspec.meta = self._timeaveraged[0].meta - avgspec.meta["TSYS"] = np.average(a=[k.meta["TSYS"] for k in self._timeaveraged], axis=0, weights=w) - avgspec.meta["EXPOSURE"] = np.sum([k.meta["EXPOSURE"] for k in self._timeaveraged]) - # observer = self._timeaveraged[0].observer # nope this has to be a location ugh. see @todo in Spectrum constructor - # hardcode to GBT for now - s = Spectrum.make_spectrum( - Masked(avgdata * avgspec.flux.unit, avgspec.mask), - meta=avgspec.meta, - observer_location=Observatory["GBT"], - ) - - s = average_spectra(self._timeaveraged, weights=weights) - s.merge_commentary(self) - elif mode == "new": - # average of the integrations - allcal = np.all([d._calibrated for d in self.data]) - if not allcal: - raise Exception("Data must be calibrated before time averaging.") - c = np.concatenate([d._calibrated for d in self.data]) - if weights == "tsys": - w = np.concatenate([d.tsys_weight for d in self.data]) - # if len(np.shape(w)) > 1: # remove empty axes - # w = w.squeeze() - else: - w = None - timeavg = average(c, weights=w) - avgspec = self.data[0].calibrated(0) - avgspec.meta["TSYS"] = np.nanmean([d.tsys for d in self.data]) - avgspec.meta["EXPOSURE"] = np.sum([d.exposure for d in self.data]) - s = Spectrum.make_spectrum( - timeavg * avgspec.flux.unit, meta=avgspec.meta, observer_location=Observatory["GBT"] - ) - s.merge_commentary(self) - else: - raise Exception(f"unrecognized mode {mode}") + # average of the averages + self._timeaveraged = [] + for scan in self.data: + self._timeaveraged.append(scan.timeaverage(weights)) + s = average_spectra(self._timeaveraged, weights=weights) + s.merge_commentary(self) return s @log_call_to_history @@ -990,13 +942,6 @@ def __init__( self._nrows = len(self._scanrows["ON"]) self._smoothref = smoothref self._apply_flags = apply_flags - # print(f"PJT len(scanrows ON) {len(self._scanrows['ON'])}") - # print(f"PJT len(scanrows OFF) {len(self._scanrows['OFF'])}") - # print("PJT scans", scans) - # print("PJT scanrows", scanrows) - # print("PJT calrows", calrows) - # print(f"len(scanrows ON) {len(self._scanrows['ON'])}") - # print(f"len(scanrows OFF) {len(self._scanrows['OFF'])}") # calrows perhaps not needed as input since we can get it from gbtfits object? # calrows['ON'] are rows with noise diode was on, regardless of sig or ref @@ -1165,7 +1110,6 @@ def timeaverage(self, weights="tsys"): raise Exception("You can't time average before calibration.") if self._npol > 1: raise Exception("Can't yet time average multiple polarizations") - print(f"{self.calibrated(0).mask=}") self._timeaveraged = deepcopy(self.calibrated(0)) # ._copy() data = self._calibrated if weights == "tsys": @@ -1180,12 +1124,6 @@ def timeaverage(self, weights="tsys"): self._timeaveraged.meta["TSYS"] = self._timeaveraged.meta["WTTSYS"] self._timeaveraged._history = self._history self._timeaveraged._observer_location = self._observer_location - print( - "PS TA OBS ", - self._timeaveraged._observer_location, - self._timeaveraged._velocity_frame, - self._timeaveraged.mask, - ) return self._timeaveraged @@ -1505,19 +1443,19 @@ def __init__( self._debug = debug if self._debug: - print("---------------------------------------------------") - print("FSSCAN: ") - print("SigOff", self._sigoffrows) - print("SigOn", self._sigonrows) - print("RefOff", self._refoffrows) - print("RegOn", self._refonrows) + logger.debug("---------------------------------------------------") + logger.debug("FSSCAN: ") + logger.debug(f"SigOff {self._sigoffrows}") + logger.debug(f"SigOn {self._sigonrows}") + logger.debug(f"RefOff {self._refoffrows}") + logger.debug(f"RefOn {self._refonrows}") nsigrows = len(self._sigonrows) + len(self._sigoffrows) nrefrows = len(self._refonrows) + len(self._refoffrows) if nsigrows != nrefrows: raise Exception("Number of sig rows does not match ref rows. Dangerous to proceed") if self._debug: - print("sigonrows", nsigrows, self._sigonrows) + logger.dbeug(f"sigonrows {nsigrows}, {self._sigonrows}") self._nrows = nsigrows a_scanrow = self._sigonrows[0] @@ -1528,17 +1466,17 @@ def __init__( else: self._bintable_index = bintable if self._debug: - print(f"bintable index is {self._bintable_index}") + logger.debug(f"bintable index is {self._bintable_index}") self._observer_location = observer_location self._scanrows = list(set(self._calrows["ON"])) + list(set(self._calrows["OFF"])) df = self._sdfits._index.iloc[self._scanrows] if self._debug: - print("len(df) = ", len(df)) + logger.debug(f"{len(df) = }") self._set_if_fd(df) self._pols = uniq(df["PLNUM"]) if self._debug: - print(f"FSSCAN #pol = {self._pols}") + logger.debug(f"FSSCAN #pol = {self._pols}") self._npol = len(self._pols) if False: self._nint = gbtfits.nintegrations(self._bintable_index) @@ -1558,7 +1496,7 @@ def __init__( if self._calibrate: self.calibrate(fold=fold, shift_method=shift_method) if self._debug: - print("---------------------------------------------------") + logger.debug("---------------------------------------------------") self._validate_defaults() @property diff --git a/src/dysh/spectra/tests/test_spectrum.py b/src/dysh/spectra/tests/test_spectrum.py index e9f3e265..b1081b36 100644 --- a/src/dysh/spectra/tests/test_spectrum.py +++ b/src/dysh/spectra/tests/test_spectrum.py @@ -254,10 +254,6 @@ def test_slice(self, mock_show, tmp_path): meta_ignore = ["CRPIX1", "CRVAL1"] spec_pars = ["_target", "_velocity_frame", "_observer", "_obstime", "_observer_location"] s = slice(1000, 1100, 1) - print(f"{self.getps[0].timeaverage()._velocity_frame=}") - print(f"{self.getps0[0]._target=}") - print(f"{self.ps0._velocity_frame=}") - print(f"{self.ps0._target=}") trimmed = self.ps0[s] assert trimmed.flux[0] == self.ps0.flux[s.start] assert trimmed.flux[-1] == self.ps0.flux[s.stop - 1] @@ -272,7 +268,6 @@ def test_slice(self, mock_show, tmp_path): # Check additional object properties. # Not all of them make sense, since their shapes will be different. for k in spec_pars: - print(k) assert vars(trimmed)[k] == vars(self.ps0)[k] # Check that we can plot. trimmed.plot(xaxis_unit="km/s", yaxis_unit="mK") From ca3a7957dfe1d9fe2edb273a4a1be92343f8cd3e Mon Sep 17 00:00:00 2001 From: Marc Pound <22331890+mpound@users.noreply.github.com> Date: Wed, 23 Oct 2024 14:58:21 -0700 Subject: [PATCH 76/95] ensure all scan timeaverages use np.ma and set fill value to nan --- src/dysh/spectra/scan.py | 18 ++++++++++++------ src/dysh/spectra/spectrum.py | 14 +++----------- 2 files changed, 15 insertions(+), 17 deletions(-) diff --git a/src/dysh/spectra/scan.py b/src/dysh/spectra/scan.py index 95fe5567..0a7ccdd1 100644 --- a/src/dysh/spectra/scan.py +++ b/src/dysh/spectra/scan.py @@ -421,8 +421,10 @@ def timeaverage(self, weights="tsys"): # warnings.simplefilter("ignore", NoVelocityWarning) # average of the averages self._timeaveraged = [] + i = 0 for scan in self.data: self._timeaveraged.append(scan.timeaverage(weights)) + print(f"timeaveraged[{i}]= {self._timeaveraged[i].data.data}") s = average_spectra(self._timeaveraged, weights=weights) s.merge_commentary(self) return s @@ -885,7 +887,8 @@ def timeaverage(self, weights="tsys"): else: w = np.ones_like(self.tsys_weight) non_blanks = find_non_blanks(self._data)[0] - self._timeaveraged._data = average(self._data, axis=0, weights=w) + self._timeaveraged._data = np.ma.average(self._data, axis=0, weights=w) + self._timeaveraged._data.set_fill_value(np.nan) self._timeaveraged.meta["MEANTSYS"] = np.mean(self._tsys[non_blanks]) self._timeaveraged.meta["WTTSYS"] = sq_weighted_avg(self._tsys[non_blanks], axis=0, weights=w[non_blanks]) self._timeaveraged.meta["TSYS"] = self._timeaveraged.meta["WTTSYS"] @@ -1116,7 +1119,8 @@ def timeaverage(self, weights="tsys"): w = self.tsys_weight else: w = np.ones_like(self.tsys_weight) - self._timeaveraged._data = average(data, axis=0, weights=w) + self._timeaveraged._data = np.ma.average(data, axis=0, weights=w) + self._timeaveraged._data.set_fill_value(np.nan) non_blanks = find_non_blanks(data) self._timeaveraged.meta["MEANTSYS"] = np.mean(self._tsys[non_blanks]) self._timeaveraged.meta["WTTSYS"] = sq_weighted_avg(self._tsys[non_blanks], axis=0, weights=w[non_blanks]) @@ -1361,7 +1365,8 @@ def timeaverage(self, weights="tsys"): w = self.tsys_weight else: w = np.ones_like(self.tsys_weight) - self._timeaveraged._data = average(data, axis=0, weights=w) + self._timeaveraged._data = np.ma.average(self._data, axis=0, weights=w) + self._timeaveraged._data.set_fill_value(np.nan) non_blanks = find_non_blanks(data) self._timeaveraged.meta["MEANTSYS"] = np.mean(self._tsys[non_blanks]) self._timeaveraged.meta["WTTSYS"] = sq_weighted_avg(self._tsys[non_blanks], axis=0, weights=w[non_blanks]) @@ -1754,7 +1759,8 @@ def timeaverage(self, weights="tsys"): w = self.tsys_weight else: w = np.ones_like(self.tsys_weight) - self._timeaveraged._data = average(data, axis=0, weights=w) + self._timeaveraged._data = np.ma.average(data, axis=0, weights=w) + self._timeaveraged._data.set_fill_value(np.nan) non_blanks = find_non_blanks(data) self._timeaveraged.meta["MEANTSYS"] = np.mean(self._tsys[non_blanks]) self._timeaveraged.meta["WTTSYS"] = sq_weighted_avg(self._tsys[non_blanks], axis=0, weights=w[non_blanks]) @@ -1887,12 +1893,12 @@ def timeaverage(self, weights="tsys"): raise Exception(f"Can't yet time average multiple polarizations {self._npol}") self._timeaveraged = deepcopy(self.calibrated(0)) data = self._calibrated - nchan = len(data[0]) if weights == "tsys": w = self.tsys_weight else: w = None - self._timeaveraged._data = average(data, axis=0, weights=w) + self._timeaveraged._data = np.ma.average(data, axis=0, weights=w) + self._timeaveraged._data.set_fill_value(np.nan) self._timeaveraged.meta["MEANTSYS"] = np.mean(self._tsys) self._timeaveraged.meta["WTTSYS"] = sq_weighted_avg(self._tsys, axis=0, weights=w) self._timeaveraged.meta["TSYS"] = self._timeaveraged.meta["WTTSYS"] diff --git a/src/dysh/spectra/spectrum.py b/src/dysh/spectra/spectrum.py index 6354fa3b..773d0ac8 100644 --- a/src/dysh/spectra/spectrum.py +++ b/src/dysh/spectra/spectrum.py @@ -68,11 +68,9 @@ class Spectrum(Spectrum1D, HistoricalBase): @log_call_to_history def __init__(self, *args, **kwargs): - # print(f"ARGS={args}") HistoricalBase.__init__(self) self._target = kwargs.pop("target", None) if self._target is not None: - # print(f"self._target is {self._target}") self._target = sanitize_skycoord(self._target) self._velocity_frame = self._target.frame.name else: @@ -164,11 +162,9 @@ def _toggle_sections(self, nchan, s): s1 = [] e = 0 # set this to 1 if you want to be exact complementary if s[0][0] == 0: - # print("toggle_sections: edged") for i in range(ns - 1): s1.append((s[i][1] + e, s[i + 1][0] - e)) else: - # print("toggle_sections: internal") s1.append((0, s[0][0])) for i in range(ns - 1): s1.append((s[i][1], s[i + 1][0])) @@ -745,7 +741,6 @@ def set_frame(self, toframe): actualframe = self.observer else: actualframe = astropy_frame_dict.get(toframe, toframe) - # print(f"actual frame is {actualframe} {type(actualframe)}") self._spectral_axis = self._spectral_axis.with_observer_stationary_relative_to(actualframe) self._meta["CTYPE1"] = change_ctype(self._meta["CTYPE1"], toframe) if isinstance(actualframe, str): @@ -1124,7 +1119,6 @@ def make_spectrum(cls, data, meta, use_wcs=True, observer_location=None): savecomment = meta.pop("COMMENT", None) if savecomment is None: savecomment = meta.pop("comments", None) - # print(f"{meta=}") wcs = WCS(header=meta) if savehist is not None: meta["HISTORY"] = savehist @@ -1172,7 +1166,6 @@ def make_spectrum(cls, data, meta, use_wcs=True, observer_location=None): obsitrs = None if np.ma.is_masked(data): - print("data are masked") s = cls( flux=data, wcs=wcs, @@ -1185,7 +1178,6 @@ def make_spectrum(cls, data, meta, use_wcs=True, observer_location=None): mask=data.mask, ) else: - print("data are NOT masked") s = cls( flux=data, wcs=wcs, @@ -1276,7 +1268,6 @@ def __truediv__(self, other): return result def _add_meta(self, operand, operand2, **kwargs): - # print(kwargs) kwargs.setdefault("other_meta", True) meta = deepcopy(operand) if kwargs["other_meta"]: @@ -1577,9 +1568,9 @@ def average_spectra(spectra, weights="tsys", align=False): if align: if i > 0: s = s.align_to(spectra[0]) - data_array[i] = s.data data_array[i].mask = s.mask + if weights == "tsys": wts[i] = core.tsys_weight(s.meta["EXPOSURE"], s.meta["CDELT1"], s.meta["TSYS"]) else: @@ -1588,7 +1579,8 @@ def average_spectra(spectra, weights="tsys", align=False): tsyss[i] = s.meta["TSYS"] xcoos[i] = s.meta["CRVAL2"] ycoos[i] = s.meta["CRVAL3"] - data_array = np.ma.MaskedArray(data_array, mask=np.isnan(data_array) | data_array.mask) + + data_array = np.ma.MaskedArray(data_array, mask=np.isnan(data_array) | data_array.mask, fill_value=np.nan) data = np.ma.average(data_array, axis=0, weights=wts) tsys = np.ma.average(tsyss, axis=0, weights=wts[:, 0]) xcoo = np.ma.average(xcoos, axis=0, weights=wts[:, 0]) From 93866476c7876969cee26c1dfd19436a410ddcca Mon Sep 17 00:00:00 2001 From: Marc Pound <22331890+mpound@users.noreply.github.com> Date: Wed, 23 Oct 2024 14:58:53 -0700 Subject: [PATCH 77/95] change chan to channel in agruments --- src/dysh/fits/gbtfitsload.py | 38 +++++++++++++++++++----------------- src/dysh/util/selection.py | 33 ++++++++++++++++--------------- 2 files changed, 37 insertions(+), 34 deletions(-) diff --git a/src/dysh/fits/gbtfitsload.py b/src/dysh/fits/gbtfitsload.py index 1ff54309..7e3fad31 100644 --- a/src/dysh/fits/gbtfitsload.py +++ b/src/dysh/fits/gbtfitsload.py @@ -604,7 +604,7 @@ def select_within(self, tag=None, **kwargs): self._selection.select_within(tag=tag, **kwargs) @log_call_to_history - def select_channel(self, chan, tag=None): + def select_channel(self, channel, tag=None): """ Select channels and/or channel ranges. These are NOT used in :meth:`final` but rather will be used to create a mask for calibration or @@ -626,14 +626,14 @@ def select_channel(self, chan, tag=None): Parameters ---------- - chan : number, or array-like + channel : number, or array-like The channels to select Returns ------- None. """ - self._selection.select_channel(tag=tag, chan=chan) + self._selection.select_channel(tag=tag, channel=channel) @log_call_to_history def clear_selection(self): @@ -643,9 +643,11 @@ def clear_selection(self): @log_call_to_history def flag(self, tag=None, **kwargs): """Add one or more exact flag rules, e.g., `key1 = value1, key2 = value2, ...` - If `value` is array-like then a match to any of the array members will be selected. - For instance `flag(object=['3C273', 'NGC1234'])` will flag data for either of those - objects and `flag(ifnum=[0,2])` will flag IF number 0 or IF number 2. + If `value` is array-like then a match to any of the array members will be flagged. + For instance `flag(object=['3C273', 'NGC1234'])` will select data for either of those + objects and `flag(ifnum=[0,2])` will flag IF number 0 or IF number 2. Channels for selected data + can be flagged using keyword `channel`, e.g., `flag(object='MBM12',channel=[0,23])` + will flag channels 0 through 23 *inclusive* for object MBM12. See `~dysh.util.selection.Flag`. Parameters @@ -719,7 +721,7 @@ def flag_within(self, tag=None, **kwargs): self._flag.flag_within(tag=tag, **kwargs) @log_call_to_history - def flag_channel(self, chan, tag=None): + def flag_channel(self, channel, tag=None): """ Select channels and/or channel ranges. These are NOT used in :meth:`final` but rather will be used to create a mask for @@ -743,14 +745,14 @@ def flag_channel(self, chan, tag=None): Parameters ---------- - chan : number, or array-like + channel : number, or array-like The channels to flag Returns ------- None. """ - self._flag.flag_channel(tag=tag, chan=chan) + self._flag.flag_channel(tag=tag, channel=channel) @log_call_to_history def apply_flags(self): @@ -898,7 +900,7 @@ def gettp( weights="tsys", bintable=None, smoothref=1, - apply_flags=False, + apply_flags=True, **kwargs, ): """ @@ -1022,7 +1024,7 @@ def getps( weights="tsys", bintable=None, smoothref=1, - apply_flags=False, + apply_flags=True, **kwargs, ): """ @@ -1046,7 +1048,7 @@ def getps( smooth_ref: int, optional the number of channels in the reference to boxcar smooth prior to calibration apply_flags : boolean, optional. If True, apply flags before calibration. - See :meth:`apply_flags`. Default: False + See :meth:`apply_flags`. Default: True **kwargs : dict Optional additional selection keyword arguments, typically given as key=value, though a dictionary works too. @@ -1178,7 +1180,7 @@ def getnod( weights="tsys", bintable=None, smoothref=1, - apply_flags=False, + apply_flags=True, **kwargs, ): """ @@ -1206,7 +1208,7 @@ def getnod( smooth_ref: int, optional the number of channels in the reference to boxcar smooth prior to calibration apply_flags : boolean, optional. If True, apply flags before calibration. - See :meth:`apply_flags`. Default: False + See :meth:`apply_flags`. Default: True **kwargs : dict Optional additional selection keyword arguments, typically given as key=value, though a dictionary works too. @@ -1400,7 +1402,7 @@ def getfs( weights="tsys", bintable=None, smoothref=1, - apply_flags=False, + apply_flags=True, observer_location=Observatory["GBT"], **kwargs, ): @@ -1436,7 +1438,7 @@ def getfs( smooth_ref: int, optional the number of channels in the reference to boxcar smooth prior to calibration apply_flags : boolean, optional. If True, apply flags before calibration. - See :meth:`apply_flags`. Default: False + See :meth:`apply_flags`. Default: True observer_location : `~astropy.coordinates.EarthLocation` Location of the observatory. See `~dysh.coordinates.Observatory`. This will be transformed to `~astropy.coordinates.ITRS` using the time of @@ -1557,7 +1559,7 @@ def subbeamnod( weights="tsys", bintable=None, smoothref=1, - apply_flags=False, + apply_flags=True, **kwargs, ): """Get a subbeam nod power scan, optionally calibrating it. @@ -1583,7 +1585,7 @@ def subbeamnod( smooth_ref: int, optional the number of channels in the reference to boxcar smooth prior to calibration apply_flags : boolean, optional. If True, apply flags before calibration. - See :meth:`apply_flags`. Default: False + See :meth:`apply_flags`. Default: True **kwargs : dict Optional additional selection keyword arguments, typically given as key=value, though a dictionary works too. diff --git a/src/dysh/util/selection.py b/src/dysh/util/selection.py index 904ed142..a7829c0b 100644 --- a/src/dysh/util/selection.py +++ b/src/dysh/util/selection.py @@ -631,7 +631,7 @@ def _base_select_within(self, tag=None, **kwargs): kw[k] = (v1, v2) self._base_select_range(tag, **kw) - def _base_select_channel(self, chan, tag=None): + def _base_select_channel(self, channel, tag=None): """ Select channels and/or channel ranges. These are NOT used in :meth:`final` but rather will be used to create a mask for calibration or @@ -655,7 +655,7 @@ def _base_select_channel(self, chan, tag=None): Parameters ---------- - chan : number, or array-like + channel : number, or array-like The channels to select Returns @@ -671,11 +671,11 @@ def _base_select_channel(self, chan, tag=None): raise Exception( "You can only have one channel selection rule. Remove the old rule before creating a new one." ) - self._check_numbers(chan=chan) - if isinstance(chan, numbers.Number): - chan = [int(chan)] - self._channel_selection = chan - self._addrow({"CHAN": str(chan)}, dataframe=self, tag=tag) + self._check_numbers(chan=channel) + if isinstance(channel, numbers.Number): + channel = [int(channel)] + self._channel_selection = channel + self._addrow({"CHAN": str(channel)}, dataframe=self, tag=tag) # NB: using ** in doc here because `id` will make a reference to the # python built-in function. Arguably we should pick a different @@ -1017,9 +1017,9 @@ def flag(self, tag=None, **kwargs): """Add one or more exact flag rules, e.g., `key1 = value1, key2 = value2, ...` If `value` is array-like then a match to any of the array members will be flagged. For instance `flag(object=['3C273', 'NGC1234'])` will select data for either of those - objects and `flag(ifnum=[0,2])` will flag IF number 0 or IF number 2. Channels can be flagged - using keyword `chan`, e.g., `flag(object='MBM12',chan=[0,23])` will flag channels 0 through 23 *inclusive* - for object MBM12. + objects and `flag(ifnum=[0,2])` will flag IF number 0 or IF number 2. Channels for selected data + can be flagged using keyword `channel`, e.g., `flag(object='MBM12',channel=[0,23])` + will flag channels 0 through 23 *inclusive* for object MBM12. Parameters ---------- @@ -1032,7 +1032,7 @@ def flag(self, tag=None, **kwargs): The value to select """ - chan = kwargs.pop("chan", None) + chan = kwargs.pop("channel", None) if chan is not None: if isinstance(chan, numbers.Number): chan = [int(chan)] @@ -1045,9 +1045,9 @@ def flag(self, tag=None, **kwargs): else: self._flag_channel_selection[idx] = ALL_CHANNELS - def flag_channel(self, chan, tag=None, **kwargs): + def flag_channel(self, channel, tag=None, **kwargs): """ - Flag channels and/or channel ranges for all rows. These are NOT used in :meth:`final` + Flag channels and/or channel ranges for *all data*. These are NOT used in :meth:`final` but rather will be used to create a mask for flagging. Single arrays/tuples will be treated as *channel lists; nested arrays will be treated as *inclusive* ranges. For instance: @@ -1070,7 +1070,7 @@ def flag_channel(self, chan, tag=None, **kwargs): Parameters ---------- - chan : number, or array-like + channel : number, or array-like The channels to flag Returns @@ -1079,9 +1079,10 @@ def flag_channel(self, chan, tag=None, **kwargs): """ # okay to use base method because we are flagging all rows - self._base_select_channel(chan, tag, **kwargs) + self._base_select_channel(channel, tag, **kwargs) idx = len(self._table) - 1 - self._flag_channel_selection[idx] = chan + self._flag_channel_selection[idx] = channel + self._channel_selection = None # unused for flagging def flag_range(self, tag=None, **kwargs): """Flag a range of inclusive values for a given key(s). From 0666d5cf2a80811dd953d2662ff25cd52f72002a Mon Sep 17 00:00:00 2001 From: Marc Pound <22331890+mpound@users.noreply.github.com> Date: Wed, 23 Oct 2024 14:59:22 -0700 Subject: [PATCH 78/95] use logger.debug --- src/dysh/fits/sdfitsload.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/dysh/fits/sdfitsload.py b/src/dysh/fits/sdfitsload.py index 0dd079e0..3a10c60e 100644 --- a/src/dysh/fits/sdfitsload.py +++ b/src/dysh/fits/sdfitsload.py @@ -78,7 +78,7 @@ def _init_flags(self): for i in range(len(self._flagmask)): nc = self.nchan(i) nr = self.nrows(i) - print(f"{nr=} {nc=}") + logger.debug(f"{nr=} {nc=}") self._flagmask[i] = np.full((nr, nc), fill_value=False) def info(self): From d306883dbbaf8acdd59c87a3ad6d28d82b653faa Mon Sep 17 00:00:00 2001 From: Marc Pound <22331890+mpound@users.noreply.github.com> Date: Wed, 23 Oct 2024 15:33:14 -0700 Subject: [PATCH 79/95] add note about zeros and np.ma.average --- src/dysh/spectra/scan.py | 38 ++++++++++++++++++++++++++++++++++++++ 1 file changed, 38 insertions(+) diff --git a/src/dysh/spectra/scan.py b/src/dysh/spectra/scan.py index 0a7ccdd1..843bf72b 100644 --- a/src/dysh/spectra/scan.py +++ b/src/dysh/spectra/scan.py @@ -45,6 +45,9 @@ def timeaverage(self, weights=None): ------- spectrum : :class:`~spectra.spectrum.Spectrum` The time-averaged spectrum + + .. note:: + Data that are masked will have values set to zero. This is a feature of `numpy.ma.average`. Data mask fill value is NaN (np.nan) """ pass @@ -413,10 +416,14 @@ def timeaverage(self, weights="tsys"): :math:`w = t_{exp} \times \delta\nu/T_{sys}^2` Default: 'tsys' + Returns ------- timeaverage: list of `~spectra.spectrum.Spectrum` List of all the time-averaged spectra + + .. note:: + Data that are masked will have values set to zero. This is a feature of `numpy.ma.average`. Data mask fill value is NaN (np.nan) """ # warnings.simplefilter("ignore", NoVelocityWarning) # average of the averages @@ -878,6 +885,9 @@ def timeaverage(self, weights="tsys"): ------- spectrum : :class:`~spectra.spectrum.Spectrum` The time-averaged spectrum + + .. note:: + Data that are masked will have values set to zero. This is a feature of `numpy.ma.average`. Data mask fill value is NaN (np.nan) """ if self._npol > 1: raise Exception("Can't yet time average multiple polarizations") @@ -1104,10 +1114,14 @@ def timeaverage(self, weights="tsys"): :math:`w = t_{exp} \times \delta\nu/T_{sys}^2` Default: 'tsys' + Returns ------- spectrum : :class:`~spectra.spectrum.Spectrum` The time-averaged spectrum + + .. note:: + Data that are masked will have values set to zero. This is a feature of `numpy.ma.average`. Data mask fill value is NaN (np.nan) """ if self._calibrated is None or len(self._calibrated) == 0: raise Exception("You can't time average before calibration.") @@ -1354,6 +1368,9 @@ def timeaverage(self, weights="tsys"): ------- spectrum : :class:`~spectra.spectrum.Spectrum` The time-averaged spectrum + + .. note:: + Data that are masked will have values set to zero. This is a feature of `numpy.ma.average`. Data mask fill value is NaN (np.nan) """ if self._calibrated is None or len(self._calibrated) == 0: raise Exception("You can't time average before calibration.") @@ -1748,6 +1765,9 @@ def timeaverage(self, weights="tsys"): ------- spectrum : :class:`~spectra.spectrum.Spectrum` The time-averaged spectrum + + .. note:: + Data that are masked will have values set to zero. This is a feature of `numpy.ma.average`. Data mask fill value is NaN (np.nan) """ if self._calibrated is None or len(self._calibrated) == 0: raise Exception("You can't time average before calibration.") @@ -1887,6 +1907,24 @@ def delta_freq(self): return self._delta_freq def timeaverage(self, weights="tsys"): + r"""Compute the time-averaged spectrum for this scan. + + Parameters + ---------- + weights: str + 'tsys' or None. If 'tsys' the weight will be calculated as: + + :math:`w = t_{exp} \times \delta\nu/T_{sys}^2` + + Default: 'tsys' + Returns + ------- + spectrum : :class:`~spectra.spectrum.Spectrum` + The time-averaged spectrum + + .. note:: + Data that are masked will have values set to zero. This is a feature of `numpy.ma.average`. Data mask fill value is NaN (np.nan) + """ if self._calibrated is None or len(self._calibrated) == 0: raise Exception("You can't time average before calibration.") if self._npol > 1: From 144abbaa59b1dd9cd01cd60bf63946c28fb1eae8 Mon Sep 17 00:00:00 2001 From: Marc Pound <22331890+mpound@users.noreply.github.com> Date: Wed, 23 Oct 2024 15:33:37 -0700 Subject: [PATCH 80/95] remove debug print --- src/dysh/fits/gbtfitsload.py | 2 -- 1 file changed, 2 deletions(-) diff --git a/src/dysh/fits/gbtfitsload.py b/src/dysh/fits/gbtfitsload.py index 7e3fad31..6ec88553 100644 --- a/src/dysh/fits/gbtfitsload.py +++ b/src/dysh/fits/gbtfitsload.py @@ -770,13 +770,11 @@ def apply_flags(self): # For all SDFs in each flag rule, set the flag mask(s) # for their rows. The index of the sdf._flagmask array is the bintable index for key, chan in self._flag._flag_channel_selection.items(): - print(f"{key=} {chan=}") selection = self._flag.get(key) # chan will be a list or a list of lists # If it is a single list, it is just a list of channels # if it is list of lists, then it is upper lower inclusive dfs = selection.groupby(["FITSINDEX", "BINTABLE"]) - print(f"{key=} {chan=}") # the dict key for the groups is a tuple (fitsindex,bintable) for i, ((fi, bi), g) in enumerate(dfs): chan_mask = convert_array_to_mask(chan, self._sdf[fi].nchan(bi)) From 8ee1f5c38e3d6949048a15078b9e75c418400983 Mon Sep 17 00:00:00 2001 From: Marc Pound <22331890+mpound@users.noreply.github.com> Date: Wed, 23 Oct 2024 17:29:23 -0700 Subject: [PATCH 81/95] fix NodScan timeaverage --- src/dysh/spectra/scan.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/dysh/spectra/scan.py b/src/dysh/spectra/scan.py index 843bf72b..2a1c4f7a 100644 --- a/src/dysh/spectra/scan.py +++ b/src/dysh/spectra/scan.py @@ -1382,7 +1382,7 @@ def timeaverage(self, weights="tsys"): w = self.tsys_weight else: w = np.ones_like(self.tsys_weight) - self._timeaveraged._data = np.ma.average(self._data, axis=0, weights=w) + self._timeaveraged._data = np.ma.average(data, axis=0, weights=w) self._timeaveraged._data.set_fill_value(np.nan) non_blanks = find_non_blanks(data) self._timeaveraged.meta["MEANTSYS"] = np.mean(self._tsys[non_blanks]) From 94c4cda258b04a48bebc77408717ec80020221f3 Mon Sep 17 00:00:00 2001 From: Marc Pound <22331890+mpound@users.noreply.github.com> Date: Wed, 23 Oct 2024 17:31:58 -0700 Subject: [PATCH 82/95] fix goto button text --- docs/source/reference/modules/index.rst | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/source/reference/modules/index.rst b/docs/source/reference/modules/index.rst index a2c05f05..36346350 100644 --- a/docs/source/reference/modules/index.rst +++ b/docs/source/reference/modules/index.rst @@ -41,7 +41,7 @@ Modules and APIs :outline: :click-parent: - Go to dysh.spectra + Go to dysh.plot .. grid-item-card:: :shadow: md From c17dc8ce61c6ef66c013ecac43f90d1660badb79 Mon Sep 17 00:00:00 2001 From: Marc Pound <22331890+mpound@users.noreply.github.com> Date: Thu, 24 Oct 2024 10:10:03 -0700 Subject: [PATCH 83/95] don't plot masked values --- src/dysh/plot/specplot.py | 2 ++ 1 file changed, 2 insertions(+) diff --git a/src/dysh/plot/specplot.py b/src/dysh/plot/specplot.py index 43bbb1f3..3cd0c0a1 100644 --- a/src/dysh/plot/specplot.py +++ b/src/dysh/plot/specplot.py @@ -7,6 +7,7 @@ import astropy.units as u import matplotlib.pyplot as plt import numpy as np +from astropy.utils.masked import Masked from ..coordinates import frame_to_label @@ -150,6 +151,7 @@ def plot(self, **kwargs): sf = s.flux if yunit is not None: sf = s.flux.to(yunit) + sf = Masked(sf, s.mask) self._axis.plot(sa, sf, color=this_plot_kwargs["color"], lw=lw) self._axis.set_xlim(this_plot_kwargs["xmin"], this_plot_kwargs["xmax"]) self._axis.set_ylim(this_plot_kwargs["ymin"], this_plot_kwargs["ymax"]) From 6254f648187b524f80f5ab18239625fb9acf9bee Mon Sep 17 00:00:00 2001 From: Marc Pound <22331890+mpound@users.noreply.github.com> Date: Thu, 24 Oct 2024 10:50:00 -0700 Subject: [PATCH 84/95] UMD Icon for posters and other documentation --- .../_static/icon/UMD_Globe_Icon_Large.png | Bin 0 -> 205360 bytes 1 file changed, 0 insertions(+), 0 deletions(-) create mode 100644 docs/source/_static/icon/UMD_Globe_Icon_Large.png diff --git a/docs/source/_static/icon/UMD_Globe_Icon_Large.png b/docs/source/_static/icon/UMD_Globe_Icon_Large.png new file mode 100644 index 0000000000000000000000000000000000000000..972364cb5b1f03bb0016fdaa47ae6bd310d23c80 GIT binary patch literal 205360 zcmYgYcR1B=+&(tP%qDxUgb=d#9*1LZ$H*omB-tZ-@4Z)75RNk7?4AT}lq4|E}2@;=U3p{$DsP`;=&A-0T}{VDWrjr8L- z6>MRbd|?gf+o!J2-2CPE_FY=oAW3X4lPu^Y18OAq3)WcD5ZMJhi%GQE1?w8wINCqU z!aDPPnJC$UdcI_0JPJ8Gi=d0{!?XLEBYO1mPe6?Kix>0A;Xo|a8|IzGa_#nlk2UYH4VA{OQ~9^nU*QDnPP+ z4)?CDal!;HB{~RZjco~CDSlj`$42iocRP6aC{tY^v#Ex( z^KHGf)Q?@{lhJ6EcO$uEO&&TAknEq5kpJn~X2^RnDPAaN zCEMLh{_pnV_XOj7CK>`IrhAzdS?X*%(eCnw-Eqj7nugphgN-(apmt>Tc!PH-^8C;sd4bS!OF*@8{#Bd$>k0W1k z^~Qo%xti>=RG>Mrauhl6OWMGJ=)GoK1#Csu+=7FYsWsD7{}8k7Ope!&kMhmHnz#S* z&QgE5*?2~^n3luVj@QD5XH=$|AEg92oU!}cw{L&{x?5OS7#L9G=8kQ}$TNAx8M-5T zOLDhSj>9nP17_SGc9}mE4P<6!CWr{}XFsXYmoL^ipr2*94y`1E*W1BkrO_JZYf4mk zk5?xq!1DCu<iMToat5lx zNXDD4mQ9M;v7D#Q<|3T^RY|L?Pr6l(DX}1G%co-}rOVung}9JpPNf^1nxIQ`TOqLh zx2g57CmV=cwB5g83uSq5Y_DLVqImv0KP7^O84C4Xwhbo<+-s`AmoZ?Zj!n8>zcq1m z5dcOZ7%q5#_)c*VK-VmaYz8G|1}u1i?g0Efy^?S?K04}Bm#kn#IAxSPCKlF3i+7u; zAoj_WThdp(06hf}nzDB@hPafpv@=6J*vUhPpWGD_OB8oaIbhzM6U^`@zB1XL@jb1% zk2le(L7V%#yTt!45)<#`kCh+X)8EyU{oX+kqYL28L2$S>C921+k$?142kI;nn5yAm zV3J0Cx6aO;8{Mr4pRi

|fz8 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 literal 0 HcmV?d00001 From d4a5376b9b6848613c69fd6891f1d85aee093d26 Mon Sep 17 00:00:00 2001 From: Marc Pound <22331890+mpound@users.noreply.github.com> Date: Thu, 24 Oct 2024 12:06:07 -0700 Subject: [PATCH 85/95] deal with masks during smoothing --- src/dysh/spectra/core.py | 6 +++++- src/dysh/spectra/spectrum.py | 12 +++++++----- 2 files changed, 12 insertions(+), 6 deletions(-) diff --git a/src/dysh/spectra/core.py b/src/dysh/spectra/core.py index cfb35bec..1f128d84 100644 --- a/src/dysh/spectra/core.py +++ b/src/dysh/spectra/core.py @@ -680,7 +680,11 @@ def smooth(data, method="hanning", width=1, kernel=None, show=False): if show: return kernel # the boundary='extend' matches GBTIDL's /edge_truncate CONVOL() method - new_data = convolve(data, kernel, boundary="extend") + if hasattr(data, "mask"): + mask = data.mask + else: + mask = None + new_data = convolve(data, kernel, boundary="extend", nan_treatment="fill", fill_value=np.nan, mask=mask) return new_data diff --git a/src/dysh/spectra/spectrum.py b/src/dysh/spectra/spectrum.py index 773d0ac8..cb934387 100644 --- a/src/dysh/spectra/spectrum.py +++ b/src/dysh/spectra/spectrum.py @@ -486,7 +486,7 @@ def smooth(self, method="hanning", width=1, decimate=0, kernel=None): # All checks for smoothing should be completed by this point. # Create a new metadata dictionary to modify by smooth. new_meta = deepcopy(self.meta) - + md = np.ma.masked_array(self._data, self.mask) if this_method == "gaussian": if width <= self._resolution: raise ValueError( @@ -494,12 +494,14 @@ def smooth(self, method="hanning", width=1, decimate=0, kernel=None): ) kwidth = np.sqrt(width**2 - self._resolution**2) # Kernel effective width. stddev = kwidth / 2.35482 - s1 = core.smooth(self._data, this_method, stddev) + + s1 = core.smooth(md, this_method, stddev) else: kwidth = width - s1 = core.smooth(self._data, this_method, width) - - new_data = s1 * self.flux.unit + s1 = core.smooth(md, this_method, width) + mask = np.full(s1.shape, False) + mask[np.where(s1 == np.nan)] = True + new_data = Masked(s1 * self.flux.unit, mask) new_meta["FREQRES"] = np.sqrt((kwidth * self.meta["CDELT1"]) ** 2 + self.meta["FREQRES"] ** 2) s = Spectrum.make_spectrum(new_data, meta=new_meta) From 63ecbb93fa645d4d7e9008cad35d5c26a8488332 Mon Sep 17 00:00:00 2001 From: Marc Pound <22331890+mpound@users.noreply.github.com> Date: Thu, 24 Oct 2024 12:11:07 -0700 Subject: [PATCH 86/95] deal with masks during smoothing --- src/dysh/spectra/spectrum.py | 3 +++ 1 file changed, 3 insertions(+) diff --git a/src/dysh/spectra/spectrum.py b/src/dysh/spectra/spectrum.py index cb934387..30c398d8 100644 --- a/src/dysh/spectra/spectrum.py +++ b/src/dysh/spectra/spectrum.py @@ -500,6 +500,9 @@ def smooth(self, method="hanning", width=1, decimate=0, kernel=None): kwidth = width s1 = core.smooth(md, this_method, width) mask = np.full(s1.shape, False) + # in core.smooth, we fill masked values with np.nan. + # astropy.convolve does not return a new mask, so we recreate + # a decimated mask where values are nan mask[np.where(s1 == np.nan)] = True new_data = Masked(s1 * self.flux.unit, mask) new_meta["FREQRES"] = np.sqrt((kwidth * self.meta["CDELT1"]) ** 2 + self.meta["FREQRES"] ** 2) From 242b41b023c70bc2210564ce59586fbfb49a02bd Mon Sep 17 00:00:00 2001 From: Marc Pound <22331890+mpound@users.noreply.github.com> Date: Thu, 24 Oct 2024 12:45:11 -0700 Subject: [PATCH 87/95] revert change that broke pytes --- src/dysh/spectra/spectrum.py | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/src/dysh/spectra/spectrum.py b/src/dysh/spectra/spectrum.py index 30c398d8..45dee98e 100644 --- a/src/dysh/spectra/spectrum.py +++ b/src/dysh/spectra/spectrum.py @@ -499,12 +499,13 @@ def smooth(self, method="hanning", width=1, decimate=0, kernel=None): else: kwidth = width s1 = core.smooth(md, this_method, width) - mask = np.full(s1.shape, False) + #mask = np.full(s1.shape, False) # in core.smooth, we fill masked values with np.nan. # astropy.convolve does not return a new mask, so we recreate # a decimated mask where values are nan - mask[np.where(s1 == np.nan)] = True - new_data = Masked(s1 * self.flux.unit, mask) + #mask[np.where(s1 == np.nan)] = True + #new_data = Masked(s1 * self.flux.unit, mask) + new_data = s1*self.flux.unit new_meta["FREQRES"] = np.sqrt((kwidth * self.meta["CDELT1"]) ** 2 + self.meta["FREQRES"] ** 2) s = Spectrum.make_spectrum(new_data, meta=new_meta) From d96679f6dbdf381f296dd2af9123d4f26ce15049 Mon Sep 17 00:00:00 2001 From: Marc Pound <22331890+mpound@users.noreply.github.com> Date: Thu, 24 Oct 2024 12:46:27 -0700 Subject: [PATCH 88/95] fix change that broke pytest the general idea is correct but getps with smoothref needs working out. --- src/dysh/spectra/core.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/dysh/spectra/core.py b/src/dysh/spectra/core.py index 1f128d84..bd3dce11 100644 --- a/src/dysh/spectra/core.py +++ b/src/dysh/spectra/core.py @@ -684,7 +684,7 @@ def smooth(data, method="hanning", width=1, kernel=None, show=False): mask = data.mask else: mask = None - new_data = convolve(data, kernel, boundary="extend", nan_treatment="fill", fill_value=np.nan, mask=mask) + new_data = convolve(data, kernel, boundary="extend")#, nan_treatment="fill", fill_value=np.nan, mask=mask) return new_data From 0a2981e12b6cfc9b8494fbbc580dbb42e4636a8b Mon Sep 17 00:00:00 2001 From: "pre-commit-ci[bot]" <66853113+pre-commit-ci[bot]@users.noreply.github.com> Date: Thu, 24 Oct 2024 19:48:28 +0000 Subject: [PATCH 89/95] [pre-commit.ci] auto fixes from pre-commit.com hooks for more information, see https://pre-commit.ci --- src/dysh/spectra/core.py | 2 +- src/dysh/spectra/spectrum.py | 8 ++++---- 2 files changed, 5 insertions(+), 5 deletions(-) diff --git a/src/dysh/spectra/core.py b/src/dysh/spectra/core.py index bd3dce11..bd6ed2d5 100644 --- a/src/dysh/spectra/core.py +++ b/src/dysh/spectra/core.py @@ -684,7 +684,7 @@ def smooth(data, method="hanning", width=1, kernel=None, show=False): mask = data.mask else: mask = None - new_data = convolve(data, kernel, boundary="extend")#, nan_treatment="fill", fill_value=np.nan, mask=mask) + new_data = convolve(data, kernel, boundary="extend") # , nan_treatment="fill", fill_value=np.nan, mask=mask) return new_data diff --git a/src/dysh/spectra/spectrum.py b/src/dysh/spectra/spectrum.py index 45dee98e..7b42acae 100644 --- a/src/dysh/spectra/spectrum.py +++ b/src/dysh/spectra/spectrum.py @@ -499,13 +499,13 @@ def smooth(self, method="hanning", width=1, decimate=0, kernel=None): else: kwidth = width s1 = core.smooth(md, this_method, width) - #mask = np.full(s1.shape, False) + # mask = np.full(s1.shape, False) # in core.smooth, we fill masked values with np.nan. # astropy.convolve does not return a new mask, so we recreate # a decimated mask where values are nan - #mask[np.where(s1 == np.nan)] = True - #new_data = Masked(s1 * self.flux.unit, mask) - new_data = s1*self.flux.unit + # mask[np.where(s1 == np.nan)] = True + # new_data = Masked(s1 * self.flux.unit, mask) + new_data = s1 * self.flux.unit new_meta["FREQRES"] = np.sqrt((kwidth * self.meta["CDELT1"]) ** 2 + self.meta["FREQRES"] ** 2) s = Spectrum.make_spectrum(new_data, meta=new_meta) From 203be545ddfcf7e1bf454e5d9140b2e2eac3776e Mon Sep 17 00:00:00 2001 From: astrofle Date: Fri, 25 Oct 2024 11:01:53 -0400 Subject: [PATCH 90/95] Fix: use lowest supported Python version for pre-commit --- .pre-commit-config.yaml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml index 4fadf5b8..dde8d987 100644 --- a/.pre-commit-config.yaml +++ b/.pre-commit-config.yaml @@ -1,7 +1,7 @@ --- # See https://pre-commit.com for more information default_language_version: - python: python3.11 + python: python3.10 # See https://pre-commit.com/hooks.html for more hooks repos: From a3a6b426b52099f69d2336c90c1cbab78d4c0546 Mon Sep 17 00:00:00 2001 From: astrofle Date: Fri, 25 Oct 2024 11:04:09 -0400 Subject: [PATCH 91/95] Fix: update notebook after changes to align_to --- notebooks/examples/align_spectra.ipynb | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-) diff --git a/notebooks/examples/align_spectra.ipynb b/notebooks/examples/align_spectra.ipynb index 29daee33..2ae61aec 100644 --- a/notebooks/examples/align_spectra.ipynb +++ b/notebooks/examples/align_spectra.ipynb @@ -219,7 +219,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "

" ] @@ -272,7 +272,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -304,7 +304,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -314,11 +314,11 @@ } ], "source": [ - "ps_ref.align_to(ps_sig)\n", + "ps_ref_aligned = ps_ref.align_to(ps_sig)\n", "\n", "plt.figure()\n", "plt.plot(ps_sig.flux)\n", - "plt.plot(ps_ref.flux)\n", + "plt.plot(ps_ref_aligned.flux)\n", "plt.ylabel(f\"Antenna temperature ({ps_sig.flux.unit})\")\n", "plt.xlabel(\"Channel\");" ] @@ -338,7 +338,7 @@ "metadata": {}, "outputs": [], "source": [ - "ps_avg = average_spectra((ps_sig, ps_ref))" + "ps_avg = average_spectra((ps_sig, ps_ref_aligned))" ] }, { @@ -349,7 +349,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -413,7 +413,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.9.0" + "version": "3.12.0" } }, "nbformat": 4, From e71b9a0e28c05e91d516d58e6c82df64ff188f57 Mon Sep 17 00:00:00 2001 From: astrofle Date: Fri, 25 Oct 2024 11:04:35 -0400 Subject: [PATCH 92/95] Fix: remove print statements --- src/dysh/spectra/scan.py | 18 +++++++----------- 1 file changed, 7 insertions(+), 11 deletions(-) diff --git a/src/dysh/spectra/scan.py b/src/dysh/spectra/scan.py index 2a1c4f7a..7827bd23 100644 --- a/src/dysh/spectra/scan.py +++ b/src/dysh/spectra/scan.py @@ -431,7 +431,6 @@ def timeaverage(self, weights="tsys"): i = 0 for scan in self.data: self._timeaveraged.append(scan.timeaverage(weights)) - print(f"timeaveraged[{i}]= {self._timeaveraged[i].data.data}") s = average_spectra(self._timeaveraged, weights=weights) s.merge_commentary(self) return s @@ -1559,8 +1558,8 @@ def calibrate(self, **kwargs): fold=True or fold=False is required """ if self._debug: - print(f'FOLD={kwargs["fold"]}') - print(f'METHOD={kwargs["shift_method"]}') + logger.debug(f'FOLD={kwargs["fold"]}') + logger.debug(f'METHOD={kwargs["shift_method"]}') # some helper functions, courtesy proto_getfs.py def channel_to_frequency(crval1, crpix1, cdelt1, vframe, nchan, nint, ndim=1): @@ -1656,26 +1655,23 @@ def do_fold(sig, ref, sig_freq, ref_freq, remove_wrap=False, shift_method="fft") sig_freq = self._sigcalon[0] df_sig = self._sdfits.index(bintable=self._bintable_index).iloc[self._sigonrows] df_ref = self._sdfits.index(bintable=self._bintable_index).iloc[self._refonrows] - if self._debug: - print("df_sig", type(df_sig), len(df_sig)) + logger.debug(f"df_sig {type(df_sig)} len(df_sig)") sig_freq = index_frequency(df_sig) ref_freq = index_frequency(df_ref) chan_shift = abs(sig_freq[0, 0] - ref_freq[0, 0]) / np.abs(np.diff(sig_freq)).mean() - if self._debug: - print("FS: shift=%g nchan=%d" % (chan_shift, self._nchan)) + logger.debug(f"FS: shift={chan_shift:g} nchan={self._nchan:g}") # tcal is the same for REF and SIG, and the same for all integrations actually. tcal = self._sdfits.index(bintable=self._bintable_index).iloc[self._sigonrows]["TCAL"].to_numpy() - if self._debug: - print("TCAL:", len(tcal), tcal[0]) + logger.debug(f"TCAL: {len(tcal)} {tcal[0]}") if len(tcal) != nspect: raise Exception(f"TCAL length {len(tcal)} and number of spectra {nspect} don't match") # @todo the nspect loop could be replaced with clever numpy? for i in range(nspect): tsys_sig = mean_tsys(calon=self._sigcalon[i], caloff=self._sigcaloff[i], tcal=tcal[i]) tsys_ref = mean_tsys(calon=self._refcalon[i], caloff=self._refcaloff[i], tcal=tcal[i]) - if i == 0 and self._debug: - print("Tsys(sig/ref)[0]=", tsys_sig, tsys_ref) + if i == 0: + logger.debug(f"Tsys(sig/ref)[0]={tsys_sig} / {tsys_ref}") tp_sig = 0.5 * (self._sigcalon[i] + self._sigcaloff[i]) tp_ref = 0.5 * (self._refcalon[i] + self._refcaloff[i]) # From 5377305bd02fcb654c86b974ab4fc4528c4ef473 Mon Sep 17 00:00:00 2001 From: astrofle Date: Fri, 25 Oct 2024 11:05:14 -0400 Subject: [PATCH 93/95] Fix: use a raw string in average_spectra docstring --- src/dysh/spectra/spectrum.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/dysh/spectra/spectrum.py b/src/dysh/spectra/spectrum.py index 7b42acae..d0b1bfc2 100644 --- a/src/dysh/spectra/spectrum.py +++ b/src/dysh/spectra/spectrum.py @@ -1527,7 +1527,7 @@ def spectrum_reader_gbtidl(fileobj, **kwargs): def average_spectra(spectra, weights="tsys", align=False): - """ + r""" Average `spectra`. The resulting `average` will have an exposure equal to the sum of the exposures, and coordinates and system temperature equal to the weighted average of the coordinates and system temperatures. From be4282fa8f98b31d2996439c9c4dddd9332fd30e Mon Sep 17 00:00:00 2001 From: astrofle Date: Fri, 25 Oct 2024 11:10:00 -0400 Subject: [PATCH 94/95] Add: mask slicing for Spectrum --- src/dysh/spectra/spectrum.py | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/src/dysh/spectra/spectrum.py b/src/dysh/spectra/spectrum.py index d0b1bfc2..5dfe3249 100644 --- a/src/dysh/spectra/spectrum.py +++ b/src/dysh/spectra/spectrum.py @@ -1368,7 +1368,9 @@ def wav2idx(wav, wcs, spectral_axis, coo, sto): # New Spectrum. return self.make_spectrum( - self.flux[start_idx:stop_idx], meta=meta, observer_location=Observatory[meta["TELESCOP"]] + Masked(self.flux[start_idx:stop_idx], self.mask[start_idx:stop_idx]), + meta=meta, + observer_location=Observatory[meta["TELESCOP"]], ) From 4ea555e8b117813ae27d2dc5c6bdb00309f32607 Mon Sep 17 00:00:00 2001 From: Thomas Chamberlin Date: Fri, 25 Oct 2024 13:20:35 -0400 Subject: [PATCH 95/95] Drop support for Python 3.9 (#406) specutils has dropped support for Python 3.9, so we will also Note also that we are explicitly dropping support for Python 3.13+, because our maximum-supported Astropy version is incompatible with 3.13+ --- .github/workflows/ci.yml | 4 +-- .github/workflows/release.yml | 2 +- .pre-commit-config.yaml | 2 +- .readthedocs.yaml | 2 +- docs/source/for_beta_testers/beta_testing.rst | 2 +- .../for_developers/manage_requirements.rst | 10 +++--- pyproject.toml | 8 ++--- requirements.txt | 31 ++----------------- 8 files changed, 15 insertions(+), 46 deletions(-) diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index b905b087..27b39360 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -27,7 +27,7 @@ jobs: fail-fast: false matrix: os: [ubuntu-latest, windows-latest, macos-latest] - python-version: ["3.9", "3.10", "3.11", "3.12"] + python-version: ["3.10", "3.11", "3.12"] steps: - uses: actions/checkout@v4 - name: Set up Python ${{ matrix.python-version }} @@ -63,7 +63,7 @@ jobs: - uses: actions/checkout@v4 - uses: actions/setup-python@v4 with: - python-version: 3.9 + python-version: "3.10" cache: pip - run: pip install --upgrade coverage[toml] - uses: actions/download-artifact@v4 diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml index 8c83c31b..05b5aefb 100644 --- a/.github/workflows/release.yml +++ b/.github/workflows/release.yml @@ -18,7 +18,7 @@ jobs: - name: Set up Python ubuntu-latest uses: actions/setup-python@v4 with: - python-version: '3.9' # Should always be the minimum supported Python version + python-version: '3.10' # Should always be the minimum supported Python version cache: 'pip' cache-dependency-path': 'requirements.txt' - name: Install dependencies diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml index de4e221b..dde8d987 100644 --- a/.pre-commit-config.yaml +++ b/.pre-commit-config.yaml @@ -1,7 +1,7 @@ --- # See https://pre-commit.com for more information default_language_version: - python: python3.9 + python: python3.10 # See https://pre-commit.com/hooks.html for more hooks repos: diff --git a/.readthedocs.yaml b/.readthedocs.yaml index e0652ef0..e2a2913c 100644 --- a/.readthedocs.yaml +++ b/.readthedocs.yaml @@ -9,7 +9,7 @@ version: 2 build: os: ubuntu-22.04 tools: - python: "3.9" + python: "3.10" # You can also specify other tool versions: # nodejs: "19" # rust: "1.64" diff --git a/docs/source/for_beta_testers/beta_testing.rst b/docs/source/for_beta_testers/beta_testing.rst index 44e24315..6898e9e3 100644 --- a/docs/source/for_beta_testers/beta_testing.rst +++ b/docs/source/for_beta_testers/beta_testing.rst @@ -70,7 +70,7 @@ We provide steps for working in one of `GBO data reduction hosts