diff --git a/.gitignore b/.gitignore index a257a46..7cef2cc 100644 --- a/.gitignore +++ b/.gitignore @@ -88,6 +88,3 @@ venv/ docs/preconvert site/ out - -# Sphinx -_static diff --git a/.readthedocs.yml b/.readthedocs.yml new file mode 100644 index 0000000..8fd5f15 --- /dev/null +++ b/.readthedocs.yml @@ -0,0 +1,13 @@ +version: 2 + +build: + os: "ubuntu-24.04" + tools: + python: "mambaforge-22.9" + +conda: + environment: conda/environment.yml + +sphinx: + # Path to your Sphinx configuration file. + configuration: doc/conf.py diff --git a/CMakeLists.txt b/CMakeLists.txt index 1f16728..91d8b05 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -92,6 +92,8 @@ endif() # Options option(WITH_EFENCE "Build with efence library" OFF) option(WITH_TEST "Build tests" OFF) +message(STATUS "WITH_EFENCE = ${WITH_EFENCE}") +message(STATUS "WITH_TEST = ${WITH_TEST}") ################################################## # Add a library for sequence_analysis and its Python wrappers diff --git a/README.md b/README.md index 84c9701..fc84f69 100644 --- a/README.md +++ b/README.md @@ -13,11 +13,13 @@ _________________ _________________ -**sequence analysis** Basic Statistical tools used by different Structure Analysis libraries. +**sequence_analysis** is a python module for the analysis of time series (discrete time). It is mainly dedicated to the analysis of botanical sequences but can be used for general purposes. The module contains procedures for estimating semi-Markov, hidden semi-Markov, variable-order Markov and hidden variable-order Markov models. It also has procedure to estimate renewal processes and offers diverse tools to edit sets of sequences (filter, merge sets merge variables, select, etc.) + +sequence_analysis is relies on [OpenAlea](https://github.com/openalea/) and particularly the [stat_tool module](https://github.com/openalea/stat_tool) ### Contributors -Thanks to all that ontribute making this package what it is ! +Thanks to everone who ontribute making this package what it is! diff --git a/README.txt b/README.txt deleted file mode 100644 index f740a27..0000000 --- a/README.txt +++ /dev/null @@ -1,34 +0,0 @@ -openalea.sequence_analysis ------------------ - -Description ------------ - - - -Installation from source distribution -------------------------------------- - -python setup.py install - - -Compilation Tools ------------------ - -python >= 2.4 -scons >= 0.97 - -g++ >= 3.0 (on linux) -mingw (on windows) - -openalea.config >= 0.2 -openalea.sconsx >= 0.4 -openalea.distx >= 0.3 - -qt >= 4.2 (on windows) - - -Dependencies ---------------------- - -openalea.stat_tool diff --git a/TODO b/TODO new file mode 100644 index 0000000..271b43d --- /dev/null +++ b/TODO @@ -0,0 +1,2 @@ +[ ] Remove plots from pytests +[ ] Make a list from tests to be updated diff --git a/conda/environment.yml b/conda/environment.yml index 6b13b67..a0898a4 100644 --- a/conda/environment.yml +++ b/conda/environment.yml @@ -1,6 +1,7 @@ name: sequence_analysis_dev channels: - conda-forge + - openalea3/label/dev - openalea3 dependencies: - python @@ -8,6 +9,7 @@ dependencies: - boost - matplotlib-base - openalea.stat_tool + - compilers + - doxygen - pip: - -e '..[test,dev,doc]' - diff --git a/conda/meta.yaml b/conda/meta.yaml index 38ba187..8b5ad25 100644 --- a/conda/meta.yaml +++ b/conda/meta.yaml @@ -33,13 +33,13 @@ requirements: {% for dep in build_deps %} - {{ dep }} {% endfor %} - - cmake - - make # [not win] - openalea.stat_tool - boost build: - {{ compiler("cxx") }} + - cmake + - make # [not win] run: - python @@ -62,7 +62,9 @@ test: source_files: - test/ commands: - - pytest + - cd test + - pytest -v --ignore=aml # [not win] + about: @@ -74,3 +76,5 @@ about: extra: recipe-maintainers: - Jean-Baptiste Durand + - Thomas Arsouze + - Christophe Pradal diff --git a/doc/_static/openalea_web.svg b/doc/_static/openalea_web.svg new file mode 100644 index 0000000..1e3527c --- /dev/null +++ b/doc/_static/openalea_web.svg @@ -0,0 +1,108 @@ + + + + + + + + + + image/svg+xml + + + + + + + + + + + + OpenAlea + + + diff --git a/tutorials/Code/__init__.py b/doc/examples/Code/__init__.py similarity index 100% rename from tutorials/Code/__init__.py rename to doc/examples/Code/__init__.py diff --git a/tutorials/Code/amlseq2R.py b/doc/examples/Code/amlseq2R.py similarity index 100% rename from tutorials/Code/amlseq2R.py rename to doc/examples/Code/amlseq2R.py diff --git a/tutorials/Code/matrix_plot.py b/doc/examples/Code/matrix_plot.py similarity index 100% rename from tutorials/Code/matrix_plot.py rename to doc/examples/Code/matrix_plot.py diff --git a/tutorials/Code/python_dics2R.py b/doc/examples/Code/python_dics2R.py similarity index 100% rename from tutorials/Code/python_dics2R.py rename to doc/examples/Code/python_dics2R.py diff --git a/tutorials/Utils/__init__.py b/doc/examples/Utils/__init__.py similarity index 100% rename from tutorials/Utils/__init__.py rename to doc/examples/Utils/__init__.py diff --git a/tutorials/Utils/dos2unix.py b/doc/examples/Utils/dos2unix.py similarity index 100% rename from tutorials/Utils/dos2unix.py rename to doc/examples/Utils/dos2unix.py diff --git a/tutorials/Utils/unix2dos.py b/doc/examples/Utils/unix2dos.py similarity index 100% rename from tutorials/Utils/unix2dos.py rename to doc/examples/Utils/unix2dos.py diff --git a/tutorials/example_oak.ipynb b/doc/examples/example_oak.ipynb similarity index 100% rename from tutorials/example_oak.ipynb rename to doc/examples/example_oak.ipynb diff --git a/doc/examples/example_oak.qmd b/doc/examples/example_oak.qmd new file mode 100644 index 0000000..f6e89ba --- /dev/null +++ b/doc/examples/example_oak.qmd @@ -0,0 +1,293 @@ +--- +title: 'Sequences advanced tutorial: Oak trunk annual shoots' +jupyter: + jupytext: + text_representation: + extension: .qmd + format_name: quarto + format_version: '1.0' + jupytext_version: 1.18.1 + kernelspec: + display_name: Python 3 (ipykernel) + language: python + name: python3 +--- + +```{python} +#!/usr/bin/python3.10 +``` + + + +## Configuration +### It is assumed that this notebook is run from StructureAnalysis/sequence_analysis/tutorials + + Functions used: + * data: Sequences, Vectors + * output: Plot, Display + * data exploration: ExtractHistogram, Cluster, Regression, ValueSelect, VarianceAnalysis, Compare, ContingencyTable, Estimate + + :Authors: Thomas Cokelaer + :References: Oak trunk annual shoot example + :Data: Patrick Heuret + +In this example, we will explain some functionalities of sequence_analysis package by going through the python script `example_oak.py` step by step. First, we will start to explain what is a sequence data file and how to explore and visualize its contents. + +**Import OpenAlea packages** + +```{python} +from openalea.stat_tool import _stat_tool +from openalea.sequence_analysis import _sequence_analysis +from openalea.sequence_analysis import Sequences +from openalea.stat_tool import Vectors, Regression + + +from openalea.stat_tool.data_transform import * +from openalea.stat_tool.cluster import Cluster +from openalea.stat_tool import (Transcode, +VarianceAnalysis, +ContingencyTable, +Compare, +Estimate, +Display) + +import openalea.stat_tool.plot #import DISABLE_PLOT +from openalea.stat_tool.plot import DISABLE_PLOT +DISABLE_PLOT = False + +import os + +from openalea.stat_tool.output import plot, Plot + +plot.DISABLE_PLOT = DISABLE_PLOT + +from openalea.stat_tool.plot import get_plotter, mplotlib +``` + +For correct figure rendering + +```{python} +%matplotlib inline +``` + +##### Place variables in markdown outputs + +```{python} +from IPython.display import Markdown +from IPython.core.magic import register_cell_magic + + +@register_cell_magic +def markdown(line, cell): + return Markdown(cell.format(**globals())) +``` + +## Preliminaries: data set + +```{python} +import sys, os +``` + +```{python} +sys.path +``` + +```{python} +sys.path.append(".." + os.sep + "tutorials") +``` + +```{python} +from pathlib import Path +from openalea.sequence_analysis import __path__ as seq_path +data_path = Path(seq_path[0]) +data_path = str(Path.joinpath(data_path.parent.parent.parent.absolute(), "share","data")) +``` + +The file `chene_sessile_15pa.seq` is used as a data set. Its +extension `seq` indicates that this file contains a list of sequences. + +This file contains an header that provides the number of variables and their +types. Here there are 6 variables that are labelled as **STATE** variables. +There are 46 sequences in total, and a sequence looks like:: + + 95 110 219 2 52 14 | 96 17 119 2 24 9 | 97 57 101 2 33 1 + +Each element in the sequence is separated by the other by the pipe + symbol, which is optional when the sequence is univariate. In the sequence + above, we have 6 variables and each sequence is 3-elements long (one for + each year 95, 96, 97). + +The Sequences data structures allows to read a file and returns a Sequences object that can be indexed like a normal list - the first index being the sequence index and the +second index being the vector index. + +```{python} +seq = Sequences(data_path + os.sep + 'chene_sessile_15pa.seq') +``` + +```{python} +# First sequence +seq[0] +``` + +```{python} +# 2nd value of the first sequence +seq[0][1] +``` + +```{python} +# variant of seq[0][1] +seq[0,1] +``` + +Note the syntax to access the second vector of the first sequence. First, + indices starts at zero like in C/python languages and the index syntax may be either [i][j] or [i,j]. + +You may want to extract observations for each sequence at each time step as an unstructured collection of vectors: + + +```{python} +seq.nb_sequence +``` + +```{python} +vec = Vectors(seq) +``` + +```{python} +vec.nb_vector +``` + +```{python} +assert vec[3*10] == seq[10][0] +``` + +138 is simply the number of sequences times the number of element per sequences (3 here). + +# Read sequences in a file and plot a data viewpoint + +Let us come back to the example. Once the data being read, we can plot the results using a Data viewpoint (see `openalea.stat_tool.output.Plot`). +Here, all sequences are 3 annual shoots long. Sequences are all equal for variable 1 (year): 95, 96, 97. The other variables are represented using one color per sequence. + +```{python} +Plot(seq, ViewPoint="Data") +``` + +# Looking at one variable + +On the first line of the following code, we first extract a given variable (the third one) and then cluster into bins it before plotting the variable histogram. Note that the extraction is made in such a way that each vector in each sequence is extracted in a single object. So you have 138 vectors in the **marginal3** variable. + +```{python} +marginal3 = ExtractHistogram(seq, "Value", 3) +Plot(Cluster(marginal3, "Information", 0.75)) +``` + +The variable marginal3 could also have been obtained as follows: + +```{python} +marginal3 = ExtractHistogram(vec, 3) +``` + +# Regression and vectors + +Now, coming back to the first (year) and second variable (growth length), we plot the average of the second variable versus the year (first variable) as follows. The second graph represents the residuals (differences between values and average). + +```{python} +# plot of the average sequence +Plot(Regression(vec, "MovingAverage", 1, 2, [1])) +``` + +The argument +`Regression(vec, "MovingAverage", 1, 2, [1])` +computes the average value per time index. Argument "1" is the explanatory variable (here, year), argument "2" is the response variable, here, annual shoot length, and [1] is the filter applied for averaging. +More general filters can be applied, for example [0.1, 0.7, 0.2], meaning that at time *t*, the average ${\hat x}_t$ will combine $x_{t-1}$, $x_t$ and $x_{t+1}$ as ${\hat x}_t=0.1 x_{t-1}+0.7 x_t + 0.2 x_{t+1}$. + +# Comparison and variance analysis + +Then, we want to look those data in more details by selecting the length year by year. So, we first select each year one by one (line 1 to 3 below). Here, `ValueSelect` selects the first variable when its values is 95, or 96 or 97 from which an histogram is extracted. All 3 histograms can be plotted together. + +```{python} +vec95 = ValueSelect(vec, 1, 95) +vec96 = ValueSelect(vec, 1, 96) +vec97 = ValueSelect(vec, 1, 97) + +Plot(ExtractHistogram(vec95, 2), ExtractHistogram(vec96, 2), ExtractHistogram(vec97, 2)) +``` + +The command +`VarianceAnalysis(vec, 1, 2, "N")` +achieves variance analysis (ANOVA) computations using as class (group) variable "1", response variable "2", treating response variable as "N"umeric (as opposed to "O"rdinal). +The output highlights significant difference in shoot length distributions depending on year (assuming Gaussian distributions): + +```{python} +print(VarianceAnalysis(vec, 1, 2, "N")) +``` + +Further statistics to compare the three distributions can be obtained with +`print(Compare(ExtractHistogram(vec95, 2), ExtractHistogram(vec96, 2), ExtractHistogram(vec97, 2), "N"))` +The last argument indicates whether the target variable has to be considered as "N"umeric, "O"rdinal or "S"ymbolic. +The output is somewhat verbose and not displayed here, it contains essentially the same information as above (relative and cumulated frequencies, ANOVA). Additionally, it contains a similarity measure between distributions $E\left[X-Y\right]$ inspired by the so called energy distance. + +```{python} +# print(Compare(ExtractHistogram(vec95, 2), ExtractHistogram(vec96, 2), ExtractHistogram(vec97, 2), "N")) +``` + +# Comparison and ContingencyTable + +Here again, we compare variables but looking at the ranks rather than the years. +We first look at the contingency table obtained by crossing variables 1 (year) and 4 (number of growth cycles) + +```{python} +print(ContingencyTable(vec, 1, 4)) +``` + +... and then plot some histograms. + +```{python} +Plot(ExtractHistogram(vec95, 4), ExtractHistogram(vec96, 4), ExtractHistogram(vec97, 4)) +``` + +Here the response variable is ordinal, so the last argument of `VarianceAnalysis` is "O" + +```{python} +print(VarianceAnalysis(vec, 1, 4, "O")) +``` + +# Estimating a distribution for annual shoot length + +Now, we extract an historam from the second variable and estimated a model that is a mixture of 4 negative binomial distribution and plot the results: either the mixture model or component by component. + +```{python} +mixt20 = Estimate(ExtractHistogram(vec, 2), "MIXTURE", "NB", "NB", "NB", "NB", NbComponent="Estimated") +print(Display(mixt20)) +``` + +```{python} +Plot(mixt20) +``` + +Below, the estimated mixture distribution is estimated and represented globally, without each separate component: + +```{python} +Plot(ExtractDistribution(mixt20, "Mixture")) +``` + +The alternative method `estimate_DiscreteMixture` would yield the same mixture: + +```{python} +mixt20b = ExtractHistogram(vec, 2).estimate_DiscreteMixture(["NB", "NB"]) +Plot(mixt20b) +``` + +# Regression + +Now, a regression model can be estimated to predict variable 5 (number of metamers) using variable 2 (shoot length). The right-hand figure represents residuals of the estimated regression model. + +```{python} +regress10 = Regression(vec, "Linear", 5, 2) +print(Display(regress10)) +``` + +```{python} +Plot(regress10) +``` + diff --git a/doc/examples/hidden_semi_markov.ipynb b/doc/examples/hidden_semi_markov.ipynb new file mode 100644 index 0000000..b05b0ea --- /dev/null +++ b/doc/examples/hidden_semi_markov.ipynb @@ -0,0 +1,2078 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "#!/usr/bin/python3.10" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Prerequisites: matplotlib, rpy2" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# HSMC modelling" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Configuration\n", + "### It is assumed that this notebook is run from StructureAnalysis/sequence_analysis/tutorials" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Import OpenAlea packages**" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Running cmake --build & --install in /home/jdurand/devlp/Git/openalea/stat_tool/build\n", + "Running cmake --build & --install in /home/jdurand/devlp/Git/openalea/sequence_analysis/build\n" + ] + } + ], + "source": [ + "from openalea.stat_tool import _stat_tool\n", + "from openalea.sequence_analysis import _sequence_analysis\n", + "from openalea.sequence_analysis.hidden_semi_markov import HiddenSemiMarkov\n", + "from openalea.sequence_analysis.simulate import Simulate\n", + "from openalea.sequence_analysis.data_transform import Thresholding\n", + "\n", + "from openalea.stat_tool.data_transform import *\n", + "from openalea.stat_tool.cluster import Cluster\n", + "from openalea.stat_tool.cluster import Transcode, Cluster\n", + "\n", + "import openalea.stat_tool.plot #import DISABLE_PLOT\n", + "from openalea.stat_tool.plot import DISABLE_PLOT\n", + "DISABLE_PLOT = False\n", + "\n", + "import os\n", + "\n", + "from openalea.stat_tool.output import plot, Plot\n", + "\n", + "plot.DISABLE_PLOT = DISABLE_PLOT\n", + "\n", + "from openalea.stat_tool.plot import get_plotter, mplotlib " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "For correct figure rendering" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "%matplotlib inline" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "##### Enabling R extensions" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "%load_ext rpy2.ipython" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "##### Place variables in markdown outputs" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "from IPython.display import Markdown\n", + "from IPython.core.magic import register_cell_magic\n", + "\n", + "\n", + "@register_cell_magic\n", + "def markdown(line, cell):\n", + " return Markdown(cell.format(**globals()))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Loading and preparing data" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "import sys, os" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "['/home/jdurand/usr/local/openalea',\n", + " '/home/jdurand/miniforge3/envs/statdev/lib/python313.zip',\n", + " '/home/jdurand/miniforge3/envs/statdev/lib/python3.13',\n", + " '/home/jdurand/miniforge3/envs/statdev/lib/python3.13/lib-dynload',\n", + " '',\n", + " '/home/jdurand/miniforge3/envs/statdev/lib/python3.13/site-packages',\n", + " '/home/jdurand/devlp/Git/openalea/sequence_analysis/src/openalea',\n", + " '/home/jdurand/devlp/Git/openalea/stat_tool/src/openalea']" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "sys.path" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "sys.path.append(\"..\" + os.sep + \"tutorials\")" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "from pathlib import Path\n", + "from openalea.sequence_analysis import __path__ as seq_path\n", + "data_path = Path(seq_path[0])\n", + "data_path = str(Path.joinpath(data_path.parent.parent.parent.absolute(), \"share\",\"data\"))\n" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [], + "source": [ + "from openalea.sequence_analysis import (get_shared_data, \n", + " Sequences,\n", + " _MarkovianSequences)\n", + "data_file = \"belren1.seq\"\n", + "\n", + "seq = Sequences(get_shared_data(data_file))\n", + "mseq = _MarkovianSequences(seq)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Semantics of the observed variable\n", + "Type of lateral production (ramification) at the scale of metamer along a growth unit on apple tree trunks\n", + " * 0: latent bud\n", + " * 1: short vegetative proleptic shoot\n", + " * 2: long vegetative proleptic shoot\n", + " * 3: short floral proleptic shoot\n", + " * 4: (usually long, vegetative) sylleptic shoot" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Exploratory analysis" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Print the first sequence in lines** \n", + "`print(mseq[0])` would print in a column." + ] + }, + { + "cell_type": "code", + "execution_count": 46, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "seq0 = mseq.select_individual([1], True)\n", + "Plot(seq0, ViewPoint=\"Data\")" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "15" + ] + }, + "execution_count": 36, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Number of sequences\n", + "len(mseq)" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "mseq.plot(\"Intensity\", 0, Title=\"Lateral shoot type\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "An exploratory analysis suggests that there is an initial zone with a majority of 0, mixed with 1 and 2; a second zone with a majority of 1, mixed with 0 and 3; a third zone with a majority of 1, mixed with 2; a fourth zone with a majority of 3, mixed with 0 and 1; a fifth zone with a majority of 4, mixed with 0 and a sixth zone with a majority of 0, mixed with 2." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Estimate Left-Right HSMC with nonparametric emission distributions" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "nonparametric meant as categorical, saturated model" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0\n", + "HIDDEN_SEMI-MARKOV_CHAIN\n", + "\n", + "6 STATES\n", + "\n", + "INITIAL_PROBABILITIES\n", + "0.622036 1e-05 0.377934 1e-05 1e-05 0 \n", + "\n", + "TRANSITION_PROBABILITIES\n", + "0 0.572647 1e-05 0.427323 1e-05 1e-05 \n", + "0 0 1e-05 1e-05 0.99997 1e-05 \n", + "0 0 0 0.99998 1e-05 1e-05 \n", + "0 0 0 0 0.896444 0.103556 \n", + "0 0 0 0 0 1 \n", + "0 0 0 0 0 1 \n", + "\n", + "transient class: state 0\n", + "transient class: state 1\n", + "transient class: state 2\n", + "transient class: state 3\n", + "transient class: state 4\n", + "recurrent class: state 5 (absorbing state)\n", + "\n", + "probability of no-occurrence of state 0: 0.377964\n", + "\n", + "time up to the first occurrence of state 0 distribution\n", + "mean: 0 mode: 0\n", + "variance: 0 standard deviation: 0\n", + "\n", + "time up to the first occurrence of state 0 frequency distribution - sample size: 0\n", + "\n", + "probability of no-occurrence of state 1: 0.64378\n", + "\n", + "time up to the first occurrence of state 1 distribution\n", + "mean: 10.7279 mode: 5\n", + "variance: 48.7088 standard deviation: 6.97917\n", + "\n", + "time up to the first occurrence of state 1 frequency distribution - sample size: 5\n", + "mean: 6.4 median: 7 mode: 7\n", + "variance: 9.8 standard deviation: 3.1305 lower quartile: 4 upper quartile: 7\n", + "\n", + "probability of no-occurrence of state 2: 0.622049\n", + "\n", + "time up to the first occurrence of state 2 distribution\n", + "mean: 0 mode: 0\n", + "variance: 0 standard deviation: 0\n", + "\n", + "time up to the first occurrence of state 2 frequency distribution - sample size: 0\n", + "\n", + "probability of no-occurrence of state 3: 0.356235\n", + "\n", + "time up to the first occurrence of state 3 distribution\n", + "mean: 9.43059 mode: 7\n", + "variance: 30.2303 standard deviation: 5.4982\n", + "\n", + "time up to the first occurrence of state 3 frequency distribution - sample size: 10\n", + "mean: 12.7 median: 11.5 mode: 11\n", + "variance: 53.1222 standard deviation: 7.2885 lower quartile: 7 upper quartile: 16\n", + "\n", + "probability of no-occurrence of state 4: 0.0666777\n", + "\n", + "time up to the first occurrence of state 4 distribution\n", + "mean: 23.6754 mode: 22\n", + "variance: 61.4164 standard deviation: 7.83686\n", + "\n", + "time up to the first occurrence of state 4 frequency distribution - sample size: 14\n", + "mean: 22.9286 median: 24 mode: 24.5\n", + "variance: 21.1484 standard deviation: 4.59873 lower quartile: 20 upper quartile: 25\n", + "\n", + "time up to the first occurrence of state 5 distribution\n", + "mean: 43.8813 median: 44 mode: 43\n", + "variance: 126.341 standard deviation: 11.2402 lower quartile: 38 upper quartile: 51\n", + "\n", + "time up to the first occurrence of state 5 frequency distribution - sample size: 15\n", + "mean: 43.8 median: 44 mode: 39\n", + "variance: 47.0286 standard deviation: 6.85774 lower quartile: 39 upper quartile: 49\n", + "\n", + "probability of leaving state 0: 0.0924217\n", + "\n", + "state 0 recurrence time distribution\n", + "mean: 1 mode: 1\n", + "variance: 0 standard deviation: 0\n", + "\n", + "state 0 recurrence time frequency distribution - sample size: 97\n", + "mean: 1 median: 1 mode: 1\n", + "variance: 0 standard deviation: 0\n", + "\n", + "probability of leaving state 1: 0.0553964\n", + "\n", + "state 1 recurrence time distribution\n", + "mean: 1 mode: 1\n", + "variance: 0 standard deviation: 0\n", + "\n", + "state 1 recurrence time frequency distribution - sample size: 84\n", + "mean: 1 median: 1 mode: 1\n", + "variance: 0 standard deviation: 0\n", + "\n", + "probability of leaving state 2: 0.117066\n", + "\n", + "state 2 recurrence time distribution\n", + "mean: 1 mode: 1\n", + "variance: 0 standard deviation: 0\n", + "\n", + "state 2 recurrence time frequency distribution - sample size: 47\n", + "mean: 1 median: 1 mode: 1\n", + "variance: 0 standard deviation: 0\n", + "\n", + "probability of leaving state 3: 0.0904455\n", + "\n", + "state 3 recurrence time distribution\n", + "mean: 1 mode: 1\n", + "variance: 0 standard deviation: 0\n", + "\n", + "state 3 recurrence time frequency distribution - sample size: 96\n", + "mean: 1 median: 1 mode: 1\n", + "variance: 0 standard deviation: 0\n", + "\n", + "probability of leaving state 4: 0.045714\n", + "\n", + "state 4 recurrence time distribution\n", + "mean: 1 mode: 1\n", + "variance: 0 standard deviation: 0\n", + "\n", + "state 4 recurrence time frequency distribution - sample size: 289\n", + "mean: 1 median: 1 mode: 1\n", + "variance: 0 standard deviation: 0\n", + "\n", + "state 5 recurrence time distribution\n", + "mean: 1 median: 1 mode: 1\n", + "variance: 0 standard deviation: 0\n", + "\n", + "state 5 recurrence time frequency distribution - sample size: 671\n", + "mean: 1 median: 1 mode: 1\n", + "variance: 0 standard deviation: 0\n", + "\n", + "STATE 0 OCCUPANCY_DISTRIBUTION\n", + "NEGATIVE_BINOMIAL INF_BOUND : 2 PARAMETER : 1.79274 PROBABILITY : 0.168924\n", + "mean: 10.82 median: 9 mode: 5\n", + "variance: 52.2126 standard deviation: 7.22583 lower quartile: 6 upper quartile: 14\n", + "coefficient of skewness: 1.50012 coefficient of kurtosis: 3.36598\n", + "\n", + "state 0 sojourn time frequency distribution - sample size: 9\n", + "mean: 11.7778 median: 11 mode: 7\n", + "variance: 64.6944 standard deviation: 8.04329 lower quartile: 7 upper quartile: 16\n", + "\n", + "final run - state 0 sojourn time frequency distribution - sample size: 0\n", + "\n", + "STATE 1 OCCUPANCY_DISTRIBUTION\n", + "BINOMIAL INF_BOUND : 16 SUP_BOUND : 21 PROBABILITY : 0.410345\n", + "mean: 18.0517 median: 18 mode: 18\n", + "variance: 1.20981 standard deviation: 1.09991 lower quartile: 17 upper quartile: 19\n", + "coefficient of skewness: 0.163022 coefficient of kurtosis: -0.373424\n", + "\n", + "state 1 sojourn time frequency distribution - sample size: 5\n", + "mean: 17.8 median: 18 mode: 17.5\n", + "variance: 0.7 standard deviation: 0.83666 lower quartile: 17 upper quartile: 18\n", + "\n", + "final run - state 1 sojourn time frequency distribution - sample size: 0\n", + "\n", + "STATE 2 OCCUPANCY_DISTRIBUTION\n", + "NEGATIVE_BINOMIAL INF_BOUND : 1 PARAMETER : 6.72626 PROBABILITY : 0.471408\n", + "mean: 8.54217 median: 8 mode: 7\n", + "variance: 15.9992 standard deviation: 3.9999 lower quartile: 6 upper quartile: 11\n", + "coefficient of skewness: 0.810671 coefficient of kurtosis: 0.95453\n", + "\n", + "state 2 sojourn time frequency distribution - sample size: 6\n", + "mean: 8.83333 median: 7.5 mode: 3\n", + "variance: 20.1667 standard deviation: 4.49073 lower quartile: 5 upper quartile: 13\n", + "\n", + "final run - state 2 sojourn time frequency distribution - sample size: 0\n", + "\n", + "STATE 3 OCCUPANCY_DISTRIBUTION\n", + "NEGATIVE_BINOMIAL INF_BOUND : 1 PARAMETER : 152.387 PROBABILITY : 0.938093\n", + "mean: 11.0564 median: 11 mode: 10\n", + "variance: 10.72 standard deviation: 3.27415 lower quartile: 9 upper quartile: 13\n", + "coefficient of skewness: 0.345735 coefficient of kurtosis: 0.132657\n", + "\n", + "state 3 sojourn time frequency distribution - sample size: 10\n", + "mean: 10.6 median: 10.5 mode: 10\n", + "variance: 13.8222 standard deviation: 3.71782 lower quartile: 10 upper quartile: 13\n", + "\n", + "final run - state 3 sojourn time frequency distribution - sample size: 0\n", + "\n", + "STATE 4 OCCUPANCY_DISTRIBUTION\n", + "NEGATIVE_BINOMIAL INF_BOUND : 1 PARAMETER : 52.0512 PROBABILITY : 0.71375\n", + "mean: 21.8752 median: 22 mode: 21\n", + "variance: 29.2472 standard deviation: 5.40806 lower quartile: 18 upper quartile: 25\n", + "coefficient of skewness: 0.333225 coefficient of kurtosis: 0.149462\n", + "\n", + "state 4 sojourn time frequency distribution - sample size: 14\n", + "mean: 21.6429 median: 21 mode: 20.5\n", + "variance: 31.478 standard deviation: 5.61053 lower quartile: 17 upper quartile: 25\n", + "\n", + "final run - state 4 sojourn time frequency distribution - sample size: 0\n", + "\n", + "absorption probability of state 5: 1\n", + "\n", + "state 5 sojourn time frequency distribution - sample size: 0\n", + "\n", + "final run - state 5 sojourn time frequency distribution - sample size: 15\n", + "mean: 45.7333 median: 45 mode: 43\n", + "variance: 16.781 standard deviation: 4.09646 lower quartile: 43 upper quartile: 48\n", + "\n", + "mixture of number of runs of state 0 per sequence distributions\n", + "mean: 0.622037 median: 1 mode: 1\n", + "variance: 0.235107 standard deviation: 0.484878 lower quartile: 0 upper quartile: 1\n", + "\n", + "number of runs of state 0 per sequence frequency distribution - sample size: 15\n", + "mean: 0.6 median: 1 mode: 1\n", + "variance: 0.257143 standard deviation: 0.507093 lower quartile: 0 upper quartile: 1\n", + "\n", + "mixture of number of runs of state 1 per sequence distributions\n", + "mean: 0.356218 median: 0 mode: 0\n", + "variance: 0.229327 standard deviation: 0.478881 lower quartile: 0 upper quartile: 1\n", + "\n", + "number of runs of state 1 per sequence frequency distribution - sample size: 15\n", + "mean: 0.333333 median: 0 mode: 0\n", + "variance: 0.238095 standard deviation: 0.48795 lower quartile: 0 upper quartile: 1\n", + "\n", + "mixture of number of runs of state 2 per sequence distributions\n", + "mean: 0.377943 median: 0 mode: 0\n", + "variance: 0.235102 standard deviation: 0.484873 lower quartile: 0 upper quartile: 1\n", + "\n", + "number of runs of state 2 per sequence frequency distribution - sample size: 15\n", + "mean: 0.4 median: 0 mode: 0\n", + "variance: 0.257143 standard deviation: 0.507093 lower quartile: 0 upper quartile: 1\n", + "\n", + "mixture of number of runs of state 3 per sequence distributions\n", + "mean: 0.643759 median: 1 mode: 1\n", + "variance: 0.229333 standard deviation: 0.478888 lower quartile: 0 upper quartile: 1\n", + "\n", + "number of runs of state 3 per sequence frequency distribution - sample size: 15\n", + "mean: 0.666667 median: 1 mode: 1\n", + "variance: 0.238095 standard deviation: 0.48795 lower quartile: 0 upper quartile: 1\n", + "\n", + "mixture of number of runs of state 4 per sequence distributions\n", + "mean: 0.933313 median: 1 mode: 1\n", + "variance: 0.0622396 standard deviation: 0.249479 lower quartile: 1 upper quartile: 1\n", + "\n", + "number of runs of state 4 per sequence frequency distribution - sample size: 15\n", + "mean: 0.933333 median: 1 mode: 1\n", + "variance: 0.0666667 standard deviation: 0.258199 lower quartile: 1 upper quartile: 1\n", + "\n", + "mixture of number of runs of state 5 per sequence distributions\n", + "mean: 0.999168 median: 1 mode: 1\n", + "variance: 0.000831762 standard deviation: 0.0288403 lower quartile: 1 upper quartile: 1\n", + "\n", + "number of runs of state 5 per sequence frequency distribution - sample size: 15\n", + "mean: 1 median: 1 mode: 1\n", + "variance: 0 standard deviation: 0\n", + "\n", + "mixture of number of occurrences of state 0 per sequence distributions\n", + "mean: 6.73001 median: 5 mode: 0\n", + "variance: 59.9699 standard deviation: 7.74403 lower quartile: 0 upper quartile: 11\n", + "\n", + "number of occurrences of state 0 per sequence frequency distribution - sample size: 15\n", + "mean: 7.06667 median: 4 mode: 0\n", + "variance: 72.6381 standard deviation: 8.5228 lower quartile: 0 upper quartile: 11\n", + "\n", + "mixture of number of occurrences of state 1 per sequence distributions\n", + "mean: 6.43034 median: 0 mode: 0\n", + "variance: 75.1601 standard deviation: 8.6695 lower quartile: 0 upper quartile: 17\n", + "\n", + "number of occurrences of state 1 per sequence frequency distribution - sample size: 15\n", + "mean: 5.93333 median: 0 mode: 0\n", + "variance: 75.6381 standard deviation: 8.69702 lower quartile: 0 upper quartile: 17\n", + "\n", + "mixture of number of occurrences of state 2 per sequence distributions\n", + "mean: 3.22835 median: 0 mode: 0\n", + "variance: 23.198 standard deviation: 4.81643 lower quartile: 0 upper quartile: 6\n", + "\n", + "number of occurrences of state 2 per sequence frequency distribution - sample size: 15\n", + "mean: 3.53333 median: 0 mode: 0\n", + "variance: 27.2667 standard deviation: 5.22175 lower quartile: 0 upper quartile: 7\n", + "\n", + "mixture of number of occurrences of state 3 per sequence distributions\n", + "mean: 7.11756 median: 8 mode: 0\n", + "variance: 34.9337 standard deviation: 5.91047 lower quartile: 0 upper quartile: 12\n", + "\n", + "number of occurrences of state 3 per sequence frequency distribution - sample size: 15\n", + "mean: 7.06667 median: 10 mode: 0\n", + "variance: 35.6381 standard deviation: 5.96977 lower quartile: 0 upper quartile: 11\n", + "\n", + "mixture of number of occurrences of state 4 per sequence distributions\n", + "mean: 20.412 median: 21 mode: 21\n", + "variance: 57.052 standard deviation: 7.55328 lower quartile: 17 upper quartile: 25\n", + "\n", + "number of occurrences of state 4 per sequence frequency distribution - sample size: 15\n", + "mean: 20.2 median: 21 mode: 20.5\n", + "variance: 60.4571 standard deviation: 7.77542 lower quartile: 16 upper quartile: 25\n", + "\n", + "mixture of number of occurrences of state 5 per sequence distributions\n", + "mean: 45.6151 median: 46 mode: 46\n", + "variance: 145.967 standard deviation: 12.0817 lower quartile: 38 upper quartile: 53\n", + "\n", + "number of occurrences of state 5 per sequence frequency distribution - sample size: 15\n", + "mean: 45.7333 median: 45 mode: 43\n", + "variance: 16.781 standard deviation: 4.09646 lower quartile: 43 upper quartile: 48\n", + "\n", + "1 OUTPUT_PROCESS\n", + "\n", + "OUTPUT_PROCESS 1 : CATEGORICAL\n", + "\n", + "STATE 0 OBSERVATION_DISTRIBUTION\n", + "OUTPUT 0 : 0.671017\n", + "OUTPUT 1 : 0.152148\n", + "OUTPUT 2 : 0.176815\n", + "OUTPUT 3 : 1e-05\n", + "OUTPUT 4 : 1e-05\n", + "\n", + "STATE 1 OBSERVATION_DISTRIBUTION\n", + "OUTPUT 0 : 0.17064\n", + "OUTPUT 1 : 0.590005\n", + "OUTPUT 2 : 0.038595\n", + "OUTPUT 3 : 0.200749\n", + "OUTPUT 4 : 1e-05\n", + "\n", + "STATE 2 OBSERVATION_DISTRIBUTION\n", + "OUTPUT 0 : 0.0845549\n", + "OUTPUT 1 : 0.506253\n", + "OUTPUT 2 : 0.367914\n", + "OUTPUT 3 : 2.44803e-05\n", + "OUTPUT 4 : 0.0412531\n", + "\n", + "STATE 3 OBSERVATION_DISTRIBUTION\n", + "OUTPUT 0 : 0.202418\n", + "OUTPUT 1 : 0.206426\n", + "OUTPUT 2 : 0.0243176\n", + "OUTPUT 3 : 0.544472\n", + "OUTPUT 4 : 0.0223661\n", + "\n", + "STATE 4 OBSERVATION_DISTRIBUTION\n", + "OUTPUT 0 : 0.111757\n", + "OUTPUT 1 : 0.0182254\n", + "OUTPUT 2 : 1e-05\n", + "OUTPUT 3 : 0.034318\n", + "OUTPUT 4 : 0.83569\n", + "\n", + "STATE 5 OBSERVATION_DISTRIBUTION\n", + "OUTPUT 0 : 0.835675\n", + "OUTPUT 1 : 0.0417934\n", + "OUTPUT 2 : 0.0935168\n", + "OUTPUT 3 : 2.49506e-05\n", + "OUTPUT 4 : 0.0289893\n", + "\n", + "observation probability matrix\n", + "\n", + " 0 1 2 3 4 \n", + "0 0.671017 0.152148 0.176815 1e-05 1e-05 \n", + "1 0.17064 0.590005 0.038595 0.200749 1e-05 \n", + "2 0.0845549 0.506253 0.367914 2.44803e-05 0.0412531 \n", + "3 0.202418 0.206426 0.0243176 0.544472 0.0223661 \n", + "4 0.111757 0.0182254 1e-05 0.034318 0.83569 \n", + "5 0.835675 0.0417934 0.0935168 2.49506e-05 0.0289893 \n", + "\n", + "theoretical weights: 0.0751727 0.0718197 0.0360607 0.0794988 0.227982 0.509466\n", + "\n", + "log-likelihood: -1730.69 (normalized: -1.28868)\n", + "maximum possible log-likelihood: -1730.69 (information: -1.28868)\n", + "deviance: 5.46604e-05\n", + "\n", + "chi-square test (4 degrees of freedom)\n", + "chi-square value: 5.46573e-05 critical probability: 1\n", + "reference chi-square value: 9.48773 reference critical probability: 0.05\n", + "\n", + "restoration weights: 0.0789278 0.0662695 0.0394639 0.0789278 0.225614 0.510797\n", + "\n", + "log-likelihood: -1730.77 (normalized: -1.28873)\n", + "maximum possible log-likelihood: -1730.69 (information: -1.28868)\n", + "deviance: 0.149803\n", + "\n", + "chi-square test (4 degrees of freedom)\n", + "chi-square value: 0.149834 critical probability: 0.99733\n", + "reference chi-square value: 9.48773 reference critical probability: 0.05\n", + "\n", + "time up to the first occurrence of output 0 distribution\n", + "mean: 3.1574 median: 1 mode: 0\n", + "variance: 27.1111 standard deviation: 5.20683 lower quartile: 0 upper quartile: 4\n", + "\n", + "time up to the first occurrence of output 0 frequency distribution - sample size: 15\n", + "mean: 4.4 median: 0 mode: 0\n", + "variance: 115.4 standard deviation: 10.7424 lower quartile: 0 upper quartile: 4\n", + "\n", + "time up to the first occurrence of output 1 distribution\n", + "mean: 3.41271 median: 2 mode: 0\n", + "variance: 25.8596 standard deviation: 5.08523 lower quartile: 0 upper quartile: 5\n", + "\n", + "time up to the first occurrence of output 1 frequency distribution - sample size: 15\n", + "mean: 5.4 median: 5 mode: 4.5\n", + "variance: 14.5429 standard deviation: 3.81351 lower quartile: 4 upper quartile: 7\n", + "\n", + "time up to the first occurrence of output 2 distribution\n", + "mean: 7.60389 median: 2 mode: 0\n", + "variance: 221.734 standard deviation: 14.8907 lower quartile: 1 upper quartile: 6\n", + "\n", + "time up to the first occurrence of output 2 frequency distribution - sample size: 15\n", + "mean: 11.2 median: 5 mode: 0\n", + "variance: 330.029 standard deviation: 18.1667 lower quartile: 0 upper quartile: 12\n", + "\n", + "time up to the first occurrence of output 3 distribution\n", + "mean: 11.917 median: 10 mode: 8\n", + "variance: 81.5055 standard deviation: 9.02804 lower quartile: 7 upper quartile: 15\n", + "\n", + "time up to the first occurrence of output 3 frequency distribution - sample size: 15\n", + "mean: 13.6 median: 13 mode: 11\n", + "variance: 36.6857 standard deviation: 6.05687 lower quartile: 11 upper quartile: 17\n", + "\n", + "time up to the first occurrence of output 4 distribution\n", + "mean: 22.2679 median: 22 mode: 22\n", + "variance: 172.91 standard deviation: 13.1495 lower quartile: 15 upper quartile: 28\n", + "\n", + "time up to the first occurrence of output 4 frequency distribution - sample size: 14\n", + "mean: 21.2143 median: 23 mode: 20\n", + "variance: 56.489 standard deviation: 7.51592 lower quartile: 20 upper quartile: 25\n", + "\n", + "output 0 recurrence time distribution\n", + "mean: 1.80565 median: 1 mode: 1\n", + "variance: 6.35817 standard deviation: 2.52154 lower quartile: 1 upper quartile: 2\n", + "\n", + "output 0 recurrence time frequency distribution - sample size: 701\n", + "mean: 1.80029 median: 1 mode: 1\n", + "variance: 8.62291 standard deviation: 2.93648 lower quartile: 1 upper quartile: 1\n", + "\n", + "output 1 recurrence time distribution\n", + "mean: 10.5307 median: 3 mode: 1\n", + "variance: 323.404 standard deviation: 17.9834 lower quartile: 1 upper quartile: 10\n", + "\n", + "output 1 recurrence time frequency distribution - sample size: 138\n", + "mean: 4.04348 median: 1 mode: 1\n", + "variance: 55.3704 standard deviation: 7.44113 lower quartile: 1 upper quartile: 4\n", + "\n", + "output 2 recurrence time distribution\n", + "mean: 12.876 median: 7 mode: 1\n", + "variance: 224.463 standard deviation: 14.9821 lower quartile: 3 upper quartile: 17\n", + "\n", + "output 2 recurrence time frequency distribution - sample size: 91\n", + "mean: 9.58242 median: 2 mode: 1\n", + "variance: 287.09 standard deviation: 16.9437 lower quartile: 1 upper quartile: 7\n", + "\n", + "output 3 recurrence time distribution\n", + "mean: 5.82811 median: 2 mode: 1\n", + "variance: 1657.92 standard deviation: 40.7175 lower quartile: 1 upper quartile: 8\n", + "\n", + "output 3 recurrence time frequency distribution - sample size: 73\n", + "mean: 3.24658 median: 2 mode: 1\n", + "variance: 20.7161 standard deviation: 4.5515 lower quartile: 1 upper quartile: 3\n", + "\n", + "output 4 recurrence time distribution\n", + "mean: 5.19637 median: 1 mode: 1\n", + "variance: 224.297 standard deviation: 14.9766 lower quartile: 1 upper quartile: 2\n", + "\n", + "output 4 recurrence time frequency distribution - sample size: 266\n", + "mean: 1.4812 median: 1 mode: 1\n", + "variance: 3.02795 standard deviation: 1.7401 lower quartile: 1 upper quartile: 1\n", + "\n", + "output 0 sojourn time distribution\n", + "mean: 3.9929 median: 2 mode: 1\n", + "variance: 21.301 standard deviation: 4.61531 lower quartile: 1 upper quartile: 5\n", + "\n", + "output 0 sojourn time frequency distribution - sample size: 150\n", + "mean: 3.21333 median: 1 mode: 1\n", + "variance: 18.2629 standard deviation: 4.27351 lower quartile: 1 upper quartile: 4\n", + "\n", + "final run - output 0 sojourn time frequency distribution - sample size: 15\n", + "mean: 15.6 median: 16 mode: 8\n", + "variance: 71.9714 standard deviation: 8.4836 lower quartile: 10 upper quartile: 19\n", + "\n", + "output 1 sojourn time distribution\n", + "mean: 1.50069 median: 1 mode: 1\n", + "variance: 1.17507 standard deviation: 1.08401 lower quartile: 1 upper quartile: 2\n", + "\n", + "output 1 sojourn time frequency distribution - sample size: 83\n", + "mean: 1.84337 median: 1 mode: 1\n", + "variance: 2.96297 standard deviation: 1.72133 lower quartile: 1 upper quartile: 2\n", + "\n", + "final run - output 1 sojourn time frequency distribution - sample size: 0\n", + "\n", + "output 2 sojourn time distribution\n", + "mean: 1.16166 median: 1 mode: 1\n", + "variance: 0.210163 standard deviation: 0.458435 lower quartile: 1 upper quartile: 1\n", + "\n", + "output 2 sojourn time frequency distribution - sample size: 74\n", + "mean: 1.43243 median: 1 mode: 1\n", + "variance: 0.906331 standard deviation: 0.952014 lower quartile: 1 upper quartile: 1\n", + "\n", + "final run - output 2 sojourn time frequency distribution - sample size: 0\n", + "\n", + "output 3 sojourn time distribution\n", + "mean: 1.5942 median: 1 mode: 1\n", + "variance: 1.20911 standard deviation: 1.09959 lower quartile: 1 upper quartile: 2\n", + "\n", + "output 3 sojourn time frequency distribution - sample size: 54\n", + "mean: 1.62963 median: 1 mode: 1\n", + "variance: 2.27533 standard deviation: 1.50842 lower quartile: 1 upper quartile: 2\n", + "\n", + "final run - output 3 sojourn time frequency distribution - sample size: 0\n", + "\n", + "output 4 sojourn time distribution\n", + "mean: 3.7197 median: 2 mode: 1\n", + "variance: 14.7148 standard deviation: 3.83599 lower quartile: 1 upper quartile: 5\n", + "\n", + "output 4 sojourn time frequency distribution - sample size: 60\n", + "mean: 4.66667 median: 2 mode: 1\n", + "variance: 28.9718 standard deviation: 5.38254 lower quartile: 1 upper quartile: 5\n", + "\n", + "final run - output 4 sojourn time frequency distribution - sample size: 0\n", + "\n", + "mixture of number of runs of output 0 per sequence distributions\n", + "mean: 12.9123 median: 13 mode: 13\n", + "variance: 7.94132 standard deviation: 2.81804 lower quartile: 11 upper quartile: 15\n", + "\n", + "number of runs of output 0 per sequence frequency distribution - sample size: 15\n", + "mean: 11 median: 11 mode: 6\n", + "variance: 11.1429 standard deviation: 3.33809 lower quartile: 8 upper quartile: 14\n", + "\n", + "mixture of number of runs of output 1 per sequence distributions\n", + "mean: 6.76619 median: 7 mode: 7\n", + "variance: 5.38989 standard deviation: 2.32161 lower quartile: 5 upper quartile: 8\n", + "\n", + "number of runs of output 1 per sequence frequency distribution - sample size: 15\n", + "mean: 5.53333 median: 5 mode: 3\n", + "variance: 7.8381 standard deviation: 2.79966 lower quartile: 3 upper quartile: 8\n", + "\n", + "mixture of number of runs of output 2 per sequence distributions\n", + "mean: 6.07801 median: 6 mode: 6\n", + "variance: 5.1438 standard deviation: 2.26799 lower quartile: 4 upper quartile: 8\n", + "\n", + "number of runs of output 2 per sequence frequency distribution - sample size: 15\n", + "mean: 4.93333 median: 5 mode: 5\n", + "variance: 3.20952 standard deviation: 1.79151 lower quartile: 4 upper quartile: 5\n", + "\n", + "mixture of number of runs of output 3 per sequence distributions\n", + "mean: 3.66785 median: 4 mode: 3\n", + "variance: 2.1238 standard deviation: 1.45732 lower quartile: 3 upper quartile: 5\n", + "\n", + "number of runs of output 3 per sequence frequency distribution - sample size: 15\n", + "mean: 3.6 median: 4 mode: 3\n", + "variance: 1.97143 standard deviation: 1.40408 lower quartile: 3 upper quartile: 5\n", + "\n", + "mixture of number of runs of output 4 per sequence distributions\n", + "mean: 4.99012 median: 5 mode: 5\n", + "variance: 3.90102 standard deviation: 1.9751 lower quartile: 4 upper quartile: 6\n", + "\n", + "number of runs of output 4 per sequence frequency distribution - sample size: 15\n", + "mean: 4 median: 4 mode: 3\n", + "variance: 5.71429 standard deviation: 2.39046 lower quartile: 2 upper quartile: 6\n", + "\n", + "mixture of number of occurrences of output 0 per sequence distributions\n", + "mean: 47.7275 median: 47 mode: 47\n", + "variance: 68.0868 standard deviation: 8.25147 lower quartile: 42 upper quartile: 53\n", + "\n", + "number of occurrences of output 0 per sequence frequency distribution - sample size: 15\n", + "mean: 47.7333 median: 46 mode: 37\n", + "variance: 66.9238 standard deviation: 8.1807 lower quartile: 42 upper quartile: 50\n", + "\n", + "mixture of number of occurrences of output 1 per sequence distributions\n", + "mean: 10.1999 median: 10 mode: 7\n", + "variance: 19.2462 standard deviation: 4.38705 lower quartile: 7 upper quartile: 13\n", + "\n", + "number of occurrences of output 1 per sequence frequency distribution - sample size: 15\n", + "mean: 10.2 median: 11 mode: 3\n", + "variance: 22.3143 standard deviation: 4.7238 lower quartile: 7 upper quartile: 14\n", + "\n", + "mixture of number of occurrences of output 2 per sequence distributions\n", + "mean: 7.06497 median: 7 mode: 6\n", + "variance: 8.07206 standard deviation: 2.84114 lower quartile: 5 upper quartile: 9\n", + "\n", + "number of occurrences of output 2 per sequence frequency distribution - sample size: 15\n", + "mean: 7.06667 median: 7 mode: 6.5\n", + "variance: 5.06667 standard deviation: 2.25093 lower quartile: 6 upper quartile: 9\n", + "\n", + "mixture of number of occurrences of output 3 per sequence distributions\n", + "mean: 5.86799 median: 6 mode: 5\n", + "variance: 6.83714 standard deviation: 2.61479 lower quartile: 4 upper quartile: 7\n", + "\n", + "number of occurrences of output 3 per sequence frequency distribution - sample size: 15\n", + "mean: 5.86667 median: 5 mode: 5\n", + "variance: 8.12381 standard deviation: 2.85023 lower quartile: 4 upper quartile: 8\n", + "\n", + "mixture of number of occurrences of output 4 per sequence distributions\n", + "mean: 18.6729 median: 19 mode: 19\n", + "variance: 41.1088 standard deviation: 6.41161 lower quartile: 16 upper quartile: 23\n", + "\n", + "number of occurrences of output 4 per sequence frequency distribution - sample size: 15\n", + "mean: 18.6667 median: 21 mode: 21\n", + "variance: 49.8095 standard deviation: 7.05759 lower quartile: 15 upper quartile: 23\n", + "\n", + "distances between observation distributions for consecutive states\n", + "_ 0.638596 _ 0.621096 _ _ \n", + "_ _ _ _ 0.83568 _ \n", + "_ _ _ 0.662311 _ _ \n", + "_ _ _ _ 0.813324 0.70908 \n", + "_ _ _ _ _ 0.840994 \n", + "_ _ _ _ _ _ \n", + "\n", + "sequence length frequency distribution - sample size: 15\n", + "mean: 89.5333 median: 90 mode: 89\n", + "variance: 19.4095 standard deviation: 4.40562 lower quartile: 86 upper quartile: 92\n", + "\n", + "cumulative length: 1343\n", + "\n", + "information quantity of the sequences in the i.i.d. case: -1730.69 (-1.28868)\n", + "\n", + "log-likelihood for the state sequences: -1079.48 (normalized: -0.803779)\n", + "\n", + "state sequence entropy: 35.817 (normalized: 0.0266694)\n", + "\n", + "log-likelihood for the observed sequences: -1063.68 (normalized: -0.792021)\n", + "\n", + "34 free parameters 2 * penalyzed log-likelihood (AIC): -2195.37\n", + "\n", + "34 free parameters 2 * penalyzed log-likelihood (AICc): -2197.19\n", + "\n", + "34 free parameters 2 * penalyzed log-likelihood (BIC): -2372.26\n", + "\n", + "34 free parameters 2 * penalyzed log-likelihood (BICc): -2288.42\n", + "\n", + "34 free parameters 2 * penalyzed log-likelihood (ICL): -2443.89\n", + "\n", + "34 free parameters 2 * penalyzed log-likelihood (ICLc): -2360.05\n", + "\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "iteration 1 log-likelihood for the observed sequences: -1948.95\n", + "iteration 2 log-likelihood for the observed sequences: -1287.02\n", + "iteration 3 log-likelihood for the observed sequences: -1116.51\n", + "iteration 4 log-likelihood for the observed sequences: -1089.17\n", + "iteration 5 log-likelihood for the observed sequences: -1072.9\n", + "iteration 6 log-likelihood for the observed sequences: -1065.91\n", + "iteration 7 log-likelihood for the observed sequences: -1064.37\n", + "iteration 8 log-likelihood for the observed sequences: -1064.02\n", + "iteration 9 log-likelihood for the observed sequences: -1063.91\n", + "iteration 10 log-likelihood for the observed sequences: -1063.85\n", + "iteration 11 log-likelihood for the observed sequences: -1063.82\n", + "iteration 12 log-likelihood for the observed sequences: -1063.79\n", + "iteration 13 log-likelihood for the observed sequences: -1063.73\n", + "iteration 14 log-likelihood for the observed sequences: -1063.71\n", + "iteration 15 log-likelihood for the observed sequences: -1063.69\n", + "iteration 16 log-likelihood for the observed sequences: -1063.69\n", + "iteration 17 log-likelihood for the observed sequences: -1063.69\n", + "\n", + "17 iterations\n", + "\n", + "complete/censored state occupancy weights\n", + "state 0: 9.33082, 0\n", + "state 1: 5.3434, 9.34601e-57 (1, 1.74908e-57)\n", + "state 2: 5.66922, 1.22527e-64 (1, 2.16126e-65)\n", + "state 3: 9.6566, 2.19968e-37 (1, 2.2779e-38)\n", + "state 4: 14, 3.72387e-37 (1, 2.65991e-38)\n", + "\n", + "log-likelihood for the state sequences: -1079.48 | -1079.48\n", + "\n", + "posterior state sequence probability\n", + "sequence 1: 0.523794 | state begin: 4, 23, 48, \n", + "sequence 2: 0.390808 | state begin: 5, 15, 31, \n", + "sequence 3: 0.161044 | state begin: 28, 32, 44, \n", + "sequence 4: 0.4094 | state begin: 11, 22, 46, \n", + "sequence 5: 0.453785 | state begin: 3, 17, 38, \n", + "sequence 6: 0.24745 | state begin: 11, 21, 53, \n", + "sequence 7: 0.377369 | state begin: 16, 33, \n", + "sequence 8: 0.45204 | state begin: 11, 29, 49, \n", + "sequence 9: 0.285905 | state begin: 14, 24, 39, \n", + "sequence 10: 0.187401 | state begin: 7, 18, 39, \n", + "sequence 11: 0.219127 | state begin: 7, 24, 51, \n", + "sequence 12: 0.548088 | state begin: 13, 26, 46, \n", + "sequence 13: 0.602063 | state begin: 3, 20, 44, \n", + "sequence 14: 0.608084 | state begin: 7, 25, 54, \n", + "sequence 15: 0.227543 | state begin: 19, 25, 42, \n" + ] + } + ], + "source": [ + "nb_states = 6\n", + "\n", + "hsmc_est = Estimate(mseq, \"HIDDEN_SEMI-MARKOV\", \"Ordinary\", nb_states, \"LeftRight\", Nbiteration=300) \n", + "print(hsmc_est.display())" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "hsmc_est.plot(\"Sojourn\", 0, Title=\"Sojourn time distributions\")" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "hsmc_est.plot(\"Observation\", 1)" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "hsmc_est.plot(\"Intensity\", 1, Title=\"Lateral shoot type\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Simulate sequences**" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# TODO" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [], + "source": [ + "from openalea.sequence_analysis import Simulate" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [], + "source": [ + "from openalea.stat_tool.distribution import set_seed\n", + "set_seed(0)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Simulate *nb_seq* sequences with length *seq_length*" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [], + "source": [ + "nb_seq = 30\n", + "seq_length = 200\n", + "seq = hsm.simulation_nb_sequences(nb_seq, seq_length, True)\n", + "assert(len(seq) == nb_seq)\n", + "assert(len(seq[0]) == seq_length)\n", + "# NB: hsm has 1 output process but simulation includes the hidden state\n", + "assert(len(seq[0][1]) == 3)" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [], + "source": [ + "seq = hsm.simulation_nb_sequences(nb_seq, seq_length, True)" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[0, 0, 3], [0, 0, 20], [0, 0, 2], [0, 0, 0], [0, 0, 1], [0, 0, 11], [1, 3, 4], [1, 1, 2], [1, 2, 1], [1, 3, 3], [1, 4, 3], [1, 2, 3], [1, 4, 1], [1, 3, 5], [1, 2, 5], [1, 1, 1], [1, 1, 2], [1, 4, 5], [1, 4, 2], [1, 0, 4], [1, 3, 1], [1, 2, 2], [1, 2, 2], [1, 2, 3], [1, 4, 2], [1, 0, 3], [1, 2, 4], [1, 4, 1], [1, 2, 1], [1, 4, 2], [1, 4, 2], [1, 4, 4], [1, 4, 2], [1, 2, 0], [1, 3, 0], [1, 2, 2], [1, 0, 4], [1, 4, 3], [1, 4, 2], [1, 1, 1], [1, 3, 3], [1, 0, 4], [1, 2, 3], [1, 1, 3], [1, 0, 2], [1, 4, 0], [1, 2, 1], [1, 3, 3], [1, 2, 2], [1, 2, 4], [1, 1, 3], [1, 4, 2], [1, 3, 3], [1, 2, 1], [1, 2, 1], [1, 2, 3], [1, 0, 2], [1, 1, 1], [1, 2, 1], [1, 2, 1], [1, 4, 2], [1, 4, 1], [1, 3, 4], [1, 2, 3], [1, 4, 3], [1, 2, 2], [1, 2, 2], [1, 2, 2], [1, 0, 3], [1, 2, 2], [1, 1, 3], [1, 2, 3], [1, 3, 3], [1, 4, 4], [1, 2, 1], [1, 2, 1], [1, 2, 1], [1, 2, 2], [1, 3, 2], [1, 4, 1], [1, 0, 2], [1, 1, 2], [1, 4, 4], [1, 2, 3], [1, 2, 2], [1, 0, 1], [1, 3, 4], [1, 3, 4], [1, 2, 2], [1, 0, 0], [1, 4, 1], [1, 1, 1], [1, 2, 2], [1, 2, 0], [1, 1, 2], [1, 4, 4], [1, 0, 1], [1, 0, 1], [1, 3, 3], [1, 0, 3], [1, 2, 2], [1, 4, 2], [1, 0, 1], [1, 3, 3], [1, 3, 3], [1, 2, 2], [1, 0, 0], [1, 2, 1], [1, 2, 2], [1, 0, 3], [1, 2, 2], [1, 0, 1], [1, 3, 2], [1, 1, 1], [1, 4, 3], [1, 2, 1], [1, 2, 1], [1, 2, 2], [1, 2, 2], [1, 1, 2], [1, 2, 1], [1, 2, 2], [1, 3, 2], [1, 0, 1], [1, 2, 2], [1, 2, 2], [1, 3, 2], [1, 0, 1], [1, 3, 2], [1, 3, 1], [1, 2, 1], [1, 2, 1], [1, 0, 2], [1, 2, 2], [1, 0, 2], [1, 2, 1], [1, 4, 2], [1, 0, 1], [1, 4, 2], [1, 4, 5], [1, 2, 2], [1, 2, 3], [1, 2, 2], [1, 3, 2], [1, 2, 1], [1, 0, 3], [0, 0, 3], [0, 0, 0], [0, 0, 2], [0, 0, 27], [0, 0, 6], [0, 0, 0], [0, 0, 3], [0, 0, 7], [0, 0, 4], [0, 0, 3], [1, 2, 3], [1, 4, 2], [1, 0, 0], [1, 3, 2], [1, 2, 3], [1, 2, 4], [1, 0, 1], [1, 4, 3], [1, 0, 2], [1, 3, 1], [1, 2, 2], [1, 0, 2], [1, 2, 2], [1, 1, 3], [1, 3, 2], [1, 3, 0], [1, 1, 2], [1, 2, 2], [1, 2, 2], [1, 0, 3], [1, 2, 2], [1, 3, 3], [1, 2, 3], [1, 4, 5], [1, 3, 3], [1, 4, 2], [1, 4, 3], [1, 3, 4], [1, 0, 2], [1, 2, 1], [1, 3, 1], [1, 1, 4], [1, 2, 1], [1, 4, 1], [1, 3, 1], [1, 4, 1], [1, 2, 0], [1, 4, 4], [1, 3, 3], [1, 0, 2], [1, 2, 4], [1, 2, 2], [1, 4, 3], [1, 4, 0]]\n" + ] + } + ], + "source": [ + "# Print first simulated sequence.\n", + "# The first variable is the simulated state\n", + "print(seq[0])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Discard variable 1 (state)" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [], + "source": [ + "obs = seq.select_variable([1], keep=False)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Plotting marginal relative frequencies of data as a function of index" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Variable 1\n", + "obs.plot(\"Intensity\", 0)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## HSCM re-estimation" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Reestimate from default initialisation" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### TODO: check SOJOURN 0" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0\n", + "iteration 1 log-likelihood for the observed sequences: -30721.6\n", + "HIDDEN_SEMI-MARKOV_CHAIN\n", + "\n", + "3 STATES\n", + "\n", + "INITIAL_PROBABILITIES\n", + "0.0985587 0.331737 0.569704 \n", + "\n", + "TRANSITION_PROBABILITIES\n", + "0 0.0293854 0.970615 \n", + "0.118267 0 0.881733 \n", + "0.231242 0.768758 0 \n", + "\n", + "recurrent class: states 0 1 2\n", + "\n", + "time up to the first occurrence of state 0 distribution\n", + "mean: 372.032 median: 853 mode: 0\n", + "variance: 98155.9 standard deviation: 313.298 lower quartile: 291 upper quartile: -1\n", + "\n", + "time up to the first occurrence of state 0 frequency distribution - sample size: 1\n", + "mean: 149 median: 149 mode: 149\n", + "variance: 0 standard deviation: 0\n", + "\n", + "time up to the first occurrence of state 1 distribution\n", + "\n", + "time up to the first occurrence of state 1 frequency distribution - sample size: 24\n", + "mean: 55.1667 median: 8.5 mode: 0\n", + "variance: 5021.54 standard deviation: 70.8628 lower quartile: 0 upper quartile: 141\n", + "\n", + "time up to the first occurrence of state 2 distribution\n", + "\n", + "time up to the first occurrence of state 2 frequency distribution - sample size: 21\n", + "mean: 16.3333 median: 0 mode: 0\n", + "variance: 2664.13 standard deviation: 51.6152 lower quartile: 0 upper quartile: 0\n", + "\n", + "state 0 recurrence time distribution\n", + "mean: 56.9454 median: 1 mode: 1\n", + "variance: 32058.9 standard deviation: 179.05 lower quartile: 1 upper quartile: 1\n", + "\n", + "state 0 recurrence time frequency distribution - sample size: 0\n", + "\n", + "state 1 recurrence time distribution\n", + "\n", + "state 1 recurrence time frequency distribution - sample size: 3395\n", + "mean: 1 median: 1 mode: 1\n", + "variance: 0 standard deviation: 0\n", + "\n", + "state 2 recurrence time distribution\n", + "\n", + "state 2 recurrence time frequency distribution - sample size: 2559\n", + "mean: 1.00039 median: 1 mode: 1\n", + "variance: 0.000390778 standard deviation: 0.0197681 lower quartile: 1 upper quartile: 1\n", + "\n", + "STATE 0 OCCUPANCY_DISTRIBUTION\n", + "NEGATIVE_BINOMIAL INF_BOUND : 1 PARAMETER : -6.35236 PROBABILITY : 2.11579\n", + "mean: 4.35 median: -1 mode: 1\n", + "variance: 1.58333 standard deviation: 1.25831 lower quartile: -1 upper quartile: -1\n", + "coefficient of skewness: -0.0434921 coefficient of kurtosis: -0.312952\n", + "\n", + "state 0 sojourn time frequency distribution - sample size: 1\n", + "mean: 1 median: 1 mode: 1\n", + "variance: 0 standard deviation: 0\n", + "\n", + "state 0 forward sojourn time distribution\n", + "mean: 1.49785 median: -1 mode: 1\n", + "variance: 0.249995 standard deviation: 0.499995 lower quartile: 2 upper quartile: -1\n", + "\n", + "final run - state 0 sojourn time frequency distribution - sample size: 0\n", + "\n", + "STATE 1 OCCUPANCY_DISTRIBUTION\n", + "NEGATIVE_BINOMIAL INF_BOUND : 34 PARAMETER : 3.51526 PROBABILITY : 0.0105028\n", + "mean: 365.181 median: 334 mode: 270\n", + "variance: 31532.6 standard deviation: 177.574 lower quartile: 235 upper quartile: 462\n", + "coefficient of skewness: 1.06674 coefficient of kurtosis: 1.70688\n", + "\n", + "state 1 sojourn time frequency distribution - sample size: 2\n", + "mean: 171.5 median: 166.5 mode: 166\n", + "variance: 60.5 standard deviation: 7.77817 lower quartile: 166 upper quartile: 177\n", + "\n", + "state 1 forward sojourn time distribution\n", + "mean: 226.26 median: 189 mode: 17.5\n", + "variance: 30460.1 standard deviation: 174.528 lower quartile: 92 upper quartile: 320\n", + "\n", + "final run - state 1 sojourn time frequency distribution - sample size: 22\n", + "mean: 139.818 median: 186.5 mode: 200\n", + "variance: 5183.58 standard deviation: 71.9971 lower quartile: 59 upper quartile: 200\n", + "\n", + "STATE 2 OCCUPANCY_DISTRIBUTION\n", + "NEGATIVE_BINOMIAL INF_BOUND : 1 PARAMETER : 0.878848 PROBABILITY : 0.00581562\n", + "mean: 151.24 median: 99 mode: 1\n", + "variance: 25833.8 standard deviation: 160.729 lower quartile: 38 upper quartile: 209\n", + "coefficient of skewness: 2.13341 coefficient of kurtosis: 6.82716\n", + "\n", + "state 2 sojourn time frequency distribution - sample size: 14\n", + "mean: 105.214 median: 141 mode: 151\n", + "variance: 4288.95 standard deviation: 65.4901 lower quartile: 20 upper quartile: 151\n", + "\n", + "state 2 forward sojourn time distribution\n", + "mean: 161.505 median: 110 mode: 1\n", + "variance: 27011.3 standard deviation: 164.351 lower quartile: 45 upper quartile: 223\n", + "\n", + "final run - state 2 sojourn time frequency distribution - sample size: 8\n", + "mean: 138.375 median: 200 mode: 200\n", + "variance: 7286.27 standard deviation: 85.3596 lower quartile: 34.5 upper quartile: 200\n", + "\n", + "number of runs of state 0 per length 200 sequence distribution\n", + "\n", + "number of runs of state 0 per sequence frequency distribution - sample size: 30\n", + "mean: 0.0333333 median: 0 mode: 0\n", + "variance: 0.0333333 standard deviation: 0.182574 lower quartile: 0 upper quartile: 0\n", + "coefficient of skewness: 5.47723 coefficient of kurtosis: 24.1\n", + "\n", + "number of runs of state 1 per length 200 sequence distribution\n", + "\n", + "number of runs of state 1 per sequence frequency distribution - sample size: 30\n", + "mean: 0.8 median: 1 mode: 1\n", + "variance: 0.165517 standard deviation: 0.406838 lower quartile: 1 upper quartile: 1\n", + "coefficient of skewness: -1.58013 coefficient of kurtosis: 0.141667\n", + "\n", + "number of runs of state 2 per length 200 sequence distribution\n", + "\n", + "number of runs of state 2 per sequence frequency distribution - sample size: 30\n", + "mean: 0.733333 median: 1 mode: 1\n", + "variance: 0.271264 standard deviation: 0.52083 lower quartile: 0 upper quartile: 1\n", + "coefficient of skewness: -0.297532 coefficient of kurtosis: -0.526544\n", + "\n", + "number of occurrences of state 0 per length 200 sequence distribution\n", + "\n", + "number of occurrences of state 0 per sequence frequency distribution - sample size: 30\n", + "mean: 0.0333333 median: 0 mode: 0\n", + "variance: 0.0333333 standard deviation: 0.182574 lower quartile: 0 upper quartile: 0\n", + "coefficient of skewness: 5.47723 coefficient of kurtosis: 24.1\n", + "\n", + "number of occurrences of state 1 per length 200 sequence distribution\n", + "\n", + "number of occurrences of state 1 per sequence frequency distribution - sample size: 30\n", + "mean: 113.967 median: 166 mode: 200\n", + "variance: 7178.24 standard deviation: 84.7245 lower quartile: 35 upper quartile: 200\n", + "coefficient of skewness: -0.23113 coefficient of kurtosis: -1.76464\n", + "\n", + "number of occurrences of state 2 per length 200 sequence distribution\n", + "\n", + "number of occurrences of state 2 per sequence frequency distribution - sample size: 30\n", + "mean: 86 median: 70 mode: 0\n", + "variance: 7170.41 standard deviation: 84.6783 lower quartile: 0 upper quartile: 165\n", + "coefficient of skewness: 0.230423 coefficient of kurtosis: -1.76553\n", + "\n", + "theoretical state probabilities: -nan -nan -nan \n", + "restoration state probabilities: 0.000166667 0.569833 0.43 \n", + "\n", + "2 OUTPUT_PROCESSES\n", + "\n", + "OUTPUT_PROCESS 1 : CATEGORICAL\n", + "\n", + "STATE 0 OBSERVATION_DISTRIBUTION\n", + "OUTPUT 0 : 0.991467\n", + "OUTPUT 1 : 0.00162179\n", + "OUTPUT 2 : 0.00224435\n", + "OUTPUT 3 : 0.00194428\n", + "OUTPUT 4 : 0.00272246\n", + "\n", + "STATE 1 OBSERVATION_DISTRIBUTION\n", + "OUTPUT 0 : 0.205398\n", + "OUTPUT 1 : 0.290395\n", + "OUTPUT 2 : 0.202317\n", + "OUTPUT 3 : 0.106159\n", + "OUTPUT 4 : 0.195731\n", + "\n", + "STATE 2 OBSERVATION_DISTRIBUTION\n", + "OUTPUT 0 : 0.283595\n", + "OUTPUT 1 : 0.0800216\n", + "OUTPUT 2 : 0.279004\n", + "OUTPUT 3 : 0.170699\n", + "OUTPUT 4 : 0.18668\n", + "\n", + "observation probability matrix\n", + "\n", + " 0 1 2 3 4 \n", + "0 0.991467 0.00162179 0.00224435 0.00194428 0.00272246 \n", + "1 0.205398 0.290395 0.202317 0.106159 0.195731 \n", + "2 0.283595 0.0800216 0.279004 0.170699 0.18668 \n", + "\n", + "theoretical weights: -nan -nan -nan\n", + "\n", + "log-likelihood: -1e+37 (normalized: -1.66667e+33)\n", + "maximum possible log-likelihood: -9536.93 (information: -1.58949)\n", + "deviance: 2e+37\n", + "\n", + "chi-square test (1 degree of freedom)\n", + "chi-square value: 1e+37 critical probability: 0\n", + "reference chi-square value: 3.84146 reference critical probability: 0.05\n", + "reference chi-square value: 6.6349 reference critical probability: 0.01\n", + "\n", + "restoration weights: 0.000166667 0.569833 0.43\n", + "\n", + "log-likelihood: -9537.17 (normalized: -1.58953)\n", + "maximum possible log-likelihood: -9536.93 (information: -1.58949)\n", + "deviance: 0.486745\n", + "\n", + "chi-square test (4 degrees of freedom)\n", + "chi-square value: 0.488518 critical probability: 0.974609\n", + "reference chi-square value: 9.48773 reference critical probability: 0.05\n", + "\n", + "time up to the first occurrence of output 0 distribution\n", + "\n", + "time up to the first occurrence of output 0 frequency distribution - sample size: 30\n", + "mean: 2.63333 median: 0 mode: 0\n", + "variance: 17.2747 standard deviation: 4.15629 lower quartile: 0 upper quartile: 5\n", + "\n", + "time up to the first occurrence of output 1 distribution\n", + "\n", + "time up to the first occurrence of output 1 frequency distribution - sample size: 30\n", + "mean: 13.1333 median: 9 mode: 0\n", + "variance: 149.499 standard deviation: 12.227 lower quartile: 5 upper quartile: 20\n", + "\n", + "time up to the first occurrence of output 2 distribution\n", + "\n", + "time up to the first occurrence of output 2 frequency distribution - sample size: 30\n", + "mean: 10.7667 median: 12 mode: 0\n", + "variance: 79.5644 standard deviation: 8.91989 lower quartile: 3 upper quartile: 15\n", + "\n", + "time up to the first occurrence of output 3 distribution\n", + "\n", + "time up to the first occurrence of output 3 frequency distribution - sample size: 30\n", + "mean: 14.7333 median: 14 mode: 1\n", + "variance: 155.582 standard deviation: 12.4732 lower quartile: 6 upper quartile: 19\n", + "\n", + "time up to the first occurrence of output 4 distribution\n", + "\n", + "time up to the first occurrence of output 4 frequency distribution - sample size: 30\n", + "mean: 11.1333 median: 10 mode: 0.5\n", + "variance: 129.844 standard deviation: 11.3949 lower quartile: 1 upper quartile: 17\n", + "\n", + "output 0 recurrence time distribution\n", + "\n", + "output 0 recurrence time frequency distribution - sample size: 1428\n", + "mean: 4.04482 median: 3 mode: 1\n", + "variance: 15.4472 standard deviation: 3.93029 lower quartile: 1 upper quartile: 6\n", + "\n", + "output 1 recurrence time distribution\n", + "\n", + "output 1 recurrence time frequency distribution - sample size: 1164\n", + "mean: 4.63488 median: 3 mode: 1\n", + "variance: 28.0205 standard deviation: 5.29344 lower quartile: 1 upper quartile: 6\n", + "\n", + "output 2 recurrence time distribution\n", + "\n", + "output 2 recurrence time frequency distribution - sample size: 1374\n", + "mean: 4.03421 median: 3 mode: 1\n", + "variance: 14.2763 standard deviation: 3.7784 lower quartile: 2 upper quartile: 5\n", + "\n", + "output 3 recurrence time distribution\n", + "\n", + "output 3 recurrence time frequency distribution - sample size: 769\n", + "mean: 6.92848 median: 5 mode: 1\n", + "variance: 48.7852 standard deviation: 6.98464 lower quartile: 2 upper quartile: 9\n", + "\n", + "output 4 recurrence time distribution\n", + "\n", + "output 4 recurrence time frequency distribution - sample size: 1115\n", + "mean: 4.93274 median: 4 mode: 1\n", + "variance: 18.0897 standard deviation: 4.2532 lower quartile: 2 upper quartile: 7\n", + "\n", + "output 0 sojourn time distribution\n", + "\n", + "output 0 sojourn time frequency distribution - sample size: 956\n", + "mean: 1.51464 median: 1 mode: 1\n", + "variance: 5.04167 standard deviation: 2.24537 lower quartile: 1 upper quartile: 1\n", + "\n", + "final run - output 0 sojourn time frequency distribution - sample size: 8\n", + "mean: 1.25 median: 1 mode: 1\n", + "variance: 0.214286 standard deviation: 0.46291 lower quartile: 1 upper quartile: 1.5\n", + "\n", + "output 1 sojourn time distribution\n", + "\n", + "output 1 sojourn time frequency distribution - sample size: 871\n", + "mean: 1.36165 median: 1 mode: 1\n", + "variance: 0.518482 standard deviation: 0.720057 lower quartile: 1 upper quartile: 2\n", + "\n", + "final run - output 1 sojourn time frequency distribution - sample size: 7\n", + "mean: 1.14286 median: 1 mode: 1\n", + "variance: 0.142857 standard deviation: 0.377964 lower quartile: 1 upper quartile: 1\n", + "\n", + "output 2 sojourn time distribution\n", + "\n", + "output 2 sojourn time frequency distribution - sample size: 1053\n", + "mean: 1.31909 median: 1 mode: 1\n", + "variance: 0.470329 standard deviation: 0.685806 lower quartile: 1 upper quartile: 1\n", + "\n", + "final run - output 2 sojourn time frequency distribution - sample size: 10\n", + "mean: 1.5 median: 1 mode: 1\n", + "variance: 0.944444 standard deviation: 0.971825 lower quartile: 1 upper quartile: 2\n", + "\n", + "output 3 sojourn time distribution\n", + "\n", + "output 3 sojourn time frequency distribution - sample size: 674\n", + "mean: 1.18398 median: 1 mode: 1\n", + "variance: 0.24842 standard deviation: 0.498418 lower quartile: 1 upper quartile: 1\n", + "\n", + "final run - output 3 sojourn time frequency distribution - sample size: 1\n", + "mean: 1 median: 1 mode: 1\n", + "variance: 0 standard deviation: 0\n", + "\n", + "output 4 sojourn time distribution\n", + "\n", + "output 4 sojourn time frequency distribution - sample size: 927\n", + "mean: 1.22762 median: 1 mode: 1\n", + "variance: 0.25807 standard deviation: 0.508006 lower quartile: 1 upper quartile: 1\n", + "\n", + "final run - output 4 sojourn time frequency distribution - sample size: 4\n", + "mean: 1.75 median: 2 mode: 2\n", + "variance: 0.25 standard deviation: 0.5 lower quartile: 1.5 upper quartile: 2\n", + "\n", + "number of runs of output 0 per length 200 sequence distribution\n", + "\n", + "number of runs of output 0 per sequence frequency distribution - sample size: 30\n", + "mean: 32.1333 median: 33 mode: 33.5\n", + "variance: 13.3609 standard deviation: 3.65526 lower quartile: 30 upper quartile: 34\n", + "coefficient of skewness: -0.0825025 coefficient of kurtosis: 0.0197206\n", + "\n", + "number of runs of output 1 per length 200 sequence distribution\n", + "\n", + "number of runs of output 1 per sequence frequency distribution - sample size: 30\n", + "mean: 29.2667 median: 28.5 mode: 19\n", + "variance: 137.513 standard deviation: 11.7266 lower quartile: 19 upper quartile: 39\n", + "coefficient of skewness: -0.0858458 coefficient of kurtosis: -1.52709\n", + "\n", + "number of runs of output 2 per length 200 sequence distribution\n", + "\n", + "number of runs of output 2 per sequence frequency distribution - sample size: 30\n", + "mean: 35.4333 median: 35 mode: 32.5\n", + "variance: 37.5644 standard deviation: 6.12898 lower quartile: 32 upper quartile: 39\n", + "coefficient of skewness: 0.655432 coefficient of kurtosis: 0.171717\n", + "\n", + "number of runs of output 3 per length 200 sequence distribution\n", + "\n", + "number of runs of output 3 per sequence frequency distribution - sample size: 30\n", + "mean: 22.5 median: 22.5 mode: 18\n", + "variance: 32.3966 standard deviation: 5.6918 lower quartile: 20 upper quartile: 27\n", + "coefficient of skewness: -0.409942 coefficient of kurtosis: -0.176952\n", + "\n", + "number of runs of output 4 per length 200 sequence distribution\n", + "\n", + "number of runs of output 4 per sequence frequency distribution - sample size: 30\n", + "mean: 31.0333 median: 30.5 mode: 26\n", + "variance: 23.8954 standard deviation: 4.88829 lower quartile: 28 upper quartile: 33\n", + "coefficient of skewness: 0.593277 coefficient of kurtosis: 0.228166\n", + "\n", + "number of occurrences of output 0 per length 200 sequence distribution\n", + "\n", + "number of occurrences of output 0 per sequence frequency distribution - sample size: 30\n", + "mean: 48.6 median: 47.5 mode: 47\n", + "variance: 77.8345 standard deviation: 8.82239 lower quartile: 43 upper quartile: 54\n", + "coefficient of skewness: 0.353086 coefficient of kurtosis: 0.0392652\n", + "\n", + "number of occurrences of output 1 per length 200 sequence distribution\n", + "\n", + "number of occurrences of output 1 per sequence frequency distribution - sample size: 30\n", + "mean: 39.8 median: 44 mode: 11\n", + "variance: 366.579 standard deviation: 19.1463 lower quartile: 22 upper quartile: 56\n", + "coefficient of skewness: -0.0120296 coefficient of kurtosis: -1.558\n", + "\n", + "number of occurrences of output 2 per length 200 sequence distribution\n", + "\n", + "number of occurrences of output 2 per sequence frequency distribution - sample size: 30\n", + "mean: 46.8 median: 42.5 mode: 40\n", + "variance: 105.062 standard deviation: 10.25 lower quartile: 39 upper quartile: 55\n", + "coefficient of skewness: 0.546676 coefficient of kurtosis: -0.722483\n", + "\n", + "number of occurrences of output 3 per length 200 sequence distribution\n", + "\n", + "number of occurrences of output 3 per sequence frequency distribution - sample size: 30\n", + "mean: 26.6333 median: 24.5 mode: 21\n", + "variance: 64.792 standard deviation: 8.04934 lower quartile: 21 upper quartile: 32\n", + "coefficient of skewness: 0.258381 coefficient of kurtosis: -0.414003\n", + "\n", + "number of occurrences of output 4 per length 200 sequence distribution\n", + "\n", + "number of occurrences of output 4 per sequence frequency distribution - sample size: 30\n", + "mean: 38.1667 median: 37.5 mode: 34\n", + "variance: 41.6609 standard deviation: 6.45453 lower quartile: 34 upper quartile: 43\n", + "coefficient of skewness: 0.12706 coefficient of kurtosis: -0.530402\n", + "\n", + "distances between observation distributions for consecutive states\n", + "_ 0.786069 0.707872 \n", + "0.786069 _ 0.219425 \n", + "0.707872 0.219425 _ \n", + "\n", + "OUTPUT_PROCESS 2 : DISCRETE_PARAMETRIC\n", + "\n", + "STATE 0 OBSERVATION_DISTRIBUTION\n", + "NEGATIVE_BINOMIAL INF_BOUND : 5 PARAMETER : 1.4095 PROBABILITY : 0.209705\n", + "mean: 10.3118 median: 9 mode: 6\n", + "variance: 25.3301 standard deviation: 5.0329 lower quartile: 7 upper quartile: 13\n", + "\n", + "state 0 observation frequency distribution - sample size: 1\n", + "mean: 27 median: 27 mode: 27\n", + "variance: 0 standard deviation: 0\n", + "\n", + "STATE 1 OBSERVATION_DISTRIBUTION\n", + "BINOMIAL INF_BOUND : 1 SUP_BOUND : 66 PROBABILITY : 0.138125\n", + "mean: 9.97813 median: 10 mode: 10\n", + "variance: 7.73803 standard deviation: 2.78173 lower quartile: 8 upper quartile: 12\n", + "\n", + "state 1 observation frequency distribution - sample size: 3419\n", + "mean: 9.969 median: 10 mode: 10\n", + "variance: 7.80419 standard deviation: 2.7936 lower quartile: 8 upper quartile: 12\n", + "\n", + "STATE 2 OBSERVATION_DISTRIBUTION\n", + "NEGATIVE_BINOMIAL INF_BOUND : 0 PARAMETER : 2.7191 PROBABILITY : 0.527675\n", + "mean: 2.43388 median: 2 mode: 1\n", + "variance: 4.61247 standard deviation: 2.14767 lower quartile: 1 upper quartile: 4\n", + "\n", + "state 2 observation frequency distribution - sample size: 2580\n", + "mean: 2.49419 median: 2 mode: 2\n", + "variance: 5.17833 standard deviation: 2.27559 lower quartile: 1 upper quartile: 3\n", + "\n", + "mixture - theoretical weights: -nan -nan -nan\n", + "mean: -nan median: -1 mode: 0\n", + "variance: nan standard deviation: nan\n", + "\n", + "marginal frequency distribution - sample size: 6000\n", + "mean: 6.75767 median: 7 mode: 2\n", + "variance: 20.436 standard deviation: 4.52062 lower quartile: 2 upper quartile: 10\n", + "\n", + "log-likelihood: -1e+37 (normalized: -1.66667e+33)\n", + "maximum possible log-likelihood: -16374.1 (information: -2.72902)\n", + "deviance: 2e+37\n", + "\n", + "chi-square test (1 degree of freedom)\n", + "chi-square value: 1e+37 critical probability: 0\n", + "reference chi-square value: 3.84146 reference critical probability: 0.05\n", + "reference chi-square value: 6.6349 reference critical probability: 0.01\n", + "\n", + "mixture - restoration weights: 0.000166667 0.569833 0.43\n", + "mean: 6.73416 median: 7 mode: 1\n", + "variance: 20.3474 standard deviation: 4.51081 lower quartile: 2 upper quartile: 10\n", + "\n", + "marginal frequency distribution - sample size: 6000\n", + "mean: 6.75767 median: 7 mode: 2\n", + "variance: 20.436 standard deviation: 4.52062 lower quartile: 2 upper quartile: 10\n", + "\n", + "log-likelihood: -16598.3 (normalized: -2.76639)\n", + "maximum possible log-likelihood: -16374.1 (information: -2.72902)\n", + "deviance: 448.496\n", + "\n", + "chi-square test (21 degrees of freedom)\n", + "chi-square value: 438.86 critical probability: 8.12459e-80\n", + "reference chi-square value: 32.6706 reference critical probability: 0.05\n", + "reference chi-square value: 38.9322 reference critical probability: 0.01\n", + "\n", + "distances between observation distributions for consecutive states\n", + "_ 0.271745 0.799404 \n", + "0.271745 _ 0.866013 \n", + "0.799404 0.866013 _ \n", + "\n", + "sequence length frequency distribution - sample size: 30\n", + "mean: 200 median: 200 mode: 200\n", + "variance: 0 standard deviation: 0\n", + "\n", + "cumulative length: 6000\n", + "\n", + "information quantity of the sequences in the i.i.d. case: -25911 (-4.3185)\n", + "\n", + "log-likelihood for the state sequences: -22820.3 (normalized: -3.80338)\n", + "\n", + "state sequence entropy: 0.000899438 (normalized: 1.49906e-07)\n", + "\n", + "log-likelihood for the observed sequences: -22813.3 (normalized: -3.80221)\n", + "\n", + "30 free parameters 2 * penalyzed log-likelihood (AIC): -45686.5\n", + "\n", + "30 free parameters 2 * penalyzed log-likelihood (AICc): -45686.8\n", + "\n", + "30 free parameters 2 * penalyzed log-likelihood (BIC): -45887.5\n", + "\n", + "30 free parameters 2 * penalyzed log-likelihood (BICc): -nan\n", + "\n", + "30 free parameters 2 * penalyzed log-likelihood (ICL): -45887.5\n", + "\n", + "30 free parameters 2 * penalyzed log-likelihood (ICLc): -nan\n", + "\n", + "iteration 2 log-likelihood for the observed sequences: -24254.8\n", + "iteration 3 log-likelihood for the observed sequences: -22869.2\n", + "iteration 4 log-likelihood for the observed sequences: -22828.9\n", + "iteration 5 log-likelihood for the observed sequences: -1e+37\n", + "\n", + " Convergence failed, returning saved model with highest likelihood\n", + "\n", + "5 iterations\n", + "\n", + "complete/censored state occupancy weights\n", + "state 0: 0, 0\n", + "state 1: 0, 0\n", + "state 2: 0, 0\n", + "\n", + "log-likelihood for the state sequences: -22820.3 | -22820.3\n", + "\n", + "posterior state sequence probability\n", + "sequence 1: 0.570582\n", + "sequence 2: 0.910947\n", + "sequence 3: 0.614839\n", + "sequence 4: 0.919921\n", + "sequence 5: 0.993795\n", + "sequence 6: 0.999546\n", + "sequence 7: 0.998589\n", + "sequence 8: 0.926546\n", + "sequence 9: 0.830382\n", + "sequence 10: 0.701984\n", + "sequence 11: 0.846566\n", + "sequence 12: 0.997408\n", + "sequence 13: 0.999914\n", + "sequence 14: 0.998913\n", + "sequence 15: 0.999073\n", + "sequence 16: 0.891238\n", + "sequence 17: 0.997586\n", + "sequence 18: 0.635101\n", + "sequence 19: 0.728447\n", + "sequence 20: 0.384474\n", + "sequence 21: 0.842883\n", + "sequence 22: 0.501847\n", + "sequence 23: 0.99466\n", + "sequence 24: 0.988268\n", + "sequence 25: 0.999257\n", + "sequence 26: 0.998908\n", + "sequence 27: 0.756495\n", + "sequence 28: 0.503857\n", + "sequence 29: 0.728201\n", + "sequence 30: 0.377395\n" + ] + } + ], + "source": [ + "from openalea.sequence_analysis import Estimate\n", + "nb_states = hsm.get_nb_state()\n", + "\n", + "hsmc_est = Estimate(obs, \"HIDDEN_SEMI-MARKOV\", \"Ordinary\", nb_states, \"Irreducible\", Nbiteration=300) \n", + "print(hsmc_est.display())" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Plotting marginal relative frequencies of data and predicted probabilities as a function of index" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "hsmc_est.plot(\"Intensity\", 1)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Observation (i.e., emission) distributions" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "hsmc_est.plot(\"Observation\", 1)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This continues as before: empirical and predicted statistics" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "hsmc_est.plot(\"Counting\", 1)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "hsmc_est.plot(\"Recurrence\", 1)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "hsmc_est.plot(\"Sojourn\", 1)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Note that you may also plot figures individually (and not as a collection of figures)" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from openalea.sequence_analysis import seq_map\n", + "hsmc_est.extract(seq_map['Observation'],1,1).plot(Title=\"Observation distribution for state 1\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "hsmc_est.extract(seq_map['Sojourn'],0,0).plot(Title=\"Sojourn distribution for state 0\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Reestimate from true model" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "hsmc_est = Estimate(obs, \"HIDDEN_SEMI-MARKOV\", hsm, Nbiteration=300) \n", + "print(hsmc_est.display())" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "hsmc_est.plot(\"Observation\", 1)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## TODO: check why single plot" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "hsmc_est.plot(\"Observation\", 2)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "hsmc_est.plot(\"Sojourn\", 0)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# State restoration: Viterbi algorithm" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "restored = hsmc_est.state_sequence_computation(obs, True)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Percentages of correct restoration per state value" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# number of values in state 0\n", + "v0 = len([i for s in range(len(seq)) for i in range(len(seq[s])) if seq[s][i][0] == 0])\n", + "# number of values in state 0 with restored state 1\n", + "m0 = len([i for s in range(len(seq)) for i in range(len(seq[s])) if seq[s][i][0] == 0 and restored[s][i][0] == 1])\n", + "# number of values in state 1\n", + "v1 = len([i for s in range(len(seq)) for i in range(len(seq[s])) if seq[s][i][0] == 1])\n", + "# number of values in state 0 with restored state 1\n", + "m1 = len([i for s in range(len(seq)) for i in range(len(seq[s])) if seq[s][i][0] == 1 and restored[s][i][0] == 0])\n", + "# number of values in state 2\n", + "v2 = len([i for s in range(len(seq)) for i in range(len(seq[s])) if seq[s][i][0] == 2])\n", + "# number of values in state 2 with restored state 2\n", + "m2 = len([i for s in range(len(seq)) for i in range(len(seq[s])) if seq[s][i][0] == 2 and restored[s][i][0] == 2])\n", + "print((m0/v0, m1/v1, m2/v2))\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.13.9" + }, + "toc": { + "base_numbering": 1, + "nav_menu": {}, + "number_sections": true, + "sideBar": true, + "skip_h1_title": false, + "title_cell": "Table of Contents", + "title_sidebar": "Contents", + "toc_cell": false, + "toc_position": {}, + "toc_section_display": true, + "toc_window_display": false + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/tutorials/hidden_switching_semi_markov_lm.ipynb b/doc/examples/hidden_switching_semi_markov_lm.ipynb similarity index 99% rename from tutorials/hidden_switching_semi_markov_lm.ipynb rename to doc/examples/hidden_switching_semi_markov_lm.ipynb index ea44123..60cbdf8 100644 --- a/tutorials/hidden_switching_semi_markov_lm.ipynb +++ b/doc/examples/hidden_switching_semi_markov_lm.ipynb @@ -55,7 +55,7 @@ "from openalea.stat_tool.cluster import Transcode, Cluster\n", "\n", "import openalea.stat_tool.plot #import DISABLE_PLOT\n", - "# openalea.stat_tool.plot.DISABLE_PLOT = True\n", + "# \n", "from openalea.stat_tool.plot import DISABLE_PLOT\n", "DISABLE_PLOT = False\n", "\n", diff --git a/tutorials/seq1v_5s_LR_init.hsmc b/doc/examples/seq1v_5s_LR_init.hsmc similarity index 100% rename from tutorials/seq1v_5s_LR_init.hsmc rename to doc/examples/seq1v_5s_LR_init.hsmc diff --git a/doc/examples/sequences.ipynb b/doc/examples/sequences.ipynb new file mode 100755 index 0000000..a71317f --- /dev/null +++ b/doc/examples/sequences.ipynb @@ -0,0 +1,459 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "#!/usr/bin/python3.10" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Prerequisites: matplotlib" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Configuration" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**It is assumed that this notebook is run from StructureAnalysis/sequence_analysis/tutorials**" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Running cmake --build & --install in /home/jdurand/devlp/Git/openalea/stat_tool/build\n", + "Running cmake --build & --install in /home/jdurand/devlp/Git/openalea/sequence_analysis/build\n" + ] + } + ], + "source": [ + "import numpy as np\n", + "from openalea.sequence_analysis import Estimate\n", + "from openalea.sequence_analysis import Plot\n", + "import os\n", + "import pandas as pd\n", + "# import random\n", + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "##### Place variables in markdown outputs" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "from IPython.display import Markdown\n", + "from IPython.core.magic import register_cell_magic\n", + "\n", + "\n", + "@register_cell_magic\n", + "def markdown(line, cell):\n", + " return Markdown(cell.format(**globals()))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Loading and preparing data" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "import sys, os" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "['/home/jdurand/usr/local/openalea',\n", + " '/home/jdurand/miniforge3/envs/statdev/lib/python313.zip',\n", + " '/home/jdurand/miniforge3/envs/statdev/lib/python3.13',\n", + " '/home/jdurand/miniforge3/envs/statdev/lib/python3.13/lib-dynload',\n", + " '',\n", + " '/home/jdurand/miniforge3/envs/statdev/lib/python3.13/site-packages',\n", + " '/home/jdurand/devlp/Git/openalea/sequence_analysis/src/openalea',\n", + " '/home/jdurand/devlp/Git/openalea/stat_tool/src/openalea']" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "sys.path" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "from pathlib import Path\n", + "from openalea.sequence_analysis import __path__ as seq_path\n", + "data_path = Path(seq_path[0])\n", + "data_path = str(Path.joinpath(data_path.parent.parent.parent.absolute(), \"share\",\"data\"))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Read Sequences from an existing file**" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "from openalea.sequence_analysis import (get_shared_data, \n", + " Sequences,\n", + " _MarkovianSequences)\n", + "data_file = \"belren1.seq\"\n", + "\n", + "seq = Sequences(get_shared_data(data_file))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Print the first sequence in lines** \n", + "`print(seq[0])` would print in a column." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[2 2 2 2 1 1 1 0 0 0 1 1 1 3 3 1 1 0 1 1 1 0 1 4 4 4 4 4 4 4 4 4 4 4 4 4\n", + " 4 4 4 4 1 0 0 0 4 4 4 4 0 0 0 0 0 0 0 0 0 0 0 0 2 0 0 0 0 0 0 0 2 0 2 0\n", + " 0 0 0 1 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0]]\n" + ] + } + ], + "source": [ + "import numpy\n", + "a0 = numpy.array(seq[0])\n", + "l0 = len(a0)\n", + "a0.resize(1,l0)\n", + "print(a0)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Exploration of Sequences" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Number of sequences" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "15" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "len(seq)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "15" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "seq.nb_sequence" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Number of variables" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "1" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "seq.nb_variable" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Identifiers of sequences (indices)" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "seq.get_identifiers()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### TODO (currently fails)" + ] + }, + { + "cell_type": "raw", + "metadata": {}, + "source": [ + "\n", + "# print(seq.get_characteristics(1))" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "91" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "seq.get_length(0)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### TODO (currently fails)" + ] + }, + { + "cell_type": "raw", + "metadata": {}, + "source": [ + "seq.get_marginal_histogram(1)" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "5.45737676020835e-310" + ] + }, + "execution_count": 19, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "seq.get_max_value(1)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Operation on Sequences: select / reject / merge individuals or variables" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [], + "source": [ + "# Select sequence (individual) 1\n", + "seq0 = seq.select_individual([1], True)" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Plot the sequence\n", + "Plot(seq0, ViewPoint=\"Data\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Note that the graph is consistent with ascii output" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [], + "source": [ + "seq0 = seq.select_individual([1], True)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.13.9" + }, + "toc": { + "base_numbering": 1, + "nav_menu": {}, + "number_sections": true, + "sideBar": true, + "skip_h1_title": false, + "title_cell": "Table of Contents", + "title_sidebar": "Contents", + "toc_cell": false, + "toc_position": {}, + "toc_section_display": true, + "toc_window_display": false + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/doc/examples/sequences.qmd b/doc/examples/sequences.qmd new file mode 100644 index 0000000..ee54e90 --- /dev/null +++ b/doc/examples/sequences.qmd @@ -0,0 +1,397 @@ +--- +jupyter: + jupytext: + text_representation: + extension: .qmd + format_name: quarto + format_version: '1.0' + jupytext_version: 1.18.1 + kernelspec: + display_name: Python 3 (ipykernel) + language: python + name: python3 +--- + +```{python} +#!/usr/bin/python3.10 +``` + +Prerequisites: pandas, xlrd, matplotlib, rpy2 + +# HSMC modelling + +## Configuration +### It is assumed that this notebook is run from StructureAnalysis/sequence_analysis/tutorials + +```{python} +import numpy as np +from openalea.sequence_analysis import Estimate +from openalea.sequence_analysis import Plot +import os +import pandas as pd +# import random +import matplotlib.pyplot as plt +``` + +##### Check pandas version + +```{python} +# print pd.__version__ +``` + +```{python} +import xlrd +xlrd.__version__ +``` + +##### Enabling R extensions + +```{python} +%load_ext rpy2.ipython +``` + +##### Place variables in markdown outputs + +```{python} +from IPython.display import Markdown +from IPython.core.magic import register_cell_magic + + +@register_cell_magic +def markdown(line, cell): + return Markdown(cell.format(**globals())) +``` + +## Determining if images have to be saved (not used for the moment) + +## Loading and preparing data + +```{python} +import sys, os +``` + +```{python} +sys.path +``` + +```{python} +sys.path.append(".." + os.sep + "tutorials") +``` + +```{python} +from openalea.seqint import model +``` + +```{python} +import graphviz +``` + +```{python} +import numpy as np + +from Utils import * +from Code.amlseq2R import * +``` + +```{python} +print(os.getcwd()) +``` + +```{python} +home_dir = "./" +base_path = home_dir +ressource_path = base_path +os.chdir(base_path) +``` + +```{python} +os.listdir(ressource_path + os.sep ) +``` + +**Read an existing HSMC model** + +```{python} +from openalea.sequence_analysis import HiddenSemiMarkov + +model_file = "sim_v_5s_LR.hsmc" +#model_file = "init_v_5s_LR.hsmc" +hmsc = HiddenSemiMarkov(ressource_path + os.sep + model_file) +``` + +**Simulate sequences** + +```{python} +from openalea.sequence_analysis import Simulate +``` + +```{python} +nb_seq = 10 +seq_length = 100 +seq = hmsc.simulation_nb_sequences(nb_seq, seq_length, True) +``` + +```{python} +# Print first simulated sequence. +# First variable is the simulated state +print(seq[0]) +``` + +**Perform operations on sequences** + +```{python} +# Discard variable 1 (state) +obs = seq.select_variable([1], keep=False) +``` + +## Plotting marginal probabilities of data + +```{python} +# Variable 1: lateral shoot type +obs.plot("Intensity", 0) +plt.show() +``` + +```{python} +# Variable 2: lateral flowering +obs.plot("Intensity", 1) +plt.show() +``` + +```{python} +# Variable 3: terminal flowering +obs.plot("Intensity", 2) +plt.show() +``` + +## HSCM re-estimation + +```{python} +# Discard state variable +seq1v = seq.select_variable([2, 3, 4], True) +``` + +```{python} +nb_states = 5 +init_file = base_path + os.sep + "seq1v_" + str(nb_states) + "s_LR_init.hsmc" +``` + +```{python} +from openalea.sequence_analysis import Estimate +from openalea.sequence_analysis import HiddenSemiMarkov +``` + +```{python} +# Conversion dos2unix file if needed +try: + hmsc_init = HiddenSemiMarkov(init_file) +except: + dos2unix(init_file, init_file) +hmsc_init = HiddenSemiMarkov(init_file) +``` + +### Estimate HSCM with default initialization + +Left-right model + +```{python} +hsmc1 = Estimate(seq1v, "HIDDEN_SEMI-MARKOV", "Ordinary", nb_states, "LeftRight", Nbiteration=300) +print(hsmc1) +``` + +Irreducible model + +### Plot model and data characteristics. +Syntax: hsmc1.extract(int type, int variable, int value) +types correspond to SELF_TRANSITION , OBSERVATION , INTENSITY , FIRST_OCCURRENCE , RECURRENCE_TIME , SOJOURN_TIME , INITIAL_RUN , FINAL_RUN , NB_RUN , NB_OCCURRENCE , COUNTING , LENGTH , SEQUENCE_CUMUL , SEQUENCE_MEAN + +```{python} +# Type 1: emission distribution, Variable 1: lateral shoot type, State 4 +hsmc1.extract(1, 1, 4).plot() +plt.show() +``` + +```{python} +# hsmc1.extract(2, 1, 4).plot() +``` + +```{python} +# All emission distributions for variable 1 +plt.figure(1) +for i in range(5): + plt.subplot(3,3, i+1) + hsmc1.extract(1, 1, i).plot() +``` + +### TODO: states 3 and 4 are swapped? + +```{python} +# All emission distributions for variable 2 +plt.figure(1) +for i in range(5): + plt.subplot(3,3, i+1) + hsmc1.extract(1, 2, i).plot() +``` + +```{python} +print(Estimate(seq1v, "HIDDEN_SEMI-MARKOV", "Ordinary", nb_states, "Irreducible", Nbiteration=300)) +``` + +Discard state sequence computations (entropy, Viterbi?) + +```{python} +print(Estimate(seq1v, "HIDDEN_SEMI-MARKOV", "Ordinary", nb_states, "Irreducible", Nbiteration=300, StateSequence=False)) +``` + +Using the MCEM option would cause the library to crash + +print(Estimate(seq1v, "HIDDEN_SEMI-MARKOV", "Ordinary", nb_states, "Irreducible", Nbiteration=300, Algorithm="MCEM", MinNbStateSequence=1, MaxNbStateSequence=10, Parameter=10)) + +Using the Equilibrium option (stationary) would cause the library to crash + +print(Estimate(seq1v, "HIDDEN_SEMI-MARKOV", "Equilibrium", nb_states)) + +Change option in means of initial occupancy distributions + +```{python} +print(Estimate(seq1v, "HIDDEN_SEMI-MARKOV", "Ordinary", nb_states, "Irreducible", Nbiteration=300, InitialOccupancyMean=20)) +``` + +Change option in estimating occupancy distributions (censoring, etc.?) + +```{python} +print(Estimate(seq1v, "HIDDEN_SEMI-MARKOV", "Ordinary", nb_states, "Irreducible", Nbiteration=300, Estimator="KaplanMeier")) +``` + +Change option in state sequence restoration (Viterbi vs. smoothing) + +```{python} +print(Estimate(seq1v, "HIDDEN_SEMI-MARKOV", "Ordinary", nb_states, "Irreducible", Nbiteration=300, StateSequences="ForwardBackward")) +``` + +Change option in estimating occupancy distributions + +```{python} +print(Estimate(seq1v, "HIDDEN_SEMI-MARKOV", "Ordinary", nb_states, "Irreducible", Nbiteration=300, OccupancyMean="Estimated")) +``` + +Other options in estimate + +```{python} +help(Estimate) +``` + +### Estimate HSCM with manual initialization from file + +```{python} +hsmc1 = Estimate(seq1v, "HIDDEN_SEMI-MARKOV", hmsc_init, NbIteration=300) +print(hsmc1) +``` + +### Export states + +```{python} +from openalea.sequence_analysis import ExtractData +seg = ExtractData(hsmc1) # Data and segmentation +``` + +```{python} +# Restored states are added as the first variable to seq_1v, see +print(seg[0][0:10]) +print(seq1v[0][0:10]) +``` + +```{python} +seg_dir = "Results" +``` + +```{python} +if not os.path.exists(seg_dir): + # if the seg_dir directory is not present + # then create it. + os.makedirs(seg_dir) +``` + +```{python} +# Export into file + +seg_file = "seq1v_" + str(nb_states) + "s_LR_segm.seq" +output_Rpyseq1_file = seg_dir + os.sep + seg_file[0:-4] + ".csv" +WriteRSequence(seg, output_Rpyseq1_file, RestoredStatesHeader()) +``` + +Create DataFrame + +```{python} +df = pd.read_csv(output_Rpyseq1_file, index_col=0, comment="#", usecols=range(6)) +var_names = [' axillary shoot type',' lateral flowering', ' terminal flowering'] +df = df[var_names] +``` + +```{python} +# Add sequence identifiers to DF +seqid = [] +for i in range(len(seq1v)): + seqid += [i+1] * len(seq1v[i]) +seqid +df["seqid"] = seqid +``` + +```{python} +from seqint.pyseq_data_frame import PySeqDataFrame +pyd = PySeqDataFrame(df, seq_index_name="seqid") +pyd.seq_index_name +pyd.col_to_seq(var_names) +seqc = pyd.get_input_sequence(var_names) +``` + +```{python} +assert(str(seqc[0]) == str(seq1v[0])) +``` + +### Embed HSCM within Model class for automatic parameter visualization + +```{python} +output_path = base_path + os.sep + "Results" +model = Model(pyd, output_process_name=var_names, init_hsmc_file=init_file, output_path=output_path) +model.iterate_em(300) +model.hsmm.save(os.path.join(output_path, 'seq1v_' + str(nb_states) + 's_LR.hsmc')) +model.print_hsmc_file(verbose=False) +``` + +```{python} +from seqint import html_report + +output_path = "." + os.sep + "tmp_dir" + +if not os.path.exists(output_path): + os.mkdir(output_path) + +report = html_report.Htmlreport(model, output_path=output_path) +report.make_html(True) +``` + +*Removing some garbage files* + +```{python} +report_prefix = report._html_report_file_path[0:-11] +report_prefix = report_prefix.split("/")[2] +import glob +for f in glob.glob("." +os.sep + "*.dat"): + os.remove(f) +``` + +```{python} +print("Report printed in " + str(report._html_report_file_path)) +``` + +```{python} +import shutil +#shutil.rmtree(tempdir) +``` + +```{python} +import dill +# dill.dump_session('notebook_env.db') +``` + + diff --git a/tutorials/sim_v_5s_LR.hsmc b/doc/examples/sim_v_5s_LR.hsmc similarity index 100% rename from tutorials/sim_v_5s_LR.hsmc rename to doc/examples/sim_v_5s_LR.hsmc diff --git a/doc/pyplots/example_oak_2.py b/doc/pyplots/example_oak_2.py index 978cef6..c935004 100644 --- a/doc/pyplots/example_oak_2.py +++ b/doc/pyplots/example_oak_2.py @@ -14,22 +14,20 @@ # ######################################################################### """ + __revision__ = "$Id: test_exploratory.py 8676 2010-04-20 15:28:46Z cokelaer $" +from os.path import join as pj + from openalea.sequence_analysis import * -from openalea.sequence_analysis.estimate import Estimate from openalea.sequence_analysis import get_shared_data as path -from os.path import join as pj -seq0 = Sequences(pj(path ,"chene_sessile_15pa.seq")) +seq0 = Sequences(pj(path("chene_sessile_15pa.seq"))) # change of unit for the variable diameter of the annual shoot marginal3 = ExtractHistogram(seq0, "Value", 3) Plot(Cluster(marginal3, "Information", 0.75)) -#Plot(Cluster(marginal3, "Information", 0.61)) -#Plot(Cluster(marginal3, "Step", 10)) - - - +# Plot(Cluster(marginal3, "Information", 0.61)) +# Plot(Cluster(marginal3, "Step", 10)) diff --git a/doc/pyplots/example_oak_4.py b/doc/pyplots/example_oak_4.py index 651381b..b5e03d8 100644 --- a/doc/pyplots/example_oak_4.py +++ b/doc/pyplots/example_oak_4.py @@ -14,27 +14,27 @@ # ######################################################################### """ + __revision__ = "$Id: test_exploratory.py 8676 2010-04-20 15:28:46Z cokelaer $" from openalea.sequence_analysis import * -from openalea.sequence_analysis.estimate import Estimate from openalea.sequence_analysis import get_shared_data as path -from os.path import join as pj -seq0 = Sequences(pj(path ,"chene_sessile_15pa.seq")) -#Plot(seq0, ViewPoint="Data") + +seq0 = Sequences(path("chene_sessile_15pa.seq")) +# Plot(seq0, ViewPoint="Data") # change of unit for the variable diameter of the annual shoot marginal3 = ExtractHistogram(seq0, "Value", 3) -#Plot(Cluster(marginal3, "Information", 0.75)) -#Plot(Cluster(marginal3, "Information", 0.61)) -#Plot(Cluster(marginal3, "Step", 10)) +# Plot(Cluster(marginal3, "Information", 0.75)) +# Plot(Cluster(marginal3, "Information", 0.61)) +# Plot(Cluster(marginal3, "Step", 10)) vec10 = Vectors(seq0) # plot of the average sequence -#Plot(Regression(vec10, "MovingAverage", 1, 2, [1])) +# Plot(Regression(vec10, "MovingAverage", 1, 2, [1])) vec95 = ValueSelect(vec10, 1, 95) vec96 = ValueSelect(vec10, 1, 96) @@ -43,10 +43,12 @@ VarianceAnalysis(vec10, 1, 2, "N") -#print type(ExtractHistogram(vec95, 2)) +# print type(ExtractHistogram(vec95, 2)) -Compare(ExtractHistogram(vec95, 2), ExtractHistogram(vec96, 2), ExtractHistogram(vec97, 2), "N") +Compare( + ExtractHistogram(vec95, 2), + ExtractHistogram(vec96, 2), + ExtractHistogram(vec97, 2), + "N", +) Plot(ExtractHistogram(vec95, 2), ExtractHistogram(vec96, 2), ExtractHistogram(vec97, 2)) - - - diff --git a/doc/pyplots/example_oak_5.py b/doc/pyplots/example_oak_5.py index 2b751c7..e755939 100644 --- a/doc/pyplots/example_oak_5.py +++ b/doc/pyplots/example_oak_5.py @@ -14,14 +14,16 @@ # ######################################################################### """ + __revision__ = "$Id: test_exploratory.py 8676 2010-04-20 15:28:46Z cokelaer $" +import os.path.join as pj + from openalea.sequence_analysis import * -from openalea.sequence_analysis.estimate import Estimate from openalea.sequence_analysis import get_shared_data as path -from os.path import join as pj -seq0 = Sequences(pj(path ,"chene_sessile_15pa.seq")) -#Plot(seq0, ViewPoint="Data") + +seq0 = Sequences(pj(path("chene_sessile_15pa.seq"))) +# Plot(seq0, ViewPoint="Data") # change of unit for the variable diameter of the annual shoot @@ -34,7 +36,7 @@ vec10 = Vectors(seq0) # plot of the average sequence -#Plot(Regression(vec10, "MovingAverage", 1, 2, [1])) +# Plot(Regression(vec10, "MovingAverage", 1, 2, [1])) vec95 = ValueSelect(vec10, 1, 95) vec96 = ValueSelect(vec10, 1, 96) @@ -43,18 +45,28 @@ VarianceAnalysis(vec10, 1, 2, "N") -print type(ExtractHistogram(vec95, 2)) +print(type(ExtractHistogram(vec95, 2))) -Compare(ExtractHistogram(vec95, 2), ExtractHistogram(vec96, 2), ExtractHistogram(vec97, 2), "N") -#Plot(ExtractHistogram(vec95, 2), ExtractHistogram(vec96, 2), ExtractHistogram(vec97, 2)) +Compare( + ExtractHistogram(vec95, 2), + ExtractHistogram(vec96, 2), + ExtractHistogram(vec97, 2), + "N", +) +# Plot(ExtractHistogram(vec95, 2), ExtractHistogram(vec96, 2), ExtractHistogram(vec97, 2)) ContingencyTable(vec10, 1, 4) # one-way variance analysis based on ranks VarianceAnalysis(vec10, 1, 4, "O") -Compare(ExtractHistogram(vec95, 4), ExtractHistogram(vec96, 4), ExtractHistogram(vec97, 4), "O") +Compare( + ExtractHistogram(vec95, 4), + ExtractHistogram(vec96, 4), + ExtractHistogram(vec97, 4), + "O", +) Plot(ExtractHistogram(vec95, 4), ExtractHistogram(vec96, 4), ExtractHistogram(vec97, 4)) -#Plot(ExtractHistogram(vec95, 5), ExtractHistogram(vec96, 5), ExtractHistogram(vec97, 5)) -#Plot(ExtractHistogram(vec95, 6), ExtractHistogram(vec96, 6), ExtractHistogram(vec97, 6)) +# Plot(ExtractHistogram(vec95, 5), ExtractHistogram(vec96, 5), ExtractHistogram(vec97, 5)) +# Plot(ExtractHistogram(vec95, 6), ExtractHistogram(vec96, 6), ExtractHistogram(vec97, 6)) diff --git a/doc/pyplots/example_oak_6.py b/doc/pyplots/example_oak_6.py index 906d482..87faaae 100644 --- a/doc/pyplots/example_oak_6.py +++ b/doc/pyplots/example_oak_6.py @@ -14,29 +14,32 @@ # ######################################################################### """ + __revision__ = "$Id: test_exploratory.py 8676 2010-04-20 15:28:46Z cokelaer $" +from os.path import join as pj + from openalea.sequence_analysis import * -from openalea.sequence_analysis.estimate import Estimate -from openalea.sequence_analysis.data import path from openalea.sequence_analysis import get_shared_data as path -from os.path import join as pj -seq0 = Sequences(pj(path ,"chene_sessile_15pa.seq")) +from openalea.sequence_analysis.data import path +from openalea.sequence_analysis.estimate import Estimate -#Plot(seq0, ViewPoint="Data") +seq0 = Sequences(pj(path("chene_sessile_15pa.seq"))) + +# Plot(seq0, ViewPoint="Data") # change of unit for the variable diameter of the annual shoot marginal3 = ExtractHistogram(seq0, "Value", 3) -#Plot(Cluster(marginal3, "Information", 0.75)) -#Plot(Cluster(marginal3, "Information", 0.61)) -#Plot(Cluster(marginal3, "Step", 10)) +# Plot(Cluster(marginal3, "Information", 0.75)) +# Plot(Cluster(marginal3, "Information", 0.61)) +# Plot(Cluster(marginal3, "Step", 10)) vec10 = Vectors(seq0) # plot of the average sequence -#Plot(Regression(vec10, "MovingAverage", 1, 2, [1])) +# Plot(Regression(vec10, "MovingAverage", 1, 2, [1])) vec95 = ValueSelect(vec10, 1, 95) vec96 = ValueSelect(vec10, 1, 96) @@ -45,36 +48,58 @@ VarianceAnalysis(vec10, 1, 2, "N") -print type(ExtractHistogram(vec95, 2)) +print(type(ExtractHistogram(vec95, 2))) -Compare(ExtractHistogram(vec95, 2), ExtractHistogram(vec96, 2), ExtractHistogram(vec97, 2), "N") -#Plot(ExtractHistogram(vec95, 2), ExtractHistogram(vec96, 2), ExtractHistogram(vec97, 2)) +Compare( + ExtractHistogram(vec95, 2), + ExtractHistogram(vec96, 2), + ExtractHistogram(vec97, 2), + "N", +) +# Plot(ExtractHistogram(vec95, 2), ExtractHistogram(vec96, 2), ExtractHistogram(vec97, 2)) ContingencyTable(vec10, 1, 4) # one-way variance analysis based on ranks VarianceAnalysis(vec10, 1, 4, "O") -Compare(ExtractHistogram(vec95, 4), ExtractHistogram(vec96, 4), ExtractHistogram(vec97, 4), "O") -#Plot(ExtractHistogram(vec95, 4), ExtractHistogram(vec96, 4), ExtractHistogram(vec97, 4)) +Compare( + ExtractHistogram(vec95, 4), + ExtractHistogram(vec96, 4), + ExtractHistogram(vec97, 4), + "O", +) +# Plot(ExtractHistogram(vec95, 4), ExtractHistogram(vec96, 4), ExtractHistogram(vec97, 4)) -#Plot(ExtractHistogram(vec95, 5), ExtractHistogram(vec96, 5), ExtractHistogram(vec97, 5)) -#Plot(ExtractHistogram(vec95, 6), ExtractHistogram(vec96, 6), ExtractHistogram(vec97, 6)) +# Plot(ExtractHistogram(vec95, 5), ExtractHistogram(vec96, 5), ExtractHistogram(vec97, 5)) +# Plot(ExtractHistogram(vec95, 6), ExtractHistogram(vec96, 6), ExtractHistogram(vec97, 6)) vec11 = ValueSelect(vec10, 4, 1) vec12 = ValueSelect(vec10, 4, 2) vec13 = ValueSelect(vec10, 4, 3, 4) -#Plot(ExtractHistogram(vec11, 2), ExtractHistogram(vec12, 2), ExtractHistogram(vec13, 2)) -#Plot(ExtractHistogram(vec11, 5), ExtractHistogram(vec12, 5), ExtractHistogram(vec13, 5)) - -mixt20 = Estimate(ExtractHistogram(vec10, 2), "MIXTURE", "NB", "NB", "NB", "NB", NbComponent="Estimated") +# Plot(ExtractHistogram(vec11, 2), ExtractHistogram(vec12, 2), ExtractHistogram(vec13, 2)) +# Plot(ExtractHistogram(vec11, 5), ExtractHistogram(vec12, 5), ExtractHistogram(vec13, 5)) + +mixt20 = Estimate( + ExtractHistogram(vec10, 2), + "MIXTURE", + "NB", + "NB", + "NB", + "NB", + NbComponent="Estimated", +) Display(mixt20) Plot(mixt20) Plot(ExtractDistribution(mixt20, "Mixture")) -mixt21 = Estimate(ExtractHistogram(vec10, 5), "MIXTURE", "NB", "NB", "NB", "NB", NbComponent="Estimated") - - - - +mixt21 = Estimate( + ExtractHistogram(vec10, 5), + "MIXTURE", + "NB", + "NB", + "NB", + "NB", + NbComponent="Estimated", +) diff --git a/doc/pyplots/example_oak_7.py b/doc/pyplots/example_oak_7.py index 7b3761c..7b3ad58 100644 --- a/doc/pyplots/example_oak_7.py +++ b/doc/pyplots/example_oak_7.py @@ -14,27 +14,30 @@ # ######################################################################### """ + __revision__ = "$Id: test_exploratory.py 8676 2010-04-20 15:28:46Z cokelaer $" +from os.path import join as pj + from openalea.sequence_analysis import * -from openalea.sequence_analysis.estimate import Estimate from openalea.sequence_analysis import get_shared_data as path -from os.path import join as pj -seq0 = Sequences(pj(path ,"chene_sessile_15pa.seq")) -#Plot(seq0, ViewPoint="Data") +from openalea.sequence_analysis.estimate import Estimate + +seq0 = Sequences(pj(path("chene_sessile_15pa.seq"))) +# Plot(seq0, ViewPoint="Data") # change of unit for the variable diameter of the annual shoot marginal3 = ExtractHistogram(seq0, "Value", 3) -#Plot(Cluster(marginal3, "Information", 0.75)) -#Plot(Cluster(marginal3, "Information", 0.61)) -#Plot(Cluster(marginal3, "Step", 10)) +# Plot(Cluster(marginal3, "Information", 0.75)) +# Plot(Cluster(marginal3, "Information", 0.61)) +# Plot(Cluster(marginal3, "Step", 10)) vec10 = Vectors(seq0) # plot of the average sequence -#Plot(Regression(vec10, "MovingAverage", 1, 2, [1])) +# Plot(Regression(vec10, "MovingAverage", 1, 2, [1])) vec95 = ValueSelect(vec10, 1, 95) vec96 = ValueSelect(vec10, 1, 96) @@ -43,42 +46,65 @@ VarianceAnalysis(vec10, 1, 2, "N") -print type(ExtractHistogram(vec95, 2)) +print(type(ExtractHistogram(vec95, 2))) -Compare(ExtractHistogram(vec95, 2), ExtractHistogram(vec96, 2), ExtractHistogram(vec97, 2), "N") -#Plot(ExtractHistogram(vec95, 2), ExtractHistogram(vec96, 2), ExtractHistogram(vec97, 2)) +Compare( + ExtractHistogram(vec95, 2), + ExtractHistogram(vec96, 2), + ExtractHistogram(vec97, 2), + "N", +) +# Plot(ExtractHistogram(vec95, 2), ExtractHistogram(vec96, 2), ExtractHistogram(vec97, 2)) ContingencyTable(vec10, 1, 4) # one-way variance analysis based on ranks VarianceAnalysis(vec10, 1, 4, "O") -Compare(ExtractHistogram(vec95, 4), ExtractHistogram(vec96, 4), ExtractHistogram(vec97, 4), "O") -#Plot(ExtractHistogram(vec95, 4), ExtractHistogram(vec96, 4), ExtractHistogram(vec97, 4)) +Compare( + ExtractHistogram(vec95, 4), + ExtractHistogram(vec96, 4), + ExtractHistogram(vec97, 4), + "O", +) +# Plot(ExtractHistogram(vec95, 4), ExtractHistogram(vec96, 4), ExtractHistogram(vec97, 4)) -#Plot(ExtractHistogram(vec95, 5), ExtractHistogram(vec96, 5), ExtractHistogram(vec97, 5)) -#Plot(ExtractHistogram(vec95, 6), ExtractHistogram(vec96, 6), ExtractHistogram(vec97, 6)) +# Plot(ExtractHistogram(vec95, 5), ExtractHistogram(vec96, 5), ExtractHistogram(vec97, 5)) +# Plot(ExtractHistogram(vec95, 6), ExtractHistogram(vec96, 6), ExtractHistogram(vec97, 6)) vec11 = ValueSelect(vec10, 4, 1) vec12 = ValueSelect(vec10, 4, 2) vec13 = ValueSelect(vec10, 4, 3, 4) -#Plot(ExtractHistogram(vec11, 2), ExtractHistogram(vec12, 2), ExtractHistogram(vec13, 2)) -#Plot(ExtractHistogram(vec11, 5), ExtractHistogram(vec12, 5), ExtractHistogram(vec13, 5)) - -mixt20 = Estimate(ExtractHistogram(vec10, 2), "MIXTURE", "NB", "NB", "NB", "NB", NbComponent="Estimated") -#Display(mixt20) -#Plot(mixt20) -#Plot(ExtractDistribution(mixt20, "Mixture")) - -mixt21 = Estimate(ExtractHistogram(vec10, 5), "MIXTURE", "NB", "NB", "NB", "NB", NbComponent="Estimated") +# Plot(ExtractHistogram(vec11, 2), ExtractHistogram(vec12, 2), ExtractHistogram(vec13, 2)) +# Plot(ExtractHistogram(vec11, 5), ExtractHistogram(vec12, 5), ExtractHistogram(vec13, 5)) + +mixt20 = Estimate( + ExtractHistogram(vec10, 2), + "MIXTURE", + "NB", + "NB", + "NB", + "NB", + NbComponent="Estimated", +) +# Display(mixt20) +# Plot(mixt20) +# Plot(ExtractDistribution(mixt20, "Mixture")) + +mixt21 = Estimate( + ExtractHistogram(vec10, 5), + "MIXTURE", + "NB", + "NB", + "NB", + "NB", + NbComponent="Estimated", +) vec9596 = ValueSelect(vec10, 1, 95, 96) -#Plot(ExtractHistogram(ValueSelect(vec9596, 4, 1), 6), ExtractHistogram(ValueSelect(vec9596, 4, 2), 6), ExtractHistogram(ValueSelect(vec9596, 4, 3, 4), 6)) +# Plot(ExtractHistogram(ValueSelect(vec9596, 4, 1), 6), ExtractHistogram(ValueSelect(vec9596, 4, 2), 6), ExtractHistogram(ValueSelect(vec9596, 4, 3, 4), 6)) regress10 = Regression(vec10, "Linear", 5, 2) Display(regress10) Plot(regress10) - - - diff --git a/doc/pyplots/result b/doc/pyplots/result new file mode 100644 index 0000000..c0947eb --- /dev/null +++ b/doc/pyplots/result @@ -0,0 +1,22 @@ +value 95 96 97 +sample size 46 46 46 +mean 2.08696 1.19565 1.63043 +variance 0.170048 0.205314 0.282609 +standard deviation 0.412369 0.453116 0.53161 +mean absolute deviation 0.202268 0.323251 0.493384 +coefficient of concentration 0.0584239 0.137945 0.15913 +coefficient of skewness 2.64171 2.3056 -0.08945 +coefficient of kurtosis 9.96979 4.16166 -1.08981 + + frequency distribution 95 frequency distribution 96 frequency distribution 97 cumulative distribution 95 function cumulative distribution 96 function cumulative distribution 97 function +0 0 0 0 0 0 0 +1 1 38 18 0.0217391 0.826087 0.391304 +2 41 7 27 0.913043 0.978261 0.978261 +3 3 1 1 0.978261 1 1 +4 1 1 + +Kruskal-Wallis test +chi-square test 2 degrees of freedom +chi-square value 58.1932 critical probability 2.30942e-13 +reference chi-square value 5.99146 reference critical probability 0.05 +reference chi-square value 9.21034 reference critical probability 0.01 diff --git a/doc/usage.md b/doc/usage.md index 2f934ea..214ca2f 100644 --- a/doc/usage.md +++ b/doc/usage.md @@ -1,6 +1,8 @@ # Usage ```{nbgallery} -examples/example1.ipynb -examples/example2.ipynb +examples/sequences.ipynb +examples/hidden_semi_markov.ipynb +examples/hidden_switching_semi_markov.ipynb +examples/example_oak.ipynb ``` diff --git a/doc/user/admin.rst b/doc/user/admin.rst index 4db2818..9a9bccd 100644 --- a/doc/user/admin.rst +++ b/doc/user/admin.rst @@ -43,8 +43,6 @@ openalea.sequence_analysis.semi_markov 15 15 100% openalea.sequence_analysis.sequences 165 139 84% openalea.sequence_analysis.simulate 46 43 93% openalea.sequence_analysis.time_events 42 34 80% -openalea.sequence_analysis.top_parameters 33 33 100% -openalea.sequence_analysis.tops 32 20 62% openalea.sequence_analysis.variable_order_markov 18 18 100% TOTAL 1444 1206 83% =========================================================== ====== ======= ======== diff --git a/doc/user/autosum.rst b/doc/user/autosum.rst index 493ed32..5ee28eb 100644 --- a/doc/user/autosum.rst +++ b/doc/user/autosum.rst @@ -91,31 +91,6 @@ Data structures :show-inheritance: :synopsis: TimeEvents - -.. currentmodule:: openalea.sequence_analysis.top_parameters - -:mod:`openalea.sequence_analysis.top_parameters` module -------------------------------------------------------- -.. automodule:: openalea.sequence_analysis.top_parameters - :members: - :undoc-members: - :inherited-members: - :show-inheritance: - :synopsis: Top parameters - - -.. currentmodule:: openalea.sequence_analysis.tops - -:mod:`openalea.sequence_analysis.tops` module ---------------------------------------------- -.. automodule:: openalea.sequence_analysis.tops - :members: - :undoc-members: - :inherited-members: - :show-inheritance: - :synopsis: Tops - - .. currentmodule:: openalea.sequence_analysis.variable_order_markov :mod:`openalea.sequence_analysis.variable_order_markov` module diff --git a/pyproject.toml b/pyproject.toml index 9f9f1a9..93e2e41 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -42,7 +42,7 @@ authors = [ { name = "Yann Guédon" }, { name = "Jean-Baptiste Durand" }, { name = "Thomas Cokelaer" }, - { name = "Christophe Pradal"}, + { name = "Christophe Pradal" }, { name = "Thomas Arsouze" }, ] description = "Statistical analysis of plant architecture sequences" @@ -89,7 +89,7 @@ doc = [ # section specific to conda-only distributed package (not used by pip yet) [tool.conda.environment] channels = ["openalea3", "conda-forge"] -dependencies = ["boost", "matplotlib-base", "openalea.stat_tool", "doxygen"] +dependencies = ["boost", "matplotlib-base", "openalea.stat_tool"] [project.urls] Repository = "https://github.com/openalea/sequence_analysis" @@ -97,4 +97,3 @@ Homepage = "https://sequence_analysis.readthedocs.io/" "Bug Tracker" = "https://github.com/openalea/sequence_analysis/issues" Discussions = "https://github.com/openalea/sequence_analysis/discussions" Changelog = "https://github.com/openalea/sequence_analysis/releases" - diff --git a/setup.py b/setup.py deleted file mode 100644 index 469d4e6..0000000 --- a/setup.py +++ /dev/null @@ -1,97 +0,0 @@ -# -*- coding: utf-8 -*- -__revision__ = "$Id$" - -import os, sys -from os.path import join as pj - -from setuptools import setup, find_namespace_packages -#from openalea.deploy.binary_deps import binary_deps - - -# from openalea.deploy.metainfo import read_metainfo -# metadata = read_metainfo('metainfo.ini', verbose=True) -# for key,value in metadata.iteritems(): -# exec("%s = '%s'" % (key, value)) - -# Meta-information -name='OpenAlea.SequenceAnalysis' -version='2.0.0' -description='sequence analysis library' -long_description='Python version of sequence analysis (AML stat).' -authors='Y. Guedon, JB. Durand, P. Fernique, C. Pradal, T. Cokelaer' -authors_email='christophe.pradal@cirad.fr' -url='https://github.com/openalea/StructureAnalysis/' -license='CeCILL-C' - - -build_prefix = "build-scons" - -# Scons build directory -scons_parameters=["build_prefix="+build_prefix] - - -# platform dependencies -install_requires = [] -setup_requires = install_requires + ['openalea.deploy'] - -namespace = 'openalea' -packages = find_namespace_packages(where='src', include=['openalea.*']) -package_dir = {'': 'src'} - -""" -if sys.platform.startswith('win'): - install_requires = [binary_deps('openalea.stattool')] - install_requires += [binary_deps("boost")] - setup_requires += [binary_deps("boost")] -""" - -if __name__ == '__main__': - - setup(name=name, - version=version, - author=authors, - author_email=authors_email, - description=description, - long_description=long_description, - url=url, - license=license, - - - # Define where to execute scons - scons_scripts=['SConstruct'], - # Scons parameters - scons_parameters=scons_parameters, - - namespace_packages=['openalea'], - #create_namespaces=True, - - # Packages - packages=packages, - - package_dir=package_dir, - share_dirs = { 'share' : 'share' }, - - - # Add package platform libraries if any - include_package_data=True, - package_data = {'' : ['*.pyd', '*.so', '*.dylib'],}, - zip_safe = False, - - # Specific options of openalea.deploy - lib_dirs = {'lib' : pj(build_prefix, 'lib'),}, - inc_dirs = { 'include' : pj(build_prefix, 'include') }, - - entry_points = { - "wralea": ["openalea.stats = sequence_analysis_wralea", - "openalea.demo = sequence_analysis_wralea.demo.change_point", - ] - }, - - # Dependencies - setup_requires = setup_requires, - install_requires = install_requires, - #dependency_links = ['http://openalea.gforge.inria.fr/pi'], - - #pylint_packages = ['src/openalea/sequence_analysis'] - ) - diff --git a/src/cpp/sequence_analysis/hsmc_algorithms1.cpp b/src/cpp/sequence_analysis/hsmc_algorithms1.cpp index 8257c78..6081f72 100644 --- a/src/cpp/sequence_analysis/hsmc_algorithms1.cpp +++ b/src/cpp/sequence_analysis/hsmc_algorithms1.cpp @@ -1544,6 +1544,15 @@ HiddenSemiMarkov* MarkovianSequences::hidden_semi_markov_estimation(StatError &e if (iter <= EXPLORATION_NB_ITER) { occupancy_likelihood = hoccupancy->Reestimation::parametric_estimation(occupancy , 1 , true , OCCUPANCY_THRESHOLD , geometric_poisson); + if (occupancy_likelihood == D_INF) { +# ifdef DEBUG + cout << "Relaxing fixed parametric family for " << STAT_label[STATL_STATE] << i + << " " << STAT_label[STATL_SOJOURN_TIME] << " distribution." << endl; +# endif + occupancy_likelihood = hoccupancy->Reestimation::type_parametric_estimation(occupancy , 1 , true , + OCCUPANCY_THRESHOLD , geometric_poisson); + } + } else { occupancy_likelihood = hoccupancy->Reestimation::type_parametric_estimation(occupancy , 1 , true , diff --git a/src/cpp/sequence_analysis/semi_markov.h b/src/cpp/sequence_analysis/semi_markov.h index e23afb4..a122e3d 100644 --- a/src/cpp/sequence_analysis/semi_markov.h +++ b/src/cpp/sequence_analysis/semi_markov.h @@ -249,6 +249,7 @@ namespace sequence_analysis { int get_nb_iterator() const { return nb_iterator; } SemiMarkovData* get_semi_markov_data() const { return semi_markov_data; } int get_nb_output_process() const { return nb_output_process; } + int get_nb_state() const { return nb_state; } /// Return number of states CategoricalSequenceProcess** get_categorical_process() const { return categorical_process; } CategoricalSequenceProcess* get_categorical_process(int variable) diff --git a/src/openalea/sequence_analysis/data/test_hidden_semi_markov.dat b/src/openalea/sequence_analysis/data/test_hidden_semi_markov.dat index a83e13c..46fa8b7 100644 --- a/src/openalea/sequence_analysis/data/test_hidden_semi_markov.dat +++ b/src/openalea/sequence_analysis/data/test_hidden_semi_markov.dat @@ -1,42 +1,25 @@ HIDDEN_SEMI-MARKOV_CHAIN -8 STATES +3 STATES INITIAL_PROBABILITIES -0.4 0.3 0.3 0.0 0.0 0.0 0.0 0.0 +0.4 0.3 0.3 TRANSITION_PROBABILITIES -0.0 0.4 0.3 0.3 0.0 0.0 0.0 0.0 -0.0 0.0 0.4 0.3 0.3 0.0 0.0 0.0 -0.0 0.0 0.0 0.4 0.3 0.3 0.0 0.0 -0.0 0.0 0.0 0.0 0.4 0.3 0.3 0.0 -0.0 0.0 0.0 0.0 0.0 0.4 0.3 0.3 -0.0 0.0 0.0 0.0 0.0 0.0 0.5 0.5 -0.0 0.0 0.0 0.0 0.0 0.0 0.0 1.0 -0.0 0.0 0.0 0.0 0.0 0.0 0.0 1.0 +0.0 0.6 0.4 +0.4 0.0 0.6 +0.6 0.4 0.0 STATE 0 OCCUPANCY_DISTRIBUTION -NEGATIVE_BINOMIAL INF_BOUND : 1 PARAMETER : 1 PROBABILITY : 0.05 +NEGATIVE_BINOMIAL INF_BOUND : 1 PARAMETER : 2 PROBABILITY : 0.15 STATE 1 OCCUPANCY_DISTRIBUTION -NEGATIVE_BINOMIAL INF_BOUND : 1 PARAMETER : 1 PROBABILITY : 0.05 +NEGATIVE_BINOMIAL INF_BOUND : 1 PARAMETER : 6 PROBABILITY : 0.05 STATE 2 OCCUPANCY_DISTRIBUTION -NEGATIVE_BINOMIAL INF_BOUND : 1 PARAMETER : 1 PROBABILITY : 0.05 +NEGATIVE_BINOMIAL INF_BOUND : 3 PARAMETER : 8 PROBABILITY : 0.02 -STATE 3 OCCUPANCY_DISTRIBUTION -NEGATIVE_BINOMIAL INF_BOUND : 1 PARAMETER : 1 PROBABILITY : 0.05 - -STATE 4 OCCUPANCY_DISTRIBUTION -NEGATIVE_BINOMIAL INF_BOUND : 1 PARAMETER : 1 PROBABILITY : 0.05 - -STATE 5 OCCUPANCY_DISTRIBUTION -NEGATIVE_BINOMIAL INF_BOUND : 1 PARAMETER : 1 PROBABILITY : 0.05 - -STATE 6 OCCUPANCY_DISTRIBUTION -NEGATIVE_BINOMIAL INF_BOUND : 1 PARAMETER : 1 PROBABILITY : 0.05 - -1 OUTPUT_PROCESS +2 OUTPUT_PROCESSES OUTPUT_PROCESS 1 : NONPARAMETRIC @@ -57,33 +40,13 @@ OUTPUT 2 : 0.2 OUTPUT 3 : 0.1 OUTPUT 4 : 0.2 -STATE 3 OBSERVATION_DISTRIBUTION -OUTPUT 0 : 0.2 -OUTPUT 1 : 0.2 -OUTPUT 2 : 0.2 -OUTPUT 3 : 0.3 -OUTPUT 4 : 0.1 - -STATE 4 OBSERVATION_DISTRIBUTION -OUTPUT 0 : 0.2 -OUTPUT 1 : 0.2 -OUTPUT 2 : 0.2 -OUTPUT 3 : 0.1 -OUTPUT 4 : 0.3 +OUTPUT_PROCESS 2 : PARAMETRIC -STATE 5 OBSERVATION_DISTRIBUTION -OUTPUT 0 : 0.3 -OUTPUT 1 : 0.2 -OUTPUT 2 : 0.1 -OUTPUT 3 : 0.2 -OUTPUT 4 : 0.2 +STATE 0 OBSERVATION_DISTRIBUTION +NEGATIVE_BINOMIAL INF_BOUND : 0 PARAMETER : 2 PROBABILITY : 0.25 -STATE 6 OBSERVATION_DISTRIBUTION -OUTPUT 0 : 0.2 -OUTPUT 1 : 0.2 -OUTPUT 2 : 0.3 -OUTPUT 3 : 0.2 -OUTPUT 4 : 0.1 +STATE 1 OBSERVATION_DISTRIBUTION +BINOMIAL INF_BOUND : 0 SUP_BOUND : 6 PROBABILITY : 0.35 -STATE 7 OBSERVATION_DISTRIBUTION -OUTPUT 0 : 1.0 +STATE 2 OBSERVATION_DISTRIBUTION +POISSON INF_BOUND : 2 PARAMETER : 8 diff --git a/src/wrapper/export_semi_markov.cpp b/src/wrapper/export_semi_markov.cpp index 91f70a8..ba174ff 100644 --- a/src/wrapper/export_semi_markov.cpp +++ b/src/wrapper/export_semi_markov.cpp @@ -233,7 +233,6 @@ class SemiMarkovWrap void class_semi_markov() { - class_ > ("_SemiMarkov", "SemiMarkov\n" "Constructors from a file required 3 arguments: length(int), counting_flag(boolean) and cumul_threshold (double)") @@ -248,10 +247,13 @@ class_semi_markov() .def("extract_histogram", SemiMarkovWrap::extract_histogram, return_value_policy< manage_new_object >(), "todo") .def("extract", SemiMarkovWrap::extract, return_value_policy< manage_new_object >(), "todo") - DEF_RETURN_VALUE_NO_ARGS("get_semi_markov_data", &SemiMarkov::get_semi_markov_data, "returns semi_markov_data") + // DEF_RETURN_VALUE_NO_ARGS("get_semi_markov_data", &SemiMarkov::get_semi_markov_data, "returns semi_markov_data") + // returns the pointer without allocating a new object. Should not be used, method is private. Prefer SemiMarkov::extract_data belows. DEF_RETURN_VALUE_NO_ARGS("extract_data", SemiMarkovWrap::extract_data, "returns semi_markov_data") .def("file_ascii_write", SemiMarkovWrap::file_ascii_write,"Save vector summary into a file") + .def("get_nb_state", &SemiMarkov::get_nb_state,"Return the number of states") + DEF_RETURN_VALUE("thresholding", SemiMarkovWrap::thresholding, args("index"), "todo") DEF_RETURN_VALUE("simulation_histogram", WRAP::simulation_histogram, args("todo"), "simulation") diff --git a/src/wrapper/sequence_analysis_wrap.cpp b/src/wrapper/sequence_analysis_wrap.cpp index c665c4e..1e22a3d 100644 --- a/src/wrapper/sequence_analysis_wrap.cpp +++ b/src/wrapper/sequence_analysis_wrap.cpp @@ -25,7 +25,6 @@ #include "export_base.h" #include "export_function.h" -// #include "export_tops.h" #include "export_sequences.h" #include "export_correlation.h" #include "export_markovian_sequences.h" @@ -66,9 +65,6 @@ BOOST_PYTHON_MODULE(_sequence_analysis) class_correlation(); -// class_tops(); -// class_top_parameters(); - class_nonhomogeneous_markov(); class_nonhomogeneous_markov_data(); diff --git a/test/README.md b/test/README.md new file mode 100644 index 0000000..b6d3914 --- /dev/null +++ b/test/README.md @@ -0,0 +1,51 @@ +# Test Status + +This is the status of the tests (to be updated) + +all TOBEFINALISED +test_add_absorbing_run.py TOBEFINALISED +test_build_auxiliary_variable.py DONE +test_cluster.py TOBEFINALISED +test_compare.py TOBEFINALISED +test_compute_self_transition.py TOBEFINALISED +test_compute_state_sequences.py TOBEFINALISED +test_correlation.py TOBEFINALISED +test_cumulate.py DONE +test_dataflow_stat.py TOBEFINALISED +test_data.py DONE +test_data_transform.py TOBEFINALISED +test_difference.py DONE +test_estimate.py TOBEFINALISED +test_exploratory2.py TOBEFINALISED +test_exploratory3.py TOBEFINALISED +test_exploratory4.py TOBEFINALISED +test_exploratory5.py TOBEFINALISED +test_exploratory6.py TOBEFINALISED +test_exploratory.py DONE +test_extract_data.py TOBEFINALISED +test_extract_distribution.py DONE +test_extract_histogram.py TOBEFINALISED +test_extract_parameter_index.py DONE +test_extract_vectors.py TOBEFINALISED +test_functional1.py TOBEFINALISED +test_functional2.py TOBEFINALISED +test_functional3.py TOBEFINALISED +test_hidden_semi_markov_functional.py DONE +test_hidden_semi_markov.py TOBEFINALISED +test_hidden_variable_order_markov. TOBEFINALISED +test_index_extract.py TOBEFINALISED +test_iterator.py DONE +test_merge.py TOBEFINALISED +test_moving_average.py TOBEFINALISED +test_non_homogeneous_functional.py TOBEFINALISED +test_nonhomogeneous.py TOBEFINALISED +test_renewal_functional.py TOBEFINALISED +test_renewal.py TOBEFINALISED +test_select_individual.py TOBEFINALISED +test_select_variable.py TOBEFINALISED +test_semi_markov.py TOBEFINALISED +test_semi_markov_switching_lm_functional.py TOBEFINALISED +test_sequences.py TOBEFINALISED +test_simulate.py TOBEFINALISED +test_time_events.py TOBEFINALISED +test_transcode.py TOBEFINALISED diff --git a/test/_test_variable_order_markov.py b/test/_test_variable_order_markov.py index 6abf1ad..db55643 100644 --- a/test/_test_variable_order_markov.py +++ b/test/_test_variable_order_markov.py @@ -16,10 +16,9 @@ from openalea.stat_tool.cluster import Cluster from openalea.stat_tool.cluster import Transcode, Cluster -import openalea.stat_tool.plot #import DISABLE_PLOT -openalea.stat_tool.plot.DISABLE_PLOT = True -from .tools import interface + +from .tools import DISABLE_PLOT, interface from .tools import runTestClass from openalea.sequence_analysis import get_shared_data diff --git a/test/cpp/test_hidden_semi_markov_chain.cpp b/test/cpp/test_hidden_semi_markov_chain.cpp index fcfe383..c60864e 100644 --- a/test/cpp/test_hidden_semi_markov_chain.cpp +++ b/test/cpp/test_hidden_semi_markov_chain.cpp @@ -99,18 +99,18 @@ int main(void) seq_read = Sequences::ascii_read(error, data_fail); cout << error; seq_estim = new MarkovianSequences(*seq_read); -/* + cout << "Estimate default from lippia_fail.seq" << endl; - hsmc = seq_estim->hidden_semi_markov_estimation(error, &cout, itype, 4, true, stat_tool::D_DEFAULT, geometric_poisson , common_dispersion, estimator, counting_flag, state_sequence, 300); + /* hsmc = seq_estim->hidden_semi_markov_estimation(error, &cout, itype, 4, true, stat_tool::D_DEFAULT, geometric_poisson , common_dispersion, estimator, counting_flag, state_sequence, 300); if (hsmc != NULL) { cout << "Estimated model:" << endl; hsmc->ascii_write(cout); delete hsmc; hsmc = NULL; - } + }*/ - // Variant: using LR initial model + // TODO: debugging. Comment operation above. Stop at iteration 2 l. 784. Check reestimation of sojourn duration 0. hsmc_ref = HiddenSemiMarkov::ascii_read(error, hsmcTC00LRpath); if (hsmc_ref != NULL) { cout << "Estimate file init from lippia_fail.seq" << endl; @@ -126,9 +126,9 @@ int main(void) delete hsmc_ref; hsmc_ref = NULL; } -*/ + // Variant: using Irreducible initial model - hsmc_ref = HiddenSemiMarkov::ascii_read(error, hsmcTC00Irpath); + /* hsmc_ref = HiddenSemiMarkov::ascii_read(error, hsmcTC00Irpath); if (hsmc_ref != NULL) { cout << "Estimate file init from lippia_fail.seq" << endl; hsmc_est_file = seq_estim->hidden_semi_markov_estimation(error, &cout, *hsmc_ref, geometric_poisson , common_dispersion, estimator, counting_flag, state_sequence, 300); @@ -140,14 +140,14 @@ int main(void) hsmd = hsmc_est_file->extract_data(error); cout << error; assert(hsmd); - delete hsmd; + delete hsmd; hsmd = NULL; delete hsmc_est_file; hsmc_est_file = NULL; } delete hsmc_ref; hsmc_ref = NULL; - } + }*/ delete seq_estim; delete seq_read; diff --git a/test/test_add_absorbing_run.py b/test/test_add_absorbing_run.py index d6f6eb7..0d7d3ad 100644 --- a/test/test_add_absorbing_run.py +++ b/test/test_add_absorbing_run.py @@ -7,6 +7,13 @@ __revision__ = "$Id$" +try: + from .tools import DISABLE_PLOT + from .tools import robust_path as get_shared_data +except ImportError: + from tools import DISABLE_PLOT + from tools import robust_path as get_shared_data + import pytest from dataclasses import dataclass @@ -15,122 +22,145 @@ from openalea.sequence_analysis.sequences import Sequences from openalea.sequence_analysis.semi_markov import SemiMarkov from openalea.sequence_analysis.data_transform import AddAbsorbingRun -from openalea.sequence_analysis import get_shared_data - -MAX_RUN_LENGTH = 20 # hardcoded values in CPP code - - -# @dataclass -# class AbsorbingData: -# data: Any -# max_length: float -# max_run_length: float - - -# @pytest.fixture(params=["raw", "sequences", "semimarkov"]) -# def AddAbsorbingRunData(request): -# if request.param == "raw": -# return AbsorbingData(None, -1, 20) -# elif request.param == "sequences": -# return Sequences(str(get_shared_data("sequences1.seq"))) -# elif request.param == "semimarkov": -# markov = SemiMarkov(str(get_shared_data("test_semi_markov.dat"))) -# return markov.simulation_nb_elements(1, 1000, True) - - -# class TestAddAbsorbingRun: -# """ -# a main class to test the AddAbsorbingrun function on different type of -# data structure. - -# """ - -# def test_max_length(self, AddAbsorbingRunData): -# seq = AddAbsorbingRunData.data -# assert seq.max_length == self.max_length - -# def test_boost_versus_module(self, AddAbsorbingRunData): -# seq = AddAbsorbingRunData.data -# sequence_length = -1 -# run_length = 6 - -# boost = seq.add_absorbing_run(sequence_length, run_length) -# module1 = AddAbsorbingRun( -# seq, SequenceLength=sequence_length, RunLength=run_length -# ) -# module2 = AddAbsorbingRun(seq, RunLength=run_length) -# assert str(module1) == str(boost) -# assert str(module2) == str(boost) -# def test_no_arguments(self, AddAbsorbingRunData): -# seq = AddAbsorbingRunData.data -# assert AddAbsorbingRun(seq) - -# def test_wrong_run_length(self, AddAbsorbingRunData): -# seq = AddAbsorbingRunData.data -# try: -# # second arguments must be less than MAX_RU_LENGTH -# _res = AddAbsorbingRun(seq, -1, AddAbsorbingRunData["MAX_RUN_LENGTH"] + 1) -# assert False -# except Exception: -# assert True - -# def test_wrong_sequence_length(self, AddAbsorbingRunData): -# seq = AddAbsorbingRunData.data -# try: -# # second arguments must be less than MAX_RU_LENGTH -# _res = AddAbsorbingRun(seq, AddAbsorbingRunData["max_length"] - 1, -1) -# assert False -# except Exception: -# assert True - - -# @pytest.fixture -# def seq(): -# return Sequences(str(get_shared_data("sequences1.seq"))) - - -# @pytest.fixture -# def semi_markov(): -# markov = SemiMarkov(str(get_shared_data("test_semi_markov.dat"))) -# return markov.simulation_nb_elements(1, 1000, True) - - -# def test_max_length_seq(seq): -# assert seq.max_length == 30 - - -# def test_boost_versus_module_seq(seq): -# sequence_length = -1 -# run_length = 6 - -# boost = seq.add_absorbing_run(sequence_length, run_length) -# module1 = AddAbsorbingRun(seq, SequenceLength=sequence_length, RunLength=run_length) -# module2 = AddAbsorbingRun(seq, RunLength=run_length) +MAX_RUN_LENGTH = 20 # hardcoded values in CPP code -# assert str(module1) == str(boost) -# assert str(module2) == str(boost) +@dataclass +class AbsorbingData: + data: Any + max_length: float + max_run_length: float -# def test_no_arguments_seq(seq): -# assert AddAbsorbingRun(seq) +@pytest.fixture(params=["raw", "sequences", "semimarkov"]) +def AddAbsorbingRunData(request): + if request.param == "raw": + return AbsorbingData(None, -1, 20) + elif request.param == "sequences": + return Sequences(str(get_shared_data("sequences1.seq"))) + elif request.param == "semimarkov": + markov = SemiMarkov(str(get_shared_data("test_semi_markov.dat"))) + return markov.simulation_nb_elements(1, 1000, True) -# def test_wrong_run_length_seq(seq): -# try: -# # second arguments must be less than MAX_RU_LENGTH -# _res = AddAbsorbingRun(seq, -1, MAX_RUN_LENGTH + 1) -# assert False -# except Exception: -# assert True +class TestAddAbsorbingRun: + """ + a main class to test the AddAbsorbingrun function on different type of + data structure. + """ -# def test_wrong_sequence_length_seq(seq): -# try: -# # second arguments must be less than MAX_RU_LENGTH -# max_length = 30 -# _res = AddAbsorbingRun(seq, max_length - 1, -1) -# assert False -# except Exception: -# assert True + def test_max_length(self, AddAbsorbingRunData): + seq = AddAbsorbingRunData.data + assert seq.max_length == self.max_length + + def test_boost_versus_module(self, AddAbsorbingRunData): + seq = AddAbsorbingRunData.data + sequence_length = -1 + run_length = 6 + + boost = seq.add_absorbing_run(sequence_length, run_length) + module1 = AddAbsorbingRun( + seq, SequenceLength=sequence_length, RunLength=run_length + ) + module2 = AddAbsorbingRun(seq, RunLength=run_length) + + assert str(module1) == str(boost) + assert str(module2) == str(boost) + + def test_no_arguments(self, AddAbsorbingRunData): + seq = AddAbsorbingRunData.data + assert AddAbsorbingRun(seq) + + def test_wrong_run_length(self, AddAbsorbingRunData): + seq = AddAbsorbingRunData.data + try: + # second arguments must be less than MAX_RU_LENGTH + _res = AddAbsorbingRun(seq, -1, AddAbsorbingRunData["MAX_RUN_LENGTH"] + 1) + assert False + except Exception: + assert True + + def test_wrong_sequence_length(self, AddAbsorbingRunData): + seq = AddAbsorbingRunData.data + try: + # second arguments must be less than MAX_RU_LENGTH + _res = AddAbsorbingRun(seq, AddAbsorbingRunData["max_length"] - 1, -1) + assert False + except Exception: + assert True + + +@pytest.fixture +def seq(): + return Sequences(str(get_shared_data("sequences1.seq"))) + + +@pytest.fixture +def semi_markov(): + markov = SemiMarkov(str(get_shared_data("test_semi_markov.dat"))) + return markov.simulation_nb_elements(1, 1000, True) + + +def test_max_length_seq(seq): + assert seq.max_length == 30 + + +def test_boost_versus_module_seq(seq): + sequence_length = -1 + run_length = 6 + + boost = seq.add_absorbing_run(sequence_length, run_length) + module1 = AddAbsorbingRun(seq, SequenceLength=sequence_length, RunLength=run_length) + module2 = AddAbsorbingRun(seq, RunLength=run_length) + + assert str(module1) == str(boost) + assert str(module2) == str(boost) + + +def test_no_arguments_seq(seq): + assert AddAbsorbingRun(seq) + + +def test_wrong_run_length_seq(seq): + try: + # second arguments must be less than MAX_RU_LENGTH + _res = AddAbsorbingRun(seq, -1, MAX_RUN_LENGTH + 1) + assert False + except Exception: + assert True + + +def test_wrong_sequence_length_seq(seq): + try: + # second arguments must be less than MAX_RU_LENGTH + max_length = 30 + _res = AddAbsorbingRun(seq, max_length - 1, -1) + assert False + except Exception: + assert True + +if __name__ == "__main__": + + class AbsorbingData: + data: Any + max_length: float + max_run_length: float + + class request: + param: Any + + def AddAbsorbingRunData(request): + if request.param == "raw": + return AbsorbingData(None, -1, 20) + elif request.param == "sequences": + return Sequences(str(get_shared_data("sequences1.seq"))) + elif request.param == "semimarkov": + markov = SemiMarkov(str(get_shared_data("test_semi_markov.dat"))) + return markov.simulation_nb_elements(1, 1000, True) + + T = TestAddAbsorbingRun() + R = request + R.param = "raw" + T.test_max_length(AddAbsorbingRunData(R)) \ No newline at end of file diff --git a/test/test_build_auxialiary_variable.py b/test/test_build_auxiliary_variable.py similarity index 64% rename from test/test_build_auxialiary_variable.py rename to test/test_build_auxiliary_variable.py index e6cd66a..96d4c8a 100644 --- a/test/test_build_auxialiary_variable.py +++ b/test/test_build_auxiliary_variable.py @@ -1,5 +1,23 @@ -from openalea.sequence_analysis import * -from .tools import runTestClass, robust_path as get_shared_data + +try: + from .tools import DISABLE_PLOT, interface + from .tools import robust_path as get_shared_data +except ImportError: + from tools import DISABLE_PLOT, interface + from tools import robust_path as get_shared_data + +from openalea.sequence_analysis import ( + Sequences, + SelectVariable, + Merge, + Cluster, + HiddenSemiMarkov, + Estimate, + BuildAuxiliaryVariable, + ExtractData, + SelectIndividual, + Plot +) def test1(): seq6 = Sequences(str(get_shared_data("pin_laricio_6.seq"))) diff --git a/test/test_cumulate.py b/test/test_cumulate.py index c86f18b..27a4a88 100644 --- a/test/test_cumulate.py +++ b/test/test_cumulate.py @@ -2,10 +2,6 @@ .. author:: Thomas Cokelaer, Thomas.Cokelaer@inria.fr -.. todo : in general, variable index starts at 1 when calling Cumulate! -Do we want to start at 0 ? Since later on, python calls will -start the index at 0 ? - """ __revision__ = "$Id$" diff --git a/test/test_data.py b/test/test_data.py index 85a7020..8d5546a 100644 --- a/test/test_data.py +++ b/test/test_data.py @@ -1,5 +1,7 @@ -from .tools import robust_path as get_shared_data - +try: + from .tools import robust_path as get_shared_data +except ImportError: + from tools import robust_path as get_shared_data def test_get_shared_data(): from openalea.sequence_analysis.sequences import Sequences @@ -8,6 +10,6 @@ def test_get_shared_data(): assert seq -##if __name__ == "__main__": -## test_get_shared_data() +if __name__ == "__main__": + test_get_shared_data() diff --git a/test/test_data_transform.py b/test/test_data_transform.py index 3ef8fbe..0cea9d0 100644 --- a/test/test_data_transform.py +++ b/test/test_data_transform.py @@ -26,10 +26,10 @@ ) try: - from .tools import interface + from .tools import DISABLE_PLOT, interface from .tools import robust_path as get_shared_data except ImportError: - from tools import interface + from tools import DISABLE_PLOT, interface from tools import robust_path as get_shared_data @pytest.fixture diff --git a/test/test_estimate.py b/test/test_estimate.py index 1833154..dd2f36f 100644 --- a/test/test_estimate.py +++ b/test/test_estimate.py @@ -14,10 +14,10 @@ from openalea.stat_tool import set_seed try: - from .tools import interface + from .tools import DISABLE_PLOT, interface from .tools import robust_path as get_shared_data except ImportError: - from tools import interface + from tools import DISABLE_PLOT, interface from tools import robust_path as get_shared_data from openalea.sequence_analysis import ( diff --git a/test/test_exploratory.py b/test/test_exploratory.py index 1f91190..c1f6ec0 100644 --- a/test/test_exploratory.py +++ b/test/test_exploratory.py @@ -33,7 +33,13 @@ Vectors, VectorDistance, ) -from .tools import robust_path as get_shared_data + +try: + from .tools import DISABLE_PLOT, interface + from .tools import robust_path as get_shared_data +except ImportError: + from tools import DISABLE_PLOT, interface + from tools import robust_path as get_shared_data def test1(): diff --git a/test/test_extract_distribution.py b/test/test_extract_distribution.py index 729c26f..7d70a04 100644 --- a/test/test_extract_distribution.py +++ b/test/test_extract_distribution.py @@ -9,8 +9,12 @@ from openalea.stat_tool.data_transform import ExtractDistribution from openalea.sequence_analysis import * -from .tools import runTestClass, robust_path as get_shared_data - +try: + from .tools import DISABLE_PLOT, interface + from .tools import robust_path as get_shared_data +except ImportError: + from tools import DISABLE_PLOT, interface + from tools import robust_path as get_shared_data def test_hidden_semi_markov(): seq = Sequences(str(get_shared_data("pin_laricio_7x.seq"))) diff --git a/test/test_extract_histogram.py b/test/test_extract_histogram.py index a264ff8..ed8d8a6 100644 --- a/test/test_extract_histogram.py +++ b/test/test_extract_histogram.py @@ -10,8 +10,13 @@ from openalea.stat_tool.data_transform import ValueSelect, ExtractHistogram from openalea.sequence_analysis import * -from .tools import runTestClass, robust_path as get_shared_data - +try: + from .tools import DISABLE_PLOT, interface + from .tools import robust_path as get_shared_data +except ImportError: + from tools import DISABLE_PLOT, interface + from tools import robust_path as get_shared_data + seq = Sequences(str(get_shared_data("pin_laricio_7x.seq"))) seq_cluster = Cluster(seq, "Step", 1, 10) _seq1 = Sequences(str(get_shared_data('dupreziana_20a2.seq'))) diff --git a/test/test_extract_parameter_index.py b/test/test_extract_parameter_index.py index 557c4f9..b355239 100644 --- a/test/test_extract_parameter_index.py +++ b/test/test_extract_parameter_index.py @@ -7,8 +7,13 @@ from openalea.sequence_analysis.data_transform import IndexParameterExtract from openalea.sequence_analysis.sequences import Sequences -from .tools import runTestClass, robust_path as get_shared_data - +try: + from .tools import DISABLE_PLOT, interface + from .tools import robust_path as get_shared_data +except ImportError: + from tools import DISABLE_PLOT, interface + from tools import robust_path as get_shared_data + def test1(): """FIXME markovian_sequences call""" seq69 = Sequences(str(get_shared_data("pin_laricio_7x.seq"))) diff --git a/test/test_hidden_semi_markov.py b/test/test_hidden_semi_markov.py index fffdfc1..fa39053 100644 --- a/test/test_hidden_semi_markov.py +++ b/test/test_hidden_semi_markov.py @@ -9,7 +9,10 @@ #import openalea.stat from openalea.stat_tool import _stat_tool, set_seed -from openalea.sequence_analysis import _sequence_analysis, Estimate +from openalea.sequence_analysis import (_sequence_analysis, + Estimate, + seq_map) + from openalea.sequence_analysis.hidden_semi_markov import HiddenSemiMarkov from openalea.sequence_analysis.simulate import Simulate from openalea.sequence_analysis.data_transform import Thresholding @@ -18,14 +21,11 @@ from openalea.stat_tool.cluster import Cluster from openalea.stat_tool.cluster import Transcode, Cluster -import openalea.stat_tool.plot #import DISABLE_PLOT -openalea.stat_tool.plot.DISABLE_PLOT = True - try: - from .tools import interface + from .tools import DISABLE_PLOT, interface from .tools import robust_path as get_shared_data except ImportError: - from tools import interface + from tools import DISABLE_PLOT, interface from tools import robust_path as get_shared_data import os @@ -112,49 +112,84 @@ def test_spreadsheet_write(self, HSMData): self.init(HSMData) self.spreadsheet_write() - def test_simulate(self, HSMData): + def simulate(self, HSMData): self.init(HSMData) - sm = self.data + sm = self.hsm assert sm.simulation_nb_elements(1, 10000, True) - assert Simulate(sm,1, 10000, True) - + s = Simulate(sm,1, 10000, True) + return s + + def test_simulate(self, HSMData): + s = self.simulate(HSMData) + assert s + def test_thresholding(self, HSMData): self.init(HSMData) a = self.data.thresholding(0.01) b = Thresholding(self.data, MinProbability=0.01) assert str(a)==str(b) - def test_extract(self, HSMData): - self.init(HSMData) - assert self.data.extract(1,1,1) - - def test_extract_data(self, HSMData): + def extract_data(self, HSMData): self.init(HSMData) - assert self.data.extract_data() is None + assert self.hsm.extract_data() is None nb_seq = 10 seq_length = 50 set_seed(0) - seq = self.data.simulation_nb_sequences(nb_seq, seq_length, True) + seq = self.hsm.simulation_nb_sequences(nb_seq, seq_length, True) # Discard state obs = seq.select_variable([1], False) - hsm_estim = Estimate(obs, "HIDDEN_SEMI-MARKOV", self.data, NbIteration=3) + hsm_estim = Estimate(obs, "HIDDEN_SEMI-MARKOV", self.hsm, NbIteration=3) + return hsm_estim + + def test_extract_data(self, HSMData): + hsm_estim = self.extract_data(HSMData) assert hsm_estim.extract_data() + def test_nb_output_process(self, HSMData): + """Test consistency of the number of output processes""" + self.init(HSMData) + s = self.simulate(HSMData) + assert self.hsm.nb_output_process == (s.nb_variable - 1) + + def test_ascii_write(self, HSMData): + """Test consistency of text representation""" + self.init(HSMData) + assert str(self.data) == self.data.ascii_write(False) + + def test_simulation_histogram(self, HSMData): + """Test simulation from a distribution of sequence lengths""" + self.init(HSMData) + s1 = self.simulate(HSMData) + s2 = self.hsm.simulation_histogram(s1.extract_length(), False, False) + assert str(s1.extract_length()) == str(s2.extract_length()) + + def test_state_sequence_computation(self, HSMData): + """Test state sequence restoration""" + h = self.extract_data(HSMData) + s = h.extract_data() + r = r = h.state_sequence_computation(s.select_variable([1], False), True) + assert self.hsm.nb_output_process == r.nb_variable-1 + + def test_extract(self, HSMData): + """Test state sequence restoration""" + h = self.extract_data(HSMData) + for k in range(h.get_nb_state()): + if k < h.get_nb_state()-1: + assert h.extract(seq_map['Sojourn'],k,0) + v = 1 # Output process 1 + assert v <= h.nb_output_process + dist = h.extract(seq_map['Observation'],v,k) + assert dist + m = dist.get_alloc_nb_value-1 + for o in range(m): + assert h.extract(seq_map['Sojourn'],v,o) + assert h.extract(seq_map['FirstOccurrence'],v,o) + assert h.extract(seq_map['Recurrence'],v,o) + assert h.extract(seq_map['NbRun'],v,o) + assert h.extract(seq_map['NbOccurrence'],v,o) """ TODO: -hsm.nb_output_process -hsm.ascii_write hsm.divergence_computation -hsm.simulation_histogram -hsm.extract_histogram -hsm.simulation_markovian_sequences -hsm.file_ascii_write -hsm.get_forward -hsm.simulation_nb_sequences -hsm.get_plotable -hsm.get_semi_markov_data -hsm.state_sequence_computation -hsm.get_state_subtype hsm.nb_iterator """ @@ -188,3 +223,5 @@ def HSMData(): T.test_thresholding(HSMData()) T.test_extract(HSMData()) T.test_extract_data(HSMData()) + # T.test_extract_histogram(HSMData()) + # T.test_state_sequence_computation(HSMData()) \ No newline at end of file diff --git a/test/test_hidden_semi_markov_functional.py b/test/test_hidden_semi_markov_functional.py index 5b21e2f..240e51c 100644 --- a/test/test_hidden_semi_markov_functional.py +++ b/test/test_hidden_semi_markov_functional.py @@ -12,15 +12,18 @@ from openalea.stat_tool.cluster import Cluster from openalea.stat_tool.cluster import Transcode, Cluster -import openalea.stat_tool.plot #import DISABLE_PLOT -# openalea.stat_tool.plot.DISABLE_PLOT = True +# from openalea.stat_tool.plot import DISABLE_PLOT DISABLE_PLOT = False # DISABLE_PLOT = True -from .tools import interface -from .tools import runTestClass, robust_path as get_shared_data - +try: + from .tools import DISABLE_PLOT, interface + from .tools import robust_path as get_shared_data +except ImportError: + from tools import DISABLE_PLOT, interface + from tools import robust_path as get_shared_data + import os from openalea.stat_tool.output import plot, Plot diff --git a/test/test_hidden_variable_order_markov.py b/test/test_hidden_variable_order_markov.py index 039398e..6569623 100644 --- a/test/test_hidden_variable_order_markov.py +++ b/test/test_hidden_variable_order_markov.py @@ -15,7 +15,7 @@ from openalea.stat_tool.cluster import Transcode, Cluster -# from .tools import interface +# from .tools import DISABLE_PLOT, interface # from .tools import runTestClass # from .tools import runTestClass, robust_path as get_shared_data diff --git a/test/test_iterator.py b/test/test_iterator.py index 00112fc..6f537a8 100644 --- a/test/test_iterator.py +++ b/test/test_iterator.py @@ -14,8 +14,13 @@ ) from openalea.sequence_analysis.hidden_semi_markov import HiddenSemiMarkov from openalea.sequence_analysis.renewal import Renewal -from .tools import runTestClass, robust_path as get_shared_data +try: + from .tools import DISABLE_PLOT, interface + from .tools import robust_path as get_shared_data +except ImportError: + from tools import DISABLE_PLOT, interface + from tools import robust_path as get_shared_data N = 10 diff --git a/test/test_nonhomogeneous.py b/test/test_nonhomogeneous.py index 321457f..52edd73 100644 --- a/test/test_nonhomogeneous.py +++ b/test/test_nonhomogeneous.py @@ -17,7 +17,7 @@ # from openalea.stat_tool.cluster import Cluster # from openalea.stat_tool.cluster import Transcode, Cluster -# from .tools import interface +# from .tools import DISABLE_PLOT, interface # from .tools import robust_path as get_shared_data diff --git a/test/test_renewal.py b/test/test_renewal.py index f0a67c8..205fe73 100644 --- a/test/test_renewal.py +++ b/test/test_renewal.py @@ -20,7 +20,7 @@ from openalea.stat_tool.cluster import Cluster -# from .tools import interface +# from .tools import DISABLE_PLOT, interface # from .tools import runTestClass, robust_path as get_shared_data diff --git a/test/test_semi_markov.py b/test/test_semi_markov.py index 505baf6..2b88dce 100644 --- a/test/test_semi_markov.py +++ b/test/test_semi_markov.py @@ -10,7 +10,7 @@ from openalea.sequence_analysis import SemiMarkov, Simulate -from .tools import interface +from .tools import DISABLE_PLOT, interface from .tools import robust_path as get_shared_data diff --git a/test/test_semi_markov_switching_lm_functional.py b/test/test_semi_markov_switching_lm_functional.py index 814ebcf..ed745dc 100644 --- a/test/test_semi_markov_switching_lm_functional.py +++ b/test/test_semi_markov_switching_lm_functional.py @@ -15,8 +15,7 @@ from openalea.stat_tool.cluster import Transcode, Cluster from pathlib import Path -import openalea.stat_tool.plot #import DISABLE_PLOT -# openalea.stat_tool.plot.DISABLE_PLOT = True +# from openalea.stat_tool.plot import DISABLE_PLOT DISABLE_PLOT = False diff --git a/test/test_sequences.py b/test/test_sequences.py index f25497d..ef98da6 100644 --- a/test/test_sequences.py +++ b/test/test_sequences.py @@ -6,6 +6,12 @@ __revision__ = "$Id$" +try: + from .tools import DISABLE_PLOT, interface, runTestClass + from .tools import robust_path as get_shared_data +except ImportError: + from tools import DISABLE_PLOT, interface, runTestClass + from tools import robust_path as get_shared_data from openalea.stat_tool import _stat_tool import pytest @@ -23,13 +29,9 @@ from openalea.stat_tool.data_transform import * from openalea.stat_tool.cluster import Cluster from openalea.stat_tool.cluster import Transcode, Cluster - -from .tools import interface -from .tools import runTestClass +from openalea.stat_tool.output import Plot from openalea.sequence_analysis.sequences import Sequences, IndexParameterType -from .tools import robust_path as get_shared_data - @pytest.fixture def build_data(): @@ -471,6 +473,11 @@ def test_cumulate(build_data): res = Cumulate(s) assert res.cumul_length == 52 +def test_data_plot(build_data): + """Test plot data""" + data = build_data + Plot(data, ViewPoint="Data") + def test_extract_vectors(build_data): """see test_extract_vectors""" @@ -555,3 +562,44 @@ def test_initial_run(): seq.remove_index_parameter seq.round """ + + +if __name__ == "__main__": + + def build_data(): + """todo: check identifier output. should be a list""" + # build a list of 2 sequences with a variable that should be identical + # to sequences1.seq + data = Sequences([[1,0,0,0,1,1,2,0,2,2,2,1,1,0,1,0,1,1,1,1,0,1,1,1,0,1,2,2,2,1], + [0, 0, 0, 1, 1, 0, 2, 0, 2, 2, 2, 1, 1, 1, 1, 0, 1, 0, 0, 0, 0, 0]] + ) + assert data + + assert data.nb_sequence == 2 + assert data.nb_variable == 1 + assert data.cumul_length == 52 + assert data.max_length == 30 + + assert [0, 1] == data.get_identifiers() + + return data + + + def build_seqn(): + return Sequences([[[1, 1, 1], [12, 12, 12]], [[2, 2, 2], [22, 23, 24]]]) + + + def build_seq1(): + return Sequences([[1, 1, 1], [2, 2, 2]]) + + + def build_seq_realn(): + return Sequences( + [ + [[1.5, 1.5, 1.5], [12.5, 12.5, 12.5]], + [[2.5, 2.5, 2.5], [22.5, 23.5, 24.5]], + ] + ) + + test_recurrence_time_sequences(build_data()) + test_data_plot(build_data()) diff --git a/test/test_time_events.py b/test/test_time_events.py index 35e11a2..db1e0f7 100644 --- a/test/test_time_events.py +++ b/test/test_time_events.py @@ -15,7 +15,7 @@ from openalea.stat_tool.cluster import Cluster from openalea.stat_tool.cluster import Transcode, Cluster -# from .tools import interface +# from .tools import DISABLE_PLOT, interface # from .tools import runTestClass, robust_path as get_shared_data diff --git a/test/tools.py b/test/tools.py index 167cb86..967b835 100644 --- a/test/tools.py +++ b/test/tools.py @@ -1,28 +1,35 @@ -"""Abstract base class used by test_mixture, test_compound, etc""" +"""Abstract base class used by test_hidden_semi_markov, etc. + +author: Jean-Baptiste Durand, Thomas Arsouze, Thomas Cokelaer +""" + +__version__ = "$Id$" import os +import sys + +import openalea.stat_tool.plot + +# !!! Do not plot in nosetests !!! +# buildbot cannot close the windwos popped up by the method/function Plot/plot +# So, we test if the command "python setup.py nosetests" has been used. +# Still, using nosetests executable, windows should pop up. +if ("nosetests" in sys.argv) or ("pytest" in sys.argv[0]): + DISABLE_PLOT = openalea.stat_tool.plot.DISABLE_PLOT = True +else: + DISABLE_PLOT = openalea.stat_tool.plot.DISABLE_PLOT = False from openalea.stat_tool import Simulate -from openalea.stat_tool.plot import DISABLE_PLOT from openalea.stat_tool.output import Display, Save +import openalea.stat_tool.plot +from openalea.stat_tool.distribution import set_seed -DISABLE_PLOT = True from pathlib import Path from openalea.sequence_analysis import get_shared_data, get_shared_data_path import openalea.stat_tool as st import openalea.sequence_analysis as sa -from openalea.stat_tool.distribution import set_seed - -# from openalea.stat_tool import * -# from openalea.stat_tool.plot import DISABLE_PLOT - -# import os -# from openalea.stat_tool.output import Display, Save - - -__revision__ = "$Id$" def runTestClass(myclass): @@ -31,18 +38,26 @@ def runTestClass(myclass): getattr(myclass, function)() +def _remove_file(filename): + """alias to remove a file""" + try: + os.remove(filename) + except: + pass + + class interface: - """Interface to be used by test file that perform tests on the following - data structure: compound, convolution, mixture, histogram, vector + """Interface to be used by test files related to data structure such as + sequences. :param data: a data that will be filled using the build_data structure - :para filename: a filename to a file containing the relevant data structure + :param filename: a filename to a file containing the relevant data structure :param structure: reference to a data structure Class that is not instantiated. :Usage: - In you test file, add :: + In your test file, add:: - >>> from .tools import interface + >>> from .tools import DISABLE_PLOT, interface Then, if we consider the Compound class case, create a class as follows:: @@ -58,28 +73,23 @@ def build_data(self): data = Compound(d1, d2) return data - def test_empty(self): - self.empty() - """ - # def __init__(self, data=None, filename=None, Structure=None): - # self.data = data - # self.filename = filename - # self.structure = Structure - # set_seed(0) + def init(self, data=None, filename=None, Structure=None): + if data is None: + raise AttributeError("data must be provided") + if Structure is None: + raise AttributeError("Structure must be provided") + + self.data = data + self.filename = filename + self.structure = Structure + self.N = 1000 + set_seed(0) def build_data(self): raise NotImplementedError() - def empty(self): - """Test that empty constructor fails""" - try: - _m = self.structure() - assert False - except TypeError: - assert True - def constructor_from_file(self): """Test constructor from file""" if self.filename == None: @@ -94,7 +104,7 @@ def constructor_from_file_failure(self): try: _h = self.structure("whatever_wrong_filename.txt") assert False - except IOError: + except Exception: assert True def print_data(self): @@ -120,26 +130,19 @@ def display_versus_str(self): def plot(self): """run plotting routines""" - if DISABLE_PLOT == False: - self.data.plot() + # if DISABLE_PLOT == False: + self.data.plot() def save(self, Format=None, skip_reading=False): - """In the Vector case, Format should be Data. + """In the Vector case, Format should be set to Data. :param skip_reading: some class do not have Filename Constructor; skip_reading can be set to False to prevent code to be run. .. todo:: This is surely a bug. to be checked""" c1 = self.data - - try: - os.remove("test1.dat") - except: - pass - try: - os.remove("test2.dat") - except: - pass + # _remove_file('test1.dat') + # _remove_file('test2.dat') if Format is None: c1.save("test1.dat") @@ -154,32 +157,33 @@ def save(self, Format=None, skip_reading=False): c1_read = self.structure("test1.dat") c2_read = self.structure("test2.dat") - print(c1_read) - assert c1 and c1_read and c2_read assert str(c1_read) == str(c2_read) - # os.remove('test1.dat') - # os.remove('test2.dat') + _remove_file("test1.dat") + _remove_file("test2.dat") def plot_write(self): h = self.data h.plot_write("test", "title") + _remove_file("test.print") + _remove_file("test.plot") + _remove_file("test0.dat") def file_ascii_write(self): h = self.data h.file_ascii_write("test.dat", True) - os.remove("test.dat") + _remove_file("test.dat") def file_ascii_data_write(self): h = self.data h.file_ascii_data_write("test.dat", True) - os.remove("test.dat") + _remove_file("test.dat") def spreadsheet_write(self): h = self.data h.spreadsheet_write("test.dat") - os.remove("test.dat") + _remove_file("test.dat") def survival_ascii_write(self): d = self.data @@ -196,15 +200,18 @@ def survival_file_ascii_write(self): def survival_spreadsheet_write(self): d = self.data d.survival_spreadsheet_write("test.xsl") - os.remove("test.xsl") + _remove_file("test.xsl") - def simulate(self): + def simulate(self, N=-1): """Test the simulate method""" + set_seed(0) + if N == -1: + N = self.N m = self.data - s = m.simulate(1000) - s2 = Simulate(m, 1000) - assert len(s) == 1000 - assert len(s2) == 1000 + s = m.simulate(N) + s2 = Simulate(m, N) + assert len(s) == N + assert len(s2) == N assert str(s2) assert str(s) return s @@ -220,5 +227,13 @@ def test_extract_data(self): def robust_path(filename): - p = get_shared_data(filename) - return p + p = st.get_shared_data(filename) + if p is not None: + # module in develop mode? + return get_shared_data(filename) + + p = Path(st.__path__[0]) + if "src" in str(p): + root_pkg = p + "/../../.." + data = st.get_shared_data(root_pkg) + return os.path.join(data, filename) diff --git a/tutorials/hidden_semi_markov.ipynb b/tutorials/hidden_semi_markov.ipynb deleted file mode 100644 index df6758b..0000000 --- a/tutorials/hidden_semi_markov.ipynb +++ /dev/null @@ -1,2628 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [], - "source": [ - "#!/usr/bin/python3.10" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Prerequisites: pandas, xlrd, matplotlib, rpy2" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# HSMC modelling" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Configuration\n", - "### It is assumed that this notebook is run from StructureAnalysis/sequence_analysis/tutorials" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "**Import OpenAlea packages**" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [], - "source": [ - "from openalea.stat_tool import _stat_tool\n", - "from openalea.sequence_analysis import _sequence_analysis\n", - "from openalea.sequence_analysis.hidden_semi_markov import HiddenSemiMarkov\n", - "from openalea.sequence_analysis.simulate import Simulate\n", - "from openalea.sequence_analysis.data_transform import Thresholding\n", - "\n", - "from openalea.stat_tool.data_transform import *\n", - "from openalea.stat_tool.cluster import Cluster\n", - "from openalea.stat_tool.cluster import Transcode, Cluster\n", - "\n", - "import openalea.stat_tool.plot #import DISABLE_PLOT\n", - "from openalea.stat_tool.plot import DISABLE_PLOT\n", - "DISABLE_PLOT = False\n", - "\n", - "import os\n", - "\n", - "from openalea.stat_tool.output import plot, Plot\n", - "\n", - "plot.DISABLE_PLOT = DISABLE_PLOT\n", - "\n", - "from openalea.stat_tool.plot import get_plotter, mplotlib " - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "##### Check pandas version" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [], - "source": [ - "# print pd.__version__" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [ - { - "ename": "ModuleNotFoundError", - "evalue": "No module named 'xlrd'", - "output_type": "error", - "traceback": [ - "\u001b[31m---------------------------------------------------------------------------\u001b[39m", - "\u001b[31mModuleNotFoundError\u001b[39m Traceback (most recent call last)", - "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[4]\u001b[39m\u001b[32m, line 1\u001b[39m\n\u001b[32m----> \u001b[39m\u001b[32m1\u001b[39m \u001b[38;5;28;01mimport\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34;01mxlrd\u001b[39;00m\n\u001b[32m 2\u001b[39m xlrd.__version__\n", - "\u001b[31mModuleNotFoundError\u001b[39m: No module named 'xlrd'" - ] - } - ], - "source": [ - "import xlrd\n", - "xlrd.__version__" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "For correct figure rendering" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [], - "source": [ - "%matplotlib inline" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "##### Enabling R extensions" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [ - { - "ename": "ModuleNotFoundError", - "evalue": "No module named 'rpy2'", - "output_type": "error", - "traceback": [ - "\u001b[31m---------------------------------------------------------------------------\u001b[39m", - "\u001b[31mModuleNotFoundError\u001b[39m Traceback (most recent call last)", - "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[6]\u001b[39m\u001b[32m, line 1\u001b[39m\n\u001b[32m----> \u001b[39m\u001b[32m1\u001b[39m \u001b[43mget_ipython\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\u001b[43m.\u001b[49m\u001b[43mrun_line_magic\u001b[49m\u001b[43m(\u001b[49m\u001b[33;43m'\u001b[39;49m\u001b[33;43mload_ext\u001b[39;49m\u001b[33;43m'\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[33;43m'\u001b[39;49m\u001b[33;43mrpy2.ipython\u001b[39;49m\u001b[33;43m'\u001b[39;49m\u001b[43m)\u001b[49m\n", - "\u001b[36mFile \u001b[39m\u001b[32m~/miniforge3/envs/statdev/lib/python3.13/site-packages/IPython/core/interactiveshell.py:2504\u001b[39m, in \u001b[36mInteractiveShell.run_line_magic\u001b[39m\u001b[34m(self, magic_name, line, _stack_depth)\u001b[39m\n\u001b[32m 2502\u001b[39m kwargs[\u001b[33m'\u001b[39m\u001b[33mlocal_ns\u001b[39m\u001b[33m'\u001b[39m] = \u001b[38;5;28mself\u001b[39m.get_local_scope(stack_depth)\n\u001b[32m 2503\u001b[39m \u001b[38;5;28;01mwith\u001b[39;00m \u001b[38;5;28mself\u001b[39m.builtin_trap:\n\u001b[32m-> \u001b[39m\u001b[32m2504\u001b[39m result = \u001b[43mfn\u001b[49m\u001b[43m(\u001b[49m\u001b[43m*\u001b[49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43m*\u001b[49m\u001b[43m*\u001b[49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m 2506\u001b[39m \u001b[38;5;66;03m# The code below prevents the output from being displayed\u001b[39;00m\n\u001b[32m 2507\u001b[39m \u001b[38;5;66;03m# when using magics with decorator @output_can_be_silenced\u001b[39;00m\n\u001b[32m 2508\u001b[39m \u001b[38;5;66;03m# when the last Python token in the expression is a ';'.\u001b[39;00m\n\u001b[32m 2509\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mgetattr\u001b[39m(fn, magic.MAGIC_OUTPUT_CAN_BE_SILENCED, \u001b[38;5;28;01mFalse\u001b[39;00m):\n", - "\u001b[36mFile \u001b[39m\u001b[32m~/miniforge3/envs/statdev/lib/python3.13/site-packages/IPython/core/magics/extension.py:33\u001b[39m, in \u001b[36mExtensionMagics.load_ext\u001b[39m\u001b[34m(self, module_str)\u001b[39m\n\u001b[32m 31\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m module_str:\n\u001b[32m 32\u001b[39m \u001b[38;5;28;01mraise\u001b[39;00m UsageError(\u001b[33m'\u001b[39m\u001b[33mMissing module name.\u001b[39m\u001b[33m'\u001b[39m)\n\u001b[32m---> \u001b[39m\u001b[32m33\u001b[39m res = \u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43mshell\u001b[49m\u001b[43m.\u001b[49m\u001b[43mextension_manager\u001b[49m\u001b[43m.\u001b[49m\u001b[43mload_extension\u001b[49m\u001b[43m(\u001b[49m\u001b[43mmodule_str\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m 35\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m res == \u001b[33m'\u001b[39m\u001b[33malready loaded\u001b[39m\u001b[33m'\u001b[39m:\n\u001b[32m 36\u001b[39m \u001b[38;5;28mprint\u001b[39m(\u001b[33m\"\u001b[39m\u001b[33mThe \u001b[39m\u001b[38;5;132;01m%s\u001b[39;00m\u001b[33m extension is already loaded. To reload it, use:\u001b[39m\u001b[33m\"\u001b[39m % module_str)\n", - "\u001b[36mFile \u001b[39m\u001b[32m~/miniforge3/envs/statdev/lib/python3.13/site-packages/IPython/core/extensions.py:62\u001b[39m, in \u001b[36mExtensionManager.load_extension\u001b[39m\u001b[34m(self, module_str)\u001b[39m\n\u001b[32m 55\u001b[39m \u001b[38;5;250m\u001b[39m\u001b[33;03m\"\"\"Load an IPython extension by its module name.\u001b[39;00m\n\u001b[32m 56\u001b[39m \n\u001b[32m 57\u001b[39m \u001b[33;03mReturns the string \"already loaded\" if the extension is already loaded,\u001b[39;00m\n\u001b[32m 58\u001b[39m \u001b[33;03m\"no load function\" if the module doesn't have a load_ipython_extension\u001b[39;00m\n\u001b[32m 59\u001b[39m \u001b[33;03mfunction, or None if it succeeded.\u001b[39;00m\n\u001b[32m 60\u001b[39m \u001b[33;03m\"\"\"\u001b[39;00m\n\u001b[32m 61\u001b[39m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[32m---> \u001b[39m\u001b[32m62\u001b[39m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43m_load_extension\u001b[49m\u001b[43m(\u001b[49m\u001b[43mmodule_str\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m 63\u001b[39m \u001b[38;5;28;01mexcept\u001b[39;00m \u001b[38;5;167;01mModuleNotFoundError\u001b[39;00m:\n\u001b[32m 64\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m module_str \u001b[38;5;129;01min\u001b[39;00m BUILTINS_EXTS:\n", - "\u001b[36mFile \u001b[39m\u001b[32m~/miniforge3/envs/statdev/lib/python3.13/site-packages/IPython/core/extensions.py:77\u001b[39m, in \u001b[36mExtensionManager._load_extension\u001b[39m\u001b[34m(self, module_str)\u001b[39m\n\u001b[32m 75\u001b[39m \u001b[38;5;28;01mwith\u001b[39;00m \u001b[38;5;28mself\u001b[39m.shell.builtin_trap:\n\u001b[32m 76\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m module_str \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;129;01min\u001b[39;00m sys.modules:\n\u001b[32m---> \u001b[39m\u001b[32m77\u001b[39m mod = \u001b[43mimport_module\u001b[49m\u001b[43m(\u001b[49m\u001b[43mmodule_str\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m 78\u001b[39m mod = sys.modules[module_str]\n\u001b[32m 79\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m._call_load_ipython_extension(mod):\n", - "\u001b[36mFile \u001b[39m\u001b[32m~/miniforge3/envs/statdev/lib/python3.13/importlib/__init__.py:88\u001b[39m, in \u001b[36mimport_module\u001b[39m\u001b[34m(name, package)\u001b[39m\n\u001b[32m 86\u001b[39m \u001b[38;5;28;01mbreak\u001b[39;00m\n\u001b[32m 87\u001b[39m level += \u001b[32m1\u001b[39m\n\u001b[32m---> \u001b[39m\u001b[32m88\u001b[39m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43m_bootstrap\u001b[49m\u001b[43m.\u001b[49m\u001b[43m_gcd_import\u001b[49m\u001b[43m(\u001b[49m\u001b[43mname\u001b[49m\u001b[43m[\u001b[49m\u001b[43mlevel\u001b[49m\u001b[43m:\u001b[49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mpackage\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mlevel\u001b[49m\u001b[43m)\u001b[49m\n", - "\u001b[36mFile \u001b[39m\u001b[32m:1387\u001b[39m, in \u001b[36m_gcd_import\u001b[39m\u001b[34m(name, package, level)\u001b[39m\n", - "\u001b[36mFile \u001b[39m\u001b[32m:1360\u001b[39m, in \u001b[36m_find_and_load\u001b[39m\u001b[34m(name, import_)\u001b[39m\n", - "\u001b[36mFile \u001b[39m\u001b[32m:1310\u001b[39m, in \u001b[36m_find_and_load_unlocked\u001b[39m\u001b[34m(name, import_)\u001b[39m\n", - "\u001b[36mFile \u001b[39m\u001b[32m:488\u001b[39m, in \u001b[36m_call_with_frames_removed\u001b[39m\u001b[34m(f, *args, **kwds)\u001b[39m\n", - "\u001b[36mFile \u001b[39m\u001b[32m:1387\u001b[39m, in \u001b[36m_gcd_import\u001b[39m\u001b[34m(name, package, level)\u001b[39m\n", - "\u001b[36mFile \u001b[39m\u001b[32m:1360\u001b[39m, in \u001b[36m_find_and_load\u001b[39m\u001b[34m(name, import_)\u001b[39m\n", - "\u001b[36mFile \u001b[39m\u001b[32m:1324\u001b[39m, in \u001b[36m_find_and_load_unlocked\u001b[39m\u001b[34m(name, import_)\u001b[39m\n", - "\u001b[31mModuleNotFoundError\u001b[39m: No module named 'rpy2'" - ] - } - ], - "source": [ - "%load_ext rpy2.ipython" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "##### Place variables in markdown outputs" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [], - "source": [ - "from IPython.display import Markdown\n", - "from IPython.core.magic import register_cell_magic\n", - "\n", - "\n", - "@register_cell_magic\n", - "def markdown(line, cell):\n", - " return Markdown(cell.format(**globals()))" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Loading and preparing data" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": {}, - "outputs": [], - "source": [ - "import sys, os" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "['/home/jdurand/usr/local/openalea',\n", - " '/home/jdurand/miniforge3/envs/statdev/lib/python313.zip',\n", - " '/home/jdurand/miniforge3/envs/statdev/lib/python3.13',\n", - " '/home/jdurand/miniforge3/envs/statdev/lib/python3.13/lib-dynload',\n", - " '',\n", - " '/home/jdurand/miniforge3/envs/statdev/lib/python3.13/site-packages',\n", - " '/home/jdurand/devlp/Git/openalea/StructureAnalysis/sequence_analysis/src/openalea',\n", - " '/home/jdurand/devlp/Git/openalea/StructureAnalysis/stat_tool/src/openalea']" - ] - }, - "execution_count": 9, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "sys.path" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": {}, - "outputs": [], - "source": [ - "sys.path.append(\"..\" + os.sep + \"tutorials\")" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": {}, - "outputs": [], - "source": [ - "from pathlib import Path\n", - "from openalea.sequence_analysis import __path__ as seq_path\n", - "data_path = Path(seq_path[0])\n", - "data_path = str(Path.joinpath(data_path.parent.parent.parent.absolute(), \"share\",\"data\"))\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Estimate HSMC with nonparametric emission distributions" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "nonparametric meant as categorical, saturated model" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "**Read an existing HSMC model**" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2 \n", - "3 8 STATES\n", - "4 \n", - "5 INITIAL_PROBABILITIES\n", - "6 0.4 0.3 0.3 0.0 0.0 0.0 0.0 0.0\n", - "7 \n", - "8 TRANSITION_PROBABILITIES\n", - "9 0.0 0.4 0.3 0.3 0.0 0.0 0.0 0.0\n", - "10 0.0 0.0 0.4 0.3 0.3 0.0 0.0 0.0\n", - "11 0.0 0.0 0.0 0.4 0.3 0.3 0.0 0.0\n", - "12 0.0 0.0 0.0 0.0 0.4 0.3 0.3 0.0\n", - "13 0.0 0.0 0.0 0.0 0.0 0.4 0.3 0.3\n", - "14 0.0 0.0 0.0 0.0 0.0 0.0 0.5 0.5\n", - "15 0.0 0.0 0.0 0.0 0.0 0.0 0.0 1.0\n", - "16 0.0 0.0 0.0 0.0 0.0 0.0 0.0 1.0\n", - "19 NEGATIVE_BINOMIAL INF_BOUND : 1 PARAMETER : 1 PROBABILITY : 0.05\n", - "22 NEGATIVE_BINOMIAL INF_BOUND : 1 PARAMETER : 1 PROBABILITY : 0.05\n", - "25 NEGATIVE_BINOMIAL INF_BOUND : 1 PARAMETER : 1 PROBABILITY : 0.05\n", - "28 NEGATIVE_BINOMIAL INF_BOUND : 1 PARAMETER : 1 PROBABILITY : 0.05\n", - "31 NEGATIVE_BINOMIAL INF_BOUND : 1 PARAMETER : 1 PROBABILITY : 0.05\n", - "34 NEGATIVE_BINOMIAL INF_BOUND : 1 PARAMETER : 1 PROBABILITY : 0.05\n", - "37 NEGATIVE_BINOMIAL INF_BOUND : 1 PARAMETER : 1 PROBABILITY : 0.05\n", - "42 \n", - "43 STATE 0 OBSERVATION_DISTRIBUTION\n", - "44 OUTPUT 0 : 1.0\n", - "45 \n", - "46 STATE 1 OBSERVATION_DISTRIBUTION\n", - "47 OUTPUT 0 : 0.2\n", - "48 OUTPUT 1 : 0.1\n", - "49 OUTPUT 2 : 0.3\n", - "50 OUTPUT 3 : 0.2\n", - "51 OUTPUT 4 : 0.2\n", - "52 \n", - "53 STATE 2 OBSERVATION_DISTRIBUTION\n", - "54 OUTPUT 0 : 0.2\n", - "55 OUTPUT 1 : 0.3\n", - "56 OUTPUT 2 : 0.2\n", - "57 OUTPUT 3 : 0.1\n", - "58 OUTPUT 4 : 0.2\n", - "59 \n", - "60 STATE 3 OBSERVATION_DISTRIBUTION\n", - "61 OUTPUT 0 : 0.2\n", - "62 OUTPUT 1 : 0.2\n", - "63 OUTPUT 2 : 0.2\n", - "64 OUTPUT 3 : 0.3\n", - "65 OUTPUT 4 : 0.1\n", - "66 \n", - "67 STATE 4 OBSERVATION_DISTRIBUTION\n", - "68 OUTPUT 0 : 0.2\n", - "69 OUTPUT 1 : 0.2\n", - "70 OUTPUT 2 : 0.2\n", - "71 OUTPUT 3 : 0.1\n", - "72 OUTPUT 4 : 0.3\n", - "73 \n", - "74 STATE 5 OBSERVATION_DISTRIBUTION\n", - "75 OUTPUT 0 : 0.3\n", - "76 OUTPUT 1 : 0.2\n", - "77 OUTPUT 2 : 0.1\n", - "78 OUTPUT 3 : 0.2\n", - "79 OUTPUT 4 : 0.2\n", - "80 \n", - "81 STATE 6 OBSERVATION_DISTRIBUTION\n", - "82 OUTPUT 0 : 0.2\n", - "83 OUTPUT 1 : 0.2\n", - "84 OUTPUT 2 : 0.3\n", - "85 OUTPUT 3 : 0.2\n", - "86 OUTPUT 4 : 0.1\n", - "87 \n", - "88 STATE 7 OBSERVATION_DISTRIBUTION\n", - "89 OUTPUT 0 : 1.0\n" - ] - } - ], - "source": [ - "model_file = \"test_hidden_semi_markov.dat\"\n", - "\n", - "f = open(data_path + os.sep + model_file, \"r\")\n", - "f.close()\n", - "\n", - "hsm = HiddenSemiMarkov(data_path + os.sep + model_file)" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "metadata": {}, - "outputs": [], - "source": [ - "from openalea.sequence_analysis import Estimate\n", - "from openalea.sequence_analysis import seq_map " - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Intensity is the a priori probability of states as a function of index" - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "hsm.plot(\"Intensity\", 1)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Emission probabilities" - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAzoAAANCCAYAAACuwLkYAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjgsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvwVt1zgAAAAlwSFlzAAAPYQAAD2EBqD+naQABAABJREFUeJzs3Qd4VGXWwPGTEBJKCB1CD70XCQFBAQUplhUsCIiAFZAiNkRsKIrroi4qIipKWQGBBVEQRVkEadICSAsdBBQIoYUWAsn9nvPizDcTZiYJZDIzyf/3PONl7tzy3nPvZt8zb5kgy7IsAQAAAIAcJNjXBQAAAACArEaiAwAAACDHIdEBAAAAkOOQ6AAAAADIcUh0AAAAAOQ4JDoAAAAAchwSHQAAAAA5DokOAAAAgByHRAcAAABAjkOiAwC5yCeffCKTJk3KlnOdP39eXn/9dVmyZEm2nC+nWr58uTz++OMSHR0tYWFhEhQUJPv37/d1sQDA75HoAEAukt2JzhtvvEGic50WLVok//vf/6RixYrSokWLrLk5AJALkOgAAHIETaxyoldffdW04MyZM0fuvPNOXxcHAAIGiQ4A+Hm3pbZt20qhQoWkQIEC5hv9+fPnO22j3cO0O1Na2nLj2M0pKipKtm7dKr/++qtZry9dp7R7mb6fMmWKPPvssxIZGSn58+eX1q1by4YNG5yOe8stt5hXWg8//LD9eHrOkiVLmn9rq47tfLqNO5kpgx4nPDxcNm/eLO3btzfx0TipEydOSP/+/aVcuXISGhoqVapUkZdfflkuXrzodIzU1FQZM2aMNGrUyJynSJEicuONN8rcuXOdtpsxY4Y0b95cChYsaM7ZoUOHq8qzd+9e6datm5QtW9Z0LytdurQpz8aNG+3b/PLLLyZuxYsXN+fTFpr77rsv3QQtOJj/qwaAa8FfTwDwU5qQtGnTRk6fPi1ffvmlfP3116ZC/49//MNUvjNLWwS00n/DDTfIb7/9Zl66ztFLL71kKu1ffPGFef3111+mcq7rMqNMmTKyYMEC8+/HHnvMfj5tnUhPRsuQnJwsd999t4nRd999ZxKqpKQkufXWW+U///mPSZY0KXzooYdk1KhRcu+9916VLA0ePFhiYmJMPKdPn26O5zj+5e2335bu3btLnTp1ZObMmfLVV1/JmTNnpGXLlrJt2zb7dnfccYfExsaa8yxcuFDGjRtn4nzq1CnzuR5TW2M08ZowYYKJzTvvvGOSJ70OAIAXWAAAv3TjjTdapUqVss6cOWNfd/nyZatevXpW+fLlrdTUVLNu+PDhlqs/5xMnTjTr9+3bZ19Xt25dq3Xr1ldtu3jxYrNt48aN7cdV+/fvt/LmzWs9/vjj9nW6v6tj9O7d26pUqZL9/bFjx8wxtXwZkZky6Ll02wkTJjgd49NPPzXrZ86c6bT+X//6l1n/888/m/dLly41719++WW35Tlw4IAVEhJiDRo0yGm93o/IyEjrgQceMO8TEhLMsT744AO3x5o1a5bZZuPGjdb1ePfdd6+6pwAA12jRAQA/dO7cOVm9erXcf//9pruUTZ48eaRnz55y6NAh2bFjR5af98EHH3TqBlepUiXTXW7x4sVZfq6sKIN2/XKk3cO0lUTj5sjWZU4H9qsff/zRLAcMGOC2HD/99JNcvnxZevXqZZa2V758+Ux3OttscsWKFZOqVavKu+++K//+979NtzbtFudIu8dpa06fPn1k8uTJmW4hAwBkHokOAPihkydPahON6QKWlo4DUcePH8/y8+q4GFfrvHGu6y2DjlmKiIhwWqfb6LZpxyyVKlVKQkJC7Mc4duyYSRpdncvm6NGjZqld2/Lmzev00q5uCQkJ5nM9lyZQOnZHu641btzYjE966qmnTDc3pYmQzpym5dDkSt/r68MPP7zmOAEAPAtJ53MAgA8ULVrUDEI/fPjwVZ/pmBVVokQJs9QWBqWD7XUgvI2tIp4ZR44ccblOB9Db6Pl03FBa13K+ay2DcjUBg26jLWGaJDp+Hh8fb1pjbDHTRCQlJcUc11UyqWzbzpo1y7QqeaKf6zgqtXPnTjOeRyeJ0PE3n376qVmv43r0peddt26dmQjh6aefNhMX6EQGAICsRYsOAPgh7X7VrFkz+eabb+TChQv29dolSmclK1++vNSoUcOss810tmnTJqdjzJs376rjaiLkeLy0dMIDTRJs/vjjD1m5cqXTLGt6Pq3MO85ipi0lul3acylP57vWMrijM52dPXtWvv32W6f1OjmB7XN1++23m6VOGuCOttBoK9CePXukSZMmLl+u6H155ZVXpH79+rJ+/fqrPteWJL23Y8eONe9dbQMAuH606ACAn/rnP/8p7dq1M7OIPf/882aMh/7g55YtW0wyYGux0Bm/dJyIzm42YsQIUznXqaUPHjx41TG18q2zi2nXK52BTVtndJ1jy8c999wjTzzxhGm1GT58uNlm2LBh9m10jNBnn31mZjPT7TTJ0S5babuR6Qxx2tKhM6JpgqFl1FYSW2LmTkbK4I6Op9EEonfv3mamM702naJbZ0/TON12221mO21Z0et46623TBe1u+66yyRmOr5Gu8QNGjTIlFPjqVNT65iajh07mpY23X7NmjUmGdWZ3jTBHDhwoHTp0kWqV69u7pOOFdL1L774ojmfturoOp15TaeV1tnhdPY1ZSuTO9rNTmfgUzqdtm2MkbZK6UvHCwEAXHAzSQEAwA8sW7bMatOmjVWwYEErf/78Zia2efPmXbXdmjVrrBYtWpjtypUrZ2Y6++KLL66aoUtnMGvfvr1VqFAh85ltljTbjGdfffWV9dRTT1klS5a0wsLCrJYtW1rr1q276nyTJ0+2ateubeXLl8+qU6eONWPGjKtmXVP/+9//rBtuuMEcS4+v27iTmTLocfRaXTl+/LjVr18/q0yZMmbWNC3TsGHDrKSkJKftUlJSrNGjR5tZ7EJDQ63ChQtbzZs3vyq+3377rXXrrbdaERERpjx6vPvvv99cmzp69Kj18MMPW7Vq1TJlCg8Ptxo0aGCOrbPkqd9++8265557zL56jOLFi5uZ6+bOnes2Hmnj4urlavY7AMAVQfofVwkQACD30BnEtOXov//971UzluWmMgAAcg7G6AAAAADIcUh0AAAAAOQ4dF0DAAAAkOPQogMAAAAgxyHRAQAAAJDjkOgAAAAAyHEC4gdD9ZfA//rrL/Pjc7YfyAMAAACQ+1iWJWfOnJGyZctKcHBwYCc6muRUqFDB18UAAAAA4CcOHjwo5cuXD+xER1tybBcTERHh6+IAAAAA8JHExETTCGLLEQI60bF1V9Mkh0QHAAAAQFA6Q1qYjAAAAABAjkOiAwAAACDHIdEBAAAAkOMExBgdAACQc6SkpMilS5d8XQwAfipv3rySJ0+e6z4OiQ4AAMi23744cuSInDp1iogD8KhIkSISGRl5Xb+hSaIDAACyhS3JKVWqlBQoUIAfAQfg8guR8+fPS3x8vHlfpkwZuVYkOgAAIFu6q9mSnOLFixNxAG7lz5/fLDXZ0b8Z19qNjckIAACA19nG5GhLDgCkx/a34nrG85HoAACAbHM9/e0B5B5BWfC3gkQHAAAAQI5DogMAAAAnkyZNMrNe5SS33HKLPP3009l+3iVLlpjWCdtsg96K7f79+815Nm7c6PK83jyXvyLRAQAAASUlNUWW7F8iX2/+2iz1va88/PDD0rlz50zv9/rrr0ujRo2ypAwnT56Unj17SuHChc1L/52bp/B2V8H/5ptv5M033xRf69q1q+zcuTND22YmKapQoYIcPnxY6tWrJ95+xit46VxZjVnXAABAwPgm7hsZvGCwHEo8ZF9XPqK8fNjxQ7m39r2SGz344INy6NAhWbBggXnfp08fk+zMmzdPAklycrKEhoZ67fjFihUTf5lRzDarWFbHTn93JjvkyZMn2851PWjRAQAAAZPk3D/zfqckR/2Z+KdZr597w6xZs6R+/fqmcqpTY992221y7tw50yozefJk+e6770wLgr60NUENHTpUatSoYWaOqlKlirz66qv22aP0W/o33nhDfv/9d/t+uk6dPn3aJCo6pW5ERIS0adPGbOdOXFycSXC++OILad68uXmNHz9evv/+e9mxY4fHVqBevXpJ0aJFTRlvv/122bVr11Xbffvtt+Y68uXLJ+3atZODBw/aP9Ny3XrrrVKoUCFT1ujoaFm3bp3985UrV0qrVq1M3LQF4KmnnjJxs4mKipK33nrLtBhoS9QTTzxhyv/iiy86leHYsWOSN29eWbx4sXk/ZcoUadKkiTmvVrY10bP95op2qdIyKb02ja0e31XXtfRiYGtN+emnn6R27doSHh4uHTt2NC0Znvzwww8mZnrdWhYtk6dWGndx1GfpkUceMc+E7TnRZ85d7Nx1J1uxYoU0bNjQ3MNmzZrJ5s2bPbYsfvDBB+b4ts9dPeOuzvXrr79K06ZNJSwszPz2jd7Hy5cv2z/X+Osz8MILL5ikU++d7Xq8hUQHAAD4Pe2epi05llhXfWZb9/SCp7O8G5tWart37y6PPvqoSSq0knfvvfeaHzV8/vnn5YEHHrBXfvXVokULs59WWrVCu23bNvnwww9N8jF69Gh716XnnntO6tata99P1+kx77zzTvPDqlpZjo2NlcaNG0vbtm3lxIkTLsv322+/mYquVmBtbrzxRrNOEw13tIKslem5c+eaY+i577jjDqepfPVHG0eOHGkqulpZTkxMlG7dutk/79Gjh5QvX17Wrl1ryqoVW01IlFamO3ToYGK1adMmmTFjhixfvlwGDhzoVI53333XdH/S/TUZ1GN+/fXXpjw2um/p0qWldevW9tYL7YKmCYImYvv27bMnM5pQzZ492/xbEz2Nrcb/emLw3nvvyVdffSVLly6VAwcOmPvujiaCes16HE0CHn/88asSt7TcxVGfJU06NPmxPSeO504bO3eGDBlirkGPrwn03XffneEpmz09447+/PNPc80xMTHmvowbN06+/PJLk4w50mepYMGCsnr1ahk1apSMGDFCFi5cKF5jBYDTp0/r026WAAAg8Fy4cMHatm2bWTo6l3zOiv0rNt3XZ+s+s+R1Sfel26V3LD1nRsXGxpo6yP79+11+3rt3b6tTp07pHmfUqFFWdHS0/f3w4cOthg0bOm2zaNEiKyIiwkpKSnJaX7VqVeuzzz5zedyRI0da1atXv2q9rnv77bdd7rNz505zTStWrLCvS0hIsPLnz2/NnDnTvJ84caLZZtWqVfZt4uLizLrVq1eb94UKFbImTZrk8hw9e/a0+vTp47Ru2bJlVnBwsP0ZqFSpktW5c2enbeLj462QkBBr6dKl9nXNmze3hgwZYrmzZs0aU64zZ86Y94sXLzbvT5486bRd69atrcGDB2c6Brt377ZvM3bsWKt06dJuyzJs2DCrdu3aVmpqqn3d0KFDncqjxy1cuLD9c09xTLutjavY7du3z5xnw4YNTnGYPn26fZvjx4+ba5wxY4bb53D06NHm+J6e8bTneumll6yaNWs6XbfGKjw83EpJSbHH/+abb3Y6TkxMjIlPZv5mZCY3YIwOAADwme0J2yX68+gsO17f7/umu01sn1hpXKZxho6nXX60RUW7rmkLRfv27eX+++833Z3S6+6m38bv3r1bzp49a7rw6DfzHssVG2u21e5xji5cuCB79uzJ1O+NaOuEu98h0ZapkJAQp1YgPWfNmjXNZza6jXYRs6lVq5bpcqXbaBelZ5991rRYaGuHdufr0qWLVK1a1X4teu1Tp051KlNqaqppgdGuYMrx+KpkyZKmi5zu17JlS7OttrZoC4HNhg0bTJcnbTHRli49ptLWljp16riN07XEQLu02a5JaZcsWzc5d8fVFjXH2Gt3PE88xdGTtLFzp7nD+bXLWNprzAp6PD2P43XfdNNN5nnW8WMVK1Y06xo0aOC0X3rxvF4kOgAAwGdqlahlEo/0rPtrXYaSmM/u+kyalG2S7jkzM+hau9ZoN7Cff/5ZxowZIy+//LLpelO5cmWX+6xatcp08dJxOJocaTey6dOny/vvv+/xXFph14qfbZyPI3czb+k4h6NHj161Xse1aHcvVxy7haWXHLlKlmzrNNnQ8THz58+XH3/8UYYPH26u85577jHX0rdvXzMmIy1bpVdpNyZXXbkGDx5sYj1t2jTTxU8TTqVjfDTZ1JeO1dHESBMcjbN2acuojMbA1hXP8drd7evpuJ54iqMnrmKXUUF/X2NwcPBVZc5ot7b0nh3bcdOLpy1R9QYSHQAA4DMF8hbIUOtKw9IN5c2lb5qJB1yN0wmSIDP72mM3PCZ5gvNkaRm1MqbfTuvrtddek0qVKsmcOXPMN/E601VKivO4IB3PottoQmTzxx9/OG3jaj8dj6Pjc7SlwTYYPD36LboOVl+zZo1pZVGahOk6V2MplLZ6aAuTbmfb5vjx42bKY1tLi9JtdAyL7bg65kWnbNaWHRsddK+vZ555xoxlmjhxoqmg67Vs3bpVqlWrJpmlUxlrkqSTLGiiozPI2Wzfvl0SEhLknXfeMeNxlOMECMo2c1va+F5LDDJLj6vjhtImvulxF0dXz0lmrVq1yp5c6gQMeo22e6iJoj5zjolK2skMMlIGvW4dG+V4HP1yQMeqlStXTnyFyQgAAIDf0+RFp5C2JTWObO8/6PhBlic5WhF+++23TWVaWw70t1i0tcRWGdaERAfbaxKgFXD9Nlwr97qtfiuvXc4++ugjkxg50v20W5ZWKnW/ixcvmm5LmrhoRV9n+tKZrbSy+Morr1xVmbfRcuhAcZ11Syu0+tJ/33XXXaaLkivVq1eXTp06me10ggAdPP7QQw+ZCqmud/z2fdCgQSYG69evNzOAabcsTXy0O51OLKCtT5rEaXKng91tcdFZ57TL2YABA8w16mxmOuhfj5cebanQcugAe+0Spa0dNlph14q3tvbs3bvXHDPtb+NokqmVbZ15Tu+Vdp+61hhkVr9+/cw91yRYnwlN1Gwz6rmSXhz1OdHyL1q0yDwnOjlCZo0YMcLsv2XLFjMBQ4kSJey/i6MzoWmMdGIALffYsWNNq5IjV894Wv379zcTMej91WRUZ2nTlimNg7Ya+YwVAJiMAACAwOZpYHFmzN422yr/7/JOExBU+HcFs94btMwdOnSwSpYsaYWFhVk1atSwxowZ4zR4vl27dmbQtVardAC40sHzxYsXN+u7du1qBng7DirXCQfuu+8+q0iRImY/HXSuEhMTrUGDBllly5a18ubNa1WoUMHq0aOHdeDAAbdl1AHmuo0OateX/jvtQPy0Tpw4YSYM0DLp4HS9Rh2gn3YQ/OzZs60qVapYoaGhVps2beyTMly8eNHq1q2bKZ9+puUdOHCg0/3VSQJssSlYsKDVoEEDM3mCjQ5417i4Mn/+fBOXVq1aXfXZtGnTrKioKHM/dKKCuXPnOg2MVyNGjLAiIyOtoKAgM5g+7WQEmYmBozlz5phzeTJv3jyrWrVqpnwtW7a0JkyY4HYygozEsV+/fuZZ0mPo5AHuYuduMoJ58+ZZdevWNcfXwf8bN2502m/cuHHm/HqPevXqZe6R42QErp7xtOdSS5YsMcfX82jsdZKBS5cu2T9PG3+lkxzY7o83JiMI0v+In9PpDLV/qzbDpjeQDwAA+J+kpCTTgqHjWvT3PK6HTiG97MAyOXzmsJQpVEZaVmyZ5S05APz3b0ZGcwPG6AAAgICiSc0tUbf4uhgA/BxjdAAAAADkOCQ6AAAAAHIcEh0AAAAAOQ6JDgAAAIAch0QHAAAAQI5DogMAAAAgxyHRAQAAAJDjkOgAAAAAyHFIdAAAAOBk0qRJUqRIkRwVlVtuuUWefvrpbD/vkiVLJCgoSE6dOuXV2O7fv9+cZ+PGjS7P681z+SsSHQAAgGv08MMPS+fOnTO93+uvvy6NGjXKkriPHDlSWrRoIQUKFMhxycm1cFfB/+abb+TNN98UX+vatavs3LkzQ9tmJimqUKGCHD58WOrVqyfefsYreOlcWY1EBwAABJ7//U+kTp0ry1wuOTlZunTpIk8++aQE+nV4U7FixaRQoULia/nz55dSpUpleezy5MkjkZGREhISIt6WJxvPdT1IdAAAQGCxLJGXXhKJi7uy1PdeNGvWLKlfv76poBYvXlxuu+02OXfunGmVmTx5snz33XemBUFf2pqghg4dKjVq1DCtLFWqVJFXX31VLl26ZP+W/o033pDff//dvp+uU6dPn5Y+ffqYinBERIS0adPGbOeJHuuZZ54xZcyokydPSq9evaRo0aKmjLfffrvs2rXrqu2+/fZbcx358uWTdu3aycGDB+2fabluvfVWkzxoWaOjo2XdunX2z1euXCmtWrUycdMWgKeeesrEzSYqKkreeust02JQuHBheeKJJ6R58+by4osvOpXh2LFjkjdvXlm8eLF5P2XKFGnSpIk5r1a2H3zwQYmPj7d3qdIyKb02ja0e31XXtfRiYGtN+emnn6R27doSHh4uHTt2NC0Znvzwww8mZnrdWhYtk6dWGndx1GfpkUceMc+E7TnRZ85d7Nx1J1uxYoU0bNjQ3MNmzZrJ5s2bPbYsfvDBB+b4ts9dPeOuzvXrr79K06ZNJSwsTMqUKWPu4+XLl+2fa/z1GXjhhRdM0qn3znY93kKiAwAAAsvPP4usXXvl37rU916ildru3bvLo48+KnFxcaaSd++994plWfL888/LAw88YK/86ku7kCmttGqFdtu2bfLhhx/K+PHjZfTo0fauS88995zUrVvXvp+u02PeeeedcuTIEVNZjo2NlcaNG0vbtm3lxIkTWXpdWkHWyvTcuXPlt99+M+e+44477MmYOn/+vOkWpxVdrSwnJiZKt27d7J/36NFDypcvL2vXrjVl1YqtJiRKK9MdOnQwsdq0aZPMmDFDli9fLgMHDnQqx7vvvmu6P+n+mgzqMb/++mtTHhvdt3Tp0tK6dWt764V2QdMEQROxffv22ZMZTahmz55t/r1jxw4TW43/9cTgvffek6+++kqWLl0qBw4cMPfdHU0E9Zr1OJoEPP7441clbmm5i6M+S5p0aPJje04cz502du4MGTLEXIMeXxPou+++2+kaPfH0jDv6888/zTXHxMSY+zJu3Dj58ssvTTLmSJ+lggULyurVq2XUqFEyYsQIWbhwoXiNFQBOnz6tT7tZAgCAwHPhwgVr27ZtZunk3DnLio3N+GvdOsuqU8eygoO1Knxlqe91fUaPoefMoNjYWFMH2b9/v8vPe/fubXXq1Cnd44waNcqKjo62vx8+fLjVsGFDp20WLVpkRUREWElJSU7rq1atan322WfpnmPixIlW4cKF091u586d5ppWrFhhX5eQkGDlz5/fmjlzpv1Yus2qVavs28TFxZl1q1evNu8LFSpkTZo0yeU5evbsafXp08dp3bJly6zg4GD7M1CpUiWrc+fOTtvEx8dbISEh1tKlS+3rmjdvbg0ZMsTt9axZs8aU68yZM+b94sWLzfuTJ086bde6dWtr8ODBmY7B7t277duMHTvWKl26tNuyDBs2zKpdu7aVmppqXzd06FCn8qS9T57i6O6euordvn37zHk2bNjgFIfp06fbtzl+/Li5xhkzZrh9DkePHm2O7+kZT3uul156yapZs6bTdWuswsPDrZSUFHv8b775ZqfjxMTEmPhk6m9GJnID/+5YBwAAcrbt20Wio699/9RUkW3bRJo0yfg+sbEijRtnaFPt8qMtKtotTFso2rdvL/fff7/p7pRedzf9Nn737t1y9uxZ04VHv5n3XKxYs612j3N04cIF2bNnj2QVbZnSsRXajclGz1mzZk3zmY1uo13EbGrVqmW6XOk22kXp2WefNS0W2tqh3fl0nFDVqlXt16LXPnXqVPv+2mKSmppqWmC0K5hyPL4qWbKk6SKn+7Vs2dJsq60t2kJgs2HDBtPlSVtMtKVLj6m0taWOjtvKwhholzbbNSntkmXrJufuuDfeeKPp1mWj3fE88RRHT9LGzp3mDufXLmNprzEr6PH0PI7XfdNNN5nn+dChQ1KxYkWzrkGDBk77pRfP60WiAwAAfKdWrSuJR0ZoG06vXleSo78rt0Zw8JXj/Oc/Ig4VLY/nzMSga+1ao+NNfv75ZxkzZoy8/PLLputN5cqVXe6zatUq08VLx85ocqRjKKZPny7vv/++x3NphV0rfrZxPo6ycjY1x25hadc7VlRV2veO6zTZ0PEx8+fPlx9//FGGDx9urvOee+4x19K3b18zJiMtW6VXaTcmV125Bg8ebGI9bdo008VPE06lY3w02dSXjtXRxEgTHI1zZiYzyGgMbF3xHK/d3b6ejuuJpzh64ip2GRX09zUGBwdfVeaMdmtL79mxHTe9eNoSVW8g0QEAAL5ToECGW1fkp5+utN64a9VJSBDp0CHLi6iVMf12Wl+vvfaaVKpUSebMmWO+iQ8NDZWUlBSn7XU8i26jCZHNH3/84bSNq/10PI6Oz9GWBttgcG/QVg9tYdJkzTbe4vjx42bKY1tLi9JtdAyLtt7YxrzolM3asmOjg+71pZMh6FimiRMnmgq6XsvWrVulWrVqmS6fTmWsSdKCBQtMotOzZ0/7Z9u3b5eEhAR55513zHgc5TgBgi22Km18ryUGmaXH1XFDaRPf9LiLo6vnJLNWrVplTy51Aga9Rts91ERRnznHRCXtZAYZKYNet46NcjyOfjmgY9XKlSsnvsJkBAAAwP/pt8M64Fpbb1zR9fp5Fs/AphXht99+21SmteVAf4tFZwGzVYY1IdHB9poEaAVcvw3Xyr1uq9/Ka5ezjz76yCRGjnQ/7ZallUrd7+LFi6bbknb/0Yq+zvSlM1tpZfGVV165qjLvSM+lx9GlVkj13/rSbkOuVK9eXTp16mRm6tIJAnTw+EMPPWQqpLre8dv3QYMGmRisX7/ezACm3bI08dHudDqxgLY+aRKnyZ0OdrfFRWed0y5nAwYMMGXR2cx00L8eLz3aUqHl0AH22iVKWztstMKuFW9t7dm7d685ZtrfxtEkUyvb33//vblXruKQ0RhkVr9+/cw91yRYnwlN1Gwz6rmSXhz1OdHyL1q0yDwnOjlCZo0YMcLsv2XLFjMBQ4kSJey/i6MzoWmMdGIALffYsWNNq5IjV894Wv379zcTMej91WRUZ2nTlimNg7Ya+YwVAJiMAACAwOZpYHGG6AB9HQR+JZVx/YqMvLJdFtIyd+jQwSpZsqQVFhZm1ahRwxozZozT4Pl27dqZQddardIB4EoHzxcvXtys79q1qxng7TioXCccuO+++6wiRYqY/XTQuUpMTLQGDRpklS1b1sqbN69VoUIFq0ePHtaBAwfcllEHi+sx0r5sZXHlxIkTZsIALZMOTtdr1AH6aQfBz54926pSpYoVGhpqtWnTxj4pw8WLF61u3bqZ8ulnWt6BAwc63V+dJMAWm4IFC1oNGjSwRo4caf9cB7xrXFyZP3++uYZWrVpd9dm0adOsqKgocz90ooK5c+c6DYxXI0aMsCIjI62goCATn7STEWQmBo7mzJljzuXJvHnzrGrVqpnytWzZ0powYYLbyQgyEsd+/fqZZ0mPoZMHuIudu8kI5s2bZ9WtW9ccXwf/b9y40Wm/cePGmfPrPerVq5e5R46TEbh6xtOeSy1ZssQcX8+jsddJBi5dumT/PG38lU5yYLs/3piMIEj/I35OpzPU/q06j3h6A/kAAID/SUpKMi0YOq5Ff8/jmuhvuBw75v5z/RHG8uWvuYwAAuNvRkZzA8boAACAwKBjMv4elwEA6WGMDgAAAIAch0QHAAAAQI5DogMAAAAgxyHRAQAAAJDjkOgAAAAAyHFIdAAAAADkOCQ6AAAAAHIcEh0AAAAAOQ6JDgAAAJxMmjRJihQpkqOicsstt8jTTz+d7eddsmSJBAUFyalTp7wa2/3795vzbNy40eV5vXkuf0WiAwAAcI0efvhh6dy5c6b3e/3116VRo0ZZUuF87LHHpHLlypI/f36pWrWqDB8+XJKTkyW3clfB/+abb+TNN98UX+vatavs3LkzQ9tmJimqUKGCHD58WOrVqyfefsYreOlcWS3E1wUAAADIiH37XpegoDwSFfXqVZ/t3/+mWFaKVK78eq4K5vbt2yU1NVU+++wzqVatmmzZskWeeOIJOXfunLz33nsSSDQ5Cw0N9drxixUrJv5AE1J9eSN2kZGRkh3y5MmTbee6HrToAACAgKBJzv79r5mkxpG+1/X6uTfMmjVL6tevbyqnxYsXl9tuu80kEtoqM3nyZPnuu+9MC4K+tDVBDR06VGrUqCEFChSQKlWqyKuvviqXLl2yf0v/xhtvyO+//27fT9ep06dPS58+faRUqVISEREhbdq0Mdu507FjR5k4caK0b9/enOfuu++W559/3rReeHLy5Enp1auXFC1a1JTx9ttvl127dl213bfffmuuI1++fNKuXTs5ePCg/TMt16233iqFChUyZY2OjpZ169bZP1+5cqW0atXKxE1bAJ566ikTN5uoqCh56623TItB4cKFTYLWvHlzefHFF53KcOzYMcmbN68sXrzYvJ8yZYo0adLEnFcr2w8++KDEx8fbW7i0TEqvTWOrx3fVdS29GNhaU3766SepXbu2hIeHm3hrS4YnP/zwg4mZXreWRcvkqZXGXRz1WXrkkUfMM2F7TvSZcxc7d93JVqxYIQ0bNjT3sFmzZrJ582aPLYsffPCBOb7tc1fPuKtz/frrr9K0aVMJCwuTMmXKmPt4+fJl++caf30GXnjhBZN06r2zXY+3kOgAAICAoC05UVEjnJIdW5Kj61219FwvrdR2795dHn30UYmLizOVvHvvvVcsyzIJxQMPPGCv/OqrRYsWZj+ttGqFdtu2bfLhhx/K+PHjZfTo0fauS88995zUrVvXvp+u02PeeeedcuTIEVNZjo2NlcaNG0vbtm3lxIkTGS6zVozTa73QCrJWpufOnSu//fabOfcdd9xhT8bU+fPnZeTIkaaiq5XlxMRE6datm/3zHj16SPny5WXt2rWmrFqx1YREaWW6Q4cOJlabNm2SGTNmyPLly2XgwIFO5Xj33XdN9yfdX5NBPebXX39tymOj+5YuXVpat25tb73QLmiaIGgitm/fPnsyownV7Nmzzb937NhhYqvxv54YaMvYV199JUuXLpUDBw6Y++6OJoJ6zXocTQIef/zxqxK3tNzFUZ8lTTo0+bE9J47nThs7d4YMGWKuQY+vCbQmw47X6ImnZ9zRn3/+aa45JibG3Jdx48bJl19+aZIxR/osFSxYUFavXi2jRo2SESNGyMKFC8VrrABw+vRpfdrNEgAABJ4LFy5Y27ZtM0tHly+fsxITYzP12rGjn7V4sVhLluQ1S32fmf31nBkVGxtr6iD79+93+Xnv3r2tTp06pXucUaNGWdHR0fb3w4cPtxo2bOi0zaJFi6yIiAgrKSnJaX3VqlWtzz77LEPl3b17tznG+PHj3W6zc+dOc00rVqywr0tISLDy589vzZw507yfOHGi2WbVqlX2beLi4sy61atXm/eFChWyJk2a5PIcPXv2tPr06eO0btmyZVZwcLD9GahUqZLVuXNnp23i4+OtkJAQa+nSpfZ1zZs3t4YMGeL2etasWWPKdebMGfN+8eLF5v3JkyedtmvdurU1ePDgTMdAY2ozduxYq3Tp0m7LMmzYMKt27dpWamqqfd3QoUOdyqPHLVy4sP1zT3FMu62Nq9jt27fPnGfDhg1OcZg+fbp9m+PHj5trnDFjhtvncPTo0eb4np7xtOd66aWXrJo1azpdt8YqPDzcSklJscf/5ptvdjpOTEyMiU9m/mZkJjdgjA4AAPCZ8+e3S2xs9DXta1lXvpX+669PzSujoqNjpVChxhnaVrv8aIuKdl3TFgrtInb//feb7k7pdXfTb+N3794tZ8+eNV149Jt5T/Sbed1Wu8c5unDhguzZsyfdsv7111/mm/cuXbqYlgR3tGUqJCTEdGOy0XPWrFnTfGaj22gXMZtatWqZLle6jXZRevbZZ815tLVDu/PpeXUyBNu16LVPnTrVvr+2mOh4Im2B0a5gyvH4qmTJkqaLnO7XsmVLs622tmgLgc2GDRtMlydtMdGWLj2m0taWOnXqpBunzMRAu7TZrklplyxbNzl3x73xxhtNty4b7Y7niac4epI2du40dzi/tvSlvcasoMfT8zhe90033WSe50OHDknFihXNugYNGjjtl148rxeJDgAA8JkCBWqZxCMzDh8ebxKboKC8JtkpW7aflCnzRKbOmZlB19q1Rseb/PzzzzJmzBh5+eWXTdcbnenMlVWrVpkuXjoOR5MjHUMxffp0ef/99z2eSyvsWvGzjfNxlN7MW5rk6DgPrWx+/vnnHrd17BaWdr1jRVWlfe+4TpMNHR8zf/58+fHHH81sb3qd99xzj7mWvn37mjEZadkqvUq7MbnqyjV48GAT62nTppkufppwKh3jo8mmvnSsjiZGmuBonDMz01xGY2Driud47e729XRcTzzF0RNXscuooL+vMTg4+KoyZ7RbW3rPju246cXTlqh6A4kOAADwmTx5CmS4dcU2JkeTHNuYHNsYndDQsl4Zo2OrjOm30/p67bXXpFKlSjJnzhzzTbzOdJWSkuK0vY5n0W00IbL5448/nLZxtZ+Ox9HxOdrSYBsMnhE6PkKTHB3ErhMTaOXVE2310BYmTdZs4y2OHz9upjy2tbQo3UbHsGjrjW3Mi07ZrC07NjroXl/PPPOMGcuk59cKul7L1q1bzUxwmaVTGWuStGDBApPo9OzZ02mWuYSEBHnnnXfMeBzlOAGCss3clja+1xKDzNLj6rihtIlvetzF0dVzklmrVq2yJ5c6AYNeo+0eaqKoz5xjopJ2MoOMlEGvW8dGOR5HvxzQsWrlypUTX2EyAgAAEBBcTTzgaoKCrKQV4bfffttUprXlQGcz01nAbJVhTUh0sL0mAVoB12/DtXKv2+q38trl7KOPPjKJkSPdT7tlaaVS97t48aLptqQtMlrR15m+dGYrrSy+8sorV1XmHVtydDYrrfTrgHMtm1Zc9eVO9erVpVOnTmamLp0gQAePP/TQQ6ZCqusdv30fNGiQicH69evNDGDaLUsTH+1OpxMLaOuTJnGa3Olgd1tcdNY57XI2YMAAc406m5kO+tfjpUdbKrQcOsBeu0Rpa4eNVti14q2tPXv37jXHTPvbOJpkamX7+++/N/HQ7lPXGoPM6tevn7nnmgTrM6GJmm1GPVfSi6M+J1r+RYsWmedEJ0fIrBEjRpj9depxnYChRIkS9t/F0WdHY6QTA2i5x44da1qVHLl6xtPq37+/mYhB768mozpLm7ZMaRzSS7y9ygoAtgFH32/63rqcctkMdEq65DxQDwAA+C9PA4szau/e4da+fSNcfqbr9fOspmXu0KGDVbJkSSssLMyqUaOGNWbMGKfB8+3atTODrrWuogPAlQ6eL168uFnftWtXM8DbcVC5Tjhw3333WUWKFDH76aBzlZiYaA0aNMgqW7aslTdvXqtChQpWjx49rAMHDrgsn23AvKuXJydOnDATBmiZdHC6XqMO0Hc8rn42e/Zsq0qVKlZoaKjVpk0b+6QMFy9etLp162bKp59peQcOHOh0f3WSAFtsChYsaDVo0MAaOXKk/XMd8K5xcWX+/PnmGlq1anXVZ9OmTbOioqLM/dCJCubOnes0MF6NGDHCioyMtIKCgsxg+rSTEWQmBo7mzJmTbmznzZtnVatWzZSvZcuW1oQJE9xORpCROPbr1888S3oMnTzAXezcTUYwb948q27duub4Ovh/48aNTvuNGzfOnF/vUa9evcw9cpyMwNUznvZcasmSJeb4eh6NvU4ycOnSJfvnaeOvdJID2/3xxmQEQfqfzCRGOrWeTmeng8x0ijn9hiK9XwTWebU1o9MmzLJly5r5szXjzSidzlD7t8qLIiWKlZDCYYXlbPJZWfvEWqlQ+EqzJQAA8F9JSUmmBUPHtejveQDAtf7NsOUGOpW6p0k+Mt2WpIPAdEDYxx9/nKHttYA6r7bOnKGzZLz00ktmYJptjvPMSjifIHtO7pGj547KsfPHrukYAAAAAHK2TE9GoL8aq6+M+vTTT01/Sp1iUWmfQ+1nqv1I77vvPrkeKanXNzgLAAAAQM7k9dFBOhBNpwB0pFMAarLjbvo6HZCnTVKOL1c2HNnglTIDAAAACGxeT3R01o/SpUs7rdP3OqWfztzgyj//+U/T7872sk0fmFbCOdf7AwAAAMjdsmW+t4z8gJCjYcOGmcFFtpdOV+dKiYIlvFBaAAAAAIHO6z8YGhkZedVc7vHx8ebHsIoXL+5yn7CwMPNKzw2RN2RZOQEAAADkHF5v0dEfvlq4cKHTup9//lmaNGlifojqeuQJznOdpQMAAACQE2U60dFfZ9VfuNWXsv2qr/4CsK3bWa9evezb6+/l6C+96u/o6K/bTpgwQb788kt5/vnnr6nAJQqUkKpFq0pkeKSUKljqmo4BAAAAIGfLdNc1nS3t1ltvtb/XBEb17t1bJk2aZH5E1Jb0KP2Rnx9++EGeeeYZGTt2rPnB0I8++uiap5be1HeTRBaKlOSUZAkLSb97GwAAAIDcJ9MtOrfccouZTCDtS5McpcslS5Y47dO6dWtZv369mTZaW4C0ledafb7+czOJAUkOAACAd2h9rkiRIjkqvFqHffrpp7P9vFov1rrrqVOnvBrb/fv3m/PYel0tSXNeb54rV8+6llWCg4JlzvY5vi4GAACA8fDDD0vnzp0zHY3XX39dGjVqlCVRvPvuu82Ps+fLl0/KlCkjPXv2lL/++ivX3iF3FfxvvvlG3nzzTfG1rl27ys6dOzO0bWaSIv05Fu1ZVa9ePfH2M17BS+fK1YmOjs2JOxbn62IAAAAfO3xYk4Ury9xOhxTMnDlTduzYIbNnz5Y9e/bI/fffL4EmOTnZq8cvVqyYFCpUSHwtf/78UqpUqSyPXZ48ecxsxzqzsbflycZzXY+ASnQ6VusoyanJsuLACl8XBQAA+JAmOG+8kT2JzqxZs6R+/fqmgqo/jXHbbbfJuXPnTKvM5MmT5bvvvjMtCPqydd8fOnSo1KhRQwoUKCBVqlSRV199VS5dumT/lv6NN96Q33//3b6fbQiA/n5gnz59TEU4IiJC2rRpY7bzRMdB33jjjVKpUiVp0aKFvPjii7Jq1Sr7+Vw5efKkmTyqaNGipoy333677Nq166rtvv32W3Md2lrUrl07p9821HJpkqXJg5Y1OjrajOW2WblypbRq1crETVsAnnrqKRM3m6ioKHnrrbdMi4H+QPwTTzxhZuvV8js6duyYmal38eLF5v2UKVPM7L16Xq1sP/jgg+anS2xdqmxjyfXaNLZ6fFdd19KLga015aeffpLatWtLeHi4dOzY0bRkeKJj0zVmet1aFi2Tp1Yad3HUZ+mRRx4xz4TtOdFnzl3s3HUnW7FihTRs2NDcw2bNmsnmzZs9tix+8MEH5vi2z109467O9euvv0rTpk3NT8Roy6Lex8uXL9s/1/jrM/DCCy+YpFPvne16vCWgEp0+0X3Mcty6cb4uCgAAyAW0Utu9e3d59NFHzeyxWsm79957zfhknUH2gQcesFd+9aWJhtJKq1Zot23bJh9++KGMHz9eRo8ebe+69Nxzz0ndunXt++k6Peadd95pfn9QK8uxsbHSuHFjadu2rZw4cSJD5dXtpk6dasrh6Wc8tIKslem5c+fKb7/9Zs59xx13OCVH58+fl5EjR5qKrlaWExMTpVu3bvbPe/ToIeXLl5e1a9easmrF1nZOrUx36NDBxGrTpk0yY8YMWb58uQwcONCpHO+++67p/qT7azKox/z666/tPy6vdN/SpUubMd+21gvtgqYJgiZiOv7blsxoQqWtWkpbuDS2Gv/ricF7770nX331lSxdutRMuOVp5mBNBPWa9TiaBDz++ONXJW5puYuj3kNNOjT5sT0njudOGzt3hgwZYq5Bj68JtHZ19JQEO/L0jDv6888/zTXHxMSY+zJu3Dgzy7ImY470WSpYsKCsXr1aRo0aJSNGjLjqZ2iylBUATp8+rU+7WRZ6u5BV9v2yvi4SAADIhAsXLljbtm0zS0fnzllWbGzGXgsWWNaUKVder7yiNeErS9s6/Twjx9FzZlRsbKypg+zfv9/l571797Y6deqU7nFGjRplRUdH298PHz7catiwodM2ixYtsiIiIqykpCSn9VWrVrU+++wzj8d/4YUXrAIFCpiy3njjjVZCQoLbbXfu3Gm2W7FihX2dbp8/f35r5syZ5v3EiRPNNqtWrbJvExcXZ9atXr3avC9UqJA1adIkl+fo2bOn1adPH6d1y5Yts4KDg+3PQKVKlazOnTs7bRMfH2+FhIRYS5cuta9r3ry5NWTIELfXs2bNGlOuM2fOmPeLFy8270+ePOm0XevWra3BgwdnOga7d++2bzN27FirdOnSbssybNgwq3bt2lZqaqp93dChQ53Ko8ctXLiw/XNPcUy7rY2r2O3bt8+cZ8OGDU5xmD59un2b48ePm2ucMWOG2+dw9OjR5vienvG053rppZesmjVrOl23xio8PNxKSUmxx//mm292Ok5MTIyJT2b+ZqTNDTzx7451LkSXiZYlfyyRpMtJki8kn6+LAwAArsP27SLR0de+f5ovjDMkNlakceOMbatdfrRFRbuuaQtF+/btzfgX7e6UXnc3/TZ+9+7d5jcItQuPfjPvuVyxZlvtHufowoULZtyNJ/qt/WOPPWZ+u1C7xWmXrO+//950L0pLW6Z0bIV2Y7LRc9asWdN8ZqPbaBcxm1q1apkuV7qNdlHSnxjRFgtt7dDufF26dJGqVavar0WvXVuXbLTFJDU11bTAaFcw5Xh8VbJkSdNFTvdr2bKl2VZbW7SFwGbDhg2my5O2mGgLlh5TaWtLnTp1PMYpszHQLm22a1LaJcvWTc7dcbUboWPctTueJ57i6Ena2LnT3OH82mUs7TVmBT2ensfxum+66SbzPB86dMhMlqEaNGjgtF968bxeAZfo9GjQwyQ6kzdOlr5N+vq6OAAA4DrUqnUl8ciIY8dEEhL+P0HSJOeVV64cQ5UooRXljJ0zM4OutWuNjjf5+eefZcyYMfLyyy+brjf6W4Gu6PgY7eKlCYcmRzqGYvr06fL+++97PJdW2LXil/ZnOlR6M2+VKFHCvHRsiCYR2oVLy+Gqku3YLSzt+rSJkatEybZOkw0dHzN//nz58ccfZfjw4eY677nnHnMtffv2NWMy0rJVepV2Y3LVlWvw4MEm1tOmTTNd/DThVDrGR5NNfelYHU2MNMHROGdmMoOMxiBt9z/9zN2+no7riac4euIqdhkV9Pc1BgcHX1XmjHZrS+/ZsR03vXjaElVvCLhEp1eDXtJnXh+ZtnkaiQ4AAAGuQIGMt644Wr/+SqKjdcFr2T8ztDKm307r67XXXjOD/ufMmWO+iQ8NDZWUlBSn7XU8i26jCZGNtrQ4crWfjsfR8Tna0mAbDH4tbBVM/f1CV7TVQ1uYNFmzjbc4fvy4mfLY1tKidBsdw6KtN7YxLzpls7bs2GhipS+dEEHHMk2cONFU0PVatm7dKtWqVct0+XUqY02SFixYYBIdnS7bZvv27ZKQkCDvvPOOSeaU4wQIttiqtPG9lhhklh5Xxw050oQzPe7i6Oo5yaxVq1bZk0udgEGv0XYPNVHUZ84xUUk7mUFGyqDXrWOjHI+jXw7oWLVy5cqJrwTUZAQqNCRUykWUk9jDGfz6BwAA4BppRfjtt982lWltOdDfYtFZwGyVYU1IdLC9JgFaAddvw7Vyr9vqt/La5eyjjz4yiZEj3U+7ZWmlUvfTpES7LWkLjFb0daYvndlKK4uvvPLKVZV5mzVr1sjHH39sjqPJlM5Mpq0D2vXJXZep6tWrS6dOncxMXTpBgA4ef+ihh0yFVNc7fvs+aNAgEwP94XedAUy7ZWnio93pdGIBbX3S82pyp4PdbXHRWee0y9mAAQNM2XQ2Mx30r8dLj7ZUaDl0gL12idLrsdEKu1a8tbVn79695phpfxtHk0ytbGvXPb1X2n3qWmOQWf369TP3XJNgfSY0UbPNqOdKenHU50TLv2jRIvOc6OQImTVixAiz/5YtW8wEDNryZ/tdHJ0JTWOkEwNouceOHWtalRy5esbT6t+/v5mIQe+vJqM6S5u2TGkctNXIZ6wAkHbAUe85vS15Xazdx/9/cBgAAPBfngYWX4u//tKB1FeW3qRl7tChg1WyZEkrLCzMqlGjhjVmzBinwfPt2rUzg661rqIDwJUOni9evLhZ37VrVzPA23FQuU44cN9991lFihQx++mgc5WYmGgNGjTIKlu2rJU3b16rQoUKVo8ePawDBw64LN+mTZusW2+91SpWrJgpX1RUlNWvXz/r0KFDHq/rxIkTZsIALZMOTtdr1AH6aQfBz54926pSpYoVGhpqtWnTxj4pw8WLF61u3bqZ8ulnWt6BAwc63V+dJMAWm4IFC1oNGjSwRo4caf9cB7xrXFyZP3++iUurVq2u+mzatGnmOvV6daKCuXPnOg2MVyNGjLAiIyOtoKAgM5g+7WQEmYmBozlz5phzeTJv3jyrWrVqpnwtW7a0JkyY4HYygozEUe+nPkt6DJ08wF3s3E1GMG/ePKtu3brm+Dr4f+PGjU77jRs3zpxf71GvXr3MPXKcjMDVM572XGrJkiXm+Hoejb1OMnDp0iX752njr3SSA9v98cZkBEH6H/FzOp2h9m/VecR1IN/aP9dK0y+aytPNnpbRHa9M1QgAAPxXUlKSacHQcS36ex4AcK1/M9LmBjmm65qKKRcjYXnCZP6u+b4uCgAAAAA/FJCJjqpTso7sObnHqzM1AAAAAAhMAZvo3Fv7Xkm1UuX7Xd/7uigAAAAA/EzAJjr9mvQzywkbJvi6KAAAAAD8TMAmOiUKlJBi+YvJ8gPLfV0UAAAAAH4mYBMd1aJ8Czl+4bicOH/C10UBAAAA4EcCOtF59IZHzfKz2M98XRQAAAAAfiSgE51ONTtJcFCwzI6b7euiAAAAAPAjAZ3oBAcHS9WiVWVL/BZfFwUAAACAHwnoREd1rNZRLqZclHV/rfN1UQAAAHKESZMmSZEiRSQnueWWW+Tpp5/O9vMuWbJEgoKC5NSpU16N7f79+815Nm7c6PK83jyXvwr4RGdQ00Fm+cnaT3xdFAAA4EUHDhyQ9evXu33p59nt4Ycfls6dO2d6v9dff10aNWqUpWW5ePGiOWYgVEC9yV0F/5tvvpE333xTfK1r166yc+fODG2bmaSoQoUKcvjwYalXr554+xmv4KVzZbUQCXDVi1eXgnkLyv/2/s/XRQEAAF6iSUzNmjUlKSnJ7Tb58uWTHTt2SMWKFXPlfXjhhRekbNmy8vvvv0sgSk5OltDQUK8dv1ixYuIP8ufPb17eiF1kZKRkhzx58mTbuXJ1i466IfIGOZR4SJIvJ/u6KAAAwAsSEhI8JjlKP9ftstqsWbOkfv36pnJavHhxue222+TcuXOmVWby5Mny3XffmRYEfWlrgho6dKjUqFFDChQoIFWqVJFXX31VLl26ZP+W/o033jAJiW0/XadOnz4tffr0kVKlSklERIS0adMmQ4nLjz/+KD///LO89957GbqmkydPSq9evaRo0aKmjLfffrvs2rXrqu2+/fZbcx2aRLZr104OHjxo/0zLdeutt0qhQoVMWaOjo2Xduv8fSrBy5Upp1aqViZu2ADz11FMmbjZRUVHy1ltvmRaDwoULyxNPPCHNmzeXF1980akMx44dk7x588rixYvN+ylTpkiTJk3MebWy/eCDD0p8fLy9S5WWSem1aWz1+K66rqUXA1tryk8//SS1a9eW8PBw6dixo2nJ8OSHH34wMdPr1rJomTy10riLoz5LjzzyiHkmbM+JPnPuYueuO9mKFSukYcOG5h42a9ZMNm/e7LFl8YMPPjDHt33u6hl3da5ff/1VmjZtKmFhYVKmTBlzHy9fvmz/XOOvz4Am5Jp06r2zXY+35IhEp3v97mKJJVM3T/V1UQAAQA6ildru3bvLo48+KnFxcaaSd++994plWfL888/LAw88YK/86qtFixZmP620aoV227Zt8uGHH8r48eNl9OjR9q5Lzz33nNStW9e+n67TY955551y5MgRU1mOjY2Vxo0bS9u2beXECfe/GXj06FFT0f3qq69MhT0jtIKslem5c+fKb7/9Zs59xx132JMxdf78eRk5cqSp6GplOTExUbp162b/vEePHlK+fHlZu3atKatWbDUhUVqZ7tChg4nVpk2bZMaMGbJ8+XIZOHCgUzneffdd0/1J99dkUI/59ddfm/LY6L6lS5eW1q1b21svtAuaJgiaiO3bt8+ezGhCNXv2ldl4tXVPY6vxv54YaPKosV26dKlpWdT77o4mgnrNehxNAh5//PGrEre03MVRnyVNOjT5sT0njudOGzt3hgwZYq5Bj68J9N133+10jZ54esYd/fnnn+aaY2JizH0ZN26cfPnllyYZc6TPUsGCBWX16tUyatQoGTFihCxcuFC8xgoAp0+f1qfdLF05d/GcJa+L1WZSm2wvGwAASN+FCxesbdu2maWjc+fOWbGxsem+pkyZYuoC6b10u/SOpefMKN1ej7t//36Xn/fu3dvq1KlTuscZNWqUFR0dbX8/fPhwq2HDhk7bLFq0yIqIiLCSkpKc1letWtX67LPPXB43NTXV6tixo/Xmm2+a9/v27TPl3bBhg9uy7Ny502yzYsUK+7qEhAQrf/781syZM837iRMnmm1WrVpl3yYuLs6sW716tXlfqFAha9KkSS7P0bNnT6tPnz5O65YtW2YFBwfbn4FKlSpZnTt3dtomPj7eCgkJsZYuXWpf17x5c2vIkCFur2fNmjWmXGfOnDHvFy9ebN6fPHnSabvWrVtbgwcPznQMdu/ebd9m7NixVunSpd2WZdiwYVbt2rXNfbEZOnSoU3n0uIULF7Z/7imOabe1cRW7tPd+8d9xmD59un2b48ePm2ucMWOG2+dw9OjR5vienvG053rppZesmjVrOl23xio8PNxKSUmxx//mm292Ok5MTIyJT2b+ZmQkN7AJ+DE6qkBoASkTXkbW/rXW10UBAACZsH37dtNVJ6s89NBD6W5jaynJCO3yoy0q2nVNWyjat28v999/v+nulF53N/02fvfu3XL27FnThUe/mU+vXLqtdo9zdOHCBdmzZ4/LfcaMGWNaWoYNGyYZpS1TISEhphuTjZ5Tx0DpZza6jXYRs6lVq5bpcqXbaBelZ5991rRYaGuHdufr0qWLVK1a1X4teu1Tp/5/bxttMUlNTTUtMNoVTDkeX5UsWdJ0kdP9WrZsabbV1hZtIbDZsGGD6fKkLSba0qXHVNraUqdOnSyNgbaQ2a5JaZcsWzc5d8e98cYbTbcuG+2O54mnOHqSNnbuNHc4v3YZS3uNWUGPp+dxvO6bbrrJPM+HDh2yj5tr0KCB037pxfN65YhER90SdYt8veVrOXD6gFQsnDsHIQIAEGi08qyV4oxUpDKSxOj4DVsl2tM5MzPoWrvW6HgTHQOjicXLL79sut5UrlzZ5T6rVq0yXbx0HI4mRzqGYvr06fL+++97PJdW2LXiZxvn48jdzFu//PKLOZ+Oi0hbCdYuUdpVKC3HbmFp1ztWVFXa947rNNnQ8THz5883Y4SGDx9urvOee+4x19K3b18zJiMtx8kitBtTWlruwYMHm1hPmzbNdPHThFPpGB9NNvWl91oTI01wNM7apS2jMhoDW1c8x2t3t6+n43riKY6euIpdRgX9fY36m5Rpy5zRbm3pPTu246YXT1ui6g05JtHpF93PJDpj14yVf7X7l6+LAwAAMkC/Mc9o60pGaJKTlcezVcb022l9vfbaa1KpUiWZM2eO+SZeZ7pKSUlx2l7Hs+g2mhDZ/PHHH07buNpPy63jc7SlwTYYPD0fffSR0ziIv/76y1T6dVyLY2uFI2310BYmTdZs4y2OHz9upjx2TBJ1Gx3Doq03tjEvOmWzY6Kog+719cwzz5ixTBMnTjQVdL2WrVu3SrVq1SSzdCpjTZIWLFhgEp2ePXs6tQDqhBPvvPOOGY+jHCdAULaZ29LG91pikFl6XB035EgT0fS4i6Or5ySzVq1aZU8udQIGvUbbPdREUZ85x0Ql7WQGGSmDXreOjXI8jn45oGPVypUrJ76SIyYjUK2iWkne4Lwyb+c8XxcFAADkEFoRfvvtt01lWlsO9LdYdBYwW2VYExIdbK9JgFbA9dtwrdzrtvqtvHY502REEyNHup92y9JKpe6nv4Gj3Za0+49W9HWmL53ZSiuLr7zyylWVeRutwOqAdNtLK8tKuz7pAHdXqlevLp06dTITGOgEATp4XFvLtEKq6x2/fR80aJCJgf5Okc4Apt2yNPHR7nQ6sYC2PmkSp8mdDna3xUVnndMuZwMGDDDXqLOZ6aB/PV56tKVCy6ED7LUlT1s7HK9XK97a2rN3715zzLS/jaNJpla2v//+e3OvtPvUtcYgs/r162fuuSbB+kxoomabUc+V9OKoz4mWf9GiReY50ckRMmvEiBFm/y1btpgJGEqUKGH/XRydCU1jpBMDaLnHjh1rWpUcuXrG0+rfv7+ZiEHvryajOkubtkxpHLTVyGesAJDRAUf1P6lvhYwIsQ96AgAA/sHTwOKM+OOPP6x8+fJ5nIhAP9ftspKWuUOHDlbJkiWtsLAwq0aNGtaYMWOcBs+3a9fODLrWMugAcKWD54sXL27Wd+3a1QzwdhxUrhMO3HfffVaRIkXMfjroXCUmJlqDBg2yypYta+XNm9eqUKGC1aNHD+vAgQMZKm9GJiNQJ06cMBMGaJl0cLpeow7QTzsIfvbs2VaVKlWs0NBQq02bNvZJGS5evGh169bNlE8/0/IOHDjQ6f7qJAG22BQsWNBq0KCBNXLkSPvnOuBd4+LK/PnzzXW0atXqqs+mTZtmRUVFmfuhExXMnTv3qmseMWKEFRkZaQUFBZnB9GknI8hMDBzNmTPHnMuTefPmWdWqVTPla9mypTVhwgS3kxFkJI79+vUzz5IeQycPcBc7d5MRzJs3z6pbt645vg7+37hxo9N+48aNM+fXe9SrVy9zjxwnI3D1jLt6zpYsWWKOr+fR2OskA5cuXbJ/njb+Sic5sN0fb0xGEKT/ET+ng+y0f6vOI+5pIN9ri1+TN5e+KQt6LJAO1TpkaxkBAIDn37jRFgwd16K/53EttJXE0+/k6DfVufXHQoHc9DcjMYO5QY4Zo6P6x/Q3ic749eNJdAAAyGE0iSGRAZDrxuioyPBIKZKviCz7Y5mviwIAAADAh3JUoqOalWsm8efjJTEp0ddFAQAAAOAjOS7R6d2wt1l+seELXxcFAAAAgI/kuESnS90uEiRBMnPrTF8XBQAAAICP5LhEJyQ4RKKKRMmmo5t8XRQAAAAAPpLjEh3VoWoHuXD5gmw5usXXRQEAAADgAzky0RnYdKBZfrzmY18XBQAAAIAP5MhEp26pupI/JL/8tPcnXxcFAAAAgA/kyERHNSjdQP449YdcTr3s66IAAAAElEmTJkmRIkUkJ7nlllvk6aefzvbzLlmyRIKCguTUqVNeje3+/fvNeTZu3OjyvN48l7/KsYnOA3UfEEss+e/W//q6KAAAIAskHUySM+vPuH0lHUrK9jg//PDD0rlz50zv9/rrr0ujRo2ypAxRUVGm0un4evHFFyW3clfB/+abb+TNN98UX+vatavs3LkzQ9tmJimqUKGCHD58WOrVqyfefsYreOlcWS1Ecqg+0X3kuZ+fk8m/T5bu9bv7ujgAAOA6pF5MldiYWLl09JLbbfJG5pXm+5tLcFiO/R7XrREjRsgTTzxhfx8eHi6BJjk5WUJDQ712/GLFiok/yJ8/v3l5I3aRkZGSHfLkyZNt57oeOfYvQXhouJQqWEpW/7na10UBAADXKSg0SPJVzOe+5hIskq9CPrNdVps1a5bUr1/fVE6LFy8ut912m5w7d860ykyePFm+++47e0uKtiaooUOHSo0aNaRAgQJSpUoVefXVV+XSpUv2b+nfeOMN+f333+376Tp1+vRp6dOnj5QqVUoiIiKkTZs2Zrv0FCpUyFQ8ba/0Ep2TJ09Kr169pGjRoqaMt99+u+zateuq7b799ltzHfny5ZN27drJwYMH7Z9puW699VZzbi1rdHS0rFu3zv75ypUrpVWrViZu2gLw1FNPmbg5tkS99dZbpsWgcOHCJlFr3rz5Va1Rx44dk7x588rixYvN+ylTpkiTJk3s1/zggw9KfHy8vUuVlknptWls9fiuuq6lFwNba8pPP/0ktWvXNjHt2LGjacnw5IcffjAx0+vWsmiZPLXSuIujPkuPPPKIeSZsz4k+c+5i56472YoVK6Rhw4bmHjZr1kw2b97ssWXxgw8+MMe3fe7qGXd1rl9//VWaNm0qYWFhUqZMGXMfL1/+/yEkGn99Bl544QWTdOq9s12Pt+TYREe1qtRKTiWdkiNnj/i6KAAA4Dpoparym5VFUt1skCrmc90uK2mltnv37vLoo49KXFycqeTde++9YlmWPP/88/LAAw/YK7/6atGihdlPK61aod22bZt8+OGHMn78eBk9erS969Jzzz0ndevWte+n6/SYd955pxw5csRUlmNjY6Vx48bStm1bOXHihMdy/utf/zJJmFZaR44cab7h90QryFqZnjt3rvz222/m3HfccYc9GVPnz583x9KKrlaWExMTpVu3bvbPe/ToIeXLl5e1a9easmrFVhMSpZXpDh06mFht2rRJZsyYIcuXL5eBA6/MjGvz7rvvmu5Pur8mg3rMr7/+2pTHRvctXbq0tG7d2rzXa9MuaJogaCK2b98+ezKjCdXs2bPNv3fs2GFiq/G/nhi899578tVXX8nSpUvlwIED5r67o4mgXrMeR5OAxx9/PN1uhO7iqM+SJh2a/NieE8dzp42dO0OGDDHXoMfXBPruu+92ukZPPD3jjv78809zzTExMea+jBs3Tr788kuTjDnSZ6lgwYKyevVqGTVqlGmJXLhwoXiNFQBOnz6tT7tZZsbPu3+25HWxXln0itfKBgAA0nfhwgVr27ZtZuno8rnLVmJsYoZep9edtlbXWW0tDl5sLRaHV/Bis14/z8hx9JwZFRsba+og+/fvd/l57969rU6dOqV7nFGjRlnR0dH298OHD7caNmzotM2iRYusiIgIKykpyWl91apVrc8++8ztsf/9739bS5YssX7//Xdr/PjxVokSJazHHnvM7fY7d+4017RixQr7uoSEBCt//vzWzJkzzfuJEyeabVatWmXfJi4uzqxbvXq1eV+oUCFr0qRJLs/Rs2dPq0+fPk7rli1bZgUHB9ufgUqVKlmdO3d22iY+Pt4KCQmxli5dal/XvHlza8iQIW6vZ82aNaZcZ86cMe8XL15s3p88edJpu9atW1uDBw/OdAx2795t32bs2LFW6dKl3ZZl2LBhVu3ata3U1FT7uqFDhzqVR49buHBh++ee4ph2WxtXsdu3b585z4YNG5ziMH36dPs2x48fN9c4Y8YMt8/h6NGjzfE9PeNpz/XSSy9ZNWvWdLpujVV4eLiVkpJij//NN9/sdJyYmBgTn8z8zchMbpBjx+iotpXbSkhwiHy34zt5s43vB58BAABn57efl9jo2OsLS6rI+W3nZX2T9RnaPDo2Wgo1LpShbbXLj7aoaNc1baFo37693H///aa7U3rd3fTb+N27d8vZs2dNFx79Zt4T/WZet9WWGUcXLlyQPXv2uN3vmWeesf+7QYMGpmxaRlsrT1raMhUSEmK6MdnodjVr1jSf2eg22kXMplatWqbLlW6jXZSeffZZ02KhrR3ana9Lly5StWpV+7XotU+dOtW+v7aYpKammhYY7QqmHI+vSpYsabrI6X4tW7Y022pri7YQ2GzYsMF0edIWE23p0mMqbW2pU6eOxxhnNgbapc12TUq7ZNm6ybk77o033ujUsqjd8TzxFEdP0sbOneYO59cuY2mvMSvo8fQ8jtd90003mef50KFDUrFiRfvz6Si9eF6vHJ3oBAcHS/Vi1WV7wnZfFwUAALhQoFYBk3hklFaWt/fabhIk040t+Moxav2nVoa7ren2mRl0rV1rdLzJzz//LGPGjJGXX37ZdL2pXLmyy31WrVplunjpOBxNjnQMxfTp0+X999/3eC6tsGvFzzbOx1FmpiPWirbSRMNVouPYLSzt+rQxdBVT2zpNNnR8zPz58+XHH3+U4cOHm+u85557zLX07dvXjMlIy1bpVdqNyVVXrsGDB5tYT5s2zXTx04RT6RgfTTb1pWN1NDHSBEfjnF53vWuJga0rnuO1u9vX03E98RRHT1zFLqOC/r5GrSunLXNGu7Wl9+zYjptePG2Jqjfk6ERH/aPGP2TUylGydP9SaRXVytfFAQAADvIUyJPh1hWbav+uJps6brryJvXK+4hoz60l10MrY/rttL5ee+01qVSpksyZM8d8E68zXaWkpDhtr+NZdBtNiGz++OMPp21c7afjcXR8jrY02AaDXwtt8VCaNLmirR7awqTJmm28xfHjx82Ux7aWFqXb6BgWbb2xjXnRKZu1ZcdGB93rS1uVdCzTxIkTTQVdr2Xr1q1SrVq1TJdfpzLWJGnBggUm0enZs6f9s+3bt0tCQoK88847ZjyOcpwAQdlmbksb32uJQWbpcXXcUNrENz3u4ujqOcmsVatW2ZNLnYBBr9F2DzVR1GfOMVFJO5lBRsqg161joxyPo18O6Fi1cuXKia/k6MkI1ICmA8zy09hPfV0UAACQBYq2LyqFYq4kR7rU996iFeG3337bVKa15UB/i0VnAbNVhjUh0cH2mgRoBVy/DdfKvW6r38prl7OPPvrIJEaOdD/tlqWVSt3v4sWLptuSdv/Rir7O9KUzW2ll8ZVXXrmqMm+j3bp0kgM9jh5v5syZJknQAeeOLSeOqlevLp06dTIzdekEATp4/KGHHjIVUl3v+O37oEGDTAzWr19vZgDT1iJNfLQ7nU4soK1PmsRpcqeD3W1x0VnntGwDBgwwZdPZzHTQvx4vPdpSoeXQAfbaJUpbO2z0mrTira09e/fuNcdM+9s4mmRqZfv7778390q7T11rDDKrX79+5p5rEqzPhCZqthn1XEkvjvqcaPkXLVpknhOdHCGzRowYYfbfsmWLmYChRIkS9t/F0ZnQNEY6MYCWe+zYsaZVyZGrZzyt/v37m4kY9P5qMqqztGnLlMZBW418xsrBkxHYRPwzwirzXpksLxcAAMgYTwOLr8Xxhcet1bVXm6U3aZk7dOhglSxZ0goLC7Nq1KhhjRkzxmnwfLt27cyga62r6ABwpYPnixcvbtZ37drVDPB2HFSuEw7cd999VpEiRcx+OuhcJSYmWoMGDbLKli1r5c2b16pQoYLVo0cP68CBA24nS2jWrJk5dr58+cyAcB1gfu7cOY/XdeLECTNhgO6ng9P1GnWAftpB8LNnz7aqVKlihYaGWm3atLFPynDx4kWrW7dupnz6mZZ34MCBTvdXJwmwxaZgwYJWgwYNrJEjR9o/1wHvGhdX5s+fb+LSqlWrqz6bNm2aFRUVZe6HTlQwd+5cp4HxasSIEVZkZKQVFBRkBtOnnYwgMzFwNGfOHHMuT+bNm2dVq1bNlK9ly5bWhAkT3E5GkJE49uvXzzxLegy9t+5i524ygnnz5ll169Y1x9fB/xs3bnTab9y4ceb8eo969epl7pHjZASunvG051I6IYYeX8+jsddJBi5dumT/PG38lU5yYLs/3piMIEj/I35OpzPU/q06j3h6A/lcue0/t8mifYvk3LBzUiA04/1yAQBA1khKSjItDjquRX/PAwCu9W9GRnODHN91TfVscKVv54SNE3xdFAAAAADZIFckOt3rdZcgCZLpW6b7uigAAAAAskGuSHRCQ0KlfER52XjEeRYJAAAAADlTrkh01G1VbpNzl87JjoQdvi4KAAAAAC/LNYlO/5j+Zjl27VhfFwUAAACAl+WaRKdJ2SYSlidMftztPDc4AAAAgJwn1yQ6ql6perL35F5JTU31dVEAAAAAeFGuSnTur3O/pFqpMme7868TAwAAAMhZclWi069JP7OcuHGir4sCAADgtyZNmiRFihSRnOSWW26Rp59+OtvPu2TJEgkKCpJTp055Nbb79+8359m4caPL83rzXP4qVyU6RfIVkeL5i8tvh37zdVEAAEAO8PDDD0vnzp0zvd/rr78ujRo1yrJyzJ8/X5o1ayb58+eXEiVKyL333iu5lbsK/jfffCNvvvmm+FrXrl1l586dGdo2M0lRhQoV5PDhw1KvXj3x9jNewUvnymohksvcXPFm+W7Hd5JwPkFKFCjh6+IAAIAMupiaKqFBQaYSi/83e/ZseeKJJ+Ttt9+WNm3aiGVZsnnz5oALUXJysoSGhnrt+MWKFRN/oMmovrwRu8jISMkOefLkybZzXY9c1aKjHr3hUbP8dN2nvi4KAADIoINJSVLpt9+k2fr18tOJE6Yyn11mzZol9evXN5XT4sWLy2233Sbnzp0zrTKTJ0+W7777ziRf+tLWBDV06FCpUaOGFChQQKpUqSKvvvqqXLp0yf4t/RtvvCG///67fT9dp06fPi19+vSRUqVKSUREhElcdDt3Ll++LIMHD5Z3331X+vXrZ85Zs2ZNuf/++z1e08mTJ6VXr15StGhRU8bbb79ddu3addV23377rTlmvnz5pF27dnLw4EH7Z1quW2+9VQoVKmTKGh0dLevWrbN/vnLlSmnVqpWJm7YAPPXUUyZuNlFRUfLWW2+ZFoPChQubZK158+by4osvOpXh2LFjkjdvXlm8eLF5P2XKFGnSpIk5r1a2H3zwQYmPj7d3qdIyKb02ja0e31XXtfRiYGtN+emnn6R27doSHh4uHTt2NC0Znvzwww8mZnrdWhYtk6dWGndx1GfpkUceMc+E7TnRZ85d7Nx1J1uxYoU0bNjQ3ENt9XNMgl21LH7wwQfm+LbPXT3jrs7166+/StOmTSUsLEzKlClj7qM+nzYaf30GXnjhBZN06r2zXY+35LpE567qd0meoDzyTdw3vi4KAADIoGOXLsnRS5ck9swZ6bhpU7YlPFqp7d69uzz66KMSFxdnKnnaLUzP+/zzz8sDDzxgr/zqq0WLFmY/rbRqhXbbtm3y4Ycfyvjx42X06NH2rkvPPfec1K1b176frtNj3nnnnXLkyBFTWY6NjZXGjRtL27Zt5cSJEy7Lt379evnzzz8lODhYbrjhBlPB1Ar71q1bPV6XVpC1Mj137lz57bffzLnvuOMOezKmzp8/LyNHjjQVXa0sJyYmSrdu3eyf9+jRQ8qXLy9r1641ZdWKrSYkSivTHTp0MLHatGmTzJgxQ5YvXy4DBw50KocmaNr9SffXZFCP+fXXXzvdV923dOnS0rp1a3vrhXZB0wRBE7F9+/bZkxlNqLSFS+3YscPEVuN/PTF477335KuvvpKlS5fKgQMHzH13RxNBvWY9jiYBjz/++FWJW1ru4qjPkiYdmvzYnhPHc6eNnTtDhgwx16DH1wT67rvvdrpGTzw94470GdRrjomJMfdl3Lhx8uWXX5pkzJE+SwULFpTVq1fLqFGjZMSIEbJw4ULxGisAnD59Wp92s8wKNcbUsELfDM2SYwEAgPRduHDB2rZtm1lei9jEREsWL7a/8vy9jFm3zlpw/LiVmprqldsQGxtr6iD79+93+Xnv3r2tTp06pXucUaNGWdHR0fb3w4cPtxo2bOi0zaJFi6yIiAgrKSnJaX3VqlWtzz77zOVxv/76a1O+ihUrWrNmzbLWrVtnde/e3SpevLh1/Phxl/vs3LnT7LNixQr7uoSEBCt//vzWzJkzzfuJEyeabVatWmXfJi4uzqxbvXq1eV+oUCFr0qRJLs/Rs2dPq0+fPk7rli1bZgUHB9ufgUqVKlmdO3d22iY+Pt4KCQmxli5dal/XvHlza8iQIZY7a9asMeU6c+aMeb9Ynw0R6+TJk07btW7d2ho8eHCmY7B79277NmPHjrVKly7ttizDhg2zateu7fQ8Dh061Kk8etzChQvbP/cUx7Tb2riK3b59+8x5NmzY4BSH6dOn27fRZ0KvccaMGW6fw9GjR5vje3rG057rpZdesmrWrOl03Rqr8PBwKyUlxR7/m2++2ek4MTExJj6Z/ZuR0dwg143RUXdWv1NGrxotqw+tlmblm/m6OAAA5FrnU1Jk+/nz6W4Xl2ablL+XthaeOgUKyMBy5aRZRES6x6pVoIAUyJMnQ+XTLj/aoqJd17SFon379qZbmHZ3Sq+7m34bv3v3bjl79qzpwqPfzHui38zrtto9ztGFCxdkz549Lvex/Tbgyy+/LPfdd5/598SJE00LwX//+1/p27fvVftoy1RISIjpxmSj59Qub/qZjW6jXcRsatWqZbpc6TbaRenZZ581LRba2qHd+bp06SJVq1a1X4te+9SpU+37a4uJlldbYLQrmHI8vipZsqTpIqf7tWzZ0myrrS3aQmCzYcMG0+VJW0y0pcsWA21tqVOnjscYZzYG2qXNdk1KW8xs3eTcHffGG290Gkem3fE88RRHT9LGzp3mDufXLmNprzEr6PH0PI7XfdNNN5nn+dChQ1KxYkWzrkGDBk77pRfP65UrE50BMQNMovPJ2k9IdAAA8CFNcqJjY695f9tPgG87f176uxhj4kpsdLQ0LlQow4OutWuNjjf5+eefZcyYMSap0K43lStXdrnPqlWrTBcvHYejyZGOoZg+fbq8//77nq8lNdVU/GzjfBy5m3lLt1eOFXwdI6HjgrTi74q77n66Pu1ED64mfrCt02RDx8fojG8//vijDB8+3FznPffcY65Fkywdk5GWrdKrtBuTq65cOu5IYz1t2jTTxU8TTqVjfDTZ1JeO1dHESK9T46xd2jIqozGwdcVzvHZP3SWvpSulpzh64ip2GRX09zVql8e0Zc5ot7b0nh3bcdOLpy1R9YZcmehULVZVCuYtKL/s/8XXRQEAIFfT1hVNPDLSovOQi2+hdbCxVpMy26KTGVoZ02+n9fXaa69JpUqVZM6cOeabeJ3pKiXF1r50hY5n0W00IbL5448/nLZxtZ+Ox9HxOdrSYBsMnh4duK6JjY5Hufnmm+0VVR0srmVwRZMibWHSZM023uL48eNmymNbS4vSbXQMi7beKD2HTtmsLTs2OuheX88884wZy6StSVpB12vRcULVqlWTzNKpjDVJWrBggUl0evbsaf9s+/btkpCQIO+8844Zj6McJ0BQtpnb0sb3WmKQWXpcHTeUNvFNj7s4unpOMmvVqlX25FInYNBrtN1DTRT1mXNMVNJOZpCRMuh169gox+PolwM6Vq1cuXLiK7luMgKb6DLR8mfin5J8OePZPwAAyFrahUxbV9J71U6TnNg6nkUXKiQLGjSQLTEx8mS5chk6Vka7rSmtCOu0zVqZ1pYD/S0WnQXMVhnWhEQH22sSoBVwTTK0cq/b6rfy2uXso48+MomRI91Pu2VppVL3u3jxoum2pN1/tKKvM31psqKVxVdeeeWqyryNdofT2da0FUBbnLQcTz75pPlMu0C5Ur16denUqZOZqUsnCNDB4w899JCpkOp6x2/fBw0aZGKgkx7oDGDaLUsTH+1OpxMLaOuTJnGa3Olgd1tcdNY57XI2YMAAc406m5kO+tfjpUdbKrQcOsBeu0Rpa4eNVti14q2tPXv37jXHTPvbOJrgaWX7+++/N/dKu09dawwyS++F3nNNgvVeaKJmm1HPlfTiqM+Jln/RokXmOdHJETJrxIgRZv8tW7aYCRj0d5Zsv4ujM6FpjHRiAC332LFjTauSI1fPeFr9+/c3EzHo/dVkVGdp02dS46CtRj5j5cLJCNSnaz+15HWxxseOz7JjAgAA705GEJxNkxDYaJk7dOhglSxZ0goLC7Nq1KhhjRkzxmnwfLt27cyga62r6ABwpYPndUIAXd+1a1czwNtxULlOOHDfffdZRYoUMfvpoHOVmJhoDRo0yCpbtqyVN29eq0KFClaPHj2sAwcOuC1jcnKy9dxzz1mlSpUyA9tvu+02a8uWLR6v68SJE2bCAC2TDk7Xa9QB+mkHwc+ePduqUqWKFRoaarVp08Y+KcPFixetbt26mfLpZ1regQMHOt1fnSTAFpuCBQtaDRo0sEaOHGn/XAe8a1xcmT9/volLq1atrvps2rRpVlRUlLkfOlHB3LlznQbGqxEjRliRkZFWUFCQGUyfdjKCzMTA0Zw5c8y5PJk3b55VrVo1U76WLVtaEyZMcDsZQUbi2K9fP/Ms6TF08gB3sXM3GcG8efOsunXrmuPr4P+NGzc67Tdu3Dhzfr1HvXr1MvfIcTICV8942nOpJUuWmOPreTT2OsnApUuX7J+njb/SSQ5s98cbkxEE6X/Ez+l0htq/VecRT28gX0YlXU6S/CPzyy2VbpHFD1+Zlx0AAHhHUlKSacHQcS36ex6ZdSgpSWJiY6VCvnzyZuXK0v7v30gBkPv+ZiRmMDfIlWN0VL6QfFKuUDlZd9h1UzAAAPAf5fPlk/3Nm0vo3z9aCADpybVjdFSbqDZyNvms7Du5z9dFAQAA6QgLDibJAZBhuTrR6dvkytzyH6/92NdFAQAAAJCFcnWic1PFmyQ0OFR+2PmDr4sCAAAAIAvl6kRH1S5ZW3ad2OXVHysCAAAAkL1yfaJzT617JMVKkQV7FmRz6AEAAAB4S65PdJ5scuVHtb5Y/4XXggwAAAAge+X6RKdUeCkpmq+oLD+wPJtDDwAAAMBbcn2io5qXby7Hzh+TU0mnvBZoAAAAANmHREdEHrnhEROMz2M/z8bQAwAA+KdJkyZJkSJFJCe55ZZb5Omnn8728y5ZssT8/tOpU6e8Gtv9+/eb82zcuNHleb15Ln9FoiMi99a6V4KDgmXWtlm+vh8AACCAPPzww9K5c+dM7/f6669Lo0aNrvv8tsqsq9fatWslN3JXwf/mm2/kzTffFF/r2rWr7Ny5M0PbZiYpqlChghw+fFjq1asn3n7GK3jpXFktxNcF8AfBwcESVSRKNsdv9nVRAADANbAsS5JTkiUsJCxXxa9Fixamwuno1Vdflf/973/SpEkTCSTJyckSGhrqteMXK1ZM/EH+/PnNyxuxi4yMlOyQJ0+ebDvX9aBF528dq3WUpMtJsvGwfzfBAQAA5wTnp90/SbMvmkmlDyrJwdMHszw8s2bNkvr165vKafHixeW2226Tc+fOmVaZyZMny3fffWdvRdHWBDV06FCpUaOGFChQQKpUqWKSj0uXLtm/pX/jjTfk999/t++n69Tp06elT58+UqpUKYmIiJA2bdqY7dyxVW5tLy3f3Llz5dFHHzXHdefkyZPSq1cvKVq0qCnj7bffLrt27bpqu2+//dZcR758+aRdu3Zy8OD/x1fLdeutt0qhQoVMWaOjo2XdunX2z1euXCmtWrUycdMWgKeeesrEzSYqKkreeust02JQuHBheeKJJ6R58+by4osvOpXh2LFjkjdvXlm8eLF5P2XKFJPE6Xn1mh988EGJj4+3d6nSMim9No2BHt9V17X0YmBrTfnpp5+kdu3aEh4eLh07drwqsUzrhx9+MDHT69ayaJk8tdK4i6M+S4888oh5JmzPiT5z7mLnrjvZihUrpGHDhuYeNmvWTDZv3uyxZfGDDz4wx7d97uoZd3WuX3/9VZo2bSphYWFSpkwZcx8vX75s/1zjr8/ACy+8YJJOvXe26/EWEp2/DYwZaJZj1471asABAEDWJjgdp3aU2L9i5ei5o2Zyoaykldru3bubxCEuLs5U8u69915z/ueff14eeOABe+VXX9rCorTSqhXabdu2yYcffijjx4+X0aNH27suPffcc1K3bl37frpOj3nnnXfKkSNHTGU5NjZWGjduLG3btpUTJ05kqLya5CQkJNgr9+7o51qZ1u1/++03c+477rjDnoyp8+fPy8iRI01FVyvLiYmJ0q1bN/vnPXr0kPLly5suclpWrdhqQqK0Mt2hQwcTq02bNsmMGTNk+fLlMnDglfqWzbvvvmu6P+n+mgzqMb/++mtTHhvdt3Tp0tK6dWt764V2QdMEQROxffv22a9XE6rZs2ebf+/YscPEVuN/PTF477335KuvvpKlS5fKgQMHzH13RxNBvWY9jiYBjz/++FWJW1ru4qjPkiYdmvzYnhPHc6eNnTtDhgwx16DH1wT67rvvdrpGTzw9447+/PNPc80xMTHmvowbN06+/PJLk4w50mepYMGCsnr1ahk1apSMGDFCFi5cKF5jBYDTp0/r026W3lRgZAGr0uhKXj0HAAC50YULF6xt27aZ5fVITU21FuxaYMV8HmPJ62LleSOPWdpesX/FWlkpNjbW1EH279/v8vPevXtbnTp1Svc4o0aNsqKjo+3vhw8fbjVs2NBpm0WLFlkRERFWUlKS0/qqVatan332WYbKe/vtt5uXJzt37jTXtGLFCvu6hIQEK3/+/NbMmTPN+4kTJ5ptVq1aZd8mLi7OrFu9erV5X6hQIWvSpEkuz9GzZ0+rT58+TuuWLVtmBQcH25+BSpUqWZ07d3baJj4+3goJCbGWLl1qX9e8eXNryJAhbq9nzZo1plxnzpwx7xcvXmzenzx50mm71q1bW4MHD850DHbv3m3fZuzYsVbp0qXdlmXYsGFW7dq1zXNqM3ToUKfy6HELFy5s/9xTHNNua+Mqdvv27TPn2bBhg1Mcpk+fbt/m+PHj5hpnzJjh9jkcPXq0Ob6nZzztuV566SWrZs2aTtetsQoPD7dSUlLs8b/55pudjhMTE2Pik9m/GRnNDRij46BR6Uby26Hf5HLqZQkJJjQAAHjb+UvnZXvC9gxtu/rQavl47cey7dg2M4mQSrFSnLaJS4hL9zi1StSSAnkLZOic2uVHW1S065q2ULRv317uv/9+090pve5u+m387t275ezZs6YLj34z74l+M6/bavczRxcuXJA9e/akW9ZDhw6ZblYzZ870uJ22TIWEhJhuTDZ6zpo1a5rPbHQbx3E+tWrVMl2udBvtovTss8+aFgtt7dDufF26dJGqVavar0WvferUqfb9tcUkNTXVtMBoVzCVdhxRyZIlTRc53a9ly5ZmW21t0RYCmw0bNpguT9pioi1dekylrS116tRJN06ZiYF2abNdk9IuWbZucu6Oe+ONNzp1G9TueJ54iqMnGR2D1dzh/NplLO01ZgU9np7H8bpvuukm8zzrc1mxYkWzrkGDBk77pRfP60Vt3kG3et1k5aGVMm3zNOnVsJfXgg4AAK7QJCf68+hMhyPVulK5Teuhbx5Kd9/YPrHSuEzjDA+61q41Ot7k559/ljFjxsjLL79sut5UrlzZ5T6rVq0yXbx0HI4mRzqGYvr06fL+++97vqbUVFPxs43zcZSRmbcmTpxoKuvaNckTx25hadenHdfjapyPbZ0mGzo+Zv78+fLjjz/K8OHDzXXec8895lr69u1rxmSkZav0Ku3G5Kor1+DBg02sp02bZrr4acKpdIyPJpv60rE6mhhpgqNx1i5tGZXRGNi64jleu7t9PR3XE09x9MRV7DIq6O9r1Am50pY5o93a0nt2bMdNL562RNUbSHTS/J7OUwuekimbppDoAACQDbR1RROPa2nRcZXsTLl3itQuUTvdc2aGVsb022l9vfbaa1KpUiWZM2eO+SZeJwNISXFuVdLxLLqNJkQ2f/zxh9M2rvbT8Tg6PkdbGmyDwTNKK5Wa6Ojg+rSVybS01UNbmDRZs423OH78uJny2NbSonQbHcOirTe2MS86ZbO27NjooHt9PfPMM2Ysk5ZBK+h6LVu3bpVq1apJZulUxpokLViwwCQ6PXv2tH+2fft2MwbpnXfeMeNxlOMECMo2c1va+F5LDDJLj6vjhtImvulxF0dXz0lmrVq1yp5c6gQMeo22e6iJoj5zjolK2skMMlIGvW4dG+V4HP1yQMeqlStXTnyFyQgchIeGS2R4pKz5c43PbggAALmJdiHT1pWMvJ6MeVK2PLlFFvRYINFlrrQC5QnK43Q8TXLSO05Gu60prQi//fbbpjKtLQf6Wyw6C5itMqwJiQ621yRAK+D6bbhW7nVb/VZeu5x99NFHJjFypPtptyytVOp+Fy9eNN2WtPuPVvS1C5rObKWVxVdeeeWqynxav/zyizneY489lu41Va9eXTp16mRm6tIJAnTw+EMPPWQqpLreRhOmQYMGmRisX7/ezACm3bI08dHudDqxgLY+aRKnyZ0OdrfFRWed0y5nAwYMMNeos5npoH89Xnq0pULLoQPstUuUtnbYaIVdK97a2rN3715zzLS/jaNJpla2v//+e3OvtPvUtcYgs/r162fuuSbB+kxoomabUc+V9OKoz4mWf9GiReY50ckRMmvEiBFm/y1btpgJGEqUKGH/XRydCU1jpBMDaLnHjh1rWpUcuXrG0+rfv7+ZiEHvryajOkubtkxpHLTVyGesAJBdkxGorv/tagYzHjx90OvnAgAgt8iqyQjcTUoQ/HqwVyYj0DJ36NDBKlmypBUWFmbVqFHDGjNmjNPg+Xbt2plB11pX0QHgSgfPFy9e3Kzv2rWrGeDtOKhcJxy47777rCJFipj9dNC5SkxMtAYNGmSVLVvWyps3r1WhQgWrR48e1oEDBzyWs3v37laLFi0yfF0nTpwwEwZomXRwul6jDtBPOwh+9uzZVpUqVazQ0FCrTZs29kkZLl68aHXr1s2UTz/T8g4cONDp/uokAbbYFCxY0GrQoIE1cuRI++c64F3j4sr8+fNNXFq1anXVZ9OmTbOioqLM/dCJCubOnes0MF6NGDHCioyMtIKCgsxg+rSTEWQmBo7mzJljzuXJvHnzrGrVqpnytWzZ0powYYLbyQgyEsd+/fqZZ0mPoZMHuIudu8kI5s2bZ9WtW9ccXwf/b9y40Wm/cePGmfPrPerVq5e5R46TEbh6xtOeSy1ZssQcX8+jsddJBi5dumT/PG38lU5yYLs/3piMIEj/I35OpzPU/q06j3h6A/mu1y/7fpG2/2krw24eJm+3fdur5wIAILdISkoyLQ46rkV/zyOraDXm5z0/y6uLX5WDiQdl7RNrpXxE+Sw7PgD/+5uR0dyArmtptKncxsy4NnfHXO/cNQAAkGW0i1KHah1k9eOrZf/g/SQ5AOxIdFyoVbyW7Di+w9VHAADATxOesJAwXxcDgB8h0XHh7lp3m9/SWbR3UfbfEQAAAADXjUTHhSebPGmW49ePv/4IAwAAAMh2JDou6CDGwmGF5dc/fs3+OwIAAADgupHouNG0XFM5cvaInE2+eu51AABwbQJgslcAOeRvBYmOG70a9DLLL9d/ed1BBgAgt9Mfn1TX8oOHAHKf83//rbD97bgWIVlYnhylW/1u0uvbXjJj6wwZfONgXxcHAICAlidPHilSpIjEx8eb9wUKFDAzpQFA2pYcTXL0b4X+zdC/HdeKRMddYIJDpGLhirLxyMZrDi4AAPh/kZGRZmlLdgDAHU1ybH8zrhWJjgftq7Y3M69tjd8qdUvVva5AAwCQ22kLTpkyZaRUqVJy6dIlXxcHgJ/S7mrX05JjQ6LjQf8m/U2i88m6T2TsHWOvO9gAAOBKN7asqMQAgCdMRuBBozKNJF9IPlmwe4HHIAIAAADwLyQ66ahfqr7sP7VfUlNTs+eOAAAAALhuJDrp6FKni6RaqTIrbtb1RxsAAABAtiDRSUff6L5mOWnjpOy4HwAAAACyAIlOOiLyRUjJAiVl1aFVWRFvAAAAANmARCcDWlZsKSeTTkr8Web9BwAAAAIBiU4GPNb4MbMct26ct+8HAAAAgCxAopMBHat2lDxBeWTO9jlZEXMAAAAAXkaik5EgBQdL9WLVJe5YnLfvBwAAAIAsQKKTQXfVuEuSU5NlxYEVWRF3AAAAAF5EopNBA5sONEvG6QAAAAD+j0QngyoVqSSFQgvJ4v2LvXtHAAAAAFw3Ep1MaFK2ifx15i9Jupx0/ZEHAAAA4DUkOpnwYP0HzXLyxsneuh8AAAAAsgCJTib0atBLgiRIpm2elhWxBwAAAOAlJDqZEBoSKuUiykns4Vhv3Q8AAAAAWYBEJ5PaVm4r5y6dkz0n9vAAAgAAAH6KRCeTBsQMMMuP13zsjfsBAAAAIAuQ6GRSTLkYCcsTJvN3zc+K+AMAAADwAhKda1C3ZF3Zc3KPpKamZv0dAQAAAHDdSHSuwT2175FUK1W+3/X99d8BAAAAAFmOROca9GvSzywnbJiQ1fcDAAAAQBYg0bkGJQqUkGL5i8nyA8uz4h4AAAAAyGIkOteoRfkWcvzCcTlx/kTW3hEAAAAAvkl0PvnkE6lcubLky5dPoqOjZdmyZR63nzp1qjRs2FAKFCggZcqUkUceeUSOHz8ugezRGx41y89iP/N1UQAAAABcb6IzY8YMefrpp+Xll1+WDRs2SMuWLeX222+XAwcOuNx++fLl0qtXL3nsscdk69at8t///lfWrl0rjz/+uASyTjU7SXBQsMyOm+3rogAAAAC43kTn3//+t0laNFGpXbu2fPDBB1KhQgUZN26cy+1XrVolUVFR8tRTT5lWoJtvvln69u0r69atk0AWHBwsVYtWlS3xW3xdFAAAAADXk+gkJydLbGystG/f3mm9vl+5cqXLfVq0aCGHDh2SH374QSzLkqNHj8qsWbPkzjvvdHueixcvSmJiotPLH3Ws1lEuplyUdX8FdtIGAAAA5OpEJyEhQVJSUqR06dJO6/X9kSNH3CY6Okana9euEhoaKpGRkVKkSBEZM2aM2/P885//lMKFC9tf2mLkjwY1HWSWn6z9xNdFAQAAAHC9kxEEBQU5vdeWmrTrbLZt22a6rb322mumNWjBggWyb98+6dfvym/RuDJs2DA5ffq0/XXw4EHxR9WLV5eCeQvK//b+z9dFAQAAAOAgRDKhRIkSkidPnqtab+Lj469q5XFsnbnppptkyJAh5n2DBg2kYMGCZhKDt956y8zCllZYWJh5BYIbIm+QFQdXSPLlZAkNCfV1cQAAAABktkVHu57pdNILFy50Wq/vtYuaK+fPnzcD9x1psmRrCQp03et3F0ssmbp5qq+LAgAAAOBau649++yz8sUXX8iECRMkLi5OnnnmGTO1tK0rmnY70+mkbf7xj3/IN998Y2Zl27t3r6xYscJ0ZWvatKmULVtWAt3DDR82yymbpvi6KAAAAACupeua0kkF9Mc+R4wYIYcPH5Z69eqZGdUqVapkPtd1jr+p8/DDD8uZM2fk448/lueee85MRNCmTRv517/+JTlBgdACUia8jKz9a62viwIAAADgb0FWAPQf0+mldfY1nZggIiJC/M2Dsx+Ur7d8LX88/YdULFzR18UBAAAAcqyM5gbXNOsanPWLvtJtb+yasYQGAAAA8AMkOlmgVVQryRucV+btnJcVhwMAAABwnUh0skitErVk14ldkpqamlWHBAAAAHCNSHSySOdaneVy6mVZuNd56m0AAAAA2Y9EJ4v0j+lvluPXj8+qQwIAAAC4RiQ6WSQyPFKK5Csiy/5YllWHBAAAAHCNSHSyULNyzST+fLwkJiVm5WEBAAAAZBKJThbq3bC3WX6x4YusPCwAAACATCLRyUJd6naRIAmSmVtnZuVhAQAAAGQSiU4WCgkOkagiUbLp6KasPCwAAACATCLRyWIdqnaQC5cvyJajW7L60AAAAAAyiEQniw1sOtAsP17zcVYfGgAAAEAGkehksbql6kr+kPzy096fsvrQAAAAADKIRMcLGpRuIH+c+kMup172xuEBAAAApINExwseqPuAWGLJf7f+1xuHBwAAAJAOEh0v6BPdxywn/z7ZG4cHAAAAkA4SHS8IDw2XUgVLyeo/V3vj8AAAAADSQaLjJa0qtZJTSafkyNkj3joFAAAAADdIdLykT+Mr3dfGrhnrrVMAAAAAcINEx0vaVm4rIcEh8t2O77x1CgAAAABukOh4SXBwsFQvVl22J2z31ikAAAAAuEGi40X/qPEPuZR6SZbuX+rN0wAAAABIg0THiwY0HWCWn8Z+6s3TAAAAAEiDRMeLKhauKBFhEbJk/xJvngYAAABAGiQ6XhZTNkYOnz0s55PPe/tUAAAAAP5GouNlPRv0NMsJGyd4+1QAAAAA/kai42Xd63WXIAmS6Vume/tUAAAAAP5GouNloSGhUj6ivGw8stHbpwIAAADwNxKdbHBbldvk3KVzsiNhR3acDgAAAMj1SHSyQf+Y/mY5du3YXP/AAQAAANmBRCcbNCnbRMLyhMmPu3/MjtMBAAAAuR6JTjapV6qe7D25V1JTU3P9QwcAAAB4G4lONrm/zv2SaqXKnO1zsuuUAAAAQK5FopNN+jXpZ5YTN07MrlMCAAAAuRaJTjYpkq+IFM9fXH479Ft2nRIAAADItUh0stHNFW+WExdOSML5hOw8LQAAAJDrkOhko0dveNQsP133aXaeFgAAAMh1SHSy0V3V75I8QXnkm7hvsvO0AAAAQK5DopOdwQ4OlqrFqsrWY1uz87QAAABArkOik83urH6nJKcky+pDq7P71AAAAECuQaKTzQbEDDDLT9Z+kt2nBgAAAHINEp1spl3XCuYtKL/s/yW7Tw0AAADkGiQ6PhBdJlr+TPxTki8n++L0AAAAQI5HouMDD9Z/UCyx5D+b/uOL0wMAAAA5HomOD/Ru1Nssp26a6ovTAwAAADkeiY4P5AvJJ+UKlZN1h9f54vQAAABAjkei4yNtotrI2eSzsu/kPl8VAQAAAMixSHR8pG+Tvmb58dqPfVUEAAAAIMci0fGRmyreJKHBofLDzh98VQQAAAAgxyLR8aHaJWvLrhO7JDU11ZfFAAAAAHIcEh0fuqfWPZJipciCPQt8WQwAAAAgxyHR8aEnmzxpll+s/8KXxQAAAAByHBIdHyoVXkqK5isqyw8s92UxAAAAgByHRMfHmpdvLsfOH5NTSad8XRQAAAAgxyDR8bFHbnjELD+P/dzXRQEAAAByDBIdH7u31r0SHBQss7bN8nVRAAAAgByDRMfXNyA4WKKKRMnm+M2+LgoAAACQY5Do+IGO1TpK0uUk2Xh4o6+LAgAAAOQIJDp+YGDMQLMcu3asr4sCAAAA5AgkOn6gdsnaUiBvAVm4d6GviwIAAADkCCQ6fqJR6UZy4PQBuZx62ddFAQAAAAIeiY6f6Favm1hiybTN03xdFAAAACDgkej42e/pTNk0xddFAQAAAAIeiY6fCA8Nl8jwSFnz5xpfFwUAAAAIeCQ6fqR1pdZy+uJpOZR4yNdFAQAAAAIaiY4f6RPdxyw/WfuJr4sCAAAABDQSHT/SpnIbCQkOkbk75vq6KAAAAEBAI9HxM7WK15Idx3f4uhgAAABAQCPR8TN317rb/JbOL/t+8XVRAAAAgIBFouNnnmzypFl+Hvu5r4sCAAAABCwSHT9TPqK8FA4rLL/+8auviwIAAAAELBIdP9S0XFM5cvaInE0+6+uiAAAAAAGJRMcP9WrQyyy/XP+lr4sCAAAABCQSHT/UrX43CZIgmbF1hq+LAgAAAAQkEh0/pL+lU7FwRdl4ZKOviwIAAAAEJBIdP9W+anu5cPmCxB2L83VRAAAAgIBDouOn+jfpb5Yfr/3Y10UBAAAAAg6Jjp9qVKaR5AvJJwt2L/B1UQAAAICAQ6Ljx+qXqi/7T+2X1NRUXxcFAAAACCgkOn6sS50ukmqlyqy4Wb4uCgAAABBQSHT8WN/ovmY5aeMkXxcFAAAACCgkOn4sIl+ElCxQUlYdWuXrogAAAAABhUTHz7Ws2FJOJp2U+LPxvi4KAAAAEDBIdPzcY40fM8tx68b5uigAAABAwCDR8XMdq3aUPEF5ZM72Ob4uCgAAABAwSHT8XHBwsFQvVl3ijsX5uigAAABAwCDRCQB31bhLklOTZcWBFb4uCgAAABAQSHQCwMCmA82ScToAAABAxpDoBIBKRSpJodBCsnj/Yl8XBQAAAAgIJDoBoknZJvLXmb8k6XKSr4sCAAAA+D0SnQDxYP0HzXLyxsm+LgoAAADg90h0AkSvBr0kSIJk2uZpvi4KAAAA4PdIdAJEaEiolIsoJ7GHY31dFAAAAMDvkegEkLaV28q5S+dkz4k9vi4KAAAA4NdIdALIgJgBZvnxmo99XRQAAADAr5HoBJCYcjESlidM5u+a7+uiAAAAAH6NRCfA1C1ZV/ae3Cupqam+LgoAAADgt0h0Asw9te+RFCtFvt/1va+LAgAAAPgtEp0A069JP7OcsGGCr4sCAAAA+C0SnQBTokAJKZa/mCw/sNzXRQEAAAD8FolOAGpRvoUcv3BcTpw/4euiAAAAAH6JRCcAPXrDo2b5Wexnvi4KAAAA4JdIdAJQp5qdJDgoWGbHzfZ1UQAAAAC/RKITgIKDg6Vq0aqyJX6Lr4sCAAAA+CUSnQDVsVpHuZhyUdb9tc7XRQEAAAD8DolOgBrUdJBZfrL2E18XBQAAAPA7JDoBqnrx6lIwb0H5397/+booAAAAgN8h0QlgN0TeIIcSD0ny5WRfFwUAAADwKyQ6Aax7/e5iiSVTN0/1dVEAAAAAv0KiE8AebviwWU7ZNMXXRQEAAAD8ColOACsQWkDKhJeRdYeZeQ0AAABwRKIT4G6JukUSLybKgdMHfF0UAAAAwG+Q6AS4ftH9zHLsmrG+LgoAAADgN0h0AlyrqFaSNzivzNs5z9dFAQAAAPwGiU4OUKtELdl1Ypekpqb6uigAAACAXyDRyQE61+osl1Mvy8K9C31dFAAAAMAvkOjkAP1j+pvl+PXjfV0UAAAAwC+Q6OQAkeGRUiRfEVl2YJmviwIAAAD4BRKdHKJZuWYSfy5eziaf9XVRAAAAAJ8j0ckhejfsbZafx37u66IAAAAAPkeik0N0qdtFgiRIZm6d6euiAAAAAD5HopNDhASHSFSRKNl0dJOviwIAAAD4HIlODtKhage5cPmCbDm6xddFAQAAAHyKRCcHGdh0oFl+vOZjXxcFAAAA8CkSnRykbqm6kj8kv/y892dfFwUAAADwKRKdHKZB6Qay/9R+uZx62ddFAQAAAHyGRCeHeaDuA2KJJf/d+l9fFwUAAADwGRKdHKZPdB+znPz7ZF8XBQAAAPAZEp0cJjw0XEoVLCWr/1zt66IAAAAAgZXofPLJJ1K5cmXJly+fREdHy7Jlyzxuf/HiRXn55ZelUqVKEhYWJlWrVpUJEyZca5mRjlaVWsmppFNy5OwRYgUAAIBcKdOJzowZM+Tpp582icuGDRukZcuWcvvtt8uBAwfc7vPAAw/IokWL5Msvv5QdO3bI119/LbVq1bressONPo2vdF8bu2YsMQIAAECuFGRZlpWZHZo1ayaNGzeWcePG2dfVrl1bOnfuLP/85z+v2n7BggXSrVs32bt3rxQrVuyaCpmYmCiFCxeW06dPS0RExDUdIzdJTU2VsJFhUrtEbdn05CZfFwcAAADIMhnNDTLVopOcnCyxsbHSvn17p/X6fuXKlS73mTt3rjRp0kRGjRol5cqVkxo1asjzzz8vFy5c8NjVTS/A8YWMCw4OlurFqsv2hO2EDQAAALlSphKdhIQESUlJkdKlSzut1/dHjrgeD6ItOcuXL5ctW7bInDlz5IMPPpBZs2bJgAED3J5HW4Y0S7O9KlSokJliQkT+UeMfcin1kizdv5R4AAAAINe5pskIgoKCnN5r77e06xy7UelnU6dOlaZNm8odd9wh//73v2XSpEluW3WGDRtmmqJsr4MHD15LMXO1AU2vJJKfxn7q66IAAAAA2S4kMxuXKFFC8uTJc1XrTXx8/FWtPDZlypQxXda0ZcZxTI8mR4cOHZLq1atftY/OzKYvXLuKhStKRFiELNm/hDACAAAg18lUi05oaKiZTnrhwoVO6/V9ixYtXO5z0003yV9//SVnz561r9u5c6cZR1K+fPlrLTcyIKZsjBw+e1jOJ58nXgAAAMhVMt117dlnn5UvvvjC/A5OXFycPPPMM2Zq6X79+tm7nfXq1cu+/YMPPijFixeXRx55RLZt2yZLly6VIUOGyKOPPir58+fP2quBk54NeprlhI38ZhEAAAByl0wnOl27djUTCowYMUIaNWpkEpcffvjB/BioOnz4sNNv6oSHh5sWn1OnTpnZ13r06CH/+Mc/5KOPPsraK8FVutfrLkESJDO2zCA6AAAAyFUy/Ts6vsDv6Fy7iqMryokLJ+TsS//fdRAAAAAIVF75HR0Entuq3CbnLp2THQk7fF0UAAAAINuQ6ORw/WP6m+XYtWN9XRQAAAAg25Do5HBNyjaRsDxh8uPuH31dFAAAACDbkOjkAvVK1ZO9J/eaH28FAAAAcgMSnVzg/jr3S6qVKnO2z/F1UQAAAIBsQaKTC/RrcuU3jiZtnOTrogAAAADZgkQnFyiSr4gUz19cVh5a6euiAAAAANmCRCeXuLnizeb3dBLOJ/i6KAAAAIDXkejkEo/e8KhZfrruU18XBQAAAPA6Ep1c4q7qd0meoDzyTdw3vi4KAAAA4HUkOrlEcHCwVC1WVbYe2+rrogAAAABeR6KTi9xZ/U5JTkmW1YdW+7ooAAAAgFeR6OQiA2IGmOW4deN8XRQAAADAq0h0chHtulYwb0FZtG+Rr4sCAAAAeBWJTi4TXSZa/kz8U5IvJ/u6KAAAAIDXkOjkMg/Wf1AsseQ/m/7j66IAAAAAXkOik8v0btTbLKdumurrogAAAABeQ6KTy+QLySflCpWTdYfX+booAAAAgNeQ6ORCbaLayNnks7Lv5D5fFwUAAADwChKdXKhvk75m+cnaT3xdFAAAAMArSHRyoZsq3iShwaHy/c7vfV0UAAAAwCtIdHKp2iVry64TuyQ1NdXXRQEAAACyHIlOLnVPrXskxUqRBXsW+LooAAAAQJYj0cmlnmzypFl+sf4LXxcFAAAAyHIkOrlUqfBSUjRfUVl+YLmviwIAAABkORKdXKx5+eZy7PwxOZV0ytdFAQAAALIUiU4u9sgNj5jl+Njxvi4KAAAAkKVIdHKxe2vdK8FBwfLfbf/1dVEAAACALEWik4sFBwdLVJEo2Ry/2ddFAQAAALIUiU4u17FaR0m6nCQbD2/0dVEAAACALEOik8sNjBlolmPXjvV1UQAAAIAsQ6KTy9UuWVsK5C0gC/cu9HVRAAAAgCxDogNpVLqRHDh9QC6nXiYaAAAAyBFIdCDd6nUTSyyZvnk60QAAAECOQKID++/p/GfTf4gGAAAAcgQSHUh4aLhEhkfKmj/XEA0AAADkCCQ6MFpXai2nL56WQ4mHiAgAAAACHokOjD7Rfczyk7WfEBEAAAAEPBIdGG0qt5GQ4BCZu2MuEQEAAEDAI9GBXa3itWTH8R1EBAAAAAGPRAd2d9e62/yWzi/7fiEqAAAACGgkOrB7ssmTZvl57OdEBQAAAAGNRAd25SPKS+GwwvLrH78SFQAAAAQ0Eh04aVquqRw5e0TOJp8lMgAAAAhYJDpw0qtBL7P8cv2XRAYAAAABi0QHTrrV7yZBEiQzts4gMgAAAAhYJDpwor+lU7FwRdl4ZCORAQAAQMAi0cFV2ldtLxcuX5C4Y3FEBwAAAAGJRAdX6d+kv1l+vPZjogMAAICARKKDqzQq00jyheSTBbsXEB0AAAAEJBIduFS/VH3Zf2q/pKamEiEAAAAEHBIduNSlThdJtVJlVtwsIgQAAICAQ6IDl/pG9zXLSRsnESEAAAAEHBIduBSRL0JKFigpqw6tIkIAAAAIOCQ6cKtlxZZyMumkxJ+NJ0oAAAAIKCQ6cOuxxo+Z5bh144gSAAAAAgqJDtzqWLWj5AnKI3O2zyFKAAAACCgkOnD/cAQHS/Vi1SXuWBxRAgAAQEAh0YFHd9W4S5JTk2XFgRVECgAAAAGDRAceDWw60CwZpwMAAIBAQqIDjyoVqSSFQgvJ4v2LiRQAAAACBokO0tWkbBP568xfknQ5iWgBAAAgIJDoIF0P1n/QLCdvnEy0AAAAEBBIdJCuXg16SZAEybTN04gWAAAAAgKJDtIVGhIq5SLKSezhWKIFAACAgECigwxpW7mtnLt0Tvac2EPEAAAA4PdIdJAhA2IGmOXHaz4mYgAAAPB7JDrIkJhyMRKWJ0zm75pPxAAAAOD3SHSQYXVL1pW9J/dKamoqUQMAAIBfI9FBht1T+x5JsVLk+13fEzUAAAD4NRIdZFi/Jv3McsKGCUQNAAAAfo1EBxlWokAJKZa/mCw/sJyoAQAAwK+R6CBTWpRvIccvHJcT508QOQAAAPgtEh1kyqM3PGqWn8V+RuQAAADgt0h0kCmdanaS4KBgmR03m8gBAADAb5HoIHMPTHCwVC1aVbbEbyFyAAAA8FskOsi026vdLhdTLsq6v9YRPQAAAPglEh1k2sCmA83yk7WfED0AAAD4JRIdZFr14tWlYN6C8r+9/yN6AAAA8EskOrgmN0TeIIcSD0ny5WQiCAAAAL9DooNr0r1+d7HEkqmbpxJBAAAA+B0SHVyThxs+bJZTNk0hggAAAPA7JDq4JgVCC0iZ8DKy7jAzrwEAAMD/kOjgmt0adaskXkyUA6cPEEUAAAD4FRIdXLO+0X3NcuyasUQRAAAAfoVEB9esVVQryRucV+btnEcUAQAA4FdIdHBdapWoJbtO7JLU1FQiCQAAAL9BooPr0rlWZ7mcelkW7l1IJAEAAOA3SHRwXfrH9DfL8evHE0kAAAD4DRIdXJfI8Egpkq+ILDuwjEgCAADAb5Do4LrdWO5GiT8XL2eTzxJNAAAA+AUSHVy3Xg17meXnsZ8TTQAAAPgFEh1cty51u0iQBMnMrTOJJgAAAPwCiQ6uW0hwiEQViZJNRzcRTQAAAPgFEh1kiQ5VO8iFyxdky9EtRBQAAAA+R6KDLDGw6UCz/HjNx0QUAAAAPkeigyxRt1RdyR+SX37e+zMRBQAAgM+R6CDLNCzdUPaf2i+XUy8TVQAAAPgUiQ6ydPY1Syz579b/ElUAAAD4FIkOskyf6D5mOfn3yUQVAAAAPkWigywTHhoupQqWktV/riaqAAAA8CkSHWSpVpVayamkU3Lk7BEiCwAAAJ8h0UGW6tP4Sve1sWvGElkAAAD4DIkOslTbym0lJDhEvtvxHZEFAACAz5DoIGsfqOBgqVGshmxP2E5kAQAA4DMkOshyd9W4Sy6lXpKl+5cSXQAAAPgEiQ6y3ICmA8zy09hPiS4AAAB8gkQHWa5i4YoSERYhS/YvIboAAADwCRIdeEVM2Rg5fPawnE8+T4QBAACQ7Uh04BU9G/Q0ywkbJxBhAAAAZDsSHXhF93rdJUiCZMaWGUQYAAAA2Y5EB14RGhIqFQpXkA1HNhBhAAAAZDsSHXj1x0PPXTonOxJ2EGUAAABkKxIdeE3/mP5mOXbtWKIMAACAbEWiA69pUraJhOUJkx93/0iUAQAAkK1IdOBV9UrVk70n90pqaiqRBgAAQLYh0YFX3V/nfkm1UmXO9jlEGgAAANmGRAde1a9JP7OctHESkQYAAEC2IdGBVxXJV0RKFCghKw+tJNIAAADINiQ68LqbKtwkJy6ckITzCUQbAAAA2YJEB1736A2PmuWn6z4l2gAAAMgWJDrwuruq3yV5gvLIN3HfEG0AAABkCxIdeP8hCw6WqsWqytZjW4k2AAAAsgWJDrLFndXvlOSUZFl9aDURBwAAgNeR6CBbDGo6yCzHrRtHxAEAAOB1JDrIFpWLVpbw0HBZtG8REQcAAIDXkegg2zSObCx/Jv4pyZeTiToAAAC8ikQH2ebB+g+KJZb8Z9N/iDoAAAC8ikQH2aZ3o95mOXXTVKIOAAAA/0t0PvnkE6lcubLky5dPoqOjZdmyZRnab8WKFRISEiKNGjW6ltMiwOULySflCpWTdYfX+booAAAAyOEynejMmDFDnn76aXn55Zdlw4YN0rJlS7n99tvlwIEDHvc7ffq09OrVS9q2bXs95UWAaxPVRs4mn5V9J/f5uigAAADIwTKd6Pz73/+Wxx57TB5//HGpXbu2fPDBB1KhQgUZN87ztMF9+/aVBx98UJo3b3495UWAezLmSbP8ZO0nvi4KAAAAcrBMJTrJyckSGxsr7du3d1qv71euXOl2v4kTJ8qePXtk+PDhGTrPxYsXJTEx0emFnKF5heYSmidUvt/5va+LAgAAgBwsU4lOQkKCpKSkSOnSpZ3W6/sjR4643GfXrl3y4osvytSpU834nIz45z//KYULF7a/tMUIOUftErVl14ldkpqa6uuiAAAAIIe6pskIgoKCnN5blnXVOqVJkXZXe+ONN6RGjRoZPv6wYcPMmB7b6+DBg9dSTPipe2rdIylWiizYs8DXRQEAAEAOlalEp0SJEpInT56rWm/i4+OvauVRZ86ckXXr1snAgQNNa46+RowYIb///rv59y+//OLyPGFhYRIREeH0Qs7xZJMr43S+WP+Fr4sCAACAHCpTiU5oaKiZTnrhwoVO6/V9ixYtrtpeE5TNmzfLxo0b7a9+/fpJzZo1zb+bNWt2/VeAgFMqvJQUzVdUlh9Y7uuiAAAAIIfK2KAZB88++6z07NlTmjRpYmZQ+/zzz83U0prA2Lqd/fnnn/Kf//xHgoODpV69ek77lypVyvz+Ttr1yF2al28uP+z+QU4lnZIi+Yr4ujgAAADI7WN0unbtaqaU1i5o+sOfS5culR9++EEqVapkPj98+HC6v6kDPHLDIyYI42PHEwwAAABkuSBLZxLwczq9tM6+phMTMF4nZ9AZ1/K+lVeiy0TLmifW+Lo4AAAACBAZzQ2uadY14Hppt8aoIlGyOX4zwQQAAECWI9GBz3Ss1lGSLifJxsMbuQsAAADIUiQ68JmBMQPNcuzasdwFAAAAZCkSHfhM7ZK1pUDeArJwr/N05QAAAMD1ItGBTzUq3UgOnD4gl1MvcycAAACQZUh04FPd6nUTSyyZvnk6dwIAAABZhkQHPvXYDY+Z5X82/Yc7AQAAgCxDogOfKhBaQCLDI2XNn/yWDgAAALIOiQ58rnWl1nL64mk5lHjI10UBAABADkGiA5/rE93HLD9Z+4mviwIAAIAcgkQHPtemchsJCQ6RuTvm+rooAAAAyCFIdOAXahWvJTuO7/B1MQAAAJBDkOjAL9xd627zWzq/7PvF10UBAABADkCiA78woMkAs/w89nNfFwUAAAA5AIkO/ELZiLJSOKyw/PrHr74uCgAAAHIAEh34jablmsqRs0fkbPJZXxcFAAAAAY5EB36jV4NeZvnl+i99XRQAAAAEOBId+I1u9btJkATJjK0zfF0UAAAABDgSHfgN/S2dioUrysYjG31dFAAAAAQ4Eh34lfZV28uFyxck7licr4sCAACAAEaiA7/Sv0l/s/x47ce+LgoAAAACGIkO/EqjMo0kX0g+WbB7ga+LAgAAgABGogO/U79Ufdl/ar+kpqb6uigAAAAIUCQ68Dtd6nSRVCtVZsXN8nVRAAAAEKBIdOB3+kb3NctJGyf5uigAAAAIUCQ68DsR+SKkZIGSsurQKl8XBQAAAAGKRAd+qWXFlnIy6aTEn433dVEAAAAQgEh04Jceb/y4WY5bN87XRQEAAEAAItGBX+pQtYPkCcojc7bP8XVRAAAAEIBIdOCXgoODpXqx6hJ3LM7XRQEAAEAAItGB37qrxl2SnJosKw6s8HVRAAAAEGBIdOC3BjYdaJaM0wEAAEBmkejAb1UqUkkKhRaSxfsX+7ooAAAACDAkOvBrTco2kb/O/CVJl5N8XRQAAAAEEBId+LUe9XuY5eSNk31dFAAAAAQQEh34tZ4NekqQBMm0zdN8XRQAAAAEEBId+LXQkFApF1FOYg/H+rooAAAACCAkOvB7bSu3lXOXzsmeE3t8XRQAAAAECBId+L0BMQPM8uM1H/u6KAAAAAgQJDrwezHlYiQsT5jM3zXf10UBAABAgCDRQUCoW7Ku7D25V1JTU31dFAAAAAQAEh0EhHtr3yspVop8v+t7XxcFAAAAAYBEBwGhb5O+ZjlhwwRfFwUAAAABgEQHAaFEgRJSLH8xWX5gua+LAgAAgABAooOA0aJ8Czl+4bicOH/C10UBAACAnyPRQcB49IZHzfKz2M98XRQAAAD4ORIdBIxONTtJcFCwzI6b7euiAAAAwM+R6CBgBAcHS9WiVWVL/BZfFwUAAAB+jkQHAeX2arfLxZSLsu6vdb4uCgAAAPwYiQ4CysCmA83yk7Wf+LooAAAA8GMkOggo1YtXl4J5C8r/9v7P10UBAACAHyPRQcC5IfIGOZR4SJIvJ/u6KAAAAPBTJDoION3rdxdLLJm6eaqviwIAAAA/RaKDgPNww4fNcsqmKb4uCgAAAPwUiQ4CToHQAlImvIysO8zMawAAAHCNRAcB6daoWyXxYqIcOH3A10UBAACAHyLRQUDqG93XLMeuGevrogAAAMAPkeggILWKaiV5g/PKvJ3zfF0UAAAA+KEQCSBnNp6RoPAg8++8pfJKvvL5fF0k+FCtErUkLiFOUlNTJTiYnB3IiS6mpkpoUJAEBV352w8AyJ0OHDggCQkJ5t9nz57N0D4BVTvc2HqjxEbHXnnFxErqxVRfFwk+1LlWZ7mcelkW7l2YY+/Dvn2vy/79b7r8TNfr50BOdTApSSr99ps0W79efjpxQqz//U+kTh0RXQK51OHDIq+/fmUJ5KYkp2bNmhIdHW1erVu3znmJjl2wSL4K+SQolG/4crP+Mf3Ncvz68ZJTBQXlkf37X7sq2dH3ul4/B3KqY5cuydFLlyT2zBnpuGmTNDt8WH4KDxfrpZdELMvXxQN8QhOcN94g0UHukpCQIElJSTm765pdqkjlNyvTlSGXiwyPlCL5isiyA8skp4qKetUsNamxvbclOVFRI+yfAzmZre1+fdmy0nHUKInZvl3eXLhQ2rdrx/8PAAByUKKTR6RQ40JStH1RX5cEfuDGcjfKgj0L5GzyWQkPDZecSJOZlJRzJrn54483xbIukeQgV0rJc6UFc3316tIxTx6JWb9e3q5cWW4rVszXRQO83oqjr9RUkZkzr6xbv/7/Py9T5soLQKB3XUsRKdOvDN/iwejVsJdZfh77eY6LSErKeTl6dLps2nSnHDz4nlmnSY5IkOTNW1wuXTru6yICPk141p45I4N27uQuIMd76y2R6GiRmBiRd9+9su6JJ66s09dnn/m6hIB/CrxEJ1hk52M7JfbGWDn08SFJPpbs6xLBh7rU7SJBEiQzt/79FVeAs6wUOXlykcTFPSwrV5aWuLjucvnySSlW7HbzeVCQNsJasmvXQFm5MlI2b+4k8fGzJCUl8/1WAX91LiVFph09KgN37XL5eZB+rf23gydPSp8vvpBlS5dKakpKNpYS8K4jR0RGjxZp3Fjkk09EChUSue8+kaFDr3weEiJSrZrIrFkifa/8tByAQE906s2pJ3Vm1JHQUqGy55k98lvZ32TzPzZL/Mx4SbnA/8nlNiHBIRJVJEo2Hd0kgezs2c2yZ88L8ttvleT332+TxMQVUqHCEGnWbLdJck6c+N50V2vd+kq3NU12ihZtL8nJR2Tbti4m6dmx4wk5depXsSxmI0TgSbEsWXjihPSOi5PIlSulR1ycnD9/3mmbPH8nMk127pQFL7wg23r1kqfj4uTnIkWkVWqqVP3mG3ll4kTZvmWLj64CuD7nzolMmSLSsaNIuXIiL74oUrmyyJw5IseOXUlqHnjgyra6Xd68Ij17isybx/wcyLlSU1Nl6tSp17RvkGX5/9Q1iYmJUrhwYVnSeIm0WtfK3m1NW3OOzTwmR746ImdWn5E8EXmk5P0lpfRDpaVI6yISFMysbLnBk98/KZ/Gfiqb+22WeqXrSaC4ePFPOXr0azl69Cs5d26ThIQUl1KluklkZE8pVKipec7dTTzguL5UqQfk6NGpcvToFElK2idhYRWldOkeUrr0Q1KwYB2fXiPgif7fz6Zz5+SrI0dkWny8HE5Olur580vP0qWlx2+/yal//UuiP/hAglNTJTU4+MokBBMmSPu1a8X8ddffz4qOltSVK2XFypUyZedOmRkZKafCw6XJwYPyUHCwdLvlFimtNUbAT12+LPLLLyJffXUlodFkp2VLkYceEunSRaRomiHJOjZHu6vFxorUqiXy7LNXuq7de6/I+PEiDFlDTnL06FF5+OGHZcGCBS4/P336tEREROSMRGfft/skqlOUy23O7zovR6ccNa+kvUkSVj5MSvUoJZE9I6Vg3YLZXmZkn63xW6XeuHrSt3Ff+fQfn/p16C9fPiMJCd+YpES7qAUFhUqJEp1MUlKsWAcJDg512l5/J0enkHY1u5omO9rVrXLlK7+lo/9TTkxcKUeOfCXHjs00Xd7CwxubY5cq1V3CwiKz7ToBTw4lJZnE5qujR2XLuXNSIm9e6V6qlDxUurTEWJYEDRxovq4+9PjjEnPHHVLh6FHnBMdRZKT+j0H+r73zAG+y/Nr43YzulTZJ2UtQ9gYFRJaADNmzDAVxb/27RcWB63PvwYaypwgIMmXvPWWvNknTtE2zx3ed5y2Isgo0zTo/r161JW3evsmbPPdzzrlvREWJL20WCxYtXy5+9+8VKwqB1OHECQxJSUH3e+9FLPX/MIyfoZXXzp1SVSYjQ2pTu+MOqTqTni5Vca4GmRKQsKF2tQsGBHPmACNGAHFx0u8sYsQIwwQ0f/zxB4YOlWaxP/30Uzz66KOXWUyHlNC53h9zcbG3MQ9Zk7Kgm66Dy+hCfP14pA1Jg3agFlGlpTdDJrSI/SBW2E0fe/YYAg2Px4WcnKVC3BgM8+DxWJGc3BppaUOg0fSGQpHkg/u0Izt7kbjP7OyF8HpdSEnpIESPWt0DcjmLf6ZkyXO5MFuvx+SsLKw0mRAlk6F7aiqGlCqFDioVlFSd2bwZGDhQ6tGhoYTBg2E/dQqRev3VDWi0WqBcuSv+k1Gnw4wVKzDZbse6ihURb7Gg97lzGFy5Mtq0agU5DTkwTAly+jRAHTgkRvbtAzQa6SlPAoeqNFd7mhf1d9Pv+esv4I03gLfekuZ4GCbYsNvteP311/H555/jvvvuw/jx45GWliZCQylPhzCbzSI0NOyEzqV4HB4YFxtFa1v2b9nwurxQtVMJ0aPuqYYinl8BQoVmvzbDprOb4BjpEHM7/oYuq/z8baItTaebBqdTh9jYmkLcpKWlIzq6Qokdi9NphF4/SxxLbu5ayGRx0Gh6iWNRqdpy6Cjju+eex4OlOTmiNW1+djbsHg/aJCeLyk1vjQaJF1ZhZC7wySfAyJHS5DVtcd92W7Eey7HDhzFl/XpMionBkbQ0lDEakZ6TgyENGqAu3SfD+IjcXGD2bKk1bfVqIDoa6NFDak1r316asykuaIztww+Bd94BmjaVLqVKV26EYZiA5NChQxg4cCD27t2Ljz/+GM8++yxktBF2k9ogpIXOpThNTuhn6UWlJ3dNLmSxMiF2qLUtuV0yZIqg82VgLuHzDZ/jxaUvIqNXBgbWGei3c2O1noBOJ83LWCwHoVSmCWFDoiI+vr7fbdGt1uOF8zyTYLUeRmRkaWi1dHyDER9fz+/HxwQ/9JZCts9UuZmm00HvdKJ2XJyYu6H2tPK0yruUc+ekbeiVK6XJa4p8L86V33+Pz+PBlk2bMGnfPkzTamFITESds2cxxOPBwJYtUY5XhUwx4HQCNFJAlZsFC2iHGmjXThI3PXsCN7mUKTIbNkgtcEaj1OY2YIBv749hiuO9Y+zYsXjmmWdQvnx5TJ06FQ0aNLjq7VnoXAPbSRuypmQJ0WM5aIEyTYm0gWmi0hPfIJ4Xe0EIBYYmfJiAjrd1xJLBVx5Y8xVOZw70+plC3OTm/gWZLPZixSQ5uS1kAVBhunLFaas4Zp1uKpxOPWJjawkjBK12EKKjr9wKxDBX47jVKsQNfRy2WlE6MhLpWq1oTasbF3fl11Wyiho2DIiMlFaEbduW6Al22u34g1rbzp7F/PLlYVcq0fbkSQxOSEDvdu2Q8N8pcIa5BrRtTN2XVLmZNg3Izgbq1pXEDYmOkvbEoErSY49Jx/Lgg8A33wDxoZmrzQQ5JpNJzN/MmDEDDz30EL766ivE0cDZNWChU8TFnnm7WTIxyMiCU+dEbM1Y4dqWlp6G6Ir/2XlkApq0/0uDw+1Azis5Pr8vaQZmsaiMXJiBUanaX5yBUSiC593E43EiJ2eZ+FukGSL7f2aIfLz1yAQtRqcTM/V60Zq2Li8PcTKZaEmj1rS2KhXkV6sQWq3ASy8B330HdOsGjBkDqNXwJ7lGI+aQiYHZjFUVKyLa4UD3M2cwpFw5tG/TBspCswOG+S9Hj/4zd0PRT2XKAIMGSQKHhI6/xdeECQD5e9BxkejhTk0mkFi3bh0GDRokxM7PP/+Mfhf8068DC50bxOPyIOfPHFHlMcw1wGP1IKlVkmhtU/dWQ5nsu1YKpnjoO7MvZu2fhfMvnhfGBMXNBVczqQoyvdDVrIEQBGQLHRVVaH8TxLhcedDrJVc4k2kFZLIopKZ2E3+j5ArH10G4Q3M2v2dni8oNfXZ5veiQkiJa07qr1YiTy6/9C2gCm/poaEX4+efA44/f2gS2Dzh9/Dgy/voLkxQK7CtTBprcXAzQ6zGkdm00btoUEVfoF2fCC6rWzJghVW+oTYwqJX36SOKmdWvgepdBSXP4sFRV2r1bmuF5/nnJnZ1h/IXL5cLo0aMxatQo3HXXXcjIyEDFihWL/PMsdG7l5Oe7hNihSk/O8hxEKCOg7qYWlZ6U+1Igi+RXh0Bk2dFl6DC5A95s+Sbea/tesf1ei+WwWPjTbIvNdgxRUeUvyamphVDFZjsj2tqknJ89UCrVQtDR330h54cJDzxeL9bn5grL5hl6PUwuFxrFx4vKzQCtFqWKUu2greUff5RCP8hoYOpUoE4dBDI0z7Nr+3ZM3rULGSkpOK9S4Y7MTAy22zGoWTNUvv12fx8iU4KQq+3ChVLlZtEiyUOjY0dpxIwKk7Gxgf1wOBySG9v//R/QoYNU6SF3doYpacg9jao469evx8iRI/Hmm29CcYMWgSx0ign7OTt0U3XCua1gVwEUqQpo+2uF6Em8K5EXewGWnBv1QRRqqGtg9+O7b+l3ORx6UbWhRX5+/mbI5YnQaPqKRX5yMoXWhpfYNZt3i3ORlZUBh+McYmKqiXNBHzExVfx9eIyPOGSxXJy7OWGzoUJUlBA39FHjOv3Tl21/U8jHvHnAE09IK62YmKB63NwuF1asWoVJJ05gTtmyKIiJwd0nTmBwdDT6tWsHFfkEMyEHiZm1a6XKzcyZ0txLkyZS5YYKk+RuHmwsXQpQNAn9bePHA507+/uImHBi1qxZePjhh5GQkIApU6agJaXj3gQsdHyAeU/hPM+ULDjOOhB9W7Q0zzM4DbFVA3wrJ0yo9V0tHDEeETbTN4rbbUV29gJRvTEaJUODlJROom0rNbUr5PLgWpj5AgoozclZWZgJNBtutxmJic0L2/f6QalM8fchMreIzuEQbmlUvdman48kuRx9yVQgLQ13JyVBdqOVPHJToy1vmssZOxbo3j3oH6OCvDzM+/NPTDaZsLRiRSjcbnQ5dUoYL3Ru1w5RQSbimMs5cECq3NDszcmTkkUziRuavalePfjPmE4n+YBQZerZZ4GPP76YucswPqGgoADPP/88fvnlF/Tp00fM46huwfCFhY4P8bq9MK02CdFDltXufLeo7pBrm6afBpHqf6fbMyXHK8tewSfrP8HqB1bjnkr3XPf2Xq8HJtNqUa2grBm3Ox+JiXeJSoVG0x+Rkf4dkA5k3G4LDIb54twZjUtFlSs1tYs4dyQMab6HCQ4sbjcWGAxC3PxhNAox05nmbkqVQpeUFETfzMAB+etSmAcNBNDQAm2Jl7TtVAmQeeYMpq1ejUleL7aXKwdVfj76ZWVh8B13oEWLFjzPE0RkZUkdlSRwtm0DkpMBmosmnd68eejNtFA36ddfAy+/DNSoIf3t9JlhipudO3eKbBxqWSNHNXJWu9X2dxY6JYTb4hZhpNTaZlxiFA9cSucUUeVJvT8V8ugAm0gMcU7lnkLFLytiYO2ByOidcdXbmc17C00FpsBuP4Po6NsKW7EGITa2WokecyjgcGSJYFQ6p2RbrVAkF7b6DUFSUouwa/ULBtxeL1aZTMIxbbbBALPbjWaJiaJy00+rReqtZNkcOyZNPm/dCrz3nrSSCrTpbB+wf/duTN66FVMSE3FKrUZlvR6DzGYMadoUt9cK3Xm+YKagAJg/X9Lhy5ZJYqZrV6l606VLeFQ5du4EBg6UKldffSV1mfIIJlNcJk4kbF555RXUrFlTZONUL6aSKAsdP+DQOaCbrhOVnvzN+ZAnyaHpoxHObUktkxAh4+HtkiDpoyTEKeNw7sVz//q+3X4eOl2GWIybzTuhUKRAq+0vFuNUxeHh+uKhoOBgoXnDZNjtJxEdXUlk80jmDSHQ8xHk7DGbReUmIysLZx0OVI2JEeJmUFoabiuOliuKYqfwDrKLpi3iO+9EuOFxu/HXX39h8t9/Y2bp0siNi0PTU6cwWKFA/9atoSWfX8ZvuN3AihVS5WbOHNr4Alq0kCo3fftSy3J4Cj7yCfn5Z8k9jj5zjBRzK+h0OgwbNgyLFi3Cc889h48++ghRxbhzwELHz1gOWaRQ0slZsB23IapCFNIGSfM8cTVvYIiXuWHunXgvlh9fjoLXChAp88BgmCvaq3JyliMiQgm1+n6x6Kb5G5mM2wx9BbUF5uauE4JHr58Bl8uEhITG4tyTe1tkZJrP7pv5N2ftdiFsyFRgd0EBUhUK4ZZGrWlNExKKR+Tn50thHRMnSoMM33/v+/j3IMBmsWDhn39ikl6PRRUrwhsRgfvIxCA1Fd3atUNsQoK/DzEsoDYtslamyg1p8fPnATLNuzB3U4U9VQSzZ0sVHXpa0nzSTc6JM2HO0qVLMXToUGESNX78eHT2geMFC50AQWSvrM8TrW36GXq4clyIbxgvBI92oBZRpcKgLl7CjN8xBsMWjMDXzRqjXvR+eDwWJCXdUxiA2QdKZbK/DzHscLttMBoXFQas/i5EUEpKB/GYqNXdIZezmUdxk+9yYQ7N3WRmYoXJhMiICJFzQ45pHVNSEFmcAwdbtkitapmZksChrXHmMgyZmZixciUmOxzYULEiEiwW9D53DkOqVEGre+6B/AbtVZnrc+aMJGxI4OzdKxUaqU2LBA65p3GL1uWcOiWdn3XrgDffBEaOBPipyRQFh8OB119/HZ999hk6dOiACRMmoJSPPMxZ6AQgHrsH2YuyRZUne2E2vC4vVO1VUihpDzXkcaHfw+5LQWk2bxfVg3OZGbh/tQ6dysTg47Zvirmb6Oiih1AxvsXpNEKnmyEeq7y8dZDL46FW9xaVHpWqDSIi+Dq4WVweD5bm5IjKzTyDAVaPB62Tk0VrWm+NBknFvVohf1qyiqZwjgYNpBVl1arFex8hytFDhzB5wwZMio3FUa0WZY1GDDKZMLhBA9Shc8ncNHl5UmWCWtPI9I+6Zcjsj/Q35cfcyvhZOLX3jR4NjBoF3HWXVN25gSxHJgw5fPiwMBzYs2cPPvzwQ+GwJvOhgwcLnQDHaXQKx7asSVnIXZsLWZwMml4aUelRtVMhQs7zPEXBZjspgjxp0WyxHIBSmYa0tIHo/Ps0nCvIg/n1Ap8/lszNY7UeK3z8JsFqPYLIyDJIS0sXlZ74+Lp8aoso8rfl54u5G7KF1jmdqBkbK8RNeloaKkRH++Y8Uu8PhXEsXy6ZDbz7LhDJraA3E0q6aeNGTN6/H9O0WmQnJqLe2bMY7PEgvVUrlKlQwScPX6hBJn+UD0OVGzIXsNuBNm2kykTv3txFebOsXy8Va00maW6HXOgY5r/vQdSe9vTTT6NMmTLCcKBRo0bwNSx0ggjrcas0zzMpC9bDVkSWjhRtbWRXHV8vnofk/4PTaRJW0CRucnNXQyaLgVrdUyyOVap7IZMpMHz+cIzbOQ4HnzyIO9R3+OeBZW7ohTI/f4sQPOTe5nQaEBdXpzCfZyCio8vx2fwPJ6xWTNHpRPXmoMWCUpGRSNdqRWta/Xgfv25QPDyFcNDWOK0s27Xjx6cYcNhsWLJiBSafO4cFFSrAoVCg3YkTGJKUhJ7t2iGB/I6Zf83dUNckVW6mTQP0eqB2balyQ+1p5cvzySoOSOSQv8j06cDw4ZIl9Y3kBTOhi8lkwmOPPYbp06cL44Gvv/4a8fHxJXLfLHSCdbG3NV+0tumm6uDUOxFbK1a0tmnTtYgu76Od2SDA43HAaFxcGFT5G7xeJ1SqdqLdiUSOQvHvgd6t57aiyS9N8HTTp/F1p6/9dtzMjePxOGE0/iEe6+zs+fB47EhObluYbdT7ssc6nMhxOjFTrxfi5q/cXMTKZOil0YjqTdvkZCh8HfRhs0nVm2++kTx4KQBUo/HtfYYppuxszF6+HJMLCrCqcmXE2GzoeeYMBpcvj/Zt20IRxv1Xx49L4oY+Dh8GSpeWDAWoelO3Ls/d+EpUjhsHPP00UK6cZKjYsKFP7ooJEtavX4/09HTk5OSI8M/+/fuX6P2z0AlyPE4PcpbliCqPYZ5BzPckt04WrW2a3hookkJ/aFUYOeRtLMy7mQ6XKxtxcfVQqpS0yx8VdW2L1uj3o1E+qTyOPH2kxI6ZKV5crlzo9XNEpcdkWgWZLFqYF0jVu/aQyUJ/sWf3eLA4O1u0pi3MzobL60V7lUpUbnqo1YgvqSnh/fulbfJDh6S5nCef5BVlCXHq2DFkrF2LSUol9pcuDa3JhIHZ2RhSpw4aNm4cFqGkRiMwc6ZUQKQheaooUEsaVW+oRS0MYpoCArr8qZVtzx7go4+A554LvSBV5tq43W6MHj0ao0aNQtOmTZGRkYFKlSqhpGGhE0K48lzQz9GLSo9phQmyKBlSu6WK1raUjimQKUPrVcZi+ftiDovNdhSRkWWFoQDt6MfH1yny72n8c2PsyNwB55tOnw7EMSWDzXZa5CBlZk6CxbIPSqVG2FST6CHb6lDKQSKRvz4vT1Ruput0yHG50CA+XlRuyBa6dEmmGNJWLjXnP/88ULmytJVL2+aMX+Z5dm7fjkm7diEjNRVZycmofv48hjgcSG/eHJWqhVbYMc3Z/P67VLmhzzQgT2YCVLkhcwFun/Lf40L+I599Btx3HzB+PJDGaQFhwenTpzF48GCsXbsWb7zxBt566y0o/GTJx0InRLGdsYm2Nqr0FOwpgFKthHaAVlR6EpoWUx6GH3A4DNDrpxc6cW2EXJ4grKBpEZucfM9NOXF9tPYjvLb8NczpNwc9a/T0yXEz/nLY21VY6cuAw3EeMTF3CCFMgjgmpnLQPiyHLRYhbujjuM2G8lFRIsiTqje1/LGqo210CtWYO1dq0qeVTSxbgQcCLqcTy8mq+tQpzClXDpboaLSkeZ6YGPRt1w7J5KMchJCRHw3AU+VmxgxpPoTmmkncUEGRF9SBwx9/AA88IO2FTJggiR4mdJkzZw5GjBiBuLg4TJkyBffcc49fj4eFThhg3m0WgicrIwuOcw7EVIsRgoc+YqoUQ8K5j3G7rcjOXijakmj+hkhJuU8sWFNTu0Euv7W/wWQzQfWxCl2rdcVv6b8V01EzgYTX60ZOzgrxHKIWN4+nAElJdxfO8/SDUqlCoKN3OETVhlrTNufnI1EuR1+NRoibe5KTIfPX5sXq1dLq0mIBfv0V6MmbBYGKOTcX85YvxySTCX9WrAiF2437T50SgbCd7r0Xkb5y3ivmlqgLczcnTgBkNkdPP/qoUcPfR8dcjawsyZdk8WKp6Pvhh5KdNxM6WCwWYRVNczi9evXCL7/8gpSUFH8fFgudcMLr9iJnZY5obTPMNsBtdiOxeaJobdP21UKZGjhzDBQUaTKtEbvxev1MuN15SEhoWuiu1R+RkcU72Kz5VAOP14Psl7OL9fcygYfbXQCDYZ54bhmNSxERoUBqahfx3EpN7QyZLHDefa1uNxZkZ4vKzRKqmgDolJIiWtO6pqYixp8DB+TTS1bRH3wA0I4drTxp+pgJCs6fPo2pq1djMoAd5cohJT8f/bOyMLh6dTRr3jyg5nl0Osktjao3W7cCSUlA377S3M3dd/PsRzBV4ciJ7ZVXgFq1pO7WO9jsNCTYtWuXyMY5ceIEvvzySzz88MMB0znEFZ0wxW1xwzDfIESP8Q8jImQRSO2SKqo8qV1TxXyPPygo2C923SkzxW4/jejoyoWtRoMRG3u7z+63x7QemH9oPvQv6aGODc5WDubGsdszhU01PecoSFahUIkKDz3fkpJa+OWF2uP1YrXJJCo3s/R65LvduCsxUVRu+ms0UAdCBg3ZWdGkMXn2UlLgq6/ylHcQs2/XLkzetg1TkpJwOjUVVXQ6DC4owOC77kI1P5VJqEC4YIEkbqj1iXRX586SuOnSBQiC4hNzFXbskNoLT5+WhA9ZUQfImpi5iRbxb775Bi+99BKqV68usnFq1qyJQIKFDgNHlgO66dI8D9lWK5IV0PTViEpPUoskIYJ8v9icWrjY3CEWm1S1ocVmYmLzEllsLji0AN2ndcd7bd7Dm/e86fP7YwIPSWRPLhTZpwpFNplbDPGpyL7AXrNZVG4o8+aM3Y7boqOFuKHZm2qBNO9C27A0h0MtCRkZQLNm/j4ippjwuN1Y89dfmPT335hVujTy4uJwJ7W2KRTo36YN1OTP7EPIRGDVKknczJ4NmM1A8+ZSWxoFUKam+vTumRKkoEByYqNuV6rOkY8Jxz8FF3q9XmTi/P7773jmmWfw8ccfIzoAdyBY6DD/ouBggajy0If9pB1RFaOQNihNiJ646nHF2j6k188VC8ucnGWF7UNdC9uHOpV4+5DH40Hk+5Gom1YX2x/dXqL3zQQW1DaZm/tXoYkBtU3mFrZNDi5sm9QW232dt9uRQXM3mZnYVVCAFFpQarWiNY2qOIFS+hfQqpPCMcg6ibZjf/hB6iFiQhJrQQF++/NPTDYYsLhiRfG9TidPYrBajfvvvRcxxWh6sXu31PlIuvnsWaBqValyQ5k3t91WbHfDBCBkBf7II0BiovT4t2jh7yNiisKyZcswdOhQuFwujB8/Hl2ozBqgsNBhrojX40XuulwhePQz9HCZXIhvFC+Fkg7QIjIt8iYHwpcXDoTPLRwIb1k4EN7X7wPhd3x7B06YTsD+pt2vx8EEDm637RIjjEWiTH/BCEOtJiOMG6+0mF0uzDEYRPVmeU4OlBERuF+tFuLmvpQURAbQbMRFaDCCWtXOnQO++w4YOpR7TcII/fnzmLFqFSY5ndhUoQISCwrQ5/x5DL7tNrS65x7IbmJWjAQNLWxJ4JDQoWrNgAGSwGnalJ9e4cSpU5KoJRe9t96SLKn95ETMXAeHw4E333wTn376Kdq3b48JEyagtI8rvbcKCx3murhtbhgXGUVrW/bv2UIEpXRIEfM86h5qyGPl17H43XmJxW+msPiVwjzTA8ri94U/XsAXG7/Axoc24s5yd/r7cJiAtDafUWhtvqHQ2rx3obV5q2tam7s8HvyZkyPmbuYZDLB4PLgnKUmImz4aDZIDNb2epofJKppWHpSJQ21rIZbBwtwYRw4cwOSNGzE5Lg7HtFqUy87GoNxcDGnUCLXq1bvmz+bnk/Ws1Jq2YgVA42aUc0OtaWQ5HKiXAeN7XC7J14T8TahdccoUyVGPCRyOHDmC9PR0YTxAQaAvvPBCUGQPstBhbgin0QndDJ2o9OSty4M8Xg51L7VobVO1USFCHnExtJFmHWhR+E9o48DC0MZGgdWSU8jxnOOo8nUVPFDvAYzvMd7fh8MEMFbrUfHcplDSq4XVksjfXjh3MzUrC1lOJ2rExgpxk56WhooB2Mv8L86fl8Ivli0DXnoJeP99aWXKMIWhpBvWr8fkgwcxPS0NxoQE1D9zBkMADGzVCqXLl7+4gF26VKrczJtH1w7QurVUuendm7sfmX+zdq1U3cnLA375BejTh8+Qv/F6vZg4cSKefPJJUb0hw4HGjRsjWGChw9w01mNWZE3JEpUe6xErIssoEddND1frachPmwGZLBpqdQ+x+FOp2kMmC/ztuoQPE5AcnYzTz5/296EwQfIGkJe3qbBiOQ0uVzbyYlpjbfRD+M1WBQetDqQplRiYliYEToP4+IAU+ZdB8fIUekEtSRMnAu3b+/uImADGYbNhMeXznD+P3ypUgEsuR9OjeiQcuh07ZtSB4YwSZMRE4oY6IHmnnrkWOTnAo49K8zuUQ/zll4A/cpAZIDc3F48//rgQNw888IBwWEtISAiqU8NCh7klPB4nsrOX4OzypTDNUAIr7gFykxFVw4HSQyuh1OAKiC4X4DvXl9BqXCv8deov2N6wIVLBu9dM0TA5nZihy8SEs4ew3qJANGy4G3+hZ7wB3cq2QClNTygUQfDmYLNJIRfk+UrDpePGAZrizaxiQhcK8Px1fD7GHNEhs2keUC8XCqsH7Y9l4Zlqqbi3TRsouD+NKQJeLzB2LPDMMwAVB6lrtkEDPnUlycaNG0U2jtFoxI8//ij+PxgpqtAJ/CY8psR3sQ8ffgrr15fGvn3d4LxtDap8WRp3nmmM2r/VRmLdsjg1KhMbK2zEznt34vz483DluQL+UUqvkw4vvJi4e6K/D4UJcBweD+YbDOi7bx9KrV+Px48cRVyUBhOrV8fZO5tg4h1V0FxxGH8fegDr16dh//5ByM5eDI8nQK+DAweAu+4CfvwR+Oor4LffWOQwRdp9J2tgyoytXBn44tME3Cu7DX/UaIAjpcthlO40jqcAnSIjUX7hQrzw66/YvmWLaH1jmKtBhe+HHgK2bQNiYqSXJqrskABifIvb7cYHH3yAu+++G6VKlcLOnTuDVuTcCBFeWt2GiGpjbmUuQZq7sVqPIDKyzCVzCXUvu70r1wX9HL1obTOtMkEWLYO6u1qYGKg6qCBTBp5+trlsiPkgBq0rtsbKB1f6+3CYAINeBjfm5QlTgek6HYwuF+rHx4u8m4FaLcpEXW6LbrOdQlZWhnBus1j2Q6nUink1MuSIj2/o/1Y2emmnMItnnwUqVZK2Tq8zVM6EN3Y7sHixZCqwcKE0h0PdjWQq0KMHEB//79uTqNm+dSsm79mDjNRU6JKTUZNc2xwODLr7blRgD2nmOs+3114DvvgC6NRJcrjXFp/LP3MJZ2jObsgQrF69Gq+//jrefvttKIO8Csuta8w1cTqzodNdcJpaD7k8Hmp1b7FIS05ufU2nqUuxnbZBl6FD5qRMWPZZoNQohU01mRgkNE7w/2LvEsp9Xg659lzkv5bv70NhAoQjFgumZGUJY4GjNhvKRUVhkFYrBE7t/67qrutAOEkIH6czC7Gx1YVBh+RAWAkljtEohVhQOiN9ppVEIIWTMgED6WGy/yVTgenTpUoOtRLR3A3ZQhfVYdbldOLPlSsx6dQpzC1XDtboaLQ6cQJDYmPRu21bJKvVvv5TmCBlyRLJH4WWCxMmAB07+vuIQot58+bhoYceQmxsLCZPnoxWrVohFGChw1wxO8Ro/F04SknZIR6kpHQszA7pflPZIf9a7O0yC9c2Ej6O8w7E3BEjqjwUTBpTOcbvj8jQOUMxac8knHj2BComS0F5TPhhcDgwXa8X4oaqOAlyubCCJlOBVsnJkN2COKf2NZOJMqUmQ6+fA4/HUpgpNaQwUyoZPmfNGsneiCLKqaLTq5fv75MJOg4flsQNfRw/Ls1L0NOGqje1at3a7843mTB3+XJMzs3F8ooVoXS70e3UKQwuUwb3tW2LyEB3JmRKnKwsSez88QfwwgvA6NHAFQrpzA1gsVjw4osvijmcnj174tdff0VKSkrInEMWOswlafBrC92jZhSmwTcu3G2mNPi0Yj9TXrcXOStyRGsbtbh5CjxIujtJiB5NPw2UKv+USzec3oDmY5vjf83+h087fOqXY2D8g9XtxsLsbNGatpiqHYAI8aTKTbfUVMTcRDDi9XC5zDAY5olKT07On4iIUCA19X5RNU1J6QSZrJhNMajPiMIqKLTi7rulFWyhFTDDEHq9VLWh1rTNm6XU+r59JXFDszi+iM44d+oUpq5ejUkyGXaVLYvUvDz01+kwpGZN3HnXXYgIgrwOpmSg8S6a13n1VaBOHanb9vbb+ezfDHv27MGAAQNw7NgxfPnll3jkkUcCqsOmOGChE+YUFBwsbKWZArv9JKKiKorKDX3ExVUvseNwF7hhmGcQlR7jUiMiFBFI7ZIqWttSO6dCFlWyb3JR70ehSnIVHHjqQIneL1PyeLxerDGZROVmpl6PPLcbTRMSROWmv1YLTQlmx9jt56HTTRUbDmbzDigUKWKjga7HxMRmt/4GRLZYtB2/aRPwzjtS47sPxBsTfFC+zYIFku6lFiGic2dJ3HTtKg2ElxR7duzA5B07MCU5GWdTUlA1KwuDrVYMuusuVK1ecu9LTGCzfTtAM/JnzwLffAM8+KDU1sYUrbvmu+++w//+9z/cfvvtwj661q2WaAMUFjphiMORhaysC4upbVAokqHR9BOLqaSkFoiI8O/OmT3TDt00naj0mLeboVApRIWHKj1JLZJKZLeh/o/1sVe3F443HUGR/MvcOPsLCkTlhmZvTtvtqBwdLSo39HF7AMypFBTsE9eotAlxGtHRVS5uQsTGVrvxX0hb9BROkZwMZGRI8eMMwn1nfPVqqXIzaxaQny+5W9HcTb9+gL/HZdwuF1avWYNJx45hdpkyyI+NRbOTJzE4MhL927RBaqlS/j1Axu+YzZKPCllR03P2p5+klzjm6uj1egwfPhwLFy7E008/jU8++QTRIdwmykInTHC7C2AwzBfVG6NxmRAzqaldxaIpJaUz5PLAfJIX7C8QVR4KJrWfsiO6crSY5SHRE3uH7xajo1aNwjur38Hv6b+jc7XOPrsfpmQ5b7djmk4nBM4OsxkqhUJUbUjcNE9MDMiSPbWVmkxrxLWr18+C252HhIQ7RWubRkNtperrrwQojIIycfr3l+yjeSUQ1uzdK1VupkwhlyWATM+ockMfVasiILHk5+M3CiXNzsaSSpXIChadT57EELUaXdu3R3QAbE4w/mPGDMlPhfdxrs3y5cuFq5rT6cS4cePQlcq1IU5eER2Z2V46CPF63cjJWSF2hQ2GOXC7zUhMbCHEjVbbD0pl8AybeT1e5P6VK5kYzNTBnetGQpME0dqm7a9FpLZ424t0Zh3SPktDz+o9Maf/nGL93UzJUuB2Y26hqcCynBwoIiLQNTVVtKZ1Sk1FVBBV7NxuK7KzfxPXtNG4WHyP5njomqa5Hrk85uq9Hd9++49lERN2nD8vFfKoerNrFz1vJLc0EjdUxQmmp4Xu3DlMX7UKk10ubK5QAUkFBeh77hwGV6uGli1bQsbtmGHJpZ25b78NvP46d+ZegITNyJEjRfWmbdu2mDhxIsqUKYNwII+FTuhhNu8Sjmk6XQYcjvOIiakmTAUo8yYmpgqCHbfNjeyF2aK1zbjIKHpNU+5LEVUedTc15LHFM3OQ8nEKFDIFdC/piuX3MSWHy+PBCpNJVG5I5BR4PGiZlCQqN301GqiCPBeAcDj00OtniGs9P38T5PJEaDR9hOhJTmyJiC+/kmZweFo3bKFi3pw5UvVm+XKAnvb33y+1pt13H1CC42c+49C+fZiyeTMmx8fjuEaDCgYDBuXlYXDjxqhZ9/J8Nya0Ia+V994D3n8faNFCeu5XqICw5u+//0Z6ejp27NghgkBpLiecWvLzWOiEBjbbGSFsaKe3oGAPlEq1CCWkRU9CQpOAbMkpDhwGB/Qz9KLSk7chD/IEOTS9NaLSk9wqGRHym/+7u0zpgkV/L0LuK7lIjOYA2kCHBO9Os1lUbjJ0OmQ6HLgjJgZDSpVCulaLyiU5TV3CWCxHCud5JsNmO4aovChoF9pRqswDiHv959BY0TJFXuj9+adUuZk3j54bklMaiZs+fUK3a5FCSdevW4dJhw5hRloachIS0PD0aQyOiMDA1q1Rqlw5fx8iU4L89ZdU3aG5M3LP7907PE//pEmT8MQTTyAtLU0YDjRp0gThRh4LneDF5cqDXj9bLG5MppWQyaKQmtpd9O6rVB0gkwX/rvWNYD1qFYKHQkltR22ILBt5cZ4nvk7RQh0vZdb+Weg7sy8+ufcTvNTiJZ8cM3PrnLbZLoZ57rNYoFEqMVCrFa1pjRICK4zW13gXL0Le6MHIammDrr0Croh8xMfXL7SJH4ioqCKmOjJBF+ZJXYq0e01Wu5Q1UqOGJG7S04GKYRYHZrdasYjyeTIzsbBCBbjkcnQ4cQKDVSr0uPdexF2jT58JHSjU9uGHpTxk+kyW1OEyykWLexI4U6ZMwdChQ/Htt98iISEB4UgeC53gwuNxIidnqWhXyc6eD4/HjuTkNqJyo9H0hkLBL+C0s5+3KU+a55mmgyvbhbh6cVIoaXoaosoULV3M4/FA+b4SjUo3wuaHN/v8sWWKTq7LhVmFczerTSZEy2TooVaL1rT2KhWUYVSWF9jtUqgEvZOTJ/C4cfCok8Ucj/Ra8Ru8XhdUqnsLg397QqG4cfHPBBYnT0qGAiRwDhwA0tKkkSwSOA0aBNfcja8w6nSYtXIlJlmtWFupEuKsVvQ6exZDKlZE2zZtIFco/H2IjI83AcaMkfxYSPBPmwbUqxfap3zjxo2iVc1gMIgQUPr/cCaPhU5wLNzz87cUhnlOg9OpR1xc7Yu7tNHRHPZ3NTwOD4xLjEL0GBYY4HV4oWqnEq1t6p5qKBKu/SZ329e34Vz+OVjfsPrgkWVuBIfHgz+MRjF3s8BggMPrRTuVSoibnmo1EsN1wXLwoLS63b8f+OQT6R39Pytcp9MEvX6meA3JzV0DmSxWiB2q/iYnt4NMFqbnLggxmSQraGpNW7NG2qHu2VMyFbj3XiBcL4OicPzwYUzZsAGToqJwuFQplM7JQbrRiMH16qFew4YcShrC0EYAvUzS56u8TAY9brcbH3/8Md566y00btwYGRkZqFIl+OeybxUWOgGM1Xr8Yt+91XoYkZGlodWmi8VJXFzdsGrJKQ6cJicMs6VQUtMqE2QxMiF2qNKjaq+CTHF5FeDJRU/i+y3fY8cjO1C/dH2/HHc4QyJ/U16eqNyQLXS2y4W6cXGiLW1gWhrKRhWtOhfSW5UUIlG+vLRVWf/6z1Gr9UThPN8kWCwHERlZ6uI8X3x8A35dCUAcDmDxYqly89tvJFyBdu2kyk2PHkCYdqTc0jzPVjIw2LsXUzUa6JOSUOvcOQxxuTCoZUuUq1zZ34fI+ACbTSp8f/XVxcI3tNrQONVnqUo5ZAhWrVqF1157De+88w6UIWC6Uxyw0AkwnE6j2HmldpO8vHWQyeJESxotQlSqtoiI4BTz4sB2yoasjCzh3GbZb4FSq4R2oBalhpRCfMP4i4u9A/oDqPl9TYxoMAK/dPulWO6buT5HrVYhbujjb6sVZSIjMagwzLNuPLdcieZzCo2grX1qPv/iCyAu7oZFpNm8vdChcSqcTh1iY2sWhpIOQnR0mFsVBYCO3bhRqtxQ1qvRKOlYqtzQznSYOMP6HKfdjmXU2nbmDOaVLw+7UonWlM8TF4fe996LRPLhZkKKRYuABx+UrKcnTgTat0dQM3/+fBEASqGfkydPRps2bfx9SAEFC50AgOZssrN/F5Ub+ky99CkpHURrmlrdHXL5jS1gmBtc7O00C8FDwseZ5URs9Vgpnyddi5hKMYgbHQdNrAYnnjvBp9aHZDudmFEY5rkhLw/xcjn6aDRC3LROToacK5gSa9dKdkJ5ecAvv0hWWreIx+NCTs6ywsytufB4rEhKaiWqx2p1byiVIWrVFYAcOfLP3M3RowCZhdHDTQKndm1/H11ok5eTgzlkYpCfjxUVKyLK6US306cxpEwZdGzXDspwriCHGJmZwNChwLJlwP/+B3zwQfCZU1qtVmEV/f3336N79+4YM2YMUlNT/X1YAQcLHT+mnefmri9MO58Bl8uE+PhGhWGeAxAVVcpfhxa2eFwemJabRGubfo4eHosHSS2T8FqL17AsehnsI+0iV4cpPmxuNxZmZ4vKzSKjER6vFx1TUkRrWje1GrEc/Pdv32AKh6CQCB8GRLhc+ULskOjJyVmOiAgl1Opu4rUpJeU+yGRBthoIAgwGqWpDDylVcagVjfQrtaa1agWEm7dGIHDmxAlM/esvTJLJsKdsWajz8jBAp8PgWrXQ9M47eZ4nBPB4gM8/l4JFKXKJHAurVUNQsHfvXgwYMABHjx7F559/jscee4zbjq8CC50SxmI5dEnexQlERVUobBUZjLi4GiV9OMxVcJldMMwziErPqsOr8NyDz+HXvb+i++DuSOmUAlkkrzxuFhIza3NzReVmpk6HXLcbTRISROVmgFYLbbBtq5WUvRZt62/Y8E/kdwlMndvt50RbG7W3FRTsgkKRCq22v6g2JybeyW+st4DVCixcKLWm0fwNQSGeVLnp1g0I4dinoGP39u2YtGMHMlQqnEtJQbWsLAy2WjG4WTNUueMOfx8ec4ts2ya1g547B3z7LfDAA4FrVEBdKFTBefHFF1GtWjWRjVObS73XhIVOCeBw6IRbGokbck+Ty5Og1fYVi4WkpLsREcGL5kDGdMoEza8aDNwzEMPnDYciRQFtf60wMUhslsiLvSJyoKBAVG4o8+ak3Y5K0dFC3AzSalH9BudLwoqZM6U5nKQkICNDqub4AbN5T+EmzRQ4HGcRE1O1sAI9CLGxVf1yTMG4g0xOaVS5oYeVug/vvFMSN/37AxqNv4+QuRZulwsrV6/G5OPHMbtMGZhjY9Gc5nkiI9GvbVukkL83E5SYzZITGxkUDBgA/Pij9JIbSJBd9EMPPYQFCxbgySefxKeffooY3hG5Lix0fITbbYHBsEC0phmNfwgxk5LSWSwMUlO7Qi6P9tVdMz6g9GelYXVacfb+s6K1LWtKFuyn7YiuEi3l8wxOQ2y1MEkiuwGyHA5MLTQV2GY2I1mhQD+NRrSmNU9KgixQt80CgYICyVGNnNX69QN++ikgYu29XjdMptWFbbez4XbnIzGxWaHo6Q+lknvE/ws5f1PlhmZvTp8GyNSLxA193H67Xx5G5hax5Odj/p9/YpLRiKWVKkHm8aDLyZNi86Zru3aICpdkyhCDzCsffRQgDwraV2rWDAHBihUrhKua3W7H2LFj0Y3KvkyRYKFT7AuAVWLX898LAMq76ccLgCBmwKwBmL5vOk4/fxrlEsvB6/HCtMYkWtv0s/Rw57mRcGeCEDxU7YnUhG/7VYHbjfkGg2hNW2Y0CjHTNTVVLAC6pKYiigcOrs+OHVIvBa2Kv/kGGDYsIHspaEOHwkiptc1oXCKqm9KGzpCw39A5f15aNJHAoYdTpZKqNiRumjcPyIeTuUmyzp7FtFWrMJlsq8uXR7LZjL6ZmRhSrRpa3H03ZDxrGFQcPy51Cm/eDLzzDvDaa5JDmz9wOp0iF4fycchNbeLEiShbtqx/DiZIYaFTbC0dk5CVlfGvlg76iIm5rTjugvEzK46vQLuJ7fDa3a9hdLvR//o3t9WN7N+yRaXHuNgovpdyX4pwbku9PxXymNC3BHd7vViRkyMqN3MMBpjdbrRITMSQUqXQV6NBCvv5F723iUIeKOyhVi1pOjZIZgCkFt3p4rXw3y26g5GU1DIsWnSpCDd3rtSaRm5ONEbVtatkKtCpE8CmXaHPwb17MXnLFkxOSMBJtRqV9HoMys/H4KZNUZ1nKYLK++XddyU3tpYtpWuaHBBLEjIaSE9Px/bt2/Hee+/hpZdegpxF8w3DQucmsdvPIitrqnhTLyjYXTikO0C8qfOQbmiifE+JO1LvwN4n9l71Ng69A/oZemROykT+pnzIE+XQ9NGISk9yq2REyEJnG5eGIncXFGBSZiYydDqcdzhwe0yMNHeTloYq3Dt8Y2RlSeEOS5YAL7wAjB4dtCtjyXRlSqHpyvFC05VBhaYrNRFqC6IVK6TKDYkcEju0MKLKTd++UiWHCT88bjfWrVuHSYcPY0bp0siNi0Pj06cxWCbDgNatkca78kEBzdRRdYeua+oi7tmzZO6X8nCeeOIJaDQaYTjQtGnTkrnjEISFzg3brs65xHY1stB2dQhSUjqy7WqIU+f7OjiYfRDOkc4i3d5yxCLN80zOgu2YDVHloqAdJIWSxtUK3uH7MzabEDbUmra3oABqpRIDtVohcMg97ULYKnMD/PGHFOpATJgg2W+FiBjOy1svWtskG/0cxMc3LJznGRi0NvoU5rlzp7TLS338lMlBhTeq3NCiqFIlfx8hE0jYLBYsWr5cvGb+XrEiPDIZOpw4gSEpKeh+772IJT9xJmChsF7yg5kzR5rfIUtqX41g0aKcjAZI6AwePBjfffcdEhMTfXNnYUJeXh6SkpKQm5t7zXMZ4aV3rBD5Y24uSG8SDIZ5IkgvObm1eKPWaPpAoQgwWw7GZ7yx4g2M/ms0lg9djraV297YYm9DnhA8uuk6uIwuxNePl0JJB2oRVTrwd+3zXC7M1utFa9pKk0nM2XRPTRWtaR1UKih57ubmsNslq2h65yRxM348EKLOTVIw8qLCYOSFlwQjD4Za3SMogpFpZOpCmOe+fYBWK41SUfWmUSOeu2Guj1Gnw4wVKzDZbse6ihURb7Gg99mzGFylCtq0agV5CdjGMzcOrYApn/m55yQzEeoqpuyd4mTz5s0YOHAgdDodfvjhByF0mFuHhc5VFqb5+dvEGzJlSDidOsTG1hSVm7S0dERHF39IHxP4nMs7h7JflEX/Wv0xrc+0m/odHodHzPFQaxvN9XhdXqjuVYnWNnVPNRTxgfMm5/R4sDQnR7Smzc/Oht3jQZvkZOGY1kujQSK/Id8ahw5Jq+S9e4GPP5Yc1sJEMDqdRuj1s8QGUm7uWshkcdBoeonXWJWqLSIiAmeuLTcXmDVLEjerVwPR0UCPHlL15t57AR4/Y26WY4cPY8r69ZgUE4MjaWkoYzQiPScHQ+rXR11SzkxAOijSyza9fH/6KfDUU7e+weHxePDJJ59g5MiRaNiwITIyMnDbbTzfXVyw0LkEq/UEdDqpr9xiOQilMk0IG3rzjY+vzy05DJI/SkaMMgbnXzx/y2fDaXJCP1MvKj25a3Ihi5UJsUOtbcntkiFTlPyil0T+lvx8UbmZptNB73SidlycEDfpWi3K0SqPudWTDIwdK4U2lC8vbQ02aBC2Z9VqPV44zzMJVuthREaWhlZLr7uDER9fzy+vuw6H1E1IczcLFkhft2snVW569QK404gpTrweD7Zs2oRJ+/ZhmlYLQ2Ii6pw9iyFuNwbecw/KcS9kQGGzAa+8Anz9tWQ2Qi/nN5uBde7cOWEbvXLlSrz66qsYNWoUlLx7UqyEvdBxOnMu2Vn8CzJZ7MWdxeTktpDJAmeHnfE/HSZ1wLJjy5D/Wj7iI+OL7fdaT1ihy9AJu2rLQQsiS0WKtjaq9MQ3iPf5Yu+41SrEDX0ctlpROjJSGArQ3E3duDgW+cWFySQ1ec+YATz0kOSwxmGpl1TSt15SSdcjNrYWSpUie/5BiI4u53P9uWmTVLkhW+jsbKk1hSo3tIPLs+NMSeC02/EHtbadPYv55cvDrlSi7YkTGJyYiN7t2iGB3S0ChoULJed/0iUTJ0oV3hvht99+w7BhwxAZGSlmctq2LXpLPBPmQmf16tWIj5cWoWq1GhUqVLhCr/hiIW4u9IqrVPcKcUO94gpF8S1gmdBi8q7JGDJvCL7s+CWevevZYv/9dJmZt5tFa5tuqg5OnROxNWOlUNJBaYiucOWKyoENR5F/LBsRuLIgSq2aiip3VvnX94xOJ2bq9aI1bV1eHuJkMvQuDPNso1JBzqYCxcu6ddKkOomdn3+WQkCZK+LxOP8zG2kvnI0cAo2mNxSKy9+sTp06JZLDr8aV3guIo0clcUMff/8NlCkjPUxUvSnuHnyGuRFyjUbMIRMDsxmrKlZEtMOB7mfOYEi5cmjfpg2UV3BlzD1lQYTeddXNKaVWiehyXJkvzrws8pFZvhx46SXgvfeAyOvE6FmtVmEVTUYD999/vwgApdcnpviwnbbBqZeMo/LMeSjXqpxvhM7333+PTz/9FOfPn0etWrXw5ZdfoiX5bl6BOXPmiOGrnTt3iuRXuv0777yDjh073rDQuZSoKAUOHz6K8uXLC/cfabdweqH7T4PCMM8BiIoqfaN/HhOGuDwuRL4XibvK3YX1D6336X15XB7kLMsRrW2GuQZ4rB4ktUoSrW3q3mook5XidhsOHEWnAydRSifD8LFAky24TO4YYUSjw41Q6rby+D07W1Ru6DPl33RISRGVm+5qNeLYo983/sNkFT1qlBSzTdPsFSv64I5CE5crD3q95HZpMq2ATBaF1NRL3S6VQuTcfvttsNtdV/09F94LSOxQtYaKatSatmEDQPtiffpI4qZ1a/+FAzLM1Th9/Dgy/voLkxQK7CtTBprcXAzQ6zGkdm00btoUETIZTuZZ0GDFZmgzcdX3AmUpJZqdaAZZVHjMA5ZU/Nlnn0m+MvXrS93IVate+bb79u3DgAEDcOTIEXz22WfCQpqdSosXj92DteX+hMcgKc4CFKAruha/0Jk+fbroOySx06JFC/z000/49ddfsX///ivuqj333HMoU6aMSH5NTk7GuHHj8H//93/YtGkTGhSxf/1KQodYsGAENJoVsNmOISqq/CV5DrVu5E9iGEGlLytBb9Gj4PWCEjsjrnyXEDskenKW5yBCGQF1N7Wo9CxRH8UQhxURHi+8sgjccfDfb3KuCA8W1z6N4z9UxUqvFyaXC43i44Vj2gCtFmnX235ibp5Tp6TywPr1wMiRwJtvSimSzE1hs50RbW1SftkeKJVqsVF1/nxjtGr14HV//uOPt2H9+oZYtEhanNA+GrWmdevmO7tYhinueZ5d27dj8q5dyEhJwXmVCndkZmKw3S4MDLobDIjwAF4ZLnsvgAxIaJSAhpsa8uLaB2zdKrW5kt38d99Jry0XCmu0hP7xxx/xwgsvCKMBysapU6eOLw4j7PF6vdhQfyEce+LEheAzoXPnnXcK9wiq0lygRo0a6NGjBz788MMi/Q6q6vTv3x9vvfXWjQkdsmolSb1li/j+L7/E4e67pTDP5OR7wiKhm/Edj/z2CH7Z/gv2P7EfNTQ1SvxU28/ZRVsbtbcV7CrAkQbAI5//8+8yN+CRA5WPSR/7agFZpYFSEREYXr68qN7U4LkQ30NWXRS+QJPrVMW5SjWbuTnM5t1C8GRlZWDv3nNi9On6bEOTJg1F5WbAAMkemmGCFbfLhRWrVmHSiROYU7YsCv4T0nzhveBSwVNvSV2kdEzx2zGHOvn5wNNPS3Fo6ekALYGdzmyMGDEC8+bNw+OPPy4qOTEcqO1TjH8Ysfu+3eL/fSJ0HA4HYmNjMXPmTPS8JEb22WefFa1pNENTFLu9SpUq4eWXX8ZT5N93BajFjT4uFTrUoiZscmhxQbJ6/XrcHlMNcXHc/8gUDxaPDocinoPa8QDKRxW9tdIXxFoVkLkU+KvL1ePX400umKf8hHam25CiKl+ixxe2rWo7dwDHjwFlywNNGgNKrpr5Di90OnpfGXPdW86atQ29ezf04bEwjH8oyMvDFytXYuQVulouCJ4aRzwYuT8H95x1+OUYw4mtpzSYtq0alIoD8HomweN1YnDTpqhbpqy/Dy0s8HqB08tTYc9RoADWIgmdG+q1oIFQt9uNtP8E39HXmSQ+igAp3oKCAvS7xsAuVYbIiu8yLmRRlColAg8O08KDYYqNVGBXZRg0Z2Gomur/83od0wBzsgLo0gXLhz0s9S4wJcfZTcDZWXzGfY6nSLeioD+GCUXiEhPRuW1bjNy27bJ/I5FDHKgmw2tKFSZ8yWsiX5MMD0bgMNwues8dBgUiIF/nwd8IeF+v0CAC8Iq1UdHXPDfVVP7fASsqChVl6Ip6F8mIYP78+dBeo7fgtddeE/2Ol1V03G7pGwcPiijbbffei4b/+9/NG50zzH9oelKNbedXwPnYH5D5OeRxypYtGFxw+byQzO2FRx6B2w960fwXMx77eC0aP9MY8mietPbJ9hFZRVO4Qs2aUuts9erFfz/MFdm+fTsaFSFg8ZVXeuP5519Ex46PQS7nWSkmNLBnSu3M+1ecA168/N8vzG+K21aLwp/HKgt3zdt5MM0nHDt2DOnp6di6dSveeec9WCwv46OP5GjVSnJ3ZKt632A27y00HJsCu/0MovRRcL34JXCmDBX+r8sNreTIJk8ul19WvdHpdJdVea5kYvDQQw9hxowZuPc6puRRUVGiDHXpx0W/0JdfBh5/nN4BJTsM8gy9/37JasdqvZE/h2Euo2/NvvB4PZh1IPB266lNgah2JAJ1X56Mmo9/g6bb5bC+YsX6Uutx6OFDMK02wevhnaViQaeTUuOefx544glg40YWOQHKjh2n0KXL0yhfPgZPPnk3tm9f5O9DYpibwl3gRubkTOy6bxc2lN2AY68eQ2TZqCu+F9x+OALTXx6Dlc89h642G745cwZ3bN6MO7dtE/+vo0RcpljIyMhA/fr1xXp37dq1ePPN1zB6tBwrVgBHjkiW9fPn88kuLuz28zh9+jNs3doAW7fWwfnzvyA19X40cHyO0r/Z4X5qLOAt2ubuTZkR0A4bua5doGbNmujevftVzQiokjN8+HDxmUwLbpSrua5tW7YMDQ8dkrxEKRGOBNEFL1GS2H7ekWeCjzxbHpI+TkKnqp2waNCiwKjokI2UTIaKB614YmwMErYcxBN4/OLtNs/eDPVOtXBusx23IapClMjmIee2uJpxfv0bgpalS6UQBTr3NH3aqZO/jygsKWpFZ/PmTdDrN2P8+O+wePFBmM30vhSLfv06Yvjwd1G+fO0SOV6GuRm8bq9w3aRgaf1cPTwFHiS1TBKv4Zq+GuyRW9Fo+3bIPB54ZDLUPGjFA2Nj0HbLQTTC48KCGo0awbZhAxZmZ2NSVhYWGY2i2+a+wpiBbmo1Ytlf/YbJz88X8+QTJ04U1Rxa+/53PUq29iNGAPPmSfvwtAfPngQ3jstlhsEwV5jR5OQsR0SEEmr1/cJwLCWlE2QRSpx4vTxOdDyLimOAU5M/R2u8cN0ZHboQbohp06Z5lUqld8yYMd79+/d7n3vuOW9cXJz3xIkT4t9fffVV75AhQy7ePiMjw6tQKLzfffed9/z58xc/TCZTke8zNzeXxNi/PqLk8J48fPifG9H/v/WW11ulCik3r7dcOa/3lVe83r17b/RPZMIczScar+ojlb8Pw7vx6FEvZs/24ocfvGjSxNsADb3jMM7bEA0vXgfR0dHekydPitt7PB6vaa3Je/DRg96/VH95V2Kld0vDLd5Tn5/y2s7b/P3nBAd2u9f74ovSa0iHDl7v+fP+PqKwhp7bUVGKy17///VeEKW4eA0QZnOOd8yY/3nbti3tVSjglcngvftujfeHH57y5uXp/fr3MMwF6PU6b3ue98gLR7zrSq0Tr9cb79joPfH+Ca/lmOVfJ+p0bq631Ny53iY//OBd0qSJ14CG3k0Y581GQ+m1ij5KlfJ6bf+8zuvtdu93Z854m23b5sXKld6ENWu8Dx444F1uNHpdHg8/EEVg8+bN3qpVq3rj4+O9EydOvOZt6ZT+8IPXGx3t9daq5fXu3s2nuCi43U6vwbDYu2/fIO/q1bHelSvh3b79Hu/Zs794HY6cf9/YZvMeezLOe3yI9Jw/jnriPYA0wrW46cDQTz75RASG1q5dG1988QXuuece8W8PPvggTpw4gVWrVomvW7dufUU3tgceeADjx4+/oYrO6p9/Rnxh76m6alVUuPPOKyk3qcWEqjzTpwNGo5T0RMbnZIRemgNEmWvTe3pvzDk4B1kvZkEb71+f2iMnTyKP8hOuMgN3tVR4CtbKXpQtqjzZC7PhdXmR0iFF7BCqe6ghj+N5nss4fFh6jdizB/joIwoB46pwAEChoWSEczWudg0QmZl/Y/z4tzBt2kLs2pUvdlk7drwNQ4Y8gm7dnoNCwa55TMknu2dNyRKvzZZ9Fig1SmgHapE2JE1k4Vzttd5+6hQi9fqrz0PT3HO5clf8p6NWqwiTnpSZiaM2G8pGRmJQWpqo9NShVF3mMndgynt84403RN4jta1VvVpS6H/Yt096G6G3E6rsUNdzEUbYwwqv1wuzebuYu8nKmgqnMwuxsTVEWHRaWjqio68RvH36NKDXi//NM5uR1KpV8efo+IMLQue65an/Qv2pixdLoue33yR72HbtJNFD9th8gTNXYPGRxeic0RnvtHoHb7d+O+jPkdPohH6WXrRF5K7NhSxOBk0vjXhjVbVVIUIe5q/C9BJImy4UkkDTpGQ40JCtikON/ftX4ddf38WsWWtx+rQTarUMPXo0xEMPvYK77urj78NjQhhXrgv62dJrMM1RyqJlYsOJNp5U7VWQKUumzZ6We5vy8oTomabTIdvlQr24OCF40tPSUCbq37NA4Qht4A8dOhTLly8XMSjvvvsuIm8wfNtmA156Cfj2W2mEfOxY2pDx2SEHDTbbSWRlTRECx2I5AKUyDWlpA4XAiY9vcMNht0XVBqEtdC7FZJKC/kj0rFkjxWWT2CHRQ+KHU82ZS3ZzIt+PRG1tbex8bGdInRfrcau0mzgpC9bDVkSWjoQ2XSvecOPrxYdfqja9Ljz2mFT9HTYM+Ppr3gAJg+t71arxGDfuSyxcuBcmkxdVq0ajb9+2GD78HVSt2sTfh8iEAB6nB8YlRqmqviBbVNmT2yaj1JBSUPdUQ5HoX3dAh8eDJUajED0LDAY4vF60U6mEa1tPtRoJYbgmWrhwIYYNGwalUolJkyahHa0NbwHaX6e3FdJJtPS8xV8XlDidJuj1s4S4yc1dDZksFmp1TzF3o1LdC5ns5p9nLHSuxcmTUqI5PfPIqpoc46jWSKKnQQOuMzKo8W0NHMs5BvvIf4JrQwna38jfmi/ehMm+1Kl3IrZWrHgT1g7SIrpcNEKe9euliOucHODnn4H+/f19REwJY7dbMHv2R5g4cTxWrjwNpxNo0kSFgQN74YEH3oVKVYYfE+bGXlc35yNzUiZ003RwZbsQVzdObCSlpach6j/uaYGCyenEbINBiJ5VJhNiZDIhdqjS016lgiLEjZ1sNpuo3nzzzTfo2rUrxo4dC00xxZacOyf52pA7G6UUvPsuoFQipPF4HDAaFwtxYzD8Bq/XCZWqnajcqNU9oFAkFMv9sNApClTMIptqMkDPyJDsZCkrg1zbaAFU8Rp9gkxI89LSl/B/G/4Pa4etRYsKLRDqO485yyTHH8M8g7Tz2DpZtLZpemv8vvNY7FAe1+jRAIUS05wfbXpUquTvo2L8THb2KUyY8A6mTZuLrVtNYhe2bdsKGDp0OHr2fAlRUdJ8KMP8F+vRwkr55CxYj1gRWSbyovNlfN3gmoE5ZbNhCs3zZGXhgMUCrVKJgVothpQqhYbxoVf1379/PwYOHIhDhw6JuZwnn3yy2P9GMu/89FPgzTelrmhabt52G0JO5OflbSzMu5kOlysb8fH1ReVGqx2IqKji3zRioXOj0PzOn39KVZ65c6VMHrKoJtFDltXJycX+IDGBy0nTSVT6qhIG1RmEyb0mI1xw5bmgn6MXb9imFSbIomRI7ZYqRE9Kx5QS6yX3GTTISNf02rXSu87Ikdy2ylzGkSObMHbsO5gxYyWOHbMjOTkC999fB8OGvYBWrYb4PUyY8T/ObCd0M3TitTJvfR7k8XKoe6tFVZw2ioJ99pEWrjvMZlHlycjKQpbTieqxsaK1LV2rRaUg90+mv+/nn3/G888/j8qVK4v4k7oUhuNDNm+W9tBpT50SWuitKNixWP4uNBWYDJvtKKKiykGrHSQETny8b239WejcCvn5ktihSs/y5VKdkSbKqLXtvvukhksm5En8MBGJUYk488IZhCO2MzbR1kaVnoI9BVCqldAOkOZ5Eppe3R0oYJkzRwo7iIuTqjiFTpEMc615ng0bZmLcuE8xb94OZGd7ULFiJHr3bokRI95CjRr8HAon3DY3jL8bRWuacZFRhDPTBpBws+yuhjw2NN0sXR4PlptMQvTM0eth8XjQMilJiJ6+Gg2Sg6wXy2g0YsSIEZg7dy4ee+wxfPbZZ4gtdPQtieXlk09Ke+qDBkmC52ZHz/2Fw2GAXj9diBuq4sjlCdBo+ojWtOTkVoiIKJmNIBY6xQU1WJILEz0rd+0CUlOlXn6S4nfdxfM8IUzbCW2x8sRKWN+wIloRBjMr18C82ywET1ZGFhznHIipFiP1nQ9OQ0yVAN/Zs1iA55+X5nB69QJ++QVISfH3UTFBhsvlwPz5n2PixF+wbNkxUfSvXz8RAwZ0xbBh70OrrezvQ2R8AIkZcquk1z/dTB3cuW4kNE4QVW5tfy0i08Jr49PscmGewSBa2/7MyYEiIgL3p6aK1rZOKSmIDPBqJ8WdDB48GAUFBRgzZgx6kimVH6C9NgoXpVEgamW7UlpKIOF2W5GdvVCEedL8DZGScp+o3KSmdoNcXvLrABY6voDyNajKQ8/Qs2elJksSPPRRRI91JngYs30MRvw2Aj92+RGPNn7U34cTOAneK3NEu4ZhtgFusxuJzROlN/1+WihTAmxnjzYnyGjkxAngq6+kik6wVaKYgCMvT4fJk99BRsZMbNhgAAXO33NPaQwePAT9+7+BmJgg26JlLqPgQIF4naPZG/tJO6IqRl3c3ImrHsdnjKyY7XZM1elEpYfa3FIUCvTXaoWJQbPExICq+judTmEV/cEHH4jcx8mTJ6PcVXKHSopjx6S3JxoVJ5OCl1+GeC0JFLxeD0ymNaJyo9fPhNudh4SEpqJyo9X2R2Rk8Rg23CwsdHw9zEwhqCR6yLKaapFU3aHWtn792DA9RHC4HIj+IBotK7TE6mGXh96GO26LG4b5BrHTaVxqRIQsAqldUsVCILVrqpjv8RtkNPLNN1KYQY0aUlWWPjNMMXPy5G6MHfs2Zsz4AwcPWpGQEIHOnavjgQeeQseOj/E8TxDhyHIga6pkKmDeZoYiWQFNP414TUtqkSRe45grs6+gQAgeMjI4bbejSnS0EDz0Ua2E2sKuxvHjx5Geno4tW7Zg1KhRePXVVyEPEEVBTo9vvy1lVLduLTUPUZybPyko2C8qN5R5Y7efRnR0ZVG5oY/Y2NsRKLDQKcm2GDJLp2fnkiXSbnHnzlKVh+Z6osO75SnYKf9FeeRYc2B+3ezvQwn4BQLZqdICgWyrxQKhrxRKWuILBEpNpvCC338HnnkG+Phjvg6ZEmHr1gUYO/YjzJmzGVlZbpQpo0CvXndhxIg3UK/effwoBCDugks2bJYVbth0lTZsUjqnQB4dGAviYMHj9WKNySRa22bp9chzu3FnQoIQPFTt0ZTwjDOZDNAcTkpKCjIyMtCsWTMEImQ/TXvldrsUMNqtW8nev92eCZ1uqhA4ZvMOKBQqUbUhcZOY2DygqnMXYKHjD8hKg4IHqdJD9hpJSZJjGz17W7YEArx3lbmcB+c9iAm7JuDvp//GbSkh5gfpIwoOFrZ8TPZDy8eyZVJoAVVdx40DunTx7f0xzBVwu11YsuQ7TJjwAxYvPgSzGahVKw79+9+HYcNGoVy5Wnze/N2Cu6KwBXdOYQtui0TxGhWQLbhBitXtxm/Z2aLSs9hoFN+7LyVFmBjQXE+MD6sqZrMZTz/9NMaPHy/so3/44QcRPB/IGAzAQw8BCxZIhgVkSe1Lczu3uwB6/VzRmpaTswwREQqkpnYVrWmpqZ0gkwVm7tMFWOj4m0OHpFkeEj3HjwMVKkgWG1TpoaweJijYcnYLmv7aFM/d+Ry+uO8Lfx9O8A3xrisc4p1xyRAvLSYGFPMQr8Mh2UXTO0P79sCECUDp0sX3+xnmJikoMGHatPcweXIG/vorU3RVtmihxaBB/ZGe/hYSEtR8bksI8y6zFOaZoYPjfKGpypA0kXkT8KYqQY7e4cAMvR6TMjOxKT8fiXI5+mg0otLTKjkZsmKsGGzdulW0qp07dw7fffcdhg4dGpAViStBrw8//AC8+KI0+k1d17WL0aXZ63UjJ2e5qNyQyPF4CpCU1FJUbjSavlAqVQgWWOgE0rOWEtiptW3GDCmFnRKjSPDQFFqpUv4+QuY6RL8fjYrJFXHoqUN8rm7FlnWRUYie7N+zJVvWDilikXHLtqxHjkjhBGQ8QEGgL7zA1VMmIDl37hDGj38b06f/jt27zaDRhY4dq+KBBx5Dly5PQ6EILwevErPJz5Daai/a5A8stMlvEoQ2+SHAEYtFVHno45jNhnJRURhUGEpai+z/b8EOnqyi33jjDZGJQ21r1apVQzCydy8wYABw9Cjw2WeSQ9vNPlW9Xi/M5p2FYZ4ZcDgyERNzB0qVIlOBdMTEBKdjJAudQISaLxctkqo8CxdKIaW0+0ytbT16SPkeTMDR6KdG2JW1C443HTxYXAw4jZcE7a37J2iPFh6qNqqiB+3RJsLEiVKNv0wZyaOzcePiOESG8Tl79y7HmDHvY+bMtTh71gWNRoaePRtj+PCXceedvfkRuNXg49mFwccrC4OPu6eKME9VB1XwBx+HCLQA35CXJwTPdJ0ORpcL9ePjRWvbQK0WpaOK3jp1/vx5PPDAA1i2bBleeuklvP/++4gM8sxDsrAnP53vvgO6dwfGjJESToqKzXZaGAqQwLFY9kGp1ECrHSha0xISGgW9yGehE+hQvyo5tlGlh1LaSeRQxgdVetq1CyyPwTDngzUf4M2Vb2L+gPnodkcJTwiGONZjVmHfSpUe6xErIstEIi09TVR64uvGX/0Hc3OlLS6q6z/4oOSwFn+N2zNMgEK70CtWjMW4cV/h99/3ITfXi2rVotG3bzuMGPEuKldu6O9DDAo8Tg9yluaI1rTs+dnw2D1IbpMsNlA0vTVQJCr8fYjMNXB4PGKOh1rbaK7H5fXiXpVKtLb1VKsRr7j64/f7779j2LBhwklt4sSJaE8byCEEzewMHw6Q7qN98jZtrn5blysXev1s0ZpmMq2GTBYNtbqHaE1TqdpDJgud+TMWOsEEzfDQPA+JnsOHpdkCamujSk+9epz74WcMFgM0n2rQ/Y7umDdgnr8PJ2R39vK35EvzPNN0cBqciKsTJ+XzDNQiutwl7oUbN0rXB20W/PSTVN9nmBDAZjNj1qwPMXnyRKxYcUYU/Zs2TUF6em8MGfIOVKoy/j7EwHzdmFz4uqF3Iq72Ja8b5dn1NBgxOZ2YqdeLSs+a3FzEymRC7FBrW7vkZCgKjZ1sNhteeeUVfP311+jSpQvGjRsHDSVwhiAU3UhLwlWrgFdfBUaNApSFmsXjccJoXCIqN9nZC+Dx2KFStRPiRq3uCYUiNHO9WOgEI9SKs3WrJNlpp5pscmvVkp7dNINQvry/jzBsSf0kFRGIgOFlg78PJSx2Zo1/GMXi5eLObNtkpKVroTk+EYoP3wSaNJFa1SoHZ28xw1wPvf4kJk58G9OmzcfWrSaxm3vvvRUxZMhw9Oz5MiIjw3cRbz1uvejsaD1sRWTpSGjTtaI1La5uXNC35DD/cMJqRYZOJ+yqD1osKBUZKdraWlgseHfoUBw8cACffvqpcFgL9cedzEQ/+QQYOZK6tL346addiIn5FTrdNLhc2YiLqyva0tLSBiIqys9hPCUAC51gh1KkyCqXqjzz5knzPZQmRa1tvXtL1tVMiXF/xv1YeGQhsl/KRkpsCp/5EsKV64J+jh5Zv56Cab0FMtihrmlC2ug2UHXWcK89ExYcPrwBv/76DmbOXIUTJxxQqSLQrVs9DB/+Iu6+Oz0sZgdptk8/Uy9a02i2TxYnEy1pYrav7Q3M9jFBW73bbjZjYmYmxp08iXyFApHnzuHRKlXwv/r1USFMMgut1qNYsmQVnn66PXJykvG//72OoUNjRfUmPr4uwom8vDxhGZ6bm4vExKtXrSK89OwJcIr6x4QseXnAnDlSpYdSpWhrj9KkqNLTseM/9UvGZ8w9MBe9ZvTC6Laj8VrL1/hMlyQk9B96CLbIctB1+wqZ62Jh2WeBUqMUNtXUpkK21aG+m8cwNM+zbt1UjBv3OebP3wmj0YNKlSLRt28rDB/+FqpXvzukThJVc8mlUVR3ya3R9R+3xjieZQ0njEYjHnnkEcyeOxf3jRyJxN698VtODqweD1olJYnWtt5qNZJDbE3kdGZDp5shWtPy8tZDLo9HTMxgfPrpW5gxo7RYCpJhQUICwoo8FjohypkzUlsbVXr27AHUamlGgSo9TZvyPI8PFxjK95VoUKoBtj6y1Vd3w1yKxSKFCfz4I9CzJ/Drr0BKimSVucss9eVfyMO4I0YKJaU8jMqch8GEPg6HDQsWfIYJE37Fn3+egM0GNGiQiIEDu+PBB9+DRlMRQZu/tV7K39LP0MNlciG+UfzF/K2oUoEdYsj4hjVr1mDQoEEoKCjAr7/+il5k3gQg3+XCXINBzPMsz8mBMiIC3dRqYWJA4aSRQVrtdLttMBp/R2bmJBiNi+D1epCS0lG0pqnV3SCXx4rb0VLwiSeAtDRpaUhd3eFCHgudMGD3bulZTrMK584B5BdPgoeCSW+7zd9HF3Lc/s3tOJV7CrY3bf4+lNCHRDwJeDLq+OIL4JFHrijiLyac06Jojh6eAg+S7k6SnJb6aaBUhdbOHsNcCZMpE5MmvYOpU2dh06ZsYdrZunVZDBkyFH37vo7o6MB3JLQcslycu7GdsCGqQpS0eTE4DXE1OHohXHG5XHj33XfxwQcf4O6778bkyZNR/irzyufsdkyleZ7MTOwqKECqQoH+lM+TloY7ExMDvupPYiY3d61wTNPpZsLtzkVCQhPRlqbVDkBkpPaKP0dZOzTGvX078P77kiV1kOq7G4KFTjhBE2orV0qtbbNnA2Yz0Ly5JHr69bsx43Xmqjy7+Fl8vflrbHl4CxqX4bwWn0CdtFSD/9//gNtvB6ZNA2rWLNKPugvcMMwziIWScakREYoIpHZJFW0uqZ1TRZYGw4Q6J07sxNixFEq6DIcPW5GYGIEuXWrgwQefwb33PhxQ8zwOnUO4pdFGRf7WfMiT5ND2ldpRacMiQhbYC1PGt5w4cUJUcTZt2oS3334br7/+urCQLgp7zGZR5ZmSlYWzDgeqxsSIKg8Fk1alpN4AoqDggGhLo8wbu/0koqMrFYqbQYiLq17kse633gI+/hho21aKmKN4uVCGhU44t/vMny+Jnj/+kGR9ly6S6KHPYTKw5wuOZB/B7d/ejmH1h2Fs97H+PpzQg1wGKSyAwnSfflqyl7nJ56s9035xAWXeboZCpRAVHtodTmqRFPA7ewxTHGzePA/jxn2MuXO3ICvLjbJlFejVqzlGjHgTdev6J2vEbXHDsMAgrk1yVyQxk9I5RVybqV1TIY/muRsGmD59Oh599FEkJycjIyMDzWnz9maeb14vVptMwrVttl6PfLcbdyUmiioPVXtS/TTP43BkIStrqhA4ZvM2KBTJ0Gj6ida0pKTmiIi4uQ2J5cul8W2HAxg3Drj/foQsLHQYICuLXi2k9jayrU5OBvr2lUTP3XeHR22zmIkfHY+UmBScev6Uvw8ltLjw6kzbUvTq3LVrsf3qgv0FUkvMlCzYT9kRXTlazPLQwir2jsDa2WMYX+B2u7Bo0bcYP/57/PHHERQUALVrx6F//04YNuxdlC1bw6cnnlpMTatMwjHNMNsAt9mNxGaJUt5NPy2UqdxiykiYzWY888wzIhOnf//++PHHH4XYKQ4sbrcII6XWtiVGo9jw6pySIkRP19RURPs4qN3tLoDBMF+0phmNy4SYSU3tKqo3qaldIJMVz/yZwSDtGf72G/DUU8Cnn4bmHjcLHebfHDwoVXno4+RJoGJFaZaHFpfVi1YaZYCWY1ti3el1sL1hQ6Qikk/JrULChkIBqHrTrh0wYYLP6u1iyPmvXMnEYKYO7lw3EpokSIut/lpEavnxZEIfs9mIqVPfw5QpU7F2bZb4XosWWgwenI6BA0ciPr747PPNe8yicpOVkQXHWQdiqsaI602YhtzGpiHMv9m+fTsGDhyIs2fP4ttvv8UDDzzgs+q7zuHA9MJ8ni35+UiSy9FHoxHObS2TkiArpvv1et3IyVkhKjcGwxy43WYkJrZAqVJDoNH0hVKZ4rMu8O+/l/x8brALPGhgocNcGY8HWLdOEjwzZtAUK9CokSR4aPibrDuYq/L9lu/x5KInMbbbWAxrMIzP1K3w99/SBOWOHcAHH0hzOSVUZXTb3MhemC21zywyCie3lPuk9hl1NzXksdw+w4Q+Z88ewPjxFEq6CHv3FiAujhILquGBBx5Dly7PQC5X3PDvtJ+1I2tqlri2CnYXQJGqEG5pFOaZ0JRt4Jkru5p+8cUXeO2111CnTh1MnToVt9PqvIQ4ZLGIWR6a6Tlus6FCVBQGpaWJmZ6adFHcBGbzLuGYptNlwOE4j5iY20XlJi1tEGJiqqAkfX0GDpQMC8jX59FHQ8ecl4UOc33Ij3TRIqm17fffJRHUoYPU2tajBxBgA3uBgMVhQdyHcWhXuR3+HPqnvw8neAkgT0yHwSFsbKnSk7chD/IEuRREOCQNya2SOYiQCQt2716GX399H3PmrMfZsy5otXL06NEYI0a8hiZNul/zZ135LhjmSEYgOctzEBEZIXJuaOMgpWMKZJHcJs1cmczMTFG5Wbp0KV588UWMHj0akZH+qa7Thtf6vDzR2jZDr0eOy4WG8fFC8AzUalGKMgyvgc12Rggbqt4UFOyBUqmGVjtQCBxyT/PXbKjVKlV2fvhBWtpRUkMoeFSx0GFuDKNRqvBQpYcqPvHxAPnUU6WnTRsIv1JGUOazMihwFiD31Vw+Izf+yiQJnClTgKFDgW+/DaiUM+tRq1is0SyB7agNkWUjL87zxNcJfItehimO3fU///wF48d/g99/34+8PC9uvz0G/fu3x/Dho1CpUn3pdi4PcpbmiOuF3A49Vg+SWyeLDQLaKFAk3Xg1iAkvFi9ejAcffFAIgAkTJqAjBaAHCHaPB4uys0WVZ2F2NlxeL9qrVKK1rYdajbjCNZHLlQe9frYQNybTSjFnk5raXbSmqVQdIJMpAy17GzEx0lKvdWt/H9GtwUKHuXmOHZMWorTrfuSINDNBLUZU6alXL+zP7KDZg5CxNwMnnzuJCkkVwv58FJmNG6XnEU1KUggo/X+AQjt7eZvypHmeaTq4sl2Iqxcn5XqkpyGqDIcWMqGPzWbGzJmjMWnSRKxadRZuF9CrdlP0TxmOUvtrwqV3I7ZmrDR3k56G6AohOPHMFDt2ux2vvvoqvvzyS3Tq1Anjx4+HVnvljJhAwOh0YpZeL+Z51ubmIk4mQ5dEO9p5/0C1vB8Q4bUiObmNqNxoNL2hUCQikDPnhwwBVq8GXn8dePttwE/Gc7cMCx2meKbZtmyRBA9NstECtU4dSfDQIrVcubA8y2tOrEGrCa3wcvOX8XH7j3PEBNIAAC6VSURBVP19OMGR80Tm/mTy37ixFHBbpeR6lG8Vj8MD4xKjtHO9wACvwwtVO5VY3Kl7qqFI4J1rJrSxnrDi+M+HcXLMccTokpGNbKySL4el+T50eroDunV/EZGRLHKY63Pw4EFhOLB//3588sknwmEtGOz+afMrP38Ltp6dg6l6E/7wNMdpVIBW7sAArQbDylRFvfj4oPhb3Je8JVPXOL0lV66MoIOFDlP87liUy0P1TsrpsdulljbaGqAWt8TA3cHwBZHvRaJqSlXsf3K/vw8lsDl7VnqOrFoFvPYa8M47wbt9RJeBySnscUn0kF2uLEYmxA5VelTtVZApeBaBCQ2cOU7oZ0qza+RWKIuVQdNLml3LKrMP4ya+h5kzV+PECQdSU2Xo1q0+hg17AS1aDAyoUFImcITCmDFj8Oyzz6J8+fKYNm0a6teX2iADGav1eGGY52RYrYcRGVlaGApQmOcBT2VM0ekwVaeD3ulErdhY0dqWrtWifBD4OW8sbLLIzpaaLMi0IJhgocP4jtxcYM4cqdJDC1i6oLt3lyo9ZGYQxAvZolL3h7o4YDgA+xt2flO/GiSIycyfGoLpuULCOISwnbKJbB5yl7IcsECpVUI7UHKXim8YHDt7DHMpHrsH2YslN0JyJfS6vELACzfCHmoo4hWXzfOsXZuBsWM/w4IFu5CT40XlylHo06cVRox4B7ff3oxPMIOcnBw88sgjmDVrFh5++GHhsBZ3k25mJYHTaYReP1O4puXlrYNMFida0ijMU6Vqg4iIf88sOz0eLMvJEa1t8wwGMd/TOjlZmBj01miQpFAE9HLuiSekqs4DDwDffBNQY7PXhIUOUzKcPi1dIbSQ3bcP0Ggkm2raxac2pRBd7L218i28t+Y9LBm0BB2rBs4AZUBAFi9kFU0m/iSAx4wJDYuXa+xUmneYpVDSjCw4s5yIrS7NLWjTtYipxHkhDAJ7Hm194TzadB1cOS7EN4iXnr8DtIgqXbR5NIfDhrlzP8GkSWPx558nRdG/UaMkDBzYA0OHjoJGU9HnfwsTeKxduxaDBg0Si9JffvkFffr0QSDi8diRnf27qNzQZ8q/SUnpIOZu1OrukMuLJszyXC7M0euFicEKkwlRMhm6paaKUNKOKSlQBmC10+uVlnBPPgmUKiUZodLyLdBhocOU/JWya5fU2kbC5/x54I47pCoPBZMGYwPoNcg0Z6L0Z6XRp2YfzOw709+HEzjs3SsJXTLt//xz4LHHQlbsXglyojItN4lFo36OHh6LB0ktkyQnqj4aKFWhX+1kggPLYYskzqdkwXbMhqjyURcdBuNq3dpue07OOUya9A4yMmZj82YjaEO7bdtyGDx4KPr0eQ3R0exgGOq4XC68//77eO+999CiRQtMnjwZFSoElnmP1+tBbu56ZGVNgl4/Ay6XCfHxjQrzbgYiMvLWcgXP2GyirY0qPXsKCqBWKjFAqxWVnqYJgZcp9fffUvvazp3A6NGSJXUA6rKLsNBh/DvptmKFtEVALW4FBcDdd0uip18/QKUKiUdH9bEKkfJIZP1PShcPay6NYa5WTdoSql0b4YzL7BK2u9QGlPNnDiIUEUi9P1UsJFM7p3K2CFPiOPQOUbWh52T+5nzIE+XQ9NWI52TyPcmIkBX/wuvYsW0YO/YdzJjxJ44csSEpKQJdutTCsGHPom3b4dz6G4KcPHlSVHE2bNiAt99+G6+//joUAdS+ZbEcujh3Y7OdQFRUhUJxMxhxcTV8cp+7zWYheDKysnDO4UC1mBgheOijCrV3BwgOBzByJPDJJ0D79sCECUDp0ghIWOgwgQGJHDJvp0rP0qUQW3tdukitbZ07A9cJ4ApkOk3uhCVHlyD/tXzER4bxDiW58ZE5/4IFwFNPSa+QAfTCHQjYz9uhm6oTO+jU5qZIUUDbTysqPYnNEgNuZ48JHdxWN7IXZIvnHrkHEimdUsRzL7VrKuQxJZeRtmnTbIwd+wnmzt0Kvd6DcuWU6NOnBYYPfxN16rQrseNgfMfMmTPFHE5SUhIyMjJENScQcDh00OmmiepNfv5WyOVJ0Gr7CXGTlHQ3IiJKpnTh9nqxMidHtLbNNhhgdrvRPDFRtLb11WqRGiAzzn/+KS3TXC5g/Hhp2RZosNBhAo/MTMmmmio927dLlR2q8FClh14Mg2yxN3XPVKTPScdnHT7DC81eQFhClTt6NaSG/LFjgW7d/H1EAU/BvoKLLUP203ZEV4mW8nkGpyG2Wqy/D48JAbweL0yrTaJyo5+lhzvfjcS7EsVzTNNfg0i1f5LnL+ByOfD7799gwoQf8ccff8NioeSCeAwY0AXDh7+HUqWq+fX4mBunoKBAOKqRs1q/fv3w008/ITk52a+n0u22wGBYIMSN0fiHEDMpKZ1FmGdKShfI5f51RrO43ZhvMIhKz1KjEbKICHRJTRVVnq6pqWK+x5/o9cCwYcDvvwNPPy3tYQaSmRwLHSaw2b9fqvJQMOmpU0ClSpLgoQ+a7QkCXB6XsJluWrYpNo7YiLCzGycTfjLjJze1iROBsmX9fVTBtxhdc8liNM+NhDsTxGJU21+LSI1/F6NM8GHeK5li6KboYD9jR/RthSJ6UOCK6Px8A6ZOfQ+TJ0/DunU6sd/VsmUpDB6cjgEDRiIuzr+LZeb67NixQ2TjnD59Gt988w2GDRvmtyo1mQiYTKuEY5rBMBtutxmJic1F5YYqOEplYBrjZDkcmKbTiUrP1vx8JCsU6KvRiEpPi6QkIYL81ZX+7bfASy9JSzPaq67hm+6+G4aFDhMceDzAX39JomfmTMnrkBKsqErQvz8QwGnJRJWvqghjAssbFoQNZDRA5vtUlXv/fekVMJAnFoOlvei3wvaixYXtRfcVthfdX7LtRUwQtkVmFLZF7ixsi+xf2BZ5V3C1RZ45sw/jxr2NadOWYP/+AsTHAx073o5hw57Affc9Cbk8cOY8GMle/KuvvsKrr76KWrVqYerUqbjDTxuVZvMeUbnJysqAw3EWMTFVhR00Zd7ExNwWVA/XwYICIXjo46TdjopRURiUliZET3U/2XLv3i35DJ04AXz5JfDww/5vwmGhwwQfNhuwcKHU2rZokbSVcN99UpWHWqJiA29H8vGFj+PHbT9iz2N7UDstDIbvSZCS6T7ZiJPhQNOm/j6ikBwY18/QI3NSJvI3FQ6M9ykcGG/lm4FxJgiNLuYWGl0sz0GEMgLq+9VC3JBAlkUG/8bDzp2LMXbsh5g9ewPOnXMhLU2OXr2aYvjwV9G4MbfI+pusrCw8+OCDWLJkCV544QWMHj0aUSU8c2u3n0VW1lQhcAoKdkOhSIVWO0C0piUkNA0qkX8lPF4v1uXmita2GTodct1uNIqPF6Gk5N6WFlmyVX+LBXjhBeCnn6Sc+F9+AVJS4DdY6DDBP+A+Y4a0sN6wQUqw6t1bqvS0agXIA2OHe59uH2r/UBuPNXoMP3T9ASFLXp5ksk+PBwnP774DEhP9fVQhj+VIoQXw5EIL4HJR0A6SQklv1QKYCT7rcnLvo+cCiRxhXX7PJdblyYExxOyLqsGyZT9h3LhvsGjRQeTne1G9egz69euA4cPfRcWKdf19iGHHH3/8gaFDh4r/nzBhAu6jDckSwuXKh8EwRzim5eQsR0REpMi5oda0lJT7IJOF5nVgc7uxyGgUouf37GwhgjqkpIh5nh5qNWJLcE00Zw4wYgRAxSVaEtCSzB+w0GFCq1WKriaq9ND/0ywIZfPQgrtOHX8fHWI/iEWp+FI49uwxhCSbN0vm+jSZSBbSdN6Zkg913HBJqKPRhfj6haGOA4se6sgEYRjt9sIw2qmFYbQ1pDDatPQ0RFcMoMngEsBqzcP06R9gypTJWL36nEgyaNZMjfT0vhg8+B0kJgZ2q3OwY7fbhVX0559/LsTN+PHjkZZ2a1kzRcHjcSEnZ6kQNwbDPHg8ViQntxataRpNbygUSQgnjE6nqPBQa9u6vDzEy+XopVaL1rY2KhXkJVDJOn1a2nemyYM33pBGdkvaQZyFDhN6UCvbpk2S6KGJuOxsoF49aeFNMyNlyvjlsJr92gybzm6CY6QDCpkitOanyGaFTPUbNpSCYG8Lrl7nUMTj8Ig5Hmpto7ker8sL1b0q0dqm7qmGIj6EnoNhiu2kTbjykcCxHLBAmaZE2sA0IXDiG8QHfUtOcZCVdRQTJryNqVN/w86decLRvn37Khg6dAS6d38RCgWbeRQnhw4dEoYDe/fuxccffywc1mQ+nM0kkZ+fv020pZEttNOpQ2xszcK5m3RERwdW+Ki/OGa1YkpWlqj0HLFaUSYyEumF+Tz1aMjNh9BGw4cfAu+8I3Wx0xKBfKVKChY6TGhDqVZLlkiih/Jb6Ot27STRQ82j1OpWQny+4XO8uPRFZPTKwMA6AxESnDsnbdesXAm8+iowahQQIP7+zD84TU7oZ+rFgjh3TS5ksTIhdqi1LbldMmSK4J/VCKvHclbhY7n6n8eSBCwJWX4sr86BA2vw66/vYtasNTh1yonUVBm6d2+A4cNfQrNmfTmU9BYFx9ixY/HMM8+gfPnywnCgQYMG8BVW6wnodFNE9cZiOYjIyFLQatNFa1p8fH0W+dd4nLbk5wvBQ+5tBqcTdeLihOBJ12pRzoe+0DRdQHvNRqM0v0OmBSUBCx0mfDCZgNmzJdGzapUUVtmjh7RQp2hfH9dTzQ4zEj5MQMfbOmLJ4CUIen77TTLPp8FSahds29bfR8QUAesJq+S+NSkLloMWRJaKFG1ttFDmKkBgV+fE3M1vBnidXqjaqUTlRt1DDUUCV+du6Hx6PFi9ehLGj/8CCxbshsnkRZUqUejXrw2GD38H1ard6bPHMhQxmUx49NFHMWPGDDz00EPCYS3OB65fTmcO9PqZQtzk5v4FmSwWGk0vUb1JTm4LWSh1SpQATo8HfxiNorVtfnY27B4P2iQni9a2XhoNEn2wJiLD3Mcek5ptHnwQ+OYbCNdEX8JChwlPKJOH6qe0QKesHrKnpvkSqvQ0auQzP8S0/0uDw+1Azis5CFqsVskqmowGyOVuzBhArfb3UTE3OddBrW26qTo4dU7E1oyV8lTCcK4jIOetNl4yb5VdOG81uHDeqgzPWxUHdrsFc+d+iokTx2L58lMi+qtx42QMGNADDz74LlJSyhfL/YQq69atw6BBg4TY+fnnn0UIaHHi8diRnb1YtKZlZy+E1+uCStVeVG7U6h5QKHy8Sg4Tcl0uzNHrRaVnlcmEaJkM3dVqUenpoFJBWYzthzRdQJF65FtEkwQkeqjr3Vew0GHCG7ridu6UBA8Jn6wsoHp1SfCQkUExN5L2ndkXs/bPwvkXzwtjgqBj3z6p3nzkCPD558Djj/vfJJ8pHqeuZZc4dVk9SGqVJFrb1L3VIevUFYhY/r7EQe/oPw56ouJWmxd1vsRoPIOJE9/B1KlzsGVLjujCbdOmPIYOfRC9e7+KqKjAiy7wFy6XS1hFjxo1Cs2aNcOUKVNQsWLF4hP5eetF5Uanmw6XKwfx8Q1E5YZsoaOiShfL/TBX5rTNhgydDpMyM7HPYoFGqRQ21VTpaZyQUGxtgYcPS61slL1DMzzPP++bqD0WOgxzAZcLWL5cam0jX0Qyg2/ZUmpt69MHUKlu+VwtO7oMHSZ3wMh7RuLdNu8GlyD88UfJHJ+MBigbJwCc7Jjix5VfmL0y+ZLslW7SDEioZK8EGg6DA/rp0twNVXHkCYWZSEM4E8lf/P33Fowd+w5mzlyBv/+2ITk5Al271sawYc+idethYT3Pc+rUKVHFWb9+PUaOHIk333wTimJoc7JYDgtxk5U1BTbbMURFlRdBnlS9iYurVSzHztyY4NxlNovWNhI+5x0O3BETI6o8FExamdr/bxEamyY3tv/7P6BDB7IhB0oV8x4wCx2GuRJmMzBvnlTp+fNPaX7n/vulSk/nzsBNBnBRb3jUB1Gooa6B3Y/vDo5zT651ZIZP54NCQOkVqRhe4JjAx37OLtraqL2tYFcBFKkKaPtrxQI88c5EHvi9BdxWN7IXZotZKZq/IUhIkqBM7ZYKeUxgZIAxwMaNszBmzMeYN287DAYPypdXok+fuzFixFuoWbN1WJ2iWbNm4eGHH0ZCQoKo4rSkzcBbwOHQi6oNtabl52+GXJ4IjaavEDfJyfcgIiJ8BWUg4fZ6sSInR7S2UYtbgceDu5OShOjpp9FAdYsmREuXAhS5RCau48dLy6zigoUOw1yP8+elCgZVenbskCJ+qQ+ZKj3Nmt1w61at72rhiPGIsJkOeMhNjf5OmssZOxbo3t3fR8T4CfOewpyWKVlwnHUgpmqMNC8ySIvYqtzSUxS8Hi9Ma0ziPJILnjvPjYSmCVLOUX8tIjVsdRzIuFwOLFjwJSZN+hl//HFUvCzWq5eAAQO64sEHR6FUqWoIVQoKCvD888/jl19+QZ8+fcQ8juomuxzcbiuysxeI6o3RKBnzpKR0FuImNbUr5HLeSAtkCtxuzDMYRKVnqdEIRUQEuqSmita2zqmpiLrJaqdOJ/kbLVoEPPss8PHHktfRrcJCh2FudEaFBM+UKVISVpUqUpWHPqoV7U3ulWWv4JP1n2D1A6txT6V7AvP800Qumd5T42zr1lJliwJYmbDH6/bCtNokKhH62Xq4891IvCtRLNY1/TSIVPNi/b8U7C8Q54tEov20HdGVoyXTh8FpiL2dRWIwkp9vwJQpozBlynSsX68XswX33FNatHQNGPAmYmNDJ5xy586dIhuHWtbIUY2c1W50TsPr9cBkWi0qN3r9LLjd+UhMvKswzLMfIiPZ0CYYybTbhU01VXq2m81QKRSiwkOVnhZJSTfxPAG+/hp4+WWgRg1pj5k+3wosdBjmZqD66po1kgCYNYuuJODOOyXB078/oNFc9UdP5Z5CxS8rYmDtgcjonRF45//YMWlCcOtW4L33pFccObfRMJfjtrhFGCm1thmXGMWbWkrnwvar+1Mhjw7f5409U2r7I4Fj3mGGQlXY9jc4DYnNue0vlDh9ei/Gjn0LM2b8gf37LYiPj0CnTnfgwQefQMeOj0MuVwTtjAYJm1deeQU1a9YU2TjVyaznBjCb9xaaCkyB3X4G0dG3icoNfcTGVvXZsTMlz/6CAlHloWDSU3Y7KkVHC8FDH3fE3tiGzq5dku/RyZPAV19J3fM364HAQodhbhXqX6BMGar0LF4sfe+++6SWL5rrucI8S9JHSYhTxuHci+cC6/yT8xyZ3JNdNG2lkHhjmCLg0DmEDTIt7PO35EOeJA3Uk3NbUsskRMhC353PXeCGfq5kKkAudhGKCKR2TRXVrtROqZBF8bxBqLN9+yKMGTMac+ZsRGamG6VKydGr15146KE30LBhMQ4e+BidTodhw4Zh0aJFeO655/DRRx8hqoh9RHb7eeh0GULgmM07oVCkCLc0EjdUxSku1y4mMPF4vfgrN1eInpk6HXLdbjRJSBCtbf21WmiLOONMflDkxPbzz5IfFH2+mW5JFjoMU5zo9cCMGVKlZ9MmIDFRukKp0tOq1UXvxHsn3ovlx5ej4LUCxEYGQOtKfj7w1FOSuT3Zan//vXTsDHMTWA5ZRJuWsEg+bkNUhSikDZJateJqFn+QoL9b+cidTrTyzdXDU+ARwo7+Vk1fDZQqtuYOR9xuF/7440eMH/8dFi8+KPxtatSIRf/+HTF8+LsoX742ApWlS5di6NChwjxnwoQJ6NSp03V/xuUyw2CYK1rTcnKWIyJCCbX6ftGalpJyH2QybmkNR2xuNxZmZ4vWtkVGo6gS3peSIqo83dRqxBahW4Ry3qmik5AgTQ3cqP8FCx2G8RWUNUNVHvqgdrBy5SQRMWQIJji34sH5D+K7zt/hiSZP+Pcx2LJFalXLzJQEDlWiGKa48jDW54nWNv0MPVw5LsQ3vCT0slRU8Iat7pTMGXQZOjgyHYi5I0ZUr7TpWsRU5mFq5h8KCkyYMWM0Jk+ejDVrzovO5+bNNUhP74vBg0chISEw5lMcDgdef/11fPbZZ+jQoYMQOaWu4fXr8biQk/OnqNyQyPF4LEhKaiUqNxpNHyiVySV6/ExgY3A4MEOvF5WeDXl5SJDL0VujEZWeVsnJkF+j0kcZ77RfvG4d8OabwMiRkhluUWChwzC+hqbrNmyQBM/06ZRKB1f9ekjssgvNSjfF8ic3+ecxoHdbsoomE/sGDaS2tarcM8346Olm9yB7UbYQB2Sr7HV5oWqvkkJJe6ghjwv8eR7badvFSpVlnwVKjVIINmpNS2hUfEF6TOiSlXUU48aNxLRpC7FrV77obO7QoQqGDn0U3bo9B4XCP5WPw4cPC8OBPXv2iDY1ale7UlaQEPnm7YV5N1PhdGYhNraGqNykpaUjOrp4QkOZ0Oao1SoED4WSHrXZUDYyEulpaUL01Im/cjCy2w2MHg2MGgXcdZdU3SlKRi0LHYYpSSgdi+Z4Jk1Cf9lsHEsGtpzsIG1V9OwJXOUC94llNpnWU0AqmQ28++5NZwMxzI3iNDqhn6UX7V65a3Mhi5NB00sjKj2qdipEyANHMLhyXcJdjo6V3OZk0TIhzEjcqO5VQabkuRvm5ti/fxV+/fU9zJr1F06fdkKtlqFHj4YYPvwlNGvWr0ROKwmX8ePH4+mnn0bZsmWF4UDDhg0vu53NdlIEeZLAsVgOQKlMQ1raQCFw4uMbsMhnbvr5tykvT4gecm/LdrlQNy5OCJ6BaWkoe4W5sPXrpSYUk0ma26G0j2vBQodh/MQj0wfjlwNTcG5NY5ReuRUgVxISO9Q61q5d0euyN8rChZJZPQV80SwR3RfD+AnrcatUJZmUBethKyJLR16sksTXi/fLAsrj9AgXOVF9WpAtqlEkwEiIqXupoUgIThctJjChWZjVqydg7NgvsHDhXphMXlStGo2+fdtg+PBRqFq1iU/u12Qy4bHHHsP06dOF8cDXX3+N+Es225xOk7CCJnGTm7saMlks1OqeojVNpboXMhlfB0zx4fB4sMRoFKJngcEAh9eLdiqVmOfppVYj4ZI1EYkc8k2iJpnhwyVL6rirjH+y0GEYP7H13FY0+aUJnm76NL6u8YLUOkbC4+BBgPqiBw6UKj3UVlYciz2bTarefPON5AY3Zsw1bbAZpqR39vK35ktzL1N1cOqdiK0Ve3HuJbp8tO/vf3O+mCfSTdPBle1CXN04IbjSBqYhqmxwzhMxwYXdbsHs2R9h0qTxWLHitIg0a9JEhYEDe2Ho0HeQklKuWO5n/fr1SE9PR05Ojgj/7E+xCEJ0OWA0Li6cu/kNXq8TKlU7UblRq3tAoUgolvtnmGthcjoxuzCUdJXJhBiZDD3UalHpaa9SQSGTiamA8eOBp5+WYv7IKPYKxUgWOgzjT6Lfj0b5pPI48vQR6Rt05W7fLgkeumopKrhmTUnwUK22KA2pV2L/fkk4HTokzeU8+WTxiCeG8VFFheyZqcpjmGcQFZXk1smSk1lvDRRJiivOz5A4uhpKrRLR5S4XS9ajhRWlyVmwHrEiskzkRYe4+Lol1ErKMFcgO/sUJk58B1OnzsXWrSbRXdy2bQUMGTIMvXq9jKioyx07KdTTYDBc9XyqVCphijBq1CjceeedmDJlCipWrIi8vI2FeTfT4XJlIz6+vqjcaLUDERVVhh8fxm+cstlENg85tx2wWKBVKjFQqxWVnkYJCThyJEIsb/bsAT76CHjuOcAJDyIjIkRHAFd0GMaPNP65MXZk7oDzTeflg58uF7BsmWRiMHeulNdDFtXU2ta7N5B8FUebP/8EnnlGquVSWxo1sZIZfeXKkniqW7dE/jaGKQ5ceS7o50jZNKYVJpFFk9pNyqZJ6ZgiZmRICG2ouAHOrGsInVJKNDvRTPy8M9sJ3Qyd+J3kCiePlzJ/SNyQoAqkGSGGIY4c2YSxY9/BjBkrceyYHcnJEbj//joYNuwFtGo1RLx/kMi5/fbbYLe7rnrSpP2tCIwcORIvvjgQ2dnThMCx2Y4iKqoctNpBQuDExweu/TUTnni9Xuwwm0WVJyMrC1lOJ6rHxgrB0ydZi1/ei8FnnwGt+tqw/+ltqBQbjfcqV0YlvRzVqycjNzcXideIzYjw0j0EOEVVbQwTKHy09iO8tvw1zOk3Bz1r9Lx2zg2JHRI9ZCBA8zXdukmVHgonvWAkQJcphXySZTS1vFEFaN48qZmVXgFuMJ2YYQIJ2xmbaGujSk/BngIo1UpoB2ihHaTF30//jfzt+YDnCj8oA+IbxKPCqxWEuDEuMsLr8QqhRIJJ3U0NeWzgu74xDM3zbNgwE+PGfYp583YgO9uDihUj0bt3SzRvPgB9+jx83ZP0ySfpaNfumKjiyOUJwgqaWtOSk1shIoLNNZjAx+XxYLnJJETPHL0eFo8HLZOS0NCQhgmjY2B6excivIA3ArjDGoFDnVuz0GEYf2CymaD6WIWu1brit/TfivZD585JlRlqb9u1C0hNBai/mio9NKF3abgbDZZSCCiZHDBMCGHebRaCJysjC45zDtFyRp+vhixWBo/Fg4QmCVKOzwAtIrXsNMgELy6XA/Pnf46JE3/BsmXHRNG/KPz8sxx33dVJVG5SU7tBLufcJyZ4MbtcmGcwiNa2P3NyaF8Ll9Y0IwoK4O3alYUOw/gLzacaeLweZL+cfeM/TE2pVOUhQ/mzZwGyYiQL6wsF2Hr1gB07eB6HCVm8bi9yVuZIJgKTdVes6ERERqD8S+WFwImrfhVrHoYJYvLydBg9+kl8/PGs695248Y/ceed7LbJhB7n7XZ8evo0vjhz5p9vFhQARRA6XMtkGB/RonwLGK1GGCxXHyC9KnXqAB9/DJw8KU3h2e3/iByCKj5Llxbr8TJMIEHzNCn3pqDmhJqoPefKcwW159VGlfersMhhQpbERC369XutSLdVKlU+Px6G8Qelo6LEzM7NwEKHYXzE8AbDxecft/5487+EjAxmzwbk/5kzoK9Hjvy3+GGYEIVMCqg1DRcuAznE1yn3pfj5yBiGYZhAhoUOw/gIms+RR8gx58Ccm/8lVLUhAwK3+9/fp6/p+1zVYcIAshKt/F5l4MJl4Ib42h+howzDMIz/KeqrPwsdhvERZAt6W8pt2Kffd3O/gKo1VLX5rz31P3fAVR0mbFB1UElVHUjVHPqaYRiGCS9khZ9vlxUtD42FDsP4kC7VusDhdmDTmU03/sNkPnDqFEVaX/nf6funT0u3Y5hwqOqMrozYGrHiM1dzmHBBrVYjKuryMN1LoX+n2zFMqKJVKlFKqRRhokvq1sX8KvWL9HOco8MwPuR4znFU+boKHqj3AMb3GH/jv4CEjF5/9X/XaoFy5W7pGBmGYZjAhkJDDYarG9uQyKlQoUKJHhPDlDR2jweRERFio6uoGZvX3iJgGOaWqKyqjPjIeCw/vvzmfkH58tIHwzAME7aQiGEhw4Q7UVdr5b8G3LrGMD6mYamGOJt3Fg4Xt5gxDMMwDMOUFCx0GMbHpNdJhxdeTNw9kc81wzAMwzBMCcFCh2F8zAP1HxCfp+yewueaYRiGYRimhGChwzA+JloRjbIJZbH1/FY+1wzDMAzDMCUECx2GKQHaVmoLs8OMk6aTfL4ZhmEYhmFKABY6DFMCPN7kcfH5283f8vlmGIZhGIYpAVjoMEwJ0Kx8M0TKI7Hw8EI+3wzDMAzDMCUACx2GKSFqqGvgiPEIPB4Pn3OGYRiGYRgfw0KHYUqIntV7wu11Y8nRJXzOGYZhGIZhfAwLHYYpIR5vLM3p/Lr9Vz7nDMMwDMMwPoaFDsOUENp4LVTRKqw9tZbPOcMwDMMwjI9hocMwJUizcs2gt+iRZ8vj884wDMMwDONDWOgwTAkyrMEw8fmnbT/xeWcYhmEYhvEhLHQYpgTpVb0XZBEyzNw/k887wzAMwzCMD2GhwzAliEwmQ6XkStij28PnnWEYhmEYxoew0GGYEua+qvfB5rJh5/mdfO4ZhmEYhmF8BAsdhilhnmrylPj83Zbv+NwzDMMwDMP4CBY6DFPC1NDUQKwyFsuOLeNzzzAMwzAM4yNY6DCMH6ifVh+nck/B5XHx+WcYhmEYhvEBLHQYxg8MqD0AXngxbc80Pv8MwzAMwzA+gIUOw/iBhxo8JD5P3D2Rzz/DMAzDMIwPYKHDMH4gNjIWpeJLYfPZzXz+GYZhGIZhfAALHYbxE60qtkKuPRdn8s7wY8AwDMMwDFPMsNBhGD/xSKNHxOfvt3zPjwHDMAzDMEwxw0KHYfxE28ptoZApsODQAn4MGIZhGIZhihkWOgzjR6qnVseh7EP8GDAMwzAMwxQzLHQYxo90q95NZOmsOL6CHweGYRiGYZhihIUOw/iRJxs/KT7/vO1nfhwYhmEYhmGKERY6DONHyiSWQVJUElafXM2PA8MwDMMwTDHCQodh/EzTsk2Rac6E2WH296EwDMMwDMOEDCx0GMbPDK07VHwes32Mvw+FYRiGYRgmZGChwzB+ZkCdAYhABKbvm+7vQ2EYhmEYhgkZWOgwjJ+hLJ0KSRWwK2uXvw+FYRiGYRgmZGChwzABQIfbOsDitOCA/oC/D4VhGIZhGCYkYKHDMAHAE42fEJ+/3fKtvw+FYRiGYRgmJGChwzABQP3S9RGtiMaSv5f4+1AYhmEYhmFCAhY6DBMg1NHWwQnTCXg8Hn8fCsMwDMMwTNDDQodhAoS+NfvC4/Vg1oFZ/j4UhmEYhmGYoIeFDsMECI82elR8Hr9zvL8PhWEYhmEYJuhhocMwAUJidCI0sRpsPLPR34fCMAzDMAwT9LDQYZgAomWFlsix5UBn1vn7UBiGYRiGYYIaFjoME0CMaDhCfP5h6w/+PhSGYRiGYZighoUOwwQQHW/rCHmEHHMPzvX3oTAMwzAMwwQ1LHQYJoCQyWSollINB/QH/H0oDMMwDMMwQQ0LHYYJMLre3hUOjwPrTq3z96EwDMMwDMMELSx0GCbAeKrpU+Izz+kwDMMwDMPcPCx0GCbAqJhcEQmRCVh1YpW/D4VhGIZhGCZoYaHDMAFI4zKNcTb/LGwum78PhWEYhmEYJihhocMwAcigOoPE5wk7J/j7UBiGYRiGYYISFjoME4AMqTsEEYhAxp4Mfx8KwzAMwzBMUMJCh2ECkEhFJMomlsW289v8fSgMwzAMwzBBCQsdhglQ2lVuhwJnAY4aj/r7UBiGYRiGYYIOFjoME6A82eRJ8fnbzd/6+1AYhmEYhmGCDhY6DBOgNCnbBFHyKCz6e5G/D4VhGIZhGCboYKHDMAFMLU0t0brm8Xj8fSgMwzAMwzBBBQsdhglgetXoBbfXjYVHFvr7UBiGYRiGYYIKFjoME8A82vhR8XnsjrH+PhSGYRiGYZiggoUOwwQw6lg1UmJSsPbUWn8fCsMwDMMwTFCh8PcBMAxzbZqXay5a1xYcXCDspksnlEbLCi0hi5DB4XYgShHFp5AJedweN/469RfO55/na4AJW/g6YBhI18HJv3wndL7//nt8+umnOH/+PGrVqoUvv/wSLVu2vOrtV69ejRdeeAH79u1DmTJl8PLLL+Oxxx7jx4phikBNTU0hdLpP7/6vSk9SVBLMDjO2PLwF5ZPK87lkQpY5B+bg2SXP4kzemYvf42uACTf4OmAY/HMd6P55PyjW1rXp06fjueeewxtvvIEdO3YIgdOpUyecOnXqirc/fvw4OnfuLG5Ht3/99dfxzDPPYPbs2fx4MUwRLuhP1n9y2fcNFgOO5hxFVkEW9BY9n0cmpK+BPjP6/EvkEHwNMOEEXwcMg6teB8UqdD7//HM89NBDGDFiBGrUqCGqOeXLl8cPP/xwxdv/+OOPqFChgrgd3Z5+bvjw4fi///s/fswY5jqlWdq1KMrtGCaUrwEvvNe9HcOEKnwdMAyKfB3cUuuaw+HAtm3b8Oqrr/7r+x06dMD69euv+DMbNmwQ/34pHTt2xJgxY+B0OqFUKi/7GbvdLj4ukJubKz7n5eXdyOEyTFBD/adFKc0+PPNhVFZVLpFjYpiShKqVfA0w4Q5fBwyDy6+DQpng9XqLT+gYDAa43W6kpaX96/v0dWZm5hV/hr5/pdu7XC7x+0qXLn3Zz3z44YcYNWrUZd+nyhHDMP9mV+F/DBOu8DXAMHwdMOFJfn4+kpKSiteMICIi4l9fk5r67/eud/srff8Cr732mjAvuIDJZELFihXFHNC1/hiGCWWookli//Tp00hMTPT34TBMicPXAMPwdcAwF7QEiRwyObsWNyR01Go15HL5ZdUbnU53WdXmAqVKlbri7RUKBVJTU6/4M1FRUeLjv5DI4QUeE+7QNcDXARPO8DXAMHwdMExSEYofN2RGEBkZiUaNGmHZsmX/+j593bx58yv+TLNmzS67/dKlS9G4ceMrzucwDMMwDMMwDMPcKjfsukYtZb/++ivGjh2LAwcO4PnnnxctZRdycajtbOjQoRdvT98/efKk+Dm6Pf0cGRH873//u+WDZxiGYRiGYRiGKZYZnf79+yM7OxvvvvuuCAytXbs2Fi1aJGZoCPrepZk6lStXFv9Ogui7774TvXRff/01evfuXeT7pDa2t99++4rtbAwTLvB1wIQ7fA0wDF8HDHMjRHiv58vGMAzDMAzDMAwT6q1rDMMwDMMwDMMwgQ4LHYZhGIZhGIZhQg4WOgzDMAzDMAzDhBwsdBiGYRiGYRiGCTkCXuh8//33wrktOjpaZPj89ddf/j4khilR1qxZg/vvv184FkZERGDevHn8CDBhxYcffogmTZogISEBWq0WPXr0wKFDh/x9WAxTovzwww+oW7fuxcBcyilcvHgxPwoME6xCZ/r06XjuuefwxhtvYMeOHWjZsiU6der0L/tqhgl1CgoKUK9ePXz77bf+PhSG8QurV6/Gk08+iY0bN4oAapfLhQ4dOohrg2HChXLlyuGjjz7C1q1bxUfbtm3RvXt37Nu3z9+HxjABS0DbS995551o2LCh2MW4QI0aNcRuHu3wMUy4QRWduXPnimuAYcIVvV4vKjskgO655x5/Hw7D+I2UlBR8+umneOihh/hRYJhgqug4HA5s27ZN7NpdCn29fv16vx0XwzAM419yc3MvLvIYJhxxu92YNm2aqGpSCxvDMFdGgQDFYDCICzktLe1f36evMzMz/XZcDMMwjP+gJoQXXngBd999N2rXrs0PBRNW7NmzRwgbm82G+Ph4UeGvWbOmvw+LYQKWgBU6l7bq/PdN7r/fYxiGYcKDp556Crt378batWv9fSgMU+Lccccd2LlzJ0wmE2bPno0HHnhAtHCy2GGYIBM6arUacrn8suqNTqe7rMrDMAzDhD5PP/00FixYIJwIaTCbYcKNyMhIVK1aVfx/48aNsWXLFnz11Vf46aef/H1oDBOQyAL5YiY7aXLYuRT6unnz5n47LoZhGKZkoUo+VXLmzJmDFStWiMgBhmGka8Nut/OpYJhgq+gQ1Ic9ZMgQsWtBPak///yzsJZ+7LHH/H1oDFNimM1m/P333xe/Pn78uGhdoEHsChUq8CPBhDxkLZ2RkYH58+eLLJ0Llf6kpCTExMT4+/AYpkR4/fXXRcRG+fLlkZ+fL8wIVq1ahSVLlvAjwDDBaC99ITD0k08+wfnz58Xg6RdffMF2okxYQW9kbdq0uez71Js9fvx4vxwTw5QkV5vLHDduHB588EF+MJiwgCykly9fLtZDJPIpPPSVV15B+/bt/X1oDBOwBLzQYRiGYRiGYRiGCZkZHYZhGIZhGIZhmJuFhQ7DMAzDMAzDMCEHCx2GYRiGYRiGYUIOFjoMwzAMwzAMw4QcLHQYhmEYhmEYhgk5WOgwDMMwDMMwDBNysNBhGIZhGIZhGCbkYKHDMAzDMAzDMEzIwUKHYRiGYRiGYZiQg4UOwzAMwzAMwzAhBwsdhmEYhmEYhmFCDhY6DMMwDMMwDMMg1Ph/+GQEdJvOKx0AAAAASUVORK5CYII=", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "hsm.plot(\"Observation\", 1)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Distributions of number of successive occurrences of values (\"runs\") and number of occurrences (not necessarily successive)" - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "metadata": {}, - "outputs": [], - "source": [ - "# Note that hsm.plot(\"Counting\", 1) replaces hsm.plot(\"NbRun\", 1) and hsm.plot(\"NbOccurrence\", 1)" - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "hsm.plot(\"Counting\", 1)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Distributions of the number of time steps required to observe a value again once you just stopped observing it" - ] - }, - { - "cell_type": "code", - "execution_count": 18, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "hsm.plot(\"Recurrence\", 1)\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Distributions of the number of time steps required to observe a value for the first time" - ] - }, - { - "cell_type": "code", - "execution_count": 19, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAA3EAAANCCAYAAADImkVPAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy80BEi2AAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOzdeVxU9f4/8NcwMMOOsoPAgOaCu2KpGKlpuLSrZXndfmnltdy43VtmXdFuWtY1rOtSqZktitfltplXUzFMS0VIU1JTEFSQRWURZZl5//7wy1yGGWBYZ4DX08c8Hs5nPudzPufMzHnznnPO56MQEQERERERERE1CzaW7gARERERERGZj0kcERERERFRM8IkjoiIiIiIqBlhEkdERERERNSMMIkjIiIiIiJqRpjEERERERERNSNM4oiIiIiIiJoRJnFERERERETNCJM4IiIiIiKiZoRJHFETWbVqFTZs2NAk6yoqKkJ0dDTi4uKaZH0t1cGDBzF9+nSEhYVBrVZDoVAgNTXV0t0iImowjE3ND2MTAUziiJpMUwfKRYsWMVDW0969e/HDDz8gKCgI4eHhlu4OEVGDY2xqfhibCGASR0QNoKioyNJdaBSvv/46UlNTsWPHDjz44IOW7g4REdUCYxO1ZEziiKpw8OBBDBs2DC4uLnB0dER4eDi+++47gzrR0dFQKBRGy27YsMHg8obg4GCcOnUKBw4cgEKhgEKhQHBwMAAgLi4OCoUCn3/+OaKiouDr6wsHBwcMHjwYiYmJBu0OGTIEQ4YMMVrf1KlT9e2lpqbCy8sLALBo0SL9+qZOnVrlttamD1OnToWzszNOnjyJyMhIuLi4YNiwYQCAa9euYebMmWjXrh1UKhXat2+PBQsWoLi42KANnU6HDz74AL1794aDgwPatGmDAQMG4OuvvzaoFxsbi4EDB8LJyQnOzs4YMWKEUX8uXLiAp556Cv7+/lCr1fDx8cGwYcOQlJSkr7Nv3z4MGTIEHh4ecHBwQFBQEMaOHVtjgLex4SGSiKwLYxNjE2MTAUziiEw6cOAA7r//fuTl5WHdunXYtGkTXFxc8PDDDyM2NrbW7e3YsQPt27dHnz59cPjwYRw+fBg7duwwqPPqq6/iwoULWLt2LdauXYsrV65gyJAhuHDhQq3W5efnh127dgEApk2bpl/f66+/XuOy5vahpKQEjzzyCO6//3589dVXWLRoEW7fvo2hQ4di48aNiIqKwnfffYeJEydi2bJlGDNmjMHyU6dOxZw5c3D33XcjNjYWmzdvxiOPPGJwTf+SJUvw9NNPo2vXrtiyZQs+++wzFBQUICIiAqdPn9bXGz16NBISErBs2TLs2bMHq1evRp8+fXDjxg0Ad/5wePDBB6FSqbB+/Xrs2rULb731FpycnFBSUlKrfUtEZEmMTYxNRHpCREYGDBgg3t7eUlBQoC8rKyuT7t27S0BAgOh0OhERWbhwoZj6Gn3yyScCQFJSUvRl3bp1k8GDBxvV3b9/vwCQvn376tsVEUlNTRU7OzuZPn26vmzw4MEm25gyZYpoNBr98+zsbAEgCxcuNGt7a9OHKVOmCABZv369QRtr1qwRALJlyxaD8rffflsAyO7du0VE5McffxQAsmDBgir7k5aWJra2tjJr1iyD8oKCAvH19ZUnn3xSRERycnIEgMTExFTZ1tatWwWAJCUl1bAXqvfOO+8YvadERE2JsanqPjA2pdSrHWp+eCaOqJKbN2/il19+wbhx4+Ds7KwvVyqVmDRpEi5duoQzZ840+HonTJhgcPmLRqNBeHg49u/f3+Draog+jB071uD5vn374OTkhHHjxhmUl18qs3fvXgDA999/DwB44YUXquzHf//7X5SVlWHy5MkoKyvTP+zt7TF48GD9TfHu7u7o0KED3nnnHSxfvhyJiYnQ6XQGbfXu3RsqlQrPPfccPv3001r/ekxEZA0YmxibiCpiEkdUyfXr1yEi8PPzM3rN398fAJCbm9vg6/X19TVZ1hjrqm8fHB0d4erqalCWm5sLX19fo/swvL29YWtrq28jOzsbSqXS5LrKXb16FQBw9913w87OzuARGxuLnJwcAIBCocDevXsxYsQILFu2DH379oWXlxdmz56NgoICAECHDh3www8/wNvbGy+88AI6dOiADh06YMWKFbXcO0RElsPYVHMfGJuoNbG1dAeIrE3btm1hY2ODjIwMo9euXLkCAPD09AQA2NvbAwCKi4uhVqv19coP5LWRmZlpsszDw0P/3N7eHnl5eUb16rK+uvYBgMkb5j08PPDLL79ARAxez8rKQllZmX6feXl5QavVIjMz0+QfI8D/9u/WrVuh0Wiq7bNGo8G6desAAGfPnsWWLVsQHR2NkpISrFmzBgAQERGBiIgIaLVaHDt2DB988AHmzp0LHx8fPPXUU9W2T0RkDRibqu8DwNhErQvPxBFV4uTkhP79+2P79u24deuWvlyn0+Hzzz9HQEAAOnXqBAD6UbdOnDhh0MY333xj1K5arTZor7JNmzZBRPTPL168iEOHDhmM+BUcHIyzZ88ajKiVm5uLQ4cOGa0LQLXrq2sfqjJs2DAUFhbiP//5j0H5xo0b9a8DwKhRowAAq1evrrKtESNGwNbWFufPn0e/fv1MPkzp1KkTXnvtNfTo0QPHjx83el2pVKJ///5YuXIlAJisQ0RkjRibGJuIKuKZOCITli5digceeABDhw7FSy+9BJVKhVWrVuG3337Dpk2b9L/mjR49Gu7u7pg2bRoWL14MW1tbbNiwAenp6UZt9ujRA5s3b0ZsbCzat28Pe3t79OjRQ/96VlYWHn/8cTz77LPIy8vDwoULYW9vj/nz5+vrTJo0CR9++CEmTpyIZ599Frm5uVi2bJnR5SMuLi7QaDT46quvMGzYMLi7u8PT01Mf2KtiTh+qMnnyZKxcuRJTpkxBamoqevTogYMHD2LJkiUYPXo0hg8fDuDOL4+TJk3CP/7xD1y9ehUPPfQQ1Go1EhMT4ejoiFmzZiE4OBiLFy/GggULcOHCBYwcORJt27bF1atXceTIETg5OWHRokU4ceIEXnzxRTzxxBPo2LEjVCoV9u3bhxMnTuCVV14BAKxZswb79u3Dgw8+iKCgINy+fRvr168HAH2fqpKdnY0DBw4AAE6ePAngzn0TXl5e8PLywuDBg2vcL0REDYWxibEJYGyi/2O5MVWIrFt8fLzcf//94uTkJA4ODjJgwAD55ptvjOodOXJEwsPDxcnJSdq1aycLFy6UtWvXGo0WlZqaKpGRkeLi4iIA9CN2lY++9dlnn8ns2bPFy8tL1Gq1REREyLFjx4zW9+mnn0poaKjY29tL165dJTY21mgEMBGRH374Qfr06SNqtVoAyJQpU6rc1tr0YcqUKeLk5GSyndzcXJkxY4b4+fmJra2taDQamT9/vty+fdugnlarlffee0+6d+8uKpVK3NzcZODAgUb79z//+Y8MHTpUXF1dRa1Wi0ajkXHjxskPP/wgIiJXr16VqVOnSpcuXcTJyUmcnZ2lZ8+e8t5770lZWZmIiBw+fFgef/xx0Wg0olarxcPDQwYPHixff/11lfuj8n4x9TA1EhsRUWNjbGJsYmwiERGFSIXz00TU5OLi4jB06FD8+9//Nho9qzX1gYiIrIc1xAVr6AORteI9cURERERERM0IkzgiIiIiIqJmhJdTEhERERERNSM8E0dERERERNSMMIkjIiIiIiJqRpjEERERERERNSOc7LuJ6HQ6XLlyBS4uLvrJOImIqGmICAoKCuDv7w8bG/5+WY6xiYjIMuobl5jENZErV64gMDDQ0t0gImrV0tPTERAQYOluWA3GJiIiy6prXGIS10RcXFwA3HmjXF1dLdwbIqLWJT8/H4GBgfpjMd3B2EREZBn1jUtM4ppI+WUqrq6uDJRERBbCSwYNMTYREVlWXeMSbwwgIiIiIiJqRpjEERERNYFVq1YhJCQE9vb2CAsLQ3x8fJV1MzIyMGHCBHTu3Bk2NjaYO3dutW1v3rwZCoUCjz32WMN2moiIrBKTOCIiokYWGxuLuXPnYsGCBUhMTERERARGjRqFtLQ0k/WLi4vh5eWFBQsWoFevXtW2ffHiRbz00kuIiIhojK4TEZEVqvU9cVqtFqWlpY3Rlyb15ZdfYt26dcjOzkbHjh0xf/589OvXr8r6JSUlWLlyJb755hvk5OTAx8cHM2bMwNixY81aX0lJCTQaDUpKSnD79u2G2gwiIgJgY2MDnU5X5euWPgZ/8cUXiIqKwsSJEwEAb731Fk6cOIHPP/8cUVFRRvV9fX3x9ttvAwC+/fZbuLq6muy3VqvFvHnz8NZbbyEhIQH5+fm12j5L7xciopZMpVI12rQ2ChERcyqKCDIzM3Hjxo1G6UhTunnzJnJycuDu7g57e3sUFBSgsLAQ/v7+sLU1nddmZWVBq9Wibdu2sLW1hVarBQCo1Wqz1qnT6ZCeno7AwEDOUURE1EBEBGVlZRARKJVKKJVKk/UseQwWEaSlpcHLywuOjo768mvXrqGkpAS+vr7VLp+ZmQmVSgV3d3ej127cuIGSkhJ4e3sjJycHOp0O3t7e1falYtjX6XS4fPkyYxMRUSOwsbFBSEgIVCqV0Wv5+flwc3NDXl5enQaWMvtMXHkC5+3tDUdHx2Y9wtf58+fRsWNHtGvXTl929uxZuLi4mAymBQUFuHXrFjp16lRlklcTrVaLW7duITg4uMo/MoiIqHays7NRUFAAT09P2NnZQalUmgyWljwGl5SUoKioCMHBwXByctKXOzk54caNGwgJCamxDbVaDX9/f4Oymzdvori4GN27d4ednR3s7Oyg1Wqh0WiqbCcrKwtZWVkGZZ6enoxNREQNTKfT4cqVK8jIyEBQUFCD505mZSRarVafwHl4eDRoB5qaTqfDrVu34O/vD3t7e315mzZtUFRUZFBW7urVq/pgm5ubCxsbG7Rp0wbt2rUz+5fL8jN39vb2DJRERA1Aq9WisLAQPj4+8PDwQFlZGUpLS6FWq42CpSWPweVxQq1WG8QYOzs72NjYmIw7lZe3tbU1qKfVanH58mWEhITo5xgq367q2gsICDD4AVOr1eLEiROMTUREjcDLywtXrlxBWVkZ7OzsGrRts5K48nvgKl4G0lyVlZUBgNGOtLOz079WWXFxMQoLC2FjY4O77roLZWVluHjxIrRaLYKDg00uo9PpDC5ZKf8DgoiIGkbl2FSeLImIVV0tUn4FR+X7yUtLS+t8dUdxcTFKSkpw7tw5o9eOHTuG7t27m0zmeMkkEVHTKb8yRKvVWiaJK2dNQdESQkJC9AE3MDAQ58+fR1BQkMmgmJmZiStXrjR1F4mIWh1rj002NjZwcnJCfn4+2rZtqy/Pz89HmzZt6tSmvb09unXrZlB2+fJlaLVaBAUFmbyklIiImlZjxqe6/QTYjNXlF1E7OzuoVCqD18t/4SwpKTH5a6evry98fHz0z8svWSEiotbHx8cHKSkpcHJygpOTE3JyclBSUgIvLy8AwKVLl1BaWmpwf1xRURGAO/GjrKwMRUVFUCgUcHBwgI2NDRwcHAzWUX45ZOVyIiJqeVrddRU//vgj7r77bqSnpxuU5+fnw9nZ2eQyzs7OKC0tNbgksri4GACq/LXTxsZGP1JadSOmWbvU1FQoFAokJSU1eNsfffSRfkS0mJgYREdHo3fv3g2+HrKc33//HQMGDIC9vT3fWzPFxcVBoVDoRwLesGFDnc/WVKfyd7vyehtzXa2Ru7s7AgMDceXKFZw+fRoFBQXo2LGjfoTj+Ph4tG/f3mD/nz59GqdPn0ZRURGuXbuG06dPm7x8sjVibKL6YGyqPcYm69OkSZxWp0Vcahw2ndyEuNQ4aHWNe5/YkCFDMHfuXIOy8PBwnD59GiUlJcjJycGtW7eQnp5u9ItoSkqKfhl3d3fY2toiNTUVt27dQkFBAdLT0+Hp6WkV9xcoFAr85z//qXc7U6dOxWOPPVbvdsyRn5+PF198ES+//DIuX76M5557Di+99BL27t1br3ZNvedkOQsXLoSTkxPOnDlT7/e2Oo35R1ZtAtWBAwcQFhYGe3t7tG/fHmvWrKn3+sePH4+zZ8+aVbc2fQ0MDERGRga6d+9ej94ZM3Ucaax1NZSmik3e3t7o2bMn/vKXv+Cjjz7SD0gCAGPHjkVGRgbc3Nz0Zf369TN69OzZs8r2Q0JCcNdddzVK3+uCsel/GJusS2uKTRkZGZgwYQI6d+4MGxubBvscMjZZXpNdTrk9eTvm7JqDS/mX9GUBrgFYMXIFxoSOaapuQKVSITQ0FFlZWbhy5QpKS0vh4OBg8ItoaWkpSkpK9MsolUp07NgR6enpSE5Ohq2tLdq2bWswwhfVTlpaGkpLS/Hggw/Cz89PX17V2VDgzqWrLfU+D61WC4VCYfSjQHPf5vPnz+PBBx+sdsjzliIlJQWjR4/Gs88+i88//xw//fQTZs6cCS8vL4wdO7bO7To4ODT45XHln6ua5idrKEqlssnWVVvWFJusdR+1JoxNhhibmr/i4mJ4eXlhwYIFeO+99xqsXcYmKyBmuHXrlpw+fVpu3bplTnUj205vE0W0QhANg4ciWiGKaIVsO72tTu1WZ8qUKQLA4JGSkiL79+8XAHL9+nUREfnkk0/Ezc1NvvnmG+nUqZM4ODjI2LFjpbCwUDZs2CAajUbatGkjL774opSVlenbLy4ulr/+9a/i7+8vjo6Ocs8998j+/fur7M8ff/whAOTYsWP6suvXrwsA/XLlffv222+lZ8+eolar5Z577pETJ05U2a5GozHYRo1Go39t1apV0r59e7Gzs5NOnTrJxo0bq2xn4cKFRvtr//79kpKSIgBk27ZtMmTIEHFwcJCePXvKoUOHDJb/6aefJCIiQuzt7SUgIEBmzZolhYWFJtf1ySefmHxvFi5cKL169dLXmzJlijz66KOyZMkS8fPz02/bypUr5a677hK1Wi3e3t4yduxYfX1T7Zpy7do1mTRpkrRp00YcHBxk5MiRcvbsWYM6Bw8elPvuu08cHBykTZs2EhkZKdeuXRMREa1WK2+99ZZ06NBBVCqVBAYGyj/+8Q8REaPPmIhIYmKiQX8qfu5CQ0NFqVTKhQsXRKPRyBtvvCFTpkwRV1dXmTx5sln7V6PRyJtvvin/7//9P3F2dpbAwED58MMPDbYnPT1dxo8fL23bthVHR0cJCwuTn3/+Wf/6119/LX379hW1Wi0hISESHR0tpaWlJvdf+T5YtGiRtGvXTlQqlfTq1Uu+//57/euV34uFCxeabOf27dsya9Ys8fLyErVaLYMGDZIjR47oXy/fVxXt2LFDyg9fpj5Pn3zyib4Pq1atkpEjR4q9vb0EBwfLli1b9O3U9F6Vv27Odvztb3+TLl26GJQ9//zzMmDAgCr3oYjId999Jx07dhR7e3sZMmSIfnsqH6PKJSUlyZAhQ8TZ2VlcXFykb9++cvTo0Wr7aupzVf7dTkxMNNgX1R1/Kn9HRUTee+89/XezpuNI+bpEROLi4uTuu+8WlUolvr6+8vLLLxt83gYPHiyzZs2Sv/71r9K2bVvx8fEx2veVY5NWq5WioiLRarVG+7msrEyOHj1qcBxnbGJsqoixibGpopYSmyoaPHiwzJkzp8Z6IoxN9YlNFVWXQ+Xl5QkAycvLq/H9MKXRk7gybZkELA8wCpIVg2Xg8kAp05bV3Fgt3LhxQwYOHCjPPvusZGRkSEZGhpSVlZkMlHZ2dvLAAw/I8ePH5cCBA+Lh4SGRkZHy5JNPyqlTp+Sbb74RlUolmzdv1rc/YcIECQ8Plx9//FH++OMPeeedd0StVhsdbMvVJlCGhobK7t275cSJE/LQQw9JcHCwlJSUmGw3KytLf2DIyMiQrKwsERHZvn272NnZycqVK+XMmTPyz3/+U5RKpezbt89kOwUFBfLkk0/KyJEj9furuLhY/wHv0qWLfPvtt3LmzBkZN26caDQa/Yf6xIkT4uzsLO+9956cPXtWfvrpJ+nTp49MnTrV5LqKiorkhx9+EABy5MgR/XtjKlA6OzvLpEmT5LfffpOTJ0/K0aNHRalUypdffimpqaly/PhxWbFiRbXvuSmPPPKIhIaGyo8//ihJSUkyYsQIueuuu/T7OTExUdRqtfz5z3+WpKQk+e233+SDDz6Q7OxsEbnzB3vbtm1lw4YN8scff0h8fLx8/PHHBu9jTYHSzs5OwsPD5aeffpLff/9dCgsLRaPRiKurq7zzzjty7tw5OXfunFn7V6PRiLu7u6xcuVLOnTsnS5cuFRsbG0lOTta/v+3bt5eIiAiJj4+Xc+fOSWxsrP4Pnl27domrq6ts2LBBzp8/L7t375bg4GCJjo42uf9ERJYvXy6urq6yadMm+f333+Vvf/ub2NnZ6b8DGRkZ0q1bN/nLX/4iGRkZUlBQYLKd2bNni7+/v+zcuVNOnTolU6ZMkbZt20pubq5+X1UXKIuKiuQvf/mLdOvWTf++FxUVicidQOnh4SEff/yxnDlzRl577TVRKpVy+vRps96r4uJiiYmJEVdXV33bVW1HRESEzJ4926Bs+/btYmtrW+X3Ny0tTdRqtcyZM0d+//13+fzzz8XHx6faQNmtWzeZOHGiJCcny9mzZ2XLli2SlJRUbV9Nfa6qCpTVHX9qCpQ1HUfK13Xp0iVxdHSUmTNnSnJysuzYsUM8PT0NAuHgwYPF1dVVoqOj5ezZs/Lpp5+KQqGQ3bt36+vUJ4ljbLqDsel/GJsYmypqKbGpInOTOMam+sWmiqw2ibtZclMSriRU+/jw2IdVBsmKjw+PfVhjWwlXEuRmyU2zN87Uh9VUoAQgf/zxh77O888/L46OjgZfiBEjRsjzzz8vIneCnkKhkMuXLxu0PWzYMJk/f77JvtQmUFYMyLm5ueLg4CCxsbFVbicA2bFjh0FZeHi4PPvsswZlTzzxhIwePbrKdsp/Xayo/AO+du1afdmpU6cEgP4gPGnSJHnuuecMlouPjxcbG5sqE//KgUPE+Es4ZcoU8fHxkeLiYn3Ztm3bxNXVVfLz8022a84B6uzZswJAfvrpJ31ZTk6OODg46H8Je/rpp2XQoEEml8/Pzxe1Wq0PjJWZGygBSFJSksGyGo1GHnvsMYMyc/avRqORiRMn6l/X6XTi7e0tq1evFhGRDz/8UFxcXPTBp7KIiAhZsmSJQdlnn30mfn5+JuuLiPj7+8ubb75pUHb33XfLzJkz9c979epV7S9UhYWFYmdnJ1988YW+rKSkRPz9/WXZsmUiUnOgFDF9ABe5892YMWOGQVn//v3lz3/+s4jU7pfpmnTs2NFof/z0008CQK5cuWJymfnz50toaKjodDp92csvv1xtoHRxcZENGzaYbK+qvpr6XFUVKKs7/tQUKEWqP46Ur+vVV1+Vzp07G2z3ypUrxdnZWZ+ADR48WO69916Ddu6++255+eWX9c9NJXE5eTly9NJRo9hxJP2IfPbDZ3Ik/QhjUwWMTYYYmxibRFpWbKrI3CSOsal+samixkzi6nVP3O85vyPso7D6NKH3/LfPm1Uv4bkE9PXr2yDrLOfo6IgOHTron/v4+CA4ONjgGngfHx9kZWUBAI4fPw4RQadOnQzaKS4uhoeHR737M3DgQP3/3d3d0blzZyQnJ9eqjeTkZDz33HMGZYMGDcKKFSvq1KeKN9OX3yeQlZWFLl26ICEhAX/88Qe++OILfR0RgU6nQ0pKCkJDQ+u0TgDo0aOHwXX3DzzwADQaDdq3b4+RI0di5MiRePzxx2s1EX35fY39+/fXl3l4eBjs56SkJDzxxBNVLl9cXIxhw4bVcavuUKlUJgcp6Nevn8Fzc/dvxbYUCgV8fX31n9mkpCT06dMH7u7uJvuSkJCAo0eP4s0339SXabVa3L59G0VFRUb7Nz8/H1euXMGgQYMMygcNGoRff/3VnM0HcOe+hNLSUoN27OzscM8999T6M1+Vit+n8ueNNRJV5flgRMRkebnk5GQMGDDA4PXK/a0sKioK06dPx2effYbhw4fjiSeeMDh+VaXy56oqDXH8qUlycjIGDhxosN2DBg1CYWEhLl26hKCgIAAw+n74+fnpP9NVOZN7BoM2Dqq6wsHa9ZWx6X8Ym/6HsYmxqb6aMjbVFmNTw8emxlCvJK6LZxckPJdQbZ1jV46ZFQQ/fOhD9POv+Y3s4tnF7P6Zq/IM6gqFwmSZTqcDAOh0OiiVSiQkJBhNHVDVzc/lNwWX/1EHGM9VV526TBZo6g/Kuk46WHF/lLdRcX88//zzmD17ttFy5R/4unJycjJ47uLiguPHjyMuLg67d+/G3//+d0RHR+Po0aNmj3xU8T2oXF6+bdXdrFvTjbzmvtcODg4m34/K22zu/q3uM1tTn3U6HRYtWoQxY4wHcjA1D2LFdVRU289YVUlOxXZsbGyM3rPafHdMqdh2xX7Up21fX19kZmYalGVlZcHW1rbKP6Cr+ixWJzo6GhMmTMB3332H77//HgsXLsTmzZvx+OOPV7tc5c9VbTT0e2Hqc2Lqs1DdZ7oqnT064+j0o0YDMWi1Wpw5cwadO3eGUqlkbPo/jE11w9jE2NRcYlNdMDYZllVcF1C32NQY6pXEOdo51vjLYy+fXnjjxzdwOf8yBMYfCgUUCHANwLQ+06C0adi51FQqlcHcbg2lT58+0Gq1yMrKQkREhFnLlE9fkJGRoS+r6heXn3/+WX8AvH79Os6ePYsuXar+A8HOzs5oO0NDQ3Hw4EFMnjxZX3bo0KFqf3ms6/7q27cvTp061WRDW9va2mL48OEYPnw4Fi5ciDZt2mDfvn0YM2aMWdvQtWtXlJWV4ZdffkF4eDgAIDc3F2fPnjX45XDv3r1YtGiR0fIdO3aEg4MD9u7di+nTpxu9XvG9btu2LYCq32tzNMT+7dmzJ9auXYtr166Z/MWzb9++OHPmjNnrcHV1hb+/Pw4ePIj77rtPX37o0CHcc889ZvfrrrvugkqlwsGDBzFhwgQAdw68x44d0w+D7OXlhYKCAty8eVN/sK+8P6t733/++WeD78HPP/+MPn366NsGqn+vzP1eDBw4EN98841B2e7du9GvXz+jA365rl27Gg3B/vPPP9e4rk6dOqFTp06YN28enn76aXzyySd4/PHHG+SYV93xx8vLC5mZmQaBri77q2vXrti2bZtBO4cOHYKLi0u9R/0tj0umkjhFpgJ9/PpAqVQyNv0fxqaGw9hUe4xNjR+b6oKxqeFjU2No9EnOlDZKrBh55zIJBQyz2/LnMSNjGjxIAkBwcDB++eUXpKamIicnp8Gy5E6dOuFPf/oTJk+ejO3btyMlJQVHjx7F22+/jZ07d5pcxsHBAT169MCyZctw+vRp/Pjjj3jttddM1l28eDH27t2L3377DVOnToWnp2e1c+QEBwdj7969yMzMxPXr1wEAf/3rX7FhwwasWbMG586dw/Lly7F9+3a89NJL1bZz4sQJnDlzBjk5OWb/ivHyyy/j8OHDeOGFF5CUlIRz587h66+/xqxZs8xavja+/fZbvP/++0hKSsLFixexceNG6HQ6dO7cWb8NNb3nHTt2xKOPPopnn30WBw8exK+//oqJEyeiXbt2ePTRRwEA8+fPx9GjRzFz5kycOHECv//+O1avXo2cnBzY29vj5Zdfxt/+9jds3LgR58+fx88//4x169YBuHPwDwwMRHR0NM6ePYvvvvsO//znP+u8zQ2xf59++mn4+vrisccew08//YQLFy5g27ZtOHz4MADg73//OzZu3Ijo6GicOnUKycnJiI2NrfIzCtz5jL399tuIjY3FmTNn8MorryApKQlz5swxu19OTk7485//jL/+9a/YtWsXTp8+jWeffRZFRUWYNm0aAKB///5wdHTEq6++ij/++ANffvklNmzYYNBOcHAwUlJSkJSUhJycHBQXF+tf+/e//43169fj7NmzWLhwIY4cOYIXX3wRgHnvVXBwMAoLC7F3717k5OSgqKjI5LbMmDEDFy9eRFRUFJKTk7F+/XqsW7eu2u/cjBkzcP78eURFReHMmTMmt62iW7du4cUXX0RcXBwuXryIn376CUePHtX/gWduX6tT3fFnyJAhyM7OxrJly3D+/HmsXLkS33//vcHy5hxHZs6cifT0dMyaNQu///47vvrqKyxcuBBRUVFNNvcmY9MdjE0Ng7GJsclaYxNwJ6FJSkpCYWEhsrOzkZSUhNOnT1dZn7HJcrGpVsy5ca6+UwyI3BnKufJIYIHLAxtlCOdyZ86ckQEDBoiDg4PRsKxV3ZgpYvoGyco3RJaUlMjf//53CQ4OFjs7O/H19ZXHH3+8yiGXy8rKZMuWLdK/f39xcHCQ3r17y+7du03ePP7NN99It27dRKVSyd133210g3FlX3/9tdx1111ia2tb52GcRe6MJvbAAw+Is7NztcOvVr7pXUTkyJEj+mWdnJykZ8+eRjcWV2TuzeOVb0KNj4+XwYMHS9u2bfVDSle8sd7Ue25K+TDObm5u4uDgICNGjDAavS0uLk7Cw8NFrVZLmzZtZMSIEfrPjVarlX/84x+i0WjEzs5OgoKCDG6+PnjwoPTo0UPs7e0lIiJC/v3vf5t1Q7JGo5H33nvPqLym/Wtquco3bqempsrYsWPF1dVVHB0dpV+/fvLLL7/oX9+1a5eEh4eLg4ODuLq6yj333CMfffSRyf1Xvg/Kh3G2s7MzGsbZVB9MuXXrlsyaNUs8PT1NDuMscudm8bvuukvs7e3loYceko8++sjg5vHbt2/L2LFjpU2bNvoR8UTu3Dy+cuVKeeCBB0StVotGo5FNmzYZtF3TeyUiMmPGDPHw8BCg+mGc4+LipE+fPqJSqSQ4OFh/8351vvnmG/2w5BEREbJ+/foqj1HFxcXy1FNPSWBgoKhUKvH395cXX3zR4Nhsqq+mPh9V3Txe0/Fn9erVEhgYKE5OTjJ58mR58803DY475h5HzBnGufIN+I8++qhMmTJF/7y+UwyIMDYxNhlibGJsKteSYhMAo0fF76QpjE11j00VNebAJgqRmi98vX37NlJSUhASElLtNcg10eq0iE+LR0ZBBvxc/BARFNEov3JaI61Wi8TERPTp08foXoVycXFxGDp0KK5fv272NfREVDWFQoEdO3ZUe7aAmq/KsUmn06G4uBhqtdrk5ZRVHYMZmxibiJoSY1PrUV0OlZ+fDzc3N+Tl5cHV1bXWbdfrnrjaUtooMSR4SFOukoiIqFqMTURE1NxY4QWeREREREREVJUmPRNH1RsyZEidhnUlItP4fSKqP8YmoobF7xM1BJ6JIyIiIiIiakaYxBERERERETUjtUriLDEbORERUXXKYxMvUSIiImvSmHHJrHviVCoVbGxscOXKFXh5eUGlUulnMifzlM8Sf/v27SqHcSYiIvOVJ2+XL1+Gh4cHbGxs9LGpcoziMdg07hciosYhIsjOzoZCoYCdnV2Dt29WEmdjY4OQkBBkZGTgypUrDd6J1kCn0yEnJwepqanWOes7EVEzpNPpUFRUhKKiItjY2ECpVJr8kZHHYNO4X4iIGo9CoUBAQECj/Ehm1mTf5UQEZWVl+l/uyHyFhYXo168fjh07BmdnZ0t3h4ioxagYxqq6SoTHYNO4X4iIGo+dnV2VCVyTTvZdfjqwMU4JtnQlJSW4ePEiVCqV0YztRETUuHgMNo37hYioeeK1E00s/mI8tDqeySQiam1WrVqFkJAQ2NvbIywsDPHx8VXWzcjIwIQJE9C5c2fY2Nhg7ty5RnU+/vhjREREoG3btmjbti2GDx+OI0eO1KlvjE1ERM0Lk7gm9tCXDyF4RTC2J2+3dFeIiKiJxMbGYu7cuViwYAESExMRERGBUaNGIS0tzWT94uJieHl5YcGCBejVq5fJOnFxcXj66aexf/9+HD58GEFBQYiMjMTly5dr3T/GJiKi5qVW98RR3ZVf94pXAIX9nXs2tj65FWNCx1i4Z0RELV997z2or/79+6Nv375YvXq1viw0NBSPPfYYli5dWu2yQ4YMQe/evRETE1NtPa1Wi7Zt2+Jf//oXJk+ebFa/GJuIiCyjvnGJZ+IsQHAnb567ay4vXyEiauFKSkqQkJCAyMhIg/LIyEgcOnSowdZTVFSE0tJSuLu712l5xiYiouaDSZyFCATp+emIT6v6nggiImr+cnJyoNVq4ePjY1Du4+ODzMzMBlvPK6+8gnbt2mH48OFV1ikuLkZ+fr7BoyLGJiKi5oFJnIVlFGRYugtERNQEKk9/ICJVTolQW8uWLcOmTZuwffv2akeZXLp0Kdzc3PSPwMBAk/UYm4iIrBuTOAvzc/GzdBeIiKgReXp6QqlUGp11y8rKMjo7VxfvvvsulixZgt27d6Nnz57V1p0/fz7y8vL0j/T0dJP1GJuIiKxbq03iajPUc1xcHBQKhdHj999/r/P6FVAg0DUQEUERdW6DiIisn0qlQlhYGPbs2WNQvmfPHoSHh9er7XfeeQdvvPEGdu3ahX79+tVYX61Ww9XV1eBREWMTEVHzUKvJvluK8qGeV61ahUGDBuHDDz/EqFGjcPr0aQQFBVW53JkzZwwCnpeXV53Wr8Cdy2diRsZAaWN6FnciImo5oqKiMGnSJPTr1w8DBw7ERx99hLS0NMyYMQPAnTNkly9fxsaNG/XLJCUlAQAKCwuRnZ2NpKQkqFQqdO3aFcCdSyhff/11fPnllwgODtaf6XN2doazs3Ot+8jYRETUfLTKKQZqO9RzXFwchg4diuvXr6NNmzZ1WmfFYZwDvQMRMzKGQzgTETURS08xANy5AmTZsmXIyMhA9+7d8d577+G+++4DAEydOhWpqamIi4vT1zd1v5xGo0FqaioAIDg4GBcvXjSqs3DhQkRHR5vVJ8YmIiLLqG9canVn4sqHen7llVcMys0Z6rlPnz64ffs2unbtitdeew1Dhw6t9fqHtR+G/077L3/lJCJqZWbOnImZM2eafG3Dhg1GZTX9xlqezDWExUMX49XhrzI2ERE1E60uiavLUM9+fn746KOPEBYWhuLiYnz22WcYNmwY4uLi9L+iVlZcXIzi4mL98/JhnBVQMEgSEZFV8XfxZ2wiImpGWl0SV642Qz137twZnTt31j8fOHAg0tPT8e6771aZxC1duhSLFi0yKs+9lVuPXhMRETW867euW7oLRERUC61udMqGGup5wIABOHfuXJWvVzWMc3ZRdt06TkRE1Eiu3b5m6S4QEVEttLokrqGGek5MTISfX9Xz6FQ1jHP2zewa73MgIiJqSjwTR0TUvLTKyylrO9RzTEwMgoOD0a1bN5SUlODzzz/Htm3bsG3btlqvu7isGIUlhXBRuzToNhEREdUVz8QRETUvrTKJGz9+PHJzc7F48WL9UM87d+6ERqMBAGRkZCAtLU1fv6SkBC+99BIuX74MBwcHdOvWDd999x1Gjx5dp/Vn3cxiEkdERFaDZ+KIiJqXVjlPnCVUnIvn0MxDGBg40NJdIiJqNaxhnjhrVL5fwt4Pw7FZxyzdHSKiVqO+canV3RNnDbJuZlm6C0RERHo8E0dE1LwwibMAJnFERGRNrt9mEkdE1JwwiWtiHo4eTOKIiMiqXL91HTrRWbobRERkJiZxTczL0YtJHBERWZ0bt29YugtERGQmJnFNzNPJkxN+ExGR1bl2i9MMEBE1F0zimhjPxBERkTXKLcq1dBeIiMhMTOKaGJM4IiKyRjwTR0TUfDCJa2Kejp5M4oiIyOrk3uKZOCKi5oJJXBPzcvRCdlE2RwEjIiKrobZV80wcEVEzwiSuiXk5eUEnOgZLIiKyGu4O7rwnjoioGWES18S8HL0AcMJvIiKyHm3t2/LHRSKiZoRJXBPzcmISR0RE1sXd0Z33xBERNSNM4pqYp6MnACZxRERkPXgmjoioeWES18Rc1a5QKVVM4oiIWplVq1YhJCQE9vb2CAsLQ3x8fJV1MzIyMGHCBHTu3Bk2NjaYO3euyXrbtm1D165doVar0bVrV+zYsaNOfXN34Jk4IqLmhElcE1MoFJwrjoiolYmNjcXcuXOxYMECJCYmIiIiAqNGjUJaWprJ+sXFxfDy8sKCBQvQq1cvk3UOHz6M8ePHY9KkSfj1118xadIkPPnkk/jll19q3T93e3eeiSMiakaYxFmAt5M3sm9mW7obRETURJYvX45p06Zh+vTpCA0NRUxMDAIDA7F69WqT9YODg7FixQpMnjwZbm5uJuvExMTggQcewPz589GlSxfMnz8fw4YNQ0xMTK3719ahLUenJCJqRpjEWYC3kzeyingmjoioNSgpKUFCQgIiIyMNyiMjI3Ho0KE6t3v48GGjNkeMGFGnNt0d3JFXnIcyXVmd+0NERE3H1tIdaI28nbyRciPF0t0gIqImkJOTA61WCx8fH4NyHx8fZGZm1rndzMzMWrdZXFyM4uJi/fP8/HwAd87EAcD1W9f1oygTEZH14pk4C/B28uY9cURErYxCoTB4LiJGZY3d5tKlS+Hm5qZ/BAYGArhzTxwA3hdHRNRMMImzACZxRESth6enJ5RKpdEZsqysLKMzabXh6+tb6zbnz5+PvLw8/SM9PR3A/87EcYRKIqLmgUmcBXg7eePG7Rso0ZZYuitERNTIVCoVwsLCsGfPHoPyPXv2IDw8vM7tDhw40KjN3bt3V9umWq2Gq6urwQO4c08cwDNxRETNBe+JswBvJ28AQPbNbLRzbWfh3hARUWOLiorCpEmT0K9fPwwcOBAfffQR0tLSMGPGDAB3zpBdvnwZGzdu1C+TlJQEACgsLER2djaSkpKgUqnQtWtXAMCcOXNw33334e2338ajjz6Kr776Cj/88AMOHjxY6/65qu8kc9+d/Q7OKmdEBEVAaaOs51YTEVFjYRJnAeVJXNbNLCZxREStwPjx45Gbm4vFixcjIyMD3bt3x86dO6HRaADcmdy78pxxffr00f8/ISEBX375JTQaDVJTUwEA4eHh2Lx5M1577TW8/vrr6NChA2JjY9G/f/9a96/vR30BAGsS1mBNwhoEuAZgxcgVGBM6po5bTEREjUkhImLpTrQG+fn5cHNzQ15eHm7IDWhiNNj1p10YcdcIS3eNiKjFq3gMLr+EkP63X/AKAPv/lStwZ3CUrU9uZSJHRNQI6huXeE+cBXg53hm+mYObEBGRNRLc+X137q650Oq0Fu4NERFV1mqTuFWrViEkJAT29vYICwtDfHy8Wcv99NNPsLW1Re/eveu8bgc7BzirnJFdlF3nNoiIiBqTQJCen474NPPiIxERNZ1WmcTFxsZi7ty5WLBgARITExEREYFRo0YZ3Y9QWV5eHiZPnoxhw4bVuw+cZoCIiJqDjIIMS3eBiIgqaZVJ3PLlyzFt2jRMnz4doaGhiImJQWBgIFavXl3tcs8//zwmTJiAgQMH1rsPTOKIiKg58HPxs3QXiIioklaXxJWUlCAhIQGRkZEG5ZGRkTh06FCVy33yySc4f/48Fi5c2CD9YBJHRETWTAEFAl0DEREUYemuEBFRJa1uioGcnBxotVr4+PgYlPv4+CAzM9PkMufOncMrr7yC+Ph42Nqat8uKi4tRXFysf56fn2/wurejN369+mste09ERNT4ykenjBkZw/niiIisUKs7E1dOoVAYPBcRozIA0Gq1mDBhAhYtWoROnTqZ3f7SpUvh5uamfwQGBhq8zjNxRERkLfxd/Q2eB7gGcHoBIiIr1uqSOE9PTyiVSqOzbllZWUZn5wCgoKAAx44dw4svvghbW1vY2tpi8eLF+PXXX2Fra4t9+/aZXM/8+fORl5enf6Snpxu8Xp7EcZo+IiKytN/+/Bs+e+wzAMB7I95DypwUJnBERFas1V1OqVKpEBYWhj179uDxxx/Xl+/ZswePPvqoUX1XV1ecPHnSoGzVqlXYt28ftm7dipCQEJPrUavVUKvVVfbD28kbt8pu4WbpTTirnOu4NURERPWntFHisdDHgP/ciU+8hJKIyLq1uiQOAKKiojBp0iT069cPAwcOxEcffYS0tDTMmDEDwJ2zaJcvX8bGjRthY2OD7t27Gyzv7e0Ne3t7o/La8HbyBnBnwm8mcUREZGnOKme4ql1xpeCKpbtCREQ1aJVJ3Pjx45Gbm4vFixcjIyMD3bt3x86dO6HRaAAAGRkZNc4ZV18Vk7j2bds36rqIiIjM4e/izySOiKgZUAhvymoS+fn5cHNzQ15eHlxdXXG18Cp8/+mLr576Co90fsTS3SMiatEqH4Ppjsr7ZdjGYfBy9MLmcZst3TUiohatvnGp1Q1sYi08HD0AANk3sy3cEyIiojt4Jo6IqHlgEmchtja28HDw4DQDRERkNfydmcQRETUHTOIsiHPFERGRNSk/E8c7LYiIrBuTOAvydvJGVhGTOCIisg7+Lv64VXYLecV5lu4KERFVg0mcBfFMHBERWRN/F38A4CWVRERWjkmcBTGJIyIia8IkjoioeWASZ0FM4oiIyJr4ufgBYBJHRGTtmMRZkLeTN7JvZkMnOkt3hYiICPa29nB3cGcSR0Rk5ZjEWZC3kze0osX1W9ct3RUiIiIAnCuOiKg5YBJnQd5O3gDASyqJiFqBVatWISQkBPb29ggLC0N8fHy19Q8cOICwsDDY29ujffv2WLNmjVGdmJgYdO7cGQ4ODggMDMS8efNw+/btevWTSRwRkfVjEmdBXo5eAJjEERG1dLGxsZg7dy4WLFiAxMREREREYNSoUUhLSzNZPyUlBaNHj0ZERAQSExPx6quvYvbs2di2bZu+zhdffIFXXnkFCxcuRHJyMtatW4fY2FjMnz+/Xn1lEkdEZP2YxFlQ+Zm47KJsC/eEiIga0/LlyzFt2jRMnz4doaGhiImJQWBgIFavXm2y/po1axAUFISYmBiEhoZi+vTpeOaZZ/Duu+/q6xw+fBiDBg3ChAkTEBwcjMjISDz99NM4duxYvfrq78wkjojI2jGJs6A29m1ga2PLM3FERC1YSUkJEhISEBkZaVAeGRmJQ4cOmVzm8OHDRvVHjBiBY8eOobS0FABw7733IiEhAUeOHAEAXLhwATt37sSDDz5YZV+Ki4uRn59v8Kis/EyciNRqO4mIqOkwibMghULBaQaIiFq4nJwcaLVa+Pj4GJT7+PggMzPT5DKZmZkm65eVlSEnJwcA8NRTT+GNN97AvffeCzs7O3To0AFDhw7FK6+8UmVfli5dCjc3N/0jMDDQqI6Pkw9KdaX4+PjHiEuNg1anre0mExFRI2MSZ2FM4oiIWgeFQmHwXESMymqqX7E8Li4Ob775JlatWoXjx49j+/bt+Pbbb/HGG29U2eb8+fORl5enf6Snpxu8vj15O174/gUAwPPfPo+hnw5F8IpgbE/ebv6GEhFRo7O1dAdaOyZxREQtm6enJ5RKpdFZt6ysLKOzbeV8fX1N1re1tYWHhwcA4PXXX8ekSZMwffp0AECPHj1w8+ZNPPfcc1iwYAFsbIx/p1Wr1VCr1SbXuT15O8ZtGQeB4WWUl/MvY9yWcdj65FaMCR1j3kYTEVGj4pk4C2MSR0TUsqlUKoSFhWHPnj0G5Xv27EF4eLjJZQYOHGhUf/fu3ejXrx/s7OwAAEVFRUaJmlKphIjU+n42rU6LObvmGCVwAPRlc3fN5aWVRERWgkmchXk7MokjImrpoqKisHbtWqxfvx7JycmYN28e0tLSMGPGDAB3LnOcPHmyvv6MGTNw8eJFREVFITk5GevXr8e6devw0ksv6es8/PDDWL16NTZv3oyUlBTs2bMHr7/+Oh555BEolcpa9e9Q+iFcyr9U5esCQXp+OuLTqp/bjoiImgYvp7QwnokjImr5xo8fj9zcXCxevBgZGRno3r07du7cCY1GAwDIyMgwmDMuJCQEO3fuxLx587By5Ur4+/vj/fffx9ixY/V1XnvtNSgUCrz22mu4fPkyvLy88PDDD+PNN9+sdf8yC00PsFJZRkFGrdsmIqKGpxCOIdwk8vPz4ebmhry8PLi6uurLP0n8BM98/QyKXyuGSqmyYA+JiFquqo7BrV35fvn2xLd4aPtDNdbfP2U/hgQPafyOERG1cPWNS7yc0sLKJ/zOKcqxcE+IiKi1Cg8MR4BrABQwPVqmAgoEugYiIiiiiXtGRESmMImzMC8nLwBA9s1sC/eEiIhaK6WNEitGrgAAo0Su/HnMyBgobWp3rx0RETUOJnEWVn4mjvfFERGRJY0JHYOtT25FO9d2BuUBrgGcXoCIyMowibMwL8c7Z+KYxBERkaWNCR2D1DmpiB0bCwBYcv8SpMxJYQJHRGRlmMRZmJPKCU52TkziiIjIKihtlBjXbRzUSjWcVE68hJKIyAq12iRu1apVCAkJgb29PcLCwhAfX/XcNwcPHsSgQYPg4eEBBwcHdOnSBe+9916D9YXTDBARkTWxUdigg3sH/HHtD0t3hYiITGiV88TFxsZi7ty5WLVqFQYNGoQPP/wQo0aNwunTpxEUFGRU38nJCS+++CJ69uwJJycnHDx4EM8//zycnJzw3HPP1bs/TOKIiMja3OV+F5M4IiIr1SrPxC1fvhzTpk3D9OnTERoaipiYGAQGBmL16tUm6/fp0wdPP/00unXrhuDgYEycOBEjRoyo9uxdbXg7eSOriEkcERFZjw5tO+D89fOW7gYREZnQ6pK4kpISJCQkIDIy0qA8MjIShw4dMquNxMREHDp0CIMHD26QPvFMHBERWZu73O9CyvUUlOnKLN0VIiKqpNVdTpmTkwOtVgsfHx+Dch8fH2RmZla7bEBAALKzs1FWVobo6GhMnz69yrrFxcUoLi7WP8/Pz6+yLpM4IiKyNne534VSXSnS89IR0jbE0t0hIqIKWt2ZuHIKheFkpiJiVFZZfHw8jh07hjVr1iAmJgabNm2qsu7SpUvh5uamfwQGBlZZl0kcERFZmw5tOwAA74sjIrJCrS6J8/T0hFKpNDrrlpWVZXR2rrKQkBD06NEDzz77LObNm4fo6Ogq686fPx95eXn6R3p6epV1vRy9UFRahJslN2u1LURERI1F00YDWxtb3hdHRGSFWl0Sp1KpEBYWhj179hiU79mzB+Hh4Wa3IyIGl0tWplar4erqavCoireTNwAguyjb7PUTERE1JlsbWwS3CeaZOCIiK9Tq7okDgKioKEyaNAn9+vXDwIED8dFHHyEtLQ0zZswAcOcs2uXLl7Fx40YAwMqVKxEUFIQuXboAuDNv3LvvvotZs2Y1SH/Kk7ism1kIbhPcIG0SERHVV4e2nCuOiMgatcokbvz48cjNzcXixYuRkZGB7t27Y+fOndBoNACAjIwMpKWl6evrdDrMnz8fKSkpsLW1RYcOHfDWW2/h+eefb5D+VEziiIiIrEX7tu3x/R/fY9PJTfBz8UNEUASUNkpLd4uIqNVTiIhYuhOtQX5+Ptzc3JCXl2d0aWWpthSqf6iw7pF1eKbPMxbqIRFRy1XdMbg1q26/bE/ejme+egZ5xXn6sgDXAKwYuQJjQsc0dVeJiFqU+salVndPnDWyU9rB3cGdZ+KIiMgqbE/ejnFbxhkkcABwOf8yxm0Zh+3J2y3UMyIiApjEWQ1OM0BERNZAq9Nizq45EBhfqFNeNnfXXGh12qbuGhER/R8mcVaCSRwREVmD+LR4XMq/VOXrAkF6fjri0+KbsFdERFQRkzgrwSSOiIisQUZBRoPWIyKihsckzkp4OzKJIyJqyVatWoWQkBDY29sjLCwM8fHVn8k6cOAAwsLCYG9vj/bt22PNmjVGdW7cuIEXXngBfn5+sLe3R2hoKHbu3Fmvfvq5+DVoPSIianhM4qwEz8QREbVcsbGxmDt3LhYsWIDExERERERg1KhRBtPZVJSSkoLRo0cjIiICiYmJePXVVzF79mxs27ZNX6ekpAQPPPAAUlNTsXXrVpw5cwYff/wx2rVrV6++RgRFIMA1AAooTL6ugAKBroGICIqo13qIiKjuWuU8cdbIy8kL2UXZEBEoFKYDJxERNU/Lly/HtGnTMH36dABATEwM/vvf/2L16tVYunSpUf01a9YgKCgIMTExAIDQ0FAcO3YM7777LsaOHQsAWL9+Pa5du4ZDhw7Bzs4OAPTzndaH0kaJFSNXYNyWcVBAYTDASXliFzMyhvPFERFZEM/EWQlvJ2+U6cpw4/YNS3eFiIgaUElJCRISEhAZGWlQHhkZiUOHDplc5vDhw0b1R4wYgWPHjqG0tBQA8PXXX2PgwIF44YUX4OPjg+7du2PJkiXQaqseNbK4uBj5+fkGD1PGhI7B1ie3op2r4Vm9ANcAbH1yK+eJIyKyMCZxVsLbyRsAeEklEVELk5OTA61WCx8fH4NyHx8fZGZmmlwmMzPTZP2ysjLk5OQAAC5cuICtW7dCq9Vi586deO211/DPf/4Tb775ZpV9Wbp0Kdzc3PSPwMDAKuuOCR2D1Dmp2Dd5H1xULpjSawpS5qQwgSMisgJM4qwEkzgiopat8qXyNV0+b6p+xXKdTgdvb2989NFHCAsLw1NPPYUFCxZg9erVVbY5f/585OXl6R/p6enV9llpo8TQkKHoH9AfecV5vISSiMhK8J44K8EkjoioZfL09IRSqTQ665aVlWV0tq2cr6+vyfq2trbw8PAAAPj5+cHOzg5K5f8Sq9DQUGRmZqKkpAQqlcqoXbVaDbVaXett6O3TG1uTt9Z6OSIiahw8E2cl2ti3ga2NLZM4IqIWRqVSISwsDHv27DEo37NnD8LDw00uM3DgQKP6u3fvRr9+/fSDmAwaNAh//PEHdDqdvs7Zs2fh5+dnMoGrj96+vZF6I5X3bRMRWQkmcVbCRmEDL0cvJnFERC1QVFQU1q5di/Xr1yM5ORnz5s1DWloaZsyYAeDOZY6TJ0/W158xYwYuXryIqKgoJCcnY/369Vi3bh1eeuklfZ0///nPyM3NxZw5c3D27Fl89913WLJkCV544YUG739v394AgF8zf23wtomIqPZ4OaUV4VxxREQt0/jx45Gbm4vFixcjIyMD3bt3x86dO/VTAmRkZBjMGRcSEoKdO3di3rx5WLlyJfz9/fH+++/rpxcAgMDAQOzevRvz5s1Dz5490a5dO8yZMwcvv/xyg/e/s2dnqGxU+Pfpf+NKwRX4ufghIiiC98gREVmIQsrvlKZGlZ+fDzc3N+Tl5cHV1dVkncjPIuFm74Z/P/HvJu4dEVHLZs4xuDUyd79sT96Op7Y+hVJdqb4swDUAK0au4GiVRER1UN+4xMsprQjPxBERkbXZnrwd47aMM0jgAOBy/mWM2zIO25O3W6hnREStF5M4K8J74oiIyJpodVrM2TUHAuOLdsrL5u6aC62u6gnGiYio4TGJsyLeTt7Ivplt6W4QEREBAOLT4nEp/1KVrwsE6fnpiE+Lb8JeERERkzgr4u3kjdxbuSjTlVm6K0RERMgoyGjQekRE1DCYxFmR8gm/c4pyLNwTIiIiwM/Fr0HrERFRw2ASZ0XKkzjeF0dERNYgIigCAa4BUEBh8nUFFAh0DUREUEQT94yIqHVjEmdFmMQREZE1UdoosWLkCgAwSuTKn8eMjOF8cURETYxJnBVhEkdERNZmTOgYbH1yK9q5tjMoD3ANwNYnt3KeOCIiC7C1dAfof5xUTnC0c2QSR0REVmVM6Bg82vlRxKfF45mvnkEH9w7Y9addPANHRGQhPBNnZTjhNxERWSOljRJDgofg8S6P40zOGdgo+CcEEZGltNoj8KpVqxASEgJ7e3uEhYUhPr7qOW62b9+OBx54AF5eXnB1dcXAgQPx3//+t1H6xSSOiIis2b1B9yI9Px3v//I+4lLjONE3EZEFtMokLjY2FnPnzsWCBQuQmJiIiIgIjBo1CmlpaSbr//jjj3jggQewc+dOJCQkYOjQoXj44YeRmJjY4H1jEkdERNZqe/J2vPj9iwCAuf+di6GfDkXwimBsT95u4Z4REbUuChERS3eiqfXv3x99+/bF6tWr9WWhoaF47LHHsHTpUrPa6NatG8aPH4+///3vZtXPz8+Hm5sb8vLy4OrqWmW9Z756Bsk5yTg87bBZ7RIRUc3MPQa3NrXZL9uTt2PclnEQGP7ZUD5KJQc5ISIyX33jUqs7E1dSUoKEhARERkYalEdGRuLQoUNmtaHT6VBQUAB3d/cG7x/PxBERkbXR6rSYs2uOUQIHQF82d9dcXlpJRNREWl0Sl5OTA61WCx8fH4NyHx8fZGZmmtXGP//5T9y8eRNPPvlklXWKi4uRn59v8DAHkzgiIrI28WnxuJR/qcrXBYL0/HTEp1V9fzkRETWcVpfElVMoDCctFRGjMlM2bdqE6OhoxMbGwtvbu8p6S5cuhZubm/4RGBhoVr+8nbxRWFKIotIis+oTERE1toyCjAatR0RE9dPqkjhPT08olUqjs25ZWVlGZ+cqi42NxbRp07BlyxYMHz682rrz589HXl6e/pGenm5W/8on/M6+mW1WfSIiosbm5+LXoPWIiKh+Wl0Sp1KpEBYWhj179hiU79mzB+Hh4VUut2nTJkydOhVffvklHnzwwRrXo1ar4erqavAwR3kSx0sqiYjIWkQERSDANUA/iEllCigQ6BqIiKCIJu4ZEVHr1OqSOACIiorC2rVrsX79eiQnJ2PevHlIS0vDjBkzANw5izZ58mR9/U2bNmHy5Mn45z//iQEDBiAzMxOZmZnIy8tr8L4xiSMiImujtFFixcgVAFBlIhczMgZKG2VTdouIqNVqlUnc+PHjERMTg8WLF6N379748ccfsXPnTmg0GgBARkaGwZxxH374IcrKyvDCCy/Az89P/5gzZ06D983T0RMAkzgiIrIuY0LHYOuTW9HOtZ1BuZ2NHeYMmAN3B3eOTklE1ERaZRIHADNnzkRqaiqKi4uRkJCA++67T//ahg0bEBcXp38eFxcHETF6bNiwocH7pVKq0Na+LZM4IqIWZtWqVQgJCYG9vT3CwsIQH1/9SI4HDhxAWFgY7O3t0b59e6xZs6bKups3b4ZCocBjjz3WwL02NCZ0DFLnpGL/lP2Y238unOycUKorRczPMZz4m4ioCbXaJM6acZoBIqKWJTY2FnPnzsWCBQuQmJiIiIgIjBo1yuCqj4pSUlIwevRoREREIDExEa+++ipmz56Nbdu2GdW9ePEiXnrpJURENM39aEobJa7duoYVv6zAzdKbBq9dzr+McVvGMZEjImpkTOKskLeTN7KKmMQREbUUy5cvx7Rp0zB9+nSEhoYiJiYGgYGBWL16tcn6a9asQVBQEGJiYhAaGorp06fjmWeewbvvvmtQT6vV4k9/+hMWLVqE9u3bN8WmcOJvIiIrwCTOCnk5eXGKASKiFqKkpAQJCQmIjIw0KI+MjMShQ4dMLnP48GGj+iNGjMCxY8dQWlqqL1u8eDG8vLwwbdo0s/pSXFyM/Px8g0dtceJvIiLLYxJnhbwdeTklEVFLkZOTA61WazQXqY+Pj9GcpeUyMzNN1i8rK0NOTg4A4KeffsK6devw8ccfm92XpUuXws3NTf8IDAys5dZw4m8iImvAJM4K8Z44IqKWR6EwHJpfRIzKaqpfXl5QUICJEyfi448/hqenp9l9mD9/PvLy8vSP9PT0WmzBHZz4m4jI8mwt3QEyVp7E1RTgiYjI+nl6ekKpVBqddcvKyjI621bO19fXZH1bW1t4eHjg1KlTSE1NxcMPP6x/XafTAQBsbW1x5swZdOjQwahdtVoNtVpdr+0pn/j7cv5lk/fFAYCXoxfCA8LrtR4iIqoaz8RZIW8nb5TqSpFX3PCTiRMRUdNSqVQICwvDnj17DMr37NmD8HDTic7AgQON6u/evRv9+vWDnZ0dunTpgpMnTyIpKUn/eOSRRzB06FAkJSXV6TJJc5kz8Xd2UTY6fNCBo1QSETUSJnFWyNvJGwAn/CYiaimioqKwdu1arF+/HsnJyZg3bx7S0tIwY8YMAHcuc5w8ebK+/owZM3Dx4kVERUUhOTkZ69evx7p16/DSSy8BAOzt7dG9e3eDR5s2beDi4oLu3btDpVI16vZUNfF3RZxugIio8TCJs0JM4oiIWpbx48cjJiYGixcvRu/evfHjjz9i586d0Gg0AICMjAyDOeNCQkKwc+dOxMXFoXfv3njjjTfw/vvvY+zYsZbaBCNjQsfg/Kzz8HL0Mvk6pxsgImo8Cim/U5oaVX5+Ptzc3JCXlwdXV9dq6+YW5cLzHU9se3IbxoSOaaIeEhG1XLU5Brcm9d0vcalxGPrp0Brr7Z+yH0OCh9Shh0RELVN9j788E2eF2jq0hVKh5Jk4IiKyapxugIjIMpjEWSEbhQ28nLyYxBERkVUzdxqB8tsEiIioYTCJs1JejkziiIjIupVPN1DVKJXlpv5nKgc4ISJqQEzirJS3kzeyi7It3Q0iIqIqmTPdAABcLuBIlUREDYlJnJUqn/CbiIjImpVPN+Dv4l9lHY5USUTUsJjEWSkmcURE1FyMCR2DTx/7tNo6AkF6fjri0+KbqFdERC0XkzgrxSSOiIiaE3Nj1uX8y43cEyKilo9JnJXydvJGblEuynRllu4KERFRjcwdqXLef+fx3jgionpiEmelvJ28IRDkFuVauitEREQ1MnekypyiHA5yQkRUT0zirFT5nDq8pJKIiJqDiiNVVoeDnBAR1R+TOCvFJI6IiJqb8pEqPR09q61XPshJXGpc03SMiKiFYRJnpZjEERFRczQmdAxiRsSYVffJrU/yskoiojpgEmelnOyc4GDrwCSOiIianXau7cyqd+3WNd4fR0RUB0zirJRCoYCXkxeyi7It3RUiIqJaMXeQE+DOpZUzvp2BkrKSJugZEVHLwCTOinGuOCIiao7MHeSkXHZRNgLeC+AZOSIiM7XaJG7VqlUICQmBvb09wsLCEB8fX2XdjIwMTJgwAZ07d4aNjQ3mzp3bJH1kEkdERM1V+SAn7g7uZtXPLsrmpZVERGZqlUlcbGws5s6diwULFiAxMREREREYNWoU0tLSTNYvLi6Gl5cXFixYgF69ejVJH7U6LbQ6LU5nn0ZcahyHYSYiomZnTOgYbBm3pVbLcOoBIqKatcokbvny5Zg2bRqmT5+O0NBQxMTEIDAwEKtXrzZZPzg4GCtWrMDkyZPh5ubW6P3bnrwdwSuC8d/z/8W5a+cw9NOhCF4RzF8niYio2RkSPKRW98dx6gEiopq1uiSupKQECQkJiIyMNCiPjIzEoUOHLNSr/9mevB3jtozDpfxLBuWX8y/zMhMiImp2ant/HMCpB4iIatLqkricnBxotVr4+PgYlPv4+CAzM7PB1lNcXIz8/HyDR020Oi3m7JoDgRi9Vl7Gy0yIiKi5MXcS8HLXbl3D2C1j8e9T/27knhERNU+tLokrp1AYXtYhIkZl9bF06VK4ubnpH4GBgTUuE58Wb3QGzqCP/3eZSXxa1YOwEBGRdarNgFoAcODAAYSFhcHe3h7t27fHmjVrDF7/+OOPERERgbZt26Jt27YYPnw4jhw50pibUC9jQsfg8rzL8HL0MnuZp7c9ja2ntjZir4iImqdWl8R5enpCqVQanXXLysoyOjtXH/Pnz0deXp7+kZ6eXuMyGQUZZrVtbj0iIrIOtR1QKyUlBaNHj0ZERAQSExPx6quvYvbs2di2bZu+TlxcHJ5++mns378fhw8fRlBQECIjI3H58uWm2qxaU9mqsOahNWbdHwcAWtHiia1P8NJKIqJKWl0Sp1KpEBYWhj179hiU79mzB+Hh4Q22HrVaDVdXV4NHTfxc/Mxq20bR6t42IqJmrbYDaq1ZswZBQUGIiYlBaGgopk+fjmeeeQbvvvuuvs4XX3yBmTNnonfv3ujSpQs+/vhj6HQ67N27t6k2q05qO/UAAE4GTkRUSavMBqKiorB27VqsX78eycnJmDdvHtLS0jBjxgwAd86iTZ482WCZpKQkJCUlobCwENnZ2UhKSsLp06cbtF8RQRE1juBlo7DBpB2TMHfXXFwtvGr0ulanRVxqHDad3MSpCYiIrEBdBtQ6fPiwUf0RI0bg2LFjKC0tNblMUVERSktL4e5ufnJkKbWdeoCTgRMRGbK1dAcsYfz48cjNzcXixYuRkZGB7t27Y+fOndBoNADuTO5d+RKXPn366P+fkJCAL7/8EhqNBqmpqQ3Wr/IRvMZtGQcFFAYDnJQndhsf34jU66l459A7WHt8LeYOmIuXwl9CG/s22J68HXN2zTG4ry7ANQArRq7AmNAxDdZPIiIyX10G1MrMzDRZv6ysDDk5OfDzM75y45VXXkG7du0wfPjwKvtSXFyM4uJi/XNzBt1qLOVTD1R3L3hF2UXZGLtlLBYNWYQFEQugtFE2cg+JiKxXqzwTBwAzZ85EamoqiouLkZCQgPvuu0//2oYNGxAXF2dQX0SMHg2ZwJUrv8yknWs7g/IA1wBsfXIr/tTjT1hw3wJcmHMBs+6ZheWHlyNkRQgmbp/IqQmIiKxYbQfUMlXfVDkALFu2DJs2bcL27dthb29fZZt1GXSrsdRl6gEAWBi3EMExnDuViFq3VpvEWbMxoWOQOicV+6fsx5djvsT+KfuRMifF4Gyau4M7lg5fivOzz2NC9wn44uQXnJqAiMgK1WVALV9fX5P1bW1t4eHhYVD+7rvvYsmSJdi9ezd69uxZbV/qMuhWYyq/rFKpqN1ZtUsFlzB2y1gsPrCYsY2IWiUmcVZKaaPEkOAheLrH0xgSPKTKy0b8XPzwRLcnqm2LUxMQEVlOXQbUGjhwoFH93bt3o1+/frCzs9OXvfPOO3jjjTewa9cu9OvXr8a+1GXQrcb2RLcnsHns5joty7NyRNRaMYlrAeo7NQEHQyEialy1HVBrxowZuHjxIqKiopCcnIz169dj3bp1eOmll/R1li1bhtdeew3r169HcHAwMjMzkZmZicLCwibfvvoa120ctj25zezJwCviWTkiao1a5cAmLY25UxOczT2LUm0p7JT/+xWXg6EQETW+2g6oFRISgp07d2LevHlYuXIl/P398f7772Ps2LH6OqtWrUJJSQnGjRtnsK6FCxciOjq6SbarIY0JHYOHOj6EgPcCkF2UXevlF8YtxAe/fICJvSbi0c6PIiIogoOfEFGLpZDyO6WpUeXn58PNzQ15eXkNfvmKVqdF8IpgXM6/bPK+OABQK9Uo1hajnUs7zOg3A8+FPYeDaQcxbss4o2XKR8Lc+uRWJnJE1CI05jG4ObPG/bI9ebvJ2FRb/EGSiKxZfY+/vJyyBag4wlflOeYU//fvy7FfIun5JIzuOBpL4pcgYHkAJu2YxMFQiIjIquhHaXZpV3PlalzK52WWRNRyMYlrIWqammBM6Bj08u2Fjx7+CJejLmNan2koKi2qsj0OhkJERJYyJnQMLs69iEVDFtW7rYVxC+H9jjeTOSJqUXg5ZRNpqktWtDot4tPikVGQAT8XvyrvCdh0chMmbJ9QY3tfjvkST/d4us7rISKyBtZ42aA1aA77ZXvydsz+fjYuF1yud1uuKlc80/cZ3jNHRBZX3+MvBzZpYcqnJqiJuYOhpN5IRYm2BCqlSl/GwVCIiKipjAkdg0c7P4o349/EwriF9WorvyQfMT/HIObnGHg6emJiTw6CQkTNE8/ENRFr+7XTnMFQbG1sUaYrQxv7NhjTZQzGdx+PvNt5GL91PAdDIaJmxdqOwdaiue2XhjwrVxETOiJqavU9/jKJayLWGCjLRwADYJCUlSdk/37i3+jk0Qmxp2IReyoWf1z7AzYKG+hEZ7I9BRQIcA1AypwUkwGQl2ASkaVY4zHYGjTH/aLVaRvkrFxVmNARUVNgEtdMWGugNHVpZKBrIGJGxhicURMRfJTwEWZ8N6PGNvdP2W90SScvwSQiS7LWY7ClNef9YiquNDQmdETUWJjENRPWHCgbejCUv9/3d7x232v6ScWrmvOHl2ASUVOx5mOwJTX3/VIev776/St8fuJz5NzKabR1MaEjoobEJK6ZaO6BEgDiUuMw9NOhZtV1Ubng/pD7Mbz9cLwZ/yYyCzNN1uMlmETUFFrCMbgxtKT90tiXWVbk7uCOWffMQkRQBLJuZjE+EVGtMYlrJlpCoKxpMBQFFGjn2g5bn9iKvSl78d/z/8XBtINV3kNXES/BJKLG1BKOwY2hJe6X7cnb8dw3zyH3Vm6Trpdn6oioNpjENRMtJVDWNBhK5Usj1yeux7Svp9XY7mePf4aJPScarYeXYBJRQ2gpx+CG1lL3S/lZuRW/rMC1W9eafP3lCd1DHR8CAJ6tIyIjTOKaiZYUKM0dDAUw/xJMtVKN/gH9MTBgIO72vxuzvp+FjMIMk3V5CSYR1VZLOgY3pJa+XyreM/fFyS+QXZRt0f4wuSOickzimomWFijNTZTMuQTTy8kLLw18Cb9c/gWHLx3GlYIrZvWhIS/BZOJH1LK1tGNwQ2lN+8XaErqKPB09MaHHBIS0CYGXoxfaubZjHCJq4ZjENROtKVBWVttLMP/1y78wa9esGtt94e4X8HzY8+js2RkqparOl2Dy3juilq81H4Or01r3izUndOVMnbXzdvLW/58/OBI1b0zimonWGijLNcYlmOXsbOzQ2aMzLty4gKLSIpN1qroEsz733vHsHVHz0dqPwVXhfmkeCV1VmOgRNV9M4poJBsqGvQQzwDUAx587juScZJy4egL/Pf9ffHP2mxr78N6I9/BE1yfg5+IHEUHwiuAqJ4qt7t47XrZJ1LzwGGwa94uh5pzQVaXydAgVkzwmfESWwySumWCgrJ3aXoJp7kTk5RxsHeDj7IPUG6k11q18711TX7bJxI+o/ngMNo37pWoVE7r1ieuRX5Jv6S41uurO7GUWZiK7KBtejl7wdfbVv864RFQ3TOKaCQbK2muMSzA/fexTuDu441zuOXx/7nvsSdlT4zIjOozA8PbDEeQWBH9nfzy59claj5zZHBI/JovUkvEYbBr3i3ksPWWBtavpss6a/l8xQeSgLtRaMIlrJhgo66ahL8GsmFyZm/gFuQbh2u1rKCwpNLvfK0evxOiOo+Hj5AOVUlWnyzabMvFjskgtHY/BpnG/1E7F41d5AvLt2W9bzKWX1qIhk8KKZw1r0wbPMlJjYxLXTDBQNr7aXoJZm8TPRmGDvOI8fHjsQ7yy95Va9cvB1gG3ym7VWO/zxz/HqI6j0Ma+TZ3v16tL4sdkkcu0BjwGm8b90jBa4r10dEfl6R/qkxQ2ZsLZWO01dtutOTYxiaujVatW4Z133kFGRga6deuGmJgYREREVFn/wIEDiIqKwqlTp+Dv74+//e1vmDFjhtnrY6BsGrW5BLO8fm0SP3PP3q19eC2C3IJw9eZV7Dq3C1/89oXZ26CAAs4qZxSUFNRY9+3hbyMiKAKualc4q5wRvj68ynn2TCV+5Yksk0UuU5E1J5l1XWbXqV14qOdDFj0GN0bc2bZtG15//XWcP38eHTp0wJtvvonHH3/c7D4xNjU8nq0jqh1zB99pSQlsZmEm0rPTMX/4fCZxtREbG4tJkyZh1apVGDRoED788EOsXbsWp0+fRlBQkFH9lJQUdO/eHc8++yyef/55/PTTT5g5cyY2bdqEsWPHmrVOBsqmU9s/8mqT+DXmZZvLI5cjyC0IubdysS9lH2JPxZq7ybXycKeH0dG9I5xVzrhaeBUfHv+wxmW+e/o7RN4VCVsb2zolftaeLHIZw2WtNcms1zJZl4C3YLFjcGPEncOHDyMiIgJvvPEGHn/8cezYsQN///vfcfDgQfTv39+sfjE2NR0md0Rk4DbqFZdaZRLXv39/9O3bF6tXr9aXhYaG4rHHHsPSpUuN6r/88sv4+uuvkZycrC+bMWMGfv31Vxw+fNisdTJQWrfaJH6NedlmbRO/2LGx6OrdFfnF+fjq96+w7NCyGpcJaRMCta0ahSWFuHbrWpVz65liZ2MHO6WdWcuM7DASIW1DoFaqcfXmVWz6bVONy7wz/B3c3e5uqJQqKBVKPLL5EVy9edVkXQUUaOfaDimzU2CrtAVQt2SRy/yPNSeZ9V6mnsGyvhoj7owfPx75+fn4/vvv9XVGjhyJtm3bYtOmmr9vAGOTNSiPP5fzLyO7KBup11Px5W9fMrEjaunqGZdsG75H1q2kpAQJCQl45RXD+5oiIyNx6NAhk8scPnwYkZGRBmUjRozAunXrUFpaCjs7u0brLzUNpY3SYBqB6owJHYOtT241eUbA1Nk7pY0SK0auwLgt46CAwmTiFzMyxuAP6oigCAS4BtSY+I3tOla/XIm2xKwkbv2j6/Xbam6y+Pp9ryOkTQhuld3CobRDZl0eev76eVy9eRXF2mLkFOXUWB8A/vrDX82qB9xJoC/lX4LdP+xgZ2MHWxtbKBSKahNMgSA9Px09VveAh6MHbG1skX87v8qEp+Iyj2x6BIFugVAqlMgozDBrmT9/92d0dO8IG4UNLly/YNYyf9//d3Tz7gYbhQ1OZ582a5nlh5ejj18fKKDAiasnzFpm7fG16OffDwqFAgoooBMdZn430+TnTSBQQIEXdr6Arp5dobRRQqFQQKfT4YWdL1S7zKyds9DPrx9slbZQQAGtTosXd75Y7TKzv5+NewPv1SfnOp0Os76fVeMyw0KG3enb/61n9vezTS7T1Bor7hw+fBjz5s0zqhMTE9Og/afGZSr+/HPEP43O2lW8FItn8Iio1SVxOTk50Gq18PHxMSj38fFBZmamyWUyMzNN1i8rK0NOTg78/PyMlikuLkZxcbH+eV5eHoA7v3pS8ze83XCc+H8ncCj9EDILM+Hr7IvwwHAobZQm3+Ph7YZj4+iNePmHl3El/3/3rPm7+uOt4W9heLvhRsstvXcpJm2fZHL9AsGS0Utws/CmvqxXm17wV/kbtF9ZO9d26NWml35d5i4zr888fbKosdfgi2M1J3HvDXkPEZo79/vEX4zHQ18+VOMy6x9dj96+vVGqK8V3577D4rjFNS4zuddk9PTpiTJdGY5fOY4tp7fUuIy7jTsC1AHQ6XQoLC2882tYDZIvJ+NKzhVoRXtniHEzlvny6JewU9pBK1oUlxUD2pqXWfLDkporVfK3b/9W62VmbDP/nl7gzmcu83YmQpeH1mqZK7evQPO2plbLXL59GT5v+tRcudIybRa1qbrS/x2OLXHxSWPFnarqVNUmwNjUnPR17wu4Vyjw/N9/7/a8G38f8Hd9DPJy9AIA/T07hy8dxocJH+L6retN22kiMl8941KrS+LKKRQKg+ciYlRWU31T5eWWLl2KRYsWGZUHBgbWtqvUgl3GZUx61XSiVpNJb9V+ucu4DPdX3WuuWM9lAOCht2pO2ip75q1nar3MRmys9TI/4adaL5OClFovcxM3a65ETaqgoABubm4WWXdjxJ3atsnYRERkXeoal1pdEufp6QmlUmn0S2VWVpbRL5rlfH19Tda3tbWFh4eHyWXmz5+PqKgo/fMbN25Ao9EgLS3NYn9AWIP8/HwEBgYiPT291d5/wX3AfQBwH5Rrqv0gIigoKIC/v3+jraMqjRV3qqpTVZtA64xNreW71hq2k9vYcrSG7axpG+sbl1pdEqdSqRAWFoY9e/YYDMO8Z88ePProoyaXGThwIL755huDst27d6Nfv35V3g+nVquhVquNyt3c3Frsh7U2XF1dW/1+4D7gPgC4D8o1xX6wVJLSWHFn4MCB2LNnj8F9cbt370Z4eHiVfWnNsam1fNdaw3ZyG1uO1rCd1W1jfeKSTZ2XbMaioqKwdu1arF+/HsnJyZg3bx7S0tL08+/Mnz8fkydP1tefMWMGLl68iKioKCQnJ2P9+vVYt24dXnrpJUttAhERNSONEXfmzJmD3bt34+2338bvv/+Ot99+Gz/88APmzp3b1JtHRERNrNWdiQPuDMucm5uLxYsXIyMjA927d8fOnTuh0dy5+T4jIwNpaWn6+iEhIdi5cyfmzZuHlStXwt/fH++//77Zc8QREVHr1hhxJzw8HJs3b8Zrr72G119/HR06dEBsbKzZc8QREVHz1SqTOACYOXMmZs6cafK1DRs2GJUNHjwYx48fr/P61Go1Fi5caPIyltaE+4H7AOA+ALgPyrWm/dAYcWfcuHEYN25cnfvUGvZ/a9hGoHVsJ7ex5WgN29nY29gqJ/smIiIiIiJqrlrlPXFERERERETNFZM4IiIiIiKiZoRJHBERERERUTPCJI6IiIiIiKgZYRLXRFatWoWQkBDY29sjLCwM8fHxlu5Sk4mOjoZCoTB4+Pr6Wrpbje7HH3/Eww8/DH9/fygUCvznP/8xeF1EEB0dDX9/fzg4OGDIkCE4deqUZTrbSGraB1OnTjX6bAwYMMAynW0ES5cuxd133w0XFxd4e3vjsccew5kzZwzqtIbPgTn7oaV/FqxVS4pNrfH7tnTpUigUCoO5AVvCNl6+fBkTJ06Eh4cHHB0d0bt3byQkJOhfb+7bWFZWhtdeew0hISFwcHBA+/btsXjxYuh0On2d5riNDfF3T3FxMWbNmgVPT084OTnhkUcewaVLl5pwK6pX3TaWlpbi5ZdfRo8ePeDk5AR/f39MnjwZV65cMWijobaRSVwTiI2Nxdy5c7FgwQIkJiYiIiICo0aNMpgTqKXr1q0bMjIy9I+TJ09aukuN7ubNm+jVqxf+9a9/mXx92bJlWL58Of71r3/h6NGj8PX1xQMPPICCgoIm7mnjqWkfAMDIkSMNPhs7d+5swh42rgMHDuCFF17Azz//jD179qCsrAyRkZG4efOmvk5r+ByYsx+Alv1ZsEYtLTa1tu/b0aNH8dFHH6Fnz54G5c19G69fv45BgwbBzs4O33//PU6fPo1//vOfaNOmjb5Oc9/Gt99+G2vWrMG//vUvJCcnY9myZXjnnXfwwQcf6Os0x21siL975s6dix07dmDz5s04ePAgCgsL8dBDD0Gr1TbVZlSrum0sKirC8ePH8frrr+P48ePYvn07zp49i0ceecSgXoNto1Cju+eee2TGjBkGZV26dJFXXnnFQj1qWgsXLpRevXpZuhsWBUB27Nihf67T6cTX11feeustfdnt27fFzc1N1qxZY4EeNr7K+0BEZMqUKfLoo49apD+WkJWVJQDkwIEDItI6PwcixvtBpPV9FqxBS49NLfn7VlBQIB07dpQ9e/bI4MGDZc6cOSLSMrbx5ZdflnvvvbfK11vCNj744IPyzDPPGJSNGTNGJk6cKCItYxvr8nfPjRs3xM7OTjZv3qyvc/nyZbGxsZFdu3Y1Wd/NZervmsqOHDkiAOTixYsi0rDbyDNxjaykpAQJCQmIjIw0KI+MjMShQ4cs1Kumd+7cOfj7+yMkJARPPfUULly4YOkuWVRKSgoyMzMNPhdqtRqDBw9uVZ8LAIiLi4O3tzc6deqEZ599FllZWZbuUqPJy8sDALi7uwNovZ+DyvuhXGv6LFhaa4hNLfn79sILL+DBBx/E8OHDDcpbwjZ+/fXX6NevH5544gl4e3ujT58++Pjjj/Wvt4RtvPfee7F3716cPXsWAPDrr7/i4MGDGD16NICWsY2VmbNNCQkJKC0tNajj7++P7t27N9vtzsvLg0Kh0J9JbshttG3IjpKxnJwcaLVa+Pj4GJT7+PggMzPTQr1qWv3798fGjRvRqVMnXL16Ff/4xz8QHh6OU6dOwcPDw9Lds4jy997U5+LixYuW6JJFjBo1Ck888QQ0Gg1SUlLw+uuv4/7770dCQgLUarWlu9egRARRUVG499570b17dwCt83Ngaj8AreuzYA1aemxqyd+3zZs34/jx4zh69KjRay1hGy9cuIDVq1cjKioKr776Ko4cOYLZs2dDrVZj8uTJLWIbX375ZeTl5aFLly5QKpXQarV488038fTTTwNoGe9jZeZsU2ZmJlQqFdq2bWtUpzkel27fvo1XXnkFEyZMgKurK4CG3UYmcU1EoVAYPBcRo7KWatSoUfr/9+jRAwMHDkSHDh3w6aefIioqyoI9s7zW/LkAgPHjx+v/3717d/Tr1w8ajQbfffcdxowZY8GeNbwXX3wRJ06cwMGDB41ea02fg6r2Q2v6LFiTlvrZa6nft/T0dMyZMwe7d++Gvb19lfWa8zbqdDr069cPS5YsAQD06dMHp06dwurVqzF58mR9vea8jbGxsfj888/x5Zdfolu3bkhKSsLcuXPh7++PKVOm6Os1522sSl22qTlud2lpKZ566inodDqsWrWqxvp12UZeTtnIPD09oVQqjbLrrKwso18jWgsnJyf06NED586ds3RXLKZ8dE5+Lgz5+flBo9G0uM/GrFmz8PXXX2P//v0ICAjQl7e2z0FV+8GUlvpZsBYtOTa15O9bQkICsrKyEBYWBltbW9ja2uLAgQN4//33YWtrq9+O5ryNfn5+6Nq1q0FZaGiofsCdlvA+/vWvf8Urr7yCp556Cj169MCkSZMwb948LF26FEDL2MbKzNkmX19flJSU4Pr161XWaQ5KS0vx5JNPIiUlBXv27NGfhQMadhuZxDUylUqFsLAw7Nmzx6B8z549CA8Pt1CvLKu4uBjJycnw8/OzdFcsJiQkBL6+vgafi5KSEhw4cKDVfi4AIDc3F+np6S3msyEiePHFF7F9+3bs27cPISEhBq+3ls9BTfvBlJb2WbA2LTE2tYbv27Bhw3Dy5EkkJSXpH/369cOf/vQnJCUloX379s1+GwcNGmQ0NcTZs2eh0WgAtIz3saioCDY2hn+CK5VK/RQDLWEbKzNnm8LCwmBnZ2dQJyMjA7/99luz2e7yBO7cuXP44YcfjG4batBtrNUwKFQnmzdvFjs7O1m3bp2cPn1a5s6dK05OTpKammrprjWJv/zlLxIXFycXLlyQn3/+WR566CFxcXFp8dtfUFAgiYmJkpiYKABk+fLlkpiYqB+h6K233hI3NzfZvn27nDx5Up5++mnx8/OT/Px8C/e84VS3DwoKCuQvf/mLHDp0SFJSUmT//v0ycOBAadeuXYvZB3/+85/Fzc1N4uLiJCMjQ/8oKirS12kNn4Oa9kNr+CxYo5YWm1rr963i6JQizX8bjxw5Ira2tvLmm2/KuXPn5IsvvhBHR0f5/PPP9XWa+zZOmTJF2rVrJ99++62kpKTI9u3bxdPTU/72t7/p6zTHbWyIv3tmzJghAQEB8sMPP8jx48fl/vvvl169eklZWZmlNstAddtYWloqjzzyiAQEBEhSUpLBcai4uFjfRkNtI5O4JrJy5UrRaDSiUqmkb9++BkNrt3Tjx48XPz8/sbOzE39/fxkzZoycOnXK0t1qdPv37xcARo8pU6aIyJ3hdhcuXCi+vr6iVqvlvvvuk5MnT1q20w2sun1QVFQkkZGR4uXlJXZ2dhIUFCRTpkyRtLQ0S3e7wZjadgDyySef6Ou0hs9BTfuhNXwWrFVLik2t9ftWOYlrCdv4zTffSPfu3UWtVkuXLl3ko48+Mni9uW9jfn6+zJkzR4KCgsTe3l7at28vCxYsMPhDvzluY0P83XPr1i158cUXxd3dXRwcHOShhx6yqlhQ3TampKRUeRzav3+/vo2G2kaFiEjtzt0RERERERGRpfCeOCIiIiIiomaESRwREREREVEzwiSOiIiIiIioGWESR9REVq1ahQ0bNjTJuoqKihAdHY24uLgmWV9LdfDgQUyfPh1hYWFQq9VQKBRITU21dLeIiBoMY1Pzw9hEAJM4oibT1IFy0aJFDJT1tHfvXvzwww8ICgpqNnPUEBHVBmNT88PYRACTOCJqAEVFRZbuQqN4/fXXkZqaih07duDBBx+0dHeIiKgWGJuoJWMSR1SFgwcPYtiwYXBxcYGjoyPCw8Px3XffGdSJjo6GQqEwWnbDhg0GlzcEBwfj1KlTOHDgABQKBRQKBYKDgwEAcXFxUCgU+PzzzxEVFQVfX184ODhg8ODBSExMNGh3yJAhGDJkiNH6pk6dqm8vNTUVXl5eAIBFixbp1zd16tQqt7U2fZg6dSqcnZ1x8uRJREZGwsXFBcOGDQMAXLt2DTNnzkS7du2gUqnQvn17LFiwAMXFxQZt6HQ6fPDBB+jduzccHBzQpk0bDBgwAF9//bVBvdjYWAwcOBBOTk5wdnbGiBEjjPpz4cIFPPXUU/D394darYaPjw+GDRuGpKQkfZ19+/ZhyJAh8PDwgIODA4KCgjB27NgaA7yNDQ+RRGRdGJsYmxibCGASR2TSgQMHcP/99yMvLw/r1q3Dpk2b4OLigocffhixsbG1bm/Hjh1o3749+vTpg8OHD+Pw4cPYsWOHQZ1XX30VFy5cwNq1a7F27VpcuXIFQ4YMwYULF2q1Lj8/P+zatQsAMG3aNP36Xn/99RqXNbcPJSUleOSRR3D//ffjq6++wqJFi3D79m0MHToUGzduRFRUFL777jtMnDgRy5Ytw5gxYwyWnzp1KubMmYO7774bsbGx2Lx5Mx555BGDa/qXLFmCp59+Gl27dsWWLVvw2WefoaCgABERETh9+rS+3ujRo5GQkIBly5Zhz549WL16Nfr06YMbN24AuPOHw4MPPgiVSoX169dj165deOutt+Dk5ISSkpJa7VsiIktibGJsItJrsCnMiVqQAQMGiLe3txQUFOjLysrKpHv37hIQECA6nU5ERBYuXCimvkaffPKJAJCUlBR9Wbdu3WTw4MFGdffv3y8ApG/fvvp2RURSU1PFzs5Opk+fri8bPHiwyTamTJkiGo1G/zw7O1sAyMKFC83a3tr0YcqUKQJA1q9fb9DGmjVrBIBs2bLFoPztt98WALJ7924REfnxxx8FgCxYsKDK/qSlpYmtra3MmjXLoLygoEB8fX3lySefFBGRnJwcASAxMTFVtrV161YBIElJSTXsheq98847Ru8pEVFTYmyqug+MTSn1aoeaH56JI6rk5s2b+OWXXzBu3Dg4Ozvry5VKJSZNmoRLly7hzJkzDb7eCRMmGFz+otFoEB4ejv379zf4uhqiD2PHjjV4vm/fPjg5OWHcuHEG5eWXyuzduxcA8P333wMAXnjhhSr78d///hdlZWWYPHkyysrK9A97e3sMHjxYf1O8u7s7OnTogHfeeQfLly9HYmIidDqdQVu9e/eGSqXCc889h08//bTWvx4TEVkDxibGJqKKmMQRVXL9+nWICPz8/Ixe8/f3BwDk5uY2+Hp9fX1NljXGuurbB0dHR7i6uhqU5ebmwtfX1+g+DG9vb9ja2urbyM7OhlKpNLmuclevXgUA3H333bCzszN4xMbGIicnBwCgUCiwd+9ejBgxAsuWLUPfvn3h5eWF2bNno6CgAADQoUMH/PDDD/D29sYLL7yADh06oEOHDlixYkUt9w4RkeUwNtXcB8Ymak1sLd0BImvTtm1b2NjYICMjw+i1K1euAAA8PT0BAPb29gCA4uJiqNVqfb3yA3ltZGZmmizz8PDQP7e3t0deXp5Rvbqsr659AGDyhnkPDw/88ssvEBGD17OyslBWVqbfZ15eXtBqtcjMzDT5xwjwv/27detWaDSaavus0Wiwbt06AMDZs2exZcsWREdHo6SkBGvWrAEAREREICIiAlqtFseOHcMHH3yAuXPnwsfHB0899VS17RMRWQPGpur7ADA2UevCM3FElTg5OaF///7Yvn07bt26pS/X6XT4/PPPERAQgE6dOgGAftStEydOGLTxzTffGLWrVqsN2qts06ZNEBH984sXL+LQoUMGI34FBwfj7NmzBiNq5ebm4tChQ0brAlDt+urah6oMGzYMhYWF+M9//mNQvnHjRv3rADBq1CgAwOrVq6tsa8SIEbC1tcX58+fRr18/kw9TOnXqhNdeew09evTA8ePHjV5XKpXo378/Vq5cCQAm6xARWSPGJsYmoop4Jo7IhKVLl+KBBx7A0KFD8dJLL0GlUmHVqlX47bffsGnTJv2veaNHj4a7uzumTZuGxYsXw9bWFhs2bEB6erpRmz169MDmzZsRGxuL9u3bw97eHj169NC/npWVhccffxzPPvss8vLysHDhQtjb22P+/Pn6OpMmTcKHH36IiRMn4tlnn0Vubi6WLVtmdPmIi4sLNBoNvvrqKwwbNgzu7u7w9PTUB/aqmNOHqkyePBkrV67ElClTkJqaih49euDgwYNYsmQJRo8ejeHDhwO488vjpEmT8I9//ANXr17FQw89BLVajcTERDg6OmLWrFkIDg7G4sWLsWDBAly4cAEjR45E27ZtcfXqVRw5cgROTk5YtGgRTpw4gRdffBFPPPEEOnbsCJVKhX379uHEiRN45ZVXAABr1qzBvn378OCDDyIoKAi3b9/G+vXrAUDfp6pkZ2fjwIEDAICTJ08CuHPfhJeXF7y8vDB48OAa9wsRUUNhbGJsAhib6P9YbkwVIusWHx8v999/vzg5OYmDg4MMGDBAvvnmG6N6R44ckfDwcHFycpJ27drJwoULZe3atUajRaWmpkpkZKS4uLgIAP2IXeWjb3322Wcye/Zs8fLyErVaLREREXLs2DGj9X366acSGhoq9vb20rVrV4mNjTUaAUxE5IcffpA+ffqIWq0WADJlypQqt7U2fZgyZYo4OTmZbCc3N1dmzJghfn5+YmtrKxqNRubPny+3b982qKfVauW9996T7t27i0qlEjc3Nxk4cKDR/v3Pf/4jQ4cOFVdXV1Gr1aLRaGTcuHHyww8/iIjI1atXZerUqdKlSxdxcnISZ2dn6dmzp7z33ntSVlYmIiKHDx+Wxx9/XDQajajVavHw8JDBgwfL119/XeX+qLxfTD1MjcRGRNTYGJsYmxibSEREIVLh/DQRNbm4uDgMHToU//73v41Gz2pNfSAiIuthDXHBGvpAZK14TxwREREREVEzwiSOiIiIiIioGeHllERERERERM0Iz8QRERERERE1I0ziiIiIiIiImhEmcURERERERM0IJ/tuIjqdDleuXIGLi4t+Mk4iImoaIoKCggL4+/vDxoa/X5ZjbCIisoz6xiUmcU3kypUrCAwMtHQ3iIhatfT0dAQEBFi6G1aDsYmIyLLqGpeYxDURFxcXAHfeKFdXVwv3hoiodcnPz0dgYKD+WEx3MDYREVlGfeMSk7gmUn6ZiqurKwMlEZGF8JJBQ4xNRESWVde4xBsDiIiIiIiImpFmmcStWrUKISEhsLe3R1hYGOLj46usm5GRgQkTJqBz586wsbHB3LlzjeoMGTIECoXC6PHggw/q60RHRxu97uvr2xibR0REREREVKVml8TFxsZi7ty5WLBgARITExEREYFRo0YhLS3NZP3i4mJ4eXlhwYIF6NWrl8k627dvR0ZGhv7x22+/QalU4oknnjCo161bN4N6J0+ebPDtIyIiIiIiqk6t74nTarUoLS1tjL6Y5YsvvkBUVBQmTpwIAHjrrbdw4sQJfP7554iKijKq7+vri7fffhsA8O2338LV1RW3b982qOPo6AhHR0f986+++gqdO3fGI488oq/r7OyMgIAAtGnTxmDZym1VpaSkBBqNBiUlJWYvQ0RE5rGxsYFOp6vydR6DTeN+ISJqPCqVqtGmtVGIiJhTUUSQmZmJGzduNEpHzO1DWloavLy8DJKua9euoaSkpMbLGzMzM6FSqeDu7l5tvStXrkCtVsPDw0NfduPGDeTn58PGxgYKhQIqlQpt27aFra3pPFhEUHHX6nQ6XL58GYGBgZyjiIiogYgIysrKICJQKpVQKpUm6+l0OqSnp/MYXAn3CxFR47GxsUFISAhUKpXRa/n5+XBzc0NeXl6dBpYy+0xceQLn7e0NR0dHi4zwVVJSgqKiIgQHB8PJyUlf7uTkhBs3biAkJKTGNtRqNfz9/at8vaioCDdv3kT79u0NEsWCggLodDqoVCpotVpkZ2ejuLgYISEhJhO5rKwsZGVlGZR5enoiODi4yj8yiIiodrKzs1FQUABPT0/Y2dlBqVSaDJZarRa3bt3iMbgS7hciosah0+lw5coVZGRkICgoqMFzJ7OSOK1Wq0/gKp6damrlvxKq1WrY29vry+3s7GBjY2NQVtXytra21da7evUqHBwcjM7WVV6mbdu2+O2331BYWGjyDGBAQADatWunf67VanHixAnY29szUBIRNQCtVovCwkL4+PjAw8MDZWVlKC0thVqtNgqWWq0WAHgMroT7hYio8Xh5eeHKlSsoKyuDnZ1dg7Zt1rUT5ffAVTwzZQnlZ7wq35NXWlpa5WWNtaHVanHt2jV4enrWWFepVMLBwQHFxcUmX7exsdFf2lPdJT5ERFQ3lWNT+Q99Zt4lQERE1KjKrwwp/8GsIdXqAnhLT5JqY2MDJycn5OfnG5Tn5+fD2dm53u1fv34dOp3OrLONOp0Ot27davCsmoiIasfSsYmIiMiUxoxP9T991cR8fHyQkpICJycnODk5IScnByUlJfDy8gIAXLp0CaWlpQb3xxUVFQG4kwWXlZWhqKgICoUCDg4OBm3n5OSgTZs2Js/qpaeno02bNlCpVCgtLUVGRga0Wq1FLy8lIiIiIqLWp9kNReXu7o7AwEBcuXIFp0+fRkFBATp27Ai1Wg3gzuU1JSUlBsucPn0ap0+fRlFREfbs2QMnJyckJCQY1Ll9+zYKCwv1yWBlJSUluHDhAn777TecP38eCoUCoaGh+vW2VKmpqVAoFEhKSmrwtj/66CP9iGgxMTGIjo5G7969G3w9ZDm///47BgwYAHt7e763ZoqLi4NCodCPBLxhwwajqU0aQuXvduX1Nua6yFhj7v+WiLGJ6oOxqfYYm6yQmOHWrVty+vRpuXXrljnVq1SmLZP9KfvlyxNfyv6U/VKmLatXezUZPHiwzJkzx6CsuLhYMjIyRKfTNeq6KysrK5OjR49KWVnDbzMA2bFjR73bmTJlijz66KMGZSkpKQJAEhMT691+RXl5eWJnZycffPCBXLlyRW7evCkFBQWSk5NTr3ZNvedkOU8++aTcf//9kpqaWu/3tjoLFy6UXr16NUrbn3zyibi5udVYb9u2bTJ8+HDx9PQUFxcXGTBggOzatavW69u/f78AkOvXr4uISFFRkVy9erVB+ypy55iUkZEhpaWlJtdbV6aOI5XX1VAqxyatVitFRUWi1WqN6lZ3DG6q2HT16lX59ddfpW/fvjJx4kTJz8/Xv1Y5NhUXF8v58+fl5MmTcvToUbl48aLJNq9duyYnT56UY8eOycmTJ+XatWu16hNjkyHGptahNcWm+Ph4CQ8PF3d3d7G3t5fOnTvL8uXLa70+xqa6qS6HysvLEwCSl5dXp7ab7HLK7cnbMWfXHFzKv6QvC3ANwIqRKzAmdExTdQMqlarG+eSo8aWlpaG0tBQPPvgg/Pz89OXV3dtYUlJicujwlkCr1UKhUBjN09Tct/n8+fN48MEHodFoLN2VRvfjjz/igQcewJIlS9CmTRt88sknePjhh/HLL7+gT58+dW7XwcHB6NLv+ir/XDXVsVCpVFrtcbepYtO1a9eQnp6OoKAgODk5QaVS4dy5c+jWrRvUarXR+yEisLW1ha+vr9F0NeUKCwtx/vx5tGvXDm3atMGNGzdw4cIFdO7cuUHuE2+NGJsMMTY1f05OTnjxxRfRs2dPODk54eDBg3j++efh5OSE5557rs7tMjZZgfpmkebYdnqbKKIVgmgYPBTRClFEK2Tb6W11arc6U6ZMEQAGj5SUFKOMvvzXgW+++UY6deokDg4OMnbsWCksLJQNGzaIRqORNm3ayIsvvmjwS2VxcbH89a9/FX9/f3F0dJR77rlH9u/fX2V//vjjDwEgx44d05ddv35dAOiXK+/bt99+Kz179hS1Wi333HOPnDhxosp2NRqNwTZqNBr9a6tWrZL27duLnZ2ddOrUSTZu3FhlOwsXLjTaX/v379f/2rlt2zYZMmSIODg4SM+ePeXQoUMGy//0008SEREh9vb2EhAQILNmzZLCwkKT6/rkk09MvjeVf7Eq/9VkyZIl4ufnp9+2lStXyl133SVqtVq8vb1l7Nix+vqm2jXl2rVrMmnSJGnTpo04ODjIyJEj5ezZswZ1Dh48KPfdd584ODhImzZtJDIyUv8rt1arlbfeeks6dOggKpVKAgMD5R//+IeImP7VKDEx0aA/FT93oaGholQq5cKFC6LRaOSNN96QKVOmiKurq0yePNms/avRaOTNN9+U//f//p84OztLYGCgfPjhhwbbk56eLuPHj5e2bduKo6OjhIWFyc8//6x//euvv5a+ffuKWq2WkJAQiY6OrvbXKa1WK4sWLZJ27dqJSqWSXr16yffff69/vfJ7sXDhQpPt3L59W2bNmiVeXl6iVqtl0KBBcuTIEf3rpn7B27Fjh5Qfvkx9nj755BN9H1atWiUjR44Ue3t7CQ4Oli1btujbqem9Kn/dnO0wpWvXrrJo0aJq63z33XfSsWNHsbe3lyFDhui3p/IxqlxSUpIMGTJEnJ2dxcXFRfr27StHjx6ttq+mPleVz2SYc/wx9avye++9p/9u1nQcqXjWJC4uTu6++25RqVTi6+srL7/8ssHnbfDgwTJr1iz561//Km3bthUfHx+jfV/fM3FNGZtOnz4tqampdYpNwcHBYm9vbxSbXF1dZeLEiQbbdPLkSXn22WcZm/4PYxNjE2OTsccff1wmTpxYbR3GprrHpooa80xcoydxZdoyCVgeYBQkKwbLwOWBDX75yo0bN2TgwIHy7LPPSkZGhmRkZEhZWZnJQGlnZycPPPCAHD9+XA4cOCAeHh4SGRkpTz75pJw6dUq++eYbUalUsnnzZn37EyZMkPDwcPnxxx/ljz/+kHfeeUfUarXRwbZcbQJlaGio7N69W06cOCEPPfSQBAcHS0lJicl2s7Ky9AeGjIwMycrKEhGR7du3i52dnaxcuVLOnDkj//znP0WpVMq+fftMtlNQUCBPPvmkjBw5Ur+/iouL9R/wLl26yLfffitnzpyRcePGiUaj0X+oT5w4Ic7OzvLee+/J2bNn5aeffpI+ffrI1KlTTa6rqKhIfvjhBwEgR44c0b83pgKls7OzTJo0SX777Tf9ZUVKpVK+/PJLSU1NlePHj8uKFSuqfc9NeeSRRyQ0NFR+/PFHSUpKkhEjRshdd92l38+JiYmiVqvlz3/+syQlJclvv/0mH3zwgWRnZ4uIyN/+9jdp27atbNiwQf744w+Jj4+Xjz/+2OB9rClQ2tnZSXh4uPz000/y+++/S2Fhof4Ps3feeUfOnTsn586dM2v/ajQacXd3l5UrV8q5c+dk6dKlYmNjI8nJyfr3t3379hIRESHx8fFy7tw5iY2N1f/Bs2vXLnF1dZUNGzbI+fPnZffu3RIcHCzR0dEm95+IyPLly8XV1VU2bdokv//+u/ztb38TOzs7/XcgIyNDunXrJn/5y18kIyNDCgoKTLYze/Zs8ff3l507d8qpU6dkypQp0rZtW8nNzdXvq+oCZVFRkfzlL3+Rbt266d/3oqIiEbkTKD08POTjjz+WM2fOyGuvvSZKpVJOnz5t1ntVXFwsMTEx4urqqm+7qu2oTKvVSmBgoHzwwQdV1klLSxO1Wi1z5syR33//XT7//HPx8fGpNlB269ZNJk6cKMnJyXL27FnZsmWLJCUlVdtXU5+rqgJldcefmgJlTceR8nVdunRJHB0dZebMmZKcnCw7duwQT09Pg0A4ePBgcXV1lejoaDl79qx8+umnolAoZPfu3fo69UnimjI2abVaOXr0qFy7ds3gOHX06FH58ccfa4xN27dvly1bthjFpvfff98oNo0ZM0Z69+7N2CSMTYxNjE2mHD9+XHx8fPSfC1MYm+oXmyqy2iTuZslNSbiSUO3jw2MfVhkkKz4+PPZhjW0lXEmQmyU3zd44U9egmwqUAOSPP/7Q13n++efF0dHR4AsxYsQIef7550XkTtBTKBRy+fJlg7aHDRsm8+fPN9mX2gTKigE5NzdXHBwcJDY2tsrtBIzvOwgPD5dnn33WoOyJJ56Q0aNHV9lOdfcdrF27Vl926tQpAaA/CE+aNEmee+45g+Xi4+PFxsamysS/cuAQMf4STpkyRXx8fKS4uFhftm3bNnF1dTW4l6Qic+47OHv2rACQn376SV+Wk5MjDg4O+l/Cnn76aRk0aJDJ5fPz80WtVld5ADQ3UAKQpKQkg2U1Go089thjBmXm7F+NRmPwq5pOpxNvb29ZvXq1iIh8+OGH4uLiog8+lUVERMiSJUsMyj777DPx8/MzWV9ExN/fX958802Dsrvvvltmzpypf96rV69qf6EqLCwUOzs7+eKLL/RlJSUl4u/vL8uWLRORmgOlSNX3HQCQGTNmGJT1799f/vznP4tI7X6Zrq1ly5aJu7t7tfcMzJ8/X0JDQw3u0X355ZerDZQuLi6yYcMGk+1V1VdTn6uqAmV1x5+aAqWIefcvvfrqq9K5c2eD7V65cqU4OzvrE7DBgwfLvffea9DO3XffLS+//LL+uakkLicvR45eOmoUO46kH5HPfvhMjqQfafLYVFxcLEePHtXHlPLj1JUrV+TkyZMG+99UbPr999/l4sWLRrHp2LFjcv/99xvFpopnHUQMY5NWq5WysjL948yZM4xNFTA2MTaJtMzYVH5m0sbGRhYvXlxtXcam+sWmiqz2nrjfc35H2Edh9WlC7/lvnzerXsJzCejr17dB1lnO0dERHTp00D/38fFBcHCwwTXwPj4++vsSjh8/DhFBp06dDNopLi5ukCkHBg4cqP+/u7s7OnfujOTk5Fq1kZycbHSt86BBg7BixYo69alnz576/5ffJ5CVlYUuXbogISEBf/zxB7744gt9HRGBTqdDSkoKQkND67ROAOjRo4fBdfcPPPAANBoN2rdvj5EjR2LkyJF4/PHHazURfXJyMmxtbdG/f399mYeHh8F+TkpKwhNPPFHl8sXFxRg2bFgdt+oOlUplsF/L9evXz+C5ufu3YlsKhcLgXpqkpCT06dMH7u7uJvuSkJCAo0eP4s0339SXabVa3L59G0VFRUb7Nz8/H1euXMGgQYMMygcNGoRff/3VnM0HcOe+hNLSUoN27OzscM8999T6M1+Vit+n8ueNPRLVpk2bEB0dja+++gre3t5V1ktOTsaAAQMM5pGp3N/KoqKiMH36dHz22WcYPnw4nnjiCYPjV1Uqf66q0hDHn5okJydj4MCBBts9aNAgFBYW4tKlSwgKCgIAo++Hn59flfeHlTuTewaDNg6qusLB2vXVGmLTmTNnAJiOTV5eXkaxacyYMQb3MFWMTZmZmbhy5Yr+tYr/rwlj0/8wNjE21VdTx6b4+HgUFhbi559/xiuvvIK77roLTz/9tMm6jE0NH5saQ72SuC6eXZDwXEK1dY5dOWZWEPzwoQ/Rz7/mN7KLZxez+2euyhN2KxQKk2U6nQ7AnYm+lUolEhISoFQqDepVdfNzeUAVEX1ZaWmp2X2sy2SBlZcRkTpPOlhxf5S3UXF/PP/885g9e7bRcuUf+LpycnIyeO7i4oLjx48jLi4Ou3fvxt///ndER0fj6NGjZg91W/E9qFxevm3V3axb04285r7XDg4OJt+Pytts7v6t7jNbU591Oh0WLVqEMWOMB3Kwt7evcrn6fsbK91F17djY2Bi9Z7X57phSse2K/WiItmNjYzFt2jT8+9//xvDhw6utW9VnsTrR0dGYMGECvvvuO3z//fdYuHAhNm/ejMcff7za5Sp/rmqjod8LU58TU5+F6j7TVens0RlHpx81GohBq9XizJkz6Ny5M5RKZZPGpvK5Ryvvq9LSUpPzkparKTbZ2dnp/2gG/hebNm/ejK5duxosWx6bfH194ePjoy8vP24yNtUOYxNjU3OLTeXzJ/fo0QNXr15FdHR0lUkcY5NhWcV1AXWLTY2hXkmco51jjb889vLphTd+fAOX8y9DYPyhUECBANcATOszDUobpYkW6k6lUkGr1TZomwDQp08faLVaZGVlISIiwqxlyuefy8jI0JdV9YvLzz//rD8AXr9+HWfPnkWXLlX/gWBnZ2e0naGhoTh48CAmT56sLzt06FC1vzzWdX/17dsXp06dwl133VXrZevC1tYWw4cPx/Dhw7Fw4UK0adMG+/btw5gxY8zahq5du6KsrAy//PILwsPDAQC5ubk4e/aswS+He/fuxaJFi4yW79ixIxwcHLB3715Mnz7d6PWK73Xbtm0BVP1em6Mh9m/Pnj2xdu1aXLt2zeQvnn379sWZM2fMXoerqyv8/f1x8OBB3HffffryQ4cO4Z577jG7X3fddRdUKhUOHjyICRMmALhz4D127Bjmzp0L4M7+LCgowM2bN/UH+8r7s7r3/eeffzb4Hvz888/60SLNea9q873YtGkTnvn/7N15XNTV/j/w1zAsg8ggCrLIqqWhuEKp2CTeDJcWDcktl75X69KiIF9valgu3eJmXkO7orllViqmVFZkoomhkiZBuZArCNIQjimjoSzD+f3hj/k6zrDDbLyej8c8as6cz/mc8wE/h/eczznn73/Htm3b8Pjjj9ebv2fPnvjiiy/06luf7t27o3v37pgzZw4mTZqEDz/8EE8//XSL3PPquv+4u7ujuLhYp6NryvXq2bMndu3apVPOkSNH4OzsjC5dujSr/jX9kqEgTlIsQX+v/pBKpUbtm2xsbODk5AS1Wg1XV1ftNVKr1c3aZ8nJyUnnD5WavunWrVu1/lu+97rUrMzGvqn52Dc1Hvsm4/RN9xJCoLy8vNbP2Te1fN/UGlp9s2+pjRQrR955TEIC3ei25n3iyMQWD+AAICAgAEePHkV+fj5UKlWLRcndu3fHs88+i2nTpiElJQV5eXn46aef8M477yA1NdXgMY6OjujduzeWLVuG06dP44cffsDChQsN5l26dCn279+PkydP4rnnnoObmxvGjh1ba30CAgKwf/9+FBcX49q1awCAf/7zn9i8eTPWrl2Lc+fOYcWKFUhJScHcuXPrLOfXX3/FmTNnoFKpGvwtxrx585CZmYmXX34ZOTk5OHfuHHbv3o1Zs2Y16PjG+Prrr7Fq1Srk5OTg0qVL2LJlC6qrq9GjRw9tG+r7md9///0YM2YMnn/+eRw6dAi//PILpkyZgi5dumDMmDEAgAULFuCnn37CSy+9hF9//RW//fYb1qxZA5VKBZlMhnnz5uHVV1/Fli1bcOHCBfz444/YuHEjgDs3f19fXyxevBhnz57FN998g//85z9NbnNLXN9JkybB09MTY8eOxeHDh3Hx4kXs2rULmZmZAIA33ngDW7ZsweLFi3Hq1Cnk5uYiOTm51t9R4M7v2DvvvIPk5GScOXMG8+fPR05ODmJiYhpcLycnJ7z44ov45z//iT179uD06dN4/vnnUVZWhhkzZgAABg4ciHbt2uG1117D+fPnsXXrVmzevFmnnICAAOTl5SEnJwcqlUqnc/rss8+wadMmnD17FosWLcKxY8fwyiuvAGjYzyogIAA3b97E/v37oVKpUFZWZrAt27Ztw7Rp0/Cf//wHgwYNQnFxMYqLi1FaWlpr+6Ojo3HhwgXExcXhzJkzBtt2t1u3buGVV15Beno6Ll26hMOHD+Onn37S/oHX0LrWpa77T3h4OK5cuYJly5bhwoULWL16Nb799lud4xtyH3nppZdQWFiIWbNm4bfffsOXX36JRYsWIS4uTi/IaC3G7ps8PDygUqmgUqng4+ODjIwM7Uaz1dXVuHLlisHjysrKoNFoUFVVhcrKSp17moeHByoqKnD79m3cunULzs7OGDVqFObNm8e+Ceyb2DexbwKA1atX46uvvsK5c+dw7tw5fPjhh1i+fDmmTJlSa/vZN5mub2qUhkyca4nNvned3qW3EpjvCt9W2V6gxpkzZ8SgQYOEo6Oj3rKstU3MFMLwBMl7J0RWVFSIN954QwQEBAg7Ozvh6ekpnn766VqXXK6qqhI7duwQAwcOFI6OjqJfv35i7969BiePf/XVV6JXr17C3t5ePPjgg3oTjO+1e/ducd999wlbW9smL+MsxJ3VxB577DHRvn37OpdfvXfSuxBCHDt2THusk5OT6NOnj97E4rs1dPL4vZNQMzIyxNChQ4Wrq6t2Sem7J9Yb+pkbUrOMs4uLi3B0dBQjRozQW70tPT1dhIWFCQcHB9GhQwcxYsQI7e+NRqMR//rXv4S/v7+ws7MTfn5+OpOvDx06JHr37i1kMplQKBTis88+a9CEZH9/f/Hee+/ppdd3fQ0dd+/E7fz8fDFu3Dghl8tFu3btRGhoqDh69Kj28z179oiwsDDh6Ogo5HK5eOihh8S6desMXr+aa1CzjLOdnZ3eMs6G6mDIrVu3xKxZs4Sbm5vBZZyFuDNZ/L777hMymUw88cQTYt26dTqTx2/fvi3GjRsnOnTooF0RT4g7k8dXr14tHnvsMeHg4CD8/f3Ftm3bdMqu72clhBDR0dGiU6dOOksj32vo0KF6SxgDENOnT6+z/V999ZV2WXKFQiE2bdpU6z2qvLxcTJw4Ufj6+gp7e3vh7e0tXnnlFZ17s6G6Gvr9qG3yeH33nzVr1ghfX1/h5OQkpk2bJt566y2d+05D7yMNWcb53oUgxowZo3M9W2Kzb2P2TTWbfe/atUv07dtX5z61detWvZ97+/btxU8//aR9Pf/886JHjx46ZU6cOFEMGzZMu9n3H3/8wb6JfRP7JvZNWqtWrRK9evUS7dq1E3K5XPTv318kJSUZvE/ejX1T0/umu7XmwiYSIep/8PX27dvIy8tDYGBgnc8g10dTrUFGQQaUN5TwcvaCwk/RKiNw5kij0SA7Oxv9+/fXm0dXIz09HcOGDcO1a9ea9YgNEd0hkUjw+eef1zlaQJbr3r6puroa5eXlcHBwMPg4ZW33YPZN7JuIjIl9U9tRVwylVqvh4uKC0tJSyOXyRpfdrDlxjSW1kSI8INyYpyQiIqoT+yYiIrI0ZviAJxEREREREdXGqCNxVLfw8PAmLetKRIbx3xNR87FvImpZ/PdELYEjcURERERERBakUUEcvzkgIiJzw76JiIjMUWv2Tw0K4mp2Jm/Kvg5ERESt4d6+qWbvrZpNWomIiEypoqICAGpd/bc5GjQnTiqVokOHDigpKQEAtGvXjp1kI9XsEn/79u1W+UESEbVF7du3xx9//AGNRgM7OztIpVKD/RPvwYbxuhARtY7q6mpcuXIF7dq1g61tyy9D0uASPT09AUAbyFHjVFdXQ6VSIT8/3zx3fSciskBCCFRVVUGpVEIqldYaiPAebBivCxFR67GxsYGfn1+rDH41aLPvu2k0GlRWVrZ4RazdzZs3ERoaiuPHj6N9+/amrg4RkVWxsbHRPk5pCO/BhvG6EBG1Hnt7+1q/IDP6Zt91fdNJtauoqMClS5dwVHkUI3uNhNSG15CIyFhq7sH29vaQyWSmro7ZYN9ERGSZLPLZiaSkJAQGBkImkyEkJAQZGRm15lUqlZg8eTJ69OgBGxsbxMbG6uXZvHkzJBKJ3uv27dtNPm9tntj6BAJWBiAlN6XRxxIREbUG9k1ERJbF4oK45ORkxMbGIj4+HtnZ2VAoFBg1ahQKCgoM5i8vL4e7uzvi4+PRt2/fWsuVy+VQKpU6r7u/rW3seetSpC5C1I4odpZERGQ22DcREVkOiwviVqxYgRkzZmDmzJkICgpCYmIifH19sWbNGoP5AwICsHLlSkybNg0uLi61liuRSODp6anzas556yJwZxpi7J5YaKo1jT6eiIiopbFvIiKyHBYVxFVUVCArKwsRERE66REREThy5Eizyr558yb8/f3h4+ODJ554AtnZ2c06b3l5OdRqtc7rbgIChepCZBQ0/pFMIiKi1sC+iYjIMlhUEKdSqaDRaODh4aGT7uHhgeLi4iaX+8ADD2Dz5s3YvXs3tm3bBplMhiFDhuDcuXNNPm9CQgJcXFy0L19fX4P5lDeUTa43ERFRa2DfRERk3iwqiKtx714LQohm7b8waNAgTJkyBX379oVCocCOHTvQvXt3vP/++00+74IFC1BaWqp9FRYWGszn5ezV5HoTERG1BvZNRETmreW3D29Fbm5ukEqleqNfJSUleqNkzWFjY4MHH3xQOxLXlPM6ODjAwcGh1nNIIIGP3AcKP0WL1ZuIiKg52DcREVkGixqJs7e3R0hICNLS0nTS09LSEBYW1mLnEUIgJycHXl5erXJeCe6M3iWOTOSePEREZBbYNxERWQ6LGokDgLi4OEydOhWhoaEYPHgw1q1bh4KCAkRHRwO48xhjUVERtmzZoj0mJycHwJ3FS65cuYKcnBzY29ujZ8+eAIAlS5Zg0KBBuP/++6FWq7Fq1Srk5ORg9erVDT5vY/jIfZA4MhGRQZHNuBJEREQth30TEZHlsLggbsKECbh69SqWLl0KpVKJ4OBgpKamwt/fH8Cdzb3v3butf//+2v/PysrC1q1b4e/vj/z8fADA9evX8cILL6C4uBguLi7o378/fvjhBzz00EMNPm9D/U+//8H6Z9bzW04iIjIbT/V4CinTUtg3ERFZCIkQQpi6Em2BWq2Gi4sL4r6Mw3+e+o+pq0NE1KbU3INLS0shl8tNXR2zUXNdRm4YiW9nfGvq6hARtRnN7Zcsak6cNSgtLzV1FYiIiHRcvHbR1FUgIqJGYBBnZNdvXzd1FYiIiHTkX89Htag2dTWIiKiBGMQZGYM4IiIyNxWaCvx+43dTV4OIiBqIQZyRMYgjIiJzdOHPC6auAhERNRCDOCNjEEdERObo/J/nTV0FIiJqIAZxRsYgjoiIzE0XeRdcuMaROCIiS8Egzsiu374O7upARETmJNA1kEEcEZEFYRBnZJpqDf6q/MvU1SAiItLq2qEr58QREVkQBnEmcO3WNVNXgYiISCvQNRDn/zzPJ0WIiCwEgzgT4Lw4IiIyJ/4u/igtL8X6n9cjPT8dmmqNqatERER1YBBnAtducySOiKitSUpKQmBgIGQyGUJCQpCRkVFn/oMHDyIkJAQymQxdu3bF2rVr9fIkJiaiR48ecHR0hK+vL+bMmYPbt283um6v7nsVAPCPr/+BYR8NQ8DKAKTkpjS6HCIiMg4GcSbAxymJiNqW5ORkxMbGIj4+HtnZ2VAoFBg1ahQKCgoM5s/Ly8Po0aOhUCiQnZ2N1157DbNnz8auXbu0eT799FPMnz8fixYtQm5uLjZu3Ijk5GQsWLCg0fVT/aXSeV+kLkLUjigGckREZopBnAlwJI6IqG1ZsWIFZsyYgZkzZyIoKAiJiYnw9fXFmjVrDOZfu3Yt/Pz8kJiYiKCgIMycORN///vfsXz5cm2ezMxMDBkyBJMnT0ZAQAAiIiIwadIkHD9+vNn1FbgzNy52TywfrSQiMkMM4ozM0c6Rc+KIiNqQiooKZGVlISIiQic9IiICR44cMXhMZmamXv4RI0bg+PHjqKysBAA8/PDDyMrKwrFjxwAAFy9eRGpqKh5//PFa61JeXg61Wq3zqo2AQKG6EBkFdT/2SURExmdr6gq0NR1kHfg4JRFRG6JSqaDRaODh4aGT7uHhgeLiYoPHFBcXG8xfVVUFlUoFLy8vTJw4EVeuXMHDDz8MIQSqqqrw4osvYv78+bXWJSEhAUuWLGlU/ZU3lI3KT0RErY8jcUbm4uDCxymJiNogiUSi814IoZdWX/6709PT0/HWW28hKSkJP//8M1JSUvD111/jzTffrLXMBQsWoLS0VPsqLCyst95ezl715iEiIuPiSJyRdXDswCCOiKgNcXNzg1Qq1Rt1Kykp0Rttq+Hp6Wkwv62tLTp16gQAeP311zF16lTMnDkTANC7d2/89ddfeOGFFxAfHw8bG/3vaR0cHODg4NCgeksggY/cBwo/RYPyExGR8XAkzsg6OPBxSiKitsTe3h4hISFIS0vTSU9LS0NYWJjBYwYPHqyXf+/evQgNDYWdnR0AoKysTC9Qk0qlEEI0e9NuCe6M9iWOTITURtqssoiIqOUxiDOyDo4duLAJEVEbExcXhw0bNmDTpk3Izc3FnDlzUFBQgOjoaAB3HnOcNm2aNn90dDQuXbqEuLg45ObmYtOmTdi4cSPmzp2rzfPkk09izZo12L59O/Ly8pCWlobXX38dTz31FKTSxgVe3nJvnfc+ch/sHL8TkUGRzWg1ERG1Fj5OaWQdHDrg1+u/mroaRERkRBMmTMDVq1exdOlSKJVKBAcHIzU1Ff7+/gAApVKps2dcYGAgUlNTMWfOHKxevRre3t5YtWoVxo0bp82zcOFCSCQSLFy4EEVFRXB3d8eTTz6Jt956q9H1O/niSfxy/Rc8s+MZPNbtMXz89MccgSMiMmMWORKXlJSEwMBAyGQyhISEICOj9uWPlUolJk+ejB49esDGxgaxsbF6edavXw+FQgFXV1e4urpi+PDh2iWbayxevBgSiUTn5enp2ei6c3VKIqK26aWXXkJ+fj7Ky8uRlZWFRx55RPvZ5s2bkZ6erpN/6NCh+Pnnn1FeXo68vDztqF0NW1tbLFq0COfPn8etW7dQUFCA1atXo0OHDo2um9RGivCAcAzwHoBbVbcYwBERmTmLC+KSk5MRGxuL+Ph4ZGdnQ6FQYNSoUTrfYN6tvLwc7u7uiI+PR9++fQ3mSU9Px6RJk3DgwAFkZmbCz88PERERKCoq0snXq1cvKJVK7evEiRONrn8HGRc2ISIi89SjUw+cUZ0xdTWIiKgeFhfErVixAjNmzMDMmTMRFBSExMRE+Pr6Ys2aNQbzBwQEYOXKlZg2bRpcXFwM5vn000/x0ksvoV+/fnjggQewfv16VFdXY//+/Tr5bG1t4enpqX25u7s3uv4dZB1wu+o2blfdbvSxREREralHpx44/+d5VFVXmboqRERUB4sK4ioqKpCVlYWIiAid9IiICBw5cqTFzlNWVobKykp07NhRJ/3cuXPw9vZGYGAgJk6ciIsXLza67A6yDgDAxU2IiMjs9HDrgcrqSuRdyzN1VYiIqA4WFcSpVCpoNBq9fXU8PDz09tNpjvnz56NLly4YPny4Nm3gwIHYsmULvvvuO6xfvx7FxcUICwvD1atXDZZRXl4OtVqt8wLubPYNgPPiiIjI7PTo1AMAcOYqH6kkIjJnFhXE1ZBIJDrvhRB6aU21bNkybNu2DSkpKZDJZNr0UaNGYdy4cejduzeGDx+Ob775BgDw0UcfGSwnISEBLi4u2pevry+AO1sMAOC8OCIiMjtd5F3Qzq4d58UREZk5iwri3NzcIJVK9UbdSkpK9EbnmmL58uV4++23sXfvXvTp06fOvE5OTujduzfOnTtn8PMFCxagtLRU+yosLARwZ4sBgCNxRERkfmwkNujeqTtH4oiIzJxFBXH29vYICQlBWlqaTnpaWhrCwsKaVfa7776LN998E3v27EFoaGi9+cvLy5GbmwsvLy+Dnzs4OEAul+u8gP8bieOcOCIiMkc9OvVgEEdEZOYsbrPvuLg4TJ06FaGhoRg8eDDWrVuHgoIC7f45CxYsQFFREbZs2aI9JicnBwBw8+ZNXLlyBTk5ObC3t0fPnj0B3HmE8vXXX8fWrVsREBCgHelr37492rdvDwCYO3cunnzySfj5+aGkpAT/+te/oFarMX369EbV39HWEfZSez5OSUREZun+jvdj74W92HZiG7ycvaDwU3DfOCIiM2NxQdyECRNw9epVLF26FEqlEsHBwUhNTYW/vz+AO5t737tnXP/+/bX/n5WVha1bt8Lf3x/5+fkA7mweXlFRgaioKJ3jFi1ahMWLFwMALl++jEmTJkGlUsHd3R2DBg3Cjz/+qD1vQ0kkEm74TUREZiklNwVJx5Nw7fY1TE6ZDADwkftg5ciViAyKNHHtiIiohkQIIUxdibZArVbDxcUFpaWleGjLQxh9/2isGLHC1NUiImoT7r4H1zzeTrrXZV/RPkTtiIKA7p8FEtxZOGzn+J0M5IiIWkhz+yWLmhNnLVwdXTknjoiIzIamWoOYPTF6ARwAbVrsnlhoqjXGrhoRERnAIM4EXGWunBNHRERm40jhEVxWX671cwGBQnUhMgoyjFgrIiKqDYM4I9NUa1BeVY4zqjNIz0/nt5pERGRyxTeL688EQHlD2co1ISKihrC4hU0sXfCaYPxe8TsAYNhHwzhhnIiITM6zvWeD8nk5G95Wh4iIjIsjcUb2u/p3nfdF6iJE7YhCSm6KiWpERERtXZhvGHzkPtpFTO4lgQS+cl8o/BRGrhkRERnCIM7EOGGciIhMTWojxcqRKwFAL5CreZ84MpH7xRERmQkGcWaAE8aJiMjUIoMisXP8TnSRd9FJ95H7cHsBIiIzwzlxZoQTxomIyJQigyIxpscYZBRk4JnPnsGjgY/i08hPOQJHRGRmOBJnRjhhnIiITE1qI0V4QDgG+QyCulzNAI6IyAwxiDMDnDBORETmJtg9GCdLTpq6GkREZACDOBPjhHEiIjJHwZ2DUaguROntUlNXhYiI7sEgzsi85d467zlhnIiIzFFw52AAwKkrp0xcEyIiuheDOCM7+eJJHJh+AF7tvRAVFIW8mDwGcEREZHZ6uPWAVCLlI5VERGaIQZyR1UwYv7/T/bC3tecjlEREZJZktjLc3+l+BnFERGaIQZyJeLb3xB83/zB1NYiIiGrVy70XMi5lYNuJbUjPT4emWmPqKhEREbhPnMl4OHngVAnnGRARkXlKyU1B2oU0qCvUmJwyGcCdedwrR67kNAAiIhPjSJyJeDh54I+/OBJHRETmJyU3BVE7oqCuUOukF6mLELUjCim5KSaqGRERAQziTMazvSdUZSpUaipNXRUiIiItTbUGMXtiICD0PqtJi90Ty0criYhMiEGciXi09wAAXCm7YuKaEBER/Z+MggxcVl+u9XMBgUJ1ITIKMoxYKyIiuhuDOBPxbO8JAFzchIiIzIryhrJF8xERUcuzyCAuKSkJgYGBkMlkCAkJQUZG7d8GKpVKTJ48GT169ICNjQ1iY2MN5tu1axd69uwJBwcH9OzZE59//nmzzlsfD6c7I3HFN4ubXAYREVmOxvYhBw8eREhICGQyGbp27Yq1a9fq5bl+/TpefvlleHl5QSaTISgoCKmpqc2qp5ezV4vmIyKilmdxQVxycjJiY2MRHx+P7OxsKBQKjBo1CgUFBQbzl5eXw93dHfHx8ejbt6/BPJmZmZgwYQKmTp2KX375BVOnTsX48eNx9OjRJp+3Pp2dOgMAFzchImoDGtuH5OXlYfTo0VAoFMjOzsZrr72G2bNnY9euXdo8FRUVeOyxx5Cfn4+dO3fizJkzWL9+Pbp06dKsuir8FPCR+0ACicHPJZDAV+4LhZ+iWechIqKmkwgh9Gcum7GBAwdiwIABWLNmjTYtKCgIY8eORUJCQp3HhoeHo1+/fkhMTNRJnzBhAtRqNb799ltt2siRI+Hq6opt27Y1+7wAoFar4eLigtLSUsjlcgBAx3c6Yt6QeZj38Lx6jycioqYzdA82psb2IfPmzcPu3buRm5urTYuOjsYvv/yCzMxMAMDatWvx7rvv4rfffoOdnV2T6lXbdalZnRKAzgInNYHdzvE7uc0AEVEzNLdfsqiRuIqKCmRlZSEiIkInPSIiAkeOHGlyuZmZmXpljhgxQltma53Xo70HH6ckIrJyTelDauuXjh8/jsrKO6sa7969G4MHD8bLL78MDw8PBAcH4+2334ZG0/xVIyODIrFz/E50keuO6vnIfRjAERGZAYva7FulUkGj0cDDw0Mn3cPDA8XFTQ+GiouL6yyzKectLy9HeXm59r1ardbL49nek49TEhFZuab0IbX1S1VVVVCpVPDy8sLFixfx/fff49lnn0VqairOnTuHl19+GVVVVXjjjTcMltuQvqlGZFAkxvQYg4yCDDz3xXPo5d4LuyfthtRG2tCmExFRK7GokbgaEonuc/pCCL201iizMedNSEiAi4uL9uXr66uXx8OJI3FERG1FY/suQ/nvTq+urkbnzp2xbt06hISEYOLEiYiPj9d5ZPNeDemb7ia1kSI8IByPBj4K5U0lAzgiIjNhUUGcm5sbpFKp3jeXJSUlet9YNoanp2edZTblvAsWLEBpaan2VVhYqJfHw8mDI3FERFauKX1Ibf2Sra0tOnXqBADw8vJC9+7dIZX+X2AVFBSE4uJiVFRUGCy3IX2TIQO8BuBkyUmUV5XXn5mIiFqdRQVx9vb2CAkJQVpamk56WloawsLCmlzu4MGD9crcu3evtsymnNfBwQFyuVzndS/P9p7cJ46IyMo1pQ+prV8KDQ3VLmIyZMgQnD9/HtXV1do8Z8+ehZeXF+zt7Q2W25C+yZABXgNQWV2JU1dONSg/ERG1LouaEwcAcXFxmDp1KkJDQzF48GCsW7cOBQUFiI6OBnDnW8aioiJs2bJFe0xOTg4A4ObNm7hy5QpycnJgb2+Pnj17AgBiYmLwyCOP4J133sGYMWPw5ZdfYt++fTh06FCDz9sUHu09cPXWVVRqKmEnbdrKYkREZP4a23dFR0fjv//9L+Li4vD8888jMzMTGzdu1K6YDAAvvvgi3n//fcTExGDWrFk4d+4c3n77bcyePbvF69/How8kkGDbiW04ozoDL2cvKPwUfLySiMhELC6ImzBhAq5evYqlS5dCqVQiODgYqamp8Pf3B3Bnc+97993p37+/9v+zsrKwdetW+Pv7Iz8/HwAQFhaG7du3Y+HChXj99dfRrVs3JCcnY+DAgQ0+b1N4tvcEAJT8VaK3AhgREVmPxvZdgYGBSE1NxZw5c7B69Wp4e3tj1apVGDdunDaPr68v9u7dizlz5qBPnz7o0qULYmJiMG9ey29b892F7yC1kWJ55nJtmo/cBytHruRKlUREJmBx+8RZKkN7QWT9noXQ9aHIeiELA7wGmLiGRETWy9T7xJmrhlyXmj3j7t4vDuCecUREzdGm9omzNh7t70xo5wqVRERkjjTVGsTsidEL4ID/2wQ8dk8sNNXN35uOiIgajkGcCXV26gwAXNyEiIjMUkZBBi6rL9f6uYBAoboQGQUZRqwVERExiDMhe6k9Ojp25EgcERGZJeUNZYvmIyKilsEgzoQ01Ro42zvjh0s/ID0/nY+jEBGRWfFy9mrRfERE1DIYxJlISm4KAlYG4FLpJey5sAfDPhqGgJUBSMlNMXXViIiIAAAKPwV85D7aRUzuJYEEvnJfKPwURq4ZEVHbxiDOBGpW+rp3nkGRughRO6IYyBERkVmQ2kixcuRKANAL5GreJ45M5H5xRERGxiDOyLjSFxERWZLIoEjsHL9Tbz9TH7kPtxcgIjIRBnFGdqTwCFf6IiIiixIZFIn8mHx8P+17ONs7Y1qfaciLyWMAR0RkIgzijKyhK1FypS8iIjInUhsphgUOQ3hAOH6/+TsfoSQiMiEGcUbm2d6zQfm40hcREZmjwT6DcfTyUT72T0RkQgzijCzMN4wrfRERkcUa2GUgblTcwPIjy7k9DhGRiTCIMzKu9EVERJYqJTcF076YBgCYv38+t8chIjIRBnEmwJW+iIjI0tRsj1N0o0gnndvjEBEZH4M4E6lZ6evA9APo07kPHvZ9mCt9ERGRWeL2OERE5oVBnAlJbaQIDwjHYN/BuFl5k49QEhGRWcooyOD2OEREZoRBnBkI7BCI/Ov5pq4GERGRQQ3d9obb4xARGQeDODMQ0CEA129fx/Xb101dFSIiIj0N3faG2+MQERkHgzgzENAhAAA4GkdERGZJ4afg9jhERGaEQZwZYBBHRETmjNvjEBGZFwZxZqCzU2c42joyiCMiIrNV2/Y4ro6u3B6HiMjILDKIS0pKQmBgIGQyGUJCQpCRUfdqWAcPHkRISAhkMhm6du2KtWvX6nweHh4OiUSi93r88ce1eRYvXqz3uaenZ4u0RyKRIKBDAIM4IiIya3dvj7M1ciu6unbFk92fZABHRGRktqauQGMlJycjNjYWSUlJGDJkCD744AOMGjUKp0+fhp+fn17+vLw8jB49Gs8//zw++eQTHD58GC+99BLc3d0xbtw4AEBKSgoqKiq0x1y9ehV9+/bFM888o1NWr169sG/fPu17qbTlHhsJ6BCAvOt5LVYeERFRa6jZHgcAfrz8I7af2o6tJ7bC29kbCj8FH6kkIjICiwviVqxYgRkzZmDmzJkAgMTERHz33XdYs2YNEhIS9PKvXbsWfn5+SExMBAAEBQXh+PHjWL58uTaI69ixo84x27dvR7t27fSCOFtb2xYbfbtXQIcAHC483CplExERtbSU3BR8euJTXL11Fc+mPAsA8JH7YOXIlRyZIyJqZRb1OGVFRQWysrIQERGhkx4REYEjR44YPCYzM1Mv/4gRI3D8+HFUVlYaPGbjxo2YOHEinJycdNLPnTsHb29vBAYGYuLEibh48WIzWqOrZq84IUSLlUlERNQaUnJTELUjCldvXdVJL1IXIWpHFFJyU0xUMyKitsGigjiVSgWNRgMPDw+ddA8PDxQXFxs8pri42GD+qqoqqFQqvfzHjh3DyZMntSN9NQYOHIgtW7bgu+++w/r161FcXIywsDBcvXpVrwwAKC8vh1qt1nnVJaBDANTlaly7fa3OfERERKakqdYgZk8MBPS/dKxJi90TC021xthVIyJqMywqiKshkegubyyE0EurL7+hdODOKFxwcDAeeughnfRRo0Zh3Lhx6N27N4YPH45vvvkGAPDRRx8ZPGdCQgJcXFy0L19f3zrbxG0GiIjIEmQUZOCy+nKtnwsIFKoLkVFQ96JjRETUdBYVxLm5uUEqleqNupWUlOiNttXw9PQ0mN/W1hadOnXSSS8rK8P27dv1RuEMcXJyQu/evXHu3DmDny9YsAClpaXaV2FhYZ3l+crvBHkf//ox0vPT+Q0mERGZJeUNZYvmIyKixrOoIM7e3h4hISFIS0vTSU9LS0NYWJjBYwYPHqyXf+/evQgNDYWdnZ1O+o4dO1BeXo4pU6bUW5fy8nLk5ubCy8vL4OcODg6Qy+U6r9qk5KbgwQ0PAgASf0zEsI+GIWBlAOcUEBGR2fFyNtzvNTUfERE1nkUFcQAQFxeHDRs2YNOmTcjNzcWcOXNQUFCA6OhoAHdGwKZNm6bNHx0djUuXLiEuLg65ubnYtGkTNm7ciLlz5+qVvXHjRowdO1ZvhA4A5s6di4MHDyIvLw9Hjx5FVFQU1Go1pk+f3qz21EwOv/fRFE4OJyIic6TwU8BH7gMJDE9jkEACX7kvFH4KI9eMiKjtsLgtBiZMmICrV69i6dKlUCqVCA4ORmpqKvz9/QEASqUSBQUF2vyBgYFITU3FnDlzsHr1anh7e2PVqlXa7QVqnD17FocOHcLevXsNnvfy5cuYNGkSVCoV3N3dMWjQIPz444/a8zZFfZPDJZAgdk8sxvQYw313iIjILEhtpFg5ciWidkRBAolOH1YT2CWOTGS/RUTUiiSCa9obhVqthouLC0pLS7WPVqbnp2PYR8PqPfbA9APajVWJiKjxDN2DqXnXJSU3BTF7YnSeJHGVuWLDUxu4TxwRUT2a2y9Z3OOU1oSTw4mI2o6kpCQEBgZCJpMhJCQEGRl1r9548OBBhISEQCaToWvXrli7dm2tebdv3w6JRIKxY8e2cK1rFxkUifyYfByYfgBbI7eil1sv9HTvifKqci7QRUTUyhjEmRAnhxMRtQ3JycmIjY1FfHw8srOzoVAoMGrUKJ3H/++Wl5eH0aNHQ6FQIDs7G6+99hpmz56NXbt26eW9dOkS5s6dC4XC+HPQpDZShAeEw8HWAZdvXMbhwsOYnDKZC3QREbUyPk5pJIaGTDXVGgSsDECRusjgvDgJJPCR+yAvJo9zC4iImsHUj1MOHDgQAwYMwJo1a7RpQUFBGDt2LBISEvTyz5s3D7t370Zubq42LTo6Gr/88gsyMzO1aRqNBkOHDsX//M//ICMjA9evX8cXX3zR4Hq1xHWpWaDr3n6sZn7czvE7+XglEdE9+DilBauZHA5Ab5UvTg4nIrIOFRUVyMrKQkREhE56REQEjhw5YvCYzMxMvfwjRozA8ePHUVlZqU1bunQp3N3dMWPGjAbVpby8HGq1WufVHPUt0AUAsXti+WglEVELYxBnYpFBkdg5fie6yLvopPvIffjtJRGRFVCpVNBoNPDw8NBJ9/DwQHFxscFjiouLDeavqqqCSqUCABw+fBgbN27E+vXrG1yXhIQEuLi4aF++vr6NbI2ujIIMvS1y7iYgUKguREZB3fP/iIiocRjEmYG7J4eP7DYSXZy7IC8mjwEcEZEVkUh0n7gQQuil1Ze/Jv3GjRuYMmUK1q9fDzc3twbXYcGCBSgtLdW+CgsLG9ECfVygi4jINCxunzhrVTM5/MKfF/Ddhe9QoamAo42jqatFRETN5ObmBqlUqjfqVlJSojfaVsPT09NgfltbW3Tq1AmnTp1Cfn4+nnzySe3n1dXVAABbW1ucOXMG3bp10yvXwcEBDg4OzW2SFhfoIiIyDY7EmZlenXtBQOA31W+mrgoREbUAe3t7hISEIC0tTSc9LS0NYWFhBo8ZPHiwXv69e/ciNDQUdnZ2eOCBB3DixAnk5ORoX0899RSGDRuGnJycZj8m2VAKPwV85D5687prSCCBr9wXCj/jr5xJRGTNGMSZmZ7uPQEAJ0tOmrgmRETUUuLi4rBhwwZs2rQJubm5mDNnDgoKChAdHQ3gzmOO06ZN0+aPjo7GpUuXEBcXh9zcXGzatAkbN27E3LlzAQAymQzBwcE6rw4dOsDZ2RnBwcGwt7c3SrvqWqALuDMnbuaAmUapCxFRW8IgzszIHeTwd/FnEEdEZEUmTJiAxMRELF26FP369cMPP/yA1NRU+Pv7AwCUSqXOnnGBgYFITU1Feno6+vXrhzfffBOrVq3CuHHjTNWEWtW2QFeNRemLuGccEVEL4z5xRtKYvSCe2PoEBAS+mfyNkWpHRGTdTL1PnLlqyeuiqdbgrYy3sCh9kd5n3DOOiEgX94mzQsGdgzkSR0REFmf9z4a3O+CecURELYtBnBnq6d4TBaUF2JS9Cen56ezwiIjI7HHPOCIi4+EWA2YmJTcFr6a9CgCYsXsGgDsbf68cuZKPoBARkdninnFERMbDkTgzkpKbgqgdUfjjrz900ovURYjaEcVJ4UREZLa4ZxwRkfEwiDMTmmoNYvbEaOcN3I1zCYiIyNzVt2ccALi3c0eYj+G98YiIqOEYxJkJziUgIiJLVt+ecQBwpewKur3fjU+WEBE1E4M4M8G5BEREZOnq2zMO4BQBIqKWwCDOTHAuARERWYPIoEhcmHUB7u3cDX7OKQJERM3HIM5M1DeXQAIJfOW+UPgpjFwzIiKixjly+QiulF2p9XNOESAiah4GcWairrkENe8TRyZCaiM1et2IiIgag1MEiIhal0UGcUlJSQgMDIRMJkNISAgyMur+Ju/gwYMICQmBTCZD165dsXbtWp3PN2/eDIlEove6fft2s87bWLXNJfCR+2Dn+J3cJ46IiCwCpwgQEbUuiwvikpOTERsbi/j4eGRnZ0OhUGDUqFEoKCgwmD8vLw+jR4+GQqFAdnY2XnvtNcyePRu7du3SySeXy6FUKnVeMpmsyedtqsigSOTH5OPA9AP438H/CwBIn57OAI6IiCwGtxsgImpdFhfErVixAjNmzMDMmTMRFBSExMRE+Pr6Ys2aNQbzr127Fn5+fkhMTERQUBBmzpyJv//971i+fLlOPolEAk9PT51Xc87bHFIbKcIDwjH/4fkAgB+LfmzxcxAREbUWbjdARNS6LCqIq6ioQFZWFiIiInTSIyIicOTIEYPHZGZm6uUfMWIEjh8/jsrKSm3azZs34e/vDx8fHzzxxBPIzs5u1nnLy8uhVqt1Xo3l1s4N3Tt2x46TO7DtxDak56dzJS8iIrII3G6AiKj1WFQQp1KpoNFo4OHhoZPu4eGB4uJig8cUFxcbzF9VVQWVSgUAeOCBB7B582bs3r0b27Ztg0wmw5AhQ3Du3LkmnzchIQEuLi7al6+vb6Pbm5Kbgss3LuPLs19icspkDPtoGAJWBrCzIyIii8DtBoiIWodFBXE1JBLdRzOEEHpp9eW/O33QoEGYMmUK+vbtC4VCgR07dqB79+54//33m3zeBQsWoLS0VPsqLCxsWOP+v5TcFETtiEJZZZlOOr+1JCIiS8LtBoiIWp5FBXFubm6QSqV6o18lJSV6o2Q1PD09Dea3tbVFp06dDB5jY2ODBx98UDsS15TzOjg4QC6X67waSlOtQcyeGO03lHfjt5ZERGRJGrqNQJG6qJVrQkRkPSwqiLO3t0dISAjS0tJ00tPS0hAWZniFq8GDB+vl37t3L0JDQ2FnZ2fwGCEEcnJy4OXl1eTzNkdGQQYuqy/X+jm/tSQiIkvR0G0E5nw3h0+ZEBE1kEUFcQAQFxeHDRs2YNOmTcjNzcWcOXNQUFCA6OhoAHceY5w2bZo2f3R0NC5duoS4uDjk5uZi06ZN2LhxI+bOnavNs2TJEnz33Xe4ePEicnJyMGPGDOTk5GjLbMh5WxI3SSUiImvRkO0GAEBVpuJ0ASKiBrI1dQUaa8KECbh69SqWLl0KpVKJ4OBgpKamwt/fHwCgVCp19m4LDAxEamoq5syZg9WrV8Pb2xurVq3CuHHjtHmuX7+OF154AcXFxXBxcUH//v3xww8/4KGHHmrweVsSN0klIiJrUbPdQNSOqDrzCQhIIEHsnliM6TEGUhupkWpIRGR5JKJmlQ9qVWq1Gi4uLigtLa13fpymWoOAlQEoUhcZnBcngQQ+ch/kxeSxkyMiaoDG3IPbEmNel5TcFPzj639AVaaqN++B6QcQHhDeqvUhIjKl5t5/Le5xyragrk1Sa94njkxkAEdERBYjMigSiSMSG5SXi5wQEdWNQZyZqm2T1C7yLtg5ficigyJNVDMiIqKmqWvj77txkRMioroxiDNjkUGRyI/Jx4HpB7D8seUAgH+E/APlVeVIz0/nFgNERGRRuMgJEVHLYBBn5qQ2UoQHhCOgQwBsJbZ4/cDrmJwyGcM+GoaAlQHs4IiIyGLcPV2gLtwTlYiobgziLEBKbgqe+ewZVIkqnfQidRG/qSQiIotSM13ArZ1bnfm4JyoRUe0YxJk5TbUGMXtiDK5SyW8qiYjIEjVmkZMvf/uydStDRGSBGMSZuYyCDFxWX671c35TSURElqihi5wkHk3kEydERPdgEGfmlDeULZqPiIjIHNQsclKfmg3A+cQJEdH/YRBn5rycvVo0HxERkTlozCInhepCpOent36liIgsBIM4M9eQ5Zjd27kjzCfMiLUiIqLGSkpKQmBgIGQyGUJCQpCRUfdj8AcPHkRISAhkMhm6du2KtWvX6ny+fv16KBQKuLq6wtXVFcOHD8exY8daswktLjIoErGDYhuUd/zO8Xyskojo/2MQZ+bu/qaytkDuStkVdHu/Gzs3IiIzlZycjNjYWMTHxyM7OxsKhQKjRo1CQUGBwfx5eXkYPXo0FAoFsrOz8dprr2H27NnYtWuXNk96ejomTZqEAwcOIDMzE35+foiIiEBRUZGxmtUixvQY06B8f976kysyExH9fxIhhP6yh9Ti1Go1XFxcUFpaCrlc3ujjU3JTELMnptZFTmoCvJ3jdyIyKLJZdSUisjbNvQc318CBAzFgwACsWbNGmxYUFISxY8ciISFBL/+8efOwe/du5ObmatOio6Pxyy+/IDMz0+A5NBoNXF1d8d///hfTpk1rUL1MfV2AO6swB6wMQJG6yOBKzHeTQAIfuQ/yYvIgtZEaqYZERC2vufdfjsRZiMigSFyYdQHu7dwNfs7tBoiIzFNFRQWysrIQERGhkx4REYEjR44YPCYzM1Mv/4gRI3D8+HFUVlYaPKasrAyVlZXo2LFjy1TcSBo6Nw7g/DgiohoM4izIkctHcKXsSq2fc7sBIiLzo1KpoNFo4OHhoZPu4eGB4uJig8cUFxcbzF9VVQWVSmXwmPnz56NLly4YPnx4rXUpLy+HWq3WeZmDmg3AOzo2LADl/DgiausYxFkQbjdARGS5JBLdec1CCL20+vIbSgeAZcuWYdu2bUhJSYFMJqu1zISEBLi4uGhfvr6+jWlCq4oMisSOqB0Nysv5cUTU1jGIsyAN3Uags1PnVq4JERE1lJubG6RSqd6oW0lJid5oWw1PT0+D+W1tbdGpUyed9OXLl+Ptt9/G3r170adPnzrrsmDBApSWlmpfhYWFTWhR6wkPCK93ReYaAgLRX0ejoqrCCDUjIjIvDOIsSEO2GwCA5754jt9OEhGZCXt7e4SEhCAtLU0nPS0tDWFhhreHGTx4sF7+vXv3IjQ0FHZ2dtq0d999F2+++Sb27NmD0NDQeuvi4OAAuVyu8zInjZkfB9xZndnnPR/2eUTU5jCIsyAN2W4AAIpuFPExEyIiMxIXF4cNGzZg06ZNyM3NxZw5c1BQUIDo6GgAd0bI7l5RMjo6GpcuXUJcXBxyc3OxadMmbNy4EXPnztXmWbZsGRYuXIhNmzYhICAAxcXFKC4uxs2bN43evpbU2PlxV8quYNyOcVh6cCkX9iKiNoNBnIWp6dy8nb1rzcOVKomIzMuECROQmJiIpUuXol+/fvjhhx+QmpoKf39/AIBSqdTZMy4wMBCpqalIT09Hv3798Oabb2LVqlUYN26cNk9SUhIqKioQFRUFLy8v7Wv58uVGb19La8z8uBqL0hchIDGAX2ASUZvAfeKMpKX34tl/cT+Gf1z7CmQ19k3dh0e7Ptrs8xERWTJz2A/NHJnzdWnM/nF3k0DCPVOJyOy1yX3ikpKSEBgYCJlMhpCQEGRk1L2k/sGDBxESEgKZTIauXbti7dq1Op+vX78eCoUCrq6ucHV1xfDhw3Hs2DGdPIsXL4ZEItF5eXp6tnjbGqrkr5IG5eMyzEREZIkaOz+uBhc8IaK2wOKCuOTkZMTGxiI+Ph7Z2dlQKBQYNWqUzmMod8vLy8Po0aOhUCiQnZ2N1157DbNnz8auXbu0edLT0zFp0iQcOHAAmZmZ8PPzQ0REBIqKinTK6tWrF5RKpfZ14sSJVm1rXRq6UiWXYSYiIktVM4XArZ1bo47jgidEZO0s7nHKgQMHYsCAAVizZo02LSgoCGPHjkVCQoJe/nnz5mH37t3Izc3VpkVHR+OXX35BZmamwXNoNBq4urriv//9r3ai+eLFi/HFF18gJyenSfVu6UdWGvOYiQQS+Mh9kBeTB6mNtNnnJiKyNOb82KApWcp1qaiqgM97PrhSdqXRxy4JX4J4RTz7PyIyK23qccqKigpkZWUhIiJCJz0iIgJHjhwxeExmZqZe/hEjRuD48eOorKw0eExZWRkqKyvRsaPuyljnzp2Dt7c3AgMDMXHiRFy8eLHWupaXl0OtVuu8WlJjHjMREChUFyI9P71F60BERGQM9rb2WPvE2gbtH3cvLnhCRNbIooI4lUoFjUajtzmqh4eH3qaoNYqLiw3mr6qqgkqlMnjM/Pnz0aVLFwwf/n8LhwwcOBBbtmzBd999h/Xr16O4uBhhYWG4evWqwTISEhLg4uKiffn6+jamqQ3S2GWYOT+OiIgsVU2f18W5S6OPvXzjMsbtGIfPTn3WCjUjIjI+iwriakgkut/ECSH00urLbygduLPvzrZt25CSkgKZTKZNHzVqFMaNG4fevXtj+PDh+OabbwAAH330kcFzLliwAKWlpdpXYWFhwxrXSI1Zhpnz44iIyJJFBkXiUuwlLAlf0qTjJ+2ahJ2ndrZwrYiIjM+igjg3NzdIpVK9UbeSkhK90bYanp6eBvPb2tqiU6dOOunLly/H22+/jb1796JPnz511sXJyQm9e/fGuXPnDH7u4OAAuVyu82ot4QHh8JH7NOgxEwGBmG9juH8cERFZJKmNFG8MfQO7xu9q9IInGqHBMzuf4cbgRGTxLCqIs7e3R0hICNLS0nTS09LSEBYWZvCYwYMH6+Xfu3cvQkNDYWdnp01799138eabb2LPnj0IDQ2tty7l5eXIzc2Fl1fDVolsTY1dhvnyjct4K+OtVqwRERFR64oMikTRnCK4t3Nv9LGcJ0dEls6igjgAiIuLw4YNG7Bp0ybk5uZizpw5KCgoQHR0NIA7jzHWrCgJ3FmJ8tKlS4iLi0Nubi42bdqEjRs3Yu7cudo8y5Ytw8KFC7Fp0yYEBASguLgYxcXFuHnzpjbP3LlzcfDgQeTl5eHo0aOIioqCWq3G9OnTjdf4OjR2ftyi9EX8JpKIiCxacxY8qZknx76QiCyRxQVxEyZMQGJiIpYuXYp+/frhhx9+QGpqKvz9/QEASqVSZ8+4wMBApKamIj09Hf369cObb76JVatWYdy4cdo8SUlJqKioQFRUFLy8vLSv5cuXa/NcvnwZkyZNQo8ePRAZGQl7e3v8+OOP2vOag8bMjwP4TSQREVm+5ix4AtzpCz2Xe2LOd3OQnp/OgI6ILILF7RNnqYy1F0/N/nGX1ZcbdRz30SEia2Yp+6EZmzVdF021Bm9lvIVF6YuaVY5bOzdM6TMFY3qMgcJPwX6RiFpFm9onjurX2PlxNTgqR0RElqxmwZMdUTsglTQ98FKVqZD4YyKGfTQMASvZLxKReWIQZ4UigyKbtPwy5wcQEZGle6bXM9g+bnuLlHVZzX6RiMwTH6c0EmM/sqKp1iAgMQCXbzTuscoabo5umNKXj5MQkXWwpscGW5I1X5eU3BTM/nY2im4UtUh57BeJqCU19/7LIM5ITNFRpuSmIGpHFASa9yPm/AAisnTWHKw0h7Vfl5aaJ3evjo4dETMwhnPJiajJGMRZCFN1lC39TaSP3AcrR65EZFBki5RHRGQM1h6sNFVbuS4t3RfWkNvL8fcBf+eXnETUaFzYhOoUGRSJS7GXmjRHzhDODyAiIkvT0n1hDXWFWrsIiud/uE0BERkPR+KMxBy+7Wyt+QFP3P8EAKDkrxJ4OXvx20giMjvmcA82R23xuqTkpiBmT0yjt+JpDE5DIKL68HFKC2EuHWVrzQ+4GzsvIjI35nIPNjdt9bpoqjXIKMjAl799iU9PfIorZVda7Vw1fSK/8CSiuzGIsxDm1lG21vyAezGgIyJzYG73YHPB66Ib0H3y6ydQ3VIZ5bzsH4naNgZxFsIcO0pjjMrdraNjR8x6aBYUfgp+E0lERmWO92BzwOuiy9j9Yg23dm6Y3HsyAjsEwr2dO7rIu7B/JLJyDOIshDl3lMaYH1AbPmZCRMZgzvdgU+J1McyU/WIN9o9E1o1BnIUw947SmPMDGoKdFxG1JHO/B5sKr0vt7u4XN2VvgrpCbeoqAWD/SGQtGMRZCEvqKE01P6Ah2HkRUVNY0j3YmHhdGqbmMcuVR1fiz1t/mro6BrF/JLIsDOIshKV2lKaaH9BYhjqvzk6dtf/PjoyobbPUe3Br43VpHHN7aqUh7p2Pzr6RyDwwiLMQlt5RmsP8gOaqqyNjp0Zk3Sz9HtxaeF2azhIDOkPq+xKU/SNR62AQZyGsoaO0lg6rIdipEVkXa7gHtwZel5bRlvpHfiFK1DIYxFkIa+soazos5Q2l9qb99dmvrb7zqk1Dg77im8W4UnaFS0gTGZm13YNbCq9Ly2tLAV192DcS1Y5BnIVoKx2lua7mZa4aM+LX2P/nt6BE/6et3IMbi9eldfELz6Zpbt94d1Do2d5T+zn7RTInDOIsRFvsKC1hNS9rd29HWFvH1lKBY2M6Vn7bSsbUFu/BDcHrYhocrTOdpgSIrd13MrhsmxjEWYi23FHym0iqTWuORJq6U+b5zev8f934C2P6jWmT9+C6tOW+yVzU9JFF6iJcKbuC/Gv52HpyK/vHNqahcw1NeW9t6bLNvbzWrmvhlUIsGL6gbQVxSUlJePfdd6FUKtGrVy8kJiZCoVDUmv/gwYOIi4vDqVOn4O3tjVdffRXR0dE6eXbt2oXXX38dFy5cQLdu3fDWW2/h6aefbtZ578aOUh+DOyIymtsA/g2T3oNN1XfVhX2TeWL/SNQGNLNfsrggLjk5GVOnTkVSUhKGDBmCDz74ABs2bMDp06fh5+enlz8vLw/BwcF4/vnn8Y9//AOHDx/GSy+9hG3btmHcuHEAgMzMTCgUCrz55pt4+umn8fnnn+ONN97AoUOHMHDgwCad917sKBuOnRcRtTgTB3Gm6rvqw77JsrB/JLIibS2IGzhwIAYMGIA1a9Zo04KCgjB27FgkJCTo5Z83bx52796N3NxcbVp0dDR++eUXZGZmAgAmTJgAtVqNb7/9Vptn5MiRcHV1xbZt25p03nuxo2w+dl5E1GQmDuJM1XfVh32Tdbi3f8woyMD7x97nfHQic9bMfsm25WvUeioqKpCVlYX58+frpEdERODIkSMGj8nMzERERIRO2ogRI7Bx40ZUVlbCzs4OmZmZmDNnjl6exMTEJp+XWp7URorwgHCdtEe7PorlEcv1grua547ZkRGRqZmq76K2497+8dGuj+L1R16vtW8E+CUokaWzqCBOpVJBo9HAw8NDJ93DwwPFxcUGjykuLjaYv6qqCiqVCl5eXrXmqSmzKectLy9HeXm59n1paSmAO996Ussb0HEA0PGuBLc7/3nQ7UHE9IvBkcIjKL5ZDPd27gCgnZx67//vOb8HO07vwNWyq8asPhG1tv9/OzbFwyem6rsMYd/UttTWNwJ3+sc3Br3RoP4x83ImPsj6ANduXTNi7YmsXDP7JYsK4mpIJBKd90IIvbT68t+b3pAyG3PehIQELFmyRC/d19e31noSEVHrunHjBlxcXExyblP1XXdj30REZF6a2i9ZVBDn5uYGqVSq9y1jSUmJ3reRNTw9PQ3mt7W1RadOnerMU1NmU867YMECxMXFad9fv34d/v7+KCgoMNkfEMaiVqvh6+uLwsJCq55jwXZal7bSTqDttPXudjo7O+PGjRvw9vY2ej1M1XcZ0hb7prb4+26t7WQbrUdbaGd9bRRCNKtfsqggzt7eHiEhIUhLS9NZQjktLQ1jxowxeMzgwYPx1Vdf6aTt3bsXoaGhsLOz0+ZJS0vTmVuwd+9ehIWFNfm8Dg4OcHBw0Et3cXGx2l/We8nl8jbRVrbTurSVdgJtp6017TRVkGKqvsuQttw3tbXfd2vGNlqPttDOutrYnH7JooI4AIiLi8PUqVMRGhqKwYMHY926dSgoKNDunbNgwQIUFRVhy5YtAO6s5vXf//4XcXFxeP7555GZmYmNGzfqrNwVExODRx55BO+88w7GjBmDL7/8Evv27cOhQ4cafF4iIqLamKrvIiIi62RxQdyECRNw9epVLF26FEqlEsHBwUhNTYW/vz8AQKlUoqCgQJs/MDAQqampmDNnDlavXg1vb2+sWrVKu88OAISFhWH79u1YuHAhXn/9dXTr1g3Jyck6++zUd14iIqLamKrvIiIiKyXIKG7fvi0WLVokbt++beqqtLq20la207q0lXYK0Xba2lba2Rxt4Rq1hTYK0TbayTZaj7bQztZuo8Vt9k1ERERERNSW2Zi6AkRERERERNRwDOKIiIiIiIgsCIM4IiIiIiIiC8IgzkiSkpIQGBgImUyGkJAQZGRkmLpKzZKQkIAHH3wQzs7O6Ny5M8aOHYszZ87o5BFCYPHixfD29oajoyPCw8Nx6tQpE9W4ZSQkJEAikSA2NlabZi3tLCoqwpQpU9CpUye0a9cO/fr1Q1ZWlvZza2hnVVUVFi5ciMDAQDg6OqJr165YunQpqqurtXkstZ0//PADnnzySXh7e0MikeCLL77Q+bwh7SovL8esWbPg5uYGJycnPPXUU7h8+bIRW1G/utpZWVmJefPmoXfv3nBycoK3tzemTZuG33//XacMS2insVhT39QW+yVr7ZOsvT+y1r6oLfRDZtUHtcpyKaRj+/btws7OTqxfv16cPn1axMTECCcnJ3Hp0iVTV63JRowYIT788ENx8uRJkZOTIx5//HHh5+cnbt68qc3z73//Wzg7O4tdu3aJEydOiAkTJggvLy+hVqtNWPOmO3bsmAgICBB9+vQRMTEx2nRraOeff/4p/P39xXPPPSeOHj0q8vLyxL59+8T58+e1eayhnf/6179Ep06dxNdffy3y8vLEZ599Jtq3by8SExO1eSy1nampqSI+Pl7s2rVLABCff/65zucNaVd0dLTo0qWLSEtLEz///LMYNmyY6Nu3r6iqqjJya2pXVzuvX78uhg8fLpKTk8Vvv/0mMjMzxcCBA0VISIhOGZbQTmOwtr6prfVL1tontYX+yFr7orbQD5lTH8QgzggeeughER0drZP2wAMPiPnz55uoRi2vpKREABAHDx4UQghRXV0tPD09xb///W9tntu3bwsXFxexdu1aU1WzyW7cuCHuv/9+kZaWJoYOHartMK2lnfPmzRMPP/xwrZ9bSzsff/xx8fe//10nLTIyUkyZMkUIYT3tvLdjaUi7rl+/Luzs7MT27du1eYqKioSNjY3Ys2eP0ereGIb+SLjXsWPHBABtYGKJ7Wwt1t43WXO/ZM19Ulvoj9pCX9QW+iFT90F8nLKVVVRUICsrCxERETrpEREROHLkiIlq1fJKS0sBAB07dgQA5OXlobi4WKfdDg4OGDp0qEW2++WXX8bjjz+O4cOH66RbSzt3796N0NBQPPPMM+jcuTP69++P9evXaz+3lnY+/PDD2L9/P86ePQsA+OWXX3Do0CGMHj0agPW0814NaVdWVhYqKyt18nh7eyM4ONii215aWgqJRIIOHToAsN52NlZb6JusuV+y5j6pLfRHbbEvaqv9UGv2QbYtWVHSp1KpoNFo4OHhoZPu4eGB4uJiE9WqZQkhEBcXh4cffhjBwcEAoG2boXZfunTJ6HVsju3bt+Pnn3/GTz/9pPeZtbTz4sWLWLNmDeLi4vDaa6/h2LFjmD17NhwcHDBt2jSraee8efNQWlqKBx54AFKpFBqNBm+99RYmTZoEwHp+nvdqSLuKi4thb28PV1dXvTyWeq+6ffs25s+fj8mTJ0MulwOwznY2hbX3TdbcL1l7n9QW+qO22Be1xX6otfsgBnFGIpFIdN4LIfTSLNUrr7yCX3/9FYcOHdL7zNLbXVhYiJiYGOzduxcymazWfJbezurqaoSGhuLtt98GAPTv3x+nTp3CmjVrMG3aNG0+S29ncnIyPvnkE2zduhW9evVCTk4OYmNj4e3tjenTp2vzWXo7a9OUdllq2ysrKzFx4kRUV1cjKSmp3vyW2s7mstbfdWvtl9pCn9QW+qO23Be1lX7IGH0QH6dsZW5ubpBKpXrRdUlJid63EZZo1qxZ2L17Nw4cOAAfHx9tuqenJwBYfLuzsrJQUlKCkJAQ2NrawtbWFgcPHsSqVatga2urbYult9PLyws9e/bUSQsKCkJBQQEA6/l5/vOf/8T8+fMxceJE9O7dG1OnTsWcOXOQkJAAwHraea+GtMvT0xMVFRW4du1arXksRWVlJcaPH4+8vDykpaVpvwEFrKudzWHNfZM190ttoU9qC/1RW+yL2lI/ZKw+iEFcK7O3t0dISAjS0tJ00tPS0hAWFmaiWjWfEAKvvPIKUlJS8P333yMwMFDn88DAQHh6euq0u6KiAgcPHrSodj/66KM4ceIEcnJytK/Q0FA8++yzyMnJQdeuXa2inUOGDNFbivvs2bPw9/cHYD0/z7KyMtjY6N72pFKpdllna2nnvRrSrpCQENjZ2enkUSqVOHnypEW1vabzPHfuHPbt24dOnTrpfG4t7Wwua+yb2kK/1Bb6pLbQH7XFvqit9ENG7YMatQwKNUnNMs4bN24Up0+fFrGxscLJyUnk5+ebumpN9uKLLwoXFxeRnp4ulEql9lVWVqbN8+9//1u4uLiIlJQUceLECTFp0iSzXx63Ie5eCUwI62jnsWPHhK2trXjrrbfEuXPnxKeffiratWsnPvnkE20ea2jn9OnTRZcuXbTLOqekpAg3Nzfx6quvavNYajtv3LghsrOzRXZ2tgAgVqxYIbKzs7UrYjWkXdHR0cLHx0fs27dP/Pzzz+Jvf/ubWS3tLETd7aysrBRPPfWU8PHxETk5OTr3pvLycm0ZltBOY7C2vqmt9kvW1ie1hf7IWvuittAPmVMfxCDOSFavXi38/f2Fvb29GDBggHbJY0sFwODrww8/1Oaprq4WixYtEp6ensLBwUE88sgj4sSJE6ardAu5t8O0lnZ+9dVXIjg4WDg4OIgHHnhArFu3Tudza2inWq0WMTExws/PT8hkMtG1a1cRHx+vc3O11HYeOHDA4L/J6dOnCyEa1q5bt26JV155RXTs2FE4OjqKJ554QhQUFJigNbWrq515eXm13psOHDigLcMS2mks1tQ3tdV+yRr7JGvvj6y1L2oL/ZA59UESIYRo3NgdERERERERmQrnxBEREREREVkQBnFEREREREQWhEEcERERERGRBWEQR0REREREZEEYxBEZSVJSEjZv3myUc5WVlWHx4sVIT083yvms1aFDhzBz5kyEhITAwcEBEokE+fn5pq4WERERtXEM4oiMxNhB3JIlSxjENdP+/fuxb98++Pn5WcxGo0RERGT9GMQRUbOVlZWZugqt4vXXX0d+fj4+//xzPP7446auDhEREREABnFEtTp06BAeffRRODs7o127dggLC8M333yjk2fx4sWQSCR6x27evFnn0buAgACcOnUKBw8ehEQigUQiQUBAAAAgPT0dEokEn3zyCeLi4uDp6QlHR0cMHToU2dnZOuWGh4cjPDxc73zPPfectrz8/Hy4u7sDAJYsWaI933PPPVdrWxtTh+eeew7t27fHiRMnEBERAWdnZzz66KMAgD///BMvvfQSunTpAnt7e3Tt2hXx8fEoLy/XKaO6uhrvv/8++vXrB0dHR3To0AGDBg3C7t27dfIlJydj8ODBcHJyQvv27TFixAi9+ly8eBETJ06Et7c3HBwc4OHhgUcffRQ5OTnaPN9//z3Cw8PRqVMnODo6ws/PD+PGjas3+LSx4S2SiIiIzA//QiEy4ODBg/jb3/6G0tJSbNy4Edu2bYOzszOefPJJJCcnN7q8zz//HF27dkX//v2RmZmJzMxMfP755zp5XnvtNVy8eBEbNmzAhg0b8PvvvyM8PBwXL15s1Lm8vLywZ88eAMCMGTO053v99dfrPbahdaioqMBTTz2Fv/3tb/jyyy+xZMkS3L59G8OGDcOWLVsQFxeHb775BlOmTMGyZcsQGRmpc/xzzz2HmJgYPPjgg0hOTsb27dvx1FNP6cw3e/vttzFp0iT07NkTO3bswMcff4wbN25AoVDg9OnT2nyjR49GVlYWli1bhrS0NKxZswb9+/fH9evXAdwJah9//HHY29tj06ZN2LNnD/7973/DyckJFRUVjbq2RERERGZBEJGeQYMGic6dO4sbN25o06qqqkRwcLDw8fER1dXVQgghFi1aJAz9M/rwww8FAJGXl6dN69Wrlxg6dKhe3gMHDggAYsCAAdpyhRAiPz9f2NnZiZkzZ2rThg4darCM6dOnC39/f+37K1euCABi0aJFDWpvY+owffp0AUBs2rRJp4y1a9cKAGLHjh066e+8844AIPbu3SuEEOKHH34QAER8fHyt9SkoKBC2trZi1qxZOuk3btwQnp6eYvz48UIIIVQqlQAgEhMTay1r586dAoDIycmp5yrU7d1339X7mRIRERGZAkfiiO7x119/4ejRo4iKikL79u216VKpFFOnTsXly5dx5syZFj/v5MmTdR7N9Pf3R1hYGA4cONDi52qJOowbN07n/ffffw8nJydERUXppNc8xrl//34AwLfffgsAePnll2utx3fffYeqqipMmzYNVVVV2pdMJsPQoUO1C7Z07NgR3bp1w7vvvosVK1YgOzsb1dXVOmX169cP9vb2eOGFF/DRRx81emSTiIiIyNwwiCO6x7Vr1yCEgJeXl95n3t7eAICrV6+2+Hk9PT0NprXGuZpbh3bt2kEul+ukXb16FZ6ennpzBDt37gxbW1ttGVeuXIFUKjV4rhp//PEHAODBBx+EnZ2dzis5ORkqlQoAIJFIsH//fowYMQLLli3DgAED4O7ujtmzZ+PGjRsAgG7dumHfvn3o3LkzXn75ZXTr1g3dunXDypUrG3l1iIiIiMyDrakrQGRuXF1dYWNjA6VSqffZ77//DgBwc3MDAMhkMgBAeXk5HBwctPlqgozGKC4uNpjWqVMn7XuZTIbS0lK9fE05X1PrAMDgYi6dOnXC0aNHIYTQ+bykpARVVVXaa+bu7g6NRoPi4mKDgTLwf9d3586d8Pf3r7PO/v7+2LhxIwDg7Nmz2LFjBxYvXoyKigqsXbsWAKBQKKBQKKDRaHD8+HG8//77iI2NhYeHByZOnFhn+URERETmhiNxRPdwcnLCwIEDkZKSglu3bmnTq6ur8cknn8DHxwfdu3cHAO2KkL/++qtOGV999ZVeuQ4ODjrl3Wvbtm0QQmjfX7p0CUeOHNFZjTIgIABnz57VWe3x6tWrOHLkiN65ANR5vqbWoTaPPvoobt68iS+++EInfcuWLdrPAWDUqFEAgDVr1tRa1ogRI2Bra4sLFy4gNDTU4MuQ7t27Y+HChejduzd+/vlnvc+lUikGDhyI1atXA4DBPERERETmjiNxRAYkJCTgsccew7BhwzB37lzY29sjKSkJJ0+exLZt27QjTaNHj0bHjh0xY8YMLF26FLa2tti8eTMKCwv1yuzduze2b9+O5ORkdO3aFTKZDL1799Z+XlJSgqeffhrPP/88SktLsWjRIshkMixYsECbZ+rUqfjggw8wZcoUPP/887h69SqWLVum92ijs7Mz/P398eWXX+LRRx9Fx44d4ebmpg06a9OQOtRm2rRpWL16NaZPn478/Hz07t0bhw4dwttvv43Ro0dj+PDhAO6Mik2dOhX/+te/8Mcff+CJJ56Ag4MDsrOz0a5dO8yaNQsBAQFYunQp4uPjcfHiRYwcORKurq74448/cOzYMTg5OWHJkiX49ddf8corr+CZZ57B/fffD3t7e3z//ff49ddfMX/+fADA2rVr8f333+Pxxx+Hn58fbt++jU2bNgGAtk61uXLlCg4ePAgAOHHiBIA7c/rc3d3h7u6OoUOH1ntdiIiIiFqcaddVITJfGRkZ4m9/+5twcnISjo6OYtCgQeKrr77Sy3fs2DERFhYmnJycRJcuXcSiRYvEhg0b9FYyzM/PFxEREcLZ2VkA0K4mWbMy5Mcffyxmz54t3N3dhYODg1AoFOL48eN65/voo49EUFCQkMlkomfPniI5OVlvdUohhNi3b5/o37+/cHBwEADE9OnTa21rY+owffp04eTkZLCcq1eviujoaOHl5SVsbW2Fv7+/WLBggbh9+7ZOPo1GI9577z0RHBws7O3thYuLixg8eLDe9f3iiy/EsGHDhFwuFw4ODsLf319ERUWJffv2CSGE+OOPP8Rzzz0nHnjgAeHk5CTat28v+vTpI9577z1RVVUlhBAiMzNTPP3008Lf3184ODiITp06iaFDh4rdu3fXej3uvS6GXoZWCSUiIiIyBokQdz07RURGl56ejmHDhuGzzz7TW9mxLdWBiIiIiBqGc+KIiIiIiIgsCIM4IiIiIiIiC8LHKYmIiIiIiCwIR+KIiIiIiIgsCIM4IiIiIiIiC8IgjoiIiIiIyIJws28jqa6uxu+//w5nZ2ftRtFERGQcQgjcuHED3t7esLHh95dERGTZGMQZye+//w5fX19TV4OIqE0rLCyEj4+PqatBRETULAzijMTZ2RnAnT8g5HK5iWtDRNS2qNVq+Pr6au/FREREloxBnJHUPEIpl8sZxBERmQgfZyciImtgtRMDkpKSEBgYCJlMhpCQEGRkZNSaV6lUYvLkyejRowdsbGwQGxtbZ9nbt2+HRCLB2LFjW7bSRERERERE9bDKIC45ORmxsbGIj49HdnY2FAoFRo0ahYKCAoP5y8vL4e7ujvj4ePTt27fOsi9duoS5c+dCoVC0RtWJiIiIiIjqZJVB3IoVKzBjxgzMnDkTQUFBSExMhK+vL9asWWMwf0BAAFauXIlp06bBxcWl1nI1Gg2effZZLFmyBF27dm2t6hMREREREdWq0XPiNBoNKisrW6MuLaKiogIqlQqjR4/G7du3telRUVH47bffdNIM6dy5M+RyucF877//Ph544AE8++yzOHnyJKRSab3l3V0vf39/VFRUNPgYIiJqGDs7O0ilUlNXg4iIyCgkQgjRkIxCCBQXF+P69eutXKXm0Wg0uHz5Mjw9PeHg4KBNLy0txc2bN9GlS5c6jy8uLoa9vT06duyok15eXo4rV67Ay8sLUqkUKpUK1dXV6Ny5s8FyhBC4+9JWV1ejqKgIvr6+3KOIiKgVdOjQAZ6engYXL1Gr1XBxcUFpaSkXlyIiIovX4JG4mgCuc+fOaNeundmu8FUz0uXr6wsnJydteklJCa5fv47AwMB6y3BwcIC3t7f2vUajwfnz59GvXz/t8tR2dnbQaDTw9/c3WEZJSQlKSkp00tzc3BAQEMBvi4mIWpAQAmVlZdp7rpeXl4lrRERE1LoaFMRpNBptANepU6fWrlOz2NvbAwBsbGwgk8n0Prs37V42NjawtbXVyVdWVobKykpcunRJL//JkycRHBysV66Pj4/OqJ9Go8Gvv/4KmUzGII6IqIU5OjoCuPMFWufOnXmfJSIiq9agIK5mDly7du1atTItwcbGBk5OTlCr1XB1ddWmq9VqdOjQoUllymQy9OrVSyetqKgIGo0Gfn5+2sDx3noQEZHx1PRRlZWVDOKIiMiqNWphE3N9hPJeHh4eyMvLg5OTE5ycnKBSqVBRUQF3d3cAwOXLl1FZWanzaGVZWRmAOyNmVVVVKCsrg0QigaOjI2xsbLTf8tao+QPh3nQiIjINS+mjiIiImssqh4s6duwIX19f/P777zh9+jRu3LiB+++/Hw4ODkhPT4evry9UKpXOMadPn8bp06dRVlaGP//8E6dPn8a5c+dM1ALzkZ+fD4lEgpycnBYve926ddqFXhITE7F48WL069evxc9DpvPbb79h0KBBkMlk/Nk2UHp6OiQSiXYRqc2bNzf5KYK63Ptv+97ztua5iIiIqHmMGsRpqjVIz0/HthPbkJ6fDk21ptXO1blzZ8yePRsff/wxevbsqV2QJCwsDEqlEqGhoTr5Q0ND9V59+vSptfzAwEDcd999rVb/xpBIJPjiiy+aXc5zzz2HsWPHNruchlCr1XjllVcwb948FBUV4YUXXsDcuXOxf//+ZpUbHh6O2NjYlqkkNduiRYvg5OSEM2fONPtnW5fW/AKgKUHU4cOHYWtr2yJ1mjBhAs6ePdugvI2pq6+vL5RKJYKDg5tRO32G7iOtdS4iIqK2qtH7xDVVSm4KYvbE4LL6sjbNR+6DlSNXIjIo0ljVgL29PTw9PY12PjKsoKAAlZWVePzxx3VWkmvfvn2tx1RUVBicf2gNNBoNJBKJ3lxKS2/zhQsX8Pjjj9e6iqs1Ki0txbRp0/Doo4/ijz/+aHZ5jo6OLf7Yds3vlbHuhVKplPddIiKiliQa4NatW+L06dPi1q1bDcmuZ9fpXUKyWCKwGDovyWKJkCyWiF2ndzWp3LpMnz5dANB55eXliQMHDggA4tq1a0IIIT788EPh4uIivvrqK9G9e3fh6Ogoxo0bJ27evCk2b94s/P39RYcOHcQrr7wiqqqqtOWXl5eLf/7zn8Lb21u0a9dOPPTQQ+LAgQO11uf8+fMCgDh+/Lg27dq1awKA9riaun399deiT58+wsHBQTz00EPi119/rbVcf39/nTb6+/trP0tKShJdu3YVdnZ2onv37mLLli21lrNo0SK963XgwAGRl5cnAIhdu3aJ8PBw4ejoKPr06SOOHDmic/zhw4eFQqEQMplM+Pj4iFmzZombN28aPNeHH35o8GezaNEi0bdvX22+6dOnizFjxoi3335beHl5adu2evVqcd999wkHBwfRuXNnMW7cOG1+Q+Ua8ueff4qpU6eKDh06CEdHRzFy5Ehx9uxZnTyHDh0SjzzyiHB0dBQdOnQQERER4s8//xRCCKHRaMS///1v0a1bN2Fvby98fX3Fv/71LyGE0PsdE0KI7Oxsnfrc/XsXFBQkpFKpuHjxovD39xdvvvmmmD59upDL5WLatGkNur7+/v7irbfeEv/zP/8j2rdvL3x9fcUHH3yg057CwkIxYcIE4erqKtq1aydCQkLEjz/+qP189+7dYsCAAcLBwUEEBgaKxYsXi8rKSoPXr+YaLFmyRHTp0kXY29uLvn37im+//Vb7+b0/i0WLFhks5/bt22LWrFnC3d1dODg4iCFDhohjx45pP6+5Vnf7/PPPRc3ty9Dv04cffqitQ1JSkhg5cqSQyWQiICBA7NixQ1tOfT+rms8b0o4aEyZMEAsXLtT7fa7NN998I+6//34hk8lEeHi4tj333qNq5OTkiPDwcNG+fXvh7OwsBgwYIH766ac662ro96rm33Z2drbOtajr/mOoTe+9957232Z995GacwkhRHp6unjwwQeFvb298PT0FPPmzdP5fRs6dKiYNWuW+Oc//ylcXV2Fh4dHvde+rr6qtLRUABClpaV1lkFERGQJWj2Iq9JUCZ8VPnoB3N2BnO8KX1Glqaq/sEa4fv26GDx4sHj++eeFUqkUSqVSVFVVGQzi7OzsxGOPPSZ+/vlncfDgQdGpUycREREhxo8fL06dOiW++uorYW9vL7Zv364tf/LkySIsLEz88MMP4vz58+Ldd98VDg4OeoFAjcYEcUFBQWLv3r3i119/FU888YQICAgQFRUVBsstKSnR/tGqVCpFSUmJEEKIlJQUYWdnJ1avXi3OnDkj/vOf/wipVCq+//57g+XcuHFDjB8/XowcOVJ7vcrLy7V/fD3wwAPi66+/FmfOnBFRUVHC399f+wfXr7/+Ktq3by/ee+89cfbsWXH48GHRv39/8dxzzxk8V1lZmdi3b58AII4dO6b92RgK4tq3by+mTp0qTp48KU6cOCF++uknIZVKxdatW0V+fr74+eefxcqVK+v8mRvy1FNPiaCgIPHDDz+InJwcMWLECHHfffdpr3N2drZwcHAQL774osjJyREnT54U77//vrhy5YoQQohXX31VuLq6is2bN4vz58+LjIwMsX79ep2fY31BnJ2dnQgLCxOHDx8Wv/32m7h586bw9/cXcrlcvPvuu+LcuXPi3LlzDbq+/v7+omPHjmL16tXi3LlzIiEhQdjY2Ijc3Fztz7dr165CoVCIjIwMce7cOZGcnKwNxvfs2SPkcrnYvHmzuHDhgti7d68ICAgQixcvNnj9hBBixYoVQi6Xi23btonffvtNvPrqq8LOzk77b0CpVIpevXqJ//3f/xVKpVLcuHHDYDmzZ88W3t7eIjU1VZw6dUpMnz5duLq6iqtXr2qvVV1BXFlZmfjf//1f0atXL+3PvaysTAhxJ4jr1KmTWL9+vThz5oxYuHChkEql4vTp0w36WZWXl4vExEQhl8u1ZdfWDiGE2LRpkwgNDRWVlZUNCuIKCgqEg4ODiImJEb/99pv45JNPhIeHR51BXK9evcSUKVNEbm6uOHv2rNixY4fIycmps66Gfq9qC+Lquv/UF8TVdx+pOdfly5dFu3btxEsvvSRyc3PF559/Ltzc3HSCtKFDhwq5XC4WL14szp49Kz766CMhkUjE3r17a72eDOKIiKitaFYQ91fFXyLr96w6Xx8c/6DWAO7u1wfHP6i3rKzfs8RfFX81uHFDhw4VMTExOmmGgjgA4vz589o8//jHP0S7du10/lgbMWKE+Mc//iGEuBOQSSQSUVRUpFP2o48+KhYsWGCwLo0J4u4OFq9evSocHR1FcnJyre0EID7//HOdtLCwMPH888/rpD3zzDNi9OjRtZZTM/J1t5o/vjZs2KBNO3XqlACgDRCmTp0qXnjhBZ3jMjIyhI2NTa2B/71BjRD6fyBOnz5deHh4iPLycm3arl27hFwuF2q12mC5hn7m9zp79qwAIA4fPqxNU6lUwtHRUTtKM2nSJDFkyBCDx6vVauHg4KAN2u7V0CAOgMjJydE51t/fX4wdO1YnrSHX19/fX0yZMkX7eXV1tejcubNYs2aNEEKIDz74QDg7O2sDo3spFArx9ttv66R9/PHHwsvLy2B+IYTw9vYWb731lk7agw8+KF566SXt+759+9Y5enLz5k1hZ2cnPv30U21aRUWF8Pb2FsuWLRNC1B/ECWE4uBDizr+N6OhonbSBAweKF198UQjRuFHT+pw9e1Z07txZnDlzps463W3BggUiKChIVFdXa9PmzZtXZxDn7OwsNm/ebLC82upq6PeqtiCurvtPfUGcEHXfR2rO9dprr4kePXrotHv16tWiffv2QqPRCCHu/Ft++OGHdcp58MEHxbx58wy2XQgGcURE1HY0a07cb6rfELIupDlFaP3j6380KF/WC1kY4DWgRc5Zo127dujWrZv2vYeHBwICAnTmZ3l4eKCkpAQA8PPPP0MIge7du+uUU15e3iKboQ8ePFj7/x07dkSPHj2Qm5vbqDJyc3Pxwgsv6KQNGTIEK1eubFKd7l7kpWYOW0lJCR544AFkZWXh/Pnz+PTTT7V5hBCorq5GXl4egoKCmnROAOjdu7fOnLDHHnsM/v7+6Nq1K0aOHImRI0fi6aefbtQehrm5ubC1tcXAgQO1aZ06ddK5zjk5OXjmmWdqPb68vByPPvpoE1t1h729vcHFc+5ddKeh1/fusiQSCTw9PbW/szk5Oejfvz86duxosC5ZWVn46aef8NZbb2nTNBoNbt++jbKyMr3rq1ar8fvvv2PIkCE66UOGDMEvv/zSkOYDuDNnrrKyUqccOzs7PPTQQ43+na/N3f+eat639CqJGo0GkydPxpIlS/TuC3XJzc3FoEGDdJbGv7e+94qLi8PMmTPx8ccfY/jw4XjmmWd07l+1uff3qjYtcf+pT25uLgYPHqzT7iFDhuDmzZu4fPky/Pz8AEDv34eXl5f2d5qIiKgta1YQ94DbA8h6IavOPMd/P96gAO2DJz5AqHf9f2Q84PZAg+vXUHZ2djrvJRKJwbTq6moAQHV1NaRSKbKysvQ2lK1tYY6aBSuEENq0mk3UG6Ip+x/de4wQosn7KN19PWrKuPt6/OMf/8Ds2bP1jqv5Y6ypnJycdN47Ozvj559/Rnp6Ovbu3Ys33ngDixcvxk8//dTgVfnu/hncm17TtroWkqhvkYmG/qwdHR0N/jzubXNDr29dv7P11bm6uhpLlixBZKT+IkMymazW45r7O1Zzjeoqx8bGRu9n1ph/O4bcXfbd9Whq2Tdu3MDx48eRnZ2NV155BcCdayqEgK2tLfbu3Yu//e1vesfV9rtYl8WLF2Py5Mn45ptv8O2332LRokXYvn07nn766TqPu/f3qjFa+mdh6PfE0O9CXb/TREREbVmzgrh2du3qHRXr69EXb/7wJorURRDQ/4NFAgl85D6Y0X8GpDZSAyU0nb29PTSalt/GoH///tBoNCgpKYFCoWjQMTUbjSuVSm1abaMBP/74o/aP82vXruHs2bN44IHag1c7Ozu9dgYFBeHQoUOYNm2aNu3IkSN1joo19XoNGDAAp06dMtqWC7a2thg+fDiGDx+ORYsWoUOHDvj+++8RGRnZoDb07NkTVVVVOHr0KMLCwgAAV69exdmzZ3VGtfbv348lS5boHX///ffD0dER+/fvx8yZM/U+v/tn7erqCqD2n3VDtMT17dOnDzZs2IA///zT4GjcgAEDcObMmQafQy6Xw9vbG4cOHcIjjzyiTT9y5AgeeuihBtfrvvvug729PQ4dOoTJkycDuBMUHD9+XLtVhLu7O27cuIG//vpLG4jcez3r+rn/+OOPOv8OfvzxR/Tv319bNlD3z6ohv1NyuRwnTpzQSUtKSsL333+PnTt3IjAw0OBxPXv21Nse5Mcff6zzXADQvXt3dO/eHXPmzMGkSZPw4Ycf4umnn26Re15d9x93d3cUFxfrBGFNuV49e/bErl27dMo5cuQInJ2d0aVLl2bVn4iIqC1o9X3ipDZSrBx55xE+CXS/ea15nzgyscUDOAAICAjA0aNHkZ+fD5VK1WLf4Hbv3h3PPvsspk2bhpSUFOTl5eGnn37CO++8g9TUVIPHODo6onfv3li2bBlOnz6NH374AQsXLjSYd+nSpdi/fz9OnjyJ5557Dm5ubnXu3xYQEID9+/ejuLgY165dAwD885//xObNm7F27VqcO3cOK1asQEpKCubOnVtnOb/++ivOnDkDlUrV4G/Y582bh8zMTLz88svIycnBuXPnsHv3bsyaNatBxzfG119/jVWrViEnJweXLl3Cli1bUF1djR49emjbUN/P/P7778eYMWPw/PPP49ChQ/jll18wZcoUdOnSBWPGjAEALFiwAD/99BNeeukl/Prrr/jtt9+wZs0aqFQqyGQyzJs3D6+++iq2bNmCCxcu4Mcff8TGjRsB3AlMfH19sXjxYpw9exbffPMN/vOf/zS5zS1xfSdNmgRPT0+MHTsWhw8fxsWLF7Fr1y5kZmYCAN544w1s2bIFixcvxqlTp5Cbm4vk5ORaf0eBO79j77zzDpKTk3HmzBnMnz8fOTk5iImJaXC9nJyc8OKLL+Kf//wn9uzZg9OnT+P5559HWVkZZsyYAQAYOHAg2rVrh9deew3nz5/H1q1bsXnzZp1yAgICkJeXh5ycHKhUKpSXl2s/++yzz7Bp0yacPXsWixYtwrFjx7SjZQ35WQUEBODmzZvYv38/VCoVysrK9NphY2OD4OBgnVfnzp0hk8kQHBxc6yhYdHQ0Lly4gLi4OJw5c8Zg2+5269YtvPLKK0hPT8elS5dw+PBh/PTTT9ovHxpS1/rUdf8JDw/HlStXsGzZMly4cAGrV6/Gt99+q3e96ruPvPTSSygsLMSsWbPw22+/4csvv8SiRYsQFxent80GERERGdCQiXPN3WJAiDvbDNy7SqXvCt9W2V6gxpkzZ8SgQYOEo6NjvVsM3M3Q5P17J+tXVFSIN954QwQEBAg7Ozvh6ekpnn766Vq3A6iqqhI7duwQAwcOFI6OjqJfv35i7969Bhc2+eqrr0SvXr2Evb29ePDBB/UWv7jX7t27xX333SdsbW2bvMWAEHdWunzsscdE+/bt61wa/N4FWYQQ4tixY9pjnZycRJ8+ffQWvbhbQxc2uXeBhIyMDDF06FDh6uqq3e7g7kVfDP3MDanZYsDFxUU4OjqKESNG6K0smp6eLsLCwoSDg4Po0KGDGDFihPb3RqPRiH/961/C399f2NnZCT8/P52FQQ4dOiR69+4tZDKZUCgU4rPPPmvQYhn+/v7ivffe00uv7/oaOu7eRUXy8/PFuHHjhFwuF+3atROhoaHi6NGj2s/37NkjwsLChKOjo5DL5eKhhx4S69atM3j9aq5BzRYDdnZ2elsMGKqDIbdu3RKzZs0Sbm5uBrcYEOLOQib33XefkMlk4oknnhDr1q3TWdjk9u3bYty4caJDhw56WwysXr1aPPbYY8LBwUH4+/uLbdu26ZRd389KCCGio6NFp06dGrTFQI2GbjHw1VdfabfMUCgUYtOmTbXeo8rLy8XEiROFr6+vsLe3F97e3uKVV17RuTcbqquh34/aFjap7/6zZs0a4evrK5ycnMS0adPEW2+9pXPfaeh9pCFbDNy7SNGYMWPE9OnTa72WXNiEiIjaCokQ9U/KuH37NvLy8hAYGFjn/Jj6aKo1yCjIgPKGEl7OXlD4KVplBM4caTQaZGdno3///nrz6Gqkp6dj2LBhuHbtWoPndxFR7SQSCT7//PM6R7LJetTVV6nVari4uKC0tBRyudxENSQiImoZzZoT11hSGynCA8KNeUoiIiIiIiKrwskHREREREREFsSoI3FUt/Dw8CYtOU5EhvHfExEREVkjjsQRERERERFZEAZxREREREREFqRRQRwfTSIiInPFPoqIiNqKBgVxdnZ2ANCkjWOJiIiMoaaPqumziIiIrFWDFjaRSqXo0KEDSkpKAADt2rWDRCJp1YpZG41GA+DOPka17RNHRESNJ4RAWVkZSkpK0KFDB95jiYjI6jV4dUpPT08A0AZy1DjV1dVQqVTIz8+HjQ2nIhIRtbQOHTpo+yoiIiJrJhGNnESg0WhQWVnZWvWxWjdv3kRoaCiOHz+O9u3bm7o6RERWxc7Ors4ROLVaDRcXF5SWlkIulxuxZkRERC2v0fvESaVSPqrSBBUVFbh06RKOKo9iZK+RkNrwGhIRERERUeNZ7XN9SUlJCAwMhEwmQ0hICDIyMmrNq1QqMXnyZPTo0QM2NjaIjY3Vy7N+/XooFAq4urrC1dUVw4cPx7Fjxxpdrye2PoGAlQFIyU1p9LFERERERERWGcQlJycjNjYW8fHxyM7OhkKhwKhRo1BQUGAwf3l5Odzd3REfH4++ffsazJOeno5JkybhwIEDyMzMhJ+fHyIiIlBUVNTo+hWpixC1I4qBHBERERERNVqj58RZgoEDB2LAgAFYs2aNNi0oKAhjx45FQkJCnceGh4ejX79+SExMrDOfRqOBq6sr/vvf/2LatGn11qlmPgbmA5ABEkjgI/dBXkweH60kImplnBNHRETWxOpG4ioqKpCVlYWIiAid9IiICBw5cqTFzlNWVobKykp07NjR4Ofl5eVQq9U6r7sJCBSqC5FRUPtjnkRERERERPeyuiBOpVJBo9HAw8NDJ93DwwPFxcUtdp758+ejS5cuGD58uMHPExIS4OLion35+voazKe8oWyxOhERERERkfWzuiCuxr2bkQshWmyD8mXLlmHbtm1ISUmBTCYzmGfBggUoLS3VvgoLCw3m83L2apE6ERERERFR29DoLQbMnZubG6RSqd6oW0lJid7oXFMsX74cb7/9Nvbt24c+ffrUms/BwQEODg61fl4zJ07hp2h2nYiIiIiIqO2wupE4e3t7hISEIC0tTSc9LS0NYWFhzSr73XffxZtvvok9e/YgNDS0yeVIcGdEMHFkIhc1ISIiIiKiRrG6kTgAiIuLw9SpUxEaGorBgwdj3bp1KCgoQHR0NIA7jzoWFRVhy5Yt2mNycnIAADdv3sSVK1eQk5MDe3t79OzZE8CdRyhff/11bN26FQEBAdqRvvbt26N9+/aNqp+P3AeJIxMRGRTZAq0lIiIiIqK2xCq3GADubPa9bNkyKJVKBAcH47333sMjjzwCAHjuueeQn5+P9PR0bX5D8+X8/f2Rn58PAAgICMClS5f08ixatAiLFy+utz41y1uP3DASX//P1xyBIyIyIm4xQERE1sRqgzhzU/MHxOObHsfX//O1qatDRNSmMIgjIiJrYnVz4sxdyV8lpq4CERERERFZMAZxRqYqU5m6CkREREREZMEYxBkZR+KIiIiIiKg5GMQZ2V8Vf6GssszU1SAiIiIiIgvFIM4EOBpHRERERERNxSDOBP64+Yepq0BERERERBaKQZwJ/PEXgzgiIiIiImoaBnEmwMcpiYiIiIioqRjEGVmndp34OCURERERETUZgzgjc2/nzscpiYiIiIioyRjEGVnn9p0ZxBERERERUZMxiDOyzu06c04cERERERE1GYM4I3Nr58Y5cURERERE1GQM4oyssxMfpyQiIiIioqZjEGdknZ06489bf6JSU2nqqhARERERkQViEGdk7k7uAIArZVdMXBMiIiIilyF4OwAAKoZJREFUIrJEDOKMzL3dnSCO8+KIiIiIiKgpGMQZWWenzgDAFSqJiIiIiKhJGMQZWc3jlFzchIiIiIiImoJBnJHJbGWQO8j5OCURERERETWJ1QZxSUlJCAwMhEwmQ0hICDIyMmrNq1QqMXnyZPTo0QM2NjaIjY01mG/Xrl3o2bMnHBwc0LNnT3z++eeNrpemWgNne2ekX0pHen46NNWaRpdBRERERERtl1UGccnJyYiNjUV8fDyys7OhUCgwatQoFBQUGMxfXl4Od3d3xMfHo2/fvgbzZGZmYsKECZg6dSp++eUXTJ06FePHj8fRo0cbVbfgNcEoulGE1HOpGPbRMASsDEBKbkqj20hERERERG2TRAghTF2JljZw4EAMGDAAa9as0aYFBQVh7NixSEhIqPPY8PBw9OvXD4mJiTrpEyZMgFqtxrfffqtNGzlyJFxdXbFt27Z666RWq+Hi4gLMByD7v3QJJACAneN3IjIosv7GERFRo9Xcg0tLSyGXy01dHSIiomaxupG4iooKZGVlISIiQic9IiICR44caXK5mZmZemWOGDGi1jLLy8uhVqt1XoYI3ImhY/fE8tFKIiIiIiKql9UFcSqVChqNBh4eHjrpHh4eKC4ubnK5xcXFjSozISEBLi4u2pevr2+tZQsIFKoLkVFQ+7w9IiIiIiIiwAqDuBoSiUTnvRBCL601y1ywYAFKS0u1r8LCwnrLV95QNqt+RERERERk/WxNXYGW5ubmBqlUqjdCVlJSojeS1hienp6NKtPBwQEODg6NOoeXs1eT60dERERERG2D1Y3E2dvbIyQkBGlpaTrpaWlpCAsLa3K5gwcP1itz7969zSqzhgQS+Mp9ofBTNLssIiIiIiKyblY3EgcAcXFxmDp1KkJDQzF48GCsW7cOBQUFiI6OBnDnUceioiJs2bJFe0xOTg4A4ObNm7hy5QpycnJgb2+Pnj17AgBiYmLwyCOP4J133sGYMWPw5ZdfYt++fTh06FCz6lqzOmXiyERIbaTNKouIiIiIiKyfVQZxEyZMwNWrV7F06VIolUoEBwcjNTUV/v7+AO5s7n3vnnH9+/fX/n9WVha2bt0Kf39/5OfnAwDCwsKwfft2LFy4EK+//jq6deuG5ORkDBw4sFF185Z74/eK37XvfeQ+SByZyO0FiIiIiIioQaxynzhzVLNH0Z/X/sQv13/BhJ0T8LeAv+GTyE84AkdE1Mq4TxwREVkTq5sTZ+6kNlKEB4QjyC0INjY2DOCIiIiIiKhRGMSZiI/cB5fVl01dDSIiIiIisjAM4kyEQRwRERERETUFgzgTqQniOCWRiIiIiIgag0GcifjIfVChqYCqTGXqqhARERERkQVhEGciPnIfAOAjlURERERE1CgM4kyEQRwRERERETUFgzgT6ezUGbY2tgziiIiIiIioURjEmYiNxAZdnLswiCMiIiIiokZhEGdCPnIfXL7BII6IiIiIiBqOQZwJca84IiIiIiJqLAZxJsQgjoiIiIiIGotBnAlxw28iIiIiImosBnEm5CP3QVllGa7fvm7qqhARERERkYVgEGdC3CuOiIiIiIgai0GcCdUEcYXqQhPXhIiIiIiILAWDOBNyb+cOCSRIyU1Ben46NNUaU1eJiIiIiIjMHIM4E0nJTcF9798HAYGN2Rsx7KNhCFgZgJTcFFNXjYiIiIiIzBiDOBNIyU1B1I4ovblwReoiRO2IYiBHRERERES1YhBnZJpqDWL2xEBAf1uBmrTYPbF8tJKIiIiIiAyy2iAuKSkJgYGBkMlkCAkJQUZGRp35Dx48iJCQEMhkMnTt2hVr167Vy5OYmIgePXrA0dERvr6+mDNnDm7fvt2oeh0pPFLnapQCAoXqQmQU1F1fIiIiIiJqm6wyiEtOTkZsbCzi4+ORnZ0NhUKBUaNGoaCgwGD+vLw8jB49GgqFAtnZ2Xjttdcwe/Zs7Nq1S5vn008/xfz587Fo0SLk5uZi48aNSE5OxoIFCxpVt+KbxQ3Kp7yhbFS5RERERETUNtiaugKtYcWKFZgxYwZmzpwJ4M4I2nfffYc1a9YgISFBL//atWvh5+eHxMREAEBQUBCOHz+O5cuXY9y4cQCAzMxMDBkyBJMnTwYABAQEYNKkSTh27Fij6ubZ3rNB+bycvRpVLhERERERtQ1WNxJXUVGBrKwsRERE6KRHRETgyJEjBo/JzMzUyz9ixAgcP34clZWVAICHH34YWVlZ2qDt4sWLSE1NxeOPP96o+oX5hsFH7gMJJAY/l0ACX7kvFH6KRpVLRERERERtg9WNxKlUKmg0Gnh4eOike3h4oLjY8KOMxcXFBvNXVVVBpVLBy8sLEydOxJUrV/Dwww9DCIGqqiq8+OKLmD9/vsEyy8vLUV5ern2vVqsBAFIbKVaOXImoHVGQQKKzwElNYJc4MhFSG2njG09ERERERFbP6kbiakgkuiNdQgi9tPry352enp6Ot956C0lJSfj555+RkpKCr7/+Gm+++abB8hISEuDi4qJ9+fr6aj+LDIrEzvE70UXeRecYH7kPdo7ficigyIY3lIiIiIiI2hSrG4lzc3ODVCrVG3UrKSnRG22r4enpaTC/ra0tOnXqBAB4/fXXMXXqVO08u969e+Ovv/7CCy+8gPj4eNjY6MbDCxYsQFxcnPa9Wq3WC+TG9BiDjIIMRH8dDR+5D76b8h1H4IiIiIiIqE5WNxJnb2+PkJAQpKWl6aSnpaUhLCzM4DGDBw/Wy793716EhobCzs4OAFBWVqYXqEmlUgghtKN2d3NwcIBcLtd53UtqI0V4QDgG+w7GzYqbDOCIiIiIiKheVhfEAUBcXBw2bNiATZs2ITc3F3PmzEFBQQGio6MB3BklmzZtmjZ/dHQ0Ll26hLi4OOTm5mLTpk3YuHEj5s6dq83z5JNPYs2aNdi+fTvy8vKQlpaG119/HU899RSk0uYFX107dMWFaxeaVQYREREREbUNVvc4JQBMmDABV69exdKlS6FUKhEcHIzU1FT4+/sDAJRKpc6ecYGBgUhNTcWcOXOwevVqeHt7Y9WqVdrtBQBg4cKFkEgkWLhwIYqKiuDu7o4nn3wSb731VrPr261jN6jKVFCXqyF30B+xIyIiIiIiqiERhp4FpBanVqvh4uKC0tJSvUcrj14+ikEbByH7H9no59nPNBUkIrJidd2DiYiILI1VPk5pabq6dgUAXPiTj1QSEREREVHdGMSZAbd2bnC2d8bFaxdNXRUiIiIiIjJzDOLMgEQiQbeO3bi4CRERERER1YtBnJno6tqVI3FERERERFQvBnFmopsrR+KIiIiIiKh+DOLMRDfXbrh0/RIqNZWmrgoREREREZkxBnFmwt/FHxqhweqfViM9Px2aao2pq0RERERERGbIKjf7tjQpuSl4OfVlAMCc7+YAAHzkPlg5ciUigyJNWTUiIiIiIjIzHIkzsZTcFETtiELxzWKd9CJ1EaJ2RCElN8VENSMiIiIiInPEIM6ENNUaxOyJgYDQ+6wmLXZPLB+tJCIiIiIiLQZxJpRRkIHL6su1fi4gUKguREZBhhFrRURERERE5oxBnAkpbyhbNB8REREREVk/BnEm5OXs1aL5iIiIiIjI+jGIMyGFnwI+ch9IIDH4uQQS+Mp9ofBTGLlmRERERERkrhjEmZDURoqVI1cCgF4gV/M+cWQipDZSo9eNiIiIiIjME4M4E4sMisTO8TvRRd5FJ91H7oOd43dynzgiIiIiItIhEULor29PLU6tVsPFxQWlpaWQy+V6n2uqNcgoyMArqa+go2NHHJh+gCNwREQtpL57MBERkSXhSJyZkNpIER4QjkcDH0XJXyUM4IiIiIiIyCAGcWamV+deOP/neZRXlZu6KkREREREZIYYxJmZXu69oBEanLl6xtRVISIiIiIiM2S1QVxSUhICAwMhk8kQEhKCjIyMOvMfPHgQISEhkMlk6Nq1K9auXauX5/r163j55Zfh5eUFmUyGoKAgpKamtmi9e3XuBQA4VXKqRcslIiIiIiLrYJVBXHJyMmJjYxEfH4/s7GwoFAqMGjUKBQUFBvPn5eVh9OjRUCgUyM7OxmuvvYbZs2dj165d2jwVFRV47LHHkJ+fj507d+LMmTNYv349unTpYrDMpuog6wBvZ2+cusIgjoiIiIiI9Fnl6pQDBw7EgAEDsGbNGm1aUFAQxo4di4SEBL388+bNw+7du5Gbm6tNi46Oxi+//ILMzEwAwNq1a/Huu+/it99+g52dXaPr1JiV0SI+joCTvRM+n/B5o89DRET6uDolERFZE6sbiauoqEBWVhYiIiJ00iMiInDkyBGDx2RmZurlHzFiBI4fP47KykoAwO7duzF48GC8/PLL8PDwQHBwMN5++21oNJoWb0OQWxB+KvoJ205sQ3p+OjTVLX8OIiIiIiKyTLamrkBLU6lU0Gg08PDw0En38PBAcXGxwWOKi4sN5q+qqoJKpYKXlxcuXryI77//Hs8++yxSU1Nx7tw5vPzyy6iqqsIbb7yhV2Z5eTnKy/9vhUm1Wt2g+qfkpuDjXz/GtdvXMDllMoA7G3+vHLmSG38TEREREZH1jcTVkEgkOu+FEHpp9eW/O726uhqdO3fGunXrEBISgokTJyI+Pl7nkc27JSQkwMXFRfvy9fWtt84puSmI2hGFa7ev6aQXqYsQtSMKKbkp9ZZBRERERETWzeqCODc3N0ilUr1Rt5KSEr3Rthqenp4G89va2qJTp04AAC8vL3Tv3h1S6f9twh0UFITi4mJUVFTolblgwQKUlpZqX4WFhXXWW1OtQcyeGAjoT1GsSYvdE8tHK4mIiIiI2jirC+Ls7e0REhKCtLQ0nfS0tDSEhYUZPGbw4MF6+ffu3YvQ0FDtIiZDhgzB+fPnUV1drc1z9uxZeHl5wd7eXq9MBwcHyOVynVddMgoycFl9udbPBQQK1YXIKKh7qwQiIiIiIrJuVhfEAUBcXBw2bNiATZs2ITc3F3PmzEFBQQGio6MB3BklmzZtmjZ/dHQ0Ll26hLi4OOTm5mLTpk3YuHEj5s6dq83z4osv4urVq4iJicHZs2fxzTff4O2338bLL7/cInVW3lC2aD4iIiIiIrJOVrewCQBMmDABV69exdKlS6FUKhEcHIzU1FT4+/sDAJRKpc6ecYGBgUhNTcWcOXOwevVqeHt7Y9WqVRg3bpw2j6+vL/bu3Ys5c+agT58+6NKlC2JiYjBv3rwWqbOXs1eL5iMiIiIiIutklfvEmaP69ijSVGsQsDIAReoig/PiJJDAR+6DvJg8SG2kep8TEVHtuE8cERFZE6t8nNISSW2kWDlyJYA7Advdat4njkxkAEdERERE1MYxiDMjkUGR2Dl+J7rIu+ik+8h9sHP8Tu4TR0REREREfJzSWBrzKI+mWoOMggws2L8AN8tvIic6hyNwRETNwMcpiYjImnAkzgxJbaQIDwjHMz2fwYVrFwzOkSMiIiIioraJQZwZe9D7QdyquoXTV06buipERERERGQmGMSZsQFeA2AjscGxomOmrgoREREREZkJq9wnzlo42Tuhp1tPfPnbl3Cyc4KXsxcUfgrOjyMiIiIiasMYxJmxlNwUXLx+ESevnMTX574GcGelypUjV3KlSiIiIiKiNoqPU5qplNwURO2IQlllmU56kboIUTuikJKbYqKaERERERGRKTGIM0Oaag1i9sQYXJWyJi12Tyw01RpjV42IiIiIiEyMQZwZyijIwGX15Vo/FxAoVBcioyDDiLUiIiIiIiJzwCDODClvKFs0HxERERERWQ8GcWbIy9mrRfMREREREZH1YBBnhhR+CvjIfSCBxODnEkjgK/eFwk9h5JoREREREZGpMYgzQ1IbKVaOXAkAeoFczfvEkYncL46IiIiIqA1iEGemIoMisXP8TnSRd9FJ95H7YOf4ndwnjoiIiIiojZIIIfTXsacWp1ar4eLigtLSUsjl8gYfp6nWIKMgA+uz1mPn6Z24Pv86HO0cW7GmRETWp6n3YCIiInNka+oKUN2kNlKEB4RD7iDH1pNbsT5rPdyd3OHl7AWFn4KPVBIRERERtTEM4izExT8vQgIJYr6L0ab5yH2wcuRKPlpJRERERNSGcE6cBUjJTcH4neMhoPvka5G6CFE7opCSm2KimhERERERkbFZbRCXlJSEwMBAyGQyhISEICMjo878Bw8eREhICGQyGbp27Yq1a9fWmnf79u2QSCQYO3ZsC9dan6Zag5g9MXoBHABtWuyeWGiqNa1eFyIiIiIiMj2rDOKSk5MRGxuL+Ph4ZGdnQ6FQYNSoUSgoKDCYPy8vD6NHj4ZCoUB2djZee+01zJ49G7t27dLLe+nSJcydOxcKhXH2aMsoyMBl9eVaPxcQKFQXIqOg7iCViIiIiIisg1UGcStWrMCMGTMwc+ZMBAUFITExEb6+vlizZo3B/GvXroWfnx8SExMRFBSEmTNn4u9//zuWL1+uk0+j0eDZZ5/FkiVL0LVrV2M0BcobyhbNR0REREREls3qgriKigpkZWUhIiJCJz0iIgJHjhwxeExmZqZe/hEjRuD48eOorKzUpi1duhTu7u6YMWNGy1e8Fl7OXi2aj4iIiIiILJvVrU6pUqmg0Wjg4eGhk+7h4YHi4mKDxxQXFxvMX1VVBZVKBS8vLxw+fBgbN25ETk5Og+pRXl6O8vJy7Xu1Wt24hvx/Cj8FfOQ+KFIXGZwXJ4EEPnIfKPyM83gnERERERGZltWNxNWQSCQ674UQemn15a9Jv3HjBqZMmYL169fDzc2tQedPSEiAi4uL9uXr69vIFtwhtZFi5ciVd+oC3TrWvE8cmcj94oiIiIiI2girC+Lc3NwglUr1Rt1KSkr0RttqeHp6Gsxva2uLTp064cKFC8jPz8eTTz4JW1tb2NraYsuWLdi9ezdsbW1x4cIFvTIXLFiA0tJS7auwsLDJbYoMisTO8TvRRd5FJ93V0RWLwxdjTI8xTS6biIiIiIgsi9UFcfb29ggJCUFaWppOelpaGsLCwgweM3jwYL38e/fuRWhoKOzs7PDAAw/gxIkTyMnJ0b6eeuopDBs2DDk5OQZH2RwcHCCXy3VezREZFIn8mHwsCV8CZ3tnAMCft/7EovRFCFgZwL3iiIiIiIjaCKubEwcAcXFxmDp1KkJDQzF48GCsW7cOBQUFiI6OBnBnlKyoqAhbtmwBAERHR+O///0v4uLi8PzzzyMzMxMbN27Etm3bAAAymQzBwcE65+jQoQMA6KW3pi/PfInF6Ytr3fR75/idiAyKNFp9iIiIiIjI+KwyiJswYQKuXr2KpUuXQqlUIjg4GKmpqfD39wcAKJVKnT3jAgMDkZqaijlz5mD16tXw9vbGqlWrMG7cOFM1QU99m35LIEHsnliM6TGG8+OIiP5fe/ceVNV1t3H8IVzFNxAUBREv6GRebYhJhMTxgrGtJTdrjGkTTb1kOpMpbTRcpg0atSZmDAmmiU0IWhPttDVRMw0mNpNYMRUqlY4W0RjlrXkTFKWcAXIBlITrev/w5YxHDnhAOLA3388ME1l7nc36DZM1+2HvvRYAADbmY9pW8ECvqq2tVWhoqGpqarr1aGXemTx99w/fvWq/A0sPaNbYWd0YIQDY17XOwQAA9Ce2eyfOrtj0GwAAAIBEiLMMNv0GAAAAIBHiLKNt0+8r94q73LDgYZoW7X4FTgAAAAD2QIiziM42/W5TVV+l8a+OZ7sBAAAAwMYIcRbS0abfl2vbboAgBwAAANgTIc5i5k+cr8+Wf6ZhwcPcHm/bgiBlb4paWlu8OTQAAAAAXkCIs6BD5w+pqr6qw+NGRudqz+lg2UEvjgoAAACANxDiLIjtBgAAAICBixBnQZ5uIzB88PBeHgkAAAAAbyPEWZAn2w1I0qPvPsoCJwAAAIDNEOIsyJPtBiSpvI6VKgEAAAC7IcRZVNt2A1HXR3XYh5UqAQAAAPshxFnY/Inz9Yd5f+i0DytVAgAAAPZCiLO4youVHvUrry3v5ZEAAAAA8AZCnMV5ulJl6l9TeTcOAAAAsAFCnMV5ulJldX01i5wAAAAANkCIs7jLV6rsDIucAAAAAPZAiLOBtpUqw4PDO+3XtshJ3pk87wwMAAAAQI8jxNnE/InztfGujR71fejPD/FYJQAAAGBRhDgbGRky0qN+X37zJe/HAQAAABZFiLMRTxc5kS49Wpn0fpIamxu9MDIAAAAAPcW2IS47O1sxMTEKCgpSXFycDh7sfLPr/Px8xcXFKSgoSOPGjdPmzZtdjr/++utKSEhQWFiYwsLCNHv2bB0+fLg3S+gyTxc5aVNVX6Xol6O5IwcAAABYiC1D3K5du5SSkqJVq1apuLhYCQkJuueee1RWVua2f2lpqe69914lJCSouLhYTz31lJ544gm98847zj55eXlauHChDhw4oMLCQo0ePVqJiYkqL+9fm2i3LXIyZNAQj/pX1VfxaCUAAABgIT7GGNPXg+hpU6ZM0eTJk7Vp0yZn28SJEzVv3jxlZGS065+enq49e/aopKTE2ZaUlKTjx4+rsLDQ7c9oaWlRWFiYsrKytGTJkquOqba2VqGhoaqpqVFISEg3quqajz7/SLP/NNvj/sOCh+l86nkF+AX04qgAoG94ew4GAKA32e5OXGNjo4qKipSYmOjSnpiYqEOHDrn9TGFhYbv+d911l/71r3+pqanJ7Wfq6+vV1NSkIUPc3/FqaGhQbW2ty5c3zRo7y+P34yQerQQAAACswnYhrrq6Wi0tLYqIiHBpj4iIkMPhcPsZh8Phtn9zc7Oqq6vdfmbFihUaOXKkZs92f7crIyNDoaGhzq9Ro0Z1o5ru6+r7cdKlIPfg2w9qXf46NgQHAAAA+inbhbg2Pj6ud6CMMe3artbfXbskZWZmaseOHcrJyVFQUJDb861cuVI1NTXOr3PnznW1hGvm6SbgV1qbt1ZjN47lrhwAAADQD9kuxIWHh8vX17fdXbfKysp2d9vaREZGuu3v5+enoUOHurS/+OKLeu6557Rv3z5NmjSpw3EEBgYqJCTE5asvzJ84X+Wp5RoWPKxLnztfd54FTwAAAIB+yHYhLiAgQHFxccrNzXVpz83N1bRp09x+ZurUqe3679u3T/Hx8fL393e2bdiwQc8++6z27t2r+Pj4nh98LwnwC9DmOZs9fj+ujZFR8ofJPFoJAAAA9CO2C3GSlJaWpjfeeEPbtm1TSUmJUlNTVVZWpqSkJEmXHnW8fEXJpKQknT17VmlpaSopKdG2bdu0detW/fKXv3T2yczM1OrVq7Vt2zaNHTtWDodDDodDFy5c8Hp93dHdRyvP153Xgj8vUN6ZPMIcAAAA0A/YcosB6dJm35mZmaqoqFBsbKxefvllzZw5U5L06KOP6syZM8rLy3P2z8/PV2pqqk6ePKmoqCilp6c7Q58kjR07VmfPnm33c9auXaunn376quPpL8tbNzY3KvrlaFXVV3X5s9Eh0frt3b/V/Inze2FkANB7+sscDABAT7BtiOtv+tMFRE5Jjn709o9k1L1f/TOzntGqhFXyvc63h0cGAL2jP83BAABcK1s+TonOtT1aOfL6kd36/Nq8tYp8MVKpf03lMUsAAADAy7gT5yX98a/ALa0tWn9wvdbmrb2m84QHh2vRpEW6/7/vV8LoBO7QAeh3+uMcDABAdxHivKQ/X0Csy193zUGuDe/NAeiP+vMcDABAV/E4JbQqYZWir4/ukXOdrz2vB99+UOvy1/GYJQAAANALuBPnJf39r8DXutiJO+GDwvXIpEcUc0OMhgUP08iQkTxuCaBP9Pc5GACAriDEeYkVLiBySnKUvDdZ52vP99rP4P05AH3BCnMwAACeIsR5iVUuIFpaW3Sw7KDe+5/3tP3j7ar+prrXfhaBDoC3WGUOBgDAE4Q4L7HiBURPrV7pibZAN+fGOZKkyouVGnH9CMIdgB5hxTkYAICOEOK8xMoXEN54zLIj3K0D0BOsPAcDAHAlQpyXWP0C4vLHLN888aaq6qu8Pobw4HA9cjMLpQDoOqvPwQAAXI4Q5yV2uoDw5ntzV8NjmAA8Yac5GAAAQpyX2PUCwpvvzXUF4Q7A5ew6BwMABiZCnJfY/QKiL9+b6wp34W744OHOfxP0AHuy+xwMABhYCHFeMhAuIPrDe3M9YcigIVp+x3IljE4g5AE2MRDmYADAwEGI85KBdgHRFujKa8tVVV+lM1+d0VufvGXZYHe5q93NI/QB/c9Am4MBAPZGiPMSLiDsc6euqzq7s0fgA7yDORgAYCeEOC/hAsLVQA10V9PZXT7HBYeq6qs0LHiYIv8rst1xgiDQMeZgAICdEOK8hAuIjrUFuoq6Cmcgef/0+4S7burK455dCYiERVgZczAAwE4IcV7CBUTXcbeuf7vWu4Zd+XdPnY/wOXAxBwMA7IQQ5yVcQFwbOy+UAu+6Mnz218DpjXP39/P15Lkv1l3U/bfezxwMALAF24a47OxsbdiwQRUVFbrpppu0ceNGJSQkdNg/Pz9faWlpOnnypKKiovTkk08qKSnJpc8777yjNWvW6LPPPtP48eO1fv16PfDAAx6NhxDX83gME4DHvpX0vJiDAQC2YMsQt2vXLi1evFjZ2dmaPn26fve73+mNN97QqVOnNHr06Hb9S0tLFRsbq8cee0w/+9nP9I9//EO/+MUvtGPHDj344IOSpMLCQiUkJOjZZ5/VAw88oN27d+vXv/61CgoKNGXKlKuOiRDnPYQ7AO0Q4gAANmLLEDdlyhRNnjxZmzZtcrZNnDhR8+bNU0ZGRrv+6enp2rNnj0pKSpxtSUlJOn78uAoLCyVJDz/8sGpra/Xhhx86+9x9990KCwvTjh07rjomQlzfcxfu2h61Olh2UK8eflVffvNlH48SQK8gxAEAbMSvrwfQ0xobG1VUVKQVK1a4tCcmJurQoUNuP1NYWKjExESXtrvuuktbt25VU1OT/P39VVhYqNTU1HZ9Nm7c6PacDQ0NamhocH5fU1Mj6VKYQ9+ZPGSyNOSyhvBL/7k9/HYl35qsQ+cOyXHBoWHBwyTJ+Q6OJO393716+9Tb+qL+Cy+PGsA1+//p2IZ/twQADEC2C3HV1dVqaWlRRESES3tERIQcDofbzzgcDrf9m5ubVV1drREjRnTYp6NzZmRk6JlnnmnXPmrUqK6UAwDoQXV1dQoNDe3rYQAAcE1sF+La+Pj4uHxvjGnXdrX+V7Z35ZwrV65UWlqa8/uvv/5aY8aMUVlZma0vIGprazVq1CidO3fOto8sUaN9DIQ6qfESY4zq6uoUFRXl5dEBANDzbBfiwsPD5evr2+4OWWVlZbs7aW0iIyPd9vfz89PQoUM77dPROQMDAxUYGNiuPTQ01LYXUpcLCQmxfZ3UaB8DoU5qlK3/gAYAGFiu6+sB9LSAgADFxcUpNzfXpT03N1fTpk1z+5mpU6e2679v3z7Fx8fL39+/0z4dnRMAAAAAeoPt7sRJUlpamhYvXqz4+HhNnTpVW7ZsUVlZmXPft5UrV6q8vFx//OMfJV1aiTIrK0tpaWl67LHHVFhYqK1bt7qsOpmcnKyZM2fqhRde0P3336/33ntP+/fvV0FBQZ/UCAAAAGBgsmWIe/jhh/XFF19o3bp1qqioUGxsrD744AONGTNGklRRUaGysjJn/5iYGH3wwQdKTU3Va6+9pqioKL3yyivOPeIkadq0adq5c6dWr16tNWvWaPz48dq1a5dHe8RJlx6vXLt2rdtHLO1kINRJjfYxEOqkRgAA7MeW+8QBAAAAgF3Z7p04AAAAALAzQhwAAAAAWAghDgAAAAAshBAHAAAAABZCiPOS7OxsxcTEKCgoSHFxcTp48GBfD6nbMjIydPvtt+v666/X8OHDNW/ePP373/926WOM0dNPP62oqCgNGjRIs2bN0smTJ/toxNcuIyNDPj4+SklJcbbZocby8nItWrRIQ4cOVXBwsG699VYVFRU5j9uhxubmZq1evVoxMTEaNGiQxo0bp3Xr1qm1tdXZx2p1/v3vf9cPf/hDRUVFycfHR++++67LcU/qaWho0PLlyxUeHq7Bgwdr7ty5On/+vBer6FxnNTY1NSk9PV0333yzBg8erKioKC1ZskT/+c9/XM7R32sEAKC7CHFesGvXLqWkpGjVqlUqLi5WQkKC7rnnHpdtDqwkPz9fjz/+uP75z38qNzdXzc3NSkxM1MWLF519MjMz9dJLLykrK0tHjhxRZGSkfvCDH6iurq4PR949R44c0ZYtWzRp0iSXdqvX+NVXX2n69Ony9/fXhx9+qFOnTuk3v/mNbrjhBmcfq9coSS+88II2b96srKwslZSUKDMzUxs2bNCrr77q7GO1Oi9evKhbbrlFWVlZbo97Uk9KSop2796tnTt3qqCgQBcuXNCcOXPU0tLirTI61VmN9fX1Onr0qNasWaOjR48qJydHp0+f1ty5c1369fcaAQDoNoNed8cdd5ikpCSXtgkTJpgVK1b00Yh6VmVlpZFk8vPzjTHGtLa2msjISPP88887+3z77bcmNDTUbN68ua+G2S11dXXmxhtvNLm5uebOO+80ycnJxhh71Jienm5mzJjR4XE71GiMMffdd5/56U9/6tI2f/58s2jRImOM9euUZHbv3u383pN6vv76a+Pv72927tzp7FNeXm6uu+46s3fvXq+N3VNX1ujO4cOHjSRz9uxZY4z1agQAoCu4E9fLGhsbVVRUpMTERJf2xMREHTp0qI9G1bNqamokSUOGDJEklZaWyuFwuNQcGBioO++803I1P/7447rvvvs0e/Zsl3Y71Lhnzx7Fx8frxz/+sYYPH67bbrtNr7/+uvO4HWqUpBkzZuijjz7S6dOnJUnHjx9XQUGB7r33Xkn2qbONJ/UUFRWpqanJpU9UVJRiY2MtWbN0aR7y8fFx3km2Y40AALTx6+sB2F11dbVaWloUERHh0h4RESGHw9FHo+o5xhilpaVpxowZio2NlSRnXe5qPnv2rNfH2F07d+7U0aNHdeTIkXbH7FDj559/rk2bNiktLU1PPfWUDh8+rCeeeEKBgYFasmSJLWqUpPT0dNXU1GjChAny9fVVS0uL1q9fr4ULF0qyx+/ycp7U43A4FBAQoLCwsHZ9rDgvffvtt1qxYoUeeeQRhYSESLJfjQAAXI4Q5yU+Pj4u3xtj2rVZ0bJly/Txxx+roKCg3TEr13zu3DklJydr3759CgoK6rCflWtsbW1VfHy8nnvuOUnSbbfdppMnT2rTpk1asmSJs5+Va5QuvZO6fft2vfXWW7rpppt07NgxpaSkKCoqSkuXLnX2s3qdV+pOPVasuampSQsWLFBra6uys7Ov2t+KNQIAcCUep+xl4eHh8vX1bfeX38rKynZ/Kbea5cuXa8+ePTpw4ICio6Od7ZGRkZJk6ZqLiopUWVmpuLg4+fn5yc/PT/n5+XrllVfk5+fnrMPKNY4YMULf+c53XNomTpzoXHDHDr9HSfrVr36lFStWaMGCBbr55pu1ePFipaamKiMjQ5J96mzjST2RkZFqbGzUV1991WEfK2hqatJDDz2k0tJS5ebmOu/CSfapEQAAdwhxvSwgIEBxcXHKzc11ac/NzdW0adP6aFTXxhijZcuWKScnR3/7298UExPjcjwmJkaRkZEuNTc2Nio/P98yNX//+9/XiRMndOzYMedXfHy8fvKTn+jYsWMaN26c5WucPn16u60hTp8+rTFjxkiyx+9RurSS4XXXuU51vr6+zi0G7FJnG0/qiYuLk7+/v0ufiooKffLJJ5apuS3Affrpp9q/f7+GDh3qctwONQIA0KG+WlFlINm5c6fx9/c3W7duNadOnTIpKSlm8ODB5syZM309tG75+c9/bkJDQ01eXp6pqKhwftXX1zv7PP/88yY0NNTk5OSYEydOmIULF5oRI0aY2traPhz5tbl8dUpjrF/j4cOHjZ+fn1m/fr359NNPzZtvvmmCg4PN9u3bnX2sXqMxxixdutSMHDnSvP/++6a0tNTk5OSY8PBw8+STTzr7WK3Ouro6U1xcbIqLi40k89JLL5ni4mLnyoye1JOUlGSio6PN/v37zdGjR833vvc9c8stt5jm5ua+KstFZzU2NTWZuXPnmujoaHPs2DGXeaihocF5jv5eIwAA3UWI85LXXnvNjBkzxgQEBJjJkyc7l+O3Ikluv37/+987+7S2tpq1a9eayMhIExgYaGbOnGlOnDjRd4PuAVeGODvU+Je//MXExsaawMBAM2HCBLNlyxaX43aosba21iQnJ5vRo0eboKAgM27cOLNq1SqXi32r1XngwAG3/w8uXbrUGONZPd98841ZtmyZGTJkiBk0aJCZM2eOKSsr64Nq3OusxtLS0g7noQMHDjjP0d9rBACgu3yMMcZ79/0AAAAAANeCd+IAAAAAwEIIcQAAAABgIYQ4AAAAALAQQhwAAAAAWAghDgAAAAAshBAHAAAAABZCiAMAAAAACyHEAQAAAICFEOIAAAAAwEIIcQAAAABgIYQ4AAAAALAQQhwAAAAAWMj/ARb1igMvDk7bAAAAAElFTkSuQmCC", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "hsm.plot(\"FirstOccurrence\", 1)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Distributions of the maximal number of successive occurrences of a same value" - ] - }, - { - "cell_type": "code", - "execution_count": 20, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "hsm.plot(\"Sojourn\", 1)" - ] - }, - { - "cell_type": "code", - "execution_count": 21, - "metadata": {}, - "outputs": [], - "source": [ - "# Would plot all above graph into a same figure, I do not recommend this.\n", - "# hsm.plot()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "**Simulate sequences**" - ] - }, - { - "cell_type": "code", - "execution_count": 22, - "metadata": {}, - "outputs": [], - "source": [ - "from openalea.sequence_analysis import Simulate" - ] - }, - { - "cell_type": "code", - "execution_count": 23, - "metadata": {}, - "outputs": [], - "source": [ - "from openalea.stat_tool.distribution import set_seed\n", - "set_seed(0)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Simulate *nb_seq* sequences with length *seq_length*" - ] - }, - { - "cell_type": "code", - "execution_count": 24, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "N.o. initial states in parallel: 1\n" - ] - } - ], - "source": [ - "nb_seq = 30\n", - "seq_length = 100\n", - "seq = hsm.simulation_nb_sequences(nb_seq, seq_length, True)\n", - "assert(len(seq) == nb_seq)\n", - "assert(len(seq[0]) == seq_length)\n", - "# NB: hsm has 1 output process but simulation includes the hidden state\n", - "assert(len(seq[0][1]) == 2)" - ] - }, - { - "cell_type": "code", - "execution_count": 25, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "N.o. initial states in parallel: 1\n" - ] - } - ], - "source": [ - "seq = hsm.simulation_nb_sequences(nb_seq, seq_length, True)" - ] - }, - { - "cell_type": "code", - "execution_count": 26, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[[1, 4], [1, 3], [1, 0], [1, 2], [1, 2], [1, 1], [1, 4], [1, 0], [1, 1], [1, 4], [1, 3], [1, 3], [1, 3], [1, 1], [1, 2], [1, 3], [1, 1], [1, 4], [1, 2], [1, 2], [1, 4], [1, 0], [1, 0], [1, 3], [1, 1], [1, 0], [1, 1], [1, 0], [1, 1], [1, 0], [1, 2], [1, 3], [1, 4], [1, 3], [1, 0], [1, 2], [1, 0], [1, 2], [1, 2], [1, 0], [1, 3], [1, 3], [1, 2], [1, 4], [1, 2], [1, 2], [1, 0], [3, 1], [3, 3], [3, 1], [3, 3], [6, 1], [7, 0], [7, 0], [7, 0], [7, 0], [7, 0], [7, 0], [7, 0], [7, 0], [7, 0], [7, 0], [7, 0], [7, 0], [7, 0], [7, 0], [7, 0], [7, 0], [7, 0], [7, 0], [7, 0], [7, 0], [7, 0], [7, 0], [7, 0], [7, 0], [7, 0], [7, 0], [7, 0], [7, 0], [7, 0], [7, 0], [7, 0], [7, 0], [7, 0], [7, 0], [7, 0], [7, 0], [7, 0], [7, 0], [7, 0], [7, 0], [7, 0], [7, 0], [7, 0], [7, 0], [7, 0], [7, 0], [7, 0], [7, 0]]\n" - ] - } - ], - "source": [ - "# Print first simulated sequence.\n", - "# The first variable is the simulated state\n", - "print(seq[0])" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Discard variable 1 (state)" - ] - }, - { - "cell_type": "code", - "execution_count": 27, - "metadata": {}, - "outputs": [], - "source": [ - "obs = seq.select_variable([1], keep=False)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Plotting marginal relative frequencies of data as a function of index" - ] - }, - { - "cell_type": "code", - "execution_count": 28, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# Variable 1\n", - "obs.plot(\"Intensity\", 0)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## HSCM re-estimation" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Reestimate from default initialisation" - ] - }, - { - "cell_type": "code", - "execution_count": 29, - "metadata": { - "scrolled": true - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0\n", - "iteration 1 log-likelihood for the observed sequences: -4390.74\n", - "iteration 2 log-likelihood for the observed sequences: -3382.28\n", - "iteration 3 log-likelihood for the observed sequences: -3021.61\n", - "iteration 4 log-likelihood for the observed sequences: -2938.58\n", - "iteration 5 log-likelihood for the observed sequences: -2913.02\n", - "iteration 6 log-likelihood for the observed sequences: -2897.22\n", - "iteration 7 log-likelihood for the observed sequences: -2882.79\n", - "iteration 8 log-likelihood for the observed sequences: -2871.16\n", - "iteration 9 log-likelihood for the observed sequences: -2867.5\n", - "iteration 10 log-likelihood for the observed sequences: -2866.07\n", - "iteration 11 log-likelihood for the observed sequences: -2865.17\n", - "iteration 12 log-likelihood for the observed sequences: -2864.46\n", - "iteration 13 log-likelihood for the observed sequences: -2863.73\n", - "iteration 14 log-likelihood for the observed sequences: -2862.76\n", - "iteration 15 log-likelihood for the observed sequences: -2861.31\n", - "iteration 16 log-likelihood for the observed sequences: -2859.6\n", - "HIDDEN_SEMI-MARKOV_CHAIN\n", - "\n", - "8 STATES\n", - "\n", - "INITIAL_PROBABILITIES\n", - "0.392168 0.211256 0.0849307 0.0882364 0.223388 1e-05 1e-05 0 \n", - "\n", - "TRANSITION_PROBABILITIES\n", - "0 1e-05 0.181573 1e-05 0.57504 1e-05 0.0845286 0.158828 \n", - "0 0 1e-05 0.549445 0.317319 0.133206 1e-05 1e-05 \n", - "0 0 0 1e-05 1e-05 0.99996 1e-05 1e-05 \n", - "0 0 0 0 1e-05 0.99997 1e-05 1e-05 \n", - "0 0 0 0 0 0.919854 0.0801364 1e-05 \n", - "0 0 0 0 0 0 0.982026 0.0179745 \n", - "0 0 0 0 0 0 0 1 \n", - "0 0 0 0 0 0 0 1 \n", - "\n", - "transient class: state 0\n", - "transient class: state 1\n", - "transient class: state 2\n", - "transient class: state 3\n", - "transient class: state 4\n", - "transient class: state 5\n", - "transient class: state 6\n", - "recurrent class: state 7 (absorbing state)\n", - "\n", - "probability of no-occurrence of state 0: 0.607832\n", - "\n", - "time up to the first occurrence of state 0 distribution\n", - "mean: 0 mode: 0\n", - "variance: 0 standard deviation: 0\n", - "\n", - "time up to the first occurrence of state 0 frequency distribution - sample size: 0\n", - "\n", - "probability of no-occurrence of state 1: 0.788736\n", - "\n", - "time up to the first occurrence of state 1 distribution\n", - "mean: 0 mode: 0\n", - "variance: 0 standard deviation: 0\n", - "\n", - "time up to the first occurrence of state 1 frequency distribution - sample size: 0\n", - "\n", - "probability of no-occurrence of state 2: 0.843857\n", - "\n", - "time up to the first occurrence of state 2 distribution\n", - "mean: 9.4149 mode: 0\n", - "variance: 235.476 standard deviation: 15.3452\n", - "\n", - "time up to the first occurrence of state 2 frequency distribution - sample size: 4\n", - "mean: 3.5 median: 0.5 mode: 0\n", - "variance: 22.3333 standard deviation: 4.72582 lower quartile: 0 upper quartile: 4.5\n", - "\n", - "probability of no-occurrence of state 3: 0.795677\n", - "\n", - "time up to the first occurrence of state 3 distribution\n", - "mean: 18.0978 mode: 0\n", - "variance: 251.231 standard deviation: 15.8503\n", - "\n", - "time up to the first occurrence of state 3 frequency distribution - sample size: 6\n", - "mean: 16 median: 0.5 mode: 0\n", - "variance: 307.6 standard deviation: 17.5385 lower quartile: 0 upper quartile: 32\n", - "\n", - "probability of no-occurrence of state 4: 0.484056\n", - "\n", - "time up to the first occurrence of state 4 distribution\n", - "mean: 13.5278 mode: 0\n", - "variance: 295.02 standard deviation: 17.1762\n", - "\n", - "time up to the first occurrence of state 4 frequency distribution - sample size: 16\n", - "mean: 14.1875 median: 3.5 mode: 0\n", - "variance: 372.163 standard deviation: 19.2915 lower quartile: 0 upper quartile: 31.5\n", - "\n", - "probability of no-occurrence of state 5: 0.136806\n", - "\n", - "time up to the first occurrence of state 5 distribution\n", - "mean: 61.8947 mode: 47\n", - "variance: 925.744 standard deviation: 30.426\n", - "\n", - "time up to the first occurrence of state 5 frequency distribution - sample size: 24\n", - "mean: 56.125 median: 52 mode: 36\n", - "variance: 589.071 standard deviation: 24.2708 lower quartile: 36.5 upper quartile: 79\n", - "\n", - "probability of no-occurrence of state 6: 0.077812\n", - "\n", - "time up to the first occurrence of state 6 distribution\n", - "mean: 228.006 mode: 218\n", - "variance: 7358.96 standard deviation: 85.7844\n", - "\n", - "time up to the first occurrence of state 6 frequency distribution - sample size: 2\n", - "mean: 41.5 median: 33.5 mode: 33\n", - "variance: 144.5 standard deviation: 12.0208 lower quartile: 33 upper quartile: 50\n", - "\n", - "time up to the first occurrence of state 7 distribution\n", - "mean: 256.769 median: 267 mode: 262\n", - "variance: 10563.5 standard deviation: 102.779 lower quartile: 216 upper quartile: 319\n", - "\n", - "time up to the first occurrence of state 7 frequency distribution - sample size: 4\n", - "mean: 56.25 median: 47.5 mode: 5\n", - "variance: 1562.25 standard deviation: 39.5253 lower quartile: 5.5 upper quartile: 78.5\n", - "\n", - "probability of leaving state 0: 0.0456091\n", - "\n", - "state 0 recurrence time distribution\n", - "mean: 1 mode: 1\n", - "variance: 0 standard deviation: 0\n", - "\n", - "state 0 recurrence time frequency distribution - sample size: 250\n", - "mean: 1 median: 1 mode: 1\n", - "variance: 0 standard deviation: 0\n", - "\n", - "probability of leaving state 1: 0.0313043\n", - "\n", - "state 1 recurrence time distribution\n", - "mean: 1 mode: 1\n", - "variance: 0 standard deviation: 0\n", - "\n", - "state 1 recurrence time frequency distribution - sample size: 186\n", - "mean: 1 median: 1 mode: 1\n", - "variance: 0 standard deviation: 0\n", - "\n", - "probability of leaving state 2: 0.0167307\n", - "\n", - "state 2 recurrence time distribution\n", - "mean: 1 mode: 1\n", - "variance: 0 standard deviation: 0\n", - "\n", - "state 2 recurrence time frequency distribution - sample size: 242\n", - "mean: 1 median: 1 mode: 1\n", - "variance: 0 standard deviation: 0\n", - "\n", - "probability of leaving state 3: 0.0212466\n", - "\n", - "state 3 recurrence time distribution\n", - "mean: 1 mode: 1\n", - "variance: 0 standard deviation: 0\n", - "\n", - "state 3 recurrence time frequency distribution - sample size: 272\n", - "mean: 1 median: 1 mode: 1\n", - "variance: 0 standard deviation: 0\n", - "\n", - "probability of leaving state 4: 0.0216044\n", - "\n", - "state 4 recurrence time distribution\n", - "mean: 1 mode: 1\n", - "variance: 0 standard deviation: 0\n", - "\n", - "state 4 recurrence time frequency distribution - sample size: 688\n", - "mean: 1 median: 1 mode: 1\n", - "variance: 0 standard deviation: 0\n", - "\n", - "probability of leaving state 5: 0.00547761\n", - "\n", - "state 5 recurrence time distribution\n", - "mean: 1 mode: 1\n", - "variance: 0 standard deviation: 0\n", - "\n", - "state 5 recurrence time frequency distribution - sample size: 1029\n", - "mean: 1 median: 1 mode: 1\n", - "variance: 0 standard deviation: 0\n", - "\n", - "probability of leaving state 6: 0.0222973\n", - "\n", - "state 6 recurrence time distribution\n", - "mean: 1 mode: 1\n", - "variance: 0 standard deviation: 0\n", - "\n", - "state 6 recurrence time frequency distribution - sample size: 88\n", - "mean: 1 median: 1 mode: 1\n", - "variance: 0 standard deviation: 0\n", - "\n", - "state 7 recurrence time distribution\n", - "mean: 1 median: 1 mode: 1\n", - "variance: 0 standard deviation: 0\n", - "\n", - "state 7 recurrence time frequency distribution - sample size: 171\n", - "mean: 1 median: 1 mode: 1\n", - "variance: 0 standard deviation: 0\n", - "\n", - "STATE 0 OCCUPANCY_DISTRIBUTION\n", - "NEGATIVE_BINOMIAL INF_BOUND : 1 PARAMETER : 1.24259 PROBABILITY : 0.0560531\n", - "mean: 21.9254 median: 16 mode: 5\n", - "variance: 373.315 standard deviation: 19.3214 lower quartile: 8 upper quartile: 30\n", - "coefficient of skewness: 1.79493 coefficient of kurtosis: 4.83132\n", - "coefficient of variation: 0.88123\n", - "\n", - "state 0 sojourn time frequency distribution - sample size: 12\n", - "mean: 21.8333 median: 10 mode: 10\n", - "variance: 406.515 standard deviation: 20.1622 lower quartile: 5.5 upper quartile: 33.5\n", - "\n", - "final run - state 0 sojourn time frequency distribution - sample size: 0\n", - "\n", - "STATE 1 OCCUPANCY_DISTRIBUTION\n", - "BINOMIAL INF_BOUND : 29 SUP_BOUND : 37 PROBABILITY : 0.368056\n", - "mean: 31.9444 median: 32 mode: 32\n", - "variance: 1.86073 standard deviation: 1.36408 lower quartile: 31 upper quartile: 33\n", - "coefficient of skewness: 0.193455 coefficient of kurtosis: -0.212575\n", - "coefficient of variation: 0.0427018\n", - "\n", - "state 1 sojourn time frequency distribution - sample size: 6\n", - "mean: 32 median: 32 mode: 32\n", - "variance: 0.8 standard deviation: 0.894427 lower quartile: 31 upper quartile: 33\n", - "\n", - "final run - state 1 sojourn time frequency distribution - sample size: 0\n", - "\n", - "STATE 2 OCCUPANCY_DISTRIBUTION\n", - "NEGATIVE_BINOMIAL INF_BOUND : 1 PARAMETER : 14.7903 PROBABILITY : 0.201063\n", - "mean: 59.7703 median: 58 mode: 55\n", - "variance: 292.298 standard deviation: 17.0967 lower quartile: 48 upper quartile: 70\n", - "coefficient of skewness: 0.523324 coefficient of kurtosis: 0.409092\n", - "coefficient of variation: 0.28604\n", - "\n", - "state 2 sojourn time frequency distribution - sample size: 4\n", - "mean: 61.5 median: 62.5 mode: 32\n", - "variance: 436.333 standard deviation: 20.8886 lower quartile: 32.5 upper quartile: 73.5\n", - "\n", - "final run - state 2 sojourn time frequency distribution - sample size: 0\n", - "\n", - "STATE 3 OCCUPANCY_DISTRIBUTION\n", - "BINOMIAL INF_BOUND : 1 SUP_BOUND : 71 PROBABILITY : 0.658092\n", - "mean: 47.0664 median: 47 mode: 47\n", - "variance: 15.7505 standard deviation: 3.96869 lower quartile: 44 upper quartile: 50\n", - "coefficient of skewness: -0.0796695 coefficient of kurtosis: -0.0222242\n", - "coefficient of variation: 0.084321\n", - "\n", - "state 3 sojourn time frequency distribution - sample size: 6\n", - "mean: 46.3333 median: 47 mode: 47\n", - "variance: 18.2667 standard deviation: 4.27395 lower quartile: 43 upper quartile: 49\n", - "\n", - "final run - state 3 sojourn time frequency distribution - sample size: 0\n", - "\n", - "STATE 4 OCCUPANCY_DISTRIBUTION\n", - "NEGATIVE_BINOMIAL INF_BOUND : 1 PARAMETER : 2.05351 PROBABILITY : 0.0433776\n", - "mean: 46.287 median: 39 mode: 24\n", - "variance: 1044.02 standard deviation: 32.3113 lower quartile: 23 upper quartile: 62\n", - "coefficient of skewness: 1.39601 coefficient of kurtosis: 2.92278\n", - "coefficient of variation: 0.698064\n", - "\n", - "state 4 sojourn time frequency distribution - sample size: 14\n", - "mean: 40.7143 median: 36 mode: 7.5\n", - "variance: 694.374 standard deviation: 26.351 lower quartile: 21 upper quartile: 64\n", - "\n", - "final run - state 4 sojourn time frequency distribution - sample size: 2\n", - "mean: 67 median: 37.5 mode: 37\n", - "variance: 1800 standard deviation: 42.4264 lower quartile: 37 upper quartile: 97\n", - "\n", - "STATE 5 OCCUPANCY_DISTRIBUTION\n", - "NEGATIVE_BINOMIAL INF_BOUND : 59 PARAMETER : 4.17913 PROBABILITY : 0.0327158\n", - "mean: 182.561 median: 173 mode: 152\n", - "variance: 3776.81 standard deviation: 61.4557 lower quartile: 138 upper quartile: 217\n", - "coefficient of skewness: 0.978469 coefficient of kurtosis: 1.43597\n", - "coefficient of variation: 0.336631\n", - "\n", - "state 5 sojourn time frequency distribution - sample size: 0\n", - "\n", - "final run - state 5 sojourn time frequency distribution - sample size: 24\n", - "mean: 43.875 median: 38.5 mode: 18\n", - "variance: 589.071 standard deviation: 24.2708 lower quartile: 22 upper quartile: 64\n", - "\n", - "STATE 6 OCCUPANCY_DISTRIBUTION\n", - "BINOMIAL INF_BOUND : 41 SUP_BOUND : 47 PROBABILITY : 0.641414\n", - "mean: 44.8485 median: 45 mode: 45\n", - "variance: 1.38001 standard deviation: 1.17474 lower quartile: 44 upper quartile: 46\n", - "coefficient of skewness: -0.240758 coefficient of kurtosis: -0.275369\n", - "coefficient of variation: 0.0261935\n", - "\n", - "state 6 sojourn time frequency distribution - sample size: 2\n", - "mean: 45 median: 45 mode: 45\n", - "variance: 0 standard deviation: 0\n", - "\n", - "final run - state 6 sojourn time frequency distribution - sample size: 0\n", - "\n", - "absorption probability of state 7: 1\n", - "\n", - "state 7 sojourn time frequency distribution - sample size: 0\n", - "\n", - "final run - state 7 sojourn time frequency distribution - sample size: 4\n", - "mean: 43.75 median: 22.5 mode: 5\n", - "variance: 1562.25 standard deviation: 39.5253 lower quartile: 5.5 upper quartile: 53.5\n", - "\n", - "number of runs of state 0 per length 100 sequence distribution\n", - "mean: 0.392168 median: 0 mode: 0\n", - "variance: 0.238372 standard deviation: 0.488234 lower quartile: 0 upper quartile: 1\n", - "coefficient of skewness: 0.441721 coefficient of kurtosis: -1.80488\n", - "\n", - "number of runs of state 0 per sequence frequency distribution - sample size: 30\n", - "mean: 0.4 median: 0 mode: 0\n", - "variance: 0.248276 standard deviation: 0.498273 lower quartile: 0 upper quartile: 1\n", - "coefficient of skewness: 0.430057 coefficient of kurtosis: -1.87222\n", - "\n", - "number of runs of state 1 per length 100 sequence distribution\n", - "mean: 0.21126 median: 0 mode: 0\n", - "variance: 0.166629 standard deviation: 0.408203 lower quartile: 0 upper quartile: 0\n", - "coefficient of skewness: 1.41469 coefficient of kurtosis: 0.00134152\n", - "\n", - "number of runs of state 1 per sequence frequency distribution - sample size: 30\n", - "mean: 0.2 median: 0 mode: 0\n", - "variance: 0.165517 standard deviation: 0.406838 lower quartile: 0 upper quartile: 0\n", - "coefficient of skewness: 1.58013 coefficient of kurtosis: 0.141667\n", - "\n", - "number of runs of state 2 per length 100 sequence distribution\n", - "mean: 0.155732 median: 0 mode: 0\n", - "variance: 0.131479 standard deviation: 0.362601 lower quartile: 0 upper quartile: 0\n", - "coefficient of skewness: 1.89888 coefficient of kurtosis: 1.60576\n", - "\n", - "number of runs of state 2 per sequence frequency distribution - sample size: 30\n", - "mean: 0.133333 median: 0 mode: 0\n", - "variance: 0.11954 standard deviation: 0.345746 lower quartile: 0 upper quartile: 0\n", - "coefficient of skewness: 2.27252 coefficient of kurtosis: 2.46538\n", - "\n", - "number of runs of state 3 per length 100 sequence distribution\n", - "mean: 0.204318 median: 0 mode: 0\n", - "variance: 0.162572 standard deviation: 0.403202 lower quartile: 0 upper quartile: 0\n", - "coefficient of skewness: 1.46667 coefficient of kurtosis: 0.151122\n", - "\n", - "number of runs of state 3 per sequence frequency distribution - sample size: 30\n", - "mean: 0.2 median: 0 mode: 0\n", - "variance: 0.165517 standard deviation: 0.406838 lower quartile: 0 upper quartile: 0\n", - "coefficient of skewness: 1.58013 coefficient of kurtosis: 0.141667\n", - "\n", - "number of runs of state 4 per length 100 sequence distribution\n", - "mean: 0.514647 median: 1 mode: 1\n", - "variance: 0.249785 standard deviation: 0.499785 lower quartile: 0 upper quartile: 1\n", - "coefficient of skewness: -0.0586148 coefficient of kurtosis: -1.99656\n", - "\n", - "number of runs of state 4 per sequence frequency distribution - sample size: 30\n", - "mean: 0.533333 median: 1 mode: 1\n", - "variance: 0.257471 standard deviation: 0.507416 lower quartile: 0 upper quartile: 1\n", - "coefficient of skewness: -0.140769 coefficient of kurtosis: -2.01607\n", - "\n", - "number of runs of state 5 per length 100 sequence distribution\n", - "mean: 0.781274 median: 1 mode: 1\n", - "variance: 0.170885 standard deviation: 0.413382 lower quartile: 1 upper quartile: 1\n", - "coefficient of skewness: -1.36084 coefficient of kurtosis: -0.148105\n", - "\n", - "number of runs of state 5 per sequence frequency distribution - sample size: 30\n", - "mean: 0.8 median: 1 mode: 1\n", - "variance: 0.165517 standard deviation: 0.406838 lower quartile: 1 upper quartile: 1\n", - "coefficient of skewness: -1.58013 coefficient of kurtosis: 0.141667\n", - "\n", - "number of runs of state 6 per length 100 sequence distribution\n", - "mean: 0.0695858 median: 0 mode: 0\n", - "variance: 0.0647436 standard deviation: 0.254448 lower quartile: 0 upper quartile: 0\n", - "coefficient of skewness: 3.38312 coefficient of kurtosis: 9.44553\n", - "\n", - "number of runs of state 6 per sequence frequency distribution - sample size: 30\n", - "mean: 0.0666667 median: 0 mode: 0\n", - "variance: 0.0643678 standard deviation: 0.253708 lower quartile: 0 upper quartile: 0\n", - "coefficient of skewness: 3.66 coefficient of kurtosis: 9.63571\n", - "\n", - "number of runs of state 7 per length 100 sequence distribution\n", - "mean: 0.114078 median: 0 mode: 0\n", - "variance: 0.101064 standard deviation: 0.317906 lower quartile: 0 upper quartile: 0\n", - "coefficient of skewness: 2.42791 coefficient of kurtosis: 3.89473\n", - "\n", - "number of runs of state 7 per sequence frequency distribution - sample size: 30\n", - "mean: 0.133333 median: 0 mode: 0\n", - "variance: 0.11954 standard deviation: 0.345746 lower quartile: 0 upper quartile: 0\n", - "coefficient of skewness: 2.27252 coefficient of kurtosis: 2.46538\n", - "\n", - "number of occurrences of state 0 per length 100 sequence distribution\n", - "mean: 8.55929 median: 0 mode: 0\n", - "variance: 252.432 standard deviation: 15.8881 lower quartile: 0 upper quartile: 11\n", - "coefficient of skewness: 2.50884 coefficient of kurtosis: 7.19439\n", - "\n", - "number of occurrences of state 0 per sequence frequency distribution - sample size: 30\n", - "mean: 8.73333 median: 0 mode: 0\n", - "variance: 272.547 standard deviation: 16.509 lower quartile: 0 upper quartile: 9\n", - "coefficient of skewness: 2.11944 coefficient of kurtosis: 2.75721\n", - "\n", - "number of occurrences of state 1 per length 100 sequence distribution\n", - "mean: 6.74859 median: 0 mode: 0\n", - "variance: 170.43 standard deviation: 13.0549 lower quartile: 0 upper quartile: 0\n", - "coefficient of skewness: 1.4232 coefficient of kurtosis: 0.0394921\n", - "\n", - "number of occurrences of state 1 per sequence frequency distribution - sample size: 30\n", - "mean: 6.4 median: 0 mode: 0\n", - "variance: 169.628 standard deviation: 13.0241 lower quartile: 0 upper quartile: 0\n", - "coefficient of skewness: 1.58334 coefficient of kurtosis: 0.155414\n", - "\n", - "number of occurrences of state 2 per length 100 sequence distribution\n", - "mean: 9.02619 median: 0 mode: 0\n", - "variance: 483.46 standard deviation: 21.9877 lower quartile: 0 upper quartile: 0\n", - "coefficient of skewness: 2.24764 coefficient of kurtosis: 3.66329\n", - "\n", - "number of occurrences of state 2 per sequence frequency distribution - sample size: 30\n", - "mean: 8.2 median: 0 mode: 0\n", - "variance: 497.269 standard deviation: 22.2995 lower quartile: 0 upper quartile: 0\n", - "coefficient of skewness: 2.60499 coefficient of kurtosis: 4.1921\n", - "\n", - "number of occurrences of state 3 per length 100 sequence distribution\n", - "mean: 9.61647 median: 0 mode: 0\n", - "variance: 363.354 standard deviation: 19.0618 lower quartile: 0 upper quartile: 0\n", - "coefficient of skewness: 1.49929 coefficient of kurtosis: 0.300671\n", - "\n", - "number of occurrences of state 3 per sequence frequency distribution - sample size: 30\n", - "mean: 9.26667 median: 0 mode: 0\n", - "variance: 358.478 standard deviation: 18.9335 lower quartile: 0 upper quartile: 0\n", - "coefficient of skewness: 1.61415 coefficient of kurtosis: 0.285933\n", - "\n", - "number of occurrences of state 4 per length 100 sequence distribution\n", - "mean: 21.8631 median: 6 mode: 0\n", - "variance: 774.16 standard deviation: 27.8237 lower quartile: 0 upper quartile: 39\n", - "coefficient of skewness: 1.10544 coefficient of kurtosis: 0.15026\n", - "\n", - "number of occurrences of state 4 per sequence frequency distribution - sample size: 30\n", - "mean: 23.4667 median: 7.5 mode: 0\n", - "variance: 913.499 standard deviation: 30.2241 lower quartile: 0 upper quartile: 37\n", - "coefficient of skewness: 1.13801 coefficient of kurtosis: -0.190321\n", - "\n", - "number of occurrences of state 5 per length 100 sequence distribution\n", - "mean: 34.9007 median: 33 mode: 0\n", - "variance: 734.349 standard deviation: 27.0989 lower quartile: 10 upper quartile: 56\n", - "coefficient of skewness: 0.213299 coefficient of kurtosis: -1.08806\n", - "\n", - "number of occurrences of state 5 per sequence frequency distribution - sample size: 30\n", - "mean: 35.1 median: 34 mode: 0\n", - "variance: 785.817 standard deviation: 28.0324 lower quartile: 12 upper quartile: 57\n", - "coefficient of skewness: 0.344513 coefficient of kurtosis: -1.04994\n", - "\n", - "number of occurrences of state 6 per length 100 sequence distribution\n", - "mean: 2.79198 median: 0 mode: 0\n", - "variance: 111.862 standard deviation: 10.5765 lower quartile: 0 upper quartile: 0\n", - "coefficient of skewness: 3.61461 coefficient of kurtosis: 11.2429\n", - "\n", - "number of occurrences of state 6 per sequence frequency distribution - sample size: 30\n", - "mean: 3 median: 0 mode: 0\n", - "variance: 130.345 standard deviation: 11.4169 lower quartile: 0 upper quartile: 0\n", - "coefficient of skewness: 3.66 coefficient of kurtosis: 9.63571\n", - "\n", - "number of occurrences of state 7 per length 100 sequence distribution\n", - "mean: 6.49375 median: 0 mode: 0\n", - "variance: 423.119 standard deviation: 20.5699 lower quartile: 0 upper quartile: 0\n", - "coefficient of skewness: 3.26525 coefficient of kurtosis: 9.57041\n", - "\n", - "number of occurrences of state 7 per sequence frequency distribution - sample size: 30\n", - "mean: 5.83333 median: 0 mode: 0\n", - "variance: 390.42 standard deviation: 19.759 lower quartile: 0 upper quartile: 0\n", - "coefficient of skewness: 3.89334 coefficient of kurtosis: 12.4423\n", - "\n", - "1 OUTPUT_PROCESS\n", - "\n", - "OUTPUT_PROCESS 1 : CATEGORICAL\n", - "\n", - "STATE 0 OBSERVATION_DISTRIBUTION\n", - "OUTPUT 0 : 0.99996\n", - "OUTPUT 1 : 1e-05\n", - "OUTPUT 2 : 1e-05\n", - "OUTPUT 3 : 1e-05\n", - "OUTPUT 4 : 1e-05\n", - "\n", - "STATE 1 OBSERVATION_DISTRIBUTION\n", - "OUTPUT 0 : 0.122538\n", - "OUTPUT 1 : 0.31821\n", - "OUTPUT 2 : 0.209335\n", - "OUTPUT 3 : 0.148394\n", - "OUTPUT 4 : 0.201522\n", - "\n", - "STATE 2 OBSERVATION_DISTRIBUTION\n", - "OUTPUT 0 : 0.197229\n", - "OUTPUT 1 : 0.159907\n", - "OUTPUT 2 : 0.311546\n", - "OUTPUT 3 : 0.202186\n", - "OUTPUT 4 : 0.129132\n", - "\n", - "STATE 3 OBSERVATION_DISTRIBUTION\n", - "OUTPUT 0 : 0.185393\n", - "OUTPUT 1 : 0.229193\n", - "OUTPUT 2 : 0.225746\n", - "OUTPUT 3 : 0.217339\n", - "OUTPUT 4 : 0.142328\n", - "\n", - "STATE 4 OBSERVATION_DISTRIBUTION\n", - "OUTPUT 0 : 0.210002\n", - "OUTPUT 1 : 0.181782\n", - "OUTPUT 2 : 0.178779\n", - "OUTPUT 3 : 0.157921\n", - "OUTPUT 4 : 0.271516\n", - "\n", - "STATE 5 OBSERVATION_DISTRIBUTION\n", - "OUTPUT 0 : 0.99996\n", - "OUTPUT 1 : 1e-05\n", - "OUTPUT 2 : 1e-05\n", - "OUTPUT 3 : 1e-05\n", - "OUTPUT 4 : 1e-05\n", - "\n", - "STATE 6 OBSERVATION_DISTRIBUTION\n", - "OUTPUT 0 : 0.262422\n", - "OUTPUT 1 : 0.35585\n", - "OUTPUT 2 : 0.101671\n", - "OUTPUT 3 : 0.0525601\n", - "OUTPUT 4 : 0.227497\n", - "\n", - "STATE 7 OBSERVATION_DISTRIBUTION\n", - "OUTPUT 0 : 0.261249\n", - "OUTPUT 1 : 0.132831\n", - "OUTPUT 2 : 0.200594\n", - "OUTPUT 3 : 0.232187\n", - "OUTPUT 4 : 0.173138\n", - "\n", - "observation probability matrix\n", - "\n", - " 0 1 2 3 4 \n", - "0 0.99996 1e-05 1e-05 1e-05 1e-05 \n", - "1 0.122538 0.31821 0.209335 0.148394 0.201522 \n", - "2 0.197229 0.159907 0.311546 0.202186 0.129132 \n", - "3 0.185393 0.229193 0.225746 0.217339 0.142328 \n", - "4 0.210002 0.181782 0.178779 0.157921 0.271516 \n", - "5 0.99996 1e-05 1e-05 1e-05 1e-05 \n", - "6 0.262422 0.35585 0.101671 0.0525601 0.227497 \n", - "7 0.261249 0.132831 0.200594 0.232187 0.173138 \n", - "\n", - "theoretical weights: 0.0855929 0.0674859 0.0902619 0.0961647 0.218631 0.349007 0.0279198 0.0649375\n", - "\n", - "log-likelihood: -3938.91 (normalized: -1.31297)\n", - "maximum possible log-likelihood: -3938.89 (information: -1.31296)\n", - "deviance: 0.045217\n", - "\n", - "chi-square test (4 degrees of freedom)\n", - "chi-square value: 0.0451775 critical probability: 0.999749\n", - "reference chi-square value: 9.48773 reference critical probability: 0.05\n", - "\n", - "restoration weights: 0.0873333 0.064 0.082 0.0926667 0.234667 0.351 0.03 0.0583333\n", - "\n", - "log-likelihood: -3939.02 (normalized: -1.31301)\n", - "maximum possible log-likelihood: -3938.89 (information: -1.31296)\n", - "deviance: 0.257615\n", - "\n", - "chi-square test (4 degrees of freedom)\n", - "chi-square value: 0.258313 critical probability: 0.992344\n", - "reference chi-square value: 9.48773 reference critical probability: 0.05\n", - "\n", - "time up to the first occurrence of output 0 distribution\n", - "mean: 3.02421 median: 1 mode: 0\n", - "variance: 25.261 standard deviation: 5.02603 lower quartile: 0 upper quartile: 4\n", - "\n", - "time up to the first occurrence of output 0 frequency distribution - sample size: 30\n", - "mean: 3.8 median: 1 mode: 0\n", - "variance: 35.7517 standard deviation: 5.97927 lower quartile: 0 upper quartile: 4\n", - "\n", - "time up to the first occurrence of output 1 distribution\n", - "mean: 14.5622 median: 6 mode: 0\n", - "variance: 682.125 standard deviation: 26.1175 lower quartile: 2 upper quartile: 18\n", - "\n", - "time up to the first occurrence of output 1 frequency distribution - sample size: 30\n", - "mean: 13.5333 median: 5 mode: 0\n", - "variance: 322.12 standard deviation: 17.9477 lower quartile: 1 upper quartile: 23\n", - "\n", - "time up to the first occurrence of output 2 distribution\n", - "mean: 14.6961 median: 6 mode: 0\n", - "variance: 718.095 standard deviation: 26.7973 lower quartile: 2 upper quartile: 17\n", - "\n", - "time up to the first occurrence of output 2 frequency distribution - sample size: 30\n", - "mean: 10.9667 median: 3.5 mode: 0\n", - "variance: 286.102 standard deviation: 16.9146 lower quartile: 1 upper quartile: 11\n", - "\n", - "time up to the first occurrence of output 3 distribution\n", - "mean: 16.6851 median: 7 mode: 0\n", - "variance: 916.86 standard deviation: 30.2797 lower quartile: 2 upper quartile: 19\n", - "\n", - "time up to the first occurrence of output 3 frequency distribution - sample size: 29\n", - "mean: 13.8966 median: 5 mode: 3\n", - "variance: 359.31 standard deviation: 18.9555 lower quartile: 3 upper quartile: 14\n", - "\n", - "time up to the first occurrence of output 4 distribution\n", - "mean: 13.4275 median: 6 mode: 0\n", - "variance: 431.958 standard deviation: 20.7836 lower quartile: 2 upper quartile: 17\n", - "\n", - "time up to the first occurrence of output 4 frequency distribution - sample size: 30\n", - "mean: 12.1333 median: 5.5 mode: 2\n", - "variance: 290.395 standard deviation: 17.041 lower quartile: 2 upper quartile: 12\n", - "\n", - "output 0 recurrence time distribution\n", - "mean: 1.28005 median: 1 mode: 1\n", - "variance: 2.11762 standard deviation: 1.45521 lower quartile: 1 upper quartile: 1\n", - "\n", - "output 0 recurrence time frequency distribution - sample size: 1616\n", - "mean: 1.763 median: 1 mode: 1\n", - "variance: 5.28683 standard deviation: 2.29931 lower quartile: 1 upper quartile: 1\n", - "\n", - "output 1 recurrence time distribution\n", - "mean: 17.1212 median: 3 mode: 1\n", - "variance: 2362.13 standard deviation: 48.6018 lower quartile: 2 upper quartile: 7\n", - "\n", - "output 1 recurrence time frequency distribution - sample size: 321\n", - "mean: 4.29283 median: 3 mode: 1\n", - "variance: 18.5015 standard deviation: 4.30133 lower quartile: 2 upper quartile: 5\n", - "\n", - "output 2 recurrence time distribution\n", - "mean: 17.2394 median: 3 mode: 1\n", - "variance: 2472.46 standard deviation: 49.7238 lower quartile: 2 upper quartile: 7\n", - "\n", - "output 2 recurrence time frequency distribution - sample size: 326\n", - "mean: 4.40491 median: 3 mode: 1\n", - "variance: 18.0632 standard deviation: 4.25009 lower quartile: 2 upper quartile: 6\n", - "\n", - "output 3 recurrence time distribution\n", - "mean: 20.9892 median: 4 mode: 1\n", - "variance: 3150.26 standard deviation: 56.1271 lower quartile: 2 upper quartile: 8\n", - "\n", - "output 3 recurrence time frequency distribution - sample size: 269\n", - "mean: 5.19703 median: 4 mode: 1\n", - "variance: 23.0618 standard deviation: 4.80227 lower quartile: 2 upper quartile: 7\n", - "\n", - "output 4 recurrence time distribution\n", - "mean: 17.1691 median: 3 mode: 1\n", - "variance: 2398.99 standard deviation: 48.9795 lower quartile: 2 upper quartile: 7\n", - "\n", - "output 4 recurrence time frequency distribution - sample size: 319\n", - "mean: 4.45455 median: 3 mode: 1\n", - "variance: 15.1041 standard deviation: 3.88639 lower quartile: 2 upper quartile: 6\n", - "\n", - "output 0 sojourn time distribution\n", - "mean: 15.5596 median: 1 mode: 1\n", - "variance: 2477.78 standard deviation: 49.7773 lower quartile: 1 upper quartile: 2\n", - "coefficient of variation: 3.19915\n", - "\n", - "output 0 sojourn time frequency distribution - sample size: 279\n", - "mean: 2.12186 median: 1 mode: 1\n", - "variance: 33.87 standard deviation: 5.81979 lower quartile: 1 upper quartile: 1\n", - "\n", - "final run - output 0 sojourn time frequency distribution - sample size: 25\n", - "mean: 42.16 median: 38 mode: 18\n", - "variance: 638.057 standard deviation: 25.2598 lower quartile: 21 upper quartile: 61\n", - "\n", - "output 1 sojourn time distribution\n", - "mean: 1.28114 median: 1 mode: 1\n", - "variance: 0.378052 standard deviation: 0.614859 lower quartile: 1 upper quartile: 1\n", - "coefficient of variation: 0.479931\n", - "\n", - "output 1 sojourn time frequency distribution - sample size: 272\n", - "mean: 1.28676 median: 1 mode: 1\n", - "variance: 0.345507 standard deviation: 0.587798 lower quartile: 1 upper quartile: 1\n", - "\n", - "final run - output 1 sojourn time frequency distribution - sample size: 1\n", - "mean: 1 median: 1 mode: 1\n", - "variance: 0 standard deviation: 0\n", - "\n", - "output 2 sojourn time distribution\n", - "mean: 1.27565 median: 1 mode: 1\n", - "variance: 0.35309 standard deviation: 0.594214 lower quartile: 1 upper quartile: 1\n", - "coefficient of variation: 0.465814\n", - "\n", - "output 2 sojourn time frequency distribution - sample size: 279\n", - "mean: 1.27599 median: 1 mode: 1\n", - "variance: 0.373198 standard deviation: 0.6109 lower quartile: 1 upper quartile: 1\n", - "\n", - "final run - output 2 sojourn time frequency distribution - sample size: 0\n", - "\n", - "output 3 sojourn time distribution\n", - "mean: 1.22431 median: 1 mode: 1\n", - "variance: 0.2786 standard deviation: 0.527826 lower quartile: 1 upper quartile: 1\n", - "coefficient of variation: 0.431122\n", - "\n", - "output 3 sojourn time frequency distribution - sample size: 236\n", - "mean: 1.25847 median: 1 mode: 1\n", - "variance: 0.371204 standard deviation: 0.609266 lower quartile: 1 upper quartile: 1\n", - "\n", - "final run - output 3 sojourn time frequency distribution - sample size: 1\n", - "mean: 1 median: 1 mode: 1\n", - "variance: 0 standard deviation: 0\n", - "\n", - "output 4 sojourn time distribution\n", - "mean: 1.27823 median: 1 mode: 1\n", - "variance: 0.35734 standard deviation: 0.59778 lower quartile: 1 upper quartile: 1\n", - "coefficient of variation: 0.467663\n", - "\n", - "output 4 sojourn time frequency distribution - sample size: 280\n", - "mean: 1.23571 median: 1 mode: 1\n", - "variance: 0.238146 standard deviation: 0.488003 lower quartile: 1 upper quartile: 1\n", - "\n", - "final run - output 4 sojourn time frequency distribution - sample size: 3\n", - "mean: 1 median: 1 mode: 1\n", - "variance: 0 standard deviation: 0\n", - "\n", - "number of runs of output 0 per length 100 sequence distribution\n", - "mean: 10.0036 median: 10 mode: 9\n", - "variance: 22.869 standard deviation: 4.78216 lower quartile: 6 upper quartile: 13\n", - "coefficient of skewness: 0.427249 coefficient of kurtosis: -0.295971\n", - "\n", - "number of runs of output 0 per sequence frequency distribution - sample size: 30\n", - "mean: 10.1333 median: 10.5 mode: 5\n", - "variance: 25.7057 standard deviation: 5.07008 lower quartile: 6 upper quartile: 13\n", - "coefficient of skewness: 0.551009 coefficient of kurtosis: 0.133669\n", - "\n", - "number of runs of output 1 per length 100 sequence distribution\n", - "mean: 9.06264 median: 8 mode: 7\n", - "variance: 24.7691 standard deviation: 4.97686 lower quartile: 5 upper quartile: 13\n", - "coefficient of skewness: 0.367291 coefficient of kurtosis: -0.520738\n", - "\n", - "number of runs of output 1 per sequence frequency distribution - sample size: 30\n", - "mean: 9.1 median: 10 mode: 11\n", - "variance: 21.8862 standard deviation: 4.67827 lower quartile: 5 upper quartile: 12\n", - "coefficient of skewness: -0.00484963 coefficient of kurtosis: -1.01555\n", - "\n", - "number of runs of output 2 per length 100 sequence distribution\n", - "mean: 9.28724 median: 9 mode: 9\n", - "variance: 23.3499 standard deviation: 4.83217 lower quartile: 6 upper quartile: 13\n", - "coefficient of skewness: 0.150553 coefficient of kurtosis: -0.597501\n", - "\n", - "number of runs of output 2 per sequence frequency distribution - sample size: 30\n", - "mean: 9.3 median: 8.5 mode: 7\n", - "variance: 17.7345 standard deviation: 4.21123 lower quartile: 7 upper quartile: 12\n", - "coefficient of skewness: 0.306374 coefficient of kurtosis: -0.47525\n", - "\n", - "number of runs of output 3 per length 100 sequence distribution\n", - "mean: 8.18276 median: 8 mode: 8\n", - "variance: 19.5665 standard deviation: 4.42341 lower quartile: 5 upper quartile: 11\n", - "coefficient of skewness: 0.272993 coefficient of kurtosis: -0.43369\n", - "\n", - "number of runs of output 3 per sequence frequency distribution - sample size: 30\n", - "mean: 7.9 median: 8 mode: 5\n", - "variance: 18.7138 standard deviation: 4.32594 lower quartile: 5 upper quartile: 11\n", - "coefficient of skewness: 0.0318733 coefficient of kurtosis: -1.10965\n", - "\n", - "number of runs of output 4 per length 100 sequence distribution\n", - "mean: 9.06905 median: 8 mode: 6\n", - "variance: 24.8814 standard deviation: 4.98813 lower quartile: 5 upper quartile: 12\n", - "coefficient of skewness: 0.586317 coefficient of kurtosis: -0.140073\n", - "\n", - "number of runs of output 4 per sequence frequency distribution - sample size: 30\n", - "mean: 9.43333 median: 8.5 mode: 8\n", - "variance: 21.7713 standard deviation: 4.66597 lower quartile: 6 upper quartile: 13\n", - "coefficient of skewness: 0.231232 coefficient of kurtosis: -0.79577\n", - "\n", - "number of occurrences of output 0 per length 100 sequence distribution\n", - "mean: 54.8687 median: 56 mode: 61\n", - "variance: 423.019 standard deviation: 20.5674 lower quartile: 37 upper quartile: 70\n", - "coefficient of skewness: 0.0857876 coefficient of kurtosis: -0.922464\n", - "\n", - "number of occurrences of output 0 per sequence frequency distribution - sample size: 30\n", - "mean: 54.8667 median: 57 mode: 59\n", - "variance: 382.809 standard deviation: 19.5655 lower quartile: 35 upper quartile: 71\n", - "coefficient of skewness: 0.23948 coefficient of kurtosis: -0.918006\n", - "\n", - "number of occurrences of output 1 per length 100 sequence distribution\n", - "mean: 11.6257 median: 11 mode: 9\n", - "variance: 48.3723 standard deviation: 6.95502 lower quartile: 6 upper quartile: 16\n", - "coefficient of skewness: 0.577083 coefficient of kurtosis: -0.255672\n", - "\n", - "number of occurrences of output 1 per sequence frequency distribution - sample size: 30\n", - "mean: 11.7 median: 11.5 mode: 7\n", - "variance: 42.4241 standard deviation: 6.51338 lower quartile: 7 upper quartile: 17\n", - "coefficient of skewness: 0.473458 coefficient of kurtosis: -0.473184\n", - "\n", - "number of occurrences of output 2 per length 100 sequence distribution\n", - "mean: 11.8912 median: 12 mode: 11\n", - "variance: 43.805 standard deviation: 6.61853 lower quartile: 7 upper quartile: 17\n", - "coefficient of skewness: 0.356237 coefficient of kurtosis: -0.236288\n", - "\n", - "number of occurrences of output 2 per sequence frequency distribution - sample size: 30\n", - "mean: 11.8667 median: 12 mode: 12\n", - "variance: 32.1885 standard deviation: 5.67349 lower quartile: 8 upper quartile: 15\n", - "coefficient of skewness: 0.283527 coefficient of kurtosis: -0.540716\n", - "\n", - "number of occurrences of output 3 per length 100 sequence distribution\n", - "mean: 10.024 median: 10 mode: 10\n", - "variance: 32.3254 standard deviation: 5.68554 lower quartile: 6 upper quartile: 14\n", - "coefficient of skewness: 0.400543 coefficient of kurtosis: -0.205836\n", - "\n", - "number of occurrences of output 3 per sequence frequency distribution - sample size: 30\n", - "mean: 9.93333 median: 10.5 mode: 5\n", - "variance: 33.5126 standard deviation: 5.78901 lower quartile: 5 upper quartile: 14\n", - "coefficient of skewness: 0.262876 coefficient of kurtosis: -0.805018\n", - "\n", - "number of occurrences of output 4 per length 100 sequence distribution\n", - "mean: 11.5903 median: 10 mode: 7\n", - "variance: 46.5412 standard deviation: 6.82211 lower quartile: 6 upper quartile: 16\n", - "coefficient of skewness: 0.765721 coefficient of kurtosis: 0.219628\n", - "\n", - "number of occurrences of output 4 per sequence frequency distribution - sample size: 30\n", - "mean: 11.6333 median: 10 mode: 5.5\n", - "variance: 40.4471 standard deviation: 6.35981 lower quartile: 6 upper quartile: 16\n", - "coefficient of skewness: 0.523481 coefficient of kurtosis: -0.760353\n", - "\n", - "distances between observation distributions for consecutive states\n", - "_ _ 0.802731 _ 0.789958 _ 0.737538 0.738711 \n", - "_ _ _ 0.148211 0.166984 0.877422 _ _ \n", - "_ _ _ _ _ 0.802731 _ _ \n", - "_ _ _ _ _ 0.814567 _ _ \n", - "_ _ _ _ _ 0.789958 0.226488 _ \n", - "_ _ _ _ _ _ 0.737538 0.738711 \n", - "_ _ _ _ _ _ _ 0.278551 \n", - "_ _ _ _ _ _ _ _ \n", - "\n", - "sequence length frequency distribution - sample size: 30\n", - "mean: 100 median: 100 mode: 100\n", - "variance: 0 standard deviation: 0\n", - "\n", - "cumulative length: 3000\n", - "\n", - "information quantity of the sequences in the i.i.d. case: -3938.89 (-1.31296)\n", - "\n", - "log-likelihood for the state sequences: -2873.61 (normalized: -0.957871)\n", - "\n", - "state sequence entropy: 47.4195 (normalized: 0.0158065)\n", - "\n", - "log-likelihood for the observed sequences: -2852.01 (normalized: -0.95067)\n", - "\n", - "48 free parameters 2 * penalyzed log-likelihood (AIC): -5800.02\n", - "\n", - "48 free parameters 2 * penalyzed log-likelihood (AICc): -5801.61\n", - "\n", - "48 free parameters 2 * penalyzed log-likelihood (BIC): -6088.32\n", - "\n", - "48 free parameters 2 * penalyzed log-likelihood (BICc): -5941.91\n", - "\n", - "48 free parameters 2 * penalyzed log-likelihood (ICL): -6183.16\n", - "\n", - "48 free parameters 2 * penalyzed log-likelihood (ICLc): -6036.75\n", - "\n", - "tion 17 log-likelihood for the observed sequences: -2858.48\n", - "iteration 18 log-likelihood for the observed sequences: -2857.32\n", - "iteration 19 log-likelihood for the observed sequences: -2855.61\n", - "iteration 20 log-likelihood for the observed sequences: -2854.43\n", - "iteration 21 log-likelihood for the observed sequences: -2853.82\n", - "iteration 22 log-likelihood for the observed sequences: -2853.42\n", - "iteration 23 log-likelihood for the observed sequences: -2853.17\n", - "iteration 24 log-likelihood for the observed sequences: -2853\n", - "iteration 25 log-likelihood for the observed sequences: -2852.84\n", - "iteration 26 log-likelihood for the observed sequences: -2852.71\n", - "iteration 27 log-likelihood for the observed sequences: -2852.57\n", - "iteration 28 log-likelihood for the observed sequences: -2852.46\n", - "iteration 29 log-likelihood for the observed sequences: -2852.33\n", - "iteration 30 log-likelihood for the observed sequences: -2852.22\n", - "iteration 31 log-likelihood for the observed sequences: -2852.14\n", - "iteration 32 log-likelihood for the observed sequences: -2852.1\n", - "iteration 33 log-likelihood for the observed sequences: -2852.07\n", - "iteration 34 log-likelihood for the observed sequences: -2852.05\n", - "iteration 35 log-likelihood for the observed sequences: -2852.04\n", - "iteration 36 log-likelihood for the observed sequences: -2852.03\n", - "iteration 37 log-likelihood for the observed sequences: -2852.02\n", - "iteration 38 log-likelihood for the observed sequences: -2852.02\n", - "\n", - "38 iterations\n", - "\n", - "complete/censored state occupancy weights\n", - "state 0: 11.7653, 3.82708e-26 (1, 3.25286e-27)\n", - "state 1: 6.33785, 2.72235e-10 (1, 4.29538e-11)\n", - "state 2: 4.41609, 0.268228 (0.942739, 0.0572608)\n", - "state 3: 6.12955, 6.90893e-06 (0.999999, 1.12715e-06)\n", - "state 4: 13.7482, 1.73045 (0.888204, 0.111796)\n", - "state 5: 0.00158837, 24.0347 (6.60819e-05, 0.999934)\n", - "state 6: 1.91689, 0.180941 (0.913748, 0.0862516)\n", - "\n", - "N.o. initial states in parallel: 1\n", - "\n", - "log-likelihood for the state sequences: -2873.61 | -2873.61\n", - "\n", - "posterior state sequence probability\n", - "sequence 1: 0.663218 | state begin: 52, \n", - "sequence 2: 0.562116 | state begin: 3, \n", - "sequence 3: 0.768757 | state begin: 7, \n", - "sequence 4: 0.806722 | state begin: 62, \n", - "sequence 5: 0.63489 | state begin: 79, \n", - "sequence 6: 0.740864 | state begin: 5, \n", - "sequence 7: 0.244956 | state begin: 32, 72, \n", - "sequence 8: 0.616051 | state begin: 39, 66, \n", - "sequence 9: 0.275982 | state begin: 33, 82, \n", - "sequence 10: 0.595224 | state begin: 7, 15, \n", - "sequence 11: 0.477811 | state begin: 47, \n", - "sequence 12: 0.786082 | state begin: 64, \n", - "sequence 13: 0.798894 | state begin: 47, \n", - "sequence 14: 0.0644339 | state begin: 32, 50, 95, \n", - "sequence 15: 0.77781 | state begin: 22, \n", - "sequence 16: 0.620404 | state begin: 10, 95, \n", - "sequence 17: 0.124355 | state begin: 33, 88, \n", - "sequence 18: 0.749795 | state begin: 82, \n", - "sequence 19: 0.249874 | state begin: 33, 78, \n", - "sequence 20: 0.63185 | state begin: 63, \n", - "sequence 21: 0.275816 | state begin: 31, 78, \n", - "sequence 22: 0.467325 | state begin: 46, \n", - "sequence 23: 0.690883 | state begin: 69, \n", - "sequence 24: 0.622146 | state begin: 9, 39, \n", - "sequence 25: 0.755173 | state begin: 32, \n", - "sequence 26: 0.671974 | state begin: 36, \n", - "sequence 27: 0.244974 | state begin: 31, 52, \n", - "sequence 28: 0.496528 | state begin: 43, \n", - "sequence 29: 0.49913 | state begin: 4, 36, \n", - "sequence 30: 0.655077 | state begin: 10, 83, \n" - ] - } - ], - "source": [ - "from openalea.sequence_analysis import Estimate\n", - "nb_states = 8\n", - "\n", - "hsmc_est = Estimate(obs, \"HIDDEN_SEMI-MARKOV\", \"Ordinary\", nb_states, \"LeftRight\", Nbiteration=300) \n", - "print(hsmc_est.display())" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Plotting marginal relative frequencies of data and predicted probabilities as a function of index" - ] - }, - { - "cell_type": "code", - "execution_count": 30, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "hsmc_est.plot(\"Intensity\", 1)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Observation (i.e., emission) distributions" - ] - }, - { - "cell_type": "code", - "execution_count": 31, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "hsmc_est.plot(\"Observation\", 1)\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "This continues as before: empirical and predicted statistics" - ] - }, - { - "cell_type": "code", - "execution_count": 32, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "hsmc_est.plot(\"Counting\", 1)\n" - ] - }, - { - "cell_type": "code", - "execution_count": 33, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "hsmc_est.plot(\"Recurrence\", 1)\n" - ] - }, - { - "cell_type": "code", - "execution_count": 34, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "hsmc_est.plot(\"Sojourn\", 1)\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Note that you may also plot figures individually (and not as a collection of figures)" - ] - }, - { - "cell_type": "code", - "execution_count": 35, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "from openalea.sequence_analysis import seq_map\n", - "hsmc_est.extract(seq_map['Observation'],1,1).plot(Title=\"Observation distribution for state 1\")" - ] - }, - { - "cell_type": "code", - "execution_count": 36, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "hsmc_est.extract(seq_map['Sojourn'],0,0).plot(Title=\"Sojourn distribution for state 0\")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Estimate HSMC with parametric emission distributions" - ] - }, - { - "cell_type": "code", - "execution_count": 37, - "metadata": {}, - "outputs": [], - "source": [ - "model_file = \"test_hidden_semi_markov_param.dat\"\n", - "\n", - "f = open(data_path + os.sep + model_file, \"r\")\n", - "f.close()\n", - "\n", - "hsm = HiddenSemiMarkov(data_path + os.sep + model_file)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Simulated model:" - ] - }, - { - "cell_type": "code", - "execution_count": 38, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "HIDDEN_SEMI-MARKOV_CHAIN\n", - "\n", - "3 STATES\n", - "\n", - "INITIAL_PROBABILITIES\n", - "1 0 0 \n", - "\n", - "TRANSITION_PROBABILITIES\n", - "0 0.8 0.2 \n", - "0.2 0 0.8 \n", - "0.8 0.2 0 \n", - "\n", - "recurrent class: states 0 1 2\n", - "\n", - "time up to the first occurrence of state 0 distribution\n", - "mean: 0 median: 0 mode: 0\n", - "variance: 0 standard deviation: 0\n", - "\n", - "time up to the first occurrence of state 1 distribution\n", - "mean: 28.9851 median: 19 mode: 19\n", - "variance: 547.273 standard deviation: 23.3939 lower quartile: 18 upper quartile: 20\n", - "\n", - "time up to the first occurrence of state 2 distribution\n", - "mean: 59.9053 median: 58 mode: 19\n", - "variance: 1044.37 standard deviation: 32.3167 lower quartile: 51 upper quartile: 64\n", - "\n", - "state 0 recurrence time distribution\n", - "mean: 4.78015 median: 1 mode: 1\n", - "variance: 327.733 standard deviation: 18.1034 lower quartile: 1 upper quartile: 1\n", - "\n", - "state 1 recurrence time distribution\n", - "mean: 2.21 median: 1 mode: 1\n", - "variance: 74.3382 standard deviation: 8.62196 lower quartile: 1 upper quartile: 1\n", - "\n", - "state 2 recurrence time distribution\n", - "mean: 2.9469 median: 1 mode: 1\n", - "variance: 144.221 standard deviation: 12.0092 lower quartile: 1 upper quartile: 1\n", - "\n", - "STATE 0 OCCUPANCY_DISTRIBUTION\n", - "BINOMIAL INF_BOUND : 10 SUP_BOUND : 20 PROBABILITY : 0.85\n", - "mean: 18.5 median: 19 mode: 19\n", - "variance: 1.275 standard deviation: 1.12916 lower quartile: 18 upper quartile: 19\n", - "coefficient of skewness: -0.61993 coefficient of kurtosis: 0.184314\n", - "coefficient of variation: 0.0610356\n", - "\n", - "state 0 forward sojourn time distribution\n", - "mean: 9.78446 median: 10 mode: 5.5\n", - "variance: 29.0577 standard deviation: 5.39052 lower quartile: 5 upper quartile: 14\n", - "\n", - "STATE 1 OCCUPANCY_DISTRIBUTION\n", - "POISSON INF_BOUND : 15 PARAMETER : 25\n", - "mean: 40 median: 40 mode: 39.5\n", - "variance: 25 standard deviation: 5 lower quartile: 37 upper quartile: 43\n", - "coefficient of skewness: 0.2 coefficient of kurtosis: 0.04\n", - "coefficient of variation: 0.125\n", - "\n", - "state 1 forward sojourn time distribution\n", - "mean: 20.8125 median: 21 mode: 8\n", - "variance: 145.86 standard deviation: 12.0773 lower quartile: 11 upper quartile: 31\n", - "\n", - "STATE 2 OCCUPANCY_DISTRIBUTION\n", - "NEGATIVE_BINOMIAL INF_BOUND : 20 PARAMETER : 10 PROBABILITY : 0.5\n", - "mean: 30 median: 29.5 mode: 28.5\n", - "variance: 20 standard deviation: 4.47214 lower quartile: 27 upper quartile: 33\n", - "coefficient of skewness: 0.67082 coefficient of kurtosis: 0.65\n", - "coefficient of variation: 0.149071\n", - "\n", - "state 2 forward sojourn time distribution\n", - "mean: 15.8333 median: 16 mode: 10.5\n", - "variance: 85.471 standard deviation: 9.24505 lower quartile: 8 upper quartile: 23\n", - "\n", - "number of runs of state 0 per length 20 sequence distribution\n", - "mean: 1 median: 1 mode: 1\n", - "variance: 0 standard deviation: 0\n", - "\n", - "number of runs of state 1 per length 20 sequence distribution\n", - "mean: 0.6425 median: 1 mode: 1\n", - "variance: 0.229694 standard deviation: 0.479264 lower quartile: 0 upper quartile: 1\n", - "coefficient of skewness: -0.594664 coefficient of kurtosis: -1.64637\n", - "\n", - "number of runs of state 2 per length 20 sequence distribution\n", - "mean: 0.160625 median: 0 mode: 0\n", - "variance: 0.134825 standard deviation: 0.367185 lower quartile: 0 upper quartile: 0\n", - "coefficient of skewness: 1.84852 coefficient of kurtosis: 1.41704\n", - "\n", - "number of occurrences of state 0 per length 20 sequence distribution\n", - "mean: 18.5 median: 19 mode: 19\n", - "variance: 1.275 standard deviation: 1.12916 lower quartile: 18 upper quartile: 19\n", - "coefficient of skewness: -0.61993 coefficient of kurtosis: 0.184314\n", - "\n", - "number of occurrences of state 1 per length 20 sequence distribution\n", - "mean: 1.2 median: 1 mode: 0\n", - "variance: 1.38 standard deviation: 1.17473 lower quartile: 0 upper quartile: 2\n", - "coefficient of skewness: 0.806843 coefficient of kurtosis: 0.134846\n", - "\n", - "number of occurrences of state 2 per length 20 sequence distribution\n", - "mean: 0.3 median: 0 mode: 0\n", - "variance: 0.615 standard deviation: 0.784219 lower quartile: 0 upper quartile: 0\n", - "coefficient of skewness: 2.94529 coefficient of kurtosis: 8.9413\n", - "\n", - "1 OUTPUT_PROCESS\n", - "\n", - "OUTPUT_PROCESS 1 : DISCRETE_PARAMETRIC\n", - "\n", - "STATE 0 OBSERVATION_DISTRIBUTION\n", - "BINOMIAL INF_BOUND : 45 SUP_BOUND : 75 PROBABILITY : 0.25\n", - "mean: 52.5 median: 52 mode: 52\n", - "variance: 5.625 standard deviation: 2.37171 lower quartile: 51 upper quartile: 54\n", - "\n", - "STATE 1 OBSERVATION_DISTRIBUTION\n", - "BINOMIAL INF_BOUND : 75 SUP_BOUND : 100 PROBABILITY : 0.85\n", - "mean: 96.25 median: 96 mode: 97\n", - "variance: 3.1875 standard deviation: 1.78536 lower quartile: 95 upper quartile: 98\n", - "\n", - "STATE 2 OBSERVATION_DISTRIBUTION\n", - "NEGATIVE_BINOMIAL INF_BOUND : 1 PARAMETER : 3 PROBABILITY : 0.2\n", - "mean: 13 median: 12 mode: 8.5\n", - "variance: 60 standard deviation: 7.74597 lower quartile: 7 upper quartile: 17\n", - "\n", - "distances between observation distributions for consecutive states\n", - "_ 1 0.997646 \n", - "1 _ 1 \n", - "0.997646 1 _ \n", - "\n" - ] - } - ], - "source": [ - "print(hsm)" - ] - }, - { - "cell_type": "code", - "execution_count": 39, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "hsm.plot(\"Intensity\", 0) " - ] - }, - { - "cell_type": "code", - "execution_count": 40, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "N.o. initial states in parallel: 0\n", - "\n", - "ERROR: 3 10.3294 16.1009\n", - "\n", - "ERROR: 10 7.76323 5.10749\n", - "\n", - "ERROR: 15 3.36213e-16 -1091.26\n", - "\n", - "ERROR: 19 5.94737 5.77204\n" - ] - } - ], - "source": [ - "set_seed(0)\n", - "nb_seq = 30\n", - "seq_length = 500\n", - "seq = hsm.simulation_nb_sequences(nb_seq, seq_length, True)\n", - "assert(len(seq) == nb_seq)\n", - "assert(len(seq[0]) == seq_length)\n", - "# NB: hsm has 1 output process but simulation includes the hidden state\n", - "assert(len(seq[0][1]) == 2)\n", - "\n", - "nb_states = 3\n", - "obs = seq.select_variable([2], True)\n" - ] - }, - { - "cell_type": "code", - "execution_count": 41, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0\n", - "iteration 1 log-likelihood for the observed sequences: -83418.3\n", - "iteration 2 log-likelihood for the observed sequences: -61605.1\n", - "iteration 3 log-likelihood for the observed sequences: -44917.8\n", - "iteration 4 log-likelihood for the observed sequences: -40171.1\n", - "iteration 5 log-likelihood for the observed sequences: -1e+37\n", - "\n", - " Convergence failed, returning saved model with highest likelihood\n", - "\n", - "5 iterations\n", - "\n", - "complete/censored state occupancy weights\n", - "state 0: 0, 0\n", - "state 1: 0, 0\n", - "state 2: 0, 0\n", - "\n", - "N.o. initial states in parallel: 0\n", - "\n", - "log-likelihood for the state sequences: -40172.3 | -40172.3\n", - "\n", - "posterior state sequence probability\n", - "sequence 1: 0.990092\n", - "sequence 2: 0.817015\n", - "sequence 3: 0.985866\n", - "sequence 4: 0.986438\n", - "sequence 5: 0.984957\n", - "sequence 6: 0.996672\n", - "sequence 7: 0.983564\n", - "sequence 8: 0.987378\n", - "sequence 9: 0.975652\n", - "sequence 10: 0.589754\n", - "sequence 11: 0.985768\n", - "sequence 12: 0.990928\n", - "sequence 13: 0.982602\n", - "sequence 14: 0.984363\n", - "sequence 15: 0.984156\n", - "sequence 16: 0.98134\n", - "sequence 17: 0.993964\n", - "sequence 18: 0.990026\n", - "sequence 19: 0.992416\n", - "sequence 20: 0.985521\n", - "sequence 21: 0.989126\n", - "sequence 22: 0.996691\n", - "sequence 23: 0.982248\n", - "sequence 24: 0.986879\n", - "sequence 25: 0.991516\n", - "sequence 26: 0.96385\n", - "sequence 27: 0.986337\n", - "sequence 28: 0.942628\n", - "sequence 29: 0.988051\n", - "sequence 30: 0.988644\n" - ] - } - ], - "source": [ - "set_seed(0)\n", - "hsmc_est = Estimate(obs, \"HIDDEN_SEMI-MARKOV\", \"Ordinary\", nb_states, \"Irreducible\", Nbiteration=300)" - ] - }, - { - "cell_type": "code", - "execution_count": 42, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "HIDDEN_SEMI-MARKOV_CHAIN\n", - "\n", - "3 STATES\n", - "\n", - "INITIAL_PROBABILITIES\n", - "1e-05 0.999973 1.70881e-05 \n", - "\n", - "TRANSITION_PROBABILITIES\n", - "0 0.286123 0.713877 \n", - "0.807751 0 0.192249 \n", - "0.209932 0.790068 0 \n", - "\n", - "recurrent class: states 0 1 2\n", - "\n", - "time up to the first occurrence of state 0 distribution\n", - "mean: 27.0295 median: 18 mode: 15\n", - "variance: 706.904 standard deviation: 26.5877 lower quartile: 14 upper quartile: 25\n", - "\n", - "time up to the first occurrence of state 0 frequency distribution - sample size: 30\n", - "mean: 24.3667 median: 18.5 mode: 18.5\n", - "variance: 304.24 standard deviation: 17.4425 lower quartile: 18 upper quartile: 19\n", - "\n", - "time up to the first occurrence of state 1 distribution\n", - "mean: 0 median: 0 mode: 0\n", - "variance: 0 standard deviation: 0\n", - "\n", - "time up to the first occurrence of state 1 frequency distribution - sample size: 0\n", - "\n", - "time up to the first occurrence of state 2 distribution\n", - "mean: 56.9857 median: 51 mode: 49\n", - "variance: 1265.56 standard deviation: 35.5747 lower quartile: 38 upper quartile: 66\n", - "\n", - "time up to the first occurrence of state 2 frequency distribution - sample size: 30\n", - "mean: 61 median: 57.5 mode: 53\n", - "variance: 988.069 standard deviation: 31.4336 lower quartile: 53 upper quartile: 62\n", - "\n", - "state 0 recurrence time distribution\n", - "mean: 2.38216 median: 1 mode: 1\n", - "variance: 102.379 standard deviation: 10.1182 lower quartile: 1 upper quartile: 1\n", - "\n", - "state 0 recurrence time frequency distribution - sample size: 6659\n", - "mean: 2.08154 median: 1 mode: 1\n", - "variance: 62.0458 standard deviation: 7.87691 lower quartile: 1 upper quartile: 1\n", - "\n", - "state 1 recurrence time distribution\n", - "mean: 4.76758 median: 1 mode: 1\n", - "variance: 334.826 standard deviation: 18.2983 lower quartile: 1 upper quartile: 1\n", - "\n", - "state 1 recurrence time frequency distribution - sample size: 3439\n", - "mean: 3.99971 median: 1 mode: 1\n", - "variance: 236.899 standard deviation: 15.3915 lower quartile: 1 upper quartile: 1\n", - "\n", - "state 2 recurrence time distribution\n", - "mean: 2.69064 median: 1 mode: 1\n", - "variance: 129.626 standard deviation: 11.3853 lower quartile: 1 upper quartile: 1\n", - "\n", - "state 2 recurrence time frequency distribution - sample size: 4812\n", - "mean: 2.57336 median: 1 mode: 1\n", - "variance: 111.042 standard deviation: 10.5376 lower quartile: 1 upper quartile: 1\n", - "\n", - "STATE 0 OCCUPANCY_DISTRIBUTION\n", - "NEGATIVE_BINOMIAL INF_BOUND : 1 PARAMETER : 27.4906 PROBABILITY : 0.456886\n", - "mean: 33.6788 median: 33 mode: 32\n", - "variance: 71.525 standard deviation: 8.45724 lower quartile: 28 upper quartile: 39\n", - "coefficient of skewness: 0.399356 coefficient of kurtosis: 0.232238\n", - "coefficient of variation: 0.251115\n", - "\n", - "state 0 sojourn time frequency distribution - sample size: 162\n", - "mean: 39.0247 median: 39 mode: 35\n", - "variance: 25.0056 standard deviation: 5.00056 lower quartile: 35 upper quartile: 42\n", - "\n", - "state 0 forward sojourn time distribution\n", - "mean: 18.4012 median: 17 mode: 1\n", - "variance: 131.461 standard deviation: 11.4657 lower quartile: 9 upper quartile: 26\n", - "\n", - "final run - state 0 sojourn time frequency distribution - sample size: 18\n", - "mean: 20.3889 median: 19 mode: 9\n", - "variance: 105.781 standard deviation: 10.285 lower quartile: 10 upper quartile: 26\n", - "\n", - "STATE 1 OCCUPANCY_DISTRIBUTION\n", - "NEGATIVE_BINOMIAL INF_BOUND : 1 PARAMETER : 16.2481 PROBABILITY : 0.507052\n", - "mean: 16.7962 median: 16 mode: 15\n", - "variance: 31.153 standard deviation: 5.58149 lower quartile: 13 upper quartile: 20\n", - "coefficient of skewness: 0.527524 coefficient of kurtosis: 0.401372\n", - "coefficient of variation: 0.332307\n", - "\n", - "state 1 sojourn time frequency distribution - sample size: 186\n", - "mean: 18.5806 median: 19 mode: 19\n", - "variance: 1.17454 standard deviation: 1.08376 lower quartile: 18 upper quartile: 19\n", - "\n", - "state 1 forward sojourn time distribution\n", - "mean: 9.82542 median: 9 mode: 1\n", - "variance: 39.9603 standard deviation: 6.32142 lower quartile: 5 upper quartile: 14\n", - "\n", - "final run - state 1 sojourn time frequency distribution - sample size: 2\n", - "mean: 6.5 median: 1.5 mode: 1\n", - "variance: 60.5 standard deviation: 7.77817 lower quartile: 1 upper quartile: 12\n", - "\n", - "STATE 2 OCCUPANCY_DISTRIBUTION\n", - "NEGATIVE_BINOMIAL INF_BOUND : 1 PARAMETER : 1.56827 PROBABILITY : 0.0468652\n", - "mean: 32.8953 median: 26 mode: 12\n", - "variance: 680.575 standard deviation: 26.0878 lower quartile: 14 upper quartile: 45\n", - "coefficient of skewness: 1.59751 coefficient of kurtosis: 3.82733\n", - "coefficient of variation: 0.793058\n", - "\n", - "state 2 sojourn time frequency distribution - sample size: 157\n", - "mean: 29.8089 median: 29 mode: 29\n", - "variance: 18.7966 standard deviation: 4.3355 lower quartile: 27 upper quartile: 33\n", - "\n", - "state 2 forward sojourn time distribution\n", - "mean: 27.2904 median: 20 mode: 1\n", - "variance: 610.309 standard deviation: 24.7044 lower quartile: 9 upper quartile: 38\n", - "\n", - "final run - state 2 sojourn time frequency distribution - sample size: 10\n", - "mean: 16.2 median: 14.5 mode: 8.5\n", - "variance: 50.1778 standard deviation: 7.08363 lower quartile: 11 upper quartile: 20\n", - "\n", - "number of runs of state 0 per length 500 sequence distribution\n", - "mean: 6.49014 median: 7 mode: 7\n", - "variance: 1.45771 standard deviation: 1.20736 lower quartile: 6 upper quartile: 7\n", - "coefficient of skewness: -0.113836 coefficient of kurtosis: -0.0142091\n", - "\n", - "number of runs of state 0 per sequence frequency distribution - sample size: 30\n", - "mean: 6 median: 6 mode: 6\n", - "variance: 0.551724 standard deviation: 0.742781 lower quartile: 6 upper quartile: 6\n", - "coefficient of skewness: -0.540921 coefficient of kurtosis: 0.171875\n", - "\n", - "number of runs of state 1 per length 500 sequence distribution\n", - "mean: 6.88114 median: 7 mode: 7\n", - "variance: 1.85313 standard deviation: 1.3613 lower quartile: 6 upper quartile: 8\n", - "coefficient of skewness: -0.0404238 coefficient of kurtosis: -0.0295892\n", - "\n", - "number of runs of state 1 per sequence frequency distribution - sample size: 30\n", - "mean: 6.26667 median: 6.5 mode: 7\n", - "variance: 1.16782 standard deviation: 1.08066 lower quartile: 5 upper quartile: 7\n", - "coefficient of skewness: -0.224315 coefficient of kurtosis: -1.03865\n", - "\n", - "number of runs of state 2 per length 500 sequence distribution\n", - "mean: 5.61652 median: 6 mode: 6\n", - "variance: 1.47333 standard deviation: 1.21381 lower quartile: 5 upper quartile: 6\n", - "coefficient of skewness: 0.0815073 coefficient of kurtosis: 0.0186221\n", - "\n", - "number of runs of state 2 per sequence frequency distribution - sample size: 30\n", - "mean: 5.56667 median: 6 mode: 6\n", - "variance: 0.736782 standard deviation: 0.85836 lower quartile: 5 upper quartile: 6\n", - "coefficient of skewness: -0.74673 coefficient of kurtosis: 1.04719\n", - "\n", - "number of occurrences of state 0 per length 500 sequence distribution\n", - "mean: 211.283 median: 212 mode: 214\n", - "variance: 1608.34 standard deviation: 40.1041 lower quartile: 185 upper quartile: 239\n", - "coefficient of skewness: -0.156288 coefficient of kurtosis: -0.0472775\n", - "\n", - "number of occurrences of state 0 per sequence frequency distribution - sample size: 30\n", - "mean: 222.967 median: 229 mode: 169\n", - "variance: 933.895 standard deviation: 30.5597 lower quartile: 206 upper quartile: 247\n", - "coefficient of skewness: -0.40855 coefficient of kurtosis: -0.314425\n", - "\n", - "number of occurrences of state 1 per length 500 sequence distribution\n", - "mean: 113.726 median: 114 mode: 113\n", - "variance: 625.855 standard deviation: 25.0171 lower quartile: 97 upper quartile: 131\n", - "coefficient of skewness: 0.04 coefficient of kurtosis: -0.0510556\n", - "\n", - "number of occurrences of state 1 per sequence frequency distribution - sample size: 30\n", - "mean: 115.633 median: 127 mode: 130\n", - "variance: 448.309 standard deviation: 21.1733 lower quartile: 97 upper quartile: 130\n", - "coefficient of skewness: -0.262237 coefficient of kurtosis: -0.865496\n", - "\n", - "number of occurrences of state 2 per length 500 sequence distribution\n", - "mean: 174.991 median: 174 mode: 171\n", - "variance: 2384.54 standard deviation: 48.8318 lower quartile: 141 upper quartile: 208\n", - "coefficient of skewness: 0.165464 coefficient of kurtosis: -0.0718306\n", - "\n", - "number of occurrences of state 2 per sequence frequency distribution - sample size: 30\n", - "mean: 161.4 median: 166 mode: 143\n", - "variance: 728.041 standard deviation: 26.9822 lower quartile: 144 upper quartile: 177\n", - "coefficient of skewness: -0.457214 coefficient of kurtosis: 0.832975\n", - "\n", - "theoretical state probabilities: 0.422559 0.227468 0.349973 \n", - "restoration state probabilities: 0.445933 0.231267 0.3228 \n", - "\n", - "1 OUTPUT_PROCESS\n", - "\n", - "OUTPUT_PROCESS 1 : DISCRETE_PARAMETRIC\n", - "\n", - "STATE 0 OBSERVATION_DISTRIBUTION\n", - "BINOMIAL INF_BOUND : 76 SUP_BOUND : 100 PROBABILITY : 0.844839\n", - "mean: 96.2761 median: 96 mode: 97\n", - "variance: 3.14607 standard deviation: 1.77372 lower quartile: 95 upper quartile: 98\n", - "\n", - "state 0 observation frequency distribution - sample size: 6689\n", - "mean: 96.2643 median: 96 mode: 97\n", - "variance: 3.19568 standard deviation: 1.78765 lower quartile: 95 upper quartile: 98\n", - "\n", - "STATE 1 OBSERVATION_DISTRIBUTION\n", - "BINOMIAL INF_BOUND : 21 SUP_BOUND : 100 PROBABILITY : 0.401434\n", - "mean: 52.7133 median: 53 mode: 53\n", - "variance: 18.9825 standard deviation: 4.35689 lower quartile: 50 upper quartile: 56\n", - "\n", - "state 1 observation frequency distribution - sample size: 3469\n", - "mean: 52.4967 median: 52 mode: 52\n", - "variance: 5.57301 standard deviation: 2.36072 lower quartile: 51 upper quartile: 54\n", - "\n", - "STATE 2 OBSERVATION_DISTRIBUTION\n", - "NEGATIVE_BINOMIAL INF_BOUND : 1 PARAMETER : 2.73891 PROBABILITY : 0.18672\n", - "mean: 12.9296 median: 11 mode: 8\n", - "variance: 63.8903 standard deviation: 7.99314 lower quartile: 7 upper quartile: 17\n", - "\n", - "state 2 observation frequency distribution - sample size: 4842\n", - "mean: 12.8401 median: 11 mode: 9\n", - "variance: 59.0713 standard deviation: 7.68579 lower quartile: 7 upper quartile: 17\n", - "\n", - "mixture - theoretical weights: 0.422559 0.227468 0.349973\n", - "mean: 57.198 median: 54 mode: 97\n", - "variance: 1363.71 standard deviation: 36.9284 lower quartile: 16 upper quartile: 96\n", - "\n", - "marginal frequency distribution - sample size: 15000\n", - "mean: 59.213 median: 54 mode: 97\n", - "variance: 1338.64 standard deviation: 36.5874 lower quartile: 18 upper quartile: 96\n", - "\n", - "log-likelihood: -54066.4 (normalized: -3.60442)\n", - "maximum possible log-likelihood: -53085.6 (information: -3.53904)\n", - "deviance: 1961.54\n", - "\n", - "chi-square test (78 degrees of freedom)\n", - "chi-square value: 1595.15 critical probability: 1.54107e-281\n", - "reference chi-square value: 99.6169 reference critical probability: 0.05\n", - "reference chi-square value: 109.958 reference critical probability: 0.01\n", - "\n", - "mixture - restoration weights: 0.445933 0.231267 0.3228\n", - "mean: 59.2972 median: 56 mode: 97\n", - "variance: 1340.23 standard deviation: 36.6092 lower quartile: 18 upper quartile: 96\n", - "\n", - "marginal frequency distribution - sample size: 15000\n", - "mean: 59.213 median: 54 mode: 97\n", - "variance: 1338.64 standard deviation: 36.5874 lower quartile: 18 upper quartile: 96\n", - "\n", - "log-likelihood: -54039.1 (normalized: -3.60261)\n", - "maximum possible log-likelihood: -53085.6 (information: -3.53904)\n", - "deviance: 1907.06\n", - "\n", - "chi-square test (78 degrees of freedom)\n", - "chi-square value: 1521.69 critical probability: 2.29711e-266\n", - "reference chi-square value: 99.6169 reference critical probability: 0.05\n", - "reference chi-square value: 109.958 reference critical probability: 0.01\n", - "\n", - "distances between observation distributions for consecutive states\n", - "_ 1 0.999998 \n", - "1 _ 0.991291 \n", - "0.999998 0.991291 _ \n", - "\n", - "sequence length frequency distribution - sample size: 30\n", - "mean: 500 median: 500 mode: 500\n", - "variance: 0 standard deviation: 0\n", - "\n", - "cumulative length: 15000\n", - "\n", - "information quantity of the sequences in the i.i.d. case: -53085.6 (-3.53904)\n", - "\n", - "log-likelihood for the state sequences: -40172.3 (normalized: -2.67815)\n", - "\n", - "state sequence entropy: 4.03785 (normalized: 0.00026919)\n", - "\n", - "log-likelihood for the observed sequences: -40171.1 (normalized: -2.67807)\n", - "\n", - "18 free parameters 2 * penalyzed log-likelihood (AIC): -80378.2\n", - "\n", - "18 free parameters 2 * penalyzed log-likelihood (AICc): -80378.3\n", - "\n", - "18 free parameters 2 * penalyzed log-likelihood (BIC): -80515.3\n", - "\n", - "18 free parameters 2 * penalyzed log-likelihood (BICc): -80485.1\n", - "\n", - "18 free parameters 2 * penalyzed log-likelihood (ICL): -80523.4\n", - "\n", - "18 free parameters 2 * penalyzed log-likelihood (ICLc): -80493.2\n", - "\n" - ] - } - ], - "source": [ - "print(hsmc_est.display())" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Estimated emission distribution (state 0)" - ] - }, - { - "cell_type": "code", - "execution_count": 43, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAA1UAAAORCAYAAAAahohkAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy80BEi2AAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOzdd3wT9f8H8FeaNulOB3TZ0oLsIVOgZc+CIvhFBAULfEHGF2UPQUQqKgjKEhQBkSLTwdAfYtl7lkJRpBSohTJayijdM/n8/og5mybpblPo6/l45EFz97m7913CXd73GScTQggQERERERFRiViYOwAiIiIiIqKnGZMqIiIiIiKiUmBSRUREREREVApMqoiIiIiIiEqBSRUREREREVEpMKkiIiIiIiIqBSZVREREREREpcCkioiIiIiIqBSYVBEREREREZUCkyoiqrL8/PywbNkyc4dRZo4cOQKZTIYnT55U+LY7d+6MSZMmSe/L69gOHz4cr776qsntlue2ysvVq1fRtm1bWFtbo1mzZuW+PSIiKntMqojomXP79m2MHDkSXl5eUCgU8PX1xcSJE/Ho0SNzh1ZmjCUTAQEBiIuLg0qlMk9QeYSFhWH06NFFKlucBGz58uUICQkpeWBG3Lx5EzKZDBEREeW+LWPmzp0LOzs7REVF4eDBg+W+PZ2QkBA4OTkVe7myTN6FEAgODoaXlxdsbGzQuXNn/PXXX6VeLxFRRWNSRUTPlL///hutWrXCtWvXsHXrVty4cQPffPMNDh48CH9/fzx+/NhssanVamg0mnJbv0KhgIeHB2QyWblto6iqV68OW1vbMluf7tipVKoSJQIlUVHbio6ORvv27eHr6wtXV9cSrSM7O7uMo6oYixYtwpIlS7By5UqEhYXBw8MDPXr0QEpKirlDIyIqFiZVRPRMeeedd6BQKLBv3z506tQJNWrUQO/evXHgwAHcvXsXs2fP1iufkpKCwYMHw97eHl5eXlixYoXe/ODgYNSoUQNKpRJeXl6YMGGCNC87OxszZszAc889Bzs7O7Rp0wZHjhyR5utqAnbv3o2GDRtCqVRi7dq1sLa2NrjLP2HCBHTq1AkA8OjRI7z55pvw9vaGra0tmjRpgq1bt0plhw8fjqNHj2L58uWQyWSQyWS4efOm0RqE7du3o1GjRlAqlfDz88PixYv1tuvn54f58+djxIgRcHBwQI0aNbBmzZoCj3FaWhqGDh0Ke3t7eHp6GqxTt968tU+mjmPnzp1x69YtTJ48WdoXU8fu1q1bRpvk5ebm4t1334WTkxNcXV3xwQcfQAghzZfJZNi1a5feMk5OTlItVM2aNQEAzZs3h0wmQ+fOnaXjnHdbWVlZmDBhAtzc3GBtbY327dsjLCxMmq87/gcPHkSrVq1ga2uLgIAAREVFmTyWMpkM4eHhmDdvHmQyGYKDgwEAf/75J7p27QobGxu4urpi9OjRSE1NlZbTxbZgwQJ4eXmhbt26Rtd/6dIldOnSBQ4ODnB0dETLli1x/vx5HDlyBP/973+RlJQkHXfdtjdt2oRWrVrBwcEBHh4eGDx4MBISEgBoa/W6dOkCAHB2doZMJsPw4cMBaGudFi1ahFq1asHGxgZNmzbFzz//bHLfhRBYtmwZZs+ejf79+6Nx48bYsGED0tPTsWXLFpPLERFVSoKI6Bnx6NEjIZPJxPz5843OHzVqlHB2dhYajUYIIYSvr69wcHAQCxYsEFFRUeLLL78Ucrlc7Nu3TwghxE8//SQcHR3Fnj17xK1bt8TZs2fFmjVrpPUNHjxYBAQEiGPHjokbN26Izz//XCiVSnHt2jUhhBDr168XVlZWIiAgQJw8eVJcvXpVpKamCnd3d/Htt99K68nNzRXu7u5i9erVQggh7ty5Iz7//HNx8eJFER0dLcV15swZIYQQT548Ef7+/mLUqFEiLi5OxMXFidzcXHH48GEBQCQmJgohhDh//rywsLAQ8+bNE1FRUWL9+vXCxsZGrF+/Xtq2r6+vcHFxEV999ZW4fv26WLBggbCwsBCRkZEmj/P//vc/4e3tLfbt2yf++OMP0adPH2Fvby8mTpyot96lS5cWehwfPXokvL29xbx586R9KejYDRs2TPTr10/aTqdOnaRtX716VWzatEnY2trqfU4AxM6dO/X2QaVSScfh3LlzAoA4cOCAiIuLE48ePRJCCINtTZgwQXh5eYk9e/aIv/76SwwbNkw4OztL5XXHv02bNuLIkSPir7/+Eh06dBABAQEmj2VcXJxo1KiRmDp1qoiLixMpKSkiLS1NeHl5if79+4s///xTHDx4UNSsWVMMGzZMWm7YsGHC3t5eBAUFicuXL4s///zT6PobNWok3nrrLREZGSmuXbsmfvzxRxERESGysrLEsmXLhKOjo3TcU1JShBBCrFu3TuzZs0dER0eL06dPi7Zt24revXsLIbTf1e3btwsAIioqSsTFxYknT54IIYR4//33Rf369UVoaKiIjo4W69evF0qlUhw5csRobNHR0QKAuHDhgt70vn37iqFDh5o8ZkRElRGTKiJ6Zpw5c8boD2idJUuWCADi/v37QgjtD/9evXrplRk0aJD0A3Lx4sWibt26Ijs722BdN27cEDKZTNy9e1dverdu3cSsWbOEENrEAICIiIjQKzNhwgTRtWtX6f3evXuFQqEQjx8/NrlvL730kpg6dar0vlOnTnpJjBDCIKkaPHiw6NGjh16Z6dOni4YNG0rvfX19xVtvvSW912g0ws3NTaxatcpoHCkpKUKhUIht27ZJ0x49eiRsbGxMJlUFHcf8ZXVMHTtjSVWDBg2kRFkIId577z3RoEED6X1hSVVMTIwAIC5evGhyW6mpqcLKykps3rxZmp+dnS28vLzEokWLhBD/Hv8DBw5IZX777TcBQGRkZBjddyGEaNq0qZg7d670fs2aNcLZ2VmkpqbqrcfCwkLEx8dLsbm7u4usrCyT6xVCCAcHBxESEmJ03vr164VKpSpweSH+TTp1SVf+75kQ2uNjbW0tTp06pbfsyJEjxZtvvml0vSdPnhQADP4PjRo1SvTs2bPQuIiIKhM2/yOiKkP80yQsb58jf39/vTL+/v6IjIwEALz++uvIyMhArVq1MGrUKOzcuRO5ubkAgAsXLkAIgbp168Le3l56HT16FNHR0dL6FAoFXnjhBb1tDBkyBEeOHMG9e/cAAJs3b8ZLL70EZ2dnANr+Q59++ileeOEFuLq6wt7eHvv27UNsbGyx9jcyMhLt2rXTm9auXTtcv34darVampY3PplMBg8PD6m5V37R0dHIzs7WO24uLi6oV6+eyTgKOo4FMXbsjGnbtq3BZ5p/H0srOjoaOTk5esfTysoKrVu3lr4vOnlj9vT0BACTx9OYyMhING3aFHZ2dtK0du3aQaPR6DUlbNKkCRQKRYHrmjJlCt5++210794dn332md5305SLFy+iX79+8PX1hYODg9QcsqDv35UrV5CZmYkePXro/X/4/vvvC91m/j6AQohK0S+QiKg4mFQR0TOjdu3akMlkuHLlitH5V69ehbOzM6pVq1bgenQ/6Hx8fBAVFYWvvvoKNjY2GDduHDp27IicnBxoNBrI5XKEh4cjIiJCekVGRmL58uXSumxsbAx+ILZu3RrPP/88tm3bhoyMDOzcuRNvvfWWNH/x4sVYunQpZsyYgUOHDiEiIgKBgYHFHozA2I9TkaevkY6VlZXB/psaUMPY8oUp6DgWxNixKwmZTGYQd2Hbzs9YQq6bnn9a3uOpm1ecAUoKSiryTs+bdJkSHByMv/76Cy+//DIOHTqEhg0bYufOnSbLp6WloWfPnrC3t8emTZsQFhYmlS/o+6fbv99++03v/8OVK1dM9qvy8PAAAMTHx+tNT0hIgLu7e6H7RkRUmTCpIqJnhqurK3r06IGvv/4aGRkZevPi4+OxefNmDBo0SO+H6ZkzZ/TKnTlzBvXr15fe29jYoG/fvvjyyy9x5MgRnD59Gn/++SeaN28OtVqNhIQE1K5dW++l+7FYkMGDB2Pz5s34v//7P1hYWODll1+W5h0/fhz9+vXDW2+9haZNm6JWrVq4fv263vIKhaLQmpiGDRvixIkTetNOnTqFunXrQi6XFxqjMbVr14aVlZXecUtMTMS1a9cKXM7UcSzqvhTE2GdYp04daR+rV6+OuLg4af7169eRnp4uvdfV9hQUQ+3ataFQKPSOZ05ODs6fP48GDRqUOHZjGjZsiIiICKSlpUnTTp48CQsLC5MDUhSkbt26mDx5Mvbt24f+/ftj/fr1AIwf96tXr+Lhw4f47LPP0KFDB9SvX9+gls3Y8dINJhIbG2vw/8HHx8doXDVr1oSHhwf2798vTcvOzsbRo0cREBBQ7P0kIjInJlVE9ExZuXIlsrKyEBgYiGPHjuH27dsIDQ1Fjx498Nxzz+HTTz/VK3/y5EksWrQI165dw1dffYWffvoJEydOBKAdgW7dunW4fPky/v77b2zcuBE2Njbw9fVF3bp1MWTIEAwdOhQ7duxATEwMwsLCsHDhQuzZs6fQOIcMGYILFy7g008/xYABA2BtbS3Nq127Nvbv349Tp04hMjISY8aMMbib7+fnh7Nnz+LmzZt4+PCh0ZqQqVOn4uDBg/j4449x7do1bNiwAStXrsS0adNKcmgBAPb29hg5ciSmT5+OgwcP4vLlyxg+fDgsLExfTgo6jrp9OXbsGO7evYuHDx8WO6bbt29jypQpiIqKwtatW7FixQrpMwSArl27YuXKlbhw4QLOnz+PsWPH6tUmubm5wcbGBqGhobh//z6SkpIMtmFnZ4f//e9/mD59OkJDQ3HlyhWMGjUK6enpGDlyZLFjLsiQIUNgbW2NYcOG4fLlyzh8+DDGjx+PoKCgYtXgZGRk4N1338WRI0dw69YtnDx5EmFhYVIS6Ofnh9TUVBw8eBAPHz5Eeno6atSoAYVCgRUrVuDvv//Gr7/+io8//lhvvb6+vpDJZNi9ezcePHiA1NRUODg4YNq0aZg8eTI2bNiA6OhoXLx4EV999RU2bNhgND6ZTIZJkyZh/vz52Llzp/RdsrW1xeDBg0t+AImIzMFcnbmIiMrLzZs3xfDhw4WHh4ewsrISPj4+Yvz48eLhw4d65Xx9fcVHH30kBg4cKGxtbYW7u7tYtmyZNH/nzp2iTZs2wtHRUdjZ2Ym2bdvqDUKQnZ0tPvzwQ+Hn5yesrKyEh4eH+M9//iP++OMPIUThAwG8+OKLAoA4dOiQ3vRHjx6Jfv36CXt7e+Hm5iY++OADMXToUL0BGqKiokTbtm2FjY2NACBiYmKMDiDw888/i4YNGworKytRo0YN8fnnnxscg/yDROQfOCG/lJQU8dZbb0nHbNGiRQYDZ+Rdb2HH8fTp0+KFF14QSqVS6C5Lpo6dsYEqxo0bJ8aOHSscHR2Fs7OzmDlzpt7AFXfv3hU9e/YUdnZ2ok6dOmLPnj16A1UIIcTatWuFj4+PsLCwEJ06dTK6rYyMDDF+/HhRrVo1oVQqRbt27cS5c+ek+caO/8WLF6XPxxRjx/uPP/4QXbp0EdbW1sLFxUWMGjVKGijCWGzGZGVliTfeeEP4+PgIhUIhvLy8xLvvvqs3aMbYsWOFq6urACDFsGXLFuHn5yeUSqXw9/cXv/76q8FAHvPmzRMeHh5CJpNJoxJqNBqxfPlyUa9ePWFlZSWqV68uAgMDxdGjR03GqNFoxNy5c4WHh4dQKpWiY8eOJkcyJCKqzGRClKCBPBEREREREQFg8z8iIiIiIqJSYVJFRERERERUCkyqiIiIiIiISoFJFRERERERUSkwqSIiIiIiIioFJlVERERERESlwKSKiIiIiIioFJhUERERERERlQKTKiIiIiIiolJgUkVERERERFQKTKqIiIiIiIhKgUkVERERERFRKTCpIiIiIiIiKgUmVURERERERKXApIqIiIiIiKgUmFQRERERERGVApMqIiIiIiKiUmBSRUREREREVApMqoiIiIiIiEqBSRUREREREVEpMKkiIiIiIiIqBSZVREREREREpcCkioiIiIiIqBSYVBEREREREZUCkyoiIiIiIqJSYFJFRERERERUCkyqiIiIiIiISoFJFRERERERUSkwqSIiIiIiIioFJlVERERERESlwKSKiIiIiIioFJhUERERERERlQKTKiIiIiIiolJgUkVERERERFQKTKqIiIiIiIhKgUkVERERERFRKTCpIiIiIiIiKgUmVURERERERKXApIqIiIiIiKgUmFQRERERERGVApMqIiIiIiKiUmBSRUREREREVApMqoiIiIiIiEqBSRUREREREVEpMKkiIiIiIiIqBSZVREREREREpcCkioiIiIiIqBSYVBEREREREZUCkyoiIiIiIqJSYFJFRERERERUCkyqiIiIiIiISoFJFRERERERUSkwqSIiIiIiIioFJlVERERERESlwKSKiIiIiIioFJhUERERERERlQKTKiIiIiIiolJgUkVERERERFQKTKqIiIiIiIhKgUkVERERERFRKTCpIiIiIiIiKgUmVURERERERKXApIqIiIiIiKgUmFQRERERERGVApMqIiIiIiKiUmBSRUREREREVApMqoiIiIiIiEqBSRUREREREVEpMKkiIiIiIiIqBSZVREREREREpcCkioiIiIiIqBSYVBEREREREZUCkyoiIiIiIqJSYFJFRERERERUCkyqiIiIiIiISoFJFRERERERUSkwqSIiIiIiIioFJlVERERERESlwKSKiIiIiIioFJhUERERERERlQKTKiIiIiIiolJgUkVERERERFQKTKqIiIiIiIhKgUkVERERERFRKTCpIiIiIiIiKgUmVURERERERKVgae4AyotGo5H+lslkZoyEiKhqEUJIf1tY8N5dXhqNBvfu3YODgwOvTUREFUgIgZSUFHh5eZXLtemZTaoAIDMz09whEBFVWdbW1uYOodK5d+8efHx8zB0GEVGVdfv2bXh7e5f5ep/ppArQXtR5N5CIqOIIIXhTywQHBwcA2ou6o6OjmaMhIqo6kpOT4ePjI52Hy9ozm1TpEimZTMakiojIDHjuNaQ7Jo6OjkyqiIjMoLyuTWzsTkREREREVApMqoiIiIiIiEqBSRUREREREVEpPLN9qkhLrVYjJyfH3GEQ0TPGysoKcrnc3GE8tTQaDQfzICIqQ+a+LjGpekYJIRAfH48nT56YOxQiekY5OTnBw8ODA1IUgxACI0aMwN27d/kMLyKiMmbO6xKTqmeULqFyc3ODra0tf/QQUZkRQiA9PR0JCQkAAE9PTzNH9PRITEzEm2++CTc3N9jb2/PcTERUBirDdYlJ1TNIrVZLCZWrq6u5wyGiZ5CNjQ0AICEhAW5ubmwKWARqtRppaWlwcnKCi4sLjxkRURky93WJbQ+eQbo+VLa2tmaOhIieZbpzDPttFg2PExFR+TLndYlJ1TOMzUqIqDzxHENERJWJOa9LTKqIiIiIiIhKgUkVERERERFRKTCpokqtc+fOmDRpkvTez88Py5YtK/PtDB8+HK+++qrJ7ZbntiqDjh07YsuWLeYOgyqJadOmYcKECeYOgwqg1qhx5OYRbP1zK47cPAK1Rm3ukMzi5s2bkMlkiIiIqBTrKczVq1fRtm1bWFtbo1mzZuW6rWeNTCbDrl27AJTv55X/d0be7Zb3tsrLrl27ULt2bcjl8nL7bVNU5fn7ytyYVNFTJSwsDKNHjy5S2eKcrJYvX46QkJCSB2aEqZN+eWzLGJlMJr0sLS1Ro0YNTJkyBVlZWXrldu/ejfj4eLzxxht6cRt7/fTTT3rL/vbbb2jTpg1sbGxQrVo19O/fv1gxxsXFYfDgwahXrx4sLCxMnmi3b9+Ohg0bQqlUomHDhti5c6dBma+//ho1a9aEtbU1WrZsiePHjxcrFkA73HVQUBBUKhVUKhWCgoIKfdZbamoq3n33XXh7e8PGxgYNGjTAqlWrjJYVQqB3794FXqSzsrLQrFkzo9+dsLAwdOvWDU5OTnB2dkbPnj31ykRFRaFLly5wd3eHtbU1atWqhQ8++MCgw+5XX32FBg0awMbGBvXq1cP333+vN3/GjBlYv349YmJiCtx3Mo8dkTvgt9wPXTZ0weAdg9FlQxf4LffDjsgd5g7tqWDsxpaPjw/i4uLQuHHjct323LlzYWdnh6ioKBw8eLBct/UsK87nVdwErDi/M4oqJCQETk5OFbItY8aMGYMBAwbg9u3b+Pjjj8t9ewBw5MgRyGQyg2vojh07KiyGisakip4q1atXL9NRDdVqNTQaDVQqldETXnmoyG2tX78ecXFxiImJwddff42NGzfik08+0Svz5Zdf4r///a/0IFLdxSrv66OPPoKdnR169+4tLbd9+3YEBQXhv//9Ly5duoSTJ09i8ODBxYovKysL1atXx+zZs9G0aVOjZU6fPo1BgwYhKCgIly5dQlBQEAYOHIizZ89KZX744QdMmjQJs2fPxsWLF9GhQwf07t0bsbGxxYpn8ODBiIiIQGhoKEJDQxEREYGgoKACl5k8eTJCQ0OxadMmREZGYvLkyRg/fjx++eUXg7LLli0rtBPtjBkz4OXlZTA9JSUFgYGBqFGjBs6ePYsTJ07A0dERgYGBUtJkZWWFoUOHYt++fYiKisKyZcuwdu1azJ07V1rPqlWrMGvWLAQHB+Ovv/7CRx99hHfeeQf/93//J5Vxc3NDz5498c033xQYK1W8HZE7MODHAbiTfEdv+t3kuxjw4wAmViUkl8vh4eEBS8vyfdJMdHQ02rdvD19fX5OPPOEokYUrj88rOzsbQNn/zihIRWwrNTUVCQkJCAwMhJeXFxwcHMp1e4VxcXExewzlRjyjNBqNSEtLExqNxtyhVLiMjAxx5coVkZGRYe5QiiU1NVUEBQUJOzs74eHhIb744gvRqVMnMXHiRKmMr6+vWLp0qfR+7ty5wsfHRygUCuHp6SnGjx8vhBCiU6dOAoDeSwgh1q9fL1Qqlfi///s/0aBBAyGXy8Xff/8thg0bJvr16yett1OnTuKdd94R77zzjlCpVMLFxUXMnj1b7/sEQOzcuVNvH1QqlVi/fr00P++rU6dOQghhsK3MzEwxfvx4Ub16daFUKkW7du3EuXPnpPmHDx8WAMSBAwdEy5YthY2NjfD39xdXr14t8Hgai2/EiBHipZdekt4/ePBAyGQycfny5QLX1axZMzFixAjpfU5OjnjuuefEt99+W+ByxZH/s9YZOHCg6NWrl960wMBA8cYbb0jvW7duLcaOHatXpn79+mLmzJlF3v6VK1cEAHHmzBlp2unTpwWAAo91o0aNxLx58/SmtWjRQnzwwQd60yIiIoS3t7eIi4sz+tkIIcSePXtE/fr1xV9//SUAiIsXL0rzwsLCBAARGxsrTfvjjz8EAHHjxg2T8U2ePFm0b99eeu/v7y+mTZumV2bixImiXbt2etNCQkKEj4+PyfUKYfpcU5XPvwXJyMgQly9fFmFhYSI3N7fYy+eqc4X3Em+BYBh9yYJlwmeJj8hVF3/dhVGr1eKzzz4Tzz//vFAoFMLHx0d88sknQoh/z1GJiYlS+YsXLwoAIiYmRgihf+6tW7eusLGxEa+99ppITU0VISEhwtfXVzg5OYl3331X79gUdp6NiYnR+7+Sm5srRowYIfz8/IS1tbWoW7euWLZsmbTs3LlzDc7Nhw8f1luPWq0Wzz33nFi1apXedsPDwwUAER0dLYQQ4smTJ2LUqFGievXqwsHBQXTp0kVERESYPIb5tzt37lxpuz/88IPo1KmTUCqV4rvvvhNCCPHdd9+J+vXrC6VSKerVqye++uorvfWdPXtWNGvWTCiVStGyZUuxY8cOvWOhO+Z57dy5U7oe6vz666+iRYsWQqlUipo1a4rg4GCRk5OjF/fatWvFq6++KmxsbETt2rXFL7/8oreOy5cvi5deekk4ODgIe3t70b59e3Hjxg1x9OhRYWlpKeLi4vTKT5kyRXTo0MHksbp27Zro0KGDUCqVokGDBmLfvn1634X8n/vjx4/F4MGDRbVq1YS1tbWoXbu2dBwLuxbPnz9feHp6Cl9fXyGE4e8MAOLrr78WvXr1EtbW1sLPz0/8+OOP0vzCvv+6+fk/e2PbunXrlujbt6+ws7MTDg4O4vXXXxfx8fHS/Llz54qmTZuK77//Xvj6+gpHR0cxaNAgkZycbPQ4Gtv24cOHpfXktXTpUukY5D0+n3/+ufDw8BAuLi5i3LhxIjs7WyqTmZkppk+fLry9vYVCoRC1a9cW3377rfT55H0NGzZMCGF4rX/8+LEICgoSTk5OwsbGRvTq1Utcu3ZNmq/7HoeGhor69esLOzs7ERgYKO7du2d0nwv6DZyUlCQAiKSkJKPLlhYf/lvFxKXEIS41rkK25WnvCU+Hoj/Revr06Th8+DB27twJDw8PvP/++wgPDzfZ7vznn3/G0qVLsW3bNjRq1Ajx8fG4dOkSAG31ctOmTTF69GiMGjVKb7n09HQsWLAA3377LVxdXeHm5mZ0/Rs2bMDIkSNx9uxZnD9/HqNHj4avr6/B+kw5d+4cWrdujQMHDqBRo0ZQKBRGy82YMQPbt2/Hhg0b4Ovri0WLFiEwMBA3btyAi4uLVG727NlYvHgxqlevjrFjx2LEiBE4efJkkWIBgGvXruHw4cMYPny4NO3EiROwtbVFgwYNTC4XHh6OiIgIfPXVV9K0Cxcu4O7du7CwsEDz5s0RHx+PZs2a4YsvvkCjRo2KHFNRnD59GpMnT9abFhgYKDXtzM7ORnh4OGbOnKlXpmfPnjh16lSxtqNSqdCmTRtpWtu2baFSqXDq1CnUq1fP6HLt27fHr7/+ihEjRsDLywtHjhzBtWvXsHz5cqlMeno63nzzTaxcuRIeHh5G13P//n2MGjUKu3btMnrnsl69eqhWrRrWrVuH999/H2q1GuvWrUOjRo3g6+trdJ03btxAaGioXrPMrKwsWFtb65WzsbHBuXPnkJOTAysrKwBA69atcfv2bdy6dcvk+qlspOek4+rDq4WWO3/vvEENVV4CAreTb2PdxXVo5dWqwHXVr1YftlZFv0M+a9YsrF27FkuXLkX79u0RFxeHq1cLjzmv9PR0fPnll9i2bRtSUlLQv39/9O/fH05OTtizZw/+/vtvvPbaa2jfvj0GDRpUrHXraDQaeHt748cff0S1atVw6tQpjB49Gp6enhg4cCCmTZuGyMhIJCcnY/369QC0d87v3bsnrcPCwgJvvPEGNm/ejLFjx0rTt2zZAn9/f9SqVQtCCLz88stwcXHBnj17oFKpsHr1anTr1g3Xrl3TO3frxMXFoXv37ujVqxemTZsGe3t7PHz4EADw3nvvYfHixVi/fj2USqVUw7xy5Uo0b94cFy9exKhRo2BnZ4dhw4YhLS0Nffr0QdeuXbFp0ybExMRg4sSJxT5ee/fuxVtvvYUvv/wSHTp0QHR0tNQcLW8N90cffYRFixbh888/x4oVKzBkyBDcunULLi4uuHv3Ljp27IjOnTvj0KFDcHR0xMmTJ5Gbm4uOHTuiVq1a2LhxI6ZPnw4AyM3NxaZNm/DZZ5+Z/Az79++PatWq4cyZM0hOTi60D86cOXNw5coV/P7776hWrRpu3LiBjIwMAAVfiw8ePAhHR0fs378fQogC1//ZZ59h+fLl2LhxI9588000bty4wGunTkBAAJYtW4YPP/wQUVFRAAB7e3uDckIIvPrqq7Czs8PRo0eRm5uLcePGYdCgQThy5IhULjo6Grt27cLu3buRmJiIgQMH4rPPPsOnn35qdNtRUVGoV68etm/fjoCAALi4uOitryCHDx+Gp6cnDh8+jBs3bmDQoEFo1qyZ9Dto6NChOH36NL788ks0bdoUMTExePjwIXx8fLB9+3a89tpriIqKgqOjo/Rg3vyGDx+O69ev49dff4WjoyPee+89vPTSS7hy5Yp0PUpPT8cXX3yBjRs3wsLCAm+99RamTZuGzZs3F2k/KgqTqipmdfhqfHT0owrZ1txOcxHcObhIZVNTU7Fu3Tp8//336NGjBwBtUuPt7W1ymdjYWHh4eKB79+6wsrJCjRo10Lp1awDai6RcLoeDg4PBj9icnBx8/fXXJpub6fj4+GDp0qWQyWSoV68e/vzzTyxdurTISVX16tUBAK6uriZ/SKelpWHVqlUICQmRmtatXbsW+/fvx7p166SLEAB8+umn6NSpEwBg5syZePnll5GZmWnwAzmvN998E3K5HLm5ucjKykKfPn0wa9Ysaf7Nmzfh7u4uNf0zZt26dWjQoAECAgKkaX///TcAIDg4GEuWLIGfnx8WL16MTp06mfxBUVLx8fFwd3fXm+bu7o74+HgAwMOHD6FWqwssU9TtGEuw3dzcClzPl19+iVGjRsHb2xuWlpawsLDAt99+i/bt20tlJk+ejICAAPTr18/oOoQQGD58OMaOHYtWrVrh5s2bBmUcHBxw5MgR9OvXT2qPXrduXezdu9egCUxAQAAuXLiArKwsjB49GvPmzZPmBQYG4ttvv8Wrr76KFi1aIDw8HN999x1ycnLw8OFDeHpqb4Q899xzALTfESZV5evqw6touaZlma1vzO4xhZYJHx2OFp4tirS+lJQULF++HCtXrsSwYcMAAM8//7zed7wocnJysGrVKjz//PMAgAEDBmDjxo24f/8+7O3t0bBhQ3Tp0gWHDx8ucVJlZWWFjz769xpXs2ZNnDp1Cj/++CMGDhwIe3t72NjYICsry+R5GQCGDBmCJUuWSDcVNBoNtm3bhvfffx+A9sfmn3/+iYSEBCiVSgDAF198gV27duHnn3822k9G11zN3t5e2rYuqZo0aZLezY+PP/4YixcvlqbVrFkTV65cwerVqzFs2DBs3rwZarUa3333HWxtbdGoUSPcuXMH//vf/4p1vD799FPMnDlT+lxr1aqFjz/+GDNmzNBLqoYPH44333wTADB//nysWLEC586dQ69evfDVV19BpVJh27Zt0o/gunXrSsuOHDkS69evl65nv/32G9LT0zFw4ECjMR04cACRkZG4efOm9Btg/vz5es3P84uNjUXz5s3RqpX2ZoKfn580r6BrsZ2dHb799luTNz11Xn/9dbz99tsAtJ/N/v37sWLFCnz99dcFLgcACoUCKpUKMpmswO/cgQMH8McffyAmJgY+Pj4AgI0bN6JRo0YICwvDiy++CECbdIaEhEhN6IKCgnDw4EGjSZVCoZCuay4uLgVu3xhnZ2esXLkScrkc9evXx8svv4yDBw9i1KhRuHbtGn788Ufs378f3bt3B6D9/ujofge4ubmZ7PKgS6ZOnjwp/cbYvHkzfHx8sGvXLrz++usAtOeOb775Rjp3vPvuu3rXtcqCSVUVM6blGPSt17dCtuVpX/RaqujoaGRnZ8Pf31+a5uLiYrJ2ANCe5JYtW4ZatWqhV69eeOmll/DKK68U2sZaoVDghRdeKDSmtm3b6vV/8ff3x+LFi6FWqyGXy4uwV4WLjo5GTk4O2rVrJ02zsrJC69atERkZqVc2b8y6H74JCQmoUaOGyfUvXboU3bt3h1qtxo0bNzBlyhQEBQVh27ZtAICMjIwCk7KMjAxs2bIFc+bM0Zuu0WgAaGvPXnvtNQDa/lve3t746aefMGZM4T/qiiN/PyQhhMG0opQp7naKsp4vv/wSZ86cwa+//gpfX18cO3YM48aNg6enJ7p3745ff/0Vhw4dwsWLF02uY8WKFUhOTtZLePPLyMjAiBEj0K5dO2zduhVqtRpffPEFXnrpJYSFhendBfzhhx+QkpKCS5cuYfr06fjiiy8wY8YMANo7rvHx8Wjbti2EEHB3d8fw4cOxaNEive+1bn3p6emmDxiVifrV6iN8dHih5c7fO1+khGl1n9VFqqkqqsjISGRlZaFbt25FXsYYW1tb6UcRoL3x4efnp3fX3t3dHQkJCaXazjfffINvv/0Wt27dQkZGBrKzs4s90l7z5s1Rv359bN26FTNnzsTRo0eRkJAgJQLh4eFITU016BeVkZGB6OjoYsesSwYA4MGDB7h9+zZGjhypdxMvNzcXKpUKgPYzadq0qV6tdt7rZ1GFh4cjLCxM7we5Wq1GZmYm0tPTpfXnvf7Y2dnBwcFB+pwiIiLQoUMHKaHKb/jw4fjggw9w5swZtG3bFt999x0GDhwIOzs7o+UjIyNRo0YNvZuqhe3b//73P7z22mu4cOECevbsiVdffVXvRqApTZo0KTShMrZ9f3//Mh95MDIyEj4+PlJCBQANGzaEk5MTIiMjpaTKz89Pr0+Sp6dnqf/PmNKoUSO964Knpyf+/PNPANrPXS6XSzd7SyIyMhKWlpZ6LURcXV1Rr149vd9A+c8d5bnPpcGkqorxdChek7yKUlC1uyk+Pj6IiorC/v37ceDAAYwbNw6ff/45jh49avLkDmh/LJbFE7dlMplB3MXtYKxbvigJQd590s3TJTemeHh4oHbt2gC0zcdSUlLw5ptv4pNPPkHt2rVRrVo1JCYmmlz+559/Rnp6OoYOHao3XZfUNWzYUJqmVCpRq1atYg8OURgPDw+DmqKEhASpZqpatWqQy+UFlinqdu7fv28w/cGDBybXk5GRgffffx87d+7Eyy+/DED74yMiIgJffPEFunfvjkOHDiE6OtrgTt1rr72GDh064MiRIzh06BDOnDkj3fHWadWqFYYMGYINGzZgy5YtuHnzJk6fPi3VLG7ZsgXOzs745ZdfpNEbAUgX5YYNG0KtVmP06NGYOnUq5HI5bGxs8N1332H16tW4f/8+PD09sWbNGjg4OKBatWrSOh4/fgzg37u8VH5srWyLVGvU1L0pPj72Me4m34WA4TlTBhm8Hb0xsvlIyC3K5sYPAJPNdnR038e850Nj58L852WZTGZ0Wt7zWnHPsz/++CMmT56MxYsXw9/fHw4ODvj888/1BrYpqiFDhmDLli2YOXMmtmzZgsDAQOn/iEajgaenp9FmVCUZiChvgqHb/7Vr1+r92AQg/cAtyjXTwsKi0GOn0Wjw0UcfGR25Ne8Nt4I+p8K+H25ubnjllVewfv161KpVC3v27Cmw+ZmxfSvsmt27d2/cunULv/32Gw4cOIBu3brhnXfewRdffFHgcqYSu6LQxVTU739hTN3Ayz+9sP8zRVGU70Zh2yrscy8KU9/jouxzSX43ljeO/keVQu3atWFlZYUzZ85I0xITE3Ht2rUCl7OxsUHfvn3x5Zdf4siRIzh9+rR0F0WhUECtLvmzW/LGontfp04d6aJWvXp1xMX92z/t+vXrenf1dXe/Coqhdu3aUCgUOHHihDQtJycH58+fL1Jb7eLSxa5ra67rD2UqsVq3bh369u1r8MO6ZcuWUCqVUvtwXdzl0VTM398f+/fv15u2b98+6S6kQqFAy5YtDcrs37+/SHcq824nKSkJ586dk6adPXsWSUlJJteTk5ODnJwcg+aTcrlcuvDMnDkTf/zxByIiIqQXoK1F1PXp+PLLL3Hp0iVp/p49ewBoa5x0d5DT09NhYWGhd6HRvS/ogiqEQE5OjsEFyMrKCt7e3pDL5di2bRv69Omjtx+XL1+GlZVVmfeRo5KTW8ixvJe2r54M+Wpq/3m/rNeyMk2oAKBOnTqwsbExOQS47vyQ93xYVnfxCzvP5nf8+HEEBARg3LhxaN68OWrXrm1Qc1TUa8PgwYPx559/Ijw8HD///DOGDBkizWvRogXi4+NhaWmJ2rVr673y3pwoCXd3dzz33HP4+++/DdZds2ZNANobJpcuXZLO5YDhNat69epISUlBWlqaNC3/59KiRQtERUUZbKd27doFNgvP64UXXsDx48cLTCTefvttbNu2DatXr8bzzz+v1zojv4YNGyI2Nlavn9vp06cLjaN69eoYPnw4Nm3ahGXLlmHNmjUAinYtLoyx3wP169eXtgsU/P0vyndOt9+3b9+Wpl25cgVJSUll/nugevXqiI+P17suFPf/bJMmTaDRaHD06FGj84ty3Bs2bIjc3Fy9mx6PHj3CtWvXyuU3UHljTRVVCvb29hg5ciSmT58OV1dXuLu7Y/bs2QWe1ENCQqBWq9GmTRvY2tpi48aNsLGxkX7U+/n54dixY3jjjTegVCqLfaG7ffs2pkyZgjFjxuDChQtYsWIFFi9eLM3v2rUrVq5cibZt20Kj0eC9997Tu5vi5uYGGxsbhIaGwtvbG9bW1lLTDR07Ozv873//w/Tp0+Hi4oIaNWpg0aJFSE9Px8iRI4sVrzFPnjxBfHw8NBoNrl+/jnnz5qFu3brSyap58+aoXr06Tp48iT59+ugte+PGDRw7dkz6gZ+Xo6Mjxo4di7lz58LHxwe+vr74/PPPAUBqA11UuhN5amoqHjx4gIiICCgUCqkWbOLEiejYsSMWLlyIfv364ZdffsGBAwf0ElFds8ZWrVrB398fa9asQWxsrF4n88I0aNAAvXr1wqhRo7B69WoAwOjRo9GnTx+9Zqj169fHggUL8J///AeOjo7o1KkTpk+fLn33jh49iu+//x5LliwBoK0BM9aOvUaNGtIPpPxNOHXNoZ5//nmpCUyPHj0wffp0vPPOOxg/fjw0Gg0+++wzWFpaokuXLgC0bdGtrKzQpEkTKJVKhIeHY9asWRg0aJDULPbatWs4d+4c2rRpg8TERCxZsgSXL1/Ghg0b9GI4fvw4OnToUCZ3I6ns9G/QHz8P/BkTQyfqDVrh7eiNZb2WoX+D4j0rriisra3x3nvvYcaMGVAoFGjXrh0ePHiAv/76CyNHjkTt2rXh4+OD4OBgfPLJJ7h+/breubI0CjvP5le7dm18//332Lt3L2rWrImNGzciLCxM+r8GaK8Ne/fuRVRUFFxdXQ3Oyzo1a9ZEQEAARo4cidzcXL0+kd27d4e/vz9effVVLFy4EPXq1cO9e/ewZ88evPrqq3rN+UoiODgYEyZMgKOjI3r37o2srCycP38eiYmJmDJlCgYPHozZs2dj5MiR+OCDD3Dz5k2DWhndtfH999/H+PHjce7cOYNnJH744Yfo06cPfHx88Prrr8PCwgJ//PEH/vzzT4PHb5jy7rvvYsWKFXjjjTcwa9YsqFQqnDlzBq1bt5bOnYGBgVCpVPjkk08K7QvTvXt31KtXD0OHDsXixYuRnJyM2bNnF7jMhx9+iJYtW6JRo0bIysrC7t27petcUa7Fhfnpp5/QqlUrtG/fHps3b8a5c+ewbt06ACjS99/Pzw+pqak4ePCg1Gwz/4BE3bt3xwsvvIAhQ4Zg2bJl0kAVnTp1KvX3Kb/OnTvjwYMHWLRoEQYMGIDQ0FD8/vvvcHR0LPI6/Pz8MGzYMIwYMUIaqOLWrVtSM1lfX1/IZDLs3r0bL730EmxsbAwG6KhTpw769esnXXcdHBwwc+ZMPPfccyb7IFdq5TKmYCVQlYf0fVqHVE9JSRFvvfWWsLW1Fe7u7mLRokUFDqm+c+dO0aZNG+Ho6Cjs7OxE27ZtxYEDB6Syp0+fFi+88IJQKpUGQ6rnZ2xI9XHjxomxY8cKR0dH4ezsLGbOnKn3fbp7967o2bOnsLOzE3Xq1BF79uzRG+pXCCHWrl0rfHx8hIWFhckh1TMyMsT48eNFtWrVChxSvaDhio1BnqFMZTKZ8PT0FIMGDZKGA9aZOXOm3vDkOrNmzRLe3t5CrVYbXX92draYOnWqcHNzEw4ODqJ79+4GQ7P7+vpKQ8cWJU7dK++wrkII8dNPP4l69eoJKysrUb9+fbF9+3aD9Xz11VfC19dXKBQK0aJFC3H06FG9+XPnzjVYb36PHj0SQ4YMEQ4ODsLBwUEMGTJE77jr4s37GcfFxYnhw4cLLy8vYW1tLerVqycWL15c4LkHJoZU18k/XLDOvn37RLt27YRKpRLOzs6ia9eu4vTp09L8bdu2iRYtWgh7e3thZ2cnGjZsKObPn693Lrhy5Ypo1qyZsLGxEY6OjqJfv35Gh4yvW7eu2Lp1q8kYheCQ6sVV2iHV88pV54rDMYfFlj+2iMMxh8tlGPW81Gq1+OSTT4Svr6+wsrISNWrUEPPnz5fmnzhxQjRp0kRYW1uLDh06iJ9++snokOp5GRvWOf/5sbDzbP7/K5mZmWL48OFCpVIJJycn8b///U/MnDlTbzsJCQmiR48ewt7e3uiQ6nl99dVXAoAYOnSowTFJTk4W48ePF15eXsLKykr4+PiIIUOG6D32IL+mTZvqnRNNbVcIITZv3iyaNWsmFAqFcHZ2Fh07dhQ7duyQ5p8+fVo0bdpUKBQK0axZM7F9+3aDde3cuVPUrl1bWFtbiz59+og1a9YYDKkeGhoqAgICpHNC69atxZo1a6T5xs5X+a91ly5dEj179hS2trbCwcFBdOjQweBaM2fOHCGXy00OhZ1XVFSUaN++vVAoFKJu3boiNDS0wCHVP/74Y9GgQQNhY2MjXFxcRL9+/cTff/8tra8o12IdY0Oqf/XVV6JHjx5CqVQKX19fg3NjYd9/IYQYO3ascHV1LZMh1fPKPxR6fomJidL3PK9Vq1YJHx8fYWdnJ4YOHSo+/fRTo0Oq5zVx4kTp+AmhPadNnjxZeHp6SkOq64ayF0KIefPmCQ8PDyGTyQodUl2lUgkbGxsRGBhodEj1vIw9GiBvTOYaUl0mRCVslFgGhBDIyMgos/4zT5PMzEzExMSgZs2aBQ5CQARoh/Ju1KgRwsPDy7TpXkZGhjTcsK4mxZx0Q8nnv1NLhn777TdMnz4df/zxR4EDv5g611Tl829BMjMzER0djYyMDDRv3rzMBrwhArQjddasWRMXL14s9sAcFWHUqFG4f/8+fv31V3OHQs+wgn4DJycnQ6VSISkpqVi1ckXF5n9EVZy7uzvWrVuH2NjYMk2qjh49iq5du1aKhArQxnPs2DFzh/FUSEtLw/r16wsdSZOIqDBJSUkICwvD5s2b8csvv5g7HKJywysmEZVL2+VevXqhV69eZb7ekoqJiTF3CE8NU8+PISIqrn79+uHcuXMYM2aM9BxKooqm1qhx/Nbxct0GR/8jIqIq6dixY3jllVfg5eUFmUyGXbt2FbrM0aNH0bJlS1hbW6NWrVr45ptvyj9QoiLw8/ODEKLSNf07cuQI0tPTsXTpUnOHQlXUjsgd8Fvuh88/7VN44VJgUkVERFVSWloamjZtipUrVxapfExMDF566SV06NABFy9exPvvv48JEyZg+/bt5RwpERGVxI7IHRjw4wDcSbqDD42P/l5m2PyPiIiqpN69e6N3795FLv/NN9+gRo0aWLZsGQDtMPznz5/HF198gddee62coiQiopJQa9SYGDoRAgI9o4FW8eW7vWLXVBWluURkZCT69u0LlUoFBwcHtG3bFrGxsdL8rKwsjB8/HtWqVYOdnR369u2LO3fu6K0jMTERQUFBUKlUUKlUCAoKwpMnT4q9g0RERGXh9OnT6Nmzp960wMBAnD9/3uSDT7OyspCcnIzk5GSkpqYW+KBmIiIqO8djj2uf5yeAjw8BJX/8c9EUO6kqrLlEdHQ02rdvj/r16+PIkSO4dOkS5syZozes4aRJk7Bz505s27YNJ06cQGpqKvr06aP31OXBgwcjIiICoaGhCA0NRUREBIKCgkqwi0RERKUXHx8Pd3d3vWnu7u7Izc3Fw4cPjS6zYMEC6eZgq1atcPfu3YoIlYioyrubrD3f9owGWt8DyvshFsVu/ldYc4nZs2fjpZdewqJFi6RptWrVkv5OSkrCunXrsHHjRnTv3h0AsGnTJvj4+ODAgQMIDAxEZGQkQkNDcebMGbRp0wYAsHbtWvj7+yMqKkp6QjcREVFFyv/cLd2jHk09j2vWrFmYMmUKACA7OxtxcXHIysoq3yCJiKq4fdH7MGnvJKmWqiLaCJTpQBUajQa//fYb6tati8DAQLi5uaFNmzZ6TQTDw8ORk5Oj14TCy8sLjRs3xqlTpwBom1ioVCopoQKAtm3bQqVSSWXyy9vEIjk5GSkpKWW5a1QBhBAYPXo0XFxcIJPJEBERYe6QnhrDhw/Hq6++Kr3v3LkzJk2aVObbCQ4O1htZKv92y3NbRObm4eGB+Hj9RvkJCQmwtLSEq6ur0WWUSiUcHR3h6OgIe3t7WFhwfKiydPPmzTK5XpTVekq73SNHjkAmk5VLd4e8XTbKe3+LOppmaa1ZswY+Pj6wsLCQ+jqai5+fn9ljIK30nHRM/H0iHqY/xHsntLVUFXHmLdNtJCQkIDU1FZ999hl69eqFffv24T//+Q/69++Po0e1Q27Ex8dDoVDA2dlZb1l3d3fpYhUfHw83NzeD9bu5uRlc0HTyNrFQqVTw9vYuy12jChAaGoqQkBDs3r0bcXFxaNy4sblDemrt2LEDH3/8cZHKFicBmzZtGg4ePFiKyIwzdgEur20RlZS/vz/279+vN23fvn1o1aoVrKyszBQVFZexm0E+Pj6V4roTEBCAuLg4qFSqQssWNwGLi4sr1sAsRWHq5ld5bCu/5ORkvPvuu3jvvfdw9+5djB49uly3pxMSEgInJyeD6WFhYRUWA5kmhMDjjMcQEIAG+OBYxW27zGuqAO2D3iZPnoxmzZph5syZ6NOnT6HP8hBC6DWfMNaUIn+ZvGbNmoWkpCTplX/gCyqhAweAhg21/5az6OhoeHp6IiAgAB4eHrC0NGydmp2dXe5xPAtcXFzg4OBQZusTQiA3Nxf29vYm78iXtYrcFlVNqampiIiIkO7Wx8TEICIiQhpYadasWRg6dKhUfuzYsbh16xamTJmCyMhIfPfdd1i3bh2mTZtmjvAr9Pz8rJPL5SavOxVJoVDAw8PD5G+dktBdNz08PKBUKstsvQWpiG3FxsYiJycHL7/8Mjw9PWFra1uu2ytM9erVzR4DaWup1BrtGA0vXwfsjY8hVC7KNKmqVq0aLC0t0bBhQ73pDRo0kC5SHh4eyM7ORmJiol6ZhIQEqQOwh4cH7t+/b7D+Bw8eGHQS1snbxMLR0bFMf1BWWUIA778PREZq//2n70B5GD58OMaPH4/Y2FjIZDL4+fkB0NaivPvuu5gyZQqqVasmPY39ypUreOmll2Bvbw93d3cEBQXpdRRPS0vD0KFDYW9vD09PTyxevNigRsZY7YiTkxNCQkKk93fv3sWgQYPg7OwMV1dX9OvXDzdv3tSL+9VXX8UXX3wBT09PuLq64p133tEbCSwrKwszZsyAj48PlEol6tSpg3Xr1kEIgdq1a+OLL77Qi+Hy5cuwsLBAdHS00WOlVqsxZcoUODk5wdXVFTNmzJD6dejk39evv/4aderUgbW1Ndzd3TFgwAAp/qNHj2L58uWQyWSQyWS4efOmdAd07969aNWqFZRKJY4fP27yruRHH30ENzc3ODo6YsyYMXrJr7EmEc2aNUNwcLA0HwD+85//6H32+bel0Wgwb948eHt7Q6lUolmzZggNDZXm65qz7NixA126dIGtrS2aNm2K06dPGz2OROfPn0fz5s3RvHlzAMCUKVPQvHlzfPjhhwC0d9vzjlxbs2ZN7NmzB0eOHEGzZs3w8ccf48svvzTPcOoVeH4GtP//Fi5ciNq1a0OpVKJGjRr49NNPARivMYmIiJDOJ8C/d/d3796NevXqwdbWFgMGDEBaWho2bNgAPz8/ODs7Y/z48XqDVhXlPJ2XWq3GyJEjUbNmTdjY2KBevXpYvny5ND84OBgbNmzAL7/8Ip3zjhw5otccTqPRwNvb2+Bm8IULFyCTyfD3338D0PYRHz16tHTu69q1Ky5dulTgcTx37hyaN28Oa2trtGrVChcvXtSbn/9Y3rp1C6+88gqcnZ1hZ2eHRo0aYc+ePbh58ya6dOkCAHB2doZMJsPw4cMBmL5uGjuWV69eRUBAAKytrdGoUSMcOXJEmmesRmbXrl1SwhcSEoKPPvoIly5dko6l7nPJv60///wTXbt2hY2NDVxdXTF69GikpqZK84tyLc0rJCQETZo0AaDtt6/7rhmrhZw0aRI6d+4sve/cuTMmTJiAGTNmwMXFBR4eHtL1SOfJkycYPXo03N3dYW1tjcaNG2P37t04cuQI/vvf/yIpKUna57zXsrzXutjYWPTr1w/29vZwdHTEwIED9X7b6q5xGzduhJ+fH1QqFd544w12XymlbPW/vz/mHgV0Z8ZcAFdcynfbZZpUKRQKvPjii4iKitKbfu3aNfj6+gIAWrZsCSsrK70mFHFxcbh8+TICAgIAaJtYJCUl4dy5c1KZs2fPIikpSSpDFWDfPiAsTPt3WJj2fTlZvny59IM5Li4OYbrtAtiwYQMsLS1x8uRJrF69GnFxcejUqROaNWuG8+fPIzQ0FPfv38fAgQOlZaZPn47Dhw9j586d2LdvH44cOYLw8PBixZSeno4uXbrA3t4ex44dw4kTJ2Bvb49evXrpJQ2HDx9GdHQ0Dh8+jA0bNiAkJETvgj906FBs27YNX375JSIjI/HNN9/A3t4eMpkMI0aMwPr16/W2+91336FDhw54/vnnjca1ePFi6Q75iRMn8PjxY+zcudPkfpw/fx4TJkzAvHnzEBUVhdDQUHTs2FE67v7+/hg1ahTi4uIQFxcHHx8fadkZM2ZgwYIFiIyMxAsvvGB0/QcPHkRkZCQOHz6MrVu3YufOnfjoo48KPb46us96/fr1Bp99XsuXL8fixYvxxRdf4I8//kBgYCD69u2L69ev65WbPXs2pk2bhoiICNStWxdvvvkmcnNzixwPVR2dO3eGEMLgpfv/GxISovcjEwA6deqECxcuICsrCzExMRg7dmzFBw5U6PkZ0NbaLVy4EHPmzMGVK1ewZcsWkzc5TUlPT8eXX36Jbdu2ITQ0FEeOHEH//v2xZ88e7NmzBxs3bsSaNWvw888/lzhOXUL0448/4sqVK/jwww/x/vvv48cffwSgbVY8cOBA9OrVSzrn5f9dYWFhgTfeeAObN2/Wm75lyxb4+/ujVq1aEELg5ZdfRnx8PPbs2YPw8HC0aNEC3bp1w+PHj43GlpaWhj59+qBevXoIDw9HcHBwobWc77zzDrKysnDs2DH8+eefWLhwIezt7eHj4yM9dDoqKgpxcXF6yWP+66Yp06dPx9SpU3Hx4kUEBASgb9++ePToUYEx6QwaNAhTp05Fo0aNpGM5aNAgg3Lp6eno1asXnJ2dERYWhp9++gkHDhzAu+++q1eusGtp/m0f+KeG9ty5cwbXrsJs2LABdnZ2OHv2LBYtWoR58+ZJv0s1Gg169+6NU6dOYdOmTbhy5Qo+++wzyOVyBAQEYNmyZXB0dJT22dhnKITAq6++isePH+Po0aPYv38/oqOjDY5PdHQ0du3ahd27d2P37t04evQoPvvssyLvBxlSyBUAgPaxwIv3AF2dryWAhsb/a5YdUUwpKSni4sWL4uLFiwKAWLJkibh48aK4deuWEEKIHTt2CCsrK7FmzRpx/fp1sWLFCiGXy8Xx48eldYwdO1Z4e3uLAwcOiAsXLoiuXbuKpk2bitzcXKlMr169xAsvvCBOnz4tTp8+LZo0aSL69OlT5Dg1Go1IS0sTGo2muLv41MvIyBBXrlwRGRkZ+jPS0oQIDy/a6/x5IRo2FMLCQghA+2/DhtrpRV1HeLh2m0W0dOlS4evrqzetU6dOolmzZnrT5syZI3r27Kk37fbt2wKAiIqKEikpKUKhUIht27ZJ8x89eiRsbGzExIkTpWkAxM6dO/XWo1KpxPr164UQQqxbt07Uq1dP7zuUlZUlbGxsxN69e4UQQgwbNkz4+vrqfXdff/11MWjQICGEEFFRUQKA2L9/v9F9vnfvnpDL5eLs2bNCCCGys7NF9erVRUhIiImjJISnp6f47LPPpPc5OTnC29tb9OvXT5rWqVMnaV+3b98uHB0dRXJystH15S2rc/jwYQFA7Nq1S2/63LlzRdOmTaX3w4YNEy4uLiItz+e8atUqYW9vL9RqtRBCCF9fX7F06VK99TRt2lTMnTtXem/ss8i/LS8vL/Hpp5/qlXnxxRfFuHHjhBBCxMTECADi22+/leb/9ddfAoCIjIw0uu9UOqbONVX5/FuQjIwMcfnyZREWFqZ3zijWubmszs/FODcnJycLpVIp1q5da3S+7nyRmJgoTdP9RoiJiRFCCLF+/XoBQNy4cUMqM2bMGGFraytSUlKkaYGBgWLMmDHS+8LO07r/9xcvXjQZ/7hx48Rrr70mvR82bJje+dLYei5cuCBkMpm4efOmEEIItVotnnvuOfHVV18JIYQ4ePCgcHR0FJmZmXrref7558Xq1auNxrF69Wqj58u8281/LJs0aSKCg4ONrs/YcRfC+HVTCP1jqdtfY9eShQsXCiG0n5lKpdJbx86dO0Xen475z9PGtrVmzRrh7OwsUlNTpfm//fabsLCwEPHx8UKIwq+lxuT/junWk/+znThxoujUqZP0vlOnTqJ9+/Z6ZV588UXx3nvvCSGE2Lt3r7CwsBBRUVFGt2vsuAihf63bt2+fkMvlIjY2Vpqvux6dO3dOCKE9dra2tnrX5unTp4s2bdqY3GcqXHp6uth3Zp84+6KvyJVBe4785/VIW3ElkpKSymXbxW48fP78eanKGYA0VOywYcMQEhKC//znP/jmm2+wYMECTJgwAfXq1cP27dvRvn17aZmlS5fC0tISAwcOREZGBrp164aQkBDI5f+OIL9582ZMmDBBGiWwb9++Jp+NRUV09SrQsmXJltVogCtXgFatirdceDjQokXJtvmPVvm2GR4ejsOHD8Pe3t6gbHR0NDIyMpCdnQ1/f39puouLS7GH4g8PD8eNGzcMmpJmZmbqNc1r1KiR3nfX09MTf/75JwBtExi5XI5OnToZ3YanpydefvllfPfdd2jdujV2796NzMxMvP7660bLJyUlIS4uTm/fLC0t0apVK4MmgDo9evSAr68vatWqhV69eqFXr174z3/+U6S23/mPvTFNmzbVW5e/vz9SU1Nx+/ZtqYa6tJKTk3Hv3j20a9dOb3q7du0MmtvkrVHz9PQEoG1eXL9+/TKJhajMlebcDJTs/FyMc3NkZCSysrLQrVu3EgaoZWtrq1cD7+7uDj8/P71zubu7OxISEkq1nW+++Qbffvstbt26JV0PijuSaPPmzVG/fn1s3boVM2fOxNGjR5GQkCC1iAgPD0dqaqpBv8+MjAyTTbcjIyONni8LMmHCBPzvf//Dvn370L17d7z22msmWw3kVZRzd/7t664lkZGRRVq2qHT7bWdnJ01r164dNBoNoqKipBrPgq6lZS3/MfT09JS+dxEREfD29kbdunVLvP7IyEj4+Pjo1Z41bNgQTk5OiIyMxIsvvghA22Qw72+MvHFQychkMlST2aNBAiDP97OovHtMFnv9uuYSBRkxYgRGjBhhcr61tTVWrFiBFStWmCzj4uKCTZs2FTc8Kkj9+toLaWGEAIYO1V7oNXlG9rew0K7j+++BonaiLYMfsnlPxIC2av6VV17BwoULDcp6enoaNAczRSaTGXyX87bf1mg0aNmypUETEEDbIVUn/6hfMplMGrTFxsam0DjefvttBAUFYenSpVi/fj0GDRpUpp1dHRwccOHCBRw5cgT79u3Dhx9+iODgYISFhRkdwSiv/Me+OHTt7i0sLAo8ziVZp44wMnhN3s9DN0+jqYgnVBCVUFHPzUDZnZ+LcW4u7DymGyY+7/9zY//HjZ0rCzp/6t4X5/zx448/YvLkyVi8eDH8/f3h4OCAzz//HGfPni1wH4wZMmQItmzZgpkzZ2LLli0IDAxEtWrVAGjPKZ6engbNQwGYPK8W9tvJmLfffhuBgYH47bffsG/fPixYsACLFy/G+PHjC1yuMp27jZ2n828LKPhaWlRFjbm01+3CmNrn/NPLYp8pHyFgnZoBUYaDvRSVeYe5oYpla1u0O5N792rveuanuxv68CEQGFj28RVRixYtsH37dvj5+Rkdqal27dqwsrLCmTNnUKNGDQBAYmIirl27pldjVL16dcTFxUnvr1+/jvT0dL3t/PDDD1In5JJo0qQJNBoNjh49Kj3sOr+XXnoJdnZ2WLVqFX7//XccO2Z6/E+VSgVPT0+cOXNG6heVm5srtec3xdLSEt27d0f37t0xd+5cODk54dChQ+jfvz8UCoVex/DiunTpEjIyMqQL0ZkzZ2Bvby891iD/cU5OTkZMTIzeOqysrAqMwdHREV5eXjhx4oS03wBw6tQptG7dusSxE1UKRT03A2Y5P9epUwc2NjY4ePAg3n77bYP5uptMcXFx0uNSyur5R4Wdp/M7fvw4AgICMG7cOGla/pqjop7zBg8ejA8++ADh4eH4+eefsWrVKmleixYtEB8fD0tLS2lwncI0bNgQGzduNDhfFsbHxwdjx47F2LFjMWvWLKxduxbjx4+HQqHtO1Ka87exa4mur1P16tWRkpKCtLQ0KUnL/7kW5Vg2bNgQGzZs0FvPyZMnYWFhUaraIGOqV6+Oy5cv602LiIgo1iMPXnjhBdy5cwfXrl0zGl9R9zk2Nha3b9+WaquuXLmCpKQkNGjQoMixUAkIAeTmQlbOg/cYw6cQkj4hgDlztHc9jbGw0M43w5dV55133sHjx4/x5ptv4ty5c/j777+xb98+jBgxAmq1Gvb29hg5ciSmT5+OgwcP4vLlyxg+fLjBQze7du2KlStX4sKFCzh//jzGjh2rd+IdMmQIqlWrhn79+uH48eOIiYnB0aNHMXHixCIP2e/n54dhw4ZhxIgR2LVrF2JiYnDkyBGp0zSgHcp3+PDhmDVrFmrXrl1oc5CJEyfis88+w86dO3H16lWMGzeuwOeU7N69G19++SUiIiJw69YtfP/999BoNFJzSD8/P5w9exY3b97Ew4cPi32XLDs7GyNHjsSVK1fw+++/Y+7cuXj33Xel4921a1ds3LgRx48fx+XLlzFs2DC9Jh66GA4ePIj4+HiDkUF1pk+fjoULF+KHH35AVFQUZs6ciYiICEycOLFY8RI9tcx0fra2tsZ7772HGTNm4Pvvv0d0dDTOnDmDdevWAdDeyPLx8UFwcDCuXbuG3377DYsXLy6TbRd2ns6vdu3aOH/+PPbu3Ytr165hzpw5BoPf+Pn54Y8//kBUVBQePnxosvalZs2aCAgIwMiRI5Gbm4t+/fpJ87p37w5/f3+8+uqr2Lt3L27evIlTp07hgw8+wPnz542ub/DgwbCwsJDOl3v27DEY/TW/SZMmYe/evYiJicGFCxdw6NAh6Ue5r68vZDIZdu/ejQcPHuiNpldUX331lXQteeedd5CYmCi1NGrTpg1sbW3x/vvv48aNG9iyZYvBwBF+fn7SowgePnyIrKwsg20MGTIE1tbWGDZsGC5fvozDhw9j/PjxCAoKKvZgJ4Xp2rUrzp8/j++//x7Xr1/H3LlzDZKswnTq1AkdO3bEa6+9hv379yMmJga///67NNqsn58fUlNTcfDgQTx8+NBokt+9e3e88MILGDJkCC5cuIBz585h6NCh6NSpU5GbZlIJWVgAnp7I+ekHxDgB1wNf1LYECA8H/nlmbrltulzXTk+f7GwgNla/WUleGg1w+7a2nJl4eXnh5MmTUKvVCAwMROPGjTFx4kSoVCrph/znn3+Ojh07om/fvujevTvat2+Plvn6LCxevBg+Pj7o2LEjBg8ejGnTpuk1u7O1tcWxY8dQo0YN9O/fHw0aNMCIESOQkZFRrJqrVatWYcCAARg3bhzq16+PUaNGIS0tTa/MyJEjkZ2dXWCzWZ2pU6di6NChGD58uNS85T//+Y/J8k5OTtixYwe6du2KBg0a4JtvvsHWrVvRqFEjANrRsORyORo2bIjq1avrDSFdFN26dUOdOnXQsWNHDBw4EK+88ore8LSzZs1Cx44d0adPH7z00kt49dVXDUY2XLx4Mfbv3w8fHx9peOv8JkyYgKlTp2Lq1Klo0qQJQkND8euvv6JOnTrFipfoqWXG8/OcOXMwdepUfPjhh2jQoAEGDRok9f2wsrLC1q1bcfXqVTRt2hQLFy7EJ598UibbLew8nd/YsWPRv39/DBo0CG3atMGjR4/0aq0AYNSoUahXrx5atWqF6tWr4+TJkybXN2TIEFy6dAn9+/fXaxYmk8mwZ88edOzYESNGjEDdunXxxhtv4ObNmyYTBXt7e/zf//0frly5gubNm2P27NlGm7HnpVar8c4776BBgwbo1asX6tWrh6+//hoA8Nxzz+Gjjz7CzJkz4e7ubjCaXlF89tlnWLhwIZo2bYrjx4/jl19+kZo46rph7NmzB02aNMHWrVsNhh5/7bXX0KtXL3Tp0gXVq1fH1q1bDbZha2uLvXv34vHjx3jxxRcxYMAAdOvWrVz6yQcGBmLOnDmYMWMGXnzxRaSkpOg9a66otm/fjhdffBFvvvkmGjZsiBkzZki1UwEBARg7diwGDRqE6tWrY9GiRQbL64aUd3Z2RseOHdG9e3fUqlULP/zwQ6n3kYrA0hK3PWzwXDIgAvy1LQFatACK2beyuGSiJI18nwJCCKmKvSwfovc0yMzMRExMDGrWrAlra+vir+D2beDBA9Pz3dyAf5p2PU06d+6MZs2aGTwzqTI4efIkOnfujDt37pT5nTui8mLqXFOVz78F0Q1yk5GRgebNmxvU2BbJM3p+JiIqC7rrUlzcOXTtNhyPdm6B66tvAtB2P1CpVEhKSipxt46CsE8VGfLx0b6o3GVlZeH27duYM2cOBg4cyISKiArG8zMRUaFSrv0FAHBpUnH9rtn8j8iMtm7dinr16iEpKcloEwIiIiIiKp6cv68jRy6DrIwe7VIUrKmiKsPY0LfmNnz4cAwfPtzcYRARERE9MxR345Dgbo/njIwSXV5YU0VERERERM8Mh/hEpNSo2C4VTKqIiIiIiOiZoBEaeDzKgjrfSMPljUnVM4xP5Sai8sRzDBERVSYajQa56hz4JKph06BxhW6bfaqeQQqFAhYWFrh37x6qV68OhULBYY2JqMwIIZCdnY0HDx7AwsICCoXC3CE9FXTn4szMTCQnJ8Pa2prnZiKiMpD3upSZngzbe/FwfaFthcbApOoZZGFhgZo1ayIuLg737t0zdzhE9IyytbVFjRo1pIduU8EsLCzg4eGBH374Ac7OzjxuRERlzNbWFrfP/og2ublwbNyyQrfNh/8+w4QQyM3NlZ4CTkRUVuRyOSwtLY2eX3n+NS05ORlOTk54+PAhbG1tzR0OEdEzQ3dd2jLaH6+HnIMiMwfI85B1PvyXSkwmk8HKygpWVlbmDoWIiP4hhIClpSWsra3NHQoR0TNHEROLBx4OeC5PQlUR2PaAiIiIiIieamqNGkduHoHT7QQkeDpCranYllpMqoiIqGgOHAAaNtT+S0REVEnsiNwBv+V+6LKhC2o+UOOQ5R34LffDjsgdFRYDkyoiIiqcEMD77wORkdp/n83uuERE9JTZEbkDA34cgDvJd9DzOvB8IiDXAHeT72LAjwMqLLFiUkVERIXbtw8IC9P+HRamfU9ERGRGao0aE0MnQkAAAvh8PyAD0OuGtv8qAEwKnVQhTQGZVBERUcGEAObMAXRDgMvl2vesrSIiIjM6Hnscd5LvAAB6RgMvJGin13+kfS8gcDv5No7HHi/3WJhUERFRwXS1VBqN9r1azdoqIiIyu7iUOO0fAvj4EKCrj8qVad9D5CtXjphUERGRaflrqXRYW0VERGbm6eAJQFsr1foeoBtE3VJo3/eM1i9XnphUERGRaflrqXRYW0VERGbWoUYHeDs8h48PaWun8tLVVvk4eKNDjQ7lHguTKiIiMs5ULZWOhQVrq4iIyGzkFnJsdfgvWt/T1k7lpaut2uIwHHKL8n8QMJMqIiIyLjsbiI01rKXS0WiA27e15YiIiCqaEGi/di+ETGZ8tkyG9mv3VsjNP8ty3wIRET2dlEptE7+RI4GbN/HgxYbI/fUXPPl5ExpUb6At4+amLUdERFTR/rn5JzORNMmEqLCbf0yqiIjIqEe//gDNu+/ANSEFFnODkZ0aB2s1kPFCA8CzhbnDIyKiqk538+/BAwDA/Y4tkdDNH03mrvy3jO7mX1ZWuYbCpIqIiAwJAesP58Hu9iPt+4EDof5hLezZ0o+IiCoTHx/AxweZuZmwyway6tQEWlT8jT/2qSIiIkP79sHu0pV/39+4AY2dDZRqQJadY764iIiIjEhMug/7HEDuWt0s2y92UnXs2DG88sor8PLygkwmw65du0yWHTNmDGQyGZYtW6Y3PSsrC+PHj0e1atVgZ2eHvn374s6dO3plEhMTERQUBJVKBZVKhaCgIDx58qS44RIRUXH9M+qf+GfUPyGTAXPmQGNrAwCwSM8wZ3REREQGUuJjAQBKNw+zbL/YSVVaWhqaNm2KlStXFlhu165dOHv2LLy8vAzmTZo0CTt37sS2bdtw4sQJpKamok+fPlCr1VKZwYMHIyIiAqGhoQgNDUVERASCgoKKGy4RERXXP8+mkv0z6p9MCCAsDMroWwAAi7R0c0ZHRERkIC1BW0FjU90w96gIxe5T1bt3b/Tu3bvAMnfv3sW7776LvXv34uWXX9abl5SUhHXr1mHjxo3o3r07AGDTpk3w8fHBgQMHEBgYiMjISISGhuLMmTNo06YNAGDt2rXw9/dHVFQU6tWrV9ywiYioKHTPppLLtQ/41ZHL4bJ9j/ZP1lQREVElk3H/LgDAzsPHLNsv8z5VGo0GQUFBmD59Oho1amQwPzw8HDk5OejZs6c0zcvLC40bN8apU6cAAKdPn4ZKpZISKgBo27YtVCqVVCa/rKwsJCcnS6+UlJQy3jMioirgn1oqvYQKANRq2Ny4CQCwSE2r+LiIiIgKkPUwHgDg4F7DLNsv86Rq4cKFsLS0xIQJE4zOj4+Ph0KhgLOzs950d3d3xMfHS2Xc3NwMlnVzc5PK5LdgwQKp/5VKpYK3t3cp94SIqIrR1VJZGL806B6uyKSKiIgqm9yHCQAA6+qeZtl+mQ6pHh4ejuXLl+PChQuQmXiysSlCCL1ljC2fv0xes2bNwpQpU4oXMBER/eufhyjin75U+ekerihPSq3IqIiIiAqlfvwIGZaAja2tWbZfpjVVx48fR0JCAmrUqAFLS0tYWlri1q1bmDp1Kvz8/AAAHh4eyM7ORmJiot6yCQkJcHd3l8rcv3/fYP0PHjyQyuSnVCrh6OgovRwcHMpy14iInn26hyiGhwPh4Xj4eh/EOgKRoZuA8HBc3bUOAGBRAU+mJyIiKpbEx0ixlZtt82WaVAUFBeGPP/5ARESE9PLy8sL06dOxd+9eAEDLli1hZWWF/fv3S8vFxcXh8uXLCAgIAAD4+/sjKSkJ586dk8qcPXsWSUlJUhkiIioHPj7ahya2aAFha4NHtkDGCw2AFi2Q/mJTaMAh1YmIqPKRP0lCir3CbNsvdvO/1NRU3LhxQ3ofExODiIgIuLi4oEaNGnB1ddUrb2VlBQ8PD2nEPpVKhZEjR2Lq1KlwdXWFi4sLpk2bhiZNmkijATZo0AC9evXCqFGjsHr1agDA6NGj0adPH478R0RUQSzS05GqAOx0E2QypCoAOYdUJyKiSsYyKRUZ9tbm235xFzh//jy6dOkivdf1Yxo2bBhCQkKKtI6lS5fC0tISAwcOREZGBrp164aQkBDI5f9W2W3evBkTJkyQRgns27dvoc/GIiKismORlqGfVAFIVfA5VUREVPlYJ6chS2We/lRACZKqzp07Q/zTWbkobt68aTDN2toaK1aswIoVK0wu5+Ligk2bNhU3PCIiKiPy1DSkKIC8PVlTFYAqjc3/iIiocrFJyURmzepm236ZD6lORETPBl1NVV6pCm2zQCIiosrEPjUbaieV2bbPpIqIiIyS/9OnKq9UBWCRyqSKiIgqF4d0NZDvObgViUkVEREZZaqmigNVEBFRZZKrzoFThoDMxbXwwuWESRURERllkWaipop9qoiIqBJJehwHpRqwrOZmthiYVBERkVFyI0lVipJ9qoiIqHJJjr8FAFBWcy+kZPlhUkVERIZyc2GRmYUUpf5kNv8jIqLKJi3+NgDAxs3LbDEwqSIiIkNpaQDA5n9ERFTpZT6IAwDYunubLQYmVUREZCg1VfuP0aSKNVVERFR5ZD6MBwA4uvuaLQYmVUREZKiApEqezpoqIiKqPHIf3gcA2Hv4mC0GJlVERGQoJQWAiZqqzCwgN9cMQRERERnSPH6kHUjJSlF44XLCpIqIiAz9U1OVYiSpyjufiIjI7B4nIsnO0qwhMKkiIiJDBTT/yzv/aff111+jZs2asLa2RsuWLXH8+PECy2/evBlNmzaFra0tPD098d///hePHj2qoGiJiMgYiydJSLOzMm8MZt06ERFVTlUgqfrhhx8wadIkzJ49GxcvXkSHDh3Qu3dvxMbGGi1/4sQJDB06FCNHjsRff/2Fn376CWFhYXj77bcrOHIiIsrLKikF6fbWZo2BSRURERn6J2lKz3fj71lKqpYsWYKRI0fi7bffRoMGDbBs2TL4+Phg1apVRsufOXMGfn5+mDBhAmrWrIn27dtjzJgxOH/+fAVHTkREeSmT05HlaGvWGJhUERGRoZQUqG1tIPJdJVKekaQqOzsb4eHh6Nmzp970nj174tSpU0aXCQgIwJ07d7Bnzx4IIXD//n38/PPPePnll01uJysrC8nJyXovIiIqWzapGchR2Zs1BiZVRERkKDUVGnvDu37PSk3Vw4cPoVar4e7urjfd3d0d8fHxRpcJCAjA5s2bMWjQICgUCnh4eMDJyQkrVqwwuZ0FCxZApVJJLx8f8w33S0T0rLJPzYbaSWXWGJhUERGRodRUqO2e3aRKRyaT6b0XQhhM07ly5QomTJiADz/8EOHh4QgNDUVMTAzGjh1rcv2zZs1CUlKS9Lp9+3aZxk9ERIBDuhrCydmsMZh37EEiIqqcUlOhsTVMqqQ+Vk95UlWtWjXI5XKDWqmEhASD2iudBQsWoF27dpg+fToA4IUXXoCdnR06dOiATz75BJ6engbLKJVKKJXKst8BIiICAAi1GqoMAQtXV7PGwZoqIiIylJoKjZ2NwWRhAahtbZ76pEqhUKBly5bYv3+/3vT9+/cjICDA6DLp6emwsNC/bMrlcgDaGi4iIqp4KQ/vQi4AS1c3s8bBpIqIiAyZaP4HABo726c+qQKAKVOm4Ntvv8V3332HyMhITJ48GbGxsVJzvlmzZmHo0KFS+VdeeQU7duzAqlWr8Pfff+PkyZOYMGECWrduDS8vL3PtBhFRlZYSr30MhrK68VYGFYXN/4iIyFBKitGBKgBAbWcDq5SUCg6o7A0aNAiPHj3CvHnzEBcXh8aNG2PPnj3w9fUFAMTFxek9s2r48OFISUnBypUrMXXqVDg5OaFr165YuHChuXaBiKjKS4vX9lW1djPvzS0mVUREZCg1FWqX6kZnaWyfjZoqABg3bhzGjRtndF5ISIjBtPHjx2P8+PHlHBURERVVxoN7AAA7N2+zxsHmf0REZMhEnyoA2unPSFJFRERPt8wH2gGHHD18zRoHkyoiIjKUmqrtO2WE+hnpU0VERE+/3If3oZYBjtVZU0VERJVNQQNV2DOpIiKiykHz+BGSrAErK/M+voJJFRERGUpJgcbWRPO/Z6hPFRERPeUeJyLJzvzDRDCpIiIifbm5QGYm1PZ2Rmez+R8REVUWFklJSLOzKrxgecdh7gCIiKiSSUsDAA5UQURElZ7VkxSkOVibOwwmVURElM8/CZOpgSqelYf/EhHR00+Zko4sB+PXq4pU7KTq2LFjeOWVV+Dl5QWZTIZdu3ZJ83JycvDee++hSZMmsLOzg5eXF4YOHYp79+7prSMrKwvjx49HtWrVYGdnh759++LOnTt6ZRITExEUFASVSgWVSoWgoCA8efKkRDtJRETF8E/CZGqgCrWdDfAMPPyXiIiebmqNGk4JyWh2KR6XNi2GWqM2WyzFTqrS0tLQtGlTrFy50mBeeno6Lly4gDlz5uDChQvYsWMHrl27hr59++qVmzRpEnbu3Ilt27bhxIkTSE1NRZ8+faBW/3sgBg8ejIiICISGhiI0NBQREREICgoqwS4SEVGx/JMwFThQRUYGoDbfxYuIiKq2HZE74LfMFx6JOXBMVyPrvWnwW+aLHZE7zBJPsYfK6N27N3r37m10nkqlwv79+/WmrVixAq1bt0ZsbCxq1KiBpKQkrFu3Dhs3bkT37t0BAJs2bYKPjw8OHDiAwMBAREZGIjQ0FGfOnEGbNm0AAGvXroW/vz+ioqJQr1694oZNRERFpWv+Z2KgCqlZYFoa4OhYUVEREREB0CZUA34cgB43BJT/3N9rfQ9odPEuBqQMwM8Df0b/Bv0rNKZy71OVlJQEmUwGJycnAEB4eDhycnLQs2dPqYyXlxcaN26MU6dOAQBOnz4NlUolJVQA0LZtW6hUKqlMfllZWUhOTpZeKWyaQkRUMlLzP+M1VdJ09qsiIqIKptaoMTF0IoQQ+OTgv9NzZcC8QwCEwKTQSRXeFLBck6rMzEzMnDkTgwcPhuM/dzPj4+OhUCjg7OysV9bd3R3x8fFSGTc3N4P1ubm5SWXyW7BggdT/SqVSwdvbvE9VJiJ6ahVloIo85YiIiCrK8djjuJN8Bz2jgRfj/p1uKbS1VT2igdvJt3E89niFxlVuSVVOTg7eeOMNaDQafP3114WWF0JAJpNJ7/P+bapMXrNmzUJSUpL0yj/wBRERFZEuqbIxPkStmkkVERGZSVxKHCCAjw9pa6fyypVpp0P8U64ClUtSlZOTg4EDByImJgb79++XaqkAwMPDA9nZ2UhMTNRbJiEhAe7u7lKZ+/fvG6z3wYMHUpn8lEolHB0dpZeDg0MZ7hERURWSmgrY2QEWxi8RrKkiIiJz8XTwRM9oba2UpdCfp6ut6hmtLVeRyjyp0iVU169fx4EDB+Dq6qo3v2XLlrCystIb0CIuLg6XL19GQEAAAMDf3x9JSUk4d+6cVObs2bNISkqSyhARUTlJSQEKuDHFpIqIiMylg097LDxqBVM9ptQAFh61Qgef9hUZVvFH/0tNTcWNGzek9zExMYiIiICLiwu8vLwwYMAAXLhwAbt374ZarZb6QLm4uEChUEClUmHkyJGYOnUqXF1d4eLigmnTpqFJkybSaIANGjRAr169MGrUKKxevRoAMHr0aPTp04cj/xERlbfUVMDe3uRsDlRBRETmIs9Vo366LeRIMj4fQP0MO8hz1YC82KlOiRV7S+fPn0eXLl2k91OmTAEADBs2DMHBwfj1118BAM2aNdNb7vDhw+jcuTMAYOnSpbC0tMTAgQORkZGBbt26ISQkBHK5XCq/efNmTJgwQRolsG/fvkafjUVERGWskKRKen4VR1klIqKKplTC+uKfOHTuBxxbNxfBv6ej81Ag2RrwsHfHtIBp6NrmDUCprNCwip1Ude7cGUIIk/MLmqdjbW2NFStWYMWKFSbLuLi4YNOmTcUNj4iISquQpApyOWBjw5oqIiIyDx8fdPWZBpvI68DvazDsndWo6VYXHWp0gNxCXvjy5aDi6sSIiOjpUFhSBWjnM6kiIiIzEknJyJQDw158Gxaycn/8boHMu3UiIqp8ChmoAgCTKiIiMjtNShJSlTB7QgUwqSIiovxYU0VERE+DlBSkWZunuV9+TKqIiEgfkyoiInoKyFJSkcGkioiIKqWiJFUODkyqiIjIrGSpaci0UZg7DABMqoiIKD/WVBER0VPAMi0DWbZMqoiIqDIqwkAV6Uo5bt29griUuAoKioiISJ9VeiZybK3NHQYAJlVERJRXbi6QmVloTVWaAkhMiEVcKpMqIiIyD0V6FnLtbMwdBgAmVURElFdamvbfQpIqtZ0t7LMrIB4iIiITrDNyoLG3NXcYAJhUERFRXrp+UoUkVRo7GyZVRERkVtaZuRB2duYOAwCTKiIiyqvISRVrqoiIyLxsM9WFP6y+gjCpIiKifxUxqbK6Gw/7HMDh6OkKCIqIiCgfIWCfJSBzdDR3JACYVBERUV4pKdp/C7rzJwSc9h4FADw3fyUgRAUERkRE9K/cjDRYaQC5o5O5QwHApIqIiPIqQk2Vw9HTUMbeBQDY/nkV2LevIiIjIiKSpD2KBwBYqpzNHIkWkyoiIvpXYUmVALwWroKwkGnfWlgAc+awtoqIiCpU2mNtUmXl5GLmSLSYVBER0b90SZWt8SFqe0YDdpeuQKbRJlEyjQYIC2NtFRERVaiMxwkAAKVTNTNHosWkioiI/pWaCtjZARZGLg9C4ONDgJDnmyeXs7aKiIgqVGbiAwCAtXN1M0eixaSKiIj+lZJicpAKh6On0foeIFNr9Geo1aytIiKiCpX95BEAwMbZzcyRaDGpIiKif6WmGu9PJQS8Fq6C2tRy7FtFREQVKOfJYwCAnauHmSPRYlJFRET/MpVUZWdDcTceclPLaTTA7dtANp8ITERE5S83OREAYO/CpIqIiCqba9eAqCjgwAH96Uolrv6+ES1GA5Ghm3Dt5zUAgDuzJwDh4dpXWBigVJohaCIiqmrUSUlIswKUSuMDK1U0S3MHQERElYQQwPnzQEYG8P77wK5VerNznvPARS8g44UGkGVmAQByPaoDLVqYI1oiIqrCREoSUpUy2Jk7kH+wpoqIiLT27QOePNH+HRYGh6OnTRYVSgUASMkVERFRhUpJQbq1yUbpFY5JFRERaWup5sz5971cDq+FqwBT407IZMiUAxZZ7ENFREQVT5aahkybytPojkkVERFpa6nCwv59r1bD7tIV9Iw2vUimJSDLYk0VERFVPHlaOjJtFOYOQ8KkioioqtPVUsn1m1EIuQU+PgSTw6RnWrKmioiIzMMyLQM5TKqIiKjS0NVSqfWfQiVTa9D6Hkz2rdLWVDGpIiKiimeVnoUcO2tzhyFhUkVEVJXpaqksjF8O1MA/fasMa6syLQELDlRBRERmoEzPQq5d5RhOHShBUnXs2DG88sor8PLygkwmw65du/TmCyEQHBwMLy8v2NjYoHPnzvjrr7/0ymRlZWH8+PGoVq0a7Ozs0LdvX9y5c0evTGJiIoKCgqBSqaBSqRAUFIQnulGpiIiobGRnA7Gx2of3GiEHoLh33+hDfVlTRURE5mKdkQNhX1kGVC9BUpWWloamTZti5cqVRucvWrQIS5YswcqVKxEWFgYPDw/06NEDKSkpUplJkyZh586d2LZtG06cOIHU1FT06dMH6jxNTwYPHoyIiAiEhoYiNDQUERERCAoKKsEuEhGRSUqltulfeDhwWtvMb05n7QN+I0M3ocVo4OrvG40+1Ffbp4o1VUREVPFsMtUQ9vbmDkNS7HEIe/fujd69exudJ4TAsmXLMHv2bPTv3x8AsGHDBri7u2PLli0YM2YMkpKSsG7dOmzcuBHdu3cHAGzatAk+Pj44cOAAAgMDERkZidDQUJw5cwZt2rQBAKxduxb+/v6IiopCvXr1Srq/RESUn4+P9pWYCAC44qZ9wC8AXDwD5Hi5G12MA1UQEZG52GWqAQcHc4chKdM+VTExMYiPj0fPnj2laUqlEp06dcKpU6cAAOHh4cjJydEr4+XlhcaNG0tlTp8+DZVKJSVUANC2bVuoVCqpTH5ZWVlITk6WXnlrxoiIqAjS0gAA6VZFK87mf0REZA5Co4FdNmDhqDJ3KJIyTari4+MBAO7u+nc13d3dpXnx8fFQKBRwdnYusIybm5vB+t3c3KQy+S1YsEDqf6VSqeDt7V3q/SEiqlLS0wEAacVIqtj8j4iIKlpm8mPIBSBXOZk7FEm5jP4nk8n03gshDKbll7+MsfIFrWfWrFlISkqSXvkHviAiokKUpKYqkzVVRERUsdIeaytZLFXOhZSsOGWaVHl4eACAQW1SQkKCVHvl4eGB7OxsJP7Tdt9Umfv37xus/8GDBwa1YDpKpRKOjo7Sy6EStbEkInoq6GqqivgsxSzWVBERkRmkP9LmCQonVzNH8q8yTapq1qwJDw8P7N+/X5qWnZ2No0ePIiAgAADQsmVLWFlZ6ZWJi4vD5cuXpTL+/v5ISkrCuXPnpDJnz55FUlKSVIaIiMpYFexT9fXXX6NmzZqwtrZGy5Ytcfz48QLLZ2VlYfbs2fD19YVSqcTzzz+P7777roKiJSIiAMhITAAAKJ2qmTmSfxV79L/U1FTcuHFDeh8TE4OIiAi4uLigRo0amDRpEubPn486deqgTp06mD9/PmxtbTF48GAAgEqlwsiRIzF16lS4urrCxcUF06ZNQ5MmTaTRABs0aIBevXph1KhRWL16NQBg9OjR6NOnD0f+IyIqLyXpU5X69CZVP/zwAyZNmoSvv/4a7dq1w+rVq9G7d29cuXIFNWrUMLrMwIEDcf/+faxbtw61a9dGQkICcnNzKzhyIqKqLSvxIQDAxsVwDAZzKXZSdf78eXTp0kV6P2XKFADAsGHDEBISghkzZiAjIwPjxo1DYmIi2rRpg3379uk1x1u6dCksLS0xcOBAZGRkoFu3bggJCYFcLpfKbN68GRMmTJBGCezbt6/JZ2MREVEZ+KemqqjN/7Q1VU9v878lS5Zg5MiRePvttwEAy5Ytw969e7Fq1SosWLDAoHxoaCiOHj2Kv//+Gy4uLgAAPz+/AreRlZWFrDzHKDk5uex2gIioisp6ok2qbF2Mdwsyh2InVZ07d4YQwuR8mUyG4OBgBAcHmyxjbW2NFStWYMWKFSbLuLi4YNOmTcUNj4iISio9HUImQ6al6XN8Xk/zc6qys7MRHh6OmTNn6k3v2bOnyUd3/Prrr2jVqhUWLVqEjRs3ws7ODn379sXHH38MGxsbo8ssWLAAH330UZnHT0RUleUkPQYA2Ll4mDmSfxU7qSIiomdUWho0NtaALKNIxTMtAYvMp7Om6uHDh1Cr1QU+AiS/v//+GydOnIC1tTV27tyJhw8fYty4cXj8+LHJflWzZs2SWnQA2poqHx+fstsRIqIqKDc5CRoAdk7VzR2KhEkVERFppadrkyoUPal62geqKM4jQDQaDWQyGTZv3gyVSvvAySVLlmDAgAH46quvjNZWKZVKKJXKsg+ciKgK0yQnIU0BOMgrTypTLs+pIiKip1BaGjS2xpuxGfM0N/+rVq0a5HJ5gY8Ayc/T0xPPPfeclFAB2oGVhBB8NiIRUUVKSUaadeVKYypXNEREZD5STVXRZFoCMrUaeApHv1MoFGjZsqXe4z0AYP/+/SYf3dGuXTvcu3cPqamp0rRr167BwsIC3t7e5RovERHlkZKCDGt54eUqEJMqIiLSKkFNlfaPzPKJp5xNmTIF3377Lb777jtERkZi8uTJiI2NxdixYwFo+0MNHTpUKj948GC4urriv//9L65cuYJjx45h+vTpGDFihMmBKoiIqOxZpKYhw7qIz/+oIJWnISIREZlXCWqqtH9kAvb25RNTORo0aBAePXqEefPmIS4uDo0bN8aePXvg6+sLQPtg+tjYWKm8vb099u/fj/Hjx6NVq1ZwdXXFwIED8cknn5hrF4iIqiR5WgaybIv4/I8KwqSKiIi00tKgsS1hUvWUGjduHMaNG2d0XkhIiMG0+vXrGzQZJCKiimWVloEc28o1CBCb/xERkVZpaqqIiIgqiFV6FnLsKlezayZVRESkVcX6VBER0dPJOiMbajtbc4ehh0kVERFpsaaKiIieAtYZuRD2duYOQw+TKiIi0kpLg6YYo9gxqSIiInOwzVRDOFSuAZKYVBERkVZaGmuqiIio0rPL0kDm4GjuMPQwqSIiIq30dPapIiKiSk2dmwP7bMDCUWXuUPQwqSIiIi3WVBERUSWX+jgeAGCpcjFzJPqYVBEREZCbC2RnQ82aKiIiqsTS/kmqrJyczRyJPiZVREQEpKcDAEQxaqqy5Lo/ssohICIiIkPpiQkAAKVTNTNHoo9JFRERSUmV2rboSZWwADQKK9ZUERFRhcl8/AAAoHRyNXMk+phUERERkJYGAMXqUwUAQqlgUkVERBUm68lDAICNs5uZI9HHpIqIiKSaquKM/gcAGqWSSRUREVUItUaNG7cuAgD+yoiFWqM2c0T/YlJFRET/1lQVO6liTRUREZW/HZE74LfcD7+GbwEA9P99OPyW+2FH5A4zR6bFpIqIiP6tqSp28z/WVBERUfnaEbkDA34cgDvJd/DiXUAACLgN3E2+iwE/DqgUiRWTKiIiKnlNlTVrqoiIqPyoNWpMDJ0IAQEIoH8kIAMw/yAghAAATAqdZPamgEyqiIioFDVVTKqIiKj8HI89jjvJdwAAPaOBGsna6a3vad8LCNxOvo3jscfNGCWTKiIiAko8+h8HqiAiovIUlxKn/UMAHx8CNP9Mz5Vp30PkK2cmTKqIiEhbU6VUAnJ54WXzYE0VERGVJ08HTwDaWqnW9/5NXizFv7VVecuZC5MqIiLS1lTZ2RV7MdZUERFReepQowO8HZ7Dx4e0tVN56WqrfBy80aFGB/ME+A8mVUREpK2psrUt9mKsqSIiovIkt5Bjq8N/0fqetnYqL11t1RaH4ZBbFK+lRVljUkVERCWvqeLof0REVJ6EQPu1eyFkMuOzZTK0X7sXEMLo/IrCpIqIiEpcU8Xmf0REVK6ys4HYWMhMJE0yIYDbt7XlzKjMk6rc3Fx88MEHqFmzJmxsbFCrVi3MmzcPGo1GKiOEQHBwMLy8vGBjY4POnTvjr7/+0ltPVlYWxo8fj2rVqsHOzg59+/bFnTt3yjpcIiICSlxTxeZ/RERUrpRKICwMCA8HwsMR52iB8F5NpfcID9fOVyrNGmaZJ1ULFy7EN998g5UrVyIyMhKLFi3C559/jhUrVkhlFi1ahCVLlmDlypUICwuDh4cHevTogZSUFKnMpEmTsHPnTmzbtg0nTpxAamoq+vTpA7XavA/2IiJ6JrGmioiIKisfH6BFC6BFCyhzBVJ9PaX3aNEC8PY2d4SwLOsVnj59Gv369cPLL78MAPDz88PWrVtx/vx5ANpaqmXLlmH27Nno378/AGDDhg1wd3fHli1bMGbMGCQlJWHdunXYuHEjunfvDgDYtGkTfHx8cODAAQQGBhpsNysrC1lZWfo7Z1nmu0dE9GxiTRUREVVyQgjYZwnIHFXmDsVAmddUtW/fHgcPHsS1a9cAAJcuXcKJEyfw0ksvAQBiYmIQHx+Pnj17SssolUp06tQJp06dAgCEh4cjJydHr4yXlxcaN24slclvwYIFUKlU0su7EmSsRERPjbS0ktVUcaAKIiKqIJlpSVCoAUuVs7lDMVDmVTnvvfcekpKSUL9+fcjlcqjVanz66ad48803AQDx8fEAAHd3d73l3N3dcevWLamMQqGAs7OzQRnd8vnNmjULU6ZMKevdISKqGtLTS1hTxeZ/RERUMVIe3IUNAEunKpBU/fDDD9i0aRO2bNmCRo0aISIiApMmTYKXlxeGDRsmlZPlGxZRCGEwLb+CyiiVSijzdFATQiAjI6MUe0JEVIWUtKaKzf+IiKiCpCfeBwBYObmaORJDZZ5UTZ8+HTNnzsQbb7wBAGjSpAlu3bqFBQsWYNiwYfDw8ACgrY3y9PSUlktISJBqrzw8PJCdnY3ExES92qqEhAQEBASUdchERFTCmiqNUgnk5mpf7MdKRETlKPNRAgBA6VzNzJEYKvM+Venp6bCw0F+tXC6XhlSvWbMmPDw8sH//fml+dnY2jh49KiVMLVu2hJWVlV6ZuLg4XL58mUkVEVF5KGFNlVAqtH/kGyiIiIiorGU+eQAAsHF2M3Mkhsr8tuIrr7yCTz/9FDVq1ECjRo1w8eJFLFmyBCNGjACgbfY3adIkzJ8/H3Xq1EGdOnUwf/582NraYvDgwQAAlUqFkSNHYurUqXB1dYWLiwumTZuGJk2aSKMBEhFRGSppTZX1P0lVZmaJliciIiqq7CePAAC2rh5mjsRQmSdVK1aswJw5czBu3DgkJCTAy8sLY8aMwYcffiiVmTFjBjIyMjBu3DgkJiaiTZs22LdvHxwcHKQyS5cuhaWlJQYOHIiMjAx069YNISEhkMvlZR0yEVHVptGU+DlVQteXlf2qiIionOUkapMqu6qQVDk4OGDZsmVYtmyZyTIymQzBwcEIDg42Wcba2horVqzQe2gwERGVA11CVKI+VXlqqoiIiMqROvkJNADsnCpf878y71NFRERPmbQ07b8lqalSMKkiIqKKoUl6glQlIKuELdeYVBERVXXp6dp/WVNFRESVWUoK0pSVM32pnFEREVHF0dVUleThv9bsU0VERBVDlpyCdJvK+fgOJlVERFWdrqaqpA//BZhUERFRuZOlpiHTxsrcYRjFpIqIqKorTU0VR/8jIqIKYpmWjkxbhbnDMIpJFRFRVceaKiIiegpYpWUix1Zp7jCMYlJFRFTVlaKmikkVERFVFEV6FnLti38DsCIwqSIiqupKUVMlmFQREVEFsUnPhtqOSRUREVVGaWmApSWgKEE7dbkcsLJiUkVEROXOOjMXGgd7c4dhFJMqIqKqLj29RLVUEmtrJlVERFTubDPVgIODucMwikkVEVFVl5ZWov5UEiZVRERUARwyBWSOjuYOwygmVUREVR1rqoiIqJLLSU+FUg3IVc7mDsUoJlVERFUda6qIiKiSS30UBwCwZFJFRESVUloaa6qIiKhSS398HwBg5eRi5kiMY1JFRFTVpaezpoqIiCq1jH+SKqVzdTNHYhyTKiKiqo41VUREVMllPn4AALBmUkVERJUSa6qIiKiSy056BACwdfUwcyTGMakiIqrqWFNFRESVXHbiQwCArYu7mSMxjkkVEVFVx5oqIiKq5HKTngAAHFw9zRuICUyqiIiquipcU/X111+jZs2asLa2RsuWLXH8+PEiLXfy5ElYWlqiWbNm5RsgEREBAETSE6QoAEtLhblDMYpJFRFRVVcWNVVZWWUXTwX54YcfMGnSJMyePRsXL15Ehw4d0Lt3b8TGxha4XFJSEoYOHYpu3bpVUKRERCRSkpGmrLypS+WNjIiIKkYVralasmQJRo4cibfffhsNGjTAsmXL4OPjg1WrVhW43JgxYzB48GD4+/tXUKRERISUFKTZyM0dhUlMqoiIqjIhqmSfquzsbISHh6Nnz55603v27IlTp06ZXG79+vWIjo7G3Llzi7SdrKwsJCcn672IiKj4LFJSkWljae4wTGJSRURUlWVnA2p1lUuqHj58CLVaDXd3/VGk3N3dER8fb3SZ69evY+bMmdi8eTMsLYt2YV+wYAFUKpX08vHxKXXsRERVkTwtHZm2lbM/FcCkioioaktP1/5bBZv/AYBMJtN7L4QwmAYAarUagwcPxkcffYS6desWef2zZs1CUlKS9Lp9+3apYyYiqoqsUjORbWtt7jBMqrx1aEREVP7S0rT/VrGaqmrVqkEulxvUSiUkJBjUXgFASkoKzp8/j4sXL+Ldd98FAGg0GgghYGlpiX379qFr164GyymVSiiVyvLZCSKiKkSRnokMdydzh2ESa6qIiKqyKlpTpVAo0LJlS+zfv19v+v79+xEQEGBQ3tHREX/++SciIiKk19ixY1GvXj1ERESgTZs2FRU6EVGVpMzIQa5DKW4AljPWVBERVWWHDmn/vXwZ6NixZOuwtgZycrR9s+SVd2Sm/KZMmYKgoCC0atUK/v7+WLNmDWJjYzF27FgA2qZ7d+/exffffw8LCws0btxYb3k3NzdYW1sbTCciorJnk5EDYV95k6pyqam6e/cu3nrrLbi6usLW1hbNmjVDeHi4NF8IgeDgYHh5ecHGxgadO3fGX3/9pbeOrKwsjB8/HtWqVYOdnR369u2LO3fulEe4RERVkxDA8uXav1et0r4vCet/2rg/Zc+qGjRoEJYtW4Z58+ahWbNmOHbsGPbs2QNfX18AQFxcXKHPrCIioophm6mGcHAwdxgmlXlSlZiYiHbt2sHKygq///47rly5gsWLF8PJyUkqs2jRIixZsgQrV65EWFgYPDw80KNHD6SkpEhlJk2ahJ07d2Lbtm04ceIEUlNT0adPH6jV6rIOmYioatq3D7h6Vfv35cva9yWhS6qesiaAADBu3DjcvHkTWVlZCA8PR8c8tXUhISE4cuSIyWWDg4MRERFR/kESERHsMzWQOTiaOwyTyrz538KFC+Hj44P169dL0/z8/KS/hRBYtmwZZs+ejf79+wMANmzYAHd3d2zZsgVjxoxBUlIS1q1bh40bN6J79+4AgE2bNsHHxwcHDhxAYGBgWYdNRFS1CAHMmQNYWAAajbbZ3pw5wK6CH3xr1FOcVBERUeUnsrJgnQtYqFTmDsWkMq+p+vXXX9GqVSu8/vrrcHNzQ/PmzbF27VppfkxMDOLj4/UeuKhUKtGpUyfpgYvh4eHIycnRK+Pl5YXGjRubfChj/gcs5q31IiKifPbtA8LCtAkVoO0PFRYGh6Oni78uJlVERFSO0h5rR2q1dHIxcySmlXlS9ffff2PVqlWoU6cO9u7di7Fjx2LChAn4/vvvAUAavragBy7Gx8dDoVDA2dnZZJn88j9g0dvbu6x3jYjo2aCrpco/qIRcDq+Fq4Didq1iUkVEROUo7ZH297+VqvImVWXe/E+j0aBVq1aYP38+AKB58+b466+/sGrVKgwdOlQqV9QHLha1zKxZszBlypRSRk9EVAXoaqnyU6thd+kKejYp5vqYVBERUTlKf3wfAKBwrmbmSEwr85oqT09PNGzYUG9agwYNpBGUPDw8AKDABy56eHggOzsbiYmJJsvkp1Qq4ejoKL0cKvHoIEREZpO3L5Wx2TIZPj6E4o0EyKSKiIjKUVbiAwCAtXN1M0diWpknVe3atUNUVJTetGvXrklD1NasWRMeHh56D1zMzs7G0aNHpQcutmzZElZWVnpl4uLicPnyZaMPZSQioiLKzgZiY//tS5WPTAj4JAOy7Jyir5NJFRERlaOsxIcAAGsXNzNHYlqZN/+bPHkyAgICMH/+fAwcOBDnzp3DmjVrsGbNGgDaZn+TJk3C/PnzUadOHdSpUwfz58+Hra0tBg8eDABQqVQYOXIkpk6dCldXV7i4uGDatGlo0qSJNBogERGVgFKpbfr3QHvXL2naeFyPPAW7kE1oUL0BIh9Eosfet/CrUlH0dTKpIiKicpTz5BEAwN7V08yRmFbmSdWLL76InTt3YtasWZg3bx5q1qyJZcuWYciQIVKZGTNmICMjA+PGjUNiYiLatGmDffv26TXZW7p0KSwtLTFw4EBkZGSgW7duCAkJgTx/x2oiIioeHx/tC4CwtMQ9R8D7hQaAZwtkxAF3zxRzfUyqiIioHOU8eQwAsHfxMHMkppV5UgUAffr0QZ8+fUzOl8lkCA4ORnBwsMky1tbWWLFiBVasWFEOERIREQDIU1KRrCzlSphUERFROdIkJyFVAdgp7cwdikll3qeKiIieHvKUNCRZl3Ilyn+yMiZVRERUDkRyElKVskJHCjcnJlVERFWYPLUMaqrkcsDKikkVERGVj5QUpFlX7i5ATKqIiKoweXIZJFWAtgkgkyoiIioHspRUZNqUS6+lMsOkioioqhICFqlpSGJSRURElZg8NR2ZNsUYldYMmFQREVVVWVmwyMllTRUREVVqVmnpyLIti4tV+WFSRURUVSUlAQCTKiIiqtSs0rKQY1faUZXKF5MqIqKqKjkZAEo/+h8A5OQA334LHDhQBisjIiL6lzIjG7n2tuYOo0BMqoiIqqp/kqpS11QJASQkAImJwPvva98TERGVEZuMHAj7yvuMKoBJFRFR1VVWzf/27QPS07V/h4UBhw6VcoVERERaao0ajik5eHHvZVzatBhqjdrcIRnFpIqIqKrSNf8rTVIlBDBnzr/v5XLgk09KFxcRERGAHZE74LfMF46ZAqqUbGS9Nw1+y3yxI3KHuUMzwKSKiKiqKoPmfw5HT2trp3TUauDChVIGRkREVd2OyB0Y8OMANAm/KyUsre8BjS7exYAfB1S6xIpJFRFRVZWUBI21EjklfZ6iALwWrtLWTuWV/z0REVExqDVqTAydCCEEPsnTojxXBsw7BEAITAqdVKmaAjKpIiKqqpKToS5Fx9+e0YDdpSva2qm88r8nIiIqhuOxx3En+Q56RgMt4v+dbim0tVU9ooHbybdxPPa4+YLMh0kVEVFVlZwMtUMJkyoh8PGh/2fvvuObqP84jr/SdE9ogQ4oFARlrwIKsvcURGTKVkS2CLJUhgoKgoAIqCAgWIZQEBWQsvePUtkUkFlGa5ndM7nfH7WRtCm0NG3S5vN8PPrQ3H1z98419JtP7nvfA0WlMm4mIYQQFi88JhwU+HQPaDJ0M6mqtOUo/7YzE8876EMIIURBFxWFxsX5uZ6qSk6hdBSoZPp0IYQQRubt4k3rq2lnpTJKP1vV+mpaO3MhZ6qEEMJSRUejfc4zVYqdLXWHQOiONRASQuSgnkTb/vv4wAEjBxVCCGFJGvk25Mv9NmQ1mFwDfLnfhka+DfMz1lNJUSWEEJYql9dU3XaDhOqVoHZtEl8og33qv49r1DBiSCGEEJZGnaqhYrwjWU17pAYqJjihTjWfa3ilqBJCCEsVFYXG9fmG/2WkdXLAVps2LFAIIYTIFTs77E+eZc/GOSyvZ8t9e6g9JO2n/VhP9mycg/3Js2CX27vXG49cUyWEEJYqOhpNhZJG2ZTW0QEAq/gEo2xPCCGEhfP1pbnvOI6s/YUHN0IYP2I13i7eNCrdCLWV+d26Q4oqIYSwVLm4piojKaqEEELkBfXjKOJc7OhVrZepozyVDP8TQghLlYvZ/zLSODkCYBUXb5TtCSGEEAA2j2JIcHUwdYxnkqJKCCEskaLk7j5VGWgd7AGwSkg0yvaEEEIIAPvoeJJcjdNX5SUpqoQQwhIlJIBGk6vZ/56k/fdMlVrOVAkhhDAix5hEUou4mTrGM0lRJYQQligqCsB4s//JNVVCCCHygEtcMlr3oqaO8UxSVAkhhCWKjgYw4jVV/xZVcqZKCCGEsSgKbvFarDw8TJ3kmaSoEkIIS/RvUaU11vA/3ZkquaZKCCGEcWgeP8JaC2qP4qaO8kxSVAkhhCUy8vA/rK1JVMs1VUIIIYwnKvw6AHbFvU2c5NmkqBJCCEuUPvzPSGeqAOJs5ZoqIYQQxhMTfhMAB69SJk7ybFJUCSGEJdIVVY5G22SsFFVCCCGMKD7iFgBOnr4mTvJseV5UzZo1C5VKxZgxY3TLFEVh2rRp+Pj44ODgQNOmTTl//rze85KSkhg5ciTFihXDycmJ1157jdu3b+d1XCGEsAxRUeDoCDY2RttknI0UVUIIIYwnMfIuAG4+ZU2c5NnytKgKDg7m+++/p3r16nrLZ8+ezbx581i0aBHBwcF4eXnRqlUrYmJidG3GjBnD5s2bWbduHYcOHSI2NpaOHTui0WjyMrIQQliG6GhwdTXqJmNt5ZoqIYQQxpN8L4IUKyhSzIKH/8XGxtKnTx9++OEHihb9b255RVGYP38+U6ZMoWvXrlStWpVVq1YRHx9PQEAAAFFRUSxfvpy5c+fSsmVLatWqxZo1azh79iy7du0yuL+kpCSio6N1P08WaEIIITLIg6JKrqkSQghhTJoH93noCA62xhuqnlfyrKgaPnw4HTp0oGXLlnrLr1+/TkREBK1bt9Yts7Ozo0mTJhw5cgSAkJAQUlJS9Nr4+PhQtWpVXZuMZs2ahZubm+6nVCnzr2iFEMJkoqLAzbh3qI+1Bas4KaqEEEIYh+rBA6KcrE0dI1vyJOW6dev466+/CA4OzrQuIiICAE9PT73lnp6e3Lx5U9fG1tZW7wxXepv052c0adIkxo4da4z4QghR+OXFmSobsEqQokoIIYRxWD1+TJyzraljZIvRi6pbt24xevRodu7cib29fZbtVCqV3mNFUTIty+hpbezs7LCzs9NrmyCduxBCGJZX11TJ8D8hhBBGYvM4hngXB1PHyBajD/8LCQkhMjISf39/rK2tsba2Zv/+/SxcuBBra2vdGaqMZ5wiIyN167y8vEhOTubRo0dZthFCCJELeTD8L06G/wkhhDAiu+h4ktyMdz/FvGT0oqpFixacPXuWU6dO6X7q1KlDnz59OHXqFOXKlcPLy4ugoCDdc5KTk9m/fz8NGjQAwN/fHxsbG7024eHhnDt3TtdGCCFELuTRmSqZqEIIIYSxOEUnklrEuF8A5hWjD/9zcXGhatWqesucnJzw8PDQLR8zZgwzZ86kQoUKVKhQgZkzZ+Lo6Ejv3r0BcHNzY/DgwXzwwQd4eHjg7u7OuHHjqFatWqaJL4QQQjyHvLqmSqZUF0IIYSQucckoRYuYOka2mGQ6jQ8//JCEhASGDRvGo0ePePnll9m5cycuLi66Nl9//TXW1tZ0796dhIQEWrRowcqVK1Gr1aaILIQQhUseDf+Ta6qEEEIYhaLgFq9F5eFh6iTZki9F1b59+/Qeq1Qqpk2bxrRp07J8jr29Pd988w3ffPNN3oYTQghLoyh5N/wvMQlFbtIuhBAilzRRj7HWgnWxgjGfQp7dp0oIIYSZiotLK6zyYPgfADLzqhBCiFyKunsNANviXiZOkj1SVAkhhKWJikr7bx7c/Dftf2KNul0hhBCWJyY87f61Dp4lTZwke6SoEkIISxMdnfZfY5+pSi+q4mWyCiGEELkT/89tAJw8fU2cJHukqBJCCEuTR0WV7kxVXJxRtyuEEMLyJETeAcCtZDkTJ8keKaqEEMLS5NHwP901VQWoqFq8eDFly5bF3t4ef39/Dh48mGXbwMBAWrVqRfHixXF1daV+/fr8+eef+ZhWCCEsR0pkBClWUKRYKVNHyRYpqoQQwtLImSoA1q9fz5gxY5gyZQonT56kUaNGtGvXjrCwMIPtDxw4QKtWrdi2bRshISE0a9aMTp06cfLkyXxOLoQQhZ/mwX0eOoCDraOpo2SLFFVCCGFp0ouqJ+4NaAxxBayomjdvHoMHD+btt9+mUqVKzJ8/H19fX5YsWWKw/fz58/nwww+pW7eu7sb1FSpU4Lfffsvn5EIIYQEePiDaySS31H0uUlQJIYSliYoCZ2cw8s3UYwvQRBXJycmEhITQunVrveWtW7fmyJEj2dqGVqslJiYGd3f3LNskJSURHR2t9yOEEOLZrB5FEeti++yGZkKKKiGEsDR5cONfgGQ1KGp1gThTdf/+fTQaDZ6e+jeV9PT0JCIiIlvbmDt3LnFxcXTv3j3LNrNmzcLNzU334+tbMGaxEkIIU7N9HE28i4OpY2SbFFVCCGFp8qioQgUaJ4cCUVSlU6lUeo8VRcm0zJC1a9cybdo01q9fT4kSJbJsN2nSJKKionQ/t27dynVmIYSwBHbR8SS7OZk6RrYVnIGKQgghjCMqyugz/6XTOjqgLgBFVbFixVCr1ZnOSkVGRmY6e5XR+vXrGTx4ML/88gstW7Z8als7Ozvs7OxynVcIISyNY0wiqUUKxsx/IGeqhBDC8vz9N5w7B7t2GX3TWkfHAnFNla2tLf7+/gQFBektDwoKokGDBlk+b+3atQwYMICAgAA6dOiQ1zGFEMJiucSmoC1a1NQxsk2KKiGEsCSKAqdOpQ3Rmzw57bERaR3tITbWqNvMK2PHjmXZsmX8+OOPhIaG8v777xMWFsbQoUOBtKF7/fr107Vfu3Yt/fr1Y+7cubzyyitEREQQERFBVPp9v4QQQhiHouAWr0Hl4WHqJNkmw/+EEMKS7Nz535TqwcG47D9q1M1rnArGmSqAHj168ODBA2bMmEF4eDhVq1Zl27ZtlClTBoDw8HC9e1Z99913pKamMnz4cIYPH65b3r9/f1auXJnf8YUQotDSRD3GRgvWxbK+ZtXcSFElhBCWQlHg44//e6xW4/PlEuhivF1oHQvWRBXDhg1j2LBhBtdlLJT27duX94GEEEIQFX4dd8C2uJepo2SbDP8TQghLsXMnBAf/91ijwen0BVpfNd4utAVs9j8hhBDmJyb8JgAOnjJRhRBCCHOSfpYqww1/FbUVn+7BaNdWFbQzVUIIIcxPfETa7SecvUqbOEn2SVElhBCWIP0slUajt1il0VLvLka7tkrrIEWVEEKI56fRani4YzMA94/tQaPVPOMZ5kGKKiGEKOzSz1JZGf6Tr4G0a6uMcLZK4+QoRZUQQojnEhgaiN/8MpTcug8Am1mz8ZtfhsDQQNMGywYpqoQQorBLToawMNBqDa5WA7Z3/0lrl0taR/sCM/ufEEII8xEYGki3Dd2ofPIOfv/eqaLeXahy8g7dNnQz+8JKiiohhCjs7OzShv6FhMD48Sg2Nny39B3uHdhB6I411B4CF7evTmuXS1onxwJznyohhBDmQaPVMHrHaBRF4dM9kP4VYKoKZvx73e+YHWPMeiigFFVCCGEJfH2hdm2wsiLZuwRDI37gVvniJFSvxEkfSPHxNMputI4OcqZKCCFEjhwMO8jt6Nu0vpp2diq9QLFW0h63ugq3om9xMOygSXM+jRRVQghhSe7eJcWreJ5tXuPkYLSZBIUQQliG8JhwUODTPWlnp56UquLfWWr/bWem5Oa/QghhSe7eJcUz74oqrYNDnm1bCCFE4eTt4q07S5VR+tmq1lfT2pkrKaqEEMKS3L1LcsNaebZ5rZNjnm1bCCFE4dTItyFF9tugIQW1gfUa4Mv9NlTzbZjf0bJNhv8JIYQluXMnT4f/aR3lTJUQQoicUadqqBjvaLCggrRZaismOKFOlYkqhBBCmFpsLERH5+nwP42TFFVCCCFyyM4O+5Nn2bNxDuPecAHg9e5Qewi0H+vJno1zsD951iiz1OYVGf4nhBCWIjztAt8Ur+JwP292IWeqhBBCPBdfX5r7jsPtchhs+oZ2I+bzom8NGpVuhNoqq3NY5sPoZ6pmzZpF3bp1cXFxoUSJEnTp0oVLly7ptVEUhWnTpuHj44ODgwNNmzbl/Pnzem2SkpIYOXIkxYoVw8nJiddee43bt28bO64QQliOO3cA8naiCrmmSgghRC6kXPubCGd4p+Eomvo1LRAFFeRBUbV//36GDx/OsWPHCAoKIjU1ldatWxMXF6drM3v2bObNm8eiRYsIDg7Gy8uLVq1aERMTo2szZswYNm/ezLp16zh06BCxsbF07NgRjcZ8x1IKIYRZu5s2rZJcUyWEEMJcqW6G8Y+HPSqV6tmNzYjRh//t2LFD7/GKFSsoUaIEISEhNG7cGEVRmD9/PlOmTKFr164ArFq1Ck9PTwICAnj33XeJiopi+fLlrF69mpYtWwKwZs0afH192bVrF23atDF2bCGEKPzu3gVX1zw9m6S1t4MC1hEKIYQwHw53I3ns6WbqGDmW5xNVREVFAeDu7g7A9evXiYiIoHXr1ro2dnZ2NGnShCNHjgAQEhJCSkqKXhsfHx+qVq2qa5NRUlIS0dHRup8nz3oJIYQgrajy8cnbfVhZgdyrSgghxHMq+k80iaW8TB0jx/K0qFIUhbFjx9KwYUOqVq0KQEREBACenp56bT09PXXrIiIisLW1pWjRolm2yWjWrFm4ubnpfkqVKmXslyOEEAXbnTt5X1QBODvn/T6EEEIUPhoNno+SoUwZUyfJsTwtqkaMGMGZM2dYu3ZtpnUZx0kqivLMsZNPazNp0iSioqJ0PzKphRBCZHD3LpQsmff7cZTJKoQQQuRc1PWL2GrArvxLpo6SY3lWVI0cOZKtW7eyd+9evbNGXl5pp/MynnGKjIzUnb3y8vIiOTmZR48eZdkmIzs7O1xdXXU/Li4uxnw5QghR8OXH8D8AJ6e834cQQohCJ/JCMABFXqxh4iQ5Z/SiSlEURowYQWBgIHv27KFs2bJ668uWLYuXlxdBQUG6ZcnJyezfv58GDRoA4O/vj42NjV6b8PBwzp07p2sjhBAiBxQl/4b/SVElhBDiOURdPgOAV5WXTZwk54w++9/w4cMJCAjg119/xcXFRXdGys3NDQcHB1QqFWPGjGHmzJlUqFCBChUqMHPmTBwdHendu7eu7eDBg/nggw/w8PDA3d2dcePGUa1aNd1sgEIIIXLg0SNISsqf4X9SVAkhhHgOyVcu88ABSni9YOooOWb0omrJkiUANG3aVG/5ihUrGDBgAAAffvghCQkJDBs2jEePHvHyyy+zc+dOvSF7X3/9NdbW1nTv3p2EhARatGjBypUrUasLxg3AhBDCrPx7jyo5UyWEEMJshd0kwsMOjwJ4aw6jF1WKojyzjUqlYtq0aUybNi3LNvb29nzzzTd88803RkwnhBAWSq+oepC3+5KJKoQQQjwHhzsF8x5VkA/3qRJCCGEG7txJ+6+3d97vS85UCSGEeA5F/okisaThSenMnRRVQghhCe7eheLFwdY27/clRZUQQoicUhS8HiQVyHtUgRRVQghhGfJrOnWQokoIIUSORYX9jUMq2L1Q8O5RBVJUCSGEZcjPokquqRJCCJFD/1w4DoDbS9VNnOT5SFElhBCW4M6d/JlOHcDZOX/2I4QQotB4fPE0AJ6V65k4yfORokoIISxBfp6pCgvLn/0IIYQoNJKuXiLaDoqXetHUUZ6LFFVCCFHY/fln2pmqqKi835eiwNateb8fIYQQhYZGqyH2ynnuFLVmf9gBNFqNqSPlmBRVQghRmCkKTJiQ9v9//JH2OA+57D8K16/n6T6EEEIUHoGhgfgt8KPouWuUepDKZ580w2+BH4GhgaaOliNSVAkhRGG2cyecThunzpUraY/zigI+Xy4BK+lahBBCPFtgaCDdNnTjdtRtqv8DLikwczfcibpNtw3dClRhJT2fEEIUVooCH3/8X5GjVqc9zqOzVa2vgtPpC6DV5sn2hRBCFB4arYbRO0ajoND6Cjimpi2vdxdaXU37/zE7xhSYoYBSVAkhRGG1cycEB/9X5Gg0EBycNkTP2BSFT/eAopZuRQghxLMdDDvI7ejboMCs3f8tT1WR1p8oCreib3Ew7KDpQuaA9H5CCFEYpZ+lUqv1l6vVaUP0jHyyymX/UerdBZVGzlIJIYR4tvCYcCBtlEPtiP+WWytpZ6taX9VvZ+6kqBJCiMIo/SyVJsOwCY0Gp9MXdJ2VUSgKPl8uoWAM0BBCCGEOvF28QUk7K5Xx67j0s1Uo/7YrAKSoEkKIwibjtVQZV6tU/3ZWRjpdlZyM7Z0I1M9uKYQQQgDQqHQj+oQXo97dzAVJ+tmqPuHFaFS6kUny5ZQUVUIIUdgkJ6fdgDeLCSNUioJvNKiSU4yzPzs7Lm5fTe0hELpjDfe3F5zZmoQQQpiGWmXFwiNuWY5y0AALj7ihVhWMcqVgpBRCCJF9dnZpQ/9CQqBdOxIqlNUVPISEELpjDXXfAcXO1mi7TCnpxUkfSKheiTvlihltu0IIIQqp5GTc78VmOcpBDbjfj0v7orAAsDZ1ACGEEHnA1zft58IFots05KTPdRKqVwLv2iSEw51jpg4ohBDCov37BeD+Hi9TOfQBN1d/w/24+xRzKkYtr1qordRQokRauwJAiiohhCisbt2CmzeJfXkE3PrZ1GmEEEIIPYnexSl2LYK7r/pTp+MQU8fJFSmqhBCisDqYdm+PuHq14JaJswghhBD/0mg1HAw7yJHgzUz+R+FG+66mjpRrck2VEEIUVgcPQsWKpHoUNXUSIYQQAoDA0ED8FvjRbFUzzqxfCEDXe98QGFqwJzmSokoIIQqrgwehUcGYilYIIUThFxgaSLcN3bgdfRuAFtfhXHE4RQTdNnQr0IWVFFVCCFEYBQbC+fNQVM5SCSGEMD2NVsPoHaNRSLtHYour0P8U/O2ObtmYHWPQaAvmreSlqBJCiMJGUUgdPw6AlD9+M95NfoUQQojndDDsoO4MFQrM3Qm2Wqh6L+2xgsKt6FscDDto0pzPS4oqIYQobHbuxPradQBszofisv+oiQMJIYSwdOEx4br/b30VavyT9v8VHqY9NtSuIJGiSgghChNFgY8/Jv3clKK2wufLJSAnq4QQQphQCacSaf+jwKd7QPvv8lRV2uP0fsrbxdsU8XJNiiohhChMdu6E4GBU/z5UabQ4nb6g9y2gEEIIkZ8CQwPpv6U/kHZWqt7d/4oQayXtcZur4OvqS6PSBXOCJblPlRBCFAa7dsHIkZCSkmmVorbi0z1aubZKCCFEvkm/F9WvF39l/v/mA9DiCvy6Nu2klOqJtqkqmLEHbk/6GrWV2hRxc02KKiGEKOgUBSZPhosXDa5WabTUuwt/7z8KvfzzOZwQQojCIr1QCo8Jx9vFmwalGnDk9hHCY8J1w/si4yL5++Hf/BDyA7djbv/3ZAW+3Qb2Bib3Sz9bVe+WM1TOpxdjZDL8TwhheXbtgsqV0/6b8fHT1uWkbX6u++ILCA5+6kvWwL/XVsnZKiGEMEvm0qdksS76BV/eGu7FZ580o0bz3nz2STMcZzrqHs+a1pJZ01pSo3lvDiyfyu2Y27S4CucXpU2f3voKvPTwKa/fygo+/rjg9lOKmfv2228VPz8/xc7OTqldu7Zy4MCBbD1Pq9UqcXFxilarzeOEQogCRatVlLp1FQXS/qvR/Pe4Tp20H0PrctI2v9c5OiqKSpX2/0/5SS7uoSiJiUrI3RCFaSghd0P0/l9RFKOsO3n3ZIH5+5vTPmbfvn1K7dq1FTs7O6Vs2bLKkiVLcrS/qKgoBVCioqJyE1sIUdg8b9+UT+seVH1BUUD5nzfK/3zS+pT/+aDwyROPn7LuuDfK324o2mf0U4qXl6IkJubJIc7rv79mXVStW7dOsbGxUX744QflwoULyujRoxUnJyfl5s2bz3yuFFVCCIN27ND/A/7ZZ1n/cc+4LidtTbkOlJuff6jUGoJyYcca5cKONUqtIShnTmxTFMU4hVNhKKpy2sdcu3ZNcXR0VEaPHq1cuHBB+eGHHxQbGxtl48aN2d6nFFVCCINy0zfl8brUT2dkuW5S86z7oaetS/8Z1g6l1hCU4N++U5SQEEW5dSvPDnFe//1VKYqimPZcWdZefvllateuzZIlS3TLKlWqRJcuXZg1a5Ze26SkJJKSkvSWWVtbY29vj0qlQgghUBRo3hxOnwbNv4O6bW3TJncw9Kcw47qctDXGOhsbSE3VrVNIu7BXAVRWViha7X+Pn3yeWk18pQp4d7zIgYEHAGi8sjEHBhyghlcNTkec1j3Oi3VWWFHerTz29vZYWZnvKPOc9DEAEyZMYOvWrYSGhuqWDR06lNOnT3P0qOF7gWXsm6KioihdujS3bt3C1dXViK9GCFFgpfdNJ0/+1xfY2BiceMgU67TWapRUDWrQ3Z1DRdqw8lQV2Chp1xM9uU77xP+rMqxLlwqc8oJ+I304O+xcnk9QER0dja+vL48fP8bNzc3o2zfboio5ORlHR0d++eUXXn/9dd3y0aNHc+rUKfbv36/Xftq0aUyfPl332NvbmytXruRbXiGEEPpUKhUODg6mjmFQTvsYgMaNG1OrVi0WLFigW7Z582a6d+9OfHw8NjY2mZ6TsW8SQghhWlevXqVcuXJG367Zzv53//59NBoNnp6eess9PT2JiIjI1H7SpEmMHTtW9zg6Opry5ctz8eJFXFxc8jxvQRITE0OpUqW4ffu2HJsnyHHJmhwbw+S4GBYTE0PFihW5ePGi2RZVOe1jACIiIgy2T01N5f79+3h7Z75hZca+6fHjx5QpU4awsLA8+aa0oEr/BlnO4GUmx8YwOS5Zk2NjWPpIAXd39zzZvtkWVekyDt1TFMXgcD47Ozvs7Oz0loWHhxvchkj70ANybDKS45I1OTaGyXExLP3vr7nLbh/ztPaGlqcz1DcBuLm5yYcdA1xdXeW4ZEGOjWFyXLImx8awvBqWbraD3YsVK4Zarc70jWFkZGSmbwqFEEKInHiePsbLy8tge2trazw8PPIsqxBCCPNntkWVra0t/v7+BAUF6S0PCgqiQYMGJkolhBCiMHiePqZ+/fqZ2u/cuZM6deoYvJ5KCCGE5TDbogpg7NixLFu2jB9//JHQ0FDef/99wsLCGDp06DOfa2dnx9SpUw0Ou7B0cmwMk+OSNTk2hslxMaygHJdn9TGTJk2iX79+uvZDhw7l5s2bjB07ltDQUH788UeWL1/OuHHjsr3PgnJs8pscl6zJsTFMjkvW5NgYltfHxWxn/0u3ePFiZs+eTXh4OFWrVuXrr7+mcePGpo4lhBCiEHhaHzNgwABu3LjBvn37dO3379/P+++/z/nz5/Hx8WHChAnZ+qJPCCFE4Wb2RZUQQgghhBBCmDOzHv4nhBBCCCGEEOZOiiohhBBCCCGEyAUpqoQQQgghhBAiF6SoEkIIIYQQQohcKLRF1eLFiylbtiz29vb4+/tz8OBBU0fKV7NmzaJu3bq4uLhQokQJunTpwqVLl/TaKIrCtGnT8PHxwcHBgaZNm3L+/HkTJTaNWbNmoVKpGDNmjG6ZJR+XO3fu8NZbb+Hh4YGjoyM1a9YkJCREt94Sj01qaiofffQRZcuWxcHBgXLlyjFjxgy0Wq2ujaUclwMHDtCpUyd8fHxQqVRs2bJFb312jkNSUhIjR46kWLFiODk58dprr3H79u18fBWmY+n9EkjflF3SN/1H+iXDpG9KY1b9klIIrVu3TrGxsVF++OEH5cKFC8ro0aMVJycn5ebNm6aOlm/atGmjrFixQjl37pxy6tQppUOHDkrp0qWV2NhYXZsvvvhCcXFxUTZt2qScPXtW6dGjh+Lt7a1ER0ebMHn+OX78uOLn56dUr15dGT16tG65pR6Xhw8fKmXKlFEGDBig/O9//1OuX7+u7Nq1S7ly5YqujSUem88++0zx8PBQfv/9d+X69evKL7/8ojg7Oyvz58/XtbGU47Jt2zZlypQpyqZNmxRA2bx5s9767ByHoUOHKiVLllSCgoKUv/76S2nWrJlSo0YNJTU1NZ9fTf6SfimN9E3PJn3Tf6Rfypr0TWnMqV8qlEVVvXr1lKFDh+otq1ixojJx4kQTJTK9yMhIBVD279+vKIqiaLVaxcvLS/niiy90bRITExU3Nzdl6dKlpoqZb2JiYpQKFSooQUFBSpMmTXQdlyUflwkTJigNGzbMcr2lHpsOHToogwYN0lvWtWtX5a233lIUxXKPS8bOKzvH4fHjx4qNjY2ybt06XZs7d+4oVlZWyo4dO/ItuylIv2SY9E36pG/SJ/1S1qRvyszU/VKhG/6XnJxMSEgIrVu31lveunVrjhw5YqJUphcVFQWAu7s7ANevXyciIkLvONnZ2dGkSROLOE7Dhw+nQ4cOtGzZUm+5JR+XrVu3UqdOHd58801KlChBrVq1+OGHH3TrLfXYNGzYkN27d3P58mUATp8+zaFDh2jfvj1gucclo+wch5CQEFJSUvTa+Pj4ULVq1UJ9rKRfypr0Tfqkb9In/VLWpG96tvzul6yNE9t83L9/H41Gg6enp95yT09PIiIiTJTKtBRFYezYsTRs2JCqVasC6I6FoeN08+bNfM+Yn9atW8dff/1FcHBwpnWWfFyuXbvGkiVLGDt2LJMnT+b48eOMGjUKOzs7+vXrZ7HHZsKECURFRVGxYkXUajUajYbPP/+cXr16AZb9nnlSdo5DREQEtra2FC1aNFObwvz3Wfolw6Rv0id9U2bSL2VN+qZny+9+qdAVVelUKpXeY0VRMi2zFCNGjODMmTMcOnQo0zpLO063bt1i9OjR7Ny5E3t7+yzbWdpxAdBqtdSpU4eZM2cCUKtWLc6fP8+SJUvo16+frp2lHZv169ezZs0aAgICqFKlCqdOnWLMmDH4+PjQv39/XTtLOy5ZeZ7jYCnHSt4j+qRv+o/0TYZJv5Q16ZuyL7/6pUI3/K9YsWKo1epM1WVkZGSmStUSjBw5kq1bt7J3715KlSqlW+7l5QVgcccpJCSEyMhI/P39sba2xtramv3797Nw4UKsra11r93SjguAt7c3lStX1ltWqVIlwsLCAMt9z4wfP56JEyfSs2dPqlWrRt++fXn//feZNWsWYLnHJaPsHAcvLy+Sk5N59OhRlm0KI+mXMpO+SZ/0TYZJv5Q16ZueLb/7pUJXVNna2uLv709QUJDe8qCgIBo0aGCiVPlPURRGjBhBYGAge/bsoWzZsnrry5Yti5eXl95xSk5OZv/+/YX6OLVo0YKzZ89y6tQp3U+dOnXo06cPp06doly5chZ5XABeffXVTFMbX758mTJlygCW+56Jj4/Hykr/T6VardZNW2upxyWj7BwHf39/bGxs9NqEh4dz7ty5Qn2spF/6j/RNhknfZJj0S1mTvunZ8r1fytG0FgVE+tS1y5cvVy5cuKCMGTNGcXJyUm7cuGHqaPnmvffeU9zc3JR9+/Yp4eHhup/4+Hhdmy+++EJxc3NTAgMDlbNnzyq9evUqdFNtZseTMywpiuUel+PHjyvW1tbK559/rvz999/Kzz//rDg6Oipr1qzRtbHEY9O/f3+lZMmSumlrAwMDlWLFiikffvihro2lHJeYmBjl5MmTysmTJxVAmTdvnnLy5EndtODZOQ5Dhw5VSpUqpezatUv566+/lObNm1vUlOqW3C8pivRNOSF9k/RLTyN9Uxpz6pcKZVGlKIry7bffKmXKlFFsbW2V2rVr66ZrtRSAwZ8VK1bo2mi1WmXq1KmKl5eXYmdnpzRu3Fg5e/as6UKbSMaOy5KPy2+//aZUrVpVsbOzUypWrKh8//33eust8dhER0cro0ePVkqXLq3Y29sr5cqVU6ZMmaIkJSXp2ljKcdm7d6/Bvyv9+/dXFCV7xyEhIUEZMWKE4u7urjg4OCgdO3ZUwsLCTPBq8p+l90uKIn1TTkjflEb6JcOkb0pjTv2SSlEUJWfntoQQQgghhBBCpCt011QJIYQQQgghRH6SokoIIYQQQgghckGKKiGEEEIIIYTIBSmqhBBCCCGEECIXpKgSQgghhBBCiFyQokoIIYQQQgghckGKKiGEEEIIIYTIBSmqhBBCCCGEECIXpKgSQgghhBBCiFyQokoIIYQQQgghckGKKiGEEEIIIYTIBSmqhBBCCCGEECIXpKgSQgghhBBCiFyQokoIIYQQQgghckGKKiGEEEIIIYTIBSmqhBBCCCGEECIXpKgSQgghhBBCiFyQokoIIYQQQgghckGKKiGEEEIIIYTIBSmqhBBCCCGEECIXpKgSQgghhBBCiFyQokoIIYQQQgghckGKKiGEEEIIIYTIBSmqhBBCCCGEECIXpKgSQgghhBBCiFyQokoIIYQQQgghckGKKiGEEEIIIYTIBSmqhBBCCCGEECIXpKgycyqVimnTpuX4efHx8UybNo19+/ZlWrdy5UpUKhU3btzIdT5jMJSnadOmNG3aNEfbuXDhAtOmTcvx68q4rxs3bqBSqfjqq69ytJ1nmTlzJlu2bMm0fN++fahUKoO/q/zw0UcfUbp0aaytrSlSpIhJMqQLCAhg/vz5Btc977+FgiSr90h2pL+PNm7c+My2AwYMwM/P77n2I4QQQojMrE0dQOSN+Ph4pk+fDpCpOOnQoQNHjx7F29vbBMmyZ/HixTl+zoULF5g+fTpNmzbN0QfG59nX85g5cybdunWjS5cuestr167N0aNHqVy5cr7keNKvv/7K559/zpQpU2jXrh12dnb5nuFJAQEBnDt3jjFjxmRad/ToUUqVKpX/ofJRVu8RY/v4448ZPXp0nu5DCCGEsCRSVFmg4sWLU7x4cVPHeKr8KDDi4+NxdHQ0STHzJFdXV1555RWT7PvcuXMAjBo1ihIlSpgkQ3aZ6hgVRi+88IKpIwghhBCFisUM/7t48SK9evXC09MTOzs7SpcuTb9+/UhKSgJg2rRpqFSqTM8zNDTNz8+Pjh078vvvv1OrVi0cHByoVKkSv//+u+45lSpVwsnJiXr16nHixAm9bWY1tC07Q3Lu3bvHsGHDqFy5Ms7OzpQoUYLmzZtz8OBBXZsbN27oiqbp06ejUqlQqVQMGDDA4GsaM2YMTk5OREdHZ9pfjx498PT0JCUlRbds/fr11K9fHycnJ5ydnWnTpg0nT558au50x44d49VXX8Xe3h4fHx8mTZqkt+10ho7RkiVLqFGjBs7Ozri4uFCxYkUmT56se01vvvkmAM2aNdO95pUrV+q2V7VqVQ4cOECDBg1wdHRk0KBBWe4LQKvV8vnnn1O6dGns7e2pU6cOu3fv1muT1e8s4/tJpVIRFxfHqlWrdNnS95nV8L+tW7dSv359HB0dcXFxoVWrVhw9etTgfs6fP0+vXr1wc3PD09OTQYMGERUVlSnXk/z8/Pjoo48A8PT01Btel9VQOz8/P937CP57L+3du5f33nuPYsWK4eHhQdeuXbl7926m5wcEBFC/fn2cnZ1xdnamZs2aLF++HEj7Pfzxxx/cvHlTd4wyHsOMmc6dO0fnzp0pWrQo9vb21KxZk1WrVum1ST++a9euZcqUKfj4+ODq6krLli25dOnSU48R/HeMz5w5w5tvvombmxvu7u6MHTuW1NRULl26RNu2bXFxccHPz4/Zs2frPT8xMZEPPviAmjVr6p5bv359fv31V712T3uPANy5c4chQ4bg6+uLra0tPj4+dOvWjX/++UdvOykpKc98nYbetyqVihEjRrB69WoqVaqEo6MjNWrU0P1de9Kvv/5K9erVsbOzo1y5cixYsCDLv6FCCCGEJbCIour06dPUrVuXY8eOMWPGDLZv386sWbNISkoiOTn5ubc5adIkJkyYQGBgIG5ubnTt2pWpU6eybNkyZs6cyc8//0xUVBQdO3YkISHBKK/l4cOHAEydOpU//viDFStWUK5cOZo2bar7UO7t7c2OHTsAGDx4MEePHuXo0aN8/PHHBrc5aNAg4uPj2bBhg97yx48f8+uvv/LWW29hY2MDpA1P6tWrF5UrV2bDhg2sXr2amJgYGjVqxIULF56a/cKFC7Ro0YLHjx+zcuVKli5dysmTJ/nss8+e+brXrVvHsGHDaNKkCZs3b2bLli28//77xMXFAWlDGmfOnAnAt99+q3vNHTp00G0jPDyct956i969e7Nt2zaGDRv21H0uWrSIHTt2MH/+fNasWYOVlRXt2rXLVNhkx9GjR3FwcKB9+/a6bE8bdhgQEEDnzp1xdXVl7dq1LF++nEePHtG0aVMOHTqUqf0bb7zBiy++yKZNm5g4cSIBAQG8//77T820efNmBg8eDMCOHTs4evQob7/9do5fG8Dbb7+NjY0NAQEBzJ49m3379vHWW2/ptfnkk0/o06cPPj4+rFy5ks2bN9O/f39u3rwJpA3DfPXVV/Hy8tIdo6cd60uXLtGgQQPOnz/PwoULCQwMpHLlygwYMCBTYQMwefJkbt68ybJly/j+++/5+++/6dSpExqNJluvsXv37tSoUYNNmzbxzjvv8PXXX/P+++/TpUsXOnTowObNm2nevLnub0K6pKQkHj58yLhx49iyZQtr166lYcOGdO3alZ9++knX7mnvkTt37lC3bl02b97M2LFj2b59O/Pnz8fNzY1Hjx4Z7XX+8ccfLFq0iBkzZrBp0ybc3d15/fXXuXbtmq7Njh076Nq1Kx4eHqxfv57Zs2ezdu3aTMWsEEIIYVEUC9C8eXOlSJEiSmRkZJZtpk6dqhg6HCtWrFAA5fr167plZcqUURwcHJTbt2/rlp06dUoBFG9vbyUuLk63fMuWLQqgbN26VbesSZMmSpMmTTLtq3///kqZMmX0lgHK1KlTs8ydmpqqpKSkKC1atFBef/113fJ79+5l+VxDr6l27dpKgwYN9NotXrxYAZSzZ88qiqIoYWFhirW1tTJy5Ei9djExMYqXl5fSvXv3LHMqiqL06NFDcXBwUCIiIvTyV6xYMVOejMdoxIgRSpEiRZ66/V9++UUBlL1792Za16RJEwVQdu/ebXDdk/u6fv26Aig+Pj5KQkKCbnl0dLTi7u6utGzZUrfM0O9MUQy/n5ycnJT+/ftnart371693BqNRvHx8VGqVaumaDQaXbuYmBilRIkSer+n9P3Mnj1bb5vDhg1T7O3tFa1Wm2l/hnLeu3dPb3lW750yZcrovYb099KwYcP02s2ePVsBlPDwcEVRFOXatWuKWq1W+vTp89Q8HTp0MHg8DWXq2bOnYmdnp4SFhem1a9euneLo6Kg8fvxYUZT/jm/79u312m3YsEEBlKNHjz41U/oxmjt3rt7ymjVrKoASGBioW5aSkqIUL15c6dq1a5bbS/83O3jwYKVWrVp667J6jwwaNEixsbFRLly4kOV2c/I6s/pb4+npqURHR+uWRUREKFZWVsqsWbN0y+rWrav4+voqSUlJumUxMTGKh4eHwb+hQgghhCUo9Geq4uPj2b9/P927dzfqdUQ1a9akZMmSuseVKlUC0oYwOTo6Zlqe/m28MSxdupTatWtjb2+PtbU1NjY27N69m9DQ0Ofe5sCBAzly5IjeMKEVK1ZQt25dqlatCsCff/5Jamoq/fr1IzU1Vfdjb29PkyZNnjl73d69e2nRogWenp66ZWq1mh49ejwzX7169Xj8+DG9evXi119/5f79+zl+jUWLFqV58+bZbt+1a1fs7e11j11cXOjUqRMHDhzI9tmN53Hp0iXu3r1L3759sbL675+os7Mzb7zxBseOHSM+Pl7vOa+99pre4+rVq5OYmEhkZGSe5XzW/uG/931QUBAajYbhw4cbbZ979uyhRYsW+Pr66i0fMGAA8fHxmc5yPSvjs3Ts2FHvcaVKlVCpVLRr1063zNramvLly2fa5i+//MKrr76Ks7Oz7t/s8uXLs/1vdvv27TRr1kz39+RpcvM6mzVrhouLi+6xp6cnJUqU0D03Li6OEydO0KVLF2xtbXXtnJ2d6dSpU7ZeixBCCFEYFfqi6tGjR2g0GqPPGubu7q73OP0DRlbLExMTjbLfefPm8d577/Hyyy+zadMmjh07RnBwMG3bts3VEMM+ffpgZ2enuwbpwoULBAcHM3DgQF2b9Gs36tati42Njd7P+vXrn1noPHjwAC8vr0zLDS3LqG/fvvz444/cvHmTN954gxIlSvDyyy8TFBSU7deY09kOs8qanJxMbGxsjraVEw8ePAAM5/Xx8UGr1WYa8uXh4aH3OH0WP2MNO32WZ+3/3r17AEb9d/jgwYMsj1H6+pxkfBZD/7YdHR31Cu/05U/+ew8MDKR79+6ULFmSNWvWcPToUYKDgxk0aFC2/y7cu3cv28cuN68z43PTn5/+3EePHqEoit4XI+kMLRNCCCEsRaGf/c/d3R21Ws3t27ef2i79g1FSUpLetNLPc0bkWezt7Q1OIpCdfa1Zs4amTZuyZMkSveUxMTG5ylS0aFE6d+7MTz/9xGeffcaKFSuwt7enV69eujbFihUDYOPGjZQpUybH+/Dw8CAiIiLTckPLDBk4cCADBw4kLi6OAwcOMHXqVDp27Mjly5ezlSenF9FnldXW1hZnZ2cg7XeZPtnJk3Lzvkn/YBseHp5p3d27d7GysqJo0aLPvf3ssLOzM/i6MhYq2ZV+lvj27duZziw9Lw8PjyyPEfz3fjW1NWvWULZsWdavX6/3HjR0fLNSvHjxZ/4Nyw9FixZFpVJlmhwDsv/vWAghhCiMCv2ZKgcHB5o0acIvv/zy1A+66TNhnTlzRm/5b7/9ZvRMfn5+XL58We9D1YMHDzhy5Mgzn6tSqTLdS+jMmTOZhjo9z5mKgQMHcvfuXbZt28aaNWt4/fXX9W4G26ZNG6ytrbl69Sp16tQx+PM0zZo1Y/fu3XofyDQaDevXr892RgAnJyfatWvHlClTSE5O5vz584Dxz84EBgbqnUmIiYnht99+o1GjRqjVaiDtdxkZGan3mpKTk/nzzz8zbe/Jb/yf5qWXXqJkyZIEBASgKIpueVxcHJs2bdLNCJiX/Pz8Mv1b2LNnz3OfoWvdujVqtTrTlwEZZfcYAbRo0YI9e/ZkmmXwp59+wtHR0WymYFepVNja2uoVVBEREZlm/4OsX3+7du3Yu3dvtmYrzEtOTk7UqVOHLVu26E3yExsba3CWQCGEEMJSFPqiCtKGzKWkpPDyyy/zww8/sHfvXtatW0fv3r11Z3jat2+Pu7s7gwcPZsuWLfz+++9069aNW7duGT1P3759efjwIW+99RY7d+5k7dq1tGzZEldX12c+t2PHjuzcuZOpU6eyZ88elixZQps2bShbtqxeOxcXF8qUKcOvv/7Kzp07OXHihN608Ia0bt2aUqVKMWzYMCIiIvSG/kHaB+0ZM2YwZcoUhg4dypYtW9i/fz8bNmxg3LhxTJ069anbT5++u3nz5qxfv57ffvuNDh066Gbwe5p33nmHUaNGsX79eg4cOMCGDRuYNm0abm5u1K1bF0B37df333/PoUOHOHHixHOfWYG0671atWrF5s2b2bRpEy1atCA6Olp3U2VIm3JerVbTs2dPtm3bRmBgIK1btzZ4zVW1atXYt28fv/32GydOnMjyA7KVlRWzZ8/m1KlTdOzYka1bt/LLL7/QrFkzHj9+zBdffPHcrym7+vbty/bt2/nkk0/YvXs333zzDe+99x5ubm7PtT0/Pz8mT57M6tWrefPNNwkMDNRt98n3TbVq1YiMjGTJkiUcP3480+0InjR16lRsbGxo1qwZP//8M9u3b+ett97ijz/+0L03zEHHjh25dOkSw4YNY8+ePaxatYqGDRsaHLqY1XtkxowZFCtWjMaNG7NgwQL27NlDYGAgQ4YM4eLFi/n6embMmMGdO3do06YNW7ZsYdOmTbRs2RJnZ2eZUl0IIYTFsoiiqkaNGhw/fhx/f38mTZpE27ZtmTBhAnZ2drprnlxdXdmxYwcuLi689dZbDB06lKpVqzJlyhSj53n11VdZtWoV58+fp3Pnznz22WdMmjTJ4L2SMpoyZQoffPABy5cvp0OHDixbtoylS5fSsGHDTG2XL1+Oo6Mjr732GnXr1jV436EnWVlZ0a9fP90QrRYtWmRqM2nSJDZu3Mjly5fp378/bdq04cMPP+TmzZs0btz4qduvWrUqu3btwtXVlf79+zNkyBCqV6+e5VTvT2rUqBHnzp1j9OjRtGrVivfff58XX3yRgwcP6oaWlS1blvnz53P69GmaNm1K3bp1c3WmccSIEbRq1YpRo0bRu3dvUlNT+eOPP3j11Vd1bcqWLcuvv/7K48eP6datG+PHj+fNN9+kX79+mba3YMECKlSoQM+ePalbty7vvvtulvvu3bs3W7Zs4cGDB/To0YOBAwfi6urK3r17Df6ujW38+PGMHz+elStX0qlTJzZt2sSGDRv0zlzm1IwZM/jpp5+4efMmffr0oUuXLqxYsULvC4HRo0fTrVs3Jk+ezCuvvKIrmA156aWXOHLkCC+99BLDhw+nS5cunDt3jhUrVjB+/PjnzmlsAwcO5IsvvmD79u20b9+eL7/8kokTJ9K7d+9MbbN6j5QsWZLjx4/TsWNHvvjiC9q2bcvIkSOJiorKdK1XXmvbti2bNm3SvTfHjh3L66+/TufOnXP1/hBCCCEKMpXy5PgiIYQQIodSUlJ0M6Lu3LnT1HGEEEKIfFfoJ6oQQghhXIMHD6ZVq1Z4e3sTERHB0qVLCQ0NZcGCBaaOJoQQQpiEFFVCCCFyJCYmhnHjxnHv3j1sbGyoXbs227Zto2XLlqaOJoQQQpiEDP8TQgghhBBCiFywiIkqhBBCCCGEECKvSFElhBBCCCGEELlQaK+p0mq13L17FxcXF7l3ihBC5CNFUYiJicHHxwcrK/nu7knSNwkhhGnkdd9UaIuqu3fv4uvra+oYQghhsW7dukWpUqVMHcOsSN8khBCmlVd9U6EtqlxcXAC4fv16vt8cM6OUlBR27txJ69atsbGxMWkWc8sjWcw/i7nlkSzmnyU6OhpfX1/d32HxH+mbzD+LueWRLOafxdzySBbD8rpvKrRFVfqwChcXF1xdXU2aJSUlBUdHR1xdXU3+hjK3PJLF/LOYWx7JYv5Z0snwtsykbzL/LOaWR7KYfxZzyyNZni6v+iYZ7C6EEEIIIYQQuSBFlRBCCCGEEELkghRVQgghhBBCCJELhfaaquzSaDSkpKTk6T5SUlKwtrYmMTERjUZjlG3a2NigVquNsi0hhBD5x9HRkZSUFBITE02aIy/6psKQxdzySBbzz2JueSw1i6k/G1tsUaUoChERETx+/Dhf9uXl5cWtW7eMenFckSJF8PLykovBhRCiAFAUhYcPHxIQEMD9+/d59OiRyfPkRd9U0LOYWx7JYv5ZzC2PJWcx5Wdjiy2q0guqEiVK4OjomKcHX6vVEhsbi7Ozs1FuNqYoCvHx8URGRgLg7e2d620KIYTIWxEREcTFxVGyZEnKlClj8pmwjN03FZYs5pZHsph/FnPLY4lZzOGzsUUWVRqNRldQeXh45Pn+tFotycnJ2NvbG+0N5eDgAEBkZCQlSpSQoYBCCGHGnux3bt68iYODA9bWpu2C86JvKgxZzC2PZDH/LOaWx1KzmPqzsenfhSaQfg2Vo6OjiZPkTnr+vL4mTAghRO6k/51O7/SFEEIYnyk/G1tkUZXO1ONMc6ug5xdCCEsjf7eFECLvmPJvrEUXVUIIIYQQQgiRW1JUCSGEEEIIIUQuSFGVSxqthn039rH27Fr23diHRmv6eyUIIYQonPK7z1EUhSFDhuDu7o5KpeLUqVN5ur/CZMCAAXTp0kX3uGnTpowZM8bo+5k2bRo1a9bMcr/GNH36dBo1apQn2xbPx8/Pj/nz55s6hsBCZ/8zlsDQQEbvGM3t6Nu6ZaVcS7Gg7QK6VupqwmRCCCEKG1P0OTt27GDlypXs27ePcuXKUaxYsTzZjyUIDAzM9jT6TZs2pWbNmtn6sDxu3DhGjhyZy3SZqVQqNm/erFegffDBB/Tv39/o+yqM9u3bR7NmzXj06BFFihTJ9fZWrlzJmDFjMt1fNTg4GCcnp1xvX+SenKl6ToGhgXTb0E2vcwO4E32Hbhu6ERgaaKJkQgghChtT9TlXr17F29ubBg0a4OXlZXAa+OTk5DzZd2Hj7u6Oi4uL0banKAqpqak4Ozvny+1hAJydnXF3d8+XfVmK3P77KV68eIGczbowzlwtRdVz0Gg1jN4xGgUl07r0ZWN2jJGhgEIIIXLNVH3OgAEDGDlyJGFhYahUKvz8/IC0sygjRoxg7NixFCtWjFatWgFw4cIF2rdvj7OzM56envTt25f79+/rthcXF0e/fv1wdnbG29ubuXPnZhoSp1ar2bJli16OIkWKsHLlSt3jO3fu0KNHD4oWLYqHhwedO3fmxo0berm7dOnCV199hbe3Nx4eHgwfPlzvQ1xSUhIffvghvr6+2NnZUaFCBZYvX46iKJQvX565c+fqZTh37hxWVlZcvXrV4LHSaDSMHTuWIkWK4OHhwYcffoii6P++Mr7WxYsXU6FCBezt7fH09KRbt266/Pv372fBggWoVCrUajVhYWHs27cPlUrFn3/+SZ06dbCzs+PgwYOZhv+lmz59OiVKlMDV1ZV3331X78O7oSFjNWvWZNq0abr1AK+//rre7z7j8D+tVsuMGTMoVaoUdnZ21KxZkx07dujW37hxA5VKRWBgIM2aNcPR0ZEaNWpw9OhRg8cx3ePHjxkyZAienp7Y29tTtWpVfv/9d936TZs2Ua1aNTw9PSlXrlym35efnx8zZ85k0KBBuLi4ULp0ab7//nu9Nrdv36Znz564u7vj5OREnTp1+N///qdb/9tvv+Hv74+9vT3lypVj+vTppKam6tarVCqWLVvG66+/jqOjIy+99BLbtm3Tve5mzZoBULRoUVQqFQMGDACy/vczb948qlWrhpOTE76+vgwbNozY2Fgg7azXwIEDiYqKQqVSoVKp9H5XT/4uw8LC6NKlC6VKlaJIkSJ0796df/75R7c+/f2yevVq/Pz8cHNzo2fPnsTExDz1d3L48GGaNGmCo6MjRYsWpU2bNjx69MhgBtB/P0Hav+2lS5fSuXNnnJycdO+bpUuX6j3vr7/+QqVSce3aNQCioqIYMmSI7r3cvHlzTp8+/dSspiLD/54QnxLPxfsXn9nuxN0Tmb4tfJKCwq3oWyw/uZw6PnXQarXExcXhFOdk8MZnFYtVxNGm4H3LIIQQIney0+/ktM95luz2OQsWLOCFF17g+++/Jzg4WO9GmqtWreK9997j8OHDKIpCeHg4TZo04Z133mHevHkkJCQwYcIEunfvzp49ewAYP348e/fuZfPmzXh5eTF58mRCQkIMFgRZiY+Pp1mzZjRq1IgDBw5gbW3NZ599Rtu2bTlz5gy2trYA7N27F29vb/bu3cuVK1fo0aMHNWvW5J133gGgX79+HD16lIULF1KjRg2uX7/O/fv3UalUDBo0iJUrV+raAvz44480atSIF154wWCuuXPn8uOPP7J8+XIqV67M3Llz2bx5M82bNzfY/sSJE4waNYrVq1fToEEDHj58yMGDB3XH/fLly1StWpUZM2ag1Wqxs7PTFagffvghX331FeXKlaNIkSLs378/0/Z3796Nvb09e/fu5caNGwwcOJBixYrx+eefZ+s4BwcHU6JECVasWEHbtm2zvInqggULmDt3Lt999x21atXixx9/5LXXXuP8+fNUqFBB127KlCl89dVXVKhQgSlTptCrVy+uXLli8MynVqulXbt2xMTEsGbNGl544QUuXLigyxASEkL37t2ZOnUq7du358yZM4wYMQIPDw9d4ZL+O/n000+ZPHkyGzdu5L333qNx48ZUrFiR2NhYmjRpQsmSJdm6dSteXl789ddfaLVaAP7880/eeustFi5cSKNGjbh69SpDhgwBYOrUqbp9TJ8+ndmzZzNnzhwWLlzIu+++S+vWrfH19WXTpk288cYbXLp0CVdXV7171GX89wNgZWXFwoUL8fPz4/r16wwbNowPP/yQxYsX06BBA+bPn88nn3zCpUuXgLSzhhkpikKXLl1wcnLi999/x87OjhEjRtCjRw/27duna3f16lW2bNnC77//zqNHj+jevTtffPFFlu+PU6dO0aJFCwYNGsTChQuxtrZm7969aDQ5+yJn6tSpzJo1i6+//hq1Wk1CQgI///wzQ4cO1bUJCAigfv36lCtXDkVR6NChA+7u7mzbtg03Nze+++47WrRoweXLl83urKkUVU+4eP8i/t/7G2177/7+brbahQwJobZ3baPtVwghRMFgzH7H2H2Om5sbLi4uqNVqvLy89NaVL1+e2bNn6x5/8skn1K5dm5kzZ+qW/fjjj/j6+nL58mV8fHxYvnw5P/30k+6b+VWrVlGqVKlsZU63bt06rKysWLZsme5+NCtWrKBIkSLs27eP1q1bA2lnBxYtWoRaraZixYp06NCB3bt3884773D58mU2bNhAUFAQLVu2BKBcuXK6fQwcOJBPPvmEkJAQmjVrRkpKCmvWrGHOnDlZ5po/fz6TJk3ijTfeAGDp0qX8+eefWbYPCwvDycmJjh074uLiQpkyZahVqxaQdtxtbW1xdHTEy8sLrVZLdHS07rkzZszQHcOs2Nra8uOPP+Lo6EiVKlWYMWMG48eP59NPPzX45W5GxYsXB9LOEmb83T/pq6++YsKECfTs2ROAL7/8kr179zJ//ny+/fZbXbtx48bRoUMHIK0QqVKlCleuXKFixYqZtrlr1y6OHz9OaGgoL774IqD/+5k3bx4tWrTgo48+Ijo6mtq1a3Px4kXmzJmjV1S1b9+eYcOGATBhwgS+/vpr9u3bR8WKFQkICODevXsEBwfrPpiXL19e99zPP/+ciRMn6q4fK1euHJ9++ikffvihXlE1YMAAevXqpXvOokWLOH78OO3bt9dtt0SJEpmuqcr47wfQO4tZtmxZPv30U9577z0WL16Mra0tbm5uqFSqp/4+du3axZkzZ7h69Spubm64urqyevVqqlSpQnBwMHXr1gXSCteVK1fqhqP27duX3bt3Z1lUzZ49mzp16rB48WLdsipVqmSZIyu9e/dm0KBBusd9+vRh3rx53Lx5kzJlyqDValm3bh2TJ08G0r4cOXv2LJGRkdjZ2QFp77ktW7awceNGXaFrLqSoekLFYhUJGRLyzHYn7p7IVuf1Xcfv9M9UOWV9pkoIIYTlyU6/k9M+Jzv7zK06dfT3ExISwt69ew1+e3716lUSEhJITk6mfv36uuXu7u689NJLOdpvSEgIV65cyXRtUmJiot7QvCpVquidXfH29ubs2bNA2rfuarWaJk2aGNyHt7c37du3Z82aNTRr1ozff/+dxMRE3nzzTYPto6KiCA8P13tt1tbW1KlTJ9MQwHStWrWiTJkylCtXjrZt29K2bVvdMLJnyXjsDalRo4beturXr09sbCy3bt2iTJkyz3x+dkRHR3P37l1effVVveWvvvpqpuFZ1atX1/2/t7c3AJGRkQaLqlOnTlGqVCldQZVRaGgonTt3zrTP+fPno9FodL/3J/eZXoxERkbq9lGrVq0sz3SEhIQQHBysV2RoNBoSExOJj4/XHdsn9+Hk5ISzs7NuH09j6He4d+9eZs6cyYULF4iOjiY1NZXExETd58fsCA0NxdfXF19fX10hXrlyZYoUKUJoaKiuqPLz89P7N+Tt7f3U3KdOncry/Z8TGV93rVq1qFixImvXrmXixIns37+fyMhIunfvDqT9HmJjYzNdM5iQkJDlUFxTkqLqCY42jtn69q6GZw0+PfApd6LvGBzjrkJFKddSDK41GLWVWvctk6ura7a+IRJCCGEZstPv5LTPyQ8ZP+RptVo6derEl19+mamtt7c3f//9d7a2q1KpMhUiT14LpdVq8ff35+eff8703PSzK0CmWfZUKpVuaNeTw7CyMnjwYPr168eiRYtYsWIFPXr0MOpkAC4uLvz111/s27ePnTt38sknnzBt2jSCg4OfOVNcbmZ6Sz+7Z2Vl9dTj/DzbTKcoSqZlT/4+0tel/z4yetbvx9D2DRWvuXkPaLVapk+fTteumWfVtLe3z9Y+nibj7/DmzZu0b9+eoUOH8umnn+Lu7s6hQ4cYPHhwjn4vho6NoeU5zf2s45Xd95Oh926fPn0ICAhg4sSJBAQE0KZNG90so1qtFm9vb72hi+mMMaOisckn/OegtlKzoO0CIK0ze1L64/lt5+db5yaEEKLwKgh9Tu3atTl//jx+fn6UL19e78fJyYny5ctjY2PDsWPHdM959OgRly9f1ttO8eLFCQ8P1z3++++/iY+P19vP33//TYkSJTLtx83NLVtZq1WrhlarNXgtUrr27dvj5OTE0qVL2b59u96QpYzc3Nzw9vbWe22pqamEhDz9DKS1tTUtW7Zk9uzZnDlzhhs3buiuP7O1tc3x9SpPOn36NAkJCbrHx44dw9nZWTfcMuNxjo6O5vr163rbsLGxeWoGV1dXfHx8OHTokN7yI0eOUKlSpefOXr16dW7fvp3pvZGucuXKBvf54osvZnntl6F9nDp1iocPHxpcX7t2bS5dupTpPVa+fPlsfzmefn1fdn6PJ06cIDU1lblz5/LKK6/w4osvcvfu3Uzbe9a2KleuTFhYGLdu3dItu3DhAlFRUbn+nezevTvL9dl5P2Wld+/enD17lpCQEDZu3EifPn1062rXrk1ERATW1taZfg/meHsHKaqeU9dKXdnYfSMlXUvqLS/lWoqN3TfKfaqEEEIYjbn3OcOHD+fhw4f06tWL48ePc+3aNXbu3MmgQYPQaDQ4OzszePBgxo8fz+7duzl37hwDBgzI9AG1WbNmLFq0iL/++osTJ04wdOhQvW/V+/TpQ7FixejcuTMHDx7k+vXr7N+/n9GjR3P7dtaTeTzJz8+P/v37M2jQILZs2cL169fZt28fGzZs0LVRq9X06tWLyZMnU758eb2hfYaMHj2aL774gs2bN3Px4kWGDRuW6X5CT/r9999ZuHAhp06d4ubNm/z0009otVrdcEg/Pz/+97//cePGDe7fv5+tsx9PSk5OZvDgwVy4cIHt27czdepURowYoTvezZs3Z/Xq1Rw8eJBz587Rv3//TAWJn58fu3fvJiIiQjfLW0bjx4/nyy+/ZP369Vy6dImJEydy6tQpRo8enaO8T2rSpAmNGzfmjTfeICgoiOvXr7N9+3bdrIIffPABu3fv5rPPPuPKlSusWrWKRYsWMW7cuGzvo1evXnh5edGlSxcOHz7MtWvX2LRpk25Wwk8++YSffvqJadOmcf78eUJDQ1m/fj0fffRRtvdRpkwZVCoVv//+O/fu3dPN5GfICy+8QGpqKt988w3Xrl1j9erVmWbF8/PzIzY2lt27d3P//n29LxvStWzZkurVq9O3b19Onz7N8ePH6devH02aNMnWsNGsTJo0ieDgYIYNG8aZM2e4ePEiS5Ys0U2ekp33U1bKli1LgwYNGDx4MKmpqXpDO1u2bEn9+vXp0qULf/75Jzdu3ODIkSN89NFHnDhx4rlfT16RoioXulbqyo3RN9jbfy8BXQPY238v10dfN3nnJoQQovAx5z7Hx8eHw4cPo9FoaNOmDVWrVmX06NG4ubnpPsjPmTOHxo0b89prr9GyZUsaNmyIv7/+JB1fffUVvr6+NG7cmN69ezNu3Di9YXeOjo4cOHCA0qVL07VrVypVqsSgQYNISEjA1dU123mXLFlCt27dGDZsGBUrVuSdd94hLi5Or03fvn1JTk5+6lmqdB988AH9+vVjwIAB1K9fHxcXF15//fUs2xcpUoTAwECaN29OpUqVWLp0KWvXrtVd/D9u3DjUajWVK1fG09Mz2wVjuhYtWlChQgUaN25M9+7d6dSpk9701pMmTaJx48Z07NiR9u3b06VLl0wzG86dO5egoCB8fX11k2hkNGrUKD744AM++OADqlWrxo4dO9i6davezH/PY9OmTdStW5devXpRuXJlPvzwQ91Zmtq1a7NhwwbWr19PgwYNmDZtGjNmzNCbpOJZbG1t2blzJyVKlKB9+/ZUq1aNL774QlcItGnTht9//52goCDq1q3LK6+8wrx583J0PVrJkiWZPn06EydOxNPTkxEjRmTZtmbNmsybN48vv/ySqlWr8vPPPzNr1iy9Ng0aNGDo0KH06NGD4sWLZ5roAtKG8W3ZsoUiRYrQoUMHWrduTbly5Vi/fn22cxvy4osvsnPnTk6fPk29evWoX78+v/76q272xuy8n56mT58+nD59mq5du+oNNVSpVGzbto3GjRszaNAgXnzxRXr27MmNGzfw9PTM1WvKCyolq6soC7jo6Gjc3Ny4f/9+pgvcEhMTuX79OmXLltUbG5tX8uqaqud9HSkpKWzbto327dtn++7ueUWymH8Wc8sjWcw/S/rf36ioqBx90C3M0v9ely5dmtDQUGrWrGlwOun8ZA7X+zZt2lT3gdLUWZ6k1WrZuXMnnTp14vbt2yb9AGcOvyfJUrDyWHKWp302zuu+SSaqEEIIIYT4V1JSEjdv3mTmzJm8+eabZvmNuBDC/Ji+tBdCCFFoaLQaDt48aOoYQjy3tWvXUqlSJaKjow3OZiiEKHjyo2/Kl6LqwIEDdOrUCR8fH914z2fZv38//v7+2NvbU65cuUwX7AkhhDAvgaGB+C3wo2NAR1NHyRbpm0xv3759zJ8/39Qx9AwYMICUlBT27dtHyZIln/0EIYRZS++b5nyet31TvhRVcXFx1KhRg0WLFmWr/fXr12nfvj2NGjXi5MmTTJ48mVGjRrFp06Y8TiqEEOJ5BIYG0m1DN25H5+yCelOSvkkIIQo3Xd8UdZtPsr6LglHkyzVV7dq1o127dtluv3TpUkqXLq379qpSpUqcOHGCr776ijfeeCOPUgohhHgeGq2G0TtGG7wxrTmTvkkIIQqvJ/um1lehTkTe7s8sJ6o4evQorVu31lvWpk0bli9fTkpKisGZrZKSkkhKStI9jo6OBtJmxMp4V+eUlBQURUGr1eb43g/PI32CxfR9GotWq0VRFFJSUrJ9PwD47y7Xz3v3dGOSLIaZUxYwrzySxTBTZtl/c7/eGapicXA/31Pkvdz0TcnJyWi1Wt200MbuD55HXvVNBT1Leo70/5o6j2Qx/yzpOdL/a+o8lpzlyc/Gh24fSuubFPh0DzysBITm3b7NsqiKiIjINNuOp6cnqamp3L9/H29v70zPmTVrFtOnT8+0fO/evXr3uIC0u5h7eXkRGxtLcnKyccM/RUxMjFG3l5ycTEJCAgcOHCA1NTXHzw8KCjJqntyQLIaZUxYwrzySxbD8yqJRNFyIvcCj1EfcSrilW17uIWxcDbXzJUX+yk3fVKZMGZYuXUpCQgKQ9sVfTr4My0vG7ptyw5yygHnlkSyGmVMWMK88lpgl/bPxsu3L2HVvFwCtr0I5Pwj+AMjDQQVmWVRB2g2/npRe6WZcnm7SpEmMHTtW9zg6OhpfX1+aNWtm8D5Vt27dwtnZOV/uU6UoCjExMbi4uGSZ/3kkJibi4OBA48aNc3yfqqCgIFq1amXy+9lIFvPPYm55JIvps2y+uJmxQWO5E3NHb3mtu7D9Z7hjm6e7N6nn7ZuSk5P5559/8PX15fLly7i6upq8qMqrvqmgZzG3PJLF/LOYWx5LzhIZFcnD1IcsCFvAzbiboMCXSXBuBhTdnbf7NsuiysvLi4gI/YGPkZGRWFtbZyqQ0tnZ2WFnZ5dpuY2NTaYPGBqNBpVKhZWVVb7ciCz9dGf6Po3FysoKlUpl8DVmx/M+Ly9IFsPMKQuYVx7JYlheZwkMDaRnYM9M10+1uAqb10NoMWjXDViYZxFMJjd9U2JiIvfu3dMVUsbuD57H8/ZN6TfsTb+2zM/PjzFjxjBmzBijZhkwYACPHz/WzcqYcb/GlHFfedVvPw9LzaJSqdi8eTNdunQxeZbsMKc8lprlUcIjbsfcxiZZw+8/w5hqMNAXHg8Dn1/Bc0Ge7t4871NVv379TENYdu7cSZ06dczmg4sQQliarCak6HEWtv0Mh32heX946JjFBgo46ZsMCw4OZsiQIdlq6+fnl+2iaMGCBaxcufL5gxlw48YNVCoVp06dyvN9FVYBAQG4u7sbbXvTpk2jZs2amZaHh4fnaCIZYdkUReFWdNpQ9CKJ8EIUfOkJJVuB349QYT6o8ngupXwpqmJjYzl16pTuj9j169c5deoUYWFhQNrwiH79+unaDx06lJs3bzJ27FhCQ0P58ccfWb58OePGjcuPuEIIIQw4GHYw05TpI4/Buk2wvip06g1xmQcMmK0C2zft2gWVK6f91wwUL14807XLuaHRaNBqtbi5uVGkSBGjbfdp8nNfliK316x7eXkZHIFk7sxh4iJLFJscS7ImGacksNXAlWEQ0xbKfg1+qyE/BkHmS1F14sQJatWqRa1atQAYO3YstWrV4pNPPgHSvo1I78QAypYty7Zt29i3bx81a9bk008/ZeHChTJlrRBCmFB4TPh/DxSYuQsW7oA5DaB/F0j99xKh8Q3GmyRfThXIvklRYPJkCA1N+6+St1+9xsXF0a9fP5ydnfH29mbu3LmZ2mQ8+zRt2jRKly6NnZ0dPj4+jBo1Ckgbvnfz5k3ef/99VCqV7vqKlStX4u7uzo4dO6hatSp2dnbcvHmTAQMGZBr6lZqayogRIyhSpAgeHh589NFHuuvaAIM3cS5SpIjuLFTZsmUBqFWrFiqViqZNmwJk2ldSUhITJkzAy8sLe3t7GjZsSHBwsG79vn37UKlU7N69mzp16uDo6EiDBg24dOnSU4/n7du36dmzJ+7u7jg5OVGnTh3+97//6dYvWbKEF154AVtbW1566SVWr16t93yVSsWyZct4/fXXcXR0pEKFCmzdulWvzfnz5+nQoQOurq64uLjQqFEjrl69qlu/YsUKKlWqhL29PRUrVmTx4sW6deln8gIDA2nWrBmOjo7UqFGDo0eP6l738OHDiYqK0v0Op02bBqS9Dz777DMGDBiAm5sb77zzDgATJkzgxRdfxNHRkXLlyvHxxx/rCo+VK1cyffp0Tp8+rdte+u8q4+/y7NmzNG/eHAcHBzw8PHj33XeJjY3VrU//HX711Vd4e3vj4eHB8OHDn1nkbN26lTp16mBvb0+xYsXo2rWr3vF+2vsp/Xht2LCB5s2b4+XlxZIlS3BwcGDHjh16zwsMDMTJyUmX+c6dO/To0YOiRYvi4eFB586duXHjxlOziqwla9KK+BIJkFIUHteEylPh0f+g9pC0n0YD8jZDvlxT1bRpU70/ehkZOuXepEkT/vrrrzxMJYQQIie8XdJmt7PWwPe/wcBT8EFrmNdAv10TvybMYU7+B8yhAtk37dwJ6R/ug4PTHrdpk2e7Gz9+PHv37mXz5s14eXkxefJkQkJCDA7XAti4cSNff/0169ato0qVKkRERHD69Gkg7UNljRo1GDJkiO4Dd7r4+Hi+/vprvv/+e4oXL06JEiUMbn/VqlUMHjyY//3vf5w4cYIhQ4ZQpkyZTNvLyvHjx6lXrx67du2iSpUq2NoanlVlwoQJ/Pbbb6xYsYKyZcsye/Zs2rRpw5UrV/SGvk2ZMoW5c+dSvHhxhg4dyqBBgzh8+LDBbcbGxtKkSRNKlizJ1q1b8fLy4q+//tJdc7J582ZGjx7N/PnzadmyJb///jsDBw7Ex8cHf39/3XamT5/O7NmzmTNnDt988w19+vTh5s2buLu7c+fOHRo3bkzTpk3Zs2cPrq6uHD58WDdD8A8//MDUqVNZtGgRtWrV4uTJk7zzzjs4OTnRv39/vdf11VdfUaFCBaZMmUKvXr24cuUKDRo0YNasWcyaNUtXQDo7O+ueN2fOHD7++GM++ugj3TIXFxdWrlyJj48PZ8+e5Z133sHFxYUPP/yQHj16cO7cOXbs2MGuf8+8urm5ZTp28fHxtG3blldeeYXg4GAiIyN5++23iYuLY82aNbp2e/fuxdvbm71793LlyhV69OhBzZo1s3x//PHHH3Tt2pUpU6awevVqkpOT+eOPPwy2fZoJEyYwZ84cFixYgIeHB4cOHeLnn3+mbdu2ujYBAQF07twZZ2dn4uPjadasGY0aNeLAgQNYW1vz2Wef0bZtW86cOZPl+1JkzVZtS9FkUBUDbTi8NBtKHIYSQPF42FkeSMzbDGY5UYXJxMfDxYvG365WizouDpycwNBFehUrghGHTgghRF4o7Voa11Q1Aes1tL4KfbpCQPX/1qtQUcq1FA18G2S9EaEvJ/2OosDYsWn9iFab9t+xY+GnnyAns2pls8+JjY1l+fLl/PTTT7Rq1QpIK2pKlSqV5XPCwsLw8vKiZcuW2NjYULp0aerVqweAu7s7arUaFxcXvLy89J6XkpLCV199RYMGDZ56Mbuvry9ff/01KpWKl156ibNnz/L1119nu6gqXrw4AB4eHpkypIuLi2Pp0qV8++23tGvXDisrK3744QeCgoJYvnw548f/dyb2888/p0mTJgBMnDiRDh06kJiYaHBG3oCAAO7du0dwcLCuMCtfvrxu/VdffcWAAQMYNmwYkHbm9NixY8ydO5eAgABduwEDBtCrVy8AZs6cyTfffMPx48dp27Yt3377LW5ubqxbt053nd+LL76oe+6nn37K3LlzdWdjypYty4ULF/juu+/0iqpx48bRoUMHIK2Iq1KlCleuXOHFF1/E1dUVlUpl8Pg1b94803DYJwssPz8/PvjgA9avX8+HH36Ig4MDzs7OulvdZOXnn38mISGBn376CScnJwAWLlxI586dmTt3ru52BkWLFmXRokWo1WoqVqxIhw4d2L17d5bvj88//5yePXvq3ZKnRo0aWebIypgxY+jatSvR0dG4urrSp08f+vXrR3x8PI6OjkRHR/PHH3+wadMmANatW4eVlRXLli3TnbFdsWIFRYoUYd++fZnuhyeezcFKhacrJCWD7SNwvZy2PFWVdo+qoBfAx7Ukd7jz9A3lghRVT7p4EZ74NshYrACXpzUICYHahfGuLkKIwuJUxCn6fN+WPT9Z8VK4hk694c//Pg+i+nfE+vy281Fbmcf9lwqE3PQ7Wi1cuAB16uTsednsc65evUpycjL169fXLXN3d+ell17K8jlvvvkm8+fPp1y5crRt25b27dvTqVMnrK2f/nHD1taWqlWrPjPTK6+8ojctc/369Zk7dy4ajcZoU9RfvXqVlJQUXn75Zd0yGxsb6tWrR2io/p1Dq1f/71uF9A/2kZGRlC5dOtN2T506Ra1atbKc5CE0NDTThB+vvvoqCxboT1n25D6dnJxwcXEhMjJSt49GjRoZnDjl3r173Lp1i8GDB+sVGampqZnODmX1up4s0AypY+C9uHHjRubPn8+VK1eIjY0lNTUVV1fXp24no9DQUGrUqKErqCDt2Gi1Wi5duqTLWKVKFb33gbe3N2fPns1yu6dOncp2Qf40GV93hw4dsLa2ZuvWrfTs2ZNNmzbh4uKiK5ZCQkK4cuUKLi76nw4TExP1hmqK7ElOekxSwhWstOAQDlZP3LrVWoF6d9PuVfXWqC/oO7lvnuWQoupJFSumdTZGptVqiYuLw8nJyfA3cBUrGn2fQghhLLuu7WL00i788VMqpVNd2L9mAufvfANPTFpRyrUU89vOp2ultG9rRTZlt99RFOjXL60I+3e4GJB2tqpixZydrcpmn/O0oZFZ8fX15dKlSwQFBbFr1y6GDRvGnDlz2L9//1NnSHRwcDDKPWxUKlWm3DmdOCCre48pipJp2ZOvKX2d9snfzxMcHByeue+c7jP9Oen7fNo+0tv88MMPegUjkKkgzcnretKTRQ/AsWPHdGeC2rRpozuLZujavKcxdBwy5suYO33d03I/63eS3fdTxtdta2tLt27dCAgIoGfPngQEBNCjRw/dlwtarRZ/f39+/vnnTNtKP5sqsicp4R7JyTexSgaHO5CsydxGo4KAUy9g/WKnPM0iRdWTHB3z5oyRVosmOhpcXQ0P/xNCCDO15swa5n4/gP0B1ri7eWO1cyfNKlTghvYDDoYdJDwmHG8XbxqVbiRnqJ5HdvudP/9MOyuVUfrZqvv3jX5tVfny5bGxseHYsWO6My+PHj3i8uXLuiFvhjg4OPDaa6/x2muvMXz4cCpWrMjZs2epXbs2tra2aDQGPvVk07FjxzI9rlChgq4oKF68OOHh/02o8vfffxMfH697nH6tytMylC9fHltbW44dO0aVKlWAtA/SJ06cyNW9uKpXr86yZct4+PChwbNVlSpV4tChQ3ozTh45coSKOfjitXr16qxatYqUlJRMBYanpyclS5bk2rVr9OnT57lfh42NTbZ/h4cPH6ZMmTJMmTJFt+zmzZt6bbLznqhcuTKrVq3SfUGdvm0rK6tnnj17murVq7N7924GDhxocP2z3k9P06dPH1q3bs358+fZu3cvn376qW5d7dq1Wb9+PSVKlMjxWTvxn4S4u6Rq7mKVAA7/qLHK4n2kVsD9fhzRuZyR8lmkqBJCCJGJoih8efhL/vhxEofX2+JQ4SVUO/6Ef697UFupaerX1LQhLYWiwMcf/3ctVUZWVmnrW7fO2bVVz+Ds7MzgwYMZP348Hh4eeHp6MmXKlKde87Ry5Uo0Gg0vv/wyjo6OrF69GgcHB8qUKQOkXVNz4MABevbsiZ2dHcWKFctRplu3bjF27Fjeffdd/vrrL7755hu9sx7Nmzdn0aJFvPLKK2i1WiZMmKBXXJQoUUI3M1upUqWwt7fPNPTNycmJoUOHMnXqVEqWLImfnx+zZ88mPj6ewYMH5yjvk3r16sXMmTPp0qULs2bNwtvbm5MnT+Lj40P9+vUZP3483bt3p3bt2rRo0YLffvuNwMBAdu7cme19jBgxgm+++YaePXsyadIk3NzcOHbsGPXq1eOll15i2rRpjBo1CldXV9q1a0dSUhInTpzg0aNHjB07Nlv7KF26NLGxsezevZsaNWrg6OiY5ZT65cuXJywsjHXr1lG3bl3++OMPNm/erNfGz89PdzuDUqVK4eLikmkq9T59+jB16lT69+/PtGnTuHfvHqNHj6ZHjx54enpm+/hkNHXqVFq0aMELL7xAz549SU1NZfv27Xz44YfAs99PT9OkSRM8PT3p06cPfn5+vPLKK3qvZ86cOXTu3JkZM2ZQqlQpwsLCCAwMZPz48U+9blGkiY+5gYb7WMWAtVsFrNwdICUFkpLAxgY2bdL/e1iiBOTxFP1y2kQIIYQejVbDyO0jObZoEnvWqHGo1wDV/gO6gkrks+RkCAszXFBB2vJbt9LaGdmcOXNo3Lgxr732Gi1btqRhw4Z6M9FlVKRIEX744QdeffVV3VmA3377DQ8PDwBmzJjBjRs3eOGFF55rmFO/fv1ISEigXr16DB8+nJEjR+pdhzR37lx8fX1p3LgxvXv3Zty4cXof+K2trVm4cCHfffcdPj4+dO7c2eB+Zs2aRadOnejfvz+1a9fmypUr/PnnnxQtWjTHmdPZ2tqyc+dOSpQoQfv27alWrRpffPGF7ixbly5dWLBgAXPmzKFKlSp89913rFixQjfte3Z4eHiwZ88e3UyD/v7+/PDDD7pC4O2332bZsmWsXLmSatWq0aRJE1auXKmbaj47Xn75Zd5991169OhB8eLFmT17dpZtO3fuzPvvv8+IESOoWbMmR44c4eOPP9Zr88Ybb9C2bVuaNWtG8eLFWbt2babtODo68ueff/Lw4UPq1q1Lt27daN68+VP3nR1Nmzbll19+YevWrdSsWZPmzZvrTXH/rPfT06hUKnr16sXp06cznRl0dHTkwIEDlC5dmq5du1KpUiUGDRpEQkKCnLl6BkVRiIv+O62gegQ27pWwc3YDW9u0CeEcHdP+v0qVtFEA6T/5UKiqlOcZNF0AREdH4+bmxv3793V/zNMlJiZy/fp1ypYta3CGHmPTarW6GWGe9g1fTj3v60hJSWHbtm20b98+29+45BXJYv5ZzC2PZMnbLAkpCfQJ7IPnmi18uw2s3ugGq1fn6Bu+9L+/UVFR8gHhX+l/r0uXLk1oaCg1a9Z85uQNem7dgnv3sl5fokSOPzTkVd/0PMwpi7nlkSzmn8Xc8hTWLIqiJS76IooqHquHKuy8q2Btp//592mfjfO6b5Lhf0IIIQB4EP+A19Z2ol1AMB/tUWD4cFiwAIw0q5rIBV/ftB8hhLBAiqIhNuoCWCVhdd8Ke9+qqG3M635eUlQJIYTgxuMbtP+pDR8GhDHgf6nw+ecwaZJRr9ERQgghckqrTSEu+jyQiuqeGge/alipza+EMb9EQggh8tXJ8JO8vqod362NofW5ZFi2DHJxQb4QQghhDFptEnHR51EpWpRHtjiVrYrKDIZ7GiJFlRBCWLCgq0EMXPU6W9epqHVLi2rLFuiUt/fyEEIIIZ5Fo4kjLvYiVhoFJdoe57JVjHI/u7wiRZUQQlio1adXM2XNQA6ud8Qv1hrV7j+hQQNTxxJCCGHhUlOjiY+7jDoZtPHOOPu9ZNYFFVh4UZWdu4Obs4KeXwhhGoqi8MWhL1i1fjInNzjhbueG6tCfULmyqaMJIYSwcCnJD0hMvI51AmhSi+BSprypI2WLRRZVtra2WFlZcffuXYoXL46trW2eVr9arZbk5GQSExONMrWloigkJydz7949rKysdHeIF0KIZ9FoNYzaPooTWxbz1wYHHEqVQbVjh8wsJ4QQwuSSkiJITrqNdQxorIrjUqqMqSNlm0UWVVZWVpQtW5bw8HDu3r2b5/tTFIWEhAQcHByMWrw5OjpSunRpk9+DQAhRMCSkJNA7sDepv23l0CZbbPxrw9at4O5u6mhCCCEsmKIoJCbeIjU1EuvHoHXwxrl4SVPHyhGLLKog7WxV6dKlSU1NRaPR5Om+UlJSOHDgAI0bNzbaDULVajXW1tZmP75UCGEeHsQ/oNPaTlTdHsLSLWDVoS2sWwcODqaOJoQQwoIpikJC/DU02kfY3ANtEV+c3D1NHSvHLLaoAlCpVNjY2Bit0MmKWq0mNTUVe3v7PN+XEEJkdP3RddqtaUvv7bf5ZHsyvP02LFkC1hbdBQghhDAxRdEQH/c3Wm0sNv8AJcri6OZh6ljPRXpUIYQoJDSKhv0393Mv4R7eLt40Kt2I0/+cpsPqdszclsTA/fHw0UcwY4bc1FcIIYRJabWpxMddRNEmYhMBqpIVsHN2M3Ws5yZFlRBCFAKbL25m2IVhPDj9QLesmGMxkuJj2LDNiTbB0fDttzBsmAlTCiGEsFSKohCbHEuyJhlbKxUk3wJtCtYRKtRlKmLj4GTqiLkiRZUQQhRwgaGB9AzsiYKitzzx0X0C10PzWxpUGzZAt24mSiiEEMKSPU58zO2Y2/8WVFDaHqy1YPWPCptylbG2K/jX98q0cUIIUYBptBpG7xidqaAqEQv7VkK9O9D77aJour5umoBCCCEsWmxqLPf/uUaF8GQ8NFDGAaxTQRsBl1wUYrSJpo5oFPlWVC1evJiyZctib2+Pv78/Bw8efGr7b7/9lkqVKuHg4MBLL73ETz/9lE9JhRCi4DgYdpDb0bf1lpV7CIeXg08MNB4IGzzvcTDs6X9zLZWp+yaNJp6YmL/y9Uejic9VZiGEyIn7KfcpGQ3W9lDMFawTITUS/nYDjRXcir6FoijP3pCZy5fhf+vXr2fMmDEsXryYV199le+++4527dpx4cIFSpcunan9kiVLmDRpEj/88AN169bl+PHjvPPOOxQtWpROnTrlR2QhhCgQwmPC9R7Xugvbf4YoO2gwGG4UNdxOmEffFB9/kZAQ/9y+lBzx9w/BxaV2vu5TCGGZYpNjcUxIxcYREj3BOhZSHsAVd+Df+ZKSNcnEJsfiYudi0qy5lS9F1bx58xg8eDBvv/02APPnz+fPP/9kyZIlzJo1K1P71atX8+6779KjRw8AypUrx7Fjx/jyyy+lqBJCiCd4u3jr/r/FVdi8HkKLQYc+cN/JcDuRxhz6JkfHivj7hzz/i3jOfQohRH5I0STjo4ak4mDzGOz+Aa0NuoIqXbIm2RTxjCrPi6rk5GRCQkKYOHGi3vLWrVtz5MgRg89JSkrC3t5eb5mDgwPHjx8nJSXF4L2ekpKSSEpK0j2Ojo4G0m68m5KSktuXkSvp+zd1jnTmlEeyGGZOWcC88kgWfdU8qmGntqPLqSR+2gx7ykK37hBnl7ZehYqSriV5xfuVfMtpDr+bZ8nvvik5ORmtVqu72byiKGi1WlQqe5ycahrnReWAVqvVDbdJz2JK5pQlPUf6f02dR7KYf5b0HOn/NXUec8pim3wPxR1s74Ptg7RayikFXBMh+ok/pzZWNkbJmv63LSUlBbVarbcur/umPC+q7t+/j0ajwdNT/87Inp6eREREGHxOmzZtWLZsGV26dKF27dqEhITw448/kpKSwv379/H2zvyN66xZs5g+fXqm5Xv37sXR0dE4LyaXgoKCTB1BjznlkSyGmVMWMK88kiXt4t/Prn/Ge0dS+Ho7rK4OgzpD6hP9iIJCH/c+/Lnjz3zLFR9v/tfs5HffVKZMGZYuXUpCQgKQ9sVfxg7fVGJiYkwdQcecsoB55ZEshplTFjCvPKbNokWl+gcrdRx2EWAb9d8aBSgZ819RZa2yRpOgIToxOtd7TU5OJiEhgQMHDpCamqq3Lq/7pnybUl2V4UaTiqJkWpbu448/JiIigldeeQVFUfD09GTAgAHMnj07y05o0qRJjB07Vvc4OjoaX19fmjVrhoeHae/MnJKSQlBQEK1atTL4TaYl55Es5p/F3PJIljSRcZF0WNueIX/c4P19WkL7dWBshaOkah7q2pRyLcXclnN5vWL+zvyXPlKgIMivvik5OZl//vkHX19fLl++jKurq8mLKkVRiImJwcXFJcvXbIlZzC2PZDH/LOaWx/RZNCQkXEGbGof9XbCJ1V+b8WxVabfSuNkb56a/iYmJODg40Lhx40wjC/K6b8rzoqpYsWKo1epM3/xFRkZm+oYwnYODAz/++CPfffcd//zzD97e3nz//fe4uLhQrFgxg8+xs7PDzs4u03IbGxuTf/BKZ05ZwLzySBbDzCkLmFceS85yK+oW7Va15KM1t+h5IhG++oryo0bx3R+/4VrVlXsJ9/B28aZR6UaorfL/g7u5/F6eJr/7psTERO7du6crpFQqFVZWpr2rSfpQG8mSmTnlkSzmnwXMK48ps2i1ycTHX0ZJTcThDqgTDLdTgFKxKpK8y1HUoajR9m9lZYVKpTLYL+d135TnR9rW1hZ/f/9Mw2OCgoJo0KDBU59rY2NDqVKlUKvVrFu3jo4dO5r8jSqEEKb094O/abW0AQu/u0WPUymwZg188AEAapWaJmWa0KtaL5r6NTVJQVVQSN8khBDGpdEkEh8XipKSiN1tUCerM85HoaMCHBRritoZ5wyVOciX4X9jx46lb9++1KlTh/r16/P9998TFhbG0KFDgbThEXfu3NHd7+Py5cscP36cl19+mUePHjFv3jzOnTvHqlWr8iOuEEKYpTP/nKHH0pasXxlDtXtWqH7/Hdq0MXWsAkv6JiGEMA6NJo74+MuokjXY3gWlbHlUto5oU1KIi4nBycUl05kclY0NFKIvpPKlqOrRowcPHjxgxowZhIeHU7VqVbZt20aZMmUACA8PJywsTNdeo9Ewd+5cLl26hI2NDc2aNePIkSP4+fnlR1whhDA7x24fY8iiNmxbmUSZVGes9m6HunVNHatAk75JCCFyLzU1ioT4K6gSFaz/UaEq/xK2Ds5pK62t0aSkgINDoSqgDMm3iSqGDRvGsGHDDK5buXKl3uNKlSpx8uTJfEglhBDmb8/1PUz6uiO7V2twL+KN1c4gqFDB1LEKBembhBDi+aWkPCAx4TpWcWB13wrrFytjbWf/7CcWQvlWVAkhhMi5rZe2smBON3avVXAoXwn1nzvBy8vUscRzSr9/jBBCFHRJSREkJ9/GOhq0UWpsK1VBbW1r0kym/BsrRZUQQpipgLMBbJzZl+2bwPrVRlht+RXcCs9FvZYkfdap9PtUCSFEQaUoCklJt0lJ+QebB5CaYINjxapYmcG999LvRWWKWWilqBJCCDO09MRSTk1/j43bVND1DazWrAEDt40QBYNaraZIkSJERkYCacWVqaee12q1JCcnk5iYaPLZC80pi7nlkSzmn8Xc8uRlFkXRkpR0h9TUKGwfQJzWFscy5UlOSYGUlHzNop9LIT4+nsjISIoUKWKS+wBKUSWEEGbmy4NfEP/JJJbuA2XYe6gWLgQz+AZQ5I6XlxdJSUlcuXIFe3t7s7j5b0JCAg4ODmZxs1JzyWJueSSL+Wcxtzx5lUVRtKSk3EOrTcQmClLUdth7eMLNm/meJStFihTBy0RD5KWoEkIIM6EoCh8FTcJ38pdMCAHls89QTZ4MZvCBQeSeSqXC3d2d3r17c/XqVYoUKWLSPCkpKRw4cIDGjRub/KyZOWUxtzySxfyzmFuevMiSnPyAy5eHEP84lJfmafnbvyV1piwySZas2NjYmPTLKimqhBDCDGgVLWN/HUbjSd/R5bIKlv2AavBgU8cSeSA+Ph4bGxvs7U07Q5ZarSY1NRV7e3uTfwg0pyzmlkeymH8Wc8tj7CwJCdc5f74lSfdvUHOcltB+Q2k4ZYlJspgzKaqEEMLEUrWpjAh4i95T1tPgHxustmyCTp1MHUsIIYSFi4k5xenTbdDcvU+ND7Rc/Wgq9d+dZupYZkmKKiGEMKGk1CTe+6Ez70//kxcTnLDesxMaNDB1LCGEEBbu0aO9nD3TCatr8VSdqHDn28X4d3vP1LHMlhRVQghhInHJcYz8uhXTZh2luEMx7I7uh8qVTR1LCCGEhYuM/IULF/pgfzqVMjPh0bqNVG32hqljmTUpqoQQwgQeJTxi/GeNmTP/HPYly+Cw5xCUKmXqWEIIISzc7duLuHJlFC4HFIovVqPZsZvytZqYOpbZk6JKCCHy2T+x//DpxPos+P462prVcdqxF9zdTR1LCCGEBVMUhevXPyYs7HOKbQabQDscDh2nePnqpo5WIEhRJYQQ+SgsKoxvR9RjfsA/xLdqiuvmbeDgYOpYQgghLJhWm8rly0OJiFhOqR8gLtgF3+CzuHmVMXW0AkOKKiGEyCeX719i04CX+fKPKKL7dsf1x5/BWv4MCyGEMB2NJp4LF3ry4P7vlJ8NEf94UvXEBexdZQRFTliZOoAQQliCM+Gn2Pd6LSb9EUX0+FG4rlonBZUQQgiTSkl5yOnTrbj/zzaqTlQIS3yBmkevS0H1HKSoEkKIPPa/awe53K4ebx9OIGbeF7jOXgAqlaljCSGEsGCJibc4ebIhUZHH8R+lIbSkP/V3XcLaToakPw8pqoQQIg/tO/Mbca2b8tr5VBLWrMLl/QmmjiSEEMLCxcWd56+/GhAXfoWXh6RyqlFbGm0KRqVWmzpagSVFlRBC5JEdh1bh2q4zL9+1Qrt9G069+5k6khBCCAsXFXWYv/5qSHLYP7zydgon+/Wj8XfbZQRFLklRJYQQeeDXP+ZRvvMAysbbYXvoKPYt25o6khBCCAt3//5WTp1qiXIplrrvpnD2o/G8+tkqU8cqFKSoEkIII/tl9SRe6fEBzvauuJw4g03tOqaOJIQQwsLdvbuMc+dex/pECjXGpPL34q+oN3q2qWMVGjL1lBBCGNHa+W/TccJyHvp54nvwNFYlPE0dSQghhAVTFIWbNz/nxo2PcQqywu8bDeG//ETNdn1NHa1QkaJKCCGMQFEU1n3UhTe+2MpN/xcov/skKhcXU8cSQghhwRRFw99/j+bu3W8pulaFxwaI27mdiq/IkHRjy7fhf4sXL6Zs2bLY29vj7+/PwYMHn9r+559/pkaNGjg6OuLt7c3AgQN58OBBPqUVQojs0ypaNg5tTK+ZW7nSyp8Kh0OloCogpG8SQhRWWm0iFy705O6dxXh/Ay6/2mB9+Bh+UlDliXwpqtavX8+YMWOYMmUKJ0+epFGjRrRr146wsDCD7Q8dOkS/fv0YPHgw58+f55dffiE4OJi33347P+IKIUS2abSp/NmzNm9+f4gzfVtTedtxsLExdSyRDdI3CSEKrzjOn+/EvcgtlJuhkHrSmaLB5/CqXNfUwQqtfCmq5s2bx+DBg3n77bepVKkS8+fPx9fXlyVLlhhsf+zYMfz8/Bg1ahRly5alYcOGvPvuu5w4cSI/4gohRLYkJsRgO2sor22+wMlxfan+059gJfP/FBTSNwkhCqPk5HCcnacQ/fAYld9P5f59D/xOXKGobwVTRyvU8vyaquTkZEJCQpg4caLe8tatW3PkyBGDz2nQoAFTpkxh27ZttGvXjsjISDZu3EiHDh2y3E9SUhJJSUm6x9HR0QCkpKSQkpJihFfy/NL3b+oc6cwpj2QxzJyygHnlMZcssY/+4VKrGrQ595DgWaOp+cEck2Yyl+NiLhmeRfom83zPmEMWMK88ksUwc8oC5pMnIeEy5851QEkMp/bIZM57+lJ9xylsHV1Mks1cjkt+ZFApiqLk5Q7u3r1LyZIlOXz4MA0aNNAtnzlzJqtWreLSpUsGn7dx40YGDhxIYmIiqampvPbaa2zcuBGbLIbVTJs2jenTp2daHhAQgKOjo3FejBBCAMmPwqkw9X3KRyTy25j+ODZ43dSRzEp8fDy9e/cmKioKV1dXU8cxSPomIURho1b/jaPjp2gfJ9HwvSR2v1ia5DFzsbKWIemQ931Tvs3+p8pwl2ZFUTItS3fhwgVGjRrFJ598Qps2bQgPD2f8+PEMjZXKLgAAY6NJREFUHTqU5cuXG3zOpEmTGDt2rO5xdHQ0vr6+NGvWDA8PD+O9kOeQkpJCUFAQrVq1yrLjtdQ8ksX8s5hbHlNnuX/xLxJa9cA1Npm/132Ho5WnHJcM0s/GFATSN5nHe8acsphbHsli/lnMIc+jRzu5eHEamrvQ5N0kfmtYhTbrj2FrZ5fvWZ5k6uPypLzum/K8qCpWrBhqtZqIiAi95ZGRkXh6Gr5/y6xZs3j11VcZP348ANWrV8fJyYlGjRrx2Wef4e3tnek5dnZ22Bl449jY2Jj8l5jOnLKAeeWRLIaZUxYwrzymyBJ+ZCdW7dujVsPDXb9R1b81Ydu2WfxxMZTB3Enf9B/JkjVzyiNZDDOnLGCaPBERa7h0aSDKJVsaj4rn8LA3UDfpi62dndkcG3P4PeX1/vP8impbW1v8/f0JCgrSWx4UFKQ35OJJ8fHxWGW42FutVgNp3yIKIUR+u/V7AI4t2vLAyQrl0CFefCXr62iE+ZO+SQhRGISFfcXFi31R/c+a+iPiCZ42gvpfrjV1LIuUL9NUjR07lmXLlvHjjz8SGhrK+++/T1hYGEOHDgXShkf069dP175Tp04EBgayZMkSrl27xuHDhxk1ahT16tXDx8cnPyILIYTO9RVfU/z1PoSWdqDIsdP4VXrF1JGEEUjfJIQoqBRFy5UrH3Dt2njsttvi/1Ei55d8yisTvzF1NIuVL9dU9ejRgwcPHjBjxgzCw8OpWrUq27Zto0yZMgCEh4fr3RdkwIABxMTEsGjRIj744AOKFClC8+bN+fLLL/MjrhBC6FydNQG/KbPZU7sINXeepbh7KVNHEkYifZMQoiDSapO5eHEQkZEBuPxkzQvrUri+fim1X3/X1NEsWr5NVDFs2DCGDRtmcN3KlSszLRs5ciQjR47M41RCCJEFReHq+wN4YcFPBDb3psXWc7g5uZs6lTAy6ZuEEAVJamos58+/waNHeyg+T4XHfi0PtgdStUkXU0ezePlWVAkhRIGh0XC9TwdeWP8nK9+sQPc1J3G0dTJ1KiGEEBYsOTmSs2c7EBtzHt+PNFhfskZzYA8v1Gho6mgCKaqEEEJfYiJhHRtRes8Jlgytw+BFh7FV25o6lRBCCAuWkHCdM2dakxj3DxVGJRAT7YDb/4IpVq6KqaOJf+XLRBVCCFEgPH7MnQbVKL7/BN9OasmQb49JQSWEEMKkYmJOcfJkAxKjHlBtQAz3UovgfeKSFFRmRooqIYQAuHuXSP9KOIRe4fsvuzPisz9RW6lNnUoIIYQFe/RoL6dONSb5YSp1ej3iiqc3LwVfw7WEr6mjiQykqBJCWDwlNJRHtSqRdD+CtUuGMer9dVip5M+jEEII04mM/IUzZ9qSGm5Pw+73OVWzAv6Hr2PvUtTU0YQB8qlBCGHRtMeOEvdybe4q0ez46ROGD/gWlUpl6lhCCCEs2O3bi7hwoQfaK6406XOPIx3r0SDoImpbO1NHE1mQokoIYbFSf9tKctNGnCqSyF/r5/NO5+mmjiSEEMKCKYrCtWsfceXKSAguStN37nNoSAcab/gfKiv52G7OZPY/IYRF0Gg1HAw7SHhMON4u3tTffRnrIUPZ+SKkrFlNX/+3TB1RCCGEBdNqU7l8eSgREcux2u5GgzkPOfLxQBpP/9HU0UQ2SFElhCj0AkMDGb1jNLejb4MC4w9D012w3F+Fz+pfea1SJ1NHFEIIYcE0mnguXOjJgwfbsPvJkVqrozi5cBKvjphp6mgim6SoEkIUaoGhgXTb0A0FBZUW5u6E94/Bp43hk2YKm0gxdUQhhBAWKH0EhXb3r7gqS4gvp+A635ryO+O59NPX1O01xtQRRQ5IUSWEKLQ0Wg2jd4xGQcEmFVZugZ7nYFh7WFIPVKgYs2MMnV/qLNOnCyGEyDfpIyiSEm/zS2lIdIZKo4FrEL41gBqte5k6osghueJNCFFoHQw7yO3o2zgnwR8B8EYodH8zraACUFC4FX2Lg2EHTRtUCCGExUgfQWGdeptl1cBWDbVHQvFzMLEFnPeVGf4KIimqhBCFVnhMOCViYd9KqHcH2rwFmwzcgD48JjzfswkhhLA86SMoqrgqLKgJRR9ArRHgeAtSVfBuCIzZPhqNVmPqqCKHpKgSQhRaZR9qObwcfGKg8UDYX9ZwO28X7/wNJoQQwiIdDDtIaZvbfFUdUu/CK8PB/kHaOmsF6t2FSidvywiKAkiKKiFE4fTXX9To+h5aFTQYDGe8MjdRocLX1ZdGpRvlfz4hhBAW5/G9AGZUgTvX4bV3QB2nvz5VBZ/ugfDou6YJKJ6bFFVCiEJH2bWLpIb1OWsfw5TpTbhZVIUKlV6b9Mfz286XSSqEEELkKUVRuHHjM4rE/cDNkzDwXbBOyfxBPP1sVeWTt02SUzw/KaqEEIWKJuBnNO3asNcnmT3LprBh+F42dt9ISdeSeu1KuZZiY/eNdK3U1URJhRBCWAJF0fD33yO5ceNjtMG+DPwAIhwgq6umNCqovugXUJR8zSlyR6ZUF0IUGslff4Xt2PGsqa4i5YfvmFhvCABdK3Wl80udORh2kPCYcLxdvGlUupGcoRJCCJGnNJpELl7sy717gai2laD5nFtseKsWjTefJKseSK0At29DcjLYyUyABYUUVUKIgk9RiB8/Bse5C5nf0JqXlm2h3Usd9JqordQ09WtqmnxCCCEsTmpqFOfOdSEq6hg2K115eXUkhz8dQvePvmP7nu9Z+MfH/BMbqWvv5ezJuAbjaF62OZQoIQVVASNFlRCiYEtJIaZ/L1zWbuKTjk50WrqXuiXrmjqVEEIIC5aUFM6ZM+1ITLiO05dWVN71mFNLp/PqO58A0K75EFo3HSwjKAoRKaqEEAVXXBxRndvguPcwH/T1ZNj8w7zg/oKpUwkhhLBg8fGXOXOmDanJ8RT9MJGSZ1K49sv31On8jl47GUFRuOTbRBWLFy+mbNmy2Nvb4+/vz8GDWc+/P2DAAFQqVaafKlUM3LVTCGGZHjzg8at1UB88zAcjX2TCkjNSUIkck75JCGFMMTEnOHnyVVKTNPi8cx/3Sxoe7vyVqhkKKlH45EtRtX79esaMGcOUKVM4efIkjRo1ol27doSFhRlsv2DBAsLDw3U/t27dwt3dnTfffDM/4gohzJzDvXvE1a9Nyt8X+eijBsya/RclnEqYOpYoYKRvEkIYk7X1Sc6da4WS5MYLPW+hRFnDocO80LCTqaOJfJAvRdW8efMYPHgwb7/9NpUqVWL+/Pn4+vqyZMkSg+3d3Nzw8vLS/Zw4cYJHjx4xcODA/IgrhDBnZ89SZ/woHj4O5+u53fhqyn6cbJ1MnUoUQNI3CSGMJTLyZxwdP4PYUlTrcpUHjs4UDT6HT5WXTR1N5JM8v6YqOTmZkJAQJk6cqLe8devWHDlyJFvbWL58OS1btqRMmTJZtklKSiIpKUn3ODo6GoCUlBRSUlKeI7nxpO/f1DnSmVMeyWKYOWUB88mjPbAfzWsdCHNJZvuCUUx7fQ6KRiFFY5pc5nJcnsxgTlnMmfRN5vmeMYcsYF55JIth5pTlzp153LgxkbgbvrR69xJnKhWjQtApnIqWMEk+czo25pglr6gUJW/vLHb37l1KlizJ4cOHadCggW75zJkzWbVqFZcuXXrq88PDw/H19SUgIIDu3btn2W7atGlMnz490/KAgAAcHR2f/wUIIcyCx9FD1J07l8OlFLZ98DaNfDuaOpLIQnx8PL179yYqKgpXV1dTxzFI+iYhRO5psbdfhZ3dr8ScLEn7sXfYXceT2AkLUNvYmzqcyCCv+6Z8m/1PpVLpPVYUJdMyQ1auXEmRIkXo0qXLU9tNmjSJsWPH6h5HR0fj6+tLs2bN8PDweK7MxpKSkkJQUBCtWrXCxsbGpFnMLY9kMf8s5pAn/tuvcZ79FVuqqLFauYZGtx3M4tiY+riYa5b0szEFgfRN5vGeMacs5pZHsphnFq02mStX3uHeva1oj5Sl05Tr/Nr8BVps+Qs7e4d8z/MkUx8bc82S131TnhdVxYoVQ61WExERobc8MjIST0/Ppz5XURR+/PFH+vbti62t7VPb2tnZYWfgJmk2NjYm/yWmM6csYF55JIth5pQFTJBHUXg0eSxFv5jP8gb2VA3YTW2fumy7vc2sjo1kyZzB3Enf9B/JkjVzyiNZDDNFltTUWC5efIPHj/ei2uJN8wXX2Tu0LbR5Fzt7B4s+Nlkxhyx5vf88n6jC1tYWf39/goKC9JYHBQXpDbkwZP/+/Vy5coXBgwfnZUQhhDnSaLjf/02KfjGfrzoUpfGvp3m5zNP/ZgiRXdI3CSGeR3JyJKdPNyM66ijW37nw6jd3OTxtMA0XboVsnOUWhVe+DP8bO3Ysffv2pU6dOtSvX5/vv/+esLAwhg4dCqQNj7hz5w4//fST3vOWL1/Oyy+/TNWqVfMjphDCXCQmEtmlFR47D/Fp3zIMWfw/PJ2ffvZAiJySvkkIkRMJCdc5c6Y1KclROHyqUGXfQ/769mNeHTrDLCZiEKaVL0VVjx49ePDgATNmzCA8PJyqVauybds23YxJ4eHhme4LEhUVxaZNm1iwYEF+RBRCmIvHj/mn5Su4nr7Ep+/XZtys/TjbOps6lSiEpG8SQmRXTMwpzp5th6K1oejoKEqGpnBl/RLqdR1q6mjCTOTbRBXDhg1j2LBhBtetXLky0zI3Nzfi4+PzOJUQwpwod+5wr0kdbO5EMO+z9kwZtwUbtXmMBxeFk/RNQohnefRoL+fOdUateOE94BqODxTu7wikWpMupo4mzEi+FVVCCPE0mgvniWpan6SkGNYvHsrkAYuzNQubEEIIkVciI38hNPQtbDQvUq7nOeJVtmgO7aV8NbnGV+jL84kqhBDiWRIP7yfuldqEE8P+gFmMHLhECiohhBAmdefOt1y40AN1XGUqv3aOB05OuAWfoaQUVMIAKaqEECYVs3k9SvPmnCuaSthva3irw0RTRxJCCGHBFEXh2rWP+PvvEVhF1qJO51NcLeeBX8hVPEq/ZOp4wkxJUSWEMJkHS+bh0K0n+8qrUf+/vTsPi6ru+zj+HnZQ0YRUVETNct/C3XBfKyuXtCxLb63MFpWsNCuXLFuNFjG91UzNtMzuNlMpN9wyDVdUzCVUQBQXUASGmfP80aNFYIswcwbm87ourqs5nHHeDmM/vjNnznz/Az1b3md2koiIuDG7PZcDBx4iMfFl2N+YtgN+5udWYTT88SilyusstHJ1GqpExPkMg+QXRhM04imWtihNzR/iaHljB7OrRETEjdlsmezd24eUlHkQW5sOj+5kw51NaLX2F3z8dRZa+Ws6UYWIOJfdTuKw/lT78HP+e2tFei2Oo1KZELOrRETEjVmtZ9i9uxcXLuyAzyrTIfoAax/uTvsZy7F46DUI+XsaqkTEeXJyOHpXR6qt2MR7D9Zh8MytlPEtY3aViIi4saysY+za1Z2cnJN4vleKtp8fI/bFwXSY9KHZaVKMaKgSEacw0tNJ7NyMkLiDTB/TnkemrsLH08fsLBERcWMXL+5l164eGHbwfd5Kg41n2P7+c0SMeNnsNClmNFSJiMPZU5I5EdGEcsdSWfDafTweuUCnTBcREVOdP7+R3bt74WkJJvDRY4QezCJh0Xu0uPtxs9OkGNJQJSIOlX0gnrPtW+B18SIr5oxj2H2vmJ0kIiJu7vTpr4iPH4CP5SYq3LeXgHMGqcuX0rhjX7PTpJjSUCUiDpO+aS25PbuR4Z3L4WUzGNB1uNlJIiLi5pKSZpOQ8Ai+9mZU7/cTl7y8yI1dzY2NbjE7TYoxnc5ERBwi9atP8OzUmSOBds7EfEV3DVQiImIiwzA4enQKCQkP4ZPZmrq3b+VMoD9lftxBVQ1UUkgaqkSkyCXOfJ1yfQbyUw0fSq3fQsumt5udJCIibswwbBw8+ARHj76AZ3Jbbr5jI4drlid020GCa9QzO09KAA1VIlKkDk54gmrDn2VV+HXctHE/dWo0MztJRETcmM2WRXz8PSQlzcCytyVt7tvIzy2r0WDrUcoEVzY7T0oIvadKRIqGYbDvod7UnfMln/asRo/PdxLoX87sKhERcWO5uefZs+cu0tO3YKytR4dJP7KuVyMivtiOh6d+DZaio0eTiBSe1creu9pSf/lPfPzgzdw9Z7M+g0pEREyVnZ3Mrl09yc76FfuiynScuYd1Q7vQbtZKLB46WEuKlh5RIlIo9gsZxLetzU0rfuKTZ2/j3g9/0kAlIiKmysxMIC6uDdacUzDNl4hZh4kdP4j2s2M0UIlD6FElItcs+2QSh26uQbUdR1g+7VHuffUbPCz634qIiJgnPf0n4uLaguGFz7MXafbNSba98ywRU+abnSYlmA7/E5Frkp6wh7MdWlLufCZbF7zKnQOeNTtJRETc3JkzK9mzpy++XrUoPfQAVQ9nsX9BFC3vGWl2mpRwGqpE5F87ufl76NkTw9PO0W8/plOHgWYniYiIm0tJWciBA0Pw92xOcP+fKJVuJ+XbJTTp3N/sNHEDOk5HRP6VI1/Nx69TN06XspC9bjXNNVCJiIjJEhPfZP/+QfjZb6Ha7VvwyLGQs241tTVQiZM4baiKjo6mRo0a+Pn5ER4eTmxs7F/un52dzfjx4wkLC8PX15cbbriBuXPnOqlWRAqyf86rhPR9kAPVArhuy05qN2hvdpJIoWhtEineDMPOL7+M4fDhp/G72JWbbl3LuUA/Sm35mdCmWqPEeZxy+N+SJUsYNWoU0dHRtG3blpkzZ9KzZ0/i4+OpVq1agdfp378/J0+eZM6cOdSqVYvU1FRyc3OdkSsiBbB9EU29+auIbXY9TWP2ULZsBbOTRApFa5NIcWfl4MEhnDq1GO+kLjR5MIb4m66j1tpdBF5f1ew4cTNOGaqmTZvG0KFDGTZsGABRUVGsXLmSGTNmMHXq1Hz7r1ixgnXr1nH48GHKly8PQPXq1f/yNrKzs8nOzr5yOT09HQCr1YrVai2iv8m1uXz7Zndc5ko9aimYK7VgGPz0aC/6fLSKFd1u4JbPt+PrG2BamyvdN2opmCs0/BNam1zvMeMKLeBaPWopWFbWWQICXub06b2w6xZajfqerS2q0HDFTnxLBTq90ZXuG7UUzNENFsMwDEfeQE5ODgEBAXz22Wf07t37yvaRI0eyY8cO1q1bl+86I0aMICEhgWbNmrFgwQJKlSrFHXfcwUsvvYS/v3+BtzNx4kQmTZqUb/uiRYsICAgour+QiBux51oJiHqa7huOsrBXXUoNmYKHh6fZWeLiMjMzGThwIOfPnycwMNDsnAJpbRIpviyWcwQETMHT8wTnPg+h9/TDfBNRjZyRb+Lppc9JlII5em1y+CtVp0+fxmazUbFixTzbK1asSEpKSoHXOXz4MBs2bMDPz48vvviC06dPM2LECM6cOXPVY9fHjRtHZGTklcvp6emEhobSsWNHgoKCiu4vdA2sVisxMTF07doVb29vU1tcrUctrtuSczGdvT2aEL71ON8905cybQbpvlHLP3L51RhXprXJtR4zrtTiaj1qySsr6wh7995Gbm46594vR+8lh1nzYHu6zVxp6of6usJ9o5a/5ui1yWmnVLdYLHkuG4aRb9tldrsdi8XCxx9/TNmyZYHfDtPo168f06dPL/AZQV9fX3x9ffNt9/b2Nv2HeJkrtYBr9ailYGa1pJ9M5Ej7xjQ8dI5N7z1Dl4ensHz5ct03V6GW/A3FhdYmtfwVV+pRC2Rk7GD37p54WErBq57c+m0y6565h46vfeL0lqvRz6lgrtDi6Nt3+EgfHByMp6dnvmf+UlNT8z1DeFlISAhVqlS5smgB1K1bF8MwOH78uEN7RdxdSsLPpITXplriefYtfo+Ix14zO0mkyGltEilezp5dw44d7fDyqIBnZBrNVySz6LG7aDNlvtlpIoAThiofHx/Cw8OJiYnJsz0mJoY2bdoUeJ22bduSlJTEhQsXrmxLSEjAw8ODqlV1NhcRRzm06VtyW7Wg9AUrp1d+wc19Hzc7ScQhtDaJFB+pqZ+xa1cP/LwbEjD4ILXjzrH7w9cp03Ww2WkiVzjl4NPIyEhmz57N3Llz2bdvH6NHjyYxMZHhw4cDvx1z/sADD1zZf+DAgQQFBTFkyBDi4+NZv349Tz/9NP/5z3+u+mZgESmcnV/OolzXXmT5esGmTdwYcafZSSIOpbVJxPWdODGd+PgBlPJuR1CfrVQ4kU3SV4tofM8os9NE8nDKe6oGDBhAWloakydPJjk5mQYNGrB8+XLCwsIASE5OJjEx8cr+pUuXJiYmhieeeIJmzZoRFBRE//79mTJlijNyRdzOpg+ep/GTL3O4eiDV1u6gbOUaZieJOJzWJhHXZRgGR468QGLiy5Tidirf+i1WL08urY2hTngnlzhFt8gfOe1EFSNGjGDEiBEFfm/evHn5ttWpUyffYRkiUvS+nzCIDi8tJC68Mg1X78GvzHVmJ4k4jdYmEddjt+eSkDCclJQ5+F+8i1r9/sfJ6/0JWvMj19/Q0Ow8kQI5bagSEddi2O2sGN6Fnv9dw+YeDWj51XY8vPX5HiIiYh6bLZP4+HtIS1uOd1IvGj34P/bXKkfNtTspW7Ga2XkiV6WhSsQN5VizWNP3Znp+vY/ND3ah9Yer4CqnkRYREXEGq/UMu3f34sKFHXjs7EjLyK/Z1qwyTX7Yi1/pcmbnifwl8z4lTURMkZGRxsb2Nej6zT5+em4IrefFaKASERFTZWUdIy7uFjIzD2Bf0ZB2o75nU7d6NN9wRAOVFAsaqkTcyMnkX9jbogZttqaw970Xaf7yXLOTRETEzV28uJe4uDbYbJnkzqlAh6k/svaBdkR8uxtPHZYuxYSGKhE38Uv8RlJb1Kfe0Qsc/3Q2DR+bZHaSiIi4ufPnNxIXF4GnR1lsU2y0m7eP9U/3p8NH67B46NdUKT70aBVxAz/HfoZHu3ZUSrdxMWY5N/QZanaSiIi4udOnv2Lnzi74+dbG8mQSLVYe58c3R9Hu9SVmp4n8axqqREq4tZ9Po0rP/nh7+eC95SdCbulhdpKIiLi5pKTZ7NnTm9J+Efjet4s6O86yd94btH7qbbPTRK6Jzv4nUoJ9Ez2a9qOjSAm9jtDYnfiFhJqdJCIibswwDH799WWOHn2Bsr69CbzjGwIv5HL8ywU07XG/2Xki10xDlUgJZBgGn73Ql7umfsEvTapRe80uPAPLmp0lIiJuzDBsHDw4kqSk6QRa7qViz8XYPD25uHoldVt0NTtPpFA0VImUMFablU+H38J9s7eyt3tT6n21BYuPzp4kIiLmsdmy2L9/EKdOLaPUxfuocfciUsv7Um7NZire2MTsPJFC01AlUoJcyM7g27sbc9/XR4h/8Fbqz/0adPYkERExUW7uefbsuYv09C34nuhH/SEfk1CzLDXW7qRspTCz80SKhIYqkWLIZrcRmxhLckYyIWVCiKgWwenzyfx4WxMGbE7jwLiHqffKTLMzRUTEzWVnJ7NrV0+ys3/F8nNnmj/1KdvCQ2iyOl4f6islioYqkWJm2b5ljFwxkuPpx69sq+FTkZnzz9IzIYdf33+Z2o89Z2KhiIgIZGYmsGtXd+x2K7nfNqTDq98S2602rb/egZePn9l5IkVKQ5VIMbJs3zL6fdoPA+PKtvKZ8PHskzQ8CSujnuB2DVQiImKy9PSf2L37Vry8gsmZVYYOH8Wy9r62tJ+/Xh/qKyWShiqRYsJmtzFyxcg8A1XoOVi5EIIzodNgSMn9Hz3tb+Pp4Wlap4iIuKfLh6anpa0g6MI7lA5oyKUXU2m3Yj/rIvvS4a2lZieKOIyeKhApJmITY/Mc8tfgJGyeA7650GYo/FQFjqUfIzYx1sRKERFxR8v2LeP+xyoRGNmRcudf48fULE4P2UbLmF/Z8voTtNdAJSWcXqkSKSaSM5Kv/Pctv8LXi+BoOehxP5wsU/B+IiIijrZs3zL6LelLbC6kPwl+ayFiLjRKMbhtIDx6ewezE0UcTkOVSDERUiYEgDv3weKlsCkUet8D6X4F7yciIuJoNruNUSueZGoQWDtAtY+hxmw47wsdB8P2KhYOrBjFnbXv1KHpUqLp8D+RYqJVlVY8HufN55/CV7Wh5/15ByoLFkIDQ4moFmFepIiIuJXYX1czqPIJWtaHmu9Bzdm/bU8sC9sqg4GhQ9PFLWioEikGLmZf4LN7G/Lel1ZmNIOB/SDnD68zW7AAENUjSs8EioiIU+TmXiA76Sk6BUO9l6Dast+2W4BGqdDt0O/76tB0KemcNlRFR0dTo0YN/Pz8CA8PJzb26s9YrF27FovFku9r//79zsoVcRlnLpxiZfdaDPr8Fw5GDqHyvKWElKuaZ5+qgVVZ2n8pfer2MalSpHjS2iRybXJyUtm5syO+uYeoMBmuX5v3+7kWeGk1XD5hrQ5Nl5LOKe+pWrJkCaNGjSI6Opq2bdsyc+ZMevbsSXx8PNWqVbvq9Q4cOEBgYOCVy9dff70zckVcRtKpwyTc1pw7d2Zw+I3x3DhmCjcCd9a5i9jEWJIzkgkpE0JEtQi9QiXyL2ltErk2WVlHiI+/jdzcDAKXNqDh+q359vEyoEUSdD8E8Tfr0HQp+ZzyStW0adMYOnQow4YNo27dukRFRREaGsqMGTP+8noVKlSgUqVKV748PfVLo7iPU2kHSWnXmIg9GSTNn07NMVOufM/Tw5MO1Ttwb8N76VC9gwYqkWugtUnk3/PwOMyuXe3BAOuSGtz8/tY/fHpiXjZg8mqI6q7PT5SSz+GvVOXk5LB9+3bGjh2bZ3u3bt3YtGnTX163adOmZGVlUa9ePZ5//nk6dux41X2zs7PJzs6+cjk9PR0Aq9WK1WotxN+g8C7fvtkdl7lSj1oKtmPbclo/9yxVMiDtq0+p1OUuU7tc6b5RS8FcscWVaW1yzceMK7SAa/W4Ukta2veULj0eb6/aZL5+kQ7LtpDt743vpYLbPIGG2WVpWq17kfe70v0CrtWjloI5usFiGMbVnmAoEklJSVSpUoWNGzfSpk2bK9tfeeUVPvroIw4cOJDvOgcOHGD9+vWEh4eTnZ3NggUL+OCDD1i7di3t2rUr8HYmTpzIpEmT8m1ftGgRAQEBRfcXEnGwpAOrue2V9/DGk58mvoRRo67ZSSL/SmZmJgMHDuT8+fN5DpNzJVqbRP4dL6+NBAS8jTWnDj7PHydi+zkWP9iJ4Lb34vv/TxbYDTuHLx0mPTedQK9AavrXxFruOrKCg02uF3H82uS0oWrTpk20bt36yvaXX36ZBQsW/OM3+Pbq1QuLxcJXX31V4PcLejYwNDSU5ORkgoKCCveXKCSr1UpMTAxdu3bF29vb1BZX61FLXus+fZ0mDz/PhXKl2DnxNbreN8T0+wVc475RS/FpSU9PJzg4uFgMVVqbXOMx40otrtbjCi3JyTM4fHgUZQJuxX7fahocvcTOqOcIf3iiKT3gGveLq/aopWCOXpscfvhfcHAwnp6epKSk5NmemppKxYoV//Gf06pVKxYuXHjV7/v6+uLr65tvu7e3t+k/xMtcqQVcq0ct8N27T9JuzHscqxlM1R+2w7Y4l7pfQD+nq1FL/gZXp7Xpd2q5OlfqMaPFMAyOHHmBxMSXuS5gIH59llLhTA4HPplOq34jnNpyNa70MwLX6lFL/gZHcviJKnx8fAgPDycmJibP9piYmDyHXPyduLg4QkJ0Ok4peQzD4Jvn7qbrqPc4dHN1btx+BN8KeqyLOJLWJpG/ZrfncuDAQyQmvkxZjyEEdV9M6Ys2lk8ZT/07HzI7T8TlOOWU6pGRkQwaNIhmzZrRunVrZs2aRWJiIsOHDwdg3LhxnDhxgvnz5wMQFRVF9erVqV+/Pjk5OSxcuJDPP/+czz//3Bm5Ik5jt9v49uEO9JqzgZ9vu5mmX2zB4u2N3QXe0ClS0mltEimYzZZJfPw9pKUtp/TFwYT1n0daOR/8Vq6l9KGTZueJuCSnDFUDBgwgLS2NyZMnk5ycTIMGDVi+fDlhYWEAJCcnk5iYeGX/nJwcxowZw4kTJ/D396d+/fp8++233Hrrrc7IFXEKqzWbH/o0odc3+/lpSA+az1kOFovZWSJuQ2uTSH5W6xl27+7FhQs78E28m3rD5nGwRiDV1+4kILgKHFpudqKIS3LKUAUwYsQIRowo+PjbefPm5bn8zDPP8MwzzzihSsQcmRfPsbVrfbptSWLb+CE0nzLX7CQRt6S1SeR3WVnH2LWrBzk5J2FrB5o/u5ht4ZVp8sMe/Mpc5xKnxRZxVU758F8R+d3Z1ET2tqhO661J7H73eZppoBIREZNdvLiXuLg22GwXyV12E+2eXs6m7vVovvEIfmWuMztPxOVpqBJxopRDO0luVpvah9I59Ml0Gj/+ktlJIiLi5s6f30hcXARenteRHeVHh7c3s/Y/nYj4Zjee3j5m54kUCxqqRJzk6PYfyGrVjKBzOZz6bin17naN09GKiIj7On36K3bu7IK/X12sz5wm4rMDxI4fRIc5P2Dx0K+JIv+U/rWIOMH+lYso1aErWCzkxq7jho59zE4SERE3l5Q0mz17elMmoAMeg/fQdGMy299/jogp881OEyl2NFSJONjOj6dR5Y77SA32p/TWnVRpfIvZSSIi4sYMw+Do0SkkJDxEuYA+BNy1huqHMzi4OJoWI142O0+kWHLa2f9E3NFPbz1F42ensbNeeeqs2UOZIH1IqIiImMcwbBw8OJKkpOmU9byfoB6L8DQspK36H41uucPsPJFiS0OViINseWYgrd74hPUR1Wi5ci++/qXNThIRETdms2Wxf/8gTp1aRulLgwjrt5C0sj6U/iGWWnWbm50nUqxpqBIpaobBlgc60WrhWmJ6N6bTpz/h6eVtdpWIiLix3Nzz7NlzF+npW/A9cTf1hizgYPVAwtbuoFzlGmbniRR7ek+VSBEycnL4qXtDWi1cy4pHu9Ll8zgNVCIiYqrs7GTi4tpz4cIO2N6J5g8sYVeTEG7adkQDlUgR0VAlUkRyL6Szs80NNPlhLysnDqJH9CosFovZWSIi4sYyMxOIi2uD1Xqa3C/r0i5yOZu61aX5xqP4B5Y3O0+kxNBQJVIELqUc55em1am1+zgbpj9L9wk6Ha2IiJgrPf0n4uLaYrH4Yn2/NB3e3MzawR2I+HaPPtRXpIhpqBIppPMJu0m9+SaCks6ya1EUHYe/anaSiIi4uTNnVrJjR0d8fWpge+48tyw+wPpx99HhwzX6UF8RB9CJKkQK4fSPa7B374bhaef4d0to066/2UkiIuLmUlIWcuDAEMqUag//2UbTfefZ9u5Y2j0+1ew0kRJLQ5XINTrx7WLK3H0fx67zwGvlapo2aG92koiIuLljx97i0KExlPW/A/8+K6l0KoeDi6fTsu8Is9NESjQNVSLX4MiHbxPycCRxNfypHLOFsLBGZieJiIgbMww7hw49w/HjbxHoOYDgnp/haVg4vfILGrW70+w8kRJPB9WK/EsHXxlDtaGRxDYuxw1bDmigEhERU9ntOezb9wDHj0+jVNa9hPX4lGxfL9iwkVoaqEScQq9UifxThsH+kfdT571FfNGlKp2/3EVgwHVmV4mIiBvLzb3A3r19OXduDb7Jfan34Cf8ElaGamvjuK7KDWbnibgNDVUi/4TNxv57ulJn6Ro+vqcefedvw8/b3+wqERFxYzk5qezefRuZmQew7OxC89FL2d60Eo1W79VnUIk4mQ7/E/k7WVkkdG7CjZ+v4aPHI7jn410aqERExFSXLh0hLq4tWVnHsH3bgHYjv2NTlzqEbzqigUrEBBqqRP6CcfYsh1vcSOjGPSyafDcPvLsOTw9Ps7NERMSNZWTsIC6uDYYB1pnX0eG1zax5oB0R3+3Fy8fP7DwRt6ShSuQqco8ncrzpDZQ7eJyvpj/JoOc/xWKxmJ0lIiJu7OzZNezY0R5vr0rYXsgkYuF+1o+9l44frdOH+oqYyGn/+qKjo6lRowZ+fn6Eh4cTGxv7j663ceNGvLy8aNKkiWMDRf4ge89OzjStA2fPsuHjqQx4+B2zk0TEAbQ2SXGSmvoZu3b1IMCvMZ6PHCF8bRI/vfMM7aYuMjtNxO05ZahasmQJo0aNYvz48cTFxREREUHPnj1JTEz8y+udP3+eBx54gM6dOzsjUwSAi7GryWrdjNMeWSR8PY87+ow1O0lEHEBrkxQnyckziI8fQBm/zpS6eys196dzYNF7tHriNbPTRAQnDVXTpk1j6NChDBs2jLp16xIVFUVoaCgzZsz4y+s98sgjDBw4kNatWzsjU4RSW9fj2/NW9gUZZMR8S+d2D5qdJCIOorVJigPDMPD1/ZjDh0dSxvMugm9bRdlzVk6t+JzGdz9udp6I/D+Hn1I9JyeH7du3M3Zs3mf7u3XrxqZNm656vQ8//JBDhw6xcOFCpkyZ8re3k52dTXZ29pXL6enpAFitVqxW6zXWF43Lt292x2Wu1ONKLanT36DDq9P4vo4vFb9cTYOw5qZ1udL9Aq7Vo5aCuWKLK9Pa5JqPGVdoAdfpMYxcDh58FD+/z/DL7EO1/ss4X8YH4/vvqV6/ldP7XOV++WODK7SAa/WopWCObnD4UHX69GlsNhsVK1bMs71ixYqkpKQUeJ2DBw8yduxYYmNj8fL6Z4lTp05l0qRJ+bavWbOGgICAfx/uADExMWYn5OFKPaa2GAZBn87llk++5uNm/mRGvkX23lMk7l1uXtP/c6WfEbhWj1oK5gotmZmZZif8La1Nv3OFx8xlrtQCZvdkExDwJl5e2zmzoxU9nl1GQmU/EiZOw+/XM+z41bw1ypV+Tq7UAq7Vo5a8HL02Oe3Df/981jTDMAo8k5rNZmPgwIFMmjSJm2666R//+ePGjSMyMvLK5fT0dEJDQ+nYsSNBQUHXHl4ErFYrMTExdO3aFW9vb1NbXK3H9Ba7nZRH7yf0k6+Z1bMCvkNe477b+ut+ceEetbh+y+VXY4oDrU2u8ZhxpRZX6LFaz7BvX28uXtyLfUdn7hgTw/bGFai7agcNygY7vef3Ltf5OblSi6v1qKVgjl6bHD5UBQcH4+npme+Zv9TU1HzPEAJkZGSwbds24uLiePzx344VttvtGIaBl5cXq1atolOnTvmu5+vri6+vb77t3t7epv8QL3OlFnCtHlNacnI40a87Vb5dx9uDajFo+mY2rt6o++UvuFKPWgrmCi1m3/4/obXpd2q5OjN6srKOsWdPD3JyTmJf1ZgOL8ewvHVlOsbsx79UGae2XI0r/ZxcqQVcq0ct+RscyeFDlY+PD+Hh4cTExNC7d+8r22NiYrjzzjvz7R8YGMju3bvzbIuOjmb16tUsXbqUGjVqODpZ3EFGBkldWxO8bS9vjmzOk2+sx9PQh/qKuAutTeKKLl7cy65dPQBPcudcT4d5m1l9X1ty+j6lD/UVcXFOOfwvMjKSQYMG0axZM1q3bs2sWbNITExk+PDhwG+HR5w4cYL58+fj4eFBgwYN8ly/QoUK+Pn55dsuck1OnuRk+2aUOnqcdyfdSuS4L/Hy8HKJN1GKiPNobRJXcv78Rnbv7oWPdxWsE87QbuWvrHtmABFTFrB8ufnv8RWRv+aUoWrAgAGkpaUxefJkkpOTadCgAcuXLycsLAyA5OTkv/1cEJGiYPzyC2faN8eefo557wxhzMNzCnz/hIiUfFqbxFWcPv0V8fEDCPBrjGXEfhrtPM+PUWNoP/INPeEnUkw47UQVI0aMYMSIEQV+b968eX953YkTJzJx4sSijxK3krttK5ld2pPmmcX6ec8xsu/LZieJiMm0NonZkpJmk5DwCGX8OxJw70ZCkrLYv/AdWg940uw0EfkXnDZUiZgpZ9V32O68gwNBuRxe8B7DOuoDE0VExDyGYfDrry9z9OgLlPG6neBe3+GTbZD63VKadOhrdp6I/EsaqqTEy1wwF+8hw4itaSF38RIG3Nzf7CQREXFjhmHj4MGRJCVNp1ROb6rd/gXppX3wjF3NTY3amp0nItfAw+wAEUfKeONlAh4YyrKGXpT67gdu1UAlIiImstmyiI+/h6SkGfievpO6vb4gpVJprvtpD1U1UIkUW3qlSkomw+Bc5GOUi5pBdPsAbvlkI41CmphdJSIibiw39zx79txFevoWPPd1odnjXxLXuAL1V++hVLnrzc4TkULQUCUlj9XK2Qfu5rrFX/LKXUHcM3crNa+raXaViIi4sezsZHbt6kl29q/Yv29Kh5dWEdv5Rlp9uxNvX3+z80SkkDRUScmSmcmZXl0ps3YTzw2pxpPv/kil0pXMrhIRETeWmZnArl3dsdut5M4LocOczay5ry0d5q/H4qF3YoiUBPqXLCVHWhpn24bjs2ETY0c34NnoXRqoRETEVOnpPxEX1xYLPthfgXZz9rH26bvpuHCDBiqREkT/mqVkSEzkfPNG5CbsZ8KLEUyZupWyfmXNrhIRETd25sxKduzoiI9XNTxHptJ8xQm2vB1Jh9c/NTtNRIqYDv+T4m/3bi50iiAt9zyz3uzDa48swctDD20RETFPSspCDhwYQinftgTc/yNVjmURv/Bt2twzyuw0EXEA/eYpxZqxfj1Zt3bjl9LZfPX+o0ztPx2LxWJ2loiIuLFjx97i0KExlPbqTvAd3+OXbZCy/FOadrrb7DQRcRAd/ifFlm3ZMnK7dGLz9dms+2gSLw6I1kAlIiKmMQw7v/wyhkOHxlDK2ouwHiuxWzywxq6jtgYqkRJNr1RJsWSNfh/Px5/gf/UsZM6ZyciWD5udJCIibsxuz2H//v+QmroI37TbqTvwa45ULUXImu0EV6ttdp6IOJheqZLixTDIfnE83o89wQctPPD99HMe1EAlIiImys29wO7dvTh16lM8E7rQrP83xNe7nprbDmugEnETeqVKig+bjUuPDMV/zkdM7uZLh5kraVe9vdlVIiLixnJyUtm9+zYyMw9grGtGxIQY1neqRetvd+LtF2B2nog4iYYqKR6ysrjYvzd+36xg9N2BPPjuOppUamJ2lYiIuLFLl46wa1c3cnMzsC2sSodZm1k9sA0dF8TqM6hE3Iz+xYvrO3eOi50i8PxuBY8MrcjjH/ysgUpEREyVkbGDuLg2GHYD4w0v2s3ax9qn+tLp440aqETckP7Vi2tLSuJi62bk7NjOw6Nu4KVpcdxQ/gazq0RExI2dPbuGHTva4+VRAc/IMzT/5gSb3xxFhzeXmp0mIibR4X/iMmx2G7GJsSRnJBNSJoSIzOvJ6dqJsxdPMe65prw35gfK+ZUzO1NERNxYaupn7Nt3PwG+4fg/uIPQXy+xd8FbtL030uw0ETGRhipxCV/s/4Knvn+K4+nHAWhxHJYvspBSyuCNKZ2Z+chXBHjrDb8iImKeEyemc/DgE5Ty6sT1vdfil2mQ/O1ibu48wOw0ETGZhiox3eZzm3l92esYGAD0OAhLP4W4SgZ33AsfdHxYA5WIiDidzW5j49GN2GNWUiUhmuTb0gnI7UHYHSu44O+Ndf0P1GkcYXamiLgAvadKTGWz25h9YvaVgeqBHfD1Ivi+JnR9AM4FWBizagw2u83cUBERcSubz22m1vRadP6oI97HXyX5tnTKLrBQ59YVpAaVInDrLkI1UInI/3PaUBUdHU2NGjXw8/MjPDyc2NjYq+67YcMG2rZtS1BQEP7+/tSpU4e3337bWaniRBuObSDNmgYGPL0BPvoffNgU+vaHLG8wMDiWfozYxKs/XkRErpXWJinIF/u/4LWjr3H64gk+qA62dlBnKjSda7Dvetiz+B2Cw+qYnSkiLsQph/8tWbKEUaNGER0dTdu2bZk5cyY9e/YkPj6eatWq5du/VKlSPP744zRq1IhSpUqxYcMGHnnkEUqVKsXDDz/sjGRxkuQLyVjs8NYqGL0FXmoHL3YELH/aLyPZlD4RKbm0NklBbHYbkTGRlPGCVxrAjb7Q4DkI3gp2wMOAZzZO5O7mg/H08DQ7V0RchFNeqZo2bRpDhw5l2LBh1K1bl6ioKEJDQ5kxY0aB+zdt2pR7772X+vXrU716de6//366d+/+l88gSvFU2SeYhctg5BYYcSu82Il8AxVASJkQp7eJSMmmtUkKEpsYS07OCd5tAjV94ebI3wYq+O2XpubJUDfuuI6gEJE8HP5KVU5ODtu3b2fs2LF5tnfr1o1Nmzb9oz8jLi6OTZs2MWXKlKvuk52dTXZ29pXL6enpAFitVqxW6zWUF53Lt292x2Uu05ORQavhU/DaB/3vhs/r59/FgoUqgVVoFdLK4b0uc7/gWi3gWj1qKZgrtrgyrU2u+ZhxhZbktM283wTsBjR5Asr8kvf7uRZ4aTUciEzEWsXxva5036jl6lypRy0Fc3SDxTAMw5E3kJSURJUqVdi4cSNt2rS5sv2VV17ho48+4sCBA1e9btWqVTl16hS5ublMnDiRF1544ar7Tpw4kUmTJuXbvmjRIgICdOY4V+N77hw3T34BvxPHuec+P76rdumq+z5b/Vlal2vtxDoRKYzMzEwGDhzI+fPnCQwMNDunQFqbpCCenvvwDZjM8YuXaPIMNN1/9X0XPf0Apdr2cV6ciBSKo9cmp51S3WLJe0yXYRj5tv1ZbGwsFy5cYMuWLYwdO5ZatWpx7733FrjvuHHjiIz8/YP30tPTCQ0NpWPHjgQFBRX+L1AIVquVmJgYunbtire3t6ktLtFz6BC5Pbpw/kwSg0fXoN/N4xl0oz9Pr36aExknruxWNbAqb3V5i951ejsly/T7xUVbXK1HLa7fcvnVmOJAa5NrPGZcoSUt7WsSEibh41GHm4fuoP6v//8eqgL2tVngntV7sU35L/zN46WwXOG+UUvx6lFLwRy9Njl8qAoODsbT05OUlJQ821NTU6lYseJfXrdGjRoANGzYkJMnTzJx4sSrLly+vr74+vrm2+7t7W36D/EyV2oBk3p+/pnsbp05znmef6EZM4d/y6bVm7i1/q30b9Sf2MRYkjOSCSkTQkS1CFPeBOxKPydXagHX6lFLwVyhxezb/ye0Nv1OLZCUNJuEhEfwt7Skcp8fsWRbOOdnEHyVgyg8DeDECTwMA3x8nNKon1PBXKkFXKtHLfkbHMnhQ5WPjw/h4eHExMTQu/fvrzjExMRw5513/uM/xzCMPMelSzH0ww/k3HEbu67LJnribXw0eCmexu9Dk6eHJx2qdzCvT0TchtYmgd9+fr/++jJHj76A76UIbro7ltRyvvitXs1/Vy1k3fGlpF48dWX/SqUrMqbNGDrV6AQVKkABA7OIuCenHP4XGRnJoEGDaNasGa1bt2bWrFkkJiYyfPhw4LfDI06cOMH8+fMBmD59OtWqVaNOnd8+A2LDhg28+eabPPHEE87IFQcwPvkE+wODWB1mY8XUoczuOxNPD0+XeOOiiLgnrU3uzTBsHDw4kqSk6Xin3EKTQbHsq1WWGmt2UjqoMvUOnWL0Y9PYkrzF9CMoRMT1OWWoGjBgAGlpaUyePJnk5GQaNGjA8uXLCQsLAyA5OZnExMQr+9vtdsaNG8eRI0fw8vLihhtu4NVXX+WRRx5xRq4UMfs7UXiMGs2iRpA4bQJvd5rwt+9ZEBFxNK1N7stmy2L//kGcOrUMy+5mtB65gU1tQmm2cjd+pcpeecJPR1CIyD/ltBNVjBgxghEjRhT4vXnz5uW5/MQTT+iZv5LAMMgd+wxer7/Jm22gbNQHjG+uXz5ExHVobXI/ubnn2bPnLtLTt8DKG2n/6jZW92lK+yU/4unlGu8/EZHix2lDlbgZq5WcoYPxWbCIZ3t60WbaUu6s88/fpyAiIlLUsrOT2bWrJ1lZv2KZXZ4OCw6w+onb6fjOVzqCQkQKRUOVFL3MTLL63IFnzA88PCCAB19fRdtqbc2uEhERN5aZmcCuXd2x5Wbj+5JB49VJbHjtcTo9857ZaSJSAmiokqKVlsalHp2x79rF0IeCeW7yWupXqG92lYiIuLH09J/YvftWLEYZyj1xhir7s9kz/01uGfiU2WkiUkJoqJKik5jIpc7tuJicyGOjqvPmc+sILRtqdpWIiLixM2dWsmdPX7yNUEIeOIjPeYOU5Z8S3vFus9NEpATRUCVFY/dusrp0JMV6hueev5kZI1dR3r+82VUiIuLGUlIWcuDAELxz6lFrwC7O+frguWENdRq0MTtNREoYD7MDpASIjSWnTUv2e6Qx6ZVuzH0qVgOViIiY6tixt9i/fxCeZ+vTuNcuTgQHErQtnlANVCLiABqqpFCML74gt0snNgRf4sO3BzP74W/w9/Y3O0tERNyUYdj55ZcxHDo0BsvhBrTqs5MdTSpTe/tRyle5wew8ESmhNFTJNbPP/ACjX1+W1cpl48zxRA2Yi5eHjigVERFz2O057Nv3AMePT8OypRbth+4h9vaGtIo9gn+Z68zOE5ESTEOV/HuGQe7EF/EY/ijRzQzOzp3OC92m6DM+RETENLm5F9i9uxenTn2Gx7JKtB/3Cz882oMO/9uBp7eP2XkiUsLpZQX5d2w2sh99GN//zuXFLp40fedTetfrY3aViIi4sZycU+zefRsXL+7D9/0Awpcls37KQ3QeP8vsNBFxExqq5J/LyuLSgL74fL2cJ/r60/+tlUSERZhdJSIibuzSpSPs2tUda/YZAl/I5YYtF9gx52XaDX7O7DQRcSMaquSfOXeOzFu74bFtG0OHlGfM1HU0qNDA7CoREXFjGRk72L27J3arJ5VGnKfMMTuJXy+kebf7zE4TETejoUr+XlISmZ3bk/3rIUY8EcprL8ZSrWw1s6tERMSNnT27hj177sJiLU+tQUe5mOtN1vrV1G/S3uw0EXFDOlGF/LUDB7jUoilnkg/x2LhGvP/SzxqoRETEVKmpn7FrVw/IuJ5GvY+S6l+asj/tJkwDlYiYREOVXN2PP5LVqhmHc1J5YUpnZo/dRFBAkNlVIiLixk6cmE58/ABICaVl70PE16rIDdsOE1ytttlpIuLGNFRJgYzly8npEMG2MheY9fb9/HfEdwR4B5idJSIibsowDA4ffp6DBx+HfaG0u/cQmzrWodnmo5Qqd73ZeSLi5jRUST72eR9i73U734VZ+WHms0QNnK8P9RUREdPY7bkcOPAQiYkvY1lTgQ4jEln9n460X74XLx8/s/NERDRUyR8YBrmvvoLHkP/wYRODpA/fZULPV/WhviIiYhqbLZO9e/uSkjIPn0/K0nZKKmsnDKbz7NVYPPRrjIi4Br38IL+x28ke9QS+70XzSnsPak9fQt/6/cyuEhERN2a1nmH37l5cyIijTJQPtb87z/YPJtDhoYlmp4mI5KGhSiAnh0v334Pv0i946g4/7nhnBe2r6wxKIiJinqysY+za1YOsSye4fryV4B02jn4+l5a3DzE7TUQkHw1V7i4jg8xePfDcsIlH7i/HE2+so1HFRmZXiYiIG7t4cS+7dvUgNyuL6iPSsZ/25MLaVTRo1sXsNBGRAjntYOTo6Ghq1KiBn58f4eHhxMbGXnXfZcuW0bVrV66//noCAwNp3bo1K1eudFaq+zh5kou3tCT3x8089Fgoz7+7QwOViLgVrU2u5/z5jcTFRWDNsFFv4GnSs/wJ2BpHDQ1UIuLCnDJULVmyhFGjRjF+/Hji4uKIiIigZ8+eJCYmFrj/+vXr6dq1K8uXL2f79u107NiRXr16ERcX54xctxCQnExO2xZkHN7PiGfqM23qz4SVCzM7S0TEabQ2uZ60tK/ZubMLtjR/mvdL5lDFYMK2H6JCjQZmp4mI/CWnDFXTpk1j6NChDBs2jLp16xIVFUVoaCgzZswocP+oqCieeeYZmjdvzo033sgrr7zCjTfeyNdff+2M3JIvLo5Wzz7FiYvJPPdSe2aO30JwQLDZVSIiTqW1ybV4e8ewf//d2H8txy13J7G1RS2a/phImfKVzE4TEflbDn9PVU5ODtu3b2fs2LF5tnfr1o1Nmzb9oz/DbreTkZFB+fLlr7pPdnY22dnZVy6np6cDYLVasVqt11BedC7fvtkdAJbVq7H3voN91+Uw76V+vD/wI7wt3qa1udJ9o5arc6UetRTMFVtcmdYm13nMGIZBYuIrBARMhx3laf9UCj8MbEO72avBw8OUPle5b/7YoJa8XKkFXKtHLQVzdIPFMAzDkTeQlJRElSpV2LhxI23atLmy/ZVXXuGjjz7iwIEDf/tnvPHGG7z66qvs27ePChUqFLjPxIkTmTRpUr7tixYtIiAg4Nr/AiVIyPr1NH3nbX6obvDx43fRt/qD+gwqESlymZmZDBw4kPPnzxMYGGh2ToG0NrkKG35+c/D1XY6x3J+INy+x+P4IyvR9yuwwESlhHL02Oe3sf3/+5d0wjH/0C/0nn3zCxIkT+fLLL6+6aAGMGzeOyMjIK5fT09MJDQ2lY8eOBAUFXXt4EbBarcTExNC1a1e8vb1NabC/G4XvtGksaASn33mNfudrm9pzmSvcN2opXj1qcf2Wy6/GFAdam8x7zNjtWSQkDCYtbQUB8/1osPASm94ew4ARrzi95c/Mvm/UUrxaXK1HLQVz9Nrk8KEqODgYT09PUlJS8mxPTU2lYsWKf3ndJUuWMHToUD777DO6dPnrs/74+vri6+ubb7u3t7fpP8TLTGkxDLKfGYPvm9OY1taDqjM+5vE6fVm+fLnum6tQy9W5Uo9aCuYKLWbf/j+htel3ZrTk5p5n3767OH9uM0HTPKj8QzZLxz/KvSNecZn7BfRzuhq1XJ0r9aglf4MjOfxEFT4+PoSHhxMTE5Nne0xMTJ5DLv7sk08+YfDgwSxatIjbbrvN0Zklk9XKpQcG4vvmNMbd6kvTBd/Tv+E9ZleJiJhOa5N5srOTiYtrz/mzPxE6NodyGw1Or/gfZZt0NztNROSaOeXwv8jISAYNGkSzZs1o3bo1s2bNIjExkeHDhwO/HR5x4sQJ5s+fD/y2aD3wwAO88847tGrV6sozif7+/pQtW9YZycVfZiYXe9+Oz/dreGxgWR56ay1NKjUxu0pExGVobXK+zMwEdu3qTvbFs9QZcZEzl/wI+HEzNcPqs3/5crPzRESumVOGqgEDBpCWlsbkyZNJTk6mQYMGLF++nLCw3z4XKTk5Oc/ngsycOZPc3Fwee+wxHnvssSvbH3zwQebNm+eM5OItLY0L3Tti2b2Hhx+pzIsvb6DGdTXMrhIRcSlam5wrPf0ndu++ldx0O02HnudAUHlu2rCTstdXdYkzg4mIFIbTTlQxYsQIRowYUeD3/rwYrV271vFBJVViIhc73UJW8jGeGlOXN59bx/Wlrje7SkTEJWltco4zZ1ayZ09f7Kd9aDvkLFuaVKflit34+Jc2O01EpEg45cN/xUl27yazeRNOnjnGs5MjmD5hqwYqERExVUrKQnbvvh37IS8iBp5lfc+WtF3ziwYqESlRNFSVFLGxZLdpQYLlLFFv3c0Ho36gtI8WLBERMc+xY2+xf/8gLNt8iRh2nvWP9aXz4i14eHianSYiUqScdvifFB2b3UZsYizJGcmElAnhlp9PY9xzDxur2FgXNYp37pimD/UVERHTGIadQ4ee4fjxt/Bd4UeTty6y5a1IOo56y+w0ERGH0FBVzCzbt4yRK0ZyPP04AA9tg4hvYVldSJ3xJpPa6VPoRUTEPHZ7Dvv3/4fU1EUEfuRFjSXZ7F/0Lm3vfsLsNBERh9Hhf8XIsn3L6Pdpv98GKgNeWAuzvoHo5nBvP6h8vc7wJyIizmez29i58C3O1KvMplUNSU1dQqU3oOL/DE6v/IKmGqhEpITTUFVM2Ow2Rq4YiYGBhx2iv4XJa+G5TvBkTzA8LIxaMQqb3WZ2qoiIuJFl+5ZRPSqMrCljOPJEMjZ7AjWfzcUe54Vl02ZujLjT7EQREYfTUFVMxCbGcjz9OL5W+PQzeHg7DL0DprYDLGBgcCz9GLGJsWanioiIm7h8BEXrgydgPGRVhJtHwplfoc2DVrZwzOxEERGn0FBVTCRnJFP2EqxcCLcehLvugbk3F7yfiIiIo10+gqJmKYMR3cCwwM2PQ6lfINcD0n3RERQi4jY0VBUTYZnerP8QGp6Ezg/AN7UL3i+kTIhzw0RExC3FJsYS7HGc9xtB6VS4+QnwT/7tF4tmydD1EDqCQkTchoaq4uDAARr2Hs51WXDLf2Bztfy7WLAQGhhKRLUI5/eJiIjbOXv6C15rCMF7oPFo8Dn3+/dyLfDSasDQERQi4h40VLk4Y8sWLrZoSmJuGuNeas/+ChYs5P0MqsuXo3pE4akPVBQREQc7cWI65S68R+lNcPOz4H0p7/e9DGiRBN0O6QgKEXEPGqpcWO43X5PTIYK4spf4ft6LLHhiDUv7L6VKYJU8+1UNrMrS/kvpU7ePSaUiIuIODMPg8OHnOXjwccp8a6H5BCC34H1twGvrvIkIvcWZiSIiptCH/7qoS7M/wOeREay6CS5+NJeRLYYA0KduH+6sfSexibEkZyQTUiaEiGoReoVKREQcym7PJSFhOCkpc6jwoYXSX0NumVJ4n79Y4P6eQJ1LpfDMtYGnft0QkZJN/5dzNYZB+pQXCHzxZT5q7k3owm/odVO3PLt4enjSoXoHc/pERMTt2GyZxMffS9rpb6j+Jlzc44fPT5vx9ynP6q1LeGPTG5y8kHpl/0qlKzKmzRg6tbwHfH1NLBcRcQ4NVa7EbidtxBCCZs4nqksZOi2IpVGlxmZXiYiIG7Naz7B7dy/Sz26l3vN2jlwKpu7POwkMqgxAp9AxtO89WkdQiIhb01DlKnJySL37NoK//p6XBoQweOaPhJYNNbtKRETcWFbWMXbt6kHmmYPcHJnLz1VvpO3anXj7+ufZT0dQiIi704kqXEFGBic7NKPst98zaUQ9npgXr4FKRERMdfHiXn7+uTWZSQdp8bCVn1p3pP2K/fkGKhER0VBlvpMnOdmiHn4/7+b1FzrxXNTPlPMrZ3aViIi4sfPnN/Lzz7eQe+QkzR62snXYEDrPWY3FQ782iIgURIf/mcj+y0HOtGuOPeM8H0YNZvwjc/CwaMESERHznD79FXv39scr3krd5+3EvzWFDoPHm50lIuLSNFSZJHvrZi5168gZz2w2L5jAqLsmmp0kIiJuLjl5DgcOPEypzQaV34LkxR/ToutAs7NERFyehioTZCz/H559+/FLkJ2TSz7kwbaDzU4SERE3ZhgGiYmvcOTI8wR9C74fe5O7ZjX1G+qDe0VE/gmnHWsWHR1NjRo18PPzIzw8nNjY2Kvum5yczMCBA6lduzYeHh6MGjXKWZkOd2rOe/jd0ZvN1TzI/X4Vt2mgEhExjdYmMAwbBw8+wZEjz1N1HuR8XYbgn/YRpoFKROQfc8pQtWTJEkaNGsX48eOJi4sjIiKCnj17kpiYWOD+2dnZXH/99YwfP57GjUvO5zQlTR3H9cOe5Jumpai69mda1elidpKIiNvS2gSQw4ED95F0Yjo3vgUpB6tSb1si5avcYHaYiEix4pTD/6ZNm8bQoUMZNmwYAFFRUaxcuZIZM2YwderUfPtXr16dd955B4C5c+f+o9vIzs4mOzv7yuX09HQArFYrVqu1sH+FQrHm5BA0+03CvtnA/K4V6PTJT1QMDDGt6/Ltmn2//LFBLXm5Ugu4Vo9aCuaKLa7O3demS5dOExAwibST8dSfCDsq3UzE97F4enk7vc2VHr/gWj1qKZgrtYBr9ailYI5usBiGYTjyBnJycggICOCzzz6jd+/eV7aPHDmSHTt2sG7dur+8focOHWjSpAlRUVF/ud/EiROZNGlSvu2LFi0iICDgmtqLgiU3l4pvv0DLjft4+46qhDz4Bv6e+owPESm5MjMzGThwIOfPnycwMNDsnAK5/dpkOUOA/0Q8rcdo8qzBtw1bUbr/s1gsFtOaREQcydFrk8NfqTp9+jQ2m42KFSvm2V6xYkVSUlKK7HbGjRtHZGTklcvp6emEhobSsWNHgoKCiux2/g3j4kWO9mxJja0JvDqoASOiN+LvAh+aaLVaiYmJoWvXrnh7e6tFLcWqRy2u33L51RhX5s5r06VLCeze1YPcUydo8IzBjuFPMuDJN01pucyVHr+u1qMW129xtR61FMzRa5PTzv7352e/DMMo0mfEfH198fX1zbfd29vblB9i7qmTHItoROXDqSyeej91buqLv6+/6Q+oPzLrvimIWgrmSi3gWj1qKZgrtJh9+/+Gu61N6ek/sTOuG5Zj57npeYNvBj/CwCffdJmfmSs8fv/IlXrUUjBXagHX6lFL/gZHcviJKoKDg/H09Mz3zF9qamq+ZwhLisxf9pPcpBZljqWyZu4L3DN6rg6pEBFxIe64Np05s5K47RH47DtH5ec9OLfgS8o17Wl2lohIieDwocrHx4fw8HBiYmLybI+JiaFNmzaOvnmnS/txLReaNyL30kX2fzmHXvdPNjtJRET+xN3WppSUhezaeSuBP2YTMM2fgNU/U6uVBioRkaLilMP/IiMjGTRoEM2aNaN169bMmjWLxMREhg8fDvx2zPmJEyeYP3/+levs2LEDgAsXLnDq1Cl27NiBj48P9erVc0byNTn2zSLK9h9E8nUe2JevIKJxN7OTRETkKtxmbTr2FocOjaHCCjj/fRANtuyhTPlKLnE2LhGRksIpQ9WAAQNIS0tj8uTJJCcn06BBA5YvX05YWBjw2wcq/vlzQZo2bXrlv7dv386iRYsICwvj6NGjzkj+Sza7jdjEWJIzkgkpE0JEtQh+mfsmYY+OZUfNAEJWbSYsrJHZmSIi8hdK2tr0Z4Zh59Chpzl+fBrVFsKvx2/klk078XaBEyaJiJQ0TjtRxYgRIxgxYkSB35s3b16+bQ4+0/s1W7ZvGSNXjOR4+vEr20bvKsUbX1xkXXgQTWJ2U75ciImFIiLyT5WUtenPT/a1rdqShP3/4dSpxdR6D/YHdaLz8hgsHg4/6l9ExC05bagqCZbtW0a/T/th8P+LqgEvrIPJay/yXguoMOtdDVQiIuJUl5/sqx13nHe/g6d6we29fKhfOoebXoWEjkPp8vxsszNFREo0DVX/kM1uY+SKkVcGKg87vL8cHt0Gz3WCVyOg6uqx9Gs4AE8PT5NrRUTEHVx5ss8w+PwHqGWF59qAzTeHWs/DirsH8p8xGqhERBxNxwH8Q7GJsVcO+fO1wqefwcPbYegdMLUdGBY4ln6M2MRYk0tFRMQd/PHJvm6HoKEd4t4Dj/JQ8xm49WaY6BmLzW4zO1VEpMTTUPUPJWckA1D2EqxcCLcehLvugbk3F7yfiIiII115ss+ASYfg5/cBCzR9HM6cht0V9WSfiIizaKj6h0LKhBCSDus/hIYnofMD8E3tgvcTERFxtMtP4g3LBOtz4Hsamj4BAcnQ5CR0O5R3PxERcRwNVf/QhV3b2TQHrsuCW/4Dm6vl/b4FC6GBoURUizAnUERE3EpImRDaB8F9XSFwHzQZDT7nfvtergVeWg0YerJPRMQZNFT9DbthZ+b0/9DqnjEYpQJoMxT2V7Dk2cfCb5ejekTpJBUiIuIUNYhjQj2osA4aPgdel37/npcBLZLgvuRgPdknIuIEGqr+woWcC7w87hbuH/0hWbXCqL4rkXce+pwqgVXy7Fc1sCpL+y+lT90+JpWKiIi7MAyDhPjRHDkaSdXPofYr4JGbfz8b8O6msnhatNSLiDiaTql+FUfPHWX2yAgmLjzO6Q4tqPrNWvD3p09QH+6sfWeeD1mMqBahV6hERMTh7PZcdm/rz9nML6jyXwj7phSexsUC9/UEyp++CDk54Ovr3FARETejoaoA64+uY81jtzJleSZn7+tLpXmLwev3u8rTw5MO1TuYFygiIm7HZstk24ZOXMr9kUrvWch5bCE+r0bAqVPY7DbiUuI4ffE0waWCaVqp6W9P9lWooIFKRMQJ3HaostltBb7a9N+fZpI58lEmbDbIfPYprpv6Blgsf/8HioiIOIjVeoYf1zTDbj/Cde96UeqN9YTWb/3bN0ND8QSa0dzURhERd+aWQ9WyfcsYuWLklQ/zBahapipNy9fnnrdWMnQv2N57l4DHnzCxUkRE3NGfn/RrUaE6P629GU/rWXxmlaHah7u5rmKY2ZkiIvIHbjdULdu3jH6f9sPAyLP93OnjPDH9OB0SPfD4dAn062dSoYiIuKs/P+lX3R8+qAOBmZC9rCrNl+7D17+0yZUiIvJnbnVKIJvdxsgVI/MNVBUuwJp50OIE3PdwELY+vc0JFBERt7Vs3zJmTO3LyleO0/kQNC4NsxtA+VPw/SJIm/C2BioRERflVkNVbGJsnkP+AGqegY1zoEoGtBsCn1U4RWxirEmFIiLijmx2GyO/e5KXf4B6p+HlM/B2Q7guAT6IgQnhFkavisRmt5mdKiIiBXCroSo5IznP5aZJsGkO2C3QZijsqlTwfiIiIo4UmxhLvbgTtEiC5Fvh0mgo/yM8uwvm1gUDg2Ppx/Skn4iIiyrx76my2W2sPbqW5IxkTl48eWV7p8Pwv8WwLxhuuw9Ol/r9OiFlQkwoFRERd/LHE1LEp+5l8mo4cj/8OhQqfwlZi+D7R/NeR0/6iYi4phI/VDX5bxOSrb8vQhYs3L3HYMEyWF0D+vWHi76/f69qYFUiqkWYVCsiIu7g64SveWHLC1cOSe9+CAb1g197Q/W5ELYALEC3Q7Cq1u/X05N+IiKuqcQf/vfnZ/Ue32LwyVJY0gB6Dcw7UAFE9Yj67QMTRUREHGTIV0OoHXecve9DtyMwuTYk3QE3vQnV/3+gyrXAS6sB47c1KjQwVE/6iYi4qBI/VF1hwCvfw7sr4K028J/eHuT+YXaqGliVpf2X0qduH/MaRUTEbbzyA9x0CaY0haxmUH8CVP729+97GdAi6bdXsUBP+omIuLISf/gfgJcNZn0NQ3ZAZDd4uw2Anbe7v03FUhUJKRNCRLUILVYiIuIU514Fv/IQFwXZFaHRGCi3J/9+NuDVdd48PO4TPeknIuLCnPZKVXR0NDVq1MDPz4/w8HBiY//6DEbr1q0jPDwcPz8/atasyQcffHBNt+tnhS8Ww/274L4+lweq31QsVZF7G95Lh+odNFCJiLghs9amS5Uh7n2wloUmTxY8UAF4Ao1zytPnhtuv6XZERMQ5nDJULVmyhFGjRjF+/Hji4uKIiIigZ8+eJCYmFrj/kSNHuPXWW4mIiCAuLo7nnnuOJ598ks8///xf3/bXn0CHo3DbQFjUKO/39IZfERH3ZebatOsN8MiGmx+H0kd/2/ZYT7j54d++tn09E7Zvh+3bsWzbBr6+hfibioiIoznl8L9p06YxdOhQhg0bBkBUVBQrV65kxowZTJ06Nd/+H3zwAdWqVSMqKgqAunXrsm3bNt5880369u1b4G1kZ2eTnZ195fL58+cBuP4MtBsIcSFA1u/7Vw6sTL1S9UhLSyuav+RfsFqtZGZmkpaWhre3t8Nvrzj1qMX1W1ytRy2u35KRkQGAYRimdvwdM9cm22G44XXIyYAcIBfoGwfRjX9bn6q1vIu0Px5B4YC1ypUeM67U4mo9anH9FlfrUUvBHL42GQ6WnZ1teHp6GsuWLcuz/cknnzTatWtX4HUiIiKMJ598Ms+2ZcuWGV5eXkZOTk6B15kwYYIB6Etf+tKXvlzk69ixY0WzkDiA1iZ96Utf+nLPL0etTQ5/per06dPYbDYqVqyYZ3vFihVJSUkp8DopKSkF7p+bm8vp06cJCcl/2N64ceOIjIy8cvncuXOEhYWRmJhI2bJli+Bvcu3S09MJDQ3l2LFjBAYGmtriaj1qcf0WV+tRi+u3GIZBRkYGlStXNrXjr2htcq3HjCu1uFqPWly/xdV61FIwR69NTjv7n8ViyXPZMIx82/5u/4K2X+br64tvAcecly1b1vQf4mWBgYEu0wKu1aOWgrlSC7hWj1oK5iotZg8M/5TWJtd5zIBrtYBr9ailYK7UAq7Vo5b8HLk2OfxEFcHBwXh6euZ75i81NTXfM36XVapUqcD9vby8CAoKcliriIi4B61NIiJSlBw+VPn4+BAeHk5MTEye7TExMbRp06bA67Ru3Trf/qtWraJZs2amv8lNRESKP61NIiJSlJxySvXIyEhmz57N3Llz2bdvH6NHjyYxMZHhw4cDvx1z/sADD1zZf/jw4fz6669ERkayb98+5s6dy5w5cxgzZsw/vk1fX18mTJhQ4GEXzuZKLeBaPWpx/RZwrR61uH5LcaG1SS1X40o9anH9FnCtHrWYw2IYzjnnbXR0NK+//jrJyck0aNCAt99+m3bt2gEwePBgjh49ytq1a6/sv27dOkaPHs3evXupXLkyzz777JWFTkREpChobRIRkaLgtKFKRERERESkJHLK4X8iIiIiIiIllYYqERERERGRQtBQJSIiIiIiUggaqkRERERERAqhWA9V0dHR1KhRAz8/P8LDw4mNjf3L/detW0d4eDh+fn7UrFmTDz74wJSW5ORkBg4cSO3atfHw8GDUqFFF1vFvW5YtW0bXrl25/vrrCQwMpHXr1qxcudK0ng0bNtC2bVuCgoLw9/enTp06vP3226a0/NHGjRvx8vKiSZMmprSsXbsWi8WS72v//v1ObwHIzs5m/PjxhIWF4evryw033MDcuXOLpOXf9gwePLjA+6Z+/fpObwH4+OOPady4MQEBAYSEhDBkyBDS0tJMaZk+fTp169bF39+f2rVrM3/+/CLpkL+mtanwLY5em1xpXfq3PX+ktSkvR65NrrQu/dse0NrkFEYxtXjxYsPb29v473//a8THxxsjR440SpUqZfz6668F7n/48GEjICDAGDlypBEfH2/897//Nby9vY2lS5c6veXIkSPGk08+aXz00UdGkyZNjJEjRxa64VpbRo4cabz22mvG1q1bjYSEBGPcuHGGt7e38fPPP5vS8/PPPxuLFi0y9uzZYxw5csRYsGCBERAQYMycOdPpLZedO3fOqFmzptGtWzejcePGhe64lpY1a9YYgHHgwAEjOTn5yldubq7TWwzDMO644w6jZcuWRkxMjHHkyBHjxx9/NDZu3FjolmvpOXfuXJ775NixY0b58uWNCRMmOL0lNjbW8PDwMN555x3j8OHDRmxsrFG/fn3jrrvucnpLdHS0UaZMGWPx4sXGoUOHjE8++cQoXbq08dVXXxW6Ra5Oa1PRtDhybXKldelaei7T2pSfo9YmV1qXrqVHa5NzFNuhqkWLFsbw4cPzbKtTp44xduzYAvd/5plnjDp16uTZ9sgjjxitWrVyessftW/fvkgXrsK0XFavXj1j0qRJLtPTu3dv4/777zetZcCAAcbzzz9vTJgwocgWrn/bcnnhOnv2bJHcfmFavvvuO6Ns2bJGWlpakbdcS8+fffHFF4bFYjGOHj3q9JY33njDqFmzZp5t7777rlG1alWnt7Ru3doYM2ZMnm0jR4402rZtW+gWuTqtTUXfcllRrU2utC4VpkdrU16OXJtcaV26lh6tTc5RLA//y8nJYfv27XTr1i3P9m7durFp06YCr7N58+Z8+3fv3p1t27ZhtVqd2uIoRdFit9vJyMigfPnyLtETFxfHpk2baN++vSktH374IYcOHWLChAmFuv2iaAFo2rQpISEhdO7cmTVr1pjS8tVXX9GsWTNef/11qlSpwk033cSYMWO4dOmSKT1/NmfOHLp06UJYWJjTW9q0acPx48dZvnw5hmFw8uRJli5dym233eb0luzsbPz8/PJs8/f3Z+vWrYX6f55cndYmx7UU1drkSutSYXq0NuXnqLXJldala+3R2uQcxXKoOn36NDabjYoVK+bZXrFiRVJSUgq8TkpKSoH75+bmcvr0aae2OEpRtLz11ltcvHiR/v37m9pTtWpVfH19adasGY899hjDhg1zesvBgwcZO3YsH3/8MV5eXoW6/cK2hISEMGvWLD7//HOWLVtG7dq16dy5M+vXr3d6y+HDh9mwYQN79uzhiy++ICoqiqVLl/LYY48VquVae/4oOTmZ7777rtCPl2ttadOmDR9//DEDBgzAx8eHSpUqUa5cOd577z2nt3Tv3p3Zs2ezfft2DMNg27ZtzJ07F6vVWqj/58nVaW1yXEtRrU2utC5da4/WJueuTa60Ll1rj9Ym5yi6f40msFgseS4bhpFv29/tX9B2Z7Q40rW2fPLJJ0ycOJEvv/ySChUqmNoTGxvLhQsX2LJlC2PHjqVWrVrce++9Tmux2WwMHDiQSZMmcdNNNxX6dgvTAlC7dm1q16595XLr1q05duwYb775Ju3atXNqi91ux2Kx8PHHH1O2bFkApk2bRr9+/Zg+fTr+/v5O7fmjefPmUa5cOe66665CN1xLS3x8PE8++SQvvvgi3bt3Jzk5maeffprhw4czZ84cp7a88MILpKSk0KpVKwzDoGLFigwePJjXX38dT0/PQrfI1WltKtoWR6xNrrQu/ZserU3mrU2utC792x6tTc5RLF+pCg4OxtPTM98UnJqamm9avqxSpUoF7u/l5UVQUJBTWxylMC1Llixh6NChfPrpp3Tp0sX0nho1atCwYUMeeughRo8ezcSJE53akpGRwbZt23j88cfx8vLCy8uLyZMns3PnTry8vFi9erXTWq6mVatWHDx48Jo7rrUlJCSEKlWqXFm0AOrWrYthGBw/ftzpPZcZhsHcuXMZNGgQPj4+heq41papU6fStm1bnn76aRo1akT37t2Jjo5m7ty5JCcnO7XF39+fuXPnkpmZydGjR0lMTKR69eqUKVOG4ODga26Rq9PaVPQtRb02udK6dC09Wpucvza50rp0rT1am5yjWA5VPj4+hIeHExMTk2d7TEwMbdq0KfA6rVu3zrf/qlWraNasGd7e3k5tcZRrbfnkk08YPHgwixYtKvTxtUXR82eGYZCdne3UlsDAQHbv3s2OHTuufA0fPpzatWuzY8cOWrZs6bSWq4mLiyMkJOSaO661pW3btiQlJXHhwoUr2xISEvDw8KBq1apO77ls3bp1/PLLLwwdOrRQDYVpyczMxMMj7/9WLz/zdvnVB2e1XObt7U3VqlXx9PRk8eLF3H777fkapWhobSraFkesTa60Ll1Lj9Ym569NrrQuXWuP1iYncex5MBzn8ikc58yZY8THxxujRo0ySpUqdeXMKmPHjjUGDRp0Zf/Lp60dPXq0ER8fb8yZM6fIT1v7T1sMwzDi4uKMuLg4Izw83Bg4cKARFxdn7N271+ktixYtMry8vIzp06fnOf3nuXPnCt1yLT3vv/++8dVXXxkJCQlGQkKCMXfuXCMwMNAYP36801v+rCjPsPRvW95++23jiy++MBISEow9e/YYY8eONQDj888/d3pLRkaGUbVqVaNfv37G3r17jXXr1hk33nijMWzYsEK3XEvPZffff7/RsmXLImm41pYPP/zQ8PLyMqKjo41Dhw4ZGzZsMJo1a2a0aNHC6S0HDhwwFixYYCQkJBg//vijMWDAAKN8+fLGkSNHCt0iV6e1qWhaHLk2udK6dC09f6a16TeOXJtcaV26lh6tTc5RbIcqwzCM6dOnG2FhYYaPj49x8803G+vWrbvyvQcffNBo3759nv3Xrl1rNG3a1PDx8TGqV69uzJgxw7QWIN9XWFiY01vat29fYMuDDz5YJC3/tufdd9816tevbwQEBBiBgYFG06ZNjejoaMNmszm95c+KcuH6ty2vvfaaccMNNxh+fn7GddddZ9xyyy3Gt99+a0qLYRjGvn37jC5duhj+/v5G1apVjcjISCMzM9O0nnPnzhn+/v7GrFmziqzhWlveffddo169eoa/v78REhJi3Hfffcbx48ed3hIfH280adLE8Pf3NwIDA40777zT2L9/f5F0yF/T2lT4FkevTa60Lv3bnj/T2vQ7R65NrrQuXUuP1ibHsxhGIV73ExERERERcXPF/OBFERERERERc2moEhERERERKQQNVSIiIiIiIoWgoUpERERERKQQNFSJiIiIiIgUgoYqERERERGRQtBQJSIiIiIiUggaqkRERERERApBQ5WIiIiIiEghaKgSEREREREpBA1VIiIiIiIihfB/pHsYtV0/umYAAAAASUVORK5CYII=", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "hsmc_est.extract(seq_map['Observation'],1,0).plot(Title=\"Observation distribution for state 0\")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "For the sake of comparison: associated true emission distribution" - ] - }, - { - "cell_type": "code", - "execution_count": 44, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAA1EAAAORCAYAAAATbSgeAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy80BEi2AAAACXBIWXMAAA9hAAAPYQGoP6dpAADbtklEQVR4nOzdd3xUVf7/8fekNxJ6EkgDQQgiiKBSjIhKsy8irChlRVhEpO1aUHdF113UXTXYsCGgAooQXNflhyDSFCwgcVEiNRDARKSlkzJzfn/wnZEhk5AJSWaSvJ6Pxzwezr1n7v3cY5gzn3vOPcdijDECAAAAAFSKj6cDAAAAAIC6hCQKAAAAANxAEgUAAAAAbiCJAgAAAAA3kEQBAAAAgBtIogAAAADADSRRAAAAAOAGkigAAAAAcANJFAAAAAC4gSQKQIOQkJCg5ORkT4dRbdatWyeLxaKTJ0/W+rmvvvpqTZ061fG+pup2zJgxuvXWW8s9b02eq6b89NNP6tmzp4KCgnTJJZfU+PkAADWDJApAnXbw4EGNHTtWrVq1UkBAgOLj4zVlyhQdO3bM06FVG1fJQ+/evZWZmamIiAjPBHWGb7/9VuPHj69UWXcSrtmzZ2v+/PlVD8yF/fv3y2KxKDU1tcbP5crjjz+u0NBQ7dy5U2vWrKnx89nNnz9fjRs3dvtz1Zmsp6SkaODAgWrevLnL/wcAUJeQRAGos/bt26cePXpo165dWrx4sfbs2aPXXntNa9asUa9evXT8+HGPxWa1WmWz2Wrs+AEBAYqKipLFYqmxc1RWixYtFBISUm3Hs9ddRERElX74V0VtnWvv3r268sorFR8fr2bNmlXpGMXFxdUcVe3Iz89Xnz599PTTT3s6FAA4byRRAOqs++67TwEBAVq1apX69u2ruLg4DR48WJ999pkOHz6sRx991Kl8bm6uRowYobCwMLVq1UovvfSS0/6ZM2cqLi5OgYGBatWqlSZPnuzYV1xcrAcffFCtW7dWaGiorrjiCq1bt86x336n/5NPPlGnTp0UGBioN998U0FBQWXu4k+ePFl9+/aVJB07dkx33HGHYmJiFBISoosvvliLFy92lB0zZozWr1+v2bNny2KxyGKxaP/+/S57CJYtW6aLLrpIgYGBSkhI0HPPPed03oSEBP3jH//Q3XffrUaNGikuLk5vvPFGhXWcn5+vUaNGKSwsTNHR0WWOaT/umb1L5dXj1VdfrQMHDmjatGmOaymv7g4cOOByiF1paakmTZqkxo0bq1mzZnrsscdkjHHst1gs+uijj5w+07hxY0cvU5s2bSRJ3bp1k8Vi0dVXX+2o5zPPVVRUpMmTJ6tly5YKCgrSlVdeqW+//dax317/a9asUY8ePRQSEqLevXtr586d5dalxWLR1q1b9eSTT8pisWjmzJmSpO3bt+uaa65RcHCwmjVrpvHjxysvL8/xOXtss2bNUqtWrXThhRe6PP7333+vfv36qVGjRgoPD1f37t21ZcsWrVu3Tn/4wx+UnZ3tqHf7ud977z316NFDjRo1UlRUlEaMGKEjR45IOt1r169fP0lSkyZNZLFYNGbMGEmSMUbPPvus2rZtq+DgYHXt2lVLly4t99olaeTIkfrrX/+q6667rsJyAFAnGACog44dO2YsFov5xz/+4XL/uHHjTJMmTYzNZjPGGBMfH28aNWpkZs2aZXbu3GlefPFF4+vra1atWmWMMebDDz804eHhZsWKFebAgQPm66+/Nm+88YbjeCNGjDC9e/c2GzZsMHv27DH//Oc/TWBgoNm1a5cxxph58+YZf39/07t3b/Pll1+an376yeTl5ZnIyEjz1ltvOY5TWlpqIiMjzeuvv26MMebQoUPmn//8p9m2bZvZu3evI66vvvrKGGPMyZMnTa9evcy4ceNMZmamyczMNKWlpWbt2rVGkjlx4oQxxpgtW7YYHx8f8+STT5qdO3eaefPmmeDgYDNv3jzHuePj403Tpk3NK6+8Ynbv3m1mzZplfHx8TFpaWrn1fO+995qYmBizatUq87///c/ceOONJiwszEyZMsXpuC+88MI56/HYsWMmJibGPPnkk45rqajuRo8ebW655RbHefr27es4908//WTee+89ExIS4vT/SZJZvny50zVEREQ46uGbb74xksxnn31mMjMzzbFjx4wxpsy5Jk+ebFq1amVWrFhhfvzxRzN69GjTpEkTR3l7/V9xxRVm3bp15scffzRJSUmmd+/e5dZlZmamueiii8yf/vQnk5mZaXJzc01+fr5p1aqVGTJkiNm+fbtZs2aNadOmjRk9erTjc6NHjzZhYWFm5MiR5ocffjDbt293efyLLrrI3HXXXSYtLc3s2rXLLFmyxKSmppqioiKTnJxswsPDHfWem5trjDFm7ty5ZsWKFWbv3r1m8+bNpmfPnmbw4MHGmNN/q8uWLTOSzM6dO01mZqY5efKkMcaYRx55xHTs2NGsXLnS7N2718ybN88EBgaadevWlXv9dunp6UaS2bZt2znLAoC3IokCUCd99dVXLn8w2z3//PNGkvnll1+MMad/6A8aNMipzPDhwx0/GJ977jlz4YUXmuLi4jLH2rNnj7FYLObw4cNO26+99lozY8YMY8zpRECSSU1NdSozefJkc8011zjef/rppyYgIMAcP3683Gu7/vrrzZ/+9CfH+759+zolLcaYMknUiBEjTP/+/Z3KPPDAA6ZTp06O9/Hx8eauu+5yvLfZbKZly5Zmzpw5LuPIzc01AQEB5v3333dsO3bsmAkODi43iaqoHs8ua1de3blKohITEx2JsTHGPPTQQyYxMdHx/lxJVHk/4M88V15envH39zcLFy507C8uLjatWrUyzz77rDHmt/r/7LPPHGX++9//GkmmsLDQ5bUbY0zXrl3N448/7nj/xhtvmCZNmpi8vDyn4/j4+JisrCxHbJGRkaaoqKjc4xpjTKNGjcz8+fNd7ps3b56JiIio8PPG/JZk2pOss//OjDldP0FBQWbTpk1Onx07dqy54447znkOkigA9QHD+QDUS+b/hnid+cxQr169nMr06tVLaWlpkqTbb79dhYWFatu2rcaNG6fly5ertLRUkvTdd9/JGKMLL7xQYWFhjtf69eu1d+9ex/ECAgLUpUsXp3PceeedWrdunX7++WdJ0sKFC3X99derSZMmkk4///P3v/9dXbp0UbNmzRQWFqZVq1YpIyPDretNS0tTnz59nLb16dNHu3fvltVqdWw7Mz6LxaKoqCjH8K2z7d27V8XFxU711rRpU3Xo0KHcOCqqx4q4qjtXevbsWeb/6dnXeL727t2rkpISp/r09/fX5Zdf7vh7sTsz5ujoaEkqtz5dSUtLU9euXRUaGurY1qdPH9lsNqehgRdffLECAgIqPNb06dN1zz336LrrrtPTTz/t9LdZnm3btumWW25RfHy8GjVq5BjeWNHf344dO3Tq1Cn179/f6d/DO++8U6lzAkB9QBIFoE5q166dLBaLduzY4XL/Tz/9pCZNmqh58+YVHsf+gzw2NlY7d+7UK6+8ouDgYE2cOFFXXXWVSkpKZLPZ5Ovrq61btyo1NdXxSktL0+zZsx3HCg4OLjPRw+WXX64LLrhA77//vgoLC7V8+XLdddddjv3PPfecXnjhBT344IP6/PPPlZqaqoEDB7o9eYAxpsy5zRnPCtn5+/uXuf7yJsBw9flzqageK+Kq7qrCYrGUiftc5z6bqwTcvv3sbWfWp32fOxOKuDrm2ceT5JRklWfmzJn68ccfdcMNN+jzzz9Xp06dtHz58nLL5+fna8CAAQoLC9N7772nb7/91lG+or8/+/X997//dfr3sGPHjnM+FwUA9QVJFIA6qVmzZurfv79effVVFRYWOu3LysrSwoULNXz4cKcfol999ZVTua+++kodO3Z0vA8ODtbNN9+sF198UevWrdPmzZu1fft2devWTVarVUeOHFG7du2cXlFRUeeMdcSIEVq4cKH+85//yMfHRzfccINj38aNG3XLLbforrvuUteuXdW2bVvt3r3b6fMBAQHn7Gnp1KmTvvjiC6dtmzZt0oUXXihfX99zxuhKu3bt5O/v71RvJ06c0K5duyr8XHn1WNlrqYir/4ft27d3XGOLFi2UmZnp2L97924VFBQ43tt7cyqKoV27dgoICHCqz5KSEm3ZskWJiYlVjt2VTp06KTU1Vfn5+Y5tX375pXx8fMqdQKIiF154oaZNm6ZVq1ZpyJAhmjdvniTX9f7TTz/p6NGjevrpp5WUlKSOHTuW6UVzVV/2yT8yMjLK/HuIjY11O2YAqItIogDUWS+//LKKioo0cOBAbdiwQQcPHtTKlSvVv39/tW7dWn//+9+dyn/55Zd69tlntWvXLr3yyiv68MMPNWXKFEmnZ4ibO3eufvjhB+3bt0/vvvuugoODFR8frwsvvFB33nmnRo0apZSUFKWnp+vbb7/VM888oxUrVpwzzjvvvFPfffed/v73v2vo0KEKCgpy7GvXrp1Wr16tTZs2KS0tTX/84x+VlZXl9PmEhAR9/fXX2r9/v44ePeqyp+NPf/qT1qxZo7/97W/atWuXFixYoJdffll//vOfq1K1kqSwsDCNHTtWDzzwgNasWaMffvhBY8aMkY9P+U1HRfVov5YNGzbo8OHDOnr0qNsxHTx4UNOnT9fOnTu1ePFivfTSS47/h5J0zTXX6OWXX9Z3332nLVu2aMKECU69RS1btlRwcLBWrlypX375RdnZ2WXOERoaqnvvvVcPPPCAVq5cqR07dmjcuHEqKCjQ2LFj3Y65InfeeaeCgoI0evRo/fDDD1q7dq3uv/9+jRw5UpGRkZU+TmFhoSZNmqR169bpwIED+vLLL/Xtt986kr6EhATl5eVpzZo1Onr0qAoKChQXF6eAgAC99NJL2rdvnz7++GP97W9/czpufHy8LBaLPvnkE/3666/Ky8tTo0aN9Oc//1nTpk3TggULtHfvXm3btk2vvPKKFixYUG6Mx48fd/RYSdLOnTuVmppa5u8dAOoEjz2NBQDVYP/+/WbMmDEmKirK+Pv7m9jYWHP//febo0ePOpWLj483TzzxhBk2bJgJCQkxkZGRJjk52bF/+fLl5oorrjDh4eEmNDTU9OzZ02nSgOLiYvPXv/7VJCQkGH9/fxMVFWV+97vfmf/973/GmHM/uH/ZZZcZSebzzz932n7s2DFzyy23mLCwMNOyZUvz2GOPmVGjRjlNqLBz507Ts2dPExwcbCSZ9PR0lw/8L1261HTq1Mn4+/ubuLg4889//rNMHZw9qcPZEx2cLTc319x1112OOnv22WfLTHRx5nHPVY+bN282Xbp0MYGBgcbeBJVXd64mlpg4caKZMGGCCQ8PN02aNDEPP/yw00QThw8fNgMGDDChoaGmffv2ZsWKFU4TSxhjzJtvvmliY2ONj4+P6du3r8tzFRYWmvvvv980b97cBAYGmj59+phvvvnGsd9V/W/bts3x/6c8rur7f//7n+nXr58JCgoyTZs2NePGjXNM7OAqNleKiorM73//exMbG2sCAgJMq1atzKRJk5wmuZgwYYJp1qyZkeSIYdGiRSYhIcEEBgaaXr16mY8//rjMpA9PPvmkiYqKMhaLxTFroM1mM7NnzzYdOnQw/v7+pkWLFmbgwIFm/fr15cZon0Dk7FdFf38A4K0sxlRh0DsAAAAANFAM5wMAAAAAN5BEAQAAAIAbSKIAAAAAwA0kUQAAAADgBpIoAAAAAHADSRQAAAAAuIEkCgAAAADcQBIFAAAAAG4giQIAAAAAN5BEAQAAAIAbSKIAAAAAwA0kUQAAAADgBpIoAAAAAHADSRQAAAAAuIEkCgAAAADcQBIFAAAAAG4giQIAAAAAN5BEAQAAAIAbSKIAAAAAwA0kUQAAAADgBpIoAAAAAHADSRQAAAAAuIEkCgAAAADcQBIFAAAAAG4giQIAAAAAN5BEAQAAAIAbSKIAAAAAwA0kUQAAAADgBpIoAAAAAHADSRQAAAAAuIEkCgAAAADcQBIFAAAAAG4giQIAAAAAN5BEAQAAAIAbSKIAAAAAwA0kUQAAAADgBpIoAAAAAHADSRQAAAAAuIEkCgAAAADcQBIFAAAAAG4giQIAAAAAN5BEAQAAAIAbSKIAAAAAwA0kUQAAAADgBpIoAAAAAHADSRQAAAAAuIEkCgAAAADcQBIFAAAAAG4giQIAAAAAN5BEAQAAAIAbSKIAAAAAwA0kUQAAAADgBpIoAAAAAHADSRQAAAAAuIEkCgAAAADcQBIFAAAAAG4giQIAAAAAN5BEAQAAAIAbSKIAAAAAwA0kUQAAAADgBpIoAAAAAHADSRQAAAAAuIEkCgAAAADcQBIFAAAAAG4giQIAAAAAN5BEAQAAAIAbSKIAAAAAwA0kUQAAAADgBpIoAAAAAHADSRQAAAAAuIEkCgAAAADcQBIFAAAAAG4giQIAAAAAN5BEAQAAAIAbSKIAAAAAwA0kUQAAAADgBpIoAAAAAHADSRQAAAAAuIEkCgAAAADcQBIFAAAAAG4giQIAAAAAN5BEAQAAAIAbSKIAAAAAwA0kUQAAAADgBpIoAAAAAHADSRQAAAAAuMHP0wFUF5vNpp9//lmNGjWSxWLxdDgA0GAYY5Sbm6tWrVrJx4d7c3a0SwDgOTXdNtWbJOrnn39WbGysp8MAgAbr4MGDiomJ8XQYXoN2CQA8r6bapnqTRDVq1EjS6YoKDw/3cDQA0HDk5OQoNjbW8T2M02iXAMBzarptqjdJlH2oRHh4OI0VAHgAQ9ac0S4BgOfVVNvE4HUAAAAAcANJFAAAAAC4gSQKAAAAANxQb56JgvexWq0qKSnxdBgAzpO/v798fX09HQYaANoNAJXl6baJJArVzhijrKwsnTx50tOhAKgmjRs3VlRUFJNHoEbQbgCoCk+2TSRRqHb2hrBly5YKCQnhRxdQhxljVFBQoCNHjkiSoqOjPRwR6iPaDQDu8Ia2iSQK1cpqtToawmbNmnk6HADVIDg4WJJ05MgRtWzZkqF9qFa0GwCqwtNtExNLoFrZx7KHhIR4OBIA1cn+b5rnVVDdaDcAVJUn2yaSKNQIhmIA9Qv/plHT+BsD4C5Pfm+QRAEAAACAG0iiAAAAAMANVUqiXn31VbVp00ZBQUHq3r27Nm7cWG7ZlJQU9e/fXy1atFB4eLh69eqlTz/91KnM/PnzZbFYyrxOnTpVlfBQD1htVq3bv06Lty/Wuv3rZLVZaz2Gq6++WlOnTnW8T0hIUHJycrWfZ8yYMbr11lvLPW9NnssbXHXVVVq0aJGnw2iwjhw5ohYtWujw4cOeDgU4L97QbniD/fv3y2KxKDU11SuOc77nXbdunSwWS41Mf2+xWPTRRx+5PG9NnqsmvfHGG4qNjZWPj0+N/GZxR039bvIWbidRH3zwgaZOnapHH31U27ZtU1JSkgYPHqyMjAyX5Tds2KD+/ftrxYoV2rp1q/r166ebbrpJ27ZtcyoXHh6uzMxMp1dQUFDVrgp1WkpaihJmJ6jfgn4akTJC/Rb0U8LsBKWkpXg0rm+//Vbjx4+vVFl3vjhmz56t+fPnVz0wF8prDGriXK6ceTPEz89PcXFxmj59uoqKipzKffLJJ8rKytLvf/97p7hdvT788EPH5xISEsrsf/jhh92KMTMzUyNGjFCHDh3k4+NTbuK6bNkyderUSYGBgerUqZOWL19epow7N5bKc+LECY0cOVIRERGKiIjQyJEjz/mjIS8vT5MmTVJMTIyCg4OVmJioOXPmOJW5+uqry9SVvb4lqWXLlho5cqQef/xxt2MGvIW3tht1hasbbLGxscrMzFTnzp09E9T/6d27tzIzMxUREXHOsu4mXJmZmRo8ePB5Ruhs5syZuuSSS2rlXGfLycnRpEmT9NBDD+nw4cOV/s1yvubPn6/GjRuX2e7O76a6yO0k6vnnn9fYsWN1zz33KDExUcnJyYqNjS3TcNslJyfrwQcf1GWXXab27dvrH//4h9q3b6///Oc/TuUsFouioqKcXmh4UtJSNHTJUB3KOeS0/XDOYQ1dMtSjDWKLFi2qdfYoq9Uqm82miIgIl18+NaE2zzVv3jxlZmYqPT1dr776qt5991099dRTTmVefPFF/eEPf5CPz+mvInujfebriSeeUGhoaJnG58knn3Qq99hjj7kVX1FRkVq0aKFHH31UXbt2dVlm8+bNGj58uEaOHKnvv/9eI0eO1LBhw/T11187yrh7Y6k8I0aMUGpqqlauXKmVK1cqNTVVI0eOrPAz06ZN08qVK/Xee+8pLS1N06ZN0/33369///vfTuXGjRvnVFevv/660/4//OEPWrhwoU6cOOFWzIA38OZ2oy7z9fVVVFSU/Pw8uxpOQEBAtS+mWlxcLEmKiopSYGBgtR23IrVxroyMDJWUlOiGG25QdHS0x2e8rO7fTd7GrSSquLhYW7du1YABA5y2DxgwQJs2barUMWw2m3Jzc9W0aVOn7Xl5eYqPj1dMTIxuvPHGMj1VZysqKlJOTo7TC3Wb1WbVlJVTZGTK7LNvm7pyao0M0cjPz9eoUaMUFham6OhoPffcc2XKnN27NHPmTMXFxSkwMFCtWrXS5MmTJZ2+83/gwAFNmzbNcedf+u1OzSeffOLo2Thw4IDLO4ClpaWaNGmSGjdurGbNmumxxx6TMb/Vi6thAY0bN3b0MrVp00aS1K1bN1ksFl199dWSyt5tLCoq0uTJk9WyZUsFBQXpyiuv1LfffuvYb7+rt2bNGvXo0UMhISHq3bu3du7cec46ta8iHhsbqxtvvFE333yzvvvuO8f+o0eP6rPPPtPNN9/s2GZvtM98LV++XMOHD1dYWJjT8Rs1auRU7uz955KQkKDZs2dr1KhR5d7hTE5OVv/+/TVjxgx17NhRM2bM0LXXXuv0d+DujSVX0tLStHLlSr311lvq1auXevXqpTfffFOffPJJhXW9efNmjR49WldffbUSEhI0fvx4de3aVVu2bHEqFxIS4lRXZ1/vxRdf7KhroC7xZLths9n0zDPPqF27dgoMDFRcXJz+/ve/S3LdI5KamiqLxaL9+/dLcm4TOnTooJCQEA0dOlT5+flasGCBEhIS1KRJE91///2yWn+L/1zf/2ezWq0aO3as2rRpo+DgYHXo0EGzZ8927J85c6YWLFigf//73442a926dU4jGmw2m2JiYvTaa685Hfu7776TxWLRvn37JEnZ2dkaP368WrZsqfDwcF1zzTX6/vvvK6zHb775Rt26dVNQUJB69OhR5vff2XV54MAB3XTTTWrSpIlCQ0N10UUXacWKFdq/f7/69esnSWrSpIksFovGjBkj6XS7PGnSJE2fPl3NmzdX//79y63Ln376Sb1791ZQUJAuuugirVu3zrHPVY/LRx995NTOP/HEE/r+++8ddWn//3L2ubZv365rrrlGwcHBatasmcaPH6+8vDzHfnt7/a9//UvR0dFq1qyZ7rvvvnKn8p4/f74uvvhiSVLbtm0df2uufmNMnTrV8bvAXj+TJ0/Wgw8+qKZNmyoqKkozZ850+szJkyc1fvx4RUZGKigoSJ07d9Ynn3yidevW6Q9/+IOys7Md12z/7Nm/mzIyMnTLLbcoLCxM4eHhGjZsmH755RfHfnsv3rvvvquEhARFRETo97//vXJzc11es6e5dXvh6NGjslqtioyMdNoeGRmprKysSh3jueeeU35+voYNG+bY1rFjR8f//JycHM2ePVt9+vTR999/r/bt27s8zqxZs/TEE0+4Ez48qKCkQD8d/anCMlt+3lLmTuKZjIwO5hzU3G1z1aNVj3Oes2Pzjgrxr9wdkAceeEBr167V8uXLFRUVpUceeURbt2512SUvSUuXLtULL7yg999/XxdddJGysrIcDUVKSoq6du2q8ePHa9y4cU6fKygo0KxZs/TWW2+pWbNmatmypcvjL1iwQGPHjtXXX3+tLVu2aPz48YqPjy9zvPJ88803uvzyy/XZZ5/poosuUkBAgMtyDz74oJYtW6YFCxYoPj5ezz77rAYOHKg9e/Y43eh49NFH9dxzz6lFixaaMGGC7r77bn355ZeVikWSdu3apbVr1zoaNEn64osvFBISosTExHI/t3XrVqWmpuqVV14ps++ZZ57R3/72N8XGxur222/XAw88UO51VtXmzZs1bdo0p20DBw50NAr2G0tnDyV058aS/TwRERG64oorHNt69uypiIgIbdq0SR06dHD5uSuvvFIff/yx7r77brVq1Urr1q3Trl27nH4gSdLChQv13nvvKTIyUoMHD9bjjz+uRo0aOZW5/PLLtXHjRt19992VjhuoKZVpMyTPthszZszQm2++qRdeeEFXXnmlMjMz9dNP5475TAUFBXrxxRf1/vvvKzc3V0OGDNGQIUPUuHFjrVixQvv27dNtt92mK6+8UsOHD3fr2Hb2BGjJkiVq3ry5Nm3apPHjxys6OlrDhg3Tn//8Z6WlpSknJ0fz5s2TJDVt2lQ///yz4xg+Pj76/e9/r4ULF2rChAmO7YsWLVKvXr3Utm1bGWN0ww03qGnTplqxYoUiIiL0+uuv69prr9WuXbvK3DyXTt/AvPHGG3XNNdfovffeU3p6uqZMmVLh9dx3330qLi7Whg0bFBoaqh07digsLEyxsbFatmyZbrvtNu3cuVPh4eGOxVil0+3qvffeqy+//NLppuTZHnjgASUnJ6tTp056/vnndfPNNys9Pb1SC0EPHz5cP/zwg1auXKnPPvtMklzepCsoKNCgQYPUs2dPffvttzpy5IjuueceTZo0ySkZXrt2raKjo7V27Vrt2bNHw4cP1yWXXOLyt8Dw4cMVGxur6667Tt98841iY2PVokWLc8Zst2DBAk2fPl1ff/21Nm/erDFjxqhPnz7q37+/bDabBg8erNzcXL333nu64IILtGPHDvn6+qp3795KTk7WX//6V8dNP1c3NY0xuvXWWxUaGqr169ertLRUEydO1PDhw50S1b179+qjjz7SJ598ohMnTmjYsGF6+umnHTcovEmV+mjP7lI1xlSqm3Xx4sWaOXOm/v3vfzv9eOzZs6d69uzpeN+nTx9deumleumll/Tiiy+6PNaMGTM0ffp0x/ucnBzFxsa6eymoJT8d/Und3+heLcf64yd/rFS5reO36tLoS89ZLi8vT3PnztU777zjuDu1YMECxcTElPuZjIwMRUVF6brrrpO/v7/i4uJ0+eWXSzrd+Pj6+jp6Ss5UUlKiV199tdzhY3axsbF64YUXZLFY1KFDB23fvl0vvPBCpZMo+xdns2bNyh0am5+frzlz5mj+/PmOoXJvvvmmVq9erblz5+qBBx5wlP373/+uvn37SpIefvhh3XDDDTp16lSFzy3ecccd8vX1VWlpqYqKinTjjTdqxowZjv379+9XZGSkYyifK3PnzlViYqJ69+7ttH3KlCm69NJL1aRJE33zzTeaMWOG0tPT9dZbb52jZtyTlZVV4U2j6rixZD+Pq4S6ZcuWFR7nxRdf1Lhx4xQTEyM/Pz/5+Pjorbfe0pVXXukoc+edd6pNmzaKiorSDz/8oBkzZuj777/X6tWrnY7VunXrc44AAGpLdbYZUvW3G7m5uZo9e7ZefvlljR49WpJ0wQUXOP3bq4ySkhLNmTNHF1xwgSRp6NChevfdd/XLL78oLCxMnTp1Ur9+/bR27doqJ1H+/v5ON53btGmjTZs2acmSJRo2bJjCwsIUHBysoqKiCh+luPPOO/X888/rwIEDio+Pl81m0/vvv69HHnlE0ukf/Nu3b9eRI0ccw9b+9a9/6aOPPtLSpUtdPhuzcOFCWa1Wvf322woJCdFFF12kQ4cO6d577y03joyMDN12221OvS529kStZcuWZXqM2rVrp2efffYctSVNmjRJt912myRpzpw5WrlypebOnasHH3zwnJ8NDg5WWFiY/Pz8KqzLhQsXqrCwUO+8845CQ0MlSS+//LJuuukmPfPMM442pUmTJnr55Zfl6+urjh076oYbbtCaNWtc/haw92hJp38DuPtYTJcuXRzPxrZv314vv/yy1qxZo/79++uzzz7TN998o7S0NF144YWSnOs9IiLC8VhOeT777DP973//U3p6uuP3+rvvvquLLrpI3377rS677DJJp5P++fPnO270jRw5UmvWrKn7SVTz5s3l6+tbplE/cuRImR8RZ/vggw80duxYffjhh7ruuusqLOvj46PLLrtMu3fvLrdMYGBgrY1jxfnr2Lyjto7fWmGZLT9vqVRD9/qNr1f6jmJl7N27V8XFxerVq5djW9OmTcu9+y9Jt99+u5KTk9W2bVsNGjRI119/vW666aZzjh0PCAhQly5dzhlTz549nW5M9OrVS88995ysVqt8fX0rcVXntnfvXpWUlKhPnz6Obf7+/rr88suVlpbmVPbMmKOjoyWd/ncfFxdX7vFfeOEFXXfddbJardqzZ4+mT5+ukSNH6v3335ckFRYWVpiEFRYWatGiRfrLX/5SZt+ZvUNdunRRkyZNNHToUD3zzDOVulvojsrcNKrqjaWKjlGZ47z44ov66quv9PHHHys+Pl4bNmzQxIkTFR0d7fiePbOx7dy5s9q3b68ePXrou+++06WX/vZjMTg4WAUFBW7FDNSUyrQZkufajbS0NBUVFenaa6+tVPnyhISEOBIo6fQNmISEBKc7+ZGRkTpy5Mh5nee1117TW2+9pQMHDqiwsFDFxcXljrQoT7du3dSxY0ctXrxYDz/8sNavX68jR444RhZt3bpVeXl5Zb6DCwsLtXfvXpfHTEtLU9euXZ2emzmzLXZl8uTJuvfee7Vq1Spdd911uu222yrVrvboce7//2ef38/PTz169CjTJp4v+3XbEyjpdAeCzWbTzp07Hb+pL7roIqc2Pzo6Wtu3b6/WWOzOrsPo6GjH311qaqpiYmIcCVRVpKWlKTY21qnDo1OnTmrcuLHS0tIcSVRCQoLTSIkz4/A2biVRAQEB6t69u1avXq3f/e53ju2rV6/WLbfcUu7nFi9erLvvvluLFy/WDTfccM7zGGOUmprquMuAui/EP+Scd/e6RnbV3zb8TYdzDrsc326RRTHhMRrbbax8faonkZBUYbd+eWJjY7Vz506tXr1an332mSZOnKh//vOfWr9+vfz9/cv9XHBwcLU8HGuxWMrEXd446fLYP1+ZBODMa7Lvs9lsFR4/KipK7dq1kyR16NBBubm5uuOOO/TUU0+pXbt2at68eYUTGSxdulQFBQUaNWrUOa/F3pO9Z8+eak2ioqKiKrxpdD43ls4+z5njwu1+/fXXco9TWFioRx55RMuXL3d8r3bp0kWpqan617/+Ve7NqksvvVT+/v7avXu3UxJ1/Phxt4Z+ADWpMm2G5Ll248xhYq7Ye9jP/J529R19dnthsVhcbjvz+9bd7/8lS5Zo2rRpeu6559SrVy81atRI//znP50myKmsO++8U4sWLdLDDz+sRYsWaeDAgWrevLmk021CdHS009Asu/ImNKpK+3vPPfdo4MCB+u9//6tVq1Zp1qxZeu6553T//fdX+LkzExZ32ds9Hx+f8257pYpvkJ25/Vx/C5VR2ZgrOte5/t4ro7xrPnt7dVxzbXF7dr7p06frrbfe0ttvv+2YDSojI8MxRnbGjBlOP3oWL16sUaNG6bnnnlPPnj2VlZWlrKwsZWdnO8o88cQT+vTTT7Vv3z6lpqZq7NixSk1NdRp3i/rP18dXswedfpbDorPu9P/f++RBydXaEEqnu/j9/f311VdfObadOHFCu3btqvBzwcHBuvnmm/Xiiy9q3bp12rx5s+MOUUBAgNODwO46Mxb7+/bt2zvuSLVo0UKZmZmO/bt373bqRbA/G1RRDO3atVNAQIC++OILx7aSkhJt2bKlwueUqsoee2FhoaTTdzWzsrLKTaTmzp2rm2++uVI/7O3D0Oy9ZNWlV69eZYa9rVq1yjG88MwbS2davXp1mSGI5zpPdna2vvnmG8e2r7/+WtnZ2eUep6SkRCUlJWWGQ/r6+lbY4Pz4448qKSkpU1c//PCDunXrVumYAW/gqXajffv2Cg4O1po1a1zut39vnfk9XV3rD53r+/9sGzduVO/evTVx4kR169ZN7dq1K9MzVNk2a8SIEdq+fbu2bt2qpUuX6s4773Tsu/TSS5WVlSU/Pz+1a9fO6WVPtM7WqVMnff/99452QSrb/rkSGxurCRMmKCUlRX/605/05ptvOq5DqrjtO5czz19aWqqtW7eqY8fTPZQtWrRQbm6u8vPzHWXO/v9ambrs1KmTUlNTnY7z5ZdfysfH57x6e1w5++9Fcv9vsUuXLjp06FC5v4sqe80ZGRk6ePCgY9uOHTuUnZ1dI785aoPbSdTw4cOVnJysJ598Updccok2bNigFStWKD4+XtLpL4wzp/Z9/fXXVVpaqvvuu0/R0dGO15kPDtpn/EhMTNSAAQN0+PBhbdiwwfGMCRqOIYlDtHTYUrUOb+20PSY8RkuHLdWQxCHVfs6wsDCNHTtWDzzwgNasWaMffvhBY8aMqfBZnfnz52vu3Ln64YcftG/fPr377rsKDg52/DtISEjQhg0bdPjwYR09etTtmA4ePKjp06dr586dWrx4sV566SWnfzPXXHONXn75ZX333XfasmWLJkyY4HT3pmXLlgoODtbKlSv1yy+/ON20sAsNDdW9996rBx54QCtXrtSOHTs0btw4FRQUaOzYsW7HfLaTJ08qKytLP//8s9avX68nn3xSF154oePLslu3bmrRooXLCSr27NmjDRs26J577imzb/PmzXrhhReUmpqq9PR0LVmyRH/84x918803Vzi80JXU1FSlpqYqLy9Pv/76q1JTU7Vjxw7H/ilTpmjVqlV65pln9NNPP+mZZ57RZ5995rSm1LluLFVGYmKiBg0apHHjxumrr77SV199pXHjxunGG290GlbasWNHxwx64eHh6tu3rx544AGtW7dO6enpmj9/vt555x3HSIG9e/fqySef1JYtW7R//36tWLFCt99+u7p16+Y0jLOgoMDlzKtAXeCJdiMoKEgPPfSQHnzwQb3zzjvau3evvvrqK82dO1fS6ZtUsbGxmjlzpnbt2qX//ve/Lmd9rYpzff+frV27dtqyZYs+/fRT7dq1S3/5y1+cZmGVTrdZ//vf/7Rz504dPXq03N6VNm3aqHfv3ho7dqxKS0udRiFdd9116tWrl2699VZ9+umn2r9/vzZt2qTHHnuszIyhdiNGjJCPj4/Gjh2rHTt2aMWKFfrXv/5V4fVPnTpVn376qdLT0/Xdd9/p888/d7Qr8fHxslgs+uSTT/Trr786zXZXWa+88oqWL1+un376Sffdd59OnDjhmHDniiuuUEhIiB555BHt2bNHixYtKjMrYkJCgtLT05WamqqjR4+WWR9ROt2jFxQUpNGjR+uHH37Q2rVrdf/992vkyJFujWKojGuuuUZbtmzRO++8o927d+vxxx/XDz/84NYx+vbtq6uuukq33XabVq9erfT0dP2///f/tHLlSkmnrzkvL09r1qzR0aNHXSb11113nbp06aI777xT3333nb755huNGjVKffv2rfRQS69j6ons7GwjyWRnZ3s6lAatsLDQ7NixwxQWFp7XcUqtpWZt+lqz6H+LzNr0tabUWlpNEbqWm5tr7rrrLhMSEmIiIyPNs88+a/r27WumTJniKBMfH29eeOEFY4wxy5cvN1dccYUJDw83oaGhpmfPnuazzz5zlN28ebPp0qWLCQwMNPZ/ZvPmzTMRERFlzj169Ghzyy23ON737dvXTJw40UyYMMGEh4ebJk2amIcfftjYbDZHmcOHD5sBAwaY0NBQ0759e7NixQoTERFh5s2b5yjz5ptvmtjYWOPj42P69u3r8lyFhYXm/vvvN82bNzeBgYGmT58+5ptvvnHsX7t2rZFkTpw44di2bds2I8mkp6eXW5+SHC+LxWKio6PN8OHDzd69e53KPfzww+b3v/99mc/PmDHDxMTEGKvVWmbf1q1bzRVXXGEiIiJMUFCQ6dChg3n88cdNfn6+U7n4+Hjz+OOPlxvj2XHaX/Hx8U5lPvzwQ9OhQwfj7+9vOnbsaJYtW1bmOK+88oqJj483AQEB5tJLLzXr16932v/444+XOe7Zjh07Zu68807TqFEj06hRI3PnnXc61bs93jP/H2dmZpoxY8aYVq1aOeriueeec/ytZGRkmKuuuso0bdrUBAQEmAsuuMBMnjzZHDt2zOm4ixYtMh06dKgwvor+bfP96xr1Ujl1td2wWq3mqaeeMvHx8cbf39/ExcWZf/zjH479X3zxhbn44otNUFCQSUpKMh9++KHTd6erNuHxxx83Xbt2ddp29vf2ub7/09PTjSSzbds2Y4wxp06dMmPGjDERERGmcePG5t577zUPP/yw03mOHDli+vfvb8LCwowks3bt2jLHsXvllVeMJDNq1KgydZKTk2Puv/9+06pVK+Pv729iY2PNnXfeaTIyMsqtx82bN5uuXbuagIAAc8kll5hly5Y5nffsdmjSpEnmggsuMIGBgaZFixZm5MiR5ujRo47jPfnkkyYqKspYLBYzevRoY4wp057bSTLLly93qrdFixaZK664wgQEBJjExESzZs0ap88sX77ctGvXzgQFBZkbb7zRvPHGG+bMn9OnTp0yt912m2ncuLHTd/aZ5zLGmP/973+mX79+JigoyDRt2tSMGzfO5ObmOvaf/f/dGGOmTJniaM9dKa99/utf/2oiIyNNRESEmTZtmpk0aZLTcVzVzy233OKoP2NOt1F/+MMfTLNmzUxQUJDp3Lmz+eSTTxz7J0yYYJo1a2YkOdreM383GWPMgQMHzM0332xCQ0NNo0aNzO23326ysrIc+139/b/wwgsVtp+ebJssxlRhQKoXysnJUUREhLKzsxUeHu7pcBqsU6dOKT09XW3atKlw0gBAkn755RdddNFF2rp1q6MXrzoUFhY6ptm1rxviSfap3ctbx8XTLr/8ck2dOlUjRowot0xF/7b5/nWNeqkc2g0AVeXJtsmzy1ADaNAiIyM1d+5cZWRkVGsStX79el1zzTVekUBJp+PZsGGDp8Nw6ciRIxo6dKjuuOMOT4cCAECdQRIFwKMqmtmzqgYNGqRBgwZV+3GrKj093dMhlKtly5aVWv8EAIC6wmqzauOBjTV6DrcnlgAAoK7ZsGGDbrrpJrVq1UoWi0UfffTROT+zfv16de/eXUFBQWrbtq1ee+21mg8UAHBeUtJSlDA7QTcuurFGz0MSBQCo9/Lz89W1a1e9/PLLlSqfnp6u66+/XklJSdq2bZseeeQRTZ48WcuWLavhSAEAVZWSlqKhS4bqUM6hGj8Xw/lQI7x1YTQAVVPX/00PHjxYgwcPrnT51157TXFxcUpOTpZ0ehr6LVu26F//+pduu+22GoqyYavrf2MAat+Z3xtWm1VTVk5xufB2TSCJQrUKCAiQj4+Pfv75Z7Vo0UIBAQHlrsoNwPsZY1RcXKxff/1VPj4+jsUs67vNmzeXWTdr4MCBmjt3rkpKSlyuy1NUVOS0JkxOTk6Nx1kf0G4AcJertmlDxoZa6YGyI4lCtfLx8VGbNm2UmZmpn3/+2dPhAKgmISEhiouLq3AR6vokKyurzKKXkZGRKi0t1dGjRxUdHV3mM7NmzdITTzxRWyHWG7QbAKrqzLYpMzezVs9NEoVqFxAQoLi4OJWWlspqtXo6HADnydfXV35+fg2ud+Ds67Uvq1hePcyYMUPTp093vM/JyVFsbGzNBViP0G4AcNeZbZPVZtUv+b/U6vlJolAjLBaL/P39XQ55AQBvFxUVpaysLKdtR44ckZ+fn5o1a+byM4GBgQoMDKyN8Ool2g0AVZGSlqIpK6fU6lA+iSQKAIAyevXqpf/85z9O21atWqUePXrwIx8AvIR9Nr7amkziTA1jcDsAoEHLy8tTamqqUlNTJZ2ewjw1NVUZGRmSTg/FGzVqlKP8hAkTdODAAU2fPl1paWl6++23NXfuXP35z3/2RPgAgLPU9mx8Z6MnCgBQ723ZskX9+vVzvLc/uzR69GjNnz9fmZmZjoRKktq0aaMVK1Zo2rRpeuWVV9SqVSu9+OKLTG8OAF5iY8bGWh/CdyaSKABAvXf11Vc7JoZwZf78+WW29e3bV999910NRgUAqKrano3vbAznAwAAAFCnRDcqu9REbSKJAgAAAFCnJMUlKSY8RhZ5ZvkNkigAAAAAdYqvj69mD5otSWUSqdpIrEiiAAAAANQ5QxKHaOmwpWoe0txpe0x4jN4d8m6NnpuJJQAAAADUSUMShyj7VLbu/vhuzbtlnhIaJygpLkn5efk1el6SKAAAAAB11p7jexQTHqMxl4yptXMynA8AAABAnbX7+G61b9q+Vs9JEgUAAACgziKJAgAAAIBKMsZo97HdurDZhbV6XpIoAAAAAHVSZl6m8kvy1b4ZPVEAAAAAcE67j+2WJIbzAQAAAEBl7Dq2Sz4WH7Vt0rZWz0sSBQAAAKBO2n18t+Ij4hXoF1ir5yWJAgAAAFAn7T6+u9afh5JIogAAAADUUbuO7dKFTWt3Zj6JJAoAAABAHWS1WbX3+F56ogAAAACgMg7mHFSRtajWZ+aTJL9aPyMAwKtZbVZtzNiozNxMRTeKVlJcknx9fD0dFgAATuzTm9f2QrsSSRQA4AwpaSmasnKKDuUccmyLCY/R7EGzNSRxiAcjAwDgN1abVf/d/V/5WHy0/+R+JTROqNUbfgznAwBIOp1ADV0y1CmBkqTDOYc1dMlQpaSleCgyAAB+k5KWooTZCZr99WzZjE3XvXudEmYn1Go7RRIFAJDVZtWUlVNkZMrss2+bunKqrDZrbYcGAICDt9zwI4kCAGhjxsYyDdKZjIwO5hzUxoyNtRgVAAC/8aYbfiRRAABl5mZWazkAAKqbN93wI4kCACi6UXS1lgMAoLp50w0/kigAgJLikhQTHiOLLC73W2RRbHiskuKSajkyAABO86YbfiRRAAD5+vhq9qDZLvfZE6vkQcmsFwUA8BhvuuFHEgUAkNVmVdPgphpx8Ygy+2LCY7R02FLWiQIAeJQ33fAjiQKABs6+3ka/Bf20cPtCSVLz4OaSpIf6PKT0KekkUAAArzAkcYiWDluqpsFNnbbX9g0/v1o5CwDAK9nX2zh7uthjhcckSUcLjjKEDwDgVYYkDtGhnEP606o/acGtC9SqUSslxSXVantFTxQANFCVWW9j6Y6lLLALAPA6J0+dVPOQ5hpx8QhdnXB1rd/wI4kCgAbqXOttSFJ2UTYL7AIAvM6JwhNqEtTEY+cniQKABsqb1tsAAMAdx08dL/NcVG0iiQKABsqb1tsAAMAdxwtJogAAHnCu9TYkKdgvmAV2AQBe50ThCTUJZjgfAKCWnbnextmJlP19YotEZucDAHid44XH1TSInigAgAfY19to1aiV0/aY8BglxSWpUUAjD0UGAED5GM4HAPCoIYlDtGXcFknS9J7TtXb0WqVPSVenFp2UV5zn4egAAHBmjNGJU54dzsdiuwAAFZQWSJKub3+9rk64WpIUFhBGEgUA8DoFJQUqthbTEwUA8Cx7shQWEObYRhIFAPBGJ06dkCTWiQIAeJY9WWoU+NszUCRRAABvdLzwuCTREwUA8KzcolxJrnuijDGeCgsAgDLqbBL16quvqk2bNgoKClL37t21cePGcsumpKSof//+atGihcLDw9WrVy99+umnZcotW7ZMnTp1UmBgoDp16qTly5dXJTQAQBU4eqICnHuirMaqImuRp8ICAKCME4X/N5yvLq0T9cEHH2jq1Kl69NFHtW3bNiUlJWnw4MHKyMhwWX7Dhg3q37+/VqxYoa1bt6pfv3666aabtG3bNkeZzZs3a/jw4Ro5cqS+//57jRw5UsOGDdPXX39d9SsDAFRabvHpnqjQgFDHNnuvFEP6AADexN4T1TioscdicDuJev755zV27Fjdc889SkxMVHJysmJjYzVnzhyX5ZOTk/Xggw/qsssuU/v27fWPf/xD7du313/+8x+nMv3799eMGTPUsWNHzZgxQ9dee62Sk5OrfGEAgMrLK85TgG+AAnwDHNtC/UMd+wAA8BbHC48rIjBCfj6em2jcrSSquLhYW7du1YABA5y2DxgwQJs2barUMWw2m3Jzc9W06W9jGDdv3lzmmAMHDqzwmEVFRcrJyXF6AQCqJrcot8zCuvREAQC8kafXiJLcTKKOHj0qq9WqyMhIp+2RkZHKysqq1DGee+455efna9iwYY5tWVlZbh9z1qxZioiIcLxiY2PduBIAwJnyivOcJpWQSKIAAN7peOFxj04qIVVxYgmLxeL03hhTZpsrixcv1syZM/XBBx+oZcuW53XMGTNmKDs72/E6ePCgG1cAADhTXnGe0/Tm0m9JVH5xvidCAgDApROnTng8iXJrIGHz5s3l6+tbpofoyJEjZXqSzvbBBx9o7Nix+vDDD3Xdddc57YuKinL7mIGBgQoMDHQnfABAOXKLc+mJAgDUCccLj3t0oV3JzZ6ogIAAde/eXatXr3bavnr1avXu3bvczy1evFhjxozRokWLdMMNN5TZ36tXrzLHXLVqVYXHBABUn7ziPJ6JAgDUCd4wnM/tKS2mT5+ukSNHqkePHurVq5feeOMNZWRkaMKECZJOD7M7fPiw3nnnHUmnE6hRo0Zp9uzZ6tmzp6PHKTg4WBEREZKkKVOm6KqrrtIzzzyjW265Rf/+97/12Wef6Ysvvqiu6wQAVMBVT1SQX5B8LD4kUQAAr3Ki8ETd6omSpOHDhys5OVlPPvmkLrnkEm3YsEErVqxQfHy8JCkzM9NpzajXX39dpaWluu+++xQdHe14TZkyxVGmd+/eev/99zVv3jx16dJF8+fP1wcffKArrriiGi4RAHAuriaWsFgsCgsII4kCAHiVOtkTJUkTJ07UxIkTXe6bP3++0/t169ZV6phDhw7V0KFDqxIOAOA8uRrOJ4kkCgDgVaw2q7KLsj2eRFVpdj4AQP2SW1R2OJ9EEgUA8C4nT52UpLq1ThQAoH5yNcW5VL+SqFdffVVt2rRRUFCQunfvro0bN1ZYfuHCheratatCQkIUHR2tP/zhDzp27FgtRQsAcOV44XFJoicKAOB5riaWkP4viSqp+0nUBx98oKlTp+rRRx/Vtm3blJSUpMGDBzs9w3umL774QqNGjdLYsWP1448/6sMPP9S3336re+65p5YjBwCciSQKAOAVrDarCkoK6vUzUc8//7zGjh2re+65R4mJiUpOTlZsbKzmzJnjsvxXX32lhIQETZ48WW3atNGVV16pP/7xj9qyZUstRw4AONOJUyckqe7NzgcAqF8KSgokqd4+E1VcXKytW7dqwIABTtsHDBigTZs2ufxM7969dejQIa1YsULGGP3yyy9aunSpy7UO7YqKipSTk+P0AgBUL3qiAABeIbc4V1I5SZR/3U+ijh49KqvVqsjISKftkZGRjrULz9a7d28tXLhQw4cPV0BAgKKiotS4cWO99NJL5Z5n1qxZioiIcLxiY2Or9ToAAKfXiArwDVCIf4hH4yCJAoAGzp4k1feJJSwWi9N7Y0yZbXY7duzQ5MmT9de//lVbt27VypUrlZ6e7lhY3pUZM2YoOzvb8Tp48GC1xg8AON0T1SSoSbnf37WlSutEAQDqj9yiCnqi6kES1bx5c/n6+pbpdTpy5EiZ3im7WbNmqU+fPnrggQckSV26dFFoaKiSkpL01FNPKTo6usxnAgMDFRgYWP0XAABw8IaFdiV6ogCgwXP0RLmYWCI0ILTOJ1EBAQHq3r27Vq9e7bR99erV6t27t8vPFBQUyMfHuYn09fWVdLoHCwDgGSdOnfD4GlESSRQANHgVPhNVD3qiJGn69Ol666239PbbbystLU3Tpk1TRkaGY3jejBkzNGrUKEf5m266SSkpKZozZ4727dunL7/8UpMnT9bll1+uVq1aeeoyAKDB85aeKIbzAUADZ0+SykuiTpWeUqmtVH4+dbfJGD58uI4dO6Ynn3xSmZmZ6ty5s1asWKH4+HhJUmZmptOaUWPGjFFubq5efvll/elPf1Ljxo11zTXX6JlnnvHUJQAAdDqJuqDpBZ4OgyQKABo6exIVGhBaZp89scovzldEUEStxlXdJk6cqIkTJ7rcN3/+/DLb7r//ft1///01HBUAwB0nTp3w+BpREsP5AKDByy3KVah/qHwsZZsEexJVH4b0AQDqPm8ZzkcSBQANXF5xnsvpzSWSKACA9zDGkEQBALxDbnGuy+ehJJIoAID3KCwtVLG1mOF8AADPyyvOczm9uXTGM1El+bUZEgAAZRwvPC5J9EQBADwvrziPnigAgNc7UXhCEkkUAMALMJwPAODtrDar1qSvkSTtOrZLVpvVo/GQRAFAA1fRxBKh/qGOMgAAeEJKWooSZido2qfTJEmjPhqlhNkJSklL8VhMJFEA0MDlFuUqzN91T5Svj6+C/YJJogAAHpGSlqKhS4bqUM4hp+2Hcw5r6JKhHkukSKIAoIGrqCdKOj2kjyQKAFDbrDarpqycIiNTZp9929SVUz0ytI8kCgAauIomlpBIogAAnrExY2OZHqgzGRkdzDmojRkbazGq00iiAKCBq2hiCYkkCgDgGZm5mdVarjqRRAFAA1fROlESSRQAwDOiG0VXa7nqRBIFAA1YsbVYxdZieqIAAF4nKS5JMeExssjicr9FFsWGxyopLqmWIyOJAoAGzZ4cMbEEAMDb+Pr4avag2ZJUJpGyv08elCxfH99aj40kCgAasNyiXEmqsCcqNCCUJAoA4BFDEodo6bClah3e2ml7THiMlg5bqiGJQzwSl59HzgoA8AqOnqiKnonypycKAOA5QxKH6JYOt+iCFy9QYvNEPXTlQ0qKS/JID5QdSRQANGD25IhnogAA3szXx1c2Y1OPVj10dcLVng6H4XwA0JDlFp97OB9JFADAG+QU5VT4DG9tIokCgAaMiSUAAHWBMUa5xbkKDwz3dCiSSKIAoEGrzMQS9iTKGFNbYQEA4KSwtFA2Y6vwGd7aRBIFAA1YXnGe/Hz8FOgbWG6ZsIAwGRkVlhbWYmQAAPzGftOP4XwAAI/LK85TWECYLBbXCxlKv/VSMaQPAOAp9md46YkCAHhcbnHuORskkigAgKfREwUA8Br2nqiKkEQBADyNnigAgNfILcoliQIAeD16ogAAXiOvJO+cDZI9icovzq+NkAAAKIOeKACA16AnCgBQF9h7okIDQj0cyWkkUQDQgOUV5zGxBADA6+UWn77p52PxjvTFO6IAAHhEZSaW8LX4ysfio7X712rd/nWy2qy1FB0AAKflFp17NtnaRBIFAA2Y/c5eeVLSUtTmxTayGZvmpc5TvwX9lDA7QSlpKbUYJQCgocstzvWaSSUkkigAaNAqGs6XkpaioUuG6lDOIafth3MOa+iSoSRSAIBaQ08UAMBrlDexhNVm1ZSVU2Rkyuyzb5u6cipD+wAAtYKeKACAVzDGnO6JctEobczYWKYHyumzMjqYc1AbMzbWZIgAAEj6vySKnigAgKcVlhbKyLjsicrMzazUMSpbDgCA85FbRE8UAMDDrDarVu5ZKUnaf2J/mWF50Y2iK3WcypYDAOB80BMFAPColLQUJcxO0G1LbpMkPbr20TIz7iXFJSkmPEYWWVwewyKLYsNjlRSXVCsxAwAaNiaWAAB4TGVn3PP18dXsQbMlqUwiZX+fPChZvj6+tRA1AKChY2IJAIBHuDvj3pDEIVo6bKlah7d2KhsTHqOlw5ZqSOKQmg8aAADREwUA8JCqzLg3JHGI9k/Zr5suvEkJjRO0dvRapU9JJ4ECANQam7EpvySfnigAQO2r6ox7vj6+atukrUL8Q3R1wtUM4QMA1Kq84jxJoicKAFD7zmfGvSC/IJ0qPVXdIQEAcE65RbmSRE8UAKD2nc+MeyRRAABPyS3+vySKnigAQG07nxn3SKIAAJ6SU5QjSQoPDPdwJL8hiQKABqSqM+6RRAEAPKXeDOd79dVX1aZNGwUFBal79+7auHFjuWUzMzM1YsQIdejQQT4+Ppo6dWqZMvPnz5fFYinzOnWKBhsAqpt9xr3fX/R7RYZGVmrGPXsSZUzZ6dEBAKhJ9WI43wcffKCpU6fq0Ucf1bZt25SUlKTBgwcrIyPDZfmioiK1aNFCjz76qLp27VruccPDw5WZmen0CgoKcjc8AEAl+Pr4qnlIc0WGRVZqxr0gvyDZjE2lttJaihAAgNPqRU/U888/r7Fjx+qee+5RYmKikpOTFRsbqzlz5rgsn5CQoNmzZ2vUqFGKiIgo97gWi0VRUVFOLwBAzckvyVeof2ilygb5nb6pxZA+AEBtyy3OlZ+PnwJ9Az0dioNbSVRxcbG2bt2qAQMGOG0fMGCANm3adF6B5OXlKT4+XjExMbrxxhu1bdu2CssXFRUpJyfH6QUAqLz8knyF+IdUqixJFADAU3KLctUooJEsFtezy3qCW0nU0aNHZbVaFRkZ6bQ9MjJSWVlZVQ6iY8eOmj9/vj7++GMtXrxYQUFB6tOnj3bv3l3uZ2bNmqWIiAjHKzY2tsrnB4CGqKCkQKEB9EQBALxbbnGuVw3lk6o4scTZWaAx5rwyw549e+quu+5S165dlZSUpCVLlujCCy/USy+9VO5nZsyYoezsbMfr4MGDVT4/ADRE+cX0RAEAvJ+9J8qb+LlTuHnz5vL19S3T63TkyJEyvVPnw8fHR5dddlmFPVGBgYEKDPSecZEAUNcUlBTwTBQAwOvV+Z6ogIAAde/eXatXr3bavnr1avXu3bvagjLGKDU1VdHR0dV2TACAM56JAgDUBbnFdbwnSpKmT5+ukSNHqkePHurVq5feeOMNZWRkaMKECZJOD7M7fPiw3nnnHcdnUlNTJZ2ePOLXX39VamqqAgIC1KlTJ0nSE088oZ49e6p9+/bKycnRiy++qNTUVL3yyivVcIkAAFfoiQIA1AW5RXW8J0qShg8fruTkZD355JO65JJLtGHDBq1YsULx8fGSTi+ue/aaUd26dVO3bt20detWLVq0SN26ddP111/v2H/y5EmNHz9eiYmJGjBggA4fPqwNGzbo8ssvP8/LAwCUp6E9E+XOQvHS6VlgH330UcXHxyswMFAXXHCB3n777VqKFgBgVy96oiRp4sSJmjhxost98+fPL7PtXCvcv/DCC3rhhReqEgoAoIoa0ux89oXiX331VfXp00evv/66Bg8erB07diguLs7lZ4YNG6ZffvlFc+fOVbt27XTkyBGVlrLYMADUtjo/sQQAoH4wxjSoxXbPXChekpKTk/Xpp59qzpw5mjVrVpnyK1eu1Pr167Vv3z41bdpU0unF4ytSVFSkoqIix3vWLwSA6lHnJ5YAANQPxdZi2YytQQznq8pC8R9//LF69OihZ599Vq1bt9aFF16oP//5zyosLCz3PKxfCAA1g54oAIBXyC/Jl6RKD+cL9D29pERdTKKqslD8vn379MUXXygoKEjLly/X0aNHNXHiRB0/frzc56JmzJih6dOnO97n5OSQSAFANfDGniiSKABogApKCiSp0j1RFotFgb6BdTKJsnNnoXibzSaLxaKFCxcqIiJC0ukhgUOHDtUrr7yi4ODgMp9h/UIAqH7F1mIVW4u9rieK4XwA0ADlF/9fT1Qln4mSTg/pq4tJVFUWio+Ojlbr1q0dCZQkJSYmyhijQ4cO1Wi8AIDf5BblSpLX9USRRAFAA+RuT5RUd5OoqiwU36dPH/3888/Ky8tzbNu1a5d8fHwUExNTo/ECAH6TW/x/SRQ9UQAAT3P3mSip7iZR0umF4t966y29/fbbSktL07Rp08osFD9q1ChH+REjRqhZs2b6wx/+oB07dmjDhg164IEHdPfdd7scygcAqBne2hPFM1EA0AA1pJ4o6fRC8ceOHdOTTz6pzMxMde7cucKF4sPCwrR69Wrdf//96tGjh5o1a6Zhw4bpqaee8tQlAECD5K09USRRANAANaRnouzcXSi+Y8eOZYYAAgBql7f2RDGcDwAaoIbWEwUAqJu8tSeKJAoAGqD8knxZZHEsolsZQX5BOmUliQIA1B56ogAAXiO/OF8h/iHlrpPkCj1RAIDallucq2C/YPn5eNdTSCRRANAAFZQUuDUzn0QSBQCofTlFOV7XCyWRRAFAg5Rfku/W81ASSRQAoPblFuV63fNQEkkUADRIBSUFbs3MJ5FEAQBqX25xLj1RAADvYH8myh0kUQCA2pZbTE8UAMBLFJTyTBQAwPvlFtETBQDwEvnF+QznAwB4PXqiAABeo6CkgOF8AACvx8QSAACvkV+Sz3A+AIBXs9qsysrL0uHcw1q3f52sNqunQ3IgiQKABqigpEAhfvREAQC8U0paihJmJ+hgzkH9vz3/T/0W9FPC7ASlpKV4OjRJJFEA0CDlF1e9J8oYU0NRAQBwOoEaumSoDuUcctp+OOewhi4Z6hWJFEkUADRAVX0mymZsKrWV1lBUAICGzmqzasrKKTIqe8POvm3qyqkeH9pHEgUADVB+SdVm55PEkD4AQI3ZmLGxTA/UmYyMDuYc1MaMjbUYVVkkUQDQAFW1J0oiiQIA1JzM3MxqLVdTSKIAoIEptZWq2FpcpWeiJJIoAEDNiW4UXa3lagpJFAA0MAUlBZJETxQAwOskxSUpJjxGFllc7rfIotjwWCXFJdVyZM5IogCggckvzpcknokCAHgdXx9fzR402+U+e2KVPChZvj6+tRlWGSRRANDA5JecTqLoiQIAeKMhiUO0dNhSNQtu5rQ9JjxGS4ct1ZDEIR6K7Dd+ng4AAFC77MP5eCYKAOCthiQOUX5xvkZ9NErzb5mv+MbxSopL8ngPlB1JFAA0MPbhfPREAQC8WV5xnnwtvhrVdZQsFtfPSHkKw/kAoIFx9ETxTBQAwIvlFucqPDDc6xIoiSQKABocnokCANQFOUU5ahTYyNNhuEQSBQANDM9EAQDqgtyiXDUKIIkCAHgB+zNRwX7Bbn0u0DdQEkkUAKB22IfzeSOSKABoYApKChTkF+T2DEcWi0WBvoEkUQCAWsFwPgCA18gvyXd7Ugm7IL8gkigAQK2gJwoA4DUKSgrcnlTCjiQKAFBbcopyeCYKAOAd8ovz3Z5Uwi7IL0hF1qJqjggAgLJyi+iJAgB4CXqiAAB1AT1RAACvwTNRAIC6ILc4l4klAADegZ4oAIC3M8YwnA8A4D3yS87vmSiSKABATSssLZTVWBnOBwDwDvREAQC8XW5RriTREwUA8A75xTwTBQDwbjlFOZLEM1EAAO9ATxQAwNvlFtMTBQDwIszOBwDwdo6eKJ6JAgB4g/zifHqiAABezf5MFMP5AABeoaCkgNn5AABezd4TxXA+AIDH2YxNhaWF9EQBALxabnGufCw+CvYL9nQoLpFEAUADUlhSKEk8EwUA8Gr2hXYtFounQ3GJJAoAGpD8knxJoicKAODVcopyvHZSCYkkCgAalIKSAknimSgAgFfLLc712uehJJIoAGhQ8ovpiQIAeL+cohyvnZlPIokCgAbF0RN1Hs9EWY1VpbbS6gwLAAAn9bIn6tVXX1WbNm0UFBSk7t27a+PGjeWWzczM1IgRI9ShQwf5+Pho6tSpLsstW7ZMnTp1UmBgoDp16qTly5dXJTQAQAXsz0Sdz3A+SfRGAQBqVL17JuqDDz7Q1KlT9eijj2rbtm1KSkrS4MGDlZGR4bJ8UVGRWrRooUcffVRdu3Z1WWbz5s0aPny4Ro4cqe+//14jR47UsGHD9PXXX7sbHgCgAvaeqPMZzieRRAEAalZuUW79Gs73/PPPa+zYsbrnnnuUmJio5ORkxcbGas6cOS7LJyQkaPbs2Ro1apQiIiJclklOTlb//v01Y8YMdezYUTNmzNC1116r5ORkd8MDAFTA/kzU+Qznk0iiAAA1K7c4V+EB9WQ4X3FxsbZu3aoBAwY4bR8wYIA2bdpU5SA2b95c5pgDBw6s8JhFRUXKyclxegEAKkZPFACgLqhXE0scPXpUVqtVkZGRTtsjIyOVlZVV5SCysrLcPuasWbMUERHheMXGxlb5/ADQUOSX5Mvfx1/+vv5V+jxJFACgNtgX2/VWVZpY4uyVg40x572asLvHnDFjhrKzsx2vgwcPntf5AaAhKCgpqHIvlEQSBQCoecaY+jWxRPPmzeXr61umh+jIkSNlepLcERUV5fYxAwMDFR4e7vQCAFQsvzi/yjPzSXU7iXJnZtkzffnll/Lz89Mll1xSswECACSdbmOsxlp/eqICAgLUvXt3rV692mn76tWr1bt37yoH0atXrzLHXLVq1XkdEwBQVkPtiXJ3Zlm77OxsjRo1Stdee20tRQoAyCk6PddBvXkmSpKmT5+ut956S2+//bbS0tI0bdo0ZWRkaMKECZJOD7MbNWqU02dSU1OVmpqqvLw8/frrr0pNTdWOHTsc+6dMmaJVq1bpmWee0U8//aRnnnlGn332WblrSgEAqia/JL/KM/NJdTeJcndmWbs//vGPGjFihHr16lVLkQIAcotzJcmrh/P5ufuB4cOH69ixY3ryySeVmZmpzp07a8WKFYqPj5d0enHds+/sdevWzfHfW7du1aJFixQfH6/9+/dLknr37q33339fjz32mP7yl7/oggsu0AcffKArrrjiPC4NAHC2/JL8BtcTZZ9Z9uGHH3bafq6ZZefNm6e9e/fqvffe01NPPXXO8xQVFamoqMjxnlljAaBq7D1R3jycz+0kSpImTpyoiRMnutw3f/78MtuMMec85tChQzV06NCqhAMAqASrzar9J/crtzhX6/avU1Jcknx9fN06Rl1Moqoys+zu3bv18MMPa+PGjfLzq1xTOWvWLD3xxBPnHS8ANHS5Rf/XE1WfhvMBAOqelLQUJcxO0Lr96/TDkR/Ub0E/JcxOUEpailvHCfQNlFS3kii7ys4Ca7VaNWLECD3xxBO68MILK318Zo0FgOphH85X73qiAAB1R0paioYuGSoj51EBh3MOa+iSoVo6bKmGJA6p1LEsFosCfQPrVBLl7syyubm52rJli7Zt26ZJkyZJkmw2m4wx8vPz06pVq3TNNdeU+VxgYKACAwNr5iIAoAFxTCzhxc9E0RMFAPWY1WbVlJVTyiRQkhzbpq6cKqvNWuljBvkF1akkyt2ZZcPDw7V9+3bHpEipqamaMGGCOnTooNTUVJ7XBYAalluUKx+Lz3k9w1vT6IkCgHpsY8ZGHco5VO5+I6ODOQe1MWOjrk64ulLHrGtJlHR6ZtmRI0eqR48e6tWrl954440yM8sePnxY77zzjnx8fNS5c2enz7ds2VJBQUFltgMAqp99oV1XQ669BUkUANRjmbmZ1VpOqptJVFVmlgUAeEZuca5XTyohkUQBQL0W3Si6WstJdTOJktyfWfZMM2fO1MyZM6s/KABAGTlFOV49qYTEM1EAUK8lxSUpJjxGFrkeEmGRRbHhsUqKS6r0MetqEgUAqBtyi3K9elIJiSQKAOo1Xx9fzR40W5LKJFL298mDkt1aL4okCgBQk3KLc+mJAgB41pDEIVo6bKmiwqKctseEx7g1vbkdSRQAoCblFOXwTBQAwPOGJA5Rx2YdddGci/SXq/6ia9pco6S4JLd6oOxIogAANSm3ONetZ3U9gSQKABqI/JJ8SdJtibepa1TXKh+HJAoAUJPsU5x7M4bzAUADYV8B/nzHmZNEAQBqUm4Rz0QBALwESRQAoC6gJwoA4DXsSdT5PqxLEgUAqCnGmDqx2C5JFAA0EDlFOQryC1KAb8B5HYckCgBQU06VnlKprZThfAAA71BdK8CTRAEAakpuca4kMZwPAOAdSKIAAN4ut+h0EkVPFADAK2QXZSsiMOK8j0MSBQCoKdX1/G5NI4kCgAaCnigAgLezD+ejJwoA4BVIogAA3s7RE8UzUQAAb1AdSZTVZtX+k/tlNVat2bdGVpu1mqIDADR0VptVXx/6WpKUmpXq1W2Mn6cDAADUjvNNolLSUjRl5RQdyjkkSbru3esUEx6jWVfOqq4QAQAN1NltzPWLrldMeIxmD5qtIYlDPBxdWfREAUADcT5JVEpaioYuGepo3OwO5xzWyJSR1REeAKCBqqiNGbpkqFLSUjwUWflIogCggahqEmW1WTVl5RQZmTL7XG0DAKCyKtPGTF051euG9pFEAUADYIyp8hTnGzM2lrk7CABAdThXG2NkdDDnoDZmbKzFqM6NJAoAGoBTpadUaiutUk9UZm5mDUQEAEDl2xhva4tIogCgAbBPGVuVJCq6UXR1hwMAgKTKtzHe1haRRAFAA3A+SVRSXJJiwmNkkaW6wwIANHDnamMssig2PFZJcUm1HFnFSKIAoAE4nyTK18dXswfNlqQyjRyJFQDgfFSmjUkelCxfH99aj60iJFEA0ACcTxIlSUMSh2jpsKVqHd7aaXtMeIzeHfLueccHAGi4Kmpjlg5byjpRAADPON8kSjrdyO2fsl+fj/pckjSt5zSlT0nXzR1urpYYAQAN15DEIUqfnC4/Hz+N7jpaa0evVfqUdK9MoCTJz9MBAABqXnUkUdLpYRf92vRTWECYYsJjvG54BQCg7iqyFqnUVqoBFwzQ1QlXezqcCtETBQANQHZRtgJ9AxXoF1gtxwsLCFNecV61HAsAAEk6XnhcktQ0uKmHIzk3kigAaAByinLOuxfqTKH+ocovzq+24wEAQBIFAPAq1Z1E0RMFAKhuJFEAAK9SI0lUCUkUAKD62JOoZsHNPBzJuZFEAUADUO3D+QIYzgcAqF7HC4/LIosigiI8Hco5kUQBQAPAcD4AgLc7XnhcTYKbyMfi/SmK90cIADhvOUU51XpnL9Q/VPkl9EQBAKrPscJjdeJ5KIkkCgAahOyibIUH0BMFAPBexwuPk0QBALwHU5wDALwdSRQAwKvwTBQAwNuRRAEAvEqNzM7HM1EAgGp0vPC4mgaRRAEAvEBRaZGKrcU10hNljKm2YwIAGrbjhcfVLMT714iSSKIAoN7LKcqRpGpPomzGpiJrUbUdEwDQsDGcDwDgNWoiiQr1D5UknosCAFSLwpJCFZYWkkQBALyDPYmqznWiwgLCJJFEAQCqx/HC45JEEgUA8A7ZRdmSqrknKuB0TxTTnAMAqgNJFADAq9TUM1ESPVEAgOpBEgUA8Co1+UwU05wDAKoDSRQAwKvkFOXI38dfgb6B1XZMeqIAANXJnkQ1Dmrs2UAqiSQKAOo5+0K7Foul2o7JM1EAgOp0vPC4IgIj5Ofj5+lQKoUkCgDqOXsSVZ1C/EMk0RMFAKgedWmhXYkkCgDqvZyinGqd3lySfCw+CvUP5ZkoAEC1qEsL7UokUQBQ72UXZVd7T5R0ekgfPVEAgOpw/BRJFADAi9TEcD7p9OQSPBMFAKgOxwqO1f8k6tVXX1WbNm0UFBSk7t27a+PGjRWWX79+vbp3766goCC1bdtWr732mtP++fPny2KxlHmdOnWqKuEBAM5QU0lUqD89UQCA6nG88LiaBtXjJOqDDz7Q1KlT9eijj2rbtm1KSkrS4MGDlZGR4bJ8enq6rr/+eiUlJWnbtm165JFHNHnyZC1btsypXHh4uDIzM51eQUFBVbsqAIBDTlGOwgNqpicqr4QkCgBw/uraM1FuzyH4/PPPa+zYsbrnnnskScnJyfr00081Z84czZo1q0z51157TXFxcUpOTpYkJSYmasuWLfrXv/6l2267zVHOYrEoKiqqipcBAChPjfVEBYQynA8AUC3qWhLlVk9UcXGxtm7dqgEDBjhtHzBggDZt2uTyM5s3by5TfuDAgdqyZYtKSkoc2/Ly8hQfH6+YmBjdeOON2rZtW4WxFBUVKScnx+kFACirJp+JqkvD+dwZip6SkqL+/furRYsWCg8PV69evfTpp5/WYrQA0HAUlRYpvyS//iZRR48eldVqVWRkpNP2yMhIZWVlufxMVlaWy/KlpaU6evSoJKljx46aP3++Pv74Yy1evFhBQUHq06ePdu/eXW4ss2bNUkREhOMVGxvrzqUAQINRE1OcS6pTU5y7OxR9w4YN6t+/v1asWKGtW7eqX79+uummm855gw8A4L4Tp05IUv1fJ+rsVe+NMWW2nav8mdt79uypu+66S127dlVSUpKWLFmiCy+8UC+99FK5x5wxY4ays7Mdr4MHD1blUgCgXiu2FutU6akG3xN15lD0xMREJScnKzY2VnPmzHFZPjk5WQ8++KAuu+wytW/fXv/4xz/Uvn17/ec//6nlyAGg/jteeFyS6lRPlFvPRDVv3ly+vr5lep2OHDlSprfJLioqymV5Pz8/NWvmOtv08fHRZZddVmFPVGBgoAIDA90JHwAanJyi00OdG/IU5/ah6A8//LDT9oqGop/NZrMpNzdXTZuW38AXFRWpqKjI8Z5h5gBQOXUxiXKrJyogIEDdu3fX6tWrnbavXr1avXv3dvmZXr16lSm/atUq9ejRQ/7+/i4/Y4xRamqqoqOj3QkPAHAGq82qVXtXSZL2ndgnq81arcevK1OcV2Uo+tmee+455efna9iwYeWWYZg5AFRNvU+iJGn69Ol666239PbbbystLU3Tpk1TRkaGJkyYIOn0MLtRo0Y5yk+YMEEHDhzQ9OnTlZaWprfffltz587Vn//8Z0eZJ554Qp9++qn27dun1NRUjR07VqmpqY5jAgDck5KWooTZCboz5U5J0p9W/UkJsxOUkpZSbecICwirM89ESe4PRbdbvHixZs6cqQ8++EAtW7YstxzDzAGgao4VHJMkNQlq4uFIKs/tKc6HDx+uY8eO6cknn1RmZqY6d+6sFStWKD4+XpKUmZnp9KBumzZttGLFCk2bNk2vvPKKWrVqpRdffNFpevOTJ09q/PjxysrKUkREhLp166YNGzbo8ssvr4ZLBICGJSUtRUOXDJWRcdp+OOewhi4ZqqXDlmpI4pDzPk9oQN3oiarKUHS7Dz74QGPHjtWHH36o6667rsKyDDMHgKo5XnhcjQIayd/X9Sg1b2Qx9lke6ricnBxFREQoOztb4eHVP/YfAOoCq82qhNkJOpRzyOV+iyyKCY9R+pR0+fr4nte53vn+HY3+aLR+nfyrWjRt4dXfv1dccYW6d++uV1991bGtU6dOuuWWW1yucSid7oG6++67tXjxYt16661un5N2CQAq59E1j2rh9oXaP3V/tR2zpr+DqzQ7HwDAO23M2FhuAiVJRkYHcw5qY0b5ayRVVqh/qCTVid4od4eiL168WKNGjdJzzz2nnj17KisrS1lZWcrOzvbUJQBAvVXXFtqVqjCcDwDgvTJzM6u1XEXCAsIkSQXFBed9rJrm7lD0119/XaWlpbrvvvt03333ObaPHj1a8+fPr+3wAaBeO37qeJ1aI0oiiQKAeiW6UeVmNa1suYqEBpzuiaork0tMnDhREydOdLnv7MRo3bp1NR8QAEBS3eyJYjgfANQjSXFJigmPkUWuZ52zyKLY8FglxSWd97nsPVF1YTgfAMA7WW1WHTh5QMcKjmnd/nXVvhxHTSGJAoB6xNfHV7MHzZakMomU/X3yoOTznlRC+u2ZqIIS7x/OBwDwPvblOHYf36016WvUb0G/al+Oo6aQRAFAPTMkcYiWDluq1uGtnbbHhMdU2/Tm0m89UXVlOB8AwHvYl+M4ezIk+3Ic3p5IkUQBQD00JHGI9k/ZryC/IN3Z+U6tHb1W6VPSqy2Bks5IoopJogAAlWe1WTVl5ZQy6xlKcmybunKqVw/tI4kCgHqqoKRAp0pP6YYLb9DVCVdXyxC+M4X4h0giiQIAuKc2l+OoKSRRAFBPZeadnsa8Ombic8XXx1fBfsEqKOWZKABA5dXmchw1hSQKAOope+PTqlGrGjtHaEAos/MBANxSm8tx1BSSKACop37O/VmSFB1Wc41QWEBYnVhsFwDgPWpzOY6aQhIFAPVUZl6mwgLC1CiwUY2dI9Q/VHkl9EQBACrvzOU4zlbdy3HUFJIoAKinfs79uUZ7oaT/64linSgAgJvsy3EE+wU7ba/u5Thqip+nAwAA1IzMvMwafR5KOv1MFLPzAQCqYkjiEHVq0UmRoZG6q8tdim4UraS4JK/ugbIjiQKAeurn3J9r/KHcsIAw5eUxnA8AUDUZ2Rm6pcMtuuPiOzwdilsYzgcA9VRmbqZahdVsT1RYQBhTnAMAqqSgpEC/Fvyq+Mbxng7FbSRRAFBP1UZPVKg/w/kAAFVzMPugJCkuIs7DkbiPJAoA6qG84jzlFufW+DNRYQFhJFEAgCo5kH1AkhQfQU8UAMAL2BfarenZ+UL9Q5VfQhIFAHDfgZMH5GPxUUx4jKdDcRtJFADUQ5l5p5Oo2uiJYopzAEBVHMg+oFaNWsnf19/TobiNJAoA6qGfc3+WpJp/JiogVHnFzM4HAHDfgewDdXIon0QSBQD1UmZupkL9Q9UooFGNnicsIEwl1pIaPQcAoH7KyM6ok5NKSCRRAFAv2Wfms1gsNXqeUP/QGj0+AKD+OnCSnigAgBf5Oe/nGn8eSjrdEwUAgLtKbaU6lHOoTq4RJZFEAUC9lJmbWeMz80kkUQCAqvk592dZjZWeKACA9/g5t3Z6okIDGM4HAHDfgZP/t0YUPVEAAG+RmUdPFADAe9kX2mViCQCAV8gvzldOUU7t9EQxsQQAoAoysjPUNLhpnb0ZRxIFAPWMfaHdml4jSqInCgBQNXV5Zj6JJAoA6h37Qrs8EwUA8FYHsg/U2eehJJIoAKh3MnP/ryeqFp6J8vPxU4BvQI2fBwBQvxzIpicKAOAlrDarNhzYoADfAH2X+Z2sNmuNn48kCgDgDmOMDpw8UGcnlZBIogCg3khJS1HC7AS9uuVVFVuLdc071yhhdoJS0lJq9Hx5xXk1cnwAQP1jtVn18c6PVVhaqNyi3Bq/2VdTSKIAoB5ISUvR0CVDdSjnkNP2wzmHNXTJ0GpPpMo7HwAA5bHffLv1g1slSTPXz6zRm301iSQKAOo4q82qKSunyMiU2WffNnXl1Gq721fR+QAAcKW2b/bVNJIoAKjjNmZsrLBHyMjoYM5BbczYWCvnAwDgTLV9s682kEQBQB1nn42vusrV1nEAAA1Dbd/sqw0kUQBQx1V2Ud3qWny3NhbxBQDUH7V9s682kEQBQB2XFJekmPAYWWRxud8ii2LDY5UUl1Qr5wMA4Ey1fbOvNpBEAUAd5+vjq9mDZrvcZ090kgcly9fHt9rPRyIFADiX2r7ZVxtIogCgHhiSOEQf3v6hfM76Wo8Jj9HSYUs1JHFItZ9v6bClah3eulqPCwCof2r7Zl9t8PN0AACA6tG5ZWfZZNMz1z2j2PBYRTeKVlJcUo01SkMSh+iWDrdo5Y8rdePTN9bIOQAA9YP95tuIZSNUZC1ybI8Jj1HyoORqv9lX00iiAKCe2HRwkyyyaHz38Woc1LhWzunr46uk+Loz/AIA4DnXt79exhjdd9l96hPbp8Zv9tUkkigAqCc2Hdyki1peVGsJFAAA7vjq0FcqthVr3KXj1DWqq6fDOS88EwUA9cSmQ5vUJ7aPp8MAAMCldfvXqUlQE10cebGnQzlvJFEAUA+cKDyhHb/uUO/Y3p4OBQAAl9btX6e+CX3lY6n7KUjdvwIAgL469JUkkUQBALyO1WbVp3s+1RcZXyimUYysNqunQzpvJFEAUIdZbVat279Ob2x9QxGBEUqISPB0SAAAOKSkpShhdoIGLRwkq7Hq5W9fVsLsBKWkpXg6tPNCEgUAdZS9Yeq3oJ8+2vmRsouy1ebFNnW+YQIA1A8paSkaumSoDuUcctp+OOewhi4ZWqfbK5IoAKiD6nPDBACo+6w2q6asnCIjU2affdvUlVPr7NA+kigAqGPqe8MEAKj7NmZsLHOj70xGRgdzDmpjxsZajKr6kEQBQB1T3xsmAEDdl5mbWa3lvA1JFADUMYdzDleqXF1tmAAAdZvVZtUv+b9Uqmx0o+gajqZm+Hk6AABA5aWkpWjqp1MrVbauNkwAgLorJS1FU1ZOqXDEhCRZZFFMeIyS4pJqKbLqRRIFoF6x2qzamLFRmbmZim4Urd4xvbXp0CZl5maqZWhLSdKR/CNu7auu45zvvk92faLkr5PPWQd1vWECgPqmJtomb9znTjslScmDkuXr41tNtVy7SKIA1Buu7n75WnxlNa4nWHBnX3Udpzr2VaQ+NEwAUJ/UZNvkrfvOJSY8RsmDkjUkcUiVPu8NqvRM1Kuvvqo2bdooKChI3bt318aNFT+8vH79enXv3l1BQUFq27atXnvttTJlli1bpk6dOikwMFCdOnXS8uXLqxIagAaqvCm/K/qCd2dfdR2nOvZVpHlIcy0dtrRON0w1pSbaLgCoSE23Td66ryIvDHxB6VPS63w75XYS9cEHH2jq1Kl69NFHtW3bNiUlJWnw4MHKyMhwWT49PV3XX3+9kpKStG3bNj3yyCOaPHmyli1b5iizefNmDR8+XCNHjtT333+vkSNHatiwYfr666+rfmUAGoyKpvxuaF4Y+EKtN0x1YSr1mmi7AKAitE2uRYZG1ouREhZjjFv/Z6+44gpdeumlmjNnjmNbYmKibr31Vs2aNatM+Yceekgff/yx0tLSHNsmTJig77//Xps3b5YkDR8+XDk5Ofp//+//OcoMGjRITZo00eLFi13GUVRUpKKiIsf77OxsxcXF6eDBgwoPD3fnkgDUcRsPbNSNi270dBhe4ZMRnygpvnafhfr0x081rPcwnTx5UhEREbV67sqqibbrbLRLAM5E2+RabbVTOTk5io2Nrbm2ybihqKjI+Pr6mpSUFKftkydPNldddZXLzyQlJZnJkyc7bUtJSTF+fn6muLjYGGNMbGysef75553KPP/88yYuLq7cWB5//HEjiRcvXrx4eclr79697jQptaam2q6z0S7x4sWLl/e9aqptcmtiiaNHj8pqtSoyMtJpe2RkpLKyslx+Jisry2X50tJSHT16VNHR0eWWKe+YkjRjxgxNnz7d8f7kyZOKj49XRkaG194J9QR7Fs6d0LKoG9eol/JRN67Ze1yaNm3q6VBcqqm262y0S5XHvyXXqJfyUTeuUS/lq+m2qUqz81ksFqf3xpgy285V/uzt7h4zMDBQgYGBZbZHRETwR+RCeHg49VIO6sY16qV81I1rPj7evX57TbRdZ6Jdch//llyjXspH3bhGvZSvptomt47avHlz+fr6lrlzd+TIkTJ37OyioqJclvfz81OzZs0qLFPeMQEAqKyaarsAAA2XW0lUQECAunfvrtWrVzttX716tXr37u3yM7169SpTftWqVerRo4f8/f0rLFPeMQEAqKyaarsAAA2Yuw9Rvf/++8bf39/MnTvX7Nixw0ydOtWEhoaa/fv3G2OMefjhh83IkSMd5fft22dCQkLMtGnTzI4dO8zcuXONv7+/Wbp0qaPMl19+aXx9fc3TTz9t0tLSzNNPP238/PzMV199Vem4Tp06ZR5//HFz6tQpdy+pXqNeykfduEa9lI+6ca0u1EtNtF3nUhfqxVOoG9eol/JRN65RL+Wr6bpxO4kyxphXXnnFxMfHm4CAAHPppZea9evXO/aNHj3a9O3b16n8unXrTLdu3UxAQIBJSEgwc+bMKXPMDz/80HTo0MH4+/ubjh07mmXLllUlNAAAXKqJtgsA0DC5vU4UAAAAADRk3j2VEgAAAAB4GZIoAAAAAHADSRQAAAAAuIEkCgAAAADcUC+SqFdffVVt2rRRUFCQunfvro0bN3o6pFo1a9YsXXbZZWrUqJFatmypW2+9VTt37nQqY4zRzJkz1apVKwUHB+vqq6/Wjz/+6KGIPWPWrFmyWCyaOnWqY1tDrpfDhw/rrrvuUrNmzRQSEqJLLrlEW7dudexvqHVTWlqqxx57TG3atFFwcLDatm2rJ598UjabzVGmIdTNhg0bdNNNN6lVq1ayWCz66KOPnPZXpg6Kiop0//33q3nz5goNDdXNN9+sQ4cO1eJVeBZtE21TZdA2OaNtKot26Tde1TZ5ZlLA6mNf++PNN980O3bsMFOmTDGhoaHmwIEDng6t1gwcONDMmzfP/PDDDyY1NdXccMMNJi4uzuTl5TnKPP3006ZRo0Zm2bJlZvv27Wb48OEmOjra5OTkeDDy2vPNN9+YhIQE06VLFzNlyhTH9oZaL8ePHzfx8fFmzJgx5uuvvzbp6enms88+M3v27HGUaah189RTT5lmzZqZTz75xKSnp5sPP/zQhIWFmeTkZEeZhlA3K1asMI8++qhZtmyZkWSWL1/utL8ydTBhwgTTunVrs3r1avPdd9+Zfv36ma5du5rS0tJavpraR9tE21QZtE3OaJtco136jTe1TXU+ibr88svNhAkTnLZ17NjRPPzwwx6KyPOOHDliJDnWQLHZbCYqKso8/fTTjjKnTp0yERER5rXXXvNUmLUmNzfXtG/f3qxevdr07dvX0VA15Hp56KGHzJVXXlnu/oZcNzfccIO5++67nbYNGTLE3HXXXcaYhlk3ZzdUlamDkydPGn9/f/P+++87yhw+fNj4+PiYlStX1lrsnkLbVBZtkzPaprJom1yjXXLN021TnR7OV1xcrK1bt2rAgAFO2wcMGKBNmzZ5KCrPy87OliQ1bdpUkpSenq6srCynegoMDFTfvn0bRD3dd999uuGGG3Tdddc5bW/I9fLxxx+rR48euv3229WyZUt169ZNb775pmN/Q66bK6+8UmvWrNGuXbskSd9//72++OILXX/99ZIadt3YVaYOtm7dqpKSEqcyrVq1UufOnet9PdE2uUbb5Iy2qSzaJtdolyqnttsmv+oJ2zOOHj0qq9WqyMhIp+2RkZHKysryUFSeZYzR9OnTdeWVV6pz586S5KgLV/V04MCBWo+xNr3//vv67rvv9O2335bZ15DrZd++fZozZ46mT5+uRx55RN98840mT56swMBAjRo1qkHXzUMPPaTs7Gx17NhRvr6+slqt+vvf/6477rhDUsP+u7GrTB1kZWUpICBATZo0KVOmvn8/0zaVRdvkjLbJNdom12iXKqe226Y6nUTZWSwWp/fGmDLbGopJkybpf//7n7744osy+xpaPR08eFBTpkzRqlWrFBQUVG65hlYvkmSz2dSjRw/94x//kCR169ZNP/74o+bMmaNRo0Y5yjXEuvnggw/03nvvadGiRbrooouUmpqqqVOnqlWrVho9erSjXEOsm7NVpQ4aUj3xN/Ib2qbf0DaVj7bJNdol99RW21Snh/M1b95cvr6+ZTLHI0eOlMlCG4L7779fH3/8sdauXauYmBjH9qioKElqcPW0detWHTlyRN27d5efn5/8/Py0fv16vfjii/Lz83Nce0OrF0mKjo5Wp06dnLYlJiYqIyNDUsP9m5GkBx54QA8//LB+//vf6+KLL9bIkSM1bdo0zZo1S1LDrhu7ytRBVFSUiouLdeLEiXLL1Fe0Tc5om5zRNpWPtsk12qXKqe22qU4nUQEBAerevbtWr17ttH316tXq3bu3h6KqfcYYTZo0SSkpKfr888/Vpk0bp/1t2rRRVFSUUz0VFxdr/fr19bqerr32Wm3fvl2pqamOV48ePXTnnXcqNTVVbdu2bZD1Ikl9+vQpM9Xwrl27FB8fL6nh/s1IUkFBgXx8nL8afX19HVPJNuS6satMHXTv3l3+/v5OZTIzM/XDDz/U+3qibTqNtsk12qby0Ta5RrtUObXeNrk1DYUXsk8jO3fuXLNjxw4zdepUExoaavbv3+/p0GrNvffeayIiIsy6detMZmam41VQUOAo8/TTT5uIiAiTkpJitm/fbu644456OfXluZw5A5IxDbdevvnmG+Pn52f+/ve/m927d5uFCxeakJAQ89577znKNNS6GT16tGndurVjKtmUlBTTvHlz8+CDDzrKNIS6yc3NNdu2bTPbtm0zkszzzz9vtm3b5piiuzJ1MGHCBBMTE2M+++wz891335lrrrmmwU1xTttE21QZtE2n0Ta5Rrv0G29qm+p8EmWMMa+88oqJj483AQEB5tJLL3VMn9pQSHL5mjdvnqOMzWYzjz/+uImKijKBgYHmqquuMtu3b/dc0B5ydkPVkOvlP//5j+ncubMJDAw0HTt2NG+88YbT/oZaNzk5OWbKlCkmLi7OBAUFmbZt25pHH33UFBUVOco0hLpZu3aty++V0aNHG2MqVweFhYVm0qRJpmnTpiY4ONjceOONJiMjwwNX4xm0TbRNlUXb9BvaprJol37jTW2TxRhj3Ou7AgAAAICGq04/EwUAAAAAtY0kCgAAAADcQBIFAAAAAG4giQIAAAAAN5BEAQAAAIAbSKIAAAAAwA0kUQAAAADgBpIoAAAAAHADSRQAAAAAuIEkCgAAAADcQBIFAAAAAG4giQIAAAAAN5BEAQAAAIAbSKIAAAAAwA0kUQAAAADgBpIoAAAAAHADSRQAAAAAuIEkCgAAAADcQBIFAAAAAG4giQIAAAAAN5BEAQAAAIAbSKIAAAAAwA0kUQAAAADgBpIoAAAAAHADSRQAAAAAuIEkCgAAAADcQBIFAAAAAG4giQIAAAAAN5BEAQAAAIAbSKIAAAAAwA0kUQAAAADgBpIoAAAAAHADSRQAAAAAuIEkCgAAAADcQBIFAAAAAG4giQIAAAAAN5BEAQAAAIAbSKIAAAAAwA0kUQAAAADgBpIoAAAAAHADSRQAAAAAuIEkCgAAAADcQBIFAAAAAG4giQIAAAAAN5BEAQAAAIAbSKIAAAAAwA1+ng6guthsNv38889q1KiRLBaLp8MBgAbDGKPc3Fy1atVKPj7cmwMA1H/1Jon6+eefFRsb6+kwAKDBOnjwoGJiYjwdBgAANa7eJFGNGjWSJKWnp6tp06YejaWkpESrVq3SgAED5O/vTyxeGIu3xUMs3h+Lt8XjTbHk5OQoNjbW8T0MAEB9V2+SKPsQvkaNGik8PNyjsZSUlCgkJETh4eEe/3FDLHUjHmLx/li8LR5visWOodQAgIaCwesAAAAA4AaSKAAAAABwA0kUAAAAALih3jwTVRk2m03FxcU1fp6SkhL5+fnp1KlTslqtNX4+Yqn78VRnLP7+/vL19a2myAAAAHC2BpNEFRcXKz09XTabrcbPZYxRVFSUDh486PEHrYmlbsRT3bE0btxYUVFRHr8uAACA+qhBJFHGGGVmZsrX11exsbE1vhikzWZTXl6ewsLCPL7wJLHUjXiqKxZjjAoKCnTkyBFJUnR0dHWFCAAAgP/TIJKo0tJSFRQUqFWrVgoJCanx89mHDQYFBXnFj3Ni8f54qjOW4OBgSdKRI0fUsmVLhvYBAABUM8//kq0F9mdMAgICPBwJUDvsNwtKSko8HAkAAED90yCSKDueD0FDwd86AABAzWlQSRQAAAAAnC+SKAAAAABwQ4OYWKK6WG1WbczYqMzcTEU3ilZSXJJ8fXho3xuMGTNGJ0+e1EcffeTpUAAAAFDPkURVUkpaiqasnKJDOYcc22LCYzR70GwNSRziwci8n8Vi0fLly3XzzTef97H279+vNm3aaNu2bbrkkksc22fPni1jzHkfHwAAADgXhvNVQkpaioYuGeqUQEnS4ZzDGrpkqFLSUjwUWf1xvrPIRUREqHHjxtUTTC0qLi72dAgAAABwE0nUOVhtVk1ZOUVGZXs57Numrpwqq81a7ee22Wx65pln1K5dOwUGBiouLk5///vfHfu3b9+ua665RsHBwWrWrJnGjx+vvLw8x/4xY8bod7/7nV566SW1bt1azZo103333eeUsBQVFenBBx9UbGysAgMD1b59e82dO9exf8eOHbr++usVFhamyMhIjRw5UkePHnXsv/rqqzV58mQ9+OCDatq0qaKiojRz5kzH/oSEBEnS7373O/n6+qpLly6SpJkzZ+qSSy7R22+/rbZt2yowMFDGGK1cuVJXXnmlGjdurGbNmunGG2/U3r17Hcdr06aNJKlbt26yWCy6+uqrHdd66623Ol3X5MmT1bJlSwUFBenKK6/Ut99+69i/bt06+fr6av369br88ssVEhKi3r17a+fOnRX+Pzl06JB+//vfq2nTpgoNDVWPHj309ddfu4xBkqZOneqI0V5fkyZN0vTp09W8eXP1799fd9xxh+644w6nz5WUlKh58+aaN2+epNOL6D777LNq27atgoOD1bVrVy1durTCWAEAAFAzGuxwvoKSAv109Kdzltvy85YyPVBnMjI6mHNQc7fNVY9WPSSdTn7y8/MVmh9aZuHUjs07KsS/cgv+zpgxQ2+++aZeeOEFXXnllcrMzNRPP52OuaCgQIMGDVLPnj317bff6siRI7rnnns0adIkzZ8/33GMdevWqVmzZlqzZo327dun4cOH65JLLtG4ceMkSaNGjdLmzZv14osvqmvXrkpPT3ckSZmZmerbt6/GjRun559/XoWFhXrooYc0bNgwff75545zLFiwQNOnT9fXX3+tzZs3a8yYMerTp4/69++vb7/9Vi1bttS8efM0YMAAFRQUOD63Z88eLVmyRMuWLXMsCJufn6/p06fr4osvVn5+vv7617/qd7/7nVJTU+Xj46NvvvlGl19+uT777DNddNFF5a799eCDD2rZsmVasGCB4uPj9eyzz2rgwIHas2ePmjZt6ij31FNP6Z///KciIyM1YcIE3X333fryyy9dHjMvL099+/ZV69at9fHHHysqKkrfffedbDZbpf5/nllf9957r7788ksZY7Rnzx4NGzZMzz33nMLDwyVJn376qfLz83XbbbdJkh577DGlpKRozpw5at++vTZs2KC77rpLLVq0UN++fd06PwAAAM5Pg02ifjr6k7q/0b3ajvfHT/5YqXJbx2/VpdGXnrNcbm6uZs+erZdfflmjR4+WJF1wwQW68sorJUkLFy5UYWGh3nnnHYWGhkqSXn75Zd1000165plnFBkZKUlq0qSJ/vnPf6pJkybq1KmTbrjhBq1Zs0bjxo3Trl27tGTJEq1evVrXXXedJKlt27aOGObMmaNLL71U//jHPxzb3n77bcXGxmrXrl268MILJUldunTR448/Lklq3769Xn75Za1Zs0b9+/dXixYtJEmNGzdWVFSUcnJyHMcqLi7Wu+++6ygjyZE02M2dO1ctW7bUjh071LlzZ0fZZs2aKSoqymXd5efna86cOZo/f74GDx4sSXrzzTe1evVqzZ07Vw888ICj7GOPPaa+ffvKx8dHDz/8sG644QadOnVKQUFBZY67aNEi/frrr/r2228diVi7du1cxlCRdu3a6dlnn3W8v+CCCxQaGqpPPvlE48ePd5zrpptuUnh4uPLz8/X888/r888/V69evSSd/v/0xRdf6PXXXyeJAgAAqGUNNonq2Lyjto7fes5yW37eUqkE6fUbXy/bExXquieqMtLS0lRUVKRrr7223P1du3Z1JFCS1KdPH9lsNu3cudORRHXq1MnRyyNJ0dHR2r59uyQpNTVVvr6+5f4I37p1q9auXauwsLAy+/bu3euURJ0pOjpaR44cOec1xsfHOyVQ9uP+5S9/0VdffaWjR486enkyMjLUuXPncx7TfoySkhL16dPHsc3f31+XX3650tLSnMpedNFFTnFL0pEjRxQXF1fmuKmpqerWrZtTT1ZV9OjRw+m9v7+/hg4dqqVLl2r8+PHKz8/Xv//9by1atEjS6SGVp06dUv/+/Z0+V1xcrG7dup1XLAAAAHBfg02iQvxDKtUj1DWyq/624W86nHPY5XNRFlkUEx6jsd3GOqY7t9lsysnJUXh4eJkkqrKCg4Mr3G+MkcVicbnvzO3+/v5l9tkTk3Odw2azOXq2zmZPOM51joqcmQDa3XTTTYqNjdWbb76pVq1ayWazqXPnzm5NwGCfpe/s+nFVZ2fGbt9XXuznqi8fH58yMwS6mjDD1XWPGDFC/fr105EjR7RmzRoFBQU5etHs8fz3v/9V69atnT4XGBhYYUwAAACofkwscQ6+Pr6aPWi2pNMJ05ns75MHJVf7elHt27dXcHCw1qxZ43J/p06dlJqaqvz8fMe2L7/8Uj4+Po4eonO5+OKLZbPZtH79epf7L730Uv34449KSEhQu3btnF6uEoHy+Pv7y2o998Qbx44dU1pamh577DFde+21SkxM1IkTJ5zK2J+Bquh47dq1U0BAgL744gvHtpKSEm3ZskWJiYmVjvtsXbp0UWpqqo4fP+5yf4sWLZSZmem0LTU1tVLH7t27t1q3bq0lS5Zo4cKFuv322x3X2qlTJwUGBiojI6PM/4fY2NgqXw8AAACqhiSqEoYkDtHSYUvVOty5FyAmPEZLhy2tkXWigoKC9NBDD+nBBx/UO++8o7179+qrr75yzJx35513KigoSKNHj9YPP/ygtWvX6v7779fIkSMdQ/nOJSEhQaNHj9bdd9+tjz76SOnp6Vq3bp2WLFkiSbrvvvt0/Phx3XHHHfrmm2+0b98+rVq1SnfffXelkqIzz7NmzRplZWXp5MmT5ZZr0qSJmjVrpjfeeEN79uzR559/runTpzuVadmypYKDg7Vy5Ur98ssvys7OLnOc0NBQ3XvvvXrggQe0cuVK7dixQ+PGjVNBQYHGjh1b6bjPdscddygqKkq33nqrvvzyS+3bt0/Lli3T5s2bJUnXXHONtmzZonfeeUe7d+/W448/rh9++KFSx7ZYLBo6dKhef/11rV69WnfddZdjX6NGjfTnP/9Z06ZN04IFC7R3715t27ZNr7zyihYsWFDl6wEAAEDVkERV0pDEIdo/Zb/Wjl6rRUMWae3otUqfkl6jC+3+5S9/0Z/+9Cf99a9/VWJiooYPH+541igkJESffvqpjh8/rssuu0xDhw7Vtddeq5dfftmtc8yZM0dDhw7VxIkT1bFjR40bN87Ru9WqVSt9+eWXslqtGjhwoDp37qwpU6YoIiLCrWGKzz33nFavXq34+HhdddVV5Zbz8fHR+++/r61bt6pz586aNm2a/vnPfzqV8fPz04svvqjXX39drVq10i233OLyWE8//bRuu+02jRw5Updeeqn27NmjTz/9VE2aNKl03GcLCAjQqlWr1LJlS11//fW6+OKL9fTTTzueORs4cKD+8pe/6MEHH9Rll12m3NxcjRo1qtLHv/3227Vjxw61bt3a6XkuSfrb3/6mv/71r5o1a5YSExM1cOBA/ec//3FM+Q4AAIDaYzFnP8RRR+Xk5CgiIkJHjx5Vs2bNnPadOnVK6enpatOmjctZ16pbdTwTRSwNK57qjuV8/uZLSkq0YsUKXX/99WWed6tt3hSLt8XjTbHYv3+zs7Md0/QDAFCfef6XLAAAAADUISRRAIAqs9qs2nhgo6fDAACgVlV7ErVhwwbddNNNatWqlSwWiz766KNzfmb9+vXq3r27goKC1LZtW7322mvVHRYAoJqlpKUoYXaCblx0o6dDAQCgVlV7EpWfn6+uXbtWeoKD9PR0XX/99UpKStK2bdv0yCOPaPLkyVq2bFl1hwYAqCYpaSkaumSoDuUc8nQoAADUumpfbHfw4MGORUIr47XXXlNcXJySk5MlSYmJidqyZYv+9a9/6bbbbqvu8AAA58lqs2rKyikuFyAHAKAhqPYkyl2bN2/WgAEDnLYNHDhQc+fOVUlJSbmzThUVFamoqMjxPicnR9LpGatKSkqcypaUlMgYI5vNJpvNVs1XUJZ9wkP7OT2JWMrnTfFUdyw2m03GGJWUlDimYK8s+7+fs/8deYI3xSJ5VzyejGX9gfVOPVCjt0msWAYAaEg8nkRlZWWVWRw2MjJSpaWlOnr0qKKjo11+btasWXriiSfKbF+7dq1CQkKctvn5+SkqKkp5eXkqLi6uvuDPITc3t9bOdS7EUj5viqe6YikuLlZhYaE2bNig0tLSKh1j9erV1RJLdfCmWCTviscTsWw4seH0fxjpL+ulP68jiQIANCweT6IkyWKxOL2335U/e/uZZsyYoenTpzve5+TkKDY2Vv369XO5TtTBgwcVFhb2/9u79/ie6///47f3zhsmTLNsmA6IQlvYGDmOyDmHOYQpa6qxTqRyqE86anxqDkUIUSgdhtYBb3T4JL4fRZQOc3g7rdi0bG/vvX5/+NmntVF4v9+v97b79XtxuXzer71ee9/21pf3w+v1fr7ccp8owzDIzc2lSpUqF/wZ3EEtZaPH2S2nT58mMDCQtm3bXtJ9ojIzM+ncubPp9x/ypBZP63F3i6PQweb9m7GdsnFVyFV4/QQvZcDdX8H9bYFNLk8QERHxGKYPUbVq1eLw4cPFth09ehQfH58Sw9Cf+fv74+/vX2K7r69viTcUDocDi8WCl5eXW26qeu5yrHPPaSa1nJ8n9Ti7xcvLC4vFUur/P/xTl3Oss3lSC3hWjztaVu9eTcq6lKJL+Pzt8OZq6PUdjOoJr12PhigREalQTB+iYmJieO+994pt+/DDD4mOjvaYNykiIhXVuVX4zi0iUfUPWLMcWhyEPoPg/QbAaXMbRURE3M3p//x+6tQpduzYwY4dO4CzS5jv2LGDrKws4OxleMOHDy/aPykpiV9++YXU1FR2797NggULmD9/Pg888ICz00RE5CL8dRW+sBzY9BrccAQ6Dj87QHlbLm7hEhERkfLA6UPUV199RfPmzWnevDkAqampNG/enMcffxwAm81WNFABREZGkpGRwYYNG2jWrBlPPPEEs2bN0vLmIiIms2ZZiy7hu+44bJ0P1U5Dm1HwWZ2z+zgMB9M7TTexUkRExP2cfjnfLbfcUrQwRGkWLlxYYlu7du34+uuvnZ0iIiKXwZZrA6DFAfhgKRypDPFD4WDV4vvVDKppQp2IiIh5TP9MlGny8uC771zzvQsL8f79d6hUCf66SEDDhvCXJdhFRDxRWJUwun4PK9+E7bWg52D4rZQ/vmpVruX+OBERERNV3CHqu+8gKsol39oLqHK+L27bBjfd5JLnFRFxpuve+5z33oAProVB/eH0X9b6sWAhPDic2IhYcwJFRERMUnGHqIYNzw40LlBYWMjvv/9OpUqVSi5X3bChS55TRMRpDINDj4/nqidnsqxlEHd0ycPhbQH+d6m2hbP3M0vrmoa3lxaXEBGRiqXiDlFBQa47I1RYiCMnB4KDS17OJyLiyQoLOXjXIGrPf4tXuofRe/kOVuzfXOw+UQDhweGkdU2jb6O+5OTkmBgsIiLifhV3iBIRkeIKCjjUrwthH2zkxWHXkPjKNoL9g+nbqC+9GvTCmmXFlmsjrEoYcXXidAZKREQqLA1RIiICubkc7hJLjf98w3Mp0dz37CYCfQOLvuzt5c0t9W4xr09ERMSD6FozEZGK7sgRjrZsQuD2b3hhcmfuf+GzYgOUiIiIFKczUSIiFZjxww/8dktLHCd/Zc4Lg5mQvAQvi/59TURE5EL0N6WISAVlbNvGqZubcvyPX3nrlXE8lLxUA5SIiMg/oL8tRUQqIEfmh+S3acXuoDw2Lv0X9w16EYvFYnaWiIhImaDL+UREKhj7siUwfDgbIw1+e/0V7mw12uwkERGRMkVnokREKpDTM57Fe+gw3mpiwf72agZpgBIREbloFepMlGEYZieIuEVhYaHZCeJpDIM/HhxP4AszmRnnS7OF62lXv73ZVSIiImVShRiifH19sVgsHDt2jJo1a7r8uv/CwkIKCgo4ffo0Xl7mnuxTS9nocVaLYRgUFBRw7NgxvLy88PPzc2KllFl2O7+PHEqlpW/yWI9K9Jm3iZvCbjK7SkREpMyqEEOUt7c34eHhHDhwgJ9//tnlz2cYBn/88QeBgYGmf1BbLWWjx9ktQUFB1KlTx/ThUDxAXh6/9+mO30cbuG9IdZLTttAwpKHZVSIiImVahRiiACpXrsy1116L3W53+XPZ7XY2bdpE27Zt8fX1dfnzqaXs9zizxdvbGx8fH9MHQ/EA2dn8Ht8Bdu4kKSmcyU9toU7VOmZXiYiIlHkVZoiCs28uvb293fI8Z86cISAgwPQ352opGz2e1CLlRFYWeR3bkmfLIvX+65gxyUrNSjXNrhIRESkXKtQQJSJSIXzzDac73cKRgl959NFoZo//iGD/YLOrREREyg19YEJEpDyxWimIbcUeSzaT/9WJV+/fqAFKRETEyXQmSkSkjHIYDjb+spFjfxwjrEoYcV//ijF4IJuvOsPyJwYwf/ASfL11eaiIiIizaYgSESmD3v7ubZJ3JZP9f9kA3PkVxH0AqxvB59OTmXPbv/Gy6GIDERERV3DZ37Dp6elERkYSEBBAVFQUVqv1gvu//PLLNGrUiMDAQBo0aMDixYtdlSYiUqat3r2aQasHkW3PBgMe2wDz3of0m2Fwf2h9TQcNUCIiIi7kkr9lV6xYwbhx45g0aRLbt28nLi6Obt26kZWVVer+s2fPZuLEiUyZMoVvv/2WqVOnMnbsWN577z1X5ImIlFmOQgcp61IwMPAqhPQPYNoGeKQD3NcNDC8L49ePx1HoMDtVRESk3HLJEDVjxgwSExMZPXo0jRo1Ii0tjYiICGbPnl3q/q+//jpjxoxh4MCB1K9fn0GDBpGYmMgzzzzjijwRkTLLmmXlQM4B/O3w5ltw5zYY1ROmtwUsYGCwP2c/1qwLn/0XERGRS+f0z0QVFBSwbds2JkyYUGx7ly5d2Lp1a6nH5OfnExAQUGxbYGAgX375JXa7vdT75uTn55Ofn1/0OCcnBzh701J33FD3Qs49v9kdf25QS0me1KOW0nlSC3hGz/4T+6n6B6xZDi0OQp9B8H6D0vdzV6en/P6IiIi4i9OHqOPHj+NwOAgNDS22PTQ0lMOHD5d6THx8PK+++iq9e/fmpptuYtu2bSxYsAC73c7x48cJCwsrccz06dOZOnVqie2ffvopQUFBzvlhLlNmZqbZCUXUcn6e1KOW0nlSC5jbk521k02vQXgOdBwOn9Upfb9fvvmFjF8y3NKUl5fnlucRERHxFC5bnc9isRR7bBhGiW3nPPbYYxw+fJhWrVphGAahoaGMGDGCZ599Fm9v71KPmThxIqmpqUWPc3JyiIiIoH379tSoUcN5P8glsNvtZGZm0rlz51LPoqnF/BZP61GL57d4RM+ePXDvWA6fhjajYPeVJXexYKF2cG0euP0BvL1K//PT2c5dCSAiIlJROH2ICgkJwdvbu8RZp6NHj5Y4O3VOYGAgCxYsYO7cuRw5coSwsDDmzZtHlSpVCAkJKfUYf39//P39S2z39fX1iDdboJbz8aQW8KwetZTOk1rApJ4vvuDMrV3Z53uKgffU4Du/XwGj2C4Wzv5D1cyuMwnwDyjlm7iGJ/3eiIiIuIPTF5bw8/MjKiqqxOUumZmZxMbGXvBYX19fwsPD8fb2Zvny5fTo0QMvLy3TKyIV3Nq1ONrfwlfBp0h84FrWTtjJ8r7LqeFb/Kx7eHA4KwespG+jvuZ0ioiIVBAuuZwvNTWVYcOGER0dTUxMDPPmzSMrK4ukpCTg7KV4Bw8eLLoX1N69e/nyyy9p2bIlv/32GzNmzOCbb75h0aJFrsgTESk7Fi2iMHEUa6+1MCPlZt67I4NqgdXo07APPvt8CG4SzLE/jhFWJYy4OnFuu4RPRESkInPJEDVw4ECys7OZNm0aNpuNJk2akJGRQd26dQGw2WzF7hnlcDh44YUX2LNnD76+vrRv356tW7dSr149V+SJiHg+w4DnnoOHH+a1KAvvpHTh/UGrCPL938I53hZv2tVtp8vpRERE3MxlC0skJyeTnJxc6tcWLlxY7HGjRo3Yvn27q1JERMqWwkK4/35IS+OJtrA3JYHVvV7D11vDkoiIiCdw2RAlIiKXoKAAY8QIWL6csbeC370pLIqfgZdFnw8VERHxFBqiREQ8RW4uRt8+ODZ8yqD+Bs3veZJH4h457+0hRERExBwaokREPMGRIxR2v5XTu3fSfUghA++ZTVJ0ktlVIiIiUgoNUSIiZtu3j8L4Lpw4fpAuIwweTn6T2xvfbnaViIiInIeGKBERM339NYXdunLAkku30V6k3f0ena/ubHaViIiIXICGKBERs3z8MYW9e/FtjUL6Dw/k9THraFG7hdlVIiIi8je03JOIiBlWrMDo1g1ruIP+SdV4594tGqBERETKCA1RIiLuNmsWxuDBrLzBi7FJdci8+zMa1WxkdpWIiIj8Q7qcT0TEXQwDHnkEnn6af8f5sXTIDWwYtpaQoBCzy0REROQiaIgSEXEHux3uugsWLuShrt58PTiOjwa+TRX/KmaXiYiIyEXSECUi4mp5eTBgAIXr13FHPwunB/bhgz5L8PfxN7tMRERELoE+EyUi4krZ2dCxIwWfZNJ1kINKI+5ieb/lGqBERETKMA1RIiKukpWF0aYNp777L62HFtBi5CRmd5+Nt5e32WUiIiJyGXQ5n4iIK3zzDUZ8PMcducQOy2NswouMazXO7CoRERFxAg1RIiLOZrVi9OzJz1UN2iT8ztNDFzOs6TCzq0RERMRJdDmfiIgzvfMORufO7AiDVsNOM/fONRqgREREyhkNUSIizjJvHka/fnzUJJD4hEJW3fkRPa7rYXaViIiIOJmGKBGRy2UYMG0ajBnDkjZVGDHQn4/utNKmThuzy0RERMQF9JkoEZHL4XDAPffAnDk83S2YV+KrYx3+EfWr1Te7TERERFxEQ5SIyKU6fRqGDMFYs4b7+gVh7RTJlqHrqFW5ltllIiIi4kIaokRELsWJE9CrF44vPmfgYG+OdLiJDYPf44qAK8wuExERERdz2Wei0tPTiYyMJCAggKioKKxW6wX3X7p0KU2bNiUoKIiwsDBGjhxJdna2q/JERC7doUPQti35O7bRfpiD/Fu7sH7oeg1QIiIiFYRLhqgVK1Ywbtw4Jk2axPbt24mLi6Nbt25kZWWVuv/mzZsZPnw4iYmJfPvtt7z11lv85z//YfTo0a7IExG5ZJUPHsSnXTtOHdnPTUN/J7L7EFYPWE2Qb5DZaSIiIuImLhmiZsyYQWJiIqNHj6ZRo0akpaURERHB7NmzS93/888/p169etx3331ERkbSpk0bxowZw1dffeWKPBGRS2L58kvaTJjAMX6n4ZATxPccz2u9XsPX29fsNBEREXEjp38mqqCggG3btjFhwoRi27t06cLWrVtLPSY2NpZJkyaRkZFBt27dOHr0KCtXrqR79+7nfZ78/Hzy8/OLHufk5ABgt9ux2+1O+Eku3bnnN7vjzw1qKcmTetRSOk9qsaxbh/egQeyp5U9c/+Ok3voED8U8hOOMAwcOt/d40mvjCQ0iIiLuZDEMw3DmNzx06BC1a9dmy5YtxMbGFm1/6qmnWLRoEXv27Cn1uJUrVzJy5EhOnz7NmTNn6NmzJytXrsTXt/R/4Z0yZQpTp04tsX3ZsmUEBemyGhFxnohPPqHZSy+x9foriO/1GyPq302XGl3MzvIYeXl5JCQkcPLkSYKDg83OERERcTmXrc5nsViKPTYMo8S2c3bt2sV9993H448/Tnx8PDabjQcffJCkpCTmz59f6jETJ04kNTW16HFOTg4RERG0b9+eGjVqOO8HuQR2u53MzEw6d+583iFQLeZf/uRJPWrx0BbDwOuFF/CeNYu17WrTr/1R7q33IJNvn6zX5k/OXQkgIiJSUTh9iAoJCcHb25vDhw8X23706FFCQ0NLPWb69Om0bt2aBx98EIAbb7yRSpUqERcXx5NPPklYWFiJY/z9/fH39y+x3dfX1/Q3FOeopXSe1AKe1aOW0pnSUlgI998PaWks6FGblJgTvN3/PU7vPq3XppQGERGRisTpC0v4+fkRFRVFZmZmse2ZmZnFLu/7s7y8PLy8iqd4e3sDZ89giYi4VUEBDB2KMXMmTwwM4+G2+Xw6YgMdIjuYXSYiIiIewCWX86WmpjJs2DCio6OJiYlh3rx5ZGVlkZSUBJy9FO/gwYMsXrwYgNtuu40777yT2bNnF13ON27cOFq0aMFVV13likQRkdLl5kLfvhRu2sjY4TX4oKkP1mGf0DCkoRZQEBEREcBFQ9TAgQPJzs5m2rRp2Gw2mjRpQkZGBnXr1gXAZrMVu2fUiBEjyM3N5aWXXuL+++/niiuuoEOHDjzzzDOuyBMRKd2RI9C9O46939FvZBB7b6jJlqHriagaYXaZiIiIeBCXLSyRnJxMcnJyqV9buHBhiW333nsv9957r6tyREQubN8+iI8nP+c32o8wcNzYAGtCBjWCzF2oRkRERDyPS262KyJSpnz9NcTGcupMHk2HnaLyza35ePjHGqBERESkVBqiRKRi+/hjaNeOYzUrcfXAwzSN6c17g9+jsl9ls8tERETEQ2mIEpGKa8UK6NaNH6+/isieP9E3bgzL+i7D36fk7RNEREREztEQJSIV06xZGIMHs63ttTSI30tq58dI756Ot5e32WUiIiLi4Vy2sISIiEcyDHjkEXj6adb1bkL3G78h7daZ3NfyPrPLREREpIzQECUiFYfdDnfdBQsXsmBoY8Zc9x2v91rCkBuHmF0mIiIiZYiGKBGpGPLyYMAAjPXr+dddDXmqzo+sGbCGW6+91ewyERERKWM0RIlIueUodGDNspK9fy+dUmZSZe/PjE2uw/KrDpM5OJPWdVqbnSgiIiJlkIYoESmXVu9eTcq6FCxZB1i/BPLzIH6oF3uu+pVNIzZxQ+gNZieKiIhIGaXV+USk3Fm9ezX93+xP1e8P8Nl88D8DrRPhi6sKOXn6JN//+r3ZiSIiIlKGaYgSkXLFUeggZV0KrX8xsL4Gx4IgNhF+qPG/fcatG4ej0GFepIiIiJRpGqJEpFyxZlmJ+uIAmYthey1oNxKOVPnf1w0M9ufsx5plNS9SREREyjQNUSJSrgS9toRVb8K7DaDbUMgJKH0/W67NvWEiIiJSbmiIEpHywTBg2jRaTJtP+s0wuD8UXGDpnLAqYe5rExERkXJFq/OJSNnncMA998CcOWSMaMN9dTeDpfRdLVgIDw4nrk6cextFRESk3NCZKBEp206fPnsT3VdeYf7YWLrX28yo5qOw/P//+7Nzj9O6puHt5W1GrYiIiJQDGqJEpOw6cQLi4zEyMnhiXHOSQr9kad+lzO81n5UDVlI7uHax3cODw1k5YCV9G/U1p1dERETKBV3OJyJl06FD0LUrhQf2c/f4a1haeTcfDPyALld3AaBvo770atALa5YVW66NsCphxNWJ0xkoERERuWwaokSk7NmzB+LjOXOmgL5ja7C1io1PhnxCi9otiu3m7eXNLfVuMadRREREyi0NUSJStnzxBXTvTn7IFcQNLOBINTtbhm6hQUgDs8tERESkgtBnokSk7Fi7Fjp0ILd+bRoP+pW80OpsHbVVA5SIiIi4lcuGqPT0dCIjIwkICCAqKgqr1XrefUeMGIHFYinxq3Hjxq7KE5GyZtEiuO02jsbcSL3u31OrzvVYR1pLLB4hIiIi4mouGaJWrFjBuHHjmDRpEtu3bycuLo5u3bqRlZVV6v4zZ87EZrMV/dq/fz/Vq1fn9ttvd0WeiJQlhoHX88/DiBH80CuOOm3+Q+x1Hflw2IdUC6xmdp2IiIhUQC4ZombMmEFiYiKjR4+mUaNGpKWlERERwezZs0vdv2rVqtSqVavo11dffcVvv/3GyJEjXZEnImVFYSFNFizA+5FH+GJkF669YQODmw/j7YFvE+QbZHadiIiIVFBOX1iioKCAbdu2MWHChGLbu3TpwtatW//R95g/fz6dOnWibt26590nPz+f/Pz8osc5OTkA2O127Hb7JZQ7z7nnN7vjzw1qKcmTetRSioICLCNHUv/991k9tiP9an7I/a3u56n2T2E4DOwO9/d5zGuDZ7aIiIhUFBbDMAxnfsNDhw5Ru3ZttmzZQmxsbNH2p556ikWLFrFnz54LHm+z2YiIiGDZsmUMGDDgvPtNmTKFqVOnlti+bNkygoL0L9QiZZnPH39w89NPU+Pbb3lyWEOm1P2GkVeNpNeVvcxOk1Lk5eWRkJDAyZMnCQ4ONjtHRETE5Vy2xLnFYin22DCMEttKs3DhQq644gp69+59wf0mTpxIampq0eOcnBwiIiJo3749NWrUuKRmZ7Hb7WRmZtK5c2d8fX3V4oEtntajlj85cgTvXr2w/PQTjzwUzXN+/+HVW19leLPh7m/5C9NfGw9tOXclgIiISEXh9CEqJCQEb29vDh8+XGz70aNHCQ0NveCxhmGwYMEChg0bhp+f3wX39ff3x9/fv8R2X19f099QnKOW0nlSC3hWT4Vv2bcP4uMpPHWKkan1ecv3vzwS8QjDmw33mNcF9PtUWoOIiEhF4vSFJfz8/IiKiiIzM7PY9szMzGKX95Vm48aN/PDDDyQmJjo7S0Q83ddfQ2wsZyjk1rFVeS8wi/UJ64kKjjK7TERERKQYl6zOl5qayquvvsqCBQvYvXs348ePJysri6SkJODspXjDh5e8NGf+/Pm0bNmSJk2auCJLRDzVxx9Du3acrh1KixF2dlX+g80jN9Oydkuzy0RERERKcMlnogYOHEh2djbTpk3DZrPRpEkTMjIyilbbs9lsJe4ZdfLkSVatWsXMmTNdkSQinmr5chg+nJOto2ja8XuCql3JlqHriagaoVXfRERExCO5bGGJ5ORkkpOTS/3awoULS2yrWrUqeXl5rsoREU80axakpHCoV0caR39Ow7AbeH/w+9QIMndxGBEREZELccnlfCIiF2QYMHEipKSwe0QPIptvJCayLR8N+0gDlIiIiHg8l52JEhEpld0Od90FCxdiva837aqvYeiNQ5nfcz6+3lrlTURERDyfzkSJiPvk5UGfPhhLlvDWxF60rf4O98fcz8LeCzVAiYiISJmhM1Ei4h7Z2dCjB8bOncx8rDPjjTU82+lZHmz9oNllIiIiIhdFQ5SIuF5WFsTHY2Rn89Aj0bx45kMW9lrIHc3uMLtMRERE5KJpiBIR19q5E7p2pdDPl2Gp9Xjb8SXvDHqHHtf1MLtMRERE5JJoiBIR17Fa4bbbsNepTdchsJ0f+Gj4R8RGxJpdJiIiInLJNESJiGu88w4MGkTezc2J6W4j2/cM1qFWGl/Z2OwyERERkcui1flExPnmzYN+/fitSxwNuu8jv3IAWxO3aoASERGRckFDlIg4j2HAtGkwZgz7h/YksuXnXBUSyeZRm6lTtY7ZdSIiIiJOocv5RMQ5HA645x6YM4dvUgYTVWMl7et2YNWAVVTyq2R2nYiIiIjT6EyUiFy+06dhwAB45RU+fXQoN1ZbTv/Gt/Pu4Hc1QImIiEi5oyFKRC7PiRNn7wGVkcGyabfTwWcJKS1TeL3P6/h5+5ldJyIiIuJ0GqJE5NIdOgRt22Ls3Mnz07oyxL6c6R2nMyN+Bl4W/fEiIiIi5ZM+EyUil2bPnrNnoBxnSH3sZmblvsv8nvMZ1XyU2WUiIiIiLqUhSkQu3hdfQPfuOK6syeA7q/Fe3ibeHvg2PRv0NLtMRERExOU0RInIxVm7Fvr3p+DGJnS5/Q925O/iw6EfElc3zuwyEREREbfQECUi/9yiRZCYyO9d2tOiwz5+M05jHWnlhtAbzC4TERERcRt98ltE/p5hwLPPwogRZA/syXXt/suZAF+2Jm7VACUiIiIVjoYoEbmwwkJITYWHH+bne4dRv8lHXFW9DptHbqbeFfXMrhMRERFxO13OJyLnV1AAI0bA8uXseOxOWvktJi48jtUDVlPFv4rZdSIiIiKmcNmZqPT0dCIjIwkICCAqKgqr1XrB/fPz85k0aRJ169bF39+fq6++mgULFrgqT0T+Tm4udO8Oq1aROf1Oonzm07thbz5I+EADlIiIiFRoLjkTtWLFCsaNG0d6ejqtW7dm7ty5dOvWjV27dlGnTp1SjxkwYABHjhxh/vz5XHPNNRw9epQzZ864Ik9E/ob/iRN4d+6M8cMPvP7MEO44OY97W9xLWtc03URXREREKjyXDFEzZswgMTGR0aNHA5CWlsb69euZPXs206dPL7H/unXr2LhxIz/++CPVq1cHoF69ehd8jvz8fPLz84se5+TkAGC327Hb7U76SS7Nuec3u+PPDWopyZN6PKnlzJ49tJkwAQyDp56M59FfX2Nqu6lMiJ2A44wDBw63tXjS6wKe1eOJLSIiIhWFxTAMw5nfsKCggKCgIN566y369OlTtD0lJYUdO3awcePGEsckJyezd+9eoqOjef3116lUqRI9e/bkiSeeIDAwsNTnmTJlClOnTi2xfdmyZQQFBTnvBxKpQKru20eradOwBwWROLo2q7y/JikiiS41upidJh4sLy+PhIQETp48SXBwsNk5IiIiLuf0M1HHjx/H4XAQGhpabHtoaCiHDx8u9Zgff/yRzZs3ExAQwNtvv83x48dJTk7m119/Pe/noiZOnEhqamrR45ycHCIiImjfvj01atRw3g90Cex2O5mZmXTu3BlfX1+1eGCLp/V4Qovlk0/wnjyZM9ddQ7eedj7z3sny3svp3aC3KT3gGa+Lp/Z4Usu5KwFEREQqCpetzmexWIo9NgyjxLZzCgsLsVgsLF26lKpVqwJnLwns378/L7/8cqlno/z9/fH39y+x3dfX1/Q3FOeopXSe1AKe1WNay/LlMHw4+e3a0LHHr2zP+YkPBn1Ax2s6ur+lFJ70ewSe1eMJLWY/v4iIiLs5/RPiISEheHt7lzjrdPTo0RJnp84JCwujdu3aRQMUQKNGjTAMgwMHDjg7UUT+bNYsGDyYU32607z7fvbZj/Cva/9F27ptzS4TERER8UhOH6L8/PyIiooiMzOz2PbMzExiY2NLPaZ169YcOnSIU6dOFW3bu3cvXl5ehIeHOztRRAAMAyZOhJQUjt19Bw2iP8fuDRuGbyAyMNLsOhERERGP5ZK1ilNTU3n11VdZsGABu3fvZvz48WRlZZGUlASc/TzT8OHDi/ZPSEigRo0ajBw5kl27drFp0yYefPBBRo0add6FJUTkMtjtMGoUPP00Pz46lmvrvENocBibR26mfrX6ZteJiIiIeDSXfCZq4MCBZGdnM23aNGw2G02aNCEjI4O6desCYLPZyMrKKtq/cuXKZGZmcu+99xIdHU2NGjUYMGAATz75pCvyRCq2vDwYMADWr2fbs+NpnZ9O66ta8/bAtwn2D9Zy1SIiIiJ/w2ULSyQnJ5OcnFzq1xYuXFhiW8OGDUtcAigiTpadDT16wM6drEu7l+7ZM+nXqB+v93kdf5+SC7WIiIiISEkuuZxPRDxQVha0aYOxbx8LZ9xBt+MvkhSVxBv93tAAJSIiInIRNESJVAQ7d0JMDEZ+Pv+a3o2RtnSmtJvCS7e+hLeXt9l1IiIiImWKyy7nExEPYbXCbbdRWK8uY++pz9wDrzO7+2ySopPMLhMREREpkzREiZRn77wDgwZxJqYltw/2JuNwBm/d/hb9ru9ndpmIiIhImaUhSqS8mjcP7r6b/N496NjpEP/N3sO6IetoH9ne7DIRERGRMk1DlEh5YxjwxBMweTI5d95Bqyafkf37CTaO2EjzsOZm14mIiIiUeRqiRMoThwPuuQfmzOHIxPu4qcZbBBDIllFbuKb6NWbXiYiIiJQLGqJEyovTp2HIEFizhu+fnUCLwjnUq1yPtUPWUqtyLbPrRERERMoNLXEuUh6cOAHx8ZCRwZcvPcKNBWk0q9WMDXds0AAlIiIi4mQaokTKukOHoG1b2LmTD2anEnv0KW699lbWDllL1YCqZteJiIiIlDsaokTKsj17IDYW47ffmD9rJD1+eYrE5om82f9NAnwCzK4TERERKZc0RImUVV98Aa1bY1SqxBPTuzF63wweb/s4c3rMwdvL2+w6ERERkXJLC0uIlBGOQgfWLCu2XBuNt2Vxw9hpGM2akTymNvP2vcpL3V5ibIuxZmeKiIiIlHsaokTKgNW7V5OyLoUDOQcYvgNuXwMfXh/AlEG/s+2Xd1jefzkDGg8wO1NERESkQtAQJeLhVu9eTf83+2MYBg9ugWc/gldugru7n8bx6//xeLvHNUCJiIiIuJE+EyXiwRyFDlLWpUChwYz1ZweoaW3hrtvA8f8/9vTa9tdwFDrMDRURERGpQDREiXgwa5aVI78eYMlqSPkckm+FyR0Ay//22Z+zH2uW1bRGERERkYpGl/OJeLBjh3/kg2XQ9hcYcDusalz6frZcm3vDRERERCowDVEinurIEbre9QyFByF+KGyMPP+uYVXC3NclIiIiUsFpiBLxRPv2QXw8lX//nbZjqrC5em6pu1mwEB4cTlydODcHioiIiFRcLvtMVHp6OpGRkQQEBBAVFYXVev7PbGzYsAGLxVLi13fffeeqPBHP9fXXEBuL4eXFy2kJRQOU5c8fhPrT47Suabq5roiIiIgbuWSIWrFiBePGjWPSpEls376duLg4unXrRlZW1gWP27NnDzabrejXtdde64o8EY9l+eQTaNcOo24dJkxpw73fzeDJ9k+y8vaV1A6uXWzf8OBwVg5YSd9GfU2qFREREamYXHI534wZM0hMTGT06NEApKWlsX79embPns306dPPe9yVV17JFVdc4YokEY9X22rFe9YsHO1vYfiQQFb8sJhXb3uVxJsSAejdsDfWLCu2XBthVcKIqxOnM1AiIiIiJnD6EFVQUMC2bduYMGFCse1dunRh69atFzy2efPmnD59muuvv55HH32U9u3bn3ff/Px88vPzix7n5OQAYLfbsdvtl/ETXL5zz292x58b1FKSJ/UYM2cS/cIL5N3el+6djvDF/s2s7L+S7td2L9bXunbrov9d6Cik0FHo9BZPel08qQU8q8cTW0RERCoKi2EYhjO/4aFDh6hduzZbtmwhNja2aPtTTz3FokWL2LNnT4lj9uzZw6ZNm4iKiiI/P5/XX3+dOXPmsGHDBtq2bVvq80yZMoWpU6eW2L5s2TKCgoKc9wOJuJJh0GjJEq5btYqdt8XTM2Y32Y7fmFR/Eg0rNTS7TuQfycvLIyEhgZMnTxIcHGx2joiIiMu5bHU+i6X4h+ANwyix7ZwGDRrQoEGDoscxMTHs37+f559//rxD1MSJE0lNTS16nJOTQ0REBO3bt6dGjRpO+Akund1uJzMzk86dO+Pr66sWD2zxiB67He+778Zr1SoOPJZKx4DX8ff3Z/PgzTQKaeT+nqIsz/l98qQWT+vxpJZzVwKIiIhUFE4fokJCQvD29ubw4cPFth89epTQ0NB//H1atWrFkiVLzvt1f39//P39S2z39fU1/Q3FOWopnSe1gEk9eXkwYACsX8/3s6bQ6o9ZVDYqs3HERupVr+felvPwpN8nT2oBz+rxhBazn19ERMTdnL46n5+fH1FRUWRmZhbbnpmZWezyvr+zfft2wsJ0A1Eph7KzoWNH2LCBz+c+RtOcZ7g+5HqeuuYpalep/ffHi4iIiIipXHI5X2pqKsOGDSM6OpqYmBjmzZtHVlYWSUlJwNlL8Q4ePMjixYuBs6v31atXj8aNG1NQUMCSJUtYtWoVq1atckWeiHmysiA+HrKzeXfOePr+OI2eDXqy8LaFfJr5qdl1IiIiIvIPuGSIGjhwINnZ2UybNg2bzUaTJk3IyMigbt26ANhstmL3jCooKOCBBx7g4MGDBAYG0rhxYz744ANuvfVWV+SJmGPnTujaFcPfn9lpQxj7/ZMkRSXx0q0vuWSVPRERERFxDZctLJGcnExycnKpX1u4cGGxxw899BAPPfSQq1JEzGe1wm23YdSrxyMPNOfp79OYdss0Hm37KBaLRUOUiIiISBnisiFKRP6/d96BQYNwxLRi1IgrWPLjYub1mMedUXeaXSYiIiIil0BDlIgrzZsHd99NQe+e9Oj2K9YD61k9YDW9GvYyu0xERERELpGGKBFXMAx44gmYPJlTd40krulX/JJ9gI+GfUTrOq3NrhMRERGRy6AhSsTZHA645x6YM4djj4zj5pDVOPILsY600vjKxmbXiYiIiMhl0hAl4kynT8OQIbBmDT8+N4kWhXMI9Q9l3ZB1RFSNMLtORERERJzA6TfbFamwTpw4ew+ojAy+enkSNxS8SKOajdg8crMGKBEREZFyREOUiDMcOgRt28LOnXwwO5VWR/5F5/qd+XDoh1QLrGZ2nYiIiIg4kYYokcv13XcQE4Px22+8MvMOevzyFInNE1k5YCWBvoFm14mIiIiIk2mIErkcX3wBbdpgVK7M5Kc6c9ePaUxuN5k5Pebg46WPHIqIiIiUR3qXJ3Kp1q6F/v0pbNaU0aOvZNFPi5jdfTZJ0Ulml4mIiIiIC2mIErkUixZBYiL2bl24refvbDi4jpW3r6RPoz5ml4mIiIiIi2mIErkYhgHPPQcPP0zeHQnE3fwNP/6aReawTOLqxpldJyIiIiJuoCFK5J8qLIT774e0NLLvTyY6/APs+WewjrTS5MomZteJiIiIiJtoiBL5JwoKYMQIWL6cn//1IDf7vkZN35psHLqOOlXrmF0nIiIiIm6k1flE/k5uLnTvDqtWsX3mRBrzMtdWv5bNozZrgBIRERGpgDREiVzIkSNwyy3w5ZesfzmVFieepWNkRz4a/hHVA6ubXSciIiIiJtAQJXI++/ZB69YYhw7x2syRdD34NHc0vYPVA1cT5Btkdp2IiIiImERDlEhpvv4aYmMxvLx4cno3Rv0yk0fjHuWV217RTXRFREREKji9GxT5q48/ht69KWzYkKS7w3n1l4W8fOvLJN+cbHaZiIiIiHgADVEif7Z8OQwfzplb2tK7/xk+OrSWlQNW0rdRX7PLRERERMRDaIgSOWfWLEhJ4Y9B/WgXt4+9v/7E+qHraVevndllIiIiIuJBXPaZqPT0dCIjIwkICCAqKgqr1fqPjtuyZQs+Pj40a9bMVWkixRkGTJwIKSn8NjaRJi22cfD0UawjrRqgRERERKQElwxRK1asYNy4cUyaNInt27cTFxdHt27dyMrKuuBxJ0+eZPjw4XTs2NEVWSIlWM6cwfvOO+Hpp9n/+Dga1H0XX19/to7ayg2hN5idJyIiIiIeyCVD1IwZM0hMTGT06NE0atSItLQ0IiIimD179gWPGzNmDAkJCcTExLgiS6S4vDxaPP00lmXL+O/zD9HI/xWurn41W0Ztoe4Vdc2uExEREREP5fTPRBUUFLBt2zYmTJhQbHuXLl3YunXreY977bXX2LdvH0uWLOHJJ5/82+fJz88nPz+/6HFOTg4Adrsdu91+ifXOce75ze74c4Na/iI7G69evQj55hvWz7iX207MoEv9LiztvZRKvpXc3uhJr41azs+TejyxRUREpKJw+hB1/PhxHA4HoaGhxbaHhoZy+PDhUo/5/vvvmTBhAlarFR+ff5Y0ffp0pk6dWmL7p59+SlCQZ9wINTMz0+yEImr5n8Bjx4iZOhW/3FyeSe3E5F9fpGP1jiRWSmTjRxtNbTP7tfkztZyfJ/V4QkteXp7ZCSIiIm7lstX5LBZLsceGYZTYBuBwOEhISGDq1Klcd911//j7T5w4kdTU1KLHOTk5RERE0L59e2rUqHHp4U5gt9vJzMykc+fO+Pr6qsWTWnbuxCc5Gfz8ePLZnky2vc5DrR7iifZPlPrfp7t4xGujljLV40kt564EEBERqSicPkSFhITg7e1d4qzT0aNHS5ydAsjNzeWrr75i+/bt3HPPPQAUFhZiGAY+Pj58+OGHdOjQocRx/v7++Pv7l9ju6+tr+huKc9RSOtNarFa47TYK69XlnnuvZs6BJdxZ+06e7PCkXptSqOX8PKnHE1rMfn4RERF3c/oQ5efnR1RUFJmZmfTp06doe2ZmJr169Sqxf3BwMDt37iy2LT09nU8++YSVK1cSGRnp7ESpiN55BwYN4kyrlvQf7MVa2wcs7bOUoJ8849JPERERESk7XHI5X2pqKsOGDSM6OpqYmBjmzZtHVlYWSUlJwNlL8Q4ePMjixYvx8vKiSZMmxY6/8sorCQgIKLFd5JLMnQvJyZzu1Z1bOu5n928/sm7IOtqEtyHjpwyz60RERESkjHHJEDVw4ECys7OZNm0aNpuNJk2akJGRQd26Z5eNttlsf3vPKJHLZhjwxBMweTInRg/j5sabOXX6DzaN2ETTWk21opiIiIiIXBKXLSyRnJxMcnJyqV9buHDhBY+dMmUKU6ZMcX6UVBwOB9xzD8yZw8GHk7mpxltc4VONz0Z8Qr0r6pldJyIiIiJlmMuGKBHTnD4NQ4bAmjV8Oz2VVsY8rq92PR8kfEBIUIjZdSIiIiJSxnmZHSDiVCdOQHw8ZGSw8cVxNLf/m7g6cXwy/BMNUCIiIiLiFBqipPw4dAjatoWdO3lj5mhu+fUFEm5IYM2gNVTyq2R2nYiIiIiUExqipHz47juIicH47Teee6YXCbaXmNB6Aq/1eg1fb93DRkREREScR5+JkrLviy+ge3cKQ69k3LiGvHRoETO7zuS+lveZXSYiIiIi5ZCGKCnb1q6F/v1xNLuRgcMCeffw+7zR7w0GNhlodpmIiIiIlFMaoqTsWrQIEhPJ79qJjt2O8d/fvmXd0HV0iOxgdpmIiIiIlGMaoqTsMQx47jl4+GFyhg2gxU3bOHn6dzaN3ESzWs3MrhMRERGRck5DlJQthYVw//2QloZt3GiaXbWGqt5XsPWOrURWizS7TkREREQqAA1RUnYUFMCIEbB8Od9NvZebfV+j0RWN+CDhA2pWqml2nYiIiIhUEFriXMqG3Fzo3h1WrWLz8yncaJlD64jWfHLHJxqgRERERMStNESJ5ztyBG65Bb78kpUv3klcbhqDmgzivcHvUdmvstl1IiIiIlLBaIgSz7ZvH7RujXHoEGnP9OX2Yy/zUOxDLOy9UDfRFRERERFTaIgSz/X11xAbi+Fl4YEpMYw/spAX41/kmc7P4GXRf7oiIiIiYg4tLCGe6eOPoXdvHA0bkDAymLePnr2J7qAmg8wuExEREZEKTkOUeJ7ly2H4cArataFzz5N8ffI/ZAzJoFP9TmaXiYiIiIhoiBLzOQodWLOs2HJtRK/cyrXTXuLUgN60iPmG7PwcNo7YyE1hN5mdKSIiIiICaIgSk63evZqUdSkcOHmApz6GwZshvV0Qjzb7lOpeIWwdtZWrq19tdqaIiIiISBENUWKa1btX0//N/ng7DBa8ByN3QGoXeDE2Dwrgha4vaoASEREREY+jJc7EFI5CBynrUggoMHh7OQz9LwzpCy/Gnv26BQuTN0zGUegwN1RERERE5C80RIkprFlW8g4f4OPFcMvP0D0Blt34v68bGOzP2Y81y2pao4iIiIhIaVw2RKWnpxMZGUlAQABRUVFYred/M7x582Zat25NjRo1CAwMpGHDhrz44ouuShMPcHLvTjYvgKt/hfYjIPOa0vez5drc2iUiIiIi8ndc8pmoFStWMG7cONLT02ndujVz586lW7du7Nq1izp16pTYv1KlStxzzz3ceOONVKpUic2bNzNmzBgqVarEXXfd5YpEMdPOnXQdPo2DZ6B1IvxQ4/y7hlUJc1+XiIiIiMg/4JIzUTNmzCAxMZHRo0fTqFEj0tLSiIiIYPbs2aXu37x5cwYPHkzjxo2pV68eQ4cOJT4+/oJnr6Rsqv7tt/h06ID3lbVof5ffeQcoCxYigiOIqxPn3kARERERkb/h9DNRBQUFbNu2jQkTJhTb3qVLF7Zu3fqPvsf27dvZunUrTz755Hn3yc/PJz8/v+hxTk4OAHa7HbvdfgnlznPu+c3u+HODJ7QUrl5N7JQpnG4RRed+pziW5w1nzg5MBkbRfhYsADzf6XkKHYUUOgpd0uNJr41aSudJLeBZPZ7YIiIiUlFYDMMw/n63f+7QoUPUrl2bLVu2EBsbW7T9qaeeYtGiRezZs+e8x4aHh3Ps2DHOnDnDlClTeOyxx86775QpU5g6dWqJ7cuWLSMoKOjyfghxurrr19N07lz2tWhK+1sPkOft4PH6j2PLt/HqwVfJtmcX7RviG0Ji7URirogxsVhE/qm8vDwSEhI4efIkwcHBZueIiIi4nMvuE2WxWIo9NgyjxLa/slqtnDp1is8//5wJEyZwzTXXMHjw4FL3nThxIqmpqUWPc3JyiIiIoH379tSocYEP2biB3W4nMzOTzp074+vrW7FbDAOvf/0L79mzOTC0N9HXfsRV1SLYMOg96lQ9+/m4KYVT2Lx/M7ZTNsIqh9Emog3eXt4uTzP9tVFLmWrxtB5Pajl3JYCIiEhF4fQhKiQkBG9vbw4fPlxs+9GjRwkNDb3gsZGRkQDccMMNHDlyhClTppx3iPL398ff37/Edl9fX9PfUJxT4VscDrjnHpgzh93jhnJTjbeIDKjPp8M/JTT4f/8t+OJLp2s6ubftTyr879N5qOX8PKnHE1rMfn4RERF3c/rCEn5+fkRFRZGZmVlse2ZmZrHL+/6OYRjFPvMkZczp0zBgALzyChseG0aTasvoek03pl49leqB1c2uExERERG5ZC65nC81NZVhw4YRHR1NTEwM8+bNIysri6SkJODspXgHDx5k8eLFALz88svUqVOHhg0bAmfvG/X8889z7733uiJPXO3ECejVC+PLL1k6pR/DHK9zT/Q9PNfxOdavW292nYiIiIjIZXHJEDVw4ECys7OZNm0aNpuNJk2akJGRQd26dQGw2WxkZWUV7V9YWMjEiRP56aef8PHx4eqrr+bpp59mzJgxrsgTVzp0CLp2xThwgKemdODR02/yTKdneDD2Qc6cOWN2nYiIiIjIZXPZwhLJyckkJyeX+rWFCxcWe3zvvffqrFN58N13EB9PYaGDuyc0ZkH+hyzuvZhhTYeZXSYiIiIi4jQuG6KkgvniC+jenTM1Q+g10p9Njh1kJGTQ+erOZpeJiIiIiDiVhii5fGvXQv/+/HFDI9r0yuag1wk2DdtE87DmZpeJiIiIiDid01fnkwpm0SK47TZ+axNNg56/cKqKH58lfqYBSkRERETKLQ1RcmkMA559FkaMYH/fTtRt8x9qh17DllFbiKwWaXadiIiIiIjLaIiSi1dYCKmp8PDD7LjzNiIbZ9L+2s58PPxjQoJCzK4TEREREXEpDVFycQoKYOhQjJkzyRjXg+a13yPxptGsGrCKIN8gs+tERERERFxOQ5T8c7m50L07xqpVvPJwJ7pf8T7TbpnGnB5z8PHSGiUiIiIiUjHona/8M0eOwK23YvzwA48+HM0zPp8w/7b5jGo+yuwyERERERG30hAlf2/fvrM30T2Vy4jx9Vjlt4N3b3+XW6+91ewyERERERG30xAlF/b119CtG/YqQXRNqsR/Kx3i04RPaVG7hdllIiIiIiKm0BAl5/fxx9C7N79fU5eWvY9xuloVPhv6GddUv8bsMhERERER02hhCSnd8uXQrRvHmzfkml6/EHhVHbYmbtUAJSIiIiIVnoYoKWnWLBg8mB+7tCCiw3aaXxvHp3d8ypWVrjS7TERERETEdBqi5H8MAyZOhJQUvhzclmuitjC4+XDWDFpDZb/KZteJiIiIiHgEDVFylt0Oo0bB00/z9ug2tGywiUntHmV+z/n4evuaXSciIiIi4jG0sIRAXh4MGICxfj2z7m1BashWZt86m6ToJLPLREREREQ8joaoii47G3r0wNi5kwfua0h69f+yut9qejXsZXaZiIiIiIhH0hBVkWVlQXw8juPHSBh7JR/VOMTHgz8mNiLW7DIREREREY+lIaqi2rkTunalwMdCx9E+7A8tZOvQrTQIaWB2mYiIiIiIR9PCEhWR1QpxcZyqGkiToTmcqhfGZ4mfaYASEREREfkHNERVNO+8A507c6RBOJF9s6jbsCUbR2wkrEqY2WUiIiIiImWCy4ao9PR0IiMjCQgIICoqCqvVet59V69eTefOnalZsybBwcHExMSwfv16V6VVXHPnQr9+7G3dkDpdviX+pgF8kPABwf7BZpeJiIiIiJQZLhmiVqxYwbhx45g0aRLbt28nLi6Obt26kZWVVer+mzZtonPnzmRkZLBt2zbat2/Pbbfdxvbt212RV/EYBl5PPglJSWzucSON2vwf49o+xOI+i/Hz9jO7TkRERESkTHHJwhIzZswgMTGR0aNHA5CWlsb69euZPXs206dPL7F/WlpascdPPfUUa9as4b333qN58+auSKw4HA5unDsX73XrWDH4RgZft4O0bjO5r+V9ZpeJiIiIiJRJTh+iCgoK2LZtGxMmTCi2vUuXLmzduvUffY/CwkJyc3OpXr36effJz88nPz+/6HFOTg4Adrsdu91+CeXOc+75ze7g9Gksw4ZR98MPeWbkdUyuv4dlPd+gX6N+prR5zOvy/3lSj1pK50kt4Fk9ntgiIiJSUVgMwzCc+Q0PHTpE7dq12bJlC7Gx/7vf0FNPPcWiRYvYs2fP336P5557jqeffprdu3dz5ZVXlrrPlClTmDp1aonty5YtIygo6NJ/gHLC59QpWk6fzhV795I0uBrLr/2dRyIfoXHlxmaniUg5k5eXR0JCAidPniQ4WJ+xFBGR8s9l94myWCzFHhuGUWJbad544w2mTJnCmjVrzjtAAUycOJHU1NSixzk5OURERNC+fXtq1Khx6eFOYLfbyczMpHPnzvj6+ro/4NAhfHr0wHFwP7cnVcNay8GGoRtoGtbU/S1/Yvrr4sE9avH8Fk/r8aSWc1cCiIiIVBROH6JCQkLw9vbm8OHDxbYfPXqU0NDQCx67YsUKEhMTeeutt+jUqdMF9/X398ff37/Edl9fX9PfUJxjSst330F8PPn209wyEnKvqckzNcfTNKxpxX5dLsCTetRSOk9qAc/q8YQWs59fRETE3Zy+Op+fnx9RUVFkZmYW256ZmVns8r6/euONNxgxYgTLli2je/fuzs6qGL74Atq0IcfXoPHQk/jf2JxPh31KiF+I2WUiIiIiIuWGSy7nS01NZdiwYURHRxMTE8O8efPIysoiKSkJOHsp3sGDB1m8eDFwdoAaPnw4M2fOpFWrVkVnsQIDA6lataorEsufjAy4/XZs19aiSfyPdIy+ncV9FuNteJtdJiIiIiJSrrjkPlEDBw4kLS2NadOm0axZMzZt2kRGRgZ169YFwGazFbtn1Ny5czlz5gxjx44lLCys6FdKSoor8sqfRYswevZkV9Pa1O/xI8Pbj2N5/+UE+ASYXSYiIiIiUu64bGGJ5ORkkpOTS/3awoULiz3esGGDqzLKN8OA556Dhx9mY6dr6BTzPc90fZ77Y+83u0xEREREpNxy2RAlLlZYCPffD2lpLO1dn5HNf+b1PssYfMNgs8tERERERMo1DVFlhKPQgTXLii3XxlX+IcRNXoBlxQqeGRzBUzccY92g9XSI7GB2poiIiIhIuachqgxYvXs1KetSOJBzgMr5sHoF2H+B5CHBrG12BusQK01rmXsPKBERERGRikJDlIdbvXs1/d/sj4HBlacgYylc8yvED4WNkTnMafesBigRERERETdyyep84hyOQgcp61IwMKj/K2yZD1flQtuRsDESLFj4l/VfOAodZqeKiIiIiFQYGqI8mDXLyoGcAzQ/BFvnQ6EFYhPhv7XOft3AYH/OfqxZVnNDRUREREQqEA1RHsyWa6PDj7BxIfxSFVonws/VSt9PRERERETcQ0OUB2u6YTdrl8CWCOhwBxyvVPp+YVXC3BsmIiIiIlKBaYjyVLNmcf19T7DyBi9uS4Df/UvuYsFCRHAEcXXi3N8nIiIiIlJBaYjyNIYBEydCSgqLOtfkzn5+nPE+OzD92bnHaV3T8PbyNqNURERERKRC0hDlSex2GDUKnn6aJ3pdwaSufnx+15esGrCK2sG1i+0aHhzOygEr6duor0mxIiIiIiIVk+4T5Sl+/x0GDKDww/UkDQzis3bhfD5kLeHB4dwQegO9GvTCmmXFlmsjrEoYcXXidAZKRERERMQEGqI8QXY2dO+O/b876D3Ewh/tW7J54NtUDahatIu3lze31LvFvEYREREREQF0OZ/5srIw2rQhb8+3xA7Np1rPgawbuq7YACUiIiIiIp5DQ5SZdu7EiIkh+8Qhmg47ReeBE3m9z+v4efuZXSYiIiIiIuehy/nMYrVi3HYbP18BrW/P5bEB6dx9891mV4mIiIiIyN/QEGWGd97BGDSIryP96d6/gHlD36Fng55mV4mIiIiIyD+gy/ncbe5cjH79WHe9L72G+7FmzAYNUCIiIiIiZYiGKHcxDJg6FZKSWBDjz7g7Qtkw5jNahrc0u0xERERERC6CLudzB4cDxo6FuXOZ0tmXdbffwOaE96lZqabZZSIiIiIicpE0RLna6dMwZAiFa97hrl4Wjg3qxif93iDIN8jsMhERERERuQQuu5wvPT2dyMhIAgICiIqKwmq1nndfm81GQkICDRo0wMvLi3Hjxrkqy71OnMCIj8f+/rv0GlCI/513s3rAag1QIiIiIiJlmEuGqBUrVjBu3DgmTZrE9u3biYuLo1u3bmRlZZW6f35+PjVr1mTSpEk0bdrUFUluF/Drr3h3aM/vX39Ou6FniBv7DC/d+hLeXt5mp4mIiIiIyGVwyeV8M2bMIDExkdGjRwOQlpbG+vXrmT17NtOnTy+xf7169Zg5cyYACxYs+EfPkZ+fT35+ftHjnJwcAOx2O3a7/XJ/hMty5ptvaPPQQxx35NJ5RCH3Jy5icOPBnDlzxu0t514Ls1+TPzd4Qgt4Vo9aSudJLeBZPZ7YIiIiUlFYDMMwnPkNCwoKCAoK4q233qJPnz5F21NSUtixYwcbN2684PG33HILzZo1Iy0t7YL7TZkyhalTp5bYvmzZMoKCzLtcrtrevbR4YhpZgfl0H+bNHc0mcUOVG0zrERFxtby8PBISEjh58iTBwcFm54iIiLic089EHT9+HIfDQWhoaLHtoaGhHD582GnPM3HiRFJTU4se5+TkEBERQfv27alRo4bTnudiWNauxTL5cb6uVcjghMq8ced6ml3VzJSWc+x2O5mZmXTu3BlfX1+1eGiPWjy/xdN6PKnl3JUAIiIiFYXLVuezWCzFHhuGUWLb5fD398ff37/Edl9fX3PeUCxahJE4irXXeTF5TAMeuSqVZlc1M/3NzTmmvS6l8KQW8KwetZTOk1rAs3o8ocXs5xcREXE3py8sERISgre3d4mzTkePHi1xdqpcMAx49lkYMYIFzSDtwTjWjtpADT9zzoaJiIiIiIhrOX2I8vPzIyoqiszMzGLbMzMziY2NdfbTmauwEGP8eHj4Yaa1hQ2PDOb94euoGlDV7DIREREREXERl1zOl5qayrBhw4iOjiYmJoZ58+aRlZVFUlIScPbzTAcPHmTx4sVFx+zYsQOAU6dOcezYMXbs2IGfnx/XX3+9KxIvX0EBhXfcASuWM/ZWqJb6CIs7PInFYsFeqJWqRERERETKK5cMUQMHDiQ7O5tp06Zhs9lo0qQJGRkZ1K1bFzh7c92/3jOqefPmRf9727ZtLFu2jLp16/Lzzz+7IvGiOAodWLOs2HJthFUJI65aM+jXj8KNGxhyu4WOD85mTPQYszNFRERERMQNXLawRHJyMsnJyaV+beHChSW2OXmldadZvXs1KetSOJBzAIArT0HmG75EZju4/Q5f7nloJT2u62FypYiIiIiIuIvLhqjyYPXu1fR/sz8GZwe8+r/C+tehkt1OmxGQMGSqBigRERERkQrG6QtLlBeOQgcp61KKBqjmh2DrfCi0QGwi7Kxl4eX/vIyj0GFyqYiIiIiIuJOGqPOwZlmLLuHr8CNsXAi/VIXWifBzNTAw2J+zH2uW1dxQERERERFxKw1R52HLtQEwcCesXQJbIqDDHXC8Uun7iYiIiIhIxaAh6jzCqoRx7+ewfBWsaAK3JcDv/qXvJyIiIiIiFYcWliiNYRCb/j63rIPnYuHhTmD8Zdy0YCE8OJy4OnHmNIqIiIiIiCk0RP2V3c7pUXcQsOQNHoz34vmYQixYgP8twX72MaR1TcPby9ukUBERERERMYMu5/uz338nr3sXvJe9QdKgyvR9ZTOrBqyidnDtYruFB4ezcsBK+jbqa1KoiIiIiIiYRWeizsnO5lTndli+/Za7xlzFpCc3ck31awDo1aAX1iwrtlwbYVXCiKsTpzNQIiIiIiIVlIYogKwsctu35o8jB5j40A08N/ETQoJCir7s7eXNLfVuMa9PREREREQ8hoaonTs51TGOY/aTzPhXF15KfodA30Czq0RERERExENV6M9EFW7ayB8xN/OD10len53ErPvWaoASEREREZELqjBnohyFjmKfa2r5HxveQ4byWXghP7z6LJM7PGh2ooiIiIiIlAEVYohavXs1KetSOJBzAIC7voK4D+Dt670IeGMld93Qz+RCEREREREpK8r95Xyrd6+m/5v9zw5QBjy+Aea+D+k3w8B+hRT4WMxOFBERERGRMqRcD1GOQgcp61IwMPAqhNnvw9QN8EgHuK8bGF4Wxq0bh6PQYXaqiIiIiIiUEeV6iLJmWTmQcwB/O7z5Foz+Gkb1hOltAQsYGOzP2Y81y2p2qoiIiIiIlBHl7jNRjkIHG37egC3Xxq5ju6j6B6xZDi0OQp9B8H6DksfYcm3uDxURERERkTKp3A1RzV5phs1+digKy4FNSyA8BzoOh8/qlH5MWJUwNxaKiIiIiEhZVu6GKFuuDQKgwTFYvwS8DGgzCnZfWXJfCxbCg8OJqxPn/lARERERESmTyuVnolocgM0L4JQfxCSef4ACSOuahreXt5sLRURERESkrHLZEJWenk5kZCQBAQFERUVhtV548YaNGzcSFRVFQEAA9evXZ86cOZf0vJ32wSeL4LsQiBsJB6uWvl94cDgrB6ykb6O+l/Q8IiIiIiJSMbnkcr4VK1Ywbtw40tPTad26NXPnzqVbt27s2rWLOnVKfjDpp59+4tZbb+XOO+9kyZIlbNmyheTkZGrWrEm/fhd3I9wVb8FHDWBQfzjtW/xrj8Y9yvU1ryesShhxdeJ0BkpERERERC6aS4aoGTNmkJiYyOjRowFIS0tj/fr1zJ49m+nTp5fYf86cOdSpU4e0tDQAGjVqxFdffcXzzz9/3iEqPz+f/Pz8oscnT54E4NUmMPFWKHQAf7n9U3S1aNpc1QaAE7+duLwf8gLsdjt5eXlkZ2fj6+v79we4kFrKRo9aPL/F03o8qSU3NxcAwzBM7RAREXEXpw9RBQUFbNu2jQkTJhTb3qVLF7Zu3VrqMZ999hldunQpti0+Pp758+djt9tLfYMwffp0pk6dWmL7w98A35Te1vvp3v/oZxARkYuXm5tL1arnuYZaRESkHHH6EHX8+HEcDgehoaHFtoeGhnL48OFSjzl8+HCp+585c4bjx48TFlZyCfKJEyeSmppa9PjEiRPUrVuXrKws0/8Sz8nJISIigv379xMcHKwWD2zxtB61eH6Lp/V4UothGOTm5nLVVVeZ2iEiIuIuLlvi3GKxFHtsGEaJbX+3f2nbz/H398ff37/E9qpVq5r+huKc4OBgtZTCk1rAs3rUUjpPagHP6vGUFrP/8UpERMSdnL46X0hICN7e3iXOOh09erTE2aZzatWqVer+Pj4+1KhRw9mJIiIiIiIil8zpQ5Sfnx9RUVFkZmYW256ZmUlsbGypx8TExJTY/8MPPyQ6Otr0D0yLiIiIiIj8mUvuE5Wamsqrr77KggUL2L17N+PHjycrK4ukpCTg7OeZhg8fXrR/UlISv/zyC6mpqezevZsFCxYwf/58HnjggX/8nP7+/kyePLnUS/zcTS2e3wKe1aMWz28Bz+rxpBYREZGKxmK4aE3a9PR0nn32WWw2G02aNOHFF1+kbdu2AIwYMYKff/6ZDRs2FO2/ceNGxo8fz7fffstVV13Fww8/XDR0iYiIiIiIeAqXDVEiIiIiIiLlkUsu5xMRERERESmvNESJiIiIiIhcBA1RIiIiIiIiF0FDlIiIiIiIyEUoU0NUeno6kZGRBAQEEBUVhdVqveD+GzduJCoqioCAAOrXr8+cOXNMabHZbCQkJNCgQQO8vLwYN26c0zoutmX16tV07tyZmjVrEhwcTExMDOvXrzelZfPmzbRu3ZoaNWoQGBhIw4YNefHFF01p+bMtW7bg4+NDs2bNnNZysT0bNmzAYrGU+PXdd9+5vQUgPz+fSZMmUbduXfz9/bn66qtZsGCB21tGjBhR6uvSuHFjt7cALF26lKZNmxIUFERYWBgjR44kOzvbKS2X0vPyyy/TqFEjAgMDadCgAYsXL3Zai4iIiPyJUUYsX77c8PX1NV555RVj165dRkpKilGpUiXjl19+KXX/H3/80QgKCjJSUlKMXbt2Ga+88orh6+trrFy50u0tP/30k3HfffcZixYtMpo1a2akpKRcdsOltqSkpBjPPPOM8eWXXxp79+41Jk6caPj6+hpff/2121u+/vprY9myZcY333xj/PTTT8brr79uBAUFGXPnznV7yzknTpww6tevb3Tp0sVo2rTpZXdcas+nn35qAMaePXsMm81W9OvMmTNubzEMw+jZs6fRsmVLIzMz0/jpp5+ML774wtiyZYvbW06cOFHs9di/f79RvXp1Y/LkyW5vsVqthpeXlzFz5kzjxx9/NKxWq9G4cWOjd+/el91yKT3p6elGlSpVjOXLlxv79u0z3njjDaNy5crGu+++65QeERER+Z8yM0S1aNHCSEpKKratYcOGxoQJE0rd/6GHHjIaNmxYbNuYMWOMVq1aub3lz9q1a+fUIepyWs65/vrrjalTp3pES58+fYyhQ4ea1jJw4EDj0UcfNSZPnuzUIepie84NUb/99pvTGi61Ze3atUbVqlWN7Oxs01v+6u233zYsFovx888/u73lueeeM+rXr19s26xZs4zw8PDLbrmUnpiYGOOBBx4oti0lJcVo3bq1U3pERETkf8rE5XwFBQVs27aNLl26FNvepUsXtm7dWuoxn332WYn94+Pj+eqrr7Db7W5tcRVntBQWFpKbm0v16tVNb9m+fTtbt26lXbt2prS89tpr7Nu3j8mTJ1/W8zurB6B58+aEhYXRsWNHPv30U1Na3n33XaKjo3n22WepXbs21113HQ888AB//PGH21v+av78+XTq1Im6deu6vSU2NpYDBw6QkZGBYRgcOXKElStX0r1798tqudSe/Px8AgICim0LDAzkyy+/vKw/80RERKSkMjFEHT9+HIfDQWhoaLHtoaGhHD58uNRjDh8+XOr+Z86c4fjx425tcRVntLzwwgv8/vvvDBgwwLSW8PBw/P39iY6OZuzYsYwePdrtLd9//z0TJkxg6dKl+Pj4XNbzO6MnLCyMefPmsWrVKlavXk2DBg3o2LEjmzZtcnvLjz/+yObNm/nmm294++23SUtLY+XKlYwdO9btLX9ms9lYu3btZf/3cqktsbGxLF26lIEDB+Ln50etWrW44oor+Pe//21KT3x8PK+++irbtm3DMAy++uorFixYgN1uv6w/80RERKQk575bdDGLxVLssWEYJbb93f6lbXdHiytdassbb7zBlClTWLNmDVdeeaVpLVarlVOnTvH5558zYcIErrnmGgYPHuy2FofDQUJCAlOnTuW666677Oe93B6ABg0a0KBBg6LHMTEx7N+/n+eff562bdu6taWwsBCLxcLSpUupWrUqADNmzKB///68/PLLBAYGuq3lzxYuXMgVV1xB7969L+v5L7Vl165d3HfffTz++OPEx8djs9l48MEHSUpKYv78+W7veeyxxzh8+DCtWrXCMAxCQ0MZMWIEzz77LN7e3k7pERERkbPKxJmokJAQvL29S/wL7NGjR0v8S+05tWrVKnV/Hx8fatSo4dYWV7mclhUrVpCYmMibb75Jp06dTG2JjIzkhhtu4M4772T8+PFMmTLFrS25ubl89dVX3HPPPfj4+ODj48O0adP4v//7P3x8fPjkk0/c2nM+rVq14vvvv3d7S1hYGLVr1y4aoAAaNWqEYRgcOHDArS3nGIbBggULGDZsGH5+fpfccDkt06dPp3Xr1jz44IPceOONxMfHk56ezoIFC7DZbG7vCQwMZMGCBeTl5fHzzz+TlZVFvXr1qFKlCiEhIZfVIyIiIsWViSHKz8+PqKgoMjMzi23PzMwkNja21GNiYmJK7P/hhx8SHR2Nr6+vW1tc5VJb3njjDUaMGMGyZcuc8vmNy2n5K8MwyM/Pd2tLcHAwO3fuZMeOHUW/kpKSaNCgATt27KBly5Zu7Tmf7du3ExYW5vaW1q1bc+jQIU6dOlW0be/evXh5eREeHu7WlnM2btzIDz/8QGJi4iU//+W25OXl4eVV/I/Qc2d8zp31dmfPOb6+voSHh+Pt7c3y5cvp0aNHiU4RERG5TO5eyeJSnVvud/78+cauXbuMcePGGZUqVSpalWvChAnGsGHDivY/t8T5+PHjjV27dhnz5893+hLn/7TFMAxj+/btxvbt242oqCgjISHB2L59u/Htt9+6vWXZsmWGj4+P8fLLLxdbKvrEiRNub3nppZeMd99919i7d6+xd+9eY8GCBUZwcLAxadIkt7f8lbNX57vYnhdffNF4++23jb179xrffPONMWHCBAMwVq1a5faW3NxcIzw83Ojfv7/x7bffGhs3bjSuvfZaY/To0W5vOWfo0KFGy5YtL/v5L6fltddeM3x8fIz09HRj3759xubNm43o6GijRYsWpvTs2bPHeP311429e/caX3zxhTFw4ECjevXqxk8//eSUHhEREfmfMjNEGYZhvPzyy0bdunUNPz8/46abbjI2btxY9LU77rjDaNeuXbH9N2zYYDRv3tzw8/Mz6tWrZ8yePdu0FqDEr7p167q9pV27dqW23HHHHW5vmTVrltG4cWMjKCjICA4ONpo3b26kp6cbDofD7S1/5ewh6mJ7nnnmGePqq682AgICjGrVqhlt2rQxPvjgA1NaDMMwdu/ebXTq1MkIDAw0wsPDjdTUVCMvL8+UlhMnThiBgYHGvHnznPL8l9Mya9Ys4/rrrzcCAwONsLAwY8iQIcaBAwdM6dm1a5fRrFkzIzAw0AgODjZ69eplfPfdd05rERERkf+xGMZlXnciIiIiIiJSgehCeRERERERkYugIUpEREREROQiaIgSERERERG5CBqiRERERERELoKGKBERERERkYugIUpEREREROQiaIgSERERERG5CBqiRERERERELoKGKBERERERkYugIUpEREREROQiaIgSERERERG5CP8PyhH4vuTdIccAAAAASUVORK5CYII=", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "hsm.extract(seq_map['Observation'],1,1).plot(Title=\"Observation distribution for state 1\")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Estimated emission distribution (state 1)" - ] - }, - { - "cell_type": "code", - "execution_count": 45, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "hsmc_est.extract(seq_map['Observation'],1,1).plot(Title=\"Observation distribution for state 1\")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "For the sake of comparison: associated true emission distribution" - ] - }, - { - "cell_type": "code", - "execution_count": 46, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "hsm.extract(seq_map['Observation'],1,0).plot(Title=\"Observation distribution for state 0\")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Estimated emission distribution (state 2)" - ] - }, - { - "cell_type": "code", - "execution_count": 47, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "hsmc_est.extract(seq_map['Observation'],1,2).plot(Title=\"Observation distribution for state 2\")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "For the sake of comparison: associated true emission distribution" - ] - }, - { - "cell_type": "code", - "execution_count": 48, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "hsm.extract(seq_map['Observation'],1,2).plot(Title=\"Observation distribution for state 2\")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# State restoration: Viterbi algorithm" - ] - }, - { - "cell_type": "code", - "execution_count": 49, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "N.o. initial states in parallel: 0\n" - ] - } - ], - "source": [ - "restored = hsmc_est.state_sequence_computation(obs, True)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Percentages of correct restoration per state value" - ] - }, - { - "cell_type": "code", - "execution_count": 50, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "(1.0, 1.0, 0.999587118084228)\n" - ] - } - ], - "source": [ - "# number of values in state 0\n", - "v0 = len([i for s in range(len(seq)) for i in range(len(seq[s])) if seq[s][i][0] == 0])\n", - "# number of values in state 0 with restored state 1\n", - "m0 = len([i for s in range(len(seq)) for i in range(len(seq[s])) if seq[s][i][0] == 0 and restored[s][i][0] == 1])\n", - "# number of values in state 1\n", - "v1 = len([i for s in range(len(seq)) for i in range(len(seq[s])) if seq[s][i][0] == 1])\n", - "# number of values in state 0 with restored state 1\n", - "m1 = len([i for s in range(len(seq)) for i in range(len(seq[s])) if seq[s][i][0] == 1 and restored[s][i][0] == 0])\n", - "# number of values in state 2\n", - "v2 = len([i for s in range(len(seq)) for i in range(len(seq[s])) if seq[s][i][0] == 2])\n", - "# number of values in state 2 with restored state 2\n", - "m2 = len([i for s in range(len(seq)) for i in range(len(seq[s])) if seq[s][i][0] == 2 and restored[s][i][0] == 2])\n", - "print((m0/v0, m1/v1, m2/v2))\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.13.9" - } - }, - "nbformat": 4, - "nbformat_minor": 4 -} diff --git a/tutorials/sequences.ipynb b/tutorials/sequences.ipynb deleted file mode 100755 index 3288d23..0000000 --- a/tutorials/sequences.ipynb +++ /dev/null @@ -1,1070 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [], - "source": [ - "#!/usr/bin/python3.10" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Prerequisites: pandas, xlrd, matplotlib, rpy2" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# HSMC modelling" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Configuration\n", - "### It is assumed that this notebook is run from StructureAnalysis/sequence_analysis/tutorials" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [], - "source": [ - "import numpy as np\n", - "from openalea.sequence_analysis import Estimate\n", - "from openalea.sequence_analysis import Plot\n", - "import os\n", - "import pandas as pd\n", - "# import random\n", - "import matplotlib.pyplot as plt" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "##### Check pandas version" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [], - "source": [ - "# print pd.__version__" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "'2.0.1'" - ] - }, - "execution_count": 4, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "import xlrd\n", - "xlrd.__version__" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "##### Enabling R extensions" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [], - "source": [ - "%load_ext rpy2.ipython" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "##### Place variables in markdown outputs" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [], - "source": [ - "from IPython.display import Markdown\n", - "from IPython.core.magic import register_cell_magic\n", - "\n", - "\n", - "@register_cell_magic\n", - "def markdown(line, cell):\n", - " return Markdown(cell.format(**globals()))" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Determining if images have to be saved (not used for the moment)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Loading and preparing data" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [], - "source": [ - "import sys, os" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "['/home/jdurand/usr/local/openalea',\n", - " '/home/jdurand/mambaforge/envs/openalea/lib/python310.zip',\n", - " '/home/jdurand/mambaforge/envs/openalea/lib/python3.10',\n", - " '/home/jdurand/mambaforge/envs/openalea/lib/python3.10/lib-dynload',\n", - " '',\n", - " '/home/jdurand/.local/lib/python3.10/site-packages',\n", - " '/home/jdurand/mambaforge/envs/openalea/lib/python3.10/site-packages',\n", - " '/home/jdurand/mambaforge/envs/openalea/lib/python3.10/site-packages/OpenAlea.SConsX-2.4.0-py3.9.egg',\n", - " '/home/jdurand/mambaforge/envs/openalea/lib/python3.10/site-packages/OpenAlea.StatTool-2.0.0-py3.10-linux-x86_64.egg',\n", - " '/home/jdurand/mambaforge/envs/openalea/lib/python3.10/site-packages/OpenAlea.SequenceAnalysis-2.0.0-py3.10-linux-x86_64.egg',\n", - " '/home/jdurand/mambaforge/envs/openalea/lib/python3.10/site-packages/openalea.deploy-3.1.2-py3.10.egg']" - ] - }, - "execution_count": 8, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "sys.path" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": {}, - "outputs": [], - "source": [ - "sys.path.append(\"..\" + os.sep + \"tutorials\")" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": {}, - "outputs": [], - "source": [ - "from openalea.seqint import model" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": {}, - "outputs": [], - "source": [ - "import graphviz" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "metadata": {}, - "outputs": [], - "source": [ - "import numpy as np\n", - "\n", - "from Utils import *\n", - "from Code.amlseq2R import *" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "/home/jdurand/devlp/Git/openalea/StructureAnalysis/sequence_analysis/tutorials\n" - ] - } - ], - "source": [ - "print(os.getcwd())" - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "metadata": {}, - "outputs": [], - "source": [ - "home_dir = \"./\"\n", - "base_path = home_dir\n", - "ressource_path = base_path\n", - "os.chdir(base_path)" - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "['seq1v_5s_LR_init.hsmc',\n", - " 'sim_v_5s_LR.hsmc',\n", - " 'Code',\n", - " 'Utils',\n", - " 'sequences.ipynb',\n", - " '.ipynb_checkpoints']" - ] - }, - "execution_count": 15, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "os.listdir(ressource_path + os.sep )" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "**Read an existing HSMC model**" - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "metadata": {}, - "outputs": [], - "source": [ - "from openalea.sequence_analysis import HiddenSemiMarkov\n", - "\n", - "model_file = \"sim_v_5s_LR.hsmc\"\n", - "#model_file = \"init_v_5s_LR.hsmc\"\n", - "hmsc = HiddenSemiMarkov(ressource_path + os.sep + model_file)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "**Simulate sequences**" - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "metadata": {}, - "outputs": [], - "source": [ - "from openalea.sequence_analysis import Simulate" - ] - }, - { - "cell_type": "code", - "execution_count": 18, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "N.o. initial states in parallel: 1\n" - ] - } - ], - "source": [ - "nb_seq = 10\n", - "seq_length = 100\n", - "seq = hmsc.simulation_nb_sequences(nb_seq, seq_length, True)" - ] - }, - { - "cell_type": "code", - "execution_count": 19, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[[0, 4, 0, 0], [0, 0, 0, 0], [0, 4, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0], [0, 4, 0, 0], [0, 1, 0, 0], [0, 0, 0, 0], [1, 1, 0, 1], [1, 1, 0, 1], [1, 1, 0, 0], [1, 1, 0, 0], [1, 1, 0, 1], [1, 1, 0, 1], [1, 1, 0, 1], [1, 1, 0, 0], [1, 2, 0, 1], [1, 1, 0, 1], [1, 1, 0, 1], [1, 1, 0, 1], [1, 1, 0, 0], [1, 1, 0, 1], [4, 3, 1, 1], [4, 0, 0, 1], [4, 3, 1, 0], [4, 2, 3, 1], [4, 2, 3, 1], [4, 3, 0, 1], [4, 2, 1, 1], [4, 3, 0, 1], [4, 2, 3, 1], [4, 3, 3, 1], [4, 3, 1, 1], [4, 3, 2, 1], [4, 3, 2, 0], [4, 3, 3, 1], [4, 2, 0, 1], [4, 1, 3, 1], [4, 3, 3, 1], [4, 3, 3, 0], [4, 1, 0, 1], [4, 3, 0, 1], [4, 0, 2, 0], [4, 3, 2, 1], [4, 3, 0, 1], [4, 3, 0, 1], [4, 2, 2, 1], [4, 3, 2, 1], [4, 3, 2, 1], [4, 3, 0, 1], [4, 3, 0, 1], [4, 3, 3, 1], [4, 2, 0, 0], [4, 2, 3, 1], [4, 3, 2, 1], [4, 3, 0, 1], [4, 3, 2, 1], [4, 3, 1, 0], [4, 2, 3, 1], [4, 3, 1, 1], [4, 2, 3, 1], [4, 3, 2, 1], [4, 3, 3, 1], [4, 3, 3, 1], [4, 1, 3, 0], [4, 3, 2, 1], [4, 3, 0, 1], [4, 2, 2, 1], [4, 2, 3, 1], [4, 3, 2, 0], [4, 2, 3, 0], [4, 0, 3, 1], [4, 3, 0, 1], [4, 3, 3, 1], [4, 2, 3, 0], [4, 3, 3, 1], [4, 3, 3, 1], [4, 3, 0, 0], [4, 3, 2, 1], [4, 3, 0, 1], [4, 3, 2, 1], [4, 3, 2, 0], [4, 3, 2, 1], [4, 3, 0, 1], [4, 2, 2, 0], [4, 2, 0, 0], [4, 3, 3, 1], [4, 3, 2, 0], [4, 3, 0, 1], [4, 3, 2, 1], [4, 3, 3, 1], [4, 2, 3, 1], [4, 3, 0, 1], [4, 3, 0, 1], [4, 2, 1, 1], [4, 3, 3, 1], [4, 3, 2, 1], [4, 3, 0, 0], [4, 3, 2, 0], [4, 2, 0, 1]]\n" - ] - } - ], - "source": [ - "# Print first simulated sequence.\n", - "# First variable is the simulated state\n", - "print(seq[0])" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "**Perform operations on sequences**" - ] - }, - { - "cell_type": "code", - "execution_count": 20, - "metadata": {}, - "outputs": [], - "source": [ - "# Discard variable 1 (state)\n", - "obs = seq.select_variable([1], keep=False)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Plotting marginal probabilities of data" - ] - }, - { - "cell_type": "code", - "execution_count": 21, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/jdurand/mambaforge/envs/openalea/lib/python3.10/site-packages/OpenAlea.StatTool-2.0.0-py3.10-linux-x86_64.egg/openalea/stat_tool/output.py:804: UserWarning: Cannot use new plotter. Use old style plot.\n", - " warnings.warn(\"Cannot use new plotter. Use old style plot.\")\n" - ] - }, - { - "ename": "ArgumentError", - "evalue": "Python argument types in\n _MarkovianSequences.plot_write(_MarkovianSequences, str, str, list)\ndid not match C++ signature:\n plot_write(sequence_analysis::MarkovianSequences, std::__cxx11::basic_string, std::allocator > prefix, std::__cxx11::basic_string, std::allocator > title)", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mArgumentError\u001b[0m Traceback (most recent call last)", - "Cell \u001b[0;32mIn[21], line 2\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[38;5;66;03m# Variable 1: lateral shoot type\u001b[39;00m\n\u001b[0;32m----> 2\u001b[0m \u001b[43mobs\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mplot\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mIntensity\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m0\u001b[39;49m\u001b[43m)\u001b[49m\n\u001b[1;32m 3\u001b[0m plt\u001b[38;5;241m.\u001b[39mshow()\n", - "File \u001b[0;32m~/mambaforge/envs/openalea/lib/python3.10/site-packages/OpenAlea.StatTool-2.0.0-py3.10-linux-x86_64.egg/openalea/stat_tool/output.py:813\u001b[0m, in \u001b[0;36mStatInterface.plot\u001b[0;34m(self, *args, **kargs)\u001b[0m\n\u001b[1;32m 811\u001b[0m plotter\u001b[38;5;241m.\u001b[39mplot(plotable, Title, groups, \u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkargs)\n\u001b[1;32m 812\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m--> 813\u001b[0m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mold_plot\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkargs\u001b[49m\u001b[43m)\u001b[49m\n", - "File \u001b[0;32m~/mambaforge/envs/openalea/lib/python3.10/site-packages/OpenAlea.StatTool-2.0.0-py3.10-linux-x86_64.egg/openalea/stat_tool/output.py:414\u001b[0m, in \u001b[0;36mStatInterface.old_plot\u001b[0;34m(self, *args, **kargs)\u001b[0m\n\u001b[1;32m 411\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mAttributeError\u001b[39;00m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;132;01m%s\u001b[39;00m\u001b[38;5;124m has not \u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124msegment_profile\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124m viewpoint\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m 412\u001b[0m \u001b[38;5;241m%\u001b[39m (\u001b[38;5;28mstr\u001b[39m(\u001b[38;5;28mtype\u001b[39m(\u001b[38;5;28mself\u001b[39m))))\n\u001b[1;32m 413\u001b[0m \u001b[38;5;28;01melif\u001b[39;00m(args):\n\u001b[0;32m--> 414\u001b[0m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mplot_write\u001b[49m\u001b[43m(\u001b[49m\u001b[43mprefix\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mtitle\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43mlist\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43margs\u001b[49m\u001b[43m)\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 415\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 416\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mplot_write(prefix, title)\n", - "\u001b[0;31mArgumentError\u001b[0m: Python argument types in\n _MarkovianSequences.plot_write(_MarkovianSequences, str, str, list)\ndid not match C++ signature:\n plot_write(sequence_analysis::MarkovianSequences, std::__cxx11::basic_string, std::allocator > prefix, std::__cxx11::basic_string, std::allocator > title)" - ] - } - ], - "source": [ - "# Variable 1: lateral shoot type\n", - "obs.plot(\"Intensity\", 0)\n", - "plt.show()" - ] - }, - { - "cell_type": "code", - "execution_count": 22, - "metadata": {}, - "outputs": [ - { - "ename": "ArgumentError", - "evalue": "Python argument types in\n _MarkovianSequences.plot_write(_MarkovianSequences, str, str, list)\ndid not match C++ signature:\n plot_write(sequence_analysis::MarkovianSequences, std::__cxx11::basic_string, std::allocator > prefix, std::__cxx11::basic_string, std::allocator > title)", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mArgumentError\u001b[0m Traceback (most recent call last)", - "Cell \u001b[0;32mIn[22], line 2\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[38;5;66;03m# Variable 2: lateral flowering\u001b[39;00m\n\u001b[0;32m----> 2\u001b[0m \u001b[43mobs\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mplot\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mIntensity\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m1\u001b[39;49m\u001b[43m)\u001b[49m\n\u001b[1;32m 3\u001b[0m plt\u001b[38;5;241m.\u001b[39mshow()\n", - "File \u001b[0;32m~/mambaforge/envs/openalea/lib/python3.10/site-packages/OpenAlea.StatTool-2.0.0-py3.10-linux-x86_64.egg/openalea/stat_tool/output.py:813\u001b[0m, in \u001b[0;36mStatInterface.plot\u001b[0;34m(self, *args, **kargs)\u001b[0m\n\u001b[1;32m 811\u001b[0m plotter\u001b[38;5;241m.\u001b[39mplot(plotable, Title, groups, \u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkargs)\n\u001b[1;32m 812\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m--> 813\u001b[0m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mold_plot\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkargs\u001b[49m\u001b[43m)\u001b[49m\n", - "File \u001b[0;32m~/mambaforge/envs/openalea/lib/python3.10/site-packages/OpenAlea.StatTool-2.0.0-py3.10-linux-x86_64.egg/openalea/stat_tool/output.py:414\u001b[0m, in \u001b[0;36mStatInterface.old_plot\u001b[0;34m(self, *args, **kargs)\u001b[0m\n\u001b[1;32m 411\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mAttributeError\u001b[39;00m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;132;01m%s\u001b[39;00m\u001b[38;5;124m has not \u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124msegment_profile\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124m viewpoint\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m 412\u001b[0m \u001b[38;5;241m%\u001b[39m (\u001b[38;5;28mstr\u001b[39m(\u001b[38;5;28mtype\u001b[39m(\u001b[38;5;28mself\u001b[39m))))\n\u001b[1;32m 413\u001b[0m \u001b[38;5;28;01melif\u001b[39;00m(args):\n\u001b[0;32m--> 414\u001b[0m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mplot_write\u001b[49m\u001b[43m(\u001b[49m\u001b[43mprefix\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mtitle\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43mlist\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43margs\u001b[49m\u001b[43m)\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 415\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 416\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mplot_write(prefix, title)\n", - "\u001b[0;31mArgumentError\u001b[0m: Python argument types in\n _MarkovianSequences.plot_write(_MarkovianSequences, str, str, list)\ndid not match C++ signature:\n plot_write(sequence_analysis::MarkovianSequences, std::__cxx11::basic_string, std::allocator > prefix, std::__cxx11::basic_string, std::allocator > title)" - ] - } - ], - "source": [ - "# Variable 2: lateral flowering\n", - "obs.plot(\"Intensity\", 1)\n", - "plt.show()" - ] - }, - { - "cell_type": "code", - "execution_count": 23, - "metadata": {}, - "outputs": [ - { - "ename": "ArgumentError", - "evalue": "Python argument types in\n _MarkovianSequences.plot_write(_MarkovianSequences, str, str, list)\ndid not match C++ signature:\n plot_write(sequence_analysis::MarkovianSequences, std::__cxx11::basic_string, std::allocator > prefix, std::__cxx11::basic_string, std::allocator > title)", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mArgumentError\u001b[0m Traceback (most recent call last)", - "Cell \u001b[0;32mIn[23], line 2\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[38;5;66;03m# Variable 3: terminal flowering\u001b[39;00m\n\u001b[0;32m----> 2\u001b[0m \u001b[43mobs\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mplot\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mIntensity\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m2\u001b[39;49m\u001b[43m)\u001b[49m\n\u001b[1;32m 3\u001b[0m plt\u001b[38;5;241m.\u001b[39mshow()\n", - "File \u001b[0;32m~/mambaforge/envs/openalea/lib/python3.10/site-packages/OpenAlea.StatTool-2.0.0-py3.10-linux-x86_64.egg/openalea/stat_tool/output.py:813\u001b[0m, in \u001b[0;36mStatInterface.plot\u001b[0;34m(self, *args, **kargs)\u001b[0m\n\u001b[1;32m 811\u001b[0m plotter\u001b[38;5;241m.\u001b[39mplot(plotable, Title, groups, \u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkargs)\n\u001b[1;32m 812\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m--> 813\u001b[0m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mold_plot\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkargs\u001b[49m\u001b[43m)\u001b[49m\n", - "File \u001b[0;32m~/mambaforge/envs/openalea/lib/python3.10/site-packages/OpenAlea.StatTool-2.0.0-py3.10-linux-x86_64.egg/openalea/stat_tool/output.py:414\u001b[0m, in \u001b[0;36mStatInterface.old_plot\u001b[0;34m(self, *args, **kargs)\u001b[0m\n\u001b[1;32m 411\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mAttributeError\u001b[39;00m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;132;01m%s\u001b[39;00m\u001b[38;5;124m has not \u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124msegment_profile\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124m viewpoint\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m 412\u001b[0m \u001b[38;5;241m%\u001b[39m (\u001b[38;5;28mstr\u001b[39m(\u001b[38;5;28mtype\u001b[39m(\u001b[38;5;28mself\u001b[39m))))\n\u001b[1;32m 413\u001b[0m \u001b[38;5;28;01melif\u001b[39;00m(args):\n\u001b[0;32m--> 414\u001b[0m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mplot_write\u001b[49m\u001b[43m(\u001b[49m\u001b[43mprefix\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mtitle\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43mlist\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43margs\u001b[49m\u001b[43m)\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 415\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 416\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mplot_write(prefix, title)\n", - "\u001b[0;31mArgumentError\u001b[0m: Python argument types in\n _MarkovianSequences.plot_write(_MarkovianSequences, str, str, list)\ndid not match C++ signature:\n plot_write(sequence_analysis::MarkovianSequences, std::__cxx11::basic_string, std::allocator > prefix, std::__cxx11::basic_string, std::allocator > title)" - ] - } - ], - "source": [ - "# Variable 3: terminal flowering\n", - "obs.plot(\"Intensity\", 2)\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## HSCM re-estimation" - ] - }, - { - "cell_type": "code", - "execution_count": 24, - "metadata": {}, - "outputs": [], - "source": [ - "# Discard state variable\n", - "seq1v = seq.select_variable([2, 3, 4], True)" - ] - }, - { - "cell_type": "code", - "execution_count": 25, - "metadata": {}, - "outputs": [], - "source": [ - "nb_states = 5\n", - "init_file = base_path + os.sep + \"seq1v_\" + str(nb_states) + \"s_LR_init.hsmc\"" - ] - }, - { - "cell_type": "code", - "execution_count": 26, - "metadata": {}, - "outputs": [], - "source": [ - "from openalea.sequence_analysis import Estimate\n", - "from openalea.sequence_analysis import HiddenSemiMarkov" - ] - }, - { - "cell_type": "code", - "execution_count": 27, - "metadata": {}, - "outputs": [], - "source": [ - "# Conversion dos2unix file if needed\n", - "try:\n", - " hmsc_init = HiddenSemiMarkov(init_file)\n", - "except:\n", - " dos2unix(init_file, init_file)\n", - "hmsc_init = HiddenSemiMarkov(init_file)\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Estimate HSCM with default initialization\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Left-right model" - ] - }, - { - "cell_type": "code", - "execution_count": 28, - "metadata": { - "scrolled": true - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0\n" - ] - }, - { - "ename": "ArgumentError", - "evalue": "Python argument types in\n _MarkovianSequences.hidden_semi_markov_estimation_model(_MarkovianSequences, str, int, bool, float, bool, EstimatorHSMType, bool, bool, int, ClusterType)\ndid not match C++ signature:\n hidden_semi_markov_estimation_model(sequence_analysis::MarkovianSequences, stat_tool::process_type, int, bool, double, bool, bool, stat_tool::censoring_estimator, bool, bool, int, stat_tool::duration_distribution_mean_estimator tobedone)", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mArgumentError\u001b[0m Traceback (most recent call last)", - "Cell \u001b[0;32mIn[28], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m hsmc1 \u001b[38;5;241m=\u001b[39m \u001b[43mEstimate\u001b[49m\u001b[43m(\u001b[49m\u001b[43mseq1v\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mHIDDEN_SEMI-MARKOV\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mOrdinary\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mnb_states\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mLeftRight\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mNbiteration\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;241;43m300\u001b[39;49m\u001b[43m)\u001b[49m \n\u001b[1;32m 2\u001b[0m \u001b[38;5;28mprint\u001b[39m(hsmc1)\n", - "File \u001b[0;32m~/mambaforge/envs/openalea/lib/python3.10/site-packages/OpenAlea.SequenceAnalysis-2.0.0-py3.10-linux-x86_64.egg/openalea/sequence_analysis/estimate.py:863\u001b[0m, in \u001b[0;36mEstimate\u001b[0;34m(obj, *args, **kargs)\u001b[0m\n\u001b[1;32m 645\u001b[0m \u001b[38;5;250m\u001b[39m\u001b[38;5;124;03m\"\"\"Estimate\u001b[39;00m\n\u001b[1;32m 646\u001b[0m \n\u001b[1;32m 647\u001b[0m \u001b[38;5;124;03m* Estimation of distributions.\u001b[39;00m\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 856\u001b[0m \n\u001b[1;32m 857\u001b[0m \u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[1;32m 859\u001b[0m \u001b[38;5;66;03m# top case (no type specified and args may be empty)\u001b[39;00m\n\u001b[1;32m 860\u001b[0m \u001b[38;5;66;03m#if isinstance(obj, _Tops):\u001b[39;00m\n\u001b[1;32m 861\u001b[0m \u001b[38;5;66;03m#return _estimate_top(obj, *args, **kargs)\u001b[39;00m\n\u001b[1;32m 862\u001b[0m \u001b[38;5;66;03m#else:\u001b[39;00m\n\u001b[0;32m--> 863\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43m_estimate_dispatch\u001b[49m\u001b[43m(\u001b[49m\u001b[43mobj\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkargs\u001b[49m\u001b[43m)\u001b[49m\n", - "File \u001b[0;32m~/mambaforge/envs/openalea/lib/python3.10/site-packages/OpenAlea.SequenceAnalysis-2.0.0-py3.10-linux-x86_64.egg/openalea/sequence_analysis/estimate.py:621\u001b[0m, in \u001b[0;36m_estimate_dispatch\u001b[0;34m(obj, *args, **kargs)\u001b[0m\n\u001b[1;32m 619\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m _estimate_hidden_variable_order_markov(obj, \u001b[38;5;241m*\u001b[39margs[\u001b[38;5;241m1\u001b[39m:], \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkargs)\n\u001b[1;32m 620\u001b[0m \u001b[38;5;28;01melif\u001b[39;00m itype \u001b[38;5;241m==\u001b[39m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mHIDDEN_SEMI-MARKOV\u001b[39m\u001b[38;5;124m\"\u001b[39m:\n\u001b[0;32m--> 621\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43m_estimate_hidden_semi_markov\u001b[49m\u001b[43m(\u001b[49m\u001b[43mobj\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;241;43m1\u001b[39;49m\u001b[43m:\u001b[49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 622\u001b[0m \u001b[38;5;28;01melif\u001b[39;00m itype \u001b[38;5;241m==\u001b[39m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mSEMI-MARKOV\u001b[39m\u001b[38;5;124m\"\u001b[39m:\n\u001b[1;32m 623\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m _estimate_semi_markov(obj, \u001b[38;5;241m*\u001b[39margs[\u001b[38;5;241m1\u001b[39m:], \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkargs)\n", - "File \u001b[0;32m~/mambaforge/envs/openalea/lib/python3.10/site-packages/OpenAlea.SequenceAnalysis-2.0.0-py3.10-linux-x86_64.egg/openalea/sequence_analysis/estimate.py:414\u001b[0m, in \u001b[0;36m_estimate_hidden_semi_markov\u001b[0;34m(obj, *args, **kargs)\u001b[0m\n\u001b[1;32m 411\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mValueError\u001b[39;00m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mIncompatible user arguments\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n\u001b[1;32m 413\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m Algorithm \u001b[38;5;241m==\u001b[39m NO_COMPUTATION:\n\u001b[0;32m--> 414\u001b[0m hsmarkov \u001b[38;5;241m=\u001b[39m \u001b[43mobj\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mhidden_semi_markov_estimation_model\u001b[49m\u001b[43m(\u001b[49m\u001b[43m \u001b[49m\u001b[43mType\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mNbState\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 415\u001b[0m \u001b[43m \u001b[49m\u001b[43mLeftRight\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mInitialOccupancyMean\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mCommonDispersion\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mEstimator\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 416\u001b[0m \u001b[43m \u001b[49m\u001b[43mCounting\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mStateSequence\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mNbIteration\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mMeanComputation\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 417\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m hsmarkov\n\u001b[1;32m 419\u001b[0m \u001b[38;5;28;01melif\u001b[39;00m Algorithm \u001b[38;5;241m==\u001b[39m FORWARD_BACKWARD_SAMPLING:\n", - "\u001b[0;31mArgumentError\u001b[0m: Python argument types in\n _MarkovianSequences.hidden_semi_markov_estimation_model(_MarkovianSequences, str, int, bool, float, bool, EstimatorHSMType, bool, bool, int, ClusterType)\ndid not match C++ signature:\n hidden_semi_markov_estimation_model(sequence_analysis::MarkovianSequences, stat_tool::process_type, int, bool, double, bool, bool, stat_tool::censoring_estimator, bool, bool, int, stat_tool::duration_distribution_mean_estimator tobedone)" - ] - } - ], - "source": [ - "hsmc1 = Estimate(seq1v, \"HIDDEN_SEMI-MARKOV\", \"Ordinary\", nb_states, \"LeftRight\", Nbiteration=300) \n", - "print(hsmc1)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Irreducible model" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Plot model and data characteristics. \n", - "Syntax: hsmc1.extract(int type, int variable, int value) \n", - "types correspond to SELF_TRANSITION , OBSERVATION , INTENSITY , FIRST_OCCURRENCE , RECURRENCE_TIME , SOJOURN_TIME , INITIAL_RUN , FINAL_RUN , NB_RUN , NB_OCCURRENCE , COUNTING , LENGTH , SEQUENCE_CUMUL , SEQUENCE_MEAN" - ] - }, - { - "cell_type": "code", - "execution_count": 29, - "metadata": {}, - "outputs": [ - { - "ename": "NameError", - "evalue": "name 'hsmc1' is not defined", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", - "Cell \u001b[0;32mIn[29], line 2\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[38;5;66;03m# Type 1: emission distribution, Variable 1: lateral shoot type, State 4\u001b[39;00m\n\u001b[0;32m----> 2\u001b[0m \u001b[43mhsmc1\u001b[49m\u001b[38;5;241m.\u001b[39mextract(\u001b[38;5;241m1\u001b[39m, \u001b[38;5;241m1\u001b[39m, \u001b[38;5;241m4\u001b[39m)\u001b[38;5;241m.\u001b[39mplot()\n\u001b[1;32m 3\u001b[0m plt\u001b[38;5;241m.\u001b[39mshow()\n", - "\u001b[0;31mNameError\u001b[0m: name 'hsmc1' is not defined" - ] - } - ], - "source": [ - "# Type 1: emission distribution, Variable 1: lateral shoot type, State 4\n", - "hsmc1.extract(1, 1, 4).plot()\n", - "plt.show()" - ] - }, - { - "cell_type": "code", - "execution_count": 30, - "metadata": {}, - "outputs": [], - "source": [ - "# hsmc1.extract(2, 1, 4).plot()" - ] - }, - { - "cell_type": "code", - "execution_count": 31, - "metadata": {}, - "outputs": [ - { - "ename": "NameError", - "evalue": "name 'hsmc1' is not defined", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", - "Cell \u001b[0;32mIn[31], line 5\u001b[0m\n\u001b[1;32m 3\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m i \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mrange\u001b[39m(\u001b[38;5;241m5\u001b[39m):\n\u001b[1;32m 4\u001b[0m plt\u001b[38;5;241m.\u001b[39msubplot(\u001b[38;5;241m3\u001b[39m,\u001b[38;5;241m3\u001b[39m, i\u001b[38;5;241m+\u001b[39m\u001b[38;5;241m1\u001b[39m)\n\u001b[0;32m----> 5\u001b[0m \u001b[43mhsmc1\u001b[49m\u001b[38;5;241m.\u001b[39mextract(\u001b[38;5;241m1\u001b[39m, \u001b[38;5;241m1\u001b[39m, i)\u001b[38;5;241m.\u001b[39mplot()\n", - "\u001b[0;31mNameError\u001b[0m: name 'hsmc1' is not defined" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# All emission distributions for variable 1\n", - "plt.figure(1)\n", - "for i in range(5):\n", - " plt.subplot(3,3, i+1)\n", - " hsmc1.extract(1, 1, i).plot()\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### TODO: states 3 and 4 are swapped?" - ] - }, - { - "cell_type": "code", - "execution_count": 32, - "metadata": {}, - "outputs": [ - { - "ename": "NameError", - "evalue": "name 'hsmc1' is not defined", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", - "Cell \u001b[0;32mIn[32], line 5\u001b[0m\n\u001b[1;32m 3\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m i \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mrange\u001b[39m(\u001b[38;5;241m5\u001b[39m):\n\u001b[1;32m 4\u001b[0m plt\u001b[38;5;241m.\u001b[39msubplot(\u001b[38;5;241m3\u001b[39m,\u001b[38;5;241m3\u001b[39m, i\u001b[38;5;241m+\u001b[39m\u001b[38;5;241m1\u001b[39m)\n\u001b[0;32m----> 5\u001b[0m \u001b[43mhsmc1\u001b[49m\u001b[38;5;241m.\u001b[39mextract(\u001b[38;5;241m1\u001b[39m, \u001b[38;5;241m2\u001b[39m, i)\u001b[38;5;241m.\u001b[39mplot()\n", - "\u001b[0;31mNameError\u001b[0m: name 'hsmc1' is not defined" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# All emission distributions for variable 2\n", - "plt.figure(1)\n", - "for i in range(5):\n", - " plt.subplot(3,3, i+1)\n", - " hsmc1.extract(1, 2, i).plot()" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "scrolled": true - }, - "outputs": [], - "source": [ - "print(Estimate(seq1v, \"HIDDEN_SEMI-MARKOV\", \"Ordinary\", nb_states, \"Irreducible\", Nbiteration=300)) \n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Discard state sequence computations (entropy, Viterbi?)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "print(Estimate(seq1v, \"HIDDEN_SEMI-MARKOV\", \"Ordinary\", nb_states, \"Irreducible\", Nbiteration=300, StateSequence=False))" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Using the MCEM option would cause the library to crash" - ] - }, - { - "cell_type": "raw", - "metadata": {}, - "source": [ - "print(Estimate(seq1v, \"HIDDEN_SEMI-MARKOV\", \"Ordinary\", nb_states, \"Irreducible\", Nbiteration=300, Algorithm=\"MCEM\", MinNbStateSequence=1, MaxNbStateSequence=10, Parameter=10))" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Using the Equilibrium option (stationary) would cause the library to crash" - ] - }, - { - "cell_type": "raw", - "metadata": { - "scrolled": true - }, - "source": [ - "print(Estimate(seq1v, \"HIDDEN_SEMI-MARKOV\", \"Equilibrium\", nb_states)) \n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Change option in means of initial occupancy distributions" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "print(Estimate(seq1v, \"HIDDEN_SEMI-MARKOV\", \"Ordinary\", nb_states, \"Irreducible\", Nbiteration=300, InitialOccupancyMean=20))" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Change option in estimating occupancy distributions (censoring, etc.?)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "print(Estimate(seq1v, \"HIDDEN_SEMI-MARKOV\", \"Ordinary\", nb_states, \"Irreducible\", Nbiteration=300, Estimator=\"KaplanMeier\"))" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Change option in state sequence restoration (Viterbi vs. smoothing)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "print(Estimate(seq1v, \"HIDDEN_SEMI-MARKOV\", \"Ordinary\", nb_states, \"Irreducible\", Nbiteration=300, StateSequences=\"ForwardBackward\"))" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Change option in estimating occupancy distributions" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "print(Estimate(seq1v, \"HIDDEN_SEMI-MARKOV\", \"Ordinary\", nb_states, \"Irreducible\", Nbiteration=300, OccupancyMean=\"Estimated\"))" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Other options in estimate" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "help(Estimate)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Estimate HSCM with manual initialization from file" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "scrolled": false - }, - "outputs": [], - "source": [ - "hsmc1 = Estimate(seq1v, \"HIDDEN_SEMI-MARKOV\", hmsc_init, NbIteration=300)\n", - "print(hsmc1)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Export states\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "from openalea.sequence_analysis import ExtractData\n", - "seg = ExtractData(hsmc1) # Data and segmentation" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# Restored states are added as the first variable to seq_1v, see\n", - "print(seg[0][0:10])\n", - "print(seq1v[0][0:10])" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "seg_dir = \"Results\"" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "if not os.path.exists(seg_dir): \n", - " # if the seg_dir directory is not present \n", - " # then create it. \n", - " os.makedirs(seg_dir) " - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# Export into file\n", - "\n", - "seg_file = \"seq1v_\" + str(nb_states) + \"s_LR_segm.seq\"\n", - "output_Rpyseq1_file = seg_dir + os.sep + seg_file[0:-4] + \".csv\"\n", - "WriteRSequence(seg, output_Rpyseq1_file, RestoredStatesHeader())" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Create DataFrame" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "df = pd.read_csv(output_Rpyseq1_file, index_col=0, comment=\"#\", usecols=range(6))\n", - "var_names = [' axillary shoot type',' lateral flowering', ' terminal flowering']\n", - "df = df[var_names]" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# Add sequence identifiers to DF\n", - "seqid = []\n", - "for i in range(len(seq1v)):\n", - " seqid += [i+1] * len(seq1v[i])\n", - "seqid\n", - "df[\"seqid\"] = seqid" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "from seqint.pyseq_data_frame import PySeqDataFrame\n", - "pyd = PySeqDataFrame(df, seq_index_name=\"seqid\")\n", - "pyd.seq_index_name\n", - "pyd.col_to_seq(var_names)\n", - "seqc = pyd.get_input_sequence(var_names)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "assert(str(seqc[0]) == str(seq1v[0]))" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Embed HSCM within Model class for automatic parameter visualization\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "output_path = base_path + os.sep + \"Results\" \n", - "model = Model(pyd, output_process_name=var_names, init_hsmc_file=init_file, output_path=output_path)\n", - "model.iterate_em(300)\n", - "model.hsmm.save(os.path.join(output_path, 'seq1v_' + str(nb_states) + 's_LR.hsmc'))\n", - "model.print_hsmc_file(verbose=False)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "from seqint import html_report\n", - "\n", - "output_path = \".\" + os.sep + \"tmp_dir\"\n", - "\n", - "if not os.path.exists(output_path):\n", - " os.mkdir(output_path)\n", - " \n", - "report = html_report.Htmlreport(model, output_path=output_path)\n", - "report.make_html(True)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "*Removing some garbage files*" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "report_prefix = report._html_report_file_path[0:-11]\n", - "report_prefix = report_prefix.split(\"/\")[2]\n", - "import glob\n", - "for f in glob.glob(\".\" +os.sep + \"*.dat\"):\n", - " os.remove(f)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "print(\"Report printed in \" + str(report._html_report_file_path))" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "import shutil\n", - "#shutil.rmtree(tempdir)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "import dill\n", - "# dill.dump_session('notebook_env.db')" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.10.14" - } - }, - "nbformat": 4, - "nbformat_minor": 2 -}