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..25ccf22 --- /dev/null +++ b/TODO @@ -0,0 +1,2 @@ +[ ] Remove plots from pytests (NB. pytest test_name.py works, pytest does not) +[ ] 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..abe8057 --- /dev/null +++ b/doc/examples/hidden_semi_markov.ipynb @@ -0,0 +1,3047 @@ +{ + "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 being 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 (\n", + " _sequence_analysis,\n", + " Estimate\n", + ")\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": 3, + "metadata": {}, + "outputs": [], + "source": [ + "%matplotlib inline" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "##### Enabling R extensions" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "%load_ext rpy2.ipython" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "##### Place variables in markdown outputs" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "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": 6, + "metadata": {}, + "outputs": [], + "source": [ + "import sys, os" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "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": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "sys.path" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "sys.path.append(\"..\" + os.sep + \"tutorials\")" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "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": 10, + "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": 11, + "metadata": {}, + "outputs": [], + "source": [ + "seq0 = mseq.select_individual([1], True)" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "Plot(seq0, ViewPoint=\"Data\")" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "15" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Number of sequences\n", + "len(mseq)" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "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": 15, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "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,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: 9\n", + "mean: 0 median: 0 mode: 0\n", + "variance: 0 standard deviation: 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: 6\n", + "mean: 0 median: 0 mode: 0\n", + "variance: 0 standard deviation: 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", + " \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": 16, + "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": 17, + "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": 18, + "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": 19, + "metadata": {}, + "outputs": [], + "source": [ + "from openalea.sequence_analysis import Simulate" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "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": 21, + "metadata": {}, + "outputs": [], + "source": [ + "nb_seq = 30\n", + "seq_length = 200\n", + "seq = hsmc_est.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": 22, + "metadata": {}, + "outputs": [], + "source": [ + "seq = hsmc_est.simulation_nb_sequences(nb_seq, seq_length, True)" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[2, 1], [2, 1], [2, 1], [2, 0], [2, 1], [2, 1], [2, 2], [2, 2], [3, 3], [3, 3], [3, 3], [3, 0], [3, 3], [4, 4], [4, 4], [4, 4], [4, 4], [4, 4], [4, 0], [4, 4], [4, 3], [4, 4], [4, 4], [4, 4], [4, 4], [4, 4], [4, 0], [4, 3], [4, 4], [4, 4], [4, 4], [4, 4], [4, 4], [4, 4], [4, 4], [4, 4], [4, 4], [4, 4], [4, 4], [4, 4], [5, 0], [5, 0], [5, 0], [5, 1], [5, 0], [5, 0], [5, 2], [5, 0], [5, 0], [5, 0], [5, 0], [5, 0], [5, 0], [5, 4], [5, 0], [5, 0], [5, 0], [5, 0], [5, 0], [5, 0], [5, 0], [5, 0], [5, 0], [5, 1], [5, 0], [5, 0], [5, 2], [5, 0], [5, 0], [5, 0], [5, 0], [5, 2], [5, 0], [5, 2], [5, 0], [5, 0], [5, 0], [5, 0], [5, 0], [5, 0], [5, 2], [5, 2], [5, 0], [5, 0], [5, 0], [5, 0], [5, 2], [5, 0], [5, 0], [5, 0], [5, 0], [5, 0], [5, 0], [5, 0], [5, 0], [5, 0], [5, 0], [5, 0], [5, 0], [5, 0], [5, 1], [5, 0], [5, 0], [5, 0], [5, 0], [5, 1], [5, 0], [5, 0], [5, 0], [5, 0], [5, 0], [5, 0], [5, 0], [5, 0], [5, 0], [5, 2], [5, 0], [5, 0], [5, 0], [5, 0], [5, 0], [5, 0], [5, 0], [5, 0], [5, 4], [5, 0], [5, 1], [5, 0], [5, 0], [5, 0], [5, 0], [5, 0], [5, 0], [5, 0], [5, 0], [5, 2], [5, 0], [5, 0], [5, 0], [5, 0], [5, 0], [5, 0], [5, 2], [5, 0], [5, 0], [5, 0], [5, 0], [5, 0], [5, 0], [5, 0], [5, 0], [5, 0], [5, 0], [5, 0], [5, 0], [5, 2], [5, 0], [5, 0], [5, 0], [5, 0], [5, 0], [5, 0], [5, 0], [5, 0], [5, 0], [5, 4], [5, 0], [5, 0], [5, 0], [5, 2], [5, 0], [5, 0], [5, 0], [5, 0], [5, 0], [5, 0], [5, 0], [5, 0], [5, 0], [5, 0], [5, 0], [5, 0], [5, 0], [5, 2], [5, 0], [5, 0], [5, 0], [5, 0], [5, 0], [5, 0], [5, 0], [5, 0], [5, 0], [5, 0], [5, 0], [5, 0], [5, 0], [5, 0], [5, 0], [5, 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": 24, + "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": 25, + "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": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "obs.plot(\"Sojourn\", 0)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## HSCM re-estimation" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Reestimate from default initialisation" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "HIDDEN_SEMI-MARKOV_CHAIN\n", + "\n", + "6 STATES\n", + "\n", + "INITIAL_PROBABILITIES\n", + "0.737356 1e-05 0.22795 0.0346649 1e-05 1e-05 \n", + "\n", + "TRANSITION_PROBABILITIES\n", + "0 0.495831 1e-05 0.504139 1e-05 1e-05 \n", + "1e-05 0 1e-05 1e-05 0.99996 1e-05 \n", + "1e-05 1e-05 0 0.99996 1e-05 1e-05 \n", + "1e-05 1e-05 1e-05 0 0.842341 0.157629 \n", + "1e-05 1e-05 1e-05 1e-05 0 0.99996 \n", + "0.999239 8.3811e-05 0.000657299 1e-05 1e-05 0 \n", + "\n", + "recurrent class: states 0 1 2 3 4 5\n", + "\n", + "time up to the first occurrence of state 0 distribution\n", + "mean: 120.614 median: 0 mode: 0\n", + "variance: 47645.5 standard deviation: 218.278 lower quartile: 0 upper quartile: 255\n", + "\n", + "time up to the first occurrence of state 0 frequency distribution - sample size: 22\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: 301.505 median: 422 mode: 5\n", + "variance: 97435 standard deviation: 312.146 lower quartile: 12 upper quartile: 909\n", + "\n", + "time up to the first occurrence of state 1 frequency distribution - sample size: 11\n", + "mean: 11.8182 median: 10 mode: 10\n", + "variance: 72.9636 standard deviation: 8.54188 lower quartile: 6 upper quartile: 16\n", + "\n", + "time up to the first occurrence of state 2 distribution\n", + "mean: 2.34218 median: -1 mode: 0\n", + "variance: 1607.85 standard deviation: 40.098 lower quartile: -1 upper quartile: -1\n", + "\n", + "time up to the first occurrence of state 2 frequency distribution - sample size: 7\n", + "mean: 0 median: 0 mode: 0\n", + "variance: 0 standard deviation: 0\n", + "\n", + "time up to the first occurrence of state 3 distribution\n", + "mean: 160.852 median: 13 mode: 8\n", + "variance: 72331.8 standard deviation: 268.946 lower quartile: 8 upper quartile: 515\n", + "\n", + "time up to the first occurrence of state 3 frequency distribution - sample size: 19\n", + "mean: 9.26316 median: 8 mode: 6\n", + "variance: 33.9825 standard deviation: 5.82945 lower quartile: 6 upper quartile: 12\n", + "\n", + "time up to the first occurrence of state 4 distribution\n", + "mean: 68.6485 median: 24 mode: 22\n", + "variance: 21592.4 standard deviation: 146.943 lower quartile: 19 upper quartile: 31\n", + "\n", + "time up to the first occurrence of state 4 frequency distribution - sample size: 27\n", + "mean: 23.8148 median: 23 mode: 13\n", + "variance: 72.7721 standard deviation: 8.53066 lower quartile: 18 upper quartile: 27\n", + "\n", + "time up to the first occurrence of state 5 distribution\n", + "mean: 42.4644 median: 43 mode: 42\n", + "variance: 156.799 standard deviation: 12.5219 lower quartile: 35 upper quartile: 50\n", + "\n", + "time up to the first occurrence of state 5 frequency distribution - sample size: 30\n", + "mean: 42.3333 median: 40.5 mode: 40\n", + "variance: 148.23 standard deviation: 12.175 lower quartile: 37 upper quartile: 50\n", + "\n", + "state 0 recurrence time distribution\n", + "mean: 43.3126 median: 1 mode: 1\n", + "variance: 19932.9 standard deviation: 141.184 lower quartile: 1 upper quartile: 1\n", + "\n", + "state 0 recurrence time frequency distribution - sample size: 220\n", + "mean: 1 median: 1 mode: 1\n", + "variance: 0 standard deviation: 0\n", + "\n", + "state 1 recurrence time distribution\n", + "mean: 21.042 median: 1 mode: 1\n", + "variance: 12187.5 standard deviation: 110.397 lower quartile: 1 upper quartile: 1\n", + "\n", + "state 1 recurrence time frequency distribution - sample size: 192\n", + "mean: 1 median: 1 mode: 1\n", + "variance: 0 standard deviation: 0\n", + "\n", + "state 2 recurrence time distribution\n", + "mean: 1.08387 median: 1 mode: 1\n", + "variance: 57.45 standard deviation: 7.57958 lower quartile: 1 upper quartile: 1\n", + "\n", + "state 2 recurrence time frequency distribution - sample size: 57\n", + "mean: 1 median: 1 mode: 1\n", + "variance: 0 standard deviation: 0\n", + "\n", + "state 3 recurrence time distribution\n", + "mean: 35.6677 median: 1 mode: 1\n", + "variance: 20471.5 standard deviation: 143.079 lower quartile: 1 upper quartile: 1\n", + "\n", + "state 3 recurrence time frequency distribution - sample size: 182\n", + "mean: 1 median: 1 mode: 1\n", + "variance: 0 standard deviation: 0\n", + "\n", + "state 4 recurrence time distribution\n", + "mean: 22.5353 median: 1 mode: 1\n", + "variance: 11008.7 standard deviation: 104.922 lower quartile: 1 upper quartile: 1\n", + "\n", + "state 4 recurrence time frequency distribution - sample size: 533\n", + "mean: 1 median: 1 mode: 1\n", + "variance: 0 standard deviation: 0\n", + "\n", + "state 5 recurrence time distribution\n", + "mean: 1.10237 median: 1 mode: 1\n", + "variance: 4.8844 standard deviation: 2.21007 lower quartile: 1 upper quartile: 1\n", + "\n", + "state 5 recurrence time frequency distribution - sample size: 4700\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.64862 PROBABILITY : 0.158153\n", + "mean: 10.7756 median: 9 mode: 5\n", + "variance: 55.4881 standard deviation: 7.44904 lower quartile: 5 upper quartile: 14\n", + "coefficient of skewness: 1.56342 coefficient of kurtosis: 3.65743\n", + "\n", + "state 0 sojourn time frequency distribution - sample size: 22\n", + "mean: 11 median: 9 mode: 6\n", + "variance: 58.5714 standard deviation: 7.6532 lower quartile: 6 upper quartile: 14\n", + "\n", + "state 0 forward sojourn time distribution\n", + "mean: 8.4621 median: 7 mode: 1.5\n", + "variance: 50.666 standard deviation: 7.11801 lower quartile: 3 upper quartile: 12\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.47\n", + "mean: 18.35 median: 18 mode: 18\n", + "variance: 1.2455 standard deviation: 1.11602 lower quartile: 18 upper quartile: 19\n", + "coefficient of skewness: 0.0537625 coefficient of kurtosis: -0.39711\n", + "\n", + "state 1 sojourn time frequency distribution - sample size: 11\n", + "mean: 18.4545 median: 19 mode: 19\n", + "variance: 1.07273 standard deviation: 1.03573 lower quartile: 17 upper quartile: 19\n", + "\n", + "state 1 forward sojourn time distribution\n", + "mean: 9.70894 median: 10 mode: 8.5\n", + "variance: 28.5998 standard deviation: 5.34788 lower quartile: 5 upper quartile: 14\n", + "\n", + "final run - state 1 sojourn time frequency distribution - sample size: 0\n", + "\n", + "STATE 2 OCCUPANCY_DISTRIBUTION\n", + "NEGATIVE_BINOMIAL INF_BOUND : 6 PARAMETER : 3.80769 PROBABILITY : 0.535135\n", + "mean: 9.30769 median: 9 mode: 8\n", + "variance: 6.18105 standard deviation: 2.48617 lower quartile: 7 upper quartile: 11\n", + "coefficient of skewness: 1.10104 coefficient of kurtosis: 1.73754\n", + "\n", + "state 2 sojourn time frequency distribution - sample size: 7\n", + "mean: 9.14286 median: 8 mode: 7.5\n", + "variance: 5.14286 standard deviation: 2.26779 lower quartile: 7 upper quartile: 11\n", + "\n", + "state 2 forward sojourn time distribution\n", + "mean: 5.48584 median: 5 mode: 3.5\n", + "variance: 10.7213 standard deviation: 3.27434 lower quartile: 3 upper quartile: 8\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 : 145.79 PROBABILITY : 0.937389\n", + "mean: 10.7377 median: 11 mode: 10\n", + "variance: 10.3881 standard deviation: 3.22306 lower quartile: 8 upper quartile: 13\n", + "coefficient of skewness: 0.351711 coefficient of kurtosis: 0.137419\n", + "\n", + "state 3 sojourn time frequency distribution - sample size: 19\n", + "mean: 10.5789 median: 11 mode: 10\n", + "variance: 11.7018 standard deviation: 3.42078 lower quartile: 7 upper quartile: 13\n", + "\n", + "state 3 forward sojourn time distribution\n", + "mean: 6.35253 median: 6 mode: 1\n", + "variance: 14.8497 standard deviation: 3.85353 lower quartile: 3 upper quartile: 9\n", + "\n", + "final run - state 3 sojourn time frequency distribution - sample size: 0\n", + "\n", + "STATE 4 OCCUPANCY_DISTRIBUTION\n", + "NEGATIVE_BINOMIAL INF_BOUND : 10 PARAMETER : 4.32173 PROBABILITY : 0.281585\n", + "mean: 21.0261 median: 20 mode: 18\n", + "variance: 39.1574 standard deviation: 6.25758 lower quartile: 16 upper quartile: 25\n", + "coefficient of skewness: 0.97524 coefficient of kurtosis: 1.41387\n", + "\n", + "state 4 sojourn time frequency distribution - sample size: 27\n", + "mean: 20.7407 median: 21 mode: 21\n", + "variance: 40.4302 standard deviation: 6.35847 lower quartile: 15 upper quartile: 24\n", + "\n", + "state 4 forward sojourn time distribution\n", + "mean: 11.9441 median: 11 mode: 5.5\n", + "variance: 59.252 standard deviation: 7.69753 lower quartile: 6 upper quartile: 17\n", + "\n", + "final run - state 4 sojourn time frequency distribution - sample size: 0\n", + "\n", + "STATE 5 OCCUPANCY_DISTRIBUTION\n", + "NEGATIVE_BINOMIAL INF_BOUND : 146 PARAMETER : 2.91533 PROBABILITY : 0.0100734\n", + "mean: 432.492 median: 400 mode: 334\n", + "variance: 28440.3 standard deviation: 168.642 lower quartile: 309 upper quartile: 522\n", + "coefficient of skewness: 1.17136 coefficient of kurtosis: 2.05812\n", + "\n", + "state 5 sojourn time frequency distribution - sample size: 0\n", + "\n", + "state 5 forward sojourn time distribution\n", + "mean: 249.621 median: 218 mode: 73.5\n", + "variance: 33049.8 standard deviation: 181.796 lower quartile: 109 upper quartile: 351\n", + "\n", + "final run - state 5 sojourn time frequency distribution - sample size: 30\n", + "mean: 157.667 median: 160 mode: 160\n", + "variance: 148.23 standard deviation: 12.175 lower quartile: 150 upper quartile: 163\n", + "\n", + "number of runs of state 0 per length 200 sequence distribution\n", + "mean: 0.738745 median: 1 mode: 1\n", + "variance: 0.194612 standard deviation: 0.441149 lower quartile: 0 upper quartile: 1\n", + "coefficient of skewness: -1.05871 coefficient of kurtosis: -0.794684\n", + "\n", + "number of runs of state 0 per sequence frequency distribution - sample size: 30\n", + "mean: 0.733333 median: 1 mode: 1\n", + "variance: 0.202299 standard deviation: 0.449776 lower quartile: 0 upper quartile: 1\n", + "coefficient of skewness: -1.11166 coefficient of kurtosis: -0.956818\n", + "\n", + "number of runs of state 1 per length 200 sequence distribution\n", + "mean: 0.365894 median: 0 mode: 0\n", + "variance: 0.232046 standard deviation: 0.481712 lower quartile: 0 upper quartile: 1\n", + "coefficient of skewness: 0.557237 coefficient of kurtosis: -1.68835\n", + "\n", + "number of runs of state 1 per sequence frequency distribution - sample size: 30\n", + "mean: 0.366667 median: 0 mode: 0\n", + "variance: 0.24023 standard deviation: 0.490133 lower quartile: 0 upper quartile: 1\n", + "coefficient of skewness: 0.582933 coefficient of kurtosis: -1.73732\n", + "\n", + "number of runs of state 2 per length 200 sequence distribution\n", + "mean: 0.227976 median: 0 mode: 0\n", + "variance: 0.176012 standard deviation: 0.419538 lower quartile: 0 upper quartile: 0\n", + "coefficient of skewness: 1.29699 coefficient of kurtosis: -0.317231\n", + "\n", + "number of runs of state 2 per sequence frequency distribution - sample size: 30\n", + "mean: 0.233333 median: 0 mode: 0\n", + "variance: 0.185057 standard deviation: 0.430183 lower quartile: 0 upper quartile: 0\n", + "coefficient of skewness: 1.32834 coefficient of kurtosis: -0.496273\n", + "\n", + "number of runs of state 3 per length 200 sequence distribution\n", + "mean: 0.634638 median: 1 mode: 1\n", + "variance: 0.232412 standard deviation: 0.482091 lower quartile: 0 upper quartile: 1\n", + "coefficient of skewness: -0.551986 coefficient of kurtosis: -1.67539\n", + "\n", + "number of runs of state 3 per sequence frequency distribution - sample size: 30\n", + "mean: 0.633333 median: 1 mode: 1\n", + "variance: 0.24023 standard deviation: 0.490133 lower quartile: 0 upper quartile: 1\n", + "coefficient of skewness: -0.582933 coefficient of kurtosis: -1.73732\n", + "\n", + "number of runs of state 4 per length 200 sequence distribution\n", + "mean: 0.900086 median: 1 mode: 1\n", + "variance: 0.0900147 standard deviation: 0.300025 lower quartile: 1 upper quartile: 1\n", + "coefficient of skewness: -2.66362 coefficient of kurtosis: 5.11548\n", + "\n", + "number of runs of state 4 per sequence frequency distribution - sample size: 30\n", + "mean: 0.9 median: 1 mode: 1\n", + "variance: 0.0931034 standard deviation: 0.305129 lower quartile: 1 upper quartile: 1\n", + "coefficient of skewness: -2.80912 coefficient of kurtosis: 4.84074\n", + "\n", + "number of runs of state 5 per length 200 sequence distribution\n", + "mean: 1.00001 median: 1 mode: 1\n", + "variance: 1.20218e-05 standard deviation: 0.00346725 lower quartile: 1 upper quartile: 1\n", + "coefficient of skewness: 288.406 coefficient of kurtosis: 83176.3\n", + "\n", + "number of runs of state 5 per sequence frequency distribution - sample size: 30\n", + "mean: 1 median: 1 mode: 1\n", + "variance: 0 standard deviation: 0\n", + "\n", + "number of occurrences of state 0 per length 200 sequence distribution\n", + "mean: 7.95307 median: 6 mode: 0\n", + "variance: 63.37 standard deviation: 7.96053 lower quartile: 0 upper quartile: 12\n", + "coefficient of skewness: 1.39805 coefficient of kurtosis: 2.80561\n", + "\n", + "number of occurrences of state 0 per sequence frequency distribution - sample size: 30\n", + "mean: 8.06667 median: 6 mode: 0\n", + "variance: 66.892 standard deviation: 8.17875 lower quartile: 0 upper quartile: 12\n", + "coefficient of skewness: 1.17775 coefficient of kurtosis: 0.543067\n", + "\n", + "number of occurrences of state 1 per length 200 sequence distribution\n", + "mean: 6.71139 median: 0 mode: 0\n", + "variance: 78.5596 standard deviation: 8.86338 lower quartile: 0 upper quartile: 18\n", + "coefficient of skewness: 0.57578 coefficient of kurtosis: -1.64296\n", + "\n", + "number of occurrences of state 1 per sequence frequency distribution - sample size: 30\n", + "mean: 6.76667 median: 0 mode: 0\n", + "variance: 82.1851 standard deviation: 9.0656 lower quartile: 0 upper quartile: 18\n", + "coefficient of skewness: 0.597422 coefficient of kurtosis: -1.70479\n", + "\n", + "number of occurrences of state 2 per length 200 sequence distribution\n", + "mean: 2.12189 median: 0 mode: 0\n", + "variance: 16.6563 standard deviation: 4.08122 lower quartile: 0 upper quartile: 0\n", + "coefficient of skewness: 1.63919 coefficient of kurtosis: 1.36687\n", + "\n", + "number of occurrences of state 2 per sequence frequency distribution - sample size: 30\n", + "mean: 2.13333 median: 0 mode: 0\n", + "variance: 16.5333 standard deviation: 4.06612 lower quartile: 0 upper quartile: 0\n", + "coefficient of skewness: 1.58175 coefficient of kurtosis: 0.52229\n", + "\n", + "number of occurrences of state 3 per length 200 sequence distribution\n", + "mean: 6.81322 median: 8 mode: 0\n", + "variance: 33.3551 standard deviation: 5.77539 lower quartile: 0 upper quartile: 11\n", + "coefficient of skewness: 0.0419287 coefficient of kurtosis: -1.3066\n", + "\n", + "number of occurrences of state 3 per sequence frequency distribution - sample size: 30\n", + "mean: 6.7 median: 7 mode: 0\n", + "variance: 34.1483 standard deviation: 5.84365 lower quartile: 0 upper quartile: 12\n", + "coefficient of skewness: 0.0268608 coefficient of kurtosis: -1.56226\n", + "\n", + "number of occurrences of state 4 per length 200 sequence distribution\n", + "mean: 18.9238 median: 19 mode: 0\n", + "variance: 75.0216 standard deviation: 8.6615 lower quartile: 15 upper quartile: 24\n", + "coefficient of skewness: -0.357719 coefficient of kurtosis: 0.843471\n", + "\n", + "number of occurrences of state 4 per sequence frequency distribution - sample size: 30\n", + "mean: 18.6667 median: 21 mode: 21\n", + "variance: 76.2989 standard deviation: 8.73492 lower quartile: 15 upper quartile: 24\n", + "coefficient of skewness: -0.37642 coefficient of kurtosis: 0.649974\n", + "\n", + "number of occurrences of state 5 per length 200 sequence distribution\n", + "mean: 157.477 median: 157 mode: 158\n", + "variance: 158.942 standard deviation: 12.6072 lower quartile: 150 upper quartile: 165\n", + "coefficient of skewness: -0.0651994 coefficient of kurtosis: 0.668161\n", + "\n", + "number of occurrences of state 5 per sequence frequency distribution - sample size: 30\n", + "mean: 157.667 median: 160 mode: 160\n", + "variance: 148.23 standard deviation: 12.175 lower quartile: 150 upper quartile: 163\n", + "coefficient of skewness: 0.0917512 coefficient of kurtosis: 0.395032\n", + "\n", + "1 OUTPUT_PROCESS\n", + "\n", + "OUTPUT_PROCESS 1 : CATEGORICAL\n", + "\n", + "STATE 0 OBSERVATION_DISTRIBUTION\n", + "OUTPUT 0 : 0.621228\n", + "OUTPUT 1 : 0.163885\n", + "OUTPUT 2 : 0.214867\n", + "OUTPUT 3 : 1e-05\n", + "OUTPUT 4 : 1e-05\n", + "\n", + "STATE 1 OBSERVATION_DISTRIBUTION\n", + "OUTPUT 0 : 0.203088\n", + "OUTPUT 1 : 0.649252\n", + "OUTPUT 2 : 0.00970781\n", + "OUTPUT 3 : 0.137941\n", + "OUTPUT 4 : 1e-05\n", + "\n", + "STATE 2 OBSERVATION_DISTRIBUTION\n", + "OUTPUT 0 : 0.064759\n", + "OUTPUT 1 : 0.389754\n", + "OUTPUT 2 : 0.487592\n", + "OUTPUT 3 : 1e-05\n", + "OUTPUT 4 : 0.0578844\n", + "\n", + "STATE 3 OBSERVATION_DISTRIBUTION\n", + "OUTPUT 0 : 0.170518\n", + "OUTPUT 1 : 0.178162\n", + "OUTPUT 2 : 0.0293639\n", + "OUTPUT 3 : 0.585885\n", + "OUTPUT 4 : 0.0360715\n", + "\n", + "STATE 4 OBSERVATION_DISTRIBUTION\n", + "OUTPUT 0 : 0.113349\n", + "OUTPUT 1 : 0.0278772\n", + "OUTPUT 2 : 1e-05\n", + "OUTPUT 3 : 0.0310131\n", + "OUTPUT 4 : 0.82775\n", + "\n", + "STATE 5 OBSERVATION_DISTRIBUTION\n", + "OUTPUT 0 : 0.842944\n", + "OUTPUT 1 : 0.0449189\n", + "OUTPUT 2 : 0.0841954\n", + "OUTPUT 3 : 1e-05\n", + "OUTPUT 4 : 0.0279312\n", + "\n", + "observation probability matrix\n", + "\n", + " 0 1 2 3 4 \n", + "0 0.621228 0.163885 0.214867 1e-05 1e-05 \n", + "1 0.203088 0.649252 0.00970781 0.137941 1e-05 \n", + "2 0.064759 0.389754 0.487592 1e-05 0.0578844 \n", + "3 0.170518 0.178162 0.0293639 0.585885 0.0360715 \n", + "4 0.113349 0.0278772 1e-05 0.0310131 0.82775 \n", + "5 0.842944 0.0449189 0.0841954 1e-05 0.0279312 \n", + "\n", + "theoretical weights: 0.0397715 0.0335565 0.0106111 0.0340715 0.0946245 0.787365\n", + "\n", + "log-likelihood: -5844.74 (normalized: -0.974123)\n", + "maximum possible log-likelihood: -5844.74 (information: -0.974123)\n", + "deviance: 0.000294819\n", + "\n", + "chi-square test (4 degrees of freedom)\n", + "chi-square value: 0.000294716 critical probability: 1\n", + "reference chi-square value: 9.48773 reference critical probability: 0.05\n", + "\n", + "restoration weights: 0.0403333 0.0338333 0.0106667 0.0335 0.0933333 0.788333\n", + "\n", + "log-likelihood: -5844.79 (normalized: -0.974131)\n", + "maximum possible log-likelihood: -5844.74 (information: -0.974123)\n", + "deviance: 0.101663\n", + "\n", + "chi-square test (4 degrees of freedom)\n", + "chi-square value: 0.101962 critical probability: 0.998744\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: 2.75352 median: 1 mode: 0\n", + "variance: 25.9745 standard deviation: 5.09652 lower quartile: 0 upper quartile: 2\n", + "\n", + "time up to the first occurrence of output 0 frequency distribution - sample size: 30\n", + "mean: 2.43333 median: 1 mode: 0\n", + "variance: 14.7368 standard deviation: 3.83885 lower quartile: 0 upper quartile: 3\n", + "\n", + "time up to the first occurrence of output 1 distribution\n", + "mean: 4.14746 median: 2 mode: 0\n", + "variance: 39.3538 standard deviation: 6.27326 lower quartile: 1 upper quartile: 5\n", + "\n", + "time up to the first occurrence of output 1 frequency distribution - sample size: 30\n", + "mean: 3.93333 median: 3.5 mode: 0\n", + "variance: 14.0644 standard deviation: 3.75025 lower quartile: 1 upper quartile: 6\n", + "\n", + "time up to the first occurrence of output 2 distribution\n", + "mean: 8.15448 median: 2 mode: 0\n", + "variance: 262.059 standard deviation: 16.1882 lower quartile: 0 upper quartile: 5\n", + "\n", + "time up to the first occurrence of output 2 frequency distribution - sample size: 30\n", + "mean: 6 median: 1 mode: 0\n", + "variance: 221.586 standard deviation: 14.8858 lower quartile: 0 upper quartile: 4\n", + "\n", + "time up to the first occurrence of output 3 distribution\n", + "mean: 18.1773 median: 11 mode: 9\n", + "variance: 2806.16 standard deviation: 52.9732 lower quartile: 7 upper quartile: 16\n", + "\n", + "time up to the first occurrence of output 3 frequency distribution - sample size: 30\n", + "mean: 11.8333 median: 11 mode: 8\n", + "variance: 48.3506 standard deviation: 6.95346 lower quartile: 8 upper quartile: 15\n", + "\n", + "time up to the first occurrence of output 4 distribution\n", + "mean: 22.8087 median: 22 mode: 23\n", + "variance: 216.197 standard deviation: 14.7036 lower quartile: 14 upper quartile: 29\n", + "\n", + "time up to the first occurrence of output 4 frequency distribution - sample size: 30\n", + "mean: 23.6 median: 22 mode: 13\n", + "variance: 348.179 standard deviation: 18.6596 lower quartile: 13 upper quartile: 29\n", + "\n", + "output 0 recurrence time distribution\n", + "mean: 1.26043 median: 1 mode: 1\n", + "variance: 0.926906 standard deviation: 0.96276 lower quartile: 1 upper quartile: 1\n", + "\n", + "output 0 recurrence time frequency distribution - sample size: 4245\n", + "mean: 1.38751 median: 1 mode: 1\n", + "variance: 2.12666 standard deviation: 1.45831 lower quartile: 1 upper quartile: 1\n", + "\n", + "output 1 recurrence time distribution\n", + "mean: 17.0526 median: 10 mode: 1\n", + "variance: 385.084 standard deviation: 19.6235 lower quartile: 3 upper quartile: 24\n", + "\n", + "output 1 recurrence time frequency distribution - sample size: 429\n", + "mean: 12.1119 median: 5 mode: 1\n", + "variance: 252.501 standard deviation: 15.8903 lower quartile: 2 upper quartile: 17\n", + "\n", + "output 2 recurrence time distribution\n", + "mean: 11.9945 median: 8 mode: 1\n", + "variance: 148.766 standard deviation: 12.197 lower quartile: 3 upper quartile: 16\n", + "\n", + "output 2 recurrence time frequency distribution - sample size: 458\n", + "mean: 11.8057 median: 7 mode: 1\n", + "variance: 158.883 standard deviation: 12.6049 lower quartile: 3 upper quartile: 16\n", + "\n", + "output 3 recurrence time distribution\n", + "mean: 83.8759 median: 2 mode: 1\n", + "variance: 34845.8 standard deviation: 186.67 lower quartile: 1 upper quartile: 9\n", + "\n", + "output 3 recurrence time frequency distribution - sample size: 135\n", + "mean: 2.81481 median: 1 mode: 1\n", + "variance: 12.1072 standard deviation: 3.47955 lower quartile: 1 upper quartile: 3\n", + "\n", + "output 4 recurrence time distribution\n", + "mean: 16.7901 median: 2 mode: 1\n", + "variance: 758.827 standard deviation: 27.5468 lower quartile: 1 upper quartile: 23\n", + "\n", + "output 4 recurrence time frequency distribution - sample size: 583\n", + "mean: 7.07376 median: 1 mode: 1\n", + "variance: 283.312 standard deviation: 16.8319 lower quartile: 1 upper quartile: 2\n", + "\n", + "output 0 sojourn time distribution\n", + "mean: 5.82896 median: 4 mode: 1\n", + "variance: 30.781 standard deviation: 5.54806 lower quartile: 2 upper quartile: 8\n", + "\n", + "output 0 sojourn time frequency distribution - sample size: 810\n", + "mean: 5.02963 median: 3 mode: 1\n", + "variance: 26.6196 standard deviation: 5.15942 lower quartile: 1 upper quartile: 7\n", + "\n", + "final run - output 0 sojourn time frequency distribution - sample size: 24\n", + "mean: 8.375 median: 4.5 mode: 1.5\n", + "variance: 93.7228 standard deviation: 9.68106 lower quartile: 2 upper quartile: 12\n", + "\n", + "output 1 sojourn time distribution\n", + "mean: 1.17657 median: 1 mode: 1\n", + "variance: 0.448374 standard deviation: 0.669608 lower quartile: 1 upper quartile: 1\n", + "\n", + "output 1 sojourn time frequency distribution - sample size: 350\n", + "mean: 1.30286 median: 1 mode: 1\n", + "variance: 0.836381 standard deviation: 0.914539 lower quartile: 1 upper quartile: 1\n", + "\n", + "final run - output 1 sojourn time frequency distribution - sample size: 3\n", + "mean: 1 median: 1 mode: 1\n", + "variance: 0 standard deviation: 0\n", + "\n", + "output 2 sojourn time distribution\n", + "mean: 1.10598 median: 1 mode: 1\n", + "variance: 0.122432 standard deviation: 0.349903 lower quartile: 1 upper quartile: 1\n", + "\n", + "output 2 sojourn time frequency distribution - sample size: 428\n", + "mean: 1.13318 median: 1 mode: 1\n", + "variance: 0.176602 standard deviation: 0.42024 lower quartile: 1 upper quartile: 1\n", + "\n", + "final run - output 2 sojourn time frequency distribution - sample size: 3\n", + "mean: 1 median: 1 mode: 1\n", + "variance: 0 standard deviation: 0\n", + "\n", + "output 3 sojourn time distribution\n", + "mean: 1.69553 median: 1 mode: 1\n", + "variance: 1.57781 standard deviation: 1.25611 lower quartile: 1 upper quartile: 2\n", + "\n", + "output 3 sojourn time frequency distribution - sample size: 96\n", + "mean: 1.71875 median: 1 mode: 1\n", + "variance: 1.88849 standard deviation: 1.37422 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: 1.82425 median: 1 mode: 1\n", + "variance: 5.62107 standard deviation: 2.37088 lower quartile: 1 upper quartile: 1\n", + "\n", + "output 4 sojourn time frequency distribution - sample size: 231\n", + "mean: 2.65368 median: 1 mode: 1\n", + "variance: 11.4708 standard deviation: 3.38686 lower quartile: 1 upper quartile: 3\n", + "\n", + "final run - output 4 sojourn time frequency distribution - sample size: 0\n", + "\n", + "number of runs of output 0 per length 200 sequence distribution\n", + "mean: 27.6336 median: 28 mode: 28\n", + "variance: 16.861 standard deviation: 4.10621 lower quartile: 25 upper quartile: 30\n", + "coefficient of skewness: 0.0640307 coefficient of kurtosis: -0.0200186\n", + "\n", + "number of runs of output 0 per sequence frequency distribution - sample size: 30\n", + "mean: 27.8 median: 27 mode: 25\n", + "variance: 9.47586 standard deviation: 3.07829 lower quartile: 25 upper quartile: 30\n", + "coefficient of skewness: 0.984295 coefficient of kurtosis: 0.439251\n", + "\n", + "number of runs of output 1 per length 200 sequence distribution\n", + "mean: 11.5439 median: 11 mode: 11\n", + "variance: 10.0695 standard deviation: 3.17325 lower quartile: 9 upper quartile: 14\n", + "coefficient of skewness: 0.205664 coefficient of kurtosis: 0.00482136\n", + "\n", + "number of runs of output 1 per sequence frequency distribution - sample size: 30\n", + "mean: 11.7667 median: 11 mode: 8\n", + "variance: 13.5644 standard deviation: 3.68298 lower quartile: 8 upper quartile: 14\n", + "coefficient of skewness: 0.575913 coefficient of kurtosis: -0.828011\n", + "\n", + "number of runs of output 2 per length 200 sequence distribution\n", + "mean: 14.3625 median: 14 mode: 14\n", + "variance: 11.7618 standard deviation: 3.42955 lower quartile: 12 upper quartile: 17\n", + "coefficient of skewness: 0.195567 coefficient of kurtosis: 0.022655\n", + "\n", + "number of runs of output 2 per sequence frequency distribution - sample size: 30\n", + "mean: 14.3667 median: 14 mode: 13\n", + "variance: 7.82644 standard deviation: 2.79758 lower quartile: 13 upper quartile: 16\n", + "coefficient of skewness: 0.323742 coefficient of kurtosis: -0.334981\n", + "\n", + "number of runs of output 3 per length 200 sequence distribution\n", + "mean: 3.23588 median: 3 mode: 3\n", + "variance: 2.04268 standard deviation: 1.42922 lower quartile: 2 upper quartile: 4\n", + "coefficient of skewness: 0.383988 coefficient of kurtosis: 0.207192\n", + "\n", + "number of runs of output 3 per sequence frequency distribution - sample size: 30\n", + "mean: 3.2 median: 3.5 mode: 4\n", + "variance: 1.82069 standard deviation: 1.34933 lower quartile: 2 upper quartile: 4\n", + "coefficient of skewness: -0.119107 coefficient of kurtosis: -0.881921\n", + "\n", + "number of runs of output 4 per length 200 sequence distribution\n", + "mean: 7.90831 median: 8 mode: 8\n", + "variance: 6.98129 standard deviation: 2.64221 lower quartile: 6 upper quartile: 10\n", + "coefficient of skewness: 0.267388 coefficient of kurtosis: 0.0824172\n", + "\n", + "number of runs of output 4 per sequence frequency distribution - sample size: 30\n", + "mean: 7.7 median: 7 mode: 7\n", + "variance: 9.38966 standard deviation: 3.06425 lower quartile: 5 upper quartile: 10\n", + "coefficient of skewness: 0.620055 coefficient of kurtosis: 0.0409737\n", + "\n", + "number of occurrences of output 0 per length 200 sequence distribution\n", + "mean: 142.492 median: 142 mode: 142\n", + "variance: 81.8574 standard deviation: 9.04751 lower quartile: 137 upper quartile: 148\n", + "coefficient of skewness: 0.202036 coefficient of kurtosis: 0.284941\n", + "\n", + "number of occurrences of output 0 per sequence frequency distribution - sample size: 30\n", + "mean: 142.5 median: 142 mode: 136\n", + "variance: 94.1207 standard deviation: 9.70158 lower quartile: 136 upper quartile: 148\n", + "coefficient of skewness: 0.524983 coefficient of kurtosis: 0.131893\n", + "\n", + "number of occurrences of output 1 per length 200 sequence distribution\n", + "mean: 15.3029 median: 15 mode: 12\n", + "variance: 31.7994 standard deviation: 5.63909 lower quartile: 11 upper quartile: 20\n", + "coefficient of skewness: 0.362772 coefficient of kurtosis: -0.563702\n", + "\n", + "number of occurrences of output 1 per sequence frequency distribution - sample size: 30\n", + "mean: 15.3 median: 14 mode: 19\n", + "variance: 30.8379 standard deviation: 5.55319 lower quartile: 10 upper quartile: 19\n", + "coefficient of skewness: 0.326489 coefficient of kurtosis: -1.14108\n", + "\n", + "number of occurrences of output 2 per length 200 sequence distribution\n", + "mean: 16.2677 median: 16 mode: 16\n", + "variance: 17.462 standard deviation: 4.17875 lower quartile: 13 upper quartile: 19\n", + "coefficient of skewness: 0.2841 coefficient of kurtosis: 0.0792168\n", + "\n", + "number of occurrences of output 2 per sequence frequency distribution - sample size: 30\n", + "mean: 16.2667 median: 15.5 mode: 14\n", + "variance: 13.5126 standard deviation: 3.67595 lower quartile: 14 upper quartile: 20\n", + "coefficient of skewness: 0.321274 coefficient of kurtosis: -0.662407\n", + "\n", + "number of occurrences of output 3 per length 200 sequence distribution\n", + "mean: 5.5061 median: 5 mode: 4\n", + "variance: 8.47118 standard deviation: 2.91053 lower quartile: 3 upper quartile: 7\n", + "coefficient of skewness: 0.499307 coefficient of kurtosis: -0.0437603\n", + "\n", + "number of occurrences of output 3 per sequence frequency distribution - sample size: 30\n", + "mean: 5.5 median: 5 mode: 5\n", + "variance: 8.81034 standard deviation: 2.96822 lower quartile: 4 upper quartile: 7\n", + "coefficient of skewness: 0.712043 coefficient of kurtosis: 0.453455\n", + "\n", + "number of occurrences of output 4 per length 200 sequence distribution\n", + "mean: 20.4315 median: 21 mode: 20\n", + "variance: 54.5492 standard deviation: 7.38574 lower quartile: 17 upper quartile: 25\n", + "coefficient of skewness: -0.194155 coefficient of kurtosis: 0.57132\n", + "\n", + "number of occurrences of output 4 per sequence frequency distribution - sample size: 30\n", + "mean: 20.4333 median: 22 mode: 22\n", + "variance: 61.6333 standard deviation: 7.85069 lower quartile: 16 upper quartile: 26\n", + "coefficient of skewness: -0.555489 coefficient of kurtosis: -0.026905\n", + "\n", + "distances between observation distributions for consecutive states\n", + "_ 0.623299 _ 0.636213 _ _ \n", + "_ _ _ _ 0.82774 _ \n", + "_ _ _ 0.691634 _ _ \n", + "_ _ _ _ 0.791679 0.727258 \n", + "_ _ _ _ _ 0.830822 \n", + "0.249637 0.742265 0.778185 _ _ _ \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: -5844.74 (-0.974123)\n", + "\n", + "log-likelihood for the state sequences: -4096.51 (normalized: -0.682752)\n", + "\n", + "state sequence entropy: 62.7959 (normalized: 0.010466)\n", + "\n", + "log-likelihood for the observed sequences: -4067.6 (normalized: -0.677934)\n", + "\n", + "39 free parameters 2 * penalyzed log-likelihood (AIC): -8213.21\n", + "\n", + "39 free parameters 2 * penalyzed log-likelihood (AICc): -8213.73\n", + "\n", + "39 free parameters 2 * penalyzed log-likelihood (BIC): -8474.49\n", + "\n", + "39 free parameters 2 * penalyzed log-likelihood (BICc): -8339.75\n", + "\n", + "39 free parameters 2 * penalyzed log-likelihood (ICL): -8600.08\n", + "\n", + "39 free parameters 2 * penalyzed log-likelihood (ICLc): -8465.34\n", + "\n", + "iteration 1 log-likelihood for the observed sequences: -8211.39\n", + "iteration 2 log-likelihood for the observed sequences: -4842.18\n", + "iteration 3 log-likelihood for the observed sequences: -4267.28\n", + "iteration 4 log-likelihood for the observed sequences: -4182.96\n", + "iteration 5 log-likelihood for the observed sequences: -4115.72\n", + "iteration 6 log-likelihood for the observed sequences: -4080.81\n", + "iteration 7 log-likelihood for the observed sequences: -4070.79\n", + "iteration 8 log-likelihood for the observed sequences: -4068.22\n", + "iteration 9 log-likelihood for the observed sequences: -4070.46\n", + "iteration 10 log-likelihood for the observed sequences: -4067.85\n", + "iteration 11 log-likelihood for the observed sequences: -4070.87\n", + "iteration 12 log-likelihood for the observed sequences: -4067.83\n", + "iteration 13 log-likelihood for the observed sequences: -4067.62\n", + "iteration 14 log-likelihood for the observed sequences: -4067.61\n", + "iteration 15 log-likelihood for the observed sequences: -4067.61\n", + "\n", + "15 iterations\n", + "\n", + "complete/censored state occupancy weights\n", + "state 0: 22.1223, 0.019247 (0.999131, 0.000869268)\n", + "state 1: 10.9686, 0.000780434 (0.999929, 7.11467e-05)\n", + "state 2: 6.83868, 1.33832e-05 (0.999998, 1.95698e-06)\n", + "state 3: 19.0314, 0.00029284 (0.999985, 1.5387e-05)\n", + "state 4: 27, 3.70352e-08 (1, 1.37167e-09)\n", + "state 5: 0.020334, 29.9797 (0.000677799, 0.999322)\n", + "\n", + "log-likelihood for the state sequences: -4096.51 | -4096.51\n", + "\n", + "posterior state sequence probability\n", + "sequence 1: 0.671708\n", + "sequence 2: 0.691936\n", + "sequence 3: 0.305846\n", + "sequence 4: 0.288726\n", + "sequence 5: 0.381571\n", + "sequence 6: 0.206856\n", + "sequence 7: 0.801052\n", + "sequence 8: 0.582897\n", + "sequence 9: 0.392282\n", + "sequence 10: 0.275213\n", + "sequence 11: 0.544493\n", + "sequence 12: 0.415691\n", + "sequence 13: 0.410421\n", + "sequence 14: 0.499975\n", + "sequence 15: 0.446748\n", + "sequence 16: 0.356626\n", + "sequence 17: 0.413955\n", + "sequence 18: 0.242718\n", + "sequence 19: 0.445827\n", + "sequence 20: 0.340894\n", + "sequence 21: 0.311262\n", + "sequence 22: 0.784145\n", + "sequence 23: 0.271107\n", + "sequence 24: 0.167435\n", + "sequence 25: 0.578771\n", + "sequence 26: 0.253603\n", + "sequence 27: 0.312522\n", + "sequence 28: 0.503687\n", + "sequence 29: 0.211121\n", + "sequence 30: 0.278927\n" + ] + } + ], + "source": [ + "from openalea.sequence_analysis import Estimate\n", + "nb_states = hsmc_est.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": 28, + "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": 29, + "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": 30, + "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": 31, + "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": 32, + "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": 33, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAz8AAAORCAYAAADcQxzdAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjgsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvwVt1zgAAAAlwSFlzAAAPYQAAD2EBqD+naQAAjRBJREFUeJzt3Qd4lFXaxvGb3jvSBAQFkY4UUUDpvS0WrCiKgiAd67q66H4riitFUBQbCirWUJUqRUSQIgqIIog0QVDpLZR81/O+m2wSEkjCzLwz8/5/1xUhk8nMmTMJzj3POc/JFBcXFycAAAAAiHKZvR4AAAAAAIQC4QcAAACALxB+AAAAAPgC4QcAAACALxB+AAAAAPgC4QcAAACALxB+AAAAAPgC4QcAAACALxB+AAAAAPgC4QdAVCpXrpxGjRqlaLFw4UJlypRJ+/fvD/l9N2nSRAMHDgz63Hbv3l1/+9vfUr3fYN5XsPz444+6+uqrlTNnTtWqVSvo9wcAODfCD4CIsn37dvXo0UOlSpVS9uzZdckll2jAgAH6888/FS1SetHfoEED7dq1SwUKFJDXVqxYoZ49e6bpuukJSqNHj9aECRMUSL/++qsTGtesWRP0+0rJP//5T+XJk0c//fST5s+fr1Cxx1awYEFPQ/ann36q1q1bq2jRoik+BwDgBcIPgIjxyy+/qG7dutq4caPef/99bdq0Sa+88orzovKaa67RX3/95dnYTp8+rTNnzgTt9i3olShRwnkR6bWLLrpIuXPnDvjcWbDLyAv2jAjVfW3evFmNGjVyQnqRIkUydBuxsbGKREeOHFHDhg317LPPej0UAEhA+AEQMR544AEnBMyZM0eNGzdW2bJl1bZtW82bN087d+7U448/nuT6hw4d0m233aa8efM6laIxY8Yk+frQoUOd28iRI4fz9f79+yd5wfnwww/r4osvdt65r1+/vvOuePJ31mfMmKEqVao4t/Haa685y5uSv2tut2vjNVahuvXWW1W6dGknQFSvXt0JcomXYy1atMipTFjQsQ+rXqT0jvwnn3yiqlWrOvdtFZYXXnghyf3aZc8884zuuece5cuXz3ms48ePP+8L1jvvvNOZs5IlS551mylVc1KbR6tgbd26VYMGDUp4LKnNnV0vpaVop06dUt++fZ3rW3j4xz/+obi4uISv221OmTIlyffYdeOrOuXLl3f+vPLKK53r2pji5znxfZ04ccIZd7FixZzn0AKLVbjixc+/BW0L4PbcWTXOKjqpseuvWrVKTz/9tPN3myezdu1aNWvWTLly5XIek1XRDh8+nPB98WMbNmyYM5+XX355irf/3XffqWnTps5zmz9/ftWpU0crV650xnr33XfrwIEDCfMef9+TJk1yxm/fY2Hafj/27NnjfM1+zuz2TKFChZzvs7EYm/Phw4fr0ksvdcZds2ZNffzxxzqXbt266cknn1SLFi3OeT0ACKk4AIgAf/75Z1ymTJninnnmmRS/ft9998UVKlQo7syZM87nl1xySVy+fPnihg0bFvfTTz/Fvfjii3FZsmSJmzNnjvP1jz76KC5//vxxn332WdzWrVvjli9fHjd+/PiE27vtttviGjRoELd48eK4TZs2xT3//PNxOXLkiNu4caPz9bfeeisuW7ZsznW++uqruB9//DHu8OHDccWLF497/fXXE27n1KlTzmWvvvqq8/mOHTuc2/r222/jNm/enDCuZcuWOV/fv39/3DXXXOM8nl27djkfdhsLFiywV/xx+/btc663cuXKuMyZM8c9/fTTzuOz8eTKlcv5M57NQeHCheNeeumluJ9//tmZC/ueDRs2pDrPvXv3jitdurQzT99//31chw4d4vLmzRs3YMCAJLc7cuTI886jPWd2WzbG+Mdyrrm766674jp37pxwP40bN064b7vOpEmT4nLnzp3kebI5iYmJSfIYChQokDAP33zzjXOdefPmOfdvYzLJ76t///5xpUqVch7H+vXrna/bz1P89ePnv379+nELFy50rnPttdc6jyE1dn9Vq1aNGzJkiPP3Q4cOxR05csS5n+uvvz5u7dq1cfPnz48rX768c3/x7O/2uLt16xa3bt0653opsdu+4447nOfTfi4//PDDuDVr1sSdOHEibtSoUc7zEj/vdt/mjTfecB6j/ex9/fXXcVdffXVc27Ztna/Zz9knn3ziPE77mbLvs59H8/e//z3uiiuuiJs1a5bzvTa/9vtgc3E+W7ZscW7TfuYBwGuEHwARwcJBSi90440YMcL5+u+//57wAr1NmzZJrnPzzTcnvNB74YUX4i6//PK42NjYs27Lwo4FrZ07dya5vHnz5nGPPfaY83d78Wf3Zy82E7MX0c2aNUv4fPbs2XHZs2eP++uvv1J9bO3atXNeICd+0Z84bJjk4cfCWcuWLZNc56GHHoqrUqVKwuc2B/biOJ4Fw2LFisWNGzcuxXHYC2Qb6+TJkxMusxf/FqpSCz/nmsfk142X2tylFH4qV66cEGjNI4884lyW1vCT2gvvxPdlwcvC2LvvvpvwdXs8FlKGDx+eZP4tRMWbOXOmc9mxY8fiUlOzZs24f/7znwmfW3CzUGX3mfh2LJTu3r07YWwWmC3EnIuF+wkTJqT4NXv8Ng/nEx8O48NR8p8zY2PNmTNn3NKlS5N8b48ePeJuvfXW894H4QdAOGHZG4CoEL8UKvGeGNsHlJh9vmHDBufvN910k44dO+Ys47nvvvsUExPjLLEyq1evdm7PlhvZ8q/4D1uOZns44tkSvBo1aiS5j9tvv91ZdvTbb785n7/77rtq166ds4wofn/Lv//9b+f7bMmT3a4t49u2bVu6Hq89DttPkZh9/vPPPzv3ES/x+GxubKlT/DKn5Oyx2XK/xPNWuHBhVapUKdVxnGsezyWluUuJdUpL/pwmf4wXyh73yZMnk8xntmzZdNVVVyX8vMRLPGZbFmhSm8+U2O3ZkjFbShnP7tf2PCVeQmfLIW2OzmXw4MG69957nWVltq8m8c9mar799lt17tzZ2YNkS9/ilwGe6+fvhx9+0PHjx9WyZcskvw/vvPNOmu4TAMIJ4QdARKhQoYLzItheiKXWUtgChnWWOpf4F9JlypRxXmy+9NJLzh6GPn366LrrrnNeBNsL0SxZsjj7NaxDVfyHvXC1vTjx7PuSNyCwF8yXXXaZJk+e7IQCCwN33HFHwtdtD83IkSOd/URffPGFc7vWESu9m9otnCW/78R7YRK/iE/++FNrzJDS95/PuebxXFKau4yw20g+7vPdd1qCc/zlyS9LPJ/xX0tPo4uUbjP57ZnE4Sg1to9n/fr1at++vfOzZPun7OftXPu5WrVq5QQX2/tje5rir3+un7/4xzdz5swkvw/2u3i+fT8AEG4IPwAiglVJ7J3nl19+2QkVie3evdupsNx8881JXkAuW7YsyfXs8yuuuCLJC/BOnTrpxRdfdKo1X3/9tbMZ3TbHW2XB3tG30JX4wyon52ObyG0806dPV+bMmZ0Xp/G+/PJL5513C0RWAbCKiVUyErN3/M9X2bAXukuWLEly2dKlS51qlQW3jLDHZy/uE8/bvn37nO5655LaPKb1sZxLSs9hxYoVEx6jdZ6zFuDxbC6PHj2a8Hl89eRcY7DHbddLPJ8WoKx5QOXKlRVI9rxZcLAgEu+rr75yfk5Sa2xwLvY91lDCqofXX3+93nrrrVTn3d4g+OOPP5wq0bXXXuv8LiSvWqU0X/FNKaw6lPz3wcIvAEQSwg+AiDF27FinK5dVShYvXuyc+TNr1iwnFFlXNltOlpi9qLQOVfbi3SoTH330kXMmkLFuYG+88YbWrVvntNCeOHGi8yLelgPZC0pbvmZdz+yski1btjjvkj/33HP67LPPzjtO+15bOmfjufHGG53uYfHsBePcuXOdoGKVpF69ejnhLXk3teXLlzvdt+zFakqVhSFDhjidx/71r385j+/tt9925ufBBx/M8PxaRcDOUHrooYec27a5sW5f9sI8Neeax/jHYs+VdeOzx5Je9hzb8i6rLllXPOvYF/8cGuuaZo/b5tvCyv3335+kOmPd22w89nPy+++/Ox3QkrMqS+/evZ3HbdezioYt4bMQZfMRSPazYT8Pd911lzNnCxYsUL9+/ZzOaMWLF0/z7dgbANYFz8Kmdcqzn3X7GY0Pazbv1kHOnkebd3ss1pHPwo3NoT1X06ZNc35+ErPnzd5AsE58e/fudW7DlsfZz5WFLPs5s6VutnzOfqfs89RY6/n4CpGx59A+T/7zDgAh5fWmIwBIj19//TWue/fucSVKlHA2qZcpUyauX79+cX/88cdZG+2feuqpuK5duzodwmwDuXXAimeb5K1zl3XEypMnj9P1KvFmdtvw/uSTT8aVK1fOuR+7vy5dujgd0NKyobxevXrOxvEvvvgiyeXWQMA22ls3L2s+8I9//CPuzjvvTLLR3zpt2Xis0YDdhm0YT2kj+scff+w0OLDxlS1b1ukid75mA8k34CdnG9+tSUL8nNmG/+QNGBLf7vnm0TqK1ahRw+kMFv+/nNTmLqWGB3369Im7//77ndu3RgGPPvpokgYI1pSiVatWzn1XrFjR6WSWuOGBee2115yfE2sqYLeZ0n1Z0wL7OSpatKgz1oYNGzrNAOKlNP/WRCH++UlNSvNtP0NNmzZ1mghYNz7r7BffcCClsaXEmiHccsstzuOyJhXWnKFv375Jmi/YvBUpUsQZY/wY3nvvPedn2h6jdRWcNm3aWQ0hrDuf/bxb04/4LnQ256NHj46rVKmS8/N20UUXxbVu3Tpu0aJFqY4xvrFF8o9z/fwBQLBlsv+ENm4BAAAAQOix7A0AAACALxB+AAAAAPgC4QcAAACALxB+AAAAAPgC4QcAAACALxB+AAAAAPgC4QcAAACALxB+AAAAAPgC4QcAAACALxB+AAAAAPgC4QcAAACALxB+AAAAAPgC4QcAAACALxB+AAAAAPgC4QcAAACALxB+AAAAAPgC4QcAAACALxB+AAAAAPgC4QcAAACALxB+AAAAAPgC4QcAAACALxB+AAAAAPgC4QcAAACALxB+AAAAAPgC4QcAAACALxB+AAAAAPgC4QcAAACALxB+AAAAAPgC4QcAAACALxB+AAAAAPgC4QcAAACALxB+AAAAAPgC4QcAAACALxB+AAAAAPgC4QcAAACALxB+AAAAAPgC4QcAAACALxB+AAAAAPgC4QcAAACALxB+AAAAAPgC4QcAAACALxB+AAAAAPgC4QcAAACALxB+AAAAAPgC4QcAAACALxB+AAAAAPgC4QcAAACALxB+AAAAAPgC4QcAAACALxB+AAAAAPgC4QcAAACALxB+AAAAAPgC4QcAAACALxB+AAAAAPgC4QcAAACALxB+AAAAAPgC4QcAAACALxB+AAAAAPgC4QcAAACALxB+AAAAAPgC4QcAAACALxB+AAAAAPgC4QcAAACALxB+AAAAAPgC4QcAAACALxB+AAAAAPgC4QcAAACALxB+AAAAAPgC4QcAAACALxB+AAAAAPgC4QcAAACALxB+AAAAAPgC4QcAAACALxB+AAAAAPgC4QcAAACALxB+AAAAAPgC4QcAAACALxB+AAAAAPgC4QcAAACALxB+AAAAAPgC4QcAAACALxB+AAAAAPgC4QcAAACALxB+AAAAAPgC4QcAAACALxB+AAAAAPhCVkWgM2fOJPw9U6ZMno4FAAAAgHfi4uIS/p45c+boCz/m+PHjXg8BAAAAQJjImTPnea8TseEn/gFS+QEAAAD8Xfk5nsbCSESGn/jAY38SfgAAAABkSsN2GBoeAAAAAPAFwg8AAAAAX0h3+Fm8eLE6duyoUqVKOaWlKVOmnHWdDRs2qFOnTipQoIDy5cunq6++Wtu2bUv4+okTJ9SvXz8VLVpUefLkca67Y8eOC380AAAAABCoPT9HjhxRzZo1dffdd+uGG2446+ubN29Wo0aN1KNHDz311FNOALIwlLj7wsCBAzV9+nRNnjxZRYoU0ZAhQ9ShQwetWrVKWbJkSe+QAAAAIt7p06d18uRJr4cBhKXs2bOft411WmSKS9wYO73fnCmTYmJi9Le//S3hsltuuUXZsmXTxIkTU/yeAwcO6KKLLnK+fvPNNzuX/fbbbypTpow+++wztW7d+qzvsUqRfSSWNWtW5cqVi4YHAAAgotlLsd27d2v//v1eDwUIWxZ8ypcv74SglH6Hjh07lqZskDXQh4/OnDlTDz/8sBNivv32W2eQjz32WEJAsuqOvavRqlWrhO+zJXTVqlXT0qVLUww/w4YNc6pI8Wwpnf0jAQAAEOnig0+xYsWUO3du3tgFUsgYVizZtWuXypYte0G/IwENP3v27NHhw4f17LPP6v/+7//03HPPadasWbr++uu1YMECNW7c2PkFt8RWqFChJN9bvHjxVAONhafBgwcHcqgAAABhsdQtPvjYVgAAKbOVYxaATp065awyy6iAV35M586dNWjQIOfvtWrVcio6r7zyihN+UmPlqtRSXI4cOZyP5KUtAACASBa/x8cqPgBSF7/czd4wuJDwE9BW19a9zfbiVKlSJcnllStXTuj2VqJECcXGxmrfvn1nVY2s+gMAAOA3HNoOhOZ3JHOgE1m9evX0008/Jbl848aNuuSSS5y/16lTx0lrc+fOTfi6rd9bt26dGjRoEMjhAAAAAEDGl73Znp5NmzYlfL5lyxatWbNGhQsXdjYgPfTQQ04Xt+uuu05NmzZ19vxYW+uFCxc617fW19YG29pb29pW+74HH3xQ1atXV4sWLdI7HAAAAAAITuVn5cqVuvLKK50PY40I7O9PPvmk83mXLl2c/T3Dhw93As3rr7+uTz75xDn7J97IkSOd7m9du3ZVw4YNnXWuFpA44wcAACByNWnSxDnP0ZQrV06jRo0K+H107949yTErie8z2PeFyHdB5/x4JT29vAEAAMLV8ePHnVU0djRI4gPhI5UFEWt2ZaFn7969ypMnT5qaOVhQsgCTlhBjZ0baa8GCBQuedZ8Z9euvvzrPgR3TYreV2n0hPH9XPDvnBwAAAIhvTRxI1uXLXtjaFopQCeV9ITQC2vAAAAAA/nDkyBHdeeedyps3r0qWLKkXXnghydeTL3sbOnSosz/cji+xA+779++fULnZunWrc0yKhZv4d+4nTJjgVFxmzJjhdBK277PrpbQUzc5+6du3r3N921P+j3/8w6kGxLPbnDJlSpLvsevafRirJhjbymHXtTGZ5Pd14sQJZ9x2LpNVH2xbx4oVKxK+bnvc7fvnz5+vunXrOlUva+iVvBkYvEPlBwAAIAztOrRLuw7vCsl9lcxbUiXzlUzX91iTKzvEPiYmxjnK5O9//7tWrVqVZNlYvI8//tjZ8z158mRVrVrVOdj+u+++c7726aefqmbNmurZs6fuu+++JN939OhRDRs2zNlDbqHGQkdK3n77baeh1vLly5396XZb1mk4+e2l5ptvvtFVV12lefPmOeOLP1MmuYcfftjZy273Z7dve9xbt27tNAOzJl7xHn/8cScMWvXr/vvv1z333KOvvvoqTWNBcBF+AAAAwtCrq17VU4ueCsl9/bPxPzW0ydB0df9944039M4776hly5bOZRYISpcuneL17bxHC0jW2deOPLEKkIUNY6HBml7ly5fPuU7yQ2BffvllJxydS5kyZZxwZVWXSpUqae3atc7naQ0/8Uv0LGAlH0PiSte4ceOcalHbtm2dy1577TXn+BabCwuD8f7973+rcePGzt8fffRRtW/f3tmzEg37uiId4QcAACAM9arTS50qdQpZ5Sc9Nm/e7Bxaf8011yRcZiHGgkdKbrrpJmcJ3KWXXqo2bdqoXbt26tixo7JmPfdLUavA1KhR47zjufrqq5NsdLdxWeXF9gkFqpuwPWYLY9apOJ4FOQtxGzZsSHLdxGO2JYFmz549TuiDtwg/AAAAYciWoaV3KVqopLdZsFVmbN+LVUlsaVmfPn30/PPPa9GiRU6ASE2gOvvabSQfswWZ9Ij//uTjscuTX5b4McV/7cyZM+keNwKPhgcAAABIlwoVKjgv8JctW5Zw2b59+7Rx48ZzBplOnTrpxRdfdBoDfP31187ytPgKj1VpMirxOOI/r1ixYkLVx5a17dr1v/1TP//8s7OfKF78Hp9zjcEes11vyZIlSQKU7TGqXLlyhseO0KLyAwAAgHSxDm/WYMD2udg+meLFizub/DNnTvl9ddsnY8Gifv36Tge0iRMnOmHImgbEd4ZbvHixbrnlFqerW9GiRdM1nu3bt2vw4MHq1auXVq9erTFjxiTpPtesWTONHTvWWR5nFZhHHnkkSXXGGinYeGbNmuXsW7K9OcnbXNuZRb1793Yesy3xsyVs1vDAQpTNBSID4QcAAADpZsvWrPGBVXOsWcGQIUOcQ0FTYm2ln332WSegWAiqXr26pk+f7gQn8/TTTzvB5bLLLnPaSad3WZ213LZDLm3/jVV7+vXr53R8i2dB6O6779Z1113ntNkePXq005kunu09soqUjePJJ5/Utdde61SnkrPHYOGpW7duOnTokNPOevbs2SpUqFC6xgvvZIpL709XGEjPKa4AAACReGo9gLT9rqQnG7DnBwAAAIAvEH4AAAAA+ALhBwAAAIAvEH4AAAAA+ALhBwAAAIAvEH4AAAAA+ALhBwAAAIAvEH4AAAAA+ALhBwAAAOlih0r27NlThQsXdg6VXLNmDTOYRt27d9ff/va3hM+bNGmigQMHBnz+hg4dqlq1aqV6v8G8r3BG+AEAAEC6zJo1SxMmTNCMGTO0a9cuVatWjRnMoE8//VT/+te/0nTd9ASlBx98UPPnzw/485IpUyZNmTIlJPcVDIQfAACAaDBvnlSlivtnkG3evFklS5ZUgwYNVKJECWXNmvWs68TGxgZ9HNHAqmf58uULaFXu1KlTyps3r4oUKaJQyBvC+7pQhB8AAIBIFxcn/f3v0oYN7p/2eZDY8ql+/fpp27ZtThWgXLlyCVWJvn37avDgwSpatKhatmzpXP7DDz+oXbt2zgvk4sWLq1u3bvrjjz8Sbu/IkSO68847na9boHrhhRfOqnCkVG0oWLCgU32Kt3PnTt18880qVKiQ80K8c+fO+vXXX89a9vWf//zHuR+7zgMPPKCTJ08mXOfEiRN6+OGHVaZMGeXIkUMVK1bUG2+84QSKChUqON+b2Lp165Q5c2YnDKbk9OnTznzYWO3+7LbtthJL/lhffvll535z5szpzNeNN96YMP5FixZp9OjRznzYhz2+hQsXOn+fPXu26tat64z7yy+/THUp2lNPPaVixYopf/786tWrV5KQas/lqFGjklzfbsNuK/7rpkuXLkme++T3debMGT399NMqXbq0Mx77mlUL49m47fut6tW0aVPlzp1bNWvW1Ndff61gI/wAAABEujlzpBUr3L/bn/Z5kNiL7/gXtrbkbUX8/Up6++23nSrQV199pVdffdX5euPGjZ0XvytXrnReAP/+++/q2rVrwvc89NBDWrBggWJiYjRnzhznxfyqVavSNaajR486L6ItQC1evFhLlixx/t6mTZskL+7tfiyo2J82VgtPiQOUhbDJkyfrxRdf1IYNG/TKK684t2Mv1O+55x699dZbSe73zTff1LXXXqvLLrssxXFZkLPrWICyMf3111/O40yNzVH//v2d+f3pp5+c+bruuusS5v2aa67Rfffd58yrfVhIi2fBatiwYc64a9SokeLtz58/3/m6Pf7333/fGYuFobSKf65tHpI/94nZWO2xW1j8/vvv1bp1a3Xq1Ek///xzkus9/vjjzpI52zN2+eWX69Zbb3WqVsF0do0SAAAA3jp6VPrxx7Rd1yoJgwdLmTPbW+7un/b5O+9YySTt93nFFVLu3Oe9WoECBZxlWlmyZHGWvCVm1ZHhw4cnfP7kk0+qdu3aeuaZZxIuszBgL9o3btyoUqVKOcHgnXfeSagUWSixYJUeFlisAvP66687QSX+BbpVXCxMtWrVyrnMqkJjx451xn7FFVeoffv2TiCwQGHj+fDDDzV37ly1aNHCuf6ll16acB93332383i++eYbXXXVVU7FaNKkSXr++edTHZdVUR577DHdcMMNzucWpqxCkxqrpuXJk0cdOnRw5viSSy7RlVdemTDv2bNnd6okyefdWGCKn8PUZM+e3Zl/u42qVas632Ph0/Yc2fydz0UXXeT8afOa0hjiWeh55JFHdMsttzifP/fcc07gsvl46aWXEq5nwceeA2MhzMa0adMm57kJFsIPAABAuLHgU6dOxr7XAtAPP0h166bv+6zaUru2LoQtu0p6k6ucF71WPUnOKjDHjh1zKjNW0Ui8B6ZSpUrpul+7H3vRnHzvzPHjx5MsSbMX1xZ84tnyt7Vr1zp/t+qDfc0qVSmx69oLdQsPFn6s2YPd/k033ZTi9Q8cOOBURxI/NquK2RwlX/oWz8KLBR4LXVa1sg9bYmZhJb1zn5KaNWsmuS0b2+HDh7V9+3bnfgPh4MGD+u2339SwYcMkl9vn3333XZLLEleobH7Nnj17CD8AAAC+Yu98p2Xpl72IvvNONyxZ6Iln7+LbbaSn+hOAd9utapGY7f3o2LGj885/cvZiN/kyqNRYNSd5YEi8V8fup06dOnr33XdTrVaYbNmynXW79r0mV65c5x3Hvffe6+xZGjlypFNZsj1GaQkmaWXhbfXq1U61ypYAWqXJ9tPY8jKrtqRn7tMj039/Rqz6c655zshtxrPbTX5Z4ucj/mvxz0ewUPkBAAAIN/aCOi1VGFtCZVWe1Ko/1ligdWt5xZa8ffLJJ87G+JQ6wtkyOXsBvGzZMpUtW9a5bN++fc4StMQVGAswVkWJZ6HJ9vkkvp8PPvggYSN/RlSvXt154W1NBeKXvSVnjRssZIwbN06ff/65s78oNbZMzQKePbb4fTu2n8WqVDbe1Ng82f3bxz//+U8n9HzxxRe6/vrrnWVr1kQho7777jun2hYf9GxsVpWLX2aYfJ6tirNly5Ykt2HP17nGYPNvyxltj1P84zZLly51KmZeo+EBAABAJLJ36J94wq3ypMQut68HsfPb+Vg3NdvkbxvZba/ML7/84lQ0rHmAvYC2F949evRw9p3Y3hvrnmZdzZLvP2nWrJmzV8eqItYU4P77709SNbj99tudDnPW4c06ndkLdgsxAwYM0I4dO9I0Vgtod911lzM26yxnt2EVGNsHFM+Wxdn4bB+PBbfES9pSYvf/7LPPOo0FfvzxR/Xp00f79+9P9fq2lM6aLdgSvK1btzp7oSyQxS8DtDEuX77c6ZZmHfPSWyWJjY115ts68Fl4s3BlHfri59vmeeLEic4c2nNh85F4mWD8GOy52r17txNUU2LPp1X7LJBa44ZHH33UeUw2H14j/AAAAEQi62K2bVvS5W6J2eXbt7vX84hVAKzzmwUd6/hlh6HaC2CrisS/4LaGAVYhsG5gVu1o1KiRs4QtMescZk0S7Hq33Xabs1E+8XIz+7tVYax6ZBWSypUrOyHGqhzpqQRZRcdaS1tIsU331gjBWnEnZuHBQoTd/vkMGTLE6SBngcmCki1rsz08qbEqj7V/thBij8EaJFhXNturZOxxWxipUqWKU6WxBgnp0bx5c6eNts2jddyzJYnxbayNhTr7mjVcsCqXtQZP3snOngtrCmHPR3wzhuSsY509dvuwipp1rZs2bZpz317LFJfajqswZkOOL9klXzsIAAAQKWzDvFUYypcv75zrkm4WbvbuTf3rxYpJ6eycFg7s7Btrj538zJlwYGHOxmcVJTuHB97/rqQnG7DnBwAAIFLZOS+JznpB8NgBqNYV7YknnnCqJgSfyMSyNwAAAOA8bPmZ7b2xFtaJzzJCZGHZGwAAQKQuewN84niAlr1R+QEAAADgC4QfAAAAAL5A+AEAAPBYsE+1ByJdXIAaVNPtDQAAwCPZs2d3zrv57bffnHNb7HOO8QDODj579+51fjcSH26bEYQfAAAAj1jwsQ3cu3btcgIQgJRZ8CldurRzyOuFIPwAAAB4yKo9ZcuW1alTp3T69GmeCyAFVvG50OBjCD8AAAAei1/Oc6FLegCcGw0PAAAAAPgC4QcAAACALxB+AAAAAPgC4QcAAACALxB+AAAAAPgC4QcAAACALxB+AAAAAPgC4QcAAACALxB+AAAAAPgC4QcAAACALxB+AAAAAPgC4QcAAACALxB+AAAAAPgC4QcAAACALxB+AAAAAPgC4QcAAACALxB+AAAAAPgC4QcAAACALxB+AAAAAPgC4QcAAACALxB+AAAAAPgC4QcAAACALxB+AAAAAPgC4QcAAACALxB+AAAAAPgC4QcAAACALxB+AAAAAPgC4QcAAACALxB+AAAAAPgC4QcAAACALxB+AAAAAPgC4QcAAACALxB+AAAAAPgC4QcAAACALxB+AAAAAPgC4QcAAACALxB+AAAAAPgC4QcAAACALxB+AAAAAPgC4QcAAACALxB+AAAAAPgC4QcAAACALxB+AAAAAPgC4QcAAACAL6Q7/CxevFgdO3ZUqVKllClTJk2ZMiXV6/bq1cu5zqhRo5JcfuLECfXr109FixZVnjx51KlTJ+3YsSNjjwAAAAAAghF+jhw5opo1a2rs2LHnvJ6FouXLlzshKbmBAwcqJiZGkydP1pIlS3T48GF16NBBp0+fTu9wAAAAACBNsiqd2rZt63ycy86dO9W3b1/Nnj1b7du3T/K1AwcO6I033tDEiRPVokUL57JJkyapTJkymjdvnlq3bp3eIQEAAABA6Pf8nDlzRt26ddNDDz2kqlWrnvX1VatW6eTJk2rVqlXCZVYdqlatmpYuXZribdoyuYMHDyZ8HDp0KNDDBgAAABDlAh5+nnvuOWXNmlX9+/dP8eu7d+9W9uzZVahQoSSXFy9e3PlaSoYNG6YCBQokfJQuXTrQwwYAAAAQ5dK97O1crKozevRorV692ml0kB5xcXGpfs9jjz2mwYMHB2iUAAAAAPwooJWfL7/8Unv27FHZsmWd6o99bN26VUOGDFG5cuWc65QoUUKxsbHat29fku+177PqT0py5Mih/PnzJ3zky5cvkMMGAAAA4AMBDT+21+f777/XmjVrEj5sP4/t/7HmB6ZOnTrKli2b5s6dm/B9u3bt0rp169SgQYNADgcAAAAAMr7szdpSb9q0KeHzLVu2OCGncOHCTsWnSJEiSa5vQceqPZUqVXI+tz07PXr0cKpBdl37vgcffFDVq1dP6P4GAAAAAJ6Hn5UrV6pp06YJn8fvxbnrrrs0YcKENN3GyJEjnSVxXbt21bFjx9S8eXPne7NkyZLe4QAAAABAmmSKs04DEcaGbKEpV65c6W6sAAAAACB6pCcbBLzVNQAAAACEI8IPAAAAAF8g/AAAAADwBcIPAAAAAF8g/AAAAADwBcIPAAAAAF8g/AAAAADwBcIPAAAAAF8g/AAAAADwBcIPAAAAAF8g/AAAAADwBcIPAAAAAF8g/AAAAADwBcIPAAAAAF8g/AAAAADwBcIPAAAAAF8g/AAAAADwBcIPAAAAAF8g/AAAAADwBcIPAAAAAF8g/AAAAADwBcIPAAAAAF8g/AAAAADwBcIPAAAAAF8g/AAAAADwBcIPAAAAAF8g/AARatehXRq6cKjzJwAAAM6P8ANEqF2Hd+mpRU85fwIAAOD8CD9AhMq3eLnWj3X/BAAAwPlliouLi1OEsSEfO3ZMuXLlUqZMmbweDhB6cXE6cmU15fnuBx2pWUV5vl0n8bsAAAB8KC4d2YDKDxCJ5sxxgo9x/pwzx+sRAQAAhD3CDxBprFj7xBOK++87G3FZMjufO5cDAAAgVYQfINJYlWfFCluz6nya6fQZ53OqPwAAAOdG+AEisOpz1v6eLFmo/gAAAJwH4QeIwKrPWUvcTp+m+gMAAHAehB8g0qs+8TKz9wcAAOBcCD9ApIiNlbZtS72xwZkz0vbt7vUAAABwFsIPECly5JCGD3f//tpr2jBrkmr3lI5ddonUqpW0apW79M2uBwAAgLMQfoBI8vbbUr16Uo8eOlajsr4tJe3r0kb6+mupalWpdGmvRwgAABC2CD9ApFizRvriC2nIkCT7fg60aSodOiQtWODp8AAAAMId4QeIFC+8IF1yiXTDDUkuPla5glS+vDRlimdDAwAAiASEHyAS7NghTZ4sDRggZc2a9GtWBerSRZo61W16AAAAgBQRfoBIMGaMlDu3s9cnRX/7m7R7t/TNN6EeGQAAQMQg/ADhzvbzvPqq1LOnlD9/ytdp0EAqWpSlbwAAAOdA+AHC3ZtvSkeOSP37p36dLFmkTp2kmJjUzwECAADwOcIPEM5OnZJGjZK6dpXKlDn3dW3p28aN0o8/hmp0AAAAEYXwA4Qzq+T8+qvb3vp8WrSQ8uRh6RsAAEAqCD9AuLLla9beukkTqXbt818/Vy6pTRvCDwAAQCoIP0C4WrpUWr48bVWfxEvfrOPbzp3BHBkAAEBEIvwA4cqqPpUqSe3apf172rd3zwGyM38AAACQBOEHCEebNrnL1wYPljKn49e0UCF3mZx9LwAAAJIg/ADhyDq82bk93bql/3tt6duCBdL+/cEYGQAAQMQi/ADh5q+/pLfekvr0cZsYpJed92MtsmfODMboAAAAIhbhBwg3r7winT7thp+MsPOA6tZl6RsAAEAyhB8gnJw4IY0ZI915p1SsWMZvx5a+ff65dPx4IEcHAAAQ0Qg/QDh5/31p92630cGF6NJFOnJEmj8/UCMDAACIeIQfIJwONR0xwm1XfcUVF3ZblStLFSuy9A0AACARwg8QLubOldauTd+hpqnJlMld+mbn/dj+IQAAABB+gLA61PTKK91zegLBws/evdLXXwfm9gAAACIclR8gHFjFZ84ct+pjVZtAuPpqqXhxlr4BAAD8F+EHCAe216d0aalr18DdZubMUufObvix/UQAAAA+R/gBvLZrl/Tuu1L//lK2bIG9bVv6tnmztG5dYG8XAAAgAhF+AK+NHSvlyCHdd1/gb7tZMylfPpa+AQAAEH4Aj9lZPOPGSffeKxUsGPjbt1DVrh3hBwAAgPADeGzCBOnAAWnAgODdhy19W71a2rYtePcBAAAQAVj2BnjFzt8ZOVK68UapXLng3U/btu5eImt8AAAA4GOEH8Ar06a5zQgCcajpuRQo4O79IfwAAACfI/wAXh5q2qiRdNVVwb8vW/q2eLH055/Bvy8AAIAwRfgBvLB8ufTVV8Gv+sSz835smd3MmaG5PwAAgDBE+AG8qvpUqCB17Bia+ytZUrr6apa+AQAAXyP8AKG2ZYv0ySfSoEFSliyhu19b+jZrlnT0aOjuEwAAIIwQfoBQGz3aPdOne/fQ3q+Fn2PHpLlzQ3u/AAAAYYLwA4TS/v3SG29IvXtLuXOHdu4rVZIqV2bpGwAA8C3CDxBK48dLsbFS377ezLtVf6ZPl06d8ub+AQAAPET4AULFQs+LL0q33y6VKOFd+LF210uWeHP/AAAAHiL8AKHy4YfSzp3S4MHezXndulKpUix9AwAAvkT4AUIhLs5tb926tVStmndznjmzW/2ZMsUdEwAAgI8QfoBQWLBAWrMmdIeanouFn61bpe++83okAAAAIUX4AULBqj41akgtWng/340bSwUKSDExXo8EAAAgpAg/QLBt2CB99pm71ydTJu/nO3t2qX179v0AAADfIfwAwTZihFSypHTrreEz17b07fvvpV9+8XokAAAAIUP4AYLp99+liROlfv3ciku4aNNGypFDmjrV65EAAACEDOEHCKaXX5ayZJF69Qqvec6Xz91/ZF3fAAAAfILwAwTLsWNu+LnnHqlw4fCbZ1v6Zoed7t3r9UgAAADCM/wsXrxYHTt2VKlSpZQpUyZNSfTO8cmTJ/XII4+oevXqypMnj3OdO++8U7/99luS2zhx4oT69eunokWLOtfr1KmTduzYEZhHBISLd96R/vxTGjhQYaljR/esn+nTvR4JAABAeIafI0eOqGbNmho7duxZXzt69KhWr16tJ554wvnz008/1caNG51wk9jAgQMVExOjyZMna8mSJTp8+LA6dOig06dPX9ijAcLFmTNuo4MuXaTLLlNYKl5catiQpW8AAMA3sqb3G9q2bet8pKRAgQKaO3duksvGjBmjq666Stu2bVPZsmV14MABvfHGG5o4caJa/PfMk0mTJqlMmTKaN2+eWrdundHHAoSPmTOljRult95SWLOlb48/Lh0+LOXN6/VoAAAAInvPj4UdWx5XsGBB5/NVq1Y5y+NatWqVcB1bHletWjUtXbo0xduwZXIHDx5M+Dh06FCwhw1c+KGmV18tNWgQ3jPZubP9gkmzZ3s9EgAAgMgOP8ePH9ejjz6q2267Tfnz53cu2717t7Jnz65ChQoluW7x4sWdr6Vk2LBhTlUp/qN06dLBHDZwYVatkhYtkoYMCf+ZrFBBqlaNpW8AAMAXghZ+rLpzyy236MyZM3rZOl6dR1xcnFMhSsljjz3mVJDiP2iOgLCv+pQv7+73iQQ2zhkz7JfW65EAAABEXvix4NO1a1dt2bLF2QMUX/UxJUqUUGxsrPbt25fke/bs2eNUf1KSI0cO5zbiP/LZGSVAONq2TfrwQ7fDm53vEwls38/+/dbK0euRAAAARFb4iQ8+P//8s9PAoEiRIkm+XqdOHWXLli1JY4Rdu3Zp3bp1ahDu+yOA83nxRfcAUTvbJ1JceaVUpgxL3wAAQNRLd7c3a0u9adOmhM+turNmzRoVLlzYaVxw4403Om2uZ8yY4bSujt/HY1+3vT62Z6dHjx4aMmSIE4zs8gcffNA5Gyi++xsQkQ4elF57TerdO7I6p9lyU6v+xMS44S2V5acAAAC+Cz8rV65U06ZNEz4fPHiw8+ddd92loUOHatq0ac7ntWrVSvJ9CxYsUJMmTZy/jxw5UlmzZnUqRMeOHVPz5s01YcIEZYmUZUJASl5/3Q67kvr1i7z5sfAzZozbrKFuXa9HAwAAEBSZ4qzTQISxIVtoypUrV6pNEoCQOnXKPcy0cWPpnXdCcperd61WnfF1tKrnKtUuWfvCx1+smNSnj/R//xeoIQIAAIRVNgj6OT+AL3z8sdvsIBLaW6cka1apY0f2/QAAgKhG+AEulBVPrb118+ZSzZqRO5+29G39eunnn70eCQAAQFAQfoAL9eWXthkucqs+8Vq1knLmpPoDAACiFuEHuFBW9alSRWrTJrLnMk8eqXVrwg8AAIhahB/gQmzcKE2fbm0Po6NFtC19+/pr6b8t6gEAAKIJ4Qe4ECNHShddJN1+e3TMY4cOboj7b8t6AACAaEL4ATLqjz+kCROkvn3dvTLRoGhR6dprWfoGAACiEuEHyKhx49wqSe/e0TWHXbpI8+dLBw96PRIAAICAIvwAGXH8uDR2rHTXXW61JJp07izFxkqzZnk9EgAAgIAi/AAZ8e670t690qBB0Td/5cpJtWqx9A0AAEQdwg+QkUNNR4yQOnaULr88OufPur7NnOlWgAAAAKIE4QdIL1sO9sMPkX+o6fnCj+35WbDA65EAAAAEDOEHyMihpnXrul3RolWNGlL58ix9AwAAUYXwA6THmjVuJzSr+kTDoaapscdm1Z+pU6UzZ7weDQAAQEAQfoD0sL0+ZctKN94Y/fNm4WfXLumbb7weCQAAQEAQfoC02rlTev99acAAKWvW6J+3hg3dNt5Tpng9EgAAgIAg/ABpNWaMlDu3dO+9/pizLFmkTp0IPwAAIGoQfoC0OHxYevVV6b77pPz5/TNntvTtp5+kH3/0eiQAAAAXjPADpMWbb0qHDkn9+/trvlq0cKtdMTFejwQAAOCCEX6A8zl9Who1Sura1W124Ce5cklt2rD0DQAARAXCD3A+VvXYsiW6DzU939I36/hmDR8AAAAiGOEHSMuhpo0bS3Xq+HOuOnRwmx9Mm+b1SAAAAC4I4Qc4l6VLpWXL/Fv1MYUKSU2asPQNAABEPMIPcL6qT6VKUvv2/p4nW/r2xRfS/v1ejwQAACDDCD9AajZvdvf7DBokZfb5r0rnztKpU9Jnn3k9EgAAgAzz+Ss64Bysw1uRItKddzJNZcpIdeuy9A0AAEQ0wg+Qkr/+cs/26dPHbfcMd+nb559Lx48zGwAAICIRfoCUvPqqe77PAw8wP4nDz+HD0vz5zAkAAIhIhB8gudhYacwYqVs3qVgx5idelSpShQosfQMAABGL8AMk9/770q5d0uDBzE1imTJJXbq45/1YVQwAACDCEH6AxOLi3PbW7dpJlSszNyktfduzxz37CAAAIMIQfoDE5s2T1q7196Gm51K/vlS8OEvfAABARCL8AIlZ1adWLalpU+YlJVmySJ06uecfWZUMAAAgghB+gHjr1kmzZ7tVH9vfgtSXvtkBsOvXM0MAACCiEH6AeCNGSBdfLN18M3NyLs2bS3nzsvQNAABEHMIPYHbvlt59V+rfX8qWjTk5lxw53IYQU6YwTwAAIKIQfgAzdqyUPbvUsyfzkdalb6tWSdu2MV8AACBiEH6AI0ekceOkHj2kggWZj7Swyo9VyKZOZb4AAEDEIPwAb78t7d8vDRjAXKRVgQJSs2YsfQMAABGF8AN/O31aGjlSuuEGqXx5r0cTeUvfFi2S/vrL65EAAACkCeEH/jZ9urRpE4eaZoSd92PhccaMgD8tAAAAwUD4gb/ZoaYNG0r163s9kshTqpQ7b3R9AwAAEYLwA//65htpyRKqPheiSxdp1izp6NGAPS0AAADBQviBv6s+l13mLt9Cxvf9HDsmzZvHDAIAgLBH+IE//fqr9PHH0qBBUpYsXo8mclWqJF1xBUvfAABARCD8wJ9Gj3bbNXfv7vVIoqP6M22adOqU1yMBAAA4J8IP/MfO9Hn9dal3bylPHq9HEx3h588/pa++8nokAAAA50T4gf+89poUGyv17ev1SKJDvXpu5ze6vgEAgDBH+IG/nDwpvfiidNttUsmSXo8mOmTOLHXu7IafuDivRwMAAJAqwg/85cMPpR07pMGDvR5J9C19syYS333n9UgAAABSRfiBf1hVwtpbt2olVa/u9WiiS5MmbgMJlr4BAIAwRviBfyxcKH37LYeaBkP27FL79oQfAAAQ1gg/8A+r+ljFp2VLr0cSvUvfbNnbli1ejwQAACBFhB/4w4YN0syZ7l6fTJm8Hk10atPGrQCx9A0AAIQpwg/8YeRIqUQJ6dZbvR5J9MqXT2rRgvADAADCFuEH0W/PHumdd6R+/aQcObweTXTr0kVaskTau9frkQAAAJyF8IPo9/LLUpYs0v33ez2S6Nexo9tVb8YMr0cCAABwFsIPotuxY9JLL0l33y0VLuz1aKJf8eJSgwYsfQMAAGGJ8IPoNnGi9Oef0sCBXo/EX13f5syRjhzxeiQAAABJEH4Qvc6ckUaMcF+MV6jg9Wj8w+b7+HFp9myvRwIAAJAE4QfR67PPpJ9+4lDTULOgWa0aS98AAEDYIfwgug81rV/f3YOC0Fd/rOnByZPMPAAACBuEH0Sn1aulhQvdqg+HmnoTfvbtkxYv9uDOAQAAUkb4QfRWfcqVc8+dQejVri2VKcPSNwAAEFYIP4g+27dLH3zgdnjLmtXr0fiTVdus+jNlinvuDwAAQBgg/CD6vPiilDevdM89Xo/E3yz87NjhLkEEAAAIA4QfRJeDB6Xx46VevaR8+bwejb9de61UqBBL3wAAQNgg/CC6vPGGdPSo1K+f1yNBtmxShw5STAxzAQAAwgLhB9Hj1Clp9Gjplluk0qW9Hg2MNZxYv176+WfmAwAAeI7wg+jxySfS1q0cahpOWrWScuaUpk71eiQAAACEH0QJ6yhm7a2bNZNq1fJ6NIiXJ48bgKzrGwAAgMeo/CA6LFkirVhB1Sdcu74tXSr9/rvXIwEAAD5H+EF0sKpP5cpSmzZejwTJWdMDO/dn2jTmBgAAeIrwg8hnm+nthfXgwVJmfqTDzkUXuW2vWfoGAAA8xitFRL6RI90X2Hfc4fVIcK6lb/PmSYcOMUcAAMAzhB9Etj//lCZMkPr2dbuKITx17izFxkqff+71SAAAgI8RfhDZxo1z/+zd2+uR4FzKl5dq1mTpGwAA8BThB5Hr+HFp7FjprrukokW9Hg3ScuDpzJluBQgAAMADhB9Ervfek/bskQYN8nokSOu+n4MHpYULmS8AAOAJwg8i91DTESOkjh2lyy/3ejRIixo1pHLlWPoGAAA8Q/hBZJo9W1q/nkNNI4md9WPVH2t5feaM16MBAAA+RPhB5B5qWreue34MImvfz65d0ooVXo8EAAD4EOEHkee779wzY4YMcasJiBwNGrjNKTjwFAAAeIDwg8hje33KlpVuvNHrkSC9smZ192kRfgAAQCSEn8WLF6tjx44qVaqUMmXKpCnJXsTExcVp6NChztdz5cqlJk2aaL3tzUjkxIkT6tevn4oWLao8efKoU6dO2rFjx4U/GkS/336T3n9fGjDAfSGNyGP7fn780f0AAAAI5/Bz5MgR1axZU2PtfJUUDB8+XCNGjHC+vmLFCpUoUUItW7bUoUOHEq4zcOBAxcTEaPLkyVqyZIkOHz6sDh066PTp0xf2aBD9xoyRcuWS7r3X65Ego1q2lHLnpvoDAABCLlOclWoy+s2ZMjkh5m/2Tu5/qz5W8bFw88gjjyRUeYoXL67nnntOvXr10oEDB3TRRRdp4sSJuvnmm53r/PbbbypTpow+++wztW7d+rz3a/dz7Ngxp7JkY4BPHD4slSkj9egh/ec/8rvVu1arzvg6WtVzlWqXrK2IcsMN0s6d0rJlXo8EAABEuPRkg4Du+dmyZYt2796tVq1aJVyWI0cONW7cWEuXLnU+X7VqlU6ePJnkOhaYqlWrlnCd5CxAHTx4MOEjcRUJPvLWW5I99/37ez0SXCh7w2T5cncZIwAAQIgENPxY8DFW6UnMPo//mv2ZPXt2FSpUKNXrJDds2DAVKFAg4aN06dKBHDYigS2JHDVK6trVbXaAyNa+vZQlizR1qtcjAQAAPhKUbm/Jy01WijpfCepc13nsscec5XLxHzRH8CFrrPHLLxxqGi0KF5YaN2bfDwAAiNzwY80NTPIKzp49exKqQXad2NhY7du3L9XrJGdL5/Lnz5/wkS9fvkAOG5FyqKm9WK5Tx+uRIJAHnn7xhbR/P3MKAAAiL/yUL1/eCTdz585NuMyCzqJFi9TADjeUvXato2zZsiW5zq5du7Ru3bqE6wBJfP21+2GHmiJ6dO4snTolff651yMBAAA+ke6DUqwt9aZNm5I0OVizZo0KFy6ssmXLOp3ennnmGVWsWNH5sL/nzp1bt912m3N927PTo0cPDRkyREWKFHG+78EHH1T16tXVokWLwD46RE/Vp1Ild58Iood17rNKni1pvPVWr0cDAAB8IN3hZ+XKlWratGnC54MHD3b+vOuuuzRhwgQ9/PDDTqu5Pn36OEvb6tevrzlz5iRZqjZy5EhlzZpVXbt2da7bvHlz53uz2AZoIDHb5xMTI738spQ5KFvU4HXXt+eek44fl3Lm5LkAAADhe86PVzjnx0esrfX770vbtrmHmyI6zvmJt26dVL26NHOm1K6d16MBAAARyLNzfoCAsqYYb74p9elD8IlWVatKFSrQ9Q0AAIQE4Qfh69VX3Q3xDzzg9UgQLPbujC19s/N+7CwnAACAICL8IDzFxkpjxkjduknFink9GgSThZ89e6Rly5hnAAAQVIQfhKfJk6XffrOOGl6PBMF29dVuwLWubwAAAEFE+EH4sR4c1t7aNsBXruz1aBBs1uXRzvyxrn6R138FAABEEMIPws/8+dL333Ooqd+Wvm3eLP3wg9cjAQAAUYzwg/BjVZ9ataRE50khyjVrJuXNy9I3AAAQVIQfhJf166VZs9yqz3n6tCOK2AGnbdu6S98AAACChPCD8DJihHTxxdLNN3s9EoRaly7SqlXS9u3MPQAACArCD8LH7t3SpElS//5StmxejwahZg0u7Hm3M38AAACCgPCD8PHSS1L27FLPnl6PBF4oUMDd50XLawAAECSEH4SHo0elceOkHj2kggW9Hg287Pq2cKH01188BwAAIOAIPwgPb78t7dsnDRjg9UjgpU6dpNOnpZkzeR4AAEDAEX7gvTNnpJEjpRtukMqX93o08JI1u6hfn6VvAAAgKAg/8N706dLPP3OoKf639M3anR87xowAAICAIvwgPA41bdjQfccfsPBje8DmzmUuAABAQBF+4K0VK6Qvv6Tqg/+54gqpUiWWvgEAgIAj/MD7qs9ll7kb3YHEB55OmyadOsWcAACAgCH8wDtbt0offywNGiRlycIzgaRL3/78U1q6lFkBAAABQ/iBd0aPlvLnl7p351lAUvXqSSVLsvQNAAAEFOEH3jhwQHr9dal3bylPHp4FJJU5s9S5sxQTI8XFMTsAACAgCD/wxmuvSSdOSH378gwg9X0/v/4qff89MwQAAAKC8IPQO3nSXfJ2223u0iYgJU2auMsip0xhfgAAQEAQfhB6H30k7dghDR7M7CN12bNL7dsTfgAAQMAQfhBatn/D2lu3aiVVr87s4/xd39askbZsYaYAAMAFI/wgtBYtklav5lBTpE2bNm4FaOpUZgwAAFwwwg9Cy6o+VvFp2ZKZx/nZnp8WLVj6BgAAAoLwg9D58Udpxgx3r0+mTMw80r707csvpT/+YMYAAMAFIfwgdEaOlEqUkG69lVlH2nXs6O4Vmz6dWQMAABeE8IPQ2LtXeucdqV8/KUcOZh1pZ4H5mmtY+gYAAC4Y4Qeh8fLLUubM0v33M+PI2IGnc+ZIR44wewAAIMMIPwi+Y8ekl16S7r5bKlyYGUf6de4sHT/uBiAAAIAMIvwg+CZNcjerDxzIbCNjKlaUqlZl6RsAALgghB8E15kz0ogRbseuChWYbWSc/QxZ04OTJ5lFAACQIYQfBNfnn7strocMYaZx4ft+9u1z214DAABkAOEHwT/UtH59qUEDZhoXpnZtqXRplr4BAIAMI/wgeL79VlqwwK36cKgpLpT9DNnStylT3HN/AAAA0onwg+BWfcqVc5crAYFg4Wf7dmn1auYTAACkG+EHwbFjh/TBB26Ht6xZmWUExnXXSYUKsfQNAABkCOEHwfHii1KePNI99zDDCJxs2aQOHQg/AAAgQwg/CLxDh6Tx46VevaR8+ZhhBH7p27p10qZNzCwAAEgXwg8C7403pCNHpH79mF0EXuvWUs6cVH8AAEC6EX4QWKdOSaNGSbfc4rYlBgLNllO2bEn4AQAA6Ub4QWB9+qm0dSuHmiK4rIPg0qXS778z0wAAIM0IPwgcO3vF2ls3aybVqsXMInis6YGd+zN9OrMMAADSjPCDwPnqK+mbb6j6IPguukhq1IilbwAAIF0IPwgcq/pUriy1acOsIjRd3+bOdbsLAgAApAHhB4Hx88/S1KnS4MFSZn6sEKLwExsrzZrFdAMAgDThVSoCwzq82VKkO+5gRhEa5ctLNWuy9A0AAKQZ4QcX7s8/pbfekh54wD1/BQhl9WfmTLcCBAAAcB6EH1y4V15xO7317s1sIvTh58ABaeFCZh4AAJwX4QcX5sQJaexY6a673GVvQCjZsrdLLmHpGwAASBPCDy7Me+9Ju3dLgwYxkwg9O+vHDjy1ZhtnzvAMAACAcyL8IONsqduIEVLHjlKlSswkvFv69ttv0sqVPAMAAOCcCD/IuDlzpHXrONQU3mrYUCpShKVvAADgvAg/uLBDTevUka67jlmEd7JmdauPMTE8CwAA4JwIP8iY77+X5s51qz627wLwku37+fFH9wMAACAVhB9kjO31KVNGuvFGZhDea9lSyp3bbXwAAACQCsIP0s82l1uXtwEDpGzZmEF4L1cuqXVr9v0AAIBzIvwg/excn5w5pXvvZfYQXl3fli1zwzkAAEAKCD9InyNHpFdeke67TypQgNlD+OjQQcqSRZo2zeuRAACAMEX4Qfq89ZZ08KC75A0IJ4ULS40bs/QNAACkivCDtDt9Who5UrrpJqlsWWYO4bn07YsvpAMHvB4JAAAIQ4QfpJ110vrlFw41Rfjq3Fk6eVL67DOvRwIAAMIQ4QfpO9TUDjStW5dZQ3iyimTt2ix9AwAAKSL8IG2si9bSpVR9EBkHnlrl58QJr0cCAADCDOEHaa/6XH6521ELCPd9P4cPu3t/AAAAEiH84Py2bJE+/VQaNEjKzI8MwlzVqtJll7H0DQAAnIVXsji/UaOkQoWkO+9kthD+MmVyqz/WoMM6FAIAAPwX4Qfntm+f9MYbUp8+Uu7czBYiZ9/P779Ly5d7PRIAABBGCD84t/HjpVOnpAceYKYQOa6+WipWjKVvAAAgCcIPUhcbK734onTHHVLx4swUIkeWLFKnTlJMjBQX5/VoAABAmCD8IHUffCD99ps0eDCzhMhj+342bZJ++MHrkQAAgDBB+EHK7N1ya2/dtq1UpQqzhMjTvLmUNy9L3wAAQALCD1JmZ6R89x2HmiJy5czphvcpU7weCQAACBOEH6TMqj41a0rNmjFDiOylbytXStu3ez0SAAAQBgg/OJvtkfj8c7fqY2emAJGqXTspa1b3zB8AAOB7hB+cbcQIqVQp6eabmR1EtoIFpaZNWfoGAAAchB8kZQdDTpwo9e8vZc/O7CA6DjxduNA9sBcAAPga4QdJvfSSlC2b1LMnM4PoYOf9nD4tzZzp9UgAAIDHCD/4n6NHpZdflnr0kAoVYmYQHS6+WLrqKpa+AQAAwg8Seecdd2nQwIFMC6Kv65s18Th2zOuRAAAAD1H5gevMGWnkSOn666Xy5ZkVRN++H6tszpvn9UgAAICHCD9wzZghbdzIoaaITldcIVWqxNI3AAB8jvCD/x1q2qCBdPXVzAiid+nbtGlu8wMAAOBLAQ8/p06d0j/+8Q+VL19euXLl0qWXXqqnn35aZ2xZ1X/FxcVp6NChKlWqlHOdJk2aaP369YEeCtJq5Upp8WKqPoj+8PPHH9JXX3k9EgAAEC3h57nnntMrr7yisWPHasOGDRo+fLief/55jRkzJuE6dtmIESOc66xYsUIlSpRQy5YtdejQoUAPB2mt+lx2mdS5M/OF6GUd30qWZOkbAAA+FvDw8/XXX6tz585q3769ypUrpxtvvFGtWrXSSqsu/LfqM2rUKD3++OO6/vrrVa1aNb399ts6evSo3nvvvRRv88SJEzp48GDCByEpgLZtkz76yO3wliVLIG8ZCC+ZM7sBf8oU+4fI69EAAIBoCD+NGjXS/PnztdE2z0v67rvvtGTJErVr1875fMuWLdq9e7cTiOLlyJFDjRs31tKlS1O8zWHDhqlAgQIJH6VLlw70sP1r9Ggpf37p7ru9HgkQmqVvW7ZIa9cy2wAA+FDWQN/gI488ogMHDuiKK65QlixZdPr0af373//Wrbfe6nzdgo8pXrx4ku+zz7du3ZribT722GMaPHhwoIeKAwek116T+vaV8uRhPhD9mjZ1w75Vf2rU8Ho0AAAg0is/H3zwgSZNmuQsYVu9erWzpO0///mP82dimTJlSvK5LYdLflniylD+/PkTPvLlyxfoYfvT669Lx4+74Qfwg+zZJatCx8R4PRIAABANlZ+HHnpIjz76qG655Rbn8+rVqzsVHVu6dtdddznNDeIrQCVt8/F/7dmz56xqEILo5El3ydttt0mlSjHV8NeBpzffLP36q1SunNejAQAAkVz5scYFmW1jcSK2/C2+1bW1wLYANHfu3ISvx8bGatGiRWpg58wgND7+WNq+XWI5IfymTRu3AjR1qtcjAQAAkR5+Onbs6OzxmTlzpn799VfFxMQ4ba272Lut/13uNnDgQD3zzDPO19atW6fu3bsrd+7cus2qEAg+63Rl7a1btmTfA/zH9vw0b07LawAAfCjgy97sPJ8nnnhCffr0cZay2UGmvXr10pNPPplwnYcffljHjh1zrrNv3z7Vr19fc+bMYS9PqNiBpqtWSbNmhewugbDr+ta7t3voadGiXo8GAACESKY46zQQYWzIFp5y5cqVapMEnEOnTm673++/t1IcUxWhVu9arTrj62hVz1WqXbK218OJLNZ10va6vfmm1L2716MBAAAhygYBX/aGMPfTT9L06e5eH4IP/Moar1xzDUvfAADwGcKP34wc6b7wY38V/M6Wvs2ZY11avB4JAAAIEcKPn+zdK9l5S3auT44cXo8G8D78HDsmzZ7NMwEAgE8Qfvxk3Dh3qdv993s9EsB7FStKVaqw9A0AAB8h/PjF8ePSSy9Jd98tFSni9WiA8GAt+G0P3KlTXo8EAACEAOHHLyZNcpe9DRrk9UiA8Fr6tm+f9OWXXo8EAACEAOHHD86ckUaMkDp3lipU8Ho0QPioU0e6+GKWvgEA4BOEHz+ww0w3bJCGDPF6JEB4sT1wVv2ZMsUOCfB6NAAAIMgIP37wwgvSVVdJDRt6PRIgPPf9bNsmffut1yMBAABBRviJdmvWSF984VZ9ONQUONt110kFC7L0DQAAHyD8+KHqc8kl0vXXez0SIDxlyyZ16ED4AQDABwg/0WzHDmnyZGngQClrVq9HA4Qv2/ezdq20ebPXIwEAAEFE+IlmY8ZIefJIPXp4PRIgvLVpI+XMSfUHAIAoR/iJVocOSa++KvXsKeXL5/VogPBmbxK0bEn4AQAgyhF+otWbb0pHjkj9+3s9EiBylr599ZW0Z4/XIwEAAEFC+IlGp05Jo0ZJN98slS7t9WiAyNCxo9sRcdo0r0cCAACChPATjWJipF9/5VBTID0uusg9C8sOPAUAAFGJ8BNt7JR6a2/dtKl05ZVejwaIvANP581z98wBAICoQ/iJNkuXSsuXU/UBMqJzZ+nECWn2bOYPAIAoRPiJNlb1ueIKqW1br0cCRJ5LL5Vq1GDpGwAAUYrwE002bXJftA0eLGXmqQUy3PVtxgwpNpYJBAAgyvAKOZpYh7eiRaVu3bweCRDZ+34OHJAWLfJ6JAAAIMAIP9Hir7+kt96SHnjAPakeQMbUrCldcglL3wAAiEKEn2jxyivSmTNSnz5ejwSIbHbWjy19mzrV/Z0CAABRg/ATDaw71Zgx0p13umeVALgwFn527pRWrmQmAQCIIoSfaPD++9Lu3dKgQV6PBIgOjRpJRYqw9A0AgChD+Il0dqjpiBFShw5ui2sAFy5rVqljR8IPAABRhvAT6ebOldau5VBTIBhL3zZskH76ibkFACBKEH6i4VDT2rWlxo29HgkQXVq2lHLlchsfAACAqED4iWRW8Zkzx636WIcqAIGTO7fUurUUE8OsAgAQJQg/kcz2+pQuLd10k9cjAaL3wNNly6Rdu7weCQAACADCT6SyF2PvvisNGCBly+b1aIDo1L69lCWLNG2a1yMBAAABQPiJVGPHSjlzSvfd5/VIgOhl7a6vu46ubwAARAnCTyQ6ckQaN066916pQAGvRwNEf9e3+fOlAwe8HgkAALhAhJ9I9NZb0sGD7pI3AMEPPydPSp9/zkwDABDhCD+R5vRpaeRI6cYbpUsu8Xo0QPQrW9ZtJz9litcjAQAAF4jwE2nszJFffuFQUyDU1Z/PPpNOnGDeAQCIYISfSDzU9NprpXr1vB4J4K/wc+iQ9MUXXo8EAABcAMJPJLHzRpYupeoDhFq1atKll7L0DQCACEf4ibSqT8WKUseOXo8E8JdMmdwDT23Z6ZkzXo8GAABkEOEnUmzZIn36qTRokJSZpw3wZOnb779Ly5cz+QAARCheRUeKUaOkQoWku+7yeiSAP11zjXTRRSx9AwAgghF+IsG+fdIbb0i9e0u5c3s9GsCfsmSROnWSYmKkuDivRwMAADKA8BMJxo93D1l84AGvRwL4m+37+flnacMGr0cCAAAygPAT7mJjpRdflO64QypRwuvRAP7WvLmUJw9L3wAAiFCEn3D3wQfSb79Jgwd7PRIAOXNKbdsSfgAAiFCEn3Bm+wqsvXWbNlLVql6PBkB817cVK6QdO5gPAAAiDOEnnNlp8t99x6GmQDhp317KmtU98wcAAEQUwk84s6pPjRruPgMA4aFgQalpU5a+AQAQgQg/4eqHH6TPP3erPna6PIDwWvq2cKHbhh4AAEQMwk+4GjFCKlVKuuUWr0cCIDk77+fUKWnmTOYGAIAIQvgJR7//Lk2cKPXrJ2XP7vVoACRXurRUrx5L3wAAiDCEn3D00ktStmxSr15ejwTAuQ48nTVLOnaMOQIAIEIQfsLN0aPSyy9L99wjFSrk9WgAnGvfz5Ej0vz5zBEAABGC8BNu3nnH3UQ9cKDXIwFwLldcIV1+OUvfAACIIISfcHLmjDRypLuc5tJLvR4NgHOxLoxW/Zk2TTp9mrkCACACEH7CyYwZ0saNHGoKRAp7o2LvXmnpUq9HAgAA0oDwE26Hml5zjfsBIPxddZVUogRL3wAAiBCEn3CxcqW0eDFVHyCSZM4sde7shp+4OK9HAwAAzoPwE05VH9vnY3sIAEQO+5395Rdp7VqvRwIAAM6D8BMOtm2TPvrI7fCWJYvXowGQHs2aSfnzs/QNAIAIQPgJB6NHS/nySXff7fVIAKRX9uxSu3aEHwAAIgDhx2sHDkivvSbdf7+UN6/XowGQ0aVv334rbd3K/AEAEMYIP157/XXp+HGpXz+vRwIgo9q2lbJlo/oDAECYI/x46eRJd8nbrbdKpUp5OhQAF8D2/DRvTvgBACDMEX689PHH0vbt0uDBng4DQIAOPLV29X/+yXQCABCmCD9esTNBrL11ixZSzZqeDQNAgHTq5P5ez5jBlAIAEKYIP16xd4hXreJQUyBalCghXX01S98AAAhjhB+vWNWnalWpdWvPhgAgCF3fZs+Wjh5lagEACEOEHy/89JM0fbq71ydTJk+GACBI+36OHZPmzGF6AQAIQ4QfL4wcKRUvLt1+uyd3DyBIKlaUqlRh6RsAAGGK8BNqe/dKb78t9e0r5cgR8rsHEIKlb1bZPXWKqQYAIMwQfkJt3Dh3qVvv3iG/awAhCj9//SV9+SXTDQBAmCH8hNLx49JLL0ndu0tFioT0rgGESN260sUXs/QNAIAwRPgJpUmT3GVvgwaF9G4BhJBVdq36M2WKe+4PAAAIG4SfUDlzRhoxwj0I0TZFA4heFn62bZPWrPF6JAAAIBHCT6jMmiVt2MChpoAfNG4sFSjA0jcAAMIM4SeUh5rWqyc1ahSyuwTgkWzZpA4dpJgYngIAAMII4ScUbOnLF1+4VR8ONQX8c+Dp2rXS5s1ejwQAAPwX4SdUVZ9LLpFuuCEkdwcgDLRu7Z7lNXWq1yMBAAD/RfgJth07pMmTpQEDpKxZg353AMJE3rxSy5bs+wEAIIwQfoJtzBgpd26pR4+g3xWAMOz6tmSJtGeP1yMBAACEnyA7dEh69VWpZ08pf35+4AC/sdb2ts9v+nSvRwIAAAg/Qfbmm9KRI1L//vywAX500UVSw4YsfQMAIJqXve3cuVN33HGHihQpoty5c6tWrVpatWpVwtfj4uI0dOhQlSpVSrly5VKTJk20fv16RZVTp6RRo6SuXaUyZbweDQAvl77NnSsdPsxzAABAtIWfffv2qWHDhsqWLZs+//xz/fDDD3rhhRdUsGDBhOsMHz5cI0aM0NixY7VixQqVKFFCLVu21CFbJhYt7HyPX3/lUFPA7yz8nDjhHnQMAAA8lSnOyjAB9Oijj+qrr77Sl19+meLX7e6s4jNw4EA98sgjzmUnTpxQ8eLF9dxzz6lXr17nvQ+7jWPHjjlVo0zheG6OTek110i5ckkLFng9GkSp1btWq874OlrVc5Vql6zt9XBwLjVrStWrS5MmMU8AAARYerJBwCs/06ZNU926dXXTTTepWLFiuvLKK/Xaa68lfH3Lli3avXu3WrVqlXBZjhw51LhxYy1dujTF27RwdPDgwYSPsK8Q2eNYvpyqD4D/VX9mzJBOnmRGAADwUMDDzy+//KJx48apYsWKmj17tu6//371799f77zzjvN1Cz7GKj2J2efxX0tu2LBhKlCgQMJH6dKlFfaHmlaqJLVr5/VIAIRL+DlwQFq0yOuRAADgawEPP2fOnFHt2rX1zDPPOFUfW8Z23333OYEoseQlKStXpVameuyxx3TgwIGEjx12cGi42rTJ7ew0eLCUmWOUAEiqVUsqW5aubwAAeCzgr85LliypKlWqJLmscuXK2rZtm/N3a25gkld59uzZc1Y1KPGyuPz58yd85MuXT2HLOrwVLSp16+b1SACEC3tjx6o/9sbImTNejwYAAN8KePixTm8//fRTkss2btyoSy65xPl7+fLlnQA011q//ldsbKwWLVqkBg0aKKL99Zf01ltSnz5uswMAiNeli50DICVq+w8AACI8/AwaNEjLli1zlr1t2rRJ7733nsaPH68HHnjA+botbbNOb/b1mJgYrVu3Tt27d3fOA7rtttsU0V55RTp92g0/AJBYo0ZS4cIsfQMAwENZA32D9erVc0KN7dN5+umnnUrPqFGjdPvttydc5+GHH3ba0fXp08c5F6h+/fqaM2dOeC9nOx87x2PMGOnOO6VixbweDYBwkzWr1LGjG37+/W+vRwMAgC8F/JyfUAjLc34mTJDuvlvasEG64gqvRwMf4JyfCGTBx5a/2dLgyy/3ejQAAEQFT8/58SXLjyNGSO3bE3wApM7ON7P9gBaCAABAyBF+AsGaN6xdy6GmAM4td26pdWvCDwAAHiH8BOpQ0yuvlJo0CcjNAYhi1vJ62TJp1y6vRwIAgO8Qfi6UVXzmzHGrPuGy/whA+OrQwf23Yto0r0cCAIDvEH4ulO31KV1a6to1IE8IgChXpIh03XUsfQMAwAOEnwthy1befVfq31/Kli1gTwqAKGcd3+bPlw4e9HokAAD4CuHnQowdK+XIId13X8CeEAA+0LmzdPKk9PnnXo8EAABfIfxk1JEj0rhx0r33SgULBvRJARDlLrnEbZJCy2sAAEKK8HMhh5oeOCANGBDQJwSAj7q+zZwpnTjh9UgAAPANwk9GnD4tjRwp3XijVK5cwJ8UAD7Z93PokLRggdcjAQDANwg/GWEtajdv5lBTABlXrZp06aUsfQMAIIQIPxk91LRRI+mqqwL+hADwCTvrx5a+TZ0qnTnj9WgAAPAFwk96LV8uffUVVR8AF87Cz+7d7r8rAAAg6Ag/Gan6VKggdewYlCcEgI80aCBddBFL3wAACBHCT3ps2SJ98ok0aJCUJUvQnhQAPmH/jnTqJMXESHFxXo8GAICoR/hJj9Gj3TN9uncP2hMCwIdL337+WfrxR69HAgBA1CP8pNX+/dIbb0i9e0u5cwf1SQHgI82bS3nysPQNAIAQIPyk1fjxUmys1LdvUJ8QAD6TK5fUpo279A0AAAQV4SctLPS8+KJ0++1SiRLBfUYA+PPA0xUrpB07vB4JAABRjfCTFh9+KO3cKQ0eHPQnBIAPtWsnZc3qHqAMAACChvBzPtaBydpbt27tnsgOAIFWqJDUpAn7fgAACDLCz/ksWCCtWcOhpgCC3/XN/r3Zt4+ZBgAgSAg/52NVnxo1pBYtgvUcAIDUubN06pT02WfMBgAAQUL4OZcNG9wXIrbXJ1OmYD0HACCVLi3Vq8fSNwAAgojwcy4jRkglS0q33hrM5wAA/rf07fPPpePHmREAAIKA8JOa33+XJk6U+vWTsmcPxtwDwNnh58gRad48ZgYAgCAg/KTm5ZelLFmkXr2CMe8AcLbKlaXLL2fpGwAAQUL4ScmxY274ueceqXDhYM09ACRlewut+mPn/Zw+zewAABBghJ+UvPOO9Oef0sCBgZ5vADg3Cz9790pff81MAQAQYISf5M6ccRsddOkiXXZZoOcbAM6tfn2peHGWvgEAEASEn+RmzpQ2buRQUwDeyJzZPfMnJkaKi+NZAAAggAg/KR1qevXVUoMGgZxnAEg7qzz/8ou0bh2zBgBAABF+Elu1Slq0iKoPAG81bSrly8fSNwAAAozwk7zqU768+64rAHglRw6pXTvCDwAAAUb4ibdtm/Thh26HNzvfBwC87vq2erW0dSvPAwAAAUL4iffii+4yEzvbBwC8ZpWfbNmkqVO9HgkAAFGD8GMOHpRee03q1UvKm9fr5wQApPz5pebNWfoGAEAAEX7M669LR49K/foFcm4B4MKXvi1e7B66DAAALhjh59QpafRo6dZbpYsvvvAZBYBA6dTJPXh5xgzmFACAACD8fPyx2+xgyJBAzCcABE7Jku65Y1OmMKsAAASAv8OPnZ5u7a1tXX3Nml6PBgBSXvo2e7a7NBcAAFwQf4efL7+UVq6k6gMgvMPPsWPS3LlejwQAgIjn7/BjVZ8qVaQ2bbweCQCk7PLLpcqVWfoGAEAA+Df8bNwoTZ8uDR4sZcrk9WgA4NzVH/v3yhq0AACADPNv+Bk5UrroIun2270eCQCcW5cubrvrJUuYKQAALoA/w88ff0gTJkh9+0o5c3o9GgA4tzp13Fb8dH0DAOCC+DP8jBvnLnXr3dvrkQDA+WXOLHXu7IYf61IJAAAyxH/h5/hxaexY6a67pKJFvR4NAKR938/WrdKaNcwYAAAZ5L/w8+670t690qBBXo8EANKuSROpQAGWvgEAcAH8FX5suciIEVLHjm77WACIFNmySR06EH4AALgA/go/s2ZJP/zAoaYAInfp2/ffS7/84vVIAACISJl9d6hp3brStdd6PRIASD87kDlHDmnqVGYPAIAM8E/4sU3C8+e7VR8ONQUQifLmlVq2lGJivB4JAAARyT/hx/b6lC0r3Xij1yMBgAtb+vbVV9KePcwiAADp5I/ws3On9P770oABUtasXo8GADLOGrZY85YZM5hFAADSyR/hZ8wYKXdu6d57vR4JAFyYYsWkhg3p+gYAQAZEf/g5fFh69VXpvvuk/Pm9Hg0ABGbp25w57r9vAAAgzaI//Lz5pnTokNS/v9cjAYDAhZ8TJ6TZs5lRAADSIbrDz+nT0qhRUteubrMDAIgGl10mVa/O0jcAANIpusOPtYPdsoVDTQFEZ/XHmh6cPOn1SAAAiBiZo/5Q08aNpTp1vB4JAAQ+/OzfLy1axMwCACC/h5+lS6Vly6j6AIhOV17pLuedMsXrkQAAEDEyR3XVp1IlqX17r0cCAIGXKZNb/bHwY+f+AAAAn4afzZvd/T6DBkmZo/MhAoATfuwQ51WrmAwAANIgOpOBdXgrUkS6806vRwIAwXPttVLhwix9AwDAt+Hnr7/cs3369JFy5fJ6NAAQPFmzSh07upVuAADgw/Dz6qvu+T4PPOD1SAAgNEvffvhB2riR2QYAwFfhJzZWGjNG6tZNKlbM69EAQPC1auVWuadOZbYBAPBV+Hn/fWnXLmnwYK9HAgChkTu3G4BoeQ0AgI/Cj7V6tfbW7dpJlSt7PRoACO3St6+/lnbvZtYBAPBF+Jk3T1q7lkNNAfiPNT2wc3+mTfN6JAAAhLXoCT9W9alVS2ra1OuRAEBoWWv/665j6RsAAL4IP+vWSbNnu1Ufe/cTAPy49G3+fOngQa9HAgBA2IqO8DNihHTxxdLNN3s9EgDwRufObsfLzz/nGQAAIGrDj23wffddqX9/KVs2r0cDAN4oV0668kqWvgEAENXhZ+xYKXt2qWdPr0cCAN4vfZs5UzpxgmcCAICoCz9Hj0rjxkk9ekgFC3o9GgDwPvwcOiQtXMgzAQBA1IWf996T9u+XBgzweiQA4L3q1aXy5Vn6BgBAVIaf//xHuuEG93/2AOB31u3Sqj9Tp0pnzng9GgAAwk5kh59du6TBg70eBQCEjy5d3H8bv/nG65EAABB2Ijv8mAMHvB4BAISPBg2kokVZ+gYAQNSFn8yZpSeekOLivB4JAISHLFmkTp0IPwAARF34sTXtK1ZIc+Z4PRIACB+27+enn6QNG7weCQAAYSWyw0/8u5xUfwDgf1q0kPLkofoDAECow8+wYcOUKVMmDRw4MOGyuLg4DR06VKVKlVKuXLnUpEkTrV+/PmN3cPo01R8ASCxXLqlNG8IPAAChDD8rVqzQ+PHjVaNGjSSXDx8+XCNGjNDYsWOd65QoUUItW7bUITucLyPY+wMAZy99s45vO3cyMwAABDv8HD58WLfffrtee+01FSpUKEnVZ9SoUXr88cd1/fXXq1q1anr77bd19OhRvWeHlmZ078/27VJsbOAeAABEsvbtpaxZ3TN/AABAcMPPAw88oPbt26uFrT1PZMuWLdq9e7datWqVcFmOHDnUuHFjLV26NMXbOnHihA4ePJjwkVAhWrxYWrXK/bDGBzlyBOvhAEBksTedmjRh6RsAAMEOP5MnT9bq1aud/T7JWfAxxYsXT3K5fR7/teTsdgoUKJDwUbp0afe2Lisu1a7tfvz3MgBAoqVvCxZI+/czJQAABCP8bN++XQMGDNCkSZOUM2fOVK9nTRASs+VwyS+L99hjj+nAgQMJHzt27HAu//3w7wEePQBEETvv59Qp6bPPvB4JAADRGX5WrVqlPXv2qE6dOsqaNavzsWjRIr344ovO3+MrPsmrPPY9yatBiZfF5c+fP+EjX758gR42AESfMmWkunVZ+gYAQLDCT/PmzbV27VqtWbMm4aNu3bpO8wP7+6WXXup0d5s7d27C98TGxjoBqUGDBoEeDgD4my19+/xz6fhxr0cCAIDnsgb6Bq0qYx3cEsuTJ4+KFCmScLmd+fPMM8+oYsWKzof9PXfu3LrtttsCPRwA8LcuXaR//EOaP9/tAAcAgI8FPPykxcMPP6xjx46pT58+2rdvn+rXr685c+awnA0AAq1yZaliRXfpG+EHAOBzmeKs00CEsSFbeNp4YKNqlazl9XAAT6zetVp1xtfRqp6rVLtkbZ4FpO7hh6W335Z++03KkoWZAgBElfhskCtXrlQbqAX9nB8AQBjt+9mzR/r6a69HAgCApwg/ABDtrr7aDlOj6xsAwPcIPwAQ7TJnljp3dsNP5K10BgAgYAg/AOCXpW+bN0vr13s9EgAAPEP4AQA/aNbMziJg6RsAwNcIPwDgBzlySO3aSTExXo8EAADPEH4AwE9L31avlrZt83okAAB4gvADAH7Rtq2ULZs0darXIwEAwBOEHwDwiwIF3L0/1vUNAAAfIvwAgN+Wvi1aJP35p9cjAQAg5Ag/AOAndt7P6dPSzJlejwQAgJAj/ACAn5QsKV19NUvfAAC+RPgBAD8ufZs1Szp61OuRAAAQUoQfAPBj+Dl2TJo71+uRAAAQUoQfAPCbSpWkypVZ+gYA8B3CDwD4tfozfbp06pTXIwEAIGQIPwDg1/Bj7a6/+srrkQAAEDKEHwDwo7p1pVKlWPoGAPAVwg8A+FHmzG71JyZGiovzejQAAIQE4QcA/MrCz9at0nffeT0SAABCgvADAH7VuLFUoABL3wAAvkH4AQC/yp5dat+e8AMA8A3CDwD4fembLXvbssXrkQAAEHSEHwDwszZtpBw5qP4AAHyB8AMAfpYvn9SiBeEHAOALhB8A8Dtb+rZkibR3r9cjAQAgqAg/AOB3HTu6Z/1Mn+71SAAACCrCDwD4XfHiUsOGLH0DAEQ9wg8AwF36NmeOdPgwswEAiFqEHwCA1LmzdOKEG4AAAIhShB8AgFShglStGkvfAABRjfADAHB16eI2PTh5khkBAEQlwg8A4H/7fvbvlxYvZkYAAFGJ8AMAcF15pVSmDEvfAABRi/ADAHBlyuRWf6ZMcc/9AQAgyhB+AAD/Y+Fnxw5p1SpmBQAQdQg/AID/ue46qVAhlr4BAKIS4QcA8D9Zs0odOxJ+AABRifADADh76dv69dLPPzMzAICoQvgBACTVqpWUM6c0dSozAwCIKoQfAEBSefJIrVtLMTHMDAAgqhB+AAApL337+mtp925mBwAQNQg/AICzdejgnvszfTqzAwCIGoQfAMDZihaVrr2Wrm8AgKhC+AEApL70bd486eBBZggAEBUIPwCA1MNPbKw0axYzBACICoQfAEDKypWTatVi6RsQ7qxCW6WK+yeAcyL8AADOXf2ZOdOtAAEIP3Fx0t//Lm3Y4P5pnwNIFeEHAHDu8GN7fhYsYJaAcDRnjrRihft3+9M+B5Aqwg8AIHU1akjly7P0DQhHVuUZNMhtS2+yZJGeeILqD3AOhB8AQOrsRZVVf6ZOlc6cYaaAcHHkiHTDDe5yt/ilbqdPU/0BzoPwAwA4Nws/u3b9b2kNAG/Nni1VrepWZOOrPokNHEj1B0gF4QcAcG4NG7qHntoLLQDe+eMP6c47pTZtpIIF3YCTUoODH3+Ubr5ZOnHCi1ECYY3wAwA4N9tH0KmTFBPDTAFesIDz7rtS5crSjBnSG29I2bJJmVN5GWfVoI8+kurWlb77LtSjBcIa4QcAkLalbz/95L6jDCB0tm6V2rWT7rhDatZM+uEH6fbbpe3bU9+HZ2GpSBH3z3r1pGefdfcDASD8AADSoEULKXdulr4BoWJhZfRod2/PunXStGnSBx9IJUpIOXK4e/BWrXI+NsyapNo95fwZf5nWrHH/HDzYPf/nuuukTZt4/uB7VH4AAOeXK5e7z4B9P0DwrV0rNWjgtrHu3l1av17q2DHpdcqUkWrXdj6O1aisb0vJ+TP+MpUu7YYkq/osXizt3i3VrCm98grNEOBrhB8AQNqXvi1fLu3cyYwBwXD8uPSPf7jh5dAhackSaexYKX/+C7vdRo3cvT/dukm9e7vL6H77LVCjBiIK4QcAkDYdOrjND2z5DYDAsuqMVWaGD3cD0LffutWfQMmb1636zJzpLomrVs1dRgf4DOEHAJA2hQpJTZqw9A0IpP37pV69pMaN3SYFFkz++U93yVowWNXH9hDZPr5bbpFuvVX666/g3BcQhgg/AID0LX374gv3BRuAC2Pt46tUkd57T3rpJXeZm30ebBayrOpj9ztrllsFsj8BHyD8AADSrnNn6dQp6bPPmDUgo2y/zQ03SNdfL9Wp47av7tMn9XN7gsHOArKqj1WBqleX2rZ19wMdORK6MQAeIPwAANLOOkzZwYl0fQPSz87lGT/ere5YlceqL7aHzn6vvHLxxW7VxypPb7/t7jtautS78QBBRvgBAKR/6dvnn7udqQCkjR0S3LSpu7/HKj4bNkhdu7oVGK/ZGKzyZB3hLrpIuvZa92yg2FivRwYEHOEHAJD+8HP4sLv3B8C5nTwpPfOMW1HZsUOaN096802pcOHwm7mKFaUvv5T+9S/p+eelq65yzxwCogjhBwCQPrZkp0IFlr4B5/PNN+6enieflAYMcINE8+bhPW9Zs7pVHxu77e+zZa7Wfvv0aa9HBgQE4QcAkP4lMl26SFOn8oIISIlVRgcNkq65RsqWTVqxQnruOSl37siZryuvlFaulPr3lx591G1z/8svXo8KuGCEHwBAxpa+7dkjLVvG7AGJxbeOfvVVN/AsX+4GiUiUM6e7/G3hQnfJXo0a0muvSXFxXo8MyDDCDwAg/erXl4oXZ+kbEG/vXumOO9yW0bYs1Ja4Pfigu4ws0l13nfT9925r7J49pQ4dpF27vB4VkCGEHwBA+mXJInXq5B7SyLvA8DP7+Z80Sapc2T3/6q23pLlzpcsuU1TJl8+t+kyfLq1a5Va3PvrI61EB6Ub4AQBkfOnb5s3S+vXMIPzp11/dSk+3blLLlm776u7dw6N9dbBY1ccORrW23daq26pd+/Z5PSogzQg/AICMsa5VefOy9A3+Y53PRo6UqlZ1w79VQ95/310K6gdFi7pVn4kTpRkzpOrV3WoXEAEIPwCAjMmRQ2rXjvADf7G9L9bFbcgQ6Z57pB9+cKshfmPVLav62N6mK66QWrWS+vaVjhzxemTAORF+AAAXtvTN1v9v384sIrodPy49/rh7bo+9wP/qK2nMGHcvjJ+VKSPNmePOhR3eap3t6AKJMEb4AQBknFV+7BwTO/MHiFaLFrltnv/zH+mJJ6Rvv3WrP3BlzuxWfWxeChWSGjZ05yk2lhlC2CH8AAAyrkABqVkzt+sbEG3273dbO9sBn8WKSWvWSE8+KWXP7vXIwlOlSm5FbOhQ6dlnpauvpiEKwg7hBwBw4Uvf7J3xv/5iJhE9Pv3UbV89ebL08svS4sXu5zg3O9fIqj629M2WCtoywRdecJtEAGGA8AMAuDB23o+9sJk5k5lE5Nu5U+rSRbrhBqlePbehQe/e7tIupJ2FHtsP+MAD0kMPuRViaw0OeIzfZADAhSlVSqpfn65viGxnzkivvipVqSJ9/bX04YfuXrbSpb0eWeTKlcut+nzxhbR1q9sS25oicDAyPET4AQBcOHunfNYs6dgxZhOR56ef3H09998v3XSTe1ip/RnNh5WGks2ttQi3Q1F79JA6d5Z+/93rUcGnCD8AgMDs+zl6lIMOEVmsG9m//+12cvvtN2n+fOn1192OZQis/PmlN95wq2nLl0vVqrn7qoAQI/wAAALT5ckOOpwyhdlEZLAX4LYv5Z//lAYPdg/rtH0pCP4ewXXrpGuvdfdV3Xmn21UPCBHCDwAgMKz6M22adOoUM4rwdfiwNHCge05PjhzSypXSsGHu/hSExkUXSZ98Ir39tlsJssqbVd2AECD8AAACF37+/NM95wMIR59/LlWtKo0fLz3/vNuOuVYtr0flT7afyqo+VnGrWFFq0UIaMMBdPgtEUvgZNmyY6tWrp3z58qlYsWL629/+pp9sI2EicXFxGjp0qEqVKqVcuXKpSZMmWr9+faCHAgAIJWsLbJ3fWPqGcLN3r3T77VK7du4STVt2NWSIeyYNvFW2rLtXcPRoN5TWri2tWMGzgsgJP4sWLdIDDzygZcuWae7cuTp16pRatWqlI0eOJFxn+PDhGjFihMaOHasVK1aoRIkSatmypQ4dOhTo4QAAQsXOQbEuThZ+aGWLcGA/hxMnuoeTWjdCW2Y1e7Z06aVejwzJ/+3o319avVrKl89dkmh7sU6eZJ4Q/uFn1qxZ6t69u6pWraqaNWvqrbfe0rZt27TKDrr6b9Vn1KhRevzxx3X99derWrVqevvtt3X06FG99957gR4OACDUS9/sIENrawt4acsWqXVrd2lVq1Zu+2r7O+2rw5eF1KVLpSeecLvwWQiy5w2IpD0/Bw4ccP4sXLiw8+eWLVu0e/dupxoUL0eOHGrcuLGW2g98Ck6cOKGDBw8mfFAhAoAwPs+jQAGWvsE71nBjxAi3lfKPP0ozZkj25mqxYjwrkSBbNrfqY/uxbNXQlVdKo0a5h9AC4R5+rMozePBgNWrUyKnwGAs+pnjx4kmua5/Hfy2lfUQFChRI+CjNacsAEJ6yZ5fat5diYrweCfzou+/casGDD0r33ivZfmL7eUTkqVvXXQbXu7c0aJDUvLm0davXo0IUCGr46du3r77//nu9//77Z30tU7KyswWl5JfFe+yxx5wKUvzHjh07gjZmAEAAlr7Zi1BbdgSEwrFj0t//7p7bY3+3lSS2gd72jyByWfvxkSPdNtibN0vVq0sTJrCnEOEZfvr166dp06ZpwYIFSSo11tzAJK/y7Nmz56xqUOJlcfnz50/4sE5yAIAw1aaNWwGy8zuAYFu4UKpZU3rhBWnoULdacPXVzHs0scNnrSX29ddLd9/t/rlnj9ejQoQKePixCo5VfD799FN98cUXKl++fJKv2+cWgKwTXLzY2FinS1yDBg0CPRwAQKjZG1R2ZgctrxFM+/ZJ990nNW1qa+fdauM//uEGb0Qf20toVZ9PP5WWLHH3dPEGC8Ih/Fib60mTJjmd26xCYxUe+zhmZej/LncbOHCgnnnmGcXExGjdunVOd7jcuXPrtttuC/RwAABe6NJF+vJL93wVINDtqz/+2O0M9sEH0rhxds6GdMUVzLNf/m2xc5psb5ctsbVK0H+bawGehJ9x48Y5+3Ls4NKSJUsmfHxg/0D918MPP+wEoD59+qhu3brauXOn5syZw3I2AIgWHTu6L1Kt0xYQKDt3ui9+b7rJXdpmbZDvv989Jwb+YZU+qyy/+ab0ySdSjRrSggVejwp+XvaW0odVd+JZ9Wfo0KHatWuXjh8/7ix5i+8GBwCIkhcntpSZpW8IBGtz/MorUpUq0vLlbuXHOgpefDHz61fWJMuqPnammG2xsH1Bgwe7DS+Ac+CtEgBAcNiSlDlz3LM6gIyys3oaN3ZbHnftKv3wg3TDDRxWCle5ctIXX7hnO738stvxb9UqZgepIvwAAIIXfo4fl2bPZoaRfrGx0r/+5XZy+/13d1nTa69JhQoxm0jKlj3aWUDW6c/aY9uSyKeflk6eZKZwFsIPACA4KlRwOzKx9A3ptWyZVLu29NRT0pAhbie3Jk2YR5ybLYu0n53HHnPDT8OG0k8/MWtIgvADAAhu9ceaHvAOLNLi0CFpwAB3v5i9g2/Ll555xv07kBbZsrnB56uv3C5wtWpJY8a4+8YAwg8AIOjhx85jsbbXwLnMnClVrSq9/rr0n/9IX3/tLnkDMqJ+fenbb92zoPr3l1q1krZvZy5B5QcAEES2dKlMGZa+IXV79kh2zl+HDu7ZPXaGi3XtypqVWcOFyZ1bevFFae5cd/lb9erSxIluG374FsveAADBbUdr1R/b98MLDiRmPw9vv+0GHmuK8c470qxZbttiIJBatJDWrnXPH7vzTunGGzmA2ccIPwCA4LLwY8tNrBMTYH75xV2GZGcAtmnjHlbarRvtqxE8BQu6VZ+PPpIWLXKrQNOnM+M+RPgBAATXtde67Ynp+oZTp6QXXnC7AG7cKH32mfTuu1KxYswNQsOqPra0sl49qVMn6d57pYMHmX0fIfwAAILffcn2cxB+/G3NGvf8lYceknr2lNavl9q29XpU8KMSJaRp09zmGh984DbWWLzY61EhRAg/AIDg69LFfbd10yZm22+OHZMefVSqW1c6ccLt4jZqlJQ3r9cjg9/3I/bo4Z4hZU1Z7BypBx90D2ZGVCP8AACCz/Z35MxJ9cdvFiyQatSQRo50Dyy1c3usBTEQLi691P05HT7cPQ/IQrq1yEbUIvwAAIIvTx43ALH0zR/sbCd7V71ZM6lkSffd9ccfl7Jn93pkwNmyZHGrPhbObZnuVVdJ//63nD1qiDqEHwBA6Lq+LV0q/f47Mx7N7autm5a1r/74Y+mVV6SFC6UrrvB6ZMD5WSOO5culRx6RnnxSatTIbcyBqEL4AQCEhjU9sHX2ttEY0WfHDjfgdu0qXXON9MMPUq9eUmZeaiCCWHXy//5PWrJE+vNPqVYt6aWXOKcsivAvEgAgNC66yG17zdK36HLmjPTyy1KVKtI330iffCLFxEgXX+z1yICMswBvHQrvvlvq21dq3doN+Ih4hB8AQOhYZWDePOnQIWY9GtjhpNddJz3wgHTLLe7n11/v9aiAwO1VtKrPrFlua3Y7GPW996gCRTjCDwAgdDp3lmJj3RcTiFz2HD79tLskaM8ed1/P+PFSwYJejwwIPKv6WKv+du2k22+Xbr7ZXRKHiET4AQCETvny7oGCLH2LXHZOT+3a0r/+5XbI+v57qXFjr0cFBFehQtK777qHos6f7zZHmDmTWY9AhB8AQOgPPLUXDVY9QOSwpYr9+0sNG0q5c7ttga0dsJ3fBPiFNfRYu1a68kq3iYs19Th82OtRIR0IPwCA0O/7OXDAXSqFyDBjhlS1qvTGG9KIEW71xw4vBfyoVCn3DZxXX3WrQVbNtu5wiAiEHwBAaNmL5nLlWPoWCexMJmtk0LGj283NNn0PHOgeCgn4mbXt79nTPcDXDvK1xh92PtCJE16PDOdB+AEAhP5Fg1V/pk512yQjPA8rnTDBPazUuvNNnCh9/rkbWgH8z2WXSYsWScOGSSNHSvXquYEIYYvwAwAIPQs/v/0mrVjB7IebzZulli3d803at3fbV99xhxtaAZzNKqFW9Vm50v09sQD07LPS6dPMVhgi/AAAQs82zRctytK3cHLqlPSf/7hnmWza5FZ6rOJjh9MCSNuSXjvod8gQ6fHH3aVw9ruEsEL4AQCEXtas7j4SWl6Hh2+/lerXd9+9tu5VdqZJmzZejwqIPDlyuEvgFi+Wdu92myG88goHo4YRwg8AwLulbz/+6H7AG0ePuoHHlumcPOl2cbN9C3nz8owAF1rdtr0/3bpJvXu7B6TaUl94jvADAPCG7Sux82Ks8QFC74sv3GU6o0dLTz/tnttz1VU8E0Cg2JsIVvX57DM3CNnBqHZIKjxF+AEAeCNXLndpVUwMz0Ao/fWX1KOH1Ly5dPHF7ouyv/9dypaN5wEIhrZt3YNR7Q0fax1/663u7yE8QfgBAHi79G35cpaDhKp99Ycfuu2rP/lEGj9eWrBAqlQpJHcP+FqRIm7V5/33pVmz3CqQ/YmQI/wAALxjrZStTey0aTwLwbR9u9S5s3TzzVKjRtIPP0j33Sdl5mUAEFJW+bGGItZV0SpCth/oyBGehBDiXz0AgHcKF5YaN6brW7DYIbIvvSRVqeKeQWIVH/soVSpodwngPGy5qVV9Xn5ZeucdtyPc0qVMW4gQfgAA3urSxd18f+AAz0QgWXXn2mulvn2l225zP7/+euYYCAd2GKpVfdascc/Sst9V23sXG+v1yKIe4QcA4C1bjmVtlq0jEi7ciRPSU09JtWpJf/whLVokvfqqVLAgswuEm4oVpS+/lP7v/9xDhq3jojVHQNAQfgAA3ipTRqpTh6VvgWBLZ2rXdl9I2fk91snNTpkHEN6HPj/2mPTNN9Lp01LdutLw4e7fEXCEHwBAeHR9s8qPVS2QfgcPusvbrJmBnS2yerX0r39JOXMym0CksGrtihXSgAHSo49KTZpIv/zi9aiiDuEHABAe4efwYWn+fK9HEnlmzJCqVpUmTJBGjnSrP9ZJCkDksTcsrOpjy1V37nQPIn7tNbdVPQKC8AMA8J69eK9QgaVv6fH7727r6o4d3TNDrH2uvWNsrcMBRDZrgGDLVq1ZSc+eUocO0q5dXo8qKhB+AADh0fnIqj9Tp7LO/XzsHeC33nIPK7Uuee++6y4ZLFcuJE8VgBDJl889jHj6dGnVKvdNjo8+YvovEOEHABAeLPzs2SMtX+71SMLX5s1SixbSPfe47wRv2OC+M2zhEUB0st91q+w2bSp17SrdcYe0b5/Xo4pYhB8AQHi4+mqpWDGWvqXk1Cl3H4C982sByA5ItMMRixYN+dMEwAP2u25Vn0mT3H1+tq9v7lyeigwg/AAAwoPtVbEzf2Ji2NybmHVus7M/rBWuHYpo7wC3bu3Z0wTAI1bhvf129xwgW/baqpXb5fHIEZ6SdCD8AADCa+nbpk3SDz94PRLvHT0qPfywG3zsvI9ly6QRI9xW1gD8fTba7NnSmDHSm29KV17p/vuANCH8AADCR7Nm7ov7KVPka9by25a1vPiie17PypVSvXpejwpAuMic2a36fPutVKiQ1LCh9MQTUmys1yMLe4QfAEB4nXHRtq1/w89ff0l33+02NbB3d7//3l3uli2b1yMDEI4qVZK++kp66inp2WfdvZPr13s9qrBG+AEAhJcuXdxKx/bt8lX76smT3XX8tufJDjW0NtaXX+71yACEu6xZpX/8w+2UeeKEVKeO9MILHBuQCsIPACC8tGvnVjrszB8/2LbNPaj01lvdgw2tffW997rLWgAgrWrXds8DeuAB6aGH3GXEv/7K/CXDv6wAgPBSoIB7nkW0L32zJgZjx0pVq7rr9q3i8/HHUsmSXo8MQCQvHbaqj1WOt2519w5aUwSrLsNB+AEAhGfXt4ULo/cgP1uTb1Wefv3cAwutu509ZgAIhCZN3D2Ddihqjx7uMQK//87cEn4AAGGpUye3MmKH+UUTW4//z3+6rWmtucHixdK4cW61CwACKX9+6Y033CXEth/IDkn+9FPfzzGVHwBA+Ln4Yql+/eha+mYdmSz0PPOM9Oij0po1bvUHAIL9ZpIdjmz/3txwg3TnndL+/b6dc8IPACA82TKwWbOkY8cU0Q4edDcgN2rkvhO7erX09NPu2nwACIWLLpI++UR6+223ElSjhnuemA8RfgAA4Rt+jh6V5s1TxJo2TapSxX3BMXq0W/2xDcgAEGqZMrlVn7VrpYoV3fPEBgxw/531EcIPACA8XXGFe4BfJC59273b3Whsm4ztHVZrcNC/v5Qli9cjA+B3ZctKc+e6b8iMH++2yF6xQn5B+AEAhPeBp1Y9OXVKEcHayVpbWTusdMEC6b33pJkzpUsu8XpkAPA/do6YvSFjy3Dz5ZOuucZtxnLypKId4QcAEN5L3/74Q1q6VGFv0yapeXO3raxtMLbDSu3gUltqAgDhqHJl99/XJ56Q/v1vNwTZv11RjPADAAhf9eq5h36G89I3e6f0uefcvTxbtkizZ7t7fIoW9XpkAHB+2bK5VZ9ly6QjR9yulKNGSWfOROXsEX4AAOG9NMP2zVj4CccTyletkq66Svr7392ObtZOtlUrr0cFAOlXt667DK53b2nQILeSvXVr1M0k4QcAEP77fqyiYqeVhwvrjvTQQ27wsVBmBwj+5z9SnjxejwwAMi5XLmnkSLcN9ubNbkV7woTwfPMpgwg/AIDw1qSJez5OuCx9sy5JdlL62LHugaXWJcneMQWAaNGsmdsS+/rrpbvvdv/cs0fRgPADAAhv2bNL7dt7H37+/FPq3t1d1mbd26wS9cgj7np5AIg2BQq4VZ9PP5WWLHHf9LEDUiMc4QcAEBld39askX79NfT3bcs9Jk92uyLZ//hff1364gv3kEAA8MPS43Xr3E5w9m+xVYIOHFCkIvwAAMJfmzZuBSjU7zpu2yZ16OC2rLbld9YC1lpZ074agJ8UL+5W3+0cs08+cQ9vtrPMIhDhBwAQ/mzPT4sWUkxMaO7v9GlpzBipShW34mT/0//wQ6lEidDcPwCEm0yZ3KqPLfktX97dFzR4sHTsmCIJ4QcAEBlsucWXX7qHngaTLe9o2NA9/fzOO6UffnDbbQMApHLl3KW/I0ZIL78s1anjtv2PEIQfAEBk6NjR3X8zY0Zwbv/ECenJJ6Xatd317Ba07H/stukXAJD0DDY7C8jOBbL22FdfLT39tHvoc5gj/AAAIoMtObMNt8Ho+madjGrVkp59VnrsMXepW6NGgb8fAIgmVapIy5a5/25a+LGq+U8/KZwRfgAAkdV1aPZs6ciRwNyeVXj69JGuvVYqWNB9F/Opp6QcOQJz+wAQ7bJlc4PPV1+5/6baG0m2Z/LMGYUjwg8AIHLY3pvjx6U5cy78tqxzXNWq0sSJ7v+o48+xAACkX/360rffSvfd5+6ZtDPRtm9XuCH8AAAih52tY4HlQpa+7d4t3XST20ChZk1p/Xqpb18pS5ZAjhQA/Cd3bunFF6W5c93lb9Wru28w2X7NMEH4AQBEFgst06dLp06l7/vsf752QKkdVrpokfT++27zhLJlgzVSAPCnFi2ktWvdRjXWNfPGG6W9exUOCD8AgMjb97Nvn7R4cdq/5+ef3TMpbDmGLZ2zw0pvuYXDSgEgWGwfpVV9PvrIfcPJqkD2xpXHCD8AgMhirahLl07b0jdru2od3Ox/ulu3unuFJkyQihQJxUgBADfe6J6fVq+e1KmTdO+90sGDns0L4QcAEHmnjNvSNws/51pHvnKl+z/bxx+X+vVzl2C0bBnKkQIA4o8qmDbNXXr8wQfufsv0VO8DiPADAIg8Fn6si5B1FkrO2mAPGeJ2HrKg9M030vPPS3nyeDFSAICxf4979JC++04qU0Zq0kR68EG3g2cIEX4AAJHnuuukQoWkESPcQ/bmzXMvt2Vt1q765ZelYcPc4FOnjtejBQDEu/RSacECafhw95iBunVTfiMrSAg/AIDIPFSvfXvp00/d5gUPP+x2FGrdWipf3l3iZpfZ9QAA4SVLFrfqs2qV++/0VVdJ//53+rt4ZgDhBwAQmcqVk44dc/9u7xpaEHrjDWn+fKlCBa9HBwA4H6vUL18uPfKI9OSTUqNG0saNCibCDwAg8lijg88+S7qW3ALP3XfTvhoAIkn27NL//Z+0ZIn0559SrVrSSy8F7WBUwg8AIPLY3p7Vq//3uf1P0jbR2uUAgMhzzTXSmjXum1h9+7rLmHfsCPjdEH4AAJHFgs4TT7hrxhOzz+3yIL1bCAAIMuvKaVWfWbOk9evdM9reey+g/64TfgAAkcWqOytWSKdPJ73cPrfLqf4AQGRr3do9GLVdO+n226Wbb3aXxAUA4QcAEHlVn8yp/O/LLqf6AwCRr1Ah6d133UNRrZGNNUeYOfOCb5bwAwCIHLGx0rZt0pkzKX/dLrfDT+16AIDI17Wre3zBlVdKHTpIvXpJhw9n+OYIPwCAyJEjh7u0zc6GWLVKG2ZNUu2ecv6Mv8z5ul0PABAdSpVyqz6vvupWg2rWdLvDxVu4MDLCz8svv6zy5csrZ86cqlOnjr788ksvhwMAiARlyki1azsfx2pU1rel5PwZf5lKl/Z6hACAQLMjDXr2dDt7liwpXXedez7Q8ePSU0+Ff/j54IMPNHDgQD3++OP69ttvde2116pt27baZssZAAAAACC5yy6TFi2Shg2TRo6UKldOevTBeWSVR0aMGKEePXro3nvvdT4fNWqUZs+erXHjxmmYPZhETpw44XwkljVrVmVWZsXR0hQ+ZT//+bLn4/cAvsbvAcDvAXwoc2bp4YfdbnDNmysub17nYssFmaxCdA6Z4jxID7GxscqdO7c++ugjdenSJeHyAQMGaM2aNVpkaS6RoUOH6qlE5aySJUtq06ZNIR0zAAAAgPBlW2kyp9YN1MvKzx9//KHTp0+rePHiSS63z3fv3n3W9R977DENHjw44fODBw+qQoUK+vHHH5UvX76QjBkIN4cOHVLp0qW1Y8cOfg/gW/weAPweAHHpqOV4tuzNJC9LpVaqypEjh/OR2K5du1K8DcBvL/wMvwfwM34PAH4P4G+Z0pEHPGl4ULRoUWXJkuWsKs+ePXvOqgYBAAAAQCB4En6yZ8/utLaeO3duksvt8wYNGngxJAAAAABRzrNlb7aHp1u3bqpbt66uueYajR8/3mlzff/995/3e20J3D//+c+zlsIBfsLvAcDvAcD/D4D08aTbW+JDTocPH+7s36lWrZpGjhyp6+zAIgAAAACIpvADAAAAAFG95wcAAAAAQo3wAwAAAMAXCD8AAAAAfIHwAwAAAMAXIjL8WJe48uXLK2fOnM55QV9++aXXQwJCZvHixerYsaNKlSrlnGg8ZcoUZh++MmzYMNWrV0/58uVTsWLF9Le//U0//fST18MCQmrcuHGqUaOG8ufP73zYsSGff/45zwIQbeHngw8+0MCBA/X444/r22+/1bXXXqu2bds6ZwQBfnDkyBHVrFlTY8eO9XoogCcWLVqkBx54QMuWLXMOxz516pRatWrl/G4AflG6dGk9++yzWrlypfPRrFkzde7cWevXr/d6aEBYi7hW1/Xr11ft2rWddzziVa5c2Xnnz94NBPzEKj8xMTHOzz/gV3v37nUqQBaKOCsOfla4cGE9//zz6tGjh9dDAcJWRFV+YmNjtWrVKucdvsTs86VLl3o2LgCAdw4cOJDwwg/wo9OnT2vy5MlO9dOWvwFIXVZFkD/++MP5BS9evHiSy+3z3bt3ezYuAIA3bPHC4MGD1ahRI1WrVo2nAb6ydu1aJ+wcP35cefPmdVYCVKlSxethAWEtosJP4qU+yf/nl/wyAED069u3r77//nstWbLE66EAIVepUiWtWbNG+/fv1yeffKK77rrLWf5JAAKiJPwULVpUWbJkOavKs2fPnrOqQQCA6NavXz9NmzbN6YBom78Bv8mePbsqVKjg/L1u3bpasWKFRo8erVdffdXroQFhK3Ok/ZJba2vr7pOYfd6gQQPPxgUACB2r9lvF59NPP9UXX3zhHH0AwP3dOHHiBFMBREvlx9ja7m7dujnvcNg61/Hjxzttru+//36vhwaExOHDh7Vp06aEz7ds2eIse7DN3mXLluVZQNSzNtfvvfeepk6d6pz1E78aoECBAsqVK5fXwwNC4u9//7tz1EeZMmV06NAhp+HBwoULNWvWLJ4BIJpaXccfcjp8+HDt2rXL2eA6cuRI2pvCN+x/bk2bNj3rclvrPWHCBE/GBIRSans833rrLXXv3p0nA75g7aznz5/vvBay4G8Hnj7yyCNq2bKl10MDwlpEhh8AAAAAiOo9PwAAAACQUYQfAAAAAL5A+AEAAADgC4QfAAAAAL5A+AEAAADgC4QfAAAAAL5A+AEAAADgC4QfAAAAAL5A+AEAAADgC4QfAAAAAL5A+AEAAAAgP/h/gBCdtf97P1QAAAAASUVORK5CYII=", + "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": 34, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAzoAAAORCAYAAAA6ateZAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjgsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvwVt1zgAAAAlwSFlzAAAPYQAAD2EBqD+naQABAABJREFUeJzs3Qd4U1UbB/A3bWnLaJFNoWUIKCB7qCAICjJURBHBCSgqCEoRRUFEQFDEgYAIKiKKioiIuNgy/RiyZ0E2LRTZlF3a3u/5n3DDTZqkaZvd/+95QsnNTe7JzW1z3vue816TpmmaEBERERERBZEQXzeAiIiIiIjI3RjoEBERERFR0GGgQ0REREREQYeBDhERERERBR0GOkREREREFHQY6BARERERUdBhoENEREREREGHgQ4REREREQUdBjpERERERBR0GOgQETnw9ddfyw033BBQ+6dbt27y4IMPWu43b95c+vbt6/btDB06VOrUqeNwu57clqccPXpU7rnnHilYsGDAfe5ERJQZAx0iCkrHjh2THj16SLly5SQiIkJKly4trVu3llWrVrn8Gp07d5Z///1XAtmsWbNk+PDhLq2bnaDo1Vdflb/++kvczWQyyezZs72yLVsff/yxJCcny6ZNm7z6uS9dulS97zNnzmTreQcOHFDPQ3vdYcKECVKxYkWJjIyU+vXry4oVK9zyukREvhLmsy0TEXnQww8/LFevXpVvvvlGbrzxRvnvv/9UZ/nUqVMuv0b+/PnVzZM0TZP09HQJC/PMn+OiRYt6pL2FChVSN2/w1rb27t2rOvhVqlTJ8WvgmMuXL58Emh9//FEFuQh27rjjDvn888+lbdu2smPHDnWygIgoIGlEREHm9OnTGv68LV261Ol6Bw8e1B544AGtYMGCWlRUlPbII49oR48etTw+ZcoUrXDhwlbPmTBhgnbjjTdq+fLl02666SZt6tSplsf279+vtrtx48ZMbVmyZIm6j5+4P2/ePK1+/frqdRYvXqw1a9ZMe+mll7T+/ftrRYoU0UqVKqUNGTLEafvT0tK0l19+WbWxaNGi6rldunTR2rdvb1kHrxsfH2+5/+mnn2qVK1fWIiIitJIlS2oPP/ywWt61a1fVLuMN78dRe9G22rVrW14Xz8d2hw4dqpUoUULtz+eff167cuWKZZ3y5ctrH3/8sdV7wGvo7xOPG7eP+2C7rfT0dG3YsGFa2bJltfDwcPXY3LlzM30OP//8s9a8eXMtf/78Wq1atbSVK1c63Je228b7ceUY0ds2efJkrWLFiprJZNIyMjIyvf6BAwe0+++/X7vhhhu0AgUKaNWrV9f+/PNPS1vtbRvv6Y477rB8vvfdd5+2Z88ey2vaPg+fte6rr77Sqlatqj7nm2++WX3uztx6661az549rZbh+QMGDHD6PCIif8aha0QUdPQMAIZAXblyxe466CdiTgkyPMuWLZOFCxeqM/oYrubIL7/8IvHx8fLKK6/Itm3b1NC4p59+WpYsWZLtNr722msycuRISUhIkFq1aqllyD5hfsiaNWvk/fffl7ffflu1y5GPPvpIvvrqK5k8ebL8/fff6r2gjY6sW7dO+vTpo153165dMm/ePLnzzjvVY2PHjpVGjRrJc889p4Zv4RYXF+e0vbaQMcPj2B8//PCDasuwYcNc3idr165VP6dMmaK2r9+3hbbivX/44YeyZcsWNSTxgQcekN27d1utN2jQIDXsDUO7brrpJnnsscckLS3N4bbbtGkjnTp1UtvGNlw9Rvbs2SMzZsyQn3/+2eEwst69e6tjcfny5bJ161YZNWqUOkaxj/E8wGeibxsuXLgg/fr1U23Dvg0JCZGHHnpIMjIy1OP//POP+rlo0SL1PAxThEmTJqn3/s4776jP491335XBgwer48ue1NRUWb9+vbRq1cpqOe6vXLnS7nOIiAKCryMtIiJPmDlzpsqMREZGao0bN9YGDhyobd682fL4ggULtNDQUO3QoUOWZdu3b1dnxv/55x+7GR28znPPPWe1HZzhv/fee7Od0Zk9e7bV6+BsfJMmTayWNWzYUHv99dcdvseYmBjtvffes9y/evWqFhsb6zCjgwxHdHS0lpKSYvf1bLM/ztprL6ODrMOFCxcsyyZOnKgVKlRIZWBcyegAtvXLL7843VaZMmW0d955J9O+6tWrl9Xn8OWXX2b6bBMSEjRHsN/0bIqrxwjahizXsWPHNGdq1qypsl326PsYx4oz2AbW27p1q8PjDeLi4rRp06ZZLRs+fLjWqFEju697+PBh9Tr/+9//rJZjHyNrSUQUqJjRIaKgnaNz5MgR+e2339QZf0z4rlevnqqkBjjTjbPpxqxF9erVVbUtPGYPlmP+ghHuO1rfmQYNGmRaZpspiYmJUUUV7Dl79qw6i48sjA7zfOy9rg4VxcqXL6/mLD311FPy/fffy8WLF3PcXlu1a9eWAgUKWO6jbefPn5fExERxl5SUFPW5uvI5GPcn9iU42p/2uHqMYJ+WKFHC6WshkzZixAjVziFDhqhMVFaQPXr88cfV5xUdHa0KBcChQ4ccPuf48eNqf3fv3t2S2cQN28brOYPCBkaIO22XEREFEgY6RBS0UD0Knfu33npLDcFBCWR0Mp114rLq3DnrDGJokb7MODndHgxRs2U7iR2vqw9TcoeoqCjZsGGDGlaGjj/2C4ITV6p92Wuvq4z7x7hvnO0fV1/T2edm3J/6Y9nZn64eI67sm2effVb27dunAkwMXUPg+Mknnzh9Trt27eTkyZNqKBqGM+KmDzVzRH9/eA6G0ek3DLVcvXq13ecUL15cQkNDVXltIwSFpUqVyvK9ERH5KwY6RJRn4Gw85j3o/8eZcWO2ARWmkCmpVq2a3edjOebCGCGA0tfXz+oj06JzV+lfW4ULF1bBirHzivknmGvhDLI+LVu2VHOAkFVAieLFixerx8LDw1VFtZzavHmzXLp0yXIfbUM2ITY21rJ/jPsG2Zn9+/dnCk6ctQGZjTJlyjj9HNwlJ8eIM8gM9ezZU82lwTwvBCP6fgfj+0aAg6zRm2++KS1atFDbO336tNXr2XseApOyZcuqoKpy5cpWNz0jZAuvg2pztvPBcL9x48bZfp9ERP6C5aWJKOigk/jII4/IM888o4YvIZOBifjo3Ldv316tg84+HnviiSdkzJgxKkjo1auXNGvWzOEwrf79+6vJ6hgCh87n77//rjqtmAwOKEV9++23y3vvvScVKlSQEydOqI6qp6AwAraFcsjoCI8ePdppduaPP/5QHWAUIChSpIjMmTNHZQBuvvlm9TjajKwBgh8EKNktTY1MA4ZM4T0fPHhQZc9efPFFS6br7rvvVkMHkanA9jFBHpkEI7QBE+8xxAvXP8J69j4HvHalSpXUhURRvAABJYbiuVNOjhFHULoZ5ZpRFAEBC4JLPVjC0DdkiPD53Hvvveo4wvsuVqyYfPHFFyqgRcA1YMAAq9csWbKkWhdFJRBMIoOJABgXWMVQOQSF2CaKIOD4x3ZR3MAeLEe2Ce8LQw6xXWwTgRkRUaBiRoeIgg466bfddpu6ACQ69TVq1FCdalQUGz9+vNWFKdGhxDro1GIuBK4n4ggqcKEi1gcffCC33HKLutYIOtm40KYOVdAwHAsdRgQimBvhKcgKdOnSRQ3JQ+cUAR2qcjmCuSUIzBBwoJP92WefqWFseC+ACmUIPJDJQPbF2VwQexD8IejC/kRAiIAGnW7dwIED1WP333+/6tBjfyJYMUI1NWQSkP2oW7eu3e2gE4/3jlvNmjVVRx9zsXJz/Rt7cnKMOIKsCyqvYb+juhuCS1yzBpCBQXU6BDLIyOjB4fTp01WGDsfvyy+/rI472+zcuHHj1HGILJcexGOY3JdffqmCSuwfBGb4v6OMDqCSHII5VORD8IjqcAiEEYQREQUqEyoS+LoRRET+CB3I4cOHS1JSkq+bQkRERNnEjA4RkR2Yl4Ez2nq2g4iIiAIL5+gQEdmBeTgYUqSXoyYiIqLAwqFrREREREQUdDh0jYiIiIiIgg4DHSIiIiIiCjoMdIiIiIiIKOgw0CEiIiIioqDDQIeIiIiIiIIOAx0iIiIiIgo6DHSIiIiIiCjoMNAhIiIiIqKgw0CHiIiIiIiCDgMdIiIiIiIKOgx0iIiIiIgo6DDQISIiIiKioMNAh4iIiIiIgg4DHSIiIiIiCjoMdIiIiIiIKOgw0CEiIiIioqDDQIeIiIiIiIIOAx0iIiIiIgo6DHSIiIiIiCjoMNAhIiIiIqKgw0CHiIiIiIiCDgMdIiIiIiIKOgx0iIiIiIgo6DDQISIiIiKioMNAh4iIiIiIgg4DHSIiIiIiCjoMdIiIiIiIKOgw0CEiIiIioqDDQIeIiIiIiIIOAx0iIiIiIgo6DHSIiIiIiCjoMNAhIiIiIqKgw0CHiIiIiIiCDgMdIiIiIiIKOgx0iIiIiIgo6DDQISIiIiKioMNAh4iIiIiIgg4DHSIiIiIiCjoMdIiIiIiIKOgw0CEiIiIioqDDQIeIiIiIiIIOAx0iIiIiIgo6DHSIiIiIiCjoMNAhIiIiIqKgw0CHiIiIiIiCDgMdIiIiIiIKOgx0iIiIiIgo6DDQISIiIiKioMNAh4iIiIiIgg4DHSIiIiIiCjoMdIiIiIiIKOgw0CEiIiIioqDDQIeIiIiIiIIOAx0iIiIiIgo6DHSIiIiIiCjoMNAhIiIiIqKgw0CHiIiIiIiCDgMdIiIiIiIKOgx0iIiIiIgo6DDQISIiIiKioMNAh4iIiIiIgg4DHSIiIiIiCjoMdIiIiIiIKOgw0CEiIiIioqDDQIeIiIiIiIIOAx0iIiIiIgo6DHSIiIiIiCjoMNAhIiIiIqKgw0CHiIiIiIiCDgMdIiIiIiIKOgx0iIiIiIgo6DDQISIiIiKioMNAh4iIiIiIgg4DHSIiIiIiCjoMdIiIiIiIKOgw0CEiIiIioqDDQIeIiIiIiIIOAx0iIiIiIgo6DHSIiIiIiCjoMNAhIiIiIqKgw0CHiIiIiIiCDgMdIiIiIiIKOgx0iIiIiIgo6IRJAMjIyLD832Qy+bQtRER5iaZplv+HhPDcmO1305EjRyQqKorfTUREXoTvpnPnzkmZMmWcfjcFRKADly9f9nUTiIjyrMjISF83we8gyImLi/N1M4iI8qzExESJjY0N/EBH/6JlRoeIyLtnzXiiyT5kcvQv2ujoaB6WRERekpKSok406X+HAzrQ0YMb/GSgQ0Tku7/DlHmfIMhhoENE5H/fTRxwTUREREREQYeBDhERERERBR0GOkREREREFHQCYo6OP0hPT5erV6/6uhlERG6VL18+CQ0N5V4lIqKgw0DHhYpDR48elTNnznjnEyEi8rIbbrhBSpcuzYIDREQUVBjoZEEPckqWLCkFChRgR4CIgupEzsWLF+XYsWPqfkxMjK+bRERE5DYMdLIYrqYHOcWKFXPfXici8hP58+dXPxHs4G8dh7EREVGwYDECJ/Q5OcjkEBEFK/1vHOchEhFRMGGg4wJeKI+Ighn/xhERUTBioENEREREREGHgQ4REREREQUdBjp5SPPmzaVv376W+xUqVJAxY8a4fTvdunWTBx980OF2PbmtQDJ58mRp1aqVr5tBQQ5FBkqUKCGHDx/2dVOIiIi8ioFOHrZ27Vp5/vnnXVo3O0HR2LFj5euvvxZ3OnDggJpHsGnTJo9vyx5sOzIyUg4ePGi1HEEWgi0d/o919Ruq9bVp00a2bNli9bwrV67IW2+9JYMHD7YsmzRpkjRt2lSKFCmibi1btpR//vkn22394osvVHAZHR2t2uDqNaDQEX7yySdVmzE5vU6dOrJ+/Xq76/bo0UO9tu0xgXLsTz31lLomS8GCBaVevXoyc+bMTM//888/5bbbblMVv4oXLy4dOnSwPLZ582Z57LHHJC4uTj1erVo19TnnxM8//yzVq1eXiIgI9fOXX35xuv7ly5fVZ1izZk0JCwuzG0QvXbrU6jPWbzt37rRaD/vm5ptvVu8B7+Xll19Wr69bvny5tGvXTsqUKaOeP3v27Ezbsj2ecLv99tszfRaVKlVS20FA0759e6u2oJIaPpMhQ4Zka98REREFOgY6eRg6Re6sKIdy3BkZGVK4cGF1AUJv8Oa20MlEcJIVBDbJycnq9tdff6kO8/3335+pA16oUCEV2Bg70OjgL1myRFatWiXlypVTGZ/snonHdVHQhjfeeMPl55w+fVruuOMOyZcvn8ydO1d27NghH330kd19iw75mjVrVAfdFjrUu3btkt9++022bt2qApjOnTvLxo0brd471nv66adVUPO///1PHn/8ccvjCK5wbH733Xeyfft2GTRokAwcOFDGjx+frf2AfYhtY1vYDn526tRJtd3ZMYyAoU+fPirQdAbvU/+ccatSpYrlse+//14GDBiggouEhASVvfvxxx/V+9BduHBBateuneX7Mh5PuM2ZM8fq8fr168uUKVPUdubPn6+ujYPjBu9Fh32NNuFzJiIiyjO0AJCRkaFduHBB/fSmS5cuaTt27FA/A8358+e1p556SitYsKBWunRp7cMPP9SaNWumxcfHW9YpX7689vHHH1vuDxkyRIuLi9PCw8O1mJgY7aWXXlLL8TwcKsYbTJkyRStcuLD2+++/a9WqVdNCQ0O1ffv2aV27dtXat29veV08v3fv3uqG9YsWLaoNGjTI6vPEa/7yyy9W7wHrYhv648YbXhNst3X58mXV7hIlSmgRERHaHXfcof3zzz+Wx5csWaKev2jRIq1+/fpa/vz5tUaNGmk7d+50uj/xnP79+2shISHali1bLMuxbbRBZ9seWL58uXr+sWPHLMvatWunvfrqq063mZaWpkVFRWnffPONlhP6ez19+nSW677++utakyZNslwvKSlJK1u2rLZt27ZMxw/geJs6darVMnzeX375pfr/1atX1fP1+67q1auXdtddd2XrOZ06ddLatGljtax169bao48+6tLz7X2Wru5XHOt333231bJ+/fo53Mf2jn9nbXBm8+bN6vX27NljtbxChQra5MmTs/23zld/fwPB2bNn1b7GTyIi8r+/v8zo5FDyuWTZkLzBazdsLzv69++vMgMYqrNgwQKVLXA0DAkwvOjjjz+Wzz//XHbv3q3O2mP4DsyaNUtiY2Pl7bfftpxVNmYPRo4cKV9++aU6+45hMvZ88803KrOBs+njxo1T28JzXKUP4Vq0aJHaPtpkz2uvvaYyBtjehg0bpHLlytK6dWs5deqU1XrIEiBjsW7dOtWuZ555Jss2NG7cWGVmjGfls3L+/Hl1Jh3tMF50dsWKFdKgQQOnz8W+xXVNihYtKp6GDAza88gjj6jPsG7dumoonRGydciK4Ni65ZZb7L5OkyZNVOYC+xvrT58+XQ3Tw1A6wGeCDFVISIjaRkxMjLRt21YdO86cPXs22/sBGR3bOVA4FlauXCnuoLe/RYsW6nfNdj/g900/bvft26cyMffdd1+2t4PfXXwmN910kzz33HNqzo0jyBIhu1OxYkU1XM7o1ltvVccdERFRXhHm6wYEqs/Xfy7Dlg3z2vaGNBsiQ5sPdblzjaEyU6dOlXvuuUctQ8cfwYojhw4dUvMqMFwHw5cwbAodI0AHE1dLj4qKUusYoSM+YcIENQTHGXS6ENxg+BfmLWBYE+6j4+YKDGUCBAu2bTB28iZOnKjm7KDzDOisL1y4UO0PdNB177zzjjRr1kz9H0OM0AHF/AnMw3EGQV2tWrVUh9E47Mzojz/+UMPS9DahM4xl6NwD5szgZm/olxHaVbZs2SyHULkDOuLYd/369VND3tBBx/AtzG3p0qWLWmfUqFEqKMRyRxDkYLgYPiesi6GRCLYxh0TfDgwdOlRGjx6t5n4h4MRn8e+//9oNZhCwzJgxQ83ryQ7MFypVqpTVMtzH8tzA54l5UBgyhiDu22+/VcEOApI777xTrfPoo4/K8ePHVcCDhE1aWpq88MIL6jPNDhzHCD7Lly8v+/fvV3O67r77bhVE4bPR4XcQQT6Ot6pVq6pjPjw83Oq1cCwZhxASEREFOwY6OdSjfg954OYHxFtiCsW4vO7evXslNTVVGjVqZFmGDiQCDEfQmcLk6RtvvFHNCbj33nvVRGl0Vp1BZwod/6xgArXxooRoGzq4mEeAIMod8L4ReGGuiQ5BGwI2zF8wMrYZHVfAmXIEeM5gQjs6/q+//rrDzMBdd92lggZAZgOdUHRYETygw3rp0iX1mLOg6v3335cffvhBdZ6zCr7cAdkXZHTeffddS7YCWRa8D7xfdKxREAAZGWcXl3zzzTfVPBBk3lBkAJlBHFsIDJEhxHb0jNrDDz+s/o8MBILwn376SU2sN0IbMLkec6P0oD07bNuKoCO3F8fE75HxdwnHcmJionz44YeWQAefG4JpfPYourBnzx6Jj49Xx5qxAEVWEDTqatSooT4jHEMI+owFHJ544gm1f5DtRDswFwlzn4zHDuYeIUtIRESUVzDQyaGYqBh180fmIf/Zg4wLJlfjTDA6qb169ZIPPvhAli1bpoIFR9B5csdV1fEatu1G0JId+vNd6dwa35P+mN4Jz8qwYcPUMCJ7VbIA1cYwVE2HM/8omoDs0ogRI1S2A9t0NDEcHVUEHPgcXAki3QEdcARxRqh2hmGAgEDFNhBEkPrKK6+oABlV8RBoYmL9tm3bLEPbkOnDcz/99FP57LPPLEGlcVvITCDARlbRCAURkL1A1g8BVHYh82ebvcF7sM3yuAMCeRRP0CGYwTC/Z599Vt1HkIdsC6ocIsjTs3vZhf2HQAfDS41wfOGGgghoC6r2IZOG4hY6BN16ZpSIiCgv4BydIIRONjryq1evtixDpxpDg5xB0PLAAw+oOTQ4I40hQxhipmdujFWcssvYFv0+OmV6NgcdMOPcH3TkjGef9WE4ztqA9431/v77b6tgCfNw0Gl3FwSFL774ohri5co+QVCDjq2eyUEb0dFHR94Wgsvhw4fLvHnzspzD407IgiHQNcLxgk41oNOOEtko763fMPQOwwFR6Qv0z8u2E4/PWA8iEfQhsDFuC58RAiV9W3omB5mxrl27qsxITiDTgsDdCPPVMNfK3TAkTA/i9H1hbz8g6M7JiQjdyZMnVfbIuC17sA0MqzNCAIpMHRERUV7BjE4QwvyQ7t27q04osgc4g53VWWTMa0GnHcNsMK8C8w4Q+OidT8ylwHU/MPcAHVUMS8oOdM4w/wNDkzD86ZNPPlFD13Q4c49sAM5Go1OMoWHGrAsmY6M9CAAwzAlDcnAG2zaTgnkQeN8YqofsA4aAodOJ/eFOKEiADA3mTRiHFwE6mHomAQEm3hfmTWEooHFSPAIy44VU0VZkAqZNm6b2t/4a+Dz1OT+uwPNww3ApQLCK+VXYH/ocGMwpeeihh1TABrjGCwIAZJIw7AnD7DAPBTfAcWQspgD4fJA10YdxYW4Igk18xshKYX1kvRBsYI4S4No+PXv2VGWXETDi+EJwBxjiZgxyUEgAx4y+HxAoZCcjgaFiGEqGuUUY/vbrr7+qLJkxEMZng8wHyoDrEIBi6CcyIOfOnbNcuwnXFQJksPD5IGuF9ZDJQeZLz34BPmvMQUJgoQ9dw2eLEwl6cI9jQv+MAMcStqUfu3gcc5kwxA+BDYJBBNf43cNnp895wrwo7Cv9oqB4v/hdwfBTHX4HMPxQH5pIRESUJ2gBgOWls+/cuXPak08+qRUoUEArVaqU9v777zstL43StrfddpsWHR2tSgTffvvtqgSzbtWqVVqtWrVUyWbb8tK27JWXRnngnj17qtcvUqSINmDAAKtytYcPH9ZatWqltl2lShVtzpw5VuWlYdKkSar8NUo8OyovjfK4KC9dvHhxp+WljaWBN27cqJbt37/f4f60V/733XffVctty0sby2CjPHTDhg21mTNnWj03ISFBlbY+c+aM1edhW0YbN5T91mF/ZPVri/XtvY5xX2JbxtcFlAmvUaOG2m9Vq1bVvvjiC6fbsVde+t9//9U6dOiglSxZUh17OGZsy02npqZqr7zyiloH+6dly5aqXHVW7cf2jGzfkz0//fSTdvPNN2v58uVT7+nnn3/OtK9sX9fR56AbNWqUVqlSJS0yMlIdyygZ/eeff1q9BspoDx061LIejlv8DhiPO/1YtL3px9PFixfV7wRKpaP95cqVU48dOnTI6vembdu2al9indjYWO3xxx/PVC592rRpaj84wvLSOcPy0kRE/v3314R/xM+hiRj24675IK5CFS6cZUWpVm9MCKe8BZkTnPHPTrlqnOHHsELc8jJkNzD0EdkX44U6yT4U5ED20HhhVlf/1vnq728gSElJUZlllD9HtpKIiPzr7y/n6BD5CIZsZWdIGmA+DIa45XUYwoiJ/QxysoYCDB07drQqTEBERJQXMKPjBDM6RJQXMKOTM8zoUFbSM9JlxaEV6qLfqNTatFxTCQ1xzyUViPKyFH/J6GCoDYY7GG+OLvhIRESUXSiUggIQqASI7xhHpd+NUDofVQAxVA/lzVH+nMidZiXMkgpjK8hd39wlj896XP3EfSynbFi0CNckMP90tCyr+8G6Tl5+D0uWiEs8PVkIk31vueUWLTk52XI7duxYtl6DxQiIiDwn0IsRoHjJoEGDVLEJe4VDbO3bt08Vy0BxFrxvFDpBMQfboiFZYTECcuTnHT9rpqEmTYaK1Q3LcMPjfmvhQk2rVs3809Eyb62DvzsNG2Iyufkn7tsuS093ft+V5wTiOnn8PZytV8+lYgReCXRq166dq9dgoENE5DmBHugYuRLovPbaa6oKn1GPHj1UtcnsYKBD9qSlp2mxo2MzBTnGYCdudJxaz+O8EVh4cp25c83/12/z5plvxmUjRji/78pzAnGdPP4ezl6rVOoXgQ7OnMXExGgVKlTQOnfurO3du9fpcy5fvqwabrz54ovW2Zc/EVGwyGuBTtOmTbU+ffpYLZs1a5YWFhamyp+7+t2UmJjo0hct5S1L9i9xGOQYb1jPq0GLpwKLnK4zaJD1/a++wnUkrJfFxWlaSIj5//hZpYr5pi8zmTQtIsL6fni4+ad+H5cQwE1fhpvtOrGx5ptxnXz5rNeJidG0MmWcr1O6tPlmXCcszHqdkiU1rVSp3K1j7zklSpif52yd4sXN6/nDOrl53eLFXQ50PF6MYO7cuepidTfddJP8999/MmLECNm5c6e6KKDtBQiN83qGDRtmuY+LHeKigSwvTUTkfsFUjABtxEVgH3zwQYfr4PuoW7du6gKsupUrV8odd9whR44cURdodeW7Scfy0mT0w9Yf1JycrEzrME0eq+mgGiLmIvTpIzJunEjLluYu3223iaxdK9Kwocjq1SK33379/po15ucZ13n7bZG2ba+/5ogRIm++ef3+vHnm1zWuU66cSFKSSEaGCC4yHhdn/j+W6d3FsDCR9PTr96OizD/Pnbv+Ovhb4dnuJeVxKSKCy8b7vBhB27Zt1ZW9a9asKS1btpQ///xTLf/mm28cPgfXFUHD9VsSfsGIiIjcxDZo08/5OQvmbL+bEhMT+XlQJqiu5kyLvSLbx4tU33zk+kLjZGsciwjCExLMP3F/wQJzAAP4OXKk9X08/uuv1su6dTMHHLohQ6wbcu+91kEOHDpkDmwAPw8eFMFxbgxa0tKs7yPAMQY5wCCH/ITXr6NTsGBBFfTs3r3b4ToREREqOtNvyOhQ9uBLG9cZKVq0qPri3rRpE3ehi3Cm13g2uHnz5upii+6Gs8N16tRxuF1PbosoL0PlT4wSsL3eUFhYmMORBva+m3iRULIHJaRjo2PFJCarwAY/Mdjm3b9Eqp8QqTV2+vVBWsbAZv5864Bl7lyR1183Z1h0Q4daBzFt2og89JB1Q/77zzrgQBbGSA9oiIKY1wOdK1euSEJCgsOhAeS+Cyp+/fXX8scff0hycrLUqFGDuzaHZs2aJcOHD3dp3ewERa+++qr89ddfbv9c7JXX9dS2iAJRo0aNZOHChVbLFixYIA0aNJB8+fL5rF0UBBYtktAaNWVa9DPm+4bABj9b7xG59Voix7RunTkTY5ut6dLFOoi57z6RzZutAxPbrAoR+SbQQQcL1yvA+O81a9aoK3TjIj9du3aVPMdeHXAP2bt3rwomGzdurM5e4kylrdTUVI+3IxggK+bOrCKybWlpaVKoUCGnZ4/dyZvbIvK28+fPq6y1nrnG9w3+fwjDcK4NOeuCzuM1PXv2lIMHD0q/fv3UibevvvpKJk+erL6viHLMkJlp+vlcGdTkDWm193pgg5+fzg+VjJBrQQyCmccey5yJOX48cxATAPPjiPxR5t6vm2F+zWOPPSYnTpyQEiVKyO233y6rV6+W8uXLS55im5pu0cJjf7gwBEqfA4Wz+9jXBw4cUNkGZHbCw8Nl6tSpcsstt6ggdMeOHeoLHhfdw9DCVq1ayccffyzFixdXr3HhwgV54YUXVGYDHX6s+/vvv6uhUGPGjHE4AfiGG25Qj6M9cPjwYdWxwJnTkJAQadKkiYwdO1YqVKhgafeZM2fU8o8++kgFYo8++qh6Df0sKzKCgwcPlh9++EENNSlXrpwMGDBAnnnmGalSpYrqwBg7K9u2bZNatWqpoZKVKlXKtK/S09Olf//+qqMTGhoq3bt3t4zV12G/Gd/rhAkT1P7B+Hxclbdp06Yyc+ZM1X7sT9zwvvQOF/b9XXfdpbJsgwYNki1btsj8+fPVesi82A4rxGTnTz/9VE0Qx+/OJ598oj4zwL5CxsiYNULbsN8xPE3flw9d++LUP3s8ZtxWRkaGKgzyxRdfyPHjx6VatWry3nvvSRsMfxBRz8HE9J9//lltHycpsH9xUUWcDSfyJ+vWrVO/Yzr8nQGcUENmG1ltPegBHNtz5syRl19+Wf2u4UKj48aNU/NJibLFWDQAQ8MMmZkSf5eQj5bkE82UJqgZhW+WSicMw8fwXXP6tGvbyevZG5yomzwZZzXM94sWzbz/sP9DQ6/ft13H3nMCcZ1geJ/pbngPKJzTsaP4PNCZPn26pzcRGGxT07jfurVHNoVONjr16MSuXbtWdeB1CIAQtPzvf/9THXp0AJo1aybPPfecjB49WlVXev3116VTp06yePFi9RwEAkuWLFGBDLJDqFS0fv36bM35QOU9dEQQFCCgQoYJHW10rNHx1zvy2A4yUfi5Z88e6dy5s9oO2gc4K7tq1SrVKaldu7YKJBBEI9BCsDNlyhSrQAcBDLZpL8gBBFT62dzq1aur+3ifd999t8MOVZ8+feTbb79V2bJTp07JihUrLPv933//VcHk26h2I6KCewQN8Nprr8mHH36orsKOIBCBji0ML0PVK7x/PO/pp59WAec777zj0n7G512yZEm1H7BvjZ+9EdqK9/r5559L3bp11T544IEHVDVEBDQ6BGZoM5bh/wi88LnYyxAS+QpORjgrIIpgxxb+7m3YsMHDLaOgYq8Smn4Cc+BA8zr4m5ueLprJJD3fniPhhtFmpmALLDzZMS5Vyro9JUuKxMZ66M1SQEpB3bWssbeSExcviuzc6fr6+AXGGUZMJNRLNuL+1KnZy+pUrSpSoECWqyHLgMwLOrkITIwqV64s77//vuX+W2+9JfXq1ZN3333Xsgyd3ri4ONVpx5lOBAHIAN1zzz2WYCk2m39wEPAii/Pll19aqhqhM44O/9KlS1UWCYoUKSLjx49Xba9atarcd999qvOPQAftmTFjhhpbjwp+gKBBh6AA7+eff/6RW2+9Va5evSrfffedfPDBBw7bhSwNhrXoZ3KRsUC2xRGcFUbW6/7771f7GBkTBAr6fkfAVqBAgUz7HRD86PvQETwf+x+vgYwbnoNAE3OEsP+ygsAKsF/ttUGH4AUBLTJmMGrUKBVcYX/gDLcOQSM+Az3ThDYh0MFnQ0SUZ9gblWE8gYn5NgbI4ISjzoDJpP7vUzfcgC87c1loYGBBeQgDnZxAkFO/fs73OoKdHTtEGjTI3vPWrxepVy/n2xVs0nqbyMygg4s5HPbm+SDDgyFkxuFKmLNy8803Z2u72A46yLZzXTA8C9vRoSNtzEIgu7N161b1fwy7wmM4E2sP1kWnHIECAh0UYsDrP/LII3bXR3lYZLSM7w2ZCuwjR2eHEagguEGAhYwJbhgmhsAku/veHmSpjK+FtmH+AYbJuWu4J+bI4VohuGaIEe5vxoRXAwz70+kFRDBkkIEOEeXlYWmC4cNOLpOhc2uQY5tlAQYtRE4x0MkJnM1G0OEK/JHDJFgER8aKKTg7j9fJTlbHDWfRkY0wwlyNdu3aqTP6ttCxdVYG3AhZGtvgABkV43bq168v33//vcMsBNhWPMLr4rmACxZm5dlnn5WnnnpKzaFBxghD31wJQlyFQA3DXZCFwlwjZJAw/wVDxpBFyc6+zw49C4asjrP9nJPX1OF1bZcZPw/9Mf3zICIK2sAGGRvjsDRUOTNeBBPreBoCmz/+QKrffJ/Dt4iyjYFOTqDj7GpmBcOgkL1xlNU5ccJjc3VcgWFrmHCOSez25l1gqBs6uygggYn/cPr0aTWMzJhZQbCC7IgOARLm5Ri38+OPP6r5Izm99gSuv4RONua26EPXbN17770qoJg4caLMnTtXzQdyBEPNEMzhvd15551qGaqhIfuE9jqC/YTt4zZkyBAV4GA+U4cOHdTQMxQ4yClkVPSr0APahmybPlTQdj8jO4N5Skb4vJy1AfsfQxL//vtvy/vWrwyPTBgRUTBLz0iXFYdWSPK5ZHVxT1z3BgHMhVdelOiEXZLyyouS/90PJZ+DYWk6LSRETDk98WNvDgznpRC5HQMdT8KZn8GDr8/NsYXleBzzU3xUOrJ3794yadIkNckcc0Ew8R1DzDCnBsvRyUYlMjyG8sSlSpVSk9Jt54tg8j7m1qCqHoIRzP8wZgOeeOIJNVemffv2at4JOu6Y74JKbnhtV+b8IBhDFSUUHdCLEaBELIZSoXgCYGgbqp9h3g2CtKwqhMXHx6tqY5hsj8pjKMiAym+OYDjcvn37VICA+USo3IT3qw/lQxtRoQyFBLDvMMwvOzBMEPv7zTffVO8NgdSLL75o2d/Yz5hYjSwcto8KdLYFB9AGzGvCUDRc4BDr2cI+x2ujSAOKPSD7haGB9jJuRETBYlbCLImfFy9JKUmWZcXyF5O7dqXKT1vOqfvRW3bJqY7tBH858c2s59Btv6VdDnJsMzPA7AyRVzDQ8SRcpwYlTR39McTyxETzehER4gs4s48KbAhMWrdurco3Yy4I5p7onWsEKJgngqpcGLr1yiuvqPktRqjghWIACADwmqjqhcyIDsPHkF3BdpD5OHfunJQtW1ZatGiRrQwPMjWo+tarVy85efKkyjLhvhECBRRXQECUFbwXZEgQHOH94jmYc2P7/nTI3iA4w3A1zP9BgIRS15hbpE/eRzCGCm7IzNhmW7KC/YHXxH7EZ4FiAdiWDgEcAi0UQ0BGCkUKbLeBzwLldRGoYh/rVd+MUDkO2SC8fwSKaO9vv/1mVXGNiCjYgpyOMzoKCj232Csybq5In7Yif914UvrPE0k3iYSigAASLJevPy87pyGRS08oLtKlw/XnjXh0pLS9/XZ3vx0icoFJc1aT00+gifpwHts5BJ6Ejiw6kbjmAkr+5ggCGVz8y5EAPatje20Zf4LADe3DNZyQgSKinP+t89Xf30CAkwU44YATIzkdkkveG65WYWwFcyZHE1kzyXwBz3/KiPxZWWSY41HO2ZZcSKRCX5HUMAQ7JomNjpX98fslNMR+uX8i8tzfX2Z0PC0uznwjj0MGBNXJMJwLQ9kY5BAREWybNkbmv5ukMjjI2iDIAfzEDWd8cxLGH88vcv/jIlcNMcyxguYgB5A9SkxJVHOCmldozg+DyMsY6FDQwBAyDFtDpgkX9CQiIsJ82dj3JkixEyLvLhKJTr0e2GBgeYiLQY5xWJoxqDlcOOvnovABEXkfAx3KEZRX9jeYZ4MbERGRxYIFUmz7PvXfW23ijawvw3wdkjbFLotsL3k9Y+MqVHcjIu9joENERERBfT0czWRSF+90VEHN1aFpxmFprtDn6KgS1kTkdQx0iIiIKDigvpJ+oU/8bN9eZMMGS2DjLMDp3VZklc2UWleHpjkKcmBMmzEsREDkIwx0XMArwRNRMOPfOAoaCxaI6Bf6xE/9/1lAaemum0Um4JrJKDNtCpV07fqFl23v49o7cPLSSYfrIJODIKdDNcOkHiLyKgY6TuAq97i2ypEjR9QV6XGf5VWJKFigdDQuUnv8+HH1tw5/44gCdqja2LHOL9LtBCqx1b5aVKa3+1hKFSsnjWMby8qklaqIAObX2N7Xh6KhmpqzdVhSmsi3eB2dLKATgAtKXrx40TufCBGRl+GCvjExMXYDHV5HxzFeR8dPhqrddps5c1O5ssiePa49D9eEqlZNZOpU8/8D+Lp2RHlRCq+j4x744i9XrpykpaVJevr1lDQRUTAIDQ2VsLAwZqsp8IequRrk6AHSqVMiNWqIRER4rHlE5FscuuYCDFfLly+fuhEREZEfQLDi6lC1Tz6RaVEHZOyasbK4y2IpGF7QnMFhkEMU1BjoEBERUeCVjsYoCxeKDWghIXJu0nh557kQKVi3rkTe2lgk5Fq9aCIKatm5VhYRERGR70tHDxgglx/v7NLTTBkZcmHfLtnzX4KsPbJWKoytILMSZnm8uUTke8zoEBERUWDNx1m/XiKzcU0c44U+D6cclo4zOsrMTjNZ+pkoyDGjQ0RERIExHyfUPORMu3azB2WDcE2cjTEiG8uYb8aLfmrXntl3Xl9Jz2CRIaJgxkCHiIiIAiObc636KQpCXysKnQlCobgUkXAnMQyCncSURHUdHCIKXhy6RkRERP5bfOCll0SuXs30UJqI7Cwu0qVD5qcZh6o5g4t7ElHwYqBDRERE/lt8YOdOhx2YGidESlwUWVA5Z5uIiYrJXRuJyK9x6BoRERH5d/EBBzA6bfhiJxN2HDCJSeKi46Rpuaa5ayMR+TUGOkREROR/2ZyBA7NczZX5OPaCHBjTZoyE8no6REGNQ9eIiIjIv/z5p8jGjZmXf/KJSOPG6r9Dlw6V33b9bjUfJ9QUKuna9ainWP5i6ufJSycty2KjY1WQ06Ganck9RBRUGOgQERGRfxQe6NNH5OOPRbp2zfw4SktPnSrSu7eIySTLtp6TUk3byOgmr6uiAphv0zi2saxMWmm5rw9NQ3U14zJmcojyBpOmIT/s39DES5cuSf78+cVkclRQkoiI+PfXe1JSUqRw4cJy9uxZiY6O5sGXG+iK3HabeU5OkSIip087XnfePDl1Z0Mp+UFJ+fTeT6VHgx7c90R5TIqLf385R4eIiIj8p/CAsyAnJERdOPTPXX+oIWrtbm7ntSYSUeBhoENERES+zeYMHmwOYrKSkSGSmChzdsyWW8veKmWiynijhUQUoDhHh4iIiPyujHT6uLGysWKknLhwQooXLC61S9aWzcc2y4HwizJ77UAZ1HSQT5pLRIGDgQ4RERH5LpszKHPAkhESIls/eFUaPnMV9aDtVlQb/894qV6iOqunEZFDHLpGREREvqmyVr68yPr1mR4KyciQOolXpdXe68uMQQ4cu3BMOs7oKLMSZnmjtUQUgBjoEBERkW8uCJqY6HAVhDXDF2NdBy9x7YG+8/pKekY2rhhKRHkGAx0iIiLy/rycdeucrhIqInEpIuFOYhgEO4kpieo6OUREtjhHh4iIiHw3LwfV1qpWVRcDnbdnvryx+PpjxwqKpLrQU8HFQImIbDHQISIiIu9mc4zzclAyescOkRMnJPK2xrJxZ/ZfMiYqxq1NJKLgwKFrRERE5L1sziuvZF4eGqqupdM0ronERseKSS+1lgWsFxcdJ03LNXV/W4ko4DHQISIiIs9XWKteXeTdd0W2b8/8eHq6upZO6KK/ZGybsS69pB4MjWkzRkJDMKOHiMgaAx0iIiLybBbnjTdEEhJEhg1zvB7m6gweLB2qPiQjW4zM9DCuo2OEzM/MTjN5HR0icohzdIiIiMizc3LWrjX//+pVx+thrg7KTaemSsqVFCkSWUR+euQndb0czMFpHNtYViatVIUHcB/D1ZjJISJnGOgQERGR57I5gweb5+BgeBpUqyby7bciJjvzcEqWFImIkF93/Srtbm4nLW5sYfVw8wrN+UkRkcsY6BAREZHnszk6DGE7cUKkdWu7T9l7aq9sP75d3r7rbX4qRJQrnKNDREREns3m2Kmwph63A9mciNAIaVWpFT8VIsoVBjpERETkuWyOPmTNpsKaetxBoNPyxpZSKLwQPxUiyhUOXSMiIiK3Sc9IlxUHl0vNV3pJUZNJTHYyN1pIiJx7LV7+jHlLYqLLWAoN/HvyX1lxcIVMvG8iPxEiyjUGOkREROQWsxJmSfy8eKmxLkl+3yFisj86TUwZGXJh3y7p9tMTkhpmLh2drl3P/AxbNkxKFCzB0tFElCsMdIiIiMgtQU7HGR1F0zT5ealI2LUg54W2ImviMq9/rKCoIAeMQQ4cPX9UvRavk0NEucFAh4iIiHI9XA2ZHE00abVX5NYj1x/bV0xkY5nsvR5exyQm6Tuvr7S/uT2vl0NEOcJiBERERJQrKw6tkKSUJEQoMnyxSMa15Wkm830szy4EO4kpieq1iYhygoEOERER5UryuWT1U8/m6J0LDF/DfSzP7WsTEWUXAx0iIiLKlZiomEzZHHFDVsfy2kREgRDojBw5Ukwmk/Tt29fbmyYioiA2YcIEqVixokRGRkr9+vVlxQrnQ56+//57qV27thQoUEBiYmLk6aeflpMnT3qtvcGkabmm8kRycatsjuQyq4M5OnHRceq1iYj8PtBZu3atfPHFF1KrVi1vbpaIiILcjz/+qE6gDRo0SDZu3ChNmzaVtm3byqFDh+yu//fff0uXLl2ke/fusn37dvnpp5/Ud9Szzz7r9bYHg1BTiIxbWdhh0gY11bKT1UGQA2PajGEhAiLy/0Dn/Pnz8sQTT8ikSZOkSJEi3tosERHlAaNHj1ZBCwKVatWqyZgxYyQuLk4mTrR/4cnVq1dLhQoVpE+fPioL1KRJE+nRo4esW7fO620PCqmpUvTo2WvhSWahIhKXIhKeLlIsfzF1s3rchDWui42OZWlpIgqc8tK9e/eW++67T1q2bCkjRoxwuu6VK1fUzSgsjJWwiYgos9TUVFm/fr0MGDDAanmrVq1k5cqVdndZ48aNVfZnzpw5KvNz7NgxmTlzpvqecvW7KSUlhR8HLFok0qePSO3acmn139LxyXAZcu/7curSKSlesLjULllbNh/bLEkRqTK/Sg3LUDRUU0OhAczBaRzbWFYmrbTcxzqhIdbBDxFRdnklepg+fbps2LBBDQtwdR7PsGHDLPejoqLk6NGj4g34I/v5+s+lR/0enABJRBQATpw4Ienp6VKqVCmr5bjv6LsDgQ7m6HTu3FkuX74saWlp8sADD8gnn3zi8ncTYSiaJvLGGyIJCeo2oX1JKdGmrdz6QE+r3dNAbpMGNjuseYXmTu8TEfn90LXExESJj4+X7777Tk0QdcXAgQPl7NmzlltSUpJ4S/L5ZBm2bJj6SUREgQOFbow0Tcu0TLdjxw41bO2tt95S2aB58+bJ/v37pWdP6w66s+8mfL/leQsWYAKuZTcsz39MXeCTiChPZHTwBYIhAaiAo8OZt+XLl8v48ePVMIDQUOv0dEREhLoZv6wuXbrk6aYSEVEAKl68uPoesc3e4LvHNstjzM7ccccd0r9/f3UfRXIKFiyoihhgeDWqsNmy/W7K85DNGTxYJCREJCNDNJPI4BUmqXpjyzy/a4gojwQ6LVq0kK1bt1otQwnPqlWryuuvv54pyCEiIsqO8PBwdTJt4cKF8tBDD1mW43779vazCxcvXsw091P/PsLJNbIvPSPdMrem+oZEqW3I5pg0kQaHNZGlK0Vat+YuJKLgD3Qwv6ZGjRpWy3DWrFixYpmWExER5US/fv3kqaeekgYNGkijRo3UpQxQWlofioZhZ4cPH5apU6eq++3atZPnnntOVWVr3bq1JCcnq/LUt956q5QpU4Yfgh2zEmZJ/Lx4SUpJUmWi10wyXwwU18nR4X7Kq72laKvdGEvI/UhEPsVSZkREFPBQVAAX+3z77bdV0IITaaioVr58efU4lhmvqdOtWzc5d+6cGkL9yiuvyA033CB33323jBo1yofvwr+DnI4zOop27UI4uPgnLgJqC0FP0W175e8v35Imzw33fkOJiAxMWgDk6PU5Ovnz53c4sdRdNiRvkPpf1Jf1z6+XejH1PLotIiJ/582/v4EG5aULFy6sChNER0dLMA9XqzC2gjmTA9eyOfWPmK+Pk2l9Edkal09q7r8ooaE8n0pEvvv767ULhhIREVHgwZwcS5CDOVHpIuXO2g9yAMtLnb4qf+9Z7LU2EhHZw1MtRERE5BAKDxilhok0fE5kydcih6NFXm6T+TnHCop8kHqSe5WIfIqBDhERETkUE2VdarvFXpHJv4qUTxHp/qDIxjKuPY+IyNs4dI2IiIgcalquqcRGx4pJTGp+zrt/mYOc8/lElpfLvD7Wi4uOU88jIvIlBjpERETkUGhIqIxtMzZTtbVCV0Va7bNeVwVDIjKmzRj1PCIiX2KgQ0RERE51qNZBvn/oOxm+WCTDcM2cEag3YKjdiszPzE4z1fpERL7GOTpERESUpRvX7rG6dg6umdPwiMimiqNkR704NScHw9WYySEif8FAh4iIiJzTNCn53ieSYRIJMV59LzRUan86U2qvWSPC6ywRkZ/h0DUiIiJyKmP+PKm454R1kAPp6SJr14osWMA9SER+h4EOEREROaZpcvH1VyxzczL3JEJEBg9W6xER+RMGOkRERORYaqpoiQcddxgyMkQSE9V6RET+hHN0iIiIyK70jHRZkbxKhnYvKPPHXJJ8z/eUkO7PZl6xZEmRiAjuRSLyKwx0iIiIKJNZCbMkfl68JKUkyQs7RELTRRqWnC2D8rdk+WgiCggcukZERESZgpyOMzqqIKfFXpHR80VWx4pslKNqOR4nIvJ3DHSIiIjIargaMjkargSqiYydKxKZLlLiAuoNmAsO9J3XV61HROTPGOgQERGRxYpDK1QmB1rtFbnlhHn5zafM9xEAJaYkqvWIiPwZAx0iIiKySD6XbP6PJvLuX+qHkmYSGb7YvNxqPSIiP8VAh4iIiCxiomLUT2Rv6ieLmK4tD9NEbj1iXm5cj4jIXzHQISIiIoum5ZpKbFRZlb2xvUiontWJi4pV6xER+TMGOkRERGQRGhIqP0Q9rbI3tp0EPaszLaqbWo+IyJ8x0CEiIqLrNE2aTJpvmZtjSzOZ1ONYj4jInzHQISIioutSU0U7dMgyN8eWCQFOYqJaj4jIn4X5ugFERETkRyIiZOv4wVLrkRflwOs9pEKn5zOvU7KkWo+IyJ8x0CEiIiIryb//IDdGmCTuzQ9ECkVx7xBRQOLQNSIiIrpO06TKvH9kS6NKEsogh4gCGDM6REREJOkZ6bLi0ApJXPKrPHXsqhwd8Tj3ChEFNGZ0iIiI8rhZCbOkwtgKMuKtu6Rt7zFyOkLksTNfquVERIGKgQ4REVEehmCm44yOknQ2SUb+JVL8kkhqmEjihSNqOYMdIgpUDHSIiIjy8HC1+HnxookmrfaKNDxiXl7qgsg9e83/7zuvr1qPiCjQMNAhIiLKozAnJyklSXB10OGLRTKuLU8zme9rmiaJKYlqPSKiQMNAh4iIKI9KPpesfiKbc+uR652CMM18H8uN6xERBRIGOkRERHlUTFSMJZuTbrJ+TM/q4HG1HhFRgGGgQ0RElEc1LddUnkgurrI3oZr1Y3pWB49jPSKiQMNAh4iIKI8KNYXIuJWFxVGpASzH41iPiCjQ8C8XERFRXpWaKkWPn5dQBw9jedETF9R6RESBJszXDSAiIiIfiYgQWbtWkge8KIV++k3mf/6qFCpQRIoXLC51S9eV0JBQkZIlzesREQUYBjpERER5WVycpP+zWhbWiJQO3UZJCIepEVGQ4NA1IiKiPEzbv19i9xyT4/c0ZpBDREGFgQ4REVEe9t/3X8iVUJHynXv6uilERG7FQIeIiCgPS/35R1lSKVSa12rn66YQEbkV5+gQEREFufSMdFlxaIUkn0tWF//Ur4uT8NkIuWXTflnZqqzkC8nn62YSEbkVAx0iIqIgNithlsTPi5eklCTLsmL5i4lomvzz3ikxicjNmw9LhTHlZWzbcdKhWgeftpeIyF04dI2IiCiIg5yOMzpaBTlw8tJJqb/tlNx4xny/7n8it2w8rNbFc4iIggEDHSIioiAdroZMjiZa5gc1kXf+Uj+UNJPI24uxXJO+8/qq5xIRBToGOkREREEIc3JsMzm6VntFGiSLGrYGYZrIrUdE7tkrkpiSqJ5LRBToGOgQEREFIRQesEsTGb5YJMNmMbI6WI7HHT6XiCiAsBgBERFREEJ1NUfZHGRvbOlZHTzu6LlERIGEGR0iIqIghBLSsdGxYrIMUHOczdFhZs6oZfmkaVwTbzWTiMhjmNEhIiLKhYyMDLl8+bJf7sNPW30q8XPj1f9RlCA8XSSmsEiqk0vmVCwSLVcvXJSr4eHeaygRkUG+fPkkNDRUcouBDhERUQ5omibPPPOMHD58WEJC/HOARJWQKjKz1Uw5efGkZGjmPM7OJigvLWLSRE7mv75uaEiIREcUlsjwAiKHD/uu0UREInLDDTdI6dKlxWQyZKWziYEOERFRDpw+fVoee+wxKVmypBQqVChXX8aeduLCCTl64aiUjSor4SFhUmDPIZGSJeRi4YKSmp4q4aHhUiBfAb9+D0SUd04iXbx4UY4dO6bux8TkfM4gAx0iIqJsSk9PlwsXLqgzjkWLFnXLEAtPyriSIZGRkRJTJEYkJUVdL0eKl5D8+Q0pHSIiP6H/bUKwg5NJOf0b65+5diIiIj929epVCSSX0y5LZFik+c7ZsxgALxJ57T4RkR8qUKBArv/eejzQmThxotSqVUuio6PVrVGjRjJ37lxPb5aIiPKYCRMmSMWKFVXmon79+rJihfOLXl65ckUGDRok5cuXl4iICKlUqZJ89dVXEowyBTqFC4twmBoR+TF3DKX1+NC12NhYee+996Ry5crq/jfffCPt27eXjRs3yi233OLpzRMRUR7w448/St++fVWwc8cdd8jnn38ubdu2lR07dki5cuXsPqdTp07y33//yeTJk9V3FIZIpKWlSbBJz0hX83BUoHPliggqxJUp4+tmERF5nMcDnXbt2lndf+edd1SWZ/Xq1Q4DHZxlw80oLIzTiYiIyL7Ro0dL9+7d5dlnn1X3x4wZI/Pnz1ffNyNHjsy0/rx582TZsmWyb98+NccGKlSo4HT3Gr+bUlNTVVnpQHAl3dxmFeicTTEvjI72baOIiLwgxNuTN6dPn64mcGIImyP4UipcuLDlhqwQERGRPQg61q9fL61atbJajvsrV660+5zffvtNGjRoIO+//76ULVtWbrrpJnn11Vfl0qVLLn034bkoK+2ObMvSA0vlh60/qJ+474lha5D/4lWRxETM8sXZQ/EnBw4cUMNUNm3a5Bevk5WdO3fK7bffroZJ1qlTx6PbCjb4fGbPnu3xzwsnLnDCw952Pb0tT0H7kX3GxHxksH2pefPmPm+DK7zyl27r1q0qsMEF1VCC85dffpHq1as7XH/gwIHSr18/bzSNiIgC3IkTJ9SJtFKlSlktx/2jR4/afQ4yOX///bfqqOI7Ca/Rq1cvOXXqlMN5OsbvJgRXycnJmUYfZMeshFkSPy9eklKSLMtio2NlbJux0qFaB3FnoBMWEiahR5JxdVMRDM9D1bUAn6PTrVs3OXPmjFXnNS4uTn0uxYsX9+i2hwwZIgULFpRdu3apfg3lTHY+LwRFmIOHqQ+uBJdr165Vn5E7ff3116pzj+PO09uyp0ePHvL0009Lnz59JCoqSrxh6dKlctddd6ly+qgyqZs1a5a6qKe/80qgc/PNN6toHQfGzz//LF27dlVDBhwFO5gUipuxnrazs2xERES2E1fx3eFoMiuGneGx77//XmVo9OFvHTt2lE8//dRu2WXjdxNO3OXmIqEIcjrO6CiaaFbLD6ccVstndprptmAHgU6xq/lELl40L0AFI5SYvva+gwnOdOMCg562d+9eue+++1QhC0dQKSoQOoLB9nnhJER4eLiUKFFCvMUb2zp//ryaR9i6dWsp4wdz7IpeG/Lr77wydA0HHFJtSPUj9V+7dm0ZO3asNzZNRERBDmeD0WGyzd6gU2Cb5dHhAnQYsqYHOVCtWjUVHCUlXc+weAKGpyGTYxvkgL6s77y+bhvGdvnqZSl55qolwBv1zTdSuWZNFbShUAPmzupnbhH8Gc9W4yQlluFsun5GG2d1//jjD3USE+VfERxiSDqKDWEIT5EiReSll15SWTZnw4bwOng9u/soPV3NucIZfASd2Jax3zB06FC1vV9//VW9Nm5ov3EoFN4rhr5/9tlnVq+9YcMGtQ6yenD27Fl5/vnn1bU6UB327rvvls2bNzvcn3guhkq+/fbb6v9oi77dGTNmqCE9yBR+9913av0pU6aoYwvLqlatqgpmGP3zzz9St25d9Tj6ScgwGodz6fvcCPvSNoj//fffVbVBvM6NN94ow4YNsyqugfW//PJLeeihh9TnVqVKFTWE02j79u0qgMN+QMagadOmKqhbvny5Ctpsf8deeeUVufPOOx3uq927d6vH0Sac3F64cKHV47ZD15A1eOKJJ1TggM8dbcT+AxwLgH2F52A/65m9Bx98UPUvEQBgGKqj4WTIHqFICV4br/fTTz9ZHsvq+MfjyKbgeNGPOXz29rZ16NAhVXgL2T7sS73wiQ7PQ1bq22+/Vc/F36FHH31Uzp07Z3c/Ytt6BgfHp368669jhHYY5xt2u7Z/PvzwQ/V3r1ixYtK7d2+rks3ITL/22msqw4a/C9jvKNKC941sDuD3GtvF69kbuobPrkuXLmo9HF/Yz/j8dfpxjLmT+H3AvmnTpo36TDzJJ4N08UWSm3Q/ERGR8WQaOnjoRKETp8N9dDbsQWU2dHJwllQfevTvv/+qLE1O54VevHpRdp7YmeV6646ssxquZi/YSUxJlMkbJ0uDMg2yfL2qxatKgXwF7L+Wpkn4hUsSccUcQA389FOZNHu2fPzyy9LkwQcl+fx5Nd8kO3DF8nHjxqk5t+iYdejQQd3QiZkzZ44KIB5++GFp0qSJdO7cWXJCD1IQOCCQxVwrBCPoqKHTiPlUCQkJkpKSYukI4wzzkSNHLK+BzxKdR2TtevbsaVk+bdo0NZwewQD2Dzr2eC7ajg4nKva1aNFCHQ/2zlqjY9ayZUvVSUM7cPxg6CO8/vrr8tFHH6k2ocM4adIkNcxt/PjxqoOOYVfPPfecGuaE0S0IEO+//37VeUVgtH//fomPj8/2/kLn8cknn1Sfix6cYH8Btq9D8IN5aR988IF88sknKqg4ePCgep+Yc4agBB3YxYsXqw76//73PxUsYTn2Fzrm/fv3V6+F5WgzKus6+gxxXODzQwEqfFZZzekYPHiwqpSIy5DgeXv27LGM6EFAeOutt8qiRYtUMSv83uv++usv1V78zuMzdfb6aC+CZryXxx57TGrUqKE63llp3LixCiLeeustNWQR7A1bxPYRWOAzxugl7CcMi8XvAoITHT4jBKw4aYAgAcc12qafeLDdNraJgB8jo3Afn5nx9ZxZsmSJ+t3BT+xTtAUBEo5FQICyatUqdfwgGYHjEMc0Ah9sD7/P2D72saOLDCMAQmCD4Bnr4Xfh3nvvVZ+nntnE3w4EXNj3+P3EMYvfIfyOeozmYQMHDtSWL1+u7d+/X9uyZYv2xhtvaCEhIdqCBQtcfo2MjAztwoUL6qenrT+yXpOhon4SEeV13vz7mxvTp0/X8uXLp02ePFnbsWOH1rdvX61gwYLagQMH1OMDBgzQnnrqKcv6586d02JjY7WOHTtq27dv15YtW6ZVqVJFe/bZZ13a3qVLl7Rt27Zpa9eu1dLS0qy+P7x9c/Z9deXqZe38prVaxtq1WsrSpVpEeLg2adAgTVu7VtN27MAHbFl3yZIl6CFqp0+ftizbuHGjWobvcJgyZYq6v2fPHss6PXr00AoUKKD2qa5169ZquQ7P+eWXX6zaVrhwYfV6gNfHOtieI7169dIefvhhy/2uXbtq7du3t1rH9nU2bNigmUwmy3GQnp6ulS1bVvv000/V/b/++kuLjo7WLl++bPU6lSpV0j7//HOHbaldu7Y2ZMiQTNsdM2aM1XpxcXHatGnTrJYNHz5ca9Sokfo/tlG0aFH1O6abOHGi1XvAPsK+MsK+NHbhmjZtqr377rtW63z77bdaTEyM5T7Wf/PNNy33z58/r/bN3LlzLf21ihUraqmpqXbf86hRo7Rq1apZ7s+ePVsrVKiQeh175s+fr4WGhmqJiYmWZdiW8Viw/bzatWunPf3003Zfz9ExguOgVKlS2pUrV6yWly9fXvv444+t3n/Pnj2t1rntttu0F154IVvHv+1nYbst9G/xvg8dOmR5HH9j8Dr//POPuo9jB78zKSkplnX69++v2uMI2oXXQDt1eB0ci0ZoB9pj3D/ly5e3/J2CRx55ROvcubP6/65du9TrLly40O527e0XaNasmRYfH6/+/++//6p1/ve//1keP3HihJY/f35txowZDv924PcQn52zv7P4e46fts6ePateDz+d8XhGB6m6p556Sp0BwZkSXDwUZT3vueceT2+aiIjyCJyhPHnypBpOhO8bnKXFGXp9DgWWYTiJDmdicfYXQ6wwXAjDOXBGdcSIETluAzIr659f71JGp8cfPbJc7/P7P3c5o+PI1TOnpOC1ESoJBw7IldRUadGwoXnBhQs5mquDYSm4uKoOwwMxVMZ4dhvLMHQwNzDkDEOtkHHAWX3MvchuhTNkUTBc7IcffpABAwaoM+xoFz5rwBA0ZPXw+Rthezjjnl04lnTHjx+XxMRENQRPP3MOOMOvD5lEVgpn0PUrwIOzqrSO4H1gQrwxG4Dhf5hLhrPo+uujD6ZDxgHDofTPCcO0kA1yNK8IZ+zffPNNlZ1BxTkU7cB+dDQJH+8NQyONGdKs3tsLL7ygsgcYXoiqiciMIHuRlZo1a1pleByx3T7uu7viG943MiG46TBsDxlPPNbw2u8ffmeMBQWQccnt74wjt9xyixrea9wWCoUB3j8ea9asWY5fH+8Ll4G57bbbLMvwO4UMFB5z9LfDk+9Z5/FAB2P8iIiIPA3DQ3Czx95cEHSAbecM5AaGj9WLqZflerVL1Zbhy4erwgP25umYxKSqr3Wv211CQ653TrINw9aOHldbwGyO/IYiPxYY6oVr6phMluIKxqE/xnH8OtuOMMbt21tmvM4Q7tsOKbL32joMWXv55ZfVMDB0RtEhxHCrNWvWSHZheBaGqyHQwU9M5tarfKGN6GzZGwJkOy/GFcZOv/7+MXzN2AEEvdPpbJiVDp9LVvsO28KwNAwVs4X5MTpnn5OjIUk6zGHCtRExLA/D2HAiwdnQKXvvLasr3WNeBwLbP//8Uw1RwxBCzCfBcCdnclPxTG+Tq8d/VhwVQbFdntXvjCtcOTZy+7m7wtFx7Mp7duV3IGCuo0NERJTXIXhBCWk9qDHS749pMyZ3QQ5omoRcTbNsoUpcnAp2/lq79vo6qanmUtOGylHGycHuOtuN1za+LsbyI9PgyIoVK9SZfASuyMqgoJFthgVn8I0FDxx5/PHH1dlrZD1mzpypAh9dvXr11AR7nI3GNoy33JaoRlYLBS8wZ8n2tfWJ9TjTj8IHxsqyyJjY7jvMhcJ8HkefC94H5lDYbgc3V6sDItuD/e6sc48L8mJuFuYx4cw85ro5gveGLKpx3hTmgWQF7xfZI8z/wZyYL774Qi3XMzaufOaO2O5b3McJD327WR3/rhxz+vtGNk+HeSooYuDKXKDsQJtx/BqDhez+ztasWVMFPch22uPKfsd7RqbSeCICGXbMc3P3e84uBjpERERehtLRKCFdNrqs1XJkctxWWjokRA6WKSCHY8xDyiIrVJDXX3lFXpswQaZu3Ch7IyJkdUqKTL42mR+dYgy3QSUndFBwVh0ZFXfAZHtMyMeQpHXr1qniAM5KL6MtWA+T7NEWTCLH0CwjDP3ZsmWL6uBj4rSjDjqCCgRNGEKGzpixQAWKCiBjhCFS2BaqTKHwAYZoYfu5hX2JamCY/I73gYALGRGUMteDMAQiaBs6w8iS2GYvkA3CkJ833nhDTSRHVso2Q4kJ8lOnTlXbQ+U0DBf68ccf1ftw1YsvvqgKBqCAA947glFMGtcn3gOyYRh2hyGeqEDmDPYthi5hojuCOQRRgwYNcvocvA9U0sP7xPvARH29o4yMErIPmP6AaREIHLILBUgw5A6fBYo0oMAB3rerxz+OOQx1RPEDHHP2gnW8bwSNCKhxvGMb2AcYGmYc2ugOKByBIZIoMIETASiNj0IO2VGhQgVVGOOZZ55RxRFQiACZOmRVAcN/kXnBZ4Ft4f3bQpU2/F5hiCauT4bPG4UGEOg7KgjjLQx0iIiIfADBzIH4A7Kk6xKZ1mGa+rk/fr9bLxZ6XlIl0nQtoCheXAYPH65KAr/1zjtSrX596fzkk5Yx8gg8MJcFVdgwb2TUqFG5mrNkhA4jOpGo3oXOPSotGeel2EIghGFYmHuFjj7ODtsOS0SnCh1pdB5xZhsVwhxBpxOdL7ymcagOOnAILtAudPRQmhgdfQQ8jkqTZwcyIJhnhMAEZ87R2cX/9YwO5jWhLDSCHGSuEAhgvxuhuhayG2gnXgOfkV7W2BiAoCOKoZiYA4I5NAimnF3nxxbmVKDaGjqyaCcqGWLYnTEgRVCGbAvO7qPz7gzWRalsVNlFtTTsC3sVxWyzB7gwLwIFfCYY4ocMEiDrhqpgyCahjHROOtAY3ofXw+ujPDmqfenXdHTl+EfAjGMTxyWOOQQYtvRS6iizjPeAwAdD/RB4uhuCQJQrR4CDNiOowu9Wdk2cOFGVicfvGDJc+N3SM4gIVrDfMPQTvxN6YGgLATyOGVQRxMkDZJlwzPr6WlImVCQQP6dfMBR/nLIa35lbG5I3SP0v6qsJpa6MtSYiCmbe/PsbSDDJG2dQsW/QQTVO9PUXuA7PxqMb5ZbL0ZL//GWMTfJ1k8gFCLIQCKEUdXaLL3gDOsHIqNheg4fIE39nkWHC74Nxrhkg+4jsIjJ7KGftV9fRISIiIs+6nHZZ/Qy/eEXEUN2JKCfQocTwQWRBMLyMKBAw0CEiIgrCTNyZy2ckLEMk9PIV0UrH2JQ9IMoeDBXD0KgePXrwEiEUMBjoEBERBZHTl05LYkqipKanyg1XzMt2XjkspS+FSpH8RXzdPHJhcrg/zipwVkqayF+xGAEREVEQBTl7T+9VQQ5Ep4pcDhO5YLqqluNxIqK8goEOERFREEAWAJkco6grIucMF4zH4/6YLSAi8gQGOkREREHgfOp5SyYHilwSyZ8mkmb4psfjWI+IKC9goENERBQEjEEOlE0x/yx8xfl6RETBioEOERFREAgPvT5GLfqySGS6+f8Frprv21uPiCiYMdAhIiIKAoXCC1mCmLLnRPSZONq1+4DHsZ4/XiQTF6TdtGmTX7xObreLCmW4f+bMGbdvC687e/Zsu9v15LY86YsvvpC4uDgJCQmRMWPGiK+r3vm6DeQ+DHSIiIiCADqlcdFxKntT8KpYrpuDn7iP5Xgc6wWDbt26yYMPPmi1DJ3l5ORkqVGjhvhS48aNVTtw5fasZDcowuu2bdtW3Gno0KFSp04dr2zLFq5w/+KLL8rrr78uhw8flueff1684euvv5Ybbrgh03JcFNVbbSDPY6BDRETkS4sWiVSvbv6ZS0Uib5AbL0VYsjk63MdyPB7MQkNDpXTp0hIW5tvLBIaHh6t2uDOoTE01z63C60ZERIg3eGNbhw4dkqtXr8p9990nMTExUqBAAfGlEiVK+LwN5D4MdIiIiHwFpZ7feEMkIcH8M7eln1NSJOzSFUs2R4f7WJ5x5oyMGjVKKleurDqw5cqVk3feecdhZgFDorAMQ6SMZ8H/+OMPufnmm1WHsGPHjnLhwgX55ptv1LCfIkWKyEsvvSTp6elOh0DhdfB69uC53bt3l4oVK0r+/PnVtsaOHWuVgcD2fv31V/XauKH9xqFcGRkZEhsbK5999pnVa2/YsEGts2/fPnX/7Nmz6gx+yZIlJTo6Wu6++27ZvHmz0938zz//SN26dSUyMlIaNGggGzdutHrcdl8ePHhQ2rVrp/ZNwYIF5ZZbbpE5c+ao9t51111qHTyG5yBTBc2bN1eZjn79+knx4sXlnnvucbgvd+7cqbJIaA9e23hxT3uZCzxfD8Lw+LBhw9R71vel/rnYbmvr1q1q/+AzKVasmNpv58+fz5Rl+/DDD1XQgnV69+6tAhl7sJ2aNWuq/994442WY81etq5v375qn+jw/z59+shrr70mRYsWVUEZjgsj7H+0sVSpUmrfINOHYxf75+mnn1afvf6e9efaDl1DINa+fXspVKiQOj46deok//33X6Zs2Lfffqueiyzeo48+KufOXRsvSj7l21MeREREedmCBRgrY/4/fuJ+69Y5ey0ESUeOqOyNozzCwP79ZdKsWfLxxx9LkyZN1NAkdJKz4+LFizJu3DiZPn266sx16NBB3dCZRucdAcTDDz+sXr9z5845eit6kDJjxgzVyV+5cqXqsKLzjI7mq6++KgkJCWrY05QpU9Rz0Nk9cuSI5TUw3wMdzu+//1569uxpWT5t2jRp1KiR6ljjmkLIJOC5aDs6qZ9//rm0aNFC/v33X7XcFoK6+++/X3X4v/vuO9m/f7/Ex8c7fT/o7CMjs3z5chXo7NixQ3WcMdTu559/Vvtr165dqiONIEKHYO6FF16Q//3vf06vf9S/f3/VOa9evbqMHj1aHnjgAdUuBBpZwWe0bds2mTdvniy6llW0N+QOn3ubNm3k9ttvV8O7jh07Js8++6wKxowB65IlS9TnhJ979uxRr49A4LnnnrO7beyDli1bquAR/0dGxVXYPwgE16xZI6tWrVIB0h133KGCQhxDGHaHYxSfU6VKldR+R9YPQSH211tvvaX2O+DzsIV9joALn9myZcskLS1NevXqpdptDCb37t2rAkIEUadPn1bH6HvvvWc5iUC+w0CHiIjIHS5exKl119dHx7VfP/TI0bM3/8T9qVNxKt3116laVQRDbfB6qakOg5xzFy7I2G+/lfGffCJdu3ZVy9D5Q0CSHTg7P3HiRPVcQEYHZ7NxlhudRXS2kaVARzengU6+fPlUlkGHzA6CHQQ+6ERiOwgIrly5os7kO/LEE0+ojj8yKuXLl1edXwRobyB7dq1TjiwFOu36EC1kI9BpnTlzpt25GgickHH66quvVEYLGZSkpCQVkDiCrACCGWP2QqcHU8go2WZekHl7//33s9xfCDbw+oDPBkHL5MmTVbYjK9iP2J8Y7udsX+J9X7p0SaZOnao6/jB+/HiVqUKWEFkTPTOF5QgoqlatqgLJv/76y26go2eGAAGOs+3bU6tWLRkyZIj6f5UqVdR2sS0EOgjaEDwhIL7pppsy7XcEc8jkONsmXmPLli0qaEQQBjjW8Zkj2GvYsKFahuMKwV5UVJS6/9RTT6l2MNDxPQY6RERE7oAgp379nD8fwc6OHSINGmTveevXi9SrZw6UqlWT88ePSKHkE5JesYKERl7PDiSsWydXUlOlxbUhUDmFzr0e5AA6uBiyYzwjjmUIHnIDQ86+/PJLFaSgg42MiL0J885geBk62z/88IMMGDBAnZVHuxAswfr169XQK9vMB7aHs/T2oONcu3Ztq3kcyBA5gyFWCIQWLFigshcIStBJzwqGxbnCuH0ELHge2ulO+vvWgxxA9gSdfGRF9EAHQQCCHB2yOwgmPcF2H2Jb+nGH4YvICupBTk7fMwIcPcgBBPIISPGYHujg+NeDHNt2kG8x0CEiInIHZFYQdLgC2ZcuXczBEQIcHYIVvE52sjpYXxceLhlXr0iaSSSsaDGr18hvZxiWEYZ6mZt2fYiUvbkVyLYY4ay4vWXoABvv2w69cjRvA5C5efnll+Wjjz5SnXh0Ij/44AM1RCm7kNXBcDUEOvjZunVrNRwO0EZ0So3DkHT2KnKBsyFkjmCIF7b7559/qmBn5MiR6r1hLpMzxqAiu/Q5OPhcs7PvHcFrOCquYFye1bHgClfb7GxbxiGAOeXoPdsud8d7Js9goENEROQOOMOPzIor5s83Z28cZXVOnMjxXJ2wC5flcmSYFLLpoGFoDzp/GFKDjrctfW4E5u1g+BG46/oseG28rm737t1qzocjK1asUPMoMB9CZ5thQWUzY8EDRx5//HF58803VfYGw9EwtEtXr149OXr0qMqC4Ky8K3BGH8OXkPXRO9OrV6/O8nnICmCuEG4DBw6USZMmqUAH7wNceS+OYPt33nmn+j/mkeC9Yjibvu8xTwVzi/TAyfZzdWVf4n1jTozxdTB3CEFJbrIm9qDNmDdkhDbbBhRZZXswpBBzrey1z9X3jGGHiYmJlqwO5vmgiEG1atVcbgv5DquuEREReRPOVA8ebM7e2IPleDwnFdg0TSIuX5W0/JlLAqPqFK5VgnkbmGeBwAEdZMzl0OeDoDOHKlLoHCL7gKyDO2DiPuZPoOLZunXrVGffWacVbcF68+fPV20ZPHiwmhNhhMAE8ycwbOrEiRMOsxSY34OgCVXcEASggpYOw8iQMcKEc2wLFb8wFwiBEbbvKHBC5x6vh04vihhgXo8zqBiG18dcD+yDxYsXWzrKmDuEDAAmsh8/ftyqipmrPv30U/nll19UYQkUPsCE+GeeeUY9dtttt6lhdpiXhOIAyGrZVrvDvkTbEExgX2Luk73MGI4hzO9CEIL5TQjUMB9FH7bmLjhesP9xnCIoxjwc28AnK82aNVPBH4YJLly4UL2/uXPnqvlL+nvGvkbgj/dsL/DG8YGACe8dnxvm/HTp0kW9tqvDCsm3GOgQERF5E66HcuiQ9ZA1IyxPTDSvl03apUsSqolkFLI/5AkBwyuvvKKqTaGjjWIB+lwCBB6Yy4LOMuZiYIL5iBEjxB0QMCGIQscTgQKqpjm7VgkCIVRyQ/vQUT958qRVdgcwuR1lp9HhRAYA2QVH0FFF+WS8pnFIEwIMBCpoFwIDnPlHpTYEPI4675iL9Pvvv6sgB3OABg0apPaVM8gcIADBPkflMrR7woQJ6rGyZcuqwgsYWodt6pmY7ECFL7QBnxuyYSi7rQ/PQ7EDVB3D+0QxBHzGtmWYEQygXSgigX2JdWzh80KwdurUKTU3BUUoUJ0OAay7YZgfjlUE5dgWMlIIMLILFe3w/Mcee0xlZ/B6ehYHwS+OMxxjeM/2ij7o5bWR4cQxgsAHBQ1+/PFHt7xP8jyTlpPBpl6GJuopYk9f0XlD8gap/0V9Wf/8eqkX4+IQBCKiIOXNv7+B5PLlyyojgn2Dzq5x8rVLEMgcP+748ZIlRWJjs92utKNHJCTpiJyrXkkKFzAPPyMiCtS/s8jEISuLbKIRSsujch6GEaIsuyOco0NERORtGO9vqOTkLhnnzsnlfCKR4byyOxERh64REREFidCLl+RChEh4qHmCOxFRXsZAh4iIKBikpkro1TS5EhnOYYZERAx0iIiIgsS1al0ZBXN//RAiomDAjA4REVGgS0kROXhQUkNE8kVwfg4RETDQISIiCmQonnr4MGoYC+riRYZZVyciIgpEGY5K8GcDq64RERFlE66qjnLbKH+KMqcofeqz8tvnzolcuGD+f4ZI2NlLcjnksm/aQkTkhssapKamqgvo4uK8+HubUwx0iIiIsglfvqVLl1YXDsTFBHHfZ5KTLRcXVRfGS0kRU8w537WHiMgNcJHacuXK5ervKwMdIiKinHyBhoXJ8OHDJT4+Xn0h+8Tff4s8+2zm5V9+KdKkiS9aRESUa7gIM/7G5jZTzkCHiIgoF0Ms8GVse9Vur83NeeMNkaQkNT/HIjTUvHzNGhFfDacjIvIDLEZAREQUiBYsEFm71jrIAdzHcjxORJSHMdAhIiIKNMjmDB4smoOMjVo+eLB5PSKiPIqBDhERUaBJTZXL+/4Vk4NABssv799tKVJARJQXcY4OERFRgEnPFyZ39sovaf+dlVdWidx5QKT9Y9cfR54ntHR+WZUvTEJ92VAiIh9ioENERBRgVhxaIWtDj4qUEalwRuTv8iIby9iulazWa16huW8aSUTkYxy6RkREFGCSzyWrn2HpIvWSRdaUdb4eEVFexECHiIgowMRExaifNf8TyZ8m8k9Z5+sREeVFDHSIiIgCTNNyTSU2OlZuPyxyNURko008YxKTxEXHqfWIiPIqBjpEREQBJjQkVMa2GSu3JolsLiVyOZ91kANj2oxR6xER5VUMdIiIiAJQh2od5KFzZWWtzbA1ZHpmdpqpHiciystYdY2IiCgQnT0r0fuPyOpaIl898JVEhkWqOTkYrsZMDhERAx0iIqLAtG6dujBocrVY6Vanm5hM5iFrRERkxowOERFRAMpYvVrOR5qkZtOODHKIiOxgoENERBSAzq5YIOtjNHmg2oO+bgoRkV9iMQIiIqIAkp6RLkv3LxFtzRrZWD5cbo+93ddNIiLySwx0iIiIAsSshFlSYWwF+fzVu6XomSuSIqlS+ZPKajkREVljoENERBQAEMx0nNFRks4myfAl5mUdEkQOn01SyxnsEBFZY6BDREQUAMPV4ufFiyaatNorUvm0eXnd/0Tu2Wv+f995fdV6RETkpUBn5MiR0rBhQ4mKipKSJUvKgw8+KLt27fL0ZomIKI+ZMGGCVKxYUSIjI6V+/fqyYsUKl573v//9T8LCwqROnTrir1YcWiFJKUkimsjwxeqHkma6dl/TJDElUa1HREReCnSWLVsmvXv3ltWrV8vChQslLS1NWrVqJRcuXPD0pomIKI/48ccfpW/fvjJo0CDZuHGjNG3aVNq2bSuHDh1y+ryzZ89Kly5dpEWLFuLPks8lq5/I5tx6RES/Yk6YZr6P5cb1iIjIC4HOvHnzpFu3bnLLLbdI7dq1ZcqUKeqLZ/369dz/RETkFqNHj5bu3bvLs88+K9WqVZMxY8ZIXFycTJw40enzevToIY8//rg0atTIrz+JmKgYSzYHWRwjPauDx9V6RETkmzk6OHsGRYsWdbjOlStXJCUlxXI7d+6cF1tIRESBJDU1VZ08w2gBI9xfuXKlw+fhxNvevXtlyJAhLm3H9rsJN29pWq6pPJFcXGVvkMUx0rM6eBzrERGRDwIdjCHu16+fNGnSRGrUqOF0Xk/hwoUtt9jY2GxvC+n7oUuHeiWNb7stb26biCivO3HihKSnp0upUqWsluP+0aNH7T5n9+7dMmDAAPn+++/V/BxX2H43IWPkLaGmEBm3srA4KjWA5Xgc6xERkZlX/yK++OKLsmXLFvnhhx+crjdw4ECV+dFvSUlJ2d5W8vlkGbZsmPrpabbb8ua2iYjIzGQyZTq5ZrsMEBRhuNqwYcPkpptucnn32X43JSYmem/Xp6ZK0ePnJdTBw1he9MQFtR4REZm5dhrLDV566SX57bffZPny5VlmaCIiItTN+GV16dIlL7SSiIgCTfHixSU0NDRT9ubYsWOZsjyA4dDr1q1TRQtwAg4yMjLUdw2yOwsWLJC77747y+8mr8J2166VETNekn4Df5WTj3eQ7W3rS/GCxaVu6boSGhIqUrKkeT0iIvJOoIMvDgQ5v/zyiyxdulSV/iQiInKX8PBwVU4alT0feughy3Lcb9++fab1o6OjZevWrZlKUy9evFhmzpzpt99TGbFlZd5/f8ubV0UKPNVL4vy8UhwRUdAHOigtPW3aNPn111/VtXT0M24Y35w/f35Pb56IiPIAzP986qmnpEGDBqqC2hdffKEqfPbs2dMy7Ozw4cMydepUCQkJyTRPFNd5w/V3nM0f9bU1SWuk/N6T5jv16vm6OUREfs/jgY5e2rN58+aZqt2g7DQREVFude7cWU6ePClvv/22JCcnq4Blzpw5Ur58efU4lmV1TR1/99uu36TJ8UjRbiwjpiJFfN0cIiK/55Wha0RERJ7Wq1cvdbPn66+/dvrcoUOHqps/+3XXrzLrVGEx1a/v66YQEQUErxUjICIiouxJz0iXFYdWyMbkjbLzWIJUOpBf5EkOWyMicgUDHSIiIj80K2GWxM+Ll6QU8yUWbjolku/CJfm7xCVp4uvGEREFAF5ZjIiIyA+DnI4zOlqCHKh37dJsD/77tnqciIicY6BDRETkZ8PVkMnRxHqOa/0jIvtvEDlVwCR95/VV6xERkWMMdIiIiPwI5uQYMzm6+ski62NEBUCJKYlqPSIicoyBDhERkR9JPndtjJqBKcM8dG19GefrERHRdQx0iIiI/EhMVEymZZVOixS+Ys7oOFuPiIiuY6BDRETkR5qWayqx0bFiEpPV/BxARgfL46Lj1HpEROQYAx0iIiI/EhoSKmPbjFX/14MdzM85UFjkdAHz/TFtxqj1iIjIMQY6REREfqZDtQ4ys9NMKRtdVlrsFem1ViQxWlSmB8vxOBEROZe3A51Fi0SqVzf/JCIi8iMIZg702S8fLQ2XgldFGqYWl/199jHIISJyUd4NdDRN5I03RBISzD9xn4iIyI+ELvpLaiemqv9H/ndC3SciItfk3UBnwQKRtWvN/8dP3CciIvIXmibam29Kul6TIDRUZPBgnpgjInJRSJ4cqrZwofnLIiQk05dH1PI1sn28qJ9EREQ+s2CBmNatk1B9wEF6Ok/MERFlQ0ieHKr2/PPmL4uMDOsvj7lzpczI8VL9hKifHM5GREQ++84aPFi0UJuvaWZ1iIhcFpInh6odOGB/nYcekoKbd6j/qp8czkZERD78zjKlXzshp2NWh4jIZSF5KpuTldTU60/BWTSOhSYiIh9lcyzDq21hOb+fiIiyFJJnzoxt2JCtp6izaCxSQERE3oaTbocOXR9ebQvLExOtTs4REVFmYZIXzoy9+WbOnouzZn36mMdEjxsn0rKlu1tHRERkLSLCfKLt+HHZ+G4fqfzb/yRq1ToRk15+TURKljSvR0REeTfQiVq2SmTdOscrfPKJ+edLL9k/a/bvv+b/Y+hbixbWXzRERESeEBenbqEnTsmOchFyW/363M9ERNkU3EPXNJEyoyY6z9h884355mgstI7D2IiIyMtK7T4i+8oX5n4nIsqBoA50wtNFwhOPOF5BH+fsbCy0jiU9iYjIm86dkxLJZ+VIpZLc70REORDUQ9dSw0ROPXyvlPp2lsi8eSJRUZlXwjhnzOM5flzdTTieIE/MelJml3tNyr35vv2Snq1be/FdEBFRnrRli4RoIidvjvN1S4iIAlLQBjpRy9fI9vEiRdP+EOnaVaRZs6zHQ4vIpWSRjatEiv30hzmLgwDHtqRnq1acq0NERJ61aZNcDTXJ5So3ck8TEeVAcA5d0zQpM3K8VD8hku9MikivXtl6equ91y4YagxyAMPbkNV57z2R6tVFFi1yb7uJiIh0mzbJzlKhUqRwKe4TIqIcCM5AZ8ECc6CiS052/bmaJsMXi2jOqquNGCGSkGCuxIZhb0RERG6mbdwoG0qlS/ECxblviYhyICRYryitXauipgKWbFxB2pR6VcqdFTE5W//iRfNPVmIjIiJPuHpVZNs2WV9Kk2IFinEfExHlQPAFOigWsHatmK5VUVMBSzYCEi0iXBo+L5Iw7zuR9eutb6tXi0RGXl+ZldiIiMgTdu4U05Ursqm0MKNDRJRDYcGYzclUREAPSFwsIpBUWORSrWoiMfWsH5g/X+Ty5UyV2NRFSYmIiNxl0yb1YzMDHSKiHAsJxmxOpiICxtLQ7giijEJDzRcl5VQdIiJyl02b5EJcaUmJZEaHiCingifQ0QORa3NzMtFLQ+e0eICTIAqFD1CpjYiIyC02bpQTN8Wq/xbLzzk6RER5O9BJTRU5dMhcAtoeLE9MNK/n5iAKBQ9QqY0V2IiIKNfwnbNpkyTdWFwKhReSiLAI7lQiojwd6EREmDMuKBrw9ttqUdNuNkUF8DjWc3MQhYIHdZNFohf/L7fvgoiI8rpp00ROn5YLVy+wEAERUS4EVzGCuDjz7ccf5UpsjPxdIdl+UYGcBlHHj1svR4aoY0e5GlVQ8p0+KzEffi7yxEu52xYREeXtbM7Qoeq/1ZZtl+KNKvq6RUREASu4Ah3dtm1yuWolXCnU/UGUUb16Ip07S77vv1d31UVKMZenVgn3bZeIiPIOfIfs2aP+G7f/lLTaw0CHiCingmfomtG2bXLpZgQ6XjjztnOnpeCaFprLggdERJR36fNBr0k3iTwzaz+/U4iIcij4Ap2UFDWf5nLVyt4587Z+vehX5jGlZ/C6OkRElPPvFAyTviZUE6m091TuLo1ARJSHBV+gs327+uHxjA6vq0NERB7+TskIMXGkABFRDgVfoLNtmyoDfblyBc9uh9fVISIiD3+nhGRoub/gNRFRHhWcgU6VKqJFevC6A1ldV0dEZk8XiVq22nNtICKi4ODpC14TEeVRwRno1Kjh2W1kdV0dEcmfJlJm5Hh+MRERke8ueE1ElIcx0MntxUnXr1cXJa33/LWLkz75pGW1glsSONyAiIhc/06pWlWkXTvZOudr9b2ye8H03F3wmogoDwuu6+gcO2a+eTqjY3NdnUvJIhtXi1yqWVVk5xg1dM10rdy0CcMNWrUSMem12YiIiOx8p5QuLbJ/v8gLL8ihSsVlYxmRgrc3FYkqw91FRCR5PaNzreKaVwIdO6KWrRJZty5TuWlOIiUioizt2iVy5YpI7dpy4uIJtahY/mLccUREORQSdPNzwsNFKnvhGjq2NJEyoyZmKg2q7nMSKRERZWXzZvPPa4FOVHiURIRxuBoRUU4FX6BTrZpImPdH5LXaK1Jw845MpUHVfWZ1iIgoK5s2iZQvL3LDDXLy0kkpVoDZHCKi3Ai+oWu+GLamaTJ8sYjmaB4OljOrQ0REWWV0atdW/0VGp3iB4txfRES5EDyBDq4vgIzOLbd4fdOm1KtS7qyIydE1DrB8926R6tVFFi3ydvOIiMjf4XsCGZ06ddRdBjpERLkXPIHO4cMiZ8/6JKOjRYRLQ728tG256UmTzCsVKiSyc6fIG2/w2jpERGTt6FGR48etMjosREBElDvBE+h8+63555kzPtl8UmGRS7WqidSrp36iLKi6/+yzInfdJZKUZF6R83WIiMhJIQLAHB0OXSMiyp2QoEn5T5hg/v+4cf6VMUFbTp26fp9V2IiIyBaGrUVFiVSsqO5y6BoRUe4FR6CzYMH1jMm6df513Rq0RT9TB6zCRkREtvA9UauWSEiIaJomJy8yo0NElFuBH+ggY4KKZv6YMdHbxmvrEBFRVoHOtUIEZ6+clXQtnXN0iIgCIdBZvny5tGvXTsqUKSMmk0lmz57t3owJ5r3YZEyilq0SX1NtQNt4bR0iIo+bMGGCVKxYUSIjI6V+/fqyYsUKh+vOmjVL7rnnHilRooRER0dLo0aNZP78+b75lC5dEtm1y6oQAXCODhFRAAQ6Fy5ckNq1a8v48eO9ljEpM2qiiC+TOpqY2xDiZBc/+KDIwoXebBURUVD68ccfpW/fvjJo0CDZuHGjNG3aVNq2bSuHDh1yeAIOgc6cOXNk/fr1ctddd6kTcniu1+HSCBkZDHSIiNwsTLwAXza4uZ1tNkeXni4FN++QVjXFZ8LTRcIPHzV/eTly+bLIwIEiLVuaLypKREQ5Mnr0aOnevbs8i0qXIjJmzBiVoZk4caKMHDky0/p43Ojdd9+VX3/9VX7//XepW7eu94et4aTYtcsjMKNDRBRAgU52XblyRd2MwsLC7Gdz8OVgJ5jQTCYZvljz2Vyd1DCRnXO/lZohpTM/+MknIl9/bf7/+vXmgK11a6+3kYgoGKSmpqqszIABA6yWt2rVSlauXOnSa2RkZMi5c+ekaNGiLn83paSkSK7hItKvvSZStqxIgQJqEQoRQLECxXL/+kREeZhfFiPA2bfChQtbbrGxsZlXSk0VwZAEBxkTk6ZJXIqIKfWqZVnyuWQZunSo+ukqe89x9XWuli2trqtjdcOZwm3bLKPqtNAQS/EE29d1ZTs5eU85fR137T9P8ea2iMh/nDhxQtLT06VUqVJWy3H/KC7E6YKPPvpIDbPu1KmTy99NcXFxuWp3enqapLzyosjp03I15Yy6n56RLquTVktkaKSsTFyp7hMRURAFOgMHDpSzZ89abkl66WijiAjzsDVkRJAhEZF7HxdJmPedWoafDZ8T0SLCLU9JPp8sw5YNUz9dZe85OXkdC2Rv1q0TfaCaKT3DchFR29d1ZTu5aks2X8dd+89TvLktIvI/KHZjhDLNtsvs+eGHH2To0KFqnk/JkiVd/m5KTEzMcVtnJcySrr1iJHrLLnU/39lz8ujzRaXUh6Xks/WfyeX0y3LXN3dJhbEV1LpERBQkgU5ERISqgqPfonARNXtwNg1ZkuLF1d0V5UUu1aqmluHn4cLiXxwVT8DwO38piU1EFGCKFy8uoaGhmbI3x44dy5TlsYXgBnN7ZsyYIS0xXzIb30245QQCl44/Pix9/jghadfisHSTSP955yzD1nSHUw5LxxkdGewQEQVLoJNtp0+LFhoq568nb/yTXjzBttw0ht/5SUlsIqJAEx4erspJL7SpYon7jRs3dprJ6datm0ybNk3uu+8+L7RU1FC0+Hnxcs9ekVuPiIRdO78Vqpnvt9prvb52baBz33l9OYyNiMgfA53z58/Lpk2b1A3279+v/u+o7Ge2nT4taYWjxDIezB8Ziyc4EPvmB7J9vEjU8jVebRoRUaDr16+ffPnll/LVV19JQkKCvPzyy+o7pmfPnpZhZ126dLEKcnAfc3Nuv/12lQ3CDUPSPGnFoRWSdDZJhi8WSzZHh/tYbntpBAQ7iSmJ6rlERORngc66detUuU69ZCe+kPD/t956yz0bOH1a0m/I2RACr8mieAJEHjws1U+IlBk5nsPYiIiyoXPnzqpk9Ntvvy116tRR18nBNXLKly+vHk9OTrY6ufb5559LWlqa9O7dW2JiYiy3+Ph4j+53FEtpZZPN0YU5yOoYn0tERH5WXrp58+ZqUqjHINBBRsef6cUTjh9XdxOOJ8gTs56U7zt8J9WKVBHp2FFM1ya24hpAaphbrRI+bjQRUeDo1auXutnztV7S/5qlS5eKL8QUKq2yNhjAbDNbU8FyPL6gEqor2Dw3KsZbzSQiCgp+eR2dnA1d8/OMjl484Vo50kvJIhtXXyueULquSHS0Gq1gulZy2oRhbrMn+rrFRETkRk1L3yanUkIkVOxn9xH84NIIuOg0rscGJjFJbHSsNC3XlJ8FEVFeDHTSAyHQcQTZm+3bM5WcZnECIqLgEpq/gKz7daK8+WMPaZgk8tkckYc6iRy84fo6xwpaBzkwps0YCQ2xlwMiIqLgD3TKVZaAZCw5bazGFhoqZUZNFHnQl40jIiJ3a3v383Ippris7/eYnM+XKr9VFckIESmWv5h6/OSl6yWmkclBkNOhWgd+EEREeTbQCdCMjsraYO6OrfR0NVfnwH6R1GprRDrX80XziIjIAx6q+pCY/guVpApF5buO49X8G31oGqqrofCAvoyZHCKiPB7oqPLSgUYTc9YGJaftVGPDnJ3yKSIXUIWtU09c9tsnzSQiIvfadHST3JR0SQq1vkceq/mY1WPNKzTn7iYicoPAv2BoWppISkpAZnQw2TT88FGHJaf1sMZShY2IiILCnM0zpeoJkdJN2vq6KUREQSvwA50zZ9QPv7+Ojh2YbLpz7rci69erW8K876Te8yIJWFa1quWacRoyPpjH48kS3URE5DUJS3+SUE0krH4D7nUiIg8J/EDn9Gn1Iy0AAx24Wra0SL166oZS0xvLiISdPiOyc+f1KmzI+GAeD7M6REQB7+CZg1Jw+27JCA0RqVHD180hIgpaQRPoBOLQNafzdlCFzYhZHSKigJaekS5LDyyVIUuGSN2jJtGq3iwSGenrZhERBa2gCXQCshiBHa32XpuTYyw1DXpW5733RKpXF1m0yFdNJCKibJqVMEsqjK0gd31zl3yz5Rupk6zJ7MiDajkREXlG0AQ6gThHJxNNk+GLRTRn1dWGDxdJSBB54w3O2SEiCgAIZjrO6ChJKUnqfkiGSK3/RFYWu6iWM9ghIvKM4Ah0QkMlo2ABCXSm1KtS7qyIyVnRgUuXzD85Z4eIKCCGq8XPixfNUl5G5KaTIgXSRDaWNt/vO6+vWo+IiNwrOAKdIkWC4hozWkS4NETVtXnfWVdhw/1160Ti4q6vjDk8rMRGROTXcPFPPZOjq3PU/HNTaUzL1CQxJVGtR0RE7hUWNIFOkEgqLKr6msTUk0vJIhtXX7u/5bhIYuL1FTGHZ+1aiVq2ypfNJSIiJ5LPJWdaVjdZ5GBhkdMFnK9HRES5EzwZnWCGoWzI3tipxBb75geyfbxI1PI1vmodERE5EBMVk2kZMjr6sDVn6xERUe4w0AkAKmuDOTl2KrHl33dIqp8QKTNyPIsTEBH5mablmkpsdKyY9CujaSJ1j5qHrQGWx0XHqfWIiMi9GOgEynV1cB0dJ1RJal5QlIjIr4SGhMrYNmMt9ztvEylxUSTDZA5yYEybMWo9IiJyLwY6fi48XST88FHzdXSc0HhBUSIiv9ShWgeZ2WmmFA6PlreXmJc9nCASG1VWLcfjRETkfixG4OdSw0R2zv1WaobYDOheuVLkpZcsd036BUWR1Wnd2vsNJSIihxDM7Js+UW46Zb7Yc+3/RPZX+1xCq93LvUZE5CHM6ASAq2VLi9Srd/1Wt67I1KmZixPAoEEiCxeKVK8ussj8hUpERD6maXLv1FXXr6YTGiqhQ4ZybiURkQcFdqCDyfkpKcFfdc0Wsjb2ihPA+vUivXuLJCSIvPEGv0SJiPyANn++VD9wQS9JYLlEAOdWEhF5TmAHOmfOmH/mpUBHLzXtrDjB7t3mn/wSJSLyPU2TtEEDJc32uta88DMRkUcFdqBz6lTeC3RSU0UOHcqyOIHCL1EiIt9bsEDybdgkYZZxa9cwq0NE5FEhAX+xUChaVPKMiAhzpgZD1Navl4R530m950X9lE8+sf8l+t57nLNDROTDLLxmsk3nXMOKmUREHhMWFIGOyuickDwjLs58E5FLySIbV4tcqllVZPAL5iyO7dydESNELl40z9lp0ULE0RcuERF5JAtvQsBjD7LziYnm9XAii4iI3CY4Mjp5aeiaA1HLVjkuUIAgBzhnh4jIJ1n4viOayIXIUJGePS0ZecsNf5sZ5BARuV3gBzrIYBQqJHmaJlJm1ETnBQps5+yg9DRLUBMReV5cnGy/nCgFL6eLPPig9eUCcIuN5adAROQBgR/oIJuTx4dihaeLhB8+mnWBAn3Ozvz55mFsLEFNRORxqempUjrhkPlOw4bc40REXhL4c3Q4bE1Sw0R2zv1WaoaUvr5vkLXp0kVk587MAdDTT4scPWo9nK1WCe9+dkREecTeU3ulQZImFyuUlQJ5qXgOEZGPBUdGh+Rq2dLWQyFOnBDZscN+lgdBjp4FYwlqIiKP2nlip9x6WMR0663c00REXsRAJ69eVFSvAHRtOFvJ8VNk+3iRqOVrvNZMIqK8YPfR7VL3qEhkozt93RQiojyFgU5ev6gomEwSM2ayVD8hUmbk+OtBEBER5dqFDWskMk3EdNtt3JtERF4U+HN0qlb1dSv896Kix49bL1+5UuSllzKvr2kSeumy+m/BzTvMc3Zat/ZSY4mIglvBjdskLdQkYXXr+ropRER5SuAHOpyjk+VFRRVkaXD9Bgxns5PpQQ4Hs3a0kBAx6cPe4uNFxo0TadnSc58hEVEQ0zRNyu48Iscrx0hMZKSvm0NElKdw6FpekcVwNr1AtwmPIxvUuzfLTxMR5dLxi8elzqFUuVinJvclEZGXBW6gg0n0KSnM6GR3OJvxatzr1pkvGmqvaMHu3dblp8VcqIAFC4iIXLd7/3qpdlwksnFT7jYiIi8L3EDnzBnzTw5dcx2GsrlaglqHMtQDB6p1UKiABQuIiFx3+n+L1Bdtieb3cbcREXlZSEDPzwEGOp4rQa2vt3GjSIcO5kIFxoIFixaZM0L4SUREFukZ6bL5u4+kyWvj5WI+kdBq1bl3iIi8jIFOXpXdEtS//qoKFoAWGiLy5pvmTE9Cgsgbb7AkNRHRNbMSZkmFMeXlyuuvyg0pqZJmEqnwyY1qOREReU/gBjqnTpl/Fi3q65YExZydhHnfSe+2zp9iKViQnmGe34ObzTweZnmIKC9DMNNxRkepvvGw3HrEvCw6VeSWjYfVcgY7RETeE7iBDoeuuXXOzqWaVaXrZhENc3KyKzTUPAwO2SFkd5jlIaI8Olwtfl68Kik9fLGoTI5abhJ5e7F5KHDfeX3VekRE5HmBHeigg12okK9bEhRMqVel3FkRE+bk5KQCHrI6I0aYfxqyPKzURkR5xYpDKyQpJUla7RWVzQm79uc0VDPfv2evSGJKolqPiIg8L7ADHRQiyEkGgjLRIsKl4fOihrBlKj/t6j4eMuT6ughC33yTldqIKM9IPpesrr5szObocB/L8bhaj4iIPC7wAx1ym6TCIpdqVbtefrpGDZGTJ7NXaEBfF1medesyV2oDVmsjoiAUExWTKZujw30sx+NYj4iIPI+BDrlesGDut7KtRPbm8VgqtaGMtaN5PAx8iCgINI1rIqOW5RNHM3CwHI9jPSIi8jwGOuRywYLLVStL8YvZm8djqdSGAAdBU+vW1vN45s+3X8CAwQ8RBZjQtHSperGAhDp6XESqXiqo1iMiIs9joEPencdjvLgonvPcc5kKGKhgh1kfIgo0ERESuXGrLJ75gewtIvJbFZF6z5tv9/YrpZbjcZUtJyIijwuTQJ6jU7Wqr1uRd+fxxNQzL7hyJfvzeHR4TlKSdeDz6qsi77+fOevz1lvXsz4tWpjXRdDUp4/IuHEiLVu66R0SEeVCXJw0vtJOIk/3l0XPtZD+T3ZXc3KalmsqoSGOcj1EROQJzOiQW+fxZDvDYxv4bNsm0q7d9edjbg+CGReyPnZLWXMIHBF52e5vx8jVEJHmz78rj9V8TJpXaM4gh4jIBxjokFvn8eSoUpsRAhxUbNOfj7k9u3cbjtgQkf79RebOzZT1KTNyvFQ/Ieqner4rQ+AYCBGRm2l//inrb8wvN93YkPuWiMiHAjPQQUc4JYXlpQOhUtu876TecyKXbqroWpYnqwAJgc/WrSL3359prk+mUta4OSt8YK8CHLgSDDFAIiJ7f6IunJcqmxPlRPNbxcTrvBER+VRgBjpnzph/8jo6fp/hwXye7aVEwk6dzXmWxxY6D8bXspnrox557DGRp582Z4D0C5jaDoEbOTLrIXH2giFXiyXkJGBiAEUUkNIz0mXpgaUyfVwPyZ8mUqrzM75uEhFRnheYgc4ff5h/7tvn65aQC1LDRHbO/fb6PJ5Vq0SKFs35vssiYDLpxSqSk82Bip4FNA6Bg6FDrecCYUjcr79mHQxllSmyFwy5EjC5M8PkriDLn9bx9/YF6/tcuvT6Y2TXb7t+kwpjK8iIt+6SNm9Pk+SCIh02vyGzEmZxjxER+ZLmJZ9++qlWoUIFLSIiQqtXr562fPlyl5+bkZGhXbhwQf3UcKtWzdxNvOUW831N09YfWa/JUFE/7d13tMxWTl7HledktR13vk5OeGpbDp9z6JCmrV9//bZqlaYVLap3//3nFhqqaSZ15SDzz3LlNO3GGzUtJMS8DD8rVrR+zrx55ptx2YgROVsHx3fDhub7+Jmebn1f/51wtk5OnuNv6/h7+4L4fWY0a3b976+fy+73zNKlS9V6WL9ixYraxIkTs7W9s2fP4myEJgNEkyGirSlj/t09WlA00xDRTENN2s87fs7luyIiIkd/f/HTGa8EOtOnT9fy5cunTZo0SduxY4cWHx+vFSxYUDt48GD2Ax3bziHuM9AJvEDHHmPw44vARw9ocnvLl0/TIiOdB0xlymhabKz1sogI6wCqenVNQ8fL+DqDBmU/YMppkOVP6/h7+4L4fWZERQVEoJPd75l9+/ZpBQoUUOthfTwPz585c2aOAp1WT1r/HcB9BDpxo+O0tPQ0N75TIiI662Kg45Xr6IwePVq6d+8uzz77rLo/ZswYmT9/vkycOFFGYmiQjStXrqibUVhYmGgY2oP1Cxc2D/PBvAvcv+ceCZEQiQqPUj8RwNneB3vLbOXkdVx5TlbbcXXbrrxOTnhqW9l6Tmys+abbvFnkxInr91NTRR55xDwsLRDky+f4sXPnzD8LFbJeHh5+/f+JiSKvvSYSFXV9Ga4ZZLyP/YHhd8Zlo0ZZ38d1iYz3u3TJ/JwPPrC+3727eZ3oaHO3DT788Pp9PNajR+Z1PvrIep1evbJe58UXM68zerTj+1gX860gq3Wcva6r68THe2cd+Phj6+f07Zv5fdpbx/Z13biOdu24wO+vP0+uz+73zGeffSblypVT60G1atVk3bp18uGHH8rDDz9sdxu2301nz5699oDI64tEzlwbD54m5vsLYjVJvJwo87bPk6blm3rmjRMR5UEpKEp27bvJGROiHU82JDU1VQoUKCA//fSTPPTQQ5bl8fHxsmnTJlm2bFmm5wwdOlSGDRtmuR8TEyN79uzxZDOJiMiJyMhICdGLe/iZnHzP3HnnnVK3bl0ZO3asZdkvv/winTp1kosXL0o+OycqbL+biIjItxITEyXWeJLchsczOidOnJD09HQpVaqU1XLcP3r0qN3nDBw4UPr162cVtVWuXFl27twpUcazzn7q3LlzaqcnJSUFRHuBbeY+DobjItDaGwht9vC5MJ99z2C5vfXT0tLU6+EEW1bfTWfOnJHy5cvLoUOHpDBGGvg5fJfGxcWpjkE0MncBINDaHGjtBbaZ+zgQjwt8N+H7s0yZMk7X88rQNbAd8uBsGERERIS6GSWjgpad1/FX2PmB1F5gm7mPg+G4CLT2+nub/bFN7viecbS+veXOvpsAQY4/dgQcQVsDqb2B2OZAay+wzdzHgXZcuHKCyePjEIoXLy6hoaGZzqodO3Ys09k0IiIib3zPlC5d2u76mA9arFgxfghEREHA44FOeHi41K9fXxYuXGi1HPcbN27s6c0TEVGQy8n3TKNGjTKtv2DBAmnQoIHd+TlERBR4vDKzFGOav/zyS/nqq68kISFBXn75ZTWmuWfPni49H0MFhgwZYnfIgD8KtPYC28x9HAzHRaC1N1Db7I+y+p7B/JouqDh4DZYfPHhQPQ/r43mTJ0+WV199NWg/u0BrbyC2OdDaC2wz93GwHBc+qbqmmzBhgrz//vtqrk2NGjXk448/VlVviIiIPP09061bNzlw4IAsXbrUsj6qsSEg2r59u5rQ+vrrr7t8Ao6IiPyf1wIdIiIiIiIib/HPiyIQERERERHlAgMdIiIiIiIKOgx0iIiIiIgo6DDQISIiIiKioBMSCFV0KlasKJGRkeo6CStWrBB/sXz5cmnXrp2q1oMrac+ePdvqcdR5GDp0qHo8f/780rx5c1Xdx1dGjhwpDRs2lKioKClZsqQ8+OCDsmvXLr9u88SJE6VWrVqWK/Pi2hdz58712/ba2+c4Nvr27eu3bUZb0EbjDRdT9Nf26g4fPixPPvmkurhjgQIFpE6dOrJ+/Xq/bHeFChUy7WPcevfu7XdtJdfwu8l9+N3kffxu8oxA+l7KM99Nmh+bPn26li9fPm3SpEnajh07tPj4eK1gwYLawYMHNX8wZ84cbdCgQdrPP/+MynXaL7/8YvX4e++9p0VFRanHt27dqnXu3FmLiYnRUlJSfNLe1q1ba1OmTNG2bdumbdq0Sbvvvvu0cuXKaefPn/fbNv/222/an3/+qe3atUvd3njjDXVM4D34Y3uN/vnnH61ChQparVq11LGr87c2DxkyRLvlllu05ORky+3YsWN+2144deqUVr58ea1bt27amjVrtP3792uLFi3S9uzZ45ftxv407t+FCxeqvxlLlizxu7ZS1vjd5F78bvIufjd5RqB9L+WV7ya/DnRuvfVWrWfPnlbLqlatqg0YMEDzN7aBTkZGhla6dGl1kOguX76sFS5cWPvss880f4ADHO1etmxZwLQZihQpon355Zd+3d5z585pVapUUX80mjVrZgl0/LHNCHRq165t9zF/bC+8/vrrWpMmTRw+7q/t1uF4qFSpkmqnv7eVMuN3k2fxu8lz+N3kOYH+vRSs301+O3QtNTVVpftatWpltRz3V65cKf5u//79cvToUav24+qyzZo185v2nz17Vv0sWrRoQLQ5PT1dpk+fLhcuXFBD2Py5vUj73nfffdKyZUur5f7a5t27d6vUNIaJPvroo7Jv3z6/bu9vv/0mDRo0kEceeUQNw6xbt65MmjTJ8ri/tlv/2/bdd9/JM888o4YI+HNbKTN+N3kev5s8h99NnhPI30vB/N3kt4HOiRMnVMe2VKlSVstxHzve3+lt9Nf2IwnVr18/adKkibqCuD+3eevWrVKoUCH1C4arlv/yyy9SvXp1v20vgrENGzaoMdC2/LHNt912m0ydOlXmz5+v/iijHY0bN5aTJ0/6ZXsBgRjmb1WpUkW1G8dFnz591PsAf203YC7fmTNnpFu3bn7fVsqM302exe8mz+F3k2cF8vdSMH83hYmfQ1Rp+0fQdpk/89f2v/jii7Jlyxb5+++//b7NN998s2zatEn9Av7888/StWtXWbZsmV+2NzExUeLj42XBggWqgIYj/tTmtm3bWv5fs2ZNlS2rVKmSfPPNN3L77bf7XXshIyNDnTl799131X2cOcMESXzJdOnSxbKev7UbJk+erPY5MmhG/thWcizQPy9/bT+/mzyD302eF8jfS8H83eS3GZ3ixYtLaGhopqjx2LFjmaJLf6RXrfLH9r/00ksqxbpkyRKJjY31+zaHh4dL5cqV1R8QZElq164tY8eO9cv2Yrglto8KgWFhYeqGoGzcuHHq/3q7/KnNtgoWLKgCHgxn88d9DDExMSqrZ1StWjU5dOiQ+r+/tvvgwYOyaNEiefbZZy3L/LWtZB+/mzyH302ew+8mzwvU76Vg/27y20AHnVt0FhcuXGi1HPcxrMbfYa4DDhJj+zH+EZ1eX7UfUTjOls2aNUsWL16s2ujvbXb0Pq5cueKX7W3RooUaaocMlH5DgPbEE0+o/994441+12Zb2LcJCQnqj7Y/7mO44447MpVG//fff6V8+fLq//7a7ilTpqix25i/pfPXtpJ9/G5yP343eR6/mzwvUL+Xgv67SQuAEp6TJ09W5aX79u2ryksfOHBA8weoXrJx40Z1w64cPXq0+r9e/hqVKlCdYtasWaos32OPPebTsnwvvPCCas/SpUutyglevHjRso6/tXngwIHa8uXLVZnGLVu2qPLSISEh2oIFC/yyvfYYq675Y5tfeeUVdUzs27dPW716tXb//fercpL675m/tVcvjxoWFqa988472u7du7Xvv/9eK1CggPbdd99Z1vG3dqenp6ty7qjMY8vf2krO8bvJvfjd5Bv8bnKvQPxeygvfTX4d6MCnn36q6pKHh4dr9erVs5RC9geoM44Ax/bWtWtX9ThK86F0L8rzRUREaHfeeac6UHzFXltxw7V1dP7W5meeecby+ZcoUUJr0aKFJcjxx/a68mXib23W6+LjpEKZMmW0Dh06aNu3b/fb9up+//13rUaNGqpNKDv/xRdfWD3ub+2eP3+++n3D9aBs+VtbKWv8bnIffjf5Br+b3C/QvpfywneTCf/4OqtERERERESUJ+boEBERERER5RQDHSIiIiIiCjoMdIiIiIiIKOgw0CEiIiIioqDDQIeIiIiIiIIOAx0iIiIiIgo6DHSIiIiIiCjoMNAhIiIiIqKgw0CHiIiIiIiCDgMdIiIiIiIKOgx0iIiIiIgo6DDQISIiIiKioMNAh4iIiIiIgg4DHSIiIiIiCjoMdIiIiIiIKOgw0CEiIiIioqDDQIeIiIiIiIIOAx0iIiIiIgo6DHSIiIiIiCjoMNAhIiIiIqKgw0CHiIiIiIiCDgMdIiIiIiIKOgx0iIiIiIgo6DDQISIiIiKioMNAh4iIiIiIgg4DHSIiIiIiCjoMdIiIiIiIKOgw0CEiIiIioqDDQMeLTCaTDB06NNvPu3jxonre0qVLMz329ddfq9c9cOCA+AN77WnevLm6ZceOHTvUe87u+7LdFp6P9nz44YfiTu+++67Mnj0703J8Rtievc/KG958800pV66chIWFyQ033CC+NG3aNBkzZoxbfxcCiaNjxBX6cTRz5sws1+3WrZtUqFAhR9shIiIKZmG+bgC5FugMGzZM/d82YLjvvvtk1apVEhMT47e7csKECdl+DgIdvGe83+x04nKyrZx2Yjt27CgPPvig1fJ69eqpz6N69eribb/++qu88847MmjQIGnbtq1ERESIrwOdbdu2Sd++fTM9hn0UGxsrwczRMeJugwcPlvj4eI9ug4iIKBAx0AlwJUqUUDd/5o1OP4LBAgUK+CTAMIqOjpbbb7/dJ9tGUAF9+vSRkiVLij/z1T4KRpUqVfJ1E4iIiPxSQA5d27lzpzz22GNSqlQpddYaQ3W6dOkiV65cUY9jSAyGfbgyrArZgvvvv1/++OMPqVu3ruTPn1+qVaum7uvPwf2CBQvKrbfeKuvWrbN6TUfDslwZTnL8+HHp1auX6pwXKlRIdU7vvvtuWbFihWUdtFUPZJDhQPtxw+vbe084e462pqSkZNpe586d1T67evWqZdmPP/4ojRo1Us9BG1q3bi0bN24UV6xevVruuOMOiYyMlDJlysjAgQOtXtvZPpo4caLUrl1bbTMqKkqqVq0qb7zxhuU9PfLII+r/d911l+U9Y7n+ejVq1JDly5dL48aNVYDzzDPPONwWZGRkqGwHjhW0t0GDBvLXX3+59JnZHk/4/4ULF+Sbb76xtE3fpqOha7/99pvaz2gr3u8999yjshr2trN9+3Z1fBcuXFh9XnhvZ8+edfpZoN0YtgZ4jnFomKNhYniOfhzp+x3rLlmyRF544QUpXry4FCtWTDp06CBHjhyxm7HBe8JniFudOnVk8uTJ6jHsjz///FMOHjxo2Ue2+9C2TQjU2rdvL0WKFFGfEV4P+9hI378//PCDylzhuENw2bJlS9m1a5fTfWTcx1u2bFHHGPZx0aJFpV+/fpKWlqZeo02bNuozwv55//33rZ5/+fJleeWVV1Tb9OdiHyCbZuTsGIHDhw/L888/L3FxcRIeHq7eB7I///33n9Xr4Pcpq/dp77jF9l588UX59ttv1d8vHHf4fdP/rhmh7bVq1VJ/S2+88UYZO3asw7+hREREgSTgAp3NmzdLw4YNVSf77bfflrlz58rIkSNVkJOamprj10Qn/fXXX5dZs2apDgw6d0OGDJEvv/xSDUH5/vvvVWcTQdGlS5fc8l5OnTqlfmI76BROmTJFdTTQIdI7yhiSNm/ePPX/7t27q84xbhiuYg86xchuzJgxw2r5mTNnVIfmySeflHz58qlleF/oUCPQwvroFJ07d06aNm2qho45g8dbtGihXhcd5M8++0wFSCNGjMjyfU+fPl0FeM2aNZNffvlFzWN4+eWXVcdQH46HtsGnn35qec9YrktOTlbv5fHHH5c5c+ao13Nm/Pjxaj9izsh3330nISEhaniXbbDhCjwHAfG9995raZuzIXMICNCBR0cVHXQEA6dPn1af899//51p/Ycfflhuuukm+fnnn2XAgAHq+dg/zmA/4vgAvE+06dlnn5WcwPNwjGC76OjjWMS+NnrrrbfkiSeeUB1wfP7YfteuXVVgA9gfCIJLly5t2UfO9jU67whaEeSNGzdO/R7iuEQn3jbYAATF2BZ+P7/44gvZvXu3tGvXTtLT0116j506dVIdf+zj5557Tj7++GO1jzHMDMcZ3g9OOuh/E3T4O4Pf21dffVUdt/g8mzRpov5eTJ061aVjBEEO/oZhGwiw8DcMxyX+7uC4cNf7xN8UHPf4O4n3iaDsoYcekn379lnWwbGCtiOgxUkP7Gu8J9sAk4iIKCBpAebuu+/WbrjhBu3YsWMO1xkyZIhm761NmTJFLd+/f79lWfny5bX8+fNrSUlJlmWbNm1S68XExGgXLlywLJ89e7Za/ttvv1mWNWvWTN1sde3aVb22EZ6LtjmSlpamXb16VWvRooX20EMPWZYfP37c4XPtvad69eppjRs3tlpvwoQJar2tW7eq+4cOHdLCwsK0l156yWq9c+fOaaVLl9Y6deqkOdO5c2e1344ePWrV/qpVq2Zqj+0+evHFF9Vn6MxPP/2kXmfJkiWZHsNr4bG//vrL7mPGbaEdWLdMmTLapUuXLMtTUlK0okWLai1btnT6mTk6ngoWLKjWt4X2Gtudnp6utl2zZk31f+N+LlmypNXnpG/n/ffft3rNXr16aZGRkVpGRoaDvWX9fBwvRo6OHbxX43vQjyVszwjtwfLk5GR1f9++fVpoaKj2xBNPOG3PfffdZ3d/2mvTo48+qkVERKjj0qht27ZagQIFtDNnzljt33vvvddqvRkzZqjlq1atcmkfffTRR1bL69Spo5bPmjXLsgy/iyVKlNA6dOiQ5e9s9+7dtbp167p0jDzzzDNavnz5tB07djh83ey8T0d/a0qVKqWOcx1+V0NCQrSRI0daljVs2FCLi4vTrly5YnVsFitWzO7fUCIiokASUBkdZCqWLVumzsa6c14KhqGULVvWch9DPQBn3DHkw3a5ftbaHZAJwQR2DNVBpSycSceQqoSEhBy/5tNPPy0rV660GuKCbBHOImPIF8yfP18N1cGQP/zUb2gHMi1ZVQ3D8CZkdDBMShcaGqqGx2UFQwCRCUI2CVmmEydOZPs9YngTzri7Cmet8d50GJqEM+MY/uZqFiAn8Blg2NdTTz2lskg6DPVC5gaZSRzXRg888IDVfQwrwpCpY8eOeaydWW3feNwvXLhQ7bPevXu7bZuLFy9WxxOGchkho4P9Y5sNyqqNWUFm1gi/2xiqhSyfDr+PlStXzvSaP/30k8pW4TPUf2eRpXP1dxYZHAzJ1P+eOJOb94lt4DjX4XcVw2P15yKDiqG4yGJh+JwO7wu/G0RERIEuoAIdDOtAB8vd1ZowpMNI/9J3tBydTncYPXq0mgtx2223qaEl6PSuXbtWzRHIzfA4DCnCeHt9TguGmeF1EQDp9LkACH7QUTPeMIQlq+Dj5MmTaliSLXvLbKHT/9VXX6kOFzr76HxhH6AD7arsVplz1FYMdzx//rx4CvaTo/Zi2BfmDtkOV8IwIiO9epq7hkxmJavtY24ZuPP3EPvJ0T7SH89OG7Ni73cbJzWMwbC+3Pj7jmFsONGCEyMYAokADL9bGDLq6t8F7D9X911u3qftc/Xn68/FcYfkj/Fkhc7eMiIiokATUFXX0DlB1iApKcnpenpnBePpjSV2c5I5yAq2ZW+iuCvbQkcJWSNMzDfCPJncQLYDc0IwZwBzZpDNQTuRQdFhojngOh3ly5fP9jbQiTp69Gim5faW2YOgCzecVUZWBfOUcJb933//dak92Z0o7ait6MjiDDZgH+kFLYxyc9zonU3MKbKFTA+yPPi8PAm/A/bel23w4Co9m4rfQ9sMTG72k6N9ZDxefQ2/sxUrVlQnA4zHoL3962z/ZfU3zBtw3OE92BZAyM7vMRERkT8LqIwOJvdiWBWGjjjrfOoViFBZyej33393e5uwLXTOjR0ddCAxdCwr6GTYXusEbbYdppOTM/oIItBJxER9dM4wCdl4AUlUV8Owm71796oKZPZuWQ2LwRA7YycJ2TZ0ALMD1d4wXAiVpZBdwWT0nL5nZ3Am3njGHcEkjgcUXkDwrH+WGB5mfE9oE4b5OTsz7szNN9+szv5jYr956oQZAjxk8fRKbJ6E92X7u4ChYjnNZLVq1UrtM9sAPaf7CDBsDW2yre6GYB37x1/KUeN3FsGxMchBUGBbdc3Z+8fxjqGfrlSJ8yT87uH3HEUVjIVccFzYq85GREQUaAIq0NGHe6HkKoY6TZo0SXUYUMUL1bf0TAgqHSH7gypU+BLHlzZKtyYmJrq9PRiGhSpMqEq1YMECVbEIJWBRYSsryGDgOchmoJOHjiMCEJwxNsI4e2Q50JnC+hhXbyyR7agziuExqEaGjphx2Jre+UU1JgQYPXv2VPsJ859QfQ0VpdAmZ/RSxpgng+AGQQOqVemV05xBlStc6wXPQzYH20Q5W1SdwlA60OcSodIUKpPhPec0AwHomKOkMypdIcBAxxoluPULsQLmF2G9Rx99VAWICI6wH+3N4alZs6aax4T3jbY56rQiY4NKVps2bVKfN8pMI1BHoIh5Su+99554Go5RzAtBpTQEp5988okaMon9nRM4dlANDFX6UKIZ+0l/XeNxg32EwBHH9T///JOpNLsRnodhk9gvqHCI9uJ3CpXD9GPDH+AzxGeN3yv8zqI6Gaqu2Rt25+gYwe8dMlR33nmnKuWM18E+RLlplM73JrQFVeDwdwd/A/C7gb9fyHKyvDQREQW6gAt0UBIWnab69eurktCYz4ISsDh7qs+hQZCBsqkIENBZQkceHWd06t0Nk5LR2UEmAsPFMFQM7bJ3LRdbaA+uyYGJzAgSUEIWxQnQcbKFdXBmG5OTEQzYuy6KbQcbhQb04UXo2NtCOzF0DRkplAZGZ+e1115Tc2fQCXMG+3PRokVqX+O56KRhorSjstdGyKLgmim4mjuCD5T1RTllXD9IHxaFYA8ld1H6G/sS7zk3GTlcUwTbQoCFoBiFF9CJxuenwzYRTCIAQWDcv39/1ZHHfrSFDmqVKlVUUIS29ejRw+G2sT10IhGoIZhC0In9hiDd3mftbngfuGHOFiaZozOL4NKY4ctJBxnZFhwrmBOGCe0YImkM0vH5Yj8iKEJGRg9iHWW+kAXFTxQ5wOvhGMFrou3+Ap8dglMEYjihMmrUKFUCHJ+xq8cIMnz4G4agCa+Fv2EvvfSSGgJrO3fI07BtHA/6sYly18j+4m9Zbo4PIiIif2BC6TVfN4KIiPwDMuZ6JUpkkImIiAJVQBUjICIi98IQX2Q7MfwOw1yRVUapbGSkiIiIAhkDHSKiPAxzGzEvD2WvMU8K1/XCHDXM1SEiIgpkHLpGRERERERBJ+CKERAREREREWWFgQ4REREREQWdgJijk5GRoS4kiHLRvLYDEZH3oDAn5vGUKVNGla0nfjcREQXKd1NABDoIcnAtGCIi8g1ccBkXIabr+N1EROTf300BEeggkwP79+/3+gX17F1jAteWaNWqlapQxLZw3/CYCfzfJX9rjz+1JSUlRZ1o0v8O03X8bvL/45dt4b7hMZO3v5sCItDRh6vhzeCK8r7+kAsUKKDa4esP2Z/a4m/tYVu4X3jMuBeHDTveJ/xu4t/fQPte8rf2sC3+v1/8sT2ufDdxwDUREREREQUdBjpERERERBR0GOgQEREREVHQCYg5Oq5KT09X4wc9Ca8fFhYmly9fVttzB4xzDA0NdctrERGR98qbYjJsamqq+k7wJU98N7Etwbtf/K09bIv/7xdvt8ddfeOwYPmyOXr0qJw5c8Yr2ypdurQqZ+fOybk33HCDel1O+CUi8n8Ibg4fPiyff/65nDx50ivfP774bmJbgnO/+Ft72Bb/3y++aI87+sZBEejoQU7JkiVVNQhP7nxcvPT8+fNSqFAht1w8DwfNxYsX5dixY+p+TEyMG1pJRESegr/bycnJ6sxmiRIlpEKFCur/vuTu7ya2Jbj3i7+1h23x//3izfa4s28c8IEOUmd6kFOsWDGvfMg4kxcZGem2Dzl//vzqJz5QvA8OYyMi8l9paWnqSxhnGnEtB3wf+EOg4+7vJrYlePeLv7WHbfH//eLt9rirb+z7vZZL+pwcZHICmd5+T88xIiKi3NHHpvvLdSSIiIJRATf0jQM+0NH5w9jFvNx+IqK8hn+3iYj8+29s0AQ6REREREREOgY6REREREQUdBjoXJOekS5LDyyVH7b+oH7iPhERUbB876CS0fPPPy9FixZVQ0I2bdrk0e0Fk27dusmDDz5oud+8eXPp27ev27czdOhQqVOnjsPtutOwYcOkadOmHnltyhlUcBwzZgx3nxsFfNU1d5iVMEvi58VLUkqSZVlsdKyMbTNWOlTr4NO2ERFR8PHF9868efPk66+/lqVLl8qNN94oxYsX98h28oJZs2a5XIwCQRGCl9GjR2e57quvviovvfSSuBsC219++cUqaHrllVeka9eubt9WMMLvzF133SWnT59W13bJLfweIlC2vf7W2rVrpWDBgrl+fbouz2d08GXTcUZHqy8bOJxyWC3H40RERIH+vbN37151PYrGjRur0tj2SmKjdCxlDVmxqKgot2bbULYc1yfxxqUyANvC+yD3ye3vD67LFYhVhK/6ccXgPB3oYJgAzqhpomV6TF/Wd15fDmMjIqKA/t7BEChkCg4dOqTO7mOIjJ5tePHFF6Vfv34qw3PPPfeo5Tt27JB7771XdYZLlSolTz31lJw4ccLyehcuXJAuXbqoxxE8ffTRR5mGc+G6F7Nnz7ZqB86G42y27vDhw9K5c2cpUqSI6uC3b99eDhw4YNVuZCE+/PBDtR2s07t3b6uO1ZUrV+S1116TuLg4iYiIkCpVqsjkyZNV8HDTTTfJJ598YtWGbdu2qWuAIPBzVD4c+wNtxfbw2ngtI9v3OmHCBLVdXF8E+6tjx46W9i9btkzGjh2r9gfeJ94fMgT4HObPny8NGjRQ7V6xYkWmoWvGYWa4lkh0dLT06NHDqkNtb7gTXgOvpT8ODz30kNVnbzt0DddIefvttyU2Nla1B6+BLKAO7cbzkc1CdgMd8tq1a8uqVavEGWQtMGQS+wX7p0aNGvLHH39YHv/555+lZs2a6nFkGnEsGaG97777rjzzzDMquCxXrpx88cUXVuskJSXJo48+qgI3ZESwT9esWWN5/Pfff5f69eur7WMbeO8ILHV4X19++aXaRzimse5vv/1med94v4DPD+vic3X2+4PsHd4T2oLjslevXupCm4DP/umnn5azZ8+q18LN+FkZP0v8vj7++OPqc8etU6dO8t9//1ke14+Xb7/9Vj23cOHCaj+cO3fO6Wfyv//9T5o1a6Y+Q7yn1q1bq2yVvTbYHk+AY/mzzz5Tv694j/pxg2VGGzZsUO9v37596j7eM44F/Vi+++67ZfPmzeJJQTl07eLVi7LzxM4s11t3ZF2mM2q2XzqJKYkyeeNkaVCmgeUPAf7AF7xQMNPFkqoWryoF8gVeJE5ERP77veOMq9876GhXqlRJdRAxPMZ48b1vvvlGXnjhBdX5QYc+OTlZdYKee+451WG7dOmSvP7666qTtXjxYvWc/v37y5IlS9RwKGSH3njjDVm/fr3dTrojuOgqOpDobC9fvlxlmEaMGCFt2rSRLVu2SHh4uFoP20GQg5979uxRgRG2g/YBAi50tseNG6c63vv371dBGTpY6FB+9913MmjQIMt2v/rqK7VN7A970NHGOgiWqlevru7jfaJTZs+6deukT58+qrOJbNmpU6dU0KLv93///Vd17tFRRAcUHV90YAFBFII4dL4RWCEosvXXX3+pDjrePzrdeE/oVL/zzjsu7Wd83uhYTpkyRe1bRxdeRFvxXj///HOpW7eu2gcPPPCAbN++XQVxOuxLtBnL8P/HHntMfS72MoToM7Vt21a9b3wO2OcIovU24JjBcTVkyBAVWONzR+CAAFMPJvTPZPjw4eo4mzlzpjpe77zzTqlataoKIHC8li1bVgUnOB7Rwca2AcHkk08+qY4PfO4IcNHZBmxXh+Dn/fffl1GjRqnjHsH9wYMH1eeFYOzhhx+WXbt2qQ66fjFLe78/gP4htoegAccjAh181giIcYwgkHjrrbfU6wGCK1t4rQ4dOqigE5893g9eB8c/giUd3g9OKCB4RLCC/fnee+85PD42bdokLVq0UIEj2ojPDa+vXx/MVdh3I0eOlI8//lh9nvg78f3330vPnj0t60ybNk0aNWqkjm+8n/vuu08Fo3PmzFFBGY41tAW/I57KLgZloIMvm/pf1Hfb6/X4o4dL661/fr3Ui6nntu0SEVFg8PfvHXQqcDYcHRJ0BI0qV66sOng6dMDq1aunzqLr0OlFhw8dkjJlyqggYOrUqZYz2Ojs4YxudkyfPl11CHEmXb9eBjrj6PCjI9eqVSu1DGecx48fr9qOji06S+j8I9BBe2bMmCELFy6Uli1bqvXRqdKhs4wO2T///CO33367ygShw/3BBx84bBc6oQMHDlQdW8BZanSWHUHQgrPa999/v9rH5cuXV4GCvt8RsOHMOfY7fhoDDZwJ1/ehI3g+9j+ee8stt6jnINBEx9+Vq9NjOBRgv9p+9kYIXhDQIiMA6PCjA4z98emnn1rNI8JnoAcHaBMCHXw2thYtWqT2fUJCgsqu2X4+CCjQ0X3zzTclJSVFHXc7d+5Un48x0EEQhE4+oI3oXOMYwTbRmT5+/LgK6PTOMo5pHTr8AwYMsMxHwvax7xB4GAMdbA9BGwKKwYMHq5MCaDuCQ/11ETDaztGx/f0BY7avYsWKansIhhDo4PPEcYFj3tnngX2HwA+BCQJufNYIprG/8V4bNmyo1kN7kSXVh1IiQMPvh6NA5/3331cZL7RFh9fMLmSaECzpnnjiCfV5IjjE7wDahd9xBKeAY2nr1q1y7NgxFbzpxxyCNASvevDpbkEZ6OAMF/74u3JmzZUvk8/v/zxzRqeg/YwOERHlPZ783slqu7mFTo8RzrKjU2LvLDPOHuPMLYZO4UytDh3Bm2++OVvbxXbQQbad63L58mWrYWXohBmDA2R30GECdALxGM7o24N1ETAhgEKgg7PeeP1HHnnE7voYWoOMlvG94Yw39pHt8DUdAhV07NCBRqcYNwyBcmWuhe2+twdZKuNroW3IYiQmJqrtugOCjCNHjsgdd9xhtRz3bYcW1apVy2r/Ajqv9gIdfD4IgPUgxxYCIAx/st0mgitkGPTP3bhNPUDANvVtILB0lBHAcYbAwNjxx2vjOEBWUd+3xm2gj4fjUt9Gdj9D/P7gRAGyV9i3GCaH7en9R1dg3+DkgvEEAgIeBFp4TA90kDUy/g7hM3HW7k2bNjk8/rPD9n3jM8Ax8MMPP6jAEtlJtAMZJv1zwHFrOwcNf08cDSN1h6AMdJDGd+UMV+1StWX48uFqAqi98dImMakqON3rdpfQkFBLoIODFqlLV86kEBFR8PPk946n2Xa88D3Xrl07dUbfFjpRu3fvdul10SG1DQ6Mc2uwHcyFwHAXR1kIsK1uhtfVhyUZhxA5gjPcOJuOzjMCHgz9ceeEb3QyMVQKGYYFCxaojBiGqaFznVWFrtxU2NKzYOiLONvPOXlNHV7Xdpnx89Af0z8PW1l9PvZe315AmZtjAOsh84RhYP9n7z7AmrraOID/k7BRVEQREQFxoThQ67bVuncddbVardbZKtpqHbVV62yVaodWq9a9R9W60LpQ6udCQZbiZMmSvULG97w3DbJlBBLg/fnkwdzcJCfnBs597znnPdnRkMCCvEdhjiH1aFAPFA3hop4cCsCuX7+OiRMnFuq45FY3uW0vbLmN31JfBf0+5fbdpV4d6mGjQId+0twfdXZHKhP9/cg87E5NE5ns8lKhz9SpEaFUnurGJTP1/fV91pdaY8MYY6x8KwvtDg0fonkZdKWYhuVkvtHJDf2kk6ubN29mPIfmBtAwsuzBCvWOqFGARFfQM78PbaPhQNnfh4b2FARN+KYTqNzmtqhRjw6Ve9OmTTh79myW4TbZ0fvSyVjmz0ZX4+lqdH6o14eGztGwIBpuRHNp1POZaKhSYec/ZEY9KnTVW43KRr1t6iv92euZLsbSvJDM6HjlVwa6eEtDEumEPDMPDw84OjoWuezUS0KJArJ/NzL3UOT2ntQDlNdcotzeg3opaG5Ubuh7RnNhsn/H6FbQC9bq+WIFOY40Z4u+MzSviHoR6bNQb1n213vba1Hd0LBIqj816iGiXsfiHpN//vknz8cL8n3Kbzgb9bbS7wsNR6PAJ/NxePXqlfC7kv04lGSq+wod6BBar+DIiCOwNrPOsp2uqNF2XkeHMcZYRWp3KKsZnTTSfAWao0AZk6inggIEOjmjk2y6Ok3zROiEibKY0fyG7CeNlGiA5tZQbwed/NEV7sxXn+kkiE5waOgSTd6nkykKWGbNmpXl5C4/FIzR3AsqG431p9egK8Y0b0eNTphpH5p3QydVmYel5YbenyZzUwICmi9Cc0Oyr3eSGQ2Ho0nddLJNV/Np7hIFX+qhfFRGygBGwU90dHSBegkyo2GCVN90kkuBGs0roQn76vqmJAk0d4PqkI4FfdbsQQKVgY4VnWiqs2tlR8eTevEOHjwoBAZ0VZ4+E9VHUdGQQkoaQPOdaB4VHR/6DOpsbrSWD5WLklDQMEaa60XfGZoHVFD0PaWhbJSdjxIC0PeVkgeos8FRDxsdE+plowCehn3RZ6R5QQVFQwSpp4SONc0HUmdQyw0lXKBAh7L9UVno2GTPRkbHg16DPjslzsh8AUCNAmcKSmjuCv0O0e8iJd6gOi3IkMe8LFiwQOhtpO81BeX0HaeLAOqsigX5PuWF5iNRsgX6vlIdZB6WSJ+HfvfoONGcN/p9oKCWjgP9fSgpFT7QIdSoPJ/1HJc/uYx9Q/cJP5/Neqb1xoYxxlj5pMvtDl3ZpxNGCmpo6AllDKOTXertUJ9c02RxOoGlrFx0AtO5c2dhGFpmNNGY5hjQfnSll05eMw8Zo/9TtjVKF0zDiugqNQUs1HtBPQwFRSdplM6ZTtxojgAlKaC5EJnR61LAkF9vjhqdfNMJJQVvdGJGQ9Nozk1eaNgNpVymE0T6DHRSS/MU1BO86XPTiSLVIwVa6oxrBUWT9SnDGdUjzXegYYWZU/3SiSs9RskQaMgUnUhmzyhHvQsUaNDxUCdKyI4yx9Fnpxv1lFEwQlnMMmdcKwoKOmg+CQUk1EtBSQDUvRl0lZ+CUgo86ASZPhclW8iciOBtqHeEAnHqGaTPT2WnQFV9ck7fYQpQ6PNTOaiXhSbNF2Z+E2V0o+FvFPxRGmwKNPOiXhyWgkY65jQ0k7KTZUaflQJ/GkZJPSjZkxkQdSpv+n5RGmv6PaN5YFRXxdGwYUOhvqinsG3btsJ3/MSJExlZ8wryfcoPXcCg16bf6czD5OjzULY1em36PaRyUOILCnioTkuKSJnX7DodQt1m9AeWos3sk5hochddIaAoMvNYy5JSUnN0ivI5aMwkfWnoi1jQFZpLki6Vh8vC9cLfGc3+/aXhEoU5+SzP1H+v6QSdrg7TiU1uqXVLky7MH6WTMfVJnrbLkr1eaDgNBSLUU1SSJ1UFKYsu1IuulYfLovv1oo3y5HduXNC2Sfu1xhhjjDFWAmgxURo+RMO9qDdEW0EOY0w7ymXWNcYYYwUjV8hx5fkVXHp2CU9jniIiIQJhiWF4Ff8KMbIYIJVrkpVdNISMhrKpV49njJWPdsv9hWpR3rcpdI8Ojael8aE0hpfG29Hkv7ehyYU0dpe6nWh8YfZJWYwxxkrfMb9jsFxriR67e2Dl9ZU44HMAl15egt9rP1WQU0Zwu6QbKAkApXDWJTTXgxIA0ORrmmfBGCv77ZbdBjt0bD6gZAIdmuBHi1dRVoyCoLF1NGejS5cu8PT0FFZIpQlvNDmNMcaY9hqLYYeGIToluswfAm6XGGOsYrRbww8NR/DT4AIHMIUeuta3b1/hVlDUe0MTNtVXeSgjCaWRo2wslG6QMcZY6Xf7zzw7s9xUO7dLjDFW/tutWedmCQsty34FsuZV1OIcHcpjTot1ZUap/rZt2yZkxsotOxdNHqRb5swKhPbPvjor3afEcZQJorC56YtCnaRO/Z6aQq9Fr0mfp6D5ytV1UdQVkDVNl8rDZeF64e9M3q6+uIqQhJACVVGvQMAN5UtR2qXMbROlKaa/2eoUuZpuD3SpbeKylM960bXycFl0v160UZ7M58bXg68jOD4YiKDFlYFnYwHs1oFAhxanyp7lhO7TQkKULppWIM6O8o1TvvLsLl++nCUHP6GUnrRQFC28RI1PaUlISNDo61HZae0AGmtOdVMYlBtel+hSebgsXC/8ncnpWsy1AlXLhHvA2pNA1qT+ZV9R2qXMbROtv0GjFdSr1dPFuIJeoCprbVNxcFl0v150rTxcFt2vl9IsT+Zz40uRl1TbNgMBXwPBXXQk0CGUtCC3iDD7djVarGjOnDkZ96kRoUWuaJXl3NbRCQoKElZqLo11dKjsdIBpAbG8yl8U9DloYSVaSKkw6+jQiXzPnj21vm6NrpWHy8L1wt+ZvJm+MIXrC9e8d1ACC9yBlZeAn1oCuI9yp7DtUua2iRrf8PBwoV169OiRsIaDtgOdkmqbuCzls150rTxcFt2vF22UJ/O5sWG4ITbec4XfciCmNdBoRcFeo8QDHeptoatnmUVERAg9MdmDFjVDQ0Phlh2dPGc/gaahA1TZtHBRaSxepO6qU7+nptBr0Wvm9hnfpijPKUm6VB4uC9cLf2dy6lavG6wrW+c6fE2sANafA764BXzbFfi+ffkLdIrSLmVum6jxjYyMzAhuNN0elGbbpF7kUz2P1s7ODi4uLsJNk2Wh7GexsbEZmVqzv68mZX6vkmqzi0KXylLa5aH3OH78OD744AOtl+VtuCy6UzeZz4072zTD9cZArD3QbCGgd6eAr1HShezQoUOO4UNubm5o06aNzpwMM8ZYRSIRS/Bz359zbDeQAfuPANNvA1MGAN93RbnE7VLeKA3z5MmTC1SPFBQVNFDZsGEDduzYAU16/vy5cBJ0//79En+v8mrfvn0wNzfX2OstWbJECGCzCwsLK1QiK8YyS0sLwYO7nZFqBbR0AcwLGOQUKdChuTD0R0X9h4XSR9P/X758mdG1P27cuIz9p06dihcvXgjd/X5+fti+fbsw4fOrr74q7FszxhjTkKGOQ3F0xFFUN1b1YJilAmf3AIMCgGEjgC1tyk5Vl+l26eJFoEkT1U8dUKNGjRxzYYuDRl3QVeAqVaqgatWqKA2l+V4VRXHnQFMvam4jdXSdLiRXqugUCil8fUdD+SoYzl8AZo8K9/xCBzqUGtrZ2Vm4EWoo6P/ffvttRtSublyIvb09zpw5IywkRlH+999/j59//plTSzPGmA4EO+FfhcMh1RR39lVC20h9zJ/bCo86OaKaXjWUFWW2XaJ5QQsXAn5+qp//zRMqyfWGKOCjOa2UcGHdunVv7aWhK/S0RASdpNJC4bQOnnroGQWLs2fPFnpV1OP1qSeFegjOnTsHJycn4Xm0Hw0nyz5siZI/fP7550JQQkMGv/nmm4y5UiS3RclpX3VvDR1HQsea9qUykezvRZnyZs2ahZo1awpzYDt37iz0XKnR94Ce/88//wijTSjQ69ixIwICAvKtz+DgYIwaNUr4vKampsJz//e//2U8vmnTJjg4OMDAwACNGjXC7t1ZZ07Te27duhVDhgwR3rNBgwY4efJkln18fHzQv39/YR4YzYugNQmfPHmS8fiff/4pLNtBn6tx48bYuHFjjh6vY8eOCXOc6T1oHUTKOqj+3DNmzEBcXFzGMaTjrf4eLF++XKhLChw/++wzYfvXX3+Nhg0bCq9FC8AvXrw4Ixig40LJOh48eJDxeupjlf1Yent74/333xfmX9CxnzJlinDBQk19DGkpEvqu0j5U1rcFHlR/dByoPiwsLDB06NACf5/U9XXo0CEMGDBA+IxUn1RG+j5nRnVKx1xd5pCQEIwcORLVqlUTyjp48GDh9VjxyGRJkEpfQV+vOpwnpcKkYMlCs1KWAXFxcfSXTxkVFZXjsZSUFKWvr6/wszTI5XJlTEyM8FOTivI5pFKp8q+//hJ+6gJdKg+XheuFvzMFI/P3Uz6pCmVijapKpbd3nn9/6SfL+vc6MTFRefv2bWV6enrRqubcOTqtf3Oj+yXYNk2bNk1Zp04dpZubm9LLy0s5YMAAZaVKlZSzZs3K2MfW1lb5008/Cf8/fPiw0szMTHnmzBnlixcvlP/73/+UW7ZsER6Ljo4WXmvZsmXKsLAw4Ub+/PNPpb6+vrJt27ZKd3d3pb+/v1BPn3zyiXLw4MEZ7/Pee+9lvDfts2fPHqWJiUnG6xP63h0/fjzLZ6hSpYrwHuTWrVvCPhcvXhTen8pEMr8X1ceUKVOUtWvXFj6Hj4+P8Hi1atUy9r98+bLwOu3atVNeuXJF2KdLly7Kjh075lmXCQkJynr16gn70ed8/Pix8uDBg0oPDw/h8WPHjgn18NtvvykDAgKU69atU0okEuXJkyczjhG9J9Xhvn37hOfPnDlTqBN1uYKDg5Xm5ubKoUOHCt8zep3t27cL9UWorqysrJRHjx5VPn36VPhJ++/YsUN4/NmzZ8J7NG7cWPn3338Lzx8+fLhwjOk7S9/jVatWCcdYfQzpc6m/B7T9xx9/FMpGN/L9998rb9y4Ibw2fRZLS0vlmjVrhMeSk5OVX375pbJp06YZr0fbsh/LpKQk4XjQ5/L29lb+888/Snt7e+Xo0aMz6oaOEb3/1KlTlX5+fspTp07l+H5kR5+R6vjbb78Vfj/v37+vXLFiRYG/T+r6srOzU+7atUsZGBioDAkJUQ4bNkz58ccfZ3kebaPyqj9PgwYNlJ9++qnwe0XvPWbMGGWjRo2UaWlpSl085ywL5ZFKXyujou4o79+/rEwIDcz6t5LaJCFtztvbplLJulbqkpMBf/+SeW2FApKkJMDUlGZJZX2scWNAg13+jDFWou7cgahvX6TpAdf3r0FvJyeu8NJqd6ippuyi1I7QBF/6Sfd37aJLzwV/nQK2O3TlmYbn7dq1S8iMSXbu3Ik6derk+RzqBaMhRz169BDm1FLPTtu2bYXHqBeDkjFQLwPtkxlddacr8dQrkt+EZcpa99NPPwlX0anHg67y031170FBhtkRuoKevQyZe7FoaCLd1HNE/vjjD2HuMNXH3LlzM/ZdsWIF3nvvPeH/8+fPF3pSKPFEbplQaW4LJaSgniH1HJf69etnPE6fn3olpk+fntHLSD0pv/zyi/C6arTP6NGjhf+vXLlSePzWrVvo06cPfvvtN6E35cCBAxlzmqk3RY16IqlXTt1rQT1cvr6+2Lx5Mz755JOM/WhIpvo9qceladOmCAwMFF6Leoqo/nOrP+pxyT6ck3rd1KjX58svv8TBgwcxb948oeeDegvVy37kZe/evULKYPouUq8IoR5V6gWhz6NO7069I7/++qvwPaPeKvoM1OuW1/eDjh/1sGVenoR6sAqLev8GDhwo1A19fz/66COhJzQ5OVno5aFMwKdPn8bRo0eF/en40H7UO6fu2aSeNuotol6z7Gt2sbeTSiOQlvYSEokZ9PWNoSczEKKaouR5K5+BDjU2rVuXyEvTn+zKeT149y7QqlWJvC9jjGmUmxswdChSG9dH5+5RONGgCVewNtsdCnZ8fYE2hZwcVcB2h4Y70TwLSsSgRifoFGDk5cMPPxSGsdEQJTrx7tevn3ACSCey+aGhWjRs7W3at2+fJUUtlY1OdGlej6bSddPnpsCrU6dOGdsoaKCAjeZnZda8efOM/6tPtikbHwV42dEcMBoyl9dEfnrt7EkdqAzZkzdkfk866afAkd5T/R40VC23xE0UZNHSGhMnTsxy4k/DASk4Ksjnyhw05YaGgGV35MgR4TNQoETBM70fBQSFQXVDAYg6yFHXDc3louGC6jJSQJb5e0DbKRjOC9VXQYPk/LTO9ntMARZ952lYHAVSFODQcVIHMHfv3hXqg7ZlRkFy5mGG7O2o400qDYNUGgp9/ZrQ06sBkeg54OlZpCCn/AY6dIWL/viXAPpFpCtE9Aua40oVvS9jjOm6vXvpUjLQuzc8f5yJ14d6w8LEQtulqjjtDvXmUHIECo4yry5ObQq9TmF6dQrY7mSe+1JQ1ONCJ57U+3Hx4kWhd+LHH3/E1atX882aSlf2NbHGBr1G9nIXdnJ4Xusj0fbs2zJ/JvVjea3+Tp/xbQr7nurnqN8zv/dQ70O9U+3atcvyWPYgsTCfK7PMgQi5efNmRo9J7969M3qbcpvrlZ/c6iF7+bKXW/1YfuV+2zEp6Pcp++emwH348OFCLx59fvpJ83HUAT+ViYIj6qnKq9eRvR0dG+rFSU+PhIGBNQwMagnz6wRr16KoymegQ934JdWzolBAHh8P0BUMHciDzxhjuZEr5HB/6Y6Q+BBEJkcK2dWiU6LR+cgttFm3H4GDuuDvr97Dda8twv5+kX5oYN5ASD3NSrjdOX9e1XuTV69OVJQQhGoSDauiE0c6WVX3UMTExAgLnqqHa+V18jho0CDhRpPBaQgRXVVv1aqVcAJIvS9FRWXJfp8m5KtP1OkkkRJJqD1+/FgYPqRG70/yKwN9btrv+vXrwlAr9cktJbAozlpB1EtCQ5Vev36da68OJQig98yc7c/Dw+OtvSjZ34OGF1J5s5/0W1pawtraGk+fPhWGVhUVvW5Bj+GNGzdga2uLRYsWZWyjRBOZFeQ70aRJE+FzqS8aq1+bLh4Xpn5yqy8a2jZhwoRcH3/b9yk/VMfUg0PJIS5fviwMG1Sj3wUavkfJLgrbu8VUlEoFUlOfQiaLhaGhHQwMMl14UyqhDA5GUZXPQIcxxiqwY37HMOvcLATHv2kcRApgzUWgjQewsjOwyNkduOSe8fjQQ0OFYGjLwC1CNjZWQuiK8uLFb+bmZEfb6XEaFqPBlcdp7gQNc6I5KTSnhU6U6YQ1vzk0lI2KTlqpx4DmJlDWMAp86GSXUOBw7do14So3ZVejLFeFQUOvaO4KZdy6d++eMD8lc+8AzRGhORo0xI2umlPGr8wn/HRiqc6IRXONaC5N9mFbdCL96aefCs+l8lGQ98MPPwgnuFQfRUXzamhODWUGW7VqlTCsytPTU8hMR0PwqJ5HjBghnAR3794dp06dEhbMzJ71Kz+UkY7qhOqXUqTTZ6NgkIbd0ZBDypBGWfDo5JrmH9HVbwrgKIClei0Iqg8agkYBAg0no+OcV3pxChpp3hb14rzzzjvCPBX6TJnRd0Kd3p2OCQ3nyp5WmoKG7777TphHRJ+BhuHRvBjqJaHvZVHRa1JdU6Y7qjMaVnf27Flh/lBBvk/5oYsBVDYqO31Geo3Mn4d6OmmO0bJly4TPTfVEmdnoe5DfPDgGKBQypKYGQi5PhpERXZDJJTV8AXog88JdEowxVs6CnOGHhmcJcvTkwM6/gC89gJl9gEU9cp/VST0+ww4NE16DlRBaj4RSXefVcNP2oCDVfhpGJ2Pvvvuu0DtDCQYozXL2+QiZ0WRqGhpF8yfUV8vphJ0CJUIndZRCl04sizJEh3o7aFI6nbhTb9EXX3yRZV4LBT00fI7KPGbMGGFifOaTcBo6RJPYafI9BRh0opnXCTBN2B87dqwQeNB8ivPnzwuT3YuKei5o8XMKtmjuUrNmzbB69eqM3igKgGjhUqpzmmtCZaTkB1TnBUX1fOnSJSEQoRNtOlZ0PNQn55MmTRJ6lSggpfenfej/6rTbBUFBLAWaFGTQMaQgMC9Uv5ROnAIwSstOPVSUXjozStFO87konTW93v79+3O8Dh1Dqn/qDaOAiYaFURCS33sXBKUXP3z4sDCXhspHr5k53ffbvk9vG/ZGwS2lzs7eg0avQQE/BY30PaPePAqu6bvNPTxvXyMnJSUAcnkqjI0b5h7kpKQUeX4OEVHqNeg4ynBBVzKioqIy/sBmnuxFVw/oFzu3zCiaRlcBqDzqbByaUpTPQd3ZtBYE/ZEt6FWJkqRL5eGycL1UxO8MDVez22CXJcgxTQOOHALefwaMHQocKkBitTpmdfB81nNhGJv67y+ttcGNdta/13RiQxOr6aTqbRP0s6BAJjIy78dr1gQKeRW4pNqmouCy6H696Fp5uCy6Xy+aLo9cnoKUlMfC/42NachqzjlWqSkpeHrdHfU+mwyjbMMk42lxYOCtbRMPXWOMsXKC5uRkDnIskoDTe4HGUUDfj4FL9Qr2OvQa9Fpd7VQLMDINs7FR3RhjrAKSyRKRkhIIsVhfCHLEYtV8uxwocYW86MPWCAc6jDFWToQlvJloaxsDuO0GqqQBXccDnrWL/lqMMcaYJlDCgZSUp5BITIQ5OWJx3qGIIjGh2O/HgQ5jjJUTVpVV6080fwWc2wMk6QMdJwJPzYv+WowxxpgmSKVRSEt7DomkKoyN60Ekymf4m1IJRXh4sd9T+wP+GGOMaUSXul0wPMIC1/4EQisDnYoY5NAcHXotxhhjTDNr5IQJQY6+vgWMjR3yD3JUT4JYA0lZuEeHMcbKCcmx4zjwRywu2QBDRwKJWbO6FtiGPht4PR3GGGMaCnKCkJ4eAQMDKxgY1C7QgsKpcilEGkiXVm56dAqyyq8uK+vlZ4xp2caNwIgRkAz/EInHDiDNuPCZ42gdnaMjjvI6OowxxjS0EOgzIcgxNKwLQ0PrAgU5JC34ebHSSpebHh3KZU8p7kJDQ4Wc7XS/oJVY1IBEKpUK6UU1keqPIl16PVowi15PvdIzY4wV8I8I8O23wPLlAK30vm4dBkIB8alPMOOdGehQpwMikyOFIIbWycn8k7ZHJ0dDLBILGdboRimlGWOMseJQKuVCZjW5PBFGRg7Q169WqHPtytGJyHPgGp3nN2wIBASU/0CHggNaeyYsLEwIdkoaBSa0CBStxqzJgIoWnKI1GXQhTzpjrIyQyYBp04CtW4E1a4C5c4UGwD/CF2nyNIxoOgLv2r6r7VIyxhirQBSKdGGNHIUiTVgIVE+vcqGenxwVikpvu8AXE1Og1yrzgQ6hXhAKEmQyGeRyeYkv5Ecr4NLKuppaVJBWUqbF5kqyJ4oxVs6kpACjRgGnTwM7d9Iy8xkP3Qu7J/xsWaulFgvIGGOsopHLU/9bCFQBE5NGQhrpQlEqYRAWkffjdK7s6AgcPgw0bVoxAh1CQQIFHiW9ojkFJRRQGRkZaX31dMZYBfX6NTBoEODpCZw8CfTrl+VhzzBP1DevDzPDvFeLZowxxjRJLk/6L8jRg4lJY4jFhc+II5WlQT9dkX9vDrWBNWoU6PXKTaDDGGMVgfzlC6T2eA96kdF4uOdHNOvVAx7PrwgLfNY0rSnsc+7JOVhXtoZcIec5N4wxxkqcTBYvzMkRi41hbEwLgRatMyA15AXyna3+yy/ABx8AhgULojjQYYyxMuLCqQ1oMu5LyJRy9BoLPPKaAYn3TMiVOYfs+kf5w26DnZAqeqjjUK2UlzHGWPmXnv5ayK4mkVT+b40cSZHnwVeKSsh7B5rHvmsXMGMGkJDPfpmfUqSSMMYYK1VX9q1E6xEuiDaQo8NE4JGFantuQY5aSHwIhh8ajmN+x0qvoIwxxioMqTQcqalPoadnLvTkFDXIIclRYfkHJrQUS1AQvWmBX5MDHcYY03HyE3+h3fhv4G0JvDsBCCvg1BslVKutuZxzEYaxMcYYY5pAvS+pqcHCYqD6+rVgZGQHkagYYYVSCf3QV/nvQ8PWbt8u8LA1UqQSbdy4UUjpTBPyW7duDXd393z3/+233+Do6CikZG7UqBF2UbcTY4yxt9u+HeJhw3CmvhK9PwbijAtXaRTsBMUHwf1l/n+nywNttk1yeTISEu6V+o3elzHGSpcSqanPkZ7+CoaGNjAyqlPszMGy2BgY5JeEQD1szdq6UK9b6Dk6Bw8ehIuLi9CgdOrUCZs3b0bfvn3h6+srpHjObtOmTViwYAH++OMPvPPOO7h16xY+++wzVKtWDQMHDizs2zPGWMWgVEK8erWwGGjgh90xwvEfKIpxsYySFZRn2m6bkpP9cfdua5S21q3vonLlVqX+voyxikohDFWTy+NhZGQPff3qxX9JpRKKkCBhDIKoIMPWCtGjU+hAx9XVFRMnTsSkSZOE++vXr8f58+eFRmPVqlU59t+9ezemTJmCkSNHCvfr1auHmzdvYs2aNRzoMMZYbuRyNPvjD0jOnAGWLkXI2C5Q7PqnWHVlVdmqXNe1ttsmSqVKQUdpo/dljLHSoFTKIBaHQi6XCvNx9PSqaOZ14+NhkJqe9w7ffAO0agXUrFmoIKfQgY5UKsXdu3cxf/78LNt79eoFDw+PXJ+TlpYmDCPIjIYJ0NUzWnwzt7Vo6Dl0U4uPjxd+0v500yb1+2u7HLpWFl0rD5eF66XMfmfS0iD65BPYnzsH6c8/QzR1Ktor5EK66NCE0Ix5NwUlggjWZtZob9W+SJ9N6/Whg20TvZ9CochYoJrGqovFRjA11c4CrVQWKoO6LHRfm7gsul8vulYeLktZqBepkD4aSIeRUQOIxaYaK5MyOEiYS5NXb47i+HGk06LYNDyukG11oQKdqKgo4Q+7paVllu10/9Wr3CcQ9e7dG1u3bsUHH3yAVq1aCY3R9u3bhQLS61lZ5bzKSFffli5dmmP75cuXYWJSyBVWS8iFCxegK3SpLLpWHi4L10tZ+s7oJSWh7erVMPf3x6158/CKhlxRrw6Aj6t/jDUJawr9mhQYfWT+Ec6fO1+kMiUn6/4ckNJum2xtbfH7778jJSUl42IcLSatCxIKmHK1NHBZdL9edK08XBZdrZc0iMU0/FkEhcIaSUl0kUfVCVFsCgUqp6bmPWSNgpqgIPxz8iQUmS5AFbRtKtI6OtknHFGkmdckpMWLFwsNTfv27YX9qOEZP348fvjhhzwbBho3PWfOnIz71IjY2NigW7duqF5dA2MBi4EaQToR6tmzZ65X/CpqWXStPFwWrpcy95159Qp6NGQqKAhpp0/jVXJylrL0Qz84+ztjzPExUCjfXEWTiCR5ppiuY1YH63qsw5DGQ4pcLHWPellQWm0T9eiEh4cL7dKjR49gZmam9UCHPgOdDFWuXLnYk4K5LOW/XnStPFwW3a0XuTwRqamhEIsNYGhYH4mJKRotT14ZQakvS2lgAGWtWhAfO4Y+trZFapsKFehYWFgIf8yzXyGLiIjIcSUt81AAukpGE0OpYaCrZFu2bBEqiV4vN4aGhsItO2rwtX0CrcZl4brh70z5+13SWnkeP6YuBmHYGtzdIWnUSOjJyV4We3N7Icj5uc/PsDCxEObddKzTER7BHkKygZqmNYX9IpIihMe61O0Cibh4J+C6dGx0pW1KTU1FZGRkRnBDDb6YMgJpkXoICZeF64W/M/y7pCnp6TFC4gGJpJIwJ0eppOAmRaN/Z5KDnqBSLiOy6Z1EUilEYjH069TJ0RYVtG0qVKBjYGAgpOykq55Dhry5Qkj3Bw8enO9zqUB16tQR/n/gwAEMGDBA6w0DY4xp3Z07QL9+APVWX74M0FWrPMYe//3ob1QzqoZp70yDnvjNn++udl1RkXHbxBhjmiWVRiAt7SX09KoJ2dVojRxlptEEmuqxMo6Kyz/bWmyskJWtqAo9dI267ceOHYs2bdqgQ4cOwhWwly9fYurUqRld+yEhIRnrEVC3Pk3ubNeuHWJiYoTMOA8fPsTOnTuLXGjGGCsX3NyAoUOBZs2Av/9WBTv5oECnb4O+WYIcpsJtE2OMaSb4kErDIJWGQl+/prBOjqaHzcnkMgREB8AoKQ0Ob4thKOkLXfwzLuQicv8pdGtJqTijo6OxbNkyhIWFwcnJCWfOnBEmZxLaRoHPm/LJsW7dOgQEBAi9OjTPhrLg2NnZFanAjDFWLuzdC4wfrxqydvAgYGqa7+4h8SHwfOWJuR3nlloRyxJumxhjrPhBTlraS6SnR8LAwBoGBrU0HuQ8ePUA6QrVqIV6caq5ODnegTJi2turhnOHhFC3fZHfr0iXBadPny7ccrNjx44s92nVaU9Pz6KVjjHGyiNXV+DLL1WBzpYtNLY3Y1Km+0t3BMUG4UXCC/RW9IZYIRa27fHaAzHE6FGvh7ZLr7O4bWKMsaJRKlULgcpksTA0tIOBQe5zFTUV5JilAsayPHZMTQVkMlooDNAr3ggGHv/AGGOlhSaMf/01sHYtjfMFVqxQrQsA4JjfMcw6NwvB8cEZu/+0/ifhalp0SnTGtlZbWmFDnw0Y6jiUj5uWqde4YIyxskyhkCE1NRByeTKMjOpDX7+qxt+DhqupgxxS921J00JDocyWaa0oOBsAY4yVBhpj/MknwLp1wIYNwMqVWYKc4YeGZwlyyOvU11mCHPUQNtqXnsO0Q51trSwspsoYY/lRKGgh0ADI5akwNm5YIkEOoTk5aiIlYJBXb46aVIrkpKRiZ//kHh3GGCtpiYnA8OHApUvA/v00oSTjIRquRj05tLBnQdB+Iojgcs4FgxsNLnb6aFZ4enp6wuLVlGKaULpp2qbt9NK0vg+VRdsZTbksul8vulYeLot26kUuT0Vq6gvh/0ZGdpDJ9CCTpZbIcZKmSVUTcgCYpAHSXPYJqQRIDcSwq2KLZJkMEVFRqFq1arHWKeNAhzHGShKdDPfvD/j7A2fPAt27Z3mY5t9k78kpSLATFB8kPLeip5bWBhpOSOvuBAYGCsGOkZGRTiwYmpKSIqwPpAuLP3JZdLtedK08XJbSrxeFIk1IIS0SSWBgUBMiUViJHqfXCa+RLlf1ghskAM+yZaqmGEgaA0RX0QfSVBnWKMipVasWioMDHcYYKynPnwO9egFxccCVK0CrVjl2oYU+i6o4z2XFX7vH2toavXv3FpZQqFatmlarlIbRXbt2De+++67WF3nlsuh+vehaebgspVsvMTFXEBjoAlPTpqhffyP09auU+HGqllQN7f9sj84vgK2n8t4v6dcNMG1uL7y+Ji4gcaDDGGMl4cEDoE8fVdpoDw/AwSHX3awqWxX5LYrzXFZ8dEUzODhYCHqoV0eb6IRAJpMJ5dD2SSuXRffrRdfKw2UpvXoJC9uBgIBJqF59AJo02QOJxLhUylPLqBZSlSlYvD8CRlmnnmaQi4Dqy1YA/QdlzGEtLu0PEmWMsfKGem/efReoXRu4cSPPIId0qdsFdczqCPNuCor2tTGzEZ7LGGOMFWTY2YsXqxEQMAFWVp+iadMjhQpyNOHvoUdRLybvxyU0fi0oSEhEoCkc6DDGmCYdOaJaBLRtW1XAY2mZ7+6UTIDSRReUOiBa32c9JyJgjDFWoDVyAgNd8OzZAtjafouGDTdDLC79QV1/b50L/Wxzc0jS2jXA3buq2+3bgKGhxt6TAx3GGNOUjRuBESOAYcOA06eBypUL9DRaE2dyq8k5tlc3ri7cMqPenyMjjvA6OowxxgqUdMDP7yOEhPyCBg02wt5+qVaSTzwIu49+u27mzC8qkcD04BHA2Vk1j7VOHY2+L8/RYYyx4qKFI7/9Fli+HHBxUa2VU8jUm3df3cWABgPwZccvERQbhBcPX+CrD78SxkFTdjVKPEBzcmi4GqeUZowx9jYyWTwePhyKuDh3NG16GDVqDNNapT38ciw+Cs3lAblc1Yvj5qYaDaFhHOgwxlhxyGTAtGnA1q3AmjXA3LmFnkR5/9V93Am9gxOjTgjpoimzzZkXZ4SAhm6cQpoxxlhhSKXh8PLqi5SUJ2jRwg1Vq76ntQr0C/fB4CMP896BLgwuXqzKUqrh3iYOdBhjrKhSUoBRo1TD1HbuBMaNK9LLbL23FVaVrNCvQT8+FowxxoolOTkQXl69oVCkwNn5GipVaqHVGj29fga+Ui2hkzuF4k0SAg3OzyEc6DDGWFG8fg0MGgR4egInTwL9ihakpKSnYI/XHkx/Zzr0tDA5lDHGWPmRkHBP6MnR06sKZ2cPGBvbabU8gdGP8d6uq8LcHJG696ZxY2DXrqy9NzVrajzIIdyqMsZYYQUHq8YSh4cDly4B7doVuQ6P+B5BXFocJjpP5OPAGGOsyF6/vggfnyEwMWmCZs3+hoFBDa3X5slfPsec0Gy9N76+QFRUiczJyY4DHcYYy4NcIc+ZCMA/QLUQqEgEufs1uBtHIMx7f66JAnJ9vliSZfvaf9eim103OJjnvdYOY4wxlp/w8APw9x+HatW6/7dGjqnWK+x5zDN0+cPtTW+OmkRSYnNysuNAhzHGcnHM7xhmnZuF4PjgjG2Do2vg0M4UGNja48wvMzHlXO8sj1PqZ1oTh9JF5/Z8eny002jsf7g/y3ZzY3Nhf3oeY4wxVhjBwRuEdXIsLcehUaOtEIv1daICT/3yBb7QQqa1zHgdHcYYy4aCjuGHhmcJRgYEAPs2ReLfaon4dmlXDLgyOcvjJCQ+RHjevAvzcjyf0P0fPX7MsT0mJUbYn96XMcYYKwilUoknT+YLQY6NzTw0brxDZ4KckLhg9Pr5dM51c7JnWqPlGUoQBzqMMZYJDSujnhhlpj/PE+4Bxw8AZxsAvT8GVnpvzPK4mvK/f67/uub6eF7U+7qccxHenzHGGMuPQpEOf/8JCApaAwcHVzg4rNHKQqB5cb26CvVisg1ZyyvTWgnioWuMMZbJ9aDrb3pclMACd2DlJWBTG+DzfoCCLg8p8w9G5G95PK9gJyg+SJi708m6Ex8Txhhjubcx8iT4+IxATMwFODruhaXlGJ2qqfDEcDw+thX6ikwbf/kF6Ngx644llGktMw50GGMsk7DEMOGnWAGsPwd8cQv4tivwPa21VgoXyyhBAWOMMZYbqTQK3t4DkJT0UMisZm7eS+cqytVjHVacl71JQkDJByid9IwZJZ58IDseusYYY5nQwp0GMmD/EWD6bWDKAOD7rqUT5AjvX9mKjwdjjLEcUlNfwNOzM1JTn6Jlyys6GeREJ0fDf//PaPZK8abZzJx8oJQVKdDZuHEj7O3tYWRkhNatW8Pd3T3f/ffu3YsWLVrAxMQEVlZWmDBhAqKjo4taZsYYKzGdzZrh0gFDDAoAho0AtrTJuY9EJIEon8jnbY/nhva3MbMRUlCzouG2iTFWXiUmeuPevY5QKqVwdr4BM7NcGicdsOHmeqw4K805S1WdUrqEkw8UO9A5ePAgXFxcsGjRInh6eqJLly7o27cvXr58mev+169fx7hx4zBx4kT4+Pjg8OHDuH37NiZNmqSJ8jPGmMYYxsTAsFdvOIcBPccBJxxzBiP0b06HORn3C/N4XtT7re+zPss6PKzguG1ijJVXcXHu8PTsAgODmnB29oCJSQPoorjUODzc4wqncGXO1k9LvTqFDnRcXV2FoIUCFUdHR6xfvx42NjbYtGlTrvvfvHkTdnZ2mDlzptAL1LlzZ0yZMgV37tzRRPkZY0wzHj9Gl/nzIQ9/he6T9CF59z1h3ZvM6P6REUfwQ88fhJ/WZtaFepx6bOZ2nJvn6/I6OkXHbRNjrDzS07sJH59+qFy5NVq2vApDw1rQVX//Ngv7diXnvUMppZQucjICqVSKu3fvYv78+Vm29+rVCx4eHrk+p2PHjkLvz5kzZ4Sen4iICBw5cgT9+/fP833S0tKEm1p8fLzwMz09Xbhpk/r9tV0OXSuLrpWHy8L1Uhiiu3ehN3AgUg0NMWFOPbxUPoHn0EMwMzQTsrBRggKau9PZprPQ40Lfr4H1B6Lf9H5FenzZu8vyfJ6ufn91GbdNuvmd4bLobr3oWnm4LLkLCdkEE5MfUK3aEDRqtANKpaFWj1d6Pt+ZhNR4NPlpN4zySzqqUED58iVkSUnFzrZW0HoQKWm1oQIKDQ2FtbU1bty4IQQwaitXrsTOnTsREBCQ6/MosKF5OampqZDJZBg0aJCwTV8/90WNlixZgqVLl+bYvm/fPmGeD2OMaUoNT0+0XbMG8ba2+GF6F6yJ2Ypv7L9Bmyq6Of65tCUnJ2PMmDGIi4uDmZkZdBG3TYyx8kUJQ8MDMDI6iLS0/khNnajz+cMeX/4VX224mHH/weTJiGnUKMd+aVWqINXCotTapiKll86+IBHFSnktUuTr6ysMW/v222/Ru3dvhIWFYe7cuZg6dSq2bduW63MWLFiAOXNUY9zVPTo0PK5bt26oXr06tIkiyAsXLqBnz555BmoVsSy6Vh4uC9dLQYj27YNkxQooe/XC619W4pe9HfFR04/w7eBvoU269P1V96iXBdw26cZ3Rpe+v1wWrpuy9p1RKuV48uQLhIcfRJ06S+Dj0wI9e/bS+u9SfnWTLE1C3c+HZ6STVkokaHb3LuS0dk4JpZMuaNtUqEDHwsICEokEr169yrKdhqNZWlrm+pxVq1ahU6dOQnBDmjdvDlNTUyGJwfLly4UsbNkZGhoKt+yoUnXhQBMuC9cNf2fK+O+Sqyvw5ZfA+PHA5s34/OAgGEmM8FPvn/jvTLbjo+u4bXqD26bccb3kjetGd+pFLk+Bn98YREWdQqNG22Fh8TF8fM7o1DEi2ctz6bf5GBIsy7gvksuFIeHiy5eB3r1REgpaH4XqBzMwMBDSSVM0lxndzzyULXvXkpgmH2VCwRIpxKg5xhjLl1whx5XnV7Dfe7/wk+7nSqGA4qsvhSDHZ+IgXPl2HLY93IXzT89jep3pqGpUlWu6jOG2iTFW1qWnx8LLqzdevz4PJ6e/YGU1AWVBWnoq7Ndt15l00sUeukZDysaOHYs2bdqgQ4cO2LJli5BamoaiqYedhYSEYBetgApg4MCB+Oyzz4SsbOqha5Seum3btqhdu7bmPxFjrMI55ncMs87NQnB8cJZMZhv6bMiaySw9HS+H9UCdv69hZh/gF5uTwK6TQnrn9+q+x/NyyjBumxhjZVVaWgi8vPogLS0ULVr8gypVOqCsuPD7PAwIziUxQOZ00iXUq1Migc7IkSOFxT6XLVsmBC1OTk5CRjVbW1vhcdqWeU2d8ePHIyEhAb/++iu+/PJLVK1aFe+//z7WrFmj2U/CGKuwQc7wQzQ2OOtVo5D4EGF7RtrmxESE9+2CWh73MXoYcMjpzb703Gsvr6G9uD36oV/pfwhWbNw2McbKoqQkf6Enh1oiZ+frMDXNtoCbDkqRpmD2hdkIiPTHmtWXM+bm5JlOulevEpur8zZFSkYwffp04ZabHTt25Nj2xRdfCDfGGNMkGp5GPTnZgxxC26inxuWcCwabd4R44ECYeD1A34+BS/Vyf71tIduwRLEE+tCdsdCs4LhtYoyVJXFxN+Ht3R8GBlZo3vwcjIyyrrGmi1Y+XYkP1n4g/L/PI6BFaB5BDlEogKAgWgOg2OmkSzXQYYwxXeD+0j3LcLXcgh3JiyDEtWkGw6RUvPeJEp618943Kj1KWN+mR/0eJVdoxhhjFV509Gn4+HwoLATq5HQS+vrVdL5Ohh0ehlvxt1R3lMDySwDNun9tBPQYB3S1ew+uvV2zPqlmTa0FOYQDHcZYmRWWEJbv481fAef2AK/1o9B7LPDUvACvmZj/azLGGGPFERa2AwEBk1C9+gA0abIfEolxmRiudurxqYz7vZ4Arf9LwmyeCtRIBn6SXsUKJ0cYG+jO59Ht1YcYYywfVpVzpqdXe+8ZcO1PILQy4Ht8C1ZPPlSgurSqlPdrMsYYY0VF2YZfvFiNgIAJsLL6FE2bHikTQQ6Ze1G1TIxACay5IPwQyETA95dU27PspwO4R4cxVmZ1qdtFyK6WffjaMB9g7zHgmi0wc5I1Hnb5VNhO+1KSgtzm9NB8nur61dHZpnOplZ8xxljFoFQqEBg4GyEhP8PW9lvY2S3JscixLnsc/ThLb07L8DeP6SmBtqGq7Y8d3uynC7hHhzFWZknEEgxpPCTLtmm3gEOHgaOOwIAxwIoPfhb2oxulm1YHNZmp70+0nijsxxhjjGmKQpEGP7+PEBLyCxo02Ah7+6VlKsghDao3EH7SdULXc8hB3avTwLw+dAkHOoyxMosWBv39zu/obt8ddSpbY9klYOMZYEN7YMH4Otg/5miWdXTo/5Ru2trMOsvrUE/PgaEH0KFq2Vm7gDHGmO6TyeLh5dUfkZHH0LTpYVhbT0NZ9GOPH4WfvQKBplE5H1f36qxTam/NnNzw0DXGWJkUEBWAoQeH4l3bd3F25ClIZnwB8bVtuO8yGs4zP8NT23dz7Z2hYGdwo8FCxjZKZkDzfGgInEKuwJmnZ7TyWRhjjJU/Umk4vLz6IiXlCVq0cEPVqu+hrDI2MEZPux74bcPFPPdRiADDZcuB/gO1tm5OdhzoMMbKnMikSPTb108IUo4M3A39EaOA06eBnTvRcty4tz6fAqCudl2zbKNAhzHGGNOE5ORAYSFQhSIFzs7XUKlSi7JdsRcvYsfC/8EyJu9dxDT9Vcvr5mTHgQ5jrExJlaXig4MfIFGaiEsDjqDqwA8BT0/g5EmgXz9tF48xxlgFl5BwT+jJ0dOrCmdnDxgb26FMUyqRPNcFtUMThFQ+yfv24OfIkwiKewmbKnXh0m4WjPSNdGLdnOw40GGMlRkKpQITTkzAvbB78Oh1CLYDPwbCw4FLl4B27bRdPMYYYxXc69cX4eMzBCYmTdCs2d8wMKiBMs/NDSb3fYT/0oA0A7OqmD/6IMoCTkbAGCszvrv8HQ48PIC/mq2E87AZQGIicOMGBzmMMca0Ljz8ALy9+6FKlc5o2fJS+QhylErEzZ0J9eBuhVgM8XffCdvLAu7RYYzpJLlCniVhwNOYp1juvhy7Laeh9/jvgTp1gHPngNq1tV1UxhhjFVxw8AYEBrrA0nIcGjXaCrFYH+WB/NxZVPF+lHFfrFAAd+8KvTzorVsZ1nLDgQ5jTOcc8zuGWedm5VgI9JvYFvhozQ7gnXeAEyeAqlW1VkbGGGNMqVTi6dMFCApaAxubeahXb3WZWyMnT0olXn81Axb/DVnL2CyRQLR4MdCrl85kV8sLD11jjOlckDP80PAcQc6Ee8B3Gx4gtHNz4Px5DnIYY4xplUKRDn//CUKQ4+DgCgeHNeUnyAGQevokavg+z7bENiCSy4Hbt1W9OjqOAx3GmE4NV6OeHKWQ1+U/SmDhNWD7SWBra6BT7xDIDcrHkADGGGNlk1yehIcPP0BExD44Ou6Fjc1slCtKJWLmTM3cGmclFgPUq6Pjc3U40GGM6Qyak5O5J0esAH4+C6y4BHzbFZjWH3iRGCzsxxhjjGmDVBqF+/e7Izb2qpBZzdJyTLk7EK9ev0SVZ69y9OZkoLk66jVzdBjP0WGM6QxKPKBmIAN2HwOG+QFTBgBb2uS+H2OMMVZaUlNf4MGD3pDJXqNlyyswM8vUOJUjf+yZg4UyIOWLaTAeP0nYli6T4cb16+jUuTP09fR0bs2c3HCgwxjTGZRdjZilAscPAB2DgGEjgBOOue/HGGOMlZbERG94efWBWGwIZ+cbMDFpUP4q/+JFpE6fgiGxTxFTrxYs1m0A9P8bLp6ejriwMMDZ+c02HceBDmNMZ7SzbgfbFEMc35kGu1ig5zjguu2bx0UQoY5ZHXSp20WbxWSMMVbBxMZeg7f3IBgb26NZs7MwNKyFckdJk2IXwujxUzhRXLNvZ5kJaPLCgQ5jTCfIFDLM2zQEl7akwVAGvDsBeGiZNcgh6/ush0Qs0V5BGWOMVSiRkcfh6zsaVap0gpPTcejpmaFccnNTZVP7j75ctxMNFAQnI2CM6US2taVrB2LxwvOoUa0OvI5tQmyDOln2oZ6cIyOOYKjjUK2VkzHGWMUSEvI7fHyGw8JiMJo3P1N+gxylEspvvoFCfVciKRNZ1Uok0Nm4cSPs7e1hZGSE1q1bw9097wxI48ePF3KKZ781bdq0OOVmjJUTCqUCG77vj68Xn4OkfgNUvnUffXtMxfNZz3H5k8vYN3Sf8PPZrGcc5LB8cdvEGNPkQqDPni3B48fTYG09A02a7Bfm5pRbbm4Q3bmTERiUpbVyNBroHDx4EC4uLli0aBE8PT3RpUsX9O3bFy9fvsx1/w0bNiAsLCzjFhQUBHNzc3z44YeaKD9jrIw3JHsX9MMXy84jtl1LVL/hCVSvLjxGw9O62nXF6GajhZ88XI3lh9smxpjmyPHkyQy8eLEU9vYrUb/+BohE5XgQlFIJxaKFOdfMKQe9OoU+aq6urpg4cSImTZoER0dHrF+/HjY2Nti0aVOu+1epUgW1atXKuN25cwcxMTGYMGGCJsrPGCvDQU707m/wqeslPOvfEXX+uQWYmmq7WKyM4raJMaYJcnkKTEx+QHj4n2jUaDtsbRcII5HKNTc3iO/ey7lmTjno1SlUMgKpVIq7d+9i/vz5Wbb36tULHh4eBXqNbdu2oUePHrC1zZRKKZu0tDThphYfHy/8TE9PF27apH5/bZdD18qia+Xhsuh4vSgU+PejLph4zAe3Pu4O521nIJRIi+XSmbrR0bLoMm6bdPM7w2XR3XrRtfLoSllkslj4+g6Bnp4nGjQ4CAuLQVotU6nUi1IJ5ZezQbnVcgvnlGIxlIsWQd6tm7COTomXp4AKWgaRki6rFlBoaCisra1x48YNdOzYMWP7ypUrsXPnTgQEBOT7fBq6Rr0/+/btw4gRI/Lcb8mSJVi6dGmO7fQ8ExOTghaXMaYD5Eo5fBN9ESOLQTW9amhq1BA11n6Njv97jv0j26LS6IXaLiLLR3JyMsaMGYO4uDiYmenmJFxumxhjxSUSRcPUdClEohgkJy+CXN64QlSqWCpF79EjYZBPhrXUqlVx4Y8/oNChVNMFbZuKlF46excexUoF6dbbsWMHqlatig8++CDf/RYsWIA5c+Zk6dGhAKlbt26o/t/4fW1GkBcuXEDPnj2hr+UDrktl0bXycFl0o16O+x/HnAtzEJIQItw3TQP+OqKHtk9kOLpoGCq9M1Ynvi+EvzO5U/eolwXcNvHf3+z49zpvXDdvJCf7w9d3pnA+26jRFVy/HqQTbVNpHKOwnb8IQc6l6X3R5ZMlue4jqVEDferUKZNtU6ECHQsLC0gkErx69SrL9oiICFhaZlrwIhf05dm+fTvGjh0LAwODfPc1NDQUbtlRpWq7YtW4LFw3/J3J3zG/Yxh1bBSU/01vtEgCTu8FGkfJ0PdjYMrIEcBT3fpdIrpUHl0oi7bfvyC4bdKt74wal0X360XXyqONssTF3YS3d38YGFihefNzkEjofDaoXNdL+vmziJ86AUc/bo0PfnHDeSdjvLfhGPT1jLRSnqIo6PsXKhkBBSiUTpqiuczofuahbLm5evUqAgMDhUQGjLHyvy7OrHOzMoIcuxjgxjbANg7oOh64XE+ELy9+KQxrY6y4uG1ijBVFdPRpPHjwPkxNm8DZ2R1GRlnXbyuP5rnNxf1P+6H683AMdj0D42QZPuuZgm8vf4vyqNBZ12hI2datW4XeGT8/P8yePVtILT116tSMYWfjxo3LNQlBu3bt4OTkpJmSM8Z0lvtLdwTHBwv/b/4K8NgGiJVAx4mAZ20IARA9TnN3GNMEbpsYY4URFrYD3t6DUa1aLzRv7gZ9/WrlvgLnXZiHB7vX4p1Q1X3LZGBPcyCoCvCjx4/C4+VNoefojBw5EtHR0Vi2bJmQXIAClzNnzmRkUaNt2dfUoYlCR48eFdbUYYyVf2EJYcLP954BJw4AgeZAv4+AiEpZ96MEBYxpArdNjLGCoKkUL1+uwbNnC2Bl9RkaNNgIsbhIU9bLFKlMClePdfC4BMhEgJ6SLjoCbai5pv+IANd/XbG823IY6OU/xaQsKdKRnT59unDLK+FAbmvpUHYExljFYFXZCsN8gL3HgGu2wNCRQGIuC0pTFjbGNIXbJsZYfpRKBQIDZyMk5GfY2n4LO7sl5X+NnP9svLMR3QMVaPtfbw6hT069O72eAG71VVlSaT+X9i4oL8rxMq+MMW3p8rc3Dh0BjjoC/cfkDHJEEKGOWR00qdREW0VkjDFWgSgUafDz+wghIb8IvTj29ksrTJBDnkQH4vv/enMyo/u0/b8ptXjy+gnKEw50GGOao1RCvmghJF/MxIZ2wMdDAZmeKEeQQ9b1WAeJSMK1zxhjrETJZPHw8uqPyMhjaNr0MKytp1W4Gn//sUzozaEha5nR/bb/9eoQB3MHlCcc6DDGNEMmg2zSp5CsXIUFPcWw/uMAjow6Cmsz6yy7UU/OkRFHMKTxEK55xhhjJUoqDcf9+12RkHAbLVq4oUaNYRWvxpVKDN57B4o8Hqb8p9SrI4EY09vkPjWlrCr/s68YYyUvJQXpI4ZBdOYsPhtugA9Xn0Ivh17CQ4MbDRaysFGCApq706VuF0jEEmHhMcYYY6ykJCcHwsurNxSKFDg7X0OlSi0qZmVLpRA/e57nwzS2wiYemNtmVrlKREA40GGMFc/r15D27wP5vbv4ZFwlzPn+AtrXaZ/xMAU1Xe26ci0zxhgrNQkJ9+Dl1Rd6elXh7OwBY2O7ilv7Eglk1rURqojBVxNq41lSKOTKN/07EpEYH7w7Gav6u6K84UCHMVZ0wcGQ9ngficFPMG6qOdYsuoKmNZtyjTLGGNOa168vwsdnCExMmqBZs79hYFCjYh8NV1eIHz7EJ58ZYvd3/6KmSU0huxolHqA5OTRcrbz15KhxoMMYKxpfX0h7dUdEUgQmuthg81dXYFe1Al8xY4wxpnXh4Qfg7z8O1ap1R9OmRyCRmKJC8/eH4tvFcG2vxIBxy4V5sqQ8pZDODwc6jLHC8/BAer8+eGychNnzm2DP5/+gpmlNrknGGGNaExy8AYGBLrC0HIdGjbZCLNavuEfj4kVg5kwha3RQVTEOjGiCf9vNREXDgQ5j5ZhcIc+SCKC9Vftiv0aXB7HAqFG4WSsda+Z2wOFPT6OKUZUSKT9jjDH2NkqlEk+fLkBQ0BrY2MxDvXqrK9QaOTkolcDChYCfn3B39ATgpw9+h76k4gV+HOgwVk4d8zuGWedmITg+OGObdWVrfFz9Y/RDvyK9xoR7QOe/gZONgP3zB+DImMMw0jMqsc/AGGOM5UehSEdAwGcID98JBwdX2NjM5gpzcwNu3xbqgcK9oTY90MW2S4WsF15Hh7FyiAKU4YeGZwlySGhCKNY8X4Pj/scL9xp0cegasP0k8Ecr4MMPgRGtx3GQwxhjTGvk8iQ8fPgBIiL2wdFxLwc56t6cb77JqCOZCJj1d5RqewXEgQ5j5QwNNaNeGKUwMjcr9bYvL34p7FeQ1xArgJ/PAisuAd92Bab3B5RiEb50y/81GGOMsZIilUbh/v3uiI29KmRWs7Qcw5Wt7s25cyejLvSUgP69+6rtFRAPXWOsnKH5NNl7crKjxy3XWsJQzzDXx9NkaYhOiYaBDNh9DBjmB0wZAGxpo3qcAqCg+CDhvXiNHMYYY6UpNfUFHjzoDZnsNVq2vAIzs/8ap4qOem1mzxYuaWaZoSSRAIsXA716ARVs7hIHOoyVM5Q0oCC62XVDM8tmuT7mHe4NN88jOH4A6BgEDBsBnHAs+nsxxhhjmpCY6A0vrz4Qiw3h7HwDJiYNuGLVTpwQEhDkCGXkctWcHerV6d27QtUXBzqMlTOUGa0gZrSdkWdvjMftY1g46wjsYoGe44DrtsV7L8YYY6y4YmOvwdt7EIyN7dGs2VkYGtbiSs3cmzN5cs7eHDWxuEL26vAcHcbKmS51u8CqUv4BCC0YRvvl6vFjdBj5FaySxXh3Qu5Bjggi2JjZ5P0ajDHGmAZFRh7Hgwe9ULlya7RseZWDnOyOH6dKyj3IIQoFEBREk5tQkXCPDmPljFgkFnpawhLDhIAkc1IC9f11PdZBIpbkfDJNYOzXD6Lq1eF59Df43Jgu/NHM/hpkfZ/1ub8GY4wxpkEhIb/j8eMZqFFjOBwddwnD1lgm4eHA1KmI7uiMnk6e+L7bMvRv2D9nFdWsCRhWrLrjQIexcmbXg124F3YP8zvNxx7vPVnX0TGzxkfmH2FI4yE5n0hjd4cOBZo1A/7+G32rV8cR65o51uKh3iAKcoY6Di2tj8QYY6yCLgT6/PlSvHixFNbWX6B+/fUQiXgwUrZKAiZOhFIkQv/+sahc+130G/lNhRqelh8OdBgrR0LiQ4TAZFyLcVjVYxWWv79cyIxGSQOol6e9VXucP3c+5xP37gXGj1dNUjx4EDA1FTZTMDO40eAsr0HD1bgnhzHGWElSKuV49Gg6wsK2wN5+JerWnQ8Rn7zntGULcPo0Dq76GHfTD+B+v1NcT5lwoMNYObry9dmpz2BqYIr1vdcL2yggyZxwID09PecTXV2BL79UBTr0B1NfP8vD2V+DMcYYK0lyeQr8/MYgKuoUGjXaDiurCVzh2V28KAxXo3k38RPGYIL8COa0n4OmNZtyXWXCgQ5j5cSf9//E2cCz+Hv036hmXO3tT6CJiV9/DaxdCyxYAKxYwV3djDHGtCo9PRYPHw5CQsIdODn9BQuLAXxEchuuNn8+8OQJlIaGmNApCjXia2Dxe4u5rrIp0kDHjRs3wt7eHkZGRmjdujXc3d3z3T8tLQ2LFi2Cra0tDA0N4eDggO3btxflrRljuQiKC8Ls87MxvuX43CcgZkc9O598AqxbB2zYAKxcyUEOK/O4bWKsbEtLC8H9+12QlOSDFi3+4SAnDyl/nwDu3hX+L0pLQ+IVN2zoswGVDCqV5uEqnz06Bw8ehIuLi9CgdOrUCZs3b0bfvn3h6+uLunXr5vqcESNGIDw8HNu2bUP9+vUREREBmUymifIzVuHRkLVJpyahskFl/NT7p7fWhyQlBZIhQ4DLl4H9+4GRIyt8HbKyj9smxso2sTgY3t4zhTyfzs7XYWqayyrVDG23vIOdC++g8X/r5chEwPeXgBmdV2CIYy6Jhiq4Qgc6rq6umDhxIiZNmiTcX79+Pc6fP49NmzZh1apVOfY/d+4crl69iqdPn8Lc3FzYZmdn99YeILqpxcfHZ8wvyHWOQSlSv7+2y6FrZdG18lSksmzz3Aa3J244OfIkTCWm+b5PemgoOn37LUSvXkF26hSU77+v6t2p4MdI18qji2XRddw26d53hsuiu/Wia+WJibkBU9MFEIvroGnT0zAwqKO1culSvWQvS8c/O8L+wh04Rr/ZR08JtA0FzK/fxTuid+AxwaPUyqNNBS2DSEmXgwtIKpXCxMQEhw8fxhC6IvyfWbNm4f79+0JAk9306dPx6NEjtGnTBrt374apqSkGDRqE77//HsbGxrm+z5IlS7B06dIc2/ft2ye8P2NMJUIagVn+s9Cpaid8XvfzfKvFJDwcHZYuhV5SEm5++y3iHBy4GtlbJScnY8yYMYiLi4OZmZlO1hi3TYyVXXp6d2Bi8gPkcgckJS0CwMOvcpMsS8ZHD8bg9Q9AlTRVb44a9ercswLafQbsa7YPJnrl/1w5uYBtU6F6dKKioiCXy2FpaZllO91/9epVrs+hnpzr168L83mOHz8uvAYFP69fv85zns6CBQswZ86cLD06NjY26NatG6pXrw5tR5AXLlxAz549oZ8tO1VFLouulacilIWuUfTd3xcWlSywf/x+VDGqkvfODx5Ab+pUKE1M8M/ixeg0bly5rZfyUB5dKou6R12XcdukW98ZLovu14uulCc8fBcCA1ehatW+ePFiLHr2HKD1utGFesmtLKP+GoUtfwNV3wx4ytGr0+sJsL/hfhwddLTc1018AdumImVdy57HnE648sptrlAohMf27t2LKlWqZAwxGD58OH777bdce3UoYQHdsqNK1XbFqnFZuG60/Z35/c7vuPT8Es5/fB4WlS3y3vHKFWDwYKB+fchOnEDy3bv8/S3F41TWy6Lt9y8Mbpt04zujxmXR/XrRVnnovPHlyzV49mwBrKw+g739Brx44aZTdaNrZaly9yEmegKKPDKJyaGaqzOpw7MSL7e+DtRNQd+/UFnXLCwsIJFIcvTeUHKB7L08alZWVrC2ts4Icoijo6PwJQ8OfrPaOmOs4J7FPMNXbl9hcqvJ6OXQK+8djxxRLQLatq0q4Mnj95SxsozbJsbKDqVSgcBAFyHIsbX9Fg0bboZIxKud5Cs6Gq47wpAuzvvEXQLAJh5oVNm+JA5bmVWob5aBgYGQTpq6rTLP0aH7g+mKcS4oMxvN6UlMTESlSqpxlzRnRywWo06dOsUtP2MVjkKpwMSTE1HdpDp+7PVj3jtu3Ah8/jkwahSwYwf9Amst8QBjJYnbJsbKBoUiDf7+4xERcRANGmyEtfU0bRdJ9ymVkEyaBAsYo92nqZDl00URYQr4f7ivNEtX/tbRobkzW7duFebX+Pn5Yfbs2Xj58iWm0uqs/82vGTduXMb+NFGI5tVMmDBBSEF97do1zJ07F59++mmeyQgYY3nbdHsTLj+/jG2DtsHMMJcJeJRfZPFiYMYMyhQC7NmjCnIYK8e4bWJMt8lk8fDy6o/IyGNo2vQwBzkF5HDyJMSnT0O+fTt87U3hWRt53mo7voNKRpzMIbNC9xWOHDkS0dHRWLZsGcLCwuDk5IQzZ84Ii4ES2kaBjxr14lCPzxdffCFkXqOgh9bVWb58eWHfmrEK72nMU8y7OA/T2kxDj3o9ctYHrU81bRqwdSuwZg0wdy4vBMoqBG6bGNNdUmk4vLz6IiXlCVq0cEPVqu9pu0hlguj2bTTZtQvy2bMx3/g60uRpcKzuCL9ovxz7vlP7Hdz67JZWyqnLijQokrKm0S03O2iITDaNGzcWgh3GWPGGrE04MQE1TWvih54/5NwhJUU1TO30aWDnTiBTzypjFQG3TYzpnuTkQHh59YZCkQJn52uoVKmFtotUNsTGQvLRR4hxcMDlsW2x7uRorOu1DnM6zEFiaiLG/jUWT2KewKGaA3Z/sJt7cvLAs78YKyN+u/Ubrr24hkvjLqGSQbau6devgUGDAE9P4ORJoF8/bRWTMcYYEyQk3BN6cvT0qsLZ2QPGxvkvGM8AXLwIzJwJmJsLwc7Z77/CjPNTMaTxEMxuP1uoIhqednzUca6uAuBAh7EyIPB1IL6++DVmvDMD3ey7ZX2QshdSZrXwcODSJaBdO20VkzHGGBO8fn0RPj5DYGLSBM2a/Q0DgxpcM29Dc2wXLgT8VEPTUvfvxbcvF6O6cXVsH7w9z6VcWN440GGsjAxZs6pshdU9Vmd90NcX6NNHNQ/nxg2gUSNtFZMxxhgThIcfgL//OFSr1h1Nmx6BRGLKNVMQbm7A7dsZd7f470GQOAjXR19HVaOqXIelkXWNMVa6fv7fz7j+8jr+HPxn1iFrHh5A585A1arAv/9ykMMYY0zrgoM3wM9vNGrWHA0np5Mc5BSmN2fBgoy7CrEIHf44i0m1J8K5lnMJHa3yj3t0GNNhj6IfYcE/CzCz7Uy8a/vumwdOnaI0U8A77wAnTqiCHcYYY0xLaCH4p08XIChoDWxs5qFevdU81Kowzp5VzbP9j1ihRNtQQBZUswSOVsXBPTqM6RC5Qo4rz69gv/d+/PP0H4z/azzqmNXByu4r3+y0fTtAC/b27QucP89BDmOMMa1SKNLh7z9BCHIcHFzh4LCGg5zC9uZMmpRzs0QCx337VI+zIuEeHcZ0xDG/Y5h1bhaC44OzbF/ebTlMDUxVf+hWrgS++QagBXp//RWQSLRWXsYYY/DB+AcAAF05SURBVEwuT4KPzwjExFyAo+NeWFqO4UopLFrkOywsx2aRXI5qgYGQ0RIt/ftzvRYBBzqM6UiQM/zQcCiR86rN4suL4WjeEEM3X1MFN0uXqv4ocvYVxhhjWiSVRsHbewCSkh4KmdXMzXvx8Sishw+BVavyfFgpEkH83XeqZSO43S80DnQY04HhatSTk1uQQwxkShh8/AmU3mkQ/f47MGVKqZeRMcYYyyw19QUePOgNmew1Wra8AjOzNlxBhRUbC3zwQb4BjIhGc9AyElIpYGjIdVxIHOgwpmXuL91zDFdTM0sFjh8AOgalwGfT93CazEEOY4wx7UpM9IaXVx+IxYZwdr4BE5MGfEgKS6EAPv4YiI5G4rlT+Oj8ZFQyrITtg7bDUE8V0KTLZLhx/To6DRkCfQ5yioQDHca0LCwh57hcYpkAnN0L2MUCPccB0zs4wKnUS8cYY4y9ERt7Dd7eg2BsbI9mzc7C0LAWV08hSWVS3JsyEG3PuOHE2s+wM3IzrlZPwL0pV2FYrd6bHdPTEUdzd+rU4TouIg50GNMyWgg0u/rRwPndgKEc6DIB8LEEvs9lP8YYY6y0REYeh6/vaFSp0glOTsehp2fGlV9I8y7Mw6M/1+Gv/Qoseh9YmfAHkAB80PgD1Msc5DCN4PTSjGlZl7pdhBTSaq1DgBvbgDQ9oONEwNdSBBszG2E/xhhjTBtCQn6Hj89wWFgMRvPmZzjIKWKQc/LEj9h1VIFjjYFVnd889pf/X8LjTLM40GFMyyRiCfo49BH+3zMQuLIDeGIOdP4UCKqqmqC4vs96YT/GGGOstBcCffZsCR4/ngZr6xlo0mS/MDeHFcLFi1A4OuLR9rU4fhAINgM+GQIos52Fu/7rKgxrY5rDgQ5jWnb/1X3s8tqFNa+a4/Q+4Iod0GMc8NoEQk/PkRFHMNRxqLaLyRhjrIJRKuV49GgqXrxYCnv7lahffwNEIj51LGQlAgsXQuzvjz//UqJ2PDBkFJCYS6woV8qx8c5GjR0/xnN0GNOqRGkiRh4ZiZUPLPDlES8oPvkElRd9jK2pkcLcHRquxj05jDHGSptcngI/vzGIijqFRo22w8pqAh+EonBzA27fFv5bLRX47j3gkUXeuz95/YTrWYM4GQFjWvT539Mx7eAzuFxPBxYsgHjFCrzHC4IxxhjTovT0WDx8OAgJCXfg5PQXLCwG8PEoam8OLfAtFgvppBUA+j8GlnWlBXJyf4qDuQPXtQZxoMOYluy+sx3dl+7Gx94iYMMGYOZMPhaMMca0Ki0tRFgjJy0tFC1a/IMqVTrwEdFAbw6hQX9tQ4FeTwC3+jl3l4gkmN5mOte3BnGgw5gWPHp+D7XGTEa3Z2KI9u8DRo7k48AYY0yrkpL84eXVm7oi4Ox8HaamjnxEitObM39+js0yEfD9JcDNIWevzpwOc2CgZ8B1rkE8o4yxUpYaFgRp1y7oEKRE+qkTHOQwxhjTuri4m/D07ASJpDKcnT04yCmuU6eA+/dzbNZTvunVydyTM7fjXPzQ84divy3TQKCzceNG2Nvbw8jICK1bt4a7u3ue+165cgUikSjHzd/fvyhvzVjZ9uwZ4ts0Q42oZISc2APjPjzumTFN4baJsaKJjj6NBw/eh6lpEzg7u8PI6M3abqwI5HJg/Pg8H1aKxdh51waft5mBn3r/hOSFyRzk6MrQtYMHD8LFxUVoUDp16oTNmzejb9++8PX1Rd26dfN8XkBAAMzM3qygW6NGjaKXmrGy6MEDpPbtiXh5HP7d9R3G9hqt7RIxVm5w28RY0YSH70Jg4BRUrz5AWCNHIjHmqiyub74BYmLyfFikUKBWTDp+6bEOMOQ1iXSqR8fV1RUTJ07EpEmT4OjoiPXr18PGxgabNm3K93k1a9ZErVq1Mm4SCS9+yCqO6t7eEL/fDf6GCVixqi8+HvKdtovEWLnCbRNjhV8I1NDwKAIDJ8HK6lM0bXqEgxxN2LULWL0aiq+/xtxV76PjdEP4nN0F3L2b9UZJCjjI0a0eHalUirt372J+tslVvXr1goeHR77PdXZ2RmpqKpo0aYJvvvkG3bp1y3PftLQ04aYWHx8v/ExPTxdu2qR+f22XQ9fKomvl0aWyKA4dQoelS3G3gSnGj7XCldE7IJPJUNHrRZfKomvl0cWy6DJum3TzO8Nl0d16USoVePJkNoyMdqN27QWws1sCuVwJuVw7ZdOluilOWUTu7pBMmgTl+PH46r00rL91GYenH0bDhoOQ66u95T10qV50rTwFLYNISSF9AYWGhsLa2ho3btxAx44dM7avXLkSO3fuFIanZUfbrl27JszloeBl9+7d+P3334W5O++++26u77NkyRIsXbo0x/Z9+/bBxMSkoMVlTOvszpxB8z/+wI3WddCjTzCWOq5CY9PG2i4WYwWWnJyMMWPGIC4uLsvwY13CbRNjhZEOY+Ofoa9/HampkyGV9uXq0wDT0FC8+/XXiLOzw3fT22JT+DZMsp6EATV4Lq4226YipZemZAKZUayUfZtao0aNhJtahw4dEBQUhLVr1+YZ6CxYsABz5szJ0qNDw+OoF6h69erQdgR54cIF9OzZE/r6+lwWrpvcKZUQL1kCyZYteDp2EN6zP4nvui7FnM5vvtfawN9frpvCUveolwXcNnHblB3/zctKJouHv/8IxMf/Dw4Oe3D3rimfz2jiO/P6NfQ6dwasrPC/zXOx+cJ4zHxnJtb2XFtuvr9ltW0qVKBjYWEhzK159epVlu0RERGwtLQs8Ou0b98ee/bsyfNxQ0ND4ZYdVaq2K1aNy8J1kycaljZ9OrB1KxKWfYOORlvQTNICX3f6mr+/Ov67pGvl0YWyaPv9C4LbJt36zqhxWXSrXqTScPj49EVKyhO0aOEGU1MamXOGj1Nxj5NUqlomIiYG3ie3YuTljzC40WC49nGFRCwpd79LulKegr5/oZIRGBgYCEPQKJrLjO5nHsr2Np6enrCysirMWzNWNqSkAMOGAX/+CcWOPzHc/hZdZsbsurMhFvGyVYyVBG6bGMtfcnIg7t3rCKn0lZA+umrV97jKNIFmf0yeDPz7L8J2b0JPj6loVrMZ9gzdo7EghxVPoYeu0ZCysWPHok2bNsIwtC1btuDly5eYOnVqxrCzkJAQ7KKsE4CQlc3Ozg5NmzYVJoxST87Ro0eFG2PlyuvXwKBBFMkDJ0/iRzNvXPjnAk6PPg2pn1TbpWOsXOO2ibHcJSTcg5dXX+jpVRUWAjU2tuOqKia523mkzpiCV03t4HDiKhK2bUL3p9/B1MAUJ0efhIk+zycvs4HOyJEjER0djWXLliEsLAxOTk44c+YMbG1thcdpGwU+ahTcfPXVV0LwY2xsLAQ8p0+fRr9+/TT7SRjTpqAgoE8fWpAAuHQJ/9ZWYNGfizC/83z0sO+BM35n+PgwVoK4bWIsp9evL8LHZwhMTJqgWbO/YWDAaxgW1zHfo6g3aTRaBqXDIfAFlrwLrA51gb5EH3c+u4OapjX5q6hDipSMYPr06cItNzt27Mhyf968ecKNsXLL1xfo3RsQi4EbNxBTtyZGbW6JdnXaYWnXpYBC2wVkrGLgtomxN8LDD8DffxyqVev+3xo5plw9xXTM7xi2rBqOc0Fvtv1rA6TJ04SbT6QPGlm8ScDFtI8nDTBWHLR+FGVaqVZNGKOrbNgQk05NQnxaPPYN3Sdc4WGMMcZKU3DwBvj5jUbNmqPh5HSSgxwNkCvkmHV2Jta4Aep1WWQi4PvLNFcHEEEEl3Muwn5Md3Cgw1hRnToF9OgBNGsGXLsG1K6NTXc2CVd8tg/aDtuqquGcjDHGWGmg5T6ePJmPwEAX2NjMQ+PGOyAW8wU3TXB/6Y5OHiFoEUFBjYqeEmgbCvR6QrGOEkHxQcJ+THdwoMNYUWzfDgwZAvTtC5w/D1StigevHmDO+TmY8c4MDHEcwvXKGGOs1CgU6fD3n4CgoDVwcHCFg8OaPNc4ZIUXFfwY20+86c1B5l6dS6peHRKWEMbVW9bn6DBWoVNJrlwJfPMNFFOm4NrcDxH2+DiqGlUVuqwbWzTG2l7FWyCMMcYYKwy5PAk+PiMQE3MBjo57YWk5hitQk1JS0GfiKpjIcj6UuVfHrT5gVZmXT9ElHOgwVlByOeDiAvz6K3w/H4ne9n8jeM/mjIdpfO6GPhtgpGfEdcoYY6xUSKVR8PYegKSkh0JmNXPzXlzzml4EfORImD5+LuQWym0oFM3KoV4dP+c66FK3C9e/DuFAh7GCSEsDxo4Fjh6F53dT0Fq0BcqErB3YND531rlZsDazxlDHoVyvjDHGSlRq6gs8eNAbMtlrtGx5BWZmbbjGNT2K47PPgDNnoDCrBElcQq670dKgNvHAz93X8kKhOoYDHcbeJi5ONR/HwwPyw4cx6MUsKOOzj9J9g4awDW40mP/YMcYYKzGJid7w8uoDsdgQzs43YGLSgGtb077+mtZNQfjv69A/eA3qy2thbPOx+PX2rwhPjMjYrVYlS3wx4Ht80GIkHwMdw4EOY/l59UqVcOD5c+DCBbjbyBHsHZzn7pmzrnS168p1yxhjTONiY6/B23sQjI3t0azZWRga1uJa1jDxunXAjz8idvUSdEj9FXo1q2DDBHdYVrJEnxELhXaeEg/QnBwariYRU78O0zUc6DCWl8ePVQuB0rA1d3fAyQlh3vsLVF+cdYUxxlhJiIw8Dl/f0ahSpROcnI5DT8+MK1rD6v7zDyS//ILkebPRqfIhyNJkuDL+ihDkEApq+GJm2cDppRnLzZ07QKdOgKGhalFQJycolArcCrlVoPrirCuMMcY0LSTkd/j4DIeFxWA0b36Gg5wSIDp5Ei1/+w2pn36C9xyuITIpEhfGXkDdKnVL4u1YCeNAh7Hs3NyArl0BBwfg+nXA1hZe4V7otL0T1v9vPUz1TYUMa7mh7TZmNpx1hTHGmEYXAn32bAkeP54Ga+sZaNJkvzA3h2nY1auQfPQRgtu9g74dn+Lx60Cc//g8Glk04qouozjQYSyzvXuB/v1Vgc7Fi0iqbISvL3yNVptbIT4tHu4T3LFryC5h1+zBjvr++j7reawuY4wxjVAq5Xj0aCpevFgKe/uVqF9/A0QiPn3TOE9PYNAgKDp2wMgh6fjfqzs4PeY0nK2cNf9erNTwbwpjaq6uwMcfq27Hj+NM6FU4bXLCz7d+xvfdvofnFE90rttZSB19ZMQRIY10ZnXM6gjbObU0Y4wxTZDLU4ShamFh29Co0XbY2i6ASJT7iAJWBBcvAk2aADt3An36QNmgASaON8ftFC8cGnYInep24mot4zgZAWMKhSqF5Nq1wIIFCJ0/Ay5/fYTDvofRy6EXLo69CAdzhyz1RMEMpZDmrCuMMcZKQnp6LB4+HISEhDtwcvoLFhYDuKI1vUbOwoWAnx8weTKUtraYN9sJu5/sxpe2X6K3Q2+u73KAAx1WsaWnA59+KgxZU6z/Cb93NMCCjU1gpGeEfUP3YZTTqDyvnnHWFcYYYyUhLS1EWCMnLS0ULVr8gypVOnBFa5BcIcfD3evQ4vZt1QapFIeHNMTawJ3Y0n8LaobU5PouJ3joGqu4EhOBgQOBgwfxYtNqdDQ9gBlnZmBU01Hwn+GP0c1G8xABxhhjpSopyR/37nWETBYHZ+frHORo2DG/Y7Bbb4v0BV9DvfS3XATY7TkN157rML7FeE2/JdMi7tFhFVNkpJB0QOnvjy3ff4AZ4QvR2KIxrk+4zmNyGWOMaUVc3E14e/eHgYEVmjc/ByOjOnwkNBzkDD80HAP8lWgT9ma7RAm0DQWkPjHAO1zl5QkHOqzcd0/feH4j6+rFL14KC4GmvY7E0M9McUl2CsvfX445HebAQGKg7SIzxhirgKKjT8PH50NUrtwaTk4noa9fTdtFKnfnA7POzYJRmhJ7jkHozck8MF0mAip9vwbysQu1WEqmaRzosHLr39h/MeO3GQhJCMnY1jOhJv7akYZ4PRk6fZSEBs694dN/I+pVq6fVsjLGGKu4wsJ2ICBgEqpXHyCskSORGGu7SOUOJQ+Kig7GjT8BM2nOx/WUQMugdNzbvx4wb6KNIrISwHN0WLl03P841jxfkyXIee8ZcPjXCPgZxKHLRDFWfLYfZz86y0EOY4wxrS0E+uLFagQETICV1ado2vQIBzklJCLyBU7sA1q8AhR57CMHUHfdH6qMbKxc4B4dVi67p+dcmJNl2zAfYO8x4JotMHQkUKW6GT5s8iEnG2CMMaYVSqUCgYGzERLyM2xtv4Wd3RJuk0pKSgp6fPkrjF4CcUaAeWruu0kAVA6PhVgmK7GisDLQo7Nx40bY29vDyMgIrVu3hru7e4Ged+PGDejp6aFly5ZFeVvGCtw9nbknZ9ot4NBh4Kgj0H8MkGgI4XHajzFWfnDbxMoKhSINfn4fISTkFzRoQOdUSznIKSmpqcCQIah2xwdjJpqhxTSg1eSct9aTgX5zLKG8eQsKff0SKw7T8UDn4MGDcHFxwaJFi+Dp6YkuXbqgb9++ePnyZb7Pi4uLw7hx49C9e/filJext6LEAwIlsOwSsPEMsKE98PFQIF0vl/0YY2Uet02srJDJ4uHl1R+RkcfQtOlhWFtP03aRyn2Qg6tXcf23r3HKOhHBVYD7tUXwrI2Mm+q+CJMmbYSkrq22S820Gei4urpi4sSJmDRpEhwdHbF+/XrY2Nhg06ZN+T5vypQpGDNmDDp04EWvWMmKSY2BRA5sOQUsvgbM6wHM6Q0os33bKQsbY6x84LaJlQUiUSwePuyBhITbaNHCDTVqDNN2kcqvtDRg6FDgyhVc/XUuugV9LwxZPzj8IKzNrLPsWsesDo6MOIKhjkO1VlymA3N0pFIp7t69i/nz52fZ3qtXL3h4eOT5vD///BNPnjzBnj17sHz58re+T1pamnBTi4+PF36mp6cLN21Sv7+2y6FrZdGF8oQmhGLR5UU46rkXx4+K0DdAiXEfALuzjZQUQST8kWtv1b5UyqrteuGycN1o4jujy7ht4r8zZeHvb0KCP0xNv4ZUKkKzZpdgatpcq+XSpbrReFnS0iAZMQKiy5fxz0+z0CdkpRDkbB+4HXpiPQyqPwjXg64jLDEMVpWs0NmmMyRiSZbzzHJZL+WoPAUtQ6ECnaioKMjlclhaWmbZTvdfvXqV63MeP34sBEY0j4fm5xTEqlWrsHTp0hzbL1++DBMTE+iCCxcuQFfoUlm0UZ50RTpORp7E4fDDsEzRx8PDtWDzMhqDRqfjbMOc+yuhxEfmH+H8ufMV9jhxWbhuCio5ORm6jtumN/h3WzfrRSx+AlPTZQBMER39Ha5eDQZAN+3Tdt1ouizi9HS8s2YNajx4gC1fDMSM8B/xbrV38aHeh3A755ZlXzOYIQlJOO9zvtzXS0Vtm4qUdU0kEuVIj5h9G6GgiIarUdDSsGEuZ5x5WLBgAebMmZOlR4eGx3Xr1g3Vq1eHtiNIOsA9e/aEvpYnq+lSWbRRHvrenQ48jfkX5+N57HMssh2Hxas9IImJQprbBTR/fhZeUXsQkhiSpXt6XY91GNJ4CCriceKycN0UlrpHvSzgton/zuji37zY2H/g5/cdjI0bIyzsC/ToMVzrbYGu1I3Gy0I9OaNGQeTtjfOuMzA9egPGNR+H3/v9LvTYlGpZNECXylJW26ZCBToWFhaQSCQ5em8iIiJy9PKQhIQE3LlzR0ha8PnnnwvbFAqFcIJKvTtubm54//33czzP0NBQuGVHlartilXjsmi3bvyj/OFyzgXnn5xHz3o9ca6VK+qPnkGXzSi9HyT16qFDbCyWjFqCm2E3hcQDNCenS90uBf5jp2n8ndH9etG18uhCWbT9/gXBbZNufWfUuCxAePgB+PuPQ7Vq3dGw4X6Ehl7VqXohulSeYpVFKgXGjAEuXsT5tdPQL3oDJjpPxOaBmyEWiStuvZTT8hT0/QsV6BgYGAjppCmaG0JZLP5D9wcPHpxjfzMzM3h7e+dI/3np0iUcOXJESFHNWGHEpcZh6dWl+OXWL6hbpS7+GvkXBkVbQDRwIFCnDnDuHFC7Nl12EPanoKarXVeuZMbKMW6bmC4KDt6AwEAXWFqOQ6NGWyGn1SiZZl28CMycCaxbB2zeDJw/jzNrp6B/9HpMbT0Vv/X/rUhBDis/Cj10jYaUjR07Fm3atBEyqG3ZskVILT116tSMYWchISHYtWsXxGIxnJycsjy/Zs2awvo72bcz9rZFQP+8/ycW/rMQyenJWNZ1GWZ3mA2jsxeAkT2Bd94BTpwAqlblimSsAuK2iekKGrXy9OkCBAWtgY3NPNSrt1oYVimXa38Cd7miVAILFwJ+fqqenKQknP7hMwx4/QtmvDMDv/T9hdcmYoUPdEaOHIno6GgsW7YMYWFhQsBy5swZ2Nqq8o7TtretqcNYYdx4eQMzz83EvbB7+Lj5x1jdfbUqNeT27cDkyQD1Ju7dCxgZccUyVkFx28R0gUKRjoCAzxAevhMODq6wsZmt7SKVS1KZFKd/nYkht2+rNsTG4uZn/TAgbiNmtZuFn3r/xEEOK3oygunTpwu33OzYsSPf5y5ZskS4MfY2IfEh+Pri19jrvRetrVrD41MPdLDpoLqKs2IF8M03APUk/vorINHOvBvGmO7gtolpk1yeBB+fEYiJuQBHx72wtBzDB6QEzLswD64e63BzswKK/xaElIsA8ekzmLNtNtb2XsdBDiteoMOYpoajub90z5EoIFWWCtd/XbHSfSVMDUyxbdA2jG85XjXOlgY5u7ioghtKQb54MaVa4gPCGGNMa6TSKHh7D0BS0kM0a/Y3zM178dEooSDnR48fMdgPaBP2ZrtECbQNBR7cewlRHz4nYG9woMO04pjfMcw6NwvB8cFZUj+PaTYGR3yP4GXcS6H7efG7i1HFqIpqB1pEduxY4OhR4PffgSlT+OgxxhjTqtTUF3jwoDdkstdo2fIKzMza8BEpoeFqdBG0eiKw5xitiUcLgL8hEwEtfzsK6dw0GOjnzNzLKiZORcG0EuQMPzQ8S5BD6P4PN36AmaEZvKd5Y22vtW+CnLg4oG9f4ORJVaDDQQ5jjDEtS0z0xr17HaFUSuHsfIODnBK08c5GWMXKcW8LUCk9a5BD9JTAO6HA6d9mlWQxWBnDgQ4r9eFq1JOjFK7F5C46ORoNzBu82UDrNnXtCnh6Ui5z4IMPSqewjDHGWB5iY6/B07MLDAxqwtnZAyYmmdotpnGJD+7gxlbAMgnC3JzcUAbvVhuPq+byMsaBDittNCcne09OdkHxQcJ+gsePgY4daVVawN0d6NKldArKGGOM5SEy8jgePOiFypVbo2XLqzA0rMV1VZLu3MGc+X8h0RCIN8z7Kj2lJbKITlEtHsoYz9FhpY0SDxR4vzt3gH79gOrVgcuXgf9SmDPGGGPaEhLyOx4/noEaNYbD0ZHWDOT5ICWK2v9BgyBvYIfOPX1gmg7USMp9V4lIjBvz7wOGfEyYCicjYKWKsqsVRBPPYGD6Z0CzZsDff6uCHcYYY0yLC4E+f74UL14shbX1F6hffz1ElA2UlZxjx4DRoxHWpjGad38EAzNLBCeFI/i/6bvZze34JQzs6vERYRn4N5SVKkohTdnVRDmmEarQ9i8em6P5xIWqeTkXL3KQwxhjTKuUSjkePZoqBDn29itRv/4GDnJK2rZtUH74Ibw61oft+17o1XIons16hrkd50Iiyrp2Ht2n7T/0/KHEi8XKFu7RYaWK1snZ0GcDhh0almuQM9tDiXVur4Hx44EtWwB9fT5CjDHGtEYuT4Gf3xhERZ1Co0bbYWU1gY9GSfvhB+Drr3Guhx0GdvTFip6rMa/TPGEhUApmlndbLmRhe/L6CRzMHTC9zXQY6BnwcWE5cKDDSl1Hm47QE+vBVN8UcWlxwjaRAth4rRKmXkkAFiwAVqzghUAZY4xpVXp6LB4+HISEhDtwcvoLFhYD+IiUJMqWNm8e8OOP+L1vDczrHIW/hp/CgIZZ652CGpf2Lnws2FtxoMNK3W+3foOhxBCBXwTiYeRDvHodhK7f74bl1YvAhg3AzJl8VBhjjGlVWloIvLz6IC0tFC1a/IMqVTrwESlBIrkckqlTgT//xMKBJjjUwww3R19BkxpNuN5ZkXGgw0pVkjRJ6G6e1GoSLEwt0FXZBpi6Grh0Bdi/Hxg5ko8IY4wxrUpK8oeXV2/qYoCz83WYmjryESlJqalo8+OPwO1bGD9UjODBHXDrw0MwNzbnemfFwskIWKna+WAnYlNjVV3OkZHA++8DHh7A2bMc5DDGGNO6uLib8PTsBImksrAQKAc5JYASDTVpovoZHw/xwAGofvcWBo1QwGzSDJz96CwHOUwjuEeHlRq5Qg7Xf10xvMlw2MUogd6dqEUBrlwBWrXiI8EYY0yroqNPw8fnQ2EhUCenk9DXr8ZHpCTm4SxcCPj5AXPnIh0KpAX4YMBYEUZN2YSpbadynTON4UCHlZqTASfxJOYJ/nJcCnTsCJiaqnpzHBz4KDDGGNOqsLAdCAiYhOrVB6BJk/2QSIz5iJQENzfg9m3V/+/fR5KxCEMmV0Gvd+ZiovNErnOmUTx0jZWatf+uxRfJzeA0fDpQuzZw4wYHOYwxxrS+EOiLF6sREDABVlafomnTIxzklFxlA4sXA2LV6acSQEQ1A/yx6BaaVmpaYm/LKi7u0WGl4t+gf2F1zgM//aUHvNdVtdpx5cpc+4wxxrRGqVQgMHA2QkJ+hq3tt7CzWyKs1cJKoTdHWD8PaBiaBtmtR/DhSmclgHt0WKl4uGQ6Dh0BxMOHA6dPc5DDGGNMqxSKNPj5fYSQkF/QoMFG2Nsv5SCnZCscis8mCb04WUgkEH/3naq3hzEN40CHlSylEq+/+hyfbb+Ph6Peh2jPXsCAVy9mjDGmPTJZPLy8+iMy8hiaNj0Ma+tpfDhKUno6Unp3hzgoWOjFyUIuh/juXdS4f5+PAdM4DnRYyZHJgMmTYb7uNyztZ4IGO05ljMtljDHGtEEqDcf9+12RkHAbLVq4oUaNYXwgStLr14h7rx0ML16BIo9dlGIxHPfu5V4dpnE8R4eVjJQUYNQoKE+fxuThBrCeMRfGBiZc24wxxrQmOTlQWAhUoUiBs7M7KlVqzkejJAUEIL7nu0iPikCiiR7MkmW57iZSKGAcFUVRKI/6YBpVpMvrGzfSWFZ7GBkZoXXr1nB3d89z3+vXr6NTp06oXr06jI2N0bhxY/z000/FKTPTda9fAz17CguBHVr5EXa3EGH6O9O1XSrGWDnHbRPLT0LCPWEhUJFIT1gIlIOckiV3O4/kNi0QnBIB159GwMjHH7h7N9db+v/+h6tr1wKGhvwlZtrt0Tl48CBcXFyEBoUCmM2bN6Nv377w9fVF3bp1c+xvamqKzz//HM2bNxf+T4HPlClThP9PnjxZU5+D6QijyEjodesGRERA6nYOLjdH4JMWn6CmaU1tF40xVo5x28TyExv7D/z9P4SJSRM0a/Y3DAxqcIWVoKSfXWE0+yu411Pi+e9rsOL9uapED3Z5PCE9HalhYXxMmPZ7dFxdXTFx4kRMmjQJjo6OWL9+PWxsbLBp06Zc93d2dsbo0aPRtGlT2NnZ4eOPP0bv3r3z7QViZZSvL96dPx9IShLWyNlrEohXia8wu8NsbZeMMVbOcdvE8qKv7w5f30GoUqUzWra8xEFOSZLJEPPZWJjO+hJb2xtA7/Q5TOk+j7PZsbLRoyOVSnH37l3Mp5PZTHr16gUPWuG+ADw9PYV9ly9fnuc+aWlpwk0tPj5e+Jmeni7ctEn9/touh66VRfTvv9D74AMkm5kB//wDiY0N1v4xFP0b9IdDFYdSL6Mu1Q2XRffrRdfKo4tl0WXcNunmd0YXyhIUtB4mJutgbj4GDRv+AYVCHwqFdsqlS/VSIuWJi0PMkN4w97iHJSMtMXLDZdQ3r1+g19eluuGylK26eRuRkpYELqDQ0FBYW1vjxo0b6NixY8b2lStXYufOnQgICMjzuXXq1EFkZCRkMhmWLFmCxbQybh7o8aVLl+bYvm/fPpiY8IR2XWN56xbarF2L2AYN8L8FCyCrVAn34u9h2dNlWF5/OZwqOWm7iIyxIkpOTsaYMWMQFxcHM7qQoYO4bWI5KWFouBtGRseQljYEqanj/luekmmCXCmHb6IvYmQxqKZXDW0SqqHZ94tgEhOHb8Y3ROeeS2Ai4fM1pv22qUhZ17KvGkyx0ttWEqahaomJibh586bQI1S/fn1hSFtuFixYgDlz5mTp0aHhcd26dROSGmg7grxw4QJ69uwJfX39Cl8W0Y4dkKxZA+XAgTDZtg0yd3ehbn4+/DNaW7XG3A//G5fLx4m/Mzr8u6Rr5dGlsqh71MsCbpt04zuj7e8v9dg8eTIVERHHULfuanh7N+Z60eBxOu5/HHMuzEFIQohwv8tzYOoh4LURsPfXT7Hu498gEUvK1HeGy1J+26ZCBToWFhaQSCR49epVlu0RERGwtLTM97mUpY00a9YM4eHhQq9NXoGOoaGhcMuOKlXbFatW4ctCHYErVwLffANMnQrRr79CX6HKkO/z2geXnl/C/mH7YaDlxUEr/HHieuHvjAZ+h3Qdt01vVPS/eXJ5Evz8RiAm5gIcHffC3PxDeHufqfD1oqnjdMzvGEYdGwUlVIOBxnsCm08B1+sCw0cAWzv2h5GhUZGPX0X//paFsuhKeQr6/oVKRkAnrZROmqK5zOh+5qFsb0M9QJnn4LAyRi4HZs5UBTk0xHDjRkDy5urN+v+tR90qdTG8yXCtFpMxVjFw28SIVBqF+/e7Izb2qpBZzdJyDFeMhtNFO3UbifefKCFWAD+4AX+eAHa0BHqPBWJNRHA55wK5Qs71znRGoYeu0ZCysWPHok2bNujQoQO2bNmCly9fYurUqRnDzkJCQrBr1y7h/m+//Saknab1cwill167di2++OILTX8WVhooQB07Fjh6FPj9d2DKlCwPR0mjcMj/EH7o8QP0xLweLWOsdHDbVLGlpr7Agwe9IZO9RsuWV2Bm1kbbRSpflEokzZ2FhuEyrLkIBFcGBjwGXHoDG9qrpz8pERQfBPeX7uhq11XbJWZMUOgz0ZEjRyI6OhrLli1DWFgYnJyccObMGdja2gqP0zYKfNQUCoUQ/Dx79gx6enpwcHDA6tWrhbV0WBkTFwcMGQJQhj0KdD74IMcuf0f9DVN9U0xqNUkrRWSMVUzcNlVciYne8PLqA7HYEM7ON2Bi0kDbRSp/3Nxg5qVKONU6DGgcCQwcDZxtmHPXsAReD4fpjiJdcp8+fbpwy82OHTuy3KeeG+69KQdoXlbfvsDz5zRWEejSJccu8WnxcItyw7S201DZsLJWiskYq7i4bap4YmOvwdt7EIyN7dGs2VkYGtbSdpHKH5qTu3gxFCIRxErV7Jyn1YCzecSTVpWtSruEjGluwVBWAT1+DNAcrIgISp+Xa5BD/nzwJ9IUaZjRZkapF5ExxljFEhl5HA8e9ELlyq3RsuVVDnJKiOLcWeD2bSHIwX+j1JpFAr2eZN1PBBFszGzQpW7u5wiMaQMHOix/d+4AnTpRKjzVkDWn3NfEkSlk+OXWL+hSrQvqmNXhWmWMMVZiQkJ+h4/PcFhYDEbz5megp6ebazyVdVHBj5E0fHCO7TIR8P0lYVpORpBD1vdZX+jU0oyVJA50WN7c3ICuXQEHB8oiAfw3Dys3R3yP4GX8SwyumfMPImOMMaYJlLX12bMlePx4GqytZ6BJk/3C3BymeXdPbYHcsTEqJ8tyPKanBNqGvunVoQucR0YcwVDHoXwomE7htFgsd3v3AuPHA717AwcPAqam+TY8az3Wortdd9gbq9ZLYowxxjRJqZTj0aPpCAvbAnv7lahbd75WFqQu7+RyGc7PGYzuv56BQk8MpUgE0X/D1jKj7fs87eG9bCu62L7LPTlMJ3GPDsvJ1RX4+GPV7fjxfIMccu3FNdwNuwuXdi5cm4wxxjROLk8RhqqFhW1Do0bbYWu7gIOcEhAWEgD3DrXR7+czeDCgDYyqWuQa5BDaXj06GV1rd+Qgh+ks7tFhbygUwNdfA2vX0oJIwIoVQAGulq37dx2cajqhV71eOBtwlmuUMcaYxqSnx+Lhw0FISLgDJ6e/YGExgGu3BFw/8StqT5yFVklK+Py2BG2nfwcEBVHWh7yfVLOmag4vYzqKAx2mkp4OfPqpasjahg3AzJkFqhn/KH+cenQK2wdt56trjDHGNCotLURYIyctLRQtWvyDKlU6cA1rWLpMipNzB6D/r24IqVMZ6ZcuoGnzdqoHbWxUN8bKKA50GK22BgwfDly6BOzfTyvvFbhWXP91Ra1KtTCm2ZiM7CuMMcZYcSUl+cPLq7eQ2svZ+TpMTR25UjUsOu4FrnW1xbBb0bg/pAOa770IsbEJ1zMrN3iOTkVHXdLvv69KHX32bKGCnIikCOx6sAtftP0Chnrcdc0YY0wz4uJuwtOzEySSynB29uAgpwT8c3I9On3pgs4PXuPxr9+j5TEPDnJYucM9OhXZs2eqrGpxccCVK0CrVoV6+m+3fhMmIE5tM7XEisgYY6xiiY4+DR+fD4WFQJ2cTkJfv5q2i1SupMpSceirfhj+22WE1jCB1OMiGrTiIYGsfOIenYrqwQOgY0dVAgLqzSlkkJOcnoyNdzbi05afwtzYvMSKyRhjrOIIC9sBb+/BqFatF5o3d+MgR8MevfCEW5faGLfhMp716wjfn7ajcrM2mn4bxnQGBzoVEfXevPsuULs2cOOGakHQQqIha69TXsOlPaeUZowxVjy0HtuLF6sREDABVlafomnTI5BIjLlaNejEsVWQt22NHvdi8eKXFWh45AqURkZcx6xc40CnojlyRDVcrW1bVcBjaVnol1AoFUISgiGNh8DBvPBBEmOMMaamVCoQGOiCZ88WwNb2WzRsuBliMY+sL5aLF4EmTYSfidJEbHbpjB6jFqKyYRUob92C7ecL+QvIKgT+S1KRbNwIfP45MGoUsGMHYGBQpJc5FXAKj18/xq4huzReRMYYYxWHQpEGf//xiIg4iAYNNsLaepq2i1T20QKfCxcCfn5I/nImzpqEYMrNeAQO6oL6+86+dRFwxsoT7tGpKH/0Fi8GZswAZs0C9uwpcpCjXiC0o01HtK/TXqPFZIwxVnHIZPHw8uqPyMhjaNr0MAc5muLmBty+LfzXxMsPg27HI2zDCtQ/cY2DHFbhcI9OeSeTAdOmAVu3AmvWAHPnAiJRkV/uVsgtuL90x7ERxzRaTMYYYxWHVBoOL6++SEl5ghYt3FC16nvaLlL5oFRCtmgBxCJArFQtb6ffuAmsvlig7ZIxphUc6JRnKSmqYWqnTwM7dwLjxhX7Jak3p755fQxqNEgjRWSMMVaxJCcHCguBKhQpcHZ2R6VKzbVdpDJHrpALFx3DEsJgVdkKXep2EZZ7eLx5FRrc9czYjy5rinx8Vb08ND+XsQqGA53y6vVrYNAgwNMTOHkS6Nev2C/5LOYZjvgewS99fxH+oDLGGGOFkZBwT+jJ0dOrKiwEamxsxxVYSMf8jmHWuVkIjg/O2FbHrA6+fFUP09deE3pxsozbkEhUw9d79SrWiA7GyiIOdMqjoCCgTx8gPBy4dAlo104jL7vhfxtQzagaxrccr5HXY4wxVnG8fn0RPj5DYGLSBM2a/Q0DgxraLlKZDHKGHxoOpRDOqFRLBlYdDcbH3m8CnyzkctWcHe7VYRUQJyMob3x9VQuBJiaq1sjRUJATkxKDrfe2YlqbaTDRN9HIazLGGKsYwsMPwNu7H6pU6YyWLS9xkFPE4WrUk5M5yBkQAPhsBPo/Ap5UBeR5ddiIxapeHUpOxFgFwoFOeeLhAXTuDFSrBvz7L9CokcZeesvdLUhXpOPztp9r7DUZY4yVf8HBG+DnNxo1a46Gk9NJSCSc3rgoaE6Oerha1RRgx3Hg1H7gTm3AeQpgmg5I8opjFArVaA+ptBhHkrEKEuhs3LgR9vb2MDIyQuvWreHu7p7nvseOHUPPnj1Ro0YNmJmZoUOHDjh//nxxysxyc+oU0L070KwZcO0aULu2xupJKpfi51s/Y2zzsbCsVPgFRhljrDRw26RblEolnjyZLywGamMzD40b74BYrK/tYpVZlHiA9H0EPNwIDPYHPvkAGDQaeGEOvDMZaDUZOHdgBXD3bs4bDV8zNNT2x2BMtwOdgwcPwsXFBYsWLYKnpye6dOmCvn374uXLl7nuf+3aNSHQOXPmDO7evYtu3bph4MCBwnOZZoho8c8hQ1QJByiIrFpVo1V74OEBhCaEYk6HORp9XcYY0xRum3SNDIGBkxAUtAYODq5wcFgDEU+ELxZLmSG2/QWc2Qd4WQJO04FdLd9kHgiuAnjWBozadQRatcp5q1NHI0eWsXKdjMDV1RUTJ07EpEmThPvr168Xemg2bdqEVatW5difHs9s5cqVOHHiBE6dOgVnZ+filJ0plWh4+DD09u4Fpk4Ffv1VlV1Fw1fk1nqsRb8G/dCkRhOuc8aYTuK2SXfI5UkwMVmFyEgvODruhaXlGG0XqcwL2LMBTb74Cq1TgE8HAX/S6VO2+TgiiITsa5RqmjFWhEBHKpUKvTLz58/Psr1Xr17woPkhBaBQKJCQkABzc/M890lLSxNuavHx8cLP9PR04aZN6vfXdjmELCqzZ8Nx715Iv/kGIppkSGNw6aZBF59dhHeEN9b1WPfWz6wzdcNl4Xrh74zGf5d0GbdNuvP3Nz09Cj4+g6Gn54OGDY/A3LyvVsukK/VS1LKkRIfDd0JftD/3EDcdK+P+959jx8PVQoyTOSkBBTlkbY+1UMgVwq0kylNSuCy6Xy+6Vp6ClkGkpEv2BRQaGgpra2vcuHEDHSmzV6Zemp07dyIgIOCtr/Hjjz9i9erV8PPzQ82aNXPdZ8mSJVi6dGmO7fv27YOJScXM+CVXyuGb6IsYWQwslJUxdqsbrG/+Dw+mTMELDS8Clvm9TkScgEKpgGsjVx52wFgFlJycjDFjxiAuLk6YZ6mLuG3SDSJRBExNl0IkSkRy8mLI5fW1XaQyLfnfE3j3910wS5Hj8IftUHXYXEjEevg39l9sDdmK6PTojH0t9C0w0XoiOlTtoNUyM6ZrbVOR1tHJPs6WYqWCjL3dv3+/EMTQ0LW8ghyyYMECzJkzJ0uPjo2NjTC/p3r16tB2BHnhwgVh3pG+fulMqjzufxxzLsxBSEIIzFKB4wcAi2DAfe1sxNR7T6NlyfxearR2jtRBiiGNh+hc3XBZuF74O1Oy1D3qZQG3Tdr7+5uU5A1f3+kQiQzRqNE1uLs/47agiG1kYnQYfCb0w+BzPrjT2Azxuw5ibMvuGY/3Qz8sUSzB9aDrCEsMg1UlK3S26Vzohby5zeZ6Kayy2DYVKtCxsLCARCLBq1evsmyPiIiApaXlWyeK0tyew4cPo0ePHvnua2hoKNyyo0rVdsWWdllocbBRx0YJXdS1EoCzewDbOKDXWOB6/HrMizVAP/1+GilL5vfKLDY1Vth+ZMQRDHUc+tbXqYjHqSC4LLpfL7pWHl0oi7bfvyC4bdLudyY29hq8vQfB2NgezZqdhVhMFySf6cT3V03XyiKWiIV00ZRJzaqylTCvhgKVe7t/RM1ZC9AySY5Lc4fjvZX7INHLWW596KNH/R7lsm64LLpdL7pSnoK+f6GyrhkYGAjppCmay4zuZx7KlltPzvjx44WhZ/379y/MW1ZomRcHqx8NeGwDaiQDXSYA7raqfbaFbBP20+R7Zafe5nLORSPvxRhjmsRtk/ZERh7Hgwe9ULlya7RseRWGhrW0WJqygUZOfDyjFmq+0w3bfhyDbju7ofGaOjjZwwatxs1DpGVlRN+8jPd/OJxrkMMYK7hCD12jIWVjx45FmzZthDVxtmzZIqSWnkpZv/4bdhYSEoJdu3ZlBDnjxo3Dhg0b0L59+4zeIGNjY1SpUqWwb18hFwdrHQKc2QtEmwBdxwMvq74JQKLSo7Dh1ga0qt2qWO/14NWDjIXIckPvFRQfJJSpq13XYr0XY4xpGrdNpS8k5Hc8fjwDNWoMh6PjLojFvEbL29D8mh+OrsHNk0CTKGDlP8A8EbD95CtYJgH7J3fEyI1XIZYUaWYBYyybQv8mjRw5EtHR0Vi2bBnCwsLg5OQkrJFja6vqYqBtmdfU2bx5M2QyGWbMmCHc1D755BPsoPVfWJ6oS7tnIHDsIOBtCQwYA7zOJRfD/EtZs+CVxoJljDGmS7htKj00L/f586V48WIprK2/QP366yESFWn98QqFRkRQEoGeT4C2oapt9PPKLuBaXaDXOEBqF4QRvN4QYxpTpEsG06dPF265yR68XLlypWglY2h+0Run9wHnHYCRHwLJBrlXyp4P9qCzbedi1di/wf9i9NHRb92PxhIzxpgu4rap5CmVcjx6NB1hYVtgb78SdevO54ycBUTJA6Kl0fj+EiAXARIljZYAXpoBXT8BlJRLgEdOMKZR3Deqo558MwNNV2zEny2ByQMBWS7JVChvfnX96hjWeBiMDI2K9X60yNjcC3MREh+S6zwdXoiMMcYqNrk8BX5+YxAVdQqNGm2HldUEbRepTKEMaeM93/TmEMpXaxsP9HwGuP2XjZtHTjCmOdzXrGMCIvxwfGB9OFCQ09cKIeuXQS6hMCNr+m71fcqbX9iUkrmh19jQZ0OW187+Xuv7rNfIezHGGCtb0tNj4eXVG69fn4eT018c5BTSy2BfYNFCbDup6sXJTCaC0MujfoBHTjCmORzo6IjIpEjMPDkNt3s2xeDTT3B3/if45HQwvnlvsZDW2drMOkcPzIGhBzS6OBiljs7rvQqaWpoxxlj5kpYWgvv3uyApyQctWvwDC4sB2i5SmZGUlojD3wyFpGlTjDwXLJx0ZV91UE+p6uXp/QSwMbMRUk0zxjSDh65pWUp6Cjb8bwM2XFyB3ftS0e2ZGLI9f6L1mLEZ+1CAMbjR4Bw59xVyBc48PaPR8uT1XtyTwxhjFU9Skr/Qk0PdDc7O12Fq6qjtIpUJCqUCZw+vgsX8ZfjwmRQ+nRrAMtYACl8fiHOODgct3LDsEhC84CdubxnTIA50tPhHcJ/3Piz8ZyHSw0Nx87gFbF4B4nN/QdL9zQrIahRoZE/rTIFOScjtvRhjjFUscXE34e3dHwYGVmje/ByMjOpou0g6lUEtrwuCd73d8HzmWHxwNQKhtSsj7OgfaNp/JJR160KUS5BD6JnNpVXR1oF7yxjTJA50tODK8yv40u1L3Au7h2nV+2D9YQkMEpOBK1eBVsVbD4cxxhgrrujo0/Dx+VBYCNTJ6ST09atxpf7nmN8xYYHtzGvP0RDv7zp9A72t2zBo9200hBjPvpmB+ot/oiXchX1k//6LG3/9hU6dO0MsFsHzlSeikqJgYWoB51rOMKplBRjyWkSMaRIHOqXIL9IPX1/8GqcenUI763a41+5POE9YAJiaAh4egINDaRaHMcYYyyEsbAcCAiahevUBaNJkPyQSY66lTEHO8EPDc2QntfcKRps1U9E8Ang8sBPq/34I9a1qZ603GxvEUTvv7AyJvj7a4B2uV8ZKGCcjKAURSRGYfno6mm1qhocRD3Fw+EH867AKziNnAbVrAzducJDDGGNM6wuBvnixGgEBE2Bl9SmaNj3CQU624WrUk5M5yKkTB+w7AlzbAaTqAQNn1kD941chyR7kMMa0gnt0SnCcbnJ6MtbfXI/V11cL237o+QNmvDMDhn+dAj7qA7z7LnDsGFC5siaOJWOMMVYkSqUCgYGzERLyM2xtv4Wd3RJeCDQbauvVw9UM04Ev/wUWugMJBsAnHwC7mwNKcaSwH89zZUw3cKBTAuN0f+r9kxDkLLq0COGJ4fi87ef45t1vYG5sDmzcCHz+OTBqFLBjB2BgoInjyBhjjBWJQpEGf//xiIg4iAYNNsLaehrXZC5CE0KFtW4GBgA/nQfqxgEb2gHfvwfEZ1qzmxf8ZEx3cKBTRMf9j2PUsVE5xulS0PPh4Q+F/w9vMhyru6+Gg7kDXS4DFi8Gli8HXFyAdesAMY8cZIwxpj0yWTwePhyKuDh3NG16GDVqDOPDkcuQvvNPzmPfoW9xdj/Q5wlw3gHoPwYIqJGzunjBT8Z0Bwc6RSBXyjHnwpwcQU5mNU1r4sCwA6phbDIZMG0asHUrsGYNMHcuIMq+ZBhjjDFWeqTScHh59UVKyhO0aOGGqlXf4+pXu3gRypkz8b95Y7Ag/jj6HbyHv/4nQlAVMQaPUuBko5wrf4ogEkZ18IKfjOkODnSKwDfRFyEJIW9NQCCM07Vspxqmdvo0sHMnMG5cUY8VY4wxphHJyYHCQqAKRQqcnd1RqVJzrtn/KBRyxM2ehmp+gag5ezGOyPVQVWYE8ZJFeDCgPk6dGCPEOJkvdlKQQ9b3Wc8LfjKmQ3jsVBHEyGIKtF908GOgZ0/hyhBOnuQghzHGmNYlJNyDp2cniER6cHb24CAn00LeR3yPYIZLA1R7GChsqxcLmLfqBEnAI4i++QYftByFIyOOwNrMOkudUk8ObR/qOLT0DyhjLE/co1ME1fTevnAapZzs8+kK4HUicOkS0K5dUd6KMcYY05jXry/Cx2cITEyaoFmzv2FgkMskkwqYPZUCnO+vfQ+xlw9u7M50aiQWQ5ScDNSpk7GJgpnBjQbnmXGVMaY7ONApgiaVmsCqkhXCEsNyfzwCuLBPAhMzpWqNnEY0mJcxxhjTnvDwA/D3H4dq1br/t0aOaYU+HDKFDAcfHsRy9+XQ8/HH73cs0fm28MibnRQK4PZtwM0N6N07YzMFNZxCmjHdx0PXisjC2CLLuFy1ji8B9+2AaU1riP79l4McxhhjWhccvAF+fqNRs+ZoODmdrNBBDgU4O+/vRJPfmmDV7x/jj11x8N4EdI40BuzsAEm2nhm6T1lTKXsqY6xM4UCnCHaG7oRvlC+Wdl2aZZzugADgn10iyJ2aoMr/HgC1eWVkxhhj2k2N/OTJfAQGusDGZh4aN94BsVi/Qh6SdHk6tt3bhka/NsIPf4zH9n3J8P5dhM4RhsC2bcCvvwLPnwNyedYn0n11rw5jrEzhoWuFtMd7D05GnsRPPX+CS0cXLOqySBina7xrP9oe2goMGgyjffsAo0yrhzHGGGOlTKFIR0DAZwgP3wkHB1fY2MyukMcgXZGOrZ5bscZjDUwev8AuzzroeFMEUV09YMsW4JNPAD091VxaWt+OhqtlR9upV6dXL14egrEyhAOdQrgTegfTzkxDd/PumN5murBNIhKj694bwHdbgKlTVVeEsnd7M8YYY6VILk+Cj88IxMRcgKPjXlhajqlw9Z8qS8Ufd//AMr9lqPFPFPber4uOHiKIbMTA5s2qAMfAQLVzWhrw8mXuQQ6h7UFBtPgQYGhYqp+DMVZ0HOgUUHhiOIYcHIIWli0w1WIqRLTgJ3Vnu7iogpulS1VXe3ghUMYYY1oklUbB23sAkpIeCpnVzM17VajjkZKegj/u/YE1N9bA7HkY9nnUQI97IojqKIFNm4AJE94EOGoUvNDwtMjIvF+4Zk0OchirCHN0Nm7cCHt7exgZGaF169Zwd3fPc9+wsDCMGTMGjRo1glgshgsFBmWMVC7FsEPDhBSUh4Ydgj6Nb6arP6NHU2UAv/8OfPstBzmMMaZFFa1tyk1q6gt4enZGaupTtGx5pUIFOUnSJLj+6wr7DfbYtHc2Dp00gu9vInR+Lofil1+Ax4+BKVNyBjlqNjZAq1Z53zKlmGaMldNA5+DBg0KDsGjRInh6eqJLly7o27cvXlKXby7S0tJQo0YNYf8WLVqgLJp5diZuh97GsZHHULtybeglJUEycKBqEdCjR1V/OBljjGlNRWybshOLn8Pb+z0olVI4O9+AmVkbVASJ0kT8cOMHIcD54+A8HDtdCb6/AZ0C06BYvx4Xf/8dismTuTeGsQqo0EPXXF1dMXHiREyaNEm4v379epw/fx6bNm3CqlWrcuxvZ2eHDRs2CP/fvn17gd6DGiC6qcXHxws/09PThVtpou7vzXc3Y0v/LWht2RrpL1+i86JFEMXGQnb2LJSdO1PBoA3quijtOikL5eGycL3wd0azv0u6rqK1TdlFR19GpUoLoadXH02b/g19/VpaK1Np/f2NT4vHprubsP5/61EjNA5/edmjw7XXgGUKFK6uUHz6KdIlEiguXND68dG1dknXysNl0f160bXyFLQMIiXlniwgqVQKExMTHD58GEOGDMnYPmvWLNy/fx9Xr17N9/ldu3ZFy5YthQYoP0uWLMFSmvOSzb59+4T3Ly2+ib5YHLgYvS16Y3KdyTANDUWHJUsglsnw73ffIcHWttTKwhhj2pCcnCwM8YqLi4OZmZlOHoSK1jZlp6d3EyYm6yCXN0ZS0gIA2itLSavx4AGa/rEZvw1rhFUWt1E7KgW/3qyF7rfDIK1SBY+GDcOLXr2gyGt4GmOsQrVNherRiYqKglwuh6WlZZbtdP/Vq1fQlAULFmDOnDlZrprZ2NigW7duqF69OkpDUHwQJm+fjE51O+Hw6MMwuO8FyWefQWlujotffonOH30EfX19rUezFy5cQM+ePbVeFl0rD5eF64W/M5qh7rXQZRWpbcouLGwLnj79AebmQ/Ds2Sj07Nmv3P79fZ0cjfSvp6FKcBgGHghDN6dGaH/lMVBDDsWPP0IyaRIcjY3hWAplKQpdKouulYfLovv1UlbbpiJlXRMyjmVCnULZtxWHoaGhcMuOKrU0KpYytow4OgJG+kY4MuIITK5dB4YOBZo1g+z4caT873+lVpaC0KWy6Fp5uCxcL/ydKf7vUFlR3tum7J/t+fOlePFiKaytv4Ct7Y949uxcufybF5UchZ/+/Qm+e37C8YAUYVuzcCWQ9gpYu1aYJysxNkZ+CzuUx3opj+Xhsuh+vehKeQr6/oUKdCwsLCCRSHJcIYuIiMhxJa2sosZj8t+T4Rvpixuf3kCNv9yA8eOB3r1ptmve2VoYY4xpRUVomzJTKuV49Gi60Jtjb78SdevOh0wmQ3kTkRQhZFH79X+/oNMzGY4fEYHG2guhKwWw9erR+ETOeMoY00zWNQMDAyFlJ3VbZUb3O3bsiPJg/c312OO1B9sGbYPz/svAxx+rbsePA6am2i4eY4yxCtg2qcnlKfDxGY6wsG1o1Gg7bG0XaLTXShe8SnyFr9y+gtMPdkj9ZT2ebDXB+W1SmCSmqYIcQtOL790D3Ny0W1jGmE4r9NA1Gp88duxYtGnTBh06dMCWLVuE9J1Tp07NGMMcEhKCXbt2ZTyHJoOSxMREREZGCvepYWrSpAl0ycWnF/HVha/wdfu5GL3rnqpLfMECYMUKvmLEGGM6rDy3TWrp6bF4+HAQEhLuwMnpL1hYDEB5EpoQKqSJvnxuE6bdAl4+AAxTZRAN6gwY+gGBgaqFutUkEtVC3b16cRvNGNNMoDNy5EhER0dj2bJlwoJrTk5OOHPmDGz/y0BG27KvW+Ds7Jzx/7t37woZamj/58+fQ1c8jXmKkUdGoq9tD6zcHUppdABKPTpzpraLxhhjrIK2TWppaSHw8uqDtLRQtGjxD6pU6YDyIiguCD9eW4Ww/X9gxm1gfaAMihoWEM+eolqnztcX6NMn5xMp6Ll9W9WrQ8PLGWNME8kIpk+fLtxys2PHjhzbCpHBWmuLjQ0+MBh1xFVxfI8M4quHgP37qeXUdtEYY4xV0LZJLSnJH15edCKvhLPzdZiaZs4rVna9iH2BX//+FkY79mDeHaBOnAKydm2BJTMhHj5ctcAnHaNhw2g1VEChyPkitJ17dRhjmgx0yhNq6Mb/NR6Jwc/ge9Ye+oG3gbNnge7dtV00xhhjFVxc3E14e/eHgYEVmjc/ByOjOijrnr5+goPb5qDu3lNY/lAJsUQPytGjgZku0GvVKuvOUilAPXG5BTmEtgcFqfbLJSMeY6xiq/CBzgr3FbjrcRTef9WGcUoEcOUKkP0PLWOMMVbKoqNPw8fnQ1Su3BpOTiehr1+tTB+DwGBvXFszDS2O3sCCMCC2tjmw4ivofzYFMDfP/UkUvNDwtMjIvF+4Zk0OchhjuarQgc6pgFM4vH8xvA5VQqVqxoDHecDBQdvFYowxVsGFhe1AQMAkVK8+AE2a7IdEYoyy6smdC/BfPgvt3fwwPhV40cERqb8vR9UBH6iGnr2NjY3qxhhjJZleujzxi/TDprUj4bFTD5XsGgI3bnCQwxhjTOvDqV+8WI2AgAmwsvoUTZse0f0g5+JFgDLV0U81hQIvD26GZ2tr2L/TC53c/PFyyPuQ+j6E/Q1fGA0aWrAghzHGiqFC9ujEpsZi49fv46/dqRC/2xWiv04AlStru1iMMcYqMKVSgcDA2QgJ+Rm2tt/Czm6Jzq6RI5VJsfHORjyJDsSiuSdRyy8IWLiQUtnh1YblaL3pd9SJSsVDa31cXTwWHb/aAGezsj30jjFW9lSIQEeukMP9pTvCEsJQ07Tm/9u7E/CY7r0P4N+skhQRRKJJKpIidiGvJanobdGFS4ryVi3tgzbVlvCgdXF1e69b1FLXWqG1cy2tLlppi0bsW29EUCJMEColIiHreZ/fPx03y2hlZjIzJt/P80xjTs5kvj1zcn75n+V3kPzeKMxdkY7sPj1RY80muductSMSEVEVVlSUi5MnX8LVq+vRqNEC+Pm9Bls1IW4CZu2dhUKtEN3PAL7Jv3/j4EHk+daDT1ERtraqBud/TsCzQ99DC2c2CSAi67D7gc7m5M0Y/e1opN1Mk86ceG8HMOUnYE/fDgjf8AUPnRMRkVUVFNzE8eN9kJkZj+bN/w1v7742PciZsWeG+nfAdeCTraq0Qo47yddfPTTsXD8TbncC0aNHL7g4u1g7MhFVYY72Psjpt6GfGuQ4FQJLviwe5EzoCjzWYj82n/rc2hGJiKgKy8u7gmPHHkdW1kG0br3dpgc5crra+m8/wui9QMJS4MJc4JGbxYMcIV/9bmrom/conB3sfj8qET0AHO35dDU5kqNBg1s+sGkD8PJRYEgUMOMx2SI7IObbGDUfERGRpeXknMGRI+HIy0tHaGg8atXqYpsfwsWLwNy5uNa2Cc7PKsKH38uRG+BsLaCgzCVE8vzGW28W3+iTiMjK7HagI9fkyJEcrxwgbgXQNQXo9QKwsk3x92UApLupU/MRERFZUlbWERw9GgEHB2eEhu5B9eqtLPr+spNvZ+pOrE1cq76W2+l36RIwbx60zp0Bf38UjBuLn/N0GPwcUG88sKA9EHwDcC4znpHnvid18D52zKL/P0REhtjtsWVpPOCfCXy7CvC5BTwxFDjgb3g+IiIiS/ntt++RlPQcPDyaoWXLr+Dq6m29a1d/51/TH4vbvYNn/3Mb2ob1wO4EFDo5YGcjF6yIAva1rYN6DzdGQlqCuhjn/R8BGRo5Gfj5RQ4OaLp6dXEXNiIiK7LbgU5wei72xMoGF4gYBpyua3i++jXqWzoaERFVUVeurMPJk0Pg5fXk7/fIecgq167KWQ3CJwvokwz0T0pD5PnhKHBywK5GLljZS8OBMB90a9cfI5r1w/KAcHXUx+MfHnAqKMQjmYYHOcJR0+B+7ZpcgMSupkRkVXY50NESEtCi72s44w48PQi4XLP8PA5wUHuwOj/S2RoRiYioiklLm4szZ2Lg4zMETZoshaNjJXckkxt4jhoFfPwx0LXr3WtXvW9pvw9ugMjzxTsEvw8ChvUGvgpxwIuPv4ZXmvfHMv+OcHT47xnuTo5OGNtprOq69j+vAN7Z5d9yaOshGBn2OnYlJuKJamwrTUTWZXcDnfzPN0Mb0B8H6xdi9fvPIz1l4+9tL7VSgxwx5+k5asNNRERUWTRNQ0rKROh0HyIgYAKCgv5Z+TcClWYAcupYcnLx11at8MuSafh0WRoeTy1uBf1DEPDKX4HPQ4DfPPQvLEJUSBTCA8IN/tjp3aarr3IfnTTP/17X4+RQPAga3W068vPzcecyTwsnIuuzq4FO1sK5cH8jBl+FOKJw5UosaTsIT9/jXGQZ5PRp2seqeYmIyL4VFeXj1KkRuHLlMwQHz0JAwBjLvPH27eoGnsrBgyj08cGjjsCFQCC6J7AlBMi4x1lzf3btqgx2PvjLB1hwaAHO/nYWwbWDMTJsJFydefNtIrIt9jHQ0TRcmzwWdf8xB8s7uiFkbRw6BUoPaajBTO8mvVV3Ndl4yzU5croaj+QQEVFlKizMRlJSf1y/HoemTVfDx2dgpb6fY+Z1/BI7HTlxX6HllwegP3GsSG7kWccN0z6Kwsep6/7059zPtasyqInpGGOG1ERElefBH+gUFuLisOfh99kWzOtRFz1W7ENQ7eBSs8ig5vHAx60WkYiIqpa8vGtITOyJ7OzjqrNa7drdzf4eub+m4+yWZciK+wp19ieiR9otOGpAenWgWv5/55OrbHwz7mBWvcHY/NtuXLx5sdTp3Hq8dpWI7M2DfR+d3FycfzYcviu2YNbQxhj079PlBjlERESWdOfOeRw9+hju3ElBmzY7DQ5ypDHAz6s+Qmawv/p6Pzevvn31EhI/+T/sfb4TfmlQAy4+9dHs1Unw/X4fzgV6InZoBA7Hb4RPSBjgVOb6UycnOE19B3OfmlPqWlU9XrtKRPbogR3oaDdu4FynEPj8cADz3/oL3ohNhJe7l7VjERFRFXbrViKOHAmHpuUhNDQBNWuGGWzxHDinAXLfGgfPlIvqqzyX6SVl/3oJx5Z+gITnO+JUYA1U8/VDy1cmw//7A9AFeiHub/+L4/u/hH9GPh7/4RzqRY1H60w3OBw6pM52KEWeHzyIPrrq2Nh/I/xq+pX6tly7KtN57SoR2ZMH6tS1RYcXYfwT46FdvoT0yLaolX4d/54zAm++vrjyO9gQEREZsPvCbvT06omsmwlITOwFd/eGaNlyG6pV873nfWy6ndHQ/lLxNPna/OhFvPxrX2TXGIAGx87B+0ASGl/IRhsNuOjpiDOt/KEb9Ff49RqEJmFPIaBMx9CiwiJ1varj1KmAo6N0QSgfVKZPmYI++/fz2lUiqhIeqIHO5B2TseLrKYhb5Qjn/ELsWzMdg58bb+1YRERUhc3+MArLu9fB6KCb8KrVGS1abIGzc/kbuOnvYyPtpt//EShwAJy14mYBG9cD7vlyE871uKQGNgFIHxQFv14volHYU/CTQcqfcCwogINOZ3iQI2S6fD8vD07VqvHaVSKye0adurZgwQI0bNgQbm5uaNeuHeLj4/9w/l27dqn5ZP6goCAsWrTIqLBtLgPxSzVkOxZi+vTeeIaDHCIisnJt+huANxtmYOfVfKS4vlJ6kKNpyEw9haS18/DlG90xeXUaEucXH8WRQY6+EFfPB+Z1AB59Ezh1JA6RP6XiLx+sQuP2z8DhPgY5osjFBQV79wKHD9/7IS2neSNPIqoiKnxEZ/369YiJiVEFJSIiAosXL8YzzzyDEydO4JFHHik3/7lz5/Dss89ixIgRWLVqFRISEjBy5Eh4e3ujb9++FXrvr1cDZ32BngOBzKtfYUZBHvv2ExGRVWtT/mDgPyeAxalA+A/R8K65GQ4nklHzrA4Bukx45WjwBBDsBJysA/hmFx/FKTl8kaM74TpgzNNAevYV4z/RgAAgKIhrBBGRMQOdWbNmYdiwYRg+fLh6PmfOHHz33XdYuHAhpk2bVm5+2UMmRUbmE02bNsWhQ4cwc+bMexaT3Nxc9dDLzMxUX7f7AyP7ArelOtwuxIwfZyC6XbRFP0i543NOTg4yMjLg4uJi0fe25Sy2lodZuFy4zphHVlaW+iqnW9kya9amOkuBlz4HXlHPbiDXcQMu1HPBxYC6SIlqBpfmLVE7NAIXvVywcPYL2LIBuFX2h2tAyCXgiWTAo8BDbUcrgts8LpeK4jrD5VIlapNWAbm5uZqTk5O2efPmUtNHjRqlRUZGGnxN586d1fdLktc7OztreXl5Bl8zdepUSc0HlwHXAa4DXAdsZB3Q6XSarWJtsv76wQeXAdcBrgOwwdpUoSM6165dQ2FhIXx8fEpNl+fp6ekGXyPTDc1fUFCgfl79+uXvwDxx4kSMHTv27vMbN26gQYMGuHDhAjw95QQA67l58yYCAgKg0+lQs2b5i02rahZby8MsXC5cZ8xD9pbJnrOHH34Ytoq1idu8e2EtuDcuGy6XqlCbjOq6VraVs7zZH7V3NjS/oel61apVU4+yZJBj7QWrJzmYhcuG64x9/S7ZWh5byWLtHUz3i7XJdtYZwSy2v1xsLQ+z2P5yedBqU4W6rtWtWxdOTk7ljt5cvXq13FEbPV9fX4PzOzs7o06dOhV5eyIiItYmIiK6LxUa6Li6uqpWnHFxcaWmy/Pw8HCDr+nUqVO5+bdv346wsDCrX8hEREQPPtYmIiIyy3105NqZpUuXYtmyZUhOTsaYMWPUtTPR0dF3r68ZMmTI3fll+vnz59XrZH55XWxsLMaNG3ff7ymnsU2dOtXg6WyWxixcNlxn7O93ydby2FKWBwVrk+2sM7a0/jILlw3XGfv8fbpfDtKRoKIvkvsUTJ8+HZcvX0aLFi0we/ZsREZGqu+99NJLSE1Nxc6dO0vdlE0GRElJSeqiobfeeuvuwIiIiMgcWJuIiMjkgQ4REREREZFdnbpGRERERERk6zjQISIiIiIiu8OBDhERERER2R0OdIiIiIiIyO442lK3nIYNG8LNzU3dqyc+Pv4P55dObjKfzB8UFIRFixZZJYt0nhs4cCCaNGkCR0dHxMTEmC1HRbNs3rwZ3bp1g7e3t7pjrdzD6LvvvrNKlt27dyMiIkLdFNbd3R0hISGqO5811xm9hIQEdcPaNm3aWCWLdCSUO7iXfZw8edLiWURubi4mTZqEBg0aqJaRwcHBqg28pbNIx0ZDy6V58+YWzyJWr16N1q1bw8PDA/Xr18fLL7+MjIwMs2QxJs/8+fPRtGlT9fsk25sVK1aYLQvZfl2qaB7WJuvUJluqSxXNw9pkWFWqTQvssS5pNmDdunWai4uL9sknn2gnTpzQRo8erT300EPa+fPnDc6fkpKieXh4qPlkfnmdvH7jxo0Wz3Lu3Dlt1KhR2meffaa1adNGzW8uFc0i3//www+1AwcOaKdPn9YmTpyoXn/kyBGLZ5H3XLNmjXb8+HG1jFauXKk+s8WLF5ucxZg8ejdu3NCCgoK07t27a61bt7ZKlh07dkinQ+3UqVPa5cuX7z4KCgosnkX06tVL69ChgxYXF6c+q/3792sJCQkWzyKfTcnlodPptNq1a2tTp061eJb4+HjN0dFRmzt3rtreyPPmzZtrUVFRJmcxJs+CBQu0GjVqqNedPXtWW7t2rVa9enVt69atZslDtl2XjMnD2mT52mRLdcmYPKxNVbs2rbPTumQTA5327dtr0dHRpaaFhIRob7/9tsH5J0yYoL5f0quvvqp17NjR4llK6tKli1kHOqZk0WvWrJn27rvv2kSW5557Ths0aJDJWUzJM2DAAG3y5MlqA2WuglLRLPpicv36dbO8vylZtm3bpnl6emoZGRlWz1LWli1bNAcHBy01NdXiWWbMmKH+8Cjp448/1vz9/U3OYkyeTp06aePGjSs1TbY1ERERZslDtl2XjMlTEmuTZWqTLdUlY/KwNlXt2tTeTuuS1U9dy8vLw+HDh9G9e/dS0+X5nj17DL5m79695eZ/6qmncOjQIeTn51s0S2UxR5aioiJkZWWhdu3aVs9y9OhRNW+XLl1MymJKnuXLl+Ps2bPqrr7mYsqyCQ0NVYedn3zySezYscMqWbZu3YqwsDB1A2A/Pz80btwY48aNw+3bty2epazY2Fh07dpVnVJn6Szh4eFIS0vDN998IzuDcOXKFWzcuBE9evQwKYuxeeT0QjmVoCQ5VeDAgQMmbfPI9uuSsXkqC2uT7dclUz8n1qaqV5vy7LguWX2gc+3aNRQWFsLHx6fUdHmenp5u8DUy3dD8BQUF6udZMktlMUeWjz76CNnZ2ejfv7/Vsvj7+6vrPuSP6ddffx3Dhw83KYuxeX755Re8/fbb6txWOQ/aXIzJIoObJUuWYNOmTeq6KjmvVQY7P/30k8WzpKSkqHPWjx8/ji1btmDOnDlqoymflaWzlL2+YNu2bVZbX6SYyLoyYMAAuLq6wtfXF7Vq1cK8efOskkf+YF66dKkqRFLc5I9nuY5Kiokp2zyy/bpkbJ7Kwtpk+3XJ2DysTVW3Nl2z47pk3t8sE8iFXSXJQis77c/mNzTdElkqk7FZ1q5di3feeQdffPEF6tWrZ7UsciHbrVu3sG/fPrVBf/TRR/HCCy9YNI/88krDiHfffVcdsagMFVk2MrCRh540jdDpdJg5cyYiIyMtmkWO+sn3ZMPp6empps2aNQv9+vVTFxnK3hlLZSnp008/VRvvqKgok97f2CwnTpzAqFGj8Pe//11tzKW4jR8/HtHR0WpvnqXzTJkyRRWbjh07qvmk+MgFsnIkzsnJySx5yLTP6F7zG5puLNYm269NtlSXKpJHsDaxNjnYYV2y+hGdunXrqgVSdsR49erVciNLPRnBGppf9ohIJxVLZqkspmRZv349hg0bhg0bNqjDq9bMIt07WrZsiREjRmDMmDFq8GXpPHL6nuxpeOONN9Q6Io/33nsPP//8s/r3jz/+aLEs9yIbCtm7ZwpjssgePDllTT/IEdJBRTZacnjckln05L1lr9DgwYPVHitTGZNl2rRpqjOTDG5atWqlBjvSjUZyyaDH0nlkwCnvnZOTg9TUVFy4cAGBgYGoUaOG+nlkv3XJ2DyVhbXJ9uuSqZ9TSaxNVaM21bXjumT1gY6sLNLCLi4urtR0eS6H6AyRPeBl59++fbs6PcrFxcWiWSqLsVnkSI6MqNesWWOW6wlMyWJoIyHndFo6j7TaTkxMxLFjx+4+ZM+87L2Sf3fo0MFiWf7oGiYZdJjCmCyywbx06ZLas6l3+vRp1SpdTju0ZJaSLXrPnDmjBuvmYEwW2XDLMihJv4dKv5feknn0ZPsmn4tkWbduHXr27FkuJ9lXXTI2T2VhbbL9umTK51QWa1PVqE2u9lyXNBugb2kXGxurWtrFxMSolnb6jhbS8WHw4MHl2niOGTNGzS+vM3d76fvNIo4ePaoe7dq10wYOHKj+nZSUZPEs0jLT2dlZmz9/fqlWiNIa0dJZ/vWvf6kWg9LmWh7Lli3TatasqU2aNMnkLMbkKcuc3W0qmmX27Nmqa4ssF2lxKt+XX8VNmzZZPEtWVpbq1tKvXz+1zu7atUtr1KiRNnz4cItn0ZPuR9Lu2pwqmmX58uXqd0naZ0rbzN27d2thYWGqK4018kgrcmmDK+uMtP+WLk3S3lTa45L91yVj8gjWJsvWJluqS8bkYW2q2rVpnZ3WJZsY6Aj547xBgwaaq6ur1rZtW/UHl97QoUNVe8ySdu7cqYWGhqr5AwMDtYULF1oti/yRWvYhr7d0Fvm3oSwyn6WzSLtD6e0uhV+KiHxW8otZWFholiwVzVPZBaUiWeReR8HBwZqbm5vm5eWlPfbYY9rXX39tlSwiOTlZ69q1q+bu7q4GPWPHjtVycnKskkUG5ZJjyZIlZnl/U7LIOizt2SVP/fr1tRdffFFLS0uzSh4pOnKfLskiv0+9e/fWTp48abYsZPpnVNl1yZg8rE2Wr022VJcqmoe16d6fU1WpTfPtsC45yH+sfVSJiIiIiIjInGzoJDoiIiIiIiLz4ECHiIiIiIjsDgc6RERERERkdzjQISIiIiIiu8OBDhERERER2R0OdIiIiIiIyO5woENERERERHaHAx0iIiIiIrI7HOgQEREREZHd4UCHiIiIiIjsDgc6REREREQEe/P/jel4noxLEbAAAAAASUVORK5CYII=", + "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": [ + "### Reestimate from true model" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "HIDDEN_SEMI-MARKOV_CHAIN\n", + "\n", + "6 STATES\n", + "\n", + "INITIAL_PROBABILITIES\n", + "0.73737 1e-05 0.227942 0.034658 1e-05 1e-05 \n", + "\n", + "TRANSITION_PROBABILITIES\n", + "0 0.495828 1e-05 0.504142 1e-05 1e-05 \n", + "1e-05 0 1e-05 1e-05 0.99996 1e-05 \n", + "1e-05 1e-05 0 0.99996 1e-05 1e-05 \n", + "1e-05 1e-05 1e-05 0 0.842339 0.157631 \n", + "1e-05 1e-05 1e-05 1e-05 0 0.99996 \n", + "0.999766 1.31243e-05 0.000201331 1e-05 1e-05 0 \n", + "\n", + "recurrent class: states 0 1 2 3 4 5\n", + "\n", + "time up to the first occurrence of state 0 distribution\n", + "mean: 120.693 median: 0 mode: 0\n", + "variance: 47468.1 standard deviation: 217.872 lower quartile: 0 upper quartile: 258\n", + "\n", + "time up to the first occurrence of state 0 frequency distribution - sample size: 22\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: 302.058 median: 423 mode: 5\n", + "variance: 97446.1 standard deviation: 312.164 lower quartile: 12 upper quartile: 907\n", + "\n", + "time up to the first occurrence of state 1 frequency distribution - sample size: 11\n", + "mean: 11.8182 median: 10 mode: 10\n", + "variance: 72.9636 standard deviation: 8.54188 lower quartile: 6 upper quartile: 16\n", + "\n", + "time up to the first occurrence of state 2 distribution\n", + "mean: 0.79118 median: -1 mode: 0\n", + "variance: 543.867 standard deviation: 23.3209 lower quartile: -1 upper quartile: -1\n", + "\n", + "time up to the first occurrence of state 2 frequency distribution - sample size: 7\n", + "mean: 0 median: 0 mode: 0\n", + "variance: 0 standard deviation: 0\n", + "\n", + "time up to the first occurrence of state 3 distribution\n", + "mean: 161.151 median: 13 mode: 8\n", + "variance: 72430.4 standard deviation: 269.129 lower quartile: 8 upper quartile: 515\n", + "\n", + "time up to the first occurrence of state 3 frequency distribution - sample size: 19\n", + "mean: 9.26316 median: 8 mode: 6\n", + "variance: 33.9825 standard deviation: 5.82945 lower quartile: 6 upper quartile: 12\n", + "\n", + "time up to the first occurrence of state 4 distribution\n", + "mean: 68.7232 median: 24 mode: 22\n", + "variance: 21578.6 standard deviation: 146.897 lower quartile: 19 upper quartile: 31\n", + "\n", + "time up to the first occurrence of state 4 frequency distribution - sample size: 27\n", + "mean: 23.8148 median: 23 mode: 13\n", + "variance: 72.7721 standard deviation: 8.53066 lower quartile: 18 upper quartile: 27\n", + "\n", + "time up to the first occurrence of state 5 distribution\n", + "mean: 42.4645 median: 43 mode: 42\n", + "variance: 156.799 standard deviation: 12.5219 lower quartile: 35 upper quartile: 50\n", + "\n", + "time up to the first occurrence of state 5 frequency distribution - sample size: 30\n", + "mean: 42.3333 median: 40.5 mode: 40\n", + "variance: 148.23 standard deviation: 12.175 lower quartile: 37 upper quartile: 50\n", + "\n", + "state 0 recurrence time distribution\n", + "mean: 43.3505 median: 1 mode: 1\n", + "variance: 19878.4 standard deviation: 140.991 lower quartile: 1 upper quartile: 1\n", + "\n", + "state 0 recurrence time frequency distribution - sample size: 220\n", + "mean: 1 median: 1 mode: 1\n", + "variance: 0 standard deviation: 0\n", + "\n", + "state 1 recurrence time distribution\n", + "mean: 21.0974 median: 1 mode: 1\n", + "variance: 12219 standard deviation: 110.539 lower quartile: 1 upper quartile: 1\n", + "\n", + "state 1 recurrence time frequency distribution - sample size: 192\n", + "mean: 1 median: 1 mode: 1\n", + "variance: 0 standard deviation: 0\n", + "\n", + "state 2 recurrence time distribution\n", + "mean: 1.02823 median: 1 mode: 1\n", + "variance: 19.3418 standard deviation: 4.39793 lower quartile: 1 upper quartile: 1\n", + "\n", + "state 2 recurrence time frequency distribution - sample size: 57\n", + "mean: 1 median: 1 mode: 1\n", + "variance: 0 standard deviation: 0\n", + "\n", + "state 3 recurrence time distribution\n", + "mean: 35.7462 median: 1 mode: 1\n", + "variance: 20514.6 standard deviation: 143.229 lower quartile: 1 upper quartile: 1\n", + "\n", + "state 3 recurrence time frequency distribution - sample size: 182\n", + "mean: 1 median: 1 mode: 1\n", + "variance: 0 standard deviation: 0\n", + "\n", + "state 4 recurrence time distribution\n", + "mean: 22.5684 median: 1 mode: 1\n", + "variance: 11001 standard deviation: 104.886 lower quartile: 1 upper quartile: 1\n", + "\n", + "state 4 recurrence time frequency distribution - sample size: 533\n", + "mean: 1 median: 1 mode: 1\n", + "variance: 0 standard deviation: 0\n", + "\n", + "state 5 recurrence time distribution\n", + "mean: 1.10256 median: 1 mode: 1\n", + "variance: 4.89363 standard deviation: 2.21215 lower quartile: 1 upper quartile: 1\n", + "\n", + "state 5 recurrence time frequency distribution - sample size: 4700\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.64862 PROBABILITY : 0.158153\n", + "mean: 10.7756 median: 9 mode: 5\n", + "variance: 55.4881 standard deviation: 7.44904 lower quartile: 5 upper quartile: 14\n", + "coefficient of skewness: 1.56342 coefficient of kurtosis: 3.65743\n", + "\n", + "state 0 sojourn time frequency distribution - sample size: 22\n", + "mean: 11 median: 9 mode: 6\n", + "variance: 58.5714 standard deviation: 7.6532 lower quartile: 6 upper quartile: 14\n", + "\n", + "state 0 forward sojourn time distribution\n", + "mean: 8.4621 median: 7 mode: 1.5\n", + "variance: 50.666 standard deviation: 7.11801 lower quartile: 3 upper quartile: 12\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.47\n", + "mean: 18.35 median: 18 mode: 18\n", + "variance: 1.2455 standard deviation: 1.11602 lower quartile: 18 upper quartile: 19\n", + "coefficient of skewness: 0.0537625 coefficient of kurtosis: -0.39711\n", + "\n", + "state 1 sojourn time frequency distribution - sample size: 11\n", + "mean: 18.4545 median: 19 mode: 19\n", + "variance: 1.07273 standard deviation: 1.03573 lower quartile: 17 upper quartile: 19\n", + "\n", + "state 1 forward sojourn time distribution\n", + "mean: 9.70894 median: 10 mode: 8.5\n", + "variance: 28.5998 standard deviation: 5.34788 lower quartile: 5 upper quartile: 14\n", + "\n", + "final run - state 1 sojourn time frequency distribution - sample size: 0\n", + "\n", + "STATE 2 OCCUPANCY_DISTRIBUTION\n", + "NEGATIVE_BINOMIAL INF_BOUND : 6 PARAMETER : 3.80769 PROBABILITY : 0.535135\n", + "mean: 9.30769 median: 9 mode: 8\n", + "variance: 6.18105 standard deviation: 2.48617 lower quartile: 7 upper quartile: 11\n", + "coefficient of skewness: 1.10104 coefficient of kurtosis: 1.73754\n", + "\n", + "state 2 sojourn time frequency distribution - sample size: 7\n", + "mean: 9.14286 median: 8 mode: 7.5\n", + "variance: 5.14286 standard deviation: 2.26779 lower quartile: 7 upper quartile: 11\n", + "\n", + "state 2 forward sojourn time distribution\n", + "mean: 5.48584 median: 5 mode: 3.5\n", + "variance: 10.7213 standard deviation: 3.27434 lower quartile: 3 upper quartile: 8\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 : 145.79 PROBABILITY : 0.937389\n", + "mean: 10.7377 median: 11 mode: 10\n", + "variance: 10.3881 standard deviation: 3.22306 lower quartile: 8 upper quartile: 13\n", + "coefficient of skewness: 0.351711 coefficient of kurtosis: 0.137419\n", + "\n", + "state 3 sojourn time frequency distribution - sample size: 19\n", + "mean: 10.5789 median: 11 mode: 10\n", + "variance: 11.7018 standard deviation: 3.42078 lower quartile: 7 upper quartile: 13\n", + "\n", + "state 3 forward sojourn time distribution\n", + "mean: 6.35253 median: 6 mode: 1\n", + "variance: 14.8497 standard deviation: 3.85353 lower quartile: 3 upper quartile: 9\n", + "\n", + "final run - state 3 sojourn time frequency distribution - sample size: 0\n", + "\n", + "STATE 4 OCCUPANCY_DISTRIBUTION\n", + "NEGATIVE_BINOMIAL INF_BOUND : 10 PARAMETER : 4.32173 PROBABILITY : 0.281585\n", + "mean: 21.0261 median: 20 mode: 18\n", + "variance: 39.1574 standard deviation: 6.25758 lower quartile: 16 upper quartile: 25\n", + "coefficient of skewness: 0.97524 coefficient of kurtosis: 1.41387\n", + "\n", + "state 4 sojourn time frequency distribution - sample size: 27\n", + "mean: 20.7407 median: 21 mode: 21\n", + "variance: 40.4302 standard deviation: 6.35847 lower quartile: 15 upper quartile: 24\n", + "\n", + "state 4 forward sojourn time distribution\n", + "mean: 11.9441 median: 11 mode: 5.5\n", + "variance: 59.252 standard deviation: 7.69753 lower quartile: 6 upper quartile: 17\n", + "\n", + "final run - state 4 sojourn time frequency distribution - sample size: 0\n", + "\n", + "STATE 5 OCCUPANCY_DISTRIBUTION\n", + "NEGATIVE_BINOMIAL INF_BOUND : 146 PARAMETER : 3.02714 PROBABILITY : 0.0104831\n", + "mean: 431.735 median: 401 mode: 337\n", + "variance: 27256.7 standard deviation: 165.096 lower quartile: 310 upper quartile: 520\n", + "coefficient of skewness: 1.14953 coefficient of kurtosis: 1.98211\n", + "\n", + "state 5 sojourn time frequency distribution - sample size: 0\n", + "\n", + "state 5 forward sojourn time distribution\n", + "mean: 247.93 median: 217 mode: 73.5\n", + "variance: 32152.5 standard deviation: 179.311 lower quartile: 108 upper quartile: 349\n", + "\n", + "final run - state 5 sojourn time frequency distribution - sample size: 30\n", + "mean: 157.667 median: 160 mode: 160\n", + "variance: 148.23 standard deviation: 12.175 lower quartile: 150 upper quartile: 163\n", + "\n", + "number of runs of state 0 per length 200 sequence distribution\n", + "mean: 0.738553 median: 1 mode: 1\n", + "variance: 0.194461 standard deviation: 0.440977 lower quartile: 0 upper quartile: 1\n", + "coefficient of skewness: -1.0618 coefficient of kurtosis: -0.800665\n", + "\n", + "number of runs of state 0 per sequence frequency distribution - sample size: 30\n", + "mean: 0.733333 median: 1 mode: 1\n", + "variance: 0.202299 standard deviation: 0.449776 lower quartile: 0 upper quartile: 1\n", + "coefficient of skewness: -1.11166 coefficient of kurtosis: -0.956818\n", + "\n", + "number of runs of state 1 per length 200 sequence distribution\n", + "mean: 0.365859 median: 0 mode: 0\n", + "variance: 0.232033 standard deviation: 0.481698 lower quartile: 0 upper quartile: 1\n", + "coefficient of skewness: 0.557349 coefficient of kurtosis: -1.68835\n", + "\n", + "number of runs of state 1 per sequence frequency distribution - sample size: 30\n", + "mean: 0.366667 median: 0 mode: 0\n", + "variance: 0.24023 standard deviation: 0.490133 lower quartile: 0 upper quartile: 1\n", + "coefficient of skewness: 0.582933 coefficient of kurtosis: -1.73732\n", + "\n", + "number of runs of state 2 per length 200 sequence distribution\n", + "mean: 0.227968 median: 0 mode: 0\n", + "variance: 0.176007 standard deviation: 0.419532 lower quartile: 0 upper quartile: 0\n", + "coefficient of skewness: 1.29704 coefficient of kurtosis: -0.317141\n", + "\n", + "number of runs of state 2 per sequence frequency distribution - sample size: 30\n", + "mean: 0.233333 median: 0 mode: 0\n", + "variance: 0.185057 standard deviation: 0.430183 lower quartile: 0 upper quartile: 0\n", + "coefficient of skewness: 1.32834 coefficient of kurtosis: -0.496273\n", + "\n", + "number of runs of state 3 per length 200 sequence distribution\n", + "mean: 0.634593 median: 1 mode: 1\n", + "variance: 0.232346 standard deviation: 0.482023 lower quartile: 0 upper quartile: 1\n", + "coefficient of skewness: -0.552831 coefficient of kurtosis: -1.67734\n", + "\n", + "number of runs of state 3 per sequence frequency distribution - sample size: 30\n", + "mean: 0.633333 median: 1 mode: 1\n", + "variance: 0.24023 standard deviation: 0.490133 lower quartile: 0 upper quartile: 1\n", + "coefficient of skewness: -0.582933 coefficient of kurtosis: -1.73732\n", + "\n", + "number of runs of state 4 per length 200 sequence distribution\n", + "mean: 0.900073 median: 1 mode: 1\n", + "variance: 0.0900212 standard deviation: 0.300035 lower quartile: 1 upper quartile: 1\n", + "coefficient of skewness: -2.6636 coefficient of kurtosis: 5.11438\n", + "\n", + "number of runs of state 4 per sequence frequency distribution - sample size: 30\n", + "mean: 0.9 median: 1 mode: 1\n", + "variance: 0.0931034 standard deviation: 0.305129 lower quartile: 1 upper quartile: 1\n", + "coefficient of skewness: -2.80912 coefficient of kurtosis: 4.84074\n", + "\n", + "number of runs of state 5 per length 200 sequence distribution\n", + "mean: 1.00001 median: 1 mode: 1\n", + "variance: 9.8374e-06 standard deviation: 0.00313646 lower quartile: 1 upper quartile: 1\n", + "coefficient of skewness: 318.824 coefficient of kurtosis: 101647\n", + "\n", + "number of runs of state 5 per sequence frequency distribution - sample size: 30\n", + "mean: 1 median: 1 mode: 1\n", + "variance: 0 standard deviation: 0\n", + "\n", + "number of occurrences of state 0 per length 200 sequence distribution\n", + "mean: 7.95199 median: 6 mode: 0\n", + "variance: 63.3686 standard deviation: 7.96044 lower quartile: 0 upper quartile: 12\n", + "coefficient of skewness: 1.39828 coefficient of kurtosis: 2.80637\n", + "\n", + "number of occurrences of state 0 per sequence frequency distribution - sample size: 30\n", + "mean: 8.06667 median: 6 mode: 0\n", + "variance: 66.892 standard deviation: 8.17875 lower quartile: 0 upper quartile: 12\n", + "coefficient of skewness: 1.17775 coefficient of kurtosis: 0.543067\n", + "\n", + "number of occurrences of state 1 per length 200 sequence distribution\n", + "mean: 6.71116 median: 0 mode: 0\n", + "variance: 78.5603 standard deviation: 8.86342 lower quartile: 0 upper quartile: 18\n", + "coefficient of skewness: 0.575827 coefficient of kurtosis: -1.64293\n", + "\n", + "number of occurrences of state 1 per sequence frequency distribution - sample size: 30\n", + "mean: 6.76667 median: 0 mode: 0\n", + "variance: 82.1851 standard deviation: 9.0656 lower quartile: 0 upper quartile: 18\n", + "coefficient of skewness: 0.597422 coefficient of kurtosis: -1.70479\n", + "\n", + "number of occurrences of state 2 per length 200 sequence distribution\n", + "mean: 2.12182 median: 0 mode: 0\n", + "variance: 16.6559 standard deviation: 4.08116 lower quartile: 0 upper quartile: 0\n", + "coefficient of skewness: 1.63924 coefficient of kurtosis: 1.36704\n", + "\n", + "number of occurrences of state 2 per sequence frequency distribution - sample size: 30\n", + "mean: 2.13333 median: 0 mode: 0\n", + "variance: 16.5333 standard deviation: 4.06612 lower quartile: 0 upper quartile: 0\n", + "coefficient of skewness: 1.58175 coefficient of kurtosis: 0.52229\n", + "\n", + "number of occurrences of state 3 per length 200 sequence distribution\n", + "mean: 6.81292 median: 8 mode: 0\n", + "variance: 33.3518 standard deviation: 5.7751 lower quartile: 0 upper quartile: 11\n", + "coefficient of skewness: 0.0418132 coefficient of kurtosis: -1.30694\n", + "\n", + "number of occurrences of state 3 per sequence frequency distribution - sample size: 30\n", + "mean: 6.7 median: 7 mode: 0\n", + "variance: 34.1483 standard deviation: 5.84365 lower quartile: 0 upper quartile: 12\n", + "coefficient of skewness: 0.0268608 coefficient of kurtosis: -1.56226\n", + "\n", + "number of occurrences of state 4 per length 200 sequence distribution\n", + "mean: 18.9237 median: 19 mode: 0\n", + "variance: 75.0237 standard deviation: 8.66162 lower quartile: 15 upper quartile: 24\n", + "coefficient of skewness: -0.357748 coefficient of kurtosis: 0.843418\n", + "\n", + "number of occurrences of state 4 per sequence frequency distribution - sample size: 30\n", + "mean: 18.6667 median: 21 mode: 21\n", + "variance: 76.2989 standard deviation: 8.73492 lower quartile: 15 upper quartile: 24\n", + "coefficient of skewness: -0.37642 coefficient of kurtosis: 0.649974\n", + "\n", + "number of occurrences of state 5 per length 200 sequence distribution\n", + "mean: 157.478 median: 157 mode: 158\n", + "variance: 158.987 standard deviation: 12.609 lower quartile: 150 upper quartile: 165\n", + "coefficient of skewness: -0.0649767 coefficient of kurtosis: 0.66758\n", + "\n", + "number of occurrences of state 5 per sequence frequency distribution - sample size: 30\n", + "mean: 157.667 median: 160 mode: 160\n", + "variance: 148.23 standard deviation: 12.175 lower quartile: 150 upper quartile: 163\n", + "coefficient of skewness: 0.0917512 coefficient of kurtosis: 0.395032\n", + "\n", + "1 OUTPUT_PROCESS\n", + "\n", + "OUTPUT_PROCESS 1 : CATEGORICAL\n", + "\n", + "STATE 0 OBSERVATION_DISTRIBUTION\n", + "OUTPUT 0 : 0.621223\n", + "OUTPUT 1 : 0.163883\n", + "OUTPUT 2 : 0.214874\n", + "OUTPUT 3 : 1e-05\n", + "OUTPUT 4 : 1e-05\n", + "\n", + "STATE 1 OBSERVATION_DISTRIBUTION\n", + "OUTPUT 0 : 0.20309\n", + "OUTPUT 1 : 0.649248\n", + "OUTPUT 2 : 0.0097095\n", + "OUTPUT 3 : 0.137943\n", + "OUTPUT 4 : 1e-05\n", + "\n", + "STATE 2 OBSERVATION_DISTRIBUTION\n", + "OUTPUT 0 : 0.06476\n", + "OUTPUT 1 : 0.389777\n", + "OUTPUT 2 : 0.487571\n", + "OUTPUT 3 : 1e-05\n", + "OUTPUT 4 : 0.057882\n", + "\n", + "STATE 3 OBSERVATION_DISTRIBUTION\n", + "OUTPUT 0 : 0.170503\n", + "OUTPUT 1 : 0.178151\n", + "OUTPUT 2 : 0.0293577\n", + "OUTPUT 3 : 0.585916\n", + "OUTPUT 4 : 0.0360725\n", + "\n", + "STATE 4 OBSERVATION_DISTRIBUTION\n", + "OUTPUT 0 : 0.113356\n", + "OUTPUT 1 : 0.0278785\n", + "OUTPUT 2 : 1e-05\n", + "OUTPUT 3 : 0.0310126\n", + "OUTPUT 4 : 0.827743\n", + "\n", + "STATE 5 OBSERVATION_DISTRIBUTION\n", + "OUTPUT 0 : 0.842944\n", + "OUTPUT 1 : 0.0449192\n", + "OUTPUT 2 : 0.0841957\n", + "OUTPUT 3 : 1e-05\n", + "OUTPUT 4 : 0.027931\n", + "\n", + "observation probability matrix\n", + "\n", + " 0 1 2 3 4 \n", + "0 0.621223 0.163883 0.214874 1e-05 1e-05 \n", + "1 0.20309 0.649248 0.0097095 0.137943 1e-05 \n", + "2 0.06476 0.389777 0.487571 1e-05 0.057882 \n", + "3 0.170503 0.178151 0.0293577 0.585916 0.0360725 \n", + "4 0.113356 0.0278785 1e-05 0.0310126 0.827743 \n", + "5 0.842944 0.0449192 0.0841957 1e-05 0.027931 \n", + "\n", + "theoretical weights: 0.0397661 0.0335554 0.0106108 0.03407 0.094624 0.787374\n", + "\n", + "log-likelihood: -5844.74 (normalized: -0.974123)\n", + "maximum possible log-likelihood: -5844.74 (information: -0.974123)\n", + "deviance: 0.000288513\n", + "\n", + "chi-square test (4 degrees of freedom)\n", + "chi-square value: 0.00028841 critical probability: 1\n", + "reference chi-square value: 9.48773 reference critical probability: 0.05\n", + "\n", + "restoration weights: 0.0403333 0.0338333 0.0106667 0.0335 0.0933333 0.788333\n", + "\n", + "log-likelihood: -5844.79 (normalized: -0.974131)\n", + "maximum possible log-likelihood: -5844.74 (information: -0.974123)\n", + "deviance: 0.101631\n", + "\n", + "chi-square test (4 degrees of freedom)\n", + "chi-square value: 0.10193 critical probability: 0.998745\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: 2.75349 median: 1 mode: 0\n", + "variance: 25.9751 standard deviation: 5.09658 lower quartile: 0 upper quartile: 2\n", + "\n", + "time up to the first occurrence of output 0 frequency distribution - sample size: 30\n", + "mean: 2.43333 median: 1 mode: 0\n", + "variance: 14.7368 standard deviation: 3.83885 lower quartile: 0 upper quartile: 3\n", + "\n", + "time up to the first occurrence of output 1 distribution\n", + "mean: 4.14752 median: 2 mode: 0\n", + "variance: 39.3559 standard deviation: 6.27343 lower quartile: 1 upper quartile: 5\n", + "\n", + "time up to the first occurrence of output 1 frequency distribution - sample size: 30\n", + "mean: 3.93333 median: 3.5 mode: 0\n", + "variance: 14.0644 standard deviation: 3.75025 lower quartile: 1 upper quartile: 6\n", + "\n", + "time up to the first occurrence of output 2 distribution\n", + "mean: 8.15424 median: 2 mode: 0\n", + "variance: 262.05 standard deviation: 16.1879 lower quartile: 0 upper quartile: 5\n", + "\n", + "time up to the first occurrence of output 2 frequency distribution - sample size: 30\n", + "mean: 6 median: 1 mode: 0\n", + "variance: 221.586 standard deviation: 14.8858 lower quartile: 0 upper quartile: 4\n", + "\n", + "time up to the first occurrence of output 3 distribution\n", + "mean: 18.1798 median: 11 mode: 9\n", + "variance: 2800.69 standard deviation: 52.9216 lower quartile: 7 upper quartile: 16\n", + "\n", + "time up to the first occurrence of output 3 frequency distribution - sample size: 30\n", + "mean: 11.8333 median: 11 mode: 8\n", + "variance: 48.3506 standard deviation: 6.95346 lower quartile: 8 upper quartile: 15\n", + "\n", + "time up to the first occurrence of output 4 distribution\n", + "mean: 22.8089 median: 22 mode: 23\n", + "variance: 216.197 standard deviation: 14.7036 lower quartile: 14 upper quartile: 29\n", + "\n", + "time up to the first occurrence of output 4 frequency distribution - sample size: 30\n", + "mean: 23.6 median: 22 mode: 13\n", + "variance: 348.179 standard deviation: 18.6596 lower quartile: 13 upper quartile: 29\n", + "\n", + "output 0 recurrence time distribution\n", + "mean: 1.26054 median: 1 mode: 1\n", + "variance: 0.92791 standard deviation: 0.963281 lower quartile: 1 upper quartile: 1\n", + "\n", + "output 0 recurrence time frequency distribution - sample size: 4245\n", + "mean: 1.38751 median: 1 mode: 1\n", + "variance: 2.12666 standard deviation: 1.45831 lower quartile: 1 upper quartile: 1\n", + "\n", + "output 1 recurrence time distribution\n", + "mean: 17.0469 median: 10 mode: 1\n", + "variance: 384.989 standard deviation: 19.6211 lower quartile: 3 upper quartile: 24\n", + "\n", + "output 1 recurrence time frequency distribution - sample size: 429\n", + "mean: 12.1119 median: 5 mode: 1\n", + "variance: 252.501 standard deviation: 15.8903 lower quartile: 2 upper quartile: 17\n", + "\n", + "output 2 recurrence time distribution\n", + "mean: 11.9947 median: 8 mode: 1\n", + "variance: 148.799 standard deviation: 12.1983 lower quartile: 3 upper quartile: 16\n", + "\n", + "output 2 recurrence time frequency distribution - sample size: 458\n", + "mean: 11.8057 median: 7 mode: 1\n", + "variance: 158.883 standard deviation: 12.6049 lower quartile: 3 upper quartile: 16\n", + "\n", + "output 3 recurrence time distribution\n", + "mean: 83.9496 median: 2 mode: 1\n", + "variance: 34756.2 standard deviation: 186.43 lower quartile: 1 upper quartile: 9\n", + "\n", + "output 3 recurrence time frequency distribution - sample size: 135\n", + "mean: 2.81481 median: 1 mode: 1\n", + "variance: 12.1072 standard deviation: 3.47955 lower quartile: 1 upper quartile: 3\n", + "\n", + "output 4 recurrence time distribution\n", + "mean: 16.7768 median: 2 mode: 1\n", + "variance: 758.335 standard deviation: 27.5379 lower quartile: 1 upper quartile: 23\n", + "\n", + "output 4 recurrence time frequency distribution - sample size: 583\n", + "mean: 7.07376 median: 1 mode: 1\n", + "variance: 283.312 standard deviation: 16.8319 lower quartile: 1 upper quartile: 2\n", + "\n", + "output 0 sojourn time distribution\n", + "mean: 5.82822 median: 4 mode: 1\n", + "variance: 30.7781 standard deviation: 5.5478 lower quartile: 2 upper quartile: 8\n", + "\n", + "output 0 sojourn time frequency distribution - sample size: 810\n", + "mean: 5.02963 median: 3 mode: 1\n", + "variance: 26.6196 standard deviation: 5.15942 lower quartile: 1 upper quartile: 7\n", + "\n", + "final run - output 0 sojourn time frequency distribution - sample size: 24\n", + "mean: 8.375 median: 4.5 mode: 1.5\n", + "variance: 93.7228 standard deviation: 9.68106 lower quartile: 2 upper quartile: 12\n", + "\n", + "output 1 sojourn time distribution\n", + "mean: 1.17674 median: 1 mode: 1\n", + "variance: 0.448869 standard deviation: 0.669977 lower quartile: 1 upper quartile: 1\n", + "\n", + "output 1 sojourn time frequency distribution - sample size: 350\n", + "mean: 1.30286 median: 1 mode: 1\n", + "variance: 0.836381 standard deviation: 0.914539 lower quartile: 1 upper quartile: 1\n", + "\n", + "final run - output 1 sojourn time frequency distribution - sample size: 3\n", + "mean: 1 median: 1 mode: 1\n", + "variance: 0 standard deviation: 0\n", + "\n", + "output 2 sojourn time distribution\n", + "mean: 1.10601 median: 1 mode: 1\n", + "variance: 0.122467 standard deviation: 0.349952 lower quartile: 1 upper quartile: 1\n", + "\n", + "output 2 sojourn time frequency distribution - sample size: 428\n", + "mean: 1.13318 median: 1 mode: 1\n", + "variance: 0.176602 standard deviation: 0.42024 lower quartile: 1 upper quartile: 1\n", + "\n", + "final run - output 2 sojourn time frequency distribution - sample size: 3\n", + "mean: 1 median: 1 mode: 1\n", + "variance: 0 standard deviation: 0\n", + "\n", + "output 3 sojourn time distribution\n", + "mean: 1.6956 median: 1 mode: 1\n", + "variance: 1.57806 standard deviation: 1.25621 lower quartile: 1 upper quartile: 2\n", + "\n", + "output 3 sojourn time frequency distribution - sample size: 96\n", + "mean: 1.71875 median: 1 mode: 1\n", + "variance: 1.88849 standard deviation: 1.37422 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: 1.82529 median: 1 mode: 1\n", + "variance: 5.6274 standard deviation: 2.37221 lower quartile: 1 upper quartile: 1\n", + "\n", + "output 4 sojourn time frequency distribution - sample size: 231\n", + "mean: 2.65368 median: 1 mode: 1\n", + "variance: 11.4708 standard deviation: 3.38686 lower quartile: 1 upper quartile: 3\n", + "\n", + "final run - output 4 sojourn time frequency distribution - sample size: 0\n", + "\n", + "number of runs of output 0 per length 200 sequence distribution\n", + "mean: 27.6336 median: 28 mode: 28\n", + "variance: 16.861 standard deviation: 4.10622 lower quartile: 25 upper quartile: 30\n", + "coefficient of skewness: 0.0640315 coefficient of kurtosis: -0.0200188\n", + "\n", + "number of runs of output 0 per sequence frequency distribution - sample size: 30\n", + "mean: 27.8 median: 27 mode: 25\n", + "variance: 9.47586 standard deviation: 3.07829 lower quartile: 25 upper quartile: 30\n", + "coefficient of skewness: 0.984295 coefficient of kurtosis: 0.439251\n", + "\n", + "number of runs of output 1 per length 200 sequence distribution\n", + "mean: 11.5437 median: 11 mode: 11\n", + "variance: 10.0696 standard deviation: 3.17326 lower quartile: 9 upper quartile: 14\n", + "coefficient of skewness: 0.20567 coefficient of kurtosis: 0.00481521\n", + "\n", + "number of runs of output 1 per sequence frequency distribution - sample size: 30\n", + "mean: 11.7667 median: 11 mode: 8\n", + "variance: 13.5644 standard deviation: 3.68298 lower quartile: 8 upper quartile: 14\n", + "coefficient of skewness: 0.575913 coefficient of kurtosis: -0.828011\n", + "\n", + "number of runs of output 2 per length 200 sequence distribution\n", + "mean: 14.3625 median: 14 mode: 14\n", + "variance: 11.7615 standard deviation: 3.42951 lower quartile: 12 upper quartile: 17\n", + "coefficient of skewness: 0.195556 coefficient of kurtosis: 0.0226429\n", + "\n", + "number of runs of output 2 per sequence frequency distribution - sample size: 30\n", + "mean: 14.3667 median: 14 mode: 13\n", + "variance: 7.82644 standard deviation: 2.79758 lower quartile: 13 upper quartile: 16\n", + "coefficient of skewness: 0.323742 coefficient of kurtosis: -0.334981\n", + "\n", + "number of runs of output 3 per length 200 sequence distribution\n", + "mean: 3.23574 median: 3 mode: 3\n", + "variance: 2.04246 standard deviation: 1.42915 lower quartile: 2 upper quartile: 4\n", + "coefficient of skewness: 0.38395 coefficient of kurtosis: 0.207086\n", + "\n", + "number of runs of output 3 per sequence frequency distribution - sample size: 30\n", + "mean: 3.2 median: 3.5 mode: 4\n", + "variance: 1.82069 standard deviation: 1.34933 lower quartile: 2 upper quartile: 4\n", + "coefficient of skewness: -0.119107 coefficient of kurtosis: -0.881921\n", + "\n", + "number of runs of output 4 per length 200 sequence distribution\n", + "mean: 7.90836 median: 8 mode: 8\n", + "variance: 6.98131 standard deviation: 2.64222 lower quartile: 6 upper quartile: 10\n", + "coefficient of skewness: 0.267387 coefficient of kurtosis: 0.082417\n", + "\n", + "number of runs of output 4 per sequence frequency distribution - sample size: 30\n", + "mean: 7.7 median: 7 mode: 7\n", + "variance: 9.38966 standard deviation: 3.06425 lower quartile: 5 upper quartile: 10\n", + "coefficient of skewness: 0.620055 coefficient of kurtosis: 0.0409737\n", + "\n", + "number of occurrences of output 0 per length 200 sequence distribution\n", + "mean: 142.493 median: 142 mode: 142\n", + "variance: 81.8683 standard deviation: 9.04811 lower quartile: 137 upper quartile: 148\n", + "coefficient of skewness: 0.202145 coefficient of kurtosis: 0.284868\n", + "\n", + "number of occurrences of output 0 per sequence frequency distribution - sample size: 30\n", + "mean: 142.5 median: 142 mode: 136\n", + "variance: 94.1207 standard deviation: 9.70158 lower quartile: 136 upper quartile: 148\n", + "coefficient of skewness: 0.524983 coefficient of kurtosis: 0.131893\n", + "\n", + "number of occurrences of output 1 per length 200 sequence distribution\n", + "mean: 15.3025 median: 15 mode: 12\n", + "variance: 31.7998 standard deviation: 5.63913 lower quartile: 11 upper quartile: 20\n", + "coefficient of skewness: 0.362811 coefficient of kurtosis: -0.5637\n", + "\n", + "number of occurrences of output 1 per sequence frequency distribution - sample size: 30\n", + "mean: 15.3 median: 14 mode: 19\n", + "variance: 30.8379 standard deviation: 5.55319 lower quartile: 10 upper quartile: 19\n", + "coefficient of skewness: 0.326489 coefficient of kurtosis: -1.14108\n", + "\n", + "number of occurrences of output 2 per length 200 sequence distribution\n", + "mean: 16.2676 median: 16 mode: 16\n", + "variance: 17.4612 standard deviation: 4.17866 lower quartile: 13 upper quartile: 19\n", + "coefficient of skewness: 0.284076 coefficient of kurtosis: 0.0791914\n", + "\n", + "number of occurrences of output 2 per sequence frequency distribution - sample size: 30\n", + "mean: 16.2667 median: 15.5 mode: 14\n", + "variance: 13.5126 standard deviation: 3.67595 lower quartile: 14 upper quartile: 20\n", + "coefficient of skewness: 0.321274 coefficient of kurtosis: -0.662407\n", + "\n", + "number of occurrences of output 3 per length 200 sequence distribution\n", + "mean: 5.5061 median: 5 mode: 4\n", + "variance: 8.47088 standard deviation: 2.91048 lower quartile: 3 upper quartile: 7\n", + "coefficient of skewness: 0.499194 coefficient of kurtosis: -0.0441533\n", + "\n", + "number of occurrences of output 3 per sequence frequency distribution - sample size: 30\n", + "mean: 5.5 median: 5 mode: 5\n", + "variance: 8.81034 standard deviation: 2.96822 lower quartile: 4 upper quartile: 7\n", + "coefficient of skewness: 0.712043 coefficient of kurtosis: 0.453455\n", + "\n", + "number of occurrences of output 4 per length 200 sequence distribution\n", + "mean: 20.4312 median: 21 mode: 20\n", + "variance: 54.549 standard deviation: 7.38573 lower quartile: 17 upper quartile: 25\n", + "coefficient of skewness: -0.194158 coefficient of kurtosis: 0.571276\n", + "\n", + "number of occurrences of output 4 per sequence frequency distribution - sample size: 30\n", + "mean: 20.4333 median: 22 mode: 22\n", + "variance: 61.6333 standard deviation: 7.85069 lower quartile: 16 upper quartile: 26\n", + "coefficient of skewness: -0.555489 coefficient of kurtosis: -0.026905\n", + "\n", + "distances between observation distributions for consecutive states\n", + "_ 0.623297 _ 0.636236 _ _ \n", + "_ _ _ _ 0.827733 _ \n", + "_ _ _ 0.691649 _ _ \n", + "_ _ _ _ 0.791671 0.727279 \n", + "_ _ _ _ _ 0.830815 \n", + "0.249642 0.742261 0.778184 _ _ _ \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: -5844.74 (-0.974123)\n", + "\n", + "log-likelihood for the state sequences: -4096.51 (normalized: -0.682751)\n", + "\n", + "state sequence entropy: 62.7673 (normalized: 0.0104612)\n", + "\n", + "log-likelihood for the observed sequences: -4067.6 (normalized: -0.677933)\n", + "\n", + "39 free parameters 2 * penalyzed log-likelihood (AIC): -8213.2\n", + "\n", + "39 free parameters 2 * penalyzed log-likelihood (AICc): -8213.73\n", + "\n", + "39 free parameters 2 * penalyzed log-likelihood (BIC): -8474.48\n", + "\n", + "39 free parameters 2 * penalyzed log-likelihood (BICc): -8339.41\n", + "\n", + "39 free parameters 2 * penalyzed log-likelihood (ICL): -8600.02\n", + "\n", + "39 free parameters 2 * penalyzed log-likelihood (ICLc): -8464.95\n", + "\n", + "iteration 1 log-likelihood for the observed sequences: -4067.6\n", + "iteration 2 log-likelihood for the observed sequences: -4067.6\n", + "\n", + "2 iterations\n", + "\n", + "complete/censored state occupancy weights\n", + "state 0: 22.1226, 0.0161006 (0.999273, 0.000727262)\n", + "state 1: 10.9688, 0.000630482 (0.999943, 5.74764e-05)\n", + "state 2: 6.83847, 3.43205e-06 (0.999999, 5.01874e-07)\n", + "state 3: 19.0312, 0.000238602 (0.999987, 1.25372e-05)\n", + "state 4: 27, 3.04015e-08 (1, 1.12598e-09)\n", + "state 5: 0.0169734, 29.983 (0.000565779, 0.999434)\n", + "\n", + "log-likelihood for the state sequences: -4096.51 | -4096.51\n", + "\n", + "posterior state sequence probability\n", + "sequence 1: 0.671747\n", + "sequence 2: 0.692078\n", + "sequence 3: 0.305837\n", + "sequence 4: 0.288759\n", + "sequence 5: 0.381571\n", + "sequence 6: 0.206868\n", + "sequence 7: 0.801106\n", + "sequence 8: 0.582908\n", + "sequence 9: 0.392381\n", + "sequence 10: 0.275188\n", + "sequence 11: 0.544491\n", + "sequence 12: 0.415674\n", + "sequence 13: 0.410463\n", + "sequence 14: 0.500025\n", + "sequence 15: 0.446837\n", + "sequence 16: 0.356642\n", + "sequence 17: 0.4143\n", + "sequence 18: 0.242719\n", + "sequence 19: 0.445865\n", + "sequence 20: 0.340964\n", + "sequence 21: 0.311311\n", + "sequence 22: 0.784175\n", + "sequence 23: 0.271096\n", + "sequence 24: 0.167438\n", + "sequence 25: 0.578816\n", + "sequence 26: 0.253719\n", + "sequence 27: 0.312497\n", + "sequence 28: 0.503668\n", + "sequence 29: 0.211141\n", + "sequence 30: 0.278954\n" + ] + } + ], + "source": [ + "hsmc_est = Estimate(obs, \"HIDDEN_SEMI-MARKOV\", hsmc_est, Nbiteration=300) \n", + "print(hsmc_est.display())" + ] + }, + { + "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.plot(\"Observation\", 1)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "hsmc_est.plot(\"Sojourn\", 0)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# State restoration: Viterbi algorithm" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "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": 39, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(0.9590163934426229, 0.9846153846153847, 0.9846153846153847)\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] == 0])\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] == 1])\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..a74550b --- /dev/null +++ b/doc/examples/sequences.ipynb @@ -0,0 +1,683 @@ +{ + "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": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "number of sequences : 15\n", + "1 1 VARIABLE\n", + "2 \n", + "3 VARIABLE 1 : INT # 5 values\n", + "4 \n", + "5 # value histogram - size of the sample: 1343\n", + "6 # mean: 1.30231 variance: 2.66115 standard deviation: 1.6313\n", + "7 \n", + "8 # | value histogram\n", + "9 # 0 716 latent bud\n", + "10 # 1 153 short shoot\n", + "11 # 2 106 long shoot\n", + "12 # 3 88 fruiting shoot\n", + "13 # 4 280 immediate shoot\n", + "14 \n", + "15 # sequence length histogram - size of the sample: 15\n", + "16 # mean: 89.5333 variance: 19.4095 standard deviation: 4.40562\n", + "17 \n", + "18 # cumulative length: 1343\n", + "19 \n", + "20 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 4 4 4 4 1 \\\n", + "21 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 0 0 0 1 0 0 0 0 0 0 \\\n", + "22 0 0 0 1 0 0 0 0 0\n", + "23 \n", + "24 1 1 1 0 1 3 0 1 1 3 3 3 3 3 3 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 3 0 0 0 0 0 0 0 0 0 0 \\\n", + "25 0 0 0 0 0 0 0 0 0 0 0 0 2 1 2 1 2 2 0 2 1 0 2 1 1 1 1 1 0 1 0 2 0 1 2 0 0 0 0 0 0 \\\n", + "26 0 0\n", + "27 \n", + "28 0 0 0 0 0 0 0 0 0 1 0 1 2 0 2 2 0 1 1 0 0 0 0 0 0 0 0 0 3 3 0 0 4 4 4 4 4 4 4 0 0 \\\n", + "29 0 4 4 0 0 0 0 4 0 0 0 0 0 0 0 0 0 0 0 0 2 1 0 0 0 0 0 1 0 0 2 0 0 0 1 0 0 2 0 0 0 \\\n", + "30 0 0 0 0 0 0 0 0 0 0\n", + "31 \n", + "32 0 1 2 0 2 1 0 2 0 0 0 3 3 3 3 3 3 3 3 3 1 3 4 3 4 4 4 4 4 4 0 4 4 4 4 4 0 4 4 4 0 \\\n", + "33 4 4 4 4 4 0 0 0 0 0 4 0 0 0 0 0 0 0 0 0 2 0 2 0 2 0 0 2 2 0 0 2 2 0 2 0 0 0 0 0 2 \\\n", + "34 0 0 0 0 0 0 0 0 0 0\n", + "35 \n", + "36 2 2 2 3 3 3 3 3 0 1 0 0 1 1 3 3 0 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 3 4 0 0 4 4 2 0 0 \\\n", + "37 0 0 0 0 0 0 0 0 0 0 0 0 2 1 0 2 2 2 1 0 2 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0\n", + "38 \n", + "39 0 2 2 2 1 1 1 1 1 1 1 3 0 3 1 0 3 0 0 0 3 4 4 4 4 4 0 4 0 4 4 4 4 4 4 4 4 4 4 0 0 \\\n", + "40 4 4 4 4 0 4 4 4 4 4 0 4 0 0 4 0 0 0 0 0 0 2 0 0 0 0 0 0 0 2 2 0 2 0 2 2 0 0 0 0 0 \\\n", + "41 0 0 0 0 0 0 0 0 0 0 0\n", + "42 \n", + "43 0 0 0 0 0 0 0 0 0 0 0 0 2 2 0 0 1 3 1 3 0 3 3 1 3 3 3 3 3 0 3 1 3 0 0 0 0 0 0 0 0 \\\n", + "44 0 0 0 0 0 0 0 1 2 0 0 0 0 2 0 1 2 0 1 0 0 2 0 1 0 0 2 0 0 1 0 0 0 0 1 0 1 0 0 0 0 \\\n", + "45 0 0 0 0\n", + "46 \n", + "47 0 0 0 0 1 2 2 0 1 1 2 1 1 0 1 3 1 1 1 3 3 3 3 0 1 1 1 3 1 4 1 4 4 4 4 4 4 4 4 4 4 \\\n", + "48 4 4 4 4 4 4 4 4 0 0 0 0 0 0 0 0 0 0 0 0 4 0 0 4 0 0 4 0 4 0 0 2 0 0 0 0 0 0 0 0 2 \\\n", + "49 0 0 2 0 0 0 0 0 0 0 0 0 0 0\n", + "50 \n", + "51 2 2 2 2 0 1 1 1 1 1 1 1 1 1 3 3 1 3 3 3 1 1 3 3 4 4 4 4 4 4 4 4 4 4 4 4 3 0 4 0 0 \\\n", + "52 0 0 4 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 2 0 0 2 0 0 0 0 0 0 0 0 \\\n", + "53 0 0 0 0 0 0 0 0\n", + "54 \n", + "55 4 4 0 2 2 1 2 0 1 3 0 1 3 0 3 0 3 0 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 0 4 0 4 0 0 \\\n", + "56 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 2 0 0 0 0 0 0 0 0 2 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 \\\n", + "57 0\n", + "58 \n", + "59 0 0 0 0 0 1 0 1 1 0 1 1 1 1 1 1 1 1 1 3 0 3 0 3 4 4 4 4 4 1 4 4 4 4 4 4 1 4 4 4 0 \\\n", + "60 0 4 3 4 0 3 4 4 4 4 1 1 0 0 0 2 0 4 1 4 4 1 0 1 0 0 0 0 0 0 2 2 2 2 2 0 0 0 0 2 0 \\\n", + "61 0 0 0 0 0 0 0 0 0\n", + "62 \n", + "63 2 2 2 2 2 1 1 1 1 1 1 1 2 3 2 3 1 1 3 2 4 4 1 1 3 3 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 \\\n", + "64 4 0 4 0 4 0 0 0 0 0 0 0 0 0 0 0 0 0 0 4 0 4 4 0 2 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 \\\n", + "65 0 0 0 0 0 0 0\n", + "66 \n", + "67 0 0 0 1 1 2 1 1 1 1 1 3 0 2 1 0 3 3 1 3 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 3 \\\n", + "68 0 1 3 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 2 0 0 0 0 2 0 0 0 0 0 0 0 0 0 0 0 0 \\\n", + "69 0 0 0 0 0 0 0\n", + "70 \n", + "71 0 0 0 0 0 0 0 1 1 1 1 1 1 2 0 1 3 1 1 3 0 3 1 1 1 4 3 4 4 4 4 4 4 4 4 4 4 4 4 4 4 \\\n", + "72 4 0 0 3 4 4 4 4 4 4 4 4 4 0 0 0 0 0 0 4 4 0 0 4 2 2 2 2 0 0 0 0 2 0 0 2 0 2 0 0 0 \\\n", + "73 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0\n", + "74 \n", + "75 0 0 0 0 1 0 2 1 1 1 0 2 0 0 1 0 1 0 2 3 1 0 3 0 3 4 4 0 4 4 4 4 4 4 4 4 4 0 4 4 0 \\\n", + "76 4 0 0 0 0 4 4 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 \\\n", + "77 0 0 0 0 0 0\n", + "0 91 | 1 84 | 2 92 | 3 92 | 4 82 | 5 93 | 6 86 | 7 96 | 8 90 | 9 83 | 10 91 | 11 89 | 12 89 | 13 97 | 14 88 | \n" + ] + } + ], + "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": [ + "# TODO: elaborate on MarkovianSequences" + ] + }, + { + "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": [ + "### Types of variables" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# TODO: index variables from 1" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "seq.get_type(0)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Identifiers of sequences (indices)" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "seq.get_identifiers()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Length of a given sequence" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "88" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "seq.get_length(15)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Plot marginal histogram of variable 1" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "Plot(seq.get_marginal_histogram(1))" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "5.3801842024676e-310" + ] + }, + "execution_count": 16, + "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": "markdown", + "metadata": {}, + "source": [ + "### Select / reject / merge individuals" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [], + "source": [ + "# Select sequence (individual) 1\n", + "seq0 = seq.select_individual([1], True)" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "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": "markdown", + "metadata": {}, + "source": [ + "### Select / reject / merge variables" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Duplicate sequence and shift by -1" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [], + "source": [ + "seq_s1 = _MarkovianSequences(seq)\n", + "seq_s1 = _MarkovianSequences(seq_s1.shift(1,-1))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Merge seq and seq_s1" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [], + "source": [ + "seq2 = seq.merge_variable([seq_s1],1)" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[2, 1], [2, 1], [2, 1], [2, 1], [1, 0], [1, 0], [1, 0], [0, -1], [0, -1], [0, -1], [1, 0], [1, 0], [1, 0], [3, 2], [3, 2], [1, 0], [1, 0], [0, -1], [1, 0], [1, 0], [1, 0], [0, -1], [1, 0], [4, 3], [4, 3], [4, 3], [4, 3], [4, 3], [4, 3], [4, 3], [4, 3], [4, 3], [4, 3], [4, 3], [4, 3], [4, 3], [4, 3], [4, 3], [4, 3], [4, 3], [1, 0], [0, -1], [0, -1], [0, -1], [4, 3], [4, 3], [4, 3], [4, 3], [0, -1], [0, -1], [0, -1], [0, -1], [0, -1], [0, -1], [0, -1], [0, -1], [0, -1], [0, -1], [0, -1], [0, -1], [2, 1], [0, -1], [0, -1], [0, -1], [0, -1], [0, -1], [0, -1], [0, -1], [2, 1], [0, -1], [2, 1], [0, -1], [0, -1], [0, -1], [0, -1], [1, 0], [0, -1], [0, -1], [0, -1], [0, -1], [0, -1], [0, -1], [0, -1], [0, -1], [0, -1], [1, 0], [0, -1], [0, -1], [0, -1], [0, -1], [0, -1]]\n" + ] + } + ], + "source": [ + "print(seq2[0])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Select 1st variable in seq2" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [], + "source": [ + "seq_v1 = seq2.select_variable([1], True)" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "1" + ] + }, + "execution_count": 23, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "seq_v1.nb_variable" + ] + }, + { + "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/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..131ff65 100644 --- a/src/cpp/sequence_analysis/hsmc_algorithms1.cpp +++ b/src/cpp/sequence_analysis/hsmc_algorithms1.cpp @@ -480,24 +480,19 @@ HiddenSemiMarkov* MarkovianSequences::hidden_semi_markov_estimation(StatError &e } for (i = 0;i < nb_variable;i++) { - if ((type[i] != INT_VALUE) && (type[i] != REAL_VALUE) && (type[i] != STATE)) { + if ((type[i] != INT_VALUE) && (type[i] != REAL_VALUE)) { status = false; ostringstream error_message , correction_message; error_message << STAT_label[STATL_VARIABLE] << " " << i + 1 << ": " << STAT_error[STATR_VARIABLE_TYPE]; correction_message << STAT_variable_word[INT_VALUE] << " or " << STAT_variable_word[REAL_VALUE]; + if (type[i] == STATE) { + correction_message << ";\n" << "Convert type " << STAT_variable_word[STATE] + << " to " << STAT_variable_word[INT_VALUE] << "."; + } error.correction_update((error_message.str()).c_str() , (correction_message.str()).c_str()); } -# ifdef DEBUG - if (type[i] == STATE) - cout << "Warning: " << STAT_label[STATL_VARIABLE] << " " << i + 1 << " has type " << STAT_variable_word[STATE]; -# endif -# ifdef MESSAGE - if (type[i] == STATE) - cout << "Warning: " << STAT_label[STATL_VARIABLE] << " " << i + 1 << " has type " << STAT_variable_word[STATE]; -# endif - } if (ihsmarkov.nb_output_process != nb_variable) { @@ -848,6 +843,8 @@ HiddenSemiMarkov* MarkovianSequences::hidden_semi_markov_estimation(StatError &e } # endif + // NB. This is the reason why a variable of type STATE + // would not be handled for (i = 0;i < nb_sequence;i++) { for (j = 0;j < nb_variable;j++) { switch (type[j]) { @@ -1544,6 +1541,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/cpp/sequence_analysis/sequences.h b/src/cpp/sequence_analysis/sequences.h index b7b1619..9a60a16 100644 --- a/src/cpp/sequence_analysis/sequences.h +++ b/src/cpp/sequence_analysis/sequences.h @@ -748,6 +748,9 @@ namespace sequence_analysis { RenewalData* extract_renewal_data(stat_tool::StatError &error , int variable , int begin_index_parameter , int end_index_parameter) const; + /// Convert variable from STATE to INT_VALUE + bool set_type_to_int(stat_tool::StatError &error , int variable); + /// Merge several sets of Sequences (arrays of Sequences) Sequences* merge(stat_tool::StatError &error , int nb_sample , const Sequences **iseq) const; /// Merge several sets of Sequences (std::vector) diff --git a/src/cpp/sequence_analysis/sequences2.cpp b/src/cpp/sequence_analysis/sequences2.cpp index 637258c..cf70c14 100644 --- a/src/cpp/sequence_analysis/sequences2.cpp +++ b/src/cpp/sequence_analysis/sequences2.cpp @@ -62,7 +62,39 @@ using namespace stat_tool; namespace sequence_analysis { +/*--------------------------------------------------------------*/ +/** + * \brief Convert variable from INT_VALUE to STATE + * + * \param[in] error reference on a StatError object, + * \param[in] variable variable whose type is to be converted + * (indexed from 1, should have type STATE) + * + * \return True iif the function applied successfully + */ +/*--------------------------------------------------------------*/ +bool Sequences::set_type_to_int(stat_tool::StatError &error , int variable) +{ + bool status = true; + + error.init(); + + if ((variable < 1) || (variable > nb_variable)) { + status = false; + error.update(STAT_error[STATR_VARIABLE_INDEX]); + } + if (status) { + variable--; + if (type[variable] != STATE) { + status = false; + error.update(STAT_error[STATR_VARIABLE_TYPE]); + } else { + type[variable] = INT_VALUE; + } + } + return status; +} /*--------------------------------------------------------------*/ /** 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/openalea/sequence_analysis/enums_seq.py b/src/openalea/sequence_analysis/enums_seq.py index 1f5cf50..aa214f7 100644 --- a/src/openalea/sequence_analysis/enums_seq.py +++ b/src/openalea/sequence_analysis/enums_seq.py @@ -26,7 +26,7 @@ #todo: get rid if type_dict, rename the enumerate properly -type_dict = enumerate_st.pearson_type +type_dict = enumerate_st.correlation_type diff --git a/src/openalea/sequence_analysis/estimate.py b/src/openalea/sequence_analysis/estimate.py index 00cf45b..e5cb219 100644 --- a/src/openalea/sequence_analysis/estimate.py +++ b/src/openalea/sequence_analysis/estimate.py @@ -370,9 +370,7 @@ def _estimate_hidden_semi_markov(obj, *args, **kargs): InitialOccupancyMean], [bool, bool, int, int, int, [int, float], bool, [float, int]]) - - print(Algorithm) - + if Algorithm != sub_markovian_algorithms["MCEM"]: options = ["Parameter", "MaxNbStateSequence", "MinNbStateSequence"] for option in options: diff --git a/src/openalea/sequence_analysis/sequences.py b/src/openalea/sequence_analysis/sequences.py index e540d9b..fc5bcfe 100644 --- a/src/openalea/sequence_analysis/sequences.py +++ b/src/openalea/sequence_analysis/sequences.py @@ -438,10 +438,16 @@ def Sequences(obj, **kargs): - - - - +# Add methods to _Sequences + +def _Sequences_get_marginal_histogram(self, variable): + """Get marginal histogram""" + try: + return self.__get_marginal_histogram(variable) + except: + return self.__get_marginal_frequency_distribution(variable) + +_Sequences.get_marginal_histogram = _Sequences_get_marginal_histogram def IndexParameterType(obj): """ 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/export_sequences.cpp b/src/wrapper/export_sequences.cpp index e573920..e40f62c 100644 --- a/src/wrapper/export_sequences.cpp +++ b/src/wrapper/export_sequences.cpp @@ -111,11 +111,14 @@ class SequencesWrap boost::python::list sequences = extract (input_sequences); - lengths = new int[nb_sequences]; - identifiers = new int[nb_identifiers]; - types = new variable_nature[nb_types]; - index_parameters = new int*[nb_sequences]; - + if (nb_sequences > 0) { + lengths = new int[nb_sequences]; + index_parameters = new int*[nb_sequences]; + } + if (nb_identifiers > 0) + identifiers = new int[nb_identifiers]; + if (nb_types > 0) + types = new variable_nature[nb_types]; //cout << "allocate memory and set values of index_parameters"<= seq.get_nb_sequence()) + if (index < 1 || index > seq.get_nb_sequence()) { PyErr_SetString(PyExc_IndexError, - "index must be positive and less than number of sequences"); + "index must be positive and not more than number of sequences"); boost::python::throw_error_already_set(); } - return seq.get_length(index); + return seq.get_length(index-1); } static double @@ -1547,15 +1556,55 @@ class SequencesWrap return ret; } + static DiscreteDistributionData* + get_marginal_frequency_distribution(Sequences &input, int variable) + { + FrequencyDistribution *ret = NULL; + DiscreteDistributionData *retddd = NULL; + StatError error; + + if ((variable > 0) && (variable <= input.get_nb_variable())) { + ret = input.get_marginal_distribution(variable-1); + if (ret == NULL) { + ostringstream error_message; + error_message << "; Histogram does not exist."; + error.update((error_message.str()).c_str()); + } + } else { + error.update(STAT_error[STATR_VARIABLE_INDEX]); + } + if (!ret) + sequence_analysis::wrap_util::throw_error(error); + else + retddd = new DiscreteDistributionData(*ret); + + return retddd; + } + static Histogram* get_marginal_histogram(Sequences &input, int variable) { - Histogram *ret; - ret = input.get_marginal_histogram(variable); + Histogram *ret = NULL; + StatError error; + + if ((variable > 0) && (variable <= input.get_nb_variable())) { + ret = input.get_marginal_histogram(variable-1); + if (ret == NULL) { + ostringstream error_message; + error_message << "; Histogram does not exist."; + error.update((error_message.str()).c_str()); + } + } else { + error.update(STAT_error[STATR_VARIABLE_INDEX]); + } + if (!ret) + sequence_analysis::wrap_util::throw_error(error); + else + ret = new Histogram(*ret); + return ret; } - }; // Boost declaration @@ -1647,6 +1696,7 @@ class_sequences() DEF_RETURN_VALUE_NO_ARGS("cross", SequencesWrap::cross, "Cross") DEF_RETURN_VALUE_NO_ARGS("cumulate", SequencesWrap::cumulate,"Cumulate") DEF_RETURN_VALUE_NO_ARGS("merge", SequencesWrap::merge, "Merge sequences") + DEF_RETURN_VALUE_NO_ARGS("set_type_to_int", SequencesWrap::set_type_to_int, "Convert variable from STATE to INT_VALUE") DEF_RETURN_VALUE_NO_ARGS("merge_variable", SequencesWrap::merge_variable, "Merge variables") DEF_RETURN_VALUE_NO_ARGS("markovian_sequences", SequencesWrap::markovian_sequences , "returns markovian sequence") DEF_RETURN_VALUE_NO_ARGS("get_plotable", SequencesWrap::get_plotable, "Return a plotable") @@ -1658,7 +1708,8 @@ class_sequences() .def("segment_profile_write", SequencesWrap::segment_profile_write, args("sequences", "iidentifier","nb_segment", "model_type" , "output", "segmentation", "nb_segmentation"), "segment profile write for Display") .def("select_bin_width", SequencesWrap::select_bin_width, args("variable", "bin_width"), "select_bin_width on sequences") - DEF_RETURN_VALUE("get_marginal_histogram", SequencesWrap::get_marginal_histogram, args("variable"), "get_marginal_histogram wrapper") + DEF_RETURN_VALUE("__get_marginal_histogram", SequencesWrap::get_marginal_histogram, args("variable"), "get_marginal_histogram wrapper") + DEF_RETURN_VALUE("__get_marginal_frequency_distribution", SequencesWrap::get_marginal_frequency_distribution, args("variable"), "get_marginal_frequency_distribution wrapper") 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..2732ce9 100644 --- a/test/cpp/test_hidden_semi_markov_chain.cpp +++ b/test/cpp/test_hidden_semi_markov_chain.cpp @@ -22,6 +22,7 @@ int main(void) register int var, t, u, nb_integral, cptm= 0; // j, i, nb_states, bool status, geometric_poisson=false, common_dispersion=false, counting_flag=true, state_sequence=true; + stat_tool::rounding mode = ROUND; const int nb_sequence = 30 , length = 100; const stat_tool::process_type itype = stat_tool::ORDINARY; HiddenSemiMarkov *hsmc= NULL, *hsmc_ref= NULL, *hsmc_est_file= NULL; @@ -29,128 +30,28 @@ int main(void) stat_tool::censoring_estimator estimator=stat_tool::COMPLETE_LIKELIHOOD; // Hidden_variable_order_markov *hmc= NULL, *hmc_init= NULL; MultiPlotSet *plotable=NULL; - MarkovianSequences *seq_estim= NULL; - Sequences *seq_read= NULL; + MarkovianSequences *mseq= NULL; + Sequences *seq= NULL, *seq_cluster= NULL; StatError error; std::vector< int > select; - const char * hsmcrefpath= "../../../share/data/test_hidden_semi_markov_param.dat"; - const char * data_fail= "../../../test/lippia_fail.seq"; - const char * hsmcTC00LRpath = "../../../test/TC00LR_4S_init.hscm"; - const char * hsmcTC00Irpath = "../../../test/TC00Ir_4S_init.hscm"; - - /* - // reading and printing of a hidden Markov out tree - hsmc_ref = HiddenSemiMarkov::ascii_read(error, hsmcrefpath); - cout << error; - - if (hsmc_ref != NULL) - { - cout << "Reference hidden semi Markov model : " << endl; - hsmc_ref->ascii_write(cout, false); - cout << endl; - - set_seed(1); - - plotable = hsmc_ref->get_plotable(); - delete plotable; - // simulation of hidden Markov out trees - hsmd= hsmc_ref->simulation(error, nb_sequence, length); - cout << error; + const char * hsmcrefpath= "../../../share/data/pin_laricio_6.hsc"; + const char * datarefpath = "../../../share/data/pin_laricio_7x.seq"; - select.resize(1); - select[0] = 2; - // discard state variable - seq_estim = hsmd->select_variable(error, 1, select, true); - -# ifdef DEBUG - // printing of the simulated trees - cout << "Simulated sequences: " << endl; - hsmd->MarkovianSequences::ascii_data_write(cout); - cout << "End simulated sequences" << endl; -# endif + + seq = Sequences::ascii_read(error, datarefpath, false); + seq_cluster = seq->cluster(error, 1, 10, mode); - if (seq_estim != NULL) - hsmc_est_file = seq_estim->hidden_semi_markov_estimation(error, &cout, *hsmc_ref, geometric_poisson , common_dispersion, estimator, counting_flag, state_sequence, 300); - else { - cout << error; - return 1; - } - plotable = hsmc_est_file->get_plotable(); - delete plotable; - } - - if (hsmc_ref != NULL) - delete hsmc_ref; - hsmc_ref = NULL; - if (hsmd != NULL) - delete hsmd; - if (seq_estim != NULL) - delete seq_estim; - seq_estim = NULL; - hsmd = NULL; - if (hsmc_est_file != NULL) { - cout << "Estimated model:" << endl; - hsmc_est_file->ascii_write(cout); - delete hsmc_est_file; - } - hsmc_est_file = NULL; -*/ - // Test behaviour in case of convergence failure - 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); - if (hsmc != NULL) { - cout << "Estimated model:" << endl; - hsmc->ascii_write(cout); - delete hsmc; - hsmc = NULL; - } - - - // Variant: using LR initial model - hsmc_ref = HiddenSemiMarkov::ascii_read(error, hsmcTC00LRpath); - 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); - if (hsmc_est_file != NULL) { - cout << "Estimated model:" << endl; - hsmc_est_file->ascii_write(cout); - plotable = hsmc_est_file->get_plotable(); - delete plotable; - delete hsmc_est_file; - hsmc_est_file = NULL; - } - delete hsmc_ref; - hsmc_ref = NULL; - } -*/ - // Variant: using Irreducible initial model - 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); - if (hsmc_est_file != NULL) { - cout << "Estimated model:" << endl; - hsmc_est_file->ascii_write(cout); - plotable = hsmc_est_file->get_plotable(); - delete plotable; - hsmd = hsmc_est_file->extract_data(error); - cout << error; - assert(hsmd); - delete hsmd; - hsmd = NULL; - delete hsmc_est_file; - hsmc_est_file = NULL; - } - delete hsmc_ref; - hsmc_ref = NULL; - } + hsmc_ref = HiddenSemiMarkov::ascii_read(error, hsmcrefpath); + mseq = new MarkovianSequences(*seq_cluster); + hsmc_est_file = mseq->hidden_semi_markov_estimation(error, &cout, *hsmc_ref, geometric_poisson , common_dispersion, estimator, counting_flag, state_sequence); + + hsmc_est_file->ascii_write(cout); - delete seq_estim; - delete seq_read; + delete seq; + delete seq_cluster; + delete hsmc_est_file; + delete hsmc_ref; + delete mseq; return 0; } 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 63% rename from test/test_build_auxialiary_variable.py rename to test/test_build_auxiliary_variable.py index e6cd66a..6cfce52 100644 --- a/test/test_build_auxialiary_variable.py +++ b/test/test_build_auxiliary_variable.py @@ -1,5 +1,25 @@ -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 + +import os + +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..a7a243e 100644 --- a/test/test_data_transform.py +++ b/test/test_data_transform.py @@ -25,13 +25,40 @@ Vectors, ) +from openalea.sequence_analysis.data_transform import ( + Cumulate, + Difference +) + +from openalea.stat_tool.data_transform import * +from openalea.stat_tool.cluster import Cluster +from openalea.stat_tool.cluster import Transcode, Cluster + 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 +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 + + @pytest.fixture def create_data_sequence(): return Sequences(str(get_shared_data("sequences1.seq"))) @@ -41,6 +68,25 @@ def create_data_sequence(): def create_data_sequence2(): return Sequences(str(get_shared_data("sequences2.seq"))) +@pytest.fixture +def build_seqn(): + return Sequences([[[1, 1, 1], [12, 12, 12]], [[2, 2, 2], [22, 23, 24]]]) + + +@pytest.fixture +def build_seq1(): + return Sequences([[1, 1, 1], [2, 2, 2]]) + + +@pytest.fixture +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]], + ] + ) + class TestRemoveRun: """ @@ -122,6 +168,233 @@ def test_merge(): assert histo12 +def test_value_select(build_seqn): + "test_value_select implemented but need to be checked" + seqn = build_seqn + a = seqn.value_select(1, 1, 2, True) + assert a + assert str(ValueSelect(seqn, 1, 1, 2)) == str(seqn.value_select(1, 1, 2, True)) + + +def test_select_variable_int(build_seqn): + "test_select_variable_int implemented but need to be checked (index issue)" + # !!!!!!!! NEED to CHECK THE INDEX 0, 1 , ... or 1,2,.... + # what about identifiers ? + # Variable seems to start at 1 not 0 + s = build_seqn + # select variable 1 + select = s.select_variable([1], keep=True) + assert select[0, 0] == [1] + assert select[1, 0] == [2] + + +def test_select_variable_real(build_seq_realn): + "test_select_variable_real implemented but need to be checked (index issue)" + # !!!!!!!! NEED to CHECK THE INDEX 0, 1 , ... or 1,2,.... + # what about identifiers ? + # Variable seems to start at 1 not 0 + s = build_seq_realn + # select variable 1 + select = s.select_variable([1], keep=True) + assert select[0, 0] == [1.5] + assert select[1, 0] == [2.5] + + +def test_select_individual(build_seqn): + # select one or several sequences + s = build_seqn + + # select all + select = s.select_individual([0, 1], keep=True) + assert s.display() == select.markovian_sequences().display() + + # select first sequence only + select = s.select_individual([0], keep=True) + assert select[0, 0] == [1, 1, 1] + assert select[0, 1] == [12, 12, 12] + try: + select[1, 0] + assert False + except: + assert True + + # select second sequence only + select = s.select_individual([1], keep=True) + assert select[0, 0] == [2, 2, 2] + assert select[0, 1] == [22, 23, 24] + try: + select[1, 0] + assert False + except: + assert True + + +def test_shift_seqn(build_seqn): + s = build_seqn + shifted = s.shift(1, 2) + assert shifted[0, 0] == [3, 1, 1] + assert shifted[0, 1] == [14, 12, 12] + assert shifted[1, 0] == [4, 2, 2] + assert shifted[1, 1] == [24, 23, 24] + shifted1 = s.shift(1, 1) + assert shifted1[0, 0] == [2, 1, 1] + assert shifted1[0, 1] == [13, 12, 12] + assert shifted1[1, 0] == [3, 2, 2] + assert shifted1[1, 1] == [23, 23, 24] + + +def test_shift_seq1(build_seq1): + s = build_seq1 + shifted = s.shift(1, 2) + assert shifted[0, 0] == [3, 1, 1] + assert shifted[0, 1] == [4, 2, 2] + + +def test_threshold_seq1(build_seqn): + s = build_seqn + thresholded = s.thresholding(1, 10, "ABOVE") + for x in thresholded: + for v in x: + assert v[0] <= 10 + + +def test_threshold_seq(): + s = Sequences( + [ + [[1.01, 1.07], [2.01, 2.07], [1.99, 1.07], [2.41, 2.07]], + [[1.97, 1.07], [1.98, 2.07], [1.99, 1.07], [2.00, 2.07]], + ] + ) + thresholded = s.thresholding(1, 1.99, "ABOVE") + for x in thresholded: + for v in x: + assert v[0] <= 1.99 + thresholded = s.thresholding(1, 1.99, "BELOW") + for x in thresholded: + for v in x: + assert v[0] >= 1.99 + + assert s + + +def test_merge(build_seqn, build_seq1): + s1 = build_seqn + s2 = build_seqn + s3 = build_seq1 + + sall = s1.merge([s2]) + assert sall.nb_sequence == 4 + assert sall.nb_variable == 3 + + sall = s1.merge([s3]) + assert sall.nb_sequence == 3 + assert sall.nb_variable == 3 + + +def test_merge_and_Merge(build_seqn): + s1 = build_seqn + s2 = build_seqn + + a = s1.merge([s2]) + b = s2.merge([s1]) + v = Merge(s1, s2) + + assert str(a) == str(b) + assert str(a) == str(v) + + +def test_imcompatible_merge(build_seqn, build_seq1): + s1 = build_seqn + s3 = build_seq1 + try: + s1.merge(s3) + assert False + except: + assert True + + +def test_merge_variable(build_seqn, build_seq1): + s1 = build_seqn + s2 = build_seqn + s3 = build_seq1 + + sall = s1.merge_variable([s2], 1) # why 1 ? same result with 2 ! + assert sall.nb_sequence == 2 + assert sall.nb_variable == 6 + + # sall = s1.merge_variable([s3],1) + # assert sall.nb_sequence == 2 + # assert sall.nb_variable == 3 + + +def test_merge_variable_and_MergeVariable(build_seqn, build_seq1): + s1 = build_seqn + s2 = build_seqn + s3 = build_seq1 + + a = s1.merge_variable([s2], 1) + b = s2.merge_variable([s1], 1) + v = MergeVariable(s1, s2) + + assert str(a) == str(b) + assert str(a) == str(v) + + +def test_cluster_step(): + seq1 = Sequences([[1, 2, 3], [1, 3, 1], [4, 5, 6]]) + assert str(Cluster(seq1, "Step", 1, 2)) == str(seq1.cluster_step(1, 2, True)) + seqn = Sequences([[[1, 2, 3], [1, 3, 1]], [[4, 5, 6], [7, 8, 9]]]) + assert str(Cluster(seqn, "Step", 1, 2)) == str(seqn.cluster_step(1, 2, True)) + + +def test_cluster_limit(): + seq1 = Sequences([[1, 2, 3], [1, 3, 1], [4, 5, 6]]) + assert str(Cluster(seq1, "Limit", 1, [2])) == str(seq1.cluster_limit(1, [2], True)) + seqn = Sequences([[[1, 2, 3], [1, 3, 1]], [[4, 5, 6], [7, 8, 9]]]) + assert str(Cluster(seqn, "Limit", 1, [2, 4, 6])) == str( + seqn.cluster_limit(1, [2, 4, 6], True) + ) + + +def test_transcode(build_seqn): + """This functionality need to be checked. + + See also the vector case!""" + seq = build_seqn + assert str( + seq.transcode( + 1, + [0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0o1, 1, 1, 1, 1, 0, 0], + False, + ) + ) == str( + Transcode( + seq, + 1, + [0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0o1, 1, 1, 1, 1, 0, 0], + ) + ) + + +def test_reverse(build_seqn): + """reverse to be checked. seems to give same output as input""" + s = build_seqn + s.reverse() + + +def test_difference(build_data): + data = build_data + assert str(Difference(data, 1)) == str(data.difference(1, False)) + res = Difference(data, 1) + assert res.cumul_length == 50 + + +def test_cumulate(build_data): + # see also test_cumulate for more tests + s = build_data + res = Cumulate(s) + assert res.cumul_length == 52 + # def test_select_step(): # """ # ######################################################################### @@ -157,3 +430,26 @@ def test_merge(): # SelectStep(vec1, 1000) # Plot(vec1) + + + +if __name__ == "__main__": + + def build_seqn(): + return Sequences([[[1, 1, 1], [12, 12, 12]], [[2, 2, 2], [22, 23, 24]]]) + + + def test_shift_seqn(build_seqn): + s = build_seqn + shifted = s.shift(1, 2) + assert shifted[0, 0] == [3, 1, 1] + assert shifted[0, 1] == [14, 12, 12] + assert shifted[1, 0] == [4, 2, 2] + assert shifted[1, 1] == [24, 23, 24] + shifted1 = s.shift(1, 1) + assert shifted1[0, 0] == [2, 1, 1] + assert shifted1[0, 1] == [13, 12, 12] + assert shifted1[1, 0] == [3, 2, 2] + assert shifted1[1, 1] == [23, 23, 24] + + test_shift_seqn(build_seqn()) \ No newline at end of file diff --git a/test/test_estimate.py b/test/test_estimate.py index 1833154..c3fde11 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 ( @@ -29,6 +29,7 @@ Estimate, _SemiMarkovData, HiddenVariableOrderMarkov, + HiddenSemiMarkov ) _seq1 = Sequences(get_shared_data("dupreziana_20a2.seq")) @@ -183,7 +184,6 @@ def Test_Estimate_VARIABLE_ORDER_MARKOV_from_markovian(): def create_sequence_estimate_variable_order_markov(): return Sequences(get_shared_data("sequences1.seq")) - @pytest.fixture def create_hvom_estimate_hidden_variable_order_markov(): return HiddenVariableOrderMarkov(get_shared_data("dupreziana21.hc")) @@ -206,17 +206,27 @@ def test_estimate_hidden_variable_order_markov( @pytest.fixture def create_data_estimate_hidden_semi_markov(): - return _SemiMarkovData() + return HiddenSemiMarkov(get_shared_data("wij1.hsc")) @pytest.fixture def create_sequence_estimate_hidden_semi_markov(): return Sequences(get_shared_data("wij1.seq")) +@pytest.fixture +def create_sequence_simulate_hidden_semi_markov(): + hsm = HiddenSemiMarkov(get_shared_data('test_hidden_semi_markov.dat')) + set_seed(0) + nb_seq = 30 + seq_length = 100 + seq = hsm.simulation_nb_sequences(nb_seq, seq_length, True) + return seq + def test_estimate_hidden_semi_markov( create_data_estimate_hidden_semi_markov, create_sequence_estimate_hidden_semi_markov ): + """Estimate hidden semi-Markov model from initial number of states""" set_seed(0) # data is a hsm class Estimate( @@ -226,6 +236,55 @@ def test_estimate_hidden_semi_markov( "Ordinary", 3, "LeftRight", NbIteration=300 ) +def test_estimate_init_model_hidden_semi_markov( + create_data_estimate_hidden_semi_markov, create_sequence_estimate_hidden_semi_markov +): + """Estimate hidden semi-Markov model from initial model read from file""" + set_seed(0) + # data is a hsm class + Estimate( + create_sequence_estimate_hidden_semi_markov, + "HIDDEN_SEMI-MARKOV", + create_data_estimate_hidden_semi_markov, + NbIteration=300 + ) + +def test_estimate_hidden_semi_markov_wrong_nb_variable( + create_data_estimate_hidden_semi_markov, create_sequence_simulate_hidden_semi_markov +): + """Estimate HiddenSemiMarkov with initial model and wrong number of variables""" + set_seed(0) + # data is a hsm class + create_sequence_simulate_hidden_semi_markov.set_type_to_int(1); + assert(create_sequence_simulate_hidden_semi_markov.get_type(1) == 0) + try: + Estimate( + create_sequence_simulate_hidden_semi_markov, + "HIDDEN_SEMI-MARKOV", + create_data_estimate_hidden_semi_markov, + NbIteration=300 + ) + except: + assert True + else: + assert False + +def test_estimate_hidden_semi_markov_wrong_type( + create_sequence_simulate_hidden_semi_markov +): + """Estimate HiddenSemiMarkov with initial model and wrong variable type""" + set_seed(0) + # data is a hsm class + try: + Estimate( + create_sequence_simulate_hidden_semi_markov, + "HIDDEN_SEMI-MARKOV", + "Ordinary", 3, "LeftRight", NbIteration=300 + ) + except: + assert True + else: + assert False """ def test_estimate_semi_markov(): set_seed(0) @@ -246,7 +305,7 @@ def create_data_estimate_histogram(): return Vectors(seq0) def create_data_estimate_hidden_semi_markov(): - return _SemiMarkovData() + return HiddenSemiMarkov(get_shared_data("wij1.hsc")) def create_sequence_estimate_variable_order_markov(): return Sequences(get_shared_data("sequences1.seq")) @@ -254,12 +313,16 @@ def create_sequence_estimate_variable_order_markov(): def create_hvom_estimate_hidden_variable_order_markov(): return HiddenVariableOrderMarkov(get_shared_data("dupreziana21.hc")) - def create_sequence_estimate_hidden_semi_markov(): return Sequences(get_shared_data("wij1.seq")) - def create_sequence_estimate_hidden_semi_markov(): - return Sequences(get_shared_data("wij1.seq")) + def create_sequence_simulate_hidden_semi_markov(): + hsm = HiddenSemiMarkov(get_shared_data('test_hidden_semi_markov.dat')) + set_seed(0) + nb_seq = 30 + seq_length = 100 + seq = hsm.simulation_nb_sequences(nb_seq, seq_length, True) + return seq def test_estimate_mixture(): set_seed(0) @@ -282,7 +345,41 @@ def test_estimate_hidden_semi_markov(): "HIDDEN_SEMI-MARKOV", create_data_estimate_hidden_semi_markov(), ) + # hsmc_est = Estimate(obs, "HIDDEN_SEMI-MARKOV", hsm, Nbiteration=300) + + def test_estimate_hidden_semi_markov_wrong_type(): + """Estimate HiddenSemiMarkov with initial model and wrong variable type""" + set_seed(0) + # data is a hsm class + try: + Estimate( + create_sequence_simulate_hidden_semi_markov(), + "HIDDEN_SEMI-MARKOV", + "Ordinary", 3, "LeftRight", NbIteration=300 + ) + except: + assert True + else: + assert False + def test_estimate_hidden_semi_markov_wrong_nb_variable(): + """Estimate HiddenSemiMarkov with initial model and wrong number of variables""" + set_seed(0) + # data is a hsm class + seq = create_sequence_simulate_hidden_semi_markov() + seq.set_type_to_int(1); + assert(seq.get_type(1) == 0) + try: + Estimate( + seq, + "HIDDEN_SEMI-MARKOV", + create_data_estimate_hidden_semi_markov(), + NbIteration=300 + ) + except: + assert True + else: + assert False def test_estimate_mixture2(): set_seed(0) mixt20 = Estimate( @@ -309,7 +406,7 @@ def test_estimate_mixture2(): test_estimate_error1()""" # Test_Estimate_VARIABLE_ORDER_MARKOV_from_markovian() test_estimate_hidden_semi_markov() - + test_estimate_hidden_semi_markov_wrong_nb_variable() """ test_estimate_hidden_semi_markov() test_estimate_semi_markov() 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..6a12abf 100644 --- a/test/test_hidden_semi_markov.py +++ b/test/test_hidden_semi_markov.py @@ -9,23 +9,23 @@ #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 from openalea.stat_tool.data_transform import * -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 import Display, Save 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 @@ -46,7 +46,14 @@ def HSMData(): hsm = HiddenSemiMarkov(get_shared_data('test_hidden_semi_markov.dat')) return HSM(data, hsm) -class TestHiddenSemiMarkov(interface): +def _remove_file(filename): + """alias to remove a file""" + try: + os.remove(filename) + except: + pass + +class TestHiddenSemiMarkov(): """ Test HiddenSemiMarkov class """ @@ -59,6 +66,143 @@ def init(self, HSMData): self.hsm = hsm self.structure = HiddenSemiMarkov + + + def constructor_from_file(self): + """Test constructor from file""" + if self.filename == None: + return None + else: + c = self.structure(self.filename) + assert c + return c + + def constructor_from_file_failure(self): + """run constructor with filename argument""" + try: + _h = self.structure("whatever_wrong_filename.txt") + assert False + except Exception: + assert True + + def print_data(self): + """test that print command exists""" + print(self.data) + + def display(self): + """check that .display/Display is callable""" + data = self.data + data.display() + Display(data) + assert data.display() == Display(data) + + def display_versus_ascii_write(self): + """check that display is equivalent to ascii_write""" + assert Display(self.data) == self.data.ascii_write(False) + + def display_versus_str(self): + """check that display and str are equivalent""" + data = self.data + s = str(data) + assert Display(data) == s + + def plot(self): + """run plotting routines""" + # if DISABLE_PLOT == False: + self.data.plot() + + def save(self, Format=None, skip_reading=False): + """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 + # _remove_file('test1.dat') + # _remove_file('test2.dat') + + if Format is None: + c1.save("test1.dat") + Save(c1, "test2.dat") + else: + c1.save("test1.dat", Format="Data") + Save(c1, "test2.dat", Format="Data") + + if skip_reading: + pass + else: + c1_read = self.structure("test1.dat") + c2_read = self.structure("test2.dat") + + assert c1 and c1_read and c2_read + assert str(c1_read) == str(c2_read) + + _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) + _remove_file("test.dat") + + def file_ascii_data_write(self): + h = self.data + h.file_ascii_data_write("test.dat", True) + _remove_file("test.dat") + + def spreadsheet_write(self): + h = self.data + h.spreadsheet_write("test.dat") + _remove_file("test.dat") + + def survival_ascii_write(self): + d = self.data + d.survival_ascii_write() + + def survival_plot_write(self): + d = self.data + d.survival_plot_write("test", "test") + + def survival_file_ascii_write(self): + d = self.data + d.survival_file_ascii_write() + + def survival_spreadsheet_write(self): + d = self.data + d.survival_spreadsheet_write("test.xsl") + _remove_file("test.xsl") + + def simulate(self, N=-1): + """Test the simulate method""" + set_seed(0) + if N == -1: + N = self.N + m = self.data + s = m.simulate(N) + s2 = Simulate(m, N) + assert len(s) == N + assert len(s2) == N + assert str(s2) + assert str(s) + return s + + def test_len(self): + raise NotImplementedError() + + def test_extract(self): + raise NotImplementedError() + + def test_extract_data(self): + raise NotImplementedError() + def test_constructor_from_file2(self): # self.init() hmc = HiddenSemiMarkov(get_shared_data("test_hidden_markov.hmc")) @@ -112,49 +256,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 +367,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..c048446 100644 --- a/test/test_hidden_semi_markov_functional.py +++ b/test/test_hidden_semi_markov_functional.py @@ -1,5 +1,5 @@ # -*- coding: utf-8 -*- -"""tests on mv_mixture""" +"""tests on hidden semi-Markov models""" __version__ = "$Id$" # from openalea.stat_tool import _stat_tool @@ -12,15 +12,13 @@ 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 @@ -32,10 +30,11 @@ from openalea.stat_tool.distribution import set_seed def test1(): - """Estimate HSMC with nonparametric emission distributions""" + """Estimate HSMC with nonparametric and parametric emission distributions, + 2 output processes.""" set_seed(0) - hsm = HiddenSemiMarkov(str(get_shared_data('test_hidden_semi_markov.dat'))) + hsm = HiddenSemiMarkov(get_shared_data('test_hidden_semi_markov.dat')) hsm.plot("Intensity", 1) hsm.plot("Observation", 1) @@ -63,8 +62,8 @@ def test1(): seq = hsm.simulation_nb_sequences(nb_seq, seq_length, True) assert(len(seq) == nb_seq) assert(len(seq[0]) == seq_length) - # NB: hsm has 1 output process but simulation includes the hidden state - assert(len(seq[0][1]) == 2) + # NB: hsm has 2 output processes but simulation includes the hidden state + assert(len(seq[0][1]) == 3) print(seq[0]) obs = seq.select_variable([1], keep=False) @@ -77,8 +76,6 @@ def test1(): hsmc_est = Estimate(obs, "HIDDEN_SEMI-MARKOV", "Ordinary", nb_states, "LeftRight", NbIteration=300) print(hsmc_est.display()) - # TODO: find adequate error message in - # hsmc_est = Estimate(seq, "HIDDEN_SEMI-MARKOV", "Ordinary", nb_states, "LeftRight", NbIteration=300) plotter = mplotlib() hsmc_est.plot("Intensity", 1) 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..916cc15 100644 --- a/test/test_sequences.py +++ b/test/test_sequences.py @@ -6,30 +6,27 @@ __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 from openalea.sequence_analysis import _sequence_analysis from openalea.sequence_analysis.sequences import Sequences, Split, SaveMTG from openalea.sequence_analysis.data_transform import ( - Cumulate, - Difference, ExtractVectors, IndexParameterExtract, IndexParameterSelect, RecurrenceTimeSequences, ) -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(): @@ -126,6 +123,29 @@ def test_extract(build_seqn): assert seqn.extract_value(2) +def test_get_marginal_histogram(build_seqn): + """Extract marginal histograms""" + seqn = build_seqn + for i in range(1,seqn.nb_variable+1): + assert seqn.get_marginal_histogram(i) + +def test_get_marginal_histogram_wrong_variable(build_seqn): + """Extract histogram with bad variable indices""" + seqn = build_seqn + try: + seqn.get_marginal_histogram(-1) + except: + assert True + else: + assert False + + try: + seqn.get_marginal_histogram(4) + except: + assert True + else: + assert False + def test_index_parameter_type(): seq1 = Sequences([[1.0, 1, 1], [2.0, 2, 2.0]]) assert IndexParameterType(seq1) == "IMPLICIT_TYPE" @@ -228,215 +248,6 @@ def test_container(build_seq1, build_seqn): assert len(s) == 1 -def test_value_select(build_seqn): - "test_value_select implemented but need to be checked" - seqn = build_seqn - a = seqn.value_select(1, 1, 2, True) - assert a - assert str(ValueSelect(seqn, 1, 1, 2)) == str(seqn.value_select(1, 1, 2, True)) - - -def test_select_variable_int(build_seqn): - "test_select_variable_int implemented but need to be checked (index issue)" - # !!!!!!!! NEED to CHECK THE INDEX 0, 1 , ... or 1,2,.... - # what about identifiers ? - # Variable seems to start at 1 not 0 - s = build_seqn - # select variable 1 - select = s.select_variable([1], keep=True) - assert select[0, 0] == [1] - assert select[1, 0] == [2] - - -def test_select_variable_real(build_seq_realn): - "test_select_variable_real implemented but need to be checked (index issue)" - # !!!!!!!! NEED to CHECK THE INDEX 0, 1 , ... or 1,2,.... - # what about identifiers ? - # Variable seems to start at 1 not 0 - s = build_seq_realn - # select variable 1 - select = s.select_variable([1], keep=True) - assert select[0, 0] == [1.5] - assert select[1, 0] == [2.5] - - -def test_select_individual(build_seqn): - # select one or several sequences - s = build_seqn - - # select all - select = s.select_individual([0, 1], keep=True) - assert s.display() == select.markovian_sequences().display() - - # select first sequence only - select = s.select_individual([0], keep=True) - assert select[0, 0] == [1, 1, 1] - assert select[0, 1] == [12, 12, 12] - try: - select[1, 0] - assert False - except: - assert True - - # select second sequence only - select = s.select_individual([1], keep=True) - assert select[0, 0] == [2, 2, 2] - assert select[0, 1] == [22, 23, 24] - try: - select[1, 0] - assert False - except: - assert True - - -def test_shift_seqn(build_seqn): - s = build_seqn - shifted = s.shift(1, 2) - assert shifted[0, 0] == [3, 1, 1] - assert shifted[0, 1] == [14, 12, 12] - assert shifted[1, 0] == [4, 2, 2] - assert shifted[1, 1] == [24, 23, 24] - - -def test_shift_seq1(build_seq1): - s = build_seq1 - shifted = s.shift(1, 2) - assert shifted[0, 0] == [3, 1, 1] - assert shifted[0, 1] == [4, 2, 2] - - -def test_threshold_seq1(build_seqn): - s = build_seqn - thresholded = s.thresholding(1, 10, "ABOVE") - for x in thresholded: - for v in x: - assert v[0] <= 10 - - -def test_threshold_seq(): - s = Sequences( - [ - [[1.01, 1.07], [2.01, 2.07], [1.99, 1.07], [2.41, 2.07]], - [[1.97, 1.07], [1.98, 2.07], [1.99, 1.07], [2.00, 2.07]], - ] - ) - thresholded = s.thresholding(1, 1.99, "ABOVE") - for x in thresholded: - for v in x: - assert v[0] <= 1.99 - thresholded = s.thresholding(1, 1.99, "BELOW") - for x in thresholded: - for v in x: - assert v[0] >= 1.99 - - assert s - - -def test_merge(build_seqn, build_seq1): - s1 = build_seqn - s2 = build_seqn - s3 = build_seq1 - - sall = s1.merge([s2]) - assert sall.nb_sequence == 4 - assert sall.nb_variable == 3 - - sall = s1.merge([s3]) - assert sall.nb_sequence == 3 - assert sall.nb_variable == 3 - - -def test_merge_and_Merge(build_seqn): - s1 = build_seqn - s2 = build_seqn - - a = s1.merge([s2]) - b = s2.merge([s1]) - v = Merge(s1, s2) - - assert str(a) == str(b) - assert str(a) == str(v) - - -def test_imcompatible_merge(build_seqn, build_seq1): - s1 = build_seqn - s3 = build_seq1 - try: - s1.merge(s3) - assert False - except: - assert True - - -def test_merge_variable(build_seqn, build_seq1): - s1 = build_seqn - s2 = build_seqn - s3 = build_seq1 - - sall = s1.merge_variable([s2], 1) # why 1 ? same result with 2 ! - assert sall.nb_sequence == 2 - assert sall.nb_variable == 6 - - # sall = s1.merge_variable([s3],1) - # assert sall.nb_sequence == 2 - # assert sall.nb_variable == 3 - - -def test_merge_variable_and_MergeVariable(build_seqn, build_seq1): - s1 = build_seqn - s2 = build_seqn - s3 = build_seq1 - - a = s1.merge_variable([s2], 1) - b = s2.merge_variable([s1], 1) - v = MergeVariable(s1, s2) - - assert str(a) == str(b) - assert str(a) == str(v) - - -def test_cluster_step(): - seq1 = Sequences([[1, 2, 3], [1, 3, 1], [4, 5, 6]]) - assert str(Cluster(seq1, "Step", 1, 2)) == str(seq1.cluster_step(1, 2, True)) - seqn = Sequences([[[1, 2, 3], [1, 3, 1]], [[4, 5, 6], [7, 8, 9]]]) - assert str(Cluster(seqn, "Step", 1, 2)) == str(seqn.cluster_step(1, 2, True)) - - -def test_cluster_limit(): - seq1 = Sequences([[1, 2, 3], [1, 3, 1], [4, 5, 6]]) - assert str(Cluster(seq1, "Limit", 1, [2])) == str(seq1.cluster_limit(1, [2], True)) - seqn = Sequences([[[1, 2, 3], [1, 3, 1]], [[4, 5, 6], [7, 8, 9]]]) - assert str(Cluster(seqn, "Limit", 1, [2, 4, 6])) == str( - seqn.cluster_limit(1, [2, 4, 6], True) - ) - - -def test_transcode(build_seqn): - """This functionality need to be checked. - - See also the vector case!""" - seq = build_seqn - assert str( - seq.transcode( - 1, - [0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0o1, 1, 1, 1, 1, 0, 0], - False, - ) - ) == str( - Transcode( - seq, - 1, - [0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0o1, 1, 1, 1, 1, 0, 0], - ) - ) - - -def test_reverse(build_seqn): - """reverse to be checked. seems to give same output as input""" - s = build_seqn - s.reverse() - - def test_max_length(build_data): s = build_data assert s.max_length == 30 @@ -454,22 +265,14 @@ def test_get_min_value(build_data): def test_get_length(build_data): s = build_data - assert s.get_length(0) == 30 - assert s.get_length(1) == 22 + assert s.get_length(1) == 30 + assert s.get_length(2) == 22 -def test_difference(build_data): +def test_data_plot(build_data): + """Test plot data""" data = build_data - assert str(Difference(data, 1)) == str(data.difference(1, False)) - res = Difference(data, 1) - assert res.cumul_length == 50 - - -def test_cumulate(build_data): - # see also test_cumulate for more tests - s = build_data - res = Cumulate(s) - assert res.cumul_length == 52 + Plot(data, ViewPoint="Data") def test_extract_vectors(build_data): @@ -555,3 +358,73 @@ 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]], + ] + ) + + def build_seq_wrong_identifiers(): + try: + s = Sequences([[1, 1, 1], [2, 2, 2]], Identifiers=[-1, 1]) + assert False + except: + assert True + + + def test_len(build_data): + seq = build_data + assert len(seq) == 2 + assert len(seq) == seq.nb_sequence + + + def test_extract(build_seqn): + # todo + seqn = build_seqn + assert seqn.extract_value(1) + assert seqn.extract_value(2) + + + def test_get_marginal_histogram(build_seqn): + """Extract marginal histograms""" + seqn = build_seqn + for i in range(1,seqn.nb_variable+1): + assert seqn.get_marginal_histogram(i) + + test_len(build_data()) + test_recurrence_time_sequences(build_data()) + test_data_plot(build_data()) + test_get_marginal_histogram(build_seqn()) 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..3c2393a 100644 --- a/test/tools.py +++ b/test/tools.py @@ -1,28 +1,34 @@ -"""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 pathlib import Path from openalea.stat_tool import Simulate -from openalea.stat_tool.plot import DISABLE_PLOT from openalea.stat_tool.output import Display, Save +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 +37,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 +72,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 +103,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 +129,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 +156,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 +199,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 +226,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": "iVBORw0KGgoAAAANSUhEUgAAAzoAAANCCAYAAACuwLkYAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjgsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvwVt1zgAAAAlwSFlzAAAPYQAAD2EBqD+naQAAltBJREFUeJzt3Qd8FGX+x/FfSKWFTkIPiFQRBETKIcXesIOKJ5bT4/yrYC94UuwVPCtYT0/vEAXPdggqIIiCFEEBKVJCD6EkoYRAMv/X71lm2d3sZndTdyef9+s1zO7M7OzsLknmu7/neSbGsixLAAAAAMBBqlT0AQAAAABAaSPoAAAAAHAcgg4AAAAAxyHoAAAAAHAcgg4AAAAAxyHoAAAAAHAcgg4AAAAAxyHoAAAAAHAcgg4AAAAAxyHoAEAl8uqrr8q7775bLs918OBBGTNmjMyePbtcns+p5s2bJ3/5y1+kW7dukpiYKDExMbJx48aKPiwAiHgEHQCoRMo76IwdO5agU0LffvutfPPNN9K8eXPp3bt36Xw4AFAJEHQAAI6gwcqJ/v73v5sKzrRp0+SCCy6o6MMBgKhB0AGACG+2dMYZZ0jNmjWlWrVq5hv9L7/80msbbR6mzZl8aeXGs5lTWlqarFixQubMmWOW66TLlDYv0/v/+te/5K677pLU1FSpWrWq9OvXT5YuXeq13/79+5vJ1/XXX+/enz5ngwYNzG2t6tjPp9sEEs4x6H5q1Kghv/76q5x99tnm/dH3Se3Zs0duvfVWadKkiSQkJEirVq1k1KhRcvjwYa99FBQUyEsvvSRdunQxz1O7dm3p2bOnfPbZZ17bTZ48WXr16iXVq1c3z3nOOecUOp7169fLVVddJY0bNzbNy1JSUszx/PLLL+5tvvvuO/O+1atXzzyfVmguv/zyoAGtShX+VANAcfDbEwAilAaSgQMHSlZWlrz11lvy73//25zQX3TRRebkO1xaEdCT/lNOOUV+/PFHM+kyTw899JA5aX/zzTfNtG3bNnNyrsvC0ahRI5k+fbq5fdNNN7mfT6sTwYR6DHl5eTJo0CDzHv33v/81gSo3N1cGDBgg7733nglLGgqvvfZaeeaZZ+Syyy4rFJZGjBghp556qnk///Of/5j9efZ/eeKJJ+Tqq6+WDh06yEcffSTvv/++5OTkSN++fWXlypXu7c4//3xZvHixeZ6ZM2fKa6+9Zt7nffv2mfW6T63GaPB6++23zXvz1FNPmfCkrwMAUAYsAEBE6tmzp9WwYUMrJyfHvezo0aPWSSedZDVt2tQqKCgwy0aPHm35+3X+zjvvmOUbNmxwL+vYsaPVr1+/QtvOmjXLbNu1a1f3ftXGjRut+Ph46y9/+Yt7mT7e3z6GDRtmtWjRwn1/165dZp96fKEI5xj0uXTbt99+22sfr7/+uln+0UcfeS1/+umnzfIZM2aY+99//725P2rUqIDHk56ebsXFxVm3336713L9PFJTU63Bgweb+5mZmWZfEyZMCLivjz/+2Gzzyy+/WCXx7LPPFvpMAQD+UdEBgAh04MABWbBggVxxxRWmuZQtNjZW/vznP8uWLVtk9erVpf6811xzjVczuBYtWpjmcrNmzSr15yqNY9CmX560eZhWSfR982Q3mdOO/ep///ufmf/f//1fwOP4+uuv5ejRo3LdddeZuT0lJSWZ5nT2aHJ169aVE044QZ599ll54YUXTLM2bRbnSZvHaTXnlltukX/+859hV8gAAOEj6ABABNq7d6+WaEwTMF/aD0Tt3r271J9X+8X4W1YWz1XSY9A+S8nJyV7LdBvd1rfPUsOGDSUuLs69j127dpnQ6O+5bDt37jRzbdoWHx/vNWlTt8zMTLNen0sDlPbd0aZrXbt2Nf2T7rjjDtPMTWkQ0pHT9Dg0XOl9nV588cViv08AgKLFBVkPAKgAderUMZ3Qt2/fXmid9llR9evXN3OtMCjtbK8d4W32iXg4duzY4XeZdqC36fNpvyFfxXm+4h6D8jcAg26jlTANiZ7rMzIyTDXGfs80iOTn55v9+guTyt72448/NlWlouh67Uel1qxZY/rz6CAR2v/m9ddfN8u1X49O+ryLFi0yAyGMHDnSDFygAxkAAEoXFR0AiEDa/Oq0006TqVOnyqFDh9zLtUmUjkrWtGlTadOmjVlmj3S2fPlyr318/vnnhfarQchzf750wAMNCbZNmzbJ/PnzvUZZ0+fTk3nPUcy0UqLb+T6XKur5insMgehIZ/v375dPP/3Ua7kOTmCvV+edd56Z66ABgWiFRqtAf/zxh3Tv3t3v5I9+Lg8//LB06tRJlixZUmi9VpL0s33llVfMfX/bAABKjooOAESoJ598Us466ywzitg999xj+njoBT9/++03EwbsioWO+KX9RHR0s3HjxpmTcx1aevPmzYX2qSffOrqYNr3SEdi0OqPLPCsfl156qdx8882majN69GizzYMPPujeRvsITZw40YxmpttpyNEmW77NyHSEOK106IhoGjD0GLVKYgezQEI5hkC0P40GiGHDhpmRzvS16RDdOnqavk9nnnmm2U4rK/o6HnvsMdNE7cILLzTBTPvXaJO422+/3Rynvp86NLX2qTn33HNNpU23X7hwoQmjOtKbBszbbrtNrrzySjnxxBPN56R9hXT5Aw88YJ5Pqzq6TEde02GldXQ4HX1N2ccUiDaz0xH4lA6nbfcx0qqUTtpfCADgR4BBCgAAEWDu3LnWwIEDrerVq1tVq1Y1I7F9/vnnhbZbuHCh1bt3b7NdkyZNzEhnb775ZqERunQEs7PPPtuqWbOmWWePkmaPePb+++9bd9xxh9WgQQMrMTHR6tu3r7Vo0aJCz/fPf/7Tat++vZWUlGR16NDBmjx5cqFR19Q333xjnXLKKWZfun/dJpBwjkH3o6/Vn927d1vDhw+3GjVqZEZN02N68MEHrdzcXK/t8vPzrfHjx5tR7BISEqxatWpZvXr1KvT+fvrpp9aAAQOs5ORkczy6vyuuuMK8NrVz507r+uuvt9q1a2eOqUaNGtbJJ59s9q2j5Kkff/zRuvTSS81jdR/16tUzI9d99tlnAd8P3/fF3+Rv9DsAgEuM/uMvAAEAKg8dQUwrR1OmTCk0YlllOgYAgHPQRwcAAACA4xB0AAAAADgOTdcAAAAAOA4VHQAAAACOQ9ABAAAA4DgEHQAAAACOExUXDNUrgW/bts1cfM6+QB4AAACAyseyLMnJyZHGjRtLlSpVojvoaMhp1qxZRR8GAAAAgAixefNmadq0aXQHHa3k2C8mOTm5og8HAAAAQAXJzs42RRA7I0R10LGbq2nIIegAAAAAiAnSpYXBCAAAAAA4DkEHAAAAgOMQdAAAAAA4TlT00QEAAMDxy27k5eXxdsCx4uPjJTY2tsT7IegAAABECQ04GzZsMGEHcLLatWtLampqia6hSdABAACIkoskbt++3XzTrUPrFnWhRCCa/58fPHhQMjIyzP1GjRoVe18EHQAAgChw9OhRcwKoV4OvVq1aRR8OUGaqVq1q5hp2GjZsWOxmbHwVAAAAEAXy8/PNPCEhoaIPBShzdpg/cuRIsfdB0AEAAIgiJemzAFSm/+cEHQAAAACOQ9ABAABAuZo9e7b5xn7fvn1R9c7rMX/66aeltr+0tDSZMGFCqe0P3gg6AAAAlUh+Qb7M3jhb/v3rv81c75el/v37y8iRIyWajBkzRrp06VJouY56d95550k0effdd81QzRUdWH/99Vfp16+fGWigSZMmMm7cODPCWlli1DUAAIBKYuqqqTJi+gjZkr3FvaxpclN58dwX5bL2l4nTacd2vRhlcel1XRC+7OxsOeuss2TAgAHy888/y5o1a+T666+X6tWry9133y1lhYoOAABAJQk5V3x0hVfIUVuzt5rlur606cnsnDlz5MUXXzTf/Ou0ceNG9/rFixdL9+7dzQhbvXv3ltWrV3s9/vPPP5du3bpJUlKStGrVSsaOHWuG2balp6fLxRdfLDVq1JDk5GQZPHiw7Ny5s1Bl5u233zaPT0xMNFWErKwsueWWW8zQxfq4gQMHyrJly9wVEH0evW8fsy7z13Rty5YtctVVV0ndunXNSbu+lgULFph1f/zxhzm2lJQUc3ynnnqqfPPNN2G9f3phWK18NG3a1By7vpbp06cXWVH55Zdf3O/z7Nmz5YYbbjCv134t+p7YzeYeffRRueaaa8zx6bDlL730kns/+njdXvdn0+fRZbpfXa/BRdWpU8cs18/bnw8++EByc3PN+3jSSSfJZZddJg899JC88MILZVrVIegAAAA4nDZP00qOJYVPKu1lI6ePLPVmbBpwevXqJTfffLNp9qWTXuzUNmrUKHn++edl0aJFEhcXJzfeeKN73ddffy3XXnut3HHHHbJy5UqZOHGiOVF+/PHHXcdtWXLJJZfInj17TJiaOXOmCRdDhgzxOoZ169bJRx99JJ988on7pP2CCy6QHTt2yFdffWXCVteuXeWMM84w+9LHa5WhY8eO7mP23afav3+/aYq1bds2+eyzz0wwuu+++0w4sdeff/75JtwsXbpUzjnnHLnoootMOAvn/dP357nnnpPly5ebfQwaNEjWrl0b0uN79+5t+gBpmLNfyz333ONe/+yzz8rJJ58sS5YskQcffFDuvPNO8z6GQj9HfU+VBlTdtx6vPz/++KN5rzSs2fS16HvnGXxLG03XAAAAotTBIwfl98zfg263aNuiQpUc37CzOXuzvLX0LeneuHvQ/bWr306qxQe/aGmtWrXMdX+0YuOv2ZeGFj0BVg888IAJIPrNv1ZwdJ0uGzZsmFmvFRmtQGiYGD16tAkQevK/YcMGd3h6//33TUDR5lFaQVF5eXlmeYMGDcz97777zvQX0YtR2ifeGiS0UvPxxx+bSo9WODR4FdVU7cMPP5Rdu3aZ59KKjmrdurV7fefOnc1ke+yxx2TatGkmFN12221B3zv7uO6//35TNVJPP/20zJo1y4SXV155JejjExISzGeg1RZ/r6VPnz7mPVZt2rSRH374QcaPH2+amQWjF/G0X7dWxorqB6ShUitInrTSZa9r2bKllAWCDgAAQJTSkNNtUrdS299fv/hrSNstvmWxdG3UtcTPp9UEW6NGjcxcA0jz5s1NpUVDhF3BsS+aqkHo4MGDsmrVKhNwPCtEHTp0MCfcus4OOi1atHCHHHPsixebaku9evW8juXQoUOmIhQqrQ6dcsop7pN9XwcOHDBN4L744gtTudAmd/ocoVZ0tF+LPk7DiCe9bzezK6levXoVul9Wo8D5XhfHbrJWlteFIugAAABEKa2saOgIpaITSoiZeOHEkCs6pcFzYAD7hNdu+qVzDQran8OXVnz0RNnfSbLvcu0740n3q6FK+5n4Cmd0Mh09rCj33nuvaX6nVRmt9Oj2V1xxhakwlTQg2MuqVHH1QvHs56IDLpRETBnsW6tJWrnxpIHWs7JTFgg6AAAAUUqbj4VSWemc0lke/f5RM/CAv346MRJjRl+76ZSbJLZKbKkeozaf0kpMuLTfjPb98GwO5kmrN1od2bx5s7uqo315tON9+/bti9yvnnRr0zTf5lThHLNWo958803Tr8dfVWfu3Lmmc/6ll15q7msVKZz+KNqvRgcImDdvnpx++unu5fPnz5cePXqY23alSvvH6IAAynPwgGCv5aeffip0v127doX2rZWrQPtWwd4rrRTp4AMa8uzHzJgxw7y+QJ9BaWAwAgAAAIfT8KJDSNuhxpN9f8K5E0o95Cg9kdWRyPQkPzMz012xCeaRRx6R9957z4wStmLFCtMcbfLkyfLwww+b9WeeeaYJG0OHDjWd6RcuXCjXXXed6fOjo58Foo/TE28dyEArLnpcGh50vzoogn3M2vdHT+z1mA8fPlxoP1dffbWpVOh+tG/L+vXrTed87XivNKBNnTrV7EObmunoZqG+ds+qkPbL0detoU/70+j+RowY4X4ODXn6HumQzV9++aUZvMBTWlqaCVnffvuteS3a7M+mx/3MM8+Yx2qfnylTprj3rRWonj17ylNPPWUC5Pfff+9+723aLFArQNo8T/sr6fP4o69d+0Np8Pvtt99MX6UnnnhC7rrrrjJtuqblqIiXlZWlXz2YOQAAQGV06NAha+XKlWZeXJ+s/MRq+kJTS8aIe2r2QjOzvKysXr3a6tmzp1W1alVzPrdhwwZr1qxZ5vbevXvd2y1dutS93jZ9+nSrd+/e5rHJyclWjx49rEmTJrnXb9q0yRo0aJBVvXp1q2bNmtaVV15p7dixw71+9OjRVufOnQsdU3Z2tnX77bdbjRs3tuLj461mzZpZQ4cOtdLT08363Nxc6/LLL7dq165tjumdd94xy/X2tGnT3PvZuHGj2U6PrVq1alb37t2tBQsWmHX6OgYMGGCOXff/8ssvW/369bNGjBjhfnyLFi2s8ePHB3zv8vPzrbFjx1pNmjQxx6mv5X//+5/XNvPmzbM6depkJSUlWX379rWmTJlS6H0cPny4Va9ePbNc3xP7uXXfgwcPNseekpJiTZgwwWvf+v/N/uy6dOlizZgxw+xDPz/buHHjrNTUVCsmJsYaNmxYwNeyfPlyc3yJiYlm+zFjxlgFBQXF+v8eajaI0X8kwmlnLB0xQkuRWsYDAACobLQTvlYZdIQq7aNSXDqE9Nz0ubI9Z7s0qtlI+jbvWyaVHES2tLQ0GTlypJmi7f97qNmAPjoAAACViIaa/mn9K/owgDJHHx0AAAAAjkNFBwAAAKhkNoYxAly0oqIDAAAAwHEIOgAAAAAch6ADAAAAwHEIOgAAAAAch6ADAAAAwHEIOgAAAAAch6ADAACAcjV79myJiYmRffv2RdU7r8f86aefltr+0tLSZMKECaW2P3gj6AAAAKDM9O/fX0aOHBlV7/CYMWOkS5cuhZZv375dzjvvPIkm7777rtSuXbtCA2tubq5cf/310qlTJ4mLi5NLLrlEygNBBwAAoLL55huRDh1c80rkyJEjJXp8amqqJCYmltrxVBb5+flStWpVueOOO+TMM88st+cl6AAAAFQmliXy0EMiq1a55nq/jOi3+HPmzJEXX3zRfPOv08aNG93rFy9eLN27d5dq1apJ7969ZfXq1V6P//zzz6Vbt26SlJQkrVq1krFjx8rRo0fd69PT0+Xiiy+WGjVqSHJysgwePFh27txZqDLz9ttvm8drSLEsS7KysuSWW26Rhg0bmscNHDhQli1b5q6A6PPoffuYdZm/pmtbtmyRq666SurWrSvVq1c3r2XBggVm3R9//GGOLSUlxRzfqaeeKt+EGSwLCgpk3Lhx0rRpU3Ps+lqmT59eZEXll19+cb/Ps2fPlhtuuMG8Xvu16HtiN5t79NFH5ZprrjHH17hxY3nppZfc+9HH6/a6P5s+jy7T/er6AQMGmOV16tQxy/Xz9kffm9dee01uvvlmExbLC0EHAACgMpkxQ+Tnn123da73y4gGnF69epkTXG32pVOzZs3c60eNGiXPP/+8LFq0yDRpuvHGG93rvv76a7n22mtNFWDlypUyceJEEzgef/xxs14DizaB2rNnjwlTM2fONOFiyJAhXsewbt06+eijj+STTz5xn7RfcMEFsmPHDvnqq69M2OrataucccYZZl/6+Lvvvls6duzoPmbffar9+/dLv379ZNu2bfLZZ5+ZYHTfffeZcGKvP//88024Wbp0qZxzzjly0UUXmXAWzvun789zzz0ny5cvN/sYNGiQrF27NqTH9+7d2/QB0jBnv5Z77rnHvf7ZZ5+Vk08+WZYsWSIPPvig3HnnneZ9DIV+jvqeKg2oum893kgSV9EHAAAAgGI6eFDk999D316rN3fdJVKlipYLXHO9/957Wq4IfT/t2olUqxZ0s1q1aklCQoKp2Pj7Jl9Di4YF9cADD5gAov05tIKj63TZsGHDzHqtyGgFQsPE6NGjTYDQk/8NGza4w9P7779vAsrPP/9sKigqLy/PLG/QoIG5/91338mvv/4qGRkZ7mZoGiS0UvPxxx+bSo9WODR4FVV9+PDDD2XXrl3mubSio1q3bu1e37lzZzPZHnvsMZk2bZoJRbfddltIb7Me1/3332+qRurpp5+WWbNmmfDyyiuvBH18QkKC+Qy02uLvtfTp08e8x6pNmzbyww8/yPjx4+Wss84Kuu/Y2Fj369bKWFn1AyoJgg4AAEC00pDTrVvxH69hZ+VKke7dw3vc4sUiXbtKSWk1wdaoUSMz1wDSvHlzU2nREGFXcOy+HhqEDh48KKtWrTIBx7NC1KFDB3PCrevsoNOiRQt3yHEd+mJTbalXr57XsRw6dMhUhEKl1aFTTjnFfbLv68CBA6YJ3BdffGGqPtrkTp8j1IpOdna2eZyGEU96325mV1K9evUqdN9Jo8ARdAAAAKKVVlY0dIRazbnuOlc4Ota8ytCqju4nnKqObl8K4uPj3be16qDspl8616Bw2WWXFXqcVny06Zr9GE++y7V/iCfdr4Yq7WfiK5yqhHauL8q9995rmt9pVUYrPbr9FVdcYSpM4fB9jZ6vr4p+dseWldaACzFluO/yRtABAACIVtp8LNTKytdfu6o3gao6mZki55xT6oeozae0EhMu7TejfT88m4N50uqNVkc2b97srupoXx7teN++ffsi96v9c7RpmnbIL+4xazXqzTffNP16/FV15s6dazrnX3rppea+VpE8B2IIRvvV6AAB8+bNk9NPP929fP78+dKjRw9z265Uaf8YHRBAeQ4eEOy1/PTTT4XutzsWYj33rZWrQPtWxfl8ywODEQAAADidfiv/97+7qjf+6HJdXwYjsGmY0JHI9CQ/MzPTXbEJ5pFHHpH33nvPjBK2YsUK0xxt8uTJ8vDDD5v1Okyxho2hQ4eazvQLFy6U6667zvT50dHPAtHHaRMtHchAKy56XBoedL86KIJ9zNr3R0/s9ZgPHz5caD9XX3216fei+9G+LevXrzed83/88UezXgPa1KlTzT60qZmObhbqa/esCmm/HH3dGvq0P43ub8SIEe7n0JCn79GaNWvkyy+/NIMXeEpLSzMh69tvvzWvRZv92fS4n3nmGfNY7fMzZcoU9761AtWzZ0956qmnTID8/vvv3e+9TZsFagVIm+dpfyV9nkB0H3rsGgw1jOpt3+BU6qwokJWVpT91Zg4AAFAZHTp0yFq5cqWZhy0317JSUjTGBJ5SU13blbLVq1dbPXv2tKpWrWrO5zZs2GDNmjXL3N67d697u6VLl7rX26ZPn2717t3bPDY5Odnq0aOHNWnSJPf6TZs2WYMGDbKqV69u1axZ07ryyiutHTt2uNePHj3a6ty5c6Fjys7Otm6//XarcePGVnx8vNWsWTNr6NChVnp6+rG3K9e6/PLLrdq1a5tjeuedd8xyvT1t2jT3fjZu3Gi202OrVq2a1b17d2vBggVmnb6OAQMGmGPX/b/88stWv379rBEjRrgf36JFC2v8+PEB37v8/Hxr7NixVpMmTcxx6mv53//+57XNvHnzrE6dOllJSUlW3759rSlTphR6H4cPH27Vq1fPLNf3xH5u3ffgwYPNsaekpFgTJkzw2rf+f7M/uy5dulgzZsww+9DPzzZu3DgrNTXViomJsYYNGxbwtejz6WN9p+L8fw81G8ToPxLhtDOWjhih6U/LeAAAAJWNdsLXKkPLli1NH5Wwbd4ssmtX4PUNG4o0bVqiY0T0SEtLk5EjR5op2v6/h5oN6KMDAABQGWg/Fo8RygCno48OAAAAAMehogMAAABUMhvDGAEuWlHRAQAAAOA4BB0AAAAAjkPQAQAAAOA4BB0AAAAAjkPQAQAAAOA4BB0AAAAAjkPQAQAAQLmaPXu2xMTEyL59+6Lqnddj/vTTT0ttf2lpaTJhwoRS2x+8EXQAAABQZvr37y8jR46Mqnd4zJgx0qVLl0LLt2/fLuedd55Ek3fffVdq165doYFVt7v44oulUaNGUr16dfPefvDBB1LWCDoAAACVwIYNY2Tjxkf9rtPlut7pjhw5UqLHp6amSmJiYqkdT2Uxf/58Ofnkk+WTTz6R5cuXy4033ijXXXedfP7552X6vAQdAACASiAmJlY2bnykUNjR+7pc15e266+/XubMmSMvvvii+eZfp40bN7rXL168WLp37y7VqlWT3r17y+rVq70eryfC3bp1k6SkJGnVqpWMHTtWjh496l6fnp5uKgU1atSQ5ORkGTx4sOzcubNQZebtt982j9eQYlmWZGVlyS233CINGzY0jxs4cKAsW7bMXQHR59H79jHrMn9N17Zs2SJXXXWV1K1b11Qq9LUsWLDArPvjjz/MsaWkpJjjO/XUU+Wbb74J6/0rKCiQcePGSdOmTc2x62uZPn16kRWVX375xf0+z549W2644Qbzeu3Xou+J3Wzu0UcflWuuucYcX+PGjeWll15y70cfr9vr/mz6PLpM96vrBwwYYJbXqVPHLNfP25+HHnrIPJd+xieccILccccdcu6558q0adOkLBF0AAAAKoG0tL9LWto4r7BjhxxdrutLmwacXr16yc0332yafenUrFkz9/pRo0bJ888/L4sWLZK4uDjzTb/t66+/lmuvvdacFK9cuVImTpxoAsfjjz9u1mtgueSSS2TPnj0mTM2cOdOEiyFDhngdw7p16+Sjjz4y1QT7pP2CCy6QHTt2yFdffWXCVteuXeWMM84w+9LH33333dKxY0f3MfvuU+3fv1/69esn27Ztk88++8wEo/vuu8+EE3v9+eefb8LN0qVL5ZxzzpGLLrrIhLNw3j99f5577jlTCdF9DBo0SNauXRvS43v37m36AGmYs1/LPffc417/7LPPmkrLkiVL5MEHH5Q777zTvI+h0M9R31OlAVX3rccbKg1fGhDLUlyZ7h0AAABlJj//oBw8+HvI29erd4Hk5W0z4WbTpkfFso5I48bDzfKcnCUh76datXYSG1st6Ha1atWShIQEU7HRZl++NLRoWFAPPPCACSC5ubmmgqPrdNmwYcPMeq3IaFVAw8To0aNNgNCT/w0bNrjD0/vvv28Cys8//2wqKCovL88sb9Cggbn/3Xffya+//ioZGRnuZmgaJLRS8/HHH5tKj1Y4NHj5O2bbhx9+KLt27TLPZZ+wt27d2r2+c+fOZrI99thjpoKhoei2224L6X3W47r//vtN1Ug9/fTTMmvWLBNeXnnllaCPT0hIMJ+BVlv8vZY+ffqY91i1adNGfvjhBxk/frycddZZQfcdGxvrft1aGQunH5C+z/q+aXgtSwQdAACAKKUhZ/HibsV6rIYctW3b62YKR7dui6Vmza5SUlpNsGlHdaUBpHnz5qbSoifDdgVH5efnmyB08OBBWbVqlQk4nhWiDh06mBNuXWcHnRYtWrhDjtL9arWlXr16Xsdy6NAhUxEKlVaHTjnllIBViQMHDpgmcF988YWp+miTO32OUCs62dnZ5nEaRjzpfbuZXUn16tWr0P2yHgVOm71pE7c33njDhNKyRNABAACIUlpZ0dARju3b3zDBJiYm3l3RadTo5rCftzTEx8e7b2vVQdlNv3SuQeGyyy4r9Dit+GjTNfsxnnyXa98ZT7pfDVV6wu0rnKpE1apVi1x/7733muZ3WpXRSo9uf8UVV5gKUzh8X6Pn66tSpYp7WWkNuBBThvvWJobafO+FF14wgxGUNYIOAABAlNLmY+FUVrRPjoYcu0+O3UcnIaFxmfTRsZtPaSUmXNpvRvt+eDYH86TVG62ObN682V3V0b482vejffv2Re5X++do0zTtkF/cY9Zq1Jtvvmn69fir6sydO9dULi699FJzX6tIngMxBKP9anSAgHnz5snpp5/uNYJZjx49zG27UqX9Y3RAAOU5eECw1/LTTz8Vut+uXbtC+9bKVaB9q1A+Xw2WF154oWl+p80DywODEQAAAFQC/gYe8DdAQWnTMKEjkelJfmZmprtiE8wjjzwi7733nhklbMWKFaY52uTJk+Xhhx82688880wTNoYOHWo60y9cuNBUCbTPj45+Fog+Tpto6UAGWnHR49LwoPvVQRHsY9a+P3pir8d8+PDhQvu5+uqrTb8X3Y/2bVm/fr3pnP/jjz+a9RrQpk6davahTc10dLNQX7tnVUiDgb5uDX3an0b3N2LECPdzaMjT92jNmjXy5ZdfmsELPKWlpZmQ9e2335rXos3+bHrczzzzjHms9vmZMmWKe99agerZs6c89dRTJkB+//337vfeps0CtQKkzfO0v5I+T6CQo/2vdGCJyy+/3ARNnTQklikrCmRlZWnNzMwBAAAqo0OHDlkrV6408+JYv360tWHDOL/rdLmuLwurV6+2evbsaVWtWtWcz23YsMGaNWuWub137173dkuXLnWvt02fPt3q3bu3eWxycrLVo0cPa9KkSe71mzZtsgYNGmRVr17dqlmzpnXllVdaO3bscK8fPXq01blz50LHlJ2dbd1+++1W48aNrfj4eKtZs2bW0KFDrfT0dLM+NzfXuvzyy63atWubY3rnnXfMcr09bdo09342btxottNjq1atmtW9e3drwYIFZp2+jgEDBphj1/2//PLLVr9+/awRI0a4H9+iRQtr/PjxAd+7/Px8a+zYsVaTJk3Mcepr+d///ue1zbx586xOnTpZSUlJVt++fa0pU6YUeh+HDx9u1atXzyzX98R+bt334MGDzbGnpKRYEyZM8Nq3/n+zP7suXbpYM2bMMPvQz882btw4KzU11YqJibGGDRvm93Xocn2c76TvR3H+v4eaDWL0n3CCkaY5HYpOO3JpKUtHj9AkG6w93l133WXSuJbgdLSM4cOHh/yc2hlLR4zQUqSW8QAAACob7YSvVYaWLVuaPipASaSlpcnIkSPNFG3/30PNBmE3XdMRJHSovJdffjmk7fUAdQzxvn37mjHE9YJBWrayx90GAAAAgAofjOC8884zU6hef/11M0SgPVSddg7T9o86AoW20QMAAACAqBt1TTtknX322V7L9Kqub731lhmiznNYQZt2+PLs9KXlKQAAAAClY2MYI8BFqzIfdU1HVEhJSfFapvf1okk68oM/Tz75pGl3Z0+eF4ICAAAAgIgYXtrfhY78Lbc9+OCDpnORPen46AAAAAAQMU3XdHxxrep4ysjIMBdpqlevnt/HJCYmmgkAAAAAIrKioxdkmjlzpteyGTNmmAs5+eufAwAAAADlHnT0iqd6RVadlH3V2PT0dHezM70qrU2vl7Np0yZzHR29ou3bb79tBiK45557SnzwAAAAAFAqTdd0aOgBAwa472uAUcOGDZN3333XXETUDj1KL/Lz1VdfyZ133imvvPKKuWDoP/7xD4aWBgAAABA5Qad///7uwQT80bDjq1+/frJkyZLwjw4AAACOM3v2bPPF+d69e6V27doSLXQgrWnTpskll1xSKvtLS0uTkSNHmglROuoaAAAAKif9kjzaTuTHjBkjXbp0KbRcWy6dd955Ek3efffdMguTGlg1/O3bt6/I7VavXm2CrV5iJikpSVq1aiUPP/ywuaZmVI+6BgAAgMiyfbvIxIkif/2rSKNGUmkEulh9OKMJI3z6nmsf/q5du5rQtWzZMrn55puloKBAnnjiiWLsMTRUdAAAACph0Bk71jUvS9dff73MmTNHXnzxRfPNv04bN250r1+8eLEZibdatWrSu3dv882/p88//1y6devmrgKMHTvWXHTepv3CL774YqlRo4YkJyfL4MGDZefOnYUqMzoYlj5eL1+iXTD0Oo233HKLNGzY0Dxu4MCB5uTbroDo8+h9+5jtrhl6+9NPP3Xvf8uWLXLVVVdJ3bp1pXr16ua1LFiwwKz7448/zLFpFUOP79RTT5VvvvkmrPdPg8C4ceOkadOm5tj1tUyfPr3IiooOEma/z7Nnz5YbbrjBvF77teh7Yjebe/TRR+Waa64xx6f96F966SX3fvTxur09AJnS59Flul9db/fbr1Onjlmun7c/+t7rcXTu3FlatGghgwYNkqFDh8rcuXOlLBF0AAAAUCY04OilRvTbe232pVOzZs3c60eNGiXPP/+8GexKr7F44403utd9/fXXcu2118odd9whK1eulIkTJ5rA8fjjj5v1Gli0r8yePXtMmNLLmWi4GDJkiNcxrFu3Tj766CP55JNP3CftF1xwgbnOow6YpWFLKw1nnHGG2Zc+/u6775aOHTu6j9l3n/ZIxNoPfdu2bfLZZ5+ZYHTfffeZcGKvP//88024Wbp0qZxzzjly0UUXeQ3aFcr7p+/Pc889J8uXLzf70JCwdu3akB7fu3dvmTBhgglz9mvxHPn42WeflZNPPtn0pdeRk3XwMN/LwgSin6O+p0oDqu5bjzcU+ploYNP3ryzRdA0AACBKHTwo8vvvoW27a5dIZqbrtv2YadNEVq1y3a5fX6RBg9D21a6dSLVqwberVauWJCQkmIqNv2ZfGlrsk90HHnjABJDc3FxTwdF1ukxH9rWrAlqB0DAxevRoEyD05F8vdWKHp/fff98ElJ9//tlUUFReXp5Z3uDYi/vuu+/k119/NRewty9Qr0FCKzUff/yxqfRohUODV1FN1T788EPZtWuXeS6t6KjWrVu712v1QifbY489ZgYy0FB02223hfQ+63Hdf//9pmqknn76aZk1a5YJLzqacTAJCQnmM9Bqi7/X0qdPH/MeqzZt2sgPP/wg48ePl7POOivovmNjY92vWytjofQD0uCloerw4cPmfdZqVVki6AAAAEQpDSzduhX/8Y89VrzHLV4s0rWrlJhWE2yNjnUW0gDSvHlzU2nREGFXcFR+fr4JQgcPHjTXZ9SA41kh6tChgznh1nV20NGmUnbIcR37YlNtqVevntexHDp0yFSEQqXVoVNOOcV9su/rwIEDpgncF198Yao+2uROnyPUik52drZ5nIYRT3rfbmZXUr169Sp0X0NUWZk8ebLk5OSY47/33ntNkNPgWlYIOgAAAFFKKysaOopT0dGQ8/DDrn0Up6JTGjwHBtCqg7Kbfulcg8Jll11W6HFa8dGma/ZjPPku174znnS/Gqq0n4mvcEYnq1q1apHr9URem9/pybxWenT7K664wlSYwuH7Gj1fX5Uqrl4onpd+KelIZjFluG87lGog1dCqVR1tJqjVobJA0AEAAIhS2nysOJUVvbyhBp1LLy2dykyw5lN6Uhsu7TejfT88m4N50pNlrY5s3rzZfQKtfXm043379u2L3K/2z9Gmadohv7jHrNWoN9980/Tr8VfV0Y722jn/Un2Tj/XZ8RyIIRjtV6MDBMybN09OP/109/L58+dLjx49zG27UqX9Y3RAAOU5eECw1/LTTz8Vut/uWIr13LdWrgLtWxXn89UApcGpqOtzlhSDEQAAAKDMaJjQkcj0JD8zM9NdsQnmkUcekffee8+MErZixQrTHE2bPun1V9SZZ55pwoaO3qX9PhYuXGiGMNY+Pzr6WSD6OG2ipQMZaMVFj0vDg+5XB0Wwj1n7/uiJvR6z9inxdfXVV5t+L7of7duyfv160zn/xx9/NOs1oE2dOtXsQ5tq6ehmob52z6qQ9svR162hT/vT6P5GjBjhfg4NefoerVmzRr788kszeIGntLQ0E7K+/fZb81q02Z9Nj/uZZ54xj9U+P1OmTHHvWytQPXv2lKeeesoEyO+//9793tu0WaBWgLR5nvZX0ufx54MPPjADQuhnqO+TPo8OfqCDPGjgLDNWFMjKytKoZ+YAAACV0aFDh6yVK1eaeUlt22ZZo0e75mVt9erVVs+ePa2qVaua87kNGzZYs2bNMrf37t3r3m7p0qXu9bbp06dbvXv3No9NTk62evToYU2aNMm9ftOmTdagQYOs6tWrWzVr1rSuvPJKa8eOHe71o0ePtjp37lzomLKzs63bb7/daty4sRUfH281a9bMGjp0qJWenm7W5+bmWpdffrlVu3Ztc0zvvPOOWa63p02b5t7Pxo0bzXZ6bNWqVbO6d+9uLViwwKzT1zFgwABz7Lr/l19+2erXr581YsQI9+NbtGhhjR8/PuB7l5+fb40dO9Zq0qSJOU59Lf/73/+8tpk3b57VqVMnKykpyerbt681ZcqUQu/j8OHDrXr16pnl+p7Yz637Hjx4sDn2lJQUa8KECV771v9v9mfXpUsXa8aMGWYf+vnZxo0bZ6WmploxMTHWsGHD/L6O//znP1bXrl2tGjVqmM+qQ4cO1hNPPFHk/+Wi/r+Hmg1i9B+JcNoZS0eM0FKklvEAAAAqG+2Er1WGli1bmj4qQEmkpaXJyJEjzRRt/99DzQY0XQMAAADgOAQdAAAAAI7DqGsAAABAJbMxjBHgohUVHQAAAACOQ9ABAAAA4DgEHQAAAACOQ9ABAAAA4DgEHQAAAACOQ9ABAAAA4DgEHQAAAJSr2bNnS0xMjOzbty+q3nk95k8//bTU9peWliYTJkwotf3BG9fRAQAAqATS09MlMzMz4Pr69etL8+bNS/15+/fvL126dImqE/oxY8aYQPPLL794Ld++fbvUqVNHosm7774rI0eOLJNQqYF1wIABsnfvXqldu3ZIj1m3bp2ccsopEhsbW+ZBl6ADAABQCUJO27ZtJTc3N+A2SUlJsnr16jIJO5HiyJEjEh8fX+zHp6amlurxVDZHjhyRq6++Wvr27Svz588v8+ej6RoAAIDDaSWnqJCjdH1RFZ/iuP7662XOnDny4osvmmZfOm3cuNG9fvHixdK9e3epVq2a9O7d2wQtT59//rl069bNhLBWrVrJ2LFj5ejRo14B7uKLL5YaNWpIcnKyDB48WHbu3OlVmdFq0ttvv20en5iYKJZlSVZWltxyyy3SsGFD87iBAwfKsmXL3BUQfR69bx+zLvPXdG3Lli1y1VVXSd26daV69ermtSxYsMCs++OPP8yxpaSkmOM79dRT5Ztvvgnr/SsoKJBx48ZJ06ZNzbHra5k+fXqRTQC1CmW/z7Nnz5YbbrjBvF77teh7Yjebe/TRR+Waa64xx9e4cWN56aWX3PvRx+v2nlUtfR5dpvvV9VrNUVrl0uX6eRfl4Ycflnbt2pnPqTwQdAAAAFAmNOD06tVLbr75ZtPsS6dmzZq5148aNUqef/55WbRokcTFxcmNN97oXvf111/LtddeK3fccYesXLlSJk6caALH448/btZrYLnkkktkz549JkzNnDnThIshQ4YUair10UcfySeffOI+ab/gggtkx44d8tVXX5mw1bVrVznjjDPMvvTxd999t3Ts2NF9zL77VPv375d+/frJtm3b5LPPPjPB6L777jPhxF5//vnnm3CzdOlSOeecc+Siiy4y4Syc90/fn+eee06WL19u9jFo0CBZu3ZtSI/v3bu3aTKoYc5+Lffcc497/bPPPisnn3yyLFmyRB588EG58847zfsYCv0c9T1VGlB133q8gXz33XcyZcoUeeWVV6S80HQNAAAgSh08eFB+//33oNutWrUqpP2Fup1+K69VmGBq1aolCQkJZlt/zb40tGhYUA888IAJIFpZ0gqOrtNlw4YNM+u1IqMVCA0To0ePNgFCT/43bNjgDk/vv/++CSg///yzqaCovLw8s7xBgwbuE+5ff/1VMjIyTJVEaZDQSs3HH39sKj1a4dDgVVRTtQ8//FB27dplnksrOqp169bu9Z07dzaT7bHHHpNp06aZUHTbbbeF9D7rcd1///2maqSefvppmTVrlgkvoQSGhIQE8xlotcXfa+nTp495j1WbNm3khx9+kPHjx8tZZ50VdN/ax8Z+3VoZK6qPzu7du02151//+pcJXeWFoAMAABClNORo067SohWUUNhVkJLSaoKtUaNGZq4BRPsJ6XNoiLArOCo/P98EIQ14Gso04HhWiDp06GBOuHWdHXRatGjhDjn2sWu1pV69el7HcujQIVMRCpVWh7RTvX2y7+vAgQOmCdwXX3xhqj7a5E6fI9SKTnZ2tnmchhFPet9uZldSvXr1KnS/LAaN0IqeNpE7/fTTpTwRdAAAAKKUVlb0xD0YPfEPJcToN+7t27cP6XlLg+fAAFp1UHbTL51rULjssssKPU4rPtp0zX6MJ9/l2nfGk+5XQ5X2M/EV6shhqmrVqkWuv/fee03zO63KaKVHt7/iiitMhSkcvq/R8/VVqVLFvcyzw39JxJTBvrWKppUsfS/sfernoFWzSZMmeTVZLE0EHQAAgCilTcJKo7Ji05BTmvuzm09pJSZcehza98OzOZgnrd5odWTz5s3uqo725dGO90WFNd2v9s/Rk2ztkF/cY9Zq1Jtvvmn69fir6sydO9c017r00kvNfa0ieQ7EEIw28dIBAubNm+dVCdHRynr06GFu25Uqz2GvfYfETijitfz000+F7tsh1nPfWrkKtG8V7L368ccfvbb573//a5rh6Wtp0qSJlBUGIwAAAECZ0TChI5HpSb6O6mZXbIJ55JFH5L333jOjhK1YscJUpSZPnmxG7lJnnnmmCRtDhw41nekXLlwo1113nenzo6OfBaKP0yZaOpCBVlz0uPSEW/ergyLYx6x9f/TEXo/58OHDhfajwyRrvxfdj/ZtWb9+vemcryf1SgPa1KlTzT60qZk23Qr1tXtWhTQQ6OvW0Kf9aXR/I0aMcD+Hhjx9j9asWSNffvmlGbzAU1pamglZ3377rXkt2uzPpsf9zDPPmMdqnx8dLMDet1agevbsKU899ZQJkN9//737vbdps0CtAGnzPO2vpM/jjwbPk046yT1puNGKkd4uy+sSEXQAAAAcTi8Gqs29iqLrdbvSpqN8acd1rcBolSDUPio6wpieQOsoYNrfRk+6X3jhBXNy7TnUs54oa8VDA4wOWKChoCj6OB1tTR+jTaa0E7529tfAo0NBq8svv1zOPfdcM3yyHvO///3vQvvRasaMGTNMR3wdXa1Tp04mFOhrVdqpX49NRz7T0db09YRbLdMR53QEOJ10/zq0tDYBO/HEE91N//TYtK+WDnygoUgHPfDUu3dvGT58uBk5Tl+LBhub7lebPmrFRgd60JCkx2nTYbm1uZoGRw1AvvvWwKLNCzWA6XsX6iAL5SXG8mx4F6G0M5aOGKGlyPIcqQEAACBSaCd8rTK0bNkyaGjxRwNGUdfJ0ZDj5IuFQgpVekaOHGmmaPv/Hmo2oI8OAABAJaAhhiCDyoSmawAAAAAch4oOAAAAUMlsDGMEuGhFRQcAAACA4xB0AAAAokgUjCMFRMT/c4IOAABAFLCHLc7Ly6voQwHKnH29Hx1Cu7joowMAABAF4uLipFq1aubCjHrypxdcBJxYyTl48KBkZGRI7dq13QG/OAg6AAAAUUAvdNmoUSNzbZFNmzZV9OEAZUpDTmpqaon2QdABAACIEgkJCXLiiSfSfA2OFh8fX6JKjo2gAwAAEEW0yZrvleIBFEbjTgAAAACOQ9ABAAAA4DgEHQAAAACOQ9ABAAAA4DgEHQAAAACOQ9ABAAAA4DgEHQAAAACOQ9ABAAAA4DgEHQAAAACOQ9ABAAAA4DgEHQAAAACOQ9ABAAAA4DgEHQAAAACOQ9ABAAAA4DgEHQAAAACOQ9ABAAAA4DgEHQAAAACOQ9ABAAAA4DgEHQAAAACOQ9ABAAAA4DgEHQAAAACOQ9ABAAAA4DgEHQAAAACOQ9ABAAAA4DgEHQAAAACOQ9ABAAAA4DgEHQAAAACOQ9ABAAAA4DgEHQAAAACOQ9ABAAAA4DgEHQAAAACOQ9ABAAAA4DgEHQAAAACOQ9ABAAAA4DgEHQAAAACOQ9ABAAAA4DgEHQAAAACOQ9ABAAAA4DgEHQAAAACOQ9ABAAAA4DgEHQAAAACOQ9ABAAAA4DgEHQAAAACOQ9ABAAAA4DgEHQAAAACOQ9ABAAAA4DgEHQAAAACOQ9ABAAAA4DgEHQAAAACOQ9ABAAAA4DgEHQAAAACOQ9ABAAAA4DgEHQAAAACOQ9ABAAAA4DgEHQAAAACOQ9ABAAAA4DgEHQAAAACOQ9ABAAAA4DgEHQAAAACOQ9ABAAAA4DgEHQAAAACOQ9ABAAAA4DgEHQAAAACOQ9ABAAAA4DgEHQAAAACOQ9ABAAAA4DgEHQAAAACOQ9ABAAAA4DgEHQAAAACOQ9ABAAAA4DgEHQAAAACOQ9ABAAAA4DgEHQAAAACOQ9ABAAAA4DgEHQAAAACOQ9ABAAAA4DgEHQAAAACOQ9ABAAAA4DgEHQAAAACOQ9ABAAAA4DgEHQAAAACOQ9ABAAAA4DgEHQAAAACOQ9ABAAAA4DgEHQAAAACOQ9ABAAAA4DgEHQAAAACOU6yg8+qrr0rLli0lKSlJunXrJnPnzi1y+w8++EA6d+4s1apVk0aNGskNN9wgu3fvLu4xAwAAAEDpBp3JkyfLyJEjZdSoUbJ06VLp27evnHfeeZKenu53+3nz5sl1110nN910k6xYsUKmTJkiP//8s/zlL38J96kBAAAAoGyCzgsvvGBCiwaV9u3by4QJE6RZs2by2muv+d3+p59+krS0NLnjjjtMFehPf/qT/PWvf5VFixaF+9QAAAAAUPpBJy8vTxYvXixnn32213K9P3/+fL+P6d27t2zZskW++uorsSxLdu7cKR9//LFccMEFAZ/n8OHDkp2d7TUBAAAAQJkEnczMTMnPz5eUlBSv5Xp/x44dAYOO9tEZMmSIJCQkSGpqqtSuXVteeumlgM/z5JNPSq1atdyTVowAAAAAoEwHI4iJifG6r5Ua32W2lStXmmZrjzzyiKkGTZ8+XTZs2CDDhw8PuP8HH3xQsrKy3NPmzZuLc5gAAAAAKqm4cDauX7++xMbGFqreZGRkFKryeFZn+vTpI/fee6+5f/LJJ0v16tXNIAaPPfaYGYXNV2JiopkAAAAAoMwrOtr0TIeTnjlzptdyva9N1Pw5ePCgVKni/TQaluxKEAAAAABUeNO1u+66S9588015++23ZdWqVXLnnXeaoaXtpmja7EyHk7ZddNFFMnXqVDMq2/r16+WHH34wTdl69OghjRs3Lt1XAwAAAADhNl1TOqiAXuxz3Lhxsn37djnppJPMiGotWrQw63WZ5zV1rr/+esnJyZGXX35Z7r77bjMQwcCBA+Xpp5/mAwAAAABQJmKsKGg/psNL6+hrOjBBcnJyRR8OAAAAgAjPBsUadQ0AAAAAIhlBBwAAAIDjEHQAAAAAOA5BBwAAAIDjEHQAAAAAOA5BBwAAAIDjEHQAAAAAOA5BBwAAAIDjEHQAAAAAOA5BBwAAAIDjEHQAAAAAOA5BBwAAAIDjEHQAAAAAOA5BBwAAAIDjEHQAAAAAOA5BBwAAAIDjEHQAAAAAOA5BBwAAAIDjEHQAAAAAOA5BBwAAAIDjEHQAAAAAOA5BBwAAAIDjEHQAAAAAOA5BBwAAAIDjEHQAAAAAOA5BBwAAAIDjEHQAAAAAOA5BBwAAAIDjEHQAAAAAOA5BBwAAAIDjEHQAAAAAOA5BBwAAAIDjEHQAAAAAOA5BBwAAAIDjEHQAAAAAOA5BBwAAAIDjEHQAAAAAOA5BBwAAAIDjEHQAAAAAOA5BBwAAAIDjEHQAAAAAOA5BBwAAAIDjEHQAAAAAOA5BBwAAAIDjEHQAAAAAOA5BBwAAAIDjEHQAAAAAOA5BBwAAAIDjEHQAAAAAOA5BBwAAAIDjEHQAAAAAOA5BBwAAAIDjEHQAAAAAOA5BBwAAAIDjEHQAAAAAOA5BBwAAAIDjEHQAAAAAOA5BBwAAAIDjEHQAAAAAOA5BBwAAAIDjEHQAAAAAOA5BBwAAAIDjEHQAAAAAOA5BBwAAAIDjEHQAAAAAOA5BBwAAAIDjEHQAAAAAOA5BBwAAAIDjEHQAAAAAOA5BBwAAAIDjEHQAAAAAOA5BBwAAAIDjEHQAAAAAOA5BBwAAAIDjEHQAAAAAOA5BBwAAAIDjEHQAAAAAOA5BBwAAAIDjEHQAAAAAOA5BBwAAAIDjEHQAAAAAOA5BBwAAAIDjEHQAAAAAOA5BBwAAAIDjEHQAAAAAOA5BBwAAAIDjEHQAAAAAOA5BBwAAAIDjEHQAAAAAOA5BBwAAAIDjEHQAAAAAOA5BBwAAAIDjEHQAAAAAOA5BBwAAAIDjEHQAAAAAOA5BBwAAAIDjEHQAAAAAOA5BBwAAAIDjEHQAAAAAOA5BBwAAAIDjEHQAAAAAOA5BBwAAAIDjEHQAAAAAOA5BBwAAAIDjEHQAAAAAOA5BBwAAAIDjEHQAAAAAOA5BBwAAAIDjEHQAAAAAOA5BBwAAAIDjEHQAAAAAOA5BBwAAAIDjEHQAAAAAOA5BBwAAAIDjEHQAAAAAOA5BBwAAAIDjEHQAAAAAOA5BBwAAAIDjEHQAAAAAOA5BBwAAAIDjEHQAAAAAOA5BBwAAAIDjEHQAAAAAOA5BBwAAAIDjEHQAAAAAOA5BBwAAAIDjEHQAAAAAOA5BBwAAAIDjEHQAAAAAOE6xgs6rr74qLVu2lKSkJOnWrZvMnTu3yO0PHz4so0aNkhYtWkhiYqKccMIJ8vbbbxf3mAEAAACgSHESpsmTJ8vIkSNN2OnTp49MnDhRzjvvPFm5cqU0b97c72MGDx4sO3fulLfeektat24tGRkZcvTo0XCfGgAAAABCEmNZliVhOO2006Rr167y2muvuZe1b99eLrnkEnnyyScLbT99+nS56qqrZP369VK3bl0pjuzsbKlVq5ZkZWVJcnJysfYBAAAAIPqFmg3CarqWl5cnixcvlrPPPttrud6fP3++38d89tln0r17d3nmmWekSZMm0qZNG7nnnnvk0KFDRTZ10xfgOQEAAABAmTRdy8zMlPz8fElJSfFarvd37Njh9zFayZk3b57pzzNt2jSzj1tvvVX27NkTsJ+OVobGjh0bzqEBAAAAQMkGI4iJifG6r63ffJfZCgoKzLoPPvhAevToIeeff7688MIL8u677was6jz44IOmFGVPmzdvLs5hAgAAAKikwqro1K9fX2JjYwtVb3RwAd8qj61Ro0amyZq2o/Ps06PhaMuWLXLiiScWeoyOzKYTAAAAAJR5RSchIcEMJz1z5kyv5Xq/d+/efh+jI7Nt27ZN9u/f7162Zs0aqVKlijRt2rRYBw0AAAAApdp07a677pI333zT9K9ZtWqV3HnnnZKeni7Dhw93Nzu77rrr3Ntfc801Uq9ePbnhhhvMENTff/+93HvvvXLjjTdK1apVw316AAAAACj96+gMGTJEdu/eLePGjZPt27fLSSedJF999ZW5GKjSZRp8bDVq1DAVn9tvv92MvqahR6+r89hjj4X71AAAAABQNtfRqQhcRwcAAABAmV1HBwAAAACiAUEHAAAAgOMQdAAAAAA4DkEHAAAAgOMQdAAAAAA4DkEHAAAAgOMQdAAAAAA4DkEHAAAAgOMQdAAAAAA4DkEHAAAAgOMQdAAAAAA4DkEHAAAAgOMQdAAAAAA4DkEHAAAAgOMQdAAAAAA4DkEHAAAAgOMQdAAAAAA4DkEHAAAAgOMQdAAAAAA4DkEHAAAAgOMQdAAAAAA4DkEHAAAAgOMQdAAAAAA4DkEHAAAAgOMQdAAAAAA4DkEHAAAAgOMQdAAAAAA4DkEHAAAAgOMQdAAAAAA4DkEHAAAAgOMQdAAAAAA4DkEHAAAAgOMQdAAAAAA4DkEHAAAAgOMQdAAAAAA4DkEHAAAAgOMQdAAAAAA4DkEHAAAAgOMQdAAAAAA4DkEHAAAAgOMQdAAAAAA4DkEHAAAAgOMQdAAAAAA4DkEHAAAAgONEVdCZu2mu5BfkV/RhAAAAAIhwURV0LvzwQkl7MU2mrppa0YcCAAAAIIJFVdBRW7O3yhUfXUHYAQAAAOCcoGOJZeYjp4+kGRsAAAAAZwQdO+xszt4sc9PnVvShAAAAAIhAURl0PJuxAQAAAICjgs7fvvybDJ4yWCYtniTr966v6MMBAAAAECHiJArFSIw0qNZAbu52s3y34Tu59ctbJd/Kl1Z1WsmZLc+UM1udKQNbDpR61epV9KECAAAAqABx0Rhy1GsXviaXtb/M3M7KzZI5m+bIzD9myjcbvpFJSyaZ7bo26mpCj05/av4nSYpLquCjBwAAAFAeYizLcg1jFsGys7OlVq1aIg+INGvYTCacO8EdcvzZkr1Fvln/jXvaeWCnCTkadrTic9YJZ0mX1C5SJSaqW+4BAAAAlU72sWyQlZUlycnJzgg6Xyz/Qs7teK7EVokN+bH68n7L+M0VejZ8I3M2zpEDRw5Ivar1TPO2s1qdZSo+Leu0LNPXAAAAAKDkHBl0gr2YUOTl58lPW35yV3sWbl3o7t9jh54BaQPC6t+TX5BvhrrenrNdGtVsJH2b9w0rjAEAAAAIDUEnRNq/Z/bG2Sb0zFw/U1bvXu3u32MHnz7N+wTs3zN11VQZMX2EaS5na5rcVF4898Uim9cBAAAACB9Bp5g2Z22Wbzd8W6h/j1Zp7IEN7P49GnKu+OgKcwFTfwMmfDz4Y8IOAAAAUIoIOqXAs3+PVnt0ZLeDRw6a/j0DWg6Qb9d/K3tz9/p9rIYdrexsGLGBZmwAAABAKSHolAG7f48OY/3Jqk9kVeaqoI+ZNWyW9E/rXxaHAwAAAFQ62SH232d85TAkxCbI6S1Ol0cHPip/P/3vIT1m1a7gYQgAAABA6SLoFJOOrhaKW7+6Vdq/0l7+9sXfZPJvk2XH/h3FfUoAAAAAIYoLdUN408EJtA/O1uythQYjsPvoaBh67qzn5PtN38vsTbPl9cWvm3Vt67U1zdl06teiX8ihCQAAAEBoKt11dEqTPeqa8gw7gUZd02qOCT0bZ5vJ7uOjwUcDjwk+af2kcc3G5f5aAAAAgGjAYATlxN91dJolN5MJ504IOrT0zv07zUhuvsGnTb020r/FsYoPwQcAAABwI+iUo/yCfJmbPle252w3zdC0WVtsldiw96PBx13x2TRbVu5a6Q4+7opPi37SJLlJhRwfAAAAUNEIOg7gGXy08rNi1wqz/MS6J3r18Skq+PirOGnfohfPfZGLmQIAACDqEHQcKONAhlcfHzv4tK7b2qupmwYZzz5EvoMlBOpDBAAAAEQ6gk4lCj5zNs4xTd1+y/jNHXy0edp/f/+v7Mnd4/exGnY0EG0YsYFmbAAAAIgaBJ1KaNeBXe6Kzxdrv5CN+zYGfcysYbNMJQgAAABwUtDhgqEO0qB6A7m8w+Xy0vkvyRMDnwjpMfM3z5ejBUfL/NgAAACA8kTQcahQL0I66rtRUvup2nLW+2fJmNlj5Jv130jO4ZwyPz4AAACgLHHBUIfSIaXTXkyTrdlbCw1GYPfR0dHaPrj0A/lp608yL32e/LD5B9lzaI9UiakiXVK7SJ9mfeRPzf9k5uEOaQ0AAACUBfrowD3qmvIMO4FGXSuwCmR15moTeOzgs27POrMurXaaV/Dp2LCjCUQAAABAeSLoIOB1dJolN5MJ504IaWjpHft3yA/pP7jDz9IdS02fntpJtaVX017u4NOjSQ+pGl+Vdx0AAABliqADr2Zsc9Pnyvac7abvjg49HVsltljv0IG8A7Jw60J38Plxy4+SfThb4qvES9dGXU3wscOPDo5QEccIAAAA5yLooFxoQNHr93g2d0vPSjfr2tRr49XcTe/HxLiazQWrOuk1fl4890UuaAoAAAAvBB1UmM1Zm93BR6flO5ebPkL1q9X3Cj7dGneTL9Z8YfoR+Q6YEKgfEQAAACq37BCvo8OoayhzWblZ8tOWn9zhZ8HWBXLwyEFJjE00AScvP8//f06JMZWdDSM20IwNAAAABkEHEetI/hH5Zccv8s9l/5RXfn4l6Pazhs2S/mn9y+XYAAAA4Iygw/jAKHfxsfFyapNTTfO1UNz65a1y/8z7ZdqqabItZ1uZHx8AAACiX1xFHwAqLx1dLRTat+eDXz+QZ+Y/Y+5rc7bTmpwmPZv2NHPt61MtvloZHy0AAACiCUEHFUaHkNbQsjV7a6HBCDz76GjTNR1qWrfT/j3a30fno2ePNn19YmNipVNKJ+nZpKec1vQ0E37a1m/LBU0BAAAqMQYjQIXSoaV11DXlGXZCGXVNL1y6ImOFO/jotGrXKrOfWom1zEVMNfTY4Sec6/oAAAAgMjEYAaKGv+voNEtuJhPOnRD20NI6wtvP236WBVtcwUdD0K6Du8y6VnVauYLPsWZvXVK7SGJcYsj75qKmAAAAFY+gg6hSViHCsizZuG+jq+KzZYH8tPUnWbp9qRzOPywJsQkm7Hg2edMwxEVNAQAAIhdBBwhAr9uzbMcyr/4+6/ascw98YFd9NPxo87fvNnzHRU0BAAAiBEEHCMPug7tl4daF7uCjt/fm7jXr4qrEmf5A/nBRUwAAgPJF0AFKoMAqkLW718q7v7wrT/3wVNDtZ147U8484UzecwAAgAgJOgwvDfhRJaaKGaL65JSTQ3p/zvvgPOnauKt0a9TNTN0bd5cODTqYi6MCAACg/BF0gFK4qOlfu/9Vsg9ny5xNc+T1Ra+bIa4TYxOlc2pnd/jRC5t2bNCR8AMAAFAOCDpAKVzU9MVzX3SPErc/b7/8suMXWbxtsSzevtiEn4mLJ5rmcBp+tEpkV30IPwAAAGWDC4YCZXhRU9uBvAMm/CzatsiEH51+z/y9UPjR4KPzkxqeVKzKD9f6AQAATpcdYh8dgg5Qzhc19Q0/dvDRCtCqzFUm/Og1fjqndPYKPx0bdjTLwzlGu9pU3GMEAACINAQdoJSVR7UkWPjxavbmEX7sqpNv87pwqk4AAADRgKADOISGn2U7l7n7/GjzN8/w06lhJ9MM7sCRA34fz7V+AACAkzC8NOAQ1ROqS+9mvc3kL/x8ufbLgCFHaZVnc/ZmU43qn9a/nI4aAACgYjHqGhDl4ad+tfry9R9fB33M5R9dbrbXvj9mSu0sreu2NtcMAgAAcBqCDlBJrvVzzgnnyN7cvfL20rdl+/7tZlm1+Gqm6VuX1C7u8KP3aybWLOOjBgAAKFsEHaCSXOvn/Uvfdw+ekHEgQ5btWGaav+k0f/N8eWvpW3K04KhZf0KdE0zo8az+tKjVQmJiXIMblARDYAMAgPLA8NKAA5TGtX4OHz1sBjnQAKQjv9khaM+hPWZ9rcRahcJPxwYdpWp81bCOkyGwAQBASTDqGlDJlMW1fizLkq05W72qPxqC1u5eawKV9u9pW6+tVwDSZnCpNVILVX8YAhsAAJQGgg5QCZVXszAd9e23jN9c4edYCFq+c7nk5OWY9Q2qNfAKPyc1PEku+vdFJjT5wxDYAAAgVAQdAOVKr+uzcd9GV7M3jwqQLgvVrGGzGAIbAAAUievoAChX2oytVZ1WZvJsKpeVmyUv/PiCjPt+XNB9vLv0XROYtO9Pw+oNS2XwAwAAUDkxGAGAMjd742wZ8M8BQbeLqxLnHvmtXtV60rFhRzmpwUlmruFH53rdIAAAUHllZ2dLrVq1JCsrS5KTkwNux/DSACJmCOy1t6+VDfs2yIqMFbJil2uavWm2TFoyyR2AUqqnHA8+x8KPzutUrVMqx8rw1wAAOAMVHQARPwR2Xn6eGenNhJ+MFfLbrt/MfN2edZJv5ZttGtds7BV+dACEDg06SHJicljHyPDXAABENgYjAOD4IbD12j+rd692V4B0JDid/7HnD3eY0v3bVR8NPzpv36C91Eio4TeI+VacwrkWEQAAKHsEHQARqTyahh06ckh+z/zdK/xoGNJmcba02mnu8NO+fnu575v7JONAht/9Mfw1AACRg6ADAH6u/7Mqc5Ur/Hj0A0rPSg/pvWL4awAAKh5BBwBC9PbSt+Wmz24Kup1WfrQC1a5+O2lbv620rdfWVIbK4qKsAADAP0ZdA4AQ6bV/QpFaI1UWbF0g7y9/Xw4dPWSWJcYmSuu6rV3hp15brxBUK6lWmXwGjAwHAEBwDC8NoNILdfjrmX+eaao3elHTzVmbzUAIqzNXm/5Aevufy/4pW3O2egUjd/ip19YEIL3dolaLYleBGBkOAIDQMLw0AJRw+GtP+/P2y5rda1zhR0PQbtdcl3lWgU6sd6Ir/IRRBWJkOAAAhD46AFDRw1978qwC+YagoqpAdghqWrOpnPDSCV7H5omR4QAAlUV2drbUqlVLsrKyJDk58PXyqOgAQAX3f8k5nGMqPu4QdKxJnM5zj+aabeKrxMuRgiNB98XIcAAAp8sm6ABAdLOrQBp+Pvz1Q3lv+XtBH3NJ20vk4nYXmwESdEqpniIxMa7mdwAAOAGjrgFAlKsSU0Va1G5hpsS4xJCCzrz0efLp6k/d96vHV5cT6p7gCj51Wh+/Xbe1GWBBn6MsMDIcAKCiMeoaADhoZLgNIzbI4fzDsmHvBlm3Z52Z/tj7h5lPWTlFNmVtMpUie1CElnVa+g1BOjJcfGx8sY6VkeEAAJGAPjoAUIlGhsvLz5NN+zYVCkE6rd+73t0PKDYm1lSS7BCkczsI6XWHkuKSijxG3zAW7uh1AAAEQh8dAHCgshwZTpub6X79hSCd7OGxNbQ0SW5SKAS1rN1SBv1nkGzL2eZ3/4wMBwAoDQQdAHCoiuj/YlmW7Ni/I2AIyjqcFfK+GBkOAFASBB0AQLnQELTn0B559edX5ZHZjwTdvkG1BnJSw5MkrXaambQSZN9uXLNxmYc2GwMmAEB0YtQ1AEC50OGr61WrJ31b9A1p+zNbnWkGRFi5a6V8tfYr2Xlgp3tdXJU4aV6ruSv41EozgyXYIUinRjUalUoQYsAEAHA+BiMAAJRahSTtxbSQRobzDCsHjxw0AyRs3Lfx+JS10Ywcp7d3Hdzl3lYvnGoHIc9KkDsI1WwUdMhsBkwAgOhG0zUAQFSODOfrQN4BMyy2HYJMAMo6HooyD2a6t02ITTBByF8I0kmbzbX6RyuvwRw8MWACAEQ+gg4AwHEjw/mzP2+/uyK0YZ+rCuQ57T6026siZA+hXRQGTACAyEXQAQBUmEjq6J9zOMcdej5Z+Yn8c/k/gz5GK0KdUztL05pNpVmtZiao6Vyb3jWp2aTYF1ON5vcRACrFYASvvvqqPPvss7J9+3bp2LGjTJgwQfr2Dd4J9YcffpB+/frJSSedJL/88ktxnhoAEAX0ZLx/Wn+JBDUTa0qnlE5m0tuhBJ0ODTpI7tFcmbVxlqlMeQ6frc3bUmukmtBjhyBz2yMM6ehxOrBCSTBgAgCU82AEkydPlj//+c8m7PTp00cmTpwob775pqxcuVKaN28e8HGauLp27SqtW7eWnTt3hhV0Qk1tAACUxYAJWhXanL3ZhJ7NWZuP387e7L6vTehsOiCCjhDnGYbcgejYfQ1LgaozDJgAABXQdO20004zgeW1115zL2vfvr1ccskl8uSTTwZ83FVXXSUnnniixMbGyqeffkrQAQA4ZsAE/VOafTjbHXzcIcgnHOkIc7bYmFhT+bGrQHYY0iZqt//vdsk4kOH3uRgwAUBll10WTdfy8vJk8eLF8sADD3gtP/vss2X+/PkBH/fOO+/IH3/8If/617/kscceC/o8hw8fNpPniwEAoDRoiNEw4ztggoaN4g6YoNcSqpVUy0x6MdRAYWhf7r6AYWjp9qXmtjaZK4qGM93u+R+fl3Nbn2sqR3odo2DDapcF+hABiGRhBZ3MzEzJz8+XlJQUr+V6f8eOHX4fs3btWhOM5s6dK3FxoT2dVobGjh0bzqEBABAyDTMXt724XDv6axiqU7WOmU5OOTlgGHpjyRvy1y/+GnR/939zv5ns0eS0KZy+Dq0SafjRydyuefx2g+oNSi0Q0YcIQKSLK+4va99fzL7LlIaia665xoSWNm3ahLz/Bx98UO666y6vik6zZs2Kc6gAAET8gAk2/Vvapl5ofy//c/l/zLWBtuVsk+37t5vAZt/+ccuP5vauA7u8mudpc7mUGilFhiG93bB6wyIHUwjUh0j7Puny4jT/A4AKDTr169c3fWx8qzcZGRmFqjwqJydHFi1aJEuXLpXbbrvNLCsoKDDBSKs7M2bMkIEDBxZ6XGJiopkAAKhstLKkzeiCDZhwRYcrglagjuQfMX19/IUhnS/avki2r9kuOw/slAKrwP04rfroxVULhaAarhB061e3+j02XabHN3L6SFMxi4ShsGleB1ReYQWdhIQE6datm8ycOVMuvfRS93K9f/HFFxfaXjsH/frrr17LdLS27777Tj7++GNp2bJlSY4dAADH0XDw4rkvmsqIhgZ/AyZoX6JQQoRe76dJchMzBQsDGojsAKSByH17/3ZZvnO5TF83XXbs3yH5Vn5IfYge+OYB6ZfWzwQje6oWX03KE83rgMqt2MNLv/7669KrVy+ZNGmSvPHGG7JixQpp0aKFaXa2detWee+99/w+fsyYMYy6BgBAMU7SdVS24g6YUBq06jNp8ST525d/K9bjq8dX9wo+9pRSPaXQMh1goSTXImKIbsC5yuyCoUOGDJHdu3fLuHHjzAVD9eKfX331lQk5Spelp6eX7OgBAKjkKmLAhGC0SVu7+u1C2nbmtTPlpJSTZOf+naZaVGg6mCG/Zvxqbus2h44e8nq8Vq807HgFoGoNTR8jf2GpZkJNd39hrVBpSKR5HVC5hV3RqQhcMBQAgOi+6GowB/IOuELPgQDByGPadXCXV58ilRib6A49OujCwm0Lgz7nrGGzKnxACprXARF0wdCKQNABAMDZF10NN2ztzd3rrgb5BqElO5bIom2Lgu5Hq0Daf6le1XqmemTmnrf9zBNiE0rtddC8Digegg4AAKhUfYhsszfOlgH/HBB0uxu73Ggu8rr70G7ZfXC313zvob1+K1Y1Emp4hZ+6VesGDUe1EmsVugyHXRnzfP9KozJWVhi9DpGEoAMAACrlyW9pNK/TfezL3ec3BLnnfpblHs0ttC9tSmcCkUf4yTuaJ9P/mB70tdC8DiiMoAMAACqtimped/DIwcDB6Nh8z6E9snr3alm3Z13Q/VWNqyoNqjeQ2km1vadEn/t+puTE5BIHz2hpXhepoRtlg6ADAAAqNSc0rxvebbipAGl1yZ6yDmd53d+ftz/g4zXsaOjR5nPBgpHvVCO+hpzw0gkR37yOAR0qn2wGIwAAAJVdpH7TX5qj1x3JPyLZh7O9wo/f6bD/5UUFpVBoGOuS2kVqJtY0AzzoXAOWfVvnerFY335KpSFaKk6R/H8xGhF0AAAAIlhFj15nO1pwVLJyswpVi75e97VMWjIppOZ12jfJX2DzvAaTDuTgGX4KzYtad2xuAlRiTTP6XTQN6BAtVaf8KAljBB0AAIAI54TmdTpgQr8W/Uz/pJy8HMk5nGMqTPbtIucB1vleQNaXBp2k2CTJzssOenw3d71ZOjXsZKpKOlVPqO6+be7He9/XfZdm9Slaqk5ToyiMTV8xXS48+UKuowMAABDJIvVb9LK6OGyoVSZtUldUUNL3bPKKyUH3pX2NjlpH/Y6I54+OkucVhIIEo0L3PbbXC9leOeVKcyHcSK46TY22MJaxReQpIegAAAAgupvXlbTi1D+tvxRYBXLoyCFTeTpw5ICZ29OBPJ/7/tYfDb59qGHKV8PqDc2AEUlxSZIYl+iaxyZ63dcKVqB19v2iHp/oZ5v4KvHmfYmGJoBeYUzfZoIOAAAAnNi8riIrToHYYcoOPlNWTpH7Zt4X9HGXtrtUWtdtbYLS4aOHJTf/2Fzv5x+b+9z3XaZVsOKIrxIvRwqOBN2uW6NuklIjxWwfHxvvPfe3rBTnVaSK/OmdP8n2/dtdBxNi0Ikr1jsCAACASkHDzMVtL4645nX6/Np/RL/l11Djr+KkYaw8j1MHXdCmazqpUxufGtLj7jjtDlN1Kmnw8w1FuUUEJfv+D5t/kH8u+2fQ/cdViTP9l3SUP+1DpXMNSOHOy1OMZVmBh8iIspEVAAAAULlEasUpUqtOJW0CWBIaO/Kt/LDD0Yx1M+TJH548viMqOgAAAHC6SK04RWrVyZe+Vxq2goUx3a6kdDS7uJg4Ux2qKlXDeqxX0AlRlbAfAQAAAEQQDQpabbi609VmHgkhxzOI6aANTZKbeC3X8BAJo5nFHgtjnuErUsOY7/EFQ9M1AAAAoJIOIx4NTQALjQCYazHqGgAAAACHhTGuowMAAADAaWFs+orpcuHJFwYdqIw+OgAAAACiglaY+rYIbWAEgg4AAAAAxyHoAAAAAHAcgg4AAAAAxyHoAAAAAHAcgg4AAAAAxyHoAAAAAHAcgg4AAAAAxyHoAAAAAHAcgg4AAAAAxyHoAAAAAHAcgg4AAAAAxyHoAAAAAHAcgg4AAAAAxyHoAAAAAHAcgg4AAAAAxyHoAAAAAHAcgg4AAAAAxyHoAAAAAHAcgg4AAAAAxyHoAAAAAHAcgg4AAAAAxyHoAAAAAHAcgg4AAAAAxyHoAAAAAHAcgg4AAAAAxyHoAAAAAHAcgg4AAAAAxyHoAAAAAHAcgg4AAAAAxyHoAAAAAHAcgg4AAAAAxyHoAAAAAHAcgg4AAAAAxyHoAAAAAHAcgg4AAAAAxyHoAAAAAHAcgg4AAAAAxyHoAAAAAHAcgg4AAAAAxyHoAAAAAHAcgg4AAAAAxyHoAAAAAHAcgg4AAAAAxyHoAAAAAHAcgg4AAAAAxyHoAAAAAHAcgg4AAAAAxyHoAAAAAHAcgg4AAAAAxyHoAAAAAHAcgg4AAAAAxyHoAAAAAHAcgg4AAAAAxyHoAAAAAHAcgg4AAAAAxyHoAAAAAHAcgg4AAAAAxyHoAAAAAHAcgg4AAAAAxyHoAAAAAHAcgg4AAAAAxyHoAAAAAHAcgg4AAAAAxyHoAAAAAHAcgg4AAAAAxyHoAAAAAHAcgg4AAAAAxyHoAAAAAHAcgg4AAAAAxyHoAAAAAHAcgg4AAAAAxyHoAAAAAHAcgg4AAAAAxyHoAAAAAHAcgg4AAAAAxyHoAAAAAHAcgg4AAAAAxyHoAAAAAHAcgg4AAAAAxyHoAAAAAHAcgg4AAAAAxyHoAAAAAHAcgg4AAAAAxyHoAAAAAHAcgg4AAAAAxyHoAAAAAHAcgg4AAAAAxyHoAAAAAHAcgg4AAAAAxyHoAAAAAHAcgg4AAAAAxyHoAAAAAHAcgg4AAAAAxyHoAAAAAHAcgg4AAAAAxyHoAAAAAHAcgg4AAAAAxyHoAAAAAHAcgg4AAAAAxyHoAAAAAHAcgg4AAAAAxyHoAAAAAHAcgg4AAAAAxyHoAAAAAHAcgg4AAAAAxyHoAAAAAHAcgg4AAAAAxyHoAAAAAHAcgg4AAAAAxyHoAAAAAHCcYgWdV199VVq2bClJSUnSrVs3mTt3bsBtp06dKmeddZY0aNBAkpOTpVevXvL111+X5JgBAAAAoHSDzuTJk2XkyJEyatQoWbp0qfTt21fOO+88SU9P97v9999/b4LOV199JYsXL5YBAwbIRRddZB4LAAAAAGUhxrIsK5wHnHbaadK1a1d57bXX3Mvat28vl1xyiTz55JMh7aNjx44yZMgQeeSRR0LaPjs7W2rVqiVZWVmmKgQAAACgcsoOMRuEVdHJy8szVZmzzz7ba7nenz9/fkj7KCgokJycHKlbt27AbQ4fPmxegOcEAAAAAKEKK+hkZmZKfn6+pKSkeC3X+zt27AhpH88//7wcOHBABg8eHHAbrQxpSrOnZs2ahXOYAAAAACq5Yg1GEBMT43VfW7/5LvPn3//+t4wZM8b082nYsGHA7R588EFTirKnzZs3F+cwAQAAAFRSceFsXL9+fYmNjS1UvcnIyChU5fGl4eamm26SKVOmyJlnnlnktomJiWYCAAAAgDKv6CQkJJjhpGfOnOm1XO/37t27yErO9ddfLx9++KFccMEFxTpQAAAAACiTio6666675M9//rN0797dXBNn0qRJZmjp4cOHu5udbd26Vd577z13yLnuuuvkxRdflJ49e7qrQVWrVjX9bwAAAACgwoOODgu9e/duGTdunGzfvl1OOukkc42cFi1amPW6zPOaOhMnTpSjR4/K//3f/5nJNmzYMHn33XdL63UAAAAAQPGvo1MRuI4OAAAAgDK7jg4AAAAARAOCDgAAAADHIegAAAAAcByCDgAAAADHIegAAAAAcByCDgAAAADHIegAAAAAcByCDgAAAADHIegAAAAgKm3YMEY2bnzU7zpdrusrGsdYcQg6AADAcTi5rBzvY0xMrGzc+EihY9T7ulzXVzSOsez/LwYSV0rPDQAASvEPup4cpaX9vdA6/UNvWfnSsmXFnWBG+vF5nlwqz+O0T4DT0sZJReMYS87+bD0/a8/P2N//0fLGMZb+z0vduiNCegxBBwBQqXCSXjlO0Dm5FLEsS0QKjs09bxeY+963vef27UaN/iL5+dnmcz16dJ80bXqHbNnyD9my5QVp2vROSUkZKocO/WHe8+PPY0+Fl7nuS6kuq117gKSm3mSOcdMmDdpHJDX1Rqld+3TZt2+Ox+Nsvvf9LSu8TUn2k5zcQ1JS/ux1jHpfl+/ZM8Nj+5hCt2NiCi8r6nZxt69TZ6AcPpzudYyNGt0sdeueLdnZC489xvOYjk/H74ufZaXzuEaNbpL8/BxzfPv27ZZQxFiFP7WIk52dLbVq1ZKsrCxJTk6u6MMBgAoRDSfo0XCMgb7tjbRvgX2Pp7yP7/hJcv6x6ah7LpIvmzc/ZyY92W3c+FbZuvUl2br1H9K48f9J48Y3H9tWT5rzy+l2vtfx2rezsn6Q7Oz5x1rrF0jNmj2kZs2uxx5rb2/fLo954ec7cmSv5Odnud/72NgaUqVKNZ/gUVRg8Q4nnkEDcKIDB0QuvFCCZgMqOgAQJSfo0fAtevR/0z9Gmje/T/LzDxw7sS88FRQcCbgu+BTeY/Wk3NX/QP/vFUj16ifLwYMrZcWKKwMGEO9lnsuPhv2YUGzZMt5Mtm3bXjFT6atyrL+Fa25PnvcD39ZvhTUAxJjPIDv7Z4mJqXJsG8/9VilyXqVKfEjbhTaP9bq/adMTx97zWGnW7P5j32pX8fiG277tmnve9rfMtd8Yn9sl299vvw0y719MTLx06vSln2/fJcRl/r/dL8mybdteNWFbj02PsUmTEdKkyf8FqGb4Vj38b1P4fsn2s2XLi7Jly/MSE5MglpUnTZvebSpkxx0Pp951iEC3i/MYq8jtt217zet9dH1x8dcQKm2hVONCqfZ5hvRA+7Zk4cJLQ/odRdABAEecoJd/FUK/OdY/hAUFee55auowOXp0jzmmvLwdkpp6g2zfPkm2b39DUlOvN800du/+8lhY8JyOhrDMFRSKXmaHiaKWue5XqZJ0LES43k/Xe6udXcs20MbExJmTCNc8+OR5kh4XV0fy8jKOrdMT5TipUiXh2Emzvez47UDLXfv1XRZoedH7+vXXi9wnv126zHKfwB9/jOdt++Q+2O3CQcX/CWVwxzulu04u69e/NCIqdp5cHazz3ceoJ3ItWjwskcT1hc8R9zFmZ/8UMe+jHpuenPtWP+Pj60XUMWrI8T3GuLhaEf8+JiSkRMwxen75GAqCDoByEekVk4oOEfotleub9MPHgkOemRcUHHbf1nW1a/c3gcHVhnqcOWmvX/9ySUxsJtu2TfIIHnnHTuqPhxDPdYWXubb1v8x3P65lwb5N029YdbLt2PGumQKzT9w1BHhOoS6Ll9jYamE9dv36h46dYMbJiSe+FnL4sCfXfkLf/vg366HR/4P79y91n1zWqXNGBJ5wHD/53bv3u4g7Pn/N/1SkHCfHWLrvX6Df5xWJYyz997J5/tUi8u+g2xN0AAeI9BARKRUTV5hwhQd7cgUL11SnzpmSm7vBJ0RccSxETPQ4yfcMI55BJPA6f9v5rgu3Tb2reZFIZuYnZnJ9651w7OQ7wZzI67f9x+f+lrm2jY2tGvZjCj+P97Jlywa6v+nv3n15kLCiQaBKhX6Lnpe3vcJPiKLpBDjajs/zuCLlODnGktO/b/6+jLLvh/rNf7kd4zffiNxxh8g//iFpZ3KMxft5GSt1L/9vSI8h6ABBECJK3rxJT+SbNLnNPVrKkSO7TJMmbQusTZpSUq6TGjW6SEbGx8eCR27AMOKacgstO37/+GP9bRN+iPjYTBoiqlRJPHYyryfyiR4n99637W3i4pJD2D60fXne1tClfSLsE/QWLf4uaWmjI+J6EYG+6d+1a0qFn1R64iS9dN+/SAwRUXcCHA3HGIEn6V5f4nkcn5x5ZoX/Hyx0jNq/5KGHRFatcs3PiJwKbcsoOEb3/8XVPSR7yeiQHsOoa4DjR2gaI82a3XssAJT2ZAeLwJOrUhE+1zf8etJ/fPK+n+RnmX0/qZiPS5Tt29+SrVtf9AoRLVq4LjpX3D4CThqJywnHGA0/05H+BUukH19U8jlJjzh6AnzaaSI//yxy6qkiCxboL2qJGJF+fOrrr0XOPff4/enTRc45p3yeu6DANeXnuybP2573v/tO5M9/Pv64t94S6dPn+OMretJjfO45yd68WWpJ8FHXCDqoUNHyx7I0TtyON5vKlfz8Q1JQ4Dn5LtOQcCjsZYcPbzEdwY9zDacaLldTpKQgkx0awp+WLz/P3aTp1FN/CxA8yr86wQl66b+HwZZXhGj5vYNSRIiI7pN0zzBz9Ojx6ciR47e//VbkuuuOb/vqqyI9e7rW2Sfz9u1A87Jcp9PMmSL79h0/Rj1B797d9br8BZBAYaQ420WzKlWOT/peHTki2SIhBR2arjlYNPwxr+h+G9qh2hUUDkpBwUGv267woPODZsSRunXPOzZC01jTrl+Hfc3N3SgrV14TYjDJDTN06FCmVU0w0P4TrtuuyXVfQ0NVMwqT57LNm8e7hyg98cSXihFSyjZk+DZpysiYXOEnvvZx0RSncjTFKer3XiT8X4w60RAifJriRNw3/TNmuCoRSud6vzghQk9q9eS/tKe8PJEXXnC9b/p+6vz660WGDvU+kfcMHoGWlWQbfX2huvVWKbHYWNcUFxfavKh1GnA8Q47Kzna9tiZNjj9eT+b93S5qXWndXrpUZLSfJmHPPecKjZ6Bo7wmz59Vu2q3ZEnI4Y2g42AVHSKKP9LVONm4cbQ0b/6g6cdx8OBad+AIHEqKt87uhxEK18XblP5wxZjgcuDACp/QUbdQEPEOJ97LvQNMktcyVwftmBJ1rj5yJDOiTtwiuV8EJ+ilgxBRyYKEU0OEnlDryb092Sf7vlNpLD98WOSLL46HCHXllSKnnHL8BD/UqbS/uddjio93zfU4bXqcO3aI/Oc/IrVru07mfSd9nH07IUGkWjXvZf62C3eZvXzZMpFHjg8T7/bSSyJ/+lNoQcR37nuSXRL2Cbru1/Mz0vuHDol88EHF/9xYlsijj/o/xsmTRe66q+KP0fNnOUQ0XXN4xaQsmuJo5/LjIeKAex74tm57wOe2/VjX7cOHt3pdFTp0sRIbW/1YQKhmwogrKFRz3w+8zvt2UdtrCNm06TGvazFEQhMcTzS7Ahwo0vsdFLc5k74uzxN9nTxv+94v7jqdZs3S9i3Hn7tqVZFWrfyHDntZaQWGxETXibie6PubdJ1e4n3lysKPHTBApEUL1zYlmeznKc6kJ7mBvkXXdV27Vvz/yUg/Pn8/J74qohlgtB2j/TkvXmy+iKDpWiWumGhfEO0knp+/X1JTr5MjRzKODZfrajLUoMGVkpjYRLZseTloACl821URCYVryNrqxwJD9WPhobr7tja50rlrm+qSnv6U+3oWbdu+E1I4cV2lunJXIvwdn+dxRcpxRkPFBJVQJFdLSrNJk32ioCf+ubmF58VZptMnnxSuRJx8cuAgYt/WeUnYQUGDhE6BbmvTIM+Qo/Qb9NatRU48sXDoCBRIgq33t05PtIOdYBf1Tf/+/SJvvx2536Lr8Zb0/2RlOD7LkvT77pNMz58TTzExUv+++6T52WdX3GdtRcEx5uVJ+oYNknms+eJ+J1d0IqVaUtJv0V2BRJtR7T8WNo7PXeFiv991hbcpvG0ofUG087e/AOK6fTyA+L9th5fjt32XVakSV+wrV0dStYTO1YBDQ0R5V0v0+eyAoCfbvnPfZQcPijzxhMiWLcf7RTRsKHLppceDQzjBpLjhQk/ak5JcwcFzrvtdu7bw9tp8TSsmRQWQotYFe4xOoXxOUfBNf/r770umZwd6H/Xfe0+ae46AVREnwF26SOavvwY+Ae7USZr/8kvFvJeRfnz6Ga9dK23btBHtpRtIkoisXrNGmmv4rgDp0XCM6emuY/RsQunEwQgqqlpSUHDUXAPEFSaOz2vUONlcldyzk3pych/Jy9smq1ZdFyCo2CHlQAgXCIyR2NgaxwKEzmscCxyuZfHxDT3WVfdZ71qm16/Qa5Vonw+t6DRvPkpathwbMdfciPRqSTRUIugXgYgTyX037GZT2i/Cs1ryyisiXbr4DyGhzota5/MHuljHvXOn6xtqDTyeoaN+/cJBJNDtcNZrqNC+CuFUIrSKMnFihX/e6f/6l2QW8U1//X/9q0JDRPqmTdJ22LCiTy6HDZPVp58uzbUJWwVIX7dO2i5fHvgYLUuSli+X1evWVcgJcKQfn8rMySnyM1a5x7ZrLhUjMxqOMTOzUMgJRVQFnU2bnpbdu58I+m3/8UqJK5AcPVo4oHjOQ1kf2oUGXb/s9WKI2dkL3cFDLxqYmNjYK6D4hpfCIcW+n1Sia3doaNCQ4xsidGStSAgR0dDkihCBiOS0Jld2+NBAoJUMz7m/ZSWd+xu96fbb/R+b/g7Wfh066cl/oLmGjaLWhzPXsNG3r2sUJN8gUa+eyPz5FRokCBEll7l9u+QGaVSj63W7igo6kX4CHOnHh4oXVUEnPf0JadSotxw+vNkM6Rs4qARvuuXqcK6BoqbX3A4l3svtdd7b2vOtW1+WTZvGuZtdpaRcW+En59ESIqKhWgJIZa+W6Im2hgPtNK1BwXfuu0wn+xt9u8nVVVeJdOt2vElWqOEjEB3BSQNBoHndukWvX7fONWSqrzfeEDnrLO/gYY86Vd5NmhYtishqRDRUIqIhRJhqWWluVwm4rkdnSX5+vhQUFMgh/b0Rgu3bt8uGDRuOfRFe4DWFuqy42/7xxx8hHePUqVPl559/dj/Ofq2ek7/l4WxrBViu708onn76aWnYsKH7cfZnEmhe3HX+ttmzx/MagQ4NOkovhrh//1J3yEhIaCxVq9YIGkY812vVJJz+I8HChIacSGx2FQ0hgmoJIlK0VUu+/NJ15Wp/ISTUeVHrNJyEQgNB9equpk6ef5T0j5VeP0JHtNJO4MFCSqC5fVurHSUIHnqinnn++a7j9AxXen/8eKl/1lnSPCVFKkqkBwlCRHD2ybhOR48e9ZrsZVu071UIFixYIBkZGe79BZrsfZfmNrt27QrpGG+++WapXr26O4AEmxd3G52K48ILL5RI9/jjj5sWPFWqVDFz38nf8nC2jSliH4dDbBK2ZMkSqVatmrulkefc37Ki1oW7/X4dnKMyBJ2GDa+p8AARLRUTQgQQQdUS/QNtVzt00l/axZnn5IisXu2974suCu0YNCRoEPGc27dr1BDRk3t/2wSb21N8/PEQocHGN0RkZro6V1fUN+h2h9YTT5RcDV2+9HhXrpSkE090telvXjGNXSI+SIRZidCTfvsk/8iRI2U+12nz5s0hHeK9994rNWvWLBRC/AWTcJbp7dJyaxgXvtST1tjYWL9TXFxcwHWBtjmoX3SEICUlRRo0aOB+/qLmoWwT6rabNm2Shx9+OOjxvfLKK9K2bVv3Pu0T/qLul2SZ5/3ly5fL6aefHvQYFy9eLF11kIwKsGTJEummFfcgJk+eHPHHGNVBp3nzhyIiQERTxQSISJFcMfnf/wp3UNfhcksSTnQeShML7X+hgcMOHjq3b9esKek1a0qmBgZ/377ddJPU79tXmrds6T+MaDWkjJtfRUWI2LXL//F50PW6XUUdY6hBYsPWrRK7bJn75F6nvLw8r/v+lpX0/t69e0M6vl69erkrA2VFT3bj4+PNCbrnPNRv/rXpk35DrY9LSkoyc3uyT/zLatn69etl+PDhQY/x888/ly5dugQNKTqVpE9vSU4uH3vssQo5AdbjCyXo9OzZs8JO0LXShYoTVUGnRYv7pWbNpIgJO1RMgAqumNjD9WqQ0EpHCebp+/ZJpt73HYL3WAf1+vpli71Mm055hhHPuXZI12/Z/a0LNi9i2FwTItq2ldxAzcjeekuSPvhAVq9eTYgoSpCQY/t16VLZf+CAOckv7ynUfgdXXHGFhENPhBMSEkwQsKdQ72sYsO/Xrl1bftXhfIMYOXKktGzZ0m8QKY25ToFO7EM9QX/55Zcr9BvqUDRu3FiaNm1a5scDOFFUBR1FtQSI4mqJfsv63/96V0yefVakffviB5Vg3xZrKKlZ010V8Zqnppp5ekGBtH3jDck9ejTgbpISE2X1okXSvF07kbi4ihlaM0hfGV2v20V6iNiwbp3ExcebduH2pCf4Rd0PZZtQ9hHsPbRdf/PNIYWGcCatGOj1HoJtp/0xxo8fH/QY33rrLenUqVNIQUVDgTajKa0T9M8++yzodkOGDKmwEAFEivr165uf/aJ+9+h63a6i1HfIMToi6ERCJQeoVP1LdJ/aTluvjaGTBgzPub9lftalZ2VJpjbj8nX//ccrJnqs/gKJzrX/iHZkD7Te31wn7SAfROaSJZL72mtFbqPj92fm5UnzCgg5RqjXdj42Uo32E9A/CPbJvT33t6y0ttGLO4fiCh2BLQR6kp6YmOie21Og+3aIKGrbnTt3yjPPPBNSW3RtLuQviGhw0KBTVjRIhBJ09PgIEtHLKSeXFXmMkX58Sr940kq7fgml9M/ztdeK/Otfru/4lB5fhX1BJdF5jIsX75dbbunnzKADVJgIrZZosybzw6/X1vCsljz1lPktVT8+Xppr86hQQorvMp2Kau+uQUKvSqzhwnOuf1i0v0hysqti8vLLRY8ipRUTbXZVgR3VS5OGDTsQ6KTNkUpye1uIIzT17qMXLM5zD8sZDv3GX08KdNJQ4Dn3XVa3bt1C22jfDa0yBPPGG2/IySefXGRw0am0+xvYISKUoNO6dWtp06ZNqT8/ykc0ngD7E2knlzoI29SpIpddJtKgQcUfYzScoNvH6XsMenwlLXjqr3n986yNEUo6ZWQ0l127mptGEjr6vvr2W5E1a1wNJ+zvDvW2TvoYf7eLWlfS7XJzm8vhw82Pje0T2hdrBB0g0q5doj/RGjKyso7Pi7idvnOntP3uO/+jNOlx6h90EdFxuty/ZvXbaH/hpHZtkWbN/K8LtEybhoVSMZkwIXjFZPfuMgk6Wt3QsKCTjiJk37an30Lob6BGjRpl+iqEElBCHa7Tkx0odKpatarXbe0EHorbb79dTjzxRL9hJdDcvq3Nm0oaIkIJOlqFoBIRvQgRZXMCrJcy0ctP/fWvIo0aScTwPEbtVjRpkusYI6VVYlEhQv8s6q9ObUygc530T6x929/9stjG/t5Q7+/e7TpGDWQ6ToyewGurUp2KE1DK0jvvHL+tpzvajVRPH3TSPxf+bge772+dTnoqEWxb/f52wYLwXgNBByhutURH4+rd+/i3RfobVTsRhxBOirztr3mX+yc2TqRWLdekIaNWLcnUykGwoWg1bEybJs179XKFlHIYgas4li1bZi4K5htEAgWUUJdr0CkNGTt3SoOGDU3w0GZSnoHEN5iEetueawWjqD4UoXauvvrqqwkRUS7Sg0Q0VCKiJUR40mMcO1Zk0KDIO0b9Bt0ODHZlZ9Mm1zIdv8V3XpJl4W6vLav1eyW9b//InHaaK0AUo7AdEm3I4Dnpn2bfZZ7Lt251vV+e9DtTW5cuIt27H9/ePvkvz2n3bnMFAHNbv/vTcXhef911nWf906T/Jyv6/6X+jNjXNv3hB1cDm2AIOogcFd0sTH9jatjQ63/opNWStWul7R13+O+kfmw0rqSYGFldq5Y0147xRZ1Q61c3dkjxCCqif4jt257L/d32F1D0K7ZQxpbX5wlyEUS7uZWGhNKcQr2i8Y033lhomZ78axiwJ62oeN7XSUeB0pGJfJcH2t532dq1a+Wcc84JenxvvPkmISLKRXqIiJYgQYgoXXpCbg/4qKN3b9vmOnnXZfbc83Z5LtO575+2c88t3uvUE2atCujJvOfc3zLPdTrZXS59t1m40HXS68nzeC++WGTw4ODBJNRl+hrC/Z7Q8wRd/2TrWCdvvHG8KhYJIaKpx8B++n2oOvXUyKnc+b5PoV4/lKCDyKiW6G/5ESNcX3Ho/L33zG+SkP+Y28MMewYVj8ASdJne93NhND3NCDa+h7lw39Ch0rxDh8BBReclbBakIUSbQ2lwOHDggHtaunRpyM2u9AQuWCgJle5LA0OgqWHDhu7b2Xv3ynsffBB0nx998IF069nTK4xox++y6KvhKdTrgqBohIiybY4TqSK5EhGsSqEn8vqnQ0/m7cnzflHrwtk20DptBKC3PU/Mi/M9n/6K1KY/OmkA8J37W6bfvYWy/cyZIl99Ffi59fupv/0tcFDxnJfFGB7RECL8HYMeXySFCKci6FQWFV0tCee6ICtXumq4ejIdHy+r//53aa5fofgLJ573fa9/YtPHat8TDRw6tycdJth3me99rTX37x/8xehv+q5dzYXxPEPIgexsObB9u7ntG1DsKZzloV4Ez59du3aZq1drk6vU1NQiQ0qwSUNOOKNOabOrUILOCe3aSatWrYr9Gp2MEFE5Q0S0NLsqSRVD/wTYk33iX5xlvsvtfhEaKHSu+vU7HnCK26LVM1QkJfm/bd/XIrz+KfG3Tudz5riCRCDXXy+i1xQtKrDYfRvKypAhkR0kCBFl856OHh3Zv2/06hChIOg4WKlVS0Klz6O1RP12PIQpc8uW4NcF0SuUjxsnzevUKRxGtNO6v3Diu0zr3R4VAbsysn//fjNpgLBvm/vbtsn+NWvMbW3SFIr+/fu7r9sRCg0LerVk30mX16tXz3wuvssDbb9x7Vq5PITheifphfF69gzp+CobQkTpIUREZ8VE+zNoSPCdtMjrb/mOHa5+GvorPD3dtQ/986K/bjVY2L9ygwWVcGlhXEOCPWmQ8LxvT3Xr6ihS3v0gfJu7XHSRyJVXBg4hgcKMHkNpFZn1O7JIDhGBjoFqhLNDRKNGImPGSEQj6FRyIVVLkpIKX0Vdw4p+DeYvnGjVpKjwousDfUWmf/00rHhOOvTwb78FfS37pk+XTa1bewWSQrf37ZP9W7YUDi0BHhOsMqJNpWrUqGE6iIfi+mHDpE3btiGFE22OVdZNsfwK8bVURtHQJyIaQ0Q0iNRmV/orSn99a9CwT4R///14SAgUQEIJKf7Whzion7tIrhUE38fMm3f8dtu2rpNhfyEkUDgpap0u16ARTgtgmjRVPoQI+KKiUxoVE6Xj3em1Ge67zzXcR0WeGGmfkc2bQ7uK+uDB0ly/yvMMK4FCgPYz8Q0r2nvt2O2jycmyv2pVyUlMlP3x8ZITGyv7Y2Mlx7Jk/6FDkpOTY0KGPd+wYUNIL+eMIE3tNDxoKNHJ93aDBg0CrvN3275vh5ElP/0k3XSksiCuHzqUaokDKiaEiNLl1CZX+n2OhgQdgUrn4UyhPkbDh6+hQwMHD+1voWEg0KTFbf0MAq0P9njP9drXQis6VCIqn0gPEtFQiUD5IuiUdsXk1lvdN/1WTIrTFExHrCpq0jEBfZeFeA2PvQkJsqFxY8lJSjLT/oSE4wFFy/wikpOfL/uPHJGcAwe8w8q6dV73gwUrHT2rZs2aZtJAUdRQup6effZZc3FB3zCicw0koe6nTKsgFVgtiZYQEQ0VE0R/tcTu96GBQif9FWrfticd6lVP1DVMrF/vetxdd7lGGtIfI/sifIFCSKjVD6166HV6NSTYk+d9DR+NG3uvtyftVvn554H3fffdIn//+/HgUd5FYpozVb4QoQgSiDZRFXR++eUXc3IbCSdFesIWUsUkM1Oa6wUYtTlYKAHFd/L4i6p1Fh3CPjsmRnJq1ZKc5GTJrl5dcqpWlWwNKvXrS05qqmRXqSJ/6POFcFWlM+fODbhOLyBohxLPgKJz7czued/fNr5zPdn2bLK1ZPFi6XasGV1RBg4YIF1DGT65koqWEEHFpHRFc7UklDDiOYW7XovU4dJO4bY2bVzNrnyDSVGTv+00gBSX9h2xv5kO1HdDuyIiNIQIoHKKqqDTT4dLKa1qSXHp13kaULSxdAgKBg6U7JwcyS4oMBWSbK2QHJs0kOTo0LsaUhITJScuTrK1khITI9nVqpkKS7ZWUg4flpzcXNl/8KDpSG/OEuyRxjzoMLw6opaGilCvcP7cc89Jly5dCgUTnXR/ZSrUr0XDaTxeCaslihBR+ZRXtURDgx0mdOQqnftOnst37nRddE5/Veptdcklx0eAt/uYhBJG9FeQBgj9fkvnnpNWX7Qzqn3f3za+k72Nfg9kfy9AB/CSI0QAiFRRFXT8VktK0ixM/9ppaLEvB+tx+0hGhmTv3CnZGRmStXu3uQ5I9r59knXkiAkrPgO5BHSqDoEcSEGBJB45IjWTkqRmQoI7pOi8Qc2acsKx+/Yyz7m/ZVqBCbdaMqB//4qrlkRBs7BoqZagdEVrtUT7jtihxF8ICWW57zp/fUV82SFCJzvseNq8+fjts84SufTS0MJJWX3Xok3GfH9kGUWq+GjOBCBSRW3Q8aJfDWp1IzNTjmo42bJFsrdulazt201Qyd61S7L37JGsffskOztbsg8ckKyDByXbskxo0UnjiOftohqlxVapItW1YbSeUQTx8MMPS6dOnQKGlFBH9Qob1ZJSQ7Wk8imvaol+36K/RjRY6GRf9yPQfe1X4lstOeec453jQxnd3A4YWhGxw4lOOtaI9hfxt86e/C3XJlqe1/CIhpGuok00VEwAIBJFddAZ3qePWFphyc93h5SiruteJSZGamnlpGpVSW7USJJr1pRatWpJwzp1pHW9elKrYUNJrlfPhBCddJ2/29oBXq9G3y2ESsill14qXSvi0rdUSxDBorViYn+vUlQY8bwfLLjopGEnEA0QGi40hOhcv8/RjvSePIuNGsyuvTZwONFQUpZjd0RjJ/VoCBFUTACgEgad2ikpktawodSqU0eS69aV5AYNJFnva4hp3NiEFs+Aotc1KbXrlxR1dlKc7UoZfUsQySpiNC6tdmhLUg0b9tzztjav0oqJVljsCyBefbVrNCtdZl/TRKeiaAtSz3BiT9qNSy8dZd/3Xe/vvl4/xPNXFtWS0keIAADniuqg89TUqRVTLYmCpmH0LYFTaLMs31DiedvfMn/rixpxXfuC6Pgdvv1R1qw5frt/f1en+kDhxL5dlmN4UC0BAKCSBJ2KVL9xY0lKTJTcIs6edL1uV1HoW1I5RVKzMK2CaNDQJld//CGi14jVzuorVrjWa5MhDQe6TAONfi/gG1CKqqBo0y4NGDrpULv2XEfj0iGCPZf5bud5WysnVEtKH9USAEBFiu6gU0HNwtwVkzVrGI0Ljm0WphdM1ACiIcUOK/Y81GXBrlv7xRfHb59wgoh2e0tL8x9G/C3TPiel1RqVagkAAM4StUEnSasqeqZTgaiYVD6RVC0JRqsju3YVP6RoNUXDjj/aPEuH6LUnDR72kL2+y+y5Ho9WeLRT/OrVrveQ0biKj2oJAAAOCjpzJk2SGvoVroac1q2l+YknVvQhoZIpz070WrDUZlt79x6fNIB43reX6XFpqNFwsmeP6/E9ewbet4YN30DSpIlIx47+Q4rvMt9O8uHS5mqRPBpXNIzEBQAAHBR0ugwZYkZPA6KFfV3aYEEl0LJAY1lo3q9TxxU8dJ6R4d1x3tctt4g88MDxJl/a8R6BUS0BACD6cbqDiBGpzcK2bRNZu9YVWBYudC3T49ThgnWZhhkNJP6Cis4DNf/SwKEhxTOw6NgVvst87+tchzD2FG0d6amYAACAshZjWRXYoz9E2dnZ5no4WVlZVHQcTE/QtTP64sVl05xJL/So/U+0aZc97d7tfd/fpNsU9VOi4UM70vsGE39hxV6mlZWyqqqU9fsIAAAQDdmAig6ijg5DrNWScAOLVlf8BRatjtSrJ1K37vGpQ4fjt3UIY32chhOt7jz6qMg//iHSq5frKvORVi0BAAAAQafSiMRmYVphWbXK1bdEKy1agVBPPeXqrK7L9Gr2ehFHz8CizcUC9VvxDCsaXnQUMM9l/qZj41uEXC3RoNOnT+RWS2gWBgAAQNCpNMp6tDDto6IhJDPTVV2x5563fZdpVcZfhWXKlOO3W7YU6d7d1TTMM8D4hhVtEqYjgYGO9AAAAIqmayhEr3USLKT4LtPqiy8dflgDiAYT7biv87ZtXXN7mTb9spuFpaeL3HMPnegBAABQcgQdh1dxNm1yVU5+/NG17PXXXeFD+6vYF3D0DS4HDhTel/ZT8QwoOu/cufAyz9v6PPq4cJqFRfK1VRTDDgMAAEQHgk4U9YHRykdOjuvCkDppMLFv+7u/ZUvh67DokMO2hg1dF4jUUNKq1fGA4i+0aMWlJBeIBAAAAMoTQacC+8BoZ3zt1xJqcNH72jnflw5X3KCBK5TovFMn1zwhwVVR0crKzp0ijz8u8tJLrtHCNLRE2mhhdKIHAABAaSHolDINFEuXhhZa/F2fRYOJBhY7tOjUpo13kLEne7v4+NCahWnQ6d2bZmEAAABwvqgKOjt2uK4mX170ivZaccnIcE0aYuzbOmnn+a1bXX1gNLyo88/33oeOBOYZTlq0cI0i5i+06FyrM9pBHwAAAEAlCjpa3SiJgwe9w4pvePFcplUXbV7mSZuDpaS4+rfoSGPr1gV+rgcfFHniCYkINAsDAABAZRJVQccfDSLaBKyo4OK53N+IYtrZXoOLPbVr531fJzvc6IUs7U752i9HJ7tp2M03Fx4aOVIwWhgAAAAqk6gKOn//u6spmDYVy84+foFK334uuo0dTHRq316kf3//4UVDTih9XPzx15k/kodGBgAAACqLqAo6339//HaPHiLXXusdaOypRg2GQgYAAAAqs6gKOv/4h0ifPq7bDI0MAAAAwBFBp3PnyG0WRh8YAAAAIHIwkDEAAAAAx4mqoJOaWtFHAAAAACAaEHQAAAAAOE5UBR0AAAAACAVBBwAAAIDjEHQAAAAAOA5BBwAAAIDjEHQAAAAAOA5BBwAAAIDjEHQAAAAAOA5BBwAAAIDjEHQAAAAAOA5BBwAAAIDjEHQAAAAAOA5BBwAAAIDjEHQAAAAAOA5BBwAAAIDjEHQAAAAAOA5BBwAAAIDjEHQAAAAAOA5BBwAAAIDjEHQAAAAAOA5BBwAAAIDjEHQAAAAAOA5BBwAAAIDjEHQAAAAAOA5BBwAAAIDjEHQAAAAAOA5BBwAAAIDjEHQAAAAAOA5BBwAAAIDjEHQAAAAAOA5BBwAAAIDjEHQAAAAAOA5BBwAAAIDjEHQAAAAAOA5BBwAAAIDjEHQAAAAAOA5BBwAAAIDjEHQAAAAAOA5BBwAAAIDjEHQAAAAAOA5BBwAAAIDjEHQAAAAAOA5BBwAAAIDjEHQAAAAAOA5BBwAAAIDjEHQAAAAAOA5BBwAAAIDjEHQAAAAAOA5BBwAAAIDjEHQAAAAAOA5BBwAAAIDjEHQAAAAAOA5BBwAAAIDjEHQAAAAAOE6xgs6rr74qLVu2lKSkJOnWrZvMnTu3yO3nzJljttPtW7VqJa+//npxjxcAAAAASj/oTJ48WUaOHCmjRo2SpUuXSt++feW8886T9PR0v9tv2LBBzj//fLOdbv/QQw/JHXfcIZ988km4Tw0AAAAAIYmxLMuSMJx22mnStWtXee2119zL2rdvL5dccok8+eSThba///775bPPPpNVq1a5lw0fPlyWLVsmP/74Y0jPmZ2dLbVq1ZKsrCxJTk4O53ABAAAAOEio2SAunJ3m5eXJ4sWL5YEHHvBafvbZZ8v8+fP9PkbDjK73dM4558hbb70lR44ckfj4+EKPOXz4sJls+iLsFwUAAACg8so+lgmC1WvCCjqZmZmSn58vKSkpXsv1/o4dO/w+Rpf72/7o0aNmf40aNSr0GK0MjR07ttDyZs2ahXO4AAAAABwqJyfHVHZKJejYYmJivO5rmvJdFmx7f8ttDz74oNx1113u+/v27ZMWLVqYfkBFvRiUf5rW8Ll582aaFEYQPpfIxOcSmfhcIhOfS2Tic4lMlfFzsSzLhJzGjRsXuV1YQad+/foSGxtbqHqTkZFRqGpjS01N9bt9XFyc1KtXz+9jEhMTzeRLQ05l+QCjiX4mfC6Rh88lMvG5RCY+l8jE5xKZ+FwiU2X7XGqFUPwIa9S1hIQEM0z0zJkzvZbr/d69e/t9TK9evQptP2PGDOnevbvf/jkAAAAAUO7DS2uTsjfffFPefvttM5LanXfeaZqU6UhqdrOz6667zr29Lt+0aZN5nG6vj9OBCO65554SHzwAAAAAlEofnSFDhsju3btl3Lhxsn37djnppJPkq6++Mn1olC7zvKaOXlhU12sgeuWVV0xbun/84x9y+eWXh/yc2oxt9OjRfpuzoeLwuUQmPpfIxOcSmfhcIhOfS2Tic4lMfC6leB0dAAAAAHBc0zUAAAAAiHQEHQAAAACOQ9ABAAAA4DgEHQAAAACOEzFB59VXXzUjtCUlJZlr9cydO7fI7efMmWO20+1btWolr7/+erkda2Xw5JNPyqmnnio1a9aUhg0byiWXXCKrV68u8jGzZ8+WmJiYQtPvv/9ebsftdGPGjCn0/upFeYvCz0rZS0tL8/t////+7//8bs/PStn4/vvv5aKLLjKje+r7/+mnn3qt17F39GdI11etWlX69+8vK1asCLrfTz75RDp06GBGNtL5tGnTyugVVL7P5ciRI3L//fdLp06dpHr16mYbvUTFtm3bitznu+++6/dnLjc3txxeUeX4ebn++usLvb89e/YMul9+Xsr2c/H3/16nZ599NuA+363EPy8REXQmT54sI0eOlFGjRsnSpUulb9++ct5553kNU+1pw4YNcv7555vtdPuHHnpI7rjjDvPDhdKhJ8d6kvbTTz+ZC74ePXpUzj77bDlw4EDQx2og0mHG7enEE0/kYylFHTt29Hp/f/3114Db8rNSPn7++Wevz8S+SPKVV15Z5OP4WSld+vupc+fO8vLLL/td/8wzz8gLL7xg1utnpl8SnHXWWZKTkxNwnz/++KO5rMKf//xnWbZsmZkPHjxYFixYUMpHXzk/l4MHD8qSJUvk73//u5lPnTpV1qxZI4MGDQq6X70CvOfPnU765SdK/rnYzj33XK/3Vy8XUhR+Xsr+c/H9P6/Xp9TQEuyyLZX258WKAD169LCGDx/utaxdu3bWAw884Hf7++67z6z39Ne//tXq2bNnmR5nZZaRkaHDkFtz5swJuM2sWbPMNnv37i3XY6tMRo8ebXXu3Dnk7flZqRgjRoywTjjhBKugoMDven5Wyp7+Lpo2bZr7vn4Wqamp1lNPPeVelpuba9WqVct6/fXXA+5n8ODB1rnnnuu17JxzzrGuuuqqMjryyvW5+LNw4UKz3aZNmwJu884775jPDmX3uQwbNsy6+OKLw9oPPy/l//Oin9HAgQOL3OadSvzzUuEVnby8PFm8eLGpFnjS+/Pnzw/4jYHv9uecc44sWrTIlMFR+rKyssy8bt26Qbc95ZRTpFGjRnLGGWfIrFmz+DhK2dq1a01JW5t6XnXVVbJ+/fqA2/KzUjG/0/71r3/JjTfeaL5lKwo/K+VHq5s7duzw+tuhTdH69esX8G9NUT9DRT0GJf97oz87tWvXLnK7/fv3m4uVN23aVC688ELTwgOlS5vZavP1Nm3ayM033ywZGRlFbs/PS/nauXOnfPnll3LTTTcF3XZ/Jf15qfCgk5mZKfn5+ZKSkuK1XO/rHyV/dLm/7bV5le4PpUu/VLjrrrvkT3/6k5x00kkBt9NwM2nSJNOEUJsftG3b1oQdbW+K0nHaaafJe++9J19//bW88cYb5mehd+/esnv3br/b87NS/rQ99b59+0z79kD4WSl/9t+TcP7W2I8L9zEoPu0z8MADD8g111xjmtoE0q5dO9Pv4LPPPpN///vfpglOnz59zBdBKB3aheCDDz6Q7777Tp5//nnT3HPgwIFy+PDhgI/h56V8/fOf/zR9qS+77LIit2tXiX9e4iRC+H7zqSfXRX0b6m97f8tRcrfddpssX75c5s2bV+R2Gmx0svXq1Us2b94szz33nJx++ul8FKX0h8emnXf1PT7hhBPMLzsNo/7ws1K+3nrrLfM5adUtEH5WoudvTXEfg/BpiwytUhcUFJgBioqineI9O8brSVvXrl3lpZdekn/84x+8/aVA+6bZ9EvO7t27m4qAVhCKOrHm56X8aP+coUOHBu1r07MS/7xUeEWnfv36EhsbW+jbMS2P+n6LZtMOpP62j4uLk3r16pXp8VY2t99+u/kGQJugabkzXPqDVRm+MagoOkqRBp5A7zE/K+Vr06ZN8s0338hf/vKXsB/Lz0rZskcnDOdvjf24cB+D4oUcHeRBmxjqYB5FVXP8qVKlihkplL83ZUcr0Rp0inqP+XkpPzo6sQ5oU5y/N1Uq0c9LhQedhIQEM0y0PUqRTe9rkxx/9Fts3+1nzJhhvm2Ij48v0+OtLPQbS63kaBM0LVtrf5Di0Dag+ssRZUObEKxatSrge8zPSvl65513THv2Cy64IOzH8rNStvR3mJ6Eef7t0P5UOsJkoL81Rf0MFfUYFC/k6EmXflFQnC8s9W/WL7/8wt+bMqRNpLWVRlF/0/l5Kd/WA3r+rCO0hcuqTD8vVgT4z3/+Y8XHx1tvvfWWtXLlSmvkyJFW9erVrY0bN5r1Ovran//8Z/f269evt6pVq2bdeeedZnt9nD7+448/rsBX4Sx/+9vfzAgds2fPtrZv3+6eDh486N7G93MZP368GR1kzZo11m+//WbW63+xTz75pIJehfPcfffd5jPRn4GffvrJuvDCC62aNWvysxIB8vPzrebNm1v3339/oXX8rJSPnJwca+nSpWbS3z0vvPCCuW2P3qUjrunvtalTp1q//vqrdfXVV1uNGjWysrOz3fvQ32meI37+8MMPVmxsrHnsqlWrzDwuLs78/KHkn8uRI0esQYMGWU2bNrV++eUXr783hw8fDvi5jBkzxpo+fbr1xx9/mH3dcMMN5nNZsGABH0spfC66Tv/ezJ8/39qwYYMZKbJXr15WkyZN+Hmp4N9jKisry5wHv/baa373wc/LcRERdNQrr7xitWjRwkpISLC6du3qNYyxDnHYr18/r+31ZO+UU04x26elpQX8sFE8+sPlb9IhCgN9Lk8//bQZUjcpKcmqU6eO9ac//cn68ssv+QhK0ZAhQ8yJmQb7xo0bW5dddpm1YsWKgJ+J4melfHz99dfmZ2T16tWF1vGzUj7sYbt9J33/7SGmdYh2HWY6MTHROv30003g8aQ/P/b2tilTplht27Y1P3d6aQO+vCm9z0VPogP9vdHHBfpc9AtR/WJBzwEaNGhgnX322eakHKXzueiXmvqe6nur/+/1vdbl6enp/LxU8O8xNXHiRKtq1arWvn37/O6Dn5fjYvSfiq4qAQAAAICj+ugAAAAAQGkj6AAAAABwHIIOAAAAAMch6AAAAABwHIIOAAAAAMch6AAAAABwHIIOAAAAAMch6AAAAABwHIIOAAAAAMch6AAAAABwHIIOAAAAAMch6AAAAAAQp/l/AfIgHVerXbYAAAAASUVORK5CYII=", - "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": "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", - "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": "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", - "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": "iVBORw0KGgoAAAANSUhEUgAAAz8AAANCCAYAAABI6XJcAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy80BEi2AAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOzdeVxN6R8H8M9tubfbirSSsqUi2YmhLNVgBmPfot/YlyzNGIMxlRkMZsYSMmZsgwaDDMM01jLKmrKmLCVDqSxRWqTv748zHd26pSi35ft+ve6Lzvo9z733nPO9z3OeR0JEBMYYY4wxxhir4tRUHQBjjDHGGGOMvQ+c/DDGGGOMMcaqBU5+GGOMMcYYY9UCJz+MMcYYY4yxaoGTH8YYY4wxxli1wMkPY4wxxhhjrFrg5IcxxhhjjDFWLXDywxhjjDHGGKsWOPlhjDHGGGOMVQuc/LBKae3atdi8efN72deLFy/g4+OD4ODg97K/qurUqVMYO3YsWrduDZlMBolEgri4OFWHxRhjZYavTZUPX5uqH05+WKX0vi8wvr6+fIF5R8eOHcPRo0dRr149dOzYUdXhMMZYmeNrU+XD16bqh5MfxiqYFy9eqDqEcjF//nzExcUhMDAQvXv3VnU4jDHGSoGvTayq4OSHvRenTp1C9+7doaenB21tbXTs2BEHDx5UWMbHxwcSiaTQups3b1aohrayssK1a9cQEhICiUQCiUQCKysrAEBwcDAkEgm2bdsGLy8vmJqaQi6Xw8nJCREREQrbdXZ2hrOzc6H9eXh4iNuLi4uDkZERAMDX11fcn4eHR5HHWpoYPDw8oKuriytXrsDV1RV6enro3r07AODx48eYPHky6tSpA6lUigYNGmDevHnIyspS2EZubi78/PzQokULyOVy1KhRAx06dMD+/fsVltu5cyccHR2ho6MDXV1duLm5FYrnzp07GDp0KMzNzSGTyWBiYoLu3bsjMjJSXOb48eNwdnaGoaEh5HI56tWrhwEDBrzxwqimxqcbxljFwtcmvjbxtan64XeclbuQkBB069YNqamp2LBhA3777Tfo6enh448/xs6dO0u9vcDAQDRo0AAtW7bE6dOncfr0aQQGBiosM3fuXNy5cwe//PILfvnlFzx48ADOzs64c+dOqfZlZmaGoKAgAMCYMWPE/c2fP/+N65Y0huzsbPTp0wfdunXDH3/8AV9fX2RmZqJr16749ddf4eXlhYMHD2LkyJFYunQp+vfvr7C+h4cHpk+fjrZt22Lnzp3YsWMH+vTpo9BmedGiRRg2bBjs7Oywa9cubN26Fc+fP0fnzp1x/fp1cblevXohPDwcS5cuxZEjR+Dv74+WLVvi6dOnAIQLbu/evSGVSrFx40YEBQXhu+++g46ODrKzs0tVtowxpkp8beJrE6umiLFy1qFDBzI2Nqbnz5+L03JycqhZs2ZUt25dys3NJSIib29vUvaR3LRpEwGg2NhYcVrTpk3Jycmp0LInTpwgANSqVStxu0REcXFxpKmpSWPHjhWnOTk5Kd3G6NGjydLSUvw7OTmZAJC3t3eJjrc0MYwePZoA0MaNGxW2sW7dOgJAu3btUpi+ZMkSAkCHDx8mIqKTJ08SAJo3b16R8cTHx5OGhgZ5enoqTH/+/DmZmprS4MGDiYgoJSWFANCKFSuK3Nbu3bsJAEVGRr6hFIq3bNmyQu8pY4y9T3xtKjoGvjbFvtN2WMXGNT+sXKWnp+Ps2bMYOHAgdHV1xenq6upwd3fHv//+i+jo6DLf7/DhwxWaKVhaWqJjx444ceJEme+rLGIYMGCAwt/Hjx+Hjo4OBg4cqDA9r0nDsWPHAAB//fUXAGDKlClFxvH3338jJycHo0aNQk5OjvjS0tKCk5OT+LBsrVq10LBhQyxbtgw//vgjIiIikJubq7CtFi1aQCqVYvz48diyZUupf61kjLGKgK9NfG1i1RcnP6xcPXnyBEQEMzOzQvPMzc0BAI8ePSrz/ZqamiqdVh77etcYtLW1oa+vrzDt0aNHMDU1LdTO3NjYGBoaGuI2kpOToa6urnRfeR4+fAgAaNu2LTQ1NRVeO3fuREpKCgBAIpHg2LFjcHNzw9KlS9GqVSsYGRlh2rRpeP78OQCgYcOGOHr0KIyNjTFlyhQ0bNgQDRs2xMqVK0tZOowxpjp8bXpzDHxtYlWVhqoDYFVbzZo1oaamhoSEhELzHjx4AACoXbs2AEBLSwsAkJWVBZlMJi6XdwIsjcTERKXTDA0Nxb+1tLSQmppaaLm32d/bxgBA6YO0hoaGOHv2LIhIYX5SUhJycnLEMjMyMsKrV6+QmJio9CIOvC7f3bt3w9LSstiYLS0tsWHDBgBATEwMdu3aBR8fH2RnZ2PdunUAgM6dO6Nz58549eoVLly4AD8/P8yYMQMmJiYYOnRosdtnjLGKgK9NxccA8LWJVV1c88PKlY6ODtq3b4+9e/ciIyNDnJ6bm4tt27ahbt26sLa2BgCxF5vLly8rbOPAgQOFtiuTyRS2V9Bvv/0GIhL/vnv3LsLCwhR60LGyskJMTIxCDzWPHj1CWFhYoX0BKHZ/bxtDUbp37460tDTs27dPYfqvv/4qzgeAnj17AgD8/f2L3Jabmxs0NDRw+/ZttGnTRulLGWtra3z11Vewt7fHxYsXC81XV1dH+/btsWbNGgBQugxjjFVEfG3iaxOrvrjmh5W7xYsXw8XFBV27dsXnn38OqVSKtWvX4urVq/jtt9/EX4969eqFWrVqYcyYMViwYAE0NDSwefNm3Lt3r9A27e3tsWPHDuzcuRMNGjSAlpYW7O3txflJSUn45JNPMG7cOKSmpsLb2xtaWlqYM2eOuIy7uzt++uknjBw5EuPGjcOjR4+wdOnSQtX8enp6sLS0xB9//IHu3bujVq1aqF27tnhBLEpJYijKqFGjsGbNGowePRpxcXGwt7fHqVOnsGjRIvTq1Qs9evQAIPzS5e7ujm+//RYPHz7ERx99BJlMhoiICGhra8PT0xNWVlZYsGAB5s2bhzt37uDDDz9EzZo18fDhQ5w7dw46Ojrw9fXF5cuXMXXqVAwaNAiNGzeGVCrF8ePHcfnyZXz55ZcAgHXr1uH48ePo3bs36tWrh8zMTGzcuBEAxJiKkpycjJCQEADAlStXAAjtwo2MjGBkZAQnJ6c3lgtjjJUVvjbxtQnga1O1pLq+Flh18s8//1C3bt1IR0eH5HI5dejQgQ4cOFBouXPnzlHHjh1JR0eH6tSpQ97e3vTLL78U6n0lLi6OXF1dSU9PjwCIPeDk9WazdetWmjZtGhkZGZFMJqPOnTvThQsXCu1vy5YtZGtrS1paWmRnZ0c7d+4s1KMOEdHRo0epZcuWJJPJCACNHj26yGMtTQyjR48mHR0dpdt59OgRTZw4kczMzEhDQ4MsLS1pzpw5lJmZqbDcq1evaPny5dSsWTOSSqVkYGBAjo6Ohcp337591LVrV9LX1yeZTEaWlpY0cOBAOnr0KBERPXz4kDw8PMjGxoZ0dHRIV1eXmjdvTsuXL6ecnBwiIjp9+jR98sknZGlpSTKZjAwNDcnJyYn2799fZHkULBdlL2U9GzHGWHnjaxNfm/jaVP1IiPLVfTJWyQUHB6Nr1674/fffC/VGU51iYIwxVnFUhOtCRYiBsYqAn/lhjDHGGGOMVQuc/DDGGGOMMcaqBW72xhhjjDHGGKsWuOaHMcYYY4wxVi1w8sMYY4wxxhirFjj5YYwxxhhjjFULlXKQ09zcXPH/eYOQMcYYez/yPyqqpsa/oeXhaxNjjKlGaa5LlTL5AYDMzExVh8AYY9WalpaWqkOocPjaxBhjqlOS61KlTX4A4QD51zXGGHu/iIhv8ovB1ybGGHu/SnNdqpTJT95FRSKR8AWGMcZUhM+/ivjaxBhjqlWScy831maMMcYYY4xVC5z8MMYYY4wxxqqFUiU//v7+aN68OfT19aGvrw9HR0f89ddf4nwigo+PD8zNzSGXy+Hs7Ixr164pbCMrKwuenp6oXbs2dHR00KdPH/z7779lczSMMcYYY4wxVgQJ5e8b7g0OHDgAdXV1NGrUCACwZcsWLFu2DBEREWjatCmWLFmChQsXYvPmzbC2tsa3336LkydPIjo6Gnp6egCASZMm4cCBA9i8eTMMDQ3x2Wef4fHjxwgPD4e6unqJ4iAiZGRkQC6XK7Tte/XqFV6+fFma42eMMVaApqZmsefjos7B1R2XC2OMqUZpzr+lSn6UqVWrFpYtW4ZPP/0U5ubmmDFjBmbPng1AqOUxMTHBkiVLMGHCBKSmpsLIyAhbt27FkCFDAAAPHjyAhYUFDh06BDc3t7c6QCJCYmIinj59+i6Hwhhj7D81atSAqamp0osI3+Qrx+XCGGOqUZrz71v39vbq1Sv8/vvvSE9Ph6OjI2JjY5GYmAhXV1dxGZlMBicnJ4SFhWHChAkIDw/Hy5cvFZYxNzdHs2bNEBYWVuLkp6C8xMfY2Bja2tp80WGMsbdERHjx4gWSkpIAAGZmZiqOiDHGGCs7pU5+rly5AkdHR2RmZkJXVxeBgYGws7NDWFgYAMDExERheRMTE9y9exeAkKRIpVLUrFmz0DKJiYlF7jMrKwtZWVmKgWsIob969UpMfAwNDUt7OIwxxgqQy+UAgKSkJBgbG5e4STJjjDFW0ZW6t7cmTZogMjISZ86cwaRJkzB69Ghcv35dnF+w1oWI3lgT86ZlFi9eDAMDA/FVt25dcV7eMz7a2tqlPRTGGGNFyDun8nOUjDHGqpJSJz9SqRSNGjVCmzZtsHjxYjg4OGDlypUwNTUFgEI1OElJSWJtkKmpKbKzs/HkyZMil1Fmzpw5SE1NFV/Keofjpm6MMVZ2+JzKGGOsKnrncX6ICFlZWahfvz5MTU1x5MgRcV52djZCQkLQsWNHAEDr1q2hqampsExCQgKuXr0qLqOMTCYTu9fW19cXe45jjDHGGGOMsZIqVfIzd+5c/PPPP4iLi8OVK1cwb948BAcHY8SIEZBIJJgxYwYWLVqEwMBAXL16FR4eHtDW1sbw4cMBAAYGBhgzZgw+++wzHDt2DBERERg5ciTs7e3Ro0ePcjlAVnFs3rwZNWrUUHUYZcrZ2RkzZsx47/sNDg6GRCIRezgsr7KNi4uDRCJBZGSk0v2W574YY4wxxspaqZKfhw8fwt3dHU2aNEH37t1x9uxZBAUFwcXFBQDwxRdfYMaMGZg8eTLatGmD+/fv4/Dhwwo1NcuXL0e/fv0wePBgdOrUCdra2uL4QUzg4eGBfv36lXo9Hx8ftGjRokxiePLkCdzd3cXnrNzd3at1V+JF3fTv3bsX33zzjWqCymfIkCGIiYkp0bKlSZQsLCyQkJCAZs2avUN0hSn7jJfXvhhjjDHG8pSqt7cNGzYUO18ikcDHxwc+Pj5FLqOlpQU/Pz/4+fmVZtfsPRs+fDj+/fdfBAUFAQDGjx8Pd3d3HDhwQMWRlU52djakUmm5bb9WrVrltu3SkMvlYg9dZSWv7PKe5ytv6urq721fjDHGGKue3vmZH/Z2du/eDXt7e8jlchgaGqJHjx5IT0+Hj48PtmzZgj/++AMSiQQSiQTBwcEAgNmzZ8Pa2hra2tpo0KAB5s+fL/bEtHnzZvj6+uLSpUvieps3bwYApKamYvz48TA2Noa+vj66deuGS5cuFRlbVFQUgoKC8Msvv8DR0RGOjo74+eef8eeffyI6OrrI9Z48eYJRo0ahZs2a0NbWRs+ePXHz5s1Cy+3btw/W1tbQ0tKCi4sL7t27J867dOkSunbtCj09Pejr66N169a4cOGCOD8sLAxdunSBXC6HhYUFpk2bhvT0dHG+lZUVvv32W3h4eMDAwADjxo2Do6MjvvzyS4UYkpOToampiRMnTgAAtm3bhjZt2kBPTw+mpqYYPny4OM5JXFwcunbtCgCoWbMmJBIJPDw8ABRu9vamMsirdfn7779ha2sLXV1dfPjhh0hISCiyXAHg0KFDsLa2hlwuR9euXREXF6cwv2BtTlHlGBwcjP/9739ITU0VPyd5P1YoK7uimqKFhobCwcEBWlpaaN++Pa5cuSLOU1YDuWLFClhZWYnzlX3Gle0rJCQE7dq1g0wmg5mZGb788kvk5OSI852dnTFt2jR88cUXqFWrFkxNTYv98YUxxhhj1RsnPyqQkJCAYcOG4dNPP0VUVBSCg4PRv39/EBE+//xzDB48WLwhTkhIEDuD0NPTw+bNm3H9+nWsXLkSP//8M5YvXw5AaPb02WefoWnTpuJ6Q4YMARGhd+/eSExMxKFDhxAeHo5WrVqhe/fuePz4sdL4Tp8+DQMDA7Rv316c1qFDBxgYGIjjOSnj4eGBCxcuYP/+/Th9+jSICL169VLoKvfFixdYuHAhtmzZgtDQUDx79gxDhw4V548YMQJ169bF+fPnER4eji+//BKampoAhDGm3Nzc0L9/f1y+fBk7d+7EqVOnMHXqVIU4li1bhmbNmiE8PBzz58/HiBEj8Ntvv4GIxGV27twJExMTODk5ARBqOb755htcunQJ+/btQ2xsrJjgWFhYYM+ePQCA6OhoJCQkYOXKle9UBt9//z22bt2KkydPIj4+Hp9//nmR5Xrv3j30798fvXr1QmRkJMaOHVsomSuoqHLs2LEjVqxYAX19ffFzkn/fBcuuKLNmzcL333+P8+fPw9jYGH369Clxl8jFfcbzu3//Pnr16oW2bdvi0qVL8Pf3x4YNG/Dtt98qLLdlyxbo6Ojg7NmzWLp0KRYsWKDQqQpjjDHGWJ5SD3JaWSQ8T0BCWvG/ppclM10zmOmVbCT0hIQE5OTkoH///rC0tAQA2Nvbi/PlcjmysrIKNQH66quvxP9bWVnhs88+w86dO/HFF19ALpdDV1cXGhoaCusdP34cV65cQVJSEmQyGQDg+++/x759+7B7926MHz++UHyJiYkwNjYuNN3Y2LjIwWhv3ryJ/fv3IzQ0VLyR3b59OywsLLBv3z4MGjQIgDBmyOrVq8XEasuWLbC1tcW5c+fQrl07xMfHY9asWbCxsQEANG7cWNzHsmXLMHz4cLGmpXHjxli1ahWcnJzg7+8PLS0tAEC3bt0UbuiHDBmCmTNn4tSpU+jcuTMAICAgAMOHD4eampD/f/rpp+LyDRo0wKpVq9CuXTukpaVBV1dXbN5mbGxc5PMypSmDdevWoWHDhgCAqVOnYsGCBUq3CQD+/v5o0KABli9fDolEgiZNmuDKlStYsmRJkesUV44GBgaQSCRKm5gVLLuCNUx5vL29xWf9tmzZgrp16yIwMBCDBw8uMqY8urq6RX7G81u7di0sLCywevVqSCQS2NjY4MGDB5g9eza+/vpr8b1r3rw5vL29xeNcvXo1jh07JsbHGGOMMZanyiY/P4X/BN8Q3/e2P28nb/g4+5RoWQcHB3Tv3h329vZwc3ODq6srBg4ciJo1axa73u7du7FixQrcunULaWlpyMnJgb6+frHrhIeHIy0tDYaGhgrTMzIycPv27SLXUzbGR3GD0UZFRUFDQ0OhtsjQ0BBNmjRBVFSUOE1DQwNt2rQR/7axsUGNGjUQFRWFdu3awcvLC2PHjsXWrVvRo0cPDBo0SEwSwsPDcevWLWzfvl0hptzcXMTGxsLW1hYAFLYPAEZGRnBxccH27dvRuXNnxMbG4vTp0/D39xeXiYiIgI+PDyIjI/H48WPk5uYCEJIIOzu7IsvpbcpAW1tbPCYAMDMzE5vYFbXdDh06KJS9o6NjsbEUV47FKVh2Rcm//1q1ahU6xrIQFRUFR0dHhePu1KkT0tLS8O+//6JevXoAhOQnvzeVJ2OMMcaqryqb/ExoPQF9mvR5b/sz0y1ZrQ8gPNh95MgRhIWF4fDhw/Dz88O8efNw9uxZ1K9fX+k6Z86cwdChQ+Hr6ws3NzcYGBhgx44d+OGHH4rdV25uLszMzMTnhvIrqgbD1NQUDx8+LDQ9OTm5yMFo8zcpKzi9YMKkLIHKm+bj44Phw4fj4MGD+Ouvv+Dt7Y0dO3bgk08+QW5uLiZMmIBp06YVWj/vRhgAdHR0Cs0fMWIEpk+fDj8/PwQEBKBp06ZwcHAAAKSnp8PV1RWurq7Ytm0bjIyMEB8fDzc3N2RnZys9rncpg7xmfPmPvah1i9tucYorx+IoK7uSyjtGNTW1QjGXtElcfso+O3nbfVN55iWvjDHGGGP5Vdnkx0yv5M3QVEEikaBTp07o1KkTvv76a1haWiIwMBBeXl6QSqV49eqVwvKhoaGwtLTEvHnzxGl3795VWEbZeq1atUJiYiI0NDTEB87fxNHREampqWJTNAA4e/YsUlNTixyM1s7ODjk5OTh79qy4zKNHjxATEyPWyABATk4OLly4IG43OjoaT58+FZtnAYC1tTWsra0xc+ZMDBs2DJs2bcInn3yCVq1a4dq1a2jUqFGJjiO/fv36YcKECQgKCkJAQADc3d3FeTdu3EBKSgq+++47WFhYAIBCJwsAxB7jCpbv25RBadnZ2WHfvn0K086cOfPG9YoqR2Wfk9I6c+aMmHA+efIEMTEx4ntoZGSExMREheSlYIcJJYnBzs4Oe/bsUdhOWFgY9PT0UKdOnXeKnzHGGGPVE3d4oAJnz57FokWLcOHCBcTHx2Pv3r1ITk4Wb5CtrKxw+fJlREdHIyUlBS9fvkSjRo0QHx+PHTt24Pbt21i1ahUCAwMVtmtlZYXY2FhERkYiJSUFWVlZ6NGjBxwdHdGvXz/8/fffiIuLQ1hYGL766qtCN/h5bG1t8eGHH2LcuHE4c+YMzpw5g3HjxuGjjz5CkyZNlK7TuHFj9O3bF+PGjcOpU6dw6dIljBw5EnXq1EHfvn3F5TQ1NeHp6YmzZ8/i4sWL+N///ocOHTqgXbt2yMjIwNSpUxEcHIy7d+8iNDQU58+fF8tl9uzZOH36NKZMmYLIyEjxGRtPT883lrmOjg769u2L+fPnIyoqShx4FxBqjaRSKfz8/HDnzh3s37+/0Ng9lpaWkEgk+PPPP5GcnIy0tLS3LoPSmjhxIm7fvg0vLy9ER0cjICBA7MlPmTeVo5WVFdLS0nDs2DGkpKTgxYsXpY5pwYIFOHbsmDiYce3atcVxe5ydnZGcnIylS5fi9u3bWLNmDf766y+F9ZV9xguaPHky7t27B09PT9y4cQN//PEHvL294eXlJT7vwxhjjDFWKlQJ5ebmUnp6OuXm5lJGRgZdv36dMjIyVB1WiV2/fp3c3NzIyMiIZDIZWVtbk5+fnzg/KSmJXFxcSFdXlwDQiRMniIho1qxZZGhoSLq6ujRkyBBavnw5GRgYiOtlZmbSgAEDqEaNGgSANm3aREREz549I09PTzI3NydNTU2ysLCgESNGUHx8fJExPnr0iEaMGEF6enqkp6dHI0aMoCdPnhR7XI8fPyZ3d3cyMDAguVxObm5uFBMTI87ftGkTGRgY0J49e6hBgwYklUqpW7duFBcXR0REWVlZNHToULKwsCCpVErm5uY0depUhff23LlzYtno6OhQ8+bNaeHCheJ8S0tLWr58udL4Dh48SACoS5cuheYFBASQlZUVyWQycnR0pP379xMAioiIEJdZsGABmZqakkQiodGjRxMRkZOTE02fPr3UZZBfYGAgvemreODAAWrUqBHJZDLq3Lkzbdy4kQCI70n+7ZakHCdOnEiGhoYEgLy9vYssu9jYWIVyOHHiBAGgAwcOUNOmTUkqlVLbtm0pMjJSYT1/f3+ysLAgHR0dGjVqFC1cuJAsLS3F+co+4wX3RUQUHBxMbdu2JalUSqampjR79mx6+fKlOL9g+RMR9e3bV3x/2Nsr7tya/xzMXuNyYYwx1SjN+VdC9BYPFKgYESEjI0PsMSo2Nhb169cXe/tijDH2bjIzM4s8t+Y/BxfVCUp1xOXCGGOqUZrzL7cdYYwxxhhjjFULlTv5UdKDGWOMMcYYY4wpU7mTH19foPK12mOMMcYYY4ypQOVOfi5eBEJDVR0FY4wxxhhjrBKo3MmPujqwcqWqo2CMMcYYY4xVApU7+Xn1CrhyBcjIUHUkjDHGGCtHCc8T4BPsg4TnCaoOhTFWiVXu5AcA1NSAp0/52R/GGGOsCktIS4BviC8S0jj5YYy9vcqf/OTmAtnZQFqaqiNhjDHGGGOMVWCVP/nJk5TEtT+MMcZYFaV38iyurRb+ZYyxt1V1kp/sbE5+KrjNmzejRo0aqg6jTDk7O2PGjBnlvp/Q0FDY29tDU1MT/fr1K/f9VRVxcXGQSCSIjIwEAAQHB0MikeDp06dlvi+JRIJ9+/Yp3W957ouxaoEI5otXwy4FMF+8mq/3jLG3VqmTn+i9PwO//w5oago9v1URHh4eb3WD6+PjgxYtWpRJDE+ePIG7uzsMDAxgYGAAd3f3crlhrCyKumneu3cvvvnmm3Lfv5eXF1q0aIHY2Fhs3ry53PdXVXXs2BEJCQkwMDB447KlTZQSEhLQs2fPd4xQUVHf6fLYV3Vw//59jBw5EoaGhtDW1kaLFi0QHh4uzici+Pj4wNzcHHK5HM7Ozrh27ZoKI2aiw4ehc+k6AAj/Hj6s4oAYY5VVpU5+Mps2Aeztgdq1gZcvgcTEd9vg0aOAnZ3wbzU3fPhwREZGIigoCEFBQYiMjIS7u7uqwyq17Ozsct1+rVq1oKenV677AIDbt2+jW7duqFu3rtLaMyJCTk5OucdR2UmlUpiamkIikZTZNvM+Y6amppDJZGW23eK8z31VFU+ePEGnTp2gqamJv/76C9evX8cPP/yg8H1aunQpfvzxR6xevRrnz5+HqakpXFxc8Pz5c9UFzoRannnzQP99bUkiAb76imt/GGNvhyqh3NxcSk9Pp4gHEZSRkUHXr1+njLg4ogsXiF68eNuNErVtSwQI/+bmlm3QBfz+++/UrFkz0tLSolq1alH37t0pLS2NvL29CYDC68SJE0RE9MUXX1Djxo1JLpdT/fr16auvvqLs7GwiItq0aVOh9TZt2kRERE+fPqVx48aRkZER6enpUdeuXSkyMrLI2K5fv04A6MyZM+K006dPEwC6ceNGkes9fvyY3N3dqUaNGiSXy+nDDz+kmJgYcf6mTZvIwMCAAgMDqXHjxiSTyahHjx4UHx8vLhMZGUnOzs6kq6tLenp61KpVKzp//rw4PzQ0lDp37kxaWlpUt25d8vT0pLS0NHG+paUlffPNNzR69GjS19enUaNGUYcOHWj27NkKsSYlJZGGhgYdP36ciIi2bt1KrVu3Jl1dXTIxMaFhw4bRw4cPiYgoNja2UNmOHj2aiIicnJxo+vTppS6DoKAgsrGxIR0dHXJzc6MHDx4oLVNl+960aROdOHGCAFBQUBC1bt2aNDU16fjx45Sbm0tLliyh+vXrk5aWFjVv3px+//13hW0ePHiQGjduTFpaWuTs7Cx+dp48eUJERN7e3uTg4KCwzvLly8nS0lJh2saNG8nGxoZkMhk1adKE1qxZUyjuPXv2kLOzM8nlcmrevDmFhYUpbOPUqVPUpUsXksvlVKNGDXJ1daXHjx/Tli1bqFatWpSZmamwfP/+/cnd3V1pWRERnT17llq0aEEymYxat25Ne/fuJQAUERFBRCSWW96xxsXF0UcffUQ1atQgbW1tsrOzo4MHD77xPZ8yZQrNnDmTDA0NqUuXLkREBIACAwMVjv+3334jR0dHkslkZGdnJ36XiV5/FvILDAykvNNycd/p/PsiIrp8+TJ17dpVPJ+MGzeOnj9/Ls4fPXo09e3bl5YtW0ampqZUq1Ytmjx5snj+UEY8t2ZkFJqXdw7OLefzZFmaPXs2ffDBB0XOz83NJVNTU/ruu+/EaZmZmWRgYEDr1q0r0T4qY7lUCvv2Cdfmgq/Zs4lyclQdHWOsAijN+bfqJD/p6URXrhBFRb1d4hIUpHhSDQoq+8D/8+DBA9LQ0KAff/yRYmNj6fLly7RmzRp6/vw5PX/+nAYPHkwffvghJSQkUEJCAmVlZRER0TfffEOhoaEUGxtL+/fvJxMTE1qyZAkREb148YI+++wzatq0qbjeixcvKDc3lzp16kQff/wxnT9/nmJiYuizzz4jQ0NDevTokdL4NmzYUOimjIjIwMCANm7cWORx9enTh2xtbenkyZMUGRlJbm5u1KhRI4UETVNTk9q0aUNhYWF04cIFateuHXXs2FHcRtOmTWnkyJEUFRVFMTExtGvXLjFRu3z5Munq6tLy5cspJiaGQkNDqWXLluTh4SGub2lpSfr6+rRs2TK6efMm3bx5k/z8/KhevXoKXwg/Pz+qU6cOvXr1SjzmQ4cO0e3bt+n06dPUoUMH6tmzJxER5eTk0J49ewgARUdHU0JCAj19+pSICic/JS2DHj160Pnz5yk8PJxsbW1p+PDhSss0JyeHEhISSF9fn1asWCG+r3k38c2bN6fDhw/TrVu3KCUlhebOnUs2NjYUFBREt2/fpk2bNpFMJqPg4GAiIoqPjyeZTEbTp0+nGzdu0LZt28jExKTUyc/69evJzMyM9uzZQ3fu3KE9e/ZQrVq1aPPmzUT0+ubfxsaG/vzzT4qOjqaBAweSpaUlvXz5koiIIiIiSCaT0aRJkygyMpKuXr1Kfn5+lJycTC9evCADAwPatWuXuM/k5GSSSqViwlpQWloaGRkZ0ZAhQ+jq1at04MABatCgQbHJT+/evcnFxYUuX75Mt2/fpgMHDlBISMgb33NdXV2aNWsW3bhxg6KioohIefJTt25d2r17N12/fp3Gjh1Lenp6lJKSIn4Wikt+ivpOF9xXeno6mZubU//+/enKlSt07Ngxql+/vpisEZH4Y8DEiRMpKiqKDhw4QNra2rR+/XqlZUlU9ZIfW1tbmjFjBg0cOJCMjIyoRYsWCsd/+/ZtAkAXL15UWK9Pnz40atQopdvMzMyk1NRUhVdlK5cK79EjIl1d5ckPQGRjQ7RzJ9F/53LGWPVUPZOfjAyiZ8+Izp8nio0lCg8v+evCBSI7OyI1NeFkqqYm/H3hQum2k55eovjDw8MJAMXFxSmdn/cr7ZssXbqUWrduLf6t7Kb12LFjpK+vX+gX9IYNG9JPP/2kdLsLFy6kxo0bF5reuHFjWrRokdJ1YmJiCACFhoaK01JSUkgul4s3sHm/ZOevUYqKiiIAdPbsWSIi0tPTE2+gC3J3d6fx48crTPvnn39ITU1NvEGztLSkfv36KSyTV8tz8uRJcZqjoyPNmjVL6X6IiM6dO0cAxF/PC94058mf/JSmDG7duiUus2bNGjIxMSkyFiIh8cz71T9/PPv27ROnpaWlkZaWVqHalTFjxtCwYcOIiGjOnDlka2urcHKYPXt2qZMfCwsLCggIUFjmm2++IUdHRyJ6ffP/yy+/iPOvXbtGAMRkYdiwYdSpU6cij3nSpEliAkpEtGLFCmrQoEGRJ7affvqJatWqRen5vof+/v7FJj/29vbk4+OjdHvFvectWrQotLyy5Cd/LcLLly+pbt264g8Wb0p+iJS/FwX3tX79eqpZs6ZCDejBgwdJTU2NEhMTiUg4p1haWlJOvl/JBw0aREOGDFF67ERVL/mRyWQkk8lozpw5dPHiRVq3bh1paWnRli1biEioVQZA9+/fV1hv3Lhx5OrqqnSbBWvq9fT0Kl25VGj37xNZWhad+ABErVsL/9rbE+3dW+6tNhhjFVNprksa79JkrsLR0wOMjIBTp4CRI99+O7m5wPXrQJs2pVsvPBxo1eqNizk4OKB79+6wt7eHm5sbXF1dMXDgQNSsWbPY9Xbv3o0VK1bg1q1bSEtLQ05ODvT19d8QUjjS0tJgaGioMD0jIwO3b98ucj1lz0QQUZHPSkRFRUFDQwPt27cXpxkaGqJJkyaIiooSp2loaKBNvnK1sbFBjRo1EBUVhXbt2sHLywtjx47F1q1b0aNHDwwaNAgNGzYUj+XWrVvYvn27Qky5ubmIjY2Fra0tAChsHwCMjIzg4uKC7du3o3PnzoiNjcXp06fh7+8vLhMREQEfHx9ERkbi8ePHyM3NBQDEx8fDzs6uyHJ6mzLQ1tYWjwkAzMzMkJSUVKJ9FJT/WK9fv47MzEy4uLgoLJOdnY2WLVuKMXbo0EHhfXR0dCzVPpOTk3Hv3j2MGTMG48aNE6fn5OQU6kigefPm4v/NzMwAAElJSbCxsUFkZCQGDRpU5H7GjRuHtm3b4v79+6hTpw42bdoEDw+PYj+DDg4O0NbWLvGxTZs2DZMmTcLhw4fRo0cPDBgwQCHmohT8jBUl//7zPvv5PwtlIe+4dXR0xGmdOnVCbm4uoqOjYWJiAgBo2rQp1PN1DGNmZoYrV66UaSwVWW5uLtq0aYNFixYBAFq2bIlr167B398fo0aNEpcr+Pkq7rw3Z84ceHl5lV/Q1VlMDODiAiQkABKJ8ud71NSE1z//AD4+QP/+QMuWwIIFQO/ewnqMMVZA1Up+AKBOHaBhQyAwELCwePPJjwgYNQq4cUNIevKoqQE2NsCvv5b8BGpjU6LF1NXVceTIEYSFheHw4cPw8/PDvHnzcPbsWdSvX1/pOmfOnMHQoUPh6+sLNzc3GBgYYMeOHfjhhx+K3Vdubi7MzMwQHBxcaF5R3U6bmpri4cOHhaYnJyeLN1IFUREPniq7cVB2I5E3zcfHB8OHD8fBgwfx119/wdvbGzt27MAnn3yC3NxcTJgwAdOmTSu0fr169cT/578JzDNixAhMnz4dfn5+CAgIQNOmTeHg4AAASE9Ph6urK1xdXbFt2zYYGRkhPj4ebm5upeowoaRloKmpWejYi1r3TfIfa17CdvDgQdSpU0dhubyH40uyHzU1tULLvXz5stB+fv75Z4VED4DCzTWgeKx5ZZC3vlwuLzaOli1bwsHBAb/++ivc3Nxw5coVHDhwoMjl36YMx44dCzc3Nxw8eBCHDx/G4sWL8cMPP8DT07PY9ZR9xkoqrxzeVM4lVdzN+Zs+d7n5z3lVnJmZWaEfMmxtbbFnzx4AwnkPABITE8VEHRCS9aLOezKZTKHjCSJCRkZGWYde/YSHAz17ArVqAQYGQEqK8uVyc4F794C2bYWOikJCgK+/Bj7+WJi2YAHg5sZJEGNMQaXu7U0pDQ2gSROgbl2gfn2hJqa4V0qKUMtT8CYgr/YnJeXN28h75fvF+U0kEgk6deoEX19fREREQCqVIjAwEIDQI9WrV68Ulg8NDYWlpSXmzZuHNm3aoHHjxrh7967CMsrWa9WqFRITE6GhoYFGjRopvGrXrq00NkdHR6SmpuLcuXPitLNnzyI1NRUdO3ZUuo6dnR1ycnJw9uzrwecePXqEmJgYsUYGEGoHLly4IP4dHR2Np0+fwiZf4mhtbY2ZM2fi8OHD6N+/PzZt2iQey7Vr1wodR6NGjSCVSpXGladfv37IzMxEUFAQAgICMDJfzeCNGzeQkpKC7777Dp07d4aNjU2hmpi87Rcs37cpg/JiZ2cHmUyG+Pj4QuVjYWEhLnPmzBmF9Qr+bWRkhMTERIUb8/zj1ZiYmKBOnTq4c+dOof0Ulbwr07x5cxw7dqzYZcaOHYtNmzZh48aN6NGjh3gcytjZ2eHSpUsKN58Fj00ZCwsLTJw4EXv37sVnn32Gn3/+GUDJ3vM3yb//nJwchIeHi591IyMjPH/+HOnp6eIyBccFUvadLsjOzg6RkZEK2wkNDYWamhqsra3fOvaqplOnToiOjlaYFhMTA0tLSwBA/fr1YWpqiiNHjojzs7OzERISUuR5j5WD48cBZ2egQQMgNBS4eFFIhsLDERW0Da3GA1FB28RpOH8eyEtAnZyA4GAhEdLUFBKoTp2Ev7lnOMZYnvJod1feinzmJ7+bN4kiI4n+e7i6iA0JPbvlPetT8KWmVi49v505c4YWLlxI58+fp7t379KuXbtIKpXSoUOHiEh45qZevXp048YNSk5OpuzsbNq3bx9paGjQb7/9Rrdu3aKVK1dSrVq1FJ4Z2L59O+no6FBERAQlJydTZmYm5ebm0gcffEAODg4UFBREsbGxFBoaSvPmzVPoRa2gDz/8kJo3b06nT5+m06dPk729PX300UfFHlffvn3Jzs6O/vnnH4qMjKQPP/xQ6cP+7dq1ozNnzlB4eDg5OjpShw4diEh4wHvKlCl04sQJiouLo1OnTlHDhg3piy++ICKiS5cukVwup8mTJ1NERATFxMTQH3/8QVOnThVjsLS0pOXLlyuNb/jw4eTg4EASiYTu3r0rTk9KSiKpVEqzZs2i27dv0x9//EHW1tYKz4r8+++/JJFIaPPmzZSUlCQ+C1Sww4OSlMGbnvNQpqhnfgo+jzJv3jwyNDSkzZs3061bt+jixYu0evVq8Tmqu3fvklQqpZkzZ9KNGzdo+/btZGpqqrCt69evk0Qioe+++45u3bpFq1evppo1ayo88/Pzzz+TXC6nFStWUHR0NF2+fJk2btxIP/zwAxG9fuYlr/yIiJ48eaLQe2F0dDRJpVKaNGkSXbp0iaKiomjt2rWUnJwsrpOamkra2toklUppx44dxZbR8+fPqXbt2jRs2DC6du0aHTx4kBo1alTsMz/Tp0+noKAgunPnDoWHh1O7du1o8ODBRFTy9zwPlDzzU69ePdq7dy9FRUXR+PHjSVdXVzy+R48ekY6ODk2bNo1u3rxJ27dvJ3Nzc4XPgrLvdMF9paenk5mZGQ0YMICuXLlCx48fpwYNGhTq8KDgc4TTp08nJyenIsuzqj3zc+7cOdLQ0KCFCxeK5a2trU3btm0Tl/nuu+/IwMCA9u7dS1euXKFhw4aRmZkZPXv2rET7qIzlUqH8/juRVErk5kaU7xm2POEPwgk+oPAH4W/eVm6u0HFRu3bC9bxLF6L/On5hjFU91bfDg/yysoguXhQ6PyhKZiaRiUnxD1OamgrLlaHr16+Tm5sbGRkZkUwmI2tra/Lz8xPnJyUlkYuLC+nq6ircLM6aNYsMDQ1JV1eXhgwZQsuXL1e4kc7MzKQBAwZQjRo1FLrFffbsGXl6epK5uTlpamqShYUFjRgxQqGL6YIePXpEI0aMID09PdLT06MRI0YUutEuKK+bZwMDA5LL5eTm5qa0m+c9e/ZQgwYNSCqVUrdu3cSOH7Kysmjo0KFkYWFBUqmUzM3NaerUqQrv7blz58Sy0dHRoebNm9PChQvF+cUlPwcPHiQAYtfE+QUEBJCVlRXJZDJydHSk/fv3F7p5X7BgAZmampJEInljV9dvKoP8yjL5yc3NpZUrV1KTJk1IU1OTjIyMyM3NjUJCQsRlDhw4QI0aNSKZTEadO3emjRs3FtqWv78/WVhYkI6ODo0aNYoWLlxYqKvr7du3U4sWLUgqlVLNmjWpS5cutHfvXiIqWfJDRBQcHEwdO3YkmUxGNWrUIDc3t0LH5O7urrTba2VOnz5NDg4OJJVKqUWLFmKPbUUlP1OnTqWGDRuSTCYjIyMjcnd3F3tjIyrZe55HWfITEBBA7du3J6lUSra2tnTs2DGFdQIDA6lRo0akpaVFH330Ea1fv17hs1DUdzr/vohK3tV1ftUt+SESPvvNmjUjmUxGNjY2hXq7y83NJW9vbzI1NSWZTEZdunShK1eulHj7lbVcKgR/fyKJhGj4cOH6rUSpkp88ublEf/5J1KqVcE3v1o3o1KkyCpoxVlGU5vwrIap8dcH0X7vqmNQY2NS0QWxsLOrXrw8tLS3FBZOSgPh4oRlcUQNR3rsHJCcXvTNjY6EJHWNVVHBwMLp27YonT54U+RyYKrm4uMDW1harVq1SdSjVSmZmZpHn1rxzsFwuL9MBYys7Lpe3QAR8+63wrM60acDy5cIzt0pcTLiI1utbI3x8OFqZvblzoUL7+eMPwNsbuHxZeBbI1xco8NwiY6xyKs35t+p1eJCfkRHw+DEQFwc0bar8hGphIbwYYxXK48ePcfjwYRw/fhyrV69WdTiMsbKWmwtMnw6sXg0sXAjMmVN+nRNIJEC/fkCfPsCePULvcB06CL3C+foCrVuXz34ZYxVO1evwID+JBLC0BLKzgQcPVB0NY6wUWrVqhQkTJmDJkiVo0qSJqsNhjJWl7GxgxAhg7Vpg/Xpg7tz30yubmhowaJBQ+xMQANy8KQxr0a8fcOlS+e+fMaZyVTv5AQC5HDAzAx4+BF68UHU0jFU4zs7OIKIK1+QtLi4Oqamp+Pzzz1UdCmOsLKWlCd1R790L/P47kG+8sPdGXR0YNgy4dk0Y0uLqVaBFCyExunbt/cfDGHtvqn7yAwCmpoCWFnD3Lnd3yRhjjKlKSgrQvTtw+jQQFCQMTKpKGhqAuzsQFQVs2ABcuADY2wuJ0Y0bqo2NMVYuqkfyo6YmNH9LTxc6QWCMMcbY+xUfD3zwgfAcbkgI0LWrqiN6TVMT+PRTIDoaWLdOGGOoaVNhEPRbt1QdHWOsDFWZ5OeNI5Xr6go9t92/D2RlvZ+gGGOsknrjOZWx0rh+XRhwNDtbSCxatlR1RMpJpcD48cKzQKtWCQOk2tgAY8YAsbGqjo4xVgYqfW9vUqkUampqePDgAYyMjCCVSovu4s7QEHjyBLhzB7Cyej8PVzLGWCVCRMjOzkZycjLU1NQglUpVHRKr7M6cEXpVq1tXaOpmZqbqiN5MJgOmTBFqg376CVi8WHg26NNPgXnzgHr1VB0hY+wtVfrkR01NDfXr10dCQgIelKRHt1evhGd/0tMBHZ3yD5AxxiohbW1t1KtXD2pFjLnCWIkEBQEDBghdSe/fD1SwjlXeSC4HZswQOmXw9weWLAE2bRL+njsXqFNH1REyxkqp0ic/gFD7U69ePeTk5ODVq1dvXuHnn4Vfog4dAmrWLP8AGWOsElFXV4eGhgYP1MneTUAAMHo00LMnsHOnkEhUVjo6wOefAxMnCuMSLVsmdJAwcSLw5ZdCx0qMsUqhSiQ/ACCRSKCpqQlNTc03L+zjA9jaCiesLVvKPTbGGGOsWlm1ShjA1MND+MFRo4rcbujqCvcOkycDK1cCP/wgjFM0eTIwe7YwuDpjrEKrnu0ZTEyA778X2u8ePqzqaBhjjLGqgQj46ish8fniC2DjxqqT+OSnrw/Mny/0XDdrlpAA1a8PzJkDPHqk6ugYY8WonskPAPzvf0C3bkKVdXq6qqNhjDHGKrdXr4AJE4CFC4VmYUuWVP2OhWrUAHx9hZ7gpk0D/PyEDpXmzxc6WGKMVTilSn4WL16Mtm3bQk9PD8bGxujXrx+io6MVliEi+Pj4wNzcHHK5HM7OzrhWYLTkrKwseHp6onbt2tDR0UGfPn3w77//vvvRlIZEIvTgkpAAeHu/330zxhhjVUlmJjB4sFDTs3mz8HxMdWJoCCxaJCRBkyYJzeHq1wcWLABSU1UdHWMsn1IlPyEhIZgyZQrOnDmDI0eOICcnB66urkjPV3OydOlS/Pjjj1i9ejXOnz8PU1NTuLi44Pnz5+IyM2bMQGBgIHbs2IFTp04hLS0NH330Uck6KyhLjRoJz/8sXw6Eh7/ffTPGGGNVwbNnQqcGhw4B+/YJnRxUV0ZGwNKlwpAa//ufkBDVry/8m+8+iDGmOhIiorddOTk5GcbGxggJCUGXLl1ARDA3N8eMGTMwe/ZsAEItj4mJCZYsWYIJEyYgNTUVRkZG2Lp1K4YMGQIAePDgASwsLHDo0CG4ubm9cb9EhIyMDMSkxqCFWYu3DV/w8iXQtq1QE3TunDDKM2OMsSLlnYPlcjn3CJdPtSyXhw+FxCc2FjhwAPjgg3Lb1cWEi2i9vjXCx4ejlVmrcttPmXrwQBgjaP164TmhL74QOkfgoTYYK1OlOf++0zM/qf9V5daqVQsAEBsbi8TERLi6uorLyGQyODk5ISwsDAAQHh6Oly9fKixjbm6OZs2aicsUlJWVhWfPnomv52X564mmJvDLL8Dly0INEGOMMcbe7M4doFMnIDEROHmyXBOfSsvcXHgO6OZNYbyjuXOBBg2E+42MDFVHx1i19NbJDxHBy8sLH3zwAZo1awYASExMBACYmJgoLGtiYiLOS0xMhFQqRc0C4+vkX6agxYsXw8DAQHzVrVv3bcNWrk0bYRAzb2/g1q2y3TZjjDFW1Vy+LCQ+ampAWBhgb6/qiCq2evWAdeuEJOjjj4Ue4ho2FBKjzExVR8dYtfLWyc/UqVNx+fJl/Pbbb4XmFaxuIqI3VkEVt8ycOXOQmpoqvsqlc4QFC4RByiZOFLrqZIwxxlhh//wDdOki1GqcOiX0bsZKxspKaG1y4wbg4iL88Nq4sZAYZWerOjrGqoW3Sn48PT2xf/9+nDhxQqEWxvS/EY4L1uAkJSWJtUGmpqbIzs7GkwJdQOZfpiCZTAZ9fX3xpaen9zZhF09HRzj5HDvGA58yxhhjyuzfD7i6Aq1bAydOAMbGqo6ocmrUSLjXuH5dSCQnTwasrYENG4RnkRlj5aZUyQ8RYerUqdi7dy+OHz+O+vXrK8yvX78+TE1NceTIEXFadnY2QkJC0LFjRwBA69atoampqbBMQkICrl69Ki6jMm5uwMiRgJeX8BAnY4wxxgSbNgH9+wMffST07Kavr+qIKr8mTYDt24GrV4F27YCxYwEbGyExyslRdXSMVUmlSn6mTJmCbdu2ISAgAHp6ekhMTERiYiIy/ntoTyKRYMaMGVi0aBECAwNx9epVeHh4QFtbG8OHDwcAGBgYYMyYMfjss89w7NgxREREYOTIkbC3t0ePHj3K/ghLa/lyQF1dqIpmjDHGmNB986efCjfnO3YAMpmqI6pa7OyAXbuAS5cABwfAwwNo2hQICBAGj2WMlZlSJT/+/v5ITU2Fs7MzzMzMxNfOnTvFZb744gvMmDEDkydPRps2bXD//n0cPnxYoana8uXL0a9fPwwePBidOnWCtrY2Dhw4AHV19bI7srdVu7aQAO3YARw8qOpoGGOMMdXJzRUezp89G/j6a8DfX/iBkJWP5s2BvXuFsQetrYERI4TOJHbtEt4Lxtg7e6dxflSlTMf5Ub4DYdyC69eBa9eA8njGiDHGKqlqOZ5NCVS5cnn5Uqjp2boVWLUKmDpVpeFUynF+3tW5c0JPtEFBQLNmgK8v8MknwtiEjDHRexvnp8qSSIRftx49Ar76StXRMMYYY+/XixfCTfZvvwlNr1Sc+FRb7doBf/0FhIYKPdIOGCB0NnHgAPdMy9hb4uSnKPXrA998I/TBf+aMqqNhjDHG3o8nT4RumIODgT//BIYOVXVErGNH4MgR4T3R0wP69AHatxdqhDgJYqxUOPkpzrRpwi8s48Zx//uMMcaqvvv3ha6Xo6OFoR9cXVUdEcvPyUlIgI4dAzQ1hSb6nToBR49yEsRYCXHyUxwNDWEwsqgooacbxhhjrKqKiRFupFNThYFM27dXdURMGYkE6NZNGGA2KEjoDc7F5XVixBgrFic/b+LgIPR08803wojMjDHGWFVz4YKQ+GhrC8+X2NqqOiL2JhKJMD7hmTNC88T0dKBrV6B7d+E9ZIwpxclPSXz9NVCvHjB+PHc1yRhjrGo5dky4aW7YUKjxsbBQdUSsNCQSoHdvIYENDARSUoAPPhASo7NnVR0dYxUOJz8lIZcD69cLF4VfflF1NIwxxljZ+P13oFcvodbn2DHA0FDVEbG3JZEA/foBERHC+/rvv0CHDsBHHwnjBjHGAHDyU3JduwqjW3/xBfDggaqjYYwxxt6Nvz8wZAgwcCCwfz+go6PqiFhZUFMT3tPLl4Vuym/eBNq0ERKjyEhVR8eYynHyUxrLlgEyGeDpqepIGGOMvaXFixdDIpFgxowZ4jQigo+PD8zNzSGXy+Hs7Ixr166pLsjyRAQsWABMnixcz7ZuBaRSVUfFypq6OjBsmDBY+6+/AlevAi1bConR1auqjo4xleHkpzRq1RLG/dm7V2hXyxhjrFI5f/481q9fj+bNmytMX7p0KX788UesXr0a58+fh6mpKVxcXPD8+XMVRVpOcnOFhMfbG1i4EFixQqgpYFWXhgbg7i70XLthg9AErnlzITHK35HT0aOAnZ3wL2NVGJ/xSmvQIKH97JQpQnegjDHGKoW0tDSMGDECP//8M2rWrClOJyKsWLEC8+bNQ//+/dGsWTNs2bIFL168QEBAgAojLmPZ2cDw4UJzt/XrgblzhedEWPWgqSk034+OBtatE3qEa9oUGDVKaBo3d66QIM2dy2MGsSqNk5/SkkiAtWuB58+BL79UdTSMMcZKaMqUKejduzd69OihMD02NhaJiYlwzTegp0wmg5OTE8LCwt53mOUjLU344S4wUHgYftw4VUfEVEUqFXqvvXkTWLVK6OjCxgY4f16Yf/48cPiwamNkrBxx8vM2LCyAxYuFX07++UfV0TDGGHuDHTt24OLFi1i8eHGheYmJiQAAExMThekmJibiPGWysrLw7Nkz8VVhm8ilpAiDYp45IwyK2b+/qiNiFYFMJrRiuXkTqFNHcd7o0cCRI0BWlmpiY6y0SjHALyc/b2vSJMDRUfj1JDNT1dEwxhgrwr179zB9+nRs27YNWlpaRS4nKdAEjIgKTctv8eLFMDAwEF9169Yts5jLTHy8MObL3btASIjQcylj+f3zD3DvnuK0hw8BV1eh6/M+fYSmknFxKgmPsTciQvbX80q8OCc/b0tdHfj5Z+D2bWDRIlVHwxhjrAjh4eFISkpC69atoaGhAQ0NDYSEhGDVqlXQ0NAQa3wK1vIkJSUVqg3Kb86cOUhNTRVf//77b7keR6ldvw507Cg86xMaKvT0xVh+RMD8+cI9TX7q6sLzQPPmCc83e3oC9esDtraAlxfXCrGK5fBhSC+VvAdDTn7eRdOmwnM/330ndCXJGGOswunevTuuXLmCyMhI8dWmTRuMGDECkZGRaNCgAUxNTXHkyBFxnezsbISEhKBjx45Fblcmk0FfX1986enpvY/DKZnTp4UaH0NDIfFp1EjVEbGK6PBh4RmfV68Up796JdzXtGol1Bg+egTs2SN8pnbtEmqFatUCPv4YWLMGuHNHNfGz6i0tDfj7b+B//0NpuujQKLeAqot584SHR8eOBU6dKvzrCWOMMZXS09NDs2bNFKbp6OjA0NBQnD5jxgwsWrQIjRs3RuPGjbFo0SJoa2tj+PDhqgj53fz1lzCWS+vWwuClNWqoOiJWEeXV+qipCV2gF6SmJsx3dQUMDIRnxfr3F9a7elX4nP31FzBjBjB1KmBtDfTsKbycnIBimpgy9laePxd+zAkJEZ7xuXAByMkBAEhK8eMTJz/vSiYTmr917iy0iZ06VdURMcYYK6UvvvgCGRkZmDx5Mp48eYL27dvj8OHDFas2pyS2bwc8PIQb0J07Ablc1RGxiio7W3gmTFniAwjT790TlpPJXk+XSAB7e+H1xRfAs2dCj3FBQcI4iCtXCp+7rl1fJ0MNG76fY2JVy7NnQrITHCy8wsOFWkkTEyHBdncX7r2jokq1WQlR5evMnYiQkZGBmNQYtDBroepwBJMmAdu2CW2sLSxUHQ1jjJWbvHOwXC4vtkOA6kbl5bJypfArvIeH8KOcRtX6ffNiwkW0Xt8a4ePD0cqslarDqRru3QOSkwEAUclRGLF3JLb33wZbI1thvrExUJqOPIiE+6C8WqF//gFevhSaXeYlQs7OnJQz5VJThVZUwcFC7U54uJCEm5kJyY6zs/BvkyZCEv7338CHHwIASE8PGYmJJTr/Vq0zoyp9953QvGDyZOFfviFgjDH2PhABX30ldL7zxRfC9YivQawkLCzEH2wzEoCIM0BGc1vgbZNLiUR4HrppU+Dzz4VmSsePC4nQH38Afn5Cczhn59fJUOPGZXc8rHJ5+lRIkPOSnYgIIdkxNxc+I+PGCclO48aFz2lvarZZDE5+yoqBgfDQ3yefCM8ADR6s6ogYY4xVdTk5QsuDX34Bli0TbjgZqyj09IC+fYUXkdA8KShISIZmzQKmTxeaxH34oZAIde0KaGurOmpWXh4/FpKdvGd2IiOFz0XdukKyM3Gi8G/Dhm/+AedNzTaLwclPWerXT3gY0NMT6NFD6AmFMcYYKw+ZmcDw4UJrg82bhYEpGauoJBLAzk54eXkJPXWdOCEkQgcPCj8gy2TCL/15tULW1lyLWZk9egScPPk62bl8WUh26tUTkpypU4V/69cv/fsskwk9Ff7XbDP68U3UK+GqnPyUNT8/4Ys9axawYYOqo2GMMVYVpaYKv6afPQvs2wd89JGqI2KsdHR1ha6yP/5YuCGOjn79rNDs2cDMmcJNcV4i1LUroKOj6qhZcVJShGQnr4OCK1eE6VZWQlI7Y4aQ7FhZlc3+8jXbzEwo+eg9nPyUNXNzYOlSYMIEYMQIoFs3VUfEGGOsKnn4UGgmFBcnDDb5wQeqjoixdyORADY2wmvmTCA9Xbh5zkuG1q4FpFKgS5fXyZCNDdcKqVpS0utkJyRE6AIdABo0EJKdzz8X/rW0VGmYBXHyUx7GjhV6fhs/Xsh6uVcTxhhjZeHOHWHclRcvhJsOe3tVR8RY2dPRAXr3Fl5EwM2brxOhuXOBzz4TbqjzEqFu3YSaJFa+Hj583YQtJETo2Q8QevNzchJq7JycKnyvx5z8lAc1NaGb0ebNgQULgMWLVR0RY4yxyu7SJaHGR08PCAsru6YjjFVkEonw7I+1tdBBwosXirVC69YJtUKdOwuJ0IcfCo8fcK3Qu0tIEJKcvITnxg1heuPGQvO1uXOFZKc03aFXAJz8lJcmTYQu+Hx8gCFDgBYtVB0RY4yxyurkSeHZiEaNhBs+Y2NVR8SYamhrA716CS8AuHXrdSL01VdCU6t69V73INe9u/CDAXuz+/cVk52YGGF6kyZCsvP110KyY26uyijfGSc/5emLL4QRtseNA06frnIDzjHGGHsP/vhD+BGtUycgMBDQ11d1RIxVHI0aCb3senoCGRnCjXteMrR+PaCpKTwXl9dErmlTrhXK8++/is3Ybt4UptvaCknjggVCsmNqqtIwy1rJu0ZgpSeVCmMvhIcDq1apOhrGGGOVzcaNwhAKH38MHDrEiQ9jxZHLhRqflSuFWotbt4AffxRqi7y9hWfk6tUTnsneuxd49kzVEb9f8fHA1q3AmDFC0mhhAYwcKfxA7+IC7NoFJCYKz/KsXSv86FLFEh+Aa37KX/v2wq8R8+cLA6DWr6/qiBhjjFV0RMKgpbNnC72HrlkDqKurOirGKpeGDYWxZKZOFcbFOnnyda3Qzz8LLXI6dXpdK2RvX7VqheLiFGt2YmOF6c2aCcfr7Cz0oGdkpMIg3z9Oft6Hb78VmipMmiR84arSF4sxxljZys0Vmk3/8IPQxt7Hh68bjL0rLS2hp0RXV2D5ciERyEuEFiwAvvwSqFPn9bNCPXoABgaqjrrkiIRkJy/RCQ4G7t4V5jVvLtQeOzkJyU7t2ioMVPU4+Xkf9PQAf39hELrt24UqRsYYY6ygly+F4RK2bhUGzZ46VdURMVY11a8PTJ4svDIzgX/+AYKChGRowwahVqhjx9fJkINDxfoRgkjo+j5/snPvnhCjg4PQ2sjJSegFz9BQ1dFWKJz8vC+9ewNDhwqj27q5VbsqRsYYY2/w4gUweDBw+DAQECBcMxhj5U9LS3jmxcVFqHGNi3udCC1cKHTpbGb2OhFycQFq1Hi/MRIJzzDlb8b2779CstOyJTBo0Otkp2bN9xtbJcPJz/u0YoXQg4aXl/CrHmOMMQYAT54IrQMuXQL+/FNomsMYUw0rK2DiROGVlQWcOvW6idymTcLzd46Or5OhFi2EMR7LEpHQaUP+ZOfBA2E/rVoJnRE4Ows92b3vRKyS497e3icTE6HXkW3bgL//VnU0jDHGKoL794V2+NHRwLFjnPgwVpHIZEK3z99/D1y7JjxHs3at8NzMd98BrVsL4954eAjDmzx5onw7R48Kg68ePap8PpEwiOi6dUKtr7k5YGMjNMu7fRsYMQI4eBB4/Bg4f16I56OPOPF5C1zz876NHi0kPxMnAlevAjo6qo6IMcaYqsTECMlObq7wzIGtraojYowVJ6+r7PHjgexsIDT0da3Qli1CzUyHDq97kGvZUmiaNncuEBUl/Nu9u7CtqKjXtTohIcDDh0KtUps2wv2is7PQGx0P0lqmOPl53yQS4KefhG4Gv/5aaFvKGGOs+rlwQbg5MjISWgNYWKg6IsZYaUilQNeuwmvpUqHDgbxnhZYuFYY5MTYWutA+f15Y5/z51zW9yclCxwpt2wKffio8s9OxIyc75YyTH1Vo2BDw9QXmzAGGDRMyfMYYY9XHsWNAv37CaPMHD3JvTIxVBRYWwLhxwis7Wxg89NAhoefG/CIjhTEgu3YVkh1uBfRe8TM/quLlJfS7Pnas0LUpY4yx6uH334FevYTmLMeOceLDWFUklQo1Od26ARkZivPS0oR5Li6c+KgAJz+qoqEB/PILcOWK0AkCY4yxqs/fX+ilaeBAYP9+vvFhrCojEpq+qasrTldXF6YTqSauao6TH1Vq3RqYOVMYvfvWLVVHwxhjrLwQCaPIT54sNHfZulX4ZZgxVnUdPiw84/PqleL0V6+E6YcPqyauao6TH1Xz9RUGzho/nn8BYIyxqig3V0h4vL2FARNXrCj7MUEYYxVLXq1PUd91NTWu/VGRUp99T548iY8//hjm5uaQSCTYt2+fwnwigo+PD8zNzSGXy+Hs7Ixr164pLJOVlQVPT0/Url0bOjo66NOnD/799993OpBKS0dH6P3txAlh4CzGGGNVR3Y2MHy40Nxt/Xqhm1uJRNVRMcbKW3Y2EB8v/PihTG6u0Dtcdvb7jYuVPvlJT0+Hg4MDVq9erXT+0qVL8eOPP2L16tU4f/48TE1N4eLigufPn4vLzJgxA4GBgdixYwdOnTqFtLQ0fPTRR3hVsFqwunBxAUaNAj7/HEhMVHU0jDHGykJamjAIYWCg0MnBuHGqjogx9r7IZELTtvBwIDwcUUHb0Go8EBW0TZyG8+eF5dh7Vequrnv27ImePXsqnUdEWLFiBebNm4f+/fsDALZs2QITExMEBARgwoQJSE1NxYYNG7B161b06NEDALBt2zZYWFjg6NGjcHNze4fDqcR++EHoDnH6dGGEYMYYY5VTcLAwrkevXsKI7UFBQpe2jLHqxcJCHL8rIwGIOANkNLcFzFqpOLDqrUzH+YmNjUViYiJcXV3FaTKZDE5OTggLC8OECRMQHh6Oly9fKixjbm6OZs2aISwsTGnyk5WVhaysLMXANarYEEW1awvtwEeOBNzdhV8LGWOMVT5z5wKPHwNPnwqjtrdsKc4iIuTk5FTflg7vgF4SLHUsQS8JmZmZqg6nyuHyLV9cvmVPXV0dGhoakJSyKXGZZhCJ/zXZMjExUZhuYmKCu3fvistIpVLUrFmz0DKJRTT5Wrx4MXx9fcW/9fT0ily2Uhs+HNi2DZg0Sej/nUf4ZYyxyufaNUBbGwgNBRo1EidnZ2cjISEBL168UGFwlZfGKw2s67QOGs80EJseq+pwqhwu3/LF5Vs+tLW1YWZmVqp1yqX6pGAGRkRvzMqKW2bOnDnw8vIqs/gqLIlEeCi2aVPhl8OCIwIzxhirHExNgYYNxT9zc3MRGxsLdXV1mJubQyqVlvrXyuruRfYLvHz6EhY1LKAt1VZ1OFUOl2/54vItW0SE7OxsJCcnIzY2FqRX8l7zyjT5MTU1BSDU7uTPwpKSksTaIFNTU2RnZ+PJkycKtT9JSUno2LGj0u3KZDLI8j0QRkTIKDhablVhZSV0herlJdQEOTqqOiLGGGOldemSMIbHf025s7OzkZubCwsLC2hr843P23il9grQAGRaMmhJtVQdTpXD5Vu+uHzLnlwuh6amptC6rBQtict0oIH69evD1NQUR44cEadlZ2cjJCRETGxat24NTU1NhWUSEhJw9erVIpOfasfTE2jTRugZiLtAZIyxyqeIEdzVeHwfxhgrM+I5tRTDJZX6LJyWlobIyEhERkYCEDo5iIyMRHx8PCQSCWbMmIFFixYhMDAQV69ehYeHB7S1tTF8+HAAgIGBAcaMGYPPPvsMx44dQ0REBEaOHAl7e3ux97dqT10d+PlnIDoaWLJE1dEwxhgrLR7BnTHGKqRSJz8XLlxAy5Yt0fK/3mu8vLzQsmVLfP311wCAL774AjNmzMDkyZPRpk0b3L9/H4cPH4Zevof3ly9fjn79+mHw4MHo1KkTtLW1ceDAAairq5fRYVUBDg7ArFnAt98CUVGqjoYxxiq1xYsXo23bttDT04OxsTH69euH6OhohWVKMkh3qfAI7pXS5s2bUaNGDVWHUaacnZ0xY8aM977f4OBgSCQSPH36FED5lW1cXBwkEon4w3zB/ZbnvljlU+rkx9nZGURU6LV582YAQmcHPj4+SEhIQGZmJkJCQtCsWTOFbWhpacHPzw+PHj3CixcvcODAAVj81w86y2f+fMDSEhg/vugRghljjL1RSEgIpkyZgjNnzuDIkSPIycmBq6sr0tPTxWVKMkh3qVTxEdw9PDzQr1+/Uq/n4+ODFi1alEkMCxcuRMeOHaGtrV3lEpa3UdRN/969e/HNN9+oJqh8hgwZgpiYmBItW5pEycLCAgkJCYXuN9+Vss94ee2LvT9VbLCcKkYuB9avFwbH+/lnYMIEVUfEGGOVUlBQkMLfmzZtgrGxMcLDw9GlS5cSDdJdYidPvv7BythYGMGdx/UoF9nZ2Rg0aBAcHR2xYcMGVYfz1rKzsyGVSstt+7Vq1Sq3bZeGXC6HXC4v023mlV1ep1vlTV1d/b3ti5UPfvKyonN2BsaMAb74Arh/X9XRMMZYlZCamgrg9U3hmwbpLo3EhiZAq1bCq27dsgtaBXbv3g17e3vI5XIYGhqiR48eSE9Ph4+PD7Zs2YI//vgDEokEEokEwcHBAIDZs2fD2toa2traaNCgAebPn4+XL18CEH7N9/X1xaVLl8T18lqOpKamYvz48TA2Noa+vj66deuGS5cuFRufr68vZs6cCXt7+xIf05MnTzBq1CjUrFkT2tra6NmzJ27evFlouX379sHa2hpaWlpwcXHBvXv3xHmXLl1C165doaenB319fbRu3RoXLlwQ54eFhaFLly6Qy+WwsLDAtGnTFGoZrays8O2338LDwwMGBgYYN24cHB0d8eWXXyrEkJycDE1NTZw4cQIAsG3bNrRp0wZ6enowNTXF8OHDkZSUBEBojtW1a1cAQM2aNSGRSODh4QGgcLM3ZWVw6+YtcX5ercvff/8NW1tb6Orq4sMPP0RCQkKxZXvo0CFYW1tDLpeja9euiIuLU5hfsDanqHIMDg7G//73P6SmpoqfEx8fnyLLrqimaKGhoXBwcICWlhbat2+PK1euiPOU1UCuWLECVlZW4nxln3Fl+woJCUG7du0gk8lgZmaGL7/8Ejk5OeJ8Z2dnfD7zc6z6dhUsTC1gamoqHg97/zj5qQyWLRNqgTw9VR0JY4xVekQELy8vfPDBB2LTleIG6S5qUO2srCw8e/ZMfOU1j3uY9rAco39/EhISMGzYMHz66aeIiopCcHAw+vfvDyLC559/jsGDB4s3xAkJCWKPrXp6eti8eTOuX7+OlStX4ueff8by5csBCM2ePvvsMzRt2lRcb8iQISAi9O7dG4mJiTh06BDCw8PRqlUrdO/eHY8fPy7T4/Lw8MCFCxewf/9+nD59GkSEXr16iQkaALx48QILFy7Eli1bEBoaimfPnmHo0KHi/BEjRqBu3bo4f/48wsPD8eWXX0JTUxMAcOXKFbi5uaF///64fPkydu7ciVOnTmHq1KkKcSxbtgzNmjVDeHg45s+fjxEjRuC3334D5XtGbOfOnTAxMYGTkxMAoZbjm2++waVLl7Bv3z7ExsaKCY6FhQX27NkDAIiOjkZCQgJWrlxZ4jIY0HcAcl6+vmF/8eIFvv/+e2zduhUnT55EfHw8Pv/88yLL9d69e+jfvz969eqFyMhIjB07tlAyV1BR5dixY0esWLEC+vr64uck/74Lll1RZs2ahe+//x7nz5+HsbEx+vTpo/A+F6e4z3h+9+/fR69evdC2bVtcunQJ/v7+2LBhA7799luF5QK2BUCuLceJf05g6dKlWLBggULPx+z94WZvlUHNmsKAp4MHA3v3Av81yWCMMVZ6U6dOxeXLl3Hq1KlC80ozSPfixYvh6+sr/q2np1dkolSchOcJSEgr/hf1smKmawYzvZKNhp6QkICcnBz0798flpaWAKBQwyKXy5GVlVWoCdBXX30l/t/KygqfffYZdu7ciS+++AJyuRy6urrQ0NBQWO/48eO4cuUKkpKSxHH9vv/+e+zbtw+7d+/G+PHj3/qY87t58yb279+P0NBQ8UZ2+/btsLCwwL59+zBo0CAAwMuXL7F69Wq0b98egNAE0tbWFufOnUO7du0QHx+PWbNmwcbGBgDQuHFjcR/Lli3D8OHDxZqWxo0bY9WqVXBycoK/vz+0tIQxXrp166ZwQz9kyBDMnDkTp06dQufOnQEAAQEBGD58uNid76effiou36BBA6xatQrt2rVDWloadHV1xZpMY2PjIp+XKa4MgoOCYf8/e7EM1q1bh4b/DdY7depULFiwoMiy9ff3R4MGDbB8+XJIJBI0adIEV65cwZJieq0trhwNDAwgkUiUNjErWHYFa5jyeHt7w8XFBYDwHtatWxeBgYEYPHhwkTHl0dXVLfIznt/atWthYWGB1atXQyKRwMbGBg8ePMDs2bPx9ddfi+9dU/umGOc1Do1qN4JDUwesXr0ax44dE+Nj7w8nP5XFwIFAnz7A1KlAt24AP9jJGGOl5unpif379+PkyZOom69JWkkG6S5ozpw58PLyeueYfgr/Cb4hvm9esAx4O3nDx9mnRMs6ODige/fusLe3h5ubG1xdXTFw4ECFAcqV2b17N1asWIFbt24hLS0NOTk50NfXL3ad8PBwpKWlwdDQUGF6RkYGbt++XaJ4SyIqKgoaGhpiUgMAhoaGaNKkCaLy9ayqoaGBNm3aiH/b2NigRo0aiIqKQrt27eDl5YWxY8di69at6NGjBwYNGiQmCeHh4bh16xa2b98urk9EyM3NRWxsLGxtbQFAYfsAYGRkBBcXF2zfvh2dO3dGbGwsTp8+DX9/f3GZiIgI+Pj4IDIyEo8fP0buf8+WxcfHw87O7p3KoLF1Y8TeihWnaWtri8cEAGZmZmITu6K226FDB4UfCxzfMFB7ceVYnIJlV5T8+69Vq1ah97ksREVFwdHRUeG4O3XqhLS0NPz777+oV68eABTqIOFN5cnKDyc/lYVEAqxZA9jZAbNnAz/9pOqIGGOs0iAieHp6IjAwEMHBwahfv77C/PyDdOcN5ZA3SHdRv1zLZDKxliJvHxkZGaWObULrCejTpE+p13sbZrolq/UBhAe7jxw5grCwMBw+fBh+fn6YN28ezp49W6j88pw5cwZDhw6Fr68v3NzcYGBggB07duCHH34odl+5ubkwMzMTnxvKryx7caMiuh1XVsOnrMYvb5qPjw+GDx+OgwcP4q+//oK3tzd27NiBTz75BLm5uZgwYQKmTZtWaP28G2EA0NHRKTR/xIgRmD59Ovz8/BAQEICmTZvCwcEBAJCeng5XV1e4urpi27ZtMDIyQnx8PNzc3JBdih4Fiy0DvD7mvGZ8+Y+9qHWL225xiivH4igru5LKew/V1NQKxVzSJnH5Kfvs5G03/3Rl5ZnLPfmqBCc/lUndusB33wFTpgAjRgBduqg6IsYYqxSmTJmCgIAA/PHHHwrN0wwMDCCXyxUG6W7cuDEaN26MRYsWKQzSXV7M9EreFO19k0gk6NSpEzp16oSvv/4alpaWCAwMhJeXF6RSKV69eqWwfGhoKCwtLTFv3jxx2t27dxWWUbZeq1atkJiYCA0NDfGB8/JgZ2eHnJwcnD17Vmzy9ejRI8TExIg1MgCQk5ODCxcuoF27dgCEZ2iePn0qNs8CAGtra1hbW2PmzJkYNmwYNm3ahE8++QStWrXCtWvX0KhRo1LH169fP0yYMAFBQUEICAiAu7u7OO/GjRtISUnBd999Jw4Pkr+TBQBij3EFy7ckZXDr5i2MmDKi1DHn3+6+ffsUpp05c+aN6xVVjso+J6V15swZMeF88uQJYmJixPfQyMgIiYmJCslLwQ4TShKDnZ0d9uzZo7CdsLAw6OnpoU6dOu8UPysf3OFBZTNxItCxozD2D3edyhhjJeLv74/U1FQ4OzvDzMxMfO3cuVNcpiSDdFcnZ8+exaJFi3DhwgXEx8dj7969SE5OFpMEKysrXL58GdHR0UhJScHLly/RqFEjxMfHY8eOHbh9+zZWrVqFwMBAhe1aWVkhNjYWkZGRSElJQVZWFnr06AFHR0f069cPf//9N+Li4hAWFoavvvqq0A1+fvHx8YiMjER8fDxevXqFyMhIREZGIi0tTenyjRs3Rt++fTFu3DicOnUKly5dwsiRI1GnTh307dtXXE5TUxOenp44e/YsLl68iP/973/o0KED2rVrh4yMDEydOhXBwcG4e/cuQkNDcf78ebFcZs+ejdOnT2PKlCmIjIwUn7HxLEGnRTo6Oujbty/mz5+PqKgohcS7Xr16kEql8PPzw507d7B///5CY/dYWlpCIpHgzz//RHJystJyKKoMzM3N4eTm9MYYizJx4kTcvn0bXl5eiI6ORkBAgNiTnzJvKkcrKyukpaXh2LFjSElJwYsXL0od04IFC3Ds2DFcvXoVHh4eqF27tjhuj7OzM5KTk7F06VLcvn0ba9aswV9//aWwvrLPeEGTJ0/GvXv34OnpiRs3buCPP/6At7c3vLy8xOd9WAVDlVBubi6lp6dTxIMIVYeiGteuEWlqEn31laojYYxVQ3nn4NzcXFWHUqEUd23KyMig69evU0ZGxvsP7C1dv36d3NzcyMjIiGQyGVlbW5Ofn584PykpiVxcXEhXV5cA0IkTJ4iIaNasWWRoaEi6uro0ZMgQWr58ORkYGIjrZWZm0oABA6hGjRoEgDZt2kRERM+ePSNPT08yNzcnTU1NsrCwoBEjRlB8fDwREaVlpdH5++cpLStN3Nbo0aMJQKFXXizKPH78mNzd3cnAwIDkcjm5ublRTEyMOH/Tpk1kYGBAe/bsoQYNGpBUKqVu3bpRXFwcERFlZWXR0KFDycLCgqRSKZmbm9PUqVMV3ttz586JZaOjo0PNmzenhQsXivMtLS1p+fLlSuM7ePAgAaAuXboUmhcQEEBWVlYkk8nI0dGR9u/fTwAoIiJCXGbBggVkampKEomERo8eTURETk5ONH369GLLIPJqpFi+eWWQX2BgIL3ptvHAgQPUqFEjkslk1LlzZ9q4cSMBoCdPniiUbUnLceLEiWRoaEgAyNvbu8iyi42NVSiHEydOEAA6cOAANW3alKRSKbVt25YiIyMV1vP39ycLCwvS0dGhUaNG0cKFC8nS0lKcr+wzXnBfRETBwcHUtm1bkkqlZGpqSrNnz6aXL1+K852cnGjy1MkKn9++ffuK7w97e3nn1ot3L5b4uiQheotGmipG/7WrjkmNQQuzFqoORzV8fICFC4GLF4FSjG/AGGPvKu8cnNdcjAmKuzZlZmYiNjYW9evXF3v7YqWTnp2OqJQo2Na2hY707Z/5YMpx+ZYvLt/ykXduzdTJRJPaTUp0XeL6uMpqzhygcWNg3DjgHdvEMsYYY4wxVh1w8lNZyWTAzz8DZ88Ca9eqOhrGGGOMMcYqPE5+KrNOnYBJk4RaoPh4VUfDGGOMMcZYhcbJT2W3eLEw4OmkSUDle3yLMcYYY4yx94aTn8rOwEAY/PTQISBfl62MMcYYY4wxRZz8VAV9+wIDBgDTpwOPH6s6GsYYY4wxxiokTn6qCj8/ICsL+PxzVUfCGGOMMcZYhcTJT1VhZgYsWwZs2gQcO6bqaBhjjDHGGKtwOPmpSsaMAZycgAkTgBcvVB0NY4wxxhhjFQonP1WJmhqwfj3w77+Ar6+qo2GMMcYqnc2bN6NGjRqqDqNMOTs7Y8aMGeW+n9DQUNjb20NTUxP9+vUr9/1VFXFxcZBIJIiMjAQABAcHQyKR4OnTp2W+L4lEgn379indb3nuqyLh5KeqsbYGvv4a+OEHICJC1dEwxhirojw8PN7qBtfHxwctWrQokxgWLlyIjh07Qltbu8olLG+jqJvmvXv34ptvvin3/Xt5eaFFixaIjY3F5s2by31/VVXHjh2RkJAAAwODNy5b2kQpISEBPXv2fMcIFRX1nS6PfZUFTn6qolmzADs7YOxYICdH1dEwxhgrS0ePCuf4o0dVHYnKZWdnY9CgQZg0aZKqQ3kn2dnZ5br9WrVqQU9Pr1z3AQC3b99Gt27dULduXaXJKBEhh+9L3kgqlcLU1BQSiaTMtpn3GTM1NYVMJiuz7Rbnfe6rNDj5qYo0NYFffhFqflauVHU0jDHGygoRMHcuEBUl/FvOg1vv3r0b9vb2kMvlMDQ0RI8ePZCeng4fHx9s2bIFf/zxByQSCSQSCYKDgwEAs2fPhrW1NbS1tdGgQQPMnz8fL1++BCA0KfP19cWlS5fE9fJqCFJTUzF+/HgYGxtDX18f3bp1w6VLl4qNz9fXFzNnzoS9vX2Jj+nJkycYNWoUatasCW1tbfTs2RM3b94stNy+fftgbW0NLS0tuLi44N69e+K8S5cuoWvXrtDT04O+vj5at26NCxcuiPPDwsLQpUsXyOVyWFhYYNq0aUhPTxfnW1lZ4dtvv4WHhwcMDAwwbtw4ODo64ssvv1SIITk5GZqamjhx4gQAYNu2bWjTpg309PRgamqK4cOHIykpCYDQhKlr164AgJo1a0IikcDDwwNA4WZvysrg1s1b4vy8pn9///03bG1toauriw8//BAJCQlKyzSv+dSjR4/w6aefiu9rXq3E33//jTZt2kAmk+Gff/4BEWHp0qVo0KAB5HI5HBwcsHv3boVtHjp0CNbW1pDL5ejatSs2b96sUMOhrLZhxYoVsLKyUpi2adMm2NraQktLCzY2Nli7dm2huPfu3YuuXbtCW1sbDg4OOH36tMI2QkND4eTkBG1tbdSsWRNubm548uQJfv31VxgaGiIrK0th+QEDBmDUqFFKywoAzp07h5YtW0JLSwtt2rRBRIGWOgVrc+7evYuPP/4YNWvWhI6ODpo2bYpDhw698T2fOnUqvLy8ULt2bbi4uABQ3hTtxo0b6NixI7S0tNC0aVPxuwwobwa6b98+MTEr7jtdcF9XrlxBt27dxPPJ+PHjkZaWJs7Pq03+/vvvYWZmBkNDQ0yZMkU8f5QZqoRyc3MpPT2dIh5EqDqUim36dCK5nOj2bVVHwhirQvLOwbm5uaoOpUIp7tqUkZFB169fp4yMjHfbSVAQkZDyCK+goHfbXjEePHhAGhoa9OOPP1JsbCxdvnyZ1qxZQ8+fP6fnz5/T4MGD6cMPP6SEhARKSEigrKwsIiL65ptvKDQ0lGJjY2n//v1kYmJCS5YsISKiFy9e0GeffUZNmzYV13vx4gXl5uZSp06d6OOPP6bz589TTEwMffbZZ2RoaEiPHj0iIqK0rDQ6f/88pWWlFYp106ZNZGBgUKLj6tOnD9na2tLJkycpMjKS3NzcqFGjRpSdnS1uS1NTk9q0aUNhYWF04cIFateuHXXs2FHcRtOmTWnkyJEUFRVFMTExtGvXLoqMjCQiosuXL5Ouri4tX76cYmJiKDQ0lFq2bEkeHh7i+paWlqSvr0/Lli2jmzdv0s2bN8nPz4/q1aun8L3y8/OjOnXq0KtXr4iIaMOGDXTo0CG6ffs2nT59mjp06EA9e/YkIqKcnBzas2cPAaDo6GhKSEigp0+fEhGRk5MTTZ8+vdgyaNiwIZ2OO01pWWliGfTo0YPOnz9P4eHhZGtrS8OHD1dapjk5OZSQkED6+vq0YsUK8X09ceIEAaDmzZvT4cOH6datW5SSkkJz584lGxsbCgoKotu3b9OmTZtIJpNRcHAwERHFx8eTTCaj6dOn040bN2jbtm1kYmJCAOjJkydEROTt7U0ODg4KcSxfvpwsLS3Fv9evX09mZma0Z88eunPnDu3Zs4dq1apFmzdvJiKi2NhYAkA2Njb0559/UnR0NA0cOJAsLS3p5cuXREQUERFBMpmMJk2aRJGRkXT16lXy8/Oj5ORkevHiBRkYGNCuXbvEfSYnJ5NUKqXjx48rxJb3+X34+CEZGRnRkCFD6OrVq3TgwAFq0KABAaCIiAgiIrHc8o61d+/e5OLiQpcvX6bbt2/TgQMHKCQk5I3vua6uLs2aNYtu3LhBUVFRREQEgAIDAxWOv27durR79266fv06jR07lvT09CglJYWIlH+3AgMDKS+FKOo7XXBf6enpZG5uTv3796crV67QsWPHqH79+jR69Ghxu6NHjyZ9fX2aOHEiRUVF0YEDB0hbW5vWr1+v9HNH9PrcevHuxRJflzj5qcqePyeqV4/IxYWIb1IYY2WEkx/l3ir5SU8nCg8v2evCBSI7OyI1NSHxUVMT/r5woeTbCA8X9lkC4eHhBIDi4uKUzh89ejT17dv3jdtZunQptW7dWvxb2U3rsWPHSF9fnzIzMxWmN2zYkH766SciKpvkJyYmhgBQaGioOC0lJYXkcrl4A7tp0yYCQGfOnBGXiYqKIgB09uxZIiLS09MTb6ALcnd3p/HjxytM++eff0hNTU18/y0tLalfv34KyyQlJZGGhgadPHlSnObo6EizZs0q8njOnTtHAOj58+dEVPimOU/+5Ke4Mli8brGY/ACgW7duicusWbOGTExMioyFiMjAwIA2bdok/p0Xz759+8RpaWlppKWlRWFhYQrrjhkzhoYNG0ZERHPmzCFbW1uFc8zs2bNLnfxYWFhQQECAwjLffPMNOTo6EtHrm/9ffvlFnH/t2jUCICYLw4YNo06dOhV5zJMmTRITUCKiFStWUIMGDQqdH/M+v6vWrKJatWpRer7vob+/f7HJj729Pfn4+Cjdf3HveYsWLQotryz5+e6778T5L1++pLp164o/WLwp+SFS/l4U3Nf69eupZs2alJb2+vt78OBBUlNTo8TERCISzimWlpaUk5MjLjNo0CAaMmSI0mMnervkR6Ns65FYhaKrC6xbB/TqBWzbBri7qzoixhhj+d24AbRu/Xbr5uYC168DbdqUbr3wcKBVqzcu5uDggO7du8Pe3h5ubm5wdXXFwIEDUbNmzWLX2717N1asWIFbt24hLS0NOTk50NfXf0NI4UhLS4OhoaHC9IyMDNy+ffvNx1RCUVFR0NDQQPv27cVphoaGaNKkCaKiosRpGhoaaJOvXG1sbFCjRg1ERUWhXbt28PLywtixY7F161b06NEDgwYNQsOGDcVjuXXrFrZv3y6uT0TIzc1FbGwsbG1tAUBh+wBgZGQEFxcXbN++HZ07d0ZsbCxOnz4Nf39/cZmIiAj4+PggMjISjx8/Rm5uLgAgPj4ednZ271QGja0bI/ZWrDhNW1tbPCYAMDMzE5vYlVb+Y71+/ToyMzPFZlh5srOz0bJlSzHGDh06KDzz4ujoWKp9Jicn4969exgzZgzGjRsnTs/JySnUkUDz5s3F/5uZmQEAkpKSYGNjg8jISAwaNKjI/YwbNw5t27bF/fv3UadOHWzatAkeHh5FPq8TfSMaDg4O0NbWLvGxTZs2DZMmTcLhw4fRo0cPDBgwQCHmohT8jBUl//7zPvv5vw9lISoqCg4ODtDR0RGnderUCbm5uYiOjoaJiQkAoGnTplBXVxeXMTMzw5UrV8o0Fk5+qrqePYFhw4CZM4EPPwSMjFQdEWOMsTw2NkIy8iZEwKhRQrL03w0vAGGIAxsb4NdfgZI+HG1jU6LF1NXVceTIEYSFheHw4cPw8/PDvHnzcPbsWdSvX1/pOmfOnMHQoUPh6+sLNzc3GBgYYMeOHfjhhx+K3Vdubi7MzMwUnjXIU5a9uFERz0gRUaGbVWU3r3nTfHx8MHz4cBw8eBB//fUXvL29sWPHDnzyySfIzc3FhAkTMG3atELr16tXT/x//pvAPCNGjMD06dPh5+eHgIAANG3aFA4ODgCA9PR0uLq6wtXVFdu2bYORkRHi4+Ph5uZWqg4Tii0DvD5mTU3NQsde1Lpvkv9Y8xK2gwcPok6dOgrL5T0cX5L9qKmpFVou/7Mhefv5+eefFRI9AAo314Disea9x3nry+XyYuNo2bIlHBwc8Ouvv8LNzQ1XrlzBgQMHilz+bcpw7NixcHNzw8GDB3H48GEsXrwYP/zwAzw9PYtdT9lnrKTyyuFN5VxSyr5jBfcFKP/c5eY/55UBTn6qgxUrAFtbIQHatk3V0TDGGMujrV2iWhj8/bdQy1NQXu1PSgrg5lbm4UkkEnTq1AmdOnXC119/DUtLSwQGBsLLywtSqRSvXr1SWD40NBSWlpaYN2+eOO3u3bsKyyhbr1WrVkhMTISGhkahB9bLkp2dHXJycnD27Fl07NgRAPDo0SPExMSINTKAUDtw4cIFtGvXDgAQHR2Np0+fwiZf4mhtbQ1ra2vMnDkTw4YNw6ZNm/DJJ5+gVatWuHbtGho1alTq+Pr164cJEyYgKCgIAQEBcM/XYuPGjRtISUnBd999BwsLCwBQ6GQBEMoWQKHyLUkZ3Lp5CyOmjCh1zKVlZ2cHmUyG+Ph4ODk5FblMwYfyz5w5o/C3kZEREhMTFW6q849XY2Jigjp16uDOnTsYMeLtj6t58+Y4duwYfIsZP3Hs2LFYvnw57t+/jx49eojvjzI2tjbYEbADGRkZYmJV8NiUsbCwwMSJEzFx4kTMmTMHP//8Mzw9PUv0nr/JmTNn0KVLFwDCZz88PBxTp04FIJTz8+fPkZ6eLiZTBccFUvadLsjOzg5btmxR2E5oaCjU1NRgbW391rG/De7trTowNgZ+/BHYvh346y9VR8MYY6w0iID584VaHmXU1IT5Zdzz29mzZ7Fo0SJcuHAB8fHx2Lt3L5KTk8UkwcrKCpcvX0Z0dDRSUlLw8uVLNGrUCPHx8dixYwdu376NVatWITAwUGG7VlZWiI2NRWRkJFJSUpCVlYUePXrA0dER/fr1w99//424uDiEhYXhq6++KnSDn198fDwiIyMRHx+PV69eITIyEpGRkQo9SOXXuHFj9O3bF+PGjcOpU6dw6dIljBw5EnXq1EHfvn3F5TQ1NeHp6YmzZ8/i4sWL+N///ocOHTqgXbt2yMjIwNSpUxEcHIy7d+8iNDQU58+fF8tl9uzZOH36NKZMmYLIyEjcvHkT+/fvf+Ov9IDwS33fvn0xf/58REVFYfjw4eK8evXqQSqVws/PD3fu3MH+/fsLjd1jaWkJiUSCP//8E8nJyUrLoagyMDc3h5Ob8mSkLOnp6eHzzz/HzJkzsWXLFty+fRsRERFYs2YNtmzZAgCYOHEibt++DS8vL0RHRyMgIKDQuEHOzs5ITk7G0qVLcfv2baxZswZ/FbjH8fHxweLFi7Fy5UrExMTgypUr2LRpE3788ccSxztnzhycP38ekydPxuXLl3Hjxg34+/sjJSVFXGbEiBG4f/8+fv75Z3z66afFbm/w0MFQU1PDmDFjcP36dRw6dAjff/99sevMmDEDf//9N2JjY3Hx4kUcP35c/LyV5D1/kzVr1iAwMBA3btzAlClT8OTJE/E42rdvD21tbcydOxe3bt1S+l4o+04XNGLECGhpaWH06NG4evUqTpw4AU9PT7i7u4tN3t6bNz4VVAFxhwdvITeXqEcPIktLoSMExhh7S9zhgXLl1ttbZiaRiYliL28FX6amwnJl6Pr16+Tm5kZGRkYkk8nI2tqa/Pz8xPlJSUnk4uJCurq6BIBOnDhBRESzZs0iQ0ND0tXVpSFDhtDy5csVHpjOzMykAQMGUI0aNQiA+ID8s2fPyNPTk8zNzUlTU5MsLCxoxIgRFB8fT0TKOzwYPXo0ASj0yotFmcePH5O7uzsZGBiQXC4nNzc3iomJEefnPeC9Z88eatCgAUmlUurWrZvY8UNWVhYNHTqULCwsSCqVkrm5OU2dOlXhvT137pxYNjo6OtS8eXNauHChON/S0pKWL1+uNL6DBw8SAOrSpUuheQEBAWRlZUUymYwcHR1p//79Cg/KExEtWLCATE1NSSKRiD1pFeztTVkZRF6NFMu3JA+5K1NUhwcFH8bPzc2llStXUpMmTUhTU5OMjIzIzc2NQkJCxGUOHDhAjRo1IplMRp07d6aNGzcW2pa/vz9ZWFiQjo4OjRo1ihYuXKjQ4QER0fbt26lFixYklUqpZs2a1KVLF9q7dy8RvX7gP3/5PXnypNBnKDg4mDp27EgymYxq1KhBbm5uhY7J3d2datWqVajTjjz5P7+nT58mBwcHkkql1KJFC7HHtqI6PJg6dSo1bNiQZDIZGRkZkbu7u9gbG1HJ3vM8UNLhQUBAALVv356kUinZ2trSsWPHFNYJDAykRo0akZaWFn300Ue0fv16hc9CUd/p/PsiEnpC7Nq1K2lpaVGtWrVo3LhxYmcdRMo7UZk+fTo5OTkpLVOit+vwQPJfcJUKESEjIwMxqTFoYdZC1eFUHnfuAM2aARMnCjVBjDH2FvLOwXK5vEwH4avsirs2ZWZmIjY2FvXr14eWllbpN37vHpCcXPR8Y2Ogbt3Sb7cSSc9OR1RKFGxr20JH+vbPMjDlKnr5BgcHo2vXrnjy5EmZPgdWVlxcXGBra4tVq1YpnV/Ry7eyyju3ZupkokntJiW6LvEzP9VJgwaAry/w5ZdCJwht26o6IsYYYyVhYSG8GGMVyuPHj3H48GEcP34cq1evVnU4rAQ4+aluZs4EfvsNGDsWuHABKNCrBmOMMcYYK5lWrVrhyZMnWLJkCZo0aaLqcFgJcPJT3WhoAL/8ArRrB3z/PTBnjqojYowxxhgrlrOz81t3tV2e4uLiVB0CKyXu7a06atUK8PISmsDdvKnqaBhjjDHGGHsvOPmprnx8gDp1gPHjy7x7VMYYY4wxxioiTn6qK21t4KefgOBgYONGVUfDGGPVQkVstsMYY5WVeE4tRcejnPxUZz16AKNHA59/DiQmqjoaxhirsjT/61zmxYsXKo6EMcaqDvGcWoqMhjs8qO5++AE4dAiYNg3YtUvV0TDGWJWkrq6OGjVqICkpCQCgra3NYySVUlZ2FpADZGVmQT1XXdXhVDlcvuWLy7dsERFevHiBpKQk1KhRAw/xsMTrcvJT3RkaAitXAsOHA/v3A336qDoixhirkkxNTQFATIBY6WS/ykbK8xRoPtOEVF2q6nCqHC7f8sXlWz5q1KgBU1NTPEzk5IeVxtChwNatwOTJgLMzoK+v6ogYY6zKkUgkMDMzg7GxMV6+fKnqcCqda0nXMDFoIvYM3oMmxjyeSlnj8i1fXL5lT1NTE+rqpa9FU2nys3btWixbtgwJCQlo2rQpVqxYgc6dO6sypOpJIgH8/YGmTYG5cwEeoZgxVk29j+uSurr6W12wqzuJpgR30+9CoimBlpaWqsOpcrh8yxeXb8Whsg4Pdu7ciRkzZmDevHmIiIhA586d0bNnT8THx6sqpOrN0hJYuBBYu1ZoBmdnBxw9quqoqqajR7l8yxuXcfkKDlZ1BOWCr0uMMVb1qSz5+fHHHzFmzBiMHTsWtra2WLFiBSwsLODv76+qkNjUqUCbNsCXXwJRUUItEHfLWraIhHLl8i0/XMbli0gYILkK4usSY4xVfSpp9padnY3w8HB8+eWXCtNdXV0RFhamipAYAKirA59+CkyaJPx9/jxw8CDg4qLauKqSI0eEcgW4fMsLl3H5OnIEuHhR1VGUOb4uMcZY9aCS5CclJQWvXr2CiYmJwnQTExMkKhlvJisrC1lZWQrTNDQ0oAY1HjCuLBEBO3YIHR7klevw4aqNqSrS03v9fy7f8sFlXK5IV1f4l6jKdNdc2usSwNem900NatCT6nH5lhMu3/LF5Vu+1P5rzFaS65JKOzwoGFxRAS9evBi++ZpZmJmZ4datW2hk0AgZGRnlHme1cuiQqiNgjDGVKel1CeBr0/tmbWCNxOlCIsrlW/a4fMsXl2/5amTQqMTLqiT5qV27NtTV1Qv9mpaUlFToVzcAmDNnDry8vMS/nz17hkaNGuHGjRvQy/8LLysTz58/R926dfHvv/9y+ZYDLt/yx2Vcvqrir5alvS4BfG163/h7Xb64fMsXl2/5Ks11SSXJj1QqRevWrXHkyBF88skn4vQjR46gb9++hZaXyWSQyWQK0xISEgAU/pWOlY3nz58D4PItL1y+5Y/LuPxUxTIt7XUJ4GuTKvD3unxx+ZYvLt/yU5oyVVmzNy8vL7i7u6NNmzZwdHTE+vXrER8fj4kTJ6oqJMYYY9UYX5cYY6zqU1nyM2TIEDx69AgLFixAQkICmjVrhkOHDsHS0lJVITHGGKvG+LrEGGNVn0o7PJg8eTImT55c6vVkMhm8vb0LNTdgZYPLt3xx+ZY/LmP2tt72ugTw5668cfmWLy7f8sXlW3FIqCo+ucoYY4wxxhhjBaipOgDGGGOMMcYYex84+WGMMcYYY4xVC5z8MMYYY4wxxqqFSpn8rF27FvXr14eWlhZat26Nf/75R9UhVRknT57Exx9/DHNzc0gkEuzbt0/VIVUZixcvRtu2baGnpwdjY2P069cP0dHRqg6ryvD390fz5s2hr68PfX19ODo64q+//lJ1WKwa4WtT+eDrUvnia1P54mtTxVPpkp+dO3dixowZmDdvHiIiItC5c2f07NkT8fHxqg6tSkhPT4eDgwNWr16t6lCqnJCQEEyZMgVnzpzBkSNHkJOTA1dXV6Snp6s6tCqhbt26+O6773DhwgVcuHAB3bp1Q9++fXHt2jVVh8aqAb42lR++LpUvvjaVL742VTyVrre39u3bo1WrVvD39xen2draol+/fli8eLEKI6t6JBIJAgMD0a9fP1WHUiUlJyfD2NgYISEh6NKli6rDqZJq1aqFZcuWYcyYMaoOhVVxfG16P/i6VP742lT++NqkWpWq5ic7Oxvh4eFwdXVVmO7q6oqwsDAVRcVUYe3atdi8efN72deLFy/g4+OD4ODgMt1uamoqAOEkWB2cOnUKY8eORevWrSGTySCRSBAXF1cu+3r16hV27NiB9PR0ODo6lss+GMvD1yaWh69NlQ9fm6qfSpX8pKSk4NWrVzAxMVGYbmJigsTERBVFxVThfV9gfH19y/QCQ0Tw8vLCBx98gGbNmpXZdiuyY8eO4ejRo6hXrx46duxYLvu4cuUKdHV1IZPJMHHiRAQGBsLOzq5c9sVYHr42sTx8bap8+NpU/VSq5CePRCJR+JuICk1jrCKbOnUqLl++jN9++63QvBcvXqggovI3f/58xMXFITAwEL179y6XfTRp0gSRkZE4c+YMJk2ahNGjR+P69evlsi/GCuJrE6vs+NrE16bqoFIlP7Vr14a6unqhX9KSkpIK/eLGKpZTp06he/fu0NPTg7a2Njp27IiDBw8qLOPj46P0RmHz5s0K1dBWVla4du0aQkJCIJFIIJFIYGVlBQAIDg6GRCLBtm3b4OXlBVNTU8jlcjg5OSEiIkJhu87OznB2di60Pw8PD3F7cXFxMDIyAgD4+vqK+/Pw8CjyWN8Ug6enJ/bv348TJ07gq6++gq6uLq5cuQJXV1fo6emhe/fuAIDHjx9j8uTJqFOnDqRSKRo0aIB58+YhKytLYX+5ubnw8/NDixYtIJfLUaNGDXTo0AH79+9XWG7nzp1wdHSEjo4OdHV14ebmVqhM7ty5g6FDh8Lc3BwymQwmJibo3r07IiMjxWWOHz8OZ2dnGBoaQi6Xo169ehgwYMAbL4xqauV/upFKpWjUqBHatGmDxYsXw8HBAStXriz3/bLqja9NlRdfm/jaxNem6qdSJT9SqRStW7fGkSNHFKYfOXKk3Koq2bsLCQlBt27dkJqaig0bNuC3336Dnp4ePv74Y+zcubPU2wsMDESDBg3QsmVLnD59GqdPn0ZgYKDCMnPnzsWdO3fwyy+/4JdffsGDBw/g7OyMO3fulGpfZmZmCAoKAgCMGTNG3N/8+fPfuK6yGDp06IBdu3bh+PHjqF+/PgDheYE+ffqgW7du+OOPP+Dr64vMzEx07doVv/76K7y8vHDw4EGMHDkSS5cuRf/+/RX24+HhgenTp6Nt27bYuXMnduzYgT59+ii0WV60aBGGDRsGOzs77Nq1C1u3bsXz58/RuXNnhV+fevXqhfDwcCxduhRHjhyBv78/WrZsiadPnwIQLri9e/eGVCrFxo0bERQUhO+++w46OjrIzs4uVdm+D0RU6ILMWFnja1PlxNcmvjapCl+bVIwqmR07dpCmpiZt2LCBrl+/TjNmzCAdHR2Ki4tTdWhVwvPnzykiIoIiIiIIAP34448UERFBd+/efettdujQgYyNjen58+fitJycHGrWrBnVrVuXcnNziYjI29ublH0kN23aRAAoNjZWnNa0aVNycnIqtOyJEycIALVq1UrcLhFRXFwcaWpq0tixY8VpTk5OSrcxevRosrS0FP9OTk4mAOTt7V2i4y0qhpEjRxIA6t27NyUkJFBCQgINHjyYANDGjRsVtrFu3ToCQLt27VKYvmTJEgJAhw8fJiKikydPEgCaN29ekfHEx8eThoYGeXp6Kkx//vw5mZqa0uDBg4mIKCUlhQDQihUritzW7t27CQBFRkaWqCyKsmzZskLv6buaM2cOnTx5kmJjY+ny5cs0d+5cUlNTE8uKsfLE16byUx7XJSK+NuXha9NrfG2qHipVzQ8ADBkyBCtWrMCCBQvQokULnDx5EocOHYKlpaWqQ6sSLly4gJYtW6Jly5YAAC8vL7Rs2RJff/31W20vPT0dZ8+excCBA6GrqytOV1dXh7u7O/79999yGUxt+PDhCs0ULC0t0bFjR5w4caLM91XSGLZt2wYAOHjwIMzMzGBmZoZdu3YBAAYMGKCw7vHjx6Gjo4OBAwcqTM9r0nDs2DEAEAdKmzJlSpFx/P3338jJycGoUaOQk5MjvrS0tODk5CQ+LFurVi00bNgQy5Ytw48//oiIiAjk5uYqbKtFixaQSqUYP348tmzZUupfK8vTw4cP4e7ujiZNmqB79+44e/YsgoKC4OLiourQWDXA16byU9bXJYCvTXxten/42lTxVLrkBwAmT56MuLg4ZGVlITw8nPuhL0POzs4gokKvt+295smTJyAimJmZFZpnbm4OAHj06NG7hKyUqamp0mnlsa+SxkBEGDJkCGrUqCGW6+jRo6GtrQ19fX2FZR89egRTU9NC7cyNjY2hoaEhHkdycjLU1dWVHm+ehw8fAgDatm0LTU1NhdfOnTuRkpICQHhY+9ixY3Bzc8PSpUvRqlUrGBkZYdq0aXj+/DkAoGHDhjh69CiMjY0xZcoUNGzYEA0bNqwQbZc3bNggnheSkpJw9OhRvriw94qvTeWjrK9LAF+b8uNrU/nia1PFo6HqAFjVVrNmTaipqSEhIaHQvAcPHgAQHhYGAC0tLQBAVlYWZDKZuFzeCbA0lHUvm5iYCENDQ/FvLS0tcTyD/N5mf28bA1C4hygAMDQ0xNmzZwv1FpWUlIScnByxzIyMjPDq1SskJiYqvYgDr8t39+7db/wV2tLSEhs2bAAAxMTEYNeuXfDx8UF2djbWrVsHAOjcuTM6d+6MV69e4cKFC/Dz88OMGTNgYmKCoUOHFrt9xhirCPjaVHwMAF+bWNVVKWt+WOWho6OD9u3bY+/evcjIyBCn5+bmYtu2bahbty6sra0BQOzF5vLlywrbOHDgQKHtymQyhe0V9Ntvv4GIxL/v3r2LsLAwhR50rKysEBMTo/DQ4aNHjwoNSph3sStuf28bQ1G6d++OtLQ07Nu3T2H6r7/+Ks4HgJ49ewKAwqjyBbm5uUFDQwO3b99GmzZtlL6Usba2xldffQV7e3tcvHix0Hx1dXW0b98ea9asAQClyzDGWEXE1ya+NrHqi2t+WLlbvHgxXFxc0LVrV3z++eeQSqVYu3Ytrl69it9++0389ahXr16oVasWxowZgwULFkBDQwObN2/GvXv3Cm3T3t4eO3bswM6dO9GgQQNoaWnB3t5enJ+UlIRPPvkE48aNQ2pqKry9vaGlpYU5c+aIy7i7u+Onn37CyJEjMW7cODx69AhLly4tVM2vp6cHS0tL/PHHH+jevTtq1aqF2rVrixfEopQkhqKMGjUKa9aswejRoxEXFwd7e3ucOnUKixYtQq9evdCjRw8Awi9d7u7u+Pbbb/Hw4UN89NFHkMlkiIiIgLa2Njw9PWFlZYUFCxZg3rx5uHPnDj788EPUrFkTDx8+xLlz56CjowNfX19cvnwZU6dOxaBBg9C4cWNIpVIcP34cly9fxpdffgkAWLduHY4fP47evXujXr16yMzMxMaNGwFAjKkoycnJCAkJASAM+AYI7cKNjIxgZGQEJyenN5YLY4yVFb428bUJ4GtTtfT++lZg1dk///xD3bp1Ix0dHZLL5dShQwc6cOBAoeXOnTtHHTt2JB0dHapTpw55e3vTL7/8Uqj3lbi4OHJ1dSU9PT0CIPaAk9ebzdatW2natGlkZGREMpmMOnfuTBcuXCi0vy1btpCtrS1paWmRnZ0d7dy5s1CPOkRER48epZYtW5JMJiMANHr06CKPtTQxjB49mnR0dJRu59GjRzRx4kQyMzMjDQ0NsrS0pDlz5lBmZqbCcq9evaLly5dTs2bNSCqVkoGBATk6OhYq33379lHXrl1JX1+fZDIZWVpa0sCBA+no0aNERPTw4UPy8PAgGxsb0tHRIV1dXWrevDktX76ccnJyiIjo9OnT9Mknn5ClpSXJZDIyNDQkJycn2r9/f5HlUbBclL2U9WzEGGPlja9NfG3ia1P1IyHKV/fJWCUXHByMrl274vfffy/UG011ioExxljFURGuCxUhBsYqAn7mhzHGGGOMMVYtcPLDGGOMMcYYqxa42RtjjDHGGGOsWuCaH8YYY1VeTk4OvvrqK9SvXx9yuRwNGjTAggULFEaKJyL4+PjA3Nwccrkczs7OuHbtmgqjZowxVtY4+WGMMVblLVmyBOvWrcPq1asRFRWFpUuXYtmyZfDz8xOXWbp0KX788UesXr0a58+fh6mpKVxcXMRR5BljjFV+3OyNMcZYlffRRx/BxMREHCUeAAYMGABtbW1s3boVRARzc3PMmDEDs2fPBgBkZWXBxMQES5YswYQJE1QVOmOMsTJUKQc5zd9MIW8QMsYYY+9H/t/M1NQqRwOCDz74AOvWrUNMTAysra1x6dIlnDp1CitWrAAAxMbGIjExEa6uruI6MpkMTk5OCAsLK1Hyw9cmxhhTjdJclypl8gMAmZmZqg6BMcaqNS0tLVWHUGKzZ89GamoqbGxsoK6ujlevXmHhwoUYNmwYACAxMREAYGJiorCeiYkJ7t69q3SbWf9n787joqreP4B/hm3YURBZFAEXFFxwVzQTU0DLXMpcQy01zZVoMTMTtSSt1EKz9FtoKamlmKYppqIJLojgiiAI4gIBigrI6jy/P86PKwPDpozD8rxfr3kp956598yZmXvm3HPOc/LzkZ+fr7RNR6fOVquMMVbnVaVeqtNXaX19fb67xhhjzxkR1bkbUNu3b8eWLVsQFBSE9u3bIzo6Gj4+PrC1tcWkSZOkdKXrFCIqt57x9/fHkiVLpL9NTEyQmprKdRNjjD1n1amX6uScHyJCbm4uDAwMuIJhjLHnrC5eg+3s7PDxxx9j1qxZ0rbPP/8cW7ZswdWrV3H9+nW0atUK586dQ5cuXaQ0w4cPR6NGjbB58+Yyxyyv56culQtjjNUH1amX6sZgbcYYY+wZPHr0qMw4cG1tbWmejqOjI6ytrXHo0CFpf0FBAY4dO4Y+ffqoPKZcLoepqan0MDExUd8LYIwxViPq9LA3xhhjrCpeffVVfPHFF2jRogXat2+PqKgorFq1Cm+//TYAMdzNx8cHy5cvR5s2bdCmTRssX74choaGGD9+vIZzzxhjrKZw44cxxli9FxAQgEWLFmHmzJlIS0uDra0tpk+fjs8++0xK89FHHyE3NxczZ85EZmYmevXqhZCQEO7RYYyxeoTn/DDGGKsWvgarxuXCGGOawXN+GGOMMcYYY6wUbvwwxhhjjDHGGgRu/DDGGGOMMcYaBG78MMYYY4wxxhoEbvwwxhhjjDHGGgRu/DDGGGOMMcYaBG78MMYYY4wxxhoEbvwwxhhjjDHGGgRu/DDGGGOMMcYaBG78MMYYY4wxxhoEbvwwxhhjjDHGGgRu/DDGGGOMMcYaBG78MMYYY4wxxhoEbvwwxhhjjDHGGgRu/DDGGGOMMcYaBG78MMYYY4wxxhoEbvwwxhhjjDHGGgRu/DDGGGOMMcYahBpv/BQVFeHTTz+Fo6MjDAwM0LJlSyxduhQKhUJKQ0Tw8/ODra0tDAwM4O7ujsuXL9d0VhhjjDHGGGNMUuONnxUrVuCHH37A2rVrERMTg5UrV+Krr75CQECAlGblypVYtWoV1q5di4iICFhbW8PDwwNZWVk1nR3GGGOMMcYYAwDIiIhq8oBDhw6FlZUVfvrpJ2nb66+/DkNDQ/z6668gItja2sLHxwfz588HAOTn58PKygorVqzA9OnTKz0HESE3NxcGBgaQyWQ1mX3GGGOV4GuwalwujDGmGdW5/tZ4z88LL7yAw4cPIy4uDgBw/vx5nDhxAi+//DIAIDExEampqfD09JSeI5fL0b9/f4SHh6s8Zn5+Ph4+fCg9uIeIMcYYY4wxVl013viZP38+xo0bh3bt2kFXVxddunSBj48Pxo0bBwBITU0FAFhZWSk9z8rKStpXmr+/P8zMzKRH8+bNazrbjD03KVkp8Av1Q0pWiqazwhhjjDHWoNR442f79u3YsmULgoKCcO7cOWzevBlff/01Nm/erJSudJcUEZXbTbVgwQI8ePBAety6daums83Yc5OSnYIlx5YgJZsbP4wxxmoHvjHHGooab/x8+OGH+PjjjzF27Fh07NgR3t7eeO+99+Dv7w8AsLa2BoAyvTxpaWlleoOKyeVymJqaSg8TE5OazjZjz43J8dO4vFb8yxhjrIr++QdwcRH/shrHN+ZYQ1HjjZ9Hjx5BS0v5sNra2lKoa0dHR1hbW+PQoUPS/oKCAhw7dgx9+vSp6ewwVrsQwdZ/LVwyAFv/tUDNxhthjLH6iQj45BMgJkb8y9dOxthTqvHGz6uvvoovvvgC+/btQ1JSEoKDg7Fq1SqMHDkSgBju5uPjg+XLlyM4OBiXLl3C5MmTYWhoiPHjx9d0dhirXUJCYHT+CgCIf0NCNJwhxhirA0JCgIgI8f+ICL52qgGPSmANRY2Hus7KysKiRYsQHByMtLQ02NraYty4cfjss8+gp6cHQMzvWbJkCX788UdkZmaiV69eWLduHTp06FClc3A4UVYnEQG9eoEiIyFTKEBaMsi6dQdOnwb4c8zqEL4Gq8blogaFhUBYGDBuHCg1FTIABECmrQ00aQLI5YCuLqCnV/ahantVt9XE87W16861nQg5XTrA6PwV5Li6wCjqUt3JO2Oo3vW3xhs/zwNXMKxOOnAAGDKk7Pa1a4FZs55/fhh7SnwNVo3LpYakpAB//w3s3w8cOgQ8fKg6nbc34OAAFBQoPwoLq7atorSPH9fMa9Fk46s6aY8eBYYOfZLvAwcAL6+aKQPGngNu/DBW22RmAq1aiX9VGT0a+PxzoE2b55svxp4CX4NV43J5SkVFoge8uMETFSV6HXr1EjeMtm8HYmOVGyTa2kDXrurrOX/8WLlhVBMNKnU+v6Yaa/j/njW5HGjfHjAzA0xNlR+qtpXe/v8jfdgTKVkp+DHyR0zvNh02Jjaazk69w40fxmqTkyeBESOAtLTy0zRpIhpGb78NfPYZwGtZsVqMr8GqcblUQ1oacPCgaOwcPCiufxYWwODBwMsvA56e4rp48KDYVh7uoRCKG2tP06CKiABWrCh7zJdfFg2ahw+VHw8eiH+LisrPj1xe/QaTqu1yufrK7Dk7l3IO3TZ0Q+Q7kehq01XT2al3qnP91XlOeWKs4VEoRIXy6aeAgYG4O6nqXoOWFmBvD3z8MeDvD/zyCzB7NrBggfgxwBirEbdv38b8+fPx999/Izc3F05OTvjpp5/QrVs3AE/mo27YsEFpPmr79u01nPN6QKEAzp4VjZ39+8X/iYDu3cX17uWXgR49RI9OMSJg0SJxjfz/iLFKtLTEfk9Pnp+irS0e+vrVex6RqKe0tcv2rKWnA3/9pbpsiYC8PNWNIlWP4n3JyWW3FxaWnz89vafreSq9XS7X+GekOKCEbrvTwBhu/GgS9/wwpg4pKWI8+pEjwEcfAYGBFff8WFsDSUlAfj6wahXwzTeiYv/gA+C99wBj4+eWdcYqUxevwZmZmejSpQsGDBiAd999F02bNkVCQgIcHBzQqlUrAMCKFSvwxRdfYNOmTXBycsLnn3+O48ePIzY2tkrry9XFclGru3dFVLbi3p30dKBRI9FYefll0aNTzvp+AMT10N4e+O+/8tMUXzvrUQ/Bc6XpnjUi8T6X11iqzvaCgvLPo6v7dD1PpR/FNzKf4nVyQAn14mFvjGnSgQPAxIniztnWrcBLLwE3b4qKH0BMegwm7HoTW1/bAmdLZ/Gcpk2Vh7qlp4teoHXrxEV44UJgxgyu4FmtUBevwR9//DHCwsLw77//qtxPRLC1tYWPjw/mz58PAMjPz4eVlRVWrFiB6dOnV3qOulguNUqhAKKjn8zdOXVKbHN1FY2dl18GevcGdKox6KS6105Wdf8fgRSRkeX3rHXrVncikqpqRD1NQyovr/xz6OiobhRV1pC6fBmYN+/JcXi4Zo3jxg9jmlBQIBopX38tJulu2iQq5lKqNe43ORlYskQcq3lz8X9vb+WhIYw9Z3XxGuzi4gIvLy/cunULx44dQ7NmzTBz5kxMmzYNAHD9+nW0atUK586dQ5cuXaTnDR8+HI0aNcLmzZvLHDM/Px/5+flK23R0dOpUuTyzBw9ERLb9+0WjJzUVMDEBPDye9O40a1Yjp+I5EzWMe9ZUy88HsrKevRGVm6vy8CSTQdaxo7hR0FCuE88Bz/lh7Hm7fh0YO1ZczL75BvDxEXfNnlWLFsBPPwEffijGtr/1FrBypYgMN3IkXzgZq6Lr169j/fr18PX1xSeffIIzZ85g7ty5kMvlmDhxIlJTUwEAVqWGYVlZWeHGjRsqj+nv748lS5ZIf5uYmEjHqbeIgEuXnszdCQsTc0Xatxc3ZoYMAfr25WhfdYFcLoIdVNaz1pAaPoB4vXK5CLjxLAoLRSPor7+AyZOlzTIi4MIF4JVXgO+/F+Ha2XPFjR/GntVvvwHTp4tKIjxcTOCtae3aAb//LiYJf/IJ8PrrYnKwvz8wcGDNn4+xekahUKB79+5Yvnw5AKBLly64fPky1q9fj4kTJ0rpSt8xJKJy7yIuWLAAvr6+6st0bZGVBRw+/KR359YtwNAQGDRIrFM2ZIjoQWB1j52deADITQGiTgG5nZwB7ll7drq6gLm5GL5eOqCETCZ6TFu3BiZNEvX6/889ZOpXA7emGWugcnKAKVOA8eOBV18Fzp1TT8OnpO7dxQTiI0dEz9KgQeIREaHe8zJWx9nY2MDFxUVpm7OzM5KTkwEA1tbWAFCm5yYtLa1Mb1AxuVwOU1NT6VGVoAh1AhEQEyOCrwwaJKJOjhwJHDsGjBolrkF37wJ//inmInLDhzHVQkJE/Vx6HSYiESr87beBffuAtm1F79C1axrJZkPDjR/GnsaFC6Ihsm2biOS2ZYuY2Pi8DBgg1g8KDhaR5Xr2BF57Dbhy5fnlgbE6pG/fvoiNjVXaFhcXB/v//+Hu6OgIa2trHDp0SNpfUFCAY8eOoU+fPs81rxrx6JH4ETZrFtCyJeDiIuYw6umJRlB8vFhodPVqMZ+nuiGVGWtoSoZqV0VLSwyVv35dDJcPCRGjPLy9gatXn2tWGxpu/DBWHURijG7PnmJMcGSkuFujibk3MplYPPXCBWDzZrEqeseOYl5QOXMUGGuo3nvvPZw6dQrLly9HfHw8goKCsGHDBsyaNQuAGO7m4+OD5cuXIzg4GJcuXcLkyZNhaGiI8ePHazj3ahIfD3z3nQhKYG4ODB0qhrUNHSoaQnfviqFus2fzkBzGqqugQAQtUhVJDxDbb94UQ+LmzRONoG+/BY4eFTcfxo/nG5pqwo0fxqrq3j0x12bWLOCdd0QY13btNJ0rceGcOFHcKVqzRvxYcXISF9OK1hZirAHp0aMHgoOD8dtvv6FDhw5YtmwZ1qxZgwkTJkhpPvroI/j4+GDmzJno3r07bt++jZCQkPoznC0vT6zrMm8e0KaNeHz4ofgR5u8vriEJCUBAgIjUZmio6RwzVncVB5SIjAQiIxFzYAu6vgPEHNgibUNExJOAEvr64kZDQoK4yRoWBnToAIweDVy8qNnXUs9wwAPGquLECXEXJicH2L0bGD5c0zkqSy4H5swRPT/ffiuiwv30E+DrC7z/vlhrgLEGbOjQoRg6dGi5+2UyGfz8/ODn5/f8MqVuSUlPAhUcPizC79rZicbNN9+Idch4EWXG1ONpAkrI5WIu3dtvi1Edy5cDnTqJoe2LFgGdOz+fvNdj3PPDWEUePxZhpfv3F+Eoo6NrZ8OnJGNjMVY/MVH0Un31lRjD//XX5a47wBirJwoKRECUDz4QQ2ccHUVPT3a2WCfs0iUxLPaHH4Bhw7jhw1htpacHTJsGxMWJG5nR0UCXLmK4e2SkpnNXp3Hjh7Hy3LkjIh0tXgx8+qn4QfH/d3DqBHNzYMUKMa7/jTeAjz8Ww1w2bhRRZhhj9cOtW+J7PXKkiMw2cCAQFAT06QPs3Cnm7hw9Koa4tW/P64MxVpfo6opeoNhYseD55csi4NKrrwJnzmg6d3USN34YU2XfPsDVVdxxOXxY3DHVqaOjRJs1E3d5r14FXnxRzFdycQG2by9/IiZjrPYqLASOHxc3NDp1EjdlZswAMjKABQtE8JPbt4H//U8MlXmekSgZY+qhoyPWBIqJERFmr10DevUS62ydPKnp3NUp3PhhrKT8fDFHZuhQoHdv4Px5wN1d07mqGa1bi7vBUVGiB2jsWHH36O+/RRQ7xljtlZIiwuqPHg1YWoqhuD//LIbBbNsGpKcD//4rFkvs3Jl7dxirr3R0gAkTRA/Qb7+JiHJ9+gCenmJ+MqsUN34YK3btmriArFsnAgbs2QM0aaLpXNW8zp1Fz9bx44CRkZj47O4OhIdrOmeMsWKPH4u7uYsWAd26Aba2YlHl5GRxgyYiAkhNFROix4wRw1wZYw2Htra4iXnxIrBjh7hB0q+fGPZ67Jimc1erceOHMUB0IXftCmRliR8cc+fW/zun/fqJBtC+fcD9+0DfvmIM8YULms4ZYw1Terq4Fo0fDzRtKm7GfP+9CKm/ZQvw338ixP5nn4le2/IWT2SMNRxaWmJe7/nzT+b4ubuL3uEjR3hkhwp85WQNW3a2WKTU21uMjY+MFI2ghkImEz0/UVFiSFxMjOgZevNNseAaY0x9FArRg7NkiRi7b2UlrkVxcSJSY3i4WKtr61YxzMXSUtM5ZozVVlpa4ndMVBTw559iaY6BA8WNzkOHuBFUAjd+WMMVFSWGk/zxB/DLL2L4SH1ZzLC6tLSAceNE42f9enG3qG1bYOZM0ZXOGKu60NDy9927J+boTJoEWFsDPXsCq1cD9vZiDk9KCnD2LLB0KeDmJoa2MMZYVclkIox9RATw118i/L2np+hJ5jm+ALjxwxoiIuC770RAAyMj4Nw5cbeViZCa06eL8NhffCF+pLVqJaJKZWZqOneM1Q1Lljz5gUEk1udYvhx44QXRezNunNg2ZYoYepqeLsbsT54sGkSMMfasZDLglVeA06dFowcQIz169RKNogbcCOLGD2tYMjLEIqXz5olejZMnAScnTeeq9jE0BD76SAx98/UFAgLEQqn+/qIrnTFWvnPnxLycKVNEqPkuXcR3p2lT4McfgZs3xfh8f38xJEVXV9M5ZozVVzIZMHiwGEZ76BAgl4v5vd27i+FxDbARpJbGz+3bt/Hmm2/CwsIChoaG6Ny5MyJLrEZLRPDz84OtrS0MDAzg7u6Oy5cvqyMrjD1x7JiYzxIeDuzdK4aayOWazlXt1qgR8PnnQEKCmAe0eLEImb1unehKZ4yp9vnn4ubKhAlirbC7d4Fdu4CpU4HmzTWdO8ZYQyOTiYXbjx8XQ9tNTIARI8TNmZ07G9S6fzXe+MnMzETfvn2hq6uLv//+G1euXME333yDRo0aSWlWrlyJVatWYe3atYiIiIC1tTU8PDyQlZVV09lhDCgqAvz8gJdeEj/cz58X6/iwqrO2Fr0/sbFi7PCcOU8iUD1+rOncMVY7rV4NfPWVuPbo6Wk6N4wxJhpBAwaIuYmhoWJJj1GjxMLuO3Y0iEZQjTd+VqxYATs7OwQGBqJnz55wcHDAwIED0apVKwCi12fNmjVYuHAhXnvtNXTo0AGbN2/Go0ePEBQUVNPZYQ3drVsi2smyZaIBdPiwGIbCno6jowgMceGCWFne21v0pu3d2yC7zhkrl7a2WKOHvxeMsdqqf3/gn3/E4qi2tmLNsI4dxeKp9fjGZo03fvbs2YPu3bvjjTfeQNOmTdGlSxds3LhR2p+YmIjU1FR4enpK2+RyOfr3749wXmSR1aQ9e8SdjOvXxd2NRYs4clJN6dAB2L1bDOtp0kRElunblxdWY6zY48ci2lJIiKZzwhhjFevbFzh4UNTp9vZirbH27cXojqIiTeeuxtV44+f69etYv3492rRpg4MHD2LGjBmYO3cufvnlFwBAamoqAMDKykrpeVZWVtK+0vLz8/Hw4UPpwcPjWIXy8sQipcOHi8nE58+Lf1nN691bjB0+eFDMAXJ3FxMrz53TdM4Y0zwtLe79YYzVHb17A/v3A2fOiGBQ3t6AszOwaVO9agTVeONHoVCga9euWL58Obp06YLp06dj2rRpWL9+vVI6mUym9DcRldlWzN/fH2ZmZtKjOU8WZeWJjRVrY2zYAKxdCwQHA+bmms5V/SaTiXlAERHA778DSUli/aTRo8X7wVhDpVCIyG4cHIQxVpf06CFGz0RGipEeb70l1v776SegsFDTuXtmNd74sbGxgYuLi9I2Z2dnJCcnAwCs/38Ng9K9PGlpaWV6g4otWLAADx48kB63bt2q6Wyzuo5IzEXp1g3IzRVx7WfNEj/M2fMhk4lJk5cuAf/7n+g+b98emDZNzL1irIHI+HuX+NEQGSluCnBUScZYXdS1q7iJHBUlosJNnQq0aSNuMNfhmzo13vjp27cvYkvd7Y2Li4O9vT0AwNHREdbW1jh06JC0v6CgAMeOHUOfPn1UHlMul8PU1FR6mJiY1HS2WV2WlSW6ZidPFr0NkZFirg/TDB0dsb7JtWsi0tXu3SLK3vvvi3WWGKvnbrdsIn40dO3KYa0ZY3Vf587AH38AFy+KoXEzZoh6ff16ID9f07mrthpv/Lz33ns4deoUli9fjvj4eAQFBWHDhg2YNWsWADHczcfHB8uXL0dwcDAuXbqEyZMnw9DQEOPHj6/p7LD6LjJS/MDYswfYuhX4+WfAyEjTuWIAoK8PvPeeWCPo44/FnaKWLYGlS0WDlTHGGGN1R4cOwLZtYoRHv37A7NlAq1ZiKYy8PE3nrspqvPHTo0cPBAcH47fffkOHDh2wbNkyrFmzBhMmTJDSfPTRR/Dx8cHMmTPRvXt33L59GyEhIdyjw6pOoQBWrRLzexo1El2y3HiunUxNRZjx69dFl/ny5eJiuWZNnbpYMsYYYwyAi4u44XzliljHzMdH3NxcswZ49EjTuatUjTd+AGDo0KG4ePEi8vLyEBMTg2nTpintl8lk8PPzQ0pKCvLy8nDs2DF06NBBHVlh9VF6OvDqq2IY1dy5QFiY+DHNajdLS9FgvXZNhMZ+/30xgTIwsF5FkWGMMcYahLZtgV9+EcGNBg8GPvhANIK++QbIydF07sqllsYPY2pz9KiYzxMRIcIxfv01r5xe19jZiYAIly8DPXsCb78tFlXbuZNDAjPGGGN1TevWYtpBXJy4Of3xx4CDA7BiBZCdrenclcGNH1Y3FBWJ9TIGDhQx58+fB4YM0XSu2LNo106Exj57FmjRQkSK69lTrDbNGGOMsbqlZUtg40YxwuP118XvNgcHMdz94UNN507CjR9W+yUni8Uz/f2Bzz8XK6bb2Gg6V6ymdOsmFkk9cgTQ1gY8PEQj98wZTeeMMcYYY9Xl4AD88IMIeDRmDLBkidi2bBlw/76GM8eNH1bbBQeLYW43bwLHjwOffCJ+ILP6Z8AAsTbQ7t3Af/8BvXoBI0eK4XGMMcYYq1vs7IB160TAozffBL74QjSC/PyAzEyNZYsbP6x2ys0Vi5S+9proBYiOBspZB4rVIzIZMHy4GNb4yy/ife/USazhlJSk4cwxxhhjrNqaNQO++w5ITBTzfFeuFI2gRYuAu3efe3a48cNqn5gYcdf/p5/EAlq//w40bqzpXLHnSVtbLFx79Srw7bfAgQOAk5OI7vfff5rOHWOMMcaqy8ZGRH1NTATeeUf838EBWLBARPJ9Trjxw2oPItHg6d5dBDiIiBCrCMtkms4Z0xS5XCyiFh8PLF4MbN4swpovWgQ8eKDp3DHGGGOsuqysgK++Eo2gWbPEIqmOjsBHHwFpaWo/PTd+WO3w4IFYpHTqVGDCBBEBrGNHTeeK1RbGxsDChU8ulF9/LaLKfPWVGCLJGGOMsbqlaVPgyy/FsHYfHxEkwcFBrAOYmqq203Ljh2nemTNAly5i3Z5t24ANGwBDQ03nitVG5uZi3YCEBGD0aBEAo3Vr8ZkpLHyS7p9/xArUHDabMcYYq92aNBHRfJOSgA8/FKOAHB2BefOAO3dq/HTc+GGao1CIO/d9+wKWlmJy+5gxms4VqwtsbcV8sJgYoH9/YPp00djZtg14/Fg0imJixL+8cCpjjDFW+5mbi7DYSUliHtAvv4hRHrNni6i/NaRuN35CQzWdA/a0/vsPePllMb7T1xc4cUK08hmrjtatgaAg0XBu2xYYN04ERoiIEPsjIsS6UIyV4O/vD5lMBh8fH2kbEcHPzw+2trYwMDCAu7s7LnOYdcYYe/4aNQI++wy4cUP8+9tvor5/912x7RnV7cbPkiV8V7cu+ucfsXZPVJRY3HLFCkBXV9O5YnWZqyvw119iLaiSkyVlMjF2mK8T7P9FRERgw4YN6NSpk9L2lStXYtWqVVi7di0iIiJgbW0NDw8PZGVlaSinjDHWwJmaihEcSUnA0qXAH38AbdqISHGJicppq9EhUrcbP+fO8V3duqSwUHRjenqKtVvOnxf/Z6ymPHoEZGc/+ZtILJLaqpVoZCcnay5vTOOys7MxYcIEbNy4EY1LhM8nIqxZswYLFy7Ea6+9hg4dOmDz5s149OgRgoKCNJhjxhhjMDEB5s8XDZ7ly4E//xSjPKZMEXOAiUSHSBXV7cYPAIwdK0Lg7tolwuEqFJrOEVMlKQl48UURpevLL8W6LdbWms4Vq0+IRAhsbW3l7VpawP374jphby8+hz/8oJGF1ZhmzZo1C6+88goGDRqktD0xMRGpqanwLHEzRi6Xo3///ggPDy/3ePn5+Xj48KH04F4ixhhTI2Nj4IMPRCNo5UoRKKttW8DDQ3SIVFHdb/zcvy8WQXz9ddEVZmoKuLmJCdDr1gH//ivSMM35/Xegc2cRtvDff8U8H626/9FjtUxIiJjj8/ix8naFAsjMFGOGf/kFMDISkyetrYFXXxXbc3I0k2f23Gzbtg3nzp2Dv79/mX2p/x9S1crKSmm7lZWVtE8Vf39/mJmZSY/mzZvXbKYZY4yVZWgIvPcecP26WCj1+PFqPV1HTdl6frS1RdfXnj3AhQtPHqdPA4GBT8Lftmghhlq5uop/O3USk6d06n4R1FqPHokP54YNwBtviH8bNdJ0rlh9VNzro6WluvdXSwvw9xfXBW9vEXDj999FsITx40WDaMQI8X8PD56DVs/cvHkT8+bNQ0hICPT19ctNJyu1oDIRldlW0oIFC+Dr61tj+WSMMVYNBgai56ewEKjg2l5a3f/l//ixuNt7/jzg5aU8h6SwEIiNFY2h8+fFv4GBT2KG6+sD7ds/aQy5uoqFNZs00cxrqU8uXxZhq69fF42eqVPF5HPG1KGgQMznKW/Yq0IhwmQWFAByuVhdevZs8bh+XfT+bN0qHk2aiDWExo8H+vThz209EBkZibS0NHTr1k3a9vjxYxw/fhxr165FbGwsANEDZGNjI6VJS0sr0xtUklwuh1wul/4mIuTyoruMMfZ8lDfcvRJ1v/EDiLu6ixaJhk/JHyq6ukCHDuIxfvyT7RkZwMWLyo2i334D8vLEflvbJw2i4ke7dnw3uCqIRGPHx0dMMo+IEA1MxtRJLheftfR0AEBMegwm7HoTW1/bAmdLZ5GmaVORrrSWLYGFC0VEmfPnRW/Qb78B338vVpoeN05cPzp0eH6vh9WogQMH4uLFi0rb3nrrLbRr1w7z589Hy5YtYW1tjUOHDqFLly4AgIKCAhw7dgwrVqzQRJYZY4xVpni4ezXVj8ZP6bu6lWnSBBgwQDyKFRWJgAklh85t2yYmVAGi4ePiUrZRxJP2n7h/H5g2TYQinDFDjMM0MNB0rlhDYWcnHgByU4CoU0BuJ2fApmvVni+TiblpnTuLoBz//isaQj/8IIbMdeokGkHjxolhtKzOMDExQYdSjVcjIyNYWFhI2318fLB8+XK0adMGbdq0wfLly2FoaIjxJW+cMcYYqx0qG+5egTrd+IndtRHtzNuIP8q7q1tVOjqid6ddOzHkpdj9+096iYofu3Y9mSDdtGnZBpGzc7XGHtYLJ0+KH4X374vGz+uvazpHjD09LS2gf3/xCAgQ0QmDgkQozY8/Bvr1Ew2hUaN4mGw98dFHHyE3NxczZ85EZmYmevXqhZCQEJiYmGg6a4wxxkqrbLh7Bep04yevfVvAprN6T9Kokfih06/fk20KhZgnULJB9OefoqcDEGMP27ZVDq7QqRPQrFn9mz+gUIjesU8/BXr2FItMOThoOleM1Rw9PWDYMPHIygJ27xYNodmzgTlzgMGDRUNo2DAROIHVCaGlFsSTyWTw8/ODn5+fRvLDGGOsGkoNd69OFOE63fjRGC0tESmudWvgtdeebM/KAi5dUm4U7dsHPHwo9jdurNwYcnUV82EMDTXzOp5VaqqInHX4sFi81M+P50Wx+s3ERHzmvb2BtDRgxw6OGMcYY4xpQonh7iACqhhwhhs/NcnERKwx5Ob2ZBuR6JYrGVwhJESsQaRQiJ6gNm3KNors7Wt3L9HBg8DEiaIheOgQMHCgpnPE2PPVtGnVIsa5ufG6VowxxpgapWanwkzbrEppufGjbjKZaMjY24sFFYs9egRcuaLcKFqzBrh3T+w3MSk7l6hjR7FdkwoKxBC3r74ChgwBNm0SPwIZa8hKRoy7cEE0gIojxtnbi0YQR4xjjDHG1OK/7P9gZla1xo/ab0f6+/tDJpPBx8dH2kZE8PPzg62tLQwMDODu7o7Lly+rOyu1i6Eh0L078PbbwLffAkePihDct24B+/eLH1L29mLV2tmzgb59AVNTET565Ehg8WJg507g2rWyK9qry/XrwAsvAKtXA19/Dfz1Fzd8GCtJJhM9tytXAjduAMeOifXHfvhB3LxwdQVWrBD7GGOMMfbcqbXnJyIiAhs2bECnTp2Utq9cuRKrVq3Cpk2b4OTkhM8//xweHh6IjY1t2JF1ZDIRFKFZM9GrUiw/H4iJUZ5L9MMPYs4BIBpSHTo8GTJX3EvUuHHN5W3bNmD6dDGcJzwc6NGj5o7NWH2kpQW8+KJ4BASIoaJbtz6JGPfCC8CECRwxjjHGGHuO1Nbzk52djQkTJmDjxo1oXOJHOBFhzZo1WLhwIV577TV06NABmzdvxqNHjxAUFKSu7NRtcrlYe2TiRNHjEhIC/PefCDgQEgIsXSpCdJ89C7z/vgjPa24u1iIZOlQMxdm+XTSgiooqP98//4g1jf75R4T0njpVhLF+5RUgKoobPoxVl56eGPa6bZv47v76K2BsLHp1bWzEvt9+exJCnzHGGGNqobaen1mzZuGVV17BoEGD8Pnnn0vbExMTkZqaCk9PT2mbXC5H//79ER4ejunTp5c5Vn5+PvLz85UzrsPTlWBlJaJKeXg82VZYCMTGKvcS/fILcPu22C+XiwhzpQMsFN95JhKNpZgYwMdHNJZu3gR+/hmYPLl2B2FgrC4wMQHefFM80tKA338XPUIcMY4xxhhTO7W0ILZt24Zz584hIiKizL7U1FQAgJWVldJ2Kysr3ChnHLy/vz+WLFki/W1iYiIdh5WiqyuGwHXoIH5AFbt7VyzWWhxc4cIFcRc6L0/st7ERDSETExE3HQAuXwYcHYHISNGzxBirWU2bArNmicf16+I7yRHjGGOMMbWp8cbPzZs3MW/ePISEhEBfX7/cdLJSPQhEVGZbsQULFsDX17dG89ngWFgA7u7iUezxYyA+/knEufPngT17nuyXycTwubZtn3duGWt4WrYUva4LFojvZFCQeHDEOMYYY6zG1PitxMjISKSlpaFbt27Q0dGBjo4Ojh07hu+++w46OjpSj0/pnpu0tLQyvUHF5HI5TE1NpUeDDopQk7S1RcPmjTeAzz8X8w8KCp7sJxK9PiEhmssjYw1NccS44qhwx44BgwcDP/4oApl06sQR4xhjjLGnVOONn4EDB+LixYuIjo6WHt27d8eECRMQHR2Nli1bwtraGocOHZKeU1BQgGPHjqFPnz41nR1WVUTAokWiQVSStrbYTqSZfDHWkBVHjPvhByAlRfTMtm8vIsY5OAD9+ol9GRmaziljjDFWJ9R448fExAQdOnRQehgZGcHCwgIdOnSQ1vxZvnw5goODcenSJUyePBmGhoYYX3KOCnu+QkLEXJ/SawY9fiy2c+8PY5pVHDHut9+eRIwzMeGIcYwxxlg1aGQG7UcffQQfHx/MnDkT3bt3x+3btxESEsLD2TSluNenvAnVWlrc+8NYbVIcMW7/fuDOHWDNGuDePTEnqGlTsX7Q/v0i+iNjjDHGJM8lXnRoaKjS3zKZDH5+fvDz83sep2eVKSgAkpMBhUL1foVChLsuKBChshljtUfJiHGJiaL3Z+tWESyBI8YxxhhjSrgmZKJBExEhghtERiLmwBZ0fQeIObBF2oaICG74MFbbOTqKiHGXLgHR0cDbbwN79wIvvCCiyS1YIPYxxhhjDRSvFMoEOzvxAJCbAkSdAnI7OQM2XTWcMcZYtRVHjHN1Bfz9gRMnRE/Qhg3Al1+KqHETJgBjx4ow2owxxlgDwT0/jDFWn3HEOMYYY0zCjR/GGGsoSkaMS0srGzFu6FCOGMcYY6xe48YPY4w1RMbGTyLGpaSIiHGZmVWLGFcqiA1jjDFWV3DjhzHGGjpLSxEtLiwMuH4dWLhQBEx45RXRIzRzptinUIiQ90uWaDrHjDHG2FPhxg9jjLEnSkeMmzIF+OuvJxHjxo4Fzp3TdC4ZY4yxp8KNH8YYY2UVR4xbsQJISgKOHwe8vICdOzWdM8YYY+ypceOHMcZYxbS0RFS4114DHj/WdG4YY4yxp1Zv1/khIhQVFeExV9TVRoUEeyN7UCEhLy9P09mpd7h81Y/LuGZpa2tDR1sbskWLAG1tTWenTuO66enx91q9uHzVi8u35mlra0NHRwcymaxaz5MREakpT2pDRMjNzUXcgzh0tulcZn9BQQFSUlLw6NGj55+5eqDgcQFSslJgY2IDPW09TWen3uHyVT8u45pneO8ebEaOhF56OsjEBLmpqTAwMKh2pVOfcd2kXvy9Vi8uX/Xi8lUPQ0ND2NjY4MrdK3Ayc6pSvVTven4UCgUSExOhra0NW1tb6OnpceVcTY8KHqHwfiHsGtnBUM9Q09mpd7h81Y/LuOYQEQoKCpD+8CESV61Cm7feAl9Rq4/rpmfH32v14vJVLy7fmiXVTenpSExMBJlUvS+n3jV+CgoKoFAoYGdnB0ND/nA9jcdajwEdQK4vh76evqazU+9w+aofl3HNMpDLoSuX44aFBQqsrSF/8EDTWapzuG56dvy9Vi8uX/Xi8q15BgYG0NXVxY0bN4BqjCSud42fYlpaHMuBMcZqhJYWtFq2FBHgdu9GbGY8Wmg6T3UU102MMVZzpGtqNSbx1NvGD2OMsRqkpycebdsiL5ODHjDGGKub+BYU06hNmzahUaNGms5GjXJ3d4ePj89zP29oaChkMhnu378PQH1lm5SUBJlMhujoaJXnVee5GGNM3bheqjlcL7HaiBs/dcTkyZMxYsSIaj/Pz88PnTt3fubzJyUlYcqUKXB0dISBgQFatWqFxYsXo6Cg4JmPXVeVd3HdtWsXli1bpplMlTBmzBjExcVVKW11KiQ7OzukpKSgQ4cOz5C7slR9xtV1Ltbw+Pv7o0ePHjAxMUHTpk0xYsQIxMbGKqUhIvj5+cHW1hYGBgZwd3fH5cuXNZTj2k/T9RIADBs2DC1atIC+vj5sbGzg7e2NO3fu1Mix6yKul7heYpXjxg+rkqtXr0KhUODHH3/E5cuXsXr1avzwww/45JNPNJ21alN3g83c3BwmJiZqPUdVGBgYoGnTpjV6zIKCAmhra8Pa2ho6OuofNfs8z8Xqt2PHjmHWrFk4deoUDh06hKKiInh6eiInJ0dKs3LlSqxatQpr165FREQErK2t4eHhgaysLA3mnFVkwIAB2LFjB2JjY7Fz504kJCRg1KhRms5WtXG99PS4XmLVRnWQQqGgnJwciroTVWZfbm4uXblyhXJzc59/xp7R77//Th06dCB9fX0yNzengQMHUnZ2Ni1evJggpnJJj6NHjxIR0UcffURt2rQhAwMDcnR0pE8//ZQKCgqIiCgwMLDM8wIDA4mI6P79+zRt2jSytLQkExMTGjBgAEVHRxMRUXZ+NkXcjqDs/OwK87ty5UpydHSsMM29e/fI29ubGjVqRAYGBjR48GCKi4uT9gcGBpKZmRkFBwdTmzZtSC6X06BBgyg5OVlKEx0dTe7u7mRsbEwmJibUtWtXioiIkPaHhYVRv379SF9fn5o3b05z5syh7Ownebe3t6dly5bRpEmTyNTUlCZOnEi9e/em+fPnK+U1LS2NdHR06MiRI0RE9Ouvv1K3bt3I2NiYrKysaNy4cfTff/8REVFiYmKZsp00aRIREfXv35/mzZtXbhl4eHrQzn93SuVbXAYHDhygdu3akZGREXl5edGdO3cqLNt9+/ZRmzZtSF9fn9zd3aX3OzMzU+m4lZXj0aNHy7yWxYsXl1t2xa89KiqKiEh6/l9//UWdOnUiuVxOPXv2pAsXLkjnXrx4Mbm6uirlf/Xq1WRvby/tV/UZL30uIqLQ0FDq0aMH6enpkbW1Nc2fP58KCwul/f3796cZM2eQ97ve1LhxY7KyspJeD3t6Ja+tUXeiKCcnhxQKhaaz9dTS0tIIAB07doyIRL1ibW1NX375pZQmLy+PzMzM6IcffqjSMetj3VRb6iWiqtVNf/75J8lkMul8qnC9pLoMoi9FS+XL9RLXS3VF8bX13I1zVa6XuPFTS9y5c4d0dHRo1apVlJiYSBcuXKB169ZRVlYWZWVl0ejRo2nw4MGUkpJCKSkplJ+fT0REy5Yto7CwMEpMTKQ9e/aQlZUVrVixgoiIHj16RO+//z61b99eet6jR49IoVBQ37596dVXX6WIiAiKi4uj999/nywsLOju3btVbvwsXLiQunXrVmGaYcOGkbOzMx0/fpyio6PJy8uLWrdurVQR6urqUvfu3Sk8PJzOnj1LPXv2pD59+kjHaN++Pb355psUExNDcXFxtGPHDqlCvHDhAhkbG9Pq1aspLi6OwsLCqEuXLjR58mTp+fb29mRqakpfffUVXbt2ja5du0YBAQHUokULpS9JQEAANWvWjB4/fkxERD/99BPt37+fEhIS6OTJk9S7d28aMmQIEREVFRXRzp07CQDFxsZSSkoK3b9/n4jKVjKly2CQxyCyc7CjzOxMpTIYNGgQRUREUGRkJDk7O9P48ePLLdfk5GSSy+U0b948unr1Km3ZsoWsrKwqrGTKK8f8/Hxas2YNmZqaSp+TrKyscsuuvErG2dmZQkJC6MKFCzR06FBycHCQ3ufKKpnyPuOlz3Xr1i0yNDSkmTNnUkxMDAUHB1OTJk2UKpH+/fuTqakpvfP+OxR9KZo2b95MMpmMQkJCyi1PVrn61vi5du0aAaCLFy8SEVFCQgIBoHPnzimlGzZsGE2cOLFKx6xvdVNtqpeIKm/83L17l0aPHk19+/at8HVxvaS6DFq1akUnk05KjR+ul7heqgu48UMVVzB3Ht6hyDuRz+1x52HFd0hKioyMJACUlJSkcv+kSZNo+PDhlR5n5cqVSg0SVV/uw4cPk6mpKeXl5Sltb9WqFf34449VavzEx8eTqakpbdy4sdw0cXFxBIDCwsKkbRkZGWRgYEA7duwgoid3AU+dOiWliYmJIQB0+vRpIiIyMTGhTZs2qTyHt7c3vfPOO0rb/v33X9LS0pI+A/b29jRixAilNMV3044fPy5tc3Nzow8//LDc13PmzBkCIF2Aiy+uxRf1YiUrGVVlcOPODZLry+mXoF+UyiA+Pl5Ks27dOrKysio3LwsWLCBnZ2elL/n8+fMrrGQqKsfSaYupKrvyKplt27ZJae7evUsGBga0fft2Iqq8kiFS/Rkvfa5PPvmE2rZtq/S6161bR8bGxtKPg/79+5NbXzelz3CPHj3K3FFl1VOfGj8KhYJeffVVeuGFF6RtYWFhBIBu376tlHbatGnk6emp8jh5eXn04MEDpUdtr5vqar1EVH7j56OPPiJDQ0MCQL1796aMjIxy88L1UsVl4P+Dv9T44XqJ66W64GkaPw1qwOKPkT9iybElz+18i/svhp+7X5XSurq6YuDAgejYsSO8vLzg6emJUaNGoXHjxhU+748//sCaNWsQHx+P7OxsFBUVwdTUtMLnREZGIjs7GxYWFkrbc3NzkZCQUGle79y5g8GDB+ONN97A1KlTy00XExMDHR0d9OrVS9pmYWGBtm3bIiYmRtqmo6OD7t27S3+3a9cOjRo1QkxMDHr27AlfX19MnToVv/76KwYNGoQ33ngDrVq1kl5LfHw8tm7dKj2fiKTV1J2dnQFA6fgAYGlpCQ8PD2zduhX9+vVDYmIiTp48ifXr10tpoqKi4Ofnh+joaNy7dw8KhQIAkJycDBcXl0rLqaIysG9lj9irTyZbGxoaSq8JAGxsbJCWllbhcXv37q20Qrybm1uFeamoHCtSuuzKU/L85ubmZd7nmhATEwM3Nzel1923b19kZ2fj1q1baNFCrD5TeiJqZeXJGpbZs2fjwoULOHHiRJl9JT9bgLielN5WzN/fH0uWPKlTTExMkJqaWu38PM+6qT7WSx9++CGmTJmCGzduYMmSJZg4cSL++usvle8b10vll0EbpzZIjE+UtnG9VDVcL9U9DarxM73bdAxrO+y5nc/G2KbKabW1tXHo0CGEh4cjJCQEAQEBWLhwIU6fPg1HR0eVzzl16hTGjh2LJUuWwMvLC2ZmZti2bRu++eabCs+lUChgY2OD0NDQMvsqi6xy584dDBgwAG5ubtiwYUOFaYlUrzil6seEqkqqeJufnx/Gjx+Pffv24e+//8bixYuxbds2jBw5EgqFAtOnT8fcuXPLPL/4ggMARkZGZfZPmDAB8+bNQ0BAAIKCgtC+fXu4uroCAHJycuDp6QlPT09s2bIFlpaWSE5OhpeXV7Umpla1DHR1dcu89vKeW9FxK1JROVZEVdlVVfFr1NLSKpPnwsLCah9P1Wen+LiVlWfxjwTWsM2ZMwd79uzB8ePH0bx5c2m7tbU1ACA1NRU2Nk+u3WlpabCyslJ5rAULFsDX1/eZ8/Q866b6WC81adIETZo0gZOTE5ydnWFnZ4dTp06p/OHN9VIlZQCul6qL66W6p0E1fmxMbGBjUvUL//Mmk8nQt29f9O3bF5999hns7e0RHBwMX19f6Onp4fHjx0rpw8LCYG9vj4ULF0rbbty4oZRG1fO6du2K1NRU6OjowMHBoUw+cgpyymwDgNu3b2PAgAHo1q0bAgMDK12p3MXFBUVFRTh9+jT69OkDALh79y7i4uKkO18AUFRUhLNnz6Jnz54AgNjYWNy/fx/t2rWT0jg5OcHJyQnvvfcexo0bh8DAQIwcORJdu3bF5cuX0bp16wrzosqIESMwffp0HDhwAEFBQfD29pb2Xb16FRkZGfjyyy9hZ2cHADh79qzS8/X09ACgTPlWpQySryejbbu21c5zyePu3r1badupU6cqfV555ajqc1Jdp06dkir2zMxMxMXFSe+hpaUlUlNTlSqJ0mskVCUPLi4u2Llzp9JxwsPDYWJigmbNmj1T/ln9RkSYM2cOgoODERoaWubHu6OjI6ytrXHo0CF06dIFgIgidezYMaxYsULlMeVyOeRyudI5cnNzq5232lw31ZZ6qaqKf3Tm5+er3M/1UvllEH8tHhNmTah2nksel+slrpfqghoPdc1rKTyd06dPY/ny5Th79iySk5Oxa9cupKenSxdjBwcHXLhwAbGxscjIyEBhYSFat26N5ORkbNu2DQkJCfjuu+8QHBysdFwHBwckJiYiOjoaGRkZyM/Px6BBg+Dm5oYRI0bg4MGDSEpKQnh4OD799NMyF9Jid+7cgbu7O+zs7PD1118jPT0dqampFQ7xaNOmDYYPH45p06bhxIkTOH/+PN588000a9YMw4cPl9Lp6upizpw5OH36NM6dO4e33noLvXv3Rs+ePZGbm4vZs2cjNDQUN27cQFhYGCIiIqRymT9/Pk6ePIlZs2YhOjoa165dw549ezBnzpxKy9zIyAjDhw/HokWLEBMTg/Hjx0v7WrRoAT09PQQEBOD69evYs2dPmTUS7O3tIZPJ8NdffyE9PR3Z2dlVKoOpk6eiqXVTDH11aKV5LM+MGTOQkJAAX19fxMbGIigoCJs2bSo3fWXl6ODggOzsbBw+fBgZGRl49OhRtfO0dOlSHD58GJcuXcLkyZPRpEkTaX0Ed3d3pKenY+XKlUhISMC6devw999/Kz1f1We8tJkzZ+LmzZuYM2cOrl69ij///BOLFy+Gr69vpY1x1rDNmjULW7ZsQVBQkDQ8LTU1VWqsyGQy+Pj4YPny5QgODpY+x4aGhkrXhoakttdLZ86cwdq1axEdHY0bN27g6NGjGD9+PFq1alXucCuul8ovA1tbW/T36l9pHsvD9RLXS3VGzUw3esLLy4sCAwPp0qVLFB0dTa+88gq1aNFCKcTjl19+SSYmJrRz5066ePEijRkzhmxsbOjhw4dVOkd9i6hDRHTlyhXy8vIiS0tLksvl5OTkRAEBAdL+tLQ08vDwIGNjY6WQoh9++CFZWFiQsbExjRkzhlavXq00QTAvL49ef/11atSokVJI0YcPH9KcOXPI1taWdHV1yc7OjiZMmEDJyckqJ5WqCk9a/KhIcThNMzMzMjAwIC8vL5UhRXfu3EktW7YkPT09eumll6QJtvn5+TR27Fiys7MjPT09srW1pdmzZyu9v2fOnJHKxsjIiDp16kRffPGFtN/e3p5Wr16tMn/79u0jAPTiiy+W2RcUFEQODg4kl8vJzc2N9uzZUya85dKlS8na2ppkMlmlIUWLy2CQxyCVoa5LCg4OrrRs9+7dS61btya5XE79+vWjn3/+udyJpVUpxxkzZpCFhUWZkKKly668iaV79+6l9u3bk56eHvXo0UMpRC0R0fr168nOzo6MjIxo4sSJ9MUXXyhNLFX1GX/akKIzZ89U+gwPHz5cen/Y06nrAQ/Ku34VXxOJRN2yePFisra2JrlcTi+++KIUDa4q6lvdVJvqJaKyAQ8uXLhAAwYMIHNzc5LL5eTg4EAzZsygW7duVfi6uF5SXQaqQl2XxPUS10u10dMEPJARPcUgzWpIT09H06ZNcezYMbz44osgItja2sLHxwfz588HILqnrayssGLFCkyfPr3SY9L/Dy2IexCHzjadlfbl5eUhMTERjo6O0NfXV8dLqvdyCnIQkxED5ybOMNJ7+nG1TDUuX/XjMq55Ja+tVzOvwsnMCQYGBuUGA2iIuG5SL/5eqxeXr3px+apH8bU1zygPbZu0rVK9pPb+uAcPHgAQUTYAIDExEampqfD09JTSyOVy9O/fH+Hh4SqPkZ+fj4cPH0oPXm2bMcYYY4wxVl1qbfwQEXx9ffHCCy9IIf6K54iUjp5jZWVV7vwRf39/mJmZSY+SEXoYY4wxxhhjrCrU2vgpXkvht99+K7OvOmspLFiwAA8ePJAet27dUkt+GWOMMcYYY/WX2kJd1+RaCjUVTpQxxhhjjDHWcNV4zw8RYfbs2di1axeOHDlS4VoKxYrXUiiON88YY4wxxhhjNa3Ge35mzZqFoKAg/Pnnn9JaCgBgZmYmRWAoXkuhTZs2aNOmDZYvX96g11JgjDHGGGOMqV+NN37Wr18PQCweVVJgYCAmT54MAPjoo4+Qm5uLmTNnIjMzE7169UJISAhMTExqOjuMMcYYY4wxBkANjZ+qLBskk8ng5+cHPz+/mj49Y4wxxhhjjKmk9nV+GGOMMcYYY6w24MYP06hNmzahUaNGms5GjXJ3d4ePj4/azxMWFoaOHTtCV1cXI0aMUPv56oukpCTIZDJER0cDAEJDQyGTyXD//v0aP5dMJsPu3btVnled52KMPT2ul54e10tPh+ul54sbP3XE5MmTn+pC4ufnh86dOz/z+ZOSkjBlyhQ4OjrCwMAArVq1wuLFi1FQUPDMx66ryrs47dq1C8uWLVP7+X19fdG5c2ckJiZi06ZNaj9ffdWnTx+kpKTAzMys0rTVrZBSUlIwZMiQZ8yhsvK+0+o4F2MV0XS9BADDhg1DixYtoK+vDxsbG3h7e+POnTs1cuy6iOul+oHrJfXixk9l/vkHcHER/zZgV69ehUKhwI8//ojLly9j9erV+OGHH/DJJ59oOmvVpu4Gm7m5+XMJ3pGQkICXXnoJzZs3V3mXkohQVFSk9nzUdXp6erC2ti53keWnUfwZs7a2VlqjTJ2e57mYhnG9JBkwYAB27NiB2NhY7Ny5EwkJCRg1apSms1VtXC+xkrheUjOqgxQKBeXk5FDUnagy+3Jzc+nKlSuUm5tbEyci6tGDCBD/KhTPfswK/P7779ShQwfS19cnc3NzGjhwIGVnZ9PixYsJgNLj6NGjRET00UcfUZs2bcjAwIAcHR3p008/pYKCAiIiCgwMLPO8wMBAIiK6f/8+TZs2jSwtLcnExIQGDBhA0dHRRESUnZ9NEbcjKDs/u8L8rly5khwdHStMc+/ePfL29qZGjRqRgYEBDR48mOLi4qT9gYGBZGZmRsHBwdSmTRuSy+U0aNAgSk5OltJER0eTu7s7GRsbk4mJCXXt2pUiIiKk/WFhYdSvXz/S19en5s2b05w5cyg7+0ne7e3tadmyZTRp0iQyNTWliRMnUu/evWn+/PlKeU1LSyMdHR06cuQIERH9+uuv1K1bNzI2NiYrKysaN24c/ffff0RElJiYWKZsJ02aRERE/fv3p3nz5pVbBh6eHrTz351S+RaXwYEDB6hdu3ZkZGREXl5edOfOHZVlqurcgYGBdPToUQJABw4coG7dupGuri4dOXKEFAoFrVixghwdHUlfX586depEv//+u9Ix9+3bR23atCF9fX1yd3eXPjuZmZlERLR48WJydXVVes7q1avJ3t5eadvPP/9M7dq1I7lcTm3btqV169aVyffOnTvJ3d2dDAwMqFOnThQeHq50jBMnTtCLL75IBgYG1KhRI/L09KR79+7R5s2bydzcnPLy8pTSv/baa+Tt7a20reRn+PTp09S5c2eSy+XUrVs32rVrFwGgqKgoIiKp3Ipfa1JSEg0dOpQaNWpEhoaG5OLiQvv27av0PZ81axa99957ZGFhQS+++CIREQGg4OBgpdf/22+/kZubG8nlcnJxcZG+yyU/CyUFBwdT8aW6ou90yXMREV24cIEGDBggXU+mTZtGWVlZ0v5JkybR8OHD6auvviJra2syNzenmTNnSteP0kpeW6PuRFFOTg4p1HxNrGueS93UQOsloqrVTX/++SfJZLJyP8dEXC+VVwbRl6Kl8uV6ieulYrW5XiJ6cm09d+NcleslbvxU5MABUcEUPw4cePZjluPOnTuko6NDq1atosTERLpw4QKtW7eOsrKyKCsri0aPHk2DBw+mlJQUSklJofz8fCIiWrZsGYWFhVFiYiLt2bOHrKysaMWKFURE9OjRI3r//fepffv20vMePXpECoWC+vbtS6+++ipFRERQXFwcvf/++2RhYUF3796tcuNn4cKF1K1btwrTDBs2jJydnen48eMUHR1NXl5e1Lp1a6WKUFdXl7p3707h4eF09uxZ6tmzJ/Xp00c6Rvv27enNN9+kmJgYiouLox07dkgV4oULF8jY2JhWr15NcXFxFBYWRl26dKHJkydLz7e3tydTU1P66quv6Nq1a3Tt2jUKCAigFi1aKH1JAgICqFmzZvT48WMiIvrpp59o//79lJCQQCdPnqTevXvTkCFDiIioqKiIdu7cSQAoNjaWUlJS6P79+0RUtpIpXQaDPAaRnYMdZWZnKpXBoEGDKCIigiIjI8nZ2ZnGjx+vskyLioooJSWFTE1Nac2aNdL7Wnyx7NSpE4WEhFB8fDxlZGTQJ598Qu3ataMDBw5QQkICBQYGklwup9DQUCIiSk5OJrlcTvPmzaOrV6/Sli1byMrKqtqVzIYNG8jGxoZ27txJ169fp507d5K5uTlt2rSJiJ5cZNu1a0d//fUXxcbG0qhRo8je3p4KCwuJiCgqKorkcjm9++67FB0dTZcuXaKAgABKT0+nR48ekZmZGe3YsUM6Z3p6Ounp6Uk/DIoVf4b/u/cfWVpa0pgxY+jSpUu0d+9eatmyZYWVzCuvvEIeHh504cIFSkhIoL1799KxY8cqfc+NjY3pww8/pKtXr1JMTAwRqa5kmjdvTn/88QdduXKFpk6dSiYmJpSRkSF9FiqqZMr7Tpc+V05ODtna2tJrr71GFy9epMOHD5Ojo6NUKRKR9KNrxowZFBMTQ3v37iVDQ0PasGGDys8dN34q91zqpgZaLxFV3vi5e/cujR49mvr27Vvh6+J6SXUZtGrVik4mnZQaP1wvcb1EVLvrJSJu/BBRBRVMTg5RZGTVH2fPErm4EGlpiQpGS0v8ffZs9Y6Tk1Ol1xQZGUkAKCkpSeX+4tZwZVauXKnUIFF1cTh8+DCZmpqWuVPRqlUr+vHHH6vU+ImPjydTU1PauHFjuWni4uIIAIWFhUnbMjIyyMDAQLpQFN8xOHXqlJQmJiaGANDp06eJiMjExES6UJXm7e1N77zzjtK2f//9l7S0tKTPgL29PY0YMUIpTfHdtOPHj0vb3Nzc6MMPPyz39Zw5c4YASHcpSl+cipWsZFSVwY07N0iuL6dfgn5RKoP4+Hgpzbp168jKyqrcvBARmZmZSXdXSuZn9+7d0rbs7GzS19cvcxdrypQpNG7cOCIiWrBgATk7OytdMObPn1/tSsbOzo6CgoKU0ixbtozc3NyI6MlF9n//+5+0//LlywRAuiiPGzeuwh8u7777rlTRExGtWbOGWrZsWeZiV/wZ/m7dd2Rubk45Jb6H69evr7CS6dixI/n5+ak8f0XveefOncukV1XJfPnll9L+wsJCat68ufTDsLJKhkj1e1H6XBs2bKDGjRsr3Wnet28faWlpUWpqKhGJa4q9vT0VFRVJad544w0aM2aMytfOjZ/Kqb1uasD1ElH5jZ+PPvqIDA0NCQD17t1b+tGmCtdLFZeB/w/+UuOH6yWul4hqd71E9HSNnxpf56fWunoV6Nbt6Z+vUABXrgDdu1fveZGRQNeulSZzdXXFwIED0bFjR3h5ecHT0xOjRo1C48aNK3zeH3/8gTVr1iA+Ph7Z2dkoKiqCqalpJVmKRHZ2NiwsLJS25+bmIiEhodK83rlzB4MHD8Ybb7yBqVOnlpsuJiYGOjo66NWrl7TNwsICbdu2RUxMjLRNR0cH3UuUa7t27dCoUSPExMSgZ8+e8PX1xdSpU/Hrr79i0KBBeOONN9CqVSvptcTHx2Pr1q3S84kICoUCiYmJcHZ2BgCl4wOApaUlPDw8sHXrVvTr1w+JiYk4efKktEgvAERFRcHPzw/R0dG4d+8eFAoFACA5ORkuLi6VllNFZWDfyh6xV2OlbYaGhtJrAgAbGxukpaVV6RyllXytV65cQV5eHjw8PJTSFBQUoEuXLlIee/furTS22M3NrVrnTE9Px82bNzFlyhRMmzZN2l5UVFRmwmanTp2k/9vY2AAA0tLS0K5dO0RHR+ONN94o9zzTpk1Djx49cPv2bTRr1kxaPLm8cdGxV2Ph6uoKQ0PDKr+2uXPn4t1330VISAgGDRqE119/XSnP5Sn9GStPyfMXf/ZLfh9qQkxMDFxdXWFkZCRt69u3LxQKBWJjY2FlZQUAaN++PbS1taU0NjY2uHjxYo3mhVXiWeomrpcAAB9++CGmTJmCGzduYMmSJZg4cSL++usvldcFrpfKL4M2Tm2QGJ8obeN6ieulmlSb6qWG0/hp105c8KuCCJg4UVRK/39hAQBoaYnj/PILUNVJaO3aVSmZtrY2Dh06hPDwcISEhCAgIAALFy7E6dOn4ejoqPI5p06dwtixY7FkyRJ4eXnBzMwM27ZtwzfffFPhuRQKBWxsbBAaGlpmX2XhPe/cuYMBAwbAzc0NGzZsqDAtlbPgLRGVuSioukgUb/Pz88P48eOxb98+/P3331i8eDG2bduGkSNHQqFQYPr06Zg7d26Z57do0UL6f8kvW7EJEyZg3rx5CAgIQFBQENq3bw9XV1cAQE5ODjw9PeHp6YktW7bA0tISycnJ8PLyqtbE1KqWga6ubpnXXt5zK1PytRZXjPv27UOzZs2U0hVPQqzKebS0tMqkKywsLHOejRs3KlWoAJQuYoDyay0ug+LnGxgYVJiPLl26wNXVFb/88gu8vLxw8eJF7N27t9z0T1OGU6dOhZeXF/bt24eQkBD4+/vjm2++wZw5cyp8nqrPWFUVl0Nl5VxVqr5jpc8FqP7cKUpe85j6VbVu4nqpXE2aNEGTJk3g5OQEZ2dn2NnZ4dSpUyp/UHK9VEkZgOslrpeE+lwvNZzGj6Fhle50AQAOHhR300orvsuWkQF4edVs/iDe4L59+6Jv37747LPPYG9vj+DgYPj6+kJPTw+PHz9WSh8WFgZ7e3ssXLhQ2nbjxg2lNKqe17VrV6SmpkJHRwcODg5l8pFTkKMyf7dv38aAAQPQrVs3BAYGQkur4mCBLi4uKCoqwunTp9GnTx8AwN27dxEXFyfd+QLEXZizZ8+iZ8+eAIDY2Fjcv38f7UpU0E5OTnBycsJ7772HcePGITAwECNHjkTXrl1x+fJltG7dusK8qDJixAhMnz4dBw4cQFBQELy9vaV9V69eRUZGBr788kvY2dkBAM6ePav0fD09PQAoU75VKYPk68lo265ttfNcXS4uLpDL5UhOTkb//v3LTVM6Dv+pU6eU/ra0tERqaqrSxavkugBWVlZo1qwZrl+/jgkTJjx1fjt16oTDhw9jyZIl5aaZOnUqVq9ejdu3b2PQoEHS+6NKO+d22Ba0Dbm5uVIFVvq1qWJnZ4cZM2ZgxowZWLBgATZu3Ig5c+ZU6T2vzKlTp/Diiy8CEJ/9yMhIzJ49G4Ao56ysLOTk5EiVVun1F1R9p0tzcXHB5s2blY4TFhYGLS0tODk5PXXemRpUtW5q4PVSVRX/SMvPz1e5n+ul8ssg/lo8Jsx6+ut3VXG9xPWSpuslDnVdGhGwaJG4m6aKlpbY/5R3P8pz+vRpLF++HGfPnkVycjJ27dqF9PR06WLs4OCACxcuIDY2FhkZGSgsLETr1q2RnJyMbdu2ISEhAd999x2Cg4OVjuvg4IDExERER0cjIyMD+fn5GDRoENzc3DBixAgcPHgQSUlJCA8Px6efflrmQlrszp07cHd3h52dHb7++mukp6cjNTUVqamp5b6mNm3aYPjw4Zg2bRpOnDiB8+fP480330SzZs0wfPhwKZ2uri7mzJmD06dP49y5c3jrrbfQu3dv9OzZE7m5uZg9ezZCQ0Nx48YNhIWFISIiQiqX+fPn4+TJk5g1axaio6Nx7do17Nmzp9K7IYC4IzJ8+HAsWrQIMTExGD9+vLSvRYsW0NPTQ0BAAK5fv449e/aUWSPB3t4eMpkMf/31F9LT05GdnV2lMpg6eSqaWjfF0FeHVprHZ2ViYoIPPvgA7733HjZv3oyEhARERUVh3bp12Lx5MwBgxowZSEhIgK+vL2JjYxEUFFRmfQZ3d3ekp6dj5cqVSEhIwLp16/D3338rpfHz84O/vz++/fZbxMXF4eLFiwgMDMSqVauqnN8FCxYgIiICM2fOxIULF3D16lWsX78eGRkZUpoJEybg9u3b2LhxI95+++0Kjzd67GhoaWlhypQpuHLlCvbv34+vv/66wuf4+Pjg4MGDSExMxLlz53DkyBHp81aV97wy69atQ3BwMK5evYpZs2YhMzNTeh29evWCoaEhPvnkE8THx6t8L1R9p0ubMGEC9PX1MWnSJFy6dAlHjx7FnDlz4O3tLQ0tYHUI10sq83fmzBmsXbsW0dHRuHHjBo4ePYrx48ejVatW5Q4j4nqp/DKwtbVFfy/VjZGaxPUS10sar5cqnRVUC6k1ok5eHpGVlXI0ndIPa2uRrgZduXKFvLy8yNLSkuRyOTk5OVFAQIC0Py0tjTw8PMjY2JiAJyFFP/zwQ7KwsCBjY2MaM2YMrV69WmliWl5eHr3++uvUqFEjpfCDDx8+pDlz5pCtrS3p6uqSnZ0dTZgwgZKTk1VOKlUVyrD4UZHicJpmZmZkYGBAXl5eKkOK7ty5k1q2bEl6enr00ksvSRNs8/PzaezYsWRnZ0d6enpka2tLs2fPVnp/z5w5I5WNkZERderUib744gtpv729Pa1evVpl/vbt20cApBCQJQUFBZGDgwPJ5XJyc3OjPXv2KE1IJCJaunQpWVtbk0wmqzSkaHEZDPIYpDLUdUmlJxOqUt7E0tKTHhUKBX377bfUtm1b0tXVJUtLS/Ly8qJjx45Jafbu3UutW7cmuVxO/fr1o59//rnMsdavX092dnZkZGREEydOpC+++KJMSNGtW7dS586dSU9Pjxo3bkwvvvgi7dq1i4ieTKwsWX6ZmZlKn2ciotDQUOrTpw/J5XJq1KgReXl5lXlN3t7eKsOLFiv5GT558iS5urqSnp4ede7cWYqMU97E0tmzZ1OrVq1ILpeTpaUleXt7K02grsp7XgwqJpYGBQVRr169SE9Pj5ydnenw4cNKzwkODqbWrVuTvr4+DR06lDZs2KD0WSjvO13yXERVDyla0rx586h///4qy5QDHlRObXUT10tEVDbgQfFn3NzcnORyOTk4ONCMGTPo1q1bFb4urpdUl4GqUNclcb3E9VJtq5eIni7ggez/M1enEBFyc3MR9yAOnW06K+3Ly8tDYmIiHB0doa+v/3QnuHkTSE8vf3/TpkDz5k937DogpyAHMRkxcG7iDCO9px8vylSrC+UbGhqKAQMGIDMzs9Lx9prg4eEBZ2dnfPfddyr314UyrmtKXluvZl6Fk5kTDAwManQRvrpOrXVTA6+XAP5eq1ttL1+ul5gqxdfWPKM8tG3Stkr1UsOZ81MddnbiwRirVe7du4eQkBAcOXIEa9eu1XR2GHt+uF5irFbieqnu4cYPY6zO6Nq1KzIzM7FixQq0bav+gBGMMcZYRbheqnu48cMYK8Pd3f2pQ5qqU1JSkqazwBhjTAO4XmI1haO9McYYY4wxxhoEbvwwxhhjjDHGGoR62/ipjV2jjDFWV/E1tWZwOTLGWM2RrqnVCDxa7xo/urq6AIBHjx5pOCeMMVZ/FF9Ti6+xrHq4bmKMsZonXVOr0aKpdwEPtLW10ahRI6SlpQEADA0NeR2KasovyAeKgPy8fGgrtDWdnXqHy1f9uIxrDhHh0aNHSEtLQ6NGjaCtzeX5NLhuenb8vVYvLl/14vKtWaXrpv/wX5WfW+8aPwBgbW0NAFIlw6qn4HEBMrIyoPtQF3raeprOTr3D5at+XMY1r1GjRtK1lT0drpueDX+v1YvLV724fNWjuG76L7WBN35kMhlsbGzQtGlTFBYWajo7dc7ltMuYcWAGdo7eibZNOWZ9TePyVT8u45qlq6vLPT41gOumZ8Pfa/Xi8lUvLt+a97R1k0YbP99//z2++uorpKSkoH379lizZg369etXY8fX1tbmCvspyHRluJFzAzJdGfT19TWdnXqHy1f9uIzZ01J3vQRw3fS0+HutXly+6sXlW3toLODB9u3b4ePjg4ULFyIqKgr9+vXDkCFDkJycrKksMcYYa8C4XmKMsfpPY42fVatWYcqUKZg6dSqcnZ2xZs0a2NnZYf369ZrKEmOMsQaM6yXGGKv/NNL4KSgoQGRkJDw9PZW2e3p6Ijw8XBNZYowx1oBxvcQYYw2DRub8ZGRk4PHjx7CyslLabmVlhdTU1DLp8/PzkZ+fr7RNR0cHWtDiBePUQAtaMNEz4fJVEy5f9eMyVi+t/79vRkT1JlxzdeslgOum542/1+rF5ateXL7qVZ16SaMBD0pnrrwM+/v7Y8mSJdLfNjY2iI+PR2uz1sjNzVV7PhsaJzMnpM4TlT2Xb83j8lU/LmP1am3WWtNZUJuq1ksA103PG3+v1YvLV724fNWrOvWSRho/TZo0gba2dpm7aWlpaWXuugHAggUL4OvrK/398OFDtG7dGlevXoWJiYna89vQZGVloXnz5rh16xaXrxpw+aofl7F61ce7ltWtlwCum543/l6rF5evenH5qld16iWNNH709PTQrVs3HDp0CCNHjpS2Hzp0CMOHDy+TXi6XQy6XK21LSUkBUPYuHasZWVlZALh81YXLV/24jNWnPpZpdeslgOsmTeDvtXpx+aoXl6/6VKdMNTbszdfXF97e3ujevTvc3NywYcMGJCcnY8aMGZrKEmOMsQaM6yXGGKv/NNb4GTNmDO7evYulS5ciJSUFHTp0wP79+2Fvb6+pLDHGGGvAuF5ijLH6T6MBD2bOnImZM2dW+3lyuRyLFy8uM9yA1QwuX/Xi8lU/LmP2tJ62XgL4c6duXL7qxeWrXly+tYeM6uPMVcYYY4wxxhgrRSOLnDLGGGOMMcbY88aNH8YYY4wxxliDwI0fxhhjjDHGWINQJxs/33//PRwdHaGvr49u3brh33//1XSW6o3jx4/j1Vdfha2tLWQyGXbv3q3pLNUb/v7+6NGjB0xMTNC0aVOMGDECsbGxms5WvbF+/Xp06tQJpqamMDU1hZubG/7++29NZ4s1IFw3qQfXS+rFdZN6cd1U+9S5xs/27dvh4+ODhQsXIioqCv369cOQIUOQnJys6azVCzk5OXB1dcXatWs1nZV659ixY5g1axZOnTqFQ4cOoaioCJ6ensjJydF01uqF5s2b48svv8TZs2dx9uxZvPTSSxg+fDguX76s6ayxBoDrJvXhekm9uG5SL66bap86F+2tV69e6Nq1K9avXy9tc3Z2xogRI+Dv76/BnNU/MpkMwcHBGDFihKazUi+lp6ejadOmOHbsGF588UVNZ6deMjc3x1dffYUpU6ZoOiusnuO66fngekn9uG5SP66bNKtO9fwUFBQgMjISnp6eSts9PT0RHh6uoVwxTfj++++xadOm53KuR48ewc/PD6GhoTV63AcPHgAQF8GG4MSJE5g6dSq6desGuVwOmUyGpKQktZzr8ePH2LZtG3JycuDm5qaWczBWjOsmVozrprqH66aGp041fjIyMvD48WNYWVkpbbeyskJqaqqGcsU04XlXMEuWLKnRCoaI4OvrixdeeAEdOnSosePWZocPH8Y///yDFi1aoE+fPmo5x8WLF2FsbAy5XI4ZM2YgODgYLi4uajkXY8W4bmLFuG6qe7huanjqVOOnmEwmU/qbiMpsY6w2mz17Ni5cuIDffvutzL5Hjx5pIEfqt2jRIiQlJSE4OBivvPKKWs7Rtm1bREdH49SpU3j33XcxadIkXLlyRS3nYqw0rptYXcd1E9dNDUGdavw0adIE2traZe6kpaWllbnjxmqXEydOYODAgTAxMYGhoSH69OmDffv2KaXx8/NT+UNh06ZNSt3QDg4OuHz5Mo4dOwaZTAaZTAYHBwcAQGhoKGQyGbZs2QJfX19YW1vDwMAA/fv3R1RUlNJx3d3d4e7uXuZ8kydPlo6XlJQES0tLAMCSJUuk802ePLnc11pZHubMmYM9e/bg6NGj+PTTT2FsbIyLFy/C09MTJiYmGDhwIADg3r17mDlzJpo1awY9PT20bNkSCxcuRH5+vtL5FAoFAgIC0LlzZxgYGKBRo0bo3bs39uzZo5Ru+/btcHNzg5GREYyNjeHl5VWmTK5fv46xY8fC1tYWcrkcVlZWGDhwIKKjo6U0R44cgbu7OywsLGBgYIAWLVrg9ddfr7Ri1NJS/+VGT08PrVu3Rvfu3eHv7w9XV1d8++23aj8va9i4bqq7uG7iuonrpoanTjV+9PT00K1bNxw6dEhp+6FDh9TWVcme3bFjx/DSSy/hwYMH+Omnn/Dbb7/BxMQEr776KrZv317t4wUHB6Nly5bo0qULTp48iZMnTyI4OFgpzSeffILr16/jf//7H/73v//hzp07cHd3x/Xr16t1LhsbGxw4cAAAMGXKFOl8ixYtqvS5qvLQu3dv7NixA0eOHIGjoyMAMV9g2LBheOmll/Dnn39iyZIlyMvLw4ABA/DLL7/A19cX+/btw5tvvomVK1fitddeUzrP5MmTMW/ePPTo0QPbt2/Htm3bMGzYMKUxy8uXL8e4cePg4uKCHTt24Ndff0VWVhb69eundPfp5ZdfRmRkJFauXIlDhw5h/fr16NKlC+7fvw9AVLivvPIK9PT08PPPP+PAgQP48ssvYWRkhIKCgmqV7fNARGUqZMZqGtdNdRPXTVw3aQrXTRpGdcy2bdtIV1eXfvrpJ7py5Qr5+PiQkZERJSUlaTpr9UJWVhZFRUVRVFQUAaBVq1ZRVFQU3bhx46mP2bt3b2ratCllZWVJ24qKiqhDhw7UvHlzUigURES0ePFiUvWRDAwMJACUmJgobWvfvj3179+/TNqjR48SAOratat0XCKipKQk0tXVpalTp0rb+vfvr/IYkyZNInt7e+nv9PR0AkCLFy+u0ustLw9vvvkmAaBXXnmFUlJSKCUlhUaPHk0A6Oeff1Y6xg8//EAAaMeOHUrbV6xYQQAoJCSEiIiOHz9OAGjhwoXl5ic5OZl0dHRozpw5StuzsrLI2tqaRo8eTUREGRkZBIDWrFlT7rH++OMPAkDR0dFVKovyfPXVV2Xe02e1YMECOn78OCUmJtKFCxfok08+IS0tLamsGFMnrpvURx31EhHXTcW4bnqC66aGoU71/ADAmDFjsGbNGixduhSdO3fG8ePHsX//ftjb22s6a/XC2bNn0aVLF3Tp0gUA4Ovriy5duuCzzz57quPl5OTg9OnTGDVqFIyNjaXt2tra8Pb2xq1bt9SymNr48eOVhinY29ujT58+OHr0aI2fq6p52LJlCwBg3759sLGxgY2NDXbs2AEAeP3115Wee+TIERgZGWHUqFFK24uHNBw+fBgApIXSZs2aVW4+Dh48iKKiIkycOBFFRUXSQ19fH/3795cmy5qbm6NVq1b46quvsGrVKkRFRUGhUCgdq3PnztDT08M777yDzZs3V/tupTr9999/8Pb2Rtu2bTFw4ECcPn0aBw4cgIeHh6azxhoArpvUp6brJYDrJq6bnh+um2qfOtf4AYCZM2ciKSkJ+fn5iIyM5Dj0Ncjd3R1EVObxtNFrMjMzQUSwsbEps8/W1hYAcPfu3WfJskrW1tYqt6njXFXNAxFhzJgxaNSokVSukyZNgqGhIUxNTZXS3r17F9bW1mXGmTdt2hQ6OjrS60hPT4e2trbK11vsv//+AwD06NEDurq6So/t27cjIyMDgJisffjwYXh5eWHlypXo2rUrLC0tMXfuXGRlZQEAWrVqhX/++QdNmzbFrFmz0KpVK7Rq1apWjF3+6aefpOtCWloa/vnnH65c2HPFdZN61HS9BHDdVBLXTerFdVPto6PpDLD6rXHjxtDS0kJKSkqZfXfu3AEgJgsDgL6+PgAgPz8fcrlcSld8AawOVeFlU1NTYWFhIf2tr68vrWdQ0tOc72nzAJSNEAUAFhYWOH36dJloUWlpaSgqKpLKzNLSEo8fP0ZqaqrKShx4Ur5//PFHpXeh7e3t8dNPPwEA4uLisGPHDvj5+aGgoAA//PADAKBfv37o168fHj9+jLNnzyIgIAA+Pj6wsrLC2LFjKzw+Y4zVBlw3VZwHgOsmVn/VyZ4fVncYGRmhV69e2LVrF3Jzc6XtCoUCW7ZsQfPmzeHk5AQAUhSbCxcuKB1j7969ZY4rl8uVjlfab7/9BiKS/r5x4wbCw8OVIug4ODggLi5OadLh3bt3yyxKWFzZVXS+p81DeQYOHIjs7Gzs3r1bafsvv/wi7QeAIUOGAIDSqvKleXl5QUdHBwkJCejevbvKhypOTk749NNP0bFjR5w7d67Mfm1tbfTq1Qvr1q0DAJVpGGOsNuK6iesm1nBxzw9TO39/f3h4eGDAgAH44IMPoKenh++//x6XLl3Cb7/9Jt09evnll2Fubo4pU6Zg6dKl0NHRwaZNm3Dz5s0yx+zYsSO2bduG7du3o2XLltDX10fHjh2l/WlpaRg5ciSmTZuGBw8eYPHixdDX18eCBQukNN7e3vjxxx/x5ptvYtq0abh79y5WrlxZppvfxMQE9vb2+PPPPzFw4ECYm5ujSZMmUoVYnqrkoTwTJ07EunXrMGnSJCQlJaFjx444ceIEli9fjpdffhmDBg0CIO50eXt74/PPP8d///2HoUOHQi6XIyoqCoaGhpgzZw4cHBywdOlSLFy4ENevX8fgwYPRuHFj/Pfffzhz5gyMjIywZMkSXLhwAbNnz8Ybb7yBNm3aQE9PD0eOHMGFCxfw8ccfAwB++OEHHDlyBK+88gpatGiBvLw8/PzzzwAg5ak86enpOHbsGACx4BsgxoVbWlrC0tIS/fv3r7RcGGOspnDdxHUTwHVTg/T8Yiuwhuzff/+ll156iYyMjMjAwIB69+5Ne/fuLZPuzJkz1KdPHzIyMqJmzZrR4sWL6X//+1+Z6CtJSUnk6elJJiYmBECKgFMczebXX3+luXPnkqWlJcnlcurXrx+dPXu2zPk2b95Mzs7OpK+vTy4uLrR9+/YyEXWIiP755x/q0qULyeVyAkCTJk0q97VWJw+TJk0iIyMjlce5e/cuzZgxg2xsbEhHR4fs7e1pwYIFlJeXp5Tu8ePHtHr1aurQoQPp6emRmZkZubm5lSnf3bt304ABA8jU1JTkcjnZ29vTqFGj6J9//iEiov/++48mT55M7dq1IyMjIzI2NqZOnTrR6tWrqaioiIiITp48SSNHjiR7e3uSy+VkYWFB/fv3pz179pRbHqXLRdVDVWQjxhhTN66buG7iuqnhkRGV6PtkrI4LDQ3FgAED8Pvvv5eJRtOQ8sAYY6z2qA31Qm3IA2O1Ac/5YYwxxhhjjDUI3PhhjDHGGGOMNQg87I0xxhhjjDHWIHDPD2OMMcYYY6xB4MYPY4wxxhhjrEHgxg9jjDHGGGOsQaiTi5wqFArp/8WLkDHGGHs+Sk4V1dJS7z2048eP46uvvkJkZCRSUlIQHByMESNGAAAKCwvx6aefYv/+/bh+/TrMzMwwaNAgfPnll7C1tZWO4e7uLi1iWGzMmDHYtm2b9HdmZibmzp2LPXv2AACGDRuGgIAANGrUqMp55bqJMcY0ozr1Up1s/ABAXl6eprPAGGMNmr6+vtrPkZOTA1dXV7z11lt4/fXXlfY9evQI586dw6JFi+Dq6orMzEz4+Phg2LBhOHv2rFLaadOmYenSpdLfBgYGSvvHjx+PW7du4cCBAwCAd955B97e3ti7d2+18st1E2OMaU5V6qU62/gBxAvku2uMMfZ8EdFz+5E/ZMgQDBkyROU+MzMzHDp0SGlbQEAAevbsieTkZLRo0ULabmhoCGtra5XHiYmJwYEDB3Dq1Cn06tULALBx40a4ubkhNjYWbdu2rVaeuW5ijLHnqzr1Up1s/BRXKjKZjCsYxhjTkNp4/X3w4AFkMlmZ4Wpbt27Fli1bYGVlhSFDhmDx4sUwMTEBAJw8eRJmZmZSwwcAevfuDTMzM4SHh5fb+MnPz0d+fr7SNh0dHa6bGGNMQ6py7a2TjR/GGGOstLy8PHz88ccYP348TE1Npe0TJkyAo6MjrK2tcenSJSxYsADnz5+Xeo1SU1PRtGnTMsdr2rQpUlNTyz2fv78/lixZIv1tYmJSYXrGGGOax40fxhhjdV5hYSHGjh0LhUKB77//XmnftGnTpP936NABbdq0Qffu3XHu3Dl07doVgOq7hURU4V3EBQsWwNfXt4ZeAWOMseeBQ10zxhir0woLCzF69GgkJibi0KFDSr0+qnTt2hW6urq4du0aAMDa2hr//fdfmXTp6emwsrIq9zhyuRympqbSo3gYHWOMsdqLe34YY4zVWcUNn2vXruHo0aOwsLCo9DmXL19GYWEhbGxsAABubm548OABzpw5g549ewIATp8+jQcPHqBPnz7PlD+FQoGCgoJnOgZjjDFAT0+vRpZX4MYPY4yxWis7Oxvx8fHS34mJiYiOjoa5uTlsbW0xatQonDt3Dn/99RceP34szbkxNzeHnp4eEhISsHXrVrz88sto0qQJrly5gvfffx9dunRB3759AQDOzs4YPHgwpk2bhh9//BGACHU9dOjQakd6K6mgoACJiYlK6/8wxhh7OlpaWnB0dISent4zHUdGJVcFqiOICLm5uTAwMOCIOowx9pw9z2twaGgoBgwYUGb7pEmT4OfnB0dHR5XPO3r0KNzd3XHz5k28+eabuHTpErKzs2FnZ4dXXnkFixcvhrm5uZT+3r17ZRY5Xbt2bbUWOS1ZLgCQnJyMwsJC2Nraqn0xWMYYq88UCgXu3LkDXV1dtGjRokzdU516iRs/jDHGqoWvwaqVLJeioiLEx8fD1tYWZmZmms4aY4zVeQ8ePMCdO3fQunVr6OrqKu2rTr3Et6IYY4yxGvb48WMAeObhGYwxxoTi62nx9fVpceOHMcYYUxPuGWOMsZpRU9dTbvwwxhhjjDHGGgRu/DDGGGOswdq0aVO1AlvUBe7u7vDx8Xnu5w0NDYVMJsP9+/cBqK9sk5KSIJPJEB0drfK86jwXq/u48cMYY4yxSk2ePBkjRoyo9vP8/PzQuXPnGsmDg4MDZDKZ0uPjjz+ukWPXReX96N+1axeWLVummUyVMGbMGMTFxVUpbXUaSnZ2dkhJSUGHDh2eIXdlqfqMq+tcTHN4nR/GGGOM1RlLly7FtGnTpL+NjY01mJunU1BQoNZgGCXDuGuSgYGBFPq9phSXnbW1dY0etzza2trP7Vzs+eCeH8YYY4wBAP744w907NgRBgYGsLCwwKBBg5CTkwM/Pz9s3rwZf/75p9TjEhoaCgCYP38+nJycYGhoiJYtW2LRokUoLCwEIO7mL1myBOfPn5eet2nTJgAibO0777yDpk2bwtTUFC+99BLOnz9faR5NTExgbW0tPSpr/GRmZmLixIlo3LgxDA0NMWTIEFy7dq1Mut27d8PJyQn6+vrw8PDAzZs3pX3nz5/HgAEDYGJiAlNTU3Tr1g1nz56V9oeHh+PFF1+EgYEB7OzsMHfuXOTk5Ej7HRwc8Pnnn2Py5MkwMzPDtGnT4ObmVqbXKj09Hbq6ujh69CgAYMuWLejevbv0msePH4+0tDQAYjhW8RpYjRs3hkwmw+TJkwGUHfZWWRkU97ocPHgQzs7OMDY2xuDBg5GSklJh2e7fvx9OTk4wMDDAgAEDkJSUpLS/dG9OeeUYGhqKt956Cw8ePJA+J35+fuWWXXlD0cLCwuDq6gp9fX306tULFy9elPap6oFcs2YNHBwcpP2qPuOqznXs2DH07NkTcrkcNjY2+Pjjj1FUVCTtd3d3x9y5c/HRRx/B3Nwc1tbW0uthmseNH8YYY4whJSUF48aNw9tvv42YmBiEhobitddeAxHhgw8+wOjRo6UfxCkpKejTpw8A0RjZtGkTrly5gm+//RYbN27E6tWrAYhhT++//z7at28vPW/MmDEgIrzyyitITU3F/v37ERkZia5du2LgwIG4d+9ehflcsWIFLCws0LlzZ3zxxRcoKCioMP3kyZNx9uxZ7NmzBydPngQR4eWXX5YaaADw6NEjfPHFF9i8eTPCwsLw8OFDjB07Vto/YcIENG/eHBEREYiMjMTHH38srTNy8eJFeHl54bXXXsOFCxewfft2nDhxArNnz1bKx1dffYUOHTogMjISixYtwoQJE/Dbb7+h5HKL27dvh5WVFfr37w9A9HIsW7YM58+fx+7du5GYmCg1cOzs7LBz504AQGxsLFJSUvDtt98+Uxl8/fXX+PXXX3H8+HEkJyfjgw8+KLdcb968iddeew0vv/wyoqOjMXXq1EqHIJZXjn369MGaNWtgamoqfU5Knrt02ZXnww8/xNdff42IiAg0bdoUw4YNU3qNFanoM17S7du38fLLL6NHjx44f/481q9fj59++gmff/65UrrNmzfDyMgIp0+fxsqVK7F06VIcOnSoSnlhakZ1kEKhoJycHFIoFJrOCmOMNTh8DVatZLnk5ubSlStXKDc3VynNnYd3KPJO5HN73Hl4p8r5j4yMJACUlJSkcv+kSZNo+PDhlR5n5cqV1K1bN+nvxYsXk6urq1Kaw4cPk6mpKeXl5Sltb9WqFf3444/lHnvVqlUUGhpK58+fp40bN1KTJk1oypQp5aaPi4sjABQWFiZty8jIIAMDA9qxYwcREQUGBhIAOnXqlJQmJiaGANDp06eJiMjExIQ2bdqk8hze3t70zjvvKG37999/SUtLS3r/7e3tacSIEUpp0tLSSEdHh44fPy5tc3Nzow8//LDc13PmzBkCQFlZWUREdPToUQJAmZmZSun69+9P8+bNq3YZxMfHS2nWrVtHVlZW5eZlwYIF5OzsrHQdmD9/vlJ+AgMDyczMTNpfUTmWTltMVdklJiYSAIqKilIqh23btklp7t69SwYGBrR9+3YiUv05XL16Ndnb20t/q/qMlz7XJ598Qm3btlV63evWrSNjY2N6/PgxEYnyf+GFF5SO06NHD5o/f77K186qprzrKlH16qVqzfnx9/fHrl27cPXqVRgYGKBPnz5YsWIF2rZtW7IxhSVLlmDDhg3IzMxEr169sG7dOrRv315Kk5+fjw8++AC//fYbcnNzMXDgQHz//fdo3rz5s7XkGGOMsVrsx8gfseTYkud2vsX9F8PP3a9KaV1dXTFw4EB07NgRXl5e8PT0xKhRo9C4ceMKn/fHH39gzZo1iI+PR3Z2NoqKimBqalrhcyIjI5GdnQ0LCwul7bm5uUhISCj3ee+99570/06dOqFx48YYNWqU1BtUWkxMDHR0dNCrVy9pm4WFBdq2bYuYmBhpm46ODrp37y793a5dOzRq1AgxMTHo2bMnfH19MXXqVPz6668YNGgQ3njjDbRq1Up6LfHx8di6dav0fCKCQqFAYmIinJ2dAUDp+ABgaWkJDw8PbN26Ff369UNiYiJOnjyJ9evXS2mioqLg5+eH6Oho3Lt3DwqFAgCQnJwMFxeXcsvpacrA0NBQek0AYGNjIw2xK++4vXv3Vlp7xc3NrcK8VFSOFSldduUpeX5zc/Myr7EmxMTEwM3NTel19+3bF9nZ2bh16xZatGgBQHw+S6qsPNnzU63Gz7FjxzBr1iz06NEDRUVFWLhwITw9PXHlyhUYGRkBAFauXIlVq1Zh06ZNcHJywueffw4PDw/ExsbCxMQEAODj44O9e/di27ZtsLCwwPvvv4+hQ4ciMjIS2traNf8qGWOMsVpgerfpGNZ22HM7n42xTZXTamtr49ChQwgPD0dISAgCAgKwcOFCnD59Go6Ojiqfc+rUKYwdOxZLliyBl5cXzMzMsG3bNnzzzTcVnkuhUMDGxkaaN1RSdUIj9+7dGwAQHx+vsvFDJYaUld5eesFEVQsoFm/z8/PD+PHjsW/fPvz9999YvHgxtm3bhpEjR0KhUGD69OmYO3dumecX/xAGIP1OKmnChAmYN28eAgICEBQUhPbt28PV1RUAkJOTA09PT3h6emLLli2wtLREcnIyvLy8Kh3q9zRlUDyMr+RrL++5FR23IhWVY0VUlV1VFb9GLS2tMnmu6pC4klR9doqPW1l5FjdemWZVq/Fz4MABpb8DAwPRtGlTREZG4sUXXwQRYc2aNVi4cCFee+01AGLMo5WVFYKCgjB9+nQ8ePAAP/30k9TqB8SEPjs7O/zzzz/w8vKqoZfGGGOM1S42JjawMal6g+R5k8lk6Nu3L/r27YvPPvsM9vb2CA4Ohq+vL/T09PD48WOl9GFhYbC3t8fChQulbTdu3FBKo+p5Xbt2RWpqKnR0dKQJ508jKioKgLirroqLiwuKiopw+vRpaf7G3bt3ERcXJ/XIAEBRURHOnj2Lnj17AhBzaO7fv4927dpJaZycnODk5IT33nsP48aNQ2BgIEaOHImuXbvi8uXLaN26dbXzP2LECEyfPh0HDhxAUFAQvL29pX1Xr15FRkYGvvzyS9jZ2QGAUpAFAFLEuNLl+zRlUF0uLi7YvXu30rZTp05V+rzyylHV56S6Tp06JTU4MzMzERcXJ72HlpaWSE1NVWq8lA6YUJU8uLi4YOfOnUrHCQ8Ph4mJCZo1a/ZM+WfPxzMFPHjw4AGAJyEVExMTkZqaCk9PTymNXC5H//79ER4eDkB0DxcWFiqlsbW1RYcOHaQ0jDHGGHu+Tp8+jeXLl+Ps2bNITk7Grl27kJ6eLv1AdnBwwIULFxAbG4uMjAwUFhaidevWSE5OxrZt25CQkIDvvvsOwcHBSsd1cHBAYmIioqOjkZGRgfz8fAwaNAhubm4YMWIEDh48iKSkJISHh+PTTz8t8wO/2MmTJ7F69WpER0cjMTERO3bswPTp0zFs2DClHpaS2rRpg+HDh2PatGk4ceIEzp8/jzfffBPNmjXD8OHDpXS6urqYM2cOTp8+jXPnzuGtt95C79690bNnT+Tm5mL27NkIDQ3FjRs3EBYWhoiICKlc5s+fj5MnT2LWrFmIjo7GtWvXsGfPHsyZM6fSMjcyMsLw4cOxaNEixMTEYPz48dK+Fi1aQE9PDwEBAbh+/Tr27NlTZu0ee3t7yGQy/PXXX0hPT0d2dvZTl0F1zZgxAwkJCfD19UVsbCyCgoKkSH6qVFaODg4OyM7OxuHDh5GRkYFHjx5VO09Lly7F4cOHcenSJUyePBlNmjSR1u1xd3dHeno6WFs5fgAA72ZJREFUVq5ciYSEBKxbtw5///230vNVfcZLmzlzJm7evIk5c+bg6tWr+PPPP7F48WL4+vpCS4vjiNUJTzvpSKFQ0Kuvvqo0oSssLIwA0O3bt5XSTps2jTw9PYmIaOvWraSnp1fmeB4eHmUmDBbLy8ujBw8eKD14si1jjGkGBzxQrSoBD2qzK1eukJeXF1laWpJcLicnJycKCAiQ9qelpZGHhwcZGxsTADp69CgREX344YdkYWFBxsbGNGbMGFq9erXSxPW8vDx6/fXXqVGjRgSAAgMDiYjo4cOHNGfOHLK1tSVdXV2ys7OjCRMmUHJyssr8RUZGUq9evcjMzIz09fWpbdu2tHjxYsrJyanwdd27d4+8vb3JzMyMDAwMyMvLi+Li4qT9xRPtd+7cSS1btiQ9PT166aWXpMAP+fn5NHbsWLKzsyM9PT2ytbWl2bNnK723Z86ckcrGyMiIOnXqRF988YW0397enlavXq0yf/v27SMA9OKLL5bZFxQURA4ODiSXy8nNzY327NmjNPmeiGjp0qVkbW1NMpmMJk2aRETKAQ+qUwYlBQcHU2U/E/fu3UutW7cmuVxO/fr1o59//rncgAdVKccZM2aQhYUFAaDFixeXW3blBTzYu3cvtW/fnvT09KhHjx4UHR2t9Lz169eTnZ0dGRkZ0cSJE+mLL75QCnig6jNe+lxERKGhodSjRw/S09Mja2trmj9/PhUWFkr7S5c/EdHw4cOl94c9nZoKeCAjeopBmwBmzZqFffv24cSJE1KggvDwcPTt2xd37txR6oKeNm0abt68KXXrvvXWW8jPz1c6noeHB1q1aoUffvihzLn8/PywZMmTCaImJiZITU2FgYGByjG6jDHG1IeIkJuby9fgUkqWS35+PhITE+Ho6Ah9fX1NZ40xxuq8vLy8cq+r1amXnqp/bs6cOdizZw+OHj2qFKGteAXc1NRUpfRpaWmwsrKS0hQUFCAzM7PcNKUtWLAADx48kB63bt16mmwzxhhj6qdiEj9jjLHaoVqNHyLC7NmzsWvXLhw5cqRM9BdHR0dYW1srLeJUUFCAY8eOSZPsunXrBl1dXaU0KSkpuHTpksrFpAAxb8jU1FR6FEeNY4wxpgH8475iS5YATzeogjHGmJpVK9rbrFmzEBQUhD///FMaegYAZmZmUjeTj48Pli9fjjZt2qBNmzZYvnw5DA0NpUl8ZmZmmDJlCt5//31YWFjA3NwcH3zwATp27ChFf2OMMVZLEYkf9/v3azontde5c0BYGMCRnxhjrNapVuOneOEtd3d3pe2BgYGYPHkyAOCjjz5Cbm4uZs6cKS1yGhISotRbs3r1aujo6GD06NHSIqebNm3iNX4YY6y2CwkRP+5Z+bS1gW+/BVau1HROGGOMlfLUAQ80iSfbMsaYBhAB3buD4uORm5LC1+BSpLrJ2hr55uZI3LULji4uHPCAMcZqgEYDHjDGGGuAvvpK9PrUvXtmz5+2NnD/PpcVY4zVMtz4YYwxVrEHD4B33gHmz9d0TuqOx4+BggJAxaKTjDHGNIcbP4wxxsq3bx/Qvj3w668aOf3x48fx6quvwtbWFjKZDLt371baT0Tw8/ODra0tDAwM4O7ujsuXLyulyc/Px5w5c9CkSRMYGRlh2LBhZZZMyMzMhLe3N8zMzGBmZgZvb2/cv3//2V9AWhr3/jDGWC3CjR/GGGNlZWQAb74JDB0qGj9OToDW868ycnJy4OrqirVr16rcv3LlSqxatQpr165FREQErK2t4eHhgaysLCmNj48PgoODsW3bNpw4cQLZ2dkYOnQoHj9+LKUZP348oqOjceDAARw4cADR0dHw9vZ+9hdQWMiNH8YYq02oDlIoFJSTk0MKhULTWWGMsfpFoSDavp3I0pKocWOizZuJcnOJrKyIxM94UpiYaOQaDICCg4NLZFVB1tbW9OWXX0rb8vLyyMzMjH744QciIrp//z7p6urStm3bpDS3b98mLS0tOnDgABERXblyhQDQqVOnpDQnT54kAHT16tUq56+4boo5tI1y16yhK3//Tbl37jzty2XPSWBgIJmZmWk6GzWqf//+NG/ePLWf58SJE9ShQwfS0dGh4cOHq/189UViYiIBoKioKCIiOnr0KAGgzMzMGj9Xyetm6fOq81zqkJubS1euXKHc3Nwy+6rTNuCeH8YYY8KdO8BrrwFjxgAvvghcuQJMnAjo6wMREUBkJBAZidhdGzWdUwBAYmIiUlNT4enpKW2Ty+Xo378/wsPDAQCRkZEoLCxUSmNra4sOHTpIaU6ePAkzMzP06tVLStO7d2+YmZlJaVTJz8/Hw4cPpUdxb1Ne+7ZijpSBgRj2VqKHqS6bPHkyRowYUe3n+fn5oXPnzjWSBwcHB8hkMqXHxx9/XCPHrotCQ0Mhk8nKDNHctWsXli1bpvbz+/r6onPnzkhMTMSmTZvUfr76qk+fPkhJSYGZmVmlact7z8uTkpKCIUOGPGMOlZX3nVbHudSBGz+MMdbQEQE//wy4uAAnTwJ//CEe1tZP0tjZAV27Al27ih/3tUDxQttWVlZK262srKR9qamp0NPTQ+PGjStM07Rp0zLHb9q0qZRGFX9/f2mOkJmZGZo3b/5kp0wGmJsDRUXA7dtP9fok//wj3pt//nm249QTS5cuRUpKivT49NNPNZ2laisoKFDr8c3NzZXWV1SXhIQEvPTSS2jevDkaNWpUZj8RoaioSO35qOv09PRgbW1do0sHFH/GrK2tIZfLa+y4FXme53oW3PhhjLGGLCkJ8PICpkwBhg8XvT2vv67pXFVL6R8MRFTpj4jSaVSlr+w4CxYswIMHD6RH6SAK0NEBrKxE78/TRn0jAj75BIiJEf+qef7QH3/8gY4dO8LAwAAWFhYYNGgQcnJy4Ofnh82bN+PPP/+UelxCQ0MBAPPnz4eTkxMMDQ3RsmVLLFq0CIWFhQCATZs2YcmSJTh//rz0vOIeggcPHuCdd95B06ZNYWpqipdeegnnz5+vNI8mJiawtraWHsbGxhWmz8zMxMSJE9G4cWMYGhpiyJAhuHbtWpl0u3fvhpOTE/T19eHh4YGbN29K+86fP48BAwbAxMQEpqam6NatG86ePSvtDw8Px4svvggDAwPY2dlh7ty5yMnJkfY7ODjg888/x+TJk2FmZoZp06bBzc2tTK9Veno6dHV1cfToUQDAli1b0L17d+k1jx8/HmlpaQCApKQkDBgwAADQuHFjyGQyacF5d3d3+Pj4VLkMNm3ahEaNGuHgwYNwdnaGsbExBg8ejJSUFJVlmpSUBJlMhrt37+Ltt9+W3tfiXomDBw+ie/fukMvl+Pfff0FEWLlyJVq2bAkDAwO4urrijz/+UDrm/v374eTkBAMDAwwYMACbNm1S6uFQ1duwZs0aODg4KG0LDAyEs7Mz9PX10a5dO3z//fdl8r1r1y4MGDAAhoaGcHV1xcmTJ5WOERYWhv79+8PQ0BCNGzeGl5cXMjMz8csvv8DCwgL5+flK6V9//XVMnDhRZVkBwJkzZ9ClSxfo6+uje/fuiIqKUtpfujfnxo0bePXVV9G4cWMYGRmhffv22L9/f6Xv+ezZs+Hr64smTZrAw8MDAFQGirl69Sr69OkDfX19tG/fXvouA08+CyXt3r1buhZW9J0ufa6LFy/ipZdekq4n77zzDrJLXAuLe5O//vpr2NjYwMLCArNmzZKuH2pTw8Pxngue88MYY8/o8WOi774jMjIisrMj2r+/yk+NuhNVK+b8JCQkEAA6d+6cUrphw4bRxIkTiYjo8OHDBIDu3bunlKZTp0702WefERHRTz/9pHLOh5mZGf38889Vzl9x3RR1J+rJ2PRHj4iuXCG6dEmUeXUdOCDNtSJA/K0md+7cIR0dHVq1ahUlJibShQsXaN26dZSVlUVZWVk0evRoGjx4MKWkpFBKSgrl5+cTEdGyZcsoLCyMEhMTac+ePWRlZUUrVqwgIqJHjx7R+++/T+3bt5ee9+jRI1IoFNS3b1969dVXKSIiguLi4uj9998nCwsLunv3brl5tLe3J2trazI3NydXV1f6/PPPpXyUZ9iwYeTs7EzHjx+n6Oho8vLyotatW1NBQQERiTk/urq61L17dwoPD6ezZ89Sz549qU+fPtIx2rdvT2+++SbFxMRQXFwc7dixg6Kjo4mI6MKFC2RsbEyrV6+muLg4CgsLoy5dutDkyZOV8m1qakpfffUVXbt2ja5du0YBAQHUokULpe9RQEAANWvWjB7//2flp59+ov3791NCQgKdPHmSevfuTUOGDCEioqKiItq5cycBoNjYWEpJSaH79+8TUdk5P1Utg0GDBlFERARFRkaSs7MzjR8/XmWZFhUVUUpKCpmamtKaNWuk97V47kqnTp0oJCSE4uPjKSMjgz755BNq164dHThwgBISEigwMJDkcjmFhoYSEVFycjLJ5XKaN28eXb16lbZs2UJWVlZK82AWL15Mrq6uSvlYvXo12dvbS39v2LCBbGxsaOfOnXT9+nXauXMnmZub06ZNm4joyZyXdu3a0V9//UWxsbE0atQosre3p8LCQiIiioqKIrlcTu+++y5FR0fTpUuXKCAggNLT0+nRo0dkZmZGO3bskM6Znp5Oenp6dOTIEZVllZ2dTZaWljRmzBi6dOkS7d27l1q2bFnhnJ9XXnmFPDw86MKFC5SQkEB79+6lY8eOVfqeGxsb04cffkhXr16lmJgYIlI956d58+b0xx9/0JUrV2jq1KlkYmJCGRkZ0meh9PUwODiYipsM5X2nS58rJyeHbG1t6bXXXqOLFy/S4cOHydHRkSZNmiQdd9KkSWRqakozZsygmJgY2rt3LxkaGtKGDRtUlmVNzfnhxg9jjDU0V68S9e0rfkzPnEn08GG1nl5bGj/FAQ+Kf2gTEeXn56sMeLB9+3YpzZ07d1QGPDh9+rSU5tSpU08d8ECp8ZObS5STQxQRQRQfTxQZWfXH2bNELi5EWlrivdLSEn+fPVu94+TkVCn/kZGRBICSkpJU7p80aVKVJrWvXLmSunXrJv2t6kfr4cOHydTUlPLy8pS2t2rVin788cdyj71q1SoKDQ2l8+fP08aNG6lJkyY0ZcqUctPHxcURAAoLC5O2ZWRkkIGBgfQDNjAwsEzAi5iYGKXPhImJifQDujRvb2965513lLb9+++/pKWlJf1Is7e3pxEjRiilSUtLIx0dHTp+/Li0zc3NjT788MNyX8+ZM2cIAGVlZRFR+RPlSzZ+qlMG8fHxUpp169aRlZVVuXkhEjcIAgMDpb+L87N7925pW3Z2Nunr61N4eLjSc6dMmULjxo0jIqIFCxaQs7Oz0jVl/vz51W782NnZUVBQkFKaZcuWkZubGxE9+fH/v//9T9p/+fJlAiA1FsaNG0d9+/Yt9zW/++67UgOUiGjNmjXUsmXLcq+HP/74I5mbm1NOie/h+vXrK2z8dOzYkfz8/FQer6L3vHPnzmXSq2r8lAwSU1hYSM2bN5euo5U1fohUvxelz7VhwwZq3LgxZWdnS/v37dtHWlpalJqaSkTimmJvb09FRUVSmjfeeIPGjBmj8rXXVONHR739SowxxmqNwkLg66+BJUvEHJ5jx0Rgg1osOzsb8fHx0t+JiYmIjo6Gubk5WrRoAR8fHyxfvhxt2rRBmzZtsHz5chgaGmL8+PEAADMzM0yZMgXvv/8+LCwsYG5ujg8++AAdO3bEoEGDAADOzs4YPHgwpk2bhh9//BEA8M4772Do0KFo27YG5jcZGor5U8eOifDhT0uhEMMSu3ev3vMiI8V8rUq4urpi4MCB6NixI7y8vODp6YlRo0aVmS9V2h9//IE1a9YgPj4e2dnZKCoqgqmpaSVZikR2djYsLCyUtufm5iIhIaHc57333nvS/zt16oTGjRtj1KhRWLFiRZljAUBMTAx0dHSUgllYWFigbdu2iImJkbbp6Oige4lybdeuHRo1aoSYmBj07NkTvr6+mDp1Kn799VcMGjQIb7zxBlq1aiW9lvj4eGzdulV6PhFBoVAgMTERzs7OAKB0fACwtLSEh4cHtm7din79+iExMREnT57E+vXrpTRRUVHw8/NDdHQ07t27B4VCAQBITk6Gi4tLueX0NGVgaGgovSYAsLGxkYbYVVfJ13rlyhXk5eVJw7CKFRQUoEuXLlIee/furTTM1M3NrVrnTE9Px82bNzFlyhRMmzZN2l5UVFQmkECnTp2k/9vY2AAA0tLS0K5dO0RHR+ONN94o9zzTpk1Djx49cPv2bTRr1gyBgYGYPHlyuUNkY2Ji4OrqCkNDwyq/trlz5+Ldd99FSEgIBg0ahNdff10pz+Up/RkrT8nzF3/2S34WakLx6zYyMpK29e3bFwqFArGxsdJczfbt20NbW1tKY2Njg4sXL9ZoXkrjxg9jjDUE0dHA228D588D778vGkAGBprOVaXOnj0rjXEHRHQpAJg0aRI2bdqEjz76CLm5uZg5cyYyMzPRq1cvhISEKE32Xr16NXR0dDB69Gjk5uZi4MCB2LRpk1KFu3XrVsydO1eKCjds2LBy1xZ6Kra2QJs2IpCEg4MIiFARIhFp7+pV0egppqUFtGsH/PJL5cco1q5dlZJpa2vj0KFDCA8PR0hICAICArBw4UKcPn0ajo6OKp9z6tQpjB07FkuWLIGXlxfMzMywbds2fPPNNxWeS6FQwMbGRmmuQTFVE+fL07t3bwBAfHy8ysYPlTNHilTM51L147V4m5+fH8aPH499+/bh77//xuLFi7Ft2zaMHDkSCoUC06dPx9y5c8s8v0WLFtL/S/4ILDZhwgTMmzcPAQEBCAoKQvv27eHq6gpArHHl6ekJT09PbNmyBZaWlkhOToaXl1e1AiZUtQx0dXXLvPbynluZkq+1uMG2b98+NGvWTCld8eT4qpxHS0urTLqSc0OKz7Nx40alhh4Ape86oPxai8ug+PkGlVwXu3TpAldXV/zyyy/w8vLCxYsXsXfv3nLTP00ZTp06FV5eXti3bx9CQkLg7++Pb775BnPmzKnweao+Y1VVXA6VlXNVqfqOlT4XoPpzpyh5zVMDbvwwxlh9lp8PLFsGrFgBODsDp04BPXpoOldV5u7uXuGPB5lMBj8/P/j5+ZWbRl9fHwEBAQgICCg3jbm5ObZs2fIsWa1YcaNFSwto0QKwtKw4/cGDopentOLen4wMEaiihslkMvTt2xd9+/bFZ599Bnt7ewQHB8PX1xd6enpKC8MCYmK4vb09Fi5cKG27ceOGUhpVz+vatStSU1Oho6NTZsJ6dRRPHC++e1+ai4sLioqKcPr0afTp0wcAcPfuXcTFxUk9MoDoHTh79ix69uwJAIiNjcX9+/fRrkTD0cnJCU5OTnjvvfcwbtw4BAYGYuTIkejatSsuX76M1q1bVzv/I0aMwPTp03HgwAEEBQUpLax79epVZGRk4Msvv4SdnR0AKAVZAETZAihTvk9TBuri4uICuVyO5ORk9O/fv9w0pSflnzp1SulvS0tLpKamKv2ojo6OlvZbWVmhWbNmuH79OiZMmPDU+e3UqRMOHz6MJUuWlJtm6tSpWL16NW7fvo1BgwZJ748qLi4u+PXXX5Gbmys1rEq/NlXs7OwwY8YMzJgxAwsWLMDGjRsxZ86cKr3nlTl16hRe/P9e/6KiIkRGRmL27NkARDlnZWUhJydHakyVLGdA9Xe6NBcXF2zevFnpOGFhYdDS0oKTk9NT570mcLQ3xhirr06eBLp0AVauBBYtAs6erVMNn3rH1BRo0gS4dQuo6M49kXi/tMqporW0xP4ajvx2+vRpLF++HGfPnkVycjJ27dqF9PR06Qeyg4MDLly4gNjYWGRkZKCwsBCtW7dGcnIytm3bhoSEBHz33XcIDg5WOq6Dg4M0XDEjIwP5+fkYNGgQ3NzcMGLECBw8eBBJSUkIDw/Hp59+WuYHfrGTJ09i9erViI6ORmJiInbs2IHp06dj2LBhSj0sJbVp0wbDhw/HtGnTcOLECZw/fx5vvvkmmjVrhuHDh0vpdHV1MWfOHJw+fRrnzp3DW2+9hd69e6Nnz57Izc3F7NmzERoaihs3biAsLAwRERFSucyfPx8nT57ErFmzEB0djWvXrmHPnj2V3qUHxJ364cP/j737Dovi6uIA/FvKLh0FqYpgQxEVVCxojF3UxG7shcTeoiEaW4xYoolJLDHGROMHRkVNVIzGhg17AQQrigXEAgKKBUQQON8fN4wsLAjKspTzPs8+wMzszJ27y86eufee2wNz5sxBeHi41F0TEK1GcrkcK1euxJ07d7Br165cc/fY29tDJpPh33//RXx8vFImrcLWgboYGxtj6tSp+OKLL7B+/Xrcvn0boaGhWLVqFdavXw8AGDt2LG7fvg0vLy/cuHEDfn5+ueYNatOmDeLj47FkyRLcvn0bq1atwr59+5S28fb2xuLFi7FixQpERETg8uXL8PHxwdKlSwtc3pkzZyIoKAjjx4/HpUuXcP36daxevRoJCQnSNoMHD8aDBw+wdu1afPbZZ/nub9CgQdDS0sKIESNw7do17N27Fz/++GO+z5kyZQoOHDiAyMhIXLhwAUeOHJHebwV5zd9m1apV8Pf3x/Xr1zFhwgQkJiZK59GsWTMYGBhg1qxZuHXrlsrXQtX/dE6DBw+Gnp4ehg8fjitXruDo0aOYNGkShg4dmmt6gmL31lFBJRAnPGCMsXwkJRFNnkwkkxE1aUJ0+XKR7l5TCQ9KujwTHmT3+jVRaKhIfpCXV6+IrKyUs7zlfFhbi+2K0LVr18jDw4MsLCxIoVCQo6MjrVy5UlofFxdHHTt2JCMjIwJAR48eJSKiadOmkbm5ORkZGVH//v1p2bJlSgOmX716RX369KEKFSoQAGmA/PPnz2nSpElka2tLurq6ZGdnR4MHD6bo6GiV5QsJCaFmzZqRqakp6enpUe3atWnu3LlKA8lVefLkCQ0dOpRMTU1JX1+fPDw8KCIiQlqfNcB7+/btVL16dZLL5dSuXTsp8UNqaioNGDCA7OzsSC6Xk62tLU2cOFHptT1//rxUN4aGhtSgQQP69ttvpfX29va0bNkyleXbs2cPAaAPP/ww1zo/Pz9ycHAghUJB7u7utGvXLqWB8kRE8+fPJ2tra5LJZFImrZzZ3gpaB9nlHOSuSl4JD3IOxs/MzKQVK1ZQ7dq1SVdXlywsLMjDw4OOHTsmbbN7926qWbMmKRQKatWqFf3vf//Lta/Vq1eTnZ0dGRoa0rBhw+jbb79VSnhARLRp0yZydXUluVxOFStWpA8//JB27NhBRG8G/Gevv8TERKX3MxFRYGAgtWjRghQKBVWoUIE8PDxyndPQoUPJzMwsV9IOVc6cOUMuLi4kl8vJ1dVVytiWV8KDiRMnUo0aNUihUJCFhQUNHTpUysZGVLDXPAtUJDzw8/OjZs2akVwuJycnJzp8+LDSc/z9/almzZqkp6dHH3/8Ma1Zs0bpvZDX/3T2YxGJTIht27YlPT09MjMzo1GjRknJOohUJ1GZPHkytW7dWmU9FlXCA9l/hS1ViEhqPizKCaEYY6zUO3wYGDUKiIkBFi4EpkwBcvR3f19hMWFwNHXkz+Acsq5NEc8iUKdiHURGRqJatWrQ09NT3vDJE+DOHaBmTSCv8S337gHx8XkfzNISyD6pKmNlTGBgINq2bYvExMRCjQMrLh07doSTkxN+/vlnTRel3Hj16lWen6uFiQ14zA9jjJUFz54BU6cCf/wBtG4NBASIL9es5KlYETA1Be7eBYyNVQendnbiwRgrUZ48eYKAgAAcOXKkaJOisGLDwQ9jjJV2u3cDY8cCL14Av/0mWn7yGi/CNE8mE0kPrl4V43/s7TVdIsZYATVq1AiJiYn4/vvviyYVPit2HPwwxlhpFR8PTJ4MbN4MdO0qAh9uLSgdFAqgcmXRvc3cHDAy0nSJGCtR3pbpUVOioqI0XQT2nvjWIGOMlTZEIuCpW1ekRN6wAfj3Xw58ShtLS8DQEIiKUp7LhzHGmNpw8MMYY6XJgwdAjx7AoEFA27ZizpchQwo+4SUrVvneuZbJRJe31FQgNrb4CsUYY6VQUbUEcvDDGGOlAZFIZuDsDAQFATt2AH/9BWh6vgSmUtaM8mn5zecDAAYGgLW1yM6XklIMJWOMsdIp6/NU+z0zmPKYH8YYK+nu3AFGjxZprD/9FPjpJ5ExjJVYOjo6MDAwQHx8PHR1daGVXwKKihWBx4+ByEigWjVuxWOMsRwyMzMRHx8PAwMD6Oi8X/jCwQ9jjJVUGRnAypXA7NmAhYUY39Opk6ZLxQpAJpPBxsYGkZGRuHv37tufkJEBPHwIJCWJ9NeMMcaUaGlpoWrVqu89vxwHP4wxVhKFhwMjRgBnzgATJwKLFvGX4lJGLpejVq1ab+/6lmXTJmD/fmDvXpEMgTHGmEQul+ffil5AhQ5+jh8/jh9++AEhISGIiYmBv78/evbsKa339PTE+vXrlZ7TrFkznD17Vvo7NTUVU6dOxebNm5GSkoL27dvj119/RRWerZoxVt69fg0sWQLMnw84OAAnTgAffKDpUrF3pKWllWsm8jzNng1s3Ah88QWwfbt6C8YYY+VUocOn5ORkuLi45DurbefOnRETEyM99u7dq7R+ypQp8Pf3x5YtW3Dy5EkkJSXh448/RkZGRuHPgDHGyorQUKBpU2DuXMDLCwgL48CnPKlYEfj5Z5HMYudOTZeGMcbKpEK3/HTp0gVdunTJdxuFQgFra2uV6549e4Z169Zhw4YN6NChAwBg48aNsLOzw6FDh+Dh4VHwwgQGilSvjDFWmr16JVp6liwB6tUDzp0DGjfWdKmYJnzyiZi3acIEcX0zNdV0iRhjrExRS6rrwMBAWFpawtHREaNGjUJcXJy0LiQkBK9fv0anbIN2bW1tUa9ePZw+fbpwB5o3T6R/ZYyx0urUKcDVVWRw8/YWaaw58Cm/ZDLg11+B58+BGTM0XRrGGCtzijz46dKlCzZt2oQjR47gp59+QlBQENq1a4fU1FQAQGxsLORyOSrmSNNqZWWF2DwmeUtNTcXz58+lx4sXL8SKCxeAgICiPgXGGFO/pCTg88+BVq2AChVEl7evvwZ0dTVdMqZpdnbA4sXAb78BJ09qujSMMVamFHnw079/f3z00UeoV68eunXrhn379iEiIgJ79uzJ93lElGfqusWLF8PU1FR6SIkRtLSAmTO59YcxVrocPAjUry8mLf3pJ9H6U7eupkvFSpJx44DmzYFRo4D/bh4yxhh7f2rp9padjY0N7O3tcfPmTQCAtbU10tLSkJiYqLRdXFwcrPKYqXzmzJl49uyZ9Lh//75YkZkp7pZWrCj6Ro8fD/zyi5gIMCaGgyLGWMny9KlIX92pE1C9OnDlisjs9Z6zVbMySFsbWLsWuH1btAIxxhgrEmqf5+fx48e4d+8ebGxsAACNGzeGrq4uDh48iH79+gEAYmJicOXKFSxZskTlPhQKBRQKhfQ3ESElJUX8oaUFGBqKCQBPnADWrQOy5lQwNRV3U52c3vx0cgLs7cXzGGOsuOzcKW7QJCcDa9YAI0eK8R2M5aVePWD6dDHHU79+3DrIGGNFoNDBT1JSEm7duiX9HRkZibCwMJiZmcHMzAze3t7o06cPbGxsEBUVhVmzZqFSpUro1asXAMDU1BQjRozAl19+CXNzc5iZmWHq1KmoX7++lP2tUDIzxazYI0YAHh5Aejpw546YIPDaNfHz4kVg61bxpQMADAyA2rVzB0Y1anB/e8ZY0YqLAyZNAv76C/j4Y2D1aoDnNGMFNXs28PffovvbiRN8444xxt5ToT9Fg4OD0bBhQzRs2BAA4OXlhYYNG+Kbb76BtrY2Ll++jB49esDR0RHDhw+Ho6Mjzpw5A+NsM5MvW7YMPXv2RL9+/dCyZUsYGBhg9+7d0H7Xrh9aWsCcOaKbm44O4OgI9OghxgP9+ScQHCwy50RFAfv2AQsXimxKUVGiv33v3iL4MTQEnJ1FqtFvvgE2bxaBU1YrE2OMFRQRsGmTuLly+LD4fdcuDnzUwMHBATKZLNdjwoQJAMTk2znXNW/eXGkfqampmDRpEipVqgRDQ0N07979TRdrTdLTEy2Fp08Dv/+u6dIwxlipJyMqfQNjsrq96VtbQ5aV+c3aWgQz2brHFXBn4s5sVitR9p9Z2edkMtE/P3srUd26QJ06gIlJkZ4bY6wMuH8fGDsW2LMHGDAAWLECsLTUdKmKTFhMGBxNHaGvr59nopriFB8frzRJ9pUrV9CxY0ccPXoUbdq0gaenJx49egQfHx9pG7lcDjMzM+nvcePGYffu3fD19YW5uTm+/PJLPHnyBCEhIQW+MZd1bYp4FgFXG9ciOz8AwOjRwJYt4vpUuXLR7psxxko5KTYowHVJ7WN+1OnGjrWoY1ZL/GFpWfjABxCBjZWVeOScMDUxUVxosh7XromuK1FRb7apUuXNWKLsgVGlSu98XoyxUiozU2RwmzZNtCT/8w/QvbumS1XmWVhYKP393XffoUaNGmjdurW0rNgm31aXJUuA3buBiRMBf39Nl4YxxkqtUh38vHKuDRT13bXsKlYEWrQQj+ySk4EbN5RbiQ4cAFatArLuPlaqlHtMUd26gK0tD3JmrCy6fVskMQgMFGMQf/xRzN/DilVaWho2btwILy8vpbt/WZNvV6hQAa1bt8a3334Ly/9a4942+XaJCH4qVABWrhTdsnfsEN21GWOMFVqpDn40xtAQaNRIPLJLSwNu3lTuPnfmDODr+2aeBhOTNy1F2QMjBwdOd8tYaZSRIbq1ff21aEE+eBB4l+QtrEjs3LkTT58+haenp7SsS5cu+OSTT2Bvb4/IyEjMmTMH7dq1Q0hICBQKxTtNvg2IcUKpOebg0dFR42W1Tx/RkjhxItCuHQfXjDH2Djj4KUpyuUiY4OysvDwjA4iMVA6Krl4Ftm0Ts7wDYlCrqgx0NWuK/TLGSp6rV0Urz/nzwOefi2QqRkaaLlW5tm7dOnTp0gW2trbSsv79+0u/16tXD25ubrC3t8eePXvQO58WlPwm3wbEBNzz5s2T/jY2Ns43WHpvMpnoYVC3LjBjBvDbb+o7FmOMlVEc/BQHbW0RxNSsCXTr9mY5kRgYnT0oCg8HAgKAx4/FNjo64nk5u8/Vri1SdjPGil9aGvD998CCBSJF/smTubvHsmJ39+5dHDp0CDt27Mh3u/wm387e+hMXF4cW+byuM2fOhJeXV9EUvqCqVBGTnk6cCAwaBHz4YfEenzHGSjkOfjRJJgPs7MQjW19zAEB8fO4MdD4+Yk6jrOc6OOQOipycxOSujDH1CA4WrT1Xr4oJKOfMES23TON8fHxgaWmJjz76KN/timLybeAtE3Cr07hxInX66NFAWBi//xhjrBA4+CmpLCyA1q3FI7tnz4Dr15UDox07RLe6rKzlNjaqky1YWBQs2cKhQ6ILz88/89gFxrKkpADe3iKRQYMGQFAQ8N98Z0zzMjMz4ePjg+HDhyuNu0lKSir+ybfVTUsLWLtWvP8WLQLmz9d0iRhjrNTg4Ke0MTUFmjUTj+xevgQiIpSDosOHRZ/w9HSxjZmZ6qCoSpU3QRERMGuW2MesWUD79pydrqhxcFn6nDghMrlFRYmubtOmAbq6mi4Vy+bQoUOIjo7GZ599prQ8a/LtP//8E0+fPoWNjQ3atm2LrVu35pp8W0dHB/369UNKSgrat28PX1/fd598W92cncVE3osXA/375x5ryhhjTKVSPcmpWiaSK2tevwZu3co9gev168CrV2IbIyMxYWvdumJ8UraJALFhg/iCrqMjHrq6b35qaWnmnEozIhG4BgUBTZoA585xcFmSvXghvmCuWiXG9KxbJ/5XyrmSNslpSVHs16bUVMDVVUzLcPIkfyYzxsqtcjPJKSsAXd03abWzZzXKyADu3s2dgS44WPn5Q4fmvW+ZLHdAlP1nUS9T137fdqyivPMbECACH0D8DAgASsIcIiy3AwfEmIqEBJHKesIETkfPShaFQnR/a9UKWL1avEcZY4zli4Of8kpbG6heXTyyBgcfOAB07px723nzxBiH9HTRkpServx7YZflXJeWJiaOfZ/9Zk0uqw45g7x3Daq0tYHjx8X+iMTPMWNE10QHB6BqVc7gVxI8eQJ4eQHr14tun4GBQLVqmi4VY6p98IH4HJk5E+jRQ3RjZowxlicOfphAJLJWaWsrBxLa2sC//4p1Jbl7C5Eo99sCLXUue9v2Dx8CiYnKZb57F+jS5c2ySpUAe3sRCNnb5/7d3Lxkvw6l3Y4d4u55Sgrwxx/AZ59xfbOS7/vvgV27xHt3505+zzLGWD44+GFC9u5Y2WVklI7uWVmtM+qcXf19ZI31URVcOjuL5AfR0SIYyvq5b5/4PXvqXAMDEQzlFRxVrlxy66Ake/RIzJuybRvQvbvoQpRtkkzGSjRTU+CXX4A+fYDt24G+fTVdIsYYK7H4WxJ70+qjpQVkZuZer6Ul1nfqxHcU31V+weWlSyL5hKrxVURizEn2oCjr95AQwN9frM+ipSUCoLxaj6pWFQkumEAEbNwITJkiAtEtW4B+/fh9zkqf3r2Bnj2BSZNEd81sk7Uyxhh7g4MfJsbcREerDnwAsfzePbFdtgn9WAG9T3Apk4n5mSwsADc31ftPThavX87g6O5dkQHqwQPl1iYzs/y71hV0PqjS7t49MVZi3z5g0CCR1KBSJU2XirF398svImvn9OnAmjWaLg1jjJVIHPwwEdAEBQHx8QCA8PhwDN4xBJt6b4SThZPYxtKSA593pe7g0tDwTUY/VbLGG6lqPTp4UPz+8uWb7fX0lFuKcgZIVaqU7jluMjPFF8OvvgJMTMRYiW7dNF0qxt5f5crAd98B48cDgwfnniSbMcYYBz/sP3Z24gEgJQYIPQukNHACbBppuGBlgKaDSx2dN+OEVCESGc5UBUcXL4rg4L+yAxCtQra2+bceZZs8skS5eRMYNQo4dkz8/OEHMV6CsbJizBhg0yaRpv3iRXEzgzHGmISDH8aKQ0kOLmUykUXO3BxolEd5UlJyJ2TI+v3sWeD+fdHClKVCBdXjjbKWWVoW74SM6enA8uWie6GtLXD4MNCuXfEdn7HioqUlWjZdXYGFC8WDMcaYhIMfxtjb6esDtWuLhyoZGUBMjOrg6OhR8XtS0pvtFQoRDObVemRnB8jl717eQ4eAzz8XWfSsrUXK6uBgkdhgwQLRVZCxsqpuXWDWLODbb4H+/YH69TVdIsYYKzE4+GGMvT9tbTEWqEoVoGXL3OuJgKdPcydkuHsXuHoV2LtXpJvOIpOJoCW/1qO8uqsRiS9+4eHA8OFAXBxQqxZw+jTQvLlaTp+xEmfmTOCvv0T3zlOnxP8oY4wxDn4YY8VAJhOpdytWFN1xVHn1SiR+UNV6FBQk1r1+/WZ7ExPV440ePnyTVvzhQ2DgQMDHhxN2sPJFoQDWrgU++AD49VeRApsxxhgHP4yxEkJPT7TQ1Kqlen1GhmgdUtV6dOKEmK/n+XOlp5CWFmS3br1fFzrGSquWLYFx40RLaM+e0rhDxhgrzzj4YYyVDtraIlmBrS3g7q56mx07xCz3/5FlZopWoIAAwMOjmArKWAmyeDHwzz8i/fWuXeVjDi/GGMtHMaZbYowxNSISc5zkHNugrS2yvBFpplyMaZKpKbBqFfDvv8Dff2u6NIwxpnEc/DDGyoaAANHKk5GhvDwj403rD2PlUc+eQO/eIgNiYqKmS8MYYxpV6ODn+PHj6NatG2xtbSGTybBz506l9UQEb29v2NraQl9fH23atMHVq1eVtklNTcWkSZNQqVIlGBoaonv37rh///57nQhjrBwjEq07ec0dpKXFrT+sfFu5UiQVmTZN0yVhjDGNKnTwk5ycDBcXF/zyyy8q1y9ZsgRLly7FL7/8gqCgIFhbW6Njx4548eKFtM2UKVPg7++PLVu24OTJk0hKSsLHH3+MjJx3bBljrCDS0kQChMxM1eszM0W2uLS04i0XYyWFrS3w/ffAunVAYKCmS8MYYxpT6IQHXbp0QZcuXVSuIyIsX74cs2fPRu/evQEA69evh5WVFfz8/DBmzBg8e/YM69atw4YNG9ChQwcAwMaNG2FnZ4dDhw7BgwclM8YKS6EQXdvi4wEA4fHhGLxjCDb13ggnCyexjaUlp7tm5duoUcCmTcDo0cDFi2LyYsYYK2eKdMxPZGQkYmNj0alTJ2mZQqFA69atcfr0aQBASEgIXr9+rbSNra0t6tWrJ23DGGOFZmcHNGoENGqElAZOCLUFUho4SctQpYqmS8iYZmlpAWvWiPTwCxZoujSMMaYRRRr8xMbGAgCsrKyUlltZWUnrYmNjIZfLUbFixTy3ySk1NRXPnz+XHtm70DHGGGOsgOrUAWbPBn74Abh0SdOlYYyxYqeWbG+yHPMIEFGuZTnlt83ixYthamoqParwHVzGGGPs3cyYATg6AiNH5s6OyBhjZVyRBj/W1tYAkKsFJy4uTmoNsra2RlpaGhJzpNvMvk1OM2fOxLNnz6QHZ4ZjjDGWxdvbGzKZTOmRdT0COAtpLnI5sHYtEBwM5JG8iDHGyqoiDX6qVasGa2trHDx4UFqWlpaGY8eOoUWLFgCAxo0bQ1dXV2mbmJgYXLlyRdomJ4VCARMTE+lhbGxclMVmjDFWyjk7OyMmJkZ6XL58WVrHWUhVaNECGDdOdIG7e1fTpWGMsWJT6GxvSUlJuHXrlvR3ZGQkwsLCYGZmhqpVq2LKlClYtGgRatWqhVq1amHRokUwMDDAoEGDAACmpqYYMWIEvvzyS5ibm8PMzAxTp05F/fr1pexvjDHGWGHo6OgotfZk4Syk+Vi8GPjnH2D8eODff4G3dE9njLGyoNAtP8HBwWjYsCEaNmwIAPDy8kLDhg3xzTffAAC++uorTJkyBePHj4ebmxsePHiAgIAApdaaZcuWoWfPnujXrx9atmwJAwMD7N69G9ra2kV0WowxxsqTmzdvwtbWFtWqVcOAAQNw584dAJyFNF8mJsCvvwJ79wJbt2q6NIwxViwK3fLTpk0bUD6zpMtkMnh7e8Pb2zvPbfT09LBy5UqsXLmysIdnjDHGlDRr1gx//vknHB0d8ejRIyxcuBAtWrTA1atX881Ceve/7l7vkoUUEOOEUlNTlZbp6BT6sqpZ3bsDffsCkycDnToBZmaaLhFjjKmVWrK9McYYY8WlS5cu6NOnj9R9es+ePQBE97YsRZ2FFChDmUh//hlITQWmTtV0SRhjTO04+GGMMVamGBoaon79+rh586baspACZSgTqY2NmPfHxwc4ckTTpWGMMbXi4IcxxliZkpqaivDwcNjY2KgtCylQxjKRjhgBfPghMHo0kJKi6dIwxpjacPDDGGOsVJs6dSqOHTuGyMhInDt3Dn379sXz588xfPhwyGQyKQupv78/rly5Ak9PzzyzkB4+fBihoaEYMmRI+cpCqqUFrFkD3L8PzJ+v6dIwxpjalLKRmYwxxpiy+/fvY+DAgUhISICFhQWaN2+Os2fPwt7eHoDIQpqSkoLx48cjMTERzZo1U5mFVEdHB/369UNKSgrat28PX1/f8pWFtHZt4OuvAW9voH9/wNVV0yVijLEix8EPY4yxUm3Lli35rucspIXw1Vci7fWoUcDZs0B5Cv4YY+UCd3tjjDHGmCCXA2vXAiEhIgscY4yVMRz8MMYYY+yN5s2BCRNEF7ioKE2XhjHGihQHP4wxxhhTtmiRmPB03Dggn4nNGWOstOHghzHGGGPKjI2BX38F9u8HNm/WdGkYY6zIcPDDGGOMsdy6dQP69QOmTAEeP9Z0aRhjrEiU6WxvGRkZeP36taaLUerQa4K9oT3oNeHVq1eaLk6Zw/WrflzHRUtXV7d8pXxmb6xYATg5AV9+Cfj6aro0jDH23mREpa8zLxEhJSUFEc8i4GrjqnJ9bGwsnj59WuxlKwvSMtIQ8yIGNsY2kGvLNV2cMofrV/24jotehQoVYG1tDZlMhrCYMDiaOkJfXx8ymUzTRSsx3nZtKrXWrQNGjgQOHgTKy6SvjLFSJevztyDXpTLZ8pMV+FhaWsLAwIAvzoX0Mu0lXj99DbsKdjCQG2i6OGUO16/6cR0XHSLCy5cvERcXBwCwsbHRcIlYsfvsM2DjRmDMGODyZcCA/6cYY6VXmQt+MjIypMDH3Nxc08UplTK0MgAdQKGngJ5cT9PFKXO4ftWP67ho6evrAwDi4uJgaWmp4dKwYieTAWvWAPXrA/PmAd9/r+kSMcbYOytzCQ+yxvgY8J0pxhgrMlmfqTyOspyqVQv45hvgp5+A0FBNl4Yxxt5ZmQt+snBXN8YYKzr8mcowbRpQt64Y/5OerunSMMbYOymzwQ9jjDHGipCuLrB2rWj5WbFC06VhjLF3wsEP0yhfX19UqFBB08UoUm3atMGUKVOK/biBgYGQyWRSlkN11W1UVJTI+BUWpvK46jwWY0zDmjUDJk0SXeAiIzVdGsYYKzQOfkoJT09P9OzZs9DP8/b2hqura5GWJTU1Fa6uruX+S2leX/p37NiBBQsWaKZQ2fTv3x8REREF2rYwgZKdnR1iYmJQr1699yhdbqre4+o6FmPsPSxcCJibA2PHAqVvtgzGWDnHwQ8rtK+++gq2traaLsY7S0tLU+v+zczMYGxsrNZjFIS+vn6RZ+ZKS0uDtrY2rK2toaOj/mSRxXksxlgBGRsDq1cDAQHApk2aLg1jjBUKBz8lyLZt21C/fn3o6+vD3NwcHTp0QHJyMry9vbF+/Xr8888/kMlkkMlkCAwMBABMnz4djo6OMDAwQPXq1TFnzhwpG5Ovry/mzZuHixcvSs/z/W+G7mfPnmH06NGwtLSEiYkJ2rVrh4sXL761jPv27UNAQAB+/PHHAp1TYmIihg0bhooVK8LAwABdunTBzZs3c223c+dOODo6Qk9PDx07dsS9e/ekdRcvXkTbtm1hbGwMExMTNG7cGMHBwdL606dP48MPP4S+vj7s7Ozw+eefIzk5WVrv4OCAhQsXwtPTE6amphg1ahTc3d0xY8YMpTLEx8dDV1cXR48eBQBs3LgRbm5uMDY2hrW1NQYNGiTNdRIVFYW2bdsCACpWrAiZTAZPT08Aubu95ayDXt16IfpOtLQ+q9XlwIEDcHJygpGRETp37oyYmJh863bv3r1wdBQTTbZt2xZRUVFK63O25uRVj4GBgfj000/x7Nkz6X3i7e2dZ93l1RXt1KlTcHFxgZ6eHpo1a4bLly9L61S1QC5fvhwODg7SelXvcVXHOnbsGJo2bQqFQgEbGxvMmDED6dkGX7dp0wZTv5iKnxf+DDtrO1hbW0vnwxgrIh99BPTvD3zxBZCQoOnSMMZYgXHwU0LExMRg4MCB+OyzzxAeHo7AwED07t0bRISpU6eiX79+0hfimJgYtGjRAgBgbGwMX19fXLt2DStWrMDatWuxbNkyAKLb05dffglnZ2fpef379wcR4aOPPkJsbCz27t2LkJAQNGrUCO3bt8eTJ0/yLOOjR48watQobNiwocCpxD09PREcHIxdu3bhzJkzICJ07dpVKV3uy5cv8e2332L9+vU4deoUnj9/jgEDBkjrBw8ejCpVqiAoKAghISGYMWMGdHV1AQCXL1+Gh4cHevfujUuXLmHr1q04efIkJk6cqFSOH374AfXq1UNISAjmzJmDwYMHY/PmzaBsXTa2bt0KKysrtG7dGoBo5ViwYAEuXryInTt3IjIyUgpw7OzssH37dgDAjRs3EBMTgxV5DABWVQdThk7JVQc//vgjNmzYgOPHjyM6OhpTp07Ns17v3buH3r17o2vXrggLC8PIkSNzBXM55VWPLVq0wPLly2FiYiK9T7IfO2fd5WXatGn48ccfERQUBEtLS3Tv3r3AaZHze49n9+DBA3Tt2hVNmjTBxYsXsXr1aqxbtw4LFy5U2s5vox/0DfRx9MRRLFmyBPPnz8fBgwcLVBbGWAGtWAFkZABeXpouCWOMFRyVQpmZmZScnEyhD0NzrUtJSaFr165RSkpKrnUPnz+kkIchxfZ4+Pxhgc8pJCSEAFBUVJTK9cOHD6cePXq8dT9Lliyhxo0bS3/PnTuXXFxclLY5fPgwmZiY0KtXr5SW16hRg37//XdKSk2ioAdBlJSaJK3LzMykzp0704IFC4iIKDIykgBQaGhonmWJiIggAHTq1ClpWUJCAunr69Nff/1FREQ+Pj4EgM6ePSttEx4eTgDo3LlzRERkbGxMvr6+Ko8xdOhQGj16tNKyEydOkJaWlvQesLe3p549eyptExcXRzo6OnT8+HFpmbu7O02bNi3P8zl//jwBoBcvXhAR0dGjRwkAJSYmKm3XunVrmjx5cp51cPfhXVLoKehPvz+V6uDWrVvSNqtWrSIrK6s8yzJz5kxycnKizMxMadn06dOVyuPj40OmpqbS+vzqMee2WVTVXc7XPqsetmzZIm3z+PFj0tfXp61btxKR6vfhsmXLyN7eXvpb1Xs857FmzZpFtWvXVjrvVatWkZGREWVkZBCRqH/3lu5K7+EmTZrQ9OnTVZ47K5jsn62hD0MpOTlZ6XVg+V+byqx164gAogMHNF0Sxlg5lvX5W5DrUrnqSP97yO+Yd2xesR1vbuu58G7jXaBtXVxc0L59e9SvXx8eHh7o1KkT+vbti4oVK+b7vG3btmH58uW4desWkpKSkJ6eDhMTk3yfExISgqSkJJibmystT0lJwe3bt1U+Z+XKlXj+/DlmzpxZoPMBgPDwcOjo6KBZs2bSMnNzc9SuXRvh4eHSMh0dHbi5uUl/16lTBxUqVEB4eDiaNm0KLy8vjBw5Ehs2bECHDh3wySefoEaNGtK53Lp1C5uy9TsnImRmZiIyMhJOTk4AoLR/ALCwsEDHjh2xadMmtGrVCpGRkThz5gxWr14tbRMaGgpvb2+EhYXhyZMnyMzMBABER0ejbt2671UH9jXsceP6DWmZgYGBdE4AYGNjI3Wxy2u/zZs3V5p7xd3dPd+y5FeP+clZd3nJfnwzM7Ncr3NRCA8Ph7u7u9J5t2zZEklJSbh//z6qVq0KALkSJLytPhlj7+jTT8W4n7FjgcuXAUNDTZeIMcbyVeTBj7e3N+bNUw4wrKysEBsbC0B8MZ03bx7WrFmDxMRENGvWDKtWrYKzs3NRFyWXMY3HoHvt7mo/ThYbI5sCb6utrY2DBw/i9OnTCAgIwMqVKzF79mycO3cO1apVU/mcs2fPYsCAAZg3bx48PDxgamqKLVu24Keffsr3WJmZmbCxsZHGDWWXV8avI0eO4OzZs1AoFErL3dzcMHjwYKxfvz7XcyiPLEBElGvCRFUTKGYt8/b2xqBBg7Bnzx7s27cPc+fOxZYtW9CrVy9kZmZizJgx+Pzzz3M9P+uLMAAYqrggDx48GJMnT8bKlSvh5+cHZ2dnuLi4AACSk5PRqVMndOrUCRs3boSFhQWio6Ph4eFRqIQJBa2DrG582c89r+fmt9/85FeP+VFVdwWVdY5aWlq5ylzQLnHZqXrvZO33bfWZFbwyxoqQTAb8/jtQvz7g7Q388IOmS8QYY/lSS8uPs7MzDh06JP2tra0t/b5kyRIsXboUvr6+cHR0xMKFC9GxY0fcuHFD7RmybIxtYGNc8ICkuMlkMrRs2RItW7bEN998A3t7e/j7+8PLywtyuRwZGRlK2586dQr29vaYPXu2tOzu3btK26h6XqNGjRAbGwsdHR1pwHl2yWnJuZb9/PPPSuMqHj58CA8PD2zdulWpVSO7unXrIj09HefOnZPGbzx+/BgRERFSiwwApKenIzg4GE2bNgUgxtA8ffoUderUkbZxdHSEo6MjvvjiCwwcOBA+Pj7o1asXGjVqhKtXr6JmzZoqy5Cfnj17YsyYMdi/fz/8/PwwdOhQad3169eRkJCA7777DnZ2dgCglGQBEHULIFf9FqQOou9Eo3ad2oUuc/b97ty5U2nZ2bNn3/q8vOpR1fuksM6ePSsFnImJiYiIiJBeQwsLC8TGxioFLzkTJhSkDHXr1sX27duV9nP69GkYGxujcuXK71V+xtg7qlkTmDsXmD0bGDgQaNRI0yVijLE8qSXhgY6ODqytraWHhYUFAHGHdvny5Zg9ezZ69+6NevXqYf369Xj58iX8/PzUUZRS49y5c1i0aBGCg4MRHR2NHTt2ID4+XgoSHBwccOnSJdy4cQMJCQl4/fo1atasiejoaGzZsgW3b9/Gzz//DH9/f6X9Ojg4IDIyEmFhYUhISEBqaio6dOgAd3d39OzZEwcOHEBUVBROnz6Nr7/+OtcX/CxVq1ZFvXr1pIejoyMAoEaNGqhSpYrK59SqVQs9evTAqFGjcPLkSVy8eBFDhgxB5cqV0aNHD2k7XV1dTJo0CefOncOFCxfw6aefonnz5mjatClSUlIwceJEBAYG4u7duzh16hSCgoKkepk+fTrOnDmDCRMmICwsDDdv3sSuXbswadKkt9a5oaEhevTogTlz5iA8PByDBg1SOl+5XI6VK1fizp072LVrV665e+zt7SGTyfDvv/8iPj4eSUlJBaqDkZ4jYWltiY+7ffzWMuZl7NixuH37Nry8vHDjxg34+flJmfxUeVs9Ojg4ICkpCYcPH0ZCQgJevnxZ6DLNnz8fhw8fxpUrV+Dp6YlKlSpJ8/a0adMG8fHxWLJkCW7fvo1Vq1Zh3759Ss9X9R7Pafz48bh37x4mTZqE69ev459//sHcuXPh5eUFLS3O38KYxnz5pWj9GTkSyJZ9kTHGShq1fFu4efMmbG1tUa1aNQwYMAB37twBAERGRiI2NhadOnWStlUoFGjdujVOnz6tjqKUGiYmJjh+/Di6du0KR0dHfP311/jpp5/QpUsXAMCoUaNQu3ZtuLm5wcLCAqdOnUKPHj3wxRdfYOLEiXB1dcXp06dzZePq06cPOnfujLZt28LCwgKbN2+GTCbD3r178eGHH+Kzzz6Do6MjBgwYgKioKFhZWRXpefn4+KBx48b4+OOP4e7uDiLC3r17lbolGRgYYPr06Rg0aBDc3d2hr6+PLVu2ABCtho8fP8awYcPg6OiIfv36oUuXLlLXygYNGuDYsWO4efMmWrVqhYYNG2LOnDmwsSlYC9/gwYNx8eJFtGrVSqmbnIWFBXx9ffH333+jbt26+O6773Kl965cuTLmzZuHGTNmwMrKKleGufzqYPmG5bm6ZhVG1apVsX37duzevRsuLi747bffsGjRojy3f1s9tmjRAmPHjkX//v1hYWGBJUuWFLpM3333HSZPnozGjRsjJiYGu3btklrHnJyc8Ouvv2LVqlVwcXHB+fPnc2WzU/Uez6ly5crYu3cvzp8/DxcXF4wdOxYjRozA119/XejysrJj8eLFaNKkCYyNjWFpaYmePXvixo0bStt4enpKadSzHs2bN1faJjU1FZMmTUKlSpVgaGiI7t274/79+8V5KqWXri6wdi1w8SLwX8ZRxhgriWT0LoMH8rFv3z68fPkSjo6OePToERYuXIjr16/j6tWruHHjBlq2bIkHDx4oTZI5evRo3L17FwcOHFC5z9TUVKSmpiot09HRQcSzCLjauCotf/XqFSIjI1GtWjXo6ekV5amVG8lpyQhPCIdTJScYynnwalHj+lU/ruOil/2z9XridTiaijmmVI3XK26dO3fGgAED0KRJE6Snp2P27Nm4fPkyrl27Jo1Z8/T0xKNHj+Dj4yM9Ty6Xw8zMTPp73Lhx2L17N3x9fWFubo4vv/wST548QUhIiFL37bwQEVJSUlRem8qNL74QY4CuXAGqV9d0aRhj5UTW529BrktFPuYnq6UCAOrXrw93d3fUqFED69evl+6yqRqwnF9BFy9erJREwdjYWEqgwBhjrHzbv3+/0t8+Pj6wtLRESEgIPvzwQ2m5QqGAtbW1yn08e/YM69atk7IhAmKiYzs7Oxw6dAgeHh7qO4GyZMECwN8fGDMGCAgQCREYY6wEUXsneUNDQ9SvXx83b96ULjo5A5e4uLh8u1vNnDkTz549kx7cDYExxlhenj17BgBKrToAEBgYCEtLSzg6OmLUqFFK6c9DQkLw+vVrpW7Ztra2qFevXrnvll0oRkbA6tXAoUPAhg2aLg1jjOWi9uAnNTUV4eHhsLGxQbVq1WBtba0003paWhqOHTumcjb3LAqFAiYmJtJD3VnhGGOMlU5EBC8vL3zwwQdK8z116dIFmzZtwpEjR/DTTz8hKCgI7dq1k7pUx8bGQi6X55pbLftUDTmlpqbi+fPn0uPFixfqO7HSpEsXkfXNywuIj9d0aRhjTEmRBz9Tp07FsWPHEBkZiXPnzqFv3754/vw5hg8fDplMhilTpmDRokXw9/eXskIZGBgoZdpijDHG3sXEiRNx6dIlbN68WWl5//798dFHH6FevXro1q0b9u3bh4iICOzZsyff/eXXLXvx4sUwNTWVHnllviyXli8HiMQYIMYYK0GKPPi5f/8+Bg4ciNq1a6N3796Qy+U4e/Ys7O3tAQBfffUVpkyZgvHjx8PNzQ0PHjxAQEAAt+Ywxhh7L5MmTcKuXbtw9OjRtwYiNjY2sLe3x82bNwEA1tbWSEtLQ2JiotJ2+XXL5i7Z+bC0BH76Cdi0CcgjmRFjjGlCkSc8yEpRnBeZTAZvb294e3sX9aEZY4yVQ0SESZMmwd/fH4GBgahWrdpbn/P48WPcu3dPSovfuHFj6Orq4uDBg+jXrx8AICYmBleuXMkz9btCoYBCoVAqR0pKShGcURkxfDiwcSMwdqzI/mbImRcZY5rHswIyxhgr1SZMmICNGzfCz89PygYaGxsrBSJJSUmYOnUqzpw5g6ioKAQGBqJbt26oVKkSevXqBQAwNTXFiBEj8OWXX+Lw4cMIDQ3FkCFDUL9+fSn7GyskmQz47TcgNhb45htNl4YxxgBw8MMYY6yUW716NZ49e4Y2bdrAxsZGemzduhWAmOT38uXL6NGjBxwdHTF8+HA4OjrizJkzSl2uly1bhp49e6Jfv35o2bIlDAwMsHv37gLN8cPyULMmMG+eGAMUHKzp0jDGWNF3e2OMMcaK09vm6tbX189zEu3s9PT0sHLlSqxcubKoisYAkfVt82Zg1Cjg/HlAV1fTJWKMlWPc8sM0ytfXFxUqVNB0MYpUmzZtMGXKFLUf59SpU6hfvz50dXXRs2dPtR+vrIiKioJMJkNYWBgAMfeLTCbD06dPi/xYMpkMO3fuVHlcdR6LsRJFRwf44w/g0iVg2TJNl4YxVs5x8FNKeHp6vtMXXG9vb7i6uhZpWVJTU+Hq6qrWL3KlQV5fmnfs2IEFCxao/fheXl5wdXVFZGQkfH191X68sqpFixaIiYmBqanpW7ctbKAUExODLl26vGcJleX1P62OYzFWZBo3BqZMAebOBW7d0nRpGGPlGAc/b3PoEFC3rvjJAIh05ba2tpouxjtLS0tT6/7NzMyKJXX77du30a5dO1SpUkVl6xkRIT09Xe3lKO3kcjmsra3znMvlXWS9x6ytrZWygalTcR6LsXcyfz5gbS2yv72lqyJjjKkLBz/5IQJmzQLCw8VPNX9Yb9u2DfXr14e+vj7Mzc3RoUMHJCcnw9vbG+vXr8c///wDmUwGmUyGwMBAAMD06dPh6OgIAwMDVK9eHXPmzMHr168BiC5l8+bNw8WLF6XnZbUQPHv2DKNHj4alpSVMTEzQrl07XLx48a1l3LdvHwICAvDjjz8W6JwSExMxbNgwVKxYEQYGBujSpYs0r0Z2O3fuhKOjI/T09NCxY0fcu3dPWnfx4kW0bdsWxsbGMDExQePGjRGcbeDs6dOn8eGHH0JfXx92dnb4/PPPkZycLK13cHDAwoUL4enpCVNTU4waNQru7u6YMWOGUhni4+Ohq6uLo0ePAgA2btwINzc3GBsbw9raGoMGDUJcXBwA0YWpbdu2AICKFStCJpPB09MTQO5ubznroFe3Xoi+Ey2tz+r6d+DAATg5OcHIyAidO3dGTEyMyjrN6j71+PFjfPbZZ9LrmtUqceDAAbi5uUGhUODEiRMgIixZsgTVq1eHvr4+XFxcsG3bNqV97t27F46OjtDX10fbtm3h6+ur1MKhqrVh+fLlcHBwUFrm4+MDJycn6OnpoU6dOvj1119zlXvHjh1o27YtDAwM4OLigjNnzijt49SpU2jdujUMDAxQsWJFeHh4IDExEX/++SfMzc2RmpqqtH2fPn0wbNgwlXUFAOfPn0fDhg2hp6cHNzc3hIaGKq3P2Zpz9+5ddOvWDRUrVoShoSGcnZ2xd+/et77mEydOhJeXFypVqoSOHTsCUN0V7fr162jRogX09PTg7Ows/S8DqruB7ty5UwrM8vufznmsy5cvo127dtLnyejRo5GUlCStz2pN/vHHH2FjYwNzc3NMmDBB+vxgrMgZGorsb4cPA+vXa7o0jLHyikqhzMxMSk5OptCHobnWpaSk0LVr1yglJeX9D7R/P5EIecRj//7332ceHj58SDo6OrR06VKKjIykS5cu0apVq+jFixf04sUL6tevH3Xu3JliYmIoJiaGUlNTiYhowYIFdOrUKYqMjKRdu3aRlZUVff/990RE9PLlS/ryyy/J2dlZet7Lly8pMzOTWrZsSd26daOgoCCKiIigL7/8kszNzenx48eUlJpEQQ+CKCk1SamMsbGxVLlyZQoKCqLIyEgCQKGhofmeV/fu3cnJyYmOHz9OYWFh5OHhQTVr1qS0tDQiIvLx8SFdXV1yc3Oj06dPU3BwMDVt2pRatGgh7cPZ2ZmGDBlC4eHhFBERQX/99ReFhYUREdGlS5fIyMiIli1bRhEREXTq1Clq2LAheXp6Ss+3t7cnExMT+uGHH+jmzZt08+ZNWrlyJVWtWpUyMzOl7VauXEmVK1emjIwMIiJat24d7d27l27fvk1nzpyh5s2bU5cuXYiIKD09nbZv304A6MaNGxQTE0NPnz4lIqLWrVvT5MmT86yDDh07kJ2DHSUmJSrVQYcOHSgoKIhCQkLIycmJBg0apLJO09PTKSYmhkxMTGj58uXS63r06FECQA0aNKCAgAC6desWJSQk0KxZs6hOnTq0f/9+un37Nvn4+JBCoaDAwEAiIoqOjiaFQkGTJ0+m69ev08aNG8nKyooAUGKiKOPcuXPJxcVFqRzLli0je3t76e81a9aQjY0Nbd++ne7cuUPbt28nMzMz8vX1JSKS3jN16tShf//9l27cuEF9+/Yle3t7ev36NRERhYaGkkKhoHHjxlFYWBhduXKFVq5cSfHx8fTy5UsyNTWlv/76SzpmfHw8yeVyOnLkiFLZst7Dj548IgsLC+rfvz9duXKFdu/eTdWrV1d672bVW9a5fvTRR9SxY0e6dOkS3b59m3bv3k3Hjh1762tuZGRE06ZNo+vXr1N4eDgREQEgf39/pfOvUqUKbdu2ja5du0YjR44kY2NjSkhIkN4LpqamSufi7+9PWR/Vef1P5zxWcnIy2draUu/eveny5ct0+PBhqlatGg0fPlza7/Dhw8nExITGjh1L4eHhtHv3bjIwMKA1a9aofN9l/2wNfRhKycnJSv8/LP9rE8tm8GAiMzOiR480XRLGWBmR9flbkOtS+Ql+kpOJQkIK/ggOJqpbl0hLSwQ+Wlri7+Dgwu0nOblA5xQSEkIAKCoqSuX64cOHU48ePd66nyVLllDjxo2lv1V9aT18+DCZmJjQq1evlJbXqFGDfv/9d5XBT2ZmJnXu3JkWLFhARFSg4CciIoIA0KlTp6RlCQkJpK+vL32B9fHxIQB09uxZaZvw8HACQOfOnSMiImNjY+kLdE5Dhw6l0aNHKy07ceIEaWlpSe8Be3t76tmzp9I2cXFxpKOjQ8ePH5eWubu707Rp0/I8n/PnzxMAevHiBRHl/tKcJXvwo6oO7j68Swo9Bf3p96dSHdy6dUvaZtWqVWRlZZVnWYiITE1NycfHR/o7qzw7d+6UliUlJZGenh6dPn1a6bkjRoyggQMHEhHRzJkzycnJSekDY/r06YUOfuzs7MjPz09pmwULFpC7uzsRvXnP/PHHH9L6q1evEgApWBg4cCC1bNkyz3MeN26cFIASES1fvpyqV6+e68Mu6z3886qfyczMjJKz/R+uXr063+Cnfv365O3trfL4+b3mrq6uubZXFfx899130vrXr19TlSpVpBsWbwt+iFS/FjmPtWbNGqpYsSIlJb35H96zZw9paWlRbGwsEYnPFHt7e0pPT5e2+eSTT6h///4qz52Dn7fj4KeA4uKIzM2J/vsMYoyx91WY4Kf8pLq+fl0MuHxXmZnAtWuAm1vhnhcSAjRq9NbNXFxc0L59e9SvXx8eHh7o1KkT+vbti4oVK+b7vG3btmH58uW4desWkpKSkJ6eDhMTk7cUKQRJSUkwNzdXWp6SkoLbt2+rfM7KlSvx/PlzzJw5863nkiU8PBw6Ojpo1qyZtMzc3By1a9dGeHi4tExHRwdu2eq1Tp06qFChAsLDw9G0aVN4eXlh5MiR2LBhAzp06IBPPvkENWrUkM7l1q1b2LRpk/R8IkJmZiYiIyPh5OQEAEr7BwALCwt07NgRmzZtQqtWrRAZGYkzZ85g9erV0jahoaHw9vZGWFgYnjx5gszMTABAdHQ06tat+151YF/DHjeu35CWGRgYSOcEADY2NlIXu8LKfq7Xrl3Dq1evpG5YWdLS0tCwYUOpjM2bN1ca8+Lu7l6oY8bHx+PevXsYMWIERo0aJS1PT0/PlUigQYMG0u82NjYAgLi4ONSpUwdhYWH45JNP8jzOqFGj0KRJEzx48ACVK1eGj48PPD098xyvc+P6Dbi4uMDAwKDA5/b5559j3LhxCAgIQIcOHdCnTx+lMucl53ssL9mPn/Xez/7/UBTCw8Ph4uICQ0NDaVnLli2RmZmJGzduwMrKCgDg7OysNIeNjY0NLl++XKRlYSwXCwtg6VJg+HBg6FCAE3UwxopR+Ql+6tQRgUhBEAHDhomA6b8vvAAALS2xnz//FDNXF/S4BaCtrY2DBw/i9OnTCAgIwMqVKzF79mycO3cO1apVU/mcs2fPYsCAAZg3bx48PDxgamqKLVu24Keffsr3WJmZmbCxsVEaa5Alr7TTR44cwdmzZ3MNqHZzc8PgwYOxXkX/bcpjjBQR5fqyqurLa9Yyb29vDBo0CHv27MG+ffswd+5cbNmyBb169UJmZibGjBmDzz//PNfzq1atKv2e/UtglsGDB2Py5MlYuXIl/Pz84OzsDBcXFwBAcnIyOnXqhE6dOmHjxo2wsLBAdHQ0PDw8CpUwoaB1oJtj3guZTPbWuUvykv1cswK2PXv2oHLlykrbZb2WBTmOlpZWru2yjw3JOs7atWuVAj0AuSaIzH6uWXWQ9Xx9ff18y9GwYUO4uLjgzz//hIeHBy5fvozdu3fnuf271OHIkSPh4eGBPXv2ICAgAIsXL8ZPP/2ESZMm5fs8Ve+xgsqqh7fVc0Gp+h/LeSxA9fsuM/tnHmPqMnQosHGjSH5w9SpgZKTpEjHGyonyE/wYGBSoBQYAcOCAaOXJKav1JyEB8PAo2vJBfPFo2bIlWrZsiW+++Qb29vbw9/eHl5cX5HI5MjIylLY/deoU7O3tMXv2bGnZ3bt3lbZR9bxGjRohNjYWOjo6uQasA0ByWnKuZT///DMWLlwo/f3w4UN4eHhg69atub7sZqlbty7S09Nx7tw5tGjRAgDw+PFjRERESC0ygGgdCA4ORtOmTQEAN27cwNOnT1EnW+Do6OgIR0dHfPHFFxg4cCB8fHzQq1cvNGrUCFevXkXNmjVVliE/PXv2xJgxY7B//374+flh6NCh0rrr168jISEB3333Hezs7ABAKckCIOoWQK76LUgdRN+JRu06tQtd5sKqW7cuFAoFoqOj0bp16zy3yTko/+zZs0p/W1hYIDY2VulLdfY051ZWVqhcuTLu3LmDwYMHv3N5GzRogMOHD2PevHl5bjNy5EgsW7YMDx48QIcOHaTXR5U6TnWwxW8LUlJSpMAq57mpYmdnh7Fjx2Ls2LGYOXMm1q5di0mTJhXoNX+bs2fP4sMPPwQg3vshISGYOHEiAFHPL168QHJyshRM5Uwnr+p/Oqe6deti/fr1Svs5deoUtLS04Ojo+M5lZ6zIyGQi+UG9esCcOTz/D2Os2HC2t5yIxAexVh5Vo6Ul1hdx5rdz585h0aJFCA4ORnR0NHbs2IH4+HgpSHBwcMClS5dw48YNJCQk4PXr16hZsyaio6OxZcsW3L59Gz///DP8/f2V9uvg4IDIyEiEhYUhISEBqamp6NChA9zd3dGzZ08cOHAAUVFROH36NL7++utcX/CzVK1aFfXq1ZMeWV+gatSogSpVqqh8Tq1atdCjRw+MGjUKJ0+exMWLFzFkyBBUrlwZPXr0kLbT1dXFpEmTcO7cOVy4cAGffvopmjdvjqZNmyIlJQUTJ05EYGAg7t69i1OnTiEoKEiql+nTp+PMmTOYMGECwsLCcPPmTezateutd+kBcae+R48emDNnDsLDwzFo0CCl85XL5Vi5ciXu3LmDXbt25Zq7x97eHjKZDP/++y/i4+OVMmnlVwcjPUfC0toSH3f7+K1lfF/GxsaYOnUqvvjiC6xfvx63b99GaGgoVq1aJbXWjR07Frdv34aXlxdu3LgBPz+/XPMGtWnTBvHx8ViyZAlu376NVatWYd++fUrbeHt7Y/HixVixYgUiIiJw+fJl+Pj4YOnSpQUu78yZMxEUFITx48fj0qVLuH79OlavXo2EhARpm8GDB+PBgwdYu3YtPvvss3z3129AP2hpaWHEiBG4du0a9u7d+9ZMhVOmTMGBAwcQGRmJCxcu4MiRI9L7rSCv+dusWrUK/v7+uH79OiZMmIDExETpPJo1awYDAwPMmjULt27dUvlaqPqfzmnw4MHQ09PD8OHDceXKFRw9ehSTJk3C0KFDpS5vjGlc9erAvHnAzz8DQUGaLg1jrLxQ07gjtVJrtrdXr4isrJSzvOV8WFuL7YrQtWvXyMPDgywsLEihUJCjoyOtXLlSWh8XF0cdO3YkIyMjAkBHjx4lIqJp06aRubk5GRkZUf/+/WnZsmVKA6ZfvXpFffr0oQoVKhAAaYD88+fPadKkSWRra0u6urpkZ2dHgwcPpujo6DyzvWVX0GxvT548oaFDh5KpqSnp6+uTh4cHRURESOuzBnhv376dqlevTnK5nNq1ayclfkhNTaUBAwaQnZ0dyeVysrW1pYkTJyq9vufPn5fqxtDQkBo0aEDffvuttN7e3p6WLVumsnx79uwhAPThhx/mWufn50cODg6kUCjI3d2ddu3aleuc58+fT9bW1iSTyaRMWjmzveWsgw4dO9D2E9ul+i3IIHdV8kp4kHMwfmZmJq1YsYJq165Nurq6ZGFhQR4eHnTs2DFpm927d1PNmjVJoVBQq1at6H//+1+ufa1evZrs7OzI0NCQhg0bRt9++61SwgMiok2bNpGrqyvJ5XKqWLEiffjhh7Rjxw4iUv2eSUxMVHo/ExEFBgZSixYtSKFQUIUKFcjDwyPXOQ0dOpTMzMxyJe3Ikv09fObMGXJxcSG5XE6urq5Sxra8Eh5MnDiRatSoQQqFgiwsLGjo0KFSNjaigr3mWaAi4YGfnx81a9aM5HI5OTk50eHDh5We4+/vTzVr1iQ9PT36+OOPac2aNUrvhbz+p7Mfi0hkQmzbti3p6emRmZkZjRo1SkrWQaQ6icrkyZOpdevWKuuUEx68HSc8eAevXxM1bEjUoAHRf1lAGWOssAqT8EBGVPpmGiMipKSkIOJZBFxtXJXWvXr1CpGRkahWrRr09PTe7QD37gHx8Xmvt7QE8mjtKAuS05IRnhAOp0pOMJS/+zgGplppqN/AwEC0bdsWiYmJeY4D06SOHTvCyckJP//8s8r1paGOS5vsn63XE6/D0VTMC1WUk8OWdvldm1g+QkKApk2Bb78Fcsy/xhhjBZH1+VuQ61L5GfNTGHZ24sEYK1GePHmCgIAAHDlyBL/88oumi8MYKwqNGwNeXqILXJ8+QK1ami4RY6wM4+CHMVZqNGrUCImJifj+++9Ru7b6E0YwxorJvHnA9u3AmDHA4cMFz6jKGGOFxMEPYyyXNm3avHOqbXWKiorSdBEYY+pgYAD8/jvQqRPg4wO8JZkJY4y9K872xhhjjDHN69hRzP8zdSrw6JGmS8MYK6M4+GGMMcZYybB0KaCtDUyerOmSMMbKqDIb/PAs5YwxVnT4M5UVi0qVxISnW7cCe/ZoujSMsTKozI35kcvl0NLSwsOHD2FhYQG5XM6pWAspNS0VSAdSX6VCO1Nb08Upc7h+1Y/ruOgQEdLS0hAfHw8tLS3I5XJNF4mVdYMHAxs3AuPGAVevAsbGmi4RY6wMKXPBj5aWFqpVq4aYmBg8fPhQ08UpldIy0pDwIgG6z3Uh1+YvOkWN61f9uI6LnoGBAapWrQotrTLbYYCVFDIZsHo1UK8e8PXXwIoVmi4RY6wMKXPBDyBaf6pWrYr09HRkZGRoujilztW4qxi7fyy299uO2pacTriocf2qH9dx0dLW1oaOjg63orPiU60aMH8+MG0aMGgQ0KyZpkvEGCsjymTwAwAymQy6urrQ1dXVdFFKHZmuDHeT70KmK4Oenp6mi1PmcP2qH9cxY2XA5MnA5s3AqFFASAjA13PGWBHQaP+FX3/9FdWqVYOenh4aN26MEydOaLI4jDHGyjm+LpUgOjrA2rXAtWvADz8Ahw4BdeuKn6zocf2qF9evegUGFnhTjQU/W7duxZQpUzB79myEhoaiVatW6NKlC6KjozVVJMYYY+UYX5dKoIYNAS8vYN488TM8HJg1CyiBkzCXakSiXrl+1YPrV72IxGdEAWks+Fm6dClGjBiBkSNHwsnJCcuXL4ednR1Wr16tqSIxxhgrx/i6VEJ5ewNmZsDly+LvoCAgIECjRSpzAgJEvQJcv+rA9ateAQHAhQsF3lwjY37S0tIQEhKCGTNmKC3v1KkTTp8+nWv71NRUpKamKi3T0dGBFrRAHD0XOS1owVhuzPWrJly/6sd1rF5a/903I6IykwShsNclgK9NxUZPD7CxAZKTxd9aWsCMGeJubxl5/2kUETBzJmBqCmRmcv0WNa5f9fqvfsnE5L8/335d0kjwk5CQgIyMDFhZWSktt7KyQmxsbK7tFy9ejHnZmrNsbGxw69Yt1DStiZSUFLWXt7xxNHVE7GTxOnD9Fj2uX/XjOlavmqY1NV2EIlfY6xLA16ZidfKkpktQtp06pekSlG1cv+pVyPrVaLa3nJFZXtHazJkz4eXlJf39/Plz1KxZE9evX4cxT35W5F68eIEqVarg/v37XL9qwPWrflzH6lWWWzUKel0C+NpU3Pj/Wr24ftWL61e9CnNd0kjwU6lSJWhra+e6mxYXF5frrhsAKBQKKBQKpWUxMTEAcl+oWNF48eIFAK5fdeH6VT+uY/Upi3Va2OsSwNcmTeD/a/Xi+lUvrl/1KUydaiThgVwuR+PGjXHw4EGl5QcPHkSLFi00USTGGGPlGF+XGGOsfNBYtzcvLy8MHToUbm5ucHd3x5o1axAdHY2xY8dqqkiMMcbKMb4uMcZY2aex4Kd///54/Pgx5s+fj5iYGNSrVw979+6Fvb39W5+rUCgwd+7cXN0NWNHg+lUvrl/14zpm7+J9rksAv+/UjetXvbh+1Yvrt+SQUVkeucoYY4wxxhhj/9HYJKeMMcYYY4wxVpw4+GGMMcYYY4yVCxz8MMYYY4wxxsoFDn4YY4wxxhhj5UKpDH5+/fVXVKtWDXp6emjcuDFOnDih6SKVGcePH0e3bt1ga2sLmUyGnTt3arpIZcbixYvRpEkTGBsbw9LSEj179sSNGzc0XawyY/Xq1WjQoAFMTExgYmICd3d37Nu3T9PFYuUIX5vUg69L6sXXJvXia1PJU+qCn61bt2LKlCmYPXs2QkND0apVK3Tp0gXR0dGaLlqZkJycDBcXF/zyyy+aLkqZc+zYMUyYMAFnz57FwYMHkZ6ejk6dOiE5OVnTRSsTqlSpgu+++w7BwcEIDg5Gu3bt0KNHD1y9elXTRWPlAF+b1IevS+rF1yb14mtTyVPqUl03a9YMjRo1wurVq6VlTk5O6NmzJxYvXqzBkpU9MpkM/v7+6Nmzp6aLUibFx8fD0tISx44dw4cffqjp4pRJZmZm+OGHHzBixAhNF4WVcXxtKh58XVI/vjapH1+bNKtUtfykpaUhJCQEnTp1UlreqVMnnD59WkOlYprw66+/wtfXt1iO9fLlS3h7eyMwMLBI9/vs2TMA4kOwPDh58iRGjhyJxo0bQ6FQQCaTISoqSi3HysjIwJYtW5CcnAx3d3e1HIOxLHxtYln42lT68LWp/ClVwU9CQgIyMjJgZWWltNzKygqxsbEaKhXThOK+wMybN69ILzBEBC8vL3zwwQeoV69eke23JDt8+DAOHTqEqlWrokWLFmo5xuXLl2FkZASFQoGxY8fC398fdevWVcuxGMvC1yaWha9NpQ9fm8qfUhX8ZJHJZEp/E1GuZYyVZBMnTsSlS5ewefPmXOtevnypgRKp35w5cxAVFQV/f3989NFHajlG7dq1ERYWhrNnz2LcuHEYPnw4rl27ppZjMZYTX5tYacfXJr42lQelKvipVKkStLW1c91Ji4uLy3XHjZUsJ0+eRPv27WFsbAwDAwO0aNECe/bsUdrG29tb5RcFX19fpWZoBwcHXL16FceOHYNMJoNMJoODgwMAIDAwEDKZDBs3boSXlxesra2hr6+P1q1bIzQ0VGm/bdq0QZs2bXIdz9PTU9pfVFQULCwsAADz5s2Tjufp6Znnub6tDJMmTcKuXbtw9OhRfP311zAyMsLly5fRqVMnGBsbo3379gCAJ0+eYPz48ahcuTLkcjmqV6+O2bNnIzU1Vel4mZmZWLlyJVxdXaGvr48KFSqgefPm2LVrl9J2W7duhbu7OwwNDWFkZAQPD49cdXLnzh0MGDAAtra2UCgUsLKyQvv27REWFiZtc+TIEbRp0wbm5ubQ19dH1apV0adPn7deGLW01P9xI5fLUbNmTbi5uWHx4sVwcXHBihUr1H5cVr7xtan04msTX5v42lT+lKrgRy6Xo3Hjxjh48KDS8oMHD6qtqZK9v2PHjqFdu3Z49uwZ1q1bh82bN8PY2BjdunXD1q1bC70/f39/VK9eHQ0bNsSZM2dw5swZ+Pv7K20za9Ys3LlzB3/88Qf++OMPPHz4EG3atMGdO3cKdSwbGxvs378fADBixAjpeHPmzHnrc1WVoXnz5vjrr79w5MgRVKtWDYAYL9C9e3e0a9cO//zzD+bNm4dXr16hbdu2+PPPP+Hl5YU9e/ZgyJAhWLJkCXr37q10HE9PT0yePBlNmjTB1q1bsWXLFnTv3l2pz/KiRYswcOBA1K1bF3/99Rc2bNiAFy9eoFWrVkp3n7p27YqQkBAsWbIEBw8exOrVq9GwYUM8ffoUgLjgfvTRR5DL5fjf//6H/fv347vvvoOhoSHS0tIKVbfFgYhyXZAZK2p8bSqd+NrE1yZN4WuThlEps2XLFtLV1aV169bRtWvXaMqUKWRoaEhRUVGaLlqZ8OLFCwoNDaXQ0FACQEuXLqXQ0FC6e/fuO++zefPmZGlpSS9evJCWpaenU7169ahKlSqUmZlJRERz584lVW9JHx8fAkCRkZHSMmdnZ2rdunWubY8ePUoAqFGjRtJ+iYiioqJIV1eXRo4cKS1r3bq1yn0MHz6c7O3tpb/j4+MJAM2dO7dA55tXGYYMGUIA6KOPPqKYmBiKiYmhfv36EQD63//+p7SP3377jQDQX3/9pbT8+++/JwAUEBBARETHjx8nADR79uw8yxMdHU06Ojo0adIkpeUvXrwga2tr6tevHxERJSQkEABavnx5nvvatm0bAaCwsLAC1UVefvjhh1yv6fuaOXMmHT9+nCIjI+nSpUs0a9Ys0tLSkuqKMXXia5P6qOO6RMTXpix8bXqDr03lQ6lq+QGA/v37Y/ny5Zg/fz5cXV1x/Phx7N27F/b29pouWpkQHByMhg0bomHDhgAALy8vNGzYEN9888077S85ORnnzp1D3759YWRkJC3X1tbG0KFDcf/+fbVMpjZo0CClbgr29vZo0aIFjh49WuTHKmgZNm7cCADYs2cPbGxsYGNjg7/++gsA0KdPH6XnHjlyBIaGhujbt6/S8qwuDYcPHwYAaaK0CRMm5FmOAwcOID09HcOGDUN6err00NPTQ+vWraXBsmZmZqhRowZ++OEHLF26FKGhocjMzFTal6urK+RyOUaPHo3169cX+m6lOj169AhDhw5F7dq10b59e5w7dw779+9Hx44dNV00Vg7wtUl9ivq6BPC1ia9NxYevTSVPqQt+AGD8+PGIiopCamoqQkJCOA99EWrTpg2IKNfjXbPXJCYmgohgY2OTa52trS0A4PHjx+9TZJWsra1VLlPHsQpaBiJC//79UaFCBalehw8fDgMDA5iYmCht+/jxY1hbW+fqZ25paQkdHR3pPOLj46Gtra3yfLM8evQIANCkSRPo6uoqPbZu3YqEhAQAYrD24cOH4eHhgSVLlqBRo0awsLDA559/jhcvXgAAatSogUOHDsHS0hITJkxAjRo1UKNGjRLRd3ndunXS50JcXBwOHTrEFxdWrPjapB5FfV0C+NqUHV+b1IuvTSWPjqYLwMq2ihUrQktLCzExMbnWPXz4EIAYLAwAenp6AIDU1FQoFAppu6wPwMJQlV42NjYW5ubm0t96enrSfAbZvcvx3rUMQO4MUQBgbm6Oc+fO5coWFRcXh/T0dKnOLCwskJGRgdjYWJUXceBN/W7btu2td6Ht7e2xbt06AEBERAT++usveHt7Iy0tDb/99hsAoFWrVmjVqhUyMjIQHByMlStXYsqUKbCyssKAAQPy3T9jjJUEfG3KvwwAX5tY2VUqW35Y6WFoaIhmzZphx44dSElJkZZnZmZi48aNqFKlChwdHQFAymJz6dIlpX3s3r07134VCoXS/nLavHkziEj6++7duzh9+rRSBh0HBwdEREQoDTp8/PhxrkkJsy52+R3vXcuQl/bt2yMpKQk7d+5UWv7nn39K6wGgS5cuAKA0q3xOHh4e0NHRwe3bt+Hm5qbyoYqjoyO+/vpr1K9fHxcuXMi1XltbG82aNcOqVasAQOU2jDFWEvG1ia9NrPzilh+mdosXL0bHjh3Rtm1bTJ06FXK5HL/++iuuXLmCzZs3S3ePunbtCjMzM4wYMQLz58+Hjo4OfH19ce/evVz7rF+/PrZs2YKtW7eievXq0NPTQ/369aX1cXFx6NWrF0aNGoVnz55h7ty50NPTw8yZM6Vthg4dit9//x1DhgzBqFGj8PjxYyxZsiRXM7+xsTHs7e3xzz//oH379jAzM0OlSpWkC2JeClKGvAwbNgyrVq3C8OHDERUVhfr16+PkyZNYtGgRunbtig4dOgAQd7qGDh2KhQsX4tGjR/j444+hUCgQGhoKAwMDTJo0CQ4ODpg/fz5mz56NO3fuoHPnzqhYsSIePXqE8+fPw9DQEPPmzcOlS5cwceJEfPLJJ6hVqxbkcjmOHDmCS5cuYcaMGQCA3377DUeOHMFHH32EqlWr4tWrV/jf//4HAFKZ8hIfH49jx44BEBO+AaJfuIWFBSwsLNC6deu31gtjjBUVvjbxtQnga1O5VHy5FVh5duLECWrXrh0ZGhqSvr4+NW/enHbv3p1ru/Pnz1OLFi3I0NCQKleuTHPnzqU//vgjV/aVqKgo6tSpExkbGxMAKQNOVjabDRs20Oeff04WFhakUCioVatWFBwcnOt469evJycnJ9LT06O6devS1q1bc2XUISI6dOgQNWzYkBQKBQGg4cOH53muhSnD8OHDydDQUOV+Hj9+TGPHjiUbGxvS0dEhe3t7mjlzJr169Uppu4yMDFq2bBnVq1eP5HI5mZqakru7e6763blzJ7Vt25ZMTExIoVCQvb099e3blw4dOkRERI8ePSJPT0+qU6cOGRoakpGRETVo0ICWLVtG6enpRER05swZ6tWrF9nb25NCoSBzc3Nq3bo17dq1K8/6yFkvqh6qMhsxxpi68bWJr018bSp/ZETZ2j4ZK+UCAwPRtm1b/P3337my0ZSnMjDGGCs5SsJ1oSSUgbGSgMf8MMYYY4wxxsoFDn4YY4wxxhhj5QJ3e2OMMcYYY4yVC9zywxhjjDHGGCsXOPhhjDHGGGOMlQsc/DDGGGOMMcbKhVI5yWlmZqb0e9YkZIwxxopH9qGiWlp8Dy0LX5sYY0wzCnNdKpXBDwC8evVK00VgjLFyTU9PT9NFKHH42sQYY5pTkOtSqQ1+AHGCfHeNMcaKFxHxl/x88LWJMcaKV2GuS6Uy+Mm6qMhkMr7AMMaYhvDnrzK+NjHGmGYV5LOXO2szxhhjjDHGygUOfhhjjDHGGGPlAgc/jDHGGGOMsXKBgx/GGGOMMcZYucDBD2OMMcYYY6xc4OCHMcYYY4wxVi5w8MMYY4wxxhgrFzj4YYwxxhhjjJULHPwwxhhjjDHGygUOfhhjjDHGGGPlAgc/jDHGGGOMsXKBgx/GGGNlnre3N2QymdLD2tpaWk9E8Pb2hq2tLfT19dGmTRtcvXpVgyVmjDGmDhz8MMYYKxecnZ0RExMjPS5fviytW7JkCZYuXYpffvkFQUFBsLa2RseOHfHixQsNlpgxxlhR4+CHMcZYuaCjowNra2vpYWFhAUC0+ixfvhyzZ89G7969Ua9ePaxfvx4vX76En5+fhkvNGGOsKHHwwxhjrFy4efMmbG1tUa1aNQwYMAB37twBAERGRiI2NhadOnWStlUoFGjdujVOnz6d5/5SU1Px/Plz6cGtRIwxVvJx8MMYY6zMa9asGf78808cOHAAa9euRWxsLFq0aIHHjx8jNjYWAGBlZaX0HCsrK2mdKosXL4apqan0qFKlilrPgTHG2PvT0XQBGGOMMXXr0qWL9Hv9+vXh7u6OGjVqYP369WjevDkAQCaTKT2HiHIty27mzJnw8vJST4EZY4ypBbf8MMYYK3cMDQ1Rv3593Lx5U8r6lrOVJy4uLldrUHYKhQImJibSw9jYWK1lZowx9v44+GGMMVbupKamIjw8HDY2NqhWrRqsra1x8OBBaX1aWhqOHTuGFi1aaLCUjDHGihp3e2OMMVbmTZ06Fd26dUPVqlURFxeHhQsX4vnz5xg+fDhkMhmmTJmCRYsWoVatWqhVqxYWLVoEAwMDDBo0SNNFZ4wxVoQ4+GGMMVbm3b9/HwMHDkRCQgIsLCzQvHlznD17Fvb29gCAr776CikpKRg/fjwSExPRrFkzBAQEcFc2xhgrY2RERJouRGEREVJSUqCvr5/vYFTGGGNFjz+DVeN6YYwxzSjM5y+P+WGMMcYYY4yVCxz8MMYYY4wxxsoFDn4YY4yxohQYqOkSMMYYywMHPyy3Q4eAunXFT8YYY4Uzbx5Q+obTMsZYucDBD1NGBMyaBYSHi598AWeMscK5cAEICNB0KRhjjKnAwQ9TFhAABAWJ34OC+ALOGGOFpa0NzJnDN48YY6wE4uCHvUEETJ8OZKUI5As4Y4wVXkYG3zxijLESioMfBmRmAgcPAq1aARcvvgl2+ALOGGPvbswY8fnKGGOsxODgpzyLiwO+/x6oVQvo1En0U1c1MRSP/WGMscK7exdo3x5IStJ0SRhjjP2Hg5/yhgg4ehQYMACoUgWYOxdo2RL46ScgJUV1kHPhArB3b/GXlTHGSjOZDDh+HGjSBLh2TdOlYYwxBg5+yo/Hj4GlSwEnJ6BdOyAsDFiyBHj4EFi/HtiyBdDK5+0wfLjoBscYY6xgiAAzMxEENWkCbNyo6RIxxli5V+TBz+rVq9GgQQOYmJjAxMQE7u7u2Ldvn7SeiODt7Q1bW1vo6+ujTZs2uHr1alEXgwHiwnvyJDBkCFC5MjBjBtCwoZiALzwcmDJFXJjT0oDo6Pz7pj9+DEydWlwlZ4yxUuvGjrVASIh4hIaKsZN9+gBDh4pxQK9eabqIjDFWbukU9Q6rVKmC7777DjVr1gQArF+/Hj169EBoaCicnZ2xZMkSLF26FL6+vnB0dMTChQvRsWNH3LhxA8bGxkVdnPLp6VNgwwbgt99EV4uaNYEFCwBPT8DCIvf2CoW4OMfHAwDC48MxeMcQbOq9EU4WTmKbf/8VXeRsbYFp04rtVBhjrLR55VwbsHFVXrh+PfDhh8DEieLz9u+/gRo1NFI+xhgrz2RE6h/JbmZmhh9++AGfffYZbG1tMWXKFEyfPh0AkJqaCisrK3z//fcYM2ZMgfZHREhJSYG+vj5kqgbol0dEwLlzwO+/A1u3Aq9fAz17iruM7drl36UthwsxF9B4TWOEjA5BI5tGb1bMng0sWgT4+opucIyxcok/g1XLqpeIZxFwzRn8ZAkLA/r2BRISAB8foFev4iwiY4yVSYW5Lql1zE9GRga2bNmC5ORkuLu7IzIyErGxsejUqZO0jUKhQOvWrXH69Ok895Oamornz59LjxcvXqiz2KXL8+fA6tWiO5u7u+jS9vXXwL174s5ihw6FCnzytXAhMHIkMGKEaAlijDFWOK6uojtc+/ZA797Al1+Km1WMMcaKhVqCn8uXL8PIyAgKhQJjx46Fv78/6tati9jYWACAlZWV0vZWVlbSOlUWL14MU1NT6VGlShV1FLt0CQkBRo8W3dAmTQIcHIB9+4Bbt0Rqamvroj+mTCYCrW7dgH79gHwCVsYYY3kwNQW2bQOWLQN+/hlo0wa4f1/TpWKMsXJBLcFP7dq1ERYWhrNnz2LcuHEYPnw4rmVL85mzOYqI8m2imjlzJp49eyY97pfXi0RSEvDHH4Cbm3js2wd89ZWYS2LnTqBzZ0BbW71l0NEB/PxE5qKPPwY4WQVjjBWeTCaSzhw/LhLONGzIE0ozxlgxUEvwI5fLUbNmTbi5uWHx4sVwcXHBihUrYP1fa0TOVp64uLhcrUHZKRQKKXuciYlJ+UuMcPEiMH68aOUZPVq06uzaBURGAt98IzK5FSd9feCffwA7O8DDQ1y4GWOMFZ67u8gI5+YmbmB98w1PK8BYGfR411bEO1jg8a6tmi5KuVcs8/wQEVJTU1GtWjVYW1vj4MGD0rq0tDQcO3YMLVq0KI6ilB4vX4rEAu7uoo/4zp3A5Mki4Pn3X9H1TKfIk/UVXIUKwP79gFwOdOokBu8yxlgpsHjxYshkMkyZMkVaptFpGCpVAvbsEVk5v/1W3FSKiyueYzPG1I8Iet/Mh8XdBOh9M1/1hPKs2BR58DNr1iycOHECUVFRuHz5MmbPno3AwEAMHjxYutgsWrQI/v7+uHLlCjw9PWFgYIBBgwYVdVFKp2vXRJBTuTLw6aeAiQmwY4fo2rZgAWBvr+kSvmFjAxw4ADx5Anz0keiWxxhjJVhQUBDWrFmDBg0aKC3Pmobhl19+QVBQEKytrdGxY8fiS7CjpSUyah48CFy+LG56nThRPMdmjKlXQAAML4rhH4YXr3EXVw0r8uDn0aNHGDp0KGrXro327dvj3Llz2L9/Pzp27AgA+OqrrzBlyhSMHz8ebm5uePDgAQICAspfV7bsXr0CNm0Sc0A4OwObNwNjxwK3b4vgolcvQFdX06VUrVYtMfbo2jUxiV9amqZLxBhjKiUlJWHw4MFYu3YtKlasKC0nIixfvhyzZ89G7969Ua9ePaxfvx4vX76En59f8RayXTuRDrtWLaBtW2DJkvwnoGaMlVwZGcCNG8CECaD/xraTlkxk5eXWH40p8uBn3bp1iIqKQmpqKuLi4nDo0CEp8AFEsgNvb2/ExMTg1atXOHbsGOrVq1fUxSgdIiJEmtMqVYAhQ0SAs3WryPqzeDFQvbqmS1gwjRuLbnmBgWIiVb5QM8ZKoAkTJuCjjz5Chw4dlJa/6zQMamNjAxw+LCaUnj5dzNmWmFj85WCMFdzLl2/mWxw3DmjRQmR2rFMHuH0bsv+CHVkmAcHB4v/6zBkOgjRAg4NGyqm0NBEo/PYbcPQoYG4uAobRowFHR02X7t21bw9s3Aj07w9YWooUrjz5IWOshNiyZQsuXLiAoKCgXOvym4bh7t27ee4zNTUVqampSst0imospo6OuAnWsiUwbBjQqJGYu83NrWj2zxh7d48eiRba7I+ICHHzV1sbcHISXVd79xZZem/dUk5kIpOJXjO7dgHVqgEDB4pHeW0MKGYc/BSXO3eANWvEjN5xcUCrViJY6NMH0NPTdOmKxiefiMQH48cDVlbAzJmaLhFjjOHevXuYPHkyAgICoJfP521hp2FYvHgx5s2bJ/1tbGyc75x17+Tjj4ELF8Tcai1bihtL48bxzSXGikNGhghccgY6Wf/nxsaAi4uYUH7qVBHwODu/+V534IDo9pYTkZjc+Pvvxf5XrwYWLQLq1wcGDQIGDBDzNzK14OBHnV6/BnbvFk2gAQEiQ9qwYcCYMUDdupounXqMGyfuiMyaJVqARozQdIkYY+VcSEgI4uLi0LhxY2lZRkYGjh8/jl9++QU3/vtyEhsbCxsbG2mbt03DMHPmTHh5eamv4FkcHETyg6lTgQkTxO9r1ogvXoyxovHypUg2kj3IuXRJLAfE9B6ursCoUeKni4totdHKYwQJETBnjlivajiAlpaY7PjcOeCXX0Sg5OcnklvNnCm6zQ0aJG4sW1qq5ZTLKw5+1OHuXdHMuW4dEBMj0lX7+oo3sIGBpkunfnPnigBo9GjRra9nT02XiDFWjrVv3x6XL19WWvbpp5+iTp06mD59OqpXry5Nw9CwYUMAb6Zh+P777/Pcr0KhgEKhkP4mIqSkpKjnJBQKYOVK4IMPgJEjxUTT27ZxNxnG3kVsbO7WnJs333Rbq1tXBDiffPIm0DE3L9wx0tLEPIh5jYPOzATu3RPbKRRiCpNu3UTm3F27RCA0ZYrIANyhg+gW16uXyALM3gsHP0UlPV303/ztN/HTyAgYOlS08uRIqVrmyWTiLkZCgmi6DQgQmewYY0wDjI2NcyXWMTQ0hLm5ubQ8axqGWrVqoVatWli0aFHJnIahf3+gYUOgb1+gaVPRXWb4cE2XirGSKSNDBDU5A51Hj8R6Y2MR3HTqBHz1lfi9bt2iGY6gUABBQUB8PAAgPD4cg3cMwabeG+Fk4SS2sbQU22VnZCRafAYNAh4/Fjc5Nm8W48PHjBFdYQcNArp2LTvDJooZBz/v68ED0crzxx8iS5ubm+iOMGCAeAOXV9raYkxTly5A9+7A8ePlLwhkjJUaX331FVJSUjB+/HgkJiaiWbNmJXcaBkdH4OxZYOJE8YXoxAnRKqSvr+mSMaY5ycmqu61ltcZmdVsbPVr8dHUVXUrz6rZWFOzsxANASgwQehZIaeAE2DQq2PPNzUXAM2aMaCXaulUEQn36iBag3r1FINS2rWYnvi9lZESlL8deVtcCfX39fAejqk1GhmjN+P134N9/ReQ9aJB4c2brU15aXYi5gMZrGiNkdAgaFfQfNC/PnwNt2ojuf6dPi/6xjLFSTeOfwSVUVr1EPIuAq41r8Rz0f/8T44Bq1xbZ4GrVKp7jMqZJqrqtRUSIcTY6Om+6rWU9XFwAMzMNFriIv1tdvy6CoM2bRcuWlZVIijJoENCsWblMiFKY6xKHiYURGysuNGvXAlFR4p/pl1/Em437YKpmYiK6AbZsKZqVT53igXuMMVZUPvtM9Djo21fcfPPxEXeFGSsLMjJEUJMz0ImLE+tNTERw4+Eh5sTK6raWsytZWVOnDjBvHuDtDYSEiPFBW7eKFuCs1NmDBonMcywXDn7eJjMTOHJEjOX55x8xEemAAaKVp2nTchldF5qVlWgpa9lS9FE9epSzFDHGWFFp0EBMmjhypAiCJk8GliwB5HJNl4yxgktKyt1t7fLlN93WqlYVwc3Yscrd1srz9zCZTNz8cHMDfvhBDDHYvBn49VdOnZ0PDn7yEh8v7qCtWQPcvi2i56VLRRKDChU0XbrSp3p1YP9+kfigVy9gz56yf2eGMcaKi4mJuPPbqhXw5Zcife7WreILI2MlCVHe2dZydlsbMKDEdFsr8bS1xdiftm1FC9CBAyIQmj+fU2fnwMFPdkTAsWNiLM+OHSKi/uQTkaa6ZcvyfXehKLi4iPSNHh4iiNy8WfyzMsYYe38yGTBpkuiV0K+fyAqXlXiGMU1IT1futnbxonK3NVNTEdx06SK+oLu6Ak5OfHP0fSkUItlU9+55p84eNEhMRVIOh21w8AMAT54A69eLoOfGDZFJZ/FikT60sHndWf5atxZBT9++wOefizFTHFQyxljRadYMuHBBTKrdtSswe7YYG8DZoJg6JSWJ7Go5u629eiXW29uL4GbcuDfd1uzt+TuAumVPnZ2QAGzfLgKh4cNFwq6s1NldupSb1Nnl95OQSGQf+/134K+/xNiePn3E2J7WrfmfUZ169RL1PHq0GA/0zTeaLhFjjJUt5ubA7t1i7M/s2SLZzObNgLW1pkvGSqpDh8RNyZ9/Fi0DeSESGVxzdlu7detNtzVnZxHcDBr0pttaxYrFcRYsP5Uq5U6d7ecnUmabmIjvwVmps8twz5wyE/wQEdLT05GRkZH/hs+fi+a/v/4STbFVqwI//ii+kGe18qSmqr/AJRi9Jtgb2oNeE15l3bEpakOHipz8y5eL12DAAPUchzFWaNra2tDR0eE01qWdlhYwYwbg7i4+Yxs2BLZsETf4GMuOCGnTp0IeHi5+BoeKm8A5u61lPf6buBMVKojgpmvXN6053G2tdLCzA6ZOFY+s1Nl+fmK8u5WVmFB50KAymdyrTMzzk5aWhpiYGLx8+TLvJ6WmiibZ5GRxZ8LAQDQF6umVuRf1faVlpCHmRQxsjG0g11ZztqAnT4AXLwALC/GaMMZKBAMDA9jY2ECuImMYz/Ojmkbm+Smo2FiR/vb4cWDhQpEWWJ2TO7LS5cABoHPnN3937iy6SF258qbbmoOD8tw5rq7i5iV/BhRIkc7zoy5EInPk5s3iRklMjEhYNXCgeJTg1NmFuS6V+uCHiHDz5k1oa2vDwsICcrn8zUlnZABPnwKJieKfV1dXNLtWqMApQPPxMu0l7jy9g+oVqsNAruaAhAi4f1+0yNnbi4CUMaYxRIS0tDTEx8cjIyMDtWrVglaOL8kc/KhWooMfQNzF9/YGvv0W+OgjMdaVx7Wy27eBDz4AxcZCBoAAyPT13yTNcHUV6dS529p7KRXBT3YZGeJmiZ8fsG2b+D7doMGb1Nn29pouoZLyM8lpYCDS3N2RmZkJOzs7GGS1HCQnizsWjx+LsTwVKojmPRMTvkNRABlaGYAOoNBTQE9eDIPfatQQfYWjo8XEXdwCxJhG6evrQ1dXF3fv3kVaWhr0yskg2DJPR0e0+rRsCQwZAjRqBPz9t+jWwsqX16/FEIDffwcOHgQAZH07kgFibp2BA0V2VlY+ZU+d/csvonXQz09MrjpjhvgcyUqdbWGh6dIWSulu8543T7QcANAiEn1Qr10DwsOBZ8/EwM4GDYCaNUU6RQ58SiYtLREA6emJvsXqGmfEGCuwnK09rAzp0gUIDQVsbIAPPhBzgpS+TiDsXURGArNmiRvCffuKbufVquUe3K6tDcyZw+8LJmSlzt6yRaQp37hRfK+ePFl8jnTpAmzYIN5PpUDpvrpduCBeiCdPRIrqu3dF17aaNcWstra23L2ttNDWBmrVEncmb94Ud6UYY4ypR9WqokvL+PEiw1f//qL7MSt7Xr8G/P3FOJ4aNYBffxV36y9dEt0gIyNFF6fsMjKAoCAgIEAjRWYlmJERMHiwmKw+Jka0Cr18KVLrW1qK7pL+/iX6RnapDn4IEK0/ycmi33L9+uILdIUK3MpTAvn6+qJChQp5b6CrK16/zEzRApSeXmxle1dt2rTBlClTiv24gYGBkMlkePr0KYAC1O07ioqKgkwmQ1hYmMrjqvNYjDE1k8tFxs2//wb27wfc3MQXYlY23L0rWm/s7UUq46dPgXXrgIcPRWtfvXpifV6tvFpa3PrD8lepEjB2LHDsmBi6MH++GMbQu7fofTVihEih/rZMzMWsVAc/UnhTqZJIy1dGUit6enqiZ8+ehX6et7c3XF1di6wc+/fuR7NmzaCvr49KlSqhd+/eRbbvPCkUIgBKSxODMDMz1X/MAsjrS/+OHTuwYMECzRQqm/79+yMiIqJA2xYmULKzs0NMTAzq1av3HqXLTdV7XF3HYoy9Rd++oieFgYGYINXHR9MlYu8qPR345x+R0KJaNWDFCjGVR1gYcPYs8Omnb8bVpqWJL6x5XWczM8VcMGlpxVZ8VorZ2QHTponPkmvXRIvy8eNAx45AlSrAlCnAuXMlIpgu1cEPANFd6unTElGZZcmRPUcw6rNR+PTTT3Hx4kWcOnUKgwYNKp6DGxiIrotJScCdO+/12qap+UPbzMwMxsbGaj1GQejr68PS0rJI95mWlgZtbW1YW1tDpxhmhi/OYzHGcqhZEzhzRiRC+Owz8SU5v+kjWMly7x4wd65IR92zpxgDvXat6Ja0apWYZDQnhUJ0bQsJAUJCEL5/IxqNBsL3b5SWISiozNxYZsXIyUm0AkVEAOfPi+xwf/0FNG8uPmu+/loESJpCpVBmZiYlJydTprExpdjb07V9+yglLk7TxSqUv//+m+rVq0d6enpkZmZG7du3p6SkJJo7dy5B9OiTHkePHiUioq+++opq1apF+vr6VK1aNfr6668pLS2NiIh8fHxyPc/Hx4eIiJ4+fUqjRo0iCwsLMjY2prZt21JYWFieZXua/JQsrS1p1W+rCnVOT548oaFDh1KFChVIX1+fOnfuTBEREdJ6Hx8fMjU1JX9/f6pVqxYpFArq0KEDRUdHS9uEhYVRmzZtyMjIiIyNjalRnToUtGsXUWYmERGdOnWKWrVqRXp6elSlShWaNGkSJSUlSc+3t7enBQsW0PDhw8nExISGDRtGzZs3p+nTpyuVNS4ujnR0dOjIkSNERLRhwwZq3LgxGRkZkZWVFQ0cOJAePXpERESRkZG56nb48OFERNS6dWuaPHlyoetg//79VKdOHTI0NCQPDw96+PBhvnW7Z88eqlWrFunp6VGbNm2k1zsxMVFpv3nWY6NGFBQUREePHs11LnPnzs2z7rLOPTQ0lIhIev6///5LDRo0IIVCQU2bNqVLly5Jx547dy65uLgolX/ZsmVkb28vrVf1Hs95LCKiwMBAatKkCcnlcrK2tqbp06fT69evpfWtW7emSZMm0bRp06hixYpkZWUlnQ97PykpKXTt2jVKSUnJtU76DP7v/5IJWfUS+jBU00V5P76+RPr6RPXrE924oenSsLykpxPt3k308cdEWlpERkZEY8YQXbjwTrsLeRhC8AaFPAwp4oIyIq5fSk8nOnyYaMQIogoViAAiFxei774jiop6790X5rpU+lt+ssTFlZrWn5iYGAwcOBCfffYZwsPDERgYiN69e4OIMHXqVPTr1w+dO3dGTEwMYmJi0KJFCwCAsbExfH19ce3aNaxYsQJr167FsmXLAIhuT19++SWcnZ2l5/Xv3x9EhI8++gixsbHYu3cvQkJC0KhRI7Rv3x5PnjxRWb6w0DDExcZBS0sLDRs2hI2NDbp06YKrV6/me16enp4IDg7Grl27cObMGRARunbtitfZkhe8fPkS3377LdavX49Tp07h+fPnGDBggLR+8ODBqFKlCoKCghASEoIZU6dC98UL4OFDXL58GR4eHujduzcuXbqErVu34uTJk5g4caJSOX744QfUq1cPISEhmDNnDgYPHozNmzeDsr0/tm7dCisrK7T+b6bztLQ0LFiwABcvXsTOnTsRGRkJT09PAKI71vbt2wEAN27cQExMDFasWPFedfDjjz9iw4YNOH78OKKjozF16tQ86/XevXvo3bs3unbtirCwMIwcORIzZszI97XIVY8zZkBXVxctWrTA8uXLYWJiIr1Psh87Z93lZdq0afjxxx8RFBQES0tLdO/eXekc85Pfezy7Bw8eoGvXrmjSpAkuXryI1atXY926dVi4cKHSduvXr4ehoSHOnTuHJUuWYP78+Tj4X+pWxtg7GD5cdE9JSwMaNxZ3bFnJcf++GO/s4AB06ybG8KxeLX7+9puYm4exkkZbG2jXDvjjDzHp8s6dYnqTrPdyq1YiGUd8vPrL8t6hlgaobPkJDSXKyJC2efj8IYU8DCm2x8Pn+d+5zy4kJIQAUFQeke7w4cOpR48eb93PkiVLqHHjxtLfqu64Hz58mExMTOjVq1dKy2vUqEG///67yv36bBCtCnZV7Wjbtm0UHBxMAwcOJHNzc3r8+LHK50RERBAAOnXqlLQsISGB9PX16a+//hL7/a+14uzZs9I24eHhBIDOnTtHRETGxsbk6+urvPOHD4mCgmho3740evRopVUnTpwgLS0t6e60vb099ezZU2mbrFae48ePS8vc3d1p2rRpKs+FiOj8+fMEgF68eEFEb1o8slpasmRv+SlMHdy6dUvaZtWqVWRlZZVnWWbOnElOTk5KdzOmT5+eb8uPynr8T85ts6iqu7xafrZs2SJt8/jxY9LX16etW7cS0dtbfohUv8dzHmvWrFlUu3ZtpfNetWoVGRkZUcZ//+utW7emDz74QGk/TZo0ydXSxwqPW34Kr8y0/GR5/pxowABxh3biRKIc1xFWjNLTifbsIereXbTyGBoSjRpFFBxcZIco9y0Tasb1m4fnz4k2biTq2pVIW1s8unQh+vNPsa6ACnNdKtWd62/sWAuHijVFeuRq1ZQylvwe8jvmHZtXbGWZ23ouvNt4F2hbFxcXtG/fHvXr14eHhwc6deqEvn37ouJbZk/etm0bli9fjlu3biEpKQnp6ekwMTHJ9zkhISFISkqCeY5ZvFNSUnD79m2Vz6FM0UIybfo09OnTBwDg4+ODKlWq4O+//8aYMWNyPSc8PBw6Ojpo1qyZtMzc3By1a9dGeHi4tExHRwdubm7S33Xq1EGFChUQHh6Opk2bwsvLCyNHjsSGDRvQoUMHfPLJJ6hRvTqQno6QkBDcevAAmzZtelNWImRmZiIyMhJOTk4AoLR/ALCwsEDHjh2xadMmtGrVCpGRkThz5gxWr14tbRMaGgpvb2+EhYXhyZMnyPxvAGh0dDTq1q2bTw0Xvg4MDAxQo0YN6W8bGxvExcXlu9/mzZsrzVjs7u6eb1lU1mO2Y+YlZ93lJfvxzczMcp1jUQgPD4e7u7vSebds2RJJSUm4f/8+qlatCgBo0KCB0vPeVp+MsQIyNhaTGrZqBXzxhWgN+vvvEjeze5n28CHwv/+J8TvR0YCrqxjDM2iQmLidsdLO2Fikzh48GEhIALZtE587w4aJ+R+7dRPv9y5dimz8WakOfl451wYq1hE56nPM5zOm8Rh0r9292MpiY2RT4G21tbVx8OBBnD59GgEBAVi5ciVmz56Nc+fOoVq1aiqfc/bsWQwYMADz5s2Dh4cHTE1NsWXLFvz000/5HiszMxM2NjYIDAzMtS6vjF9W1lYAgDpOdaRlCoUC1atXR3R0tMrnUB5dDolI6csrgFx/Z1/m7e2NQYMGYc+ePdi3bx/mzp2LLVu2oFfPnsjU0sKYXr3w+fTp4p8lm6wvwgBgaGiYa/+DBw/G5MmTsXLlSvj5+cHZ2Rku/w0ATU5ORqdOndCpUyds3LgRFhYWiI6OhoeHR6ESJhS0DnR1dXOde17PzW+/+cmzHnv1yvd5ququoLLOUUtLK1eZC9olLjtV752s/b6tPjNLSJZAVnKsXr0aq1evRlRUFADA2dkZ33zzDbp06QJAvLfmzZuHNWvWIDExEc2aNcOqVavg7OyswVKXADKZmAuoaVMxN0zDhmIyw48+0nTJyq7MTDG/zu+/A7t3iy98AwcCY8aIdOQ8lQcrq7JSZ48dK4L9rVtFINSrl5hUtU8fEQi1aZN7Yt7AQJGtsgBKdfCTHxtjG9gYFzwgKW4ymQwtW7ZEy5Yt8c0338De3h7+/v7w8vKCXC5HRo6c6KdOnYK9vT1mz54tLbt7967SNqqe16hRI8TGxkJHRwcODg4FKlvDRg0hV8hxM+ImOrbtCEB8eY2KioJ9Hnf86tati/T0dJw7d04av/H48WNERERILTIAkJ6ejuDgYDRt2hSAGEPz9OlT1KnzJtBydHSEo6MjvvjiCwwcOBA+Pj7o1asXGjVtiquRkahJJGYULsQX9Z49e2LMmDHYv38//Pz8MHToUGnd9evXkZCQgO+++w52dnYAgODgYKXny/8LrnPW77vUQWHVrVsXO3fuVFp29uzZtz4vr3pU9T4prLNnz0oBZ2JiIiIiIqTX0MLCArGxsUrBS865ewpShrp162L79u1K+zl9+jSMjY1RuXLl9yo/K3+qVKmC7777DjVr1gQgxor16NEDoaGhcHZ2xpIlS7B06VL4+vrC0dERCxcuRMeOHXHjxo0SkdFR49zcRArb4cOBjz8GZswAFiwQPS9Y0YiNfdPKExUFNGgA/PyzuCNuaqrp0jFWvKpWFamzp00DwsOBzZtFIPS//4k5hPr3F4FQkyZi+3nzgL17C7TrspPwoBQ5d+4cFi1ahODgYERHR2PHjh2Ij4+XviA7ODjg0qVLuHHjBhISEvD69WvUrFkT0dHR2LJlC27fvo2ff/4Z/v7+Svt1cHBAZGQkwsLCkJCQgNTUVHTo0AHu7u7o2bMnDhw4gKioKJw+fRpff/11ri/4WUxMTNB7SG98u+BbBAQE4MaNGxg3bhwA4JNPPlH5nFq1aqFHjx4YNWoUTp48iYsXL2LIkCGoXLkyevToIW2nq6uLSZMm4dy5c7hw4QI+/fRTNG/eHE2bNkVKSgomTpyIwMBA3L17F6dOnUJQUJBUL9NnzMCZixcx4ccfEfbvv7h55Qp27dqFSZMmvbXODQ0N0aNHD8yZMwfh4eFKaburVq0KuVyOlStX4s6dO9i1a1euuXvs7e0hk8nw77//Ij4+HklJSe9cB4U1duxY3L59G15eXrhx4wb8/Pzg6+ub5/Zvq0cHBwckJSXh8OHDSEhIwMt3SGc7f/58HD58GFeuXIGnpycqVaokzdvTpk0bxMfHY8mSJbh9+zZWrVqFffv2KT1f1Xs8p/Hjx+PevXuYNGkSrl+/jn/++Qdz586Fl5cXtPKalI+xPHTr1g1du3aVbgp8++23MDIywtmzZ0FEWL58OWbPno3evXujXr16WL9+PV6+fAk/Pz9NF73kqFhRDFJesgT44QegQweRSpm9u6xWnj59xDwpCxeKu9pnzoi5ecaP58CHsazU2Tdviu63AwaIVqFmzcTckIMHi5szBVW4UUklQ/ZBpfkNyi2prl27Rh4eHmRhYUEKhYIcHR1p5cqV0vq4uDjq2LEjGRkZKaW6njZtGpmbm5ORkRH179+fli1bpjRw/dWrV9SnTx+qUKGCUqrr58+f06RJk8jW1pZ0dXXJzs6OBg8erJRiOruk1CQ6E3WGPp/yOVlaWpKxsTF16NCBrly5ku95ZaV5NjU1JX19ffLw8FCZ5nn79u1UvXp1ksvl1K5dOynxQ2pqKg0YMIDs7OxILpeTra0tTZw4Uem1PX/+PHXs0IGMDAzIUF+fGtSvT99++6203t7enpYtW6ayfHv27CEA9OGHH+Za5+fnRw4ODqRQKMjd3Z127dqVK+3y/PnzydrammQy2VtTXb+tDrLz9/ent/0r7t69m2rWrEkKhYJatWpF//vf//JMeFCQehw7diyZm5vnSnWds+7ySniwe/ducnZ2JrlcTk2aNMmVOn316tVkZ2dHhoaGNGzYMPr222+VEh6oeo+/a6rr7PVPRNSjRw/p9WHvriwnPEhPT6fNmzeTXC6nq1ev0u3btwkAXciRIrh79+40bNiwAu+3zCU8yM/x40Q2NkSWliJ9LSuc2FiixYuJqlcXCSXq1SNauZIoR1Kd4sQD8tWL67eIZaXO/uwzIm1tyjQ2LvB1SUZUSvJDZ0NESElJQcSzCNSpWAeRkZGoVq0a9PT0NF20MiE5LRnhCeFwquQEQ/m7jwFRq7Q04Pp10eezdm3uesFYEXv16lWen6109ChSmjWDvr6+yjF8JdXly5fh7u6OV69ewcjICH5+fujatStOnz6Nli1b4sGDB7C1tZW2Hz16NO7evYsDBw6o3F9qaipSU1OVluno6CDiWQRcbVzVeSolQ1yc6HZy9KjocjJrllLiIZZDZqaoq99/Fy1o2tpAv35iLI+7u8bH8lyIuYDGaxojZHQIGtk00mhZyiKuXzU5cADo3BlkbIyU2NgCXZeK/FNq8eLFaNKkCYyNjWFpaYmePXvixo0bStsQEby9vWFrawt9fX20adPmrXPIMKZELhdNna9fA7duiYsKY0z9iMQX3VKodu3aCAsLw9mzZzFu3DgMHz4c17LNMq4qwUZ+F9HFixfD1NRUelSpUkVtZS+RLC3FF4/Zs4FvvhFJEBISNF2qkicuTnQVrF1bdBW8ckV0G3zwAFi/HmjRQuOBD2OlEhEwZ07u5AdvUeTBz7FjxzBhwgScPXsWBw8eRHp6Ojp16oTk5GRpm6yBpb/88guCgoJgbW2Njh074sWLF0VdHFaW6esDNWsCL18Ct2+XmkluGSvVAgIK17e6BJHL5ahZsybc3NywePFiuLi4YMWKFbC2tgYAxMbGKm0fFxcHKyurPPc3c+ZMPHv2THrcv39freUvkbS1RV/8ffuA4GCgUSMxXqW8IxKtPAMGAFWqiOCweXPgxAng6lVg8mTAzEzTpWSsdAsIAIKCgEImcSry4Gf//v3w9PSUUgn7+PggOjoaISEhAMADS1nRMjICatQAnj8H7t7lAIgxdSICJk5EWfkvIyKkpqaiWrVqsLa2xsGDB6V1aWlpOHbsmJS5URWFQgETExPpUa6zwnl4AKGhYtD+hx8Cy5eXz8/jhATgp5/EzPXt2omkBd9/L1p5NmwAPviAW3kYKwpZrT7v0NVW7Z1znz17BkBMhAgAkZGRiI2NRadOnaRtFAoFWrdujdOnT6u7OKwsMjUFHBzERefBA02XhrGy6fVrMc/LrVsojV/dZs2ahRMnTiAqKgqXL1/G7NmzERgYiMGDB0Mmk2HKlClYtGgR/P39pSyGBgYGSpkh2VtUqSLm2vj8czEp6iefAP99ByjTiIBjx8T4p8qVxdinxo1FXYSHi7rIMdE4Y+w9paWJuYDeYdiDWkeJExG8vLzwwQcfoF69egDedCvI2ZXAysoq17w1WfIaVMqYxNxcfDm7fx/Q1QXy6arCGCuk+/fFwOwzZ0rtXetHjx5h6NChiImJgampKRo0aID9+/ejY0cxl9lXX32FlJQUjB8/XprkNCAgoHy35rwLXV3R8vHBB4Cnp5gf6O+/AVdXTZes6D1+DPz5J7BmjUjA4+gILFok5kKqVEnTpWOsbFMoRJe3+HgAwI0nN1H1LU/JotYIYuLEibh06RJOnjyZa11hBpYuXrwY87INsDU2Ns7VN5sxWFsD6enAvXsi+xvfaWPs/Z04IWaXz/p8LqVdmdatW5fveplMBm9vb3h7exdPgcq6Xr3EJJ2ffCLGuvzyCzBiRKkNniVEwMmTImPbtm3irnPv3sCvv4r5eUr7+TFWmtjZiQeAVzEF78ymtm5vkyZNwq5du3D06FGlDDjvMrCUB5WyAqtcWQQ9UVHlo7sFY+pCBDx9CowaJWbQrlKF0xizwqlRAzh9WrQAjRolfmZLflSqJCYCK1YA9eqJMU1nz4pED/fvA1u2AG3bcuDDWClR5FcyIsLEiROxY8cOHDlyBNWqVVNa/y4DS3lQKSswmUyM/zExERngkpI0XSLGSp+0tDc3ELy8gB07gJgYTinPCk9PD/jtNzHYf9s2MSP79euaLlXBEIngbfhwwNYWmDoVcHYGDh0CIiKAr74S6b4ZY6VKkXd7mzBhAvz8/PDPP/8odU8zNTWVJh7KGlhaq1Yt1KpVC4sWLeKBpazoyGRA9erAzZtiDqDatUVabMbY2z1/Dty5I363shJdefT03rlvNWMAgCFDRBrsvn3FOKC1a0V3ypLo6VMRrK1ZI+bkqV4dmDsX+PRTHk/KWBlQ5C0/q1evxrNnz9CmTRvY2NhIj61bt0rbfPXVV5gyZQrGjx8PNzc3PHjwgAeWlgO+vr6oUKFC8RxMW1vMAaSrK4KgtDS1HKZNmzaYMmWKWvad3alTp1C/fn3o6uqiZ8+eaj9eWREVFQWZTIawsDAAQGBgIGQyGZ4+fVrkx5LJZNi5c6fK46rzWEWGCHj4UNzRNjAQXZb09N6st7MTX14bNcIr59pFe2xWPtStC5w/D/TsKTKjjR8P5EhmpDFEoivbp5+KVh4vL3HjLCBAXENmzODAh7EyQi3d3lQ9PD09pW2yBpbGxMTg1atXOHbsmJQNjgGenp7v9AXX29sbrkWYUWf/3v1o1qwZ9PX1UalSJfTu3bvI9l0sdHSAWrXE7xERIhnCO8rrS/OOHTuwYMGC9yhkwXh5ecHV1RWRkZHw9fVV+/HKqhYtWkjZvt6msIFSTEwMunTp8p4lVJbX/3SRH+v1a/EF7+FD8cWvVi1x44CxomZkJFpVfvsNWLcOaNkSiIzUXHmePQNWrRLZ6NzdRXrqr78WKXS3bQM6duSxboyVMfwfnd2hQ+LO1KFDmi6Jxh3ZcwSjPhuFTz/9FBcvXsSpU6dKZbfENECkH01PF1/uCjkL8NuYmZkVS4vl7du30a5dO1SpUkVl6xkRIf09grvyQi6Xw9raOs/Mku8i7b9WRWtraygUiiLbb36K9FgvXgDXrgEvX4r/FVtbHrjN1EsmA8aMEanTnzwRLYq7dhXf8YlEC9SIEeL9Pnmy6Nq2b58YKzprFmBjU3zlYYwVKw5+shCJD7zwcPFTzelct23bhvr160NfXx/m5ubo0KEDkpOT4e3tjfXr1+Off/6BTCaDTCZDYGAgAGD69OlwdHSEgYEBqlevjjlz5uD169cARJeyefPm4eLFi9LzsloInj17htGjR8PS0hImJiZo164dLl68mGfZ0tPT8dM3P2Hh4oUYO3YsHB0dUbt2bfTt2zffc0pMTMSwYcNQsWJFGBgYoEuXLrh582au7Xbu3AlHR0fo6emhY8eOuHfvnrTu4sWLaNu2LYyNjWFiYoLGjRsjODhYWn/69Gl8+OGH0NfXh52dHT7//HMkZ8se5ODggIULF8LT0xOmpqYYNWoU3Nu2xYwNG4CUFDGWITMT8fHx0NXVxdGjRwEAGzduhJubG4yNjWFtbY1BgwYhLi4OgOjC1LZtWwBAxYoVIZPJpJbMnN3e3lYHWV3/Dhw4ACcnJxgZGaFz586IiYlRWadZ3aceP36Mzz77THpds1olDhw4ADc3NygUCpw4cQJEhCVLlqB69erQ19eHi4sLtm3bprTPvXv3wtHREfr6+mjbti18fX2VWjhUtTYsX74cDg4OSst8fHzg5OQEPT091KlTB7/++muucu/YsQNt27aFgYEBXFxccObMGaV9nDp1Cq1bt4aBgQEqVqwIDw8PJCYm4s8//4S5uXmu+b369OmDYcOGqawrADh//jwaNmwIPT09uLm5ITQ0VGl9ztacu3fvolu3bqhYsSIMDQ3h7OyMvXv3vvU1nzhxIry8vFCpUiVpnhhVXdGuX7+OFi1aQE9PD87OztL/MqC6G+jOnTulwCy//+mcx7p8+TLatWsnfZ6MHj0aSdmSfWS1Jv/444+wsbGBubk5Jowfj9fR0cCNG6J7W926IlEIY8WlUSPgwgUxrqxHD5FA4L9rmlo8fy5anBo1EokXDh0S3dmiowF/f6BzZ27lYaw8oFIoMzOTkpOTKfRhKKWkpNC1a9coJSXl/Xa6fz+RCHnEY//+oimsCg8fPiQdHR1aunQpRUZG0qVLl2jVqlX04sULevHiBfXr1486d+5MMTExFBMTQ6mpqUREtGDBAjp16hRFRkbSrl27yMrKir7//nsiInr58iV9+eWX5OzsLD3v5cuXlJmZSS1btqRu3bpRUFAQRURE0Jdffknm5ub0+PFjleULPBlIAGj1mtXk6upK1tbW1LlzZ7py5Uq+59W9e3dycnKi48ePU1hYGHl4eFDNmjUpLS2NiIh8fHxIV1eX3Nzc6PTp0xQcHExNmzalFi1aSPtwdnamIUOGUHh4OEVERNBff/1FYWFhRER06dIlMjIyomXLllFERASdOnWKGjZsSJ6entLz7e3tycTEhH744Qe6efMm3bx5k1auXElVq1alzMREouBgojv/b+/O46Kq9/+Bv4Zlhh0EkUURUULAFMUVva6xZPeWpJULoZYbJahRXlMzsVLLW0qSedVuaCnX+qkY5gZXRRMUAcF1AEEQU/gCigvIzvv3x4kjA8OmjCPwfj4ePHTO+j6fOTPnfOZ8Pu/PdQrZuJG6du1KVVVVRET0n//8hw4dOkQZGRl05swZGjZsGI0fP56IiCorK2nv3r0EgFJTUyknJ4fu3btHRESjR4+mhQsXtrgM3N3dKT4+nhITE8nJyYmmTZumtEwrKyspJyeHjIyMKDg4WHxfT5w4QQCoX79+FBkZSenp6VRQUEDLli0jR0dHOnLkCGVkZFBoaCjJZDKKjo4mIqLs7GySyWS0cOFCSklJoZ07d5KFhQUBoMLCQiIiWrlyJbm4uCjEsWHDBrK1tRVfb926laysrGjv3r10/fp12rt3L5mamtL27duJiCgzM5MAkKOjI/3++++UmppKb7zxBtna2lJFRQURESUlJZFMJqP33nuPkpOT6fLlyxQSEkL5+fn06NEjMjY2pl9//VXcZ35+PkmlUjp+/LjSsioqKiJzc3OaPHkyXb58mQ4cOEA9e/YkAJSUlEREJJZbzbH+/e9/Jw8PD7p48SJlZGTQgQMH6OTJk02+5wYGBrR48WJKSUkhuVxOREQAKDw8XOH4u3XrRnv27KGrV6/S7NmzydDQkAoKCsRzwdjYWOEYwsPDqeZruaHPdN19FRcXk7W1NU2cOJEuXbpEx44dIzs7O5oxY4a43RkzZpCRkRH5+fmRXC6nA+HhpKerS1uXLSP680+i6up65dnYd2vS7SQqLi6maiXrdWS1r02sBaqrib7+mkhTk+hvfxPOydYUH080ezaRvj6RhgbRa68RHTxIVFnZuvtp4xJvJxKCQIm3E9UdSrvE5ataLbkutc/KT3ExUWJi8/8SEoicnYUvRUD419lZmN6S7RQXNyv+xMREAkBZWVlK58+YMYMmTJjQ5HbWrVtHAwcOFF8ru2k9duwYGRkZUWlpqcL0Xr160ZYtW5RuN/TnUAJANt1taM+ePZSQkEBTp05ttMKUlpZGACgmJkacVlBQQLq6uuINbGiosN2zZ8+Ky8jlcgJAcXFxRERkaGgo3kDX5evrS3PnzlWY9scff5CGhob4/tva2pK3t7fCMnl5eaSlpUWnTp0iKiggio8nt4EDafHixUr3Q0R07tw5AkAPHz4kovo3zTVqV35aUgbp6eniMps2bSILC4sGYyEiMjY2ptDQUPF1TTz79+8XpxUVFZGOjg7FxsYqrDtr1iyaOnUqEREtXbqUnJycFL4clixZ0uLKj42NDYWFhSks8/nnn5ObmxsRPb75/+GHH8T5V65cIQBiZWHq1Kk0YsSIBo/5vffeEyugRETBwcHUs2fPBr/YtmzZQqamplRc63O4efPmRis/ffv2paCgIKXba+w979+/f73llVV+vvzyS3F+RUUFdevWTfzBoqnKD5Hy96LuvrZu3UqdOnWioqIicf7BgwdJQ0ODcnNziUj4TrG1taXKykqihw+JLlygNz08aPLEiUqPnYgrP0+CKz9P6fRpoq5diczNiaKinm5bDx4QbdlC5OoqXNe7dSMKCiK6ebN1Ym2H+OZctbh8Vasl16VWT3X9XEhJAQYOfPL1q6uFNvCDBrVsvcRE4XF6E1xcXPDSSy+hb9++8PLygqenJ9544w106tSp0fX27NmD4OBgpKeno6ioCJWVlTBqoplKYmIiioqKYGZmpjC9pKQEGRkZStehaqHJ3+IlizFp0iQAQhOnbt264f/9v/+HefPm1VtHLpdDS0sLQ4cOFaeZmZmhd+/ekMvl4jQtLS0MqlWujo6OMDExgVwux5AhQxAYGIjZs2fj559/hru7O95880306tVLPJb09HTs2rXrcaxEqK6uRmZmJpycnABAYfsAYG5uDg8PD+zatQsj//1vZGZk4ExiIjZ/9ZW4TFJSEoKCgpCcnIy7d++i+q/xTLKzs+Hs7NxQ8T5RGejp6YnHBABWVlZiE7uWqn2sV69eRWlpqdgMq0Z5eTkGDBggxjhs2DCFPi9ubm4t2md+fj5u3ryJWbNmYc6cOeL0ysrKeokE+vXrJ/7f6q829Hl5eXB0dERycjLefPPNBvczZ84cDB48GLdu3ULXrl0RGhqKmTNnNthfRy6Xw8XFBXp6es0+tgULFuC9995DZGQk3N3dMWnSJIWYG1L3HGtI7f3XnPu1z4XWUHPc+vr64rQRI0aguroaqamp4uDRffr0gWZ+PnDrFqCvDysHB1y6erVVY2HsqYwYASQlCWmxPT2F9NKffCJk72yu8+eFFNW7dgn92F55BQgKAsaPF5LgMMY6vPb5TeDoKFREmoMImD5dqDDVHsBPQ0PYzk8/Nb/zr6NjsxbT1NREVFQUYmNjERkZiZCQECxfvhxxcXH1BoWtcfbsWUyZMgWrVq2Cl5cXjI2NsXv3bnzzzTeN7qu6uhpWVlYKfQ1qNJR22sJSuFlydHp8PDKZDD179kR2drbSdaiBPlJEVO9mVdnNa820oKAgTJs2DQcPHsThw4excuVK7N69G6+//jqqq6sxb948LFiwoN763bs/HnWk9k1gDR8fHyxcuBAhISEIi4pCn9694WJsDBQUoFhXF56envD09MTOnTthbm6O7OxseHl5iZ3Zm6O5ZaBdJ4uWRCJpcN2m1D7WmgrbwYMH0bVrV4XlajrHN2c/Ghoa9ZarqNUOv2Y/27ZtU6joAcK5XVvtY60pg5r1dZsYe2nAgAFwcXHBTz/9BC8vL1y6dAkHDhxocPknKcPZs2fDy8sLBw8eRGRkJNauXYtvvvkGAQEBja6n7BxrrppyaKqcm0vZZ6zuvlBdDe3ycmE0ektLwNoaEi0t8b1g7Llhbg4cOgSsXi1UWmJjgZ07hen/+x+wYAGwcSPg7v54naIiYPduYMsWICHhcarqWbOA7jwiFWNMUfus/OjpNesJDADg6FHhKU9dNU9/CgoAL6/WjQ/CTcmIESMwYsQIfPrpp7C1tUV4eDgCAwMhlUpRVScrWUxMDGxtbbF8+XJx2o0bNxSWUbaeq6srcnNzoaWlVa/DekMGuA6AVCbFtbRr8BgrPEWoqKhAVlYWbG1tla7j7OyMyspKxMXFYfjw4QCAO3fuIC0tTXwiAwhPBxISEjBkyBAAQGpqKu7duwfHWhVHBwcHODg44IMPPsDUqVMRGhqK119/Ha6urrhy5Qrs7e2bdRy1eXt7Y968eThy5AjCwsLgO2MG0LkzkJWFlKIiFBQU4Msvv4SNjQ0AKCRZAISyBVCvfJ+kDFTF2dkZMpkM2dnZGD16dIPL1O2Uf/bsWYXX5ubmyM3NVbiprj1ejYWFBbp27Yrr16/Dx8fniePt168fjh07hlWrVjW4zOzZs7FhwwbcunUL7u7u4vujjLOzM37++WeUlJSIFau6x6aMjY0N/Pz84Ofnh6VLl2Lbtm0ICAho1nvelLNnz2LUqFEAhHM/MTER/v7+AIRyfvjwIYqLi8XKVN1xgZR9putydnbGjh07FLYTExMDDQ0NODg4AMXFQjrfykph7KtnNdYWY09KUxP49FMh9bSPDzBggFC5qZ2U6KWXgIsXhQrPzp1CBejll4H9+4G//52f8jDGGtSx05oQAStWNJzdRUNDmN/Kmd/i4uKwZs0aJCQkIDs7G/v27UN+fr54g9yjRw9cvHgRqampKCgoQEVFBezt7ZGdnY3du3cjIyMDGzduRHh4uMJ2e/TogczMTCQnJ6OgoABlZWVwd3eHm5sbvL29cfToUWRlZSE2NhaffPJJvRv8GkZGRpj49kSs/nw1IiMjkZqaivfeew8AGmym9MILL2DChAmYM2cOTp8+jQsXLuDtt99G165dMWHCBHE5bW1tBAQEIC4uDufPn8c777yDYcOGYciQISgpKYG/vz+io6Nx48YNxMTEID4+XiyXJUuW4MyZM5g/fz6Sk5Nx7do1RERENPkrPSD8Uj9hwgSsWLECcrkc03x8AFtbwMQE3SsrIZVKERISguvXryMiIqLe2D22traQSCT4/fffkZ+fr5BJq6VloCqGhob46KOP8MEHH2DHjh3IyMhAUlISNm3ahB07dgAA/Pz8kJGRgcDAQKSmpiIsLKzeuEFjxoxBfn4+1q1bh4yMDGzatAmHDx9WWCYoKAhr167Ft99+i7S0NFy6dAmhoaFYv359s+NdunQp4uPj8f777+PixYtISUnB5s2bUVBQIC7j4+ODW7duYdu2bXj33Xcb3d60adOgoaGBWbNm4erVqzh06BC+/vrrRtdZtGgRjh49iszMTJw/fx7Hjx8Xz7fmvOdN2bRpE8LDw5GSkoL58+ejsLBQPI6hQ4dCT08Py5YtQ3p6utL3Qtlnui4fHx/o6OhgxowZuHz5Mk6cOIGAgAD4+vrCAhCeamtoAIaGXPFhbYuHh9AMzs4OGD0aiI8XpsfHCy0t+vcXKjsLFwpjBR06JGSN44oPY6wxKup3pFKtlu2ttJTIwkIxy1vdP0tLYblWdPXqVfLy8iJzc3OSyWTk4OBAISEh4vy8vDzy8PAgAwMDAkAnTpwgIqLFixeTmZkZGRgY0OTJk2nDhg0KHaZLS0tp0qRJZGJiQgDEDvIPHjyggIAAsra2Jm1tbbKxsSEfHx/Kzs5WGl9RWRGdyTpDCxYtoC5dupChoSG5u7s3me3t7t275OvrS8bGxqSrq0teXl6UlpYmzq/p4L13717q2bMnSaVSGjdunJj4oaysjKZMmUI2NjYklUrJ2tqa/P39Fd7bc+fOiWWjr69P/fr1o9WrV4vzbW1tacOGDUrjO3jwIAGgUaNGPZ5YVUUkl1PYmjXUw9aWZDIZubm5UUREhEJHeSKizz77jCwtLUkikYiZtOpme2tuGdRWt5O7Mg0lPKjbGb+6upq+/fZb6t27N2lra5O5uTl5eXnRyZMnxWUOHDhA9vb2JJPJaOTIkfTjjz/W29bmzZvJxsaG9PX1afr06bR69WqFhAdERLt27aL+/fuTVCqlTp060ahRo2jfvn1E9LjDf+3yKywsVDifiYiio6Np+PDhJJPJyMTEhLy8vOodk6+vL5mamtZL2qHMmTNnyMXFhaRSKfXv31/M2NZQwgN/f3/q1asXyWQyMjc3J19fXzEbG1Hz3vMaUJLwICwsjIYOHUpSqZScnJzo2LFjCuuEh4eTvb096ejo0D/+8Q/aunWrwrnQ0Ge69r6IhEyIY8eOJR0dHTI1NaU5s2bRwwsXhCxX2dk0Y/r0eklUFi5cSKNHj26wLDnhQctxwgMVKSsTrsW1r81GRkR79xL9lUmTPT3ukK9aXL6q1ZLrkoRIxQPaqAARoaSkBGn30+DYyRGZmZmws7ODjo5Oyzd28yaQn9/w/C5dgG7dnjzYNqi4vBjyAjmcOjtBX/rkfRvajMpKYayTykrh18RnNFDl8yI6Ohpjx45FYWFhg/3A1MnDwwNOTk7YuHGjukNpG4qLhfGsKiuBHj2AJhKpNKS0tLTB79bknGQ4GAtjRbXmgLFtXe1rU3+r/uoOp/04elRo0lbXkSMqaZbeUZ3POY+BWwcicW4iXK2a2XWANRuXr2q15LrEz4ZtbIQ/1nFpaQEvvCBUgK5dA3r3BuokJWDP3t27dxEZGYnjx4/ju+++U3c4zz8i4YecmzcBXV3AwaHDVeRZO1TTPF1TE6jd/01TU5ju6dn8pESMMQau/DAmkEqFClBKCpCeLtw4tiS9Kmt1rq6uKCwsxFdffYXevXurO5znW1UVcOMGcPeukBXLxoZHqmftQ2Tk474+tVVVCdMjI/npD2OsRbjyw1gNHZ3HT4AyMoTMWB3gBnLMmDFPnGpblbKystQdQtvw6JHQzK28HOjZEzA1VXdEjLWO2kmJlKVlr0lKxE9/GGMt0P7v7BhrCX19odLz8CGQldXqmf4YazVEQip+uVy48XN25ooPa1/Ky4HsbOUVH0CYfvOmsBxjjDUTV34Yq8vISEiteveucGHlChB73lRVCZXzrCzAzAxwchKeXLIGrV27FoMHD4ahoSG6dOkCb29vpKamKixDRAgKCoK1tTV0dXUxZswYXLlyRU0RM8hkQtO2xEQgMRHyIzvhOheQH9kpTkN8PPdtY4y1SLup/DyPzXZYG2ZqKowMnpcH5OaqOxrGHispEZ72FBYKlfQePVTSPLO9faeePHkS8+fPx9mzZxEVFYXKykp4enqiuLhYXGbdunVYv349vvvuO8THx8PS0hIeHh54+PChGiPv4GxshEHLXV1R0s8JSdZAST8ncVpHy8bKGHt6bb7Pj/ZfWbkePXokjurOWKvo0kVIF3zrlpARztxc3RGxju7OHSGxgVQqPO1R4Xfeo0ePADz+jm3rjhw5ovA6NDQUXbp0QWJiIkaNGgUiQnBwMJYvX46JEycCAHbs2AELCwuEhYVh3rx56gibMcZYK2vzlR9NTU2YmJggLy8PAKCnp8fjTjylsvIyoBIoKy2DZnUHz3jWqZPwS/uNG0L7cmNjdUfEOqLqaiAnR3jaY2ICWFkJ/XxKS1t9V0SER48eIS8vDyYmJtBsp1kP79+/DwAw/aufVGZmJnJzc+Hp6SkuI5PJMHr0aMTGxnLlhzHG2ok2X/kBAEtLSwAQK0Ds6ZRXlaPgYQG0H2hDqilVdzjqRyRk1EpOFp4Gcd8K9ixVVAjj91RWCs0xKyqETuAqZmJiIn63tjdEhMDAQPztb3/Diy++CADI/at5q4WFhcKyFhYWuHHjhtLtlJWVoaysTGGalla7uKwyxli71S6+pSUSCaysrNClSxdUVFSoO5w270reFfgd8cPet/aidxceXwWA0K587lzg8mVg507A0VHdEbGO4NAhIZVvly5AcLAwAO8zoK2t3W6f+ACAv78/Ll68iNOnT9ebV7flABE12Jpg7dq1WLVqlfja0NBQrEQxxhh7PrWLyk8NTU3Ndn3BflYk2hLcKL4BibYEOvyUQ6CjA2zdCowdC4wfD8TECGOqMKYKZWVAYCDw/ffA1KnAli2AoaG6o2oXAgICEBERgVOnTqFbrc7yNU+5cnNzYWVlJU7Py8ur9zSoxtKlSxEYGKjagBljjLWqdpPtjTGVMzISfonX1xdGFOdmlkwVrl8Hhg8HfvgB+Pe/gV27uOLTCogI/v7+2LdvH44fPw47OzuF+XZ2drC0tERUVJQ4rby8HCdPnsTw4cOVblMmk8HIyEj8M+T3iTHGnntc+WGsJSwsgMhIoKhIeAL04IG6I2LtSXi4kL733j3gzBlg3jweub6VzJ8/Hzt37kRYWJjYPC03NxclJSUAhOZuixYtwpo1axAeHo7Lly9j5syZ0NPTw7Rp09QcPWOMsdbClR/GWqpnT+DIESA9HXj9daGJEmNPo7wcWLQImDgRcHcHzp8XKkGs1WzevBn379/HmDFjYGVlJf798ssv4jL//Oc/sWjRIrz//vsYNGgQbt26hcjISH6iwxhj7Ui76vPD2DPj4gIcOAB4egK+vsB//wtwfzP2JG7cAN56C0hKAjZuBPz9+WmPCjRn0FaJRIKgoCAEBQWpNJaqqipOzvMEqIJgq28LqiCUqiDNe0fH5ataXL6t70mT83Dlh7EnNWoUsHs3MGkSsGAB8N13fNPKWub334Hp04X+ZKdPA0OGqDsipkJEhNzcXNy7d0/dobRJWlVa+PeIf0PrgRYyizPVHU67w+WrWly+qvEkwzJw5Yexp+HtLWTimjNHSEe8cqW6I2JtQUUFsHw58K9/Aa++CuzYIQyoy9q1mopPly5deEDuJ/Co/BEq7lXAxsQGelI9dYfT7nD5qhaXb+uqPSB3S3Hlh7GnNXs28H//B3zyiZAQwc9P3RGx59mffwJTpgBnzwJffy2ktOab4HavqqpKrPiYmZmpO5w2qUqjCtACZDoy6Eh5GIbWxuWrWly+rU9XVxeAMCQBGTXdtLkGV34Yaw3LlgkVoPffBzp3Bt54Q90RsefR0aPA228L40adOiWktGYdQk0fHz09/sWXMcZai/idWt38dTjbG2OtQSIBgoOByZMBHx/g+HF1R8SeJ1VVwIoVQnr0wYOF5AZc8emQuKkbY4y1HvE7tfkPfrjyw1ir0dAQ+m6MGSP0BUpKUndE7HmQkyOkr16zBli9Wkhy0LmzuqNijDHGOiSu/DDWmqRSYO9ewNERePllYSwg1nEdPw4MGACkpgr/X7pUqCQzxp5b27dvh4mJibrDaFVjxozBokWLnvl+o6OjIZFIxAyHqirbrKwsSCQSJCcnK92vKvfF2p5WvwqfOnUKr776KqytrSGRSLB//36F+USEoKAgWFtbQ1dXF2PGjMGVK1daOwzG1MfAADh4EDAxEcYByslRd0TsWauqAj77THji07ev8BRw9Gh1R8VYq5o5cya8vb1bvF5QUBD69+//1PuvucFV9hcfH//U22+LGrrp37dvHz7//HP1BFXL5MmTkZaW1qxlW1JRsrGxQU5ODl588cWniK4+Zee4qvbFnp1Wr/wUFxfDxcUF3333ndL569atw/r16/Hdd98hPj4elpaW8PDwwMOHD1s7FMbUx9wciIwEysqEfh7376s7Ivas5OUJ73lQkJD6/MgRIQsgY6xVDR8+HDk5OQp/s2fPRo8ePTBo0CB1h9ci5eXlKt2+qakpDA0NVbqP5tDV1UWXLl1adZvl5eXQ1NSEpaUltLRUn8frWe6LqUarV37Gjx+PL774AhMnTqw3j4gQHByM5cuXY+LEiXjxxRexY8cOPHr0CGFhYa0dCmPqZWsrZPe6cQOYMAHgEZ3bv1OnhGZuFy4AUVFC5ecJRp9m7HmxZ88e9O3bF7q6ujAzM4O7uzuKi4sRFBSEHTt24LfffhOftkRHRwMAlixZAgcHB+jp6aFnz55YsWKFmO1u+/btWLVqFS5cuCCut337dgDA/fv3MXfuXHTp0gVGRkYYN24cLly40GBsUqkUlpaW4p+ZmRkiIiLw7rvvNppYorCwENOnT0enTp2gp6eH8ePH49q1a/WW279/PxwcHKCjowMPDw/cvHlTnHfhwgWMHTsWhoaGMDIywsCBA5GQkCDOj42NxahRo6CrqwsbGxssWLAAxcXF4vwePXrgiy++wMyZM2FsbIw5c+bAzc0NH3/8sUIM+fn50NbWxokTJwAAO3fuxKBBg2BoaAhLS0tMmzZNHOckKysLY8eOBQB06tQJEokEM2fOBFC/2ZuyMki/9riZds1Tl6NHj8LJyQkGBgZ4+eWXkdNES4ZDhw7BwcEBurq6GDt2LLKyshTm132a01A5RkdH45133sH9+/fF8yQoKKjBsmuoKVpMTAxcXFygo6ODoUOH4tKlS+I8ZU8gg4OD0aNHD3G+snNc2b5OnjyJIUOGQCaTwcrKCh9//DEqKyvF+WPGjMFHH3yEjV9shI2lDSwtLcXjYc/eM218npmZidzcXHh6eorTZDIZRo8ejdjY2AbXKysrw4MHD8Q/fkrE2owXXwQOHADi4oBp04TmUKz9qa4GvvwSGDcOeOEFoZnbSy+pOyrGnkpOTg6mTp2Kd999F3K5HNHR0Zg4cSKICB999BHeeust8YY4JycHw//KYGhoaIjt27fj6tWr+Pbbb7Ft2zZs2LABgNDs6cMPP0SfPn3E9SZPngwiwt///nfk5ubi0KFDSExMhKurK1566SXcvXu3WfFGRESgoKBAvOFvyMyZM5GQkICIiAicOXMGRIRXXnlFrKABwKNHj7B69Wrs2LEDMTExePDgAaZMmSLO9/HxQbdu3RAfH4/ExER8/PHH0NbWBgBcunQJXl5emDhxIi5evIhffvkFp0+fhr+/v0Ic//rXv/Diiy8iMTERK1asgI+PD/773/+C6HHaql9++QUWFhYY/Vez2fLycnz++ee4cOEC9u/fj8zMTPF4bWxssHfvXgBAamoqcnJy8O233za7DCZNmITKisc37I8ePcLXX3+Nn3/+GadOnUJ2djY++uijBsv15s2bmDhxIl555RUkJydj9uzZ9SpzdTVUjsOHD0dwcDCMjIzE86T2vuuWXUMWL16Mr7/+GvHx8ejSpQtee+01hfe5MY2d47XdunULr7zyCgYPHowLFy5g8+bN+M9//oMvvvhCYbmwnWHQ1dPFiT9OYN26dfjss88QFRXVrFhYKyMVAkDh4eHi65iYGAJAt27dUlhuzpw55Onp2eB2Vq5cSRCS2BEAMjQ0pOLiYkq6naSiyDu2xNuJhCBQ4u1EdYfSfkREEGlqEs2ZQxQZSeTkRBQVpe6oWGsoKCB65RUigGjZMqKKCnVHpHJJt5OouLiYqqur1R3Kc6W6urrBa1NJSQldvXqVSkpK6s27/eA2Jd5OfCZ/tx/cbvbxJCYmEgDKyspSOn/GjBk0YcKEJrezbt06GjhwoPh65cqV5OLiorDMsWPHyMjIiEpLSxWm9+rVi7Zs2UJEREVlRRR/K56KyoqU7mf8+PE0fvz4RmNJS0sjABQTEyNOKygoIF1dXfr111+JiCg0NJQA0NmzZ8Vl5HI5AaC4uDgiIjI0NKTt27cr3Yevry/NnTtXYdoff/xBGhoa4vtva2tL3t7eCsvk5eWRlpYWnTp1Spzm5uZGixcvbvB4zp07RwDo4cOHRER04sQJAkCFhYUKy40ePZoWLlzYZBms/fdaKiorEssgPT1dXGbTpk1kYWHRYCxLly4lJycnhe+FJUuWKMQTGhpKxsbG4vzGyrHusjWUlV1mZiYBoKSkJIVy2L17t7jMnTt3SFdXl3755RciUn4ebtiwgWxtbcXXys7xuvtatmwZ9e7dW+G4N23aRAYGBlRVVUVEQvm7jXBTOH8HDx5MS5YsUXrsrPlqvlvP3zjf7OuSWhos1n0cTUSNPqJeunQpAgMDVR0WY6rz6qvADz8A77wjpDrOyREGRn3pJWGMINY2nTkjjO306BFw+LCQ4Y+xFtqSuAWrTq56JvtaOXolgsYENWtZFxcXvPTSS+jbty+8vLzg6emJN954A506dWp0vT179iA4OBjp6ekoKipCZWUljIyMGl0nMTERRUVFMDMzU5heUlKCjIyMJmP9888/cfToUfz666+NLieXy6GlpYWhQ4eK08zMzNC7d2/I5XJxmpaWlkK/IUdHR5iYmEAul2PIkCEIDAzE7Nmz8fPPP8Pd3R1vvvkmevXqJR5Leno6du3aJa5PRKiurkZmZiacnJwAoF6/JHNzc3h4eGDXrl0YOXIkMjMzcebMGWzevFlcJikpCUFBQUhOTsbdu3dRXS2M7JidnQ1nZ+cmy6mxMnjB4QVkpmeK0/T09MRjAgArKyuxiV1D2x02bJjC/Zybm1ujsTRWjo1pbp+u2vs3NTWt9z63BrlcDjc3N4XjHjFiBIqKivDnn3+ie/fuAFAvQUJT5clU55lWfiwtLQEAubm5sLKyEqfn5eXBopEOwTKZDDKZTHxNRCgpKVFdoIypwsyZwB9/AD/+KLyOjxeSInh5qTUs9gSIgA0bgCVLgCFDgN27ARsbdUfF2qh5A+fhtd6vPZN9WRlYNb3QXzQ1NREVFYXY2FhERkYiJCQEy5cvR1xcHOzs7JSuc/bsWUyZMgWrVq2Cl5cXjI2NsXv3bnzzzTeN7qu6uhpWVlZiv6HampPxKzQ0FGZmZnjttcbLkWo1Kas7ve6PsMp+lK2ZFhQUhGnTpuHgwYM4fPgwVq5cid27d+P1119HdXU15s2bhwULFtRbv+ZGGAD09fXrzffx8cHChQsREhKCsLAw9OnTBy4uLgCEhFKenp7w9PTEzp07YW5ujuzsbHh5ebUoYUKjZYDHx1zTjK/2sTe0bmPbbUxj5dgYZWXXXDXvoYaGRr2Ym9skrjZl507NdmtPV1aeNZVX9mw908qPnZ0dLC0tERUVhQEDBgAQ2q+ePHkSX3311bMMhbFnjwi4eFF40lPzhTtlCvDRR8CwYcCgQYCxsXpjZE0rLBSe4P32G7B4sTBwaZ2LGmMtYWVoBSvD5ldKniWJRIIRI0ZgxIgR+PTTT2Fra4vw8HAEBgZCKpWiqk4/xpiYGNja2mL58uXitBs3bigso2w9V1dX5ObmQktLS+xw3lxEhNDQUEyfPr3eDWZdzs7OqKysRFxcnNh/486dO0hLSxOfyABAZWUlEhISMGTIEABCH5p79+7B0dFRXMbBwQEODg744IMPMHXqVISGhuL111+Hq6srrly5Ant7+xYdBwB4e3tj3rx5OHLkCMLCwuDr6yvOS0lJQUFBAb788kvY/PVjS+0kC4BQtgDqlW9zyiD9Wjp85vu0OOba2607vMnZs2ebXK+hclR2nrTU2bNnxQpnYWEh0tLSxPfQ3Nwcubm5CpWXugkTmhODs7Mz9u7dq7Cd2NhYGBoaomvXrk8VP1ONVk94UFRUhOTkZPEEyszMRHJyMrKzsyGRSLBo0SKsWbMG4eHhuHz5MmbOnAk9PT1MmzattUNh7PkSGQkkJDyu+ADAvXvAmjXCeDAmJoCTk/CE6PvvhWVVnP6UtVB8PODqKmR1i4gA1q3jig9rt+Li4rBmzRokJCQgOzsb+/btQ35+vlhJ6NGjBy5evIjU1FQUFBSgoqIC9vb2yM7Oxu7du5GRkYGNGzciPDxcYbs9evQQ7w0KCgpQVlYGd3d3uLm5wdvbG0ePHkVWVhZiY2PxySef1LvBr+v48ePIzMzErFmzmjymF154ARMmTMCcOXNw+vRpXLhwAW+//Ta6du2KCRMmiMtpa2sjICAAcXFxOH/+PN555x0MGzYMQ4YMQUlJCfz9/REdHY0bN24gJiYG8fHxYrksWbIEZ86cwfz585GcnIxr164hIiICAQEBTcanr6+PCRMmYMWKFZDL5Qr3Rt27d4dUKkVISAiuX7+OiIiIemP32NraQiKR4Pfff0d+fj6KioqaXQbW1tYY7fXk45H5+fkhIyMDgYGBSE1NRVhYmJjJT5mmyrFHjx4oKirCsWPHUFBQgEePHrU4ps8++wzHjh0T7zc7d+4sjtszZswY5OfnY926dcjIyMCmTZtw+PBhhfWVneN1vf/++7h58yYCAgKQkpKC3377DStXrkRgYCA0eFDr51Nrdzyq6WRW92/GjBlEJHQIXblyJVlaWpJMJqNRo0bRpUuXWrSPxjqVsqfHCQ9UoLqaaPBgIemBUP0R/jQ1iQYNIrpyhWj7dqL33ycaOJBIS0uYL5MRDRtGtGAB0a5dRNeuCdtiz1Z1NdHGjUTa2kRDhhBlZqo7IrXihAfKPWnCg+fV1atXycvLi8zNzUkmk5GDgwOFhISI8/Py8sjDw4MMDAwIAJ04cYKIiBYvXkxmZmZkYGBAkydPpg0bNih0XC8tLaVJkyaRiYkJAaDQ0FAiInrw4AEFBASQtbU1aWtrk42NDfn4+FB2djYRNZzwYOrUqTR8+PBmH9fdu3fJ19eXjI2NSVdXl7y8vCgtLU2cX9PRfu/evdSzZ0+SSqU0btw4MfFDWVkZTZkyhWxsbEgqlZK1tTX5+/srvLfnzp0Ty0ZfX5/69etHq1evFufb2trShg0blMZ38OBBAkCjRo2qNy8sLIx69OhBMpmM3NzcKCIiQqHzPRHRZ599RpaWliSRSMR7r9oJDxoqg+TLyWL5Kks2EB4eTk3dNh44cIDs7e1JJpPRyJEj6ccff2ww4UFzytHPz4/MzMwIAK1cubLBsmso4cGBAweoT58+JJVKafDgwZScnKyw3ubNm8nGxob09fVp+vTptHr1aoWEB8rO8br7IiKKjo6mwYMHk1QqJUtLS1qyZAlV1Ep+M3r0aHrf/32F83fChAni+8Oe3JMkPJAQPUEjTTWjv/r8pN1PQ3+r/uoOp905n3MeA7cOROLcRLhauao7nPbh6NHGO8MfOaLY96e0FEhOFlJknzsn/KX/NQaDqanQz6T2n7m5SsPv0O7fB2bPBvbsARYuFJ72/NW0pKNKzkmGg7EwlkdjyWo6msauTaWlpcjMzISdnR10dHTUE2AbV1xeDHmBHE6dnaAvffI+H0w5Ll/V4vJVjZrv1lL9UvTu3LtZ1yUenpYxVSMCVqwANDSE8WDq0tAQ5nt6Ps78pqMj9AMaNuzxcnfuCM2uaipD338PfPaZMM/O7nFFaOhQYaBNPT3VH1t7l5wMvPkmkJcnVH4mTVJ3RIwxxhh7CtwYkTFVKy8HsrOVV3wAYfrNm0337zEzE54effqpkC47Lw+4fl3INObtDfz5J7B8OfC3vwFGRkIFaN48Ibvc5cs8wGpLEAFbtgiVT0ND4Px5rvi0cadOncKrr74Ka2trSCSSeh2ziQhBQUGwtraGrq4uxowZgytXrqgnWMYYYyrDT34YUzWZTHhik58PAJDny+Gz723smrgTTuZ/ZRfq0kVYriUkEuGJj52dMNYMAFRUCBWdmqdDMTHAtm3CzbyBgZBRrvYToq5deZyhuoqKhEpjWBjw3nvA+vXCkzjWphUXF8PFxQXvvPMOJimpyK5btw7r16/H9u3b4eDggC+++AIeHh5ITU2FoaGhGiJmjDGmClz5YexZsLERx4EpyQGSzgIl/ZyA1u5Tpa0tPPGpeeoDAA8fAomJQmUoLk64qV+3TphnZfW4IjRkCKfbvnRJaOZ26xbw3/8KqchZuzB+/HiMHz9e6TwiQnBwMJYvX46JEycCAHbs2AELCwuEhYVhXs1niTHGWJvHlR/G2jtDQ2DMGOGvxu3bj58OnTsHfPkl8OCB8BTI0VExmUK/fh2jg39oKDB/PmBvL6QZ791b3RGxZyQzMxO5ubnw9PQUp8lkMowePRqxsbENVn7KyspQVlamME1Liy+rjDH2PONvacY6ImtroZ/QX+MdoLoaSE19/HTo3Dlg1y6gslJojjdggOITol692k9zuUePhErP9u3ArFlASAigq6vuqNgzlJubCwCwsLBQmG5hYVFvgM7a1q5di1WrVomvDQ0NxW0xxhh7PnHlhzEmZJxzchL+ZswQptVNt33oELBxozCvvaTblsuFZm6ZmcCOHcD06eqOiKlR3fSoVGvEdmWWLl2KwMBAVYfFGGOsFXHlhzGmXFPptuPilKfbrnk69Lyn2965E/DzA7p3F47J2VndETE1sbS0BCA8AbKyshKn5+Xl1XsaVJtMJoOsVqKSmnF+GGOMPb+48sMYa76adNs1A7YSAVlZioOx/vab8NRIUxPo2/dxZWjIEOHJkqamWg8BJSXCYKXbtgG+vsDmzYA+DzjXkdnZ2cHS0hJRUVEYMGAAAKC8vBwnT57EV199peboGGOMtSYe54cx9uRq0m1PmSKkhD59WkiccP48sGkT4OoqTJs9W6gImZgAY8cCS5YAe/cKYxMRPbt4r10D3NyAn38GfvhBaOrGFZ8OoaioCMnJyUhOTgYgJDlITk5GdnY2JBIJFi1ahDVr1iA8PByXL1/GzJkzoaenh2nTpqk3cPbMbd++HSYmJuoOo1WNGTMGixYtUvl+YmJi0LdvX2hra8O7pk8pa1JWVhYkEon4/RQdHQ2JRIJ79+61+r5qj3NWd7+q3NfzhJ/8MMZaV2PptmueEKkj3favvwqVMEtLIY5+/Vp/H+y5lZCQgLFjx4qva/rqzJgxA9u3b8c///lPlJSU4P3330dhYSGGDh2KyMhIHuOnETNnzsS9e/dafHMTFBSE/fv3P/UNV3R0tMJ7Wtu5c+cwePDgp9p+W1RTJoWFhQoVuH379kFbW1vl+w8MDET//v1x+PBhGBgYqHx/7dXw4cORk5MD42ZcCxt6zxuSk5ODTp06tUKUjzX0mVbFvloDV34YY6rXVLrtuDhg7VqhklQ33fbQocJTo5ak2/7f/4AFC4QEDSNHAh9+KDyJmjIF2LpViId1KGPGjAE18pRRIpEgKCgIQUFBzy6oJ1X7/HZ3V3c0alNzg1jbihUr8L///Q+DBg1SU1RPpry8HFIVDilgamqqsm3XlpGRAT8/P3Tr1k3pfCJCVVUVp4RvglQqFfsitpaac6y1t9uYZ7mvluBmb4wx9ahJt71mDXDsGHDvHnD1KvDjj0Il6fJloW/OoEGAkZHQXG3RIuGpUXp6w83liIBly4RMbh9+CAwfLvTv+f57YV2u+LC2rPb5vWyZypuN7tmzB3379oWuri7MzMzg7u6O4uJiBAUFYceOHfjtt98gkUggkUgQHR0NAFiyZAkcHBygp6eHnj17YsWKFaioqAAgNClbtWoVLly4IK63fft2AMD9+/cxd+5cdOnSBUZGRhg3bhwuXLjQYGw1N3I1f2ZmZoiIiMC7777baJa+wsJCTJ8+HZ06dYKenh7Gjx+Pa9eu1Vtu//79cHBwgI6ODjw8PHDz5k1x3oULFzB27FgYGhrCyMgIAwcOREJCgjg/NjYWo0aNgq6uLmxsbLBgwQIUFxeL83v06IEvvvgCM2fOhLGxMebMmQM3Nzd8/PHHCjHk5+dDW1sbJ06cAADs3LkTgwYNgqGhISwtLTFt2jTk5eUBEJow1TwJ69SpEyQSCWbOnAmgfrM3ZWWQfi1dnF/T9O/o0aNwcnKCgYEBXn755XqVzRo1zafu3Lkjlv/27dvF5ltHjx7FoEGDIJPJ8Mcff4CIsG7dOvTs2RO6urpwcXHBnj17FLZ56NAhODg4QFdXF2PHjsX27dsVmoIFBQWhf//+CusEBwejR48eCtNCQ0Ph5OQEHR0dODo64vvvv68X9759+zB27Fjo6enBxcUFZ86cUdhGTEwMRo8eDT09PXTq1AleXl4oLCzETz/9BDMzs3rjfU2aNAnTG8keeu7cOQwYMAA6OjoYNGgQkpKSFObXbfZ248YNvPrqq+jUqRP09fXRp08fHDp0qMn33N/fH4GBgejcuTM8PDwAKG+KlpKSguHDh0NHRwd9+vQRP8uA8mag+/fvFz9jjX2m6+7r0qVLGDdunPh9MnfuXBQVFYnzZ86cCW9vb3z99dewsrKCmZkZ5s+fL35/tBpqg6qrq6m4uJiSbiepO5R2KfF2IiEIlHg7Ud2htEtcvi1QUkIUG0sUHEw0bRpRr15Ewu0ekakp0csvE336KdHvvxPl5QnrHDnyeBmAyNKSKJHLujUl3U6i4uJiqq6uVncoz5XGrk0lJSV09epVKikpebqd1D2/jxx5uu014vbt26SlpUXr16+nzMxMunjxIm3atIkePnxIDx8+pLfeeotefvllysnJoZycHCorKyMios8//5xiYmIoMzOTIiIiyMLCgr766isiInr06BF9+OGH1KdPH3G9R48eUXV1NY0YMYJeffVVio+Pp7S0NPrwww/JzMyM7ty5Q0RERWVFFH8rnorKipTGu2fPHtLQ0KDs7OxGj+u1114jJycnOnXqFCUnJ5OXlxfZ29tTeXk5ERGFhoaStrY2DRo0iGJjYykhIYGGDBlCw4cPF7fRp08fevvtt0kul1NaWhr9+uuvlJycTEREFy9eJAMDA9qwYQOlpaVRTEwMDRgwgGbOnCmub2trS0ZGRvSvf/2Lrl27RteuXaOQkBDq3r27wucqJCSEunbtSlVVVURE9J///IcOHTpEGRkZdObMGRo2bBiNHz+eiIgqKytp7969BIBSU1MpJyeH7t27R0REo0ePpoULFzZaBr169aIzWWeoqKxILAN3d3eKj4+nxMREcnJyomnTpikt08rKSsrJySEjIyMKDg4W39cTJ04QAOrXrx9FRkZSeno6FRQU0LJly8jR0ZGOHDlCGRkZFBoaSjKZjKKjo4mIKDs7m2QyGS1cuJBSUlJo586dZGFhQQCosLCQiIhWrlxJLi4uCnFs2LCBbG1txddbt24lKysr2rt3L12/fp327t1LpqamtH37diIiyszMJADk6OhIv//+O6WmptIbb7xBtra2VFFRQURESUlJJJPJ6L333qPk5GS6fPkyhYSEUH5+Pj169IiMjY3p119/FfeZn59PUqmUjh8/rhBbzfn7f3f/j8zNzWny5Ml0+fJlOnDgAPXs2ZMAUFJSEhGRWG41x/r3v/+dPDw86OLFi5SRkUEHDhygkydPNvmeGxgY0OLFiyklJYXkcjkREQGg8PBwhePv1q0b7dmzh65evUqzZ88mQ0NDKigoICLh82BsbKxwLOHh4VRThWjoM113X8XFxWRtbU0TJ06kS5cu0bFjx8jOzo5mzJghbnfGjBlkZGREfn5+JJfL6cCBA6Snp0dbt25Vet4RPf5uPX/jfLOvS1z5YfXwzblqcfk+pYICosOHiYKCiF55hahz58c3gj16EHXqRCSRCK8lEqIBA4j4Jr1VceVHuSeq/BQXC5Xz5vwlJBA5OxNpaAjnt4aG8DohofnbSEwU9tkMiYmJBICysrKUzp8xYwZNmDChye2sW7eOBg4cKL5WdtN67NgxMjIyotLSUoXpvXr1oi1bthBR05Wf8ePHixWBhqSlpREAiomJEacVFBSQrq6ueAMbGhpKAOjs2bPiMnK5nABQXFwcEREZGhqKN9B1+fr60ty5cxWm/fHHH6ShoSG+/7a2tuTt7a2wTF5eHmlpadGpU6fEaW5ubrR48eIGj+fcuXMEgB4+fEhE9W+aa9Su/DRWBmv/vVas/ACg9PR0cZlNmzaRhYVFg7EQERkbG1NoaKj4uiae/fv3i9OKiopIR0eHYmNjFdadNWsWTZ06lYiIli5dSk5OTgrfMUuWLGlx5cfGxobCwsIUlvn888/Jzc2NiB7f/P/www/i/CtXrhAAsbIwdepUGjFiRIPH/N577ymcd8HBwdSzZ89634815+/GTRvJ1NSUimt9Djdv3txo5adv374UFBSkdP+Nvef9+/evt7yyys+XX34pzq+oqKBu3bqJP1g0VfkhUv5e1N3X1q1bqVOnTlRU9Pjze/DgQdLQ0KDc3FwiEr5TbG1tqbKyUlzmzTffpMmTJys9dqInq/xwo0vGWNuiLN12ZqbQd+jXX4Hw8MfLEgFJSUBkJODlpZ54GWtMSgowcOCTrVtdLTQVbWn/lsREIRNjE1xcXPDSSy+hb9++8PLygqenJ954440mOzDv2bMHwcHBSE9PR1FRESorK2FkZNRESIkoKiqCmZmZwvSSkhJkZGQ0Geuff/6Jo0eP4tdff210OblcDi0tLQwdOlScZmZmht69e0Mul4vTtLS0FPoNOTo6wsTEBHK5HEOGDEFgYCBmz56Nn3/+Ge7u7njzzTfRq1cv8VjS09Oxa9cucX0iQnV1NTIzM+Hk5AQA9folmZubw8PDA7t27cLIkSORmZmJM2fOYPPmzeIySUlJCAoKQnJyMu7evYvq6moAQHZ2NpybOVZZQ2XwgsMLyEzPFKfp6emJxwQAVlZWYhO7lqp9rFevXkVpaanYDKtGeXm5mGpeLpdj2LBhCs0X3dzcWrTP/Px83Lx5E7NmzcKcOXPE6ZWVlfUSCfSrlQCnZqyvvLw8ODo6Ijk5GW+++WaD+5kzZw4GDx6MW7duoWvXrggNDcXMmTMbbHqZmpIKFxcX6NUaB6+pY1uwYAHee+89REZGwt3dHZMmTVKIuSHN7ftWe/81537tz0NrkMvlcHFxgX6tDKsjRoxAdXU1UlNTxTHV+vTpA81aQ2JYWVnh0qVLrRoLV34YY22bRAL07Cmk3F6/XhhHqKrq8XxNTWDFCsDTU1iWseeJo6NQGWkKETB9ulBZ+uuGFwCgoSFs46efmn9+Ozo2azFNTU1ERUUhNjYWkZGRCAkJwfLlyxEXFwc7Ozul65w9exZTpkzBqlWr4OXlBWNjY+zevRvffPNNo/uqrq6GlZWVQl+DGs3JYBUaGgozMzO89tprjS5HDfSRIqJ6N6vKbl5rpgUFBWHatGk4ePAgDh8+jJUrV2L37t14/fXXUV1djXnz5mHBggX11u/evbv4f30lafZ9fHywcOFChISEICwsDH369IGLiwsAoLi4GJ6envD09MTOnTthbm6O7OxseHl5oby8vNHjbnYZ4PEx180OJ5FIGk0a0pjax1pTYTt48CC6du2qsFzNoMHN2Y+Ghka95Wr3DanZz7Zt2xQqegAUbq4BxWOteY9r1tfV1W00jgEDBsDFxQU//fQTvLy8cOnSJRw4cKDB5Z+kDGfPng0vLy8cPHgQkZGRWLt2Lb755hsEBAQ0up6yc6y5asqhqXJuLmWfsbr7ApSfd9W1v/NaAVd+GGPtQ2QkEB9ff3pVlTCdn/6w55GeXrOewuDoUeEpT101T38KClRyfkskEowYMQIjRozAp59+CltbW4SHhyMwMBBSqRRVtX9ogNAx3NbWFsuXLxen3bhxQ2EZZeu5uroiNzcXWlpa9TqsN4WIEBoaiunTpzeZztnZ2RmVlZWIi4vD8OHDAQB37txBWlqa+EQGEJ4OJCQkYMiQIQCA1NRU3Lt3D461Ko4ODg5wcHDABx98gKlTpyI0NBSvv/46XF1dceXKFdjb27foOADA29sb8+bNw5EjRxAWFgZfX19xXkpKCgoKCvDll1/CxsYGABSSLAAQM8bVLd/mlEH6tXT4zPdpccwt5ezsDJlMhuzsbIwePbrBZep2yj979qzCa3Nzc+Tm5ircVNdOtWxhYYGuXbvi+vXr8PF58uPq168fjh07hlWrVjW4zOzZs7FhwwbcunUL7u7u4vujjKOTI3aH7UZJSYlYsap7bMrY2NjAz88Pfn5+WLp0KbZt24aAgIBmvedNOXv2LEaNGgVAOPcTExPh7+8PQCjnhw8fori4WKxM1U1prewzXZezszN27NihsJ2YmBhoaGjAwcHhiWN/EpztjTHW9hEJT3c0GvhK09AQ5j/LAVUZay1qOr/j4uKwZs0aJCQkIDs7G/v27UN+fr5YSejRowcuXryI1NRUFBQUoKKiAvb29sjOzsbu3buRkZGBjRs3Irx2U9S/1qsZZLagoABlZWVwd3eHm5sbvL29cfToUWRlZSE2NhaffPJJvRv8uo4fP47MzEzMmjWryWN64YUXMGHCBMyZMwenT5/GhQsX8Pbbb6Nr166YMGGCuJy2tjYCAgIQFxeH8+fP45133sGwYcMwZMgQlJSUwN/fH9HR0bhx4wZiYmIQHx8vlsuSJUtw5swZzJ8/H8nJybh27RoiIiKa/JUeEH6pnzBhAlasWAG5XK4wyG737t0hlUoREhKC69evIyIiAp9//rnC+ra2tpBIJPj999+Rn5+vkEmrqTKwtrbGaC/llZHWZGhoiI8++ggffPABduzYgYyMDCQlJWHTpk3YsWMHAMDPzw8ZGRkIDAxEamoqwsLCxAxiNcaMGYP8/HysW7cOGRkZ2LRpEw4fPqywTFBQENauXYtvv/0WaWlpuHTpEkJDQ7F+/fpmx7t06VLEx8fj/fffx8WLF5GSkoLNmzejoKBAXMbHxwe3bt3Ctm3b8O677za6vbemvAUNDQ3MmjULV69exaFDh/D11183us6iRYtw9OhRZGZm4vz58zh+/Lh4vjXnPW/Kpk2bEB4ejpSUFMyfPx+FhYXicQwdOhR6enpYtmwZ0tPTlb4Xyj7Tdfn4+EBHRwczZszA5cuXceLECQQEBMDX11ds8vbMNNkr6DnECQ9UizvkqxaXrwqUlhJZWChmwar7Z2kpLMeeGic8UE5l2d7UdH5fvXqVvLy8yNzcnGQyGTk4OFBISIg4Py8vjzw8PMjAwIAA0IkTJ4iIaPHixWRmZkYGBgY0efJk2rBhg0KH6dLSUpo0aRKZmJgQALGD/IMHDyggIICsra1JW1ubbGxsyMfHR8ze1lDCg6lTpypkYmvK3bt3ydfXl4yNjUlXV5e8vLwoLS1NnF/TwXvv3r3Us2dPkkqlNG7cODHxQ1lZGU2ZMoVsbGxIKpWStbU1+fv7K7y3586dE8tGX1+f+vXrR6tXrxbn29ra0oYNG5TGd/DgQQJAo0aNqjcvLCyMevToQTKZjNzc3CgiIkKhozwR0WeffUaWlpYkkUjETFp1s70pK4Pky8li+Tank7syDSU8qNsZv7q6mr799lvq3bs3aWtrk7m5OXl5edHJkyfFZQ4cOED29vYkk8lo5MiR9OOPP9bb1ubNm8nGxob09fVp+vTptHr1aoWEB0REu3btov79+5NUKqVOnTrRqFGjaN++fUT0uMN/7fIrLCxUOJ+JiKKjo2n48OEkk8nIxMSEvLy86h2Tr68vmZqa1kvaUaP2+XvmzBlycXEhqVRK/fv3FzO2NZTwwN/fn3r16kUymYzMzc3J19dXzMZG1Lz3vAaUJDwICwujoUOHklQqJScnJzp27JjCOuHh4WRvb086Ojr0j3/8g7Zu3apwLjT0ma69LyIhE+LYsWNJR0eHTE1Nac6cOWKyDiLlSVQWLlxIo0ePVlqmRE+W8EDyV3BtChGhpKQEaffT0N+qv7rDaXfO55zHwK0DkTg3Ea5WzWiOwVqEy1dFbt4E8vMBAPJ8OXz2vY1dE3fCyfyvpixdugANDLzHWiY5JxkOxsL4G42Np9LRNHZtKi0tRWZmJuzs7KCjo9Pyjdc6v5XqAOd3cXkx5AVyOHV2gr70yfsyMOWe9/KNjo7G2LFjUVhY2Kx+YM+ah4cHnJycsHHjRqXzn/fybatqvltL9UvRu3PvZl2XuM8PY6x9sLER/gCU5ABJZ4GSfk4AVzBZe1Dr/GaMPT/u3r2LyMhIHD9+HN999526w2HNwJUfxhhjjDHGnoCrqysKCwvx1VdfoXfv3uoOhzUDV34YY4wxxthzbcyYMU+caluVsrKy1B0CayHO9sYYY4wxxhjrELjywxhjjDHGGOsQuPLDGGOMPSOtPVI5Y4x1ZOJ3agsSj3KfH8YYY0zFpFIpNDQ0cPv2bZibm0MqlXKa8BYqKy8DKoGy0jJoVmuqO5x2h8tXtbh8WxcRoby8HPn5+dDQ0ABaUKRc+WGMMcZUTENDA3Z2dsjJycHt27fVHU6bVF5VjoKHBdB+oA2pplTd4bQ7XL6qxeWrGnp6eujevTuu3rna7HW48sMYY4w9A1KpFN27d0dlZSWqqqrUHU6bcyXvCvyO+GHvW3vRuwunFG5tXL6qxeXb+jQ1NaGlpdXip+hc+WGMMcaeEYlEAm1tbWhra6s7lDZHoi3BjeIbkGhLoKOjo+5w2h0uX9Xi8n1+qDXhwffffw87Ozvo6Ohg4MCB+OOPP9QZDmOMsQ6Or0uMMda+qa3y88svv2DRokVYvnw5kpKSMHLkSIwfPx7Z2dnqCokxxlgHxtclxhhr/9RW+Vm/fj1mzZqF2bNnw8nJCcHBwbCxscHmzZvVFRJjjLEOjK9LjDHW/qmlz095eTkSExPx8ccfK0z39PREbGxsveXLyspQVlamME1LSwsa0AARqTTWjkgDGjCUGnL5qgiXr+pxGauWxl+/mxFRu0nX3NLrEsDXpmeNP9eqxeWrWly+qtWS65JaKj8FBQWoqqqChYWFwnQLCwvk5ubWW37t2rVYtWqV+NrKygrp6emwN7ZHSUmJyuPtaByMHZC7UHgfuHxbH5ev6nEZq5a9sb26Q2h1Lb0uAXxtetb4c61aXL6qxeWrWi25Lqk121vdmllDtbWlS5ciMDBQfP3gwQPY29sjJSUFhoaGKo+zo3n48CG6deuGP//8k8tXBbh8VY/LWLXa86+Wzb0uAXxtetb4c61aXL6qxeWrWi25Lqml8tO5c2doamrW+zUtLy+v3q9uACCTySCTyRSm5eTkAKh/oWKt4+HDhwC4fFWFy1f1uIxVpz2WaUuvSwBfm9SBP9eqxeWrWly+qtOSMlVLwgOpVIqBAwciKipKYXpUVBSGDx+ujpAYY4x1YHxdYoyxjkFtzd4CAwPh6+uLQYMGwc3NDVu3bkV2djb8/PzUFRJjjLEOjK9LjDHW/qmt8jN58mTcuXMHn332GXJycvDiiy/i0KFDsLW1bXJdmUyGlStX1mtuwFoHl69qcfmqHpcxexJPc10C+LxTNS5f1eLyVS0u3+eHhNpzz1XGGGOMMcYY+4vaBjlljDHGGGOMsWeJKz+MMcYYY4yxDoErP4wxxhhjjLEOgSs/jDHGGGOMsQ6hTVZ+vv/+e9jZ2UFHRwcDBw7EH3/8oe6Q2o1Tp07h1VdfhbW1NSQSCfbv36/ukNqNtWvXYvDgwTA0NESXLl3g7e2N1NRUdYfVbmzevBn9+vWDkZERjIyM4ObmhsOHD6s7LNaB8LVJNfi6pFp8bVItvjY9f9pc5eeXX37BokWLsHz5ciQlJWHkyJEYP348srOz1R1au1BcXAwXFxd899136g6l3Tl58iTmz5+Ps2fPIioqCpWVlfD09ERxcbG6Q2sXunXrhi+//BIJCQlISEjAuHHjMGHCBFy5ckXdobEOgK9NqsPXJdXia5Nq8bXp+dPmUl0PHToUrq6u2Lx5szjNyckJ3t7eWLt2rRoja38kEgnCw8Ph7e2t7lDapfz8fHTp0gUnT57EqFGj1B1Ou2Rqaop//etfmDVrlrpDYe0cX5ueDb4uqR5fm1SPr03q1aae/JSXlyMxMRGenp4K0z09PREbG6umqBh7Mvfv3wcgfAmy1lVVVYXdu3ejuLgYbm5u6g6HtXN8bWLtCV+bVIevTc8HLXUH0BIFBQWoqqqChYWFwnQLCwvk5uaqKSrGWo6IEBgYiL/97W948cUX1R1Ou3Hp0iW4ubmhtLQUBgYGCA8Ph7Ozs7rDYu0cX5tYe8HXJtXga9PzpU1VfmpIJBKF10RUbxpjzzN/f39cvHgRp0+fVnco7Urv3r2RnJyMe/fuYe/evZgxYwZOnjzJFxn2TPC1ibV1fG1SDb42PV/aVOWnc+fO0NTUrPdLWl5eXr1f3Bh7XgUEBCAiIgKnTp1Ct27d1B1OuyKVSmFvbw8AGDRoEOLj4/Htt99iy5Ytao6MtWd8bWLtAV+bVIevTc+XNtXnRyqVYuDAgYiKilKYHhUVheHDh6spKsaah4jg7++Pffv24fjx47Czs1N3SO0eEaGsrEzdYbB2jq9NrC3ja9Ozx9cm9WpTT34AIDAwEL6+vhg0aBDc3NywdetWZGdnw8/PT92htQtFRUVIT08XX2dmZiI5ORmmpqbo3r27GiNr++bPn4+wsDD89ttvMDQ0FH8lNjY2hq6urpqja/uWLVuG8ePHw8bGBg8fPsTu3bsRHR2NI0eOqDs01gHwtUl1+LqkWnxtUi2+Nj2HqA3atGkT2draklQqJVdXVzp58qS6Q2o3Tpw4QQDq/c2YMUPdobV5ysoVAIWGhqo7tHbh3XffFb8XzM3N6aWXXqLIyEh1h8U6EL42qQZfl1SLr02qxdem50+bG+eHMcYYY4wxxp5Em+rzwxhjjDHGGGNPiis/jDHGGGOMsQ6BKz+MMcYYY4yxDoErP4wxxhhjjLEOgSs/jDHGGGOMsQ6BKz+MMcYYY4yxDoErP4wxxhhjjLEOgSs/jDHGGGOMsQ6BKz+MMcYYY4yxDoErP4wxxhhjjLEOgSs/jDHGGGOMsQ6BKz+MMcYYY4yxDuH/A8P6ak9jeOrVAAAAAElFTkSuQmCC", - "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": "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", - "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": "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", - "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 -}