diff --git a/.gitlab-ci.yml b/.gitlab-ci.yml
index 53bed1d8b2dc0b17db72f634f4c8ed2f57b0c3d6..798d2a91cffdcb6bc878e6a164617b0ce27a50c5 100644
--- a/.gitlab-ci.yml
+++ b/.gitlab-ci.yml
@@ -31,6 +31,7 @@ stages: # List of stages for jobs, and their order of execution
     - build
     - test
     - quality
+    - docs
     - deploy
 
 build:
@@ -70,6 +71,19 @@ coverage:
       - coverage.xml
     when: always
 
+pages:
+  stage: docs
+  <<: *build_test
+  script:
+    - pip install sphinx sphinx-rtd-theme
+    - cd doc
+    - make html
+    - mv build/html/ ../public/
+  artifacts:
+    paths:
+      - public
+  rules:
+    - if: $CI_COMMIT_BRANCH == $CI_DEFAULT_BRANCH
 
 build-singularity:
   image: 
diff --git a/HISTORY.rst b/HISTORY.rst
index 9ef251ed16b596b36cff453cafb22441f82cf4f5..3fdbededeb7fdc49dadb77164ad280f305488739 100644
--- a/HISTORY.rst
+++ b/HISTORY.rst
@@ -2,6 +2,15 @@
 History
 =======
 
+0.1.3 (2023-03-11)
+------------------
+
+* bug fixes
+* implementation of a new timeseries stationarity analysis
+* yplus postprocessing
+* additional tests
+
+
 0.1.2 (2022-20-12)
 ------------------
 
diff --git a/MODULES.rst b/MODULES.rst
new file mode 100644
index 0000000000000000000000000000000000000000..dafba9eeeb8287615e2720c0f9019f5730c84003
--- /dev/null
+++ b/MODULES.rst
@@ -0,0 +1,10 @@
+=============
+NTRfC MODULES
+=============
+
+MODULES
+
+
+* MODULES
+* MODULES
+* MODULES
diff --git a/README.md b/README.rst
similarity index 63%
rename from README.md
rename to README.rst
index a826fd21a793a6043520fc759ae747684de868e4..11a59690cc66f3ce14620e17d34847bcadba3ce6 100644
--- a/README.md
+++ b/README.rst
@@ -1,5 +1,6 @@
-# NTRfC
-
+============
+NTRfC README
+============
 
 Numerical Test Rig for Cascades.
 
@@ -10,37 +11,26 @@ Numerical Test Rig for Cascades.
 
 
 
-## Features
-
-
-- Easy geometry and postprocessing visualization and manipulation with (pyvista)[https://github.com/pyvista]
-- Tested methods and functions for math, timeseries and meshquality-analysis
-
-## Dependencies
+Features
 
+Easy geometry and post-processing visualization and manipulation with pyvista.
+Tested methods and functions for math, time-series, and mesh quality analysis.
 
-NTRfC v0.1.0 and any following version is based on Python 3.10.
-Only older versions can be used with older versions of Python.
+Dependencies
 
-Library-requirements will be installed with the package itself.
+NTRfC v0.1.0 and any following version is based on Python 3.10. Only older versions can be used with older versions of Python. Library requirements will be installed with the package itself.
+Installation
 
-## Installation
-
-
-NTRfC is utilizing powerful and complex dependencies like pyvista and gmsh.
-It is strongly recommanded to use virtual environments or conda-environments
+NTRfC is utilizing powerful and complex dependencies like pyvista and gmsh. We strongly recommend using virtual or conda environments for installation.
 
 For more information, see:
 
-- virtualenv: https://pypi.org/project/virtualenv/
-- miniconda: https://docs.conda.io/en/latest/miniconda.html
-- anaconda: https://docs.anaconda.com/anaconda/install/index.html
-- mamba: https://mamba.readthedocs.io/en/latest/installation.html
+    virtualenv: https://pypi.org/project/virtualenv/
+    miniconda: https://docs.conda.io/en/latest/miniconda.html
+    anaconda: https://docs.anaconda.com/anaconda/install/index.html
+    mamba: https://mamba.readthedocs.io/en/latest/installation.html
 
-**Installation from gitlab with pip**
 
-You can install the package with pip from gitlab directly.
-Type:
 
 ### Installation from gitlab with pip
 
@@ -57,7 +47,7 @@ python setup.py install
 ```
 
 
-### Editable installation from source with pip**
+### Editable installation from source with pip
 
 After cloning the repository, go to the project root dir and type
 
@@ -76,8 +66,6 @@ The containers will come with a virtual graphics card and a xvfb display-server,
 
 ## Credits
 
-## Credits
-
 This package was created with Cookiecutter and the `audreyr/cookiecutter-pypackage` project template. It uses the following libraries:
 
 - [pyvista](https://github.com/pyvista)
diff --git a/docs/_static/.gitkeep b/docs/_static/.gitkeep
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/docs/conf.py b/docs/conf.py
index 9b48f6c4747a677131406a45836458171014a8b2..e50331063ad938c31e0391643df8fa1387930391 100644
--- a/docs/conf.py
+++ b/docs/conf.py
@@ -19,11 +19,10 @@
 #
 import os
 import sys
+sys.path.insert(0, os.path.abspath('..'))
 
 import ntrfc
 
-sys.path.insert(0, os.path.abspath('..'))
-
 # -- General configuration ---------------------------------------------
 
 # If your documentation needs a minimal Sphinx version, state it here.
@@ -65,7 +64,7 @@ release = ntrfc.__version__
 #
 # This is also used if you do content translation via gettext catalogs.
 # Usually you set "language" from the command line for these cases.
-language = None
+language = 'en'
 
 # List of patterns, relative to source directory, that match files and
 # directories to ignore when looking for source files.
@@ -78,6 +77,7 @@ pygments_style = 'sphinx'
 # If true, `todo` and `todoList` produce output, else they produce nothing.
 todo_include_todos = False
 
+
 # -- Options for HTML output -------------------------------------------
 
 # The theme to use for HTML and HTML Help pages.  See the documentation for
@@ -96,11 +96,13 @@ html_theme = 'alabaster'
 # so a file named "default.css" will overwrite the builtin "default.css".
 html_static_path = ['_static']
 
+
 # -- Options for HTMLHelp output ---------------------------------------
 
 # Output file base name for HTML help builder.
 htmlhelp_basename = 'ntrfcdoc'
 
+
 # -- Options for LaTeX output ------------------------------------------
 
 latex_elements = {
@@ -130,6 +132,7 @@ latex_documents = [
      'Malte Nyhuis', 'manual'),
 ]
 
+
 # -- Options for manual page output ------------------------------------
 
 # One entry per manual page. List of tuples
@@ -153,3 +156,6 @@ texinfo_documents = [
      'One line description of project.',
      'Miscellaneous'),
 ]
+
+
+
diff --git a/docs/modules.rst b/docs/modules.rst
new file mode 100644
index 0000000000000000000000000000000000000000..3ac920add438a27c9ca8d24c7506d3f84f22e677
--- /dev/null
+++ b/docs/modules.rst
@@ -0,0 +1 @@
+.. include:: ../MODULES.rst
diff --git a/examples/check_timeseries_stationarity.ipynb b/examples/check_timeseries_stationarity.ipynb
index 08f84cad9bdc6622adc0ca180cc195bc9c7f85dd..dc421e1890174190bac6b9a83ed550b2f18605fa 100644
--- a/examples/check_timeseries_stationarity.ipynb
+++ b/examples/check_timeseries_stationarity.ipynb
@@ -14,10 +14,10 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 1,
+   "execution_count": 11,
    "outputs": [],
    "source": [
-    "from ntrfc.timeseries.stationarity import stationarity\n",
+    "from ntrfc.timeseries.stationarity import estimate_stationarity\n",
     "import numpy as np\n",
     "import matplotlib.pyplot as plt"
    ],
@@ -42,12 +42,12 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": null,
    "outputs": [],
    "source": [
     "def signalgen_abatingsine(amplitude, noiseamplitude, frequency, mean, abate, time):\n",
-    "    resolution = 2048\n",
-    "    step = (resolution * frequency ** -1) ** -1\n",
+    "    resolution = 24\n",
+    "    step = (1 / frequency) / resolution\n",
     "\n",
     "    times = np.arange(0, time, step)\n",
     "    noise = np.random.normal(-1, 1, len(times)) * noiseamplitude\n",
@@ -76,15 +76,15 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": 46,
    "outputs": [],
    "source": [
     "test_amplitudes = 0.1\n",
     "test_noiseamplitude = 0.01\n",
     "test_frequencies = 6\n",
-    "test_times = 40\n",
+    "test_times = 20\n",
     "test_mean = -1\n",
-    "test_abate = 1\n",
+    "test_abate = 2\n",
     "\n",
     "\n",
     "timesteps, values = signalgen_abatingsine(amplitude=test_amplitudes, noiseamplitude=test_noiseamplitude,\n",
@@ -112,19 +112,10 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/home/many/PycharmProjects/NTRfC/ntrfc/timeseries/stationarity.py:128: RuntimeWarning: invalid value encountered in true_divide\n",
-      "  intersection = np.true_divide(np.sum(minima), np.sum(hist_2))\n"
-     ]
-    }
-   ],
+   "execution_count": 47,
+   "outputs": [],
    "source": [
-    "stationary_timestep ,_= stationarity(timesteps, values)\n",
+    "stationary_timestep = estimate_stationarity(values)\n",
     "\n",
     "well_computed_stationarity_limit = -np.log(0.05) / test_abate\n",
     "well_computed_stationary_time = timesteps[-1] - well_computed_stationarity_limit\n",
@@ -151,12 +142,12 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": 49,
    "outputs": [
     {
      "data": {
       "text/plain": "<Figure size 640x480 with 1 Axes>",
-      "image/png": "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\n"
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAi8AAAGdCAYAAADaPpOnAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/av/WaAAAACXBIWXMAAA9hAAAPYQGoP6dpAAB3lUlEQVR4nO3dd3xUVfo/8M9MGjUJJRBCC02KIlUQbCisIBZYWRWX1cXFLvbdFfZrXVfZXeta1vKzYO91EVGK9EikF+kdQggQ0kmbub8/kpmc+8zMubnJTCaTfN6vly+ZzJ2Ze2fuvec5z2kOwzAMEBEREUUIZ7h3gIiIiMgOBi9EREQUURi8EBERUURh8EJEREQRhcELERERRRQGL0RERBRRGLwQERFRRGHwQkRERBElOtw7EGxutxsZGRlo2bIlHA5HuHeHiIiIqsEwDOTn5yMlJQVOpz630uCCl4yMDHTu3Dncu0FEREQ1cPDgQXTq1Em7TYMLXlq2bAmg4uDj4+PDvDd1o7C0ECnPpAAAMu7PQPPY5mHeIyIiInvy8vLQuXNnbzmu0+CCF09TUXx8fKMJXqJKo4AmFf+Oj49n8EJERBGrOl0+2GGXiIiIIgqDFyIiIoooDF6IiIgoojB4ISIioojC4IWIiIgiCoMXIiIiiigMXoiIiCiiMHghIiKiiMLghYiIiCIKgxciIiKKKAxeiIiIKKIweCEiIqKIwuDFhlOlLry+dDf2HCsI964QERE1WgxebPjn91vx5NxtuOiZJeHeFSIiokaLwYsN76TtD/cuEBERNXoMXoiIiCiiMHghIiKiiMLghYiIiCJKnQQvL7/8MlJTU9GkSRMMHz4c6enp2u0/++wz9OnTB02aNEH//v0xd+7cuthNIiIiigAhD14++eQT3HfffXjkkUewdu1aDBgwAGPHjkVWVpbf7VeuXIlrr70W06ZNw7p16zBx4kRMnDgRmzdvDvWuarndRlg/n4iIiCqEPHh59tlncdNNN+GGG25Av3798Oqrr6JZs2Z46623/G7/n//8B+PGjcNf/vIX9O3bF48//jgGDx6Ml156KdS7qsXQhYiIqH4IafBSWlqKNWvWYMyYMVUf6HRizJgxSEtL8/uatLQ00/YAMHbs2IDbl5SUIC8vz/RfKBiGOXwpLXeH5HOIiIhIL6TBy/Hjx+FyudC+fXvT39u3b4/MzEy/r8nMzLS1/axZs5CQkOD9r3PnzsHZeSG7sNT02G0wF0NERBQOET/aaObMmcjNzfX+d/DgwZB8zsmiMtNjF/vAEBERhUV0KN+8bdu2iIqKwtGjR01/P3r0KJKTk/2+Jjk52db2cXFxiIuLC84Oa2zLNDdHlTN4ISIiCouQZl5iY2MxZMgQLFy40Ps3t9uNhQsXYsSIEX5fM2LECNP2ADB//vyA29eVmCjzV8XMCxERUXiENPMCAPfddx/++Mc/YujQoRg2bBief/55FBYW4oYbbgAAXH/99ejYsSNmzZoFALj77rtxwQUX4JlnnsGll16Kjz/+GKtXr8brr78e6l3VGprayvT4WH4JWjePDdPeEBERNV4hD16uueYaHDt2DA8//DAyMzMxcOBAzJs3z9sp98CBA3A6q7IaI0eOxIcffogHH3wQf/vb39CrVy98/fXXOOOMM0K9q1ptm8chqWUcjuWXAACW7zqO3sktw7pPREREjZHDkGOAI1xeXh4SEhKQm5uL+Pj4oL53mcuNXv/3PQBgWLfW+PSW8DZleRSWFqLFrBYAgIKZBWge2zzMe0RERGSPnfI74kcb1SW138upUlcY94SIiKjxYvBSQx0SmoR7F4iIiBolBi9EREQUURi81FC/lOD2pyEiIqLqYfBiU5vK4dF9khm8EBERhQODF5t6JFWM6uHaRkREROHB4MUmz5Q0nGGXiIgoPBi82BTldABg5oWIiChcGLzY5HRUBC/MvBAREYUHgxebPJkXBi9EREThweDFpihmXoiIiMKKwYtN3swL+7wQERGFBYMXm7wddpl5ISIiCgsGLzY52eeFiIgorBi82OTt88LYhYiIKCwYvNjEZiMiIqLwYvBiU0xURfBS6nKHeU+IiIgaJwYvNsVFRwEASssZvBAREYUDgxebPM1G5W4GL0REROHA4MWmyv664DQvRERE4cHgxSYHKqIXxi5EREThweDFpoKSMgDAoZOnwrwnREREjRODF5s+XX0IAPC/DRlh3hMiIqLGicELERERRRQGL0RERBRRGLwQERFRRGHwQkRERBGFwQsRERFFFAYvNg3v1jrcu0BERNSoMXixadLgTgCAi/q0C/OeEBERNU4MXmxyVq5t5Ob6AERERGHB4MWmytgFLjeDFyIionBg8GKTZ1VpJl6IiIjCg8GLTQ4Hm42IiIjCicGLTWw2IiIiCi8GLzZFOdhsREREFE4MXmzyNBu5GL0QERGFBYMXm6I4VJqIiCisGLzY5Onz4mafFyIiorBg8GJTeWXQsuFQbpj3hIiIqHFi8GLTZ6sPhnsXiIiIGjUGLzZdMbBjuHeBiIioUWPwYlOnVk1N/yciIqK6xeDFJs88L+ywS0REFB4MXmzyDJXmPC9EREThweDFJqdnkjp3mHeEiIiokQpp8JKdnY0pU6YgPj4eiYmJmDZtGgoKCrTb33nnnejduzeaNm2KLl264K677kJubv0Zlhwd5QleGL0QERGFQ0iDlylTpmDLli2YP38+5syZg6VLl+Lmm28OuH1GRgYyMjLw9NNPY/PmzZg9ezbmzZuHadOmhXI3banKvLDZiIiIKByiQ/XGW7duxbx58/DLL79g6NChAIAXX3wR48ePx9NPP42UlBSf15xxxhn44osvvI979OiBJ554An/4wx9QXl6O6OiQ7W61VS0PEOYdISIiaqRClnlJS0tDYmKiN3ABgDFjxsDpdGLVqlXVfp/c3FzEx8fXi8AFqBptxMwLERFReIQsIsjMzES7du3MHxYdjdatWyMzM7Na73H8+HE8/vjj2qamkpISlJSUeB/n5eXVbIeryVkZ7p0qc4X0c4iIiMg/25mXGTNmwOFwaP/btm1brXcsLy8Pl156Kfr164dHH3004HazZs1CQkKC97/OnTvX+rN1CkrKvf8+XlCi2ZKIiIhCwXbm5f7778fUqVO123Tv3h3JycnIysoy/b28vBzZ2dlITk7Wvj4/Px/jxo1Dy5Yt8dVXXyEmJibgtjNnzsR9993nfZyXlxfSAMYBh/ffbs71QkREVOdsBy9JSUlISkqy3G7EiBHIycnBmjVrMGTIEADAokWL4Ha7MXz48ICvy8vLw9ixYxEXF4dvv/0WTZo00X5OXFwc4uLi7B1ELXg67AIAYxciIqK6F7IOu3379sW4ceNw0003IT09HStWrMD06dMxefJk70ijw4cPo0+fPkhPTwdQEbhcfPHFKCwsxJtvvom8vDxkZmYiMzMTLlf96GMS37Qq3nNotiMiIqLQCOkQng8++ADTp0/H6NGj4XQ6MWnSJLzwwgve58vKyrB9+3YUFRUBANauXesdidSzZ0/Te+3duxepqamh3N1qSWpRleVxOhm+EBER1bWQBi+tW7fGhx9+GPD51NRUGErby6hRo0yP6yOHwwGno2Kel9X7svHWin145PJ+OD0lIdy7RkRE1ChwbaMa8Myye+v7a5G+Nxt/eKP689YQERFR7TB4qQFP8OJxsqgsTHtCRETU+DB4qQEnvzUiIqKwYTFcAzLzQkRERHWHwUsNMHghIiIKHwYvNcAR0kREROHD4KUGOL8LERFR+DB4qYEcji4iIiIKGwYvREREFFEYvBAREVFEYfBCREREEYXBCxEREUUUBi9EREQUURi81MCQrq3CvQtERESNFoOXGmgaExXuXSAiImq0GLzUAFcHICIiCh8GLzUQ5WeGXcMwwrAnREREjQ+DlxrwtzBjUakrDHtCRETU+DB4qQF/wYubmRciIqI6weClBvyty+hm7EJERFQnGLzUgL/MC/u8EBER1Q0GLzVQ7nb7/I2ZFyIiorrB4KUGFmzN8vkb+7wQERHVDQYvQXKysDTcu0BERNQoMHgJEgdnriMiIqoTDF6CJNrfECQiIiIKOgYvNdAs1ndtI/Z5ISIiqhsMXmqgzOVvtBGDFyIiorrA4KUGyly+gQqHShMREdUNBi9BwswLERFR3WDwEiR+5q0jIiKiEGDwEiS/HskL9y4QERE1CgxeguSb9YfDvQtERESNAoOXGujUqqnP3wpLysOwJ0RERI0Pg5caeOp3A3z+1j2pRRj2hIiIqPFh8FIDI3q0we2jemDWlf3RvHLCunN7tg3zXhERETUO0eHegUj113F9AADfb87E0h3H4OJEL0RERHWCmZdaiqpc0ojBCxERUd1g8FJLUZULMro4SR0REVGdYPBSS97ghZkXIiKiOsHgpZYYvBAREdUtBi+15HQweCEiIqpLDF5qyZN54cKMREREdYPBSy15gpdyZl6IiIjqBIOXWopisxEREVGdYvBSS+ywS0REVLcYvNQSgxciIqK6FdLgJTs7G1OmTEF8fDwSExMxbdo0FBQUVOu1hmHgkksugcPhwNdffx3K3awVdtglIiKqWyENXqZMmYItW7Zg/vz5mDNnDpYuXYqbb765Wq99/vnn4ajsT1KfMfNCRERUt0K2MOPWrVsxb948/PLLLxg6dCgA4MUXX8T48ePx9NNPIyUlJeBr169fj2eeeQarV69Ghw4dQrWLQcEOu0RERHUrZJmXtLQ0JCYmegMXABgzZgycTidWrVoV8HVFRUX4/e9/j5dffhnJycmWn1NSUoK8vDzTf3UpKorBCxERUV0KWfCSmZmJdu3amf4WHR2N1q1bIzMzM+Dr7r33XowcORITJkyo1ufMmjULCQkJ3v86d+5cq/22y5N54TwvREREdcN28DJjxgw4HA7tf9u2bavRznz77bdYtGgRnn/++Wq/ZubMmcjNzfX+d/DgwRp9dk3tOFrRAfmHLYEDMiIiIgoe231e7r//fkydOlW7Tffu3ZGcnIysrCzT38vLy5GdnR2wOWjRokXYvXs3EhMTTX+fNGkSzjvvPCxevNjnNXFxcYiLi7NzCEG1YOtRAMCR3OKw7QMREVFjYjt4SUpKQlJSkuV2I0aMQE5ODtasWYMhQ4YAqAhO3G43hg8f7vc1M2bMwI033mj6W//+/fHcc8/h8ssvt7urdaJfh3j8eqRu+9kQERE1ZiHr89K3b1+MGzcON910E9LT07FixQpMnz4dkydP9o40Onz4MPr06YP09HQAQHJyMs444wzTfwDQpUsXdOvWLVS7WitXD+0EALj0zA6YtzkTM7/cBINzvhAREYVMyIZKA8AHH3yA6dOnY/To0XA6nZg0aRJeeOEF7/NlZWXYvn07ioqKQrkbIRUVVRH/ud0Gbn1/DQCgpMyFZ68ZGMa9IiIiarhCGry0bt0aH374YcDnU1NTLbMU9T2L4RltVOaq2s8v1x1m8EJERBQiXNuolioTLygsKQ/vjhARETUSDF5qKcpZ8RWWutxh3hMiIqLGgcFLLXkyLyXlrvDuCBERUSPB4KWWPJmX4jJmXoiIiOoCg5da8nTYPVXKzAsREVFdYPBSS55mo8M5p8K7I0RERI0Eg5da8jQbERERUd1gyVtLjnDvABERUSPD4KWWuJo0ERFR3WLwUksnCkvDvQtERESNCoOXWmofHxfuXSAiImpUGLzU0u+HdfX524DOiXW/I0RERI0Eg5daahrr+xU2iebXSkREFCosZWvJ31Bpl7t+r4RNREQUyRi81FK003ewtMtg8EJERBQqDF5qKcpf8MLMCxERUcgweKklv5kXBi9EREQhw+Cllph5ISIiqlsMXmop2k+H3XIGL0RERCHD4KWWoqJ8My+7sgrCsCdERESNA4OXWopycGlGIiKiusTgpZYYuxAREdUtBi+15K/DLgAYnOuFiIgoJBi81FKgZqOCkvI63hMiIqLGgcFLLTkDZF78jUIiIiKi2mMJGyIG2GxEREQUCgxeQoRdXoiIiEKDwQsRERFFFAYvIcLECxERUWgweAkRDpUmIiIKDQYvIcLQhYiIKDQYvIQIEy9EREShweAlRA6dLAr3LhARETVIDF5C5FSpK9y7QERE1CAxeAmRmCh+tURERKHAEjbI2rWMAwCUu9nphYiIKBQYvASZJ+PiYvBCREQUEgxegiwmqmKhRpfbgNtt4Fh+SZj3iIiIqGFh8BJk0Urmpfvf5uKsJxbgp21ZYd4rIiKihoPBS5B5mo3eXL7H+7f/Lt4Vrt0hIiJqcBi8BJmn2ein7ce8f9txtCBcu0NERNTgMHgJsr3HC33+lnuqLAx7QkRE1DAxeAmy/OLycO8CERFRg8bgJQjiovk1EhER1RWWukHw9tSz0DIuGs9fMzDcu0JERNTgMXgJgpE922LDIxdj4qCOfp+fODCljveIiIio4QpZ8JKdnY0pU6YgPj4eiYmJmDZtGgoKrEfdpKWl4aKLLkLz5s0RHx+P888/H6dOnQrVbgaN01kxymjs6e19nhuS2rqud4eIiKjBClnwMmXKFGzZsgXz58/HnDlzsHTpUtx8883a16SlpWHcuHG4+OKLkZ6ejl9++QXTp0+H0xk5CSIHHD5/c3OpACIioqCJDsWbbt26FfPmzcMvv/yCoUOHAgBefPFFjB8/Hk8//TRSUvw3o9x777246667MGPGDO/fevfuHYpdDBl/cRbXOSIiIgqekKQ00tLSkJiY6A1cAGDMmDFwOp1YtWqV39dkZWVh1apVaNeuHUaOHIn27dvjggsuwPLly7WfVVJSgry8PNN/4RTlJ3pxGwxeiIiIgiUkwUtmZibatWtn+lt0dDRat26NzMxMv6/Zs6diOv1HH30UN910E+bNm4fBgwdj9OjR2LlzZ8DPmjVrFhISErz/de7cOXgHUgMxTt9mo+IyVxj2hIiIqGGyFbzMmDEDDodD+9+2bdtqtCNutxsAcMstt+CGG27AoEGD8Nxzz6F379546623Ar5u5syZyM3N9f538ODBGn1+sERH+QYvT/+4Iwx7QkRE1DDZ6vNy//33Y+rUqdptunfvjuTkZGRlmVdSLi8vR3Z2NpKTk/2+rkOHDgCAfv36mf7et29fHDhwIODnxcXFIS4urhp7Xzc8q0oTERFRaNgKXpKSkpCUlGS53YgRI5CTk4M1a9ZgyJAhAIBFixbB7XZj+PDhfl+TmpqKlJQUbN++3fT3HTt24JJLLrGzm2Hlr9mIiIiIgickaYK+ffti3LhxuOmmm5Ceno4VK1Zg+vTpmDx5snek0eHDh9GnTx+kp6cDABwOB/7yl7/ghRdewOeff45du3bhoYcewrZt2zBt2rRQ7GZIMPNCREQUWiEZKg0AH3zwAaZPn47Ro0fD6XRi0qRJeOGFF7zPl5WVYfv27SgqKvL+7Z577kFxcTHuvfdeZGdnY8CAAZg/fz569OgRqt0MOn99XoiIiCh4Qha8tG7dGh9++GHA51NTU2H4GUI8Y8YM0zwvkSaazUZEREQhxTaOIPM3zwsREREFD0vaIGPmhYiIKLQYvASZvz4vg7sk1v2OEBERNVAMXoLMX+bFxdUBiIiIgobBS5D56/Oy4WBO3e8IERFRA8XgJcjY54WIiCi0GLwEmW6el3mbj+CLNYfqcG+IiIganpDN89JYBcq8uN0Gbn1/LQDgvF5t0S6+SV3uFhERUYPBzEuQBZrnxaVMyJdXXF5Xu0NERNTgMHgJskCZlzKX2/tvB7vFEBER1RiDlyCLChC8vLFsr/ffTkYvRERENcbgJchiAnTYfXb+Du+/GboQERHVHIOXIKvO2kbMvBAREdUcg5cgq848L4xdiIiIao7BS5AF6vOiKi5z1cGeEBERNUwMXoIsM7fYcps5G4/UwZ4QERE1TAxegqy4vCqr0qpZDADfZiKu00hERFRzDF6CTI1TPE1IhoxWfP5ARERE1cXgJYSOF5T6/bubsQsREVGNMXgJA4MNR0RERDXG4CXIEpvFWm7DzAsREVHNMXgJsvN6tbXcpl+H+DrYEyIiooaJwUuQOaoxA52bHXaJiIhqjMFLsFUjLil3MXghIiKqKQYvQeaqRlalzOWugz0hIiJqmBi8BJmrGr1xy9wGsvKL8eDXm7D1SF4d7BUREVHDweAlyKozDLrc5cZfPtuI938+gEv+s6wO9oqIiKjhYPASZEkt4iy3KXcZ+JUZFyIiohph8BJkcrRR1zbNfLYpc7txLL+krnaJiIioQWHwEmJOP0OnP19zKAx7QkRE1DAweAkxp59pX/YcK6z7HSEiImogGLyE0G2jevjNvBAREVHNMXgJgY6JTQEAN4xMZfBCREQUZNHh3oGGaNGfL0BRiQutmsfC6afd6OzurfHznuww7BkREVHkY/ASAnHRUYiLjgLgv89Lu5ZN6niPiIiIGg42G4VYlJ/opTpLCBAREZF/DF5CbOOhXJ+/GQxeiIiIaozBSxi4uS4jERFRjTF4CQPZbOSuxmKOREREVIHBSxjIZqM1B06GaU+IiIgiD4OXMEjbfcL0eNG2rDDtCRERUeRh8BIGhaUuxEVXffUuNhsRERFVG4OXMCkpr+q163YbKC13I31vNkrL2ZuXiIhIh5PU1QNuAxj97GIczD6FkT3a4MObzg73LhEREdVbzLzUA27DwMHsUwCAlaI/DBEREZkxeKkHov2tIUBERER+hSx4yc7OxpQpUxAfH4/ExERMmzYNBQUF2tdkZmbiuuuuQ3JyMpo3b47Bgwfjiy++CNUu1hsX9E4K9y4QERFFjJAFL1OmTMGWLVswf/58zJkzB0uXLsXNN9+sfc3111+P7du349tvv8WmTZtw5ZVX4uqrr8a6detCtZv1QpSDmRciIqLqCknwsnXrVsybNw9vvPEGhg8fjnPPPRcvvvgiPv74Y2RkZAR83cqVK3HnnXdi2LBh6N69Ox588EEkJiZizZo1odjNeoMjpYmIiKovJMFLWloaEhMTMXToUO/fxowZA6fTiVWrVgV83ciRI/HJJ58gOzsbbrcbH3/8MYqLizFq1KhQ7Ga9kZlXHO5dICIiihghGSqdmZmJdu3amT8oOhqtW7dGZmZmwNd9+umnuOaaa9CmTRtER0ejWbNm+Oqrr9CzZ8+ArykpKUFJSYn3cV5eXu0PIES6tmmG/SeKfP6+K0vfF4iIiIiq2Mq8zJgxAw6HQ/vftm3barwzDz30EHJycrBgwQKsXr0a9913H66++mps2rQp4GtmzZqFhIQE73+dO3eu8eeHmr/ABQDY5YWIiKj6bGVe7r//fkydOlW7Tffu3ZGcnIysLPN6PeXl5cjOzkZycrLf1+3evRsvvfQSNm/ejNNPPx0AMGDAACxbtgwvv/wyXn31Vb+vmzlzJu677z7v47y8vHoVwHRq1RSHTp7SbtM0Jsr02DAM/PP7bYhyOvDXcX1CuXtEREQRx1bwkpSUhKQk62G9I0aMQE5ODtasWYMhQ4YAABYtWgS3243hw4f7fU1RUUVWwuk0J4OioqLgdgeeMj8uLg5xcXHVPYQ6V511i56dv8P0+EhuMV5bugcAML5/B5zRMSEk+0ZERBSJQtJht2/fvhg3bhxuuukmpKenY8WKFZg+fTomT56MlJQUAMDhw4fRp08fpKenAwD69OmDnj174pZbbkF6ejp2796NZ555BvPnz8fEiRNDsZt14kiu/c64Za6qYO1vXwVuMiMiImqMQjbPywcffIA+ffpg9OjRGD9+PM4991y8/vrr3ufLysqwfft2b8YlJiYGc+fORVJSEi6//HKceeaZePfdd/HOO+9g/PjxodrNesmBqk4wp0pdYdwTIiKi+idkCzO2bt0aH374YcDnU1NTYRjmJpVevXo1ihl1ddq1jINL+V7cBieBISIiUnFtoxBLaBpja3uX28Cnqw96H+8+VggAyCsuYxaGiIgIDF5Cbtzp/kdXBVLuNrBm30nT306VunDmoz+i3yPzgrlrREREEYnBS4hdN6Krre3LXb4jq3YczQcAsAWJiIiIwUvIndExARf3aw8AeHvqWZbbl7kNGDBHKd+sr1oPSvYTIiIiamxC1mGXqrx+fdUaTzFRDpS5Agcg5S43ThaVmf52qqyqr4vbAKI4Iy8RETVizLzUMV3gAlQEJ3Kto/ziMuV5Zl6IiKhxY/BSD7VtEWt6PGfjEe+/GbsQEVFjx+ClHrr1gh4Bnysp53BpIiJq3Bi81EO6pqVPfjmIU6UuTHhpOZ7+YXsd7hUREVH9wOClHlq5+3jA5349koev1h3GhkO5eOmnXXW4V0RERPUDg5d6aNnOwMFLSbkbLrHKtrsaK1cTERE1FAxeIkyT6Cg89M0W099Of/SHMO0NERFR3WPwEmHO6BhvuY3bbeBkYWkd7A0REVHdY/ASYTq3ama5Tfe/zcWgx+dj7YGKNZIWbTuKJTuOhXrXiIiI6gSDl3que9vmpsfqbLuA71pIZcrj695YhdyiMvxp9mr88a10DrMmIqIGgcFLGE0cmGK5TbnojHvnR+tMjw/nnDI9VoOXwlIX8pTZeV3s2EtE9VBWXjEHHpAtDF7CqGWTGMtt/K0yrYqOMv+Eu4+ZlxZQlxPIPVURyPyyLxubD+cCAN5ZuQ8jZy3E3uOFft//6R+2Y9bcrZb7WZeO5hXjizWHgpJJSt+bjZlfbvJ+N8VlLmTlFdf6fYkaguKy0GdrF2/PwrAnF+LW99eE/LOo4WDwEkYtm1iviykzL9K2I3mmx9sz802P1eUEtmfm42B2Ea56NQ2XvbgcAPDIt1uQkVuMx/5nHsEEAIUl5Xjpp114bekeHMsvAQAcyy+pkwxOcZkrYOA28p+LcP9nG3DNaz8DAP4x51dc+/rPloGeP1e/loaP0g/gqR+2AQBGPbUYw55ciAMnimq+8zUw88tNmDb7F64aXo8cOFGEuz9eh18z8qw3boC+33QEfR6ah/fS9oX0c55fsBMA8OOvR0P6OcG2Kysf+wJU+uqrj9MP4MWFO8O9G0HB4CWMqpV5cRs4t2fbgM+v2HXC9FiW356MAgCUlrvxyLe+QQoALN7u26F3i3LTLne7sfFQDs56YgGu/X8VQUNWfjH+39I9AUc2rdl/EusP5gAADMPA5sO51arJnSp14YxHfsDoZ5f4fd4TPHne+43le5G250TATsk/bsn0bhvI/spgJbMy67J4R5blftbG1iN5eGXxbm/26KP0A1i4LataHauLy1zYeTTfcrv6LDO3GJ9rsmel5VUncnGZC5+uPoisfPsZsWP5JXhx4U4crUE2bdo7v+Cb9Rm4/KWKQD+/uKzOApmD2UV1kvXYfDjXm2k0DAPrDpz03jNu/3AtAPhMzRBsVtem9M36w7jvk/Uh6cN36GSR9/6SmVuMN5btMTW9exSWlGPMs0sx6unFIa/Mfbb6IO75eB1Ky90oLXfjoa83Y0ENA70ZX27CM/N3eO8fa/afxJHciq4HecVl+HLtIe9CwDuO5uOpH7b5Pf76gMFLGJ0qLbfcptzlxvJdgSetk6tMu8UEdst2VhWGZS4Daburgh1/tfyMnFNYvD0LhmFgW2bVjdoBB15dshtARVMLAFz/ZjqemLsVd328zud9CkrKMemVlZj48gqUlLvw/qoDuOzF5Zj0ykq/x3HVqyuROuM77D1eiC0ZuSh3G96A4kRBCf6zYKdP/x7J301kV1YBbn5vDSa+vEL7WofD4ffvWXnFpozOrxl5KCip+N2Ky1x4c/le7D9R6P0stZDckpFr6oOk/vuS/yzDv+ZtwxvL9po+78VF1rMmX/VqGn7z3FLMr7yB7coq8FmJ3MMwDKzel+29ARmGUeNC0e02sGZ/Nk6VurzvpQbHh3NOeY/f5TawcvdxFJb4P8fHv7AMf/5sA16uPN70vdlYuLXieNJ2n8BpD36P1yrPt3/N24a/fr4RV7+aBgB4feluXPKfZd6g+R9zfsUVLy1HcZkLhmHgxnd+wcuVs0/f8t5qPDN/B6a+/QsAYM3+bIx9bikOZlecW4Ul5abv7o1le/D9poqFUHdW/t1zXo19binGv7AMK5Xr0U4/jeoWcmsPnMR5//4Jl1dmR2srUDZvV1Y+LntxOYY9uRAAsHBrFn7735UY/59lla8Lysf7dbKw1Hvd2HX3x+vx5brD+Dj9oOW2+44X4pv1hwP+TicLS73n8/2fbsC5//oJv/1vxb3i6tfS8I/vtuJvX27yeV1WZSYaqAq0M3OLA2Z/P/3lIG56d7X3s8pd7moHBX/5fCO+Xp+BL9cewger9uO9n/fjxndX+9123uYjGDlrIdbsr7hHu9yG9zNVOafKsPlwLia9shIjZi0CANz90Trc9+kG/PmzDQCAi59bipd/2o1/zPm1WvtZ1xi8hNHBk/rCGLBuNioXwUq5uOOo2ZO5m46YRiv5uzmN/OciTH37FyzefgyvLdnj/bvDAczdlGnadltlE5VnRuBv1h/Gw99shstteKN3ACguq6gtqPvjdhuYu+mItxD5ZV/FsO4L/dRk7vp4HZ5bsAOTX08L9DUAqEo778oqwKJtFf+u7g1Shi7ZhaVY8OtRDHtyIXr+3/eVx3kM419YhktfqLi5Pzd/Bx6f8ysufHoxjuWXYMyzSzD8yYUwDAMvLdqJS19Yjl6Vr1264xh6/V9Vgeyx6VCu6XGZn5tfcZkLj367xduUtamyv9Lnaw6iuMyFMc8uwZhnl3i/y8zcYm+A9fX6w/jdq2m4orIgvP+zDej/6A/e91q9Lxsv/7QLxWUulJS7cNmLy/B/X1XcrMtdbny+5pC3yfC5BTsw6ZU0TH07HQBw+wdrMeCxH7H5cC4KS8pxzj8XeY//1SW78fv/two3zP7F7/edXRl4/FSZ8bv6tTRMe2c1Dp0swl+/qLh5zvq+oinvh80V592+yn1+cu42bD2ShxcX7YJhGHhj+V5sPJSL7zcfwZdrD2PB1iw8Vbnu19oDOQAqMl0AMOmVNGw/mo/z/v0TAOC8f/+EMc8uwZr92dh6JA//+G4rbvtgrd99zsitCMzmVAY3j367BcOeXIgTBSV+t1eDhpW7j6Pfw/PwcfoB73NqoZJ7qsxbwH697jCAquBJvlfqjO+QOuM7bMkwnztARdZy3uZMb9A4Z2MGus2ciz9V/g4Pfb0ZI2dV/EZr9+eYXvtd5XEFqiTM+n4rUmd8V61MyZ5jBRj3/FJ8uyHD7/ODHp+PC55ajB0BMojVmafqeEEJDMPAD1syvX32ft5zAre+twaZlb/VqKcX4+6P1+N/G333IyPnFAY9Ph99H54Ht9vAF2sPAQA2Vl6TByqvJ09W+p/fb/MW5F9VbgsArsp9OHvWQox6ejGAit9rV1aB9zf96xcbMf/Xo/h/yyruqeNfWIYzH/3RVv+63FNl3oqjSj03bn1/LTJyizH1rYrf+8pXVqLvw/NwsrDUVGlxuQ0s3WnO8nquxR+2mLM6Gw/lwjAM3Pb+GjzyzeZq72+oMXgJo+xqXKBWwcvWI+aLXxb8i7ZVNX94bk4eJ8TnqxfBvZ+uR0Zu1U3Mf17C7O6P1+PdtP2YszEDDuUVnkJVNePLjbj9g7XeQkRVKDJSnqaxg9n6YO/zNRU3lDHPLsGfZq/Gmv0n8aTS2VjXJ8YtMk17jxeaajeGYeDb9RU3QE9G6LWleypfaw6Sfvz1KJ7+cYfp/a9/q6LA9xTIHvvFd6M2l3gM/PuPmL1yH85/yvxd/bDlqCmzceM7q5GZW4yzZy3E4MfnAwBmr9wPoKrg/3LtYZS5DLz80y7kFZfhd6+m4akftuP1pXuwaGsWNh/OwwerKgrYK15agT9/tgFnPbEAQFVWaFXlDfT7yqDireV7vc1tQMU5+N+fqjIqnr+tP5jjE5x5AjGPVxbvRlSALJj01oq93gAaAI7nl/qc4zqFJeXea/D7TZl4/+f93ud0GZXPV1ecZ7NX7sPxghK8m7YfWXnFuOW91VheGci/uHAnus2ciysqm5xufW8NSsrdmFFZi7/p3dXo+/A8ZOScwtoDJzHgsR/R/W9z/WZJUmd8h24z5+JukeG89IWK9950KBdvLd8Lt9vAI99uxq3vr8FdlaMSp39Y8X/PfeC9n/cjI7e44twVX/NxJQjL95MV8FRmPFnM5+bvwBw/QQFQUWvflpnv3Y9A7vzQ9/npH67FoMfn4w9vrAJQkbVInfEdNh/ONWX69p8owrKdx3HLe2twYWXQMPn1nzFvSyb++sVG03uu3V9ROXr02y0Y/cxiuN0GxijN0mXuwPeGgpJyFJaU49Ulu/HG8r04ll+CY8p35XIZuOW9is7GhyorpM8t2Ikxzy7BE2KwQ0ZlYLjjaEVg+tP2LLjcBu75eJ030HO5Dew8mu9zLhzLL/Fex0BFQH7gRBGG/mOBN9PokV95X9hQGWgu3XkMczZWXRtut4F/z6vewr5Oh6OycpCJd9L215tmJAYvYXRh7yTLbWSB2z3JPO/LmZ0STI/XVF6kHiV+CkMPmZXYfazqcU6ROEGrV54AANYdyIFa/mw94ttP4NPVh3z+5vHCwqoLsSBAs0MgaqC0Ytdx0zGl7akIgvwVEMt2HsfX66puxOViZW+X2/AW2v5EOasOWGZTdAXh1iN5plrm/hNFMAwD8zZneo+luCzwb+hUvujtR/OxujJd7AmCNgSoJX+z4TB2Hq2q2a/efxKl4lz71c/v5o98XXZhKQpFqnrq2+mY+PIKbyZKpf4ex/J9sxhH/fzN+9nK+b0/uxDRzuqfqPKG78l4ADAFYz6f6XKbmgcdDuBvX23GD1uO4g9vVhS4z8yvCF49tXhZqViwtSKY+HLtITym9EPLO1WOwhI1O1r1um/W+w8ULn9pOf4+51d8ue6w97pauE3fZ2v1vmxAnJbqvcKqhWvRtqP4z8KdmP7hOu8+/v1/v+KVxRWZRVnpevDrTbjjw7UwDMN0Tfu7vj2FrKe53BOIXPbicsxesc+7XbnbjQ9W7fd5PeB7b9t1rCILMnvlPuw+VojnF+5EkXKOOixucO+mVX1OqcvtDT48+yG9UNkp9s3le02/4ZHcYlMzZd6pctz/6Xp8vT7DG+hd+PRi/Oa5peg20xzM7swqMJUHO47m44EvNuJEYak30xiI2zB81sTTUbM0WfnFyC+u+p1mzd3m7yV1jsFLGCU2i7XcRt5EBnVuZQoMZHrVc1OsjjJRQBdp+uB40rCBqLW22Sv3mfbRboc2tXblaTKoLvWG9Ox8c/ajpMyNnKJSnPPPRX5HVxnK3VzW4MvdhjeNbEUOV3dZdB5Qb/Snylz4MP0Abn1/Dc7790+WnRJlkqK6WYviMjcSmlZ1GF+645gpYLMziuJoXjF+3lPVl0p2/i4uc2kXG1VPD4cDptpl7qmyap8/3208YgoirUZuZSjNIy7DMAVcsi+ZJI9nwdaqVLu/1L4M5jz2nygy7bPDWdFp1EPuhqzMqNdK+l5z530dv/cJG5epGuhXZOv2460Ve/Gveb4Fm9tt4P2fD+C7jUew53ihKbCw+p6lwznm70YNdtXvRmYwV+w6YboO54rr27A4+P8urgp0958oNH2u1fWtnr47j+abssEA8LUIStX7jHqPXrLjmOlaKHMZ3gqZlXs/2WCq6EjyWlEzpMcLSk2/k3p+hhODlzA6rX1L268pd7tNNzR54tshC4WCYnPwon6Ov9FIKtkEtkupmZSJz7EqVNT9WiE6K8vOZzJ489cPwKPcbeCFhbuQkVuMt1fs821X1+xWoI6n/nwvAi6rwlcWdv/3VVW78lvL92lfK99azvujEyWyFGpzXaBavj+/7DtpCnZeW2ru12NVPn2h9B+Q2x4P0J/EQ/2uTxaVmQot2XdDnnfqIzmKaJ5F0Kx+dTJbpDY/+aNm4lyGYSqg3CLDJ7+6zWI/L3txmfffJwoCNwP7e2x638O5pkLYKgZW+7J8t+mI6ZyVAZYanMv7iN2KTYxyfhsGsE7JLKbvq/rejvipbKmfJYMbf51aVSVK9vPpH7abAgx5DL7HX/U4I7fYlB2W16Akm1XV77ImU0MEIjP08mdRH17Yu13QPrc2GLyEkdWJ69GqWVUNOe9U8NobZTtvhia7Ivd0s7ioloohvurNTQ7rk/dQOfpFvTF8qaTyAd9ajjyG+z7dgEDchoG3VlSN7pGpbV0tMMfie/d0DPXH6gaty674q8mq5D7HRFX9UvLmJpuvZGGm3vBX7j6u3VaOblI/Sh7vZk1ACVSl2P2xKlQ2Hc4xPVabS+TPKX8GNdOkNi8C+uZWwNxcJ4Mkf80IKvWcPZZfYqrlyu/OZzSheKz2A3OK+4nMrOoyrRk5p0yfLa9JXdOnDHRkM6K6z4/P+dUUwPicK+K+kiG+W/V8WLwjy/wbywJXfFfq9S6zqIFG63mox7RFBJDyGIplICBOB7UjtlWQKDOgambZavSlz/Wu/FsGd/L7kMf02eqqkV0dEppoP7euMHgJI6tUpYfa5+EniwyIHS5xM9MNoZUdLWWNOC7afCqpnYHl3CXyqK0KKFWRzIDYqLjVZj6Gly2GML+yOPDzVv12/I0wCkTesHyDl6rfQd5Es0SGQH4dnv4KQMUszCqfG7Qs3JT92Ccm+JNZKxmsqee3nBbgvTRzFkMWSNHOquMd2DnR9JwsGHxG5rnV1Lj5u/HXcVqlHq8sYGV/KUl9ftnO46YRgDLAkAFYrI3Mmu54gaoO50BFRUr9buduNDer6JpGZIWqrNy3v5hKHa0k31c2ucq+R2rBL/uCyekOZAGty4jFNzXPuaW7V7RtEafdVmbxrIJZ3XvJ18YqlZNA0zt4yKyN6r/ifiXPWfm56m8mg9NwYfBSx64c1NH2a+xMxnTFgMDrJckZfeWoHl3w8oIovNVCAwD6dIg3PZ6vmURJ3pDstHvLtZ12ampM5/RsY3osbwwyeNTtxkGLdt7jBYFHjt336Xrta2WBpVMifqOf95iDDLXDqqy1+QbLgT/XJ0sh/qBmJprHRmknkJOfIkefqed3kQhktxyRQ8nN73b+aVWd3uUQ3pU+EziaX9s72XzOqqwKnE+VmqjaebPitfoM13YxPHi/Euyp71vxnPk31GVrfRZpFUGE/O7Uwt3pdGCD0tFcHoMumJPDoUtcYvFY8V7qIch7Tl9xH5Gf2z7eHDioZFkuf+9/fh84i9k0Jsr0WHfPlRUImbU4kmt+XpfVkdfZEjE5pvzNTNlxi2ZB3UhV+d0s26lvzlPf2iqwrysMXurY01cNwNjT2+P164ZUu3OlnYRBj3ZVo5H6JLdEs9iqi1KmEeVoElkz1xGxi62shuxYaOf4ZIAhO96pRp1mbpv1LVTM2zePC7xcg9WQddX0C3uaHstZkGWmpW2LwB23h6W2Nj2WhZfs46MGhpeJSc7k8ZaWBz6mnu1amB7L3/edlfu8/46NdvrMAWT+XH0h2j4+cBpaBslqx1gAaBFnLnRUMuDMFRmCgZ0TAr5W1kTlfBw+o/EUMhMjT52XNFm8V8U8QD59DzSnoSz4ZZOqro/EkRx9hUJXGYmLNv8GsnD7RTNKT2ZP5PHlFJkrBbrgTT5npy/wl2vNzdO6EX6SHBggM60rdwfuVPvDFvN18+riPabHuvuqfEpuqwsyZHZUlgXy+KPV5uh6soAmg5c65nQ68Np1Q3Hx6ck+bdTBoJ502zLzcV6vqqUF5IiHEnGCfiX6l4w7PTng5/j0J7BxQueKG7+d3uuxonlK14NeBiNyqOD/RI1Rd4OWx1ebFXBlJ+RWmlFnzUThLI9XDvFUO05KcjTZl2sDD1dv09y8T/KGpfYBatU88P4D/kbMmP/w+2FdAr5WFqJ2+nzJIOlHMfmWLuMlAwHZ9CnPQ9U2sb6YzOIkNjM3Uahk5qlJjPlzdE3NrcXvIPtmyGZE1fMLzAWwjHN0c3vIJmNZaMqMmK7VQX5X6qgmQP+byWHyuqauYd3MlYI9x83ZEavzTM1iy/uZncxEvFgi5qjIYOqalOXxyakcZDCzRdOMJCsJJ0XQqDaVBb/UqhkGL2GkK3hrqlSkYXWRu2znlXujZnEkeV/Q3SjUAArwnQJf1phaaDIgMkXrbzKtQPskm3bkTVU3r4ksvH/aXpXe7dK6mem5UxbT76eJmpiuJiNHZ8iv+dv15oBT179GZlrkJIUqedOUN2g1m7LnmH5YtbyZx0Sbf+8mSsr+tPbmjI9V/5FSzfOy384eOYRd+d5lwR/f1HwOynOnSUzgjI8kO//2alf9UYa69L30j+/MQ3DXHThpevzSouovyCeDRt19RJ4rstau9pGIjXZqm4mtOkr/rBka/J7o06Ir+OUIPzm6TjajSOPP6OD99x7RPCvvo+q8T5ed2cH0XC+L8113b5AVKNlfSAaC76QF7vNj9XubhqGzzwtVt9nIDllwyvSgStaYZLOR7sKRNU95sndrWxX4HD4pR2OYt5WjTf50bjfzZymdFGXworuQXOK5VxebU/JWBaNqS0aez7wo3s8Rx/Pm8r3a95I3CvUmKwMh6dsNIr1tcbNXA0FZa5eZNpUcPfXqUtmcUf3v7n0xkZis5akZMdl/RH63PqPNNMcvJ2yU14Z6Hv7h7K7ic83vJTtkTxgYuG+ZJIM3XTOhJK8V3USJUlJLc/+QjzRrAclrbrUI/PZq5v2R56xs6lH7tQzt2so7C7E/anMkANM1B/hmplS1yYBIVkGUtj+JeGqe0jQ0R3SE7iWaZ2VFrkdS1fNndzdni+Q1mJVnvn/bacqXFWk5jYTaH8ruQpqhwuAljNpY3MRq0qqUJ+Zq0XUWe3uFRSGrOfllVK/OCgqYb3ayZtI81lxrlRNmyc+9qE/geQV0tf5FImvx++Hm5okjNVhp2EPttGd3FJMM/NQgamjXVtrXetaA8rA6RdRMTKB1ZqpDFkg2BlDgaJ4Mis0v/llTIMttfTsSV39H1AKpW9vmptqk/B5lE6O8rmQ/D6mlEjTKWrwsdNSpEP588Wmm52T24N20fdrPHaKcP2oFAqjoAxeIzDzJUY3vamrtV5/V2TTTtwww1MflLgNDUwOf43J2aju1fPm91iZDoJtAtG+HeO15J/sWyQBM5XQ4TM2IMnhRM8ttmpuD0Q3iu5Kdn3WBniT7pekWiJX9g8KFwUsY6TqIAvZS0x5qZJ+s6QgJ+KbCL+7X3vRYV7uQHfwKSqrfF0GX6geAVaJD77wtgTuD6joZy7lnBoihtLJAtqJ2+FQDrmyb76MrgMvdBq4Z2jnga2PEUFk5Ykxn6Y7ANV4reafMn2MnYJsigsYDIhv43cbAna59RjmJG7S9kVrq9PeGKagqLCk3zV8h+4tIaq3eX8DZVAnQZR8YWaaO6Vt13TWLNd8Ttom1y6yyhWoBLjMPMhOjqk2WwgFzHxB5TqpTIaTvy8bgLoGDF6tRTr8b0inga+U380k1Vp0ORFawVB0Tm/r8DmoW22q0marcbZiCG3kPfkJpCtxwKMf0nGz66iqCVTkyU1LPd9nc7G+ZjvqGwUs9Jpt1assqkzNI3FTkyA6VXEtDvV5lKlTStUU7Hb7ZBR05t4edz92vaVKzQ95grfbpM7Guk1oAr9h1XNspU54TajbhjI6Bh/4CtZuRU86/ki6aFXS1ejX1DeibqwBzU5dsFjom5mORwUynVk0Dvm+pmAxOnQDwjeV70b9jVfZAV/MEzOfS6v2+56v6C64R57Oa1RnZo40pEJTNFfvEUGmricmKlAzoj6ID+qX9O8jNvR782t5qwRcoQ9QNwzyiTjYxyWBG7S8myXO0Sxtzk5QcBafymW+lmmtz+aP7ngtKynwyL+qoTjmJm4zz1YxYucttCjjl3C3qw0MnT2nvreocMNWhxlTyXLFqFagPGLzUYzXJvOhObl3zC+BbuOvSnbL/gJqy1M294u9zVFbZIkmOGpDilRqhHF0VKlZtwnJCtHVK/5IThaXa2nUPsTDnb5V5g+KbxPjM5aOSQ4WDabCmuUuOXFCn9Pc3akedy0Nm6eTILJka1w27VufuOHTSt3CSN3CdExbLFqhNnzK4UQvZ+CYxppq6nF9ENg2o/H136hwyH1auDu7RVJNNsCtVCSpkP6TnF5j7sBWJJmU1qyVHNI7ua848yIqBLuPXVQQ66iRt8Zrrwh85/Fn1855s3461ymP1/tYyLton0FGDuw9WHTA1wa4VnayvOzvV9FjeW9Vsmm4ASG8/S9Ho+q3Z6dMVLgxe6rGaZV4M5V8i5W6RGpZBhW5UhDzx7cyLoAte/F1OA8TK2Sq1ptbMz825Y6uqG5rVKCCVVaAXTG+JvkdySQSVnCyws3J85S4DI3tUTcw3qEuiaVs78/jYJWdrNn2u6POi3nA7JfpmStQCSgZ6r8hO1z4zkmpGstQieJXnltUindXt0DlvS6bpeOU5euBE4D5ddpt61OP31zFc9pHRUQMWf4ucquRwf5XMlLUTTVvye5d9YlS6laFtrv9o2V9Ed96t3Z/j/bfLMEx9VQaLa3LT4VzTvVT2UZSBv6SeO7rATk6MCJgzQjeckxrwtb3atcC5PdsGfD5cGLzUY7J/Q3WoNz95wVrdvGVtVLcYYb7owKibnVca3ad9wOf81QZ0tU/1pmEY5v4VY/q2N7U3y33UTbWuG67tz+SzAvdTCaVipaZe5nabmqC6tTEXRmpgE2y6wlo+p7any87cgH7YvcweyUB4gybrZacDZ0vx+8tAQddfrXlslGm/OioBWkyUw6dDulozl0tlBHNCMDWr4y/4srNMhbqpVcVF18flDYuRebIDq67/m27eIrurV1tR5/3p0rqZKXD4RJkluajUZZrgzR91pmOZIZotRl9JauXtO82EndJVQzpBrSrKe6FaVrjchqlTsS67W5cYvNRj1V24UaXeSLLyS8zNJhbLDMi+CGoaPaFpjClNLZunZK1e1/dA125dmxqSLPSinQ5trVZXSH67IcOng69OsG+OHqen6PuxnBIjOdS+KcfFcMczlD4dVmQNUadjYlPt8cdY3LzlhHi6LI6kK3BlQCkD0kvFnBtqU8iEQea0uQwidAX2H0Z0Ne2X2n+izGX4nHeZSuHlchvm4e3iq+inTJ4nmxAlmbWwyrza6YRtZ5JGtdIgRzVJ8nu2MyxXTsKp0l3rtXUgu0g7+kjtW2cVjHbU3Df9UX+zZZoh6D6vMwxT5kWeG+pITJdhmJrFRnQPXSXIDgYv9Yhct6MmmRc5+kIdvWCnaUe6qE877c3to3Rz+7puvpKM3MCd4ayaNiYNNo82eF1ZXM7tNvCB0s4/b0umqVCVF6hVAa12FpUF32/EqAD1vWVhXBu6PhyAeQjr3uOFpgyBHE0lRyfopPhpzgmk1OXW3pTfsqhdn6OkpM9KbaV9L7kGja7pRPYJkSl59Rw9u3tr0+gjqyREsaYi4HYb2lFQsi+Kmll0G4YpQySDQrUWL6/Ha4Z2NjU1y+9Gl8EE7I3cshMMqJUGqyBffq9yksaa8ndK6SpRwXh/f+R3PFH0Ldme6du8o5KDAWqamXO5De29UT1H5crndvqGhRKDl3pEDpOsSeZF3rDUph/dDdcftdd8abnbdLPsZ5ER0F1UduYJkJkHXSdifzdUdTcWitFTHS0KaPWCTZYjCMTxqZ0DdTPXAvb6Mi3aFnhkhiSHO24UhZWdWqx8raTeRI/ll+CYZmHGDLG6r/xN1YxgmcvQFnAye6YrcOW1IAPjvcocQeUuw/Tecp4XSdcEa1VJ0PWXKXcZpqYA2UymBrPlbsP0O7gNw5SpkdegXA5Dkv2LdHSZF3l+q/1UrLI7oepUL/dXzvNTV+RnygBbt8Ar4NtkY3eOqar9MJ8rctSeqqjUhbJ6sp6RisFLPSKDFat0uz/y5p6vFGh2hwarhYhsT7W6ydi5qHQzjsqLOzMvcNbGX5mnHoOcvVVOxHWWmDxLDV5krV32n9D1n5HsDO/WBWv+6FbdtaJOcGbVIVX+vnJ1ax05h4oagLjchq3apK4pxKpDq9p/Qt6crfZBDbjkd26nYzgAdG5dFUSXudymgFt2HFXX3yoXgZ6sTQfTaNGBfZ0mEB7VO8n0WB1tJfvKSVZNWzUlvxfD0GfHQkWeV5l51Q8YWzWL8WkasnOtqM3g5W63NvMi6WayDhcGL/WIXFisJpmXYNIFIFb9Z+wEL6f5GcbnIWtMutWL/dEFbLJWK0cr6G5u8mKP0wxrl30TrKb0V9kNXuwseSDJzqI6mzSLvMlFDa2o2aUylztofV7sFISyRizP3+FiSL4ueLcbvKhJHjtNu5l5xeYhujYCPzvBtue9VbrlAn7YUvNmBV0GoDZ8VueGvdmZ7ZCj/FTyM+VEmjpWP+0Qi9m51btbucswBZJW10p9Wc9IxeClHvHNvFT9PLKtvy5oh50GsfOf7r2s2ta7a4Z32m3TlsGM7oKV+6yrmewWSxjYuUHLNUas2BkxIlkFpNVl1eSi3wd9/xnf7av2Wa7A/OOv1Q90ZZZGLtQnO7+qTbDyK5dBoNWkjeq1IhfXs6KuFL5JzMCq/UybGRpdIStHZtWGnOfEit35Wzzyi8trFejr6N63Np9plVWzuvbVkZcLRXO0VXBiZ6mBusLgpZ5o0zxWm3mxW5sLhpyiwJOaWQUvdqat16X3sy3agP0NtfUoEClqXY0I8J0LQbdfckiunZqJbp8lu/2UajO01s5LdU2atdmHMpfbVsGqZipk1sJOs4BuWgDAt4lR7RMkp3+3M9w5Ntppet5qgkdJPUflIqy6Pl017SvhT5lFsKqbfVnSLSTrT02PI7uw1FTYq013taW7b9Smqcqqyc1qugrddZVlsc5baZAqNsHE4CXMvrhtBIaltsa704b5ZF7k6rv1idUMo7oFEyXdxS47e9ohA4oYm9+nmomRU377fJY4Bt08MXYmF7N7s9PV7PpbDJW2k0bX7VdtCka32zC9vrvFcOBgrXBbmw6JslCQAafu9zYMo1aZKt314W/SxlCw+r1rU/HSXXfJ8U1qNQRaDRrtZESssuC6ikwwm6pk05/s0yfJxXNVcv0tKZjzDQVL/S0dG4khXVvj01tH4PSUBAzsbG6zlJmY+sRuDUknWM0VUrZocpHr8ej4zD1icfHKWk+o2tMlWUDpbpxWaeVg7fJhMdmhbkFAyWWYg5faNIPZUZvPcbsN0xo0vpmXwO/tNuwFe3aaSWqzHISdSRqtAmyrrJaOLvBxG4b2nNUtrggEntLfitW1rQtWrYIkOxPAWU1+J+n6KVlR+w5aVSjqSsiClyeeeAIjR45Es2bNkJiYWK3XGIaBhx9+GB06dEDTpk0xZswY7Ny50/qFDYScNEuenJqlKyKargmqVTN7HVaDRa4UbTX/jHy+pm3bVr+xjGftdEq1rl0FJ1DQzahrRRaEZeXBq/HpCv7a9UUwj3STgaw8JrXm7hKZJit5Fk0HqtosBxHMUUu1mV9K1xSSlV+izbxYZdPU5i472VA7I9EAIEWdcsIiSLJqGlLp1jKqeL7ab2WLnQkKQylkwUtpaSmuuuoq3HbbbdV+zb///W+88MILePXVV7Fq1So0b94cY8eORXFxzZsOIonV0OgQThIZVqFqI7aiu/Zr+12rNzh/C+jV9HPlfSOYfRd099VgTrynI7Nlwcy86Ap+u+sEqWTQJzs3ygJYFrjh6M9mJZgdNGuTWbUKfHTnv9W1of4Mdu4zVteorFCoowtrc55Jcl4nKVQxRn1pQgrZIgWPPfYYAGD27NnV2t4wDDz//PN48MEHMWHCBADAu+++i/bt2+Prr7/G5MmTQ7Wr9YZsApizsfprVUQy3QUdzItdqqtg0O4xRDsdYblB6PpehGr+DStWE/4FS22GgsoCVmY8ZCAgz4d6UhaETDjmUwHsBfbBDJLl7ysD8kjX4DMvdu3duxeZmZkYM2aM928JCQkYPnw40tLSAr6upKQEeXl5pv8iVfe2wZuuOpJoJxqrh/MLhFq4aja6m71VLY8okgXzmqurflrhkpFbjO4zv8Nvnl0S1v2oN8FLZmbFnAzt25vXjGnfvr33OX9mzZqFhIQE73+dO4dndd9gcNbjDrqh1BgDlPoomE1QRI1VY7iM3Ia6JnV42ApeZsyYAYfDof1v27ZtodpXv2bOnInc3FzvfwcPHrR+ERH50K3KS0SkigrzCBJbfV7uv/9+TJ06VbtN9+7da7QjycnJAICjR4+iQ4eqUTdHjx7FwIEDA74uLi4OcXE1X88lUlwxIAU7juZbjhghIiIKtXAvX2MreElKSkJSUpL1hjXQrVs3JCcnY+HChd5gJS8vD6tWrbI1YqmhiI12mjp+fbshw2c1XiIionCwO89MsIWsz8uBAwewfv16HDhwAC6XC+vXr8f69etRUFA1C2CfPn3w1VdfAQAcDgfuuece/OMf/8C3336LTZs24frrr0dKSgomTpwYqt2st56+agB+N6ST6W/RNhdTIyIiCgWreWZCLWRDpR9++GG888473seDBg0CAPz0008YNWoUAGD79u3Iza1aI+Svf/0rCgsLcfPNNyMnJwfnnnsu5s2bhyZN9FOzN0SxUQ6c16stPl9zCADQunksYpQ03b1jTsNzC3ZU671iohw1Hq7ocDTc+WWIiKhmgrU0R02FrCo/e/ZsGIbh858ncAEq5nZR+9A4HA78/e9/R2ZmJoqLi7FgwQKcdtppodrFeq1nO/NiZtmFpaY2RquUnboYWmqbmk/nHMNsD0UAqwkeiRqLxjJolSVTPTP3rvMw+4az0LNdC+SJtUnUQGLJ9sBL1ANAirKibHSU09aaGaraThIXrPWZQrnIXLg7nlHtyUXqiMLNTkBtZxZuK3U1VHtA58S6+aAAeMXXM/1S4jGqdzsAwNxN5vltlu867v13THTgC8PhMF84MVEOWwW0nYX0dJyO4AUGMngJ5sVeXwq+cMVQ4VoANFhLDjgdDb8/mPyNIjHgDtc6ZeGS2Kz653eTIN7PdIJ5r2sfpHKiphr2FR/hijVrglw/IjXgc06HA4eUlX2jnQ5bBVSwTvAop72gSVJfKpuvgnmx15e1ZYLVRGfVj05m4Tq1ahpgy9ppHx+nfRwnfkPdKsC68zfK6Qhas1G7MN+QA5EzwAYz4NRdo21bBC6A5e8nJTQ1Bytx0aHLntZHVt+Pqq6W37C6TjokVL9/abgXCmbwUo9dPbRqtuAPbxxuek53U3G5DWzJqFomIdrptNUz3M5FJ6k3wiino1YTGan3a5lp0S2ylxjGGl5yfM07l6s3MLtBn/q5bVvoC2AZnNZm1V+do3nmNX7im5h/lybK6spx0fpztI3mfHc6HIh2BudWVpdZKFm42xHMwk43s/LxgsDr8lgF2y3izEFyk5ia/0a1uSdJdbXIqNU+q6d7nQUvFvvUTty/dMfgQAMdKk21N7hLK++/T0s2d+CNsnGzjhbNRlYFY5lmgT4rauQe7XRqlzyQtVxdvxarbJC67HxtAqball265qwBnRKq/T52g5fMvKqV160KYLnKsfraUNqZVWB6rH5X0U6HtiYnAyGV0+GwNeeEPM/U8/BofuDPCbbaNKOov3GoMmdWrM5RWfDpRjz2SNIPKghm4V5XgyetMk0xQQq47bC6N8SI53XfOzMvFJAuxWdn8a/oKKfpRmOVOjyYfUr7vI5am7bq8yKPQXcTjrOotWXkVhXATqcD/TrUbEI/WQm12ylNF7yo340Vq5tMr3aBF/F0OvTNdaFcBiDFRto5Tvk+opwObTZN51SZy1aTW/+O5iBSDbjrcn2n2vTbUpuR5LF3b1vz0YV2WO3/nuOFpseHcwLfV+py5emSEDUTX3CaeQJX3T2rb4d40zVaV79Zk5gon+ZblZ3riMELBaSmld1ispXjNmqIMaLvSe/2LTVbm9kd5RMtMjy6poCTRebRVD2SAhfITWy0l0c5HAhWpaapzVS3Ls1qFbyoaXarWm2zuMCjxw7nnArbuiNqEGlF7bdU2w63djJVu4+ZM0DqDVs2ddTGxf3aa58PVh+QQyeLTI+tRhYGqwkmNsoZtP5xfTtU/55UW6lKoBDMPk6yUrhXBG9yWzVb2FNTGQGAKwd3rN3OeT/XqW1itWpWUh2xca2HAoOXekwt+OVEcVa1nhHd23j/nb4v23Rzt1PA9LWZwVDXXoqJcsLOvU1XgNnJWlgFTXY0FZ87pm877fa6mot8L6mgpCrzYNV3ZoPFBFG1Cd7qalSImnnJLgzct6I67PRVkf041ELkjI7m811mkqwKGZXVNap73k5QILMWGw7lBtiyQrCaYKKcDtOK8JcPSKn2azu1amrKHlpdG8GkBqi9k+0FTZed2SHgcwu2Zpke54jKmaqik7kavAc+f52O4PXFkiNP5fvGWmTlT2tf9ZutO5ATlH2qKQYv9ZhaAMvMi9WNccLAqhtJfnE5Dpyoqp0ds5G1+VXp+GtXTJTTVgbgREHg/ZK1xe6aNvLC0nI4ghS8yKCpWay+VqtrdmhqI4vV3mbH34kDzQVHbTrhyoxYqOgK6Iv66INEqTYjtcxNqub3GZLa2vT43J5tq/2+hSX6ZjB5TasuG2AuJINV87ZiJwA5kG3O+CTa6IAcLbLBVk2dwbRqb7b333aCxJgoR9BGBMoRoLo+jE5H8Cpj0U6n6XNd4hw8YVGJCOYUFbVVf/aEfLRsEo3UNs3QMbEp2rWUvcD1BaE82dU2clmrv3ZYl4DvU5thxDFRDlOWR6bRZd+DlbtPmB6rWR8ZROgKkZyiMsvMRHXFRTtNbbsbD+nfd9PhwLVeW31eLGpAclixrmN0MF07rLP1RtW053hBwOes+mXJ/lG6792Keq0s23nc9FyZyFLYaXKx6sahq7nK61v9XIcD+O2g0AQztRlyHmVjSganyI7O2Xik2v2NdBUXuxZuy7LeqFKZyzDts50O+IC5U7LMvBQUB64wOBy+17eaAbFDZl5k/GyVTbEzUCTU6s+ekA+n04GF94/Ckr+M8qmVnGlx4egCdTm6xGq1arUJSmqtGXYom4HkEOZJFrXJrUeqsj6y0JDzXow9Xd+/QCWzFDrRUU7TBb7vRFHgjf1Qj9nOUFHZLn2VWKRTnUEZqLtF0nSZp9EiWyLPDVmr33NM1ydA/13VZsblG85JNT2WAYtagM/bYp4ossAim6KqTX8Qeb7/vKcqWxDlcPic/zU1vFtrU0FYmxEw/grZQKLECLFSiwEIHZXzfc+xQnRt0yzgtnIXBndJrNY+AdbNwmpw1iHB3iiv3cr5Hu10mjow65rMK4Im899qer1HRzlrlT2So5HCicFLPRfldHhPbLUwsKrF605ueVO1ug509zNdISJrYS3FPB92mlFkulI2Z/2w5Wi132uvRQCiBjdWF/o9Y3ppn1fb8u2MEFMDN8D35iaHHdfVLUWtHcvzSH5Xsh9LN02BI1kV/DuOBs7aWGlp0SlX13zxwaoD1f4cXZZmaNdWpscy+JavVSsYUU4H/rchw/u4aUwUurSu/nerknPkRFlkXnQdXKMc1c+82O2XJkcqNdcE0VNHdjM9VptgdZUtAGhq0Sx8NL+q4jdvS6blnEqByMzq4ZPm45O/p/yuThZVr49YtNOBs1JbmR7rmn7iRWfvqSNTTY/r08zODF4iyOvXDan2trqAQwYN5Rb57RW7qppz7vuNeaFMXdZGFmbbMs0Fspoat7qPyfeqTc3b6garTvBnlUa32g/11Yu2Bk5Rd25trsXJm7XVPcPO/CS697L6btKUpj2Hw9y516qpKy6IzWa1YdVuH6wJ7+TnqM218vhk8F0khrMPV7KfsgA5Veaq9qgZ+fNWVI6q/vihRXB2lugDpIqLMfdx000WGeV01HhV4t7tW+JXEdyr3lqx1/RY/R2sOoaf3T3w8QHAYrGm3HFNPz0d2V9IHo+8H8jgRTfvkSrK6TAN4Y6N1o8Qixf9luT9rz4t1Ft/9oQsDU1tjZd/Pxgf3XS25bbqyS5nlJS1ul422k/lTKeXnRm4CSYr39w8pQZBgDlVbLWEgbxoZKdSOxWCNftPap9XsxpWF6sumTKoS6Kpz48c3mxef6rmI1MAYOkO801VV5g9MK5PwOdG9AjcRAgA249WjSZzOhym4e1Wx6DLRIwUnxvKm6RVu72dpqHrzu4a8DlZSNx0fnfvv62O772f95seq9+dDGyA6jfXyNam5buO+0xaqKNb96xZbDTyle/u8QlnBNzW7ugZdS6eti19sye60Xm6UT9Sa816RHIel9rQNZkCviPIrDrSBuJ0OEwjQKOdDqTvyw64vTyf5XnFzAvV2KVndrAsYABzNmW4qE3I1Kmctl1H3nTkY3UooVXtYLtyUZW5DMy4JHChKmsA8hqyU1uWHYV1rDIAn685GPA52QdEdrK986KqJierm5k62zIAXGExKkQXkCaL4b9q58+dNppjSl1urFYCQasCSZd5kTVLO8HL+TYLFd3cPb8fHrjzOuC79osuICsoNQdBaidjf9+VrgC2aiauzbw+dprgumkmU5PfxZHcwJPSWQ3nlu4eXXWt+Ds31CyPnOdmiQjs1b5ntygBZaD39ghlt7I/nWNu6rpmqLljvNpMKJscAfO+qeeZnPzRaj6lVqJskOep2lx1+6ge2vcKNQYvDdSCrVVpaFmwP3x5P9NjO23PstYqI/Nh3fRpV/Pnmh/rbhyyYUveKNUgQ45qeugy8/F2FJ1ddfOaWHVg1A1JlsO1ZXOdnflU5E0kvqm+bX5XVuACSc0ItIiLxjfrD3sf21kqQI4OkRNcydPqiGaGVXXFdMC34JPHr7bF79Ycqz8yNa6OXJNBwCDR2VM2m+oKg4VbzU1B6jnrL/vTRzNRm9UoJ12NWAbRtaGLT2VwapXxsDMcXm2uiXY6cedFPb2Przu7q+neYVUZ+/2wquzCa0v3mJ7LE6N+pl9Y9Tm17RQ/XHNvlBVS3USDq/efNPWl+7/xfU2DCqadWxUIOQBc2j/Z+9iqGTxLXP/yetioBJ3/Xbxb+16hxuAlgv08czQ6JjbFd3ed6/OcrumjcytzZzA7qUCfSY2i1ZtGNOZuOlLt9zqvl7nGLO8N6hDur9YdNj0nAwH1GGQ/FJdYq2lkT/ONQhZIqnUH9U1MupuM/F5bxIlVdm30AdkohgIfzw+cRj6tfQtT1uuFaweZnlfPhyinw6cpQa3F/mOiOfWvm1r8s9XmLNRjV5xueqybHl6SfUDUmjdgron6e19dXyz5u/RTtpXNNXJIfncxC7SuMHjyt/1Nj9U+Xv5ep8tcWfbT0exH5xp25vVHN3+SHIliNZ3Dyt3Htc+r1FgvNtrc2XdQl0TT92kd6AV+Tl4LakC52k9zSx9lkjvdlBOA+TyT5O9rdW9Qp7DQLfCZX1JuCpTnbsoMuC3gG1QHa76sUGDwEsGSE5pgxYyL0L2tbxPBLlPwEjjgAID84ur3H1HbTwFzZiLK6TAN6QT0k2v1ELOVHhI97tWLUk6s9zsxdNhcIJuP752V5gJpTF9zZkbWxFWyn4407ozkgM85HcC406uebxEXeEFAK5tF8KK7YamfCfjOiaIOs/UXuKo15m+VIAHQF0iynV7WgGvTtCGDVas+AOoxyFmiZUZA13FUDkmWAYYu8JdzM5kWovRTgurey6pALioJ3G9FFpovimBWJZdH0B3vpWd2MDV3fLnWXMGwWqZAl7W8sLe5YqPWPwzDnAVxOsxzpnS0WKhyw0HztaQ258rpDNQg2d/aW+oMvZeLiQVlZvXtFfsC7pPsH2VnmL2sYMnzSHfVySZ0efxvi87P9QmDl0ZA1srkDUnOsaCbQkI2R6g35JNFZT6Bkm75eXmBvrNyn+nx52sOBXztJWeYbxTqKIIv1ppfJ+f1kP0HZDp4oI3FGGUgJN9XnSdEfq6d2SrlZFI92pn7HqiBkAzeZNCgFoRWqXA5OsPOPqszmQK1G0Fkt4OnOgpEFoTyhpy+N3AHRvm9y2PI0ozykoWIer77Ox5dYW4VvKidMOW8TPK1ut9QHt+bU88yPVZ3+7uN5iyr7Ag6VBmia2WI6Mdx3Qhzx9EtR6oCju83Z5pmJy53G6aKjxy+LIN5uZ/qQqUyOM+3WCxU/Vx5PzvDRt+62sxcK7sFyGt6/q+Bp5E4r5c5s3hhb3NTXk0XS60LDF4aAdk3Qdb6BnU23zh0qXA55bmcLMonIEkzZz1M+2Gx/LpuGKKd9me54KO8mcup+HVNI/eLJibdfsjvXd6g7NSuZN+iU6Xm72q0EkTJAkgWomot1Wqop2xylDN7yg6PquW7zB0lrW7Qsi+Sys7CjXeN7mU6l+SEfvuzqz/R4Kq95syb/C51Q4sNuZiq8l0v8FOgqB1LZcBlZxHHVs1F86T43nWZJhnoporru1CT4ZHkPssO6yqZ8ZELsZ7dzRyQqd9l7qkyUwVM9h+5V9MsLMkm50mDOwXYsoI6cjH3lDmjN/ksfTOSyndIsp1+iPrrfcdRc7ZcJe/BzeKqf56FG4OXBujnmaNNHbo+Sjf3RZA3EZmSlxMT6baVl5hsqy3VLAIny/2bNQWhZKcmLlfdtaqJ6uaCuEAUKvtPBB4l9PV6c5OLvBHqOijLKdDl4aa2NRcq6g1q7X59Glk3O6kk08iyuU7X5CYDO9l88+ClfU2PdZMWttIMYZV0q/kCvtkUnSvFNPzVncIeABaLUS5qtiDfYjj2dKVDKmCvZu6TeROPT/kZau0hs4MOcYU/N3+H6XGpq+q9fJqcRAHcukXg31B+q3JCS7lf6mSBhmGYmpXPEf2U7PTpk/cGmRHSkaeGnFZCxydLZ+P3lteZDMD2aK4HWSmyU6GS129dY/DSwCx74EIkJzTBn85N9f5N1p6sarGyY6lKzgTaRAZCmo5mcpipLETa2rjY5UWnW8JA3gh9airi4tcNS5U3Cl0nVDlLrux7orupyuY2ORfH5WJ+HfWGJT9Xfs921kG6Z4y51tqvgzkVrh6D7OOwX8xk3El0FJeBru7cGS2mbdf1pTpoI7Pij9rZ95L+5uZJXaZNHr+cyddO9iihqfn3l4WKXC5CJSvt54gO6roA7PGJ5k7W8nBl0PX+z1VBhAy4ZQVDNxRcnpJydW9dPxa5wGVtpiKRFQo7TZ3yeO3shs/oSae+0qCSp9XF/czNZLqARGbH7ARNuopLXWDw0sC0bV7R5DGgU6L3b7eP6ukzakRHd8HKOTVkp8xbLgicPblKzF0gbzp22ogl3UJlcvi27EGv65sgyeNVO+xZsUrvqkpF59c2zc1NWTIAUW9C6sR4AGCIem0HGytWd0w0byvTyuoNWxbsstDsLuYIkUevW69Hfle/0fQ1ktvKEUMymyKpMyzb6aDbN9lc4PZqbz437BSqsjCTAbUMBFUy0yLXo9J9z7Lzv53CW/7+ch/Vafv7iOtGBufyGr1E6Rgvs4FWq27I5jsdOUpNBhF/OLv6TUHdbCwgKT/HqoKlkt+7z8zOCYGvdxkk6rLBcn6wWXO3Bty2LjB4aaB+o8x10ju5Jf5wdlf8Z/JALLr/AgD6TIVsb1ULHavFyGT/EtXks8zBi7xA+yQHHkpoRTf6xqp7jNwPNTCQTR2yBiiHzupYzVaprjorh3dPtljNOTY68EHK1L+dzIu8mclXqoW7bPOXfVjk58qbrq5zt7x5X6iZI0RuK2/ed4lh1+rEirKZwCrQvVR5bUm5uQCW0+P3amcusHWZCDm8Wb6XLqjQDckFgHJNaS9/E90+SlbBudoXJ7FZjOl5q9Y4db9kx2Z5rchYRffWch4fmR2T0/HIEWQqOTGk3FY7n5QIOHzmwNJc3zIDIl8rByyoZGCva46XC1za6f8UCgxeGiiHw4Fv7jgHL/9+MAZUjp6ZMLCjt7CdoFlZWa0FXDusC9750zAAVVkX3RBIeTNQNY+NNqXSE0U/Bl2tVs7z4UMToVhVvHS1nGeuGmB6Tu6i/NRbLzDPOqlOECYLVVlQqP065D5btb2HamZQeTOXhUyU5nPlPqWIIELeKNXsgjzHZOCja9pbfyhHu22qyACpzZky6+azFpD4MtUATWbLZBAhp9afOb5qRmldkxng+13qmq90WSnAXLGRZGFtZ54P2TFaUkfxxUVHmSozVvF0nGZWZLmP8nKX15JaYI86TT9Rnu81W/VvOSuu1SKNuqVUrBbLveX8wLPZyiYl+X2ozeYdE5uaAlK5rZ3fO9xLBTB4acAGdE401QxVVw/tjH9POhMLKzMxHlcMSMEk5WL4v0v7onPrZtjz5Hi86wlixORyKnlTVW+UDifQV1MrVK8F2aZv1R9Gdx1ZdbL0aatWHspau7y45XtfL4Z46m66Mg2rdliWN1yZPZHUwk1+VykW2TLdJH1y4jH5Xcnn35s2zO8+Ab7f3ag+5vNIzYCoM5tWh1q7tFo1WlLPWdnEJskMn7q6cZFYDkBeC/JmrzZBttOMcPP3WvXhWWJIslX5o5sKwGqZjZnKEh5ymnpdPxypRVw0mtv4nWQWQ139WF6DsplI9sVRH8tmE8lnGLLyxct+V1bf+58v7u3990yxFIoMbOX1r1tTStfRHTD3iYmNdtoKOnT3hvH9/ZctdYXBSyPldDpw9Vmdvc08e2eNx6L7L8B/Jg9EQtMYLH/gQiz+8yjvCAL1oi2zamRWPHRp1dT8DujbbtXCLaFpjOkmY1UjkGuuqGl22bdGUlO2cr0O3XXeI6m5T61eLdzPPy3J1O4vRwGowUurZjGmx/+adKZpW93hj+jextTUJ0eLJVgsQzBFWc/ntPYtTMfsM9xVFDiyn1LX1lW/g9VwT5ltmDAwBWd0jEdisxjLNYYkNQPyzNUDNFv60p1b8syRa7+o/S9kGt3p8O2fEei9OiY29S5rYRV8xUQ5TAXHlWIUm9U6SOqwYpnRtCrXzlXmBZEZLN056nSY+960bRFr6tcjO4JbWfbXi7z/lte3vNxlEJ3apmq/reZ0aiEygGolollslKmpF/AdlBDIhIEdtSvSy/NODThkhsdq5KU6+sowDJ/gRS6nolLXVJOZtYmD9OurhRqDFwJQcQPvntTCeyPv1KqZz83JQ3b48xQcr103xHQDi3I6TMMj46KjfNLSKvVmNnlYF3xy8wjv46YxURiW6n9tkLNSW5kmrXvosn44p0fVBWvVnq72tbhnzGm4TQlgHHAEbKs+r1eSqUbUrmWc6caQ0DTGVPvWFZJj+rY3BYj9OyXgUqWA0hUMZ3SMN92go6OcPlPz66hB079/N8A0T0ZcjFNboKnBS/PYKFNBYrW4ovq73HFhDzgcDsy58zysf/hinxFiOg6HucDSrf7rr3O27vjUYFvOvSLf70/nppom/YqJcsIdIM6/e3Qv9FRmmP7b+L7416QzcddFPfG/O32X+wCqMhuf3jLCVPDJwjupZZy2U7J6zg4W2ROr/lBqvzSZhdINZ5fXYMsmMabZqX87qKNPFkTXPJ3QLMY75H+smIROZjRN7xkXbQr8opwO3Fi5FpDs/+F53uORy/uZzpWUxKamPn4OOLTZJzUQatMiVnuNdlH6PHVr29wUoHxyy9mm399qzis1a3XFgBTT2kdAxX37h3vOx84nLvF5rXr8vx/eBfeMqQp25fIudY3BC9kmsxwrZlyEff+8FGNPTzbV1H/Ttz1axEXjf9PPxdy7zkNstNNbC/B3vcVEOTHnznPx0U1no2e7FqabbPek5kgSqXVPm/OdF/UyXdxnd29tyja43IbP4nTNTFOCR2Hxn0dh8Z9HITbaaaphOJ2Bgx/Pe3hq1wvuv8BU6Ca1iLNMJXsKgDH92vusOSWDqEBaNokxBQpOh/XU7Co1qDIMw9ScERvlxMxLKuZzkG38stZ5x0U94VIK0oSmMd5Ofv4moFO/mxvP9R2l5lmTySob8OktI1CmRAkOhyPgireebJCnmemJ355hylTIWnvzuGgs/cuF+Ou43j5rRHVp3cyUibrtgh6mwiwmyunTsfY/kwfikjOSccsF3eFS+sgktYxDq+axuO/i3j6VBk/Q/u/fnYlNj16MQWKF8dbNYn3W1XlswumYdm43fH3HOT7fQVx0lPd6Gdg50dS0W50FIB+8tC/6d0zAnRf1FE0wCVg54yJMGd4F8+89H0DFookA8OeLK5ofnvxtf4zo3gY3X9Adp6dUBb5OJ9C7vTl42fToWPz697HYO2u86e+eAQQ/3HM+lj9wIfp2iDfNots8Lhrv/GkYeiQ1x5e3jzS9dmCXRFOwF+V04G/j++L7u8/zNotLD17aF2P6tscfzu5qOr+bxEThdtG8eeuoHrhmaGfMvqFiZuJrKzvaP3J5P0Q5Hdjy2FhsfmwsYqKc2gBdPSf7d0yAw+HAU787E49e3g89klqY+uI5HFWjsaaIjKXn7/+ZPBCXndkB94w5zWdRV4fDgd7JLX0qG73btzSdv22ax2H6hT2R2qYZJmr6TNYVe43DRADuGdMLLrfhs5aHx4L7zsfnaw57Z1/t36nqJnXjud3RqlmsKTOiks0Qn906AvtPFFXesM3Tuj94aV/cOqq7T3t4TJQTfZWhmIZh4JHLT8eOrHxvISkLKbXAaNsiDr8f3gXRTgdaNonxaUP/+4TT8c36DNxS2Tn318fGodTl9t5wBndJxNoDOZhxSR98v9k8hfrz1wzEPZ+sxxe3VWSVFv95FHZmFeCs1FaVmYdzfYIiwH8B/tTvzsT3mzMrCillZWinw4HLzkzB3E1HvMPE/ziiK95J22/ZqdDlNkyddJ1OB248rxsuPr29tzb4zFUD8PSP272F+ewbzsLi7cdw47ndkZVfNUz7uhFdMWFgR7ybtg9Tzjb3BQIq+nx4+rbI5hgAuPzMDkhqEeczisNj2V8vxLGCEgzu0gorxRpUvx3UEf9dvNtnBJMnEH34sn647YIeaBffBHnFZXi2cvI1hwP42/g+eHLuNu9rurRphttHVRVSb/5xKJ76YTueu2Yguic1x49bMnFOz7Z+M2tvTz0Ld3+8Hn+fUFHLnjCwIyYMrMiKZJdVTYZYnRmjHQ6Ht8BTa/EX9mmHdvFN8FF61ZwrLZvE+KymDgD9KkfPbfn7WJSUuxHfJMYUNPsrUKOdDpS7DW8258bzuuPG8yquo1m/7Y9rXv/Zu21KYlM8oSxI+egVp+O6EV3RqzLL9PvhXUxNglcO7ojM3GL0TY7HlYM74ou1h0zTHqhNTef0bIMVu07gvRuHA6go4D3Nsndc2BNLdhzzTu53wWlJWHj/KJ9jiYlymvrIRDkdcDodplGF1w7rgo/SD3hXrlaPV55P8aKS0Cw2Gv/6XVWT7xMT++OW83t4s0RqsCuD/2HdWiN9b7ap75dKnWpCjoJ89uqBuOasE96s6YBOCdhwKBd/HVfRt0Y97y7ul4yUhO0YEiCT7TGgc4Kpc6+nMrn4LxdqX1dXGLyQbS2bxOBRTcqzZ7uWmCE6pHnERjstV19VnZXaGmdVXmQPjO2DtN0n8McRqQAqClY1cLnlgu44ll+CXu1aoHvb5njomy0AKm5YXdo0M7WTW3XMVFcE7tiqGfKUid+uH5GK6yv3wbMfTZxVNaUvb6+q7V5+ZgryTpV5a8sTB3XERCWl36p5rGkeGjV4U2Mmh8OBGZf0wT+/34YzK4PBq4Z29t7QJp/VBf/31WYAwBUDUxAb7cQbf6xal+bhy0/Hb/olewPJV6YMxm0frPWpmbrcBvokt8T/Npg/u6vST2DSkE6mTt2jerfDqMo1UTq1aobbR/VAiybRaBZb8Z/nBqrydPb889jePs+pnyuneld1bt3MO6R4wsAUPLdghzfT06t9Syz764W+s5waVe/drvLGrGaarh+Rqp0XA6hYikFdjuHtG6pq7L8f3gWzV+7zNh8N794GP/9ttN/3UWek9TfU3xMEXzXUtykiLjoKy/56IQyjohAf0rUV3ps2zNSfwx/PuRMXHeXNklrN5fLjvefjm/UZ+JNobgAqju+dPw0LuMholNOB09oHngvp2asHev99Ts+2WHj/BQGXifjgxrNhGIbfILF/pwRsfmxswM6oU4Z3wQerDuCu0b1MGV1/yy48PuF0/OHsLj7z9gAV/YvWH8zByACVL8npdARsfu/VviXevuEstK+8h/2/64ZiwdajGKtZ7NVDPUdjnE44ox3eaxAAvrhtJApKyn1GdAIVAdSyBy4K+F19cdsIfL7mMB4Y1xuJzWLx3ymDfYbq1wcOw84MPhEgLy8PCQkJyM3NRXx8zecNiSSFpYVoMauitlIwswDNY6s/OVK4vbhwJ56ZvwM3ntsND/qpKUput1HteUr+s2AnThaV+g20ZnyxER//chCDuiTiq9t9U+uqfccL8fc5v+L2UT0w1KK2Ekw7j+bjN88tBQDseXI8DAA/7zmBMzsl+K0hnyp1obC03DK74k/qjO8AAKsfHIMWcdF4c/leXNi7neWcITX9nDF92+ONPw619dr/Lt6Ff8/bjkcv74ep5/gWpLlFZWjRJNrvTdnzudFOB3Y9Od7n+V1Z+dh6JB+XD0iBYRh4cu5WpLZtjinDfTNGVnKLytCySXS1zlPPtPb+RpOcKnVhZ1a+t9mgNnYczcf/NmTg5vO7+5w7JwpK8Nv/rsSVgzvinjGneb8rANj3z0tr9bn1hWEYKCp1eTMf2YWliHI4LDuzW9lzrAAXPbMEALD9H+NsrUFlxfM73HlRT9x/sW+Qn1dchiiHw9aorfrOTvnN4KUBiOTgxTAM7DtRhNQ2zWp9g7bjVKkLP/6aiVGntav1DSxU1OBl76zxIf1+jheUoLCk3JRhCQXPDfk3/drj/11vL3gBKgraNrUIzqKcDuz2E7xQlYYYvIRKUWk5+j38AwBg95Pjgzr3ycrdxzFvcyZmXNLHZ5bkhspO+d04vhGqtxwOh08H4LrQNDbK2wZcX/VIaoFBXRLRullsyAO7ti3iapSxsevm87vj9aV7cP/F1V/pV1WTwAWomI5+W2a+dlgoVfjwxuG479MNmHVlf+uNG7lmsdFY/sCFiImyN39KdYzs0bbazVONETMvDUAkZ15IL1AbfyQrLXfbWgAuGI7ll+D7zUcwcVBHn/WpiKh+YOaFqIFoaIELYG/l2mBJahln6mRNRJGN87wQERFRRGHwQkRERBGFwQsRERFFFAYvREREFFEYvBAREVFEYfBCREREEYXBCxEREUUUBi9EREQUURi8EBERUURh8EJEREQRhcELERERRRQGL0RERBRRGLwQERFRRGlwq0obhgGgYmntxqKwtBAorvh3Xl4eXLGu8O4QERGRTZ5y21OO6ziM6mwVQQ4dOoTOnTuHezeIiIioBg4ePIhOnTppt2lwwYvb7UZGRgZatmwJh8MR1PfOy8tD586dcfDgQcTHxwf1veuDhn58QMM/Rh5f5Gvox8jji3yhOkbDMJCfn4+UlBQ4nfpeLQ2u2cjpdFpGbLUVHx/fYE9KoOEfH9Dwj5HHF/ka+jHy+CJfKI4xISGhWtuxwy4RERFFFAYvREREFFEYvNgQFxeHRx55BHFxceHelZBo6McHNPxj5PFFvoZ+jDy+yFcfjrHBddglIiKiho2ZFyIiIoooDF6IiIgoojB4ISIioojC4IWIiIgiCoMX4eWXX0ZqaiqaNGmC4cOHIz09Xbv9Z599hj59+qBJkybo378/5s6dW0d7as+sWbNw1llnoWXLlmjXrh0mTpyI7du3a18ze/ZsOBwO039NmjSpoz2279FHH/XZ3z59+mhfEym/HwCkpqb6HJ/D4cAdd9zhd/tI+P2WLl2Kyy+/HCkpKXA4HPj6669NzxuGgYcffhgdOnRA06ZNMWbMGOzcudPyfe1ex6GiO76ysjI88MAD6N+/P5o3b46UlBRcf/31yMjI0L5nTc7zULH6/aZOneqzr+PGjbN83/ry+wHWx+jvmnQ4HHjqqacCvmd9+g2rUzYUFxfjjjvuQJs2bdCiRQtMmjQJR48e1b5vTa/d6mLwovjkk09w33334ZFHHsHatWsxYMAAjB07FllZWX63X7lyJa699lpMmzYN69atw8SJEzFx4kRs3ry5jvfc2pIlS3DHHXfg559/xvz581FWVoaLL74YhYWF2tfFx8fjyJEj3v/2799fR3tcM6effrppf5cvXx5w20j6/QDgl19+MR3b/PnzAQBXXXVVwNfU99+vsLAQAwYMwMsvv+z3+X//+9944YUX8Oqrr2LVqlVo3rw5xo4di+Li4oDvafc6DiXd8RUVFWHt2rV46KGHsHbtWnz55ZfYvn07rrjiCsv3tXOeh5LV7wcA48aNM+3rRx99pH3P+vT7AdbHqB7bkSNH8NZbb8HhcGDSpEna960vv2F1yoZ7770X//vf//DZZ59hyZIlyMjIwJVXXql935pcu7YY5DVs2DDjjjvu8D52uVxGSkqKMWvWLL/bX3311call15q+tvw4cONW265JaT7GQxZWVkGAGPJkiUBt3n77beNhISEutupWnrkkUeMAQMGVHv7SP79DMMw7r77bqNHjx6G2+32+3yk/X4AjK+++sr72O12G8nJycZTTz3l/VtOTo4RFxdnfPTRRwHfx+51XFfk8fmTnp5uADD2798fcBu753ld8Xd8f/zjH40JEybYep/6+vsZRvV+wwkTJhgXXXSRdpv6+hsahm/ZkJOTY8TExBifffaZd5utW7caAIy0tDS/71HTa9cOZl4qlZaWYs2aNRgzZoz3b06nE2PGjEFaWprf16SlpZm2B4CxY8cG3L4+yc3NBQC0bt1au11BQQG6du2Kzp07Y8KECdiyZUtd7F6N7dy5EykpKejevTumTJmCAwcOBNw2kn+/0tJSvP/++/jTn/6kXYA00n4/1d69e5GZmWn6jRISEjB8+PCAv1FNruP6JDc3Fw6HA4mJidrt7Jzn4bZ48WK0a9cOvXv3xm233YYTJ04E3DbSf7+jR4/iu+++w7Rp0yy3ra+/oSwb1qxZg7KyMtNv0qdPH3Tp0iXgb1KTa9cuBi+Vjh8/DpfLhfbt25v+3r59e2RmZvp9TWZmpq3t6wu324177rkH55xzDs4444yA2/Xu3RtvvfUWvvnmG7z//vtwu90YOXIkDh06VId7W33Dhw/H7NmzMW/ePLzyyivYu3cvzjvvPOTn5/vdPlJ/PwD4+uuvkZOTg6lTpwbcJtJ+P8nzO9j5jWpyHdcXxcXFeOCBB3DttddqF7uze56H07hx4/Duu+9i4cKF+Ne//oUlS5bgkksugcvl8rt9JP9+APDOO++gZcuWlk0q9fU39Fc2ZGZmIjY21iegtiobPdtU9zV2NbhVpcnaHXfcgc2bN1u2sY4YMQIjRozwPh45ciT69u2L1157DY8//niod9O2Sy65xPvvM888E8OHD0fXrl3x6aefVqsmFEnefPNNXHLJJUhJSQm4TaT9fo1ZWVkZrr76ahiGgVdeeUW7bSSd55MnT/b+u3///jjzzDPRo0cPLF68GKNHjw7jnoXGW2+9hSlTplh2jK+vv2F1y4b6gJmXSm3btkVUVJRPD+qjR48iOTnZ72uSk5NtbV8fTJ8+HXPmzMFPP/2ETp062XptTEwMBg0ahF27doVo74IrMTERp512WsD9jcTfDwD279+PBQsW4MYbb7T1ukj7/Ty/g53fqCbXcbh5Apf9+/dj/vz52qyLP1bneX3SvXt3tG3bNuC+RuLv57Fs2TJs377d9nUJ1I/fMFDZkJycjNLSUuTk5Ji2tyobPdtU9zV2MXipFBsbiyFDhmDhwoXev7ndbixcuNBUe1WNGDHCtD0AzJ8/P+D24WQYBqZPn46vvvoKixYtQrdu3Wy/h8vlwqZNm9ChQ4cQ7GHwFRQUYPfu3QH3N5J+P9Xbb7+Ndu3a4dJLL7X1ukj7/bp164bk5GTTb5SXl4dVq1YF/I1qch2Hkydw2blzJxYsWIA2bdrYfg+r87w+OXToEE6cOBFwXyPt91O9+eabGDJkCAYMGGD7teH8Da3KhiFDhiAmJsb0m2zfvh0HDhwI+JvU5NqtyY5TpY8//tiIi4szZs+ebfz666/GzTffbCQmJhqZmZmGYRjGddddZ8yYMcO7/YoVK4zo6Gjj6aefNrZu3Wo88sgjRkxMjLFp06ZwHUJAt912m5GQkGAsXrzYOHLkiPe/oqIi7zby+B577DHjhx9+MHbv3m2sWbPGmDx5stGkSRNjy5Yt4TgES/fff7+xePFiY+/evcaKFSuMMWPGGG3btjWysrIMw4js38/D5XIZXbp0MR544AGf5yLx98vPzzfWrVtnrFu3zgBgPPvss8a6deu8o23++c9/GomJicY333xjbNy40ZgwYYLRrVs349SpU973uOiii4wXX3zR+9jqOq4vx1daWmpcccUVRqdOnYz169ebrsuSkpKAx2d1nteX48vPzzf+/Oc/G2lpacbevXuNBQsWGIMHDzZ69eplFBcXBzy++vT7GYb1OWoYhpGbm2s0a9bMeOWVV/y+R33+DatTNtx6661Gly5djEWLFhmrV682RowYYYwYMcL0Pr179za+/PJL7+PqXLu1weBFePHFF40uXboYsbGxxrBhw4yff/7Z+9wFF1xg/PGPfzRt/+mnnxqnnXaaERsba5x++unGd999V8d7XD0A/P739ttve7eRx3fPPfd4v4v27dsb48ePN9auXVv3O19N11xzjdGhQwcjNjbW6Nixo3HNNdcYu3bt8j4fyb+fxw8//GAAMLZv3+7zXCT+fj/99JPf89JzHG6323jooYeM9u3bG3Fxccbo0aN9jr1r167GI488Yvqb7jquS7rj27t3b8Dr8qeffvK+hzw+q/O8LumOr6ioyLj44ouNpKQkIyYmxujatatx0003+QQh9fn3Mwzrc9QwDOO1114zmjZtauTk5Ph9j/r8G1anbDh16pRx++23G61atTKaNWtm/Pa3vzWOHDni8z7qa6pz7daGo/JDiYiIiCIC+7wQERFRRGHwQkRERBGFwQsRERFFFAYvREREFFEYvBAREVFEYfBCREREEYXBCxEREUUUBi9EREQUURi8EBERUURh8EJEREQRhcELERERRRQGL0RERBRR/j/zYW/qCv93SwAAAABJRU5ErkJggg==\n"
      },
      "metadata": {},
      "output_type": "display_data"
@@ -165,7 +156,32 @@
    "source": [
     "plt.figure()\n",
     "plt.plot(timesteps, values)\n",
-    "plt.axvline(stationary_timestep, color=\"green\")\n",
+    "plt.axvline(timesteps[stationary_timestep], color=\"green\")\n",
+    "plt.show()"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 51,
+   "outputs": [
+    {
+     "data": {
+      "text/plain": "<Figure size 640x480 with 1 Axes>",
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjgAAAGdCAYAAAAfTAk2AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/av/WaAAAACXBIWXMAAA9hAAAPYQGoP6dpAADksUlEQVR4nOx9d3hVRfr/e5JAqEkogdC7gBRFmgoKKmLvZV3b6mLvvXztrG3VdV1d13V3Vey69s7aUBQpgkakI713AgQIJDm/P/jdy5n3zJ133jNz7r2E+fDwPJl7prxnzpR33jae7/s+ODg4ODg4ODjUIORkmgAHBwcHBwcHB9twDI6Dg4ODg4NDjYNjcBwcHBwcHBxqHByD4+Dg4ODg4FDj4BgcBwcHBwcHhxoHx+A4ODg4ODg41Dg4BsfBwcHBwcGhxsExOA4ODg4ODg41DnmZJiATqK6uhuXLl0PDhg3B87xMk+Pg4ODg4OCgAd/3YfPmzdCyZUvIyVHLaPZKBmf58uXQpk2bTJPh4ODg4ODgEAFLliyB1q1bK/PslQxOw4YNAWBXBxUUFGSYGgcHBwcHBwcdbNq0Cdq0aZPcx1XYKxmchFqqoKDAMTgODg4ODg57GHTMS5yRsYODg4ODg0ONg2NwHBwcHBwcHGocHIPj4ODg4ODgUOPgGBwHBwcHBweHGgfH4Dg4ODg4ODjUODgGx8HBwcHBwaHGwTE4Dg4ODg4ODjUOjsFxcHBwcHBwqHFwDI6Dg4ODg4NDjYNjcBwcHBwcHBxqHByD4+Dg4ODg4FDj4BgcBwcHBwcHhxoHx+DEiGq/Gp6a+BT8uOzHTJPi4ODg4OCwV2GvvE08XXhz2ptwzehrAADAv8fPMDUODg4ODg57D5wEJ0ZMWz0t0yQ4ODg4ODjslXAMjkWsKV8Dn879FMYuGgsAAN8s+kZ4XlVdBVd8cgW8OvXVDFDn4ODg4OCw98AxOBYxZcUUOO614+C60dcBAMAPS34Qnr814y14ZvIzcO5752aAOgcHBwcHh70HjsGxiLycXSZNldWV0udrytekkxwHBwcHB4e9Fo7BsQiKwXFwcHBwcHBIDxyDYxGOwXFwcHBwcMgOOAbHIhIMzs7qnRmmxMHBwcHBYe+GY3AsIsfb1Z2+72LeODg4ODg4ZBKOwXFwcHBwcHCocXAMTgzwQS7B8TwvzZQ4ODg4ODjsnXAMjkV4oGZgnOrKwcHBwcEhPXAMThpR7VdnmgQHBweHrMHk5ZPh4g8vhpVbVmaaFIcaCHfZZgxIJamZuGyislxVdRVc+MGFMLDVQLhywJVxkObg4OCQNej/7/4AALBiywr4+OyPM0yNQ02Dk+BYBGVjU+VXKZ9/OPtDeHnqy3DVZ1elzPPkxCeh9zO9YdWWVZFo3FPx7yn/hjELxmSaDAcHhxgwc+3MTJPgUAPhGJw0Qmajs2zTMpi4dJdkZ+P2jWQd146+Fn5d/Svc8809tsmzhrGLxsJLv7xkrb4JSyfAJR9fAoe/dLi1Oh0cHBwcajacisoiEgxMKi8qGVr/tTUAAPx86c+stiqqKlj504kho4YAAECP4h7Qt2Vf4/oWbFgQ+m3i0omwftt6OKbLMcb1Ozg4ZBbOAcMhDjgJThqhUmGNXzKexRjtCVi4cSEA7DKu1pFOcXDgcwfCsa8dm2wjE9hcsdktzA41Blt2bIEDnj0A7hmTfunwjqodaW/ToebDMThphMqN3Ae/xm2WW3ZsAQCAo145Chr9uRHMXBNNz65iDJeULYlUpynmrpsLBQ8XwPGvH5+R9h3M8M3Cb2DppqWZJiOr8K8p/4KfV/4MI8eOTHvbyzYvS3ubDiKq/WpYU74m02RYhWNwLCKxEesyKmXby5J/+77PkuBQMXeyASM+HAEAAF/O/xIAAP7z038ySY5V/GvKvwAA4NO5n2aYEgcuvl34LRz24mHQ5q9tMk1KVmHbzm2ZJsEhgzjuteOg2WPNYMLSCZkmxRocg5MmTF89PfTbpGWTkn9zJTilK0t3l81SyQ/lNbYno6apE/cmfLPwm0yTkJWoyfM1bjwy7pE9/gA3+rfRAADw90l/zzAl9uAYHItQGRkvLlsMm3dsFvMbXN3w6+pfAWDXYGz2WDP4ddWvkevi4k/f/gnuH3t/2tpzcHCIH1XVjsGJgvkb5sOtX94KF390caZJsYKadHhzDE6a4HkefDxHDGSF1UzBgTV33Vx1ff+/7NWfXQ1rt66Fiz66yBKlamzYtgHu/uZuuGvMXYKKbW/D5ordzKqLUL1noSYt4Daxp0hwKiorYHvl9kyTkUSm1sFFGxe5tYeAY3AyiKAEZ/nm5YKq6aYvblKWTbVI+74fq+Ft0NuhsroytnaCUNkbpesC02q/Gn5Y8kOSsVm6ebeBaraqCGsqyraXwdcLvnYSB8vYEzbLar8aih8thsKHC2Fn1c60tbtu67qU8zzHS/82+tqvr0H7v7WHc989FwAAflz2I+z3z/3gi3lfGNetu55t27kNnp70dEY9WSk4BsciuEbGQSwqWySko26a146+Fto+0Rb+Ofmf0udrt66FER+MgHGLxyV/21SxKaOb9Ory1bDv0/vCYz88xi6bLrqf++k5GPT8IDjkhUMi1+H7/h6xiXCwbus6OPA/B8IzPz6jXWbEByPg1DdPjfztDnnhEDjipSPg6R+fjlRehk0Vm2o8w7Rt5zaYsHRCcgz6vg/TVk9LHlr2hPffXLEZNu/YDDuqdqTt/qrvFn0HTR9tCr97+3fS58FDVrrWowe+ewAAAF6f9joAAAx/ZThMXTUVhr8y3LjuxOF53dZ18M6Md5Lj45uF38Axrx4D8zfMBwCAe765B6767CrY9+l9jduMC47BSRNC6ijfV6qouPUl8NSkpwAA4NYvb5U+v270dfB86fMw+IXBALDLo6Tw4UK4/JPLtdu2jfvH3g8z186Em7+4OWM0UHhp6q7IzL+s+iX0TPe7nfD6CdDrmV5pPXnGjZHfjoSJyybCFZ9ekTLPkrIlyc2zqroKni99Ht6b9R7MWTcnUpsJ+7NXf301UnmMFZtXQOHDhdD3X+ZBKXVRUVkBh7xwCNz19V1pa/PkN0+Gg547CB4f/zgAALxQ+gL0eqYXnPTGSQCwZ0hw0qFenLV2Fhz76rFJb6JHfngEAADemvEWWTZd6k/MSNmMM5aoe+iLQ+H0t06Hkd/uChtw2IuHwejfRsPZ75wNALu9Y7dVZq/3nWNwsgjBBSauiTJ3vWjbc/c3dwMAwLNTnk1ZZuS3I+H5n5+Pja6KyuyNymwTn8z9BGasmQGTl0/ONCnWkIh1lAofz/kY2j7RFk5585TQs8R4f2/me/DmtDeTv/+w5Ae45YtbYOvOrXaJTYEPZ38IAHLmNS68Of1N+H7x93D/d+kz1v983ucAAEnJ198m/g0AdnvP7Ck2OAnEpZ4+8uUj4bPfPoODnjtIjw6IJsExYSijrMM3f34z/G3C37TrnrZ6GgDslhIlsCfFLHIMjkUkBvqKLSvCz7ywtCZ43QJXtElNbt04OZT+eOqqqXDPN/fAiA9HpKSx2q82Es2S75ImOxsH+/jL+L8AAMBHcz4CgPDCvKNqB5z631PhrHfOgnVb1wEAwKDnB8GjPzwKD3330K6ysz+Cvv/qCzPWzIhMx+KyxSkZpkzYUGSDkSyes86WbBe4ASCDtoi6jMftX94OJY+VwLJN6WEWfl31Kzw2/jG47n/XkXnxOEjFiO0JxvqOwbGIDds3JP+mTra+78MTE54I/Yb/Xr9tPcxbPw8AdtmqJBA1tDlmfCi9+4Ztu99pyoopofKV1ZXQ4x89sv4izIUbF8KQUUPgo9kfZZoUwVZrT1ALcGisrK6E27+8PSktwMCLZ1Bdh8MozFo3CwAATnzjRPhpxU9w5ltnSuucsHQCePd5cMUncjXZzDUzod0T7aDTk52kzzPB4GQDM7EnbFAYUfrti3lfGF3+Sx0Wg/aOuvQ9PO5hWLN1TdKWJm6U7yyPXDYbxmpUOAbHIoKRQCk7i53VO+Hnlbsv2PTBh3kb5iXTmyo2AQBAk0eaQOenOsOijYuUkUbxhZS6Uo/vFn+nfB5cBGXt/7rqV5i1dlbGgqcl3nPK8inw04qfkr9/NvczOOqVo5IeZSM+HAFjF42FE984EQAA/vLDX2DIqCFQvmPXxJ++ejrc9819aWU4znz7TOjwtw4pJQvfLPwGWj/eWmDKTBebx8c/Dvv/c/+ktKSyuhJWbVmVfP7BrA/grLfPSo6/O766A5o92kzbM++Fn1+Ah8c9DEe9chQAqEMh+OCzpHNBBj+IhCrhmcm7DJ0rqyvhik+ugLdnvA0AkAzPkMooNSMMThYyF+mgacaaGXDmW2cm1R8m0JVSD39lOPzh/T+kvCrG932YsWZG5LkfXLcTdUxePhnGLBhDlk0cVH3fh3nr58XGTOR6uaHfKqsrpQdcPA72NNVlEI7BsQjVAoEn45vT3gwtrH+d8Nfk39j1bvzS8cq2121bJ6RtGZ3ZnHCpThHcayeCG/K2ndtg686t0O/f/aDvv/omRf/HvnYsfD7vc7jk40sAYJf3WBA3fXETjF00Nnn66vlMT7j323uh+9PdAWBX8K7DXzw8aZ+gQtQ+envG27C4bHHKNg578TBYtnlZkil77qfnoNljzVLa8Pi+D//77X9KZuTGz2+EX1b9Ag99v0v9c/BzB0PJX0rgl5W77E9OfvNkeHP6m/Cnb/8EAAAPfv8grNu2LmVgR8ygLNioZrRVfUX145qtevfkjCodBc9MfgbOeOsMKQ0YsudvTX8Lrv3sWm3PoqWblsJZb58FPyz5QSt/HBvZtNXT4PrR12vfJxQHDb7vK9s/7MXD4K0Zbxl5I0aFzHQAAKD7092hxz96pLS54YyfxB7Q/9/94fCXDocVm+VtJpBgcB4f/zh0fqozXPPZNcr8yXaY3y43ZzeDU+1XQ2V1JXR6shP0fKYnqZJKqaLaAyQ7jsGxCM5GXVZRJjA41GCh7qpKNQgrKivg24XfJiVKXHuWoNoNwOyUl8qQmUtT0H6hyq8SAm0lJDIJUK6kCUlFAgnPnj+8/wcYs3AMHPPqMbtotHj3F64rYZ9C4aKPLoK1W9emVNV8OvdTOPrVo6HtE23JuhKG3T8u/xEAAF6e+rLwHG8GqrhLKlCegoKBJnoWdQHFmwr17WTPz3z7THhy0pPw5vQ3JSXCuOD9C+DN6W/CoOcHaeWn5lFldSV493ng3edpx5vq9UwveGLiE1DylxKt/CGaUH9XVVfBSW+cBJd9fJl2HWe9cxY0e6wZfL3ga+nzhBQu6gFs5lr6wt7nf35eymimktTNXjcbAMSrc1RYU74GrvnsmuShIAjch5RBboLBue2r2wAA4O8/6l2TwF2Hg+9eVV0FizYugsVli2HW2llQUVUh0I3HWzCoqQrTVk+Do185Gn5c9iOLtjjhGJwMgmNoGJWxGPHhCBj64lC4/n/Xa5epqq5Kqk3iupeE4zlFbVCYSZGVTbVZYgYuAYoxUm3MCZRtL4Plm5cr6wHYJXHgICgJe/3X15Mxjb5a8FUob6r3xkylLdUcJT3A9KiY26AKV4aEmo0CxUCrVFRBaaEKQTWFDQTVG9xrURLf8vmfn4dOT3aC2WtnC88TYxd7VGK8+MuL8OHsD+HZKc/Ctwu/1Wr7v9P/CwAAj/7wKItmXbz+626PnsR33V65Pbkpj100FkZ8OELKaNo6pFz68aXw1KSnYP9n9wcAcfz44AtSP4pJT1ew1KCKqsqvCs2JoKs3lgBj27gE8Lp35MtHwv/m/Q8G/GeAKbnWECuDs379ejjnnHOgoKAAioqKYMSIEbBli9r4dt68eXDKKadAcXExFBQUwJlnngmrVomLTJR60w08gGSi+vXb1ifTVCyBqKfZRKyQhGuoDmPR/9/9of6D9WH9tvWhCWgSuyeBScsmQZ0H6sDtX94OALvjmkTFg98/mPw72Kc6SMQNwvht/W/KcjrvXfTnImj1eKuQeiwVKqsryXYBIMl8lq4shbPfPTsZ0whjR9UO6PlMTzj9v6cDgNqgHDM4uqql3zaI9OKAlap2PPAEjxVsOE8Z0qdiKvC3+WK+OrprthsZy/rU9304/rXj4YTXT0hZ14gPR8D8DfOTatpk2f/fP1T/BtXkwct9dRCX+gJ/2207t0HRw0VJ1bLqipuo3phYgoHDCQTnt+/78M7Md0L0bqrYFGI0TWjixpAKqqjwOoBjslE2N6kYxXQFXuQg1pl9zjnnwPTp0+GLL76Ajz/+GMaOHQuXXHJJyvzl5eUwfPhw8DwPvv76axg3bhzs2LEDTjjhBKiuro5cbzYCbyiJWByp8OGc8PMoiwh1Kg7msRH2W4ZEQL+Hxz0MAADfL/6eVf6z3z5L/u2BJzA12DMtsYCYMlEqyL5D0IsuETAsgVQby2n/PQ26PNVFOKXKkKj7ko/QxoXo+HL+lzBjzYzkgvvar68ln8kCT6rSqTB20Vjlc1l4hCCCxvE6MTp0MHHZRCFN2VFF2WSWb14u3bASWLZpGVz4wYVJw/fRv40G7z4PJi6dmLLMr6t+TUr8auXWSv4uk66t37YePpn7CXw85+OUxtcJRPW4zAQWbVwEff/VF16dqhfEsXRlKVRUVWgdDKJKcMYsVBsLB50bfPClh6z2T7SHbk93g59XiOtvYp7ZVIEnMH319OTYEFRUflVIAs2JxpyYw3u1Dc7MmTNh9OjR8J///AcGDhwIgwcPhqeeegreeOMNWL5cLrYfN24cLFy4EEaNGgW9evWCXr16wYsvvgiTJ0+Gr7/+OnK96QJnoaQkAJ7nCQtbQvQbN0IbHWFRHyXIFTckPDYuxSJ71ekjjoVDB0G1GVZF/mPyP6RlEkxuInYMhYT9TAJ4I/zHj2I7KnUZpaKavCJacEKKkQrip5U/pXzGwadzP1U+V0WBTaX2Wr55ubBxtXq8FXR7uhss2iiXWJ333nkwqnRUMjpywpbrwOcO3EUDmlfP//w89P5nb2j1eCso31EOtXJ2Mziy+RJkgILxtGTYEzaiBDo/1Rl+WvETnPverjuWqqqr4NrProX3Zr4nzR+y6VKswcFnJtHEVWtKtV8tta1MqMJTjU3bHmyz186Gns/0hOaPNQcApKKqDquohBAlmrRkoycgRmwMzvjx46GoqAj69euX/G3YsGGQk5MDEyfKTzEVFRXgeR7k5+cnf6tTpw7k5OTA999/b1Tvpk2bhP/pBmehT+T/YNYHyjxxDLCgeFWGT+Z8kvwbG6JOWTFFq41xS8alfCZbeK7+7OqU+X3wYdbaWVrtmmBVuZ4thg4ozwpbwIxh7dzayb+5Nji6KgpSNavYkPBGni7mNDjmZPRt3L4RWj3eCpo80iRU9vz3z5fWSUkM8fwf8eGI5N+Tl0+WbtSV1ZUwY82MkEqBGwk8Vb/aMvIGAPjfvP9FKodV4q9MfQWenPQknPrfUwFA7Ffu+Ejkv/SjS6HhQw1ju5QY2+ToAL93VXUVfDLnE207MwyVVFz2nYO/6drj2XD1jxuxMTgrV66EZs2aCb/l5eVB48aNYeVKua7uwAMPhPr168Ott94KW7duhfLycrjpppugqqoKVqxYEbnehx56CAoLC5P/27RpY+EN1aAmn87Ap3SacZzMsDolCM/zBNXL0k1LhfdIFWfCFJR9CNfuJgpUOm8uo0lJ+qIyrlS5IINDlVXVpfKAIce9YsxmKt5GcHxhLzwAUKqiUqnoKCkl9a1kJ+qz3zkbevyjR+iS0bhUUAvLFgo0JDy7jn312FjakwF7IalUopRdSkLS9a+f/gUVVRUh2yRdqJwauEgVNflPY/8Ex79+PPT/d39rbSXwwawPSCmUCpmSikcBm8G57bbbwPM85f9Zs6KdqIuLi+Gtt96Cjz76CBo0aACFhYWwceNGOOCAAyAnJzovdvvtt0NZWVny/5Il8XDuHOgwJ3FthCrIDNB0keo0GzeC/YCD5ul4MXER5dbldKgJqDbycvKSf+NFCi9qQXudIF6d+io0+nOj5AV8bBoD32pV+SpRvZih26yDNM1ZN8fKZagcZo1khv7/d01c9vjncX8OBUzkQNflP3iYqfar4abPbwIA0QYubnCMm7fs2KLcfLG3ok6MKxl04zGZ1HXft/cBwO64Ul8v+BraPdEuMs3B8YgvDfXBF779nhBdXRd5dBYRN954I1xwwQXKPB07doSSkhJYvVo0fqusrIT169dDSUnqOA3Dhw+HefPmwdq1ayEvLw+KioqgpKQEOnbsCAAQqd78/HxB7ZUOkF4pGouSyWk4KsiTZRbqXYP99Ma0N+ClU3aHZU8V3IuLIe2GwLeLdrnK4juRdL4Dp9+ifleqjaAt0M5qcRPXbTNhG3HPN/fA3UPuJvOrVLMXfXgRPHv87thImVpYgzR9t/g7ZbBC39eLvky5/wbblAVulAWP06nLBKWrSoU0ttuIEq181tpZsL1yO+xfsn8kmlT96Hme8O6UN1wqd2ebwOpDABDidEX1mjripSMAYJctl38Pfzy8/MvuOFdSo+IAWbpGxnsC2AxOcXExFBcXk/kOOugg2LhxI0yZMgX69t1laPf1119DdXU1DBw4kCzftGnTZJnVq1fDiSeeaKXeOBEc2NTNxKQNjsZEsD3QdlbtZC2WcYgqqXfC6hFKEmELJQ14wdOC/fjJ3E/g1O6nJtM21JdcGtaUrxFi/mBJV1yLloqxx27emVJRtS9qn/y7dGWpNKx9Ap/M/QSO3+d4sk7qJnRKAiO7ly4BD8SNnQwxofltsd1G0Hi5srpSYJArKisgPy8fXvj5BXjxlxfh3d+9C43rNg69Q8J9e/0t66FR3UZadHBoDz6XMTjZYGCdKvJ4XPAhHBQWM+04/x7Es7AQmw1O9+7d4eijj4aLL74YJk2aBOPGjYOrrroKzjrrLGjZsiUAACxbtgy6desGkybtjiD5wgsvwIQJE2DevHnwyiuvwBlnnAHXX389dO3aVbvebIANLpiKRWJ78m6v3E4vzIE2ZTZCulEvdeqXAYvzE1KVIBKXk9pE0M7BB/GUVlax64T22dzPpO6qb0x7g/WtdPJK75BRlJuwdIKSsYprI6CM65VGxmm6Rb64/u4DW1CNJ8NjPzxmpU3O+kCtFSojfBl0DyaJO7wAdjE4iXEOsNsO5Y8f/hG+XfQt3PfNfSFboCDdcaiKAcJxlTCCNLw/6/1YaKCQrnGcQLVfDa9MfUX4LXh48P7/vwS4c79G2+Bw8Oqrr0K3bt3giCOOgGOPPRYGDx4M//rXv5LPd+7cCbNnz4atW3dvqrNnz4aTTz4ZunfvDiNHjoQ77rgDHnvsMVa92YgoXlTpOukn2/Q8+PS33W6Ms9fNVhqf3jnmzlAdppb1Ou8UNMzDi1bC68U23psld1MF2GW38f3i7+HY146FLk91keYJvldcC55KelXtV7PUHlGB6w3aa8xaOyukMgyO8crqSqXkAiB+Ox1ZHwZplDHUAOG74yiYqCyXbFoilKeuGNC9gkBJA2LqMf3zNswL9V2Q7qhjnpJkCQzO/7cBTVU+XVBdR4Klb7FIwX0/FAtKperDEp89SQVFga2i4qBx48bw2mtyY0UAgPbt24cG4MMPPwwPP/ywUb3ZACo+g41BZHvyeuAJYl7KRVHmcWIaFTbxTi+WvgiV1ZUw4oAR6vySfsQLre1N0QNPEN9X+9XK+1fwIkYtajbUbNhOCAf3wqj04w8ZP231NHjwuweF34LjJSghSAWdPHsCKEZO5yqQdAK7EmPX9E/mfhILMxEMYiiLCB6c29kgWcCMIEBmJDjBbzF33VyldPRvE/4G1x14nVGbQTujbIK7i8oiWNEgs9CLChvtvTz1ZSWdMvpsTObtldvhgg8ugIs+uijEZE1fM11Iy5iBYL8MajPIuhutDz58Of9LgYYgwxOMzgsQ7led+qPkmb9xfvLvbTtFuwwswcGgImnbQLVfHfKKCdK0uWIzKekKBsCLgmWblgltqEL7J5CJEPTPTH4m+bfv+7Bsk+gunW7JBPa0+WTuJ+St01YOcYo6cDDUD2aH3Z8zwRyOXzpe+TxuaYkPvtAvO6p2COsVbvPeb+81piNdd2px4Rgci7C5iW3cvjEjJ5IgXfgiyqmrpobEq/idjSU44AuTJeiqCiAPkidsiqjP6taqa0SPDqr9auFS0j+N/ZNStUcxgVElONjOgRO8i7K90sXn8z5P+Uw2P4Ibd528OlaM71VYuHGhcCM1jmki66dRv4wyapOL0pWlyTvkEli3LVrANxlUBqepgL3HfN8PuV3jy17TEhohMMaDm3g6acB47ufnhLTKPGH+hvlgG77vh7wkgxf0VlWHpbmURDGIJZsyH2ZFF47BsYjg4qjSwwLQgyjVLdecOrigGKq7xtxFbtSmTJnMzZLKr/otDiYRn1aq/WrBtgQzGph5sOH+T743+jayRY3bpimq/erQvAhuink5ebEs+EH44MPbM94W0sr8MfVL0PNJ1SeJ5/jgELdkQiaNCUqyPM8LbeQ40Kfq4KELqpygokqzKigKZq9LHTTSFqjDDHX5bE2CY3AsQhA9Enc6RVFDYFG57UUOi6FxG1JbASI0fxQaVIyiLH9wEdxZvTNkeGgbOAiejsQl2HdU5GWt+jS+fVDaVVFVoVShpkOUL2ujUZ3drsO1cmuRBrGmDIfMEDY4fj6d+6kgNVxctjgWJvmuMXdp5632q60YCnOg08+p7uHi1EEB3+OG8cTEJ5J/YyYQqyPTAfzOr0x9RSlZjYUGwv5T9ls22HnFAcfgWARHtaCTF0/uoNsmQDynS+zlopIKyGxbbGwGQQNZHVsmpZ4+hs0Je2lxGRLqzi5bi01BfkHy76rqKmP1IRf428n6CV9MSDHUtmnCfV3lV2XcoyR0GPJ9eGrSU6HfrLaJ6sMRdmWqaGqTDKax0bsufl75s/J5UCWKabr3m3szHgfnn5P/CQ99/1AyvXXn1thpiqLijnLZ5p4Ax+BYRHBgUQZ4UYBVI9YlODK1h0LVtqlik30bHOLiN52TR9wTVCe4oMkiFllFhd67ab2myb/x2Plm4TewasvuC0TTEUWYohl7f8QBmQQHq4NxjJC4VR8UI+iDz7qywAZ+/87vQzQEIY05o4jTdfpbp1ukTg4PxBARO6t3ZnyzrvKrhO/51oy3pAysTcjc6ak8pv2UrepBx+BYhEq1YnLHk6z+qHVwgW/qpiaCDRVVMM5NlIlnI/6Gsn7i21I0UYiqosJtBIN77ajaISx0i8oWCRcXpmMsySIVB9tNh/QE11ntV8PdY+grJ4Q60u3BpMHMmtKE69O5xTrT0hGMHC9HuCH8xV9ezCA1u0GN46jSrVQwleDUJDgGxyIEBseCDQ7l8hiHDQ4G9jLBYceD7tFWaPB9uOzjy5JparLKjJJtGDdyENWtOxWiLlDBNsYuGgs/LPkhmd5RtSMkXUtH4L8gKEZQR4JjSqdMOhKMtQKQ/n7BiHK6Nr3hmlyvFBGoU9YZt60Joik3Jxdq5dZS5okbWmsBoomyM4qFhhqkhlLBMTgW0atZr+Tf1AKRDRKcNeX8W3HxTbRY9UGpqHSkHUGXWGqzl8V3wRKcdHuc/G/e/4zqi7JI4jI4KJoPYVWLSbh2HWCaZLEysM0NLvPLSvWdbmyaNOZhsF+q/erYY6voHFwoL0wb4RmU7emoqGJWvWDI3MJxnKRM3W8WRCYM+oOQMaMqmuZvmE86QlDIFomQY3Asok1hm+TfOnp1LmxPFIph0pF+4LuXqDJU0D2ZCoGLdEtwuF5UNvLKNpOgOlHHwFdVXyaAJTi+b257Qs0ZGYOsknTJ6owbOnZApqpY2YWQg9oMEmig2kv3Rj5uybjQb/jbvf7r67HSgBFUrydgQxpmG+/MfEdIc9cLCtmwngA4BscqVJboUaQvpJdCzAutzqlw3GJxkbF1VUMCUSYadhM3tk8gTv1UNGVZWtlehMVBR9KV6VPVhGUTQr+pbHAAzBdKch5CODQCdqdPd8BN2fii4uCYzjvZJblBdY9UqkRFWs/AeMM0ce8IM8U3C78J/Rb3/WkYOv2OpV86EjrbNKQDjsGJCdQmaMMQzLblO64vNyfXuE4uyNMOc+Jh1/oooDy5bCOKRChKwDrb70EtajjyLYBId0iCI3kn7sJJMaeUiiodXnrUO8nUZLZBxU6JohJLtzej7DcdNWncaNGwhZDOFulGEKZSpWy4IkMGx+BYRJ28Osm/g+oqgGgqqkwPmlwvAoNjmfOnNnvKMwfAXO2lY+hMwbaKiiqD+0VmgxNEHBuoTCqgAu5nfLt4FFDfvsqvYi/mcQfdwzTLbLpsn5CpUAeyEz7pBJGBUzzl9ICNsfGloaaQzSO8jlL9Yjuad5TDDVcimA3fXgbH4FiE53lQXK8YAMIDJC9HfXF77dzaZP02DJU59WMJjlacHMtSAUp6snTTUnZ8IG6/RVEvmkjboriJ4zIvlL4Qeq46vdpgnnEdH8z+gC4T6KfK6krhPVaXrzZXUWlIUlXfU2b/IrOzsAmdDQkzPbbVsB54Qpu432Q3e6d7U5OtNY+Me0TMQxhn25boSG2TmGpX2X17JrAVGZ0DJ8GpoUgwMnhQFdUpEtJRNs04butVAZ888AVuMlCSAO4N6fid562fFyqDIwvbZgSjGOiafBsbKirs+lztV8NfJ/xV+M3GnVgm+WUIMauWJTjcGEZjF48N/caVdrH7UWbvgtr8duG3QjoOo9DhHYenbF92AWncYSx0GGa8RpGHHcs0RrGFCoZziFpHEFhKFcUrE68fFLh3LaYLjsGxjMQGHuUEf0q3U4Q0xVCYDiJqocYTTceY1tgGhzhx//unf9N1EH2tc5GpigZcP3adB6CZLFXckiiLLr6nTEaPjOlRlmHSEcVQEZfBY96Uqae+g0zFGRzDM9bMMFbfYbVJKOhnhO+NpasyjyIOZGNBJVWWbcJxS5gnLBWN1KN8l0zYBVH9smzTMiFtyuC8Me0NIY2/bfui9uT+9N7M95R1UEhHZHQdOAbHMhID3AcfWjTYbVymM/nxvStP//i0si3bHibY5Rujef3m7DZwPAVuIDeZzQQFavJOWa6+C4qiCePrBV+Hfpu6aqqyjmmrp6VuL4Kb+DWfXaPML1twbNgWmeSXldlZpWZw2PVrSHBU8YEAzC8mxBuW6tsD6KmCsXTV1JYkypUoFLJFTaGCKfMajAaeCrgfKGbU9p1xeDyd3j18bQZlnoCZMIxsvbzTMTiWEZTgYA+RIGQnU+zSOGfdHGVbtiU4H835iF0HtQGNWTCGXaeqfplKATNecYuldVx0b/j8BmUdqkUsikgZX5KKEYnBMZTgRImoiuMkcWmgVL8yG4zgt+jZrCervSjA9nhR7EBwHbYlpx54QsBNWT+mO4xFFE8f0ovOcC2Yvnq6kH575ttkGeqAxTbwZR4adYKf4r2IGxLAqahqKBKDE8fX8MGHtoVthTQXtnXcXDdwWXtdm3RVluFy9pSKSibBCXqvyeqIOw5Ou8J2oTJ4A8Lh2FWLmMyAk4LONQgYz5c+L6S59i82+hnfkh2K98KsE0uASAmOXyW0sV/z/WIPA4CvE8BjwwcfOhR1EH8jTtimkB24grdgU/kB7DMPobUAzNUesoCGJvhllRhpWybNxfOKGl821uUgZN8K23DhOhrXbSyk2XZnToJTM5EYCNV+tfCRfT8cUCwI2bM2BW0kOdVlbELHELpjo45COiTeN5wYc9fPFdJaF1tanlyyTTEInaiuz/8sMhPG7vSIJrzQUvkBAD6f97mQpoJ/cWmKgkFtBwlpbp0hCRDFMFdXwbLNu8XvPkjuNrOsqsPMb35uvpCuk1eHDOwXJYSDCjqBIoPQ8RYyvWNp4rKJrPw63mfvznzXiCaMZ6c8S+bBRsQUuBIcrqrZAw+2VW5T5sH2V9xI2k6CU0MhqKgCHzmK19R5vc9TlsELis4NwBwayirKlO3p1MHNj5/jm3Zr59aGQ9sdKvxGTS5T0TnO37GoY4qcqdvEMWFs69kp6NiyhKQfTNE3N4aRDBRzYeqRhMuHgrBZWJipNvF9Sc0biCrWHC8HmtZrKvwW7JdD2h5i304DqzGiGPCi95QFduSAsivCNGLJmAzZIllQwTaDI2NO+7XsJ/xmO8BqtvSzY3AsI2hkLEhwUFrHOwRv3JQqZnHZ4mhEa0J2aqQGsqm4P3iBKcCuDenUbqeKNDA3VlO7jm5NuwnpKJuBbZsJCnF4NVA0RAlRbxqUkct0bd25NVRH3CoqSg3n+z7UrVVX/C3wXm0L25Jxtbig7Fue+/m5UP6g4WmXxl1CdRrfcE5tuohGmdcXaYNjyNAe2PpAo/IyxG2D07ReU7ZtEndOOAlODUXSBgdJcEJp8En7FTxIhnUcZpFS/kZf0qAkXIeFGB+q5wX5BUK6qrqKXNxDUXwDNPZs1pOkecuOLUL6vVnvCencnFzoU9JHWQdGpgNpmV5aqvMcp6MYz5racVDl8di47cvbQvlNI4ibzolqvxqO73J8yjrbFLSJ3QYHY/MOUQLpgy/05QEtDiCZU51+Caq8uWNBh+nDdjym83JIuyHsMtT40gn6GgRXgtOmoI31MY3fybmJ11AkON2QDQ6W6Pg+zF43W0hjNKnXRFp3sE4TcE8zZ/Y4M1wHwembBkXDG1JldSX8uvpXJQ2qyMaN6zYm++2dGeJNuzh+TLP6zeDgNgenbB+Ar4rjYsGGBaz8Nu4+4+aPxOAw1Ynbdm5TPg+pF5HNGLZd6lDUgb5dnFKjEYwfNf6+mP+FcrP2wYdOjToJv5na5HCZEZlkjJKW4feeuWZmqF7VPWC4fm60eExTk7pNrDsg4ICu0jJpPuz8tOKncBmmGp9tD+VUVDUTgooqMEi+W/SdkE9n0cOW7Jl2xZO1x1YhMMWpWM1R7VeHDPtwnfVq1YvcvoyGKPXE7ar+4/IfWfll9Das3VBJExVzSLZI9m3RN5mOQ4KD05j5pPJTDHeXxl2gSV10sCBO3JRhMwUdxrBR3UZC/mb1mwnPWxe0ZrUZooGpktBZv6jQGDL1IKdNjDwvzODYnocytetRnY5K/i2TclMwNWqnDMD/NPZPZB24zYVlC63SlCk4BscyUsXBuf+7+0MqKwrcxZ4LbnlZbJe4XbLxRJHFe8HGharL7TDjmUCD2g1S0iBLY2lcumFjwaE2ICqGkezUFzTa1QnKSMGYkWSqOXzw2bc/c+elDk34t6Atmk5+qk3qOfcaDyyxTvzGoYFLE07rSHBM1yscTdkHX7l2yEAFkuSCalMnAj1OYwNxrl2js8GpoQhKcEJ3JCGVFYVFZYvE8jFLcKJcIojfA0fwNVWr6Vzyx7GZwMxJAioRfzq8x2yXj2JHgtvgXhWCmUcbKiquC6ypahDbylE4vMPhxjRxIRvDxuOLy6RJvpNOMFMKqgs+qeCG2E4IQD0PgoEMU2FJ2RJlm3k5eew1LVjHeb3PM7b5ohhJmZQT58FXM2Ckw+YvDjgGxzISemGZi2NwUGERswz3fXufWN62BAcNchz4LUodmMFh18dUk+jQFLKFsrAZpFvHzG2vV3PR+0xnwbFx4g7SKWNw6teqr6wD2xaZSk+4cwbHBwEI90PQ7ge7fEcBV22qc+8Utk2i3pvr8SaT4GAvT4rhIdtgMruvT3udrpMp0cOHVGz3UzevrlBn0K5Sh4aGtRuGDMZtO27olCHjaKWBpjjgGBzLSHDn2BMHQPzo2IbiuoHXkXVn2gZHBmogc/XLISNjtPAGo0GnooGS4AQXSrwoS+uT0GwqKcAbObbj4NaHcUjbQ4S0jpja2CUbMY+D2w4OlTl+n+NDvwVxzWjxTi1TpguDKn/1Z1eT/fLkpCeVddpQaanm+vil4429zTDwO1KuyrI5gj2KgnV2bNSRrb6h3jHKZa5cyRdlcN6iYQty3twz5B7lc9sG4hS27dwWem8qAKKT4DgAgL7X0KdzPxXS2GNKBtPTKVVfFNheaGOR4GAbnEAbdfPEeCM6NKX6jYOP534spLEROobprdrF9YpDv3G9XqjyWIKDjZgBdl2FoAKWPFBeUjo0CWmNfsNlejfvLaSXb16e/Ft2r4/tOSED1WYoSCfTToPr/VjtV4ci9gbbLGlQohUNGUcuV4FSocrA/Ta4HzCD06hOI7IOLLUMqozmrJ9DRq02PUxh3PLlLaHfZJJLkzay4fAN4Bgc60hMWp3w/brPUuUJ2UxU8Sa8jUFITUauDY7Ma8omUtlYcDYhXEebQvFKjSM7Hhkq89lvn4XqCILttcJc9LCoXVYn21VYQ/Jgige/f1BNA1d6EoE+HMwtWEeul2tMg+l4lOWftXYWq7ypN2S1Xw13jrlTWafpO+E2/zbxb6z6dOqk5qWM8ePOkycmPpH8+8v5XxrHNOJeibF261r29+bawjkJTg3FtNXTAEAep0SpOtE5WaI8q8pXCeni+uIpPR1ctExlFAT3JIgZgSgulLifVm5ZKTwLTr6om3SwXL8WYtjzoKt0Ajh2D5YcyfopaN9h+i2xWkVWpw2JIFc9Qz0nVXcW1EHcOoMbko4ExwZUbQxqMwhnJ8tjcCWlPvhCTCHZhhask2u8nSgThI1YTlxmhPJ40hrzlqUf2LYNq5e0blmPWdrvbHBqOHRcqnWfpcoz8tuR6vxY3VNdJdxSbGMQmgbywyjfUS6k92myj1heQnNhfqGyjX//9O/k33iRlEk2MChvobu/uZukkYLM5iG4UNk2MJfWabgQ400sE4ucDXE+xVTtW7yvUJ+x55ZhPzWr38yYBq6RcbVfDZf1vWx3/ZJ3wAcJikFReZ3i+nQRnEPDOg4j5xFpkyM5cJl+X275ar9aWC+ixGGi8uALYLlrg5PgOAiIcrKkboSlPJx07BvI6ySIBYNUvViQIgSDoElpQIaLVoxAA7/hyz912sCQMjgKg0sK5TvLyTykDQ5z4V1Vvkr4bdHGRbgImyYMLLWMw7vjwe9EtRhug7SZ4I4vyTtMWjZJSGPGP1iHTIrA7ZeKqgqBccNXpGCc1PUkwUBfxiBxVVSrtojf1lTFFXyfZB1MGy0daQhXfRN6zhw/1X41tGrYiqSL0yYGZVpg2y4oLjgGJ41QqqgiDAguc4AXZnzHkgyyOB9KGixPZp36v17wtTIPjq1herrADMxxXY7j10F8GwC1BIfCi7+8yKbB1Mh44tKJwm+3fnkrSQNFEwaO18E9kevMs5lrw1cIpAKW5um2QeHN6W8K6SkrpqSmQSJF4M6zJyc+KUThzc/LV+QGGNhqoFCn7LJNgQnz/RCTRsFURdWvZT9RouiHpUjGUkwJcynLE4TMczOBns16km3KrgFStRcF3L63IW2LA47BSRP2abKPWkWlI8GhFjFioc3xcmDBxgXJNDUIde5qIU8CTBXW0PZDhXQklZJKgqMhKtcyAkULp6p9GSga5q2fx6aJC1wHDqLIbeP1aa8L7y6LgxMl+F8QOGq1rF/aFIhG38LzCIs/vhWbuliQ2nDwFQVRaLKtCsRBRcn2EWOHvwtAuF/emflOKA+uUwUb18KoLuLVaUO25hqrKNFakg7piGkdlFrMdJ7bgmNw0oQr+18JG7ZvSPk8ivEsdzKGROtEm3k5eXxmgBDxUhs1vkkX1xdF9RKE7FJAqoxsw1KeoCwsQOu2rRO8I9Jhz/LID4+w8odsvPwq4d1l4v17vrkn+bfMGJsCDqxHqQ9tfJuRY0Vbt+A8+nTup8bie9PxIlOJRmlDxbRL8wfapK4CicTEGUoFZG1iT1OKGdWJUcOV4KgiF0vHM8GEqSRCqXBOr3NY+TENP6/8WXyO6P7n5H+yaYoDjsFJE2SB/4KIIsGhTo4btokMFQ51TurEkU1FHKAW5kieEwqao9jHpKon+Pc1A3YHqIvyLTHweDGNEA0AcFGfi0QaDCULUkaR0bendDtFO68uDTKVEX7OBQ7XT9EgQ/DiXCvjD22KUaSIRu0jSQPF4ExaNsnYUDWKEXynxrtvXY8ivdUJ32Bb4sJlmPq1FL04cXuyO7qoS0FNmUvuZcBxwTE4acKKzeFLIoOIIsEJlpGpwLARcojBsWBtT51OqHtWuGo3HVA2OGw7IclpGOcpqlMkPje0RQqdmFb8DI3q7DamjsL44UUtipFxcAxFEdcL+dNwqrchLTG9WZtiBqL0AyWJoGikoLWxMyQ4qfIo2zA87PjgQ/P6zZPp9dvWk2Mcq1ZCa4nEi4orSVdJtXXXZFU+HZd/7nggpVBpZrB14RicNIG7SErzGBoSYhWVzoKB67x24LVKmo7oeARZp7K9GCQ4wffWMQqk6sN0USorGaIs1sFbi6NARVf9WvXZG++6reHLCr9d9G3yb679lQ50GGKlBI/57U/qelLoN0rVS0m2cD/P3zCfRRMAwP3f3a9sLwqWbNotqbKh0jKOjG0oRcBjoXRlKblmYsmp1rrMfC/VvNCRxvngw7LNy1LW/8rUV4Q0dvkGAFi4caGSZgyq73FUaWdkvJdBtgB0a9pN+TxUBzHhqYWWyxDp0IXroG785dJkI7hXcEHRkuBEWNxNxe+h+iX9YPtUhDdd7jvMWDNDSOMrDWS3O5tCRwKoMsDlviMOQQCg4UIr+U7BdrFLdRRvs0RA0UR75NzXeO/f1v8m1KkCZh6kd50xaaDWs2q/Gg5rf5iyDqE8+FC2XX1lxTcLvxHSH835SJlf1gbO87sevwvlUaFLk90eaDrfCUcuxvXj6y5uOvimUB0PfPeAsg3q2+E5EJIoWmK6TeEYnAwieCLHg3RYx2Gh/MFB06O4hxVVC4VqiFcFgG1LbIg6VSLhVCLl4GastYkqGLE4JjdmoiL1C2GbMrD1QFZ9VX6VoJrDzG3wzh0uPbplpMyERQlOFDUuNV7w+OMG2ZO1T6rJiPcOfsdEnco20cauo6LiqtGCDFeiPuyEoMIX874IBVzFbfyyUrxFO4r6EOdR3Q6O7WUAANoVthPqotrE44X6VkHVdlRQa6INtWsccAxOmkDdTcUVc+fm5IY2Ve4g1FJRBerARqoAkmCDmLkgXGqxeD4dEhxcJ5ZEcNuQqaiO7XKsujxTrB1qAz3v3rQ7SbMK1X516PqIPiV9kn8nmBcsiaA2ORVd3y0WLxg9uvPRoTzti9oLaS7TbsqAy74TaVdGSHBCDE6EC2Vxe9R7BiU+MuCAntyNXXYQ4q43mOaQNEVj8w9i3bZ1sH7b+mR6v+b7WVGBCzRJpLcqJrxDUQelBDCWw5EFZsP0MJ0pOAYnS8BVF2GGZu76uWwdNncRq5VbK9TG/WPvF/Oj5/hUT91abMMolDrB4+fYlkTWj50bdxae40UJf5vgqUxKRyC/LG6LTFwfLPPB7A+E51cNuErZHgDRL74PB7Q4QPhtzdY1ketLoH7t+imffTH/ixANGE3qNlHmkTEXqjGDPcUo2JDgJOhKwNT4lmofIDzv8E3fGPVq1SPrxM/ZNjiELYrsWxbX232/XhRVMK7P1C4oSp34MKRa81Ixq0G7L9vSEplUiXvQdBIcBwHHdTlOiE4aRfROlaEWEB3ROLWI4UskcRuhwGyYRsKeIcrijwOKUV5UOmHJyUUISXAo4PxaG3fgtwlLJwjPdUT3lIpqQKsBwm/vz3qfrI86fZqe5C7rd5mQ1unb4HUOOP9dY+5ite+DD60LWgu/cccsHj+m7s+p6Ayiab2mRuVl/Xxa99OE5yqmTfZbFGYCb+wmG6fv+6Fb1kk7RuZcxnWM6DOCJaFJ9ZxrV4YZQxVaNmxJ0kH1Qxxj2gYcg5MhUKJ3GfAgjxJ1M4igJ4ZOHToiYtwGDszGPQlggzkd/Hf6f4U0dReVjsvjvA27Iwu/MvUVNoOCwbZfsGCDo4KukTF+7+B9Zs3qN1PmpyAzSsZBzCjpB/UOnGsYEvVhOw1uJGP8G1ZJGUtwIow/CjKaVFGkdcewCjJGETNRnI1TdoXKii1iuA7je6RkKqoAzfm5+VqHl+Df1PiR1RdUBbctbAttC9sq6TYFOQ+dBGfvAlcVQ4m5pWkLNjcYptFDKS+qUHn0/OYvbma1L0P34t2Tf8HGBaQEh1KjvT7tdaW6UEeUHspPfEsd5pKCqrzsdEx5xlRUVgjuoYPaDlLmpyBTo1DzghqfYxaM0W4/FXC/9CjuwaZJxQyYMjifz/ucHj8obWoAjsesDQmOTr8ZSXDAh32a7JOy/lRlqOeUSoor3aVokPZTIM/p3U9ntRlFDUutmU6Cs5dDRySMEYxMTJ0cAOwspKGNHLV5Vf+rUuaXgSt1soFgFFkZDZQqT2ogrpDgyBY9lY2DD37obhdKgpOWGDMS9WTwvULXamgw5bZBzYEvF3xpVP+rv74a+g2r8qh5N2/DPCUzkImYIX/54S/K51Ipgmp8EFIHWXmqflyHTFKlrE9CE1eiXFFZQdapVFdr2CpRaywGadvkeco6zup5Vkp6ddtsWLuh8rmLg7OXg5TgSAbd69NeF55zL44zPT3IyvdtKd4npCOJULYXA+dP2iohBoZrm4Tr1FmkOjUKhJD3fahfSzTGlX071beIcgoLPWcy3SF3WI3F3xTc8eP7vtDXUXDboNvYbQaxasuqWCU4UhqYhx2uBNkHH75a8FUy/ca0N0L58Tyaunp3SAjssQcgV91xJDhn7HtGymcAKSSlKB30ugIAePrHp0N14LSqL2XzFtcRtAviMlCyOinbuI5FHUNthNok+klHqpQNcAxOmhAlOBjGyd1OFtKheAioDm68BIDwBYjk5NJYGIOwYdTHBdUvGBOWiQa8MmkJXkBwZOMgDu9wOFzZ/0rhtwNbHyjkD0XHlfRzsK+wROiXVaKdiAxc5oAdSJIpwbmi3xUwsBUv9k6U8WI6pvLzxEiw3MUfIw57Be7B4pdVv4SkGRRNeBMds3CMkib8ntgwHgNLWnXUYEHgeC9SNS8xxscuHiuksc2OlLmgxgPxLa7733VCXvycuj4ixNBI3lMVIFE2b3EEb66qOG7JrS4cg5MhRNksCvILhOdU/IwoJ0VujAbuYh9FTK2CapFOVSfuByr0PmYmcB4ffIFpkp2gWjVsJZbHEh+in/DptV/LfoJ7OT5pRgFFQzCUvzQ/U4JTv3Z9OLzD4TyaiJNjJhZWncU+SBdmsE0D/clooPppy44toU1RVZ8Obj54t71ch6IOoTpxGALKPq92bu2wBEdBF27vs98+I2nWMTIOrrsY89bPI1W7eK4HD0wDWg0gVX042rIOzfjbBr3qdObtUZ2OUrYZRQKYCcTK4Kxfvx7OOeccKCgogKKiIhgxYgRs2aK+VXvevHlwyimnQHFxMRQUFMCZZ54Jq1atEvK0b98ePM8T/j/88MNxvkrs0DqJokFDSWhseGtgyUQUxkxFAyXZonDxAReTeajFHktosOrl4DYHh+rEBrGUmDpEE7FwYzdf3PdfzufblpTvKFc+pzZJHFnWxiLGrQPnx6fbUH4LDM+mik2sNqIYGXdsRKsNTCBjulTrgezwRKmrg0x8QX5B6FtRMYhwm92adgsxhibf0/f9kBcdvkNJZo+nsqG5/7v7lQxDqDxidj3wwocdYozLAkXOWTdHpIFQoXOBPRyz8aAhQ6wMzjnnnAPTp0+HL774Aj7++GMYO3YsXHLJJSnzl5eXw/Dhw8HzPPj6669h3LhxsGPHDjjhhBOgulrswJEjR8KKFSuS/6+++uo4X8U6uGJM/JsPEhscYtB9veBrmi7iNKKiSdamqdrDBigagi7gALTRMYAYBA9L02Ri6xBNeBFE+UNqEQ37AQr/mPwPbZoSbQo0MtWVOjRy3wHn/2nFTyQNUS6zDOKvE/6qpkmD6VdKS9AJG+PyfpeTNHJVx3gjxc8xA39e7/PItQDTg9en4EWWsu+uEz9IKcGJsHZo2dsRjB1XgqOaV7L6qXX+2SnPhp6rGBqutK5erXqh2GLUmpotiI3BmTlzJowePRr+85//wMCBA2Hw4MHw1FNPwRtvvAHLly+Xlhk3bhwsXLgQRo0aBb169YJevXrBiy++CJMnT4avvxY354YNG0JJSUnyf/36qSOmZgLn9j5X+TySLQFTgoMH3dsz3ybbCLVJbKrc98A0hTxxDDc8HWAacCRjrLLCkgsZDSEVVaBfvln4jZp58MOnaZlKIW5XTO631GLKLW9I1MaNb0mO0sZBrQ/i0cCU4FDMBobO5kHZ41FqMwqdG3fmMe2SMU0Bv0OD2g1ECY6vluBEYaZ1xjjF2KmkF1rrOmaAUBlqnX97xtuh55yDKnmY9v3QvDKNR5UuxMbgjB8/HoqKiqBfv91hoIcNGwY5OTkwceJEaZmKigrwPA/y83efXuvUqQM5OTnw/fffC3kffvhhaNKkCfTp0wceffRRqKxMLaquqKiATZs2Cf/jQsKSH4eYx+CeuHAZ3/dJ5iDKoKNO8Zz8OvWXNChh08gFbhNfLIiBVVRXf0ZLB1VGxjr5KeZ06uqpkZhiDnB91K3FofJRJDjUeGG+89hFY5XPZTh+n+OFdP+W/VnluRsG1zbO9304r/d5yjyP/vCokibTwGw67xj0QJKpwHDAzVxPnGdYUnFSt5OEdvHdZxSNOs91wlawGRYswVGoqABEFZSOZCsKzZx3wFfH+OAL99LJ6tjrJDgrV66EZs3EyKZ5eXnQuHFjWLlypbTMgQceCPXr14dbb70Vtm7dCuXl5XDTTTdBVVUVrFix25r9mmuugTfeeAPGjBkDl156KTz44INwyy23pKTloYcegsLCwuT/Nm3Cd//YBp5MVKA/nQGCJ8p1B16nzI85f1kbFCPGtsEhJD7UwsqW4OgwbShPYZ1CIY0lNjiNY2HI6hf6yfdhcdlidRni1IZprlernnWGJkQTavN/8/6nfB4qz5TgpCqjArXYU+J8KQ2G4nbqILFlxxblQYGSpvjghyI6YwRdtqPQSAHPfcz8AgD8aeyfhPSJ+5wopLG9HT5IYBplDJCJBEcGbkiI7xd/H35OrGHjl44X6jqy45Ha7QFEs6XkSHBG/zZaSGPjbt/3YUSfEUoaaowNzm233RYy8MX/Z82aRVckQXFxMbz11lvw0UcfQYMGDaCwsBA2btwIBxxwAOTk7Cb1hhtugKFDh0Lv3r3hsssug7/85S/w1FNPQUWFfCO6/fbboaysLPl/yZIl0nw2kJjE7BOSxkYf/G3OujlQmC9u1NTEWLppaajOddvWhX6j6FA9D9KAY7vIaKQmyk0H3aRsHwDghH1OYNGIFzW88GK6dfoA2+A8X/q8kOe5n58TyzDtW/6w3x9itVdqX9Q+1CbeYDBWbhEPKlwJjuy9KVD9pMPUy+hQpbn5cZsvT305JMHJzxVtrJTtESosHRqjeFQGr5PBTPi1o68NBXsT2vf9kNs3dcWFjNkQVFSUBIf53WQ0hMqg935k3CPK/IkyCWys2CgwOAAAwzsNl+aVtSejcflmuYlHqjooG7BQecn4xoc+ajxhhihTyKOziLjxxhvhggsuUObp2LEjlJSUwOrVYjjwyspKWL9+PZSUlKQoCTB8+HCYN28erF27FvLy8qCoqAhKSkqgY8fUXgYDBw6EyspKWLhwIXTt2jX0PD8/X1B7pQMmjEHKMobSkrKKMmX9jes2ZnH+UhrRRKIYGmrTLq5fDCr44EPv5r3hozkfpc5D9Bt2Nac2dln91EI5bfW0lDRU+9XkglE3r66xtEsF2SYaZPxkC+/PK38m6bEtwYlDNM6V4HAN6WXt5ebkAlSJv6nak0XTptoQ0pgRJIKEAoiMvmwuX7j/hfDkpCfl7UukUnhteP5n8RAgk74F2+zdvDcsKlskbS/VO1DPueNHSyIYyPPuzHdDz1RRyHWYsGDcnFR1mKzjOus8dZBo0aAFWUc6wJbgFBcXQ7du3ZT/a9euDQcddBBs3LgRpkzZfWP2119/DdXV1TBwIB3cq2nTplBUVARff/01rF69Gk488cSUeUtLSyEnJyekEssEEoMXf3C8iUbZrKg8wascZDTgW5Exruh3hbJN6aLFnEi2VVSydqhQ5JgGLP4v36l2p5YBq6gohPT0VL9qSDu6Ne2mQ6qcHsm3DeWJsDCq6vxpxU9sBggzn1T5vBzxDHfvkHvJNrjvid2fcX2y0y9HIkN9eywpkdEQRYITRSKSfKYhdaIMV3Ebg9sONpLgyKATtoJa04K/XT3gatJOiNtvmJlYsVkMPiith1i3qbLB/DuqdpDjKVtUUhix2eB0794djj76aLj44oth0qRJMG7cOLjqqqvgrLPOgpYtd13PvmzZMujWrRtMmjQpWe6FF16ACRMmwLx58+CVV16BM844A66//vqkZGb8+PHwxBNPwC+//ALz58+HV199Fa6//no499xzoVGjRlJa0gldFRVpy0JMJFkaGxpyF7W8nDz2Yo8v7aNEoTh+i7FtgGTB6N2st7JOqh+wOgnjtO6nifVDWEVFgZJ0yb4D59vINj2SJlQftqGgmFGuBGfMwjHshbFPiz50pgDyPJHBkRmY6xjQJtC6oDV7bks3TQZjz92gZMCegvgdOjTqEG6XYMJVkNF8SNtDkn/vqNqh5YkTpOH2r25X0kDZ0+hIR2S2kniuquZW/Vr1yW9pSiOOSSOtJ9Bv45aMU9qAqcomgGNoZavXFEascXBeffVV6NatGxxxxBFw7LHHwuDBg+Ff//pX8vnOnTth9uzZsHXr7hPQ7Nmz4eSTT4bu3bvDyJEj4Y477oDHHnss+Tw/Px/eeOMNGDJkCPTo0QMeeOABuP7664V6swE6lu6qdJQywTgTAHx7BGpyyU4X9357r1gHsVks27yMld+G6g7DNHKsLCYE14uK2jy27dwm5tdggoI4tdupJA2YHlwflmxR3+KTOZ+E6w3Uef2B10vbNQEe08ErMADCEpwodQYhU0dGUXFx3rvarw6pOFXty377aaUYLwjTiJlZAA0mnJBU4Db2L9lfSH8w+wMlTZhJwusbhuxiVApYLYZplElwsDQ+eE2KjqT1utHXCfmF9iTzkIpYj4Hr+HjOx0KajOskeQcspdxTjIz5s5+Bxo0bw2uvvZbyefv27UMd+fDDDyujEh9wwAEwYYL6TpNMIpWKCoOU4EgGCHUnCdcQTEaTig62ZEJHChWBocHlddQ7QeAFg2vfIANbRUVsHu/Pel/Mr3GC5pzSZPRQ/daknuhxh/PjQIKN6jQS8siYDYrOuevmJv/O8XJIGvHpulFdWqrLGYOy8YY9iihvIB1pXN8WfWHKiinJZz8u/1F4fkznY1JeRVArpxZZf8gAWDIHSNUMJXViMEQA8vUKl5m0bBKo0KhOI9iwfYOcJkn7fVv0hY/nfJxM4zHq+74Q7ZiSpumooFQMiw9+iJnlHsh0mCxleY2yUVSemYC7iyom6BjxCc/RpMCRRHEdjeo0CpXBNhg2xIhcMTXeZKnTrYzzl3lf6bQXrEOVhxJLc+GDuQQH0zRpubiQR9kwOKA2XR/CrsqyhTqYZ0SfEWyGF+PB7x8U81PjDz3HMW101GhcCQ42+sRtyGzCqA1BdXcQAAhxSaK8E75riJpHXDUZV6Ulo7HaF+9fu3XQrWQdQ9oPSU2ThJ59muwj5kH9gMM9+L4vdZEPtqEa0zj0AsbarWvh8fGPC7+xDaGZ6uxQeY3vttcH+ttbkTgJUZFFffAFN2+dQTVr3W73e9lEwjfAcuMnSBfKCJKA5N+SQa7jRRU08uUyC9I0qBd7HI+Di7Vb10Y6ZQXpwTSWriwV86NFq09JH/KkiIE32iB01Cb4+RvT3lDm8TxPSCckEhzcNug2JQ0dijoon9tQ/eJnIfUPui4Cj69m9ZuFnpOSTMU8OrjNwcbMgw5ChxuOikqDiVO1BxCOH9S8fnNWfTqgVCsLNi4IPVfdTfbcz8+xvo2sj6i7pyhw1dmh8hrMqY17DtMBx+BYBkdFxVVrvDL1FSE/tTBTQdBkNFGneO4mSNForG+WnCy5EhxTvFD6gpkXlU6/ojy1culb1FVtSutnfqtU9QTbC6bHLByjzC9Dq4LUt7ADADTMb6h8HsWGiyvBoeqThdrnSEIjMSfEWqBjM0FJcDDDLTyTMEQUME23filKbKIcdqhnXBp3Vu1UPl+/bT2rTswcy6CzJgbNE2QM8KdzP9WmSaefcfDTbLXBcQxOTCCZCbRgzFo7C7o2CcfwUZXHwJx/HEbGHLqiiM5V4l8Znvv5OeXJMj83n73YR0EwDo8pIyDNj/JEsZeiNm4u80rlicIQK+vTkCJEYWbZEhzqW6Hn2CtPKsFR0E3NoygbNzeCr6y+6Wumpy4r6SfK1g1/qyi315tKtvD607dFXyG9rVI0/tep8/AOh7NoCh36mNLhO76+I3YbHGzQnS0MDYZjcCwjpZu4ZEEL/jZxmfx+LhVwnVh0ytWLUpumLK2iKYp9DHWlxandw95BwTqb1mtKthEl2i0HURgBfJLD7symYmcqv0xNZtyehHGLEiWakybLazADphIc/Pz1aa+HaOLQ7fviXUBa0j5UP964J6+YrKxDWidqV3XvF1elBUDHwTGW4Ggw/S/+8qKQHtx2MNkm1Q4narWMJq5Ue+mmpUYMh87BBBtyOxucvQw6Ae24i/X5+52/O69k88BtfjJXdNvlbgaJdnTL4zw++DBhqejxFoWBCjI92FMM16lzO3nck9EHH47pfIwyD5aM3TXmLuF5r2a9xDqZRps60jOcn/o2O6p2sNqVSSr2K9lPmyYtGqnxFOHUb2pbEuW5ioZqvzoUp0a18cvon71utpDG9w9pHUaY4892lGDTeapjE4hd0aO0aeNgEASWzGu1GbMEx3lR7aVIbMZYSiC7B8rECE+22OP68CKm5SauWNR83xfE0vgmcEwjQFiPjq+L0LENoILWqVQ3OowgTptEBE60SdEcXEh1FsAZa2ZI2wlizro5aroU7VD2VwAAP6/4WUh3btxZSZOUiVcs/vgWY1l+/K2oC0GjnPpNVXk4+CUGV23GVVFV+VVam2Kq9lK1wWJGmQw5QArGz+CApYM4VCtRmOwgQhKcCHG7jCU4RHlKCp4tKivH4FhGKhWVLDiciQhXZ+PmWuP7EI7BEKTpzelvChIZ6tQne/7m9DeFdCigXYQ6VZuqDiOI0z2b9RTS9WrVC7VpimtGXyOkQ/E30LfduH1jqA6KYdH5LQFu8DkAgLN6hL2yyG+lWPx98OGMfc9Q50fpp398Wrv+VOBIKnQkE797+3fK59JLJRVrAcVcyOiZuJSn8v77pL+HaSKYLBV01BwYXONtbp4o0twoG7WppAnTRN0Ub5sGWVlsP0WtodgIOVNwDE5M4BoZ6wAbHnJtS6IsIKZSJgojx44k29OxOUhJQwQJDm7vjkPuULYvo4f7be8bep+SBhsnJKVkQiZtMVBRJOtkqpT2Ld5XmZ87hkPBMQlJBdWGjmSCUuXpzCmVkTH+VtV+dciFmvutxi0ZF/qNmkcq6NgqqdqTPo9D2qJhl6jC73qEmVnTeYP77dtF37LKy+rgIMocwenbvhLDO2QKjsGxjKhu4gD0RAipYoiN2zTYYP+W/cnTrM5vKkxdNVVZXudERS3EXGYBpzmBBwHk8WEo4Fgp1ImJOtVzv00UiWKkb8GUsJjmf2z8Yyly6rXRqE6jUF5TewPZ4SdIw2ndTwsxMCrvHR98uHrA1cJv3y3+zohGTBMlkaGYMG57UhoiSOOEZxoHuCM6HqFdHwBAu8J2ZDtcaQrXqFgGbt8PbT90d1nZWkDUh/tx/bb1rPbjgmNwYoLOxW/cgU9JRygVFXfidGjUQb2oMdUgOtAxwAxe2gcQNgx84LsHhLIUI4hppm6H1gG3H/CGpCNVYG8gqM4jOuxezKVeVBSzSakTI0hwqPy4H6go1Ko7nHTaCBmtM21RZMBrAzZIx/3m+77SKLjarw6pOD+f97kRjTcceIORBGfppqXGmySGTvumKqqWDVpq15eqTo4EB48vGU06iKKaDaJlw93vHUWCM2vtLMhGOAbHMlLZ4GDoSBpCZbAEhxh0bBscyeZiKl7l4tdVvyrpkvXR86XP734u6VOZEWYQwcjJABKpkuGGpgO8gQVPVACSjZ2IKaJj/9K2sG3y7807Noc2XmxEzhW96zBNmGbuJhi6qTvCt1LRKHtmW4LTv2V/JTNhyhhEQe3c2iwaZMBlKGbUhg0OF5SqhTLW9n0/JH3lSHBsmAVI6zU4/GhJXlH6L+P/wqQwPXAMjmXoqqhkebgLGc5Phc/mnpC4YulUv6nQsLYYifaJiU+EaWDUqXNqxP3w6A+Psuto1bBV6DeqjAqYucA3FsvUjaZGnJhGfKGj7OJBVRpDR+3FlvAQmyap5tWQOpra4FCQzcugdyKed1L1JDrsUIgUzyVQ77eLviXbObbLsUKacrRQtSf7TUuCQzDQVH6cLsgvINszMUzWWZ+iwMjIWEOCw7WNyxQcgxMTdIyMucCTnRpk7EjGkkFMLfY6vynb5J40mAyPrA38TtiFX0eypqLh6M5Hs+iT0TRj7QzlcxkNwRhBL099OZyfuUhR31KHYeaeBEN1UCoqJMEp2y6GIdCB6nvLNi9jCQ6alyu3rAy1TzEwmAEK3ngtg+wmdwpBGkpXlpLfKni3HqYRAOCtGW8py5OB/nRscAyZfqyezs9TB+nTkcRzma4obuGhegNtntnjTFZ+nfXOxcHZS/HuzHcBAOCbhd8o88nc6OZvmK8sE1JREYOOeq6qP5E2ZSbI/MSCNH7peNaiFUV/jDGw1UAyPyV2NmX0/jv9vyQNGDJ9vqoNDHzCpsbTf2eINIba01CjUpsBFTcJS3C+X/y9kqZUdKrawHlNF3NcHjMnPogBMkkmEMKBIjF+XPaj8rmsTlNVi231tqnkTEdagsNY6JgNcO3KKNiW4OhEUqYOzzi9fPNyIW2DKYsDjsGxDLwgp8LCjQvZdeNTG3fjjmSDQ6ioDmx9oPAb16XxogMuUj7/dO6nIcaOu4lxGT3scrtu2zqyTk79MnClJR0adQgZV3PbwO+A3ZuphZoaw1IJDnMzoCJhYwkO3qB0wLXBMTYyRtJdyttR1mfczR7bmenAtirOtD1Zv+OgnFxpiSlTRUlwDmp9kJomDaYrCkzsp3Skxcs2LxPSNjy/4oBjcDIESqQsQ3DgVflVoTpMJwZXguP7PnRp3EX47aVfXmK1SdmyJNrRhc4ixmUEF5ctZtGkswFd1Edk7Lg09SjuwaIpQRcnP25Tdk2Gsj2ZDQ6DmZD9RjEDq8pXsWiU1YEDauK8tlVUppLXuMC1LbEtucBrw1OTngq3ybQLo8pTNIXKgx9yicZjOiNGxqjeTo06qfMT2gHTfsoUHIOTIXBDqQOEFxB8ujVmcJgSHBlNGCd3O1n5XIdmzmlE50REiVOL6xcry1N06PQbDqxG9QOmWRZMjuobdtwlX81cYNx88M2h9qiFct1WUTpG5afUOxRw/cM6DhN+69msp/GYp8ANNKmjdo0DuN2g2r13897s8hRwP5zVU4yULZOkchBFWkL1s0xir7Lh0qFJ58ZyChTDwqUpWxkYCo7ByRB0GJyD2xwspCkDS1M9KL5hmDKotCGuN90sdEAFQMTAnl3cDUZnMZi5diarTJR+wp5YbC8o1GbpylJl/rp5dUPlqc36ozkfCemfV/6szG97oW1St4lagiOROGEazu19rrKNU7ufKqQpb0dTSYgNUEx6rperVQcHXCN3ALVEMEqb3OcLNixQ0hRFnRgHOIycjZhb2QLH4GQIO6vokye1Ic1eK94QbKoH/WHJD6H2SEkFU2ogq4MC60Sk4dnFZSbYEhzJokZ5MpgutOf0Oif0nqobqGVpDFzfi7+8yKJRxwYHg7ogNo7NXqk205BqUpGum9ZtKqS5Epw1W9eEaUjDhsO1HeHOM6q8zjvGbQhNPZfFo8LrVdwMKlZ3h+jROIjiMR+yx8sAk20DjsHJELiqGVl69jqRwbF9urViUElIlaL0AzcvVwqgo9LiSnDq5NVhtUk9x95DDWo3CJUhjVUtq2LwpYA6NjhBKZMN+ykdBL3N8BinbGxkEhyufQIeTzitIznDkq44wGEWfln1SziPoTRFRyIdt+qF+ray4IXpluA0qdckTEMEZjGY9/avbhd+cyoqBxa0NnbLXlJRQEoqDI3PsKpG2g5yYeQC00B5uunYqnBtcKh+oGxJKPUkRZOsDlPpGwbeiHUkOCd0PUFZJzeWEwWK6QoxPBL6uUwX5TUVRUo1dtFYMo8puBIcDK7KHPeDji1KsK/2Ld437SoqiqZ0SHCwLaaMHqeickgruB4pAPyToilsTE5KbSY7+YXo4Jw+JPTiQGqUp9eijYuEtA0JTty2SlyPJR2a2B4pkvpJmgjmlcuU6dAYijvDYEalTBtKt2jQQkhzI4xnw2ZCHV50xoapmzjbAYFYr6J4LEX5Fun+fhu3bwz9FjzEcSXxcXl2ZQKOwckQGuY3JPNwbSbiUFEF68Suhjq2AOSlo2gy3XDgDaz8OvjzuD+z8gfvtgKgb3+WPTM1ju1QJNrPUCoqKR2Uior4dvM2zCPbUNGk40WlsncBAJiyYkqoTg76tewnpCnvMzymZX1ISVxCEhtCJcWV4KRrA2Xb4BiO+ZCqzpDB1ipjmcnHZaKoqCjP0yjg2Brp2FftKXAMTobANa7VKROLBCcw2DFTpiWmJiQ4mGZZNN7ge38y9xNlfXEs/lyJTLVfnYxorapDhX2L91WWDxmeaiykXAkOdXcQBZ1NkJLgcC+MxWhaTzTwDd1dRagTZYcMilGkJDSk1xTxHScvn6x8bgvpluC88usrYhsaczmkDmIyZbZVVO0K27GkSjLgKy9MoUMDpaJyEhwHFrQmL/NEFLeRsY6HEpcmbIPDtXfh0hMFUhWVaiGN4K1B5cf9+OyUZ9l1mBge6kBLRcWU4GDgEPEkTajOTRWbwnnQ6ZXa2CmGJSSxIWxwTCUXccHYBofp1Ym9OHXAYdqjqF64KqzOjTsrJThFdYqU9cnqpKCz7nP3hiM7Hsmi6YL9L2DVny44BidDiGJkTNmrxC3BkT2nwKUpDvsVU0hVVKqFNMJJkapf5wRGlYnb5VrGvAT7Yki7Icab5qRlk1g04Xd+5IdHhHSVX6WUAlDvlPhN1SZmYHBk7Ky0wYlgz4JhGpdLh0Gy7YDAfS6lSSHBiSK5p4D7CcddiiLdxU4MVD/oxEXKBByDkyFEmThU7BxqQRncdjCrPfI0q7GgcCM260g/2he1F9LtCtspaWpUpxGLBp3yqu8XB5MmcwPngqsK4aKiSrxANrS4y9Q7zH6hLqRtXLexkKbm2bsz3xX6Yfa62exNjwokidNYzZqOWD9REOyXAa0GpHyW/I2wReIiipGx6i68KNJh0zmiU75rk65Gbc5YM0NIU2p+HXClitmqwnIMToYQJf6LzDWYU6dOcEGhfR33QmIy/rKS9pIKIopkq21hW2V+Ksgehfy88G28XMkWdbs8VX9xPfH6iI6NOobyUwyMKXPBhdTIWJHWoYcK14+ZX64dB07rSOMoSRmXYbLBeGKGJArSbYODwZUAxSHBiWLoHGQ4QhJBCY04Yr2xx6WGYTxVBufHhxcMnP+YzsdQZKYFjsHJEKJs5GR+YoJPXDaRXZ9qcsrow6cR7r0qOidDirnAk8t0wYhiZIyBN+YTu56obJNacA5rf5iyvLROQwnOsV2OZbdH2uAgZuKkriex2sDANg5aKgGFiklWngrMxz39co2/m9QNB3bDwIxeFHCZT4y0SHAM3Z+p8pt2hG22VJBJrEk7RsuSVZ2I4lwaSG9YlL9vi74UmWmBY3AyhCgLL+UanO44OLIN7PAOhxu1qRNkKthmozqNQkyY7QVj7da1JE3c9tibnmIT1m3DVBWCpUg67YfsEQgJTt1a4n1WXDSv31xI43c+uvPRUjqDwHGTjuhwhLJOrpfUUZ2OEtIyhkl1/YPO+DIOiCiZ2+mmQcsGh2DCShqUSPMmQNH4xrQ3SBqCkH1LkrmwLFmVjUdTFVUmpJA24BicDCHK5KdUVNaNRtHknLpqqvB8e+X2UBkbkWZ16EoA3/wtgylNX87/MkwDU4JD5cEbGlftoXUyNPSiihK4jSvBsb2443csyC8IlcFXniwq2x3oUdZHeOOlbE/w89wc0SCTyo8Rh/RXWgdTess99VPgvic1nmUB8eLwPBXSEjs0igbbEpw15WtCddarVS9EZxBUcEqMdKu/deEYnAwhyiJFWapnIpIxVyqwT5N9WPWloiv4tyqtQ1MUcG1wqPL7l+yvzG8j+i1XFULRQLYnsT+g+m3W2lmsNjC49jE6oKRnttPUt4zDLRjbsXEljDKYqqi4d1FFmedrt4WlsyagDhEyGm0bmeP6vlv8Xei3Lo27iG0yxzjVppPg7OWIYmSMg7tR+U3hA9/IeGvlVmV+HMCOqo+CjjqqGsR3wHZCUaBahHRitZDRbImFUWdBwe7IphKcKPlJCQ5igHSu7qDaDIK7UIfqi2CDY0qTTJVH0YSB6xzSboiaRlTn4xMeV9qOpMNNPIrEkItXpr5CZ1K1ifoBS9ll37JHcQ8xD7GGYbdvCjo2g7gN7IDCZVhMD09xwTE4GQI1efNz89mDZFX5KhOSQqAW2kSeIN6ZoY5+S54MmdIPyq5DVme7onZkGxwaMChPHwBzhibKxp1uCQ72opJ+K8sLIVajYpo3bNvAqk/GpHFP3Bw1XaJNjODVHVG+NVaLUflT/abMT6g5uEiXKs4E2KhY9i2xiqpDI/EaFnwgwnXI3L5V4Noxyp47CY6DEeKIG/Dp3E+t1qdjE0HFAKHyy9ok6UILBuX1EsVAl0KwjgNbH8guz11wcPqL+V8oy8tgugixvfok7qnBOkoalBirGLDh/Zx1c8T20DuOWTiG3QZGyGbGUIKjY4OjsoeRtsmUuOTl5CnriMKYpiXQHzF+4maAxi0Zl5KeRPsUjdio3XS9imLnQwWnpO6ly9ZYTo7BSRNwsDg8wILB6hL4dfWvsdKkA9PFG8NG3Am8YExYOkFZRxyTj2KqOOVlaWqDwp5dcWx6ofJMhqh8Z3mofEiiwzASlWFIe57qhQuZ1InrYUKNRx2VV7DM1p1qNbCsDqpvWzVsRdbBqQ8gTTY4xPjJBkkCV4KHL4SNIjnl0hDKj/qNiuPlAv3t5cDB4vCACHpuAGTPxGSLJg09QHSYOuXJMsLpJRMwFQFjRDFs5vYDdxGT3vuEvaYMJTim461FgxbsNrFNF3ez2Fmttnfgxl2SgZqXB7Q4QEkjLpOtNjim4yduRJlzH87+UEhz+1FHRRV6jvqOOy9M7fvigmNw0gQ8ALbs2JIhStTIz93NiOmoqLgDm1q0sMhX2qZiUdOx86Bo6NeyH0lDKnq0yyCapqyYoqyTagPbnmC0atgq1Oa01dMoMgWwI8tKvo1K8hXHokh962CcFBlkc4CSuPQp6aOk4fvF3yufSz0BDZlRXL5OXp1QmxgcCU6tnFrGqhUMqnyXxl3YTM1+zfczIYkNLTtGwzVTJ3+wnwrzC8n1xXi8ZQmz6RicNMG2AXA6oDM5uZKI/837nzFdXFCTD7tom95dpQNKfM9lyijJF7ZVAgBYXb5aWQZjyaYlrPyp6Aj+rZIScOuTgbrGQ1a+Wf1mSpqo8YTvw+JKmXQMeDHwPXPU+ME3d8vGl8CMamzSlCcOF6QjBpKK62zKtXJrGdFEIaQu1xjjsthMQdhgcPC3pCRypm06CY5D1kNLghPzQO7ZrGe4TUJFxTXYNV2YbdjghOq0fBrWkWz1b9lfWcfk5ZPNaJAs9qaSTKrvowTHpMYPFQSNexrWOf2aHjRMVXk6diQfzfmIVWenRp2Uz3UOAVwVVY6X3i0vRCOE52HD2g2VdViR4ATaxN6NAOFLbE3t85wEx0GJbBggUSQ4tlGYXxj6TbWoVVZXGquooryTzAtFBa7qb8HGBWyahPokjF/cpy4do8/g/WhR2rdhm6QsL6GJHbjPggSHgmnwQO5zH3xBUqXTTxiU+7PO/UekkTHq+7QzOBqHRNvrEaWikqlAsQ2ok+A4ZByHtjvUep34tBEcuDi8N0D8jBhp/Ch5jmOd4FD83BgQOjRS94RhcNvg3kaOIZXgpPnURXlNxdF+lI2dyyBT44eiQeYmji+p5W6SOCio7U0Wf0tZeVICY+HwRElwcBvceWoKHeNsqh8oF22qTdyGDvNhzOBkwQEdwDE4ezTiOI0EXRRDG5KGPYJtkJNV8hyrJbABLrUhUe8kU+WYGuWZ1idD3Tzx4kpSzWDYJh6P3G8XyVibYmCYkjKd55SbuKkER3bHG8kkIZqoMU/REGpf8q1M67ThOWiqSkkHKOaCek8c24kCaYNjwfCZatNJcByMkQ7pie2JwAUpbrUgzueqsHBUWBvGsfiesVVbLEellnxL2xIUnRD0tiU4xrYlGhJCUkJDjB/uRr55x2YhrWP0bqqqoyI863h6cWminnMlQDprQbolCzoGvVzvRKzaa16/uZDWGfOm3y5UZ5ZIbDAcg5Ol0Jms+EoA2y6QlEoBIH4JDmUwp2MkSj2njEh16udOcPxe2F157vq5rPpk4BpgmjKrOL4Ll6Yo7Y9fOl67PenzCFJJysgYp6nQBzr2M3EzE9gGAyMOZoLsZwuXbWKpYtDmSwbMpJtCxxCau4bioIzY5V9L8mVBPajKny0Mj2Nw9mDgOCa2XSDx6dXGxs5FlBM4++THlOAs3LhQWR9WDcmQDpFuSBJhqK6hgL3RSleWkjTZbF+GSBIcNOa5EhpTZjcOrzzqol5u/TqbZJSDgqpNWXnqAJZuo2IMLUNooh9x0D1TFXsca4FTUTmwgC9x04FtaYrvo8BsGZDgkCqECCci/BxLS6jysphGpkZ86TDwpWDsiq4hLUn3wmeq9pIy0ESgP24/UvXZOHFjppwLqQ1OzFIlrpGxDFwGx/Z6trhssXGbRXWKhLSpSjSOtcBJcPYSyO50SResMzg6nH7MG1YUrwPTCW6qf46ygMQiwUFMV6btqQDUzGncfUDRk6oM98Rse3Moqygjx5TpvU8UokhwYjcyxtIR3w+FleAyOLHPQ0m/sT3YiPL4LisZPbZVVFFUmOmAY3AsgwosFidM737BiEN/zEUUI2Od+BncNilgmvCpS5U/apsqYKNlAFoqaCzB0WCGVZKuTKmosOswl5kYu2hsqE4OdJhdbG9H1WEbUTaw2I2MNTy74g7fgEGF0vDBh9G/jRae/7TiJxZNVJqMam7BQJzK7yQ4DtZh+xSnpT/OgA0OxXRRGzm5gXHvXJJs1NjwDyPuBaFlw5ah0y0lLo9bRbWjakfaJTg6Y4Er5SnfUZ4i5y6YXo5Iufnq1GEb1EFDt4xQnrLhiWBkbDqmTPuxVk7YDtJ0XJt6fcroid3IeG+Q4DzwwANw8MEHQ7169aCoqEirjO/7cPfdd0OLFi2gbt26MGzYMJg7V7SRWL9+PZxzzjlQUFAARUVFMGLECNiyJTsur0x3IKkgbEtwAGhmIuM2OJLnppKKSBIcRMfKLStZbcTRj1y7IFMmiyo/ddVUNk1cYMnZ1wu+VubXMfrEacoTJx2n3+CluFHa5EKmhuVukti92QaDRDE07Dg5pnMghkNgKBAkaoN7sNWR4HDnZrZIbDBiZXB27NgBZ5xxBlx++eXaZR555BF48skn4Z///CdMnDgR6tevD0cddRRs3747+NU555wD06dPhy+++AI+/vhjGDt2LFxyySVxvAIbmVRRxW1kLM0TM6cexZ6GPLVbtkWJcmqM+8QTZaGPe5PEdOjQRIXzx/f4ULeDq+hJ9Rt7kzSUGkQxruV+O9kVKCpEGa+4TIPaDZTPqfIYIRW6hCZZ0ERlnYbzMB1qVtM4OjbUi1Sd2cLwxMrg3HfffXD99ddDr169tPL7vg9PPPEE3HnnnXDSSSdB79694aWXXoLly5fD+++/DwAAM2fOhNGjR8N//vMfGDhwIAwePBieeuopeOONN2D58uUxvo0eKAkOPnnZRNxGxnF4UbUpaKOmgTACldrgECcaG/E3VIhkZGx5QdBxoaVoYrepIyWyfDLkSgUwKBWoLB2lThVC7xBB2maqFqNUqlLPLqaql6ta0WL0EMOM26BslzCM576GRJAL20btOjQ5N/EYsGDBAli5ciUMGzYs+VthYSEMHDgQxo/fFdBr/PjxUFRUBP369UvmGTZsGOTk5MDEiXLRcUVFBWzatEn4nynEGZfBug2OhpEx/o1iWELlI+iCKSmAqQ1OOjwI0iHBoeqsX6u+kqY4wGW6uNI2028nq2PuOl7QRVwexzEhaYrAIJu+N3VZrGy8cucu91vpxLMK3tmlQxMF0zkQxVaJW6fpmNehyVTNOmXFFLjli1vguZ+eY9NmE1nF4KxcuctuoXlzMfR08+bNk89WrlwJzZo1E57n5eVB48aNk3kwHnroISgsLEz+b9OGtwlzQKmo4lRhZYMEx9TFWkaD6rcoNjjWXSQjqDTS7UEUxR2aC+57a+VnBiSzISEKGRXvVBsVm9KUCRUVzk96HspscAztOEyNjOdvmB+iCQeb5ML2IbFWTi3rTJcND0zbdoiYpmmrp8GjPzwKb814i02bTbAZnNtuuw08z1P+nzVrVhy0Rsbtt98OZWVlyf9LliyJrS1KRRWrBCdmN3FpHvScu0BEmWg1UYJjmzldvllU18bBnGJwVSs2JDimqj4tFRWzTuoqBx0aKNiOvWMai0UGvB7heWm7X7ZXbte6LkQF2+ppmSE0F1wJTpRI6tznzeqLQoYpK6ZIy2fSJhUAQC2XlODGG2+ECy64QJmnY8eOkYgpKdllILhq1Spo0WK3WHfVqlWw//77J/OsXr1aKFdZWQnr169PlsfIz8+H/Pz4bF+CICU4MXpZxSHBoerE4fi5NKzYskL5XGcD0ilj83mInggLWLp11joecHHHwQGwL8Gh+nHf4n1hxpoZ2uVlbZoy7bi+RnUawYbtG1LWH+U7yKJrq0DdiI4htcFhzsMtO7Yon1PlKVRUVbDyy2AqwZH1CXXPF1knISGOMo+p95y5dqYmdXIkGZwMehUDRGBwiouLobi4OA5aoEOHDlBSUgJfffVVkqHZtGkTTJw4MemJddBBB8HGjRthypQp0LdvXwAA+Prrr6G6uhoGDhwYC102ESdHG4sNjoUTsSkNyucyFRZRhjrlsd0uIzAn3EWpqE4RbNy+kd2Oqn7bhs7LNi8j89j2SKJOs1x3fZ06KYRUJ0R9XGbDBvAciCLBMZWEmtrgxAFTCU4c344rwUmHQ4Hut820BCdWG5zFixdDaWkpLF68GKqqqqC0tBRKS0uFmDXdunWD9957DwB2dcZ1110H999/P3z44Yfw66+/wvnnnw8tW7aEk08+GQAAunfvDkcffTRcfPHFMGnSJBg3bhxcddVVcNZZZ0HLli3jfB0tmKqoZJEwdWFdRRXBaC8OGkK/BRbWTRVhg3Fq8uENiFteRY8uuMxFOuJzpMXIOECHjfao0+36beuFdCYMq6kNyLYtVBRQzMTarWvF/NVVJJ1bd25VPrcdcNMGgpK1KMDvFOVOQYxQHBwLEhzbarNUz/c4CQ4Hd999N7z44ovJdJ8+fQAAYMyYMTB06FAAAJg9ezaUlZUl89xyyy1QXl4Ol1xyCWzcuBEGDx4Mo0ePhjp1drsxvvrqq3DVVVfBEUccATk5OXDaaafBk08+GeeraANzrL2b94apq6bufk58cA88KMgvkG7cFGwv1rPW8m2pbNMQh4oqSpu22+OeuuJQH8VtB0TRYWMjxwbAXIlPHIHZMLhGotkSQ0SFoPdSKlDMQtxjPhOIgzmlJHyJNj3wtMwKZHVwoVs+0xKcWBmcUaNGwahRo5R58GT2PA9GjhwJI0eOTFmmcePG8Nprr9kg0TqO7XwsPDlpN7OFA5FRk95kQJiePmzAtlhZNpFMvaSitKnC7HWz2W1wPa/isA3Av1F2HLVza5MX+XHoiLKR53q5yr5g2+ykITo3KcEx9ATbU2Hb2D8bEAdzunnHZrGNFOMjx8uBKr8qLUE995Rvk1Vu4jUBZ/Q4Q0hH8ZrKtFjPBLYH/tJNS9llslGPTrURh6eNzfIA9hfvKBs5dQDgBjCLIiHkgqtS2FM2D1OQbuIZsMExRTq+XSrpfmJupOrXYPTqtElwMryXOQbHMvAH5TI4HnhQVlFGZ7QIm4MwGxZn0w0qHbp/rt1FOjycKGTDtyW9fZhSgWxgZtMREymBpvWaxlY3F9log2OKTErfqL0mNyc3+ffeoqJyDI5l4A/KZnA0BkT7ovasOm20qYs9cVHCyIZNj8rPhc7Cm4hmm2rMZnLxTjDhpv2UCYNeioFJJ9OV6RN1EDXRBieToPaa4HNjlbcmE57p8eYYnJixunw1nYkJ24PGZvBB00Bb2YB0bHpcw9K0xKj5/3lSMjgZNH7VZcKpb8cNNmcDujY2iX6P89Sb6RN1EKnGU6If9hZbJFvgePByLyHF0DEyB8j8eHMMjmXgQTZ9zXRW+U0Vm6BlQ7W7u+1oyJnmsrMFiX5NhxQq7V5U4CclNLVyaqXMA5B6PGSDBIdCOjzguNBlZnO93Nhpyqa5TjF6DjxQ/ZaJb5/p8eZG0h4IiituV9jOan17CxILRCY2vXQi1fdO0JSNG4wuTemIYcSFLjObjn7Ppm+byhsy05vingpqHc/Et8/03pI9o72GwMYH1YmVo0Lt3Nqs9rJp0cskEv1qIzgXhUwwOLoMTDaOB915lY0SHN3IyDr9brr5Z3rD0UE6x1+qW9RTSTmzGdk4rzPNrGbfSuZgzIlzF7FMD8JsQcJ+KB12RJmwZ9GNLpqNm2BcKqpM2FulojHo5ZIKpt8mG5lXDJ1+sIVU87BuLfrCymxDVjI4ToJTs5AOZsG2KDLTg3BvRCZVVNm4EGK0aNBCSGsbGWf47jSTNtIhwcmGb2t6nU0UNK/fXPp7KqY/G/qJi0z0K4VMH573vK+Y5cgGFRV3UGV6EO6NiLqx2likslFXj4Fp3JONjHWhQ4vpt8mGuU6NvzhopEIfYFVVNvQTF5k4uNjWJthG5leyGoZs2IC4g2pvM27MBkTdWG0svLYZ5DiAx8uebIOjiy07tpB5TDeMTG84ANm5EYcYnCzoJy6ysV8zvZa4XccynIpqF3AwwkwP9GxDVNsP6tvqGEfuCSqqqCqDbPSisgljI+MsmIcUDXHY4FBrHG5zT5SCk5KxGNb5bFgrVMhu6vZAUB+8Wf1mZB2mJ+zQ6TeGEzvlqZWI6ZFsIwtORPjiUwo2Fq1GdRoZ1xEEV3on+057AoPDHcMJxGlkXCevDqvuOJBpI+N6teoZlQfIjIqUK2ng0pANQQkzIU1xKqq9DNQHPaDFAcZ14EFVkF8glmdO1igLCmZgqDrjmFz5ufms/Nz3tHGStD3BqXfAt33L8u8JNjjZqKIyjf5qA5k2Mq5fq75ReR0assFWJNMbcxRkwjvSqaj2MlAfVGeR5A5UnJ97H1aUgU+F6sZtxrFosd3hM2CblOlrNWTt7wlu4lFp2JOuCsEHEx1k2gbH8zx2nC0MzISH2kiDpIFKZ3pjjgNOguMQO3QMCSlQEhru6TcdA5870HXUSVy62RIcQkoVR5u265P1+56oosoGmmwjyjvZluBw1W42vgMlNYvlMIQPgUTaNg02VHsY1ME2lN9JcByyAVwVAnX6yASXbXoiomguqlMUu0QmioqKu+hQaNWwlZDmvkONUVGhfm1ar2k6yYkFURZ/YwkMajNVfBjd8nEgHUbGlJR7xZYVVtvXmVN4rlPg9pONb9ehqIOQdhIcBza4KgRKWpKJAFBcnXa/lv3YNNlmmjo37symgQKmsUHtBqzyppIMKYOTZW7iMs8vilHM9MnQBjZs3yCkqUt2AexLcKJIBOPue4qmjo06suvENOPrWOLeiHX6zHRt0Nk3dJxcVFi7da2ShlCbToKzd4HrySPDnqCiokTAGNyF1wPPugQH02hDRcW1h7JdXpY/0yoqvEHpqNH2BpVVSYMSMo9xoD/T8ZiGDSuOA1nGJQk6BzbDK3ZWbllJ5jf9fpt3bBbS1Hu9Me0No/ZMUfNWiQyDGqRdGncxrsNURYXFjGlRUTGZLEr8qnOSxKcVrjjVhqgct7mpYhOrvKltgNTImBkTxDZ0FllqTGd6w4oDOv1iW0XFVnOkod/jkApk+hoDnX4zlUhX+VWs8lGAbYmofsu00b9jcNIMrurFAy8k9eHqk3F6wcYFbJooDGoziEUDBtvzSyLBwSdg7mSMw9AwbpUCVu1R5VP9FkTcp3TP8wQaZO1RNFKn1T0RcahlqTayUYITh4Qx3VJsLP2NQ4ITSb3oiXsLF/s02UesM8tVxY7BSTPI07MkQF6XJqLUh9qIufYKNgZpfp4Yk4atH47AXFBqsFBfMm2bKBVV1yZdQ7/hgF+23XrxiZsKJJiNKiodUTl+73ScTjMNrVO+5fFkwyvPNnSkt1xQ4w3bQ5kiCiMZt1eoDSko9716NuvJbsMmHIMTM+4bep+QpgZxt6bdQlw2ydAQG306LN2N7YCYzAWWAsjqiCIVEmiIsNBymSoKXHurUHkJjdkgrhfGuAaN67etj5WmbEAmJDjUPCuqU2S1fR1kwgaHis1joz0s/cDgvhc3qCVW60fpR+76c2THI9lt2IRjcGIGjvxpQxfLVUmlQzzLZcK45WX5KUmVqTieG60ZAKBurboiTZZD69s4hdmOl4G9f2SSLaF+DQlOTTQippCNNjhY7YuZ0zgQh4Qx3eNJdui0HWCzfGe58jmWnnAdP2SYvHyykM60upvC3reKxAxqA9q6cytdB/N0a6qiWrZ5GUkTBa7rOkYUyQR+L/weuA4qijRX4oOfy9x8jSU4iKYlm5YoaZC1b+rRRgEzNFTwOB0bnJpoRExB1u9cOzJuG9wNKsp47tWsFyt/LDY4ad5oZdLkdDMDsr0oSJcNpi/bDyLZTV0NAB4AL5S+wBrIldWVbIkNdxHDok58amtX2I6k01iCY8HIGAPXQQXv4p5uZe+II1Xb3pC4z3dU7WCPB1NX9Di+nW2YxgOJA7I+oa5FiDvsgI07mvJy8lj5ufMuGyFbG7iSUxyXiwvulT5RkO3fIrupqwGIcjo1ZQZMvYF04pRgmDJZNoyMKZrI+rh2QBoLhm2VAgb1jhu2b2BvUqbGjji9f8n+ofYFT8EI10mYwvYt7zaA37lJ3SbsMtz88zfMF9KHdzhcmT/HywlJQge0GhArjRhRJB0ZV1FphLXAzymbHVMa0iHBybQk1jE4MYNr5Dl9zXT2BkRtMKvKV1FkhsC9O4XaRLmnFy0VlWUpwOYKMYhVFAkOhm0VVZT6TVVUVOTYKMxtpnX3sn5tW9g21jYp4D5pULsB+e24/UQZb5P2fJL2qG9peqUAjnQt+3ZUANV0b7RRmHZTm0EdGoTnFuaYk+Ds5bBhX8C2ubEgNRBO2BoTgVoIV5evJttU1UfRKAM3EvGiskWs/Dr9bluCs1/z/YQ07ifptQeGtkXdmnZj5dfZJNOtomrRoAVZf6YXa8pmQgZMc+/mvYV03xZ9Q3WyaNCYl1zJBAVqfZPRQKny0m6DI+lH24c8UxqcisqBDZ1Byl0QuO7PNqQG3IlgqhaLZGRs2RsIY8aaGcrnOu9o2wYH31eDn8ukEFH6VkgzJT46nl8UA2174QypyWKQtplC5ztRa8HUVVOFdP3aohenqRRBZk8Tt02X6doCkH4JTq3csNSJGl8rNos2gralv5lQUWUa2U1dDYANN17uqcoG588WfVsOIKYj1qai2cY9+XTUBXEsUkHoeKtxjQtLV5Yq85/U9SQWDbINK926e62DR4btBWTzPopERZWfa9+nMy8p41iuigrnp9a3rk26pkUdw0HIvV5DgoO9QG1Lf214xGFVYKZVzRQcgxMz4lhIv5j/hVifhROOUB+W4ERQUbEZHMOFW4cm29BiLohv3b1pd1YbUfqZK5EJlUf5qajVpERHQ0JIvdeh7Q5VPsfQMgjP9GKsMZ6oMtRz0/wytS/Ogxkc07WgeYPmZH1cxi1u2FCB2rbBseEmflI39eEm25Dd1NUA4Il3++DbjVVUGPhCM9s2OLplgki3+ypAOOoqVQcVkI6CDuNA9SNlwGtDWmf723BpktrgMNVeGFzXY61vlWkJjobdBg51YKo+pGiorK4U0lIJjmWJMs6P7YiibKq4DDc2DxdRvKgw4rDBwTSZ1ukYnL0ceBDVzasr/HZQ64PIMtTEmLV2Fis/hSg2ONkgwcHMAlVHuyI6vg+HhigSHPwcB8njMhc69iy2jdx1JDY4Hbz7R0bzb+t/Y9FIQedbZXqxlkq6DBlBU29GrK7UkUzYtsfTiefCVVE1qUe74JtAqm40nHfGNEhscFo1bGVUZ7pVzVw4BidmUIsWNn4EMOe0a4INTiRDQmJhPabzMcZtCO1pGMtyN6ih7Ycqy9tQURlLcIj6uEbHMizdtJRDIgkbxv9cHNHhCFb+KP1kGlKCyq/znDseKIxfOl5ZXvbOlJcmRibU12lXUWl8y06NOxnVmelDAYXspm4PhI5hV9xcrbGKKoLNhm2mDKfxpW06J3Ccxjd925icprYkpgbkOD13/Vx2GxRsqKSEtOWwBjrQMgi3TIcNRtLUeJbLNNk4kXMZnDP2PUNIY7WYjU3VtiMGBRsOB3Gs43i9SvdBNt3IbupqACgJjs5Ca7oh4QVEpzym4YAWB6jLGNJsQwpATb7Rv41m0dimoI3y+dadW9nfEoPrgRRF3WTKUJja4OATeSaA32HKiinhPJYlOKYn9llrZ2VcRaUDioGdt36esnzjuo1ZNMn6iYLp+qSDoHo5K1RUxHfJ8XKsq6uzDdlNXQ2Ajv44VCaQp7hesbE0hIryKYOwcUs4fZ2Q7lHbk5XXWahxmWWb1JeIUjQObjtY+bx0ZanxCZs7PkKLlMYUtv1tuEzYjqod6vpi2GxC0W8tqHu4sL2h1c2rG/qNcsHm9nUUFRY1HuZtUDM4XLVYHOprG1AddjJiZCxjsogDGVknU1Ifx9zmwDE4loHFq1IJDmPhK65fbF0aQkHmJs6VROC0zJgat6kqH0VNJlPXqNrgPsdtRjEypvoNewvZ9qLS6ddvFn7DoiEdhodfL/ha+fz8/c5nt2l70zNVUeHfdFzbm9ZrqqzT2AYnhn6k8i8uW2xUP0B6VCsqF2wPMm+DI5XgEN+bug/NSXD2MlRUVQhpqQ0OQ60Rics2NSoF+rTBtR1pVaC21ueqPWT0cQOKUf2iUx/1rVZtUd8DRi1C+bm8mDOyiw9VUiKdDWvdtnUpy+vQFKInhlMdVqFiaUcUBtkUpqplnef4+x3Y+kAhzf02+PJNLRoMpSNU/nFLxpE0UMBl8EHUBlTzinuwldVhCqkNDmrjsPaHCWm8BuL83Otw0g3H4MQMaqBTp7JIE4MpRgyVl9DIVp0YGjdGUVHZFgHbOIHjuCVUGfwOoQWGqS6iykTZLKJIcKjFP1VeXfRv2V9dZwRbJVPY2NBMjYhxelvlNmV9P6/8WflcRuPG7RuVbVKwMc+4ZWJhcIh5xe0XrNrlAjtV6EhwcOgManylQ1prAsfgxAxKgiMtg9VD6VZRSdo0dUfF5f+4/x+V+fHJQMeWwNRWKfRcY3qY6rSpb4X7IRJzoWCCZH1GxcYgvzXxbcp3lAvPfN/H2dngbvQycL8fFWzQ1NZpaPuh5GEoJKkiGDtKtcelEQDgx+U/Cum4GRYbXlRxbLzBvomiojqx64lC+oNZHxjRU+1Xh37D6xVpAxjhQJVNyG7qagAoGxwdZsf0JGhqgyPzUjA1PMXh/kOiT0I0itGiQQvYWbVTmQeDax9D1WHDAyXE4BD9QDFEsjwUU9a/Vf/QbxwaKAnO9DXThWdlFWXK+nVAMYILNi4g6+C2y71lnUIUJm1IuyGsOkyRCRsc0/wA8ahFQ20o1gKddbxZvWZCukOjDvaIA/maHWJ4KEm9oXYg3XAMTszA4lssFiRVVBEmpqlOXDrQDRkaqr63Z7zNq0+ygHDdkW0bGS/fvJzM/4f9/iCk8XtTOm6upAwgLCFRGUPqIHQpIEHTsV2OZdVvQxKG+0FHSmR7o6We60hfuCoqitEzhZYkjLnp/bLqF1Z+G+8kk26YAq/bvZv3FtIcyT0AwLGdefMGo1GdRqH68dynbHKodb+iUrQ5zTY4Bidm/P3HvwtprqrFhnuhqQQH0wQg2dSAZkA4NHEZJhtia+5zAPG9MDMrA96AQveIofey4UW1qlw0dOYw2DL8uEytksDppvWaxn7S49oqyWDbdoSq79ze5yrz65ymSdu3DNgVceeiThwbgQYLDPC4xeNS5IyOEPPAHIPcuX1I20NIetoV7rapocwlopgmYAPwEA1pkJyp4Bgcy8AfFKtNuConzGVHAZ4oJ+xzgjJ/lNMG18iYO9m5olMdcE/HUerg1onfC7u645D0uD4c/4WiIYotE2YmdJhRTj95ngf7NNlHO7+0zQhqWu48wx5uFE3Uc9IhgVAxAIS/jQ7TzUEctkxcGywbRsZVfhW7DrINdHDAB1XT8YDRs1lPkp5gHWu2rhHueMN7i2yvsXGQzCT2LGr3AFCW6yGuWUNFxV0wcJRWXL5erXrK8lqiSiJNxa7gMhekkXOERW/rzq0sGvqU9DFul7vITV01VUh/t/g7Zf5auTSDQ9kNmS7ElN0ZSR94cHSno7Xzy9qMYovCnWdHd+bRiKFDY/BOLh2mHtdpalQcBdw5gddMCjgukw50JOemUDmH6Kzj3DH7zORnaJoCdUxbPS1Eb4gpi+EgmUk4BidmRDEyxhvQVwu+YrWJ3Qt1mIUGtRsINAUX1tYFrWmVFUrjRYjKj8G14Ylysvhw9ocsGmQutOlWa1D1VVXTJ1PKxou7EH8852Pl8yhMuinjGGV8cNukpGXYuwiDlOBoSFHTvQF5nkdKruKmIYpUirv+REHwvSn7Fh3mdNqaaaE8LHqIg0WIRgjnxwfVKDRkEo7BiRmU3pNbvjC/kF1G52RQO7d2yvr6lPRhS3AomribKE5j6UskFZVlLyod2I4b8eb0N4X0F/O/IMvY9vxaVLZISEsZHI4Ex4LdWZQNzbaRMWXIaqqGla0luM5Tu5+qpIELDzzo1bwXmSfbkHYJjsRDKfhtZFIrTBM+OLDpAbVaTKZN4JomZDscgxMzSL06paJCz6nYGwA0c2Bjk+XaOBhLcFD+JZuWsNqPgkzY4HDfQ3bCKq5XrF3ehg0Ohqmh646qHewyXG8zGWxLmagor1wJjs4cwt+me9PuShq4wG3KLuHlfru2hW2NaNKBbQmObB0OqaSY0jXba9jHcz5WtqkjwcHIRuZVBcfgWIaOpINUERCGhRS2V24X0mwGR9Imd/El62ROdirGjaz9Fg1asNrgPo8C2yqqKODYgMnA3bh16jTNb8rUA6jHsI5KwfQ5NafWb1sfyp9uo1Cd9YvCLQffIqR/3/P3xnRRwP1AeSBRwB5wAIQER8MOzfa38sFXj2kNG5w9HbEyOA888AAcfPDBUK9ePSgqKtIq4/s+3H333dCiRQuoW7cuDBs2DObOFT1J2rdvnxwwif8PP/xwDG9gjignB2oDooDFn3jibKrYxG7T1PiMu/Di5+/MfCeUp3n95sr2ccwZiiYM7l1UOojDWJoLyhaAQpSN23Y/kW1aUL1R9ZmeyKMcXnB+U9UxFzY26vq16wvpdNxnhPuhY6OORvWNKh0VMhdQ2uAAzTzEbRckexZsk3K6AIgQciTDDFOsDM6OHTvgjDPOgMsvv1y7zCOPPAJPPvkk/POf/4SJEydC/fr14aijjoLt20WpxMiRI2HFihXJ/1dffbVt8q1AKsFh2EBEWbCoxR7HReG22aphK74EBz1funlpipy7oDORgoG0cP6g0bQuTVFoyLSKqqhOUeg3zpiSbtzMb0lushFOhsY2OKg8NghuVl+MGgvAl+CYjh+uIb0OTVEkVxzI7DYwyneWh35T0ZQOpv6TuZ+IbVrYeFVqelk/Ud5isQQfDNA4qM0g4VmUWD3OBieA++67D66//nro1UttlJaA7/vwxBNPwJ133gknnXQS9O7dG1566SVYvnw5vP/++0Lehg0bQklJSfJ//fr15ZVmGHgDkhmf4RuAg4MoygKF7/qxYYMT/G3Z5mXG+uXRv41W5uee6jA9+bn5xpMxHUbGHYo6iM+ZU/LOQ+5k5ceQfTes4qTKUJKudEhwKEkpthU5qtNRoTqUBpkSeqjxYWqrpLPZUGVsb0g63kCv/fqaso4oLvy2Ycr4BQPoJaDymgIA+HTup8o6/zbxb0Y0yRDs21YF4h1zUaSSexqyygZnwYIFsHLlShg2bFjyt8LCQhg4cCCMHy+G4X/44YehSZMm0KdPH3j00UehsjL17bAVFRWwadMm4X+6cMchdwhpHb256oSks2Ct27ZOSOPJLGMeKLsf6nQZt/uztE5DVQu1kWObBykNhu81tP1QIT1p+SR2fQ1rN2SVoSSI7896X7s8gIb6Mg0SHBxRlYyLw1zcpRIcQxWVDQkONQ/jkOAI6QgMVCYkOBQN+FoDClf0v0L5vaIwcXFLcGRjhc1U72EMUFYxOCtXrgQAgObNmwu/N2/ePPkMAOCaa66BN954A8aMGQOXXnopPPjgg3DLLaLhWhAPPfQQFBYWJv+3adMmnheQoGF+Q8FLAIsFZYMsCJlh4Zk9zmTRgCcb5YkVxYuKKoPFs1T0UlOXXRsGc5hRlIEtaSBo0mGqgtiyY0vo4lIODVH6iHvfkYypP7jNweoyzH6trBYPOFGMbSmDTAxSgsP1ooqgLlCpSQBou4qHj+DbLmI6qYi6GNkowYmy3qjWQB1VXjqgPCxLGGTqW3y76FtW+zrBCOMEm8G57bbbQga++P+sWby7Rbi44YYbYOjQodC7d2+47LLL4C9/+Qs89dRTUFEhv/jr9ttvh7KysuT/JUuWSPPFAQ88aNVwt2gQL0qz180ODapgxMkZa2aE6hzcZjCbhiAo0fmvq34NlVed2ovrFZMTY8LSCTqkJsE2ZkuzgR4nTxC477H0hauau/ubu/nSEYYNGFUeINo9ULY3NbbLNXiwb/G+yfQf9vsDW4ITh4oqaFcWBZjOhRsXKvM3qsuTXMhUVIe3P5xXhwUpEAXKPd5UlSe1XwmkP5n7ibGE2QZsS3BkwU5V2LB9Ayu/bbAZnBtvvBFmzpyp/N+xYzQL9ZKSEgAAWLVKNIJdtWpV8pkMAwcOhMrKSli4cKH0eX5+PhQUFAj/40LoJElwze/Nei+URzUodLwYMHRUVEHMXjc73K5iUdKh6dfVvyqfY+gwODPXzFTmp2g6vIN6YdahYc3WNWQeVZ1dm3YV0jqeWzYRZeGN5IJNtINdhU1VfzoqquBvuV4uW4ITh5ExR7q2ZccWLfWgClFUh6aSCUqCI7sShQtsUEvREMU7iLR/yjIJTugZknK3LWy7x6mgKLAZnOLiYujWrZvyf+3aqaPiqtChQwcoKSmBr77afTXBpk2bYOLEiXDQQQelLFdaWgo5OTnQrFnYMyLdkEXYDQ5uWfj2uO0TdCYzNRFU+T3w4LPfPmPRREFnwQkG+5OdpnRsGDg03H3o3SRNFKiAdFFcZk3UZFFsNCj1j5Sp53pmGTLx5MYP4SivVNRXnd9065PShJiuKJsiXn+iOBSoopp7ngcVVbsl5TrfFoMaL3/s80dl+YsPuJhsI1hnSYPw4RjTUJDPO/RSEhxMQ+nKUlb9tqCS1uJvF+VbZjtitcFZvHgxlJaWwuLFi6GqqgpKS0uhtLQUtmzZkszTrVs3eO+99wBg1we47rrr4P7774cPP/wQfv31Vzj//POhZcuWcPLJJwMAwPjx4+GJJ56AX375BebPnw+vvvoqXH/99XDuuedCo0Y8cWscwO7JeMC8UPoCqTdXIQqHjSVCkTY1lb7Z82DWWrtqyXSoqLgncK44X6dOk7GQwIZt4vclGTtDFRUpHZEs9Fxm05SJp1RUuAxFo6yf5m+Yr6Qpig0OV60hW19wnVyo7prywIPJyycbtWFqXN24bmOyjWAd9WuFPWxxG3/cX81UYVDqnfZF7cn3OKLDEaw2Mc7f7/zQb0FGrWHthkqJIGbSbNgtZhtiZXDuvvtu6NOnD9xzzz2wZcsW6NOnD/Tp0wcmT949QWbPng1lZWXJ9C233AJXX301XHLJJdC/f3/YsmULjB49GurUqQMAu9RNb7zxBgwZMgR69OgBDzzwAFx//fXwr3/9K85X0caAVgNCvwUHTbVfTZ4uKXDzb9u5TUjjBUbmMiu0J5GGcETpUWBqZAxgLp6PQ11EbbxRGJyd1eoozyEaDL8dV+X51oy3Yh/jXMNV6ZgOtIltYWT1jfpllLKNKDY4mOnCXnZc2I67JPWQsyzBsaFWo5h4/FvdWnXJOoPAzMHwTsOF9EGtDyLfY2Crgaw2MY7vcryUrgTO3+98tQRHYk9V0yQ49MVGBhg1ahSMGjVKmQd703ieByNHjoSRI0dK8x9wwAEwYQLPYDWdoAZIZXWl1ulSVb9tFdWQdkPgpxU/ke2mSscxKdhxcAimMcfLCblhkhIc4G2aOqDojNsGJ6QisyD5ojbJ1eWroUndJso6TOaEjIZUXnUJb74QM4EYHp1DiCnzQNngyOjAoKRIuI36teoLgfikqjeVLZKEPtsSnChqtVAeQ5rq5tWFbZXbUuQOMwe9mvWC39b/Jj5nSFLr5NUhw1aoyid/Q2M4mN6yY4uQVybBsR1WINOoWW+ThZAaowUG1Z8O+5PwvENRB7jkgEvs0kBtJsQpzPO8MCMasyjTigSHkFTYWEiDkInCqTqpjZlyp5YBR6oOisIP63CYsXdHHLFWTKWamAaZVAu/d0hFFXj+y6pflPTJ2jR9HuVE/dGcj1ht3HjQjaE2OcCbfhwSHG5MLR039c6NOwtpfPULrrNWrhj5GiPEHCBmYtbaWSxJVJR5qMOcBtM4vpVMJYqZ/j8d9ic2XdkEx+DEDFl47gUbFyT/zs/NFwbq0PZDlRNj+ebloef1atUT0sE7mgD4NhMyfLXgKyFtuklSYctt2+BQpx0ZuPfVHNPlGCEtUy9QJ/RgiAAAgAv2u4BFA8ZZPc9S0oD7RSfgGZYCxXJnl+EJ/PHxj5N1soyMI0hwKCnkzLUzhbSM6eJAx9YE269IN0lF338+73MWTTKYrke4X2TzFK9PF/W5SHiO3ecxDfhqDwxsg4MZPUoijmkEADix64lkGVV52XNVX+Z4OfDGtDeEdLAffPChfVF7Fk3ZBsfgxIDgJWy+7wuDDF/QBiAOVJl1fig/sUn2a9lP+Vy28Mou4ExVHv+msxDjzZ56xyhum0GUbS8zZsJaF7Q2okG2SHLtDeIQGav6RedbYoYG0yhbFLmbFk7fNug2ZXlsR4YN6ymJDaVq4TICAPS3e+mXl8T60IbEVf/IpA6YhpVbVgppU/VyFBUVpY7Ez2848AZl/g9nfyilS1UnRRMlwZGpNLnqRbyGnrHvGcr8qvKy37bt3EZK5nE6bsl8uuEYnBgQHDj4ynp8yvc8TwjmF8XQi9ocdIz6sP736M5HJ/9+a8ZbyjZ1JgUOvFVWUabMz7VFwe9YUVVBMmEyl31VnVzoSI2ovsN2Q08e/SSPBiZzqvMtcSRs3E+ySNmmEpw+Lfoo82t51ijE8fg5RhQjdsxMkPShuc9V/+ioLOZtmEeW4SAWI2NEU6fGnSLRxQFWwcsuYw1i/bb1Wqp/FTgMNgAIAWNT1R/87T8//4fFtEvnxB7O8DgGJ2bo3C+yfPPy5N9aEhxiQWAHPZO0R4louRIcylMLw7qKSvKO2L361O6nKmngngK5OnIZlm4Sb13nSpVC7RMMlk6/926m9jDSYex2VO1QPl+xZYXyOQZF9/yN84U6tuzcIrhDU6dX2TtRKigc3PL4fUSvlwv2v0BIV/vVRhuMjhpNZ/ylW524bNMy5fNQe54Hg9uqo7nj9QnTiMN5bNy+UUj/rsfvlPX/d8Z/yTaC6eCBMQGZg40KeA3VCrDJYNqjGBm3bNiSlT/dcAxOzMAqKmqD0TkRcRkarhGfrIzquc4Cx70vyVRFBYBo1FjI8c3cbNF7hI0+7ng/45eOh/FLxYtqVf2iU/8h7Q4R0tRVDVcPuDpU76Rl4qWi+PmzU55l0aWjDgrW8dqvr4W9qFTifMlYoNosqlMkpPEJ/MBWBwrpf0z+R1jtYUGFFASmmfLC0qmfSyNmDLF6XFZfMFifjrTDVKqED3jHdBYl77gNWT9Qa+S/fvqXkBfnwWp9ivmVXTfCYdqpd5Ah272uspu6PRRBzpztmmwhCB/l8RRlI1Y911lMqPfCxq06/RA8Fel4XpzU9aTQb6o2jWOE6EhwYhYBL9y4UBpdO1X7OvToBPYLonn95mx1DQZnPOrmMTUypsZ9l8ZdhDRWe1ASF0oqEKJHgwnD6VGlo7TqSdkmJfkCL/TeXO+y0CGR6PdaObW01jjVc0wDXjtk5VXfCtffv2V/0h6Keylyn5I+LAZFNh+ouY0lNlHWj3TCMTgxIGhf0rdlX56hV4TTCXfBCEVb1tiIMYKXrkXZXDAK64jG1zrMRXDhpJg0z/Pgkr6i+z2X2Vy7da0yfxTGkaIBu3xbcclmSnD+fcK/hTR1m3iURc5UBRVFKhmyd1HQIPv23FhNOsEDqVP/LYNuSVm/7NvNWidGGNdh6jgXJOqsVfjGctxmlV+lrPOqz65itYlDIcxZNydMF8Hs6hzaKGmb6bpPrRWYZpmjCEuCo6Gieu7E58g6sgmOwYkZ2IUbQzbRuCoqnKZOTNSNxb/v+XtyoE9dNXV3+xq6f+4GpbVhBd5bR4Jjyjj+beLfWOVtSHBwcC7bJySdExg+teF+CamoIixy3G8TRdVHlVEFdtOhibKP4h4EZOpqrgRn7KKxQppiTqOAkhI0zG+obFNHyh20yaKcA3SYhdC3R9HetQ4rBIOskpTK6uIeuHCdD33/EPsAheujGD2sumtb2FZJY6aRXdTUUJiIfHViI+BBiI3RqI0bP+/apKv1jZQd9ExnM2DYAWlJU4hFsKpaPGniyzfjkODgTdN2UD2dExjF0FAGwzr4bcNvyue4zg6NOgjpSBIctAGN/m00WYcKI/qMUNKkIyVQzYMjOx7Jkgrg8rI8WjZXbQ9J+YySfMmcJqi5/sX8L5T0fDL3E+VzKWNIvCduU+uwwuhbnX6urK4U0jrG1kFsqwy7hVMMcTDwI/UtZTRd0e8KFs3pRnZRsxdAR+wY/E0avIsYxFScEh0bCi7nT/1GeZOFPCs2L0uRU96GVLXy07+FvNxFDz/HovQoxtxcCU7Qw05Wngv8bXUkZyEGB0kBsKFqlE0USxowcB0jh45U0qgT9I67AVH12fBexEx7qG+ZEhyMKNeP1K+dOkK3bF4JzzWYDZz+fvH3JE0c2xIdRJIgYyNjDWloqmceePDm9DeV7XVr2k27fhmNsmfY0J461OHn2HnEMTh7IVSDDA+gn1b8REsjmFw21yhUVkZJj46+mil+fWbyM3SdkHqjBgBYsmmJsn2ujpsSpetsYNxAa6H8FiRrH83eHd5fZ1HmqoNsS/9kdWIPpZA68ei/hetg2q5R9FDMKpfRO7nbySEj49nrZmvXQalRotBEgTr1yzZ+U3uqBw5/gE0Td65zVZ7UoVBnTpTvKBfSuL7+Lfsrn8va4XwbmQ0OjoEWhWnPJByDk2G8NPUlaFfYLpn+bvF3wvMozAMeZBQXHqpPsihR+SmacJu9mvUS0lyDTdyGDlNIbkDEQoy906Iwjo/+8KiyDoxQVGpiPJzb+1zlc4BdQRAT0NlAMY1c7w4b4G7UTeqJl3sCqBd/7sIs3UQphofIP7DVQDOadCQ4hhu59Lnie1dUVbAPAtRagJ0kQvQQUiVpGaZkFZf57LfPjCSEOvZWkWz8GAdLmRcVNjiPsuZlEo7BSQNUqpQlZUtgSPshYn5i4+aqVjbv2CykrauoIpwkhrQT3zmSezwhwRHySt6JKoPVQ5S3R/COMdlzKV1EHsxMUPlbN7QbCBCAtsEJMuiyOmyc6kyllgB2pRc6myi+b02HAaI2ReWJXCN/6B4xjYMFVzJBhXygVLtUFHNqLHwy9xNj5lPHcH7e+t1RoScvnxyJSQrm5UqZdMYvFfogpGZjStqdBMdBiSq/Sn2y1Fi0aufWVj6PIjoPDtzz9ztfRnoS2ANBVic1Ma4aILqC6oB1QpIxisRkxPFjKBXV2EVjYb/m+2nTJENBfoGQNo3Fo4NgVFgdCQ5OY0/BtEhwCGkbV9UW5cRPjR8cDVdHEsLZkELPI0hw4lBRPXLkI0q6uLZKGDleDttmi/t8QKsBYn5J34YYWJUER0PSgX/D6w2Otixl4hmHC2xzQ40/WZs4Xb5TVLNlGo7BSQOCkgA84Kr9auOT5V+G/0VIkyoEaqFFp4mS+iWK3KKtSwJcA9y+Lfoq25CBI87X2ZC4Eh7Z80FtBmnTJGuTumuKMtaOcoK65IDd8YE88ODgNgcLzykjY5OTqy50xmwQNgy8bx98u7pNor6m9ZqyyuM6uEy5rL66teoK6UjeisQmGWy3bl7d0IXCXBUV13sIAOCP+/9RWSd3TFJrqEzypRoPWioqRCNWiYeif0veCTtnmBoZY9gICZFOOAYnDZi5dmbKZzhKJ4DGIocGVYeiDkK6VYEYEh6Dq6KKMoi5YmmcPqXbKaw2ohi+csXWOnWq6tcBdRM8yeBEkGTh8tj93YbRuilwnTg+EL4sVkfyiRd3DNUmJ1MpYGBbEUqFSamopq+eTkpwcJ23DrpVSJeuKhXSplc1JNpNQHYpKpeBiTKX8e3fXFUL1Qau754h94TK/LTiJxYNFLCEKIr0jbOG6RwCdeIoZZOayjE4acZFB1wkpKv9arVoUzKIy7aXpczfsHZDcnLiQfnZb5+F2jAZpB2KOsCwjsOUbVI4q+dZZJ4PZn+Q/DuKEV+fkvBiHESUhTgYyyKKASfF+FEnS1PkeDkh108cAI86xcXB8OA68SWkOIbIuq3rwnUo+jaKvQtlO3JkxyOFNBXfRXaiDkIndAJGk7qisXX7ovZCGtvnpaJL9Yyy47AhGeU8T9ChooG7RmLoXDKpOqhSzC1A+DBDHSxk0l+KIaaMjLnqRarNdMMxOGlG58adhbRURUUwF5/P/zxl/ijW+OOWjAvlN41ncMI+JwjpKHp2CsHoply1G0A4iB5XVSh7Llygp8EkhuLcEGUa122spikCY0oZtWNmgjJMTYcEBzMT+LRburI0XAdTQqe0h5GMp+B9Rfm5+SEa8Yb1zaJvBOkrrtOGkTF+h7p5dUN5TKBDM6Zh1Rbx+hEuc6Hl1MAcgw1ri9GWbahdOVLwddvWhdqgvDZDnqnNRc9UAB6TLlv3uepFqs10wzE4GQY2Mqai48pgekKiVFRceJ4nXOUga9NUD48RaVHMAhXVxGUThTTlmu55HnRv2j1ymzgMAW5DZ/PAEh78HEtTuDio9UFkHmozwO8xtP1Q5TzBBuWyOlTP6ubVFfpFJu7H0rePZn8UCqIXZRwnsLhsMXst0AGHqdLZ8Oaun6t8biPOEjWXMUPcvH5zdfkIdpIqOscvHR/Oz1Qv63xrjgQnipExta5e3u9yZX1xwzE4aYZsYQ4OiOL6xSTnr7otXMc2gBrEldWVoTpxSG4VPPDYMWO4NIba1FgcuJItSicdR8C7xWWLlW144AlG3Ud0OILVpmwjDzI9OuMH30eD8fSPT7NowpDFOaE2Qcqj5eoBVyu/dzDqdao2cP14c1CpJAA07qWTnKhl7apAHSSCRvA6wAEVZSBVfUxpCB6D+CZv2yEA6uTVIcvvrNqpXZ8MUZgyLPEL2ZlpHMhYNjjgheYRhpaKKlDn0PZDlfXFDcfgpBl44mAJTkjkKxmgU1ZMSVlnWUVZqI2ezXqK+YlB//SPTxu5k3peeKLYlshw8+ssvLI6g3n+edw/WeWjSMEoY1nP8wQDW2xEGqXNoG2H53laNKjS01ZPY9PABW6TkuAA8G9m50joMAONx04iT/ByQhlTRM197vfF7ziw9UBW+X8c+w+WYbPOJjtp+aRQHiE/YvQu63dZ6DnVBkZozSQOhTp2ihQ4KipZHsxc4uCVobhczDXO8zxYVLZISL8z8x0ljaT0X3KQzCQcg5NmUIuWjnqICt+P012bdhXSFPOycsvKSNKHVO1LaTQ0RNRpEz9fXb5aWYaavN2Luyuf69CE42voLFKqOmvl1hLj2Bh8t0R57PXHVd2ZIooUgPIuk7bDlIZgerDtiSqt+i34t0lsHgCNecb8djle+LLMIPDFl5gBl9EQupxVQmPwe+L4LzrvgGNzYTtDfMkkBqV2pWj4w35/YPc1zl9YR3S3/2Mf0RUe39mF9wUAcQxj1bYHXui+vmWb1IbslATnpoNvsqIWtYXsoWQvATWZdE5EVJ0Us4AXGF06dUEt5AAAx+9zvLIO6yoqz4NZa2ep82gwZkFEkRpd2f9KIf3twm+V7XGZqCjfjbTBoSQ4MTM8AAAz16QOtQCg4VIbQRpCSS6C2LJji1KiI/tNJjkIPpfZMnGkSrL8uF+woT1VnwwvlL4gtPfXCX9Npvdpsk/IM+zkricracRt4lvedVRUj094XEhjCd9BbXbbeclUM6ab9D5N9hFomrB0Aqt8YX5hKNp7nbw6yjJjFowJ/RbsW7z2eJ4Hp3Y/NZnW8aKiLnLOz81n719xwjE4aYbOAsUWbRKbIjZuXL9tPUkTPo1yTsiyBQO3ge0sqIUYA7vgRlE36DAoWMKCn3PbxB5IWGXAVQfZZjZkJ3ZjqZDGGA7e/i1rT2aUGQRXDQtg5sknk7RSEhzct7LywTZf/OVFabsqUPOIMmKX1Ue1OW/D7isLPM8TJC4tGrQIvfOh7Q5V1mdiaJ0KqvXI88I2g7gNHGGcAmZesSeiDNhlG69x1OE3ihr+sPaHCXm5h2WZNsCpqPZiUIMwyuZCDUoqOJOMJpMTjGzBsG1kHJyYOvVJFzFigUhHvI5QVGDi+5Npw8VfhxGMw7iaGzUY04DjvVDlAfjSMfxMqW5KITFSzVUZU8SlWdZmELYloxhbd25Vri8eeNC8QXNcTMwfYV5S/aJi5HK8nPA1LKg+HJVaR/rH7TvKhouLxnUbs8YwZrBTlRHSMimlgolPNxyDk2bgAfLvE/6tPPnhyKM6deI0vqtKK1BWYGCaehDI2sQDH3v3WDcyTrHhcMp44MH+Jfsn05SqL47JLVvsf1z2YzKNb443rT/RhpDHkDGk2o1ikCkbX60aqiN64zruOvQuZZ1BbN6xmZbgEIt/RWVFaIMxUZsBiKoXADqWCgUZI6fChKUTlONFevcecUCT0cSFyjsoinSXwuKyxSHbIYybD7455TOpJJWQ7nvgCTZ+Tx3zlFrNKqmPKz1zgf4cBOCP361pN6XufvLyyew6cRoHF9RRawR/e2z8Y8IzfDWEqmwC1CY5ZuEY5XMKUTYG3AZ1mSaAGBDs/rH3q9vUYKqodIdGYl/LFr2KqopkOhhoMAqktiNMtVgUtZmp5IKyd5EhB3iMm8xIM1V+2cKPT+XY43HLji3GG+sdh9yRkqZUdKkQZbMKuc9zxw/zW6f6LQh8SMPfgXvzO4VnJj8Dn8/7XJkH378XbCPVd1KpqPA71Mmro5SmyCQ43HkoO1hUVFZAtsAxOGmGbACt27aOzJMK+xbvqzXoVPVzT+37Fu8Ll/W9DBdR1kctcpi5wMZsZH0aE5NaxLD0g6oT3xatAyoIHtb14zg3GJhGHBlZB5SRcZfGXZRtymjqUdxDmeeq/uLt8ZjJP7nbySmf69CA80RiNlGZmw6+STt/qkODiu7Hxj9mzOjNWz9PSFNrARX3RIdRxMBtLtigvoMr1CbxHaKoqEKXUKL8R3c+mkdjBClSqA5KXWkoCeFKBHXUYjrM6c7q3cxkppkdx+BkGNNWT4M3pr2RTHMHdmV1JftExFVRASA7Dc+DQW1TBwyTMRMYmAadYF5BYKPTKIaJuAzlso0v08PqAB2E3GrRt+nVTAy3zpWmAIgXlV7U56LQcxVkCzcOMxCUGAGE7ROu6H8FaZSJ7/LBbr3XDrxWSRfl9UIt1o8Pf1xYiGVtRDGwTFU21e/BNtdvW2+sosL3hlEqKtPLWwEA/nrUX4U09pri1pkO5gLj4DYHC2mut5kNYAmOjGGmVFRCmrDpws9lKipqL6HWo5u+EA8F6YZjcNIMPAA2bNsgPtcQEwYxZ90c9qDTsnFQDGyKxij145gPsvuOhncanvz707mfstqk1HCp8gTx88qfQ5IGLmSRhAUa0Htg11AdmoN1dGrciaQJM6/BOovrFYfawLZHDxz+gJA+pvMxAgMqs1XC73n/d/cLz2SXZQo0axiMq2LK1MqtBS/98lIyPaTdEHLDCDIDeTl50KagTcr8qdS0lFrLOPigguZEG5z6dPIU1ytWtsFtM4rEmSvt0LHhCkLn8l9TUCrOUH6NsRCs8+0Zbyufe8C/qoH6trLYPOmEY3DSDDwAuIHepHVGUNdQ+Uk1l8p4Dcw9lmQTDW8oqvpDzzUWxVYFaqNUAFEFhCUZOuB+Gyq8PyWul7V375B7efUR4wtLcLDK9YmJTyhpBBA34l9W/kLSQEkIN2zboOzr+RvmC+lOjTqRYzBoJ7Zf8/2EYHGy/BipohsLzyOMYxUN2GMJPy+uLzInofZ0GCBDqRMZw8jQjghAQxJBpLHK3IYhrapNPFYSf3PWD3xYCdk5SiQ4cTCfmYRjcNIMyvZER296SNtDQmVUbWDUyhXvEsL5/zzsz0YDVcsGB9SLFrWIcb1DtJgu8ITTqGyy/7b+t+Tfr/36mrLNX1f/GqZDwSiqGDid8qrfgsDfXygrGUtcSdUPS34Q0mu3rmWVX7Z5GTleqLglG7ZvEH6bu0684BGfZicum0jOo6AazfO8EPOps9Gr+lJHgsNVxXZr2k1ZHl/1IasvWGdJg5IQY6faqMcsHEP2KzcKtY40FgNfe8CVcqcjOm/Q6y+VlFypopLMmQUbRfsnZX0aew+1bsehPjSBY3DSjJAEBxu2EotgQX5ByH6BK8GhJmvnxp3JOoJ2QxiyicKlSWZkrKoD2x6EyuowXWgxpyY7tuHA0PGAC4I64ctASd+4jKqM5jg2g2AZ2e3hXONY2cIb/E1nfLD7nplfWgYbeRrOXVy+pEGJsrzsYlNcX7DOmw++GZrVb8aikdoEqWCDIZoiMPXUeKHScTA4mObz9jtPaC/4XNZHsrESVIF7nheyGwxiZ9VOoY5qv5o95tPB+Jkgu6mrgcADRBYpV+Vpc2LXE8N1MiU4UYyMsSiT2rx1Lj9U0cSdOCqGCyDayWLllpVKbyAbpxVKRBzJHiFYp4RGfC9P8ATtg0+3qZE+rstxoXZTlZGNaer7Uy79uTm5Qh1Ufso+BkN2wtZhjlV9l+vlKts8osMR7A2I075OfZRUQZbmMqvVfrXgkq8TI+uXVb+EflOBu1Fz+y0KghHnddzEZWraoNSYuh7inZnvCP3wv3n/I2mk5shhHQ4j60gnHIOTZqhsDxLpv//4d+G3c3qdI9YRwWg4CB1L+VBId8LmAdPDyS+jKcfLgbp5dVPm59bveeHrJnAARACxL6asmAL5eflCHbhOLlQLo46ImDqJAgB8u+hbZR3YQJsK5BjFgJPDoMpc26kNBX+70IkbxBOwLADinYfcKZTnbMxRJD6+H2YecXuqfivILzA2Qo4U6A+/N5fhjSDpCl74WlZRpix/88E3w9cLvlbWx7UJpOyCuOuPDoLzUEeaRwX11FEN4zao4ITUHKHCQ6QbjsFJM6jNoqq6KnRXVFBd88rUV8gFhfJA0RKlB/L0bt6bLE+6hhILiozBUakVdMTaQXuaOevmQOO6jYXnl/S9JEwnYzE2PcXJYr1Qdc5ZN0dIyzasoOeCDnMSMnRHEiByw5JJQxiGp09Neir0nKvWkKobA2XemvFWqI2gLZLOxo3BlZzKNsVgmdycXGWb7816L1I4hCC4DI7sFm2uUTHXaDgYTBOA/tb7Nd9PSY+sTOg5kzHENl1R8L/fRInJlBVThPZkNAcdG7C0JIqUCb8XdWcWaYPjjIz3blCDzsoNwswFiNJp186tTS7mQbduz/NgUJtByvzURJG5iVPv9dQx4ka5ZusaIX1mjzOFNHZvxZt5jpej9JSKJMFBRn2h9iNIS5TPNRY5KvhgFJUV/g1fm8DdUCjDVKkNTqDMii0rSBo580j2rbgHB5zWchO3vFFTBr5vzXhLZHijqFGZ6dsG36akSWdTxW7dOgyxiiauBOf+w9RRzgEAZq2blfIZPnTI2mtX2E5Zv85agvNgA3IqfzpUdyZwDE6aERKFoon37qx3yTLUIMO3h2PITsfBAHMyFcP0NdOTf89aG56YQSmTBx4c2Sl8Ey6HpijGazjiLgbVLxgeeDBt9bRkmhJzc4EZiyhGpqY05OXkhU/pTAYZY1vltlCe0/c9nUUXNcZ1bGqC45TayKU2OCrpncZGjyFTUQU3Mh3JV/D7X7j/hcrnVHkA2sgYS1F1pLNN6okXn1IMCfb0wh5PVHsyNK7TWPmcYmBC+ZnMbJtC2iNSRdNv638zPthGYbjr166vzG8SPiQTcAxOmhEStSPOfOqqqWQZamHt2KijkgbZZMYuzYIxm+8LMRRmr5utXCA279gcqp9riCijkStp4NKAfyPvpzGczB/N+UjLMFVok7mpUs/bFrZV6vK1bC5QGxu2h2PQsOkmFmcdLyoKQRpk0hPSVo1rgwN+KM+kZZOE9jgMbvDQkYomVXkZjul8jJDGTJnM9ggDx1mi+pGKCE4xs5TKHEBjLhtKFDGo+hrUbmAkQdRBFAkOmZ+YZ06C4yDAhlQAl5Gpd3B+fPdKKI9io5ch2KY0urIFCc4LpS8INF1/4PWsNjBkCwy2P+GU1wF+r8FtBodo4JQ3XVDmb5hvzDiG8oMH5TvLlXmoCKfUYt+1iXh9BAY5ByTfmq2iUmxQsu+CmQUsucj1cmlJQqDeIHOkajcVjTLceeidyuey98bqP2zrRrVJRevG0GFet1duF9LY+FXnYl1Vm6b9fPq+pwsxtXTqDLWB8vdr2U9I6/QTPlDjeVO3lujowVXlZRrZRc1eAMpaXypVYHL6Oqf64EDUsU/AGNxW3JipSJ/cBYS6bBMgHD/Fhj2KSqKypGwJqz0Z8Hv+rqd4YSd34TT1qgEIR7sNlpExIliMLVvk8E3KmO5Hf3hUSROu88iOospzWMdhyvp1FtqgDQTXyFgmyaD6+rR9TxPyDG03VHiuo6KiPOSo8rVyUgd5BNgVAytUJ4hzArfx2W+fKWlg2+xQa6SGNPCN6WLYiEeOfERIUzZc+OoY2xu3B15Y/RdBxRRE/5b92eXxnX7H73O8kL7hwBuUdTojYwcBIRWVhjeQjY07CBsBxQ5ocYAyfxwSHAzTBUHWryovApNb3xOgIjBzv7WpigoA4O5D7ybzBIEDvekwF4vLFrPawHXg8cY2CpVISr+Y94W6TqaNA9XXnRt3hrnrU3vf6MxL7GEpq0MFinmQIeimLXPp37Jji9gGU42hiqwNEP52i8oWhZ4/Pvxx4Tesdi3MFxkWah5SUqUoB4tgnbL5QJkvUIii4qJscNgRoA0lyrbhGJw0Aw8IyqAOwFwcirFh2wZlGXxKkzFhKzaLUp/QImfopaDF4Bhu9lwVFL4hO8pphRtRNURTDAtKo7qNlG1Q0Lk24/1Z77PqND0x92ou3sou2yxWla8S2sN9WVGp8KCTqbSIb9GpUSdhnsgYw7i9qCjIygelHS9PfTmUBzMTpC0TeoeQSot4Byx92Vm9k7x+BkNHch4E+yAieR5USX614CvzbxXDWOBK25wEx0EAHiCyW2oHtBrAqoM7kKv9aqXkCFvwyzYHrEIi7TiIiWPDiwq3wQ06RXnaYK8VGxIcbLdhKsE5qetJxjRSoE6asneQRexWtsFVxaH8Qa9AGfAdPTL10JvT3xTbIOZdsHyQeUpFY8h2LkcdyVhWhmpDBpV9EiXhWV2+mi3psm03Jr2/j7nxUioqDO47fL/4+9Bv3DXQFFGMjLnzzBkZOwjAAyRkuwIenNf7PPG3CHY7KjTMbwifzP0k5fP/zfufMHBlzBAVt8bUYA7Xjw3oAMJB73A/YBdYaoGR3QsWREhsHeG0wl1YMagFhXsBJAD/LiCqfByLHNfFH4N6R9kmia8IEPJHsMGhYEN1zLUz00Gw77ZXbmdLX029g0Lrn8Z6RPUT9yoZ7jsEw0sksGTTEklOe4hy8OVKwal+xmnKozduOAYnRtSvFY4pEMXqHJehdN7c+jC48TgAwhtQFMNnZX0SmvGCYbrB4DZr56ivA4gCFXM6e91ssjx5gkqDiJhiuG2cRGXSDRPIruXAwPNKBQ8kt9NH2LiD9kw5Xg4s3ayOJGvaDwBqaWuUMc61vzNVw8rGPGkfhdL4oMEdsyQDheZE7+a9Q1cnxKFO5ALbdHHV9hSDJIvVlE44BidGUKHZAfQ4aKzGal/YniyjAs4vu4oBq6jwBoElNqZGxhgUwyRtk9sPiCZsYEd5huH2bz74ZrJNU2kHV0e+qWITq/4oiEOCY5tpumXQLcrnnufBs1OeDf2WKj1n3Ryte8FUGNJuiPBeOV6OlqRJ+dyQwY2i1qDWAuN5qpGfLcEx/HbUd8LPz9z3zBQ5dyMTKqpQ/DNUBjtdcFVUmXYbdwxOjMCW+zLIJBd4kGCvlaHth4p1GG6SMtUM9hhqXl90JcYDF9+LgsX7XHG+jm6XqxbjSpVG9BmhrB/TiL+TDNz4GxjcfrxrzF2s+qPA9DSsA/YGhDawpvWaCmmsysvxckJ2M6o2V5WvMpbgHN7hcMENP9fLJSU0XMkqFyH7Kt8nmQHuQcAUsj4iGX8L3oZBcBmo8p3l7AjzXNhQmWIa8AGJ28/4epx0wzE4MeDTsz+F3s17w8dnf0zmbVSnkZC+buB1ZJljuojRRk1PbbLLFv864a/KNvAic+ugW4X0zmrxhmrsKUGBYib+dfy/2MaOXFCBs+ZvmE/Wge2ATG1wTBfyOJAOFZXt95Jdk4GDw7E9cZjfUiZ1CNYh60fuVQwUothfcdVBphsvju8iO/xwJTimEuYoDBEVgwivqaQ0zzLTBmCuPsTA+1u64RicGHBMl2Pgl8t+CcXukKF+7frCRtquqB3bxdp0cuKJhC+YlBk/4jQ2wMUnZB2Vk+q5TK3GteDHbr+mEh8c+E+2IGHVXigYl2UJjs5YCF18SXiYUIhDghMH0xS8dfqq/lcJz2T9FvemR7mJ/+PYf4TKxC3yxzQt27yMLMM1POX204GtDxTLSxgo03lhYnit87x8R3nIlZ1y1KDuhaIQyU2c2Bt0VFA6+166ENtseeCBB+Dggw+GevXqQVFRkVaZd999F4YPHw5NmjQBz/OgtLQ0lGf79u1w5ZVXQpMmTaBBgwZw2mmnwapVYZfMPQk2vC9M2qMGdYPaDchIw/g5xbnbMGbDbc7bME9It2zYUkhjqZKpWDqKbcD1B10v1pEBCQ5mPjG4p3pTVY0ObBhkBqO0ntP7HGMajA8aks0iOF5kMbJseFFxys9aO4vc5CgVFVeVTN08LzvYxC3x4wJLCN+d9W7okEcxgjqG8UHI+jXI1EepI8p9fMF1N9PfITYGZ8eOHXDGGWfA5Zdfrl2mvLwcBg8eDH/+859T5rn++uvho48+grfeegu+/fZbWL58OZx66qk2SM4YVIsWvrgOwL5aAi9geFDff9j95GmDu/njO04wcHmZLhi3iVUMOBaKqTs0taHJjMqpCKlc92dqUczPzRfSB7c5mKwDgxtBFefHdyxh4Cs2dGDbeFZnQ8S/UZuFKcOcmxO+iwrPsw3bNijrxLZGFPq06KN87oEXmlcYtt3EqbVBR3UXt3chNUfwYcsDL3YbHBmC733HIXeQc4+UrGtIcGTRrjOF2Bic++67D66//nro1UsdcCuI8847D+6++24YNmyY9HlZWRk899xz8Pjjj8Phhx8Offv2hRdeeAF++OEHmDBhgi3SYwc10IODqLh+cei5acyZVgXiCeneofcq6ytpUBKqwzTAE2WQqxOTxNRzy7YKIkp8Di6DQ23Ul/a9VEhfO/Baso4gdCJrY2A7I2oR1TmZ6kRH5uKD2R+kfCarH/ftub3PNaZBqF+iosLei0d2Eu/g2lG1Q1nn4R0OZ9GAGSJZCIDvFn8n/Pbj8h+FtG03cQwdo2WubYjtQyEFz/PYNjim8DxRslUrpxZcdMBFYh6CYaGks7Jv8dOKnyLRGwf2KBucKVOmwM6dOwUGqFu3btC2bVsYP358ynIVFRWwadMm4X8mwRGnfrPwGytqiSCwjhTfzKzjkk2e0kxF5Ro2OtxTGlcygRFlk7XuMkuMBcxsyBgo6ttwF2+sCsQ0Hdb+MCEt60d8mSaGDdVLMPiazkKN1QzWNyDJ5oIDcK7aIqrfqYjQxpIuop87NeoUYrJ04tSo0lxgqeTmHZuNjYy5GNh6oPK5bA5Rd26xDzsaB7hgX+fm5MLOKrWaXkcqzaUhk9ijGJyVK1dC7dq1QzY9zZs3h5Urw7ceJ/DQQw9BYWFh8n+bNm1iplQNjvTjozkfkfWlYxDF7XYZKg/qjRsgLMmijGOtq6gkp10MbIsUtyuoDqOp2qg3bt8YnbgUbZ7Y9UQhLesDfK2GabRudqRaST/hwH/UdSRcyDbloKv6lOVTSPu4uCEbX/gWbIqh4XpQYuB3btGwhZBeUraELYkwBfVOMg87rqMFF1I1a6Bf8nLyhLAE+HkUmjId54YCi7rbbrstabGe6v+sWbPiojUybr/9digrK0v+X7Ik3pDZFPAgCsVbCTy3cds4BZJLR6JOgPgHNq7/rkPFeC4yGxzqqgVTRJFSPTb8MSFt2m8tGoiLeyTbEkqCYyjpIj0xJDThNuNQUQWhEwAx3R5LmGGfsXZGWB0ds9GmTv3rtooxsqgD2z5N9jEnDCFoa1ZZXcmX4GTA+JVjmhAHtOIsMWnIdgaHJRO78cYb4YILLlDm6dixowk9SpSUlMCOHTtg48aNghRn1apVUFISthNJID8/H/Lz81M+Tzf6t+wv6LVlNi4c2J4YMkkIqWox1LNj6JwC031NgY732W2DboOHxz2c/A0zJKbo0KiDkI6iKiTF0jFLumQ0mUbw5SJ0kpWMHdsqKQwdqYOOKi1OyBhPKixA7IwheAJdldWV1tVgppCqqJANzrGdj4XnS5/fXYZ5sOC+Y15OXkgK6XkeBJvlSr4oGrghJ2yDNRKLi4uhW7duyv+1a/Nc2zjo27cv1KpVC7766qvkb7Nnz4bFixfDQQfxPTMyhWeOe0Y7ryzGgyyPKfq26Jv8Gw/K8h3lIb133EZ8VP066gI8OZvUayK2YVkc63leyIA27UxXBJFzaBMzlOBg6NAUHHON6jQyVlHh/E3qNkmRcxfwtx3UZlDsY5xiDHS88o7tcqwRDRSuHnC1kPY8L7Q+4HgtwX7B18BEATVeqv1qttND3NISH3w4osMRu9vzvJCB73H7HGe1TSo+UF5OHjtStqkNzh7F4HCwePFiKC0thcWLF0NVVRWUlpZCaWkpbNmyW6/drVs3eO+995Lp9evXQ2lpKcyYMQMAdjEvpaWlSfuawsJCGDFiBNxwww0wZswYmDJlClx44YVw0EEHwYEHisGgsglYNNmjWQ+YdNEkWHDtAgAw11GbTlbf9+GEfU5IprGqZ8P2DcIN531b9I1dekLVJ3NFpPpBZsfDAX5nfH0FQPpPjrg9WVTqUJmYF3fKEyuK+sA0Qu8h7Q5RtymRplAeSR2KOiifU6Diosg2bpz+fc/fG9FAARuQA4Q3vZYNxDxBGm3YvshUnMHfdFTotpl2DJkaLuih5oEHh7Y7VHgeCvoZw7wM1ikLQ2Aqec92FVVs1N19993Qp08fuOeee2DLli3Qp08f6NOnD0yePDmZZ/bs2VBWVpZMf/jhh9CnTx847rhdnO1ZZ50Fffr0gX/+85/JPH/961/h+OOPh9NOOw0OPfRQKCkpgXfffTeu17CCBw5/IPRb/1b9oX1RewAQI3X6vi9M3nTY4LQpFI2u8SaZ64kTQzZRbENnoqVbLI3r/8N+fxCfgyTgWMzMBFW/7IbsuFVU7YraCeJ4HRVV0MPEA8lN3XH3o2QsnbHvGawypm0GDxkAuyJvB21w2ha2Dc07HBTPFDou3tR9atjVPQ5QarJ0HzRO3OdEqJuXOn6PD35IRYUlXzYC++HnQUm3zAYIXxDMNWpPh3bBBLHtUqNGjUpu1sH/Q4cOTebxfV+w6bngggukZe69995knjp16sDTTz8N69evh/Lycnj33XeV9jfZAO4gYetiDRf/ZvWbwevTXk+mZTZBmWYmpHmY720cjwPll7pgI7qpIGmmoPpp1C+jxPwSJixu6Kio/tjnj0LaVEXFRbqN6GU4f7/zhTQ+aMgiissCOdoEpR4CUPddHF5f2COpdm5tcmOO2/vszkPvJJ1DsJs47jd8iTIFLJGW7SM/r/w5mZatV3itpwKTYmTaDZxCdsuXagi4ekju5LRxSpq9bnbyb5no3XbwLgpx2z8AmAfZk/U7phsbs6YbMm+kuOMFJdrhPAsu1jZUVNS3xf2CoxRngsGRxUnBm6ZpoEgbWLRxkfJ5kOa4bDAa5jdM/t2oTiP+YcUyw1yvVj2BhvP3O1+QyPi+H/KIw+AatXM9onK9XNKjEZc5qdtJ6jYyLKGh4BicNOD3vXbpyXVPW8FFoVZuLVixZUXKvOfvdz7JZXMhY6iCAxkHkIoDuH6Z+NY0uKCpl0z3pt1D9ARp6lPSJ3bdv847B2+o19m4j+p0lAlJZDs6QdhMVVQ4mCVV/pqB1xi1ZwOYWcEMTSbCNWD44AuxegDM56FOm6r2sKQiE8A0DWozSAigWuVXxe6VR9GkE/QTl6GiLzsJjgO0L2oPG2/dCN9d+B2dGcQJje9TwhjecbgRbQmc1fOs5N+ndD8l9Dw4kGULbdygNqxrBlwTmpwdG4khC2wzZfuX7B+iCfdTugOzyXDlgCuTf+fm5JKLWo9mYtC9KAhGu+W6OnueZ6yi4qp9dbzf4h7zIQYH/JC6h7rY0jZk36pfy37aZeJi8BP2iwC7+gVf5UK1G+VKEgrUuE633WLPZj2FNKVSx5fw5nq5WW9jQ8ExOGlCYZ1C7QEelOAU1SlSLqzUxYa6CDJKg9sOJvOn3UZCYgMU7JeTu50cKoPv8YmbJvwbjteRLhpCeQL9JFNRxcGEBe1HQgEYJeOZMnROt5FxJlRUWIWxbuu6kMFuuumSqaKxxFjFMNsYWzIagm7/OnOMeyEsF7LAo0L7EhVV3Gsmvv4kNyeXtR5l4iBrG47ByULoLAqTL54Mb5/xNvRt2ZfMqwNqstkOU89FOmxybEDm6ptpBPsm1wtLcOIGXlSv7H9lipy7IGMM0y2pyASDg99x9rrZsat/KBpkoNandEhwMDK9EcvilQmMHoSlb+mgKQiZDZCgApUwktmyrkaFY3CyDJ0bdxY2Rc/zhNPwSV13GX31bdkXTtv3NGvt4sGNb/uesWZG8u+8nLzYjYyjIO7oyhR88LNORTVn3ZyQBAcj7kUMe2p0adJFSUMc/cYN/CaNtpymzTqIbGC8gpAa1qvcxG3EwZEwu8HfZG2k24tKpp7GhxvMYNi2naSY4bycPKVkVNbP2bCum8AxOFmCSRdNgrfPeBv2K9kvNNCCIv4L978wlvbx5Dio9e7I0D74go3CJQdcoqzL9OoJHcjC2GfDZMTi+UwbGS8qWyTQpONFZQN9SvqkfKbznUyDX3KRbYwEAMCok0aFbHAyTdfAVgOV825Yx2Fp8aLK9MGBAo5BU+1XhyQ4thkcCtgG58aDbhTSMubHSXAcrKB/q/5JiUwwJkjt3NrCopYJt1AA0QCtIL9AmTeORU3H6DPdsVIA6O8Rt4qKGxxMZmQcB4KLOfc7eeAJwS/TAR0bnHQz0E3rNc3IPU8qXHTARUrm4uhORyulAlGBQ1dw68UGtLYhU0/trNqZTPdq1ot0E4+bJmyDUzevrpAH3xK/pzM3AI7ByUoET68ndz0ZDutwWDKNg3+lAx540Khuo2RadrrO9GTQCWAXB434rh7s1hv3SbNurdTRU5N0EEbGcSMk+gYPPv79x6Hfkn9L7BniBmYcdlbvTJFTDtmVBrbhgw9D2g2JtQ0qoKfOAcu2kXGofmyQDmFpLh5z+JLaOIBpCEpwOjbqmPHLW2WeYybhHPYE7PlvUEPx8e8/hpsOugnO7X0u5OXkwQX7XwA9intYiVEiA+eULXuWbpGxji2AbWD3aZnnBDbay4TdRhCndj81rKJKgyRCdc2B53nKSxhl94zFDQ88IdQ+djsGUN9lFlefButtUrcJdG3aVZHbHFHUJpipDyIueqnrbLCKNB2bNaYDH0bjpgGvNbi9A1ocQN7hZZ2mDKsSHYOTpThun+Pg0eGPJrn+F056AX69/FfIz8uPpT2V67CWYWEgTamwogBPxDp5dVg2OI3qNEr5TBfY8BrfySWLEpppL6pm9ZoJ/ZLr5cKwjsNib/eGg25I/q2ziKabEZRtBi+e/GIyLZNUFNYpTFlfXMx1sN6bD745/QcJ3xeYVa6HW36u/fUKS/hkY6e4XrH1dinsW7xvSho88NKuosLtsSO3Z4FNoykcg7MHweYiOryTGCCQ62WCEdzoWzRoEZ0wTRzY+sCQWkN1Qvr5UvuRTpvWa0raG6g2pOBtw3HhwNYHim7iOblwSrdTYm83uJhixkDWJzhWTrrheR50btw5mc6UrRtGcHypJEixtZ8BdaEORvQZkfxbNp7O6LGbKUuXquWWQbck//bAC0XHVqmozut9nnH7oXhTOjGymJL6PQ2OwdlLgRdwzmD2wNMK3pZAMOpoVOhIa5rU2x386+oBVwtl8M29qcA12g1KaPq37C8yXeDBwNYDU5a9ddCtrLZ04Ps+NKy9+54eHM30qv5Xpc377JnjnoFLDrgkxExjm4k6eXVil3RR7+yBJ9iWpfu0ncBdh96V/PuwDocJG3kmmI0BrQZoudDrPIsKmXfP73v+fnda0idBKSV3TkdFUMXpgy/Yx1EHsE6NOhm3jy/2lbWHD2GF+amlkjUBjsFxAADaBgenOcbOA1ul3uSjInjZHsAu+nsU77aRuWfIPaSeXgbZRaMqNG/QPPn3ER2PCPUTVmvFgX2a7JP8u3PjzgLjhA2dL+xzYYi5jUtacVm/y+DZE54lPZKq/erYVVShuCjgw2Htdxvve54nfMvcHDpMfRC2NvZD2h6S/LterXrQqqCV8DzdKqo2BW2EtEztGnx3WYyjOMBh0qn7lNKFII1YnRUVg9oMSv5dUVURev7H/f8Y+i1IzzFdjlE+BwC4+ICLAQBg9Dmjo5KZMTgGZy9FcGLIIBijSZgffJ1DUEoT14kpeCqjxM6ym5l1QG20x3Y5VkjjvsGbZhwnWswwBlUruTm5oXcPvlOulyswgrh8uhDcoBrWbph2WyXf90OX31IBETlIVb5dYTsAoOefjKZsgAcSBifwLfFYioNx5UqxTux6Iiu/DWkKBo4pY0slG5zrMsN9Sj2sGucJep89/llYd8s6OKoz38El3fGsMByDs5eCYwgsW6TwRZPBiWZLjN68/u4TtQce22ARR8e1Aeymi+vdr2S/3c9i8qIKxkkCAOhZ3DNFzvCGJHMTT4faQ+U19afD/qRkcB498lFl3VHUSZ7nhdxmg9+Ky+Do3mX17QXfwv8N/j94+8y3WfUDhDenBw9/UEj3bWHn2hYM7IVXXF804E2HCshkHiWiv6cClqaksoex6Txh6+obPLeD0AmbocNAe54XmVFJ9/UUGI7BqaG4tO+lAAAwcuhIrfycTS5d9glX9L9CSOMJ3KeF6Aqqgq5oP50n5qjqhtBCRhgKBtvJVGwL1eZQXL9YyeBQakOdzY97Kamp90+iLsxEtStqBw8c8UDKaN+YWVB9r7aFbYV0HJuJ53lwcteTBXpwNPWECgNAEqNGc4zj/n72+Gd3P8vLV9ZjGnFXd85z5g713phJxNBVG3Mln5t3bBbSKq/cozsfzao7G+EYnBqKfxz3D5hxxQy489A7pc8pw0HVgtG/VX8WLbqnL2yMesI+Jwj04AU95AmWBkkE55bruFRU1LeT2ZsEacoGYJqVJ1FNmq8ZcA2dSUFDcLFPqJKiIkEzdwMa3HYwHNHhCLii3xVCPfhvaZsxMedBj6TcnNzQ5mvDu6t7cXchfUnfS+D/Bv8fnNT1JDi8w+HKsoe2O1R5hQ1X+hOUwgZhcjjA3y6xliWYiD/s/wdleewskIBK1SVbf/4+6e8krQk0qxe//WDcyA5fSAfryPFyQotGEOf2Phce/P7BZOBAavE8pO0h0LawLXRr2i000bmi21Rh+KmN7U+H/QnWbl0rFSFTUYMztbGnwwZBKcFBKiosffvzsD+z2m7VsBWdSYL7ht4HR7x0xG66ULRbFYNDIfHduXegccTuJ3c7WUgf2fFIIZ0qiizF4BTkF8Cmik3JdG5OLnx5/pcp61Uh6gZc0qAEVm5ZmUxf0e8K+Mfkf0hpkF3YqILJ+H/giAeSf8ucGpZevxTmbZgHh7Q7BFZsXpH8nbK56d5UXBcTY7H00lL4acVPKVVauH+b1msKa7eulebVXW8+PftT2LpzK+nlmUpqTo0vTEf5zvKUef9v8P8py+ri1O6nwrsz341U1jYcg7OXorBOISy5fkly0lJSgPy8fJh/zXzpIlq/lnpy2hIBN6rbCN44/Y1IbeD3SXVhaDoZIVvMjyx0vZD2U0twuHf0BF3xOTigxQFCGscPCi7U2Ag6DjSv3xwGtx0MXy/8WjAMT9KH+umfx/1TSKfaJBNIeLaRG5AFqcu5vc+FV6a+IriYm0AVnwlvtDcffLMwb6krKxJ5i+oUwcbtG5O/c+cvAECrglYhLzOAcJA/XBYztom29yvZL6X0BiA8VziMHnbKSLbteVohLFKtFX8e9mcY+uJQuOHAXYE1Wxe0hqWblu6qG9QS5MThdsKICfDJ3E/g3qH3knToIJuueMgeShxixSunvBL6TRViXQau62wCuhu5SXwNbmyXVBs71y5G1R+9m/VOj4qKssEJqqgM6bFhf+X7vrDJFOQXCCL4B48QjWfJzS8Co9i7eW+olVsLXj7l5ZDRtqzdoAu5CpMvngxn7HsGvPe79wDA/LJVLOmSbcAvnfwSrLppldLll4OgRBbPkzaFbYT+HtFnBHieB8tvWA4Lr10oDd8AAPDyKS9D3by68MnZn1ihEQN75QVB2erprmnvnPkOtC9qD2+e/qb0+YBWA5J/J9aRedfMg/+e/l/l1SUmGNJ+CGy5fQv85ai/aOUPqhMPanMQAAAMbD0QRh42ks2YpLJT0/UQTAecBGcvAfcyQFYMkBR583PzoaKqAo7upGesprougixLSDESOH3f0+HtGW+HDJijQrX51qtVLy1XEFAMQHBRw4aouI+DnmsyRD2dYRqDXnd5OXli5GMUfEy3TY7ROYWoTFXfln3hv2f8d3c+w7g1mA6ZdMXzPGW8peGdhsPn8z7XjpYbZGoSd1Mtu2EZVFRWQEF+gajy/P/jqUVDefTyRFTzc3ufC7/v+ftkfm7sJQ6jeOWAKwEAYPF1i2FV+SohTpQMukx/v5b9YMG1C1I+l13l0bFRR+jYqGPo9y6N1fGCOMEVgxKg83ufDw9+v/uAgNfUuw69C279Ui/AaNRD4lUDroI6eXWkktF0wzE4DgBgZiiYyk10ztVzYNKySXBq91OF31Mt+qZGfDpSnP+e/l/YVrmNrZpJ4PR9T4fbvrot6VqaMHSm1HQAEJrwUTc/ygYnWG+bgjbQqG4jePLoJ6FB7QbkxqK6bwkguqdOcBGmPEi6Ne0mpHXHxVGdjoLXT3s9pUFmnIjtsk2DUAcJQ+m3zngLPp/3eSiGEwfBA5IqRlYCH//+Yxj1yyhBGhccO1wvNc5BITEX2xS2gTaFbYjc0dXSUQ4vYy8YC+/Neg/+75D/ozNHwGn7npZkcDzPg9P3PR0e/eFRaF3QGgDSE5cmLycPLut3Wezt6MAxODUE+xbvCzPWzEjJNVMRRod3Gg5n9zob9mu+SwSus/m+ftrrcOuXt8LbZ8hjerQtbBvyfFJBZWSsswjp0Ox5npK5we0k+jWBTo07wZqb1ySlDN2Lu8NvV/+W8gQd3AAo5kEXHOlCo7qNAADg6oFXk3kBdp1SZejfsj/8uPxH4eoADvJy8mDtzWuh2q9OeWP1mpvXQPmO8pCdj+4G5HkenNXzrJTPf9fjd/Dm9F3qBWpzsmWLZbMdHFVYFwX5BXD6vqdr56do1tnYj9vnODhun+NSPufGzrnhwBvgli9voTOChreZpatKVOtNqj46pN0hcEi7Q6TPbAC/y4BWA2D2VbMjOQdw5wBWDWYDnA1ODcHn534ODxz+QEr9cOuC1jDpokkw56o50uc5Xg68euqrwoVxFM7qeRYsum4R9G1pJ8AYvvGbI+GQRR8NMjKpmJpE+PEL9r9A+rxPSVjt0bReU0HF0qlxp5DtgQyJ90lEfT6pm9xb48r+u0TsCUPoIzocIc2XAGYMOVFSExvNtMunwW2DboO/HyN3Ix3zhzEwfsR4IeZJEF+e9yU0qdsE3jnznZRtNanXRCm9aVqvKbQrCrtn25COeOCxNtWuTboq71DDYzOVJ6FNFRWlakkXbHwP/C7UZkpJ5bbt3Jb8W0eaujcg8Z32abJPUoJqU9KImThVMM9MwUlwaghaFbQixZ6c+DXYuDEdeOiIh+C39b+l3ERlWHjtQijfWQ7F9YthSdmS5O8e7PJO+Pzcz8EHP6WnwlGdjwL/ntR3Vv3t6L9BYX5hSgZIBc/zBNVf4gQ+88qZsG7rOqkHCADAX4/6K5zd62zo33LX98JXL1AnUJ17wkYOHQmfz/8c/rDfrvgbPZr1gIeGPZQyf/3a9VO69wPsuodrzc1rYvFCi1rnQa0PgvFLxwPArsX48n6Xw8tTX95VZ4qF/rsLv4PvFn0H5/Y+F3JzcmH6FdOFSxQTSCzu7575Ltz37X3w2mmvRaKRglEAu5g8Ao/oKHf35+C5E5+Da0ZfA1cPkEsWZW3u1zy1l1MwRAClbucY6auQDvu6BDhSTBVUHnIJDGw1ECYum8he89LZH7pwDI5D2pFqIjRv0BzGXjiWVZfsxB/EkZ2OVD6n0KReE3j6uKcjl8dh7gF2GW6mYm4AdjE0wXuS+rboC6N/07/oTscg864hd8FdQ+y4FScQ14aa6LeXT3kZznvvPHj9tNe1ynVr2i3J4ACA1NgTY3DbwYJLL3Up4indT4FTup+S8rnpoq9SLeAoybZAHWiCkrCoXnWtCloJ0r4/D/szHPnykXDdwOtStvnzpT+nHGN1a9WFNTevgdq5tdnjMBWz+8RRT8B1/7tOuLw2CCq6sgkwkxblwlBZP5zQ9QS4vN/lycOTDN//8XtYt3WdtudgNsMxOA5ZC5PNIWrZS/teCjd8foNwq7MtRKXpjkPugLp5deGErrsiO1MBEW1d5JctSGwW5/Y+F87scaa2qknV3+k6bVLMArURNqrbCEovLYX8vPzkd/73Cf+Gn1b8ZM0tHIOy16tXqx5csP8FUL6jnGVjp8KwjsNg022blKpeG9IJDq498Fo4bd/TUjKZcYyvj3//Mdzw+Q3w0skvAQDA8yc+D/d9ex+8cNILWuWp8ZTj5cA/jvuHMk9eTp4Wc5No67gux8Encz9JyZxmEo7BcZCiX4t+8P6s9wHA/sm8d7NdutrD2h8GYxaOsVq3Ka498FoY0GpA6DLRdKBrk67S3+vWqgt3HHpHMn1q91Nh5Lcjk0xYFBUVhSv7XwlP//g0/OmwPxnXZYogQxf1YkfbXk7pUtsChK8OuOiAi7TKRX3nIzseCU8f+7TSpkJ3w+VAx47NBjiRwBPeRzI8dcxT8If3/wC3DbrNGm3YOPvCPhfChX0utFa/Dbx66qtwzWfXwPtnvQ8AAO+f9T4s2rgIOjW2fwu7KRyD4yDFTQffBHeO2XWPle5iXq9WPdi6cysM7zhc+vynS36CV399NRlxlRtan4Ooi3uOlwOD2sYTqIqiqW6tsK2HDPVq1YPZV81OLsxxSHCePOZJuGrAVSmZrnQiso1EjCoEXZrS5a1lE57nWYsTlY1IFcmYi/P3Ox+O7XKsdcmRCdIxns7udTb8vufvk23l5eRlJXMD4LyoHFJAdctsKsy+aja8euqrcN2B10mf92nRBx4b/pg1d+k9DakMnR84/AHwwIP7D7tfuy7BhT4GCU6OlwPdmnbL6AZ8UteTYJ8m+0RWFx7a7tDk37be465D74JWDVvBHYfcQWcGSBpxB2kJImG4LTNkdrCLt894Gw5tdyg8dcxTALA74u4lfeXXtuggm5gbgN0BBON22c5GxlwGJ8FxsIbWBa3h7F5na+ffUyZJVCQYj6ePfRpen/Z6Shf8/zvk/+DqAVdHFtHjfuRefppppJK0vPe798AHP3IAyAv3vxBu/uJmOKDFAdCgdgMo35H6okFdjDxsJNw39D7tsfv3Y/8OR3U6Co7qfJT0+aiTRsFjPzyW8roIE6SKN7S34rR9T4PT9j0tmf7ivC9g+prp0LeFnTAXQaRThRlE3Vp1YcvtWyIH5KxpcAyOQ8bQtkBtoMhdJIJSp2y68O2K/leQIn+b9gc3HnQjjF86Hs7c90xrdWYCnqe+LFCn/Lpb1iXTQc8UXXVgqnp1Ua9WPfhdz9+lfF5cvxj+fCTvRncKr576Ktw15q6UF9M67ELdWnVTBrbck6FzeefeAsfgOGQMdxx6B6wqXwVn9rCzETer3wz+b/D/Qe3c2nvVJMdMQMP8hvC/c/+XIWqyF/Vr14evzv8KPFBHs97TcXavs5WS1F7NesGvq39NecO1gzlqunR6T4FjcBxIxHV/SYPaDeD5k563WucDRzxgtT4TpGuR29M363RG6D28w+FpaytbMfrc0fDCzy9oe2M5OOypcAyOQ0q8fMrLsKRsScrooXGDupQx25EuPfzFfS+Gt2e+Dcd1SX33TzZizlVzYN22dWSwRge7aNmwpRB2wME+MmWD4yDCMTgOKXFu73Mz2n7bwrbw6qmvxhaxtaagXq168N2F32WaDDa6NOkCXUAdVM7BwWE3BrUZBOOWjBNud3dIDcfgOGQ1OF5Z2Qanh3dwcLCJt854C56Y8ARc2u/STJOyR8AxOA4ODg4ODnsAWjRsYd3rriYje3xpHRwcHBwc9mAkDP4PaWf/LjsHPpwEx8EhJti+/8jBwSG7sfqm1VBWUeZsZLIEjsFxcHBwcHCwgPq16+9VMbiyHU5F5eBgGYl7hY7pckyGKYkP7YvaAwBAt6bdMkuIgzHuHXIvAOy6PNLBoSbBSXAcHCxjyfVLYN6GeTCg1YBMkxIbvjr/K3hiwhNww0E3ZJoUB0Nc2u9SGNZxGHRo1CHTpDg4WIVjcBwcLKNJvSbQpF6TTJMRKzo26ghPHvNkRmkY0GoATFo2CY7tcmxG6agJ6NS4U6ZJcHCwDsfgODg47JH4+Pcfw3+n/3ePjpXk4OAQHxyD4+DgsEeiuH4xXDngykyT4eDgkKVwRsYODg4ODg4ONQ6OwXFwcHBwcHCocXAMjoODg4ODg0ONg2NwHBwcHBwcHGocYmNwHnjgATj44IOhXr16UFRUpFXm3XffheHDh0OTJk3A8zwoLS0N5Rk6dCh4nif8v+yyy+wS7+Dg4ODg4LBHIzYGZ8eOHXDGGWfA5Zdfrl2mvLwcBg8eDH/+s/q21IsvvhhWrFiR/P/II4+Ykuvg4ODg4OBQgxCbm/h9990HAACjRo3SLnPeeecBAMDChQuV+erVqwclJSVRSXNwcHBwcHCo4dgjbXBeffVVaNq0KfTs2RNuv/122Lp1qzJ/RUUFbNq0Sfjv4ODg4ODgUHOxxwX6O/vss6Fdu3bQsmVLmDp1Ktx6660we/ZsePfdd1OWeeihh5ISJQcHBwcHB4eaD5YE57bbbgsZ+OL/s2bNiotWAAC45JJL4KijjoJevXrBOeecAy+99BK89957MG/evJRlbr/9digrK0v+X7JkSaw0Ojg4ODg4OGQWLAnOjTfeCBdccIEyT8eOHU3oYWPgwIEAAPDbb79Bp07yC+Py8/MhPz8/nWQ5ODg4ODg4ZBAsBqe4uBiKi4vjoiUSEq7kLVq0yCwhDg4ODg4ODlmD2GxwFi9eDOvXr4fFixdDVVVVkhHp3LkzNGjQAAAAunXrBg899BCccsopAADJ/MuXLwcAgNmzZwMAQElJCZSUlMC8efPgtddeg2OPPRaaNGkCU6dOheuvvx4OPfRQ6N27d1yv4uDg4ODg4LCHITYG5+6774YXX3wxme7Tpw8AAIwZMwaGDh0KALsYmLKysmSeDz/8EC688MJk+qyzzgIAgHvuuQfuvfdeqF27Nnz55ZfwxBNPQHl5ObRp0wZOO+00uPPOO1m0+b4PAOC8qRwcHBwcHPYgJPbtxD6ugufr5KphWLp0KbRp0ybTZDg4ODg4ODhEwJIlS6B169bKPHslg1NdXQ3Lly+Hhg0bgud5mSYnJTZt2gRt2rSBJUuWQEFBQabJSRv2xvfeG98ZwL333vTee+M7A7j3tv3evu/D5s2boWXLlpCTo3YE3+Pi4NhATk4OyfllEwoKCvaqiZHA3vjee+M7A7j33puwN74zgHtvmygsLNTKt0dGMnZwcHBwcHBwUMExOA4ODg4ODg41Do7ByWLk5+fDPffcs9cFKdwb33tvfGcA995703vvje8M4N47k++9VxoZOzg4ODg4ONRsOAmOg4ODg4ODQ42DY3AcHBwcHBwcahwcg+Pg4ODg4OBQ4+AYHAcHBwcHB4caB8fgZAgPPfQQ9O/fHxo2bAjNmjWDk08+OXm5aCqMGjUKPM8T/tepUydNFNvBvffeG3qHbt26Kcu89dZb0K1bN6hTpw706tULPv300zRRaw/t27cPvbfneXDllVdK8++J33rs2LFwwgknQMuWLcHzPHj//feF577vw9133w0tWrSAunXrwrBhw2Du3LlkvU8//TS0b98e6tSpAwMHDoRJkybF9AbRoHrvnTt3wq233gq9evWC+vXrQ8uWLeH8889PXiicClHmSbpBfe8LLrgg9A5HH300WW82f2/qnWVz3PM8ePTRR1PWme3fWmev2r59O1x55ZXQpEkTaNCgAZx22mmwatUqZb1R1wMOHIOTIXz77bdw5ZVXwoQJE+CLL76AnTt3wvDhw6G8vFxZrqCgAFasWJH8v2jRojRRbA89evQQ3uH7779PmfeHH36A3//+9zBixAj4+eef4eSTT4aTTz4Zpk2blkaKzfHjjz8K7/zFF18AAMAZZ5yRssye9q3Ly8thv/32g6efflr6/JFHHoEn/197dxvS1NvHAfxrtVlGaGVumm2opEWllOCYEYFKaoJSgRoSRs+mkD2AvRGJXlQUvfj7wnyRWgiWgib9hcRnQszIGZnJUBmK5JSEmaI22X73i/t2NN2DWzm3c/8+IHjOrnN5/fzuOufyuLF//sGzZ8/Q3d2NrVu3IjExEQsLC1b7fP36NW7duoWioiKoVCpERUUhMTERk5OTa1WGw2zVPTc3B5VKhcLCQqhUKtTW1kKtViM1NdVuv47Mk/VgL28ASEpKMquhqqrKZp/unre9mn+vdXx8HGVlZfDy8sKZM2ds9uvOWa/mWnXz5k28ffsWNTU16OjowPfv33H69Gmb/TpzPnAYMbcwOTlJAKijo8Nqm/LycvL19XXdoNZAUVERRUVFrbp9eno6paSkmO1TKBR09erVvzwy17px4waFhYWR0Wi0+LinZw2A6urqTNtGo5GkUik9fvzYtE+n05G3tzdVVVVZ7ScmJoZyc3NN2waDgYKCgujBgwdrMu4/tbxuSz5+/EgAaGRkxGobR+fJerNUd3Z2NqWlpTnUjyflvZqs09LSKC4uzmYbT8t6+bVKp9ORSCSimpoaU5uBgQECQF1dXRb7cPZ84Ci+g+MmpqenAQA7duyw2W52dhZyuRx79uxBWloa+vv7XTG8v2pwcBBBQUEIDQ1FVlYWRkdHrbbt6upCQkKC2b7ExER0dXWt9TDXjF6vR2VlJS5cuGDzw16FkPUSjUYDrVZrlqWvry8UCoXVLPV6PXp6esyO2bBhAxISEjw6/+npaXh5ecHPz89mO0fmibtqb29HQEAAIiIikJOTg6mpKatthZb3xMQEGhoacPHiRbttPSnr5deqnp4eLC4umuW2b98+yGQyq7k5cz5wBi9w3IDRaER+fj6OHj2KgwcPWm0XERGBsrIy1NfXo7KyEkajEbGxsRgbG3PhaP+MQqFARUUF3r17h5KSEmg0Ghw7dgwzMzMW22u1WkgkErN9EokEWq3WFcNdE2/evIFOp8P58+etthFC1r9bysuRLH/8+AGDwSCo/BcWFlBQUICzZ8/a/ABCR+eJO0pKSsLLly/R0tKCR48eoaOjA8nJyTAYDBbbCy3vFy9eYNu2bXb/VeNJWVu6Vmm1WojF4hULdlu5OXM+cMb/5aeJu5vc3Fx8/frV7v9dlUollEqlaTs2Nhb79+9HaWkp7t+/v9bD/CuSk5NN30dGRkKhUEAul6O6unpVf+kIwfPnz5GcnIygoCCrbYSQNTO3uLiI9PR0EBFKSkpsthXCPMnMzDR9f+jQIURGRiIsLAzt7e2Ij49fx5G5RllZGbKysuy+OcCTsl7ttcpd8B2cdZaXl4d///0XbW1tCA4OduhYkUiEw4cPY2hoaI1Gt/b8/PwQHh5utQapVLri1fgTExOQSqWuGN5fNzIygubmZly6dMmh4zw966W8HMnS398fGzduFET+S4ubkZERNDU12bx7Y4m9eeIJQkND4e/vb7UGIeX9/v17qNVqh+c54L5ZW7tWSaVS6PV66HQ6s/a2cnPmfOAMXuCsEyJCXl4e6urq0NraipCQEIf7MBgM6OvrQ2Bg4BqM0DVmZ2cxPDxstQalUomWlhazfU1NTWZ3NzxJeXk5AgICkJKS4tBxnp51SEgIpFKpWZY/f/5Ed3e31SzFYjGio6PNjjEajWhpafGo/JcWN4ODg2hubsbOnTsd7sPePPEEY2NjmJqaslqDUPIG/nuXNjo6GlFRUQ4f625Z27tWRUdHQyQSmeWmVqsxOjpqNTdnzgfODp6tg5ycHPL19aX29nYaHx83fc3NzZnanDt3ju7evWvavnfvHjU2NtLw8DD19PRQZmYmbd68mfr7+9ejBKfcvn2b2tvbSaPRUGdnJyUkJJC/vz9NTk4S0cqaOzs7adOmTfTkyRMaGBigoqIiEolE1NfXt14lOM1gMJBMJqOCgoIVjwkh65mZGert7aXe3l4CQE+fPqXe3l7Tu4UePnxIfn5+VF9fT1++fKG0tDQKCQmh+fl5Ux9xcXFUXFxs2n716hV5e3tTRUUFffv2ja5cuUJ+fn6k1WpdXp81turW6/WUmppKwcHB9PnzZ7O5/uvXL1Mfy+u2N0/cga26Z2Zm6M6dO9TV1UUajYaam5vpyJEjtHfvXlpYWDD14Wl523uOExFNT0+Tj48PlZSUWOzD07JezbXq2rVrJJPJqLW1lT59+kRKpZKUSqVZPxEREVRbW2vaXs354E/xAmedALD4VV5ebmpz/Phxys7ONm3n5+eTTCYjsVhMEomETp48SSqVyvWD/wMZGRkUGBhIYrGYdu/eTRkZGTQ0NGR6fHnNRETV1dUUHh5OYrGYDhw4QA0NDS4e9d/R2NhIAEitVq94TAhZt7W1WXxOL9VlNBqpsLCQJBIJeXt7U3x8/IrfhVwup6KiIrN9xcXFpt9FTEwMffjwwUUVrY6tujUajdW53tbWZupjed325ok7sFX33NwcnThxgnbt2kUikYjkcjldvnx5xULF0/K29xwnIiotLaUtW7aQTqez2IenZb2aa9X8/Dxdv36dtm/fTj4+PnTq1CkaHx9f0c/vx6zmfPCnvP73gxljjDHGBINfg8MYY4wxweEFDmOMMcYEhxc4jDHGGBMcXuAwxhhjTHB4gcMYY4wxweEFDmOMMcYEhxc4jDHGGBMcXuAwxhhjTHB4gcMYY4wxweEFDmOMMcYEhxc4jDHGGBMcXuAwxhhjTHD+Az7f1Vy4MJYIAAAAAElFTkSuQmCC\n"
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.figure()\n",
+    "plt.plot(timesteps[stationary_timestep:],values[stationary_timestep:], color=\"green\")\n",
     "plt.show()\n"
    ],
    "metadata": {
@@ -174,6 +190,30 @@
      "name": "#%%\n"
     }
    }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 29,
+   "outputs": [],
+   "source": [],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "outputs": [],
+   "source": [],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   }
   }
  ],
  "metadata": {
diff --git a/examples/create_cascadedomain2d.ipynb b/examples/create_cascadedomain2d.ipynb
index edcec248d9c3cccbb48b65706dd8bcf14538fc14..669e24d6649ba8f8eb34a17fbee820b2d41139e2 100644
--- a/examples/create_cascadedomain2d.ipynb
+++ b/examples/create_cascadedomain2d.ipynb
@@ -164,7 +164,7 @@
    ],
    "source": [
     "domain2d = CascadeDomain2D()\n",
-    "domain2d.from_cascade_parameters(domainparas)\n",
+    "domain2d.generate_from_cascade_parameters( domainparas)\n",
     "domain2d.plot()"
    ],
    "metadata": {
diff --git a/examples/postprocess_cascade_case.ipynb b/examples/postprocess_cascade_case.ipynb
index f2209ca254f6bdfe180bddd0fb73cb06800803ea..082c61fd260b96ce2bb3cf517e3e3ef0c3fff51d 100644
--- a/examples/postprocess_cascade_case.ipynb
+++ b/examples/postprocess_cascade_case.ipynb
@@ -15,13 +15,27 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 1,
-   "outputs": [],
+   "execution_count": 15,
+   "outputs": [
+    {
+     "ename": "ValueError",
+     "evalue": "Invalid Jupyter notebook plotting backend \"trame\".\nUse one of the following:\n\"ipyvtklink\", \"panel\", \"ipygany\", \"static\", \"pythreejs\", \"none\"",
+     "output_type": "error",
+     "traceback": [
+      "\u001B[0;31m---------------------------------------------------------------------------\u001B[0m",
+      "\u001B[0;31mValueError\u001B[0m                                Traceback (most recent call last)",
+      "Cell \u001B[0;32mIn[15], line 4\u001B[0m\n\u001B[1;32m      1\u001B[0m \u001B[38;5;28;01mfrom\u001B[39;00m \u001B[38;5;21;01mntrfc\u001B[39;00m\u001B[38;5;21;01m.\u001B[39;00m\u001B[38;5;21;01mcascade_case\u001B[39;00m\u001B[38;5;21;01m.\u001B[39;00m\u001B[38;5;21;01msolution\u001B[39;00m\u001B[38;5;21;01m.\u001B[39;00m\u001B[38;5;21;01mgeneric\u001B[39;00m \u001B[38;5;28;01mimport\u001B[39;00m GenericCascadeCase\n\u001B[1;32m      2\u001B[0m \u001B[38;5;28;01mimport\u001B[39;00m \u001B[38;5;21;01mpyvista\u001B[39;00m \u001B[38;5;28;01mas\u001B[39;00m \u001B[38;5;21;01mpv\u001B[39;00m\n\u001B[0;32m----> 4\u001B[0m \u001B[43mpv\u001B[49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43mset_jupyter_backend\u001B[49m\u001B[43m(\u001B[49m\u001B[38;5;124;43m'\u001B[39;49m\u001B[38;5;124;43mtrame\u001B[39;49m\u001B[38;5;124;43m'\u001B[39;49m\u001B[43m)\u001B[49m\n\u001B[1;32m      6\u001B[0m inlet_path \u001B[38;5;241m=\u001B[39m \u001B[38;5;124m\"\u001B[39m\u001B[38;5;124m../data/openfoam_cascade_case/boundary/inlet.vtp\u001B[39m\u001B[38;5;124m\"\u001B[39m\n\u001B[1;32m      7\u001B[0m outlet_path \u001B[38;5;241m=\u001B[39m \u001B[38;5;124m\"\u001B[39m\u001B[38;5;124m../data/openfoam_cascade_case/boundary/outlet.vtp\u001B[39m\u001B[38;5;124m\"\u001B[39m\n",
+      "File \u001B[0;32m~/miniconda3/envs/NTRfC/lib/python3.10/site-packages/pyvista/jupyter/__init__.py:141\u001B[0m, in \u001B[0;36mset_jupyter_backend\u001B[0;34m(backend)\u001B[0m\n\u001B[1;32m     69\u001B[0m \u001B[38;5;28;01mdef\u001B[39;00m \u001B[38;5;21mset_jupyter_backend\u001B[39m(backend):\n\u001B[1;32m     70\u001B[0m     \u001B[38;5;124;03m\"\"\"Set the plotting backend for a jupyter notebook.\u001B[39;00m\n\u001B[1;32m     71\u001B[0m \n\u001B[1;32m     72\u001B[0m \u001B[38;5;124;03m    Parameters\u001B[39;00m\n\u001B[0;32m   (...)\u001B[0m\n\u001B[1;32m    139\u001B[0m \n\u001B[1;32m    140\u001B[0m \u001B[38;5;124;03m    \"\"\"\u001B[39;00m\n\u001B[0;32m--> 141\u001B[0m     pyvista\u001B[38;5;241m.\u001B[39mglobal_theme\u001B[38;5;241m.\u001B[39m_jupyter_backend \u001B[38;5;241m=\u001B[39m \u001B[43m_validate_jupyter_backend\u001B[49m\u001B[43m(\u001B[49m\u001B[43mbackend\u001B[49m\u001B[43m)\u001B[49m\n",
+      "File \u001B[0;32m~/miniconda3/envs/NTRfC/lib/python3.10/site-packages/pyvista/jupyter/__init__.py:35\u001B[0m, in \u001B[0;36m_validate_jupyter_backend\u001B[0;34m(backend)\u001B[0m\n\u001B[1;32m     33\u001B[0m \u001B[38;5;28;01mif\u001B[39;00m backend \u001B[38;5;129;01mnot\u001B[39;00m \u001B[38;5;129;01min\u001B[39;00m ALLOWED_BACKENDS:\n\u001B[1;32m     34\u001B[0m     backend_list_str \u001B[38;5;241m=\u001B[39m \u001B[38;5;124m'\u001B[39m\u001B[38;5;124m, \u001B[39m\u001B[38;5;124m'\u001B[39m\u001B[38;5;241m.\u001B[39mjoin([\u001B[38;5;124mf\u001B[39m\u001B[38;5;124m'\u001B[39m\u001B[38;5;124m\"\u001B[39m\u001B[38;5;132;01m{\u001B[39;00mitem\u001B[38;5;132;01m}\u001B[39;00m\u001B[38;5;124m\"\u001B[39m\u001B[38;5;124m'\u001B[39m \u001B[38;5;28;01mfor\u001B[39;00m item \u001B[38;5;129;01min\u001B[39;00m ALLOWED_BACKENDS])\n\u001B[0;32m---> 35\u001B[0m     \u001B[38;5;28;01mraise\u001B[39;00m \u001B[38;5;167;01mValueError\u001B[39;00m(\n\u001B[1;32m     36\u001B[0m         \u001B[38;5;124mf\u001B[39m\u001B[38;5;124m'\u001B[39m\u001B[38;5;124mInvalid Jupyter notebook plotting backend \u001B[39m\u001B[38;5;124m\"\u001B[39m\u001B[38;5;132;01m{\u001B[39;00mbackend\u001B[38;5;132;01m}\u001B[39;00m\u001B[38;5;124m\"\u001B[39m\u001B[38;5;124m.\u001B[39m\u001B[38;5;130;01m\\n\u001B[39;00m\u001B[38;5;124m'\u001B[39m\n\u001B[1;32m     37\u001B[0m         \u001B[38;5;124mf\u001B[39m\u001B[38;5;124m'\u001B[39m\u001B[38;5;124mUse one of the following:\u001B[39m\u001B[38;5;130;01m\\n\u001B[39;00m\u001B[38;5;132;01m{\u001B[39;00mbackend_list_str\u001B[38;5;132;01m}\u001B[39;00m\u001B[38;5;124m'\u001B[39m\n\u001B[1;32m     38\u001B[0m     )\n\u001B[1;32m     40\u001B[0m \u001B[38;5;66;03m# verify required packages are installed\u001B[39;00m\n\u001B[1;32m     41\u001B[0m \u001B[38;5;28;01mif\u001B[39;00m backend \u001B[38;5;241m==\u001B[39m \u001B[38;5;124m'\u001B[39m\u001B[38;5;124mpythreejs\u001B[39m\u001B[38;5;124m'\u001B[39m:\n",
+      "\u001B[0;31mValueError\u001B[0m: Invalid Jupyter notebook plotting backend \"trame\".\nUse one of the following:\n\"ipyvtklink\", \"panel\", \"ipygany\", \"static\", \"pythreejs\", \"none\""
+     ]
+    }
+   ],
    "source": [
     "from ntrfc.cascade_case.solution.generic import GenericCascadeCase\n",
     "import pyvista as pv\n",
     "\n",
-    "pv.set_jupyter_backend(\"static\")\n",
+    "pv.set_jupyter_backend('trame')\n",
     "\n",
     "inlet_path = \"../data/openfoam_cascade_case/boundary/inlet.vtp\"\n",
     "outlet_path = \"../data/openfoam_cascade_case/boundary/outlet.vtp\"\n",
@@ -44,17 +58,8 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/home/many/miniconda3/envs/NTRfC/lib/python3.10/site-packages/pyvista/core/filters/poly_data.py:2772: PyvistaFutureWarning: The default value of the ``capping`` keyword argument will change in a future version to ``True`` to match the behavior of VTK. We recommend passing the keyword explicitly to prevent future surprises.\n",
-      "  warnings.warn(\n"
-     ]
-    }
-   ],
+   "execution_count": 16,
+   "outputs": [],
    "source": [
     "\n",
     "case.set_active_blade_slice()\n",
@@ -69,20 +74,12 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": 17,
    "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/home/many/miniconda3/envs/NTRfC/lib/python3.10/site-packages/pyvista/core/pointset.py:326: PyvistaDeprecationWarning: You did not specify a value for `inplace` and the default value will be changing to `False` in future versions for point-based meshes (e.g., `PolyData`). Please make sure you are not assuming this to be an inplace operation.\n",
-      "  warnings.warn(DEFAULT_INPLACE_WARNING, PyvistaDeprecationWarning)\n"
-     ]
-    },
     {
      "data": {
       "text/plain": "<Figure size 640x480 with 1 Axes>",
-      "image/png": "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\n"
+      "image/png": "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\n"
      },
      "metadata": {},
      "output_type": "display_data"
@@ -98,6 +95,32 @@
     }
    }
   },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "outputs": [
+    {
+     "ename": "AttributeError",
+     "evalue": "'GenericCascadeCase' object has no attribute 'compute_avdr_inout_massave'",
+     "output_type": "error",
+     "traceback": [
+      "\u001B[0;31m---------------------------------------------------------------------------\u001B[0m",
+      "\u001B[0;31mAttributeError\u001B[0m                            Traceback (most recent call last)",
+      "Cell \u001B[0;32mIn[14], line 1\u001B[0m\n\u001B[0;32m----> 1\u001B[0m \u001B[38;5;28;43;01mcase\u001B[39;49;00m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43mcompute_avdr_inout_massave\u001B[49m()\n",
+      "\u001B[0;31mAttributeError\u001B[0m: 'GenericCascadeCase' object has no attribute 'compute_avdr_inout_massave'"
+     ]
+    }
+   ],
+   "source": [
+    "case.compute_avdr_inout_massave()\n"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   }
+  },
   {
    "cell_type": "code",
    "execution_count": null,
diff --git a/examples/timewindow.py b/examples/timewindow.py
deleted file mode 100644
index 4623a01496caface965a240f0336ba0b868c9eab..0000000000000000000000000000000000000000
--- a/examples/timewindow.py
+++ /dev/null
@@ -1,190 +0,0 @@
-import numpy as np
-import matplotlib.pyplot as plt
-import itertools
-
-from ntrfc.timeseries.stationarity import estimate_stationarity
-
-
-def mean_squared_error(x, y):
-    return np.mean((x - y) ** 2)
-
-
-def test_stationarity():
-    def sine(x, f, a):
-        return np.sin(x * f) * a
-
-    def tanh(x, c, a):
-        return np.tanh(x * c) * a
-
-    def step(x, c, a):
-        return np.piecewise(x, [x < c, x >= 2 / 2 * np.pi], [0, 1]) * a
-
-    def linear(x, g):
-        return x * g
-
-    def dirac(x, c, a):
-        return a * np.isclose(x,c)
-
-    def euler(x, c, a):
-        return np.e ** (-x * c) * a
-
-    def noise(x, a):
-        res = np.random.rand(len(x)) * a
-        np.random.shuffle(res)
-        return res
-
-    sine_frequencies = [24, 100]
-    sine_amplitudes = np.linspace(0.5, 4, 1)
-    sine_resolutions = [8000, 13000]
-
-    res = []
-    for frequency, amplitude, resolution in itertools.product(sine_frequencies, sine_amplitudes, sine_resolutions):
-        # Do something with frequency and amplitude
-        x = x_vals(resolution)
-        f = sine(x, frequency, amplitude)
-        ans = estimate_stationarity(f)
-
-        res.append(ans / len(x))
-        plt.plot(f)
-        plt.vlines(ans, ymin=min(f), ymax=max(f), colors=["red"])
-        plt.grid()
-        plt.show()
-
-    plt.figure()
-    plt.hist(res)
-    plt.show()
-
-    tanh_c = [3]
-    tanh_amplitudes = np.linspace(0.2, 1, 1)
-    tanh_resolutions = [1000, 10000, 20000]
-
-    res = []
-    for frequency, amplitude, resolution in itertools.product(tanh_c, tanh_amplitudes, tanh_resolutions):
-        # Do something with frequency and amplitude
-        x = x_vals(resolution)
-        f = tanh(x, frequency, amplitude)
-        ans = estimate_stationarity(f)
-
-        res.append(ans / len(x))
-        plt.plot(f)
-        plt.vlines(ans, ymin=min(f), ymax=max(f), colors=["red"])
-        plt.grid()
-        plt.show()
-
-    plt.figure()
-    plt.hist(res)
-    plt.show()
-
-    euler_c = [10]
-    euler_amplitudes = np.linspace(0.2, 1, 1)
-    euler_resolutions = [10000,20000]
-
-    res = []
-    for frequency, amplitude, resolution in itertools.product(euler_c, euler_amplitudes, euler_resolutions):
-        # Do something with frequency and amplitude
-        x = x_vals(resolution)
-        f = euler(x, frequency, amplitude)
-        ans = estimate_stationarity(f)
-
-        res.append(ans / len(x))
-        plt.plot(f)
-        plt.vlines(ans, ymin=min(f), ymax=max(f), colors=["red"])
-        plt.grid()
-        plt.show()
-
-    plt.figure()
-    plt.hist(res)
-    plt.show()
-
-    step_c = [np.pi / 6]
-    step_amplitudes = np.linspace(0.2, 1, 1)
-
-    step_resolutions = [1000, 10000]
-    res = []
-    for frequency, amplitude, resolution in itertools.product(step_c, step_amplitudes, step_resolutions):
-        # Do something with frequency and amplitude
-        x = x_vals(resolution)
-        f = step(x, frequency, amplitude)
-        ans = estimate_stationarity(f)
-
-        res.append(ans / len(x))
-        plt.plot(f)
-        plt.vlines(ans, ymin=min(f), ymax=max(f), colors=["red"])
-        plt.grid()
-        plt.show()
-
-    plt.figure()
-    plt.hist(res)
-    plt.show()
-
-    noise_amplitudes = np.linspace(0.2, 1, 2)
-
-    noise_resolutions = [6000, 20000]
-    res = []
-    for amplitude, resolution in itertools.product(noise_amplitudes, noise_resolutions):
-        # Do something with frequency and amplitude
-        x = x_vals(resolution)
-        f = noise(x, amplitude)
-        ans = estimate_stationarity(f)
-
-        res.append(ans / len(x))
-        plt.plot(f)
-        plt.vlines(ans, ymin=min(f), ymax=max(f), colors=["red"])
-        plt.grid()
-        plt.show()
-
-    plt.figure()
-    plt.hist(res)
-    plt.show()
-
-    df = [1]
-    res = []
-    for g in df:
-        resolution = 10000
-        # Do something with frequency and amplitude
-        x = x_vals(resolution)
-        f = linear(x, g)
-        ans = estimate_stationarity(f)
-        if ans != False:
-            res.append(ans / len(x))
-        else:
-            res.append(1.1)
-        plt.plot(f)
-        plt.vlines(ans, ymin=min(f), ymax=max(f), colors=["red"])
-        plt.grid()
-        plt.show()
-
-    plt.figure()
-    plt.hist(res)
-    plt.show()
-
-    df = [1]
-    res = []
-    for g in df:
-        resolution = 10001
-        # Do something with frequency and amplitude
-        x = x_vals(resolution)/(2*np.pi)
-        f = dirac(x, 0.5,0.5)
-        ans = estimate_stationarity(f)
-        if ans != False:
-            res.append(ans / len(x))
-        else:
-            res.append(1.1)
-        plt.plot(f)
-        plt.vlines(ans, ymin=min(f), ymax=max(f), colors=["red"])
-        plt.grid()
-        plt.show()
-
-    plt.figure()
-    plt.hist(res)
-    plt.show()
-
-
-def x_vals(res):
-    resolution = res
-    start = 0
-    end = 2 * np.pi
-    x = np.linspace(start, end, resolution)
-    return x
-
-
diff --git a/ntrfc/__init__.py b/ntrfc/__init__.py
index 85d0e2f86abce76c097fdb6e2a8ad7bb3a006f85..abd433fcc9449fb1fb83755b277dcff7e09c0522 100644
--- a/ntrfc/__init__.py
+++ b/ntrfc/__init__.py
@@ -2,4 +2,4 @@
 
 __author__ = """Malte Nyhuis"""
 __email__ = 'nyhuis@tfd.uni-hannover.de'
-__version__ = '0.1.2'
+__version__ = '0.1.3'
diff --git a/ntrfc/cascade_case/domain/domain.py b/ntrfc/cascade_case/domain/domain.py
index 23bf6c1405229d6eb6cf26f3c83c8fb3ff4b3ab9..6d03a950bf9e923bdccd733ba911a1d65fb8e92f 100644
--- a/ntrfc/cascade_case/domain/domain.py
+++ b/ntrfc/cascade_case/domain/domain.py
@@ -16,7 +16,7 @@ class CascadeDomain2D:
     inlet: pv.PolyData = None
     outlet: pv.PolyData = None
 
-    def from_cascade_parameters(self, domainparams: DomainParameters):
+    def generate_from_cascade_parameters(self, domainparams: DomainParameters):
         # Use params attributes to generate attributes of CascadeDomain2D
 
         x_mids = domainparams.midspoly.points[::, 0]
diff --git a/ntrfc/cascade_case/solution/case_modules/postprocessing.py b/ntrfc/cascade_case/solution/case_modules/postprocessing.py
index e1eb569413642f9ddcbfd1cb3106a9a484177fb2..83cf62329054d1d38bc3195ad7b752f86752c4fd 100644
--- a/ntrfc/cascade_case/solution/case_modules/postprocessing.py
+++ b/ntrfc/cascade_case/solution/case_modules/postprocessing.py
@@ -8,16 +8,24 @@ from ntrfc.turbo.integrals import avdr
 
 
 class PostProcessing:
-    def compute_avdr(self):
+    def compute_avdr_inout_massave(self):
+
+        self.inlet["u"] = self.inlet["U"][::, 0]
+        self.inlet["v"] = self.inlet["U"][::, 1]
+        self.inlet["w"] = self.inlet["U"][::, 2]
+
+        self.outlet["u"] = self.outlet["U"][::, 0]
+        self.outlet["v"] = self.outlet["U"][::, 1]
+        self.outlet["w"] = self.outlet["U"][::, 2]
         rho_1 = massflowave_plane(self.inlet, "rho")
-        mag_u_1 = massflowave_plane(self.inlet, "U")
+        mag_u_1 = vecAbs(np.array([massflowave_plane(self.inlet, "u"),massflowave_plane(self.inlet, "v"),massflowave_plane(self.inlet, "w")]))
         U_1 = np.stack([massflowave_plane(self.inlet, "u"), massflowave_plane(self.inlet, "v"),
                         massflowave_plane(self.inlet, "w")])
         beta_1 = vecAngle(U_1, np.array([1, 0, 0]))
         rho_2 = massflowave_plane(self.outlet, "rho")
-        U_2 = np.stack([massflowave_plane(self.inlet, "u"), massflowave_plane(self.inlet, "v"),
-                        massflowave_plane(self.inlet, "w")])
-        mag_u_2 = massflowave_plane(self.outlet, "U")
+        U_2 = np.stack([massflowave_plane(self.outlet, "u"), massflowave_plane(self.outlet, "v"),
+                        massflowave_plane(self.outlet, "w")])
+        mag_u_2 =  vecAbs(np.array([massflowave_plane(self.outlet, "u"),massflowave_plane(self.outlet, "v"),massflowave_plane(self.outlet, "w")]))
         beta_2 = vecAngle(U_2, np.array([1, 0, 0]))
         self.avdr = avdr(rho_1, mag_u_1, beta_1, rho_2, mag_u_2, beta_2)
 
@@ -28,7 +36,7 @@ class PostProcessing:
         inlet = self.inlet
         inlet["u"] = inlet["U"][::, 0]
         inlet["v"] = inlet["U"][::, 1]
-        inlet["w"] = inlet["U"][::, 1]
+        inlet["w"] = inlet["U"][::, 2]
         p1 = massflowave_plane(inlet, valname="p", rhoname="rho", velocityname="U")
         rho = massflowave_plane(inlet, valname="rho", rhoname="rho", velocityname="U")
         u = massflowave_plane(inlet, valname="u", rhoname="rho", velocityname="U")
@@ -54,8 +62,8 @@ class PostProcessing:
 
         camber_angle = self.domainparams.stagger_angle
 
-        ssmeshpoints.rotate_z(camber_angle)
-        psmeshpoints.rotate_z(camber_angle)
+        ssmeshpoints.rotate_z(camber_angle, inplace=True)
+        psmeshpoints.rotate_z(camber_angle, inplace=True)
 
         ps_xc = np.zeros(psmeshpoints.number_of_points)
         ps_cp = np.zeros(psmeshpoints.number_of_points)
@@ -80,3 +88,5 @@ class PostProcessing:
         plt.grid()
         plt.legend()
         plt.show()
+
+        return 0
diff --git a/ntrfc/cascade_case/solution/case_modules/sliceseries.py b/ntrfc/cascade_case/solution/case_modules/sliceseries.py
index 3db449e91418cbd955146e63c64ea339d50d0851..7095dfd8f6722f2c29acf79554728689e3727462 100644
--- a/ntrfc/cascade_case/solution/case_modules/sliceseries.py
+++ b/ntrfc/cascade_case/solution/case_modules/sliceseries.py
@@ -26,7 +26,6 @@ class SliceSeries:
         pv.set_plot_theme("document")
         fontsize = 36
         labelsize = 36
-        pv.global_theme.font.label_size = labelsize
 
         gifpath = os.path.join(path, name)
 
@@ -36,7 +35,7 @@ class SliceSeries:
         p.window_size = [3840, 2160]
         p.open_gif(gifpath)
         p.add_mesh(first_slice, scalars=variable)
-        p.add_text(f"framenumber: 0 - time {use_timestamps[0]}", font_size=fontsize)
+        p.add_text(f"framenumber: 0 - time {use_timestamps[0]}", font_size=labelsize, position='upper_left')
         p.camera.position = (0, 0, 1)
         p.camera.roll = 0
         p.camera.zoom = 1
@@ -45,7 +44,7 @@ class SliceSeries:
             sliceframe = load_mesh(path)
             p.clear()
             p.add_mesh(sliceframe, scalars=variable)
-            p.add_text(f"framenumber: {idx} - time {time}", font_size=fontsize)
+            p.add_text(f"framenumber: {idx} - time {time}", font_size=fontsize, position='upper_left')
             p.scalar_bar.SetTitleRatio(2)
             p.write_frame()
 
diff --git a/ntrfc/timeseries/stationarity.py b/ntrfc/timeseries/stationarity.py
index 51a3590ec7258e061c600c762912345ee63a54c3..5ddf29d78abd4f2c987402b3fa3e9b4bc0b6727e 100644
--- a/ntrfc/timeseries/stationarity.py
+++ b/ntrfc/timeseries/stationarity.py
@@ -1,12 +1,96 @@
 import numpy as np
 from matplotlib import pyplot as plt
 from scipy import signal
-from scipy.stats import ks_2samp
-from statsmodels.tsa.stattools import adfuller
+from sklearn.decomposition import PCA
+from statsmodels.tsa.arima.model import ARIMA
 
 from ntrfc.math.methods import minmax_normalize
 
 
+def optimal_bin_width(sample1, sample2):
+    """
+    Compute the optimal bin width using cross-validation estimator for mean integrated squared error.
+
+    Parameters:
+    -----------
+    data : numpy array
+        One-dimensional array of data points.
+
+    Returns:
+    --------
+    h : float
+        Optimal bin width.
+    """
+
+    data = np.concatenate([sample1, sample2])
+    if np.all(data == data[0]):
+        return [data[0] - 0.5, data[0] + 0.5]
+    n = len(data)
+    h = 2 * np.std(data) * n ** (-1 / 3)  # initial bin width using Scott's rule
+
+    # perform cross-validation to estimate mean integrated squared error
+    J_min = np.inf
+    for i in range(12):
+        bins = np.arange(np.min(data), np.max(data) + h, h)
+        counts, _ = np.histogram(data, bins=bins)
+        N_k = counts[np.nonzero(counts)]
+        J = 2 / ((n - 1) * h) - (n + 1) / (n ** 2 * (n - 1) * h) * np.sum(N_k ** 2)
+        if J < J_min:
+            J_min = J
+            h_opt = h
+        h *= 0.8  # decrease bin width for better accuracy
+    bins = np.arange(min(np.min(sample1), np.min(sample2)), max(np.max(sample1), np.max(sample2)), h_opt)
+    return bins
+
+
+def var_compare(sample1, sample2):
+    var1 = np.var(sample1)
+    var2 = np.var(sample2)
+
+    if var1 == var2:
+        return 1.1  # variance is exactly the same, return value greater than 1
+    else:
+        diff = np.abs(var1 - var2)
+        max_var = max(var1, var2)
+        return max(0, 1 - diff / max_var)
+
+
+def pd_compare(sample1, sample2, verbose=False):
+    """Compare the probability distribution of two signals using the Freedman-Diaconis rule
+    to determine the number of bins.
+
+    Args:
+        sample1 (numpy.ndarray): First signal.
+        sample2 (numpy.ndarray): Second signal.
+
+    Returns:
+        float: Mean squared error between the probability distribution densities
+            of the two signals. A value of 0 indicates that the probability distributions
+            are not alike, while a value of 1 indicates that they are equal.
+    """
+    # Compute the number of bins using the Freedman-Diaconis rule.
+    bins = optimal_bin_width(sample1, sample2)
+
+    # Compute the histogram and probability density of the first signal.
+    hist1, _ = np.histogram(sample1, bins=bins, density=True)
+    pdf1 = hist1 / np.sum(hist1)
+
+    # Compute the histogram and probability density of the second signal.
+    hist2, _ = np.histogram(sample2, bins=bins, density=True)
+    pdf2 = hist2 / np.sum(hist2)
+
+    # Compute the mean squared error between the probability densities.
+    mse = np.sum((pdf1 - pdf2) ** 2)
+    # Convert the mse to a similarity score between 0 and 1.
+    similarity = 1 - mse
+    if verbose:
+        # Plot the histogram
+        plt.hist(sample1, bins=bins)
+        plt.hist(sample2, bins=bins)
+        plt.show()
+    return similarity
+
+
 def optimal_window_size(time_series, verbose=False):
     """
     Determines the optimal window size for a given time series.
@@ -35,143 +119,237 @@ def optimal_window_size(time_series, verbose=False):
     # Normalize the time series
     normalized_series = minmax_normalize(time_series)
 
-    # Initialize lists to store correlation coefficient, KS test p-value, and sanity test p-value
-    correlation_coefficients = []
-    ks_p_values = []
-    sanity_p_values = []
-
     # Get the length of the time series and define a range of allowed window sizes
     series_length = len(normalized_series)
-    allowed_window_sizes = np.array(range(series_length // 20, series_length // 4))
+    allowed_window_sizes = np.array(range(series_length // 10, series_length // 4))
 
     # Define a threshold for the sanity test
-    sanity_threshold = 0.95
+    sanity_threshold = 2.83
 
     # Iterate through the allowed window sizes and perform the Kolmogorov-Smirnov test and correlation coefficient calculation
-    for window_size in allowed_window_sizes:
-        check_window = normalized_series[series_length - (window_size * 2):]
-        first_subsequence = check_window[:len(check_window) - window_size]
-        second_subsequence = check_window[len(check_window) - window_size:]
-        ks_statistic, ks_p_value = ks_2samp(second_subsequence, first_subsequence, alternative="less", mode='exact')
-        if not np.array_equal(first_subsequence, first_subsequence):
-            correlation_coefficients.append((1 + np.corrcoef(first_subsequence, second_subsequence)[0][1]) / 2)
-        else:
-            correlation_coefficients.append(1)
-        ks_p_values.append(1 - ks_statistic)
-        sanity_p_values.append(ks_p_value)
-
-    # Calculate a cumulative score for each window size based on the correlation coefficient and KS test p-value
-    corr_coeff_scores = np.nan_to_num(correlation_coefficients, 0)
-    ks_pvalue_scores = np.array(ks_p_values)
-    cumulated_scores = corr_coeff_scores + ks_pvalue_scores
-
-    # Filter out window sizes with low sanity test p-values
-    invalid_indices = np.where(np.array(sanity_p_values) < sanity_threshold)[0]
-    cumulated_scores[invalid_indices] = 0
-
-    max_indices = np.where(2 * sanity_threshold < cumulated_scores)[0]
-    if len(max_indices) == 0:
-        return False
-    max_scores = cumulated_scores[max_indices]
-    max_index = np.argmax(max_scores)
-    optimal_window_size_index = max_indices[max_index]
-    optimal_window_size = allowed_window_sizes[optimal_window_size_index]
+    corr_coeff_scores = np.zeros(len(allowed_window_sizes))
+    pd_similiarity_scores = np.zeros(len(allowed_window_sizes))
+    var_similiarity_scores = np.zeros(len(allowed_window_sizes))
+    for i, window_size in enumerate(allowed_window_sizes):
+        check_window = normalized_series[-window_size * 2:]
+        first_subsequence = check_window[:-window_size]
+        second_subsequence = check_window[-window_size:]
+        pd_similiarity = pd_compare(second_subsequence, first_subsequence)  #
+        corr_coeff = (1 + np.corrcoef(first_subsequence, second_subsequence)[0][1]) / 2
+        var_similiarity = var_compare(first_subsequence, second_subsequence)
+        if np.array_equal(first_subsequence, first_subsequence):
+            corr_coeff = 1
+        corr_coeff_scores[i] = corr_coeff
+        pd_similiarity_scores[i] = pd_similiarity
+        var_similiarity_scores[i] = var_similiarity
+    cumulated_scores = corr_coeff_scores + pd_similiarity_scores + var_similiarity_scores
+    if not any(cumulated_scores >= sanity_threshold):
+        return False, False, False
+
+    optimal_window_size_index = np.argmax(cumulated_scores)
+    opt_window_size = allowed_window_sizes[optimal_window_size_index]
+
+    opt_window = time_series[series_length - opt_window_size * 2:]
+    freqs, psd = signal.periodogram(opt_window, return_onesided=False)
+    maxpsdid = np.argmax(psd)
+    if maxpsdid != 0:
+        tperiod = freqs[np.argmax(psd)] ** -1
+        nperiods = int(opt_window_size / tperiod)
+    else:
+        tperiod = np.inf
+        nperiods = 0
 
     # If verbose mode is enabled, display a plot of the correlation coefficient and KS test results for each window size
     if verbose:
-        plt.plot(np.nan_to_num(correlation_coefficients, 0), label="correlation coefficient")
-        plt.plot(ks_p_values, label="KS test p-value")
+        plt.plot(corr_coeff_scores)
+        plt.plot(pd_similiarity_scores)
         plt.axvline(optimal_window_size_index)
         plt.legend()
         plt.show()
 
-    return optimal_window_size
+    return opt_window, opt_window_size, nperiods
+
+
+def estimate_seasonal_error(series, opt_window_size):
+    snr_winsize = int(np.ceil((opt_window_size) / 16))
+    if snr_winsize >= 4:
+        reconstructed_mean, fluct, snr = snr_pod(series, snr_winsize)
+    else:
+        reconstructed_mean, fluct, snr = snr_pod(series, len(series) // 2)
+
+    # Calculate the rolling window of residuals
+    rolling_residuals = np.lib.stride_tricks.sliding_window_view(reconstructed_mean, opt_window_size)
+
+    # Calculate the dominant frequency of residuals for each window
+    residual_freqs = []
+    for window in rolling_residuals:
+        freqs, psd = signal.periodogram(window, return_onesided=False)
+        dominant_freq = freqs[np.argmax(psd)]
+        residual_freqs.append(dominant_freq)
+
+    # Calculate the standard deviation of mean residuals, residual variance, and dominant frequencies
+    residual_var = np.std(np.var(rolling_residuals, axis=1))
+    residual_mean = np.std(np.mean(rolling_residuals, axis=1))
+    residual_freq = np.std(residual_freqs)
+
+    return residual_mean, residual_var, residual_freq
 
 
 def estimate_stationarity(timeseries, verbose=False):
-    timeseries = minmax_normalize(timeseries)
-    series_length = len(timeseries)
-    reference_window_size = optimal_window_size(timeseries) * 2
-    if not reference_window_size:
+    sigma_threshold = 6
+    normalized_series = minmax_normalize(timeseries)
+    opt_window, opt_window_size, nperiods = optimal_window_size(normalized_series)
+    if not opt_window_size:
         return False
 
-    reference_window = timeseries[series_length - reference_window_size:]
+    reference_window = opt_window
     reference_freqs, reference_psd = signal.periodogram(reference_window, return_onesided=False)
 
     reference_mean = np.mean(reference_window)
-    reference_autocorr_frequency = reference_freqs[np.argmax(reference_psd)]
+    reference_autocorr_freq = reference_freqs[np.argmax(reference_psd)]
     reference_variance = np.var(reference_window)
 
-    reference_autocorr_timescale = (
-        1 / reference_autocorr_frequency) if reference_autocorr_frequency != 0 else reference_window_size // 2
-    reference_nperiods = np.ceil(reference_window_size / reference_autocorr_timescale)
-    block_size = int(reference_window_size / (reference_nperiods))
-    mean_error, variance_error, autocorr_error = estimate_error(reference_window, block_size=block_size)
+    residual_mean, residual_variance, residual_autocorr = estimate_residual_error(reference_window, opt_window_size)
+    seasonal_mean, seasonal_variance, seasonal_autocorr = estimate_seasonal_error(reference_window,
+                                                                                  opt_window_size // nperiods)
 
-    rolling_window = np.lib.stride_tricks.sliding_window_view(timeseries, reference_window_size)
+    mean_jk_error, var_jk_error, accr_jk_error = estimate_error_jacknife(reference_window,
+                                                                         block_size=opt_window_size // nperiods)
+    modelerror_mean, modelerror_freq, modelerror_var = estimate_model_error(reference_window, opt_window_size, nperiods)
+
+    autocorr_limit = (seasonal_autocorr + residual_autocorr + accr_jk_error + modelerror_freq) * sigma_threshold
+    mean_limit = (seasonal_mean + residual_mean + mean_jk_error + modelerror_mean) * sigma_threshold
+    variance_limit = (seasonal_variance + residual_variance + var_jk_error + modelerror_var) * sigma_threshold
+
+    rolling_window = np.lib.stride_tricks.sliding_window_view(normalized_series, opt_window_size)
+
+    def cum_score(valid):
+        scores = np.cumsum(valid[::-1])[::-1] / np.arange(1, len(valid) + 1)[::-1]
+        index = np.where(scores >= 1)[0][0]
+        return scores, index
 
     window_means = np.mean(rolling_window, axis=1)
-    mean_valid = np.isclose(abs(window_means - reference_mean), 0, atol=mean_error)
-    mean_scores = np.cumsum(mean_valid[::-1])[::-1] / np.arange(1, len(mean_valid) + 1)[::-1]
-    max_confi = 1
+    mean_valid = np.isclose(abs(window_means - reference_mean), 0, atol=mean_limit)
+    if not any(mean_valid):
+        return False
+    mean_scores, mean_index = cum_score(mean_valid)
 
     window_corrs = []
-    for ts in rolling_window:
-        freqs, psd = signal.periodogram(ts, return_onesided=False)
+    for window in rolling_window:
+        freqs, psd = signal.periodogram(window, return_onesided=False)
         window_corrs.append(freqs[np.argmax(psd)])
-    autocorr_timescale_valid = np.isclose(abs(window_corrs - reference_autocorr_frequency), 0,
-                                          atol=autocorr_error)
-
-    autocorr_timescale_scores = np.cumsum(autocorr_timescale_valid[::-1])[::-1] / np.arange(1,
-                                                                                            len(autocorr_timescale_valid) + 1)[
-                                                                                  ::-1]
-
-    autocorr_timescale_index = np.where(autocorr_timescale_scores >= max_confi)[0][0]
+    autocorr_timescale_valid = np.isclose(abs(window_corrs - reference_autocorr_freq), 0, atol=autocorr_limit)
+    if not any(autocorr_timescale_valid):
+        return False
+    autocorr_timescale_scores, autocorr_timescale_index = cum_score(autocorr_timescale_valid)
 
     window_variances = np.var(rolling_window, axis=1)
-    variance_valid = np.isclose(abs(window_variances - reference_variance), 0, atol=variance_error)
-    variance_scores = np.cumsum(variance_valid[::-1])[::-1] / np.arange(1, len(variance_valid) + 1)[::-1]
-
-    variance_index = np.where(variance_scores >= max_confi)[0][0]
-
-    mean_index = np.where(mean_scores >= max_confi)[0][0]
-
-    stationary_start = max(mean_index, autocorr_timescale_index, variance_index)
+    variance_valid = np.isclose(abs(window_variances - reference_variance), 0, atol=variance_limit)
+    if not any(variance_valid):
+        return False
+    variance_scores, variance_index = cum_score(variance_valid)
 
+    stationary_start_index = max(mean_index, autocorr_timescale_index, variance_index)
     if verbose:
         plt.plot(abs(window_variances - reference_variance), label="var error", color="red")
-        plt.hlines(y=(variance_error), xmin=0, xmax=len(window_variances), label="var_err+")
+        plt.hlines(y=(variance_limit), xmin=0, xmax=len(window_variances), label="var_err+")
         plt.legend()
         plt.show()
 
-        plt.plot(abs(window_corrs - reference_autocorr_frequency), label="accr error", color="red")
-        plt.hlines(y=(autocorr_error), xmin=0, xmax=len(window_corrs), label="accr_err+")
+        plt.plot(abs(window_corrs - reference_autocorr_freq), label="accr error", color="red")
+        plt.hlines(y=(autocorr_limit), xmin=0, xmax=len(window_corrs), label="accr_err+")
         plt.legend()
         plt.show()
 
         plt.plot(abs(window_means - reference_mean), label="mean error", color="red")
-        plt.hlines(y=(mean_error), xmin=0, xmax=len(window_means), label="mean_err+")
+        plt.hlines(y=(mean_limit), xmin=0, xmax=len(window_means), label="mean_err+")
         plt.legend()
         plt.show()
 
-    # Define your time series as an array
-    time_series = timeseries[stationary_start:]
-    if all(time_series == time_series[0]):
-        return stationary_start
-    else:
+    return stationary_start_index
+
+
+def estimate_residual_error(reference, opt_window_size):
+    """
+    Estimates the residual errors for a given time series using an ARIMA model and a rolling window approach.
+
+    In the context of time series analysis, the residual error (or simply "residuals") represents the difference
+    between the actual values of the time series and the predicted values from a model. In other words, it is the
+    part of the time series that the model is unable to explain.
+
+    Args:
+        reference (array-like): A time series to estimate residual errors for.
+        opt_window_size (int): The size of the rolling window to use for calculating metrics.
+
+    Returns:
+        Tuple: A tuple containing the following metrics of the residual errors:
+            - residual_mean (float): The standard deviation of the mean residuals over the rolling windows.
+            - residual_var (float): The standard deviation of the residual variance over the rolling windows.
+            - residual_freq (float): The standard deviation of the dominant frequencies of the residuals over the rolling windows.
+    """
+    # Fit an ARIMA model to the reference data
+    arima_model = ARIMA(reference, order=(1, 1, 1))
+    arima_results = arima_model.fit()
+
+    # Calculate the residuals
+    residuals = reference - arima_results.fittedvalues
 
-        # Perform the Dickey-Fuller test
-        result = adfuller(time_series)
+    # Calculate the rolling window of residuals
+    rolling_residuals = np.lib.stride_tricks.sliding_window_view(residuals, opt_window_size)
 
-        # Interpret the test results
-        critical_value = result[4]['1%']
-        if result[0] < critical_value:
-            return stationary_start
-        else:
-            return False
+    # Calculate the dominant frequency of residuals for each window
+    residual_freqs = []
+    for window in rolling_residuals:
+        freqs, psd = signal.periodogram(window, return_onesided=False)
+        dominant_freq = freqs[np.argmax(psd)]
+        residual_freqs.append(dominant_freq)
 
+    # Calculate the standard deviation of mean residuals, residual variance, and dominant frequencies
+    residual_var = np.std(np.var(rolling_residuals, axis=1))
+    residual_mean = np.std(np.mean(rolling_residuals, axis=1))
+    residual_freq = np.std(residual_freqs)
 
-def estimate_error(timeseries, block_size=20, n_samples=4000):
+    return residual_mean, residual_var, residual_freq
+
+
+def estimate_model_error(reference_window, opt_window_size, nper):
+    ref_length = len(reference_window)
+    ref_mean = np.mean(reference_window)
+    ref_var = np.var(reference_window)
+
+    # Calculate the dominant frequency of residuals for each window
+    freqs, psd = signal.periodogram(reference_window, return_onesided=False)
+    ref_freq = freqs[np.argmax(psd)]
+
+    x = np.linspace(0, 2 * np.pi * nper, ref_length)
+
+    y = np.sin(x) + 1
+
+    rolling_residuals = np.lib.stride_tricks.sliding_window_view(y, opt_window_size)
+    # Calculate the dominant frequency of residuals for each window
+    residual_ts = []
+    for window in rolling_residuals:
+        freqs, psd = signal.periodogram(window, return_onesided=False)
+        dominant_freq = freqs[np.argmax(psd)]
+        residual_ts.append(dominant_freq)
+
+    y_mean = 1
+    y_var = 0.5
+    y_t = nper / ref_length
+
+    # Calculate the standard deviation of mean residuals, residual variance, and dominant frequencies
+    residual_var = np.var(rolling_residuals, axis=1)
+    residual_mean = np.mean(rolling_residuals, axis=1)
+    residual_freq = residual_ts
+
+    residual_length = len(residual_mean)
+    mean_error = np.mean(np.abs(residual_mean - np.array([y_mean] * residual_length))) / y_mean * ref_mean
+    var_error = np.mean(np.abs(residual_var - np.array([y_var] * residual_length))) / y_var * ref_var
+    freq_error = np.mean(np.abs(residual_freq - np.array([y_t] * residual_length))) / y_t * ref_freq
+    return mean_error, freq_error, var_error
+
+
+def estimate_error_jacknife(timeseries, block_size=20, n_samples=4000):
     """
     Estimates the errors of the mean, variance, and autocorrelation of a given time series using jackknife resampling method.
 
@@ -215,10 +393,6 @@ def estimate_error(timeseries, block_size=20, n_samples=4000):
     var_jk = np.zeros(n_samples)
     acorr_jk = np.zeros(n_samples)
 
-    mean_noise = np.zeros(n_samples)
-    var_noise = np.zeros(n_samples)
-    accr_noise = np.zeros(n_samples)
-
     for i in range(n_samples):
         # Generate a random index array of block indices
         idx = np.random.randint(0, n_blocks, size=n_blocks)
@@ -234,20 +408,31 @@ def estimate_error(timeseries, block_size=20, n_samples=4000):
         freqs, psd = signal.periodogram(x_jk, return_onesided=False)
         acorr_jk[i] = freqs[np.argmax(psd)]
 
-        x_noise = np.random.randn(block_size)
-        mean_noise[i] = np.mean(x_noise)
-        var_noise[i] = np.var(x_noise)
-
-        freqs, psd = signal.periodogram(x_noise, return_onesided=False)
-        accr_noise[i] = freqs[np.argmax(psd)]
-
-    sigma = 12
     mean_jk_error = np.std(mean_jk)
     var_jk_error = np.std(var_jk)
     accr_jk_error = np.std(acorr_jk)
 
-    mean_error = mean_jk_error * sigma
-    var_error = var_jk_error * sigma
-    accr_error = accr_jk_error * sigma
-
-    return mean_error, var_error, accr_error
+    return mean_jk_error, var_jk_error, accr_jk_error
+
+
+def snr_pod(x, window_size, verbose=False):
+    ncomp = 16
+    if ncomp > window_size:
+        # fails otherwise
+        ncomp = window_size
+    X = np.zeros((x.shape[0] - window_size, window_size))
+    for i in range(X.shape[0]):
+        X[i] = x[i:i + window_size]
+    # Apply PCA to the windowed data
+    pca = PCA(n_components=ncomp)
+    pca.fit(X)
+    # Reconstruct the data using the principal components
+    reconstructed = pca.inverse_transform(pca.transform(X))
+    reconstructed_mean = reconstructed.mean(axis=1)
+    fluct = x[window_size // 2:-window_size // 2] - reconstructed_mean
+    snr = np.trapz(reconstructed_mean ** 2) / np.trapz(fluct ** 2)
+    if verbose:
+        plt.plot(fluct)
+        plt.plot(reconstructed_mean)
+        plt.show()
+    return reconstructed_mean, fluct, snr
diff --git a/ntrfc/turbo/pointcloud_methods.py b/ntrfc/turbo/pointcloud_methods.py
index b3a6d64d037d23f9fce648c7d17c396d6f8c47e9..6569e4f25ad4ae70730641273a4f7c9ad4a21ec1 100644
--- a/ntrfc/turbo/pointcloud_methods.py
+++ b/ntrfc/turbo/pointcloud_methods.py
@@ -78,7 +78,39 @@ def extractSidePolys(ind_1, ind_2, sortedPoly, verbose=False):
 
 
 def extract_points_fromsortedpoly(sorted_indices, sorted_poly):
-    side_two = pv.PolyData(sorted_poly.points[sorted_indices])  # polyblade.extract_cells(index_sort)
+    """
+    Extract a subset of points and associated data from a sorted polygon.
+
+    Parameters
+    ----------
+    sorted_indices : numpy.ndarray
+        1D array of shape `(n_points,)` containing the indices of the points
+        in `sorted_poly.points` that should be extracted and used to create a
+        new polygon. The indices should be sorted in the order that they
+        should appear in the new polygon.
+    sorted_poly : pyvista.PolyData
+        Polygon represented as a `PolyData` object from the `pyvista`
+        library. The `sorted_poly.points` attribute should be a NumPy array
+        of shape `(n_points, 3)` containing the 3D coordinates of the polygon
+        vertices, and the `sorted_poly.point_data` attribute should be a
+        dictionary of NumPy arrays containing additional per-vertex data.
+
+    Returns
+    -------
+    pyvista.PolyData
+        A new `PolyData` object representing the subset of the original polygon
+        specified by `sorted_indices`, with all per-vertex data preserved.
+
+    Notes
+    -----
+    This function assumes that the input polygon is sorted in a specific way.
+    Specifically, the `sorted_indices` parameter should contain the indices of
+    the points in the order that they should appear in the new polygon. If the
+    input polygon is not sorted in this way, the resulting polygon may not be
+    valid.
+    """
+
+    side_two = pv.PolyData(sorted_poly.points[sorted_indices])
     for arr in sorted_poly.array_names:
         side_two[arr] = sorted_poly.point_data[arr][sorted_indices]
     return side_two
@@ -141,15 +173,33 @@ def extract_geo_paras(polyblade, alpha=None, verbose=False):
 
 def calcMidPassageStreamLine(x_mcl, y_mcl, beta1, beta2, x_inlet, x_outlet, t, verbose=False):
     """
-
-    Returns two lists of Points representing a curve through the passage
-
-
-    Input:
-    x_mcl, y_mcl = Tuple
-    beta1, beta2 = Angle in deg - Beta = Anströmwinkel
-    x_inlet, x_outlet = scalar - representing position x-component of in/outlet
-    t = scalar pitch
+    Calculate the midpoint stream line curve through a passage.
+
+    Parameters:
+    -----------
+    x_mcl : array_like
+        The x-coordinates of the mid-chord line.
+    y_mcl : array_like
+        The y-coordinates of the mid-chord line.
+    beta1 : float
+        The angle in degrees representing the inflow angle at the inlet.
+    beta2 : float
+        The angle in degrees representing the outflow angle at the outlet.
+    x_inlet : float
+        The x-coordinate of the inlet position.
+    x_outlet : float
+        The x-coordinate of the outlet position.
+    t : float
+        The pitch of the midpoint stream line.
+    verbose : bool, optional
+        If True, a plot of the midpoint stream line is displayed.
+
+    Returns:
+    --------
+    x_mpsl_ref : array_like
+        The refined x-coordinates of the midpoint stream line.
+    y_mpsl_ref : array_like
+        The refined y-coordinates of the midpoint stream line.
     """
 
     delta_x_vk = x_mcl[0] - x_inlet
diff --git a/ntrfc/turbo/probegeneration.py b/ntrfc/turbo/probegeneration.py
index 0558927ff6429fe93308cf7f811feaddc6e0d009..00b6fbcfe6dc416a7dbcdb5c1595c53992392b11 100644
--- a/ntrfc/turbo/probegeneration.py
+++ b/ntrfc/turbo/probegeneration.py
@@ -100,7 +100,7 @@ def create_stagnationpointprobes(length, nop, sortedpoly, ind_vk, u_inlet, midsp
     angle = vecAngle(u_inlet, np.array([1, 0, 0]) * 180 / np.pi)
     stagnationLine = pv.Line((0, 0, 0), (-length, 0, 0), nop - 1)
     stagnationLine.rotate_z(angle, inplace=False)
-    stagnationLine.translate(vk_point)
+    stagnationLine.translate(vk_point, inplace=False)
     x_probes = stagnationLine.points[::, 0]
     y_probes = stagnationLine.points[::, 1]
     z_probes = stagnationLine.points[::, 2] + midspan_z
diff --git a/requirements.txt b/requirements.txt
index ccfe42e1f7adf4f76a091f83b1a81eac3d91c4a6..381e47580cffea90c6e6c8c763035ad43fee8c4c 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -1,12 +1,13 @@
-matplotlib==3.6.1
-pip>=22
-pytest==7.2.0
-pyvista==0.36.1
-PyYAML==6.0
-scipy
-pandas==1.5.1
-setuptools==61.2.0
+pip>=23
+matplotlib>=3.7.1
+pytest>=7.2.2
+pyvista>=0.38.3
+PyYAML>=6.0
+scipy==1.7.3
+pandas>=1.5.1
+setuptools>=61.2.0
 fluidfoam==0.2.3
-tqdm==4.64.1
-statsmodels==0.13.5
+tqdm>=4.64.1
+statsmodels>=0.13.5
+scikit-learn
 jupyter
diff --git a/setup.cfg b/setup.cfg
index ad83fbfd52c8744057533cac398ecd801d8bb9ee..1f876cca77cd108d45bb79fc69984a287fb02e20 100644
--- a/setup.cfg
+++ b/setup.cfg
@@ -1,5 +1,5 @@
 [bumpversion]
-current_version = 0.1.2
+current_version = 0.1.3
 commit = True
 tag = True
 
diff --git a/setup.py b/setup.py
index 712e099d79052ae1103d22e0e9592fcd1afa8dcc..25ca34ee0f504361285915b0164ef722832d4dc8 100644
--- a/setup.py
+++ b/setup.py
@@ -5,7 +5,7 @@
 from pip._internal.req import parse_requirements
 from setuptools import setup, find_packages
 
-with open('README.md') as readme_file:
+with open('README.rst') as readme_file:
     readme = readme_file.read()
 
 with open('HISTORY.rst') as history_file:
@@ -22,7 +22,7 @@ setup(
     author_email='nyhuis@tfd.uni-hannover.de',
     python_requires='>=3.10',
     classifiers=[
-        'Development Status :: 0.1.2',
+        'Development Status :: 0.1.3',
         'Intended Audience :: Developers',
         'License :: OSI Approved :: MIT License',
         'Natural Language :: English',
@@ -43,6 +43,6 @@ setup(
     test_suite='tests',
     tests_require=test_requirements,
     url='https://gitlab.uni-hannover.de/tfd_public/tools/NTRfC',
-    version='0.1.2',
+    version='0.1.3',
     zip_safe=False,
 )
diff --git a/tests/cascadecase/domain/test_ntrfc_domaingen_cascade.py b/tests/cascadecase/domain/test_ntrfc_domaingen_cascade.py
index 0bb19da840024a03a46bec5f8725302988651e45..e62c62c413dd0bec63f8a01cc51f3fda7484d6c0 100644
--- a/tests/cascadecase/domain/test_ntrfc_domaingen_cascade.py
+++ b/tests/cascadecase/domain/test_ntrfc_domaingen_cascade.py
@@ -14,4 +14,4 @@ def test_cascade_2d_domain():
     domainparas.pitch = 2
     domainparas.blade_yshift = 0.1
     domain2d = CascadeDomain2D()
-    domain2d.from_cascade_parameters(domainparas)
+    domain2d.generate_from_cascade_parameters(domainparas)
diff --git a/tests/cascadecase/solution/test_ansys.py b/tests/cascadecase/solution/test_ansys.py
index 34bfdb9d2cbb87d7b35a60e880dd7400458d8fb8..766ce254774e6e6c2f9f85d281609fb5bc4214d9 100644
--- a/tests/cascadecase/solution/test_ansys.py
+++ b/tests/cascadecase/solution/test_ansys.py
@@ -4,23 +4,25 @@ def test_solution(tmpdir):
     import pyvista as pv
 
     fake_inlet = pv.Plane()
-    fake_inlet["U"] = np.array([1] * fake_inlet.number_of_cells)
+
     fake_inlet["u"] = np.array([1] * fake_inlet.number_of_cells)
     fake_inlet["v"] = np.array([0] * fake_inlet.number_of_cells)
     fake_inlet["w"] = np.array([0] * fake_inlet.number_of_cells)
     fake_inlet["rho"] = np.array([1] * fake_inlet.number_of_cells)
+    fake_inlet["U"] = np.stack([fake_inlet["u"],fake_inlet["v"],fake_inlet["w"]]).T
 
     fake_outlet = pv.Plane()
-    fake_outlet["U"] = np.array([1] * fake_outlet.number_of_cells)
+
     fake_outlet["u"] = np.array([1] * fake_outlet.number_of_cells)
     fake_outlet["v"] = np.array([0] * fake_outlet.number_of_cells)
     fake_outlet["w"] = np.array([0] * fake_outlet.number_of_cells)
     fake_outlet["rho"] = np.array([1] * fake_outlet.number_of_cells)
+    fake_outlet["U"] = np.stack([fake_outlet["u"], fake_outlet["v"], fake_outlet["w"]]).T
 
     case = GenericCascadeCase()
     case.inlet = fake_inlet
     case.outlet = fake_outlet
-    case.compute_avdr()
+    case.compute_avdr_inout_massave()
     assert case.avdr == 1, "should be avdr==1"
 
 
diff --git a/tests/cascadecase/solution/test_openfoam.py b/tests/cascadecase/solution/test_openfoam.py
index 7572eb09128ef6b1818f0df2c9d396fa3e5f58b9..dec1ffef36a164546b073d05f4547bcec02b96f0 100644
--- a/tests/cascadecase/solution/test_openfoam.py
+++ b/tests/cascadecase/solution/test_openfoam.py
@@ -4,23 +4,23 @@ def test_solution():
     import pyvista as pv
 
     fake_inlet = pv.Plane()
-    fake_inlet["U"] = np.array([1] * fake_inlet.number_of_cells)
     fake_inlet["u"] = np.array([1] * fake_inlet.number_of_cells)
     fake_inlet["v"] = np.array([0] * fake_inlet.number_of_cells)
     fake_inlet["w"] = np.array([0] * fake_inlet.number_of_cells)
     fake_inlet["rho"] = np.array([1] * fake_inlet.number_of_cells)
+    fake_inlet["U"] = np.stack([fake_inlet["u"],fake_inlet["v"],fake_inlet["w"]]).T
 
     fake_outlet = pv.Plane()
-    fake_outlet["U"] = np.array([1] * fake_outlet.number_of_cells)
+
     fake_outlet["u"] = np.array([1] * fake_outlet.number_of_cells)
     fake_outlet["v"] = np.array([0] * fake_outlet.number_of_cells)
     fake_outlet["w"] = np.array([0] * fake_outlet.number_of_cells)
     fake_outlet["rho"] = np.array([1] * fake_outlet.number_of_cells)
-
+    fake_outlet["U"] = np.stack([fake_outlet["u"], fake_outlet["v"], fake_outlet["w"]]).T
     case = openfoam_case()
     case.inlet = fake_inlet
     case.outlet = fake_outlet
-    case.compute_avdr()
+    case.compute_avdr_inout_massave()
     assert case.avdr == 1, "should be avdr==1"
 
 
diff --git a/tests/cascadecase/solution/test_solution.py b/tests/cascadecase/solution/test_solution.py
index 6c7110cbd4e5add4426ddbd93019809b55cc789c..043c2141c1944db3fc9a03eaba83521ddfd82366 100644
--- a/tests/cascadecase/solution/test_solution.py
+++ b/tests/cascadecase/solution/test_solution.py
@@ -3,6 +3,8 @@ import os
 import numpy as np
 import pyvista as pv
 
+from ntrfc.cascade_case.solution.case_modules.postprocessing import PostProcessing
+
 ON_CI = 'CI' in os.environ
 
 
@@ -11,31 +13,34 @@ def test_solution(tmpdir):
 
     inletname = tmpdir / "fake_inlet.vtk"
     outletname = tmpdir / "fake_outlet.vtk"
+
     fake_inlet = pv.Plane(direction=(1, 0, 0))
-    fake_inlet["U"] = np.array([1] * fake_inlet.number_of_cells)
+
     fake_inlet["u"] = np.array([1] * fake_inlet.number_of_cells)
     fake_inlet["v"] = np.array([0] * fake_inlet.number_of_cells)
     fake_inlet["w"] = np.array([0] * fake_inlet.number_of_cells)
     fake_inlet["rho"] = np.array([1] * fake_inlet.number_of_cells)
+    fake_inlet["U"] = np.stack([fake_inlet["u"],fake_inlet["v"],fake_inlet["w"]]).T
     fake_inlet.save(inletname)
     fake_outlet = pv.Plane(direction=(-1, 0, 0))
-    fake_outlet["U"] = np.array([1] * fake_outlet.number_of_cells)
+
     fake_outlet["u"] = np.array([1] * fake_outlet.number_of_cells)
     fake_outlet["v"] = np.array([0] * fake_outlet.number_of_cells)
     fake_outlet["w"] = np.array([0] * fake_outlet.number_of_cells)
     fake_outlet["rho"] = np.array([1] * fake_outlet.number_of_cells)
+    fake_outlet["U"] = np.stack([fake_outlet["u"], fake_outlet["v"], fake_outlet["w"]]).T
+
     fake_outlet.save(outletname)
     case = GenericCascadeCase()
     case.read_inlet(inletname)
     case.read_outlet(outletname)
-    case.compute_avdr()
+    case.compute_avdr_inout_massave()
     assert case.avdr == 1, "should be avdr==1"
 
 
 def test_animations(tmpdir):
     from ntrfc.cascade_case.solution.generic import GenericCascadeCase
     import pyvista as pv
-    import os
 
     if ON_CI:
         pv.start_xvfb()
@@ -56,3 +61,45 @@ def test_animations(tmpdir):
     test_solution = GenericCascadeCase()
     test_solution.sliceseries.add_sliceset(slices, "some", ts)
     test_solution.sliceseries.create_animation("some", "U", tmpdir, "U.gif")
+
+
+def test_postprocessing():
+    import pyvista as pv
+    from ntrfc.cascade_case.domain.geoparas import DomainParameters
+    from ntrfc.turbo.airfoil_generators.naca_airfoil_creator import naca
+
+    xs, ys = naca("6510", 256)
+    points = pv.PolyData(np.stack([xs, ys, np.zeros(len(xs))]).T)
+    domainparas = DomainParameters()
+    domainparas.generate_params_by_pointcloud(points)
+    domainparas.profile_points["p"] = [1] * domainparas.profile_points.number_of_points
+
+    inlet = pv.Plane()
+    inlet["u"] = np.ones((inlet.number_of_cells))
+    inlet["v"] = np.zeros((inlet.number_of_cells))
+    inlet["w"] = np.zeros((inlet.number_of_cells))
+    inlet["U"] = np.stack([inlet["u"], inlet["v"], inlet["w"]]).T
+    inlet["rho"] = np.array([1] * inlet.number_of_cells)
+    inlet["p"] = np.array([1] * inlet.number_of_cells)
+    inlet.ctp()
+    outlet = pv.Plane()
+    outlet["u"] = np.ones((outlet.number_of_cells))
+    outlet["v"] = np.zeros((outlet.number_of_cells))
+    outlet["w"] = np.zeros((outlet.number_of_cells))
+    outlet["U"] = np.stack([inlet["u"], inlet["v"], inlet["w"]]).T
+    outlet["rho"] = np.array([1] * outlet.number_of_cells)
+    outlet["p"] = np.array([1] * outlet.number_of_cells)
+    outlet.ctp()
+
+    # Initialize PostProcessing object
+    postprocessing = PostProcessing()
+    postprocessing.inlet = inlet
+    postprocessing.outlet = outlet
+    postprocessing.domainparams = domainparas
+
+    # Test compute_avdr method
+    postprocessing.compute_avdr_inout_massave()
+    assert postprocessing.avdr == 1
+
+    # Test blade_loading method
+    assert postprocessing.blade_loading() == 0
diff --git a/tests/geometry/test_ntrfc_alphashape.py b/tests/geometry/test_ntrfc_alphashape.py
index 8fb7ff2adea72243419f4e251b0ef2a3210a95af..3fe73cb79d8daf7ff53f4b2ee11f1e1becf50511 100644
--- a/tests/geometry/test_ntrfc_alphashape.py
+++ b/tests/geometry/test_ntrfc_alphashape.py
@@ -9,7 +9,7 @@ def test_calc_concavehull():
     square = pv.Plane()
     boxedges = square.extract_feature_edges()
 
-    boxedges.rotate_z(np.random.randint(0, 360))
+    boxedges.rotate_z(np.random.randint(0, 360), inplace=True)
     boxpoints = boxedges.points
 
     np.random.shuffle(boxpoints)
@@ -23,7 +23,7 @@ def test_calc_concavehull():
     assert any([yi in ys_raw for yi in ys])
 
     polygon = pv.Polygon()
-    polygon.rotate_z(np.random.randint(0, 360))
+    polygon.rotate_z(np.random.randint(0, 360), inplace=True)
     polyedges = polygon.extract_feature_edges()
     polypoints = polyedges.points
     np.random.shuffle(polypoints)
@@ -48,7 +48,7 @@ def test_calc_optimize_alphashape():
     square = pv.Plane()
     boxedges = square.extract_feature_edges()
 
-    boxedges.rotate_z(np.random.randint(0, 360))
+    boxedges.rotate_z(np.random.randint(0, 360), inplace=True)
     boxpoints = boxedges.points
 
     np.random.shuffle(boxpoints)
diff --git a/tests/geometry/test_ntrfc_geometry.py b/tests/geometry/test_ntrfc_geometry.py
index 862a7357fbb6d0a455f90f25e28540d7bcee999d..97ee0e91197a70e6ff37f3e367673ae3ebe6df7f 100644
--- a/tests/geometry/test_ntrfc_geometry.py
+++ b/tests/geometry/test_ntrfc_geometry.py
@@ -20,7 +20,7 @@ def test_extract_vk_hk(verbose=False):
     res = 420
     xs, ys = naca(naca_code, res, half_cosine_spacing=False)
     sorted_poly = pv.PolyData(np.stack([xs[:-1], ys[:-1], np.zeros(len(xs) - 1)]).T)
-    sorted_poly.rotate_z(angle)
+    sorted_poly.rotate_z(angle, inplace=True)
     X, Y = sorted_poly.points[::, 0], sorted_poly.points[::, 1]
     ind_1 = res
     ind_2 = 0
@@ -110,7 +110,7 @@ def test_extract_geo_paras(verbose=False):
     res = 240
     xs, ys = naca(naca_code, res, half_cosine_spacing=False)
     sorted_poly = pv.PolyData(np.stack([xs, ys, np.zeros(len(xs))]).T)
-    sorted_poly.rotate_z(angle)
+    sorted_poly.rotate_z(angle, inplace=True)
 
     poly, ps_poly, ss_poly, ind_hk, ind_vk, mids_poly, beta_leading, beta_trailing, camber_angle, alpha = extract_geo_paras(
         sorted_poly, alpha)
diff --git a/tests/math/test_ntrfc_methods.py b/tests/math/test_ntrfc_methods.py
index 13a31edd704d4fa4e283cb0f4568c62fc002f4e6..c91b416405da39b5f48c92215650ed29e11c1394 100644
--- a/tests/math/test_ntrfc_methods.py
+++ b/tests/math/test_ntrfc_methods.py
@@ -3,7 +3,7 @@ import pyvista as pv
 
 from ntrfc.math.methods import calcAnisoMatrix, calcAnisoEigs, C_barycentric, autocorr, zero_crossings, reldiff, \
     return_intersection, is_equidistant, autocorrelate, minmax_normalize
-from ntrfc.timeseries.stationarity import estimate_error
+from ntrfc.timeseries.stationarity import estimate_error_jacknife
 
 
 def test_ellipsoidVol():
@@ -214,14 +214,14 @@ def test_estimate_error():
     # Generate correlated time series using sine function
     res = 10000
     timeseries = np.sin(np.linspace(0, 8 * np.pi, res)) + np.random.normal(size=res) * 0.1
-    mean_error, var_error, acorr_error = estimate_error(timeseries, block_size=res // 4)
+    mean_error, var_error, acorr_error = estimate_error_jacknife(timeseries, block_size=res // 4)
     assert mean_error <= 0.1
     assert var_error <= 0.1
     assert acorr_error <= 0.1
 
     # Generate a simple Gaussian, non self-correlated distributed timeseries with a mean of 0
     timeseries = np.random.randn(res * 6)
-    mean_error, var_error, acorr_error = estimate_error(timeseries, block_size=res // 2)
+    mean_error, var_error, acorr_error = estimate_error_jacknife(timeseries, block_size=res // 2)
     assert mean_error <= 0.2
     assert var_error <= 0.2
     assert acorr_error <= 4
diff --git a/tests/timeseries/test_ntrfc_stationarity.py b/tests/timeseries/test_ntrfc_stationarity.py
index 095ffd4475671b57a53c8c1a3c31db5d26bc5003..937f24295811b8c185481f23f7a069b9f3846485 100644
--- a/tests/timeseries/test_ntrfc_stationarity.py
+++ b/tests/timeseries/test_ntrfc_stationarity.py
@@ -12,19 +12,24 @@ def test_optimal_timewindow(verbose=False):
     nper = 4
     x = np.linspace(0, 2 * np.pi * nper, res)
 
-    # noise
+    # sin
+    # we have four periods, at least one period should be captured
+    # thats res // 4 as a return
     ysin = np.sin(x)
-    ans = optimal_window_size(ysin)
-    assert ans == res // nper / 4 + 1
+    opt_window, opt_window_size, nperiods = optimal_window_size(ysin)
+    assert opt_window_size == res // (nper * nperiods) - 1
+    assert nperiods == 1
     # tanh
-    eul = np.tanh(x)
-    ans = optimal_window_size(eul)
-    assert ans == res // 20
+    eul = np.tanh(x * 2)
+    opt_window, opt_window_size, nperiods = optimal_window_size(eul)
+    assert opt_window_size == res // 10
+    assert nperiods == 0
     # euler
 
-    eul = np.e ** (-x * 4)
-    ans = optimal_window_size(eul)
-    assert ans == res // 20
+    eul = np.e ** (-x * 60)
+    opt_window, opt_window_size, nperiods = optimal_window_size(eul)
+    assert opt_window_size == res // 10
+    assert nperiods == 0
 
 
 def test_stationarity_uncertainties_stationarysine(verbose=False):
@@ -79,17 +84,17 @@ def test_stationarity_uncertainties_abatingsine(verbose=False):
     import matplotlib.pyplot as plt
 
     def signalgen_abatingsine(amplitude, frequency, mean, abate, time):
-        resolution = 2048
-        step = (resolution * frequency ** -1) ** -1
+        resolution = 48
+        step = (1 / frequency) / resolution
         times = np.arange(0, time, step)
         values = amplitude * np.sin(frequency * (2 * np.pi) * times) + mean + np.e ** -(times * abate)
         return times, values
 
-    test_amplitudes = [0.2]
-    test_frequencies = [10]
+    test_amplitudes = [0.3]
+    test_frequencies = [6]
     test_times = [20]
     test_mean = [-1]
-    test_abate = [1, 5]
+    test_abate = [2, 5]
 
     test_configs = list(product(test_amplitudes, test_frequencies, test_times, test_mean, test_abate))
 
@@ -99,7 +104,7 @@ def test_stationarity_uncertainties_abatingsine(verbose=False):
                                                   abate=abate)
         stationary_timestep = estimate_stationarity(values)
 
-        well_computed_stationarity_limit = -np.log(0.01) / abate
+        well_computed_stationarity_limit = -np.log(0.02) / abate
         well_computed_stationary_time = timesteps[-1] - well_computed_stationarity_limit
         stationary_time = timesteps[-1] - timesteps[stationary_timestep]
         if verbose:
@@ -119,8 +124,9 @@ def test_stationarity_uncertainties_abatingsinenoise(verbose=False):
     import matplotlib.pyplot as plt
 
     def signalgen_abatingsine(amplitude, noiseamplitude, frequency, mean, abate, time):
-        resolution = 2048
-        step = (resolution * frequency ** -1) ** -1
+        # todo zu hoch aufgelöste signale können fehlerhaft sein
+        resolution = 64
+        step = (1 / frequency) / resolution
 
         times = np.arange(0, time, step)
         noise = np.random.normal(-1, 1, len(times)) * noiseamplitude
@@ -129,7 +135,7 @@ def test_stationarity_uncertainties_abatingsinenoise(verbose=False):
         return times, values
 
     test_amplitudes = [0.1]
-    test_noiseamplitude = [0.005]
+    test_noiseamplitude = [0.01]
     test_frequencies = [6]
     test_times = [40]
     test_mean = [-1]
@@ -145,7 +151,7 @@ def test_stationarity_uncertainties_abatingsinenoise(verbose=False):
                                                   abate=abate)
         stationary_timestep = estimate_stationarity(values)
 
-        well_computed_stationarity_limit = -np.log(0.03) / abate
+        well_computed_stationarity_limit = -np.log(0.02) / abate
         well_computed_stationary_time = timesteps[-1] - well_computed_stationarity_limit
         stationary_time = timesteps[-1] - timesteps[stationary_timestep]
         if verbose:
@@ -164,8 +170,8 @@ def test_stationarity_transientonly(verbose=False):
     import matplotlib.pyplot as plt
 
     def signalgen_abatingsine(amplitude, frequency, mean, time):
-        resolution = 2048
-        step = (resolution * frequency ** -1) ** -1
+        resolution = 36
+        step = (1 / frequency) / resolution
 
         times = np.arange(0, time, step)
 
@@ -211,7 +217,7 @@ def test_stationarity_uncertainties_abating(verbose=False):
     import matplotlib.pyplot as plt
 
     from ntrfc.math.methods import reldiff
-    def signalgen_abatingsine(noiseamplitude, mean, abate, time):
+    def signalgen_abating(noiseamplitude, mean, abate, time):
         resolution = 20000
         step = (time / resolution)
 
@@ -221,20 +227,19 @@ def test_stationarity_uncertainties_abating(verbose=False):
         values = mean + np.e ** -(times * abate) + noise
         return times, values
 
-    test_noiseamplitude = [0.005]
-    test_times = [10]
+    test_noiseamplitude = [0.01]
+    test_times = [30]
     test_mean = [-1]
-    test_abate = [3]
+    test_abate = [3, 2]
 
     test_configs = list(product(test_noiseamplitude, test_times, test_mean, test_abate))
 
     for noiseamplitude, time, mean, abate in test_configs:
 
-        timesteps, values = signalgen_abatingsine(noiseamplitude=noiseamplitude, mean=mean, time=time,
-                                                  abate=abate)
+        timesteps, values = signalgen_abating(noiseamplitude=noiseamplitude, mean=mean, abate=abate, time=time)
         stationary_timestep = estimate_stationarity(values)
 
-        well_computed_stationarity_limit = -np.log(0.01) / abate
+        well_computed_stationarity_limit = -np.log(0.02) / abate
         well_computed_stationary_time = timesteps[-1] - well_computed_stationarity_limit
         stationary_time = timesteps[-1] - timesteps[stationary_timestep]
         if verbose:
@@ -244,3 +249,40 @@ def test_stationarity_uncertainties_abating(verbose=False):
             plt.axvline(well_computed_stationarity_limit, color="red")
             plt.show()
         assert 0.05 >= reldiff(stationary_time, well_computed_stationary_time), "computation failed"
+
+
+def test_snr_pod():
+    from ntrfc.timeseries.stationarity import snr_pod, optimal_window_size
+    import numpy as np
+    from itertools import product
+
+    def signalgen(noiseamplitude, amplitude, frequency, mean, time):
+        resolution = 48
+        step = (1 / frequency) / resolution
+
+        times = np.arange(0, time, step)
+        noise = np.random.randn(len(times)) * noiseamplitude
+
+        values = np.sin(times) * amplitude + mean
+        return values, noise
+
+    test_noiseamplitude = [0.05, 0.1]
+    test_amplitudes = [1]
+    test_frequencies = [4, 8]
+    test_times = [40]
+    test_mean = [-2]
+
+    test_configs = list(product(test_noiseamplitude, test_amplitudes, test_frequencies, test_times, test_mean))
+
+    for noiseamplitude, amplitude, frequencies, time, mean in test_configs:
+        sine, noise = signalgen(noiseamplitude=noiseamplitude, amplitude=amplitude, frequency=frequencies, mean=mean,
+                                time=time)
+        signal = sine + noise
+        # Compute the SNR using the snr_pod function
+        optimal_window, optimal_window_s, nperiods = optimal_window_size(signal)
+        window = int((optimal_window_s / nperiods) / 16)
+        reconstructed_mean, fluct, snr = snr_pod(signal, window)
+
+        # Check that the SNR is close to the expected value
+        expected_snr = np.trapz(sine ** 2) / np.trapz(noise ** 2)
+        assert np.isclose(snr, expected_snr, rtol=0.05)
diff --git a/tests/turbo/test_ntrfc_cascade_geometry.py b/tests/turbo/test_ntrfc_cascade_geometry.py
index 0fac437fd2a961e034eadffa1a260b81f34adf6c..b8de239733ec2edca2d8e294110b50811f1abdd0 100644
--- a/tests/turbo/test_ntrfc_cascade_geometry.py
+++ b/tests/turbo/test_ntrfc_cascade_geometry.py
@@ -12,7 +12,7 @@ def test_calcmidpassagestreamline():
     res = 240
     xs, ys = naca(naca_code, res, half_cosine_spacing=False)
     sorted_poly = pv.PolyData(np.stack([xs, ys, np.zeros(len(xs))]).T)
-    sorted_poly.rotate_z(angle)
+    sorted_poly.rotate_z(angle, inplace=True)
 
     poly, ps_poly, ss_poly, ind_hk, ind_vk, mids_poly, beta_leading, beta_trailing, camber_angle, alpha = extract_geo_paras(
         sorted_poly, alpha)
diff --git a/tests/turbo/test_ntrfc_domaingen_cascade.py b/tests/turbo/test_ntrfc_domaingen_cascade.py
index 52fe996f2867510da229499cfbe953d01db36bff..5092b534c9feb2b5611433f9a9a5598132222758 100644
--- a/tests/turbo/test_ntrfc_domaingen_cascade.py
+++ b/tests/turbo/test_ntrfc_domaingen_cascade.py
@@ -13,7 +13,7 @@ def test_cascade_3d_domain():
     res = 420
     xs, ys = naca(naca_code, res, half_cosine_spacing=False)
     sorted_poly = pv.PolyData(np.stack([xs[:-1], ys[:-1], np.zeros(len(xs) - 1)]).T)
-    sorted_poly.rotate_z(angle)
+    sorted_poly.rotate_z(angle, inplace=True)
 
     sortedPoly, psPoly, ssPoly, per_y_upper, per_y_lower, inletPoly, outletPoly = cascade_2d_domain(sorted_poly, -1, 2,
                                                                                                     1,
@@ -32,7 +32,7 @@ def test_cascade_2d_domain():
     res = 420
     xs, ys = naca(naca_code, res, half_cosine_spacing=False)
     sorted_poly = pv.PolyData(np.stack([xs[:-1], ys[:-1], np.zeros(len(xs) - 1)]).T)
-    sorted_poly.rotate_z(angle)
+    sorted_poly.rotate_z(angle, inplace=True)
     X, Y = sorted_poly.points[::, 0], sorted_poly.points[::, 1]
     points = np.stack((X[:], Y[:], np.zeros(len(X)))).T
     pointspoly = pv.PolyData(points)
diff --git a/tests/turbo/test_ntrfc_pointcloud_methods.py b/tests/turbo/test_ntrfc_pointcloud_methods.py
index abd50a34d37d6f26b2f8eb3be8407be73cea2b4c..11b5158885e924c4c118c485ec96bf20f6c9847b 100644
--- a/tests/turbo/test_ntrfc_pointcloud_methods.py
+++ b/tests/turbo/test_ntrfc_pointcloud_methods.py
@@ -1,3 +1,9 @@
+import numpy as np
+import pyvista as pv
+
+from ntrfc.turbo.pointcloud_methods import extract_points_fromsortedpoly, calcMidPassageStreamLine
+
+
 def test_extractSidePolys():
     from ntrfc.turbo.pointcloud_methods import extractSidePolys
     from ntrfc.turbo.airfoil_generators.naca_airfoil_creator import naca
@@ -19,3 +25,43 @@ def test_extractSidePolys():
     # we generate profiles with a naca-generator. probably there is a minor bug in the algorithm
     # ssPoly needs to have one point more then psPoly
     assert ssPoly.number_of_points == psPoly.number_of_points, "number of sidepoints are not equal "
+
+
+def test_extract_points_fromsortedpoly():
+    # Create a sorted polygon with some per-vertex data
+
+    sorted_poly = pv.Circle()
+
+    # Extract a subset of the points and associated data
+    sorted_indices = np.arange(sorted_poly.number_of_points // 2, sorted_poly.number_of_points)
+    side_two = extract_points_fromsortedpoly(sorted_indices, sorted_poly)
+
+    assert side_two.number_of_points == sorted_poly.number_of_points // 2
+
+
+def test_calcMidPassageStreamLine():
+    # Define input values
+    x_mcl = np.array([1.0, 2.0, 3.0, 4.0, 5.0])
+    y_mcl = np.array([1.0, 2.0, 3.0, 4.0, 5.0])
+    beta1 = 10.0
+    beta2 = 5.0
+    x_inlet = 0.0
+    x_outlet = 6.0
+    t = 0.1
+
+    # Expected output
+    x_mpsl_ref_expected = np.array(
+        [0., 0.00756705, 0.0151341, 0.02270115, 0.0302682, 0.03783525, 0.0454023, 0.05296935, 0.0605364, 0.06810345,
+         0.07567051, 0.08323756, 0.09080461, 0.09837166, 0.10593871, 0.11350576, 0.12107281, 0.12863986, 0.13620691,
+         0.14377396, 0.15134101, 0.15890806, 0.16647511])
+    y_mpsl_ref_expected = np.array(
+        [0.87367302, 0.87500729, 0.87634157, 0.87767584, 0.87901012, 0.8803444, 0.88167867, 0.88301295, 0.88434722,
+         0.8856815, 0.88701577, 0.88835005, 0.88968432, 0.8910186, 0.89235287, 0.89368715, 0.89502142, 0.8963557,
+         0.89768997, 0.89902425, 0.90035852, 0.9016928, 0.90302707, 0])
+
+    # Calculate actual output
+    x_mpsl_ref, y_mpsl_ref = calcMidPassageStreamLine(x_mcl, y_mcl, beta1, beta2, x_inlet, x_outlet, t)
+
+    # Test output
+    assert len(x_mpsl_ref) == 1000
+    assert len(y_mpsl_ref) == 1000
diff --git a/tests/turbo/test_ntrfc_probegeneration.py b/tests/turbo/test_ntrfc_probegeneration.py
index 6f11319ed4a70d2c9027eee8c4381c0bb083dd0a..54eb90f261ec2d634ce2e881501e411ccc8848b9 100644
--- a/tests/turbo/test_ntrfc_probegeneration.py
+++ b/tests/turbo/test_ntrfc_probegeneration.py
@@ -11,7 +11,7 @@ def test_createprofileprobes():
     res = 240
     xs, ys = naca(naca_code, res, half_cosine_spacing=False)
     sorted_poly = pv.PolyData(np.stack([xs, ys, np.zeros(len(xs))]).T)
-    sorted_poly.rotate_z(angle)
+    sorted_poly.rotate_z(angle, inplace=True)
     sorted_extracted_poly, psPoly, ssPoly, ind_vk, ind_hk, midsPoly, beta_leading, beta_trailing, camber_angle, alpha = extract_geo_paras(
         sorted_poly, 1)
     n_psprobes = 24
@@ -47,5 +47,5 @@ def test_stagnationpointprobes():
     res = 420
     xs, ys = naca(naca_code, res, half_cosine_spacing=False)
     sorted_poly = pv.PolyData(np.stack([xs[:-1], ys[:-1], np.zeros(len(xs) - 1)]).T)
-    sorted_poly.rotate_z(angle)
+    sorted_poly.rotate_z(angle, inplace=True)
     probes = create_stagnationpointprobes(1, 20, sorted_poly, 0, np.array([1, 0, 0]), 1)