diff --git a/.github/workflows/draft-pdf.yml b/.github/workflows/draft-pdf.yml deleted file mode 100644 index 30efd4b7..00000000 --- a/.github/workflows/draft-pdf.yml +++ /dev/null @@ -1,28 +0,0 @@ -name: Draft PDF -on: - push: - paths: - - joss_paper/** - - .github/workflows/draft-pdf.yml - -jobs: - paper: - runs-on: ubuntu-latest - name: Paper Draft - steps: - - name: Checkout - uses: actions/checkout@v4 - - name: Build draft PDF - uses: openjournals/openjournals-draft-action@master - with: - journal: joss - # This should be the path to the paper within your repo. - paper-path: joss_paper/paper.md - - name: Upload - uses: actions/upload-artifact@v4 - with: - name: paper - # This is the output path where Pandoc will write the compiled - # PDF. Note, this should be the same directory as the input - # paper.md - path: paper.pdf \ No newline at end of file diff --git a/.github/workflows/python-publish.yml b/.github/workflows/python-publish.yml index 82f8dbd9..1e26ad65 100644 --- a/.github/workflows/python-publish.yml +++ b/.github/workflows/python-publish.yml @@ -1,11 +1,3 @@ -# This workflow will upload a Python Package to PyPI when a release is created -# For more information see: https://docs.github.com/en/actions/automating-builds-and-tests/building-and-testing-python#publishing-to-package-registries - -# This workflow uses actions that are not certified by GitHub. -# They are provided by a third-party and are governed by -# separate terms of service, privacy policy, and support -# documentation. - name: Upload Python Package on: @@ -16,49 +8,83 @@ permissions: contents: read jobs: - release-build: + build: + name: Build distributions runs-on: ubuntu-latest - steps: - uses: actions/checkout@v4 - uses: actions/setup-python@v5 with: - python-version: "3.x" + python-version: "3.11" + cache: pip - - name: Build release distributions + - name: Build sdist and wheel run: | - # NOTE: put your own distribution build steps here. + python -m pip install --upgrade pip python -m pip install build python -m build - - name: Upload distributions + - name: Upload dists uses: actions/upload-artifact@v4 with: name: release-dists path: dist/ + test-matrix: + name: Test wheel on Python ${{ matrix.python-version }} + runs-on: ubuntu-latest + needs: build + strategy: + fail-fast: false + matrix: + python-version: ["3.11", "3.12", "3.13"] + + env: + MPLBACKEND: Agg + + steps: + - uses: actions/checkout@v4 + + - name: Download dists + uses: actions/download-artifact@v4 + with: + name: release-dists + path: dist/ + + - uses: actions/setup-python@v5 + with: + python-version: ${{ matrix.python-version }} + cache: pip + + - name: Install wheel + test runner + run: | + python -m pip install --upgrade pip + python -m pip install dist/*.whl + python -m pip install pytest + + - name: Smoke import + run: | + python -c "import pyuncertainnumber; print('Imported:', pyuncertainnumber.__name__)" + + - name: Run tests + run: | + pytest -q + pypi-publish: + name: Publish to PyPI runs-on: ubuntu-latest - needs: - - release-build + needs: test-matrix + permissions: - # IMPORTANT: this permission is mandatory for trusted publishing - id-token: write + id-token: write # required for trusted publishing - # Dedicated environments with protections for publishing are strongly recommended. - # For more information, see: https://docs.github.com/en/actions/deployment/targeting-different-environments/using-environments-for-deployment#deployment-protection-rules environment: name: pypi - # OPTIONAL: uncomment and update to include your PyPI project URL in the deployment status: - # url: https://pypi.org/p/YOURPROJECT - # - # ALTERNATIVE: if your GitHub Release name is the PyPI project version string - # ALTERNATIVE: exactly, uncomment the following line instead: - # url: https://pypi.org/project/YOURPROJECT/${{ github.event.release.name }} + # url: https://pypi.org/project/pyuncertainnumber/ steps: - - name: Retrieve release distributions + - name: Download dists uses: actions/download-artifact@v4 with: name: release-dists diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml new file mode 100644 index 00000000..8173d612 --- /dev/null +++ b/.github/workflows/test.yml @@ -0,0 +1,32 @@ +name: Tests + +on: + pull_request: + branches: [main] + push: + branches: [main] + +jobs: + test: + runs-on: ubuntu-latest + env: + MPLBACKEND: Agg + + steps: + - uses: actions/checkout@v4 + + - uses: actions/setup-python@v5 + with: + python-version: "3.11" + cache: pip + + - name: Install package + test dependencies + run: | + python -m pip install --upgrade pip + python -m pip uninstall -y pyuncertainnumber || true + python -m pip install -e .[test] + + + - name: Run tests + run: | + pytest -q diff --git a/.gitignore b/.gitignore index b020fc66..f0bd0214 100644 --- a/.gitignore +++ b/.gitignore @@ -1,5 +1,6 @@ # local env matplotlibrc.txt +*.egg-info/ # Data diff --git a/docs/source/_static/KNN_calibration_demo.png b/docs/source/_static/KNN_calibration_demo.png new file mode 100644 index 00000000..159f921d Binary files /dev/null and b/docs/source/_static/KNN_calibration_demo.png differ diff --git a/docs/source/_static/custom.css b/docs/source/_static/custom.css index d497ab79..104b1117 100644 --- a/docs/source/_static/custom.css +++ b/docs/source/_static/custom.css @@ -43,4 +43,72 @@ h2 { /* center horizontally */ margin-right: auto; display: block; +} + +/* typography: global sizing + fine-grained tweaks */ + +/* Lower the global base size slightly; tweak if needed */ +html, +:root { + font-size: 15px; + /* default ~16px; smaller overall typography */ +} + +/* Main article/content area */ +.content, +.content>article, +.page, +.bd-article { + font-size: 0.95rem; + line-height: 1.6; +} + +/* Headings: reduce sizes for better hierarchy on small screens */ +h1 { + font-size: 2.0rem; +} + +h2 { + font-size: 1.6rem; +} + +h3 { + font-size: 1.3rem; +} + +h4 { + font-size: 1.15rem; +} + +/* Sidebar navigation */ +.sidebar-tree .reference { + font-size: 0.95rem; +} + +.sidebar-tree .caption { + font-size: 0.9rem; +} + +/* Cards (sphinx-design) */ +.sd-card .sd-card-header, +.sd-card .sd-card-title { + font-size: 1.1rem; +} + +.sd-card .sd-card-body { + font-size: 0.95rem; +} + +/* Code blocks and inline code */ +pre, +code, +.highlight pre, +.literal-block { + font-size: 0.9rem; +} + +/* Tables */ +table.docutils, +.docutils .line-block { + font-size: 0.95rem; } \ No newline at end of file diff --git a/docs/source/_static/nested_ds.png b/docs/source/_static/nested_ds.png new file mode 100644 index 00000000..8664fbd1 Binary files /dev/null and b/docs/source/_static/nested_ds.png differ diff --git a/docs/source/examples/calibration/2dof_tmcmc_demo.ipynb b/docs/source/examples/calibration/2dof_tmcmc_demo.ipynb new file mode 100644 index 00000000..1995d3a4 --- /dev/null +++ b/docs/source/examples/calibration/2dof_tmcmc_demo.ipynb @@ -0,0 +1,272 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "d81f5fb3", + "metadata": {}, + "source": [ + "(tmcmc)=\n", + "# Transitional MCMC with the classic eigenvalue problem" + ] + }, + { + "cell_type": "markdown", + "id": "e0e94f8b", + "metadata": {}, + "source": [ + "TMCMC (Transitional Markov Chain Monte Carlo) has been widely used in stochastic model updating, which aims to find the posterior samples of the parameters ($\\theta$) to be updated given empirical observations. \n", + "\n", + "$$\n", + "\tP^j = P(\\mathcal{D}|\\boldsymbol{\\theta})^{\\beta_{j}} \\cdot P(\\boldsymbol{\\theta})\n", + "$$\n", + "\n", + "\n", + "This notebook provides a hands-on example that illustrates how *TMCMC* is used in a classic eigenvalue problem with only elementary knowledge about structural dynamics. \n", + "\n", + "\n", + "Consider a simple two-degree-of-freedom system under undamped free vibrations. The equation of motion reads:\n", + "\n", + "$$\n", + "\\mathbf{M} \\ddot{\\mathbf{u}}(t) + \\mathbf{K} \\mathbf{u}(t) = 0\n", + "$$\n", + "\n", + "Assuming harmonic response yields the classic eigenvalue problem: \n", + "\n", + "$$\n", + "\\mathbf{K} \\phi = \\lambda \\mathbf{M} \\phi\n", + "$$\n", + "\n", + "this further leads to the characteristic equation by a nontrivial solution using the determinant:\n", + "\n", + "$$\n", + "\\det(\\mathbf{K} - \\lambda \\mathbf{M}) = | \\mathbf{K} - \\lambda \\mathbf{M}| = 0\n", + "$$\n", + "\n", + "where \n", + "- **eigenvalues**: a system of 2 degrees of freedom will give a polynomial of 2th degree in $\\lambda$. The 2 roots will represent the frequencies at which the undamped system can oscillate in the absence of external forces, *i.e.*, natural frequencies of the system. \n", + "- **eigenvectors**: The values of the vector $\\phi$ at each natural frequency describe the mode shape of the corresponding mode of vibration, which reflects the relative displacement pattern between the two masses.\n", + "\n", + "This setup solves the natural frequencies given known stiffness and mass matrix. Inversely, in order to identify the system given empirical measurements, consider a problem of solving the stiffness of the system given a few measurements of the $\\lambda_1$ which is contaminated by some Gaussian noise (e.g. known standard deviation $\\sigma_{\\lambda_{1}}$)." + ] + }, + { + "cell_type": "markdown", + "id": "bdfee9e9", + "metadata": {}, + "source": [ + "```{note}\n", + "To further explore the identifiability of the system, Yuen (2010) proposes 3 different setups:\n", + "1. Given one measured eigenvalue\n", + "2. Given two measured eigenvalues\n", + "3. Given a set of eigenvalue and associated eigenvector (mode shape)\n", + "\n", + "Readers are encouraged to have a think on the other two problems.\n", + "```" + ] + }, + { + "cell_type": "markdown", + "id": "4d51b48e", + "metadata": {}, + "source": [ + "This notebook provides an exemplar solution for the problem 2 where noisy data on two eigenvalues are available to infer the stiffness parameters. Ground truth values are $\\theta_{1} = \\theta_{2} = 1.0$, and priors are assumed as $\\theta_{1} \\sim \\mathcal{U}(0.8, 2.2), \\theta_{2} \\sim \\mathcal{U}(0.4, 1.2)$." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "615fc26a-1fe6-4140-b475-58b5168ad30c", + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "from pyuncertainnumber.calibration import pdfs\n", + "from pyuncertainnumber.calibration.tmcmc import TMCMC" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "5d533999-af6f-400a-92de-9525792956cf", + "metadata": {}, + "outputs": [], + "source": [ + "# eigen values of first mode\n", + "data1 = np.array([0.3860, 0.3922, 0.4157, 0.3592, 0.3615])\n", + "# eigen values of second mode\n", + "data2 = np.array([2.3614, 2.5877, 2.7070, 2.3875, 2.7272])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e44c59f6-7c93-407c-8398-073c91d560c0", + "metadata": {}, + "outputs": [], + "source": [ + "# number of particles (to approximate the posterior)\n", + "N = 1000\n", + "\n", + "# prior distribution of parameters\n", + "k1 = pdfs.Uniform(lower=0.8, upper=2.2)\n", + "k2 = pdfs.Uniform(lower=0.4, upper=1.2)\n", + "\n", + "# Required! a list of all parameter objects, i.e. the so-called $\\theta$ in Bayesian calibration\n", + "pars_theta = [k1, k2]" + ] + }, + { + "cell_type": "markdown", + "id": "ed804f8c", + "metadata": {}, + "source": [ + "The associated likelihood is:\n", + "\n", + "$$\n", + " p(\\mathcal{D} | \\theta) = \\frac{1}{(\\sqrt{2\\pi})^{10}\\,\\sigma_{\\lambda_1}^5\\,\\sigma_{\\lambda_2}^5}\n", + "\\exp\\!\\left[\n", + "-\\frac{1}{2\\sigma_{\\lambda_1}^2}\\sum_{m=1}^{5}\\left(\\tilde{\\lambda}_{1m}-\\lambda_1(\\theta)\\right)^2\n", + "-\\frac{1}{2\\sigma_{\\lambda_2}^2}\\sum_{m=1}^{5}\\left(\\tilde{\\lambda}_{2m}-\\lambda_2(\\theta)\\right)^2\n", + "\\right]\n", + "$$" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "919afc11-675b-4e5c-bf0d-98a7a6150b99", + "metadata": {}, + "outputs": [], + "source": [ + "def log_likelihood_case2(particle_num, s):\n", + " \"\"\"\n", + " Log-likelihood for the 2DOF example - CASE 2 (two eigenvalues λ1 and λ2).\n", + "\n", + " Args:\n", + " particle_num (int):\n", + " Index of the particle (not used in this function, but required by the TMCMC framework).\n", + "\n", + " s (ArrayLike): numpy array of shape (2,)\n", + " Parameter vector in this case:\n", + " s[0] = q1 (stiffness parameter 1)\n", + " s[1] = q2 (stiffness parameter 2)\n", + "\n", + " returns:\n", + " LL (float): Log-likelihood value at this parameter vector.\n", + " \"\"\"\n", + " q1 = s[0]\n", + " q2 = s[1]\n", + "\n", + " # standard deviations (5% noise on true eigenvalues λ1=0.382, λ2=2.618)\n", + " sig1 = 0.0191 # 0.05 * 0.382\n", + " sig2 = 0.1309 # 0.05 * 2.618\n", + "\n", + " # compute eigenvalues λ1(q1, q2) and λ2(q1, q2) for the 2×2 system\n", + " # characteristic equation: λ^2 - (q1 + 2 q2) λ + q1 q2 = 0\n", + " # closed-form solution:\n", + " # λ₁,₂ = (q1/2 + q2) ∓ sqrt((q1/2 + q2)^2 - q1 q2)\n", + " center = q1 / 2.0 + q2\n", + " disc = center**2 - q1 * q2\n", + " if disc < 0:\n", + " # if the discriminant is negative, eigenvalues are complex -> impossible here physically\n", + " # give a very low likelihood\n", + " return -np.inf\n", + "\n", + " sqrt_disc = np.sqrt(disc)\n", + " lambda1_s = center - sqrt_disc\n", + " lambda2_s = center + sqrt_disc\n", + "\n", + " # Gaussian likelihood for 5 measurements of λ1 and 5 of λ2\n", + " # p(d | θ) ∝ exp( -1/(2σ1²) Σ (λ1_s - d1_m)² - 1/(2σ2²) Σ (λ2_s - d2_m)² )\n", + " # log p(d | θ) = const - 0.5/σ1² Σ (λ1_s - d1_m)² - 0.5/σ2² Σ (λ2_s - d2_m)²\n", + "\n", + " # constant term (same form as in your Case 3 implementation)\n", + " const_term = np.log((2 * np.pi * sig1 * sig2) ** -5)\n", + "\n", + " # misfit terms\n", + " misfit1 = -0.5 * (sig1**-2) * np.sum((lambda1_s - data1) ** 2)\n", + " misfit2 = -0.5 * (sig2**-2) * np.sum((lambda2_s - data2) ** 2)\n", + "\n", + " LL = const_term + misfit1 + misfit2\n", + " return LL\n" + ] + }, + { + "cell_type": "markdown", + "id": "653d9c69", + "metadata": {}, + "source": [ + "The TMCMC algorithm is run by combining the above pieces together. " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "298bea95-0258-4f1d-911a-c5fec74ec332", + "metadata": {}, + "outputs": [], + "source": [ + "t = TMCMC(\n", + " N,\n", + " pars_theta,\n", + " log_likelihood=log_likelihood_case2,\n", + " status_file_name=\"status_file_2DOF_problem2.txt\",\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "7d63b709", + "metadata": {}, + "source": [ + "```{warning}\n", + "Do not run the code below in a Jupyter environment !!! Instead, run the whole code as a Python file. This is due to the incompatbility of the \"multiprocess\" package in the Jupyter environment. This noteboos is meant as a demonstration of how the code can be used. Unfortunately, due to the incompatbility, the code cannot directly run with the notebook. Readers are encouraged to copy all the code into aother python file to test the code. \n", + "```" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "78d98520", + "metadata": {}, + "outputs": [], + "source": [ + "mytrace = t.run() # Do not run in a Jupyter environment due to multiprocessing issues" + ] + }, + { + "cell_type": "markdown", + "id": "acce6f42", + "metadata": {}, + "source": [ + "
\n", + " \n", + "
Posterior of the problem 2
\n", + "
\n", + "\n", + "A trace object will be returned. Meanwhile, a log file named \"\"status_file_2DOF_problem2.txt\" containing information about the sampling process will be saved." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "pbox_nn", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.10" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/docs/source/examples/calibration/Data_peeling_demo.ipynb b/docs/source/examples/calibration/Data_peeling_demo.ipynb new file mode 100644 index 00000000..63e8037f --- /dev/null +++ b/docs/source/examples/calibration/Data_peeling_demo.ipynb @@ -0,0 +1,203 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "793008d0", + "metadata": {}, + "source": [ + "(peeling)=\n", + "# Data peeling algorithm\n", + "\n", + "The **data peelilng algorithm** constructs a hierarchy of nested enclosing regions, which serve as calibrated consonant *Dempster-Shafer structures* whose basic beliefs are set equal to the scenario lower probabilities. \n", + "\n", + "It begins by selecting a geometric shape for the enclosing sets, such as a rectangle or higher-dimensional hyper-box. The algorithm solves an optimisation problem to determine the smallest possible region or set that contains all data points.\n", + "\n", + "The points that lie on the boundary and mathematically define this minimal region are treated as *support vectors*. Once identified, these boundary points are iteratively removed from the dataset (*peeling*), while the process is repeated on the reduced set, producing progressively smaller, mutually nested layers. " + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "83ee5d9e-ff96-4745-b642-70c7bccfbff5", + "metadata": {}, + "outputs": [], + "source": [ + "from pyuncertainnumber.calibration import data_peeling as dp" + ] + }, + { + "cell_type": "markdown", + "id": "b25d151a-01c8-466c-87da-bcf080687179", + "metadata": {}, + "source": [ + "### data generating process" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "a2250d47-2f7e-4de0-a3b2-cb18735c3918", + "metadata": {}, + "outputs": [], + "source": [ + "X = dp.banana_data(n=100,d=3)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "86171498-f800-4c2c-9497-b4fda45f48fc", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n"
+      ],
+      "text/plain": []
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "\u001b[1m<\u001b[0m\u001b[1;95mFigure\u001b[0m\u001b[39m size 100\u001b[0m\u001b[1;36m0x1000\u001b[0m\u001b[39m with \u001b[0m\u001b[1;36m9\u001b[0m\u001b[39m Axes\u001b[0m\u001b[1m>\u001b[0m"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "dp.plot_scattermatrix(X,bins=20,figsize=(10,10))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "455f2b62-9d6d-4b2b-adaf-3f07101b285e",
+   "metadata": {},
+   "source": [
+    "### peeling algorithm"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "45f358e4",
+   "metadata": {},
+   "source": [
+    "```{tip}\n",
+    "**a**: is a list of subindices corresponding to the support vectors\n",
+    "**b**: is a list of enclosing sets (boxes by default)\n",
+    "```"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "d6129b0e-416b-4071-8253-75531a1a87f0",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "a,b = dp.data_peeling_algorithm(X,tol=0.01)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "36fe8246",
+   "metadata": {},
+   "source": [
+    "```{tip}\n",
+    "**f**: is a structure containing projections\n",
+    "**p**: is a list of lower probability, one for each level\n",
+    "```"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "809f9407-dbda-45c9-9e34-1f2d16453b2a",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/Users/lesliec/Documents/Github_repos/pyuncertainnumber/src/pyuncertainnumber/calibration/data_peeling/scenario.py:77: RuntimeWarning: divide by zero encountered in log\n",
+      "  aux2 = numpy.sum(triu(log(repmat(m1-k,N-k+1,1)),k=1),axis=1) # aux2 = sum(triu(log(ones(N-k+1,1)*(m1-k)),1),2);\n",
+      "/Users/lesliec/Documents/Github_repos/pyuncertainnumber/src/pyuncertainnumber/calibration/data_peeling/scenario.py:102: RuntimeWarning: divide by zero encountered in log\n",
+      "  poly1 = 1+bet/(2*N)-bet/(2*N)*sum(exp(coeffs1 - (N-m1)*log(t1)))-bet/(6*N)*sum(exp(coeffs2 + (m2-N)*log(t1)));\n",
+      "/Users/lesliec/Documents/Github_repos/pyuncertainnumber/src/pyuncertainnumber/calibration/data_peeling/scenario.py:102: RuntimeWarning: invalid value encountered in multiply\n",
+      "  poly1 = 1+bet/(2*N)-bet/(2*N)*sum(exp(coeffs1 - (N-m1)*log(t1)))-bet/(6*N)*sum(exp(coeffs2 + (m2-N)*log(t1)));\n"
+     ]
+    }
+   ],
+   "source": [
+    "f,p = dp.peeling_to_structure(a,b,kind='scenario',beta=0.01)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "53853f57",
+   "metadata": {},
+   "source": [
+    "### Visualise the resulting structures\n",
+    "\n",
+    "The final result is a full sequence of nested level sets that encode the depth structure of the data. Posterior samples are finally generated from a mixture distribution within the credal set identified by the calibrated consonant structure."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "253894bc-fb2c-467b-b5b1-2e062fd63ab4",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "
\n"
+      ],
+      "text/plain": []
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAABKUAAASlCAYAAAB5vWpLAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjMsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvZiW1igAAAAlwSFlzAAAPYQAAD2EBqD+naQABAABJREFUeJzs/QmcHGd17o8/tfU2m0ajkS1bsizJK8IrGCxjvNsxBsdJgMAvCYRLgEsWB5I/5JLcC8FZSMK9YQlwQzAkMQkQcGyWXGwC3rANNhgvwpKX2LIta7U0GkkzPb3U+v+ct7p7qnu6Z3pmeu/nq0+rZ6qqq6t7uuu89bznPEcLgiAAIYQQQgghhBBCCCEtRG/lkxFCCCGEEEIIIYQQIlCUIoQQQgghhBBCCCEth6IUIYQQQgghhBBCCGk5FKUIIYQQQgghhBBCSMuhKEUIIYQQQgghhBBCWg5FKUIIIYQQQgghhBDScihKEUIIIYQQQgghhJCWY7b+KfsX3/exd+9eDA0NQdO0dh8OIaRPCYIA09PTOO6446DrnJvoZBg3CCGdAmNH98DYQQjpprhBUaqFSHBYt25duw+DEEIUu3btwtq1a9t9GGQeGDcIIZ0GY0fnw9hBCOmmuEFRqoXIbEXxjzI8PAzXdfHAAw9gy5YtME3+Kcgs/GyQZn4+pqam1GC1eE4i3RM3ugmex1oH3+vW0O/vM2NH99CO2NHv3w9SH/yc9BdTdcYNfhJaSDF9VoJDUZQaGBhQP/NLSaLws0Fa8flgSn/3xY1uguex1sH3ujXwfQ5h7Oh82hE7+P0g9cDPSX+iLRA3WBBOCCGEEEIIIYQQQloORSlCCCGEEEIIIYQQ0nIoShFCCCGEEEIIIYSQlkNRihBCCCGEEEIIIYS0HIpShBBCCCGEEEIIIaTl9JTl/fT0NP7pn76Cn/zkYbznPe/AxRe/ZkkdAb797dvwox/9BJOTk6ozwKtf/Uq88Y3XIpFINOW4CSGEEEIIIYQQQvqNnhGlfvrTh5Ug5brekvchgtTHP/53eO65F/A7v/NbePnLT8eOHc/js5+9EU888RQ+/OE/QiIRb+hxE0IIIYQQ0kzS6TQ8r/YY2TAMDA4OtvSYCCHth+cG0gn0hCh1xx334Jvf/H8qO+onP/kZ7rvvgSXt5z//8y5s3/4k3vGOX8O5556llp1++qn4zd/8//DpT38et976H/i1X3tTg4+eEEIIIYSQ5l10fve730Umk6m5TSqVwutf/3pefBLSR/DcQDqFnhCl1q07Hh//+A0YGBhQotRSCIIA3/veHUoNvvDCLWXrXvGKszE4OIA777wHb3rTdYjFrAYdOelkpqam1ElaTsZSxknqg+8b6WYkFjz66M9VCfczz+zAkSNHEY/HsG7dWlx66Wvx2teWx4ci+/btxze+8S088cTTcBwba9cej9e97kps2XJey18DIYREkSwIicuxWEzdKrFtW62fL1uC1IZxg3QrPDeQTqEnRKlTTz152ft48cXdmJw8jPXr1yGZLPeOEqFq48YT8fOfb8dTT/0Xzjxz87Kfj3S2mHLw4EFs374duVxOeYlt3rwZmzZtavchdjw7duwovW+6rmP9+vU49dRTKU6RruFb3/ou/v3fv63Kt//wD38Xa9Ycg4mJSfzbv92Cz3/+H/Hkk0+rrNwoO3fuwp/92cexYcMJuOGGP8bw8JCa5PjsZ7+AAwcO4LrrXt+210MIIUXkorOWP6pcfJKlwbhBuh2eG0i76QlRqhHs2rVH3Y+Pj1Vdv2rVWGm7+USp2277Pm677QdV19l2vuRdVbz5vq/uSXt57rnn8MQTT5TElHw+rzLvhoaGVGrro48+qsSqVqWuymdCjkHM+02zO76mxfdJZgw1TcPevXuxa9cuPP/88zj77LOxcePGdh9iz7DccwfPObVxHAcjI8P4gz/4ndIA7fjj1+B973svPvjBj+CHP/wRXvOaV2Pz5tPVOvk7yEWHfO6vv/6/q8cKv/Ir1yp/wptv/jbOPfdsldFLCCGk92DcIISQ5dEdV7st4OjRo+pehIhqDAykCttNzbufbDaHw4ePVF0nqbnCAw88oJ5HgtKLL76olokQQtqDiD8vvPCCGhyIACTZUjMzMxgdHcXf33QLMukpGJqPjB+HG7TmK6MhQErPq+cMoKEbMDVXHbMf6Dh+VQqve93r1HKZ8bv77ruVOBWPs1FAI1juuUM+36Q6K1eOqlKLyhlDOTfILPhddx3Etm1Pli4upAmGZNqef/55pQuLItIBVko6vve9O/Hud7+9pa/jUNpHu/FcHxk7wGTah2G2/3h6Gb7XraFb3+epGR95FzCcAL4eqGWpWHeMLbqBXokby40d3fr96GeqnRui5J1ArZ+c8eEajfmb8nPS3YwNNkezoChVwLadUqleNYrZKgulMErp3+joinkzpbZs2aLKmYrZChdccEHXZMP0Ii+99BIOHz6MkZER/N97pmFqA9gQy+PJaRPrL3oXBvQc5DT9s8xmOH4oTjYbDR5OSz2JRzKnI0D1z2SnEdMzODu1HXEtjxFjGrumdZy+Jq5K+CTj6+UvfzmOOeaYdh9mT7Dcc4eUqpLqXHHFJTXXFUu7g8i47dFHH1f3J588NxPw5JPDkt/HHvt54w+UEEJIR8C4QQghy4NKSIGieXktI7fiRWA1E7go11xzlbrVuhC88cbPqIvI4oWkZDlEfyetR0r0pDRPMqR8WDB1H4e8UThIYNDIww7ieNrehINYC7Qooc2AB0dLIauvhNclolQGK7HdDvDy+NMwtGmVeTY2Nqa+O/L+yvvMz3njWM65g3+HpbFv30vq/rTTTp5T+r1q1ao5269YMQLLspTp7fR0GkND7FxDCCH9BOMGIYQsDK9MCkiWzHxlLTMzYavMyjRb0husWbNG+UqNGlnkggQeyZ+FSW8UCT2PnB9HOuCgoB5edNep922DtRMnmLtVZqGIU2IUT7Nz0s2k0zN4/PHtOPHEE3DWWS+vUvpdPYsylUri6FFHlX7XurhYjBfhYtLj241X8D6Te9Jc+F63hm59nz3PVbHYzucR+IVzg6uVeSLJ+oXOM/Qj7Jy40Ymxo1u/H/1M1XNDhOK5QbZr1N+Vn5PuxnUXl6FR7/mHolSBopnggQMTVddPTBwq2470Xrc4Oen+ZOYMZLSRkgiV9ihGLRZ57x63N2Nn/hhcoz2msg/FT0qypdjBkHQrX/vav6vC2ve+953KyL+y9Ns0l176vRgvwnoRv4Z2IwPcfXtexCPyztE3sanwvW4N3fo+O7aNfC6DmenwfCUYFYcv2TkPP/zwvBUB9CPsnLjRibGjW78f/Uy1c0MlpmVh+9ZHYC1QLVQv/Jx0N6lF+hHWGzcoShU44YS1ygtqz5596iRfrAEX5KJaumEkEnGcdtopbT1O0jiknFIEKVHrJVPuyJEjOOIk4BkGTC3b1mOT8j09cGAGWWhdUr4XRbwTcp6mBrmSni6d+eS9Hh8fZ8YU6Tp+9KMHce+9P8bv//5/nzMxUSz9dt2ll34vxouwXsRAtN3ILKhc3pz7yi0wWDLaVPhet4Zufp/POvc8uBGLitFU+cWgeKou1GGYfoSdEzc6MXZ08/ejn6k8N1RiGgZSqcZN0vNz0t2sXKTReb1xo+8+CZlMFp/73I0qHfY973lHqXOVzGBcffUValbj/vsfwJVXXlp6zMMPP6ZScMUrqhhISPcjHlKSISWC1BfuTSs/qdePPoBt7hk4Eoy29dh0eEiYPlYkHPho/8XlYlmhHcbLzcfxja0jeO+lvvKTmpiYUO85RSnSTTz++BO48cYv47d+620477xz56yX88fu3XtLJd7VYk643XDDvAjroVM62kiMlUEnB57Nh+91a+jW93loeMWyOyjRj7Bz4kanxo5u/X70M5XnhlbAz0n3YpqLix31nn/MfgwUjz0Wdr246qrLsHHjiaV1V199uVr39a9/E2NjK1Ub1x07nsdNN31NZVK98Y3XtvHISaORcjJp3ytZPL6mI6nlkccQprVVyGuDbRelPC2OvD4CvwszpaZhIK8PIQlbZaKJGCXvtbznhHQL27Y9gU9+8v/iHe/4NVxyyYVVt5EZ8O3bn8TBg3NLv8WoVvwYxLiWZrWEENL7MG4QQsji6QlRSk7q73//H5ct+8IX/lndVq0aw6c//del5aecsgmrV49jcHAAa9ceN0fJ+x//43349rdvw7/8y9cxOXlYzVJs2fIqvPGNv6guqknvIBk7YsC9detWjGhHkUcSz3mbkAEHActF3kN5L08ynsbk5KTyM6DZOekmtm17Ep/4xP/F29/+lrILi92792DXrr3YsuU89fvZZ5+B733vDjz77HNz9vHMMztK2xBCCOltGDcIIaSPRanx8VX4yldurGtbqb3+5Cc/VnO9eOC86U3XqRvpfcR4W0rL/uKnezCDYQpSDWSvvw5pP4WPXTCA0dFRClKka5AZ7E984nN429vkwuK1Zet27HgB993349LFxebNp6lZ70cf/bnqlBQtt/jhD3+kSsN/4Rcub/lrIIQQ0joYNwghpM9FKUKWg4hSh4OVcDVmwjWaTDCA1atXI5lMtvtQCKmL7dufwv/5P59VLbll1ltulZm5UW9B8UWQzkp//ucfx2c+8w9497t/U51T/vM/71QXHDLBIeXfhBBSJDOTXthYeICTZN0C4wbpJHh+Id0IRSlCCCGkgMxmSxtuuT344ENVtzn99PIurCeeeAL+/M//J77xjW/hIx/5mGr3vXbtGvzu774LF1zw6hYdOSGkWy4Y7/rBbchma3f5lYmcy668hheOXQLjBukUeH4h3QpFKdKXSFcSMd8W420p2SStfc9Zykc6FZm9lttiOe64NXj/+3+7KcdECOkdJINBLhhl7GHFYnPWO7at1s+X6UA6C8YN0inw/EK6FYpSpO/YsWMHtm/fjlwup8zrTzrpJAAD7T6svnrPxfRc/LwIIYSQfkQuGOPx6rYB0n2NEEKWCs8vpNugKEX6LltHxBHf9zEyMoJ0Oo1t27ZBd8+EYQToFHR40AIXhp+FBgPdihHkcfDgQdXhMAgCjI2Nqfdc/gbj4+PMmCKEENI1Hi2e5yKfz2Fq+igMY3YITY8WQggh80Gvr/mhKEX6Cikfk2wdEaT++ccz8GFgOJjG2uQUpjro6yCiVFL3Maq58NE5YtniMfDrNx7Cafo00hjEOy/0lZnnxMSE+ltQlCKk9UzO+C15Hs/zkbUDTGZ8GEZrnrNf4XvdPLKZNB6453bkclk1uZKbmcLOXXtVh7QiiUQSWy55HZKphS8o0hkfeTeAbgfwtbnx3ba7OeYT0r6YQ+o7v8j6IxkfbptiRT/Gq2gcqUViEXEkysoBHb1A51yFE9ICxM9IysckW0cEqYSWg60lMaOPw8ZgR4lSHuKw9RF1nN1MFgZsJBAPcvD9QSVGyd9A/haEEEJIJ+N5nrqQME0LpmnCs7NIJlPQtPBCwHFstV62I4QQQuaLI5ZVxevLYRzpDWmNkDqRzBzxM5IZzmEcBaDhRZyMbAcJUr2GvLfyHst7PTk5qd57+RswS4oQQki3IBcSsVhCle3JfSwe3qpdYBBCCCFV40ghdkRvFuMIM6VI/yEG21JC9snH9iKrjVCQagEHsA6ZIIUbLkhidHSUghQhhJC+RmbGay3v7vxoQkgnn18I6UQoSpG+RESpoxiDh+qdKUjjyWIAq1evQjKZbPehEEIWweGMv2TfiJwTqMf3i29Eu+B73TwyWR+2eLS4ATwtgLvMt9cwDOUdIqUarlu9C9bgUEqZ3hLSyyw1tpDa5GwdMBLIiHdRrroAFYsnMW3rcNr0/vdjvIrGEV+f6/XluIFafzTrw6njPRlN9V6xG0UpQgghhBBCWoCY2IqZ7XzeIauGrL7uwkQIWRqJ5ADOufB18D235ja6YartCOkkKEoRQgghhBDSIhbqrpTqkW5KhJDWQ8GJdCMUpUjfMTU1pQy3fcmO5LivLe+/dOCT7nv0liKEENINuI6NIPDheS5sO1fWfY8QQgipJ44sZnk/QVGK9BU7duzA9u3bkU6nkcmcAyNhIRZjx4NW8fzzz+PZZ59FLpdDIpFQXfjEeJ4QQgjpRKTURTxY7HxWCVBy8ZDNZlQn2SLiESVeUYQQQsh8caSWl2AsnlTb9Sv9+8pJX2boiCDl+77K0DH8PNzsUcQgJ4HOSpnS4UHTHeh+RmxR0RO4WWzbtk0N3MfGxpQwKH+P8fFxZkwRQgjpeI8W3/Pw4tMP4+Vnn1cmQsnPC5XkEUII6U/o9bUwFKVI3yAlY5KhMzIygq8+mMb5K57FAI7iBeNMpLWV6CS0wEM88DFsugi0uV0aupHB2DTuejKDLIbwGxf4qgPixMSE+rtQlCKEENJp5LIz815EUIwihPQ7C50n+11sKcL3YH4oSpG+QTyMpGRMMnR8zURcz8HFEHLmOFytswaVeuDB9xLwjBH4Wm9kSuUCA66bQizIq2w1EaPk7yF/F0IIIaTTLrQevf92VW5RJAgCONkpHDm0X5XvSdmedNKjMEUI6UeqnSerlaVJlhBFGTIfnVWzREgTkWwc8TCSgeQgjkg+EvbpJyHXYYJUryLvs7zf8r6L0bz8HeTvwSwpQgghnYbM/MuFlmla6mIqvKVgWjEk5d60kMtl4Xleuw+VEEI66Dw5e5Plsn6+TCpCBGZKkb5CTLWlbOwfntyHvD5CQarFHDJOQAYD+F8XJDA6OkpBihBCSEcjIpQVS6ifpfueLYa1sQQ0za5pWEsIIf16nqyE50lSDxSlSN8hotS0ZsPXqp88SXPJawNYvXoMyWSy3YdCCCGEEEIIIaSNUJQihBBCSE2OZv0lPc73fOTcAFNZH7qxtH2Q+uB73XiyOR+2FwBuAE8PG47Ee8PikZCeijWks86TURw3UOuncj6cQmxivFocI8n+cFvqj1dJCCGEEEIIIYQQQjoKZkqRnmBqakp1c5NObvQp6l74dySEEEIIIYSQ/oGiFOl6duzYge3btyOXyyGRSKiObmJoTroL/h0JIaT7yWdn4Pu1Oy3puol4F7UG9yImvboRwJNuU3YOrstuUoSQ/j635zLT8Bwb+SA8VxqmVfP8Sch8UJQiXZ9ZI0KG7/sYGRlBOp3G1q1blZm53KohoofmZgG9g+uYAw8IHCDIAFpvmVhofl79DaJMT0+rv1sQBBgbG1N/R/m7jo+PM2OKEEK66KLlyZ9+T7UAr0UsnsTpr7q644UpEc/kWOW1eK6tlgU64Do2stkMNE1DIpGEYfRWjCaEkHrP7b7r4uihffA9D7phYGTV8TDMcnlBzqNyPiVkPvgJIV2NlHqJwCGC1L//LIMAJpLBEfzLs/uRMWqo80GAoYQMIjt3llMLPCRcHyOmi0CbaxzY3Rh465dmAC1TWpLyDmGtPY0chvCrr/aVoDgxMaH+vhSlCCGkO2bOZdY8m55SFyUyY65pOvTIzLnMmstFzXyZVJ2CiGYinkWPddAK8OLTD+PlZ5+nxCi5JVODbT1OQkh30w3ZpXJ8cu42zNicbKjViRRcJw/PdXHaeVcgkRrquOMnnQ9FKdLViPeQlHpJZo0IUpaWg6sl4ZgjCPREzccFSKKTEVEqCOLwYyMIeixTqhqONgLXTcLyc/D9ASVGyd9V/r6EEEK6Y+ZcyjgOH9gN3TSh6yLamBg//iQYVmx2m0LWUTdQeSGVjPmwYgkMDg2r10YIIf2UXSqClJwDy4gloNsW7NyMEqSSAyPtOjzSxbD7HulqJItGvIckjV4ypAANE9bJsHXOXHYT8veSvxs0DZOTk+rvKX9XZkkRQkhnEp05jyUG1M1KpKAbphJsRJQS/6Ug6OBSeUII6bDzaPQmy7slu5SQ5cBpHtL1iBm2lHtJyZ5kSFGQ6k6OWicghwFccEEco6OjFKQI6SCmsosXFnzPR94J1GN1g8JEM2nHe53P+XDkOkmV6cXD49BkbshQmctSeO77Hmw3gFcoQxdvcHlMWh67gK/jcJLzpoT0O0uJPd1EtfNoFE+qCVy7rnNmS47TlfP8XFuRxZzbOTYIYYwrh6IU6QlElBIPqflK9kjnY+sDWL16JZLJzi6vJIQQQgghhBCyfChKEUIIIWTZTOfKZzwD31dZMum8D62Tu532AK14r53cDALfm/09O418Pg8vMGC4gSq/tnrfApEQ0iUxqBuwcwEcLwDcoGoGkueG69O5AHYb42gjjrMYQ+SWzeYwefgoNH02aMjPVqL9vlnNYijBzKj5oChFCCGEEEJqIhcTu3/+A7j2rBmv7zpIT+6GrlvQdB26YWHF6rVqnbrwQKDK96QrUwCtZIReCzHJDSK+KVm/fADPDk6EENJeajWqWKiBRVkMCQIY7jQmD+5TkxlFzFgSa8+8siuEqcpJmkp6XWBrBhSlCCGEEEJITWTwLRcTIjyJ8a7g6XklFEmnPcH3HNVsRIzOfc9VgpTcu2LS680O3q14EppuzhGknnvk+3AiHagss3M7UBFCSD8hIouIRhIHwnP9XGR9NPOpZgxRnUvz0OMp2XFJ1JL18wk9nTxJU0k3CWydAkUp0pVMTU0hk8kglUrRELsH4d+XEEI6DxGkDGvWjDe8AJGZ7kCVECLwMbRqnbr3XEddvGw45wrEU0ORx5iqq1QUyZASQUpdsFih6BWLjFBlX+xARQjpVZaagdQqRFwRkWW52UESQ3TTQuAY0Kw4tIIoJdQSu7phkiZKNwlsnQRFKdJ17NixA9u3b0cul0MikcDmzZtx3HHHtfuwSIN4/vnn8eyzz5b9faXDIiGEkA5Ck6woS11IyOBbBCMnnykN0jVNQ2JgBInB0TkiVC1EkDILopdlzZZ1dNLFGSGEdEoGUith1s/8kzRRukVg6yQoSpGuy6ARQcr3fYyMjCCdTmPr1q2wLAtw7XCmthcIPDHfQOBkEGjtD0StwndmsG3bNhiGgbGxMfX3lb/3+Pg4M6YI6QLE5LRI4Aeh+XYugKbPNUYljaPZ77WTD+B6AQI3gFEwuY2ZMQwfs1H5g3hOXl1UbawjK4oQQpodf7qHFEZPvWLBDKQ8Ush35eurEkMQQLzQfdUgIygZpXtegJm8GKV39uusFg+jVHstg4nySRYyF4pSpKuQki7JoBFB6juPZQHNQtw7gm/uOorh1CCA3kjt1wIPicDHioSLoMoJr1dJmBk88GwWtj6MX3qFj6GhIUxMTKi/O0UpQggpx83PdjPy3LzqiFfZzciMN08UipYuSKaUCFLx1EjTno8QQnqNZp6juz221aLZsY20HopSpKsQjyEp6ZIMGhGkzCAHT0/CsUYQGLOzs11P4CKwEwhiIwi0/vmaOoYB307BCnLw/ZQSo+TvLX93Qggh5YP2A0/8AF6hm5Hlp3GkopuREUti9cuubNrgXZXUFTKlfNdGPjNdtp6ZUoQQQpYc22qwUGyjqNV99M/VLukJJFtGPIakZE8ypESQOpI4GW4vCVJ9jPwd5e+5IvsUJicnMTAwoP7ezJIihJByVHZUwWxV0y1oTh6GNVASpQLPVusbabaq9ln42XFcTE/sVB32gsBDEPh4/tE7oEeyp6TT3sZzr6IwRQghJIwhQSC1e/AcuyxeVY1txlwj8YViWyNELdJ6KEqRrkNMr6Ws65u7D8AxhylI9RgzifWw9QFccEEMo6OjFKQIIWQeZNBumBZ0zwSkc12xxbb6rzFmqzKrLIN4Ncgv7DMIHLhOVnVPkptuxmEmBkolfXLBIR31pLNevaiLlAJRWxHpvkcIIaQ7KYshrg3dd+AFM3Mye2W7otikYlsVI/GFYttyRa2lTNJULid9LEplMlnccst38NBDjygz7LGxlbjwwi249tqrYZr1v8wdO57H//t//4nnn9+JI0eOYmRkGOvXr8N1112DTZs2NPU1kPoRUSpnegiMRLsPhTQB1xjE6tUrkEwm230ohBDS98hssswqRwfxMT+N3Y/fqTpDqQsHTUM8EV9SByIp85OsKhGxSo+pGLrF4knoes8MWwkhpC9jiNzy+x9D/Nizq3ogOtmphjznUkWtpUzSVFIU2Ej9mL0iSN1ww99gZmYG11//HmzYsB5bt27D5z//j3jmmR34wAeuh66HM4fz8ZOf/Ayf+cwXsG7d8fi933s3TjhhLQ4cOIibbvoa/vRP/wq//dvvxGtec35LXhMhhBDSjUjHmWJHONcD/Dy77zUD1w7gSgcjH/A8wJJGRk18vsoyB8vXoJuWGvTXaotdL1LeJ2V+0ayqwUT5uE0EqXiSpRaEkPpiEOk0UoAOBHDhaXHY+qCakIiSl852FbGtElkut4wdwKwytlju4+t5HYMnLdwxkaWBi2NhpaYLuPnmb2L37j1417vejlNPPRmxWAznnXcufuVXflGJU3fe+cM69/NtBEGAd7/7N3HSSRvVftauFYHqPWr9V7/672o9IYQQQghpHCJMSee+4i05UH6jIEUIIaQTMGIDMBPDNW+ynvSZKJXN5nD33fdjxYoRnHXWy8vWXXTRBdA0Dbfffkdd+5qYOKTujz9+TdlyKeEbGhpU5XxTU+WdZQghhBBCCCGEEEJIH5bvbd/+FBzHwUknbVACVBQRko499hjs27df3dasOXbefZ144gmq3G/37r1l/lFHj05hejoNwzAwMMDW9IQQQki/4tkLt5pu5Sxp4Nrwg0CVvvk1uhkRQggh3ULgufDyafhuvso6RwwL23JcpHl0vSi1a9dudb9q1aqq68fHx5QgtWvXngVFqXe849fwt3/7WXzxi19WpYDiLVX0lJKyvcsvv2hRpumEEEII6S1B6vDTd8B3area1q0kRk+9ounClIhf8lxyLCJASTc8Ob5q3YyaiefOil9uoFXtpEcIIYTUgwhRdvpAVUGqiHR7nW99acKmxnLSeXS9wiJZTEKtDKZUKlW23UKZUn/2Z3+CL3/53/CRj3ystFw6+b3pTdepDnwLcdtt38dtt/2g6jrbDr88ruuWbr7vq3uyOOQ90wJPzizoRcLX5of3fYi87uJ3hMxluecOvq+ELA3JkBIRSNMtaGas+iBYRKIWzOKK6CXiV7GbkX9wKwaPr97NqBmofceScO1Ixzy3PGNdOupVGtkSQggh8wlOscHV0j4PmmnNWR+4jqRLqe0WnLCxq3fHk/XsjtdZdP1IwbZDtVNK66phmkbZdvPx5JNPq+57o6Mr8NGPfkhlSu3ffwDf//5dyOfzqkwwHo8v6HF1+PCRquucwqzhAw88gIGBAXVR+eKLL6pl9XQH7FeK771lWaX3X34fz+QQaF3/Ea6KBh8pZy+0GelS0X+fDS1w8eCDCfU3X8rno9dZ7rlDOpUS0ku0uqROBKlqA2KZla01CG4GxdckpXuuGYeVHGqZCGQlBrD2zLDFd5HBRLkoJcciBuaEEEJ6t4y80WiGCT02UD3Ounn4khVcx4RNr74/vUjXX9FLhzzBq9bzUWUEeGXb1SKTyeDv/u4fkMvl8Zd/eb0SporZU7/xG2/BH/7hn+CJJ55WYtV8F4HJZKL02FqZUlu2bMHw8HApW+GCCy5gWWANnnvuOTzxxBPI5XJIJBLYsGEDNm7ciGw2ixv/6ygCI96zmUKrAmBi4BUItP5T8jUvj/PPH0EymVzS56PXWe65Y2pq4cxRQrqFTiqp6zdEmIoST/TfJAohhLQSxryF6dfX3c10vRIinfGEmZlMTbEpul0ttm7dpjrrnXHGy+aISqlUEmeffQbuu+8BPPDAQ3jNa15dcz/XXHOVutW6ELzxxs+oi8jihaQIXNHfSfn79dRTT6mfR0dHkU6nsW3bNqxYsUJlxXhOXircelaUEoVfvcY+FaVEeJEMqFpMT0+rz4P4vY2Pj6vPh3xejj32WCX69jrLOXfwfEOayYwdhD/4ATQvgC2/64VlTcDLubBzWTWzCqPKBJRnw81lMZNzYWB5x+HZAWSuS16Xrs3dl+8FUlWAjB3AaOJrHoiVZyQRQghZRHzqYloZ85rCAmODTomzAmNt6+j6K5N169aq+4MHJ6quP3jwUGG74+fdT3G7FStGqq4vLt+5c9e8ohRpHCIoSgbMyMgIvrdNZgNisNzD+M+XDsKxVmIkJWJNj3rjBB4Sjo+RuCsKFfoPA/+/W3KAVtvE0LIPYWQqDccYwjVn+RgaGsLExIT63PSDKEUIqcCoXVIHr0djBSGEkP6EMY/0EF0vSm3efBosy8SOHc+rjAkt0nVmejqN/ftfwjHHjC/YeW9wMEzzO3LkaNX1RZ+ookcVaT5iUi8lWZIBI4KUEeTgG0n4sWHAlLKu+Uu7uhoxcM8mgPiImJe0+2g6Eh/D6vNg+Hn4fkqJUfJ5KTY3IIQQQgghhBDS2XT91a54OF188YW44457VAmelNkVuffeHyuh6uqrrygty2Sy+NznbsTQ0CDe8553lPyhzjxzszJL/6//elYJUNESPjEvl30XRTDSGiTbZfPmzdi6davKkBIBIjNwCjxzqN2HRjoA+RzI5yGVfhKTk5OqeYB8XpglRUhnIKn1MQ9NL9/znQCuKgcAIvNSJcJmpgGyTgB9mcdRfC44tnq+Oc/l26o0oRHPFSXFEgJCCGlofOpWWhnzmoI//9igXXFWYKxtHz3hSPmWt/wyjj9+Db74xS/j6aefUZ32HnroEdx663eUR9Tll19c2vbxx5/AY489rvyhXngh7F4lrFo1hje/+ZeQz9v4xCc+i2effU6Znku53ic/+TmVdSVle5s3n96mV9mfbNq0CRdeeCGODr8CR0fPRy61vt2HRDoI+TwcHX6lMvy+5JJL1OeFEEKahXTs0SRT13MQODNzbrJc1rPVNCGEELJ4GGf7k67PlBKkXEe64t1yy3fw2c/eqAzLx8ZW4g1vuBrXXnu1yoAqcsopm7B69bgq11u79riy/ci24j31/e/fhf/9vz9TKAeKK9+qd7/7N3Hxxa9pw6sj4hXkxHzATLT7UEgH4pmDWL164U59hBBSDTXQXaB1tGaFJf5yH994Ofz8NAKZjq62fROaU0j76+gxuj5ncwkh/Y2dk/PirHeSkw27H7mFLCg5d/dqFzb1uj27+jrPLntfuo1inK03Li82jpPOpCdEqaIw9ba3vVXd5kPK8j75yY/VXC/lf9ESQEIIIYR0Piql362xvNZjnBnkn7sTgVu7tbbMyMoAOTqgdfb8dNGPWQzRAXbgZDC9+374bq60PmvoYeelArqZwPCK0SU9FyGEdKMg9dwj34eTnz0PZ+2CKFXozK1bSYyeekXPCVMSE/zpfQggXspzi56CwIcGTW2H+OItLTpB4JH91zv1stQ4TjqLnhGlCCGEENK/qf4yIA08p/o2NVL9ZeCtBrKGBU2PVRW01H59rzRAXspjFkPlAFteU5DeEzouFC5AAtNEYuUJ0IwYAteG72QRBLNemIQQ0stIJpAIUrphwbDC87Ad9p2D72P2vDiPuNL9BMo7udpyLCn6dKfA0+yYTFoDRSlCCCGE9FWq/9z1MWhVWmtL5lVNoWsJj1nSAFu3EegmNF1+N0IXW/hKkJJ24H6hXIMQQvoNEaRMKzwPG14oSnmenCGBwF76ebiT0awU9KE14WSLEatevudm1Xb9JPA0KyaT1kBRihBCCCFdzWJS/aPlCb49HQ5W9QpRR9NKg32ZkZftisx5TGTbZg2wpURD0+VmIFBXW4X6FEII6RKymTQ8UYwKZAoeUEXyto54sjnZN17Bl88r+E1Jh7du9hzSZKLCqCHCCP7yRBgKPKTVUJQihBBCqjA9PY1/+qev4Cc/eRjvec875m12sW/ffnzjG9/CE088DcexsXbt8Xjd667Eli3noZ9xvQBZNwC0zmlLLYKUv1PKE3LhwH16DyAZSFGDct0ERjaKAgVM70N2x91q5lghA/J05DFycbBioxiYhPuXVtZSPuIE0JbQrloepyb8pW12w141IaQVMG7UFqQeuOd25HKzZWG2xIYoZgKnv+rqhgtTIkgdfvoOVc7nFjQxV87TyyxJy1YIW60iGiM0b+4xLCcGNXPfszsJoDdwbLCcY05anZbv1b9QlCKEEEIq+OlPH1YXFm5xBDsPO3fuwp/92cexYcMJuOGGP8bw8BC+97078NnPfgEHDhzAdde9viXHTOpElSfkQuFJ3URYsmZFKclCUp2LZBQrg1kv3KZYCiEZUsXHqP3J1DEzlwjpdxg3aiMZUiJImaYFq+ABpUdEKdexkcln4Teha5zKinWyYQl0YXJB87qjJI2QfmGuZT8hHTjrlM1l4ThMFyX1MzU1hf3796t7QhbDHXfcg5tu+pqa5X7FK86ad1vf9/H5z/+jMhu9/vr/jmOPXY1UKolf+ZVrcc45Z+Lmm7+NXbvEpJp0HFL6IGV3KtspzHhStyrdjMJt4+qG4mOKj2sgqqzQTofZWMoXJF9o7+2VboSQzoNxoz5EkIrFE+pmxWZvZkGoaiaaGfrwyU2L3qp4J3Uqc2KEl6+48VqJdCfMlCIdzY4dO/DYY4/hwEtroVnTGB0dxdDQULsPi3TB52b79u3I5XJIJBLYvHkzNm3a1O7DIl3CunXH4+MfvwEDAwP4yU9+Nu+2TzzxFF58cTfOP/88jIyUt16Wso1HH/05vve9O/Hud7+9yUdNloXKhir8LEbichPz8ApfDjXgl+VqvVoiVwnhRYIhHlMyzx4sr6xQ/KsK5YGuMjb3EeSnQ+8q8T2JDUKHD9/Nh49zaXJOSLth3GgMdi5T9ns+58/xUoolZkvsPGf2/Oc55d33eo05MULT5k6iyMTKwLFL7r7X1YhIV2M56XwoSpGORTJcRFiQGaW4GcB2czg8sR+m7sEyC2UTvUrgwfdsuPlMuc8JmYuXRy4XL8us27p1q5qBHBsbQzqdVp+j8fFxDA+XD/4Iqcapp55c97aPPvq4uj/55I1z1p18ciiEPvbYzxt4dKShyIBeBvFSMlLo3KQEJxGpnGw4rlfZUFooSB19LhzgigilBCkZAgfA0RcK+zKAgTVKOFp0FlVZWaE8Vlfnf/UUuh6KU8XZcU30smyhzFAqCZPQ5AKFENIWGDeWj+e6eObRe+BHMkKdimo+K57ExnOvUuKU/OxIyV8hO8izZ0Wp0nlRNYfokQzTUoywAMnaDSreHCkjl8kKz4UWH1peJm83CTwyWWMmCj6R1cs/ZX2jM5tJY6EoRTqWTCajMl1ESDhjYJcanGvOUeTNs+DFx9DTBB4SWR8r4m5HGQR3Jgb+9Lt5aFoYKI38BBKTM/CNQVw+7KvMuomJCfV5oihFGk2xxGLVqlVz1q1YMQLLsnDkyFFMT6cxNDTYhiMk8yIeI2JSHvGEknI5uFno6y5Vv/u77imYnBe8puSCILEyFKPkYkcuDIbWhbPWvgvtuFdDMwfCC4h8lfLhhbo8SXmgXHAorypP7VaPDakugPK7OXAMYqkhjGx6LYzYbMvv4ND2Br85hJBmwLhRg8CHk88hlhyAUZx8jmgMkhUlIpScC+OpEax72YXwChmjwsS0X2ZALuXZRmwAbq7HbBysFLSVJ8/xMozGLi0xsrRugl0o8Mjr1NdfHsbjWnRZd8V+hKIU6VhSqZQqvZqZmVEnQN3PAaL8p1ZDt3q8hE8ubOQ1x0fCWXNSN0EwAphJ6H4evp9SYpR8juTzREijOXr0qLofGKj++RKfkKNHHRw9OlXz4uK2276P2277QdV1th0OuF3XVbd68dzaxtteMSOoTnzPhV/HYwLfL3S5KWyrBBupo2j+LHXgZOoYkBb+Rup4CllO6viKGU+lvRXWF/dXsV6pRIXzsi4ZVpoa7Kot7CkELz2CYB7jc3VuP+HS2eMpPW3huDQT2sgGdWymHmY/mVLF59rw3QwGN16CweHRckHK9+BKJlUTTIJrEfhzM7N8r3FWpY3cV6OQ74F8zj2vue+z5zb/tbtLeI7FnINIc+NGO2LHwo91VXWD3Jct9+Q746kMdjk3yndIkN+LqOWF33XDKHlMeSjfxpfzoO8hl5nCi9vvg5uf7eaXLWRKuZFMqRWnXBZmSpXO88WM2MgBFjNeVZbsIj7jZXGjBURjV2XH2OLx6A40yRAzq2RS1YE8Tj/hkoXjqRlHYE/VH3crX0eDxwbq9S5EtfejMo5V/F4tztVL9LHyc2VMqxXj8tlMmeG/YZdvJ9+PYbkebmG8WE7sqPf8w6td0rFIVot4AUkplu4cUUKDPXQKgl4XpMiykM+HfE6so09icnJS+TvI54hZUqQZ2HZYNmCKalAF0wzDrG3XTnnPZnM4fPhI1XXSJlx44IEH1Ge5XjJ27cFydp511TiS9ZGvo/W1tPeWm1bYf8z1oeX2YuCw/Na8QVPgOwikrG6+iwldhJ6NqvuSMoPV00CQAVwNyB+tmHGWQT+Avd8Lf/XSgEyKSHleXEQjH9Cc2YsA1VJavUhJ1Qz3a4hhepXPhLroSUM78mhoml62qnBckItJeTxgFMa00sU6kHZRhgMr/RwCJxFNIAhL+6b3ILtbNLPWDFA9c+5gPVtl2VKZ6sBW3TEjwOEDu/DkY1pT3+dkrPmvPbWE55BJQtIZcaMdsWMhRGzat+dFPKIqo/WymGPbOeRmpmBn0zCM8HVH9S/fk5Lp8JidGQ9+LnwPoo0M1YW66+DwC4+G69IH1PdQK+wvVqgsMFW1s6fKrL2X5Gjk1J0G7AwMhNuaZaKUp9rxGYd/Xp+4UUD3WitKlcUIv9olvGTyOtCmfj4nvrQ77pbjw2rB2KAezGKQLVAZtt2K9Ysha5THy8r4WC3GeY6Ng3ueLZv4qDwEySLcsPHkknDbinixnNhRb9ygKEU6GjGnlvKr+48cRBAboSBF6sIdXA/XHMAFF5jKHJ+CFGkWsVg42KrVArw4QxSL1e7uk0wmMDq6Yt7Z7i1btizqczyZrj3bPZlZ3Ez4zkMuprILPyad95HOBUgXSijsnKsG7TOjr2iqN56YgHuH9ha8mKq8z76UNLgwhl6ufDYkq8qfOlIoT3CAmfxcw1jZV2IsfKyUfij/DrlicwDNLX89MmMdHwwFKlsubjTAHAs7+1Ueq5RXeBkYw2eGnh+Vr2NyP6CnSt2grMJo1DJk7C9d+DIwVp4Fs+KzoDrzyWdp7SuV10orGEzMHZgOxht3gTGc7LxMqcGYj+cD4PSzz4chwmOTWJlq/mtfObj452A3286JG+2IHQshGVJyHjr3lVtgFIQ1tc+Mj2wmjaNHDitbjtntZ0Ud+TpZsUG4tg1rYFh15FNEJkRcJw8/l8Hoieeo3w8d2A8jkYJphQKMUzBFl7dVZVTZM0iNn6V8pZyjR5QPX1EIcyWrN4JmJBEfOweaWX9WfTZy/K2gWowoW6+ac1SPL+2MuypGRjOqAg8Dbh4zqVNKXWyrZlS1gGSFUGTG5v99UfuOa2XxsjI+Votx2ZkpHHhpD6xErPQdSkSO0XUcuK6DTS87F4NDwy2LF8uJHfXGDYpSpOMRUcqLB2ENMyF1EpiDWL16GMlkst2HQnqYkZER7N69FzMz5R2DimQyYWlBZYelKNdcc5W61QrmN974GTVzXpw9rwfDrH1hYRiLu+iQ8aRex2M03YcmKT16sXZCsopCs24pSWsaSiCStKJ41dnhwBOvJ690HFpsGPr6K0LPJzsN/8W7ASsZejmVkNn3MKtKjMv1dZeopf7OHwDZQ+VPIPs++mKhI58TmpJL6bVWJWYpM3Kt+ntSfB1RgaxoXq5FHisD+CrCk8oYkJnpFolSWqG0MIpuNG5w3Mh9NQr5HkgGiAhSzRSlDEn1aDLmEp5jMecg0ty40Y7YUQ+6fD9Ms0yUkpgzOLQCF1z6elXGV+RoxWTHxJE0nn74zvBcVjgHahFfVbVM06AX/YykI2lk21LDueL5stCx1EwMY/S0K5V4X8wEK/pOlfa9FM+hVnu+VosR9caXNsXdwM0j2P/TcBJodq3K+PIOH1D7UCXt6y9vj+dTZRyr+L1anKuX6GPl58qYVi3G6YahmpZIFlRRmI1FRClNy6ksKsk2LMagVsSL5cSOes8/jC6EEELIMtqAb9/+JA4enJizToxqHcdRxrV9ZVbbBZQNfsXE3IjVLncQoUe66RV+VilTUo5QafTq62Epg+pHHjSk61EgbfZk10GHdj0ihCyafo0byVT563EqJjtihUynZiCG5+peJkuUeNbFTYS6qTOelJYXu8oWJ35UfMyrjC/JVg6zlnukQyJZMhSlCCGEkCVy9tln4HvfuwPPPvvcnHXPPLOjtE0/k3MaPKPszJQbpDpp6K4Mxs2Ch61WnvUky6RTtpRaVF6IuEGY2CW3ahOi0cfKhYwfQBPRSbatvH5SApKYmXihRVW166uKY0lEPSWqdD0K9MissxLTEmpGnxDSvTBuzI/nOpFSxsjygudUJ5Krw3dx2Xg6dD0BSIyoZR5tJuCKgXazj6fe2OkVtpOYrBUnfsTU3oSvxUpda6vG5yZQFnOrHbY9E/qRFXArjM4l/hYFTtJYKEoRQgghS2Tz5tPUrPejj/5cdUqKllv88Ic/UmnYv/ALl7f1GHsKZwb67rvCQXkR34GW3jvbjUg3EQxvqCjHqyFqOWJi7lTMMOth9lQlsm8jEc7yymPE8LwSmQ1e4oxvtbbW8cIAOlm4lwGxzgExIV1Nr8eNTCaNIKJUpCt8DKX0qDJrStB1E7F4EnY+C09NNABOhfZixZOqRLmVnUY7BmsA/trL5u9aJ3GqHWVwPUDgzCC9804Ezuz4IlcxByQdHUdPvYLCVBOgKEUIIYQswz/jve99J/78zz+Oz3zmH/Dud/+m8sH7z/+8U11wvOlN1+GEE9ai32nULLJmu4jZWVU+FxQ7+gQGDOWhUfjdc1UL8lLPb0+ymwLYToDAm0Fs713Q3EIbcRGXMnsQiP9G0bxcN+ENbQhL9KKPjaWgjb8GMSeHwJj1oCrr3uPMQJvaWRC6QqPhxZRXVHpq6AUxymhxdx1CSPPo5bjh2DbuufN7yOVmz3/5CkPwRCKJLZe8Tvp4lS2PJwdw+quuDrvsFUhXlPSJIBVLDCCfOTone8pzwm1VBXVB1Oq9eJiqnpkUpQVZW5oTIOZLTJXnqvJ8hdjpOAGsOdsFkisFVyZ4ojG2iR5dC2VIqaMSDywnB028mgrxXY/Ed/lMiVl+NJOKNA6KUoQQQkgE8fl4//v/uGzZF77wz+q2atUYPv3pvy5bd+KJJ+DP//x/4hvf+BY+8pGPqXbfa9euwe/+7rtwwQWvbvHR9wdKkIp6QEW74SnD8dkLEk0EotLPbihIFUUt8eZQgpQY6Iald0pMkkwsMbWOPFZhJkOxSgasxeePilKyveo05ABOpmZ5RTO7ERJCWg/jRogf+Mhmc6pzoFXoHqgXzMUFx7GRy2VDw/Mqp0ERpqI4xcYZFYg4JVlTTj4LXxpMKM1/VpRSz2tJVhXPtc1EYmQ1KWlO7OwmjBh0Mz5HlFJTXbbT8hJWI1JC6HZwCetyoShFCCGERBgfX4WvfOXGRT3muOPW4P3v/+2mHROZBxGTVNmcq0QlLXCheVmZ1ixtEphJBGJYXvJqKoha8li5V4+V6XV/zuOLj60LEbtSa+CvvRiwapgUs7yCkJ6DcaMcEaTi8bB7mF+RASMt7ZeLZEttPPeqsjK+l46GalSxwx79f5qHxESJjTLJU0uACmMnRcHFoFcpYS2b+JLPfjypSmB7DYpShBBCCGkdbqYkDlVDCUBmeVnHvOhWWG4nopJnK0HJWXMJgogoVNqnPVX7sUKVx1c7nvLZ4ciAUTK0ZHt5bGz+du6EEEKWJ0xFseywrMrs5s56XRSj7eMuW3C74vrymCmm5p64is/7+H4kXqWEdThR6HhSQDfMqp5s3Q5FKUIIIYS0BjdT7ulUY3ZVBruLFaZmd+AqQSmoVxSKPnaBx1edHa7ozsPyPEIIIf0QoxeS/wI3UyWjKgBMB5orJe7a4rKR+4B4RQlrKlkuSvUq/ASQjmJqagqZTAapVArDw5xlJo2BnytCOoM5nk5z1juFwau74GC3XbPFzvh50MQQVYQnM1nqkFdXeV60858yVq14rG7MMTsnhBBCWpH91PAYXSWjSgs8eJnH4aTOUHE0KGZMVWYyVxwb6W0oSpGOYceOHdi+fTtyuRwSiQQ2b96MTZs2tfuwSJfDzxUhXWBUXlxep0Fq081V3SxiEw/VN1tcr2eJMwN9912hiXoBr2ICVDMT0NdfTmGKEEJI67OfGhSjy6jMqJKJmXxcZSMHXh6x/fc2Pnt6OXi2MjUX/KC8+x5pHhSlSMdksohw4Ps+RkZGkE6nsXXrVtUi17IsuPkZcUZE3xB4iLk2HHndLANZGl4eBw/m1ecoCAKMjY2pz5V8zsbHx5kxRUhPm6vOP7yRsoEg0qGvtDxwlOm55qTrni2u/+C9UJDSZ9tNIypKSSdAWc9204SQLsexZ8+vdkX3PdJaFpP91M/Z02KMr1kJBE5O2t+pZX7FJdhiOjrKtWtQiOe2ryFfkRmdR2xOqV4/Q1GKdARSWiWZLCJI/eiZHKDFoNlH8EjmEILEGEYG5ERVvS1sT+L7MMwAZtwH9IryDlInFv7hh9MwJ2YQmEN47bCvRM6JiQn1eaMoRUhrybsBNC+AERRadlc7tckpLwDyXoDArTYETcJefWlZZ70oxdnWwHEA5+jc9Z4NHQas9AvQI2V0UaScQD/4M3iBD19PAdrsbLGpL2O2uIgIUoUZaGn+V3pe+Y+mr4SQLkbXdCSTCeRyeThyHi6c+6MkEmH3sAbltfYMle9ToyjFXVhl8SyKHjgq7grFGK0maSqvvSSGeg7s3DQC30CwhOwlLQjg+oXXu4hjqz4mmJ+4Wf81lGQoD550RUlIElKx8sfX29HRs2dw4Nk74NnhmMQ0NFgVXfQGBpLK1JzCVAhFKdIRiNePlFZJJosSpPy88urQEyNALKkuRPoKmTmwEtCSI+GsOlka0jLVTAJ+Dr6fVGKUfM7k80YI6U5qDYIl+ylx6CFoXq4g7swdwAZGHPbwadDdNAIjgUCrMjMbeNB8u/2eVoQQ0mVYsRguufxqBJFZhyOZcmFDBCnpHparWE46B8lMMrN7oFVOAKn46CL50g8RWEPIHnvZkoSpeZEJn2JHXN9Wv0v28uzBScZ0c8bxeoXgZFaIUvUiwpYIUrphQTNisExN3Yp4jg07ny3rstfv8GqXdASStSJeP1JqJRlSIiQEo6cCsaF2HxrpZmJD6nOkHXoCk5OTGBgYUJ8zZkkR0npkVlR3gYQfwNcCBNpc2UfzZco0gO1KU7vFyUK64yLhZOFDg5U7qMSlMgJZ4wN2Grp9CPmBjQiMuTOUmpeHEdiq7Nf3Z4/TYNYqIYQsSCo1CMOcvcR0DYpP7cygWkzcFWTbQPeVGOQrC5FonbkGTZPMJgNwsrAdF/4ip3AkU8rzgzB7uvLYfAfxmednxTCJ24GLxP4fItDCz5RvJDG9+tK6hKnFZEo1AxGkDCsOw9RgVh6Ly1zBKBSlSMcg5tNSXiUle2GGFAUp0gCGT4RnDuKCLTpGR0cpSBHSAaiygCrVc2G5wCL3JV2FAk9lP6kZVc1Qg1jV1adYHyfLJCU/cNTAVmVDIWA2FCGEEFKBKk9XEzs6gogmpakMOF1lGc/JoqoRm2tlI8v6uev8svit4jYCJUSFz+lA97JqH4zfvQVFKdJRiCiFpAZYiXYfCuklrEGsXj2IZLLPykAJ6TBkoCmDSzWorOEo4oto5GXL5mYr91GcIZVB7dCBuwuDVBdWbq8qGzG8TFg+oukIoMOLrSg0jRDTKg59CCGEkFox2nCnC4KSBk2ZQEa3MVV8nS8HKRqbqzwL4tYMhqaOIL3yVTWOQ1dleuGT+Aj0mLrJZFatsUM1IUwrZjgXuugFMNndtkPhyIwQQgghTSGQ2VZ7CpqrQ3fCec2ZleeVBo22r4djzsLvupfD4JGHMbj/ztl9SK1AIW1f8PUEjoxfCt9IwZCurG4WrnhDaSYMhLOreqAVsqQ0NfMqpXjy7GKiLmUDQeG+ONY29DoyumRQW5iaXbLJuRDp+ifHUW05IYQQMh92nWV9hhdIdR58zymPOWVZUYDjBfDMJJyxS2A4R7Fi4ofwJENJxKAyJGCG5X3qMVVKAqOxubKrnmQp+8iF61237NiUn6MEZom9modAvKWk6YibR6AHYYaV58C1M3C1wfKj8jJYcfBu6H5ONUMRX/FicxK9cO9ZCejHXwgtPkRxqsOgKEUIIYSQhhNIav7R56Af3IuYDwwXOvtE8QIRkTTohTIAGRwXs52KpXcyK5tLrEOgm9ClPM/LwXFdSPK+DLZlt57KftKU/4VkRslj1ePVU8qAPJzXFQ1Ktg8K97VmetXzG/GwHXVhVlaELi0yYRyI9+Fisq4kU8tMAG7RiL3CqkP5tyaAOttNE0IIIXVlP+mJUKzxamQo69L4I4w9MuGjyuN0EZRicLVKUUpidV4FUruWKBWJzUHF4yUS+5qu1svElKMVjk3EMXWzYfj5UnyWMUI8s7MQ0z3VOXfk0I9w+JhfUMda2q+s83MqfsfyE9DhQpdJLVknd8o8PVACl4hS+vrLVSUF6QwoShFCCCGk4Uj3GenSI+VyMrCtNENV3hBO6CnhGSk1ANY0G6YMoFXmk1HwfvJLg2MZUhpeY7rVSJtpyMBaHUv5cclzp1e9BoExW/IbM4F4pKWzEqQW0wHIGoC/9rJSVphaVGl8qhucvSWEENIwRLiR7OJq/k7lZXut70wtpYKHxi4pHZvhprHq0J2w7ImwTLAglIXl94IIUz50Ea1qvB55jPKMlAyv4iSPSu4KfSVlWaAmh2q/H40i8GyVbO0FGtxCCWGx+15kOEEoShFCCCGkqRgySxpXJXRlKG+IkFB0iqufpauPynaCDCxD41PpgieClDQEks49rhfAlW49qiyhWIYXluWpHasZUTU1qvaozFNLTyxZVGJ87qp0f7VEmztQ9s3Bsu4+gamp27KoEJw0i6NSQgghzWWpgpPKFq6SCSVZy4vFK2Qaq8isS8O/Qiw3k6XBgKkF8CCl+BKnY7OiVDHbSeJ8sYHJguizopSyAZAf/HBMUsxWbhKabsCIJeHZWZWd5nga4JbH++RAEjo9LkvwnSCEEEJIx6Ayo5SIJOKSF6bkB3boUe5lYPg5GF5abSv3Mjj2YStT89BDKuzWU+wMJPtTpQaqpM9UY9N8/FhMjr4WRjzs8mpVTFlGzdQJIYSQfi35M/yFS/6aMw4Iu+QWjkhNSKn4LuMD3wk77kaOVxqkhCJa6EOlspL9QmyX4YGarGoNRmwAq192pcoYFwbiGgYT5eOM4VQM8SQzo4tQlCKEEEJIRyBCkummw2Go8o8QcSpAKrtTzXSazrQarK6elJK/hBqAJvL7lJeUSu/XdGRi65C096l9KUEq8OBYq0Kz1YK/hGcMwrVGADMcEBrLzYAihBBCerDkT3yjWlXyJ/v09IQSoHQ4hYxpX40LigKValqSf0kZsRdN1GU7Kc2LRTrwynhAK2YnFUN8C8vjzfjsc8USGuKJ8gyveLLejK/+gKIUIYQQQjoDJUKJ+1SY9VQswVO/q/FoaFTqanH4egoa7MJMrZT7SWceR6X2ZxLr1L5MzVVlepMrL4JnDrbdP4MQQkjr8OyZUrZK+HsobPiFbrBSZkUfv+oUY2Q1I/N6CTOZiz+H90pcUhnN5V351HMZKRwa2aIytDw97PwnHfdSwU5oKttZxCcp8vdLnQEl7osIVYz/ahvJkJKJrcJElEJlTy/9tZDmQlGKEEIIIR2Bym4KHDU3GihTUNUHD6Y7pdbLzKkSqjQNvh6HBj28D1zVkUdmdU0/C7/UglqDZw6prCiKUIQQ0l+C1OGn74DvZEvL3II+5foFUcpMIr7xcgpTzSz/KzQnkewnda/iul+z/E88HUvNTfR42KRWSuplmRKlXHWT9UUvSuUmrihkHxU6786KUhSjOh2KUqRjmJqawuTkJGzbRMJKtPtwSB997jKZDFKpFIaHh9t9OIT0Hp6t7rSKEgDV5a74c9Gzwg+3DcWoyLazvaHVnWr1XOicl42tCbeX2dIgi8nhV8A1htXA1jQ0ZkURQkgfIhlSIkhp0tnVjJXFIU1ZE9kI3GzYKbbNx9prSMyNdtUTxNRckGVJfzsODpypMqOqoSaavBmVJaXGB2qMICKTrhqXVBOZAi2M90VfSZVZXWqwItlZql1KYV/8i3caFKVIR7Bjxw5s374d6XQaO3ediNXHrMXoytF2Hxbpk89dLpdDIpHA5s2bsWnTpnYfFiE9gZRFQDrLuGEJnV7Fl0K8I2QgqYtA5TlqMFnsvDfbYUeHY4pgHCDmHFYDzYR9AAEmyp+vkCm1cuphuOYQDo5eAq/gGUUIIaQ/EUFKN8OMGr1QiqYmOiThxlt8FzlSH5WTQdIxV5A47bvx2oKUbyNuT0AvTFJJVpXyiFKm5eG4IOyg66kufrMPNJFPrlN/3HjmxXDyqjCjpRqnSJvexMqwIYqZmO3MRzoCilKkIzJVRBjwfV9lqgRuHvv37YJl+IjFwpmNvsP3YDo23GyaJ80GIJ+pXK78dDc9PY2tW7eqNvVjY2NKEJXP4fj4ODOmCGkAmpmCNrIRfnIzbFfHdH6uKGX74YiyOJtq5l6Cmd0PT1LySwamUq4ns59ueCURhB32fM0sdNwLETFLhp+yXEoGojO0hBBCCOl8pCzPjo3Dl/J8zVKTVsncbgQyyVXIhFIuklWuj8KyvzhygyfB0ALECptoUvrvZmCsvwxabFBdW7Fks7OgKEXajpROSabKyMgIfvJcDptHjwC5ozDNQejxMfQjge/DMwOk4j40nSmmyyZu4R9+5ELTZkqL/Mwk3L0ZBLEhbBn2MTQ0hImJCfV5pChFSGOQsgnEhhHoupp4qMR3y4Uq3UwXzEklU2qBIYoyNJ3dRs2Eik+FDGJlCpwQQgghXYd01PX0lPKUCvx82GWv4CkVKA/J+WN8oIk4Ja11i9dQmgw4lCClxTnG70R6RpTKZLK45Zbv4KGHHlGZN2NjK3HhhVtw7bVXwzQX9zKff34nvvvd/8RTTz2D6ek0BgcHcPzxa/DKV56Dq666rGmvoV8RLx8pnZJMFU0M7SSVNjEEa3A19PgQ+pHAdwErASs1Ak1mBkjD0RIj8Kwk4OXg+wklRsnnUD6PhJB2E5bilVHykSh4Q6hOfdFtmBlFCCGE9CKlMUEx/hfL+4qelJU/B1FDSpZpdjp1X+0+9dRTuPTSS/Hyl78cN9xwAy644II52zz77LO49dZb8V//9V8q8+W4447DySefjEsuuUTdN1OQuuGGv8HMzAyuv/492LBhPbZu3YbPf/4f8cwzO/CBD1wPXY8Wndbmnnvuw003/Rve+MZfxG/8xluQSiXxzDPP4e///kv4/vfvpijVBCQrRbx8pJQKuSOAlYS56tS+FaRIa5DPl3zOnANPKIP9gYEB9TlklhQh7UPNgqr0fH/uIFIt01SJnqwPjdLLs69U5pRkWrHRDiGEENL9FLKiNUh3XhGkwkkrw8uqrCnBr/CnFKTQJBwxFH6hj1RviFI33ngjXnrpJSX8nHPOOXPW//mf/zn+4i/+Aq5bPZ1ORKnf+73fw7ve9S6VjdBIbr75m9i9ew8++MHfx6mnhuLXeeediwMHJvDVr96MO+/8Ia688tK6MqS++MV/UWLU1VdfXlq+efNp+PVffzPuu++Bhh43mUXMpaV86ukfTsJIjFCQIi3BXHEiYA3ignM1jI6OUpAipI3oXkYNNG1rTJmcSxleFPGWygcODEnl1ww4xpDynihDCVIyaC128SOEENLPBK5dmr7wCw03gkL3vW5Cc8MYWcSoaB7Sq51mZSyQSZ44a1Lv24j5WRxZdTF8c7D02tW6yPtjGRqG4qEoFbcK3pT0kep+Ueq+++6Dpmm46KKLkEwmy9Z97nOfw5/+6Z/O+/hnnnkG73vf+/B3f/d3+NKXvoTXvva1aATZbA53330/VqwYwVlnvbxs3UUXXYCvfe3fcfvtd9QlSt1887eUYHbFFRfPWbdly6vUjTQPEaX0lA7daqxoSch8SH356tUDc85rhJDWClIrDt4N3U3DdA5VNSmXQWc+fqzqxGcEjhKkxG9izr6C/LzPUzaoD8IBq164V5laZu8N6gkhpB87wOpWEr6TRWCH2TOzFWAFgcNMhp1iu0CQGjpwN3QvW1pWeAmzv+sJHBm/tCuEKcloMt3pkpgUxfDS0AOvrCBfhKnZviYBArhKkPLM2kkMhqkhiBUeJKIU6Q1R6rnnnlP3p5122pwOVn/yJ3+ift64cSN+67d+C6effroSsPbs2YNHH30Ud9xxB3bu3Fkq8bvyyitx00034S1vecuyX8D27U/BcRycdNIG9ZxRhoYGceyxx2Dfvv3qtmbNsTX3I6/j8cefUFlRi/WgIoQQQsjSZ3pFjDLcafhaDDOJEwveUZHHBY4yNp1YcSECGFh19P5w2Vzv9EJZX3VBauzQPaozX+n5I5n9gm8kMb36UgpThBDS5RixAYyeegUCfzbmZOwwtmSdgijVJV3YVMc5KVdTZt9hFnE0UUq8lJbTdbZywiaKxOlGZmEZXgap3AtYndsbdtetQF5L3D4AP1F+PV7cUo/4RpHeoW71RczDBSlxifL1r39dCTq/+Iu/qH6Ox+fOWgoiTH34wx/GT37yE9i2jbe//e1Yv349zj///GW9gF27dqv7VatWVV0/Pj6mBKldu/bMK0o999xO1RlIWsM/9tjj+Pa3b8POnS8qoWv9+nV43euuVCWBC3Hbbd/Hbbf9oOo62w5nb6XEsXiT56xV8thvyPsggUOZfPc58h4Egc/3ogXIZ674fewWlnvu6KbXSnqH+WZ6ZRAay+1VmU+5xKaw004E3c9D8zPwjMFwcKwnQnGphgAV+ksYZcNdNaj3c8qbwi/uvziZJZn9InJ5WbUdLakIIaQ3hKmy3/XCREjhvttQXeWM+KzNYpSCl9KSM5UjEzZluw3CmHpo7JKGCFMSY7XAha8NqImoOceDcIygq/LK2b9TMaNZ8I0wxpM+FKUMw4DnebAsa47YND4+jq985Ss1BSnhiiuuULePfvSj+LM/+zOV3STClBio12tCXo2jR0OxbGCg+pek2EmruF0tXnrpoLrftu0J/Oxnj+Bd73o7Nm8+XQluN930NXzqU3+PX/u1N+P1r79qwXLCw4ePVF3nOGHt8gMPPKBMleWi8sUXX1TLlvMe9ArymXD3OfANZqqJIOVP7VE2v9psvippAr7n4sEHrTnntk5muecO8QYkpJn49gx8Ow/NywP2FDRXh+FMq2yoUBSKSd1EaaZX0yQ+auFgFf68opBnpHBw9JJ5Z4RlsCrbVft2iCAVFMr+xBhV3cuGnhwBZ2AJIYT0D8UJGymRq5wQEgLPXlYW1nwCW7USfCEfG8Pk8CvgGbOiollMaZafrVhXlCmS+qn76n9kZAQHDx7EkSPlgsuPf/xjXHfddUpkqQcRpUR8+Ku/+ivs2LED//Zv/4Zf+7Vfw1KRrKuiaFYN0zTKtqtFNhuqshMTh/Df//t/K2VFSfe93/u99+D66/8IX//6rXjVq16hsq9qkUwmMDq6Yt5MqS1btihD5WK2gnQyZMlg+Dd4OJeBYdUWN/sFyZCSSyPruFdC0/nZaCaek8f556e6ylNqueeOYuYrIc0SpNLP3gEnn0ESaegT+xHzAc2xYUm6vvg26QnkB04slSEIYm5eLyI4EUIIIaQxqNLAKiKRHwQwvNZl2Ifle4ewcurh2axmVWY/K0ppRvf4Z5H6qPtqRvyiRJR68skny8zLd+/ejXPPXbisLcoNN9ygMqt27dqFb33rW8sSpWKxMO1Psriq4bpe2XYLIeV655//yrJlIkyde+6Z+PGPf6qyqKSUrxbXXHOVutW6ELzxxs+oi8jihaRkOUR/72fkPVC13RRhFJIhJe8F34/mouluV34Hl3Pu6LbXSroLVYbt5AA1mLQAK1XodGSoLCkRn6RUTmORHCGEEELKCFRWli/Z1Pqs6KQymgueUkYTMrdIe6l7WlJm5IMgwJ133ol9+/apZf/wD/+gRJxTTjll0RdEkl0l+/vpT3+K5TAyErZwn5nJVF2fyWTKtqtFsfxPzNGrCVirVoXZUfv3H1jW8RJCCCH9gFYo0YPcG3HVLS9sn8OSZEIIIYTUxi+U9xVvQeEWzZ4ivUPdI8Nf//VfL3mRiED1zne+E5/+9KfVsuL9Yjj22NB0XLKvlsO6dWsL+5mouv7gwUOF7Y6fdz/HH7+mLLOKEEIIIa3Gh+aLf0W+7Farox4hhBDSL6gsYy/0a9T86I0xkvSJKHXOOefgHe94h8puEoPdm266SZntyu/btm3Dhz70oUU98QsvvNCQMpLNm0+DZZnYseN5dSxRpqfT2L//JRxzzPi8nfeETZs2IpFIqMyqallX4jUlHHfc/PshqFm6uH//fnrZkK6Bn1lCFo+bn4Gfn0bgOQikc07giskUoAbQdpV2QQU0XZX2aYEPw8/C8DNlNz1wSh31louk/pcP5gsDfApfhBBCOhDVddZIKvFJuuXJzYjcGhkjW4XqeFsxAdXqSajAkTHLVOnm5SpuNhsDtYpFKUJf+MIXMDg4iM9//vMlo13JmBKPqNNPP115TH3qU5/CunXr5t3P3r17cfPNN6vSv7Vrw0ynpSLG4hdffCHuuOMebN26DWeffUZp3b33/lgJVVdffUVpWSaTxec+d6Mq03vPe95R6lwVi1m49NILcfvtd+BHP3oQV111WVlHvUcffVyV9b361eV+U2RhxNB++/btyOVySvjbvHkzNm3a1O7DIqQm/MwSsnic3AwOPPEDpKeOwp3aA1/mvRIGtOxBGIGYl3pqIO2rbjoBNHcGWqQtt51Yo1pAT4y8Fp4xWLOj3rIG9XpCdREqmrYaBd/UYlMfGfR306CeEEJI7xOYKUyvvrTMR8kptq8tE66WHiNrZVvJRE4jUc1ONFMJaZpMXFUeR+CGcbgR3cfdDDTflScNn9ufNUsPnAxy+38MyPoCXqTDn2Ankhg99QoYsfoaupEWiVKS1fR3f/d3SoTaunUrjjnmGCVGCV/+8pfx5je/Gbfddht++Zd/GW984xvx2te+FqtXry7bx+233473ve99qoufiFJXXVXdFHwxvOUtv4wnn3waX/zil3H99e/Bhg3rlUB1663fwRlnvAyXX35xadvHH38Cjz32uPpZhKeNG08srXvjG6/DE088jZtv/jbGxlbizDM34/DhI7jppq8hn8+rrnwrVows+3j7CckykYt7yaqTDo7pdFp9doaGhtQtiggAdjYN3eFstRgF+04efiatzN9J8/DdPHK52fd4enpafUZF0B4bG1OfWfkMj4+Pq66ZhJDa5y3PzkIzxO9BB5wMIN1UHTEkBfQggB7YKhtKRKn4zAtA/Fhpo1Pah28kEMBoiAhViQzWD41dUjaojxVUKatwrwbLJrv5EEJIt2DnZsKu1dkwE9e1y8UaGUf3gqggsSn6yjwJrI3Yb2TCBt7cazDRvhqZhSVxPZM4EQeSp1fdp+GlMX7kfiVcLQfNzSB24B5obhZ6QWzyojqXZHRn9sMYWQfNCj8fZYfj2fCdrBrbkOazpL/26OgoLrnkkrJlv/RLv4RvfOMbynvq61//uroVtz3uuONKJXviSVVEWrCLQLVcUqkUPvrRD+GWW76Dz372RkxNTStR6Q1vuBrXXns1DGP2E3bKKZuwevU4BgcHsHZteFyzx5PAhz/8R/j2t7+Lf/3Xb+DQoUm17JRTTsKHP/xBdU8Wh5RDitgkgtTWXTagJeBlD2P3A4dhDZZ//EQEGB0Uk3l2ZAr8AFkTSCaCskwC0gxi+NrDPjQtq35z0ocxszcDPT6Mc4d9JZ5OTEyozzJFKUIWRhMTUpWFLOlRWjjKk/Gg78MPxLg0CQ0egiD0j1Jm6MXHBh5WHb1f/SyD4IOjlzRcmIriFcQowyyfHSWEENIdgtRzj3wfTj6LrF0QpSqqxHWL2S4LxcUj4+VZWFFsL1h2Ftac59QsuOZQTaHL14xCed/sMm2RmVvyekSQUp2ArUITs6goFaQRyGvWLWhmPFwdORz11IWs6sUiZX+OP3vwtq8hH8nSUp3Vk+XJGf1OQ/uCS4bUz372M1XSV+yqNzk5icOHD6ufo55PUgon2VUnnjibqbRcYeptb3urus3H6OgKfPKTH6u5XkSot771jepGGvN3kfInyTYRQQpuDoaVgpVcAcNKzH1ALNmOw+w4ZMbHthKIpUbCExdpHeqzmYLv5uD7cSVGyWdYPsuEkIWRLGh13irF/CCcawgCaJBWzuGvugwGncNls6EyQM3H1qrRp8zasuUzIYSQWqgMqXwWumHBiIWxJKIFIHCZ7VIP8wlOjcrIWlLmVsRfSi+U4JWyquvM3ApElDJC0SlaERgYNpqBCFKHn74DR71wslswDa2UkS1Y8SSGLrga8SSF0iINv9p92ctehgcffBA/+MEP8JWvfAX33nuvMkaX8i1BymGkZO9//a//VSr9I72LZJaIH4+UQ0mGlFzsJ1afBiNBdZh0JvLZlM9odv92JaoPDAyozzCzpAipE8OCteIE+DLDaJhAIqV8HDw3D9Px4Fpy/tdgOlOqtXOghzOYUtYnIpQaQAo0HieEEFIHhhWDUYgdXkR/UsXiNmNJNyHZ0ZIlXTkpJcJOEcs0G5q51XgLlixMy4JmhOMby9TUTfAcWwmpfsTLijRBlCpy5ZVXqpvgOA4OHTqEeDyuyvlIfyEG0VICpUr2JAuFghTpcBJjJ0KPD+KCzYE6Z1GQImRxKF8pmZJU5XtmmDJfMC4V0UmTVKhSaV84FAngMjOKEEII6XOqle1rEVHKiPzcqYggZYivZsEiwIzYBPhVvLv6nZbUBVmWhWOPPbYVT0U6FBGlxEOqaskeIR2IER/E6tVJ5X1HCKnHZHZaDbQCFFLixdA80AElNFWk2at1UtbnSX1FYZn8XPCZKrlHhEjL6/kEq0abohNCCOlfAkfiWu2YEzYhSjWmM1xxnxXd9GTCpl8bb1SL+UakfE9H52ZKkaVBsxpCCCEdx1/8xV/g+eefx5e+9KV2Hwqp02RWutRmD++G5+sI5F8+DciAOmcD1orZAWbgw3CmlYmp6U7NClaFrnypYKcajOdjY6XB6fjhe0J/iRo0wxSdENJ9MHaQRghS+efuRCAm2TXQzCSCdZeVurYtGukMt/eu0Ii7gFGhSQVGAtljLxOzU/QTtWK+LtnVBTQjoczZGyJMyWSam1c/+mXtDZvjOUWqQ1GKEEJIx/Hd735XNczghUX3mMxacQu6mYDnutB8v9BHVXpJu4AnhqUiVQGa70EL+9ogkLq+iPOoLJdlumRPFYzSRcySwal06wm0gt9UhLBDD03RCSGMHWT5SIaUEqQMC1rB87B8vR2uX4Z5umRIFTvDFX0Uowbtmu9AU3HTrUwc7nlqxXxJvC523zMWEfPlvYQXvomRnmuAvMeagUDWOzPh+sJ2RfREspAVR5oNRSlCCCGELNtkVovFMHTMyZiRttyeg9zki4AhZueAn1gFxwsQy78UClJKoJLBX63Rtl+lRM+Cr4f+DFFUy2iaohNCSN8i5tGe51ftvrdURJDSzLkxBzJn0iBPoGhnuGg4VBM4fe47VBnzi/NX6s9bh0m4lPUHZjIU/5zC9pHue/KGGys2IHbCa6BZYcZV0iofkwwkTBgxdshrBRSlCCGENA3pvroUpBSMdB+6GYMu+e9mHObKTYB7AIFmwjnmUqTtAEMHf4hApiqze6F7MtMpAlVUgAqgBS40BGowKoNKZkAR0n8wdpB60HQTVjypMnY9u1CCVTGnoVvMdulHxI/LPu4ylZUWL4hNxQ54RRJxs6wE04hV+FlW/L6o5/dsFEcvXqDBLXhiiYBK5kJRihBCSNM48cQToUV8AOpFhIulPI50IoW0ec1QQpPuplW2lG8klGAVRbbJWsfACBwcGrlAeUSZ7nSbjpsQ0i4YO0g9xBID2HjuVaqU/KWjoRqVscvNmUSQYrZLd6Emp3y7LLGp+K1WzVDqyJRSmKnQSqAgSmkVmVCVvzcC+byJEOp7WZU1LjhSFujOPpcIqbpOGSYK3w1CCCFNZ/Xq1YvafnJyEq5b56CDdBxqhvDI84DpQJtxYPn3YCgwC534CugWcsn1JT+NwkL4ngfNz8A3+svclRAyF8YOUo8wJVh2GF9MvcIxnHQVupdFIv9SaaKqSFFrluxprbCdZw6h0xABdPTUK5A0Z1P2BuIaBhMRo3bdRDxJoTQKRSlCCCFNY/369aoM45FHHsGaNWvqftyWLVuUWS1pPdlMGp43Kx5lZ1zkc37ZYKp4ETBftoLMXKtRpG4gMJLwA6tkTB7kD6pSPRGkAj2uloVlfH44OypGpl5abS/3MmtKCOkfGDtIzyAm2pEJGc0JoDlpZbStOryJWVLZ5Ex/o8FTwlNodD4rVRSq36AHAXQ1Zujc0n4Rpqz4rAgVS2iIJ8oMrZDPzsCfJ+NL7zPhqmmi1De+8Q11f+qpp+Kss85q1tOQLmBqakrNXGVzFgatRLsPh5BlfZYzmQxSqRSGh4fbfThdwXnnnacuLB5++GG84Q1vaPfh9CzpdLmQNDVTbqphGgZSA4N1CVIP3HM7crnZNtXpvF/yCC2mnUu5RFSYEo8EXwvguQF8NwjNZZVflHTXM2SEhiAodDHytXAQHoQClAhO8cyLJeHJl+VBgFWH71WilQhUcfsAMonqg3YlaBFCegrGDtJupMuemJpXXV4vzgz03XcBbq60KCa+izLxktkTdqA1YvAGTii7LFcd4zoI3cvM6++oyvON0Cy8UYQiVCS7CL2DnZvBcz//Puz87Firklg8idNfdTWQ7LxssK4Spd761reqmu73ve99+MQnPtGspyEdzo4dO7B9+3Z1wfTsweNx/Nr1GB9fXCo2IZ30Wc7lckgkEti8eTM2bdrU7sPqiguLf//3f8dDDz20qAsLZYZN6kLOr9IGXQTTIvmKgXQymcRlV16zoDAlwpYIUqZpwbJCEcnW/NLAXMQnMZRVWVCFrCndMOHkZ+B6AVwvtHqQzkRSwgfEAJnpVCJUuA/puidddfQgB0M8F1QHvTwC1VonvPm6CU9PFUr7itvYygC9Gr4u/lQ0siWkV2DsIO1CPIE0M4nAzdbssqfW12OeLkKOCFLiH2SEMTXwQlEqMBLQJE5K0w93BrpWPvEi61X87ABBauzQPdD9WWGtWgw+NHZJQ4SpAEahyYlMrjlVRCk/7KynGfOKZbqoWqalfKU6DRlDiSBlmDEYcowVeK6j1s+XSdVrtP+TTno6q0Qu4n3fV1kl3t4cXtz5HEwD6qKe1CbwPThOHtnMNDuGtAnfySGXC0Pg9PQ0tm7dqga7Y2NjSgSQz/b4+DgzphbgiiuuwHXXXYfBwYWzdKJ85CMfwcGDUuJFFkKEJBGkYrGYugmGM3th5tg2stks3Egm1UKIIBWLh+dpy/dVFlQRv8ogvWAhKmlLKP6riW7BTq2D4WVwZOVFatGKiR/CM2SQH4PjyaP1Mq+pfPxYTKy4EJ5R/XMkg1MxRSeE9AaMHaRdSDe2+MbL1Vi85ja6gRwWEXNEkDLihV8C9bM3fJISrDQvC2fNJcjpFaVamqk6yMFtr9Aqoo8IUlJK51cpM5RsZlnfqE654icpMd/V4mpMUHoevTDS8G1YQSiQrTh4d02xTDY342EHPkQ67HUSIkhZserXxJ5knPcRFKVI05CLJMkqGRkZwfY9eZwymoWb2Y8V+jhiseKJmVQj8AMERoDhWACNho3tIRbHf2yTLj455KeP4PD+LIzEEIaHfQwNDWFiYkJ9xilKzc8555yDb37zm4t+3DXXXNOU4+llRJAqCv5+xXnDcZymzfb5ngszPqBmeTU3gGOG5XtuZjLMfFJlfP7cwbYMcM3wgjP0loopfym/SqaDr0SnQbgdaGpKCGk8jB2k3cLUguVikcmfJSECjyHx0UVgDSLQOzu+iSAlMXrOcuX92NiMHon5MiaQjr1FVDK1QjLN3JJYprynqohlGhxobhZaH2UbdTMUpUjTEN8duUCSrBLdSMB3HMSSQ0iOHAOrT+pjl4q6yIslEB8YUaUxpL0EqRUwY0n4bg6+H1dilHy25TPej+zevRtr165t92GQDsKwYtC0GAwtgObmy/OkSt5RhV97yhmCEFIvjB2ELB3NLS9VM6QMsMm+Tt1AsWHKnOXq7aEg1S3wapc0DckgEd8dKXtyZo6oi/qhNadRkCJdh3xm5bN7dM92Zdo/MDCgPtv9miV1/vnn47bbbsOZZ57Z7kMhHYbv2rAnn1flr0F+GjCTQD4D3d+BuPKLkoGzBSdxbLsPlRDSYhg7CFm6IDV04G7oBR9GQfzSK32djoxf2jPClDQx0SNJ1lqkXJD0HhSlSFMRI2gpdZp8+AhiqRUUpEjXMjC+AUZ8EBecHGB0dLRvBSlh7969uOiii3DzzTfjyiuvbPfhkA5CfNfEGFZ54Ymxq1DqoKOprCkxOJd2zp45VDAz7dy2zoSQxsHYQcjSUKVqXjbMCioYokcTpbQG+zq1E5XxpSdCr6hId11lXF7AVybw9NztJShKkaYjolR8yFLlaIR0M2ZiCKtXJ1Qns35HzN+lI9Lf//3f453vfGe7D4c0GMeZNdh0bB9upPtePWiGBS05CpgeEDPhDZwIO7DCMj4vi/T4xfCsEfhIwnCnw8cUZj/1iulfmS0lhPQGjB2kL1HdaIs/z8a4YtyrFxGkgoJheqVVI2p0Cuw2pGnJwdFL5ghspjErSlmm2RMCnHTZW8zyXqZkGUYIIYTUw5/+6Z+qjBgxz373u9+tuh0td/b8/e9/f8OOr1+xbVs1l5BbPj97k+579WIYBhKJJFzXQTY7o252bgZO4Sad96x4EloxC2oeVLaUJh35DNV5SAbSqpOObimDc9VVKDorGjiqI5/hl99kuayX7Qgh3QtjB+k7JG6ZCWXMDSejbsobqnCD7yAwpfNs5+eJSNmc5ufn3JpRTifClDQ2id68yK3bSxRlDBWLJ1WHPRlj2RU3WS7r9S74XDSK/nmlhBBCGnZhsWHDBnVRIRcXf/mXf4mdO3fiS1/6Ekyz/rDy/PPP46//+q/x5S9/WQkqn/rUp9DNZDJZ3HLLd/DQQ49gamoKY2MrceGFW3DttVcv6n1ZLCIkiem+GPDL+yjkK7w9JbvPNBYWdZKpQWy55HXwvNkZyF2HXaRzfvlgKlHeXlkyqHwtgC8m5zJ96/thxV4d3UNlcCk+GMVZz4xdOf0bClcySCWEdC+MHZ0TN0iLsAbgr70MiGT12BVd+5QgJZM0btDx5XS1uuy1c+KoVraZdN/r1L4qMoY6/VVXw5+nM6Cum4gny8davQzPdoQQQhbN29/+dtVF6Y1vfCOOHj2Kf/3Xf8WePXtw6623Lui39eSTT+JjH/sYvv71ryvxQ2bONcmo6WLkwuKGG/4GMzMzuP7692DDhvXYunUbPv/5f8Qzz+zABz5wPXS9OcnJg4ODeP3rX18mJE3OlAs7IkilBgbr2p8IU2W/2y6cqNtoBBGoJHPKyWfheDY8EcV8V3W9CaR/s6kBKmNKV12caxGd9XRF0CKE9CSMHZ0RN0gLscqFhaDYirZLkPh8aGxuOV27O/+VeU9VKV2UU0MQT3VsFlo/CU710Jl/JUIIIR3PZZddhvvvvx/XXHMNdu3ahbvvvhsXXnih6q5Ure33I488ombGv/3tb4eG2GG/XqxZswYf+MAH0M3cfPM3sXv3Hnzwg7+PU089WS0777xzceDABL761Ztx550/xJVXXtq05xdhKopr+C2b7dt47lUIfMmmCnD06BRyP78DupWCBwvwJxHEV8qofG6rIEJIX8LY0Rlxg5B66cRyucos60osQ8Ng0gqz0EjHQ/mdEELIktm8eTMefPBBnHPOOepCYdu2bart92OPPVba5kc/+pG6+DjvvPPwrW99C77vq23Xr1+Pz33uc6oU4w/+4A/QrWSzOdx99/1YsWIEZ5318rJ1F110gZrJv/32O9CriDAVT42EHlIFAvHJ8O2wZMHLA/Y0NHeGpuWEEEW/x45+jxt9gzMD2FNlNy1yg/hKLQKJoZqXD29l3k79GVtFmIp6TZX5TllDFKS6CGZKEUIIWRYyW33ffffhV3/1V9VMd7Ht9w033KBmtmWdUJzdPvnkk/GhD30Ib3vb23rCM2P79qeUP8pJJ22YU0oyNDSIY489Bvv27Ve3NWuORS8ixpy7f/4DZNJTcKf3KzFKJUYlTGiZgzARQIMBJ7EmNDmnaTkhfU8/xw7GjT7AmYG++y7AzZUtjkWyhsXk3D7usgXFk7A8Lgndy4ZeSWph+TZsCEK6me4+oxNCCOkIxGj7O9/5Dn7v934Pn//855FOp0tlFcULCpkZ/5M/+RO85S1v6SmfjF27dqv7VatWVV0/Pj6mLix27dpT9eLittu+j9tu+0HVx9p2Xt27rqtu9eK5tcv3PG9xpX2+58Jf4DGem4ebz8C0Eoit3Ch/dLjKWOoogtiwam8sF2Azq14DzxoBjLhKudeCALqXKUu/txy/YSbnWqDVtX6h7YrbVN2ujsfWZKGKRl8rvy8+bM7v4q/jqzLKVlF5DILvNe573ch9NQr5HgS+D6+G2W+j8Nzmv3Z3Cc+xmHNQvfRr7Fhu3GhH7Fj4sa7KZpP7suU14kfl8mpxZqHYU3keDO/nMzAsrGtEOXnh8xn+XO25bMDNAuJpZMRmN/XCjSW7STrw6V5edaeVeFgNtdyIIz1+UVmsdAr7Ke1XMxDoYWxtJLWOa6n7UccX+HUdp3TkLW5nRmJO8ef5vKzCmB2Ux+nKl1IZxxaItYsh+lj5uTKm1RvjvCrbRZe1Il4sJ3bUe/6hKEUIIaQhiFHtAw88oH4uzvzKRcXQ0BBuuukm/NIv/RJ6EfFREgYGUjUvuqLbVSvjOHz4SNV1jhN205P3dWCgflPMjF17EJmdZ101jmR95Cu6BVXiOTkY7jR03UKqUMbn+wEM38OwmYeve/B1GwP+CwicGIoTvb7nIJF5HlowO2ipGGcj0ExkEicWfpnnAkXT4WtW2aKFrLUMN/ycGnVUPhi6BrPKWMw0lj5orba/avuunPx2K59TBKnpPcjulu9eawaonpjYV5CtsmypTFmdZ2AdMwIcPrALTz6mNfV9Tsaa/9pTS3gOMeRuBv0YO5YbN9oROxZCBNt9e17EI+p0rC8Yc3IVcSVXpfvcQrEnSrbQJdadR+vQCgEm1gDdRo8Eq3i1WCMldkYa0C1AC0VCwTcKj9M9wHfgZR4H8nEU9cCwFG92h5W6nOQdyz6r6nVN0Mu9BolSxePV4GNFsB+a9xiCeZyE9MBBKvdCaXwQPWPpRY1JM5FLbUBQEfuLcT3uaGWxtDLmVsbvBWPtIsga5fGyMj7WG+MSVeJqIvLYVsSL5cSOeuMGRSlCCCFLRmZFpXuStOd++umnS8vlgqI4oy0z31KKce2118Iwei+1XFqSC7Vem2kaZdtVkkwmMDq6osa+w4Hsli1bFuxMFWUyXVuNmcwsbiZ85yEXU9n5H5PPTmH/vn0IjBTyQTg4dFxfDdSnsBKu78B1ZjAde3no81DAy01hNL8XvjaIQAbuFbO/4p8hA9OJ2IlYmX4k7LJTAyldOLjiorKsKjE6nY9YYX2sDjElbmrqNmf5MsSTxNxxdBnJwvOZFYPAyt9VppRsv/aVqiNiKxhMzH3dg/HGCTXDyc7LiBmM+Xg+AE4/+3wYRvPe55Wp5r/2lYOLf46pqdoCyWLp99ix3LjRjtixEJIhJeehc1+5BUakvLJWzDlcsbxanFko9pQ9/9FQafLztUUUuyCQFe+XQzYiouWqTWzYU9An9wN6CtBmM6VUFrE6UFtlSjmpM1RGcd4N1O+Jl+6B5s3GOpngiRIYSUyPX4w8kmgFduVM0RIpxnbJfDoxeAwvGGfPW25outNYnZPxwYASnaJJkoamKfFOxgeHh1+mPKQqkbg+nNDL4nRlzC3G2NJzLhBrF0MyrpXFy8r4WG+MG66y3WgkRrQiXiwndtQbNyhKEUIIWTQyUP7Hf/xHfPzjH8fOnTvLSi2uvPJK/M//+T/VjLfMcB85cgRf/vKXVdvvW265Rc1+9xKxWDjYlBbl1XAL07bF7Sq55pqr1K1WML/xxs8o/5TFeKgYZu2BvLHIznyS+KQv8BhdNpIMB5XlUBiwyI+l39UvYXlBZBCqfpflhZtaFt2x/OK7SowSM1dPi1WdEVXilR9ehJXvf/4BZXH9QtsVt6m63XJa0i/02OJ0cPG++LCK38Nd6UqQapUoVe0YdKNxg+NG7qtRyPdAMkBEkGqmKGUslELXAMwlPEcjfJwYOxoTN9oRO+pBBEURpKKiVK2YU7m8WpxZKPZUOydp+jwiSnHdfNvU/YRB9Z9Ly4xS7JNM3lmK25bHxUDtI1Am5oHEusJEjR/Zd2h0HgpWrfKPCo+rwfvR9DnjgUo0KX/0XfU+qPgb3Vfxvasyrph9PllXHI9o1WNuZRyrI9bWS/Sx8nNlTKs3xhlVtosua0W8WE7sqPf8Q1GK1IUEt0wmo9KJFzPjQkgv0u/fh7/927/FJz7xCezfv790QSEXEdddd526oHjlK19Z1j3pda97nbr4uPPOO/Ha175WGdoed9xx6BVGRsLPwMxM9S468lmJbtdL5ubiYWTnssjPHIGbn0Gge/CC8CLKV9cSLhApzauK7yJu71fDSyFWNs4X3ykPK6d/poahgZ6Cr8fn7EKX52JnP0I6GsaOWfo1bpD6UIKUEZ8r5ngixbQ/1lV6QVYyn9dTPYiX1NjRB5DM7yuJTlE9SWQREaScWHVPtk4eMxXJ+hUilW4inqy/1LbXaJooJd0zJNCcdNJJzXoK0iJ27NiB7du3I5fLIZFIKMPJTZs2tfuwCGkL0oL62Wef7evvwwc/+EF1fpcLCik9kM5JYkIr70Ulp512mvK0eMMb3oBHHnkEjz/+uGr7LRcXL395eRvsbmXdurXq/uDBiarrDx48VNjuePQKMrh67pHvI5+ZwvShvfBdB/ncjJqFDIqGojKCHBqBZh8FkrVfu5rrDLzCbKheZlIrfhM6fOi+DV/jPBoh3QxjR3/HDdIbiCA1duieBcvpD41dsmRhSsYEhp9T2U7KK1JlVlWMG8QofsFuIZ2Bk5vBnifugJPPlpZZFUOaWDyJ0191dd8KU00b4d1zzz3N2jVpcUaICFJS+z8yMqLq+7du3apSqOtNo5aL9+zMFIx56uIJ5viDOHYe2ZlpaAXTYNJ+ZtJHsG3vNjWYHhsbU98H+X6Mj4/3XcaUpOO+/e1vV+25FxLljj32WNx7771485vfjNtvvx27d+/GhRdeqMoxLr/8cnQ7mzefBssysWPH86WZ/yLT02ns3/8SjjlmvKfaestsnwyuimV7ummVzlUqXV513gtLEeDZYRr+QvuUx2lm2aywBukq13llXISQpcHY0b9xo2/xKuJfpPteNyKCkQhSYjLuF0oMo+ji9SQl9w3oAqiM0KtkSgXwyozPu+K6TsZMhgXDCrPJYxEVxnMd2Pks/BZ20O00OO1I5kXSh0VUEkFqxwEHmp5EPn0Yd24/iuRw7Tr3KHJdMjosKajdoWZ3AmJqmDeBoaQYfvJ96xRiroM9e23EUiMYHvaVMDsxMaG+J/0kSl1//fVqxnvt2nCmtx6k1PE//uM/8N73vhdf/OIXleB9zTXX4MYbb1QXKN2MmM1efPGFuOOOe7B16zacffYZpXX33vtjdcFx9dVXoDfRQ2cH3YRumPB9KbcLpNAu7B4k3fKkTbfvwjeGWuaBQQjpPBg7ZunvuNEnSLwzE4CbUzGwtDiaDWwmEbTIB7BR5XqGm1aCmq989YrSkDbrgaXK7/pXXJkPEaRMKyzLtCqapHhufydvdP63gLQVGQxIiZJkhIgg5dk5mPEkEqkRWLFE3fuRlERSP77nqvc3NTCiLvRIZ2DqOo4mUvCcHHw/psQo+X4UWzf3C5/+9KeXbID6hS98AevXr8eHP/xhOI6D//bf/pvyDJHfu5m3vOWX8eSTT+OLX/wyrr/+PdiwYb260Lj11u/gjDNehssvvxi9hu85SB/ej1xmSplsF4fZZTK6lOoMrIZz7CWYDoYRmLW+KyJghQPeck/VBvTtJoR0BIwd5fRj3OgrrAH4ay8rxbYithMRpUSQqhkXO7NcTwSphOqaK5nSxQxpE9nkiSVhqrHIZNes/FVcFspfpFfg1S6ZF8n+kFp/KdmTDCkRpFauPR2xVP9khRBSRD738vmfeHEbJicnMTAwoL4f/ZQl1QjE0PaEE07Au971LnVx8dGPflRdXMgseLciwuRHP/oh3HLLd/DZz96IqalpjI2txBvecDWuvfbqnmtnrggCJaBr8k+XjCldze6HlXuSIVXYTlLvrUEEfqq6GaoehxaIb5Qjo92w6q9sm9nZ2LDL3txDkeWEkN6m12JHX8aNfsMaWFI3OxF+giqZVe2IdZXlelqpW6B4PRmFhiSSGdXgyg7lI2Wq8YEMKKKilK6e01fjB2Zg9wYUpciCSM2/lClJyZ5kSFGQIv3MyDEbYCYG8ep1PkZHRylILZG3ve1tOP744/HGN74RR48exT/90z917YVF9ALjbW97q7r1FZqmMqWK7ZmLA8egjllMMUE9OvYa6H4eniFlDDE4Bb+N0u4DF6afVWanugzIawzKxViVg1NCepteix19GzdIdcRX0UhA83LQvEKsi4hS6leJlW2IdSJIBYXut6EoFfo9qcNWwlGDn08zkE2sK0xMScbkrCxlBjYML6vGD8vp8kc6B4pSpC5ElBIPqcWU7BHSq8SSQ1i9Oo5kkmWpy+Gyyy5TJrbiD7J37952Hw5pE4ESoyTlv5ZtaaAGp4dGLlCD8Zr70Qx4HJwS0vMwdpBeRUrcs8dKyd+sJ5NdYc+kBCEp+XP7wXM2qPFz6GEl4wfSG1CUIoQQ0jbOOOMMPPjgg3j961/f7kMhS0DK9NTNd1WWlJTeqUndYvc9uS3QIics4UuEfhWeoxo9VCLrPXOQohMhRMHYQXqVSu9Fv45yv3Yg2VEB3LChiZTTqS67QViKv0zKxgWF7Gg9mB1MSNJUN2ZHe86smXm0j5Xn0oKAohQhhJC2IqUY9913X7sPgywC6bZnSuZswQDK90WcKoywSln8hQGkkQjNXGtk90vq/ZHxS0udfTL23A2ZBUUIqYSxg5B2UPR6cpUwFXpKeaqcLihkeC1XMJJ4f3D0ktK4QDCNWVEqZmihcNUl4wJNN2DFk3DyWdUkppoKE4snoXdBJ8Zm0b+vnBBCSEeVCJPuIZYYwPozL4Zj56AbMRimCccNlB9UtjDecqS9sT8F/9gtYXcht7bnRHRg6frsqEMIqQ/GDkJai5TNSae94kyTZEgZXg6TKy9SGc1qmwYIRpUTUVpElPIiP3cDVmIAG8+9SmWVFxlMiBfnLLpuIp6ca4zfL1CUIoQQQsiiseIpGGYMumHBsGKqxMBR6ftFUamQOSUzqfYUdCeY9cIghBBCSNvQvUxZJlIllcKSlOVVmzKS9iYiVKkSe5Mi8XyTeVGSyXJRqt/pGVEqk8mqlqoPPfQIpqamVEvVCy/colqqmubSXuYLL7yIj3zkY/A8D5/61F9hfHxVw4+bEEII6dYSvmg6et52MDO5B64bDnKVNVTSgr7nXsRgYdgLlFH59OpL2y5MFQfjRsGjIupVIVA8I4QQ0quik+5lMTT5APSIoXolUoInpfVuxN/J8Kpv343+TqSzaJsodc8996jOGcJHPvKRZQtSN9zwN5iZmcH1178HGzasx9at2/D5z/8jnnlmBz7wgeuh64tTI8Uf48Ybb1KCFCGEEELmzvpF09EPH57CC1vvQN43oekWXFGlgikAI+KBisDLwHCnYThH4RcGyoY36/TZKn8IGaiPHbonHGAXtKhIp2lFp4hnhBBCyFLi3IqDd4dG4VXQfAdW/iXkk+uqdrWV9fJYEbV8YxCHxsr9nSrpFn+nwJkB/NnX4fvlwd+HCT3WvyV0fSlK3XnnnfjLv/xLaJq2bFHq5pu/id279+CDH/x9nHrqyWrZeeediwMHJvDVr96MO+/8Ia688tJF7fO73/2+ErlGRoZx9KgMqgkhhJDuIzOThhuZYElnyhPwDcNAMhX6QAjZTLpsQiY74yKf88sypIpp6NF0dCsXqFI+3UxBN+PwxUPKkQFxDPBdWLn9apA7eOAeQLfUY6KN9oqzskACzUQG1nIcYtTqGbHCwuh6R80iy3ad2fOIEEKIYOdmShMjTjaMU64dlBlMG30oMhTjnK9ZqrSuEj2YCWOcZAXr8eo7KRpyV/g+LgfDy0D3beh+HqY7PSe7qqlNTZwZ+HvvQuDOCnX5ipwVP57E4ElXUJhqA11fvpfN5nD33fdjxYoRnHXWy8vWXXTRBfja1/4dt99+x6JEqZdeOoBbb/0P/MEf/A6+9KV/acJRE0IIIa0RpO76wW3IZrOlZXm3XGpJJJLYcsnrlDAlgtQD99yOXG52+3TehxPJ2JeSPcmQqvRHmBfVoceRZtEIjCQCPRSDiolS0VnZVuHrFvTCYDyIDkw90ajYnpkQQjpdkHruke+rEnIhW+jcGu2poVtJjJ56RV8KU4IIUtVEp0AX/8fWIoLU+OF7YPhZDMQzWJ3fjyA6I1SYnJKue00RpkSEE0FKOtwVJqS0SJp04NsInByCSCYVaR1dL0pt3/4UHMfBSSdtUFlXUYaGBnHsscdg37796rZmzbF17fNLX/pXlWl15pmbm3TUhBBCSPORDCkRpCzLghULB2F6ZBbZcWwlQBUzo+RefjdNC5YVbm9rPlAQpTzHVhcA0Q4yi0LTlSAVGAUxyK8+K0sIIYTMh8QhiUfFZht2wYa72MA1cG34jsQrigwdl72lWfD0VJkopbKUWzE5ZcSgFcYg0Y5+apxTwzOLNJ+uF6V27dqt7letqm5CPj4+pgSpXbv21CVK3XPP/XjxxV24/vp3N/xYCSGEkHYgglQ8HpbFSZe8KK47VwwSQSpW2N7y/bLHiKl5s2dTF/KuaFp6PyGEkK5CBCnTisPwQjWqWH0uvwU2Jzs6DRGklAeVTFBhNk1ZV3+w7v17ebaUks6OXZyIX5Xta7BhLS7DvM9YlCj1zne+s2FP/OijjzZkP0W/p4GB6gPUVCpcXo8vlGwjHlRvf/v/h6GhpbW0vO227+O2235QdZ1t59W967qlmxiqy32no47VC2+k+cj7HMiFIN/vjkT+Lq5rtO27u9xzRzecc0h/onlZjB/+aU1z1qan9xNCCCGELFKQOvz0HSozr8hUxBbANDSlSSza+qCPWJQo9c///M9zSuTajW3bJaPWapimUbbdfNx009ewadMGXHjh+cvyuDp8+EjVdVImITzwwAMYGBhQF5UvvviiWrbY7oCtRkokDxz0oBtdn1zXFQSBj/Sh3dj/DKBpnf3Z6FdR6sGjhiqJasvzL/PcIU0cCGkaXlhEEYh3lbSbDmy1TNXqLdAyujK9f+761ntPEUIIIb2I+Dlqfr7qclI/kiElgpR0HtbM0PrAiAzPdTjLsz7oA5akMARB5/SjiRU8MqKdgqK4rle2XS0eeWQrHnvscfzN33x0WceTTCYwOrpi3kypLVu2YHh4uJStcMEFF8A02yf2TE1NKc+RZDKpjqsasn76yTysWHO7IpFZ0WN/ABx78qsoBHYgjp3D+afH1Xdmsd+lRrDcc4ccJyGNJuxylEQwk1W+DJLtCTEMdzPQPAcaAvjS6acOoV0EKb+KOWsj0/t1GYwXJtqiFY0ifBFCCCHdTi1xSfPDznt64ELzMjWzkiu745H5EUFKug8L0XwZI9Bk8N6+A+sCFnU1IxdauVwOp5xyCv74j/94WU9866234j/+4z+wXEZGwgu/mZnqX6hMJlO2Xa3spn/6p6/gzW++DuPj1b2p6uWaa65St1oXgjfe+Bl1EVm8kJQsh+jvrWbHjh3Yvn27+rsmEgls3rwZmzZtmrOdHJ9uMFOqlWi6rt5vvuedh/xNKr+39X6XGnYMyzh3tFMEJ72LlRjA6pddiYNT4SA4a7vQDm2FnzoDTjYD7L5bmZxrkjHl5cvEoFbOyoZeFgmVcWUUSqQjDXgUvnQI5GCcEEJIFxKNc1WbiGhAPrkeR8cuUB1xa+5DyuSLbXJ7Bc9G8RUFIhYVf/Zb35GQzLKoK5OzzjoLDz74IA4dOoTf/M3fxHJ49tlnGyJKrVu3Vt0fPDhRdf3Bg4cK2x1fcx/PP78Tk5OH8a//+g11q8b73x+KcKtWjeHTn/5r9AIikslFtJQCjYyMIJ1OY+vWrcpPq9JTSy60M9PTMGP8wrYC3/fg2HnMpKeh67ww6jRcO4dcbvY7Mj09rb47kkU6Njamvkvy3RofH29qxhQh9eJEStjtiu57VbePLHds8S+b7b43H2Z8AEbCL6Wrqw43sWH4fgywhqF72fJZ2chYVwbQC5X3NQIZZB8au0SVAMYKnXesaAeewmA8MOlZRQghnU4xLnnO3O57/YrEuSPjly7YNESJTi1GspHDUn17Tve95j6xAc1MIHBzQKGMLqhI3NbiSZX1TTpclHrlK1+pRKnJyUns3LkT69evR7vZvPk0WJaJHTueVxeEUc+r6ek09u9/CcccMz5v572XvexUfOUrN1Zd9773fQgTE4fwqU/91bKzqDoNySITsUkEqV2TDjQ9iez0YTzwX1MYXFFeNiFK8sphWdZjanmH4nsB0maA4XgA3eB73nEk4nh4twZNCwc86SNT2DuZRTw1jGHfV6LuxMSE+o5RlCLtxDQMleUsZaXiDSjkxespQiKRLPkyyr38nstlS1357LwPJ5J1bqlB2yKz7cwUplfPHSA7kRlYGSC3yiuqOBD3CmKUYXaWXyYhhJD5kTgk8Ui8eqQrrGeXi1KCbvWvyNAOwame7C3DzyoByvAzZaJU00sGrQHo6y+Xi6zSorhV/vypuAk9RiPydrCoUeUrXvGK0s8PP/xwR4hS4uF08cUX4o477sHWrdtw9tlnlNbde++PlVB19dVXlJZlMll87nM3YmhoEO95zzs63mC8mUgXACkzkqwOEaTcfB6xeAqpoRWIxeemcsYTnXVy63VPKSuWxMDQCpbvdQHhdyalMqgkI0TEKPluFbt/EtIuUgODuOzKa+BGfBePZCIj9oIQlUwNqp/lfsslryvzadx12EU655ddCCy6e4z4StUxY2u404vbLyGEkK4kl50p6zKdjcQZQVeTH9VLywSJQ9LNrGge/dLR8PGZSDZw6HVIkaETkI650jlXMqSS/nYcSG2eI0DJ783srKtZ5Z8FvUKU0mOcoOqaTKmoKPUrv/Ir6ATe8pZfxpNPPo0vfvHLuP7692DDhvVKoLr11u/gjDNehssvv7i07eOPP6EMzYWrrroMGzeeiH5FMjjE90bKjiRDSi6qV69/GRIpZnYQshjkOyPfnX3PPa4ySaW7pny3mCVFOkWYiuIa5QP/SooCVel324WjHMaXiDOD2N4fYjg/1/vRD2ZnR6XUoLzL3txd0YScEEK6n2wmjUfvvx12PltaZld4F8kE+dozr5p3EiS6zrLDiQ9TZ4VBpyKCkzQx8d04XHOo57wbpWS0OHTxysYwDnrrlbZZlDr99NPxy7/8y8qDqNJzaLH81m/9Fq64YjaDaTlINsJHP/oh3HLLd/DZz96IqalpjI2txBvecDWuvfbqUlmCcMopm7B69TgGBwewdu1xVff3xBNP4y//8v9U9ZSS7KqLL34NegUxYpa/pZTsSbYHBSlClsbYmg1qcLT5GA+jo6MUpAgpEnjQ3CwC3VJd9aLINYiYnIsZq2RSlZmz1hCg5kvvN7zyjCzV8aYDPDQIIYTMItm4IkiZpgXTKnRIj5SWe66j1hezoEh3o3sZmAVzytBPKg/TnS7F8mZnSDUbyciTUlHfySKww7GLFynG0gwNiVRq8dYHfcSi3hkpdbvlllsa8sQnnniiujUKEabe9ra3qtt8jI6uwCc/+bF5t5nPY6oXEVFKPKSqlewRQuonnhrC6tUx5eFDCClHBKlAjM+jy0pTiuEgzi+k9y9U6ldt8CqC1Pjhe0JBq4Ae8ZlU+9cTyuScwhQhhLQfEaSsWEL97FVkOHl9bFTea4LU2KF7AC/MitMQYCCewer8/pKnlMRmif3dKkxJiejoqVcgiPhVpSKlgANxDUMpa/HWB30E5TpCCCGENJzAzSDw8oCTBnwHmmYCfqT9shqMWnMGr7UEKencJ/hGUs2wVlsvgpSvzWZkRTvr6JGMLEIIIWSpBM4Mgnwki6uigYjqJFvhXzSv56LvQqsoXyztymttN9jKOGxUHNdiM47DzKgc3EJsFlEq0Bx4ekqNA8Jy/e6PzZXeZVZ8drwTS2iIJfrXx7oeKEoRQgghpKH49gzyz92NhHcQur0LyOxBTBwVImV3MjjNpk4sE5WGDj+EIXfWY6S0LvAQz+9XP+fixyAQgauCALraTga64lkhaJExoCRlGRFTXUIIIWQpglT+uTvh2bOxao4HopmAv/ayhYUpN4PY3rtUiXutZtsxLaG617ZCmBJBasXBu8syjiu1sqVmHEvMl9iswS+U6sfCuC3vHf0i+x6KUoQQQgiZY0Jb7MCXnXGRr+iKtFAHPklhDySzSVQhM6lEpECGHCVRyg9Ny0v1e4Duzqjue25gzPGekk66CFy1P09LINBj5ccj7aW9uUbqhBBCSCNR8U0mT8QfyCjEomiI9GzAFV/EhTN/VIaU2pcFvyJzOFzvqAkb5bnYyBexQFaTyjjWw+PxJP4uMeNYRC7DTavXoWkGZJ5IMqXC5xFTcGNBb8hKj0jlQ2WwDK7XoChFCCGEkDJB6oF7bkcuF84Cp/M+nIoEIyueVK24F/RHUIPHmLpXA8lChpMMxIHIoNN3MXTkIcRye2EWt43uJvBh+DnlN6GZMaCQCVVEdx0YgQuxkPLhQC/4VMxeKLDNMyGEkAZixKAVfRIrQ8wiDdqVAKTF5y4vilwtRjUmKcRZNSm0hIzjopeUTDYl8nsRj8T2mK5hIDepJqxy8TXK/9E0NBjIYuzID8sytSqRTC3JHKM3ZGvIzKThFiYpBTPq4C6fB8PA4GB51+alQFGKEEIIISUkQ0oEKemKZFkx2JoPRMagnmPDWUJXJBGWguKOZBZUuvL5MtjW1Myp+E7Jz6EnVDjo0dRgOJxVlcdLZlX4mCLhdsnc7pLnlOlMlpUJqqdTA9/qHXcJIYS0B9eZPZ87Fd33SHdTzLoKdBO+EqSKsT1QYpv8r8lkkmRRBa7KqBJExArL+4qZY1opa4vekK0XpO76wW3IZmdLVePm3GZzr3/965ctTFGUIoQQQsgcRJCKxROwfB++Vl444Be65dWHrsocNM+ZHUiKuBR4MLysGmyKz4TueeGAVWVUGUqEMr0js2IUXJjeDJLZnUrGUrvRDORix0SEKpG3ZNAr+ygKWyJoiRjWiuIHQgghCyHZFdL1285n4RYEKLvCvEjWS6k46W5koqkY18MJo0DSpRFoPnTfRzy/V2U6r5y8V20vWVVBJKtKJpWyyRPDscICmVpRk3Y90KDphRS2YukfTGj1GtATSIaUCFKWZcGKhaWqSWs2LdC2bWQymZLdw3LgN50QQgghzUM34Q1tgO3MDlpERNK8LI6MXQzfHFQ/jx68q+KBMovqFx0oCkt0BDBgeGm1LsywsmF66VBz0jTofl6JW645gkDq+YoztspIlWV8hBDSbpKpQZxz4evgRwSGqQrvQl03kUeyDUdHmsFsdpN4REp8l3uJzX7oF2kkCtnSs1lVKs6rSaVKJ/mFTdpFj7KMMObrBXHKjyWgr7+cwtQiEUEqHpe/D5CIlY+jRJhqBBSlCCGEENJcxJ/CKB9yyEBTBCnPHJq1Og186AgNXTV4pS49aggkk6vKZF2HLtV/BcFJmc36ejjOlUFsodzPUCKUXsrKMgNXPZdlmjAKA1VCCCHtIZEsFwYcY67wkM8uLEaQ5mIUY62a99Eg4TNmaPAWiKNiTC6bSMzWNDMUlwrNTSRSKx/IglAlnfh0QwRIH7oq3TPUY6TBiWRTyTFIzC8+v9pHhSG67qZV6Z8vjVWUR5eGQDwowxehvLkCMaD3WfrXiVCUIoQQQkhzUN5RtvI01yKlGarzXpVtVQc9X7wLZNQZ+keFpXqSKyWDWUf5T4SzptEBsYx8AdcaKflO5FLrVZc+2YeUCR5ZdTE8a4TmqIQQQpaPiBzFnyu77y2SMK5VX96OwvP5jmexKE/HgQ0lQUomjhzzCPKplBKSJGNKYrcISZqfr2uf4iE5dPihMkN0OTZpliLPp8r3ZcIqvlFNipWUrDpN2knroSjVY0xNTanaTjEdGx4ebvfhEEJqwO8q6WU0meWUWU8pq3MzYh8BvcIvxDeSMCVrydSU90PR+iHq/RRaoEfFpwC6eESptCiZCA3C2VaxTJWMKvGukrIA3YduxkNRSgQxuDDiQ4tO2dfc2ZlYsdXS/PKZYTFwBcsACCGkv+KbmQTs7GyXvcqELjMxp+FGNSSGBGYSmpstlJjPxTOSczrSCjGz8Rm/mkgDZhKmNA6pIUD55mzsno9SXNeAwCialqsCPRWrdSMGPbBUdz/dsJSOJDFf1kucV6h478MMbKn4gxbYKuPK0mVZTu1XSv3CbR3ALnT5layqwEVQEMJI50NRqofYsWMHtm/fjlwuh0Qigc2bN2PTpk3tPixCSAX8rpJuwCl0RXJsH25F972F0GMDiG+8FNrBR+CnzoDt6pjOl4tSysjUjGQtSYceIxUOXmUALoNSe0oNLtX28OHrSTgDJwDZvUqsUjOuiTVAbl/YqUc9rjEzoSJIDR24u9TVTzwpKqsV5GICJ1xGYYoQQvoEmdyIb7wcfn421riRzoHhRkZ9ccFMwT7uMmi+i3zFxE2RvFcRK5uIPM/06kvn7W43J3YvgMqMjuxOTTVpUrpXRfSS7nqFLnyhmhVmScdmnivEd/Gf0qB5YYaU8p4y4oXHaiUzdfE1Z4e+7oKiVA9lXchFru/7GBkZQTqdxtatWzE0NKRu8yEXxjPpdMOMysjy8T0Ptp1DenoKurHwTAvpDBw7h1xu/pao09PT6rspM0NjY2Pquyrf3fHxcWZMkY7pipRIJJHLhV2R7LwPp0LnseroiqSZKWgyWIwNI9B1FZ9qEbZ/jqvMp2KKv/KC0sLW0TKFKgbnIlxJ9lPYWU9uful3VeSnPCukZNALO/IpM9WltRZX5uiF7oBqJlbXoOuR9dLG2s2Gz0cIIaSvhCmVsVtEX0aRnZlSewoqha0CQUX322YjglMjnlHFdSOp4qiGaByWbGZHCVAq7nvVSvaKRxBU+ZmekK3GiWgEeiRjvJHaAUWpHkHKgERcEkHqpaMudCOFmSOH8fjOaQyPhm75tQgCHWNDojKzXXan4HsBDhnAcFxSWvl36RricTwzIYaOtS+Cpw5P4+CRHBIDQxj2fSUaT0xMqO8wRSnSKV2RtlzyulKL312HXaQruiKJIBVLLC47KD5fqr85APuY18DYn1eDWBS8oLSZF1THveIMadhFT3ymCt4UMmMqSpFuQS+aqIogJcbmvghKoZoWWEnELCmTqH8wK9cBkh3lG7FQXBMiolSwRH8NQgghpCGxs5ORuH7cZXOylyU+u7ltyCdervy3kgfuUyX2QSBG5kEoikkJnh5mTEsHPnfgRMCIqe11LwdTuuhJbWDxVpCqZEygMqlUNlaZbEiWgGkYSCaTyGazcJxwvONVqEdiQyKTmcuFolSPIB8IKQOSrAsRpOxcDrFECgNDKxCLL9xONZ6g8Wsn4XkuYvEEBoZXwKjoWEW6G/WdTKTg2Hn4fkyJUfLdle8wIZ0kTJV+tl04evN9GVQpnJTgSeaTiECSHSWzqKV20DI4ddWAVEod1Hot7KzjJI8rTayoDKbARfaYixFYhdch3XhaVP5ACCGEkDDrau5CD4EdR2ANA3oegZFQ5XiaFzYyERFKxXypwRN5SY+rbdT4QJKpFyrRL2YvS5e9kul82H2PLI7UwCAuu/IauIVJSmHlgD4nu35wcP4qkXrg1W6PIBkW4ksjZUGSISUXvcdvPB3JAWZeENJJyHdSvpu7nn0ck5OTGBgYUN9dZkmRfp/tFRNx8WxSJXLqZiEY3jBrVOrZ0LwsvNXnQzv0WMFTQoNVVhYgj5M20MOwUqOqLGKpzDkeQgghpEl0bUbUItECDaYevt7AGoC39vJwoknWOWno++5BIBnTkhmlFuowRZASVMMRIG5Ui8962OxE9qUM0l0E4gkpIlah5EyLibhFW5TFClNRRgabMyCiKNVDiFGylAJJyZ5kY1CQIqQzOeb4jUikBrF+xMXo6CgFKUIiiE9TUGVGs+gNJYNYe93VpUFsNVRXPGZGEUIIaRCBM4NAsm9Kv0eKw8QPql5zc1JOpYeVCFAiSBXL5udBMquij/VSxxdK/cWzyoWz5hKVMR23QlHKipmL7sJLWgNFqR5DRCnxkKqnZI8Q0j6SqSGsXm2pWm1CSKE1tm7CmH6hULJXZRvNgPXSj2Gv/QUEMYq5hBBCWiNI5Z+7E4E0tyjgRaraVYW7mYC/lt1YW0HYATCpJrGqeztqaozgx1eEE1QFUUor3JPOg6IUIYQQQtqPmYKz+oKwo50IVNLxrgIRqyRDSm6tMjCtnImNLieEENL7SIaUEqQMC5r4Hgp+JDI4NuDm2I21VXHXTCoTdWZM9w4UpQghhBDSOtxMzYGkdOVRM5zmQNXU/cDLQ3MzrcvcmncmNjRn16RkgxBCSM8jgpRmhrFJ8yKyifLmXsCAmzQs7hYFp37srpfLziAdSdMzPX1Ox7xKH6hugKIUIYQQQlqDm0Fs711hNlQ1fAd6dj886cRXh59EUzFTdc3EJliqQQghhLQs7vZrBlQuO4NH778dUI1eqhvkiy2IdMzrNmGKohQhhBBCWoIqvVPleRaCYjcdQXXL8aHBDmdHvXxodlp6oF7+e6vo05lYQgghpC1E426VzGr1uz3VlwKV77mw81mkEjFYVlhGmojNilKObSObzcL1uq+MlKIUIYQQQlqKEqSKmVC+AyOzJxSmfFuV5xkzu4Cib4egm/CGNrTteAkhhBDSQZnVhVI+yazqJ2FKEEEqFk+on+MRUUpwnO70u6QoRQghhJD2EfihIFXIhgqKWVEyAxpdL/eEEEII6d/M6tJ6p+A91brGJ6R5UJQihBBCSPspGYYXZ/0is39igO7Z0DS2cyaEENIeAl+67BV/jkghnt22Y+qrzOrocnbB7SkoShFCCCGkQ9AAEZ5UdlRhsBl40AIXmleYMS123llmp79+9KMghBCyeDTdgCaxx80i8AqxKZq8Kz+bicjkCmkpC8R6JXmwKUlHQ1GKEEIIIU0lYRUynAINuq4BRuGm0JQOBelqHOiANQQMnwgYsdkZaBlwrr0UsAahaUZ9He+cGej77wLc2S41czAT8NdexsEqIYSQmmjWAOIbL0fgzxpIB85sppTrBqEgVUcsKcXDfiXQYBoa4vI+zJf9XHW8EEUDfA1xLQt9/0N1xvru6kjXT1CUIoQQQkhriZY6yM9SnueLKiWDVD0UpKLp+jIDKoPJ2HD9zyH7lEGqZEMVBa7KY5D1sh0hhBCygDAVlUY0PVK+F/2ZtBbJrO6zWO84s2MoPSjvvtetUJQihBBCSGuQmWQpcZABYjHVXjw6irPPsl6V5olA1SAqBa4o86b7E0IIIaQr6INYrxsmYvEkXDcH1w3LSH2nPIssmUzCNLqvjJSiVJczNTWFTCaDVCqF4eFFzCATQjoKfpdJX2ANhCn00RlLJw199z2hICWDSpXO7wNePlxPA1lCCCGkP6k1BujDsUEiOYBzLnwdhmKzhmYrUuWTeCJIpQa6r0yRolQXs2PHDmzfvh25XA6JRAKbN2/Gcccd1+7DIoQ04Lu8adOmdh8WIQ0hIZ2co74RFZ4OgWPCTwwhUH4QbthSp2gkW0CLJWDFTGgRL47AmZnNsKpCgGxYEai8qpwKV1pZJmWDDkx/Bhpk3/SVIoQQsnjq9YlaKG5BDNU7MBY19LgDwNSrjA3mbGbCjyXCsYFXPdNJxgamZZRivVT/z9mPjCnErtLUekaYGowIUcMDDcwsbyMUpbo4q0IuYn3fx8jICNLpNLZu3QrLsjA9rcPK95963Ev4nod8Po/pqSnoXZiCSRbGsXPI5QYwPT2tvrtBEGBsbEx9l+W7PT4+zowp0hfIQFZff/miBrwyQPZ33lkQsmrtWA9T9kXgSu+Zm76vfKw8+LvuhhYbUsfQiRcDhBBCup964pZmJjouFrXruOsdG8y7nnQNFKW6FCnzkawKEaQOz7gwzBSmjhzG7kkHY+pCloZ73YznBYibAYYSAQyDf8ueJBHH/rSBI5OHcXg6h9TgkBKZh4aGMDExob7jFKVIv7DogazvhQPk+YxNnazyTVfxUAQpKQ+MTqNKpz9BN8N9cWBLCCGkWdQRtzoyFrXxuOsZGwT5qYY/L2k9FKW6FPGdkTIfyaoQQSovZT/JFIZXjGJgkBey3Y7nuYgnkhgeWQHD4Ne0lxkaWaG+u04+D9+PKTFKvtvyHSeELIARg1bF2FRJ+SJKRbv7iSClVWykjNWtsiyqbi2vIIQQ0uVxq5MNuTv9uEUcq7G828llZ+BHShgtb3aCzfT0rvWRisKr3S5FMijEd0bKfiRDSi5qTzzpZRSkCOky5Dsr390dT/8ck5OTGBgYUN9tZkkRskzEq0Jmdd38rMgkraOjyMxvxNOiW8srCCGEkL5EJorMgvdUDXFM1qtSvy4VpB69/3bY+cJEG4BYxB8rbmqq495lV17T1cIURakuRoyQpdRnx760yragIEVId3LcCRuRHBjEWMLB6OgoBSnSE6RiGrSYhoQYcuqNNeL0DB1pU1PG53oV81Lf1RAEFlIbL1KCVHrHXdCtFDSzvPRA03QEgY/AdgvGoQHSyEOLW7XLFLw8BqW0OtEb5qKEENKP8anV+6gvbmkqFnVSfGn4cfs6tHQjxwZD8FNXIpgnw1nTDeix7pxI8j1XCVKmacG0YiUhqogBB9lsFq7XYWWfi4SiVJcjotSonVSlXoSQ7iU1MITVY6aa7SDtZ+fOXfiHf/gndf+pT/0VxsdXzbv91q3b8J3v3I4XXtgJXTdwyimb8KY3XYcNG9a37JjJXESIUvdSdmDGoJtVSg8kk6oSo/q2Ks+qRhegOdvaMz07SCaEzIVxg3Q6vRqXuvGYF4tpxWDFEurnWKTbox5ocJzyjsXdCEUpQgghpIDnefj2t2/Dbbf9AK5bn/hwzz3348Ybb8JVV12GP/iD31GdM7/85X/DRz/61/gf/+P9eNnLTm36cZPOGuD7TgaZ5+9D4NnQpESwCpqVwOBJV/TFYJqQXoZxg3RLvEo/ewcCZ57y9D6NS7ViuetrJbHO6LP3pNVQlCKEEEIKfO5zX8TExCH82Z/9Mf7mbz6tfp6PQ4cm8c///FVs2rQBb3/7W6FpGgYHB/Dbv/1b+MM//BN8/vP/iL/927+AZVktew19hWeH2UtVli9r22UO8H3Phju1B5phwRrdoO4rn1MeN9+MNSGkO2DcIIuiwbGoXiTeSNzRpIFSrfL0+eJSm4672cwXy3MFGyrdSmL01CsoTDURilKEEEJIgYsuugBnnrkZep0+B3fe+UOVNi2PkwuLIolEHOeffx7+8z/vxE9/+jBe85rzm3jU/YfMWsqMrhpE1iink/WyXfHnerZdjEg03wBfd2V4JX5VgRKkKksBF1MGSAjpbBg3SDPiVtNYZHl6xxx3k5g3lhsaAteG72Q5idRkKEoRQgghBc4++4xFbf/YY4+r+5NP3jRn3cknb1QXF48++jgvLhqMlBZIiUG93hj1buvlphoywFeDe61zjGoJIc2DcYM0I251Ct163I2I5SJKSTwP7O73bOp0KEoRQgghS8D3fezZs0/9PD4+Nmf9qlXhsl279sy7n9tu+77yIqmGbYcm3OJTUq9XieC5fu11Xu11tTq/+HU8JvB9BH6AlBmUfnf1AKbpQ9ObMMMoLZ4XxFvUtq7pI6cH0HwbWpWXrPs2Aj1A0gxXyraSHKHr4Wsu4uuAU9CkrBrr/cJ+THPx703gV5nplS6CNdphN4Og4LURxfcaJ8Q1cl+NQr4H8rn2mpzl5rnNf+3uEp5jMecg0ty40Y7YsfBjXfX65L5seY34Ubm8WpypJ/YUKYomEodqkWr3le9i4laDKca3ajFrwbjUwONu+tigke9LEJRuKs4uIsZGY6T8XBnT6o1xvifxPYBj51WcFzQv2n3PVeslLlV+9zohdtR7/mn3V7NhZDJZ3HLLd/DQQ49gamoKY2MrceGFW3DttVfDNOt7mU888TTuu+/HeOqpZzA5eRimaeC449aomYorr7wEhtGdaYmEEEIaz8zMjAq2Un6RSoVd3qIMDITLJCbNRzabw+HDR6quc5zQq+GBBx7AwED9s5AZu/agPDvPumocyfrIOws/xnYDdSsOV2TwpM/sgX4Q0Loka8j0HKSMHAIvDdSwyZAUf/Pw4+r1JZGG5uWhB+XjDN93ocfD1xzzJquuD+DAmNxatYxisRTf6+zu1r3XXpXW4Nkqy5bKVKS7UKcQMwIcPrALTz6mNfV9TjagXX2j29kXz3mkM+JGO2JHPWLDvj0v4hGVOaMvGHNyFXEl587drp7YU3qeXHjB3h3RpvUYbr5mzGpGXKpFp40NmvW+ZCviZWV8rDfGmXBU+WA2O3tOyOizjzV16cxnYfvWR2DFqniFtTl21Bs3zF4RpG644W/Ui77++veoVqrSZlWMAp95Zgc+8IHrF6zzvv/+B/H3f/8lnHjiCXjve/8b1q9fh6mpadWq9V/+5d/w6KM/xx/90e9TmCKEEKKwC+ncteJCcUIkn5/fBDSZTGB0dMW8s91btmzB8PBw3cc2ma49uzyZWdxM+M5DLqayCz8mnfeRzs1eQMiMoogkybWvrNmBrhOJrzlnwTIFM56Ck53GkYP7YFgDgFU+EPRcGxn7oPrZsFbOXe/Y8IIZxI89G1ZyaNnH3I73ejAxd2A6WBDiGsFwsv0XK5UMxnw8HwCnn30+DPEfaRIrU81/7SsHF/8c9QglpDVxox2xYyEkS0MiwLmv3AIjkhBQK+YcrlheLc7UE3tKz3+0/Vk3ncx8MasZcakWnTY2aMX7IvGyMj7WG+OGkzrWn/ZKlTFV7bErUhpMw0AqNYhWsNjYUW/caP8noQHcfPM3sXv3Hnzwg7+PU089WS0777xzceDABL761ZuVoeCVV1467z7EcFACwR/+4e+qLCshkUjgXe96O/bu3Ydt257Affc9gEsuubAlr4kQQsjied/7PrRg56Mor3nNq/E7v/OuJT1XLGaV2oHPl7Icj88/c3XNNVepW61gfuONn1Hxqd6sX8EolJdVXWcs7qJDvEv1Oh6j6ZKKXz6rLbOgMujshIFnvVjJ+i7glKmrmBSrW8UgrWheHPiqE1/p9wKB76hlykC2Qe9Nq99rLTJTW0Q3GiemNHJfjUK+B5IBIoJUM0UpQ6a+m4y5hOdYzDmom+jGuNGO2FEPkgQgglRUlKoVcyqXV4sz9cSe+c5JZG7MkvjjuXPfq2bEpZrH0kFjg3ljudpAW/b7Ip/NyphWb4wzDB2pwZGyZSORiYvRgdbGysXGjnrPP+3/JCwTSV29++77sWLFCM466+Vl66Srxde+9u+4/fY7FhSlhoaGcP75rywJUlHOPvtMPP30s9i27UmKUoQQ0sG89rVbkE7XX2KyadOJS34uKYmQYCsXEZlMZk4pxsxMRt0vZpaadB+BZ89x0pDBvZTnKH8VW7r2zPVUMGLJru1WREgvwbhB+gGJNxJ3JCbBq27c3c9xqVosLy4nzafrRant259SWU4nnbShrK2qMDQ0iGOPPQb79u1XtzVrjq25n1e+8mx1q4ZkTIUsvc6aEEJI83nTm65r2XPJjPDxx6/Bzp27VGaulH9HKc68r1t3fMuOiXTOAD8+cqzynxg/5SIYsVSNMsAu71ZESA/AuEH6AYk3q192ZR3l6f0VlyjWdQZdL0rt2rVb3a9atarqeulsIYKUdLGYT5Saj/37X1L3p512SkM7YchNZlGX081EHqvc9pvcCYa0Fvl7qhl2/l37Bvlby6mgnvPBcs8d7KDU2FbgcnHx7LPPzbm4eOaZ50rbkM7Bzc80ZFDergF+teOX3z03r7wxdDPWdxcVhHQTjBukVXGqknbEhsrXEo1XYUlce4UwinWdQdeLUkePTpV1q6ikmBZb3G4pF28//enDykhQ0nsb2QlDLipffPFFtWwhI/ZaSJbY0awPwwxr1ElvIB1MDuzbhe2PlHcwIb2L5zrYm9RhWQt/l5d77mAHpcZx+eUXq4mIe+/9sfq5mLGby+Xxk5/8DCtXjuJVr3pFuw+TRAbHB574QTgjWgOZEZUBar3CVEccfxDA8tOhWWs8VffxE0JaD+MGaWWc6rjXEolX4tXUCa+l09/HfqDrRSnbthfoYmGUbbdY/uM/vocjR47ij/7ofYjH4w3thFHMVrjggguWbB6ZzWbx4qSLeCK5pMeTzs2aCR4BNp/b3A4/pHPI57I4YaWJZHLh7/Jyzx3soNQ4xIfw7W9/K770pX/Bl7/8b3jjG39RxZubbvoapqfTKnYUjW1J+1EztHYWumFBM2LVPSWUB5TXXccfBNCcPHTd6ujjJ4QwbpDejlMLvpZCvJJud8p0vUteC2kuXX+1G4vFFuhi4ZVttxieeOJpfOtb38Vv/Mav4swzN9f1mMV2wpAsh8V2xogijxM9jsJF76G3oMMP6Rzk77yYc8Fyzh292kGpEfzwhz/CF77wz2XL3v/+P1b3ki373ve+c85jLrvsIjWz/Z3v3Ibf//3/oTqlnHzyJnz0ox/Cxo1LN8QlzUMGx4Y1d6JJjRhqeEp06vH7nlMa0AcI1O9ubnp2W5YdENJUujlupNPpsmuoqZnybneq1fxAa1rNk96KUzVfS+BD90zAioVdALvstZDm0PVXJiMjw2XdKiqRzhbR7epFar0/+cn/i1/8xdfh6quvaMCREkII6XQuvvg16rZYxP+DHiCk1YgANXNwB3zPRdICMvmDqtPfgSfuhF4o6++E0ghCeplujRsiSH33u98tXSsJ+QrLScnevuzKayhMEUKaSteLUuvWrVX3Bw9OVF1/8ODiu1i8+OJufOxjn8DVV1+uUmoJIYQQMj9DCR1DiahgEuDgQR3jIwb0GiX2rSYf03E0psNK6DCtuX5srqHDgY5jRnTEU51xzPMdv+cEyMGDaUrmpIZYoMH3NAwNDahZac+x4Xt5rB4KOvL1EELah2RIiSAl1STFihLDme007ti2sglxa1SjdBprVvTGOa7b49RCryUIpJJJg5nQ4bnd81pIc+l6B+XNm0+DZZnYseN5BPIpjyB12dI575hjxuvuvBcKUn+LK6+8pEyQOnRoEnfddW/Dj58QQgghZDlohgFN06HrJnRpb23FYVpxGNbirQsIIf2FCFKJRELd4vHZm7UE6xNCCOlLUUqMxS+++EJlRr5167ayddLVQoSqaPldJpPF//7ff4fPf/4fVQeraoLUFVdcgje96bqydS+9dBDf/vZtaDXiQ7V//34aExNCqsJzBCGEEEIIIaRb6fryPeEtb/llPPnk0/jiF7+M669/DzZsWK8Eqltv/Q7OOONlqt1qkccffwKPPfa4+vmqqy4rmQnu2rVHCVKO42Lfvpfwmc98oew52nHBt2PHDmzfvh25XE7NXmzevBmbNm1q+XEQQjqT5557Dk899RTPEYQsEilrW8zyTqN4nJ6Thy8m5x4QaDoCvzxjnBBCSHfS7XGq1jEHgQ/fd+FK/Cp0kyakJ0SpVCqlulXccst38NnP3oipqWnVbvUNb7ga1157NYyIl8Upp2zC6tXjGBwcwNq1x5WW//SnD6tyP+HBBx+q+jyrVo2hVYgIJoKUZHONjIwoM8KtW7diaGhI3YrIxejU1Axi+XzLjo20ps4/n8vh6NGjZZ9f0rvY+RxyA/UZEbuui5mZGfz85z+HpmkYGxtT5wg5Z4yPj2N4eHGNHQjpFzTdhBVPwslnlUl4NWS9bNcNx++74hkVDuoDI/Tq0A1TnRcIIYR0H90epxZ8LcpUyoGfywCa1jWvhTSXnvkEiDD1tre9Vd3mY3R0BT75yY/NWS7+UZ1kai7GgyI4iSCVyXuqa86RI4exf3IGjj574RoEFlYNJ9t6rKTxeJ6GuAkMxzUYBi8u+oJ4EjOuhUxFO+ZqeJ6PdFYMSPMYHh5R4rWI1RMTE+rcQVGKkOrEEgPYeO5VqkNdLWRwLNt1w/HnM9N47tE7YMaS0Nw0UsmVoaeUSS8YQgjpRro9Ti30WiS79/ALj2L0xHNUvOqW10KaS8+IUr2GiGxSjiPZDyJIiUCVTKYwMjKKRKJchJLlpLfwXBfxRBIjIytgmPyakiqfj3hSTTbJuWEgYSkxSs4Zcu4ghNSm2we/lccfClCzkxfipSllEd1a5kEIaS22PXueyFd03yPtodvj1HyvRbJ7DSuBeHJYZfYS0hNG572KZDqIP4yk4EuGlNyffOrLMDjEDAhCCBCLx3HSKaerc8Pk5KS6l3MGs6QI6R+KpRGBKuVz4OYycHIzpZuUS7A0ghBSDbGHkIksEaVkElxumZmZ0s1xHCSTSZi0kSCENBmOUjoYMSyWkhwp2ZMMKQpShJAoJ6zfiOGRFYhreYyOjlKQIqTPKJZGeG6+rBwiCksjCCHVGBwcxOtf/3rlY1pkssJCQASp1MBgG46OENJPUJTqcESUEg+pypI9QggRBgaHsHJgRM1mEkL6DxGcfC/OcghCyJKEqSiusbCvJSGENBqW7xFCCCGEEEIIIYSQlsPpNEIIIYQQsizs3ExPdIsihJBegudm0g1QlCKEEEIIIcu66Hnuke/DyWdrbiOG6+J/xYsfQghpDTw3k26BohQhhBBCCFkyMgsvFz26YcGwYnPWe46t1s83W08IIaSx8NxMugWKUoQQQgghZNnIRY9p/f/ZuxM4Ocoyf+C/qupzzkwmkzuEJAQI4b4k4Q6HAUUUVJBdjpVjPRZR19tVYV39u6yCB+6yRlFQFgFBQAkICYTLAAIhJJOAkEDuazLJnH1W1f/zvD3V093T3dMz03f/vvn0pydV1dXV1dX11vvU+z6vN+08y4wUfXuIiIjnZip/THRORERERERERERFx5ZSRERElFWTf+T3sCxTR7dbU6/VDd4DK6RS7+uApcPtAjwuwO3WhszX7dgVZ4NPh38UxxIR1abRlD1U3ufmUpdXVJ54JBARERERERERUdExKEVEREREREREREXH7ntERERENGZmNDKi6UREVHg8N1O5Y1CKiIiIiEZN113weP0IhwIwo+G0y8h8WY6IiIqD52aqFDwCiYiIiGpMKNAHy4pmnC+VFK+/Pqd1yXLzTlyct/UREVXq+bCc8NxMlYJBKSIiIqIaq4Ctf/lxdfc8E7l7LpWZkQSmiIgqTSHOh+WkEreZag+DUkREREQ1RO6aSwXMcHlguNxp84zI/Gx314mIqgHPh0Slx6AUERERUQ2SCpjb40s7L1P+ESKiasTzIVHp6CV8byIiIiIiIiIiqlFsKUVEREQZNftHd//KNHX4XBqa/DoMg/fACmmk+9pt6vAYmnqN26UNmW9YGmBoaPLpqBvl91+NTNMq9SYQVa3RljVjxfNhcfHagNLhkUBEREREREREREXHoBQRERERERERERUdu+8RERER1aBoJDyi6URE1YrnQ6LSYVCKiIiIqIbohgser18Ncx6NRtIuI/NlOSKiasbzIVHp8ddFREREVEN8/nocc8p5sMxoxmWkAibLERFVM54PiUqPQSkiIiKiGsMKFhFRDM+HRKXFROdERERERERERFR0DEoREREREREREVHRsfseEREREdWsYKCP+WSIiIpwro2GQ4iEgwj0dkM3jKT5PNfWLgaliIiIiKhmK0mrnn9MjbyViYy8JYmQ3R5vUbeNiKjazrWhYD8igW7s3rUDmqalPdcyMFV7GJQiIiIiopokLaQkIOVyueFye4bMj0bCan6sJVVhglKB/l6Yphn/v8tMzq7hMgzU1TcU5L2JqPRqobVm4rnWdnvg89dB0/QM51qqNQxKEREREVFNk4CU2+NLOy8ajRTsfSUgtXLFYwgGB1tqeV3JrQf8fj8WnXM+A1NENd5as9IDU8LldsOKuNT5NjEoVehzLZU3BqWIiIiIiEpAWkhJQEpaD7gHWmr5PINBqUg4jEAggGhCSyoiqtXWmkTViUEpIiIiyqilbnQD9ZqmDp9bU683DA72W0i1tK9Tu7qlMgwD/rrcWxS5TR0el6ZaJ3ncyS2UhG5psFwamv06/HWx/VwIEpDyeGMttbwJQSkRibD1AFWf0ZYt1cY5B/n93vg5IFE4pCEQiKpzUEOB91m+z6+ZzrWWDvhcGjRdS3uuLfTnpPLDoBQRERERlb10Xd1S+Xx+LDjjvFFXnIiIahHPr1RKDEoRERERUUV2dUsUiYTV/Gx3+omIaCieX6mUGJQiIiIiooqR2NUt1WgT5UqFayTTiYiqUSHOr6ndkU3JoxUOJiU657m2tjEoRUREREQ1SXKkSJcUaQGQqcIl82U5IiIa27k2EOhXgSl51rTk/Hk819YuBqWIiIhqyPj64iQQNaM6/B4N4yX5totJSwupVva1y9RVklwZnS41GbjQbQ1WRMO4Oh1NuR7n9U04//wPZB3dzmUYqKtvgBmN5n0/O5/JQERtvwiFkDT6HlElK1aZU6nSnQMSyXSZP6LzWrmcX9Oca0PhENa8/gqOOPp4GIYr7bmWag+DUkRERERUs0pZCZJKmN8vrQcCGUfZk/myHBFVn1o6B8i51uv1qUdTYzMMF0MRFFM1R0J/fwAPPPAI/va319Dd3Y3W1vE45ZQFuOCCxXCN4ICPRqN4+OGleOGFl9DZ2Ymmpia8733H4+KLL4DPl75/LRERERHRaCppi845P6eWWkRUfXgOIKqSoJQEpG666T/R19eH66+/DrNmzcTq1Wtx++134O23N+BLX7oeuq7nFJC6+eafYuPG9/CZz1yNww+fhw0b3sVtty3BunVv4lvf+gp8Pm8RPk9/fGSDYDCI/n5LNRl3hCNheAZGRZAcCIH+PlimHZ+vGxq8Xv/A37o6ifn9dUnvIf14rSwnP30gGj/cMpnWG9su+dtKeU1s25ztUp+3rze+XCgUUJ+lt7cLZsSEpuvw+b3wePwqIR5gq79dbhe8Pp96XSgUVM+RaBhulyfte6l1B4MqeZ+8RzAgjyB6+7oQDoUQDIRgGBpga4ha4fjIEx6vFw0Njaira0Bj0zj1HhLdlz7Pu3ftQF9PL2zLUsn5LMuCZgAeVyx46fK5MXHilKTP37WvE9FIbJ+GIwG17dFIFIbuUp9V9mdDY5P6/ru79mHv3j1wezzx77urax+i4Sh6e/cj2B+MvaeuDx4P4YA61nVdQ2NDS2xaqA+hUAjhYBi6AdQ3NMHjjm1j1JQ7MhY8Hi8iZhRGyilB9qGuG2p/mLaJhvpGdHfvV9+N6Ovvgm3GkhZaMNX+k+SFLsOlti0cCcHj9sK2THh9dWpbNUODZmtqGcNtqPeW7zUcDiHQHwQ0C1bUjvczN60ILNtSyRAbGprQ39eHSDg0eIzL5/fJPvKrfSrb2jYptt+HHn+6+u669u+DJds0sA7n2Auq4xdwuQ31fScek5JrxOP1JL1GOMeds+5sv5PU3538ThK3MXUd6X5jaj3BfrUP+vp61HnLY+vq2SH98evqhr6OiKgaZOrSVsqubnItM9pKJSubRLUtn+eAsZyLyvX8StWvKoJS99//R2zdug1f/vLncMghc9W0E044Frt3d+D//u9+LF/+DM4558xh1/OXvzyF9vb1uOqqy3DssUepafPmHYIrr/wEfvKT2/Hgg3/CZZd9tOABqWeffVYFo4RUNENRO97nVoJT+zr3oqW1Verx2LN7h6qk2/KfARo0eH1+FZiQgMLU6QdgwamLkirGf1v5nAqIZOIkmcs27KcEZ05YcOqQ9crJUAI2gUAfbHtwu+LbppqgujBpylTI7N07t6sAgWXbCAUCMOXvpPfV1PbIMkKXYIYe+4yyfhWUsmz1GqnUO8EMZz8Yhg7TtBAOBeH2eFWQQVXgU7YtG1mnv65eBZD8dX40NDVj+5bNsO3koEeq+oZG1VJP3kq2r6+vN/ZdqbdO//4SiJD3k2DXti2bVFCqdcJE9V1s27wJUTMKyxwMQORdYtJBOxYckuNIPqvsTwnoxT5D7vuv2OrrG2C43EP2sXyOpnHjsHPbVnXsyLGoa5o6fkLBfnVc2APHTl19vQqiyTEpQTEJshm6AZ+/Tv22hLxOgpoen1cd0xPaJg1piuz8TkTi706Cdx27d8WPa2f7EteR+htzfmevvPgCdmzbrALx6ntxaUktQqVV52mnncbAFBFVlXLt5iLXPU89uVRtVyayXdIaggEoIirHc1G5nl+pNlR8UCoQCOLpp5/HuHHNOOqow5PmnXbaQtxzzx/w2GPLhg1KSQX18ceXqeCHdPtLdNxxR6OhoR7Ll6/ARz96ITweqewWhgQeJCAlFUy3260qyVrEjldSpfVRJBJSlWPDHZvmBA0klqDiBLa0JvKo4IIEsaSFUGKQR/6WirG8h8s99LNEIxHVgkNq5z45+WRYJtZCaeh6naCK/Iv9HZvvbJvbJa1oJAAVhK3Zat9L6xYRkeyeWnILLVmX4TJghWMBIEPXB4JdUhE3EA7rMHQJSkXV9yctZ5z3khZVEtyR5eUhwT1d0+UtMoSEMtHUPg/bIbXt8ndiIDATeU9ZXv09sLy8v/qMCcGIRLHggrTYiqjXyp0JeT9dk/e01OfL8NLkLVbDrMY+dyoVZJJ/ljXkNdpAwEU214LM19R3YFp2bNsx0IppIHBWLiSA5GyPBDhd6rhxx1tJyjElARwJHjn7RFqYyTEq8yRoKZ/V+fjy+5P9pI5JFVSU1lqa+m05LQml9ZQEOeX7UfN8XtXCLtPvJPF3F42E1W9Djn21DXKcWlZ8Hel+Y0m/M9WK0K9e43MPBqXkQkLOIdkCykRElahcu7nI9khFTsoNuZGUSspxmZ9tu4mISnkuKtfzK9WGig9Ktbe/qSphBx00a8iwko2NDZg8eRJ27NipHlOmTM64ns2bt6Kzcx9mzpwBvz85d5QEOmbPPhBvvNGON9/8O448cj4KTU4mXq9XVTxNLSFoE4k1nZRgi0sq1BKs0GUUGFesdY0EQUwzfiLKFjSQinGs61QaEpQaZpnE7kLJ63UNtNLSVWXbCQo42yafJXHYZVnW2V5ZVoJZztxYwE1XwSRTj50kpeWTnDBluuwDQw+qAIsWjS0n31fie0lgTtdtFQiSIFase5u0nsr94lAOLWcfy/ZKACAe2IpHA53PEwuaycN5rxgJ5gx8RvVdxYJlqVSAQ7ZPbbcW36fSNc7ZH6mjVsvysg2J64v9HGRbkj+nCvKpfWQhOnB8OMeOtDRL/L4w0C1UtUCztIF9MLiM8/qxiAeNxrgu2W/O9jhdGOV3lNjqTwI9Ksgq34Omq+NO5su8xO9KBUrl2Bo4fuWYjH0fg69J3Z/yrLp8pvxeUn8nzm9Kvh7VNXJgG53tS1xHpt+Y+oxGrOujBDc97thnzfSeRETVopwrRFI+SAvXdDK1PCAiKpdzUTmfX6m6VXxQasuWrep5woQJaee3tbWqgNSWLduyBqVkvrN8OhMmtMaXyxaUWrr0CSxd+mTaeZIzx6kwOg+piCdWIJ1piY9IWFrMxCrb8rcpuXrCERUHUV3dJN+O5BZyglK2FQ+4yPyoGUZ/f5+qiAv5W1ppRDI0v5QouhmNqEBPtn7Fso5067Usl9pG2Q5Yg4HCxG2T+dINLbaNg9sr8xPjNLHgTmw/OF3lpPWQbdnqs+mmGX+Ns1zqfpDl5CGviXUTlG0bWTupWIsnWX/sWXXzctaRsi617oFp6nvTYp/NabGlvi/EtjGd2Pc5+HmEfN+yJ+X9dZmZun2qNVby+mLrH/oezjYkvr/zt6zHadEVW86OBd8G9rnsv1gwDXkz0u8ik8SulLLfEo8r4RwLUfntyGfRE34n8ePIGuhZaQ85JlN/W2qevG5gv0gUMPX3kvQ7US2nBn936ndmmdBMPWn7nHWk+40J+b8ZCavl5Zwix5XXcMePFee84Zxj0mHQioiIiIiIykHFB6W6urrVc319+twpTk4VZ7nM6+kaWE992vnO+odbj3Qn3Ldvf9p5TiunlStXqveRiuPmzZvVNKeFhiSk3r17d6yLj8pFFAuCOMJSUQ2H0NW5W7WuCKtEyRJwGQzGyCPY3xuvfPbs34cN61fFuvQNrKN7/161/sQWH45YZTes1hMO9GdcRtadbr2yHbJd0rLE1i1YAy3Y4tsW6FOfqW+goq0+w0DTn8SE7g55jQqSDQQvJBePCtZJ16ZoJOk1ajkVOIm9V2jgvWIPE6GB7RppVEXti1BArVu6efV0dWZbOP6n6qIVTf78UIGq5FZ9SftWumwOfJfyeiHfdyzPlCnpxNO9adptzriJAwGyoa+JBd4SP4v8L9bVUIKUoby0akp50zytJnm/y76S48NpQen8lrq79qrPI8nW5Xfi7Gt1vCasQ44d1aJu4PhyWt85r3F+B/bAcSXT9nXsTPq9JP5OROLvTv3OggFE9dBgINWy4utI9xuL/866OlUXvc7d29Vruwda36nPPhCMevnll1Vry3QkFxVVt9aG4Qf3KLRoVEedR8P4Bh0uV+m3p5pxX5d2P7tMHV4X4Hdr8HmGlu+6pcF0AePrdTSXwW+TqBBlB89DpVcJ5yIeJ1SVQSmpoIl0gRMh3bUSl8u8nsgw63HltB7p+tfSMi7De8Qq9AsWLEBTU1O8tcLChQvj6+/p6VEVRkkkl65CKfNlG6ZOnaoqqvK3LC+vV7mGBgIwsn4nyNXW1qbeo7GxMb4OmZ7pPWRed3cs+CbrybSM9ElOt16nQp24XcLZNllePvu4cbH9tH///vh7JLbycKjR1Twyal5s/8k6Zf0ScJTp8r7O6+T/Mj/1veQhSeQlGKgCTANBt1xJhV/eT9Ypz7JPZbvTrcMJMAj5XM53qwJpkUi8q1emwI58Bme+JKwW8n07+0rld0rpepj4nonTMr2P08UxtcVMrKukkdx6SuXiiuU8kmNGPkO8+14eWtwkBo3Gwjn+hew32Y+J+985DuS7kyC0LC/Ht8x35jlNmmVb5NhxPrdqeaW6g7rirxFyTMp0Oa5kfTNmzEj6vST+Tpz/O78757VOANrZBmcd6X5jQo53mb5v3z4ceOCBQ0YWdV534oknJr0ukfP7JiIiIiIiKqWKD0o5LQgy5QeKRmPTE1sapF+Pe5j1RHNaz/nnn6semSqCS5b8LF4JFSovUsL/nSBOci6iQU4+Ime+E3hI9xDOsiN9D2f6cMtkWm+mbUl8OOvNtIxjuPWM9jES6bbdCQSlBoQSgyzDbXemoFbqdqbbV6mvcd4zdT2Z1p86LXV7E9c71v1X6KBUtmMm9TPk8rtJt45cj+nE30vi7yTx/9l+v6nLJP7GEn9n6d4v9T0TX5co03QiIiIiIqJiqviaSXNzrEVQX19/2vnSOiZxuczrac7arcVZ/3DryZdMSeic4JgzP13LIqclULbWONneI3F6Lsuk28Z02+Vsm7w2MQDhtCBSXajUCGnJCbud9STmzEl8nfMapzWLMz/xvZxpzvzRdD9z8kil5pRKDaYkrjvxvVKfMwVh1IiLCd25JMCQ2IIn3bZn+jzppifu58RpzvKp+945jpyWVanLjFU+ugI6nylxnYnHR+o05//yO1G5nNIcFzLPafWXuH+c14jU4za1JWW634kzzVmP83rn/Z11DJcUV5aVVlGpQSkm0x092Z/PP/8iXn75NWzatBn9/QHVdfvgg+fg/PPfj0MOOSjja1evXotHHnkM7723SSWwl9fIaK2zZs0s6mcgotLJ1Jp+uFb2VLlYblA54rmIKk3FB6VmzJiunvfs6Ug7f8+evQPLTRtmPbH5u3enX09HR27rGSupBEvXI8kXk65rlFRepbWWUyEVqd2wJIggJx2nK5asL7Fb4nDvIZxuY9mSJWdab29vLJ9Vuu5hsm0yTUYKk25Mwgm6JCZ3zxZEcQI1zvY5QZLUbm3OezkjqKlR61LyBo1E4ght8nemlk6pnzd1dLnhgjCJQSmn66ITCEvXdS+TbO+TGlhKDIIlthZKbAnmBKec/+czMJUP6T5vaoBGjgXZj05XP+d34uwP5zPJZ3QCWon7ygk8JX6nznci05wueZl+J4m/u9QAs7N9ietI/Y05y8h0eW/pppeuJWO619HwfvSjn6O9fT0WLz4LV1/9j6qr5rvvvoc77rgb3/3uzbj22itx+uknD3ndihXPY8mSO3HuuYvwhS98Rn2Hd931e9x44w/w1a9+HocddkhJPg8RFYecb6Vrv9wIzVTpk/k8L1cflhtUTnguokpV8UGp+fMPhdvtwoYN78Yrzo6enl7s3LkLkya1ZR15TxxwwHSVC2rbth0qWbnkhnJIBXHjxvfg83lx6KEHF/TzyInitNNOyxp4kJOM041QKqXSuiuxQi6VVCeoJCedhoaGeML3XN/DOVkNt0ym9abbrsRtc7ZLSBDLeR+psMtrJOePE1CS5Z3KvJC/Jaglz/I65zVSuZfp6d7LWbfMl2c5WcuzdKmUZ3k43afkfaV7k+xjeb3k5ZGcQZIDS95DpklAbceOHSq/j5MY3gmWOd+N5AWaMmVK0uffu3dvPBghFyDyvk6eKXmtvI9c0Mg629vbcdJJJ6n1OeuUPEKyvOwf+QzynvJa53PL+pzAmZOzy/msTqsa+TxO3iMnICL/d4I1qd+X85lkm+S18t7O65x8Xk5Q0TlmnFxMzrEqv03Zb4k5q+RZ9rOzLbJ9TstGJ+jn/O3sW3l/Oa5kWecYd75nJw+TrNPJwZV6/Mp7yncn+1HmOetw9p2zT2Udzv5zji/5LM6xmMg57px1Z/udpP7u5HeS+P/UdaT+xoT8/5RTTlEDJkjeqHRd8dK9joYn3+XRRx+Byy+/ND5t3rxD8IUvfBpf/eqNuOuue3DCCceirm7wO9q7txO/+c3/Yc6cWbjiikvVcdvQUI9Pf/pqfPGL38Dtt9+BH/3oP5LOTURUXeR65gMf+MCw10zOdQ9VD5YbVE54LqJKVfFBKQkenX76KVi2bIVqBisFg+PZZ/+qKsOLF58dnybNan/+8yVobGzAddddlZSrR5a7554/4PnnV+Kcc86Mv+bVV19Hb2+fyhXl5J4qpJFUJjMlMs7ne4xmvSPZrkqtPI9m30+cODGn5SRAtH37dpWUOzHoMNrvO59SA22VqFT7MfVYH8vvV4Jw8nrmh8qfqVMn44gjDkszfQomTZqIHTt24p13NuLII+fH5y1f/oyqlJx22sKkmyJyE+Okk07AX/6yHC+//CpOPvmkon0OIio+VvJqE8sNKjc8F1ElqopxGC+55COYNm0KfvnLu/DWW2+rFg1/+9trePDBR1RBcdZZp8eXXbNmHV5/fQ2ee24l3ntvc9J6pOmt3N24994/4rXXVqv1rF//Fu688x7Vkuriiy8owacjIqJikG4WUiFIx+93RlVM7rYq5YmYO3fOkNfMnTtbPa9aFVuGiIiqC8sNIqKxq4pb7NJq4MYbv4YHHngEt922BN3dPWhtHY8PfnAxLrhgcVK/WUkiOHFim2omO316rIuPQ1ocfPWrN+Dhh5fit7+9F52d+1Ri8wULTsTFF39oSLcdIiKqftJ9c9euPaor6uzZs5KmS5dv0dbWOuR1EybEpm3Zsq2IW0tERKXGcoOIqMaCUk5gSvpzJ/bpTkfyRt166/czzpf+2zLyhTyIiIika7iMwCpdvOWGhkPymzkDEKTrhiwjMAnJXZfN0qVPYOnSJ9POC4dDww46Ua6cgSgqbbsrEfd1cdT6fq7Vz12O5UY5lh21/vug3PA4qS3RHL/nqglKERERFaIwlVyDU6ZMwsc//uGkeeFwLOF/plFsnHxfoVD2IZhlcI19+/annReJxF4rie1lIIRKIhedmzfHusmnGyWS8of7ujhqfT9LQIXKo9wox7Kj1n8flBseJ7WlL8dyg0EpIiKqGjfc8DV0dOzNefmTT34fPvOZazLOlxGSZCTX73znq/GRIh3OwBeZRrlx7g55vbHRM7MN2CGteLPd7V6wYIEambOSOJ9/4cKFTMhfYNzXxVHr+zmX1juVqBLLjXIsO2r990G54XFSW7pzLDd4JBARUdU49dQFarTUXM2Zc2DGeZKnUEZA+vrXv4jJkycNmS93n+WCSi6w+vv7h3TFkK4bYrgKgYzsKo9MhfmSJT9T71OJF29yF7RSt73ScF8XRy3v52r9zJVYbpRr2VHLvw/KHY+T2uHK8TvmkVBEtm0nRQylQJImbfJ//igpEY8NKuTx4ZyDnHNSNclXPsCHHnpUDcstFYtZs2ZmvKiSkV83bdqC3bs7cOCBByTNd+68z5gxLW/lRiXheax4uK+Lo9b3c7WWHdVWbpSq7Kj13wflhsdJbenOsdzgkVBEPT096nnGjBml3hQiInVOam5uLvVmlJ2HH35UJZBNrVhI4lrpLnHwwQfFpx199BGqcvHOOxuHVC7efntjfJnRYrlBROWGZUd5lxuCZQcRVVK5waBUEU2dOhVbtmxBY2OjGnXjS1/6N+zf34Vx45rxwx/+R6k3j8oIjw0q5PEhdyukcJBzEiV7+OGl+POfn8A3vjH0TvfKlS+jrW1CUuXirLNOV6MfPfvsX9Xfcm4XwWAIL730CsaPb8GJJx6Xt3KjkvA8Vjzc18VR6/uZZUdllBulKjtq/fdBueFxUlvsHMsNBqWKSJrsTp8+Pf5/j8cLt9ujnistgS0VFo8NKvTxwbvcQ/3pT4/hvvv+iAMOmI4///kvQ+Zv2LBRVS4StbaOxxVXXIpf/eq3uOuu3+Piiz+EcDiMO++8RyW6/cpXbognts1HuVFJeB4rHu7r4uB+ZtlRCeVGqcoO/j4oFzxOak9zDuUGg1JEREQAli17Rj1v3rxVPXK1aNFp6s72I48sxec+91UYho65c+fgxhu/htmzMyfEJSKiysZyg4ho7BiUIiIiAvCTn/xg1K+V/B9jzQFCRESVheUGEdHY6XlYBxERERERERER0YgwKEVEREREREREREXHoBQRERERERERERUdc0qV0Pnnn4NAIAi/31fqTaEyw2ODsuHxQZWAx2nxcF8XB/czUWb8fVAueJxQOppt23baOURERERERERERAXC7ntERERERERERFR0DEoREREREREREVHRMShFRERERERERERFx6AUEREREREREREVHUffK7JQKITnn38RL7/8GjZt2oz+/gDq6+tw8MFzcP7578chhxyU8bWrV6/FI488hvfe2wRdN9RrPvrRCzFr1syifgYqHDkeHnjgEfztb6+hu7sbra3jccopC3DBBYvhcvHnWs1kzIlVq97ACy+8hLff3oD9+7vg9XowY8Z0nHnmqTj11AVpX7djx07cd99DWLfuLUQiYUyfPg3nnXcOFiw4oeifgUjwPJZ/PT09+PWv78ZLL72K6667CqeffnLGZXlOGDmef4ny74YbvoaOjr1p502a1IZbbvl+0beJSofXBpQNj4Ai+9GPfo729vVYvPgsXH31P6KpqQnvvvse7rjjbnz3uzfj2muvTHuxuWLF81iy5E6ce+4ifOELn1HBrbvu+j1uvPEH+OpXP4/DDjukJJ+H8nuyvumm/0RfXx+uv/46FWyUQOTtt9+hLpK/9KXroets3FitHnroUfzhDw/j8MPn4Ytf/CymTJmEjo5O/P73D6hjYP36t1RlNNGmTVvw7/9+M2bNOgA33fR1NDU14vHHl+G2236B3bt348ILP1Cyz0O1ieex/Hv55VdVQCoaNYddlueE0eH5l6gwJk5sg2EYQ6ZPmDC+JNtDpcFrAxoOv/0ii0QiOProI3D55ZeqE7XP58W8eYfgC1/4NDRNw1133aN+uIn27u3Eb37zf5gzZxauuOJSNDTUq+jypz99tWplJT9oWS9Vtvvv/yO2bt2Ga665AoccMhcejwcnnHAsLrroQ+rEvXz5M6XeRCog+Q03NzepoPOBBx4Ar9eLadOm4IYbPqXOFc8884IKaDssy1K/fbnDf/31/4zJkyeirs6Piy66AMcccyTuv/9hbNmyraSfiWoPz2P5tWzZCtx55z0qIHLccUdlXZbnhNHj+ZeoML7xjS/ihz/87pDH1772hVJvGhURrw1oOAxKFdnUqZPTNgOfOnUKJk2aiGAwhHfe2Zg0T36ocsF02mkLVeDKIQGtk046QQWt5E4qVa5AIIinn34e48Y146ijDk+a53zvjz22rGTbR4U3fnyLOjf4fL6k6dKkWe7ei7VrBytF69a9ic2bt6oKkFSmEklrS6ksPf748iJtPRHPY4UwY8Y03HzzTep3PhyeE0aP518iosLgtQHlgt33iky652Xi93sH/rKTpr/++hr1PHfunCGvmTt3Nv7yl+VYtWoNTj75pDxvLRVLe/ubKvB40EGzkgKPorGxAZMnT1K5K+QxZcrkkm0nFc7ZZ5+RcZ7fH6so2QmnBvnNO+eAVM654vXX38j/hhJlwPNY/skd5VzxnDB6PP8SERUGrw0oFwxKlQlpCr5r1x7VnHH27FlJ07dt26H+bmtrHfK6CRNi09hMvLJt2bJVPU+YMCHtfPnu5WQt3zNP2LVnx45d6vnQQwcrqM5vPt0xI3ej3G63Stbb09OrCn2iQuN5rLR4TigMnn+JRm/58mexevUaVceReMS0aVNV65hFi05jDqEawWsDygWDUmVC+tP29fVj8eKzVc4ohySEi0ajKrJcV1c35HWSU0rIKAZUubq6upO+z1TOd+8sR7Wjt7cPa9a0qzwnic2eu7q6hjlm/OjqiqhjhpUiKgaex0qL54T84/mXaGzeeWeDyiN0wAHTVZBWBgOQgRuk3iM53BiYqn68NqBcMChVBiTodM89f1CjvXz84x9OmhcOxxKYpxu5QjhDaIZC4SJsKRVKOBwe5ns2kpaj2iHnBkDDpz71yaRmz865wTk2Mp0beMxQsfA8Vlo8J+Qfz79Eo3fddVeqLsjO70Fyt1122cewc+duvPrq63jiiafUzXiqbrw2oFwwKDUKN9zwNXR07M15+ZNPfh8+85lrMs6XkfXk7sF3vvNVNeJLIo/HrZ5N08wY0BJeryfn7aHyI902s3/PZtJyVBteeOFFPPvsX/G5z/2zSnic7tyQaZh459zAY4aKheex0uI5Ib94/qVaN9b6zvz5sUECUknXPQlKPffcSgalagCvDSgXDEqNgozQIk26czVnzoEZ5z3wwCNq5Lyvf/2LKtFbqvr6enWHQS5w+vv7h3Thky5/oqkpefQXqizO6D3O95lKvvvE5aj6rVmzDkuW3IWrr75cDZubqrm5GVu3bs9yzAQGluMxQ8XB81hp8ZyQPzz/EuW3vpNo4sQ29Sx5hKj68dqAcsGg1Ch89KMX5mU9Dz30qBo5TwJSs2bNTLuM9LWeNm0KNm3agt27O1Reg0TOHYzUu3hUWWbMmK6e9+zpSDt/zx5+z7Vk7dp1uPXW/8ZVV12GM844Je0yciy0t69Pe8xIgl0Z6UQS7jKfCRULz2OlxXNCfvD8S5Tf+s5QyaOMU3XjtQHlgtnlSuThhx/F0qVPDAlISeK/v//9naRljz76CPX8zjsbh6zn7bc3Ji1DlWn+/EPhdruwYcO7sBPHnQZU186dO3dh0qQ2jkpRA9auXY9bbvlvXHHFJUkVoq1bt2Hlyr/leF7YkLQMUTHwPFZaPCeMHc+/RPnx6KN/we2335F2nozEJ1gW1AZeG1AuGJQqgYcfXoo//3loQEqsXPmyajae6KyzTlfDC0tug8QfczAYwksvvaISB5544nFF237KP7/fh9NPP0XdYZXAZCLne2e/++ond95vueXnuPxyqRCdmjRvw4b3sHz5iqRCXu4qrVr1xpARS5555gWVlPf97z+raNtOxPNYafGcMDY8/xLlj9RR3nijHYFAcMi8ZctWxHNQUfXjtQHlgt33iuxPf3oM9933RzU06p///Jch8zds2Ii2tglJ01pbx+OKKy7Fr371W9x11+9x8cUfUiMU3HnnPSrC/JWv3BBPukmV65JLPoL169/CL395F66//joVsJST94MPPoIjjjhMBSeperW3v4kf/vA2NZS43K2XRyJp9pz4O5euvTIi1He/ezN+9rP/xbXXXonGxkbVJVgqStLsXs4zRMXE81jp8Jwwejz/EuWfBGylK+yll16E6dOnqvxUS5c+iddfX4Mjj5yPc89dVOpNpCLhtQENR7NT29FRyUeyuOiiC1TgKZWcxB95ZCnee28LDEPH3Llz1IXP7Nm5JRak8ifJ/mLJ719Dd3ePCkhKoskLLlgcH1KXqpM0c5eRaLKZN+9g/Nu/fTlp2vbtO3DffQ+pwl6GKZ8+fQrOO+8cLFzIO5BUGjyP5Y8EQz7/+a+nnTdhQit+8pMfDJnOc8LI8fxLlF9y8/zVV1fjxRdfVi0NpSyQXh8SnDr55JNw9tmnq+Au1Q5eG1A2DEoREREREREREVHRMURNRERERERERERFx6AUEREREREREREVHYNSRERERERERERUdAxKERERERERERFR0TEoRURERERERERERcegFBERERERERERFR2DUkREREREREREVHQMShERERERERERUdExKEVEREREREREREXHoBQRERERERERERUdg1JEZeBzn/scNE1Tj//6r//K6TU33XRT/DVTp07F5s2bC76dRERUHlhuEBHRSLDcoHKl2bZtl3ojiGrdli1bMGfOHEQiEUyePBnvvvsufD5fxuXvuusuXHnllervhoYGPPvsszjmmGOKuMVERFRKLDeIiGgkWG5QuWJLKaIyMGPGDFxxxRXq7507d+KOO+7IuOxTTz2Fa665Rv3tcrlw//33s4AgIqoxLDeIiGgkWG5QuWJLKaIy8c477+DQQw+FaZqYOXOm+r8UAona29tx8skno6urS/3/F7/4Ba699toSbTEREZUSyw0iIhoJlhtUjthSiqhMHHTQQfj4xz+u/t60aRN+97vfJc3fsWMHzj///HgB8Y1vfIMFBBFRDWO5QUREI8Fyg8oRW0oRlZG1a9fiyCOPhPwsDznkEKxbtw66rqOvrw+nnXYaXnvtNbXcP/zDP+C3v/2tSjpIRES1i+UGERGNBMsNKjdsKUVURg4//HB86EMfUn+/9dZb+MMf/qCa115yySXxAuKMM85QfcBZQBAREcsNIiIaCZYbVG7YUoqozPztb3/DiSeeqP4+6qijsGDBAtx+++3q/4cddhheeOEFjBs3rsRbSURE5YLlBhERjQTLDSonDEoRlaFzzz0XTz75ZNI0Gbr1xRdfVEkJiYiIErHcICKikWC5QeWC3feIytA3v/nNpP/X19fjz3/+MwsIIiJKi+UGERGNBMsNKhcMShGVIUk2KA/HTTfdhOOOO66k20REROWL5QYREY0Eyw0qFwxKEZWZN998ExdeeCEsy4pPe/jhh3N+vSQovPnmm/Gxj30MBx54oEpQKI/33nuvQFtMRESVWm5EIhE88cQT+NznPqdGY5I75T6fTw0b/tnPflYNGU5ERNVlrPWNX/ziFyox+rx58zB+/Hi43W5MmjQJH/zgB1VrK6KRYE4pojKyc+dOlWjQCSA1NDSgt7dX/f3ss8/i1FNPHXYdH/7wh9MWKu+++64KUhERUfUYa7mxbNkynHPOOervGTNmxO+Sv/zyy9i+fTuamprw+OOPq/cgIqLKl4/6xqGHHooNGzbgiCOOwLRp01BXV4eNGzfilVdeUfP/9V//FT/84Q8L/EmoWrClFFGZ6OvrU3cXnALi8ssvx5133hmf/73vfS+n9Ugh82//9m946KGHsHXrVnXXgoiIqk8+yg3puvHRj34Uf/3rX7F582b88Y9/VA+pbFx11VXo7u7GJz7xCdWiioiIKlu+6hu//vWvsW/fPtVD409/+hPuvfdeNaLfc889p1rc/uhHP8JLL71UsM9B1YUtpYjKgGma+NCHPoSlS5eq/y9atEjdmXa5XOoORHt7u5ouJ/vjjz9+ROuWUTR27drFllJERFWkkOWGIxAIYMqUKejq6sKKFStw+umn5/UzEBFRdZUb4uqrr8Ydd9yhAlzf+MY38rb9VL3YUoqoDHz605+OFxCHH344HnzwQdU3W3JBJZ7Mc717QURE1a0Y5Ybf78fBBx+s/paufEREVLmKVd+QdQqv1zvGLaZawaAUUYnJiX/JkiXq76lTp6rCorm5OT5fkgjOnTtX/S25opy7GEREVJuKVW7IXXWni4e0uiUiospUrHLj9ddfV135DMPA4sWL87T1VO0YlCIqod/+9rcq/5NobGxUBYQkmk0kJ/Wvfe1r6m/pbfv973+/JNtKRES1VW7Ie+3ZswdtbW1YuHBhHraeiIiqqdyQ3FKSf/Cyyy5T5cSxxx6L/v5+/M///A/mz59fgE9D1Yg5pYhK5KmnnlJ3ECR5rPTlfvTRR3HuueemXVaWkbsXMjS3FBpvvfUW5syZk9P7MKcUEVF1KFa5IaSFlIzE19nZqYb+vvbaa/P4SYiIqBrKjWuuuQa/+tWv4v+XUfh+/OMf45Of/KRaB1Eu2FKKqATWrFmDiy66KD6akVzwZyognL7ZX/nKV+LdKX7wgx8UbVuJiKi2yg0Zce/CCy9UAamPfexjDEgREVWgYpQbv/zlL1XLqt7eXqxatQqXXnoprrvuOjXCnwyWQZQLtpQiKrJt27bhpJNOwtatW9X/v/Od7+DGG28c9nWhUAizZs3Cjh074PF41HDd06dPH/Z1bClFRFTZilluBINBdVf9mWeewVlnnaXuqjNZLRFRZSl2fSNd66n/+I//wDe/+c1RfwaqHWwpRVREcvf5/PPPjxcQ0gc7lwJCSKXgS1/6kvo7HA7j5ptvLui2EhFRbZUbcjf94osvVgEpqcxIslsGpIiIKkup6xtXXHGFepYyhCgXbClFVOXYUoqIiIZjWRY+8YlP4L777sNRRx2Fp59+Gi0tLaXeLCIiqjDr16/HYYcdpuodUv8gGg5bShERERHVMLk/KXmjJCB1yCGH4IknnmBAioiIRmXFihXq+aCDDir1plCFYFCKiIiIqIb967/+K+644w6VR2T58uWYOHFiqTeJiIjK1Kuvvoo//vGPiEajQ+b9+c9/jueRktxSRLlg9z2iKiNJab/73e/G///aa6+pPCFHH310PDfIBz7wAXzrW98q4VYSEVE5kJwfH/7wh9XfZ555Jg444IC0y8kyznJERFS7HnroIXzkIx/BuHHjcNxxx2HSpEnYv38/3nrrLZUY3bnZ8cMf/rDUm0oVwlXqDSCi/NqzZw9eeumlIdNff/31+N+HHnpokbeKiIjK0b59++J/Sx6pTCQ3CINSRER04oknqtH8ZFAMCUQ9//zz0HUdU6dOxeWXX47rrrsOp5xySqk3kyoIW0oREREREREREVHRMacUEREREREREREVHYNSRERERERERERUdAxKERERERERERFR0TEoRURERERERERERcegFBERERERERERFR2DUkREREREREREVHQMShERERERERERUdExKEVEREREREREREXHoBQRERERERERERUdg1JERERERERERFR0DEoREREREREREVHRMShFRERERERERERFx6AUEREREREREREVHYNSRERERERERERUdAxKERERERERERFR0bmK/5a1y7IsbN++HY2NjdA0rdSbQ0Q1yrZt9PT0YOrUqdB13psoZyw3iKhcsOyoHCw7iKiSyg0GpYpICocZM2aUejOIiJQtW7Zg+vTppd4MyoLlBhGVG5Yd5Y9lBxFVUrnBoFQRyd0K50tpampCNBrFypUrsWDBArhc/CpoEI8NKuTx0d3drS5WnXMSVU65UUl4Hise7uviqPX9zLKjcpSi7Kj13wflhsdJbenOsdzgkVBETvNZKRycoFR9fb36mz9KSsRjg4pxfLBJf+WVG5WE57Hi4b4uDu7nGJYd5a8UZQd/H5QLHie1SRum3GCHcCIiIiIiIiIiKjoGpYiIiIiIiIiIqOgYlCIiIiIiIiIioqJjUIqIiIiIiIiIiIqOQSkiIiIiIiIiIio6prwnIqKa1tPTg1//+m689NKruO66q3D66SePajSZhx9eihdeeAmdnZ1qVJn3ve94XHzxBfD5fAXZbiIiIiKiSsegFBFRhent7UUwGERXV1fa4XQNw0BDQ0NJtq3SvPzyqyogFY2ao16HBKRuvvmn2LjxPXzmM1fj8MPnYcOGd3HbbUuwbt2b+Na3vgKfz5vX7SYiIiLKxzWlaWa+BuI1JRUDg1JERBV28fDYY49h586d2L59OzRNG7JMXV0dPvCBD/AiYhjLlq3AH//4Z9U66qWXXsFzz60c1Xr+8pen0N6+HldddRmOPfYoNW3evENw5ZWfwE9+cjsefPBPuOyyj+Z564mIiIjGdk356KOPor+/P+MyvKakYmBQioiogsjdrEAgoO5c1dfXQ9eTUwOGw2F1cZHtrhfFzJgxDTfffJPajxKUGg3btvH448vU93HKKQuS5h133NFoaKjH8uUr8NGPXgiPx52nLa9e3d3d6viVi2DpAlku6yIiIqo2cq0o5aTH41GPVLympGJhUIqIqAJJEERyFaUGpZyLCBreIYfMHfM6Nm/eis7OfZg5cwb8ft+Q72j27APxxhvtePPNv+PII+eP+f2q2YYNG7Bq1ap4IOmYY47BnDlzRr2u9vZ21c1Vfifz588fsi4GrYiIiKACUpnyX/KakoqhaoNScvd61ao3VNLZt9/egP37u+D1ejBjxnSceeapOPXU5Dva4oYbvoaOjr1p1zdpUhtuueX7RdhyIiKqFFu2bFPPbW2taedPmNAaXy5TUGrp0iewdOmTaeeFw6F43ip5VBLZXsuyctpuCRD99a9/VUnihTxLtwIJGI20y4C8ToJbch3Q0tKi/r9mzRr1txN82rhxI9atWxcPWh122GGYPXs2KtVI9jWNXq3v51r93MNhnYOIaGyqNij10EOP4g9/eFglnP3iFz+LKVMmoaOjE7///QO4/fY7sH79WyqPSKqJE9vU3e1UEyaMR6ns7bVK9t5UGmbUQn/YRmevBcPF758GdfdZCEWBqAV1jOi6jTrP0LxSVBySbF5IF8B06uvrBpbrzriOQCCIffv2p50XicTuUK5cuTLje5Qrqbxv3rxZ/Z2uRV8iCUJt27ZNLXf3H59Ef283DM3Ct3/4S0TtkV2quLQo6vQQLFvHnOnjcfHFF6sur88++6zah3LXV7ZLKpISkNq/fz927dqFd999F15vZSakH8m+ptGr9f3c19dX6k0oS6xzxPDatXKvKY2IDUu3h8wPRWw1v7PPQtTIz3fK46SytTYUpuyr2qBUJBJBc3MTvvCFz8SbI06bNgU33PApfPnL38Yzz7yAk09+H+bPn5f0um9844toa5tQoq0mIqJKEg5H1HO6ioVwRkfM1vxduv21tIzL2lJqwYIFFdfFzGlVsXDhwrSjRKZ2t9u0aRPcbjdOWnQB3JoJjxbBc73HY2t08oje16P34+i6dkiotseqx5MbggB8eHnDbPRZ9Wg1OnG8fze6zDp8dtE49d11dHTg8MMPx6RJk1CJRrKvafRqfT9Li0YainUOIqKxqdoSdfz4FtVcNrV/rFxEyJ2Mp57ag7Vr1w8pIIiIiHLlJC/PlATUqcSmSyDqOP/8c9UjUyVwyZKfqbKrEivB0pokl22fMmUK2trasHfvXnh1CzKo5F5zPLbbB6BfH1n3vX6MR3vYxiGeDWgy+hG2PXgrPAed9kRIpKrbthGw/fDp0XjrD+km2NjYWJH7eKT7msamlvdzLX7mXLDOQUQ0NlVbupx99hkZ5znJaO2hrRSJiCqCBEHCoSA0XYduDXbfY0LK4mpubs7araWvLzbMstxFJ2RNNC6twV555RWs3t2FfsuP9vCh6LVHNwT15ugMdJot8OkhBC1v0nrkbwlSzfP8XXUblNZZM2fOzOMnI6JawjoHVbpIhmvHTNOJ8q1qg1LZ7NixSz0feujQkZeWL38Wq1evwa5de9Sd2mnTpuK00xZi0aLTcsofMJKEtbkmzJS+t1RbzIFjQ56JEmmQPDge9HZHVSBE0zREU87kfr9f5cvJdG5hstr8mTFjmnrevbsj7Xwnka2zHGUfHU9aK337xa3otZtGHZByyOt7zYaMQatusw6fn9mF7du3q3xSO3bsSDtKHxFRpdc5cjWWOgevXSv1mtKrcltmuqkpgVVZLl/fK4+TyhaNjiynVK7nn5oLSvX29mHNmnYceOABOOqow4fMf+edDbjmmitwwAHT0dPTi8cfX4Zf//purF69VvUVH66QGEnC2lwTZkoyOKottmVhx7bNeE0KjBpMpkrZtbS0IhgIYNLkyer48LuTE53L+eT111/P+Homq80fKSskH9S2bTvU+d+5K+60Ztu48T11wXfooQeXdDvLrYWUBKSkDJSWZjI63urVq1VASlotSa6nCAy4ECjodgQtA1u3blU5pVpbW9V2yHZJN8JKy99FROWnnOocuRpLnYPXrpV7Tdk8LnMwUtd0rFu7Om/vx+OkstWNcHClXOscNReUuueeP6i48Kc+9UnVwiDRddddiUMOmRvvMy99xC+77GPYuXM3Xn31dTzxxFNYvPjsrOsfScLaXBNmyugEVFvk7oFcFhx7/AIYzOFAaY6PV19ZieMGjo/xIxwJg8lqR66/P4Cf/3wJGhsb1ChKTmVByhEpF6Rsef75lTjnnDPjr5FyQyolki/KyT1Fsi/7VQspCUj94tleWJqOZq0L//HyNuyzWtDgk30bSyBfSOO0Lix9ow89diM+dYalgmKS8Fy2j0EpIqqmOkeuxlLn4LUr5YLHSWUbX6A6R00dCS+88CKeffav+Nzn/jltV4pMCQilGa0UEM89t3LYAmKkCWtzSZjJ4TJrkxwbcrLmCZuGOz5crpEVEExWO3Jr1qzD66+vUX+fe+4izJ59YHze4sVnqXn33vtHtLaOV4ltN2x4F3feeY+6A37xxReUcMvLj+SQki570jJJAlJ+LYQQ/OhDE6K6H1H4i7IdPTAQ0urU+0urLQlGyXbJ9hERVVudIxdjrXPw2pVyweOkcrkKVOdw1VKFYsmSu3D11ZfjhBOOHdFrJ05sU887duws0NYREVGx7dnTgc9//utJ037xi9+ox4QJrfjJT34Qn37wwXNUWdDQUI/p06cOKXC/+tUb8PDDS/Hb396Lzs59KrH5ggUn4uKLPzRkRKZaJ3ftJXeTdNmTFlISkNpozkE/xpZDaqTk/eR9DzLeUgnPpYuLbBdbSRHRWLDOQUQ0MjURlFq7dh1uvfW/cdVVl+GMM04ZxRqY04mIqNq0tU3A3XcvyWlZ6SJx663fzzhfciF99KMXqgcNz0lqLl32pIVUsQNSju3WDPRadfj+wnq0tLQwIEVEY8I6BxHRyFV9drG1a9fjllv+G1dccUlS4bB16zasXPm3+P8fffQvuP32O9KuQ0bFEFOmTC7CFhMREVU/CUrts8eXLCDl6LfrMXHiRAakiGhMWOcgIhqdqg5KtbdL4fBzXH65FA6nJs3bsOE9LF++Iv7/YDCEN95oVyNZpFq2LLbcySe/rwhbTURERERElYJ1DiKi0ava7nvt7W/ihz+8DXV1fnXnQh6puURSR0Pq6upWTW4vvfQilTNERk1auvRJlcD2yCPnq+S2RERENDKSdFcSiUsS8UpskVTp209EhcM6BxHR2FRtUOq55/6KcDisHi++ONhkNtG8eQfH/77ggsWYOnUKXnzxZXWno7u7R+UIkYLiyisvw9lnnx4fApyIiIhys3HjRrz55psIBoMq6bskE5ecUpViw4YNaG9vr9jtJ6LCYp2DiGhsqjYo9alPfVI9cuXxeLBgwQnqQURERGMXCoWwbt069XdzczN6e3vVqHuST0oqYYYVhK2VNrGvYYdUwCmdnp4etb22baO1tVVtvwSo2tra2GKKiBTWOYiIxqZqg1JERERUWpFIRAV8ZGS73/y1DxYMNKELt76+HV32eDR6DQDREm+lgdNv6QG03iFzmrEXh2o96EUDPnmKpYJpHR0dqisfg1JEREREY8egFBERERWEtIaSLm/SwkgCUj4tiDB8CGjNMOFXj3IWQLPaXq8dhGU1qGCUfB7JLUVEREREY8cOy0RERFQQXq8Xhx12GDRNUy2kAA2bMRcBNKASyHbK9sp2d3Z2qs8hOaXYSoqIiIgoP9hSioiIiApm9uzZGDdunOqyJy2kKiUg5diNGei363DTQr/qhsiAFBEREVH+MChFREREBSW5mLrQChM+VKIA6jFx4gT4/eXd3ZCIiIio0rD7HhERERERERERFR2DUkREREREREREVHTsvlfh+vt6ETXNjPNdhoG6+srK30FERNWlp6cH0WgUtsuErhuo1M/Q1dWlRt5jXikiIsoX1ueo1jEoVeEnsKeeXIpAIJBxGcl/seic83kiIyKikti4cSPWrFmDQOBQmLqtRuTzeDyoJOFwBM899zJM04TP51Mj8M2ZM6fUm0VERBWO9TkiBqUqmkTU5QTmdrvhTnOBHwmH1fxskXciIqJCCYVCWLduHSzLgluLAlYQ0UAQHvihG5WRQcAyLZjBbtXSa8KECejt7UV7ezva2trYYoqIiMaE9TkiBqWqgpzAvN70IxpFIpGibw8REZFTBgWDQYwbNw4Lmt6CBR316MJ7xpHo1cajEjTYnTjQ8waWrm/GP55sqZEEOzo60N/fz6AUERHlBetzVMsYlCIiKhHmEKBqJ3d+pbtbX18fLN0LrxZEFI0IutoQ1Srj2A7ahtpmjx1WLb4kGCWfSXJLERERlRNeW1IlYlCqCgTDNizNHjI9HLYRitrY328halgl2TYaHdO0EAjb6Oy3YPC7q0qB/l6sXPEYgsHBHAJel5a0DHMIUKWT/FGzZs3C2rVr0YD9iMCPHfpBCFZIQErItso2TzXfQmdnJ+rr61VOKbaSIiIaXmcfr2Oz6e23VH1Nz0N9Lt21ZSqfz48FZ5wHf11pymHWcfJrfH1lpEIYDoNSREQlIAmT5aLB5XLD7Y7lEPB5BoNSzCFA1WL27Nmq+97/rt+BkN5cUQEpx17jAPSjHv+20IeWlhYGpIiIqCKuLRNFImE1X5YjKicMShERlZBcNHgGcgh4E4JSgjkEqFpIHqYeLQxLS58voxKEtHpMnNiqWjASERFVwrVlqmiU15ZUfhiUqgIS9R7JdCIiIiIiIioPrM9RLWNQqoJJojq5Y7u/pz9j1Fv6DRuGUfRtIyIiIiIiosyknib1NelWx/oc1SoGpSqYJD+WJMgdPZmbYcoJrFSJ7IiIiLq7u9XDNDVo1ZGPM04+l4zGJyPxMc8UERGNlNTTJPF4tjxPrM9RtWNQqgoCUw3gyAVERFR+ZLS6Z599VgVuenqOhKdO7ghXbl6pRBs2bEB7ezuCwaD6TDIi35w5c0q9WUREVGEYcKJax6AUEVEJJeYK0O3k0feIKr0V0Z49e9DW1qZaERlWCKG+fXBrDRXZDUGzQioAJXp6erB69WrYto3W1lb09vaqAJXzWYmIiEqF+amo0jAoRURUJjkErEjy6HuSM05yxxFVokBAju2oOo4ffDWA9zW/C5/dhe2eo9Cvj0flMXDpr/oArR915l5MD/cgiEZ8/H2WGl2wo6NDtQhjUIqIiEqB+amoUjEoRURUJjkExtUlJ9yRgJR00SWqRCqo6nKpVkS25oFbj8BEI8KeNlh6ZR/XEa0Z0agfbisIy6pXwSjpwie5pYiIiEqB+amoUjEoRURUIqkXBU31VZYFmmqatBiS7myWZcFv70dU86PDPRfhCg9ICfkM8lnawm+qvFn19fUqpxRbSRERUSkx4ESViEGpMiR3lRMj3N19yYnM2XqCiIgqwfjx43HIIYfg7o17EHE1V0VAytHlPgBB1GPhQi9aWloYkCIiopIL9CfXI1OxpRSVIwalyjAg9eijj6quAI5QdGiXiEXnnM/AFBERlb2Ghgb0GxZsvTpG3UsU1usxceJ4VS4TERGVOiC1csVjKqdUJpJTSrr4MTBF5YRBqTIjkW0JSHk8HvUQRsROGpFLJY/NEgEnIiIiIiKi2qpHSkDK5XLD7Y7VI1NH35P52VpSEZUCg1JlSgJSkjRVWPpgUEpEIulHUyAiIiIiIqLaJQEpjzd96+RMo/IRlRKz6hIRERERERERUdGxpRQREREVRCgUwu7du2FGXdCNUm9Neenu7lbd9evq6pgknYiIiGoWg1JERESUdxs3bsR7772HPXv2YN/+I+BvMlDHhODKhg0b0N7ejmAwqLrqz58/H3PmzCn1ZhEREREVHYNSRERElPdWQOvWrYNt26oVkG6FEOjqgEdrhmFUz6WHZoVUYGkkenp6sHr1arVvWltb1ai7EqBqa2tjiykiIiKqOdVzZVhlwuFw/O9Qyuh7RERE5Uy6pUmwxuVy4fH2CE5o2QKv2YUO79EIulpQPQxc938BQMs9MOWL7kVbXy9CWiM+fJyFxsZGdHR0qH3GoBQREY2VjLI3kulEpVa1QSm5A7lq1Rt44YWX8PbbG7B/fxe8Xg9mzJiOM888FaeeuiDt63bs2In77nsI69a9pX6406dPw3nnnYMFC04oynYbhqHyS8jFqROYCkWTl/H7/XAZTM5BRETlScox6ZbW2dkJTTfgQhiWqxER7wTYRiNqWQRNMHU/3HYQlhUr72VfyT4jospTqXUOqj5Sj/T5/AgGAxlH2ZP5shxROanaoNRDDz2KP/zhYRx++Dx88YufxZQpk9DR0Ynf//4B3H77HVi//i1cd91VSa/ZtGkL/v3fb8asWQfgppu+jqamRjz++DLcdtsvVKLWCy/8QMG3u6GhAR/4wAdgmmZ8WmeflbSMBKTq6hsKvi1ElF+B/t6k33YqH9z8bVNVkBY/hx12GHbs2KFaSJlGHfb75iJa4wEpIftA9sW4wJsqaFdfX69ySrGVFFFlqtQ6B1Uff10DFpxxXtZrTQlIyXJUXnUAo8a/l6oNSkUiETQ3N+ELX/iMugMppk2bghtu+BS+/OVv45lnXsDJJ78P8+fPU/Msy1IFh9ztuP76f1avFRdddAE2bnwP99//MI499mjMmDGtKIGpRFEjOShFRJVZGK1c8Zi6e5XJuMY6LDrnfAamqCrMnj0bb7/9Nv4ano6Iu4UBqQR9vpkI6/VYuNCDlpYWBqSIKlgl1zmo+tRyYKOS6wA+n18FFGv1+6vaoNT48S2quaxTODgkv4XcyXjqqT1Yu3Z9vIBYt+5NbN68FSeddEK8cHCcfvrJqlnu448vx7XXXlHUz0FE1XHnQ5aRwsjlcsPt9gxZTpruBwIBRLOsi/Krvz+ABx54BH/722sqMXdr63iccsoCXHDBYlVW5GrDhnfx5z//Be++u0l125AyZObMGbjwwvMxZ84s1DKPx4OQqxWWUV/qTSk7UaMBEyeOU13yiahysc5BtYwtgIaXSx0gGAxk3Y/VrmqDUmeffUbGeX5/rNCwB/OHY9WqNep57tzZQ5afOzc2TPPrr7+R/w0lopq48+GQwsjjTb5wdViRlARyVNCA1E03/Sf6+vpw/fXXYdasmVi9eq26ey05Qb70peuh6/qw63nppVfws5/9Qt3R/pd/uRYHHDAdu3fvwZ133oPvfOf/4dOf/iROPvmkonwmIiIqPtY5qFaxBdDIZKsDRDPkAKsVw19xV6EdO3ap50MPnRuftmXLNvU8YcKEIcuPG9cMt9ut7oD39PQWcUuJqFLufPj99UMeMr3W73yUq/vv/yO2bt2Ga665AoccMle16DnhhGNx0UUfUsGp5cufyXE9D6suGNdeeyUOOmi2Wo8kq/2Xf7lOzf+///uDmk9ERLWHdQ6qZrwOpnyp2pZSmfT29mHNmnYceOABOOqow+PTu7q61HN9ffrRb+rq/OjqiqCrqxuNjZkjvUuXPoGlS59MOy8cDqnnaDQaf0i/cnnOxoxmzyllmsnz9/UzB1Wls8woAiETe3vC0JlTrGwFeiMIRSxoLgO65h4y34SJUCSEfb2xux+xZU2YWqxw9rm0+LK2banghWlGYQ57ToidO5zlotGR3V8Y7pxT7QKBIJ5++nl18Z9YDojTTluIe+75Ax57bBnOOefMYdfV0bE3nj8kkXTJkLJCKhbd3T1DumgQEVF1K6c6R66Gq3OM5NokUz3FwfpKbV0HBxGu2TrO4H4arAMkikRkP1lJ+ymblrrB635zhHWAsSpUnaPmglJS2QA0fOpTn4SmDVYIw+FYpdHlSj9EppNfJBwOD1vZ2bdvf9p50l9UrFy5Uo22IyfuzZs3q2nZuon0h7PfZQ+kzA9GeFe+0lm2hX27t8BuB3StJhs0VoRIOIhIoBt2NIiwMfR0KgGmaCSMzW+9Gls+ZdmQnrysbUaw5vVX4M3QtNdhWxZ2bNuM1+Rspuuo8wyey3IhXdZqWXv7myox7UEHzUoqB4RUACZPnqSG6pbHlCmTs65LKhvS3W/r1u1J+aOkMiF3uSWXQqaKBxERVa9yqnPkarg6x0iuTeLbmWGdrK/U1nWw2+Or2TrOaPZTNj734PnEP8I6wFgVqs5RU0GpF154Ec8++1d87nP/PGREC48nFt2NRs2sUT7pmpGN9B1vaRmX9a7FggUL1Eg7zjoXLlyYNaluZ2/2KHJnyp2G0dx56A7URqS6UshdhFDExoTZJ0BPc/Ki8hDo68bW7duh+epgDBQiia2fpBAKBvpxwCHHqf/v3rUDPn9dvMBJXDYcDsKKBHDE0cejqbE56/vKXUi5lDv2+AUwXC6MbxhZoS5JvWvZli1bM3adEG1trSogJV0shgtKXXXVZfjRj27DL395l+oKKGWLk1NKWr6dddZpI0qaTkREla/c6hy5Gq7OMZJrk/g6M9RLUusrrItUx3VwIischK31Y9zMY+Cvb6rZOs5o9pOjya9nbSk1PuHvYihUnaM2jgQAa9asw5Ild+Hqqy9XeUNSNTc3qzvdfX39GZPixpbLfmI///xz1SPTl7Jkyc9UBcWppEgLqcT/p2O4sp+kw6HupL66oZSTuvzgff7sd0lqpflkJZG7TPLd1coJuxLphqHufmqarh4i8W5obLqmlnPmyUWbpsXuYEZsLeki1NA0GIYr6WIu43vrulpOHi7XyAqIWg+SSCum7F0n6pKWG66l1L//+zdw112/x7e//f34dBnJ76MfvVCNwDecQnTBKAdOF3XNNqHZlbXtxSD7JV/fa67pAGhsan0/1+rnrpY6Ry6Gq3OM5Nokvs4MdYzU6ayLVMd1cKLE62Cpz4QCfYhGQjCjYYSC/fHr4/j6dBe8w9RZK3k/WaapWkSlskwzaT8lMoyh+zVxmjHCOsBYFarOURM1k7Vr1+HWW/9b3dE+44xT0i4jdzHa29djz56OIfMkJ4h09ZD8I9n6dpdCf9/QUQ/C0eTmsB6vH8ecct6wgSkiKhwpZOS3GA4F4iNsWAktpURDYx1cKQU05Z/TJUK61qXjdKkYruuEWL/+LTX6ntytvvHGr6myZOfO3XjiiacQCoVU2eH1eoveBaMcBAIBbNq0CeN7+6G5hm+OXmskUPfiiz6V1Dgd5/iR+cMdQ7mmA6CxqfX9XOtdv2u9zkE0FhKQWv/y4yoYZYV6sGf3jiEpFOQ6ed6Ji6suMCXBNqcOIAG5dDxev1quVlX9J1+7dj1uueW/ccUVlyQVDjLq0pYt27FgwQnq/0cffQQef3wZ3nln45B1SL4QZ5lyE00Y9UCGmRR6QlBKorHyA5CmkkRUGGbCMK6GldD6KeFuiASFJTic+FtsTmmSO6HRjbp6XoQWmtMlItNoME6XiuG6TvT39+OnP/1fBIMhfO9718e7UUjrqX/8x0vwxS9+A+vWvaWCVdkqsIXoglFqGzduxNq1a1Vgr71vCuqbJ6OhobouMsdKM0M46aRm+P3+tPtv3bp1CAaD8Pl8mDVrFmbPHjp8vCPXdAA0NrW+n2u963et1zmIcrkOzjTdsqKqTmq4PNBMN9y+uqTWVbKsqrNa1VdnlSCbBNuyfTa9SluJ5aqqS1S5C3HLLT/H5ZdL4XBq0rwNG97Dc8/9NV5AzJ9/qLpzsWrVG6rLRmKT2WeeeUFFct///rNQriQg5RlIjmzpyS2lnFYZRFSEOx/G0Ls+TlPc1NaKDSn9wOvqa+/Oeyk45/fMXSf6c+o6sXr1WjWy3hFHHDYkqCSjJ0ml4rnnVmLlyr/h5JPfV9QuGKUk2/zmm2+qvyWgopkWuvd3wq3bcGVoFVSrQSkJckiriEQ9PT0qoCc5ydra2tDb26v25+TJk7MGJnNJB0BjV8v7uRY/c65qqc5BNJoWQE5ARrp2alGXyq+a2uUv0zqqQS0HnHLhqubRlX74w9tUxUDuXMgjkTSZdRINOhcZMjrGd797M372s//FtddeicbGRvzlL8tVoSG5QQ44YHoJPgkRVdKdjyafPuKcblRcM2bEzuXpuk7Epu8dWC45OW2m5aSbRTrO9E2btmQNSlUbCepJCx8pQzd2mDimeTvcVje6PUcj4hlf6s0rIwb+9YEgoMVawznc4b1o7u5FxGjE+UdZaj92dHSo/VpJreWIagXrHFSrRtICKNDXVdRto8pStUEpuSMh3Qbk8eKLf0u7zLx5Byf9X7pcfPe738R99z2kEtbKkK3Tp0/BZz97DRYurJ0KBRGN/s5HXZpRMqi8yF1qt9uFDRveVa1REnMa9PT0YufOXZg0qW3Ykfec7miSAyQdJ09UpmG/q5UkipcWUtLCR4MOl27CNhph+dsAV2OpN6/sWWiCZfhhWCFYVp0KRsn+dBLwE1F5YZ2DahlbAFE+VG1QSu5AyGOkpk6dgs9//tMF2SYiIio9yeF0+umnYNmyFaoLXmLuDhnCWwJVixefnTQS0s9/vkQlnb3uuqvi+aGOPHK+Spb+97+/owJQiV34JHm5rNsJgtUSac0zf/58rFq1CroVVNP66w+GyYBUTmQ/yf6q612Pzs5OleBe9idbSRGVJ9Y5iIjGhrf0iYio5lxyyUcwbdoU/PKXd+Gtt95Wd7j/9rfX8OCDj6gcUWeddXrS8N6vv75G5Yd6773YyFtiwoRWfOxjH0YoFMYtt9ymktZK0nPprnfrrT9Xra6k2978+fNQa+bMmYOTTyzkAmkAAQAASURBVD4ZIe8UdLW8D8G6maXepIoi+6ur6XiVUPuMM85Q+5OIiIioGlVtS6la4wwbrv5OGX2PiIiSSVcoGRXvgQcewW23LVEJy1tbx+ODH1yMCy5YrFpAOQ4+eA4mTmxT3fWmT5+atB5ZVnJPPfHEU/iv//rZQFcrr8pbJXlCTj/9ZNSqhoYGmEYdTBdHlBwN2W8TJ6YfnY+IiKgSmdGoGok6Eg4OGX2PaheDUhXOZRjw+fwIBgPxUfbCCUGp1NG/iIhoMDB1+eWXqkc20i3v1lu/n3G+dP/j8N1ERERE2UfqCwX7YUUjsIP9STk9E0fqo9rDb73C1dU3YMEZ58E0zfi0roCVtAxH/yIiIiIiIqJSjtQXjYSwa8NrmDTnWOgJrdITR+qj2sOgVBXw1yV3jYgYyUEpIiIiIiIiolKRgJPb44XL44O/vok9eSiOic6JiIiIiIiIiKjoGJQiIiIiIiIiIqKiY1CKiIiIiIiIiIiKjh05iYiIKK+6u7uxZ88eWNbgIBw0+n3Z39+vRotsamoq9eYQERER5RWDUkRERJQ3GzZsQHt7uwqm9Pbp6PX2oqFpXKk3qyK9++67eOeddxAMBuHz+TB//nzMmTOn1JtFRERElDcMShEREVFeSCBKAlKWZcVa9Vj7sW/vTsioz26Xu9SbV1GioV6sXbsWhmGgtbUVvb29at+2tbWxxRQRERFVDQaliIiIKC+km5m06mlubsZT7b2Y4utDm7YOIZcHpre11JtXUQz0YdWmIGxXI85qstDY2IiOjg61jxmUIiIiomrBoBQRERHlheQ9km5m0qpH013QYEH3NgB1E6G7G0u9eZXFMKD110GzQrCsOhWMkn0r+5iIiIioWnD0PSIiIsoLacEjeY80TYMe6QI0DeHGubAZkBox2WfhxoNhQ0NnZ6fap7Jv2UqKiIiIqglbShEREVHeSCJu6Wr2/L6d8Pa9h2j9AaXepIoVbZiJqKseCxe60NLSwoAUERERVR0GpYiIiCivJChleqOwA9tLvSkVz3Y1YOLEJvj9/lJvChEREVHeMShVgfr7ehE1zfj/e/utpPnBsA6fv74EW0ZERERERESVJhTog2VFM87XdRe8rGNSATAoVYEBqaeeXIpAIBCfForayQsZPhxzynkMTBEREREREdGwAan1Lz+OcGiwjpnK4/Vj3omLGZiivGNQqsJICykJSLndbrg9HjVNDw8GpSKRMPqDAVhm5ig3ERERERERkZAWUhKQMlweGC73kPlmNKLmZ2tJRTRaDEpVKAlIeb0+9belpbSUCoZLs1FERERERERUkSQg5fbE6pipzCjrmFQYeoHWS0RERERERERElBGDUkREREREREREVHQMShERERERERERUdExKEVEREREREREREXHROcVKhIeTDQXThl9j4iIqBS6u7vR398PXec9r0Lv47q6OjQ1NZV6c4iIqIrIKHsjmU6UDwxKVRiXYcDv9yMQCCASiZ0cQtHk0fc8Xj90g18tEREVz4YNG9De3o5gMAjDMNDdPR/+Um9UFe9jn8+H+fPnY86cOaXeLCIiqnC67lJ1yHAokHGUPVXH1FnHpPzjUVVh6uobsOic8xE1zfi0/f1W0jI9YR0+f30Jto6ocoUCfbCsaMb5Ugh7+bsiyth6R4IllmWhubkZ+/fvR+eenRjfGEQk1AdoRqk3sXKZIQSDHvT09GD16tWwbRutra3o7e1V+7ytrU21miIiIhotucadd+JiXgvngHWG/GNQqkIDU4miRnJQKpISpCKi4QuX9S8/ru4OZSJ3h6SwZiFDNJR0J5PWOxKQeuHtIGz4cWTdRkCvg9drAbpW6k2sYG78cHkEWnAvjD19sF2NOLXJQmNjIzo6OuJd+YiIiMaC17jDY52hMBiUIqKaJ3c7pHAxXB4YLnfafvQyP9tdEaJaJkER6U4mrXegeaBbIcDbALj80PzNAJv750Gz2p+wgrAsvwpGyT5nQIqIiKg4WGcoDGYiJSIaIIWL2+Mb8khX6BDRIEm4LfmNNE2DFt6vptktBwOGp9SbVj08jbBbDoEGDZ2dnWpfyz5nsnMiIqLiYp0hv3jrkoiIiMZMEm5Ll7LX+vdC9w206unfVerNqi5NB8J0NWDhAh0tLS0MSBEREVHFY1CKctYdYK6qYrFMC6GIrfa5npIzjPIvFLQQkVa2UcDSkkezFNEo1PxeWU6PfR9NfjY0JUolQSn4NcDtA9h0vTDcDZg4sUGNxEtEVM1Y96g+lV7HGU2dIR3WI5JxbxARERERERERUdHVTEspGUr517++Gy+99Cquu+4qnH76yWmXu+GGr6GjY2/aeZMmteGWW75f4C0lIiIiIqJKw/oGEdHI1URQ6uWXX1UFRDRq5rT8xIltMAxjyPQJE8YXYOuIqFyYkfCIphMREREJ1jeIagfrDPlV9UGpZctW4I9//LO6W/HSS6/guedWDvuab3zji2hrm1CU7SOi0tN0F9xePyIyhKsZSbuMzJfliIiIiBKxvkFUG1hnKIyq31szZkzDzTffhPr6elVIEBGl8vjqMfvYc2FnScwshYssR0RERJSI9Q2i2sA6Q2FUfVDqkEPmlnoTiKgCsPAgIiKi0WB9g6h2sM6Qf1UflBqN5cufxerVa7Br1x5oGjBt2lScdtpCLFp0GnQ9+4CFS5c+gaVLn0w7LxwOqedoNBp/WJalnrMxo9mHyzRNK+v/cx2eMx/LUH5YZhS2ZalnKk+Wmf5cYGaYnsuyZjS315oD5w55FtEcX+cY7pxDRERE5VvfGGmdI1fD1TlGcm0Sn56h/pA6PV09g3WP6sM6TvZ6RC71isRpudYd8qVQdQ4GpdJ4550NuOaaK3DAAdPR09OLxx9fphIXrl69Fl/4wmeyFhSBQBD79u1POy8ykPhs5cqVqnmvnLg3b96spmVbZ3/Yzrq9gZT5wUj25dMJRod/TWgU66XRsW0L/fu2omMjoGnFPdlQbrrdWtrpPlf66WmXTVmH35Pba6Uw37FtM15TTYR11OX4OkdfX9+IliciIqLyqW+MtM6Rq+HqHCO5NolvZ4Z1ptZX0tVFWPeoPqzjZK9H5FKvSKw/5Fp3yJdC1TkYlEpx3XVXqia4Llds14wf34LLLvsYdu7cjVdffR1PPPEUFi8+O+Pr/X4fWlrGZb1rsWDBAjQ1NcUjhwsXLoy/XzqdvdnvEnT2J8/fl/L/XHQHrLwsQ/khdw86bGDC7BOgG/yZlqMmvz6i6em01CUvOz7l/5nIXUi5TDv2+AUwXC6MbxhZod7d3T2i5YlGMhy6XIB4/Bq87qGjSlHhhEIh7Nq1C42Njeoag4iqt74x0jpHroarc4zk2iS+zgz1ktT6Srp6Buse1Yd1nJHVF5rSLJdYf8i17pAvhapz1O6RkMH8+fPSTpemtFJIyGga2QqJ888/Vz0yfSlLlvxMFUBOISR3QRL/n47hyn5CNgwr6/9zoefwmlyWofyRu0xysq7lE3Y50430J2Ujw/RcljVcub9Wzh1y0ScP1wheJ7Kdb4hGa8OGDXj99dexdctE6B4/Jk5oBQc2L46NGzfivffew759+1BXV4f58+djzpw5pd4sIipQfWM0dY5cDFfnGMm1SXydGeoPqdPT1TNY96hOrONkrkfkUq9InDaSukM+FKrOUbtHwghNnNimnnfs2FnqTSGiEggH+5JG2ghYySdlXXfB62fiQ6pNUgFqb29X3dK9bg2haBC7dmxFQ30AdqBXrr5KvYlVw46GEAy6klqnvfHGGzBNE62trejv71ffRVtbG1tMEVUY1jeoUq6DU3HEORoLBqVyxj7NRLVcEG987QlEQoH4NHfK2dPj9WPeiYsBf2PxN5CoxCQQEgwGVRBkbv0uuToFAvuh6X64vBY0vbg5D6qa143/fSEKTYvlabD6OxHZFoAd0THHslT3vY6ODvWdMChFVGlY36DKuA5O5fb6MfvYcxmYolFhUCrBo4/+BVu2bMOnPvXJIfNkZAwxZcpk1IpQoA9WQkQ8FExuQsuIONUKuTMkBbFuuGG4PWqaJ+HsaUYjCIcCSb8Xqgz9/QE88MAj+NvfXlOtfVpbx+OUUxbgggsWj7ib47vvblLlyJtvvq2S1jY01GPatCk4/vhjcO65i1DNpMuYz+dT+aR0lxeaGYTta4Du8sFd16zKCyoMzdeMqNsHO9ylWqpJyyn5LuQ7IaLyw/oGVVoLp3TXwYnMSFjNz/Y+RNnwKjFBMBjCG2+0q9EsJHlgomXLVqjnk09+H2olILX+5cdVRdsRSTnPMCJOtUYKYpfbq/52p4yaYUZjI93QoDfffBNnnnkmDj/8cNx0001qUIdU77zzDh588EH8/e9/Vy1tpk6dirlz5+KMM85Qz4UOSN1003+qQMr111+HWbNmqlGPbr/9Drz99gZ86UvX5zQst1ix4jnceefvcfHFH8I//uMlqKvz4+23N+J//udXeOKJp6s+KCUtciSP0erVq4HgfsDth6t1Luy+XaXetKqnexvhaj0Y4b7d6OzsVC2l5LtgKymi8sT6BlVqC6fE6+BUlhkZ07ZSbWNQKkVXVzduvfW/cemlF2H69Kno7e3D0qVP4vXX1+DII+dXfcXCIS0+JCBluDwwXO7YxISgFCPiRDScJUuWqNHAJOhzzDHHDJn/3e9+F//xH/8RH4k0lQSl/uVf/gXXXHONavmRb/ff/0ds3boNX/7y59QoSOKEE47F7t0d+L//ux/Llz+Dc845M6cWUr/85W9VMGrx4rPi0+fPPxT/8A8fUwlra4Ek1paAyFvPdMLwNUNz+xFhUKooXONmwtz3LhYsOBITJkxgQIqozLG+QcXAFk5UKao+KLVnTwc+//mvJ037xS9+ox4TJrTiJz/5QXy6dNeYOnUKXnzxZdxyy8/R3d0Dt9utCosrr7wMZ599es53zauFBKTcnlhl0NKS+7kzIk610JRZlg3198CKhmFGDGgD+R6idqyllCa5cyit5557Dpqm4bTTToPf70+a9/Of/xzf+c53sr7+7bffxg033ICf/vSn+NWvfoVTTz01b9smd6iffvp5jBvXjKOOOjxp3mmnLcQ99/wBjz22LKeg1P33P6SCZlJGpFqw4ET1qBUSlNLrdOjSnYwXucVleFRyc/kOiKi4WN+gck4gXmstnJiUvfJUfVCqrW0C7r57SU7LejweLFhwgnoQUXUaSVNmIcsG+7rQ3bE1NnztwChizvWiYbjQMnFGcTa+AoepF4ceemjSdMl5841vfEP9PXv2bFx99dWYN2+eCmBt27YNq1atwrJly7Bp06Z4F79zzjkHd955Jy655JK8bFt7+5uIRCI46KBZ6n0TNTY2YPLkSWr0I3lky+0hn2XNmnWqVdRIc1AREVF1YH2DRoMJxPOP+7Qy8QqaiGrKSJsyO8uqgNTAQxi6rMuCaUZh28mDAFCMJA4XLS0tSdPvvfdeFcz50Ic+pP72etPfvZPA1Le+9S289NJLCIfDuOKKKzBz5kycdNJJY962LVu2qmfp6pROW1urCkhJMtpsQamNGzep5NKtra2q28XDDy/Fpk2bVaBr5swZOO+8c1SXwGyWLn1CddtIJxwOqWfp4pipm2M5kW20LVP9ftTDtthiqgicfV0px0mlkn0rv/da3ce1+rmJCoXd6/KP+7QyMShFRDVpJE2ZpRurtJDSoMVHa5a2NZZtwbJMNfoeUlrbkLQiM2CapuqWkBpskm5Gd999d8aAlDj77LPV48Ybb8S///u/q5ZNEpiSBOpj7dog+TxEfX36Ecqckcuc5TJxRkpau3YdXnnlNVxzzRWYP3+eCrrdeec9+PGP/weXXfYxfOADsZZ3mboS7tu3P+28SCSWQH/lypWory//O3ryHUV3RGAZLhUksbq3QX5N7OZaWCr417sDL7/8ctbfFI2NBKQ2b96s/q7F7lWSH5CI8q9SutdJQGck00upUvYpxTAoRUQ0HE1XLaQsaRVlxlpFRW0p1Ew1zYxG4W9ogs5h75M0Nzdjz5492L8/OeDy17/+FRdeeGHOQRYJSkmw4//9v/+HDRs24Pe//z0uu+yyMW2btLxyAmfpuFxG0nKZBAKx5uEdHXvxz//8T/FWUTL63r/8y3W4/vqv4N57H8SJJx6nWl+lI6MvtbSMy9pSasGCBRWRvFr2x6vBfhhub+xupTSTn3q8yt9AhSP7Ws5FJ554InNKFaGlkIwkWovddZ3Wr0RUW6QMly5v0sIoU0BH5rOsp9HikUNZqRYgAxJbbY80It4TZPemkZBuYeGojd6QBU3nvsuncNBGxLRVVCk1eb8wo7H5vcHYPPnb7XKhvm22NEeA2xVrEeVxAdFICJFgPw498RzUNbTA6y//lizFJPmiJCi1fv36pOTlW7duxbHHZu/Sluqmm25SLau2bNmChx56aMxBKcnpIaQlVzrRqJm03HCku95JJx2fNE0CU8ceeyT++teXVSsq6cqXzvnnn6semSqBS5b8TFWAK6ESLNuoSavCgQtTaSElf/NCtfBkX1fKcVLJpIVUre7nWvzMVDkqsa4xkmvS8CjqA876zWAIRjTd+sOwclq/HxMPO1t1z89Eyv4Q/AgN8z0Uuo5T6H06Wo2+2mtdOxIsXSgtafHh8foRDgXUCUtEUrreMiJO1UaOdTMSghWNIBLoUdPUqHu6S7X8kC56TlNgtzsWnJLWCb66Rgak0pDWBC+++CKWL1+OHTt2YMqUKfjf//1fFcA5+OCDR1wZktZVP/vZz1QXpbFqbo61Ourr6087v7+/P2m5TJzuf5IcPV0AS0ZdEjt37h7zNhMRERHlSgJFLo8f0XDmFk4yX5YbjnuMScEjakQ8yTlpqmvtcH9P0vvK32N9D6pcjChQWlLBnnfiYlgJSeB6UyLfHE6Tqi0g1b1rI8xIUB33W9csU5mjeju3Qtfd0HTpwueGZ9ocGK7cWs/Uun/4h3/ALbfcovKQSIDqzDPPxG9/+1s17yc/+QkWLVo0ovVNnhxLOC6tr8ZqxozpA+vqSDt/z569A8tNy7qeadOmJLWsIiIiIioHEuSZfuQ5w7ZwKnQwSAJSW994UgXHpNeBEe1B554dSflYJTgm28rAVG1iUIoySm35EWE3MqoiTgvA+P8jIRWQEhKEcnnq4q0GJSDlLBMNB2HbNnQ7uXsrDXXMMcfgqquuwm9+8xuVHPjOO+9U02X/rV27Fl/72tfwgx/8IOf1vffee3nrQjJ//qFwu13YsOFdtT3SesvR09OLnTt3YdKktqwj74k5c2bD5/OpllXS6io1cbrkmhJTp2ZfTzWQroadnZ0IBd2oc/tKvTlU4O9ajnkZEKAScp0REVXSNelw00eiHII8EhSTgJQaEU+NYh2C7q1TOVudzynzswXPymmfUv6xcyMR1RSnKbM0Y46E+uIP1bRZtQzUVFc9w+OLPQYq11JQWpa8pl/d8QkH+1TBJt1cmeA8s1/84hf4l3/5F5VQXII/8vjkJz+JZ599Fv/93/+Niy++WOWJGs727dtx//33q+DR9OmxVk5jIcnFTz/9FOzf34XVq9cmzXv22b+q7Vy8+Oz4tP7+AP7rv36K22+/Q43A5fB43DjzzFPU3y+88OKQUfVWrVqjuvW9733J+aaqjSSgX7FihUpi/+6772Lv3lgwjqr3u5bfsDzL/4mIKH/XpM5Dpufava4SSE8D3e1Vn0eeDeeRxx4ItbZPqwVrUkRUUzI1ZZYcUtJlT1pIqWDUQAHZNCmW4DzWSiqA2cecDW9dIxoGEhZKQIr5pDKTVk0//elPVaLy1atXY9KkSZg3b56ad9ddd+FjH/sYli5dio985CMqQHXqqadi4sSJSet47LHHcMMNN6hR/CQode656ZOCj9Qll3wE69e/hV/+8i5cf/11mDVrpgpQPfjgIzjiiMNw1lmnx5dds2YdXn99jfr73HMXYfbsA+PzLr74Qqxb9xbuv/9htLaOx5FHzse+fftx5533IBQKqVH5xo1rRjW3mmlvb1fBOmk1Y24OYvuW9+DWpsMlOdr6e3nxV2AqR0c0jGAwWNBk1D09Pep3LEHb1tZW9Pb2qu++ra2NLaaIiCq0e1014T6tTAxKUdE4o5nR8GzLjo1MEbShST8xyrO6Ie1EI7qM0uGGqUkwyq1G5/C4tKS7N9KSSgJS3rpm+P1saDoSLS0tOOOMM5KmffjDH8Z9992nck/de++96uEsO3Xq1HiXPclJ5fD7/SpAlQ/S9ejGG7+GBx54BLfdtgTd3T0qqPTBDy7GBRcsVq27HAcfPAcTJ7ahoaEe06fHtm1wm3z41re+gocffhS/+9192Lu3U007+OCD8K1vfVk9VzPpxiXBkObmZry+OYTDxvfCDOyHX29C1AX4fTyPFaPMCHgM3LfKhm4ECvY+kd596NveD93bhGObLDQ2NqKjo0MdAwxKEVEpVW49Y+g1aapQxX62mEjIRtS0YUdtGLAhGWEsGQ1wYHQ8ueY2TRt9IRkRz666fdrgG0wRQekxKEVERCUjLaReeeUV1aXPGVVP8hLt27dP/S0tMhzSDU5aVx144GArpXwEpi6//FL1yKalZRxuvfX7GedLEOrSSy9Wj1oj+1DyakmrGU33QYtGoPua4GuahECgA566Zo7UWmC2FUXY7YPL4yvsvvaPg+GugxWVASG8Khgl370cA0RERESjwVv9RERUUocddhhefPFF/OUvf8EVV1yhgk7STc8JSEk3oU984hNYtWoVLrroolJvLqWQFjLz589X35kZkGCiBt/EQ2H4Gkq9aZRnhq9RfbcaNBU8lu9cvnu2kiIiIqLR4q1LIqIEthmG0wvdtAeb23K0jsI755xz1ENEIhGVLNvr9arufFTe5syZo7pybV25D25pTeNrVK13qPr4Wg+E7m3Awvm2+m0yIEVERDlfY8sNRysKMxIGBkY+lulU2xiUIiIaSHpoePwwwwHAjKhpETO5D3hstA6eNovB7XZj8uTJpd4MGgEJSrkbXPERK6l6Gd4GTJzoVzneiIiIcr7GjoahWxGYdl88KCVkPgdFqV1Fq12ZpqmGipZhvaWisXDhQlXpyOThhx9WI7x8+9vfLtYmElENc3nrMfGw5NE66r3JQSkpLD0crYOIiKgssb5BVN7X2PII7Xwd3slHJwWh5G9ZjmpTUXJKvfTSS5g7d64aeemyyy7DokWLcMABB+COO+7I+JqHHnpIDSFORFQsUhi6/U3xh6cu+cHhY4mIiMoT6xtElXCN3QjD5VXPidfcDEjVtoK3lNq8eTPe//73o7u7Ww0XffDBB6shvnft2oVrr70WTz75pBpNKdtdDMq/YKAPljmY7yMQtJLm67oLXj9PDkRERERU3ljfoLGIhvqSWsqnYiseogoPSt18882qgPinf/on/PznP1dDB1uWpQqGL33pS7jvvvvUCC5yp4K5CYoXkFr1/GMIhwLxaWFzcNh14fH6Me/ExQxMEREREVFZY32DxhKQ2r3uyVi+owwk35F0P2NgiqhCu+/JEN/Tpk3D//zP/6gCQr2pruOqq67CK6+8gsMPP1zdvZARl7q6ugq9OQSoFlISkHK53PD569VD8uQ4D8PlUfMtjpxERERERGWO9Q0aLWkhJQEp3XDD8NQPech0mZ+tJRURlXlQauvWrTjxxBPh8XiGzDvwwAPx/PPP47TTTlNJCaXvtwwBTsXhcnvg9viGPAwXmzYTERERUWVgfYPGSjM8MNzeIQ+ZTkQVHpQyDGPYIaTl7sZ5552HVatWqQJjx44dhd4sIiIiIiKqAqxvEBFVroIHpebMmYNXX3016zJer1cNyfqxj30M69evx6mnnqoSFhIRUe2QnB/ykOG5qbJILhdJKBwIZs7JQdV/DOzcuVM9ExUb6xtERJWr4EGp008/HVu2bMHLL7+cdTmXy4Xf//73KkHhxo0bsWLFikJvGhERlZFLL70Un/jEJ3DnnXeWelNoBDZs2KDKbOkW884772DPnt2l3iQq0THw7LPPqmf5P1Exsb5BRFS5Cj763gUXXIDbbrsNP/rRj3DvvfdmXVbTNPzqV79SQ7n++Mc/Vv8nIiKi8iStYtrb29UoV01NTTC3B7F500a4DMDrcSMSCSHQ36OG06bCkQS8xdzXViSIYDB2jdbT06NaN9q2jdbWVvT29qpjoq2tTR0TRMXA+gYRUeUqeFDqzDPPVKNdyAgYubrllltwxhlnYN++fQXdtloXjYTjf0eidvxvMxop0RYREVEl6e/vRzAYVJW79m0hHNwSQLR/J8bpbXB7WmAbNpo8NjR9sIyh/LMtu7j72uPFn9ba0LQgQj37sW9nAIavEU1Nlsrd09HRoY4NBqWoWFjfoLGyzTDMDNOJqAyDUjLCxfTp03N7A5cLZ5111ojf40Mf+tAotoxyoRsueLx+hEMBRAcCUGEz+SJW5ut6wWOWRERUwerq6tTw69I6Rjd8sCIRePyN8DdPguHxw+XxwVvfrModKhzLjJZsX9t14+Dy+GFFg7AsrwpGyTEhxwbRWLC+QcUgrUulvDLDAcBMf2Ne5rPFL1HhjOrK5aSTTsLSpUtx5JFH5n+LqOB8/nocc8p56iLW0R20kpaRgJTXX1+CrSMiokohLWHmz5+vum9F+var4ETjlEPh9jcmlTFUveS7lu+8a1s7Ojs7UV9fr44JtpKisWJ9g4rB5a3HxMPOUd2gM5GAlCxHRGUUlNq+fbsaSvX+++/HOeeck/+toqIEphJFjOSgFBERUa6jXkmXrc5X98NTN04FKai21LfNguFtwMK5NlpaWhiQorxgfYOKhQEnogodfU8SW37wgx/EHXfckd8tIiIioooiQSlvYxsDUjXM5WvExIkTGZCivGJ9g4io+o0qKPWd73xHjbISiURw7bXX4tvf/vaY74R8/vOfH9M6iIiIiIioOrC+QURUG0YdlPrNb34Dt9utCovvfe97uPLKKxGNjix/xLvvvot//ud/Vk3/f/azn41mU4iIiIiIqMqwvkFEVBtGPUTLFVdcoUbEuPjii9HV1YXf/e532LZtGx588MFhm26vX78e3//+93HvvffCNE1V0GiaNtpNoTISDvbBtoZeLISDNiIhGaqaiQKJiIiIaHisbxSWjJwq+8bR3ZecY9ZlGKirbyjBlhFRLRnTuMGLFi3C888/j/PPPx9btmzB008/jVNOOUWNlJFuCNfXXntN3eV4+OGHVcEgDzFlyhR86UtfQqH7pP/613fjpZdexXXXXYXTTz8547I7duzEffc9hHXr3kIkEsb06dNw3nnnYMGCEwq6jdUQkNr42hOIhAJD5kVMG1HTVkOqyggXDExRKUVDEjzlKCtERETljvWNwgWkHn30UfT398enhVLuK/v9fiw653wGpqioeJ1ee8YUlBIy7O+LL76okhCuWrUKa9euVUO4/vnPf8bRRx+tlnnhhRdU4fCXv/xF/d8pHGbOnImvfOUruPrqq+HxeFAoL7/8qiogotHMB7dj06Yt+Pd/vxmzZh2Am276OpqaGvH448tw222/wO7du3HhhR8o2HZWOmkhJQEp3XDDcKd8n1EbVigEMxzIepIhKkZBt3vdk+pYzMQJnsLHizAiIqJSY30j/6SFlASkZJ84+8WIxPaZiITDCAQCiCa0pCIqp+t0Bqaqx6hH30skdx6ee+45dQcjcQjXW2+9FWeccYb6WwoI527F3Llz8atf/Qpvv/02Pv3pTxe0gFi2bAXuvPMedbfiuOOOyrqsZVm4/fY71DZef/0/Y/Lkiair8+Oiiy7AMcccifvvfxhbtmwr2LZWCwlIudzepIfh9kIzCvc9E+VKgqJS0Kngqad+yEOmM3hKRERUXljfKAzZLz6fTz283sGHu4D7iygTXqfXprwEpURdXR0eeeQRfOpTn4o3CZUmslJ4OIWD3OW4++67VR/vf/qnf4LLNeaGWsOaMWMabr75JnWSH866dW9i8+atatnm5uR+6tL8Vj7D448vL+DWElGxSJBUgqWpDwZPiYiIyhPrG0S1gdfptSWvZ2lJOrhy5Ur1t5NIUE6sjY2NuPPOO/HhD38YxXbIIXNzXnbVqjXqee7c2UPmzZ07Rz2//vobedy66mVGw/Fm07H/27CiIVjRCKLBHvYFJiIiIqIRY32DqHLzQ6mWUNEQIoFYfZB1QspLUEqaoMpIGD/4wQ/w1ltvxadL4aDrevwuhiQbvOCCC2AYRtnueaep7IQJE4bMGzeuWQ1Ju39/F3p6etHYmD7XzNKlT2Dp0ifTzguHQ+pZhrJ1HrL/hhva1oxa2eebVtb/58LK4TXDLWPJCce2EY2E0bt3C6yEPuimZcdGPrGi2L1uGdz+JrTNOwsub13SOvpCg4GsWiYn7GjUghmIQtO5T/IpGoyqpPuWacPUYse0J/G0JMFUudtqxY7XVJapJz2nMjNMz2VZM5rba82Bc4c8q8+U4+scIx1Om4iIqJRY3xhbnSMdmS77T/atPIRlDV5z2pal5ptmNH69MZJrk/j0DPWH1Onp6hm51E8GtzdW72BdonyY4X7s//tTsCIJ+aFsG167Fx07t0tUGbrbj3EHL4Lhqct4nZ5IpsujLxiFCxGUq3rv4EiftqUNqTdkqkfkUq9InJZr3SFfClXnGHVQKhwO44477sDNN9+MTZs2qWlOy5hzzjkH3/zmN9XdC7lbsX//ftx1111qCNcHHnhA3ckoRzLUrKivTw6UOKS/d1dXBF1d3RkLiUAgiH379qedJyNrCLm7U19fr07cmzdvVtOcAjWd/nD2k2sgZX4wIUlhroLR4V8TGma9ZiQIRHqAqA63ZqqjS9MGKvCqSbUG29Lh0oLQgiEEt78Kw+VNWkcOuSFrg23B7tkGtTsG9iHF2GZyK7xUct7J1rRXWuxJYahFQ9Cs2ClQTxwh2opCtyII7XwdXft9Q14fcMUW7nanH1baNzA/F76Udfg9ub1WLhR3bNuM19ThoaMux9c5+vr6RrQ8ERFRKbC+kTkoNZI6RzrBYFBtiyQzd7o4RhKuwyUYJcnO17z+isoxNdJrk/h2ZqjHpNZX0tVFhqt7JAoEYwEM1iXKh1xzu8N7VF1GWkQpNmBYJjRdrudNINwLc9drsAfqhOmu0xPJDWPbjsDasxrRgdeMtW5QCIGEuLjp0uL1B0emekQu9YrE+kOudYd8KVSdY1RBqR/96Ee45ZZbsHPnTvV/OQjky77wwgtV4XD88cfHl5WRMM477zxVkCxfvhynnnqqGsJ16tSpKDfhcCza6nKlv7vinLClgMzE7/ehpWVc1rsWCxYsQFNTUzxyuHDhwqz93Tt7s98l6OxPnr8v5f+56A5YY14mFOjG3t07VQAqEO6EbhjQjYGglOXckdFQ526BbUbhnXw03P7kCwaLdzcU1UpHksZPPn7wJE7qjktX6h2XFKl3XFJJ99FQxw7ornrorlgBpSUWHJEwTLtPHZ/NLcm5HkSDN3ZMN/nTBwszTU+npS552fEp/89E7kLK8XHs8QtguFwY3zCywGV3d/eIlqfaJseLjNAkuVyk7CIqNB5zJFjfyFzfGGmdIx0JSEmyeEl0Lq2zUgNFkUhEPY44+ng0NTaP+NokUz0lU30lXT0jl/pJ/P27YtEo1iXKR/ya2zN4zS033rXwXkQ9rbDMKKxwH+rajoLL15jxOj2RFQ3DsgZfk4+6QSH4E1pKNfi0eP1hpPWFpjTLJdYfcq075Euh6hyjCkp9+ctfVoWCFA7SPPbjH/84vvGNb6jEgqkOPfRQFaWXIVxfe+01rFmzRg3hKgXF4YcfjnLi8cROyJmGcnWCSNlG7zj//HPVI9OXsmTJz1Rh4xQ40kIq8f/pGK7sJ2TDsLL+Pxd6Dq8Zbhlp9eT21SHY16VOMoo92H1PAti64VJBFgm6xPoRJ39udlUbJK3M0u2jWmdFg+puh5amoLKloIoG1d+Z9psK8sn5y4zAGshFYSYcdrYVUfMz7Xsn0Oo8pzIyTM9lWcOV+2vl3CEXffJwjeB1ohhJX0dDRk6SsuWggw4q9abQgA0bNqC9vV3dUZeRmaScnzMnlvOEqBB4zJGD9Y3sLTtGWudI5fV6VSsqCQBL8EmEUnraSGDY6/EmBZlyvTYZrl6SOj1dPSOX+olDG2j2zrpE+XCuuWOPhGtV5/8D8xKvudNdpyeS6amvGWvdoBCc49H5O7XekKkekUu9InHaSOoO+VCoOseovxl5gyuuuAJf+9rXhr1YmDx5Mp599ll87GMfw2OPPYatW7filFNOUU1rzzrrLJSL5uZmbN26HX19/Wnn9/fHIrCpI2VQjMdXj9nHnotg7z68u2oZXF4/XO5Ys8pwFAibcodLV817gex3f4iykUJHT+n6KeTIsgfuQGZ8rW6oOyZyR8VZNrW7tuHxs4VaCaxYsaLUm0AplRoJDkhXcykfJV/L6tWrVZeY1G4xEkAI9HXDSLizLzcfIuEQAn2xZKZUOOWwr6ULfzB23T9qPT096hiTIERra6s65uQYbGtrY4upGsX6RuE0NDTgAx/4gMr56ujsSw4CuQwDdfWZuxAS5Vu66/RUMj+1rBtL3YBKb1RBqeuvv17dvZg+fXrOr5FI+5/+9Cc1hOsvf/lLdbF7/vnnY8mSJaqwKQcynGt7+3rs2dMxZJ4kHJS7CJKAMFv/7longSnp6yvNLQ23Tw3dKQzNVg9hWrEmxUSlYHjq0XLI2UkjgaT2j+ZIIERSMepXwSapQG3YHYGm+xHq3Yfl7V3wNyXfjZSWsC1Ncr4fvEMtCXNDLqDRL4mIeee6kMpiX/u9WLFBbmCPvowPdHdh156AGgylqclSwc+Ojg51LDIoVXtY3yh8fUMCU4mio+htQVTo6/RUcp0uy1GNB6V+8pOfjOrNpEnnL37xC8ycORPf+ta31En3n/7pn1T/b/l/qR199BF4/PFleOedjUPmvf32hvgyVFh9wyR2rwmWDc20EZZ9wcpcnBm2EYlEodkhtX/SNdG1o1E1OICRst/qEwJPqQWZO6HfNxENVu6k+5S0VpGAlBkOqhawvrpmuD1Dk956vP6k/0s3blmurr5Zdd2mwqmWfW3XNatjTFpdWZZHBaPkGJRjkWoP6xuUb6xjDE9yPA0XEJIcUblet0svVblm1wcaJ8hdLN2yERkYRU9ynQ+9bq8DhuslNvBdpn2PxM+T8T2Gl1h3oMIqyZWLJCc84IADcM0116iC4sYbb1QFhdzRKKX58w9Vdy9WrXpDjXiR2Gz2mWdeUP3a3//+8mn+W+4kYXT876itHs4ICUSjYUX6EenZDtixvuSpVCGq2Wo5w8e76kRjIS1TJHeLdKeSFlISLBg/fR48dfxtUWHIsSXHWMfmtejs7FT5buQYZCspGg3WN4hGHpDqfWcZbBlRPQPN7UPDQWfnHJhSzLDqRqfIiOyWqRKWQ/K4EsnNhFK98eWXX676e0u3AMkd8Otf/xqlJndWPvWpT6qcaz/72f9i167dql/3H//4Z1VwXHzxh3DAAbk3Ia5VkkTO7fXDMiOIBPtij1AfzHDsIdOZs4eGKxTNYPeQhxXsHkhwKCPmuYc+ZAhiCUxlucNDRLmTHC6Sk2XSwSdi2rxT0DxpVqk3iaqcHGOTDz5JjUx8xhlnMMk5jQnrG1QL18fx6+Rw39hH/45I0nAXNE/d0IfhUvOztaRKpJKRu31q1HU73B97RPpVMEqeZbrMZ52QStrGe9GiRSohofT1liFJC0H6a3/+819PmvaLX/xGPSZMaMVPfvKDpHkHHngAvvvdb+K++x7Ct7/9fTVs6/TpU/DZz16DhQvfV5BtrNaE55JbytEbtNGXMEQrc/bQaO7SSAsoVaDpIRX8ZCFGVHiS10dySKXrskdUCB5/IyZO9MLvT+4SSjQarG9QNShYK6Z0jMxJw+GMsJ4D2Q7ZnqQglmXC6FwNY/xRMgTdiLoD5twaK2U6lb+SJx444ogj8OKLL6rRHwqhrW0C7r57yYheM3XqFHz+858uyPbUUmAqUVi3EGZuJBrhXRopFBNpkkRZhpC1rViLKTu5+LHl/5qhCjkiIiIiwfoGVfP1sWKGR9SKqViGBJysKDSXF4avEdDHHoqIt8aSYF2GgBlbY5W/kgelxLRp0/Dcc8+VejOojElyuppi2fCYqMlE51bERlQSvRseaFryXRpbyhNVuGnQx81WyyTNlwI5GkAIfkTC9pBR9YiIiKg2sb5BlVyvyHZ9LOQT2VYEgcjoR2GNv4ekaE1zCS0Jw23LHtN75L+OUwdj5lnDJmcPSvL0Yb531htqPCjldA8gIhqerpKAqkI5TdNiJk0kIiKidFjfIKo+mrte0s1SBSuboBRRNhKRrykyXKppIyAjFqYZ3rSa2REbpvTKU3dqUj67NTCCo20jkjDfbbAoIiIiIqLqrJtkvT5WraRslfRJltNG2QKpGO9RTnUcv5v1h3LBoBQRVR7JHSVd9Zz/2rFCxbaYzJBGRkY8euCBR/C3v72G7u5utLaOxymnLMAFFyyGyzW6IvK99zarxLWmaeLHP/5/KtcIERERUUVIuMZOnU5UCAxKEVHlkCTnmguwQkAkoJIlCltPWMTlZzLDKrVixQo1gpL49re/nZeA1E03/Sf6+vpw/fXXYdasmVi9ei1uv/0OvP32BnzpS9erobtHwrIsLFlypwpIEREREVUMSRru8sGOBuPX2KlkPgcUonxjUIqIKusuTcMUlTdKn3EmNE+DmuRNaH4bG4UjD0PLUtlZvnw5vve976mcYvkISt1//x+xdes2fPnLn8Mhh8xV00444Vjs3t2B//u/+7F8+TM455wzR7TORx99QgW5mpub0NXVPeZtJCIiIipGKya5ftZnngVkG8GP19lUACO7BUxENAJ2pA92qDvzI9KX8S6NukMT6R/6kELT0wjN1wzN26QeesKDBSXlIhAI4umnn8e4cc046qjDk+addtpCFfh67LFlI1rnrl278eCDf8InP3k53G53nreYiIiIatZw18dWNGMrppFcj6uk4QPX12kfvM6mAmBLKSIqCCngrE3LY02AM5DCU+7IJBZwvEtDxdDe/iYikQgOOmiWCkAlamxswOTJk7Bjx071mDJlck7r/NWvfqdaWh155PwCbTURERHVotFeH4/2epyomBiUIqLCsMxYAai7AMOTvvmx6rM+tHBloUiFtmXLVvU8YUL6JORtba0qILVly7acglIrVjyPzZu34Prrr837thIRERGN6vp4DNfjRMXCoBQRFZbhgWZ4h0xW/eEzJFGk6vHJT34yb+tatWpV3tbl5Huqr69LO7+uLjY9l7xQsozkoLriik+gsbFxxNuydOkTWLr0ybTzwuGQeo5Go+pRCvK+lhl7jIQsb1vWiF9HI1dt+1o+RzRqlOyYz/pbsKyy265iqdXPTVQVeD1OZYxBKSq5aKgP9kB0Phq2YYaT0/fFRlLzl2jriGgsfvOb3wzpHlcOwuFYQlDDSD+CjMtlJC2XzZ133oM5c2bhlFNOGnV+q3379qedF4nE3n/lypWory9NC0Lp5rh7jwndGNklg21b6N27FTvfBjQZOZMKptr2tQSlXuwyyi43mwSkNm/erP4e6cic1UAGcSCiCmZFANsamiDdisAO9zI9BpUMg1JU8oDU7nVPwgwHYv+3gGhK61HN7YM9ddGQk2QwknbsiepgA15LPqPsgAr9nFEbupR78kgXkxiYF43agD70M/oSRtSjymfb5XUcezyxJuymmb65enTgROQsl8lrr63G66+vwX/+542j3ha/34eWlnFZW0otWLAATU1NKLbu7m7s27cPuz0eNDW3jDiwsNMGJs89ccQBLUJN7+tIOIiT5nnh95fPDSn5LfT29iIUCmHhwoVwuSp/P49mHxDRUGVdJ3GuxyMRaH3bhraKsk3VdS+66WnA0whr+iKgkIGpEtZxWLcoX7VXolJZkRZSEpDSDTc0wwPLAjTTTu7nHGE/Z6JKJZXKYDCIgw8+GF//+tfHtK4HH3wQf/rTn/KyXc3NsQBPX19sRMdU/f39SctlauH061/fjY997EK0taXPTZWL888/Vz0yVQKXLPmZqgAXuxK8YcMGtLe3q4r4+u6JOHD2HEyZMmVE69B0XQVJqiFQUu6qaV/LZyjFMT/cb0HOC11dXaq1lJzTak25fB9ENBp2LCAlrWkTR+izBlp9agYguaUkSEVUZCxdqCxIQMpweyGNFvSEqLlqYFolOTIoBzIk7UBhaFtp7mawWXHFOeqoo/Diiy9i7969uPLKK8e0rnfeeSdvQakZM6ar5z17OtLO37Nn78By0zKu4913N6Gzcx9+97v71COdz38+FoibMKEVP/nJD1ApJBgmlXDpriQttCIdQWx45+9wG3rOrVcsy0QkHEJfbw/0NENUU/5U276OhoMIBkeen60Qenp6sHr1atXas7W1Ffv378e6deswefLkkrReJKKYcFDSfwzWESIBK54KxEn/YXh4zTiElBFaQghALrc1K5YEnbmlqEQYlCKiwpK+6rlMj/RB3/pU7C6NzE6TroND1lae448/XgWlOjs7sWnTJsycORPlYP78Q+F2u7Bhw7uqspmY96qnpxc7d+7CpEltWUfeO+ywQ3D33UvSzrvhhq+ho2Mvfvzj/zemVlSlIi1CpIVbc3MzNu8NY06rhUDvXtRr09Hg8+W0Dsu00euy0eS1oRtl3LWhClTdvvZ58epWDZo2fE63Quvd343tnQF465rQYFnwer3qtyG/EQaliEoXkNr42hOIhGLpP0QgPBCUGkiZpLv9aDnkbAamkvJJSVc9PTmtRmqOKaISYFCKiApDmgG7fLEgU6Y7LzJflhNSUCYOWZsalOKQtRXpuOOOi//96quvlk1QSvI4nX76KVi2bAVWr16Lo48+Ij7v2Wf/qgJVixefHZ/W3x/Az3++BI2NDbjuuquqPsmxjD7o8/lU1z3d8CMaisJf14Tm1knw1TXlnOfI7fGjvnFcVXQpK2fc14VT1zgOHm+dar1lWS6VU6qlpSU+QicRFZ+0kJKAlKT/MNyx3I/hWP8KlQrEjoZhRQLxgZRqmnM9Hu4evIaWllGJ5Nq7DAelodrBKxciKgx3fSxZYra+6VJQprZ6koCU4VVd3hNxyNrKbSmVGJS66KKLUC4uueQjWL/+Lfzyl3fh+uuvw6xZM1WA6sEHH8ERRxyGs846Pb7smjXrVEJzce65izB79oGoZtICZP78+arbUqBnn6qUT5x5WM4BKaJqIce8HPs7Nq5RLT6lVeVhhx3GVlJEZUACUi63N/a3GQu0SCoQ+csOSyZtil+Ph7ugb10BuPyxa+0kctFtASb3GZUGg1JEVDjsZlfz5s2bh4985CMqN1Fj49hyxFx99dU4++zB1ktjJS0dbrzxa3jggUdw221L0N3dg9bW8fjgBxfjggsWwzAGc/McfPAcTJzYhoaGekyfPjXt+tatewvf+94P0+aUktZVp59+MirJnDlz1He28u/dqrUIA1JUq1qnzILHV49DJ4Tx9ttvY/bs2aXeJCKikV2Py01i3R2/+TuEGRvtl6gUGJSikjLD/bCi0se5F1Y0pPqBJ43QLv2fkzo+E1ElkW5uDzzwQF7WdeCBB6pHPklg6vLLL1WPbFpaxuHWW7+fdZlsOaYqlQSlGsZ54fHmltycqFp56xrR1qarkfeIiKo+12sNsSOSNN+EmTLIUnTg/0yaX3gMSlHJREN96Hj7OQS7d8T7fFs2YCfmaNUMeMbPSh66lIiIiIiIiAqT67WGAlKhjcthRwMw9eSgVHBgVzBpfuExKEUlI4Eo24yibvxMaAPdZCKS63qgpZRtRWCbEdQdeAq6dZ4EKMaO9A+ZZiXc2ZC7GRydj4iIiKi6B3gwI4NdzszIYKJz6X0hdQzKQ67XWqiPRgOSoAzaQNJ8h25oTJpfJAxKUckZnjoYA0kK5Txpm7GmUqpACfdDd9cBPA9Ur0hf7IuP9AJWGIjYsZH2nETnMhqI9IGXZsVWFNa254cMXxtKSIquufzwzj6LgSkiIiKiKhQJ9aNn7zY1Uq42MBpu1Kk/yJNcJ2qaShPi8jEfYlwpro2d63yH/C35q2Q0QAmClUkgTNM90F3eIUEpJs0vDgaliKh0In3Qtz4Vb0qs9e9KGK52YBnpulk/JTZcrSRnlOCUNC9OGDlEG2hua1thdbdD3c2I9MGU22Up/cIHX8P+4URERESVxraZb7birvPjbGhGL/TOnbGLfZcv1oIrMTCVGshKVSaBLMofBqWIqHSkwJGCSgJO7jrYbn8sqZgVgaZJiylJgm9Cm3yCavlkmwHY215UhZiWMHKIZgxcnERl8Yjq4hfe9jKiVnBIv3AH+4cTERERlY9QoA9WQr6jUDC5Zbymu9RImB6fH42tU+Hy+OAa6G3RG7LjqUBUb4tIUPXGoDK5zo/fTJbvKQTo0hMmEpufGIBKG8hKkS6QRRWNQSkiKj1neFp5mBFofdsBW0WYVMspe+fLsKULn4zG2LsNcHlhj5sLzXCnXZ1tx/qHa+6BoW8HmuDG57N/OBEREVFZBaTWv/w4wqFAfFokJS2U2+vH7GPPVX/rhhuG2xdPAWKYsQCWOXC5lxjcojK5zsdA10rbBWhyfa4NTbqeNpCVQHpMpAayqOIxKEVEZUZlqIx129MGkkW5/INd9zSnAEu+e5aWMdg/PDEoxf7hREREROVDgkgSkDJcHhiugZuOCfEKMxJGJCQ3FBlsqrlAVioeA1WHQSkqOdsMx/OYqxEzBhIVqgDECAQlQXaV0GxbJWwMRWzY0o2tSmkRGx7LHkhubyeflCQgpQ0mq1R/OvNkWsLxYUOHlu5uChERERFVDAlIuT0+9beVcg1sSXevUTDDfap1vBkeSIaeUmco5sjN1VRfGc11vjxbsBGVdB2mDc2yEU6o76R/TYI0rxmOzz18DjLJS5sa67Ls2Oh7VHgMSlHJxBJN+2GGA7E+xQNBqcTWmJrbp5Yb8+h70X5oWaLqtjQRdbHfed4Ns98hQ7AORwJQ3ZvVCCvq73BvbHrXu7Al0aGUT9KEu2VWvraaiIiIiKqABKT2vbVMpW2IDtQnomqIvkEcubmEZKAjGYF7gBbsUPWH+A1oZxTuhOXzSQUkXf7YQEmSOiRx04zBPLSqPkoFw6AUlYzLW4+Jh52TlNenP2yrh0NOALokoo7k0FUrk2g/PNufgpYlAGK7/AhPXcTAVD7lsN9Va6hcChc5RiRwqFpPSZc+OUYG/rZMWNEg9GhocMQ+IsqLnp4edO7rQ2PjONTX82KdKBQKYdeuXWhsbERTE4eaJyol6dI3+Lc1eIM7oXWL1DMkIKXp7nguUi3hZnfiyM28jCwyKwI9sAPuHStigSc7Cr1vG/RID2x1vS/fiAbb3TiY0kPTYPkm5G0TJBApAUn5/v0pLarqPLH/c8TuwmNQikoemEr6v27D0PPbrFVa6qjAiO6OJcseMj+i5stytdOgtvBy2e/qTsjA34P7PjbiHmw9udWuukOhxQol1ZxOrjqksIg1r5MR9+RiQ+52aAMtqIho9DZs2IDXX38da3d54Kurx6wDZ2HatGml3iyiknnvvffUY9++fairq8P8+fMxZ86cUm8WUc2RUfgk6bnkmHK69JnhwaBUYusW5+a35vJAV8m1Y41v4gZGbqbCSb7OtwFdBjIKQ5OHXNPrLtjSMCCemsPJKzuQvEPdmDYGBkCSekKe64ruevVOxkAQyuFK+T8VDoNSVHZNbM3g0JYzdsgpYUbf51sFRtIkzLOdAAkVRNb9rmmwdW8sMBj/DqKxllHq5ogRC0Y5renk/95xqiBD86x48nPDDMAz60zonsakCxCZZyX0C4+/N/uHE2XV3d2N9vZ2WJYFv8+NUCiAv/99PdwuXVXGc2GZJsLhIHp7uqEbDBQXEvd14XV37cOeXe0wTROtra3o7+9Xv5G2tja2mCIqMo+vXo3Cl5j0fFdX7IrP6XHhtG6JBrtLtp21TtKjSG+U2M1/5zrfBlzSIKBf9ZawNZeqC8TrCpoBWx/oDaGCT4mPgbQeNSYY6INlDh7rblMfDOaYOlyGgbr6BlQyBqWobERDsT7f4eDQ7l5mdKCAcfmgz2Sf76qhuRCZfDJg+OOTvOiDvvVpaDLyigS05O5V79bBQJV6naECUprhjQW3EFUBKd07UDGI9MX6h5tBOXiS+oU72D+cKDOpcAeDQVXZnhgJQq/X0d+1H/VaHxq9g7/XbGTQir0G0OS1oRtsh1pI3NeFp3mieLc3irBlqGCtdN/r6OhQvxUGpYjyx4wO3iiOpoy+lxqYSuQOm/FeF1QmXHUqPUpifllpGWX2r0Gk7giVW9a985lYS6jBJQYDUioAZcdSfUhSc1u6WFoqgKXyAddIQGrV84+pkSkdHtfgjXavS4Pf78eic86v6MBUbXybI3T77XfguedWZpz/05/+J1pbxxd1m2pBvM+34Yq1gEkkJyJT+nwHB1vNjEFUcucNJDnUTBu6aaMnZKsLzXKg2Rbqoza6gxbspDbGlUOP2GgyYyNsqCTl0ixWj30W12CAXwWkbE/iBb0LkP9b8l1Lm+qBllNCc1rMyakrcSXp+4f7DGtIv/D4MuwfTpSRtIby+Xzo6+uDx1uHcDAIf0MTxrVOgr8+twq4aUbh8fpQ3zQOhpzXqWC4rwvPMAx4fXUI9HWrawXJtya/kVxbDhKlYn0jma674PH6VeXbHGjRHknpPCFd9qTrXjUKDdyAz3V65YiNpJgYlKqzPeiyGqBZOpok0B+N1RXkMt8rOaSMpni6Ds2OIuyfCVv3xLr7mQH0tJwMM+qLVeiyaPJlritUCsuMqt+Ey+WGy+2JB6IcBiIIBCSJ/9jrx6VUnb/qPBg3rllFHdNxubjbCsrwQHcld/eSoT/tAoy4QGXIXQ9r+iK4BwJKdrgX1uanAbc/IVipx5NVZgtMJfYNZ79wotxJyw/Jl7N69Wr07d8Hj68O02bPyzkgRVRt5NifOvtQ7O/cic7OTtVSSn4jbCVFY8H6xiCvvx7zTlwMK+FavzeYHHSQgFRqCymqQpoeawllSx3QUgEpe6B7nwSp7IQeFrXC5fbA7YkF+DwJCdl1W0MkUvlpaGrrbDcCH//4R3D66SeXejOIake0P9a8N577KSGIpPKZRweDUmYo1jVP/R2GDRNWuGdw8THkHiOiGEngLBXvNZt6UN84jgEpqnkTp87CrknvYMEJh2PChAkMSNGYsb4xNDCVKKLnrweD5BO1pOeF/J0y+l6lkXxMKkF4BrbkZSrwiOLlsA1UPRiUotoc+cGKtb5S0+3Kjy6XM7V/nTLLCTipOx8J+z3aD8/2p1QiRH2gi188h58Eo/p2xv6unxJ77tuR1I3T0g2E31sRb9It+aSk+x48ldu3mqgcqGHvW3yqSwURyd1qr0puLr8NIip/cqNS8ohKihBnlD17oA4QX8ZVOXlGJRjUuPtp6ObQHLwOy/CjZ+KZBQsK5XsbnLqCeh4IdGmmdN2Tv6VbXyxwyDpb9WJQimpy5AeVAzGhQJITp0T0KX9kf8p+lQJLg7PftaTUUPK9yPcjLaTk+1GJzQf6SyeljJILBTMKfcYZ6r/WlqdjeaVkeZXrQ4Ome+J3vOxoYHAEPiIiIiKqSZI/tOWQs9V1oTMyXyCSEpSqoBb2EqiRa2sZ3drWhqaykMCNuva2zcGb8WW6DUPqCgMBKT2h9Zoso5lB1W1PsM5WnRiUymD9+rdU8sEtW7YhFAqhra0Vxx13DC644P2or6+MkxZlHvkhZNoIJ6SnYhPTwjTp7Rt/QlLTXvdAGeKRPAkDASn5fhCODdcrhZszJKzkN1TT5K6WGoUv8QtTw+cNdOfToXsSEuNLD8CBO2FERERE5aqW6huB/l6YCcmY+wPJXfNCYX1I9718cQa2MQZG5tOrYIQ+CQY5eZaSqMGqIxWxDVL3ktZUiXUFSWSe+H9VR0vIIVUpdTYZVd65QR62NISs5Ny2IXgKdrxXIgalMli//u+4/PJLcPjhh6kT6N/+9hruuusevPTSK/j2t7+ClpZxaV+3dOkTWLr0ybTzwuGQeo5Go/GHjOAiz9mYw4wsYJpW1v/nwsrhNbksk4ktSepSmsoOXcaMDf8ZDcEaGK0tPk9GnlBR89hwoGpEtpTVaSmvSSInzMSTpiaJ01PukmTpF13s/tRqnbY1qm0qNdWkd88zqlBJ5XTNk2bUkSlnQJPvxB5snhv7fp1mVDIrCnRvVHmjpLueteWp2Lze7bHWU3KnRDdgt8weTHyujoOB4yQhEGmnFAaJMs1LN90a6FfoPKcyM0zPZVkzmttrzYFzhzyLaI6vcwx3ziEiIqLyrW+MtM6Rq+HqHCO5NolPNy0VkHrp2b8gGAwObmPqqHIuHw49/lx4/XWjqns4AYCs9Q1n3jB1ktzeMGEdI1hdpvpKrtPjXdrUmw7dP7HpNvRob8FyPuW6DbJc6jYMqeMY3qTdl1t3v9zqR/F9l5A+JEnqdX7K/7PVHbIxw/3o2vAUzHCsLuQyNLiN5HXV1fuHHO/pWKapRiaMhEOwB+pImpk4+l5UzZdReFN/e4VQqDoHg1JpnHfeObjkkouSCoIzzjgFgUAQv/vdvfjNb+7GF77w2bSvlWX27dufdl4kEmuKuHLlSnX3Q07cmzdvVtN0PfMX7DQ1zSSQMj+Y0iQ1F8EchhsNjXC9ajjXgR+PtEoKmyknVU2HnjCCmmVG4NOC6keVen5zOYWHywWtZy20Pje8KctEU9afjZS55lgLJCsCb/97ybmRUkjLn1DdgfFuZrmz0RjdAQRXJSf8LiQrMlCIZNoiLafPIf2+vXoHbEOCRsnHtaZpan9pdjes7pfUaBrOa3RDWksFoFsuFWyKdfGLAh75w5CdCbgH9nWdOxaQim04dKsTmiyjrhHk9kwYxr43oPUPBiKjKYVBokCGVsBmwpCr8WUHpnUnjHyRyJfmNZn4Utbhz3GEQAny7ti2Ga+pFmU66kY4smBfX9+IliciIqLyqW+MtM6Rq+HqHLlcm7wUkQFokuslUqHu3LND1XcMw6WenXuQTsU70t+NHW+/DNfACGMjrXsEBkbqi2aJV2gDdQVPHu756gn1jtQ6STaZ6iuJ8cBY3SI2ITUuJ9fMHlcPbCMMWxtalde0KDQ9jJbuJ6El7uS81VEGrvXdfbD1bNsQQX14LeyoJ/Wd0RjZFssTlVJPGGmdYzjeiBYPCqnnlLdzpse3O6U+kK3ukI0VDUEP7oEhn083YECLpY4ZYJsmgt09Q473dFyIqHxogUCsV4noH7jJr+brkuvQjfbVr8Gd2HOkQApV52BQKo2ZM2eknX7mmafi7rvvw6uvrkZfXz/q64dGNv1+X8a7Gs5diwULFqgRW5zI4cKFC7MO+9rZm/1M19mfPH9fyv9z0Z3ShHa0yzjCoX68u2oZoqFYhDhi2kNOwobHj7Z5Z8HlHdyPZuvR6A9GM7+36vMdWz6YEgsaScEVitrqMRZ6pAeN+6TFTn3G/tSIRNAzbj4s98gSosbuItjY6TumKP2ms7VuckjT2Z6204e9g6H2S2QHbKMOtjNa3gDDNuHq2QDDCsKM+AcLHCsCo3+fKth0lwd202x10WJLC6lgZ6zQkrsq/gmxbQl1SRvs2B0PKwp3XQu0gfey7TBsuw/eliPhbhgcGcmV5STq96af1+AbOr3BGyvRmvzpC9JM09NpqUtednzK/zOROyHy0Y89fgEMlwvjG0Z216K7e7BgIyIiosqqb4y0zpGr4eocw12bhMNh7Nu3F8HgYE4gud6WINn+ffvUtZ3H48H0Aw9CFIPXzpFwEN29fZg059ikkV5HUvcwu2KRJiuU+fo+PBB0c57HIpBQj0itk2STqb7i1Evkmty3a4XKoySs1KTsdhShYDfCdQfCTpMHSzPD0KPdqvWMpMjIdx1luGt9Zxs0sx89nsOHrF9e6+19G30hGcRIG1OdYzhNvtj1sXfgJrAvZVf4U24kp9YVstUdsokGexDp3KG6jRpuD3SXBk/Ce0UjITXIU+rxnqleMfPQ41XgNnGaY1ydBpdhoK6uOIM7FarOwaDUCPh8XjQ3N2H//i7s3LkLc+bMGrLM+eefqx6ZvpQlS36mAlBOEEruFCT+Px3Dlf2EbBhW1v/nQs/hNbks45AWN9FwUAUY5MeIqB3rgjdAgg1mJHaydUZMEy5fU7y/d9L60kX6B4Z1ja8z5f/ZyLIjWT79OiRYpMHSPGn7U0vTSl2aVErz2NEEljR99K8d6Vup7Q2qlkuZCi+ncBxue5z9EmvUm3riig4kKtRVQRbLCaXaucbutEjwSTW/luH5dLnVkrIhif/Xkqc7d1vUMtpA177BY0tLuKsw5PNlmJduui7BsITnVEaG6bksa6TewslC3W10udTDNYLXiWznGyIiIirv+sZo6hy5GK7OMSwNKiAlgSen1YYRjrWUkoCUtO6OSnekgR4T8ZdpumpNrxsGdMM1urrHwDWbli1flDMvHzmlEusRI6yDZJ9uQzNDsKV+obthpSyvm4OpQ4ZeZ6uNiV8jF6qOkv1aP7YN8i/T+lWeX71Bbd9Y6hzDb2di3SC1HiE7M/v/s9UdslEjOaq6Sax+onqKJLy3OvbTHO+Z6gp1Dc1J05oTbmK31I+sDjBWhapzsGYyQirqTDmTgJQMnywnVCPhpKpOpVmSUVvhweRwwg6lFEpq2NbyT3JXaYqVNFEVEhKQSsrzZQzmgpIglZzzpKXUQKuxIQWJc3zIyB6ynLPuhBE7iIiIiCpNpdc3JCDl9ca6JTlBFVUB17UhLX9qSqQPWuJIS6ldCxO6wjmD/6QGsWxp5RQP3oSGrmdgfjGo90rTFTKXbSiHRO1UPhiUSvH3v7+D22//NW655XtD5klyvu7uHhXpnDx5Ykm2rxZIQKr3nWWwB1pSCTOlq53m8gFTFwF5Gr51SLLFHBimrfIkShmSsSGXHeu6aI6wVZYk5pM+5LJdY23RVezPkrqunBoOqT7XLkAKVwlCRaUbYTQWuJTgk6xD9w62hpJl5S6LSmZuwo70qy6A8dW5/LG7FERERERlhvWNGhTpg771KXgGkl+nMuS62fAh2HpC1tXYTgskycFr96eZD0Q1LzQrVJA6itAtHVHNB121aBoaQJI1mroPYUuHlVLHcpmxoaZk26wCbJsjsbsclT8GpVJEoyZ27dqNDRveHdJcdvnyZ9Sdi2OPParqhmktJ9JCSgJSmjRndLp3yUlJgg5y58iKwA73AOGuWFDCYRqq7/RYpCZjHy74Ioubtp32jpYa8cGOrXNUQSnbVq8tVlAqX58lcV05N/DU3TAbZ0knbGh2ANb0M+D2N8IO98La8jQgQSYJRA7koNLGzValrGohFQ3AM+tM6J7BPusSkNLyFLAkIiIiyifWN2qQuukaVNeyqhVU6uzoQLe14UaW01yI+KZg//hTYbnS5xHSzQCa9z6Xl81OXzfyY/f4M4Yd3c+CPxZ9SmDFb17L8+jqHJ6UBOSJXRrj02wtofudK28NGagwGJRK4fQQuu22JbjiiktxyCEHqf+//PKr+MMfHkFr63hcddVlpd3IWmFIYrhYs04tGobdsy2pdYy+dUXSyAweichL66kxBqYoP3QZZU/6UCeVJxJYtNKPtqGaKVuxllHuBmjegcR/A9+xGgY1TTNlmS8BKd1ZnoiIiKiM1Wp9wzItNfq45JhKzJUUHRgtsBY43fKGTJfL4yypTZJIwMfVANM18iTl+WJJbtgyIAGpcXuehm4Fk6drgHsgeKV7/LCmSw+b4iQDT8qhrFqFaYjag4E0MxLGKAf2q1oMSqU49NCD8c1vfgkvvPASfvvbe9HZ2amStbW1TcD7378IH/zgYjQ0MNJadHKmloCUSgw3ENBw+ZMSZWvRgEqcZ5cg+GJlmF5rpGCQuzPSRkqeDSug8gfE56tE59Knz5NxGNjkFRqqhZQtd5bk+09D5rOrHhEREVWKWqtvSIJzSXgcDoVgmlEEA/2wtOTrZI/XDz1hgBoaOy1DXSTT9HIg2yYPI9qbdr5Kfm4M/jakhZQEpCwtpQWaBtguLfZZozm0QMsjqZfIKPOmdNU0I4iYmvSpTFrGX8/jPRH3RApp2XHYYYeoB42dRILVc9ROyguVmJh6RCT4oIbsGAhsJN5piBb3BKuapeo+dSI0pF93GjK/GKPnlUOATQJSrXtXqP0RG2EvJrE7oAwbG/FNguH2xwKNKS2fUgtJ6YKnzzxrMKl52jdmVz2iXMmITP39/airqxvRMOFEVBz8jdaGaq9vRMKD1/nhcOw6cNKUAxAOhxA1I3jfae9H1EhutdIb1uH183ou8Zo4VuWxR5FEfLCOkmlgqVLXUaRuIfmxUj9zXWCz+ozjO59N281Rtrtn4plDWmrJsrbkn43/X3rdyOiA8qL09bRCMTz1mHjYOfFBu+q9Ghp8yZ+1qc7D4z0Bg1JUEJrugtvrRyQUgKUixDbMlD7FEkEutxYu6fokDznJD5wE5Xlvaw79qcukeWuhA2zOnQoMJDeMTZRE51rCnY9gfKQNLTo0OaPi8Q+MxDewCgaciPJiw4YNaG9vV0l0fT4f5s+fjzlz5pR6s4hoAH+jVOl0TYff70MwGEIkEguGhBJuSkuOn8a6ZjQ1tyCYMop2JJDutmgNkiTmhk/ll1Ld+dKMVmgZ/qzX5FL32N925pjqKE6dSHLFjub16dYV+1sSvWvqWeXQEpokb3fF6gp2RLV6Mo062CktiSSQFbv5XbxWT6Pl8g7WXzw+DV5fcg8Rrz/nzLs1gUEpKgiPrx6zjz0X9kBkujdooy+UEunXjaQfbKkltvTJRAIzEohKDExVg3wF2KSFlDvcIeOCqP/rCXkTpNmsbpsI189AeMppgOFPuw6vh8kIiQrR+kIqu5LLo7m5Gb29vVi9ejUaGxvVIxOpHPf09MEdGnnrVss0EQqF0NPdrYYCp8Lhvi7efpbuR/K7kK5I+dTT06N+k9K6uLW1Vf1G5Tfb1tbGFlNUMdweD844a3FSC5j9/cnBJsMw4K9rQDBlOsXYLj8CkxdJ5nP1/3A0SxLxLMZSR0nM05RpDKjUOlGu9SupI2geqW8MtoKyNA/2tSxU9RBpISUBKcs1tC4gR0ymm+dU2RiUooIGphxh3UJYH2G2JzMc70qmuvupBOcqzIFCcFr6SKTeStNctJKi86ORlwCbbce67km/bikwtVhgKkaHDAIbyynlh+1JuciO9qucYOp7DnfDlhePsJueHemLN5UVZsI6opY20MebAS+qPdIdSCrSEpDa1xeF4apD9/592LCjFy3hzBe2tm2gtUlaN448W5+0jvW6bDT6bBgy1jUVDPd18faz32tgV5+BvaH8Voz27e3Fvp4g6hoaVfBYgsUdHR3qt/v/2XsTMDmu8tz/raW3WTUajWzLkm3Ju+UdY5DwvkWYGJIAMXHC8g/GlyyGmwQIIckNzsJNCIEkQMLFhFzgggFjsAkIMN43YRtsC0teYsuytVj7SJqll+pa/s93qqqnuqe7p2emp9f356fdmq7qqlNLn1Pfe75lgKIUaSN6evpgRERbW4rYkGlheeU+D/EiRZuiCeEL69ppGPb4gkVqRPM0OWXyHs3GJiq1r0SUcnULdmxAiZeqMJJnK++vqTC87pUocplJuJFww5hT7FGlS3X6nuYluF8ouveKk5ZFhAMtloSXlzjo4EdpW1N5hcRdVXVW83N7lA497EzFNVW3J9SA4MqPXQlfWlEsM9X52pHBUF6SM6FQbELG1JKOtYCdRvzVe1Sy+jAxeumqktBc8ktVEqZEkMq9dDc8W9yCfZxIkvWs3DaxFIZOvoLCFOk6JD+NhAOJ94UIUjkJD0r1oH9wERLJ6rOtst5ckGS2su2BwUUwVL9KFgqe68aeZ/lN1Ps8y29RtpvP5eC6cSVGyW9WfruEkA5A7BczCVhSmGl6nifRniRsD5o5o/3Sv/deIPK8W86LScL35jvhrAQiLT59+3OwidxCzifXtxP0uCqMRPtqChGknn3sx7ByU9c2XlKmTwoCLLryauVt2AjSkxOwnSnx0Swx0MTzsa9v/m3hkwtpOfR4L/pOuKLI48U6NAZ3271+onNVcU9+oJFE2bNMnB526H5csx+uLQNELPcqXBk0lKhiIpM6rmySPTLdNVeqZKhBVjyhlNin0jMGa1T3bhMPKRGkIOc6Fgx+0T7PsYIKfFXCC13HF6SMGDTd30Y03F7FqOczRfcVId2CeFpIfhoJDxIPKTF+jzvhNPT20QODkFZAfovym9zy/C9VJbbe3l71m6WXFCEdQqwX7vLLYJWLxxNBQuLkNLPIS6qi55GTgV1abS5c3iKRHYWcVIF9oAUP5Sp8z3P8iunB83o9mFYsSZkhQfW9NsF1bSVIGWYchulf26QZifrIW2q5ExGJFlqQuuen65HJTIlkiRL1SCZO3vSmN81bmKIoRdoDTZeMcb4IpWYG5AeanxaDXbO7p2erDt2fAYipeGlNs2AqMUpcS/38SOJCHzod66585sF2PNhlXGnriezHcaESxHsLvK/5Ykis+MH7YNrjSFh7fKFPl2uk+1KUlGSFDic2c2elBtcwEXpElJpN5QwRpDS5V4JijYXPPQ2e1T4DEyH1RhImS0iQhOyJVwYFKUJai2XHrEKqtw/DyTyGhoYoSBHSacR6VSqLcniRhPC1UFptrogKFffmii/sTIVhaq6lPhPBqVy4YFFFbjePpEz6w4+iEMweDYnMYUwmVwY2l29fCa7nwXWje/Mx9NlVGpRgCS2cFC8potTqGGYMsbhfNCoWEaUEu4HV5sVDSgSpWEza4wuIqdhUeyzLUl699RDJKEqRlsO1JjHx4l1++F74mXTUKt9Q8IEZh3vEG4DYVAdoOeIWOzs3VRGgpBqcOPf4f0uH6eetUrmPyCzizk014IgU5UnMXqHP8vNM8XwS0nxElJIcUjOF7BFCmkNPbz+WDptIpfgbJYQ0HxGVUpmX/Zyx4Wfi6RQkJRdxrDTpeVEeKcNUUSiuJDZXNpYYc4G31DTpKdy+eHuVfBbksqq10mDM0NCf8I0RFlGaHyJIJRK+SJaMF4tkIkzVA4pSpOVQYVj5LDTJ16BC9UIfTEyF6olAJYJUNFl2vsYZBskllZ8IhBIptSqunZ6v+nuuXzmuUDKOiCdUNRfgQgiknvDdcN00NN9n1telJPl5MPj4bsaa8naLnmG5HpCBRq6t4+fzQh1degkhhBBCCCGzxVU2k0Q9+BP38pTuR0M4RioQi8qHC/qFo7TASynIN6vsLLuq15PpTAJeumiZ5Kn1t5mA5kr6lqlk36EYFoYMTt9wUEQJZtWiSeIYEU3zIUWSitrAgkkLBkUp0roYcehBGJaIRnMJ5aqUUNvMjcHM7PTdSMU7Son2ftyzq+mwDenoJN7ZKqQ2UgJWFwpSIwenyrgKunTsEa8n8Y4yPEvNhGTjR0DzLD8mXjN811k1m2Ijn1zmJ7H3bMT3PFS0DRGkjLRcD1OtoxLZD63yc0wRQgghhBBCGorKBSUT9jKxrIkQ5Ys0fnqOMFm5V2OicrEH5F0yuod5pcRmmBJ+HKMHBwZehyWHHoTu5YrbErzrnoWB0UenJXI3rf0Y3P8gdCVY+ZsVbyn1HVX4SIOb7KtYNEkKJk28cndRpI4USYrCgkkLB0Up0lWECbVF/Ahf0qkqIdzToWs6dM+F7uWVkm+6GbiY6mhFvQ/jobuBaElYlWvLs5HIbS+48IrbreY6fscvyzUNhpuDa8g5kkEsWEcNQLKeP4BBBiFDcoDFphKZy7WQv1UOewnVZLgfIYQQQgghjaQ0T5MfaidMPZur53b16UyRKlKJ21Q2WFFeKnEGcP38vlH7SuwEsR1EoBLbI0QPvAQkhM8s8cwSD6nBAw8hmd4aeHPpyjYJi3Ar3UvTxdSrWDSpXKSOHql859kWCyYtIBSlSFeixBDVORlBJm5RTwzkjX4lSOWUx4+D0YHXwDYG4Bp+bgfpMKWTXOiwOCUGtZBnlgwK4i6rkr3LnIgSk8TDzIGu5fzocCVcycc9yKaOhavHIX25ibwK8ZsYuRhmsk+Jgn37HixKaq6Iin0yIxOtqDiL6oqeCF6BjhhxsGup80kIIYQQQtoT8arxchHvoNIk5fJMO8ccRlIhXAoyheglTkhakDajUlW5elSbi+ZpcnLjKneUhOoVV8vT1LO8H0pXGVlHqplL8ajgW+gzR5FLGNg/dBEco6+sfRXaHoW9BaKUWyZixq9IKB5OmrI/5PxHRSklnIl9oEJjao/UiYpSst9GFUxyIsnMDbe4+l6nQlGKdDWqcoTkMwq8csQFVSpAaNit/h4a+wUcsx/7hi6pmxhVKSyuqF3w0JO0YOinwzb765b/qX6i2lRcuO/OG44W8omrBgTl0qtJ0nPZbx6u2QcvVqGSkHxXQvaUh5Tjz2JIlcXIoKOZyeJyetM2YUCTCoziCRdU3/BUfqrg2CUqMJbywwMJIYQQQgiZgyCVe+luOJYvDgmlSblhJuEuv2zWwpQIUqnd90BTAotPMjrDKuJIEOmhkn5XqLJXj8iOMDTOkUrgqtKfvOaW71V5QwX/VsnNlSdWTAlS5ewcSRXiRlKo+N8LQgfluCOiXdF+xJ5QqVkkEkY5TAUL2sO7SddNxBMpWLkMHDsQoCLCmCDLDRWR0jjykWTmekQkq1eSc4GiFOlSQldSCxokTjr4gan83EqaUh2viCuVkvfVMyyuFImX1rzqAtNsha5wkKq3wFagUMIwiBGXs6jJEFLDrIIMTP0r1TbU+nYGxopLocX7IusYVZMTyrLEqsuL3GqjZUt74hoTFJJppNMZ3Hbb9/H4409gbGwMw8OLccEFa3DNNetgmrUNkc888zwefPARPPfcCxgdPQjTNLBs2VF4wxtejyuvvKThDw+EEEIIWRhUmJdMnOqRgkxRUUq8++3s3IQQKcLkSNU6XwRSm44Ue/Kr0uUxPnIRLCQrb0ZEn4V41p8l0la3RLgLU3pAqvGV+46TQSK3G+rMRoS1QuopsaFCj7FZTNy3A4lUL049fx3cyKT8QDIqzYk5ZCLVE7GPFhDTMFQl2Ewmg3zet+eckkfjnp6eujznUpQirYtjFToyzympvlcHrOQyPxlexoET5JaSgUbyJWWTK5Rnj7iaGm5x9Yd6UuqaGhJN7F4vocsfyOovsPkCn3hN+YkQVYy4k4Hn2Urcl0FEwh9nnLEpJDWXL9hKkNISA7NrSay3qKqfESlbapaUMCVEBKmbbvoHTE5O4sYbb8DKlcdi48ZN+MIXvowXXtiCD33oRuhhEoMKPPTQz/Dv//4fOO64Y/D+9/9/OPbYFRgbG8f3v/8jfO1r38STT/4SH/nIByhMEUIIIZ2EEYcWpqEofcSca0GmgGiKC6+oArnsKg/PSMHRGiNMlBOYSj+vlpMqTIIukSjqXU39uwVvrtIoD9MZUyk3xDaTin/+l8T7KfinSpLu57nqRBKp4snznlT159CFpKe3D5ddeTVsZ+pcL+4tbo883/b1zf9epChFWg4VhhVL+tUPwmoOJbHaKpRrrm6pro1Ydrfv2eO5qjP0A9B0FXqmOk1rD9JmYzv7hRa61AzFQuRV0nSkE8uDuHJLJS08tPgiOGYf4oamKl/IoOOZzZ+xISTKrbd+Dzt27MSHP/wBnHzyieqz1772XOzdux/f+MatuPvu+3HllZdW3YbMHIlH1R//8R8oLyshmUzi+uvfhVdf3YVNm57Bgw9uwCWXXNCQYyKEEEIIqRflBKaZwgXFS+vA8CVFwpEdOBjIZyl3M/b1nqn+Lo3yELvMt82kOJJ8rsMyF00llZL9ME9sQ4WpKIN9CyOSUZQiLYce70XfCVcUhWHl0yXavMoLNFeRw1PiiSednej1nhYJ31NOpUEnyupvxV5W4sElSQLl3OiB+22Qi0tVzkio+QwPthKkJBeXY2gwzPIeShITXt4fjAMNWXgymSzuvfchLFo0iLPOOr1o2UUXrcUtt3wHP/rRXTOKUv39/Xj9688rCFJRzj77TDz//IvYtOlZilKEEEIIaTvKCUy1hAuW/m0HHl+yHddOqFQiSnwqifLw3CCNithmyrvK9qt+q9J5oY1WGc1zlS3i7y60QZzaq3pHInVcVcEpOMYwxxNZEChKkZYVpqJoTpmOJF8iadjpoNxoeTzd9F9GErp0WCrfkQat4Bbrd4DSETY/kXjrzY6o0D/lCWUBmoh6emGdWP4AXJhKqNLhwrAn1DLD06B7JZ5S4o5rplQVvrIVQqRUxgxJzQmZL5s3P6e8nE44YaXKfRalv78PRx55BHbt2q1eRx11ZMXtnHfe2epVDvGY8pl9OC4hhBBC5odjTRZNcjuWPx67gQ3hR2f01l5xz3XgWuNBQR15Fg5QZooOGOXzJLU7C52fKhrloel5v3qev0S9VK5dN/DQUXaYpqrtGfa4/x1JG6JELPl3Vn1XPdoVzEeZSPd826KCfVEuUsctWbVawaTSey0fTQjuarAQQzzJvLaVoChFOoP8JOKv3qOEjkqIIJU/Yi3s4bPhWeNw9MBgTG+HK6F7IpzIgKKSbfvJujXlHZRXSfcMzWhuIvEmIMchxyMi0/DhRxCDiFM5dX6m8BC3R4N/SUUQA9rofWpwkZxSepBTanzppYDZq8Qpa9llFQXEhCQnl23MsZQuIbWwffsO9b5kyZKyy0dGhpUgtX37zqqiVDV2796j3k855aSq661ffyfWr/9p2WWW5Zdatm1bveaLbMNx/NdCI/uQvHyN2Fe3w3PdOedZti0/9Xr83utNK7aJkEqISHDw+bvg5qdsAzt4fLWD3K1StVmK5Mz0zBlW3AsrPDvjO4M8R75Aoea3ZeJ7YBXaHb1kAt6I5vVtQBJ1ib7IG32qIFUoSImdJklWplZyMDD6sF9lT60lNpzYb/ZU2z0pcBQmogqibEomIaPIPVAaqSNFkorWqVAwqdy9NhaJcjMNTSUEX3XuVRSmKkBRinQGkmBbVcKYqlZRWmLVGN9aEK307F7o0pFJTqn8BAwEinhQCUIl7Xa3+KF80DB8eAMODK6peyLxMCyu3OeNppoXmIhQhpeHrfcgb/QG4Y7BTIHnIO74MxUyiMgiW9aR6xBU3xNRr2jbZk9l35FIxTxCForDh8fUe29v+QcreXiIrjcX4+2xx36BoaFFuPDCNTOGEh48eKjssnzedxffsGEDenvn/yAj3mGHMy4Mc+Fncz3Xxd5d27H5CXmQa16izm6A57pzzrNj5/FqSkcs1noeF1IUgpB2QXk15TPQJOep6VfJ08K8Riqay/JFJilyVGvFPSOmtueLUfpUniN5xnVygFN54no2RFNcFIofeTZ0mTCXd3sChlZ/sUgEqUX77i2agC/RpNQEvITz1bKvqMAVFq3yCzPlYNrjQbXuMsh5VedYPJyClCHK/pJ8Uo66dmb+YJA8XfIBu8jHhpU3lIhZKupFN+H2Ha2EKxGFVBEldQBOzZE6tRZJKnevGZEhQkce+ZzcaxT2K0FRirQv+cmpcqv5CfHFDVT1SIcWCFSeI524489iqDKrJjxPh+7IA5YMRm6h0wgxnTQ8TUde74MhbqOBd9B8EomHwo+INOKVJX8XIeGDmh8GpzrVCsncywlIhjPhe3V5k/5gViLOVRO6ZHvVvMBkewlrL9KJo/1zGg4Mars24KZ9B1t1Xlx4etx/yfHIOMI8UaTFsCz/QahSVTzTNIrWmy3/9V8/xqFDh/GRj3wQicT0/iJKKpVU4lU1T6k1a9ZgYGB21SjLIWV9t43aSCRTWGjE48N7Alh97uthGHzcWEh4rjvnPOeyGRyz2FRluFuNsbG5ifSENBMRCXTTH4f1MK+RaA2SpkiF4c1iW3pcfVk3k3Dlu2GeInkXsSOYIFdpKMJn+Ki9ItsoST8iNolM1gaNVWlGVAha2DYRpTwHsewu9ewvz999e+9HT9TmCcSiQyOXzkuYKqrkHdgRTlA1L6y0V+sEvAhSwwembAs3Un2vN5HG0txuP/WH2BHlELtFzmkgXEmmKbHLRICS86G7UsFPbA1Ttcsxe2Dacbi62FEadDh+6hCpYiiilBINF66ieum9Fn28lHQmygWWVIRPLqQtETdafcc9gB2IKNJhpXf6olQ4COgmnP6VBWFKfU88nIx4sI7kk9KUeOJ3eB4cLVnoMB3x9hEjLnF0NW/PmikVfvQyHbqjJZRHlrQp5T1bNgywkoAk2xPhKBywsokjikW6MtUxyg5CZbzAlNAl3mil/k1yDOo4ZMD0tyMCn8zkyDDNGXvSqsTj/kyWEylzG8UOfPzD9WbDM888j9tv/yF+53d+E2eeuXrG9a+++ir1qmQE3nzzZ1WFP3nNF9mGPCg1SrjQdV3ti0LJwsNz3RnnWbZbr997vWnFNhHSaDQjDmNoJbxIvltXvJrtNNzllwCxPt/OkJDAUntFnitCz6cAybMqaS2AlBJRMkdepryiQiwbyjOqb+99vvePFle2TdSDSU1KzzJaoxoiSPkTzeJ8NLUjOeJKFfgq2RZii7hSECk4Xf7Ee17ZHIaapC/9oq72GbcPB84CwRftUmNM7LgEnPiQOt/Kngs8rNQ263QuSGPg6ELaEzUbkVWdsxKZHPEqMgMvHj8vlLhpVq+0IEq7kk6mqjOIAq/+4akOVJb7nkvzV7dLhR+Vpk9Vkwi8tLw8DBlQRNlXTXCVAGWb/VW3EyLbs1Mp5RKrezb2L7oQjtE3q0TslbzAyrrXStiefdh3J/b85Zrjz6KmMq/4sxmaiXzP0bM8U4QsPIODvtfR5GT5WbN0Ol20Xq288sp2fOYz/4Y3v/mNWLfuijq0lBBCCCGtJkwVFTGRR3mxO0SQikeeG7wSeyUSxqa24+aDwj+iPAVfCb2mwk2HYXoi7Bg98MTzJ3DOKmKWXl+Nwg0ErrC5Mnmt8vgqGyYzLZ2JOieFKJZSyaokx5M6CSwm0wlQlCLtjXTwQedcSDgoieyqCVKiwIvQpAQgz682GlR38EP0ZLmMDAuT2ygUfkSESmVfnXJbFbHJc7Dk4ANq8BLX1pH8IewdurSskFReQEr44pybVoJUqaBVT3yvqSlRL6iP4Qt6SsjzRbdp3lWEtAArVixX7/v27S+7fN++A8F6tYuq27btwCc+8WmsW3c53vrWN9eppYQQQgjpGHsl8lyscteWq0TdLWi6mmQXmyhMgeJ7ffm20XQbwit5j4RQkraGohTpPvQY7L6VcO0s4pMvKwHKsA4rbSVvLiqE9qkqDgupp0iVP88OBDA/YaLsztFTfsJ2Velu/q641RKYq2ZUyFtVK16Jp5kfxxe6znKgIK3J6tWnIBYzsWXLVuUmLqG8IePjE6py3hFHjNRcec8XpP4JV155SZEgdeDAKDZu3ITLLrtoQY6DEEII6Was7KRKIJ3P+M+ctuU/vDu5cZX3SXMsIMjzQ1oLVzNwYHCtqtIdzZG7dPRuaLk9QaVuPTIJjjJilV+WirQ3FKVI+yPuqjLgiPCikgH6lRkk8XmYAL00ybeKlZbSG2F1B2WQar6YEoo0FQSV+lfM8/epvLbk3ypJeFjZY/Yot1c3rzp1Sag+fPgRFdJXmkw9mmdqtP+8mrbtz2QU55CSkquhNFWI3468qxkg8QKzJ6AFp0hztcpJHglpAJJc/OKLL8Bdd92nRKOzzz6jsOyBBx5RQlU0/C6dzuDzn78Z/f19uOGG96i8MqWC1BVXXIK3ve0tRfvZs2cf7rhjfUNFKclDJeGHUkGwHsnRCSGdBfsI0kmC1EtP3Kkqm2WsQJQKntFFkMod2gHNiCE1vFKF3LlB6Jx6fK1U+a0K6jthgEM0N5TYIbNFno/le/Lcnp+AppfMhEvS82Y8G0uUQ+TcRCfolY1RKTH5HBFBqjSyw09R4ketiIXh/1cuUM/zQ/giNpP8LRaVXxExPA5JdD63wjWzwbP9nLpCJOWY8uianwvAFNnMJCYiGzed4vy9pmGgp7c4fUs7QFGKtDfSOU7s9Dsae0KVAo12UtrEy0rgcRNL/JA9SQIu1Rek/5IOt1A1Q5WI80WUcNueqyo3mOIaKt5UktTUSMGUBOMVOmTpWA3ThCZVHkqQygu6SqweaGEqQV9JSiuVRDWoMivVTDVNlTGNbq90O1FksOixdigRaumhB9XAkcjt9jv1YGU/CfpR6rzoroQM5hDT3YrbFHRdGmNAlyTmot0pcUo8vZyiYUKWy34kp5V/DRxVQcTIH1KVQvSgDH3p6SkkeaQwRRrItdf+Op599nl86UtfxY033oCVK49VAtV3v/t9nHHGabj88osL6z799DN46qmn1b+vuuoyrFp1nPr39u07lSCVz9vYtWsPPvvZLza1WtWWLVuwefNmZLNZJJNJrF69Gscff3xD20AIaV3YR5BOQnlI5TLQjRiMuG/Whgm1ZdJaPhdxyrHS0I381JxpIChpZgqapP2YAVlH1vXszFTFvqjoIP+OVtybCZk8Ht+qKsIpkWfXfdBLCg1JFT6V9ByNq8SpORnEs7t9YScwCKKH6QtAUr08A2eWKUKMwL5QZo+YFVIk3ats55TzfQrz/k797SlvKtcIbDyxSlROKtfPSeVkfJstmAzX4kk/zUudkftDj6Xg5jPwLLnP7CI1T/wlYqkUrGyQQ0sm41P9cxKknnzoR4AzlTg/YRafKancetmVV7edMEVRirQ3Iiap5IAxePHFUx2VdExuHm7PUarLyo+8DubBX6qOS7PTkMkI17H8gSD02vE8GOJRFHTCYfI8E47K6WQk+jG+9NIZQ+HMConEpZNVfa7yVPIFKeWQKiJPoE5Juwz5d9AZy/pxQ4NT0llHtxNF0zyVl0oJXnoM8dw+GG4mSP4+dZx6mFtLzk1sERJeGqZ4gDmSY6vU48tvTz5xJMaWXOR7dSnPp0kMHPxZkNdKqWxB9cMwZ5elqmpkhl+LntGfK+HJDZI8RovyRZM8MvsUaSTiJfDxj38Ut932fXzuczdjbGwcw8OL8au/ug7XXLMORqSe70knHY+lS0fQ19eL5cuXFT5/7LFfqHA/4Wc/e7zsfpYsGW7A0fgCmBibruticHAQExMT2LhxI/r7+9VLEEN0bGwS8VzEe3KBkMqGuWwWhw8fLjqXpP7wXHfOebZyWWR7exdk2+Pj46pPEE/Q4eFh1UdInzEyMkKPKdLWGLE4jKDadlhUV5eQveFVcK1JDJ10mXqOTwehfZm8NyU2SZW8GZB1EqsuhyeFlgK8YBuCbXtTFfdqISzIpJ7FTXhGyq+qF302FuFB7JTIo76aFHbKezDNBz1I9WHYk5Hk4UEhJn8PUzPmUkGwREgqR2ivqFQloQ0SCEliq5jikVXFzglNHGURiddYYY3ACypoXT4+DFfERXjIx5dMhfaJSHj0BcqhIBHzNxaLmzVd79lixHsxdPIV6v4QAfTwlgeBoirpGux8Di9vvMdvRyKF/rXrkEjNri2uY8PKZdCTjCMW8++XZHzq3OUtC5lMBnaFytKtDEUp0t6EYXthGF4UXYNn9PidYWoEVu+vBLHJQM7x1MxK3/6HlVeR/MgVJdtwjSTGFq+FY/apihdFmy+Tq8nv0MfVv0W8Kf1OdODwPbXEfzgqgtVOuQHId7f1ZzckJE5TnmOS3ylwgRLvJrhwZZn85+SQyO2FdvBRxKz9ZQU3OQ4rcSRcsw9ObLBwTHKcahCVSiBlKvap73o2XLNXJW6XxOxamOQxIkp1fZJH0nRh6p3vfId6VWNoaBE+85lPTPtc8ke1SlJzCccR0UkEqXTOgZnoxaFDB7F7dBJ53X/w8bwYlgw0ZtbVcTQkTGAgocGY4eGVzA+e6w46z4kUJu0Y0pP1z8l4YHQS4+mcEqlFvJb3/fv3q76DohTpRMRTCuJFleiHmRyAEYTI6aWhcjUgYkb0V18UbjfT9qKhYxJCWGq/yKStlih+No5U0/NtipTyUNIkgiNcKYKk45hLnlixZxbtu9fPYxuk3PC3M/WwLpPNudQxysbQnWxRDqhKqDbrSbXdaGVAJUoZeZUSRPLoztxmqZauT8shJbaNbP/w8AWwk0dM+5ZpmuhPBd5CgSgFpOHlpjzY3ZJ0Ii5M6PHeOQtTU010YMZ7giqNQNzUEAs8mpy8pWxQN7BJ50IsFkc8kVT/TkREKSGfb0+biqIUaU/E9VIUcGtcZOPgw5IHOHGNVEJM8LfZM1WzwfbgaP0YO/JXlBCTj5ZnlQ4/FGeCQaBUbBLCDrwS0lEeGrm0IOKUds5+XLYDXblK+W33cz2ViZ+roZNXzVXbFNEpURyHpwa96N9+InI1m+A5av1s76ppebRUBQzPxuElFxUJUqXrlINCEyGNF9gkHEe8H0SQEoEqlerB4OAQksmpB0j5rBE4to1EMoXBwUUqrJksHDzXjaHdz7P0BfL7l76hNxlTYpT0GdJ3ENJoJBSpMCks3kvZ4mdQXZ7jGxi6tiBogb1iZ33PKPV8LOEafm4m8ZJSVfnK5c6IILmlSqM1orZLtcnwGZuobJGsyuMEw/TTnkRy26p0KCJUqevh55yqBWmL2EHlJvBT+U04OHg6XD1ets0SyRHEdQQiVBnPHzUBH4MbGygbSmiUhLUhPwn31XvgybUIyJWcdjeRQt8JV8xZmCpqnhGHEUsU2mJG2iMhpaSY9htRCQlmK9zllwHWYeg77lWCk4PiWOzQMwhVEhlKJ6+6usAHVmYLBg8+PqPYND702kIHrpKSl7ZPlTMtrpxX2jlL4u9F+++HKy6phW1Ih+VCcx1ogVBVaycf3aZj9hYlM58J1akb0ztgzc1Bc9LKS6p00Kgmjs131oYQMnvE00Hyw0h4jnhIifF54smnoa+fHhCEEKi+QPqE5575JUZHR9Hb26v6DHpJkUaTSU+o3DgSihRilYgs8UQKy8+8CvHkwoSzNoTQXok8s1t5TyU2lzxSEnGgRCuxA2ZwjgxtlpDQdqkXBVtEFYCSl29HeLDnXAm87GS2yu+bUEJSORtB2RdmH/KJEWVPhQnPi9eRsL2lygGhFq8t/0uOL0iJuBZ4MGmSKDdc7Frw8tmiEE3SOChKkfZFYoKlk9TjQecyFYtdQJKaz3G2oJrYFA4uqopfhdC1ckJNtHOWTlc6ZF+8isw6iBeVzBEYTkVRp9pMiF9ZcOF/2tKGscWvq+oRJW0xDd+9lBCy8EjCYgnJkZA98YqgIEUIiXLMccejt68fCS2HoaEhClKkafnZRJAyzRjMIDcOJC9TuNzOq+WSyLztKclh5IViktgZYr+UsTe6mXDyXSbaBw/4aVZKUTW/RZCqYCeJk4EuHl6h6CQ5rYKK7PI9TYQuXdKKRMQuudUinnuksVCUIkTiceGH7OneJAyZEVBik1bS+cWgiQbm5BEzpDKEL9wXhTkHyHgjy2W9ae6jIWYvJo+8rOzsg3zWZ23CZOIsmBUS8knC9tLvSvslRlvzLL8CRdBGVYFC8kup8DwXhswGqEBB+b4bHPPsjkP233/oMRXfXgmZvZhc/NqKywkh9UdEKckhFQ3ZI4SQEBGlFvcOqipNhDQTEaRiUhFN9ICSvEyOXTnSoRTJ0+M4bnH1PRVpVvs2mobK4ySRHdHPLD/ELz+hkrGLl1QpkqeoHkgFvNCmQaQQUyQ3ufos1G9mtG9mQJNE5nm//aUFmwrrqIJNPUgvvaBivlvxMlMFpkrOjbJPDtyn7JOYGG4SCCiNlvOc3q1SwHgiBg4cAw+JQt4n0lwoSpHOQCUQ9OaU10h1Xnvv9cUVN49Y9lVfdY8o75KkO9frl4CvJ6WuuIU2KRfTeNlBaFqbi75n++1Xic0NP35dCoKIN5a/R3+9/OGgATIjoCOe3o6cXma2pkrcuBLxnEzgmVXGq0xV85vKz+VXDAlnLCLrMfcUIYQQQgiZJZpuqkpmkjjasXLTRClBj6WUsNOKqIrgmd3qeb1Yk5M8Ti60PfcjZvjVvyvZBAuDpBIJbABVlEn+tqZK4i3wORnYfeeMqVTGjryq7Dkp2CdS1Ty3X51b1Ww5DjsTzNZPqpzEjpmAMbSy7YSpfN4qEhULn1ttIMJWgKJUGdLpjCoR/vjjT6gS21Ii/IIL1qgS4ZLJn7RmAsFK4oZnpqaS880grqiSo8FrSpSSgcEPqWsGZT2i7Am/+p0mrqtSsWMq+aChJ/1cUIG7qyuJ9myppKGCAlVn7MT61GCn58fVcRn2BBKTW6clWhRxy04sqdo+EaS8sKpeFCkqgnxRxRBd+cYW8rrXfI0IIYQQQjoN2hzzQ/JNrTr3KhXmt+ew/3CZtoqf10WQKqqM1gLIM688+2rWGDQnO1Ulu4BUlovD0+NTE7xl7IFp3kPzFK5UgnGpli0TyWFycc9R+5VCUDJ5Lc/0C5kvVmycePpl33usXBhH8Lms51Q7XmmjRImIfSeipOSK0rJT6akkUbryUlsY+85zrEJ6dsfTYAfikXj1zRXdMFWuNdvOwrZ9u9fNFwuF4gFrGq0pwlaDvV2ZweGmm/4Bk5OTuPHGG7By5bHYuHETvvCFL+OFF7bgQx+6EbpevUICaU4CQUkcWA4ldtTQSStvHy2s5jCV4M+fKZgh6V1Q9S5EzSZI/il7Yl4DhQhSffsemB4iF/Ho8vSk78WlvJwSyPUdr+KvRXCSwUwJVNndviAVdO6+wObX31PtU/8J0XtbZkVy8xbjxL02rBgSD3qcREkp7VqvESGEEEJIJ0Cboz6EidBjlv+sbpaEAbYkZg+sZZdBzx0qJDx3ZJK5CB2eCuubVIJQ3+jjM6bMmI1HVTjprWwVsVkwqWyhfGKJevZXQpnkXwoqBU6MXKwSkNdD/KrarkAE8yfdy+TbkkgM16o9+brKHxUYIOIyJS8RosTekwqIKtrGF5E8Jw8351dbFxyYsxY0RQQV7zxXrlWQXzgvkSL2lO0j3n1+dcnZkUz14pwL3oj++JTNuainuI8QQaqntw/tBkWpEm699XvYsWMnPvzhD+Dkk09Un732tedi7979+MY3bsXdd9+PK6+8tNnNJFGCnEuFxIENRM0k5POIZ7YXd47i5goX/fvu972ZZjlQzBQip2lW4NGlF7y4Ckcv63ouPCOJ8ZGL/PxUe+5CzDo4LcTRF5wCl2F7HK6UVA1nJdQxeHD1xLxnRMIwRS+IPw/fCSGEEEK6EdocXY48G8vEd5Dw3NPKRR3kZp0yoxZrqCgNiOcgltszTeSRZ/984kgl6EhhJic22OAQQnESmC5VaM48q+OFOXZFMMqPwz64RSU+F9tJ/pvYcg/0IJzPSqYwdPIVsxKmZF35TsqcEo56Exr6klpR2GkiNTfvvWSqF30RIWqgtzOEa4pSETKZLO699yEsWjSIs846vWjZRRetxS23fAc/+tFdHCA6gISpqZcglRkkYV8olOiaJk6zQRmGINbMcxGHFVRx0NCbNGEmeqBJbLKXh+Hlil1vlSofVx2TEn4kp1PchRcv03HITEVJdREZGBKahX59EjHdgSfCWzREztGgZ8WbS/fbJppR1PtIEhVCQ1+PP3jEzBh08SRTIYpTohPUjIsBTzpoGRz7jyuUSVV5umT5sgvQ3zNdcS86byWeT9E29Ce08sdNCCGEENKF0ObwsSOhTPmS6nsdQX6yULE7RItGdkQ8n8xyj8ri0GNo6IuHz9xScbyceKVBs+2an7k1S+yaLBCTEMEYvHiP75UVnXQX2+SoS+DF+pQw1V8nQUrzPCTyGgaSuppcL0UXG0cFdwQZ10vxNFWISc6Jm9Qr2yel+a+Ul5TYTX7yc5U3V45ZJvKD9CaamfQFKCOm7CA3LxUgZy+CyTZiian9x5MaEmXaSqagKBVh8+bnkM/nccIJK6GV3Mj9/X048sgjsGvXbvU66qgjm9ZOUp5kbI7eN1J1Qg+FFR2aYQYJwt1Igj9xJc0AWhyIp5BI9QPH+GGDqsTojnuhSWddlChPgyl/yyxH3kZC2lfaxvwk9N33qJxYJY1CzJhAMr8DWmYPvJhsOxlJ6C7eUUGnKmF2kME7KJ2h2iBVJjR/n3JUelCJT8ISw1kH6YyVW7i4sTrK3VSLJ6YGO3E1zTtIpHqmt7v0vJUTpaJtmOu1IYQQQgjpMLrd5jAMQ+XGsXKZQm4cyyn28ZHl4lHStsgz/o7pz/hFNS+VKGPP+Cytxer8zB0+w8cqiVxiu6Sh9fQD8QHUFU/so6Ct5RKnx/xJbb+CeLlJb/9/cXWc6WmiHzAZ5LAVqcmd2oZEfSSGfPtHckmllgKTO2EMHgM93u/v2hQ70PdEU1agU7ngE6kvbfxLrz/bt+9Q70uWlE/sPDIyrAaH7dt3Vhwg1q+/E+vX/7TsMiuoCmHbduHluq56r4Zju9WXByVQK/1dC24N36llnUp4rgvPndmhVK1Tbr2Ieh+SrNPd6zmuX4ZW86AZBrzBlWFX5CP5ofIZGCsuhhaX2QIDWiw59f2cC8eMSV3bQkcW+TI8iJBkwRDXWGeseN/5SXjWqD8gyKtQ/U460ix011f0NV2SrVvwxl/yE/UpMUxinlU5CWjjL/sDm7z6lwdilQUz2J/rWcExSZK/MBQvOM/+JvxiFHIOgizkKhxSF3HMhWY6lc+bl6twzayq35/5wsxiXVeb8XOv0jpVlpX73HX0ovdSnAqf17KuY9f2XSfoO+RdsGv8XshMfQ4hhBBCOsfmqJWZbI7ZPJsUPi9jP8QTSZy15kq4kVCssWzxepJzJ4cE3BqFgdCjpaq9ES6bwSbx7HRVDxm/ml+qqk0i+YkcNwNIwvpp+aKm7AvlDRR5/i7aRvAsbuou3NBWqbJerc/cRbZPDdvz8mnf/qiEso1q9KTyHJiai6S0s8zjtyvHGsyzK5eoUoJlMW8SePXn8Eon9kVwmnzVNyQkokVfVMbmMQBxQpA0KEa8YL8pjbDglCA2jqfuAxVmOUuiNoT8O5vOFm3HyOvT7veEOALUYFdEP6vVdqgXC2VzUJSKcPiwb8D39pb/UfUEoVDhepXccQ8ePFS1fOOGDRvQ29urOu5t27apz6olMiytIjFtnyXLsxUSflcjG3GZrURuDtsNsWxPvWbClv6pZKZEGJxn+HA1PDsHx5CE5BnJEji9g9QdIO7AsLZCcxOVv69Z0FCce0k6Mjd30O8gd/6gTIUHz1fhPfGoMqEnB/2O0fMQ8yzoMRdujwldFwEqDVcS26keUwfiwX2qQu+MqXC83MuFrWu7fhysMqaOQVWdkD5YKvGpihTh8XgybQVdO1Q4Bk9zAMOCMfE0tGy5WRQLtpkDvInyApKcRzMGc3ITkG1OqdVoKiy77MyST6ZCyiynTO6rTPDZWIWZqOQs8mWVevel4lrNIu+undvwhBpAdfTU+L0QSapKCCGEkO6wOWplJptjNs8mhXZW2GapvVLOFpmN7ZEJRC2xJSoR2hjySFwReb49uFWl56i8oRgGh1aWREhUsA+k6JCem75cc+B5vqCiiWeP2CDTGwMYDvTMc3Ar2Bo1PbNXalst25vUpp0PFeoXuTTi0SYeR+HkuvL+q3RuPBdGbhfMw0+Ura7n5sZg94ixInZKmWsggmLchJl5Ea6337eBog/8kiS9N+l7RMn1NsLIkgiaAU2fgJcyocOvgCjobrENp3t5uPs2wjZnPqfVbAsLeUzue6lIYC01/Q3DxMjRJ8AQ77UZ7Iqo/VCr7VAvFsrmoCgVwbKsgktpOUy56SPrlSOVSmJoaFGF7fsd0po1azAwMFBQDteuXVu17OvoRPVZi9F08fKDJX/XwljGrcs6lZjIuZjIzjywuDkPVpnBq9xn9UJmQ3KHD8GrUtFCM1JIDJ/jh+iV4FrjyI3ugqb1KrW9aNuehXxm75RrqcpBFV1Bqmrkg1xPmowNMIeOVx5bPQ4w6SVhZ/bBTA1A0+KwcwdUeKFKGp7NB15TLrSEn9wcuUlA8lip8qcmjJTMwHmwcxNALu3HS8t0TpCLypPPfP9YIGbATPZCE4EsaLuIZYmhMwturdPO3eKzZ5xJcptYVc+MdJzRf5eSisR9R4kmJSx8lvBHkYFUeSG50uflGCqpmLG45O9KyCyk3APnnrcGhmlicd/sZi2k7DQhhBBCusPmqJWZbI7ZPJsUtlnBLim1V8rZGbOxPZzDTsGWqERoT1SzK9Rz/YFXAb0PWhkPJy+osJ1YdEbF5+OZ7AO1Hc+C6x2GJpES1Z6ljRRig6thHR6tui3Pm6z6zD7btoXbE6Lnw3PzcMa3+6lOCgKVC8OeihhRdtOqS8vaTXKsskdr8Wv8tCIlOJN7kNn2S3iSqqSMaCX7k/C+RN8JsCfGoRm90CTXVnQdYwRufgLOoW3QexZPj2QR28f14GbHYKQGoBt+7txYpDmubcFw0ugZOQtmcuZzWs22iLsTGD+wC1osBiPmtyWsSK6O2bbh2BaWrjobqd6BGe2KqP1Qq+1QLxbK5qAoFSEe929op0JWfzuQ3sP1ynH11VepV6WLcvPNn1UCVChCiYdU9O9yGJHs/WWXG27Vv2tBr+E7taxTCRV+VkOJVrVOmfV6pqLlFoBBpE65ckZxRa9QeUHKhTq6Ds3UoJdkKZRu0xGvpMD9SpLuKZffIL5Z7VOJUv73pOSqPIfohg5dYq49TbmwGrBVB+xIR+y56r7xEv2AhEV6DuKLV6pSptbBrYgPHQc90admKcKBJmasRG6/VOTwkFi8UnXe4lacP7TNdyV15dq6MJxskKsqOO5ED3qSCejxWMVz1y74Sepnt6zc53Jtou+lGBU+r2Vdo2yWy/LIPSAPffIyZ/E9oVp/QwghhJDOszlqYSabYzbPJoVtVrAfSj8vZ2fMxvYIn9mq2hvBsmp2ReG5Pp6AXsZDxrU1eJaDVNyEkaz0fFzdPlDbkVJIbhw9qy6CXiX0TewGFXkh29LCHLKlK+Xh6fqMbZpd2/ztqfUj50Mdv6whQo/YI2KLOHnEEoE45FjwnJzy8CnbFsmRZeowZZK8TM4wVx+CO7wSXr40327kcGNJ9PQtQrrSMUg7DcBdtBy9qy6BLjZT6X5y45h86T7o6rjKPEerxOi+3TaX3GZRG0J5o2kazHgCZsy/p/ycWD55LQvXyUOXqBUJK5zBroh+NhvboR4slM1ByyTC4KCvTE5OikfJdNLpdNF6ZGHobbAbokJyRc0RW+KEpa/x8tC84rZLHihdk7xSPm7QSYXKv4hErurwxHPJU9UmpGKEbmgwHA2mpsM2DCVKyYyEuPeKN6vmGb6uZch3k4gnk0rbsnUdsXgcZqJ4tHXjceSlA/PcQPTy3Wpjw8eoMD4ZTEScGjrpMhiRjls64tmUQSWEEEIIIdWhzdG6Nkb4XC/Pyup5uQRXJowNP4ypmhd+rdvp6+2Fmax+nR1rElYyparBVUq+rSdTqjq4MYtjLGe7qG15eXjBMQrR45B222LLGL5YI/aDp7mIJ6ZEK9eyK54fya8kKTVkWdlJ4Xgfes64ekZnAVluzXR+Yyb6+gfKnl87q8GKmdXPQcUWkHpDUSrCihWSIBrYt29/2eX79h0I1ju6oe3qFMqFQs1lnVYjn4jB6u2BbUloXvFA4Xp5WJoLw4zDdSXZJPwyp8FhiheU8oSSAniqHKymBkzd1FTEnxmLIT58NJaffplaf8fTd8GM98AIVHaFpqntW+kcLB3oiWmIl4SjOYYOOxaDnc8g7mWhh+GEodht6DDjgzhq6WLEkhShCCGEEEIWCtoc9Se0IeZrS1gxHemYhlhcg1Emf6ija8h7Gkb6dcSrhE7Vazs+/Rjpv2pGoabWZ/hqtovCAMxUD5YOxtQ+o8eh2q37QR4S/CFRIJK6qTe6vMpxiQfW4VENg4N6Ue6x0uOdCSs9Nq/zO5tzEEvOzxvJKq89kwgUpSKsXn0KYjETW7ZsVd4j0RKt4+MT2L17D444YqQjS7MuNP3z/DG3NMl+9J3/K2UrM+TS43jpybugG3GM7d+mQvn8Mqf+vaUEqkIpCAnyk6R6FnRPHGMlX5SNRDyGoSFf4d+XSCCWTBZcP6N44gWraYiZGuKlSfHMBPQjj0M+O4FV51yBhJR4LUFmO+IUpAghhBBCFhTaHK1ra+RcTUUtyPO0WSbJtC1eNbamxK9ElX2G2xGPG0nJUYrn5dXymbZTYA55jeZiu5TaBbn04aLzIcdv6Br04KUCLHWxPSSUTJvx/Ej1aikaJDlaK6XCaMh1msU5mC/SVlIdilIlCQMvvvgC3HXXfdi4cRPOPvuMwrIHHnhEDRrr1l3R1DaS1qRahyVeTKXxwUUoTcpT95eUxs3n0ipZIOy8ihGPJXsK7rGCE1RUKcWV9atgmDG4ZlwJUome9skFRQghhBDSSdDm6Hzk2T2WSCGfy6h8QeWQ5XPJV1QPOmUiupJdVOnzTjwHnQBFqRKuvfbX8eyzz+NLX/oqbrzxBqxceawaLL773e/jjDNOw+WXX9zsJpI2xLElZ5OUfnVUJVPNDRR7z4NhxBBP9atqEr2LlipPJhGiDr78JIaOOweGmVCdppWdrDq4SZlRXTfgODbsfG5OnTMhhBBCCFl4aHN0rtghyLP7qnOvaognTiMIj9vJ5+BKGKFKBC4FxiuHFHaz6DfTvRPNx+/M4FjQDbTOVWoRenp68PGPfxS33fZ9fO5zN2NsbBzDw4vxq7+6Dtdcs65i6VZCqnWYEsanvKGkQoVSpSIVGaQ6n1TUM6Raie/JJBUsjFgSCVWm1KxpcLOyGWzb9IASp/LZybbonAkhhBBCuhHaHK1JPcWOdhGcZnM+HNtStobYNPIu6LoJWybgJRFJgybB20n0K3tPldw+8URKncdupXuPfIZB4p3vfId6EVKvDjM9dgDbNj+kZhiK0f0HD01Domeg6iBXrWOVkLwTz39TW3TOhBBCCCHdDm2O1qOdxI5mnA9JM/LKL++HbWWnVtI0lUYkTCXSqEnwdrkG5e6pvpI8V7puIpFqj+NZCChKka5GQuIWetAJvy+iUe+iI2raXzjzMNd9EUIIIYQQQmYPn6crnw81Cf66axbMfmqEbdYMStucSnVwEbA5QFGKdC3S6b30xJ3KlbISovSLsl2u85tLp1mvTrRTO2xCCCGEEEJI6zIfwcmxc3DyWeQyYyoXbhTbsrD9mYfmbJu1E7nMJNwqtpzeZZ5TFKVI1yKijnR6uhGDEYtPWy4x0bK8nPgzX0FrPjRz34QQQgghhBAyJ/slmwby4ziwd3dRjl1B13XYeQtmPDVr26ztzsUv74RVxZaLJ1I49fx1QKof3QBFKdL1SKdnxhJll1VKcDgfQWu+NHPfhBBCCCGEEDIX+0UzYtC8GPRkDzRNL7Jf7NwkvDnaZu12LkSQkgJXhhmbtlyq8cnyap5UnQZFKULmQTM7zU7vsAkhhBBCCCGdgxGLAa6pbJioKCWIKNVNiCAViyfLLpMqh90ERSlSMwMdlpAt4+qImUDcBGKxYvdRQRep3vSrI5Qmo5vPd2vBdXSMxTR1znWjsfsmhBBCCCGk2XSa7dHNhPaLvMQBKBHToEXC98R+cQz52+t4G0fOBSmGolQHMtSjN+Q77c5E3MTWhI5UUkc8Mf34LV1HxtOxYshEX79Zt+/WguMAEykdxw6bMIzG7psQQgghhJCFpNT26EZbpJsI7ZdkUkfG1jCY1KHpepH9olsaPGgY6HAbZ1a2XE93/C664ygJIYQQQgghhBBCSEvRvhIjIXUin7dm9TkhhBBCCCGEkPpD26z7oChFuhbDMJBMppDNZmDb5RODy3JZrxU7TXbYhBBCCCGEkHYhn8/DcWxYVrYo0bnYL5JjKhFPKLtsrrZZO0FbbgqKUqRrSfX0Yc0lb4QjCZwqIJ2erLcQgtZcaea+CSGEEEIIIWQu9ksmk1bClLxHE50LvX0DOOd1F1WsSFfNNmsnaMtNh6IU6Wrm2qnNR9CaL83cNyGEEEIIIYTMxX6xLAsvbP45Tlx93jTRpVvsF9py06EoRcgcaWZH0U2dFCGEEEIIIaS9EfslnrARjyfR1z8wrcJ4N0FbrhhW3yOEEEIIIYQQQgghDad75UlC5kkmPUG3S0IIIYQQQpoAn8UJ6QwoShEyx0Fww30/UgnqKiEJ6iRemIMhIYQQQggh9YPP4oR0DhSlCJkDMisjg6BpxhCLxcuW8pTl1WZvCCGEEEIIIbOHz+KEdA4UpQiZBzIIxhPly5ZWKvFJCCGEEEIImT98Fiek/WGic0IIIYQQQgghhBDScOgp1QEs7qW22GhMR0fC1JCMa0jEtWnLdU+Dm9ewqEfHwByuj2PrSMU1LO7RYZi8voQQQgghpP1YKDtloZ/FycJAG4eUg6IUIYSQriWdzuC2276Pxx9/AmNjYxgeXowLLliDa65ZB9OsfYi0bRt33LEeDz/8KEZHRzEwMIDXve48vPWt1yCZLB9WQAghhBBCSLdDUYqQNiI9OQG7SsJG0zDQ08sKI4TUKkjddNM/YHJyEjfeeANWrjwWGzduwhe+8GW88MIWfOhDN0LX9ZoEqU9+8l/x0ksv4/d//704/fRTsWXLVnzuczfjmWeew1/+5UeQTCYW+FjShWSu2WwW6bQLx7aDvzOFKkTl0KVkdqqn8PfBgwcwOT4G1/HKrm/GTAwNL/H3OzmBvXt2wc7lYdlZpCfSsKwc8vk80pkJjB06iN2v7kQikYDjOvAcB67nwfMAXdfQ09sDO+8inZ5QuT9c24OVz6nzrhsy862p/2SfhhGDoRtqWz19PbCyeVkMeFD70gwDhqytGdBl9jwRHJMHGHEDA32L4MCB57o4fPCgv2VDU9fPczwlQmpqvzr6+wfQ2zuAbG5S9bk9Sb9flWPLpCfhOLZsFnJ7mLEY4qYvPMr3ZV/9fYP+jgEkElPnPZfLqs/lM9lP6TWx8hbisbi6Zq7jRr4nf3vqO9HtyufZTFqdNzmmbS9vRSxuFvYp68uYEL2+IRn5XpXxpPS+KLf+4UMHYef9+yxvW4iZcVhWtnDvmDED/QOLCm2R4y3d7mzbM9t210KlbYbXQRImS94a+Y2lJyawb+8eVWo+ekxCre0q3V/p9S69N+ZyTNWOUe7DuKerez9EjqenZ377IIR0JrQ/yEJDUYqQeZC3rFl9Pt8B4Z6frkcmU7n0bSqVwmVXXs2BgZAauPXW72HHjp348Ic/gJNPPlF99trXnou9e/fjG9+4FXfffT+uvPLSGbfzk5/cg82bn8V73nMdzj33LPXZqaeejHe/+7fwL//yBXz3u/+F665724IKUg888IASowQxNHO2B8MwlXiyf+8e9fmSkSNglPH+SiSSeO2aC5XRK4LU+ju+jYmxMXiB+FGKrulYcewqJRTt3P4KJsbHqrZvpuWdiJxnJXppGhIiWugaXNf1RSkP6jMRwZYsPUJdJ0Gu1cEDBzCwaFC9u65vALiuh1w2E1wPDaLoyXbjiQSsXNYX1YLPtrz4rLo+4T513cCy5cdgzYWXTROYHt/wYCCSlSd6X5RbX8Snndtegeu5SmQUwSM8zvDOkXPQ09vrCzi6oY63p6evsN3ZtueMc87D00/+vOZ210KlfYuou3/fHiWWWrkc4smk0kBlvW2vbFHnOzymeNwXnatV+QrbJUT3F+4nvN5CuN3w3pjtMc10jHKvSdhT1BtUPDovuugiClOk7Wjks3g3QvuDNAKKUoTMAZkRkA5YOmjxCCiHLJf16oXMUMj+YrEYYvEypW8tSy2vNpNBCPHJZLK4996HsGjRIM466/SiZRddtBa33PId/OhHd80oSokY8OMf36WMbgn7i/Ka15yNvr5e3H33fXjb296CeDy2gGWxs8rAlP5BRAot7ylhxM5bqo1CPJmYVjbbzueVoRp6UNhWvvAgLwaxVpKmQwQS8TQSz46YHVMCRDegabqvB9V4vKEgpcSjeFx5usg5FnFDtiOCnpxa8foyg2uSTaeRFy8x6Oq8S5nz8Ht5K+cLPeJlptqjIRaPBddK9iNChu5fM7nWMkZomhI8ctmp6xsif8t1l3tGPL1KKb0vyq3viRgFTwkosk/LsaEbpvKE09Unai11T8o6sr54ukW3O9v2yP05m3bXQqV9i3eUnGf5bctxxkxTHZ/8vqTSl9wL0WOSC5OUcb+GdkX3F+5H7gO5hrKObDe8N+ZyTDMdo9wXydiUKCXPMdKHVBPVCGk1mvEs3o3Q/iCNgKIUIXNAZgJkRqAZrqwyIMisaTkqDcqEkGI2b35O/V5OOGGlMgij9Pf34cgjj8CuXbvV66ijjqy4nW3bdmB09CCOPXYFUqni36UYs6tWHYdf/nIznnvuv3HmmauxkMgDoxiyYtg6moSjxZQ0IN4rIlyostmBR0eUaAhPiGxDhbOVnBsxWm1vSpgJl8t7KH51DHJswTEZEjanabAriFJyvuT4w3Pge9HogXgUV/eCnLswHFSujYgack1iwTURAVHtK2YqEUfEg6LvyTlWQojvFSWhcrqeCa6BpkIH5Zqp7QaGw0wimgo9LHNPVLovoutLe0V8kzb6x+yLYmqf6tyJiOkqYUXWEXFFxDjbdubdntm2uxbKbTO8huo4zZj6jeWyhhL95NgKx+TYs25XdF31e4tcb9lu0b0xx2OqdIy2riMekz5hSkCr1z4I6YZn8W6E9gdZSChKETJHOMgR0r5s375DvS9Z4udGKmVkZFgJUtu376wqSsnycP1yLFkyXFivkii1fv2dWL/+p2WXSQ6j0GCsZDTK52IgR195Kx+8W3ACYaJcKIN8JuJCOj2pPHgymUl/G56/nVJRSokirqfCf2RZ6CnVcYKUEDkm8RAr9RqLIt5B0fXlfMg5FDEj9D6Rd/lMrR/827KsQqibZeXVtRJvIMm/pTl60fc0qSSlQuW8wnb9v4Nr4Aahc547tU/Xge1MXd8Q+Vuue76CB0HpfVFufWmv7F8PwvVkv/6940GT0yH/lbRFfcex59weuT9n0+5aqLRv/7fjFK5lKA7KMapzL+/BMTl2Xh1vtTCiQrsCQS/cX7if6PX2t+vfG3M5ppmOUTylEsaUp2PYb1TrZ1S7KVyRFoPP4oR0BhSl2oDhPpbL7DZsW0ePlEvtk5lvPVL6FkjF/PK3peiuBsf0S+8O8p7puvuDzI7Dh/08R7295fOnhHlVwvUqb+dwsJ3essvD7VfbjoQSHjx4qOwyCe0RNmzYUHEfuVwOe/fu9UNzxFNGjOjA2BQD1woSnR/cv7vg1RKivDJsG1uefVJ5f0jSdzFeRTSxA4+cKKHxmp4Y87067O6YHfWFnyqKQIkoJ/mBREQSsumJgieZiAHy72xmcto1ERHCtnIYO3xAXTNbzxV9z9/N1H5kG9HPlQAk4ojnqX0Kcm3HDx0sXN8Q2dfYoQPqfim9J8rdF+XWV6KJCBne1D0gglPoKRW2NZeZLIg5h0f3qs/n2p5XXtw8q3bXQqV9h78ddW4lH5gIYpZ4fFnITI4XfmdyTLKu/G1l0jO2S4juL9xP9HrLdsN7Yy7HVMsxjgVeYEIoRj322GPK27IS0j+QzmY+NgefTTqTetsfvE9IOShKEUII6TrESBPKGZCCaU4Z3tW3k59hO+aM25Gwv6GhRVU9pdasWYOBgYGy64yPjytjUXJnlBqUIliF+16xYkXZ5ZILYu3atejv78fu3buxdetW9bmfC6j4gVEMV3HTX7x4sR+SZdsznqNOQFUDDISVcoTGfSjE+Im9faNfrpvcB1EvFDnXsm70msh1lHN5xBFHYN++fQWRMfSEE3xPKF8slG3I3/KdMPeRiBayPLxX5DqOjIwUrm+I7EuWlbtnyt0X5daXz0SUDe99yUkUhoNFxRX5fnivLFu2TIksc23Peeedp4STWttdC5X2LZ+FHlHhccj5lWMeHBwsiEVyTGGRATnvM7Ur/DvcX7if6PWWV3hvzOWYaj3G0vadf/75VfcxNtZ9RQsIIYQsPBSlCCGEdB2hx0GlxL5h3puZPBPC5OWVt2PPuJ2rr75KvSoZgTff/NmCwVoO+TwUTUpFpFAYCf9dbnmYPyr0oggTdIevKNHPo9vuxJxS0WMqdy5K1xVK1y/3iq4fvSbh+SzkMaryvUrLyq0Xvb613DPRdoXfK7d+tJ0ztSl6z8g5mmt7QrGv1nbXQqV9V7oO5Y4pek5malf07/BVbbtzOaZaj3G2522u+yeEEEKqwdGFkDajkldCN3grEFIvBgd9T5LJyXTZ5el0umi9ytsZrBrWEm5/pu3Ug3KJRqVfCL1syvURlZKThvllSikVnsK/O02QKj2m0FumEqXLQi8hERfkvKs8QYHXTXjew2Wl10Lew3Cw8Huh6BkmU5fvynqh51TY1vCahd5TM1VHrHT9a/k83H/0HIRtjYp00hYRM1SOs3y+rCgy2/bMtt21UPrd8LoV8rTl/dBIOcfiWRRe49JzUmu7ws/C/YTXO9xfeG/UM4HwQpw3Qkh3QPuDLCQUpQhpE2SGWPLciLFcaQCQ5ZXCiAghU6xYsVy979u3v+zyffsOBOsdPcN2/OV795bfzv79tW1nPshvPplMqhCiUiFJ/g5FgDBMqBT5bthviEeXvFR55wpJjWVdVWY78L7oBmYSd6oJWtJfh6F/UfFIVXKLXBNZHobfRYWCUKQIxajo8lCQCgWS8HqH+wzvjdJxodo9ExL9Xrn1w32E7Ze2heJK1GMsbKdsQ9pYbpyqtT1yfmbT7lqotO/w32GCc/k7FN3kuoUhk3JM8v3wO7W0K7q/cP2oMCTrRe+N2R5TrcdYqX2EEBJC+4M0AopShLQJfX19eNOb3lQxTEiQAUHWI4RUZ/XqUxCLmdiyZWvB2A8ZH5/A7t17cMQRI1Ur7wnHHLNc5YPauXOXSlgu+aFC5Lf60ksvI5lM4JRTTlqwY5GHwYsuuqhi3yACkyBCUrUHTmF4eBjXXnutChusJMSImBJWLZyYmMCuXbsKuavkb/m3GNjiPXbw4EG1ruSxiXr8CHLOJXm7fCbfCz1v5PuhoBJeGxHAZL+hICbtlfVCZF9h6GFUjIm2WfL9hN4o0i5B1g1Fk1Bkk+/KuvKSh3BZPzw/sk+VDD4w7GV92XYYnhn+Hc3/FW1HmHsoFABKr4mcw1AUjJ4r+Z6cm6gIGIoM0kZZ9sILL+D0009X+w/3GY4JYftrvWdK74tK68t5jHp4yb7DtgpyThct8vOlhccb3e5c2jObdtdCtW2G1yE8Nvn3k08+iXPOOUftJ3pMQq3tKt1f6fUuvTdme0yzOcZ67YMQ0pnQ/iCNgKJUhA9+8KOFWe1SxDj59Kc/0fA2ERKFHT4h9UHEo4svvgB33XUfNm7chLPPPqOw7IEHHlEixbp1VxQ+S6cz+Pznb0Z/fx9uuOE9BXFARBBZ75ZbvoOHHtqAK6+8tPCdX/ziKUxMTKp8UWHuqYWimjE52+TIIkzJq9b9Ll26tOwyEW4eeughXHDBBcxFM0tme83kXB84cACrVq2q+VzPVoAot/5cE2/Ppz0LIZxU2mbp8cl5ls+OPPLIed3Tpfur53msdZ+kudDmIO0E7Q+y0PApsYSlS0fKuh8uWbK4Ke0hhBCyMFx77a/j2Wefx5e+9FXceOMNWLnyWCVQffe738cZZ5yGyy+/uLDu008/g6eeelr9+6qrLsOqVccVlq1bd7la9q1vfQ/Dw4tx+umnKg+sr3zlFuVJ9da3XtOU4yOEENK60OYghBAfilIlfOxjf4yRET8sgRBCSOcingMf//hHcdtt38fnPnczxsbGlaj0q7+6Dtdcs67IWDjppOOVAdHX14vly5cVbUc8Jv70Tz+IO+5Yj6997VsYHT2oEpuvWXM+3vrWNxeFbxFCCCECbQ5CCPGhKEUIIaSrhal3vvMd6lUNyRv1mc9UDqeQfDNve9tb1IsQQgghhBBSG91RNocQQgghhBBCCCGEtBT0lCrh7rsfwMaNT2PPnn2QYkxHH70MF120FpdddlFNpa/Xr78T69f/tOwyy/IrBYUlgOUVlnAmJArvDbKQ9wfvK0IIIaR7bI5GwGdXUgu8T7oLu8brTFGqhBdf3ILrr3+XSk4rZcF//OO78J//+XWV/PaP/uj3ZxwkpCT4wYOHyi7L5y31vmHDBlUGW36Q27ZtU5/VMviQ7oH3BlnI+0NK2hNCCCGkO2yORsBnV1ILvE+6i8kabQ6KUhFuuOHdOPnkEwtlfhcvHsJ1170du3fvVaW977zznqIS4ZXKjEvukXLkcln1vnr1agwMDCjlUC7U6aefznLZpAjeG2Qh74+xsTH17nneArSO1JPwGoXXrB3vU2k7+7GFhee6MXT7eebY0b42RyPgsyupBd4n3cVYjeOG5nXQyPLBD34U+/cfqHn9N7zhdfj9379+xvWk1Pc//uO/4rjjjsHf/d1fzrl9O3bswIoVK+b8fUIIqSfbt2/H8uXLm90MUgWOG4SQVoNjB20OQgip57jRUfLkhReuwcRE7WEpxx9/XE3rSRlwYdeu3ZgPy5YtUxekv78fmqbhQx/6Cxw6dBiLFg3iU5/623ltm3QWvDfIQt4fMhcxPj6u+iTS2pSOG+0E+7HGwXPdGLr9PHPsaF+boxF0+++D1Abvk+7Cq3Hc6ChRauFKcdfHmUziZqMKYTyeQCwWV++Ncq0l7QHvDbLQ98fg4GDd20XqT+m40U6wH2scPNeNgeeZY0e72hyNgL8PUgu8T7qPwRrGDWYXC/jhD3+CL3zhy2WXSVUM4aijjmxwqwghhBBCCCGdAm0OQggphqJUQDabwy9/uVlVsijlrrvuK8SDE0IIIYQQQshcoM1BCCHFUJSKcPjwGD7zmX/DSy+9DMuyMDp6EP/v/31bJR0888zVuOqqy5rdREIIIYQQQkgbQ5uDEEI6NKfUfLjmmnVYtuwo/Oxnj+HTn/48xsbGEYvFsHz5Mrz73dfhiisuVvHZhBBCCCGEEDIXaHMQQkgxFKUC4vE41qx5rXoRQgghhBBCSL2hzUEIIcVQlGoiV199pYonT6WSzW4KaTF4b5Bq8P4g7QDv08bBc90YeJ4JqQx/H6QWeJ+Qcmie59Wn9ighhBBCCCGEEEIIITXCgGVCCCGEEEIIIYQQ0nAoShFCCCGEEEIIIYSQhkNRihBCCCGEEEIIIYQ0HIpShBBCCCGEEEIIIaThsPpeg8nlcnjooZ/hsceewCuvbEM6nUFvbw9OOul4XH31r+Dkk0+o+N2NGzfh+9//EV5++RXouqG+87a3vQUrVx7b0GMgC4fcD7fd9n08/vgTGBsbw/DwYlxwwRpcc806mCZ/rp2M1Jx48slf4uGHH8ULL2zBoUOHkUjEsWLFclx66YW48MI1Zb+3a9dufPvbt+OZZ55HPm9h+fKj8cY3XslS06RpsB+rP+Pj4/jP//w6Hn30F7jhhvfg4ovfUHFd9gmzh/0vIfXngx/8KPbvP1B22RFHjODTn/5Ew9tEmgefDUg1eAc0mH/6p89j8+ZnsW7d5Xjve38HAwMD2Lr1ZXz5y1/H3/zNJ/G+97277MPmffc9hJtv/gquuuoy/NEf/b4St7761W/i4x//e/zpn/5PnHbayU05HlLfzvqmm/4Bk5OTuPHGG5TYKELkF77wZfWQ/KEP3Qhdp3Njp3L77T/Ed75zB04//VT88R//AY466gjs3z+Kb37zNnUPPPvs88oYjfLKK9vx13/9SaxceQxuuunPMDDQjx//+C587nNfxN69e/GWt7ypacdDuhP2Y/Xnscd+oQQp23ZmXJd9wtxg/0vIwrB06QgMw5j2+ZIli5vSHtIc+GxAZoJXv8Hk83mcffYZeOc736E66mQygVNPPRl/9Ee/B03T8NWv3qJ+uFEOHBjF//2/38Dxx6/Eu971DvT19Sp1+fd+773Ky0p+0LJd0t7ceuv3sGPHTlx//btw8sknIh6P47WvPRe/8RtvVh333Xff3+wmkgVEfsODgwNKdD7uuGOQSCRw9NFH4YMffL/qK+6//2ElaIe4rqt++zLDf+ON/wNHHrkUPT0p/MZvXINzzjkTt956B7Zv39nUYyLdB/ux+nLXXffhK1+5RQkir3nNWVXXZZ8wd9j/ErIwfOxjf4xPfepvpr0++tE/anbTSAPhswGZCYpSDWbZsiPLuoEvW3YUjjhiKbLZHF588aWiZfJDlQemiy5aq4SrEBG0Xv/61yrRSmZSSfuSyWRx770PYdGiQZx11ulFy8Lr/qMf3dW09pGFZ/HiIdU3JJPJos/FpVlm74VNm6aMomeeeQ7btu1QBpAYU1HE21KMpR//+O4GtZ4Q9mMLwYoVR+OTn7xJ/c5ngn3C3GH/SwghCwOfDUgtMHyvwUh4XiVSqUTwL6/o86eeelq9n3ji8dO+c+KJq/CTn9yNJ598Gm94w+vr3FrSKDZvfk4JjyecsLJIeBT6+/tw5JFHqNwV8jrqqCOb1k6ycFxxxSUVl6VSvqHkRboG+c2HfUApYV/x1FO/rH9DCakA+7H6IzPKtcI+Ye6w/yWEkIWBzwakFihKtQjiCr5nzz7lzrhq1cqiz3fu3KX+PTIyPO17S5b4n9FNvL3Zvn2Hel+yZEnZ5XLtpbOW68wOu/vYtWuPej/llCkDNfzNl7tnZDYqFoupZL3j4xNq0CdkoWE/1lzYJywM7H8JmTt33/0ANm58Wtk4okccffQy5R1z2WUXMYdQl8BnA1ILFKVaBImnnZxMY926K1TOqBBJCGfbtlKWe3p6pn1PckoJUsWAtC+HD48VXc9Swmsfrke6h4mJSTz99GaV5yTq9nz48OEZ7pkUDh/Oq3uGRhFpBOzHmgv7hPrD/peQ+fHii1tUHqFjjlmuRFopBiCFG8TukRxuFKY6Hz4bkFqgKNUCiOh0yy3fUdVefvM3f61omWX5CczLVa4QwhKauZzVgJaShcKyrBmus1G0HukepG8ANLz//b9b5PYc9g3hvVGpb+A9QxoF+7Hmwj6h/rD/JWTu3HDDu1UIcvh7kNxt1133duzevRe/+MVTuPPOe9RkPOls+GxAaoGi1Bz44Ac/iv37D9S8/hve8Dr8/u9fX3G5VNaT2YO/+qs/VRVfosTjMfXuOE5FQUtIJOI1t4e0HhK2Wf06O0Xrke7g4Yd/hgceeAQf+MD/UAmPy/UNlcrEh30D7xnSKNiPNRf2CfWF/S/pduZr76xe7RcJKEVC90SUevDBDRSlugA+G5BaoCg1B6RCi7h018rxxx9Xcdltt31fVc77sz/7Y5XorZTe3l41wyAPOOl0eloIn4T8CQMDxdVfSHsRVu8Jr2cpcu2j65HO5+mnn8HNN38V733vO1XZ3FIGBwexY8erVe6ZTLAe7xnSGNiPNRf2CfWD/S8h9bV3oixdOqLeJY8Q6Xz4bEBqgaLUHHjb295Sl+3cfvsPVeU8EaRWrjy27DoSa3300UfhlVe2Y+/e/SqvQZRwBqN0Fo+0FytWLFfv+/btL7t83z5e525i06Zn8JnP/Bve857rcMklF5RdR+6FzZufLXvPSIJdqXQiCXeZz4Q0CvZjzYV9Qn1g/0tIfe2d6RRXGSedDZ8NSC0wu1yTuOOOH2L9+junCVKS+O+///vFonXPPvsM9f7iiy9N284LL7xUtA5pT1avPgWxmIktW7bCi9adBlRo5+7de3DEESOsStEFbNr0LD796X/Du951bZFBtGPHTmzY8HiN/cKWonUIaQTsx5oL+4T5w/6XkPrwwx/+BF/4wpfLLpNKfALHgu6AzwakFihKNYE77liPH/xguiAlbNjwmHIbj3L55Rer8sKS2yD6Y85mc3j00Z+rxIHnn/+ahrWf1J9UKomLL75AzbCKMBklvO6Mu+98ZOb905/+PN75TjGILixatmXLy7j77vuKBnmZVXryyV9Oq1hy//0Pq6S8v/Irlzes7YSwH2su7BPmB/tfQuqH2Ci//OVmZDLZacvuuuu+Qg4q0vnw2YDUAsP3Gsx//deP8O1vf0+VRv3BD34ybfmWLS9hZGRJ0WfDw4vxrne9A//xH1/DV7/6Tbz1rW9WFQq+8pVblML8kY98sJB0k7Qv117763j22efxpS99FTfeeIMSLKXz/u53v48zzjhNiZOkc9m8+Tl86lOfU6XEZbZeXlHE7Tn6O5fQXqkI9Td/80l89rP/B+9737vR39+vQoLFUBK3e+lnCGkk7MeaB/uEucP+l5D6I4KthMK+4x2/geXLl6n8VOvX/xRPPfU0zjxzNa666rJmN5E0CD4bkJnQvFI/OtL0Sha/8RvXKOGpFOnEv//99Xj55e0wDB0nnni8evBZtaq2xIKk9ZFkf37y+ycwNjauBElJNHnNNesKJXVJZyJu7lKJphqnnnoS/uIvPlz02auv7sK3v327GuylTPny5UfhjW+8EmvXcgaSNAf2Y/VDxJD/+T//rOyyJUuG8S//8vfTPmefMHvY/xJSX2Ty/Be/2Iif/ewx5WkoY4FEfYg49YY3vB5XXHGxEndJ98BnA1INilKEEEIIIYQQQgghpOFQoiaEEEIIIYQQQgghDYeiFCGEEEIIIYQQQghpOBSlCCGEEEIIIYQQQkjDoShFCCGEEEIIIYQQQhoORSlCCCGEEEIIIYQQ0nAoShFCCCGEEEIIIYSQhkNRihBCCCGEEEIIIYQ0HIpShBBCCCGEEEIIIaThUJQihBBCCCGEEEIIIQ2HohQhhBBCCCGEEEIIaTgUpQhpAT7wgQ9A0zT1+sd//MeavnPTTTcVvrNs2TJs27ZtwdtJCCGkNeC4QQghZDZw3CCtiuZ5ntfsRhDS7Wzfvh3HH3888vk8jjzySGzduhXJZLLi+l/96lfx7ne/W/27r68PDzzwAM4555wGtpgQQkgz4bhBCCFkNnDcIK0KPaUIaQFWrFiBd73rXerfu3fvxpe//OWK695zzz24/vrr1b9N08Stt97KAYIQQroMjhuEEEJmA8cN0qrQU4qQFuHFF1/EKaecAsdxcOyxx6q/ZRCIsnnzZrzhDW/A4cOH1d9f/OIX8b73va9JLSaEENJMOG4QQgiZDRw3SCtCTylCWoQTTjgBv/mbv6n+/corr+D//b//V7R8165duPrqqwsDxMc+9jEOEIQQ0sVw3CCEEDIbOG6QVoSeUoS0EJs2bcKZZ54J+VmefPLJeOaZZ6DrOiYnJ3HRRRfhiSeeUOv99m//Nr72ta+ppIOEEEK6F44bhBBCZgPHDdJq0FOKkBbi9NNPx5vf/Gb17+effx7f+c53lHvttddeWxggLrnkEhUDzgGCEEIIxw1CCCGzgeMGaTXoKUVIi/H444/j/PPPV/8+66yzsGbNGnzhC19Qf5922ml4+OGHsWjRoia3khBCSKvAcYMQQshs4LhBWgmKUoS0IFdddRV++tOfFn0mpVt/9rOfqaSEhBBCSBSOG4QQQmYDxw3SKjB8j5AW5M///M+L/u7t7cUPfvADDhCEEELKwnGDEELIbOC4QVoFilKEtCCSbFBeITfddBNe85rXNLVNhBBCWheOG4QQQmYDxw3SKlCUIqTFeO655/CWt7wFrusWPrvjjjtq/r4kKPzkJz+Jt7/97TjuuONUgkJ5vfzyywvUYkIIIe06buTzedx55534wAc+oKoxyUx5MplUZcP/4A/+QJUMJ4QQ0lnM19744he/qBKjn3rqqVi8eDFisRiOOOII/Oqv/qrytiJkNjCnFCEtxO7du1WiwVBA6uvrw8TEhPr3Aw88gAsvvHDGbfzar/1a2UFl69atSqQihBDSOcx33Ljrrrtw5ZVXqn+vWLGiMEv+2GOP4dVXX8XAwAB+/OMfq30QQghpf+phb5xyyinYsmULzjjjDBx99NHo6enBSy+9hJ///Odq+Z/8yZ/gU5/61AIfCekU6ClFSIswOTmpZhfCAeKd73wnvvKVrxSW/93f/V1N25FB5i/+4i9w++23Y8eOHWrWghBCSOdRj3FDQjfe9ra34ZFHHsG2bdvwve99T73E2HjPe96DsbEx/NZv/ZbyqCKEENLe1Mve+M///E8cPHhQRWj813/9F771rW+pin4PPvig8rj9p3/6Jzz66KMLdhyks6CnFCEtgOM4ePOb34z169ervy+77DI1M22appqB2Lx5s/pcOvvzzjtvVtuWKhp79uyhpxQhhHQQCzluhGQyGRx11FE4fPgw7rvvPlx88cV1PQZCCCGdNW4I733ve/HlL39ZCVwf+9jH6tZ+0rnQU4qQFuD3fu/3CgPE6aefju9+97sqNltyQUU781pnLwghhHQ2jRg3UqkUTjrpJPVvCeUjhBDSvjTK3pBtColEYp4tJt0CRSlCmox0/DfffLP697Jly9RgMTg4WFguSQRPPPFE9W/JFRXOYhBCCOlOGjVuyKx6GOIhXreEEELak0aNG0899ZQK5TMMA+vWratT60mnQ1GKkCbyta99TeV/Evr7+9UAIYlmo0in/tGPflT9W6JtP/GJTzSlrYQQQrpr3JB97du3DyMjI1i7dm0dWk8IIaSTxg3JLSX5B6+77jo1Tpx77rlIp9P493//d6xevXoBjoZ0IswpRUiTuOeee9QMgiSPlVjuH/7wh7jqqqvKrivryOyFlOaWQeP555/H8ccfX9N+mFOKEEI6g0aNG4J4SEklvtHRUVX6+33ve18dj4QQQkgnjBvXX389/uM//qPwt1Th++d//mf87u/+rtoGIbVATylCmsDTTz+N3/iN3yhUM5IH/koDRBib/ZGPfKQQTvH3f//3DWsrIYSQ7ho3pOLeW97yFiVIvf3tb6cgRQghbUgjxo0vfelLyrNqYmICTz75JN7xjnfghhtuUBX+pFgGIbVATylCGszOnTvx+te/Hjt27FB//9Vf/RU+/vGPz/i9XC6HlStXYteuXYjH46pc9/Lly2f8Hj2lCCGkvWnkuJHNZtWs+v3334/LL79czaozWS0hhLQXjbY3ynlP/e3f/i3+/M//fM7HQLoHekoR0kBk9vnqq68uDBASg13LACGIUfChD31I/duyLHzyk59c0LYSQgjprnFDZtPf+ta3KkFKjBlJdktBihBC2otm2xvvete71LuMIYTUAj2lCOlw6ClFCCFkJlzXxW/91m/h29/+Ns466yzce++9GBoaanazCCGEtBnPPvssTjvtNGV3iP1ByEzQU4oQQgghpIuR+UnJGyWC1Mknn4w777yTghQhhJA5cd9996n3E044odlNIW0CRSlCCCGEkC7mT/7kT/DlL39Z5RG5++67sXTp0mY3iRBCSIvyi1/8At/73vdg2/a0ZT/4wQ8KeaQktxQhtcDwPUI6DElK+zd/8zeFv5944gmVJ+Tss88u5AZ505vehL/8y79sYisJIYS0ApLz49d+7dfUvy+99FIcc8wxZdeTdcL1CCGEdC+33347fv3Xfx2LFi3Ca17zGhxxxBE4dOgQnn/+eZUYPZzs+NSnPtXsppI2wWx2Awgh9WXfvn149NFHp33+1FNPFf59yimnNLhVhBBCWpGDBw8W/i15pCohuUEoShFCCDn//PNVNT8piiFC1EMPPQRd17Fs2TK8853vxA033IALLrig2c0kbQQ9pQghhBBCCCGEEEJIw2FOKUIIIYQQQgghhBDScChKEUIIIYQQQgghhJCGQ1GKEEIIIYQQQgghhDQcilKEEEIIIYQQQgghpOFQlCKEEEIIIYQQQgghDYeiFCGEEEIIIYQQQghpOBSlCCGEEEIIIYQQQkjDoShFCCGEEEIIIYQQQhoORSlCCCGEEEIIIYQQ0nAoShFCCCGEEEIIIYSQhkNRihBCCCGEEEIIIYQ0HIpShBBCCCGEEEIIIaThUJQihBBCCCGEEEIIIQ2HohQhhBBCCCGEEEIIaTgUpQghhBBCCCGEEEJIwzEbv8vuxXVdvPrqq+jv74emac1uDiGkS/E8D+Pj41i2bBl0nXMTrQzHDUJIq8Cxo33g2EEIaadxg6JUA5HBYcWKFc1uBiGEKLZv347ly5c3uxmkChw3CCGtBseO1odjByGkncYNilINRGYrwosyMDAA27axYcMGrFmzBqbJS0Gm4L1BFvL+GBsbUw+rYZ9E2mfcaCfYjzUOnuvG0O3nmWNH+9CMsaPbfx+kNnifdBdjNY4bvBMaSOg+K4NDKEr19vaqf/NHSaLw3iCNuD/o0t9+40Y7wX6scfBcNwaeZx+OHa1PM8YO/j5ILfA+6U60GcYNBoQTQgghhBBCCCGEkIZDUYoQQgghhBBCCCGENByKUoQQQgghhBBCCCGk4VCUIoQQQgghhBBCCCENh6IUIYQQQgghhBBCCGk4THk/A088sRH/9E+fU//++tdvbnZzCCGEtAEcOwghpHMZHx/Hf/7n1/Hoo7/ADTe8Bxdf/IY5VSG74471ePjhRzE6Oqqqkb3udefhrW+9BslkckHaTQghrQhFqSqk0xk14JDOZGJiAo7jVFxuGAb6+voa2iZCSPvDsaPxsD8nhDSKxx77herjbbtyn1OLIPXJT/4rXnrpZfz+778Xp59+KrZs2YrPfe5mPPPMc/jLv/wIkslEXdtNCCGtCkWpKnzrW9/F4sVDGB092OymkAUwYH74wx8inU5XXKenpwdvetObaMgQQmYFx47Gwv6cENIo7rrrPnzvez9Q3lGPPvpzPPjghjlt5yc/uQebNz+L97znOpx77lnqs1NPPRnvfvdv4V/+5Qv47nf/C9dd97Y6t54QQloT5pSqwPPPv4j7738I11//rmY3hSwAMqMuBkw8HldGSulLPpfl1WbeCSGkFI4djYf9OSGkUaxYcTQ++cmbcM45Z855G57n4cc/vkt5cF5wwZqiZa95zdno6+vF3XffB8vK16HFhDSfsbEx7N69W7034/uk9aGnVAWX2i996at405t+RQ0+pHMRY6VS3L5lWQ1vDyGkfeHY0VzYnxNCFpqTTz5x3tvYtm2H8qQ99tgVSKWK+ywRqlatOg6//OVmPPfcf+PMM1fPe3+EzBURgWRSR7yNJefZXNiyZQs2b96MbDarxuhTTjllXt9fuXIlRkZG5tUm0npQlCrD7bf/UM1i/NqvvWnW312//k6sX//TssssK1cwXMKX67rqnTQWOedyjeX8y6sU+UyWh9epGe3jvUEW6v7gfdVaY8dsxo12olH9WKv3542AY0Zj6Pbz3K3HXW+2b9+p3kdGhssuX7JkuLBeNVGq1caObv99dBovvfQSnnnmmYIYdNppp2HVqlWzFrWefvppdV/09/ercPunnnoKqVRKFQswzepShKz/5JNPqjF8aGgIu3btwr333ovFixcrT+i5tIk0llr7A4pSJezYsRM/+MGP8dGP/hFisdisv5/JZHHw4KGyy/J5f6Z2w4YN6O3tVT/Qbdu2qc90vXIkZdryZt0OUp1cLovRg4cxPpmBYUz/GTiOjbxl4YFHHkMi0fgKKJ7r4tWd25CxPGhV7g3SnZTeHz1xbVbfn5ycXLC2dSvzGTtmM27USiuMG43qx1q9P28EHDMaQyed59mOGwLHjvpw+PBh9V6pT+/t7QnWG2v42DEfarVrSOuTy+Xw8ssvKzFIhCOpDimC0AsvvKC8kmfTZ2zfvh2JRAKf/89bkZ4Yg6G58KBhwkmp92qYmo0ePQfX07Fy2SJcccUVSuSQNohgtWfPHmzdulVtn7QmtY4bFKVKOtMvfelruPDCtTjllJPmtA1xwx0aWlR11mLNmjXK3TBUDteuXVtVKR6dmD7zS+bH2Phh7N61S7l+xssYKVYuq9xVzzj7PAz0Dza8fY7M/AM497w1MGaYRSDdR+n9sbhvdg9/jMlvrbFjNuNGrbTCuNGofqzV+/NGwDGjMXTSeZ7tuCFw7KgPYa4oCdUrR2gTzBR2vBBjx3yo1a4hrY+IPQcPHsTg4CD+7b5xeDAwZIzhX/97KQ44i2veTq8+ifNTEyLp49iLrkevnlX/znkxPDp5ptpuNeJ6Gmf3bFbSle0Z2DW2CxaSWL16mRrz9+/fj9NPPx1HHHFEHY6aLAS1jhvsMSL89Kf3Yv/+A/jIRz4w521cffVV6lXpotx882dVRx121jKTEP27HIbZfOOi05DZdE3T1Exnudkc+VyWy3rNevCUdsm+2/3Blyz8/WGaszMu+LDYWmPHbMeNWmiVcaMR/Vg79OeNgGNGY+iU8zzbccP/Tnsfc6sQj/vetJWKL4TizkweKQsxdsyXWuwa0vpIqJ2IPjKh4yKGHiOHjJfCmDeEnFa7513O68Uz1sk4Ob4FfUYOlpfAC9ZxOCq2Hxl9MZwZRKk0FmOz5anv9xhpODAx6fYqzyjxwJE2Slt5v7UutV4bXsGAAwdG8e1vfw/vf//vqhucdAcS0jGbzwkhJArHjtaB/TkhpB0Q75NqYS2Tk+lgPSZxJguXgLwass3Vq1dj48aNGDIOI+sl8bx1PCa8vllva5u9AqPOEJJ6Dlk3ocQtEaXm8v1h/QCOi21X4YQSliptLHf8C31+SP2hKBWwadOzyGZz+Od//veK6/z2b79PvZ966kn4i7/4cANbR+qNaRgqyV4mk0E+X77kriyX9QghpBIcO5oP+3NCSDsRVmfdu7e8YS6et9H1CKlWjU6EmeOPP77u+5FtihfSnz24AxPewJwEqRD57oTjf9+AM+fv73eGsccexj+u7VOJz8sJTo06P6S+UJQKuPjiN6hXNYPi61+/ucGtIgtFT28fLrvyatgVXKcFMWBkPUIIqQTHjubD/pwQ0k4cc8xylQtq585dKlm55IYKkZC+l156GclkYs75bUnnIh5AIrhILkvxuJNk3+LNJOKRvOqNFG457PQgDwMmMnXZpohSupeH6WWgzRC+V46cZygxStomk1FRpKKfnA9J0D48PKzOj5yvkZEReky1OBSlSNdCA4UQQjoD9ueEkFYjnc7g85+/Gf39fbjhhvcUct5Jjrt1667ALbd8Bw89tAFXXnlp4Tu/+MVTmJiYVLmiwtxThIRISJp4AIkg9cUHJuBqOga1w/jbx3bioFd7AvKa8Tz0JeW+Le+FPBd0OEiaLhYl83Axl/yXOs7934cBbXoC7SFtFGfGxjDu9uH9l7hKqJNk6HLeKEq1NhSlCCGEEEIIIaSOPP30M3jqqafVv6+66jKsWnVcYdm6dZerZd/61vcwPLwYp59+KrZs2YqvfOUW5Un11rde08SWk1ZFciRJSJp4AIkgldJyyCGFSQzA1qZXn503GmAjVddNiijlaAnk9EG4c/CUqoacBzkfKT2nvMlEjJLzxZyfrQ9FqQrcf//D+OIX/2/ZUIw///MP4bTTTm5SywghhLQqHDsIIaRz2bdvP/7n//yzos+kz5fXkiXD+Jd/+fvC5yeddDyWLh1BX18vli9fNq0i1Z/+6Qdxxx3r8bWvfQujowdVYvM1a87HW9/6ZmVIE1ItAbl4SIkA85JzPNKgt7Ag50HOxwnG8zMmQyetBUWpOeQJIYQQQsrBsYMQQjqXkZElNecJlLxRn/nMJyoul5w4b3vbW9SLkNkmIJeQPfEMoiBVzKvuCky4PfjE2t6KydBJ60FRihBCCCGEEEIIaQNElJIcUgsSstcBpL1eLF26VFXeJe2Bn3GPEEIIIYQQQgghhJAGQk8pQgghhBBCCCGkhRgbG1PJuiVRN8PQZsf4+DgOHz7Mc9cmUJQihBBCCCGEEEJahC1btmDz5s3IZrMq8b0k7JZ8UmRmbNvBgw8+CMdxeO7aBIpShBBCCCGEEEJIi3hIiSDlui4GBwcxMTGhKu5JLil5iVBluFl4mod2Q4cDzbNhuBloMOq+fc/14OYnYNs2lixZos6dnMuRkRF6TLUwFKUIIYQQQgghhJAWQEL2RHgSQer/PjIJFwYGcBifeepVHMYw4HnoT4igY6MdRamU7mJIs+Gi/qLaAEZxUupp3L55EL97oatEvP3796tzSlGqdaEoRQghhBBCCCGEtACSB0nCzsTLRwSppJaFhSQy2iAc+BX3HLRnZTkRpRwkYOmD6tjqzSQMWOhDwsspTzMRo+RcyjklrQur7xFCCCGEEEIIIS2AePRIHiRN05SHFKBhG05EBn3NblrLI+dIzpWcs9HRUXUO5VzSS6q1oacUIYQQQgghhBDSIkhibgk9k5A98ZCiIFU7e7ECaa8HN61NYWhoiIJUG0BRihBCCCGEEEIIaSFElJIcUmHIHqmdDHqxdOkSpFLtGebYbTB8jxBCCCGEEEIIIYQ0HIpShBBCCCGEEEIIIaThUJQihBBCCCGEEEKawNjYGHbv3q3eSX1wXQd79uzhOW0TmFOKEEIIIYQQQghpMFu2bMHmzZuRzWaRTCZVpThJck7mjmVZcLIZPPLIk+jr6+M5bQMoSpG2Jz05AdtxKi43DQM9vaxYQQghrQD7bEIIIcT3kBJBynVdDA4OYmJiAhs3blQJzuUlQpXuZuB5LjoFHQ40PQ/dTQMw6r5913FhZzIwPQuLFy9GLpdT53hkZIRV+FoYilKk7Y2be366HplMpuI6UnXhsiuvppFDCCFNhn02IYQQ4pNOp5XwJILUNx6dhAsTfTiE//PsLoxrFuB56EuKcGOjU9A8BwnPxYBpw9O8um+/zxvFcfFfIuP1QdeHlLi3f/9+da4pSrUuFKVIWyOz7WLcxGIxxOLxacvzlqWWV5uVJ4QQ0hjYZxNCCCE+PT09KmRPPKREkEpoWeSRQk4fhKsl1TouUugkdM+B6yThGHKM9feUynoGbPQj7tnwPA/j4+PqHMu5Jq0LE52TjkCMm0QiOe1VzughhBDSXNhnE0II6XbEc0fyHWmapjykAA279BOQ1egpPFfk3Mk5lHM5Ojqqzq2cY3pJtTb0lCItBXONEEIIaSYchwghhDQKScAtIWYSsiceUhSk5s8B4xik0Yu/WJvE0NAQBak2gKJUBzA62RnJ7zLpCWy470fIZivnGkkmU1hzyRuR6vE77Im0i5ztQbc8uGXiki3LU8sPpV3YRvucJ8dxkbE8jKZdGG3UbjI/FvfSeZV0zphRrh9r9T57LuNQK8Axo7POM8cCQroLEaUkh1QYskfmT07rxdKlwypPJWl9KEqRlsFxHGUImGYMsViZXCN5Sy2X9QghhJB6w3GIEEIIIaSxUJQiLYcYAvFE+ZkC2843vD2EEEK6C45DhBBCCCGNgaIU6Qhk9no2nxNCCGke7LMJIYR0G2NjY0in06oSHPMcNQae8/aAolQHcjDdnvkk0hkXluQasT24+vRcI3nbU8sPZ1zkg1wOWUsHjCTSkv8jW96YiSdSGLd05NvovEjeimzeU9eyW/KDZDOTcB274nLdMJFM9aKTGOph3hDSuWNKuX5sofrsevUfcxmHWoFuHDOaeZ4JIWS2bNmyBZs3b0Y2m0UymVQV4STJOVk4tm7dihdffJHnvA2gKEXaGjEyzrngjV0nZnQaYlA++dCPYOUqJxcWQ1WuNa8lIe3LQvTZ7D8IIYS0ureOCFKu62JwcBATExPYuHGjSnAuLxFNNDsD6F0wqeA5gJcHvDSgGQu2GzefxqZNm2AYBoaHh9U5l2swMjJCj6kWhKIUaXtoZLQ/YqCKQSnJhc0yyYXtvKWWVzNkCSHd2Wez/yCEENLKSPiYCE8iSH3n52l4MJHyDuFrL+5G2hCBxkN/UgSazh+nNM9B0nYxaNrwylThrRc95gQeeD6NnDaA33ydq8S//fv3q2tBUar1oChFWg4xIGbzOekcxKCMxZlcmBDS3P6D4xAhhJB6IfmMJHxMvHVEkIppWdhaCnlzEJ7uj1seUugGRJTyvATc+CC8BfSUslwDjtuDmJuF6/YqMUqugVwL0npQlCItg4RsSIiFzGhXMiBkuaxHCCGE1BuOQ4QQQuqNeOZIPiMJ2RMPKRGk9sdOhKX3NbtpHYucWznHI9ZzGB0dRW9vr7oG9JJqTfhURRSStLX5pHD8a34Frlsl14huIocUci3R3oXDlWSqtoexjAu9C5LWZrIuLMcDbA9OpeTCjoexbGslFy7HYIrJy0lnMdfxoVH9WH37j/Ych7ptzGgWfdOjQwkhpCYkwbaEkEnInnhIUZBaeA7HjkEWvVi7NoGhoSEKUi0MRSnSUiSYH4oQQkgT4ThECCFkIRBRSnJIhSF7ZOGx9F4sXboYqVR3hEe2KxSlCGlDclL+fIaZfBpWhJC5kElPwHGcqb8ni/sa9i+EEEIIIaReUJQipA0FqWcf+/GM5c9PPX9d2xmOToUcLpU+J4TUX5DacN+PkM1O9S8TObct+hf2H4QQQggh7QdFKULaDPGQEkHKMOMwzFhZA0yVP6/iSdVqiOdFmFzYsa3KyYV1dlmELCTiISWClGnGEIv5CXQszW3p/oX9ByGEEEJI+8InNELaFBGkKpU/r2SYtSricSGeFwxJJKQ1EEEqnvD7l5jrtnT/wv6DEEJIsxgbG0M6nUZPTw8TabcwvE6tDUUpQhoE80BVpxuOPSv3gDN1D8Sc4kp9ScTQ08tqLKQz+jbXcWBbWeQyaaT6FvYBsBv6D9L8e9ywPOStLCbGx2AYRmG5/DvVw76bkG5jy5Yt2Lx5M7LZLJLJJFavXq2q7JHWYuvWrXjxxRd5nVoYilKENIBOzgNFaheknnzoR0X3QNzUitZZ1N+Dy668msIU6Yi+zfM8uLlxHD58CKe97o3s20jb3+MxHchnxnDowG5o2lT/nUymsOaSN1KYIqTLPG9EkHJdF4ODg5iYmMDGjRtVhT15lUNEEdgZeCUeyF2F5wBOHl4+DU+bEvcXCjc/iU2bNqnJg+HhYXWd5LqNjIzQY6qFoChFSAPoxDxQZHaIh5RcY8nVYwa5ehIRUSqft5DJZGBHqp4R0s59m+e5sPJp9m2kY+7xZMKEZ2eRSvVA0/RC3y152KIVKwkhnY+EgonIJILU95/KAFoMCecQvrdjL7Jmhf7A8zDQI0JM946Jmucg6blYlLThad6C7y9pprHhxQwsfQC/9hpXCYb79+9X14+iVOtAUYqQBtJJeaDI3BBBKrwH4rFiTyk3370PKaTz+jYRpfK6joV/5CSkUfd4ApZhIh5PQtOnwq9tVngkpOuQ3EQSCiaeNyJImV4Wjp5C3hyAZ5R/1vdJoavxbHhWEl58EJ628FJE3jDgWj2IeVm4bo8So+S6yfUjrUNxQhNCSNsg3lWS26L0xfLnhJD5It4fVi6rXuxfCCGEkGLEy0ZyE0kor3hIARoOJU+EbZQP3SPNQa6HXBcPGkZHR9X1kutGL6nWgp5SpGbGMl0c/zxPclkXygnGBtwyrqq2DbV8QtbTXbiOi1zeU+dcN4rPu2XpgJFS4QJAee+qWCKFSUtX22oGVnYSXpVwHU1KuCfbO7/MQIqaPuk8JOeC5MeR/iX0/rByQf9Vpn+p1rdJTinHBVxvqm9rFTqtj6o2ZrQr7GMJIa2OJMuWcDAJ2RMPKQpSrclk8lhYei/Wro1jaGiIglQLQlGKkDZDDKVV515Vk0HVDMNL9vnSE3ciXyWpuxi1cgztZPQR0g1IomZJ2BzNj7P9oK1EpXr0G60gBrGPIoTMh3Q6g9tu+z4ef/wJlex6eHgxLrhgDa65Zh1Ms3bTasuWrfjBD36CrVtfwaFDhzE4OIBjj12Bt7zlahx//MoFPQZSP0SUkhxS1UP2SLOxjT4sXboIqVSXh0+2KBSlCGlDajGUmmV4icEp+9SNGIwgoXcUJ2+p5dUMU0JI8yitIJay7Lp4ObWKGMQ+ihAyH0Hqppv+AZOTk7jxxhuwcuWx2LhxE77whS/jhRe24EMfuhF6JN9YJR599Of47Ge/iBUrjsYf/uH7cMwxy7F37z585Su34K/+6n/j937vd/GGN7y+IcdECCHNhqIUIQ2c5RdjZzaft7PhJfs0Y4myy1yne/PS2JFrrbvF1fcWvjAuIQtDuT5MEp174nFlzq5PyqXHG+JNxT6KzD6PowdHKqla2aLqe6R7uPXW72HHjp348Ic/gJNPPlF99trXnou9e/fjG9+4FXfffT+uvPLSGrZzhwpxft/73o1Vq45Tny1fLgLVDfiDP/gQvvGN72Dt2tep/DeEENLpUJSKIIPDk0/+Eg8//Kia7RBX2kQijhUrluPSSy/EhReuaXYTSROZzyy/GFGyTL5bydiR5bJevaHh1RroUrEpkVKlxcNcPa5Z/LDZ198D06A01W5089hRtW/zPFGiYAZ9Wyg0VeuTbCuNbU/fB9et7JnF0DrSSHR9qu/OupaaWMhk0kVigeRhk3xspLPJZLK4996HsGjRIM466/SiZRddtBa33PId/OhHd9UkSu3ff0C9H330UUWfSwhff3+fGkfGxsbV34QQ0ulQlIpw++0/xHe+cwdOP/1U/PEf/wGOOuoI7N8/im9+8zbllvvss8/jhhve0+xmtiXjkXwk7YqVzqsyomqW3ywzy29byKfTGE/nEUfp8aaw9LQr4LlTeVpK0XQDOaRU4mDPdWHZHiZyLrQ5hs1YWQ95xwNsr2xydcf2l09kPVh1TEDcrP02iv7k3JLvJlO9OOeCN8J1pjxABksS+S7pj6Gntzh0irQ+3Tx2RHPcyW86ivR3EzueQv8xr1F9m5Udm7lvUK8MzETvHPrZ7u2j6jFmNLN/bGUSqV6cev46uK6NvpiHbc//Aqef/doiEUr+XRr2SjqPzZufQz6fxwknrJzmwSRC0pFHHoFdu3ar11FHHVl1W8cdd4yaxNix49Wi/FGHD49hfHxC3VO9vSxZTwjpDihKRZCBRmYk/uiPfh/JZLIwg/HBD74fH/7w/8L99z+MN7zhdVi9+tRmN7UtKTVY2o18zoPteDCMGKCVMZYgbv0WJnNiyJQ71h5ghuf1XHCOPNfzDYysB63stmpvr2d7MCoYXo7jVWkv2mq/C0Ffsr5u8yJMFW2/p/iG6OntPIOuG+j2sSP0WBIBJ9rPe7DhaPFAkPJq6htsKdXnSWHtufaz3dVHhdRjzGh2/9jqwpSQiruIxZPo6x+AYfARutvYvn2Hel+yZEnZ5SMjw0qQ2r5954yi1Hvecx3+6Z8+hy996au4/vp3qdxSYU4p8b69/PKLZpU0nRBC2hn2dhEWLx5SYRahUREig4LMgN9zzz5s2vRsxxoWhBBCZg/HDkII6XzEi0mo5MHU09NTtN5MnlJ//dcfw1e/+k38r//1icLnUsnvbW97i6rANxPr19+J9et/WnaZZeXUu23b6tUIZD8Set2o/bUKcrya5wBedx33XPHPleu/N3i/jfw9EJ9azzdFqQhXXHFJxWWpVLKQIoMsHDIz3arYlsziA5LqJFItvYB8Lq+05cGc50y1zHrbDuDm5j7r3cj2ltuvY1nQykSReLYlY1Hd9zsfehPdM+NP6g/HjvL9eGk/VkufJMv9Pxau32rHPmomwnPNQteELByW5Se1r5Q/zDSNovWqIWHdUn1vaGgRPv7xjypPqd279+LOO+9BLpdTHriJRPnce9EcVwcPHiq7LEzAv2HDBvT2Nib/nghS27ZtU/+upQJhOxNeo1gspo51JJ2Fp9GsrgUNLnryr0KbFMfoxt0nmmfjZz9LqmtWeg1n+q2RuSOVSmuBv54a2bVrj3o/5RS/0kY9Zi1qnVFwCk/pFZY7btW/a8Gt4Tu1rFMt34U8NM+8XusaACoflErc6yfvnb6Cv0zWm29FO7UNqVxVJQdVre318jm4ZSxiMbzq1d5SdDMJN5+B55R/MNNjvunUKiXXPVeDnUtPO985WyvK+RVL9sB1/AE0fC/FqfB5Les6dm3fdYK+Q94Fu8bvhXCWqLXGjoWY7a42bsx2jJA8aLX0/2E/H/bjpf1YTX2SxO6pPxa2n223Pmomps613dB+s5RK/WItWKoPnmq/kdenJRxPpJqbY0d+B3KfSwW+haTWsWA+zHbc8L/THr+HhSIe90OKnXKKuTo/TtF6lZD8pP/6r/8H2WwOf/d3NyphKvSe+p3fuRZ//McfwzPPPK/Eqmrijkx6hN+tNHasWbMGAwONSZYe3h9r167t6NDDl156Cc888wyy2azykD7++OOxr2cInkFho1aPpSUesL/3NfC0xhWI0JwcXv/6QaRSqWnXcOXKlVi1alXD2tJNjI3N7DkqdG6PUUcmJibx9NOb1WBRWm1jPrMWtc4oyGxt1X2WLM/mZy/sZO2Zv5Obw3ZDJNeFvGYiGM9bEtfOIeFNQLNz0NzpPx15mPa8PNx9G2Gb8xyYxLgY3wl1OoKy07PehGMhqWXhOROSiKUsqiLW/l/CNqo/QM2WgUVD8LzyD0pqv5oG78BmtMrj7STymNy3BV6JoXEoYnNJgvv+I1Yhk/Sv7VisvHdVsqSiXjWSJdtIxWv7rhhFu3ZuwxPqGuroqfF7s521II0ZOxZitrvauFE6ZszEoYxbU/8f9vOFfrykH6ulT4L0DZ4D3XYXtJ9ttz5qRoJzndkhbW/MzLNTpq/LzKL/K9qWbeHgri1FhSBKH4skh9PI0Seo6o3NIm54OLh3O559SlvQ81zrWDAfZjtuCN0+doSV8CYn0xXFpuh6ldi4cZOqrHfGGadNE5V6elI4++wz8OCDG7Bhw+MqH2Elrr76KvWqZAjefPNnlTjUSIFI7JlG77ORyHl97rnn1L+HhoYwMTGBZ599FrnMmaAmVbsoJRMpTj7XcFFKhNPR0VFs2rRJ5W4bGRlR11Cu6ZFHHtkwAbebMGvsCzqzx6gzUuJVnA3f//7fnVZtYz6zFrXOKIxOVJ+hHk0XLz9Y8nctjGXcuqxTCakIVEuicwnzaFXs7Dhy+3epBLyaPv2h2HMteFoePSNnwUz2z3/WWx7CjzxPeejMFX3pOTNW/DPirO4SdydwcO9O6LEYtIhAF/4sHTuPvJNH39FnYfHQoPpsoKRyXkilz8sxVJLofHHJ35UQDym5P849bw0M08TiPn1BZi1IY8aOhZjtrjZulI4ZM/HKAbum/j/s58N+vFw/NlOf5FhpjG15oCH9bCcRnuvUcjnXZtMSnfcl5ibU5DJjOLDnVWixGIwgtCJuFvd5IlwtXXU2Ur3NMxr64i62esCpZ79+QROd1zoWzGsfsxw3hG4fO1asWK7e9+3bX3b5vn0HgvWOrrqdcL1Fi/zniVLCz195ZXtVUYo0HhEexbtmcHAQP96UkZ4KZn4UR/alkY8X55UkFfAcJPMuBhO2KFQN3LGBP7kti1h+FINjE8gb/bj6LBf9/f3Yv3+/urYUpZoHRakZePjhn+GBBx7BBz7wP2YcZOYya1HLjIJhVjcGDMOt+nct6DV8p5Z1KiElqmvJjdSoqkFzQTfj0OM9fshHvvz8uSyX9ephFMgsrBhy89mWmWTnWgsaDOWhoZkJGLGpqS4jnPXXdFUOXK6HHhgiulH+gd6o8Hkt6xpm7d+VvkMEKXmZs/ie0KkzmO06dizEbHe1cWO2Y4ToSbX0/2E/H+3HS/uxmfqkRveznYR/rs2GnRdNny5KVeoXZ0KXm0zTYMYTMIM+OB7xJM1rWbhOHrox1Qc3A/kdiHeqCFILKUrNZiyYK7MdN/zvdPdvbvXqUxCLmdiyZavysohONoyPT2D37j044oiRGSvv9fX5Xq+HDh0uuzz0nA1zVJHWQZLZS7iXeNeIIGV4WXhmD9zUCGByoqQmJCF8JgkkBoEm5OFytQG4RgqGm4Pr9igxSq5pWKiANIfuHl1m4Omnn8HNN38V733vO/Ha157b7OaQJmPEezF08hU1eB41JqEkIaQ14dgxd9jPEkJaFfFqvfjiC3DXXfepEDwJswuRSQgRqtatu6LwWTqdwec/fzP6+/twww3vKaTqOPPM1SpZ+n//94tKgIp6yko4t2w7FMFIayGeNKtXr8bGjRsRsw8qcSPdexIcClJtg1wruWY9E8+qUD5JjSDXlF5SzYWiVAU2bXoGn/nMv+E977kOl1xyQbObQ1oEGkKEkGpw7Jg/7GcJIa3Ktdf+uqqc96UvfRU33ngDVq48VolI3/3u91WOqMsvv7hoguKpp55W/77qqsuwatVx6t9Llgzj7W//NXzzm7fh05/+HN797uuwfPnR2LNnL77+9W8rrysJ21u9+tSmHSepjCQ2l5Cvn+zZBzc+QEGqDcn2HIu83ou1a2MqNxgFqeZDUaoMmzY9i09/+t/wrnddW2RU7NixE9u3v4o1a17b1PYRQghpPTh2EEJIZyMhPlIV77bbvo/Pfe5mlbB8eHgxfvVX1+Gaa9YpD6iQk046HkuXjqhwveXLlxVtR9aV0O4777wH//iPnw1CiBIqb9X73vduXHzxG5pwdKRWRJTKx12JSW92U8gcccw+LF3qV+MjzYeiVAmbN4tR8Xm8851iVFxYtGzLlpfx4IOP0LAghBBSBMcOQgjpHmHqne98h3pVQ8LyPvOZT1RcLuF/0RBAQgjpVihKRdi8+Tl86lOfU+VYZcZbXlGk2kY87leFIYR0HlKyPprJxvH8JKZS9YmQSnDsIKQ+OPmpvjZa90QqoBJCCCGkM6EoFUFmsi3LUq+f/ezxsuuceupJDW8XIWRh8RMnp+BYGbGKCp/nnanKOmY8VShrT0gUjh2EzA+pGBhLpJDPZVSVvXJPqPFECjorLhJCCCEdB0f3CO9//++qFyFkYXGsyZaqrmUmerH0tCuntak3oRW1KZZkAmYyHY4d3d1/kPkTT/Zi1blXwXPtwmd9Sb9SWYgIUokUryshhBDSaVCUIoQ03KA8+PxdcPOZiuvosZQqC99oYaqUeHJKlCKENJ9W7T9IfYSpKKlUsShFCCGEkM6EohQhpKGIh4MYlJoeg2bGpy+3LbW8micEIaQ7Yf9BCCGEENJZUJQiTcXOFYdh2FYksynDMDoaMSh1MzHtc1cMS4tJbQkhrd9/MJSQEELai7GxMaTTaVVFcWBgoNnNIS0C74vmQlGKNFWQ2vvMT/3k0uFnYlFEYBgGIYSQVoShhIQQ0l5s2bIFmzdvRjabRTKZxOrVq3H88cc3u1mkyfC+aD4UpUjTkNllEaR0IwbN8MMwXFcqngXeUo4FO5vBZNaGgWIPqo7H9aA5HizxHIvWxZ7PJmuY0dcbYDg5lgfbgTo+XZt+bK7jwXOAtOXBqNOxC71x5ocipBGTDWNjgaeS68DIZZEZGwOCypXz7Wea1X+UbUvWhpXNQDNMIBjDShq7YGMY+zNCCJm9J4wID67rYnBwEBMTE9i4cSP6+/vVazaIeGFbacBhqPis8Ry4Mj7m0oDWxKrWTg7ZbALj4+PqPvA8D8PDw+q+kPtkZGSEHlMNhKIUaToiSBkxPwxD+vbQ0FBOU85UJR4yP0Fq4sW74OWzFdfRYkn0nXBFQ4QpQkjnkc/63q+Tk6HnkIcUJpA5sFt6mM7tZ4zKoYQcwwghpDWQ0CwRk0SQuvfZDKDFoecP4aFD++AkZjdxIALGoh4RVNjHzxrPQTLjYlHCBspMLjUOA3/1wxxM6wCSo5NwjT5cPuAqgXL//v3qfqEo1TgoShHSBYiHlAhS1Wb0ZTmTAxNC5uv9WuhnPE/NRGpGD6Bp7GcIIYQ0DckVJKFZ4gmjBCk3C5gpePFBaGZyVttS0yyx1EI1tbNxbXW+9cQgoDdfivAwqO4D3c3BdXuUGCX3idwvpHGw3i4h3UQwo1/6KitULTSOBdfOTXvJ54SQTuhn4n64XpiUvJ79DPsPQgghs0C8XiRXkKZpykNKJkus/pPgxWYXukc6C7n+6j6AhtHRUXV/yH1CL6nG0nx5kpA2pVVyNLUbcl4khEeFElYIbZHlsh4hpINw8iqPhJsbn3Ofyf6DEELIXJHk1RKeJSF74iFFQYoIdt+xsM1erF1rYmhoiIJUE6AoRdoCSVrbSnj5SeReuhueXbnqkmamkFh1ObTYHIQp10PcQd0Snbt5D7ZKnu5H0ZQiiYE910Mm70Ff4OTAQA+MYy+fUdDLogeY53XvYTJgQppG3gFinv/uuRbs0W3wnCwOv3APNCM2xz6zcf1HK/Wr7MsIIaQ+iCglOaRmG7JHOhvP7MPSpQNIpRiW2QwoSpGm4zkWQvNCqu9J9SRFC4dhqBxNIkhJ5UB9ekiKGGCyXNajKTEdMTp5XgjpIjwPnpsXxQharKdQcXUufWar9R/S9nK5btXnhBBCCCGkKhSlSNOQ2WwjnlKJcSWsIxSlZHa5XcIwRJDSylRdEgPFC46JEEKIjyailFGm32zDPlOFEkqSXBHTKrRdlrfyGEYIIYQQ0mwoSpGmYSZ6sfS0K4vCMCRMLxqqV8gx0mLhe+2Gl0/7RpM3qTzTpiEeDIQQUg8kb5TKu5eDBwuuM+H3O54DD/pUH6Rp0zym2gnx2JJww5lCCecUwk0IIYQQ0iVQlCJNF6aK/tY9GGVyb0hOjlbCy3twlNUl+USmt03yiIhVJutpc8kl4nnQHQ8Z2wM0b975r5xXHgImdktsZPmVZCZ/cCU8R4fWYue6FlKxVgrmIaQ7Cb1fvcmMSkTuHH4VbkKDndkrnSJgp1X4nn1wq3qXUtDaolWAHpt/n9k0emauYzyPPpV9GyGEEEI6HYpShHQ6IkTJq3+5Mv6mIV4LrgN92dqumdF3Sion5l1tmnFdKpgSQqoTS/rer/vG8qrCnv3C3YCeBZJDfoj2+DZAcvBJknPVL0nMnqj7pF3JZ4v70ty0vtREPMm+lBBCCCGVoShFSLcgyYGN6fmvPCcH5NMq+fBcvLAqel8JLRi6IoLUwefvgpufqpw4VuLpIN4eYlwj2df4BhLSxoiYayR9oUlV2NNsaFocnqQm1wzfQyrEc1Xy83L9EmkPQWrHL38KW/JCBsSMYlEqlkhh1blXUZgihBBCSEUoShEyHxwLZQMzWrhyYL0QQcp95W54drbiOlJuVz92phLvjUVm9UWQ0vQYNNPPZ2PoJdUgLb8KGCFk7njiCWUfhpc95FewsMalV4iuABzaCm/RShWyTNoL6SNFkNKNGIygL42ZU9fXyVvI56QvLVOakBBCCCEkgKIUaVuyc83TId490RJ/pchs/kwiiqND15OACDJ2hQduMwnb0eeWT8QDEq4co7Rnnsaa7UFX+a+K7cECwTJb8lfVksslPH/5CejZ8cD7QZsyKuXfEiYowpw9jvzkISDuzXxOS0gucC4VEaT0oAKYESmOpe6MNqsCRkhLIn2CeEPBAHRdfnSRcD3pLzxf2M9N+mF9YZ+ZnqjcR+clL1XwddV5lSCeWGZPbf14C7DQ/VwjEEHKiPl9qRkRpQSXfSkhhBBCZoCiFOku8pPQd9zji0mVMJNwl19W3aCJ9frrzFfcaufz51rQJl71RShJYBwVpWL9vtUouap23AvEB2Y+p4SQzkQJUjEguXiqn1A5pbLwUkvhLr8UiPX5faasXqmPllC/9O4pYaucd5VuwOs5Coj3sc8hhBBSYGxsDOl0GrqMSYTUeL/09PRgYGCg2c3peChKkbZhWv4i8eyZrQgkIpIYO7opiYOmL1fePdnqYlNINxo70fOnXmGOGPGO0qe8F2RZiHhN1XpO55jHyo0k12UJdkJaFOVVGfnbEw+qmC9IxYMHPmusch8t/bMIUvIS8VvlrIq4OUofo5bpU31OPTxjWwC3pDiDXZJQnBBCSGW2bNmCzZs3I5vNwjAMjI2dicHFyWY3i7TB/ZJMJrF69Wocf/zxzW5WR0NRirRt/iIVkhbB1pOwll3mh25UQMt7iLsePFWFrowoJel43TysvAdvvmFz80DzPNiOh1wd2hEeM/IWPGf6tuR44Xo1HXPx+QMMCcuBDk1ZmuIN4TtIqXAdhQvHM6F5ds3ntFo4S6U8VrnIpJdmppBY1Vp5rAjpXsRj0oWLkjAuJS7JouK+p3ofLT1L+GOX/ibuC+MhqpqfDQcxaK4NK5NGbP/j0OxM5daZqRnHjWaH4Em/NyH9Xn6q38tGDlvQzSQGFg0taDsIIaRdPV5EYHBdF4ODgzh06BAO7N2FWCymXqTBeA7ituQcnCyeWGo2Tg7ZbBzj4+PYuHEjPM/D8PAwJiYm1P0zMjJCj6kFhKIUaQ9cxxciorPnUVHKsZThIYZIR6fLtdPqGCvhyfkpMa7kMzG8/PNTPr+HLFffbcf7QHlH+Uah51rwbD9JOf0ICGkMVla8eGxYWQ/5nAcn68JVuZ/Ee1LyRuX88L1SVJ+zcL9UzXN8QUqPFYT0ouUSDtgG44b0ZyJIacZUv6dHqtx5tqWKN3jeoia2khBCWhMJwRKPFxGkHn4hCw8pnNW7BY45ACSHm9287sN1YZgeTEmeGzy/twYxfOruPLTsARj7JuGZ/bhwwEV/fz/279+v7iOKUgtHG1ihhEQw4lPlw0v7MTs/s6CTn1B5SWx5iI+E//kORDID78FwPBxMu3Cs5lVfE2MqaXnYP+HAC45Td9JYtO9e6G7lfFiunsShkUvhGlFhKgF98GK1zUp4mgE3K+e1+jEbtosh24MT5HJJuR5czUNMeUeFbQfy4pmlvNk85CWaxvUwnvMQCxKpJ0qS4c7rPlAROMH2xFGixsS6ypAL/u24xdX3CCG1C1IvPXGnqrKWd3wPT1WgQXCD35Juwuk9BpZb8sihvDTzRf2tmZvEkGXBcQx4JYUXNNdC0nECj0y/7ylSk6RWg+shK8UdPA+HMy4Gpb8yTHjedM9Y6ZcMx1L7N9wySdNLkH5r3n3XfDCmijNERSm3yf2WY0/t2/aKq+8RQkizkZxAEoIlHi/iYau7OSDRD61vKRCXHKikobg2tFgSWmqwON1HyzAImCmV99J1U0qMkvtH7iOycLTinUBI/bHTiL96DzRrDEZ6JzSY8FQupEiRKM1ELrkMrYqISiJIuVrlWX9ZXk58Khap6t2uoHyfGIeS50VCIFUbWmn2A0U5p/RYyvcssHzrWQp+RTHiKbUeIaQ64iElgpRuxBAzY/BsD1oYiidhvM5oEFZXJnRYinZG/hbhffDAw4hnX1VC+TS3fs+F4aThGqmCWE+ah/SRZjwF28pMVdmziy9MLCF9KR81CSHNQ7xbJCeQhGRp1iElOHhDJ1OQIuWJ96v7QzvwDEZHR9Hb26vuH3pJLSx8UiBdgYRn+GEcIkbJKwY3IkqJK6nkPSo2kVoTEaQ8fcpLqIhGlt/WdHUuNZlx8jxood+R/FuM0GC5LGkl+9GI92Lo5CuKkgb3xLXpxlaCOakIqRUjFoemxWFovpeSoClt2lB5njQnA92b3j85etIXoArCe05NGLgivJeIUir8WG279fvpbiCW7MXyM68s6kv7kqV9qYl4kn0pIaS5SJJqCcN6In0AenKQghSpzsBxcMw+rF2jY2hoiIJUA6AoRboKEaNCQyeac9tV3j2ub/Qobx9SDTlPIo7lUkdDc7JIZHeo8EflLOW5yCWPgqfHlTBltKABKcJUlFiC15yQeqNJdbzEoEpPnj/iEoy508UJy9XLeHL6xROm9xyBIKWEKb+/9pTyFexPVd/zi1WwH2+cMBUlkWSpdUJIayKiFFKadFzNbgppB2J9WLq0D6lUqtkt6QooSpHuQryjdPHuUcmHCh/rkhhbZumlcpPRX5i5J2VyT+lJP69V6JWlwvd0P6lwsI54TSnPM8+3Df1wG55TQrqzz43Di/XBdfumLY7m9hPEs1L1IdKflIYiy9/SyQSCkx7mrIquEnzXNfrY5xBCCCGEtAEUpUh74VhTs+cl1fdqQhLu9q+E47pFya1dOwfDyeDQkovhxAYXNAdTOyPnZWzx66ZV8dOdbEHkEw8qJ764sCxm+EamN4+S61XvAxUxOFV9jxDSxugmLPG0LCMoSaJzw07j8ND5cBLD5Ys3iHAeiODh8kpVRyt93rI4U8UZ3EhSLSnaQAghhBDSrlCUIu2BbkAzk/DsrJ80VygpluRJ4sJaEqpKTiY1Iz8la0iVJ8+z4Zp9FKSqIImIB0YfnVUFQKOe1arK3Qfq+k2toplMUk5I2+LZiOf2lw3eE+FbhKa+iedwsPdXZuyrpb+a5tlZgixvdY8q6c+kUpGXl+Pw+z23pMlSvEFjyCIhhBBC2hCKUqQt0GK90I+9HIgkVLUzk0XKVN7W/bA8a0z9rQSqenrntAjNnPWfTwXAhboPhERMKzHgmFiXkEbi5C24mgfH9goheVKJLxomPZOApNsTqg8RjyjVv0SLUaiwPh2666lk6LX0MSJaiUBebV0VktziExHSn/WdUL04g+Ad2NzglhFCCCGEzB+KUqRtiAoNXn4S+t7HAfGYCYi7JblJzBSsZZcVCVMqMa78w5V/e00P4xBDrJzBpPKpuDm13DH7K+dzatKsfzMrAJYTnPSIKEUIaRxSXS2WSCGfyyDvWHAcD2GRPc+VSQMXEO9GmSQo8W4NMa39GDzwEIz8OGK53dCdTCBITYlSIkhJJZzoZ7XQ6oJTreglxRnMElHKc21M+Y4SQgghhLQPFKVIeyIzxiJIiaFjxNVHnlMsMml2RnlOqVA93VQilf9ZHroq3hQRsbzGCDpREUpKpA8eeFjN+k81Q/MTscNDKj6JRWOHcHDkMmVYlc76K8OtRNBSOVfyh9UrzK0yX6+AaJsLngxaNIeJXtZrqtmIcCm5w0Jsd8qIc6y0ejfi/rnIR5aF3lZmgt5WhMxEPNmLVedepUSRiayHyZyH/RP+7y49OQbt4Ga4yVNVX6znx6f1R7rjYXD/g0hOblGV85SnpcgrkZxJ/somNE+q7ZkqxM/M7Vf9UXRbXqS/W1APKDvte+VO7ax4uYwjDfLWdKxJ5UElL8mNmM+MF4Uvsy8jhBBCSKtDUYq0NyJIGaHHTiRHVKn3k9mjvKZCQyLneLBsXxgSwSUvgpZmIG/bgD22IIaNiDvDB+4r5GOS9iVyrxbCUvz9mcgklythykUGnpNVbXIKx5ZS1afUtkYfL8rtJNXuErndBQFJ2p5LHOkbcQEivB0YvqRwTJU8tQrbdC0MHnq0qM2x3KswxQBUiYRd9S5tFmFK1tecPJzcuPKYiJkSQtnbFEEq99LdsCPnJxvYaZ5jIzcm5x1IDCyDZpgYK3G+MOIpLD3tSiA5vVoYId1AJj0Bx/H7hsykjVzWneYhJYKUEL5bugtL92DYLuzJfbC2PwLDPQj9wG7EXQ2DkU2IAC85/A4Pngc9Pwbdzai+sDyydh6u60LTbMSyu7F41+1FeadK+7vSvq4ScWOWXpZ2GvFX71ETHCG6XrINMwl3+WULLkyJIHXw+bvg5mWCwkPCm8Dk6K5CdcJoX0ZhihBCCCGtCkUp0h2UzmwHnkp9+x+G5mT9Ska6ib6S3Lq1GjazycckRpMrAo68K3EnpkQpEXg0uL7XkYTHVfHaKt1WNDRRtqf+hgtHT8DTfU8yvSTfU6lIVg4POnTPUuehtM2yB8MZh+65ynNBRD3lReU5GN5/ty9SGQmkl15Q8GDQIB5rCx9OozwHxCsuFit40umB8SneBGLAqfbEktDNBIyIKOVJCJKVKcrfQki3CVIb7vsRsllfeJnIuciXxIZJyJ54SIWCVBTXmsTklvtgH3wJSJnQMmPKO9UMfnc+OvJJ8b6cRMzar0T1UJTyxSY1tVCYbBBZSnlD6XEV2ixLVG67QpU96e8kTDCm+jrDmYCZPwynguhe64SDZke8Wz3pRyehSd5C8b6VflAmFKSfiVaCFS/eBcqrF0V5R+Uz0FRfG4MmVWQlzC8QpdiXEUIIIaQdoChFOp8yM9uGyr+bRyyzUwkvYtzkUivgRKr3lYo49cIt5GPS/DCP4OXBVsLU3LaFwvaUyCVH5dnKgAuXy5aNoHJTJWErijp+CRGs1Ga1Db+GoRt4J8TV+bIRz0v1LN+4NPdaBe8FLZZC5kjJ89WgWXsjrkQndTxRj4jAM02WKVEqov85DciLRUgrIx5SIkiZZgyxWByW5iKasEiSmksOKQnZqywK5/zfmfz2TV06CXiFkGnX96qU3iOoqOcj/YsmG/BDmQufBsKUiPeq/5Hfr+b3WyqcT7aRD/q7ODzlhbobi0cfqBhaHE44wOitKkj177230A+KR5Th5WGkd/p9mrRFxozBlQXx2994Y7M7aWYcuohSrgk9Fi/0b+zLCCHdxtjYGNLpNHp6ejAwMNDs5pAuhffh7KEoRToe8ZBSgpQSVnwDRVINeRCxRNQIXRk9Knm3NmVYlIo4nUqxsBX5PMxbVQYxIkP/BfV36OGgjElJyO5vTww4yWslQpkYjbojHgSdf04J6QREkIonkoi5rqqsF8WtQezQlCglQpOp8pOHWyj1Wo18o/Ca8pGKLBVv0pomCTy/j9JNOCV59WYz4aCEeycTjA3iwaopz1ElSIVilzqW0pYSQghpNFu2bMHmzZuRzWaRTCaxevVqHH/88c1uFukyeB/ODYpSpGtQglSYf0om41V0iHgoibVU3kPJ9TzYjge7xCCb0/4dT21PBDEl+LieakMhUEX+7YWCmbS38v5Lt4WS7al1gm1NLfc9m8LtldtGFFlflqswmbDNngQFSsJh8epygpMoO/INVP+vwDvC96EqeC+oaXsKUoSQGSjf20o/48DTRPg2oUuHEvZ3YTfken5fJn2oB9ieiEflBffZTDgo71MZOyR3VDBuhN5alcYOQgghjfVMESFAcg8ODg5iYmICGzduRH9/v3oJIhLksxPQbHqQNhXXgZm3YGcmJIwBrYp4fGezs5NKxsfH1X3neR6Gh4fVfSj35cjICD2mZoCiFGlvJH9H4d/F1feqIrmPXCvI+yGWTRBOUhB/Zld2vFuQMMd06jh1vsRjoCe9VX2eTh6r3nuzr8AVAUrlyHIK51UQTymVcyo/AS0IpVNl4huQY4oQ0g74eaTE23IKEX2knzaQiy+BYw4qUbwntzNYtnCikOQdRLTaqOQe9IJxQ1Xcm2WSdEIIIQuChEqJ6CSC1GNbJXw8AWQP4fn7R6H3BMWEPA+LesXLlZMJzcRzXTimh56EC620UEgrkYjh/zxsQ9Mma/6Kmx6F/WoaXrwfawZcJYju379f3Z8UpapDUYq0J6Ksm0k/oWwQCqIV8pX4eGZKiR7TQkWkgtzEVsDJwbAnCjPtyfQrcCNV8LKJoxp0MJIPRfXSSsiJ5loByudDabYw5btPBTlelLjkhz364ZDBAOM5KtmwNvmy71UgoTCeg9Se+2EYscI1kqqIFKYIIYUJgsjfmp8ZCeIDlbT2w3PGVV9iOtJ3+6GBeaP+VTIln5QUwohnXw3yR0k+K83vo/PjQTJxoyGFGwghrUU6ncFtt30fjz/+hPLQGR5ejAsuWINrrlkHU6oOz4KtW1/BD3/4Ezz33AsYH59AX18vjj76KJx33jm46qrLFuwYOg3J3SOhUuKZIoKUFDFCLAUjOQg9lpxaMT49pJs0FpWPMpZErGdQVfLtJLTkIJxYCpAiWm5SiVFyX8r9SarTWXcC6Rq0WK9fcjuSE8TKl4hSoReOVEoqWiDij60EFT84zc9e4uomXMkvFSxfqDwhKreSCqWz1f59r668qpYn4XWGKo3u/y3JeKtX4fO3pf4d8fwSkUttz7UKPl+y7nzbXPSZEs9UUF/lL0oMjZxnVa3PP9+SY0o3pYJWXuX6EtFwwTKyOFZhPkxVWCxU33On/i2rRUvVR73vCCHzQ8UR21Nxyuoz34tS/VNV1IvBc0X48fvjcH5BxHk9+AX7uer8HICFDUl4sXhg6vKb1Qr93Xz6uuJCELmg6p8JTzf8bYdhe4XjsEs8dhvff3i2pUKt5UHfzVtF1fcIaUeee+45XHrppTj99NNx0003Ye3atdPWefHFF/Hd734X//3f/608ZJYtW4YTTzwRl1xyiXpfSEHqppv+AZOTk7jxxhuwcuWx2LhxE77whS/jhRe24EMfuhG6Xpu3/X33PYivfOWbeOtb34zf+Z1r0dOTwgsvvIR///f/wJ133ktRahaIF4rk7pHQKfGQEkHKXHIy9IQfukdII5D7Te67/N5nMDo6it7eXnVf0ktqZihKkfYlVlw1yZtl3icl9gSeUShKrxsaJHmRderU2KAEuZ5UCXYRGE35+JKinCRS0vzA4BrleZRyN2Nf75lwypQtL7ct8UKS1kq7w3UML1tUIaucyBUVyaJt0eVzz1bheKaTVufKjXxX9iMimqvrgbAWJBdWwt5URS3f6JQKWYGBKl5VRsIP1JkpzHKOaLoBTTzlZKYsyB3jBk335O/QaMvLTIYNp+T50Yin1DYI6WbyInDIu+XCLqm+NyMqwbmEuzl+BTj56RdEKelZpe9IwDN7YSWXIp6TH2EgFodCu/TAgWIsFT41JQu5hTA/8aJSwX7ST2kxmF5O/Z79SYfi/r3QLBW67b/EU9YIQoklX16hv4p6P6lk7bItEc1US/yKe6pfDRKv2+niinvixVtlMqFeSB+lx1Jw8xklQHleHo41WejfBPZlpB25+eabsWfPHiX8nHPOOdOW/83f/A3+9m//Fna0Y4ogotQf/uEf4vrrr1deCvXk1lu/hx07duLDH/4ATj7ZF79e+9pzsXfvfnzjG7fi7rvvx5VXXlqTh9SXvvQ1JUatW3d54fPVq0/Bb//22/Hggxvq2u5uQJJJS7iUhOwpDykKUqQJmIuOA2J9WHuuhqGhIQpSNUJRinQNYoQom0hmj13HzyyuEtX6s/iqSp+UPg8EFXm5Rl9VT6XZIOLSvqFLqlZ8kn3JemrfdqKsIFVtW1IpaircxVBeSeW2XypsyUtKqJduT9bJxYf9bWkxHBhcW9im7Gv48CMqt5Qunl1KpHJ8zwbX9ziLehMU/m6QJ11i1eVIGlP77IlPGWqOlVbvRrxn2jL1fd2AmahcKp6QTsYwDCSTKWSzGdh2HlbORb7E9oslROwwK4sliT7o7lLxK4CnpZTQlI/k/fOMJMZHLoSDFFxzESwpoBB4QOUDVykRxpET8SqOTHK56q8K+wjyAppeBgcGXw/bGCj0TRI2PHLoIV8od3OR79hIZrdDD0KkF48+AD0IJQ7TWsg2xpeWGpTidRqI2TJkxPr9ccK14CSXQlt+qXoAndqRMW3SZCEw4r0YOvkKeJIA3nXg7tuIvqPPLhKh2JeRduTBBx9U4bIXXXQRUqni55jPf/7z+Ku/+quq33/hhRfwwQ9+EP/6r/+K//iP/8CFF15Yl3ZlMlnce+9DWLRoEGeddXrRsosuWotbbvkOfvSju2oSpW699XYlmF1xxcXTlq1Zc756kdkjopTkkCoK2SOkwWjxPixd2jut/yKVoSjVAWTSE3CcKTEhnSk2/nXDRDLVvQ+l4qUjuYv8ULG8n7hWRBIl2ogo4alZ+FxqBWwxjFwLhpPB6OKLkNUHKgpDc2HBt2XWPisUFbbEiFty8AF1HvxQuxBNhdYobyovrww2O9yH2Y+9w1cVhCxfpNoAQ0qta1I6PQ/d2uOHQ4beW1IBsYz3wkIJU0ZEbDKj/04Wz1rEEi2caJGQBpPq6cOaS95YGFe2H7QxkS0eV0SQiifLjyt6vBd9J1yBdDYH7cBGuD1nwLJ1jOciolTgkeTaHg6NXFokiKctf19hv+ToPXDMkrxRekKF1zmuBit+xFS/FGzbNnp9wT1SZU95RymRSlNeWo4WkYtpAACUA0lEQVSRgmf4+fBUeirps0TYD708VeheLPhbvLKC6ntqYRBWGOuHFh9siAhVSZjym2PDNhOIpfo7LkdHI8hlJpWXXSV03USii5+jGs1LL72k3k855ZRpla0+9rGPqX+vWrUK733ve3HqqaeqZ46dO3fiySefxF133YVXXnmlEOJ35ZVX4itf+Qquvfbaebdr8+bnkM/nccIJK9U+o/T39+HII4/Arl271euoo46suB05jqeffkZ5Rc02BxUhhHQi7AkXOIHhQpOenMCG+36kZrRDLLs4jC2eSOGcC97YvcKU2aOSaYcJz6X6m/HqfbB1SYTuGySO5xsfUplDrA7Ps5UR5GiVRSTDSdfk9dTKRNsngpGr9yhjrRSVT6pMnpai41Mi1ZXqnJiGpkJjRg4+AJhT51k3DECEKUI6kHYaO2Yz0VFKNUEqKkzpbhyakQDiA/B0XZXqLoc/OTCFHVlP5ZuaZZ8RFdylLwqRPkm8oxwjCU9CmUVwD0N5RSsXB1pE+jnNgNWzotBnGTpQ2Jxjqep8+SPfgESTBClSP0Hq2cd+DCs39RxVijxHnXr+OvQxSXJDkP5TkNCXKN/61reUoPPmN79Z/TuRmP68Iogw9Zd/+Zd49NFHYVkW3vWud+HYY4/F61//+nm1a/v2Hep9yZIlZZePjAwrQWr79p1VRamXXnpF9YdSMv6pp57GHXesxyuvbFP90bHHrsAb33ilCgmcifXr78T69T8tu8yyfC9RCXGsFOZYb2Q/clyN2l+lNvjeo81rA6mOXBvPczv6Gsk92MjfXitT6zlon6fkBlHPBIaNwHYcJUiZZgyxWGD4R0QpO2+pBy03MlvclZg9Rcm0laEjIlRYNW6WkWUiSI0cvM/P6VQBCTURw6jVhal6Eh6rFlhuypjU4/DEMBVaufSr/F5yk2ogCbHc6WF9SDJHAWn/saOaIFU60TFREr4noXurzr1qRmGqlfqiYpErXrvQpZKcB+OE9F/RSyih3yUh0p1Mp/aP4iElz0mGGYdhTr8vHBXCmqnqSUXqH0IswngsFpsmNo2MjODrX/96RUFKuOKKK9Tr4x//OP76r/9aeTeJMCUJ1OfTDx8+7Itlvb3ln+vCClvhepXYs2efet+06Rn8/OdP4Prr34XVq09VgttXvnIL/vmf/x3XXfd2vOlNV80YTnjw4KGqOQE3bNigki03AhGktm3bpv7drPFOrrW9Szz7aeK2KiJIuWM71RSQXzyk8xC7+2c/E9ucE/GTk5M1rcdf7AIlMGw0IkjFE378tFvIJusjOUHIdFSFpuD5OsyRrjuWn29EQtrsCZglydOjOZ9EkJI8S8XhblPbluXVPKm68TwjSCbs5/AK7ksJl4nmTQ4TDocGjyQtb4Anghhce5/5KRxryhiPelmov+Mp9J3/Ky1tjJPm0K5jRylOmYkOS3Lt2VNJzvO5TENnOMtV/ww/n8mD1fCKPaX8yqrz6L9kSJD8gxIGKO/5CTlBJV9qTE6pRtIN/aMIUrF4+Tw0js1Kho1kcHAQ+/btw6FDxYLLI488gre85S01iywiSolI8b//9//Gli1b8M1vfhPXXXfdnNslXlehaFYO0zSK1qtEJuP/jvbvP4D/8T/+v4JXlFTf+8M/vAE33vgRfOtb38X5579GeV9VIpVKYmhoUVVPqTVr1jQs0XLoESHVEpvlHSzn9hfZNIxYZdGSNBd5fpDRO7bsvI4NN3fyObz+9T3MKYUpz9eZ6Mw7oQUSGHY7VlZmVKce/q2sh3wkn0gzk6+qHFNGElpekoIHRk1gaCSDZN8iPi0++CAcGGW9nwrb0mKzCnfrJsJE6qaIc8F5DitciY2r1tFNxPY8UgitVOsE3lRhRTzNTEI/9vIFF6bEA0AMLkl8rAV5ZmJmJDm6bcG2GmuMk/agE8eO6ERHzHXhRgR6V6rpNYByVUZLiVYULefBqkfyvogQnrD2wFGh24mZ922kguIRU/2X5tjQ07sLFf5iu+6HXupdYybhLr9swYQp15osCnFU7ZVE53YO+cw4dDNe9/GV/SNpJJIvSkSpZ599tih5+Y4dO3DuuTOHtUW56aablGfV9u3bcfvtt89LlIrHg5QPFcKbbdspWm8mJFzv9a8/r+gzEabOPfdMPPLIY8qLSkL5KnH11VepVyVD8OabP6vEoUYKROIh1eh9RpH9qgrMHSp2dAriISXXqFOvk6bbTf0dtBK1ngOeqQVIYNjtiCD10hN3qtn0EKm6ZEcqL0mZ6qWnXdkcYcrsQebIy2DlbZUTREQoaZ9uT6LvwAYllCgPKHl3/UTfAr2fZofkiZEExvGIi0M86HES4Qy7nUF89wMqZ0shnCZcpnK8WPDsrF8tsUGIwRXOsBkRo6uRxjhpLzh21Ac98HIy7ak+Y7T/vJoripbzYFW5ogIMKbqg+u//v707AZejKvPH/62lt7tm30iAEPawg0jYCYSJKKKA4vIDHRHGcQZxHBd0dISfo6OOoo76H36iKKjDCIKyBQQCYRMEWUIIyEjYkpCQhCx366W6qv7Pe6qrb3Xf7r7d9/be30+efvqmq7q6urv6nDpvnfMed9x9kSTsMgtfsLyX8ivqDCO0aRWgZ4b1SbkV7DEks7tKmVWjekICUkMv3Yt4/tBx10XEHcLw9k0wIl01q19ZPlI9SE+bxx57DCtXrsSmTZswd+5c/L//9/9U+brvvvtW3CCS3lU//OEP8fjjj09qv/r7vR5Hw8PeDL75RkZGctYrxh/+J/VDoQDWjBle76jNm7dMan+JiFoFg1JVTmBYSdLBchMC2oET9DHLbEkW52YSxmVmA1LJuj3qcdeFY9tq3WIce/ykSuWs4+1vElZiBJoRguGPpU27Kv2G2ic7BTs5AiedgpvXvdaVqcAz04HnLSjwWO5/tcD7HpfkOLLS6Nn+uApMyVPlKrppbfVmhcpceXdgYCS6pwpQaY4LzfWG9qnX8+Zmknmcxmw+u0ymDZ9A40Q9J9uAqj21n3Chy/sr8PlLQK7U+8kfMmNmht7phqZOIv2ZtuA3YjL3fgNRPl9kpmb3807JMHN1LMswP/V5lPid5OU2KfR4djhgAbJM5UqR11M3/7cUeI48Jr8l6ZFgp+H4Xbny2EUeL2ddO13ec+1M2SH3Il3m83xMvNhcdUctktWWrjdKLbML1ClePeL/HfwdBMn6Xhme2b76Tcn6Um5I+VGgrMxsVwJSU7Y9oIJKvYXqAL+n6pQTx+TpM9OD2VlEZfi1K7mNMj27MiWR10M2c0XWcFNAJqjj96SSUe/ecMBAOWdEcqsZKbfkvakZXbvk6kqBXHnBMquM8nu8assvtzL3rtSb0svXDEEzA41Z+XzTCTVLXLH6dTIqLR+roVgZW21O8JgvcIwGz6PkvclxXup8qhrKrQsmo9J6o551x4c//GFceeWVKheJBKhOOeUU/PKXv1TLfvCDH2Dp0qUVbW/OHK/cld5Xk7FgwfzMdrYVXL5161uZ9XYruZ3ddpub07OKiKjTMShV5QSGlSQdLDch4Eiq+FlrMplAYnhAdas3Mkn9gm0ROXGSZOevv/hk0VwJIpE3Y1/B17LKC/rYVgKwpJEQAhxvnyTQEfLbKTLrgmMhufkZNYV1kNTPWqBHla+7wGcQyTt3DPbEGo98RjLUIaJvg2sYcKB7jRojDFcl3ZOTbe/kuze0QwVVvIaKhZiz1tunyAhczcoGsIKC6zrpyhsGEuia4m6GZj8joSLUmu5a6IpKwK3w1T/haiZi7gtw0qGxz028mpOrxW+qSFtNfZJ6CMmuPVUiWWH6b8lOwjCHAV1+G0aBIX5pQLegDTzrzeJVRH5uk+x+BL6adJF1RNzwgqkhZwialYRum2N6WUgD20insOPVp2GEohgIFd5eNK/3QCnRvG3EwuU9VxpFmza+jqdU8E5HV5nPqzTpINWn7qhFstpS9Ua8xLJUamydkkxLT1dvuUr2nLayv4Oc56ZdddMy2w+nHWiJN9AvKakcDd0F6hk/PiY5mmLmW6o3lF2ozFOB8xF028/CcSMFyx/Vy8ocUhFtuSyAbEmuI21MkVlAENLC6DGG4GojOfEk/xfkhkLoSq0F8so5YegaTLd4meWR5OcW3KE13sWPcWTLwmLLM+WWX5YZ6SRiGIKBELRM/ertuHdRQXeGi9avk1Fp+VgNxcrYakunEnCSg7DsBJzE2NNiOY9y0hbeXPcUBmMR7NiyHi88Ixdcalc3l1sXTEal9UY9647DDz8cH/3oR/GLX/xCnSdfe+216nEJDj733HO47LLL8M1vfrPs7b366qvqfrJDaRYv3h+hkIl1615R+xLsGTs4OITNm9/E7Nkzx+0Ru2jRXohGo6pnlfS6yq87JNeUmDePPWvLJcMV5fP02lPtmTybWvvYlHPBeuV3a0UMSlU5gWElSQfLTQi4faj4Ve2BwV14bf0bmaS0oWwDwpe2LGimhd33OxKxnuI/hIH4+L2gyllHvX58AG9t2Qw92gUzc6XWSbvq5ifKtd1hROYchlAsd6YeJ+kiVaDBNDwy9rUT1sSCZmrdtAsrPoBeaxNcowtpLQzNSSEc36WCUirQJI0cx8FIrB+OHlZX4A1nBFu6FqttzEpuhq13qWX5guumzcpnI5LG1Z7uM3jVOKxg0KsWDP2gkj2zgsNk8nspzEq8AUfrzg6Z8WOshqbBlHwsloXBKYsRinnHYMTvKZUaQGjH5pxeB2bmJE+mX5dedXBGYPQdAi1S/HOMFQkEmYGT7uDfY54f0VQulp1bN8GQPDCZBM/B4SmulYSNEUzd83BEYn3oixU+6Sn2eCFTu3LXnZb3/2Kkh5Qc7UcctQSGaWJaj16TpINUn7qjFslqS9Ub2wuUp76hwQG8uXkTYrEuhDMXMtyEA2TK17SVhJMY/R3kPDfpYCjhYmjQ234qkYZuu9jVeySSaR0Dsp3895epF4z0IKamNqsyJikXNMosU4PljwRmYolB78JCphzxeq3aiHd5+2raIWzvPQ622aP+H84EfUL+jKF+r84CpNyKOoNFyyxvAynAHoHTczAQHv/7io4zMY9ftvnll50YRPytzQib3Sp31OjrOghJcWn2wbZGCtavk1Fp+VgNlZSlkxEfHsDWLZvU56kXOBdzpbw1Upi96AjMnNqDV1zggMOOyQZta6HcumBSr1FhvVHvuuMnP/kJenp6cNVVV2XPlz/2sY+pHFEHHHCAyjH1/e9/HwsWLCi5nTfeeAM33nijCiDNn+/1dJooKatPOul43HvvKjW76mGHHZxd9uCDf1SBquXLT8uZlfXHP75aDdO7+OKPZi9Ah8MhnHLK8SrX4COPPIbTT1+ac5Hi6afXqGF9b397br4pKkyS2K9duxaJRELVwztGDsaM2fMavVtEOcemBKIXL16MRYsWNXq3mhKDUlVOYFhp0sFyEgIaZvEGRCQcUY0HmS3J707un+Rn15HgUDhS8gRKN8YPOJWzjlpPDZ3wriL6VxI1GUrhJ8qVE3hZXiARoSZjKPJmD/QWFJx6Kee/bt7/S5F1vWCPP9DO7x2lNhy4IbvcH6znB4nUlXgVuCoQ7JAkuJl1JxxUygTH6hWUmkjwTKh9lL5dWng06bufpFzT4Lia9FPIeS+u34jLfAfeLfukzL3/txwvckyVKK5yhs8Uflwrtk5mmZrOPHNsqrGDmf0PrKSWyfGtGyZ0iZoVYBR5vJx1jfG6TQRI2SEBKbmZFTxPMPFic9UdtUhWW6reMEqU5XJCL8e9NAK1zLSYaUuGinrLHWkcBn4HQZruZMrwzPbVmDj53chvX8qzsb9Bv9z2y5HR8jhvvUD5GywTg+WPV2bI7zi4jvSgcrI9pyTfVDrUDztT3skQY3VfRg9H2X+3VJnl/SdQZpVRdhf4THL45Vb2PvP6gXIqZ1sl6tfJqLR8rIZiZWy1ycUzOU9KJeNF82Kp86hQRL036Z0q51O1DEpVUhdMVKX1Rr3rDnmt//zP/1RBqNWrV2P27NkqGCWuu+46vO9978OKFSvw3ve+F+eccw5OOOEEzJo1K2cbd955Jy699FI1i58cr6efXricrcR5570XL7zwIn760+twySUXY+HCPVSA6uabb8XBBx+IU089KbvumjXP45ln1qi/JfC01157Zpedc85ZeP75F3Hjjbdg+vRpOOSQxarH7LXXXo9kMqlm5ZPJM6g0qSOl0S+jT2TWRvmupSd5OBJWbSRqPmpiDrnANTLk1S1tSEbjbN06osouCVZPnz4dQ0ND6lidOXMme0wVwJZJDRIY1lNXdw+WnPyOnMbQrrweTXISFY215hTNzarSWaGodaicZ5m/7cCwHE4JTu1Ud5QKSkWjMXWhI532yrZU0pEUfFmhSKxtZ8yhzisfI7FuHHD0cm9oahGSq0vWk0yTVF9Tp07FySePznos3vOe9+CGG25Quad+85vfqJu/7rx587JD9oLDDWVqdglQTZYMwbn88stw00234kc/uhoDA4MqqPSudy3HmWcuz+kxu+++izBr1kz09HRj/vx5Y3pdfeUrn8ctt9yBX/3qBrz11nb12L777o2vfOVz6p7GJ/Wr9EKRgNTq9Sm46Ma+sQ3o0mchFC2c55EaS3JPxk0gFnW9C1ltKYzfPTWAkTdGoEf6cESfg97eXmzbtk0dswxKjcWzyhokMKy3WJc3DMFnldmjiQrLDmFzJdOUDQMpdT1ch6WutEmOD9vsxo4ZuTMz5ZOAlG50TWhku+ZqkK9RhpQU6l3QTAzpCSU9CORC+QQv7kqS+dFqKdNDTR6Q4Xt1IldrZFZIyaWDzNVyy8797M0wG+PUPnVHsfok/0LH+h1pDAWG3slvIByt3YWOQh1kVL8k1yt/tUB+uGD5I2upjjywR8uTzIQRMjxby/aGnbxCZZZSxzKrntq9fPQCTtRKpIfUn//8ZzWkz59Vb/v27dixY8eYSX+kl6r0rtpzz9GeSpMNTJ1//gfUrRQZlv29732j6HIJQn3gA+eoG038u5BhUdILBVpUTfgQivYh2jcbRrR6Q5ipelwnjVQoinBXf8vWGeWwdQPJUBecdAKOE1HBKDlW/TyjlKt9j4QGJjAkZHNHZf9Ou+omVJ6gZqSGl5iZhLn+jFEyo1MCbib4FOz95BTIr0SVUTNimTFo6bhq5Cn+cEh/ZIwZzQxZqS2ZPl2mUVezTGV0R7QxDbP8xngyPpxzhT2UN2MUeyq2v3arO/IvdMRSaVj+kLympuWW4SJYjuuhSfdgLVlm+aTMqnEvWZmFL+cbkdnjZBKRGtWvEy0fW11++W6kXFiphMq9Jj1i5Jb/e6H6OfDAA/HYY4/hnnvuwa9//Ws8+OCDKjG6DOUSMmRGhux9+ctfzg79o/YiPU4kT48Mk7LjO2CEuhCdtT8DUtRwcgzKsRjfvFYFzGWyGjlW2UuqMAalJpHAkAqTqLcM77AC+Rks24UdmB1Prrg2yzhimSXPT0eViEj36swU5fK4k8b2aSdmk+KqYXsMRlWP2YXUvKXqc/ZFMjMuhfwcL5IbRZLr1mN3IrmvE45q4zZYXnj8LpWLJPucvFn+wpEYDj/+HQxMtTHWHdUjgR6VgzCP7geASpCgUzwmPSECfZgkQbodz5bjky7DS5RZoy9qADUqs1SuqFAUrpOAm7Jyg1KuBQcWjEhXTerXSsvHVleofA/pkvR9ADvf2qyCzzLUVXoWMjDVWMuWLVM3YVkW3nrrLUQiETWcj9qfJI6WoVEbHt2BUGwKA1LUNKLT94Qe6cGxi11VHjEgVRyDUpNIYEiFyZXSvY44XV219cmMTMPJQENBN8ac4Nab1ziJQbfjMPy8UDltIRmm16uS4jIQNT5pNOb3pZCTdk1m3yvF7PI+9vRITkMvy7HhJgfqGpwql1xBlwaLYYZhmN40WtFAwuS0lcokzy2eq4TaA+uO6uXpM4oEoEr1cipU/ggtE6ySgJSf3HzMc+0R6H7PqiL7ljMjn19m+fKDUjWkh7vRs/dpiOUlsleJY7euRs9uh6lZ5Bpdv7aDQuV7xHDhphNqghmZDMCbZKb4MH6qP5mJes6c1uiVStUjQalQjwkj5M0aS9QsjEgPZs2Kqbx2VByDUpNIYEjF5XfhT+kOUk2WzE4aGYOzvLxQ0pNLpAK9uWrRM0oaP+PloWq1AFhOYzIv+CKdhmQkkwT/Sg6ZSY8g/MZ9akiMnpllKm8UnBrGp+9xatMFpoQ0WELhaG4Prww/WTS1t06sO1KJ4ZyLD6mECyvpws7kn3LzZoItRcq9nTO98ji/HC5VPpYqf8oKZtkjmLL1fphuosS+xVRdAbM5yh4JTJnh3HJGvoe0GUEo1tvWOToaXr4bLlKGiXA4qmanZPlOREQ0eXU7c3niiSewcuVK1Z12+fLl2bHdMu3plVdeiVtuuQVbt27F3nvvjYsuugjnnnsuGqXcBIbU+iQwpfJpZ4aL+Pe1II2f6W+t8mbsK0IaT29NPxmu3jrT2EojUfa5ULBNhrJ5ydrzehrkkR5SEpCCHgJCYe/BYFDKTqmr09JrijpHK9UbnVZ3SEDq5afuVsO0fRLcT9suEpl2uq1FEOsrf/iMH3CqpBwuVf6UE+yX50mZ7BohuFqowHJL9aYttX0iIiIiavKg1Oc//3l897vfzf7/C1/4Aq666ip89KMfVbNn/OEPf8jOkvHKK6/g3nvvxWc/+1l861vfqsfuEdVFtvGjmXAk+FJg+Iksl/Waq0/Z+Io1+GxDg5HXc6gUGWYDwwvIBWfyU59Hiem6qf2w3mhu0jNHAlK6EYLhB5LTMrRJEr27XiDZigNuf833pRq9SyUg5WbKnhy2DAFkbxgiIiKiWpngBO7lu+OOO/Cd73xHXUH+27/9W1x88cXo6enBP/zDP+DnP/857rrrLjWd6wMPPIDnn38eP/7xjzFlyhT1nD/+8Y+13j2iupOAlPSEyr8VClQRdSLWG61DAlJmKKJuRuammxGZzaLRu0ZERERELaDmPaXkyrYkO5ar2scee6x67O/+7u9w5JFH4tOf/jQuvPBCXH311dn1999/fyxYsADvfve71eP+c4halZ9HykgPZWaWkp9dsPeQ5vUQqmBb7ZSTqlVYKn+OjWRm+ve4oyMxMgjbSiFtmNA0HabfY4QmhfVG5YaGhnISLg8M5ybCNg0DXd3VnyHMTqekBMv8DTXLqqN6TKXgyuyrZcyaR+2dayyf5LzKzztJREREncusR06Qo446KqeRcNhhh+GYY47BY489hksuuWTMc971rnep6T0feeSRWu8eNSkn5QUAfG4yb2YkNd118wdfgnmkJCAVTb4BRxLuBpLuynA+bxrz8rc1Xk4qBqaqH5Da8Ow9SKfiKkeWCJmAbVnYsWUDNF2HaYYxbe6eMKLhnNn3qHKsNyoPSEnvspGRkexjybyYgMz6snTZGVUNTDm2hcG33shOW2o7LhwXSNuZ2eCcNFwjBfQOA1r1p+hmkL41co3lC0ViaobeVglM2YFk5rrhwrbTSKUSavY9IiIiaoGg1Pbt23HKKaeMeXzPPfdUjYt99tmn4PP2228/rFq1qta7R00akBp66V641mjwxc6bxUlmYsO8pUATzsRWNI+UYXgJvyWZbiYoJcs1V05s3armpKLqkga2BKQkf04o6uWdCZuAY1pqVqZ0OgUrlUAqPgTDzc1LE47EoBucDasSrDcqIz2kJCAVDofVTRjWaJlipVKIx+NIV3vqetdVgSfDCEGT2QXl2oHjev1AJSmc63iTE0iZVH5qubIwSN9CucYCpGepLC/Vk6pZ6NKjKxJDKhlXPQKFq3sXG+LxEdWbMxqNteXMmkRERPVU85ZSb29vztVbn3/iLFdvC5H8II6T1zuGOiYAIAEpTRryfl6S4GxM/kxsLRR88YNIXlBKz+kppUnDrcJtFZqdT7ZSbEr0ViG9yWB7rddMDmuP3Rw9jgzTy58jQiENCEcxe/f9YKXiSCXi2P/oZZg1LTexswSkorHmDp42G9YbEyOfTzTqTV3v6LmBbsuq3TA6CUhJA96FF5DS1I9XEp7XLm1ltYP0MsueJDUv+DhNONdYsR52rSAS68YBRy9XgVdfT8jF6y8+iYMOe5sKRskt1lX9YbFUmRtuuCF7YeLQQw9t9O5QAwwODmJgYBjRbhexaOFzBKJGHp+7du1SuVL7+voavTudGZSaPXs2Nm7cOObxk046CaZZ/OXffPNNzJw5s8Z7R03NCHsJc1Wwwm2bmdgkCOUis/8SkJLeUo7kZWkPwSE1hqtBd0ffmYotSk4tMzdI40qD1oxBS8cBK/PZ5LVnVe84NWyz+RpfjuuogGC0qxddPbWfbazdsd5oHa7jwJFguAs4jquCya6U13UKDuYH6VVgW4XHvMCU5PIrNaRP/V+PwpQAVpFZ9hwjptajziOBqaBY2FG9Y3t6+2CwB2zT+MAHPqB6rl166aW48sorG707VGfr1q3DM888g3WvTEEo2oV5c+di5sxZjd4tImXbtq146KHnVK92uXC4ePFilW6CctW8Rj3kkEPwu9/9Tl31luigT6b1llsh8qU9+eSTOPzww2u9e0R1pKur+jJcz+8d5Q3fs2HYcZXsXBpHrdz4yR9SI+mX9EC0Tdc1uEYU9vxTATMwpMbsQmreUmhOGpGQn7MpL0ynG9CafLgmVQfrjeYnyarNcBSu6welZCifl1PKtTMXEXSz6sP2Su6TYyEWf9UbEi09qVwb07Y/mDORRP6QPrnfOfMUhPXiQTTVwzVYXhERUVMYGBjA2rVrVS/paNhAMhXH66+9DNNAtucwNd+IGMtKIj4yCK0JLzZXUyKRwIb1r2LfBWnMmDFD5QCV41UuoLLHVJ2DUkuXLsXq1auxZs0avP3tby/rObfddht27typrooT1XWGPL8xVYOEudIw8hKajzZ+pIeUYSewfdqJsM2e7Ou0al6oMUNqNM1rlMqsg9J7QQJy1iD05M6cnCLSU0oCU+rTzwSltMx9Ptca9vLUBDiZGfHU8xi8anmsN5qfJKne45CTVC61UKQLRigCK+0ilXYxkslnJbms4Gwf81wtHehNmVfm6hKglxn8jNgEymI3k6NPLgDoqjyxjShcPVxySJ9sz8kPgjeYX875ZZsdKOPU/2HCCLOcI6LOJhevpOEvDfzdd25XE8+kR3Zhij4T4XDhIcTUWNKb2jVc9IVdaHmpBtpNNDWIvSKbsWFoCqZNc1R6im3btqnjlkGpOgelLr74YnWrxO67766ukh999NE1269WNjI8lJOwdmgk9wpvIqUzh00FpIE0Zev9qrFSJCZVtYS5wSv22cdcWwWkbLP6s1M1ij+kxtUkFGUhkngj20NM7p1Nq4DAZyFD96SnVE7vqSINNee1lV5OsYBkYKifZsYQ2etUBqZaGOuN1qCCUWZYBaQkf5CjuTA0F3omIZwmE1Q4Y8vb3i33q+CTCIzMVsOyw8nNKpiUjMxRwe1iZXEpqmeT+meogJQ/vK9V8u4Fyzm/bLODXU5llrtoDFP3O60jA1PJ+HBOnqd8kt8sf9gdEbUn6U0tPaKGh4dV713HSiAc60WsfzZCsfY5r24n0rtavqtId3/bTwQkeQdHYr1w7CQcJ6qCUXK8BkcBkGdCR8KGDRswf/581MoRRxyhblQ4IHXfPSvUTEq+ZN7MdDCiOPz4dzAwVWHvHkcLwZYeOzWY1U624RR5vJHbqgc/EKWGJcpNhvdIL4hMEnsZciO5pGTo3rjXSyQJvgSk9EASfNU7KpMc3ZEk+DKzk12TUUMyA1Pa8rYcvLgTnDKcCmO9UXsp6ZmUkcybfa+WZEY1dZ921c3J1EnyeyxY3maGK8tMpMELAZom60sB4cKWocx5QfyOmWE0UM5pmWThOaO67RQcyyvnmpV/TJT7eCUBqRcev0vNiFeMzJgnCcoZmCJqf9LbRHL0SO9qa3gnzHAMvXP3Z0CKmoIch3I87tq4Vs0s3d3drY5X9pKqUlDqmGOOwYoVK1TeD6ov6SElAalQKIRQZiYqPRVofFgpjCTiXo6PVicn3pk/szlKMo/XgtdIGjuF9WSurvtJdKUhVWwb5eaRqua2iiUmL/q6VZhSXYbTaN5YPi+gZHiNLZX7vNKAmhGGlnm+0CR5lVCpZKofIJIhgXKik07FYSXSBUtPaQjJFXoqjPVGba/EyVU3uQLnB6aSeUWEzFhoVnnqeskrFYrEYCWlzrFg2S5s20V2wjpJdq7ySgVmG5UeUvJ7l15QRSLHauid6uEUHrcsDgbpVTmiyjIpa9qAlHOZyT6CaTfU+23SOj7/mChElst6EyE9pCQgpXromWN7HssFAlleqicVEbUXSRotw6K2P7kT4a4pDEhRU+meuRBGpAfH7uNi6tSpDEgVMaGzgjfeeAMnnngibrzxRixbtmwim6BJkoBUJJKZ+ltNaRaQqO1V8VrzcgJF4VqJ0RPvvN5gaia2FkgILsEcGWpSjaBPNbdVLDF5LYcutrJQtBvzD1mmeib0RL3mbk9Ub9iQkZGRISSTCQwM7lIzQJm2PiZI0dPTXNOUs96oHfmu3/nOd6pk777tw7n9KSUg1dXdU/W8UnsdcXo2P9xQwsVw0sW2Ie+146k0tO1rABlKm/aG7vVsewThxBve0DwJPgWLdsnrlx6GW0ZZUyhIL0EpSW7u+kP41PC/vGk8qabyj4lCJCAl602GBKRkFrxiPVpp/NQPrVBvEJVLglKR3pAaFkbUbMxoL2bNiqoLhFTYhC/rDw4O4l3vehf+67/+Cx/72McmuhmiMfRwN3r2Pi1naIKVlzfLu2xc/SCJIYm588g0w9IRJ2xosP0eORVttPKTb83VYKQ19ZqSl2ky2yq5a66DkJvI5IAae9VZGnmyPKI7Zb13Q/ZbVpNcUgU+y1YPTIlIJhgVi+kNa1isWnkXtm15E5s3bVLHZySvJJdeMxKkaLYGBuuN2sn/rtNG8dnkqikYXEjpDlK6CyPtvbYOC1qgXPGGSiclHbkKGLm6kROU0tTTZKk3c2d+GZJTFpvdGJx1Sk6QXk8Pwdj2AGwjlullpUMPvv5ky3Iqy2QDTlSf1A+tUm8QEVH7m1Cr6qtf/Spc14VlWbjooovwr//6r5O+gv7pT396Utug9gtMGdG+7E2L5N2YxLr6QxclMfmY29hAVTlUnignmbmlJLkMNAkytnsumLoN4U1AzwzZ6uruVo0I/xYOh9UwrmCvmWbAeoOyNN3r6ap6S43eZNheJaT3pkwQ4d8cmcFUlVl+wMkJlENyY+436kzB1A9SZ7RKvUFERJ1hwkGpX/ziF6pyk0bG17/+dXzkIx9BOl3ZGP5XXnkFf/d3f6fGAv/whz+cyK4QNQUZBmekB4veZHknyA6pcS0Y8plIvio7npl5z4IGJztshyZHhlqEI1E1jFdm8vBv0rhoRqw3OkM6OQw7MaBuTmoQrp0EUgPQUgOqJ5PMsFfP8id4k8cnknePqN1SP7RKvUFERJ1hwsP3LrjgAjWT0jnnnINdu3bhV7/6FTZu3Iibb7553AReL7zwAr7xjW/gN7/5jboqIw0U6VZP1EjFrqKPd3VdAk5Ttt4/bl6mnTNPafu8TPL+5H0Gh9RE3GH0bn1ABaM0Q3ox6GrYIKSxOpEk58JO5czU57qjs+9R82K90d6sxDC2PH8Phoe9IUJpx0EMQ9C3bUZYcp6nLYSSWzK/XWfsjJuq3FCD+7welnnGKysKlT+1mrihLqScS3vHuBP8oGo02QcRERFRI0xqqqilS5fi4YcfxhlnnIH169fj/vvvx/HHH69mWCo09fdTTz2lro7fcsstqkEhNzF37lx89rOfncyudJzgFN+pvNn3qDLBhLkoMltQqavrXp6UBByteF6mjpjGPCO/wWfDVENr9EyPKaHlJaJ1TckBU0ZxJEnwzag3XXqgx4Ub6HilmTKzE3tCNCvWG+1L8gDaqTg0w/RmjpMJKpwkEOpS8SbXHlZDeSXfk1ce2tCDwZbsb1rzyuNMeRE0Xk+nlgk4lVnOuZb3Gbh2bgBWj3Z2OSez7FXyOBERETWvSc9fvnjxYjz22GMqee3TTz+N5557Tk39ffvtt+Owww5T6zzyyCOqUfGHP/xB/d9vVOyxxx74/Oc/jwsvvJBdh8skMyhJ5n7JDSC5WUQyb2Y6NTW9NApaaLiHn9Q8nXJhB4Jswjvxrt1sBa5Znavrfl6mgooEuzqBfL5+QuJw5rCM5CUZVgEpc/zGpOQS0/c4FQgkwVfbC2l5szcy51gzY73R5owwdDOihuvCkuG68j1pcPWUmgTBis2Da3q/UTvQBUh6R8lw513TjoMdmdH6PZ0sCcKVuBghwbVQT8lyzi/bYoEyTnRHTRjhzivnZJZTOcdJJeNFZ9lT50DlXOQgIiKiplCVWluuWD/00EN4//vfr652+1N/X3HFFerqtiwLNir22WcfXHbZZTj//PNhmjxxqIRM6b102Rk50/ruzJuZbjClI1qnqemrEZCS4R5ydV3935GEnLnraKEo3HlLaxpoaJlGTpMNXawkMKWmaTczw+wy9xNR6DjQ8xps1PxYb3QuGZ7nf69jlhgxFZCS3pUtzRqGvuE+QHp1FiO9oRaeWrBM8x/zyzYjnFvG5f+/U0Ri3Tjg6OVwSuQmk4CUrEdEREStoWpn9jIL1K233op//Md/xFVXXYWhoaHs0Ar/5FOujn/pS1/CeeedB11nouPJBKZKTf1t5QWpJioZH8458UsmcreryRXLSU797A/30I0QNCMMxwE0283NqWHJUK3OGPrWakMXxyP5tnTJH5WhZb5azdEq6iFFY0lepVQyAU3XoWc+T5EKDO1tdqw3OovKFiVliZOGjszkD3mxqbZJRC49pCQgJWWcEejRJ4F+ObYlL5Qkgk/syq3fWrinp+QUS0olXkQ1zhkEA07VSf3QqvUGERG1n6pebpZktY8++qj6209AKw2L3t5eXHvttXjPe95TzZejGpKA1AuP36W6yPsyqS2yQpEY9jri9KqcZEpAyghFIB3AdD9yoVLhqiQRk94+1T8xsJ8A3nRHewroeuaqvzaaSyo1bykDUxUP4Y1ieHCXmsJbylrbHBvskdn5WgHrjQ6imbCiczE080Q4pndxxQpehGi14XnlkICUkRnWbVvQhjZ6ubOkzHVsOOvvl+5Q2dUll5QM3Wu1wJQEpDY8ew80u3jPsGqeM9DkUz+0cr1BRETtZdJBKcdx1AxK3/zmN/Hiiy9mH5dGhX9VW65+y3CMM888kxVei5AeUhKQMswwDDNzwhyIDdlWClYyDreG03tTfdSqAegngHeNEFwtcwxlglJSNMjQQC0dHzsDF43bU/LkU5fj6Sf/hIMPOwqGYWJad24PIilne3rG5qppFqw3OpgEncweOCFveJ4duAjR/hwvICU9wbTMb9aMjfakUrPttWbPYOn1nE7FEQnLBaaxud54ztB8qR9ard4gIqL2NeGglHT1veaaa/Dtb38br732Ws5wi2XLluFf/uVf1FVvucq9c+dOXHfddWrq75tuukldAafWIAGpUDiq/nbyGg9OByfvzhmelh7yZthzh71EvkHS8CiYO6VzSEDK9XsKZIJSkI+lijmrOk1XVw8ikSj6evthmCb6e1pjWBvrjQ5hp1QvV1cm4ZAZ9NyUTLQHzbWaquwO9hDV3bzJFzRD5cKrCakX5OVcR/US9ntSqV9CiwdtJCBlhgpP+MFzhuZK/dAq9QZ1roGBAdUjXHrx9fX1NXp3iKqGx3aVglLf/e53ceWVV2Lz5s3ZRoU0JM466yzVqDjqqKOy68oMSu94xztUA2TlypU44YQTVFLbefPmTeSliZqGPzxNglKh5JsFh8BJwyYVnQPH6GmPPClEE8R6o/3JzJdGOAZ3OK6GXbsqv5AFpEegSb5Ax4VjxBpeFmbLbsml5z+Wlzdc9lNmDa1ZYIqIqkYmyZD6ZO+99270rlCVrFu3DmvXrkUikUA0GlX5JRctWtTo3SKaNB7bVQxKfe5zn1OFvzQqpLuvzJ4kiWjlQ823//77q3whMvX3U089hTVr1qipv6WBcdBBB03k5dueDFuRJMa+gWFnTG6A/CteVH/+8DRpvCS6Fo7J2Ov1nkpj1/QTYYf62ytPClVFfCT3t27aetv+1llvtL9QtBuzDlyGrQNej5h4Kg3trdVwug5GKq1jMOnWtgdSpWW39OL08zkFglLSo0u342q9zu7nSpMpz/NJuRfr6ilr3ShCbVP218OqVasavQtU5V4k0miXof79/f2qXbR69WrVY7pYr2lp4MeHB2AwaX9LDPe2UknEhwfVxaxOYFsJJBLA4OCgOpblXHj69Onq2JZjfebMmR3fY2rCw/dkSu4LLrhATdE9XnRvzpw5ePDBB/G+970Pd955JzZs2IDjjz9eDck49dRTJ7oLbUkOzjvuuEN16fMl83rzS7JKyQ3QTicsrp2S0R1q9j0nb/a9ZieNGlcfO1xBc5LQ7BEvfwoDUpQnER/G03+6C4nE6GQCEVNr69866432Z0a6YUS9Cyk6LGgyNC3cB1fXVQOjWctuNxgPlqGG0sOrGoJ1mPwtPWrlxRjtaisSZHp01Z055Xm+aDSGJSe/Q/093rpTervaquwnqoS0gSTIJAGpdVssaHoMyaEdWLl2F2J9Y3PWCckEMLVPynMWrs3OcVwkTaA3JnlEO+T7ikWwah2QGNyFN7fGEYr1oa/PUUHWbdu2qWOeQakJuOSSS9RV7/nz55f9HBkzedttt+ETn/gEfvrTn6oo+BlnnIGrr75aNVLII1fO5MAMh8PqJgzLzZnOV2ZPCSarbIfhHnZKhntYKiiVPwpOC0XVNNlE7cSx06pRYkretkxi4GhYa9vfOusN6igyRNGMAipxeebKkuTQ85OYy3LdHE14Ti1/7pZfngdZVkot93tHjbduO5X9RJWSul+GNcmFeglI2akEzEgM0a7+bJ7bQsKRWF33kyZ+/ivfY1d3P3Rj0nOutRa7Xx3L0nPKccKqzS/HelcXOy9M6Ej4wQ9+MKEXk1mVfvKTn2CPPfbAV77yFTUt7d/+7d+qvCHyfxolASk5SIWTF0X2p/OtBzs9+lrpvNn3qnVVXYZ7SFdOMZJy1S0/cLXDYkXTqlRyY//c2k8m7DLJuU8aJeGI91uPBIJS9f6t1xrrDeoooW4485fmXmWxhqBvuB+QIYNq2KAMZ3UAO9kyPYPHU+zcoFrnDK1UnudLB86nxlvXsVo74T3RZEiPERnaL8OcpIeUNOKnzT8A4a7O7klCrU+OYTmWt73+HLZv347u7m51rPd1eC8p0ZDwpCS13X333fHxj39cNTAuv/xy1cCQK+HUHHTdVFccUsk47LR3Mpl/jhSKxKDJld4qBKayf+sujEJdOa3mGvZB45PcMY4ehekkskNh/BmuJOmxWseMwa3CMUTtj/UGtZzQaN2W7R0V7svtPZUXeNbM1uwZLBePzHAMjp0oOstetc4ZiKj9yRB/GdokQ/akhxQDUtQu+mcvhBntwdsXOJg6dSoDUhkNOzs4//zzsdtuu+Gcc87Brl278POf/5yNiyYSiXXjgKOXwwlMTz2UyA0MycllOJp30k2UIXm0ds48BWF99LgJZ0qciOEFp1RAirNbUZlYb1C79Z4K5eWRk4CUlh/MapEk9/MPWYbucPELSDxnIKJKSFBKckiVGrJH1IrCsV7MmhVRuWPJ09BLVkuXLlWJbCVHyBtvvNHIXaEigakgKxBcoFHFhqFxeJoXmHICjS4387d/T1Qp1htULcEyWnPzhhzXSl7ASQu1T1kogalIlDmyiIiIqDINP3s4+OCD8dhjj6l7olYcnqa7Fgx7ZMxNHpflsh4RVQ/rDap22a0HbhKscowYy24iIiKiOmiKwf0yHOOhhx5q9G40lVRqNCloMm/2PWqu4Wla/nSB+Y0fg8PTqs21hkdnsVLTy2Z6YFkjcF0bmiZDYLpgZx4XaUfLzPbYXMNHZKYln59zSz3O33pJrDcoSAWTyiyL88tu3Y4jlNcTWNaX5Zo1qP52OcyYKizPx3u81LoMhxIRUSdpiqCUP26YAMMw1LSQMkWkH5hK5iUYl/GnpsFTlmbAgFNjAlLOayvhSrLgjKQOuE4azuCmbFBK750L25QZrjwJmYE9FMPU/U5risCUTIMbjcbU1OD+rEyOlTuUh7/10lhvkB+QmrL1fujOaJmQT3pGSSAqGJjyn9u74wmYbonnGjEMzjoFMBtfblDznrvll+f5ZLms5/9dat2e3i6W/URE1DGaJihFnp6eHrzzne+EbY9e8d0+nHsFV05Uurp7GrB31M4q6WlQc9YwXKdwDjM3NaRukFmqjLB6TNM1NZ266lOYmd1JM2PQwt5y9X8ZTmnF4QZ6WDVSNNaNJSe/I+e3PqUrd0Q1f+vUSSZaBslzJCDlaCG4emjscsdSywtt23+ua4TgagWe61qqJ1Wp/apHL1C/16f09tSbIKhOuWJdPWPK83wSkJL1xHjrzugNsexvYiMjcdx006144omnMDAwgOnTp+H445fgzDOXwzQn1rR69dXX8a//+g11XHz/+/+OmTNnVH2/iYiaFYNSTRqYCkobTDDeyeoRLJpIT4OasYahb7gPdrF9keTEw5uB/r2gGRH1kGaMNtjUtOvSW8oIQze95WqZq8FNNVfyeb+B4uvrbniaP6JJc1ISVLbhpNLQ7CSQGoCW1qFnhqIXGg5XjTJIAlKuPvqbz2GX/u1LQMrNlCe5zwM0WA3tBap2QwLvKjF6FD17nwaEGbBoNvnl+WTW7WJdUFWrVq1SE2SIf/3Xf510QOqKK76F4eFhXHLJxVi4cA+sXv0crrrqGvz1r+vw2c9eAl2v7PtzHAdXX31tyUAlEVE7Y1CKqIlJQ61/24M1DxZNpqdB1clrSKNMrjZmekLlyPYkCEyXRURNIZ0cxtBL98K1Ekg7DmIYgr5tM8IO0Ge7OcPhgoGppiqDGsWxvYCU9PYM9gJVgXeJTKXU59osvT2JWsXKlSvx9a9/HZqmTToodeONv8OGDRvxuc99Cvvtt4967G1vOwJbtmzDf//3jVi58gEsW3ZKRdu84467VZCrv78Pu3YNTGr/iIhaES/FEDWxYEPNNrrG3OTxajbU/J4GY29jG4k1Z4RVT6j8GxqxL0RUFgmYSOBEM0xokoNJfq+hLhWAksC5lCWlhsM1VRnUKMGyz/RuqtdnoSA9EdVNPJ7A/fc/jClT+nHooQflLDvxxGNV0OvOO++taJtvvrkFN998Gz72sfMRCnVQOUdEFMCgFFELYEONiFousGKGJbkboIcBI6KGxxXK20RE1ArWrv0LLMvC3nsvVAGooN7eHsyZM1sFmTZt2lz2Nn/2s1+pnlaHHLK4BntMRNQaOHyPCEDYzD25aDTJf2RYQMjQoEZvaBKYKrQe1HJZz5jEe9Dd+rwOEVGhsncyZVA1nsvMjUQ0nvXrN6j7GTMKJyGfOXO6CkitX78Rc+fOGXd7q1Y9jNdfX49LLrmo6vtKRNRKGJSimkklJNltOvO3CyuZmwNIklKbEc4iRBMk+VUkibL0JJMk5vJ/ybWiOdI2Vf/PHH6K7jZXknMiqi6ZKU8Skxd8PPj/9OjkEXp6SE2eoEPqq5R6zJUSJNMLNf+5RFQfH/vYx6q2raeffroq2/HzPXV3F87h2dXlPV5OXihZR3JQXXDBB9Hb2zuh/Vmx4m6sWHFPwWWplHd+lE6n1a0e5HUkaXu1Xk9tz/Zu1D7k+5QZtjv5e5X3nk4bdfttNlK575FBKapZQOrlp+6GlYyr/1u2i3Qmya3PCMcw68BlHRuYCjaMxiyTx2WWORpLuszLLHsSgLJG1EPSO0ICoCoYJZEomd0rHYeL0YLQNaSdGfNm6COi1uOkvSBSHs2Oqxn9NDsBTStcbkpydbVOegS9W+5Xea0U10Yo+WZOWSzrWZE5XsLxwHOJqH5+8YtfjBki12iplBe4NozC5YFpGjnrlXLttddj0aKFOP74YyaV42rHjp0Fl1mWtw+PPvoourvrc54tAanXX39d/V3pDISFyFDJLVtt6Aabq+3EdR0MvbUBm/8qp/R6xwalHttldEQeueHh4bLW4688I5lM4uGHH8Pjjz+F1157XU35KldC9t13Ec4442+w3357N3oXW4oEBiQgpRshGKEwkHbhpkeDUtKLxU7FO3YWoTENozFcRCIpaMZeTdnToC6k51Ohx10X6J4LfcHJ0DLTokdC3omra43AdW1o0vgMdSGWeVx0hTUVkDLCnRkEpdpg3VGnMsiOI5TcjN6tD8CVPFX5nLTKWTU04zi4RmzMYgkqSbJ13RpU5a7K05fJb5XsjkHLlDYyy5/mpjE08yQ4Zk/OcxtR9kkvUOHIA/b4DV2iduNKnd8kwmFvsgHbLnzumk7bOesV89RTq/HMM2vwrW9dPqn9icWimDp1SsmeUkuWLEFfXx/q2SPi2GOPhSkzKFdgYGAA8XgcsVgsu7/y/8EXkgiFozXZX2pcQGazC8zZ5+iODThaqQSOOSCijvdKfxetRt5DOTrzSCjgu9/9MdaufQHLl5+KCy/8P+qLf+WVV3HNNb/G1772bVx00Udw0knHNXo3W44EpMxQBI7mwpDEHhmq2ratzp5VL69hFKS7KWjOcPbqfa2DRdLokt4AalYslO5pUHPyGmYUcBKqoVlwlXAPtGg/tJAXYNL94FMkt8A2wqNBKTPwN1G1sO4oEViRxqSbBtyUKr802y1aZo1bBmV6jsqMo4WCTppuqYCSLHNC4w+FkXJXglieSDYIpNlJ6PaICkiVs52q0g1oZhRuerTs83NkubZXfmmhKHt7UkeQRlgikcC+++6LL37xi5Pa1s0334zbbrtt0vvU3++dYwwPe720842MjOSsV6x3089//mu8731nYebMwrmpynXGGaerW7GG4NVX/1AFhyoNEE2G9JCq9DXXrVuHtWvXqu87Go1i8eLFWLRokdqGbrCnVDvSdF19r5363cr7Hu93sq7I76LVlFsWdOaRUKSL6GGHHYzzz/9A9rEDDtgP//RPf48vfOFyXHfd9Wp2jK6u0hHNehsZHsLQYO4J/EjcyTnoozH2DGlWuQ2jwOOZoY71ChZJL4DBWacUHU5Y194CoW4485ciZDilG2+ZgBRRI7Vq3VErEjCRwIlrJTI5mixAhio7gJ4p1wqVWeOVQTJsr2frgyroVKjMVEGvImVkq5AyTd/jVG9ocobfC9Tv9Smfr87enm0nPjKU0/vGtHOHtJiGga5ur+depzj00EPx2GOP4a233sJHPvKRSW3rpZdeqkpQasGC+ep+69ZtBZdv3fpWZr3dim7jlVdew/btO/CrX92gboV8+tNeEG7GjOn4wQ++iXYmwTNpeMvQv/7+fgwNDWH16tUqz5YMbRoZHIQZZi/RduI4NqxUEsNDg9A79CJLOpVAIlH8wtfg4KD6HcjFvenTp6vfhfxOZs6c2bI9psbDoFTGvHlzcPDBBxZ4fC5mz56lZtN46aWXm2rKVglI3XfPCuwczL1ikwoMkwtHYjj8+HcwMDWJ/E4NGb7hv64Rq1uwSLbRNJ3kQ93QAkPviJpVK9YdtSQ5Anv2Pk0NzR4ZHoC2Yy2c6H6w0jqGUqPBdlWmpUdyyq5xy6AOyOuUH2z3e4EGe31S+wWkHl11JxKJ0eH8kbxZIqXX0NJlZ3RUYOqoo45SQant27fjtddewx577NHoXcLixfsjFDKxbt0rqrEYzHk1ODiEzZvfxOzZM0vOvHfggfvh17++uuCySy+9DNu2vYXvf//fJ92LqlVI7zLpCSIBqfXbLWh6DPHBHXj0fwfQ3T8D0/rkIkTTnJ1SFTi2iyHTRV/EhW506HcbjeDJDRo0rXDAdWjnAN7YHkekqw99jqOCtNu2bVO/Fwal2pwMsSgmFvOvyjbXDydt22qcqWmGEJK8TRl6JiiVtlJIJeMdPbtBKf5JnwSkYtvuV0lyi3GNKOJzllYtMKWmKJd5yP3bmBeUgkpD2AQcXhVvKEvNIjkaFEw63vcVd7wr2bpuIsKgb8dqxbqj1qQnj5MahrXxzzDsrdB3bEfIAfrciZer5ZSZuuuVmW5eg74W26HS5aNP002EoywfS5EeUhKQCp7LRQNBSCuVUud6cs7XSY488sjs308++WRTBKUkh9NJJx2Pe+9dhdWrn1O9ZH0PPvhHFahavvy07GOSY/DHP74avb09uPjij1Yl+Xe7kRkLZWiS9ASRgFQ6mUQ40oWu3imIRLvUjdqLtEtD4Ri6e6d07PC98XT1TlG/A+lR5ThhFYyS34k/w2c74pEwDulO+uabW1XSwr32WljV6VnLnTrVThcexmTLlJquCzNk5gSl7EzuJpndQGbfcGxbrVvyfdolhkpVsE52XTlJdV21D95NcosEWiSZ/8vJrJotzX9YsrmqjK553AKvnbeaVkEyzOC6mpPMzN4UUjmexqwriW9l+JyTBNwCw0YmwOv55GZuhT5Xb5msV6qXVKvSMsl7C/KXVdKOz2sIFXrcLbZOiWWpkTg2rlmJdGr0CnbI8Nb1h0hLb8T9jzodkZhXUdh5wy5KyV/XTpf3XDtTdsi9SJf5PF8nTEHbSnVHLab1LlZvqGUVlOXCm5J7/OfIFM9eGe7ATafg2iPebJmhmExyJw9PuFytpMxUL1aj7RQsu0qVZ+MZr5zzy6a8Miq/zFJ1qdS1RfLw1UKp8tFnRmJYePhp6uS6Uk4FZWm9yO9AjvPxzqkqDUqpczlz9FwuFOgpLK8ns7nJa/plfjVUWm94z0nXtadUMCh19tlnoxmcd9578cILL+KnP70Ol1xyMRYu3EMFqG6++VbVa/bUU0/KrrtmzfMqobk4/fSl2GuvPRu4581Jen1IrhwZqiQ9pKSsmLXHgYh2tWdvEKJyRLv61O9g08trVG9RmUFTfift2ktKMCg1DqloJKGhXPno6emu6vSs5U6dOpIZ8pAvmUxgeHAXNGMERiDS7LdF5ARGeku9/uKT485ckQgM+SsmaZUfJbCtBGANwk4PwzEMrzESCDYZjg3ddZDc/AzS5miDJJ1Jhpuvu8BnEMlrT6QLPK+YYHtNGkUhc9gLSBUaHiKBIcdCT+I5uKkqBaWyr5kq/JpGGlFYmJFYC9eqLBeN7GvhxpZPLxh8qyezxLmw6Qd9Kjhf9p+TL/jRpousI+JFRgWl3BTckS0wJU9OZty7njnMNGmzOg4SyUFs+uvjMDO/sWgFvSuieUMUY2UO0ZHX3bTxdTyVSRYpMwvWYnpWqk/dUYtpvYvVG+r1SiwrZGfcKav8l6HjctNSLox0Et3aMEwtjT4MwjGATOdCjwSlnBR6hp+SsWnjllPjl5ky6+b45XR2O5oEUgpsR5ftOEW3U6hcKlb+lGO8cs7fdv5bHlOeSUBqcCPiG+o3xXap8lHtkm0jbQ1i+8tPwAhVPnvWQBMO4Q4bLnZsWY8XntGq9jmnJLfI8ICakdg/lxsOfL9yLie9pdY882dEItWbhazSeqPedccBBxyA9773vepcWYauTMaFF16I004b7cE0GdJT4fLLL8NNN92KH/3oagwMDGL69Gl417uW48wzl8MwRn+sMgvrrFkzVR0wf/68gtt7/vkX8fWvf6dgTinpXdUJE2VI8mb5jmXInvQQYUCKCJg+d6Hqabx4to2pU6e2dUBKMCg1zhWh66//LebOnY33v/89VZ+etdypU7cPFQ4wDAzuwuZNm6CHYggHgk5+gEmmm0zER7D7fkci1lP6QB4IJEefzDq+VHIEu3btQjoZVxeCLbhIB3syaYARiSE670iYgSuoTtJFqkCDaXhk7GsnrIkHzZKBIJxmDSC2YzMco6tw48hOqdmY4tGD4IaqUyD4r1m8d1YKmmFhW3QxnPDU8rebHkH0zVXjDkVMzD65ITmyiuXLyFmWaYhEK4ibxYpszyxz9r1YpPCysDOE7Vs3IRTpgh7yGqjhzGvJfspvLJUYwexFRyDW7R0bfbHyGypTu3LXnZb3/2LkarkcwUcctQSGaWJaj16T6VmpPnVHLab1LlZvqGUFytNSXnsrXVb5P5R0MJRwMTTowE4MYnjrG4hpSQxgGtLQ4Be7mpOGObgOup2AJUH3AmVgfjk1fplpqZn9xiunVRk5sBOazHBXhHrt2GEFy8hCZZdfZk3EeOWcX7bll1/5/1c9pWT9+UepIXP1UKp8FGkriXRiBFP3PByRWOV1ZyVlab30hB284gIHHHZMzsXAyRgaHMCbmzchFuvKnssFh++lkgk1dOPgw45CX28/qqXSeqPedYdcrL3pppuqsq0999xT3apFAlMyuUVwgotCpFz/3ve+UXKdUjmmOokEpXqmRFTvcyLyRLp6MWtWWOUVbHdtFZTyEwSW67jj3o5PfvLjRZf/4hf/rRIXfvWrX0AkEqnJ9KzlTJ1qmIUbA3JCJHmH5Gqd9JbwaZnhe+pxTYNuGOOePOmlZjqrYB2fXOVYdOTfZIcSSENlOJkbNJIrq5IUN/cxSfhRILgkUzeNeSx3PTfv/6XkrKsuQWuZW6GTNG+ZSiherUS7ekQlMZfgkVZwGICrGl6urFfRa7pqSnNXC5cYipiUrVfvvUyAG0gOOoa/rNQ6+Qrlhsl7XCu2TollmvSkkP1QvyXv2PATm2Z/e5nfmD8u3jDKP9HPX9eooHuYlB0SkJKbWUm3sgqmZ+0Uja47ajGtd7F6Qy2roCwX0gmmnPJf051MGS5T7QXKVfnt5Axxk+Fxabia7l0M0MPjl1PjlpnexBDjlZluqBfxOacCbolhSJpZNGhfsOyqpKyq9Ll+2ZRXRhUqs7xzAbNuQalS5aO/P7JcZleaSN4QvYKytF7kdyDnW3JOVa2glPSsyT+XU3nPMuQxWa5es4pld6X1hvcc1h1ERFR9bVW7nHDCEgwNld+1eNGi4ldNpFvu448/iS9+8TOYM2d2lfawswSTm6Z0B6lCwaYiJEluMHmqm8xrEKkGT+sme5MGjyT4LdYwknwmPYnnJ9ybSQWkCkybLt+AZrf2tOlE1ca6o1F0LyCVV1YVKqfGKzPHCyZJD6mJPpeIiIiIaqetglLnnntWVbbz+9/fgT/8YaVqVEgCw2bn5xzJ/j8w+14rkoDU0Ev3wpW8VBl2Xs4rzYwC85YCedNnt5KSDSDXhptqbN4nok7RqXVHq5lo0EjNsLr5vrrOsEo0mXM5mQEy+3iqNc/liIiIOjIoVQ233HKHmgkpv1EhSWsl78e+++6NZmEahhpjunNwBOn06FVlSTTrk7HZrTbdpsqNYSWgyX77OZ6Cw+3sFFzJBzKJWemCeUE0R4PkFDUk81WhkYOw1AiUiKHVbYpwmeFJetbLfpYc6pb/vMx7USMACvXMd72RkPV8L0SdoJXqjrpSs9ilADtwwiE582RGVU33En3rtS2nNMeG6SQAo3g+KjgJRHSb5SLVnQzfi0ZjSCTi2XM5x8qbBCMWU+d8RERE7ai1ohU1dsstK3D77XfjS18ae5X70Ucfx8yZM5qqYdHV3YOly87AtsHcYQ67AglpJSAVjbVobyIjDD0zM58WmLlP/VXFaa9dXYZtxKClZXrywkPbZLms1zTSIypZcD7NGlKzWqnPp8DwPZoYOz16pTqduYIto1HtQDCYOler1R31IDkDNSMG2EOZ8iqwUHJGwYErQ/f8Gcyk3JJAlbBT3jpSnmWo8neSvZhKDmsuUvbTxMpH9XiL9taut1hXD5ac/A7Y9uiFtil5k15IQErO+YiIiNpRE7WyG+u22+7EDTf8DrvvPh+33/6HMcvXrXtZNSyajZyk9CA335JVYRLbjmd2ITVvacEgTzUbRJUEmCSnFOwktNQAXGlEBV87PYLwG/epINoYjgVjZKMaimL37V1wVisqn0rGH44hnYrD8XPcpLWc0lP1RmymgCXVVavWHbVgJYZhxdOwE14dFNrtKGg71sKJ7gcrrcOVXICSrFyCTZtWeUPlpIyScmvwldGLDa6tEqHLOn4ZJhcGpJyuWTlM1S0fM0KRWN0Sr7d6YCqor7v5krwTERHVCs8UMu699wF1//rrG9SNOozZ5fXAqreiASYXhjmMkEyBngma+Y0xCWCp9dXsfHlBJ+lhIGNh5F6GOOYFKNkboDKhaDfmH7IsJ+l+T9RrdPVE/VmSTERatTciTRrrDk8qMYwNz96DRHwECT8+4TgwMAR9x3aEnEBgKdSjyi/5Jbl20iuv5F7N1iZDlGTePVPNpic9ZtVsfKona7ox5TRVXD76JCAVnPSEiIiIKB+DUhk/+ME3G70L1IGKB5hkWvWU13Ar0hgrOBRF0+FKI05Nmx4vONtU0w1FbIGGV1AkE4yKxXglm1h3+FwnrXrM6EYImuaVZZrkN3SSQKhLsjiPlmX5Q6Yl6ORKGSflkgQ1JMmf9BCNemUjA+otVz4SERERlYstU6ImMDbAJD2cDPV4qWGFY+gh2N0L1GxT1tyT4UqPhHoORSSijqZJLkDJFaVCSw5gmYAWhqsHAkt5Q6azw/kyPaO8B3UOPyYiIiLqAAxKUfOyU9lsWa6dO/teIdFQC86a5GrQdekVkLkFH5cZ+OQxR0NE3pv//oo9J0sadWloXb1AuK9ub4WIqJgxZVko0MMmpUE3w5KAqMgEDQXKwUr4ZabMpKp6YuWzAH0S2ycioooMDAxgZGQEXV1d6OvjuSpRp/92GJSi5py1KRSFayVkWh/vQRkGElxHhnWo3CNEREQlSF0hdYbk2SvW85R1ChFRXaxbtw5r165FIpFANBrF4sWLMW/evEbvFlFL/nYWLVqEdsCgFDUdPdyNnr1Py0meao3kzSgosziBQ9CIiGgcoW4485eqWf2KkoBUsPcWERHVpJeHNKodx0F/fz+GhoawevVqhEIhDA9pSKUKj4ag9uHYNlKpBIYGB6AbvBhUipVKIJHwUrEMDg6q34rrupg+fbr67chvaebMmW3RY4pBKWrawFSQZucFpYTV4fMwFRnGWPRxIqJOLdMYcCIiajgZdiS9PCQg9eauNHSjC8M7d+B/N6cwvVca1h1+bt8BHNvFWwbQF3GhG/y+S4pE8NdtOjTNwsCOQWzdmUC0uxd9joPe3l5s27ZN/aYYlCKi6hjT6JJCOl24McahKETUpFzJBeh4J5muDLuWGUDdFGCXmD2PZRoRUUeQPDgy7Eh6eUhAKpVIIBztQk/fVMS6W79hTeOz7TTCkSi6+6bAMBiKKFd37xT1W7FSSThOWAWj5Lckv6l2wCOBqJGKNsZcwJCp0tOAGcttjHEoChE1GU03YYZjSMRH4FpeAMp1pIerBaRHvATjxQJLLNOIiDqC9OiQPDgyDEl6SEkje7e9DmBAimgc8huR38r6l9Zg+/bt6O7uVr+lduglJRiUIrKGG9cYKtYYc224Q2vg9BwsYxnHvj4bZ0TURMLRbsw/ZBmG4mlsG/KGW8dTaWhvrYbTdbBXjpYqS8sp0xpZVhMRUVVIYmYZerTmtUHV+4MBKaLyzN5tL0S7erBHfxpTp05tm4CUYFCKOps1DH3DfV5PpWLMqBc4qmFgagxpeMnU6OE+DlkhopYQinYjBBdG2gtK6bCgVasca4aymoiIqkKCUn1TowhHYo3eFaKWEuvqxaxZIcRi7fXbYVCKOpsEf6SRo5uAER67XHI6yfJSV+eJiKi2WFYTERERtSUGpYiENHLkin4hxRLvEhFRfbGsJiIiImorDEpR+2C+ESKi9izLrSHAsTIzkuqAEWrU3hERERFRFTEoRS0rGtKyf7vWMJw37oNbIt+IZkah73EqtEBgynU02LrXxtHkPo8rM5vrQMjUoAVer+ZcwNTlPcqO1/F1iYiqrJJyrGhZLgGp4Y2Abng9pfr3ghYITDWsrCYiIiKiSWFQitqDY3uNmBL5RtRyh/lGiIhariyXHlISkJKrB2qYnpdMnYiIiIhaG4NS1F6MsDfbUx65iM58I0RErVuWu1omKOUyIEVERETULhiUIvJ7UhV5nIiImoTq7eqMLbNZVhMRERG1JAalqCXExskR4jgakiovlAbNGLuu62pwdSAS0qAHc1HBRDIcg5uOA3bhnlRaOIZIxKxvnhJHg2loiJkaoJf/upKPxS0xRFHTjZycWkREk5VKSLmTRirhwkq6sBNeTyYnlUbITSGKOLRQX1nbKlaWu9BhGyE4MrTPtWHYcWhIN76sJiIiIqJJYVCKOpoEaCJ7ndoWgRwJSCVfXukF2IrQzJh6v63wfoioNQJSLz91N6xkHJbtIm27SFjesrTjwNSGkNy1E5FFp02q3NGMMIypC6Gnk3CtEYQXngI93NuSZTURERERjWJQijqeNGLa4bq6BNZUQMoIQdPHJnt3HUn2HlfrtcP7JaLGkx5SEpDSjRBCZghu2oWmeQPrtLQLOHG4dnXKHQlMqWn2HEsFpPRIeb2viIiIiKh5MShFbUUCL3kjOkYf7xASkNLMscne5XNx7UwXBiKiKjJCYWhaGIbmQpfAkZRFkvvJMia0PZblRERERJ2BQakOlYgPwwnkUIpncoD4dN1EJNY6wyDUsA3Tyw1VLPAiy2U9IiJqTizL6yedHD8HoRlpnfMAImo+AwMDGBkZQVdXF/r62LuVqJoG2uj3xaBUhwaknn74TqSSo7mHUnbu3HPhSAwHHL28ZQJT7ZQbioioU7Esr19Aasvz98BOFc9BaIRjmHXgMgamiGhC1q1bh7Vr1yKRSCAajWLx4sVYtGhRo3eLqC2sa7PfF4NSHUh6SElAyjRDMEOZ3EOS+yPDTltqueMUno2uWbVLbigiok7Gsrz2JOgnASnJBaZydeUvt1NqeangIBFRqR4c0mB2HAf9/f0YGhrC6tWr0dvbq27SkB4cHEYoySHZncaxbSSTSQwODEA32Ou5UlYqga1bHfV7cl0X06dPV78v+b3NnDmzZXtMMSjVwSQgFQpH1d+2nttTyk6zkiAiImpnalbD0NgchCoUxRyERDRBMqRIAk8SkNoxnIZhdmFg5w6s2zSEqakYXNfA9D4pe3LbH9T+bNtFxHTRG3VhGPz+KxaNYMP2AewYTKCrp1cFfiXQu23bNvW7Y1CKiJoCEwQTUb3ZVgqO5sJOu3AyPW9lJj647GlDRNRpJMeNDCmSHhwSkErKEKNYF3r7pyASjal15P/UeWw7rY6Bvv4pMAyGIibCMAz1+7GSSThOWAWj5Pcmv7tWpTd6B4iougmC5eq2aw2PucnjTBBMRNWk6SZCkRgc24KVHIadGoabGvFu6WEVlNIMljtERJ1EemtIjhtN01QPKbnfc+8D0d3Tmr04iJpJd0+f+j1JroPt27er35f83lq1l5RgeJKoTTBBMBHVWzjajb2OOB2uk8ZQwsVw0sW2IW8213gqDWPHs4hMP5zlDhFRh5GkyzKsSIbsSQ8pBqSIqmfe7nsh1t2D6VELU6dObemAlGBQiqiNMEEwETUiMCVSuoOU7sJIe0EpHdI7MwLNbN3u5ERENHESlJIcUv6QPSKqnq7uXsyabiIWa/3fF4NSHSxtjeYYsvJm3yMiIqL2pmbZK/I4ERERUT0wKNWBdMNEOBJDKhlHOhOAStm5sx/Icl3n4UHNQeXF4rBEImqAdix/ZJ+NcAx2Kl50lj1ZzlxgREREVGuMOnSgaKwbhx//Djj26BRtAwlvuIVPAlKRWGudZFP7NgiTL6+Em44XXUcSuEs+rVZrGBJRc2vX8seMdGPWgcvGDbbJekRERES1xKBUBwemgiwjNyhF1Cy9BeQ1VYPQCEHTwwWWp9RyWY/5tIhaXzP1TGrn8ocBJyIiImoGDEoRUUv0FpAGoSRNHiMt+U+YB42oHTRDWVPwNVn+EBEREdUEg1JE1NG9BYioebCsIaJmNzISx0033YonnngKAwMDmD59Go4/fgnOPHM5TLO8ptXzz7+Ihx76I/7yl79i+/YdME0D8+bNxXHHHYNly06GYTCfGxF1DgalqCV0hTus+eFo0AzAlPetN/69244GW9eghcLQC/QWcKS3gJtGLKTBqPJ3lX1tQ5L0j13uuNJTQavJaxPR5MrtSsuxRpY1JfeH5Q8RZQJSV1zxLQwPD+OSSy7GwoV7YPXq53DVVdfgr39dh89+9hLoul5yGw8//Bj+679+hj333B2f+MTfYo89FmBgYBC33nonfvnL/8HTTz+Lz3/+UwxMEVHHKF1qEhEREREREW688XfYsGEjPv7xC7DffvsgHA7jbW87Amef/W4VnFq58oFxt2FZlupR9ZnP/IPaRjQaxaxZMzPb3BvPPfc8Hnro0bq8HyKiZsCeUtR0unm1Ga6jIW1oqoeB1gQ9pdKOhoTqKaCpWz7H1eAYXs8I1SuiTV6biCZehk+kHGu233uz7Q8RNU48nsD99z+MKVP6ceihB+UsO/HEY3H99b/FnXfei2XLTim5nd7eXhxzzFFq2F++ww47BC+++BKee+4FnHzy8VV/D0REzYhBKSJqCW46BafI40REtcTyh4jWrv2L6uW0994LoWm5Qeje3h7MmTMbmzZtVre5c+cU3c5RRx2mboVIrymPW9V9JyJqZgxKEVFTk+nf9VAMjhWHmyo8y5Usl/WIiKqJ5Q8R+dav36DuZ8yYUXD5zJnTVUBq/fqNJYNSpWze/Ka633//fcddd8WKu7FixT0Fl6VSSXWfTqfVrR7kdRzHyXk9+du2vRuRkGNBjhMeE5Nn2/L79n5nzarcfWNQiqjN2alhNVNVMdKYMsLdTdtbQPZt6n6nVe09EFHzlk12chCObcFNDsG1U9CMcEN7JrH8ISLfrl0D6r67u6vg8q6urpz1JtJ4e/zxJzF16hSccMKSsoYT7tixs+Ayy/LKykcffRTd3fUpnyTQ8Prrr6u//WTv0rNsV9yBYYbqsg/U/FzHwZZN67H2Kak/md56Muy0hTdiOkKh5v19yaQQ5WBQiqgJgj213McdL96rrvIXI1f5pdFVal8b3Vug0Z8jUSsbGR5C2h4tq4ZGckPLMsNTrKunKcom104jNbBJla1SnkT65kEzzIb2TGL5Q0QilfICPcVmxTNNI2e9St12213YuXMXPv/5SxGJjJ19NF8sFlUBrFI9pZYsWYK+vj7Us0fEscceqxK5i3g8jte3pxGJxuqyD9QavXvcp4DFRxwDI69+p8okE3HsPs1ELNa8v6+BgfKC9DwSiBoY7Kk1adjJPmp6CJoZLtzzSQJNJYJr9ewtUE6gTzR7MJComQJS992zQjUMfMl0bq6SaDSGJSe/o66BqVJlUzTcBddKwnXTmLLvKTAivU33Gy9VVtmpEXVvhAv3pmiG/SeiyslMe8IOBPmD0mk7Z71KPP/8i/j97+/A//k/78chhywu6zlnnHG6uhVrCF599Q9VcMgPENWD9JAKvqbcSwyPwQfKP07kmOBxMTmGYdb9N16pcveted8BUROrVrCnXmQfdXPsVTfpL1Gs51O+Wjeiygn0QTchqUVdJ93UwUCiZiE9pCQgJV27Q5mGkp5yc4Z4JBLxoo2sRpRN8n/HCMFJDauAlBmtz1X+apRV0tMrOfCG+rtQLy/BMoqoNfX3e2XR8LAXeM43MjKSs165XnttPb73vf8P7373O7B8+WlV2FMiotbCoFQJv/rVb9TUrgccsC++/OXPNXp3qAlVI9hD5Qf6bCvTAyHU1RLBQOpMzVh3SEAqEvFmdXK03J5S6TTLqmqVVU46Cbje56uFomPqB5ZRRK1rwYL56n7r1m0Fl2/d+lZmvd3K3ubrr2/AN75xJZYvPxXnnPPuKu0pEVFrYVCqiHXrXsEf/nBfo3ej43RHcqfYbVaWo2FABwy5FUgtYDuArQNdYQ2hCbwn19EQN4BYRIOma027n9WU3ddwGEZobKBP9tNKj0C6SoVKrGOnrKZ4P9SZWHeMluOlyrFWKpsqKatsA0hlErdGwpGxy2tURvmfNRHVzuLF+yMUMlU577ouNG30Nzw4OKRmzps9e2bZM+95AanvYtmyk3MCUm+9tR2rVz+HpUtPrMn7ICJqNkx5X4AMY/jpT6/DXnvt2ehdISKiFsG6g4iofUli8ZNOOl4lI5egUdCDD/5RBaqCw+9GRuL4j//4T1x11TVqZrpCAanTTjsZ5557Vs6yN9/ciltuWYF6kzxUmzdvLjsxMRF1loEalhHsKVXA7bffhWQyifPOO1tVJjR5vVEdvd7IkbaQDOvYFdYRiuowQ2Nju2lDhwUds/t1RLoqv3zt2C62btUxs9+AXmSWl2bYz2oqZ18TaU3llIq0wPuhztPpdUd+OV+qHGulsilfqX23Lemx5PWe6C6wvFbvq1p1BhGVdt5578ULL7yoLkBccsnFWLhwDxWguvnmW3HwwQfi1FNPyq67Zs3zeOaZNerv009fmr1gsX79RhWQsqw0Nm16Ez/84U9yXqMRQaF169Zh7dq1SCQSiEajWLx4MRYtWlT3/SCi5lTrMoJBqTybNm3G73+/Av/8z/+oZgYgage2larocSKqDOuOiWHZREStpKurC5dffhluuulW/OhHV2NgYBDTp0/Du961HGeeuRxGICi8776LMGvWTPT0dGP+/HnZxx9//Ek13E889tgTBV9nxozpqBcJgkljU3pz9ff3Y2hoCKtXr0Zvb6+6lSudTsOyLDW5hj/jljRgBwaGEU4ma/gOqNV6lScTCezatSvn90KVSyUTSHTXftKUwcFBVSZIb9Dp06erMkLKjJkzZ6KvrzqT0TAoFSAf9M9+9kscc8xROOigA9T0rJVaseJurFhxT8FlqVQyW2j7N6kA5L4UO+2UXi7JN0r8vxxOGc8pZ51O4UiSWtdFOiXTlo/9XGzLUstlPcdOV759Ow3XcSb03CAXGsxwFOlkHE66cCPPjMTUepN9rWp9pvJ5FvpM1WOZBMLjrTPRz72i/ZXkMAXYRR4vZ107Xd5z7UzZIfciXebzfOOVOVTfuqOSeqNcfr1hS1niukglk6pMEUkrOPuepZbLSaKsW4j8liZS/pcqx1qpbKqkrAr+v+jyGpRR1aozmkmxMraR5Hcgn3Ox30q1lFsXTEal9Yb3nPY5viYbmDr//A+oWylTp07B9773jTGPS/6oZkpqLrMGSvBIAlIjSRtmpBs7d+7A5u3DsPTyG7zS/ohbLnaMODAMr+xz3RBm9MVquPfUamxbQ8QE+iIajEzPYpqgSAzD6RBGhmvbRn9r+zAGR5IqSC3tD7nftm2bKjsYlKqB++9/CBs3bsKnP/3JCW8jHk9gx46dBZfJ1Nvi0UcfRXd3t/pSX3/9dfVYqSvrI4Hpuwu+Zt7yRKDBUa5EevznBBsync5Op6A7cTjWINKJwuvohokdr62GUWCWuPFIw2VkxwZsexnQtMmdnPZPmQq4/cVX0HTsWu91L28k20oA1iDs9DCcAldOXNuGbnuzhNlDVtF14DrY8erTMEK1HS86ECpckUbN8ivYaN42YuHyniuNok0bX8dT6uvTVdLkSgwPD1e0PtW27qik3iiXX29YqRSSiREMD47OsJd/nUOuaK97/imYocJl1c64M6Hyf7xyrFXKpkrKKtdOq5Nttd7Q1gLLa1NGVbPOaBbFythGChsudmxZjxee0Wr6OZdbF0xGpfWGYN3RvkE2GY4jvR8kICUBqlisC/39UxGNlh9QkgtlphlCNBKDkekpJWRbRMHjJBKNob9/Ss5xQs1LygL5HUvZ0B0NqWCUlBlSdlQLj4QMaRBcf/1N+NjHPqy62U4mCaJcGSl1xXvJkiUqquhfcTr22GOz3VwL2T5UOvq5fSR3uVyhqNRA3KnKOp1k2sIj4TrFrxpquolwZGI/Vrnavc0FZuz1NhXc6gSp5Ijqyis9Jwo2f01Az7T2pOFXbB3pXTFtr7dN+LMvV19Mr+jxQqZ25a47Le//pSp0ef9HHLVEVejTeiprHDGJaXPVHZXUG+UK1huHHvE2pCUYkrFzJPfXYxg6Yl09Rbf12lvpCZX/7VqOlSqrHM3KBvDCWgS6ZtaljGrHz7qSsrReesIOXnGBAw47BkYNP+dy64JJvUaF9YZg3dGepG6R/DAyPEd6SEnjc5/9DkRPb3V6QBBRa+vp7VNlwl+efxbbt29XF0mlzKhWLynRHmcuGZdeehm2bXur7PWPO+7t+OQnP67+vvba69XY7yVLjp7UPpxxxunqVqwyv/rqH6oAlB+Ekh5Swf8XYpilGwN+F9li/y+HXsZzylmnk0S7altZSw8YaVy0SwOjnM9z0ZF/M26gT4wbDIzWfny1LnPZFyAN/HLlr2uY5T9Xyg4JSMnNrOB5olR504kaXXdUWm+UI1hv9PblBrzccGVluW5MvPxvx3JsvLIqlYhD01yEigSdalVGtdtnXayMbST5HcjnLAGpWgalKqkLJqrSesN7TnscWzSWJCyWITkyZE96RTAgRURBu++5CN09vYhoSUydOrWqASnRVrXLCScswdBQ+V2LFy3yZsH485+fxpo1a/Gtb11Rw70jovHUI5hElI91B1WzrIp0lRiSSETUpCQoJTmkKhmyR0Sdo7unF9O6+xGLVb+MaKug1LnnnjWh50nDIpFIqqvlhbzwwv/iwx++SP199tlnNlVyQqJ2lEoMN0VvKOoMrDuoXCybiIiIiKqrrYJSE/WJT3xM3fLJDEpf//p3cMAB++LLX/5cQ/aNqBMbfS8/dTesZLzoOqFIDHsdcTobf9RQrDs6C8smIiIioupjUIqImor0QpBGn26EYBSYDcy2Ump5qd4KRETVxrKJiIiIqPoYlCKipiSNPjMUKbjMsUentyciqieWTURERETVw6BUAVdddQ0eeujRgnlBfv3rqxu4Z1QPzBlCRBPBuqM4lqtEREREVAiDUhXkCel0fbHmm5652pLxYbz87N1IlcgZEo7EcMDRyxGJ1a4B5dg6BkKa+sybcVrsWoo7OkImEDaBUEgbs1x3vZKrJ6oj1gHHJLWOdq47JlL+++VYBAm8+uw9DS9X27ls6uQ6g4iIiFobg1JEAY6TVg0nwwzDMENjlttpSy2X9YiIaHwsV4mIiIioGAaliAqQhlMoHC24zE6n6r4/REStjuUqEREREeVjUIqImpL0nqjkcSKiemDZRERERFQ9DEqR0s/cPErI1hE2NERNDSFzbM4Qw9EAQ0NfVEdXDT8z29bVPkh+EKPD8oNEEEZPV5eXf8ayYNtpuI6Ts040EkPETajvSzdMRJs4Dw1Rp9YP2XIs2hzlalAiPgzHLj5csFC5kl825TMAxLq6MKU7jGid69ROrjPqybZz6yIiIiKaPAaliKipSEPw8OPfoRqMycQI1jx+H6xkImcdK5XAs3+6N5sgWdZnYIqIyg1IPf3wneMmXs8vV4JlUzEMkhMRERFVhkEpImo6wUad9JKS/5uh8Jj10lbKS5BcopFIRBQk5YWUG6YZqrhcYcCJiIiIqLoYlCIqQBollTxOtSUNx2IJktPM40LUEpqtXGW5QkRERNR4DEoR5Q29kGEbcpW8WKNElst6REQ0Pt0wWK4SERERUUE8A2xDU7uY5HTCunoxZdkZsG276CqGYSDW1VP7pLUhTX2XnZy0ViWeNzVETA3h0NgEybqjwTE1lYi5h8c9UVPVKX45Nmd6L6Y1QbnazuUK64z6fs5ERERUPQxKEeWpV8OoU8VHhpqmcUpE9dFMv2lJdC5DBi3TBArEFzh0j4iIiKh+GJQioroGpB5ddScSieKzXkWjMSw5+R1N1YglovYpg57843148431MAxTDS3Mp2nAtBmzG7J/RERERJ2GQSkiqhvpISUBKZn1KlRg1ivLSqnl+T2p5PFCij1ORFS0DEomoGkadF2Hrud2lbJtB2krDdd1G7aPRERERJ2EQSkiqjsJSIUj4896JUP5pOeUBKqKDamR5bIeEVE5JCAVCkdU4MlxcoNPruPAdR2VeJ3lChEREVHtMShFRE1LhvDJUD7moCKiapGemvPmL4QZCo1ZZqWSiCdGcNSxS1muEBEREdUBg1JtYFo3Z9ppN3ZaRyysYZrMpGS2z/dr2rqa8Soa1hAJF5j1ytXgWBqmdOno84/r7r767yhRG6tXndGM5ZhfBnV1hxEp0FszmdRgaDbmTO8ZLYNaQDN+1u2InzMREVH1sUYlIiIiIiIiIqK6Y1CKiIiIiIiIiIjqjsP3iKjurFSqoseJiKqJZRARERFRc2BQiojqxpSk5LEY4vE4LKvwbHqyXNYjIqo2lkFEREREzYVBKSKqm67uHixddgbSJWbTk8agrEdEVG0sg4iIiIiaC4NSRFRXbOwRUSOxDCIiIiJqHkx0TkREREREREREdcegFBERERERERER1R2DUkREREREREREVHcMShERERERERERUd0xKEVERERERERERHXHoBQREREREREREdUdg1JERERERERERFR3DEoREREREREREVHdMShFRERERERERER1x6AUERERERERERHVnVn/lyQiIiIiImo9IyNx3HTTrXjiiacwMDCA6dOn4fjjl+DMM5fDNMtvWqXTadxyywo88sifsH37dvT19eHtbz8K55xzJqLRaE3fAxFRM2FQiqpqZHgIadsuutw0DHR199R1n4iIiNq53k2mkkgmExgY3AXDyD21Y71LVN2A1BVXfAvDw8O45JKLsXDhHli9+jlcddU1+Otf1+Gzn70Euq6XFZD69rf/Ey+//Co++ckLcdBBB2Ddulfwox9djeef/wu+8pXPIxqN1OH9jMDOnLcnEgmMjDiw0+nsct0wEIt1VbTNeGIEGrQxjycScTi2A93QEY3Gsv8ffS3vc/Mf89cLCu7Pjh1vYXhwAIn4CJwCTQ8zZCIaiyGSCfAFXyv4mvIaKSuFcCg8Zl+L7ZtlpRAKrJ+/v/5+xuMjqoz2nyfltP93KpUA4MKy07BTNlzHgSbHjuYgmUgBmouwGYEeMtDfP1U9Nz48opan0zYMzch5fSNkoE/WSyWguRrCkYh6rVQqjkQ8qbYv71MzNPR09SFtp2AaYaTtJABN/W05KQwPDiKdspB20jB1E5qmI5VMqvXhaojGIojFepCS52smLLnXTUydPgPhcDT7WcjvwHFsDA4NwrZSav9HhoeRTqXx5psbMbBjJyLRCFzXQTgSQzgSUp9ZyrKw/tWXkUolYVmWfETQDQ3IfB2aaaC/byrmL9hTvZfurl4MjwzCTlsYGhqEk3aQSA7DtTW1XD4nPVMPmqZ8Lz0wQwZ6+6Zkv8dkUr5vF1Y6hZA5+r3K+4hEotnvNvi9Onnt3eAxI9t1HCfnGJJ9NDSvftYNQNcNmIHXMkMm+qdMHfM7KbTtco69agm+V/kOw66uyi+fIZ9t1+Rfj0EpqhopdO+7ZwXi8XjRdWKxGJYuO4MnyERERFWqd6VhOTy4C5s3bYKm5TYGWe8SVc+NN/4OGzZsxOc+9ynst98+6rG3ve0IbNmyDf/93zdi5coHsGzZKeNu5w9/uA9r176Aj370QzjiiEPVYwccsB8+8pEP4gc/uAo333wbPvShc2v6XqTcePDBB1UwSkhDM5l2cwLb0iB/25ITym7kpi0Lf37sEdVwDpJA17atb6oghTTGJYCx461t6v+jNEjx5bqu+p+sN2PW7IL7I430FbfcgKGBXWq/vWfkkpJQnhvr6lIBEn+7Qd6+TMfAzl3qXta37TS2bfH2NbstTYP3dBeO6yKVSKigTzAAqfZ35mwYpqn28+DDj8LTTzyKNza8rrYlQQpp1Mt+yE0a+oX2qRB/v8pbz1afowQn5FOQYE29yHsP1kHy/oJBziA5HibqzTc24H//skb9Le8zP0A0Hgm0yXEhx2soHFZBN8f1gkiyPf8tyHuR79I0Q+pY7OrqUd/rmqf/rL5LX/CYcRwXyUQcbuColICgF/zVvAMzc3x6r+U9oGs65uw2HwM7d2Z/J/Ka6rMKbDuVLHLsZX4rlf5mxwtIPfHoQ9n3Ku8zYmo5PUKlV+eJJ5446cAUg1JUNdJDSgJSoVBI/cDzWamUWl6qJxURERFNrN6Vk0J1pT2D9S5R9cTjCdx//8OYMqUfhx56UM6yE088Ftdf/1vceee94walpKF+1133qh4GMuwv6MgjD0NPTzdWrlyFc889C+FwCLUijWQJSEkDU8oQCe5olqsCC0Ia7F7PnvLLD+n1onpThMMwQ6P7LkEqaXzLexbSG0Xa4tLYV0EFabSr4IULU3qBqMCNg0gk4v0/b3+kJ4+Ub15MR4MuGwvG411vX1Twx3EhxaJsJ9iQ94JCDnTosKwkDN1QPavSal/z981SjxlGyHuPsp+mmd03WUcCD+FoRPUSk/2UfUwmvCCU/55SqRR03dvRlOr5Ul5QKhslKWs9CYfIZ6Kr+sCx02ODX170LxMacfMemyBNghWhnM+2zL2elEK98sZ9hvouDXVcyvGuW5bqXSb7Lb2LNd0LQqrvTgXaoI6P7Pea9H43/jEePGYkuJVIuOp4l2CRPC6/NS9YKK8t2/Y+ZwkiyfHgON7xbhpmzu9Ejn+1x4FtJ5NyPIXGfNbeut6xV2mQrhjZTvC9ym80GhoNSklPNilD/N6Wk8GgFFWdnBhLlLYQ1Q2TiIiIqkYalHJyG5ZhBnlDh1jvElXH2rV/Ub+nvfdeOKZHYm9vD+bMmY1Nmzar29y5c4pu5/XXN2D79h3YY48FiMVyz5elMbrXXnvi2WfX4i9/+V8ccshi1KP8kAatlB22Jo3w0WBScJhOJaQBGw7nDj+U7UuQRII38ppq+JIquwzVqHVVzyRdLVOvLb1YQmGEAtvJ3x+/B5Qq9wJfiRck8gJVskxeyysnR4e8yWvKaxghMzt8SvZZ9WAZs29eAEnaOCq4IMPdQmEVfAtuyx9WFdxPeX3/PRmZz0COH1lfYhOyr4oELDJBS58fwJCgmxMIZmSWZgNcXgDFUet5/XFkma6CarYaRud4oSc/GKJ770uGffkBDO+xiX3f6n1qugpW+D3BXEd2asKbK/91DR2VxEQk4CSfkHy36ns0TFhyHMmjae8zk2V+oFG+Z+/eVMMmCx3jwWPGPz6kN5Zsx6uTNVhIecMaNdlf2Y70SvRey5agVdoLNuX+TrzjKX/b8hstdOy5k/jNluK/17SuIxzSssczqvh6DEoRERERERGVsH79BnU/Y8aMgstnzpyuAlLr128sGZSS5f76hcyYMT27Xqmg1IoVd2PFinsKLpN8PH6DsVijUR5XeW8CNytlZYMk0hNJeoCMjAzn9kIqQgIa0hNI8gdZqdweXrIt27GhZXpASQ8V9X/bC6KrRnnmdf1eF7JctufHNYL7E48Pe/usekPJvaRgCgwbk54ncpPhdo5sWxvTm8N7Ta/Xlbx2KmXBDCVH9zVn3zL7lOnxIq/r/x1cR56rPltLeqkOqzxM8ri/njxPc/xgk+x3IGojn03eZ+oHofxeX3lLsx2bRtcbXd97LU29Rv5zZbl6vnxwOY9NnHpNCeSogJST2Xbto1LB91D2+pocF95npIbFqc939D3I9+O9F+97lns5PqTXmfpe5RgPBDiDx4x/fOjOaMDRv5fXdnRvu97/HS/Y6Hj74h2Lo78TOf5F/rYLHXv+upX8Zscj2wm+V+kpFTFCOe9LbuOVM+VgUKoFTO8ZP2FiMzBtHRETiIU0RMNjfwm6VAgmMK1bR3+LvKdGSad1dIU1TOuRqw78rCgXjw9qhXqDx2n96l3pTp8woD5v/8q5YL1bXTymO9uuXQPqvru7cO4UP6eKv17x7ezKbKe74HJ/++NtR4YT7tixs+AyP6fTo48+WvR1kskktmzZ4g3NyfRwyfba8XtgpNNY98LT2V4Zpchzd2zbrHqTxSWpc16vpFRiNOfsrh1b1f/TejLbG8hvvDqZHEj+9vztBPdHXkMay9m8TH5PoAwvCOM17GU9GX4n283PdySvMbDrLaRTSezavgXxIa8nVKl983vQJCU4oZKVj25L9lfI+q+9tBaDO3eobfnvSRr1/j6ofSxzuFzwewnKDzYF82Cpz0aeV+A1Rp8XDEpNLoCkPqfMcZcNTk1ym+XIzUtWDm/YouRmUt9jIp6T90qOFem15++/fM9Cjg/5v3yvAzvfUr+Z4LHpHzP+8eFoLpB2VdApG5SSYJQz2uMtnbagZ/KNua6rjsXg78Q/nvK3Pd6xV+5vdjwS6Mp/rwOZnn7+a8nt8ccfzw41zCeTQpSDQSkiIiIiIqIS/J4IwWBLkMzsFVyv+HascbZjlrUdGfo3deqUkj2llixZgr6+voLrDA4OqgajTIZQqEEpQSvJSXfssceit7cX45HG6f3336+2KYGw4DZlW35OHWlEz507N5uvR24qyXrS22f/efLYggULsv8P7o+8xiuvvJLNZ6OGPAUCTioPVOZxScQsr6HyUwUSNPsN6pkzZ6r7efPmqffp72uxffN7qci6wX3191fIfh511FHqeVu3bs2uJ/vlD7H2e5mUE7iRY6VQkMfflr/MH3Ymn4UfSPDfT/7zgt9H8LGJkuf771OChv62ajGcLMh/z+Xy8zrJcS/vXY5VSfrvB3dUPjTTzH4/8j3LMjk+5D3J9ypBmODvJnjM+MFTeQ1vmKrkLLPUY95Q0tHvzH+tdDqtnjd79mx1vPjfi388BbddzrFX7m92PFJGyHsbr4w4+uiji77ewEDp4LqPQSkiIiIiIqISgjlcCvHzzYzXQ8FPXl58O+mytnPGGaerW7GG4NVX/zAbWClEHvcbyfm56IT/eKltFHtO/jb9oFF2prHA/4M3EbwPbie4PyofUJHn+88tdstfx9+X4H6X2rdSjwf31c8nVGi94N9+UCinB1VgH+X/+evmb8t/3njvO/hahT6PySj2Pmut0tcp9fmUWubnL/O/1/xjs9RnX2j7hV5PL/A7KXefg/tSyW+2lGqUEeXuB4NSVHXFruyMd8WHiIiIKudfhZVeA8ETR9a7RNXT3+/1OBoeHim4XHpbBNcrvp3+ksNa/O2Pt51qKTYZwmQmSch/rso1FQjC+T1ppJGv8uRkeqUEnyv/D5ZhhfanVG8j/7FsvqxA7538x/3tS88Pf1+L7Zv/WHB//HXkuflBEn/d4PaCz8nf30LvIX9opf9YfmAz2JvKX99/L0H+Y/nDNSfDzy0UfO36DN+rLBeWv0/+d+H3PvI/j+B3JI/JdyffqdwH69fg91/omFHJ7PM+j/xhjf66bua184/RbE6pvG2Xe+w1cxmRj0EpqhqJHMt4eqmUi50Iy/Ji3ZWJiIio8npXGrdS78p9/kkp612i6liwYL6637p1W8HlW7e+lVlvt3G24y3fsqXwdrZtK287kyXlggxtk2B2sSFWsryS8sMfLiflUXCb/t/SqJbt+e2EYKPWL7v8xwoNPfP3R3qRyU2GDhXLXZTf06pQA9ofFifbkoa9bM/f12L75g/B8xPFB7cl+ys9Q2Q/ZZty7w/fyg+g+T2bygnclLuuv57/d6GAlL8seJ//90QEc2/Vs6dUpfvtf0b+8E7/eww+7vMDSzIMT9aR+tT/XoO/m+Ax4x8fwc8j+HkHe6v5w/z84yf/d+IPG6302KtWnV+LMqIYBqWoanp6evDOd76zZKRdDlpZj4iIiKpT78rJ6BNPPIG3ve1tY7rKs94lqo7Fi/dHKGRi3bpXchr/YnBwCJs3v4nZs2eWnHlP7L77fJULauPGTSpZueSG8sk59Msvv4poNIL999+3pu9HGtgnnnjiuOftfgL3ckjj/e1vf3vBgIQEfPzGtuSo8f8ffC3hP+avV2h/5HbeeeepYYpyMbxQbxkpCyVfkDSag9vN3568hgTJgsMlx9s3CRDIey20reB+nnrqqRgaGso+Txr3/r7K38GcQH6QJLhM9kleZ8qUKaqclwsPfrAp/zOW9zt16lS1nqwj71teS7Yl78fvTePXCf578INv8rfsh3ymfs8ff6ia34PMz8Uk783PkSTPl9eWWSn9z9ofvijbkO3JOrIf8lnI3xs3blT5kyRPkb+v8rdsV5avW7dOrR8MUPqfm/wt73PhwoXqdeS9+NuVHEiyX36wUvZX1peb5DySezkmZH/lM/U/A/97yf9e/SCr/93632uh303wmAn2qPPJPuYPRQ0ec6FQSL2v/N9JoW2Xc+w1axlRDINSeeTgWbXqYTz44B9VZSEH9tSp/dh7773wN39zKhYtWtjoXWxqPPElok7EuoMaWe/KSbPcZFhQNfJIENFYEjw66aTjce+9q7B69XM47LCDs8uk7JdG8PLlp2UfGxmJ48c/vhq9vT24+OKP5uSHkfWuv/63ePjhR7Fs2SnZ5zz55DMYGhpWuaL83FO1VK3Ga/42C5VD+YmQJ5uIefr06epWC9VIEi38ABqNkvOjhx9+GMcff3zR+koCm82s0HdarWOmt8B2qrXtiajX8cszlwCJPF555Y9Vt9nzz/8A9ttvbzVDxn33PYAbbvg95s/fjQ0LIiLKwbqDiKgznHfee/HCCy/ipz+9DpdccjEWLtxDBahuvvlWHHzwgTj11JOy665Z8zyeeWaN+vv005dir732zC5bvvxUtew3v/kdpk+fhoMOOkD1wLr22utVT6pzzjmzIe+PiKgRGJQK+J//uQn/+7/r8B//8X8xbdpU9Zh0JTzrrHfitdc2oKenu9G7SERETYZ1BxFRZ5BeA5dffhluuulW/OhHV2NgYFAFld71ruU488zlOblV9t13EWbNmqnqgPnz5+VsR3qIfOELl+KWW1bgl7/8DbZv36ESmy9ZcjTOOefd2WFQRESdgEGpDKkM7rlnFU4++fhsoyLoU5/6u4bsFxERNS/WHUREnReYkl6xcitF8kZ973vfKLpc8sKce+5Z6kZE1MlG5zXscH/605Mqidf+++/T6F0hIqIWwbqDiIiIiGji2FMq46WXXlb3fX19+O1vb8Ejj/xJXQGXLrcyRvzss89UXXCJiIh8rDuIiIiIiCaOQamMLVu2qPuf/vRazJw5A//0T5/EnDmz8fzzf8FVV12Dp59eg8sv/8K407yuWHE3Vqy4p+CyVCqZM/Wn3GTGJrknCuKxQbU8PnhcNVfdUUm90UpYjtUPP+v66PTPuVPfNxER1RaDUhnxeELdDw2N4N///R/VtK9Cpnv94AfPxU9+8gv84hf/jS9+8TPjbmfHjp0lGxcrV65U49HlxGbDhg0YHh7OThNLJHhsUC2Pj5GREXUv01dT4+uOSuqNVsJyrH74WddHp3/OrDtah/8dDQwM1DVoKb8NeU1J5E5UCI+TzjKQKYPGqzfa6ki49NLL1JTc5TruuLfjk5/8eM5jhx56ULZR4ZOZMK6++lqsXfsXDA4Oobe3p+g25bmS2LCQoaFBdf/+97+/7H0kIqqVwcFB9Pf3o9M1uu5gvUFErYR1R2t8R2LBggWN3hUiIoxXb7RVUOqEE5ZgaGi47PUXLdoz+7d/BVqmdc0XDofUNK07d+7Cli1bSwalzjjjdHUrdoXt3/7ty+jt7YWmafjsZ7+stjllSj++851/K3u/qf3x2KBaHh9ytUIqh3nzcqeo7lSNrjsqqTdaCcux+uFnXR+d/jmz7mgd8h2tX7++rnVHp/8+qDw8TjqLW2a90VZBqclMqbrbbnOxbt0rahalWpGu3vPnz8/+PxyOIBQKq3tJkkvk47FBtT4+eJW7NeqO/HqjlbAcqx9+1vXBz5l1R6toRN3B3weVg8dJ5+kvo97ovAHxRRx00AHqfuvWbWOWWZaFXbsGVAEvCWyJiIgE6w4iIiIiooljUCrjqKMOVzk9nn12bXYctu/RR59QXc+OOOJQdHe3VqJZIiKqHdYdREREREQTx6BURiQSwSc+8beqAfHDH/4Emze/qWYHePbZ53D99b/FzJnT8dGPfqjRu0lERE2EdQcRERER0cS1VU6pyTrooANxxRVfxM0334avfvXf1TTdkrz2uOOOwVlnnVEywTkREXUm1h1ERERERBPDoFSePffcHZ/5zD80ejeIiKiFsO4gIiIiIqocg1INdMYZy9QV9Vgs2uhdoSbDY4NK4fFBrYDHaf3ws64Pfs5ExfH3QeXgcUKFaK4kwiAiIiIiIiIiIqojJjonIiIiIiIiIqK6Y1CKiIiIiIiIiIjqjkEpIiIiIiIiIiKqOwaliIiIiIiIiIio7jj7Xp0lk0k8/PBjePzxp/Daa69jZCSO7u4u7LvvIpxxxt9gv/32Lvrc1aufw6233olXX30Num6o55x77llYuHCPur4Hqh05Hm666VY88cRTGBgYwPTp03D88Utw5pnLYZr8ubYzmXPi6aefxSOP/Al//es67Ny5C5FIGAsWzMcpp5yAE05YUvB5mzZtxg03/B7PP/8iLCuF+fN3wzvesQxLlryt7u+BSLAcq77BwUH8/Oe/xp/+9CQuvvijOOmk44quyzKhcix/iarv0ksvw7ZtbxVcNnv2TFx55Tfqvk/UODw3oFJ4BNTZd7/7Y6xd+wKWLz8VF174f9DX14dXXnkV11zza3zta9/GRRd9pODJ5qpVD+Pqq6/F6acvxT/90ydVcOu66/4Hl1/+TXzhC5/GgQfu15D3Q9UtrK+44lsYHh7GJZdcrIKNEoi86qpr1EnyZz97CXSdnRvb1e9/fwd++9tbcNBBB+Azn/kHzJ07G9u2bcf//M9N6hh44YUXVWM06LXX1uP//t9vY+HC3XHFFV9EX18v7rrrXvzoRz/Bli1bcNZZ72zY+6HOxHKs+h5//EkVkEqn7XHXZZkwMSx/iWpj1qyZMAxjzOMzZkxryP5QY/DcgMbDb7/OLMvCYYcdjPPP/4AqqKPRCA44YD/80z/9PTRNw3XXXa9+uEFvvbUdv/jFf2PRooW44IIPoKenW0WX//7vL1S9rOQHLdul1nbjjb/Dhg0b8fGPX4D99tsH4XAYb3vbETj77HergnvlygcavYtUQ/Ib7u/vU0HnPffcHZFIBLvtNheXXvoJVVY88MAjKqDtcxxH/fblCv8ll/wd5syZha6uGM4++0wcfvghuPHGW7B+/caGvifqPCzHquvee1fh2muvVwGRI488tOS6LBMmjuUvUW186UufwXe+87Uxt8su+6dG7xrVEc8NaDwMStXZvHlzCnYDnzdvLmbPnoVEIomXXno5Z5n8UOWE6cQTj1WBK58EtI455m0qaCVXUql1xeMJ3H//w5gypR+HHnpQzjL/e7/zznsbtn9Ue9OmTVVlQzQazXlcujTL1Xvx3HOjjaLnn/8LXn99g2oASWMqSHpbSmPprrtW1mnviViO1cKCBbvh29++Qv3Ox8MyYeJY/hIR1QbPDagcHL5XZzI8r5hYLJL5y815/Jln1qj7ffZZNOY5++yzF/7wh5V4+uk1OO64Y6q8t1Qva9f+RQUe9957YU7gUfT29mDOnNkqd4Xc5s6d07D9pNo57bSTiy6LxbyGkhsoGuQ375cB+fyy4plnnq3+jhIVwXKs+uSKcrlYJkwcy18iotrguQGVg0GpJiFdwd98c6vqzrjXXgtzHt+4cZP6e+bM6WOeN2OG9xi7ibe29es3qPsZM2YUXC7fvRTW8j2zwO48mza9qe7333+0ger/5gsdM3I1KhQKqWS9g4NDqtInqjWWY43FMqE2WP4STdzKlQ9i9eo1qo0j8YjddpunescsXXoicwh1CJ4bUDkYlGoSMp52eHgEy5efpnJG+SQhXDqdVpHlrq6uMc+TnFJCZjGg1rVr10DO95nP/+799ahzDA0NY82atSrPSbDb865du8Y5ZmLYtctSxwwbRVQPLMcai2VC9bH8JZqcl15ap/II7b77fBWklckAZOIGafdIDjcGptofzw2oHAxKNQEJOl1//W/VbC/vf/97cpalUl4C80IzVwh/Cs1kMlWHPaVaSaVS43zPRs561DmkbAA0fOITH8vp9uyXDf6xUaxs4DFD9cJyrLFYJlQfy1+iibv44o+oIcj+70Fyt33oQ+/D5s1b8OSTz+Duu+9TF+OpvfHcgMrBoNQEXHrpZdi27a2y1z/uuLfjk5/8eNHlMrOeXD346le/oGZ8CQqHQ+retu2iAS0RiYTL3h9qPjJss/T3bOesR53hkUcew4MP/hGf+tTfqYTHhcqGYtPE+2UDjxmqF5ZjjcUyobpY/lKnm2x7Z/Fib5KAfDJ0T4JSDz30KINSHYDnBlQOBqUmQGZokS7d5Vq0aM+iy2666VY1c94Xv/gZlegtX3d3t7rCICc4IyMjY4bwyZA/0deXO/sLtRZ/9h7/+8wn331wPWp/a9Y8j6uvvg4XXni+mjY3X39/PzZseKPEMRPPrMdjhuqD5VhjsUyoHpa/RNVt7wTNmjVT3UseIWp/PDegcjAoNQHnnntWVbbz+9/foWbOk4DUwoV7FFxHxlrvtttcvPbaemzZsk3lNQjyr2DkX8Wj1rJgwXx1v3XrtoLLt27l99xJnnvueXzve/8fPvrRD+Hkk48vuI4cC2vXvlDwmJEEuzLTiSTcZT4TqheWY43FMqE6WP4SVbe9M1buLOPU3nhuQOVgdrkGueWWO7Bixd1jAlKS+O9///elnHUPO+xgdf/SSy+P2c5f//pyzjrUmhYv3h+hkIl1616BG5x3GlBDOzdvfhOzZ8/krBQd4LnnXsCVV/5/uOCC83IaRBs2bMSjjz5RZrmwLmcdonpgOdZYLBMmj+UvUXXccccfcNVV1xRcJjPxCdYFnYHnBlQOBqUa4JZbVuD228cGpMSjjz6uuo0HnXrqSWp6YcltEPwxJxJJ/OlPf1aJA48++si67T9VXywWxUknHa+usEpgMsj/3jnuvv3Jlfcrr/wxzj9fGkQn5Cxbt+5VrFy5KqeSl6tKTz/97JgZSx544BGVlPdv/ubUuu07EcuxxmKZMDksf4mqR9oozz67FvF4Ysyye+9dlc1BRe2P5wZUDg7fq7PbbrsTN9zwOzU16u23/2HM8nXrXsbMmTNyHps+fRouuOAD+NnPfonrrvsfnHPOu9UMBddee72KMH/+85dmk25S6zrvvPfihRdexE9/eh0uueRiFbCUwvvmm2/FwQcfqIKT1L7Wrv0LvvOdH6mpxOVqvdyCpNtz8HcuQ3tlRqivfe3b+OEP/x8uuugj6O3tVUOCpaEk3e6lnCGqJ5ZjjcMyYeJY/hJVnwRsZSjsBz5wNubPn6fyU61YcQ+eeWYNDjlkMU4/fWmjd5HqhOcGNB7Nze9HRw2fyeLss89Ugad8UojfeusKvPrqehiGjn32WaROfPbaq7zEgtT8JNmfl/z+KQwMDKqApCSaPPPM5dkpdak9STd3mYmmlAMO2Bdf/vLnch57441NuOGG36vKXqYpnz9/Lt7xjmU49lhegaTGYDlWPRIM+fSnv1hw2YwZ0/GDH3xzzOMsEyrH8peouuTi+ZNPrsZjjz2uehpKXSCjPiQ4ddxxx+C0005SwV3qHDw3oFIYlCIiIiIiIiIiorpjiJqIiIiIiIiIiOqOQSkiIiIiIiIiIqo7BqWIiIiIiIiIiKjuGJQiIiIiIiIiIqK6Y1CKiIiIiIiIiIjqjkEpIiIiIiIiIiKqOwaliIiIiIiIiIio7hiUIiIiIiIiIiKiumNQioiIiIiIiIiI6o5BKSIiIiIiIiIiqjsGpYiawKc+9SlomqZu//Ef/1HWc6644orsc+bNm4fXX3+95vtJRETNgfUGERFVgvUGNSvNdV230TtB1OnWr1+PRYsWwbIszJkzB6+88gqi0WjR9a+77jp85CMfUX/39PTgwQcfxOGHH17HPSYiokZivUFERJVgvUHNij2liJrAggULcMEFF6i/N2/ejGuuuabouvfddx8+/vGPq79N08SNN97ICoKIqMOw3iAiokqw3qBmxZ5SRE3ipZdewv777w/btrHHHnuo/0slELR27Vocd9xx2LVrl/r/T37yE1x00UUN2mMiImok1htERFQJ1hvUjNhTiqhJ7L333nj/+9+v/n7ttdfwq1/9Kmf5pk2bcMYZZ2QriC996UusIIiIOhjrDSIiqgTrDWpG7ClF1ESee+45HHLIIZCf5X777Yfnn38euq5jeHgYJ554Ip566im13oc//GH88pe/VEkHiYioc7HeICKiSrDeoGbDnlJETeSggw7Cu9/9bvX3iy++iN/+9reqe+15552XrSBOPvlkNQacFQQREbHeICKiSrDeoGbDnlJETeaJJ57A0Ucfrf4+9NBDsWTJElx11VXq/wceeCAeeeQRTJkypcF7SUREzYL1BhERVYL1BjUTBqWImtDpp5+Oe+65J+cxmbr1scceU0kJiYiIglhvEBFRJVhvULPg8D2iJvQv//IvOf/v7u7G7bffzgqCiIgKYr1BRESVYL1BzYJBKaImJMkG5ea74oorcOSRRzZ0n4iIqHmx3iAiokqw3qBmwaAUUZP5y1/+grPOOguO42Qfu+WWW8p+viQo/Pa3v433ve992HPPPVWCQrm9+uqrNdpjIiJq1XrDsizcfffd+NSnPqVmY5Ir5dFoVE0b/g//8A9qynAiImovk21v/OQnP1GJ0Q844ABMmzYNoVAIs2fPxrve9S7V24qoEswpRdRENm/erBIN+gGknp4eDA0Nqb8ffPBBnHDCCeNu4z3veU/BSuWVV15RQSoiImofk6037r33Xixbtkz9vWDBguxV8scffxxvvPEG+vr6cNddd6nXICKi1leN9sb++++PdevW4eCDD8Zuu+2Grq4uvPzyy/jzn/+slv/zP/8zvvOd79T4nVC7YE8poiYxPDysri74FcT555+Pa6+9Nrv861//elnbkUrmy1/+Mn7/+99jw4YN6qoFERG1n2rUGzJ049xzz8Uf//hHvP766/jd736nbtLY+OhHP4qBgQF88IMfVD2qiIiotVWrvfHzn/8cO3bsUCM0brvtNvzmN79RM/o99NBDqsftd7/7XfzpT3+q2fug9sKeUkRNwLZtvPvd78aKFSvU/5cuXaquTJumqa5ArF27Vj0uhf1RRx1V0bZlFo0333yTPaWIiNpILesNXzwex9y5c7Fr1y6sWrUKJ510UlXfAxERtVe9IS688EJcc801KsD1pS99qWr7T+2LPaWImsDf//3fZyuIgw46CDfffLMamy25oIKFeblXL4iIqL3Vo96IxWLYd9991d8ylI+IiFpXvdobsk0RiUQmucfUKRiUImowKfivvvpq9fe8efNUZdHf359dLkkE99lnH/W35Iryr2IQEVFnqle9IVfV/SEe0uuWiIhaU73qjWeeeUYN5TMMA8uXL6/S3lO7Y1CKqIF++ctfqvxPore3V1UQkmg2SAr1yy67TP0to22/8Y1vNGRfiYios+oNea2tW7di5syZOPbYY6uw90RE1E71huSWkvyDH/rQh1Q9ccQRR2BkZAT/9V//hcWLF9fg3VA7Yk4poga577771BUESR4rY7nvuOMOnH766QXXlXXk6oVMzS2VxosvvohFixaV9TrMKUVE1B7qVW8I6SElM/Ft375dTf190UUXVfGdEBFRO9QbH//4x/Gzn/0s+3+Zhe/73/8+Pvaxj6ltEJWDPaWIGmDNmjU4++yzs7MZyQl/sQrCH5v9+c9/Pjuc4pvf/Gbd9pWIiDqr3pAZ98466ywVkHrf+97HgBQRUQuqR73x05/+VPWsGhoawtNPP40PfOADuPjii9UMfzJZBlE52FOKqM42btyIY445Bhs2bFD//+pXv4rLL7983Oclk0ksXLgQmzZtQjgcVtN1z58/f9znsacUEVFrq2e9kUgk1FX1Bx54AKeeeqq6qs5ktUREraXe7Y1Cvaf+7d/+Df/yL/8y4fdAnYM9pYjqSK4+n3HGGdkKQsZgl1NBCGkUfPazn1V/p1IpfPvb367pvhIRUWfVG3I1/ZxzzlEBKWnMSLJbBqSIiFpLo9sbF1xwgbqXOoSoHOwpRdTm2FOKiIjG4zgOPvjBD+KGG27AoYceivvvvx9Tp05t9G4REVGLeeGFF3DggQeqdoe0P4jGw55SRERERB1Mrk9K3igJSO233364++67GZAiIqIJWbVqlbrfe++9G70r1CIYlCIiIiLqYP/8z/+Ma665RuURWblyJWbNmtXoXSIioib15JNP4ne/+x3S6fSYZbfffns2j5TkliIqB4fvEbUZSUr7ta99Lfv/p556SuUJOeyww7K5Qd75znfiK1/5SgP3koiImoHk/HjPe96j/j7llFOw++67F1xP1vHXIyKizvX73/8e733vezFlyhQceeSRmD17Nnbu3IkXX3xRJUb3L3Z85zvfafSuUoswG70DRFRdW7duxZ/+9Kcxjz/zzDPZv/fff/867xURETWjHTt2ZP+WPFLFSG4QBqWIiOjoo49Ws/nJpBgSiHr44Yeh6zrmzZuH888/HxdffDGOP/74Ru8mtRD2lCIiIiIiIiIiorpjTikiIiIiIiIiIqo7BqWIiIiIiIiIiKjuGJQiIiIiIiIiIqK6Y1CKiIiIiIiIiIjqjkEpIiIiIiIiIiKqOwaliIiIiIiIiIio7hiUIiIiIiIiIiKiumNQioiIiIiIiIiI6o5BKSIiIiIiIiIiqjsGpYiIiIiIiIiIqO4YlCIiIiIiIiIiItTb/w+JB2ltev4DHQAAAABJRU5ErkJggg==",
+      "text/plain": [
+       "\u001b[1m<\u001b[0m\u001b[1;95mFigure\u001b[0m\u001b[39m size 120\u001b[0m\u001b[1;36m0x1200\u001b[0m\u001b[39m with \u001b[0m\u001b[1;36m9\u001b[0m\u001b[39m Axes\u001b[0m\u001b[1m>\u001b[0m"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "dp.plot_peeling_nxd(X,a,b,p=p,figsize=(12,12))"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.11.10"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/docs/source/examples/calibration/KNN_calibrator_demo.ipynb b/docs/source/examples/calibration/KNN_calibrator_demo.ipynb
new file mode 100644
index 00000000..26480bc8
--- /dev/null
+++ b/docs/source/examples/calibration/KNN_calibrator_demo.ipynb
@@ -0,0 +1,579 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "f7568014",
+   "metadata": {},
+   "source": [
+    "(knn_calibration)=\n",
+    "# KNN calibration\n",
+    "\n",
+    "KNN filtering is a novel data-driven, likelihood-free calibration method based on a non-parametric kernel average smoother, whereby *posterior parameter samples* can be filtered using some certain norm $\\| \\cdot \\|$ as the discrepancy measure $\\delta$. Intuitively, it could be conceptually seen as a dictionary mapping between parameters and data. \n",
+    "\n",
+    "Given empirical observation, the most likely parameters, as if nearest neighbours parameterised by $K$ to the ground truth, are found through the defined norm. For this to work, it is typically needed for the parameter space to be explored first by, for instance, uniform sampling, followed by the KNN filtration process.\n",
+    "\n",
+    "This notebook demonstrates its capability using a paraboloid model as the data generating mechanism.\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "b2e70ba3",
+   "metadata": {},
+   "source": [
+    "```{note}\n",
+    "This is a likelihood-free approach, allowing calibration on epistemic parameters.\n",
+    "```"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "185e8adb",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import numpy as np\n",
+    "import matplotlib.pyplot as plt\n",
+    "from pyuncertainnumber.calibration.knn import KNNCalibrator, estimate_p_theta_knn\n",
+    "import pyuncertainnumber.calibration.knn\n",
+    "# from knn import KNNCalibrator   # import your calibrator (adjust path if needed) # from pyuncertainnumber.calibration.knn import KNNCalibrator\n",
+    "rng = np.random.default_rng(12)\n",
+    "\n",
+    "plt.rcParams.update({\n",
+    "        \"font.size\": 11,\n",
+    "        \"text.usetex\": False,\n",
+    "        \"font.family\": \"serif\",\n",
+    "        \"figure.figsize\": (6, 4.5),\n",
+    "        \"legend.fontsize\": 'small',\n",
+    "        })"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "a87ff3dc",
+   "metadata": {},
+   "source": [
+    "### Data generating mechanism"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "6e6cebfa4f1b6a02",
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2025-11-24T17:47:05.267849Z",
+     "start_time": "2025-11-24T17:47:04.917223Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "def paraboloid_model(theta, xi=0.0, A=1.0, B=0.5, C=1.5):\n",
+    "    \"\"\"Vectorized paraboloid, mild noise; supports scalar or vector xi.\"\"\"\n",
+    "    theta = np.atleast_2d(theta).astype(float)\n",
+    "    x1, x2 = theta[:, 0], theta[:, 1]\n",
+    "    xi = np.asarray(xi, float)\n",
+    "    if xi.ndim == 0:\n",
+    "        xi = np.full(theta.shape[0], xi)\n",
+    "    elif xi.ndim == 2:\n",
+    "        xi = xi.ravel()\n",
+    "    y = A * x1**2 + B * x1 * x2 * (1.0 + xi) + C * (x2 + xi) ** 2\n",
+    "    y = y + 0.2 * np.random.randn(theta.shape[0])  # small noise\n",
+    "    return y.reshape(-1, 1) if theta.shape[0] > 1 else np.array([y.item()])\n",
+    "\n",
+    "def theta_sampler(n, lb=-15, ub=15):\n",
+    "    return np.random.uniform(lb, ub, size=(n, 2))\n",
+    "\n",
+    "def scatter_post(ax, theta, truth=None, title=\"\", alpha=0.30, s=6, label=\"Posterior\"):\n",
+    "    ax.scatter(theta[:,0], theta[:,1], s=s, alpha=alpha, label=label)\n",
+    "    if truth is not None:\n",
+    "        ax.scatter(truth[:,0], truth[:,1], c=\"r\", marker=\"x\", s=60, label=\"θ true cloud\")\n",
+    "    ax.set_title(title); ax.set_xlabel(\"θ1\"); ax.set_ylabel(\"θ2\"); ax.grid(True); ax.legend()\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "3b1e1c70575ad4c5",
+   "metadata": {},
+   "source": [
+    "Generate empirical evidence (data from an unknown data generating process)\n",
+    "\n",
+    "* Case 1 - 1 sample ($y$), 1 target ($\\theta$ point-valued), 1 experiment ($\\xi$)\n",
+    "* Case 2 - 100 sample ($y$) from 100 targets ($\\theta$ distribution), 1 experiment ($\\xi$)\n",
+    "* Case 3 - 100 sample ($y$) from 100 targets ($\\theta$ distribution), for 4 experiments ($\\xi$)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "4ae07f9a0f91bbbe",
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2025-09-17T15:54:03.104953Z",
+     "start_time": "2025-09-17T15:54:03.097258Z"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "CASE 1 - designs: 1 samples: 1\n",
+      "CASE 2 - designs: 1 samples: 100\n",
+      "CASE 3 - designs: 4 samples: 100\n"
+     ]
+    }
+   ],
+   "source": [
+    "# generate data for the horse and pony show\n",
+    "\n",
+    "# Case 1 - 1 sample (y), 1 target (θ point-valued), 1 experiment (ξ)\n",
+    "theta_true_c1 = rng.normal(0, 4, size=(1, 2))   # unknown\n",
+    "xi_list_c1 = [0.0]  # selected (experiment)\n",
+    "y_emp = paraboloid_model(theta_true_c1, xi_list_c1)\n",
+    "observations_c1 = [(y_emp, xi_list_c1)]\n",
+    "print(f\"CASE 1 - designs: {len(observations_c1)} samples: {observations_c1[0][0].shape[0]}\")\n",
+    "\n",
+    "# Case 2 - 100 sample (y) from 100 targets (θ distribution), 1 experiment (ξ)\n",
+    "N_emp = 100\n",
+    "xi_list_c2 = xi_list_c1\n",
+    "theta_true_cloud = rng.normal(4.0, 0.5, size=(N_emp, 2))   # unknown\n",
+    "y_emp= paraboloid_model(theta_true_cloud, xi_list_c1)\n",
+    "observations_c2 = [(y_emp, xi_list_c1)]\n",
+    "\n",
+    "print(f\"CASE 2 - designs: {len(observations_c2)} samples: {observations_c2[0][0].shape[0]}\")\n",
+    "\n",
+    "# Case 3 - 100 sample (y) from 100 targets (θ distribution), for 4 experiments (ξ)\n",
+    "xi_list_c3 = [-1.0, 0.0, 1.0, 3.0]\n",
+    "observations_c3 = []\n",
+    "for xi in xi_list_c3:\n",
+    "    y_emp  = paraboloid_model(theta_true_cloud, xi)  # shape (100,1) per design\n",
+    "    observations_c3.append((y_emp, xi))\n",
+    "\n",
+    "print(f\"CASE 3 - designs: {len(observations_c3)} samples: {observations_c3[0][0].shape[0]}\")\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "b0bd8e22d9eba4a8",
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2025-09-17T15:54:03.515261Z",
+     "start_time": "2025-09-17T15:54:03.193538Z"
+    }
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "
\n"
+      ],
+      "text/plain": []
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "\u001b[1m<\u001b[0m\u001b[1;95mFigure\u001b[0m\u001b[39m size 60\u001b[0m\u001b[1;36m0x500\u001b[0m\u001b[39m with \u001b[0m\u001b[1;36m1\u001b[0m\u001b[39m Axes\u001b[0m\u001b[1m>\u001b[0m"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# set up knn calibrator\n",
+    "calib_single = KNNCalibrator(knn=500, evaluate_model=True)\n",
+    "calib_single.setup(model=paraboloid_model,\n",
+    "                   theta_sampler=theta_sampler,\n",
+    "                   xi_list=xi_list_c1, n_samples=500_000)\n",
+    "# run calibration\n",
+    "post_single = calib_single.calibrate(observations=observations_c1, combine=\"stack\")  # pooled kNN\n",
+    "theta_post_single = post_single[\"theta\"]\n",
+    "\n",
+    "# visualize\n",
+    "fig, ax = plt.subplots(figsize=(6,5))\n",
+    "scatter_post(ax, theta_post_single, truth=np.atleast_2d(theta_true_c1),\n",
+    "             title=f\"Unified kNN — single design (ξ*={xi_list_c1}, pooled neighbors)\")\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "7ee64dc0e5072f24",
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2025-09-17T15:54:05.239646Z",
+     "start_time": "2025-09-17T15:54:03.598743Z"
+    }
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "
\n"
+      ],
+      "text/plain": []
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "\u001b[1m<\u001b[0m\u001b[1;95mFigure\u001b[0m\u001b[39m size 60\u001b[0m\u001b[1;36m0x500\u001b[0m\u001b[39m with \u001b[0m\u001b[1;36m1\u001b[0m\u001b[39m Axes\u001b[0m\u001b[1m>\u001b[0m"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# set up knn calibrator\n",
+    "xi_star = 0.0\n",
+    "y_obs_star = next(y for (y, x) in observations_c2 if np.isclose(x, xi_star))\n",
+    "\n",
+    "calib_single = KNNCalibrator(knn=100, evaluate_model=True)\n",
+    "calib_single.setup(model=paraboloid_model, theta_sampler=theta_sampler, xi_list=[xi_star], n_samples=100_000)\n",
+    "# run calibration\n",
+    "post_single = calib_single.calibrate([(y_obs_star, xi_star)], combine=\"stack\")  # pooled kNN\n",
+    "theta_post_single = post_single[\"theta\"]\n",
+    "# visualize\n",
+    "fig, ax = plt.subplots(figsize=(6,5))\n",
+    "scatter_post(ax, theta_post_single, truth=theta_true_cloud,\n",
+    "             title=f\"Unified kNN — single design (ξ*={xi_star}, pooled neighbors)\")\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "aca7de6d",
+   "metadata": {},
+   "source": [
+    "```{tip}\n",
+    "Reuse precomputed simulations `(evaluate_model=False)`\n",
+    "```"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "54206d0e9bbaf45a",
+   "metadata": {},
+   "source": [
+    "### Build one big $(\\theta, \\xi)$ pool, then filter by $\\xi^{*}$ to create per-design kNN indices"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "bafbf0dd88685443",
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2025-09-17T15:54:06.364826Z",
+     "start_time": "2025-09-17T15:54:05.303390Z"
+    }
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "
\n"
+      ],
+      "text/plain": []
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "\u001b[1m<\u001b[0m\u001b[1;95mFigure\u001b[0m\u001b[39m size 60\u001b[0m\u001b[1;36m0x500\u001b[0m\u001b[39m with \u001b[0m\u001b[1;36m1\u001b[0m\u001b[39m Axes\u001b[0m\u001b[1m>\u001b[0m"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/html": [
+       "
\n"
+      ],
+      "text/plain": []
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "\u001b[1m<\u001b[0m\u001b[1;95mFigure\u001b[0m\u001b[39m size 60\u001b[0m\u001b[1;36m0x500\u001b[0m\u001b[39m with \u001b[0m\u001b[1;36m1\u001b[0m\u001b[39m Axes\u001b[0m\u001b[1m>\u001b[0m"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "\n",
+    "N_SIM = 1_000_000\n",
+    "knn = 10\n",
+    "resample_n = 10000\n",
+    "\n",
+    "theta_sim_pool = theta_sampler(N_SIM)\n",
+    "xi_sim_pool = rng.uniform(-4, 4, size=(N_SIM, 1))\n",
+    "y_sim_pool = paraboloid_model(theta_sim_pool, xi_sim_pool)\n",
+    "\n",
+    "simulated_data = {\"y\": y_sim_pool, \"theta\": theta_sim_pool, \"xi\": xi_sim_pool}\n",
+    "# 'prep model\n",
+    "calib_comb = KNNCalibrator(knn=knn, evaluate_model=False, a_tol=0.05)\n",
+    "calib_comb.setup(simulated_data=simulated_data, xi_list=xi_list_c3)\n",
+    "\n",
+    "\n",
+    "# 'vote' = stack\n",
+    "post_reuse = calib_comb.calibrate(observations_c3, combine=\"stack\", resample_n=resample_n)\n",
+    "theta_post_reuse = post_reuse[\"theta\"]\n",
+    "\n",
+    "fig, ax = plt.subplots(figsize=(6,5))\n",
+    "scatter_post(ax, theta_post_reuse, truth=theta_true_cloud,\n",
+    "             title=\"Unified kNN — reusing in-out simulations (and stack method)\")\n",
+    "plt.show()\n",
+    "\n",
+    "\n",
+    "# 'vote' = intersect\n",
+    "post_eval_vote = calib_comb.calibrate(observations_c3, combine=\"intersect\", resample_n=resample_n)\n",
+    "theta_post_vote = post_eval_vote[\"theta\"]\n",
+    "\n",
+    "fig, ax = plt.subplots(figsize=(6,5))\n",
+    "scatter_post(ax, theta_post_vote, truth=theta_true_cloud,\n",
+    "             title=\"Unified kNN — evaluate per design (combine='intersect')\")\n",
+    "plt.show()\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "7167fcb2d1b97639",
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2025-09-17T15:54:06.944414Z",
+     "start_time": "2025-09-17T15:54:06.482381Z"
+    }
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "
\n"
+      ],
+      "text/plain": []
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "\u001b[1m<\u001b[0m\u001b[1;95mFigure\u001b[0m\u001b[39m size 60\u001b[0m\u001b[1;36m0x500\u001b[0m\u001b[39m with \u001b[0m\u001b[1;36m1\u001b[0m\u001b[39m Axes\u001b[0m\u001b[1m>\u001b[0m"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "\n",
+    "post = calib_comb.calibrate(\n",
+    "    observations_c3,\n",
+    "    combine=\"intersect\",\n",
+    "    resample_n=None,          # <-- keep full weighted set\n",
+    "    combine_params={\n",
+    "                \"theta_match_tol\": 1e-3,\n",
+    "                \"min_frac\": 0.0,      # min occurrence fraction\n",
+    "                \"gamma\": 0.2,         # frequency sharpening\n",
+    "                \"use_kde\": True,      # enable KDE reweighting\n",
+    "                \"kde_bw\": 0.2\n",
+    "    }\n",
+    ")\n",
+    "\n",
+    "theta_post = post[\"theta\"]\n",
+    "w_post     = post.get(\"weights\", None)   # now you have KDE weights too\n",
+    "\n",
+    "\n",
+    "# visualize\n",
+    "fig, ax = plt.subplots(figsize=(6,5))\n",
+    "scatter_post(ax, theta_post[w_post>np.quantile(w_post,0.9),:], truth=theta_true_cloud,\n",
+    "             title=f\"Unified kNN — single design (ξ*={xi_star}, pooled neighbors)\")\n",
+    "plt.show()\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "73149a2e6e936d6f",
+   "metadata": {},
+   "source": [
+    "### Per-design overlay"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "e40e4750016f1c1b",
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2025-09-17T15:54:07.425191Z",
+     "start_time": "2025-09-17T15:54:07.044886Z"
+    }
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "
\n"
+      ],
+      "text/plain": []
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "\u001b[1m<\u001b[0m\u001b[1;95mFigure\u001b[0m\u001b[39m size 60\u001b[0m\u001b[1;36m0x500\u001b[0m\u001b[39m with \u001b[0m\u001b[1;36m1\u001b[0m\u001b[39m Axes\u001b[0m\u001b[1m>\u001b[0m"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "fig, ax = plt.subplots(figsize=(6,5))\n",
+    "colors = [\"tab:blue\", \"tab:orange\", \"tab:green\", \"tab:red\"]\n",
+    "for c, xi in zip(colors, xi_list_c3):\n",
+    "    post_xi = calib_comb.calibrate([(next(y for (y,x) in observations_c3 if np.isclose(x, xi)), xi)],\n",
+    "                                   combine=\"stack\", resample_n=5000)\n",
+    "    th_xi = post_xi[\"theta\"]\n",
+    "    ax.scatter(th_xi[:,0], th_xi[:,1], s=4, alpha=0.25, label=f\"ξ={xi}\", c=c)\n",
+    "ax.scatter(theta_true_cloud[:,0], theta_true_cloud[:,1], c=\"k\", marker=\"x\", s=40, label=\"θ true cloud\")\n",
+    "ax.set_title(\"Per-design posteriors (overlaid) — unified kNN\")\n",
+    "ax.set_xlabel(\"θ1\"); ax.set_ylabel(\"θ2\"); ax.grid(True); ax.legend()\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "2f1d19336ea9875b",
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2025-09-17T15:54:17.163794Z",
+     "start_time": "2025-09-17T15:54:07.498479Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "from scipy.stats import gaussian_kde\n",
+    "posters = []\n",
+    "for xi in xi_list_c3:\n",
+    "    y_i = next(y for (y,x) in observations_c3 if np.isclose(x, xi))\n",
+    "    post_i = calib_comb.calibrate([(y_i, xi)], combine=\"stack\", resample_n=1000)\n",
+    "    posters.append((xi, post_i[\"theta\"]))\n",
+    "\n",
+    "stack_all = np.vstack([th for _, th in posters] + [theta_true_cloud])\n",
+    "x_min, x_max = np.percentile(stack_all[:,0], [1, 99])\n",
+    "y_min, y_max = np.percentile(stack_all[:,1], [1, 99])\n",
+    "nx, ny = 200, 200\n",
+    "xx, yy = np.meshgrid(np.linspace(x_min, x_max, nx),\n",
+    "                     np.linspace(y_min, y_max, ny))\n",
+    "grid = np.vstack([xx.ravel(), yy.ravel()])\n",
+    "\n",
+    "zz = np.zeros((ny, nx))\n",
+    "for (c, (xi, th_xi)) in zip(colors, posters):\n",
+    "    kde = gaussian_kde(th_xi.T, bw_method='scott') # KDE on the posterior samples of this design\n",
+    "    zz_grid = kde(grid).reshape(ny, nx)\n",
+    "    zz += np.log(zz_grid)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "335d2d9c88a2c61",
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2025-09-17T15:54:17.352774Z",
+     "start_time": "2025-09-17T15:54:17.254425Z"
+    }
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "
\n"
+      ],
+      "text/plain": []
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "\u001b[1m<\u001b[0m\u001b[1;95mFigure\u001b[0m\u001b[39m size 60\u001b[0m\u001b[1;36m0x500\u001b[0m\u001b[39m with \u001b[0m\u001b[1;36m1\u001b[0m\u001b[39m Axes\u001b[0m\u001b[1m>\u001b[0m"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "\n",
+    "fig, ax = plt.subplots(figsize=(6,5))\n",
+    "# filled contours + a thin outline\n",
+    "zz_lik = np.exp(zz)\n",
+    "\n",
+    "# true cloud on top\n",
+    "ax.scatter(theta_true_cloud[:,0], theta_true_cloud[:,1],\n",
+    "           c=\"r\", marker=\"x\", s=30, label=\"θ true cloud\")\n",
+    "\n",
+    "csf = ax.contourf(xx, yy, zz_lik, levels=8, alpha=0.3, antialiased=True)\n",
+    "ax.contour(xx, yy, zz_lik, levels=8, colors='b', linewidths=0.9)\n",
+    "\n",
+    "ax.set_title(\"Per-design posterior densities (KDE) — unified kNN\")\n",
+    "ax.set_xlabel(\"θ1\"); ax.set_ylabel(\"θ2\"); ax.set_xlim(x_min, x_max); ax.set_ylim(y_min, y_max)\n",
+    "ax.grid(True); ax.legend()\n",
+    "plt.show()\n"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.11.10"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/docs/source/examples/calibration/index.md b/docs/source/examples/calibration/index.md
new file mode 100644
index 00000000..a972f5f5
--- /dev/null
+++ b/docs/source/examples/calibration/index.md
@@ -0,0 +1,36 @@
+# Calibration
+
+```{toctree}
+:maxdepth: 1
+:titlesonly:
+
+2dof_tmcmc_demo
+KNN_calibrator_demo
+Data_peeling_demo
+```
+
+::::{grid} 1 1 2 2
+:gutter: 2
+
+:::{card} Transitional MCMC (2-DOF)
+:link: 2dof_tmcmc_demo
+:link-type: doc
+:img-top: ../../_static/tmcmc_2dof.png
+Posterior inference of stiffness parameters with TMCMC.
+:::
+
+:::{card} KNN calibration
+:link: KNN_calibrator_demo
+:link-type: doc
+:img-top: ../../_static/KNN_calibration_demo.png
+Data-driven likelihood-free calibration technique.
+:::
+
+:::{card} Data peeling algorithm
+:link: Data_peeling_demo
+:link-type: doc
+:img-top: ../../_static/nested_ds.png
+Data peeling algorithm on a banana-shaped data generating process.
+:::
+
+::::
diff --git a/docs/source/examples/characterise_what_you_know.ipynb b/docs/source/examples/characterisation/characterise_what_you_know.ipynb
similarity index 100%
rename from docs/source/examples/characterise_what_you_know.ipynb
rename to docs/source/examples/characterisation/characterise_what_you_know.ipynb
diff --git a/docs/source/examples/example_dependency_dev_purpose.ipynb b/docs/source/examples/characterisation/example_dependency_dev_purpose.ipynb
similarity index 100%
rename from docs/source/examples/example_dependency_dev_purpose.ipynb
rename to docs/source/examples/characterisation/example_dependency_dev_purpose.ipynb
diff --git a/docs/source/examples/characterisation/index.md b/docs/source/examples/characterisation/index.md
new file mode 100644
index 00000000..914c5f8c
--- /dev/null
+++ b/docs/source/examples/characterisation/index.md
@@ -0,0 +1,60 @@
+# Characterisation
+
+```{toctree}
+:maxdepth: 1
+:titlesonly:
+
+work_with_interval
+example_dependency_dev_purpose
+repeated_variable
+linguistic_approximation
+significant_digits
+characterise_what_you_know
+```
+
+::::{grid} 1 2 2 3
+:gutter: 2
+
+:::{card} Work with intervals
+:link: work_with_interval
+:link-type: doc
+:img-top: ../../_static/interval_illustration.png
+Basics of interval arithmetic and usage patterns.
+:::
+
+:::{card} Dependency structures
+:link: example_dependency_dev_purpose
+:link-type: doc
+:img-top: ../../_static/distribution_dependency.png
+Illustrates dependence assumptions in uncertainty analysis.
+:::
+
+:::{card} Repeated variables
+:link: repeated_variable
+:link-type: doc
+:img-top: ../../_static/function_hint.png
+Handling repeated-variable issues in interval analysis.
+:::
+
+:::{card} Linguistic approximation
+:link: linguistic_approximation
+:link-type: doc
+:img-top: ../../_static/about_200.png
+Interpret uncertainty expressed with linguistic hedges.
+:::
+
+:::{card} Significant digits
+:link: significant_digits
+:link-type: doc
+:img-top: ../../_static/illustration_sigdigits.png
+Explore information carried by significant digits.
+:::
+
+:::{card} Characterise what you know
+:link: characterise_what_you_know
+:link-type: doc
+:img-top: ../../_static/free_pbox_constraint_demo.png
+Empirical constraints for characterising uncertain numbers.
+:::
+
+::::
diff --git a/docs/source/examples/linguistic_approximation.ipynb b/docs/source/examples/characterisation/linguistic_approximation.ipynb
similarity index 100%
rename from docs/source/examples/linguistic_approximation.ipynb
rename to docs/source/examples/characterisation/linguistic_approximation.ipynb
diff --git a/docs/source/examples/repeated_variable.ipynb b/docs/source/examples/characterisation/repeated_variable.ipynb
similarity index 100%
rename from docs/source/examples/repeated_variable.ipynb
rename to docs/source/examples/characterisation/repeated_variable.ipynb
diff --git a/docs/source/examples/significant_digits.ipynb b/docs/source/examples/characterisation/significant_digits.ipynb
similarity index 100%
rename from docs/source/examples/significant_digits.ipynb
rename to docs/source/examples/characterisation/significant_digits.ipynb
diff --git a/docs/source/examples/work_with_interval.ipynb b/docs/source/examples/characterisation/work_with_interval.ipynb
similarity index 100%
rename from docs/source/examples/work_with_interval.ipynb
rename to docs/source/examples/characterisation/work_with_interval.ipynb
diff --git a/docs/source/examples/index.md b/docs/source/examples/index.md
index 8322221e..9bb3a871 100644
--- a/docs/source/examples/index.md
+++ b/docs/source/examples/index.md
@@ -1,137 +1,118 @@
 # Examples
 
-
+
 ```{toctree}
 :maxdepth: 1
 :titlesonly:
 :hidden:
 
-work_with_interval
-example_dependency_dev_purpose
-repeated_variable
-linguistic_approximation
-significant_digits
-characterise_what_you_know
-aleatory_propagation_demo
-interval_propagation_demo
-mix_uncertainty_propagation_demo
+propagation/index
+calibration/index
+characterisation/index
 ```
 
-
+## Propagation
+
 ::::{grid} 1 2 2 3
 :gutter: 2
 
-
+:img-top: ../_static/aleatory_propagation_demo.png
+Propagate random variables via performance functions.
+:::
 
-
-
+:img-top: ../_static/interval_propagation_demo.png
+Epistemic/interval bounds, intrusive and non-intrusive.
+:::
 
-:::{card} Work with intervals
-:link: work_with_interval
+:::{card} Mixed uncertainty
+:link: propagation/mix_uncertainty_propagation_demo
 :link-type: doc
-:img-top: ../_static/interval_illustration.png
-:class-card: sd-text-center        # optional: center content
-:class-img-top: card-img-square    # <-- add a class you’ll style
-Introduction to work with intervals
+:img-top: ../_static/illustration_get_started.png
+Hybrid aleatory–epistemic propagation examples.
 :::
 
+::::
 
+## Calibration
 
-:::{card} Dependency structures in uncertainty analysis
-:link: example_dependency_dev_purpose
-:link-type: doc
-:img-top: ../_static/distribution_dependency.png
-:class-card: sd-text-center        # optional: center content
-:class-img-top: card-img-square    # <-- add a class you’ll style
-Random dependencies can be known, partially known, or unknown
-:::
+::::{grid} 1 2 2 3
+:gutter: 2
 
-:::{card} Interval dependency and repeated variables
-:link: repeated_variable
+:::{card} Transitional MCMC (2-DOF)
+:link: calibration/2dof_tmcmc_demo
 :link-type: doc
-:img-top: ../_static/function_hint.png
-:class-card: sd-text-center        # optional: center content
-:class-img-top: card-img-square    # <-- add a class you’ll style
-Repeated variable prblem in interval analysis
+:img-top: ../_static/tmcmc_2dof.png
+Posterior inference of stiffness parameters with TMCMC.
 :::
 
-:::{card} Interpret linguistic hedges
-:link: linguistic_approximation
+:::{card} KNN calibration
+:link: calibration/KNN_calibrator_demo
 :link-type: doc
-:img-top: ../_static/about_200.png
-:class-card: sd-text-center        # optional: center content
-:class-img-top: card-img-square    # <-- add a class you’ll style
-Interpret the uncertainty indicated by linguistic hedges (e.g. "about 7")
+:img-top: ../_static/KNN_calibration_demo.png
+Data-driven likelihood-free calibration technique.
 :::
 
-:::{card} Significance of significant digits
-:link: significant_digits
+:::{card} Data peeling algorithm
+:link: calibration/Data_peeling_demo
 :link-type: doc
-:img-top: ../_static/illustration_sigdigits.png
-:class-card: sd-text-center        # optional: center content
-:class-img-top: card-img-square    # <-- add a class you’ll style
-Explore the uncertainty indicated by significant digits of numbers
+:img-top: ../_static/nested_ds.png
+Data peeling algorithm on a banana-shaped data generating process.
 :::
 
+::::
 
-:::{card} Characterise what you know
-:link: characterise_what_you_know
-:link-type: doc
-:img-top: ../_static/free_pbox_constraint_demo.png
-:class-card: sd-text-center        # optional: center content
-:class-img-top: card-img-square    # <-- add a class you’ll style
-Empirical knowledge serving as constraints when characterising what you know
-:::
+## Characterisation
 
+::::{grid} 1 2 2 3
+:gutter: 2
 
-:::{card} Propagation of aleatory uncertainty
-:link: aleatory_propagation_demo
+:::{card} Work with intervals
+:link: characterisation/work_with_interval
 :link-type: doc
-:img-top: ../_static/aleatory_propagation_demo.png
-:class-card: sd-text-center        # optional: center content
-:class-img-top: card-img-square    # <-- add a class you’ll style
-propagate random variables via a performance function
+:img-top: ../_static/interval_illustration.png
+Basics of interval arithmetic and usage patterns.
 :::
 
-
-:::{card} Interval propagation
-:link: interval_propagation_demo
+:::{card} Dependency structures
+:link: characterisation/example_dependency_dev_purpose
 :link-type: doc
-:img-top: ../_static/interval_propagation_demo.png
-:class-card: sd-text-center        # optional: center content
-:class-img-top: card-img-square    # <-- add a class you’ll style
-Propagate intervals via a performance function, intrusively or nonintrusively
+:img-top: ../_static/distribution_dependency.png
+Illustrates dependence assumptions in uncertainty analysis.
 :::
 
-
-
-:::{card} Mixed uncertainty
-:link: mix_uncertainty_propagation_demo
+:::{card} Repeated variables
+:link: characterisation/repeated_variable
 :link-type: doc
-:img-top: ../_static/illustration_get_started.png
-:class-card: sd-text-center        # optional: center content
-:class-img-top: card-img-square    # <-- add a class you’ll style
-Propagation mixed uncertainty via a performance function
+:img-top: ../_static/function_hint.png
+Handling repeated-variable issues in interval analysis.
 :::
 
+:::{card} Linguistic approximation
+:link: characterisation/linguistic_approximation
+:link-type: doc
+:img-top: ../_static/about_200.png
+Interpret uncertainty expressed with linguistic hedges.
+:::
 
+:::{card} Significant digits
+:link: characterisation/significant_digits
+:link-type: doc
+:img-top: ../_static/illustration_sigdigits.png
+Explore information carried by significant digits.
+:::
 
+:::{card} Characterise what you know
+:link: characterisation/characterise_what_you_know
+:link-type: doc
+:img-top: ../_static/free_pbox_constraint_demo.png
+Empirical constraints for characterising uncertain numbers.
+:::
 
-
-
-
+::::
 ::::
\ No newline at end of file
diff --git a/docs/source/examples/aleatory_propagation_demo.ipynb b/docs/source/examples/propagation/aleatory_propagation_demo.ipynb
similarity index 100%
rename from docs/source/examples/aleatory_propagation_demo.ipynb
rename to docs/source/examples/propagation/aleatory_propagation_demo.ipynb
diff --git a/docs/source/examples/propagation/index.md b/docs/source/examples/propagation/index.md
new file mode 100644
index 00000000..73309bcb
--- /dev/null
+++ b/docs/source/examples/propagation/index.md
@@ -0,0 +1,36 @@
+# Propagation
+
+```{toctree}
+:maxdepth: 1
+:titlesonly:
+
+aleatory_propagation_demo
+interval_propagation_demo
+mix_uncertainty_propagation_demo
+```
+
+::::{grid} 1 1 2 2
+:gutter: 2
+
+:::{card} Aleatory propagation
+:link: aleatory_propagation_demo
+:link-type: doc
+:img-top: ../../_static/aleatory_propagation_demo.png
+Propagate random variables via performance functions.
+:::
+
+:::{card} Interval propagation
+:link: interval_propagation_demo
+:link-type: doc
+:img-top: ../../_static/interval_propagation_demo.png
+Propagate interval bounds intrusively or nonintrusively.
+:::
+
+:::{card} Mixed uncertainty
+:link: mix_uncertainty_propagation_demo
+:link-type: doc
+:img-top: ../../_static/illustration_get_started.png
+Hybrid aleatory–epistemic propagation examples.
+:::
+
+::::
diff --git a/docs/source/examples/interval_propagation_demo.ipynb b/docs/source/examples/propagation/interval_propagation_demo.ipynb
similarity index 100%
rename from docs/source/examples/interval_propagation_demo.ipynb
rename to docs/source/examples/propagation/interval_propagation_demo.ipynb
diff --git a/docs/source/examples/mix_uncertainty_propagation_demo.ipynb b/docs/source/examples/propagation/mix_uncertainty_propagation_demo.ipynb
similarity index 100%
rename from docs/source/examples/mix_uncertainty_propagation_demo.ipynb
rename to docs/source/examples/propagation/mix_uncertainty_propagation_demo.ipynb
diff --git a/docs/source/refs.bib b/docs/source/refs.bib
index 2966942a..6db1003b 100644
--- a/docs/source/refs.bib
+++ b/docs/source/refs.bib
@@ -27,4 +27,14 @@ @article{DONG198765
 author = {Weimin Dong and Haresh C. Shah},
 keywords = {Fuzzy set, Extension principle, Interval analysis, Vertex method, Linguistic variable},
 abstract = {This paper is to introduce a new approach — the vertex method — for computing functions of fuzzy variables. The method is based on the α-cut concept and interval analysis. The vertex method can avoid abnormality due to the discretization technique on the variables domain and the widening of the resulting function value set due to multi-occurrence of variables in the functional expression by conventional interval analysis methods. The algorithm is very easy to implement and can be applied to many practical problems. Some examples are given to illustrate the applications.}
+}
+
+@article{de2023robust,
+  title={Robust online updating of a digital twin with imprecise probability},
+  author={de Angelis, Marco and Gray, Ander and Ferson, Scott and Patelli, Edoardo},
+  journal={Mechanical Systems and Signal Processing},
+  volume={186},
+  pages={109877},
+  year={2023},
+  publisher={Elsevier}
 }
\ No newline at end of file
diff --git a/docs/source/tutorials/getting_started.ipynb b/docs/source/tutorials/getting_started.ipynb
index 990816df..01ca4d52 100644
--- a/docs/source/tutorials/getting_started.ipynb
+++ b/docs/source/tutorials/getting_started.ipynb
@@ -34,9 +34,9 @@
    "id": "6d3f8385-f0eb-4e28-bcbe-5fc7d75e9017",
    "metadata": {},
    "source": [
-    "`pyuncertainnumber` is underpined by a framework of uncertain number which allows for a closed computation ecosystem whereby trustworthy computations can be conducted in a rigorous manner. It provides capabilities across the typical uncertainty analysis pipeline, encompassing characterisation, aggregation, propagation, and applications including reliability analysis and optimisation under uncertainty, especailly with a focus on imprecise probabilities.\n",
+    "`pyuncertainnumber` is underpinned by a framework of uncertain number which allows for a closed computation ecosystem whereby trustworthy computations can be conducted in a rigorous manner. It provides capabilities across the typical uncertainty analysis pipeline, encompassing characterisation, aggregation, propagation, and applications including reliability analysis and optimisation under uncertainty, especially with a focus on imprecise probabilities.\n",
     "\n",
-    "`pyuncertainnumber` exposes APIs at different levels, including high-level user-friendly APIs best suited for new users to quickly start with uncertainty computations, and low-level APIs which allow experts to have more controls over the algorithm. Each scheme has its advantages and the best uses will certainly depend on the user cases."
+    "`pyuncertainnumber` exposes APIs at different levels, including **high-level user-friendly APIs** best suited for new users to quickly start with uncertainty computations, and **low-level APIs** which allow experts to have more controls over the algorithm. Each scheme has its advantages and the best uses will certainly depend on the user cases."
    ]
   },
   {
@@ -46,9 +46,14 @@
    "source": [
     "## High-level `Uncertain Number` APIs\n",
     "\n",
-    "As the name `pyuncertainnumber` suggests, the concept of *uncertain number* is the core to the uncertainty computation. The high-level APIs aims to give users a simple and straightforward syntax to quickly get on without worrying too much underlying nuances. Indeed, *uncertain number* is the umbrella term encompassing a wide range of uncertainty models and high-level APIs aims to allows users to perform calculations directly and consistently on uncertain numbers objects no matter what exactly the underlying uncertainty model (i.e. construct) they may be. Whatever the construct, it is an uncertain number.\n",
+    "As the name `pyuncertainnumber` suggests, the concept of *uncertain number* is the core to the uncertainty computation. The high-level APIs aim to give users a simple and straightforward syntax to quickly get on without worrying too much underlying nuances. Indeed, *uncertain number* is the umbrella term encompassing a wide range of uncertainty models and high-level APIs aims to allow users to perform calculations directly and consistently on uncertain numbers objects no matter what exactly the underlying uncertainty model (i.e. construct) they may be. Whatever the construct, it is an uncertain number.\n",
     "\n",
-    "Typically, this scheme will start with the import statement `import pyuncertainnumber as pun`. As illustrated below, with the high-level APIs, analysts can accomplish the \"uncertainty charactertion-aggregation-propagation\" workflow in only several lines of codes."
+    "\n",
+    "```{important}\n",
+    "See the tutorial notebook [what is an uncertain number](./what_is_un.ipynb) for a better understanding of what \"uncertain numbers\" are.\n",
+    "```\n",
+    "\n",
+    "Typically, this scheme will start with the import statement `import pyuncertainnumber as pun`. As illustrated below, with the high-level APIs, analysts can accomplish the *uncertainty charactertion-aggregation-propagation* workflow in only several lines of codes."
    ]
   },
   {
@@ -57,19 +62,18 @@
    "metadata": {},
    "source": [
     "```{tip}\n",
-    "Some more examples of the high-level API can be found in xxx.\n",
+    "Some more examples of the high-level API can be found in [examples](https://pyuncertainnumber.readthedocs.io/en/latest/examples/index.html).\n",
     "```"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 1,
+   "execution_count": null,
    "id": "b7234abf-f0c0-4d4d-9c6b-ef2c0dea7e7f",
    "metadata": {},
    "outputs": [],
    "source": [
     "%load_ext rich\n",
-    "from pyuncertainnumber import UncertainNumber as UN\n",
     "import pyuncertainnumber as pun\n",
     "import matplotlib.pyplot as plt"
    ]
@@ -343,7 +347,7 @@
    "source": [
     "## Low-level `pba` APIs\n",
     "\n",
-    "On the other hand, low-level APIs provide interfaces for deeper controls and customisation, which enables advanced usage and extension, since low-level APIs expose additional controls. Often when facing with complicated modelling problems (say repeated variable problem, non-monotonicity，etc.), analysts will need to tweak the workflow to suit their needs and this is the way to go. In the above example of uncertainty characterisation and propagation, low-level functions call be called:"
+    "On the other hand, **low-level APIs provide interfaces for deeper controls and customisation**, which enables advanced usage and extension, since low-level APIs expose additional controls. Often when facing with complicated modelling problems (say repeated variable problem, non-monotonicity，etc.), analysts will need to tweak the workflow to suit their needs and this is the way to go. In the above example of uncertainty characterisation and propagation, low-level functions call be called:"
    ]
   },
   {
diff --git a/docs/source/tutorials/index.md b/docs/source/tutorials/index.md
index 421cb6ef..06c74d66 100644
--- a/docs/source/tutorials/index.md
+++ b/docs/source/tutorials/index.md
@@ -4,6 +4,7 @@
 ```{toctree}
 :maxdepth: 1
 :titlesonly:
+:hidden:
 
 getting_started
 what_is_un
@@ -11,3 +12,39 @@ uncertainty_characterisation
 uncertainty_aggregation
 uncertainty_propagation
 ```
+
+::::{grid} 1 2 2 3
+:gutter: 2
+
+:::{card} Getting started
+:link: getting_started
+:link-type: doc
+Getting started with PyUncertainNumber and basic workflows.
+:::
+
+:::{card} What is UN?
+:link: what_is_un
+:link-type: doc
+:img-top: ../_static/what_is_un.png
+An introduction to uncertain numbers and their representations.
+:::
+
+:::{card} Uncertainty characterisation
+:link: uncertainty_characterisation
+:link-type: doc
+Methods for characterising and representing uncertainty in data.
+:::
+
+:::{card} Uncertainty aggregation
+:link: uncertainty_aggregation
+:link-type: doc
+Techniques for combining multiple sources of uncertainty.
+:::
+
+:::{card} Uncertainty propagation
+:link: uncertainty_propagation
+:link-type: doc
+Propagate uncertainty through computational models and functions.
+:::
+
+::::
diff --git a/docs/source/tutorials/what_is_un.ipynb b/docs/source/tutorials/what_is_un.ipynb
index dba983a2..21d606c2 100644
--- a/docs/source/tutorials/what_is_un.ipynb
+++ b/docs/source/tutorials/what_is_un.ipynb
@@ -6,9 +6,17 @@
    "metadata": {},
    "source": [
     "(what_is_uncertain_number)=\n",
-    "# What is an uncertain number\n",
-    "\n",
-    "*Uncertain Number* refers to a unified class of mathematical constructs useful for uncertainty representation that generalize real numbers, intervals, probability distributions, interval bounds on probability distributions (i.e. probability boxes), and finite DempsterShafer structures. "
+    "# What is an uncertain number"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "61326dc1",
+   "metadata": {},
+   "source": [
+    "```{important}\n",
+    "*Uncertain Number* refers to a unified class of mathematical constructs useful for uncertainty representation that generalize real numbers, intervals, probability distributions, interval bounds on probability distributions (i.e. [probability boxes (p-boxes)](https://en.wikipedia.org/wiki/Probability_box)), and finite [Dempster-Shafer structures (DSS)](https://en.wikipedia.org/wiki/Dempster–Shafer_theory). \n",
+    "```"
    ]
   },
   {
@@ -17,8 +25,7 @@
    "metadata": {},
    "source": [
     "The Python library `pyuncertainnumber` provides a closed computation environmnent where one can easily compute with uncertain numbers. Similar to automatic inference, one only needs to characterise the uncertain quantities of interest in his own analysis as uncertain numbers given the empirical knowledge, and then `pyuncertainnumber` will provide automatic uncertainty quantification.\n",
-    "\n",
-    "`Uncertain number` stands for a generalised representation that unifies several uncertainty constructs including intervals, probability distributions, [probability boxes (p-boxes)](https://en.wikipedia.org/wiki/Probability_box) and [Dempster-Shafer structures (DSS)](https://en.wikipedia.org/wiki/Dempster–Shafer_theory), plus real numbers. \n",
+    " \n",
     "These constructs are closely related to each other. `pyuncertainnumber` facilitates the computations of mixed-type uncertainties, which is common in real-world engineering analyses, since it is provided a consistent interface to work with uncertain numbers.\n",
     "\n",
     "
\n",
@@ -31,12 +38,12 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 1,
+   "execution_count": null,
    "id": "c8fcc65d-498c-4bca-9bd0-e87660931c8b",
    "metadata": {},
    "outputs": [],
    "source": [
-    "import pyuncertainnumber as pun\n",
+    "import pyuncertainnumber as pun  # yeah, pun intended\n",
     "import numpy as np"
    ]
   },
diff --git a/joss_paper/dmc_flowchart.png b/joss_paper/dmc_flowchart.png
deleted file mode 100644
index 942847bf..00000000
Binary files a/joss_paper/dmc_flowchart.png and /dev/null differ
diff --git a/joss_paper/hint.md b/joss_paper/hint.md
deleted file mode 100644
index d6c826b5..00000000
--- a/joss_paper/hint.md
+++ /dev/null
@@ -1,14 +0,0 @@
-# Tutorial on rendering the PDF
-
-step 1: Open Docker on the laptop
-
-step 2: Go to terminal and type below:
-
-```shell
-docker run --rm -it \
-    -v $PWD:/data \
-    -u $(id -u):$(id -g) \
-    openjournals/inara \
-    -o pdf,crossref \
-    joss_paper/paper.md
-```
\ No newline at end of file
diff --git a/joss_paper/imc_diagram2.png b/joss_paper/imc_diagram2.png
deleted file mode 100644
index a96114c2..00000000
Binary files a/joss_paper/imc_diagram2.png and /dev/null differ
diff --git a/joss_paper/imc_flowchart.png b/joss_paper/imc_flowchart.png
deleted file mode 100644
index b196fa5a..00000000
Binary files a/joss_paper/imc_flowchart.png and /dev/null differ
diff --git a/joss_paper/paper.bib b/joss_paper/paper.bib
deleted file mode 100644
index 73d38517..00000000
--- a/joss_paper/paper.bib
+++ /dev/null
@@ -1,177 +0,0 @@
-@article{dong1987vertex,
-  title={Vertex method for computing functions of fuzzy variables},
-  author={Dong, Weimin and Shah, Haresh C},
-  journal={Fuzzy sets and Systems},
-  volume={24},
-  number={1},
-  pages={65--78},
-  year={1987},
-  publisher={Elsevier}
-}
-
-
-@article{williamson1990probabilistic,
-  title={Probabilistic arithmetic. I. Numerical methods for calculating convolutions and dependency bounds},
-  author={Williamson, Robert C and Downs, Tom},
-  journal={International journal of approximate reasoning},
-  volume={4},
-  number={2},
-  pages={89--158},
-  year={1990},
-  publisher={Elsevier}
-}
-
-@article{springer1979algebra,
-  title={The algebra of random variables},
-  author={Springer, Melvin Dale},
-  year={1979},
-  publisher={New York: Wiley,}
-}
-
-@book{smith:2004,
-  title={Uncertainty quantification: theory, implementation, and applications},
-  author={Smith, Ralph C},
-  year={2024},
-  publisher={SIAM}
-}
-
-@article{Pearson:2017,
-  	url = {http://adsabs.harvard.edu/abs/2017arXiv170304627P},
-  	Archiveprefix = {arXiv},
-  	Author = {{Pearson}, S. and {Price-Whelan}, A.~M. and {Johnston}, K.~V.},
-  	Eprint = {1703.04627},
-  	Journal = {ArXiv e-prints},
-  	Keywords = {Astrophysics - Astrophysics of Galaxies},
-  	Month = mar,
-  	Title = {{Gaps in Globular Cluster Streams: Pal 5 and the Galactic Bar}},
-  	Year = 2017
-}
-
-@book{Binney:2008,
-  	url = {http://adsabs.harvard.edu/abs/2008gady.book.....B},
-  	Author = {{Binney}, J. and {Tremaine}, S.},
-  	Booktitle = {Galactic Dynamics: Second Edition, by James Binney and Scott Tremaine.~ISBN 978-0-691-13026-2 (HB).~Published by Princeton University Press, Princeton, NJ USA, 2008.},
-  	Publisher = {Princeton University Press},
-  	Title = {{Galactic Dynamics: Second Edition}},
-  	Year = 2008
-}
-
-@article{gaia,
-    author = {{Gaia Collaboration}},
-    title = "{The Gaia mission}",
-    journal = {Astronomy and Astrophysics},
-    archivePrefix = "arXiv",
-    eprint = {1609.04153},
-    primaryClass = "astro-ph.IM",
-    keywords = {space vehicles: instruments, Galaxy: structure, astrometry, parallaxes, proper motions, telescopes},
-    year = 2016,
-    month = nov,
-    volume = 595,
-    doi = {10.1051/0004-6361/201629272},
-    url = {http://adsabs.harvard.edu/abs/2016A%26A...595A...1G},
-}
-
-@article{astropy,
-    author = {{Astropy Collaboration}},
-    title = "{Astropy: A community Python package for astronomy}",
-    journal = {Astronomy and Astrophysics},
-    archivePrefix = "arXiv",
-    eprint = {1307.6212},
-    primaryClass = "astro-ph.IM",
-    keywords = {methods: data analysis, methods: miscellaneous, virtual observatory tools},
-    year = 2013,
-    month = oct,
-    volume = 558,
-    doi = {10.1051/0004-6361/201322068},
-    url = {http://adsabs.harvard.edu/abs/2013A%26A...558A..33A}
-}
-
-@misc{fidgit,
-  author = {A. M. Smith and K. Thaney and M. Hahnel},
-  title = {Fidgit: An ungodly union of GitHub and Figshare},
-  year = {2020},
-  publisher = {GitHub},
-  journal = {GitHub repository},
-  url = {https://github.com/arfon/fidgit}
-}
-
-
-
-@article{gray:2021,
-  title={ProbabilityBoundsAnalysis. jl: Arithmetic with sets of distributions},
-  author={Gray, Ander and Ferson, Scott and Patelli, Edoardo},
-  journal={Proceedings of JuliaCon},
-  volume={1},
-  pages={1},
-  year={2021}
-}
-
-
-@article{gray:2022,
-  title={Probability bounds analysis for Python},
-  author={Gray, Nicholas and Ferson, Scott and De Angelis, Marco and Gray, Ander and de Oliveira, Francis Baumont},
-  journal={Software Impacts},
-  volume={12},
-  pages={100246},
-  year={2022},
-  publisher={Elsevier},
-  DOI = {https://doi.org/10.1016/j.simpa.2022.100246},
-}
-
-
-@software{marco_2022_6205624,
-  author       = {de Angelis, Marco},
-  title        = {intervals},
-  month        = feb,
-  year         = 2022,
-  publisher    = {Zenodo},
-  version      = {v0.1},
-  doi          = {10.5281/zenodo.6205624},
-  url          = {https://doi.org/10.5281/zenodo.6205624},
-}
-
-@inproceedings{chen:2025,
-  title = {Imprecise uncertainty management with uncertain numbers to facilitate trustworthy computations},
-  booktitle = {SciPy Proceedings},
-  year = {2025},
-  doi = {10.25080/ahrt5264},
-  author = {Chen, Yu and Ferson, Scott},
-}
-
-
-@article{beer:2013,
-  title={Imprecise probabilities in engineering analyses},
-  author={Beer, Michael and Ferson, Scott and Kreinovich, Vladik},
-  journal={Mechanical systems and signal processing},
-  volume={37},
-  number={1-2},
-  pages={4--29},
-  year={2013},
-  publisher={Elsevier}
-}
-
-
-@incollection{ferson:2001,
-  title={Probability bounds analysis solves the problem of incomplete specification in probabilistic risk and safety assessments},
-  author={Ferson, Scott},
-  booktitle={Risk-Based Decisionmaking in Water Resources IX},
-  pages={173--188},
-  year={2001}
-}
-
-@book{moore:2009,
-  title={Introduction to interval analysis},
-  author={Moore, Ramon E and Kearfott, R Baker and Cloud, Michael J},
-  year={2009},
-  publisher={SIAM}
-}
-
-@article{oberkampf:2004,
-  title={Verification, validation, and predictive capability in computational engineering and physics},
-  author={Oberkampf, William L and Trucano, Timothy G and Hirsch, Charles},
-  journal={Appl. Mech. Rev.},
-  volume={57},
-  number={5},
-  pages={345--384},
-  year={2004}
-}
\ No newline at end of file
diff --git a/joss_paper/paper.crossref b/joss_paper/paper.crossref
deleted file mode 100644
index cb10f4bd..00000000
--- a/joss_paper/paper.crossref
+++ /dev/null
@@ -1,203 +0,0 @@
-
-
-  
-    20251119095950-6ec5be2f6134b9d3f6661adbe830ec3d985780fd
-    20251119095950
-    
-      JOSS Admin
-      admin@theoj.org
-    
-    The Open Journal
-  
-  
-    
-      
-        Journal of Open Source Software
-        JOSS
-        2475-9066
-        
-          10.21105/joss
-          https://joss.theoj.org
-        
-      
-      
-        
-          01
-          1970
-        
-        
-          ¿VOL?
-        
-        ¿ISSUE?
-      
-      
-        
-          PyUncertainNumber for uncertainty propagation with black-box models: beyond probabilistic arithmetic
-        
-        
-          
-            Yu
-            Chen
-            
-              Institute for Risk and Uncertainty, University of Liverpool, UKhttps://ror.org/00hx57361
-            
-            https://orcid.org/0000-0001-6617-2946
-          
-          
-            Scott
-            Ferson
-            
-              Institute for Risk and Uncertainty, University of Liverpool, UKhttps://ror.org/00hx57361
-            
-            https://orcid.org/0000-0002-2613-0650
-          
-          
-            Edoardo
-            Patelli
-            
-              Centre for Intelligent Infrastructure, University of Strathclyde
-            
-            https://orcid.org/0000-0002-5007-7247
-          
-        
-        
-          01
-          01
-          1970
-        
-        
-          ¿PAGE?
-        
-        
-          N/A
-        
-        
-          http://creativecommons.org/licenses/by/4.0/
-          http://creativecommons.org/licenses/by/4.0/
-          http://creativecommons.org/licenses/by/4.0/
-        
-        
-          
-            Software archive
-            10.5281
-          
-          
-            GitHub review issue
-            https://github.com/openjournals
-          
-        
-        
-          N/A
-          https://joss.theoj.org/papers/N/A
-          
-            
-              https://joss.theoj.org/papers/N/A.pdf
-            
-          
-        
-        
-          
-            Vertex method for computing functions of fuzzy variables
-            Dong
-            Fuzzy sets and Systems
-            1
-            24
-            1987
-            Dong, W., & Shah, H. C. (1987). Vertex method for computing functions of fuzzy variables. Fuzzy Sets and Systems, 24(1), 65–78.
-          
-          
-            Probabilistic arithmetic. I. Numerical methods for calculating convolutions and dependency bounds
-            Williamson
-            International journal of approximate reasoning
-            2
-            4
-            1990
-            Williamson, R. C., & Downs, T. (1990). Probabilistic arithmetic. I. Numerical methods for calculating convolutions and dependency bounds. International Journal of Approximate Reasoning, 4(2), 89–158.
-          
-          
-            The algebra of random variables
-            Springer
-            1979
-            Springer, M. D. (1979). The algebra of random variables.
-          
-          
-            Uncertainty quantification: Theory, implementation, and applications
-            Smith
-            2024
-            Smith, R. C. (2024). Uncertainty quantification: Theory, implementation, and applications. SIAM.
-          
-          
-            ProbabilityBoundsAnalysis. Jl: Arithmetic with sets of distributions
-            Gray
-            Proceedings of JuliaCon
-            1
-            2021
-            Gray, A., Ferson, S., & Patelli, E. (2021). ProbabilityBoundsAnalysis. Jl: Arithmetic with sets of distributions. Proceedings of JuliaCon, 1, 1.
-          
-          
-            Probability bounds analysis for python
-            Gray
-            Software Impacts
-            12
-            https://doi.org/10.1016/j.simpa.2022.100246
-            2022
-            Gray, N., Ferson, S., De Angelis, M., Gray, A., & Oliveira, F. B. de. (2022). Probability bounds analysis for python. Software Impacts, 12, 100246. https://doi.org/https://doi.org/10.1016/j.simpa.2022.100246
-          
-          
-            Intervals
-            Angelis
-            10.5281/zenodo.6205624
-            2022
-            Angelis, M. de. (2022). Intervals (Version v0.1). Zenodo. https://doi.org/10.5281/zenodo.6205624
-          
-          
-            Imprecise uncertainty management with uncertain numbers to facilitate trustworthy computations
-            Chen
-            SciPy proceedings
-            10.25080/ahrt5264
-            2025
-            Chen, Y., & Ferson, S. (2025). Imprecise uncertainty management with uncertain numbers to facilitate trustworthy computations. SciPy Proceedings. https://doi.org/10.25080/ahrt5264
-          
-          
-            Imprecise probabilities in engineering analyses
-            Beer
-            Mechanical systems and signal processing
-            1-2
-            37
-            2013
-            Beer, M., Ferson, S., & Kreinovich, V. (2013). Imprecise probabilities in engineering analyses. Mechanical Systems and Signal Processing, 37(1-2), 4–29.
-          
-          
-            Probability bounds analysis solves the problem of incomplete specification in probabilistic risk and safety assessments
-            Ferson
-            Risk-based decisionmaking in water resources IX
-            2001
-            Ferson, S. (2001). Probability bounds analysis solves the problem of incomplete specification in probabilistic risk and safety assessments. In Risk-based decisionmaking in water resources IX (pp. 173–188).
-          
-          
-            Introduction to interval analysis
-            Moore
-            2009
-            Moore, R. E., Kearfott, R. B., & Cloud, M. J. (2009). Introduction to interval analysis. SIAM.
-          
-          
-            Verification, validation, and predictive capability in computational engineering and physics
-            Oberkampf
-            Appl. Mech. Rev.
-            5
-            57
-            2004
-            Oberkampf, W. L., Trucano, T. G., & Hirsch, C. (2004). Verification, validation, and predictive capability in computational engineering and physics. Appl. Mech. Rev., 57(5), 345–384.
-          
-        
-      
-    
-  
-
diff --git a/joss_paper/paper.md b/joss_paper/paper.md
deleted file mode 100644
index ead0e75b..00000000
--- a/joss_paper/paper.md
+++ /dev/null
@@ -1,183 +0,0 @@
----
-title: 'PyUncertainNumber for uncertainty propagation with black-box models: beyond probabilistic arithmetic'
-tags:
-  - Python
-  - uncertainty propagation
-  - imprecise probability
-  - probability bound analysis 
-authors:
-  - name: Yu Chen
-    orcid: 0000-0001-6617-2946
-    corresponding: true
-    equal-contrib: false
-    affiliation: 1 # (Multiple affiliations must be quoted)
-  - name: Scott Ferson
-    equal-contrib: false # (This is how you can denote equal contributions between multiple authors)
-    corresponding: false
-    affiliation: 1
-    orcid: https://orcid.org/0000-0002-2613-0650
-  - name: Edoardo Patelli
-    corresponding: false # (This is how to denote the corresponding author)
-    orcid: https://orcid.org/0000-0002-5007-7247
-    affiliation: 2
-affiliations:
- - name: Institute for Risk and Uncertainty, University of Liverpool, UK 
-   index: 1
-   ror: 00hx57361
- - name: Centre for Intelligent Infrastructure, University of Strathclyde 
-   index: 2
-date: 3 October 2025
-bibliography: paper.bib
----
-
-
-
-
-# Summary
-
-Scientific calculations and simulations are complicated by various uncertainties inherent in the computational pipeline. Comprehensive analysis requires uncertainties be represented using mathematical constructs that distinguish variability from lack of knowledge and combine them rigorously in calculations. The new Python library `pyuncertainnumber` enables such analysis by computing guaranteed bounds on functions of uncertain variables given only partial empirical knowledge. It supports both intrusive methods that are efficient for projection through explicitly defined mathematical models and non-intrusive methods that can be used with black-box models that associate outputs with given inputs but whose internal workings are not known. 
-
-
-
-
-
-
-
-
-
-
-
-
-
-# Statement of need
-
-A comprehensive uncertainty framework for scientific computation involves a mathematical model,
-through which various input uncertainties are propagated to estimate the uncertainty of an unknown quantity of interest (QoI).
-Real-world complex systems (physical or engineered) of industrial significance typically involves input parameters subject to uncertainties of various nature [@oberkampf:2004; @smith:2004]. These input uncertainties often appear as a mixture of parameters subject to variability (i.e. aleatory uncertainty, typically represented by probability distributions), or lack of knowledge (i.e. epistemic uncertainty, often represented by intervals), or a combination of both (i.e. mixed uncertainty, often represented by probability boxes (p-boxes)), which effectively represent a set of distributions and thereby capture both aleatory and epistemic uncertainty within a unified structure.
-
-
-Probability bounds analysis [@springer1979algebra; @williamson1990probabilistic; @ferson:2001] is one of the expressive frameworks proposed to manage uncertainties in an imprecise setting [@beer:2013].
-Software packages have been developed to facilitate the calculations of uncertain quantities, such as *interval arithmetic* [@marco_2022_6205624] and *probabilistic arithmetic* [@gray:2021; @gray:2022]. Collectively, they can be referred to as *uncertainty arithmetic* [@chen:2025], which provides a straightforward way to compute outcomes from algebraic expressions involving uncertain variables.
-
-While these uncertainty-representing frameworks have the potential to automatically compile non-deterministic subroutines via uncertain primitives, their use faces several challenges. A major one is that code accessibility[^1] of the simulation models or software (e.g. finite-element or computational-fluid-dynamics models) employed to describe the behavior of the system is often not guaranteed, rendering intrusive[^2] use of the above-mentioned uncertainty-representing frameworks infeasible. Often, these models are treated as black-box models in practice.
-Consequently, there is a critical need for software tools capable of performing mixed-uncertainty calculations on black-box models in real-world applications of computational engineering and physics.
-
-
-
-
-
-
-
-`pyuncertainnumber` addresses this need by providing the non-intrusive[^3] capability designed to allow generic black-box models to be rigorously propagated in the face of mixed uncertainties.
-This capability significantly boosts versatility for scientific computations through interfacing with many engineering software whose internal workings are not known.
-
-
-
-
-
-
-# Interval propagation in a non-intrusive manner
-
-
-Interval analysis [@moore:2009] features the advantages of providing rigorous enclosures of the solutions to problems, especially for engineering problems
-subject to epistemic uncertainty, such as modelling system parameters due to lack-of-knowledge or characterising measurement incertitude.
-Naive interval arithmetic typically faces difficulties such as the infamous [interval dependency](https://pyuncertainnumber.readthedocs.io/en/latest/examples/repeated_variable.html) issue. 
-Though it may be mitigated through arithmetic rearrangements in some simple cases, it still can be challenging for models of most complex systems, and impossible for black-box models.
-The critical issue remains the accessibility of code.
-
-
-
-Generally, the interval propagation problem can be cast as an optimisation problem where the minimum and maximum of the response are sought given a function mapping.
-Consider the function, for example $f$ in \autoref{eq:intervalpropagation}, which is not necessarily monotonic or linear and may well be a black-box deterministic model for a generic system. 
-
-\begin{equation}\label{eq:intervalpropagation}
-Y = f(I_{x1}, I_{x2}, ..., I_{xn})
-\end{equation}
-
-where $\mathbf{I} = [\mathbf{\underline{I}}, \mathbf{\overline{I}}] = [I_{x1}, I_{x2}, ..., I_{xn}]^\text{T}$ represents the vector of interval-valued inputs.
-For black-box models the optimisation can generally be solved via gradient-free optimisation techniques, as shown below:
-
-$$\underline{Y} = \min_{\underline{\mathbf{I}} \leq \mathbf{I} \leq \overline{\mathbf{I}} } [f(\mathbf{I})]; \ \overline{Y} = \max_{\underline{\mathbf{I}} \leq \mathbf{I} \leq \overline{\mathbf{I}} } [f(\mathbf{I})]$$
-
-
-`pyuncertainnumber` provides a series of non-intrusive methodologies of varying applicability. It should be noted that there is generally a trade-off between 
-applicability and computational efficiency. With additional knowledge pertaining the characteristics of the underlying function, one can accordinly dispatch an efficient method.
-For example, if the function is known to be monotone,  one may employ the vertex method [@dong1987vertex] which requres only $2^n$ model evaluations and is therefore subtantially more efficient than a brute-force grid sampling scheme. It should be noted that the accuracy of these methods varies, and a common guideline is that increasing the number of model evaluations generally leads to a better estimate of the bound but at the cost of compututational burden.
-A summary of applicability is tabulated in \autoref{tab:ipmethods}; see @chen:2025 for additional details of their advantages and disadvantages.
-
-
-Table: Supported methods for non-intrusive interval propagation.\label{tab:ipmethods}
-
-| Category        | Assumption                         | Results of Example A   |
-|-----------------|------------------------------------|------------------|
-| Vertex (Endpoints) | monotonicity                        | [13.0,148.0]     |
-| Subinterval reconstitution | monotonicity in subintervals     | [13.0,148.0]     |
-| Cauchy-deviate method | linearity and gradient required     | [-11.7,100.67]   |
-| Bayesian optimisation | general applicability                                 | [13.0,148.0]     |
-| Genetic algorithm     | general applicability                                 | [13.0,147.8]     |
-
-To better demonstrate the non-intrusive capability, two numerical examples, as displayed below in \autoref{fig:two_functions}, are provided where they are treated as black-box models. 
-\autoref{tab:ipmethods} lists the response interval of $f_{a}([1,5], [7,13], [5,10])$ for respective methods. A reference ground truth is $[13.0, 148.0]$.
-
-![Examplar functions as black-box models. (a) Example A: $f_{a}(x, y, z) = x^3 + y +z$, three level sets of $f_b=4$, $f_b=0$, $f_b=-4$ are shown; (b) Example B: $f_{b}(x, y) = 100(x-y^2)^2 + (1 - x)^2$.\label{fig:two_functions}](photo_appending.png)
-
-
-
-# Mixed uncertainty propagation for black-box models
-
-Real world complex systems (physical or engineered) of industrial significance typically involves parameters subject to uncertainties of various nature [@oberkampf:2004]. It requires faithful characterisation of these uncertainties given the empirical information, and the approaach to rigorously progate them. Due to the fact that empirical information is often sparse or scarce or conflicting, even the uncertainty characterisation for one parameter could be of mixed nature, for example one may be confident about the distributional family but uncertain about its shape parameters, or when there exists multiple expert opiontion of different credibility regarding its elicitation. 
-Commonly, real systems expect a high-dimensional input which effectively represents a mixture of aleatory, epistemic, and mixed uncertainties, as symbolfied below:
-
-
-
-\begin{equation}
-Y = f(\mathbf{u}; C)
-\end{equation}
-
-where $\mathbf{u} \in \mathbb{R}^{n}$ denotes the collection of $n$ uncertain inputs and $C$ denotes intervariable dependency structure.
-
-
-When both aleatory and epistemic uncertainties are present in $\mathbf{u}$, a *nested (double) Monte Carlo* approach can be used for determininsitc models without confounding the two distinct types of uncertainty.
-As illustrated in \autoref{fig:dmc} with the examplar function B (see \autoref{fig:two_functions}), Latin-hypercube samples are first drawn from the epistemic interval, conditioned on which aleatory samples are drawn from the aleatoric probability distributions. 
-Propagate these samples, which are visually denoted as rug ticks alongside the abscissa, through the computational model results in an ensemble of CDF (cumulative distribution function) of the QoI whereby a final p-box is obtained as the envelope. 
-Each CDF (orange color) correponds to an epistemic sample. 
-
-![Workflow of the Double Monte Carlo method.\label{fig:dmc}](dmc_flowchart.png)
-
-
-To scale to a more realistic setting, \autoref{fig:imc} illustrates the workflow of *interval Monte Carlo* method using the examplar function A where a mixture of aleatory, epistemic, and mixed uncertainty parameters are present, plus a certain copula is specified denoting the dependency structure. Correlated samples in the uniform space from the copula, visually denoted as rug ticks alongside the probability axis, are converted to physical space through alpha-cuts. Interval propagation (see [the last section](#interval-propagation-in-a-non-intrusive-manner)) then does the heavy lifting in which scalar values can be considered as degenerate intervals. As a result, the response QoI in \autoref{fig:imc} is then obtained as a p-box shown in gray. In contrast, a pinched response, obtained from propagating pinched input variables (e.g. a p-box is pinched into a distribution and an interval is pinched into a scalar), is also shown as a comparison. Importantly, the pinched result being enclosed  in the p-box manifests a critical feature of probability bounds analysis which yields results that are guaranteed to encolse all possible distributions of the ouput so long as the input p-boxes were all sure to enclose their respective distributions.
-
-![Workflow of the Interval Monte Carlo method. The first row shows the marginal of the inputs and the second row shows the bivariate copula density. \label{fig:imc}](imc_diagram2.png)
-
-
-
-
-# Conclusion
-
-
-
-It is evident that many computational tasks in engineering and physics rely on complex numerical methods in which the model functions are black boxes.
-This makes uncertainty arithmetic difficult to manage because the model code is inaccessible.
-By providing methods supporting generic black-box models, `pyuncertainnumber` enables rigorous uncertainty analysis for real-world scenarios of mixed uncertainties and partial knowledge.
-This non-intrusive capability allows `pyuncertainnumber` to interface with multiple software environments, offering extensive compatibility with engineering applications and diverse computational workflows.
-
-
-
-
-
-# Acknowledgements
-
-The work leading to these results received funding through the UK project Development of Advanced Wing Solutions 2 (DAWS2). The DAWS2 project is supported by the Aerospace Technology Institute (ATI) Programme, a joint government and industry investment to maintain and grow the UK’s competitive position in civil aerospace design and manufacture. The programme, delivered through a partnership between ATI, Department for Business and Trade (DBT) and Innovate UK, addresses technology, capability and supply chain challenges.
-
-# References
-
-
-
-[^1]: access to the source code.
-[^2]: requiring access or modification of the source code of a computational model.
-[^3]: operating on the model as a black box, without accessing or modifying its internals.
\ No newline at end of file
diff --git a/joss_paper/paper.pdf b/joss_paper/paper.pdf
deleted file mode 100644
index 870e16c6..00000000
Binary files a/joss_paper/paper.pdf and /dev/null differ
diff --git a/joss_paper/photo_appending.png b/joss_paper/photo_appending.png
deleted file mode 100644
index bc18d4b4..00000000
Binary files a/joss_paper/photo_appending.png and /dev/null differ
diff --git a/joss_paper/pool.md b/joss_paper/pool.md
deleted file mode 100644
index 3bd51c9d..00000000
--- a/joss_paper/pool.md
+++ /dev/null
@@ -1,65 +0,0 @@
-`Gala` is an Astropy-affiliated Python package for galactic dynamics. Python
-enables wrapping low-level languages (e.g., C) for speed without losing
-flexibility or ease-of-use in the user-interface. The API for `Gala` was
-designed to provide a class-based and user-friendly interface to fast (C or
-Cython-optimized) implementations of common operations such as gravitational
-potential and force evaluation, orbit integration, dynamical transformations,
-and chaos indicators for nonlinear dynamics. `Gala` also relies heavily on and
-interfaces well with the implementations of physical units and astronomical
-coordinate systems in the `Astropy` package [@astropy] (`astropy.units` and
-`astropy.coordinates`).
-
-`Gala` was designed to be used by both astronomical researchers and by
-students in courses on gravitational dynamics or astronomy. It has already been
-used in a number of scientific publications [@Pearson:2017] and has also been
-used in graduate courses on Galactic dynamics to, e.g., provide interactive
-visualizations of textbook material [@Binney:2008]. The combination of speed,
-design, and support for Astropy functionality in `Gala` will enable exciting
-scientific explorations of forthcoming data releases from the *Gaia* mission
-[@gaia] by students and experts alike.
-
-
-# Citations
-
-Citations to entries in paper.bib should be in
-[rMarkdown](http://rmarkdown.rstudio.com/authoring_bibliographies_and_citations.html)
-format.
-
-If you want to cite a software repository URL (e.g. something on GitHub without a preferred
-citation) then you can do it with the example BibTeX entry below for @fidgit.
-
-For a quick reference, the following citation commands can be used:
-- `@author:2001`  ->  "Author et al. (2001)"
-- `[@author:2001]` -> "(Author et al., 2001)"
-- `[@author1:2001; @author2:2001]` -> "(Author1 et al., 2001; Author2 et al., 2002)"
-
-
-
-# Mathematics
-
-Single dollars ($) are required for inline mathematics e.g. $f(x) = e^{\pi/x}$
-
-Double dollars make self-standing equations:
-
-$$\Theta(x) = \left\{\begin{array}{l}
-0\textrm{ if } x < 0\cr
-1\textrm{ else}
-\end{array}\right.$$
-
-You can also use plain \LaTeX for equations
-\begin{equation}\label{eq:fourier}
-\hat f(\omega) = \int_{-\infty}^{\infty} f(x) e^{i\omega x} dx
-\end{equation}
-and refer to \autoref{eq:fourier} from text.
-
-
-
-Figure sizes can be customized by adding an optional second parameter:
-![Interval Monte Carlo.](imc_flowchart.png){ width=20% }
-
-
-
-
\ No newline at end of file
diff --git a/joss_paper/todo.todo b/joss_paper/todo.todo
deleted file mode 100644
index b6352e5c..00000000
--- a/joss_paper/todo.todo
+++ /dev/null
@@ -1,3 +0,0 @@
-✔ cite my own scipy2025 paper @done (16/10/2025, 10:15:28)
-☐ change the figure form arrow to addition symbol
-☐ add the figures of the two black box functions
\ No newline at end of file
diff --git a/pyproject.toml b/pyproject.toml
index 39fb352d..d0eabdd5 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -6,8 +6,9 @@ requires = ["setuptools >= 61.0"]
 authors = [
   {name = "(Leslie) Yu Chen", email = "leslie.yuchen666@gmail.com"},
   {name = "Roberto Rocchetta", email = "roberto.rocchetta88@gmail.com"},
-  {name = "Ioanna Ioannou", email = "Ioanna.Ioannou@liverpool.ac.uk"},
+  {name = "Marco de Angelis", email = "marco.de-angelis@strath.ac.uk"},
   {name = "Scott Ferson", email = "sandp8@gmail.com"},
+  {name = "Ioanna Ioannou", email = "Ioanna.Ioannou@liverpool.ac.uk"},
 ]
 
 dependencies = [
@@ -18,9 +19,9 @@ dependencies = [
   "Pint",
   "pymongo",
   "pymoo",
+  "rich",
   "scipy >=1.15, <1.15.2",
   "tqdm",
-  "pytest",
   "bayesian-optimization",
   "geneticalgorithm",
   "statsmodels >=0.14, <0.15", # Verified 0.14.4 compatibility
@@ -28,6 +29,7 @@ dependencies = [
   "SALib",
   "json5",
 ]
+
 description = "Rigorous computation with Uncertain Number in Python"
 license = {text = "MIT License"}
 maintainers = [
@@ -36,7 +38,12 @@ maintainers = [
 name = "pyuncertainnumber"
 readme = "README.md"
 requires-python = ">= 3.11"
-version = "0.1.2"
+version = "0.1.3"
+
+[project.optional-dependencies]
+test = [
+  "pytest",
+]
 
 [tool.setuptools.packages.find]
 # All the following settings are optional:
diff --git a/src/pyuncertainnumber/calibration/__init__.py b/src/pyuncertainnumber/calibration/__init__.py
index e1b09d0b..a6072042 100644
--- a/src/pyuncertainnumber/calibration/__init__.py
+++ b/src/pyuncertainnumber/calibration/__init__.py
@@ -19,3 +19,8 @@
 #     "plot_top_by_quantile_scatter",
 #     "kde_1d",
 # ]
+
+from .tmcmc import TMCMC, Stage
+from .calibration import MCMCCalibrator
+from .knn import KNNCalibrator
+from .epistemic_filter import EpistemicFilter
diff --git a/src/pyuncertainnumber/calibration/data_peeling/fuzzy.py b/src/pyuncertainnumber/calibration/data_peeling/fuzzy.py
index 22db122f..bc921d58 100644
--- a/src/pyuncertainnumber/calibration/data_peeling/fuzzy.py
+++ b/src/pyuncertainnumber/calibration/data_peeling/fuzzy.py
@@ -1,75 +1,93 @@
 import numpy
 import numpy.matlib as matlib
-import scipy.stats as stats 
+import scipy.stats as stats
+from numpy.typing import NDArray
 
-def samples_to_fuzzy_projection(ux:numpy.ndarray,c:list):
+
+def samples_to_fuzzy_projection(ux: NDArray, c: list) -> NDArray:
     """
-    ux:     An (mxd_) array of samples, usually uniform. m is a large integer.
+    Args:
+        ux (NDArray): an (mxd_) array of samples, usually uniform. m is a large integer.
 
-    c:      A list (of length l) of subindices of coverage samples belonging to each level.
+        c (list): a list (of length l) of subindices of coverage samples belonging to each level.
             `len(levels) < m` must yield `True`, `sum([sum(len(subi)) for subi in levels])==m` must yield `True`.
 
-    fx: returns a d-dimensional fuzzy number, i.e. an (lxdx2) array. 
+    Returns:
+        fx (NDArray): returns a d-dimensional fuzzy number, i.e. an (lxdx2) array.
     """
-    ux = numpy.asarray(ux,dtype=float)
-    m,d_ = ux.shape
+    ux = numpy.asarray(ux, dtype=float)
+    m, d_ = ux.shape
     l = len(c)
-    fx = numpy.empty((l,d_,2))
+    fx = numpy.empty((l, d_, 2))
     first_empty_level = l
-    for i,subi in enumerate(c): # levels should be arranged from bottom to top
-        if sum(subi)==0: 
-            first_empty_level = i # set (non-empty) starting level. Yes, there may be empty levels
-            print(f'levels {i}:{l} have no sample coverage. Consider increasing the sample size.')
-    for i in range(l): # levels are usually a handful, so for loop does not slow things too much
-        fx[i,:,0] = numpy.min(ux[c[i],:],axis=0)
-        fx[i,:,1] = numpy.max(ux[c[i],:],axis=0)
-    if first_empty_level lo.
+    Args:
+        lo (NDArray): an (d,) array (or list) of left endpoints. Coverage means samples are generated using low-discrepancy schemes.
+        hi (NDArray): an (d,) array (or list) of right endpoints, with hi > lo.
 
-    OUT:
-    u: An (mxd_) array of coverage samples
+    Returns:
+        u (NDArray): an (mxd_) array of coverage samples
     """
-    lo,hi = numpy.asarray(lo,dtype=float), numpy.asarray(hi,dtype=float)
-    if lo.size == 1: d=1
-    else: d = lo.shape[0]
-    dist=stats.uniform(loc=lo, scale=hi-lo) # <- change sampling scheme here
-    return dist.rvs((m,d))
+    lo, hi = numpy.asarray(lo, dtype=float), numpy.asarray(hi, dtype=float)
+    if lo.size == 1:
+        d = 1
+    else:
+        d = lo.shape[0]
+    dist = stats.uniform(loc=lo, scale=hi - lo)  # <- change sampling scheme here
+    return dist.rvs((m, d))
 
 
-def width(x):
+def width(x: NDArray) -> NDArray:
     """
-    IN
-    x: An interval iterable, i.e. an (dx2) array
+    Args:
+        x (NDArray): an interval iterable, i.e. an (dx2) array
 
-    OUT
-    w: the width of the intervals
+    Returns:
+        w (NDArray): the width of the intervals
     """
-    x = numpy.asarray(x,dtype=float)
-    return x[:,1]-x[:,0]
\ No newline at end of file
+    x = numpy.asarray(x, dtype=float)
+    return x[:, 1] - x[:, 0]
diff --git a/src/pyuncertainnumber/calibration/data_peeling/peeling.py b/src/pyuncertainnumber/calibration/data_peeling/peeling.py
index 5928cd88..7cb74ef6 100644
--- a/src/pyuncertainnumber/calibration/data_peeling/peeling.py
+++ b/src/pyuncertainnumber/calibration/data_peeling/peeling.py
@@ -41,7 +41,7 @@
 
 def data_peeling_algorithm(
     X: NDArray, tol: float = 1e-4
-):  # should also input the shape, rectangle, circle, etc.
+) -> tuple[list, list]:  # should also input the shape, rectangle, circle, etc.
     """Data peeling algorithm for constructing a sequence of nested enclosing sets.
 
     args:
@@ -49,10 +49,11 @@ def data_peeling_algorithm(
         tol (float): a tolerance parameter determining the minimal size of an allowed enclosing box
 
     returns:
-        sequence_of_indices (list):
-            a list (number of levels long) of sets (or list) of indices of heterogeneous size
-        sequence_of_boxes (list):
-            a list (number of levels long) of (dx2) boxes
+        tuple[list, list]: a tuple containing:
+            - sequence_of_indices (list):
+                a list (number of levels long) of sets (or list) of indices of heterogeneous size
+            - sequence_of_boxes (list):
+                a list (number of levels long) of (dx2) boxes
 
 
     .. figure:: /_static/peeling_illus.png
@@ -61,8 +62,6 @@ def data_peeling_algorithm(
         :width: 90%
 
         Illustration of the data peeling algorithm.
-
-
     """
     H = make_hashtable(X)  # turns dataset in to hashtable
     n, d = X.shape
@@ -104,9 +103,15 @@ def data_peeling_algorithm(
     return a, b
 
 
-def index_to_mask(x, n=100):
-    """
-    Converts the list of indices x into a (nx1) boolean mask, true at those particular indices
+def index_to_mask(x: list, n=100) -> numpy.ndarray:
+    """Converts the list of indices x into a (nx1) boolean mask, true at those particular indices
+
+    Args:
+        x (list): list of indices
+        n (int, optional): size of the mask. Defaults to 100.
+
+    Returns:
+        numpy.ndarray: boolean mask
     """
     nrange = numpy.arange(n)
     boole = numpy.zeros(nrange.shape, dtype=bool)
@@ -133,21 +138,22 @@ def sanity_check(
 
 
 def data_peeling_backward(
-    uy: numpy.ndarray, y: numpy.ndarray = None, boxes: list = None, tol=1e-4
-):
+    uy: NDArray, y: NDArray = None, boxes: list = None, tol=1e-4
+) -> tuple[list, list, list]:
     """
-    IN
-    uy: (mxd) array of coverage samples output space.
-    boxes: sequence of boxes, each box is a (dx2) array. Also iterable of interval objects.
-
-    OUT
-    a: list (number of levels long) of sets (or list) of indices (heterogeneous size).
-    b: list (number of levels long) of (dx2) boxes (array-like).
-    c: list (number of levels long) of indices (input space) conatained in each level.
-
-    There are two cases where the peeling algorithm must raise an exception, and they are both linked to the termination of the algorithm.
-    (1) When the last enclosing set has less samples than the minimum number of support scenarios to determine that set.
-    (2) When there are enough samples to determine the set but some of them are too close to eachother (even for just one dimension).
+    Args:
+        uy (NDArray): (mxd) array of coverage samples output space.
+        boxes (list): sequence of boxes, each box is a (dx2) array. Also iterable of interval objects.
+
+    Returns:
+        tuple[list, list, list]: a tuple containing:
+            - a: list (number of levels long) of sets (or list) of indices (heterogeneous size).
+            - b: list (number of levels long) of (dx2) boxes (array-like).
+            - c: list (number of levels long) of indices (input space) conatained in each level.
+    Note:
+        There are two cases where the peeling algorithm must raise an exception, and they are both linked to the termination of the algorithm.
+            - When the last enclosing set has less samples than the minimum number of support scenarios to determine that set.
+            - When there are enough samples to determine the set but some of them are too close to eachother (even for just one dimension).
 
     While two may be linked to the problem of degeneracy, in this context, it may be best suited to refer to this case as a coverage problem.
     """
@@ -174,18 +180,23 @@ def extract_kn(a):
 
 
 def peeling_to_structure(
-    a, b, kind="scenario", beta=0.01
-):  # keep b for piping: peeling_to_structure(data_peeling_algorithm(x))
-    """
-    Note b may not be boxes, but spheres, ellipses, etc.
+    a: list, b: list, kind: str = "scenario", beta: float = 0.01
+) -> tuple[NDArray, list]:
+    """Peeling to structure.
+
+    Args:
+        a (list):  (number of levels long) of sets (or list) of indices of heterogeneous size
+        b (list):  (number of levels long) of (dx2) boxes (array-like)
 
-    IN:
-    a: list (number of levels long) of sets (or list) of indices of heterogeneous size
-    b: list (number of levels long) of (dx2) boxes (array-like)
+    Returns:
+        f: (lxdx2) array containing the projections of a joint fuzzy number.
+        p: list[float] of length l
 
-    OUT:
-    f: (lxdx2) array containing the projections of a joint fuzzy number.
-    p: list[float] of length l
+    Note:
+        Note b may not be boxes, but spheres, ellipses, etc.
+
+    .. tip::
+        keep b for piping: peeling_to_structure(data_peeling_algorithm(x))
     """
     k_cum, n = extract_kn(a)
     ALPHA = []
@@ -216,25 +227,26 @@ def uniform(lo, hi, N=100):
     return stats.uniform(loc=lo, scale=hi - lo).rvs((N, d))
 
 
-def samples_to_structure(ux, c):
-    """IN:
-    ux: (mxd_) array.
-    c: list (number of levels long) subset of indices (input space) conatained in each level.
+def samples_to_structure(ux: NDArray, c: list):
+    """
+    Args:
+        ux (NDArray): (mxd_) array.
+        c (list): (number of levels long) subset of indices (input space) conatained in each level.
 
-    OUT:
-    fx: (lxd_x2) array containing the projections of a joint fuzzy number in the input space.
+    Returns:
+        fx: (lxd_x2) array containing the projections of a joint fuzzy number in the input space.
     """
 
     pass
 
 
-def width(x: numpy.ndarray):
+def width(x: NDArray):
     """
-    IN
-    x: An interval or interval iterable, i.e. an (dx2) array
+    Args:
+        x: An interval or interval iterable, i.e. an (dx2) array
 
-    OUT
-    w: the width of the intervals
+    Returns:
+        w: the width of the intervals
     """
     x = numpy.asarray(x, dtype=float)
     if len(x.shape) == 1:
diff --git a/src/pyuncertainnumber/calibration/data_peeling/plots.py b/src/pyuncertainnumber/calibration/data_peeling/plots.py
index b80e4fea..fd5a4faf 100644
--- a/src/pyuncertainnumber/calibration/data_peeling/plots.py
+++ b/src/pyuncertainnumber/calibration/data_peeling/plots.py
@@ -2,9 +2,10 @@
 import matplotlib as matplotlib
 import matplotlib.pyplot as pyplot
 from matplotlib import gridspec
-
 from .peeling import peeling_to_structure
 from .fuzzy import samples_to_fuzzy_projection
+from numpy.typing import NDArray
+import matplotlib.pyplot as plt
 
 FONTSIZE = 22
 
@@ -100,12 +101,16 @@ def factor(n):
     return a, b
 
 
-def plot_peeling(x, a, b, p=None, axes3d=False, figsize="medium", grid=True, label="X"):
-    """
-    x: (nxd) data set of iid observations
-    a: sequence of subindices for each level
-    b: sequence of boxes or enclosing sets
-    p: upper violation probability (membership value)
+def plot_peeling(
+    x: NDArray, a, b, p=None, axes3d=False, figsize="medium", grid=True, label="X"
+):
+    """Plotting function for data peeling results.
+
+    Args:
+        x (NDArray): data set of iid observations
+        a: sequence of subindices for each level
+        b: sequence of boxes or enclosing sets
+        p: upper violation probability (membership value)
     """
     x = numpy.asarray(x, dtype=float)
     n, d = x.shape
@@ -423,7 +428,7 @@ def plot_peeling_nxd(
                 labelsize="x-large",
             )
     pyplot.tight_layout()
-    pass
+    return ax
 
 
 def plot_scattermatrix(
@@ -456,7 +461,7 @@ def plot_scattermatrix(
                 ax.hist(x[:, i], bins=bins, density=True, color=color)
                 # ax.yaxis.tick_right()
                 ax.set_xlabel(labels[i], fontsize=FONTSIZE)
-                ax.set_ylabel("#i/N", fontsize=FONTSIZE)
+                ax.set_ylabel(f"{i+1}/N", fontsize=FONTSIZE)
             else:
                 ax.scatter(
                     x[:, j],
@@ -472,7 +477,7 @@ def plot_scattermatrix(
             SUBAX.append(ax)
     for ax in SUBAX:
         if grid:
-            ax.grid(b=True)
+            ax.grid(True)
         ax.tick_params(
             direction="out",
             length=6,
@@ -483,7 +488,6 @@ def plot_scattermatrix(
             labelsize="x-large",
         )
     pyplot.tight_layout()
-    pass
 
 
 def plot_fuzzy(
@@ -628,3 +632,172 @@ def plot_peeling_nxd_back(
             )
     pyplot.tight_layout()
     pass
+
+
+# * --------- refactor
+
+import numpy as np
+from matplotlib import pyplot as plt
+from matplotlib import gridspec
+
+
+def _draw_peeling_cell(
+    ax,
+    x,
+    b,
+    fx,
+    p,
+    i,
+    j,
+    labels,
+    aspect="auto",
+    marker="s",
+    markercolor="grey",
+    boxcolor="blue2",
+    grid=True,
+    baseline_alpha=0.075,
+):
+    # match your styling
+    boxcolor_rgba = c_(boxcolor, alpha=baseline_alpha)
+    markercolor_rgba = c_(markercolor, alpha=0.5)
+
+    if i == j:  # diagonal
+        _ = plot_one_fuzzy_grad(
+            fx[:, i, :],
+            data=x[:, i],
+            p=p,
+            ax=ax,
+            color=boxcolor_rgba,
+            baseline_alpha=baseline_alpha,
+        )
+        ax.set_xlabel(labels[i], fontsize=FONTSIZE)
+        ax.set_ylabel(r"$1-\delta$", fontsize=FONTSIZE)
+    else:  # off-diagonal
+        ax.scatter(
+            x[:, i],
+            x[:, j],
+            color=markercolor_rgba,
+            marker=marker,
+            edgecolors="face",
+        )
+        for box in b:
+            _ = plot_box([box[i, :], box[j, :]], ax=ax, facecolor=boxcolor_rgba)
+
+        ax.set_aspect(aspect)
+        ax.set_xlabel(labels[i], fontsize=FONTSIZE)
+        ax.set_ylabel(labels[j], fontsize=FONTSIZE)
+
+    if grid:
+        ax.grid()
+
+    ax.tick_params(
+        direction="out",
+        length=6,
+        width=2,
+        colors="#5a5a64",
+        grid_color="gray",
+        grid_alpha=0.5,
+        labelsize="x-large",
+    )
+
+    return ax
+
+
+def plot_peeling_nxd_all(
+    x,
+    a,
+    b,
+    fx=None,
+    p: list = None,
+    figsize=None,
+    aspect="auto",
+    label="X",
+    marker="s",
+    markercolor="grey",
+    boxcolor="blue2",
+    grid=True,
+    baseline_alpha=0.075,
+    return_axes=False,  # <-- new
+):
+    n, d = x.shape
+    if (p is None) or (fx is None):
+        fx, p = peeling_to_structure(a, b, kind="scenario", beta=0.01)
+
+    labels = [r"$" + label + "_" + str(i + 1) + "$" for i in range(d)]
+    if figsize is None:
+        figsize = FIGSIZE["medium"]
+    elif isinstance(figsize, str):
+        figsize = FIGSIZE[figsize]
+
+    fig = plt.figure(figsize=figsize)
+    gs = gridspec.GridSpec(d, d, figure=fig)
+
+    axes = np.empty((d, d), dtype=object)
+
+    for i in range(d):
+        for j in range(d):
+            ax = plt.subplot(gs[j, i])
+            axes[j, i] = ax  # row=j, col=i (matches your gs[j,i])
+            _draw_peeling_cell(
+                ax=ax,
+                x=x,
+                b=b,
+                fx=fx,
+                p=p,
+                i=i,
+                j=j,
+                labels=labels,
+                aspect=aspect,
+                marker=marker,
+                markercolor=markercolor,
+                boxcolor=boxcolor,
+                grid=grid,
+                baseline_alpha=baseline_alpha,
+            )
+
+    plt.tight_layout()
+    return (fig, axes) if return_axes else ax  # keep backward compatible
+
+
+def plot_peeling_one(
+    x,
+    a,
+    b,
+    i,
+    j,
+    fx=None,
+    p: list = None,
+    figsize=(4, 4),
+    aspect="auto",
+    label="X",
+    marker="s",
+    markercolor="grey",
+    boxcolor="blue2",
+    grid=True,
+    baseline_alpha=0.075,
+):
+    n, d = x.shape
+    if (p is None) or (fx is None):
+        fx, p = peeling_to_structure(a, b, kind="scenario", beta=0.01)
+
+    labels = [r"$" + label + "_" + str(k + 1) + "$" for k in range(d)]
+
+    fig, ax = plt.subplots(figsize=figsize)
+    _draw_peeling_cell(
+        ax=ax,
+        x=x,
+        b=b,
+        fx=fx,
+        p=p,
+        i=i,
+        j=j,
+        labels=labels,
+        aspect=aspect,
+        marker=marker,
+        markercolor=markercolor,
+        boxcolor=boxcolor,
+        grid=grid,
+        baseline_alpha=baseline_alpha,
+    )
+    fig.tight_layout()
+    return fig, ax
diff --git a/src/pyuncertainnumber/calibration/epistemic_filter.py b/src/pyuncertainnumber/calibration/epistemic_filter.py
index 74af8912..18f2f3ed 100644
--- a/src/pyuncertainnumber/calibration/epistemic_filter.py
+++ b/src/pyuncertainnumber/calibration/epistemic_filter.py
@@ -3,9 +3,9 @@
 from scipy.spatial import ConvexHull
 from mpl_toolkits.mplot3d.art3d import Poly3DCollection
 import numpy as np
-import numpy as np
 from scipy.spatial import HalfspaceIntersection, ConvexHull
 from scipy.optimize import linprog
+from functools import partial
 
 
 class EpistemicFilter:
@@ -19,14 +19,14 @@ def __init__(
         """The EpistemicFilter method to reduce the epistemic uncertainty space based on discrepancy scores.
 
         args:
-            xe_samples (NDArray): Proposed Samples of epistemic parameters, shape (n_samples, n_dimensions).
+            xe_samples (NDArray): Proposed Samples of epistemic parameters, shape (ne, n_dimensions).
                 Typically samples from a bounded set of some epistemic parameters.
 
             discrepancy_scores (NDArray, optional): Discrepancy scores between the model simulations and the observation.
-                Associated with each xe sample, shape (n_samples,). Defaults to None.
+                Associated with each xe sample, shape (ne,). Defaults to None.
 
             sets_of_discrepancy (list, optional): List of sets of discrepancy scores for multiple datasets.
-                Each element should be an NDArray of shape (n_samples,). Defaults to None.
+                Each element should be an NDArray of shape (ne,). Defaults to None.
 
         tip:
             For performance functions that output multiple responses, some aggregation of discrepancy scores may be used.
@@ -45,11 +45,11 @@ def __init__(
             sets_of_discrepancy if sets_of_discrepancy is not None else None
         )
 
-    def filter(self, threshold: float = 0.1):
+    def filter(self, threshold: float | list):
         """Filter the epistemic samples based on a discrepancy threshold.
 
         args:
-            threshold (float): The discrepancy threshold for filtering data points.
+            threshold (float | list): The discrepancy threshold(s) for filtering data points.
 
         returns:
             tuple:
@@ -57,16 +57,42 @@ def filter(self, threshold: float = 0.1):
                 - hull;
                 - lower bounds;
                 - upper bounds of the bounding box, or (None, None) if unsuccessful.
+        """
+        if isinstance(threshold, list):
+            return self.iterative_filter(thresholds=threshold)
+        else:
+            return filter_by_discrepancy(
+                self.xe_samples, self.discrepancy_scores, threshold
+            )
 
+    def iterative_filter(
+        self,
+        thresholds: list,
+    ) -> list:
+        """Iteratively filter the epistemic samples based on multiple thresholds.
+
+        args:
+            thresholds (list): List of discrepancy thresholds for filtering data points.
+
+            simulation_model (callable, optional): A function that takes xe_samples as input and returns discrepancy scores.
+                Required if re_sample is True. Defaults to None.
+
+        note:
+            thresholds are assumed to be sorted in ascending order.
         """
-        return filter_by_discrepancy(
-            self.xe_samples, self.discrepancy_scores, threshold
+
+        f = partial(
+            filter_by_discrepancy,
+            xe_samples=self.xe_samples,
+            discrepancy_scores=self.discrepancy_scores,
         )
+        return [f(t) for t in thresholds.sort()]
 
-    def iterative_filter(
+    # TODO develope this function which natively intergrates the simulation model and resampling
+    def iterative_filter_w_simulation_model(
         self, thresholds: list, re_sample: bool = False, simulation_model=None
     ):
-        """Iteratively filter the epistemic samples based on multiple discrepancy thresholds.
+        """Iteratively filter the epistemic samples based on multiple thresholds.
 
         args:
             thresholds (list): List of discrepancy thresholds for filtering data points.
@@ -80,7 +106,6 @@ def iterative_filter(
             if re_sample is True, the simulation_model should be provided to re-evaluate discrepancy scores.
         """
 
-        # TODO start from the smallest threshold
         pass
 
     def filter_on_sets(self, plot_hulls: bool = True):
@@ -161,23 +186,27 @@ def plot_hull_with_bounds(
 
 
 # problem agnostic
-def filter_by_discrepancy(xe, discrepancy_scores, threshold=0.1):
+def filter_by_discrepancy(xe_samples, discrepancy_scores, threshold=0.1) -> tuple:
     """Computes the intersection of convex hull bounding boxes based on a discrepancy threshold.
 
     args:
-        threshold (float): The discrepancy threshold for filtering data points.
+        threshold (float): The scalar discrepancy threshold for filtering data points.
 
     returns:
         tuple: the hull, and Lower and upper bounds of the intersected bounding box, or (None, None) if unsuccessful.
+
+    note:
+        Assume the threshold is a scalar value.
     """
     # Get the absolute path of the directory containing this script
 
-    filtered_xe = xe[discrepancy_scores < threshold]
+    filtered_xe = xe_samples[discrepancy_scores < threshold]
 
     if filtered_xe.size == 0:
         raise ValueError(f"No data points remain after filtering.")
 
     hull = ConvexHull(filtered_xe)
+
     # return hull, hull.min_bound, hull.max_bound
 
     # for multiple thresholds/datasets
@@ -201,7 +230,7 @@ def filter_by_discrepancy(xe, discrepancy_scores, threshold=0.1):
 
 
 def plot_convex_hull_with_bounds(
-    filtered_xe,
+    filtered_xe: NDArray,
     hull=None,
     ax=None,
     show=True,
@@ -209,29 +238,30 @@ def plot_convex_hull_with_bounds(
     y_title=None,
     hull_alpha=0.25,
 ):
-    """
-    Plot points, their convex hull, and the axis-aligned bounding box.
+    """Plot points, their convex hull, and the axis-aligned bounding box.
 
-    Parameters
-    ----------
-    filtered_xe : array-like, shape (n_samples, n_dims)
+    args:
+    filtered_xe (NDArray): array-like, shape (n_samples, n_dims)
         Input points. Supports 2D or 3D.
+
     hull : scipy.spatial.ConvexHull, optional
         Precomputed convex hull. If None, it is computed.
+
     ax : matplotlib Axes or 3D Axes, optional
         Existing axes to draw on. If None, a new figure/axes is created.
+
     show : bool, default True
         If True, calls plt.show() at the end.
+
     hull_alpha : float, default 0.25
         Transparency of the hull surface.
 
-    Returns
-    -------
-    fig : matplotlib.figure.Figure
-    ax : matplotlib.axes.Axes or mplot3d.Axes3D
-    hull : scipy.spatial.ConvexHull
-    min_bound : ndarray
-    max_bound : ndarray
+    Returns:
+        fig : matplotlib.figure.Figure
+        ax : matplotlib.axes.Axes or mplot3d.Axes3D
+        hull : scipy.spatial.ConvexHull
+        min_bound : ndarray
+        max_bound : ndarray
     """
     xe = np.asarray(filtered_xe)
     if xe.ndim != 2:
@@ -359,20 +389,17 @@ def plot_convex_hull_with_bounds(
 
 
 def intersect_convex_hulls(hulls):
-    """
-    Compute intersection of several ConvexHull polytopes.
+    """Compute intersection of several ConvexHull polytopes.
     Works in 2D or 3D (and in principle higher).
 
-    Parameters
-    ----------
-    hulls : list of scipy.spatial.ConvexHull
+    args:
+        hulls : list of scipy.spatial.ConvexHull
 
-    Returns
-    -------
-    vertices : (m, d) ndarray
-        Vertices of the intersection polytope (may be empty).
-    hull_int : ConvexHull or None
-        ConvexHull of the intersection vertices, or None if empty.
+    returns:
+        vertices : (m, d) ndarray
+            Vertices of the intersection polytope (may be empty).
+        hull_int : ConvexHull or None
+            ConvexHull of the intersection vertices, or None if empty.
     """
     if not hulls:
         raise ValueError("Need at least one hull.")
@@ -420,27 +447,24 @@ def plot_multiple_convex_hulls(
     ax=None,
     show=True,
 ):
-    """
-    Plot multiple 2D point sets with their convex hulls.
-
-    Parameters
-    ----------
-    xe_list : list of ndarray
-        Each array must be shape (n_i, 2)
-    hulls : list of ConvexHull or None
-        If None, hulls are computed automatically.
-    show_bounds : bool
-        Whether to draw dashed bounding rectangles.
-    hull_alpha : float
-        Transparency of hull fill.
-    ax : matplotlib Axes
-        Optional existing axes.
-    show : bool
-        Whether to call plt.show()
-
-    Returns
-    -------
-    fig, ax, hulls
+    """Plot multiple 2D point sets with their convex hulls.
+
+    args:
+        xe_list : list of ndarray
+            Each array must be shape (n_i, 2)
+        hulls : list of ConvexHull or None
+            If None, hulls are computed automatically.
+        show_bounds : bool
+            Whether to draw dashed bounding rectangles.
+        hull_alpha : float
+            Transparency of hull fill.
+        ax : matplotlib Axes
+            Optional existing axes.
+        show : bool
+            Whether to call plt.show()
+
+    Returns:
+        fig, ax, hulls
     """
 
     # Convert inputs and validate dimensions
diff --git a/src/pyuncertainnumber/calibration/knn.py b/src/pyuncertainnumber/calibration/knn.py
index daba5679..a05bedd1 100644
--- a/src/pyuncertainnumber/calibration/knn.py
+++ b/src/pyuncertainnumber/calibration/knn.py
@@ -638,131 +638,3 @@ def estimate_p_theta_knn(
     dist, knn_idx = neigh.kneighbors(scaler.transform(observed_data))
     theta_set = np.vstack([simulated_data_xi[1][idx] for idx in knn_idx])
     return theta_set
-
-
-# ----------------------------
-# Example usage
-if __name__ == "__main__":
-    import numpy as np
-    import matplotlib.pyplot as plt
-
-    # --- import your unified calibrator ---
-    # from knn import KNNCalibrator
-    # (Assuming KNNCalibrator is defined in the current file for this snippet.)
-
-    def paraboloid_model(theta, xi=0.0, A=1.0, B=0.5, C=1.5):
-        """Vectorized paraboloid, mild noise; supports scalar or vector xi."""
-        theta = np.atleast_2d(theta).astype(float)
-        x1, x2 = theta[:, 0], theta[:, 1]
-        xi = np.asarray(xi, float)
-        if xi.ndim == 0:
-            xi = np.full(theta.shape[0], xi)
-        elif xi.ndim == 2:  # if passed as (n,1)
-            xi = xi.ravel()
-        y = A * x1**2 + B * x1 * x2 * (1.0 + xi) + C * (x2 + xi) ** 2
-        y = y + 0.2 * np.random.randn(theta.shape[0])  # small noise
-        return y.reshape(-1, 1) if theta.shape[0] > 1 else np.array([y.item()])
-
-    def theta_sampler(n, lb=-15, ub=15):
-        return np.random.uniform(lb, ub, size=(n, 2))
-
-    # --------------- Build observations (unknown process) ---------------
-    N_emp = 100
-    rng = np.random.default_rng(7)
-    theta_target = rng.normal(3.1, 0.3, size=(N_emp, 2))  # this is unknown in practice
-    experiment_designs = [-1.0, 0.0, 1.0, 3.0]
-
-    observations = []
-    for xi in experiment_designs:
-        y_emp = paraboloid_model(theta=theta_target, xi=xi)  # shape (100,1) per design
-        observations.append((y_emp, xi))
-
-    # --------------- kNN calibration multiple designs ---------------
-    # Use model+sampler so each design gets its own per-design kNN built on the SAME theta grid
-    calib_joint = KNNCalibrator(knn=100, evaluate_model=True)
-    calib_joint.setup(
-        model=paraboloid_model,
-        theta_sampler=theta_sampler,
-        xi_list=experiment_designs,
-        n_samples=100_000,
-    )
-
-    #  “intersect”
-    post_joint = calib_joint.calibrate(
-        observations=observations, combine="intersect", resample_n=5000
-    )
-    theta_post_joint = post_joint["theta"]  # (5000, 2) resampled
-    # If you wanted grid + weights instead, call with resample_n=None and use post_joint["theta"], post_joint["weights"].
-
-    # --------------- SINGLE-DESIGN calibration at xi=0.0 ---------------
-    xi_star = 0.0
-    y_obs_many = next(y for (y, xi) in observations if np.isclose(xi, xi_star))
-
-    calib_single = KNNCalibrator(knn=100, evaluate_model=True)
-    calib_single.setup(
-        model=paraboloid_model,
-        theta_sampler=lambda n: theta_sampler(n, -15, 15),
-        xi_list=[xi_star],
-        n_samples=100_000,
-    )
-    post_single = calib_single.calibrate(
-        [(y_obs_many, xi_star)], combine="stack"
-    )  # pooled kNN
-    theta_post_many = post_single["theta"]  # shape: (N_emp*knn, 2)
-
-    # --------------- Quick nearest() demo ---------------
-    # Take a single observed y at xi=1.0 and fetch its 10 nearest θ:
-    y_one = observations[2][0][0]  # first row at design 1.0
-    theta_knn_10 = calib_joint.nearest(y_one, xi=1.0, k=10)  # (10,2) θ neighbors
-
-    # --------------- PLOTS ---------------
-    # 1) Joint posterior (resampled) vs true cloud
-    plt.figure(figsize=(6, 5))
-    plt.scatter(
-        theta_post_joint[:, 0],
-        theta_post_joint[:, 1],
-        s=6,
-        alpha=0.25,
-        label="Joint posterior (vote, resampled)",
-    )
-    plt.scatter(
-        theta_target[:, 0],
-        theta_target[:, 1],
-        c="r",
-        marker="x",
-        s=40,
-        label=r"θ_true samples (unknown)",
-    )
-    plt.title("Unified kNN: joint combine='vote' over multiple designs")
-    plt.xlabel("θ1")
-    plt.ylabel("θ2")
-    plt.legend()
-    plt.grid(True)
-    plt.show()
-
-    # 2) Single-design posterior (kNN pooled) vs true cloud
-    plt.figure(figsize=(6, 5))
-    plt.scatter(
-        theta_post_many[:, 0],
-        theta_post_many[:, 1],
-        s=6,
-        alpha=0.35,
-        label="Single-design posterior (pooled kNN)",
-    )
-    plt.scatter(
-        theta_target[:, 0],
-        theta_target[:, 1],
-        c="r",
-        marker="x",
-        s=40,
-        label=r"θ_true samples (unknown)",
-    )
-    plt.title(f"Unified kNN: single-design at ξ*={xi_star}")
-    plt.xlabel("θ1")
-    plt.ylabel("θ2")
-    plt.legend()
-    plt.grid(True)
-    plt.show()
-
-    # 3) Show the 10 nearest θ for one observed y at xi=1.0 (sanity check)
-    print("Ten nearest θ for one observed y at ξ=1.0:\n", theta_knn_10)
diff --git a/src/pyuncertainnumber/calibration/tmcmc.py b/src/pyuncertainnumber/calibration/tmcmc.py
index d251a5d8..5df29c3e 100644
--- a/src/pyuncertainnumber/calibration/tmcmc.py
+++ b/src/pyuncertainnumber/calibration/tmcmc.py
@@ -1,24 +1,32 @@
+from __future__ import annotations
+from typing import TYPE_CHECKING, Optional
+
 from numpy.typing import NDArray
 import pickle
 from scipy.stats import wasserstein_distance, entropy
 from sklearn.metrics import mean_squared_error
+from dataclasses import dataclass
+import matplotlib.pyplot as plt
+import seaborn as sb
+import pandas as pd
+import time
+import numpy as np
+import logging
+from ..console import console
+
+if TYPE_CHECKING:
+    from pyuncertainnumber import Distribution
+    from .pdfs import ProbabilityDensityFun
 
 """
 This is the implementation for Transitional Markov Chain Monte Carlo (TMCMC) algorithm
 
-Leslie refactored and revised for `pyuncertainnumber` package, based on the version from 
+Leslie refactored, revised and integrated for `pyuncertainnumber` package, based on the version from 
 Roberto Rocchetta (NASA UQ challenge 2025). The original code is from Mukesh K. Ramancha.
 @license: MIT License
 @date: Nov 2025
 """
 
-import matplotlib.pyplot as plt
-import seaborn as sb
-import pandas as pd
-import time
-import numpy as np
-import logging
-from ..console import console
 
 logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(message)s")
 
@@ -41,45 +49,83 @@ class TMCMC:
 
 
     example:
-        >>>    t = TMCMC(
-        >>>        N,
-        >>>        all_pars,
-        >>>        log_likelihood=log_likelihood_function,
-        >>>        status_file_name='tmcmc_running_status.txt',
-        >>>    )
-        >>>    mytrace = t.run()
+        >>> from pyuncertainnumber.calibration.tmcmc import TMCMC
+        >>> from pyuncertainnumber import pba
+        >>> # create an instance of TMCMC class and run tmcmc
+        >>> parameters = [pba.D("uniform", (0.8, 2.2)), pba.D("uniform", (0.4, 1.2))] # dummy prior distributions
+        >>> t = TMCMC(
+        >>>     N=1000,                                             # number of particles
+        >>>     parameters=parameters,                              # prior distributions
+        >>>     names =['k1', 'k2'],                                # parameter names
+        >>>     log_likelihood=log_likelihood_function,             # user defined log likelihood function
+        >>>     mutation_steps=1,                                   # number of MCMC steps for perturbation
+        >>>     status_file_name='tmcmc_progressing_status.txt',    # status log file
+        >>> )
+        >>> mytrace = t.run()
+
+        >>> # for loading trace file
+        >>> import pickle
+        >>> with open('tmcmc_trace.pkl', 'rb') as f:
+        >>>     mytrace = pickle.load(f)
+        >>> re = TMCMC(trace=mytrace, names=names)                  # create TMCMC instance with loaded trace and names
+        >>> re.plot_updated_distribution(save=False)                # plot prior and posterior distribution
+        >>> prior_samples = re.load_prior_samples()                 # load prior samples as DataFrame
+        >>> posterior_samples = re.load_posterior_samples()         # load posterior samples as DataFrame
+
 
     .. figure:: /_static/tmcmc_2dof.png
         :alt: 2DOF TMCMC example
         :align: center
-        :width: 50%
+        :width: 70%
 
         Example of TMCMC calibration of a 2-DOF system
     """
 
     def __init__(
-        self, N: int, parameters: list, log_likelihood: callable, status_file_name: str
+        self,
+        N: int = None,
+        parameters: list = None,
+        names: list[str] = None,
+        log_likelihood: callable = None,
+        mutation_steps: int = 5,
+        status_file_name: str = None,
+        trace=None,
     ):
         self.N = N
         self.parameters = parameters
+        self.names = names
         self.log_likelihood = log_likelihood
+        self.mutation_steps = mutation_steps
         self.status_file_name = status_file_name
+        self.trace = trace
+        self.check_names()
+
+    def check_names(self):
+        if self.names is None:
+            raise ValueError("Parameter names must be  provided.")
 
-    def run(self):
+    def run(self) -> list[Stage]:
         """Run the TMCMC algorithm
 
         returns:
             mytrace: returns trace file of all samples of all tmcmc stages.
         """
 
-        mytrace, _ = run_tmcmc(
+        mytrace = run_tmcmc_updated(
             self.N,
             all_pars=self.parameters,
             log_likelihood=self.log_likelihood,
+            Nm_steps_max=self.mutation_steps,
             status_file_name=self.status_file_name,
         )
+        self.trace = mytrace
+        self.check_trace()
         return mytrace
 
+    def check_trace(self):
+        if hasattr(self, "trace") and self.trace is not None:
+            print("Trace is loaded.")
+
     def save_trace(self, mytrace, file_name: str, save_dir=None):
         """Save the trace to a file
 
@@ -94,50 +140,108 @@ def save_trace(self, mytrace, file_name: str, save_dir=None):
         with open(f"{file_name}.pkl", "wb") as f:
             pickle.dump(mytrace, f, protocol=pickle.HIGHEST_PROTOCOL)
 
+    def load_prior_samples(self, trace=None) -> pd.DataFrame:
+        if trace is None:
+            trace = self.trace
+        prior = pd.DataFrame(trace[0].samples, columns=self.names)  # samples from prior
+        return prior
 
-# class prior_uniform:
-#     # TODO: add a new Half Cauchy prior
-#     def __init__(self, lb, ub):
-#         self.lb = lb
-#         self.ub = ub
-#         self.dist = sps.uniform(
-#             loc=self.lb, scale=self.ub - self.lb
-#         )  # Define the uniform distribution
+    def load_posterior_samples(self, trace=None) -> pd.DataFrame:
+        if trace is None:
+            trace = self.trace
+        posterior = pd.DataFrame(trace[-1].samples, columns=self.names)
+        return posterior
 
-#     def generate_rns(self, N):
-#         return np.random.uniform(self.lb, self.ub, N)
+    def plot_updated_distribution(self, trace=None, save=False):
+        """Plot the prior and posterior distribution of the parameters
 
-#     def log_pdf_eval(self, x):
-#         # Check if x is within the bounds
-#         if np.all(x >= self.lb) and np.all(x <= self.ub):
-#             return self.dist.logpdf(x).sum()  # Sum log-PDF values for all dimensions
-#         else:
-#             return -np.inf  # Return negative infinity if x is out of bounds
+        args:
+            trace: trace file of all samples of all tmcmc stages.
+            save (bool): if True, save the figure
+        """
+        if trace is None:
+            trace = self.trace
 
+        if not hasattr(self, "names") or self.names is None:
+            raise ValueError("Parameter names are not provided.")
 
-def recover_trace_results(mytrace, names) -> pd.DataFrame:
-    """load back the trace results and return a DataFrame
+        plot_updated_distribution(trace, self.names, save=save)
 
-    return:
-        trace results in a DataFrame
+
+@dataclass
+class Stage:
+    """Container for one TMCMC stage.
+
+    Args:
+        Sm (NDArray): samples before resampling (N x Np)
+        Lm (NDArray): log-likelihoods at Sm (N,)
+        Wm_n (NDArray): normalized incremental weights (N,)
+        ESS (Optional[float]): effective sample size the next stage (can be None in terminal stage)
+        beta (float): tempering parameter next stage beta
+        Smcap (Optional[NDArray]): resampled samples (N x Np), None in terminal stage
     """
 
-    # names = ["Xe_1", "Xe_2", "Xe_3", "Xa1_mu", "Xa2_mu", "Xa1_std", "Xa2_std"]
-    # names = [
-    #     "Xe_1",
-    #     "Xe_2",
-    #     "Xe_3",
-    #     "Xa1_alpha",
-    #     "Xa1_beta",
-    #     "Xa2_alpha",
-    #     "Xa2_beta",
-    #     "Xa_12_corr",
-    # ]
-    # names = list(Config.epistemic_domain.keys())
+    Sm: NDArray  # samples before resampling (N x Np)
+    Lm: NDArray  # log-likelihoods at Sm (N,)
+    Wm_n: NDArray  # normalized incremental weights (N,)
+    ESS: Optional[
+        float
+    ]  # effective sample size next stage ESS (can be None in terminal stage)
+    beta: float  # tempering parameter next stage beta
+    Smcap: Optional[NDArray]  # resampled samples (N x Np), None in terminal stage
+
+    def __repr__(self) -> str:
+        return (
+            f"Stage(beta={self.beta:.4f}, " f"ESS={self.ESS}, " f"N={self.Sm.shape[0]})"
+        )
+
+    # * ---- Hints ----
+
+    @property
+    def samples(self) -> NDArray:
+        """Samples before resampling (from previous stage)."""
+        return self.Sm
+
+    @property
+    def log_likelihoods(self) -> NDArray:
+        """Log-likelihood evaluated at `samples`."""
+        return self.Lm
+
+    @property
+    def weights(self) -> NDArray:
+        """Normalized incremental importance weights."""
+        return self.Wm_n
+
+    @property
+    def effective_sample_size(self) -> Optional[float]:
+        """Effective sample size after reweighting the next stage."""
+        return self.ESS
+
+    @property
+    def tempering_parameter(self) -> float:
+        """Tempering parameter beta next stage beta."""
+        return self.beta
+
+    @property
+    def resampled_samples(self) -> Optional[NDArray]:
+        """Samples after importance resampling (before MH mutation)."""
+        return self.Smcap
+
 
-    df1 = pd.DataFrame(mytrace[0][0], columns=names)  # samples from prior
+def recover_trace_samples(mytrace: list[Stage], names: list[str]) -> pd.DataFrame:
+    """Load back the Prior and Posterior samples in the form of a DataFrame
+
+    args:
+        mytrace (list[Stage]): trace file of all samples of all tmcmc stages.
+        names (list[str]): list of parameter names
+
+    returns:
+        (pd.DataFrame) : Prior and Posterior in the trace as a DataFrame
+    """
+
+    df1 = pd.DataFrame(mytrace[0].samples, columns=names)  # samples from prior
     df2 = pd.DataFrame(
-        mytrace[-1][0], columns=names
+        mytrace[-1].samples, columns=names
     )  # samples from last step posterior
 
     # Add a column to identify the source
@@ -152,55 +256,25 @@ def recover_trace_results(mytrace, names) -> pd.DataFrame:
     return combined_df
 
 
-def plot_distribution(combined_df, round_index, save=False, save_dir=None):
-    """Plot OR save the updated distribution of the parameters
-
-    args:
-        combined_df: DataFrame from the trace
-        round_index: int, the i-th model updating for E space
-        save: bool, default=False, if True save the figure
-    """
-
-    # Create the pairplot with density plots on the lower triangle
-    g = sb.pairplot(
-        combined_df,
-        hue="source",
-        palette="Set2",
-        diag_kind="kde",  # Add KDE plots to the diagonal
-    )
-
-    # Add density plots on the lower triangle
-    for i, j in zip(
-        *np.tril_indices_from(g.axes, -1)
-    ):  # Iterate over the lower triangle
-        sb.kdeplot(
-            data=combined_df,
-            x=combined_df.columns[j],
-            y=combined_df.columns[i],
-            hue="source",
-            fill=True,
-            alpha=0.5,
-            ax=g.axes[i, j],
-        )
-
-    if save == True:
-        print("Note: figure saved")
-        plt.savefig(f"{save_dir}/updated_distribution_{round_index}.png")
-    plt.show()
-
-
 # * ----------------------------------- tmcmc
 
 
-def plot_updated_distribution(mytrace, names, save=False):
+def plot_updated_distribution(mytrace, names: list[str], save=False):
+    """Plot the prior and posterior distribution of the parameters
+
+    args:
+        mytrace: trace file of all samples of all tmcmc stages.
+        names (list[str]): list of parameter names
+        save (bool): if True, save the figure
+    """
 
     # Example DataFrames from mytrace
     # names = list(Config.epistemic_domain.keys())
 
     # names = ["Xe_1", "Xe_2", "Xe_3", "Xa1_mu", "Xa2_mu", "Xa1_std", "Xa2_std"]
-    df1 = pd.DataFrame(mytrace[0][0], columns=names)  # samples from prior
+    df1 = pd.DataFrame(mytrace[0].samples, columns=names)  # samples from prior
     df2 = pd.DataFrame(
-        mytrace[-1][0], columns=names
+        mytrace[-1].samples, columns=names
     )  # samples from last step posterior
 
     # Add a column to identify the source
@@ -240,22 +314,19 @@ def plot_updated_distribution(mytrace, names, save=False):
     plt.show()
 
 
-def initial_population(N, all_pars) -> np.ndarray:
+def initial_population(N: float, all_pars: list) -> NDArray:
     """Generates initial population from prior distribution
 
-    Parameters
-    ----------
-    N : float
-        number of particles.
-    all_pars : list of size Np
-        Np is number of parameters
-        all_pars[i] is object of type pdfs
-        all parameters to be inferred.
+    Args:
+        N (float): number of particles.
+
+        all_pars (list) : All the parameters, of size Np, to be updated. `all_pars[i]` is object of type `pdfs`.
 
     Returns
-    -------
-    ini_pop : numpy array of size N x Np
-        initial population.
+        ini_pop (NDArray): the initial population which is a numpy array of size `N x Np`.
+
+    note:
+        `Np` is number of parameters
     """
     ini_pop = np.zeros((N, len(all_pars)))
     for i in range(len(all_pars)):
@@ -263,23 +334,21 @@ def initial_population(N, all_pars) -> np.ndarray:
     return ini_pop
 
 
-def log_prior(s, all_pars):
-    """
-    computes log_prior value at all particles
-    Parameters
-    ----------
-    s : numpy array of size N x Np
-        all particles.
-    all_pars : list of size Np
-        Np is number of parameters
-        all_pars[i] is object of type pdfs
-        all parameters to be inferred.
+def log_prior(
+    s: NDArray, all_pars: list[ProbabilityDensityFun | Distribution]
+) -> float:
+    """Computes log_prior value at all particles
+
+    Args:
+        s (NDArray): numpy array of size (N x Np) of all particles.
+
+        all_pars (list[ProbabilityDensityFun | Distribution]) : All the parameters, of size Np, to be updated. `all_pars[i]` is object of type `pdfs`.
 
     Returns
-    -------
-    log_p : numpy array of size N
-        log prior at all N particles .
+        log_p (NDArray): log prior at all N particles which is a numpy array of size N
 
+    Note:
+        `Np` denotes number of parameters
     """
     log_p = 0
     for i in range(len(s)):
@@ -287,31 +356,23 @@ def log_prior(s, all_pars):
     return log_p
 
 
-def compute_beta_update_evidence(beta, log_likelihoods, log_evidence, prev_ESS):
-    """
-    Computes beta for the next stage and updated model evidence
-
-    Parameters
-    ----------
-    beta : float
-        stage parameter.
-    log_likelihoods : numpy array of size N
-        log likelihood values at all particles
-    log_evidence : float
-        log of evidence.
-    prev_ESS : int
-        effective sample size of previous stage
+def compute_beta_update_evidence(
+    beta: float, log_likelihoods: NDArray, log_evidence: float, prev_ESS: int
+):
+    """Computes beta for the next stage and updated model evidence
 
-    Returns
-    -------
-    new_beta : float
-        stage parameter for next stage.
-    log_evidence : float
-        updated log evidence.
-    Wm_n : numpy array of size N
-        weights of particles for the next stage
-    ESS : float
-        effective sample size of new stage
+    Args:
+        beta (float): stage parameter.
+        log_likelihoods (NDArray): log likelihood values at all particles which is numpy array of size N
+        log_evidence (float): log of evidence.
+        prev_ESS (int): effective sample size of previous stage
+
+    :returns: A 4-tuple ``(new_beta, log_evidence, Wm_n, ESS)`` where:
+        - **new_beta** (*float*): stage parameter for next stage.
+        - **log_evidence** (*float*): updated log evidence.
+        - **Wm_n** (*NDArray*): weights of particles for the next stage.
+        - **ESS** (*float*): effective sample size of new stage.
+    :rtype: tuple[float, float, NDArray, float]
 
     """
     old_beta = beta
@@ -367,24 +428,18 @@ def compute_beta_update_evidence(beta, log_likelihoods, log_evidence, prev_ESS):
     return new_beta, log_evidence, Wm_n, ESS
 
 
-def propose(current, covariance, n):
-    """
-    proposal distribution for MCMC in pertubation stage
+def propose(current: NDArray, covariance: NDArray, n: int) -> NDArray:
+    """Proposal distribution for MCMC in pertubation stage
 
-    Parameters
-    ----------
-    current : numpy array of size Np
-        current particle location
-    covariance : numpy array of size Np x Np
-        proposal covariance matrix
-    n : int
-        number of proposals.
-
-    Returns
-    -------
-    numpy array of size n x Np
-        n proposals.
+    Args:
+        current (NDArray): numpy array of size Np
+            current particle location
+        covariance (NDArray): numpy array of size Np x Np
+            proposal covariance matrix
+        n (int): number of proposals.
 
+    Returns:
+        NDArray: n proposals
     """
     return np.random.multivariate_normal(current, covariance, n)
 
@@ -400,13 +455,12 @@ def MCMC_MH(
     numAccepts: int,
     all_pars: list,
     log_likelihood: callable,
-):
-    """
-    Markov chain Monte Carlo using Metropolis-Hastings which "perturbs" each particle using MCMC-MH
+) -> tuple[NDArray, float, float, int]:
+    """Markov chain Monte Carlo using Metropolis-Hastings which "perturbs" each particle using MCMC-MH
 
     Conduct `Nm_steps` steps of MH for each particle.
 
-    args:
+    Args:
         particle_num (int) : The index of the current particle/parameter vector being evaluated.
 
         Em (NDArray) : proposal covarince matrix which is numpy array of size Nop x Nop
@@ -430,15 +484,13 @@ def MCMC_MH(
 
         log_likelihood (callable): log likelihood function to be defined in main.py.
 
+    :returns: A 4-tuple ``(current, likelihood_current, posterior_current, numAccepts)`` where:
 
-    returns:
-        current (NDArray): perturbed particle location which is numpy array of size Nop;
-
-        likelihood_current (float): log likelihood value at perturbed particle
-
-        posterior_current (float): log posterior value at perturbed particle
-
-        numAccepts (int): total number of accepts during perturbation (MCMC - MH)
+        - **current** (*NDArray*): Perturbed particle location of shape (Nop,).
+        - **likelihood_current** (*float*): Log-likelihood at the perturbed particle.
+        - **posterior_current** (*float*): Log-posterior at the perturbed particle.
+        - **numAccepts** (*int*): Updated total number of accepts.
+    :rtype: tuple[NDArray, float, float, int]
 
     """
     all_proposals = []
@@ -481,6 +533,259 @@ def MCMC_MH(
     return current, likelihood_current, posterior_current, numAccepts
 
 
+# TODO
+def run_tmcmc_vec():
+    """vectorised version of run_tmcmc to be implemented later"""
+    pass
+
+
+def run_tmcmc_updated(
+    N: int,
+    all_pars: list,
+    log_likelihood: callable,
+    status_file_name: str,
+    Nm_steps_max: int = 5,
+    Nm_steps_maxmax: int = 5,
+) -> list[Stage]:
+    """Updated main workflow of running Transitional MCMC
+
+    Solves the "At this point, beta has been updated to the new value, but Postm is still the log-target from the previous beta (except at the very first stage).
+    So Postmcap is inconsistent with the beta you pass into MCMC_MH."
+
+    args:
+        N  (int) : int
+            number of particles to be sampled from posterior
+
+        all_pars (list) : All the parameters, of size Nop, to be updated. `all_pars[i]` is object of type `pdfs`.
+
+        log_likelihood (callable): log likelihood function to be defined in main.py as is problem specific
+
+        status_file_name (str): name of the status file to store status of the tmcmc sampling
+
+        Nm_steps_max (int, optional): Numbers of MCMC steps for perturbation. The default is 5.
+
+        Nm_steps_maxmax (int, optional): Numbers of MCMC steps for perturbation. The default is 5.
+
+    returns:
+        list[Stage]: the trace that contains all iterations of the Stage instances.
+    """
+    parallel_processing = "multiprocessing"
+
+    # side note: make all_pars as ordered dict in the future
+    # Initialize (beta, effective sample size)
+    beta = 0
+    ESS = N
+    mytrace = []
+    stage_num = 0
+    start_time_global = time.time()
+
+    # Initialize other TMCMC variables
+    Nm_steps = Nm_steps_max
+    parallelize_MCMC = True
+    Adap_calc_Nsteps, Adap_scale_cov = "yes", "yes"  # yes or no
+    scalem = 1  # cov scale factor
+    log_evidence = 0  # model evidence
+
+    # initial samples -> array (N, Np)
+    Sm = initial_population(N, all_pars)
+
+    # Evaluate posterior at Sm
+    Priorm = np.array([log_prior(s, all_pars) for s in Sm]).squeeze()
+    Postm = Priorm  # prior = post for beta = 0
+
+    status_file = open(status_file_name, "a+")
+
+    # Evaluate log-likelihood at current samples Sm
+    if parallelize_MCMC:
+        iterables = [(ind, Sm[ind]) for ind in range(N)]
+        status_file.write("======================== \n")
+        if parallel_processing == "multiprocessing":
+            status_file.write("using multiprocessing \n")
+            import multiprocessing as mp
+            from multiprocessing import Pool
+
+            pool = Pool(processes=mp.cpu_count() - 2)
+            Lmt = pool.starmap(log_likelihood, iterables)
+
+        else:
+            raise (
+                AssertionError(
+                    "parallel_processing invalid, should be either multiprocessing or mpi"
+                )
+            )
+        status_file.write("======================== \n")
+        Lm = np.array(Lmt).squeeze()
+    else:
+        Lm = []
+        for ind in range(N):
+            Lm.append(log_likelihood(ind, Sm[ind]))
+            logging.info(
+                f"Computing likelihood stage {stage_num}: particle:{ind + 1}/{N}"
+            )
+        Lm = np.array(Lm).squeeze()
+    status_file.close()
+
+    while beta < 1:
+        stage_num += 1
+        start_time_stage = time.time()
+
+        # adaptivly compute beta s.t. ESS = N/2 or ESS = 0.95*prev_ESS
+        # plausible weights of Sm corresponding to new beta
+        # logging.info(f"'Computing beta the weights ...")
+
+        beta_old = beta
+        beta, log_evidence, Wm_n, ESS = compute_beta_update_evidence(
+            beta, Lm, log_evidence, ESS
+        )
+
+        # NEW: update Postm to match the NEW beta, before resampling / MH
+        Postm = Postm + (beta - beta_old) * Lm
+
+        console.log(
+            f"[bold green]TMCMC Iteration stage {stage_num}: Tempering parameter updated to {beta:.6f}[/bold green]"
+        )
+
+        # Calculate covaraince matrix using Wm_n
+        Cm = np.cov(Sm, aweights=Wm_n, rowvar=0)
+
+        # * --------------------------------------------------------- Resample
+        # Resampling using plausible weights
+        SmcapIDs = np.random.choice(range(N), N, p=Wm_n)
+        # SmcapIDs = resampling.stratified_resample(Wm_n)
+        Smcap = Sm[SmcapIDs]  # Resampled particles
+        Lmcap = Lm[SmcapIDs]
+        Postmcap = Postm[SmcapIDs]
+
+        #  save to trace
+        # stage m: samples, likelihood, weights, next stage ESS, next stage beta, resampled samples
+        mytrace.append(Stage(Sm=Sm, Lm=Lm, Wm_n=Wm_n, ESS=ESS, beta=beta, Smcap=Smcap))
+
+        # TODO: plot updated distribution to fix later on
+        # if stage_num in [2, 4, 6]:
+        #     plot_updated_distribution(mytrace)
+
+        # print to status_file
+        status_file = open(status_file_name, "a+")
+        status_file.write("stage number = %d \n" % stage_num)
+        status_file.write("beta = %.5f \n" % beta)
+        status_file.write("ESS = %d \n" % ESS)
+        status_file.write("scalem = %.2f \n" % scalem)
+
+        # * --------------------------------------------------------- MH Perturb
+        # perform MCMC starting at each Smcap (total: N) for Nm_steps
+        Em = ((scalem) ** 2) * Cm  # Proposal dist covariance matrix
+
+        numProposals = N * Nm_steps
+        numAccepts = 0
+
+        if parallelize_MCMC:
+            iterables = [
+                (
+                    j1,
+                    Em,
+                    Nm_steps,
+                    Smcap[j1],
+                    Lmcap[j1],
+                    Postmcap[j1],
+                    beta,
+                    numAccepts,
+                    all_pars,
+                    log_likelihood,
+                )
+                for j1 in range(N)
+            ]
+
+            if parallel_processing == "multiprocessing":
+                results = pool.starmap(MCMC_MH, iterables)
+
+            # elif parallel_processing == "mpi":
+            #     results = list(executor.starmap(MCMC_MH, iterables))
+        else:
+            """Here we are running Markov-Chain Monte Carlo for each particle"""
+            results = [
+                MCMC_MH(
+                    j1,
+                    Em,
+                    Nm_steps,
+                    Smcap[j1],
+                    Lmcap[j1],
+                    Postmcap[j1],
+                    beta,
+                    numAccepts,
+                    all_pars,
+                    log_likelihood,
+                )
+                for j1 in range(N)
+            ]
+
+        Sm1, Lm1, Postm1, numAcceptsS = zip(*results)
+        Sm1 = np.asarray(Sm1)
+        Lm1 = np.asarray(Lm1)
+        Postm1 = np.asarray(Postm1)
+        numAcceptsS = np.asarray(numAcceptsS)
+        numAccepts = sum(numAcceptsS)
+
+        # total observed acceptance rate
+        R = numAccepts / numProposals
+        status_file.write("acceptance rate = %.2f \n" % R)
+
+        # Calculate Nm_steps based on observed acceptance rate
+        if Adap_calc_Nsteps == "yes":
+            # increase max Nmcmc with stage number
+            Nm_steps_max = min(Nm_steps_max + 1, Nm_steps_maxmax)
+            status_file.write("adapted max MCMC steps = %d \n" % Nm_steps_max)
+
+            acc_rate = max(1.0 / numProposals, R)
+            Nm_steps = min(
+                Nm_steps_max, 1 + int(np.log(1 - 0.99) / np.log(1 - acc_rate))
+            )
+            status_file.write("next MCMC Nsteps = %d \n" % Nm_steps)
+
+        status_file.write("log_evidence till now = %.20f \n" % log_evidence)
+        status_file.write(
+            "--- Execution time: %.2f mins --- \n"
+            % ((time.time() - start_time_stage) / 60)
+        )
+        status_file.write("======================== \n")
+        status_file.close()
+
+        # scale factor based on observed acceptance ratio
+        if Adap_scale_cov == "yes":
+            scalem = (1 / 9) + ((8 / 9) * R)
+
+        # for next beta
+        Sm, Postm, Lm = Sm1, Postm1, Lm1
+
+    # save to trace, which is the last stopping stage
+    mytrace.append(
+        Stage(
+            Sm=Sm,
+            Lm=Lm,
+            Wm_n=np.ones(len(Wm_n)) / len(Wm_n),
+            ESS=None,
+            beta=1.0,
+            Smcap=None,
+        )
+    )
+
+    status_file = open(status_file_name, "a+")
+    status_file.write(
+        "--- Execution time: %.2f mins --- \n"
+        % ((time.time() - start_time_global) / 60)
+    )
+    status_file.write("log_evidence = %.20f \n" % log_evidence)
+
+    if parallelize_MCMC:
+        if parallel_processing == "multiprocessing":
+            status_file.write("closing multiprocessing \n")
+            pool.close()
+
+    status_file.close()
+
+    if parallel_processing == "multiprocessing":
+        return mytrace
+
+
 def run_tmcmc(
     N: int,
     all_pars: list,
@@ -488,7 +793,6 @@ def run_tmcmc(
     status_file_name: str,
     Nm_steps_max: int = 5,
     Nm_steps_maxmax: int = 5,
-    parallel_processing: str = "multiprocessing",
 ):
     """Main workflow of running Transitional MCMC
 
@@ -496,10 +800,7 @@ def run_tmcmc(
         N  (int) : int
             number of particles to be sampled from posterior
 
-        all_pars (list) : list of (size Nop) prior distributions instances
-            Nop is number of epistemic parameters
-            all_pars[i] is object of type pdfs
-            all parameters to be inferred
+        all_pars (list) : All the parameters, of size Nop, to be updated. `all_pars[i]` is object of type `pdfs`.
 
         log_likelihood (callable): log likelihood function to be defined in main.py as is problem specific
 
@@ -512,11 +813,12 @@ def run_tmcmc(
         parallel_processing (str): should be either 'multiprocessing' or 'mpi'
 
     returns:
-        mytrace: returns trace file of all samples of all tmcmc stages.
-            at stage m: it contains [Sm, Lm, Wm_n, ESS, beta, Smcap]
-            comm: if parallel_processing is mpi
-
+        a tuple containing:
+            mytrace: returns trace file of all samples of all tmcmc stages.
+                at stage m: it contains [Sm, Lm, Wm_n, ESS, beta, Smcap]
     """
+    parallel_processing = "multiprocessing"
+
     # side note: make all_pars as ordered dict in the future
     # Initialize (beta, effective sample size)
     beta = 0
@@ -590,15 +892,15 @@ def run_tmcmc(
         # Calculate covaraince matrix using Wm_n
         Cm = np.cov(Sm, aweights=Wm_n, rowvar=0)
 
-        # Resample ###################################################
+        # * --------------------------------------------------------- Resample
         # Resampling using plausible weights
         SmcapIDs = np.random.choice(range(N), N, p=Wm_n)
         # SmcapIDs = resampling.stratified_resample(Wm_n)
-        Smcap = Sm[SmcapIDs]
+        Smcap = Sm[SmcapIDs]  # Resampled particles
         Lmcap = Lm[SmcapIDs]
         Postmcap = Postm[SmcapIDs]
 
-        # save to trace
+        #  save to trace
         # stage m: samples, likelihood, weights, next stage ESS, next stage beta, resampled samples
         mytrace.append([Sm, Lm, Wm_n, ESS, beta, Smcap])
 
@@ -613,7 +915,7 @@ def run_tmcmc(
         status_file.write("ESS = %d \n" % ESS)
         status_file.write("scalem = %.2f \n" % scalem)
 
-        # Perturb ###################################################
+        # * --------------------------------------------------------- MH Perturb
         # perform MCMC starting at each Smcap (total: N) for Nm_steps
         Em = ((scalem) ** 2) * Cm  # Proposal dist covariance matrix
 
@@ -698,7 +1000,7 @@ def run_tmcmc(
         # for next beta
         Sm, Postm, Lm = Sm1, Postm1, Lm1
 
-    # save to trace
+    # save to trace, which is the last stopping stage
     mytrace.append([Sm, Lm, np.ones(len(Wm_n)) / len(Wm_n), "notValid", 1, "notValid"])
 
     status_file = open(status_file_name, "a+")
@@ -716,7 +1018,7 @@ def run_tmcmc(
     status_file.close()
 
     if parallel_processing == "multiprocessing":
-        return mytrace, None
+        return mytrace
 
 
 # * ----------------------------------- likelihood
@@ -737,9 +1039,10 @@ def log_likelihood(
 
         param_vec (array-like): indeed a 1d epistemic_param_vec, the parameter vector, i.e. epistemic_domain
 
-    Note:
+
+    note:
         Gaussian approximate likelihood function is implemented here. Other likelihood functions such as
-        "pseudo" and "vae" are underway.
+        "pseudo" and "vae" are underway. `sam_id` is not used here, but it is required in the main `run_tmcmc` workflow
     """
 
     if which_likelihood_calculator == "gaussian":
@@ -808,3 +1111,104 @@ def gaussian_likelihood_fun(
     log_likelihood = -((dissimilarity / eps_scale) ** 2)  # np.exp(-dissimilarity)
 
     return log_likelihood
+
+
+# * ----------------------------------- helper functions
+
+
+def get_top_samples(trace, top_num=20):
+    """Get the top posterior samples based on likelihood values."""
+    posterior_samples = trace[-1].samples  # shape (N, 8)
+    likelihoods = trace[-1].log_likelihoods  # shape (N,)
+
+    # Select top 20% samples by likelihood
+    top_indices = np.argsort(likelihoods)[-top_num:]
+    top_samples = posterior_samples[top_indices]
+    return top_samples
+
+
+def get_posterior_samples(trace: list[Stage]) -> NDArray:
+    """Get the posterior particles of the last stage from the trace.
+
+    args:
+        trace (list[Stage]): trace object.
+    """
+    posterior_samples = trace[-1].samples  # shape (N, 8)
+    return posterior_samples
+
+
+def hdi_1d(x: NDArray, cred_mass=0.95) -> tuple[float, float]:
+    """Obtain the highest density interval (HDI) from particles
+
+    args:
+        x (NDArray): 1D array of samples.
+        cred_mass (float): Credible mass for the HDI.
+
+    returns:
+        tuple: Lower and upper bounds of the HDI.
+    """
+    x = np.asarray(x, dtype=float)
+    x = x[np.isfinite(x)]
+    if x.size == 0:
+        return (np.nan, np.nan)
+
+    x = np.sort(x)
+    n = x.size
+    m = int(np.floor(cred_mass * n))
+    if m < 1:
+        return (np.nan, np.nan)
+
+    low = x[: n - m]
+    high = x[m:]
+    widths = high - low
+    j = np.argmin(widths)
+
+    return (low[j], high[j])
+
+
+def get_hdi_bounds(
+    data: pd.DataFrame | NDArray, levels=(0.99, 0.95, 0.20, 0.10, 0.05)
+) -> pd.DataFrame:
+    """Compute HDI bounds for each column in `data`
+
+    args:
+        data (pd.DataFrame | NDArray): posterior samples (shape: n_samples x n_vars).
+        levels (tuple): A tuple of high density intervalc levels.
+
+    returns:
+        pd.DataFrame: DataFrame with HDI bounds for each column and level.
+    """
+    # Normalize input
+    if isinstance(data, pd.DataFrame):
+        values = data.to_numpy()
+        columns = data.columns
+    else:
+        values = np.asarray(data)
+        if values.ndim != 2:
+            raise ValueError("Input array must be 2D (n_samples, n_columns)")
+        columns = [f"col_{i}" for i in range(values.shape[1])]
+
+    out = {}
+
+    for j, col in enumerate(columns):
+        col_vals = values[:, j]
+        for lvl in levels:
+            lo, hi = hdi_1d(col_vals, cred_mass=lvl)
+            p = int(round(lvl * 100))
+            out.setdefault(f"hdi_{p}_low", {})[col] = lo
+            out.setdefault(f"hdi_{p}_high", {})[col] = hi
+
+    return pd.DataFrame(out).rename_axis("column").reset_index()
+
+
+def transform_old_trace_to_new(trace: list[list]) -> list[Stage]:
+    """Transform old trace format to new Stage class format.
+
+    args:
+        trace (list[list]): Old trace instance which is list of lists, where each inner list contains:
+            [Sm, Lm, Wm_n, ESS, beta, Smcap]
+
+    returns:
+        list[Stage]: New trace instance which is list of Stage class instances.
+    """
+    return [Stage(*i) for i in trace]
diff --git a/src/pyuncertainnumber/characterisation/uncertainNumber.py b/src/pyuncertainnumber/characterisation/uncertainNumber.py
index 5dafebd1..b1a73786 100644
--- a/src/pyuncertainnumber/characterisation/uncertainNumber.py
+++ b/src/pyuncertainnumber/characterisation/uncertainNumber.py
@@ -611,6 +611,15 @@ def JSON_dump(self, filename="UN_data.json"):
         with open(filepath, "w") as fp:
             json.dump(self, fp, cls=UNEncoder, indent=4)
 
+    # * ---------------------other functions---------------------*#
+    def to_pbox(self):
+        """convert the UN object to a pbox object"""
+
+        from ..pba.operation import convert
+
+        pbox = convert(self._construct)
+        return pbox
+
 
 # * ---------------------shortcuts --------------------- *#
 def makeUNPbox(func):
diff --git a/src/pyuncertainnumber/pba/distributions.py b/src/pyuncertainnumber/pba/distributions.py
index 61ecf448..a8729c2e 100644
--- a/src/pyuncertainnumber/pba/distributions.py
+++ b/src/pyuncertainnumber/pba/distributions.py
@@ -27,10 +27,9 @@
 # * --------------------- parametric cases --------------------- *#
 
 
-#! question: is Distribution class necessary?
 @dataclass
 class Distribution(NominalValueMixin):
-    """Two signature are currentlly supported, either a parametric specification or from a nonparametric empirical data set
+    """Two signatures are currentlly supported, either a parametric specification or from a nonparametric empirical data set.
 
     note:
         the nonparametric instasntiation via arrtribute `empirical_data` will be deprecated soon.
@@ -112,6 +111,10 @@ def sample(self, size):
                 "Sampling not supported for sample-approximated distributions"
             )
 
+    def generate_rns(self, N):
+        """generate 'N' random numbers from the distribution"""
+        return self.sample(N)
+
     def alpha_cut(self, alpha):
         """alpha cut interface"""
         return self._dist.ppf(alpha)
@@ -169,6 +172,10 @@ def pdf(self, x: ArrayLike):
         """compute the probability density function (pdf) at x"""
         return self._dist.pdf(x)
 
+    def log_pdf_eval(self, x: ArrayLike):
+        """compute the log of probability density function (pdf) at x"""
+        return self._dist.logpdf(x)
+
     def cdf(self, x: ArrayLike):
         """compute the cumulative distribution function (cdf) at x"""
         return self._dist.cdf(x)
diff --git a/src/pyuncertainnumber/pba/pbox_abc.py b/src/pyuncertainnumber/pba/pbox_abc.py
index f688cd9f..18224e96 100644
--- a/src/pyuncertainnumber/pba/pbox_abc.py
+++ b/src/pyuncertainnumber/pba/pbox_abc.py
@@ -442,7 +442,6 @@ def plot(
         style="box",
         fill_color="lightgray",
         bound_colors=None,
-        # NEW
         bound_styles=None,  # e.g. ("--", ":")
         left_line_kwargs=None,  # e.g. {"linewidth": 2, "alpha": 0.9}
         right_line_kwargs=None,  # e.g. {"linewidth": 2, "alpha": 0.9}
@@ -476,14 +475,15 @@ def plot(
             >>> a.plot(ax=ax, style='simple')  # simple style without fill-in color
             >>> # box style with fill-in color and also customized bound colors
             >>> a.plot(ax=ax, style='box',
-            ... fill_color='lightblue',
-            ... bound_colors = ['lightblue', 'lightblue'],
-            ... bound_styles=("--", ":"),
-            ... alpha=0.5
+            ...     fill_color='lightblue',
+            ...     bound_colors = ['lightblue', 'lightblue'],
+            ...     bound_styles=("--", ":"),
+            ...     alpha=0.5
             ... )
+            >>> # customized left and right bound line styles
             >>> ax = pbox.plot(
-            ... left_line_kwargs={"linestyle": "--", "linewidth": 2},
-            ... right_line_kwargs={"linestyle": ":", "linewidth": 2, "alpha": 0.8},
+            ...     left_line_kwargs={"linestyle": "--", "linewidth": 2},
+            ...     right_line_kwargs={"linestyle": ":", "linewidth": 2, "alpha": 0.8},
             )
 
         """
@@ -1463,10 +1463,22 @@ def div(self, other, dependency="f"):
         return self.mul(1 / other, dependency)
 
     def pow(self, other, dependency="f"):
+        """Exponentiation of uncertain numbers with the defined dependency dependency
+
+        This suggests that the exponent (i.e. `other`) can also be an uncertain number.
+        """
         from .operation import frechet_op, vectorized_cartesian_op
 
         if isinstance(other, Number):
-            return pbox_number_ops(self, other, operator.pow)
+            if self.straddles_zero():
+                from pyuncertainnumber import pba
+
+                itvls = self.to_interval()
+                response = itvls**other
+                return pba.stacking(response)
+            else:
+                return pbox_number_ops(self, other, operator.pow)
+
         if is_un(other):
             other = convert_pbox(other)
 
diff --git a/tests/conftest.py b/tests/conftest.py
new file mode 100644
index 00000000..0011b792
--- /dev/null
+++ b/tests/conftest.py
@@ -0,0 +1,3 @@
+import matplotlib
+
+matplotlib.use("Agg")  # must happen before importing pyplot
diff --git a/tests/pbox_plot.py b/tests/pbox_plot.py
deleted file mode 100644
index 2b959fce..00000000
--- a/tests/pbox_plot.py
+++ /dev/null
@@ -1,17 +0,0 @@
-import matplotlib.pyplot as plt
-from pyuncertainnumber import pba
-
-### pba level ###
-fig, axs = plt.subplots(nrows=2, ncols=4, figsize=(12, 7), layout="constrained")
-# first row
-pba.normal([0, 1], [2, 3]).plot(ax=axs[0, 0], title="N([0,1],[2,3])")
-pba.uniform([0, 1], 3).plot(ax=axs[0, 1], title="U([0,1], 3)")
-pba.beta([0.7, 1], [3, 4]).plot(ax=axs[0, 2], title="Beta([0.7,1],[3,4])")
-pba.gamma([5, 6], 2).plot(ax=axs[0, 3], title="Gamma([5,6],2)")
-
-# second row
-pba.lognormal([2, 3], [1, 5]).plot(ax=axs[1, 0], title="Lognormal([2,3],[1,5])")
-pba.expon([0.4, 0.6]).plot(ax=axs[1, 1], title="Exp([0.4, 0.6])")
-pba.chi2([20, 50]).plot(ax=axs[1, 2], title="Chisquared([20, 50])")
-pba.cauchy([1, 100], 1).plot(ax=axs[1, 3], title="Cauchy([1,100], 1)")
-plt.show()
diff --git a/tests/test_construction.py b/tests/test_construction.py
index 483a1159..f7a4344f 100644
--- a/tests/test_construction.py
+++ b/tests/test_construction.py
@@ -5,8 +5,9 @@
 def test_single_parameter_construction():
     # single-parameter distribution
     a = pba.pareto(2.62)
-    b = pba.D("pareto", 2.62)
-    b.to_pbox()
-    c = UN(essence="distribution", distribution_parameters=["pareto", 2.62])
+    b_d = pba.D("pareto", 2.62)
+    b = b_d.to_pbox()
+    c_UN = UN(essence="distribution", distribution_parameters=["pareto", 2.62])
+    c = c_UN.to_pbox()
 
     assert a == b and b == c and a == c, "Single-parameter construction problem"
diff --git a/tests/test_epistemic_propagation.py b/tests/test_epistemic_propagation.py
index 1cb2a29a..7c216bd9 100644
--- a/tests/test_epistemic_propagation.py
+++ b/tests/test_epistemic_propagation.py
@@ -5,6 +5,9 @@
 from pyuncertainnumber import b2b, pba
 from pyuncertainnumber.propagation.performance import foo_universal
 
+""" Note
+
+Some tests are commented out for automation but can run local tests """
 
 # * ------------------------------ b2b level
 
@@ -62,39 +65,39 @@ def test_b2b_level_subinterval_strategy(example_intervals):
     assert y22 == pba.I(13.0, 148.0)
 
 
-def test_b2b_level_ga_opt_strategy(example_intervals):
-    a, b, c = example_intervals
-    # optimisation - ga
-    y3 = b2b(
-        vars=[a, b, c],
-        func=foo_universal,
-        interval_strategy="ga",
-    )
+# def test_b2b_level_ga_opt_strategy(example_intervals):
+#     a, b, c = example_intervals
+#     # optimisation - ga
+#     y3 = b2b(
+#         vars=[a, b, c],
+#         func=foo_universal,
+#         interval_strategy="ga",
+#     )
 
-    assert 12 <= y3.lo and y3.hi <= 149
+#     assert 12 <= y3.lo and y3.hi <= 149
 
 
-def test_b2b_level_ba_opt_strategy(example_intervals):
-    a, b, c = example_intervals
+# def test_b2b_level_ba_opt_strategy(example_intervals):
+#     a, b, c = example_intervals
 
-    y3 = b2b(
-        vars=[a, b, c],
-        func=foo_universal,
-        interval_strategy="bo",
-    )
+#     y3 = b2b(
+#         vars=[a, b, c],
+#         func=foo_universal,
+#         interval_strategy="bo",
+#     )
 
-    assert 12 <= y3.lo and y3.hi <= 149
+#     assert 12 <= y3.lo and y3.hi <= 149
 
 
-def test_b2b_level_cauchy_deviate_strategy(example_intervals):
-    a, b, c = example_intervals
+# def test_b2b_level_cauchy_deviate_strategy(example_intervals):
+#     a, b, c = example_intervals
 
-    y5 = b2b(
-        vars=[a, b, c],
-        func=foo_universal,
-        interval_strategy="cauchy_deviate",
-        n_sam=1000,
-    )
+#     y5 = b2b(
+#         vars=[a, b, c],
+#         func=foo_universal,
+#         interval_strategy="cauchy_deviate",
+#         n_sam=1000,
+#     )
 
 
 # * ------------------------------ high level
diff --git a/tests/test_frechet_arithmetic_vec.py b/tests/test_frechet_arithmetic_vec.py
deleted file mode 100644
index e4772f90..00000000
--- a/tests/test_frechet_arithmetic_vec.py
+++ /dev/null
@@ -1,36 +0,0 @@
-"""to verify the arithmetic operations on Frechet ops on a new vectorised implementation
-
-hint: this verifies that new vectorised operations match the old reference implementation
-"""
-
-from pyuncertainnumber import pba
-from pyuncertainnumber.pba.pbox_abc import inspect_pbox
-
-a = pba.normal([4, 5], 1)  # positive
-# b = pba.uniform([3, 4], [7, 8])  # positive
-
-# a = pba.normal([1, 2], 1)  # straddles zero
-b = pba.uniform([-3, -2], [3, 4])  # straddles 0
-
-
-### + ###
-c_ref_add = a + b
-c_new_add = a.vec_add(b, dependency="f")
-assert c_ref_add == c_new_add, "Addition operation not matching"
-
-### - ###
-c_ref_sub = a - b
-c_new_sub = a.vec_sub(b, dependency="f")
-assert c_ref_sub == c_new_sub, "Subtraction operation not matching"
-
-### * ###
-c_ref_mul = a * b
-c_new_mul = a.vec_mul(b, dependency="f")
-assert c_ref_mul == c_new_mul, "Multiplication operation not matching"
-
-### / ###
-# c_ref_div = a / b
-# c_new_div = a.vec_div(b, dependency="f")
-# assert c_ref_div == c_new_div, "Division operation not matching"
-
-print("-------test over-------")
diff --git a/tests/test_mix_propagation.py b/tests/test_mix_propagation.py
index b1f0ec19..33b519dc 100644
--- a/tests/test_mix_propagation.py
+++ b/tests/test_mix_propagation.py
@@ -38,12 +38,12 @@ def test_low_level_imc(example_pboxes):
         func=foo_universal,
         dependency=de,
         interval_strategy="direct",
-        n_sam=500,
+        n_sam=10,
     )  # `direct` strategy succeeds
     assert isinstance(t_gau_copula, pun.pba.Pbox)
 
     t1_independence = mix.interval_monte_carlo(
-        vars=[a, b, c], func=foo_universal, interval_strategy="direct", n_sam=10_000
+        vars=[a, b, c], func=foo_universal, interval_strategy="direct", n_sam=10
     )  # `direct` strategy succeeds
 
     assert isinstance(t1_independence, pun.pba.Pbox)
@@ -52,7 +52,7 @@ def test_low_level_imc(example_pboxes):
         vars=[a, b, c],
         func=foo_universal,
         interval_strategy="endpoints",
-        n_sam=1e4,
+        n_sam=10,
     )  # `endpoints` strategy succeeds (expects foo_vec)
     assert isinstance(t1, pun.pba.Pbox)
 
@@ -60,7 +60,7 @@ def test_low_level_imc(example_pboxes):
         vars=[a, b, c],
         func=foo_universal,
         interval_strategy="subinterval",
-        n_sam=1000,
+        n_sam=10,
         n_sub=10,
         subinterval_style="endpoints",
     )  # `subinterval` strategy succeeds
@@ -71,7 +71,7 @@ def test_low_level_imc(example_pboxes):
 def test_low_level_slicing(example_pboxes):
     a, b, c = example_pboxes
     t3 = mix.slicing(
-        vars=[a, b, c], func=foo_universal, interval_strategy="endpoints", n_slices=30
+        vars=[a, b, c], func=foo_universal, interval_strategy="endpoints", n_slices=10
     )  # `endpoints` strategy succeeds
 
     assert isinstance(t3, pun.pba.Pbox)
diff --git a/tests/test_pbox.py b/tests/test_pbox.py
index f1a913e4..6425c2cd 100644
--- a/tests/test_pbox.py
+++ b/tests/test_pbox.py
@@ -26,14 +26,12 @@ def test_interval_aggregation():
     upper_endpoints = np.random.uniform(0.5, 1.5, 7)
     m_weights = [0.1, 0.1, 0.25, 0.15, 0.1, 0.1, 0.2]
     # a list of nInterval objects
-    nI = [pun.I(*couple) for couple in zip(lower_endpoints, upper_endpoints)]
+    nI = [pba.I(*couple) for couple in zip(lower_endpoints, upper_endpoints)]
 
-    pbox_mix = stochastic_mixture(
-        *nI, weights=m_weights, display=True, return_type="pbox"
-    )
+    pbox_mix = stochastic_mixture(*nI, weights=m_weights)
     print("the result of the mixture operation")
     assert isinstance(
-        pbox_mix, UN
+        pbox_mix, Pbox
     ), "Failed to aggregate weights intervals expert opinions into Pbox objects"
 
 
diff --git a/tests/test_sobol.py b/tests/test_sobol.py
index 3c179f23..4e6ed890 100644
--- a/tests/test_sobol.py
+++ b/tests/test_sobol.py
@@ -24,7 +24,12 @@ def my_model(x):
 
     # 3. Run the analysis
     results = sobol_analysis(
-        inputs, my_model, calc_second_order=True, print_to_console=True, N=512
+        inputs,
+        my_model,
+        plot_results=False,
+        calc_second_order=True,
+        print_to_console=True,
+        N=512,
     )
 
     # 4. Print results for the first output
diff --git a/tests/test_tmcmc_2dof.py b/tests/test_tmcmc_2dof.py
index 5cfc7ea5..7c3dc0b4 100644
--- a/tests/test_tmcmc_2dof.py
+++ b/tests/test_tmcmc_2dof.py
@@ -3,11 +3,10 @@
 """
 
 from numpy.typing import ArrayLike
-
 import numpy as np
-import pytest
 from pyuncertainnumber.calibration import pdfs
 from pyuncertainnumber.calibration.tmcmc import TMCMC
+from pyuncertainnumber import pba
 
 # measurement data:
 # eigen values of first mode
@@ -18,7 +17,7 @@
 data3 = np.array([1.68245252, 1.71103903, 1.57876073, 1.58722342, 1.61878479])
 
 # number of particles (to approximate the posterior)
-N = 1000
+N = 100
 
 # prior distribution of parameters
 k1 = pdfs.Uniform(lower=0.8, upper=2.2)
@@ -27,8 +26,14 @@
 # Required! a list of all parameter objects
 all_pars = [k1, k2]
 
+k1 = pba.Distribution("uniform", (0.8, 2.2))
+k2 = pba.Distribution("uniform", (0.4, 1.2))
+
+# Required! a list of all parameter objects
+all_pars = [k1, k2]
+
 
-def log_likelihood(particle_num: int, s: ArrayLike) -> float:
+def log_likelihood_case3(particle_num: int, s: ArrayLike) -> float:
     """
     Required!
 
@@ -63,20 +68,17 @@ def log_likelihood_case2(particle_num, s):
     """
     Log-likelihood for the 2DOF example - CASE 2 (two eigenvalues λ1 and λ2).
 
-    Parameters
-    ----------
-    particle_num : int
-        Index of the particle (not used in this function, but required by the TMCMC framework).
+    Args:
+        particle_num (int):
+            Index of the particle (not used in this function, but required by the TMCMC framework).
 
-    s : numpy array of shape (2,)
-        Current parameter vector:
-            s[0] = q1 (stiffness parameter 1)
-            s[1] = q2 (stiffness parameter 2)
+        s (ArrayLike): numpy array of shape (2,)
+            Parameter vector in this case:
+                s[0] = q1 (stiffness parameter 1)
+                s[1] = q2 (stiffness parameter 2)
 
-    Returns
-    -------
-    LL : float
-        Log-likelihood value at this parameter vector.
+    returns:
+        LL (float): Log-likelihood value at this parameter vector.
     """
     q1 = s[0]
     q2 = s[1]
@@ -118,11 +120,12 @@ def log_likelihood_case2(particle_num, s):
 def test_2dof_tmcmc(tmp_path):
     """Test TMCMC on 2DOF example"""
     # Use temporary directory for status file
-    status_file = tmp_path / "status_file_2DOF_class.txt"
+    status_file = tmp_path / "status_file_2DOF_case2_pba.txt"
 
     t = TMCMC(
-        N,
-        all_pars,
+        N=N,
+        parameters=all_pars,
+        names=["theta_1", "theta_2"],
         log_likelihood=log_likelihood_case2,
         status_file_name=str(status_file),
     )