From bc05059675556532fa600db8957cc83d33883802 Mon Sep 17 00:00:00 2001 From: Jayaram Kancherla Date: Mon, 22 Jul 2024 15:32:07 -0700 Subject: [PATCH] Updates to content (#7) --- howto.qmd | 13 +- index.qmd | 12 +- notebook/annotate_cell_types.ipynb | 329 +++++++++----- notebook/genomic_ranges.ipynb | 692 +++++++++++++---------------- tutorials/annotate_cell_types.qmd | 191 +++++--- tutorials/genomic_ranges.qmd | 290 ++++++------ 6 files changed, 822 insertions(+), 705 deletions(-) diff --git a/howto.qmd b/howto.qmd index 8ee7659..3f6ca08 100644 --- a/howto.qmd +++ b/howto.qmd @@ -18,12 +18,13 @@ jupyter lab Then checkout the [notebook](https://github.com/BiocPy/BiocWorkshop2024/tree/master/notebook) directory that contain Jupyter notebooks. -## Option 2: Using Google colab +## Option 2: Using Google Colab -To open the session in Google colab +To open the session in Google Colab: 1. Open [Google colab](https://colab.research.google.com/) in a new tab. -2. On the page, It should open up a dialog to "Open notebook" as shown in the screenshot below. If not, go to file -> Open Notebook from the menu in the top left. +2. On the page, it should open up a dialog to "Open notebook" as shown in the screenshot below. + * If no dialog appears, go to File -> Open Notebook from the menu (in the top left). 3. Choose Github and enter the repository url for the workshop: `https://github.com/BiocPy/BiocWorkshop2024`. This will automatically find the python notebooks available in the repository. ![](./assets/colab_session.png) @@ -33,7 +34,5 @@ To open the session in Google colab ![](./assets/colab_open_notebook.png) :::{.callout-important} -This process does not download the [RDS file](https://github.com/BiocPy/BiocWorkshop2024/tree/master/notebook) available in the repository. Folks might have to manually download this to their colab sessions. -::: - -and thats it! \ No newline at end of file +This process does not download the [RDS file](https://github.com/BiocPy/BiocWorkshop2024/tree/master/notebook) available in the repository. Folks might have to manually download this to their Google Colab sessions. +::: \ No newline at end of file diff --git a/index.qmd b/index.qmd index 4020a8c..178032f 100644 --- a/index.qmd +++ b/index.qmd @@ -2,23 +2,23 @@ ## Welcome -Welcome to our workshop on exploring the data structures and packages +Welcome to our workshop on exploring the data structures and methods available in [BiocPy](https://github.com/biocpy), a project that aims to facilitate Bioconductor workflows in Python. In this workshop, we will focus on interoperability between R and Python, covering two main topics: -- Reading an RDS file containing `GenomicRanges` and performing downstream range-based analyses. -- Annotating single-cell RNA-seq data using the [scrnaseq](https://github.com/biocpy/scrnaseq) package. +- Perform range-based analyses using [GenomicRanges](https://github.com/BiocPy/GenomicRanges). +- Annotate cell types in single-cell RNA-seq data stored as [SingleCellExperiment](https://github.com/BiocPy/SingleCellExperiment) object. Attendees will learn how to represent and manipulate their datasets in Python in the same manner as in R/Bioconductor. All packages in BiocPy are published to PyPI, and the code is open-source on [GitHub](https://github.com/BiocPy). -![](./assets/workshop.png) + -### Core contributors +## Core contributors - [Jayaram Kancherla](https://github.com/jkanche) - [Aaron Lun](https://github.com/LTLA) @@ -32,4 +32,4 @@ We are looking for more contributions from the community to improve our packages ## Developer notes -This is a reproducible Quarto book with reusable snippets. Check out [sessioninfo](./tutorials/sessioninfo.qmd) for packages installed during the build. \ No newline at end of file +This is a reproducible Quarto book with reusable snippets. Check out the [session information](./tutorials/sessioninfo.qmd) for versions of installed packages. \ No newline at end of file diff --git a/notebook/annotate_cell_types.ipynb b/notebook/annotate_cell_types.ipynb index 6155730..5513cb1 100644 --- a/notebook/annotate_cell_types.ipynb +++ b/notebook/annotate_cell_types.ipynb @@ -10,63 +10,39 @@ "\n", "## Outline\n", "\n", - "In this tutorial, you will learn how to:\n", + "In this tutorial, we'll walk through how to:\n", "\n", - "1. Install and set up BiocPy packages in your Python environment.\n", - "2. Explore the `scrnaseq` package and access public single-cell RNA-seq datasets.\n", - "3. Perform basic operations on `SingleCellExperiment` objects, the core data structure for single-cell data.\n", - "4. Annotate cell types using reference datasets from the `celldex` package.\n", + "1. Explore the `scrnaseq` package and access public single-cell RNA-seq datasets.\n", + "2. Perform basic operations on `SingleCellExperiment` objects, the core data structure for single-cell data.\n", + "3. Annotate cell types using reference datasets from the `celldex` package.\n", "\n", "## Prerequisites\n", "\n", "Before we begin, please ensure that you have the following prerequisites installed:\n", "\n", "- Python 3.8 or later with dependencies listed [here](https://github.com/BiocPy/BiocWorkshop2024/blob/master/requirements.txt).\n", - "- R 4.4.0 and Bioconductor packages listed [here](https://github.com/BiocPy/BiocWorkshop2024/blob/master/rpackages.R)." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Installation\n", + "- R 4.4.0 and Bioconductor packages listed [here](https://github.com/BiocPy/BiocWorkshop2024/blob/master/rpackages.R).\n", "\n", - "Let's start by installing the required packages." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "!pip install scrnaseq celldex singler" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "This will install the `scrnaseq`, `celldex`, `singler` packages from PyPI.\n", + "Install the Python packages using pip:\n", + "\n", + "```sh\n", + "pip install scrnaseq celldex singler\n", + "```\n", + "\n", + "Install the R packages using BiocManager:\n", "\n", - "#### R\n", "```r\n", "BiocManager::install(c(\"scRNAseq\", \"celldex\", \"SingleR\"), \n", " repos='http://cran.us.r-project.org')\n", "```\n", "\n", - "This will install the `scRNAseq`, `celldex`, `SingleR`, packages from Bioconductor." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## 1. Accessing and Exploring Single-Cell Datasets\n", + "## 1. Accessing and exploring single-cell datasets\n", "\n", - "Now that we have the necessary packages installed, let's explore the `scrnaseq` package and learn how to access public single-cell RNA-seq datasets. Datasets published to the `scrnaseq` package are decorated with metadata such as the study title, species, number of cells, etc., to facilitate discovery. Let's see how we can list and search for datasets.\n", + "Let's explore the `scrnaseq` package and learn how to access public single-cell RNA-seq datasets. Datasets published to the `scrnaseq` package are decorated with metadata such as the study title, species, number of cells, etc., to facilitate discovery. Let's see how we can list and search for datasets.\n", "\n", - "### 1.1 List All Datasets\n", + "### 1.1 List all datasets\n", "\n", - "The `list_datasets()` function in Python or `surveyDatasets()` in R will display all available datasets published to the `scRNAseq` collection along with their metadata." + "The `list_datasets()` function in Python or `surveyDatasets()` in R will display all available datasets published to the `scRNAseq` collection along with their metadata. To list all available datasets in the `scrnaseq` package and displays their names, titles, and versions:" ] }, { @@ -157,16 +133,11 @@ "head(all_ds[, c(\"name\", \"title\", \"version\")], 3)\n", "```\n", "\n", - "This lists all available datasets in the `scrnaseq` package and displays their names, titles, and versions." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### 1.2 Search for Datasets\n", + "### 1.2 Search for datasets\n", + "\n", + "You can also search for datasets based on metadata using `search_datasets()` in Python or `searchDatasets()` in R. This supports both simple text queries and complex boolean expressions.\n", "\n", - "You can also search for datasets based on metadata using `search_datasets()` in Python or `searchDatasets()` in R. This supports both simple text queries and complex boolean expressions." + "Let's search for datasets containing the term \"pancreas\" and displays their names, titles, and versions." ] }, { @@ -257,9 +228,7 @@ "head(pancreas_ds[, c(\"name\", \"title\", \"version\")], 3)\n", "```\n", "\n", - "This R|Python code searches for datasets containing the term \"pancreas\" and displays their names, titles, and versions.\n", - "\n", - "#### 1.2.1 Advanced Searches\n", + "#### 1.2.1 Advanced searches\n", "\n", "For more complex searches involving boolean operations, use `define_text_query()` in Python or `defineTextQuery()` in R. Here's an example to find datasets using the mouse reference genome (`GRCm38`) and containing the words `neuro` or `pancrea`.\n", "\n", @@ -358,7 +327,6 @@ "metadata": {}, "source": [ "#### R\n", - "\n", "```r\n", "suppressWarnings(library(gypsum))\n", "res <- searchDatasets(\n", @@ -380,7 +348,7 @@ "After identifying a dataset of interest, use `fetch_dataset()` in Python or `fetchDataset()` in R to download the dataset. This will load the dataset as a `SingleCellExperiment` object.\n", "\n", "```{note}\n", - "R/Bioconductor users might already be familiar with the [SingleCellExperiment](https://bioconductor.org/packages/release/bioc/html/SingleCellExperiment.html) class. BiocPy also provides the same implementation in the [singlecellexperiment](https://github.com/BiocPy/SingleCellExperiment) package.\n", + "R/Bioconductor users might already be familiar with the [SingleCellExperiment](https://bioconductor.org/packages/release/bioc/html/SingleCellExperiment.html) class. BiocPy also provides similar implementation in the [singlecellexperiment](https://github.com/BiocPy/SingleCellExperiment) package.\n", "```\n", "\n", "For this tutorial, let's download the `zeisel-brain` dataset:" @@ -430,13 +398,39 @@ "\n", "### 2.1 Side-quest on `SingleCellExperiment` in Python\n", "\n", - "The Python implementation of the `SingleCellExperiment` class adheres to Bioconductor's specification and offers similar interface and methods. Our goal is to make it simple for analysts to switch between R and Python. A key difference is the shift from functional to an object-oriented paradigm.\n", + "The Python implementation of the `SingleCellExperiment` class adheres to Bioconductor's specification and offers similar interface and methods. Our goal is to make it simple for analysts to switch between R and Python.\n", "\n", "```{note}\n", "For more details on the design, refer to the [BiocPy developer guide](https://github.com/BiocPy/developer_guide) or the [singlecellexperiment](https://github.com/BiocPy/SingleCellExperiment) documentation.\n", "```\n", "\n", - "This Python code demonstrates basic operations on a `SingleCellExperiment` object, including retrieving assay names, column names, column metadata, accessing counts, and coercing to an `AnnData` object for interoperability with existing analysis ready eco-systems in Python." + "This Python code demonstrates basic operations on a `SingleCellExperiment` object, including retrieving assay names, column names, column metadata, accessing counts, and coercing to an `AnnData` object for interoperability with existing analysis ready eco-systems in Python.\n", + "\n", + "To display assays names from the object:" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Assays names: ['counts']\n" + ] + } + ], + "source": [ + "print(\"Assays names: \", sce.get_assay_names()) # or sce.assay_names" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To access cell barcodes or ids:" ] }, { @@ -448,9 +442,31 @@ "name": "stdout", "output_type": "stream", "text": [ - "assays: ['counts']\n", - "column names: ['1772071015_C02', '1772071017_G12', '1772071017_A05', '1772071014_B06', '1772067065_H06', '1772071017_E02', '1772067065_B07', '1772067060_B09', '1772071014_E04', '1772071015_D04']\n", - "column metadata: BiocFrame with 3005 rows and 9 columns\n", + "Cell barcodes (first 10): ['1772071015_C02', '1772071017_G12', '1772071017_A05', '1772071014_B06', '1772067065_H06', '1772071017_E02', '1772067065_B07', '1772067060_B09', '1772071014_E04', '1772071015_D04']\n" + ] + } + ], + "source": [ + "print(\"Cell barcodes (first 10): \", sce.get_column_names()[:10]) # or sce.column_names" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To access all cell annotations:" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Column metadata: BiocFrame with 3005 rows and 9 columns\n", " tissue group # total mRNA mol well sex age diameter\n", " \n", "1772071015_C02 sscortex 1.0 21580.0 11.0 1.0 21.0 0.0\n", @@ -468,8 +484,31 @@ " ... ...\n", "1772063068_D01 endothelial-mural Vsmc\n", "1772066098_A12 endothelial-mural Vsmc\n", - "1772058148_F03 endothelial-mural Vsmc\n", - "access counts: <20006 x 3005> sparse ReloadedArray object of type 'uint16'\n", + "1772058148_F03 endothelial-mural Vsmc\n" + ] + } + ], + "source": [ + "print(\"Column metadata: \", sce.get_column_data()) # or sce.column_data" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To access an assay matrix:" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Counts matrix: <20006 x 3005> sparse ReloadedArray object of type 'uint16'\n", "[[ 0, 0, 0, ..., 0, 0, 1],\n", " [ 3, 1, 0, ..., 0, 0, 1],\n", " [ 3, 1, 6, ..., 0, 0, 0],\n", @@ -481,22 +520,14 @@ } ], "source": [ - "print(\"assays: \", sce.get_assay_names()) # or sce.assay_names\n", - "\n", - "print(\"column names: \", sce.get_column_names()[:10]) # or sce.column_names\n", - "\n", - "print(\"column metadata: \", sce.get_column_data()) # or sce.column_data\n", - "\n", - "print(\"access counts: \", sce.assays[\"counts\"]) # or # sce.assay(\"counts\")" + "print(\"Counts matrix: \", sce.assays[\"counts\"]) # or # sce.assay(\"counts\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "```{note}\n", - "The package uses [delayed arrays](https://github.com/biocpy/delayedarray), to load file-backed arrays and matrices. This reduces memory usage when loading large datasets. This package provides similar functionality to the R/Bioconductor's [DelayedArray](https://www.bioconductor.org/packages/release/bioc/html/DelayedArray.html) eco-system. \n", - "```" + "The package uses [delayed arrays](https://github.com/biocpy/delayedarray) (similar to the R/Bioconductor's [DelayedArray](https://www.bioconductor.org/packages/release/bioc/html/DelayedArray.html)), to load file-backed arrays and matrices. This reduces memory usage when loading large datasets. Methods are available to coerce delayed arrays to [sparse matrix representations](https://docs.scipy.org/doc/scipy/reference/sparse.html) from the scipy package:" ] }, { @@ -524,7 +555,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "or realize the entire matrix when loaded from disk," + "To simplify this, we provide the `realize_assays` option to load matrices fully into memory when fetching the dataset." ] }, { @@ -564,7 +595,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "We also provide coercions to various package to take advantage of methods in the Python ecosystem, e.g. scverse and AnnData" + "In addition, we provide coercions from `SingleCellExperiment` class to take advantage of methods in the Python ecosystem, e.g. scverse and AnnData." ] }, { @@ -591,20 +622,16 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## 3. Annotate Cell Types\n", + "## 3. Annotate cell types\n", "\n", - "We can now annotate cell types by using reference datasets and matching cells based on their expression profiles. In this tutorial, we will use [singleR](https://github.com/SingleR-inc/SingleR) in R or its Python equivalent [singler](https://github.com/BiocPy/singler).\n", + "We can now annotate cell types by using reference datasets and matching cells based on their expression profiles. In this tutorial, we will use [SingleR](https://github.com/SingleR-inc/SingleR) in R or its Python equivalent [singler](https://github.com/BiocPy/singler).\n", "\n", "Before running the `singler` algorithm, we need to download an appropriate reference dataset from the `celldex` package.\n", "\n", - "### 3.1 Access Reference Datasets from `celldex`\n", + "### 3.1 Access reference datasets from `celldex`\n", "\n", "Similar to the `scRNAseq` package, the `celldex` package provides access to the collection of reference expression datasets with curated cell type labels, for use in procedures like automated annotation of single-cell data or deconvolution of bulk RNA-seq to reference datasets. These datasets are also stored in language-agnostic representations for use in downstream analyses.\n", "\n", - "```{note}\n", - "The `celldex` package is available on [R/Bioconductor](https://bioconductor.org/packages/devel/data/experiment/html/celldex.html) and [PyPI](https://github.com/BiocPy/celldex).\n", - "```\n", - "\n", "For this tutorial, let's download the [Mouse RNA-seq](https://www.immgen.org/) reference from `celldex` using `fetch_reference()` in Python or `fetchReference()` in R. This reference consists of a collection of mouse bulk RNA-seq data sets downloaded from the gene expression omnibus ([Benayoun et al. 2019](https://doi.org/10.1101/gr.240093.118)). A variety of cell types are available, again mostly from blood but also covering several other tissues." ] }, @@ -649,7 +676,8 @@ "mouse_rnaseq_ref\n", "```\n", "\n", - "Now, let's identify cells from the `zeisel-brain` dataset using the `mouse_rnaseq` reference dataset." + "\n", + "Now, let's annotate cells from the `zeisel-brain` dataset using the `mouse_rnaseq` reference dataset." ] }, { @@ -710,14 +738,16 @@ "table(cell_labels$labels)\n", "```\n", "\n", - "## 4. Analyze Single-cell RNA-seq datasets\n", + "Give this is a brain dataset, the presence of neuron's and other brain-related cell types makes sense.\n", "\n", - "![single-cell-methods](../assets/single-cell-space.jpg)\n", "\n", - "Aaron has implemented the single-cell methods from scran in C++. This allows us to reuse the same implementation in JS and develop applications for analyzing single-cell data ([Kana](https://github.com/kanaverse/kana)), or in Python through the [scranpy](https://github.com/BiocPy/scranpy) package. This avoids different interpretations of the analysis results by switching programming languages (Pachter et al, [The impact of package selection and versioning on single-cell RNA-seq analysis | bioRxiv](https://www.biorxiv.org/content/10.1101/2024.04.04.588111v1) )\n", + "## 4. Analyze single-cell RNA-seq datasets\n", "\n", + "![single-cell-methods](../assets/single-cell-space.jpg)\n", + "\n", + "Aaron has implemented the single-cell methods from scran in C++. This allows us to reuse the same implementation in JS and develop applications for analyzing single-cell data ([Kana](https://github.com/kanaverse/kana)), or in Python through the [scranpy](https://github.com/BiocPy/scranpy) package.\n", "\n", - "To analyze the dataset," + "To analyze the dataset using the default parameters:" ] }, { @@ -740,7 +770,8 @@ "\n", "results = scranpy.analyze_sce(sce)\n", "\n", - "# results is a complex object, lets explore the umap and tsne dimensions\n", + "# results is a complex object, \n", + "# let's explore the umap and tsne dimensions\n", "print(results.tsne)" ] }, @@ -748,20 +779,52 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "### 4.1 Seems like magic?\n", + "### 4.1 Want to know whats happening in the entire analysis\n", "\n", "Running the `analyze_sce()` function uses the default parameters to run the single-cell workflow. If you want to customize or want to have fine-grained control on the analysis steps, set the parameter `dry_run=True`.\n", "\n", "```{note}\n", - "This prints out the exact series of steps the function does under the hood to perform the analysis. You can then use this to customize the analysis to your specific dataset or use case.\n", + "This prints out the exact series of steps the function runs under the hood to perform the analysis. You can then use this to customize the analysis to your specific dataset or use case.\n", "```" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 15, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "import scranpy\n", + "import numpy\n", + "\n", + "results = AnalyzeResults()\n", + "results.rna_quality_control_metrics = scranpy.quality_control.per_cell_rna_qc_metrics(rna_matrix, options=update(options.per_cell_rna_qc_metrics_options, cell_names=options.miscellaneous_options.cell_names))\n", + "results.rna_quality_control_thresholds = scranpy.quality_control.suggest_rna_qc_filters(results.rna_quality_control_metrics, options=update(options.suggest_rna_qc_filters_options, block=options.miscellaneous_options.block))\n", + "results.rna_quality_control_filter = scranpy.quality_control.create_rna_qc_filter(results.rna_quality_control_metrics, results.rna_quality_control_thresholds, options=update(options.create_rna_qc_filter_options, block=options.miscellaneous_options.block))\n", + "discard = numpy.zeros(rna_ptr.shape[1], dtype=bool)\n", + "discard = numpy.logical_or(discard, results.rna_quality_control_filter)\n", + "rna_filtered = scranpy.quality_control.filter_cells(rna_matrix, filter=discard)\n", + "results.quality_control_retained = numpy.logical_not(discard)\n", + "filtered_block = None\n", + "raw_size_factors = results.rna_quality_control_metrics.column('sums')[results.quality_control_retained]\n", + "(rna_normed, final_size_factors) = scranpy.normalization.log_norm_counts(rna_filtered, options=update(options.rna_log_norm_counts_options, size_factors=raw_size_factors, center_size_factors_options=update(options.rna_log_norm_counts_options.center_size_factors_options, block=filtered_block), with_size_factors=True))\n", + "results.rna_size_factors = final_size_factors\n", + "results.gene_variances = scranpy.feature_selection.model_gene_variances(rna_normed, options=update(options.model_gene_variances_options, block=filtered_block, feature_names=options.miscellaneous_options.rna_feature_names))\n", + "results.hvgs = scranpy.feature_selection.choose_hvgs(results.gene_variances.column('residuals'), options=options.choose_hvgs_options)\n", + "results.rna_pca = scranpy.dimensionality_reduction.run_pca(rna_normed, options=update(options.rna_run_pca_options, subset=results.hvgs, block=filtered_block))\n", + "lowdim = results.rna_pca.principal_components\n", + "(get_tsne, get_umap, graph, remaining_threads) = scranpy.run_neighbor_suite(lowdim, build_neighbor_index_options=options.build_neighbor_index_options, find_nearest_neighbors_options=options.find_nearest_neighbors_options, run_umap_options=options.run_umap_options, run_tsne_options=options.run_tsne_options, build_snn_graph_options=options.build_snn_graph_options, num_threads=options.find_nearest_neighbors_options.num_threads)\n", + "results.snn_graph = graph\n", + "results.clusters = results.snn_graph.community_multilevel(resolution=options.miscellaneous_options.snn_graph_multilevel_resolution).membership\n", + "results.rna_markers = scranpy.marker_detection.score_markers(rna_normed, grouping=results.clusters, options=update(options.rna_score_markers_options, block=filtered_block, feature_names=options.miscellaneous_options.rna_feature_names, num_threads=remaining_threads))\n", + "results.tsne = get_tsne()\n", + "results.umap = get_umap()\n" + ] + } + ], "source": [ "print(scranpy.analyze_sce(sce, dry_run=True))" ] @@ -771,7 +834,7 @@ "metadata": {}, "source": [ "```{tip}\n", - "Users can also run individual steps from the analysis without having to perform the full analysis, e.g. compute log normalized counts or find markers, etc.\n", + "Users can also run individual steps from the analysis without having to perform the full analysis, e.g. compute log-normalized counts or find markers.\n", "```\n", "\n", "## 5. Visualize Results\n", @@ -783,7 +846,7 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 16, "metadata": {}, "outputs": [ { @@ -792,13 +855,13 @@ "" ] }, - "execution_count": 15, + "execution_count": 16, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAioAAAGdCAYAAAA8F1jjAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy80BEi2AAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOz9d3Bc95nvCX86526gkXOOBBEYQIIUcwRzULApy5I97313p2TvzLju1r6+b9Wt2qrd8tyarTtz712PZ3bfWfvOeGRblERSIsEcRRJMIMCITOQcO+fu9w9MH7PZAEjJhERJ51OlsnHO6XNOHzTx+/YTvo8kFAqFEBERERERERF5BZF+3TcgIiIiIiIiIjIXolAREREREREReWURhYqIiIiIiIjIK4soVEREREREREReWUShIiIiIiIiIvLKIgoVERERERERkVcWUaiIiIiIiIiIvLKIQkVERERERETklUX+dd/An0owGGRwcBCDwYBEIvm6b0dERERERETkBQiFQthsNlJTU5FK546bfOOFyuDgIBkZGV/3bYiIiIiIiIh8Cfr6+khPT59z/zdeqBgMBmDmjRqNxq/5bkREREREREReBKvVSkZGhrCOz8U3XqiE0z1Go1EUKiIiIiIiIt8wnle2IRbTioiIiIiIiLyyiEJFRERERERE5JVFFCoiIiIiIiIiryzf+BqVFyEUCuH3+wkEAl/3rXxtyGQy5HK52MItIiIiIvKN4lsvVLxeL0NDQzidzq/7Vr52tFotKSkpKJXKr/tWREREREREXohvtVAJBoN0dXUhk8lITU1FqVR+JyMKoVAIr9fL2NgYXV1dFBQUzGuuIyIiIiIi8qrwrRYqXq+XYDBIRkYGWq32676drxWNRoNCoaCnpwev14tarf66b0lEREREROS5fCe+VovRgxnE5yAiIiIi8k1jQVeuX/3qV5SXlwtmbDU1NZw8eVLY73a7ef/994mLi0Ov13Pw4EFGRkYW8pZEREREREREvkEsqFBJT0/nr//6r2loaODOnTts3LiRvXv38ujRIwD+6q/+is8++4zDhw9z+fJlBgcHOXDgwELekoiIyL/h8/mwWq2Mj48zMDDA8PAwVqv1674tERERkQgkoVAo9FVe0Gw28zd/8ze8/vrrJCQk8MEHH/D6668D0NLSQklJCfX19axcufKFzme1WjGZTFgsligLfbfbTVdXFzk5OWJNBuLzEPkjTqeT/v5+rFYr9fX1eL1eYGZ2Vm1tLbGxsej1+q/5LkVERL7NzLd+P81XVrQQCAT4/e9/j8PhoKamhoaGBnw+H5s3bxaOKS4uJjMzk/r6+jnP4/F4sFqtEf8tNDanl/5RG609k/SP2rA5vQt+TYBf/vKXZGdno1arWbFiBbdu3fpKrivy7WdgYIBAIMDly5cFkQJgs9n45JNPmJqawm63f413KCIiIjLDgnf9PHjwgJqaGtxuN3q9niNHjlBaWkpTUxNKpZKYmJiI45OSkhgeHp7zfL/4xS/4X//X/3WB7/qPjE27+G8fNtLYOiZsqypK4KdvVpEQo1mw6/7hD3/gZz/7Gf/wD//AihUr+Lu/+zu2bdtGa2sriYmJC3ZdkW8/DoeD6elpOjo6Zt3v9/vp6urC7/cLUZVQKITD4SAUCiGTyb7zXXQiIiJfHQseUSkqKqKpqYmbN2/y53/+57z77rs8fvz4S5/v5z//ORaLRfivr6/vJd5tJDanN0qkADS2jvHfPmxc0MjKf/7P/5l/9+/+HT/60Y8oLS3lH/7hH9Bqtfw//8//s2DXFPluEAgEUKlUTE5OznnM5OQkg4ODuN1uHA4H9+/f59atW4yOjjI4OMjg4CAWi4WvOHMsIiLyHWTBIypKpZL8/HwAli5dyu3bt/kv/+W/8NZbb+H1epmeno6IqoyMjJCcnDzn+VQqFSqVaqFvGwCL3RMlUsI0to5hsXswaF++y6vX66WhoYGf//znwjapVMrmzZvnTYuJiLwIMpkMn8+HyWTC7XbPekxMTAwOhwOfz8eNGzeIiYlBKpXy2WefkZCQgEwmw+VysX37duLj41EoFFHncLlc+Hw+gsEgk5OT2Gw2UlNT0el0YkRGRETkhfnKDd+CwSAej4elS5eiUCg4f/48Bw8eBKC1tZXe3l5qamq+6tuaFYfL9yft/7KMj48TCARISkqK2J6UlERLS8uCXFPku4NOpyM2NpbKykpOnz4dtV8mk5GVlcXIyAgej4fh4WHMZjMej4c9e/YwMDCAz+cjLS2N4eFhAoEAwWAQq9VKbGwsJpOJqakprl69ytjYGDExMaxcuRKFQsG//uu/kpuby4YNGzAYDF/DuxcREfmmsaBC5ec//zm1tbVkZmZis9n44IMPuHTpEqdPn8ZkMvFnf/Zn/OxnP8NsNmM0GvnpT39KTU3NC3f8LDQ6TfS3xC+yX0TkVSUlJYXh4WFWrVrFrVu38Pv9wIyD8aZNm3j8+DGLFi2iv7+fsrIybDYbRqORI0eOCOdobGwkPT2drKwspqamiIuLY3p6momJCc6ePQvA8uXLSUtLY3BwEIlEwoEDB+jt7eXhw4ekpKSQkJCATqfD7/fjcDhwuVzIZDI0Go3YdSQiIgIssFAZHR3lhz/8IUNDQ5hMJsrLyzl9+jRbtmwB4G//9m+RSqUcPHgQj8fDtm3b+Pu///uFvKUvhEmvoqooYdb0T1VRAib9wqSg4uPjkclkUeZ3z0uLiYi8KBqNhoyMDOLi4igoKMDpdCKRSPB6vUxOTlJaWsrFixdZvXo1AEajkaNHj0adp7+/n8ePHzMwMCD4IJ04cQKA1atXY7Vahdfp9XpGRkZISUlBq9VisVhoaGhgy5YttLa2cv36dUEwxcTEsHv3bhISEr6T87lERET+yIIW0/7TP/0T3d3deDweRkdHOXfunCBSANRqNb/85S+ZnJzE4XDwySefvFILsUGr5KdvVlFVlBCxvaoogf/pzaoFqU+BmbqepUuXcv78eWFbMBjk/Pnzr0xaTOTVxeFwMDY2RnNzM11dXVgsFgKBQNRxcrkco9FIfHw8Go0GiUQiCOTwv8W4uDikUind3d1zXu/Ro0cUFRUJaV2Xy4VWq8VgMPDgwQPUajXbt29n1apVGAwG/H4/SUlJxMXFYbfb6e/v58qVK4JIAZienuYPf/iDaEAnIiLy7R5K+DJIiNHwP/9gGRa7B4fLh06jwKRXLZhICfOzn/2Md999l2XLllFdXc3f/d3f4XA4+NGPfrSg1xX55uLz+bDb7Xz++ee0t7cL2+VyOfv27SM9PR2ZTBbxmrDx240bN7DZbCQkJFBVVYXZbCYhIYH+/n6SkpJwuVxzXtftdgvFtOF5UgUFBbS0tCCTyaitreXy5csRXUa3b99m8+bNrFq1iitXrsx6Xq/XS19fHyaT6Us/kxfB5/PhcDiwWq0Eg0FiY2PRaDQolUpcLhdWq5Xe3l4MBgMpKSno9fqo5xgmGAzicrkIBoMoFArRWFFE5CUgCpUXwKBVLrgweZa33nqLsbEx/uN//I8MDw9TWVnJqVOnogpsRUTCTExM0NHRESFSYMYX5ZNPPuFHP/pRRIed1+vlzp073L59W9jW19dHX18fu3fvFlr/BwcHyc/Pp7W1ddbrpqenMzo6CoDFYiEuLg6lUonb7aagoIC2trZZW6HPnTvHD37wA6anp+d8T8PDw5SVlb3oI/hCBAIB7HY7w8PD3Llzh2XLluHz+RgdHSUzMxOZTEZ7ezuBQICUlBTsdjsDAwPExsaiVqtRqVRotVoCgQBWqxWfzyd0VDmdTjo6OigvLycuLm7WrigREZEXQxyn+wrzk5/8hJ6eHjweDzdv3mTFihVf9y2JvKLY7Xampqa4f//+rPuDwSBdXV0R2xwOR4RIeZqLFy+SlJREamoqjx8/xmw2R5kzwkwEpaqqSvBGGhwcZMeOHWRkZLBu3Tqqqqro6emZ8757enrIy8ubc/9CmhuOjY0xOTnJzZs3WblyJefOneP06dN4PB7a2tqoq6sjFAohl8sZGxtDrVYTCASE2prbt28LvjJWq5Wuri7u3LnDwMAABoOBkpISzp07N69fjYiIyPMRIyoiIt8C3G634G0yF89GLsbHx+c81m63YzAYmJiYIC0tDZvNxsaNG2lubqatrY1AIEBaWhrLly/n7t27uN1uli9fjkaj4fDhw4I/S3p6Otu2beP06dOzWvK7XC4WL15MZ2dn1D6FQkFWVtYLPoEvhtPp5N69e6hUKlasWMGpU6dwu92oVCqSkpLw+/1oNBpaWlrw+/3k5+cTHx9PZ2cnqamplJaW4vP5cLlcSKVSjh49GlFjo1KpeP3119m+fTtPnjyhra2NjIwM4uPjxW4mEZEviChURES+BUilUiHtMjExMesx6enpwv8PBoMv1E0jkUioqqpCoVBw7tw5kpOT2b59O1KpFJPJxOXLl+nr6yMhIQGj0RhRAA4zXUEWi4V169YJ3UBPk5mZydTUFCtWrOD27dsEg0FgpkNo7969C+a14na7BTM6v98vCKu8vDykUin3799nYGBAOH50dJSSkhIUCgWXLl0iGAySm5tLaWkpdXV1ESIFZmaSnTx5kqVLl/L5558DcOvWLWJjYzl48OCC192IiHybEIWKiMi3ALVaTX9/P8uXL+fUqVNR+/V6fUR9Uzi6IZfLoxZZmEm5DA8Po1AouHbtGikpKaxfv56jR4/S3NwsXHP16tWsWLEChUJBXV3drPdms9nwer3o9fqIqEpycjIWi4WLFy+yfv16fvzjH+NwOJDJZOh0OnQ63YK2Jk9PT1NaWorT6RS2ZWdn4/P5IkQKwJo1azh9+nTEHLLx8XFaWlrYtGmT4C8TExNDRkYGoVCI7u7uKKE1NTXF5cuXee2111AoFOj1erH9WkTkOYhCRUTkW4BWq2X16tU8evSITZs2cePGDRwOBzATtdi8eXPEGHWXy0VjYyObN2/m9OnTETN7lEolq1ev5ty5c2g0GlavXs3du3eZmJjg7bff5vbt24yMjGA0GjGZTIJhm8VimfP+LBYLeXl5QrqltLSUzMxMQdy4XC5MJtNXFmkI15vExMQIURyJREJiYiLXr1+PODbstDvbsNRwR1BeXh4FBQX4fD46OzuRSqWsWrUKs9nMoUOHkEgkBINB2tvbaWpqoqSkhAsXLrBz505SUlLm7CISERERhYqIyLeG+Ph4qqqq6OvrY/PmzSgUCnQ6HRqNBp1OF3GsVCpFq9WSkJDA66+/Tnt7O1arlcTERFJSUrh69So2mw2YqbdYuXKlUDC7Zs0a+vr6mJycJBQKUVdXx9KlS1Gr1XPODoqNjcVsNpORkYHf76e1tZWmpiZBIJWUlCzgk4lGq9WydetWzp07x/bt20lJSSEQCDA2Nia0WIfJzMzk4cOHc56ro6ODnTt3cu7cOaH7SavVUlNTw8DAABMTE6SnpzM5OUlcXByHDh3C7XZjt9v56KOPePfdd4mNjV3Q9ysi8k1G7PoREfmWIJVKiYmJoaysjKysLNLT04mPj48SKTBTqCqVSrl06RKDg4NMT0+jVqvp6enhyJEjTExMoFarSU1NpaenB51OR35+Pnl5eZw5c4aYmBhGR0cZGhoSzOUWL148633J5XJ0Oh16vZ6Ojg5OnTpFV1cXoVAIqVTKjh07vpa5P4mJiezcuZP29na2b99OXl4eExMTUV1IoVBo3vRMQkICAwMDgkgB2LNnD2NjY1itVkKhED09PZhMJhQKBdPT0/h8PhYvXkwgEODhw4dCVEdERCQaMaIiIvItQyKRzOvbYbPZOHLkiNA2u2rVKpqamkhPT6ewsJBVq1YRCARwOBzEx8fjcDhob28nISGByclJent7cTqdbN++XUjd9PT0UFpaSn5+Ph0dHcK1VCoVW7du5caNG6xfv56NGzdSXV3N4OAgKpWK5ORkdDrd1+IzIpPJMJvNVFdX4/V6qaioYGpqipGREXJzc3ny5Inw3tauXRvV3h2mvLw8wrQuKSkJiUTCo0ePhELkpqYmGhoagBnhVl5eTlVVFc3NzYyMjOD3+1Eqv1qvJhGRbwqiUBER+Y4xOjoa4e3R2NjI66+/zv3790lOTub8+fMRrcvhyMPExITg3Do+Pk5vb2+ENf/p06dZtmwZ+/fvx2KxCGmny5cvMzIygtPpJCUlBY1GQ0JC5FiKrxO5XI5c/sc/hTdv3iQvL08wufP7/RgMBjIzM+nt7Y14bWxsLEajMeI5VFZW4vV6ycrKIhgMcu3aNSHakpCQQGFhIVKplNHRUVatWoXdbhdmLYnGcCIi0YhCRUTkO8bTniVarZZFixZx584dlixZwunTp6P8VUZHRzl79iyFhYW0trZSWVmJUqmko6OD3NxcGhsbgZmW51u3biGRSNBoNKxfvz7C8CxcKBsIBPB4PEil0lfOYl6n07Ft2zaam5uFCc9xcXHo9XqWLVtGWVkZDx48IBAIUFRURGZmJh6Ph8LCQm7evAnMDHAMhUIkJycTCAQYHR0lPj6ebdu2YbFYaGxsxOl0kpGRQWVlJR6Ph1//+tfU1taSl5cnihURkWcQhcorypUrV/ibv/kbGhoaGBoa4siRI+zbt+/rvi2RbwBOpxO73U5fXx9yuZz09HShsDbc+humvLyciYkJjEYjNpstos7iafr7+1m2bBkDAwMMDAyQkZFBUVERRqOR9vb2iLbjUCiEVqslNjZWECmZmZno9XosFgsPHjygo6MDhUJBVVUVWVlZs9bRfF2ERUlJSQl+v5+hoSEOHz5Mfn4+hYWFbN26lYGBAVpaWrh48SIA+/fvx2AwYLPZcDgcxMbGIpFIGBoaIj4+nq1bt9LU1MSjR4+E60xNTfH48WP27duHWq2mrq6OH//4x7M6AIuIfJcRhcoLEHDZCTgsBD0OpGodMq0JmWZh3SUdDgcVFRX8+Mc/5sCBAwt6LZFvDw6Hg/Pnz0fN+1mzZg0Gg4GMjAyKi4u5ceMGMFNPEQqF+Oyzz9i5c+e85346vdHX10dpaSnXrl1j69at9PT00NHRgUwmo6ysjIKCAkEoFRQUsGbNGtxuNx988EGEe+7JkyfJyclhy5YtX0tB7VxIJBJCoRAfffSR0Hbd0NBAQ0MDBoOB/fv3c/nyZeH4S5cusWfPHmDmOYVCIRQKBbGxsaxcuRKXyxUhUsL4/X7q6+spLy/nxo0b9PT0iEJFROQZRKHyHPzWccaO/z2urnvCNk1uJQk7/xy5MX7BrltbW0ttbe2CnV/k28mzQwmNRiMZGRlMTEyQmJjIhQsX2LhxI5s3b+bcuXPo9Xq6u7tJSkqaN+UgkUiivD46OztZvnw5MpmMJUuWkJ2djdfrRa1W09vbi1wu55133kGj0aBQKDh//vysFv9dXV1MTEy8UkIFZuYWzeYNY7PZuH//PocOHaKnp4f+/n6qqqqor68XCnDlcjkrV64kPz9fiMrMxcDAAEuXLgUQvG9ERET+iChU5iHgskeJFADXkybGTvyKxH1/teCRFRGRF8VutwtDBuVyOZs2bSIYDNLZ2YlEIsHtdlNSUoLb7aa4uJjMzEwmJiaw2WxkZWWhVqupqamhvr4+6tyFhYWzDhccGxsjPj6e3t5ePB4Per2e69evC+22UqmUtWvXzjt9GaC5uZnk5ORXpmYlFArR1tY25/5Hjx5RXV1NRUUFSUlJXL16lezsbMrLywkEAshkMrq7u7Hb7QQCgShvlrnIzMx8WW9BRORbgyhU5iHgsESJlDCuJ00EHBZRqIi8MoRCIZxOJyqVih07dnDz5k0GBweF/Z2dnWRlZbFx40YcDgdHjhyJGFR469YtamtrWb16NdevXxd8TkpKSsjJyYmyyC8sLOTq1avs3buXS5cusXHjRj777LOIY4LBIJcuXSI7O3teLxKJRDKrlf/XhUQiQavVzrlfrVYL70cqlbJs2TKuXLnC2NiY8Pri4mJcLhcGgyGiq+hZMjMzGRoaIikpSTR+ExGZBdHwbR6CnvnDsEGPc979IiJfJUqlkq1bt7Jr1y4sFkuESAnT09PD0NAQjY2NUdOUQ6EQp06dIiMjgz179rB7927eeecddDoddXV1EaZkWVlZpKamcvDgQXw+Hzk5OcIMoNno6+ujuLh4zv05OTkRNTCvAnMZ2AEsWbJEKAAOhUKcO3dOECnhbc3NzfT396NSqRgdHWXJkiVR5wlPb5ZKpezdu/crKSoOBoP4fL6IsQkiIq8yYkRlHqSq+f9oSFVzf+MSEfmq8fv9+P1+wWxsLh49ekR8/Oz1VcFgkKGhIfr6+igrK6O+vp7S0lKWL19OV1cXcrmcqqoq0tPT0etnoonT09Okpqby4MGDOa95//59du3axZMnTyI6hADy8/MB0Gg0X/QtLyhGo5E1a9YI04/DZGZmUlxcLERUvF7vnHOOHj16REVFBYmJibhcLnbu3ElLSwsul4v09HQWLVqEUqkkNTV13qjLy8Dn82G1Wrl//z4TExOkpqZSWlqK0Wh84dRUGK/bisc1wdTIfaRSObHJFajUsciVr073lsi3B1GozINMZ0KTW4nrSVPUPk1uJTKdOKpd5NXA6XTS29tLY2MjRUVF80YnwjUUcxEMBikoKODSpUtYrVba2tpIS0sjOzsbrVZLdnY2arUai8VCd3c3XV1d6PV61qxZw6NHj2YVSUlJSWi1Wg4cOEB7ezvd3d0olUqKioqAmUnKr5ozq1qtpqKigry8PDo6OvB4POTl5RETE4NOp8Pj8TAxMcHIyMic5/D7/TidTrxeL6mpqXi9XtasWYNMJsNgMHxlwwgDgQC9vb0cO3ZMiKT09PRw+/Zt3nzzTVJSUp57jlAoiNc1RTAUoL/lU6wTf6w5Gum+RELGKlLytqBQiulwkZeLKFTmQabRk7Dzzxk78asIsRLu+lnI+hS73R5hRd7V1UVTUxNms1ksuBOJwOPxcOfOHaGQVqVSkZOTE2XcFqawsJCBgYE5z5eQkMCnn34aUTMS9k9Rq9UUFhbidDr5/e9/H9HFc+/ePdatW0dBQUFE51G4hkOtViOTyVi0aBHJycm43W60Wi1xcXGvXMdPGJVKhUqlIi4uLmpff38/dXV1bNmyZc7Xy+VyDAYDqampX6uRm8PhoK6uLird4/f7qaur43vf+968aSe/z8n06EMmBu9iSiiOEClhxvquE5tUjsIsChWRl4soVJ6D3BhP4r6/+jcfFSdSlRaZbuF9VO7cucOGDRuEn3/2s58B8O677/Kb3/xmQa8t8s3C6XQKIiU8v6a4uJjU1FRgpoj20aNHhEIhYmJiiI2NRaPRRHmtwExaQyaTzVnYajabkUgkc7YaX7lyhYMHDwrnjomJYdu2bYIrrUKhwGQyRbnUulwu5HL5N8aV1W63c/78ebxeL36/H5PJNGv6p6KiAqPRuOBpnedhtVrxer2z7puensblcqHT6fB7nfh9DoJBHzK5BqVqxmXXMtZMz6PDpORtZXLw7pzXGe29hs6UhVQmLi0iLw/x0/QCyDT6r7y7Z/369WKxm8gLEY6cyGQydu7cSWtrK7/97W+Frp3i4mJ2797N0NAQ6enpnD59mvz8fA4ePMjVq1cZGRlBrVZTXl5OeXk5oVAIuVw+q1h57bXX8Pv9UTNvwoQ7j3784x8TCATQaDRzflO3WCzY7XZaW1txuVxkZWWRlpZGTEzMvB1CrwIejwebzQbAtWvX2LZtW1TXz6JFi1i+fPnXLlKAF5rO7HFO0P3oMPapTgzmIlLzN+O2DyNX6hnoOAWAVKYkEHDPeY6A30UoFEBcWkReJuKnSUTkG054IVy2bBkPHjyImPIbDAZ5/PgxoVCIpKQkjhw5QmxsLPn5+dy+fZvq6mqMRiMTExM0Nzdjt9tJTk7mjTfe4Pjx48JirFQq2bBhA4mJic81JfP5fM9tsw3Xvjw9dbilpYWYmBgOHDjwyrfpPl18arfbOXnyJMuWLWP16tUEAgFiYmKIiYl5ZepuwgWzswkWjUaDTiOh7c4/4nVPEZtUgSlxEW13/i9CQR8Fy/4HfO5pAJyWPgyx+Uy4bs96nZjEMsSvVyIvG1GoiIh8wzGbzcjlclJTU4XBeM/S0tLC8uXL+cEPfoBUKsVms7FkyRI6OzsjunVCoRC7d+8mNTWVQ4cO4XQ6CQaDaLVaYVaQ3+/HbDZHTGB+mrS0tOfes8vlihApYaanp6mvr2fTpk2oVKoXfAJfPRqNJmKastPpFN6PXC7nvffee2VECswMn1y9enVUBxPAtm3b8LnG8XmsmBIrMWdsweUYw5y2hviUEiRIkcoUBAM+pkcfkl/1Y6ZGHxD0R0ZWFCoThthcrOPNGMwFKMQOIJGXhChURES+4eh0OrZv3z5nDQLMCBCLxYJWq+Xq1at0d3fPetz4+LiQ8tHr9UILst/vJxgMCkMNN2/ezOHDh6PSk2VlZc/1AvH7/XNeH6C1tZWamppXWqio1Wo2b97Mhx9+GNFuLZFI2LVr1ys1ZBFmImKLFy8mMTGRW7dukZqaSkZGBiqVCo1Gg8/ZTdqiH/PwcTcnLv8Ov9/Pwf27mBq5j9c9jTllKeP9NwiFAvS3HSe3/AeM9dVjGW9GIpESl7KEhIzVDHdfRqk2odImiEJF5KUhChURkVeQcFtrMBgUJh/PhVwuJycnh6mpqXnPqdfrkclkQiHrbJhMpoiWWYfDwdjYGE1NTQQCAcrKykhNTSU5OZkf/OAHXL16laGhIbRaLStWrBCs+OdDKpXi8Xjm3B8MBhe0Psvn8+FwOPB6vcKz/SLRj0AggNPpRCaT8b3vfY/x8XE6OzuFlNrznGi/LjQaDdnZ2cTExHDp0iVu3bpFKBRCpVJx4MABTp8+HRElS4g30nLzGgC55T/A4xzDNtmJyz7Ek3v/QlxaNSUr/xKpVM74wB38PidyhYbhrgvoYrII+OOQyV+NkQgi32xevX9NIiLfcWw2G3fu3OH+/ftCmmX9+vWkpqbOGWVQKpUYDAYSExMZHR2N2p+enk5nZycxMTGUl5fT2tqK2x1dFLly5UrBeM3hcHDu3LmINvnu7m4SEhLYv38/iYmJ7Ny5E6/Xi1QqfeEoglQqJScnR+hUepakpCQkEgljY2NoNBohqvMysNvt3LhxgwcPHhAMBpFIJBQVFbF27doXapG22Ww0NjZy7949vF4vKSkprF+/ng0bNnwjOpYcDgfHjh2LaF1XqVSMjY1FiBSFQoHfa4PQTE1L14MPSM3bQmLmGjzOCZTqGNT6JCYG7xKTWMpI9wVUWrMgMCcG76AzZiI2/4i8DEQLfRGRr4lQKITNZmNoaIjW1lZ6e3uZnp7m3Llz3L17V0jBTE5O8sknn0R4n7hcrgih4XQ6GRkZYf369VGeH4mJiVRXV9PY2Mjnn39OIBBg+/bt7Nq1S3ColUqlrFmzJsL4a3R0NEKkhNFqtUxOTmKxWATjsi+a6jCZTGRkZERtl0gkrF27lsOHD/PP//zP/P73v2d4ePiFulaeh9frZWpqioyMDFavXo3JZCIUCtHS0sLZs2dnbbd+Grvdzmeffcbt27eFNNvQ0BC///3vZxWHryIWiyXKXycxMZH+/v6IbYFAAKnsj8IrFPQz0H6SJ/f+hdG+a/Q0f4zHOc5I90UkkpllRIIE2+TM58Xnsb3ynVsi3xxEvSsi8jXgcrkYGxujoaEBp9NJSkoKubm5XLhwgSVLljA4OBgV8aivr8dsNtPT08PDhw+RSqVUVFSQnp5Oc3MzV69eJSEhgc2bN+NyuXA6neh0OiwWC3V1dXg8HjweD1arlePHj6PRaNi7dy+hUAitVovBYBCiAn6/n6ampojrGwwGtmzZQk9PD1evXsVsNpOdnU1aWhpGo/ELvX+j0cj27dt5/PgxTU1NgqV8TU0NDQ0NQreRxWLhD3/4A++++y4xMTFf+DkHAgFsNhsOh0NIUYVCIbq7u3nttdfo6uri8ePHdHV14XK55rTxD4VCTE9PMzQ0NOu+CxcucPDgwXkHGb4KzGYC6PP5oqJWwWCQQEiBQmXC5/mjP0woFMDrmkSlTcDrnsIUX4Jt6gkAKl0CbseMYDOY88W0j8hLQxQqIiJfMR6Ph8bGRurr64Vtw8PDPHr0iJ07d9LY2EhlZSU3btyIeN2KFSs4cuRIRIh+cHCQ119/XTiXzWZjenqas2fPolQq8Xq9UdGIcA2Ky+Xi6NGjvPPOO1FCIxQKRdjwSyQStmzZwsWLF1m2bBlJSUmMjIxgtVrR6XRIJJIv7C5rNBqprq6mrKyMQCBAT08Pn376aVRkw+/309bWRnV19Rc6v8Vi4fHjx3R2dqJUKikuLsbtdtPU1CRMet64cSPDw8NMTk7icDgwm83C64PBIFarlampKZRKZUTb97OMjo7i8Xi+dqESDPrxe2eKe2UyDTJFZKpwtt9Rf38/VVVVUcL00pVbbFr7Nh2N/0Qw8MeaIplcQ0bRboa6LpFRtIu2O/9IfPpKpkbuASGkcjVxqUuRSL+a8QAi335EoSIi8hXjcDgiREoYr9fLrVu3SE9PJzk5OWJfWlqasKA+jUQiwe12C6LC7XajUqmQyWRRERmZTMaKFSvQaDTs2rULm83G/fv3mZycjBIqCoWCsrIyenp6AMjLy6Ozs5N169Zx/fr1iFSHVCplx44d5OXlfeEiUqlUil6vx2azceXKlTmLbAcHB+edUeTz+XA6nQwNDeH1eklLS+PDDz/E6fzjhPO+vj4KCgpYtGgRd+7cYfHixdy8eZPKykouXrwYVQQ8OjrKo0ePkMvlDA8Pk5ubO+f7kMvlX5tBYygUxOOaJuh34XVbkEilOKZ7cdtHSc7bhEobj+zf0jhxcXGo1eqIz0YgEKCrq4vVq1dz7do1YXtnZxdJSUlUrvifsE934bIPo9Eno9ElEQj4SM3dxED7STKK9hDwu+hvO44uJpvMkgOoNOao+xQR+bKIQkVE5Cvm2XqApxkYGGDp0qVRrrDZ2dm0tLREHR92n32aO3fusGXLFk6fPi0IGLVaLUzuPXz4MIFAgLi4OGpqauZcYNPS0oiPj2d8fJzMzEwmJiZob2+PqscIBoPU1dXx3nvvRRm1ud1uHA4HbrcbhUKBUqlEo9FEFQXL5XJMJtOctR4JCQnzipQnT55QV1dHMBhk0aJF9PX1RYiUMO3t7RQXF3Pr1i0qKytpaGhAr9cTHx8fEQ2x2+2cOHGCDRs2cOTIEbRaLevWrZv1+gBFRUVfS01GMBjA4xyn68EHuGyDwnZDXCGJGatou/MPFC77H1HrEpBKZ+YOvf7663z88ccRkaupqSmqq6uFOU1ut3tmAKNJT8vNv8FgLsAYV4xGl4JCbUIWCuB3TxOftpxQKIg+JofSVf8zCqVOnKAs8tIRhcoryC9+8Qs++eQTWlpa0Gg0rFq1iv/0n/6TMGlW5JvNi3zzfnbRm6/l1+fzodFohIVncHAQuVzOnj17GB0dxeFwUFpayunTp5mYmBBeNzExQV1dHa+//vqs5zUYDBw4cIDW1lYUCgVZWVnU1dXNemwwGKS/vz9CqNhsNs6fP09nZ6ewLS0tjfXr16NWq5mYmMDpdJKUlITRaGT16tUcOXIk6txSqZSSkpI537/NZuP48ePCz1lZWZw+fXrO43t6ekhNTUWpVLJ9+3YMBgO7du2KaFEOzx4KT0Z2Op0EAgHWr1/PpUuXIs4XFxdHcXHxV9KS7PF4cDqdDA8PA5CZnkD3g9/itg9HHGebaEMmU2FOrmKk+zKp+dtQaWKRSCQkJibyzjvvMD09jdPpxGw2o9PpBKH2dDG2z2NDoTJhGXuMZeyxsF2tSyI+vRp9bC4KlRGl6ovVKImIfBFEofIC2D0OLB4bTp8LrUKDSWVAr1q4bw2XL1/m/fffZ/ny5fj9fv7Df/gPbN26lcePH79yRlIiX5z09PQ596WkpKBQKDCbzWzduhWbzUZGRgZxcXH4fL5Z3VwbGhqora3l2LFjQgSlt7eXwcFB3nzzTcE35GmR8jThQYKz1VcYDAaWLl2K1WrFZrPNOawQiLDW93g8XLp0KUKkwEzE6MKFCxQUFES8l+zsbDZv3szq1aupr68X6mrCkaD5inVbW6Mn+c5HKBSipKSEiYkJ6uvrcblcwkyklStXEgwGkUqlxMXFRdT3tLW1YTKZ2L9/PwMDA7jdbqFLaraC1JeNy+Xi3r17QnpGIpFw6M3aKJESZnr0IXmV79Lz+DCJma+h0sQKrzMYDC9UU6RQGUjN30bX/X+N2O52jDDUeZaSmr8SRYrIgiMKlecw7pzkH279lvsjzcK2iqQS/ofqHxCvXZg87KlTpyJ+/s1vfkNiYiINDQ2sXbt2Qa4p8tWh0+lYtmwZd+7cidgul8tZu3YtcXFxaDQaFi9eHLG/uLiYBw8eRBm7SaVSQqEQe/fupb+/n6mpKeLj40lJSaGxsZHY2Nh5XWtHR0fx+Xxz7pdIJOj1eoLB4LzW+U8LMKfTSVtbW9QxUqmUoaEhVqxYEbG9u7ubxsZGNBoNe/bswev1IpPJ0Gg0xMXFzRutmJ6ejvi5t7eX/Pz8OQVMUVERExMTXLx4UdgWnok0OTlJSUkJt2/fZuXKlSQkJAhFzXfv3mXTpk1MTEwwNTWFz+fDarWyfPlywftlIZmYmIioIVEqlQR8881dChEKBZDJ1P82KPDLYTQXkF64i4GO04SCM58TlTae3Ip3UKpf7ZlMIt8ORKEyD3aPI0qkANwbaeYfb/2Wv6j5swWNrIQJj49/uiNB5JuLWq1m+fLlZGVlcevWLZxOJ+np6VRVVRETE4NMJhNaavv6+lAoFGRkZKDX6zl48CDNzc20t7cjlUopKytDqVRy/PhxfD4faWlpxMbGotfrkcvllJeX4/P5hBTGbCgUiqg6F5j5Bm+z2ejo6EAikVBSUkJtbS0NDQ10dHRERFeSkpKE9mGv1xtRrJmenk5lZSU6nQ673Y5CoUCr1WI0GrFarcJxDx48YNOmTRw9ehSZTCY41L711lvzdtPk5OTw+PEf0xItLS3s3buX3t7eqA6i/Px8tFotJ06cmPVcw8PDLF++HLfbzblz59i3bx/79u0D/s1bRCplcHCQjIwMMjMz0Wq1c7Y0v0zChdbPbpMp54mKSKRIJDISMlYhlX35VmG5UkdCxipikhbj9zqQSOXIlToxkiLylSEKlXmweGxRIiXMvZFmLB7bgguVYDDIX/7lX7J69WrKysoW9FoiXx1arZbs7GxSUlIIBAIolUohamC1Wrly5UpURGDDhg2UlpZSUlKCVCrF7XZjNBq5ePGiEBEZGBhgYGCAx48f873vfY/79+/z8OFD9u/fj0QimbU+pqKiIkoIOJ1Orl+/zr179ygqKqKkpIRr164xOTlJfHw8e/fu5d69e3R3d7N48WIhTTk8PCxY08fGxgr1KLdu3YpIA5nNZrZs2cKZM2cEz5RwFAWIaI1ubGwkOTl51qiKw+EgJiYGvV4vzNzx+/1cuHCB2tpaBgYGePLkCUqlkiVLlpCUlITf75/X3G1qagqDwYDf70ehUHDlyhVB6MlkMiorK8nOzsZoNM5Z4Puy8fv9ETOFYCaFNTw6jdaYgdPaF/Uac3IlLvsIpvjiP3nujlSmQKUxi908Il8LolCZB6dvfqfK5+1/Gbz//vs8fPiQq1evLvi1RF4uDocDj8eDVCqdtdMFiNoWbhWdLW1x8eJF0tLSSEpKorS0FKvVisPhYN++fdy5c4fHjx8TCARITU1l+fLlNDc3CzVN4WjF+fPnI8RKamoqS5YsiVpwR0dHuXfvHmlpaWRmZnL06NGIfc3Nzezdu5eNGzcC8Pnnn9PS0kIoFEImk7F48WL27t1LU1MTPp9PECkxMTFUVFRgNBoFh9wjR47g9/uJjY2NWoxhpt4l7OI7OjpKX18fJpOJrKwsHj9+zOPHj9m2bRsNDQ0Rww7dbjdyuZy8vDxCoRApKSkYDAamp6eRSqVzut1qtVrcbjfr16/n1KlTgpAK/34aGhrQ6XQsXbp01tcvBCqVivT0dMbGxiK2X712mwP7apENX8Q22f5vWyXEplSSlL0eiUSKTK5GoVrY+hkRkYVEFCrzoFXMH9J93v4/lZ/85CccP36cK1euzFuAKfJq4fV6GRoa4vz580I9SW5uLhs2bHiuu6rVauXu3btz7n/w4AGJiYkRk40BNm7cyMqVKwmFQkgkEkZHR0lNTSU2NpZbt27R0dFBKBRi3759jI2N4Xa7ycrKIiEhIapA2+v1CvUzVVVVnD17Nuo+QqEQp0+f5u233+b8+fMRZmiBQEAYYrho0SIOHz4MQEFBAYWFhdy4cYOJiQmkUin5+fns3buXkydPUl1dPev8n0WLFuF0Ovnwww8jUkVSqZQtW7YQGxvL8ePHWbRoEeXl5YRCIfx+P16vN6Kmo6ysDI/Hg0wmo6ioiObm6GipSqUSun/C4mg2bt26RVFR0Rd25P2yyGQyqqqqePDgQUTKzePxcOyzc7zz9hsQckIwiEyhQSZTEZJIUSi0SMWBOyLfcMRP8DyYVAYqkkq4N0v6pyKpBJPqizlxviihUIif/vSnHDlyhEuXLpGTk7Mg1xFZGMbHx/noo4/Izs5m5cqVyOVyvF4vly9fZsOGDfMubj6fD7fbTXFxMTk5OUgkEnp7e2lpaRHC/8FgEJlMhs/nEwYCajQajEYjoVCIqakpmpub6ezsJD8/n9raWk6fPk1nZyednZ2YzWZycnKIiYmZNZ0SCAQE4zWJRDKnCZvL5cLj8czp2Pro0SMqKioIBALo9XqKi4v57LPPhP3BYJC2tjZGRkY4cOAAzc3NUYW6JpOJtLQ0Lly4ECFSwq8/d+4cu3bt4tixY9y9ezdC5O3evVv4/3l5ebjdbs6fP8/AwAC7d+9mcnIyonZHpVKxfft26uvr0ev1UUW6T+N2u+ftgFoIjEYj3/ve9zhz5ozgN5OYmMjWrVvR6GKRyeK/0vsREfmqEIXKPOhVOv6H6h/wj7d+GyFWKpJK+B+r31mw+pT333+fDz74gGPHjmEwGATPBJPJ9JUU7ol8edxuN59//jnbtm1jcnKSCxcuCNbqVVVVOByOeYVKIBBg//79tLW1cf78eQKBAHl5eezdu5eLFy+SnZ0NzAwqvHXrFn19fWi1Wqqrq0lISMDv9/O73/1O6PKxWq2o1WrefvttJiYmsFqtxMXFMTY2xq9//WsKCgpYv359RHRGpVKRm5srfO7mQi6XR7QkP0swGMTv97N79250Oh1DQ0OoVKoo4WOxWLDZbMLz6ejoQCaTsWjRIpYuXUogEODJkydzPi+73R5RowJEFAerVCqqq6v5/e9/L9S+HD9+nNdee42VK1dis9mEMQD19fWMjo6i1WrnLV5XKpUEg0EuX75MMBiksLCQ2NjYBbXQl8lkJCUlcfDgQaFYWa1Wf+22/SIiC40oVJ5DvNbMX9T82Vfqo/KrX/0KgPXr10ds//Wvf8177723YNcV+dPx+Xy89tpreL1e1Go1ZrOZO3fuCK2lPp+PhISEWSMZHo8HhUJBd3c3Wq2W119/HY/HQ2trK6dPn6a2thaj0cj4+Di/+93vhEXXarXy6aefsmjRIjIzMwWRUlBQQG5uLidPnmTlypU8efIEm82GXC6nqKiIVatW0drayrVr19i4caMwkFAqlVJaWkpjYyOhUEiYGfQscrn8uYukRCKhoaGBwcFBVq5cyfe+9z3sdjt+v18Yruj3++nq6iI/P5+tW7cKLfharRapVMrY2Ni8Jnlh19unycvLo7u7G4VCwbZt27hx40ZEga7X6+XChQvI5XK2b9/OkydPyM/Pp6KiAp/PR0pKCiqVKsJI72nKy8u5evWqUHtz9+5d8vPz2bx584J7HWm1WlGciHynEIXKC6BX6b6SNuQwX9fMkG87oVAIu92O2+1GKpWiVqvnXFTC39QdDgcSiQSdToder5+1jTeMy+WipaWF69evC2kBvV7Pxo0buX37NkNDQ9y9e5fFixdH1aqEh+U9XVMBsGTJEjIzMykqKmJkZIS4uDhOnDgRseiGCadadu/eLaSD/vCHPyCRSASBs2vXLgCam5txOp1UVVURGxuL0+nEZDIJ5zKZTHz/+9+nubmZNWvWcP78+ajrbdy4EZ/PN6e3SmZmJtPT06Snp7Nt2zbcbjeTk5PIZDKsVqsQbTlz5gwJCQnATKu0QqGIMKgLdzc9m/oJk5CQELHPYDCwevVqJicnyc7ORqFQCDOLnsXv99PZ2YnX6+XYsWNotVoUCgUmk4kzZ85w4MABPvvss4jzl5aWEh8fH+WD09HRQWFh4bwuuiIiIl8cUaiIfCfw+Xz09/dz9uxZoUDSbDZTW1tLYmJihABxu920t7dz8eJFAoEAGzduJC4ujubmZux2OyUlJcTExER9qx0YGIhyjrXb7dTV1bF7926hu8XpdEYJlfHxca5du4ZUKiU3NxeTyYTD4eD+/fskJSVx7tw5tm7disfjmTcl09XVRXt7O4mJifj9fkKhEGq1GqfTyd69e+nu7ub69evC8R0dHcL8l2eJjY1l2bJluFwuDh06xO3bt5mcnCQuLo7S0lJaWlro6+tj+/btnD9/PqKmIzExkWXLlnHixAl27NjBzZs3aW5uFkR4XFwc69ev5+7du0KB78jICBKJBJfLhUKhQK1Wc+TIEZRKJStXruTMmTNR95ibm0tsbCyVlZXYbDYKCgpITU3F6/Xy6aefArB161ZUKtWcLckqlUqYCxT+32AwKETBdu3aRSAQwGazYTQaGRsbm9Oiv6GhgezsbDFFKyLyEhGFish3gsnJST755JOobX/4wx949913I4TD2NgYly9fZsmSJRQXF+P1ehkcHCQYDJKTk8P169dRq9Vs2LBBiMg4nU7q6+uJj4/H7/cLi3ZsbCyJiYm43W5SU1MZHBzkWXw+H7dv3yYrK4ulS5fS3t7O0NAQJpOJXbt2MTo6Sm5uLvfu3ZvVmThsnuZ0OgWXWpPJJAiWpKQkkpKSkEqlxMfHs3v3bqxWK01NTUJ9SH19PVu3bo1KoYRCIZxOJ3a7XehyuX//PidOnBC8W06fPk1NTQ0mkwmPx4NcLmd6epoTJ06QmZlJX19fhCEbzLisnjlzhtdeew2bzYZer+fixYsMDAwIx6SkpLBlyxY+/fRThoaGqK2t5fbt24yPj6NWqykrK6OoqAiz2cz69euFjidAqDuJi4vDZDKxePHiKMO0MNnZ2Tx48ED4+em0XHd3N6+99hpHjx7F4/FQXl7O6OjonFFPr9c7Z9uziIjIl0MUKiLferxeL/X19bPuW7x4MU6nE4vFItQkDAwMsGvXLhobG5mamqK4uJiEhATUajXt7e2UlZXR1NTE8PAweXl5wIzYqKmpYXR0FKVSKaQyJiYmGBgYYHBwkNWrV+Pz+dDpdELXhkajQaFQUFlZCcDRo0eFhW5wcJDm5ma2b99OcXExzc3N+P1+3n77bVwuF6Ojo4IfyeTkJEajkbS0NNrb25HJZOzYsYOhoSEhbXHmzBkhGhMfH8/atWu5d+8evb29tLW1sWbNmgihYrVaaWho4MGDB/h8PlasWEF3dzcPHz6MeIZ2u53z589TVVVFWVkZ//Iv/yK8h6KiojmjD+HIltvtpqenJ0KkAAwNDXH9+nX27dvH4cOH6evro7y8HKPRiFqtpre3l87OTkEcKhQKwQ9Gr9eza9cuxsbG+PTTT3nzzTfp7u6OmM4cFjgymYzq6moePnyIzWajvLw8yscmHGkZGRkhKysr6l7DZGZmzpqW83q9OJ1OJiYmkEgkxMXFCWkmERGR+RGFisi3Hq/XG7FAhdm6dSv9/f387ne/E7bpdDr27t0rCI+uri5OnjwpRA+ys7NJT09n+fLl3Llzh/T0dMEJNdyZIpfL2bt3L2fPnhVEglarpby8HJfLJRiGJSQkcPfuXSorK/H5fFy6dGnWb+Pnz5/n+9//PgkJCUgkEtrb24X7qKuri6ifUCqV7N69G61Wy+HDh3G5XBw4cIAPP/wwoiB2fHycEydOsG/fPgYHB/H7/RHXttvtfPLJJxGDDK1W66wzgbRaLdu3b6e1tZWpqamo9zDfHCGr1UpaWhqXL1+edf/AwADBYJDVq1fz+eefC6m1xYsX43K5qKys5Pr16/T395OZmUlZWRlGoxGJRIJarUahUFBSUiJ0Fcnlcnp6esjPz8fn83H58mUsFgvx8fGsWbNGuF+Xy0VNTQ1yuTzCDG9wcJBVq1ZFdRnBTAopPz+fxsZGysrKhHEI4WGC169fFyIxMpmMLVu2kJ+fP6sRoIiIyB8RhYrItx65XI7BYIgw78rIyMBisUSlJBwOBx999BFvvvkmvb29EfUcMJMKsNlsbNu2TbCkb25ujmifLS4u5uHDh4KAUCgUvPHGGxw7diyijkMqlbJt2zZu3rzJ8uXL5zQX8/l8TE5O8uTJE6RSKS6XC6/XK9S7PE1YlHV2duJyucjKyqKnp2fWrp1gMMijR48oKipicnIyYsEcHR2NmrY8MjJCeXk5HR0dEds3btzI+fPnsVgsZGZmRnTKhEIhFArFnGLFZDLN2rL8NC6Xi5iYmIjzFBQUADPCLCkpiampKW7evMn9+/f5/ve/T0dHB42NjbjdbjIyMtBoNLS1tdHb2yt4tjxtLjc8PExdXR2bN28WztfZ2YnRaCQvL4/k5GSGh4dRq9WoVCr27t3L3bt3aWtrIxQKkZubS0VFBZcuXcJms5GVlUUoFCI+Pp6xsTF8Ph979+4lEAggkUhoaWnh1KlTvPPOOyQmJs753r8sYS8ciUQi1suIfOOZu4XhJfCLX/yC5cuXYzAYSExMZN++fVEhVbfbzfvvv09cXJwwdG2+AWoiIl8UtVpNTU1NxLbS0lLu378fdWx4jo1EIpmzpmFiYgKfz0dRURE+ny+q+yM7O5v29nbh57Vr13Lt2rUoA7FgMMjZs2dZtGjRc+saQqEQra2teL1eOjo6OHr0KHfv3qW2tjbqWLPZLNTCmM3meYtvh4eHiYuLY8OGDREL2myTjycnJ9Hr9RHdQWazGbvdLgzOvH//fsSzbm1tpby8fNZrG41G4uPj5527AzNCr7+/n6SkJGBmsODY2BiffPIJV69eRS6XU1ZWhlqtZtWqVZw+fZorV65gs9nw+Xw8efKEDz/8kPLycqEotqGhYdZrXb16lWAwSExMDNu2baOqqgqPx8PGjRvRaDSUlZXR2trK48ePkUgkbNu2jR07dqDVavn000+ZmJgQTPhu3bqF3W5HIpEwNDTE0aNH+eyzz6irq8NgMLBhwwbu3r07a6roT8FisdDR0cHp06c5ffo0HR0dwu9HROSbyIJGVC5fvsz7778vDCz7D//hP7B161YeP34sFCH+1V/9FSdOnODw4cOYTCZ+8pOfcODAgag2TRGRP4WkpCS2bdsGzCx8MTExJCQk0NvbKxyj0+nYsmULly9fZuPGjRETgJ9lcnJSqE95NqohkUgihEdKSgoXLlyY9Txht9mwN8az54KZiJBcLicQCNDe3k5WVhYtLS3CFN+0tLSImomnr+12u+f19dDr9eTl5UWZ0D3d0ZSVlcWyZcuE+Th79uyhqamJ5uZmkpOT6ev740C8gYEB4uPjhSnLnZ2d1NbWUlFRwYMHD4R7S0xMpLa2lvPnz5OSkkJ+fn5UpAZmRN/AwAByuZz4+HhKSkoIBoPC8+zt7SU1NZWUlBR27txJIBCYtX4kEAhw/fp1duzYgcvlmlMYut1uvF4voVCITz75RDC0Ky4u5o033sDv93P06FHWrFnD6dOnoyJyMPNZGxsbY3BwEI/Hw7lz5yLat/1+Pw0NDaxYsQKNRoPf739pww2np6c5efJkRNF2Z2cnmZmZbNmy5bkjHEREXkUWVKicOnUq4uff/OY3JCYm0tDQwNq1a7FYLPzTP/0TH3zwgTDc7Ne//jUlJSXcuHGDlStXLuTtiXyHCIVCeDwebt26hdPpRKPRUFFRQWFhIefOnSMrK4vNmzfj8/nYsGEDDocDmUw257ddo9GIwWDA5XKRkpISsTCMj4+TkpLC0NAQMCMcnmdY5vV6hcXvWVauXCkUsPr9fmEWDcDjx49ZtmxZxOLs9XrR6XQ4HA46OzvZvn37rBESgOrqasxmM06nk/Hxcfr6+tBoNJSWljI1NUV2djaJiYn09PTgcrlITk7G5XKxdOlSVq5ciUwm4/PPP48457179+jq6mLx4sXU1NSgUqnQ6XQcOnRIKHqdmJigt7eXrKws7t27x65du4T6mzB5eXksXryY48eP89ZbbzExMcH169ej/FSamppISkri8ePH86Y5ent7Wb58+XPN0pRKJefPn0cikZCXlyeMMmhqaqKyslIQk3FxcVHpMUD4PYaHLM7mMRO+73379r20glq/309fX9+snWW9vb0MDAygUChQqVSzGg6KiLyqfKWf1nD4MWxN3dDQgM/nY/PmzcIxxcXFZGZmUl9fP6tQ8Xg8EfnsuUygRETC+Hw+7t69y82bN4VtLpeLGzdusHjxYvbt24fBYODmzZuUlJRw7Ngx8vLyKC4u5tGjR1Hn02g0wjdTjUbDunXrIgpy79+/L7TVBoNBpFJpVI3M0yQkJAgLyPe+9z3u3LnD+Pi40FY7MDAgOKDm5OTQ2NgovNbr9UYtdJOTk6xbt466ujq8Xi99fX2sWrWK+vr6CMG0fPlyUlJSsNvtnDp1KsIUzWw2s3XrVqxWK7/73e8iXpeYmMjq1auJi4tDp9NRWVkZ9ZysVivXrl2jpqaG7u5uhoaGGBwcZN26dRw+fFhY7DMzM9m2bRsymYy1a9eyePFifD4fMpmMvr4+jh8/TmVlJS6XK+qLTxi3241MJptzQnUYuVwuPOe56mLMZjNTU1NotVq2bdtGV1cX9fX1wvRimUxGdnY2ly9fpra2ltbWVtra2vD7/SQkJLBu3ToeP36MzWZj3bp186axPR4PSqVyXhPBL4LT6Zw1nRnm4cOHxMfHc+PGDVasWBExNkFE5FVmQWtUniYYDPKXf/mXrF69mrKyMmAmP65UKqPCkUlJSXPm1X/xi19gMpmE/zIyMhb61kW+4Tgcjqg6kjADAwMolUo++OADbDYbT548wev10traSl5eHllZWRHH63Q6du7cGbEgxsfH88YbbwgC3Ol0Mjw8zNtvv01ubi6dnZ2sXr161utnZmYSExPD/fv3uXDhArdu3aKmpoZ169ZhNps5f/68IEzi4+NRq9XCRGaYScuEv7ErlUph5o/RaGTv3r0kJSXR1NQkmLZt376djRs38t5777FixQpUKhUPHz4URMqiRYvYv38/ixYtQqlUcvLkyaho0OjoKO3t7YyPjwMzaaIlS5ZEvbe0tDTMZrMQWQrXhzyd3rJarQSDQSwWC8eOHROGKt69exebzUZtbS0JCQnzFtuGPWIKCwvnHeBZUlJCZ2cnN27cYPv27VECQalUCkMJN2/ezMWLF1EqlWzdupVly5aRlZXF1NSU4GUTFqLbt29n9+7drFq1iuHhYR4/fkxVVRVOp3PetJtcLn/pHT/z1buE9zU1NXH27Nnn1gaJiLwqfGURlffff5+HDx9y9erVP+k8P//5z/nZz34m/Gy1Wr91YuVXv/oVv/rVr+ju7gZmFo//+B//46yFkyLPx+12z/kHvLKykjNnzhAIBCIKT4PBIHV1dVRXV1NVVYXNZkOr1aLT6Th9+jT79+8XFiGlUklmZiZvvvlmxDRjpVLJxo0bmZ6eRqfTsWPHDm7cuMHk5CRKpZKKigrKyso4evSoID7sdjtPnjxh+/btGAwz07kNBgPFxcWkpaVFRBXkcjlLlixhenqa3bt3C+/xzp07VFZWYrFY2LRpEzKZjGAwSGdnJ83NM8M1ExISCAaDqFQqYeLwkiVLUCgUHDlyhLy8PBQKxZwpq5aWFoqLi4GZLxwSiYQ333xTsKPPyMjA7XZHpLJKS0sjvoCsWrWKrKwsHj16RHFxMYmJiZw6dQqTyURiYiI+n48zZ87g8Xh47733iImJmXWi8fLlyzl9+jQ2m40NGzawatWqqG6tmJgYCgoKOHbsGIFAALfbzYEDBxgYGGBiYoLk5GTi4uKwWq3ExsYyOTnJypUrmZycJBAIIJVKcTgcxMbGEgqFeP3112lvb6enp4dHjx5RVVWFTCZDLpfzxhtvoFAo+OCDD9i5c+ectUeLFy9+qXOBtFothYWFjI2Nzbo/NzdXqLl58uSJkAIVEXnV+UqEyk9+8hOOHz/OlStXSE9PF7YnJyfj9XqZnp6OiKqMjIyQnJw867nCYduvEp/djm/aQsDpQKbVoYgxoVjAsGl6ejp//dd/TUFBAaFQiP/+3/87e/fupbGxkUWLFi3Ydb+tzJeP1+v1wuL3bOGp3+/n+vXrgidHQkKC0Lo6W7uvTqeLWni0Wq1QnBkbG8uePXuEFlWZTMZvf/vbWVt3L168yBtvvEFaWppgCnf79m3htTk5OaxZs4b79+/z8OFDli1bRnJyMsFgkK1bt2Kz2Thz5kxEuutpRkZGaGhoYO/evbhcLpRKJWlpadTV1bFt2zYUCsWs3jNPPxu5XI7H4xGGDmZlZVFeXs7169e5ePFixDd2s9lMamqqULwcdqSVyWSYzWZu3bqFQqFg/fr1OBwOPv/88wiRNDU1xaZNm3j48CHt7e0Eg0HMZjMrV66ko6NDSKtdvHiRvXv3cuDAAdrb2/F4POTm5pKYmMjJkycFMdfT00NPTw/bt2+nrKyMzz77jOHhYVJTU1m2bBn9/f1oNBri4uIifHRgJj29atUqHA4H6enpaDQajEYjXV1dWCwWnE4nJSUlJCQkcP36dbZt28a5c+ciUn95eXlUV1e/1FqR8LDJ+/fvR6UZY2JiyM7OjhjxMD09TVxc3Eu7vojIQrGgQiUUCvHTn/6UI0eOcOnSpaiw7NKlS1EoFJw/f56DBw8CM+2Mvb29Ue2kXxee8XHa/9vfY2m6J2yLqaok/yd/jio+fkGuuXv37oif//f//X/nV7/6FTdu3BCFypcgvODMVvj4dPh/rsLTUCiEy+WiuLiY+vp6ZDLZC4tlhUKB3+/H4/Fw4cIFocYqEAiwe/fuOf1FwseYzWbUajUwU6S5bNkyQqGQINjz8vLIzs7mzp07gvtuTEyMMHxwLpRKJX6/nydPnpCSkkJMTAytra2sW7eO5uZmRkdH2bRp05yvj4+PR6fTCX4dZrMZpVIpiGmNRkNnZ6cwibmwsBCPx0NiYiJ6vR6j0UhCQgLHjx+PiJK0t7cLQiDc+adWq/H5fJw4cYKysjLeeecdnE4nY2NjQoTqaS5fvkxlZSUOhwOFQoFWq6Wuro7S0tKoaENDQwNKpVKI9AwODqJSqcjMzEQmk3HkyJGoDqGWlhaSkpLwer1YrVZWr17Nw4cPGRwcFApZW1pa2Lt3L5999hkXL14Uioq9Xi9JSUno9foFiWbExsbyxhtvcO/ePdra2pBIJBQWFlJUVMTo6GhEh5YYTRH5prCgQuX999/ngw8+4NixYxgMBuGPgclkQqPRYDKZ+LM/+zN+9rOfYTabMRqN/PSnP6WmpuaV6Pjx2e1RIgVgurGJjv/zVxT++79a0MgKzOSVDx8+jMPheGXE2zcNnU7H7t27+fDDDyNC8OGiWJPJhMVimbfwtKKiAqfTKTicfpGQ/eTkJIODgxG1JYAwl2Yu5HK5IFLCP4fTQWHMZjOnTp2KWICmp6dpb2+Palt++jxhU7b79+9TW1tLR0cHVqsVlUolRD28Xi+JiYmzRlbWrVsn3MuGDRsAhPbl48ePs3PnTnJycgSjuvr6euRyObt27WLv3r309PRgt9tnTeW0tLSwa9culEolWq2WTZs24ff7Wb58OQ8fPqSgoIDGxsaoduawhb7T6USlUgkGeQUFBYyPjxMbGxt1LYlEEiUWT506xcGDB2lpaZmzjTk8TNFqtVJfX4/X6yUzM5Pq6mrOnz+P1Wrl9OnT7NixQ5gUbTAYMBgMC17EGhsbS3V1NYsXLyYQCODz+WhoaKClpUU4RqfTRX2WnsbpdOJyufD5fMKUcdHuX+TrYkGFyq9+9SsA1q9fH7H917/+Ne+99x4Af/u3f4tUKuXgwYN4PB62bdvG3//93y/kbb0wvmlLlEgJM93YhG/asmBC5cGDB9TU1OB2u9Hr9Rw5coTS0tIFudZ3gbi4OHbt2oXb7WZ0dJSYmBjMZjP37t1jzZo11NXVEQwGaWxspLi4mH379mG32wkGg0JYv76+niVLllBdXf2F/mirVKpZuz/8fn+Ei+vT6HQ6lEql0DU0Fz6fL8ILJkxYgJw6dSpCnEkkEjZt2iQU6NrtdqRSKYsWLWJiYoKuri7h2MuXL7Njxw6htsXv9xMfH8/69etJTk4mEAgwPDzMhQsXmJycFNp59+/fj8Ph4Pjx41Hv99ixY7z77ruYzeY5TddgpoaitrYWv9/PlStXhDTFa6+9hkwmIz09XRAqaWlpLFmyBL/fj9/vJzY2Vkh9FBQUYDAYhGf5LGVlZVGC0WazEQqF5uzSCh/j9Xo5duyYsG1wcBC9Xs+2bds4evQoo6OjOBwOTp06xRtvvCHMKPoqCPvyWCwWTpw4ERF10mg0HDx4cE6hMj09TV1dnVAELZVKqaioYMWKFS+1pkZE5EVZ8NTP81Cr1fzyl7/kl7/85ULeypci4HQ8Z390gdzLoqioSJhu+9FHH/Huu+9y+fJlUaz8CQQCAWQyGaOjo4KjamNjI5OTk+zbt09IeXg8Hnw+HykpKZhMJpxOJwaDgWXLlqHT6b5wXYHZbMZgMESJlbt377J+/XpOnz4dsYhKpVLWr1/PqVOnqKioIDc3d85U01zdMC6Xi/Pnz/Pmm28yPDxMT08Per2ejIwMmpqaBHEjkUjQ6/XExMSg1WqFAm6Yiah8+umnFBQUCC3E8fHxQmRiYGCAw4cPC8eHQiE6OjoYGxuL+HKi1+tZtGgRBoMBq9VKX18fiYmJ83aoBINBAoEAJ06cELYNDw9z8uRJtmzZQmJiIjqdjsTERIqKijh16pQQGZFIJJSXl7Np0yZiYmK4fPmy4JHzNAkJCcTExKBSqaJm91y9epW8vLxZ29PDr7XZbMIYBYlEQlZWFkajkfHxcQoLC2lubiYYDOL3+3G5XJw5c4acnBwqKiowmUzPjai9DEwmE2+88QZWq5Xx8XGMRqPweZyN8Iynp6N/YQGvVCqpqal5aeZ0IiIvylfWnvxNRKad/9uD7DnGUX8KSqWS/Px8li5dyi9+8QsqKir4L//lvyzY9b4LJCQk0NbWxpMnT4QCWZgprPz0008JhUIUFhZiNBo5d+4c09PTQvt8QkICJpPpSxU/ajSaWW3kh4eHaW1t5e2332bJkiVkZmZSUVHBvn37ePjwIQMDA9TV1c3ZxQHMWytjsViQSCQsWrSIZcuWMTg4yCeffBIxl2jlypVCrYJcLo+qgQoGg7S2tnLixIkIEeNyueYcJGixWAgEAuzfv58333yTLVu20NfXx7Vr1+jv70er1aJSqcjNzZ3z3ouKiuY8/5UrV9DpdOzZs4fly5dz5syZCBESCoW4d+8eCoWCO3fuMDg4KLQC5+bmsmTJEvbu3Ut1dTUnTpzAYrGwe/fuiFb0yclJUlNT5zSHW758OVNTU2zfvp2MjAz2799PbGwsFouF6elplixZQn5+PhKJBLlcTjAYZGJigjt37vDhhx9itVpxOBzztl2/LPR6PampqZSXl5OdnS0MbQwTCASwWCyMjo4yNTUVlaIMc/fuXdG3SuRrQbQnnAdFjImYqkqmG5ui9sVUVaKIMUW/aIEIBoNfyR+1bzOhUAiZTIZOp0OtVuPxeAQjNr/fH5HDh5mC0T+VQCCA1+vFYDCwdu3aiG4WiURCSkoKBoOBtLQ0AoEAVquVI0eOREQjr169yr59+2ZNG2i1WrKzsyNERJjs7GxhoY2NjWXjxo3U19czPDyMwWCgpqaG5ORkVCoVdrsdh8PB1NQUeXl5gsFcGIPBQFVVleCK6/P5hNTAbHR3d+NwOBgaGqKmpob4+HgGBwdxuVwMDg6yefNmVqxYQVdXV9TnOiUlBb1eP2fqJRzxSkpK4saNG3PWkdy6dYva2loGBwdpb2+ntLSUxYsX09/fz8jICCkpKRQWFnLy5El++MMfsmnTJrxer3C+u3fvsmvXLq5evSoUyWq1WmpqahgYGODevXssXbqUZcuWCW3PMCN8Hzx4wK5du+jv7+e1114TjNgKCwspLS3l0qVLTExMYDKZWLlyJfHx8V/LFGWXyyUMazSZTFFdQOEOs7y8PGEgplQqjZj3JCKy0IhCZR4Uej35P/lzOv7PX0WIlXDXz0LVp/z85z+ntraWzMxMbDYbH3zwAZcuXZrVXl3kxXn8+DHFxcWkp6dz9uzZiCF2z7Js2bLnWq0/j0AgIEQx/H4/ixcv5q233mJ6ehqZTEZSUhJarRaFQsHjx4+jxEGY8fFxoajxWdRqNVu3buXs2bMR9SXZ2dls3bpVeI1CoRDm63i93ohC3XBRq0wmQ6vVUl1dTWlpKU1NTfh8PrKzs4WalHCNQngq71ymYVqtlsnJSdxuNxcvXmTXrl10dnYKPh6XL1/mzTff5PXXX+fhw4c8efIEhUJBcXExZrN53vqQMD6fb9ZOrjBWqxWbzcZrr71GQkJChOAIs3LlSr7//e8jkUgYHR1FIpEIHVD379+nvb2dAwcOCPVKPp+Pe/fuCSItPj6es2fPRqWxwgMnX3/9dRobG+nu7iY5OZmcnByOHj0qHDc1NUV3dzdbtmyhtLR0waztvV6vMONIqVQKv0en0ykUTI+NjaFSqdi/fz9Xr17Fbrezfft2urq6uHr1KoFAgPz8fMrLy4Up0iIiXwWiUHkOqvh4Cv/9X/2bj4oTmVa74D4qo6Oj/PCHP2RoaAiTyUR5eTmnT59my5YtC3bN7wLhiIFcLsdqtWK1Wunp6RE8akZHRzEYDKxYsYKMjIw/+Q+x3W6nt7eX3bt3C3UMLS0tPHnyhPz8fMFUDWbSUnMJFZPJNG9dgMFgYMeOHTidTjweDyqVCq1WO6uwUSqVEbOCwi22586dExZ9g8HAa6+9RlFREdPT0/T19XHjxg1+9KMfCa/T6XQsWbJkzuGhaWlp3L59W/g53LYcnkjt8/nweDx88sknLF68mIMHD9LZ2Ul7ezvXr19n586dqNXqWQdDmkwmRkZGaGtrIz09PWI+0NMkJCQwOjpKZmYm/f39s87AuXHjBllZWfz2t7/F7/cDf6wR2rhxIxcuXMBisUQVBocJR6Nmw+VyYbFYhDlNlZWVET4mT3Px4kWysrIWJFIxPT3NlStX6OjoIBQKYTab2bVrl/Bv4OmBmd3d3ahUKnbs2EEwGOTSpUsRqaCwoP7+97+PQqF4afb/IiLzIX7KXgCFXo82PQ1DYQHa9LQFb0n+p3/6J7q7u/F4PIyOjnLu3DlRpLwE8vLyaGtri3BHbWlp4cyZMyQmJvLaa69RWFg4b23CFyEQCJCUlITP5xPqNrKysli/fj3379+P6MYpKSmZ849+TU3Nc+9HrVZjNptJSUmJ8F55HjabjY8++igiMmGz2Th58iR6vZ4HDx4wMDBAVlZWxD1IpVLKysrIzs6OOF+4q+jhw4cR6avw7KKnCQQCbN++nVWrVqFSqbhz547wu7lz5w5btmyJeiYKhYKNGzcSExPDnTt3iI2NnVNQLl26lIcPHyKRSLh3b/buPZjxbkpLSxN+Dk9nTkhIQK1WzxvleF7DwNNpKYVCMatDLcx0RL1IFGk+/H4/FouFJ0+e0NrayuTkJFarlQ8//JD29nbhXlNSUnjw4AEAly5dijqPx+Ohvr4ehUIxa72Kx+OhsbFxToEmIvKyESMqIt8ZzGYzOp0uyujK5XIJs4DUavUXMtXz+/04HA5sNhsqlYrx8XGcTqdgV37x4sWIAsSEhAS2bdtGRUVFRLrAaDSyf/9+jh8/LtRsSKVSampqIhbRl4nf7+fx48dzms7du3eP0tJS+vr62LJlS5T40ev11NbWYrPZ6O/vRyaTYTQauX//flR0yGQyCWkfmBmuGBsbS39/P7dv3yY5OZmDBw/y6aefYrVaGRkZQafTsW/fPnp7e4X25NTUVOrr60lISCA/P58rV67w+uuvc+bMGaHoOFxHEvZqUSgU89Z3ud3uiChTmMbGRlasWMHExARJSUmztphLpdI5BxzK5fKIdt7ndfn8KV1APp+P7u5u6urqhMgQzPj/LFu2jIsXLwrbCgoKOHfuHGazec76nuHh4XlFWGdnJ5WVlUIET0RkIRGFish3Br1ez5o1a7DZbHMWYS5duvSFvSK8Xi9Pnjzh4cOHLFq0iLq6OuLj4/H7/WRkZHD27NmoLomxsTEuX77Mli1bIrxY5HI5GRkZ/PCHP8Rut+P3+zEajWi12lkX0ZeBx+OZd7rv2NgYa9asobq6OsqkLOxZolQqSUpKIikpienpaX7961/P+lwrKiqEtE9RURGVlZX88z//c8SiqtPp2L9/PxcuXMDv99Pb28v169dJT09Hr9fT19cnjAQYHx9n27ZtXL9+HZ/Px/bt2wkGg7jdbhwOB/fv32dwcBCFQkEgECA9PX3WgmOYibTNNoPMZrORn58PwM6dO/n444+FCfDh+zUajUKL+bOsX7+e2NhYXn/9de7evUsoFJpzirZCoZjXgG0+XC6XUKS8ePFi0tPThcLxcBt6fHw84+PjgsFduK36yxKeAzU6OipEnkREFgpRqIh8p9Dr9ahUKsHe/OmFMi8vj8WLF79w3j1sprV//36cTierVq1iYGAAtVqN3++fs82zr6+PycnJKJfScETCaDT+aW/yBZHJZPMujgaDAbVaLdxjKBTC6XTi9XppbGxkcHCQpKQklixZgslkQq/XzxkV0uv1mM1mampqSExM5MMPP4x49jBTQ3Tu3Dk2bdok1PMA9Pf3R91b2Om1urqaCxcuMDExQUxMDFVVVfh8PkGk1NbWcu3aNZYuXUpvb2+UiIqNjRXaip8lKSmJlJQUNBoNKpWK733ve0xNTTE6OoparUYmk/HZZ5+RkZHBrl27uH//vnAfq1evFhZwnU5HamoqoVCI2tpaPvroo6j72LZt27wC2W63Mzk5SWdnJ2q1msLCQlQqFUNDQzQ2NlJSUkJubi5TU1OCd8uVK1dITEwkLy+PFStWcOLECUKhEDqdjlWrVs0758dkMs0bKSkpKeHs2bOsWLECt9stChWRBUUUKiLfORQKBVlZWbz33nuMjY3hcrlITk5Gp9O9cG1KIBDg3r17Qjrp2rVrgtW8XC6PGL45G36/n/Pnz7Nv376vbeaKWq2mvLxcKPZ8lurqakHIWK1WhoeHGR8fx+PxCL4yly9f5uHDhxw8eJCMjAwyMzNnjQopFAoyMzMZGxtjYmJi1iJZmEk5hGsfEhIS5rz3iooKhoeHI2ospqamuHDhAtXV1bz11lvodDo6Ojro7e0lFAqxZ88e7ty5Q39/P3K5nJKSEqqqqoQZSWFMJhNqtZqKioqIYal6vV5om7506ZLQ8TQ9PU1HRwelpaXC7CWz2RxxznD0LDU1lXfffZempiZGRkaIjY1l6dKl8xZM22w2Pv3004jaqnBK6+HDh+zcuZPLly9H1BkZjUa2bNnC6dOnuXr1Ktu2baO0tJSuri60Wi13795lZGSE8vJyoXU6jEQiYf369VitVoqLi6Pa9sN1UNevX+fKlStUV1c/V/SKiPwpiEJF5DuJTCbDZDJ96S6LYDDI9PQ0WVlZgqNtGL/fP6/gkUqlaLVaBgcHcbvdX+twOIPBwNatW4V0C8wsVMuXLycpKQmYESmTk5P09/djtVqFgYQTExOsXr2aq1evcvLkSQ4dOoTBYJgzKuT3+7l58+a8Rm/wxwJUv98/56yhxYsX8+GHH876+jt37rB48WLUajXJycloNBr6+/sZHx9n8eLFVFVVIZFIMJlM+Hw+Fi9ezOjoKHFxcVRUVDA9PU0oFCIYDOJyuaJ+PwqFIqot2+Vy0dDQgEQiieiOepbwtOh169bh8/mQy+XzFuuGBfHTIgVmon9HjhyhpqaGmzdvRrVph7t5VqxYwfnz53E6nRQUFAgFveHxA+vWrWPTpk08ePAAu91OUlISq1atEiIkiYmJlJeX8+jRI6EYPBgMcurUKWDGGE+hUDA+Pi4KFZEFQxQqIiJfgnDUxGg0RhQqhunt7SUnJyfC2yTMokWL8Hq95Ofn/0l1Ai8DvV5Pbm4uaWlpTExMEAgESEhIQKPRoNVq8Xq9DA4OUldXJ9xrZ2cnSqWSHTt2IJFIUCqV2O12XC7XvIuVz+ejq6trVpfeMCqVSrjOs7OGTCYTOTk5FBQU4PV68Xq9s54jGAxitVrx+Xzo9XrBQl4qlTI2Nsbw8DCLFi0iGAxy9OhRsrKy2Lt3L+Pj4xw7diwiLZObm8vWrVsj0jLx8fEoFIpZi5Dz8vJeqMZJJpO9kBW90+mM6ljSarVC7VNSUlJUREilUpGTk4NCoRAiO+Pj40xNTbF48WJ6enqEYy9fvkxMTAylpaVoNBphJtDAwACff/45crmcpUuX4vF4kEqlXLt2LarbRyKR0NbWRk5OznPfj4jIl0EUKiIiXwKJREJxcTEjIyOzdnzU19dz6NAh1Go1ra2tBINB5HI5ZWVlJCUlcezYMV5//fWvNZoSRqfTodPpotIVMFM3cvbs2ShB5fV6uXLlCmvXriUtLW1WQfb0OcKpHq1WS29v76wpBYAVK1bgdDrp7+8XZg2Vl5dz6NAhRkZG6Onpobu7+7lRGY/Hw+HDhzGZTKxfv56bN28yPDxMZmYmmzZtQq1Wo1ar+cEPfkAgECAQCHDy5Mmo9/nkyRMeP37MsmXLkEgk2Gw2HA4H+/bt48iRIxF1NmazmfXr17/04udnP1/BYFAQOX6/H5lMRmFhIbm5uRgMBiQSCV1dXcKU+vfee0/4/KlUqqjPnMViweFwkJiYiFarFZxnV65cSUtLCyaTic7OzllFdWZmJoODg6/E51jk24soVEREviRGo5FgMEhmZmbEt1RAsMOXyWTs2rWLYDAofPMMd4hYrVYyMzO/jlt/YcJTgmcjHPaXSCSztn0Hg0HGxsY4efIkExMTpKWlUVZWxs2bN9m6dSsxMTHcu3cPl8uFyWRi9erVKJVK3G43bW1twEx0IC8vj48++ijCg0Sj0RAbGztrwbJGoxGiHRaLhbq6Onbt2sWRI0fo7e0VIjVSqVRIUdXX188Z3WpoaKCkpESY1zMxMUEoFOLQoUOMjo5is9lISUkhLi4uqjvqT0WhUJCRkRExIdvtdqPVapHJZCiVSvbt28fjx485deoUgUCALVu2kJCQgFKp5MGDBzx69Aiv10tycrIw90cqlQqfyW3bttHb28uxY8eEZ5CYmMjWrVuF1NSmTZs4d+5cxL1ptVqWLVtGXV0db7755kt93yIiTyMKFRGRL4lUKsVsNrNmzRr6+/ujbNQlEgkPHz6cs1h1Lv+SV4n5JhzDTApjaGiIbdu2RS3SVquVP/zhD8L7HBgYYMWKFWRlZXH69GnS09NZu3YtSqUSjUZDX18fycnJEYtyZWUlN2/ejDJKa2hoYOPGjZw4cSJCSMnlcjZv3syNGzeEbeG5RCkpKQwNDfHkyRMcDofQ1RIeyjcXTqdTMFM7fvy4cL0rV66QlJTEhg0bhELbPxW/34/X60Umk6FSqVCr1axbt45//dd/jUhJNTU1sWHDBmQyGWfPnmV6ehqA4uJipqenMRqN3LlzJ2Ie0/DwMEeOHOHAgQPs3LmTzz77jIKCAoaHh3n8+HHEfYyOjnL8+HG2bdsmTA9/++23efToEXa7XSiovXDhApWVlYRCIRwOxwu39ouIfBFEoSIi8icSHx/PoUOHuHLlCr29vSgUCioqKoiPj8dsNgt5/2d5XmfQq0BsbOycnhsajQa5XM7+/fvR6/URhmWhUIiWlhZBpITTIr29vVRUVLBy5Uq6urpwOp1otVoaGxtpb29HKpXyzjvvsHTpUkKhEHK5PKoGA2YiJdeuXePNN9+ku7tbGPCXmprKzZs3oyZOT0xMYDQahYX7aXHjdDrJysri0aNHsz6D5ORkAE6dOhUVXRoZGeHcuXNs3rz5hQqznU4nDoeDQCCASqUiGAwKz8Dr9QoOtT09PSxatIiEhATMZjOHDh3i8uXL9PX1CbUneXl59Pf3CyIFZoTK6dOn2bRp05xDIz///HNWrlzJ22+/jd/v5+OPP571uOnpaex2O52dnVRUVHDq1Cm2b99OKBSiq6uLnp4e1q9fT09PD//yL/9CVmYm22trX3pUSUREFCrfAP76r/+an//85/zFX/wFf/d3f/d1347IM8hkMhITE9m1a5ewMIdD85s3b+bw4cNRC31RUdE34g96eEhh2GjtaTZs2MDQ0BAJCQno9XoCgQAOhwOn04lUKiUuLg6z2Yzdbmf9+vXU1dXhdrspLi7m4sWL+Hw+/H4/k5OTKJVK8vPzkcvldHV1CTUh8w0dHB0dpbe3l8HBQRYtWkR7e3tEJOVpYmNjGRgYAGYiXWGRMDY2xokTJ1i9evWcZmw1NTW43e45LePHx8df5FEyMTHByZMnBZO9cKFqfn4+v/vd74RalHBdzdWrV8nNzaWqqoqkpCT27NmD1+tFIpEItSRPOwDLZDI8Hg+xsbHzTrYODx9sbm4mOzs7ys/maWw2G0NDQ5SVlREfH08oFEIqkTAyMoLf7+fBgwd/nBrd20tHeweVVZUv9DxERF4UUai8AC6nF4fdi9vlQ61RoNMr0WgXxi30WW7fvs0//uM/ztspIfJqEC7QfJrk5GQOHTrE559/zuDgIDqdjuXLl5Ofn/+NKEBUKpVUVFRgMplobGwU2pOXLl3KkydPyMnJISYmBo/HQ2trK5cvXxbEmsFgYMOGDVgsFpqamnC73WRmZuJyuZicnBRafFesWEFiYiKdnZ14vV5UKhU2mw2j0YhKpcJoNEY5/IYxm81cvXqVqakpli1bNmuBrkwmIz09XXDGLSwsRKvVYrPZhNTUpUuX2LZtG42NjXR1dREKhYiNjWXlypWYTKY/ea7N9PQ0H3/8cYQQCrdrh9uow3VOYSPBPXv2cOTIEYqKioQ00LOfr6dTLWE3Wp/PN69Zm0wmQ6PRcP/+fVJTU5HL5XOKFYPBILjeVlRUYDAYuHL5Ck+ePJn1+LuNdykoLBBTQCIvFVGoPAfLtIvPPrzHk9Y/fmvKK4pn15sVmGIWdqGx2+28/fbb/N//9//N//a//W8Lei2RhUGhUJCcnMzu3bvx+XxIpdKv5Y+41+vFbrfT3d2N0+kkOzub2NjYF7oXg8EgdJQ4HA4mJyd58OABy5cvF87R3d0dVWxps9moq6vj+9//vjA1OFwAGxcXR39/P9XV1bhcLj777DPhdR0dHZjNZg4ePIjRaGTTpk0cOXIk6r6Ki4vxeDwEg0Gmpqaw2+1UV1fT0NAgfMvXaDRs2rRJmORcUVFBTU0NKpWKBw8eCKLKbrdz69YtVq9ezapVqwgGgyiVSqHgViqVzpkCk8vlzzUKnJycnHPo4K1bt6itrY0oyPb7/QwODpKamioYw83GokWLaGhoAP7oP2O1WklOTp7zfouKioRoVnt7O6WlpVGmbzBTLB6umVGr1bS1tVFTvRK3Z3azPpjpUAoFZp8fJCLyZRGFyjy4nN4okQLQ2TrO8Q/vceAHSxY0svL++++zc+dONm/eLAqVbzizfRv+qvB6vbS1tXHx4kW0Wi1Op5ObN2+SkpLCnj17olJQ4RTE09/Kw109TqeTjIwMFAqFEBFyuVyzzsqBmQX3yZMnpKSkMDg4iMvlYmpqisrKSoaHh0lOTubTTz+Net3k5CRNTU2sXr2a9PR0vve97/H5558zPDyMTqdj2bJlpKamEgwGefPNN2lpacFisVBaWkppaakwrVqj0RAKhaipqWHz5s2MjY3R0dFBSkoKOp0OmUxGIBAgOzubkpISjhw5Irx/mUzGqlWrKCkpQavVUllZSWNjY9S91tTUPNfsbL6ZSi6Xa9bPxtjYGEajcd5hhUajkQ0bNghePg0NDcL06vXr10d5/JjNZoqLi3G73UIXWm1tLT6fj+bmZuG4+Ph41q1bx5kzZ4CZyGB9fT2rV9RQkJU3azu6RqPhQO1eJBM+xu/3oDCp0GbEIDMokcpebCyFiMhsiEJlHhx2b5RICdPZOo7D7l0wofL73/+eu3fvCt8ERUS+LOGpxZs3b8ZqtWI0GgkEAly/fp2mpiZqamqQyWTY7XYGBwdpamoiGAyyaNEisrOzhVZWpVI5a11NuM5kLkZGRsjNzWVwcJDe3l72798vWL/PlUIAePDgAVVVVRgMBtLS0ti7dy8ej4fJyUnq6+u5cOECMFPTsWPHDtra2vD5fLhcLq5fv87IyAhyuZy1a9diMBj4+OOPI7qYsrOz2b59O3V1dSxZsoSjR49GdNYEAgE+//xzYmNjSUhIYOXKlcTExAhdSAaDgdWrV5OTkzOvu2z4HudCpVLNKkbi4uIYGRkRHILnem3499TZ2Ynb7RZmKo2OjvLWW2/R19eHy+UiMzMTlUrFp59+yooVK8jNzaWzs5OTJ0+ydOlS3nnnHaanp5HJZExNTXHq1CkcDgdr166lqamJ6upqlFo16enpmEymiE4phULB6zv24zw/gHXqjxEXiUxC6oFFqNOMSOXfXrFi9fjw+ANIJBKMSjlK+fPN/EReHFGozIPbNX/7qOc5+78sfX19/MVf/AVnz54Vh32JfGlCoRAulwu32019fX1EnYfRaBSs8ysqKpBIJNTV1dHX1yccMzAwIHTrnDhxgtTUVFavXo3ZbI6Y/CyTyYiNjZ3V6h5m3FOLi4u5desW5eXlOJ1OkpOTGRkZmXXScphn6ybUajUtLS2CQAljsVj46KOPBAt/lUrFgQMHhCnBfr+f3/zmN1FpkO7ubhISEli6dCldXV1z3sutW7coKCggJyeHqqoqCgoKBNO1Fy2ITkxMRKPRRFnvA5SXl0c8d5hpfS8oKHih+VMqlQqVShVl2BeemGyz2bBYLLS3t7NmzRrKysowmUyYzWacTidDQ0PcuXOH9vZ2Nm7ciM1mo6+vj5ycHPLz8+nq6kIul1NcXIxUKkWv07Nv624aH9/jcWszgUCA9a+tw980hW8qMi0UCoQYPPKYrB8tQWr6dvwts3v9OH1+JEhQyCQM2d0cax9iyO4mUatiR14yKXoVcokEnVKBRiGKlj+Vb6/EfQmoNYp596ues//L0tDQwOjoKEuWLBEMly5fvsx//a//Fblc/lxvCxGRQCDA1NSU4Cz7bDGq1WrlypUrQpH28PBw1GIJMymYwcFB4uPj6erq4l//9V+j5s5otVpWr149633IZDKKioowGo288847FBUVYbfbefLkCWlpaeTn58/5HnJzcyPST3a7fdbuI5jxShkZGRGO12q1mEwmjEajUBw7Gw8ePCA7O3teHxWLxYJKpeLo0aM4HA4MBoMwLfpF0Wq17Nq1KypFVFxcTFlZWUS3klqtZs+ePSiVSkpLS/8kp1u9Xo/RaKS3txe73c6pU6fIysri4sWLnDhxgsLCQvbu3cvGjRtZu3YtGo2G0dFRli5dSllZGV6vl9zcXKFIF0ChV2GKjaE6v4q3d77JD/d+n8L0PByds0fVQv4gnjHHl34Prwr+YIgei5P/druD/+/lx/yhuY+HYzb+860OOqccOH0Bui1O/v7uExpHLEy4fVzqGcXifvX9kl51xIjKPOj0SvKK4umcJf2TVxSPTr8waZ/wkLCn+dGPfkRxcTH/y//yv7zQjBCR7x5erxeXy0UgEMDtdtPa2kpBQUGUp0iYsbEx4uPjkUqlNDU1zXnetrY2SktLGRgYIBQKce7cOd58882IQtyUlBTWrVvHtWvXhEiIVqtl586daLVaJBIJMTExjI+Pc+PGDRwOB52dnWzfvp3k5OQo8aNQKASn2jDBYFBIY83GXG3Cc3UMwYzLq9FoJCkpKSINlZqaKizQTqcTq9WK1WrFbrd/qbZyqVSKRqNh165deDwevF4vBoMBrVbLwMAAO3bswOfzCVOIDQbDSym6VqvVVFVVUVRUxMDAAC6XC6VSKRT2Xr58GalUKhx369YtRkZGuH//PhKJBKlUGlGYXFNTA4DCoMKojyfg8kEIAm4/zDO2KuD8Zi7WHn8QfzCIWi5l3OnlP9W34gvOvNFd+Sn851sds77u0/Yh/j81RaQZNZzrHmFvQSpysU7nSyMKlXnQaJXserOC4x/eixAr4a6fhapPMRgMlJWVRWzT6XTExcVFbRcRAZiamuLKlSt0dnYikUgoKSlh0aJFwoyduXiR4XihUCiihmJychKPxxOxkGo0GiorK8nNzRXqVTweD1euXCEzM5Nly5ah1WoFr5Uw58+fp7a2luHhYZqbm/H5fOTk5Aj1IM/e63ytynFxcUxPT2MymSLuNzMzk7t37876msTERFQqFaWlpdy+fRupVMq2bdsYHx/n8ePH+P1+CgsLKSkpwePxzDrX6UUYGBjg6NGjxMTEkJ+fj0Kh4MGDB0xOTrJ//34h4qPRaNDpdEilL29RC6eGNBoN58+fj6qXCZvO6XS6CPM4qVRKaVEJJXnFyCRSpPIZ0RL+vEgkEuThv4HBEHK9Er999nELquRX3zPoaZw+P0N2N2eejDDp9lFo1rMkOYYMo5ZgKERZgpFgCFz+2aPb/mAIu9ePJASXe8dZn5lAnHbulnGR+RGFynMwxWg48IMlOOxePC4fqq/YR0VE5HlYrVZ+//vf43Q6Wb58OWlpaUIqp6CggMrKylkjJuHF3OfzUVZWFjWvKEx+fn7UvtkWUpfLxccffxwlJEZGRlCr1SxdujSq6NTn8/Hpp5+Snp7OsmXLSEtLi6qBCaPX63nttdeoq6uL2qfRaFAqldy6dYvq6uoIkRMfHz+nwFm3bh1arRaVSsWbb76J1Wrl5s2bjI6OYjQaqaqqEgpHq6qqZr2v5+FwOIT27Onpae7cuROx32q1kpeX94XP+0VRq9WsWrWK8fFxVCpVlOiyWq2YzWaGhoaQy+Uc3LkfzbQElUxH0OUDnwTfmJOQQYVcF/n3T6ZXEr8hh+HPWqOuq82OQb5A0eeFwOMPcK1/gg+bZwwC5VIJ+bE6vP4gh0rTCQHXByaYpxkLAKlEgkwmwxsI4Q3OPyXd6vFh8/rxBYLolXJMKgUKMQIjIAqVF0Cj/fqFyaVLl77W64u8moRCITo7O3E6naxbt47x8XGOHj0q7K+vr2f58uWsWLEiqr6juLiYtrY2cnJySE9PJykpKaqN1mg0kpaWxu3bt1EoFCxatIi8vDwCgUBUGmR6enrOaMetW7coLi5Gp9ORmZkZMc8HoL+/n+HhYd577715xUB2djZr1qzhxo0bQs1EfHw8a9eu5eLFi0xPT1NeXo7b7UatVhMKhZiYmGDLli0RZm4mk4lVq1ah1+txuVxoNBri4uKwWCyMjo6SlpbGsmXLuHbtmpBSiouLY8OGDRGt2S/C87qi+vv7ZxUqfr8fh8OBw+FAKpWi1WrR6/V/UrQlNjYWhUIR0Xoc5tGjR2zcuJFjx46xYdU6tFMS8IcY/rSZUGBmoZXIJMRvyEVfHI9c/cffk0QiQZsdQ8r+EsYvdeGbciNVyjBVpRBTlfrHyMs3AIvHz+F/Eyk5Rg3vlGcxaHPTMe0gRa/G5Q9gUMrRKmTEaZRMuKKjSDqFDJ1CBhJI1qlQSudWNQM2F/9wt4thx0z0UymVsDM/hbWZceiVC1MH+U1DFCoiIt9g/H4/HR0dGI1GlErlrPNqbt++zf79+wWLeIVCQVlZGUlJSZw+fVqYqrt37166urq4d+8ewWCQoqIiEhISOHv2LDqdju3bt9PU1MQnn3wiOLdu3LiR1NRUlErlvFby4boMo9HI5s2b+fDDDyPcXqVSKXv37n1uXYZGoxHccMOvm56e5syZM8L5bDYbGo0GtVqN3W7n3LlzuN1uysrK2L17tzB12Ov14vP5mJqaIi0tDYlEQnNzM1KplJUrV3Ls2LGIzqOJiQmOHDnCD37wgy8kVMI1IHOl4Z5NccFM7UxLSwuXL18W7kGj0bBz507S0tKe2w49H3q9nsLCQmJjY7l+/ToTExPExMRQXl5OMBhkw4YNpMYko/DJoiIkoUCIsXOdqJL0yFMiF1GZSoE+Lw51soGQLwhSCXKdAsk3LDLQZXEQAtIMGg6UpPN/3GjH+VSKJ92g4UBRKncGp/gfq3L4mxttERETmUTCD8oyCIaCXOub5PWSNGLUswuOCZeX/+NGG3bfH8/vDYY40jaIUSWnMikGvVJcpsUnICLyDSbsdJuUlBQ1Afdp7t+/z86dO4XFvLW1laamJkKhkODTYTAYKC8vFzpxZDIZNpuNoqIicnJyorqHpqam+Pjjj3nrrbdIT0+fdcENo1AohFRTbGwshw4dYmhoiP7+fmJjY8nJyUGv17/QAhwIBCKcbJ9FpVJht9sxmUx4vV6hcLSxsZHp6WkWLVrE5cuXhShHSkoKmzZtIi4uDqlUSm5uLm1tbbPaygcCAe7evcvGjRtfWCyEDepmM8WTyWRkZWVFbbdarej1enbs2EFzczOdnZ24XC4++eQT3n333ahW5C+KSqUiPT2dPXv24HA46O7u5tq1a5TkF1OWUYRSrmK6cWDO10/fGUBVW4B0Fr+QZ9NC3zSC/yY6duYl8Q93n0SIFIB+m4vLveMkapWo5FL+/cpCei1O4rUqJBLQKeRo5VJuDk7yed84m3MSuT9qYdrjJ8ukJU6jRAq4/UGeTDsiRMrTfNY+jFmtIM2oxaT6bkdWRKEiIvINRiaTUVVVRU9PD06nc87jXC4X7e3tgt16mLBXx9M87duhUqlYv349nZ2dc6Z1Ll26JNjdh51vn6WsrAyHw4FCoUCr1QqdLenp6UK3kt/vR6vVPtc3BP7oEfIsWq0WnU6H0+nE7XZHFAorlUoqKys5evRoRLvy0NAQhw8f5p133qGiooK+vr4563XCx3u93hcWKlKplLKyMkZHR2lraxO2KxQK9u3bF9Gy7PF4GB8fJxQKCRb+NTU1LF++nMOHD+Pz+Xj06BGvvfbavI61L0rYMVmj0ZCbm4vSDsNHW0jdX4rfOnchts/inomafAuNzTKMWnRyGYEQOOYQEfdHLfz5klym3D4mnB5CwP/V2CWImkyjhkOLMmiddODxB7jQM4bV42dZSgzFZgMquXSm3dk697/ZSbcXg1JBz7ST8qTnT+b+NiMKFRGRbzixsbFYrVZSU1OZmpoStqelpVFZWYlUKhW6Pmw2G21tbWg0GpYsWcLixYufm8aQSCR0d3fPud/j8SCRSFCr1Wzfvp3z589H+JIUFRUJs2f+5V/+hU2bNgneJTdu3GBkZAS9Xk9ZWRkSiYSsrCyMRuOc19NqtWzdupUjR45EGKgpFAp2795NZ2cnSqUShUJBTEwMOTk5dHV1UVxczP3792f1VAkPVVy8eDFTU1Po9fo5be9fNPLzNDqdjs2bN7Nq1SphenFcXJxg4x9mYmKCUCgkjBCw2+0kJiayfPly3nrrLX77298yNjaGz+f7k/xVnkWr1aKSqxi+0EzQE5gRSvE6vBPRBnUA6mQDEuW3T6TATI3IlpxErJ65W6pDQCAUQgKEkPCvjyJrrnqtLn7Z8ISfLsvj45YB3l6UybTbS5/NxYWeMYriDMSqFCyK1zPp8tJjcTL+TK2LSaUgBNwamqQoTo/qWygKXxRRqIiIfMNRq9VkZWURFxdHa2srfr+f0tJSUlJSOH/+vFAbodVq2bJlC6tWrcLj8WA2m1/Y+TgsHDQaDUlJSQQCASYmJtizZw9ut5srV66gUqnIzc1l8+bNBAIBYRJyT08PN2/eZP369axatUowFfv4448FN1ibzcbQ0BAVFRX4fD5KS0vnvDe9Xo/H42Hv3r1YLBZGRkaIi4sjJSUFh8NBYmKiYGy2detWNm7cyIcffkhcXNy8lv29vb1UVVVRWFhIXFwcnZ2dsx5XXV39pUSCRqMRinZnw263o1QqefDgQUQ7dU9PD729vezdu5fCwkJMJtOCmD6GfAF8lplOoPFLXSRuycfeNh7ljyKRSYhZkvKtnd+jV8nJNGnQzCNGtQoZapkUXzDI2a7ZBa3NO9Pi/HZZJv02F/5gCJlEwqbsBFRyGf1WF5IAbMpOwOsP4g2G+JeHvdi8MynHLTmJOH0+5FIJz2ka+tYjChURkW8BarUahULB97//fT7//HMKCgo4duxYxDFOp5PPPvuMQ4cOYTQav9B4hoKCAsGPo7e3V5ih09fXJ7TeAty5c4fq6mr8fr8wMyjcLXP27Flqa2sZGxsT9j3LvXv3OHjw4JyD+mAmlRIfH4/FYkEikWA2m5HJZHg8HiFK43A4sNvtBAIBYmJi+P73v4/NZkOn00UU8T5NeEpyOMqxbt06rly5IkRgJBIJq1evJiEh4YWf2xchGAwSCoVm9XwJhUJcvHiR2tpa5HL5nE67fwpSpQx1kh7fpAvPiAPLw1FS95cyeq4Tv3VGwChMapJqC5B/S+zwZ0OrkJNq0GJxeymM1dM2Ff152ZaTRLJeTa/VybBjdm+d/FgdmUYNrRN2znSNYvH4yInRkqJXc6Z9iMaRmaijXCrhrZJ0Bu0u/t+VOfy3hg5q0uIoMutx+QMUxOq/8zb8olAREfmWIJPJSExMZNOmTVFTc8MEg0EePHggOIy+KFKplMePHzM4OChsa2xsZMmSJSxbtizCG+TWrVscOnSIrKwsQqEQFotFGHAXFhnzteva7fbndv9IJBJ0Oh3Xr1+nra1N6OJ5OtKQm5srtDqHnV6rq6vnLMStrKwU0jBqtVooLB4dHSUUCpGYmCh4riwEfr9/znlJMGPlL5fLUSqVX6jr6EWRKmTErkjH0T2FJsWA3+Jmor6PuNWZSNUK5Holcp0Cuf7VMi5z+tx4/B5UMiVa5ct5LnEaJUqphB+WZ3Kqc4Qbg5P4gyEMSjm78pMpiTPgCwSRICFGpWD6mTTRWyXpJOpUnHwywq3BP6ZjH4/baB638WeV2QzZPQw73PiDIT541MdPl+Vxc3CSf7+ikAejFqQSCU5fgJL4udOg3xVEoSIi8i3DYrHMKwTGxsbmHQb4LC6XK0qkyOVy0tLSmJqaoqKigqampogumcePH1NaWsr58+eFWo/whOb5uoPCx71IQa1CoWDFihW0tbVFDfvTaDTk5+dHFJxKpVLS09NZsmRJRNRCIpGwefPmCMdWp9OJ0+nE6/UKAwUXSqDY7XY8Hg+hUAiDwYBCoRA8Yp5FJpNFdFC9bPzqELHfK8TtcRP0B1AEpbjG3RhNapTx2lcq3ePyuRmwDnP44XF6rYOk6BP5QcUbaJVmhuxuFFIpRpUco0pBjPrFU3V2rw+bx8+/POxlU3YiEkL8vyqyQQJKqZRei5N/fthLrknLppxENmYn8EnrH/9trEozM+b0kKhTRYiUMCHgs/YhNmYl8LvH/cK2B2NWrF4fwVCIJcmxKKUScmJ0mDXf7C6ql4EoVEREvoXExsZG2KE/uy8YDOL1ep9ba+H3+/F4PBGzp1asWEFSUhI9PT1CuqK2tpa6ujohouF2u5mYmKCsrEwQKmVlZahUKqElerZiValUSlxc3AunNsJpnfPnzzM0NARATk4O69evj7KKh5k6nZqaGioqKhgeHkYmk5GUlIROpxOiL1NTU3z22WcRM5KKi4tZt27dl5rzMxdut5u+vj4uXryIzWZDIpGQl5fHnj17OHnyZFT3VHJyMgqF4qXew9PYbDacTid37txhcHAQrVbLkiVLMCQbCJkVr5RICQQDNA094m/r/3/CtgxjBk6fGrksRCAEIzYXKSE1/hD4AiESdM8Xmg6fnx6Lk49bBumzufAFR9iWm8Q/3esWZvwkaFW8vSiDHouT3zzo5WBRKhPOeK70jRMCliTH8lFL/5zeKQAjDk9Uy/G024tGLiMQDCGTS0DC/5+9846OqzDz9nPb9KZRr5ZlW7Ll3rsBVww2PQQSAgkkpGfzZbPp2U3Y3WTTNm1TSUIKCS10MGBjwBgb994lW7236fWW74+xRh5LMgZsMImeczgH3T4j697ffcvvHREppxkRKiOM8A+Gx+Nh1qxZ1NXVDVonCAKVlZU0NTWRTCaZMGHCoFqQfu+RI0eO4PP5KC0tTaeTJk6cSCAQ4Kmnnkpvf/DgQcrKyli5ciXPPfcckEq7HDlyJD2bqqqqipKSEl588UWuueYaFi5cyDPPPEMikdnpsHDhwvRwvvOhX2hcf/31Gd1H54p+9LfkDuVF4vP5ePzxxzO6pwCOHTuG2Wzmsssue0s2+kPR1taW8T0ahkFtbS3d3d1cdtll6e8SSJ/7YqR8IDXKwOfz8eijj6bFZiAQYN26dUyePJkZM2acV5TrnaIv6ufe3Q9kLHvfpBsQBDM/2p5p0FbqtHLLxBIMDBwmGZsy/GOvL5okoRk0BVMRunp/hI31nXxiRgWtwRjBRJJ5xV5+vKM2XfT6393HWToql6/MrySUVDFLIglNx/QGwk48KypW5rLRFYljUyQ2N3cxp8iLphuEkqnzOE3yoH3+WRgRKpcg3/rWt/j2t7+dsayqqopjx469S1c0wlslHA6j6zomk+mipQ7Oxmq1Eo/Hufzyy9myZUs6jWCxWFiyZAkHDx5k1KhRbN++ndzcXEpKStL7qqrKqVOnePbZZ9PLTpw4gc1mY/Xq1SQSCbZu3TronI2NjZSVlZGXl4emaWRnZ9PZ2YnH4+G6666jsbGR5557Dl3Xefzxx1m2bBlr1qyhsbEx3Z5cWVlJY2MjkiS96Qdyf0fN2YRCIWKxGJqmYbFYcLlcaJpGPB5HkqQMkRYIBOjq6qKvrw+TyYTD4SAWi6UjG4cOHWLWrFlvmLo6H8Lh8LBjMXw+HyaTiTlz5mBWzIwuKsNqs6HJxgVtST77el599dUhu4kOHjzIlClTSCaTF0ykvV0C8RChxMBwy0JHHhbZwf/uqB1k0NYUjLKhrpOrxxSwvbWXy8tycQ5joHa4OzBIYNT2hfn5rpMU2C0sKPay/lQHFlnEMCRCSQ0D2NjQxcaGLr65sApBEOiNJcm1mZEE0IYIDlZ6HdT5B67frkiUuW2Mz3bSEY6xt93H5WW5rDvZzustvVhlkbVjCyhyWjHLIk6T8k8lWkaEynkQi4SJhgLEYxHMVhtWuwuL7e2PYD8XEydO5MUXX0z//HYss0d45wmHw+m23HA4TGFhIYsWLRp24N6FJBaLEQwGaW9v58orrwRSkRRN09i7dy9tbW1MnjyZcDjMjh070uIiGo2i63rGm3w/kUiEHTt2MGHChGHPe/To0fRnfPrpp5k6dSqvvPIKzc3NGdsFg0FkWeaJJ56gsLAQr9dLLBbj2WefZenSpRckaqBpGp2dnTz33HPp6IjdbueKK64gOzubZ599Ni0GCgsLsVgs1NbWIooiq1evxmq10tPTg8PhQJIktm7dSnd395ButW+FN5r/09XVxdSxkwgf7CK4t4GQJOKakk9yogXFeeEFbyKRoL29fdj1zc3Nb9sN90IiCpliwmN144urw7q87u/ws3ZcIeOznbSHY8MKlZiqkjvMvb03lmBCjpMCh4VipxWnWcEsiTx3sp3GQCoCs7/Tz9wiLzlWE5uburlpfAkPH23O6PDuL8j97d5UxLPCY+f6qiLsskhfLMmv99bz9QVV/HhHLd3RBPOLvSwszkbDwBdLYBIlokkNqyzhfhO1N+9lRp5+b0DQ18tLj/2BppqBGSpl4yZxxQ0fwem5eH+4sixTUFBw0Y4/wsUjGo2yZcuWjLqO+vp6GhoauOmmmygrK7uo54/FYrz22mvMnj2bZ555ZlC9x/Tp06mtrQVSUYRoNMrGjRvp7u5m9uzZwxbaNjU1MXfu3GHPm0gk0HUdn89HcXExDodjkEjpJxwOs3btWvbt20dDQwNer5frr78eu91+QUR5IBDg4YcfRlVVCgsLGTNmDB6PJz3U7+qrr+bEiROsX7+esWPHMnfuXI4dO8aVV17J008/neF6a7FYWLNmDZs2bbpgIrPfhO/sCcb96yaNHk/Xo8fRogPCqPe1RkLHuim6ceJFESvnor+I91LBZXbgtXrojfoACMZD6VTMUBhAVzjOHw40sLg0m2yrecj6jyl5Hhr8EQrslvSQQEi1EH9sWjkPH22mpm8gEmKVJT4yZRTP1LbRGIhSnePizwcbuXViKb/fV49FkvjMrDEc7PTjjyeZkOOiOseJIop8Ye44BMAkiai6ztO17dT2hvnMzAqO9QbpjiYYl+VgZoGHnliCLIvCke4Qu9v7kESRJaXZTM51kWv/x20V7+fSqY66BIlFwoNECkBjzSFefuw+YpHwMHu+fWpqaigqKqKiooIPfvCDg6bNjnDpEolEMkSKLMuMHTuW6upq9u3bRzh88f7dQOqh0t3dTU1NDTfeeCMVFRXY7XYKCgpYsWIFNpstfX1FRUXU1tZSV1eHJEnDdpuc+VmGo6ysjJqaGvx+P7Nnzx62RRpSdvYvvPACLpeLSZMm4XQ60XWd5ubmN2xNfiN0XefIkSOIosjatWuprKwkLy+Pvr4+Nm/ezMsvv0x7ezsej4drr70WSNVozJo1i02bNg2y5u+P9ixfvvxtX1s/NpuN6dOnD7mucuw4Iod6MkRKP4nuCLHW4AW5hjOxWCznFNClpaUXrdPorZBldfO5eXcii6l/j+2hLgodwz+wbYqEqhskNJ2N9V2sq20npg6OvuRYTdT7I9xSXUKpcyCyN7swi73tvgyRAhBVNe47UM9VYwuo9Do41hPkeG+Ix4638OEpoxjltnG0O8CkXBc3jS/m8rIc8u0WvFYTpS4bJS4bOTYzFlnmhqpivrawigqPnR0tqSjg0vIcBEEgy6Jw34EGnj3ZTns4TkswygNHmvntvnq6IsOPOvhHYSSicg6iocAgkdJPY80hoqHARUkBzZ07lz/+8Y9UVVXR1tbGt7/9bRYvXsyhQ4cy5oKMcGnS330CMGXKFMaMGUNtbS2hUIiysjISicQFe+ANhdVqJTc3l9raWlpaWrjhhhtoa2sjEomwffv29MweSZKYOnUqDz74IJCKQgznmgqpIl1ZlnG5XIPm/phMJsaPH88TTzyBoihomsaMGTPYsWPHoOPk5+cTCASIRCLs378/vbywsPANhdL5oKoqra2tLFu2jB07drBw4UI2bNiQHk4IqQjX2LFjqaysZObMmcRiMRwOB9XV1cTjcVpaMgfyRaNRksnkBUvB9n/3HR0dGUXPsiwzf+Zc/E8NLoTuJ3C4A/sYL6J84d4zbTYbixcv5tFHHx005XnhwoWX3H1HEATGZY/mR1d+g40nt3CyrwGBOJVeOyd6B78ILC/PY0tLT/rnzc3drKrIx3KWLb3TrHB9VRE1vUGWlufiMSvoBuTaTdzz2tA1glFVJ5RQubwsl2dPptJnLcEYv9xzilybGa9FoS0Uw2VWuKW6ZFAxrygIGdGdcEJFElOi0GM2UdMbIpxU6YsN/tuo90eo6Q3hEkTM/8AdQiNC5RzEY8MPjAKIx8+9/q2yevXq9P9PmTKFuXPnMmrUKB5++GHuuuuui3LOES4c/SHy8ePH4/V6efzxx9Pr6urq2LFjBzfffDM5OTnndTxd19F1HVmWCYfD6e4Wu90+ZHGlzWbjqquu4uGHHyYajfLKK68wa9Ys9u/fnxYYXq+XhQsXEovF0nUXuq7T2tpKZWVlxvC8fubPn8+OHTu47rrr2L17N8ePH0fXdUaPHs20adPYvHlzupB2//79rFq1CsMw2Lt3b/oc/duuW7du0PEtFgtZWVnn9Z2cC0mSKCoqIpFI4HQ6qampyRApZ24niiIPPPBA+uFsNptZvHgxTqdzUPH6uYY+vhUcDgdXXnkloVCI9vZ2rFYrJpOJvr4+pHOIEFEW4QIHN2RZJisri1tuuYXjx4/T3NycjvpkZWW9Y4XgbwZFkil05nPrlGtJaElMksJtk6ysP9XBttY+VD3V5bOiPA8DONo98G9ANyCUVMll8OdymxVmFXoJJlR03cCqSPRGE6jn8LGPqzolTgXprN9LpTeVumnwRzAw6Ikm0A0Dh2n4NJrdJHPFqFzuO9CAKAhkW01saho8gLOfnW0+Kq0WJENAtl066bkLyYhQOQdmy7nb8czmd6Zdz+PxUFlZma4rGOHSJj8/H1EUmTZtGg899NCg9f3iYdmyZZjN5mHbPmOxGIFAgH379pGfn09RURH79++nrq4ORVGorq6msrJyyC6U7OxsbrvtNpqammhpaSEWi3Hdddfh8/lIJBKEQiE2b97MkiVLEEUxXZeyc+dOVqxYQV5eHgcPHiQcDpOfn8/ChQvTPh+1tbWUlJRQXV2N2Wzm4MGDPPXUUySTSaxWKy6Xi76+Pnbs2MHy5cuprq4mmUwiiiIdHR0888wzgyInXq+XZDJ5zojO+SJJEtXV1bzyyitpZ9n+FI/dbkfXdfr6+vB4PIN+P/F4nBdffJHrrruOkydPZlznhRBRZ9M/LTovLw+A3t5eXtm9m/lVU0huH7q41T3t4szZ6R+RMHv2bKZOnYqiKBety+hCIokSVjEVGXEqErMKvUzKdeO1mmgPxdjS3MPx3sE2+OY3+A6dpoHHo0kScZlkAsPUwRQ5LLjNMpeV5fKXQ6k0/bLyXCySxM92DcyMeqqmnQXFXm4cX4xrmIJegOocJ2OybMRUDZtJQjyHMJUEAU3TUYPxf1ihMlKjcg6sDhdl4yYNua5s3CSsjnfG2jgUCnHy5EkKCwvfkfON8Paw2+2sXbs2PQl3KBoaGtA0jR07dgwKtUcSUVoDHRzpqqE12knB6CJKSkp45JFH0lGRnp4eNm/ezLp164Y0dhMEAZfLxcSJE1m5ciWTJk1ClmWee+45nn76aV5++WV8Ph8nT56kuro6vZ9hGKxfv56amhrmz5/PBz/4QRYtWoSqqul23tbWVvbu3UtNTQ2CINDe3k4ymSQ3N5fVq1ezefNmANxuN1arlUQiQWtrK4qipIcHnkl2djarV6/GbDbzxBNPDDuL583QP68nLy8PVVV5+umnefLJJ3nggQfYs2cPNpuNlpYWVq1aNWTtxdGjR6msrEz/XFZWhtVqpbm5mRdeeIHnn3+epqamC15vlJWVxbJly7CO82LKGyxgHRNyMeVc3BckRVGGjdZd6siCyIa6Tn69t46TfWGeP9UxpEgpd9syhMgb4bEoXFdVNOS6UqeVYpeVHJuFyXkuRrmsmCWRSq8znQo6k60tvRzrOXedkcdi4hPTKxBJ1c3MLx6+cWN6gQc9mCBS30cynBh2u/cyIxGVc2Cx2bniho/w8mP30VhzKL28bNwklt74kYvWovzFL36RtWvXMmrUKFpbW/mP//gPJEni1ltvvSjnG+HCoigKo0aN4sCBA+fcTtM0ent7CYfDaT8PXzTAQ4ee5qVTWzBONzVmWd18fvad2B32QVbxbW1tdHV1nZe3hyiKOByOjBTGkSNHuOGGGwA4fPhwWliZzeZ0oW04HGbcuHHU1NTg8/mYOHEigiAQiUTYsGEDy5YtIxaL0dXVxfr169NCY+LEiciyTFFRER6Ph0QigcPhYPny5cTjcaLRKFarFUEQ2LNnD0ePHsUwDHw+35tyX43FYsRiMQzDSEeo+luP9+7dy+HDA3VmhmFw4sQJ4vE4hYWF1NfXM2vWLHbu3JlxzJ6eHhYtWsSxY8eYNm0aM2bMYP/+/UiShMfjoaGhgYcffpiKigpWrFhxwdxiBUHA7XZjuAxs11lJdIQJHOpEkEXc0woxZVuRbe89AfFOIYoi/brz+VMdfGTKKO4/1Eh3dOABnmczc9fU8mFblIc8riAwPd+NbpTyxIk2QgkVUYCZBR5uGl9C1uk24SyLiZurS1A1g60tPSwu8TIt141mGGxu6eVgVyB9bRNyXOcUSx6LCY/FRDihMqfIy45WX0YnEqQiL3kWheSWBixjvPRsrif38tFI53DFfS8yIlTeAKfHy8pbPpHyUYlHMJttWB0X10elubmZW2+9lZ6eHnJzc1m0aBHbtm27aFNbR7gIiFBcXDzs6tzcXERRxO1209raSnZ2Npqusan+dTaeei1j276on++9/mu+uOhjvPD44NqOY8eODZprMxQ2m425c+dmDOWbPHkynZ2dyLLMjTfeiKqqWCwWotEo999/P4lEAkEQGDVqFIWFhcTjcV544QVUVcXtdjNnzhxaWlqIx+Ns27YNSD1slyxZkvFGbrVa0ymurq4uHnroIQRBGLJ4tq+vL8OEbjgMw6C3t5eXXnop3RWXn5/P8uXLyc3NxWQyceTIkSH3bWhoYMaMGWzbto0bbriBZDJJWVkZhmEQj8fp7e3F7XbzoQ99iL6+PiKRCGPGjEkb0i1atAiA9evX09LSQlVV1Rte75tBEARMLismlxVbhRdBAEEcCYC/EaIAi0qyOdQVwB9P8qeDDVxbWYQiCvRGk5Q4LeTZzeS9hZZeh0lhcWkOk3PdxFQNRRJxmuRBBbm72/q4vCyHtRUFHOr089Sp1KiIhUVerhtXyI931hJKqGjnOW/LbpKxKRKfnVXBgc4Aezt8yKLAzIIsCqwmbE1BIi0BsmcV0/1KHd45JSNC5Z8Ri81+0Q3ezqS/C2OE9y6hRBjFbKKqqorjx49nrBNFkQULFiAIAj09PelUiC8W4MljG4Y8XiQZpT3RPWTHTX878t69e3E6nVRVVeFwOIYM3Z85lE9RFMrLy2lpaaG8vJyTJ09iGAaVlZU8+eST6X2ysrIQRZHdu3dndMP4/f50RGXMmDFpozaPx8OJEycYO3YsXV1dHDp0iGAwyLhx4ygsLEynuobr8Dlf59dAIMCDDz6YkTrr6OjgwQcf5EMf+hCqqp5zZlAsFkOSJKLRKIlEgqeffjo9GHDx4sX09vZy5MgRFixYwObNm6mvr8/Yf8WKFVx99dW8+uqrjBo1atAoggvFpTRj51KnN5YgqmpUeh2c6A3RF0vyxwMNWGSRcreNmQXuc9aGvBFnd+gMxcyCLBRB5Od7T9EaGvi32eCPUOyw8vlZY3ihvgurfH5jIiAlXPPsFubnCUxy2dB1AzGqktzSTORkL3nLxuDbn+o2HKqt/b3OiFAZYYSLgCiIHA+eSjufHjp0KO1QO23aNMxmM6qg09HRwcqVKwFI6mqGLfjZdIS7sNvtg4TKxIkTeeSRR9Jpoa1bt3L11VczZsyYQSZdNpuNBQsWMHXqVMLhMH6/H13XeeKJJ5AkiXHjxmV4wEBKCAmCMKhlt58dO3ZQVFREc3Mzo0ePJhKJkJuby8GDB7Hb7elJxfX19Vx11VUcPXqUSZMmsW/fvkHHcjqdQwoVwzDS4wj6pysfP358UH0PkK79mTNnzrDfJaTSW/2W8f0iDVLOuevWreOaa67h8ssv58SJE4NECsCGDRu47bbbWLp0KfF4nHA4TCAQwGw243A4cDqdl5T3yD8DO9v6WFfbzgcmlTGzwMPudh+abjAlz02Zy4pVkTC/CYHwViixW9jW1JMhUvppCUVp8Ee5dmzBW7oOu92MEteItPiJtQWxeq14p1QTONhB5FTKe0U0X9zP925wUaX6q6++ytq1aykqKkIQBJ544omM9YZh8O///u8UFhZitVpZvnw5NTU1F/OSRhjhHcFldhJVYwSEMKPKR7Fo0SJWrFjBxIkTsTns+IwQDU0NLFmyJJ0SMYkKWdbBE3/7KXMXD2qzraqqIhqNDqpdWbdu3ZCFnpquIcoiXq+XvLw8bDYb7e3trFmzhtWrVzNlypRBD39d1weZoJ1JMBgkHo9TU1PD+vXrOX78OBUVFRw4cAC73Z5ubS0uLqauro6amhoKCwsZP358xoM8OzubG2+8cZBnRzgcZu/evdx///3ce++9PPLIIzQ2NuLxeBg1alTa28Rms+H1ejGZTDQ3N6MoyrAmZjk5Ofj9fkwmE7IsD+kQu3nzZnRdZ+/evcN+9mPHjqFpGtu2beOPf/wjjz32GA888AB/+9vfaG9vP+8p0CO8fXTdoMEfJaEb/PFAAy81dFHqslKRZWdPh4/f7KsjOdTgnQuMqups7fQNu35Lay9m5a2LCdGqEG32o0eTRJsDtD5+hFBNyiPGXOBA+gfs/LmoEZVwOMzUqVO588470wV7Z/L973+fn/3sZ/zpT39i9OjRfPOb32TVqlUcOXLkooVRR3hz6IZOX9RPIJ56QLrMTrKs7kGzNkbIRBAEphZW88SR55lWOIleow+nYiesRqnztTEpu5KcIg9utzudosmyurl54lp+s+v+QcfLsrgZm1OOZ0EqkiDLMtOmTSMWiw3pSWIYBi0tLenoRCAeojXQwQs1rxBRoywqm82U/Gp6enqYNm0aGzZsIB6Pk5uby/jx4zNMyOLx+Dl9NARByHjQ19fX093dzdSpU2lqaiI/P5/GxsZ0G7RhGDz//PNMmzaN6667Lm2k1h+NOJNYLMbmzZvTBbGSJKUH5DU2NpKdnc3ixYsRRZH29nZCoVB6Jo2iKKxatYqnnnqKjo6O9DG9Xi+XXXYZ69evZ/Xq1YMKafuJRCKoqnpO/xSz2UxNTQ2HDh3KWB4Oh/n73//O7bffjts9vPgc4cIhigKjPTb2dvgA6AjH6Qh3pdeXu20ob5BGiyY1Iqc9f+zK4PqTC0G/bf5bRbYq5Cwpp+2pY8TbBzqazHl2CteO/4cstr6oQmX16tUZ5mVnYhgGP/nJT/jGN76R9jj485//TH5+Pk888QS33HLLxby0Ec6DuBrncGcNv9zx5wyh8qk5H2JiXiVm+dIzgbqU8Fo9XF99JY2+VgxS7q0Fnnw8ZhdOsx3xrOJIQRCYUzKVQDzIY0eeI66lOhVGZ5Xy2bkfIduaReHkfKqqqhBFkVAoxO9///thz28YBl2hHqJqjFAizP72oxzoPEYwHmJv22HWVC5jaeE8HnnkkbSPSldXFwsWLMDhcKS7d0KhEGazGVmWhxzKN3bs2AxhA6lUyuTJk6mpqUmnV9ra2rjiiis4dOhQ2gjuzGjF+PHjmThxYsZxIpFIRtfOihUrOHr0KA0NDUAqClNWVsbzzz+fEQnKycmhsLAQl8vFDTfckE5zWSwWkskkwWCQtWvX4vP5aG1txWazYbVaCQaDJBKp791ms5FIJCguLqapqWnI77i8vJzHHntsyHWJRIKWlpYRofIOMrMgi2dq2kgMYc52fWURjmG6bELxJH2xJI8db+VwdwBBgBkFHq6vLHrThbcOi8yi/Cwa/EML3CUl2YPcad8sistC0Q3VaOEkajiBbDch2RRk+z+eSIF3sUalrq6O9vZ2li9fnl7mdruZO3cur7/++rBCJR6PZ7y9nZ2vH+HC0R7q5nuv/TIjfB2IB/nea7/i+yu/zijP8F0tI6TIsnrIsnpSQkAYPPX1bJxmB2uqlrFw1GxC8TAmScFlduCyDKRD+iMwiqLg9XqHnMI7qqIcchS+u/kXNAdSRXbVueP47NwP88e9j9Aa7CCuJQknIiy/dhUAPW1dHD1whJdeeolVq1Zx8OBBamtr0XWdhoYGrrnmGp588sm08IBUdGLy5Mk89dRTGefvj56UlpamxUg0GiUWi1FWVjZodpXZbGbBggWDCoDPTDnl5eURi8XSIgVS4yZeeOGFQemq7u5uXnrpJVavXp02VTuza07XdZ599llmzJjB2rVricfjhEIhsrKySCaTbN68mdGjR2MymZg5cybNzc2D0jgulwtZlgel3c7kXBOSR7jweK0m/nXuOH6zt47e05bzZknkfROKKfcM9p8xDIOOviixhEpHNI5JFBCElHPtrjYfx3tCfH1BFdm2838pE2WJKQVuXmntoeWsOpVRTisTsi/MOALZZkK2mTDnvnONHu8W75pQ6R8pnp+fn7E8Pz//nOPGv/vd7/Ltb3/7ol7bPzt6IkY8EuDpoy8MmWM3DIOnj23g7lkfwCT/Yyr4C83Z0ZNzoUgKefZs8uzndmm12+0sW7aMRx55JGO5yWRi0rwpfOvVn6AbAy2QR7pqaPS38um5d/DgwadYWDaLhw4/y6HOVFfShJyxvG/NVezdtIsnn3yS6upq7rjjDkKhED6fj1AkxAc++AEaWhoJBoOUlZQiCRLrnl03KNIyYcIEQqEQbW1tGdOYN2/ezG233UZrayu7d+8mkUgwZswYZsyYMWTk4cxU0Lhx4zJSLP2FwsMJhZMnTxKJRIZMW6mqyrx584jH42zYsCFD6Hi9Xq655pq0M3BXVxdr1qxh+/btdHZ2IooiY8aMYe7cufh8PpxO55AW/TD4/jbCxUUWBSqyHHx1QRXBhIqmGzjNMm6TgnxWuiUYSbD7aAd/WneEbl8Ms0li6ewyPjqzjD8cbULVDYIJlV3tfawYnY/4JgqjvQ4Ln5tRweHOAFva+0CAJUVeJuS4yLKPRKLfLO+5rp+vfvWrfOELX0j/HAgEKC0tfRev6B8LPRknUrMTX28rDZG2Ybdr8DcT0xIjQmUINF0jGA8jCkJGJORiUFhYyK233sqmTZtoa2vDarVyxcplPF27Ed3QqcgqY1nFQhxmOwk1yeaGHZzqbeBjMz/Af7/6M6LJgQf00e5avuf7DV+//FM898izdHZ2YrVaMUywtWcPTf429hw+RJ49B7vJRse+Z/nszA8P6myprKzEarXidruJRqO4XC6i0SglJSUsWrQIl8uF1+uloqIibdI23LC/rKwsTCYTiURiUNGr2Ww+ZzQDGDJVlUgkOHkyZWv+yiuvDIrG9Pb2sn37dkaPHs2mTZu49dZbaWpqYsKECcydOxdJkpAkiZqaGjo7O5k/fz7r168fdB673Z62xh/hnaXfLG04NN1g28E2fvbwvvSyeELjuS11tHQGWXPZaJ6oS70w7+/ws7g0F9ubLID1OiwsspmZXuAGARzWEYHyVnnXhEpBQQGQ8j0401K7o6ODadOmDbtf/zyKES4MarAXLexDiwaRXTkIokzns7/CXL2QYk8uDb7mIfcrdhZglkZECkBCTRBKRpAFmbgW5+VTr7OlaReKKLNq7GXMLJqM1+a5KOdWFIWioiKuu+464ok4zcF2erUAJ3pO8b6JV2M32Xjs6PP0RPpwmOxcVXkFC8tmEUnG+PYVX+BQxwnuP/BYOvISV+O81rqb0RWjqZ48kb5kqpD66ZMvkdRSofS2UGf6/M+eeokbV13J3h27MZlSvjHxeBxJknC5XEyfPp3KykoMw8BkMmX87Q434+hM7HY71157LY8++ijt7e2MHj067fgbiUTOWf8x3L0iHA6zceNGrrzyymELZevr69Ombn/961+ZNm0akyZNQhRFwuEwTU1N2Gw2Jk2aRDAYZN68eezevTvtDZOXl8fq1atH6lMuUfoCUf60bmgzwAM13Vy/ohJZFFB1A7siI7/FNnNBFHC8ibTRCEPzrgmV0aNHU1BQwMaNG9PCJBAIsH37dj75yU++W5f1T0Wiu5n2h76D6hvoiLCOm0X+NZ+j59UHuWbev/B6y760lfuZXFO1HPM/QTTFFw2Q1FUkUcRjduGL+YlrCURETLKCpusE42H6Yn7cFgfff+3X9EX96f3v3f03Xqkfzb8uvBuv1XPRrtNqtdIe7eKeLT/l/ZOuYW7JdARB4I97B9JCoUSYhw89Q7O/nWybh/W1r3LF6IX857Iv8u8bf4h2Wqwc7a3lEzM/wObWnew9eoRPzL6Nu2d9gF9s/9Og8zYGWompMQoLC1FVlS1btuD1etNFsYIgvC17eUmSKC4u5iMf+Qj19fUUFhZy7NgxEolEum26tLR0yGLX+fPnY7cPzt83NDRw9dVXv+FMIVVVuemmm9ixYwcHDx6kpqaGiRMnMn36dHJzcwkGgzQ0NCDLMuXl5RQXF6fHBNjt9hGRcgkTjqn4Q8PPxWnpCOI2K/REEywdlYvpHNOsR7j4XFShEgqFMib+1tXVsW/fPrxeL2VlZXz+85/nv/7rvxg3bly6Pbn/7XCEt4ehaxinawMEUUQQM8OWaqCHtr99Gy2YWewXrdmFZHWSe9UnicfifG7mB/jt/keJqqnwuFW28NGJa3G21KG7ChGVf8y3hWA8zKHO4zxw4AnaQ10sKZvL8rGLkESJnc37OdFzily7l6UVi3Ca7HgsLl6t35YhUvqp6anjZG8D3mLPRb3mnS2pSMNrjTv41Jzb+a9NPxtyu61Nu/jK4k/zzPGNPF/7Mv64n+8s/wpdkR58sQA13XXURVt4vm4TALtaDjAuu5xSdxFN/taMY+Xbc+nr6mXP7t1AylV25cqVF9ReoH++zrRp0zAMg1tvvZUtW7Zw6tQpdu7cyXXXXcfRo0c5fPgwmqZhtVpZsGABVVVVSNLgcL3b7WbHjh3MmjVr2HOaTKb04MJRo0YxceJEzGYz2dnZaeFlt9vJzs4mGo3i8/kQBIH8/HxsNtsgo70RLi1Msoh4umh2KJx2M7FwkMtLsylyjlhlvNtcVKGya9currjiivTP/bUld9xxB3/84x/50pe+RDgc5u6778bn87Fo0SKef/75EQ8VoKWlhS9/+cs899xzRCIRxo4dy3333XfOmyv0CxQNI5lAiwQwElEEkwXZlZNRGJvsax8kUvoJH34Nz/xrMfm6KNv2Iv899xZCsoSBgVPVMXY8R7DxKJ7SCYhZBRf0c18KqJrKaw07uG/vwwCMzxnL9RNX0RPx8YNNP0+3DdMFm+q38+Hp72NK/gS2t+wb9pgbT77GtIKJKNLF+5Prj063BNpJaMmM+pOz6Yv6sCoWIskorzftYU3VCn645Tfk23P4+OzbsEhmcu3ZdIV72NG8lzJPMbdNuYHdbQfY1riXypzR5Ni9XFY2l3hnhDlz5lBSUkJubu45IyjRZIxoIoKIgU02oSi2QSL63J9RwOPxsGTJEhYsWICu62iaxsSJE5k5c2Y6xWS3D27/7sdisdDc3ExZWRmjRo3K6CLqZ968ebhcrnR9jWEYWK3WQbU0iqKgKAou1zszSX2EC4PbYWbOxAK2HRrcuGG3yBTl2vl0kZNsmxn3OWpdRnhnuKhC5fLLLz+nM6MgCNxzzz3cc889F/My3jZaNIkWSaIlVCSzjGRVkKwX742pr6+PhQsXcsUVV/Dcc8+Rm5tLTU0NWVlZw+5jGDqGmkQN9mDEoyCISDYXoisbQ0uix8IYwsA1q/6u4Y91ens9ESXZcBAaDmIi9RRMnJEG0qIhlOEv6aKjhvpIdrcQqdmJaHVin7CAkCSgCSJIMjbFikWxIA3zwNJ1fciHmT8e5MGDqXbba8evZF7pDNqD3fz1wOMDIuUM/rr/capXVJ6z9VgSZS62mfrs4mk8cvhZIDUb6FzYFGu65gQgEAtilkx0hLv5n82/4EuLPsntU2/kR1t/iwHohkZ7qBOHyc7XLvsML53aQoOvmZc1ncUlcyjNGoXL4RxWpMTVBG3BDh45/Cy1PfV4bR6uGbuY0XYvXlcRJsv5p0lkWSYrK4tIJJIemmi1WoecbTQU/S3D27dv56qrrsLlcnH06FFUVcVqtTJv3jzGjx+fjsZcqMnII1w62CwKH7t2Ms2dIZo7B1KAFpPEN++aR77TgttuRhRHRiBcCrznun7eaZKBOB0vnCDaMBDSt5Z7yF85DsV1cdIe3/ve9ygtLeW+++5LLxs9evQ59zHUJMnuZugXEoaGFu5DT0SRbC70RBQUMS0cTQWjEW0u9MhgHxrBZEGQzQgZNSiDBadoevciX2qwh/ZHvk+irRYEEctVd7O7/SBP12+lN+ZnbNYorqteRV1fEwWOXKqyx5Blc5NQE/RGfWxv3suJnjom5lUyq2gKLrMTfzxIXV8T0WSMf5l/F8FEiN5IH5sbdjCzaHLaj+RskrpKb6SPy8vn88jhZ4bcZuXYxcgXMZoCkGPLYtXYy3ihdhMNvmbGZY+mpqdu0HYusxPV0EjqAx0xFsVMQk8Jl4SWZG/bYapyKih05DGtcCKqptEW7KAyZwxff/F7A/UsXbW8WPcaX1jwMUqsRcNeW01PHf+56afpf399MT8/3tHAmrGXsdjdTHHJnDclVoC0P8qbpV94aJrGs88+S2VlJVdeeSWQqkspLS19S8cd4b1FntfGf39iIa3dIU409pHntTGuNIsctwVpZBDkJcXIb+McaNHkIJECEK330bG+Bi069PTXt8tTTz3FrFmzeN/73kdeXh7Tp0/n3nvvHXZ7Q9dQAz0MJSaMZAJBUpDsHgxdA10j1lFP9OResld8hNxrPofkzPTr8My9FtHuQo9HULKHNnUzF45Bsr074W5DUwnsXp8SKYBp/jU8GWnkt4eeoC3UmXLU7TrBo4eeY0bhJBJagpfrtnKks4aeqI9GXysW2cKyikW0BNp54ugLvN60m8+v+w/+d+tv+dXOP/Pj139HRVYZDx16ht6ID+kNjNp6In0sGjWLIudg34wZRZMZ5Sm5KN9FP3E1TiAeYsWYJXx58ado8rfxgSnXDSrgtchmPj7rAzx5dKCdNtfmpS/qz4h+NgdaCSUijM8dy4yiyeQ7chiTXc6f9v09LVL60Q2d3+y8H39iaC+Rvqif3+y8f8jo6rO1ryI4i4gGh2+Fv9BkZWWl08u6rnPs2DGeeeYZnnnmGU6ePDmSev4nwuu2MGlMDjdcMY5FU4vJ99pGRMolyEhE5RxokeQgkdJPtN6HFklelBTQqVOn+NWvfsUXvvAFvva1r7Fz504+97nPYTKZuOOOOwbvoOsYiYFQv2C2IVmdIAgIkoIW6kOPhdGSKlrYR6yvC6tJoevJnyK7csm9+lN0PvVTjHgU1+yrcc5ciWz3YBSNI3vlXXQ98wu0YE/6+LInn7zrvvCuCRUt7Cew+7nTH1ZErZjMy9t+k7HNNVUrmVo4ga9v/AFxdcB7o9xTmupg2fFnYmqM1eMuZ17pTP79pR9m7H/9hFXU9NSjGzq7Ww9w86Q15Nq8dEUG1/WIgkihM59wIsIHp16PPxbktYYdKJLM6nFXUJE1Co/l4n1XvVEfDx98mk0N29F0jVybl/dNuhqTZOJTc24noSU41dtIvjMXl9nJw4eeptGfmoTstrj43Pw7+fm2P2YcM9eejVkycVXlFYQSEX698wE+NPUG/LGhnaCDiTC+WIBs2+BcYDgRoSM89FBDA4OGQCeiFsSdO/7tfRHnidPp5MYbb+Tvf/97hi9LTk4Ol19++XmnkEYYYYR3hhGhcg60xGCzqMz12rDrDF3D0FT0eMqnQTTbECQZQZQwdD0V3TiNIIggCgiCiKHr6LrOzBnTueerX0Q025g2ZTKHDh3i17/+9dBCRRBS/xkGkjMHDA3V34Xk9KKFfBhnFlUaBsHdz2OavhTv8g8Tb63Ft+1Jij70nwiygmTPQlRSN2pTdhGCYqbg5q+iBrpQ/d2Y8spQsgqRXed2Tb2YGBjo8ZQwk105nAxmFsRNzKtkftkMvv3yjzNECkC9r4lnjm/ka0s+zS92/JkJuePY0jh4KN2YrDI6T4uSpK5ypLOGu2beOmikAMDVlctwmR08dPApbpx4NRNzK1lYNhNBELFc5HlI4USEP+55hG3Ne9LLuiK9/HLHX1g8ag4W2YLTZOOmiVcjSzJtwU5umXwNLYF2Chx5SILIL7f/mc4zhIQgCCyrWIRNtvDw4WfY1rwXTdcyXG6Hwhhm/Rs5eiqSjMQ71z3W351z++23093dTSAQIC8vD7fbPWQ78wgXH13V0WMqgiRc1Pq/fwbUSDL1LLAqCP8gNTYjMa5zIA0zwGpg/dDdCoamogZ7SXY3oQV70II9JLubUIN96GoCPRFF9XWS7Gok2dOKFvGjJ2LoagItGqQgL5cJYytAlDDUBFoszPiqykHzUdKIIqLVhWi2g66hhfrAMBAkOVOknEFg57OYckoAA9f05SBKKJ78tEjpR3FlYy4Yjb1yDu7ZV2EdNeldFSkAomLBMirl02Ho6iDjubWVy6nva0I3dKpyxlCZXYEiDvwutzfvQTM0PjXnQ9T5mugM93A2UTWO1+pJp3x+t+cBkmqC7y7/MnOKp5Fj8zI+Zyyfn38XSysWYGDwkRnvp8Jbhs1kxapYL7pIAYip8UEtw/1sadzFjMKJrD+5Gf/poZImSeHe3Q+woXYzdX1N1PU10hkZ+PxW2cLHZ32QDbWbMYDj3afQTotqwzCwKdZB5yl05HHXjPejSCZaA+0EYpkpIIfJQUVW2ZDXKIkSxbYssvInvZWP/5YRBAGXy0VFRQXTpk2jqKhoRKS8Cxi6QaI3iu9AOwl/lIQ/Rrw7jBqOv/HOI2SghuL4D7bT+vdDND90kN5tTST9w3f+vZcYiaicA8mmYC33EK33DVpnLfcg2YZW/noyjh4ZnDLSIz5EszXVcdNfyKgn0UK9iGYHkt2NFuhm4cIFnDhVjxbygaEhKBZOHD/OqFGjhjyfoetIFjuGoQ+Yt4kyxhD24elriUfQE1HCR7YQPrIF1+yrcVQvQHJ4kZ1ehDdZ+GloqbSSoeuIihnJfvHMriSrg+xlt9Ny31fQgr2UWbOQRRlVV9OCJNuWxefm3cnRrlpEQeC6Cas43n2SJ4+tRzNSJm1Os4ODHceYkj+BvW2HMs6hiDKb6rZx86S1PHDwSQB+9Pq9FDry+MiMm8mzZ5PUNeyKlRy7l0gySiAWZE/rQcyymTx7DlkW10UpoNV0je5IHwfaj9Lga2bpmIUUOHJ54MCTGQW/uqGT0JOIgohwuucoy+rm/ZPW8uCBJ9lU9zqfmfdhvui+m3AyiixKCILA8zWvcLSrlkgyyr8u+Bhf2/h9DMNg/cnN3DL5Gv6w56H0OaYWTGBpxUIeOvg0vz+9vNxTwidnf4gyTzGSKOGyOPjknNv595d+OKhl+qNTb8CsRjFZKy749zTCpU+iN0LSH8dW7MK3q4VoawDJquCeVoi1xIXJM1gYjzAYNRSn7ZnjxJoHUrO9WxvxH2in9NYpKO73dt3ViFA5B5JVIX/lODrW12SIFWu5h/xV44YMURq6hhb2DVrejxb2I1rsg4SMgY4WCyM5s/nsRz/CZVddy/d+8jNuWnsVO/fu597f/Z5f/+oXg8+nqaDrJPvaUbwFkA6/G2d17ZyFIKJkFZK9+hPE6g8Q2P0C1lGTaH/ou+S/70tYiqvOW6yowV4Cu5/Hv+s5jHgEU3452cs/jLlwLKL54txolJwSij/8XXo2/glt+zo+Ne1Gfr7vYSRRIsvm5pnjG9ncsCO9/dPHX2RpxUJunXwtNT11eK0ezIqZy8vnU+DM5flaG+HEgJ36oc4TaIZGb9THvy64m80NO+iJ9lHuKcUkmWjyt5Jnz8FjceGPBXny2HqePb4x7eJrlS18YeHHqM4dhyJduFC2buic7GvkP1/+SUartMNk57PzPsK9u/5G9xl1NCZR4fLR83CZU50uCS3JWG85N09aCwLU9tbzx72PYJIUdMNAPaMTaEfLPj449Xp+uOobPF/zCg2+FsySwj1L/5XHjjxPV7ib68av4r82/SyjwLbe18y/v/y//GDl1yhwpmbdlLoL+f7Kr7O1cSeHO2vIs3tZXj6XbIsTu8WFrIx02fyzocVUtJiKaJJo/tt+DC31t6P643Q+X4NrSgHeeSUorvf2Q/adIN4ZzhAp/WihBL69rWQvLkd8DxcJC8a5jE7eAwQCAdxuN36/f5DpUiwWo66ujtGjR7+tSv4BHxUNySQh2Yb3UTE0lWRvG4Y6dOhSUCyIJitauC9juWhxgCAgmu2ovnbWbXiJb373R9TW1VNeWsLnPn4nH/3wHShZBWkBYWgqyb4OZHcuWqgPyeFJtyjL7nwQxYzoTTyp0dDagWXb/bjKqjAXVyKabchOLwgisZYTxJuOEms+TsndP0bxvPFANTXsp/PxHxNrODhoXcEt38A2ZvobHuPtoEWD6PEoCaBPjxM1VLrDvfz49d8N2lZA4DsrvsyRzhM8dfxF/LEAufZs3j9xLfnOHP6y7zFO9JwCoNRVxOcXfJRHDj3DgY6jzC2ZhsvsxCyZWDRqDnaTDac5lSrYXL+dn2//46DzSYLI/67+DwqdF24wXU+kj6+s/y7+eBCv1cOKMUsocubRG/Wxq/UAs4qm8Kd9fwegKqeCuSUzmFsynVy7l0giypbGXfx+z4Pohs4Hp1yHqms8dOjpYc/386vvId+RS1JTSWpJTJKCLMlEkjHiapz79z+WIQjP5LoJq3j/pLVIZxi6GYZBQksgi3LG8hH++Uj6o8S7o/RuaSDeGR5ym7Lbp2POG0nJnQtd02l/+jjh2sEpbADJbqLsQ1ORHZeei/i5nt9nMhJROQ/elMGbKCGarWjnECp6cvA6I5lAcmWnu3euWrGUq1YsPWubGIamYhgGgpgqvJUcnpTAsdjRIkFEsw1dTWAYOnqgD9mdm5lqAkz5o3HNWk37A/+JoSawlk/BOWMljvFzsRSNxTVzFVosiMJ5CBV/15AiBaBn/R8w3fYtZOfFq2mRrE4kqxMFMGsq+9oPs67mpSG3XTl2CS+e3MzGU1vSy7rCPfzfjj/ymTl38InZt9EV6SGhJumL+fnD7gd5/+RreP/ktcTUOFbZgtvixG4aePv3RQP8/chzQ55PM3Reb9rNDdWrL9jn7YsF8MeDXDd+FdV543jsyDrWneigyJnPjROvwmvxAFDqLuLOGbfgMjvJPj0QsSPczb27/wbA9MJJyKJM4RDt1P2M8Y5CEiR8UT9OswObaSA6ZlMsJLQEJ4bwaennaFctgVgQUZRwn54iLQgC5negdmeESx89qSNZ5GFFCkC0xT8iVM5AjSYxVB1BFJDtqYi5IMC53BPewFnhPcGIULnACIKAaHOjRQJnpGH6V0pIFjvJ3oG0jyCbU0WzWhJBVjCGEDFnHAAwQNfQE1EE2YTq60TOykcN9iCabUjObIRYECMewdASaIGelFAQIBmJItqi2Cpnk+hswFBTqYNo/QGcM1bS+dTPSbSnIgqmvFHkXvM5THllqa6kYUh0NeKefx2CJBNvPkG0/iD9fi7J3lb0WBguolA5k76Yn+ZAG6HTnVaFjjyuGb8Cl9mBamgUOvL58obvAFCdO44VYxYjiRKSIJJt9/KNjT8Y5Oj67y/9kG9d8QWq88all+mGTjgRQRBSv4/uIYpx+2kcptD1rRJX48wqmkKePZvvvPp/6eXHe07xnVf/jztnvJ+fXXUPsiiRY/em12u6xvM1L6d/XlaxkJ9vu48bqlczvXAie9sOZ5xHEkRumXwtP3n9d/TFAlxePo8rRi/IOKYiynitHjpCQ7sce60eWoId/HHvI6ypWsbUgmqyrCOD+kZIEe8MY8o+d8pPEAXUcCL9UP5nRYurxDtDdG+qJ9EVRnaZ8c4rxTY6C9lmwj21kNCJoe9Dzkn57/lOqn8ArXXpIUgySnYJgslGSlwICCYbircIJAlECcFkRc4qRLTYEWQllX7RNETL8G8P/VGTZE9zyhJfU5GcXjhdTCuIIsmeFoQzOjMMLYHq70D1d6FHg+iRAMF9GzHUTLO64IGXMBcMuN8mOhto/cs3UX3DW+2roT4EBGKNR4ic2ImpYDQFt3wN2X06EjNEQa8WDZLoaSXR1Yga6DnniIU3S0JLUtvTwPjcsZR7Srh92o08duQ5frDlN/xy+59p9LdgGAYrxy5hTsk0fr/nIf536708dvR59rYeGtZ2/oEDTxKKp976usO9PHt8I/+16Wd899VfcKDjGP8y/y5Mw9ShTMqrumCfD1JFwtdPuJI/7390yPV/3f84OnqGoABIaipd4VTtioCAZmjEtQQPH36GBWWzeP+ka8i352BVLEwrmMg9y77IM8c3cKKnjq5wD48cfpZvv/zjjPoXu8nGlWMvG/ZaF5bNIpKM0uhv4Zc7/szvdj+APza0KdwI/3zITjOGpmMtGT7kby50EmsPoqvDW0H8o2MYBpH6PloeOkS8PYShGST7YnQ8V0Pv9ma0uIopx4Zrch7CWVOeFY8F9+R8hPdwfQqMRFQuCoIgICgmlKz81ARjw0iJhGQUNA3ZkweGgdrXTn/0QY/4QZRRsouQXDlogbMMsiQF0eo6vQ/o8XDK6l4xp1qRFQuqL7VO9XciO7PR42eEVA0dTreZWsdMJ1K7O/P4uj4oRmjEI4SPb8cz75pBn1EN+eh6+hdET+1NL0t0NhA69Cq5az5D+8PfwV41h2SgB9HuRnFlk+hupuuZXxJvOZ76SE4v2Ss/im30ZETz2y+mNEkKhzuP8/kFH2VW8RR+9vof0lOf1dNtzF6rh/E5Y/nZtj+k9ytw5FLvax7ymIqksKh8No3+FhTJxE+23pth+lbTU0d17jg+Mv1mfrPrrxn72k02phRMeNuf60xkQURHJzZMajGuJfDHgoMcck2ywuSC8RzqTH334ul3FE3X+MX2PzHGO4orx12OVbHQ4GvBHwuyv/0oZtnM7OKp2BUbe9sPsavlAKvGXnY6mpQSTldXLmXdiZfThcSSIHLzpLU0+Joz0jw7W/Zz/YQr02mgEf650KKpOj89rhKp68PQDVwT88heNIrWx4+gxzPFSNa8UsI1PUh2E/GuCOYcG6Lyz1fXpIYSdG08NeS60PFuPNMK0aJJrCUenBPy0OMq/kOdOCq82CqyUJzv/VTriFC5iAiilDJ4MwxEqyPVnRNoRVbMqP5OBlne62raqE32FqXSJrqWEiSifHqfgXSSFgmguPNSBmixcMZxDENDMNsx4mflf0UJc345vi0PZSy2jZtFYOe6QZ8h1ngYffZViGd1ACW7mzJESvqaQn2Ej27FNWMVtrEzMNQkvRvuI+vyD9D6l29mzBbSgr10Pvp9Cm+7B+tpX5S3g8fiZuXYy9hQu5mphdVpkQKpepGYFmfV2Mt47owUCIAvFqR8GIv7z8y5g+dqXsGqmClw5A3pTHukq4ZVYy+j3FNKva8JgFGeEj4798Pk2ryDtn+rxNUEjxxex4oxi8+5XUJNEFcTmM/o+hIFkQWls3jy6HoiySiaoWFXbISTqTTZyd4GTvampghnWd2UZ5XwsZkfoNRdxK6WA4gCfG7uR7ApVqLJWLpeJeu0Rf9XlnyatmAHkiCRa/eyqX4b0won8sSRFzKubWfrfsZml1+gb2SE9wqJngiGAIED7fh2tSIoIvmrK4n3RAid6KZgTRXRJj+xthCSTcFZlUO0JUDgaBc5V4wmdKIbyVrwT9murMdUBFlEdplRAwMvKJJNoWD1OFofPUzSN3CvU7xWiq6vxpT1j/NdvbfjQe8RhNPOsYZxOmph6IPrV05jJKKg6ymRI8mp4ttwIBUt0c/yRdG11HGTcQTFjOwpSP3nzkOPhlIdPe48RLMdwWRDcuYgWuz0vfK3jMOY8kcjmm0kewfXUyjZxSmxpWmoIR9qJIAaDhDYt3HYzxs+sR3H5CUkelqQHB4ck5egxyM4qhcN2TLd+9Kf0SJvPyXQb1lfnTsu/dA9k6eObWBaQTXN/sy5Mke6TjClYMKgeT4TcsfS4G/hWHctU/InsLNl/7DnfrVhBx+e/j7+34KP8v2VX+Obl32OMk9xOvJwIQjGQ2xu2IFNsZA1zAA/t8VFOBklOkQaK8eWxdeWfIbK7Aqeq3mF26fdOOj6JFHirhm3UOIsoNCZhy/mxyQrbKrfzjc2/oDHjz5PT7QvbQKXa/eyYswSHju8jqePvchjR57jlzv+QmXOGOr7mmkLdWYc/2xzvhH+8Un6Y2gJFTWYwLcrdY/JvbyCvh3N+Ha0INtMtD56hFhbCFOODUEU6Hi+Bt/uVkw5NiSLTKTeR2QIP6t/dPSECgJ4ZhThmVFE0Q3VuCaloqXZi0fR9XJdhkgBSPZGaX/2eMqh9h+EkYjKO4TQX5rdL1jOta0oIUgKosWBfroodsjtFAsgIFocKQfceAQwQFSQHZ6U020sjOzIQrQ60KJRQMBWvRD1yCaQZByTlmCrmE7r/f8+1IXgnLoU1d9F6PAWzMVjCR9+DT0Z55yPX0FCVCwku5vp3fiXlMASRGyVs8i7/gt0PvHjjKLheHv96Xbut58S8FhdLK1YwNamPbx0RncPQJO/lZN9jeTas9OzbiCVA36h5hU+MftD/H7Pg+m0yrzSGTx1bMN5nVcAXq7byqb6bdwx7Saurlr2pq47HA/jj4fwx4OYJAWHyU6+IydjG4OUz0l9Xwsfm/UBfrz13owJyLIo8+Hp72NP68EhU059UT+/3fVXZhdPY3RWKTk2L/+z4qtsqN1MS7CNck8pq8deRtLQePTwOrY370UzdCqzK7h71gd45kTKm2Zy/nhMkil9fUWufL60+FME4yESWpJALMijR9dxtKt20DXMKp76pr6XEd77RJv9WEvddG1LpS8km4IgC8TbQwBkzSnBt7uVaJOfaFOmv5RnRhGGqpPoCmdEEy51DMPASOogCqAb6KoOIgiSiHSe6SstmsR/sIOezfUZwXfP7GKy5pViyrGT6I4MuW+8PYQWTiAPY0r6XmNEqLxTCCIIAyJkWEQ5VWwrigiiCNjQRHlwNAXhtP+JgNrXnilm9CRqoAvZU5CaMSQr6foTPRYi2dWEa8YqJKeXpK+TeFstzsmXEdj9QjrSIyhm8q79FwTZROsfv0L2yo/Sve43qH1tiDYX2cs/TOjw5iE/Qvby2/Ftf4rQ/jPahA2dyPEdGPEYnnnX0rf54fQq2ZUNF9BTw6JYmJRfhVWxDHJCffr4i7xv4lX8bNt9Gcv3tB0ipsb5z6VfpDHQiqqpVOZU8MCBlCvt/vajzCmZxroTQ7c+zyqewsOHngHAN8zgvuHoDvfxct0Wnjy2noSWegsqdOTxufl3Uu4pSfuNWGULE3LH8ptd9/MfV/w//m3RJ9jffoTWYCeFzjymFVTz9PEXuaryChymzJqfaDJGTI3T6G+l0d/Kh6e/j50t+9nSuIuZRZMp95TSHe4lqsb5/mu/pic64PNzoucUP9p6L/+26BOc6m1kc8MOnGZHhpBymu1pX5mOUDftQ3QC3VB9Jd6Rrp9/KnQt9YDWkxpaLHUPsxQ6iTQOCJLerY0UrKmi+5WB6IBkU8i5bDSiWaLtiaMAWMsuvX87hm6QDMUxkjrJ3ih6UsOcawdRQA3FiXdHsI/yEG0JEmvyI7vNOCpzEC0yAimPE/GsAlhd01PirCdCz6v1g87p29lCwZoq9PgbzKKLJUn4ov8Q6bIRofIOIYgSBmLKK0VNpqIlsdCg7WRndoYjrCgrKNlFaIGe0wMODQTZnOr2OT0LaLiIixbsRbS7MbQkomxGVxOIFjvx5mP0Hs+MNrhmXUXxXT8g3nICyelFEGWUnBICO59JRWxCfah9qZSJHgmgR4NYx8wgenJPxnEkVw6mvHK6nh7sogupVmj33DUZyzwLb0B2DJ66+3bIsWXx7Su+wA+3/DY9cE8RZS4rn8uE3HG8b+IaHjuyLu2oaldsXDN+BV2RHvJs2eQ7cjDLJibnj2dny372tx/hynGXsavlQMYAP0i1OmuGTm/UB8Ck/PPv9NENnf3tR3jk8LMZy9tCnfzXKz/jOyu+lPY6cZjtfHj6zXz9xe/zSv3reK0eGv2tZNuyaPK38lzNy1xduYxx3tEZx4qrCfa1HyYQC1LgyEUSUlb5m+q3AbC9OVVrVOou4mDn8QyR0o+qq2yofZXF5XOo7anHF/Wj6zqiODh7nO/I4b+WfYl9bYfZ3rwXp9nB6nGXU+TMx2Ea8cT4Z0IQBSSbCUM3sJa6ibUEMDQ94+EcawvS/UodnplFKG4Lgiwi2RXinWF6tzahxzWULAvmnEvLvTgZiqMG4yR7o3RuOImhDkTKndV5WEtcCAZEmwN0vXgyva5vZwv5q8chmmUiu1rImluCIAjocRU9qePf14bisRBrGT4dHjjUQfaioUeqACCAkdDp2niK3GUVoBkggGhR3pNRlhGh8g4iyApoAggqgtWFaHUCRqorKBlHlE0IimlwXYMBSAqyJ/XAMrQkaqAbxZ2Hnhi6pTa1XQJRsaAGu9ES3WhJHQQB19y1RF57ECORentRsouxjZlO55M/RbK5cEy5AiMZR9dVrOVTkBxZRBsyZ+H0bPwLOavuxF45m9CRLRjJGPYJCzDljkLt6xi2BgdAi4YQZBOGmsA5YyW2cbPf0vd5LkRBpDyrlP9c9kX8sSBJPYnb7MRjcWGSTawdv5wl5XPpCvdgkhS8Ng9ZFvcgt9T3T7qGvW2HUXWVx4+8wJcXf5K9bYd5vWk3iqiwfMwiLLKZn57uIhrrLafAkXve19kV7uWxo0MbxoWTEY501mSYspW4CvmfFV/hoUNPE1cTXDN+JV3hbsScMdw14/24La4MQzqAznA3P9n6e0rchaypWk4wHh6UFoPUjJ7j3ScHLe/naHctH5xyHWbJjCRIQ4qUfnLtXlaMXcyS8jlIooQsjtxqLjS6btAbiOELxTF0A7fDjNdtRpYunc4YQRBQXGYMVcdZlYN/fxvR5gDuqYX49w9MPU/6YunOFvfMIhSPGclqIufy0YiKhGCRkG2XTn1TMhBDDSbQ4yodz9cM6osIHunEnGsjeLQLa4kb5/hcgsdORxl1g871tZTcPJmkP0ayN4r/YAf28iw6njsBQNbcknMOZlRDCQzDwDE+h9Cx7kHrnRNySfRFcU/Op+3xIyR6Us8Jc76DvFVjMefY31OTlUfuHu8kho4a6AKE1ADCUN/p6cYios0Jkpya3aOYz9hFRwv2oMfD6BnpyFSBrnCulMnpdJORiCLa3EhI0NeArWIGrqKKdCFusreVno1/wjp6Kvbx8wgdfBXbuJmpAtu+dszF40l0njW5WVfpfu63yJ58HJMvw1JcieTJR5Qk9OjgSNGZKJ58cq78GObiKiSHB+kc3jFvlyyre0iTMYtsxuIwD6oDOZsiZx7fWf4l9rQeYnrRRP7jpf+l0JnHpLwqNEPjqWMbuHHiaiqyyhidVcqVYy8n5010+ui6Rtc5DOPq+poyflYkmTJPMZ+ZeweRZAxREJmSP37Yol1N19jevIdrxq/AIpsxSSbG5+QP6nyC1CTms1NGZ+I02VF1jcn5VeTZz/299TPiQvvGRGJJQpEEhgF2q4LjDR7I8YRKPKFR1xbgh3/djS+YeqBZzTJ3Xz+J+ZOKsF9CBl+y3UQynCTZF6X4xon0bm0k1hbAPa0A/772jG0VrxVXdeoh2/d6I4meKLLbTNa8EuyjvSiXgA28ruoET3Qj2RQSnZFBIqUf//523NMK6dlcT8Ha8QNCBTCSOglfFO+8UlofP0LB6kranzmeXp/oiWDOdxLvGNq111KQqufLXlCGZJYJHOrA0AwEWcQ1MQ9LiQvJItP6+FHQBy4w3hGi+YEDlN0+/T3VFTQiVN5B9GQcQ00gu/MyPFRAR4/4MeJRZG8B5eXlNDQM7lr5+B0f5KffvQfR6kC0OjA09XQXjcBQfy2i1Ymhqciu3FRh7WnTt96XnqdwxYeId9SnLM0Lx5B/47+hRUOIJgui1U7Hoz8k/6Z/w1w4Bj0WxjlzFaGDrww6R/+05r7XHiH3qk+m0lQWO9aKaURP7Ru0vZJbRryzAf+2Jyn84Lcuqki5EAiCgIjI5Pwqfrnjz4QSYWp66qg5wzr+d7se4J5lX8QmW3BbXOeMNJyNKEpk27LoiQxOtwCMyhq6bdqqWLEqb3yj8ceCZFk8vFS3lUgiSnVeJWXuIuaVTGf9yVcztt3ffoR/mXcnL9e9PuSxlo9ZxJisUWiGTq49G8Mw6Iv6CSUiSKKI0+xIDz88F/FkHF88QKOvFUEQKHEV4LI4sQ3zeSKJKIIgYlXe/YfUhaalK8Qfnj7EriMd6AZMGpPN3ddNpjTfiXyWSVc4mqSlK8Tjr9SyekE537r3dVRt4O8+Glf56YP7KPy0g4kV74wb9PkgmmSEUKqwU09oeBeUgSggSCLO6jz8B9rRYxqOqmxku4loS4Dulwb+vlR/nK4XTpKcFSV7QRmi6d19bGnRJPGOMOZ8O2rw3FEPyapgaAaGPvj+rCc0DE1PtR9LInpiwEcmfKqPouurCR7pzEgpAQiSgON0+7bZa0MwSRRcXZUKvJ9O6wQOd2Ak9AyR0o+R1Akc7MA9vRDZbnpPRFZG2pPPg1gsRm9vL21tbfT29hKLxd54p7MwDAM9EkSyOtHCfoYSFoaWwFCT7Ny5k7a2Ntra2mhtbuLZh+8H4IZr1yBnFdBvo99fJKt4iwaZtQkma2r4YagPQTZlTGtOdNTRveE+lOxilJwSQEgNOOxupuUPX8b/+hMpLxY1gRbyEa07gGS24Z533aBrNpeMxz5hPoJiRrKlHCYli4Ocqz6JubgyY1slp4Ts5Xfg2/wQqq8jNWbgEqcn0kdPzIckyjT4WobcJpgIE0qEybJ53pRIAcizZ3P9+FVDrrPKFibmVg657nwIxEL8Zf+j/GbXX6npqaMl2M6Gk69yzys/YdmYhdjPmlic0JIc7z7FB6ZcN+hYMwsnM7t4Glk2D5XZo9F0lb1th/jBa7/mGxu/z/977tt8Z9PPafS3ntNtuCfSx5bGXexrO4yOTlekh3pfM3W9TWn3X0jV1bQG2jnaVUttbz3razexo3k/fVH/sMd+r9HRG+FLP9/MjsMd6efJoZM9/NvPNtPaFaKlM0iXL4qm6cQTKlv2t/CvP32VaFxl64G2DJFyJg+8cIzQJdaaKlkVul6pI1KfMnozNB0tnKB3RzN6QiNvxRi0qAqyQO9rjUMew7e7lUTwzd97LzgGJPuiyDYFS+HwnYrmfAeJvlTKZSgxYM5zEGsLpYb1nI1upIuMz5x1ZMq1U7BmPIFjXUhmmdbHjuDb2ULbU8dof+oYLQ8epHdrI87xucQ7ho9sR1sCJPqixFpTNUNDoSc1koEYSV8sVTA8zHbvBCMRlTcgGAzywgsvZEQ4ysvLWblyJU7nm2+nFRQzRnj4m60eC5ObOzAM0DAMnn/lNSrKy1h65Rq0cB+SPQs9GkCPp9JIotWJkl2MkYynoiyKGUNNpKIdopRKJ51FvPEImr+Tjkd/mKoXOas7RnLlYCTiGLIJc8FoIrV7kNy55L/vK0Tr9mMkE1jKJ2HEo3Sv+w25az6NZB9IsSjuHHLXfIZkX1tqsrPNjRrsoeupn58Waqdrdi5x2kNddAQ7sb9B9OLs7qLzRRAEZhRN5ppwD8/WvJT2J8m2ZvH/FnzsTdW7nE1npJstjbsGLY8kozxy6Fm+tPiT/Gbn/bQGU1GxCTljmZRfxdGuGr6y+NPU9JwiriWoyhlDR6ibjSdf5bZpNwHQFexDM3QWl8/BZXZiYPDo4XX8x8Yf8b2VXyPPMfiNvivUQ0SNMiZ7FIc6jrO+9lVGeYrpDHXT5G/jQ1NvwGG20xf18+jhdbxUtxVVV5EEkQVls8h35PDrHffzyTm34XmPdw/pusHWA60EwoML4eNJjb+/VINuwK6jHVy7pIIl00v41WOp4Z+5HistXcM/hJo6Q/jDcTRdx30JpEogJVTylo+h+cGD9O3IFPz5a6oQzRJaJJmKMCSGscs3SEUwst84ancxEc0Skk3BnOdEDcQQrTJ6dPA91jOziK6NpzDl2Ej2ZdYSOiflIWAgSKn2ZcmuIMhiRvQk1haka+MpPLOKyFvpAgMiTX66XjlFzqJyujfXDzqnIAlEm/xkLx6F5DAN8ljpR3akuo1Cp3qR7KZUAbNVSRc5J/0xfAfasZW4EM0yggB6VE19drsJ8R225B8RKucgFosNEikA9fX1rF+/nquvvhqLxXJexxIEAdHuAk0FUUzb2Q/a7qxCuGQyyd8eeoR/+dTHQU0gObLQgn0pFS5KoCXRIz6MeATJ5UUPhTBCPhBFJIcnNfRQEFJtzwyc01ATJHvbsZRVEzurUBYga+EN6GqcRFML5sIKonX7kV059G38E+aSKgRJpmfDfQNOs7pGrLWWSM0uBNmEvXIWgslKzwu/R4+F0BOxjAJbJbsYyXbpP2wCsRBTCqoJJcLYFOuQ84AEQXhTdSlnk2P3cn31lSytWEBfLIBZMuEyO7FIJroiPSQ1FUmUUiMAbB40XaM36iemxlBEGbvJhnOIlMv2psHOwf3sbjvIB6dezzcu+xcSWgJBEJBFiW9s/AF9UT+CsJ5yTymyKLHh5GvE1ThXjr0cSE2c/u2uv2YU3rotLj45+zb+su8x9rQe5MrKyzPO1xJo54EDT7Kr9QC6oVOdW8ktk69hU93rtIY6WFA6i/ZQFxbZzN+PrEt3JEHKVXhzww5iapxSTyGn+hqZYZ38lr/vS4FYQmXH4fZh1x+p62X1gnI27WnmyU0nKc51oJ5+o+3yRSnKddDSGWLm+DwkSeTwqR7q21J/i0U5dvYe72TzvhaWzyljemUeOZdAi6op20bZh6YRPtlLpMGH4rHgmpyP4rIgyhKOsV60QTYMmVwKM2sks0zOknIijX1Yi90UXTuB7k31xNpSXTqy04x3QRnh2pSLdf7qSnpeqwdRQHGa8cwswlLsouXvh8i/chyiWSLpj5G9eBTdL2dOI1eDcURFouf1RrLnlZH0RclbNgZBkTJ8ZZwT83BW5qDF1ZTYMCBrfil9rzdhqHoqunJGAM45IRdD1dEjSZru35daVp1H1qxikAQCx1IW/L49rST9MUzZNpwTctF7NUxeC+bcd1YsjgiVcxCJRIasFYGUWIlEIuctVABE2YQWj55O//iG3saS+Q/giSeewOfzcefHPo4gKQiihOxK1QekHG6N1HA/LZGOnEh2F4JsRov4MSLB1NBDVw6JUADoSB+779UHKfzgtwkff53Ang0YiSiKtxDPguvRkgmspdV07vwxSlY+ktObGoSoJojVHxx03XosROjwawR2P5869it/xbvyTvJv/CJtf/1WhkgRrU7yb/wissNz3t/du8UoTwnPHN9IZ7ib6yas4m8Hnhi0zdLRC96246rdZMNuslHkKqAn3EtcS7Kj4ygv121FN3SWjJrL5PzxJIMqrzfv5slj6wknIpglE8sqFrFi7GJcZkeGYBHPMfVaRKDR18K25r3cOvkaCpx5xJJxqnMr2dK4E1mQKHEVMKNoMqIg0OhrZWbRFOJqnIcPPT2oO8gfC/DLHX/hw9Pfx+tNu1kxdgnS6TRYV7iHb738Y/xn+Msc6TrBf276Kf+28BP8YMuvOdpVS2V2BZ+c8yFebdg+5DXvbNnPVxZ/ihdqNzExrypjRMB7DVkW8ZxjBovLbiIaU1k6q5Sls0qRRIFv3jmX+rYAz71ex+1XVTOm2M2W/a0kVZ0rZpaQ77Xzy0f3s3pBOb978hB9wThH6noZVejkWx+df0HEihpOpJ53mp4SDaKAfJ6Fu4IgoLgteGYU4ZpagCAKGUXgisuCHg5jyramu1TORLIpSPZL45FlyrIiSAJ6UgNFIu/KsaAbp29zBrGOEI5xXrLmlmAYOrnLxqSFgqHrROp95K8chznXTvH7JtGxvpaC1ZUUrK0icLCDpC8lDlyT8wkd68ZS6CThi+KeVkjSF0Oxm9KlidmLR6GFk7Q+mSqcFRSR3CsqkN0WLIVOBEkke0EZwaNdBI91kXP5aBS3hZa/H0ILD6QI/XvbCNf0UHzzZBSnheYHDqTXxdtDBI92UbC6kkQwgWR7ZydaXxq/9UuUePzcTohvtP5sBElGsrsxdA09ERsi3ZKb4aEC8Pvf/57Vq1dTVFyMoabako1EFBARrXZEqxPZkyrO1eNRRJsr1V3kHxAkRkJFTUQRTK7MdIskAwb26oU4plwByQS6lgRDx+jrIHJyN+55awjsfp6c1R+n7f5vnf4cCqLNiR6LYCRjSHYPSV8n1jEzsFZMx1ATxFtr8G1+GMsHv0XxR39EvOUEic56TAVjMBeNRXG/9ZTGO4mAwMZTr2FgUJ5Vwsdn38Yzx1+kJdBOti2La8evJMeW9aZrU4ajN+Ijosb5v+1/pK5vIFd/sreBq8YtxaKYeezIQDtzXEuwruYleqN9XDnuCiq8ZVhOd9rMLpnK40efH/I8s4unsb/jKK837eZQ53G+u+LL5NlzuHnSGk71NfDh6TfzWsMOfrn9TyR1laqcCmYWTcYfC/Faw84hjxmIB9EN/bRJ3cD3saf1UIZI6SepJXml7nUWlM5kU/02TvScoq6viUJHXjoddTZxNYH+Bs7O7wVMssQ1S8bw2v7BYysAls4qxWFTiMTVjKLZFXNKuefuBfT4o6iqjj8U52SLn4MnuynJc/Dtj81n465G+s4o8mxoC7L1QCtrF1e8pZEOfYEYYkJDawlgcpoRTRLJvhiJngiK24K11IXkNCGbzz+VO1TqQLIpiLqZrOVldD1RmzGkUJBFsq8sR7RfGuliQRIxZdnQkipaMEHgWDfJ3pTPlX1MNqIi0bnxFFokSfldM1HcmS+05uyBuhPFZaHw2gmp+3Q4iclrw1rqRg3E6Vh3AnOxi6wx2XS/Wk+kLlV0755RiH2Ml6QvhmiS6Nk88EJdcFUVfTua0xEegD4gd2kF7umF+Pa1YSlyZYiUfizFLgxdp3PDYFdpdIPuTXXkXD4aLa6OCJVLBbP53PndN1o/FIIkI0gyclY+qGrKxE0UES329BDDfhoaGnjxxRd57LHHUsWuPS1kdApFg+iJGLIrB8nuwlBVRIuNZNfQk4D1iB/h9DA5c1ElOVd/AlNuKWqgh9DBTURO7UOyubGNnY4gySjuPCKn9uGcshTJlYtz+goUTy6yKyc1PNHuwdCSoJiRbW6CB14mfGQLhprEOnoyedf8C+FjO/AuvhHFswgmLnrT39e7ia4bdPh70lOBnzq2gSJnPsvGLCLHlkUgHmKMZxQxLX7BHp4JLcnRrpoMkdLPhLyxgxx1+9nWvJdrJ6zCHwtgceTSHenFIplZUj6XV+szIxQus5OlFQv50ZbfAKkZQlsadrF09AKyLC6+uvgz/OC1XzHaW8b7J19DOBFha+MuvvnSD/mvZf+GRbEQTgxt3d0X9bN41Nz0z3E1cc4ZSce6a1k7fkU61fNy3VYm548fVqiYJIVlFYvec9GUaCxJJK4iAGaTRDypYVEkblo6jr+/VJOx7aKpReRmWalp9PH05pS3iCDAx6+fQjia5Bu/3kpvIEa+18Y1iyuYN6mQv75wjObOEFsPttI0RBHlC9sbWDKjBM951Kyoqk63P8re4500d4YYPyqLCo8Nm24gmaTUHJngQG2NaJIoumEiUrH8tmdbWRxWdEEl76ZxRBr96D1JBLeEfXQWssuCyXz+Eex3AkmR0USVRHsIc74dPaHRs7khIy0Taw8OEipnYzq9XlAkkr4Y0WY/SAJ5K8ciO010PHeCeOdAsXngYCeF14xH9cfo2zMgdm3lHqLN/gyR0k/XS6cour6a0NEuTKejLWdup2RZ0+LHSA59P1NDiVQkbPh6+YvCiFA5BzabjfLycurr6wetKy8vx2Z7606JoqSApCCahw/H3nfffeTl5XHV6tVowR6GbNjXkqkCWpMV0SSArnPmhOUMDB1BEMm/5RvY3VlI1lQxsOLOxbPgepwzVqYKcnUNNdCDHg6QtfBGJLsHPRHFOfUKup7+PxLtAyPHJWc2BTd/he4NfyTeeDi9PFp3gFjTMQpu+QaGpiG8Bw2/kkkVhcw3uNZgB3/Z92j65++v+Dr1PbVMyB17Qc4Z1xLDRiwMwyCpDd/N0Rf1kdSS6IbBt17+X/51wd1cPW4ZM4sm88qp1wklI0zMq2R8zlh+v+dB4mc4Gu9qPUBSV2kJtHNj9WrunHkLL558jRdqN+GxuLhm/AoSWpKHDz3D8orFPHnshSGvYVz2aLKsrvTPkijitgxfdO4w2YmdMfdJN4xh633KPSUE4mGmDjHH6FJD03T84QSiCPGERiiS5EhdLx29YSaNyUEQ4MipXuZPLmTBlEIO1naTUHXGlXo41tCHrkNzV4hJFdkcre9lxZwy6lr9vLBt4M25ozfCvU8e4v3LK5k3qYBth9rZtKeZtYsr2F+TOcJAH6JNdbjrPt7Yx7//ZiuJ04WdT22GHI+FX31yEV0v1GaIFEi12bY9dZSSD0y5IHbtNrsTw+ZAcigYGAgIWOzOCxa1vODoOuFTvYRPDZ6sDqRHB5wPoizS8dwJFFfKoTd0rJu85WMyRAqAkdToeO4ERTdORPUPROad43PpeqXu7MOmibYEsBa7SPREkF1mOEOouKcV0LujmewFZW9wkQJI72xL83vv6fEOYrFYWLlyJevXr88QK/1dP2+mPuXNous69913H3fccQeyJJI4lwNtIoposiCIcirCcS4EAZMnD+msaxdECdk28IAxZRVkrNdiYXpfuj9DpABowR46/v59PItuyhAqkCrY9e9aR97az577mi5RZFnCrFvJsrjpiw3u1BqdVUooHmF28dRBjrZvlXO19r6Ru6tNsWFVLPx651/oi/oxSQo/ef33RJJRPjz9ZnojPna17ueJo4NFhl2x4Y8FONF9is5wT8bAw65wDzU9dVxWPo9RnmJmFk0eUqhUZJVR6MzNMHmTRZlVYy9jc8OOIa/58tHzMnxbFpfOI99SSpl7R8bgyGJnAZ+c8yE8ZjdZl3gRdl8gRkdvGFUz8LrMNHaE+J8/7UQ7LRaef72Br94xm25fhC//4jUEYGyphwWTCynMthOJqYCBxSSTU2LlhivGYrcofPWXryGKAnOq85k7sRBZFjhyqpcXttXzyRunsu1QO5puIA4R1Vg6qxTXeTi79vhjhKIJ/vWDM2nqCPL8tnq6fTFkSUSLa0O+qQNokSRaKAEXqGhXEARszkv799yPaJJR3BaS/hiSXSHnigpM3tPfg24gWM7/MStZFVzV+fTtTEXFLaVu1CE6wyDVPgypIuV+ISMoIvo5hJEWTSKYJEzZNiJnDYCUnWaS3ZFUxOSsDqT09dkVZIfpDSNEF5oRofIGOJ1Orr76aiKRCPF4HLPZjM1mu6giBeDFF1+ksbGRO++8M7VAEIe3pRfF1CBDSUptI0hgDNFVJMogvDV/BSMZI3py6C4S1d+FklVI7rX/QvjoViI1u9PXGqs7gB4LI5ourZDt+SBJIl6rm09OuZMf7/1VRguyx+LikzPuwGGzvq2On7OxyGbmlkzjWPfgHPGpvkaqcsYMaXOfY/NiVSyIgsTRrlqKnPl0hXvSKZQHDj7JmqplHOmqGbQvwLKKhfxuz4OsqVzG3rbDfHj6zbgtztTgNEHipbotbKrfxleXfIYsi5sPTrmex44+RzQZQxAE5hRP445pN5Fl9Qw6dp49hxsmXMljZ9XLzCyaglWx0uRPha4rssqwqvl857cH+NiNt1AyW6E32keW1Y3H4iLXfumYmA1HXzBGc2cITdfZcbiDFXPL+P5fdqVFCsBNS8fx+KaTGVGP4w19nGz2UV2RzYPrj9PYMSAInt1Sx1fvmI3DZuLzt0znZLOfo/W9hCIJRFHg/31gJpwWuPMmFXLwZKalekG2jerR2SSSGhbz0Ld8wzBo7gzxm8cPsL8mtf+4Ug9f/OBMkqpONK6lzzEc2nBtxf/gyA4Tucsr6NhwkuIbqgke7aJ740m0qIop107O4lGIooDieuN7oCCJuKcXEG0NkDWziGQogTxMus41MQ///nY8M4pSNv5AvDOMpcRFrHlojyrb6Cx6Xqsne8GoQaJTABAF/AfayV5cTvfLmS+lCJC7dAySa4gxLxeZEaFyHlgslosuTM5m5cqV6bdrwzBSlvvBoa3WJatzoLbldP2L2ttGZqpIQHZlIwTb3tL1pDqKhr9RJXta6NvyGPZxM8m/6Ut0PvnTVKTHYk8JqfcoLo+N3h4XX5z0WdqSbbRHOilzFFPmLqHAnoPFemFrJRwmK+OyRzM6q2xQncqB9iN8YvaH+P5rv8qYTuwyO/n8/I9ikU3E1NTb1zXjV7CnbSDC1RHqAgPmlkxPDyHs57LyedgUC5+eczuyKGNVLNhNVrxWD/54kNreeuaUTOfqymV0Rnqozh3HmsplLCybRSQZxSSbcJsdwzrlioLA1MJqJuZXcajjOKquMbdkGmbZTHekly8u/DiarpNjKuDrP9tLNK7S1qGyeFIFY7PPMXjtEiOR1NIRid8/dZhZE/Jo6giSPOvNdEyJm7++cGzQ/vMmFbJhe0OGSAHQdB1NN/jszdMQhFSNi2EYzJ9SSHGug/aeMKX5Lgq8Nq6cP4qdRzro7EsZxc2dWMiS6cX8+72v871PL6JgGKHSbz4Xig68yNQ0+fjGr1/nG3fO4eeP7OVHd81HUCSM5NCC5J1+y76UsBa7KLlpYsrU7tSAy3SiK0zrY0coWFOFYRjIdhOiPHT0VYurp2cjWchfNZaWhw+hhhLkr65EcphSEaszsJV5aHv6GKIikr2knL7tTQQOdpC3cixtLYFBt2vFa0XxWMheMIruV+uwj8nGNTGPcF3K7kLOsuAYl03oeDeK00zh9RMIHGhPdSDl2MmaXYLiNiO9C+MZRoTKewBBEJCsTvR45HTHzwCSw5tqWz6tcAVBQDRZUHJL0SNBdDWOqFgQrY50qPCtIJpt6UGCQyE5vWjBHgK7nyfWcpzs5XfQve7XuGZfjWT3vOXzvtuYLTIVlbmEAnGcfW7GW8fj8lix2kyY30RI93xxmB1kq0k+OuMWGnzNvFz/OrqhM7t4KsXOAo521fDFhZ+gLdhBc6CNfEcOJa5C9rQe4sFDT/GFBXfjMjspcubTFuzMOPZ9ex/mfRPXsGjUbI501mCWTIzLLqfB14JmGPxp399pCQx4e2RZ3Kl24foddIa7MctmvrjwblRNxWw2kWM/v0iS3WTjQPsxsqxuqrIrsJqsHOms4anjGwglwjhNdtZUrsAXthNLqLjsplRL7iXgmXG+JJMa9a1+onGNvkCcjt4ImmYQjGT+vVhM0pAmb5ASKj9/eN+g5YYBDouMx2WhtSvEuLIsqkdn89Tmk9x38gijCpzcuHQc37hrLvf8bhsuu5m51fkU5NgRRYF4UmNMsXuQYOpH1w1e29+aIVL6UTWdjTubmFNdwB82nuCu2UUEtzYN2s45Mfcd7QK51BBNMno8miFSzqT71fpU8avOoBk7yWCcSIOP4KEOBEnEO7+U3p0tqKeFSe/rjeSvGkvn+pMZlv3Cab8U3+5WbKM85K0cmxIRkkDxTZPo3lxPvD2EIIs4qnJwTkh1WvbtbCHeESLa6Ee0yjjG5eCeko9kUchZUk68PYR/fzvB4904q3Iw5zuxlrkxZVsRlXdn4OWIUHmPIEgyiicfQ02ix8MgnO4UkuRBgwkFQUSQTQhOL5JhpIYXCgKC+tbtpyWHB9ecNfi3PjZonWXUJBKdDel0T6K9DkE2Yaucg6N64TseJrzQKIpEVraNrOx3Zsx8tj0Lt8WJ1+ZmYn4VhqGT0JKIgsiEvHG4zA5ybFlUeEexvWkvf9r3KP5YgNFZZXSEOrl50hp8sQATcsfx1LEN6a4l3dB56NBTmGUzH5xyHd2RXn6y7Q+sqVzGk8deyBApAH0xP/fu+hs3TLyK3+y8n7ga54dbfsuPrvwmdvP5fxeSKHH56Pl8ZcN3uWHCarojvRlDEYOJMA8ceoJl5Zdx9w0zmTGukHzvpT0DCk6neTpCvLa/hcoyD6OLPZh0g+ONqYfVq/taWDE3MyKUSGrDDgyUpJSoOJvLphcTiau01vXgdphp7QqR7bJw3WVjCEUS7Dnexd4TXfy/W2eQ47HS1h2mcpSXPcc72XawDd0wmD+5EGmYAsh4UmXPsc4h1wEcb+hlzaIK/vD0YaaVe1mwciy+rY2ooQSiRcYzswj3lAKkiyDc30vE2od3C1YD8ZTwCCdSrrCnH/jJYJzWvx/K8I1xTy0gcnKgMDfpi9H54km8C8oQzRJoBqJFRjSJyG4zqj8ldCINPhS3hZylFXRvqsM5PpesOSWgG4RP9WKoOoZupH9PgiRgL8/CMS6btieOkjWnBPf0QopvmUy8M0ykrg/ZZcYxNhvJaXrXRAqMCJX3FP2tzefqFMrYXhCGniPxFhBlE+45VyOIEv7tT6c8YEQJe9VcHJMW0/n4jzO2j7edJHvVXcjOC1e/8c+ELMlkn6P2xWaycrjrBH/e/3eybVn826JP0ORv5WDHceaVzCDfkcszx17kQ9Nu4C/7HkuLFYAydxFeq4f79jyMgcG47NHD+q10RXpxmGxIgohm6MTVOE2+FvLeZL1Inj2b7638KtFkjK+s/+6Q27zSsJnvLL0M67s8dO586PXH+N8H9mAYBjdcMZb12xr4y3PH+NqH56Rt6yMxFd0wmF6Vy97jqVSdbqT2Lclz0NyZ+WBraAswodzL0fqBh5TDqrB6QTnxpM6Tr56i6Yy00PjyLD77vukc//mrhGMqv3/qEHdfNxmzSeLXjx2go3eghfyZ1+rYfqid//nMIvKyMkWmLEl4z5G2cTvMhE9HW3797BGqPr+E0lunIBgGgiS+ZwbbXWwk2xv8uzVI29prMRU9riI7zWTNK6VzfS1GUkd2mZGcZgqvGQ+AGkni39tKoidK5ws1CJKAd9EogjuawIDcKypoe+Jo+hRJf4zeLQ2pTqGuMKHj3ZhybGTNKSHWGcK/uQ1Trh3X1ILTAqaPtiePYqg6gUMdOCbkojjNKE4zjjGXzr370r8jjHDJINs9eBbdiHPaUvRoCNXfTeTkHjof+99B3UaCYmLk1nVx2dt2GJOk8PFZt/HrnX/BFwtQmV3B9pa99EZ9uCwOanrq+PLiT3Gyt4GknmSst5zeqI+fb7svLV7kN+hYCicimCQT0dMRub4hzNveCEEQUESF+lAz2jBF4Zqh0+7vI6BLZJ1H4eG7ya5jHbR2hbj7+sn81x+2pw3Z9h7rZNb4PJ7YVIthwLfv3cYPP7eY9TsaeWFbA+Foki37W/jiB2fyvb/soq17oO20psnHR9ZM5Ku/fC1dfPu590+jNxDnwQ3HM0QKwLH6Pv7w9CFuv7qaXz16gEA4gc0iU9PkyxAp/XT5omze18L1l41FPENYKLLINYsr2LRnaP+l5bPLeGLTQAF3PKljcpnf85HSC405z4EgCRhDDIu0lXuIdYRwenJoX3eCRNfA791a6qb0tqmpCJUs0bm+Nr1e8VjIXjSKwJFOIqf6MDQDa5GL3tcaEEwSSraVohur6d5UT6I7gmiWsJa60WIqWiyJd14polVGUCSsooBkVlIC5WQvgSOdmdOVReGSvWePCJUR3hSipCC689DtWQQPvEJw74Yht7NVTEMwvTOpkn9Wcm1eFpbN4uW6rUwpmMAV5fPRDB3d0LEpVsyyic31O/jJ1t9R4Mwl357DlPwJ/HTbH9J+LLn2bNxmJ4qkDOvR4rG4iakDufHRWaVv6XoD8eAbPtxkQWHD9kbGFHtwnEc77buBPxTnqVdPcuX8ch7acCJjivFDG09wz93z+fRNU/nlowcIRZN84aev8pmbprLic4vp8kWJxlUO1nZzw+VjcdlN+EJxst0W2rrDxJNJ7vn4fB5Yf5z6tgDZbguBUILG9qHbgncf6+R9ywYmbLvsJnafI42zaU8zK+aU4bJndpIU5zi45+75ROOp1tbG9iDPvV7P1HE5qJpOW0/qwVmS56CzL0xJnuOSGXh4qSC7zBSsHU/bk0czClllpxnPzGJ03aD92eMkujNFZLTJT8+rDXjnl9L80MEMs7WkL0b7s8cpur6aaJMfW6knLYa8s0tQnGZEWSJv1VjUQAJD1Yl1hhAVCTWYoO2ZY+QsLk9FcJIaRkIjdLIXk9tC4Zoq2p89nhZW7sn570qh7PkwIlRGeEuIsoJn3rXEGg6T6KzPWJe19ENI7nwky4hQuZjMLZlOva+J/e1HmVU0mcZAK48deS41VBCBSflV3D3zAywom0lcS2BTbGDAfy/7Es+e2Mix7pNcN34VWxp3sWLMYtadeGnQOaYXTqKm51Q6+lKVM4YcW9Zbul5V1+iO9FLkzB/SebbImU9Hp4pmGMQTGo5L9J+PphvEEhrFuQ5qm30Z65Kqzjd/s5UPrZ7Az//1co7W9xKJJXE5zDR3hHDaTRyp6yXXbcEXSvDwi8dTEQpZ5ObllYwu8qBpOivnjqIox05zVwj5Dbrm+sVFXpYVm0XBJA+/vUmWBnWDaLpBlz/KgxuOc6QulXaqLMviq3fMprbZx2+fSM32ynZb+Nh1k3nq1ZPMHJ//Jr+1f3z0uAqiQOlt0wjX9qCGEpjzHUgWmb7dLWQvKBskUvoJn+xNzQUayhHWgMDBDvJXV2IkdZL+OI7xObiqc4k2B2h/6hiWQifu6YXoqoFjrJfWvx/G0Ayy5pUg2RRCJ3qINPoQTRKuCbkoHiv+o10Uv38yWiRJtNmPpeTS9a0ZESojvGVkVzYFt3ydRGcDkZpdiFYn9qq5iDYXiuvS97x4r5Nt9RDXErjNLroiPfx+94PpdQYGBzuO8e1XfsJXl3ya9cc2sb1lP19e/EmC8TC6obOsYiHjssv5za77uWvmLVw7fiXrT75KNJmaynz56PlML5zE/269F0WUWVg2ixsmXoXb4jrHVQ2Py+xkfc0mPjz9ffxi+5/wx89wxTQ7+ezcu/jvXx7lEzdOIpY4fzfPdxqnTWHuxAL6S8DOthdRNYP7njmCphssmVbE+u2N/N/D+xhb5mHRlCIqS9wIokBlWRZTx+WiyAI2i4LbbqInEGPrgTb8wTj5Xhvl+S5MikR5oSs9HflMJFFA1w0UWeTOtZP43ZOHWDStiEOnhrYyWDy9GPUsl9rO3jBf+vnmtOABONHYxzd+vZXvfXYxt6+eQLbbCgL88u/7uWnpuEERmX92DMMgXNND54aTWEvdeBeWoUWSJPtiSFaZvGVjiLWeO2Wqn8OHJtYZwlbhpevFWspun46tbAxaTKX1sSOgG+li2pwrRtO9uxVDMxAUCUdlDi0PHkwfWwN6tjRiKXHhHJ+LHlNpf/oYWfNKMdRL1wdnRKi8RzB0HUNXMRJxwEBQLAhSajaQYRgpnxNNxTAMBFk5PTfo4rd3yk4vstOLtWIaWjSIEY+lhnqetusfCi0aRIsGQTcQLfb3xBTlSxGzYibPlk1NrI4nj60fcpvuSC8nuus40l2LYejsaT3EpLwqJuVVoRoa/ngAl9nJ73c/yIzCSdw98wOIoohAamKyXbHyzcv/BV/Mz66WA3z7pR/zn8u+eN6tyWeSZXFxddVy/rDnIT4y42aiapz2YCcFzjyKHYW8uLmHghwrHqcJq+XSDEEDKLLEmkUVbNjRwLRxuew9kSqUNSsSJXkOkppOc2eQiiI3tc0BinIdvH9FFbuPd/D6oXZWzxtFlz/GTx98HV8olVKrKHbzyRun8POH9yFLIh++upr12xs4WNuNzaKwYm4ZdovC/z2yLyPVtHRWKeFokq9/ZA5/31jDicY+7rhqQkYBL6SKcqeOy8FlN5E4o7NI1XTWb2/IECn9xJMaz752CrNJ4tGXawlFk4wpcTO7eiSacjZqKEHP1pTvUbTJT8uDB1E8FkSLTLIvSsHVVUjnSpUJKfv84ZAdZpK9EdzTCxEtMpJVwX+gPbPGBFCc5rRLras6l95tTUMKoFhzAPeUgtQ6QaB3SyOmLCuW/OHHXbybjAiV9wCGrqUe7sFeRJMVBBEj5EMw25AdHvRkHNXXcYZzrYBk9yDaXYiSkjKO01X0RBxDTZIMdGOSchGVt/5WZBgGWqgXLRxIeatIMoHdLxDavxHJ7saz8EYc1YuQ7O6MfZLdTXQ9+2viLccBULxF5Fz1CcxF4xCVoWsSDF0HgWGFzz8zdrMNs2we1Fp8Jo3+Fj5aeQ3ehEyypQ2bGqZy1Bh2hU7y2JHnuXLcZTx86Bn2tB1iT9uh9H6iIDKnZBr/vvGHxLSBGpXa3vq3JFRkSWZ+6Qxy7V4eOPAk4WSUsd5yyh0VnDqVpDjfyqr5o4hENLyXeDFtQbaNZbNLmTUhn/q2AGsXV1Ca7+REYx9mRWJaZS41TX2MLnLz53Un0ymVbLeFOdX5/OivuzOOd6rFz7fv3ca/3TYTA/jun3aeIR6i3PvEIWZNyONfP5AqwpUlgeWzy7hpWSV9gRi7jnRwxaxS7r5+MrpusGRaCUumlVDf5mfWhHxiCQ1/MI7TZkI6o5A2GlPTTrRDcbyxj2uWVDC6zc2V80cxsSI7FV0ZAsMwCEVSdU7OfzJPFUPVB00jTvpiIIBzQh6iRUYQBYpumkjoWPegQlbnxDwEZfj7W9acErRYAkuBM+1XE+8OD7s9pCYhd74wtBM1QLTRh2tKQdoqv/f1Rqyl7kvSD2dEqLwHMNQkhppE9uSjx8Kg64h2F4IooyfjoGnInrxU7lkQMNQEWtiPIJtQ9XDKWl8QUUM96PEwoYOHEIrHYB1VnR5M+KauR9eIt52i49EfpN1yBdmEe+5ashbfTN/mh+lZ/wdUfzfuedemfFwUE1qwj9Y/fT01Mfo0yd5W2v76LYrv+gHm/PKMc6j+bhJdjYQObgJZwTV1GXJWPoIoIdlcCNLIP18Am2LFYbITSgy+ccmizFV5s2j/xe9oPXI8vbzg8x/nschrdIS6WFaxkDnFU9lxxpRjRZT53Pw7eb7mlQyRAnC0q5Z5pTPe0rXaTTamFlRTkVVGJBHHMAxiUSiw6XT1xREMibElby219E6iG3D0VC+lhU7+59OL+P1Th/jzuoE20b++cIw7rqomGldpaA+mU0Qr5pTx1OZTQx4zFE2SVHVe2DZ0hGPX0U7WLqrgp//vMhRFJNudqklxO0w47Saefe0UT2w6yV1rJ/L3l2ooyLaxZlEF//OnnYTPmP8yvSqPz79/Gl63FUUR8TiHf2HJcpqZN7GQJdOKsZqHj3J1+6LsPtaJJAqU5jtQfBL+cBxFFsnz2PC6zcjSu+fDcbERJBHRLKHHz4heCFBwVSWRBj8tDx1MFa2KAs7xORRcXUXHuuMYuoGzOo+sWcX49rSSvaScntcaBkSMAJ6ZxSguc8pZ1jEgImwlHkJHM0VmvDsyMBX5dPu4oQ2T0pFEtMiAuEr0xTDOc3jlO83Inf4SRNM0vvWtb3H//ffT3t5OUWEBt3/gFr78qTsHuibiIZAUFHceKDJJXztoKoLJgqCYUTz5qKE+RLM1FW0RJGRHNoLUS7KriXCgHcnmwpQ36k0Xvar+btr++h9YK6bhmPgRwECQFGLNxzEVjsE+YSGR2t34dzyDrXI2RiLluRJvrckQKWkMnb7ND5G39nOIZita2E/S30XPC78j3jrwRhA+9Cr26oVkLXofid52FE8eijvnbXzT/xhkWVysGLN4SC+UpSWz8T++jtAZIgVAdDnp6kqJzF9s/xM3VF/FsjGLaAt2YjfZKHYWsKv1AC/VbRl0zGJXwaBlbxan2YHT7AAgJCdJqBrFXnnYWTSXGr2BKPc9e4TLpheTm2Vjx5GB4mCvy0K228JTm0/xtQ/P5s611WS7rOyr6aIox8Hjrwy0+ooClOQ7EQWB5s4gFrPM7mOZhcal+U6WzirF4zATjqlE4ipjStzYTqfHLCaZ4lwHt19dzc1xDbNJ4p6759PRG+Ge328jdlbof+/xTh7fdJLbr5qAxSRz4xVj2XlkcHEzpOYSvVF3T7cvyn/ft53brpxAU2eIPcc7efjFGlQt9aZuNct84dYZTK/KxXyBPHK0SDI1WsQiI1wCDsayXcEzq5jeLQNjL9xTCwif6iN49IxJ1rpB8EgXhqpTets0DN0g0Rsh0RslcKAD+9hsiq6dgBpMiXjFbSF0ooekP4ZjbGbdn63cM0gc+fe3k79yLG3PHCd8shdHVQ6Bg0P/bl3VeXQ8dyL9s8lrRXiHpyKfL++Nu8K7jJqIoCZDqMkYsmJBVhzIF7H19nvf+x6/+tWv+OMf/kD1+Ep27d7NXR/7OE6zzKc/esfAhloSLRJAtDmRHV4QRYxEFEPT0NU4sisbQz2tmA0NNdgNkky8/SRquIfw/2fvrePkKuz1//excZ9Zl7i7JyQkgRAI7m6F+qXu/VVu2297udVL29teatBSSnF3C4EocXfdZH3HfY78/jib2Z3sbIAWSqD7vF75I3POHNuZOc/5fD7P8+xYQXDJJ3BPWPCOQgPT+9cTWHgdaiJMx1O/xiiYT9z2IZNwjpmDpWoQzjFzUGPtGJpG22O/wDVuHmqso99t5o7tQUvHQZJI7lyFnkmUkJTjSO1YgWPYVJK71uCdcR6CALLn35useGxuzho2j6OxZtY2bym+bpUsXNawgF0/+1qf9xSOtdLgrem2z9d5aPvTyKJMyOEnp+W5ZPQ5rO+1reNQRJlJ1WPe1eN3ORTg1J1JKYdMViWeylMVcPLUcrNCUhN0cuN5Y0hnC7R0pqgOOsmrOrsPR3hxzWYWTKmjemItFX47R9uTLJk9iFnja9h/NIqmG4xoGIPboSBJInp3Of7WC8ehyCLPrTpERyTD4BoPl58xvGw+oM0iY+smAnarzJ4jkT4kZfRgP+fPHYJVkTncEsfjshLy2rn6rJE88PKeknWvOHMEQ2r7KkHyBQ1V00lnVTI5lXS2wBVnjuCVdUeYOa6aPz25rWT9TE7l9r+8ya++cgYVPjvRRI4jrXEUQaTGa8OjiNjctpKWg2EYpgJGFEpmN9REjtSBMNGNLRiajmt0Bd7xVf3mDOmajqHqiIr0nprSCZKId2I1hWiWxHZTHu4YEqDl8R1l10/u6cIzvormR3fgmVCFb0oNCJDa10VqXxeSQwFBQOuOW/BOqemzDdljpf6aiaW+LLqOjkHjTZOJb2/DMchP+kgUNVZaFfVMqiZzLG62p7oRnDsI+RS1BBggKm+BfCbKoR0Pkejq+RK7gyMZPPZKLGWSYt8NrFy5kosuupCz505DdgdprKnk7wvmsnZT3xuHnk0iOjwIskKh6xhF7WE2gSbKKP7qnjRlTTXt9cWeP3vXi3/CMXTyOyIqWi4Lao7Y6idKXs8c3IyaCOOdeT7tj/4M+5CJ2IdOxshn0NMJJFdfWavkDuKesAAlVI+hqxS6mtHzGZLb3+h3/6ndq5HsLhKbX8Y9cdG/PVEB0w/lEzNu4MpsjEORJtxWF43eWixdKQy1bxsh8cxLXPn56/lZ9N7ia6qu0prswKk4mFA1mkPRoxyOHisudyh2vjrvUwTt/5g8+cMERZYQBXDYZeKpPCGfjU9eNoE77t9ItFcei89l5es3T2fjng6WbTxGbYWL65aMZn9TFN2A7/9xNQDjhwUpqDpTRlUwf3Idr6xr4pzZg2gNp3l2xcHi9nYeCvPDu9/kazdOpzrgLDFuOxHtkdLq5fwpdUwcHuIPj28r5g0FPDZuuXAsbofC9z42m/3HYlgtElNGVhL0WnH2Ct1MpPIc7Uhy8FgMWRb5+4u76IxmEQT44adOI+Rz8MKqw2WPRTfg2RWHGDnIx6/u31jsbFgViS9cOoEhaZXK6aYvSCGeJbUvTHJfF5JdwTelBiXoAE2n5aldZJt71GKRVU3Et7RSf81EFJ+tWHHW8yqFWI7ohmYKkQy2Wg+eCVUoHut7VoGRnRYqzhhKYFYDhXjWJFgn6aQcH3KNb20r5vEkd5mtnN4tSgYBggABAABJREFUGWu1C7lMe04QBKwVTuquHIeWUUHTEW0Ksst0CvZOqkbLadReMpb04QjpQ1FEq4xnQhX5zjSdr5mfK0EWCZ4+CNsp3HIdICongZpP9yEpAImuPRza8RBDJ1z/nlRWTjvtNH7/u9+x70gLo8eH2LxlKyvfXM+Pv/fNMmt3JyyXSzfWVdREGMnhRktFiy8Hl3wMi54ntXsNye3LybcdRPG//Ul+x+DxtN7/o7LLCp1NyJ4Qgs1F5uAWMvs3Yq0bSXr/Bqqu+DrJLT0ZL945l2IJ1RPf8CKZIzvxCGJ3dpHYUwkqd8aFHILTR3Lb67gnnoGWSyO9g+yZDyu8Njdem5vBvvria7mMgex2oyZKDcOyrW0E1u3lE3Ou5W9bnyBVMG9qDd5aPj3zRmrcldw0+XIuHn02xxKtOBQ7lc4QAbsX6S2cbP8d4HVZmDW+pmh7P31MFX98YlsJSQGIJnP8+oFNXH7GCO58dAvPrDjIdz46C7tF4vt/XEOl386nLpvIjoNhNu/tYP/RKLdcOI5NezuYPb6G//en1WX3//vHtzJmcICQr2ewNZUpkEjnzRBDh8LIxh5C6bDJLJhSzw/vXlNSjQnHs9zx941856Oz+K+736QyYH6PhtV5aax2l2z7mRUHWbbxKFecOYI77u9J4DYMSKQKBDzWso64x3G0PQEYJUKVXEHjpw9t4n8+cRqRDc34JlZz9P6txUoCQHJ3J8F5g7CEHCUk5Ti0VIHohmb802rBIiFZJJIHIrQ93dPuzByNE93QTN1V47HX/nM3ZMMwKCRy6OkChqojOS1mKrJFQrLJSDYZS8BOvqv/awEUyYfitWFv9GKrcoFukNzTIy231XuoOmcERkFDTerILitaXkPPqQiigORQkB2WPpUQXdUIr2rCNSJI1/IjGJqOrcaNoep0LT+Md0I1NRePAVHA4rche6z9pjqfChggKieBWkj2ISnHkejag1pIvidE5etf+yqRtmbGT5uJJElomsb3v/Elrr3s4j7rCordHNTrx/HTyKcRnB5IAQgYhk7ns3ciZ+O4Ji6k4sLPoKsFCvGu7iFVd0nIoV7ImQGIck9pXpAt6Nn+A7jy7UeovOTztD3438TXv4B31gV0HdtDIdxMYPGthF/5C86RMxBlhY6nfg1A8KyPEF3+EIEzbyR7dBf2YZNJbCgvubUPm0pi8yuga6D3L4MeAFj8fhqvu4YDv/tDn2WZjdsIzZvAx6ZfiySISKJEW7KDlng7wwODcVocOC0Oaj0DctQT4bApfOyi8fz0b+u4atFIdMPok91zHM2dKYbVefn6TdPpimaxWSQef60JWRK57crJ/PL+jYTjPSX4o39aw9dunE5XLHui+rSIaCJHIp0n5LNjdO/7949vZVO3VHr0ID+fv2ZKMVNo/uQ6XlxzuGzLSNMNVmxuZvqYKlZubQHg4Vf2MLSuZw4mksjytxd28dGLzEHdE6HIIm3hNI3VbjqimT7LAQbVeGju6HuNdANe3dbCZYODdK04UkJSjiMfzpDtx50XzFaKJeQwb8Y2mfbn+x6joeq0PbuH+msn/sPKFkM3yLYmaH1qd0+SsSjgn1mHb2ptCWGQHAq2WndZcmWpcEK3Ckjx2rD47WhZldDCIQTnDkLPawiySCGe5dgDW1GTeVyjQ/in1RFec5RMUxTRJuOfVodrZAjJqaAm8+bsjqYj2RX0nGb+XzfId6ZLzObaW/cBYKt1U33BqFOapMAAUTkp1MLJ04bfavk/igcffIj7H3mcv971B8aMHMbWnXv50le/Rk1VJTdedVmvNQVkd8CUH5f7BTqO4wPkdhdGh5nsamgFEhtfwtBUPNPPpeWe7xBc/BEEi/nDp/gqyB3bTXLbGwiKDe/0JSgVjchOL6LVjiApffJ9jkNyeEjvXY9r/HxSu1aZkmogsfU1vDMvpPbm/wKg+Z5vYx8yEUv1MCzVQyl0HSPfcQQtEcEz5RxSu1ajp0tNkpRgHbI7SKGjCcHqQHIH3lHb6t8NgiQRmncahq7T9PcHUJNJEEW8s6ZjvWIJP9r0F9KF0hvLD8788vt0tB8sVAYcfPPmmUTi2bIqnd4Ix7P8+J51NFS5qa9ycfasRvxuK8s2HC0hKWBm8nzvD6v5xk0zTrpNXTfoiKYRgK/9+g2SmZ7v467DEb5z50p++Om53P3UNir8Drbs61+GfKQtwehBPZLzjliWvKpz/DFs816TAIV89rKEbO3ONgQMlswZzIbd7X1+jhRZZMaYKr63vLziqTmcxjKzka7XDpU/QMM4afyCIAoYqkHHqweoOncksttCIdL397kQzaJlCv8wUSlEMxx7aDtG75Rr3SCy+iiK14Z3gjlorqbyaDmV0BlDaX9hbwlJUAJ2QvMHE3nzKKGFQ5CsMukjUaLrjpGPZlC8dkILBtO57BDpg+bvteRQcI+p5Oj9W4qW93pOo+PVA6QOhAktHMKxB7cVW0aCLOKfXodglXCNDBLuKC9ldg4PIryPqchvFwNE5SSQlZPfAN9q+T+Kr33963z9a1/linMXgaEzadpMDh9p4me/+QM3Xns16BqixY7o9IIooadj/XuiSAoYOpI7iJAvFAdfjyO57XXck88idP4nia97Ac+Us5AcHtoevL175sVEevdqXBMWElx0E5LLj2vyIhLr+6pMjs/LJDa+TNWlX0RLRcm1HQIg37If0epAS0ZBFKi+8mtkDm4lc2gL9oYxWGqGI9ndhM77JF0v3U3lxZ8nuX056X3rESQZ94SF2AaNo/2JXwLgnXE+otVBvuMIot2NXGYGZgCgeDzUnHsOgVkz0DNZBEVhb76dH6z9Ezmt9Om1xl1FlWtg5qc/GIZBJJ5D1U3b+4DHRsBjo7UrhSQKxTDB3pBEAaV7ILSpLcH3/rCa7350FhfMG8oX71hWdj+ZnIpFEbFZpD4DsQCDazxs2tvBI6/u5YvXTmVovZctJ/ihdMayPPXGAT539RSyOZWdh8I09+O9URtylhCm0YMCOHopsLTum2O+oOO0K8U05eN4ac1hvnjdVMLxDLddMYl7n9tVNLOrCjj40rVTWbG1ud8K0bh6H6Ig9jEwO4704SgVZw0jube8465rVIj0gTDZo3GMvEb1BaNpfmR7yaxHEf+gAtfQDdKHoqUkpRfCq5qwN3gpRDIIkkjrU7sACJzWiOy0oKbyZjqyXaHliZ3IbiuiLJJpjiMAzmFBXLIpc1YT+SJJAfBMqCKy9mjZwMP0oSj5rnTRDwXM6lF4dROVZw/HNTJIYls7hVgpcVMCdhyDfcinaL5PbwwQlZNAVly4gyPLtn/cwZHIius92W86nTZdZXXzKU1LhJFkCU3XkZze7laHgCDJplIGA0QJyR3q9jXp+TDLniCCpKDFOtHTZUrTuoYARN58Fs/EhcQ2vIjiqywhKceR3Poa7smLkBxevNOWoEbbyezfUFwuuQNUnPdpul7+M+imS67/9KuJr38eBBEMnfjGl3BPOhPFVUHL339QrJioyTDeGecRXf4weiFL8KyPYGgajpEz8E4/FwSR2Prnaf37DxEsVvzzr8E+ZCJN//cZ0DVkfzUVF9yGtXY4onxqTq6/nxAkCVtFRfH/g7JOLhy9mCd3vUi+uzI2tnIk/zHjRvzv0ZD4Bx3RRJblm5t56JW9hONZ6itd3HLBOMYMCeBzW7lo/jAee21fn/edNbOR1dtKDfnufnoHX79x+kn3t+NgF7ddOZn/+fsG9F43cKdN5qbzxvDbRzaTSBf4rz+v5Vu3zGTrvs4+lYwNu9q5evFIKgNOrl48knU7+0pVBQFOn1zHf/9lLQCyJHLJgmFYej1pTxphfnZe33iUs2Y08sTr+0u2oekGv3pgI7/92pkIwNghQTI5FUUW8TotBLx2JFngqTcO9DlGh01m5rAQoiLiGOIvuUEXt58uYAk6cA4PktpXSlYUvx1Hg5foOvM3yzAMWp/aRcUZQ2l9plSWL7ssiLaT3/Z0VUfrJmKSXSmqjnRVO6nJmhrPYag6ie0dIAnmgCvQ8coBBElAtMroOZXKxcNBEHCNCKIXNLRkHsmhINpMN3HDMNBzpQTLWuUisqZ8ujVA9lgCS6WT7NHSCnR0YwvVDR5qLhlDYmeHSfQEcI0M4RzqR3Z9MH4rTwmi8pvf/Iaf/vSntLa2MmnSJH79618zc+bM9/uwkC0OBo+9srzqZ9yV75lE+cILL+T2//4xdT4nY0YOZfO2Hdxxx6+4+cbrTcWOYYAoUgi3QvcTsZ6OI1idyL5K1Gg7gmJDdgdAlMDQMQrl+8YAgqzgHnsaXS/8Ad/pVxFd/lC/6yY2vYRRyJPeux7f3MvwzjgPPZ9FEET0XJqul+6iEG5BkBSUYB2SO0Bg0U34T78KQysgWuzo+TThZQ8WSYp98ET0TJLw0h4FSvtjv0C0u/HNvQLJFUByuPDNvADvtHMQLHYiyx8m8npPto0aaaXlb9+n/uM/xxKq73PcxluUjv/d4LW5uXTMEhYOmU0qn8EqWfBYXbiszvf70E5JpDJ5/vb8Lp5f3aNqOdqe5P/dtYbPXz2ZM6Y1cNnCYfjdVh5+dS/xVB63Q+HcOUOo8Nv57SObS7bX1JYgV9CYO7GGl9c2ld1nfaWb5ZuP8Z1bZ7FtfyfNnSkG13gY0eDjnmd30hnNYrVIFFSd7Qe6GDM4UHTAPQ6Py1IMNWyodPP5ayZz56NbyXVXaRw2mY9dNJ5X1zeRV3Uaqtx89qrJVAdLf9sCHhtL5gzmhdWHWDSjkSkje6IDwFTvfOuWmQQ8NpR+5h0aqzx8+5ZZ/PaRzXR1P90PqfXw2YvGE3RasPhshBYMpulorE84n3NE0MzMOWsY2fGVxDa1YGgGjiF+LD4bbc+bv8/WavPhsRDNouVUFK+tp5IgQOXZw096cy5Es4TfbDLVNwK4x1Tgn1GP4rUhIGAJ9f/9kL1WtKyKvcFL8mCYqvNGInSTnNTeLhK7O0E3SB2M4Bjixz22EjWRpxDL0vHK/mK1RHIoVJ03Enu9h8xx4mEYxdTkchBkEcosK0QzqFHTyM0xxIdjaAB0HSSBQjR7SrrQlsP7TlQeeOABvvSlL3HnnXcya9Ys7rjjDs455xx2795NZWXl+314WOw+hk64/l/qo/LrX/+a73znO3z+//se7R3t1FRV8tEbr+ZbX/wUarTVNG/zVRZJynEYuRTYXFgqB5lusMdzgNQ8gmyBMmTF1jgOvZBHVKymm60odSuIysMo5BFdAQytQOT1B0AQsVQOwjPjfDqf/t/ieu6pZ6MEqnuqG72s9PORAuk9a3rWnbyIzud/32dfeiZB+OU/U3vzj4iteRJbw1hsjWOJrXiE1NbX+h6crhJd8yShcz6GKFvQsim0eCeJzUtRE104R8/GVj9qQM7cDUWSqXSGYICbvCWiiXwJSemNu57azuSRFYR8Di6aP4zTJtaQyhTI5DTuf2k3D77StyJrVSQ03eDi+cNYt7O92CY5jtnja6j023ljUzMrNjfz/U+eRiTRxLqdbTzw0m4umDeUm88fSzyZw25TUGSBXF4tISp2q8zHLh6PxWLeLJ12hQVT6pkwrIJI3JQV+z02LLLE6MEBrjt7NC6Hgt/dt6Xtdlq4Yclopo+u5NFl+5g3sY4rFo2gpTOFz21lcI2XoMeKfJKhTLtVZsbYKn5eP59EuoAEuKwybptcHEK1BCQab5pCZO3RopzWP6MOxyBfzzohJ65RIXLtKRI7O4oeIoIkEJw7qFiRyRyL4R5bQXxHO9ZKF4E5DSh+e78PLIVYlqb7Npe0i2KbWkntC1N/3UQUjw1Ho7evA203AnMaia4/hn96Hbakk45XD6BnVQRZxD26gpoLRtH6zG4EUSA4txFRFsl3pfpUSrR0gZbHdlBzyVgyR7cDkDoQwTkiWJQv97m29R4ia48ie634ptSieMxRAC2rIrksNP11s5mtZpEQelV7qs4dgeRUBoZp3wq/+MUv+PjHP84tt9wCwJ133skzzzzDXXfdxTe+8Y33+ehMyBbHe0pMToTb7eaOO+7gf37+c7R0DC0Z4Xg7R5AsyN4Qarz8B1ZLxxBtjqJyx9BV1Gg7kjsE+dLys6VqML7TLsVQ80Vykj28HcfwaaZtfRk4x5xGopfEGEMn33YQ0WJFkC0Ymopr0hn4Tru03xZMsSoEIEqIdpcZDVAWBoVwC7bG8VgrGkDLkz22u591TeM4I59F11SSW5fR9eKfistSO1cieyupvvqbiFYn8kDC8wDeJo6VUascRyJdIJEuEPKZ8yghn4P2cBcFVWNrPwOsi2Y0sPNQF0NqvXz5+qnsPBRm5ZYWHDaZi+cPY8zgAAgCi2Y0sGVvJ267wpHWBPuPRfn81VPYuKedH/xpdfFrFPDY+OoN09i6v4tDLXEunj+MaaMreX7VISLxHHMmVDN1dBWVfgdVAfNfb5zMRv84vC4rs8bXMHZoEFU1Z1UmDq94y/f1hiAIBL32fvOCBFHA4rdTceYw8ybfLcHtDS2TNysbBuTakig+G7YaN57xlQgWkci6YyAKWEMOnEMD2Oq9SE4FW8iJrmoU4lkwQLBIxfkMQzeIb28vO9OiJvMk93Thm1aL5LRQc/EY2l/cVzRLE2QR/4w6rFVOsi1xUgciJeTDUHXi29pQkzn8sxpwNHpRXFby0QzRjS24RoWw13swNIPU/jCZphiGZqqL7A0eMk1xkrs7qbl4DNnmBGq8lNQGTx9E8mAYe70X35QaulYeKQ7vWiqcVPiGYKt2kW1O9AkojLx5FFudB4uv/N/jVMH7SlTy+Tzr16/nm9/s8QcRRZGzzjqLVatWvY9HdmpAkCQklw/R7jaluIIAgogW7zKDAMtB10sVQLqOoeZQY+1IDg+iw4Nv3hU4/ZXIniDNf/02nmnnYh88HkSJ5K5VVF/1TdL7NqBnSmV11toRKP4askf7EgVDU6m89MsIkoxS2XjSwVbJ7sQ5aiZqIox/wbVI9pPP+giyQsdTv8K/4BqcY0/HPnw6rvHzERUrudYDJLe/gRKswzV6DpKvCkQRNRkpISnHocbaia56DO/Mi1ATYRAlBNmC5HAj96r6/DOIJXPEU3kKqobLYSHg+XDnnPw7wPEWcw1KLxMxSRQI+W3sPhzlP66YxG8f3lwyZDus3svF84dx99Pb6YpmkUSRG84dxXmnDUESxW6nXhO3XjieWDLHL+/fwEWnD+W1DUc51pFk2YbSGbJwPMsP736Tn3xmHm3hNAebY3z39z2/oRt2t+N3W/nxZ+ZRE/rnZuvc/wL3UlEWEftp0UhWma7lhwnMaUC0yxiaYQb6SSJaSqXmgtGINgkto5JtTmDpbmMVYlm6VjWR3NmOoRnYat1UnDkUS8iBntdI7ulfFZXY1YFnXCWyXUGodFJ72VjUlCkFll0WkETQdLzjqzn64Nay20gfiuKfWY8S6CYFokBowWDUeA7JJmMAnolV+KbV0vbcHvKdaSoWDSN9MIKazKPnVequHE+2NUFydxeSS8E7oRrFYyUfzaLnNVoe3V7SHsp3pGh+dAc1F4+h+dHtfQaJC7FcvwPMpxLeV6LS2dmJpmlUVZX6NFRVVbFr166y78nlcuRyPYwyHo+XXe/DAkEQu/uc3czfMBCsNjPrpwxEm9OcSzmO46RFV9ESXejpOPHNL5CIHKXq8q8hWuzEVj2OfegkvDPPJ7b6SbpevIvKS75Aatdq0vs3IipWXBMWYK0aQrZlH0aZvB7FW0n6wCaS216n5sYfnPScRIsd/5k3Uug8RmrPWmx1I7HUDCPfsr/vunYXSrAOW+NYwkvvwzFiOpLdSXzd8+jZBLbGsdRc/33yHUeIrXocPZ8hM2wqnimLsVQPRY13IrsDaMlo0fQuuX0ljuEzaH/s58j+GkLn3Ep0+YMEFl5nzva4fG/5d+kPR9sT/Oxv69l/NAaY5e4blozmjGkN/3aJsh8mVAYcZdUuACMbfXhOyMPxu23UBByEE1n+s9vxNZ7KMWFYiLoKF08u28eS2YP57SOb+dGn52JRZCxK359jj9PCm9tb2X0kyshBUa45eyQ/+OOaPuuBacp24FiMkY1+fvCnvutEEjn+/MwOvnD1FOy2U1/pUQ56QSN9JIbit3Pknk3UXzOB1KEostNCvi1FdN0xZI8V76RqrNUubHUe1FQesaCR6coUSQpAtjlB031baLhhEorbingSma6oSGYwEyDZFCSbgugooMVzdLy8vzhLUn/thD7zNSXHn9N6vFZ0AwxI7QuTOhBGEAVcI0J4JlVTec4ICtEsna8fQs+puEaFsNW4UTym54p7VEV3orx5TFZFKplz6Q1D1Unt68I5NEBqf+kMk7XCWZyjOZVx6h/hCbj99tvxer3Ffw0NDe/3If1LIQgCotUJYhmOKUimPLh3D1Y0k5N7Q88kQFOJrnyEwFkfwdAKtNz7Pax1o6m44DYMXaf1wf8G2ULlJV8w1xElRLub8Ct/6bNba80w8h1H0HMZKi//asn+tGyKfNcxEtveILlrNYVIG3ohh2hxEH3jARyDJxB+5R4CC69DOqGiIcgWQud+ko5n/g/35EUo/iryrQeJLPs7aqQFPZMkvftNWu75NrLTi5ZJoCXCJDe9TMvf/pPQeZ8keNYtOIZPw7/wOiov/RJKoAZ01VRVAWqkhfYnf41z9BzCr91PtmkXmaadaOn+zaX6Q0ckzTd/u6JIUsCUmf7hiW2s393+jrc3gFMHQY+Nb98ysygzPg6f28oXr52K5wQSarPIDK33MqrRj89tZcbYKi6YO4TakJOWrhQjBgXYtLeDH37qNKqD/Q8JqZrOqm2mCdv6nW0okljil3IiWrpS7DwU7nf56m2tJMpJdj8g0FIFOpcewFbrpvKcEXStOoJrZBAMCK88gmt0Bb5pdYg2meTOTpr+tpnmh7Zz9O9bSR8IU3fVBERLL0KiG3S9cRhEAd+02n7365teh9RLrq2rGmo0S9N9W3oGXqE4+9EfJKdJEHVNR8+qtD65yyQPBhiaQWJXB63P7Ebx2nCNClF19nCqLxyNd1INiqdndkgQhZLfeS2VL2ssdxzZtiSWYN/2TuC0hpLtnqp4XysqoVAISZJoayuVzLW1tVFdXT6h9Zvf/CZf+tKXiv+Px+P/dmRFlE1FjZaKmqTDANHuRHL5EaTSP6kgycjeCjNBufc2rA78C65FCdZR85Hb6Xz6N7Q/8hOstSMJnvNRLIFas9WEAB6wDx6Pnk3jmXI28XXPdZu9CdiHTiKw6CbybYcwtDzpPW/iGnMaus2JUcgRWfko8TVP9dqxRMV5n8ZaP5Jcy35EuwstGUa0Oam+7ntkD28j33EE2VuJrXEMmUPb0DMJIq/dh2fG+QhWB9aaYWQPby9u0tAKRFc/iWfyIqIrHzNfy2eJvvEQsreC+LrnAJCcXiou/CzxjS+Sb+8ZjDTyWWR3AMeIqaT3vAmiiGvcPCyVg96RN8v+Y7E+FurH8ddndzBxWIhAP+FpAzi1IUkiowcF+O3XzmTD7naa2hKMHRJk9CA/Ff7y82uKLBHw2gl0z2Mc60iybOMxgl4bum4QiWd5YfURLl04rN+EYkkUGNng46pFI2npTNLSlcbvthLp53NWV+EiEu/fiFLXDbIFjaa2BG6H5W3NppxK0FUNQzNI7upEsivY67wIQHj1kaIzbeaI6doa29jS640Gie3taKk8dVeOLzFOyxyJouc17A1enMP6Vh1cI4PYqkvbZWqqQGxza4l3CUC2OY5jkI/04WifY3eMCCLZZKIbmkEWyLen+syMAGjJPOlDEbzTapHexpCrruvkw2lkl6Vf237ZbS0xdpPsMsEFQ0yH3A8A3leiYrFYmDZtGq+88gqXXHIJYF70V155hc985jNl32O1WrFaP1hfrvcCgigiObzmfIcgIohSH5ICxyswDpRgPbmudgRJoeKiz2OzWtDScQqdR1ETYaou/5qpDBIEJJcXUepbGhZdFvwLrsU9eRFaKoZocyLIFtof/x/yrT2Ok9HlD1N52VcQ7c5SkgKga3Q8/b/UffwX5vFZbDhGn0aueR8IArH1zxFceD2IEvE1T2PoKr45FyPIFkSbOavjmbYEQy2QO9ajpsge3oZn2jklu0rv20DlJV8sEhUtFaPzhT9SdemXaX3o9uJ6ofM+RXjpvWSP9CSdJrcsxTVhIYFFN73t2ZU9R/r6PxxHeyRDQStvFDWADwZkWaQ66OS804a84/d2RDJ84zfLyxJZn9vChacPQyoTMFjQdKaNruSpNw7y6vomxgwOcNH8Yfzlmb6pvEGvjeENvpMSlTGDA6zZ3so9z+xgULWbz1w5meEN3g/MDJWoSAiKSHJvFzUXjqb5sR04BvnRUgUCsxuIrGmiYvEwWh4tn1qcPhTFP6se37Q6Im+aA6+iTQHBDBWsPHs4+XCGxPY28xltfBWK394nS8fIa2Rb+lYwYptaqb5wFGoyR76rR2VpH+TFP7mGpr9vIXhaI9aQk+iavl5VxeM8GME7uRp6ERU1macQzZA+EkOyyzgG+xEUkUIsR9frh/HNqCtLkMA8D9ljwTnEbz7Y2mQz3+c9Cmh8t/G+q36+9KUvcfPNNzN9+nRmzpzJHXfcQSqVKqqAPqgwdM38p3a3GUQRQ9MQBNOozTT1SWOoeUSrw3SWFaW35fWhqwXUWAdGvoc9C1YnireiPFkRJQSLhOINInbFCL/6V2jrzsIQJTxTFmPkM1jrRmKrGfYW+20nvv4F8u2HUEL1uMbNQ3b5KRntNXTaH/s51dd8u99tFcIt2IdNBQP88y43lU2SjG/mRSS2LCW9d11x3fTedVhqhlF50efpeukusk27qLz4c7Q9/JOeDUoyJzpJCZJsDiH3ghppRcuaLSIAS/UQtES4hKQcR3Lra7gnLkR2Tuj3PHqjocrd7zKvy4IkfjB+FAbw7uNwa7zfattDr+xl/uQ6FEUil9dMk7TuCktbV5pIIser602vlZ2HwswcV80VZ47gqeUHin4ow+t9fPLSCWSyKroOs8ZVs2Z7qcpPkUWuPXsUa3eYr1sUiVfXN+FzW0/afjqVILks+KfXEV7VRHxHO5WLh6Ol8wiKhOSwUIhmESWxX78RMOW/9gZvkaj4ptUW/UTk7oBBR0P/Dyd6QcMwDKQyjq56XqP12T1UnT0cyWEh35VC9thQvDaa7ttM9ZKRdK06gjNdQLSeZCbGJmOoBtlwgnR3hcjitxPb2FJ05/VOq8Va4cBW7SbXlUbLqtReMQ49r6FnVOLb28i2JAic1oiazKHnVPLRDMFZDe9ZgvR7hfedqFx99dV0dHTw3e9+l9bWViZPnszzzz/fZ8D2gwLDMEypr66BYaBnk2Z7RpTMFkwqjuTwoEbbTBWO1Y6eS6Fnkog2J6LFVpZsFLevaaixdox8qSeKkUtRiIHiqzS9UI4TpXzO9FRRrBi6jpaKoiXDFL8iukZ808tUX/NttESYrm2vIyhWnKPnIHsrioocw9DJNu0wU5O7b/7ZIztIbHyZigtuQ0vHzKpIr+3m2w6hBGophJv7nEeu7SD++VfR9eIfyXWriGxDJhJYeD2xdc/0WT/fsp/s0V24xp2OZ8piJHcQ3+lXE1/7NHo2hXPUbNL7N5a8xzl2LqlehKd4aJlk0SnXOWoWiW2v93u9Y2ufxVo/6m253Y4dEujX8vzyM0YQ+AD0ggfw3uBQS/9D/7PH13C0I8njr+2jLZxBFAWuOmsEYwYHWb2tpY8t/1+e2cGcCTV86dqpGAZUBuzkChqRRJYKv4Pv/n4ln758EuOGBnl57RESqTxjhgS4ZMFwDh6LYrXIfOfWWRw4FmP7wS7ueXYHF84bSn2l+5Qf+BYlEe/kGnRVJ7ahGTWVJzhvEP6ZdYCBZ1IVok2h+oJR5CMZUvvD5FpLhQey04KazIMAtnovnrGV78gM0tAMch0pvBOryDTF+izXMyqCJCK7Ldhq3AiiQLophnOwn8SeTnKtSYyCjmdCFbn2g2X34Z1SS2RDM9HeHisCVJwxFEuVE3udF3QDLaeCblB7+TjynWnaX9xnqoicFvwz6qg4axhqPEfnsoM4hwbwTa/7wJEUOAWICsBnPvOZfls9HyQYmmqajCUjpv29ICE5vSjBOgpdx1Cj7SiBGgqRViSHBxC6LfAFjHwGPZtAkK0ogWqEMq0X6K7U5Mu7zBq5FIaugQFaKlJUuZgQ0K1uhDKZQBXnfZrYikfJHNpSfC264hG8sy/CN+dSJIcHLRGh/fE7+lQoMHS6XvkLwbM+QseTvypZpOczCBYrSqge++AJYOik928yzddGzKDlr98pkVlnD26htWU/lZd80SRE3Vo6yR0kcOb1SE4fXS/dTaGjCRCwD5lI5SVfJLL8EdwTz6Dt4R8XtyV7K3CNm0dy+3IqL/0yCKAlIsQ3vWyGJBpmb1l0ePvkH5WcQy5tSr7fBkI+Bz/69Fz+35/WFA28BAHOmTWIM6bVI5Yp7f+7wtB1VLWAJCuI/waVpkHVfattgmBm6kwbU0kmpzJzXA2ZnEp9pYudh8Lsa4pSGXCQKWMutmprCwebY4iCwFdvnI7TppBI5Vm7oxVVM/j1g5sYXONhwZR67DaZQ80xfnLPWr5+83Tqq9z87N71JXMub2xq5tqzR3Hx/KE47ac2WZGdFoJzG/FOrsFQdQqRDNZqF4rbSvpwjObHtiNZZTzjq6hYOAQtq9Lx6gHUeM50mJVFZJeF+msmovhs79idVbRIaMk81sF+vJOriW0qrVz5ptWSbU7QvvQAtZeMRXZb0PMqzuEB2p4129X5rjSiVSobGeCZUIWWyiMAtZeNpWvlEZNsGZDc00lgTgMtj+8oMZ3zjK/EVuspeqxoqTydrx3EO6ka15gKCpHsP3SupwpOCaLyYYChqWipGFo2iWi1I1oc5i+RoaPn0sj+atRIC+Z4t45oc2FoKoJhEgvJW2luI9GFlk0jWh2gqRi6hiBbECTJNHEz3mLOQdfR9cIJJAXAQE9GEBUbsq8SI2WWDy3VQ9GSkRKSchyx1U/iHDXbJCrpWJ8k4+Iu0/GyCcaOETOwD50Chkahq5nskR345lyM7K8hsenlsl4wejZF5tBWbIPHIwginhnnm3JhUST8yl+7SQoIFqsZFxDroOLC29ALOVwTFqDGOnAMn4q1ejh6IQO6TvuTvwRNRQnW4Z9/DaInSPU130a0OZEcHgqdR4mv7VvFAUy/lreZziyJAsPrffzPFxfQFcuQzqpUBRx43VacH1A56HHouQwIwj+dVK2pKvFIJ7vWL6e9+RAVNYMYM30eHn8ISf5gX6OTYXCNB6/LQjyV5+xZg5g1rppcXqOuwkVLV4qf3LOOfK/BzHmTapk6qpL6ShcFVWfKyArsNpmCqjN+aJBRgwLsORJBAAqqTlpVMYBILzOwQy3xPpUcl93CX17dUSQpVQEHZ0yrx+e20dKZJJrIn/JEBcwub64tSduzexAkgeoLRtP0ty3FwECVHB2vHsAx1I9jsJ/KxcPpeHU/FWcNR03msdW6+8ydvF0IooBrVIjmR3dQuXgYnonVJtkwwFrpJHUgjOSzEZjZQOeygxiqTmj+YArxXElLqv2l/YROH4RnfCWZIzEERcJe5yHbfV4AUUWk+rxRdC47SCGaxT+znuZHd/RpbcW3tSN7bdhq3SXqn9iWVpzDgyBgzrR8QB+WBojKuwRD1xEsNhSbEz2fQU10mtUHUTaDBGUFBDNwSvZWmoqdbE9JUs/ETbdUn9nyKnQeLSElos1lWr8LbzH0JohoqS4E2WpWV/RSuZyezxA8+1b05j3EVj2Gc/RsEv240EJ366NmGMZbVRW650MExYZrwnzcE89AEAVyzQeIrXka0WrDM+1cU30kWcgc2tbvprJH9+CffxXZw9voeOpXZlvM7sYz7Rwco+eg59PYG8cSXfUEkTceRNrwAp4Z5+OeshgtHSe67H6stSMIv3JPibqn0HWM9sd+TtXV3zJziKx2RJsTz7RzSG5bZraEekH2VeEYMqnsMWrZVDfhdHaHRJoQRYGQz07oFHd6fLtQ411kDm8jsflVBFHEM20J1rqR/1BStWEYtBzZx5N3/Qy9e7C4ae92Nq14gQs/8iXqh44uysY/TCioZvDnjz41l2SmgGEYPL/6EMs3HeM7t87mx39dVxI6CLB8czODajwMq/diUSQmj6xgZKOfo+1J9h2NoukGg6o9/P3F3fzpqe1cPH8oly0cjgA8t+pQ2eMY1egnmSnw5g5TAXj9OaMJeG08v+oQHZEMg2s9dMYyBLw27NZT+9agxnO0Pml6bXkn1hLd0Fw21Th9IIJnfBXJfV1UnDUMPadiq3H9wyTlOBSvjZoLR9P+yn78M+pI7GjHMKCwIkNo4VDSByOkDvRUShI7OrAP8iF7rD3OsrpB57JDiFaJmovHEF1/zMww6p2CXNDpfP0gvmm1xLe2kW1L9jt/E9vUSvC0xlKZsgF6tkD1haM/MAGE5XBqfxo/INDVAoaaR89nzLmUTLz3QjPR2DCQnL7uLB2thKQUV82luuW6URKJGN//yR088dxLdHR1MXncWH7xs58w+/SFCBZ72faPYHWaqh2H18z3ESUQJbRkBEM9/uXQyRzZhaemkcCCaxEdHvT1z/d/btkkWjaFaLH3v1+LvTjX4plxHrE3n6H5L98CQ8daN4rg4o8QW/0knc/8Ft+8K8HQzTmdSEuZPYJzzBxSu1aR2PBiz3FkEkSXP4xn5oW4xs6l+S/f7kmXTkbofPo3uCadia1hLMFzP4kgivjmXYkgK+TbDhJb81TRpj/8yl+ouf773e03UAK11N58O9GVj5LatQpBlHFPOhPPjPOQvaW5QGr34G1yxwpkXyW2ulFY60ageN+ZlfgHAWq8i5b7f0Sho4fsZQ5uwTZkEpUXffYdk5VUPMKL999ZJCnHoWsaL95/J1d/9nu4vIF35dhPFUQTWdojGe59bmcxxM8iiyyeNYiv3jCDLfs7+5CU43hx9WEmDQ/xi79v4BOXTOCHd60hle158LBZJL58/TT+8swOnnj9AJNGVDKi0U9NyEnLCSm/ggDXLxlNLJFD1w0WzWgglS3wtxd6jDU37elg894Ovn3LLGaMrTplQzwNwyC+rcduwVbnMSW//SDTFEONZpFdVsSAhPIuSLIFQcBa4aT24jHkI5miwkdyKEg2qYSkAEQ3NGOrdxOcO4i250qzn/SCjp7TSO0vrxosRMxjl302c7amH2ipPKK97y1d9tqwVjhPamh3quPD9/jyHiCVV2lNZjkQSdGazJLKn2DqY+io0TZEq6OP7fxxaMmoORsBaP2sA6aEVrTa+fSXv8Urr6/grl//lPWvPMOiBfNYctGlHD3aZBIeS+kTu2BxIHtCaKkYRiGLoamoibBpne8OIMjdX05ZRvaGyBzYZLZfCnns/VQNAJyjZhN++c90vfBHAguuLbtOcNFNiHY33tkX0f74/5Devbo4A5I7tpu2R36K77RLESw2YqseR/YE8UxZ3O8+7YPHk9j4ctll8XXPoedSfSpFAMnNr2KtGkRi8ysc++NXaH/0Z7Q9eDvp/RupvOSLiN2DwYXOoyVzKWqklY5nfwdA6OyPEVj8EWwNoxGV0jaHmozQ+fwfMXQNx/Cp6Jkk2aO7KHQepRD9cBm6GYZBcufKEpJyHNmDm0sHp98mMqkE6UTf4cPisuSHy2U6ky2w92iU3zy8uSRpOK/qPLPiILuPRAic5KbZFc/SGcty6YLh3Pfibi5dOJzv3DqLb9w0ndv/Yy7f+/gcMOA/Lp+I26Hw0Ct7sCsSP/zkaSycVo8smURjULWb7398DtVBB5UBB+OHBpk7sZYn3zjQZ5+GAb95eDPhWP8S5/cbhm5QCPd6YDKMomtsOQiigK7pCLL4rpCU3pDsCrLTYlr4A45BPlL7yhvutT65G62gUnX+SOTu0EBBEnCPqSy+v9/9OBQ8Yyux13r6XccStPfJAZJcFuS3cN39IGCgovIWCGfy/GXrYXZ09pCLsSE3N49vxGcx/Uv045byhk6fMAUEBEnBwADBnME4fhMvC8Mgk83x2LMv8PDd/8fps2cC8J2vfI5nX3qVO++8k+9+/pMmWXH6zLaDKJpfVkM3W0y6hiDLyF4HRiGHGm1H9lZANosgWcDIkGs7jOyvpvPZO6m98Qekdq7CKJT+OEmeELI3RPI5UxUj+yqpvOwrJDa+RCHcjBKswzf3cvLth+l89k5cY+cWZb8l0FTiG1/CNe50EhtfQs+mQZJxTVpEcvMrJat6Z19szkP0d4101VzeD9L7N2KpHFzyd8gd3U146b34511F10t3mQPFx51p4100/+17aPFOckdM/5TjqLjos7gnLCz+P996CM+Us+h6+c8Uuno8EOJrnyGw6GbckxYh2T8YMs+3gp6Ok9hUniwiyqipmOneK4pItrd3zvpbtA/fsr34AUM0madQ0DlwrDw5e/nNw9x+2zy+eoMNSRQ53BrnhdWHCXf7oAyv93G0PcGIBj83njuG+17Yxb3PmxUQURRYOLWeySMqeG7VIb77sdmoqk5zVwq/28ptl0/ixiVj0HQDu1UuGrsl03k+fskE9h2N9lvJCcezxNN5gqdo+1KURJMQdBuzpQ9FcY0IktzdT7Jwg5dCPIf4FmTg7cIwDDN7J2eGJopWmYozh9H+wl5cI4LEt/f/0BJZfZSKBUMIzKxH7M50Eq1yD9kq8zcRbTKCLNL2wl7qrhiP5FDKhif6ZtQRebPnd0lQJGovGfOBbvkcxwBROQlSebUPSQHY0ZngL1uP8NGRfhyygKDYECy20owdBNMpVrGaT++iaFrc290gCGiF8k8sotVBPtKFpml9jO1sdjvLV6yEz30cLRlBCdWjJSPo+SyKrwowEAQBLZ9FEEUEyYlgsSF2EyjJG8Jo34Oh50ypdLwDPZugkIxQdflXiK1/nsy+DQiihGvCAryzLqLlvu8V95/Y9DKp3WtwjZ+PfegUnKNnkmveR9cLf8Q18QwyTeVNlgCyTTvxz7/avDKShJboQgnWUnXVN8k170MQRaw1w0ntXYd4wlCl7K9B9obQ4l0Uws0nlW8Lgoji7yttz7cdwlLZSPX130eUZbRUHC0ZQbDYEa0Oyo0oh5feh33wRGR3AF0tkGs/jBo+VkJSiuu+8hccwyafMkRFyyRQ412kdq3CUAs4R89G9lW9pXmdmoqC1u0T4fBw4s+hc+ZFyGPns3PrOlL77qdxyEgq6wbh9PjfctsOpwfFaqOQ6/vZVyxW7K7+nxY/iMjkCnREypNqr8vCF6+ZyhPL9vPahqMUVJ1Rg/x8+vKJLNtwlOqgk9Mn19IRyVAdsPOLv29k/9Eok0ZUEPLZ6IhkWLq+Casi4XYofOu3K/jWrbP4wZ/WYFFEbrtiEpNHVvaZNbFaJBLpHAHPySsL5cznTiU4hwXoWnEYPaeR2NVBzSVjyByNo6VKWyOeiVVkW5MEZtb/03MpAFpOJX04SscrB4r7stW4qVg0jMaPTEHLaTiH+Pu42x6Ha1iAxJ5OUt1eKI7BPoKnDyK6uZXAzHrCq5v6vCd4WiOJXR24hgdJHQhTfeFoOpcdLMquRbtMYFYDFr8D3+Qa8l1pLBVOnEP8piPtKdrCeycYIConQSKv9iEpx7GjK0FSqMKabEdyBRFtrm5WrIBeQPZWoGdTaMmeD6yGgOyrRLS50FKxvu0LUUJ0uHFlk8yeNoXb7/gNo0cMo6oixAOPP82adRsYPsw0ZJNcftOjJZdG8ddgYKBnUqZjrdOLnkma7SiHB8nhwyhk0VIxBMVK9shmAqOn0/pQt5y3kCW2eSnBRR9BnXkhRi5Nru0QhfAxvNPPI7z03uIh6plEUSFjHzyO2JtPA2DkMkj2/m80kt2NkcsgOjzmvI7LT9fj/wOijKWiHgyDyBsPgaHjnXGemckjSgQWXoca66QQPoY8fBqWUP1JnswFLJWDyqqJ7MOmINpcZA5uQcsksNYMBQREm5vgWTfT+fwfUCOlMkMtUZpSba0eTPSNB/o9x9Te9VgqGvtd/q+Clo73iS6IrX4Cx4gZ+OZejhrvxFo9FMkTKDoQa+k4mYNbiSx/EDXajqWyEd/cK7BUNBBf/wIA9nEL6PQ2svR/f0CopoGx0+cjWB00Nx+lXrai5HOoooLd5UEq43RqtduZf8H1vPJI31Treedfi9Pte28uyPsEWRLx90MIPn7xBH7/+Faae82S7D4c4ZFX9/LxSybw52e28/CrexEFmDG2mlsvHAfA6m0tHOtIMbTOy2VnDOex1/Zx7pwhLNt4jOdWHmLB1HqeX3WI2/+ylp9/fj4jGkrniCLxHD+8602+fP00rBapaBjXG41V7j7ZRacaZI+V+msn0vb8XnKtSdpf3EfVkhHkw2lS+8KIVhn3GHO+TPHaEN6l4eBce7I4xHsc2ZYEzY9up/Ls4SR2deCfXo+12tXHv0VyKHgmVNH+8n5s9R7co0IIkkjrc3sJntaIUdCpOncE0fXNFGJZLCEnvik1pI/EyLUnsTd4ia5vxl7rxjksQHDuIESLhJrMEdvUSudrB1F8Ntzjq3CNDL4rxOxUwQBROQnSZabIeyOjmTdMLRVB9lagxbvMJ/9UFENTzVmKEhiml0pFg5nVk4x0K00MRLsLyRUwc3wCtdx15//yic9+gaFT5yFJElMmT+Laa65h/Yb1ICmIVgeFSAuyrwo10XVC20ZAcgfNSmI6jmRzIyg2JJsLQYhjqx9BYvMroKtI7gCSJ0hg/lXkO4+AWiC+8SWyh01VjnvKYjwzzu8r3xVlBMVWVMqkD2yk8uIvkNz6Wtlr5Z54BtnWg9Rc+10A1FgHoXM/SWzds+TbDvUcuWwBi53KK76BFu+g/Yk7StQ4gtVBzTXfxlIznHxL6ZyEf8E1JHeuxDPjvJLX7cOn4hw1i2N3f73EB8ZaN5KK8/8DPZfGN/cyOp/+bekp2lym4y1mvpLk9JUlQcdRbkD6/UC+81jf6AIgvXcttsaxJLYsRQ23UHXl17ENGgeaRmzNU0RXPlpcN9e8j7aH/pvg2R/F1jiW7JGdKFPO4fU//Zzzb/o82VSCtUufIh7uwO0Poc4/l0EjxvPsX+9gyJgpjJ+1EKfHZ+43EaP92CG2rHyZ+mFjuOiWL7N+2TNEOlrwBauYtvB8bE436UQMp9f/ofFV8bisyJJIhc9OR7SnslIVcJDOFkpICpjE5rpzRvP//d+KIoHQDVizvZWdh8J88dqpPLPiILUhF61dKZ5deZBv3jyTgNtKVcDB1n0d3HrReJ5fZT4z3f/ibr58/TQcvaTxHdE02bzG08sP8rGLxvN/j2wu6TbYLBJfvG4qPvepbU4oCALWkJO6y8ahZQsYumG607os2Oo8iLKIoelkWxOIFhn7u5Bpo2UKdC47VH5ZukAhkiHfmSa5t5Pg/EFkjyVI7u7EUHW8U2twNPjQCxqhhUPQuy34U/vCFDrTFCIZBFkk25bEOSKI7LRQiGXpWHoQLZXHN7WWfEcKPasSXnMU37Q6wmuaMPIa/pn1+KbV4p1ag8VvR3JakMu45n6QMUBUTgLHWwwg2Y8/NRq62faRZbREGNlbQeGEEMAeGOiZBLI7iOAJgbtb5SCIRWmmKCuMnjqLZW8sJ5VMEk8kqa1v4JprrmHo0GEogVpTGqvYTBv+Pm0kAy3RieyvQc8kTTWRw4vRXcFJ712Pumc1gqRQedHniLz+EJl9poOraHfhn3clllA98fXPk9j4EtVXf8vMy+k1N+KetBDR6cM+bAqFcDNGIUfm8DZ8cy8nuuKR0us0fDq2oZOw1o6g7ZGfFgMSZW8lgTOuJ7FlKZkDmwCovOIbkM8gYND14p/6SIaNXJr2x/6Hqiu/TrZ5H7LTa/rWOLxkDm4yycQJrQXvtHNpffD2PnMvuWN7iK17DkFW8ExahGB1YOR6Ygm8sy4qUbaINhfW+lFFJ90T4Rg+rezr/0roaoFYP54wAMlty3CNmUPk9QdoffC/qf/E/4CuEV31eNn1I288SNWV3yC2+gmajx7h4lu/wpE921i3tIcIJSKdLHvir0w/80IWXHwjj9z5I5r27eCsKz+KKEmsePYB9m8zP1/xSAcLLr6ZueddTbSjlc6WJl595G5SiSgWm52LbvkylfVDPhRkxeeyMrzey+evmcKvH9xEW9j8bA2p9bLzYN/WwGkTa3htw9GyVY5EOo+q6vznx2az61AESRIYWutl/e52JgwLcvmZI6gNOdE1neH1PvYdjXKwJU42r5YQlePFyM17O3DZFb596yze3N5KRzTD4BoPi2Y0Ulvh6rP/UxWSQ0Fy9JyfllXR0nnyYfPG7xwcQHZZ3hU3Vl3VybWf+PDZg1xbCsVnJ76lFYvfTmp/GPeoEPZGH+lDEY4+vI3g7AZERSLRTWDcYyqwzGkgtrWN0BlD6Fp+mGSh9HdKtJjGcMeVTZkjMfKdaTwTq3EO85v5R3YFyyleBftnMEBUTgK3RWZcyM32Mu2fsSE3HpuCbKsGTesOBbQgOuwYhg6a2stDxdLtM2KgpRMYqkkYTGJS/gskiKbBm9sXwO0LEIlEeOGFF/jJT36CKCvoagHR7kaN9T+4ZeQz5oxM96CtaHWasmXFgve0y3FPXIia6MI9cSGeqYvJHt5OfP3zdL10NxUXfx5p7zq0eCf59sOmu26n6QjrHDcX/+lXI9sceKefR2Lzqxj5DPG1z+CefBbVV3+LbPM+BEHAMXwakieAnkly9O/fLGl3qbF22p/8FdVXfZNc20FCSz6J5HARWf4Q7gkLKYTLy5fVeAeGmsdQc3Q+/zu0ZBTJ6cU780KTLPTah6VyEPmuY/0O5ya3LqPivE/R+eJdeKefWyRZrgkLcE8+05R4d0Pxhgie9RGa7/l2H4dea/1ok0C+39C1fpVnYA5zF92JdZX07jdRgjX9Xh89k0C0WAmd/x9kDu1D1zQ2vvFc2XU3LHuOYeOnY3M4iXY2o2kq0c7WIkkBmLX4MvZtW4tWyLNrw4qS91usdtYve4aFF99UrMZ80FEZcGKRJb5z6yzi6TzpbIHqoJNX1/adRRhS6+WF1YfKbudjF41n9fYWXun1PkGAqxePwue28V9/XsukESHOO20IcybUcPXikSzbcBSrUvoTX+m3o8giBVVnxZZm1mxvYcqoSgIeG8c6ktit8ik/n3IySDYZySZjCZRPtP5nIAgguy2osfJO1rLHQuZYAi2jIlgkcq1J7HUeYptaSOzsIHTGENIHo6QO9JDUTFMMxW+j8uzhSDaZ+msn0vHy/qIXir3BS2jBYNpf3V+yLy1dILG9DXuDB1GRP9QkBQaIyknhtMjcNGEQ92w9XEJWjqt+bFoGLRXHMDREix3R7kFLRZCcfkSbC9HuRkuGMQrm4BSChOTy9ZG9lsMLL7yAYRiMGjWKffv28dWvfpXRo0dzyy23mG61ogiyclIFkaHrIIimy60gIsoKos1J4MwbsegFOp//A5n9G7rXFnCMmEblpV+k/bH/Ib72GTyTziTyxoOIdjdVV369mEckOX1INvOHQPZXUnfL7XS9ci96OoZn6jkIsoLLGzJbVBY7otVJZNkDZSXF6BrJnSupu/WnGFoeNdyKJVBrZvGcBHo2RfilP3Nc3aOlYoSX3ot72hJ8c6+k/pO/pBBuQfZXlyh5+lyjQhYkmezhrQQX34ytfjSyv6r7HPuWiy1Vg6m75b/peuWvZA9vMw3jpp+HZ8pZpoPu+wzRYsM5enaxdXcibIPGk2vp+dFTE51YaoaedJuCKCM73Lj9IaKdrWhqmb8joGsq2VQSb6CSGYsuYsfa10knosXlDpeHQi5Lw7AxvPTg70ten3f+tRTyOdqOHmDXhhUMGz8dp9eHUiby4YMGn8eGr1fOUziWYe6kWh59rbR1mcmpuB0WWrvSJa/XhpzIklhCUqCnvTNpeAi7VWbz3k7mT6nnuVUHEQWB//z4HJx201o/nVMRBXA5FD5x8QR+88hmAFTNYO2ONgQBvnPrLILeU7vl835CdlkJzGqg/cUy0nxRwF7vJfLmMRSfDT1rjqE7BvlofnSHWfmxKyUk5TgKkSzpQ1HsdV5kh4WaS8ei51TAJIxtL+wheNog4ltazSFdUcA9OoRvSi2CRcJyiqqz3k0MEJV+YGgqhmHgs4h8fNIgYtkcGVXDLom4FRFrNozWawZFzybRsylkfzVaogvZV2WG8fW+ORsaWqILwVeNruYxCvnuSowMklwynR2LxfjmN7/J0aNHCQQCXH755fzwBz9A1AsUYhEMXUXxVSEotjKtHxOixWwNYRjd1ZvuKoCu0/nsnWQObu59xsXEYs/0c4mvfx7PtCWAgG3QWCyBmrL7EAQRS6iBios/jxZto+vlv5A9vBUEEfuwyfhmX4LkrSTXvLffa51v2Q8YpLYtJ/L6/QBUXfF1BNlSfiZElMwqUR8pOCQ2vIhv1oXI7iAAaqIL26BxxFY/UXbfSkVjT1VK13EMn9rvcQKIsgVr9VCqLvsyeiGLgIDk8pVUXt5vOEZMJ7ry0T5SccFiwzVuHq0P3F58zVo9FKOQMz2AcukTN4VS0YDocJOMRchn04hvcZ6KxUqgup4je7eTSSW6/07dx+X2Eo90EqppKJIdxWJl0ZUf4/Un7yXW1VMdXP3iIyy5/jYGjZyIrHy4+u0Brx0E+MQl4/n94z2EcvmmY1y6cDh7m6Il68+fUsdLbx7pd3svrj7MjLFVvL7xGKu3tjB5ZCUvv3mETbvayOVV/vD4VnYeimBVJG69YCzzxlYz+WtncvdzOznYHGdIrYerFo+krsL1oVCIvJdwDgvgmVRFfHNPa19QRCoXDSO2yawAB+c2giRSfcmY4uff0egjta+r3+0mtrfjm1JjGrvZFeieMdELGtYKJy1P7MQ9poKqJSMByLQm6Fx+mKolI96rUz2lMEBUToChaei5NGoyDFoBRBmry0elBFq6EwQR2VqJ2mdQFsAwjd3sblOSXK6CAGiJMKLDg5bo1v2LEoq/BpQeKdlVV13FVVdd1bNlXUNLxVB7JREXom2mzDjcnSHUC4JsQZAtiJKMKFu6b6Qmy9cyyRNISg/Se9dTNWUx6X0b0JJR/AuuQXL4Tn7NDB09Gab5nm/3kCZDJ7NvA7lje6m+5lvIvirybeWTQmVfFUY+WyQpAMntb+CZfm5ZguGZeT6pXav6ORgdNREhsXmpORxq6FRc8B8oFQ3FnKDeCJ5xA50v3W0qrt6mHwiAZHcVk6VPNSjeCmpv/CGR5Q+R3P4G6Dr2YZN7FFzdn0slUAOCSHTlowSXfILs0V04hkzqDrY0SO5eg/+0S5GdPo5uWIHLGyCdjOHxVxCPdPTZr9sXxGKzU90wlNUvPoooScxefBn7tq4FIBmP4g1Wks9lcbi9pBMxRk05je1rXishKWB6Vbxw3/9x/Zdvxxv48Ln+Bjx25k2qZcKwEKu3txJPmgnHIa+NuRNrWbGl53vutCtEk/0bsHUlssydUEtXLIthGIiCgNuhMLTex9d+/QaqZjB2cIDPnDsG9oWJPr0b2W3h84tGYXgtiFbllLfMP1UgOy2ETh+Cf1odufYUhm4gyiLRjS3kOlJUnDWMXEfK9DMRBarPH2W+UXgL+6zuJGQ9ryFaJGSXWUkUFYnArAYwILa5lfgWkyA5hvqpPGvYh0rZczIMfDp7wTB0tEzctLw/Dl1Fi3ciOnwmAVEL/VYwAIxCBsHtL9q1l11Hy5d6geiaaaAWajAN28q9R9fMVOZuCBY7ktOPUcibVZxkpPu4RESHG8npBQQE3UAv5BAMw5ydgZKB0TJ7wlDzeGddgLVqKLKvstjm0VIxDF3rDl00y42FeCeFzqOkdr9Z9rromQSpXWvwzbvCdKwtA9+cS4itfbbktdTOlQTOuIHAWR8h9ubTaPFOJHcA78wLsA+ewLE/fbXfMxAkieiKh4v/73r5Hiov/jzJba+T3LWqGFDom3s5gtWOGmnBPeVsJKfvJNflnUFLx9HzWZMAKVbyoo2uWIaVW1qIJLJMH13F4FoPQe97U7ZV/FWElnwc/4JrQNfQUnE6nvk/02lWEHGMnoVn0iLan/yV+Rly+9EzCdoe+alpHGix4Z19MZLTRzaTYtua16gfPoZ0Isb8i67jxft/T76X8Z5itbH46k/QtG8HFqsNtVCgkEqgaRo1g0eAAb5QFd5gJRtef54p85aw4rkHaBg+luf//n9lz0HXNVqP7PtQEhUAv8eO32PmQiUyBdZub+VoW4LrzhnFFWcOZ8PuDhRZYPb4avY1RVm2sa9/D8CEYSHCiQyjBvmZN6mWZ5Yf5KpFI3nolT2omkGF387nzh5N5uk9xRyZXHuK1P4IwfmD8U2u/lee9gcevedg1EwBPVMgNH+wqdrpSPaYrukGhqYjORQyR+ME5jT0W1VxDg8QXnGEQjxHcN4g8tEstioXoiKZ5Gj+YPzTatFyJpGR7AqS7d/n9v3vc6ZvA4amoSWOkwEB0eEx5zsMAwQBQZJR410c7x2Wh2C2WuSTMF1R7kuvDd2swvRHVAp5ilUTSUFyeHvSmEUZyeExnWolCUTZDD1M93bEFNEdXgzDQLCe/OYouwPIDWOLMxdaKkr60FZiKx9DS0Wx1o/GP/9qRKuD1vt+gHfOJWTLpC8fR7ZpJ84xpxE671N0vvBHc9AYQJIJnX0rcqCmbO5PeOm9WGqG4Z9/NdaaYYhWB7ENL5Jt2okSqjeDG088dm9lH5KoZ5O0PfwTnGPnUnP99zByGUAg13YANdaBZ/q5eGdeeNJr8nZhaCqFcAtqMkLu2G60ZBRr7QiUmuH88YnDrN9lVtGeXn6Qxmo33/vYbCr87/7gH4CoWBG7ZzwUXxU1134bPZ9BkGREq4Pw6w+ip+MEFt1EeOl95I6ZaibJV03gzBsxfNXksxlkq47bF2TTGy9w2Se/ybbVr7H4qo8T6Wwl2tGKv7KWxhHjEASRVDxC9fhpDBo9kX1b3mTn+jdYeMnNHNq1idYj+5EkhVlnXULzwd3MWXIlCMJJHWmz6VND8v1ewuWw4HJYuGj+sJLXh/fyQLlq8ShWbGlB1UqvlduhMKLex/f+aD4EPPn6fj539RSG1nr463M7Abh63jDU1UdLwu6Oo+uNQ7hGBLFYBm4F/wiOt2kKiRzhlUdMl9leiLx5lMqzh9P6zB4QTHO4bEvpsLvkVHCNCNH82A7QDdqe3UPlWcMoRLNYu2XVoiIh+ux8uJqgbx8Dn87e0DVABwSzHaGr5oyErqNlkwiihOTqlhOnygdIiTYnhqYiWu1oiN3bK4Xk8KCl++aaGJrZmjEMHUPTTDIjCGbbplfvWHJ6u+cPuomLrvYylhNQgnUnkBQAHS3WBbqGZHNjbRhLroyTrH3IZGR/NXJ3dUHLJAgvvc/0XelGevcatGQU59g5FMLNaOmY6bhLeZWOZHeBIJiOtkMmUgi3AgZKoMaMApAtOEZMJ3OwL9nJt+wnc2ATjqGTkd0BvJMX0f7krwme9RHan/wVeq/rKNpcVF72ZbpevKvstU1ufa0485JvO0jl5V9Bi4dJ7lhO0+8+h3vyIvzzrvqnhmILsS5yLQfoeOa3Pa2/9c8j+6v5+hXf5JZD0WKw3JHWBA+9spePXTwey78gi0M+LoXvhn/uZQiCgBKoLZIUx8QzsM26lEQqSfjIQVLxKFUNQ5l91sVIosBjf/gx59/4WRSLDdlqo37YWLRCHsVmRxJlwu3NbP3jq5x7/W10tjQx48yLePT3txfdaGcsupiVzz3I4NGTGDRyAqIk4QtVEe0sL+evGWT24LPpJKl4lPbmw1htDvwV1ciKBbvLg9wPuf8woSbo4MefmcdvH9nM/qPmd3viiBCXLRzOn57cXlxP1QzufHQLP/3s6bgcFsLxLMMqXeTXlf9uYkCuLYnF/+EfyHxPIUDmaIzgaYNKXs53pgmvaqL6/JGoyTyhhYPJtaeIbW7FUHWcQwM4hvhpf3lf0T5fSxdQU3kyx+IE5w36wOf0vBsYIColMMmA5PIjSBJ6LoWezyGIIrLLj6Hr5qCsJ4Tk9KOdSFZE2Xxvd2qxEqwxb8qGVty+aHeZCcpl2iSCYjWrOukoWjLGcZIjWBxmiq8og64iiDKG1mvIVJAQHF4ExY4B6IgIVidGGcM5vZBDsruouvhztD3xS3JNO4tLbYPGU3HBp4skBcxk4sQJeTxgBgcmt5oZQIlNrxBYeB3tj/2i7FV1jZuP5PAgKlYEd7BobNcbjhEziCx/uIR4mKem4J93RfEmq/irqbjgNvJtB6i67Cuo8Q4KXc3I3kqzTeXy9zsbBGCpaCS1dy2CbEFLxRHtLnLH9oKmklj/AqJiw7/g2j7H93agqwX0VITO5+7scwxqpJXYsr/xsfMu5peP9viwvLL2CFcuGvGeVVVOBtnlxz//GtLdyi/J6UeedhHhjjZeevAPFPI9n1FfqJoLbvocg8ZMIZtOUcjnEQSBto4Who2bisPtw9B1Rk2ezaGdm1j53IMsue7TvPzgH0os83VVpWnfdpoP7WbxVZ9gzcuPM/2MC3n5oT/2Ob6GEeNweQOkElFef/JvJTJnWbGw8NKbyWcyDB47BUN24rDJKPKH80ddkSVGNvr5/sfnkMoUUDWdV9c18Yv7NhDvtnL3OC3YrTJdsQzRZI7FMxt54OU9b7Flys2kD+AdQpQlZJcFPa9hrXSW+K3k2pK0PL6T2ivHYQgC7nGVOIb4Se7uJHMsTvTR5j5/g3xnGl3TzZmVAaIyQFRKIAoIih3RaqfQ1cJxomBooMayiHYPotWc2BcdbkSb06yM6BqizczVESSlZ3JesaGE6kFXMXTdDCfUCn2s2gGQFARJQUvHSmZRAIx8GjXSiuKvptB1QrtDlBG91cTiKvlufb8oCni8PmTJgpE+gUzpKoahI3srqL7ia+YsRSZpOuM6vUh2d8nqmaZSu+iegzKK56lGWtHVPK7xC0huW1aymmfaEizVQxAkhfTBLcQ3vACaimf6eSj+6u7zjaKE6qi98f/R9eq9ZPatB0PHWjeK0DkfRfGX+pMo/ioESSK9dx25tkMYqoZS2Yiloh7ZFSBw5g20/O37fQ5ZsDqwVA8h8vr9+BdeR3jpvaixDqqv/AbN937XDE9c9xyeaUsQfZXlz/skMPIZCrGOft1r03vXMXHmVSWv5VUdrZ9wuPcaajqOmugqzua45l9DIhHllUfuKiEpANHOVt54+n4q6waxttvsLVhVz6IrP4ogyebnWxRpHDmBSz7+dVY9/xDxcCedLaUDzLmsOR+lqSr5bAY1n+PI3u2cc+2n2bDsWTqaD2O1Oxk3cwHjZi5AlGS2r3m1hKQAqIU8rz5yF+fd8FmWPXEv4uDFtEQ1zp87hMqA4wPtBXIyeF1WvC4rB5qiPLLUlMmOavRy7Rn1iLkI2XQCb8UoXDaDKSMr2H6giwMdSUaFHOQ7y8ymCWCtPjWHwj9IkGwygbmDaHl0B1XnjyK1t4vErg4MVccStBOcPwTFa0N2WBAtEkZOI7q+uWy4IJgRAYV4FmGApAADROUECMieEGq8g3ItGz0TN91eC3lzBkU3jd5Elw+xzEyKIAjdw7Hm07mh62DoSC4/WipanFMpVkwEwXy9DIzuORmlYhCGmitKd0VPJeFwHq1X71rXDaKRHP6AE0lKmcO7sgVRURAs2W7zObMFJTlOHgRX7rzATCl2jZ1b9OTofPq3+M+8kdppS0xFkSjgGDoVwebE0ApkDm5GVKw4hkwkseU1MHRa7v3P7mttwj58OhVLPo5x9i1gGKZnywnECUwzPMVXhXvKYpyZ7pZcr0A8S/UwKi76HF0v3VV0tlVC9QTOvJHIsr9jrR2O4q/ulkVDYvOruMacRnLb6xhq3jSUy2fNeIF3oOwxRKkPySxdQUc/wYNkRIMPx/ukuNDinaRzedKpDJI7gBBqINvZSS5TfhD88N6tjJu1sPj/rrajPP6Hn3DejZ+l49hhhk+cgdsXpH7oaC64+QskY309I1oO76Vu6GiOHdjF2qVPsfDSm1n66J9pObSHcTMXMG3h+QiCiMPt5e+//C4X3vwFNr7xQtnj0TWN9mOHSMfDTKhU+N1Te3hxzWF++rnTGVT94Qo4PBFOq4THaaG+wsGNC/ysePTnJZWrxpETmHfhTSya0YDXZcXV6Cfy+E4MrZQUB+cOQnZ8+Ftn/wpYK5xUnDWMtuf34Gj0UbVkBIIsInutyA4Lci9TNsllITCrgY6lB/psR5BFrCEn9joPkmWAqMAAUSmB+WSYewtVTw7BYjNzXXQN0eYyKxIn9P/Lbl8UQbYgihKi1W4OtgqiqQyRFfRCvs+QrSBbkdwBDK2Ank0iyFYExWr6tETaUDWhhKT0RiKexx+sRRIMKGTQY2H0TJLE5leQx85B8b61msJWP8o0XzvhuPJtB7GceQOW6qHkWw+AoRN55S9EZQuucfPxn3E9aAXan/xVifmYEqyj6rKvkNq/CT1f+oSX2bee+LaRuMfPR7Ta35IkiLKl7HWXbE5c4+ZhaxyHlo6ZkuVYB+ndb+KZejaCZDFnSLqR2rWa0HmfIrntdSy1I8nKIZIdMYRYBHfAwO13Ib6NJ3Qjm0Lx96+gkL0VHI32XEdRgI9fMgGP619vaqamYmSP7SFiDbHy+Uc47+LbEBDJ9kNSADAMdK2UaOVzGY4d2MWRvdvYsuplLvvEN3H7g9idbjRNxeUNlBCWHWtfZ/FVH6ezpYlEpJPXHr+Heedfi8VqI9LZgihKxCMdvPLwn1DzOTKpxEkHalPxKDaHk2wijMOmkMoU+OMT2/jS1RNQhAIWmx3LWwyP/6NIxiJ0thzhwI4NON0+RkycicsbwGJ77+c9PIrER88ZTYXfYPn9P0YtlFbxjuzZyqaVLzN06tmkcjqHs3lGXDeR9JY2ssfiyG4L/pkNWEOOPgOgA/jHIFll0zK/3ouWKSAIINoVFHff77cgCLhGh8h1pYqSYwDRJlN19nC0goat7sNNtt8JBj6hvSAIAsZbOKIiCKBrpkmWxdad8/P2cyQE8XimT5mnGEHAnJMxn3qOkxQ12lZKFEQFJViDEqglkeg/JE9VdQR0tHgHRj4DBQ10jdiap8msfZram36I8hYtDsnlJ3jOx+h6/vclr4sOj9k+uuobZA7vILHxJRAEPFPOxtY4BkGW6Xj+d30cUgtdx2h75Cf4z7iByku+QHTFY2SbdqAEagie/VHSB7fQ+sCPEC123JPPwlo3AlG2ouczZjXK4UVy+02CdxIIooTiDaF4Q6jpOLnmfRiGTnTVE8WsoeK63YGDFZd9Fc1dzyuvNLF9cysY4HBZuPCK8TRUgWK1ILv9/Zq7GfkMha5j2AdPJFNGBeU/4wbuW2cOQo4dEuDWi8YzuLpvxehfAb2QA1Fm39Z1xLraePaJ+znnilsIVNb1+x6bw4mm9Z3/6WxtIlhdz+ipc4l0NHNw92bc3gDB6noWX/0JHvvDj4tVvGw6yfJn7ufCW75E88HdHNmzDTBY+cLDpBNRsukkutYTTxCPdBKoqiPcVl6aW1HbyJE9Wxlmc5LLm3/XTXs6aGluYcVDv6R26GhmLb4Ef6ga6V0cuk1Eu3jyrp8T6egZUl376pMsvOQmRk6e/Z6Ro+Ow2BXGOW10pg/0ISnHsXf9Mpz1U6mtq6GhykwSdp7hRM+rCLI08LT+HkCQRBSPFaWf1OzekJ0WQguG4J9eRz6SRVRERJuCZJMQ7QrSQNuniAGicgIESUKw2M0be9+lZmpxuAXRYjeVOZKOaHl3BiEFUUJ0eIqKHcnlM11TT5Qy6wXUaAdKoBr5JB9mWZFAK5Q9Fy3RRXz98wQWXlfq6XICxG43U1vdSOIbXkSNd+IYPgXH8OlFkuMefzqOEWYgn2Q1r0Uh3EJ695tlt1kItyAAbY/8nKrLv0zH080Ez/4Y7U/+smSYNndsD/ZhU3GOno3s8tH60E8QbQ4qLrgN++AJRentW0EQRGRXgK4tfQc2ZW8llZd+icTW10jvXgOixGmj5jPrY3O4/759pJN5HvjLBm792Fi0F79P8OxbcAydjGixYegaaiLSXbUxEG0O0oe24ZmyGEtlI4nNr6Ln0igVDfhmX4ISqudjF1fx0YvGY7PIuN/HfA5BkhFEsfj0H+tq44l7fs1ln/wmDSPG0bR3e5/3TJ63hJ3r3ujzujdQxZAxk1n+zN/paD5cfF2x2rjw5i9w2Se+wdpXnqCjpQm3N8D0My/EG6igqn4IE2afQS6TJpOIkU6cqFSD7W8uY/biS3nh/jv7LHP7gljtTnRdJ5qTi9JdQQBJVjjtvKuRFYWd65YzcvIcquoH/6OXqwRqIc/6154pISnH8drj91A3dDSWiveWqEg2Bd/QAIdWrel3nUI+iyILrNvZRkOVSYhFWey3nTuAfz0kq4xkfW+yiT5M+OBHlL7LEEQJ2RMqmzUjufxo6QToKqLdZaYSy9Zi6vE/CkNT0Qs5DE1Fcvq6pb4iIPQJv+v1Jgxdw2qV+rW9dnusGNn+A+qS25aVlUmfCMnmxFo9hNCSj1F1xVfxTj+vTyVGsjqKJAVAL2RPasWoZRIIkkxs7bP4z7iBxJalfRQ/AJn9GxAVK6l9G3COnoXsDqIlwhTCLRSi7Wa7rB+YRCKMoRVQQnU4R88+YQ2Bigv+g7aH/5vE+ufRkhG0eCeZtY9iLP0FV1zZnYFjwOrVnViGTKX9kZ9RCDej57Ok967n2B+/TPNdX6P57q/TfPc3cI8/nfSeNzFkK5XX/oDqW3+B/5z/IHNsN7LDQ8hnp8LveF9JCpiKH8npZ/SUOcXXcpkULz7we+ZfeD0TTzsLxWISQafHx8JLbkZTCxzdv7N0OxYrY2fMJ9rZissXKLHYL+SyPP2XX5JNJwlW1zPrrEsYOm4abq/ZGhIEAcViw+pw0jBiXNnjjHW1YXW4WHLdbTg93b4igkDDiHGccelHWLv0aeZc8in++nLP0O7UkRXo2SirXniYVx+5i2hnK/lsmnSq/+/CO0EmlWDn+uX9Lj+0q7zr87sNq8dKzZD+LdTd/hCRpDpgiz+ADzwGKiplIMgWlFADeiaBnsuYlQ67C6OQRU/HkNwh9GzKrKSI4kkrEieDoevo+QxqrKMoZxUUO7I3xIqN2/jZT29jw4YNtLS18+Ddv+PSK67sNpITQBT5zv/3Te76y71E43GmT5/F7T/6OUOHmKZRNrtizlWcVFAidB+HhqFpCLJy0h+144nObwei1Wma16mlU+2iw4Nn6jlYqocSOu9TGJqKpWoQXc/9vp8tQebgZrRsCu/MCyh0HiW68lEESUGZcjFS5QgUjx+3z4nUS5qqJiPE2rvQ0kmMroO46gfjX3AtnhnnY2gqWiqKaHeRObQVLRnts89CuAVHfC9VtR7amuO0t6dhSA1gEF35GP4F19L28E/ofYH1bIqOp/6Xmpv/iw3bc6y8cw+ZdAGv386ZS87DJbpOmS+cIAgooTpsiSiT5p7N5hUvAtDVcoT77vg2p59/LVd95ntkUnFiYXPgOZdNm+3R7jbOqMmnMWHOmWx84zmiHa0EKms5/+bPs2n5C8WKTD6XIZNKsm/rWlKJGIaus2vDci775Ddxun0AKIqVaQvPZ9/WtX3aGC5vAH9FNS5vgOpBw8imkoBBJpkknVcZseAmfvnkIZo7zdkap13h2jMbeP2+HxeHgg/v3sLR/Tu44tPfweH851tthmGgqeXVGvCvNakLVNXiDVYR6+rrQzP+9Iu5Z1UbX77u5PlVAxjAqY5T5XfzlMJxtY7g8iM5vCQzBaKxPOmsgNNegTuv45QlBJvrnwqjMwq5Po6sRiFDIdxMKpVi0sSJ3HTFhVz90duQHF70TBJDNSXIP/vNH/jN7//I3X/8A40Vfr7/s19x481XsH7dJpxOB7mcSjScIeBzQa78D6drwkIMTSOx5TXUeBeiYsE5ajayr+IfPi81EUZNhNFSEWqu+Q7Zo7uJrngYS0UjnunnYqlspPP5PxFd/hAA1sZxhM7+6MnTkgUB2R1ETXTR+dzvsE08h2TdGTz18jE627aiWCSmzWlk9oKheLx24uEE2zcc483VbaSSOS67YjxK6zbaH/mp6f4LWCoHUXnZlwm/eHe/u9UPrGLW7Ot58tE4wZAdkqYcNN9+mFzrAcqzQIPomqeIqgvJdEsPY5EMj/19M0suHce0OYOQpFOjkGnxVYIoMWn2GQwdO4U9m9dQyGUZPHoSlXWDeXPpk+zZ2JOpNHb6fM6/+Quo+RxWu5NsKsnDd/6oOH/ScngvOzcsZ/FVnyCdiNHVakrpdU3lwlu+TiZTIBHpZPMbj5NNJYtEBcAbqOTK//gOK597kMN7tyGKEiMnzWLGootx+8yASZfHj+t4VQWIp3LkWuJUB53YrQpTRoZYMLmK5Q/8so9ySVNV1rz0KIuv/iTWf3LY1WK1Ud04nNYjZVJ0gUGjJv1T238ncHn9XHzrV3j9qb9xaPdmMAzsLg8T5l/Cji4X44dK+HslNw9gAB9EDBCVk0AQBDoSeX794EY27u6R0U4ZVcFnr5hE0Klg6DqGljUrK++g4mBoGmqinzRNXeOcMxZw7pJzzdyhj96Glo4VSYphGPzvH+7mG5/7NBcuORvRaueu/x1C/ahxPPvo37j8+o+RjJvrFnQF2eLAOEFhI3srcE86k1zLPrKHtoEo4hg+ldSeNdgax2KrfeepnPnOY7Q+8KOSYVVb43hqb/ov0vs3IFjstD7wXyWpvv65lxNb9yzOUbP6eLAch33oZAwg8spfUSoaiNcs5MG/9ZimFfIaq5cdpPlIjEuvn8yzj+5g707z71Xb4MVfOED0tXtLj7X9MOk9a/vNVgJzyHZodZ4p06qYNClA7jnz+JRgrZmM3Q3R4cE6YQlS9SjTQ6V1KwGh71dr6XO7GTWuCu/7YO7WHyyeIBbAE6omWNMIho6sWIh2tZeQFIAd615nx7rXsbu8XPqJr/Psvb8ukpTj0DWN1S8+ysJLbiKbTiIIAv7KWrateRlDNxg0diHzLvo4irX05ilKEsHqes6+9lPkMxkQBOxOF7LSf4vM47QycXgFIxv9FFQdUc+x6rkHCLf3jVYAOLJnG/lc5p8mKjaHi9MvuI6H7/xhH/v/mkEj8AXfuQfPPwNPIMTiqz5BIh4jnkwTTRtsOJBi+phqhtZ5cf+bBNcN4MOLAaJyEiTSfUkKwMbdHfz64c18+fIx2PLHyYaAaHMhe4JvsxVkFJ/uyy7NZxFsLiSPOa3fe1bl4JEmWts7OPP008wWhtWB2wIzpkxi9Zo1XHPDzbjcFpKJPLFoHp/fj2xzQzwMkoxv7mV4h00ivPRvpHulECe3voZz9GxEqxPZE0J29Ty9atkUeiaFnk8j2Vym8qYXKVMTYVrv/39mG6sXLJUNxNc/R+bgZrxzLikhKbaGsWDoJLe+RvWV3yRzaEsfHxLn2LmokTZsg8ejxtpxLP4sL79UXgFy5GCYaCTD4QM9+5gzO0R27R1l10/uWIF78ll0vfinssudY+YQeeZ/WXjJV0lsfY1sd5ijZ+oSkjtXmOc3eDJMu56Xl7Zy8PmjWK0yU2fNZsqsRgS7m9XLDhCPmnL3XFbtbgWV3d37Dpu914zRSVsbCdLxaIlvx3E43T4WXHQDO9a+zv5t69B1jcr6Icw77xrsLjfNh/ayZ9MqLFY7k+YuJlhVh93VI8O02hxYbe+MyNksMjYLFPJgtfefgK1YrCdN6XonCFbXFytAxw7swmp3MvG0sxg7Yz4Ot/etN/Auw2q3Y7Xb8Yd0QlmVMSMF7NYBf5QBfDgwQFROglgy14ekHMfG3R3Ec6OxFX/5DPRsAlUA2VPx9gZsJRm08jcEQZIAA7EM6WlrN4PtKitC5mxL99BqVUWItvZOtGgLDm8V9ioXhXz37IvFhuwOIjmT2KpHkt6zooSkHEdq12ocI6abwX4uP2oqRjKZJ50soCPi8vjQm3ahaFkco6Yj2UyvEzXe2YekADiGTaX1gf/CPeM8ZE+Q0JJPkD22m9SOlbhnnGuGPGoqnc/dSei8T5E7tofMwS2IFjvOcXOxVg+lEGk1Z4UkBcNZQbjzYL+X9MiBMIGQk9Zj5mCu2ymhxjvLrptvPYDl7I9irRtVzLo5DvuwqRhqAS3RSXbrS4jpOILFTmDhdSR3r8Y5ahbpfRtg2vX8+a6d6N1GWrmsyqplBzmwt4vTF4/g3EvHs3LpfpoOmQTsZCqtUwk2pxurzU4u21cx5gn2779z+oXXsfTxv5CI9Fzz9qMHefyPP+H8mz+PxxckGQsT62rn4M6NjJuxgNnnXI79XZgdUSwWRk+dW5y3ORHjZp+B3fXukAhZUaisG8y5199GPpdDEAUcTg+i9P7+fSVJxPM+D2oPYADvNgaIykmQyvT/VAmQzmpwQhVZzyQxXIG3JCqCJCM5fWjxTkSbs5jSrOfS6Lm0OYz6Vp4u5obKvqzF2gARxe5CcvkRZQVV0xAQKLQdJL3t9X43mdq5Cmv9aNRklK72JCtXdzBuci1d7UlSyQgNgwdTUamQPbYX57Ap5v4SfV1IJXcQLFbqPvoT9FwGNRkhuXsNssND1VXfAARQzBaAGuug7cHbsTWMxdY4FkPNE3vzaaqv/Aa2ulFo+Qyu8fPR0REloUgMToTDZSGX7fH6yGR1bE4vWqqv9BUg33mUios+R/bIdtJ71yGIIo4RM9BzKbpe+rN5bPFO/KdfhWv86cQ3vEj20FaMbAr/Jd/gyedayx5LW3OcfE7l9Rf2cNUt0zl6OMKBPR04TvGbSD6vkkrkiUVg0TXfQSRJW9MuOpsP0rRvO2ohz6LLbiWfzaJYrIycPIfBoyehqQUUixVZsaBpKla7k3wuU2yN6LrG5hUvUlk/lBlnXlTM9tm+dhljZy54V4gKgMcfZNZZl7Lm5cdKXg/WNDBx9plI7zKRsNqdJ63iDGAAA/jnMUBUTgKn/eSlU4et3I+ecVJZbm+INieiYkVLx83KgmAmACuhehDEUrLTS41TVWm2g9o7OqkfOqrbcE6graOTSePG9NqDbiYy95ojMAwdNdmJnu/ffVcv5BAkhVhXnNffaGfU+Goe+vP6EgfcqloPV1w1HGsqhuz0IvuqSrYhufxUXPAfxFY+Tmb/RsBAcgfwnXZZt+nbz6i98Qckd6zANe50kttNf45s0w6y3anOwSUfR/aag70y4J9/FeGNyxg3oYGtm9r7Xk9JoH6Qn0i4Zx5n9dow50y+kPSKe/usL1jsyA4Puq6TPrzTzHHSdcKv/rUkysBaO5zw0nvJHulJm07tXIk4/gJkRebKm6dhGKBYRCwWmXxOI5nIkoxnCVW5WbviMJIsMH/xyFOaqGTSebZuPEY0nKamzkcg5KDpYIb2rka8VSM4e9bFyFKeRLSTvVve5KKPfpXta5by7L2/xtB1HC4Pc8+/hnOv+w8iHS3YnR6iHa2sXfok+WyG5oN7GDFxFqIkIyuWosJnz8ZVVNUPeVfOwWzBLGLI2Cns2rCCbDrJ8IkzCVU34DpVe24DGMAATopTQ35wisLrsjJlVPky95RRFbjlcim9QgmpOCkMw2xrZOJm8qGuoadjFMqEFkqugJmeDAxpbKC6soLX1mxEtLkAgZQusXbjZmZNm9LrUKTuNOfSP3Ou9RCOof0rE5xj5iBYrETCOSbNaOCpB7f0selva46zcmU7Wnc1QbTasdYOLy4PnvUROp/9HZn9G0wFlWJFS4TpeuGPWKuHIrsDRFc9gaGq2AZPwHf6lcW8HiVQQ+jcT+IYNrVkDkb2hAhMW8TCc0ZSUVX6FCuKApffMAUbKc67YFjx9cP7w3TZxmKfeHZJhUpy+fFf9i1ykpfEkf0oYxaR3PYGye1vlJAUwWLHNe70EpLSe1lto4/H/76Jh+9Zz9//uJZnHtmKIMCmN49g6DB1TiMtR6PY7Rbu/f0aYpFyRoKnBrrak3h9dsLtKRwuC8te2IMv6KCm3othCKTTMobgQ9NFJEnmwPb17NqwokhSzrry46xb+jSP3PlfvPrI3Txzzy/Zt20tZ1/zKRSLDbvTTSGXJZOKl8yhqCeZh/lHYLU7CdU0MO/8azjryo8xeNTEAZIygAF8gDFQUTkJ3A4Ln71qSnnVz2XjsKt9Zx9Em/NtKX8MwzAJil6G7GgF4l3tHDjaSj5vEoQDhw6zraGOQCBAY309n/vsZ7n9Zz9n2OBBDB87ke9+73vU1tRy2TXXI1ksYOgIitVMc+495yKIiIqCY8R0kjtWomdKTbBkbyWOYVMxNJVUWiMTT6Gp5StEW9Y3M+/MocjZNOHX76figtsIL/0budaD6IUsoq8a55m3kcpb0HQDrxMK254juupxPFMWE172d2pv/CHH7voatoYx+Bdej2h1oCXCGI4AG7bEqagWqah24e6WWMouH0I+xYJzRqNpGs1NMQJBO4MHu2D3S2R2NzFi2sV84rPT2bKhhXhKR1U1XHOuRBp9FkY6gqDYiGYU7nu4mZo6F/NPq2HVm1FmXfBVMq/fbboBA5bqIbgXfRLREyRw5k2EX73HDHe0u5GcPlo7NJa9sKfkmnS2JXnsvo1cePUkHrx7HeOm1DJ1diPtrQnSyTxtLXG8/vc+C+adIpPOE4/leOSv65k6u5H9uzqYMquRx+/bSD7XM8hdWePmipumYlEkXn7oD8XXp51xASuefYBIe3PJdtuaDrB5xYtMmHMmkqywZ8sapp5+Lpl0z+duVC/TuQEMYAADOBEDROUtUOGz89UbphNL5khlCjjtCl6XFadFQI1aSwIMhW61zNuSKOsa+kkC4NauXsnZl1xV/P9Xv/Y1AG646jL+eMdP+eKt15DoauO2L32VaDzB3NNO46mH/46iZtD1PJLThyApiCfIbwVBwD35bMLP/prKS75AcuvrpPauRRBFnGPn4pt1EYqvEi2TJFjpZs/e/t08NU1HR0TPJLA3jKHz+T9grR6Kd84lZDrbiA6/hqf+eoBC3rzRiZLAGYvOZKi3BskTNM3rFBs1H/lv4m8+RezNp1GC9UjjzmXNxiQb1u0CoLbRx1UfmYbHa97gHU4r7a1xDu7t5MKLhqBvfxpb1wjE+uEYtUMhF8XStZ05o6pJ7VpDYdthUsJ5PL7STldnCl3Ti92wrs40p50xnEMHm2gcMYKGS7+LrGcwEDl8NEtrs8L0wXbcUxYjjFhAPJImGs5Q1RjitT9vQJZFtF7bA8ikC0S70gQrnWzf2MycBUN57UWT0HS0Jhg5trRNdiogm1F59dldGAYMGVEBAjxx/+YSkgLQ3pLgtef3MOd0T4k5m8cXoqutvCy4ae92ps4/j0wqTtPebcTC7cU8n8aR4/EFT73rMYABDODUwQBReRtwOyxlvQgUfw2Grpltm24PlbdvlHbyFtGCeXPJR9vR0zHkQB1qtB304yVyHUEQ+M+vfYH//MZXkH2VqOFWQDd9PAA1nzHJiqtviJ7iC1F16ZeIrn0GwWondN6nkN0BFH8NsssHgGR34fIVqKnvvzvoDzqwWGTQDUSLg+yRHWSP7CDTtBP5zC/x6P+uK/FE0zWDV148QuUNU3Eb7bgmLeLNDXFWvHaQ8RPn0zDOQUVdiGVLD7N7W88MSvORKBtWH+H0s0aQTubp6jD9OSZMqQNRwjF6Dl1P/ao40CtY7PhPvwrZHSR7cJOZt9OxG39oLu2tPcRr2KgKJs2ox0Dk/Csn8OzDW0mn81RWubHZFcZPrWN4o3k9UjmR++7eREdrEgT4yG1zOOeScWTSeRRFIp/XWLl0Px3d2+9oS+DzO+hqT9HZnoTuolRlzamZiKoWNMLd7q6SLJJO5sjnyrU2YefWVs5cUlecM5FkhVzurVtaB3duYt751/Lqo38mVNPApLln0zhy/D8k581l0mTTSXNw1+bA6fG9420MYAAD+GBggKj8ExAkqVtG/NYwdB3D0HoNtgqIDjdavLyXimR3oXbfeI+Tj7LrOTzdN+i+7RnTJt7Th6gIgmimFZ95A1omaSYRSzIYOoZhFG30PT4HOjK1DV6am/qqZs6+aCxurw0t4yJ7rKcFIrkr2LCurV/7/hUr27nwdIlC4+m89rttGAZsWNvChrUgSQe4+bbTaBjip5DX2LW1lbbmOGtXHGLitHru/9Na88Z/fF+yyNXXj8W35EukCwoIInaPi1whTywr47jidrSdL4PFSfpoz7VeuGQkGPDcY9u47PopPPa3TZx53mhkRaT5SBS700Ig5CTSlebV53ZjdygsOn8Me7a3UVXrYfvGFtatPFT8czrdVs6/YgLLX95Hc1MUf9DJsSPR7ustUChouNxWKmven7Tkt4Ik9xDSaDjdb7sPwNANBMnJ+FlnsGn5C2hqAZvD1e/6gijidHs549KbkSSZiz/6FURR/IeVPrGudl5/8l4O790GhoHbF2T+RTdQ1TAEWbFisQ44sQ5gAB8mDAzT/gtgaCqGVkCLhyl0NFHoaEJLdCFa7N0BhKUQbS6QZESLHUQZPZdGspe/EQiypaT91GffZZZpmSTZY3vofP4PdL3wJ9IHNpFr2kXbQz8m9ubTpgIJEBUrgQpzJmHanEbk7puZP+jg6o9MpXGQeeyS3TSAKx6TM0hnR7rPfo8jGs5A5Sju/evukpZJIOTkmo/OYNuGY2xYdYRdW1sZP6WWS6+fglbQiYbTJSQFQFN1HrxvB2E1wJ/v2sWf/7SDP/12PQcO59ixrZPf/e8m1kXHYxm/iKbDppdJw2A/sizx2gt7GDQ0yI7NLVx09STWrjjE4/dt4s3lh1j2wh7+eMcbdLYnUQsaa5cf4v4/rcUXcOByW1m74lDJsacSOR7720bmLx6BxSZTWeOmvSWB1SYjigJev50bPz0br+/Um08BsDsUBg0LALDm9YPUD+5/+NTpsiBKMlPmn8voqXMRBIH2owepHza27Ppjps7FYnNgsdqRZAWn2/sPk5RENMxjf/gxh/dsLZL+RLSLZ+75JS2H9vLaE/dwaNfmsknMAxjAAD6YGKiovMcwA/9UU8nTa3BWzybRcxmUYC2ixY6eS2O62zpMdY8oU7D4EC1eRPKIFhtaNlliECdIFnNQVhDftiTaMHSSu1aRWnpP8T3pPW+iBOsInnUzrQ/+N4nNS6m55lvIHjNjxZZrYaryBtNvmIshypDqpLDqpxS0C7COm4eoWHGOnElk6d/Mc4s2U1szhUPlo1CoqvGwf3+MTKrnXCRJ5NzLxvHY3zaRTvVUkNqa4zQODXDxtZPZt6uvJBlALejEoxncHhvZbAFJFnnp6Z1cfsNUdmxuZuO6VrwhDzPnDubNNw4xeWYDS583Dd6CFU4M3WD3drNyU3qt4PnHtnHNR2eya1srGPDqs7u4/hMzEYQ+7vGMGl+N023l6o9MRy1oXHrdZPwhBza7hZs+PQeX2/q2/kbvB+wOC+dfMZE//+9KouE0akHl2lvHoWsq+bzBpnVdHNxrEthF54/B47EhiHZmLr6K0dMWg5Fm2LjpvPnqExzYtg7DMBAlidFT5zJ53pJ+WzO6ppFKREnGImhqAbcviMPl6WOxfxxtTftJxvp69gCsW/o0Q8dN4+m/3MHQcVNZeMnNOFynZqttAAMYwNvHAFF5j2HouklCyql7DA0tnehlj2+gxjqRnF4M2UqhICKKAqmciEcREdzVCGraXN/qpqAa5LNg8dYhaDn0RCcntoAEi/mDr+s6hYJGIa9zND+IustvR9/7GtnNzwFQ6DpGet8GHMOnkt67jsyR7bjHz0f9/9k768C27rP7f8QMZmZmOw4zp+E0Ze7adW3HDO94e8f7Dd5Rh+WVMYUwc+KAHbMdM9uymOH3hxLFiuW0W9Mu23r+inWvrq6k6N7zfZ7znGM1MfL6b/GM9sC53WHHHt36JxQZpQijEhBrYohd/SCjb/8RZ+dZym68jeNHBvBe3kIQwMz5mbS1hLvYFlUkUVfTF0ZSLqL7vIH5y3JpbQgnKulZ0VTMTEUmkxAdq+Tuj8/G7fLh8/oQS0QMD1gon57K8YOdnD3Ryx0PzqK0KgWhUEBSio7S9SnooxS43T6ee/RE5O8vAP09RhKTtSG32+7zBhJTdAz0Xlq1L1ldgNPh4dHfHgoZwKnUUm66p5qoaGVYa+VaRWy8mo99YQF+rxO7ZRSHx4xprJ+2uhPkFs2kbFoBAqGC/OJ4BMKL7UEtfr+YzrYBdB4D8UnpFFbOIQCoNDqkChVKtSZiKrfP66W/s4WtT/8OlzNYgRMKRVQvXkf53GURqy69bZPHxC9ipL+LaYvWAHC+/hQVc1d8SFQ+xIf4D8B/BVEJXL70/WBf/EK1ZIrNbgdCuQqf9dIqUSCR4Xe7cLskqNQyPG4fHo8fECBVaHG7fBgva61IZSJ0+kT8xgEuikNE6mgEQhE+nx+bxcX4uBW7zc3hPcPYLD4WLp5OwRwdjiPPAmBtOEjMsruxt57EcmYXqrwZ+B3mIEkRiieTLZ8Xz1gvkqgEhLKg34g8vRhrw2ECY/Xc+cAsXnu+nvGx4LmqNDKWrS3E6fZSVpXCsX2XrPCzcmPYsaVxys+p9mQv5TNS2fNWsBKybG0hAX+A3W81o1JJWb6+iH3bWkK6kOhYFcvXFTF9bjo5BXGYjU7cTi86vRyXy0dcooa3XqoD4O6Pz8Hrmboi5bB7gqLhC3C7fEgmWOHHJaiRKyTseTvcht9mdfPUH4/x0BcXEh0X3rqzmJ2YjQ5M4w700Uq0Ojnqf3HKrc3iwuuy0HRqH/XH9uJy2olPyaR68To6Gk7j89iZtWwjElm4sFwfraSkMgOH3UN0fCoBvxuBUIBMrryidsViHGPLY78ITQBB0MH2xO7XiElMIbdsxqTnaK8Q+KdUa3FPsPw/d3wfSZn5CN9NnMWH+BAf4prFfzRRkUiCo7l2ux2F4l+kDRAIrmyFf1nbRqjQEnA7EIhk+H0BHHYPcoUEh91NVIwKvy+o1bgcbpcPh1SMQqkDnweRWo9ALEUgFOFxerBaXHg8bnw+P05H8PX27+0l/a4KhIo3gtb/HnfIVC7YUhKAUETCzV8j4AoSKmdfM6ajr4cEvoEJYYlCmQKpLJXohcGxamfPOLMXZaPRygkEAmi0MsbHHRzY3kpWXizL1hWy680mCIDfH0AonHoKSiAUUD4thbFhGy6nF6fDw6Hd7QBsuKWCl586jXNC5IFh1MYLj5/k7ofncHTvedou+OAsX1+E1eTk6P5LJMk87iAx5VLF5HKkpOupO3Vp9Da3OJ4zJ3pCf1fMSOPEwc6Iz/V6/dSfHaCwLBGVSopSLcMwauOZvxxnbOTSeHpcgppb759JVMy/JlnZYffQ3zPIucPP09d+qWox3NfJtmf+wIpbPkbN3jcpm70EnWyyCaJEKkYiFTMpU+IKaK09HkZSJuL4zldJziqYVBHJLp7GkW0vTkotBiieuYjmM5fyq/y+yFNLHwT8bh8+pwcCIJSJEcn/oy+1H+JDvK/4j/71iEQi9Ho9w8PBloFSqYxYgn4/4fX6CAhkBDyR/UiEcjkBh4MAYkRyNQGfH7/VBKpYXC4Xfr8IiUyEQCDAYXfgdHrwTjEFZDJ5EEQp8AukSL0g8Hvw+10YDQ7sDjsGwyjdbTZ83ksVpuM14yzKn4/j7FYUOVU4e4PeJbq5m/HZjAy//HPcw12h/RXZlcRv+hzDr/yCgN+HNC59yvcel6CBAOx6s4mUDD1Wk5OzJ4PJx8MDFkqnpXD7R2cyPmZDo5NTVp3CsQkEYiLyiuIZ6DOh1ckpnJ/I478P3pDSsqLo7TSEkZSLCATg8J525izJDhGVmDgVu99qCttv22v1rNpYwnOPnZw0qZSYosXt8ob0NBk50chkYmYvzObIvnbcLh8anRzD2NSeOMODFgZ6TQgEsGJ9Ma88fTqMpACMDFl5+elT3HbfTJTqD95m32Z1EfDZwkjKRJzcvYWSWYtx2izooqcOJXy3CAQCjA50T7ndPD4akWioddGsufNTbP377/B5L23PKqpCH5vIyd1bQo8VVM3F7/UilH6wn6fb6GDsQBfW1jHwB1Bm6oldnIU0WhlqmX2Ifw+MGO20dI1ztnWUGJ2caYXxaJRSdGoZgUAAt9ePUiZG+m8SNvrviv9oogKQmJgIECIrHzR8Pj8+jw+h3wGey0aRxVIEJjcCvxf8XvyeXkCAUKHFNxZcsQuEQdWmy+VFIBAgEIBrggmXAJBIRYjFQgIBMJoFBAIgEgkQCoX4/QFsFhdut5fuNhtt9eFTM1aLBzK0CKRytFUrGdvxKNpbfoxLrGLs+R/hGQ1WEqTxGQhlKlyD57Ge24+mcikiTQwi5dQeGFKpmJT0KG66pxqzyckffx4ehHjuVB/nTveRVxTPxlsriYpW0nxuaFLFqLAsEbPRSXKajqZzg+QUxoVM5GLj1WFakcvR32tCeiHuXigUIJWKJ4UIGg0O6k71ccOd0zi0u43BPjMSqYjKGakUVSTz4hM1aLRyKmakkpiqw251odRIuPcTc3G5vCiUEuLi1QwNRCajcfFqmuuHGOg1kZEdw7J1RTzzl+Oh93ARfV1GbDbXv4SojI/aGO1vn3r7yABqbRRiydU5N4FAQHJWAe3nTkbcHp2Qgkg8+bXEEgmxSemsvuOTWIxjQQNDfQyDPefZ/eLfQvslZebhsJqwmg3oYxOvyjm/G3hMTnr/XovPfok42zuN9Dx9lvS7q5Beg67EHyIyBkZtfP0PhxgxXmon/n17M5+8qQKFTMyQwc6uEz2UZEWzcVEOidGq0GTkh7i6+I8nKgKBgKSkJOLj4/F4rm6myLuBzebi9WfPUlykJyVeQaCvLjgRkVzK4LiQhLgEtFIn1tFxkKsJKKOpPztEc/0gXreX1Mwoyqenca62G5PRwdzFOezZEVz1xiVomL0om8baAXo7x5FIRRSVJ5GcpkOhkHC+dRSpTIJhxEvNkf6wSspFZGaqkKnV6O76CQ6rDcWm7/H0X05y6+ZEPKO9SHNmIpm2mc4uBxarl4xSFQrBOJqUZMSaqGCQ3xTw+/0E/MGJkuZzk/OLAAhAa8MwdpsbqUzEyg3FjA5ZaG8ZRSoVUVSRhNPhobF2AKVKyrRZ6cgVEpQqKU6nB78vcEVth0Yrw+0Mfu9L1xROqVdqODtAX7eR2x+Yid8XYGTIQnvTMK0NQ6xcX4zb7aX+zAAHd7XxkU/NpaNtjO2vNuLz+YmOVbFgRR6vPXNm0nGlMjFJqTr2XrDaP3Wsm9kLs5izKJv9O1on7T+Vydr7DaFQgFQ+dQqwUChCJJGiuIri1MzCCo5ufwmPa/II/ZxVN6JQRda3jA328Mbjv0Kl0aOLTaB60Vo8Lge6mHjEEiklsxaTkJSBa2QU37gJt0SBVPePm8r9owgEAljbxsJISmibx4/xZB+xS7IRfngzu+Zhc3j44yu1YSQFgi3qP7xUy5fvmk5avIaBURs9QxZ2nezhx5+YT376h5lS7wf+44nKRYhEoqse8f5uIJfLWbKqhCcfOYJYIiItMxiY17t/kJyCOIqn61EoJHiEwdTfnc83hdxNAZpqR2ltMHDHx2bS32NCo1Mhk8qxWpzMW5LP84/VhK3MB3vbSMnQUzUznd1vtiEUCbjt/hmcOtLL5X0NqUxE1dxc/IFctu9uJzZeRXtTPW6Xl4DDiCx7Oqbs63npzy0E/MHnHj4IcYlqbrlby2iHjcRkMdrLvEHsNjeGERsnDnficnqpmpX+jlMvIpEAqVyMWCyk6dwgKRlR+Lz+oK27P8DG2yp57Zkz2KxuklK13PXQbIwGO2aTi6RULWeO90Q87uyF2Rzeex6ZXIw+WsFAr2lKPYpIJESukGAxOXn5qdNTnqvfH+DY/g4EQgFKlRST0cHIoIVlawo5sKs1ZDsfFaNk1caSEEkBcNg8uJw+Ui443k6EQBAkdf8KRMepIJCJUCjC75+sG8kqriI6LumqTtFo9TFs/thX2fbsIxhHgkRWplCxYN1txKdkTvm80cFglc9mMWKzGOnvbCE9r4T8yjn4fV6SkjOxHz2FKj0d/8g4To8fv9uNQCRCFh191c7/cvi9fgJ+N7rqWJwDLlz94RU2v8+La3QEr8WCUCxGrNO+r+fz34BxszMopRMK0V7FZHKzzcWp5shVeI/Xj8HkZGTcTkVeLKebhynKjObQ2X6SYlURXcw/xHvDfw1R+VciJV3HfZ+ez643G+k+b0ClkbF0TSHFFUkoL/y4YhM0GEZtYSTlInxeP2dP9FJYlshLT55i022VjI/ZOXm4a1L7AIIthOlzMlBrZFgtLvZtb+WGu6dxYEfQNRUgNTOKtTeU4Q/An39xAK/Xz80fmc7ut5oRCAUIlFGIp93Ay39pDZGUixgZtHJgdwdKtYzxMTu5hfEoVVIUSil2m4v921s5PkFc2lI/xJ0PzkIgFEw6FsDKjcWYTU7efqUejVbGyg0ldHeMMTZiY+7iHPQxSra+Uo/N6kYiFbF4VQFbnq8NvZeKGams3FjMzi2N+Cccf/rcDJRqKe3NI2Tnx9LROkZT3QCbbq/kjRfqwpKM1VoZN99bHRL+avVyzMbJK/3kND39PSaWrS0kLkGDzeoKPaexbpCPfHIuNpsbt8uHxeRk22uXpp4A0rOjGew3odbKgn27CR9H+fRUVJp/zUVOrZUzPqZg/vr7OPD6X8IqT7qYBOasuhHdFSZu/hkIhELikjPY/MBXcdgs+P0+5Eo1Ko0eYYRFhcdsxmd3kJdVgm36CE21R/G4XRAI0N1yju6Wc8iVavILp2E8fYbuJ4O+PgKRiLgli0i9YTO2nl6UKcmTEsXfK1wGA6aztQy8tZWA10vM7HnEr65ibP8QPpsHXXUs7rFmznz6OfyuYAtYFh9P4Ve+iCorM6LDtcdqxe90gkCIVK971y7Y7wYBvx8Egg9cs3e1YLG76R2yYnN6ON08jMfnZ1ZJImkJGuKj3rsg3esLTPJJmgib04PL46MkO4bNi3Px+PyIhALae03E6uXE6hTIZR/eXq8WBIF/6ezue4fZbEan02EymdBqr23PBIfdg8ftRSAUoNbIJl0kXn3mDLUnL02XaLRyCkoTSM+ORqtT4HZ7aW8a4dyZPjbfUcXf/3JiSqvzsuoUXE4vLfVDwWPp5FTPTqewPAmxOFg5EAgEvPBEDZ2twRToG++u5sUnaoL/vrUAp8PLG69F1i2IRELu/eQctjxfi9HgID5Jw7I1hShUEh752f5J+xeVJ5GZE83br9SHPV4xM5WEJC3bX5sg4hQE3WNXrC/mwM42WhuGQptmL8xibMRGa2P4aqegNIHpczOwWd3YLC7iEjWo1DIG+024XT4UCglWq5OdW5rQ6uUsua4AgVCAccyOLkqBSCQkPTcG7YU20mCfiScfOYpjQhlfq5dz630zsJidHNrdTvd5Q9i2m++djtnoQCIV89ozZ7BawjVJYrGQW+6bznOPnuT2B2bx1B+P4vcFEImFVM5MZd7SXPRX4SL7z8Lt8mIxWXE5zPS01eGwGsnILyUuOQ217l+38ve53dg7uzj/xz9jbWtHIBKhnzmd6PXX8fbrj2Ezj4f2nbNiM9rGXoa375x0nKR1a4mZMxtZYgLy2Jirdn4ug4GWn/8Sc324EFmWkED+Z7+M4egYykwnrb/+xaTnihRyKn/9C+QJl4IZfS4X9u4eOh9/EnN9AxKtluQN64hfshhpdLC14Pf48Du9+L1BwiGSv7vJIo/ZhaPPhLV5DJFSgq48EYlehkguecfnXivw+nzUtY9xsmGI1w+cD9tWlhPD52+vJjaCA7TZ6mLc4mTc4sLu9JIcq0KjkhKjm7zvmMnBl39zgOHxyBlW37xvFmMmO4kxavyBAH99vZ6eoeAiUywSsH5+NpuX5KG/hk0erwW82/v3h5TvA4RCKUGhnHxBsNvcuC+IMiEojl21qQSVWoZQKGDP203BVoUAcgvi2HRbZbC6IBFNSVQkEhGOCeZpFpOTvdtaKK5MJjo2qEUwGuwhkgLgcXtRaWTYLC5OnBghJz92yvfi8/kxjTsYviAg7e0c5/XnzrLupnLW3FBKU90g51tHQxWDxtoB1BopD3x+AaePdWMyOMgpiCO7II5Hfr4v/OAB6OkY5+WnTjF3SW4YUcnIjeHogcmTQc3nhmg+N8Rt989g3/YWJBIRKzYU09dlpKVhCKlUzLQ56dx4dzWvPXuG1549i1whQa2VYbO6yC9OoKD00s0iIVnLxz6/gMF+M2PDNnRRCvz+AF6Pn7Mne8NICoDZ6OS5R09yy0emc+poF7fcN51Du9tprh8i4A+QkR3N3CU57NveSnKqHpvVxY13VeP3B6s3zecG2bethZUbiv9l7R+pTExMvJ5AQEdCSuo1Y1Ln7Oun7qtfJ3BhlDng8zF+5Bi21naWffJ+Xn/+DwiFIkpnLSEnt4z6Xz8W8ThD23egn1aJx2B4z0TFa7PhMZkJ+P04enonkRQA19AQhpNH0U+bxfm//DricXwOJ+M1p0lac13oMdv5Dur+55twYQTbYzTS9cRTGGvryP/cZ/CKJBgc45zsr2XIOUaJPpdsVRpx+lgkV7gxekxOep+vw2u6RKDNtYPEzEtHV5X0b0NWxk0unC7fJJICUNc+xqHafjYsyA5bCBotTroHLfzqudOMXCAfAgEsrEzhnrXFxF22QIjRKfjY9eX879+OTXqNGcUJ9I1aqcyLY2DUxiMv1zI+YVHi9QV4ZV870To56xfkIPpw0us940Oi8i+GxeRky/O1dLSNcuPd0zi2v4ONt1ZQc7iL2YtzeO5vJy61MwLQ1jTCQJ+Zm++tprQqmZOHuyIeN7conleeDtdZRMeqkE9Ydfl9Qe+Si8evOdrNguW5bH2lnoFeMzPmZU553rHxasymYGtEKBSwenMpfn+AvduacTu9ZOXHMXtRNm+/fC7U+jh9vId5S3NZvakUnz+AWCykrWl40hTORRgNDlSXTcD4vIEpww4BzCYnHpePNZvLePHxGlzOi+JUFzu3NJKSrmfVphLeeL4Wp8OD0+FBrZGxcEXeBR+QIAQCAbooJbooJZRAU/0gL/3tJHc+NJvG2sjCYIvJyfiYjfLqVJ756wluu38G0+Zk4HF5Geg18fpzZ4mOVTFvWS4vP3UqdG5xCWrKqlM5tLuduUtyUCiluJwezEYnLQ1DWMxOcgriiU/UoPsApkYEAgEi8bVxcfXa7HQ99XSIpEyEe3QU2biNmx/8HyRyJRKBCPOJU1Mey+92E3C78TmmNmB8N3AODdH2hz9hOn2GhBXLcBvGp9x37NB+EpYtxNHXN+U+lpbWEFFxm8yc/+OfQyRlIkxnzuI0G2nxj/Pz43/Gf8F/aVfXIaIUOr4545MkiuIRRyC6fq8Pw7GeMJJy6Ry7UeXF/NsQFY/fz9FzA1Nuf+PgeRZWphA1QWRvMLv4yZMnMU9YvAUCsO90H/HRSm5fVYhYFE7My7Jj+P6Dc3jsjQba+0zo1TLWzc+iICOKQABGTXYsdncYSZmIF3a1Mr8iJWJ150P8Y/iQqPwL4fX4OLCrNZRh09EyyurNJQwPWIhN1HDyUGeY5uIibBYXXecNFJUn0dk2Nimob8a8DPq7jeH6FQGsvqE0NCFjNjk5e6qX/JIEmuoGSUrVUVyRRFyihns+MYc9bzdjtbhJSdeH3F4nYv6yXA7sCk6tLFtbSEv9UFg7ZmjAQl1NL7d8ZAZP/PEoXrePwtLEYMtJKEB8YZXxTj1ysST84iEQBFsoXq8fuUKCTC7Ganbh8wUv2hqtnJzCOM4c75lAUi6hr9vI/OW5lE9PYXzMTlFZEoXlie/YcklK1qHWynDaPRF1NhdhMbtQqqTMW5LDk48cZc7iHDJzYkhJ15OaGcVQvzmMpADYbG7kiuBPcajfglYrp6l+kNeePRsiZccPdBKboOa2+2cQFTP1dM5/GnwOB6ZzU9vmj584SXphAcZTdcirypEnTK2jEYhEQV2G6J+/7LkNBuq//X2cAwOIFHLily+n9/kXrvAMAQG/H0VyEo7eyGRFnZsT+rfPYcfW0Tnl0SwiL788/rcQSbmIcYeJx5pe4lOV96CLQFR8di+W+qktGqytY8hi/z3+X4mEAmyX+SYlRCu5bWUBsToFw0Y7E68qNrubzgFTGEmZiDcPdbByVgaJE35XgUCAQYONJ95qZG55Mjcuy8Pu9DI4aiM5To3J6sJkDdA/OrV/ktnmxu2JbGj4If4xvG9E5Qc/+AFvvvkmZ86cQSqVYjQaJ+3T3d3Nww8/zJ49e1Cr1dxzzz386Ec/Qiz+7+BPVouLM8cuTascP9jJLR+ZzrH9ncxZnE1dzdSrsN7OcczjdpavL8LtCo7OyhXioIhWK6OhdiDY1rC4SE7Xs2J9MQlJl3qA/T1Gju49z833VlNQmojF5OT4gU6sFifJaXqWXFeALkpOXnE8Jw91UnOkC78vwOzF2RSXJ2G3u5m1IIu6U/1odPJJmhEIWsifPNLF7R+dwXOP1rBoVT7SywRmMXEqRCJhiGhMRHSsCqVKxqKV+Zw73YfH48NmdbH4unx0UUq8Xj92q4voWBVjIzbOt4wwPGAmIzuGba/VTzreRdSf7mftTWV43D78vgAmo5P2phF0UQriEjRo9fJJBEoXpeCej89hfMyORCqKKGIG0EcpsZpdxCdqkErFnDneQ3KaHovJyVsvn4v4nLQLBAZALhdjNjt5fQJJuYjRISsHdray+voyJNL/DoMpgUiIRKvF5YycEC7Raul89HEUKckgrESenIw8MRHn4OSqV+z8eZjO1ZO0ZvU/fT72vn6cA8HVfNb999H74ktEz5rJeE3kSk7MnFkgEpJ26820/PyXk7YLZTKip1eH/hYIhQhEoogVJIleT5/LgMcX2WahdrgJq9+BxqNCKLm8OhIgMEXlEoJOuv8uUMjEVOTFcax+EIEAPn/bNKJ1cnYe78bl9lFdmMCo2Rmsimpk+Al6okwFu9OL57IW+ojRwTceOYzF7qH1gmj/ItxeH3evKWbM7GTUGFnDAqBRSj40grtKeN8Ygdvt5qabbmLOnDn89a9/nbTd5/Oxdu1aEhMTOXz4MAMDA9x9991IJBJ++MMfvl+ndU3B6/VPCu0zGhx43D5cTi9qjSzMcTWnII7y6amIREKUaikKpQSxWEhMnJriiiQECELOl9NmpJFbGI/d5sZidGIxO5FKgy63YpEoNPEy0GtiZNBC3an+0Ot0nzfw+B+OcMcDs8gpiGPekhyqZqUhEAg4sKOVv/z6IH5fgOQ0HSvWFVN7upep0Fg7QPm0FD72+fno9JOrFiqNjDU3lLLl+dqwx4NpyqVsee4sUpmIyplpiMRCDKM28osTef6xk2GfTUZONKs3l/Lobw+zfG3RFfUVEqmIupO9xCZoePuV+rBJK4VKwl0PziYhWTuJrMTEqVEqJcxelMWBHZOjoZNSdZiMdqJiVBza3c79n5mHUChEo5NjNNhD+p+JEIoEVM/O4MUna5BIRSSl6ait6Zty4qDuVD/zl+WFdEb/6ZDo9SSuuY6ux56IuD2qupqmn/wMn92B+EYVQpmMom98laaf/BxHT++E/aYRM2cWgUAAWfw/76xrawuKy6NnzUCdn4cqJwuhRIq2pHiSTkWemIiurAwCoK8oJ/2u2+l55nkCFxx1pdHRFH71S8jiglowt8GAx2IjZt4cRvcfnPTaQrkMW2AySdFIVaxMnUWhJh21O4ClrR2JWoUsIQHRBVdeoVSMIkOHoyuyOaI69+qJi99vaFUyphXEkxCtZNOiHBo6DLx9pDO0/XDdAFlJWr5wRzVWpxu3x8/8ihTsLi9vHDjP5QVRrUqK/DLi3z1owRLBDwdg65EuVs3ORCwSkp+m5+M3lqNRSBk02NlxrCtUZbl+SS6d/Sb6RqzE6ORIJSLio5TYHB6sdjcBQK2QoP5wnPkd8b4Rle9+97sAPPbYYxG3b9++nYaGBnbu3ElCQgKVlZV8//vf5ytf+Qrf+c53kH7Attf/CkikIhRKSdhkSW/XONkFsdSd6qNyZho73wgG9a3aWILd5uLtl8/hdHgQi4WUVadQOTOdmDhwObz4AwEUSilup4fjhzrZu7WF/OJ4yqenEhOnor1llJOHunA5PWTlxXLzvdWIxEJ2v9U8+eQCsH9HC7ooBW+/fI7SqmSO7u9gZNBCbmE80+dmYDY5GRmyUFGdilQq5tiBjoj6EavVhT5GGTHLRyIRUVCaSEycimMHOjGNO0hI1lBckRQ0W9tYjHHcQVy8mkAAMnNiePz3Rya1dbraDRzZe568ogRa6ocorUrm+IHOiJ97TkEcPp+fw3vOTxoHd9g8PP3n4zzw2fmT/GEAFCoZM+Zl4fcFOHagIxhmKIC8C5/JQJ+Z2ppejOP2oGuqLthq00cr+cgn57L99QZaG4YIBCA5Tcf8ZXkc2Xcer8fPrffPQK4QY7dG7nlDcFTdH0G/8J8KgUCArqwUfVUlxtNnJm4g/Y7bMJw4iUSrJfcTDyNRBw3ilGlpFH/nm3jGjbhHRxEqFLjHDEjj4lCmpiB8DxVbWWIiWR/9CNriYrqffgbDiZMIxWLyPvcZElYsY3DbDgJeL1HTq4meOQNrawvqgnwkahXJ69cTt2A+HqMJgViMRK9DGh2NQCDAPT6OvacXw8ka4pcuwdLcimtoKOy10266EacuLeyx8th87k5cjPH517HUPk+TSkniqlVoCvPxWKzoiosAEMnFxC3OpufpswQuWxwpM3RI9P/aQMx/FMlxKr7/4BxGjU7++Epd2DaBADYszGbf6T7eOHgeh8uLTCJi1ewMfvX5xXzjkcNhbaCbluUTfdnkz+BlkRgioYBAIIA/AC6PD7fXhz8QoK3PxMt72lDIxKydm8Xnb5/GqNHBiNFBRV4c7b1GXtjVSv+ojaRYFbevLMDnD/Dr504TCASnlD52fTlpCZp3FN2abS5cHj9CAeg18v8qke6/rMdy5MgRysrKSJgwlrdq1Soefvhh6uvrqaqqivg8l8uFyzVBtW6OHCT37wCNVs7ClXlse/XSSqyxboDb7p9J87kh5EoJhWWJCAQCzCYHR/ZeUrl7vX5OH+vBanWxYl0Rrz1zFq/HR9n0VLJyY9m7tYXl64pwOT3YbR6OH6inu+PSpErD2QFaGoa466HZyBWSiFk5sxZk8eQjR/F6fVTOTGNk0EJxZRIZ2TG88HhNqF2ji1JQPj2FNTeU8taL4e2N4oqk4FSTe2rHVafDwzN/O0lhaQKZuTHB0L6/nsDvCyBTSCgsTWT76w2MDVtZtCo/ovYE4Nzpfj72+QUIhQJEIiHtzSOMDYdfcMqqU5BKxcgUEtqmMHSyWVyMj9nx+fxI5WJUqvBJCrVGxqyFWZRWpWAxOQkQCIUletxeGs4MUFCaMKnNFR2r4vrbq7DbXHi9flxOL411A+QUxbH2xjI8Hh+tjSNk5saEAhcvR0KyNiy5+b8BYoUcXXkZiatWBKsFWi3awgKsHZ1I9DpSb7w+bLwXQB4bizw2Fm9KMn6XG21BPqKrEEyqycvFpdfR9KOf4hoJ5kf53W6af/IzFOlp5H3mU4yfPImlqRldeRmaoiIk6mD1SySTIkpImHSuAG6jke5nnsPS2ISx5jRFX/8KlqYWzA2NSLQadBXlWJpb0AoqmZtazeHeGjQyNXcnLqb3Wz8OVWm8Fiu9L76EKieb5I3rcRkSQqZy0mgFaXdWYjjSjb1zHKFcTFR1Cur8WMRX0Sztg4BAICAxRsULuya7Oy+bkU5br4k3D12aDnR5glNCBouTb94/iy/93wGkYiFr52dRlhND96CZWJ0CzYXPIfNCm3xueRJLp6fhcvsQCYX4AwF2Hu/C5fKx/Uw3bx/u4KHry3F7fby6vx2D2Ulemp47VhXS0W/i18+dCZ3DwKiN//f3U9y4NI955ckcPNtPXfsYX/q//fz684tJjovsxOxweekcMPO3Ledo7hpHo5SyaWEOy2amE/0vTlz/oPAvIyqDg4NhJAUI/T0Yob98ET/60Y9C1Zp/dwiFAkqrUvB6/BzYGXQ09fsDNJzp4/7PzsdmdpKano9QJGTL82dZtbEEhUrC2LA1SFIsLlrrh5m3OJclqwuCI7OBAGdP9JCZE4PP6+fk4S6uu740jKRchNfj58CONipmpAadVgXBG6FIJMTt8mKzurGYnKSk6xnsMyEUCqiYnsYzfz0OgaB52dzFOYwb7NitLqKiVWy6vZK3XjqH2xVsXU2bncHxAx1ExShRqYJBXjZrMMVZpZGh1shobxrG5fBw9sTkFpJYLGTnGw10tY8Rl6iZ5E0yEcFqQyCk97j1vhn095g4d6oPqUzMtNnpjA5bEUtFWEyOK04PjY4E9SBZebEUlibisLsRioRB8iQXBw3bgPbmoLbFanFxZO95LBecMucvy0WumDxFIZOLkU2YvEpK1WIxuehsG2PvtmbMRicf+/yCyCJmASxfVxScRPovgkSvx+920/Kr36BMS8Xv8TCydx+yuDgy7rkz4o3/IsRKJSiv5ucVwNp+PkRSJsLR3UPnY0+gyc9DlZmJRKsNtXWuBL/Xi3vMgKUxGJYZt2gB7b//I+5xI6qMdNxjYwy8+TYBn49kL9y5diO5UZkEXE6Mz74aIikTYWs/D34/PrsdLhAVgUiILFZJwqo8/C5v0H9FJfm3NX0LBMARYdEyrzw54lgxwKGz/WxamMsPHpqLzell/5lePvvLfTy0uRyBIMDCyjR8fj8CgYB71xXjdPv48eMn8V5YlKkUEj59cyVSiYitRzrZtCiXxk4Deyekq59tHaW27SCfv30a6QkauofCq7av7W/ny3dN5+DZYLvd6fbx5qEO7l1XjEQ8eRHS2jPONx45HGoHm21unni7kbrzo3zh9mp06v98r5Z/iKh89atf5Sc/+ckV92lsbKSwsPA9ndSV8LWvfY3Pf/7zob/NZjNpaWlXeMa1DZVaxuxFWZRUJmMcd6BQSvB5/dTV9HLmeA9+n587Pjab/OIEjh3owGp2kpSmY/XmUhrrBjl3qg+L2cmZE924nD5Kq5IpLE8iJUPPtlcbSErV0dU+NuXrtzcPUzlzGh63j2mz0nE4g6Z0Wr2C08eC6bZOpweVWkZWXiytjUMhkjJ9bgYvPlEzQWfTRlKajls+Mp3u8waS0/W88vQpjAYH9Wf6Sc3QM3dJDs8/VoNUJqa4PJHquRkhvYxEKiIuQY3X42d4yAKBIHHa83awNWUadxATN7U2Q6WWEggE2P56A1ZzkNAsWV3AxlsrkCskDA1a0EUpOHGwk+KKJKQy8ZTZOhqNnI62Mc63jHLmRA8bbqnk0d8eDvnWpGZGsfmOKgpKE9j5RlPIJVejk3PdphL0MVe+OQb8AcYNdmqOdNHePIJCKWXhynzcTi9vvljHhlsqqDnSxdmTvbicXpLTdCxZU0hi0tSmSP+pEKtUJK1djb68jL7XXsdtGEdfVUH80qXI34Pe5J+B3+PB0hyhVXoBlsYmktetQZmejiI56V0f19p+qVqqysqi++/PAkEvFpFSScKqFShTU/FarcgMRuY4E5AlxnC27rEpj2mub0R7ofUzEUKpCOF/gBhbKBSwqDqVg7X9YY8LBOCbYjLv4ljx4Jidx964VMl+dnsz960vYczkoKlzjLeOdHLHqiK+fxnhsTk8/OrZ03z17ulAsHXzvb9OJkWBAPx9WzMbF+bwyMvh+juP14/vMmHz6ZYR1ow7iNbKUUyoxBotTv74ch0yiQitSorJ5sZ1Qfh8unmEkXHHh0TlcnzhC1/g3nvvveI+2dnZ7+pYiYmJHD9+POyxoQs92YuJx5Egk8mQyf6zvhiRSIQ+WsnIkAWhUMCbL9QyMhQcOZ63NIej+8+HVRt6Osbp6axh460VDA+YEQgEdLYa8Pn89HaOE5egZsOtFdhtbny+AOIrtApEYiHxyVo0OjmH9rTT2zV+oRKSTklFMjVHuhkbthGXoGZ40ILlgnfKnMXZvPTEqUli4IEeE+dO96HVK3jmL+Hfb2+XkeEBC0tWFxCXoKHuVB/7t7dQPTcDpVpGdKyKvu5xpFIxy1N11Nb0hnmsuF1eXE4v8UmakNHcRCxcmcfosJUV64tDHjJ73m4mNl5NUXkSSqUUvy+Azeqi7lQfsxZkcmDnZFFsdkEcQ/3m0Bjy2LCNtsZhUtL0dHcYEAgFZGRHMzZixWZ1s2B5LtGxKjxePzKZCI1WFkpsngojQxYe/e3hsDZWV/sY5dNTyc6P5dm/nWDFhiKmzU4PjnOLRWj1ckSia8OE7YOGRKNBUlyEKiebgMeLSCG/qpby7xoCIRLt1AGHEp0WaXQ0/AMW/UKxGFnMJTGr33NJPxFVPY3ENdcx+PY2xg4fRRqlRxYfh9dqw2c2IJLL8DkiT0SJVEqEl7W73OPjeK02EAqRaDVINJp3fZ5XA26PD6PFhdfnRyYVRXSF/UeQl6YnO0XL+QnZXdIIVYmJkEnEXF5DMlpdSCUijpwboKVrnOlFiTy/syXi890eHwEgTq+YVC2ZiIFRG1FTGPCJROFnoFVJ2Xa0k/goJUuq01BdqMY6PT42LspBIRMzanQQp1dgdXh4elsTRouLuvZRctP0V3y//wn4h4hKXFwccXFXZwUzZ84cfvCDHzA8PEx8fND7YMeOHWi1WoqLi6/Ka/y7ISFJy/mW0RBJiYpRUVyRzJ9/eWDyzgHYt62FRavycbu8YeO9I0NW/P4AYomQ3q5xZi/K4ngEN1eA2YuycdjcPP77IyFSYDE5efPFOipnpjFvSQ6HdrdzdP95Zi/MZqDPxFC/GaPBMYmkXERtTR/X314ZcZvN6iYqVsnzj50MPbZyYwknDnaFhMMACGDZmkLiEtXcdE9wfNNscnLqaDfL1xZx8khXSJSqUEqYvSgbu81DW+MIi6/LD+UcQXDsOzVTj8/nRyQSMH9ZLtteqyc9K5rFq/I5drADh82DSCykvDqF8umpPPXH8FVSU90AJVXJdHcYWHdTGe1NI2E6ErFEyE33VBOXEPuOGhKL2cn2LQ0RtTa1J3u59f4ZHN57nucfraGoPIkb75oWmub6b4dIJoN/4UJFJJMSNX0aA2+8GXF70to1jJ+tI2XdPzYCrS0qRCAWE/B6EUqkIBQiT0wgfukSGn/w4zCX2tZf/Yb4pUtQFxYQt2Qxg29tjXjMuIXzkV6wJfe5XFiammn/w59C49WawgJyHn4QZUb6B9L+GTM5eH5XCzuPdeP2+omPUvCR9SVU5MX900F+MToF37xvNjtPdLPtaCdOlw+Hy0temn7SWDFAarwagQBq20YnbROJBHi8flbPzcTt9bHtaGfE1/T5gzlACpkY2Tv81iMNEMTpFZguE8wvnZ7GszuaGRl3UJIdQ5YiSIY9Hj8v7GphcEJeWEqcms/dNo2/b22iJCuavmELQgRIJEL8geBr6tTSiG2kf1e8bxqV7u5uDAYD3d3d+Hw+zpw5A0Bubi5qtZqVK1dSXFzMXXfdxU9/+lMGBwf5xje+wSc+8Yn/uIrJO8FidmI1O7GYXGj1cpavK+LArjbW31LGQF/kcUIIjjLHJ2p46cnJSb+NtQNUzUznxKFOOtvGmLlgMlmJilFSNTONFx6viegOe+Z4D/d/Zh4nj3TR0TpGIBCcPupoHZ00ZjsRwfZI5AtffnE8z/z1ROjvtMwoWuqHaG++rOcfgF1vNpGQrOWlp07h9wWIjVezZHUBJw51oI9WccfHgkGHVrOLM8d76LgQB5CaGUVBWQI1h7vRRytZsDyX15+tpb1lBAIQE69i0cp8Gs4O4HJ6WbWh5IKxnAB9tJwn/nB0cjTBhQt5WmYUFqOThrPhzphej5/n/naSh7+8+IrtKQiKh8+3TL5QXkRft5HEZC193UbyiuI/JCnXEKRRUXhtdjLv/widjz4e5iAbNb0abWkJ8vi4ScLdgM+H3+NBKJFErARJ42Ip+NIXaP7pzxmvqSFu4QLUOdl0P/NsRJfa4d17iJk3F01uDub6Buxd3WHbM++9G+mERaWjp4f673w/7FiWpmbOfeNblP/kR0EfmvcRRouLnz55koYJWrnhcQc/eeIkX7qzmgWVKf80WYrVK7hpWT4rZ2Xg8/vRqqQkx6n43l+OMTBheidWL+fB68sQCgSTkpGzkrX0DlvJT9NT1zbK/MoU7lpdxKv72um9zFATYGDUyp3XFSIUChCLBHgjXD9Lc2I4f9n1WyET87Hry3j8zUttp6XT07A5PCFr/21HO3nw+nJMVhc/eeJEGEkB6Bux8tTbjTywsZTfvHAWuVTIPWtLeOtwJ8fODSAWC1k2PY1Ni3OvSkDjtYD3jah861vf4vHHHw/9fXGKZ8+ePSxevBiRSMQbb7zBww8/zJw5c1CpVNxzzz1873vfe79O6ZqEYdTGM385ztjIpR9Uaoae2x+YQXe7Ae07jQ0Ggse4HB0to2y8rRKj0c6x/R3MXZLDTfdU01w/hMvpITsvFl2UEo/Hx2CfGV2UgulzM4iOVSEQCBgdsnDicBcdraN85JNzGegxBVsQEiFrNpeGne/l0EUpsEdwgVRdqHJMdNstqUrhyN7IEy4ALQ1DZOXG0t48wuiwlZefOs0t903n5JFOfD4/PW3jJKXqmD43g9SMKE4d6+bEoU5WrCvi9LEeVm8u5Y0XgsGJFzE2bOOVp09z6/0zee3ZM7z6zBmSUnWsWF/Eji1NuF2Tza8KSxNpbx6hrDqVAzsmTxoA+P0BmusHmbs4J+L2i5hqaukiLo4dqjUysvL+ffwt/lugSElGKJWiKynG3NCIz+lCX1GGRKdDGqVHOMFawe/14hoeYXjXbiytbSjT00hctRJZfFywOnQBIqkU/bRKqn73fxjPnEWVkY7f55vSzRbA3t2NIi2F/C98DufAAIYTNUh0WuIWLUAWG4tYFSTMXpudrqcjEx6vxcrYkaMkbVgX8lx5PzBitIeRlIn425Z6SrJj3lMbSCQUhE3ApMZr+N6Ds+kbttE5YCYuSkG0Vo5eI+M7fz4a5lOkUki4a3UR53tN6DUyRowOfvjYcfRqGWvmZSEUCPjTK7Uh/xWpWEhKnJoXdrVy95oiHr6hgt++cCbsmFqVlFtXFOD3+7lrdRH9I1by0vXkpOiRSUTMr0gmRqegICMKo8WFw+Xly3dN542D5xk1OjFZXYwanXQNRm4ttfYYsdg99A5b+Nb9s/nfvx3DduG64vb62XKwg+MNQ/zo4/Mm5Rj9O+J9IyqPPfbYlB4qF5GRkcFbb731fp3CNQ+L2cmzfz0x6abf22XEZHDSfd7A/OW5Uzq3ZmRH45vCUyO/JJFtr9Wz+vpSqmdnhJxUK2ek0to0zIlDXYwOW7n9ozNJz4pmzuJs9m1vCYYfEvT4WHtDGQ6nh6a6QY4f6OT+z8wn6oJIVCoTk5SqZaB38nj48rVFnDsz+QKrUEkmGbHJ5GJsEXxDomKUyORi3G5v2JSMz+en/kw/c5fk4HH66Ose5+CuoM4kLSuK9TeXc3TveaLjVNzykRnYbS6WrS3C6/Gxf0drKHcoEIAje9u57b4ZWC0uFEoJ2igFXu9kkhITryI5TceBna3MnJ+FxRJZEwAwNjJ59XU5XE4vuQVxtDVNnhyBoEamv8fIptsr/+smfP5RBPx+3AYDfpcboVSCJCrqPfmkvBsIBIKgiDc+DnXO1Jq8gM+Ho6+f7meeY/zESQJeL6aztQy8+TZF//MV9FWVYecqkkpRJCWiSApq9Bx9/VMdGggaxsnj4xEIBKgy0omZPSvifj6nA2trZHINYG5qJm7ZkveVqERqw1zEmMmJYwpR+3tBYoyahGgVeelR+H1+NCopNoeX73x0NgfP9tM1ZCY7WUdemh6L3U1pbgxf+/2hkEvtmMlJ+yt1LKhM4cZl+Ty/s4WEaCWfvKmCZ7Y309Bh4Mu/PchNy3L534fmcri2nzGTk4q8OAoyonhxdytDBjurZmVw3dxMnE4v3/7zEZZNTyMrWYfPH+CrvzuI/QLBUCkk3Le+BKVMzAu7WplRPPU0GwRFubPLkjhwpi9EUiZiyGDnTOsIK2ZmXPXP9oPGf4dX/QcMr8eHx+tDLBYikUz9EdvMrkk5PRdhMTmwWpy4nF6uu76Et16qC18FqKUsWJGH2XjppikUCSgsSyQ7L5aUjCh8fj8yhRgMAUaHrRza3RY0KJuArg4DS1YX8PSfjoVpTvp7TLz01Cnu/8x8tr1Wj9PmITDhBHRRSm75SDCpuPZkHz6fH12UghXri3A5vUyblY4uSknD2X58Xj/5JQnMXpiN3eZGICD0XoYHzKRnRYdaIZm5McxemI1h1Ibd5iYjJxqbxU1b00hoQqe/28jcxTk88+dDYdWJno5xXnvmDB/51Dxef+4svZ2XwuI0Ojnrbyrn7VcuhST2dRuRKyWoNDLsNjeDvSZWX18aHDXe047H46N8ehrZ+bEc3hMkQ4YRG4nJ2hChuxxZucFyu8ftw253QwDkCjGyCYFv+igFsxZm0dtlnORfUzUrDaVayqbbqyKON3+IS3CbzIwdOkzPs8/hMZkRKeQkrl1D8ro1SKOi3vH5HoslOL4rDNr0i6ZoOftcbnxOJyKZDJH8ndvSwSrKMEPbd2Ftb0eemEjR/3yFwa3bMRw/AX4/Lb/8NZW/+sUVp5bEWg2akmIsEZKZEQrRFOa/q3aJQCxGGh2N1xL5WiONfufP6r0iSjN1ZVgkFCB5n0TiAoEA7QSPGK1ailYt5daVBXg8PoxWF7tO9KBWSnh13/lJVvoAB8708f8+s5CizChEQgEOlzesOvTCrjZe2dtORV4caqWUtAQNv3n+DNWFCaTGadh1oofml2r52j0zmF6UwLFzAyyoTOXLvw3XHtocHn77whl+8ZlFSCUiojTysGvlRAiFAuQyEQXpURFTpC9i/+k+FlSmIJf+e9/q/73P/hqDzerCYnbS321EIhERl6ghEAigUEkjht7ZbFPrPFobhiksTcRidjI8aOHW+2fS0TKCxewiKVVHdJwKh82DXClm2dpCBvtMVM/N4Nypfg7sbEMqEzNzXiYgIDM3hqP7OiaRFIlUREKyhnOn+yIKYz1uH6eOdJOeGY3b5UV5meBNq1dw3aYSFizPC5qjScVodHLGx+w88YfDxCVoWbWpBLU6GAXg8XiJjg3qQ/Zub2Hm/CyyC+IoKEmgo22MjOxoKmem8cITNSGNyMFdQWv6zXdUhUzmNDo5oyNWUjOiqJyZFkr7He634HJ62PN2UxhJgQsp1S/UsnR1QTDsj2BrRSgS4nR4qDnSRcPZAQKBAAUlCSxfX4TX6yclTY/P72fBijyq5wTdeJemFfL3P4dPNAGotTLSMvUYDXYO7GyjrqYXn89PbnE8y9cWEROnRigUoNLION86wuY7q2hvHqH7vAGlSkrZtBRSMvTooyK7+H6IS/B5PAzv2EnXk09feszhpO/Fl3ENDZP90AMhp9pJz3W7sXd10/GXv2FpakYgFhO7cAHpt92MPP5SqKHP5cI5MEjfK69i6+hCkZJMyuZNSKOiECkVQY+WC/A6XXjGxvC5XXgtVhq++78hfxNTbR1DO3eR+8mP4zGbsTQ147PZcY+PX5GoSDQach/+GHVf/QZeazjJyP34g0j1+nf1WUl1OlKu30Trr/5v8kaBgNh5cxGK319SnJOiQyYVhUZrJ2JBVcq/ZMRWIhEhFAp4eW8bn7mlipbuqVOwz7aOMLM4kfqOMXJT9ZO2e30BapqGSYxRUpwZTUe/mY7+S4sZoQCitDJuXJqHXFrIY29GIJ8EScmr+9oQCATMKUtkfkUyB85MrqwtrkpFIhbi9vjDxpkvh1Iu+Y+4lnxIVK4SrBYXO7c0UDshSFAoErDmhjISk7XBvI/ocLKiuUJPtrvTwNqbynjt2bMsXJ7H6ePdOB1e5BccVSvUqQz2mzm2v4PUTD2rNpTw1J+OhVUY3nypjsyzMSy+roDF1xWwY0tDyERMIhVxw13TsJqddHdM/QPt6TSQVxRPSVUycuXki5lEKkYfHf7fKCpGyb2fmIfD7qajdZS9bzfjdHjIyo9l/tI8yqanUlCWyPH9HTz9x2PkFcVz413TkMnFPPPXE5OErAO9JhpqByiqSOLcqT5mLczGbHKQnh3NGy/Uht5zcpqedTeV8edfTc5JgSBZEYmFoVDBqplpBPwBnnv0ZMjLBYJ5Om3NI2y+YxoWi4uoaCUymQS9XolW58Lr9bHxtgp2v9UcGtfOyI5mzY1lCIRCHvvNobDjtdYP09k6xv2fnofH40etkVFalczYiB2lSkLFzDR0ejlqrYwDO1vRRSmpmJ6KPkqB8L90HHkifC5X8KYvliCSBg3KPOPj9LzwUsT9Rw8cJO3WmxEIRQiEwklVEGd/P3Vf/XqISAS8XkZ278Fc30DZD7+HLDaWgN+P6Vw9jf/7o5C2w97VxdjhI+R+5pPIk5IQq1TIYmPwOZwMbdtO36uvk/3A/XQ/+9xkEza/n46/PkrOwx/D0hT0YYkUPHg5FKmpVPziZxiOHWP89Flk8XEkrlyBNCYakfzdu5JqS4tJWLGMoR27Qo8JxOKg6DYmGokmMqm7WojWyvn2R2fz3T8fxTUhUTgrWcvdq4uQSUWMmRy4PcFKdJRGjvgD+L+vU0tZNTsDgYApqxcQrPr87sWzNHYa+Omn5rNmbiZvHe4M20cggAc2lvH4W5NJyOq5Wew/1YfD5eHWlYX0DE3dIu4bsVGRF4sAAXPKklHIJOyp6QnaH0hELJuRRkFGNGabm5rGIRZPS+WJtxojHmv9/Kx3HNf+d8CHROUqofncYBhJAfD7ArzxQi233T+ToX4z+SXxqNSXLi5qtYzM3Bg62yYbsk2bnY5UJmL+0hzGx+ykZkaRkKRFKhMjlYpobx7m2P7gFE98opZDe9ojijQ728YwjTvY9WYj111fyu63mhgdsjJnUTbH9ncQl6BGo5VNyry5CI1ORtWstIi5N1eCWCxkz9vNYanK507101Q7yJ0Pzaa/28jp48Hk6NbGYVwuL+XVqZOnbS6g/kw/199eSUysCplMhABCRnAX0d9jxGhwhPxPIsFmcSOXS8gpiCMtO5rWxuEwUnERDpuHlvohps1JDz3m9fpwOj3Un+5HKBJw0z3VBPwBHHYPvV3jNJzpJzUjKuLxPG4fR/aeZ/q8TF5++hTzluaSlRtLfKKGoX4zu95qCjoLX8CRve3c8/G5pKTrp3wvE+H3BTOHhP+Af8e1CLfRhGtkBEtTM+r8PPxOJ/1vvInPakNXUU7UtErEag1+nw//FInKAPbuHjoefRwCAZLWrkadk41Urw8KS598OqKbq2toCEtTC7L5sbgN47T9+jcRBagdf/oL+V/+Erb2drQlJfidDsxNzfjdbsQaNe7RyAaLPpst2F4SCBBKJGHeKVNBIBAgT4gncc1qoufMZvxEDS2//g1ihYKU6zeiKSpEqpva1+Ui5HFxpN5yMwkrV2BubEIokaDMSEeq1yNLiH/H579XiMVCijKi+d2Xl9DSbWTU6KAgI4rEGBUioYCdx7t5amsTBrMTlVzM+oU5rJmTSdT7bBEvFonYsDCH+vYRvnzXdAIB6B22sONYNyMTkpHTE7U8/mYDYlGQRN22qpCizGhe2NWKUiFhRlE88yqS0SqlfPnO6YwaHZjtbmpbR6gqiKcgIwqRUIj6wmLvthX5SCSikOPtzuPd1DQFr5Up8WpGjQ5y0/T8/OkaFlSm8MU7qgkEIECAw7UD/PrZU3zipkrWL8wmEIDS7BjOnQ//f3fdnAzSEj5Yn5z3Cx8SlasAq9nJ4T1TTK4Egjbr46M2UjKiwoiKUi1l022VbHu1nqZzgwQCF9N001mwPA+1Vk4gFVwuH4YRF51to2TmxfL2K+dYuDwvdJyMnBhev9DOiISO1lESkrRsfeUci1bms+X5WpLT9ezf0crwoIUV64qmHJeduzhnSkGn1eLCbnPh9wXDENVaWciQbNxgDyMpF+H1+jEbHZw41Bn2uMftY3xs6kkin9dPVIyKloZh1MMyDk+RheP3+0MVk0hISNaw7uYyBvvMaLXySWRnItqbR5g2J52u9jGUKinDgxZefupUaNW1d2sLMXEqVm0s4ei+8wiEAm6+4PkSCedbRklO1zNvSS7bXj3HrffNRCIV8eQfj05qy3k9fl575gx3f3wO6ilMo7weH2azE5vFxbEDHQgQUD0ng7gENaopnnMtw20w0PzzX2KubyD1xs0M7djJ8IQKgLmhkcGt28j7zKcQiESosjKxdXROcbQApjNnCXi9GGtOETN3DtkPPhAUtNbVT3kOo0eOEDNvDh6zGY8psg4pbvEiAm4Xg1u30/HnvyHWqElYsZyEZUvDdFyRIBCJKPzKF/GYLUj0kwmG3+0OmbIJpVIkOi0SrRZHTy+1X/4afvelabqmH/2UhJXLSbv15ndFeuRxschiY5AlJBDw+xDLFYgUH1xWjFgsJCFaRUL0pfF9r8/HGwc7+Ovrl74Tm9PLs9ubGRix8tDm8vc9XdjvD2BxeHllbxNjJic5KTruXVfMqeYRdp3o5uZl+Ryu7QeBgK/dM4NonRypWMTi6mBl41z7KCcbh7DYPcwtS2LXyR62He1Cp5Zy/eJcXG4fJxuHWVydilwqpnfYwst722nrNQLBkeXNS3LJS9Pz/M4WFk9L5UePHWd2WRISkZB9p3rZN8Gi/yKSYlS09Y5TlBXDHdcV4vH6OXCmD6lExKKqVOQyESNGBy63j/jof29R/odE5SrA7w9gMU+9urOanUikIgyjNtQaGcqJ4i69gg23VrLM4gpNuKi1spAIV6tTUFqVjN3mJhAAsUiAXC6mp3OcWQuzOLa/g4A/gFAkYKpKskgkwO8PYDY6iUvUcP3tlSFTMpvFhWHUxuyFWRydmH4sgCXXFRCXOJmRB/wBhgbMvPzU6ZAYWK6QsHJDMYWlCciVUloahiY9L/T8AJiM4VUHw6iNOYunnqCIilHi9/nJL04gKkYZEsRejrpT/cxckMWhXZMdZ1PS9dhtbkaGLJRWpSCSCpFewUpcJhfjcnh5/PdHuO/T83j56dOTSsNjIzbOnuylpCo56B58BXGjTCHG5fSy881GZszP4uThTipnpk8iKRcxOmzFbnNPIioet5exERtH951neNBCTJya8mmp1J3q44k/HKG0KpmVG0umJDjXIvweD32vbcFc34BQKkWdl0fTjybHdXjGjQzt2IU0Ooq0226h6YeT95FGR+FzOMOqJmOHj5C0djWKlJRg1cMVWR8mi4mZUqAqS0hAX1WBKjOTph/9NPS412Kl7+VXiZpeTerNNyDWqCMKV4VSKX6vl66n/k7xt78xSbzrNpkYfGsrfS+/GiIk6rxc8r/4Odr/+OcwknIRQ9t3Er9sKVK9/l059QoEAqS6ayeGwWBy8fdtkRcL+073cevKgveVqAyMWnl6axP7Tl+qhrf2GPnZUzV87rYq1s3PZGDEjl4j5Q9fWUqsThFqpfSPWvnqbw8yPsFT6tV97dy/oYS5ZUkcrhvgsTca2Lgwm3GLi9KcGOwyD1/7/SGME57jcHl5emsTD20u52v3zmTHsS7cXj+HzvazfGZ6WLjiRaQnaOgdtnC6ZYSizBgsdjdbDnTwqZsraOs18aMnjjN+IUYkL03PZ2+tIj3x2vne/1H8e9eJrxFIpKIrluiT0/SMDlnxef14IqQIy+RiouNUJKboiIpRTZoUEggEqNTBAD+5UsrcJbkc3tNOaVUyN949DYfDTWnV1IZNOQXxoVBCs9HB7q3NYSO/+3e04nb7uO3+maxYX8SK9UU89IWFVM9ORxHhImE0Oji4q42MnGhyCuIQCIImZq8/d5a+nqDB0ZXcWcfHbCQmh68mXU4vToeXxJTIP6alawrx+f34L5Tilerw84pP0rDx1goqpqdSWpXMguV5SC6QEIEACssTueGuaSSn64mJU/P474/wt18fonx66pTnWT0nnWMHzzN7URb9PcYpW0qNdQPkFSUgkQbt86dCeXUqDWf7GR2yoo9WMjxgeccV+OXb/f4A51tH+fMvD1Bb08dgn5n6M/08++gJsvJiSc+K5tzp/ilbedcqXGNjDG3bDoA6Pw/TuXNT7ms4dhxtYSHSqChklwUSitVqcj7+EH0vvTLpeQNvb0OsUZO8Yd2Ux45fugQAiVaLKiuT6JnTiV+6mJLvf4f8z36KpDXX0fPcCwhEImLmzibjrjtIvekG5MlJjJ+swe9wkn7H7ZOOq0xPI/9Ln8c1ZsA9bsRw7ETYdxvw+Rjdd4CeZ58PIyTW1jacff2hwMJIMJ46jecaTpF3m0y4xsYiWv2bba4rjiYPXqHK+l5hsroYMtjDSMpEPPl2I1EaOQuqUli/IIfkWDXSiws8h4c/vVIXRlIu4tE3Glgx69JI8FuHO9mwMJuTjUO09hjDSMpEvLK3DZfbx+G6oJnkodp+clP1rJmbGfJWAijOiub+jaU8tbWJ080j/ODR46QlaNiwIIvatlF++uTJEEmBIPH6xiOH6R22vC9j4B8EPqyoXAUolFKWrS3ib785NCmRV6WWEh2nwjhuRyQWXhWX0aQULbMXZmEad7Dl+VrKq1OZsziH8y2jk/QRFTNSGewz4XH7EImFiMRCTAYHrY3DZOXFhtxcTx3t5tSxbqKilaRlRlE2LQVlBCW+x+PDZnEhV0gYH7MTm6Bh1sJgBaPrvIHdbzWRmKKloDRxyraK1eJi/rLcMBt9gF1vNnLDXdNorB2gtqbvQrtHybK1hbicXh7/XbDtkpETw/S5GezfHvSGSMuKYvbCbN5++VzINr+oIok7HpiJzxfA5fLSfX6MQCDAWy+eC7nganRylEoppVXJnDsdrqzPzo9FpZbReHaQez4xh7YIbayLuOjqO3N+FmqtjDmLsjmyL3xkMCsvBq1OHhprDvgDJKXpUGmkCISCiCRIo5OjuEzAbDE5ef25s5NFfwHY+UYja24IJmWfONhBWmbUFXOeriX4Xe7QjUwgEBCI4Bt0EQF/UI/jtdsp+p+v4Ojtxd7XjzI9DYFQSNeTT+Pom3zzCXi9eM0WYhfMZ/zUGUy1dYjkcnwOBwQCZD1wXyjtOOD3kXrzTRiOH0eiD5q4GY6dQJ2Xg0SnJffTn2Ds0GGGdu1GrFaTvG4tCIXYOrtwG40Uf+eb9L/6Om6Ticx77sI1MsrQ1u2IlEoKv/JFXKOjeM1mJBf0Je4pxMGK1BSkse+QwCwU4nU4kb7/U8b/ENxGI8aztfS99AoekxltSTEpN9+IWxeNXyAmSiND9A6aKolYxG+eO02MXsGCyhTi9ArkV5hy+UdgsbvpipAZdhGjRidWhyeiEZ3F7p7kbnsRfn+AniELSTEqBsZseLx+zFY3FXlxHDw7tYHfkMFOarya8rxYaltHkUlE+AMBSnNiWTEznXGLi0AA2nqN/OzJk1gvWBsYrS5ONg4zqySRb/7xcMRjj1tc1LaNolNLmVaQcMVJoWsR/15new0jPknDHR+dyVsvX/LpyMyJYd6yHN566RxL1xTisLtRvcMYns/rw3LBX8Xj8RGfqEGlloV5aijVMqrnZeD1+PF6/Jw41InZ5OC2j86gq91AU90gMrmYovIkTAY7u7cGCcPshVnUnQr+UI7sbee+T89n26v1IbJCAKJilSxdU4g6gojN5/Mz0Gvk9NEe3B4fDruH4wc6qDnSxfW3V2GzuRkesODz+tHoZCxamce+7eFGU1q9nIKSBJrODbJ6cyn7d7SG7Phj4oKTBzK5mOvvqEKrDQoPezvH2f76JSV9V/sY5dUplE5L4dzpPuYvy+OFx06GjVg3nh2g8ewAa28s4+j+81hMTgouuMtCUKycmRvDvh0tFJQmUlyRRGvjMH5fIDiRM2rjxSdPIZGKMI87SEqdWrAYm6BGLBYya0EmSpWMWQuzKK5Iou50Pz6vj8zcWCxmJ1ueD6aoKpQSfD4/02ZnoFBIWbIqn92XkzoBrLupDM1l34PN6sJhC/deuQinwxPSCHk8/nes1lxL8NntKFJTcPT2YW1rCwbxvfV2xH2jplVhaWlBU1DI2f/9EYVf+SK6slJGDxwk4PFMspO/iOjp1Zz75nco/OoXyf34g7iNRtyjY0ijo5HodUh0OvxOF7aRUZp//gscPZd0AX0vv0rarTcj0evJuPtOmn/y8yDBuQBrSyvRs2eSvGE9zT/5GWKVipgF89EWFdD4vR/gHLzUCh09cJCkdWvQV1SEHvO73XgjVEVyP/spBEIhuopyTGdrJ20HUOfmXKnj+C+Bx2Kh89EnGNm7L/TY2KHDGI4dJ/lr3+Cnu4eZU5rMkupUirOiI7rW6tUyDGYn248Hv89ndzTzudumMac06aqQFZfbh0J+5eNMNXl0Me/nSseWTDC39AcCtPcaSY6derpKr5bRNWhmaXUat60swGx188bBDroGzXzr/ln8+rnTmKyT238AZ1qGqS6MZ8gQuSUO0DVooW/IQlayDoXs/Z3yutr4kKhcJUilYnIK47nr4dk4bB5cTg+DfWbOne5n5cZihvrNFJUlXTH91uP20d8bTBgWiYX0dxt59ZkzTJuVzvxluWEkRygQcGRPOzMXZHJk73mazw3R2jjMrfdNZ91NZRhGbezb1kpv9zgxsSpmLsjCYXfTcCZYVnS7fIyP2rjhrmnYrS6czuDos0otDWv3BPwBTEYHFpMTqUyERCIiJkHNcL+Z4ookFq/KZ++2FnZsaWD+slyO7j+PUCREoZAyfV4maVnRnD3RGxxPzoslOU3PS0+dwmJykpKuZ8W6IqJjlVitboYHzLz+7NlgVWRfB3KFhPs+PQ+rxUVmTgyd7ZdU7W+8UMvMBVl8/MuLaTo3OGVA4vGDnVTOSKOxdjA0XZWRHU1cooaXnwpmJPV0jCOTi8nIiaGwLBGBUMDhPe34vH4EF6pgFpOL9KzoUAttIlasL8ZmcTE6YkMsEYUmpGLjVTTVDVJ/pi7M2G3RynyiYlTooxWIxSKmzckgKU3P/h0tmMYdJKboWLQyn5g41T+df1IxIxXJv5HJk8/jIfXGzbT+6jf4HE6cA4NEz5qJ4Vi4X41IqSRp3RrsPb0Mbd9BwOOh+9nnSLvxRoa27aDom/+D4UQNHqMx7HmaokIggNdmxT1u5Pyf/hJGRLQlxeR95pM4hocxHD6GVK8nfsliIOiDYjxbS8+zzxMzfz5dL70cRlIuwnD0OCnXbyL74QcBAYqkRPpfeT2MpFzEwBtvEbd4EbLYoAhWIJEgUijCjpu4djWu/kEa//JX8j/7aaxt7fhs4a2Q5I0bcA4Moi0qwuty4RkfRwCINFokqn+dgNI9ZggjKRcR8HoxPfMkq1fdyZ+2tdAzZOajG0v50eMnQlk3AEq5mE/eXMGTb18auw0E4FfPnCL/y0tJiX/v0ywqhQStSopMIgobmb6IkuzoMLO4sOfKxaQlaOiZIj05J1WH2e7mtlUFyCQiAgR4ZW8bX75rBnKpCGcEsf91czPZcaybc+fH+PEn5vPIy7Wh1pLX5ycxRsW8ihRS49VYbG721vSGsoyitXJMNhc6tXRKMpMUo6SubZS6ttErEqZrEf8+V7J/E+ijlCiVXhz2oPhVF6VArZGRMjvjHcWNFrOT9qYRhgctqNRSdFEKbr6nmr1bW+hoHaW0KiW0r1Ilxe3yEZ8kY+WGYo4d6MA07qD7vAG/H0aHLCxfV4jD7mF8zM7Jw13hugUBxCZoUKqkYeLeiQgEAvT3mhgeMOPz+YmJU/PMX46HSMG50/1IZSKuv6OKHa83olLLWLyyIPQ+vd7g5EpqZjRKtZRzZ/rQxyhD3iN93UZ0UUOIJSJqT4ar2uctzSE5Tc/ebS3ExKqYtyyX664v4cCuNupP9xMIwLH9HaRnRTN4heBGw6gNjU6O1+sLtVGmzclg6yvhGgiX00tL/RBtjcPc8bFZLFyRzxsv1OL1+hEKhRzY1cLaG8pJStVx5kQPLqeXpFQdc5fkUFvTS/2F1tGqTSVUzUpDIhURFaOkfHoqFrMLn89PfKKGRdflo9EGPVPEF0R5SpWUnII4ktN0eD1+pDJRmJPtRFysrl3uaAvBSpTfHyA2UU16VvSUn8m1CEViAmNHjpL7yY/T88JLdD/9DNkPfYyYubMZ2PImXqsNXXkpcYsX4bM7cA0OYjx9BgD3yBh+j5uAz0ffq69T8r1vM7xrN4YTJxFKpcQvXkjUjOkM7dhF2s03cf6Pf56UoWOub6DjL4+Scc9dRE2rRKSQM7RzFwQgeuZ0ktavpe23v8dntTBeMzkE9CLGDh/B1tmF6Wwtlf/3S0YPRvb0ARjZtx9FSjJipRJpVBRJ69fS+/yLoe2x8+bS8J3v43e76XzsCQq++DlMtXWYG5uQ6HQkrl4V9HKJj8NjMTO4dTvDu/bgczjQV1WQccdtKFJT3/dIgUgw1U3WGEl0WrSLlyKIiaMsJxaVvAeb04tOLeM7H53NwKiNjgEzKXFq0hM0BAhw+8oCRCIho0YnL+5uYdTo5GTjMGql9D2bxOnVMobH7Ty0uZzfvHAmLINMr5HxiRsrp0x11mvkfPyGcr7+h0Nc3rWdU5ZElFbG4KiNNw+eB4GAmcUJPHh9ORKxkO9+bA4/fOx4iFAIBLB4WhpxekVoxPil3a388OPzeOyNBs62jnCmZYT7N5Twws5WjtYNEK2Vc/3iHBwuL4++0cDymem8vKeV62Zn8tzOlknnK5OKyEnV0/N6PX5/AJPVhdnmxu8PoFZK3lPO0geBD4nK+wCpTIxUJv6HclosZid7tzZRNi0VkUjIQJ8JkViI3x9g5aZitr9ST2ZubIgEyOQSVmwo5slHjqJQill1fQkxMSp8fj8+bwCFUoJp3I7fB9u3NEzSzsxdnINKc2U1vdnkZNcbjUybnU58kpZn/3ZiUuXC7fKx7dUGbrx7GiKxEPUEq2y/z4/F7KKx9lLScH+3kapZaZw+FvRQ0ejk9F+WA1J9wbtk//YWlq8v5tzpPrY8fxaZXMLMeZkUVyTx8lOn8Xn9qDRS0jKiQpWiyxEbp8I87kAsFpKVGwuC4Jikwx65feL3B3C7vOQUxLL4ugIO7W5joNfIms1lvPRkDVWzMvjIJ+fi8/mxmFzs2drEUP8lArhjSwP5xfH4fAGe/tNxYuPVoTaT2+Xl1NEeBEIorUohKlaJXC4JEcVIwuXLodHK2HBLOc8/XhP+nQpg+boi3C4vdz4w6x/2vbma8FitQY8TgRCpXveuplGk0dHEzZ9H56OPk7JpAxKdFgQCXGNj5H/5i/idTpzDI4yfOs3I7r24DZcqWx6zGUVKCggEpGxYz7mvfwtNUQHpt9+KNCoKj9lM11PPkLJpAwQCUwb9GU6cJP3O2+h89IkwjUv/a1sYO3KM3I8/TMDnQyAUTm3WFgha6CesXAGBAH7P1OJFv8uFz+HA7/bgMZmInl6NvqKCoe3bQSDA53CGhLX27h4avvcDdOVlaPLz8dpsiLVaBEIBfpeb5h//LGxUe/z4SUxnain/6Y+C2p138R1cTQgvyw2KXr8RZ+Ucnj4xxMA5B5lj3Xz9IzNRyiU8uqUeg9lJdUE8M4sTeXpbIycahqjMi2PjwhyeeLsRl9vHp2+u4o+v1GG2uTndMsyiqtR3VXE0mJ04XV7EIiE6tRTZhUqjXCZmYWUKp5uH+db9s6hrG2XM5KQoK5qq/DiS3qHqkJem5/99dhFPvNVAU+c4erWMTYtyqMiL40u/PYDlYjBrIMDRc4M0dBj41v2zefPQeX7w0DwGx2yY7W6iNXJqmob57QtnQsfuH7XhcHl5YGMpJqsbk93NV393KESmDGYnbb1GrpuTyf/cOwOfP0Bbr4mZJUksmpbK/tO9odaUViXlC7dPQyEV878PzkUhF/P1Pxyia9CCQABp8Ro+uqGUoqzoq6b/udq4Ns/qvxDjozbKqtN45enTYavlmsNdrL+5gvIZaXgvK09GxSi55+NzsNtcwdbPuSGS0/VIpCIO7GylenYGmXkx3PvxORzY2cZAnwmtTs68pbmkZUYjn2LVfhEWk5PM3BjkCgmWC34dkWA02DGbnLz699NMn5PJzIWZaHXBtoY+WhGWXHxwVxuLr8tn851VNNYOIpWJSUjS0nPBHVcggILSRF58ooab7pnOi0/UTDCyc/LmS3Vk58Vy/R2VOO1e1Bo5+SVyDu1uDwlpJ2LOkhyG+s3cfO90/P4Ay9cWvaOgWamWootSMmNuBkXliZjGHZw62s1HP7eA/m4jLz11GqvZSVKqjsXXFVB7si9Exvy+AAO9JhKStaRlR5GUrCMzN4a921rQRyspqUrGbHTgsLuRW8XYzE7aDA6yC+KCNzl/AIVCPGXbRigSkl0Qx8c+t4BDe9oZGbAQE69mzuLsYBVO/8G62Qb8AcwmJ6MjVmQiP1qPia4nn8Lc0IhEoyZp3VoSli9FGn3lCo9QLEZTkE/Bl76AtbUN18gomvw8tEXB6R5bVxfNP/5pRKM2WVwcAaDilz9j/EQNYpWSpDWrGT1wEMPxEwiEwQkdBAJcI5ODIIVyOSKFHK/ZgtdinSzEFQhQpKYgUiqQ6HXkfOJhup54alJ7CUBXVoIyOxNzXT1+j4eo6mmT2lcXET1rJl67nZaf/RJ7V1fwpcRikjetR19RiXNw8LIPO4DpbG1IqxI1vZr23/2B/C9+DnGEuAC/203X358h4567UKak/NNtxH8GurKSkNWrZuYs2tOr+OMzl3RmQwY7xxuG+MSNFYwYHTR3jdPQYeDFPW186c5q2ntNnG4ZoalrnK/dM4Pv/uUov37uNN+8fxZCgYBX9rZSlR9/xaqKzeGmtm2Uv75ez5DBjlgkZOn0VG5bWUjsBSKv18hZUJWKwewkLUGDVCJCrRAjfhfETiYVk5uq5yt3zcDh8mJzevB4fLx56PwlkjIBZpubw3X9mKweRk0OjtUPcvBsf8RJnNR4NUIBqJRi/AH4+d9rwio+F7HtaCcrZqbj9flZNj2N371whnXzs/nW/bOxOTzoNTLUCglicdCPpSwnlm88chiP18dNy/IozorBYHbicHsZMTquWYO4D4nKNQKbzc3BnW2TSvqBALz1Uh33f2b+JMGc2+XlfMtISKQJcPp4DzHxKlZuKOH5x06ydHUB51tGiY1XM2tRFvGJGkYGLfgipARPhMftRSQWkJoZNWX1YSL8vgBul4/De9vp6hjjlntnoNHJWba2iJeePBW2796tLSSmaLn9gZmIxSJGhiycOtaN3xcgLlHD8ICZsmkpnDzcNcltVywRUjU7HcOIjZOHu9j+uoes3Fhu++hMDu5qpbE2eHGXSEXMW5pDXKKGotIEJDIJHo8PhUqCTq8gOlaFYXTy6KNcIUEiEbH7rSbiEtSkZESx/bUGcgrjOLa/I+iVcgHnW0bpaB1l0+1VjA5ZGLlgi+12+Xjh8Ro23lrJ9tcb2PZqPUtWF1Bb08czfz0eqoTI5GI23lpJUqqO+tP9nDzcidPuIbsgjgXL8oiKVUbUNEmlYhJTdGy4uRy324dUKvqX6FEC/gADfSZeePwkmzbmofIZqfvu/4bcXD0mM91PP4Oxto6CL37uHbNphGIx8oR45BGcUkUKJWm33ET3089c9iQhhV/5EoNbtyGQSLB395D94AO0/vL/8JgutQQH397G+KkzFH7lC6HHFGlppN20GRDgsViQJ8QjUiqDficXKhlCmYz8z38Gc30DTT/6KV6bDU1RIbmffJih7TswHL80uZa4ZjUCiRhbaxvDu3YjUipJvXEzptq6SZoWbXExEr2O+m9+B8+48dJn6vXS9+IrCCVSdJUVIBRGdMeVRkfjs9vwWq00/uDHFH71yxHbLcZTZ0jZuAG3Qoks5oNrB0qiosi6/146/vIo6uvW8ujzk4PzAoHgCPD9G0pp7gouVBwuL3/f1syauVk8+XYjDpeXQ7X9zC1PJjtFh88XoGfEwsKqVPpGrHRfmK6JjVBBrGsb44ePnQj97fX52X6sm/N9Jr51/+yQ661YJCT+PaSUqxQSVAoJEquQMy0j1LZFNs8MntMo5bmxbD/Wxfr52ew62RNxv81LconWyGnuNOL2+hmIcK2C4GfY3mvk1X3t3LWmiMLMaN481EF+RhR1baPsPd0byle6fnEOjZ0GXB4fX7h9GvvP9NEzZKEgI5oxk4Ntxzq5d20JmUnaD5TUvht8SFSuEShVUgZ6I2stvF4/xnE7KRp92OMXg/Yux9iwjXOn+yguT+Lw3vPc8cBMxFIRHpePk4e76GofQ62RM3NBJnEXdCoX4fEERbYHd7fR321CFyVn9sJsFEopIpEQX4SxUalMhEAQvPGWT08lPlGDzeZCrZWRnR/Lhlsq2PlGI/YLq4zsgljW3lAeahNJZWI23VbJjtcbEQoFoRHkV585M+m1lq8r5sTBzjBRa3P9EG3NI9z90GwqZ6YhFguRyiRYTA5qT/YyZ1E2EpkEhy04dXVkbzurN5fwwuM1uF2XCJtQKGD1haTq3i4jADffW83YiJUVG4p55i+TV8aBAOzd2szsRcHxaJFYiEIlYXjAQv2ZfoRCAW6Xj+7zBk4dDZ9GcTm9vPTkKe54cCbbXr3kzFlX00fj2QHu/+x8EpKmNmmSSKeuvPyjuGha6L2QtaLWyq8o/PY5XThMVupP9LJqRQbS/ha6t++IeFM1153DOTT0rkP0IkESpUdbWkzh177MwFtbcQ2PoM7JJvWWGzEcP8nQ9p3ELVqIrryM8ZrTYSTlIlxDQyAQoi0pxmu1kXHn7bT99ndhDrS6ygryP/8Zmn/2CwI+H5n33kXfy69iab7U97c0NNLY1Ezxt78BQhEBn4/Y+XNxjYwi0WgZ2rkbAGtbG7EL5lH6w+/T/9oWjGfPIlYqiVu0EEV6Gvau7jCSgkCArqwUZUY6HrOZgMtN8oZ19L/6evgbEQhIv+NWBt7aCkDA48Ha0oI6Lxdra7jRoUghx+9y4TGZPlCiIlYoiFuyBE1xMR12Ee4pxO4mqxvZZSP0bb1Gblp2yXm7qdPAp2+t4tEt9Tw+IcwvLUHNp2+u4sXdLWxcmEtS7CXHW4PJyV9ej+zF09ZrYnDMdtXt+XVqGSXZMbx9ZOoWrlohwXGBODR3j/Ppmyv525Z6zBeujSqFhIc3l5MUq8Lu8HCmZYT5lcnMKknkRONQxKqKPwBOt49fPXOab9w3E7lUxNajXew6EU6CbA4vnf1m5pQm0T1oYe3cLI6eG2D70S5kUhGLpqXSN2xFrZAQ9x6I2/uBD4nKNYIrGaRBcCJIqQovc7Y1jUzSnlxEw9kBNt1WGRxHFoDT7uHvfz4eVrFprB1g0co8qmalo1JLEYlF9HaO89SfjoV8PQyjNjpax7j+9krmLM7mYATH13lLchnoNbH5zmmcPNRJXU0fKo2UeUtyyS2Ko3x6Ktn5sTgdHsRiEUq1NGzcWqeXM9hnYvHqfGLi1IglQkaHrIhEQvwTtAByhQSFUhJx8sbn9XNgZysLVuTR1jhC3aleXE4vWXmx2G1urBYXYrGIV54+zaKV+QgQcNdDs+loHaWv20RcgprMvBiO7j0fIilBCNBGKRidQt0PMD5mD01kLVtTyMighcqZaRhGbeQVxaGLUrLttci27T6fn862MZLTdPT3XLq5er1+dmxp4Ma7qsM+q/cDNouL820jCBAgFAoRiQRIRmwkJGknWfH7nE4c/QP0vvAS9u5uklNSSMxfj0CVjLVtihgJwHj6LNqCgn/6HEUSCaqsLFzDI8QvW4JYrUEklyEQCOh/9TUgqDEpXruatl//NuIx4hYtxHD8BCmbNyEUS2j+2f+blEpsOnMWWWwsMfPmMF5zGrFGE0ZSQvD76X7yaXI/+ylMp8/Q/fdncQ0No0xPw3/B9Tb1huup/8a3yfv8ZyAQIPXGG/C73YwdPgLHT6ArLwsdTpmeRua9d2OqO4e5qRmJTodAKCCqehqq7CwG3ngL18gIqsxMElevYvTAQWztl6oUzuERJBGIYMLy5Qzt2UfKFUzu3g+MW5z0DNnZftTAkulpV9z3nVbvc8uT2Xq4k3MXpv6UcjH3bygN2csnxapxur2Mmx1o1XJEQgFOt/eKo7pNXUHr+auNWL2CTYtyqD8fOe9pYVUqT77dyL1ri/nblnrio5X84KF5eP1BOwG9Wka0Vo7F4aFn2ErHgJkzrSOUZMfw7Y/O5ok3G2ifMDwgFgmIj1JgMDuZX5HMmMmJRillb81ky32zzUWsXkF1YTwqhYSfPVUTIkgAnW82UJIdQ0qcmrhrzJPnQ6JyjUCpkqLVyzEbI1jxCyAhWTsprttujzyGBsEbt0AgQCYXI5GI2PF6Q8RJkX3bWyksS+L4wQ6mzUpny/NnI5qPvfbsWe7/9Dy0ejnHD3ZiGLURF69m5sIsrGYXSak6nvvbiRDjv+hUWzotmes2laLVK6YUeMoVUgrLkrBZXHg9fgIBP06Hh+KKpLBWS1Kqlp4IJOUi8ksS2bmlkZ7OS2nQDWcHaG0c5qZ7qqk50sWNd1czPmZn3GBnoNeEzeJCIhOTVxTPY787PMkboafTQGq6/h2N0xRKCR/55Fw8Hh9nT/bisLmZvTgHiViIPxCI/L1egGncgUotIz5RQ3ScCpvVRU/nOOebR3E6Pe8rUfF6fHS0j+Jy+Ni3rRnbhUmEuAQ1111fSpJYGHr9gM/H+OmzNP/kZ6GYWUdvH8Zjx8n7zKeu6PVxNdJ5xQoF4ox0FCnJOPr7cY+M4pNJQ3b1Prsdz/g4QlnkFW3swvk0/uDHyGJjyLjrzkkk5SJG9x8g77OfwjUyGpmkXIC1rR3nwBCaoiJysjLB60WsVKHOy8Xv9mDr7MLvdiMUiRjZt5+RfftDz5XGRCO/4Kor1mjIvPdumv/fr8LGjw1Hj5F6841oS0rI/9xnMDc1YTvfQdtvfjfJol9TkMfAm1vDHlNmZhC7YB51//MNMu+6Y+oP9ipjyGCjs99M95CF6sIE9GoZCpk4ohYjTq/AYr80/VKeG0dZTgwSsRClXIzd6WV6UQJf+W1wekokFPDFO6p58u1GOgfM3L6ykGitnBd3t+J0+5hfnkxJTgxisRCJWIhnikpOjO79yzgqzIhmyfRU9lw2ybhyVjpalYT7NpSgVUoQiQT0DltQKsRhrSeL3c1Lu1t5dd8l4t85YGb3yR6+fNd0fvXsqdDE0IObywkEAnz7o7OpbRvl/54/w5fvrMYX4Rpe0zTM1+6ZgVIuYeuRzjCSchH158cYGreTlfLOQZcfJD4kKtcI9NFK1mwu49lHT0yqksxekDXJ+AsgtyCOAztaJz0OQdv+sWEr120qwTzuoKM1MsMHaGsaRiIRMzxoDRO+ToTfH2DcYKezbYyqWWmkpOmx2dzseqOJqllpHNjZGrEsee5UP/OW5CKTiS4Z2bl9xCdpUKmlyBXBm4pMJkZAcOT5jRdruf/T88jIjgmlPwP4vIGQLf7lUKmlSGWiMJJyER63j5OHOtFFKRkdttJUN8jYiJXiimSmzU7ntWfPUliWGNHA6fSxHjbfWQUXAiMvutBORGpmFAJBMMRw/4Xv47rrSzh5qJOmukGWrS0kPlHD8BS29hnZMai1MoYHLAz2mUjLjGb+sjxOHupEwPvbK7Za3AgFAt56qS7s8ZEhK889epKPfnZ+iKi4DeO0//b3RPqgzv/5rxR+7cuRiYpAgL6q8qqds9dsZuzwEQbe3ErmvXch0elCrZ7uZ54jYcVyOs7/New5IpUKv9uNJj8PBAIc/f2RDg0ERajS6GhU2Vkh59hIEEgkSHVa+l99nZgF8xjavgOxQkHCqpVoCvIZ2rETCBIaTWEBlqZLpn7uMQNijRqxRkPC8qX0vfLaJI8UgN7nX6TiFzMxNzUhFEsY2PLmpH3EGjW6slJUmZmM7DuAz24nevYspNFRnPvWd0m75eaIAYjvB4YMNr79p6P0jVwiUnPKkvjUzRX87KmasP86YpGAe9cV8/zOFjKTtHxkfQlnWoY51TxMR7+Zz9xShcXuxuvzh1KG55QlcfTcIB39Zm5bWcCgwc7T2y7FCxyvHyQ1Xs13PzaHZdPT2Hq0a9I5SsRCCjLev5KBXiPjoxtKWTcvm6PnBggEYFZJIgCv7W+ntcdIjE7OXauLyEnVE3PZtX3c7AojKRfhcHl5aU8rd15XSEu3kZWzMth5opvDtf1YHZ7QZxutU1zUMYfB4/Wz71QvNy/P50TD4KTjX8TBM33MKkm8pnQqHxKVawiZuTHc96l57H6rKZjuq5OzYEVeaPLmckTFKiOakAkEQR+S2poeCsqKGJ9CiHURHrePjJyYiBWXiZDKxCxfV0ggEKyC6NxeRBIhUTGqkDV8JBhGrZjGHbz01KmwVOMZ8zJZuDIv1DaxWly8+WItBODR3x5mw83l3P7ATLraxmg6N4hcJaW4IpkjeycL85LT9HS1XYmMjbDp9koO7myjuDKJrvYxjh/ooL1pmDU3lKLVySOmLjsdHt56+Rx3PjiTtTeUBTVBEy4AcoWEJdcV4PP5QyRFF6VAJBLSVBe8GJw+1sP8Zbm8/tzkhOu4RDUJyVqe+tPRMMfZo/vOs/nOKuSK9/cn6vF4OHZgcugZBMXaLfVDxMYHqyEek2nKKoTPbkcgEiFPTsLZHz4qnvuJh5BEXZ0bg9topOWX/4epNkishnftIWntarr//iwA9s4uxGoV2pJizPVBPYOurJSUzZtwjYygyc9HnZeDWDO19kes1eKxWAi4PURNnxYU8EYgZ7Hz5xLw+xk/dZqUGzYRM2sWHrMZiVqFta2d+MWLGHj9DQbe3kb+5z9D229+h3vs0m+15/mXKP72N/AYjfS98tqU5zN+6jSxCxbgczrJ/thH6f77s6HvQZWVSfZDH8Pe14+2sJDEtddha2un76WX8bnc5H7yYXSlJZMCEK8mDGYnFpsbfyBA34g1LJcG4EjdAFEaGT/95ALePtLJ4JiNvDQ9K2dnYrO7SYpVsWZuFj9+4gT2CeL5Q7X9fGRdCWpl0JjNbHMzuyyJ3zx/BoVMTEailme2T47p6B228vaRTm5enk9br5G2Cdq/+CgFX7pzOlqllMGx4AiwTCJCr5GhfIcpyH8EWpUMrUpGfnrw/31t6wjf/NOR0GJuyGCnocPA7asKiF+Yg3KCHuxM69RxHb3DVgozoslO1tE1aGFJdSpjJgcd/WYSo5XcuCwfrVLCrNIkjtZNtmzoGDDj8weuqD+TiIXXFEmBD4nKNQWpTExqRhQ33TP9wtSN8IqW+2qNnBvumsapY90cP9CBw+EhIzuaxasKUCglrLuxAuO4HcOojdQM/WXai0tITtfjdHowm5zExKsYG55MbC5l1QQnhqRyMUkpOu58YBY2mwsERNTLCASgi1Ly1/87NKmldOJQJ0lpOipnBHvYXe1jofuB3xfg1WfOIpGKKChJIDUzityCOOrP9DFvaQ6HdoevOJQqKbIr3NTFElEo92eiHmhsxIbD7iEzN4Yl1xWEWfVfRG5BHCqljJLKZJJSddQc7cJicpGZG0NMnBp/wM/I4KUbeGFZYlh2kGHUxmC/mZUbizm4sy0kKk5O07Hxtipe/fvpSbb4fn+A1587ywOfW4hUKr4qGVGRIEDA8BXyTno6Dfj9WQiFwismQwN4rVbSb70Fn8MR1FloNcQvXYIsIR6x4r35unisVrxmM16bjYTly4CgY6y5voGY2TNJuWET/a+/ScDjof13j5DzyY+TsnkTlpZWVJkZNP7gx2Gjzflf+CyKtDQcPZOnLtJuugF5YgKJ61YjFInJvOcuOh97ImwfRUoKcQvmYzxbiywuFtfQCO2/fyS0XVOQT/bDD6IrL8dUW0v77x4h67578Vpt2Lq6UaanIU9MoO/V10m/9eYrvveAx4treBiRQoEyN5fi736TgMeLQCzG3t3D0K7dpN10I1KdFqlOi0SjRVdWikAsfk8C5neCx+ujpdvIL585FdKDJEQruWdtMbtOdFPTdOmG+9bhTqYVxiMWCvjSndVEaS6Jte9RSfnN82fCSMpFPP5mPVUFcWxcmM2TbzchFgpxuX3MLEnkZNPUCe3bj3aREqti7bws4qOVDBtsZCXrGR6309w1jsnqwmL38Nib9VhsbmaXJvHAprKI00PvFYNjNn77wtmIFedntzezeFpaGEmK9CuTS0V8dGMpErGINw51oJCJWViVglQi4pYVBeiUUtw+P+NmJ92DFm5dno/T6eFM66UJpItVq1f3trGoKoUtByMvUFbOznyvb/mq40Oicg1CoZRMCqObChqdnAXLcqmalU4gEEAqFYWMwxw2N1KpmJOHu9h0eyVP/uHoJMO28uoU+ruNJKfpOHGwk+Xri3j5yVOX9hPA6utLcbu8PPHIUexWNyqNjFnzM/F6/GRkR6OPVpJXFE9rw+SVQMYF6/vUDD0Wk3NSa+ngzjYysqOJilHhjtDD9rh9oZt+fKKWo/s6mLkgi1s+Mp2WhmGcDg95RXFIZRJEYgFH90X+8ZVWJdN8bpCsvFj6JhjMCYUCOttGKatOoXx6KkqVlD1bmzGNO1CqpcxbmkvZtBRkFypa3R0GzONOlq4ppOncAF6Pj55WA8mpelLS9fR1G5FIRLic4cTj+IEO0rOjWbmxGLlcglwhpq/biNvlnXLay+3y0d9jxOX0kJiim6RRuhoQCQPoohRTkpW4eHWQpBB0FhVrtREzaUQqFfKEBMaOHUceH0fyhnUIFXKkOt17JimOwSHaf/9IqK0kVqtJuX4jmoJ8el94iY6/PkbCyuVU/PzHOIeGEQgEOPr66X/1NbIffID6b35nkv/K+T/9laKvf5WeF17CeOo0BAKIlEqS16/F73ZT+4WvEL98KUlr12Dr7KTom1/HfO4cHrMFbVEBArGEll/+H2m33IQsIQH7ZYTH0txC/5Y3yPnEg7T87BdY29pp/tkvUKSnk37bzahyc2j87vfJeeghIJgYbW2J3MZV5+fhMZpo//0fyX7oAZwGA+1/+CMl3/kWYrUKRWICggnhftIPqM0zOGbnG48cwjuhHTpksPP/nq7hmxcM1CZO+1jtHjQqCTq1LGxF7/MHImb9QHCi5eJI760rCxg22MhN1SMWCnBHsL2/CLfHh0goJD5aSbRWRiAAX3/kMLYJVeOUODWfu20aP3vyJIfrBjDb3Xztnhm43D7OtY9xqnmY5DhVKAxR9k9M2JmsLvpHrCGr+0jvr3PAFDaxVJEXN2m/z902jZf3tNHcPY5SLuZTN1dgsbmxOjy43D7G5GJMNjd/fvUcSrmY21cV8MCmcobGbVhtHlQKCQNjNn7591OY7W5+/In5nGgcYnAsXHC8uDqV5Anncq3gQ6LyHwChSIhWNzm8bt+2FgQCSM2Iwjhm5/YHZnL6eA99XUaUaikV01PxuH14vX7aW0YwjNoYH7Pz4BcWcupoNz1d45RVpzA2bOX4gc5Lx7a42P12M7MWZhGXqCY2XsOqDSX095jCTOGiY1Vct6mE/h4jyal6oiqVaHUK9mxtDtn5m00ORodtKBRS0rOnVuEnJGsxXli1HT/QwamjXRSVJ7FgeQ5bnq9joNfE3CU5TJ+bwcnD4X3p6FgVBaWJvPr302y+cxrP/PU4YrGQhSvyiEvSYLO4GOgxoY9RUladQlZ+LF6PH5FYgEYjD1Uzxsds1BzpRh8lp/5MP+dO93HdplLiEjV0to+RnR/LwpX5dLWPkZkTM6kd1n3eQPd5A7MXZTM8YCY2QYMjgqBtInw+Py8+UcPdD89BH331RwZVYh8Llubw0tNnJm0TCAWUVSXhMhjwmEz4nS5KvvdthrZuZ3Db9kvtEKGQgi9/AYRCtIWF+D1u3OPjiFwqJKr3JqJ1jY1R/83v4Bq+RIK9VitdTz5N1kfvQ52bg7WtnaHtOxmvOU3h/3wF9+gYIpWSjLvvxDU8HPJEmQivxULD939I6Q+/R+bdd+Ixm/GYTIzs2cd4TdD3Z/CtrUTPmoXf7abxBz9CW1iISCGn+9nncY+OIbjg+5K8fi2tv/7NpNcY3X+QxBXLiZ45g9SbbyTg8xHw+Rjcup2E5cvI/+LnsTS3MPrss2Tddy/13/rupHONW7IYn9PJ6MFDOAcG8DtdmBsaSVi5Eo/JTOsvf42+soLE1de9p8/5H4Xb62PLgfNhJOUifP4Ae2t6mVOezL5TlwSlUVo5pTkxSMThOjOhQIBAECQOQqGAvmFrmBjU6fahVEhYVJkCAshNj+L/PV3DHdcVsv90ZJfh6UUJ+AN+FDIRXYMWfvfC2RBJSU/UkJmkxebwsOXAeVbNyeTlPW10DZgZt7j45iOHQxk7EKx6fOXuGUwvSkD6D6aRG8xOXJ6pk8CBSQnSF+3xX9kbrBqX5cTS2mOkuTuov/vGR2bh8fp54+B52vtMxOoVrJqdgUwi4oFNpfzhpVoeebmO33xhMQE/PPJyLQ63N/RzzUrW4nJ7+cpd0znfb2ZvTS8KmYj1C7LJTNK+52iC9wMfEpX/QHi9fuxWN1Wz0hBLREikIg7uaKWgLJGkFC3xiRqcDg8nD3dRWJpIXnE8j/72MLooBUVlieijlSxdW4jH7cNidrL1lcijtScPd1FSmQxAdJyK+z8zj/PNI7Q0DBOfpKG4PClUhbkIuULC9bdXsvXVesbH7CSm6OjtNKBUShjoM1NQkkBzfXhJVyAUsHpzKUqVFIfdHXTMzYtFJhPz/GM1oSrN4T3tzF+Wy413V9PWOITDETSDU2mkNNb2s/nOKnZuCbZ2Nt85jeMHO8JSi1VqKbd9dCYJSRpEFy6mXo8Pp9UTJHPNI3g9PipnpnNwVxtrbyzjtWfOhjniCoUC1t9SQVSMgtqavlCb5yKUKinZebEc3X+ejOwY3G4vKo0ssuuvIBgBYBx30NM5/r4QFYlWS6LGxPwl2Rza1xFqz0llYjbdWIQi4OTc1753KVhPKCRx1QqKv/UNup/+O8r0dJKv34Cjt49zP/8lXkuQgIq1WjLvvQtHXy+xs2dFdE59N7B394RISvTsmcQvXkQgEEAgFOG1WknesI6WX/waCAYLBnw+fE4nQqkUeVIixoHI0QoAPpsNv8OJx2Si+ee/JOCZrNEa2beP5I0bsHd1Y2641BYUiETkffqTiHU6rG3tuEcn66MCHg9eqzWkn5kIz/g46XfdiVQfhflcAyP7D1D24/+lf8ubWJpakOi0xC9dglAmQygSYTgRNJYL+LwM79pD2Q++R+/LrxLw+Ui/4zbEyg/W98Lp8tLSPVm4fhGdA2ZmlyaG/p5dmkhKnIqE6MmrdaVczPcfnEtz1zh+f4CcVB117WO8uq+NQACyU3Q0njewak4mAGKhkAc2lhEgQF6antbLIjiUcjErZ2Xg8/txuL24PT6MVhfxUQq+eEc1IpEQk9WFXCpGKRfj8/t5eU8bq2Zn8udX68JICgSrHj97qoZHvrKUhJh/rNrQPWjBYHaSmaSlc2ByJVIsEpCeGO4Gq1ZKuWFJHtWFCby8p5XF1Wk88Vbw/97i6hSsDjc/fvxEKGPIYHbS0j3O+gXZzCxKIE6voDAzmpqmYU61DPPFO6vpG7FisrrJTtGRGqfmR4+foCAjii/cUc2CymSEQgEyybVLB67dM/sQ/zAcdjdOp5dj+85z6lg3Xo8flVrK7EXZ/P/2zjvMqTJ9w3d6mbTJTDK996Ez9A4iYENQsWDDXtBdV9fe1nVd67qWtf7cxbL2ihUFpIiA9D6d6b1nJpOe8/sjEIiTQVwL7dzXxXU555ycfDkmJ0++732fJyPPiiAIxCdHolTK8PsFElMjaW3qob6mk1PmDCAj14oxMjBNL5NJQRkocA3XrgyBFuiDl2tMkVqGj0lhyMgkHL1uXn8hVKTAgeLUCSdl8sUHOxkzOZ2VS4qJSzSy5ONdnH7uYHIGxOByefH5BVwODzkDY9EbVHzw+haQBDJxdHoVb/1fXwO2NcvLUKpkXPGH8ZjMWlzOwHmS08x8/PZ2mhq6GVSQQPHuA2nK+7H3uHnz5R+4+Lqx7C1pxmLVI5VL2bKuipSMKPaWtJKRa0GrUzJgWDzfLSvrY9vv9wt8+eFOzl1QwLmXjWDT2kr2bA98WeYPjmPY6GS++GAnCNDeZsfj9TLp5Cy++qivOdXw0cmBZSGBQ/q4/BIkMhmGGDODurvJW5BPZ48XuUyCQSdDb9ay85bbQpd6/H4av/oalcVC/gP3I1Mq6K2ppfixf4QUnHptNsr+9QJ5d9+Ju6PzfxYq3fuWQ5IuOA/B56PkyaeDsw7quDiybroRbUoKfrcb69TJ7L7nfgb+/UFUFgtKkxFvdna/51ZZLEiVSiRyeViRAtD2/TriTj2FxHlnI/gF7BUVqKxWjAPysRWXoPR4qH33vbCPVUaZw9rsAzgaGvE5epEqAsu0jV8uwVFTR/oN1+JpbcPndCKRyeitrKL8rXfA7w+MVSYHvx/B78fT1cWgRx5CHR93uJfzV0OpkBETpQ3x9DgYi0lDZ48bpVzKjNEpnHNSVtjgu+5eNys21/L6l3tC6pVPGpnE5WcMoLa5h63FzeTtC9lsbrfzw55GFq8q57Txqfzh3KFsLGzi6/VVuNw+huVYOGdaFo//dzML5w2hoaWHXpcPrVrOvVeM4bPvylm+sSY4Y5MaZ+AP5w3ltPFpZCdH8sG34ZffvD4/e+ttP1uomPQqXv9yD1fPHcTj/90cdIndz7VnDSYyTFitUadiSJaF7GQTXT3uYP3OzNGpPPXO1j5BiABfrNnLuEFxDM+1MmZgHA/+ez1+AXaUthIXHYFOo+CrdZWkxOqZNCwBg25fxpjqt/Vp+jUQhcpxgNvtpbmhm5bGgBvq3pIDBVT2HjfLvyhi8sxslEoZUVYJPTYXCoWUqOgIEvZlA6nCvFkFgZ+si9CE6UaSyaT09rhpbQrfIdLV4UBvDBQCK5QyxkxKJ8qqI39IHHK5FFuXkx2bavF6/OQMiMHt8lK8u5PT5gVmMEp2NzF0VBIyuRRfGJ8Ej9uHTC7r49w6d/5QmupsSOXSsC6zAI5eD421XURb9Lz9741YYnScfu4Q1iwrpayomflXjcLl8JCYbGLZZ4Vhz+Fx+/C4A2nNQ0YkMnBoAoIg4PX4UKvlDBwWj8/np6mhmwFD4ine3cjcC4fxw+q9NNbbMJo0FIxNISPHwstPfQcECp5/KxQGA9FD8nF3dGA0upAq5CiMJjp37AhbjwJQ99EnWCZPRKqQBzpWwvV2+/20rFpF9IQJaJMS/6exaeLi0KYko9Dr2fvyKyH7nA0N7Pnr3xj44F9w1NZT+tQzJF1wHuq4OBS6iH2vTY8hPz9kNmQ/iefMpWP7dswFBf0+v9/lAokEweul5r0PUFksdO3cRdVrb5B80fxAXZg5KsTddj9J559L4zfLwp5Xm5iIq7kFlSUahdGAp8tG186d1H30CWqrlZZvV+JqacHv8WAaOoTo8WNRx8fjqKtHrtch02rJv/cuFIb+u5d+S9RKOWdPyWLtjvAzVmdPy8KkU3LOtCwi9ap+l0w6bE7sDg9DsyxsK20Jvo2Wb6zh1osKUCtlvPTxLs6YmE5Xj4sPV5Th9Qm0dDp49YtCXv2ikPw0M6dPSEMpl1FU1R70YGlus2PSq9Fp/Vx15kBWbanlmx9C3aErG2w8/OpG7r1iNM2HMIgD6HX+dJTIj4mLjqDX6eW9ZaXceelINhc1s7eui2ijmpNGJpOeYDhk7UtAREgoyLHy3fZ6kNCvkZ1fgLoWO9ZIDXXNPSFi5mAL/j0V7cydkknqIVyvjzZEoXIcUFvZwVuvbODcS0eEiJSDWb9qL+cuGBHiOpuQbOLM84fSY3MhkUhQawM5OPsJWNHLMZm1wfqQg4mO0aHRhTfX+nHR7o8JBCeWUFcV+EUmlUm45LqxLP10D3XVncHj1q3ay44tdZx32QiKdzYy54KhFO5soLyomZETUlkfplV52OhkIiL6jktvUKM3qGlt6g4rcPbT3eVEoZQRoVfR0tTDtg3V5A6KxRqnp7HeRlaeFe9PrDu7XT6+X1FO4fZQvwKdXsU5lwxn6eeFJKeZUWnkpGVZ2PBdBdn5MYyelI7X48Nk1vDVR7sQfAI6g4rY39iASSKToYqODtnmqOnrbrkfb08Pfo8HT5eN3urqfo9z1NUjlf/vtxl9TjYxs2ZQ/2lf/xAAn70XW1EJXrudvHvuQh0fHxQpABKplPjZp6NNSaJl5Sp8Difq+DgSz5pLT3k5CALyiNB25oNRWa3Y9+7F1doemB1qb0fw+1FZLdS8/S61739A9s1/ovnbFbSv/wHB50MRaSLxnLOJSEunt/rVsONOPO8cmpetoGPTZpIuOJ+9L76MYeAAIlJSMOTnotDrqVv8GamXXIitqJiqN97Ea+/FOHAA2bf8CaXZfMREyn4SrDoWnjOElz7eGfQ5kcukXHXmQFLj9ERo+reS7+wOpP9+vKocu8PDwPRozpycwf99sivowfLpd3sZlmXh9otHYDaoaWyzs7O8jekjQ51u91S0B4txLZEaVAo5t108gm831ZCeaGLjnkZG5MXyf4vDW+q3dDpobu8lNd5AjFnbrxDISvr5LfZRRg1/uXos9720lr++sp4h2RbS4g0o5FISrDqMup82ntOo5FwwM5cNe5p+8r4aoZazrdhGRpIpuM0SqUFC4HXuF4LWSA2WI5iw/nMRhcoxTrfNyVcf7UKrVdJxiF8ELqcXR687KFJi4g1MnpHNFx/soGpv4EOemGJi1tyBxMYbggm8eoOaeQsKaG3qxuX0UrijgYrSNrQ6JWdfNBxTP5kQmghlyIyH3qgmJd2MIEBleRtety8oUiDwBd7a1BMiUvZj73axbUMNjl4Pq5eWccEVgVhzn9eH9tQcNq6pJCElkmirjph4PSkZUcEunXAoVHI0EYo+LcH7MVsisHX0olbLcbu8pGZG4/X4qCxrw+fz43b6GDwigZh4PU31oUsyBpOarLwY4hKNbPi+ss+5e7pd7Nhch8GoYd3KvWzbWMOl143lzAuG4Hb5cLm8NNXb+Pz9nXS09RKfZGTu/GEhAvL3QpuS0u8+hdGARCLF2diIJiGe3qrwYkUTF4s6Pjbsvv14umx4nQ4Erxe/y41EJkNh0CPVaPD12jHm51Px0iv9Pt5eUUnk0CGorNYQkQIg02ppXrECJBIyrrsWiUKOu72dusWf4aipIfvmm2j94Qey/nADe/76Nxx1B9rKFZEmMq69ivIX/w9XczOaWCu1n3xK0rnn0PD5V7StXQ9A8aOPY5k8iew/3wwI+N1uZFote196meyb/0jFK4uCdTYyjZrE885FHRdL4ry57LzzXiLS0xn67FMBnxpbN+0/bMQweCD599xJyVPP0HOQO27ntu107drNwIf+is/lRGEw/OKuqv+VCI2CqSOSGJZtob7NDkJgBiFSrzrkLIHN7uK1LwtZtuHAe6a8tosVm2u45cICHn51A063j85uF5OHJ6JWylAqAnlBNU3dJFh1QdfaHzN/Zi7mfY0FcyZn0G33MHpALL0uX9jj91Pfaic90cj8mTn88+2tffZPKUgk0vDzi0xlUgmZiSaevWUqFQ1dNLU7yEw0EhsVgflnZA3FRUfw+B8mUt1oO0S9i5SUOANyuZTYqAhsPS4GZ1moaw4IvwSrju931FNS3YE5TJaX19aGq6GMnsK1yCNM6AZPRW6wINMc+S4gUagc47idXtpa7ChVspBwwT5ICL4xJRKYfnouH7y+JSSduLaqk9eeX8dVN00kOkaHz+vH6/WxZ1s9G9ZUolLLGTYqiRmzB6BQSDFbwtcduJweBL+fMZPS+OG7CmbNGYhECmWFLUgkcNrZA4PLSvu9BVIyoigt7N/oqGR3ExNPzqJ6bxvNTd0kp5pxu31k5cWQOyiWDd9VUlnehr3HhSVGj1IpR6kK//bWG9RMnJ7FN4v7/oLeX2hsioqgq9PBqWcNYuOaihAPmsY6G7u21nHughG89OTqgGutVMKMMwPXZc/2Br74YCc5+TFMOCmTLz/YGVLLUrSrkQuuGEVZUTMOu4fVS0uZfd4QIqPk+Hw+DEY1SamRAR+dCBXafmatfmsi0lJQxVhxNfX9/5I47xwEvw+JQo71pJOCX9ohSCTEzJyBVBX+hiz4/QEfkKXL0GVlUvXGW7hbAzOC6rg4MhZeS83b7xIz82RUVguu5paw59FlpGEcMgiFvm9EvVyrJfnC+ey49Q7a14cu9xny8/Da7bR99z0xU6aQf9892CsqcHd0ojAYEHxe9r78bwSvl+xbbkJhNhN/6iwMOTl0HJSa7He7aVq6LOhEK1Uqybj+WnpKy6h87Q1y77gVV0srEpkUucFA7bvvY8jJRhUXy8C/PYDPGQgNrHr1dXSZGRiHDMbXY8fR6wgRKcHr5vVS9cab6HNzkCmVxJ46K+xr/z1QKWTEREX8rNqN5g5HiEjZj83u5ut1lUwZnsiS9VXkpkSyckst2cmR9Di9mHQqlHIpb31dzJ8vLODFj3bQvM+1Wi6Tcva0TEbmxQTPp5DLMBtlNLX78Pm8/dr4AyTF6KlusLGluIU7Lhm5z0E28IV+9tQsxg6OQ6/93z6HMqkEq1mL9RcUw8tlUnbvbaOrx8315wzh/pfX9XktC+cN4a2vi1izvZ6LT8lFp1UE61QgcN+fOyWTWy8swKQP/Ux6ulpofOuveNoPCPWuDZ9jnnYx+mEnI1MfWbEiCpVjHKlUApLAUoNEEugq+XGnCUBGtiU4c5KRY6G0sCVEpOzH4/ZRvLsRqSyOwh0N1Nd0YY7Wcs4lBaz9tozvlpVRUdrGvAXh1/VdTi+7ttbzxQc7OfmMPC65bgxLPyukpiI0fycrz8rMOQOCRaQKheyQyzFSmQSZXMqc+UNZ/kVRUGRIJDCoIJGcATFsXldFbWUH2zbUcO6CEWTmWcM6MEqlEgYNT8Dr8fP9t2WB6yCBrFwrIyek8sN3FWRkW9Ab1Hg8vrBGeR1tvRTtauTyG8fz5Yc7GTQ8gb0lLZQc1LFUXdGOyaxl9nlDePs/G4OzWVKJhPZWO7PmDOCz93ZQuLORk8/IR6mSI5PJfpPunp+D127H29ODt7eXnFtvQSKT0fjNUpq++hqJXE7CnNlET5oQXNZpWvM9GdddQ+Wrr+NzBL44ZBFaMq65CoXJ2G9HiqulhcKHHyPn1j/h6egk7YoFSGQyOjZuomn5CvY88DcGPfI3at55n7jTTqVy0Wt9ziFVq4kcPuyQX9SqKDP5991N45Kv6dy+M5BgPGUS2qRESp/+F5GjRiBVyBEEP6VP/4uYWTOIyMzA29VFyqUX4evtpX3jZqxTJtGxfRdSrZboieNDsnsOxjR8KN1FAVt3dUwMLatW42ppIen8c2lbux5PTw+q2BjqP/mUru07SbvqMpqWrSD5ovk0fvU1xY8/iXHQQDTx8f2+Jtuu3cSddgrFjz6BPjcH05DB/R57tLF2R//xBet3N3LrhQUs31TDmUiOtZwAAFwLSURBVJMzuONfa5g9KYNvfqji6jmDOGtaFu98U8wri3cx76RsTHoVXp+fSL2apBgdhoi+sx4KuYx1u+o5fUIa7y/vWywbZVQTH63l1mfXYLO72VnWysmjkjltfBpSiYSRA2JQ/0op5f8rXp+f7aUtrN/VyMbCRu64ZAQ7y9sorekkxqxl4tB4/H6BNdvrMUQoiY2K4PH/bg45hyDARyvKGJEbE7Ld7/XQtW5xiEjZT/u3b6DNLBCFisgvQ6NTkplrpaywmTXLyph9/hA+fnNriAiJskYw7dQcXn8x8KvXEqunqjy8wVK0VYclVs9L/1gdYie/fnUFc+cPxenwUFvVQVtzT8BYThBCAvt6bM5AVwuwc0sdEokkRKTsp7SwmdxBscEgxrhEIyq1PNgh82MGDk8gIkLJlx/uouMgkyJBgB2batFoFZx0Wh5rlpfhdHj45O1tXPvnycEuph8ToVMxfEwy6dnR2DodIJFQXdFO8a5GRoxN4aO3tnLKnIHs2d7/TXXHploGFyRw3uUj6GjtZWmY4trO9l5KCpvIyrMGRUzekDh2b60jZ2Dg9Xd39R9Y+Hvj7uzC2dhI/eLPaP9hA4LPh1yvI/HceQx7/hmkMjlSvQ5PWzu+3l6kBgMtK1bibm0l88aFSNUqpHI5EoWChi++RBYRQURyctjnalu/gew//YHa9z6kfcNGEAQkMhnWaVPJv/du9jz4EM3LVpB07tnYK6uIO+M0Gr/6OmjepjSbyb3ztj61NT9GrtPhc7mQKlUkzz8fv8tF29p11LwT6NaJP+N0pEolUqUShTkS0+BB7Lztzj4Fwh0bN5Fz6824OzshIhA+2FMamiYuVauJnTWT4kcfR5OYQNoVl+Ht7aV9/Q/suO0udOnppF2+AL/XS8PnXxI9YTyCz0/UqJGU/ev5YJuz3+VCpu5/qUGqVCJ4Ateh5v0P0WVmII848lP0P8bvFxAQQrxC+gl8D6JWyfj7deMxaBW4vX5Wba1lzqQM6lvtnDE+Db1WwbtLS3jug+1EqOWcOTmDAelRYUUKBDpo1Eo5GQnGQD7OhqrgLEOiVcftF4/g+Q93BEP62m1O3l0WmMm6/8oxR1ykQGBGJTnWwPpdjZTXdvGXV9YzKCOa+OgIuuxu/rukiFH5gSXWcYPiwqYn7+fDb0vITDIGu338vV10b1/e7/E9ReswWw6dgP1bc+T/D4j8ItRqBbPmDOC1ehstzT2oVDLmXjiM7i4nvT1uYuINyBVSSvY0M2p8Gt8tK8Xl9KLTh5/GHDM5na8+2tUn88bn9fPVx7uZf+VIbJ1OvF4/lWUtbFpbzdjJ6eiNKlqbe0Ks5LPzY9hxiA9MYGYlhs3rq9AZVHS09ZKdb6XkRw635ugIho1KorOtN0SkHMzmdVUsWDiOCJ0ShVLO2hVl9HQ7+xUqEJh9kskkdNucSJAwbFQSDTVdfPredk4+PY+fuqVKJBLaWuwIfiHEMv/HFG5vYPLMHEp2N2Eya8nMtfLOvzcgk8tISjPj8/pRa4/8R1EQBJwNDVS88h96yg5EFHi7e6j89yIkUilR48firK6h5B9P4WppIeO6q1HFxNC1cxddO0OLFaVKJSnzzw/7XJ6eHhR6PdX/fSvkcYLPR9PSZQh+P3l330Ht+x/S9oMWfWYG3p4ecm+/Fb/bhTI6GpUlGqXZfFi5JLrMTDq3bmPviy8f2CiRkHzRfDSJCQAoIyPJuOYq6j79DAQBfU42lqlTUBj0OOobaPpmGc6WVjydnVT837/J+uONdJeWBYIAHQ4iRxSQMGc29qpqMv9wA8pIE1VvvEn7+h+CT2nbs4edd97DgAfuQxkVheDzIlEocDY1hXix9JSWkTjv7H4zgKInTaTth8BSlrulFb/bA0eRTrHZXTS22bHZPXh9firqujAb1QzJtDB2YBwfhJnZABg7MBavT8DudKNUyEiLM9Da5UCpkNHUbmdotoXTxqczblA8bo8PhVwatt7iYGRSCSeNSObel75nZH4sj9wwAbfHj0IupdfpJUKjCNuiO2V4ApmJR0+K8NSCJD78thSfXwj8QCtrZUdZYKl04TlD+GhlQDRnJJoorans9zxtNhdujx/Nfl0nCAje/o0n/c5DZ8X9Hhz5u6PIL8YcHcHlN46jvc1O4c4mais7mH56LvYeF9+vKEeplDGoIAFrrJ4N31dQuLOBU+YO7CMIALQ6ZTCt+MfYu110dTp5b9EmIqO0zLu0gKmzsnE5fVSUtWGx6kJmcmQyKZ5D2FwH2oilKBQy3C4vyz4rZMaZA8gdHMeebQF7+gFD40lMi8Tj9vabPgzg9fjpbO9l8TvbUanlnHHukD6Oj2HH4PHhcnqJSzBi73bh8fq45NoxVJa3sXZFOROnZ1FWFL42IndQLGWFzRSMTcbn73/Zyi8IaCMC4YWWOD2fvbs9UKMjkyCXSZk8Iztse/jvjaejA09XV4hIOZiad97DOGQQu//yIH5nYBao/vMvSb30YkqefKqPTX3alZchUYR/XX6HA1WMtY+42U/LylXEnHwSkSNH0FtVhTIyEtueIlpWrEIdH8eAv94PAng6O5GqVD9peKY0Gkg+/1xiZ87Atns3yGQYB+SjMJmCj5VIpahjY7CXV5Cx8Fo8HZ3Uvv8B7vYOItJSSbnoAlRWK0VvvYPP4aTokccxDBxAwtzZSJVKuotLsVdV0bl1G107d5Nx9RV0btuOafgwpHIZ3cUlgTZmv5+Kfy8i7pSZ1H74EcnzL8BWGDobJ/h8tK/fQNJ586h59/2QfZrEBKLGjqHo4UeBQGeU7AgV1IbDZnfx3rISBmVG8+7SkqAhm0Yl59aLCnC6fUwZnsDKLaGusnqtgpljUnn4tY3celEB97+8jj9fWMA3G6ooqmpn1r4MGplU8rMzeSyRGh68dhybC5v5z2e7UchknD4hjdxUM2aDmoXnDOasKZms2FyDRALTRiQRGxXxq7u0dnQ7aWi1s7OsFZNexeBMC2ajGtWP2re9Xj9yeej9yxqp4d4rRvPYG5uChcFSqYQzJ2Vgs7tpaLWTkxJJXLSWzCRTvx43A9LNaNUHvvolKg3q1ME4K8MknwMROaN/yUv+VRCFynGCMVKLRCJhb/Eupp+Rz9v/3hgyK1Je3MLYyelc++fJ9NicqFRyJpyUyZrloVPXip+wiPb7/PtqYrz02t0s+WR30C9FpZZz5gVDg8fWVLaTnR/Duua+LcQQWM5Jz46mYEwyfr8QWGNdVspZFw8nMcWEvcfNpnVVfPnRToaPSSZ3UP/GVnLFgQ+1y+nlk7e3cs0tkw75Wrq7nGzfVMPG76uC3T0jxiXT3tbLmuXlqFSB4MWktMg+y1fm6Agycy28/sJ6inY1cspZA9mzLfyyVd7AWFxOL8W7G1mx5IAT7qBhCej0Koymo8ey2lEb3pIcArbzvl5HUKRAoIW58etvyLv7DlrXrqO3ohJ1bCzWk09CplJR+/6HpF15eZ/0Xltx6SGXNgSfD09nJ5HDh1H73gco9HpU0VFYJk/EkJdL2bPP425rQ5eZQczJ05Hpdaithw4/lOt0yHW6sJ4u7o7OQH2NJJD23LJqNa3ffR/cb99bQcmTT5N9y02orBY8XYEvAduu3dh2HXBulioVeDq7UEWZQSoj64830rl1G36Ph9TLFuBzOKhc9Bq9lVVokhLxdvfgam8Pmy7dtHQZsbNmkH/f3XTu3I2nvR3DgHykKiWlTz2N4PUikclIOHvuIa/l701TWy8tnQ427mkKcY295NQ83v6mmPLaTh68dhxDsq0s31hNT6+HwZnRDM+18vInO8lKMlFS3UFnj4tuh5tZY1J45dPdv6gYFcBi0jJrbCoThiQglRISBGjSqzHp1UFjuV+brh4XTpeXx/67OcTRVyqVcPvFIyjItSKXy2hp7+W77XUUVXWQEqNn2shkrJEalIpA59PAjCie+tNkWrucuNw+YiI1dPa4uOuFtQDMmZTBY69v4paLRrBycy2uH/1QVMqlnDEhIyTGQKbWETX9UuoW3Q6+0B8bqqRcFOb+a6V+L0ShcpwxcHgCa5aV9lm6gYAnybAxySTsix4fPSmNgcMTqCpvRRAgNSMKv19AoZSFfbxcLg1MsQow4aRA18zBpm4up5eudgfJ6Waq97ZTUdbG9NPz2Lm5ro+Da2SUloRkE+boCARBoKneRnK6mcEFiXz+3g7aW0OnGzevqyZvcByRUdqwyz9DRiRRuOOAZ4nX46euqpOofjqTum1O3nttE3UHFcoW72qkvLiZBQvH4fX4mDg9i0/e3saYKenkD45nz456/D6BrHwrMXEGPO7ALIqt04nP6yclw9yn9idCp2Tg8AT++/IP+A/KRckfEofb5eXDxbtYcMN4FMojP6OCTIYyqv+8JYlMBr6+74uu7Tuw7d6DedQIMhZeh8JopGXlKmreeQ+pSkXS+ef2ESoSmRRZP91AB46R47HZ8LtcaJKSMAwaSG9VNXse+FvwGEdtHa1r1pJ9y59wt7QROWxIYJyHic/ppLuklL0vv4KjphaJQs6Av9wXIlIOpnLRa6RecRkljz8Zdn9Eaiodm7YQP3c2HZs20/TN0uC+lhUrMeTnk3njQkqfegZ1jBWV1cqevz7EoL/9haavvu5zvsYl36BNTyN5/nm429oof/EVurZtA0AdH0fmwuuOiDPtoVi6oZpxg+N59r1twW1qpYxIvTooXP6+aAN3XzaKUfmx2B0eymo7+WzNXvJSzcydksljbwS6qtq7nNQ02rhrwaif1c57KHSHGfj6a7D/tW0uaqLX2Td2wO8XePSNTbxw+zS67W7ueXEtzn333g27G/loZRn3XjGawZnRtHY6Wb21lvz0KLYUNpFg1RFtVKNWBkIIP15Zjl8QsPV6eOebYm69uIC3vi5m776ZldQ4A9efM4SYMIJPGZ1I4uWP07byLZwV25GqIzCMPBX9oCnIdabf/Dr9FKJQOY5QaxQkpZpZuaRvS+N+qve2EW0NfHlH6FRE6FRY92VNbNtYTeH2RiaelBmSgbOfsVPS2bE58Is7NsEQdilm+ReFzJk/lPTsaFqb7ezaVs+ZFwyhcEcjxbsakUgl5A+OIyPXypcf7uS8y0bg9wu8//pmZs0ZiN/v7yNS9vP5Bzs499IRLH5nO031AR8BiQQGDI0nKS2SxW9vCzm+/SBB4/P5cLt8yBVSFAo5LY3dISJlP16Pn9VLSxk1IQ2DUU1zYzefvrOdaKuOrHwrEomE0j3NrFxSwpz5Q4Oi7pO3tnH5H8ZTUdrKrq31uN1eMnOsDB6RgMvp46RTcykrakGhlJE3KBZHr4eP395GXILxkOvrvydKo5GI1BTkOh3enr6uwlETx+PtDb8sKHi99FZV46itw+d0Uvv+h/jdbhQmIxJJ39enS0vD092NNjmJ3uqaPvtNw4ZiKywMLGtEaIkcPhTB56f40SfCPnf1W+8Qd8pM3O0dqCyHLq49GPveCnbf90CwcFZhMGCvqOz3eHd7B6p+xJzSHInKasXn6EWh14eIlP3Y9uzBNGwI8WeeQfumLeTdfTuOunpcbe2kXr6Ayv+8GnJ85MgRaOLjaV62HF1ONhnXXoXg9YAAcr0OZZiZmCONw+VFLpWG2MVbIrXUHBQDYXd6eejVjZwzLYuclEgSY3TMn5nLtpIWHv/vpmDrbUqsfl/rs0BrZ+C9p1LI0B/KiuEowe8X2FLczGNvbOLPFxbw7Pvb+j1uc1EzW4ubgyJlPz6/wONvbOKJP07iz0+v5p7LR+Nwe2ntclDd3I1OqyTapCE1zsh9V4wOLgkVVrbz0sc7OXVcGudND8RINLTZiVDL+ywpQeBHgdKajPXMP+B39SKRSJFFGJFIf14I42+FKFSOI5QqORFhciMOh26bk1Vfl9LV4SA6Rsfs84ewcU0lrc09mKMjGD8tA3u3i8IdZQFb+zAzLhBYW/3g9S1cffNE8gZLWfFVMWu/LSdnYCyTZ2bj90N5UTPv/HsDCqUcn1/AYXcHumY+3cOoian9jrGzzUFXp5OzLxpGR1svMoUMweenpLCZxe9s7+PinpRqwuf109nRy+a1VVRXdGA0a5g2K4fdh+jmKStsZsJJmdg6DyxxtDb30Noc+uXt9wnBQk6pTEpzQzfbN9WSOzAWmUxKXU0HPTYXb/97I9Y4PSfPzqOipJVlXxQFQwjHTUs/tP/N74zSEk3uXbdT9PdHQ8SKLieb5HPPwdPTg0yjxufo26kUd/qpeHt7UBKNf1+9Stypp6Aw9S1IlJuM9FRVkXXzHyn5x9M4ag6IFX1uDnGnnULr2vV0F5cw8KEHUVmttH2/NrxVP+CoqUFpjsTT1XXYQsVjs1Hxn1dDzul3u5FpDv3LXabRkPmHG6h89fVgxIA+P4+sG6/HY+smcviw8L4y+2hZuZrsW25i5533UP/xYuJOPxV9dhaK7CyGPvMktt2FeO09aJOTcdTWsecvDyJ4vcgiIsi++Y/IDQb0WZmHVUR8JJgyPJGqRhspsXqq9v2YsTs8mH50b7I7PLz2RcBmQK2U8acLhvPGVwdqdWLMWtw+P9c8vAwBGJ5j5YyJ6azcXMPpEwJJv4cyljvStNucvPxJoANSJpP0yfk5mP1RAuGwO73UNfcwbWQSuyva+O9XRYweEMusMal8tbaS8rouooxqZo5JIS3eGPSnaulwBK8vgCFCyaShCYccs0ylRaY6svYI4Th6/y+L/E/odCoSU0xhvT8AktPD/xr0+4RgEe26lXsxmTUMHZXEKFMqti4nTfW24CzGxJOz8B6iSFYildDV6eDbL4sZOjKRop2NFO5ooPBHuSBJqZG0NHYTsc/QrKvTgfoQjrJyuRS5XILH4yNCr8LnE+jsdrJxTWWfY01mLQajhoqyVt5btCloPV1f0xnIAjmEOFAoZfh9gQJYvUFNt63vl7JUJkGrUwZDGYeOTKRwZwPNDd00NwRe06lnDwrWAAkC9PZ4WLviQL3O0FFJJKf1v9RyJFDodOizsxj8+CM4Ghpwt7cTkZqCVKWmt74BV3ML+ffdQ8k/nw4asEmVSuJnn47P6SQiLQ2pQo42OQmJXE70pIlIflTULPj9uFpaaVm+Ao/NRvbNf8DV2oa3y4bCaKS3pob6z74g47qrkSpVgXoPgDAzMyFIJHAYBdT78btcfdqLvd09yHU6pCpVIOfnR+gH5KGMMmNNSsQ0ZDDenh4kCgUKgx6FXo9c303k6FE0L+2/3dPncASXtPwuF9Vvvh3cN/TpfxA1bixlzz1P7fsfhYzBZ7dT8coiEs+ZiyrK3O/MzpEmLd7ANxuqmHdSNk+8GfDyaLc5MepU/ZqujRkUx+aiAx5EOcmRXHRKHv98ewsmvZpTxqWSHKPH7fEzd0oWj7z2A388v4AB/dzPjgZ6HG469/0gaWrv7ddRFmBgRjRfr6/q91y9Ti+j8mO596V1JMfomTg0gb/95wf8AkglEBulZVNhExEaBXMmZQQ7gA7myjMHYg4TDHksIAqV4wytTsmpZw9m0b++71NnMnF6Jrp+Zlxkcinm6IjgsktnuyNkCenUswdSVthCTLyBxjob3V1O0rOjw2YLDS5IYG9xCy2N3URGRaA39vUKkUgljJqQykf/3cp5lxWgM6josbnwuH391qEMHZVIlEVHV4cjIBQiVJgi1cw+bwjLPi8MGt2lZ1s4eXYeLpeHop0NwRwSCOQb5Q+JQyKVsn51RdhrMXBYAutWlZOZZ+XUcwby7qJNfTqVx0/NZOe+roWYeAOjJqYBgfZumUyKy+lh5ZJiOtsdTJyeybDRyfh8fk6ZOxCvz0dGtgWdQX1UzabsR6pQoImPQ3NQ7YOzuYW9L/8fubffhkSpJPfO23C3deB3u5DI5diKitGnpCD4/VS//S6ZN1yHXG/A73TStWs3Mq0WpcmE0hyJu72d+k8/R6pU0F1YRMkTT5F43tnINJp9lvwJyLRaHI3NyFVK5LoIZCoVERlpASESpsMqIi0NV2sbuqzMn/FCpcj1OrzdoTNl9Z9+Tsa1V1H2rxcQDqrJUZhMZC28Pmgup4qOQhUd+kWp0OuJHD4MX4+dzq3bwj5t5IjhyLV9vzB0mZkoTJG4O9pDnG8PxtnQgFyvx2PrPmqFitmo4eo5gyiuaufPFxbw7rISapq6+XhlKbddPILH3tgUIlayk0xcckoePr/AKePSUCmkNLY7ePy/m4gxa7lgRg5vf1PMm0sCJnrpCUauOWsIyzZUkWjV/eqdOb8W8oOWdJesq+SiU/J44kcmbBCoHbFGaoiN0pJg0dHQaqez54BAlUklWCI1wTyj08an8d8lhfgFGDMwMLOyo7yV9i4nbV1OZo5JISVOzwffltHc3ktyrJ4Fp+WTkWhC9hMhs0crEkHoZy71GMFms2E0Gunq6sJwhEO6jhb8Pj+dHQ42ra2ksqwNnV7FuKkZWOMMh/xi3LO9ng9e39Jnu1qj4Ko/TQACLcXvvboZW5eDsy8azo7NdRTtbAi22w4ZkciYyem8/OR3+Lx+jJEaTp83iI1rKiktbEYQAvUtE6dnsW1DDaWFzSQkG5kwPYv3Xt2MTqdi9vmDWfZZIU0N+9a0JTBoeAKTZ2Tz0X+3UF8TKA7bX58yeVY2EgIzLRKgpqqDlUuKEfwwqCCB1MwoPnlrG26Xl/lXjeK9VzczYlwKEomEtStCW3GjrTpmnJlPTUU7URYdJXuaGFyQyJb1VTQ1dGM0a5gwLRO/X2BvcQvZA2KwxOrR/6jQz+3y4nR4QCIhQqc8aupQ/lcEnw/bnkJKnn6W9KuvRKY3oNRH4O2x43e78bs9SBQK6t7/gK7dexj+3DNUv/UOrd+tCZ5DHRdH3t13IPh87LrnPtKvvoqSf/wzuF+mUSPTavF02YiffToynQ5dehoKgwFdRjo+p5OmpcupeOU/IWOTKpXk3HozMr0eQ27OYS+JCD4ftR98RPVb7/TZZyoYTtqCS2jfvAVnXT3GQQPR5+eitlgO69w95XspfuwJnI1NIdtlWi15d9+BXK9n2x9vDi47GQbkk3XTjaitVrqLS9hx2539njvn9j+jjolBl5F+WGM5Uvj9ArZeNy6XF59fQC6XYtAqsdndVDR00dblJCPBRIxZE2LpbrO7uO+ldVTUd/HANeMoqmgjIzESt8dHj8PNV+sqqW7s5p7LRxMXHUHcz7Dv/yXYHR48Xh9ataLfNOiDsdldPPDKD8EC2snDEhiZH8t7y0uobuxGKZcyYWgC00cmE21Ss7O8jerGbtLiDUglEraWNJMcayA1zoBCJkFAgsvjxRih4tZnv2NYjoXxg+N5/oPtIUnJZoOaRxZOQKWQ4hdAqZBhOAp/EMHhf3+LQuU4xucLeITI5bJ+c28OptfuZufmWr79qjg4GxNljeCciwuwxumRSCTYOh08+/AKfF4/MrmU4aMD7q4+nx+pTEp3pwNrnIHXnl8XPK9SJWfIiERyB8UiCAJqtYJP3tlGa3MPmTkWsgfEkpQaidfrZ9P3lXR1OigYm0JklBanw4PP60eukLHkk10hhnL7GTY6CWOkluwBMfzn6TV9EkZjEwyMnJBK4fYGzBYdG74LzKRcduM4emwuSgubcTm95AwMiI6u9l40WiXNjd3UVLQTm2gkb1AsUpkUlUp+yOWp4xm/14urtZWu3YXIFHJK/vEU2pRk1DExuDs76SkJmHhFTxiPItJEw2d9E4+VZjP5D9zLthv/RMrFF2KvrAoRMwARaakkX3gBRY88jtJsJmPhtegy0lHo9Xjtdnpr66j/ZDGu1jb0WZlYJk9CbjCgjDIjUx7eDdnT1YXgF4K2+V3bth/YKZWSc8ufiBxZ0Kdb6XDprW/A19ND0zfLaP1+LX6PB/OIAmJmnkzlq68TP/sMjIMG4unqQqbRoDAagjM1zsYmtiz8Qx9fGtgnym67hYjU1J9VNHws0ev08PdXNzB6QCyDsyyUVnfi9fmJMqr5YXcjmYkmymo7cXv8XHpqHlG/cWBnV4+L0ppOPvy2lM4eF4MyAknPMWZtyKxJOGqaurnz+TV09QRme+OiIzh1XCoD0qOw9bhZv7uBU8elUV7bSWNbLys216CQy7j+7MFsLGzih92NqJUyTh2XhlGn5In/bg4EN762kXsvH83Dr20MmTHez9BsCxefkkuUUUPUUbzcIwoVkf8Jn9dHt81Fr92NXC5Fq1OFLBf12t28/cqGsCnHALPmDqCqvC2kVXg/J52Wy64tdcTEG0AS6P6pKG1l17Z6PG4fGTkWxkxKo6Guk8a6bgaPSOCNF9Yjk0mZM38YH7zed9oUAstWF10zmrXflvcbbDj7vCF0tNmp2ttO9b7Mo3MuKeDz93aQnGFGoZBRX9MZsuR04dWjyMixHu6lO6FwNjWz9YY/4nf3dbTMf+A+ih56JOw+gAF/vZ/iJ/6Jt6eHlAsvQBVjpf2HjfjdbkzDh2IaNIjemlpkEVrkEVr8PgF1rBXlQXk+PpcLv9MFCjkylQrpYbYku9oDyyoNXy5B8HqImjQB69Qp+Lp76NqzB4VOjz4/F2Vk5P8sUiCwVLbnwYfQJiRgHjUCiUxO1+7dtKz6Dr/TiWHgAPLuvjPsEpDP6aL2gw+pff/DPvsS5p5J5IgCDHm5P6sN+1ijtKaD7aUtvPFVUTC4VCaVMH9mLm02J7kpkazYVMNN5w/7Tesueno9vLO0iMWrQ72gVAoZj944gYwE00+eo7mjl13lbewobSHGrCUnxczi1eXkpEQyJMvC298UU9Vgw2rWcsrYQEHsfS+vC1r672dAehSThibQ6/LgdHmJi9bx1Dt9k573c9eCUbz5dSF/uXLszzbI+7043O9vsUZFJASZPBCK118wnjZCyUmn5fL6C327GjRaBakZUSz5eHfffREKomN0NDV0YzBpGD0pjW8W7wlpcS7c0UB5cQvzLi2gcHsjcpkUQQBNhBJbV/i2WAjY+0skEspLwjvIAlSWtTJ4RCKdB7nuluxuJGuAlZ2b+5qcyRXSfj1YREAZZSb37jsofPDvIb/8NQnxKI3GfkUKBGYMEuaeSdVrb1D1xpvI9TpMQwYH3VUr/r2Ijs2BJUiV1ULmDdfjae9AplIFZ0xkKtXPFhKu9naKHnk8JJG49u33aFryDYMffZiE2Wf8rPMdColMhkQipW3detrW9f2sSOVyJP3UC8jUKuLPOA2V1ULNu+/jbm1DZbEQP2c2psGDUFqijyuR0mFz4vMLKBXSYF6P0+XjtS9C3Xp9foE3virkzktH8tGKUk4dn476MGaKf9HYup19RAqAy+PjhQ92cOWZA4kyqrFE9t8pY43UMm2ElmkjkvB6fTR3ODhrSgYd3S7ueO7AbGJnj4uS6g7Om57NsBwrq7YE4kekEtBplZTVdHL21CxUSilFVR109/b/GYPA0ltVQzefrCrj0tPyQ0zejjVEoSLys4mNNzL7/CEs/7wQ+74pzdgEA9NOyWXnljrOuWQ4Xy/eEyygTUg2MXlGNl9/GhAwWflWOtsdYX1Y3C4v2zfWMHlWDj3dLhRKGQ67G8MhfjXJZFLkcilKpTxQFxIGrU6FBBg5PpXSPc04HR52b2tg3qUFtDX3BOteIND1M//KUX3qTkQOIJXLMQ7IZ/hzz9C1axeu5hYM+XlokpMQvD5kGk0wSfnHyLRafE4naVdeTsMXX+FsasJeVUPSvLOwV1UHRQqAq7mF0meeI+XiC5HIZGgTD91eeSh6yveGiJT9eDo6afjiK1Iuno/X3ou7vR1XSwtKc6CzRmn+eV4l7vZ2Gpd8TfT4sVRXhe/kiD31FGTq/t9fCqOR2BknEzmiAL/LjUQiQW4yIj/EY441OrtdbCps5L1lpbR0OkhPMHLZ6fkkWnV88G3/XlArt9SSGGMgPd4Q4i77W7CzvG+zwH6KqzvQqOQs+mwXF586gLjon66Vkctl+AUBfYSSJ97sWw8I8MG3pdx92Si+317POSdlkZ1koqXTQZRRTWyUlpWbqlnyQzU3nT+s3+eJMWux2QMFuV+vr2LO5MyjdlblcBCFisjPxuf3U1HSwvQz8lEopEhlUlqbevjsvR1025wMH5PExdeOoaWxG4lUQlO9jcXvbsfe7UJvVJOebWHZ532ThvdTVtRCamYUe0taGTk+lbUrynH0uomyRtDW3NcMblBBAq1NPQwfk9ynOHY/GTkWlnyyh8goDfMWFLBjUy3bN9by0ZtbOOm0PKbMyqG1qQeDSU18kgm98dBBZyKB7iB1bAzq2NDYeE+PndhTZ1H34cd9HqOOi8PvdFL5n1fRpqQQd+oslGYz7o4OZBpt2Me4W1uRyKR0FxejjrEi7Sc/KBzuzk7cbe04m5qQKhRk3nA91e+8GxIACND63RpiT5lByRNP0VN2oLVTHRdH/n13oYk/PBtxb28vFYteo3X1mkAtSXoa9r2h3WXGoUPQZx9ed5LK/NtYuh9p7A43b39TxJdrK4PbSqo7uPP577njkhFoDiFAWjsdFOTqcbh9NLf3/mJr/UMh/YnCbJfHx8Wn5tPT66a1U/qTYqClo5eiynZioyJCOnsOxucXsNnd3HZRAV//UMU73xww3zTpVdwyfzj56dF4/X7GDYpj7c6+0R0XzMjhk1WBe6HT7eMYr/AQhYrIz2d/avDOLdvC7m9rthOhU+KN0vL14t1UlbcjlUrIHxLHyPGpNDXYUKn7f+spVTK8Xj97tjdw4dWj8fn8rFleymnnDObbL4torNvnRSCB/MFxZOfHIJFAcrqZsqJmmhtCZ2rGTcugrKiZlqZuWpq6KdnTzJwLhpIzIBa/z09sopEInZLMXLEe5dfA221Dk5BA/OwzaPjyq+DSkD43h6Tzz6X0qWcB6K2qouLfi4KPy7vv7n7P6enswtNlw+/xHrZQcba0UPTI49gPCllUxcSQecP1gVoRtxt7eTnOxiYkMhk9ZeUhIgUC7cCFf3uEgQ89cFgusJ7OLlrXBHJXyv71AunXXIm3x07Hxk1IZDJiZp6MLjMDqVKFIAhHrWnbb01ntztEpBzMy5/s4o/nD+X7fkwZ0xOMJMboeHNJEekJRs6emonPL6BWyn71GZaBGf23gA9Mj6Kosh2FQkpXj5vvttXx5wsLSI0zhP3/2thm55sfqli9tY6rzhx4yOeNUCvYXtrC5qJmRubFMHl4IjKZBEGAbzfVMGpALMVV7Zw6Po20BCNfr6+k3eYiK9HEnCkZbNjdGPRsGZQR9Zsvkf3WHNujFzkiaCOUjBiXyqfvbg+7f+SEVDRaJRqtknMXjMDp9CIhUMMikUiQy6XoDWq2b6wN+/ghI5Io2hkoxn3vtU1cet0YUjOi8HkFzjh3MCDBvu/XSFV5GwICK74qwdbpYNacAfj8ApVlbahUMjJzrej0Kv79TGh2y1cf72L2eUPo7XVjPowpW5HDx+9yo46xoklOInrieNxtbUhkMhQmE3v++hDe7vAp2FKFIuwMBIDKEo1EqUB6mOvs3p4eyp57MUSkALiamtj78iukXXk5zctXkHT+ucj1Bnqrq+mtrSPn9lsBAalcTk/5Xhq++ApHXR3ujs7DEipeuz3o8+Lr7aX0n8+gSYjHOGggpoIC5BFaKha9jqetjahxYzGPGXXYLc/HE1WN4Y3PIGAOp9cqkUkl+PyhMwEKuZSpwxPRRyjJS+0hwaLj4Vc30LjPUG3+zFySYvRofqUvZr1WwdlTM/lwRaiA1arlnD0ti9e+2MPJo5LJSDDy5pIi7nxuDU/fMrVPnk5bl4NHXt9IeW1gibm500F8dAT1YeJCNCo5MWYtyzZVs/CcITS02Xn+w+30Or2olTJOHpVCjFnLvxfvZnCmha1FTcyblk12ciTbSlt4ZfEu2vYtu8ukEhacPgDtMS5UxLltkf+JjBwLCSl9b9ypWVEkHZRAqtEqidxXnKtSK1Cq5EhlUszR2rB2+XGJBvIGx1JZFpia97h8vLtoc8CFtiOQarxlfTUqlRy/XyAyOgK1WkFLYzcup5fF72xn9TcleNw+OtsdfPjGFupru/oY3bn2ZWKcqL9of0vkOh3IZPSWl7Pj1jsoeuRxCh96BFdzS4iB2sFIVSr8Thfxs0/vs0+XmYG7vQNjfh7ujs6gPf+h8HTZ6OrHcM1Z34Dg8dK2bj2lTz1L5X8WETV2NBKZjNKnnqH40ScofOgROrdtJ/uWm1CazUGr/P34XC6cTc301tTiamkNvq5wBb6OunoMA/KR6yJw1NUROWQwCXPn0LVzFztvuwtnU1Ofxxzv/JSQkMuk/PnCgpC6j6QYPQ9cPZb6NjuFle3otUr+8dYWdle009blZHNRM7c8vZqtxc19BE447E4PTe29NLXb+7WvN0SoGJQZza0XFTB6QCw5KZGcOSmd2y4ewWtf7CE2KoLqpm5cHh8SScDufktRU5+W4fLarqBIAfhs9V4uO2MAKmWo8JZK4Ob5w1EqZIwfnEB5XRcfrSgLZvg43T4+W7OXz77by6njUymq6sDtFXj5k53IZBJ6et24PT6kEhicFc1dC0bx/rIS3lteQntXX4ftY4VjW2aJHDH0RjXnXlpAXXUnW9ZXIZFIKBibQlyS8bCKULURKiadnMXg4Yls+aEal9PD4BGJxMYb8fq8aLQKHL2Bm0d3l5MPXt9MtFXHuZcV4PMKfPXxLmoq2tHqVJx98fCQc9s6ndg6D7RHCwIQRo9IJBJSM49PL4ojiUyrQSqTUfPu+yHbG79ZSvL88/sYtgEknTePxiVfEz9nNlKlMtA1JJEQOXwYcbNPR6ZW07xiFQ2ff0nevXdhyMtFKu//9uXt7etsHLLf3oNMpcTncOKoq6fuw0+IPW0W6n1Os53bttP6/TrKn3+JlEsuCkmVdrW1Uf3Wu7SsXIXg9SLX60g6/1zMo0fTXVqGcchgurbvCB6fcM5ZuFrbKH3q2aCgkcjlpFw0H4XJSO0HH5F25RXIVEenKddvQYJFh0opC5t/k5MSiUYl58MVpcyemI7ZoEYuk9LZ4+L5D7ZT29zDowsn8MAr4fOUnv9wO9nJkf3WiwiCQG1zD//5bBebiwJ2BsNzrFwxeyAJFh3Sg7qxJBIJCRYd97y4liFZ0cRbIqhssPHpd3uRSiRcelo+j72xidEDYoORUbv2tpEcayBtX7Gv3y+wfGN1yBga2ux8sLyUOy8dyY6yVirrbSTG6Jg1JhVrpIbuXg+Thyfw135e48ottfzlyjFsL2tFKpVwwcwcNCo582fmMmV4EjXN3ZTWdPL0u1ux2d2s393I7r3t/PmiAkxHqZPvofjNhEplZSUPPvgg3377LY2NjcTHx3PRRRdx9913ozzIlGnHjh0sXLiQjRs3YrFYuPHGG7ntttt+q2GJ/IrojWpyB8WSkRsNSFAchlvjwWgjVGgjVMQnm0LW692t9Vx4URaff1EbrEfRRigZNz4WeXctfm08qZlRjByfisvppdvmJNqq6xMaCAH32sgoLT0214+eW4neoEJvOPY+tEc/EiRSKe72gCOnTKsl/swziBw+DIlSwYC/3k/thx/jqKlFHR9H7MwZdBeX0LF5C0kXnMvQZ57E292DRC5HIpPh9/lo+PQzWlasAqDwrw8x7F9PoY6JCfvsjrr6QAaPXB7WNA0CXTU+54H3RMvq77CeNJXmlavpKSnBPGYMeffcSfnzLyGRy1FEmgBwd3VR8o+nsO0+EPbm7e6h4v/+A0LA7Tbl4gvpHjsGuUaNTK1BZYmi/MX/C5lNErxeKl99ndw7b6P8+ZdIOu9cZKqj0xL/t8BsVHH7xSP426INQZ8UCATn/eG8YUSbNEwYksBLH+/s89jMRBMKuZTeMJlBAF09bmx2d79Cpam9l1ufWY3deeDxm4uaKaxczVN/mtKneyfGrOXuy0bx4kc7gjb2ybF6LpiRw6fflZOVZKKkpjN4vDVSy2tf7OHKMweSnRyYdVar+t4bi6s7eOCV9YwdGMclp+aRHKMP3kMVchnNHb14feFnhgQBehweBmdGkx5vpL61B4Vcit3p4dE3NlIb5l64vbSFlo5eUagcTFFREX6/n5deeonMzEx27drFVVddhd1u54knAlHtNpuNGTNmMH36dF588UV27tzJ5Zdfjslk4uqrr/6thibyK6NQ/PK30cFLMN3bluLZs4bZo+biN2fh9wso/HY8297Etr0NywV/Zf2qimAgoDk6gpNOy+Wj/27F96Mp1ymzcti9NdQnRSKVMPu8IUTF6A7LsVfk5yHXapAolUjVauQREeTdexeOmlpaVq5ColJiGDiQjOuuxu/2YN9bQdUbb+Jqbg44tJpMqC0WnLIWdt77FzQxVnwOBz0H1Zr43W66i4qDQsXv8eBu78BeUYGnqwul2Yzf48U6bSpN3yztMz7jkMGB8/0oNdlrt2PIy6Vr+w5aVqyka/t2MhZej6OmBoUu4KnjbmsPESn7iT1lJiqrhdY1a1HHx+Fpb6d1x06iJ04ACaRdeTmu5mZK//lMiGBpWbUa04gC+oRJHefIZTKGZFl4/rZprNlWR01TN4OzLAzJsgTrO6aPSsYvCLy/vBSHy4tUAqMGxDJrbCpd/XTM7Ke/bEqfz8/SDdUhImU/vU4vX/9QyUWz8kIcZyWSgHX9FbMH0uv00Ov00tTey+tfFBIbrWXO5AyefX8bKqUMn09gQHoUH64o5d2lxVw1ZyAquYw5kzPZVtKCSimns9sVzDoSBIi36Ig2qYMipbvXjcv908ubUUYN3XY3//50F2dMTMekV9PUZg8rUvazq7yNrKSf125/NPCb3aVnzZrFrFmzgn+np6dTXFzMCy+8EBQqb775Jm63m//85z8olUoGDBjAtm3bePLJJ0WhcoIi+P14O5vxdbfTu+rfwe37rY0kSjVyGcy9cCjvLdqEIEB7q52N31dy3hUjKNzeQF1VJwaTmrFTMoiM0uB2Byz4mxtsxMQbGTUhFVOU9mfPAIkcPnK9jpiTp2GZMpnmFSsxDRyIymLB09WFv6cHe2UVgtdHx5YtZFx/DWXPPEfyxfNRRkbi2Vdsm/2HhTjq6nG3t5N03rm0rFpF6+qAQZarJeBv4fN46Nqxk6KHH0PwHKgzMA0fFvBekctoXvYtfrcbiUxG1LgxRE+YEJIxBGAcHHDDFQ4KPPS53HQXF2MaPjS4zVHb1xwwavw4lFFRFP39UeLnzKZ11Wrkej0x06dR++EnOBsakKpUWE+ayoAH7mPPg38PpiK7WtuInVmATHfimQsqFTISLDrOOzkn7H6jTsXcKRlMHp5Ir9OLUiFFKZcCErw+f79JzDFmLQZt+GU0u9MTktL8YzYXNjN3cmZI0KHH68ft9vPAK2s5bUI6gzKiSE8w8sfzh9HS0YtUIuHiU/JQyGUkxehYsbGW2H35Q929HlYU1jIwPZqbzh9OXUsPhgglTreP/35ViCFCyYzRySxeVU6CVU9ijA6ny4fH46Ojx0VmoomK+i40Kjm9Lm9w9inBoiNCLeeu59cwNNvKSSOTkUklyGSSsEXI+zlaM39+it/152RXVxfmg3wB1q1bx6RJk0KWgmbOnMmjjz5KR0cHkWGq7F0uF66Dos9ttv6rx0WOPSRSKdrskdiLw6/NqhNzkaq0pGepuPbWyWxdX01LUw+JqZGYoyKYOWcAHrcPuUKKSnWgVfGUuQPxeHwoFFJkx7BD47GCKjKS+Dlz6K2qRpeeRtGjj4csw2hTksn644301tZT/tyL5N93N95eO+72DnyOXhq/XoZ9715U0dFETxhP+/r16NLT0WVnoUtPR24w4Gpvx+90UfTQI32KdDu3bCUiJTmQePynP4AgoI6JoWP7doof/0fIWCQKBfGzz8BRV0fHlm3EnXEakcOG4mprQ67XozSaEHy+QOfSviWgg7FOm0LhQ48gVamIHD6Mhi++wjJlMp7OTlIuuRCQ0PztChq/XIK9opKUi+YH27IjUlMxDh54XBm5/ZrIZTKsYVxfvV4/t1xYwN8X/RASyKeQS7llfkG/tvoKufSQX9aGCCUK+YHZFL9foLmjFwFQq+R8vLKMj1cGOoBuv2QE9S123l2+NSggCnItXHLqALKSTXT1uPD5BCYPS+SBV9aHdPjERUdw/5VjaGy38+7SEiYMTcDt8dLU1stT72zlpBFJCILAjecOpa3LQbvNiVGnoqmtlyXrK7nu7CH0ODw8edNkok2aoLAyRqgYPySB1Vv7dlTKpBIGpB+by4u/m1ApKyvj2WefDc6mADQ2NpKWlhZyXMy+6dzGxsawQuXhhx/mgQce+G0HK3JEUacMQKaLxNfTEbpDIsU89UJkai0ywBKjZ/oZ+fh8PuRyWXD5SKns+7aWyaXI5GKT2++JXKtBKpdT9q8X+tSK9FZVU/fxYhLnzqbkH0/RuXMXTd8sQ5+ThTIyksYvvgSgm4AZW+qCS9Dn5iL4vDR9vRRnUxORBcORqlT9dhI1LVtO6mULKH40cM9RWqIZ+Ne/4He4aF7+Ld7eXkyDBxJ7yixa1nxP9NgxJF8wD6lShbenB4XRiKupiZp33iXj2mvQZWWiiYtFbjAEu4CUZjOulhZSLrwAbUoKfp+P+NmnU/KPp3A1Bwo1pWo1iWfNQZucRN2HHxM/+wykajWCzxewyj8B25N/KXK5lKFZ0Tz752ksWVdBVVM3uclmThqZFFbY7EejUjB3ciZbi8PHbZw1JTPEi6Whzc4tT60i3qLjyjMH8vQ7W/H5BWLMWnqdXt5eesCMbVi2hUnDkvjzM6vxHBSMOjgzmhvOHco9L3wfFFUNrXae/3AHowfEsnxTDXKZhGkjk7nv5XVIpRJaOnu59LQB/OPNzVQd5OCdkWjk7stG0eNwk5vSV3SoVXIuPTWP0poOGg4SRlIJ3HrRCCKPUbftny1U7rjjDh599NFDHlNYWEhubm7w77q6OmbNmsW8efO46qqrfv4oD+LOO+/k5ptvDv5ts9lISkr6RecUObpQGC3EX/wgrctew1G2GQQ/SmsK0bOuQhEVaqEulUqQSsU6k6MSQcDRUB+yJHMwbevWE3faKQDYdu5Cl5FO87Jvybvnzj6FsIIEHPV1lD37fLC2RKpSoYmL7ffpvd09yDQHbszWaVNxd3aiz8/BNHwo3u5uHA2NOBsbMQ8fjtJiwbZjJ9Vvv4tvX9eQJimJ1AUXU/7SK+TdcSuqGCsDHriPpuXfoktNBZkUbVISNW+/S/Xb7zL48UfYeec9+J0HWkH9TifVb71D5g3Xo46Lo7eqCuPAASTOOxt1fJzYIv8/olLKSY7Vc8XsgXh8fhRyGbJ+8pMOJj3ByOnj0/j8+1C/nlPGppKZZAr+7XR5eevrYuxOL6U1nazaUsvjN05kxeYaUuMNLFlXGfL4Myam8/dXN/QpgN1R1kpGopFTx6VS3dRDS4eDhjY7JdUdnDs9C4DNRS2MyIthwWn5mA1qIjQKnn53a4hIgUCb87/e3868aVm025yYwwgPq1nLw9ePZ29dF1uLm7FEahk1IJZooxrVMbrc/bPv8LfccgsLFiw45DHp6enB/66vr2fq1KmMGzeOl19+OeS42NhYmn7kIbD/79jY8DcglUqF6hekmoocGyjMcVjP/AN+Rzf4/UhUWuQRxiM9LJGfgUyrxWfvv01Y8Hrx9QbygOR6XcAsDbDvrUATH0dvdU3w2MihQ9hx+90hBbCOujqix4/r9/zalBScjU0gkWCZNAFDfh5N3yylZcUq1PFxRA4bChIJndt3gF8g6fx5IU65AI6aGkr/+QxZf7yBzp07ibFMRapS4rXZqP/iSxLOOZvuomI6Nm9Bl5lB1/YdISLlYOo/+4KY6dNQWS1YT54ebIUW+WXIZNKfFXdh1KmYPyuXWWNT2VjYBILAiLwYokwa9AfVtvQ4PKzfecAdd3NRMxefmkdDm51hOVaaOw68t5Nj9VTU28J26aTGGRiYHo3N7sLnh9EDYrGatbz+ZWFw5iVCLcdqjuDdZaWU1XZy7+WjQ3xXDmb33jbOmpLJk29t4c8XFmDS9/0+jDJqiDJqGJnfv5A/lvjZQsVisWA5zKnKuro6pk6dSkFBAYsWLUL6o1LssWPHcvfdd+PxeFDss8VeunQpOTk5YZd9RE4sZCotMtVvl+Mh8tsikUgwDMjvd7/KasHVElgeMY8aScmTTwceJ5eHLOdI5HLcHV19BIC7tQ2ZRoPKag0usxxMysXz8bvd5N97Fx1bt2Ev30t3YWCq3lnfQEP9gYyU1AWXUPPeh2HH6e3poXdfEa2ztZXtN9+GedQIEs+ai9/lov7Tz4Ovp6e8b9Lufhx1daisVjRJif2KGZHfB71WiV6rJCXO0P9BksASk/ugZRyf18+mwmYSrXpS4gzsKA0Udes0irDZPfHREVxyah7/eHNzSKeRXqvglvkF6CMC33uDs6L54NuASJFIwO0Jv5y5H4/Xz/bSFpo7esMKleON32zRvq6ujilTppCcnMwTTzxBS0sLjY2NNDYeMOKaP38+SqWSK664gt27d/Puu+/y9NNPhyztiIiIHLuoLNHo83LD7kucdzaNS5aScNYcbLv3BDphJBK0KSk46g7KeZFIQPCHPUflolfJuP4azKNGBntSVVYLWTf/EVdzM2XPPs+evz5Ew2df4LXbURjDfzGprBYcNTVh9wE4amrRZWRQ99EnKCMjMY8YQck//olEAp6uwC9fV2sb6kMsRanj4tAkJdLwxVf9xgiIHD0YI5RMH5kcsk0uk2I2qPl2Uw2njTtQX1nfYicjoe+M71lTM3nhox192qG7ez383+JdqPbV040dFMf3OwLveUGgj2PtwUgloFQE3uvbSsLX2hxv/GZCZenSpZSVlbF8+XISExOJi4sL/tuP0Wjkm2++oaKigoKCAm655Rbuu+8+sTVZROQ4QfD5SJg7h5iZM5Du6+5Tx8WRdfMfkWm0pF9zJVKlKjgrkXrZJbR+913oOTwelGYzkjBhhO72Dspf/D9SLruUwY89TP7995B6+YLAbE5+PjLtge6Ptu/XYp02Jew4PZ1dqKz9h1KqYmNQRkXSsmIVsbNmUPtBYPbFXlmFPjfQXttTUopx0CCsJ0/HMnUySnPorHD86afQW12Du6UleC1Ejl4UchlnTs4Iye0prung/Bk5AbfXXQ3cMG8IJr0qOJuSYAltMzfqVLR0OMKev66lB4fTy4Sh8SjkshDjuz0V7YzIC29oOG5wfLAYWKf9dUMYj1Z+syrEBQsW/GQtC8DgwYP57kc3JhGR34Mumx2304/L6cXvE9BGKFAoZeh0KrGF+VdC8PkpfvRxzKNHkfmHhUhkMjxdNjq37cBZV0fkqJF4urqwTptC1PhxOBsaiTl5On6vF3tZOUqLhYQ5s/E6HKRdfil7X3ol9AkkEtIuu5SW1d9R+/a7IbuMgweSf989dBcV075xE3K9Dl1WJtaTptG8/NvQcfr9JJw1h70vhtbRAUiVSqJGj8JeUYlUpUJliQ7WzzR/u5KsP9xAd0kp6VdehqulGW9XF0glJF90IX6Xk8rX3yTu1Fl4umzULnqdrJv+gExsRz4msEYGClO3l7ayemstRZWBAtgbzx3Ke8tKqGuxc/kZA4jUqzDpVdxz+Sje+LKQ9bsbEQQhRHyEwy8IXHfWYHp6Pei1Crr3xYYsXl3OrReNQKOS8/2Oevx+AZlUwsShCYweEMs/3tqMRAJDs06MjjGJIAjHtCWizWbDaDTS1dWFwXCI9UYRkYNob+umo9XBFx/sorM9UBQnk0uZOD2TrDwr0QfZWYv873hs3ex58O/0lJSE3Z//l3tpW78BQ14OTV9/g21PEVK1mugJ49HExxGRmkr12+8SM30a0RPHY99bQc0HH+FqbEKblkLCnNkIfoFdd94T9vyJ556DwhyJITubpuUraP52BXGnzsKQl0t3aRkytRrT4EGBLxWPm9bVa2j8emkwAVluMJB98000fPEl+P2o42Ix5OVS+vS/AnlEQOSIApIvms/eF16iuzj0dZoKhpNy0XzqPvyI1jVrAQJZRQPykWvCe32IHJ043T5kUgkKuZSuHhed3S5cHh8qhQy9VoHZqMHvF2i3ObE7Pbg9PtRKOTc+sSKsAZtSLuXZP08l3qLD5/OzZH0lL350IDJALpNyytgUTh6dQtO+e9TGPU0s31iNzy/wx/OHMmFIAuowdgzHCof7/X3svkIRkf+R1nYbXa0uPnh9SzBFGQKFciuXlKA3qNFolZjMYiHvL0Vh0JNx7ZXsuP3uPm3K0RPHY9u9h6YlX2MeWUB3cSkQaOdtXrYcgIzrrkEdF4t51EjkERHoc3NIOm8egteLs6mZ5mXfBruFwtGyYhXxs0+n/MX/wzJxPH6Hg7oPP8Y+dAiJ555N8/KVVL3xJlKFAsukicTPmU3srBm4WlqRRUSgjIyk/rPP6di4CaRS8mbdTteePURPGE/ztyuAgK1+17btISJFolAQPWEc+uxsfA4Hnu4DtubyiAhRpByDqA+qGzHqVCHutfuRSiVEmzSYfCrqWnrYvbeVMydl8NE+k7iDOeekrGAekUwmZcKQBCRIePPrImx2NyDQ6/JiiAgU/pbVdgJw3snZTBiSQLRRc0yLlJ/DifEqRUQOosfmorGuK0SkHMya5WVERmlFofIroU1JYeg/n6D2g4/o2rUbhdGAddpUJBIJe1/5D3FnnE7n1m19jNukSiWG/DzMY0ahNJkC2xQKIlJTcLe1secvDxI9aQKCt/8OCcHnBamUnpIS0q+5An1uDo7aOuLOOJ3d9/016NXid7loWroMW2EhifPOpvy5F1FGR5F+9VUY8vNo/OIr8PspeeoZ0q+5Em1yEj3le+mtqsI8agQtqw8sX+vz80m7/FIal3xD3cefINfpiDvjNGKmT6P8xf8LSWIWOT6Ry6SkxBqwmDT0ODzERml5Z2kJ7TYnFpOGC2bkMGpALEpFqPiZOTaVUQNicLh8KORSTHpVUIxEmzSMGRjX31Me14hLPyInFH6/n8I9dZTvbmfbhv67PC65bgypmdG/48iOf3wuF+629sBMyIqVCB4PcaefitJkYte99+Nuaw8eK5HJyL37DkyDByENU0Tram1l89XXo4yKIvHsOZS/0Le2BCBm5sl4bd20rVtP+jVXIVWrUMdYqX3/Izq3bgPANHQIMSdPB6kEiVSG0hyJ4BfoLiwEiQTj4EE4GuopefyfQR8XbWoqGddfjc/hxO/xUPXafwPhhZGR5N19B7vuvi+Y57Mf89gxJM07G21KMlK5+BvxREIQBDpsLjw+P3KZhKh+LP5PNMSlHxGRMEilUpRqBVGWiH6PMZm1KA7RHijyvyFTqdDEx6GOjUGfk4VULg92vwx+7GG6S8ro2rEDdVwc5lEjUEZHhxUpADKdjqjxY2ldvQaJQokuMyMkYRlAYTIRNXYMhQ/+HaRSVFYLhQ/+nZzbbqFr5y4A4mefjtJspuy5F4JutOrYWNKvvZrWNd/Ts7cC09AhmMeMZtgLz9K87Fvw+TDk59GxZRuWyRNRWSz0FJdSW1ND6uWXUvXGm31ECkD7uvUkzj1TFCknIBKJBLNRLKD+XxE/MSInHEaTGolXilIlxx0mfXXi9EwMJvEXz2+FRCpFrg1dVlNFRwcCCMeNOaxzyNVqki84n85tO6j4v1fIvHEhjto6Wr77HsHjxjx6FJEjCugp30vO7X9GptaAJJCq7LXbkUdokarURKSnUfrUsyHndjY2UvzoY+Tddy9+Ry/tmzbTvnYdzro6zKNH0brme2o+/JiYk6bitXUjAQz5uSijzGgTE+navqPfcbdv3IQ+J/tnXzMRkRMZUaiInHAYjBp8HoGzLx7Olx/upGufz4FMLmXCSZmkZEShP0bDu04kNPFxDHniUVpWrqL2w4/RZWWRddMNyLRabHsKkUgkdGzYRNWePUDA0j9x3tkYBgwg5pRZSKVSGj7/Muy51fHx+Hq6KXr0iWAdS+e27TR88RU5t/8ZfW4OVa+9gbutnZzbb6Xi34vIXHgdEpk0YDznD29QJ5H1nanze724Wlrora7B291DRFoqCpMRlVjLIiICiEJF5ARErVBhjgaV2s35V47A7fTh9wtE6JVoNUq0Yar5RY5O1DFWEs85i9hTZiKRy4MzNTKFgp133Rdire/r7aXqtTeQyKRYJk/CUV1D7QcfhT1vwtwzKfvX831SnwWvl/LnXiTzhuvwewL7JBLwdHSw528PM/jxRzCPGkn7+h/Cntc8akTI3z63G9vuPRQ98niIrX7kyBGkX30F6kOY0ImInCiIQkXkhESlUKGKFAXJ8YBEJkPxo0K83rr6sPk/APWLP0OXlYUyKhJ1bExI+OF+lCYTni5b2Md7OjuRKpWkXbEAv9tN5/YdRI0bS+t3a2j46msSzzmL7qJiPJ2dIY+LO/1UZJrQ2ihXUzN7X34F67QpSKRSunbupreqio6Nm2hKSyF+7hwUWrH7TOTERhQqIiIixx32HxXWHoy7rR2JRILg8xN3+mmUP/9i34MkkkOe32vvpfSfzxCRnkby/AuQyOUY8nNRxyfg7uwg7+7b6diyDduu3cj1OqxTp6AwR9Lw5VekLrgYqVyOz+nE29NDwpln0Lp2PYLXi3XqZFQWC+UvvkTDF0sCjxOFisgJjihUREREjjvUcf37Tci0WlzNzfTW1hE9fhyJ582j7sOPg8s8cpMJuU6HVK0Om3Is06iBQJuyfW8FPkcvEpmcllXfET1xAvWLPyMiNYXY007BOGQwEqmUtrXrafxqCbrMDPxuN1K5HI/NRvXb74YU39p270GTlEjmDQspevhRhJ+wYBcROREQhYqIiMhxhy4rA5lGg8/RNxDOetJUWlavQabR0LpmLc6mRoY88Si9NbVIFXL8Ph9IJCSdN4+q197o8/ik886l6ZtlAJhHj8LZ2ET1m28DEJGehjYpkfYNG2nfsDHMuDKRqgJLjvbKqrAdQo6aWnpKS4mePLHf9mwRkRMJUaiIiIgcd6iiohjw1/vZ8+Df8doO1JqYx4wmZvpJOOrqUMfHs+PWOxA8HnTp6bStW093aRn4/Qx6/BGkCjnZt/yJxiVf46ivRxMfT+wpM7HtKQqaxVmnTaXkH/8Mnr9j81Zybr2Z2Fkz8Hu9CD4fzcu+pXPbdiRyObEzpiOVyfC53DQt+abf8beuXUf2TX9ALppYioiIQkVEROT4QyKTocvMYMiTj2HfW4Gno4OI9HSczc3suP0u/E4nObf/OZg/VPvBR2TfchM177yHz+Wiu7AIdWwM7T9sxDh4ECmXXET7+h+oeGXRgSJZqRTB5w2GEyqjzGRcdzWV/3kN2/6W6IgIEuaeiXHIYPQ52ahiYvaNUEDop4UZAL8fucGAXCO2yYuISI/0AERERER+CyRSKWqLBalSib2iiuZvV1Ly+JPBupODPU28PT0UP/FPIkeOIHPhdXRs3kLJE/9EplGjS09DqlDQsW17aCePICCRHriFpl56CeXPvRgUKQA+u53q/76FMtKEcUB+0JVWplIFbPv7IXryRNRWy690JUREjm3EGRUREZHjmojUFJBIKPzbwyHb3a1tqOPjcNY3AAdEhbO+AZlGjd/tpuHzL2n4/EtkEVqy//RH2n/YSMvq7/C7XOgy0lFZY5DrdUjkcvxuN66WlrBjqPrv2xiHDEZlNge36XNz0GVl0lMamqyrjI4mZvr0sOZwIiInIuKMioiIyHGNMjIShU4XXObZT90ni0m74nLkel3I9q7CQuJOmRWyzWfvpejhx/Da7Qx44D7y7r0L8+hRVL31NmlXXo4mLq6PH4si0oQ6Lg6JXI67tTW4RLQfVZSZ3DtvI+O6q4lIS0WTlEjyhfMZ/MjfxNkUEZGDEGdUREREjntkEdqAN8pBYfGu5hYqX32NzBuux+d00VtVRURaGvrcHKQqJZapU2hZsTJ4vODz4ensxNXcQsmTTx04uc9H8oUX4KirA8CQn0/8mWfg6ezE29ODJikRR0Nj2DBCVVQUsbNmEjV2LILgR6HXizMpIiI/QhQqIiIixz0KgxHz6JG0r98Qst1RU0vlotcZ9OhDWKdMCtmXcNaZmEeNoGPzVgSfF8ukicj1BnbddU/IcZ1bt+F1Osm68XpMBcOxTp5IyT/+GTKDYho2FMukCf2Pzyh294iI9Ie49CMiInLcI4/Qkn7lFejzckO2q2NjyL/vbpQmU5/HKAwGmletxjR4INqkJASgecUK0q66HE1CPDKNBqlSSczMk8m45krK/vUiKRdfSOkzz/VZ5uncuo3GJd8EPFpERER+FuKMioiIyAmByhJN7p234enoxNnUjNIciSrKjPKgAteDUZpMZF5zNY6GBry9vVT+51UkUimmwYNIv/pKfC4XquhoesrL8Tmc+HrtdG7d1ifIcD8Nn39B7IzpqKKjAXB3dOKor6d1zffIVCqiJ01EZYlGodf/ZtdARORYRBQqIiIiJwxKoxGl0RjoBDqc482RSBQK/C43MpWKxHnnUP78i3i6ugIHSCRYJk8iIi0NbWIi7tbWfs/ls/ci7JtRcbW3U/rUsyHOtHUfLybuzDNIOuesPiGLIiInMuLSj4iIiMiPcHd24Wpvx+dyIVOrUBj1JJ03j6YVK4mZeTLxZ56BymoFQaBl5So6t+9AZjIRkZbW7zk1CQlIlQH7/Pb1G8La5zcs/gzHvnZpERGRAOKMioiIyAmP3+tF8HjxOnrp3LKN+sWf4u3pwTh0CAlz5+CXSFFGRaGOjqb9h43IIyJIPHsugs/H3lf+Q/3iz8i66Ua83d2oY2NwNjb1eY7Uyy9FGWnC3dFBw+df9juWhi++RJeZEbZLSETkRET8JIiIiJyweB0O3G3ttH63BnVcHK1rvqdj46bg/pZvV9K2Zi2DHnmIhs+/pLe2lt7qahAEbHv2EDVuDMnzz6f6v28hU6spf/5Fsm++ifpPPqV902bw+1FGR5F2+QL0uYFCXp/Tic/R2/+YeuxwKHt9EZETDFGoiIiInJB47HbcLa10FxcjN+hRWS046urIuO5qFKZIBL8PkNC8bDk1771PzIyT0dTUkXrZpdQv/pT29RtoW7ue6IkT0SQlooqOZvCjDyNVq8j60x/w2mz4PV5kWg1KsxmJRBJ8buOgQbSsWh12XFFjRiNVKn+nqyAicvQjChUREZETBk93N86mZnrKygHY+9L/gd+PIT8fv9tD6oJLqPj3q7iaAks32uQkMq6/Fk9XF876BpQmA67GJixTJiH4/HRs3ETXzp2kXXk56hhryHPJtdrwgxDAMnUy7Rs24HM4Q3aprFb0uTm//gsXETmGEYWKiIjICYGnu5ua9z+k8fMvyb3rDgr/9vegU63g82LMz2PXfQ8EQwuV0VGkXr6A4sf/gbutPXgeldVK3l23k3r5pbg7OtAkJaGJj8PZ1IREoQjJ8wmHwqCndvGn5Nx+K41ffkXH5q1I5HKiJ4wneuL4gIuuiIhIEFGoiIiInBA4GxppWPwZxsGD6Ny2LcROH4kEW2FRUKQAJJ41l4r/+0+ISAFwNTdT+sy/sJ48nYxrr8ZeVcX2W27Ha7OhslpIvnA+kcOHoTCE90OR63QkzjmTPX/7O6bBg8m++Y/4vd6gYAlnPiciciIjtieLiIgc9wiCQOPXSwGQR0Tg6ewK2a80m+kpC00xVlmig/k9P8a+twJ1dBS7738AhV6P12YDAvlBpf98mpZVq/D3Y/wGoImLZeAD92EaOpju0jJ8TifJF56PIS9X7PYREfkRolARERE5/hEEfHY7AL3VNeizs0J2u9vbUcfGHtggkfSxwf8xfo8Hn70XV1MTmoT4kH3Vb76Du73jkI9XRUcTNXoUaZddStysmWhiY0WRIiISBlGoiIiIHPdIpFIs+0IHHXV1KKOjUUYdqCXpLipGn5t7oNtGEJCq1YHE5XDnk8mQKhSB8zU29bHh9zkceHu6f4NXIiJy4iEKFRERkRMCXVYm2n3W+RX/XkTmjQuJLBgO0sBtsOW778i7504URiMAnVu395t4bD1pGm0/bAycNyMdV2tbn2OkCrHFWETk10CcZxQRETkhUEVFkX/vXTR+s5SmJd9Q+vS/SL7wfFIWXILgdoNEgtygJ//+uwPLNoKAJjkJhdlM41df43c6kWm1xMyYjjYxgbLnXkSu0xGRno6zIdT2XpeZIeb1iIj8SohCRURE5IRBFR1N0nnnEjtzJgh+ZDodcrU65BghOhpllA0QkOt0RE+YQNSY0QgeD+7OLlpXr6Z+8WeoY2NJv/py3O2hXUGKSBNZN/8RhVEUKiIivwYSQTi4R+/Yw2azYTQa6erqwiD+ghEREfmVcbW1sfOOu9Hn5BA9cTyC14tELsfd1o7fLxA1dhS2nbtx1NSgy8pEl5GByhJ9pIctInLUc7jf36JQEREREfkJHPUNFD/2D+wVFQBI5HLiTp1FwtlzRd8TEZH/kcP9/haXfkRERER+Ak18HPkP3Iuny4bf5UKh16EwRSJTq4700EREjntEoSIiIiJyGCiNRpT7OoJERER+P8T2ZBEREREREZGjFlGoiIiIiIiIiBy1iEJFRERERERE5KhFFCoiIiIiIiIiRy2iUBERERERERE5ahGFioiIiIiIiMhRiyhURERERERERI5aRKEiIiIiIiIictQiChURERERERGRoxZRqIiIiIiIiIgctRzzFvr7MxVtNtsRHomIiIiIiIjI4bL/e/unspGPeaHS3d0NQFJS0hEeiYiIiIiIiMjPpbu7G+MhcrQkwk9JmaMcv99PfX09er0eiURypIdzTGGz2UhKSqKmpuaQEdsih494TX99xGv66yNe018f8Zr+fARBoLu7m/j4eKTS/itRjvkZFalUSmJi4pEexjGNwWAQP1i/MuI1/fURr+mvj3hNf33Ea/rzONRMyn7EYloRERERERGRoxZRqIiIiIiIiIgctYhC5QRGpVJx//33o1KpjvRQjhvEa/rrI17TXx/xmv76iNf0t+OYL6YVEREREREROX4RZ1REREREREREjlpEoSIiIiIiIiJy1CIKFREREREREZGjFlGoiIiIiIiIiBy1iELlBKSyspIrrriCtLQ0NBoNGRkZ3H///bjd7pDjduzYwcSJE1Gr1SQlJfHYY48doREfGzz00EOMGzcOrVaLyWQKe0x1dTWnnXYaWq0Wq9XKrbfeitfr/X0Heozx3HPPkZqailqtZvTo0WzYsOFID+mYYfXq1ZxxxhnEx8cjkUj45JNPQvYLgsB9991HXFwcGo2G6dOnU1paemQGewzw8MMPM3LkSPR6PVarlTlz5lBcXBxyjNPpZOHChURFRaHT6Tj77LNpamo6QiM+PhCFyglIUVERfr+fl156id27d/PPf/6TF198kbvuuit4jM1mY8aMGaSkpLB582Yef/xx/vKXv/Dyyy8fwZEf3bjdbubNm8d1110Xdr/P5+O0007D7Xazdu1aXnvtNV599VXuu+++33mkxw7vvvsuN998M/fffz9btmxhyJAhzJw5k+bm5iM9tGMCu93OkCFDeO6558Luf+yxx3jmmWd48cUX+eGHH4iIiGDmzJk4nc7feaTHBqtWrWLhwoWsX7+epUuX4vF4mDFjBna7PXjMn/70Jz777DPef/99Vq1aRX19PWedddYRHPVxgCAiIgjCY489JqSlpQX/fv7554XIyEjB5XIFt91+++1CTk7OkRjeMcWiRYsEo9HYZ/uXX34pSKVSobGxMbjthRdeEAwGQ8h1FjnAqFGjhIULFwb/9vl8Qnx8vPDwww8fwVEdmwDCxx9/HPzb7/cLsbGxwuOPPx7c1tnZKahUKuHtt98+AiM89mhubhYAYdWqVYIgBK6fQqEQ3n///eAxhYWFAiCsW7fuSA3zmEecUREBoKurC7PZHPx73bp1TJo0CaVSGdw2c+ZMiouL6ejoOBJDPOZZt24dgwYNIiYmJrht5syZ2Gw2du/efQRHdnTidrvZvHkz06dPD26TSqVMnz6ddevWHcGRHR9UVFTQ2NgYcn2NRiOjR48Wr+9h0tXVBRC8d27evBmPxxNyTXNzc0lOThav6S9AFCoilJWV8eyzz3LNNdcEtzU2NoZ8oQLBvxsbG3/X8R0viNf059Ha2orP5wt7zcTr9cvZfw3F6/u/4ff7uemmmxg/fjwDBw4EAtdUqVT2qVETr+kvQxQqxxF33HEHEonkkP+KiopCHlNXV8esWbOYN28eV1111REa+dHL/3JNRUREjn8WLlzIrl27eOedd470UI575Ed6ACK/HrfccgsLFiw45DHp6enB/66vr2fq1KmMGzeuT5FsbGxsn0r1/X/Hxsb+OgM+Bvi51/RQxMbG9ulYORGv6eESHR2NTCYL+z4Ur9cvZ/81bGpqIi4uLri9qamJoUOHHqFRHRvccMMNfP7556xevZrExMTg9tjYWNxuN52dnSGzKuJ79pchCpXjCIvFgsViOaxj6+rqmDp1KgUFBSxatAipNHRybezYsdx99914PB4UCgUAS5cuJScnh8jIyF997EcrP+ea/hRjx47loYceorm5GavVCgSuqcFgID8//1d5juMJpVJJQUEBy5cvZ86cOUBgun358uXccMMNR3ZwxwFpaWnExsayfPnyoDCx2Wz88MMP/XaunegIgsCNN97Ixx9/zMqVK0lLSwvZX1BQgEKhYPny5Zx99tkAFBcXU11dzdixY4/EkI8PjnQ1r8jvT21trZCZmSmcdNJJQm1trdDQ0BD8t5/Ozk4hJiZGuPjii4Vdu3YJ77zzjqDVaoWXXnrpCI786KaqqkrYunWr8MADDwg6nU7YunWrsHXrVqG7u1sQBEHwer3CwIEDhRkzZgjbtm0TlixZIlgsFuHOO+88wiM/ennnnXcElUolvPrqq8KePXuEq6++WjCZTCGdUyL9093dHXwfAsKTTz4pbN26VaiqqhIEQRAeeeQRwWQyCYsXLxZ27NghnHnmmUJaWprgcDiO8MiPTq677jrBaDQKK1euDLlv9vb2Bo+59tprheTkZOHbb78VNm3aJIwdO1YYO3bsERz1sY8oVE5AFi1aJABh/x3M9u3bhQkTJggqlUpISEgQHnnkkSM04mODSy+9NOw1XbFiRfCYyspK4ZRTThE0Go0QHR0t3HLLLYLH4zlygz4GePbZZ4Xk5GRBqVQKo0aNEtavX3+kh3TMsGLFirDvyUsvvVQQhECL8r333ivExMQIKpVKOOmkk4Ti4uIjO+ijmP7um4sWLQoe43A4hOuvv16IjIwUtFqtMHfu3JAfgSI/H4kgCMLvOIEjIiIiIiIiInLYiF0/IiIiIiIiIkctolAREREREREROWoRhYqIiIiIiIjIUYsoVERERERERESOWkShIiIiIiIiInLUIgoVERERERERkaMWUaiIiIiIiIiIHLWIQkVERERERETkqEUUKiIiIiIiIiJHLaJQERERERERETlqEYWKiIiIiIiIyFGLKFREREREREREjlr+H1PneudG+yUmAAAAAElFTkSuQmCC", + "image/png": "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", "text/plain": [ "
" ] @@ -811,7 +874,7 @@ "import seaborn as sns\n", "sns.scatterplot(\n", " x=results.tsne.x, y=results.tsne.y, \n", - " hue=results.clusters, palette=\"deep\"\n", + " hue=results.clusters, palette=\"Paired\"\n", ")" ] }, @@ -819,12 +882,22 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "or the UMAP embedding with the cell types we identified from `celldex`\n" + "Now's lets color the embedding with the cell types we identified from `celldex`. We ran the singleR algorithm on the full datasets, but scranpy filtered a few cells during the QC step. Lets identify which cells were kept." ] }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 17, + "metadata": {}, + "outputs": [], + "source": [ + "to_keep = [i for i,x in enumerate(results.rna_quality_control_filter) if x == False]\n", + "filtered_matches = [matches[\"best\"][i] for i in to_keep]" + ] + }, + { + "cell_type": "code", + "execution_count": 18, "metadata": {}, "outputs": [ { @@ -833,13 +906,54 @@ "" ] }, - "execution_count": 16, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import seaborn as sns\n", + "sns.scatterplot(\n", + " x=results.tsne.x, y=results.tsne.y, \n", + " hue=filtered_matches, palette=\"Paired\"\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Similarly also explore the UMAP embedding:" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 19, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -852,7 +966,7 @@ "import seaborn as sns\n", "sns.scatterplot(\n", " x=results.umap.x, y=results.umap.y, \n", - " hue=matches[\"best\"][:3002], palette=\"deep\"\n", + " hue=filtered_matches, palette=\"Paired\"\n", ")" ] }, @@ -860,22 +974,15 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "```{caution}\n", - "During the QC step, some cells were filtered, hence we filter the matches and this is incorrect (since we don't know which cells were filtered). \n", - "\n", - "We'll leave this as an exercise for the reader to change the order of steps: 1) run the dataset through the QC step 2) filter cells, and then 3) annotate using singleR.\n", - "```\n", - "\n", "## 6. Exercises\n", "\n", - "1. Share or Upload your datasets to scrna-seq, Instructions to upload are available in their respective [R/Bioc](https://bioconductor.org/packages/release/data/experiment/html/scRNAseq.html) and [Python](https://github.com/BiocPy/scrnaseq) packages.\n", + "1. Share or upload your datasets to scrna-seq package. Instructions to upload are available in their respective [R/Bioc](https://bioconductor.org/packages/release/data/experiment/html/scRNAseq.html) and [Python](https://github.com/BiocPy/scrnaseq) packages.\n", "2. Explore top markers for each cluster identified by scranpy.\n", - "3. Perform multi-modal analysis (scranpy supports RNA, ADT, CRISPR).\n", - "4. save your results and explore in [Kana](https://github.com/kanaverse/kana).\n", + "3. Save your results and explore in [Kana](https://github.com/kanaverse/kana).\n", "\n", - "Congratulations! You have now completed the tutorial on accessing single-cell datasets using `scRNAseq` and `ArtifactDB`, and annotating cell types using reference datasets from `celldex`. For more detailed usage and advanced analyses, refer to the respective documentation of these packages.\n", + "## Conclusion\n", "\n", - "By integrating R and Python workflows, you can leverage the strengths of both languages and perform comprehensive single-cell analysis. Keep exploring and happy analyzing!" + "Congratulations! You have now completed the tutorial on accessing single-cell datasets using `scRNAseq` and `ArtifactDB`, and annotating cell types using reference datasets from `celldex`. For more detailed usage and advanced analyses, refer to the respective documentation of these packages." ] } ], diff --git a/notebook/genomic_ranges.ipynb b/notebook/genomic_ranges.ipynb index b14264e..3d2393b 100644 --- a/notebook/genomic_ranges.ipynb +++ b/notebook/genomic_ranges.ipynb @@ -6,54 +6,78 @@ "source": [ "# Tutorial 1: `GenomicRanges` and range-based analyses\n", "\n", - "Genomic range operations are fundamental to many bioinformatics analyses. They allow us to work with intervals of genomic coordinates, which is crucial for understanding the relationships between different genomic features such as genes, regulatory elements, and experimental data like ChIP-seq peaks. In this tutorial, we'll explore how to work with genomic interval data using BiocPy's [GenomicRanges](https://github.com/BiocPy/GenomicRanges/) package, which provides Python implementations similar to the R/Bioconductor [GenomicRanges package](https://github.com/Bioconductor/GenomicRanges).\n", + "Genomic range operations are fundamental to many bioinformatics analyses. They allow us to work with intervals of genomic coordinates, which is crucial for understanding the relationships between different genomic features such as genes, regulatory elements, and experimental data like ChIP-seq peaks. In this tutorial, we'll explore how to work with genomic interval data using BiocPy's [GenomicRanges](https://github.com/BiocPy/GenomicRanges/) package, which provides a Python implementation of the R/Bioconductor [GenomicRanges package](https://github.com/Bioconductor/GenomicRanges).\n", "\n", "## Outline\n", "\n", - "In this workshop, we'll walk through several key aspects of working with genomic ranges in Python:\n", + "In this workshop, we'll walk through several aspects of working with genomic ranges in Python:\n", "\n", - "1. Reading Genomic Data: We'll start by reading in genomic data from RDS files, including exon positions grouped by transcripts.\n", - "2. Basic Genomic Operations: We'll cover fundamental operations like finding transcription start sites (TSS) and promoter regions.\n", - "3. Overlap Analysis: We'll learn how to find overlaps between different genomic features, a common task in many analyses.\n", - "4. Advanced Operations: We'll explore more complex operations like finding peaks within specific regions and resizing genomic intervals.\n", + "1. **Reading genomic data**: we'll start by reading in genomic data from RDS files, including exon positions grouped by transcripts.\n", + "2. **Basic genomic operations**: we'll cover fundamental operations like finding transcription start sites (TSS) and promoter regions.\n", + "3. **Overlap analysis**: we'll learn how to find overlaps between different genomic features, a common task in many analyses.\n", + "4. **Advanced operations**: we'll explore more complex operations like finding peaks within specific regions and resizing genomic intervals.\n", "\n", "## Prerequisites\n", "\n", - "Before we begin, please ensure that you have the following packages installed:" + "Before we begin, please ensure that you have the following prerequisites installed:\n", + "\n", + "- Python 3.8 or later with dependencies listed [here](https://github.com/BiocPy/BiocWorkshop2024/blob/master/requirements.txt).\n", + "- R 4.4.0 and Bioconductor packages listed [here](https://github.com/BiocPy/BiocWorkshop2024/blob/master/rpackages.R).\n", + "\n", + "\n", + "Install the Python packages using pip:" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "### Installation\n", - "\n", - "Let's start by installing the required packages for R and Python." + "!pip install -U biocutils genomicranges rds2py numpy pandas geniml" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "#### Python (shell)\n", + "Install the R packages using `BiocManager`:\n", "\n", - "You can install the Python packages using pip:" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "scrolled": true - }, - "source": [ - "!pip install -U biocutils genomicranges rds2py numpy pandas geniml" + "```r\n", + "BiocManager::install(c(\"AnnotationHub\"))\n", + "```\n", + "\n", + "## 1. Download reference annotation\n", + "\n", + "Insead of reinventing the wheel to access references in Python, we'll use existing available Bioconductor resources that provide access to genome annotations. `AnnotationHub` is a great resource providing access to genomic reference annotations. It's super convenient to search for a reference from `AnnotationHub` and download the genome of interest.\n", + "\n", + "Let's search the latest ensembl database for the human reference genome using Bioconductor's `AnnotationHub`. \n", + "\n", + "```r\n", + "suppressMessages(library(AnnotationHub))\n", + "\n", + "ah <- AnnotationHub()\n", + "ensdb <- query(ah, \"Ensembl 112 EnsDb for Homo sapiens\")[[1]]\n", + "```\n", + "\n", + "We will then extract the exon positions and group them by transcript. Additionally, we provide a list of column names we would like to be available in `mcols` for our analysis. For the purpose of this tutorial, we'll limit ourselves to the exons from chromosome 22.\n", + "\n", + "```r\n", + "exons_by_tx <- exonsBy(ensdb, \n", + " by = \"tx\", filter = SeqNameFilter(c(\"22\")), \n", + " columns= c(\"exon_id\", \"tx_name\", \"tx_id\", \"gene_name\", \"gene_id\"))\n", + "```\n", + "\n", + "Finally, save the object as an RDS file.\n", + "\n", + "```r\n", + "saveRDS(exons_by_tx, \"hg38_exons_by_tx.rds\")\n", + "```" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "If you are using Google colab, you may not have access to the RDS file used, in this tutorial. Change the block below from markdown to code and run the chunk." + "If you are using Google Colab, you may not have access to the RDS file used, in this tutorial. Change the block below from markdown to code and run the chunk." ] }, { @@ -67,61 +91,47 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "#### R\n", + "## 2. Load genome annotation in Python\n", "\n", - " ```r\n", - " BiocManager::install(c(\"AnnotationHub\"), \n", - " repos='http://cran.us.r-project.org')\n", - " ```" + "We now read the above RDS annotation object into our Python session using the [rds2py](https://github.com/biocpy/rds2py) Python package. This is a two step process. \n", + "\n", + "The first step represents the data stored in the RDS file as a python dictionary " ] }, { - "cell_type": "markdown", + "cell_type": "code", + "execution_count": 1, "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Keys of the object: dict_keys(['data', 'package_name', 'class_name', 'attributes'])\n", + "Class name of the object: CompressedGRangesList\n" + ] + } + ], "source": [ - "## 1. Save Annotations as RDS\n", - "\n", - "Let's download the human reference genome and save the exon positions grouped by transcripts. For the purpose of the tutorial, we'll limit the exons to chromosome 22.\n", - "\n", - "#### R\n", - "\n", - " ```r\n", - " suppressMessages(library(AnnotationHub))\n", - " \n", - " ah <- AnnotationHub()\n", - " ensdb <- query(ah, \"Ensembl 112 EnsDb for Homo sapiens\")[[1]]\n", - " exons_by_tx <- exonsBy(ensdb, \n", - " by = \"tx\", filter = SeqNameFilter(c(\"22\")), \n", - " columns= c(\"exon_id\", \"tx_name\", \"tx_id\", \"gene_name\", \"gene_id\"))\n", - " saveRDS(exons_by_tx, \"hg38_exons_by_tx.rds\")\n", - " ```" + "from rds2py import read_rds\n", + "hg38_robject = read_rds(\"./hg38_exons_by_tx.rds\")\n", + "\n", + "# Only printing the keys\n", + "print(\"Keys of the object:\", hg38_robject.keys())\n", + "print(\"Class name of the object:\", hg38_robject[\"class_name\"])" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "## 2. Reading RDS files in Python\n", - "\n", - "The [rds2py](https://github.com/biocpy/rds2py) Python package allows us to read RDS files and create equivalent Python representations of R objects. Key features include:\n", - "\n", - "- Parsing common R objects into Python equivalents (e.g., matrices to NumPy arrays, data frames to Pandas DataFrames).\n", - "- Ability to read S4 classes, enabling direct parsing of Bioconductor data types from R to Python.\n", - "\n", - "Reading an RDS file with rds2py involves two steps:\n", - "\n", - "1. Parse the RDS file into a Python dictionary containing data, its attributes, and associated metadata.\n", - "2. Convert this dictionary into a suitable Python object using specific parser functions.\n", - "\n", - "This process allows a seamless transition between R and Python for bioinformatics analyses." + "This object (`hg38_robject`) can then be coerced into a Python `GenomicRangesList` class." ] }, { "cell_type": "code", - "execution_count": 23, - "metadata": { - "scrolled": true - }, + "execution_count": 2, + "metadata": {}, "outputs": [ { "name": "stdout", @@ -222,6 +232,7 @@ "from rds2py import read_rds\n", "hg38_robject = read_rds(\"./hg38_exons_by_tx.rds\")\n", "\n", + "# TODO: split this into two\n", "from rds2py.granges import as_granges_list\n", "by_tx = as_granges_list(hg38_robject)\n", "\n", @@ -233,186 +244,54 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## 2. Basic Genomic Operations\n", - "\n", - "Now, let's perform some basic operations like finding Transcription Start Sites (TSS) and promoter regions. These operations are fundamental in genomic analysis as they help us identify key regulatory regions of the genome.\n", - "\n", - "### 2.1 Create a `GenomicRangesList` by gene\n", - "\n", - "To identify TSS or define promoter regions, let's first reprocess the input to create a `GenomicRangesList` by gene symbols.\n", - "\n", - "To achieve this, we unlist the `GenomicRangesList` object. This is accomplished in Python using the `as_genomic_ranges()` method. " - ] - }, - { - "cell_type": "code", - "execution_count": 24, - "metadata": {}, - "outputs": [], - "source": [ - "all_ranges = by_tx.as_genomic_ranges()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Then we split the object using the `gene_name` metadata column in `mcols()`. \n", - "\n", - "```{important}\n", - "We provide accessors to get or set attributes of the class. Most folks in Python may be familiar with direct access to class members (via properties or @property), but this should generally be avoided, as it is too easy to perform modifications via one-liners with the class.property on the left-hand side of an assignment.\n", - "\n", - "For more information, please refer to our [developer guide](https://github.com/BiocPy/developer_guide).\n", + "```{note}\n", + "Currently this is a two step process, we are working on simplifying this to a one step process for supported Bioconductor classes.\n", "```\n", "\n", - "```{note}\n", - "While gene IDs are unique, gene symbols are not. In addition, this list has genes with no symbols.\n", - "```" - ] - }, - { - "cell_type": "code", - "execution_count": 25, - "metadata": { - "scrolled": true - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Exons by gene:\n", - "GenomicRangesList with 932 ranges and 0 metadata columns\n", - " \n", - "Name: \n", - "GenomicRanges with 1846 ranges and 6 metadata columns\n", - " seqnames ranges strand exon_id tx_name tx_id gene_name gene_id exon_rank\n", - " \n", - "ENST00000255890 chr22 23402361 - 23402568 - | ENSE00001754779 ENST00000255890 ENST00000255890 ENSG00000290920 1\n", - "ENST00000255890 chr22 23402037 - 23402156 - | ENSE00001700441 ENST00000255890 ENST00000255890 ENSG00000290920 2\n", - "ENST00000255890 chr22 23401841 - 23401954 - | ENSE00004028898 ENST00000255890 ENST00000255890 ENSG00000290920 3\n", - " ... ... ... | ... ... ... ... ... ...\n", - "ENST00000706202 chr22 21008247 - 21009450 - | ENSE00003995059 ENST00000706202 ENST00000706202 ENSG00000291240 7\n", - "ENST00000714325 chr22 18939446 - 18947693 + | ENSE00003802171 ENST00000714325 ENST00000714325 ENSG00000284294 1\n", - "ENST00000715281 chr22 35838583 - 35838658 - | ENSE00004026430 ENST00000715281 ENST00000715281 ENSG00000293594 1\n", - "------\n", - "seqinfo(1 sequences): chr22\n", - " \n", - "Name: 5_8S_rRNA \n", - "GenomicRanges with 1 range and 6 metadata columns\n", - " seqnames ranges strand exon_id tx_name tx_id gene_name gene_id exon_rank\n", - " \n", - "ENST00000612732 chr22 11249809 - 11249960 - | ENSE00003735240 ENST00000612732 ENST00000612732 5_8S_rRNA ENSG00000276871 1\n", - "------\n", - "seqinfo(1 sequences): chr22\n", - " \n", - "Name: A4GALT \n", - "GenomicRanges with 20 ranges and 6 metadata columns\n", - " seqnames ranges strand exon_id tx_name tx_id gene_name gene_id exon_rank\n", - " \n", - "ENST00000249005 chr22 42695491 - 42695634 - | ENSE00001109573 ENST00000249005 ENST00000249005 A4GALT ENSG00000128274 1\n", - "ENST00000249005 chr22 42692122 - 42693998 - | ENSE00000880583 ENST00000249005 ENST00000249005 A4GALT ENSG00000128274 2\n", - "ENST00000381278 chr22 42720797 - 42720820 - | ENSE00003818792 ENST00000381278 ENST00000381278 A4GALT ENSG00000128274 1\n", - " ... ... ... | ... ... ... ... ... ...\n", - " LRG_795t1 chr22 42720797 - 42720871 - | LRG_795t1e1 LRG_795t1 LRG_795t1 A4GALT LRG_795 1\n", - " LRG_795t1 chr22 42695491 - 42695632 - | LRG_795t1e2 LRG_795t1 LRG_795t1 A4GALT LRG_795 2\n", - " LRG_795t1 chr22 42692121 - 42693998 - | LRG_795t1e3 LRG_795t1 LRG_795t1 A4GALT LRG_795 3\n", - "------\n", - "seqinfo(1 sequences): chr22\n", - " \n", - "Name: \n", - "GenomicRanges with 26 ranges and 6 metadata columns\n", - " seqnames ranges strand exon_id tx_name tx_id gene_name gene_id exon_rank\n", - " \n", - "ENST00000402174 chr22 28917389 - 28917482 + | ENSE00001552635 ENST00000402174 ENST00000402174 ZNRF3 ENSG00000183579 1\n", - "ENST00000402174 chr22 28987076 - 28987202 + | ENSE00003547707 ENST00000402174 ENST00000402174 ZNRF3 ENSG00000183579 2\n", - "ENST00000402174 chr22 29042495 - 29042570 + | ENSE00001329477 ENST00000402174 ENST00000402174 ZNRF3 ENSG00000183579 3\n", - " ... ... ... | ... ... ... ... ... ...\n", - "ENST00000544604 chr22 29048389 - 29048492 + | ENSE00001325812 ENST00000544604 ENST00000544604 ZNRF3 ENSG00000183579 7\n", - "ENST00000544604 chr22 29049197 - 29050949 + | ENSE00001308098 ENST00000544604 ENST00000544604 ZNRF3 ENSG00000183579 8\n", - "ENST00000544604 chr22 29053579 - 29057489 + | ENSE00001427475 ENST00000544604 ENST00000544604 ZNRF3 ENSG00000183579 9\n", - "------\n", - "seqinfo(1 sequences): chr22\n", - " \n", - "Name: ZNRF3 \n", - "GenomicRanges with 3 ranges and 6 metadata columns\n", - " seqnames ranges strand exon_id tx_name tx_id gene_name gene_id exon_rank\n", - " \n", - "ENST00000325660 chr22 29031391 - 29031477 - | ENSE00001718965 ENST00000325660 ENST00000325660 ZNRF3-AS1 ENSG00000177993 1\n", - "ENST00000325660 chr22 29031084 - 29031157 - | ENSE00001643791 ENST00000325660 ENST00000325660 ZNRF3-AS1 ENSG00000177993 2\n", - "ENST00000325660 chr22 29024999 - 29027010 - | ENSE00001267818 ENST00000325660 ENST00000325660 ZNRF3-AS1 ENSG00000177993 3\n", - "------\n", - "seqinfo(1 sequences): chr22\n", - " \n", - "Name: ZNRF3-AS1 \n", - "GenomicRanges with 2 ranges and 6 metadata columns\n", - " seqnames ranges strand exon_id tx_name tx_id gene_name gene_id exon_rank\n", - " \n", - "ENST00000412798 chr22 28992721 - 28992938 + | ENSE00001659048 ENST00000412798 ENST00000412798 ZNRF3-IT1 ENSG00000235786 1\n", - "ENST00000412798 chr22 29018164 - 29018621 + | ENSE00001595182 ENST00000412798 ENST00000412798 ZNRF3-IT1 ENSG00000235786 2\n", - "------\n", - "seqinfo(1 sequences): chr22\n", - " \n", - "\n" - ] - } - ], - "source": [ - "by_gene = all_ranges.split(\n", - " groups=all_ranges.get_mcols().get_column(\"gene_name\")\n", - ")\n", + "## 3. Define promoters and TSS\n", "\n", - "print(\"Exons by gene:\")\n", - "print(by_gene)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### 2.2 Finding Transcription Start Sites (TSS)\n", + "Now, let's perform some basic operations like finding transcription start sites (TSS) and promoter regions. These operations help us identify key regulatory regions of the genome.\n", + "\n", + "### 3.1 Find transcription start sites (TSS)\n", "\n", "Transcription Start Sites (TSS) are the locations where transcription of a gene begins. Identifying TSS is crucial for understanding gene regulation, as many regulatory elements are located near the TSS. \n", "\n", - "Let's use the `range()` method to get the full extent of each gene." + "First, we use the `range()` method to get the full extent of each transcript. This should give us exactly one range per transcript." ] }, { "cell_type": "code", - "execution_count": 26, - "metadata": { - "scrolled": true - }, + "execution_count": 3, + "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Gene ranges:\n", - "GenomicRangesList with 932 ranges and 0 metadata columns\n", + "Transcript ranges:\n", + "GenomicRangesList with 5387 ranges and 0 metadata columns\n", " \n", - "Name: \n", - "GenomicRanges with 2 ranges and 0 metadata columns\n", + "Name: ENST00000006251 \n", + "GenomicRanges with 1 range and 0 metadata columns\n", " seqnames ranges strand\n", " \n", - "[0] chr22 11066418 - 50674175 +\n", - "[1] chr22 15282557 - 50755435 -\n", + "[0] chr22 44677057 - 44737681 +\n", "------\n", "seqinfo(1 sequences): chr22\n", " \n", - "Name: 5_8S_rRNA \n", + "Name: ENST00000008876 \n", "GenomicRanges with 1 range and 0 metadata columns\n", " seqnames ranges strand\n", " \n", - "[0] chr22 11249809 - 11249960 -\n", + "[0] chr22 50603133 - 50613982 +\n", "------\n", "seqinfo(1 sequences): chr22\n", " \n", - "Name: A4GALT \n", + "Name: ENST00000043402 \n", "GenomicRanges with 1 range and 0 metadata columns\n", " seqnames ranges strand\n", " \n", - "[0] chr22 42692121 - 42721299 -\n", + "[0] chr22 20241415 - 20268319 -\n", "------\n", "seqinfo(1 sequences): chr22\n", " \n", @@ -420,23 +299,23 @@ "GenomicRanges with 1 range and 0 metadata columns\n", " seqnames ranges strand\n", " \n", - "[0] chr22 28883572 - 29057489 +\n", + "[0] chr22 33272509 - 33920477 -\n", "------\n", "seqinfo(1 sequences): chr22\n", " \n", - "Name: ZNRF3 \n", + "Name: LRG_856t2 \n", "GenomicRanges with 1 range and 0 metadata columns\n", " seqnames ranges strand\n", " \n", - "[0] chr22 29024999 - 29031477 -\n", + "[0] chr22 37225270 - 37244266 -\n", "------\n", "seqinfo(1 sequences): chr22\n", " \n", - "Name: ZNRF3-AS1 \n", + "Name: LRG_97t1 \n", "GenomicRanges with 1 range and 0 metadata columns\n", " seqnames ranges strand\n", " \n", - "[0] chr22 28992721 - 29018621 +\n", + "[0] chr22 20982297 - 20999033 +\n", "------\n", "seqinfo(1 sequences): chr22\n", " \n", @@ -445,22 +324,22 @@ } ], "source": [ - "ranges_by_gene = by_gene.range()\n", + "ranges_by_tx = by_tx.range()\n", "\n", - "print(\"Gene ranges:\")\n", - "print(ranges_by_gene)" + "print(\"Transcript ranges:\")\n", + "print(ranges_by_tx)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "We convert the list to a `GenomicRanges` object." + "Since the range gives us exactly one range per transcript, so we can simplify our list to a `GenomicRanges` object. This is similar to `unlist` in R." ] }, { "cell_type": "code", - "execution_count": 27, + "execution_count": 4, "metadata": {}, "outputs": [ { @@ -468,26 +347,26 @@ "output_type": "stream", "text": [ "as GenomicRanges:\n", - "GenomicRanges with 936 ranges and 0 metadata columns\n", - " seqnames ranges strand\n", - " \n", - " chr22 11066418 - 50674175 +\n", - " chr22 15282557 - 50755435 -\n", - "5_8S_rRNA chr22 11249809 - 11249960 -\n", - " ... ... ...\n", - " ZNRF3 chr22 28883572 - 29057489 +\n", - "ZNRF3-AS1 chr22 29024999 - 29031477 -\n", - "ZNRF3-IT1 chr22 28992721 - 29018621 +\n", + "GenomicRanges with 5387 ranges and 0 metadata columns\n", + " seqnames ranges strand\n", + " \n", + "ENST00000006251 chr22 44677057 - 44737681 +\n", + "ENST00000008876 chr22 50603133 - 50613982 +\n", + "ENST00000043402 chr22 20241415 - 20268319 -\n", + " ... ... ...\n", + " LRG_856t2 chr22 33272509 - 33920477 -\n", + " LRG_97t1 chr22 37225270 - 37244266 -\n", + " LRG_989t1 chr22 20982297 - 20999033 +\n", "------\n", "seqinfo(1 sequences): chr22\n" ] } ], "source": [ - "gr_by_gene = ranges_by_gene.as_genomic_ranges()\n", + "gr_by_tx = ranges_by_tx.as_genomic_ranges()\n", "\n", "print(\"as GenomicRanges:\")\n", - "print(gr_by_gene)" + "print(gr_by_tx)" ] }, { @@ -499,7 +378,7 @@ }, { "cell_type": "code", - "execution_count": 28, + "execution_count": 5, "metadata": {}, "outputs": [ { @@ -507,40 +386,40 @@ "output_type": "stream", "text": [ "Transcript Start Sites:\n", - "GenomicRanges with 936 ranges and 0 metadata columns\n", - " seqnames ranges strand\n", - " \n", - " chr22 11066418 - 50674175 +\n", - " chr22 15282557 - 50755435 -\n", - "5_8S_rRNA chr22 11249809 - 11249960 -\n", - " ... ... ...\n", - " ZNRF3 chr22 28883572 - 29057489 +\n", - "ZNRF3-AS1 chr22 29024999 - 29031477 -\n", - "ZNRF3-IT1 chr22 28992721 - 29018621 +\n", + "GenomicRanges with 5387 ranges and 0 metadata columns\n", + " seqnames ranges strand\n", + " \n", + "ENST00000006251 chr22 44677057 - 44677058 +\n", + "ENST00000008876 chr22 50603133 - 50603134 +\n", + "ENST00000043402 chr22 20268318 - 20268319 -\n", + " ... ... ...\n", + " LRG_856t2 chr22 33920476 - 33920477 -\n", + " LRG_97t1 chr22 37244265 - 37244266 -\n", + " LRG_989t1 chr22 20982297 - 20982298 +\n", "------\n", "seqinfo(1 sequences): chr22\n" ] } ], "source": [ - "tss = gr_by_gene.resize(width=1, fix=\"start\")\n", + "tss = gr_by_tx.resize(width=1, fix=\"start\")\n", "\n", "print(\"Transcript Start Sites:\")\n", - "print(gr_by_gene)" + "print(tss)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "### 2.3 Defining Promoter Regions\n", + "### 3.2 Define promoter regions\n", "\n", "Here, we're defining promoters as the region 2000 base pairs upstream to 200 base pairs downstream of each TSS. This definition can vary depending on the specific analysis, but this range often captures important regulatory elements." ] }, { "cell_type": "code", - "execution_count": 29, + "execution_count": 6, "metadata": {}, "outputs": [ { @@ -548,16 +427,16 @@ "output_type": "stream", "text": [ "Promoter Regions:\n", - "GenomicRanges with 936 ranges and 0 metadata columns\n", - " seqnames ranges strand\n", - " \n", - " chr22 11064418 - 11066618 +\n", - " chr22 50755235 - 50757435 -\n", - "5_8S_rRNA chr22 11249760 - 11251960 -\n", - " ... ... ...\n", - " ZNRF3 chr22 28881572 - 28883772 +\n", - "ZNRF3-AS1 chr22 29031277 - 29033477 -\n", - "ZNRF3-IT1 chr22 28990721 - 28992921 +\n", + "GenomicRanges with 5387 ranges and 0 metadata columns\n", + " seqnames ranges strand\n", + " \n", + "ENST00000006251 chr22 44675057 - 44677257 +\n", + "ENST00000008876 chr22 50601133 - 50603333 +\n", + "ENST00000043402 chr22 20268119 - 20270319 -\n", + " ... ... ...\n", + " LRG_856t2 chr22 33920277 - 33922477 -\n", + " LRG_97t1 chr22 37244066 - 37246266 -\n", + " LRG_989t1 chr22 20980297 - 20982497 +\n", "------\n", "seqinfo(1 sequences): chr22\n" ] @@ -574,24 +453,40 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "```{note}\n", - "Please be aware that because gene symbols may not be unique, this `GenomicRanges` object might contain duplicates. You might want to resolve duplicate symbols by making the symbols unique. We will leave this as an exercise for the reader.\n", - "```\n", - "\n", - "## 3. Overlap Analysis\n", + "## 4. Overlap with ChIP-seq peaks\n", "\n", "A common task in genomic analysis is finding overlaps between different genomic features. This helps us understand the relationships between various elements in the genome and can provide insights into gene regulation and function.\n", "\n", - "### 3.1 Reading ChIP-seq Peaks\n", + "### 4.1 Load ChIP-seq peaks\n", "\n", - "ChIP-seq (Chromatin Immunoprecipitation followed by sequencing) is a method used to identify binding sites of DNA-associated proteins. The peaks represent regions where a protein of interest is likely bound to the DNA. We're focusing on chromosome 22 for this example to keep the dataset manageable.\n", + "ChIP-seq (Chromatin Immunoprecipitation followed by sequencing) is a method used to identify binding sites of DNA-associated proteins. The peaks represent regions where a protein of interest is likely bound to the DNA. \n", "\n", - "For the purpose of this tutorial, let's download a bed file containing peaks from a ChIP-seq experiment on \"Human B cells\" to identify \"EZH2\" binding sites (from ENCODE) and cataloged in [bedbase.org](https://bedbase.org/bed/be4054acf6e3feeb4dc490e6430e358e)." + "For the purpose of this tutorial, let's download a bed file containing peaks from a ChIP-seq experiment on human B cells to identify EZH2 binding sites (from ENCODE) and catalogued in [bedbase.org](https://bedbase.org/bed/be4054acf6e3feeb4dc490e6430e358e). " ] }, { "cell_type": "code", - "execution_count": 30, + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "from geniml.bbclient import BBClient\n", + "\n", + "bbclient = BBClient(cache_folder=\"cache\", bedbase_api=\"https://api.bedbase.org\")\n", + "bedfile_id = \"be4054acf6e3feeb4dc490e6430e358e\" \n", + "bedfile = bbclient.load_bed(bedfile_id)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Our friends at bedbase (Nathan Sheffield et al.) provide methods to easily coerce these objects to `GenomicRanges`. Again, we're focusing on chromosome 22 for this example to keep the dataset manageable." + ] + }, + { + "cell_type": "code", + "execution_count": 8, "metadata": {}, "outputs": [ { @@ -614,11 +509,6 @@ } ], "source": [ - "from geniml.bbclient import BBClient\n", - "\n", - "bbclient = BBClient(cache_folder=\"cache\", bedbase_api=\"https://api.bedbase.org\")\n", - "bedfile_id = \"be4054acf6e3feeb4dc490e6430e358e\" \n", - "bedfile = bbclient.load_bed(bedfile_id)\n", "peaks = bedfile.to_granges()\n", "\n", "filter_chr22 = [x == \"chr22\" for x in peaks.get_seqnames()]\n", @@ -631,30 +521,30 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "### 3.2 Finding Overlaps with TSS\n", + "### 4.2 Find overlaps with TSS\n", "\n", "Here, we're identifying ChIP-seq peaks that overlap with TSS. This analysis can help us understand if the protein of interest tends to bind near the start of genes, which could suggest a role in transcription initiation." ] }, { "cell_type": "code", - "execution_count": 31, + "execution_count": 9, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Peak indices that overlap with first 10 TSS:\n", - "[[], [], [], [55], [217], [], [], [], [], []]\n" + "Peak indices that overlap with TSS between 30-40:\n", + "[[], [], [], [], [], [], [], [], [1157], []]\n" ] } ], "source": [ "overlaps = peaks_chr22.find_overlaps(tss)\n", "\n", - "print(\"Peak indices that overlap with first 10 TSS:\")\n", - "print(overlaps[:10])" + "print(\"Peak indices that overlap with TSS between 30-40:\")\n", + "print(overlaps[30:40])" ] }, { @@ -667,28 +557,28 @@ "**TODO: Future plans to convert this into a `Hits` object.**\n", "```\n", "\n", - "Let's identify the peaks that overlap with TSS." + "Let's identify the peaks that overlap with any TSS." ] }, { "cell_type": "code", - "execution_count": 32, + "execution_count": 10, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "GenomicRanges with 35 ranges and 0 metadata columns\n", + "GenomicRanges with 75 ranges and 0 metadata columns\n", " seqnames ranges strand\n", " \n", " [0] chr22 19756445 - 19756735 *\n", - " [1] chr22 38467935 - 38468225 *\n", - " [2] chr22 24952664 - 24952954 *\n", + " [1] chr22 36816145 - 36816435 *\n", + " [2] chr22 38467935 - 38468225 *\n", " ... ... ...\n", - "[32] chr22 21032552 - 21032842 *\n", - "[33] chr22 50270553 - 50270843 *\n", - "[34] chr22 19131257 - 19131547 *\n", + "[72] chr22 50270553 - 50270843 *\n", + "[73] chr22 19131257 - 19131547 *\n", + "[74] chr22 19014170 - 19014460 *\n", "------\n", "seqinfo(46 sequences): chr1 chr10 chr11 ... chrUn_KI270750v1 chrUn_KI270752v1 chrX\n" ] @@ -706,28 +596,28 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Instead, one can subset peaks that overlap with TSS using the `subset_by_overlaps` method:" + "Alternatively, we can use `subset_by_overlaps` method to more conveniently overlap the peaks that overlap with any TSS:" ] }, { "cell_type": "code", - "execution_count": 33, + "execution_count": 11, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "GenomicRanges with 35 ranges and 0 metadata columns\n", + "GenomicRanges with 75 ranges and 0 metadata columns\n", " seqnames ranges strand\n", " \n", " [0] chr22 19756445 - 19756735 *\n", - " [1] chr22 38467935 - 38468225 *\n", - " [2] chr22 24952664 - 24952954 *\n", + " [1] chr22 36816145 - 36816435 *\n", + " [2] chr22 38467935 - 38468225 *\n", " ... ... ...\n", - "[32] chr22 21032552 - 21032842 *\n", - "[33] chr22 50270553 - 50270843 *\n", - "[34] chr22 19131257 - 19131547 *\n", + "[72] chr22 50270553 - 50270843 *\n", + "[73] chr22 19131257 - 19131547 *\n", + "[74] chr22 19014170 - 19014460 *\n", "------\n", "seqinfo(46 sequences): chr1 chr10 chr11 ... chrUn_KI270750v1 chrUn_KI270752v1 chrX\n" ] @@ -742,95 +632,95 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Additionally, in some cases, we may want to ignore strand information (`ignore_strand=True`) when finding overlaps." + "### 4.3 Find overlaps with promoters\n", + "\n", + "This operation finds ChIP-seq peaks that overlap with our defined promoter regions. If a significant number of peaks fall within promoters, it might suggest that the protein plays a role in gene regulation." ] }, { "cell_type": "code", - "execution_count": 34, + "execution_count": 12, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "GenomicRanges with 35 ranges and 0 metadata columns\n", - " seqnames ranges strand\n", - " \n", - " [0] chr22 19756445 - 19756735 *\n", - " [1] chr22 38467935 - 38468225 *\n", - " [2] chr22 24952664 - 24952954 *\n", - " ... ... ...\n", - "[32] chr22 21032552 - 21032842 *\n", - "[33] chr22 50270553 - 50270843 *\n", - "[34] chr22 19131257 - 19131547 *\n", + "Peaks Overlapping with Promoters:\n", + "GenomicRanges with 344 ranges and 0 metadata columns\n", + " seqnames ranges strand\n", + " \n", + " [0] chr22 19756445 - 19756735 *\n", + " [1] chr22 37427967 - 37428257 *\n", + " [2] chr22 19169462 - 19169752 *\n", + " ... ... ...\n", + "[341] chr22 42368884 - 42369174 *\n", + "[342] chr22 21630789 - 21631079 *\n", + "[343] chr22 17368148 - 17368438 *\n", "------\n", "seqinfo(46 sequences): chr1 chr10 chr11 ... chrUn_KI270750v1 chrUn_KI270752v1 chrX\n" ] } ], "source": [ - "peaks_by_tss_ignoring_strand = peaks_chr22.subset_by_overlaps(tss, ignore_strand=True)\n", - "print(peaks_by_tss_ignoring_strand)" + "peaks_by_promoters = peaks_chr22.subset_by_overlaps(promoters)\n", + "\n", + "print(\"Peaks Overlapping with Promoters:\")\n", + "print(peaks_by_promoters)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "```{note}\n", - "This yields the same results for this particular scenario, but may not if the 'peaks' contain strand information.\n", - "```\n", - "\n", - "### 3.3 Finding Overlaps with Promoters\n", + "### 4.4 Find overlaps with exons\n", "\n", - "This operation finds ChIP-seq peaks that overlap with our defined promoter regions. If a significant number of peaks fall within promoters, it might suggest that the protein plays a role in gene regulation through promoter binding. This kind of analysis is often used to characterize the binding patterns of transcription factors or other regulatory proteins." + "Lets find overlaps with any exon. We `unlist` our `GenomicRangesList` object to get all exon positions." ] }, { "cell_type": "code", - "execution_count": 35, + "execution_count": 13, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Peaks Overlapping with Promoters:\n", - "GenomicRanges with 190 ranges and 0 metadata columns\n", - " seqnames ranges strand\n", - " \n", - " [0] chr22 19756445 - 19756735 *\n", - " [1] chr22 37427967 - 37428257 *\n", - " [2] chr22 22521942 - 22522232 *\n", - " ... ... ...\n", - "[187] chr22 39993439 - 39993729 *\n", - "[188] chr22 22338004 - 22338294 *\n", - "[189] chr22 19131257 - 19131547 *\n", + "All exons:\n", + "GenomicRanges with 34967 ranges and 6 metadata columns\n", + " seqnames ranges strand exon_id tx_name tx_id gene_name gene_id exon_rank\n", + " \n", + "ENST00000006251 chr22 44677057 - 44677241 + | ENSE00001838743 ENST00000006251 ENST00000006251 PRR5 ENSG00000186654 1\n", + "ENST00000006251 chr22 44702492 - 44702609 + | ENSE00003647870 ENST00000006251 ENST00000006251 PRR5 ENSG00000186654 2\n", + "ENST00000006251 chr22 44714591 - 44714672 + | ENSE00003614159 ENST00000006251 ENST00000006251 PRR5 ENSG00000186654 3\n", + " ... ... ... | ... ... ... ... ... ...\n", + " LRG_989t1 chr22 20996696 - 20996802 + | LRG_989t1e19 LRG_989t1 LRG_989t1 LZTR1 LRG_989 19\n", + " LRG_989t1 chr22 20996886 - 20996967 + | LRG_989t1e20 LRG_989t1 LRG_989t1 LZTR1 LRG_989 20\n", + " LRG_989t1 chr22 20997232 - 20999033 + | LRG_989t1e21 LRG_989t1 LRG_989t1 LZTR1 LRG_989 21\n", "------\n", - "seqinfo(46 sequences): chr1 chr10 chr11 ... chrUn_KI270750v1 chrUn_KI270752v1 chrX\n" + "seqinfo(1 sequences): chr22\n" ] } ], "source": [ - "peaks_by_promoters = peaks_chr22.subset_by_overlaps(promoters)\n", + "# Combine all exons into a single GenomicRanges object\n", + "all_exons = by_tx.as_granges()\n", "\n", - "print(\"Peaks Overlapping with Promoters:\")\n", - "print(peaks_by_promoters)" + "print(\"All exons:\")\n", + "print(all_exons)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "### 3.4 Finding Overlaps with Exons\n", - "\n", - "Another analysis is to look at overlaps with all exons. This can help identify potential roles of the ChIP-seq peaks in splicing. Let's modify our analysis to look at all exons:" + "We can then find peaks that overlap with any of these regions:" ] }, { "cell_type": "code", - "execution_count": 36, + "execution_count": 14, "metadata": {}, "outputs": [ { @@ -843,9 +733,9 @@ " \n", " [0] chr22 19766788 - 19767078 *\n", " [1] chr22 17369888 - 17370178 *\n", - " [2] chr22 29307104 - 29307394 *\n", + " [2] chr22 19756445 - 19756735 *\n", " ... ... ...\n", - "[276] chr22 16969920 - 16970210 *\n", + "[276] chr22 29307104 - 29307394 *\n", "[277] chr22 35552420 - 35552710 *\n", "[278] chr22 37931897 - 37932187 *\n", "------\n", @@ -855,9 +745,6 @@ } ], "source": [ - "# Combine all exons into a single GenomicRanges object\n", - "all_exons = by_gene.as_granges()\n", - "\n", "# Find peaks overlapping with any exon\n", "peaks_by_exons = peaks_chr22.subset_by_overlaps(all_exons)\n", "\n", @@ -874,20 +761,42 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "This analysis can provide insights into whether the protein of interest (captured by the ChIP-seq: \"EZH2\") tends to bind within gene bodies, potentially influencing gene expression, splicing, or other co-transcriptional processes.\n", - "\n", - "## 4. Advanced Operations\n", + "## 5. Advanced Operations\n", "\n", "Let's explore some more complex operations that are often used in genomic analyses.\n", "\n", - "### 4.1 Comparing Exonic vs. Intronic Binding\n", + "### 5.1 Compare exonic vs. intronic binding\n", + "\n", + "Let's first identify intron regions. There are two ways to find introns\n", "\n", - "Let's first identify intron regions. We will use the `by_gene` object we created that contains a `GenomicRangesList` split by gene." + "1. **Find introns for each gene**, regions within each gene body that do not overlap to that gene's exons (using `psetdiff` in R/Bioconductor).\n", + "2. **Find introns globally**, regions that don't overlap with any exon (using `subtract`). To find these positions, we also ignore strand information.\n", + "\n", + "We will find introns globally (2) for our tutorial today. If you are wondering why, we currently don't have `psetdiff` implemented in BiocPy/GenomicRanges. If you are interested in contributing, check out [this issue](https://github.com/BiocPy/GenomicRanges/issues/115).\n", + "\n", + "Let's first get all transcript ranges, following the steps in [Section 3.1](#find-transcription-start-sites-tss):" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [], + "source": [ + "# Get the full extent of each gene\n", + "tx_ranges = by_tx.range().as_genomic_ranges()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We now subtract any exons that overlaps within each transcript by ignoring the strand. The result is a `GenomicRangesList` containing intron regions for each transcript. We simplify this by coercing this into a `GenomicRanges` object." ] }, { "cell_type": "code", - "execution_count": 37, + "execution_count": 16, "metadata": {}, "outputs": [ { @@ -895,25 +804,23 @@ "output_type": "stream", "text": [ "Intron regions:\n", - "GenomicRanges with 1572 ranges and 0 metadata columns\n", - " seqnames ranges strand\n", - " \n", - " chr22 15282557 - 15550904 -\n", - " chr22 15552888 - 15553211 -\n", - " chr22 15553587 - 15553691 -\n", - " ... ... ...\n", - " ZNRF3 chr22 28883572 - 29057489 +\n", - "ZNRF3-AS1 chr22 29024999 - 29031477 -\n", - "ZNRF3-IT1 chr22 28992721 - 29018621 +\n", + "GenomicRanges with 5403 ranges and 0 metadata columns\n", + " seqnames ranges strand\n", + " \n", + "ENST00000006251 chr22 44677057 - 44737681 +\n", + "ENST00000008876 chr22 50603133 - 50613982 +\n", + "ENST00000043402 chr22 20241415 - 20268319 -\n", + " ... ... ...\n", + " LRG_856t2 chr22 33272509 - 33920477 -\n", + " LRG_97t1 chr22 37225270 - 37244266 -\n", + " LRG_989t1 chr22 20982297 - 20999033 +\n", "------\n", "seqinfo(1 sequences): chr22\n" ] } ], "source": [ - "# Create intronic regions (regions within genes but not in exons)\n", - "gene_ranges = by_gene.range().as_genomic_ranges() # Get the full extent of each gene\n", - "introns = gene_ranges.subtract(all_exons).as_granges()\n", + "introns = tx_ranges.subtract(all_exons, ignore_strand=True).as_granges()\n", "\n", "print(\"Intron regions:\")\n", "print(introns)" @@ -923,12 +830,12 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "To gain further insight, we can compare the proportion of peaks overlapping with exons to those overlapping with introns:" + "We can compare the proportion of peaks overlapping with exons to those overlapping with introns:" ] }, { "cell_type": "code", - "execution_count": 38, + "execution_count": 17, "metadata": {}, "outputs": [ { @@ -936,20 +843,20 @@ "output_type": "stream", "text": [ "Peaks overlapping with introns:\n", - "GenomicRanges with 1438 ranges and 0 metadata columns\n", - " seqnames ranges strand\n", - " \n", - " [0] chr22 19766788 - 19767078 *\n", - " [1] chr22 17369888 - 17370178 *\n", - " [2] chr22 19756445 - 19756735 *\n", - " ... ... ...\n", - "[1435] chr22 27212058 - 27212348 *\n", - "[1436] chr22 49201359 - 49201649 *\n", - "[1437] chr22 49663362 - 49663652 *\n", + "GenomicRanges with 1000 ranges and 0 metadata columns\n", + " seqnames ranges strand\n", + " \n", + " [0] chr22 19766788 - 19767078 *\n", + " [1] chr22 17369888 - 17370178 *\n", + " [2] chr22 19756445 - 19756735 *\n", + " ... ... ...\n", + "[997] chr22 36626768 - 36627058 *\n", + "[998] chr22 48833277 - 48833567 *\n", + "[999] chr22 49663362 - 49663652 *\n", "------\n", "seqinfo(46 sequences): chr1 chr10 chr11 ... chrUn_KI270750v1 chrUn_KI270752v1 chrX\n", "Percentage of peaks overlapping with exons: 19.36%\n", - "Percentage of peaks overlapping with introns: 99.79%\n" + "Percentage of peaks overlapping with introns: 69.40%\n" ] } ], @@ -973,16 +880,15 @@ "metadata": {}, "source": [ "```{note}\n", - "These percentages add up to over 100% because some peaks overlap both introns and exons, depending on how wide the peaks are. Ideally, you may want to filter the peaks based on preference as you annotate them with TSS, promoters, etc.\n", + "These percentages may or may not add up to 100%. Some peaks may overlap both introns and exons depending on how wide they are. In our case its because of ignoring strands and finding global intronic regions. Ideally, you may want to filter the peaks based on preference as you annotate them with TSS, promoters, etc.\n", "```\n", "\n", "This comparison can help determine if the protein of interest shows a preference for binding in exonic or intronic regions, which could suggest different functional roles (e.g., splicing regulation for exonic binding vs. potential enhancer activity for intronic binding).\n", "\n", - "### 4.2 Finding Overlaps with the first exon\n", + "### 5.2 Find overlaps with the first exon\n", "\n", "```{note}\n", - "- This analysis is performed by transcript.\n", - "- The rationale for this analysis may vary, but we are mostly showcasing complex genomic operations that are possible with the package.\n", + "The rationale for this analysis may vary, but we are mostly showcasing complex genomic operations that can be performed.\n", "```\n", "\n", "Let's first put together a `GenomicRanges` object containing the first exon for each transcript." @@ -990,7 +896,7 @@ }, { "cell_type": "code", - "execution_count": 39, + "execution_count": 18, "metadata": {}, "outputs": [], "source": [ @@ -1007,12 +913,12 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Then we combine all the individual genomic elements. The [biocutils](https://github.com/BiocPy/BiocUtils) package provides utilities for convenient aspects of R that aren't provided by base Python and generics. One of these generics is the `'combine'` operation that merges or concatenates various Bioconductor classes." + "Then we combine all the individual genomic elements. The [biocutils](https://github.com/BiocPy/BiocUtils) package provides utilities for convenient aspects of R that aren't provided by base Python and generics. One of these generics is the `combine_sequences` operation that merges or concatenates 1-dimensional Bioconductor classes." ] }, { "cell_type": "code", - "execution_count": 40, + "execution_count": 19, "metadata": {}, "outputs": [], "source": [ @@ -1024,12 +930,12 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "We can now subset peaks that overlap with the first exon" + "We can now subset peaks that overlap with the first exon:" ] }, { "cell_type": "code", - "execution_count": 41, + "execution_count": 20, "metadata": {}, "outputs": [ { @@ -1060,12 +966,17 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "### 4.3 Resizing and Shifting Peaks" + "### 4.3 Resizing and Shifting Peaks\n", + "\n", + "Resizing and shifting genomic ranges can be useful in various contexts. For example:\n", + "\n", + "- Narrowing peaks might help focus on the center of ChIP-seq binding sites.\n", + "- Shifting ranges can be used to look at regions adjacent to your features of interest. e.g., defining the predicted CRISPR cleavage site based on the position of the CRISPR gRNA sequence." ] }, { "cell_type": "code", - "execution_count": 42, + "execution_count": 21, "metadata": {}, "outputs": [ { @@ -1100,26 +1011,19 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Resizing and shifting genomic ranges can be useful in various contexts. For example:\n", - "\n", - "- Narrowing peaks might help focus on the center of ChIP-seq binding sites.\n", - "- Shifting ranges can be used to look at regions adjacent to your features of interest. e.g. defining the predicted CRISPR cleavage site based on the position of the CRISPR gRNA sequence.\n", - "\n", "These operations demonstrate the flexibility of genomic range manipulations, which can be useful for fine-tuning analyses or testing hypotheses about the spatial relationships between genomic features.\n", "\n", - "## 5. Exercises\n", + "## 6. Exercises\n", "\n", - "1. Calculate the average width of the ChIP-seq peaks on chromosome 22.\n", - "2. Determine how many peaks overlap with CpG islands.\n", - "3. Compute the percentage of promoter regions that have at least one overlapping ChIP-seq peak.\n", + "1. Split the input genome reference by `gene_name`, e.g. a field that contains gene symbols.\n", + "2. Calculate the average width of the ChIP-seq peaks on chromosome 22.\n", + "4. Compute the percentage of promoter regions that have at least one overlapping ChIP-seq peak.\n", "\n", "## Conclusion\n", "\n", "In this tutorial, we've explored how to use BiocPy's genomic ranges functionality to perform various genomic analyses. These tools and techniques provide a powerful way to work with genomic interval data in Python, mirroring the capabilities from Bioconductor. They form the foundation for many more complex genomic analyses and can be applied to a wide range of biological questions.\n", "\n", - "```{note}\n", - "Refer to the [BiocPy documentation](https://biocpy.github.io/) for more detailed information on these packages and their functionalities.\n", - "```" + "Refer to the [BiocPy documentation](https://biocpy.github.io/) for more detailed information on these packages and their functionalities.\n" ] } ], diff --git a/tutorials/annotate_cell_types.qmd b/tutorials/annotate_cell_types.qmd index 7b1b02d..73a5da2 100644 --- a/tutorials/annotate_cell_types.qmd +++ b/tutorials/annotate_cell_types.qmd @@ -4,12 +4,11 @@ Welcome to this tutorial on annotating single-cell datasets with reference colle ## Outline -In this tutorial, you will learn how to: +In this tutorial, we'll walk through how to: -1. Install and set up BiocPy packages in your Python environment. -2. Explore the `scrnaseq` package and access public single-cell RNA-seq datasets. -3. Perform basic operations on `SingleCellExperiment` objects, the core data structure for single-cell data. -4. Annotate cell types using reference datasets from the `celldex` package. +1. Explore the `scrnaseq` package and access public single-cell RNA-seq datasets. +2. Perform basic operations on `SingleCellExperiment` objects, the core data structure for single-cell data. +3. Annotate cell types using reference datasets from the `celldex` package. ## Prerequisites @@ -18,37 +17,35 @@ Before we begin, please ensure that you have the following prerequisites install - Python 3.8 or later with dependencies listed [here](https://github.com/BiocPy/BiocWorkshop2024/blob/master/requirements.txt). - R 4.4.0 and Bioconductor packages listed [here](https://github.com/BiocPy/BiocWorkshop2024/blob/master/rpackages.R). -## Installation - -Let's start by installing the required packages. +Install the Python packages using pip: ::: {.panel-tabset} -## Python (shell) - +## Shell ```sh pip install scrnaseq celldex singler ``` +::: -This will install the `scrnaseq`, `celldex`, `singler` packages from PyPI. +Install the R packages using BiocManager: + + +::: {.panel-tabset} ## R ```r BiocManager::install(c("scRNAseq", "celldex", "SingleR"), repos='http://cran.us.r-project.org') ``` - -This will install the `scRNAseq`, `celldex`, `SingleR`, packages from Bioconductor. - ::: -## 1. Accessing and Exploring Single-Cell Datasets +## 1. Accessing and exploring single-cell datasets -Now that we have the necessary packages installed, let's explore the `scrnaseq` package and learn how to access public single-cell RNA-seq datasets. Datasets published to the `scrnaseq` package are decorated with metadata such as the study title, species, number of cells, etc., to facilitate discovery. Let's see how we can list and search for datasets. +Let's explore the `scrnaseq` package and learn how to access public single-cell RNA-seq datasets. Datasets published to the `scrnaseq` package are decorated with metadata such as the study title, species, number of cells, etc., to facilitate discovery. Let's see how we can list and search for datasets. -### 1.1 List All Datasets +### 1.1 List all datasets -The `list_datasets()` function in Python or `surveyDatasets()` in R will display all available datasets published to the `scRNAseq` collection along with their metadata. +The `list_datasets()` function in Python or `surveyDatasets()` in R will display all available datasets published to the `scRNAseq` collection along with their metadata. To list all available datasets in the `scrnaseq` package and displays their names, titles, and versions: ::: {.panel-tabset} @@ -68,12 +65,12 @@ head(all_ds[, c("name", "title", "version")], 3) ::: -This lists all available datasets in the `scrnaseq` package and displays their names, titles, and versions. - -### 1.2 Search for Datasets +### 1.2 Search for datasets You can also search for datasets based on metadata using `search_datasets()` in Python or `searchDatasets()` in R. This supports both simple text queries and complex boolean expressions. +Let's search for datasets containing the term "pancreas" and displays their names, titles, and versions. + ::: {.panel-tabset} ## Python @@ -92,9 +89,7 @@ head(pancreas_ds[, c("name", "title", "version")], 3) ::: -This R|Python code searches for datasets containing the term "pancreas" and displays their names, titles, and versions. - -#### 1.2.1 Advanced Searches +#### 1.2.1 Advanced searches For more complex searches involving boolean operations, use `define_text_query()` in Python or `defineTextQuery()` in R. Here's an example to find datasets using the mouse reference genome (`GRCm38`) and containing the words `neuro` or `pancrea`. @@ -142,7 +137,7 @@ Once a dataset is identified, always list the name and version of the dataset in After identifying a dataset of interest, use `fetch_dataset()` in Python or `fetchDataset()` in R to download the dataset. This will load the dataset as a `SingleCellExperiment` object. ::: {.callout-note} -R/Bioconductor users might already be familiar with the [SingleCellExperiment](https://bioconductor.org/packages/release/bioc/html/SingleCellExperiment.html) class. BiocPy also provides the same implementation in the [singlecellexperiment](https://github.com/BiocPy/SingleCellExperiment) package. +R/Bioconductor users might already be familiar with the [SingleCellExperiment](https://bioconductor.org/packages/release/bioc/html/SingleCellExperiment.html) class. BiocPy also provides similar implementation in the [singlecellexperiment](https://github.com/BiocPy/SingleCellExperiment) package. ::: For this tutorial, let's download the `zeisel-brain` dataset: @@ -167,7 +162,7 @@ sce ### 2.1 Side-quest on `SingleCellExperiment` in Python -The Python implementation of the `SingleCellExperiment` class adheres to Bioconductor's specification and offers similar interface and methods. Our goal is to make it simple for analysts to switch between R and Python. A key difference is the shift from functional to an object-oriented paradigm. +The Python implementation of the `SingleCellExperiment` class adheres to Bioconductor's specification and offers similar interface and methods. Our goal is to make it simple for analysts to switch between R and Python. ::: {.callout-note} For more details on the design, refer to the [BiocPy developer guide](https://github.com/BiocPy/developer_guide) or the [singlecellexperiment](https://github.com/BiocPy/SingleCellExperiment) documentation. @@ -175,31 +170,69 @@ For more details on the design, refer to the [BiocPy developer guide](https://gi This Python code demonstrates basic operations on a `SingleCellExperiment` object, including retrieving assay names, column names, column metadata, accessing counts, and coercing to an `AnnData` object for interoperability with existing analysis ready eco-systems in Python. +To display assays names from the object: + ::: {.panel-tabset} ## Python ```{python} -print("assays: ", sce.get_assay_names()) # or sce.assay_names +print("Assays names: ", sce.get_assay_names()) # or sce.assay_names +``` + +::: -print("column names: ", sce.get_column_names()) # or sce.column_names +To access cell barcodes or ids: -print("column metadata: ", sce.get_column_data()) # or sce.column_data +::: {.panel-tabset} + +## Python -print("access counts: ", sce.assays["counts"]) # or # sce.assay("counts") +```{python} +print("Cell barcodes (first 10): ", sce.get_column_names()[:10]) # or sce.column_names ``` -:::{.callout-note} -The package uses [delayed arrays](https://github.com/biocpy/delayedarray), to load file-backed arrays and matrices. This reduces memory usage when loading large datasets. This package provides similar functionality to the R/Bioconductor's [DelayedArray](https://www.bioconductor.org/packages/release/bioc/html/DelayedArray.html) eco-system. ::: +To access all cell annotations: + +::: {.panel-tabset} + +## Python + +```{python} +print("Column metadata: ", sce.get_column_data()) # or sce.column_data +``` +::: + +To access an assay matrix: + +::: {.panel-tabset} +## Python + +```{python} +print("Counts matrix: ", sce.assays["counts"]) # or # sce.assay("counts") +``` +::: + +The package uses [delayed arrays](https://github.com/biocpy/delayedarray) (similar to the R/Bioconductor's [DelayedArray](https://www.bioconductor.org/packages/release/bioc/html/DelayedArray.html)), to load file-backed arrays and matrices. This reduces memory usage when loading large datasets. Methods are available to coerce delayed arrays to [sparse matrix representations](https://docs.scipy.org/doc/scipy/reference/sparse.html) from the scipy package: + +::: {.panel-tabset} + +## Python + ```{python} from delayedarray import to_scipy_sparse_matrix print("counts as csr: ") print(repr(to_scipy_sparse_matrix(sce.assays["counts"], "csc"))) ``` +::: + +To simplify this, we provide the `realize_assays` option to load matrices fully into memory when fetching the dataset. + +::: {.panel-tabset} -or realize the entire matrix when loaded from disk, +## Python ```{python} sce = scrnaseq.fetch_dataset( @@ -207,8 +240,13 @@ sce = scrnaseq.fetch_dataset( realize_assays=True) print(sce) ``` +::: + +In addition, we provide coercions from `SingleCellExperiment` class to take advantage of methods in the Python ecosystem, e.g. scverse and AnnData. + +::: {.panel-tabset} -We also provide coercions to various package to take advantage of methods in the Python ecosystem, e.g. scverse and AnnData +## Python ```{python} print("coerce to AnnData: ", sce.to_anndata()) @@ -216,20 +254,16 @@ print("coerce to AnnData: ", sce.to_anndata()) ::: -## 3. Annotate Cell Types +## 3. Annotate cell types -We can now annotate cell types by using reference datasets and matching cells based on their expression profiles. In this tutorial, we will use [singleR](https://github.com/SingleR-inc/SingleR) in R or its Python equivalent [singler](https://github.com/BiocPy/singler). +We can now annotate cell types by using reference datasets and matching cells based on their expression profiles. In this tutorial, we will use [SingleR](https://github.com/SingleR-inc/SingleR) in R or its Python equivalent [singler](https://github.com/BiocPy/singler). Before running the `singler` algorithm, we need to download an appropriate reference dataset from the `celldex` package. -### 3.1 Access Reference Datasets from `celldex` +### 3.1 Access reference datasets from `celldex` Similar to the `scRNAseq` package, the `celldex` package provides access to the collection of reference expression datasets with curated cell type labels, for use in procedures like automated annotation of single-cell data or deconvolution of bulk RNA-seq to reference datasets. These datasets are also stored in language-agnostic representations for use in downstream analyses. -::: {.callout-note} -The `celldex` package is available on [R/Bioconductor](https://bioconductor.org/packages/devel/data/experiment/html/celldex.html) and [PyPI](https://github.com/BiocPy/celldex). -::: - For this tutorial, let's download the [Mouse RNA-seq](https://www.immgen.org/) reference from `celldex` using `fetch_reference()` in Python or `fetchReference()` in R. This reference consists of a collection of mouse bulk RNA-seq data sets downloaded from the gene expression omnibus ([Benayoun et al. 2019](https://doi.org/10.1101/gr.240093.118)). A variety of cell types are available, again mostly from blood but also covering several other tissues. ::: {.panel-tabset} @@ -252,7 +286,7 @@ mouse_rnaseq_ref ``` ::: -Now, let's identify cells from the `zeisel-brain` dataset using the `mouse_rnaseq` reference dataset. +Now, let's annotate cells from the `zeisel-brain` dataset using the `mouse_rnaseq` reference dataset. ::: {.panel-tabset} @@ -278,41 +312,51 @@ cell_labels <- SingleR(test = assay(sce, "counts"), ref = mouse_rnaseq_ref, labe table(cell_labels$labels) ``` - ::: -## 4. Analyze Single-cell RNA-seq datasets +Give this is a brain dataset, the presence of neuron's and other brain-related cell types makes sense. + + +## 4. Analyze single-cell RNA-seq datasets ![single-cell-methods](../assets/single-cell-space.jpg) -Aaron has implemented the single-cell methods from scran in C++. This allows us to reuse the same implementation in JS and develop applications for analyzing single-cell data ([Kana](https://github.com/kanaverse/kana)), or in Python through the [scranpy](https://github.com/BiocPy/scranpy) package. This avoids different interpretations of the analysis results by switching programming languages (Pachter et al, [The impact of package selection and versioning on single-cell RNA-seq analysis | bioRxiv](https://www.biorxiv.org/content/10.1101/2024.04.04.588111v1) ) +Aaron has implemented the single-cell methods from scran in C++. This allows us to reuse the same implementation in JS and develop applications for analyzing single-cell data ([Kana](https://github.com/kanaverse/kana)), or in Python through the [scranpy](https://github.com/BiocPy/scranpy) package. +To analyze the dataset using the default parameters: -To analyze the dataset, +::: {.panel-tabset} +## Python ```{python} import scranpy results = scranpy.analyze_sce(sce) -# results is a complex object, lets explore the umap and tsne dimensions +# results is a complex object, +# let's explore the umap and tsne dimensions print(results.tsne) ``` +::: -### 4.1 Seems like magic? +### 4.1 Want to know whats happening in the entire analysis Running the `analyze_sce()` function uses the default parameters to run the single-cell workflow. If you want to customize or want to have fine-grained control on the analysis steps, set the parameter `dry_run=True`. :::{.callout-note} -This prints out the exact series of steps the function does under the hood to perform the analysis. You can then use this to customize the analysis to your specific dataset or use case. +This prints out the exact series of steps the function runs under the hood to perform the analysis. You can then use this to customize the analysis to your specific dataset or use case. ::: +::: {.panel-tabset} + +## Python ```{python} print(scranpy.analyze_sce(sce, dry_run=True)) ``` +::: :::{.callout-tip} -Users can also run individual steps from the analysis without having to perform the full analysis, e.g. compute log normalized counts or find markers, etc. +Users can also run individual steps from the analysis without having to perform the full analysis, e.g. compute log-normalized counts or find markers. ::: ## 5. Visualize Results @@ -321,38 +365,61 @@ I can't have a tutorial without a section on visualization or figures. We will use the seaborn and matplotlib packages in Python to create visualizations. We'll plot the t-SNE embedding and color the cells by their cluster assignments. +::: {.panel-tabset} + +## Python ```{python} import seaborn as sns sns.scatterplot( x=results.tsne.x, y=results.tsne.y, - hue=results.clusters, palette="deep" + hue=results.clusters, palette="Paired" ) ``` +::: -or the UMAP embedding with the cell types we identified from `celldex` +Now's lets color the embedding with the cell types we identified from `celldex`. We ran the singleR algorithm on the full datasets, but scranpy filtered a few cells during the QC step. Lets identify which cells were kept. +::: {.panel-tabset} +## Python +```{python} +to_keep = [i for i,x in enumerate(results.rna_quality_control_filter) if x == False] +filtered_matches = [matches["best"][i] for i in to_keep] +``` +::: + +::: {.panel-tabset} + +## Python ```{python} import seaborn as sns sns.scatterplot( - x=results.umap.x, y=results.umap.y, - hue=matches["best"][:3002], palette="deep" + x=results.tsne.x, y=results.tsne.y, + hue=filtered_matches, palette="Paired" ) ``` +::: + +Similarly also explore the UMAP embedding: -:::{.callout-caution} -During the QC step, some cells were filtered, hence we filter the matches and this is incorrect (since we don't know which cells were filtered). +::: {.panel-tabset} -We'll leave this as an exercise for the reader to change the order of steps: 1) run the dataset through the QC step 2) filter cells, and then 3) annotate using singleR. +## Python +```{python} +import seaborn as sns +sns.scatterplot( + x=results.umap.x, y=results.umap.y, + hue=filtered_matches, palette="Paired" +) +``` ::: ## 6. Exercises -1. Share or Upload your datasets to scrna-seq, Instructions to upload are available in their respective [R/Bioc](https://bioconductor.org/packages/release/data/experiment/html/scRNAseq.html) and [Python](https://github.com/BiocPy/scrnaseq) packages. +1. Share or upload your datasets to scrna-seq package. Instructions to upload are available in their respective [R/Bioc](https://bioconductor.org/packages/release/data/experiment/html/scRNAseq.html) and [Python](https://github.com/BiocPy/scrnaseq) packages. 2. Explore top markers for each cluster identified by scranpy. -3. Perform multi-modal analysis (scranpy supports RNA, ADT, CRISPR). -4. save your results and explore in [Kana](https://github.com/kanaverse/kana). +3. Save your results and explore in [Kana](https://github.com/kanaverse/kana). -Congratulations! You have now completed the tutorial on accessing single-cell datasets using `scRNAseq` and `ArtifactDB`, and annotating cell types using reference datasets from `celldex`. For more detailed usage and advanced analyses, refer to the respective documentation of these packages. +## Conclusion -By integrating R and Python workflows, you can leverage the strengths of both languages and perform comprehensive single-cell analysis. Keep exploring and happy analyzing! \ No newline at end of file +Congratulations! You have now completed the tutorial on accessing single-cell datasets using `scRNAseq` and `ArtifactDB`, and annotating cell types using reference datasets from `celldex`. For more detailed usage and advanced analyses, refer to the respective documentation of these packages. \ No newline at end of file diff --git a/tutorials/genomic_ranges.qmd b/tutorials/genomic_ranges.qmd index 9be7102..dc0a0b4 100644 --- a/tutorials/genomic_ranges.qmd +++ b/tutorials/genomic_ranges.qmd @@ -1,46 +1,51 @@ # Tutorial 1: `GenomicRanges` and range-based analyses -Genomic range operations are fundamental to many bioinformatics analyses. They allow us to work with intervals of genomic coordinates, which is crucial for understanding the relationships between different genomic features such as genes, regulatory elements, and experimental data like ChIP-seq peaks. In this tutorial, we'll explore how to work with genomic interval data using BiocPy's [GenomicRanges](https://github.com/BiocPy/GenomicRanges/) package, which provides Python implementations similar to the R/Bioconductor [GenomicRanges package](https://github.com/Bioconductor/GenomicRanges). +Genomic range operations are fundamental to many bioinformatics analyses. They allow us to work with intervals of genomic coordinates, which is crucial for understanding the relationships between different genomic features such as genes, regulatory elements, and experimental data like ChIP-seq peaks. In this tutorial, we'll explore how to work with genomic interval data using BiocPy's [GenomicRanges](https://github.com/BiocPy/GenomicRanges/) package, which provides a Python implementation of the R/Bioconductor [GenomicRanges package](https://github.com/Bioconductor/GenomicRanges). ## Outline -In this workshop, we'll walk through several key aspects of working with genomic ranges in Python: +In this workshop, we'll walk through several aspects of working with genomic ranges in Python: -1. Reading Genomic Data: We'll start by reading in genomic data from RDS files, including exon positions grouped by transcripts. -2. Basic Genomic Operations: We'll cover fundamental operations like finding transcription start sites (TSS) and promoter regions. -3. Overlap Analysis: We'll learn how to find overlaps between different genomic features, a common task in many analyses. -4. Advanced Operations: We'll explore more complex operations like finding peaks within specific regions and resizing genomic intervals. +1. **Reading genomic data**: we'll start by reading in genomic data from RDS files, including exon positions grouped by transcripts. +2. **Basic genomic operations**: we'll cover fundamental operations like finding transcription start sites (TSS) and promoter regions. +3. **Overlap analysis**: we'll learn how to find overlaps between different genomic features, a common task in many analyses. +4. **Advanced operations**: we'll explore more complex operations like finding peaks within specific regions and resizing genomic intervals. ## Prerequisites -Before we begin, please ensure that you have the following packages installed: +Before we begin, please ensure that you have the following prerequisites installed: -### Installation +- Python 3.8 or later with dependencies listed [here](https://github.com/BiocPy/BiocWorkshop2024/blob/master/requirements.txt). +- R 4.4.0 and Bioconductor packages listed [here](https://github.com/BiocPy/BiocWorkshop2024/blob/master/rpackages.R). -Let's start by installing the required packages for R and Python. -::: {.panel-tabset} +Install the Python packages using pip: -## Python (shell) +::: {.panel-tabset} -You can install the Python packages using pip: +## Shell ```sh pip install -U biocutils genomicranges rds2py numpy pandas geniml ``` +::: + +Install the R packages using `BiocManager`: + +::: {.panel-tabset} ## R ```r -BiocManager::install(c("AnnotationHub"), - repos='http://cran.us.r-project.org') +BiocManager::install(c("AnnotationHub")) ``` - ::: -## 1. Save Annotations as RDS +## 1. Download reference annotation + +Insead of reinventing the wheel to access references in Python, we'll use existing available Bioconductor resources that provide access to genome annotations. `AnnotationHub` is a great resource providing access to genomic reference annotations. It's super convenient to search for a reference from `AnnotationHub` and download the genome of interest. -Let's download the human reference genome and save the exon positions grouped by transcripts. For the purpose of the tutorial, we'll limit the exons to chromosome 22. +Let's search the latest ensembl database for the human reference genome using Bioconductor's `AnnotationHub`. ::: {.panel-tabset} @@ -51,27 +56,38 @@ suppressMessages(library(AnnotationHub)) ah <- AnnotationHub() ensdb <- query(ah, "Ensembl 112 EnsDb for Homo sapiens")[[1]] +``` +::: + +We will then extract the exon positions and group them by transcript. Additionally, we provide a list of column names we would like to be available in `mcols` for our analysis. For the purpose of this tutorial, we'll limit ourselves to the exons from chromosome 22. + +::: {.panel-tabset} + +## R + +```r exons_by_tx <- exonsBy(ensdb, by = "tx", filter = SeqNameFilter(c("22")), columns= c("exon_id", "tx_name", "tx_id", "gene_name", "gene_id")) -saveRDS(exons_by_tx, "hg38_exons_by_tx.rds") ``` - ::: -## 2. Reading RDS files in Python +Finally, save the object as an RDS file. -The [rds2py](https://github.com/biocpy/rds2py) Python package allows us to read RDS files and create equivalent Python representations of R objects. Key features include: +::: {.panel-tabset} -- Parsing common R objects into Python equivalents (e.g., matrices to NumPy arrays, data frames to Pandas DataFrames). -- Ability to read S4 classes, enabling direct parsing of Bioconductor data types from R to Python. +## R -Reading an RDS file with rds2py involves two steps: +```r +saveRDS(exons_by_tx, "hg38_exons_by_tx.rds") +``` +::: + +## 2. Load genome annotation in Python -1. Parse the RDS file into a Python dictionary containing data, its attributes, and associated metadata. -2. Convert this dictionary into a suitable Python object using specific parser functions. +We now read the above RDS annotation object into our Python session using the [rds2py](https://github.com/biocpy/rds2py) Python package. This is a two step process. -This process allows a seamless transition between R and Python for bioinformatics analyses. +The first step represents the data stored in the RDS file as a python dictionary ::: {.panel-tabset} @@ -80,92 +96,84 @@ This process allows a seamless transition between R and Python for bioinformatic from rds2py import read_rds hg38_robject = read_rds("./hg38_exons_by_tx.rds") -from rds2py.granges import as_granges_list -by_tx = as_granges_list(hg38_robject) - -print("Exons by transcript:") -print(by_tx) +# Only printing the keys +print("Keys of the object:", hg38_robject.keys()) +print("Class name of the object:", hg38_robject["class_name"]) ``` - ::: -## 2. Basic Genomic Operations - -Now, let's perform some basic operations like finding Transcription Start Sites (TSS) and promoter regions. These operations are fundamental in genomic analysis as they help us identify key regulatory regions of the genome. - -### 2.1 Create a `GenomicRangesList` by gene - -To identify TSS or define promoter regions, let's first reprocess the input to create a `GenomicRangesList` by gene symbols. +This object (`hg38_robject`) can then be coerced into a Python `GenomicRangesList` class. ::: {.panel-tabset} ## Python - -To achieve this, we unlist the `GenomicRangesList` object. This is accomplished in Python using the `as_genomic_ranges()` method. - ```{python} -all_ranges = by_tx.as_genomic_ranges() -``` +from rds2py import read_rds +hg38_robject = read_rds("./hg38_exons_by_tx.rds") -Then we split the object using the `gene_name` metadata column in `mcols()`. +# TODO: split this into two +from rds2py.granges import as_granges_list +by_tx = as_granges_list(hg38_robject) -:::{.callout-important} -We provide accessors to get or set attributes of the class. Most folks in Python may be familiar with direct access to class members (via properties or @property), but this should generally be avoided, as it is too easy to perform modifications via one-liners with the class.property on the left-hand side of an assignment. +print("Exons by transcript:") +print(by_tx) +``` -For more information, please refer to our [developer guide](https://github.com/BiocPy/developer_guide). ::: :::{.callout-note} -While gene IDs are unique, gene symbols are not. In addition, this list has genes with no symbols. +Currently this is a two step process, we are working on simplifying this to a one step process for supported Bioconductor classes. ::: -```{python} -by_gene = all_ranges.split( - groups=all_ranges.get_mcols().get_column("gene_name") -) +## 3. Define promoters and TSS -print("Exons by gene:") -print(by_gene) -``` -::: +Now, let's perform some basic operations like finding transcription start sites (TSS) and promoter regions. These operations help us identify key regulatory regions of the genome. -### 2.2 Finding Transcription Start Sites (TSS) +### 3.1 Find transcription start sites (TSS) Transcription Start Sites (TSS) are the locations where transcription of a gene begins. Identifying TSS is crucial for understanding gene regulation, as many regulatory elements are located near the TSS. -::: {.panel-tabset} +First, we use the `range()` method to get the full extent of each transcript. This should give us exactly one range per transcript. -Let's use the `range()` method to get the full extent of each gene. +::: {.panel-tabset} ## Python ```{python} -ranges_by_gene = by_gene.range() +ranges_by_tx = by_tx.range() -print("Gene ranges:") -print(ranges_by_gene) +print("Transcript ranges:") +print(ranges_by_tx) ``` +::: + +Since the range gives us exactly one range per transcript, so we can simplify our list to a `GenomicRanges` object. This is similar to `unlist` in R. -We convert the list to a `GenomicRanges` object. +::: {.panel-tabset} +## Python ```{python} -gr_by_gene = ranges_by_gene.as_genomic_ranges() +gr_by_tx = ranges_by_tx.as_genomic_ranges() print("as GenomicRanges:") -print(gr_by_gene) +print(gr_by_tx) ``` +::: Then we resize to a width of 1 base pair at the start of each range to pinpoint the TSS. +::: {.panel-tabset} + +## Python ```{python} -tss = gr_by_gene.resize(width=1, fix="start") +tss = gr_by_tx.resize(width=1, fix="start") print("Transcript Start Sites:") -print(gr_by_gene) +print(tss) ``` ::: -### 2.3 Defining Promoter Regions +### 3.2 Define promoter regions Here, we're defining promoters as the region 2000 base pairs upstream to 200 base pairs downstream of each TSS. This definition can vary depending on the specific analysis, but this range often captures important regulatory elements. @@ -179,21 +187,17 @@ print("Promoter Regions:") print(promoters) ``` -:::{.callout-note} -Please be aware that because gene symbols may not be unique, this `GenomicRanges` object might contain duplicates. You might want to resolve duplicate symbols by making the symbols unique. We will leave this as an exercise for the reader. -::: - ::: -## 3. Overlap Analysis +## 4. Overlap with ChIP-seq peaks A common task in genomic analysis is finding overlaps between different genomic features. This helps us understand the relationships between various elements in the genome and can provide insights into gene regulation and function. -### 3.1 Reading ChIP-seq Peaks +### 4.1 Load ChIP-seq peaks -ChIP-seq (Chromatin Immunoprecipitation followed by sequencing) is a method used to identify binding sites of DNA-associated proteins. The peaks represent regions where a protein of interest is likely bound to the DNA. We're focusing on chromosome 22 for this example to keep the dataset manageable. +ChIP-seq (Chromatin Immunoprecipitation followed by sequencing) is a method used to identify binding sites of DNA-associated proteins. The peaks represent regions where a protein of interest is likely bound to the DNA. -For the purpose of this tutorial, let's download a bed file containing peaks from a ChIP-seq experiment on "Human B cells" to identify "EZH2" binding sites (from ENCODE) and cataloged in [bedbase.org](https://bedbase.org/bed/be4054acf6e3feeb4dc490e6430e358e). +For the purpose of this tutorial, let's download a bed file containing peaks from a ChIP-seq experiment on human B cells to identify EZH2 binding sites (from ENCODE) and catalogued in [bedbase.org](https://bedbase.org/bed/be4054acf6e3feeb4dc490e6430e358e). ::: {.panel-tabset} @@ -204,6 +208,16 @@ from geniml.bbclient import BBClient bbclient = BBClient(cache_folder="cache", bedbase_api="https://api.bedbase.org") bedfile_id = "be4054acf6e3feeb4dc490e6430e358e" bedfile = bbclient.load_bed(bedfile_id) +``` + +::: + +Our friends at bedbase (Nathan Sheffield et al.) provide methods to easily coerce these objects to `GenomicRanges`. Again, we're focusing on chromosome 22 for this example to keep the dataset manageable. + +::: {.panel-tabset} + +## Python +```{python} peaks = bedfile.to_granges() filter_chr22 = [x == "chr22" for x in peaks.get_seqnames()] @@ -214,7 +228,7 @@ print(peaks_chr22) ::: -### 3.2 Finding Overlaps with TSS +### 4.2 Find overlaps with TSS Here, we're identifying ChIP-seq peaks that overlap with TSS. This analysis can help us understand if the protein of interest tends to bind near the start of genes, which could suggest a role in transcription initiation. @@ -225,9 +239,10 @@ Here, we're identifying ChIP-seq peaks that overlap with TSS. This analysis can ```{python} overlaps = peaks_chr22.find_overlaps(tss) -print("Peak indices that overlap with first 10 TSS:") -print(overlaps[:10]) +print("Peak indices that overlap with TSS between 30-40:") +print(overlaps[30:40]) ``` +::: :::{.callout-note} `find_overlaps` returns a `list` with the same length as TSS, indicating which indices from peaks overlap with each of the TSS. Ideally, we would want to return a `Hits` object similar to the Bioconductor implementation. @@ -235,8 +250,11 @@ print(overlaps[:10]) **TODO: Future plans to convert this into a `Hits` object.** ::: -Let's identify the peaks that overlap with TSS. +Let's identify the peaks that overlap with any TSS. + +::: {.panel-tabset} +## Python ```{python} import itertools @@ -244,30 +262,22 @@ all_indices = list(set(itertools.chain.from_iterable(overlaps))) peaks_by_tss = peaks_chr22[all_indices] print(peaks_by_tss) ``` +::: -Instead, one can subset peaks that overlap with TSS using the `subset_by_overlaps` method: +Alternatively, we can use `subset_by_overlaps` method to more conveniently overlap the peaks that overlap with any TSS: + +::: {.panel-tabset} +## Python ```{python} peaks_by_tss2 = peaks_chr22.subset_by_overlaps(tss) print(peaks_by_tss2) ``` - -Additionally, in some cases, we may want to ignore strand information (`ignore_strand=True`) when finding overlaps. - -```{python} -peaks_by_tss_ignoring_strand = peaks_chr22.subset_by_overlaps(tss, ignore_strand=True) -print(peaks_by_tss_ignoring_strand) -``` - -:::{.callout-note} -This yields the same results for this particular scenario, but may not if the 'peaks' contain strand information. ::: -::: +### 4.3 Find overlaps with promoters -### 3.3 Finding Overlaps with Promoters - -This operation finds ChIP-seq peaks that overlap with our defined promoter regions. If a significant number of peaks fall within promoters, it might suggest that the protein plays a role in gene regulation through promoter binding. This kind of analysis is often used to characterize the binding patterns of transcription factors or other regulatory proteins. +This operation finds ChIP-seq peaks that overlap with our defined promoter regions. If a significant number of peaks fall within promoters, it might suggest that the protein plays a role in gene regulation. ::: {.panel-tabset} @@ -282,9 +292,9 @@ print(peaks_by_promoters) ::: -### 3.4 Finding Overlaps with Exons +### 4.4 Find overlaps with exons -Another analysis is to look at overlaps with all exons. This can help identify potential roles of the ChIP-seq peaks in splicing. Let's modify our analysis to look at all exons: +Lets find overlaps with any exon. We `unlist` our `GenomicRangesList` object to get all exon positions. ::: {.panel-tabset} @@ -292,8 +302,21 @@ Another analysis is to look at overlaps with all exons. This can help identify p ```{python} # Combine all exons into a single GenomicRanges object -all_exons = by_gene.as_granges() +all_exons = by_tx.as_granges() + +print("All exons:") +print(all_exons) +``` +::: + +We can then find peaks that overlap with any of these regions: + +::: {.panel-tabset} + +## Python + +```{python} # Find peaks overlapping with any exon peaks_by_exons = peaks_chr22.subset_by_overlaps(all_exons) @@ -305,34 +328,52 @@ percent_overlapping = (len(peaks_by_exons) / len(peaks_chr22)) * 100 print(f"Percentage of peaks overlapping with exons: {percent_overlapping:.2f}%") ``` - ::: -This analysis can provide insights into whether the protein of interest (captured by the ChIP-seq: "EZH2") tends to bind within gene bodies, potentially influencing gene expression, splicing, or other co-transcriptional processes. - -## 4. Advanced Operations +## 5. Advanced Operations Let's explore some more complex operations that are often used in genomic analyses. -### 4.1 Comparing Exonic vs. Intronic Binding +### 5.1 Compare exonic vs. intronic binding + +Let's first identify intron regions. There are two ways to find introns + +1. **Find introns for each gene**, regions within each gene body that do not overlap to that gene's exons (using `psetdiff` in R/Bioconductor). +2. **Find introns globally**, regions that don't overlap with any exon (using `subtract`). To find these positions, we also ignore strand information. + +We will find introns globally (2) for our tutorial today. If you are wondering why, we currently don't have `psetdiff` implemented in BiocPy/GenomicRanges. If you are interested in contributing, check out [this issue](https://github.com/BiocPy/GenomicRanges/issues/115). + +Let's first get all transcript ranges, following the steps in [Section 3.1](#find-transcription-start-sites-tss): + +::: {.panel-tabset} + +## Python + +```{python} +# Get the full extent of each gene +tx_ranges = by_tx.range().as_genomic_ranges() +``` +::: -Let's first identify intron regions. We will use the `by_gene` object we created that contains a `GenomicRangesList` split by gene. +We now subtract any exons that overlaps within each transcript by ignoring the strand. The result is a `GenomicRangesList` containing intron regions for each transcript. We simplify this by coercing this into a `GenomicRanges` object. ::: {.panel-tabset} ## Python ```{python} -# Create intronic regions (regions within genes but not in exons) -gene_ranges = by_gene.range().as_genomic_ranges() # Get the full extent of each gene -introns = gene_ranges.subtract(all_exons).as_granges() +introns = tx_ranges.subtract(all_exons, ignore_strand=True).as_granges() print("Intron regions:") print(introns) ``` +::: -To gain further insight, we can compare the proportion of peaks overlapping with exons to those overlapping with introns: +We can compare the proportion of peaks overlapping with exons to those overlapping with introns: +::: {.panel-tabset} + +## Python ```{python} # Find peaks overlapping with introns peaks_by_introns = peaks_chr22.subset_by_overlaps(introns) @@ -351,16 +392,15 @@ print(f"Percentage of peaks overlapping with introns: {percent_intronic:.2f}%") ::: :::{.callout-note} -These percentages add up to over 100% because some peaks overlap both introns and exons, depending on how wide the peaks are. Ideally, you may want to filter the peaks based on preference as you annotate them with TSS, promoters, etc. +These percentages may or may not add up to 100%. Some peaks may overlap both introns and exons depending on how wide they are. In our case its because of ignoring strands and finding global intronic regions. Ideally, you may want to filter the peaks based on preference as you annotate them with TSS, promoters, etc. ::: This comparison can help determine if the protein of interest shows a preference for binding in exonic or intronic regions, which could suggest different functional roles (e.g., splicing regulation for exonic binding vs. potential enhancer activity for intronic binding). -### 4.2 Finding Overlaps with the first exon +### 5.2 Find overlaps with the first exon :::{.callout-note} -- This analysis is performed by transcript. -- The rationale for this analysis may vary, but we are mostly showcasing complex genomic operations that are possible with the package. +The rationale for this analysis may vary, but we are mostly showcasing complex genomic operations that can be performed. ::: Let's first put together a `GenomicRanges` object containing the first exon for each transcript. @@ -375,14 +415,14 @@ for txid, grl in by_tx: all_first.append(grl.sort()[0]) ``` -Then we combine all the individual genomic elements. The [biocutils](https://github.com/BiocPy/BiocUtils) package provides utilities for convenient aspects of R that aren't provided by base Python and generics. One of these generics is the `'combine'` operation that merges or concatenates various Bioconductor classes. +Then we combine all the individual genomic elements. The [biocutils](https://github.com/BiocPy/BiocUtils) package provides utilities for convenient aspects of R that aren't provided by base Python and generics. One of these generics is the `combine_sequences` operation that merges or concatenates 1-dimensional Bioconductor classes. ```{python} from biocutils import combine_sequences first_exons = combine_sequences(*all_first) ``` -We can now subset peaks that overlap with the first exon +We can now subset peaks that overlap with the first exon: ```{python} peaks_with_first_exons = peaks_chr22.subset_by_overlaps(first_exons) @@ -391,6 +431,11 @@ print(peaks_with_first_exons) ### 4.3 Resizing and Shifting Peaks +Resizing and shifting genomic ranges can be useful in various contexts. For example: + +- Narrowing peaks might help focus on the center of ChIP-seq binding sites. +- Shifting ranges can be used to look at regions adjacent to your features of interest. e.g., defining the predicted CRISPR cleavage site based on the position of the CRISPR gRNA sequence. + ```{python} narrow_peaks = peaks_chr22.narrow(start=10, width=100) shifted_peaks = narrow_peaks.shift(10) @@ -399,18 +444,13 @@ print("Narrowed and Shifted Peaks:") print(shifted_peaks) ``` -Resizing and shifting genomic ranges can be useful in various contexts. For example: - -- Narrowing peaks might help focus on the center of ChIP-seq binding sites. -- Shifting ranges can be used to look at regions adjacent to your features of interest. e.g. defining the predicted CRISPR cleavage site based on the position of the CRISPR gRNA sequence. - These operations demonstrate the flexibility of genomic range manipulations, which can be useful for fine-tuning analyses or testing hypotheses about the spatial relationships between genomic features. -## 5. Exercises +## 6. Exercises -1. Calculate the average width of the ChIP-seq peaks on chromosome 22. -2. Determine how many peaks overlap with CpG islands. -3. Compute the percentage of promoter regions that have at least one overlapping ChIP-seq peak. +1. Split the input genome reference by `gene_name`, e.g. a field that contains gene symbols. +2. Calculate the average width of the ChIP-seq peaks on chromosome 22. +4. Compute the percentage of promoter regions that have at least one overlapping ChIP-seq peak. ## Conclusion