From c0e60407aacb320e1cfc7a5e747934abf0073775 Mon Sep 17 00:00:00 2001
From: Olivier Pigeon <olivier.pigeon@rte-france.com>
Date: Thu, 27 Nov 2025 16:54:05 +0100
Subject: [PATCH 1/6] feat(#2): Create enumerations for solver and heat
 equations

Signed-off-by: Olivier Pigeon <olivier.pigeon@rte-france.com>
---
 README.md                                     |   8 +-
 examples/example_solver_intensity.py          |   2 +-
 examples/example_transient.py                 |   3 +-
 examples/example_transient2.py                |   3 +-
 src/thermohl/solver/__init__.py               |  82 ++++--
 src/thermohl/solver/heat_equation_enum.py     |   9 +
 src/thermohl/solver/solver_type.py            |   7 +
 test/functional_test/functional_test.py       |   8 +-
 test/test_shape.py                            |   7 +-
 test/test_solver1t.py                         |   6 +-
 test/test_solver3t.py                         |  10 +-
 .../docs/examples/ex_all_params.ipynb         | 265 ++++++++++--------
 .../docs/examples/ex_steady_1t.ipynb          |   5 +-
 .../docs/examples/ex_steady_3t.ipynb          | 247 ++++++++--------
 .../docs/examples/ex_transient_3t.ipynb       | 244 +++++++++-------
 thermohl-docs/docs/getting-started.md         |   8 +-
 16 files changed, 525 insertions(+), 389 deletions(-)
 create mode 100644 src/thermohl/solver/heat_equation_enum.py
 create mode 100644 src/thermohl/solver/solver_type.py

diff --git a/README.md b/README.md
index 6858a92..dab8f90 100644
--- a/README.md
+++ b/README.md
@@ -1,4 +1,4 @@
-<!--
+from thermohl.solver import HeatEquationType<!--
 SPDX-FileCopyrightText: 2025 RTE (https://www.rte-france.com)
 
 This Source Code Form is subject to the terms of the Mozilla Public
@@ -138,8 +138,9 @@ surface temperature (°C) of a conductor in steady-state regime along with the c
 
 ```python
 from thermohl import solver
+from thermohl.solver.heat_equation_enum import HeatEquationType
 
-slvr = solver.ieee(dic=None, heateq='1t')
+slvr = solver.ieee(dic=None, heat_equation=HeatEquationType.HEAT_EQUATION_ONE_TEMPERATURE)
 temp = slvr.steady_temperature() 
 ```
 
@@ -161,8 +162,9 @@ distinct ampacities (and the lower the ambient temperature, the higher the ampac
 ```python
 import numpy as np
 from thermohl import solver
+from thermohl.solver.heat_equation_enum import HeatEquationType
 
-slvr = solver.ieee(dict(Ta=np.array([0., 15., 30.])), heateq='1t')
+slvr = solver.ieee(dict(Ta=np.array([0., 15., 30.])), heat_equation=HeatEquationType.HEAT_EQUATION_ONE_TEMPERATURE)
 Tmax = 80.
 imax = slvr.steady_intensity(Tmax)
 ```
diff --git a/examples/example_solver_intensity.py b/examples/example_solver_intensity.py
index f497a97..2531e58 100644
--- a/examples/example_solver_intensity.py
+++ b/examples/example_solver_intensity.py
@@ -16,7 +16,7 @@
 
 
 def test_solve(dct, Trep, tol=1.0e-06, mxi=64):
-    """Given an input dictionnary, a default tolerance and a maximum number of
+    """Given an input dictionary, a default tolerance and a maximum number of
     iterations, compute the surface temperature for the four available models.
     Print compute time, Return a DataFrame with both input and computed
     temperature."""
diff --git a/examples/example_transient.py b/examples/example_transient.py
index 3b973e3..894ea7d 100644
--- a/examples/example_transient.py
+++ b/examples/example_transient.py
@@ -11,6 +11,7 @@
 import numpy as np
 
 from thermohl import solver
+from thermohl.solver.solver_type import SolverType
 
 if __name__ == "__main__":
     import matplotlib
@@ -53,7 +54,7 @@
     plt.show()
 
     # dict with all 4 solvers
-    kys = ["cigre", "ieee", "rte", "rtem"]
+    kys = [SolverType.SOLVER_CIGRE, SolverType.SOLVER_IEEE, SolverType.SOLVER_RTE, SolverType.SOLVER_OLLA]
     slv = dict(
         cigre=solver.cigre(dct),
         ieee=solver.ieee(dct),
diff --git a/examples/example_transient2.py b/examples/example_transient2.py
index a6d1bb9..bd85789 100644
--- a/examples/example_transient2.py
+++ b/examples/example_transient2.py
@@ -11,6 +11,7 @@
 import numpy as np
 
 from thermohl import solver
+from thermohl.solver.solver_type import SolverType
 
 if __name__ == "__main__":
     import matplotlib
@@ -54,7 +55,7 @@
     plt.show()
 
     # dict with all 4 solvers
-    kys = ["cigre", "ieee", "rte", "rtem"]
+    kys = [SolverType.SOLVER_CIGRE, SolverType.SOLVER_IEEE, SolverType.SOLVER_RTE, SolverType.SOLVER_OLLA]
     slv = dict(
         cigre=solver.cigre(dct),
         ieee=solver.ieee(dct),
diff --git a/src/thermohl/solver/__init__.py b/src/thermohl/solver/__init__.py
index 291ae73..eae3d06 100644
--- a/src/thermohl/solver/__init__.py
+++ b/src/thermohl/solver/__init__.py
@@ -15,10 +15,12 @@
 from thermohl.power import olla as ollap
 
 from thermohl.solver.base import Args, Solver
+from thermohl.solver.heat_equation_enum import HeatEquationType
 from thermohl.solver.slv1d import Solver1D
 from thermohl.solver.slv1t import Solver1T
 from thermohl.solver.slv3t import Solver3T
 from thermohl.solver.slv3t_legacy import Solver3TL
+from thermohl.solver.solver_type import SolverType
 
 concreteSolverType = Union[
     Type[Solver1T], Type[Solver3T], Type[Solver3TL], Type[Solver1D]
@@ -30,21 +32,14 @@ def default_values() -> Dict[str, Any]:
 
 
 def _factory(
-    dic: Optional[Dict[str, Any]] = None, heateq: str = "1t", model: str = "ieee"
+    dic: Optional[Dict[str, Any]] = None,
+    heat_equation: HeatEquationType = HeatEquationType.HEAT_EQUATION_ONE_TEMPERATURE,
+    model: SolverType = SolverType.SOLVER_CIGRE,
 ) -> Solver:
     solver: concreteSolverType
-    if heateq == "1t":
-        solver = Solver1T
-    elif heateq == "3t":
-        solver = Solver3T
-    elif heateq == "3tl":
-        solver = Solver3TL
-    elif heateq == "1d":
-        solver = Solver1D
-    else:
-        raise ValueError()
+    solver = create_solver_from_heat_equation(heat_equation)
 
-    if model == "cigre":
+    if model == SolverType.SOLVER_CIGRE:
         return solver(
             dic,
             cigrep.JouleHeating,
@@ -52,7 +47,7 @@ def _factory(
             cigrep.ConvectiveCooling,
             cigrep.RadiativeCooling,
         )
-    elif model == "ieee":
+    elif model == SolverType.SOLVER_IEEE:
         return solver(
             dic,
             ieeep.JouleHeating,
@@ -60,7 +55,7 @@ def _factory(
             ieeep.ConvectiveCooling,
             ieeep.RadiativeCooling,
         )
-    elif model == "olla":
+    elif model == SolverType.SOLVER_OLLA:
         return solver(
             dic,
             ollap.JouleHeating,
@@ -68,7 +63,7 @@ def _factory(
             ollap.ConvectiveCooling,
             ollap.RadiativeCooling,
         )
-    elif model == "rte":
+    elif model == SolverType.SOLVER_RTE:
         return solver(
             dic,
             rtep.JouleHeating,
@@ -80,45 +75,78 @@ def _factory(
         raise ValueError()
 
 
-def cigre(dic: Optional[Dict[str, Any]] = None, heateq: str = "1t") -> Solver:
+def create_solver_from_heat_equation(heat_equation: HeatEquationType):
+    if heat_equation == HeatEquationType.HEAT_EQUATION_ONE_TEMPERATURE:
+        solver = Solver1T
+    elif heat_equation == HeatEquationType.HEAT_EQUATION_THREE_TEMPERATURES:
+        solver = Solver3T
+    elif heat_equation == HeatEquationType.HEAT_EQUATION_THREE_TEMPERATURES_LEGACY:
+        solver = Solver3TL
+    elif heat_equation == HeatEquationType.HEAT_EQUATION_1D:
+        solver = Solver1D
+    else:
+        raise ValueError(f"Invalid HeatEquation value {heat_equation.value}")
+
+    return solver
+
+
+def __solver_model(dic: Optional[Dict[str, Any]] = None,
+                   heat_equation: HeatEquationType = HeatEquationType.HEAT_EQUATION_ONE_TEMPERATURE,
+                   model: SolverType = SolverType.SOLVER_CIGRE,
+                   )\
+        -> Solver:
+    """Get a Solver using a given model and heat equation.
+
+       Args:
+           dic (dict | None): Input values. The default is None.
+           heat_equation (HeatEquationType): Input heat equation.
+           model (SolverType): Solver model to use.
+
+       """
+    return _factory(dic, heat_equation=heat_equation, model=model)
+
+
+def cigre(dic: Optional[Dict[str, Any]] = None,
+          heat_equation: HeatEquationType = HeatEquationType.HEAT_EQUATION_ONE_TEMPERATURE)\
+        -> Solver:
     """Get a Solver using CIGRE models.
 
     Args:
         dic (dict | None): Input values. The default is None.
-        heateq (str): Input heat equation.
+        heat_equation (HeatEquationType): Input heat equation.
 
     """
-    return _factory(dic, heateq=heateq, model="cigre")
+    return __solver_model(dic=dic, heat_equation=heat_equation, model=SolverType.SOLVER_CIGRE)
 
 
-def ieee(dic: Optional[Dict[str, Any]] = None, heateq: str = "1t") -> Solver:
+def ieee(dic: Optional[Dict[str, Any]] = None, heat_equation: HeatEquationType = HeatEquationType.HEAT_EQUATION_ONE_TEMPERATURE) -> Solver:
     """Get a Solver using IEEE models.
 
     Args:
         dic (dict | None): Input values. The default is None.
-        heateq (str): Input heat equation.
+        heat_equation (HeatEquationType): Input heat equation.
 
     """
-    return _factory(dic, heateq=heateq, model="ieee")
+    return __solver_model(dic, heat_equation=heat_equation, model=SolverType.SOLVER_IEEE)
 
 
-def olla(dic: Optional[Dict[str, Any]] = None, heateq: str = "1t") -> Solver:
+def olla(dic: Optional[Dict[str, Any]] = None, heat_equation: HeatEquationType = HeatEquationType.HEAT_EQUATION_ONE_TEMPERATURE) -> Solver:
     """Get a Solver using RTE-olla models.
 
     Args:
         dic (dict | None): Input values. The default is None.
-        heateq (str): Input heat equation.
+        heat_equation (HeatEquationType): Input heat equation.
 
     """
-    return _factory(dic, heateq=heateq, model="olla")
+    return __solver_model(dic, heat_equation=heat_equation, model=SolverType.SOLVER_OLLA)
 
 
-def rte(dic: Optional[Dict[str, Any]] = None, heateq: str = "1t") -> Solver:
+def rte(dic: Optional[Dict[str, Any]] = None, heat_equation: HeatEquationType = HeatEquationType.HEAT_EQUATION_ONE_TEMPERATURE) -> Solver:
     """Get a Solver using RTE models.
 
     Args:
         dic (dict | None): Input values. The default is None.
-        heateq (str): Input heat equation.
+        heat_equation (HeatEquationType): Input heat equation.
 
     """
-    return _factory(dic, heateq=heateq, model="rte")
+    return __solver_model(dic, heat_equation=heat_equation, model=SolverType.SOLVER_RTE)
diff --git a/src/thermohl/solver/heat_equation_enum.py b/src/thermohl/solver/heat_equation_enum.py
new file mode 100644
index 0000000..5627d6f
--- /dev/null
+++ b/src/thermohl/solver/heat_equation_enum.py
@@ -0,0 +1,9 @@
+from enum import Enum
+
+class HeatEquationType(Enum):
+
+    HEAT_EQUATION_ONE_TEMPERATURE = "1t",
+    HEAT_EQUATION_THREE_TEMPERATURES = "3t",
+    HEAT_EQUATION_THREE_TEMPERATURES_LEGACY = "3tl",
+    HEAT_EQUATION_1D = "1d"
+
diff --git a/src/thermohl/solver/solver_type.py b/src/thermohl/solver/solver_type.py
new file mode 100644
index 0000000..31ba770
--- /dev/null
+++ b/src/thermohl/solver/solver_type.py
@@ -0,0 +1,7 @@
+from enum import Enum
+
+class SolverType(Enum):
+    SOLVER_CIGRE = "cigre",
+    SOLVER_IEEE = "ieee",
+    SOLVER_OLLA = "olla",
+    SOLVER_RTE = "rte"
\ No newline at end of file
diff --git a/test/functional_test/functional_test.py b/test/functional_test/functional_test.py
index 867d20f..5f969b1 100644
--- a/test/functional_test/functional_test.py
+++ b/test/functional_test/functional_test.py
@@ -13,7 +13,7 @@
 import yaml
 from typing import List, Dict
 
-from thermohl.solver import rte
+from thermohl.solver import rte, HeatEquationType
 
 
 def cable_data(s: str) -> dict:
@@ -66,7 +66,7 @@ def scn2dict(d: dict) -> dict:
 def test_steady_temperature():
     for d in scenario("temperature", "steady"):
         for _, e in d.items():
-            s = rte(scn2dict(e), heateq="3tl")
+            s = rte(scn2dict(e), heat_equation=HeatEquationType.HEAT_EQUATION_THREE_TEMPERATURES_LEGACY)
             r = s.steady_temperature()
 
             assert np.allclose(r["t_surf"], e["T_surf"], atol=0.05)
@@ -77,7 +77,7 @@ def test_steady_temperature():
 def test_steady_ampacity():
     for d in scenario("ampacity", "steady"):
         for _, e in d.items():
-            s = rte(scn2dict(e), heateq="3tl")
+            s = rte(scn2dict(e), heat_equation=HeatEquationType.HEAT_EQUATION_THREE_TEMPERATURES_LEGACY)
             r = s.steady_intensity(T=e["Tmax_cable"])
 
             assert np.allclose(r["transit"], e["I_max"], atol=0.05)
@@ -94,7 +94,7 @@ def test_transient_temperature():
     for d in scenario("temperature", "transient"):
         for _, e in d.items():
             # solver
-            s = rte(scn2dict(e), heateq="3tl")
+            s = rte(scn2dict(e), heat_equation=HeatEquationType.HEAT_EQUATION_THREE_TEMPERATURES_LEGACY)
 
             # initial steady state
             s.args["transit"] = e["I0_cable"]
diff --git a/test/test_shape.py b/test/test_shape.py
index ec39f25..a81828f 100644
--- a/test/test_shape.py
+++ b/test/test_shape.py
@@ -9,13 +9,14 @@
 import pandas as pd
 
 from thermohl import solver
+from thermohl.solver import HeatEquationType, SolverType
 
 
 def _solvers():
     li = []
-    for ht in ["1t", "3t"]:
-        for m in ["rte", "cigre", "ieee", "olla"]:
-            li.append(solver._factory(dic=None, heateq=ht, model=m))
+    for heat_equation in [HeatEquationType.HEAT_EQUATION_ONE_TEMPERATURE, HeatEquationType.HEAT_EQUATION_THREE_TEMPERATURES]:
+        for m in [SolverType.SOLVER_RTE, SolverType.SOLVER_CIGRE, SolverType.SOLVER_IEEE, SolverType.SOLVER_OLLA]:
+            li.append(solver._factory(dic=None, heat_equation=heat_equation, model=m))
     return li
 
 
diff --git a/test/test_solver1t.py b/test/test_solver1t.py
index 99df08d..46f17bc 100644
--- a/test/test_solver1t.py
+++ b/test/test_solver1t.py
@@ -8,14 +8,16 @@
 import numpy as np
 
 from thermohl import solver
+from thermohl.solver import SolverType
+from thermohl.solver.heat_equation_enum import HeatEquationType
 
 _nprs = 123456
 
 
 def _solvers(dic=None):
     return [
-        solver._factory(dic=dic, heateq="1t", model=m)
-        for m in ["rte", "cigre", "ieee", "olla"]
+        solver._factory(dic=dic, heat_equation=HeatEquationType.HEAT_EQUATION_ONE_TEMPERATURE, model=m)
+        for m in [SolverType.SOLVER_RTE, SolverType.SOLVER_CIGRE, SolverType.SOLVER_IEEE, SolverType.SOLVER_OLLA]
     ]
 
 
diff --git a/test/test_solver3t.py b/test/test_solver3t.py
index 891c503..53845ea 100644
--- a/test/test_solver3t.py
+++ b/test/test_solver3t.py
@@ -8,15 +8,17 @@
 import numpy as np
 
 from thermohl import solver
+from thermohl.solver import HeatEquationType
+from thermohl.solver.solver_type import SolverType
 
 _nprs = 123456
 
 
 def _solvers(dic=None):
     return [
-        solver._factory(dic=dic, heateq=he, model=m)
-        for he in ["3t", "3tl"]
-        for m in ["rte", "cigre", "ieee", "olla"]
+        solver._factory(dic=dic, heat_equation=heat_equation, model=m)
+        for heat_equation in [HeatEquationType.HEAT_EQUATION_THREE_TEMPERATURES, HeatEquationType.HEAT_EQUATION_THREE_TEMPERATURES_LEGACY]
+        for m in [SolverType.SOLVER_RTE, SolverType.SOLVER_CIGRE, SolverType.SOLVER_IEEE, SolverType.SOLVER_OLLA]
     ]
 
 
@@ -42,7 +44,7 @@ def test_balance():
 
     for s in _solvers(dic):
         # compute guess with 1t solver
-        s1 = solver._factory(dic=dic, heateq="1t", model="ieee")
+        s1 = solver._factory(dic=dic, heat_equation=HeatEquationType.HEAT_EQUATION_ONE_TEMPERATURE, model=SolverType.SOLVER_IEEE)
         t1 = s1.steady_temperature(
             tol=2.0, maxiter=16, return_err=False, return_power=False
         )
diff --git a/thermohl-docs/docs/examples/ex_all_params.ipynb b/thermohl-docs/docs/examples/ex_all_params.ipynb
index ee2dd04..5436c86 100644
--- a/thermohl-docs/docs/examples/ex_all_params.ipynb
+++ b/thermohl-docs/docs/examples/ex_all_params.ipynb
@@ -1,127 +1,156 @@
 {
  "cells": [
   {
-   "cell_type": "code",
-   "execution_count": 2,
-   "id": "598e692d-d918-4a10-8f57-171c0da12624",
    "metadata": {},
-   "outputs": [],
+   "cell_type": "raw",
    "source": [
-    "import numpy as np\n",
-    "import matplotlib.pyplot as plt\n",
-    "\n",
-    "from thermohl import solver"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 9,
-   "id": "e8f89e34-6e50-4ba0-b805-888a37ce6f51",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def plot_all_params(dic):\n",
-    "    # using 1t heat equation on all power terms model sets, building solvers and\n",
-    "    # solving steady temperature\n",
-    "    models = [\"cigre\", \"ieee\", \"olla\", \"rte\"]\n",
-    "    solvers = [solver._factory(dic, heateq=\"1t\", model=m) for m in models]\n",
-    "    results = [s.steady_temperature(return_power=True) for s in solvers]\n",
-    "\n",
-    "    # plot all\n",
-    "    fig, ax = plt.subplots(nrows=2, ncols=4, figsize=(20, 10))\n",
-    "    for i, key in enumerate([\"transit\", \"Ta\", \"ws\"]):\n",
-    "        ax[0, i].plot(dic[\"hour\"], dic[key])\n",
-    "        ax[0, i].set_title(f\"Input {key}\")\n",
-    "\n",
-    "    ax[0, 3].set_title(\"Conductor temperature\")\n",
-    "    for i, r in enumerate(results):\n",
-    "        ci = f\"C{1 + i}\"\n",
-    "        ax[0, 3].plot(t, r[\"t\"], c=ci, label=models[i])\n",
-    "        for j, p in enumerate([\"P_joule\", \"P_solar\", \"P_convection\", \"P_radiation\"]):\n",
-    "            ax[1, j].plot(t, r[p], c=ci, label=models[i])\n",
-    "            ax[1, j].set_title(f\"{p} (W/m)\")\n",
-    "\n",
-    "    for i in range(ax.shape[0]):\n",
-    "        for j in range(ax.shape[1]):\n",
-    "            ax[i, j].set_xlabel(\"Time (hour)\")\n",
-    "            ax[i, j].grid(True)\n",
-    "    ax[-1, -1].legend()\n",
-    "    %matplotlib inline"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "ec9ffe0a-cc7a-482c-a8bb-303201de6705",
-   "metadata": {},
-   "source": [
-    "We can modify the values of the dictionnary if we don't want to use the default values.\n",
-    "Missing or None values in the input dictionary are replaced with a default value, available using solver.default_values()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 10,
-   "id": "17464075-7c56-4879-9df3-0dc03661d585",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# time array (in hours)\n",
-    "t = np.linspace(0.0, 24, 241)[:-1]\n",
-    "\n",
-    "# input dict, with vrying transit, ambient temperature and wind speed\n",
-    "dic = dict(\n",
-    "    lat=45.2,\n",
-    "    lon=0.0,\n",
-    "    alt=543.0,\n",
-    "    azm=21.0,\n",
-    "    month=6,\n",
-    "    day=20,\n",
-    "    hour=t,\n",
-    "    transit=np.piecewise(t, [t < 12.0, t >= 12.0], [300.0, 600.0]),\n",
-    "    Ta=10.0 + 7.5 * (1 + np.sin(np.pi * (t - 7.0) / 12.0)),\n",
-    "    ws=np.piecewise(t, [t <= 6.0, t > 6.0, t > 12.0, t >= 18.0], [1.0, 2.0, 1.0, 3.0]),\n",
-    "    wa=69,\n",
-    "    al=0.21,\n",
-    "    tb=0.5,\n",
-    "    d=0.0,\n",
-    "    D=3.0e-02,\n",
-    "    a=0.0,\n",
-    "    A=5.69e-04,\n",
-    "    R=6.30e-02,\n",
-    "    alpha=0.9,\n",
-    "    epsilon=0.8,\n",
-    "    RDC20=5.84e-05,\n",
-    "    km=1.02,\n",
-    "    ki=0.01,\n",
-    "    kl=4.0e-03,\n",
-    "    kq=8.0e-07,\n",
-    "    RDCHigh=6.7744e-05,\n",
-    "    RDCLow=5.84e-05,\n",
-    "    THigh=60.0,\n",
-    "    TLow=20.0,\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 11,
-   "id": "2d04dd49-8468-4f1b-bf20-afba2974413f",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "iVBORw0KGgoAAAANSUhEUgAABlIAAANXCAYAAABOvML2AAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjAsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvlHJYcgAAAAlwSFlzAAAPYQAAD2EBqD+naQABAABJREFUeJzs3Qd4k+XXBvC7SfemE0pL2ZRStsjeS5YguHAAivJXwQFO3CCKGzcuRP0QByIgQ/bee0OhrFLogBZaurO+63nShJa20JGd+3ddsW+TN8nzpJh3nPec46LT6XQgIiIiIiIiIiIiIiKiUhSl7yIiIiIiIiIiIiIiIiKBgRQiIiIiIiIiIiIiIqJyMJBCRERERERERERERERUDgZSiIiIiIiIiIiIiIiIysFAChERERERERERERERUTkYSCEiIiIiIiIiIiIiIioHAylERERERERERERERETlYCCFiIiIiIiIiIiIiIioHAykEBERERERERERERERlYOBFCIiIiIiIiIiIiIT+vnnn+Hi4oKzZ89aeyhEZAIMpJDTM2zYdu/eDVuQm5uLt99+G+vXr6/Q+mI9Mf6///7b7GMjIiL73m7UrVtXjv1WNzFHIiIyD3vejhAR2bJTp07hf//7H+rXrw9PT0/4+/ujc+fO+Pzzz5GXlwdHc/HiRfn9vX//fou959atW+V7Xr161WLvaS/mzp2Lzz77zNrDIDNyNeeLE1HVDmSmTJkil3v06GHt4RARkQNtN8SOfXZ2tvH3ZcuW4ffff8eMGTMQEhJivL9Tp05mHDEREdkSHn8QkSNYunQp7rnnHnh4eGDUqFGIi4tDYWEhNm/ejBdffBFHjhzB999/D0cLpIjvb3GxVKtWrSwWSBHvOWbMGAQGBlrkPe0pkHL48GE899xz1h4KmQkDKUREREROYtiwYSV+T0lJkYEUcb84ACMiIiIisjdnzpzB/fffj+joaKxduxa1atUyPjZ+/HgkJCTIQAtVTE5ODnx8fODsxIUG3t7e1h6GzYyDWNqLqEwisu7r64sLFy7Ik0tiOTQ0FC+88AI0Go1xPVHnUqTlf/zxx/JqXrHR9vLyQvfu3WUUujhxdVdZV3iJ9zKcvBKvJ95HEBF+Q4kVkTZJRES2y5G2G4sWLcKgQYMQEREhr+hr0KAB3nnnnRLzICIi59yOiFIuSqUSX3zxhfG+y5cvQ6FQIDg4GDqdznj/k08+iZo1axp/P3nyJEaMGCHvEyV3IiMj5YnPzMzMan12REQffvihzLqeNWtWiSCKQcOGDfHss88af1er1XL/Vuzniv1d8Z346quvoqCgoMTzxP2DBw+WWS233367/O4SZcN+/fXXUu8hMl569eolv5PF99u0adOg1WpLrVfed6x4L/H9fON37sSJE+VjYpzidUW2jfjeFeUY27VrJ9d75JFHyizRO2/ePLRt21aOSWSfP/TQQ3I7U9b2R5RFGzhwIPz8/PDggw+W+TmLcYvsHqFevXrG9yzeA2bOnDnG9wwKCpLf8+fPny/xOmLbJDKGDh48KLdfIkgg/kaGkvUbNmxA+/bt5Ws0adIEq1evLjUO8b7Hjx/HvffeK0u4iW2Q+Bvn5+eXGndlxrRnzx5069ZNjkn8m6jo8ZF4vgjWnTt3zvi5GLa15fXKMZTqL15a82bjEP8+33rrLflZiXFERUXhpZdeKvXvlsyHGSlE5RBfiP3795df3uJARXxxf/LJJ/ILUxwUFCc2oteuXZNXOogvbVF/U2xADx06hPDw8Aq/pziImTlzpnz9u+66C8OHD5f3t2jRwuTzIyIi03KU7YbY0RcHU5MmTZI/xVV9b775JrKysvDRRx9V+XWJiMj+tyOijIs4wbNx40Y888wz8j5xglGcCMrIyMDRo0fRrFkzef+mTZvQtWtXuSzK64i5iZM9Tz/9tAymiJN5S5YskScKAwICqvy5EREtXrxYBjgqWp72sccewy+//IK7774bzz//PHbs2IHp06fj2LFjWLBgQYl1RTaLWG/s2LEYPXo0fvrpJxl8ECfmDd93Isu7Z8+eMkDzyiuvyGwOUUZMnLivKhEYEt+hYkyPPvoo2rRpIwMo//77L5KSktC0aVNMnTpV7qePGzfO+H1r+AzEPr0IsIhgi5hbamqq3FZs2bIF+/btK1GWS4xbfEd36dJFbn/Ky34Q24gTJ06UKg1sCMi/++67eOONN2RwQ3zGly5dwpdffikDAje+55UrV2SQSgQ1REk2sS0Sy7/99pssjfXEE0/ggQcekMcf4vMXgQ8R5ClOvI8IVoj5bd++XQb5xesWD3RVZkzp6ekYMGCAHIcIOhm2pxU5PnrttdfkhQHibyM+G0GsWxVljUME5e688065zRV/b/H3F9t88V7ib7Jw4cIqvRdVko7Iyc2ePVtcNqXbtWuX8b7Ro0fL+6ZOnVpi3datW+vatm1r/P3MmTNyPS8vL11SUpLx/h07dsj7J06caLyve/fu8nYj8V7R0dHG3y9duiSf+9Zbb1Vo/OvWrZPrz5s3rxKzJiIiZ91uFPfRRx/J54pxGeTm5pZa73//+5/O29tbl5+fX+n3ICIix9qOjB8/XhceHm78fdKkSbpu3brpwsLCdDNnzpT3paen61xcXHSff/65/H3fvn08ZiEis8jMzJTfL0OHDq3Q+vv375frP/bYYyXuf+GFF+T9a9euNd4nvivFfRs3bjTel5aWpvPw8NA9//zzxvuee+45uZ74Li6+XkBAQKl97fK+b8V7ie9ngzfffFOu+88//5RaV6vVyp9iOyLWEduV4goLC+V3clxcnC4vL894/5IlS+T64rVv3P688soruqoePwhnz57VKZVK3bvvvlvi/kOHDulcXV1L3C+2TeI15s6da7zv+PHj8j6FQqHbvn278f4VK1aUmqP4/MR9d955Z4n3euqpp+T9Bw4cqPKYvv3221Jzrujx0aBBg0psX2/c7t/4mRnO54mftxrH//3f/8nPZtOmTSXuF+uJ9bds2VLqfcn0WNqL6CZEBLw4EeE/ffp0qfVE+n3t2rWNv4uUT3ElmWjiS0REzsMRthvFr5wTVzuLK9/EPERtXpE+T0REzr0dEWMSVzbHx8cbM0/Elb3ifrEsiCtmxflCwxXShoyTFStWyO0JEZGpiKwA4cZshfIYvidFdkFxIjNFuLGXSmxsrPG7zJB9IcpNFf9uFq/ZoUMH+V1cfL3ySmRVxPz589GyZUuZLXgjkQV4M7t370ZaWhqeeuopWY7MQJSniomJKbNfzI2Zj5X1zz//yKwJkfkhjh8MN5GB2KhRI6xbt67E+iJbQ2RcGIjPVGSHiEwLsT0zMCyXtS0UWZnFiYzH4n/jyo5JlMsSWTzWPj4qaxyiTJv4bMTfr/hcRDaqcONcyDwYSCEqh9jYGNITDWrUqCHTBG8kvoBv1Lhx41L1D4mIyHE5ynZD1HcWB2zipJeoNyzmJFLKBdaxJyIyH3vZjhhOKIqgiWhILEqjiPtEMMUQSBE/xTZEnAQ01NIXJy1//PFHWQpGlJD5+uuvuV0homoT3zWGE9wVIXpYiL5Oos9EceLkujiRLx4vrk6dOqVe48bvZvGcsr6XRXCgqkTPElFKsSoMcyjr/cWJ+Bvn6OrqKvuvVIfogyUC6OJzENuy4jdRnkwEdooT73djQEgcf4i+HzfeJ1RkWyhKYYq/rWFbWNkxiQsU3N3drX58VNY4xFzEOG6ch9j2CzfOhcyDPVKIyiGaKJqS2EAUb75owOa9RESOwRG2G6JOvWj4KA4QRM1lcTAiTuzt3bsXL7/8cpkNM4mIyLm2I6LZrgiMiD4poja9eI+OHTvKEzqi0a84QScCKaJOvzihZSD6vYi+AqJp78qVK2WPFUNd++qewCMi5yX2W8X30uHDhyv1vFtlddzqu7ms79fqsOa5IZEBUfz7uirEcYL4TP/7778yP7Mb+4WU97lW5/O+8W9a2TGV1dPGFMdH5f1bK+9vXtY4xPs0b94cn376aZnPuTEARebBQAqRCYjI8I1EsydxYFH8ioWyUhFvvBKgohtzIiKyX7a63Vi/fr1sbijS4MWVxQZnzpwx2XsQEZH9b0dEBooIpIiASqtWrWRJHZF9Iq7WXb58uTzBNGXKlFLPEyeBxO3111/H1q1b0blzZ3z77beYNm1apcdARGQgmpaL5u7btm2Tgd2biY6OlielxfeoKJVkIEoWipPm4vHKEs8p63vZUAKxOPHdLN6nuMLCQiQnJ5e4T5ywv1VwqLzvb8McxPsbSj8VH1NV5nir9xTjFcEOsV0wZEmYm/jMxfsZJCQkyL+tYVtoijFV5viovM9G/M2FG//uN26Pb0bM5cCBA+jduzfPG1oRS3sRmcDChQtx4cIF4+87d+7Ejh07MGDAgBJfeqJ24qVLl4z3iS/BLVu2lHgtb2/vMr9giYjIcdjqdsNwpVbxK77Egd0333xT7dcmIiLH2Y6IQIoonfLnn38aS32Jq5lFFoq4WlalUpXoKSB6GKjV6hKvIQIq4jkFBQWVmjsR0Y1eeukl+Pj44LHHHpMBkbLKZH3++edyeeDAgfLnZ599VmIdw5X+oo9IZYnXFNl14rvYQHz3/vbbb6XWFd/NIhBdnAgC3ZidMGLECPmdvWDBglKvYdhXF3Mu6/v7tttuQ1hYmAxUF/+OFZkZoqRVVeZoUN57Dh8+XB5LiCD6jdkj4ncRjDA1USKyuC+//FL+NGwLTTGmyhwfic+mrFJf4m8uFP+7i7+3+LtXlOjzIrb7P/zwQ6nH8vLyZKlNMj9mpBCZgKit2aVLF9mcS2ykxAY5ODhYbswNHn30UblhFvWAx44dK+sXio1as2bNjM3RDCl8opmZOCgREfOgoCBZF7OqtTGJiMj22Op2Q5wAE1dMjR49WpZcEVc7/d///Z/JSxcQEZF9b0cMQRJxZfN7771nvF9crStO1IkyMe3atTPev3btWkyYMAH33HOPfA8RVBHbF3GCSpwsJCKqDnGieu7cubjvvvtklsmoUaPkd5g44S2y30SjblFaUBDZc2JfV5zENpRtEgGQX375BcOGDUPPnj0r/f7iu1d8p91xxx2yxKE4oS5eX2R+HDx4sMS6ItjzxBNPyO++vn37ymDJihUrZP+o4l588UX8/fff8ntTfJ+3bdsWGRkZ+Pfff+V3uZiHmLfo6yJ+F5mB4n1Fc3aRgfHBBx/IhuVifiNHjpQBJhFMEtkaEydOrPJnLcYhvPbaa7JZvJubG4YMGSLHIrILJ0+eLAPt4rMUYxKZGyIYNG7cOLzwwgswJfHad955p/zcRTbSnDlz8MADDxj7c5liTJU5PhKfjdiWip5gYhsoSoeJz0Zsdzt06CDHIf6GYjv7xx9/lLrA4GYefvhh/PXXX/LfjmgsLzI6RTBGXDAh7hf/hkQAjcxMR+TkZs+eLb79dLt27TLeN3r0aJ2Pj0+pdd966y25rsGZM2fk7x999JHuk08+0UVFRek8PDx0Xbt21R04cKDU8+fMmaOrX7++zt3dXdeqVSvdihUr5HtFR0eXWG/r1q26tm3byvXE64v3Lc+6devkOvPmzavGp0BERM6y3ShOjEOsL8ZlsGXLFl2HDh10Xl5euoiICN1LL70k31esJ7Y5RERUPY6yHQkLC5PrpqamGu/bvHmzvE+Mp7jTp0/rHn30UV2DBg10np6euqCgIF3Pnj11q1evrsAnRkRUMSdOnNA9/vjjurp168rvMz8/P13nzp11X375pS4/P9+4nkql0k2ZMkVXr149nZubm/wunTx5col1BPFdOWjQoFLv0717d3kr7uDBg/I+8R1Xu3Zt3TvvvKObNWtWqX1tjUaje/nll3UhISE6b29vXf/+/XUJCQnyvcT3c3Hp6em6CRMmyNcT84mMjJTrXL582bjOokWLdLGxsTpXV1f5XmIbY/Dnn3/qWrduLbcT4nv3wQcf1CUlJZV4j/K2Pzcj5ibGpFAoSs1v/vz5ui5dusjXFLeYmBjd+PHjdfHx8SU+v2bNmpV63fI+b/Ee4jVu3DYePXpUd/fdd8u/c40aNeRnlZeXV+r51RlTZY6PsrOzdQ888IAuMDBQPlZ8W3vq1Cldnz595N8iPDxc9+qrr+pWrVpV6jVuNo7CwkLdBx98IB8XryPmLLbd4t9yZmZmmc8h03IR/zF3sIbIUYmItoj0f/TRRyaPrBMRkePhdoOIiKqD2xEiInJ2b7/9tizXJcqn3ZjJQ2RO7JFCRERERERERERERERUDgZSiIiIiIiIiIiIiIiIysFAChERERERERERERERUTnYI4WIiIiIiIiIiIiIiKgczEghIiIiIiIiIiIiIiIqBwMpRERERERERERERERE5XCFA9Bqtbh48SL8/Pzg4uJi7eEQEdkVUeHx2rVriIiIgELB+Dq3KUREVcdtynXcnhARVR23JyVxm0JEZP3tiUMEUsTGJCoqytrDICKya+fPn0dkZCScHbcpRETVx20KtydERKbA7YketylERNbfnjhEIEVE5A0fiL+/f6Wfr1KpsHLlSvTr1w9ubm5wNpw/58/5O/f8Fy5ciMcee8z4XersqrNN4b8nzp/z5/yddf4CtyklcXtSPc7+GXD+nL+zz5/bk5K4Tak6zp/z5/yde/4LTbg9cYhAiiGtUWxMqhpI8fb2ls911n9UnD/nz/k79/wFpohXf5vCf0+cP+fP+Tvr/AVuU0ri9qR6nP0z4Pw5f86f25PiuE2pOs6f8+f8OX9TbU9YaJKIiIiIiIiIiIiIiKgcDKQQERERERERERERERGVg4EUIiIiIiIiIiIiIiKicjCQQkREREREREREREREVA4GUoiIiIiIiIiIiIiIiMrBQAoREREREREREREREVE5GEghIiIiIiIiIiIiIiIqBwMpRERERERERERERERE5WAghYiIiIiIiIiIiIiIyFyBlAsXLuChhx5CcHAwvLy80Lx5c+zevdv4uE6nw5tvvolatWrJx/v06YOTJ0+WeI2MjAw8+OCD8Pf3R2BgIMaOHYvs7OzqDo2IiIiIiBzczJkz0aJFC3ksIW4dO3bEf//9d9PnzJs3DzExMfD09JTHL8uWLSvxeEWOYYiIiIiIyHlUK5By5coVdO7cGW5ubvJg5ejRo/jkk09Qo0YN4zoffvghvvjiC3z77bfYsWMHfHx80L9/f+Tn5xvXEUGUI0eOYNWqVViyZAk2btyIcePGVW9mRERERETk8CIjI/H+++9jz5498oKuXr16YejQofL4oixbt27FyJEj5cVb+/btw7Bhw+Tt8OHDxnUqcgxDRERERETOw7U6T/7ggw8QFRWF2bNnG++rV69eiSu5PvvsM7z++uvyYEb49ddfER4ejoULF+L+++/HsWPHsHz5cuzatQu33XabXOfLL7/EwIED8fHHHyMiIqI6QySyCYVqLVYcScHVPBVsjUajwZEUF1zZeR5KpRLOxtHmf2fLCAR4uVl7GERkAzLzVEhIy0Z6dgEycgrh5a5EsI8HagZ4oH6ILxQKF2sPkcgkhgwZUuL3d999V2apbN++Hc2aNSu1/ueff4477rgDL774ovz9nXfekRd0ffXVVzJwUpFjGCJyTuczcrHhxCXozPw+jnSM4u/piqGtalt7GERkCYk7gEvHADdv/S2gNhAYDXjVAFx47EFOHkj5999/5ZVZ99xzDzZs2IDatWvjqaeewuOPPy4fP3PmDFJSUmQqvEFAQADat2+Pbdu2yYMQ8VOU8zIEUQSxvkKhkFd/3XXXXaXet6CgQN4MsrKy5E+VSiVvlWV4TlWe6wg4f/PPf8G+C3j5n7KvirQNSsw7cwzOy3Hmf3udAHi7+lR4fWf9/57IUYnAybw957El4TKOXMyCrpwzPTW83dC+XjD6xoZjUIta8HSz75M0RMVPPoqyXTk5ObLEV1nE8cekSZNK3CeOaUSQpKLHMGUx5TGKs++fC87+GXD+tjn/Z37fi33nMy30bo5xjFI32BsDm4VV6jm29ncnogrIzQB+Hgho1aUf8woCarcFIm8D6vcAItsBCh5/kJMFUk6fPi2v9hIHIq+++qrMKnnmmWfg7u6O0aNHywMQQVy9VZz43fCY+BkWVnKj6urqiqCgIOM6N5o+fTqmTJlS6v6VK1fC29u7yvMRV6I5M87ffPPfckFE3pWo4a5DHV9zX79Ezmz75g047mHtURCRpW08cQnfbzyNzQmXS9xfO9ALoX4eCPJxR75Kg/TsQpy/kosruSosP5Iib+8uO4aRt0fhsS71UcPH3WpzIKqOQ4cOycCJKL3l6+uLBQsWIDY2tsx1xTHGrY5PDPeVt46ljlGcff9ccPbPgPO3rfmfTxMn/lzQ0F8Ln2qdTXEe/m7ZpfpQEZGDBlJEEMVFCdTrChRcAzKTgOxUIC8DSFilv62frs9QadQfaHkfUK87gypkN6q16ddqtTKT5L333pO/t27dWtYWFinxIpBiLpMnTy5xFZm42kuUGOvXr59sMFlZ4moHsYPWt29f2e/F2XD+5p9/0qYzQOJJ9GhWGx8Oj4Mt4d+f81+0aJG1h0FEVXQuPQfvLDmK1cfS5O+iWlevmHAMblELHRsEI9zfs9RzVBotDiZlyuDLvN3ncTEzH1+vO4XfdiTihX5NMPL2OlCy7BfZmSZNmmD//v3IzMzE33//LY9FRMZ8ecEUWz9Gcfb9E8HZPwPO3zbn//HxTUBBHt67rwNa1wl0uvlbCo9RiOyQtiiTzDMAGFXs/9/CXH25r6Q9wPntQMIaIO8KcPAP/c2/NtBmNNDuMcAn2GrDJzJ7IKVWrVqlDk6aNm2K+fPny+WaNWvKn6mpqXJdA/F7q1atjOukpekP/g3UajUyMjKMz7+Rh4eHvN1I7GBUZyejus+3d5y/+eavKIquKxUKm/2M+fd37vkTkX0RPRxmbT6DD1fEyz5crgoXPNwxGo92roeooJtf+e6mVKBtdA15e7pXQ6w+lorPVp/E8ZRreH3hYRlc+XJkG9QJrnqWL5GliYz4hg0byuW2bdvKTHnRC+W7774rta44xhDHI8WJ3w3HHhU5hrHUMQr3T/gZcP42Nv+i6wxc3VwtMi6bmz8RUXk0RYEU5Q3fWe7e+rJe4tZ+HKBRA0k7gcPzgUPzgKwLwPr3gM0zgNYPAl0m6XurENkgRXWe3LlzZ8THx5e478SJE4iOjjY2nhcHImvWrClxZZbofWKoWSx+Xr16FXv27DGus3btWpntIuoQEzkCXVE7Ql7fS0REpmgi/7//24NpS4/JIErXRiFY/lw3vDWk2S2DKDdyVSpwR1wtLHm6C94eEgs/T1ccSMrEoC83Yfnh8ksYEdk6cSxRvF9JceL4o/jxiSCu/DYcn1TkGIaInJOh9xiP64iIyslIUd6iVLDSFYjuBAz6BHj+BDD8R6BWS0CdB+z6EfiiNbDiNX2pMCJHCqRMnDgR27dvl6W9EhISMHfuXHz//fcYP368fNzFxQXPPfccpk2bJhvTi9rFo0aNQkREBIYNG2bMYLnjjjtkg/qdO3diy5YtmDBhgmziKNYjcqgdbu5xExFRNUt53fnVZqw8mgp3pQLvDG2GXx+9HQ3DfKv1uiKgMqZzPax4rpvMVLmWr8YTc/bg05XxMvuFyJaJklobN27E2bNn5fGG+H39+vV48MEH5ePi+EPcZ/Dss89i+fLl+OSTT3D8+HG8/fbb2L17tzwGqegxDBE5+3EdD+yIiEoQmSaCohLFj9w8gRb3AOM2AKMXA3U6AZoCYNtX+oDK7p8ArcZsQyayaGmvdu3ayUaO4sBk6tSp8uqtzz77zHjQIrz00kvIycnBuHHjZOZJly5d5IGLp+f1mt2//fabPHDp3bs3FAoFRowYgS+++KI6QyOySS68domIiKro6MUsjPppJy5nF8gm8jMfaoMWkaatzx4R6IU/xnXAB/8dx4+bz+CLtQlIzynE1KFx7JtCNkuUCRaBjuTkZAQEBKBFixZYsWKF7C0gJCYmymMMg06dOskLwF5//XW8+uqraNSoERYuXIi4uLhKHcMQkfPiFpGI6AaawrJLe1WECE7X6wbU7QokrAZWvw2kHgaWTAT2/h9w5xdAzeYmHzKRRQMpwuDBg+WtPOJKDRFkEbfyBAUFyYMZIkdluJqXFy4REVFV7DmXgTGzd8lMkaa1/PHLo+0Q5meeE7qih8rrg2NRN8QHbyw6LJvQi3JiM+5rJR8jsjWzZs266eMiO+VG99xzj7xV5xiGiJwPj+uIiG5R2ktRjb5O4su1UV+gfk9g9yxg7TTg4l7g+55Aj1eAzs/pS4MRWQmPhoksgKW9iIioqo5czMSYn/RBlHZ1a8iMEXMFUYp7qEM0vri/NdyULlhyMBmvzD8ErZZlvoiIyHkZtoKsNEBEVE5pr6pkpNxIBEva/w+YsBuIGawP0qx9B/ipP3DlXPVfn6iKGEghsoDrp524w01ERJXriTJaBFEK9EGUXx9tjwAvExycVNCQlhH45sG2sqzX/L1JeG/ZMfZMISIip8UL5IiIbtVs3oTHKn7hwH1zgLu+AzwCgAu7ge+6AseXme49iCqBgRQiC+AONxERVZbohfLQrB3ypyjn9ePodvByV1p8HH1jw/HhiBZyWfRN+X7jaYuPgYiIyBboil0iR0RExWhMUNqrLOJEWsv7gSc2AbXbAvmZwB8jgTVTAa3WtO9FdAsMpBBZcIebcRQiIqoIlUaLp37bi/MZeagT5C17olgyE+VGI9pG4vVBTeXy+8uPY93xNKuNhYiIyFp4gRwR0S0CKebqYVIjGnhkOdD+Sf3vmz4B/nwIKMg2z/sRlYGBFCIL4A43ERFVxrQlR7HzTAZ8PVzx05jbLNIT5VYe61ofD7SvI7dpz/yxD6cv8aCFiIicC3ukEBGZsdn8rbi6AwPe15f6UroD8Uv1fVOyLprvPYmKYSCFyAK4w01ERBX11+7z+GWbvonijPtaoWGYH2zF20Oa4bboGrLx/bj/24PsgqKmkkRERE6AF8gREd0qI8Xd/O8lSn2NWQb4hAGph4FZ/YBLJ8z/vuT0GEghsuAeN3e4iYjoZhLSruHNRYfl8sQ+jWV/Elvi7qrANw+1Qbi/BxLSsvHWoiPWHhIREZEF8biOiOjmzebNVNrrRlHtgMdWA8ENgczz+syUpD2WeW9yWgykEFk0I4WIiKhsBWoNnvl9P/JVWnRtFIKnezWELRJlxr56oA0ULsD8vUlYfICp9ERE5GQZKTyyIyKyTLP5W/VNeXQFENEGyMsAfh0KJO6w3PuT02EghciiKeDc4SYiorJ9vCIeR5OzUMPbDZ/c0xIKEamwUe3qBmFCT32g59UFh5B0JdfaQyIiIrLcBXK2u4kmIrJyaS8LBlIEnxBg9GKgbleg8BowZzhwbptlx0BOg4EUIgvQGXe5iYiIStt66jJ+2HRGLn94d0uE+Vu/ufytPN27EVpFBcp+Kc//dQBaLbd1RETk2HSGks3WHggRkc2W9rJwIEXw8AUe+Auo1w0ozAbmjGBmCpkFAylEFsCmhESmMX36dLRr1w5+fn4ICwvDsGHDEB8fX+6B7oABA2Qm2MKFCy0+VqKKyivU4JX5h+TyyNvr2FxflPK4KRX4/P5W8HZXYseZDPyxO8naQyIiIjIrZqQQEZVDo7Z8aa/i3L2BkX8C9XsAqhxg7j1Air73JJGpMJBCZNEeKdzjJqqODRs2YPz48di+fTtWrVoFlUqFfv36IScnp9S6n332GcvpkV2YsfoEEjNyUSvAE68OjIE9iQ72wYv9m8jlD1eewNUCa4+IiIjI/BfIMSeFiMiGMlKKB1PunwtEtQfyM4H/uwvIOGW98ZDDYSCFyAKYkUJkGsuXL8eYMWPQrFkztGzZEj///DMSExOxZ8+eEuvt378fn3zyCX766SerjZWoIg4mXcWPm07L5XfvioOfpxUPPKpoVMe6aF0nEDkFGvx1RmEse0JEROSwpb14XEdEVJKm0LoZKQbuPvoyX+HNgZw0uP5+L9xVWdYdEzkMV2sPgMgZsJYukXlkZmbKn0FBQcb7cnNz8cADD+Drr79GzZo1b/kaBQUF8maQlaXfyRLZLuJWGYb1K/s8R8H5V27+ao0WL/19EKK1yODmNdG1QZDdfnbv3hmLO7/ZhiNXFFhy8CKGtKwNZ+Ps//6dfe5E5GQXyFl7IEREtlraS2kDp5q9AoGH/wFm9YXLlbNoXzgDUA0F3OzvojWyLTbwr5vI8bGWLpHpabVaPPfcc+jcuTPi4uKM90+cOBGdOnXC0KFDK9x3ZcqUKaXuX7lyJby9vas0NlF2zJlx/hWb/6YUFxxPUcJbqUNHjyQsW2bfPUb6RCiwPEmBqf8ehjrxADyUcErO/u+fiMg5jut4YEdEVHZpL3fYBN8w4MH50M3qg6DcU9AuehK47/8ABYszUdUxkEJkwYwUBXe4iUxG9Eo5fPgwNm/ebLzv33//xdq1a7Fv374Kv87kyZMxadKkEhkpUVFRsveKv79/pa/GFidR+/btCzcnvNqF86/4/DNyCvHm5+LfrhovDWiKe9vXgb3rmpuPnZ9uQEaBC854NcKkPo3gTJz937/hM1i0aJG1h0FEZIHjOmuPhIjIxmhUtlHaq7iQhtDc/Stc5twFZfwSYN00oPeb1h4V2TEGUogswFgunjvcRCYxYcIELFmyBBs3bkRkZKTxfhFEOXXqFAIDA0usP2LECHTt2hXr168v9VoeHh7ydiNxIrSqJ0Or81xHwPnfev6frzuOzDw1mtbyx8Od6kPpAGdk/LyBYdFa/HRCiVmbz+H+26NlM3pn4+z//omIHNn1wzr7324TEZknI8W2TjXr6nTEgTpj0fbcd8CmT4BaLYHYilWvILoR85mILIA73ESmuwpQBFEWLFgggyb16tUr8fgrr7yCgwcPymbzhpswY8YMzJ4920qjJirp8IVM/L4zUS5PubOZQwRRDFoE6dC5QTAKNVq8s+SYtYdDRERknh4pjrPpJiJy3IyUIklBnaFp/6T+lwVPAqlHrT0kslMMpBBZAHe4iUxXzmvOnDmYO3cu/Pz8kJKSIm95eXnycdFcXvRLKX4T6tSpUyroQmStYOC7S4/J7cKdLSNwe70gOBKxnXtjUAxcFS5YfSwV20+nW3tIREREJqMzXiJHRERlBlJspUfKDbS93gLqdQdUOcCfDwL5WdYeEtkhBlKILLjDzTgKUfXMnDkTmZmZ6NGjB2rVqmW8/fnnn9YeGlGFrD9xCdtOp8NdqcBLdzSBI2oQ6oORt+t7vkxfJoJGPOlERESOgRfIERHZV2kvI4UrcPdsICAKyDgNLH62WB1+oophIIXIArjDTWQa4oRsWbcxY8bc9DnDhg2z6DiJyqLR6vDBf8fl8uhO0Yis4Q1H9UzvRvBxV+JAUiaWHkq29nCIiIhMW7KZB3ZERCVp1DZb2svIJ1gfTBFBlSP/AHt+tvaIyM4wkEJkQeyRQkTkvBbsu4DjKdfg7+mK8T0bwpGF+nng8W715fJHK+JRqNZae0hERETVZ7hAztrjICKyNZpC/U+lDQdShKh2QO+39Mv/vQykHLb2iMiOMJBCZAGGsia8cImIyDkVqDX4dGW8XH6qZ0MEettm7WBTerxrfYT4euBcei7+2JVo7eEQERGZrmQzj+uIiMop7WUHxzkdJwCN+gGaAuCfxwFVvrVHRHaCgRQiS6aAW3kcRERkHX/tOo+Lmfmo6e+JMZ3qwhn4eLji2d76zJuv1yUgX6Wx9pCIiIhMU7KZR3ZEROWU9rLRHinFKRTAsJmATyiQdhRYN83aIyI7wUAKkQUY+1fx0iUiIqfMRvlm/Sm5/FTPBvB0U8JZ3NsuCrUDvZCaVYC5O5iVQkRE9o2HdUREt8pIsfHSXgY+IcCQL/TLW78Czm629ojIDjCQQmTJFHBrD4SIiCxu3u4kJGfmI9zfA/feFgVn4uGqNPaDmbnhFPIKmZVCREQOULLZ2gMhm/H222/DxcWlxC0mJsb4eH5+PsaPH4/g4GD4+vpixIgRSE1NteqYicxCo7L9ZvM3ihkItH5IHyZf8CRQcM3aIyIbx0AKkSVTwLnHTUTkVEST9W/WJcjlJ7s7VzaKwd1tIxFZwwuXrhXgtx3nrD0cIiKiamekMJJCxTVr1gzJycnG2+bN169snzhxIhYvXox58+Zhw4YNuHjxIoYPH27V8RKZNZCitIPSXsXd8T4QWAfITATWvGPt0ZCNYyCFyKI9UrjHTUTkTObt0fdGCfPzwP2314EzcndV4JlejeTyt8xKISIiO8YeKVQWV1dX1KxZ03gLCQmR92dmZmLWrFn49NNP0atXL7Rt2xazZ8/G1q1bsX37dmsPm8i0tCqo8xXIS7iA/PgTKExKgjbfDpq4e/gBgz/TL+/8Hji/09ojIhtmZ2FCIvvEjBQiImfNRtH3Rnmyh3Nmoxjc1aY2vlqXgMSMXPy1+zxGd6pr7SERERFVGY/rqLiTJ08iIiICnp6e6NixI6ZPn446depgz549UKlU6NOnj3FdUfZLPLZt2zZ06NCh3NcsKCiQN4OsrCz5U7yeuFWGYf3KPs9RcP6Wmb8ivxCnloZBu/C9kvcHBMA1LAyuEbXg0bgxPJrEwD2mCdyiouAimr7bwvyju0HZ4n4oDv4B3aIJUI9dC7h6wBHw37/KpK/HQAqRRbCWLhGRs5m/NwkXruYh1M8DI500G8XATanA493q442Fh/H9xtN4oH0deR+RKYgTVv/88w+OHz8OLy8vdOrUCR988AGaNGlS7nN69OghS6zcaODAgVi6dKlcHjNmDH755ZcSj/fv3x/Lly83wyyIyF76owg8riOD9u3b4+eff5bbHFHWa8qUKejatSsOHz6MlJQUuLu7IzAwsMRzwsPD5WO32raJ17rRypUr4e3tXaWxrlq1Cs6M8zfv/HtcyoZW5S6X1b6+UBQUQKFSQZuZiUJxO3kSuRs2GtfXeHoir3495DZsiNwGDVEYHmbWKPWt5u+m64rerkvhcTkep36ZgPhad8GROPu/f1NhIIXIApiRQkTkXNQaLb5Z79y9UW50T9tIfL76hAwuLT2YjGGta1t7SOQgREBENPJt164d1Go1Xn31VfTr1w9Hjx6Fj49Pmc8RgZfCwkLj7+np6WjZsiXuueeeEuvdcccdsgyLgYeHY1ydSESVVyyOIhuKEwkDBgwwLrdo0UIGVqKjo/HXX3/J4H5VTZ48GZMmTSqRkRIVFSW3b/7+/pW+IlucRO3bty/c3OyoEbiJcP6Wmb9mxwvypyLADzGbt8jgs/baNahTU6FOS4P6/HkUxJ9AQfxxFJ44CWV+PnyPHpM3wTU8HD59+8C3Xz94tmxpsmyVyszfpYEbsHAcmlxahgbDXwNq2H8WPf/9q7Bo0SKTvR4DKUQWDaRwh5uIyBksP5KC8xl5CPJxd/psFAMRTHqkcz18tCJe9koZ2iqC20UyiRszRMSVwWFhYbKkSrdu3cp8TlBQUInf//jjD3mF742BFBE4EfXuK4JlWEzL2T8Dzt/25q/RXo+kqNXi/2sXp5q/JdnzvEX2SePGjZGQkCBPXIqg/dWrV0tkpaSmpt5y2yK2P2UF78WJ0KqeDK3Ocx0B52/e+WvUog+iKxTF3yc4WH+LjS2xrk6jQf6x48jdvg05W7chd+9eGXDJnPObvImgiv+gQQi852541Ktnufm3vBc48BtczmyA2+o3gAf+gKNw9n//psJACpEF6Izt5omIyNGJq69+2HhaLo/qGA0vd2ajGDzUPhrfrEvA8ZRrWB9/CT1jwqw9JHJAorlvWcGSmxHNgO+///5SGSzr16+XQZkaNWrIRsHTpk1DsDghUAaWYTEPZ/8MOH/bmb9Gd/0UyupVq+Hj5lzzp4rJzs7GqVOn8PDDD8vm8uLE5Zo1azBixAj5eHx8PBITE2UvFSJHopOBFMClAifrXZRKeMU1k7fgxx6DtqAAOVu2Imv5f8heu04GVTJ++knevDt0QI377oVf795wcdeXDjMbcZHXwI+AmZ2AE/8B8cuBJneY9z3JrjCQQmQBLO1FROQ8dp27ggNJmfBwVeDhDtHWHo5NCfB2w4MdomWflJnrTzGQQian1Wrx3HPPoXPnzoiLi6vQc3bu3Clr2Ytgyo1lvYYPH4569erJk2KiZJgo4SIaBCuVpQOkLMNiWs7+GXD+tjd/lUaLSdtXy+V+/foiwMvNqeZvz6VYzOmFF17AkCFDZDmvixcv4q233pLbiJEjRyIgIABjx46V2wYR3BfbgqeffloGUW7WaJ7IHmlUWuxr+Qyy/etg44uboHRTwNvPHd7++ptPoAeCInwRFOGDwDAvKIr1S1R4eMCvV0950xYWImfTJlz9ax6yN25E7vbt8uZaqxaCHxmDwLvvhqKKF6hUSGgToON4YMvnwH8vAfW7A25VL9NHjoWBFCILMOSjuLAtIRGRw5u1+Zz8eXfbSAT7sp/CjR7tXA+zt5zBzrMZ2HMuA22jK541QHQroleKCIps3ry5ws8RAZTmzZvj9ttvL3G/yFAxEI+L2vcNGjSQWSq9e/cu9Tosw2Iezv4ZcP62M3+di9bi47Kl+VPZkpKSZNBE9NoKDQ1Fly5dsH37drkszJgxAwqFQmakiPKP/fv3xzfffGPtYROZ3DV1DVyp0UQuq67py/NlZ1wveVqc0lWB4No+iGgUiNpNaqBWw0B4eOlPUSvc3WX2ibipLl7E1b//xpV586BOTkbqe9Nx+ZuZqPHwQwh6+GEoK3mhSoV1ewk4OA+4eg7Y8S3QZaJ53ofsDgMpRBbAjBQiIueQmgesjb8kv+/HdjFNPV9HUzPAE3e1ro2/didh5vrT+HE0AylkGhMmTMCSJUuwceNGREZGVug5OTk5sj/K1KlTb7lu/fr1ERISIuvelxVIISLnKdfM4zoyENuQm/H09MTXX38tb0QOS6eDRqMEFICrtgB3v9UVqkIN8q6pkJtZgNysQlxLz0f6xRxkXMyGulCLtHPX5G3/6vPyOzW8nj/qtwpDgzah8A/RZ4C4RUQg9JlnEPzEE8hcsBDps2ZBlZiIy19+hSu//h9CnnoSgSNHyuCLSXn4An3eAhb8D9j0KdD6YcAnxLTvQXaJgRQiC+50c3+biMixrbuoT1Hv2zQc9UN9rT0cmzWuWwMZSFl9LBVnLuegXkjJvhREle1LJEqlLFiwQGaLiFJcFTVv3jx5hfBDDz1UoauOxRXHtWrVquaIicieL44TeFxHRFSMRgWN1k0GUpRQI7h2+cdBOq0OWel5SD2ThQsnruJC/BVkXspDyuksedv6TwJConzRqF04YjrUkmXBRKBE9EkJHDEcWStWyKyUwlOnkDr9fWT83xyETnwO/gMHwsWUUe7m9wLbvwGSDwDr3wcGfWy61ya7db0gHRGZDzNSiIgc3uXsAuy6pP+iH9etvrWHY9MahvmiZxN9yYtft5219nDIAcp5zZkzB3PnzoWfnx9SUlLkLS8vz7jOqFGjZA+Tssp6DRs2rFQDedEs+MUXX5TlWc6ePSsbBQ8dOhQNGzaUZVmIyLmZ9GQdEZG906qg0RWV5sL1MohlcVG4ICDUG41vr4meD8XgoXc6YtR7ndDt/sayzJf4er18Phvb/jmFXyZvwfLvDyHxaLoMwLi4uiJg0CDUX7QQNadOgWtoKFRJSbj4/AtIHDUaBadPm25OCgXQ71398u6fgEsnTPfaZLcYSCGyAPZIISJyfHN2nIda54JWUQFoG13D2sOxeY901mcNzNudhOwCtbWHQ3Zs5syZyMzMRI8ePWS2iOH2559/GtdJTExEcnJyiefFx8fLXiqiEfCNRKPggwcP4s4770Tjxo3lOm3btsWmTZvK7INCRI6PGSlERLfISJEnmot9WVaQX5AnmveIxLCJrfHIR13Q48EmstSXVqPDqb2XsPiLA5g7ZQeObrkIjVorAyo17r0XDVYsR8gzT8PFywu5u3bh9NBhuPTFl9AWlN2bpdLqdQWaDAR0GmDtrcvAkuNjaS8iC5WcEHjhEhGRYypQa/D7rvNy+dFO0bxStQK6NgpBg1AfnLqUg/l7kjC6U11rD4nsfD/rZkTJrxs1adKk3Od6eXlhxYoVJhkfETkG9kghIiqHVn09I8Xl5hkpt+Ll645mXWvL2+WkbBzdfBHxO1JwNTUX6/7vOHYuPoOWvaMQ16023Ly9EfrUUwi4cyhS3pmKnA0bcfmbb5C1bBkiPngfXi1bVn9uvd8E4pcBx5cCWRcB/4jqvybZLWakEFlA5ePxRERkT5YdSkZGjgqB7jr0bRpm7eHYBRFsGlMUPPll61lotdxaEhGRvWSkMJJCRGSkKYRGV5SR4mK6ffqQSF9Z8mv09E7oNKIhfALckXO1AFvnJ2DOG9tweOMFaDRauEfWRtS336L2Z5/Jcl+FZ8/i7AMP4tI330Cnrmbme1hTILqzaO4C7JtjqqmRnWIghciCO928QpmIyDH9uu2c/NkpXAtXJXevKmp4m0j4ebji9OUcbDx5ydrDISIiKlfxU4M8rCMiuqG0V1FGCqDB+WvnkZqTigKNaUpsuXu6onXfOnh4Wif0fDgG/iGeyM0qxIa58fhj6k6c2psm1/O/oz/qL10iG89Do8HlL77EhUfHwjUjo3oDaDtG/3PPL4BWY4IZkb2q9pH+22+/LU8OF7/FxMQYHxe1im98/IknnijxGqJm8aBBg+Dt7Y2wsDDZ2FFd3YghkU32SCEiIkdzKCkT+xKvwk3pgo5hzKqoDB8PV9zbLkou/7yVTeeJiMi+ywgSETklrRqFRRkpmaorGPjPQPT5uw9um3MbOs7tiKELh+LZtc9ixp4ZWH52OS5mX6zSd6rSTYHYzhF44O0O6HpfI3j6usmSX8u/P4x/P98vl5X+/oj45GNEfPgBFD4+yN+3D9Gff4GcjZuqPr+mdwJeNYCsJCBhTdVfh+yeSXqkNGvWDKtXr77+oq4lX/bxxx/H1KnXm/KIgImBRqORQZSaNWti69atsgnkqFGj4Obmhvfee88UwyOyOvZIISJyXL9u0wcA7mgWDn/3JGsPx+6M6hiNn7acwfr4Szh9KRv1Q32tPSQiIqJSmJFCRFQOjQq5cJeLOqjh5eqFQlnuS4NsVTayM7NxOvM0oG8pKYV5haFT7U7oUrsLOkZ0hL+7f4XfTumqQIueUYjpUAv7ViXKW9LxK/j9nR1oe0ddtOlfBwF33gmvNm1w4fkXkH/gAJInTID6uecQPO7xyleLcfMEWj4AbP8a2PMz0Lhf5Z5PDsMkgRQROBGBkPKIwEl5j69cuRJHjx6VgZjw8HC0atUK77zzDl5++WWZ7eLurv8fkcieMSOFiMgxXckpxL8HLsrlh9rXQcphBlIqKzrYB71jwrD6WJrslTJlaJy1h0RERFQKe6QQEZVDUwh1UWkvFxcddj64U15QfE11Del56UjOTsaZrDM4ffU0DqcfxomME0jLS8PChIXypnRRom14WwyuPxh9o/vC171iF1a5e7mi/Z31EdOxJjb+fgKJRzOwa8kZnNyVit5jmqJmvUjUnv0T9jz5FAJ37MClGTOQf/QoIt57V2arVErb0fpAyonlbDrvxEwSSDl58iQiIiLg6emJjh07Yvr06ahTp47x8d9++w1z5syRwZQhQ4bgjTfeMGalbNu2Dc2bN5dBFIP+/fvjySefxJEjR9C6detS71dQUCBvBllZWfKnSqWSt8oyPKcqz3UEnL/556/VaPU/tVqb+5z59+f8iajq/tp9HgVqLZpF+KN1VAD+O2ztEdmn0Z3qykDKP3sv4OUBMfB2N8kuKhERkekUD6QwjkJEdJ1WBY3hFLOLvoeIyPoQWSbiVi+gnsw+MchX52Nf2j5svrBZ3kS2ys6UnfL27o530SuqF+5qdBc61OpQoeyRgFBvDH66JRL2pGHzXydlia9/PtqLdoPqokXv2kgbfhca9euHS++/j2srVuDsuXOI+u47uIWHVXyOoU2AOp2AxK3AgT+ArpOq8EGRvav2UWr79u3x888/o0mTJrIs15QpU9C1a1ccPnwYfn5+eOCBBxAdHS0DLQcPHpSZJvHx8fjnn3/k81NSUkoEUQTD7+KxsohAjXifsrJbipcNq6xVq1bBmXH+5pv/xWTRjkiBo0ePYFmGbZ5l49/fuedPRJWn0eowZ8c5Y3mqSqeIk1HnBiGoG+yNs+m5WHIg2dg3hYiIyFZoi6WkcItPRFSMRg1NUY8UKG7d+8TT1VOW8xK3F9u9iKRrSbJ3yr+n/sWZzDP47+x/8taoRiM83PRhDKo/CO7Km1csEsdijW4LR53YIGz4/YTMStm5+AzOHb4MlzouCLj3Hng3jUHS08+g4PhxnBs5ElE//giP+vUqPs9WDxQFUn4HukxkVN0JVTuQMmDAAONyixYtZGBFBE7++usvjB07FuPGjTM+LjJPatWqhd69e+PUqVNo0KBBld5z8uTJmDRpUomMlKioKPTr1w/+/hWvqVf8imxxErVv376yN4uz4fzNP/+lmfuBjDTExcVh4O22dXKIf3/Of9GiRdYeBpFd2nAiDecz8hDg5YY7W9YWp1isPSS7pVC44P7b6+D9/45j7s5EBlKIiMjmFD81qODJMyKikhkpRaW9dEUZKZUR6ReJx5o/hrFxY3E0/SgWJCyQQZWTV07iza1v4vO9n+Ph2IcxMmYkvN1ufgG9h7cb+o1thui4YGz8PR6pZ67BJdEHZ5uko1GbNqj7x+84/9jjKDx3DuceeABR338HrxYtKjbQ2KHAsheByyeAC3uByLaVnivZN5PXTQgMDETjxo2RkJBQ5uMi0CKIx0UgRZT72rlzZ4l1UlNT5c/y+qp4eHjI243ESdDqnAit7vPtHedvvvkbrlJ2VSpt9jPm39+5509Elffb9kT58562kfByV0KlYiClOu5uG4lPVsZj//mrOHoxC7ERlb84hoiIyFxEvX8DxlGIiIrRqKA1nGKuQEbKzc6dNQtpJm9Pt34a80/Ox9xjc5Gam4rP9n6G/zv6f3i8xeO4p/E9t8xQadK+Jmo1DMCqWUeQcjoLK78/iiuDctFuUD1E/z4X5//3BPIPHULio2MR9cP38C6jtUQpnv5A0yHAob+AA3MZSHFCot6QSWVnZ8tsE5F5Upb9+/fLn4bHRU+VQ4cOIS0tzbiOuDpcZJbExsaaenhEVmHY5+YONxGRY0jJzMe6eP2+y8j21/vCUdWF+HqgXzP9RTS/79QHqYiIiGxF8VODLOdJRFSMpliPFIVpLi4L8AjAo3GP4r8R/2Fa52mo7Vsb6fnpeH/n+xi0YBCWnF5SIsBdFv9gLwx+pjl8owvl77uWnsWybw9B6+WP6J9nw/v226HNzsb5sY8hd/fuig2s1Uj9z0N/A+rr/bvJOVQ7kPLCCy9gw4YNOHv2LLZu3Yq77roLSqUSI0eOlAGVd955B3v27JGP//vvvxg1ahS6desmy4AJohyXCJg8/PDDOHDgAFasWIHXX38d48ePLzPrhMgeGb7aXVhNl4jIIczbfR5aHXB7vSA0CPW19nAcxgO364NSC/ddQG6h2trDISIiMrrF+ToiIuelVUFr6JGiNO2XpZvCDUMbDsXiYYvxRoc3EOYVhpScFEzeNBmPrHgEJ66cuOnzFUoFAmML0P3BxlC6KnD24GX8/cFu5BQoEfXdt/Du2AHa3FwkPj4Oufv23XpA9boDfhFA/lXgxHLTTZScI5CSlJQkgyai2fy9996L4OBgbN++HaGhoXB3d8fq1atlsCQmJgbPP/88RowYgcWLFxufL4IuS5YskT9FdspDDz0kgy1Tp06t7tCIbAYzUoiIHIdWq8Ofu8/L5fvZy8OkOtYPlk3nrxWosfjARWsPh4iIyEhXdHkcj+mIiMxT2utm3JRuuLfJvVg6fKks++Wp9MSe1D24d/G9MkslR5Vz0+c36RCOu15oA59AD1xJycX8D3YjI12NqJkz4dOpE3R5efpyX/HxNx+IQgm0uFe/vP93E86QnCKQ8scff+DixYsoKCiQQRXxu6GJvGgAL7JV0tPTkZ+fj5MnT+LDDz8s1RBeNKdftmwZcnNzcenSJXz88cdwdTV5+xYiKyra6bb2MIjs3PTp09GuXTv4+fkhLCwMw4YNQ3yxHZ2MjAw8/fTTMrjv5eWFOnXq4JlnnkFmZqZVx02OZcupy0i6kgc/T1cMiCu7lClVr+m8MHenPlhFRERkEwwXx1l7HEREtkarhq4okOKiNO9bebp6YlyLcVg0bBH6RveFRqfBb8d+w4h/R2BXyq6bPje8rj9GvNQWQRE+yMksxD8f70VyYh4iv/oSXq1bQ5uVhcSxj6Hw7NmbD6LVA/qfCauA7EsmnB05XY8UIiqNGSlEpiGC86L0o8h8FP20VCqVzHrMydFffSIC++ImAvKHDx/Gzz//jOXLl2Ps2LHWHjo5kD926U/w39W6tmwyT6ZvOu+mdMGB81dx5CKDoEREZGPlmnlQR0RUfkaKhQ6PInwj8GmPT/Fdn+9k/5QL2Rfw6IpH8cHOD5Cvzi/3eX5Bnhj+QhtENAqEKl+DJV8ewIWz+bLMl0dMDDSXLyNx3P+gvnKl/DcPbQJEtJEBJBz+2zwTJJvEQAqRBbBHCpFpiKDImDFj0KxZM7Rs2VIGShITE2UvLiEuLg7z58/HkCFDZHZkr1698O6778qSkmo1+y1Q9WXkFGLlkRS5fB/LepkFm84TEZFNXxxn7YEQEdkaTeH1jBQLFxjqVLsT5t85HyMajZC/zzk2B/csvgfxGeWX6PLwdsOQZ1oiunkw1Cotln5zEOfPFaLOjz/ArXZtqBITkTThaWgL9U3qb5qVsn+uyedEtov1s4gsQMe9biKzMJTsCgoKuuk6oqRkeSUjRWlKcTPIysqSP0W2i7hVhmH9yj7PUTjD/OftOgeVRoe4CH80DvUuMVdnmP/NmHL+97SJwNKDyfh3/0W80q8RPNxsP/PH2f/+zj53InJ87JFCRFQOrQq6oppeLq6W/5L0cfPB253eRu86vfH21rdxNussHlr2EF7v8DoGRg8s8zmubkoM+F9zrPzxCE7vv4T/vj2EQU+1kJkpZ0c+gLw9e5D82uuI+PCDsjMR40YAyycDKQeB1KNAeKz5J0pWx0AKkUUzUojIVLRaLZ577jl07txZZqKU5fLly3jnnXcwbty4m/ZdmTJlSqn7V65cCW9v7yqNTZQdc2aOOn8RE//pgDhAcEFTjyuyv5szzb+iTDF/rQ4IdFfiar4aH/2+Em1CzNO00hyc/e9PROSorl8bx6M6IqIS1IXG0l7WCKQYdI3sKrNTXtn8CrZc2ILXt7yOval70VzXvMz1la4K9Hu8GVbNOopTe9NkMGXIM60Q+flnsrxX1uLF8GzaFMGPPlL6yd5BQKN+QPxS4Mg/DKQ4CQZSiCzaI4U73USmInqliD4omzdvLvNxkVkyaNAgxMbG4u233y73dSZPnoxJkyaVeF5UVJTsvSIyWSp7NbY4idq3b1+4ubnB2Tj6/Pecu4LU7bvg5abA5Ad6yWbzzjT/WzH1/E96JOCbDadxWheG1we2ha1z9r+/4TNYtGiRtYdBRGQWxpA+D+mIiErSFFwv7eVm3S4SgZ6B+Kb3N/j+4Pf4Zv83+CfhH2xXbken3E6ICIgotb5SqUDfR2OhLtTg3OF0LP36AIZObI3wVycjdeo7SPvkE3g2awaf9reXfrO44fpAyuH5QM/XmLLoBBhIIbIAZqQQmdaECROwZMkSbNy4EZGRkaUev3btGu644w74+flhwYIFNz2p6eHhIW83Es+p6snQ6jzXETjq/Bce0PdGGdg8AkF+Xk43/4oy1fzvu72ODKRsOZWO9FwNagZ4wh44+9+fiMjRyzXzmI6I6AbqQuhcfOSi0sqBFEHhosATLZ9Ai5AWeHnTy7hYcBGjV47GzD4z0bBGwzIzU+4YF4fFXx7AxZNXseTrgxjx0jAEHDiIzEWLcGHSJNT7Zz7cwsNLPrHxHYCrF5BxGkg+AES0stwkySqs/6+byJl2urnXTVTt/5dEEEUER9auXYt69eqVWkdklIhsEnd3d/z777/w9LSPk69k2/JVGtmzQ7i7bengHZledLAPbq8bJMt8zd+bZO3hEBGRk7teZcDaIyEist1m87CBQErxRvS/9v8VIYoQpOSmYNR/o7AzeWeZ67q6K2WPlOBIX+RlFWLp14dQ4+XX4BETA016Oi5Meh46tbrkkzx8gcb99csiK4Ucnu386yZyAtzpJqp+Oa85c+Zg7ty5MtskJSVF3vLy8koEUXJycjBr1iz5u2EdjUZj7eGTHVtxJAXXCtSoHeiF9vWCrD0cp3H3bfqg1fw9ScaLEoiIiKyJPVKIiMoo7VXUbF7pblvFjyJ9IzHOdxxahbbCNdU1/G/1/7Dk9JIy13X3csXg8S3gE+COK8k5WPFLAiJmfAaFj49sPp/+ww9ll/cSjiy8HnEnh8VACpEFsDEhkWnMnDkTmZmZ6NGjB2rVqmW8/fnnn/LxvXv3YseOHTh06BAaNmxYYp3z589be/hkx+bvvSB/jmhTGwoFv8stZVDzWvB2V+L05RzsTbxi7eEQEZETY0YKEdHNSnu52mQgRfBWeGNmr5noF90Paq0ar256FX+f+LvMdX1reGLQhJZw81DiQvwV7NxZgJpvvSkfu/TV18jbv7/kE0TDeXdfIDMRSNptiemQFTGQQmQBuqIuKdzpJqoecUV6WbcxY8bIx0WApbx16tata+3hk51KzcrH5pOX5PLwNizrZUk+Hq4YEFdLLv+9h+W9iIjIBo7prD0QIiKbzEgpCqR42F4gRfBQeuCj7h9hZMxI+X0+ZdsU/H789zLXDY3ykw3ohUPrkpAc1g7+gwYBGg0uvPgSNNk511d28wKaDNQvs7yXw2MghcgCmN1HRGS/Fu67IPt0tI2ugboh+iaKZDn3FJX3WnwgGXmFLNFHRETWzkhhKIWIqFRGSlGPFKWHG2yVaEI/+fbJGB07Wv7+3o738Nux38pct17LUNw2UH8x5vrf4uH62AtwjagF1fnzuPTpJ+WU91oAaHm84sgYSCGyAO50ExHZJ5HNZGh0PoLZKFYhGs5HBXkhu0CN5UeSrT0cIiJyUoZr43hER0RURkaKQt8jxdWGAymG83LP3/Y8Hmv+mPz9/Z3vY2HCwjLXvX1wPUTHBUOj0mLl3DMInfKuvP/K3N+Ru7tYGa8GvQCPACA7BUjcZpmJkFUwkEJkAUwDJyKyT4cvZOFEajbcXRUY1EJfYoosS/SkMQSxFuy7aO3hEBGRE19cIfGgjoioBF1hPrSG0l6e7rB1IpjyTOtn8HDsw/L3t7a+hVXnVpVeT+GCPo/Ewi/IE1mX8rA7IQCB99wtH0t+/Q1oCwr0K7p6AE2H6JcP/2PBmZClMZBCZAFsTEhEZJ8M2Sj9YsMR4GXbV1c5smGtasufolfNpWtFByxEREQWxIwUIqKy6VSF0Cn0gRQ3Tw/YAxFMefG2FzG80XBodVq8tPEl7E4p3Sze08dN9ksR5/Pid6Tgau9H4RoaisKzZ3H5q6+vrxh3l/7n0UWARm3BmZAlMZBCZNGdbu52ExHZi0K1Fv8e0GdAjGjLsl7WJHrTtK4TKHvVLC76mxAREVkSyzUTEZVNV1gArYvSrgIphu/zNzu8ib7RfaHWqvHsumdxJvNMqfVqNQxEu8H15PKmBYnweeEtuZw+ezYKTp3Sr1SvO+BVA8i9zPJeDoyBFCJLYEYKEZHd2XjiEjJyChHq54GuDUOsPRynZ8hKWbj/grWHQjZm+vTpaNeuHfz8/BAWFoZhw4YhPj7+ps/5+eef5cFz8Zunp2epMj5vvvkmatWqBS8vL/Tp0wcnT54082yIyHYVlWvmMR0RUalAiiEjxcPTC/ZEqVDivS7voUVoC2QVZuGp1U8hIz+j1HptB9RFrYYBUBVosPN0Dfj06Amo1Uh99z196UelG9B4gH7l40ssPxGyCAZSiCyAPVKIiOzPoqLMhztbRsBVyV0maxvcohaUChccTMrEqUvZ1h4O2ZANGzZg/Pjx2L59O1atWgWVSoV+/fohJyfnps/z9/dHcnKy8Xbu3LkSj3/44Yf44osv8O2332LHjh3w8fFB//79kZ+fb+YZEZEtYosUIqKyiV4hWoW+DLK7l+33SLmRp6snvuj5BWr71kZSdhImrpsIlVZVqm9j79FN4equwIX4q8jo/wRc3NyQs3Urstes0a/UdLD+5/Gl1zca5FB4VoDIAtgjhYjIvuQUqLHqaIoxkELWF+zrgW6N9JlBi/YxK4WuW758OcaMGYNmzZqhZcuWMtskMTERe/bsuenzRBZKzZo1jbfw8HDjY+LKws8++wyvv/46hg4dihYtWuDXX3/FxYsXsXDhQgvMiohstlwzD+qIiErQFV7vCeLuZp99JYO9gvFN72/g4+aDvWl78enuT0utExDqjQ5DG8jlneuvwOPh/8nl1OnvQysutGnQC3DzBjLPA8n7LT4HMj993hURmdX1ODR3uomI7MGqo6nIV2lRN9gbLSIDrD0cKjKsdW2si7+EhfsvYmLfxjyZRWXKzMyUP4OCgm66XnZ2NqKjo6HVatGmTRu89957MhgjnDlzBikpKbKcl0FAQADat2+Pbdu24f777y/1egUFBfJmkJWVJX+KDBlxqwzD+pV9niNx9s+A87e9+V8fi87s47LF+VuSs86byF6pCzXGZQ93+8tIMagfWB/vdnkXz617DnOOzUGzkGYYXL8oy6RIi56ROLU3DcmnMnHItQNiwudBdeECMn7+BSFP/A9o2Bs4thg4tgSIaG21uZB5MJBCZAGyXiIzUoiI7IahyfydrWrzZL0N6RsbDm93JRIzcrE38SraRtew9pDIxoigyHPPPYfOnTsjLi6u3PWaNGmCn376SWaaiMDLxx9/jE6dOuHIkSOIjIyUQRSheJaK4XfDY2X1apkyZUqp+1euXAlvb+8qzUeUKnN2zv4ZcP62M/+LslqgKwoLC7Fs2TKnmz8RUXnUhVrjsoeb/TSbL0vvOr3xePPH8cOhHzBl6xTE1IhBwxoNjY+7KFzQ8+EY/DltF86fyETdB16E24wXkP7jjwi87164Nr1TH0gRfVJ6v2HVuZDpMZBCZMk0cCuPg4iIbk00mBeN5gWW9bIt3u6uuKNZTfyz7wIW7rvAQAqVInqlHD58GJs3b77peh07dpQ3AxFEadq0Kb777ju88847VXrvyZMnY9KkSSUyUqKiomS/FtGPpbJXY4sTqH379oWbnZbIqC5n/ww4f9ub//GUa/jg4DZ4enhg4MAeTjd/SxLzX7RokbWHQUQVpFYVne3SaeHhZr8ZKQbjW43HkfQj2HpxK17c+CJ+H/S77KNiUKOmD1r3r4PdS89i75lAdGoaB82xw0j//geEPzMOULgCl44DlxOAkOtBGLJ/DKQQWbRHCkMpRES2btmhZKi1OjSL8EfDMF9rD4fKKO8lAilLDl7EG4Nj4e7Kln+kN2HCBCxZsgQbN26UWSWVIU5Utm7dGgkJCfJ30TNFSE1NRa1atYzrid9btWpV5mt4eHjIW1mvXdUTodV5rqNw9s+A87ed+SuVrsZjOkuNyZbmT0RUHq1Kn5HiotPAw9W+M1IEpUIpS3yN+HcEEq4m4NM9n+LV9q+WWKdt/2jEb0/BtfR8JPd8CmHHnsKV335D0MMPwa1eN+DUWuD4YqDLRKvNg0yPR55EFsCMFCIi+yvrNbQVs1FsUacGwQjx9cCVXJUxc4icmyihKoIoCxYswNq1a1GvXr1Kv4ZGo8GhQ4eMQRPxGiKYsmbNmhIZJjt27CiRyUJEzkNXdFTHYzoiopLURb3mXXRquCkcI/gb4hUigynC78d/x/rz60s87uquRNd7G8nlo/GA9vbe0BUW4tLXXwMxRX1VRJ8UcigMpBBZAnukEBHZhYtX87DzTIZcHtyCgRRb5KpUYHAL/clukZVCJMp5zZkzB3PnzoWfn5/sYSJueXl5xnVGjRolS28ZTJ06VfYuOX36NPbu3YuHHnoI586dw2OPPWa84lz0Wpk2bRr+/fdfGWQRrxEREYFhw4ZZZZ5EZCtVBqw9EiIi21KoKvqCFIEUpWMEUoQutbvg4diH5fJbW9/ClfwrJR6v2yIE0c2DodXocDr2Pnlf5oKFKPRuqQ+7X9gNZPF4xZEwkEJkyYwU7nQTEdm0xUXZKLfXC0JEoJe1h0PlGFLUu2bV0VTkqzTWHg5Z2cyZM2XD+B49esiMEsPtzz//NK6TmJiI5ORk4+9XrlzB448/LvuiDBw4UGabbN26FbGxscZ1XnrpJTz99NMYN24c2rVrh+zsbCxfvhyentdrZBOR83FhTgoR0XU6HQq1SmNpL3eF/fdIKe65Ns+hYWBDZORn4P2d75d4TFx403lEQ9mAPvGsCgXdRwBaLS7PXQBEttOvdHypdQZOZsFACpEFaA0ZKdzpJiKyaSzrZR/a1AlE7UAv5BRqsO54mrWHQzZQ2qus25gxY4zrrF+/Hj///LPx9xkzZsgMlIKCApm9snTpUtkj5caDY5G5Ih7Pz8/H6tWr0bhxY4vOjYhs8JiOh3RERNdpClGoNbTgVsNd6ViBFDGfdzq/A4WLAsvOLMO6xHUlHheN52O76I8d48P7ygupMxf9C1Vod/0KxxZbY9hkJgykEFkA08CJiGxfQto1HLmYBVeFCwbGXW8uTbZHnOAeZCzvdT3LgIiIyNzHdAoe1BERXacuQKGuqJyXTiMDDo4mLiQOo5uNlstTt09FZkFmicfbDaoLVw8lLqdpkNn5Xtk0Jn3HVf2D57YA+SXXJ/vleP+6iWw6kMKdbiIiW/Xvfn02SrfGoajh41hXUjmiIUU9bNYcT0VOQVGHSyIiIjOXayYiomI0KqgMgRQ47j75+FbjUde/Li7nXcYXe78o8ZhPgAda960jl08G9YDWRYGrS1ZB5dkA0KqBUyWzWMh+MZBCZMkeKVYeBxERlU2UAVrEsl52Ja62P6KDvZGv0mL1sVRrD4eIiJxgX0HgtXFERMVoCqA2BlIct3ehh9IDb3Z8Uy7POzEPhy8fLvF4qz5R8PJzw7VrOmTcfg90hYXIOFtb/+CJFdYYMpkBAylEFsCdbiIi23YwKRPn0nPh6aZAn6bh1h4OVYDI8hzM8l5ERGTpi+N4TEdEdJ1aBFKKeqS4OG4gRWhXsx0G1x8MHXSYtn0aNNrr83X3dEXrvtFy+XRIN31Wys4kaFQuwMmVsgk92T8GUogsiM3miYhs05KD+mwUEUTx8TA0SyRbN6SlPntoQ/wlZOWrrD0cIiJyhnLNPKYjIrpOU+gUGSkGz9/2PHzdfHEk/Qjmn5xf4rG47rVlVkp2DnC52UBoc/OReT4IyL0MXNxrtTGT6TCQQmQBbDZPRGTbWYPLDqXIZUOGA9mHJuF+aBjmi0KNFiuPsLwXERGZE6sMEBGVoi6AxpiR4vhZFyFeIZjQeoJc/nzv5yUaz7t5KNGqj75XytnIvjIrJeOkP3TiYzmx3GpjJtNhIIXIAkTan8B9biIi27P//FVcuJoHb3clejQJs/ZwqJLlvQxN5w1ZRURERObNSCEiojIzUpwgkCLc1+Q+NAxsiKzCLPxw8IdSWSmevm7IzndFWt1uUF0pQPZFTwZSHAQDKUQW3OnmXjcRke1ZdkjfX6N303B4uimtPRyqpMEt9VlEm09expWcQmsPh4iIHL5HCg/qiIiMNIXQOlFGiuCqcMWktpPk8tzjc3H+2vkSvVJE43khqZHopwJkxPsAKYeALF74Ze8YSCGygOtxFO50ExHZalmvQc1rWns4VAUNQn3RtJY/1Fodlh/R/y2JiIhMjRkpRETllfYqykhROEcgRehSuws61uoIlVaFL/Z+UeKxuG61ZZmvrEIvZITEIfeSB/KvuAInVlhtvGQaDKQQWehEncCLl4iIbAvLejmGIUVZKSzvRURE5j6mYySFiOiGjBQ4XyBFZCeKxvPigunlZ5fj4KWDxsc8vN0Q20VffvhCi7vlz6unfYCTK602XjINBlKILICVvYiIbBPLejmGwc31ByrbTqXj0rUCaw+HiIgcEI/piIjKoC64XtrLiQIpQpOgJrizwZ1y+ct9X5Z4rEWvSLgoXHBZG4prvpHIPOsF7Yn1gCrPSqMlU2AghcgSDBcvMSWFiMhmsKyX46gT7I2WkQHQ6oD/DuuDY0RERKZkTEjhMR0RUTkZKYaQs/N4qtVTsmfK9uTt2J2y23i/f7AXGrbVVzxIajIEWpUCWad0wNnNVhwtVRcDKUQWbUxo5YEQEZERy3o5lsEt9Fkp/xUFx4iIiExJV3RUx0M6IqKyM1JcnDDBP8I3AiMajZDLX+3/6noZSMDYdD7FrxnyPQJx9ZQPcGK51cZK1cdACpEle6RYeyBERGTEsl6O5Y44fVbRjjPpuJzN8l5ERGRixowUaw+EiMiGaAqgQ1EgxdX5MlKEx5o/BjeFG/ak7sGOlB3G+8Oi/VGrYQB0cMHFiC7IS3dH/vaV11Mcye4wkEJkAcxIISKyLSzr5XiigrzRvLa+vNfKI6nWHg4RETlsjxQe1BERGWlUxtJezpiRItT0qYl7Gt8jl7/e93WJrJTm3SPlz+ToHtC6KHB1/1Ug47TVxkrVw0AKkQVc/w7lTjcRkS1gWS/HzkphnxQiIjJfjxRrj4SIyIaoRUZKUY8UV+f9ghRZKR5KD+y/tB+7U6/3SqnfOhRefm4ogBcuB7dA1jlv6I6vsOpYyYqBlLfffls2Wyt+i4mJMT6en5+P8ePHIzg4GL6+vhgxYgRSU0teJZiYmIhBgwbB29sbYWFhePHFF6FWq6s7NCLbq6frvNsUIpOYPn062rVrBz8/P7m9GDZsGOLj40usU5HtDhHLejmmAUWBlG2n0nE1t9DawyEiIgc8piMionJKe7k570mvUO9QDGs4TC7POjTLeL/SVYHYzvpejheje0BTqED2ikVWGyfZQEZKs2bNkJycbLxt3rzZ+NjEiROxePFizJs3Dxs2bMDFixcxfPhw4+MajUYGUQoLC7F161b88ssv+Pnnn/Hmm2+aYmhEtnX1krUHQmTnxHZEBEm2b9+OVatWQaVSoV+/fsjJyanwdoeIZb0cV/1QX8TU9INaq8OqowygEhGROTJSeFRHRGSkLjQGUhRuzl34aEyzMVC6KLHl4hYcSz9mvD+2a4Q8IZjh1wi5XmHI3J4AqPKtOlaqGpP8C3d1dUXNmjWNt5CQEHl/ZmYmZs2ahU8//RS9evVC27ZtMXv2bBkwESfBhJUrV+Lo0aOYM2cOWrVqhQEDBuCdd97B119/LYMrRI6AO91EprF8+XKMGTNGBvBbtmwpA+8iq3HPnj0V3u4QsayXYxsQV0v+/O+wPlhGRERk2h4pRERUVkaKswdSIv0i0b9uf7n80+GfjPf7B3uhblywXL4Q0QXZSW7QHF1ttXFS1en/pVfTyZMnERERAU9PT3Ts2FGWXqlTp448sSWuFu7Tp49xXVH2Szy2bds2dOjQQf5s3rw5wsPDjev0798fTz75JI4cOYLWrVuXer+CggJ5M8jKypI/xXuJW2UZnlOV5zoCzt/88zc0mtKo1Tb3OfPvz/nbMxE4EYKCguTPimx3zLlN4b8n+5j/kgMX5M+eTUKhhBYqldap5m8utjL/vk1DMGP1CWw6eQkZ13Lh51lUs9lJ5m9Nzjx3InJ8hmM6XhtHRHRDRopLUSDFnSWTH417FMvOLMPKcyvxdNbTqONfR97frFttnD2UjpRa7dHg9CJcW/A7AlsOtvZwydKBlPbt28srgps0aSLLek2ZMgVdu3bF4cOHkZKSAnd3dwQGBpZ4jgiaiMcE8bN4EMXwuOGxsohAjXifG4nsFtFnpapEmRhnxvmbb/65eWJj4oKtW7cgyRc2iX9/556/PdJqtXjuuefQuXNnxMXFyfsqst2xxDbF2f892fL8xTmQRfv038mhBRewbFmSU83fEmxh/uFeSqTmATP+XI3bQnVON38iIjJjRgoDKUREZWakKNl7Ek2CmqBr7a7YdGETfjnyC97o+Ia8v05sELz93ZGb5Yv0oGbw3XQAJc9akFMEUkQpLoMWLVrIwEp0dDT++usveHl5wRwmT56MSZMmlbh6OCoqStbJ9/f3r9LVc+Kgt2/fvnBzs8xVi7aE8zf//Kcf2QAUFqBL5y6Iq135f6PmxL8/579okX02OhO9UkTQvnhfLmtvU/jvyfbnfzI1G5e3b4Wb0gXP3tsXvh4mSc61m/mbky3NP949Ad9sOI0Ut1oYOLCV083fWux5m0JEdEvGvpeMpFD53n//fXl88eyzz+Kzzz6T9+Xn5+P555/HH3/8ITPhRRWWb775ptRFxUR2SVMsI8WDgRRDrxQRSFl8ejGeafMMAjwCoFAq0Lh9TexflYiUmu0ReuQgVPF74dakjbWHS5VgurMHRcRVwI0bN0ZCQoI8kBR9Tq5evVri6uDU1FTZS0UQP3fu3FniNcTjhsfK4uHhIW83Eget1Tlwre7z7R3nb87563e23dxcbfYz5t/fuedvbyZMmIAlS5Zg48aNiIyMNN4vthu32u5YYpvi7P+ebHn+a09clj+7NAxBDV8vp5u/JdjC/Ae3rC0DKRtPXkah1gU+JgyY2cP8iYjI9HRFkRRmpFB5du3ahe+++05eZFzcxIkTsXTpUsybNw8BAQHyWGb48OHYsmWL1cZKZI7SXkoP7gML7Wq2Q+MajXHiygksOLkAY+LGyPtjOugDKZeD41Do5oP8nWsZSLEzJu8ClJ2djVOnTqFWrVqyya84kFyzZo3x8fj4eNkYWPRSEcTPQ4cOIS0tzbiOuJpPXAUcGxtr6uERWXWnm4iqX5taHHgsWLAAa9euRb169Uo8XpHtDjm3VUf1F2v0a1Z2YI0cQ9NafogO9kaBWot18df3MYmIiKqqqEUK81Go3HNhDz74IH744QfUqFGjRE/HWbNm4dNPP0WvXr3k8crs2bOxdetWbN++3apjJqqWvKvAsSXAob+gc9EHUFw93a09Kpvg4uKCB5s+KJd/P/471Fq1XA6u7YvQOn7QKVyRGnYbdKpCK4+UKqval+e98MILGDJkiCzndfHiRbz11ltQKpUYOXKkjLSPHTtWlkwRjYBFcOTpp5+WJ7MMDX9F6RQRMHn44Yfx4Ycfyhr2r7/+uizZUtYVwkR2vdPNvW6iahHbhrlz58rSMX5+fsa+J2J7I8pJVmS7Q84rOTMPB5Iy5Xdx76Zh1h4OmfngZUBcLXy74RT+O5yCwS0irD0kIiJykGM6HtRReccpgwYNQp8+fTBt2jTj/Xv27JGlL8X9BjExMahTpw62bdtW7jGKKAEmbsXLDwvitcStMgzrV/Z5joLzN+H8sy5AcWQ+XI4vgUvyfrjotPJunYu+pJfCTWlzn7O1/v59I/tihscMXMy5iDVn16BXVC95f6N2obiUeE2W99IUnjX7uPjvX2VbgZSkpCQZNElPT0doaCi6dOkio+piWZgxYwYUCgVGjBhRohakgQi6iPIsTz75pDzR5ePjg9GjR2Pq1KnVHRqRzTDuc/P6JaJqmTlzpvzZo0ePEveLq7rGjBlToe0OOa/VRdkoberUQJifp7WHQ2Y2IK6mDKSsO56GvEINvNxZs5mIiExxTEdUkuh9snfvXlna60biwi93d/cSZYcF0R/FcFFYWaZPn44pU6aUun/lypXw9vau0jhF9RdnxvlXcf46LcKzDqBB2gqEZh8t8dA1j1q47NMEunP608tnzp/DsmXLYIus8fdvgRbYiI34autXyPfLl/dpClzgovPCNb9oHD2xC5ct9Hk5+79/mwmkiA3GzXh6euLrr7+Wt/KIbBZb/R+NyBSYkUJkutJet1KR7Q45p5WGsl6xbOzpDFpEBqB2oBcuXM3DhhOXcEccy7kREVH190N5TEfFnT9/XjaWFycpxXGIqYiG9SLLvnhGSlRUlKzqIrLuK3tFthif6GPsjH3cOP8qzl+nhcvhv6Hc8ilc0hOMd2vrdIK22QjoGvaFp38EaqtU0E7Qn6SPbdEcvTpez75y9r9/m5w22PLvFpzVnEWjTo3QKLCRvP/P5XOR6R4Fv8B6uH3gQLOOgf/+VbKiialYrvMmkVPjTjcRkTVl5qmw7VS6XGZ/FOcp7yWCJ7M2n8Hyw8kMpBARUbUwI4XKIkp3iZ6/bdpcbxit0WiwceNGfPXVV1ixYgUKCwtx9erVElkpqampqFmz/H0TUeq+rHL34kRoVU+GVue5joDzr8T8T60FVr0JpBzS/+4RANw2Bmj3OBSBUSUabmsKCqFV6E8ve/h52+xnbI2/f1RgFHrV6YVV51Zh4emFeLX9q/J+pU4jf+q0OouNydn//dtss3kiulljQu52ExFZw/r4NKi1OjQK80W9EB9rD4csxBA8WXM8DSqNvoYzERFR9aoM8JiOruvduzcOHTqE/fv3G2+33XabbDxvWBYnL9esWWN8Tnx8PBITE2V5eyKbkn0J+PtR4P/u0gdRPPyB3m8Bk44AfacCgVGlniIaphsDKV5eVhi0bbu70d3y55JTS5CnzpPLChf9cYlWfeuKG2RbGEghsgD2JSQisq6VR4rKejVjWS9nIvrhhPi641q+GttP6zOSyPGIOvLt2rWDn58fwsLCMGzYMHmS6mZ++OEHdO3aFTVq1JA30QR4586dJdYRvbfECdPitzvuuMPMsyEim68yYO1hkE0R2564uLgSN9H7Nzg4WC4HBARg7NixskzXunXrZAbLI488IoMo5TWaJ7KKw/OBr2/X/3RRAO2fAJ7ZD3SdJFJNyn2atqAAOoU+08HDhOXtHEWHiA6o7Vsb11TXsPLsSnmfC4oCKbzQy+4wkEJkyXq61h4IEZETyldpZEaK0C+W5Z2ciVLhgr5FPXFWHCm/oSvZtw0bNmD8+PHYvn27rAEtaiGLGvI5OTnlPmf9+vUYOXKkPKm1bds2Y935CxculFhPBE6Sk5ONt99//90CMyIiW8S+l1RVM2bMwODBgzFixAh069ZNlvT6559/rD0sIr3CXODfZ/SZKHkZQHgc8NgaYMAHgE/wLZ+uyS80LruzdFQpChcFRjQaIZf/PvF30X2GQIpVh0ZVwB4pRBag5U43EZHViN4oOYUa1PT3RPPaAdYeDlmY6Inz+87zMitp6p1xUCi4MXY0y5cvL/H7zz//LDNTxFW/4oRVWX777bcSv//444+YP3++LL0yatQo4/2iPv3NatgTkRMe0/HyOLoFEawvTjSh//rrr+WNyKZknAb+eBBIO6q/9LfbC0D3lwFlxQMi6rwC47Knh7uZBmrf7mp0F77Z/w32X9qPk1dOQlGUkaLRsLSXvWEghciSGSmMpBARWdzKo/pMBJGZwJPozqdTg2D4ergi7VoB9iddleW+yLFlZmbKn0FBQRV+Tm5ursxkufE54mSYCMqI8l+9evXCtGnTZLmWshQUFMibQVZWlvwpXlfcKsOwfmWf50ic/TPg/G1v/mq1umhJZ/Zx2eL8LclZ501kUee26oMoIgvFJwwY/j3QoGelX6Z4Roqnu4eJB+kYQrxC0COqB1YnrpZZKU1d9KXStAyk2B0GUogs2SPFyuMgInI2Gq0Oq47q+6MYSjyRc/FwVaJHk1AsOZgsy3sxkOLYtFotnnvuOXTu3FnWpq+ol19+GREREbJXSvGyXsOHD0e9evVw6tQpvPrqqxgwYIAsBaZUKsvs1TJlypRS969cuRLe3t5Vmo8oVebsnP0z4PxtZ/57L4ujOSUyMtKxbNkyp5s/ETmQA38Ci8YDWhUQ0QYY+TvgV7UMXHVeUSBFp4G7KzNSyjOi8QgZSFl6Zimautwn79OxRYrdYSCFyBKMpb0YSiEisqT956/gcnYh/Dxc0aH+rWv8kmPq36ymDKSI8l6v3BHD7bEDE71SDh8+jM2bN1f4Oe+//z7++OMPmX0iyq8Y3H///cbl5s2bo0WLFmjQoIFcr3fv3qVeZ/LkybKZcPGMFEPvFX9//0pfjS1OoPbt2xduTlpv3Nk/A87f9uavPZiMX04eQkhwMAYObOd087ckMf9FixZZexhEjmnHd8B/L+mXY4cCw74F3Kt2wYdQmKvPxnXRquGuYCClPB1rdUSoVygu5V1CPvQZjuyRYn8YSCGyAGakEBFZhzhxLvSMCYO7q8LawyErERkp7koFzlzOQUJaNhqF69PpybFMmDABS5YswcaNGxEZGVmh53z88ccykLJ69WoZKLmZ+vXrIyQkBAkJCWUGUkQ/FXG7kTgJWtUTodV5rqNw9s+A87ed+SuKMtEUCoXFxmRL8yciB7DpE2DNVP1yh/FAv2niS61aL1mQnyd/uujUcFcykFIepUKJwfUHY/aR2bgGffBJw4wUu8MzCkQW7ZFi7ZEQETnXd+/KorJe/ZqxrJcz8/N0Q+eG+owkUd6LHO//dRFEWbBgAdauXStLcVXEhx9+iHfeeUc2q7/ttttuuX5SUhLS09NRq1YtE4yaiOwVj+mIyB4pNn18PYjS/RWg/7vVDqIIhXn5RUtquFWiSb0zurPBnfJnNvTl0LRskWJ3GEghsmhGCve6iYgs5dSlbJmBIDIRujcOtfZwyAbKewkrirKUyLHKec2ZMwdz586Fn58fUlJS5C0vT3+FpDBq1ChZesvggw8+wBtvvIGffvoJdevWNT4nOztbPi5+vvjii9i+fTvOnj2LNWvWYOjQoWjYsCH69+9vlXkSkXUVXRvHYzoisjv105ZDufF9/S99pwI9J5ssKqzKLyrtpVPD1YWFj26mYY2GiA2OhRb6ml46Lbcn9oaBFCJL7nTzO5KIyGIMJ8w7NQyWGQnk3Ho3DZfb4UMXMnHh6vUT7GT/Zs6ciczMTPTo0UNmixhuf/75p3GdxMREJCcnl3hOYWEh7r777hLPEaW+BNFM/uDBg7jzzjvRuHFjjB07Fm3btsWmTZvKLN9FRI5PV3R5HI/piMieuOz7Fc0vzNX/0vN1oPOzJn39wgJDs3k1+xBWMCtF66IPpGhZ2svuMFRIZMGdbiIishxjWa9YfSYCObdQPw/cFl0Du85ewaojKRjTuWLln8h+SqjejGgQX5zIMrkZLy8vrFixotpjIyLHUYGvGiIi2xL/H5T/vSAXNR2fhrKbftmUVAWqoiV2Tq+IgfUG4geXI3I5n7W97A4zUogsgBkpRESWlZKZjwPnr8rv3T6xYdYeDtkIlvciIqLqH9PxoI6I7MDFfcDfj8JFp8W54O7Q9nzTLCel1IaMFBe1yV/bEdXwrAEvpf50fCHjKHaHgRQiS/ZI4U43EZFFrDqmP1HeOioQYX6e1h4O2VggZefZDFzJKTroIyIiqlTfSyIiG3f1PDD3PkCVC239njgQNdpsV/aqCg0BFGakVJSLi36LotXxtLy94V+MyBKMjQmJiMgSVh5JkT/7FZ04JxKigrzRtJY/NFodVhcF24iIiCpTRpDXxhGRTVPlAX88AGSnAmGx0Nw1CzozNoHXGAIpRX0/6NZ0Sn1zFB0DKXaHfzEiC2BjQiIiy8nMU2HbqXS53C823NrDIRtj+DfB8l5ERFQZzEghIpsnAr5LJgIpBwHvYOCBPwFPf7O+pUZlCKAwkFL5jBRuUewNAylElqyny91uIiKzWx+fBrVWh4Zhvqgf6mvt4ZCNlvfadPISco2lCIiIiG6BPVKIyNbt+hE48DvgogDung0E1jH7W2rU+uwKuBT9pFtT6jcoOp6Wtzv8ixFZtEeKlQdCROQEVh7VZxowG4XK0rSWH6KCvFCg1mLjiUvWHg4REdlblQFrD4SIqCxJe4Dlr+iX+04F6ne3yNuqDYEUBTNSKspFURRIYWkvu8O/GJEl6+laeyBERA6uQK3B+uNpcpn9Uags4kri/rH6fxss70VERJWuMsCDOiKyNfmZwN+PAFo1EDsU6DjBYm+tVRd9OSqYkVLZs/HMSLE//IsRWTAjhZEUIiLz2noqHTmFGoT5eaBF7QBrD4dsVP84fSBlzbFUqDQ86CMiokoc0/GgjohssS/K1XNAQB1gyBcWjfhqjRkp178l6eZcjKW9lNYeClUSAylEFsAeKURElrGyKMOgb2w4FAp+51LZ2tSpgRBfd2Tlq7HjdIa1h0NERHaAGSlEZJP2/wYcni/OzgN3zwK8Ai369lpDRS8GUipOqd+QMCPF/vAvRmRB3OkmIjIfrVaH1ceK+qOwrBfdhFLhgj5N9T10Vh5NsfZwiIjIDrBHChHZnCvngP9e1i/3fBWIut3iQzAEUgxZFnRriqJEFGak2B8GUogs1B9F4E43EZH57E+6ikvXCuDn4YqO9YOtPRyycSJrSVh1NLXEtpqIiKgszEghIpui1QKLxgOF2UBUB6DLRIu+vfryZWRv2ACPpCv6OxhIqTAXY0YKAyn2xtXaAyBydMXPzYgGt0REZN6yXj1iwuDuymtF6OY6NwyBt7sSyZn5OHwhC80j2VOHiIjKZzisY7lmIrIJu34Ezm4C3LyBYd9cT3MwY+AkZ8sW5Gzdipydu6BOTpb3axvdp//pweOvinIpOhvP0l72h4EUIjMrHpPnLjcRkfkYSjT1K8o0ILoZTzclujcOxX+HU+S/HQZSiIioIlfI8do4IrK6jNPA6rf0y32nAsENzPI2mqwsZP23HFnLliF3584brxSGe/36yKmprwSQE+VvljE4IkXRRX860deG7AoDKUSWLO3FnW4iIrNISMvG6Us5cFO6oEeTUGsPh+xEv2bh+kDKkVQ836+JtYdDRET2kJHCYzoisiZxjmnp84AqF6jXDbhtrMnfIj8+Hlfm/IbMJUugy8sz3u8R2xS+nbvAp1NHeDZvAaWvD5Z9/A8UCYCLO08xV5SLmyEThRkp9ob/yoksmpHCvW4iInNmo3RqEAI/TzdrD4fsRK8m4bLxfHzqNZy9nIO6IT7WHhIREdl6jxQe0xGRNR2eD5xaCyg9gMGfAQrTnYzPO3wEl7/+Gtnr1hnv82jUEAFDh8LvjgFwj6xtvD8/R4WU+CtApv7YS8nSyhXGjBT7xUAKkZmV6F/LfW4iIrP2RxEZBkQVFeDthg71g7AlIV02nX+8W31rD4mIiGy90gCP6YjIWvKuAssn65e7vWiykl6F588j7cMPcW3Vav0dCgX8+vVD0IMPwOu222S/X7VKg7MHLyPxaAYunryC9As5+lWhvxBJ6WWSoTgFpav+dDwDKfaHgRQiM9MVy0lhGjgRkemlZuVj//mrcrlvUwZSqHL6xdaUgRSR1cRAChER3brZPBGRlayZAuSkASGNgc7PVPvltHl5uDzzW2TMng2dSiUDKAFDBiP4f0/Ao349aLU6JB7JwPFtyTh3OB2qAk2J5/sFe+KydxL2uWxD5wZNqz0eZ6FwZ0aKvWIghcjMSvTisuZAiIgclMgkEFrXCUSYv6e1h0N2pm9sON769wh2n7uCy9kFCPH1sPaQiIjIBhkTUnh1HBFZw/mdwO7Z+uXBMwDX6u2z5u7ejYuvvQbVuUT5u+h7Ej55MjwaNUJ+tgq7lp7B0c0XkX2lwPgc3xoeqNsiBLUb10BEo0B4+7vjtc2vYf+p1ejp0bx683MiCreijBQwkGJvWMCOyIK4001UPRs3bsSQIUMQEREh/39auHBhicezs7MxYcIEREZGwsvLC7Gxsfj222+tNl6yjJVFgRSRWUBUWRGBXmheO0CeIFtzTP9viYiI6EbMSCEiq9GogcXP6b+JWj0E1O1S5ZfSFRYi9f0PcO7hUTKI4hoejsivvkTUrFlQh9XB5r9O4pdXt2Dn4jMyiOLh44oWvSJx9yu3YdR7ndB9ZBM0bBsmgyiCSqOSP90V+t/p1pTu+r4yOheelrc3zEghMjNmpBCZTk5ODlq2bIlHH30Uw4cPL/X4pEmTsHbtWsyZMwd169bFypUr8dRTT8nAy5133mmVMZN5ZeWrsO3UZbnM/ihUVf1iw3HoQqbstXNfuzrWHg4REdlwjxReG0dEFrdnNpB2BPAKAvpOrfLLFCZdwIWJE5F/6JD8PWDEcIS/8go0bl7YueQM9q9KhLpQKx8LifJF6751UL91KFzdrmdOZBdmY2fKTuxI3oHD6YdxPP24vN9dyUBKRbkaAynMSLE3DKQQmRl7pBCZzoABA+StPFu3bsXo0aPRo0cP+fu4cePw3XffYefOnQykOKj18Zeg0uhQP9QHDUJ9rT0cslP9mtXEJ6tOYFPCZeQUqOHjwV1kIiIqGw/piMii8q4A697TL/d6DfAJrtLL5GzejNSXX4E2KwuKgABETH8Pvj17ImFPGjb/dQC5WYVyvfB6/rh9cD1ExQYZq6pkFmRiTeIaLDuzDLtTdkOjK9krJcgzCG3D21Z3pk5D6XE9kKLTauGiYGaKveBRIpFFM1K4201kTp06dcK///4rM1ZEFsr69etx4sQJzJgxo9znFBQUyJtBVlaW/KlSqeStMgzrV/Z5jsIa819xKFn+7BMTavXPnX9/+51/vSAP1AnyQmJGHtYeS8EdVchusuf5m4ozz52IHB97pBCRVWz8GMjLAEKbAm3GVCmbLnDzZiQvXQZotfBs2QKRn36KfK9gLP36oGwiL/iHeqHjsAZo0CbU+D135PIRzD0+F/+d+Q8q7fX9vDp+ddAxoiNah7VGbHAsov2joWCZqgpTeuizd3QKJaBWA+7M5rEXDKQQmVmxOAozUojM7Msvv5RZKKJHiqurKxQKBX744Qd069at3OdMnz4dU6ZMKXW/KAvm7e1dpXGsWrUKzsxS81drgdXHRDq0C3yuJGDZsgTYAv797XP+DTwUSIQCv6zeB+05fUkDZ5o/ERFVrNIAD+mIyGLSTwE7vtMv958GKCt3Glen0eDSu+8ibPESYymvWm+9hYSDV7D+t50ozFND4eqCtv2j0faOulC66YMhO5N34uv9X2Nv2l7jazUMbIiB9Qaif93+qOPPUrjV4ebhIX9qRUaKWg0XBlLsBgMpRGamLZ6SQkRmD6Rs375dZqVER0fL5vTjx4+X2Sl9+vQp8zmTJ0+WvVWKZ6RERUWhX79+8Pf3r/TV2OIkat++feHmpk/XdSaWnv+mk5dRsGMvQn3d8cQ9faFQWPfUBv/+9j3/sHNXsO7HXTiR7Y6+/XvATalwqvmbgvgMFi1aZO1hEBGZhZbd5onI0la+AYhMkIZ9gYZlH8+WR1tYiIsvvoRrK1ZA5+KCkEkTETjqEaydewLHt6cYy3j1Ht0UNWr6GDNQPtnzCXal7JK/uypcZeDkgZgH0CK0hRkm6JyUnp76BRcFtIUqKKp2/SZZAQMpRJYs7cWdbiKzycvLw6uvvooFCxZg0KBB8r4WLVpg//79+Pjjj8sNpHh4eMjbjcSJ0KqeDK3Ocx2Bpea/Jl7fZL5vs5rwKEqPtgX8+9vn/G+vH4pgH3ek5xRiX9I1dG4Y4lTzJyKiCpb2YiSFiCzh9AYgfikgGpL3f7dST9Xm5iLp6WeQs2WL2DlF8n33Inzw/fjno71IT8qW56baDqiL2wbVhVKpQEZ+Br7Y+wX+OfmPzL5zU7hhRKMReKz5Ywj3qXzJW6pYRoqgKVTx5Lwd4d+KyNyKBVIUjKQQmY2hp4ko51WcUqmEVlv1Mj1km7RaHVYdTZXL/WK5c0/Vp1S4oHfTMPy1Owkrj6RUOZBCRESOXdrLygmwROQMxPHritf0y7c9CoQ2qfhTc3Nx/n9PIHfXLrh4e6PWjBk4eCoLCz7ah4JcNbz83ND/8TjUblxD9k9ZdnoZ3tv5nmwoLwyuPxjPtH4GtXxrmWt2Ts/Nw8u4rMm/3q+VbB8DKUQW2uEWuM9NVD3Z2dlISLjeB+PMmTMy4yQoKAh16tRB9+7d8eKLL8LLy0uW9tqwYQN+/fVXfPrpp1YdN5negaSrSLtWAF8PV3RsEGzt4ZCD6BdbUwZSRJDu7TubsaEwERGV0Wze2iMhIod35B8g9RDg4Q/0mFzhp2nz83F+/HgZRFH4+qLOjz/gdE4ILu+KB3RqhEX7YcATzeFbw1NmoUzbPg2rzun7+zWp0QSvtn8VbcLbmHFiJLjJagoauazNz7P2cKgSGEghsmhpL+51E1XH7t270bNnT+Pvht4mo0ePxs8//4w//vhD9jx58MEHkZGRIYMp7777Lp544gkrjprMYWVRNkqPJqHwcBUN54mqr0ujEHi5KXExMx9HLmYhrnaAtYdEREQ2hqW9iMisNCpgXVEpr07PAD4Vu2hMV1goy3nlbtsOhbc3Ir/7DkdTArF94Qn5zdWgTSj6PBILVzcl9qbuxYsbX0RabhpcXVwxruU4WcZLlPQi83NzE6W9cuUyM1LsCwMpRGZWvNU8d7mJqqdHjx4y/bg8NWvWxOzZsy06JrIOUXpJ6NesprWHQg7E002J7o1DsfxIivw3xkAKEREZGPZBeW0cEZnV/rlAxmnAOwToULELAnVaLS5OfhU5mzbBxcsLkd/OxIGz/ti36rR83LdeIXqNbgKlqwK/HPkFM/bMgEanQV3/uviw24doGtzUzJOi4tzdvABdtmw2rylgIMWelCwkX03vv/++vOL+ueeeK3HSS9xX/HbjlcGJiYmyMbC3tzfCwsJkWRa1Wm3KoRFZTfGTvtzpJiKqvoS0bJy6lAM3pYvMSCEypX7NwktkPZHtmz59Otq1awc/Pz95LDFs2DDEx8ff8nnz5s1DTEwMPD090bx5cyxbtqzUPtybb76JWrVqyZKRffr0wcmTJ804EyKyZSztRURmp8oHNnygX+46CfDwq9DT0j78CFlLlwKurqj9+efYezYQ+1Ylysc6Dq+PwJgCqHQqvLb5NXy8+2MZRBlQbwD+HPwngyhW4OrqCRedvrSXpqDQ2sMhawRSdu3ahe+++w4tWrQo9djjjz+O5ORk4+3DDz80PqbRaGQQpbCwEFu3bsUvv/wiy7OIgxYih8tI4V43EVG1GZrMd2wQAn9Ppp+TafWKCZON54+nXMO59BxrD4cqQPTDGj9+PLZv345Vq1ZBpVKhX79+yMkp/+8njjtGjhyJsWPHYt++fTL4Im6HDx82riOOWb744gt8++232LFjB3x8fNC/f3/k5+dbaGZEZEvY+ZKIzG7PbCDrAuBfG7htbIWekvHLL8j4+We5XOvdd7HvQhgOrk2Sv/d4sAma96yNHG0Onlj7BBafXgyli1L2Qvmg6wfwdvM263SobKKEmiGQIkqykZOV9hLNf0U9+h9++AHTpk0r9bjINBHlVsqycuVKHD16FKtXr0Z4eDhatWqFd955By+//DLefvttuLuLBjxE9usmVYiIiKgKVh4tKusVq88cIDKlQG93tK8XhK2n0mXQ7rGu9a09JLqF5cuXl/hdXJQlMlP27NmDbt26lfmczz//HHfccYfMhBfE8YcIwnz11VcycCKyUT777DO8/vrrGDp0qFzn119/lccrCxcuxP3332+BmVFlib/bnnNXcDnb/stkqNUaHEh3gfJIKlzN2AsszN8TraMCecFXBTAjhYjMqiAb2Pixfrnbi4Cb5y2fkr1pM1I/0F+sHvbiCzimjcWhDYky3tvr4Rg07RSBxKuJ+D77e6RnpcPPzQ8f9/gYnSI6mXs2VMFAiqZQZe3hkKUDKeIKMJFVItLdywqk/Pbbb5gzZ44MpgwZMgRvvPGGDK4I27Ztk6n04qDEQFzp9eSTT+LIkSNo3bp1qdcrKCiQN4OsrCz5U1x9Jm6VZXhOVZ7rCDh/887f8Lpih9sWP2P+/Tl/InuSlpWPfYlX5XJfBlLITESQTgRSVh5hIMUeZWZmyp9BQUHlriOOQSZNmlTiPnEMIoIkwpkzZ5CSkiKPbwwCAgLQvn17+dyyAimmPEZx9v2Tqn4GmxPS8cgve+A4lPjpxAGzv8tfj9+O1nUCYUts8f8BUU3D0IvA3OOyxflbkrPOm5zcjplA7mWgRj2g9UO3XL3w7FlceP55QKtFwN0jcCaiN/Yu0vdE6fmgPohyOvM0xq0ah3RtOmp618S3fb9Fg8AGFpgM3YyrwhUwlvay/4s/nEm1Ayl//PEH9u7dK0t7leWBBx5AdHQ0IiIicPDgQZlpImoW//PPP/JxcYBSPIgiGH4Xj5VXB3nKlCllZrcYAjRVIa5Cc2acv3nmnymz9MSXpK5U7W1bwr+/c8+fyF6sOqYv69UqKhDh/re+SouoKvo2q4m3Fx/F7nMZ8sr2EF8Paw+JKkir1cp+jZ07d0ZcXFy565V3DGI4/jD8vNk6ljhG4f5J5T6D7WkiVUAJb6UO4axWckvJuUC+xgXLNmxDcrBtptHb0v8DJ86LyugK2eN12bKzTjd/IjKj/Cxg61f65Z6vAsqbly/WZGfj/PgJ0GZlwatVK1zpOw47fk+Qj3Ua0RCxXSIQnxEvgygZ+RkIVYRidr/ZiAyItMRsqAKBFBfoAynaAgaOnSaQcv78eTz77LNy4y6aNJZl3LhxxmWReSKaNfbu3RunTp1CgwZVi4JOnjy5xBVk4mqvqKgoWQvZ39+/Slc7iDn07dsXbm7OV2ud8zfv/FOz8vHmno1QKBQYOLA/bA3//pz/okWLrD0MogoTGQICs1HInGoHeiGutj8OX8jC2mNpuLddlLWHRJXIlBd9TjZv3mzx9zblMYqz759U9TPI3p0EnDqKjo3C8O2DpSsb2BNL/Bt4+Kdd2H7mClq1ao2BzcsuxW0ttvj/wMk1CUDSadSNjsbAgU2dbv6WxGMUcjq7ZwH5V4HgRkDciJuuKrLiLr74EgpPnYJrWBjw7LvY+H+n5GNtB0Sjdd86SLiSgMdXPo4rBVcQUyMGd2nuQrg3j59sqbSXISNFxR4pzhNIEXWH09LS0KZNmxLprhs3bpT1hUVqu1JZsp6rSIcXEhISZCBFlPvauXNniXVSU/UnScrrq+Lh4SFvNxI7GNXZyaju8+0d52+e+bu66r8cxfVxtvz58u/v3PMnsgfX8lXYdipdLvdvxgMBMq9+sTVlIEX05GEgxT5MmDABS5YskccikZE3v+JSHGcYjjkMxO+G4w/DT3GfuBCs+Dqip6OljlG4f1K5z8BFoT/2VCoUDvO5mfPfgFKpKPrcbPfzsqX/B8SFcYbPzVJjsqX5E5GZFOZez0bp+jxQtC0rz+WZM5G9bh1c3N3h+84MLPkrCVqtDo3ahaP9nfVlOa/HVj4mgyixwbGY2XMmNq3eZJm5UMVLe0Erl9XskWJX9HsCVSQySw4dOoT9+/cbb7fddptsPC+WbwyiCOJ+wXBA0rFjR/kaIiBjIK68EFdtxcbGVmd4RDZBB32aPJsSEhFVz4YTl1Co0aJ+iA8ahPpaezjk4PoVBes2nryMnAK1tYdDt2gwLoIoCxYswNq1a1GvXr1bPkccg6xZs6bEfeIYRNwviNcQwZTi64gMkx07dhjXIdujLeoGruCOd4UYPidDE3W6OcPHxH9dRGRSe3/R90YJjAaa333TVXN37cLlr7+Ry4GvTsHqVfkozFOjZv0A9BoVg9TcVJmJkp6fjpigGHzf93v4uftZaCJUlR4pamakOE9Gip+fX6nawz4+PggODpb3i/Jdc+fOxcCBA+V9okfKxIkT0a1bN7Ro0UKuL1LdRcDk4YcfxocffihrDr/++usyLb+sK7qI7I3hwMSFu9xERKYp69UsHC48SUZm1iTcD3WCvJGYkYtNJy/hjrjrWQlkW8RxgzjmEGVgxPGJoYeJaA7v5eUll0eNGoXatWvLPiaCKE/cvXt3fPLJJxg0aJDs+7h79258//338nHxHSN6rUybNg2NGjWSgZU33nhD9n0cNmyYFWdLtwqqCUWJA3QLhm2pIQBFFTyu4z4IEZmKugDY8rl+ucvEm/ZGUV+5ggsvviSby/veOQxbk6KQdTkT/iGeGPhkc+TqcvDk6ieRlpuG+gH1ZRAlwCNAlsojGyztVdQjhX8f+2LWXUx3d3esXr1aBktiYmLw/PPPY8SIEVi8eLFxHZG1IlLwxU9xdddDDz0kD3SmTp1qzqERWYzxsIT720REVVao1mLd8TRjySUicxMnyvoV9eIxBPHINs2cOROZmZno0aOHzHo33P7880/jOqI5dHJysvH3Tp06yeCLCJy0bNkSf//9NxYuXFjiIrGXXnoJTz/9tOz52K5dO2RnZ2P58uXl9oYk69PyRHelKFxKfm5UsUoDREQms/834Foy4BcBtHrgphcKJL/+BtQpKXCPjsapuAeRnJAJdy9XDBrfEkpv4Nm1zyLhagJCvULxbZ9vUcOzhkWnQhWnlOXb9KW9NAykOE9GSlnWr19vXBbNFTds2HDL50RHR2PZsmWmHgqRTV0Zx8M5IqKq2346HdcK1Ajx9UDrqEBrD4ecRL9mNfHj5jNYczwNKo0WbkX9BMg297UqeoxicM8998hbecTJeHFxFy/wsh+aoogAS3tVjOFzErX1qTIZKdYeCRE5BI0K2DxDv9z5WcC1/Ko8V+bORbYoN+rmhrwnpuHIiqILzMY2Q2BNL7yy8RXsTt0NHzcfzOwzE7V8mUlt8wylvVT6n2QfeDRIZGbc4SYiqj7R8FvoGxsOheESWiIzaxtdA0E+7sjMU2HXmQxrD4eIKtwjxdojsbeMFAZSKtcjhf/AiMgEDs0DriYCPqFAm1HlrpYffwJpH3wolz2fehlb1ufI5bYDohEdF4wv9n6B/87+B1cXV8zoMQNNgppYbApUHYZACnsx2hMGUogshDvcRERVI66UXXU0tUQDcCJLUCpc0DsmTC6vLPo3SES2yxAPYEZKZXukWHsk9oEXyBGRyWi1wObP9MsdxwPu3mWuplOpkDx5MnSFhfDo3hPb0hpAXaBB7SY1cPuQ+lh+djlmHZ4l153aeSo6RnS05CzIBIEUjVpf4ovsAwMpRGbGHW4iouo5eCETqVkF8HFXolODYGsPh5ywvJew8khKhUpIEZH1GDIruN9dMcxIqVqPFP7zIqJqS1gNXI4HPPyB28aWu1r6rFnIP3oULgEBSGj1GK4k58I7wF2W9DqVmYA3t7wp13uk2SMY0mCIBSdA1eZS1COFgRS7wkAKkZlxh5uIqHrECWyhR0wYPFxFYz4iy+naKARebkpczMzHkYtZ1h4OEd2EIbNCyUhKhbPuBAaJK4gXyBGRqWz9Qv+z7WjA07/MVfJPnMClr7+Ry3lj3sTJA1fhonBB/8eaQe2Zj+fWPYc8dR7a12qPZ9o8Y8nRkykzUjQMpNgTBlKILJaRwj1uIqKqMJRU6hfLsl5keZ5uSnRrHCKXWd6LyF56pHC/uyJY2quKPVL474uIquPiPuDsJkDhCrR/osxVdGo1kie/CqhUUPQYiN0nfOX97QbVRc2GAbK5fOK1RET4ROCjbh/BVbwW2RkGUuwRAylEFmtKSERElXXqUjYS0rLhpnRBz6JeFUSW1i/2enkvIrJdhswKBY9yK8QQcGJpr8r9++JxHRFVy9av9D+bDQcCIstcJf2n2cg/cgQu/gE4Wu9eFOapEV7PH23viMYPB3/Apgub4KH0wIyeM1DDs4Zlx08mog+gaDXcBtsT7mISmZkxVZ573ERElWZoMt+hfjD8Pd2sPRxyUr1iwmQJnOMp15CYnmvt4RBROQyZFcwYqGyPFGuPxD4Y403850VEVXU1ETiyQL/caUKZqxScPo3LX36pX33km7h4Jgeu7gr0GROLg+kHMfPATPnYGx3eQGxwrOXGTqblos9IYSDFvjCQQmRm3N8mIqo6QwYAy3qRNdXwccftdYPk8sqjzEohsv3SXtYeiX1lpLBHSmWP6/gPjIiqaPu3gE4D1OsO1GpZ6mHxfZwy9R3oVCpouw7C/lPe8v7OIxpCWUODVza9Ao1Og0H1B2Fow6FWmACZDgMp9oiBFCIzY48UIqKqSbuWj33nr8rlPgykkJX1a6b/N8g+KUS2y5BZwR4pFWP4mFjaq7LHddYeCRHZpbyrwN5f9Mudym4On7V0GXK3b4fO0wuHa98FjVqLOs2C0KxbbUzbPg0Xsi+gtm9tvNb+NcuOnUzPpai0F1uk2BUGUojMrqiWLne4iYgqZc2xNHnSomVkAGoFeFl7OOTk+hYF83afzUB6doG1h0NEN+uRwh3vSvZIsfZI7IPOcFxn7YEQkX3aPQsozAbCYoGGvUs9rLl2DakfvC+XM+56CZdTCuDh7Ypeo5piyeklWHZmGZQuSrzf9X34uftZYQJknkAKtyr2hIEUIjNjixQiomqW9Wqmb/RNZE2RNbzRLMJfnnBcczzN2sMhojIYMisYR6lsjxRGUiqCGSlEVGV5V4Atn+uXOz9X5hfJpS+/hObSZagbtMCRy/rjn853N0SGIg3v7nhX/v5EyyfQKqyVZcdO5g2kcBNsVxhIIbJULV3ucRMRVVh2gRpbEtLlMvujkK3oF6s/qF15hOW9iGwRS3tVtUeKtUdiX9gjhYgqTQRR8jP12SjN7y71cP6xY7gy5zd5/ujk7U9ArdKidpNANO4Qjre3vo0cVQ7ahLXB480ft8rwyfR0Sn0gxSVH3yuF7AMDKURmxowUIqLK2xB/CYUaLeqF+KBhmK+1h0NUok/KppOXkFuotvZwiOgGbDZfOYYLvbS8HLZSpeMYpyOiSslOA3Z8p1/u9QagUJZ4WKfVImXKVNksI7PvY0hO1kHpqkCPB2Iw/+R87EzZCS9XL0zrPA3KG55L9utqsH5jorxSgMKkJGsPhyqIgRQiS9XS5Q43EVGFrTxaVNYrNpwZfWQzYmr6ISrICwVqLTaeuGzt4RBRORcwMSOlsqW9rD0SO6s0YOVxEJEdZqOocoHabYEmA8psMJ+3fz/U/iE44nabvK/d4LrI88nEp3s+lb8/0/oZRPlHWXzoZD6FPvqfalcfXJn7u7WHQxXEQAqRmV1PlecuNxFRRRSqtVhb1IPCkAFAZAtEUM9Y3qso2EdEtsOQWcEAfGWbzTOSUhHGj4n/voiooq6lALt+1C/3fLXU94c2Px9pn+qDJYl9nkdBrgbBtX3Qsk8UpmyfIkt6tQpthZExI60xejKjwkB9Fsql0Na4tGAJtLm51h4SVQADKURmxqaXRESVs+NMOq7lqxHi64FWUTWsPRyiEgw9e9YcS4Nao69tTES2QcPSXpXCZvNVPK6z9kCIyH5s+hRQ5wNR7YEGvUs9nPHzL1AnJyO7fjuczfCXXzA9HorBsnNLseXCFrgr3DGl8xSW9HJA6hrnkeF1ERqlBy74NEfm4iXWHhJVAAMpRGbGHilERJVjaOTdNzYMSp4NIxvTNroGani7ITNPhZ1nM6w9HCIqhqW9qtgjhYGUCmFCChFVSuYFYM9s/XLP10p9eagvXUL6999DBxckxI2S98V2qgXXmip8sPMD+ftTrZ5C/YD6lh87mZ2bUomDtTbI5aTI7kif85uxFxfZLgZSiCyEB3RERBUry7LqqCGQwrJeZHtclQr0bhpeIuhHRLaBzearWtrL2iOxDwzUUVlmzpyJFi1awN/fX946duyI//77z/h4fn4+xo8fj+DgYPj6+mLEiBFITeX+g1PY9AmgKQSiuwD1upV6+NKXX8lyTpfa3YOMLAXcvVzRfmgDfLr7U2QVZqFpUFOMbjbaKkMn83N1UeJkyB7ANQ/5nsG4cMUbeXv2WHtYdAsMpBBZKiOF+9tERLd08EImUrLy4eOuRKcGIdYeDtFNy3uJoB+vHCOyxZK63PGuCJb2qiyW9qLSIiMj8f7772PPnj3YvXs3evXqhaFDh+LIkSPy8YkTJ2Lx4sWYN28eNmzYgIsXL2L48OHWHjaZ29VEYO+v+uWek0udEMqPP4Grf/8NlasXTgb3kPfdPrgejuYexOLTi+ECF7zZ8U24KlytMXqyUCBFo1RBF3lI/n4+sieuzptn7WHRLTCQQmRmOu5wExFV2Ioj+gbePWLC4OnGWsBkm7o2CoWnmwIXrubhaHKWtYdDREUMmRUsC1kxhs+JcZSK4QVyVJYhQ4Zg4MCBaNSoERo3box3331XZp5s374dmZmZmDVrFj799FMZYGnbti1mz56NrVu3ysfJgW38GNCqgHrdgbpdSj2c9uGHIhUfF7o/hYJ8HWrU8kFMtzC8u+Nd+fjdje9GXEicFQZOluLm7it/qmqshUIBZAY2xIWNh6HJzLT20OgmGNokstgON/e4iYgqGkjp36ymtYdCVC4vdyW6NQrFyqOpsrxXs4gAaw+JiOR+N0t7ValHCmt7VQiP6+hWNBqNzDzJycmRJb5ElopKpUKfPn2M68TExKBOnTrYtm0bOnToUO5rFRQUyJtBVpb+wg3xeuJWGYb1K/s8R2Hx+Wclw3X/XHkxrbrri9Dd8L65O3ciZ8sWZPtH4YxW3/+k4/B6+P3470i4moBAj0A82fxJk42Xf3/bnL8iqCFw5QDUBfGoF+uJU4fzkRTaHnUXLETggw84/PwtxdTzZiCFyMx4WEJkOhs3bsRHH30kD0qSk5OxYMECDBs2rMQ6x44dw8svvyxT59VqNWJjYzF//nx5wEK2LSHtGk5fyoGb0gU9moRaezhEN9WvWU19IOVoKib2bWzt4RCRDAjof/JEd2VLe1l7JPZVaYDoRocOHZKBE9EPRWSjiGMUcQyyf/9+uLu7IzAwsMT64eHhSEnRXzxUnunTp2PKlCml7l+5ciW8vb2rNM5Vq1bBmVlq/nFJv6GBVoXLvk2w5VAGcGjZ9Qd1OkR9MxNe4ri11SgZoPUKV2Fzwgp8lfWVXKWHoge2rtlq8nHx729b8z+Xly5/5igUqJE3H8AgpIa3w7lfP8PWwACTpz/a2vztFQMpRBa6Mo7Hc0TVJ67uatmyJR599NEyawufOnUKXbp0wdixY+WBh2j4KOoTe3p6WmW8VDkrihp3i94o/p5u1h4O0U31jgmTJyGPJWfhfEYuavrx3yyR7TSb54535ZrNM0BQESztReVp0qSJDJqIUl5///03Ro8eLS/qqo7Jkydj0qRJJTJSoqKi0K9fP3mMU9krssVJ1L59+8LNzfn2Vyw6/5zLcP36CbkYOGQaBtbvWfLhDRuQnJiIjPAWuKaIgELpgqFPdMQH8dNQkFWAuOA4vN7vdShcTNeJgX9/25y/T5IP1m9cj5Xe3nghfykSQofj6iXgCqLRKzISni1bOvT8LUXMf9GiRSZ7PQZSiMzMcFjCHW6i6hswYIC8lee1116TNYo/FDVnizRo0MBCo6PqWsmyXmRHavi44/Z6Qdh+OkNmpYxqH2ntIRE5PUNmBUt7VYzhczJc+EUVPK5j90u6gcg6adiwoVwWfVB27dqFzz//HPfddx8KCwtx9erVElkpqampqFnz5vu7Hh4e8nYjcSK0qidDq/NcR2CR+e+dBahygVqt4Nq4b4kTQTqtFhlffQ0dXHC25cNAIdC8eyQSlafw37n/5HfLGx3fgId76b+7KfDvb1vz7xndE3X8opB47TwWu1xFXPN8bF7rggsRXZH1zwL43XabQ8/fXjGQQmSpK5e4w01kVlqtFkuXLsVLL72E/v37Y9++fahXr568muvG8l/Fsf6w6VRn/smZ+TiQlCmPNXo2DrLLz5B/f+ebf++YUBlIWXE4GSPbhDvd/G/kzHMnW+uRwv3uSvVIYRylQpiRQpU5LhHHFyKoIk5crlmzBiNGjJCPxcfHIzExUZYCIweTnwXs+F6/3PX5Ul8W15YvR8Hx40ir0xVXC73h7uWKtgOi8djGR+TjwxsNR2xwrDVGTlagVCjxUOzDeG/He5gT4Id56j+xTXk/cnxrI2nzQtTKy4PCSxSBI1vCQAqR2bG0F5ElpKWlITs7G++//z6mTZuGDz74AMuXL5clwNatW4fu3buX+TzWHza9qsx/Y7L4klSirq8OOzeugT3j39955q/MF/91xa6zGViwbBV83Zxr/kS2xlCiivvdFcPSXlXrkcJ/XlScuGhLZMyLfozXrl3D3LlzsX79eqxYsQIBAQGy5LAo0RUUFCRLcj399NMyiHKzRvNkp3b9CBRkAiFNgJjBJR7SqdW49MWX0ChccabJCEAFtOlfB+svr8HBywfh7eqNCa0nWG3oZB1DGwzFV3s+RyJysO3if2jU9ikc35mB80HtELN6DQKGlPx3RNbHQAqRxTJSiMjcV34JQ4cOxcSJE+Vyq1atsHXrVnz77bflBlJYf9h0qjP/P2bvBpCB+zo3wcDOdWGP+Pd3zvnPS96GYynXgIg44NJhp5u/OWsQE1W9tBf3vCuCzeYriRkpVM7FXKNGjUJycrIMnLRo0UIGUcT+gDBjxgwoFAqZkSKyVETm/DfffGPtYZOpFeYC277WL3edBChK9jjJXPQvCs+excVGg5CrcoNvDQ/EdA/Dq0v/Jx9/NO5RhHiFWGPkZEXebt64J+Z+zDo8C7/6eeLDmodwHLVxKbQVLi/6l4EUG8RACpHFeqRwj5vInEJCQuDq6orY2JLp0E2bNsXmzZvLfR7rD5teZed/NbcQO89ekcsDmkfY/WfHv79zzb9/XE0ZSFl3Ih1Dajjf/Ilss9m8tUdiHxRFHxR7pFQMe6RQWWbNmnXTxz09PfH111/LG9kJ8Z0Yv0z2OUFA7Yo9Z/9vQO5lILAOEDei5MupVLj8zTdQuXrhXJ3+gAa4fUg9/HnqD1zMuYgw7zCMajbKPHMhm/dA0wfwy+HZ2OvpibSk7xAY8j7+n737gI6q2voA/s9MekghgTQIvfdeVZAqKNLsCirYsNfn83s27O0p+sCGCBawCwgiUqQovfdOIJCEhJLek5lv7TPcMGmQhMzcKf/fWrOmZnLOZHL3vXefs0/qGSD2YAEaJCXDKyJc7yaSlZIpUiKqcZyRQmS/RR67d++u6g5bO3jwIBo2bKhbu+jSlu9LRpHJjFaRgWgYFqB3c4iqZEgby2Kx/xw5i/wivVtD5N60/W4tQUAXp43zYmmvytESThwfR+Titn4NfH8b8N0tlXu9qQhYN9Vyu8+jgLHkgJq0BQtREB+PEy1GIr/IiNDoANTt5IPpO6er5x/t/Cj8PLkWhruSRNqwBgPV7W8KEtCmq2WQZ2JET6QvXKBz66g0JlKIbKx4hBd3uIkum6yBsn37dnURsbGx6rYs2CieeeYZ/PDDD5g+fToOHz6MqVOnYsGCBXjwwQd1bjldzJ97TqnrIW0tJ6SJnEnrqEDUr+2H3AIT9qcx2Oth9erVGDFiBKKjo9UM4Hnz5l309XfddZd6XelL27Zti1/z8ssvl3m+VatWdugN1cwaKfxfrNoaKXq3xDnwYyJyE6vesVyf2lm518vslZRjgG8I0Om2Ek+Zi4pw9rPPkO9VCyci+6rHeo1qis92forMgky0Dm2NEU1H1HgXyLmM63Cvul4S4I8Q88/w8DAjPbgJ4heu5qxRB8NECpHdpoAT0eXavHkzOnfurC5C1jaR2y+++KK6P3r0aLUeyjvvvIP27dvjiy++wC+//IIrrrhC55ZTRXLyi7D60Gl1e2jbCL2bQ1RlcsJWm5Wy6xyjvR6ysrLQsWPHSpdN+fDDD1Ute+1y4sQJtQjwjTfeWOJ1klixft3FykSSY2Bpr+qukcKTNJVRPD6OiToi1yXrbqafrNrPrD0/G6X7RMC75Oz69D8WI//4ccQ1vw5FJgPCGwbC2DAbPx/8WT3/VLenYPDgqVl31zqsNXoENUWRDAg6NR8NWwWrx4/nRSN37169m0dWuEYKkY1xh5uo5vTv3/+SIzImTJigLuQcVh08rUbyy4j+NlFBejeHqFqGtI3Al2tisTvFA4VFJnCJFPsaNmyYulSWLAYsF43MYElJScHdd99d4nWy7lZkZOVnyskiwnLRpKenq+uCggJ1qQrt9VX9OVdSnc9A/v+E2WRy+s/OHt8B+ZxEYaHjfV6O+D9QdP7zMpmKbN4uR+y/Pblrv8kBnNpx4bbPhX2FCp3cDJxYDxi8gB73ldnGnv3sU+R5ByE+oq8aZdvj+ib4ZOd7KDQXom90X/SM6mmDTpAzuq3TJGxc/TTm+hrwRUwSju3zw6nInkj9fRH8rGZNk76YSCGyMfP5OSlMoxARlbXkfFmvoW0jmXAmp9WtYW2E+HkhNacAW+JScUULzq5ytoWCBw0aVGY9rUOHDqlyYbJQcO/evfHmm2+iQYMGFb6PPD958uQyjy9ZsgT+/v7VatvSpUvh7qryGZxKklG9BuzetQuByZUsyeLgbPkd2J8ocdeIk/HxWLToBByRI/0PJCRYvl/79u7FopQ9btd/IrdwcMmF20X5l369tjZK+xuBwJKDLzKWLUPeocOIa30riswGRDYJQn7UOfy++Xf1/CNdHqnZtpNT69dwICIMvkhCLvanfgJfnyeQiyDE/n0IkU+b4GHgzCVHwEQKka0Vz0jRuyFERI6loMiE5fuTixMpRM7K02jA1a3qYu62BCzdl8xEihNJSEjAH3/8gTlz5pR4vGfPnpg1axZatmypynpJguTKK6/E7t27ERgYWO57Pffcc6rkpPWMlJiYGAwZMgRBQUFVHo0tJ1AHDx4MLzed4lSdz+DXs1uBlDPo2LEDhnepB2dmj+/A6XXHMffYAURFRWP48A5wJI74P/Bnxg5sO5ukyv4N71VxUtVV+29P0v/58+fr3QxyR4eXXbhdmGNZSN5gLP+1KceBvee/p70fKvGUVFE48+mnyPUJQXxkn+LZKO/veFUNth3UYBDahnGWAV3gafDEjU2vx9RDP+LHnEO4r2sodq1NQYJnU+Rs3wH/Lpby5qQvJlKI7LZGCjMpRETWNsaeQ1pOAcICvNG1YW29m0N0WQa3CleJlGX7kvHy9WbOsHISX331FUJCQjBq1KgSj1uXCuvQoYNKrMiMlR9//BETJ04s9718fHzUpTQ5CVrdE6GX87OuomqfgeX/zsvT02U+N1t+B+RzUjw8HPbzcqT/AY/z6xh4Go12a5Mj9Z/I5eWkAPGbSz6WnwX4VjAYYsNnUr8LaNIfiGxX4qnMVauQt3cfjre+HSazAdHNQ5BWJwHLNixT54Ye6lQy8UIkxnaehE8P/ogdPt7wCVoDoA1O1+mAcwsXM5HiIDgviMhua6To3RIiIsfy5/myXoPbRMDIlYHJyV3RLAxeBjPiU3OxN9GyNgY5Nhkt+uWXX2LcuHHw9va+6Gsl2dKiRQscPnzYbu2jqtMWTTfyKLdSDOdjLxebr2LJZu6yELmmoystiZE6LQEP44VESnly04CtX1tu9y5bouvs59OR4xOKhIhe6n6PEY0xdbulDNi1Ta5Fs9rNbNULcmJ1/OpgcGATdfuPc98iKBAwGX1wZMNJmIuK9G4eMZFCZL8dbiIiusBkMmPJnqTihbqJnJ2ftxGtgi0xf+ley3ebHNuqVatUYqSiGSbWMjMzceTIEURFRdmlbVQ9Wj7AwDPdlaKNYWAipYoD5PRuCBHZtqxXs0GAd62LJ1K2zQbyM4C6rYBmA0s8lb1tG3K2bkVcoyEww4B6LUNwKvgo1sSvgaeHJx7s+KCte0JO7JbOlu/H7x4ZaNjZT91O8G+F7E2bdG4ZCSZSiOw2I4W73EREmp3xaTiVnosAbyP6NK2jd3OIakT7UEvQ15KEZB+S5Ni+fbu6iNjYWHU7Li6ueO2S8ePHl7vIvJTsateuZDkO8fTTT6tEy7Fjx7B27VqMHj0aRqMRt956qx16RNWlJQS43105WsLJxDxKpRTnm/j9InLNf/DDf1luS2LEO8ByW5IlpZlMwKYvLLd73Fdmm3Duy5nI8w5CYlQfdb/78MaYus0yG2VU81GICYqxaVfIuXVuPATN4YVcgwGxxu/UYymhrZC8YKneTSMmUojsuUYKERFp/tidqK6vbhUOX68KFnAkcjJta5vVCG8p7XXiXLbezXEbmzdvRufOndVFyILvcvvFF19U92WxeC2poklLS8Mvv/xS4WyUkydPqqSJLDZ/0003ISwsDOvXr0fdunXt0CO63EQKq0VWjvY5SZk7qkJpL70bQkQ1L3kfkJEAePoCDftYJVLKmZFydAVw7gjgEwR0uLnEU/nHjiFj2TKcqD8AJhgR2SQICUGHsTlpM7wMXri/w/126hA5KxkMcku9Aer2T9krUaeOB8weRhzZfg7mwkK9m+f2uNg8kY1pByYcuEREdGG7uHi3ZX2U4e1ZJodcRy0voFvD2th4LEWV95pwRWO9m+QW+vfvf9ETwbNmzSrzWHBwMLKzK052ff/99zXWPrIfbWYFS3tVjjZzhzNSKodrXxK5sCPLLdeNrgC8/C6eSNFmo3S8FfA5XwLsvLOzZqHA6If4mP7qftdrGuGNXf+nbo9qNgqRAZE27Qa5hut6PoUPfv4Dxw0G+LZMAc6EIDG4HbI3b0ZAL8u6O6QPzkghsjHOACciKklG6x8/mw1fLwP6t+TobnItg1qHq+sley3JQiKyHy2hxhkpVS3txUxK1SoN8AtG5LLrozQ9v95J8RopmSVflxoHHFxsud39nhJPFZ47h7S583CyXj8UeXghrF4tpEXGY13iOhg9jJjY/tJrshEJ/8AoXOtlOaZYZ/5WRaD0oMY4tWiV3k1ze0ykENla8aKE3OEmIhJ/7LKcYO7fIhz+3pwcS65lUGtLcnBj7DmkZOXr3Rwit6LNrOAaKVVdbF7vljgHzkghclH52cDxdRcWmhfaTJPSM1I2fwmYTUDjfkDdFiWeSpk9BwWFwMmGlvfoek1DfL7rc3X7uibXoV6tejbvCrmOsa1vU9dLTAdRp45J3T668xzMskYPuUYi5a233lI7rY8//njxY7m5uXjooYdUXeFatWph7NixSEoquQCn1Cy+9tpr4e/vj/DwcDzzzDMoZN03crVautzhJiJSo4UXnV8fZVh7Tm0n1xNT2x+to4LUicnl+5P1bg6Rm66Rwh3vytA+J66RUllcI4XIJcWtBYrygKD6QJ3mlse00l55VjNSCnKBrV9bbve4t8RbmHJykDJ7NhKi+qLA4Ivgun7Ib3QGq0+uhsHDgHs7lHw90aW07ngn2hQUocDDA5kxh9Rjp/xbIGf7Dr2b5tZqLJGyadMmfPbZZ+jQoUOJx5944gksWLAAP/30E1atWoWEhASMGTOm+PmioiKVRMnPz8fatWvx1VdfqTrG2uKQRC4zcknvhhAROYBDyZk4ejoL3kYDBrSyTFcmcjVD2kSo6yV7WN6LSJ81UvRuiXPQ8k0s7VU5nJFC5KKOni+X1KT/hX/w8tZI2TsPyD5rSbi0GFbiLdLmzUNBWiZONBqi7ne5piGm756ubl/T6Bo0DGpol66QC/H0xtiQturmn56/sLyXKyVSMjMzcfvtt2P69OmoXbt28eNpaWmYMWMG3n//fQwYMABdu3bFzJkzVcJk/fr16jVLlizB3r178e2336JTp04YNmwYXn31VUybNk0lV4icXfFxCfe4iYiwaJdlNspVLeog0NdL7+YQ2cSQtpZEyupDp5GTX6R3c4jccI0U7ndXaY0UVgmpFK6RQuSiYldbrhtfdeGx8tZI2WhJjKDbXYDRs0TsOffNtzgV0R15noEICPGBsUUmlsctV9uL+zrcZ59+kMsZ3uUh+JlM2OeZjOCQbPXY0W3JnEmqoxopTC6lu2RWyaBBg/Daa68VP75lyxYUFBSoxzWtWrVCgwYNsG7dOvTq1Utdt2/fHhERlgNOMXToUEyaNAl79uxB586dy/y+vLw8ddGkp6era/ldcqkq7Weq87OugP23bf+Ly9SZzQ75GfPvz/4T2dPi3ZYR+te0i9K7KUQ20yYqCPVC/BCfmqOSKUPbsowdkT1oMyuYR6kcLjZfNcUnrvj9InId2eeAxB3lJFJKzUiR18RvBgxeQJc7S7xF1tq1yDt6FCd63K7udxwQgy/3TVO3BzUchKYhTe3SFXI9tRr3w5BlBsz3AU5Gbkdgal8k+jRF7t698Gtrma1CTpZI+f7777F161ZV2qu0U6dOwdvbGyEhISUel6SJPKe9xjqJoj2vPVeeN998E5MnTy7zuMxukXVWqmvp0qVwZ+y/bfq/65zsaRuRlpqKRYsWwVHx7+/e/SeyhyOnM7H/VAY8DR4Y3Lpk7CdyJbJmoCRPvlwTiz92JTKRQmQn2swKzkipHK0EGvMoVZ2RQkQu49g/lv/uOi2BoKhyZqScT6Roa6O0vg6oVbI8cco33+JcaBtk+UfCy9eI2p2BP//4Uz13b3uujUKXwcMDY2MGYn7yciwKWIyb0UeV90pa/A8aMZHifImUEydO4LHHHlMnIH19fWEvzz33HJ588skSM1JiYmIwZMgQBAUFVWtEtvRh8ODB8PJyvzIj7L9t+++5Nwk4sAO1a4dg+PCecDT8+7P/8+fP17sZ5GazUfo0q4Ngf/f7fyP3cm0HSyJl2b5k5BYUwdfLqHeTiFweF5uvetJXFDGTUqU1eLTPjYhcQKy2Pkq/ko8Xz0jJAApygJ0/We53GV/iZfnHjyNz1SrEdXhY3W/TNxrfx85BkbkIvaN6o3VYazt0glxZp24Posm8xTjqnQ4//3PIyQ7Dka1JaKR3w9zUZSVSpHRXcnIyunTpUmLx+NWrV2Pq1Kn4888/1TonqampJWalJCUlITLSMjJPrjdu3FjifeV57bny+Pj4qEtpchL0ck6EXu7POzv23zb9NxotJ04MBoNDf778+7t3/4ns4Y/dlvVRhrfj6HxyfZ1jaiMq2BeJablYffA0hnBWCpEdEyl6t8Q5aJ8TS3tVrbQXv15ELrjQfOPSiRSrGSl7fwPy0oDgBkDj/iVeljJnDjIC6iGldit4GDzQqG8Qnlzxq3ru7nZ326cP5NI86rbAGI9AvIdcHKizCQ3irsGpoggUJCXBq1SFJ3LwxeYHDhyIXbt2Yfv27cWXbt26qYXntdtyYnL58uXFP3PgwAHExcWhd+/e6r5cy3tIQkYjo8NlZkmbNm0up3lEDkE7LuEBHRG5s7iz2dgdnw6jwYMnlMktGAweGHZ+LaBFuyxJRCKyLc4YqO4aKXq3xLkYLussChE5jPQE4OwhwMMANLqi5HPWa6Rs+8Zyu8u4EhuAoswspP7yK07UH6DuN+1SFwtPz0VOYQ5ah7ZGr6he9usLubQRzUbD02zG6jrr1f3U4KY4s2S13s1yS5c1IyUwMBDt2rUr8VhAQADCwsKKH584caIqwxUaGqqSI4888ohKnshC80LKcUnCZNy4cXjnnXfUuijPP/+8WsC+vFknRM5bS5cHdETkvrTZKD0bhyI0wFvv5hDZBct7EdkXZ6RUjXY+sHgRdbqoC2vN8wtG5BJiz5+IjuoI+IWUn0g5cxDISbHMRet0W4mXpM2fh+wCTyRFdFP321wdgdc3zVG372p7F5P6VGNCO96G/ntnYFlACjyNZ1BYVAdH1xxF1Di9W+Z+bD6W4oMPPsB1112HsWPH4qqrrlLlun791TLNTSt7tHDhQnUtCZY77rgD48ePxyuvvGLrphHZRfFxCWMoEbmxP86vjzKsvdUijkRuUt4rM69QlfciIvvsd8vsR6rKjBQmUirDfH6IHM+NErl4WS/r0l4qiQKg2SAguH7x02aTCSnfzsbJev1g9jAiqlkw1hb8hZS8FEQHRGNIoyF26QK5idqNcL235Tg6Nnibuo4/5wNTbq7ODXM/lzUjpTwrV64scV8WoZ82bZq6VKRhw4ZYtGhRTTeFyLF2uPVuCBGRTuJTc7D9RKo68TC0Leu4kvuV95JZKVLei2XtiGxLSwhwFHAVEykmvVviHJhvInIxx/+xXDe+suxzPucTKZpSi8xnrV2H7LgEJPR+SN3vOKg+Htn7gro9vu14eBpq/HQrubkr2tyM0P2fYH29bYg5Nxhng1si7Z91qD3oar2b5lZY3ZPIXlPAeTxHRG7qj/PrQ3RrWBvhgb56N4fI7uW9hFbei4hsh6W9qoYzUqp7XMcvGJHTSz0BpMYBHkYgpmeJp/JPnMChGx/A6d3nkykBdYEW15T88R++R1JEdxR6+iG4rh8OB+/AiYwTCPYJxuhmo+3ZE3ITXu3GYnhmNs4GxMNgToPJ6IPYZbv0bpbbYSKFyMa4RgoRubuFOy2JlOs6ROvdFCK7Y3kvIvvRZlZoCQK6OC3hxDxK5bDSAJELOb7Wch3dCfAJLPFUwnPPoTD5DM7sDrI80PEWwPPCGo8FSUlI/2uFKusl2vevj2/3WRakv6XlLfD38rdbN8iNBEVjZGAzFYQS/berh+KO5XOdMztjIoXIxrSNGo/niMgdnTiXrcp6ycmaYe1Z1ojct7yXkPJeRGT7/W4mUipHm1nBGSmVw0oDRC7k+BrLdcM+ZZ7K2byl5AOdS5b1Sv35Z6QENkVWQDQ8fYwwt0zB9tPbVTmvW1rdYtNmk3tr1e4WtMjLx5YGlpkoyf7NkLN3n97NcitMpBDZCXe4icidZ6P0bBzGsl7ktljei8g+TDzRXa0ZKUykVA4rDRC5YiKlb4mHC06dQr5XLWzr+AgSInsBN84C6rYoft5cWIjUn35G/PnZKK16RuL72Dnq9jWNrkEdvzr27AW5m9YjMTIrGydDjsDDlIMC7yAcX7RB71a5FSZSiOw1cok73ETkhhbuTFDXIzqyrBe5L5b3IrL3Ginc767sjDnBPEolMVFH5BoykoCzhy2F+hr0KvFU5spVONDiVqTUboX9rcbB3Pzaks+v/hsZKfk4XaeDul+vlz/+PPanun1Hmzvs2AlyS7XqYnhoR3h4FCHNa7d66NjuFL1b5VaYSCGyVy1d7nATkZuJPZOFPQnpMBo8cE07lvUi98XyXkT2nZFi4FFupXBGStVwjRQiFxF3fn2UiHaAX+0ST2WuWlWcJBFF6eklnk/54XvE17sS8DCgXsvaWJw2H4WmQnQO74y2YW3t035ya3Xa34wrcnKxq56lvFeiOQoFycl6N8ttcBeTyMZ4XEJE7mrhDstslL7N6iA04MICjUTuiOW9iGyPa6RUd40UvVviHLhGCpGLOFb++iimvDyc27JHJUk0RWlpxbfzT8Yj/Z/1SIiy/FzrfhH46eBP6vbtrW+3T9uJWl+H67NysT9yP2AqRI5/BBKWrNe7VW6DiRQiu+1wc4+biNzLAq2sVwfLSHwid8byXkT2LO2ld0ucg5Zw4oyUyrnwKfELRuTUjq8tN5GSvXkzTgc0L/FY/rnU4tupP/+EpLpdUOhVC4GhvtgTsAHncs8hMiASAxsMtE/bifxqo39UH/ghGwU4pB6K3XhC71a5DSZSiOy2KCERkfs4mJSBg0mZ8DYaMKQty3oRSXmv4e0tScUFO1nei8i2i81zz7sytIQT8yhVm/HErxeRE8s+ByTvKXeh+azVq3GmTvsSj+UkW2akmAsKkPLLL8WLzLfrF405B2ar27e2uhWeBk/7tJ8IgHf7GzAsKxvHa+9V9xPPesNsMundLLfARAqRjXGHm4jcuazXVS3qINjPS+/mEDmEER2j1fWyvUnIyivUuzlELoeLzVcNZ6RUDQfIEbmAuPMlkMKaq4W7raWtXouUkJYlHss+l6muM1auRGquPzICG8Do6YHc5sk4kHIAvkZfjG0+1n7tJxIth2FkTgG2NrAkUlICGiBjx/kEIdkUEylENsYdbqKas3r1aowYMQLR0dFqtOm8efMqfO0DDzygXjNlyhS7tpEsCWRtxL124piIgI71g9EwzB85BUVYti9J7+YQuRzT+SkpLO1VOVq+qYiLpFQKSzYTuYATGyzXDXqVeDg/Lg5J6b4wGb1RK8QbAR5Z6vGcFMt12s+/ID76CnW7aZdw/HDMMhvl+qbXI9gn2L59IPIJRLuYfgj2SoRH4WmYDV6IXbpT71a5BSZSiGyNO9xENSYrKwsdO3bEtGnTLvq6uXPnYv369SrhQva3NzEDsWey4ONpwMDWEXo3h8hhyL7AyPPJxfnbLbO2iKjmaPkAzkip6owUvVviHDhAjsgFnNxkuY7pWeLhzNV/40yYpaxX44514eNZpG7npeeiICkZqWs3ISm8m3osvKsXVpxYoW5zkXnSi0fb0bguKwtp3vvU/bgD6Xo3yS0wkUJkY+bzu9zc4Sa6fMOGDcNrr72G0aNHV/ia+Ph4PPLII5g9eza8vFhSSg+Ldp9S1wNahaOWD+sFE1m7vpMlkSILzqdk5evdHCKXopWoYh6laokUrRQxXQK/X0TOragAiN9SbiIl4+/VOBPWTt2u1zYE2WbL2ig5GflImzcPp+p2hcnog9qR/lia95s6z9Mnug+ahDSxfz+IRMtrMDynALujLOW9korqoijTUoqObIdnN4jsNgVc75YQuT6TyYRx48bhmWeeQdu2bSv1M3l5eeqiSU+3jOQoKChQl6rQXl/Vn3MV0m/Z5v2+y5JIGdY23K0+C/792X/r64o0rO2L1pGB2HcqAwt2nMSt3WPgKtz1b0+Ot9/NGSmVo5VA4xopVZyRwq8XkVPySNoFFOYCfrWBsGbFj5tyc5G06yTyO4TA08sDmwwrcbYoEQGIQV52IVJ+/Q0J0ZaZJy36hmPakbnq9m2tbtOtL0RS3qt+4wHwTtkOjxMFyPMNRcKyjYgZNUDvlrk0JlKIbOzCYQn3uIls7e2334anpyceffTRSv/Mm2++icmTJ5d5fMmSJfD3969WO5YuXQp3dTwTiE/NhbfBjLzYrVgUB7fjzn9/wf5fuv/NvT2wD0Z8tWIvgk/vsku7iNyBlhAwcpGUSjGc/5xY2quKA+R4XEfklDy0sl71e8gGsPjx7I0bcSawlbod0zYMv8bPRgPPKAQUAFknk3HunAcyG9dXi8zHRe5EekI66tWqhyvqWdZMIdJN21EYtnQVkooOwWBog9h1xxAzSu9GuTYmUohsjDNSiOxjy5Yt+PDDD7F169YqrUn03HPP4cknnywxIyUmJgZDhgxBUFBQlUdjy0nUwYMHu2VZMen/pOnL1e0hbaMwakQHuBP+/dn/yva/c1oufntvNY5keKBz3wGICvaFq3wG8+fPt/vvXb16Nd59910VBxITE9U6WaNGVXwUuXLlSlx99dVlHpefjYyMLL4v63HJ+546dUqtz/W///0PPXr0sFk/6PKxtFd110hhJqUqJZuZRyFyTh4nN1puxPQoZ30US1mv8Fb+2By3GXW9BgAFQF6RJ+Kj+6rnmnYNx8y46er2DS1ugNFgtHcXiEpqcQ2GLHgEbwftRf2cNjhpKQxBNsRECpGNcY0UIvv4+++/kZycjAYNGhQ/VlRUhKeeegpTpkzBsWPHyv05Hx8fdSlNToRW92Tw5fysMyssMmHrGcvWbnSX+m75Gbjz31/D/l+6/w3qeKFHo1BsPHYOi/cm476rmtqtfa4oKytLJTomTJiAMWPGVPrnDhw4UCJhHh4eXnz7hx9+UEn2Tz/9FD179lRxZOjQoepnrF9HjoWLzVeNNnGHeZSqzkghIqeekWK1PoqsEXXmny3IaNRb3Y8N2YWi40XI8s4GsoFcvzCkBTVWz/l3yMeu3bvgafDE6GYVr9lJZDe+QQhpMgBmz21A7A1I9amPzCMnUKup65QOdjRcbJ7Ixjgjhcg+ZG2UnTt3Yvv27cWX6OhotV7Kn3/+qXfz3MK62HPIKPBAbX8vXNWirt7NIXKKRefnb0/QuylOb9iwYXjttdcwenTVTmpIQkRmoGgXg1WZj/fffx/33nsv7r77brRp00YlVKTc45dffmmDHlBNsF4wnYmUyuGMlOoe1/H7ReRsfPPPwiMjAfAwAvW6FD+ef+wYkvJqq9vhMQH468wSdTvTN0tdp9RuZVlkPsofS3LnqceGNByCML8wXfpBVEabUbjaIxbG/NMwGzxx9I/zCUOyCc5IIbLXooQcu0R02TIzM3H48OHi+7GxsSphEhoaqmaihIWV3KGVUeFycqxly5Y6tNb9/LY9UV0PbxcJLyPHahBdzPD2UXj5tz3Yk5COw8mZaBZeS+8muZ1OnTohLy8P7dq1w8svv4y+fS2lO/Lz81WZMCn9qJEky6BBg7Bu3boK30/eSy7WpSK1kmdyqQrt9VX9OVdS1c+gyGqhj6LCQhQUOPe+tz2+A0VFhcWJFEf7rjni/4CWcJLPzdbtcsT+25O79ptsJzTr/DFkZHvAO6D48ay/paxXe3U7qkMw1ieuV7ezZYEUK017heKD2EXq9s0tb7Zfw4kupeU16LegCHs898AH/XF4VxLcq8C2fTGRQmRrrNVMVGM2b95coq69trbJnXfeiVmzZunYMsrOL8SSfcnq9siOUXo3h8jhhQZ4q5lbf+1Pxm87EvDk4BZ6N8ltREVFqRkm3bp1U4mPL774Av3798eGDRvQpUsXnDlzRpWGjIiIKPFzcn///v0Vvu+bb76JyZMnl3l8yZIlajZLdci6O+6usp9BkenC4e2yZUvh7yJHurb8DqSovJ8nCguLsGiR5QSho3Gk/4H0dFkPwQObNm5CxkGz2/WfyJmFZh0qU9ZLpK1ag3O1LeuqJYUdQeG5QjQJboJAjzDgiOU1ssj8gbqbkHsqF81rN0fn8M52bz9RhXyD4dtkIDzTtwPp/XEuPxym/HwYvL31bplLcpHdSyInmJHCRArRZZMTXdalOy6lonVRqOYt3ZuE7PwihPmY0SkmWO/mEDmF6ztGWxIp2+PxxKDmLBdjJzJL0XqmYp8+fXDkyBF88MEH+Oabb6r9vjKDRUvwazNSYmJiMGTIkBJrsVR2NLacQB08eLDbrjlU1c8gr9AEbFimbg8dMgSBvs59qGuP78Cp9Fy8vHU1PAwGDB8+FI7EEf8HPj66FsjORM+ePdC3aZjb9d+epP/z58/XuxnkijNSrBaaN2VnI/5QGkxtfBAQaMTqHEtZr8ENB+NQ3IXjSFlk/qPj76vbN7e4mftr5HjajkL3o09he0oe8nxq49DPK9DyNseK667CufcuiZxqUUIGWyJyXfO2xavrbnXMPLggqqTBbSLg62XAsbPZ2HkyDR1jQvRuktvq0aMH/vnnH3W7Tp06MBqNSEpKKvEauS/lIivi4+OjLqXJSdDqngi9nJ91FZX9DIpQVHzbx1t+xjUOdW35HfDxsnxmUhXNUb9njvU/YNm/8fL0tFubHKv/RE6qMA/BOcctt+t3K344a8MGnAluZXm4QximJq4pTqQkpc4pfp1HmzQc238M/p7+uK7pdfZuPdGltRyGHr89gs3mzTCgL7Yvj0XL2/RulGtiAXMiGysePc/zikTkos5k5mH1oTPqdte6qrYKEVVCgI8nBrexnJift92SjCR9yHpbUvJLeHt7o2vXrli+fHnx8yaTSd3v3bu3jq2ki7FeMJ2LzVeONvCBi81Xjvl8rQF+u4ici0fSHhjMRTD7hwEhDYsfz1i1GmfC2qnb6dEJyCvKQ0xgDFrUboHagcHY0GABCjolYlH2z+o1I5qOQIDXhfVViByGbzCMTQfAM9JSDvKssQlSd19YW5ZqDhMpRHZbbJ6IyDX9vjNRLfLbvl4QIvz0bg2RcxnVKVpdL9iRgALLIg9URZmZmSoRIhcRGxurbsfFxRWX3Bo/fnzx66dMmaJKxhw+fBi7d+/G448/jr/++gsPPfRQ8WukRNf06dPx1VdfYd++fZg0aRKysrJw991369BDqgyrteZZUreSDOc/J8mjVKV0qrsq/oj4/SJyKh4JW9W1OapziQBxatMh5PmGwmgE1sMyeGJQw0EqyRzqG4pt9ZZhd+MV+OvEX+q5m1repFMPiCqhzSgM8N8LY14szAZPLHrvH+SnpOndKpfDRAqRjRVPSOERHRG5qLnny3pdz0XmiapMFpwPC/DGmcx8rD54Wu/mOKXNmzejc+fO6qIlQeT2iy++qO4nJiYWJ1VEfn4+nnrqKbRv3x79+vXDjh07sGzZMgwcOLD4NTfffDPee+899R6dOnVSiZnFixeXWYCeHAdnpFSd9efEPMqlXcij8PtF5Ew8Erepa3P0hUXi8+PicKqwrrod3TIIK0+tULcHNxisrkP9QtX1hlMbUGQuQpfwLmqmCpHDajkMLQqBnc1nw1CUixTfBlj0r5/UwvNUc1yjcCyRA+PAJSJyZbFnsrD9RCqMBg9c1z4SG1fv0btJRE7Fy2jAyE718OWaWPyy9SQGtuaJ+qrq37//RUfTz5o1q8T9f/3rX+pyKQ8//LC6kHMwm8rOtKDKJ1IkEWXgEctFadsZ5umInHRGSnSX4sey1qzB2dC26nZBw3TkpOYgMiAS7epYSn3JjBRrnI1CDs8vBB5NB2Bw4j+YX+9LdE+8H/HGJlj179nAwHC9W+cyOCOFyMa4w01Ermzu1pPqum+zOqhTq+wiy0R0aWO71lPXy/YmIy27QO/mEDmlIs5IqTIPQ/mfH5WPA+SInFBuGnD28IXSXued+2cT0oMaqdvbfP9W14MaWMp6idq+tYtfK0kVWYCeyOG1GYkRmVk41/AgDgd/px46VNAMWHxI75a5DCZSiGyMa80Tkasymcz4ZaulrNcNXevr3Rwip9U2OhitIgORX2TCgp0JejeHyOlLezGPUjks7VU1LNlM5IQStsMDZmR51wEC6qiHzAUFOHkoXWWTQ0KN+Ovsn8Xro2jCfMOKb49uNhreRm8dGk9URa2Gw9PghaeTk7Cs7Sac8VqkHj5p7ox9n/6md+tcAhMpRDZmPj92iSPjiMjVrDt6FvGpOQj09cSQNixHRHQ5xnaxJCOlvBcRVT+RIrvcPNFdOdYl0KwTUXTxSgMsHUfkRM6X9Ur1b1L8UM6uXTjj31Td9mphQkZBBur41UGnup1KzELx9/SH0cOIG1rcoEPDiarBrzbQbCCuysnFY57R+Lnrn8g1rVNJwzU7/RH7y196t9DpMZFCZGPFxyTc4SYiF/PT5hPqekTHaPh6GfVuDpFTG9k5Wq01tC0uFUdPZ+rdHCKn3efm4KXqrpGia1OcQvFhHb9iRM4jfou6SrFKpGT+LeujtFG3DwVtV9cDGwyE0XDheEZmoHw2+DPMGDoD9QM5856cyIAXAA8jJh5aj5sj++DrXj8ABftgMvpg6aIMJK+xfOepephIIbKxC3kU7nETketIzy3A4j2n1O0bWdaL6LKFB/riquaWkhO/ni+ZR0SVp82oMPIsd7UXm6eLu/AR8TtG5DTit5WZkZKw4QAKvAPhaTRhSe78MmW9NJ3CO6FrRFc7NpaoBkS2A3o+oCLVczv+xFVRXTGr10x45sejwCsQv08/gPSDx/RupdNiIoXIbrV09W4JEVHN+X1nInILTGhaNwCdYkL0bg6RSxh7Pik5d1u8WoOIiCpP+5fhPnflWZeoMpv0bIlzlWzmd4zISWScAtJPwuxhQKq/ZWH5orQ0JJyzrHcS2MCMcwVnEeITgm4R3XRuLFENGvA8UK8bjDkpePvAZoT7hmJ2l0/gWZCCbN+6WPjGKuSeOq13K50SEylE9trh1rshREQ16OctlnUcbuwWw1r0RDVkUOsIteaQrD20/uhZvZtD5FS05CNLe1UeZ6RUc4Cc3g0hosqJt6yPgjotUGT0VTez1m/A2dqWsl7xUZZR+VfHXA1Pg6d+7SSqad7+wG0/ALUbwz81DlNPJSEwKhgL2nwKY1EOUnxjsOC535Cflq53S50OEylENsYZKUTkao6czsSW4ylqJOvozvX0bg6Ry5C1hmTNIfHj+TWIiKiqa6To3RLnYX18wkRKVY7r+CUjcgqJlrUgzFEXFpFP+XsD0oMss1NWYmGFZb2InF5AHeCOX2D2D0PjrGP4ONsbGfXzsbLhZ/Aw5SPZpzEWPfk9inJy9W6pU2EihchOuEYKEbmKX87PRunXoi4igiyju4ioZtzcLUZdL9p9CmnZBXo3h8hpaIkAzkipPEkIaB8XqwlWHr9hRE4icae6Mkd2sFybzYjblQx4GOBfKx9x5qOo5VULvaJ66dxQIhsJa4qim2ajyMMLDY+sxDSfpjjaOBFbomYC5iLEezXDkie+gqmAxxyVxUQKkY1JsBY8piMiV1BkMhcvhH1DV8sJXyKqOR3qB6NVZCDyC02Yt52LzhNVNZHCfe6q0RJP2jELVYzHdUROJnFHiURKQVwckj2i1O30GMv6EP1j+sPbaFkzhcgVmet1w5ZGk2CGB9pt/wXv1bkCm5vux77QOer5o2iOVc/MhNnExdIqg4kUIhtjaS8iciWrD53GqfRcBPt5YVCbcL2bQ+SSI8Rv7dFA3f5uYxxPbhJVkjajwsDaXlWifVyckXJp2kfESgNETiDrDJCRoP5jzeFtLQ+tWYezoZb1UTb4rVbXLOtF7iAxpBtMQ95Qt69a9yVeirkWq1ptRlzAz+qxvbnNsO75mTzuqAQmUohs7MJmiDvcROT85myIU9djutSDj6dR7+YQuaRRnerB29OA/acysPNkmt7NIXIK2sE/S3tVjbbeB9dIuTQOkCNyvtkoUtoIPoHq5ql1e1HgHQSjRxH2eG2Cn6cf+kb31bedRHZi6n4v0PthdXvM35/jycajsKjD3zjt9Yd6bNvZhtj2lmWWClWMiRQiG+MONxG5ilNpufhrf7K6fdv5EfNEVPOC/b0wvF2kuv39JkvykogqOSOF+9zVnJHCRMqlmK2GyBGRkyRSzpf1QlER4k8WqZvmOmdhMhThynpXwteT6z2SGxn8KtBmFGAqwN1rvsI9TUbil66Lkenxt1o7aH1sXez+yDJLhcrHRAqRnXa4eUxHRM7ux80n1Bop3RvVRvMIy8guIrKNW84nK3/bnoCsvEK9m0PkRGukcK+7emuk6N0Sx8cBclSeN998E927d0dgYCDCw8MxatQoHDhwoMRrcnNz8dBDDyEsLAy1atXC2LFjkZSUpFub3cIpy0LziLIkUvzi4nA2sLm6vbPOdnU9uOFg/dpHpAeDARj9GdCgN5CXhkc3/IibGw3D7J6/IN+0BWaDJ/7eHYi9H/+qd0sdFhMpRDbGHW4icgWSQPlh0wl1W1u/gYhsp2fjUDQK80dWfhEW7pQa30RUmUQKZ6RUL5HCGSmXxjVSqDyrVq1SSZL169dj6dKlKCgowJAhQ5CVlVX8mieeeAILFizATz/9pF6fkJCAMWPG6Npul5eoJVI6qivvA8eQFtRY3d7mtwbeBm9cWf9KPVtIpA8vX+DW74DwtvDITML/7ViMa2L6Y1avb1BUtAsmgxdWbfPH/s/n6d1Sh8RECpGNcYebiFzB6oOnEZ+aoxaZH94+Su/mELk8GVV/c3dL0vL780lMIqqYlgfgGilVo31cXGz+0jhAjsqzePFi3HXXXWjbti06duyIWbNmIS4uDlu2bFHPp6WlYcaMGXj//fcxYMAAdO3aFTNnzsTatWtV8oVsIDcdOHfEcjvSkkjJTzSp0kWe3mnI8klFn3p9EOAVoG87ifTiVxsY9ytQuzEMKcfx+oGNuKJ+L8zoPRPmoj0wGb2xYpMPDn65QO+WOhzPy32DTz75RF2OHTum7kvwePHFFzFs2DB1v3///irjbu3+++/Hp59+WnxfgsykSZOwYsUKNc3xzjvvVNMjPT0vu3lE+isuM6B3Q4iIqm/OxguLzPt6cZF5InsY27Ue/rvkALbFpWL/qXS0igzSu0lEDj1zUjCRUjXa56V9fnQxPK6jS5PEiQgNDVXXklCRWSqDBg0qfk2rVq3QoEEDrFu3Dr169Sr3ffLy8tRFk56erq7lveRSFdrrq/pzzsojfrs62WkOqodC7yDknj6NDFjWnosLO6iuB9Yf6Dafh7v9/Utj/yvov28YcNvP8PxqOLyS9+FdrwBMim6HL3rPwL1r74PJsxX+WmuG2WMBmtxxDZxVQQ3/3S87U1G/fn289dZbaN68OcxmM7766iuMHDkS27ZtU0kVce+99+KVV14p/hl/f//i20VFRbj22msRGRmpMvKJiYkYP348vLy88MYbb1xu84gcaEYKEZHzLzJ/e0+W9SKyl/BAXwxqHYHFe07h2/XH8dqo9no3icgJ1kjRuyXORSuFJsfyVMkZKTyyowqYTCY8/vjj6Nu3L9q1a6ceO3XqFLy9vRESElLitREREeq5isjg4smTJ5d5fMmSJSXOqVWFlB5zB02S/4TsMZ3yCMfGRYsQsH0nzoVa9qE2194AI4zI25uHRfsWwZ24y9+/Iux/+f0PrP8Yrjj0OvzjN+OljLZ4qG4kvugzHfesuQ9FXi2xYk0ODh/+Hwp7NLV7mx3RZSdSRowYUeL+66+/rmaoyBRFLZEiG3lJlJRHgsDevXuxbNkyFUg6deqEV199Fc8++yxefvllFXCIXGMKOHe4ici5F5nv0SgUzcK5yDyRPY3v3VAlUuZujcez17RCoK+X3k0ickjahArOSKnuGil6t8SJBsjxK0YVkLVSdu/ejX/++eey3+u5557Dk08+WWJGSkxMjFp/JSgoqMojsuUk6uDBg9WgZVdnXLAIiAfCOwzG8KuGY//fu3HAOwgeKMCpwKO4ol5fjOnnPmvUuNvfvzT2/9L994jvAvPsMWiSvgffRV+LB0KCMaPP57hn3SQUeTbDiaRW6HcqF80mlMwBOEv/58+fX2PvV6O1s2R2iSyeJYtq9e7du/jx2bNn49tvv1XJFEm8vPDCC8UZdJnK2L59e5VE0QwdOlSV+tqzZw86d+5s0ymO2s9ZX7sb9t+2/Zf/C210iiN+xvz7s/9ElV5kvmeM3s0hcju9m4ahWXgtHE7OxK9b43Fnn0Z6N4nIIWkzKrjYfNVog7242Hzlv2P8ilF5Hn74YSxcuBCrV69WlVs0ch4sPz8fqampJWalJCUlVTjgWPj4+KhLaXIitLongy/nZ51K0m51ZazXGQZPTyTE5gJ1gSz/WJgMRRjaeKh7fA7u+vevAPt/kf436g3cMhuYfRNC9v+OzzvdivsiWuKL3p9i4rr7UeTZHCs3G2DKnYu2j90Ed1YjiZRdu3apxElubq5a42Tu3Llo06aNeu62225Dw4YNER0djZ07d6qZJgcOHMCvv/6qnpepjNZJFKHdr2iaoy2mOApO82L/beFQnEEO6XD82DEsWnQUjop/f/fuP1FFlu9LUovMh/h7YVg7LjJPpMdJznG9GuKl3/bg63XH1AwVznIlusiMFGZSqsQohypMpFQKZ6RQRQm2Rx55RJ0HW7lyJRo3blzieVlcXk5eLl++HGPHjlWPyTkxWSvYegAy1ZDCPOD0fsvtqA7Ij43FaW9LaeJtdbbB0+CJ/jH99W0jkSNqOgAY+wXw890I2v4dPusyDvdFmDG9z6e4Z/1EmIxtsGpPCAre+had/n0H3FWNJFJatmyJ7du3q0W1fv75Z7VYvCwwL8mU++67r/h1MvMkKioKAwcOxJEjR9C0aVPdpzgKTvNi/23Z/71LDmFZfCwaN26E4cNbwdHw78/+1+Q0R3I9s9YeU9e3dG/AReaJdDKmSz28s3g/jpzOwtojZ9G3WR29m0TkcLREAEt7VY32eTGPcmkXPiN+x6hkOa85c+aoY6rAwMDiAcHBwcHw8/NT1xMnTlTnsGQBejlnJYkXSaJUtNA8XYYzBwFTIeAbDATVQ8qvc5AWZEluxdbZhz7RfRDkXfXzhkRuoe0oSzJy7v0I3voNPu96F+6ta8b0XtMxYeNd8DR0xNrYCBS+PBNdX7rLLQd31UgiRdYxadasWXG2fdOmTfjwww/x2WeflXltz5491fXhw4dVIkWmMm7cuLHEa2SKo6homqMtpjjWxM87O/bfNv33MFiGeRmNRof+fPn3d+/+E5XnwKkMddJWBveO691Q7+YQuS1ZF2VMl/r4Zv1xNSuFiRSiiyVS9G6Js66RwkxKpUt78TtGVmSNYNG/f8lZDjNnzsRdd92lbn/wwQcwGAxqRoqUqZdy9h9//LEu7XV5SXst1+Ft1T/r8Q3HAI8oFCEJmT4pGNJwiN4tJHJsHW8GzEXAvAcRvGUWpnefgPvCPTCj1yzcueE2+KI7NiTGIO/Zz9HnzXvgYXSvwZbnJ/LWLFkLwnoNE2syc0XIzBQhWXgpDZacnFz8GhkdLll6rTwYkTMzn58Ezv1tInLW2ShD20aiXoif3s0hcmtaMnPp3iQkpObo3Rwih6PlATgjpWq0j4uLzVehtJfO7SDHS7CVd9GSKMLX1xfTpk3DuXPn1JrCUur+Yuuj0OWvj4KItjAXFCDhtOUk74mgPSzrRVRZnW4Drv+fuhm86UvMMDRA18gumNVzNjKM/8iIcWxPb45lD3+Kohz3Oi657ESKlNmSxbSOHTumEiJyX+pC3n777ap816uvvootW7ao53/77TeMHz8eV111FTp06KB+XspxScJk3Lhx2LFjB/788088//zzanpkebNOiJx1j5vHdETkTFKz8zF320l1+y4ubk2kuxYRgejVJFSd7JyzIU7v5hA5HG1GhTuWmbgcnJFSneM6fseIHFby+RkpEW2QvX07zgS1UHd3R+9Dz4ieCPYJ1rd9RM6iyzhgxEfqZq2Nn+MTROCq+ldidvefkOS7WD1+0NwaCx+chbwz5+AuLjuRIjNJJDki66TI2idS1kuSIbLegJT8WrZsmUqWtGrVCk899ZSayrhgwYLin5dyRwsXLlTXMjvljjvuUO/3yiuvXG7TiBxsUULucBOR8/hh0wnkFpjQOioIPRqH6t0cIgJwZ29LUvO7jXHIKyzSuzlEjrnYPHe5q0T7vLSyVVQxzkghcgJJeyzXEe2QsGIr8n1CAHM+EoOPYlCDQXq3jsi5dL0TuO4DddN3/SeYkm3E8MbDMLfzHzgQ8p0qAXbSpyXmPTUXmYcs1Sxc3WWvkTJjxowKn5MF4GXR+Utp2LAhFi1adLlNIXLsWrp6N4SIqJIKi0z4et1xdfvuPo2YCCZyEIPbRCAq2BeJabmYvz0BN3WL0btJRA6Di81f7owUvVvi+LhGCpGDyz4HZCRaboe3Rtzu5YA/kGk8CLPBhP71WdaLqMq6TQAMnsBvj8Jr61d4s90NqNX8BvyIn5F6PA29T07AGb/G+OW1NRh6RyIiB/eGK7PJGilEdEHx4C7ucBNdNiklOWLECERHR6uT+/PmzSt+rqCgAM8++yzat2+PgIAA9RqZ4ZiQkKBrm53Rsn3JiE/NQW1/L1zfKVrv5hDReZ5GQ3Gpvemrj3IEOZEV7f+BM1KquUYKMymXdOGwjl8yIoeejRLSAEV5ZpzKr63uHgzfh6aeTVnWi6i6uowHbpihEiqG3T/j+di9uL/dRGxruA+Lm38Ez8IMZPpF4bfvT2P/xz+59DEKEylENsYdbqKaI4szduzYUS3WWFp2dja2bt2KF154QV3LIo4HDhzA9ddfr0tbndnMNbHq+tYeDeDrZVmgkYgcw609G6CWjycOJWdi5cHTejeHyGGYTJZrzqKsGs5IqTztvBC/YkSOvj5KO6T+vR5pQU3V3f2R+9HWq62+bSNydu3GArfMATx94XFoMR7evRyv9PgP4iIS8U2Xd+FZFI8Cr1r4a3sI1v3rM5jz8+GKLru0FxFdHHe4iWrOsGHD1KU8wcHBWLp0aYnHpk6dih49eiAuLg4NGjQo9+fy8vLURZOenl48w0UuVaG9vqo/50h2nkzDhthz8DR44JZu9arUF1fo/+Vg/9l/62tb8TMCN3Wthy/XHsfnq47giiaW0ZaOQK+/vcxWfPfdd7FlyxYkJiZi7ty5GDVqVIWvl0T7J598gu3bt6vtf9u2bfHyyy9j6NChxa+R+5MnTy7xc7Im5P79+23aF6qJ0l56t8Q5EymuPHq0ppiLh8gRkUPPSAlvg2NLD8BsaAuTKRlZ/ilo7dVa79YROb8WQ4E7fgHm3AzErsbo/CxEDngTT26YjE97vY+7ttwJT3TAtowWOH3fdAx+6Xr4N3atUsRMpBDZaYebx3RE9peWlqZGpoaEhFT4mjfffLPMyTKxZMkS+Pv7V+v3lk7oOJMvD8hkVQM6hxVh25q/sM3N+l8T2H/239Zi8uS/1Ih1R8/hsx8XIaYW3Jo2W3HChAkYM2ZMpRIvgwcPxhtvvKHiw8yZM1XZyA0bNqBz587Fr5MEy7Jly4rve3ry0Mk5FpvnXne1SnsxR3BJHCBH5CwLzbfBybhjQBBw2n8fukd0R0BugN6tI3INja4A7vwN+HYsEL8FvRc+i6+vfx8Pb3kHX/SYget3D0V0xjU46dsaP728GgNHR6H+qAFwFTwaILIx7nAT6SM3N1etmXLrrbciKCiowtc999xzePLJJ0vMSImJicGQIUMu+nMVjcaWk6hygs7LywvO5ujpLOxcv0bdnnzzFWgeUcut+n+52H/2357931q4Ewt2nsIBj/q4f3gHOMpnMH/+fIearVieKVOmlLgvCRVp94IFC0okUiRxEhkZWaNtJXuskcKd7uqV9mImpdIlm/kdI3LM+o7J+9TNvMI6OONtqfe4q94+3NbwRuCAzu0jciX1ugITlgCzbwBSjqH5jxPx/djpeObID/jN40+0iT+KAbF3qXVTFi7MRdfN09H1xTth8PaGs2MihchOuEYKkX1P5t10003qpIqUb7kYHx8fdSlNToRW92To5fysnr5cG6eSv4Nah6NN/eqXC3LW/tcU9p/9t0f/7+/XTCVSFu1Owr+HF6JeiJ/Nf6erMplMyMjIQGhoaInHDx06hOjoaPj6+qJ3795qBmNFZSIFS0XWrKp+BvkFhedvmV3ic7PXd8DDw5IeyK/G99SWHPF/QEvWFRUW2rxdjth/e3LXftNlSD0GFGQBRh8kbklCrm8dwFSAk3WPY0DMAPxz4B+9W0jkWuq2AO5ZZinzlbAVtb+7HZ+Omor3Q1vgG3yDuNC3cNf2e1Do2QgbzzTFyXu+wIAn+iG4s3OvV8RECpGNaaO7OHCJyL5JlOPHj+Ovv/6q8qwSd3UqLRe/bjupbk/qb1mYkYgcV7t6wejbLAxrDp/FzH9i8fx1bfRuktN67733kJmZqWKHpmfPnpg1a5ZaF0XWXZESkFdeeSV2796NwMDAct+HpSJto7KfwdYzsrNtRMq5s1i0aBFcha2/A+lpRjXka+Omzcg67HizUhzpf6DIZPmsVvz1F0LKjsFx+f4TObSk8wvN122J41sTAdRBvsdh9GrQA0HePB4ksola4cBdC4Ff7gEOLILnL/fiX1c+hTZ9X8fk9a9iWq8PMXb3daiTcTUS/Fvhx48OoFerzWj31O3wcNKSuc7ZaiKnLO3FTAqRvZIoMop4xYoVCAsL07tJTuPLNbEoKDKje6Pa6Nqw5KhsInJM917ZRCVSvtsYh4eubobaAc4/Xd7e5syZo5IfUtorPDy8+HHrUmEdOnRQiZWGDRvixx9/xMSJE8t9L5aKrFlV/QwKdyQCh3ahbp06GD68G5ydvb4DM06sx4msdHTp2hUDW134H9CbI/4PPLlhqTq4GzhwACKCfN2u/+5QKpKcWLIlkWKu2wYJKT5qfZRjtfdjeOPhereMyLV5BwA3fwssfRFYNxX4+7+47tRQtB48Hc9seAU/t/8NjU9vx4iDdyPfJxSrY0MQO/FTXPXwlQjp3hHOhokUIhvjYvNENUdGDB8+fLj4fmxsLLZv367KsURFReGGG27A1q1bsXDhQhQVFeHUqVPqdfK8twvU47SVtOwCzF5/XN1+oB9noxA5i34t6qJ1VBD2JaZjxj+xeHpoS72b5FS+//573HPPPfjpp58waNCgi75WFqVv0aJFiRhUGktF2kZlPwOD0aCujUaDS31mtv4OGA2Wz81gMDrk5+ZI/wNaaS9vO7bJkfpP5NDOr4+SmV4XqbUaq9v7Gx/Fm/X76dwwIjdgMAJDXweiOgK/PQIc+hNNzx3BnBtn4r1jv+EH/ICPa7+O2/fcBL/snjjh1wY/fnIM7X9ai+7/vgWeodUvK25vlr0mIrIZLjZPVHM2b96sFgLWFgOWkb9y+8UXX0R8fDx+++03nDx5Ep06dVKJFe2ydu1avZvu0L7dcBxZ+UVoGRGIq1s6zmhUIro4me362MDm6vastceQmp2vd5OcxnfffYe7775bXV977bWVSuQfOXJExRRy3HWGBRebrxpj8WLzerfE8RV/RPyKETme05bV5GMP14LJ4AWPwnPo2Kot/L2qV1qTiKqhw03AhMVAUH3g7GH4zhiK530aY0r/DxAYEIivOs7Biib/g7f5DAq8A7E1vSW+f2wejkz/BWYnWRuLiRQiO+1wc7F5osvXv39/NRqw9EXq2Ddq1Kjc5+QiP0fly8orVCPZxf39msBg4LaKyJkMaROBVpGByLT6X3Y3kuSQ2YlysZ6tGBcXV1xya/z48SXKecn9//73v6pkl8xelEtaWlrxa55++mmsWrUKx44dU8n40aNHw2g04tZbb9Whh1SVdQkZxqpGSzxpsy2oEgPkeFxH5FiKCoGzh9TNEwmWsnup3nsxvAnLehHZXXRn4L6VQON+QEE2MP9BDNz8A+YN+xbDGg3DgYjDmNrrdZyuswxGUx7SAhpi8Zba+PXuzxH33e8wayNjHBQTKUQ2xhkpROTIvlp3DOey8tEozB/Xd4zWuzlEVEWS/Hx80PlZKWuOqVJ97uZisxWFLBavJVXE559/jsLCQjz00EMlZi8+9thjxa+R2Y2SNJHF5mXtLVlza/369ahbt64OPaSq7HNzRkrVaB8XZ6RUHr9iRA4m9ThQlA+T2Q9Jpkj1UGz9Y+gb3VfvlhG5p1p1gXHzgIEvAh5GYNePCP1qJN5pejOmXD0FoQGh+KX5Anzd5TUYfPYDZhNO1WqNBSt9MP/OaYj/+Q+YCwvhiLhGCpHNcY0UInJMGbkF+Hz1UXX70YHN4Xm+vjwROZchbSLVrJT9pzIwY00snhzcAu44W7EiMmvR2sqVKyu1fgo554wUKXlHlaclnrTPj8pnvY3hN4zIwZzer65OZXVGjl84YC5C/T6N4WXk+kJEujEYgCufAhpeAfwyETh3FJgxCAN7P4xu136PT/fMwnf7v8PHXT5BvfT6uPHQTcjNb4j4gLaIX2pC+NzP0bZrIFrcfR08azvOGio8Y0JkY5yRQkSO6iu1pkIBmtQN4GwUIieflSLJUDFzTSzSctxvVgqRNqOCpb2q5vxa80ykXIL1x8NkHZFjJlKOprZT1+aioxjacrDOjSIipUFP4IG/gQ43q5knWPsRgr8cjmcj++OX639Bn+g+iA86iSld38fyVtPg63UC8DAgObAVVhysh9mPLsQ/j0/FuRVrYC4qgt6YSCGyWyKFO9xE5DjScwsw/W/LegqyWDVnoxA5t2vaRqJlRCAycgvxpZuulULu7cIaKdznrt4aKXq3xLFZfzz8hhE55kLzJ3IbqutzIUfRPaK7zo0iomJ+tYExnwO3/gAERqmF6PHlUDRd9QE+7fUqpg2chtahrXGo9kFM6fYeFnb8L7yDD8FgKkBmQD3syG2D77/Lws/jPsWJRWuhJ541IbIxc4ndbiIixzB99VE1ar1ZeC1c14GzUYhcaVaKLDp/NjNP7yYR6VJ6SZthQZWjDfbijJQqlPZiJoXIsZzej9wsb6T6NVV3g/pEwGgw6t0qIiqt5TXAg+uBTndYhihs+wYeU7viqrgd+OGabzB1wFS0DWuLk/5x+KjNVMzo8QIyotfC3+MczAZPJAe1hmd4BPTE3UwiG2NpLyJyNEnpufji/GyUp4e0hJF1UIhcwrB2kWhXLwiZeYX431+H9W4OkS6lvTgLvGq0XQAuNl+VGSn8jhE5DJMJOH0Q+892gsnoA0NhGq7pN1zvVhFRRfxCgFHTgAlLgKhOQF46sOR5eHzSG/1SkvDdsG/xyaBPcFX9q5DvlYvZDX/A+70mY1mXj+ERsxu5zfRNZTCRQmSnnW7ucBORo5iy7CByCorQtWFtDG2r74gOIqrZWSn/vqa1uj17w3HEnc3Wu0lEdsPSXtXDxeYrp8THw68YkeNIiwMKc3Awr6u6a/Y6ilZhrfRuFRFVZu2Ue1cA108FAuoC544Av94Lj4974Yoz8ZjW/0P8MfYP3NP+HoT6huKwzwF8Un860vLToCcmUohsjDNSiMiRHE7OwA+bTqjbzw1rxZG7RC7miuZ1cGXzOigoMuPdJZaa4UTugIvNV4/2eVmXrqKLl2vmrhORAzl9QJ1zyTRaFpoPaeuvd4uIqLKkHmuXccAjW4EBL1jWUjl7CJh7HzC1K+rt+AWPtRqHZTcuU7NU7mh9BzrW7Qg9MZFCZGPaTjf3t4nIEbz1xwF1smlwmwh0axSqd3OIyAb+rZKkwIIdCdhxIlXv5hDZd40UnuWu5hoperfEsVnnmfgNI3Igp/djd3o0cvyjAbMJ/W64Xu8WEVFV+QYBVz0NPL4LGPiiJaGScgxY+gLw31bwmv8Irig04tluz+g+EJSJFCJb44wUInIQqw+exrJ9SWpNlGevaal3c4jIRtpGB2N053rq9ssL9sDEM6TkBrTSVNznru4aKdxOVJbeJ3GIyMrpA9iR3lPd9Ck8iXqRlv0fInJCPoHAlU8BT+wBRnwERHYAivKAHd8BM68BPuwIxP6taxOZSCGyMa6RQkSOIL/QpE6oivG9G6JZeKDeTSIiG3r2mlbw9zZiW1wq5m6L17s5RDZXZLJcc0ZKNddIYcL1ojgjhcgxFZ3eh7z8Dup2aFSh3s0hoprgHQB0vRO4fzVwz3Kg0x2Ad6BlTaSQGOiJiRQiO5UZ4DEdEenpq7XHcPR0FsICvPH4oBZ6N4eIbCwiyBePDGiubr/5x35k5Bbo3SQiOy02r3dLnHWxeb1b4ti4RgqRAzKbsSY2DXl+7dXdbtf11btFRFSTJODW7waMmgY8cwgYNw+o3Qh6YiKFyMZ4TEJEekvOyMWHyw8Vj1IP9vPSu0lEZAcTrmiExnUCcCYzDx+d3wYQuSqukVI92sfF0l5VmZHC7xiRQzi1E0dPDoHZYIRf4XE06NVa7xYRka14+QFNr4bemEghstNON2vpEpFeXlmwF5l5hehYPxg3dK2vd3OIyE58PI14cUQbdXvmmmPYm5Cud5OIbEabUcF97qrhjJTKsf54+BUjcgw7P/0cud5XqdtNrwzWuzlE5AaYSCGy2xopRET2t3RvEhbuTFQLzL8+uj0MrHlC5FaubhmOYe0iUWgy49lfdqJQW0iCyMVoMyqMPMKtEtk/sJ7RQ+Xj50PkWLa+Oxv/JF6PIk9feOcfxRW3j9S7SUTkBribSWRjXCOFiPSSnluA5+ftUrfvubIx2tXjSC0idzR5ZFsE+XpiV3waZvwTq3dziGxCm1HB0l5Vw9JelcMZKUSOwVRYiBVPfoZ1R6JgNngB+TvQ86WuMHoa9W4aEbkBJlKIbIwzUohIL2/9sR9J6XloFOaPJ7jAPJHbCg/0xfPXWkp8vb/0II6dydK7SUQ1jmukVA9Le1UO10gh0l/emRT89sB07M1uru5nYjkKx59Bh4ad9W4aEbkJJlKIbI31molIBysOJGPOhjh1+80xHeDrxVFaRO7sxm710bdZGPIKTXjyx+0s8UUuR5tRwV3uqtEqfnJGyiVYJ1L4HSOyu9Mb9+CHp35HvGdLwFyEOP/vUeeeuni032t6N42I3AgTKUQ2Zj6/180dbiKyl9MZeXjmpx3q9l19GqF30zC9m0REOpMBHW+N6YBAH09sjUvFR38d1rtJRDWKpb2qR/u8mEep3DGd4DeMyL72fbEAv352FBl+0TAWZGBb1CcY/NBITOz2OAesEpFdMZFCZGPaQQnDOxHZq7TJv37egTOZ+WgZEYh/D2uld5OIyEHEhPrjtdHt1O2pfx3CpmPn9G4SUY3RZlRoMyyocrSTkCbW9qp8aS+euCWyi8KcXKx46jP8tckPhV4BMOYdw+qun+CZR9/EoKbX6t08InJDTKQQ2WunmzvcRGQHX645hhUHTsPb04CPbu3Mkl5EVMLITvUwpks9NXr/8e+3IyUrX+8mEdXoPjdnpFS3tJfeLXGixeZ1bAeRuzi7dT9+fOA77M1qDngYkF+0BruuW4pPJv6AlqEt9W4eEbkpJlKI7FXaS++GEJHLW3vkDN5YtE/dfv7a1mgZGah3k4jIAb0ysh0ahvkjPjUHj3y3jeulkEvQZlRwtkB1F5tnJuVSM341/IoR2fZ/beeUH/HztENI8WsIQ1Eujtb6Bp4TjPho9LcI9gnWu4lE5MaYSCGyV2kv7nATkQ2dOJeNh2ZvRZHJjNGd62Fcr4Z6N4mIHFQtH098Nq4r/L2N+OfwGby9eL/eTSKqwTVS9G6Jc9E+L+tEAV1iRgoP7IhsIuPICfx276f4e3+d4lJeK9t8gNGP3YVHev8fjAbOtCcifXnq/PuJXF5xZS/OSSEiG8nMK8T932xBSnYB2tULwptj2vMgn4guqlVkEN67sSMenL0V0/+OVffHdq2vd7OIamCNFMa/aq2RwjzKRTHPRGQ7pqIi7PzwJ2zc7YsC75aA2YR0wzLEXX8c0675DnX86ujdRCIihTNSiGyMM1KIyJbyCotw/zebsTcxHWEB3vhsXDeui0JElTK8fRQeurqpuv3sLzuxYn+y3k0iqjZtRgVnpFQNS3tVsVwzv19ENerMpj34deIMrDkYjgLvIHjmJWJ9zIeIeaAJPh41h0kUInIonJFCZHNcI4WIbEPKeMli0WsOn1Uler68qzvqhfjp3SwiciJPDW6Jkyk5mL89AZNmb8G3E3uiW6NQvZtFVGXajArOyKwaLjZfSdr3S+92ELmInPgkrHlnLg5lN4LJtxk8TIU457kEh4cfwStDPkLj4MZ6N5GIqAwmUohsjDNSiMgWZHHof/2yE3/sPgVvowHTx3dDx5gQvZtFRE7GYPBQJb7Scgqw8sBpTJi1Cd9M7MntCTmdIpb2qvY2QHBGSiXLNfP7RXRZCjOysPWjX7HjSC3ke7cAjIAh/xBWtp6LscNvw/+1eQcGDxbPISLHxEQKkY1pByVcI4XI9ZlMZrvU0M4tKMIj323D0r1JMBo88OEtndC3Gae9E1H1eBkN+OT2rhj/5QZsOpaCO77YgJl3d+fMFHIqLO1VPVpeQPZhqDLHdERUHfmp6dg+9TfsPuyFHN96gDfgmX8a26LmI+jKWvjwylmIDIjUu5lERBfFRAqR3UYv6dwQIrK5aSuPYs1hA/rnFSLEy8smvyMlK1+V31l/9By8PQ2YdlsXDG4TYZPfRUTuw8/biJl398DEWZuwIfYcvtt4gokUciomU8kZFlTVNVL0bolj0wbKcMYTUdVkxSVgxxdLsO9ELeT6RAO+gLEwEwn+S3GkfyyeufpVdIrorHcziYgqhYkUIruV9uJON5ErS0jNwSerj6KgyIAxn27Ap+O6okVEYI3+jq1xKXh49lYkpOUi0McT0+/shl5Nwmr0dxCR+6rl44lZd/fAF38fxQP9LYvQEzndjAHucldzjRRmUi6m+NPh94voksxFRYj77W/sWrQPJ9EIRcYGgA9gLEhHfMBy7OyzG/f0fgwvN7ueZbyIyKkwkUJkrxkpOreDiGwrOsQPX93VDZO+3oijZ7Iwcuoa/N+1rXFbjwaq/NblyC80YfrfR/HB0oMoNJnRuE4APr69C1pHBdVY+4mItJkpjwxsrncziKpMm1FhZCalSrTPSyuNRuXTPh9+u8gZv7vxv68B8vJs+ntM+fk4uWQDDv+1DyfO+iPTLxowtlTPGfNP4Xjw3zhwxSFM6PUoXmryATwNPB1JRM7nslO/n3zyCTp06ICgoCB16d27N/7444/i53Nzc/HQQw8hLCwMtWrVwtixY5GUlFTiPeLi4nDttdfC398f4eHheOaZZ1BYWHi5TSNyrJ1u7nUTXbbVq1djxIgRiI6OVrO85s2bV+b/7cUXX0RUVBT8/PwwaNAgHDp0yG7t696oNp7pWIQ+TUORU1CEF+btxshp/2DL8XPVej/pz6qDp3HNlNV4988DKolybfso/PZwXyZRiIgqGRvKs3LlSnTp0gU+Pj5o1qwZZs2aVeY106ZNQ6NGjeDr64uePXti48aNNuoB1ewaKdzprgpt1jxLe1W2yoDeLSGqmrObduH3xSacWuKP+fd+iTUvfIWTi9agMD3jst7XnJ+Pc5t3Y/uUn7HogU8w6755WLCwAPuym6kkioepEIWFm7G23kfYMOInXP3YKPx8+xJc1+x6JlGIyGld9tarfv36eOutt9C8eXO18/rVV19h5MiR2LZtG9q2bYsnnngCv//+O3766ScEBwfj4YcfxpgxY7BmzRr180VFRSqJEhkZibVr1yIxMRHjx4+Hl5cX3njjjZroI5FD4E430eXLyspCx44dMWHCBBVLSnvnnXfw0UcfqVjUuHFjvPDCCxg6dCj27t2rToTZQ6AX8OX4rvhuczzeX3oQu+PTMfaTdejRKBR39mmEIW0j1MLOl1pMfuHORHy19hh2xaepx+rU8sa/h7XG2C71WCqQiKgKsaG02NhYdfzxwAMPYPbs2Vi+fDnuuecelYSXmCF++OEHPPnkk/j0009VEmXKlCnquQMHDqiBX+R4WNrrctdIYSalMjw4J4WczOFNf8NQ1AiFXv5I8mqOpNPA9t/yYJz7D2rlJSHYOweBIV4IDA+Ef2gAfIL94RPoZ6n7ZwYKc/KQm5qNnNRsZCZnICMlB+nZnkg31kW+twzskvXUQtXaJx6mfJiK9uNo6E7san4Ig9sOwqvt3keT4CZ6fwxERI6RSJHRX9Zef/11NUtl/fr1KskyY8YMzJkzBwMGDFDPz5w5E61bt1bP9+rVC0uWLFEnuJYtW4aIiAh06tQJr776Kp599lm8/PLL8Pb2hi2l5xZg78kUHE0HthxPgaen+2XGZfYP+2+7/qflFKhr7nQTXb5hw4apS3kkmS8nup5//nmV0Bdff/21ii0yOvmWW26xWzullNfdfRtjRMdovLv4AH7eehIbj51TlwBvI3o0DkX3xqGIDvZDaIC3OnlxLisf8Sk5apHnzcfPIbfAsmquLCh/R8+GeHxwcwT52mYBeyIiV40N5ZHkiCTb//vf/6r7cmzyzz//4IMPPihOpLz//vu49957cffddxf/jAwO+/LLL/Hvf/8btnYiJdut98+rs49+JjNfXXNGStVo1UeT0vOw+Vj1ZtC6wzGqfD6CXy9yNsbhLbGw9qvwjQtAu/gWCM9qDg/Ppigy+iDNvwHUkK3M85ej2k/llHoXn/OX2pa7fucfNptgLIhHhtcRHK5zGEeaxeHKJn0wuundeCuqJ7yNtj2fR0RkbzW6RyKzS2TmiYwKkxJfW7ZsQUFBgSqtomnVqhUaNGiAdevWqUSKXLdv316d6NLIAcykSZOwZ88edO7cuczvycvLUxdNenq6upbfJZeq2HH8HMbN3Kw+ig/3bIL7Yv9t3X+TqajK30970NrkiG2zB/bfdfotI4xPnTpVIubITEgZSSyxpqJESk3GlNLfp2AfA14b2RoPX90Y3208iR+3nFQnelYcOK0uFxMd7Itbu9fHjd3qIyzA2yn+Xvx/Yv+tr92Nu/ffmfouMcE6VmjHH48//ri6nZ+fr45jnnvuueLnDQaD+hn52YrUZDyZteYYvt7j7vvnohqfgdnkNN9Fh9immC0DN5btS1IXx+J4/wOSSLHH98vdY4q79tsWujcehHn1+2H2wtkIHFULW+JXYfOp7+CR7IPmydGISI9ArbxQ+Jhqw4AAwMMfZg859rBkDT3MBYA5B2Zko8AjFVne53DO/wyO1k1AcsRZtK3TGN1i+mFS9Bi0r9MeRoNR7y4TETl2ImXXrl0qcSLrocg6KHPnzkWbNm2wfft2NaMkJCSkxOslaSInu4RcWydRtOe158rz5ptvYvLkyWUel9ktss5KVRzLAOr4ckNPthXsBWQd3YZFJ7fBUS1duhTuzN377wq0mFFeTKkontR0TLnY90mWWvxPOyAhGziU5oG4TA9kFgIZBR5qwbJaXmZVFqxRoBnNg8yI8MuER9Z+bFi1H87G3f+f2H/2nxxbRccfkvjIyclBSkqKGiBW3mv2799vl3hyNsEDdXwvezlLt1PLEzAn7MaiRbvhKmy9TfHOBhoEGJFdZNNf4zK61inAokWL7Pb7GFOoptQ21MbwpsMxttUN6n5aXhoOphxEbFosEtLjcCx1F9JyziGjIAPZhZI4sZT78zH4INA7AEHeIYgMboB6wa3RKzAGLUNbIiogiiWHicit1EgipWXLlippkpaWhp9//hl33nknVq1aBVuR0WFSs1gjBz0xMTEYMmSIWvC+qu4tKFA7KIMHD1Zrs7jjaA/2n/1n/923//Pnz4c7q8mYwu8T+8/+s//u2n/h7jGlJuPJYH6f3P5/yp79nwDHw78/++/O8cQegn2C0T2yu7oQEZEdEyky66RZs2bqdteuXbFp0yZ8+OGHuPnmm9XU+NTU1BKzUpKSktTi8kKuN27cWOL95HntufL4+PioS2myg3E5OxmX+/POjv1n/9l/9+2/K9BihsQQWTBYI/dl/a2K2CKmuPv3if1n/9l/9+2/s8QL7XhDI/cl2eHn5wej0agu5b2mouMTwXhiG+7+GbD/7L8795+IiMiR2GS+uMlkUvWBJakiQX/58uXFzx04cABxcXGqFJiQaykNlpycXPwaGXkhBzJSHoyIiKgyZOFgOcFlHXNkNPCGDRuKYw4REZHEBOtYoR1/aLFCBonJcYz1a+T4Ru4znhARERERuSfPmpjCPmzYMLWAfEZGBubMmYOVK1fizz//VIv8Tpw4UU1xDw0NVcmRRx55RB2AyELzQqa6S8Jk3LhxeOedd1TN4ueffx4PPfRQuSO6iIjIfWVmZuLw4cMlFpiX0pISYyQOyULBr732Gpo3b64SKy+88AKio6MxatQoXdtNRET6xQY5XomPj8fXX3+tnn/ggQcwdepU/Otf/8KECRPw119/4ccff8Tvv/9e/B5y/CLlirt164YePXpgypQpyMrKwt13361LH4mIiIiIyMkTKTKTZPz48UhMTFSJkw4dOqgkitTyFB988AEMBgPGjh2rZqkMHToUH3/8cfHPy7T5hQsXYtKkSSrBEhAQoA5aXnnllcttGhERuZjNmzfj6quvLr6v1aKXuDFr1ix1UkxOdN13332qrOQVV1yBxYsXw9fXV8dWExGRnrFBjlNkRrxGEu2SNHniiSdUOeL69evjiy++UMcpGilRfPr0abz44otqoJeUiJR4UnoBeiIiIiIicg+XnUiZMWPGRZ+Xk1fTpk1Tl4o0bNgQixYtutymEBGRi+vfvz/MZnOFz3t4eKhEPJPxRETu41KxQZIp5f3Mtm3bLvq+Dz/8sLoQERERERHZZI0UIiIiIiIiIiIiIiIiV8BEChERERERERERERERUQWYSCEiIiIiIiIiIiIiIqoAEylEREREREREREREREQVYCKFiIiIiIiIiIiIiIioAkykEBERERERERERERERVYCJFCIiIiIiIiIiIiIiogowkUJERERERERERERERFQBT7gAs9msrtPT06v18wUFBcjOzlY/7+XlBXfD/rP/7D/7b70tdXeXE1P4fWL/2X/23137LxhTSmI8uTzu/hmw/+w/+894Yo0xpfrYf/af/Wf/ayqeuEQiJSMjQ13HxMTo3RQiIqfelgYHB8PdMaYQEV0+xhTGEyKimsB4YsGYQkSkfzzxMLtAet9kMiEhIQGBgYHw8PCo8s9LVk6C0YkTJxAUFAR3w/6z/+w/+7937160bNkSBgMrPl5OTOH3if1n/9l/d+2/YEwpifHk8rj7Z8D+s//sP+OJNcaU6mP/2X/2n/3fW0PxxCVmpMiHUL9+/ct+H/lCueOXSsP+s//sv/v2v169ejxAqcGY4u7fJ/af/Wf/3bf/gjHFgvGkZrj7Z8D+s//u3H/GkwsYUy4f+8/+s//u2/96NRRPGJGIiIiIiIiIiIiIiIgqwEQKERERERERERERERFRBZhIAeDj44OXXnpJXbsj9p/9Z//Zf3ftf01z98+T/Wf/2X/37b/gZ1Bz+FnyM2D/2X/23337X9Pc/fNk/9l/9p/996mh/rvEYvNERERERERERERERES2wBkpREREREREREREREREFWAihYiIiIiIiIiIiIiIqAJMpBAREREREREREREREVWAiRQiIiIiIiIiIiIiIqIKuH0iZdq0aWjUqBF8fX3Rs2dPbNy4Ee7i5ZdfhoeHR4lLq1at4KpWr16NESNGIDo6WvV13rx5JZ43m8148cUXERUVBT8/PwwaNAiHDh2Cu/T/rrvuKvN9uOaaa+AK3nzzTXTv3h2BgYEIDw/HqFGjcODAgRKvyc3NxUMPPYSwsDDUqlULY8eORVJSEtyl//379y/z93/ggQd0a7OzcteYwnjCeOIu8UQwpjCm2APjCeOJYDxhPGE8YTy5XO4aTwRjCmOKu8QUd48n9owpbp1I+eGHH/Dkk0/ipZdewtatW9GxY0cMHToUycnJcBdt27ZFYmJi8eWff/6Bq8rKylJ/Y9mRKM8777yDjz76CJ9++ik2bNiAgIAA9X2QjY079F9IELH+Pnz33XdwBatWrVIBY/369Vi6dCkKCgowZMgQ9ZlonnjiCSxYsAA//fSTen1CQgLGjBkDd+m/uPfee0v8/eV/girP3WMK48kFjCeuG08EYwpjiq0xnjCeaBhPGE8YTxhPLoe7xxPBmHIBY4rrxhR3jyd2jSlmN9ajRw/zQw89VHy/qKjIHB0dbX7zzTfN7uCll14yd+zY0eyO5Ks/d+7c4vsmk8kcGRlpfvfdd4sfS01NNfv4+Ji/++47s6v3X9x5553mkSNHmt1BcnKy+gxWrVpV/Lf28vIy//TTT8Wv2bdvn3rNunXrzK7ef9GvXz/zY489pmu7nJ07xxTGE8YTd40ngjGFMaWmMZ4wngjGE8YTxhPGk8vlzvFEMKYwprhrTHH3eGLLmOK2M1Ly8/OxZcsWNZVNYzAY1P1169bBXcg0Ppn21qRJE9x+++2Ii4uDO4qNjcWpU6dKfB+Cg4PV1Fd3+j6sXLlSTYFr2bIlJk2ahLNnz8IVpaWlqevQ0FB1LdsCyVZb//1lym+DBg1c8u9fuv+a2bNno06dOmjXrh2ee+45ZGdn69RC58OYwniiYTxxr3giGFMYU2oS4wnjiYbxxILxhPGE8aR6GE8sGFMsGFPcK6a4ezyxZUzxhJs6c+YMioqKEBERUeJxub9//364A9lgzpo1S21AZDrT5MmTceWVV2L37t2qppw7kYAiyvs+aM+5OpniKNP6GjdujCNHjuD//u//MGzYMLVRNRqNcBUmkwmPP/44+vbtqzacQv7G3t7eCAkJcfm/f3n9F7fddhsaNmyodjJ37tyJZ599VtWT/PXXX3Vtr7Nw95jCeHIB44n7xBPBmMKYUtMYTxhPNIwnjCeMJ4wnl8Pd44lgTLmAMcV9Yoq7xxNbxxS3TaQQ1AZD06FDBxVk5Av1448/YuLEibq2jezvlltuKb7dvn179Z1o2rSpytgPHDgQrkJqJsqOkyvXRq1O/++7774Sf39ZgE7+7rKDId8DoothPCF3jCeCMYUxhWoW4wlZYzxxH4wnZAuMKeSOMcXd44mtY4rblvaSaTyScUxKSirxuNyPjIyEO5LMZIsWLXD48GG4G+1vzu/DBTL1Vf5PXOn78PDDD2PhwoVYsWIF6tevX/y4/I1l6nNqaqpL//0r6n95ZCdTuNLf35YYU0piPGE8cfV4IhhTGFNsgfGkJMYTxhNrjCeu+V8NR6QAAQAASURBVB1gPLENxpOyGFMYU1w9prh7PLFHTHHbRIpMaeratSuWL19eYuqP3O/duzfcUWZmpsrCSUbO3cjUPtl4WH8f0tPTsWHDBrf9Ppw8eVLVi3SF74OsNSYb07lz5+Kvv/5Sf29rsi3w8vIq8feX6X1SP9UV/v6X6n95tm/frq5d4e9vD4wpJTGeMJ64ajwRjCmMKbbEeFIS4wnjiTXGE8YTxpPKYzwpizGFMcVVY4q7xxO7xhSzG/v+++/NPj4+5lmzZpn37t1rvu+++8whISHmU6dOmd3BU089ZV65cqU5NjbWvGbNGvOgQYPMderUMScnJ5tdUUZGhnnbtm3qIl/9999/X90+fvy4ev6tt95Sf//58+ebd+7caR45cqS5cePG5pycHLOr91+ee/rpp83r1q1T34dly5aZu3TpYm7evLk5NzfX7OwmTZpkDg4OVt/3xMTE4kt2dnbxax544AFzgwYNzH/99Zd58+bN5t69e6uLK7hU/w8fPmx+5ZVXVL/l7y//A02aNDFfddVVejfdqbhzTGE8YTxxl3giGFMYU2yN8YTxhPGE8UTDeMJ4cjncOZ4IxhTGFHeJKe4eT+wZU9w6kSL+97//qS+St7e3uUePHub169eb3cXNN99sjoqKUn2vV6+eui9fLFe1YsUKtTEtfbnzzjvV8yaTyfzCCy+YIyIi1M7GwIEDzQcOHDC7Q/9lwzJkyBBz3bp1zV5eXuaGDRua7733XpfZwSqv33KZOXNm8Wtk5+HBBx80165d2+zv728ePXq02ui6Q//j4uJU8AgNDVXf/WbNmpmfeeYZc1pamt5NdzruGlMYTxhP3CWeCMYUxhR7YDxhPBGMJ4wnjCeMJ5fLXeOJYExhTHGXmOLu8cSeMcXj/C8jIiIiIiIiIiIiIiKiUtx2jRQiIiIiIiIiIiIiIqJLYSKFiIiIiIiIiIiIiIioAkykEBERERERERERERERVYCJFCIiIiIiIiIiIiIiogowkUJERERERERERERERFQBJlKIiIiIiIiIiIiIiIgqwEQKERERERERERERERFRBZhIISIiIiIiIiIiIiIiqgATKeQ27rrrLowaNUq33z9u3Di88cYbxfcbNWqEKVOm6NKWM2fOIDw8HCdPntTl9xMROTvGlAsYU4iIqo/x5ALGEyKi6mM8uYDxhGzF02bvTGRHHh4eF33+pZdewocffgiz2Qw97NixA4sWLcInn3wCR1CnTh2MHz9efS4zZszQuzlERA6FMaVqGFOIiMrHeFI1jCdEROVjPKkaxhOyFSZSyCUkJiYW3/7hhx/w4osv4sCBA8WP1apVS1308r///Q833nijrm3Q5Ofnw9vbG3fffTe6du2Kd999F6GhoXo3i4jIYTCmVB5jChFRxRhPKo/xhIioYownlcd4QrbE0l7kEiIjI4svwcHBKltv/ZhszEtPc+zfvz8eeeQRPP7446hduzYiIiIwffp0ZGVlqQ1uYGAgmjVrhj/++KPE79q9ezeGDRum3lN+RqYvyrTBihQVFeHnn3/GiBEjyjyXnZ2NCRMmqN/VoEEDfP755yWe37VrFwYMGAA/Pz+EhYXhvvvuQ2ZmZok+SPutSR+lr9bTKV999VWVjQ8KClLvIdq2bYvo6GjMnTu3Sp81EZGrY0y5gDGFiKj6GE8uYDwhIqo+xpMLGE9IT0ykkFv76quv1JS/jRs3qgAzadIklUXv06cPtm7diiFDhqigIRt/kZqaqjbynTt3xubNm7F48WIkJSXhpptuqvB37Ny5E2lpaejWrVuZ5/773/+qx7dt24YHH3xQ/X5tVIEEt6FDh6qAt2nTJvz0009YtmwZHn744Sr387333kPHjh3V73nhhReKH+/Rowf+/vvvKr8fERGVxZjCmEJEVBMYTxhPiIhqAuMJ4wnVLCZSyK3Jhvb5559H8+bN8dxzz8HX11cFmXvvvVc9JtMlz549qwKDmDp1qgoosoBWq1at1O0vv/wSK1aswMGDB8v9HcePH4fRaFQLXZU2fPhwFUxkFMCzzz6rfre8l5gzZw5yc3Px9ddfo127diqYye//5ptvVCCrCvnZp556Ck2bNlUXjWTnpX1ERHT5GFMYU4iIagLjCeMJEVFNYDxhPKGaxTVSyK116NCh+LZs+GUqYfv27Ysfk2mMIjk5uXgBLdnol1f38ciRI2jRokWZx3NycuDj41Pu4mDWv1+bmqn9rn379qmgFxAQUPyavn37wmQyqQy+1rbKKG9kgJDpk9rIAyIiujyMKYwpREQ1gfGE8YSIqCYwnjCeUM1iIoXcmpeXV4n7smG3fkwLBLIhF1KrUeo+vv3222XeKyoqqtzfIRl32XBrC15d6vdrv6syDAYDzGZziccKCgrKvM46MFk7d+4c6tatW+nfR0REFWNMYUwhIqoJjCeMJ0RENYHxhPGEahZLexFVQZcuXbBnzx61mJVMTbS+VLTh7tSpk7reu3dvlX5X69at1WgAqRupWbNmjQokLVu2VPclICQmJpZY5EsWBqssea1M1SQiIvtjTCEioprAeEJERDWB8YTo4phIIaqChx56SGW0b731VrUYlkxt/PPPP3H33XerDXp5ZMMvweiff/6p0u+6/fbbVf3KO++8U238ZXqlLA4mC4FpUxylDuTvv/+uLvv371cLd8niYJUhIwa2bNmiFhcjIiL7Y0whIqKawHhCREQ1gfGE6OKYSCGqAlmoSjLkEkBkYyy1JR9//HGEhISorHlF7rnnHsyePbtKv8vf318FLAli3bt3xw033ICBAweqxbc0EyZMUEFn/Pjx6NevH5o0aYKrr766Uu8/f/58NGjQAFdeeWWV2kVERDWDMYWIiGoC4wkREdUExhOii/Mwly42R0Q1ThbfkqmJP/zwA3r37g1H0KtXLzz66KO47bbb9G4KERFVAWMKERHVBMYTIiKqCYwn5C44I4XIDvz8/PD111/jzJkzcATSjjFjxqjpmkRE5FwYU4iIqCYwnhARUU1gPCF3wRkpREREREREREREREREFeCMFCIiIiIiIiIiIiIiogowkUJERERERERERERERFQBJlKIiIiIiIiIiIiIiIgqwEQKERERERERERERERFRBZhIIZfTqFEj3HXXXTb9HfL+8ntq2oMPPojBgwfDGfTq1Qv/+te/9G4GEZHT8PDwwMsvv2y337dx40Z4e3vj+PHjcHSffvopGjRogLy8PL2bQkTklmbNmqXi1LFjx3T5/ZmZmQgPD8fs2bPh6Pbu3QtPT0/s3r1b76YQEVV4rGGL7bq8l7ynvLdehg8fjnvvvReOrqCgADExMfj444/1bgrVICZSyCFoG3jt4uvrixYtWuDhhx9GUlIS3EFsbCy++OIL/N///Z+6n5ycrD6Lxx57rMxr5TF57qWXXirz3Pjx4+Hl5YXs7OwSj+/atUv9jJxYqwnPPvsspk2bhlOnTtXI+xER1RTGFIv//Oc/uPXWW9GwYcPig47atWvDbDaXeN22bdvU56S9ztpff/2lnvv888/LPNe1a1c1AKCmBijk5+fjs88+q5H3IyLXx2199bzxxhuYN28eHM2HH36IwMBA3HLLLer+O++8o/6uEqOsSQyTWCbPyfGTtdzcXPj4+OC2224r8/5PPfUU2rRpUyNtlfe59tpr8eKLL9bI+xGRY3PHeDNnzhxMmTIFjmbNmjVYsmSJOh8l5PyW/E0++OCDMq8dOXKkem7mzJllnrvqqqtQr169Mo8vWLAABoOhRs5zyXm5J598Eq+//rqKT+QamEghh/LKK6/gm2++wdSpU9GnTx988skn6N27d5mkwMUcOHAA06dPh7ORg4fGjRvj6quvVvdlRFbz5s3xzz//lBs8ZBSUXJf3XOfOneHv71/i8d9//129Z/fu3WukvRKUgoKCmF0nIpeOKc5q+/btWLZsGR544IHix6644gqkpqaWGUGrxZS4uDicPHmyzHPaz1pLTExUJ7fkRFJNkAPSO++8E++//36ZRA8R0cW487a+JhMp48aNQ05OTrlJdXuM2pVjoXvuuQdGo7FE3Cl9LLRnzx4Vy8o7Ftq0aZNKypeOWdqxUE3FLCHxde7cuThy5EiNvScROTZnizeXs12vKJEi7yXvKe+th3fffRcDBw5Es2bN1P0uXbqoc1/lnTdbu3ZtubFC4oTEi759+5YbK2SwWGRkZI209+6778aZM2fU50mugYkUcijDhg3DHXfcoXaiJev/+OOPq5FG8+fPr/R7yCgkyfw6Ezl4kGnsN910U4nH5SBgx44daqq7JisrSz0mr92wYQOKiopKnNg6evRouQcPixYtUp+vZORrgmTpb7jhBnz99dc86UVELhtTHJXEgouRkVdSKkvKMGoqOiklBxcyW6VWrVplnpP7YWFhaN26dYnH//jjD5X8GDBgAGqKxDUpQ7ZixYoae08icn2uvK23J0lgyHa9po4VqmLhwoU4ffp0iWOhbt26qfaUF7MkLsmJtPJilih9LCTHRzLYriYTKYMGDVIzY7766qsae08icr94YzKZbDZbwRbbdW1Gjpb0tiep2iKJDutYIYmSnj17lkmWyDZfEhjy2tKxYsuWLeozr+i8WU3GipCQEAwZMkTXUmhUs5hIIYemnaApPW27qmukyM7zjTfeiNDQUJWtlhNLsgG2VlH9yJUrV6rH5fpSAVAy9m3btlWBJSIiAvfffz9SUlIu2WbZsMtGXnbIrcmGXRIl69evL35MkieFhYV4+umnVYJFRh1fauSwjNqSbLwWELS6lu+9954qz9WkSRP1ucgG/sSJEyox8uqrr6J+/frw8/NTs0/OnTtXpt2ynouc9LJuAxGRK8WUpUuXqm2q7ARLoqFly5bFJRitd+onTpyotvuy/e/YsWOlTqzI9lNKY8l7yrZWTgxJrCodh7T4tGrVKvV6mV0o2+eLkdHG0l/rA6cePXqoNVNKH2jIfZneLs9bPydxTeKPjLgrfQAmMVRmUEq7Rf/+/dGuXTvs3LkT/fr1UzFFRor9/PPP6nlpuxzkyOulvzJbpjQZ/SVxmic/icje23rx7bffqu2gbL/kBLlsF6V8iDWZiS37+jJwKzo6Gg899JDaz7ambQ9lHQ3ZTsr7SfkQKVWlkVIwcvJn8uTJZdohJ39kmysjnjXyO+SEndRal98t29e3335bbaetyX2Z2dG+fXsVj+rWrYtrrrkGmzdvVs/L+0oiXmKUVqJGO26q6Fiopvp8qZglx3BNmzYtfkzilcykLy9myQhwGUlc3nMSr6UtpWNWcHBw8TGSrCEgfT148KA6KSrPyWf1wgsvqOMgOR7SZt/LqOT//ve/ZdosA/ek34xZRO6rOvFGtj1SEkwG0mrb1sWLF6vn5PyM7HfLMYHsM8u+sbYvbU3WFHziiSfUdktKIl5//fVlZpVXtF2XbZacF5Ltufxu2e7KuR/rAbqybZPtphyraLFCWyO4ojVSpBzwlVdeiYCAALUdlm3ovn37SrxG2/YePnxYxR55nWx/ZdZGZWb1SJvkXFh5580krsr7WscD2Ybfd999xUkV6+e0nytdDl+2/9p5M+1c4I8//qjitcQ1+bxlQHFaWpr6O0hslmMzOU6UfpS33qOcN5NzfuWdUyPnw0QKOTRtqrQEkuqSDaoEoz///FOdgNLqE0qwkenYNUWSJs8884zaqZcDGNmISnAcOnSomnFyMZLkkA20lOSyVt7oYdnoSz1Oea2cSLM+gKgoIEjf5f0lUWJN2icHR4888oiqGywnuiRj//zzz6tgLnUnJfBInUhJ3JQmgd369xIRuVJMkfIh1113ndohlqn8ciJFYof1Nk+mtsvBhkzzv/3229V0czkgkIMDiQUXI1PKZfsv9eA/+ugjVSZk+fLl6v3KO5iQGCYnqaQm+7///e8K3zc+Pl6V6ZKp7tbkpJpst61jihwsyEXipFys+yYHE+np6WViisQ0SYTILBZrMnBAPi9JmMjJMzk4k7798MMP6lpe/9Zbb6mTeHIAkpGRUabt0mbGFCKy9/GDnCCRMiVycly293JfkhZyYsj6BJAkEeTkk8SDsWPHqnWdZP+69L6+bA8lgSGJdXltq1at1H61zOYTkniXpLOcnClNtpky0lcS60LigbxWEj2yFqLECzneeO6551TtdWuS1NcSLpJokVgh235tUJbEKtk2y8kuuS0XOYapSE32+WIkFpaOWULij8Q065OAEiO0mKWV+RKSAJH3kSSLzJwvPcJYTmRJ8srazTffrJJPEpskdr322mtqYJy8Vk6YyWcoSSs5Dlq9enWZ9klMlXKZEiuJyP1U93yVxBZJhMg2SI4XtCSF3JbzPBKHpAyjbLMkFpQeBCwzYmRbJdti2X5J7KrsLApJgMhJf4kf8vtkO1b62ELWWezUqRPq1KlTHCsutl6KHBfIeS8ZXCZxQ95btscSq8pb6F7OOclxwJtvvqluS5vKG1hQmrynfNalS5VVdN5MBlDLtl0+H/lZ6+ckISLxqnSskKSIzIi0Ju2Uc2ryGU2YMAG//vqrOm6T25KQlz6PGTNG9UPiRmnyGWsxilyAmcgBzJw5U2pDmZctW2Y+ffq0+cSJE+bvv//eHBYWZvbz8zOfPHmy0u/VsGFD85133ll8//HHH1fv/ffffxc/lpGRYW7cuLG5UaNG5qKiohJtiI2NLfF+K1asUI/LtUbeX36PRt5bXjN79uwSP7t48eJyHy/tjjvuUH0tT3h4uHngwIHF94cOHWq+++671e2bbrrJfOONNxY/161bN3Pz5s3LvMe4cePM/fr1K74vfZR21a1b15yamlr8+HPPPace79ixo7mgoKD48VtvvdXs7e1tzs3NLfPe8vikSZMu2j8iImeMKR988IF6H3mPikyZMkW95ttvvy1+LD8/39y7d29zrVq1zOnp6cWPy+teeuml4vvZ2dll3m/dunXqdV9//XWZ/lxxxRXmwsLCS7Zb+i2vX7BgQZnnnnnmGfWc9hl89913Zl9fX3NeXp550aJFZqPRWNzmqVOnqteuWbOmxHssX768TLyUGCOPzZkzp/ix/fv3q8cMBoN5/fr1xY//+eef6nHpV2n33Xef+hsREdlrW3/o0CG1nRo9enTxcYHGZDKp6+TkZLXPO2TIkBKv0baTX375ZZntofV2XLaxkZGR5rFjxxY/9tlnn6nX7dq1q8TvbNOmjXnAgAHF91999VVzQECA+eDBgyVe9+9//1tts+Pi4tT9v/76S73fo48+WqaPWj+EvJf1sZKm9LGQLfpcHjnm8PDwMD/11FNlnvv999/V+37zzTfqfmJiorq/atUqdTwn/ZfXiN27d6vnXn/99RLvkZWVpeKcdcyRWCyvlZijkfhav3591Za33nqr+PGUlBT1fSrvM5OYJ++zYcOGi/aRiJxbTZ6v0vaN9+zZU+a50scGckzRrl27EjFh+/bt6j0efPDBEq+97bbbyhxrlHeOq7zjj/vvv9/s7+9f4nzPtddeW+KcV+lzSdbb1E6dOqnzVmfPni1+bMeOHaqf48ePL7PtnTBhQon3lPhb0fkwa3Is1LVr1zKPy7GLxIOJEycWP9ayZUvz5MmT1e0ePXqoYyCNnAcbPHhwmfe58sorS2zrtXOB8jeQv4X1+TGJFcOGDSvx83L8V95nlpCQoN7n7bffvmQfyfFxRgo5FJmiJ9MTZRSVjF6VTLnMGpERQdUlWWWZpm89olbeV2ZaSHZcRvderp9++kmNQJbRSzJlULtI5ll+16XqvZ89e1aVECiPZPG1tVCsy6xoz2kjd2W0mpTYKj1yWH5GZpeUN0JBRjdIuzWSrRcyxd16xJY8LgtyyYiw0qTd1tMkiYhcJabIdHNtCnzp8inWMUbKftx6663Fj8mop0cffVSVX5SZfhXRymIJGdkrsUBGvsrv3bp1a5nX33vvvZWqRyzvI8qLK1qM+Pvvv9W1xBCJVVJCRUbxanFGe05GMpcelSV9btOmTfHoOY18vvI5a6SEl/RF1lfR4ovQbkvZzdKkzTLLx1EX7SQi19vWS1kp2fbJiNzSMxm0soYy2lb2hWW2h/VrZLsspUNKjxaWNsj+tEa2sXI8Yr3dk9Grsr8tM1A0MrtBjk1klLL1cYbMINH2ubWL9FuOD7SZEr/88otq70svvVSmj9Wpj2+LPpdHSp3IucXyYpYc88jv1kYZS1ySGCslv+T3dejQofhYqKKZ+TLyW2aWytoGpcmobo3EV4l30haZ2aOROCbxrKKYJXgsROQeaup8lcwylH3pix0byCw/KR8l23/r4wLZDxdyrGFNttWVYf07ZFaIbL/kd8i+9/79+1FVsk6vnIeS2fhSolcj22c5P6a115rM5rAmv1+OXy41u6+i82Yyu0R+nxYrpE9Szqu882Yyg0TW5CqvHP66devKPW8ms0Gt12GWYxmJFTIjxZo8LjP9pfyYNcYK11JybiuRzmS9DilbJQcVMuVddlpLH9BUldR1tD6Bo9EWzpXnS9fRrapDhw6pICfTAMsjUxwvpaIF22UDL8FZgpNsvOX3SCAQEhgSEhJUQkjqcsoGu3RAkNIxEijKCwiyELE1LakiOwblPV7eei/Sbj0WpSQisnVMkRNZX3zxhTrRIlO5ZWFbOfElZam095EY0rx58zLvax1jKiIJA5kqLgvDS6LaOg7Itr60xo0boyrKiysSP2SbLQcTcgAo13KQo50skoM67TG5lpNVcjLMmpw8GzFiRJn3lnKTpeOBxI+qxhTBuEJE9trWS2kWeX15J7U02rZc3tuabB9lrcHS2/rytodyIkXWkdJIyRSJK1LeS+rTC0mqSD8k1lgfZ8jPycm7ix1nSD+kBJf1iazLYYs+VzVmSVySNQSskyVS9kY7EWhdklKuteRN6ZglCRL5blTmWEgGEMjfpvTj2iCF8trMmEXkHmrqfFVF+/QLFy5UJQbl3I/1WhvW2xjZ9srvtF5TqrxtdUWkJKKUcpckc+nERXnHH9WNFdrxkJTEkrK+snZKRdteLdEgxwaSqK/uebP//e9/KlkhJbQkOS6lvbRYISXt5TO9WDl8UbocflXPm8nADPkcrcu9MVa4FiZSyKHIjm/pka/2UtFGzXrRrYrIxlKSKLLmSHkqOvDRyEa2okXpres9ysGBHBxJzWEhdStlMUd5TlvgrHRAkBEAMmq4vIPDikY2V/R4eUFLMvelDzaIiFwhpsiJGhnpK7MK5USMzO6Tk1yysKQsQFyZ2SEXI+tTSRJFRpDJbBDZ+ZZYJAmO8mbAWI8guxhtx728uCLPSQyRuCEzZuQEl/XoZTnQkOdkwUpZZ0XWfbEmsUZGq33yySc2iSnSZolrle0rEZGexw8Vqex2T7b3sq6inDST/XpJqkhyxXrfWuKBJLf/9a9/lfueclLPEVRlW29Njm0k9l3sWOjTTz9Vxxza+igauf3ll1+qWZ0Su2SGpSRCSh8LyWdc2TZXNWYJHgsRuYeaijfl7efKbHFZi/Gqq65SJ/2joqLUQFo5VpgzZw5qgmxHZTaMJCtkHRZJxsg2U2a8yJpWFc3Ad5R4canzZpJIkTghiZT27durGUNarJAkigwyllghiTAtyWIdK2TAmXXFlku1t7L9YKxwLUykkMuThahkWl9p2rRFbaEqLQuuLVioudhoYo0EIJn+Lhve6pz8kZNakoSRzHXpDbcsvKglS2RxSDnZpiV9JADIaGEJFnJyS5I5pQ+m5ORf6QWBa4qMoJYp/9rIayIiVyMjvuSkllzef/99tfCjLMAoyRWZ3i8xRJIRcuBhPSKtdIwpz88//4w777xTLcqryc3NLROHqkpLtmsJ9vIONOTEkySDZLBA6ZNS3333HVauXFn82tIxReJU6cdrirSZMYWI7En242UbLiW1JJlRHm1bLscUMhtDI/vBst2SeFAdo0aNUou9a+W9pOSILCJfun2S+L7U75DXyYhaKZV1sVkplR0Ra6s+lybHM9L2i8UsSd7Lsda2bdvwzDPPlIhZMrtTYpOU3ho7dmyJn5VSaTIooLKLMFeVtFliv6Mks4jIeUl5RklqyHZczvtoJJFSetssMUtmIVrPAinvnFdpsn8vs+tksXRJ2GjK2/5WJ1aUJsdDkjywno1yucc48jldagCylOjSqrgIma0p7ZTzZtrMRjnHZp34kAFzTz/9NGxB+3x5jOMauEYKuTxJImzcuFFtTDUytfDzzz8vMVNDmxqp1RkWcoJJXncpN910k3qtNi3fmpTbutRJMUmOyMZ7y5Yt5R5cSGkybaNvfcJLyH1ps9S0tw4WIikpSY0usNXBg9be0m0iInIFcjKqNO0kmzbdXmLMqVOnStS4l+2+jIiSUVAy6qsiMoqp9Igl+bnKzIS8GKnTLFPNN2/eXOGBhvyO9957T5Uls541KdtzOWEnI+Hk5FDp7buM1pIp79braNUkiVmMKURkT5LMkO2djM4tPRpX20ZL0kBmhn/00UclttszZsxQA6Gqu68tpauGDh2qZqJ8//336ndIe0ofZ8hxjFZ2xJocY2i12CWJIG2bPHlymddZt1lOaFUmYW+rPld0LHSxmCVkMIPMPLGOEXIsJ6O233nnnRKvtY5ZUn7HVjOW5FhISo+VN4KZiKgq5LhAkhfWxwFSwl3W8bKmrfck22ZrU6ZMqdTvENbbdEmOy35/aRIrKlPqS7bBcnz01VdflYgtksiWQVs1OahXYoXM7ihvzSpJlkjJtOXLl6t4Ut55M/ksJeFTXjl8KZNpy/Nm8reV9pPz44wUcnlS115G10rAkQW5ZISWbOQlKyzZbG0EsewEy/Q+GQWmjeSSA5rSC0WVR06UyWgyqXUvU/PlJJNMw5SaxrJA5Icffqhq6ldENuQyTVFGWknJmPKe1xasL50skYAgv1d7XemDBxnVcPXVV8MWli5dqupFSkafiMjVyEk1SVTLTrWMYpIdbDnQkDrw2vb2vvvuw2effaYWWJSdZDmpIzNNJPEtBzSy+GFFrrvuOnzzzTfqBIwk9eVEmcQB65q61TVy5Ei1vlZ561hpbZffJ+22JqNqZeSYPCdT4uUkn0ZG/UoskhIrtiCfn8RfaTsRkb00a9ZMzTSUAVGy4K2sTyKjgeXEipyYkf1sSTjLMYIkKa655hpVfkVOxkhMkNnh1ousV5WsxyU/L+8lSRXr7a6QGRi//fabihmyzZbyVTIobNeuXSreyIk22W7L/v64cePUyTU5BpF2SmJIysXIcw8//LB6P/l5iTWSmNBOPJW3nqQt+1yabPclHsqMnNKzO+RYQwYHSFySGCttLn0sJMd0EutKHyfJTBU5BrRFXXpJ6qxatQoPPvhgjb83EbkfOd6Q7bJsb2+77TZ13CFrskiMsl5rSpIWt956q9oWS6JDtoGSPDh8+PAlf4e8ViqxyIx4OTcm20bZ9pZXUktihQwUe/LJJ9U2XwaIlbdGonj33XfVtlYSBRMnTlTHDDI4TI5xXn75ZdTkZySDuSSGyTFYaXKMI/2p6LyZnBfUXlc6VlRUDr+mzptJe2riGI/0xxkp5PJkFJLUSJTawrIxlwMCGV21YMECjB49usRrpbyWbGDfeustVb5FDjrkdmXIiSWZvSIB7//+7//U75EFvOQgo/RGvDRpj9Shl6RLebQNvVbKy5q0Vzs4KC+RIn2wRa15OTCTg5bx48dz0Swickly0khO4EgZrIceekgdzMg0eNm2a6NPZfsq0+RlGy5J+qeeekolA2Qa/mOPPXbR95cku2xDJfbIzyUmJqoDA62e7+WYMGGCKr+oLahoTUq0aCeiypv9oT1WOqZIv2UmjjYSrqZJDJTPu7wBBUREtk6cy7ZeTv5IUuXFF19U5X2lrKNGTgZNnTpVlYp64okn1CwSOZEjI25lANXlxBqJJRkZGSqpUpqUH5ET9pJQkXgjsUWOTyRZIkkO69kQEnvkhJYMGJPXy/GM9Ml6Wy8n6uQEmSw2LCfjylvzytZ9Lk1OzkkySN6/PFo8Ki9macdZUvLF+iSVnGCUY0BblTiWE5cS7+WEJBHR5ZL9X5nxJzPdZf1EOen/9ttvlzlnJSReSSJEylHJ+lmS2JVkwKXINlIWtJdZJBIDZHa6nCfTZvVZkySxJHQkrsi1rO14sRmM0hZ5f4mf8r4ySFmOQyRZX5Pn9mSbfqlYIbPzS5dXtj4nV955M1vFColFEjNLD14j5+VhvtRqPkRORkYsyWiuL774As5EpifKAcAff/xR4qCtumQmjQQyGUVni5FSMi1SAqrU5pRATEREjkViiSRMtJFZl0tiiUyVl3KZNU0SNDISTGaRXioBRURErkdmBMkJO0kQVbSAb1XIiTYZ5HDmzBmblN6SEmwymExmfxIRkX3ILMv+/fur9VekRPHlknL4cj5LEky2SKZIhQJJVMl5M1sMcCb744wUcimSiZfFs2REk7OREcIyDbKyM2AuRUZIycix8kYw1AQZHSElAphEISJyTDISWabky6jqmiClBMqrvV8T5OSZjG5+4IEHbPL+RETk2OS4RdboktLKNUFKpEmZM1skUfbt26dOupW3PiYREdmOlOCUUvrlzaKp7owRmUVji3L4cn5SZoHK7B8mUVwHZ6SQ05ApjhezYcMGNUti1qxZauqcTFEkIiKqTkyRnV0uHktE5Ny4rSciIntgvCFyD0ykkNO41DocMr1PFtiaNGmSWqOEiIioujFFap5LYp6IiJwXt/VERGQPjDdE7sFT7wYQVdbSpUsv+rzUgW/Tpo3d2kNERK4dU4iIyLlxW09ERPbAeEPkHjgjhYiInJKsJ/Tcc8+phallETeRm5uLp556StXXlsWrhw4dio8//hgRERF6N5eIiIiIiIiIiJwUF5snIiKns2nTJnz22Wfo0KFDmYVKFyxYgJ9++gmrVq1CQkICxowZo1s7iYiIiIiIiIjI+blEaS+TyaROlgUGBl6yLiEREZUkExMzMjLUdGODwfHz65mZmbj99tsxffp0vPbaa8WPp6WlYcaMGZgzZw4GDBigHps5cyZat26N9evXo1evXpV6f8YUIiL3iSm2xHhCRFR9jCclMaYQEekfT1wikSLBJCYmRu9mEBE5tRMnTqB+/fpwdA899BCuvfZaDBo0qEQiZcuWLSgoKFCPa1q1aoUGDRpg3bp1FSZSpASYXDTx8fFcb4mIyE1iii3xGIWI6PIxnlgwphAR6R9PXCKRIhl57QMJCgqq8s/LibclS5ZgyJAh8PLygrth/9l/9t+9+z9v3jzcc889xdtSRyZrn2zdulWV9irt1KlT8Pb2RkhISInHZX0Uea4ib775JiZPnlzm8S+++AL+/v411HIiIveQnZ3tNDHFkY9R3H3/RLj7Z8D+s//u3n9nOkaxB8aU6mP/2X/23737P68G44lLJFK0aY0STKqbSJGTZfKz7vqlYv/Zf/bfvfsvHH2KuBw0yMLyS5cuha+vb429ryxY/+STTxbfT09PV6O9Ro0aVa2DFGnf4MGD3fb7xP6z/+y/e/Zf+wzmz5/vFDHF0Y9R3H3/RLj7Z8D+s//sv3Mco9gLY0r1sf/sP/vP/tdUPKlSIkVG7f7666/Yv38//Pz80KdPH7z99tto2bJl8Wv69++vFvi1dv/99+PTTz+9aK2yl156SdW7T01NRd++ffHJJ5+gefPm1ekTERG5ICndlZycjC5duhQ/VlRUhNWrV2Pq1Kn4888/kZ+fr+KI9ayUpKQkREZGVvi+Pj4+6lKa7GRUd0fjcn7WFbD/7D/77779JyIiIiIickVVWmFFEiRSm14W7ZURd5LVkalBWVlZJV537733IjExsfjyzjvvXPR95fmPPvpIJVs2bNiAgIAADB06FLm5udXrFRERuZyBAwdi165d2L59e/GlW7duauF57bacvFy+fHnxzxw4cABxcXHo3bu3rm0nIiIiIiIiIiLnVaUZKYsXLy5xf9asWQgPD1ejhK+66qrix2XKzMVG/5aejTJlyhQ8//zzGDlypHrs66+/VjXtpYbZLbfcUpUmEhGRi5J6lu3atSvxmCTew8LCih+fOHGiKtMVGhqqpq4+8sgjKolS0ULzRERERERERERENl0jJS0tTV3LCStrs2fPxrfffquSKSNGjMALL7xQ4YK9sbGxahHgQYMGFT8WHByMnj17Yt26deUmUvLy8tTFup69kBkycqkq7Weq87OugP1n/62v3Q3771r9/uCDD2AwGDB27FgVJ2R248cff6x3s4iIiIiIyEVJqeF3331XDTKWqixz585V6y1a27dvH5599llV6aWwsBBt2rTBL7/8ggYNGujWbiLSn0wwkG2ClC231TkfT09PVfXJVr/DERiNRtVPW6+rVe1EislkwuOPP67WM7EeIXzbbbehYcOGiI6Oxs6dO1WgkNIqsrZKeSSJImQGijW5rz1X3lotkydPLvP4kiVLKkzYVIaUK3Nn7D/7787cvf/OauXKlSXuyyL006ZNUxciIiIiIiJbk3L3HTt2xIQJEzBmzJgyzx85cgRXXHGFmj0v57Jk5vyePXvUsQsRuS9Z41WSr9nZ2TZN1MhEhxMnTtg8yaA3yQlERUXB29vb8RIpslbK7t278c8//5R4/L777iu+3b59e9UBqWsvgaNp06aoCc8995wq3WI9IyUmJkat1yIBqTrZOTmJOnjwYLdcHJT9Z//Zf/fu//z58/VuBhERERERkVMaNmyYulTkP//5D4YPH15i/eCaOj9GRM5JJihIlSaZSSGTEeTkvy0SHfJ7MjMzUatWLVW9wxWZzWaVlDp9+rT6TJs3b26zvlYrkfLwww9j4cKFavpi/fr1L/paKdElDh8+XG6g0NZSSUpKUkkXjdzv1KlTue/p4+OjLqXJSdDLORF6uT/v7Nh/9p/9d9/+ExERERERUc2fxPz999/xr3/9S5Ud3rZtGxo3bqwGCJcu/2WrkvYsZ83+W1+7G0ftv/x/S6mtevXqXVZ1pcomGeQ8uivPSPHx8VFJqbi4ODXDR8sb1PTf3bOqH74s3Cv1HqWcimz8L2X79u3q2jpJYk3eQ5Ipy5cvL06cSIDYsGEDJk2aVJXmEREREREREREROYTk5GQ1Gvytt97Ca6+9hrfffhuLFy9WJcBWrFiBfv362a2kvbuXs2b/2X9HIut5yPlwOekva6TYWkZGBlxdfn4+cnJyiteisgXPqpbzmjNnjioDExgYWLyGiSwO7+fnp8p3yfMyZTEsLEytkfLEE0/gqquuQocOHYrfp1WrVioojB49WmXDZK0VCSgy9UYSK7I4vUxrulh2noiIiIiIiIiIyJFnpIiRI0eq82NCBhGvXbsWn376aYWJlJosac9y1uw/++94/ZfF32XdEim5Zcv1kmRShCRR5Dy+K89I0T5TyU9IHkL7TGu6nH2VEimffPKJuu7fv3+Jx2fOnIm77rpL1XNbtmwZpkyZohbbko382LFj8fzzz5d4vSw+n5aWVnxfpjjK62V9ldTUVLUIl2ToufAWERERERERERE5ozp16qiR523atCnxeOvWrcusOWzrkvbuXs6a/Wf/Han/UtZLEhuyloct1y7Rkrna73JlBoNB9dOWf+sql/a6GEmcyPSZqr6PdPKVV15RFyIiIiIiIiIiImcnA467d++uBhRbO3jwIBo2bKhbu4iIatqxY8dUpSlZC6qidc+dXbUWmyei6snasBH5sbHw8DRKQUR4GD3h4eUJGI3Ftw1+fjD4+6uLh58/DAH+6jEPo1Hv5hMRUU3JOgMk7QayzwIFOYCpEPCvAwRGAqFNAP9QvVtIRESuLiMJSNwONB8ioxv1bg2R05I1UA4fPlx8PzY2Vq0XHBoaigYNGuCZZ57BzTffrMrNXH311aoCy4IFC9Taw0Qu5fhay3FNwytkeoDerSE7i4mJQWJiopqJ56qYSCGyk4L4eGx/4i1k+4UDZhM8zEXwUNfabbO6Nhblw2jKh7Eo7/zFctvTywPGAH8Yg4NhDAkpex0SDGNoKLzCw+FZty6MdevC4O2td7eJiEgUFQBHVwK7f7FcZyRe/PWhTYGYnkDLaywnuLz87NVSIiJyFx/3AnLOAaM+BTrdqndriJzW5s2bVYJEo61tcuedd2LWrFlqfWBZD0XWCn700UfRsmVL/PLLL6qsPZHLyD4HzBwudYiAoPpAx1uAbncDwfX1bhnZidFoRGRkZI2VPHNETKQQ2cnpNeuwvf2DgEf1NwaGonx4FWbBsyAbXilZ8ErOhmdBFrwKY+EljxVkwic/Dd756fDJS4NvgCe86tZRiRXP8HB4RUfDq359eNWvB+/69eEZEVGjfSQiolLys4CNnwNrpwLZZ0o+JzNPgupZkiQSG7JOAxmngPR44NwRy2XHHMArAGg9Auh5H1Cvq149IXIpL7/8MiZPnlziMTmxtX///uLFKp966il8//33yMvLw9ChQ/Hxxx8jgvtO5EokiSL2L2QihegyyDrClyqFP2HCBHUhclk5KZYkikg/Cfz9HrBmCtB2DNDnESCqg94tdHyyHSnIrtn3lDVS5D3zjRXPEvLyr9LMVJPJhPfeew+ff/45Tpw4ofaP77//ftx+++1lSnv99ttvap9aXte7d2+1xrpcUlJSEBISopLNjz/+OL7++mv8+9//VmUPZYZfVFQU/vOf/+C7775T66m3a9cOb7/9dpl12+2NiRQiOzl74CTgEQrvokzUjzwDk8lDJqao7aRs1ywXMwqLjCgo8kSByQeFZh8UmH1hhqWsl8nojTy5+NSu1O+UGS6SVPHOTYfP4TT47j4N39wD8M09A7/cs/AtTId/3WDU8/FB8uYt8GvWFN5Nm8GnWVOVZJEsMBERVYNs1LfMBFa+aUmQiIC6QNvRQOvrgehOgE9gxaO5Tm4GYlcBe38D0uKAnd9bLjG9gCufZBkWohrQtm1bLFu2rPi+LAaseeKJJ/D777/jp59+QnBwMB5++GGMGTMGa9as0am1RDZUmKt3C4iIyNnJCS7hHQhc/xGw+Uvg2N/Arh8tlzajgKv/A9RtoXdLHZckPN6IrtG3lNRJyKVe9H8JgHdApd/zueeew/Tp0/HBBx+omXVSzksbjGRNyhzecMMNeOyxx3DPPfeoBMvTTz9d5nXZ2dkqSfLFF18gLCwM4eHhat977969alBTdHQ05s6di2uuuQa7du1C8+bNoRcmUojsJC05R13XxXEMe/WRS/9AUSGQlw5zTiqK0s+gMCUJ+alnkZeSity0DOSm5yAvMwe5mXnIzfdCnikQ2aZgZJtqI8sUihxTEMweRpV0kUtGBb9GZrf45p7F0b1n4L95NwKyliMgOxG1PDLh17gBfJo2hW/rVvBt1w6+rVqptVuIiOgi0hOA3x8Djq6w3K/dCOj3b6D9jYCxErtesj5KiyGWy5DXgJObgE0zLGXBTqwH5twENOgDDHoZaNDT5t0hclWSOCmv/EBaWhpmzJiBOXPmYMCAAeqxmTNnonXr1li/fj169eqlQ2uJbKgwT+8WEBGRszMVWa7leKfdGMslYRuw5iNgz1xg7zxg329A17uAAS9wTUgnlZGRgQ8//BBTp05V5QtF06ZNVUJFFpu39tlnn6kZ3++++666L7d3796N119/vcTrCgoK1Mzvjh07qvtxcXFq31uuJYkiJAEj60vJ42+88Qb0wkQKkZ1kZBoBHyDQr5IjviT4+IfCwz8UnmFN4NkY8C3vdTKlRaZQph4HUo5brs/tQlHSYeQkxSM724CsIkmuhCGjqC7Si8KRXhSBjKII5JiCUejlj0y5BMaUel8TfHPPIeDwKdTavgeBGX8gMOsEguvXhl/bdiqx4tehPXzbtIGH1QhOIiJ3Fp6+E57THwFy0wBPX2DgS0CPewGjV/XeUGadxPSwXAZPBtZNs5QKi1sLfDkE6HCLJdlSq25Nd4XI5R06dEgdnPn6+qpSA1K7XhYF3rJlizqgGzRoUPFrW7VqpZ5bt25dhYkUKQEmF016erq6lveSS1Vor6/qz7kSd/8M7NF/LTKZCnJQ5GCfM//+7D8RORnz+USKwer8UHRn4MaZwFVPA3+9Dhz43TJTZc88y7FNpzu4KH3pElsyO6QGSRmu9IwMBAUGVrzuiPzeStq3b5/a3x04cOAlX3vgwAF07969xGM9evQo8zpvb2906HCh9JvMOpG1Ulq0KDl7SX6vzFjRE89+EtlJZoG/SqQEh9VwkJCTbJLJl4sEqfOkGFgtsxm1MpOB0/stl+R9wKlVwKldQFG+Kh8miRVJqqQVReKcoSVSPFogJScMuXlG5PrVUZezYe2K31fWYQk8GofAHTsQ9OlvqJ2fgOCOreHfozsCuneHb9u28PCq5glDIiIn5rH9W/Q88j48YLJsj0d/XrNT1wMjgSGvAj0fsJQM2/atpdzXwT8syZTO41jui6iSevbsqWoyy8g4KUcg66VceeWVapTcqVOn1AGd1G22JvWf5bmKSCKm9LorYsmSJfCv5ozepUuXwt25+2dgy/6PPH+dcS4ZKxctgiPi39+9+09ETjgjxcNSmr6EiLbArXOAY/8Avz8NnN4H/PYIsOUr4Pr/ARFt7N5chyTHclUosVXpktNeRZb3rYGklZ+fX400q/R7Wi8tkJmZqRaul8FNcm2tVq1a0BMTKUR2kmWwHIzXrh9kv18qG6LACMulSb8Ljxfmq8DllbANISe3wLh/NRrmbYeHaaHleV+o0mApnu1wLqg/Tnu0w+n02jh7Kg8FqIVzoW3URROQGY+Q3w4j5OuVCM07idBenVCrf3/U6t8PnqGcrklELk5mBq58C56r3lJ3Te1vgmHkNMDT2za/L7geMHIq0PVuYOHjwKmdlgORA39YDkQC6tjm9xK5kGHDhhXflhFwklhp2LAhfvzxx2ofIEq96CeffLLEjJSYmBgMGTIEQUFBVR6NLSdQBw8eDC83HaDi7p+BXfq/zXIV5O+N4cOHw5Hw78/+z58/X+9mEFG1ZqSUk0jRNLoCeOBvYMNnloFh8ZuBz/sBA54Hej988Z8lh9C8eXO1r7x8+XK17snFyIClRaUGamzatOmSv6Nz585qRkpycrIa6ORImEghsoPC1FTk+Fimn9VuWaqElh7k5F5UR3Uxdbgdq7AIwwf1g1fSduD4WnXxO7kJfoVrEZ26tvjHitp1wdmw65Ds01slVhKPpiElMRtZteqpS3w9S7Im8Gwcwj5fgzpvfY7wJiEIvPpqBA27Bt4NGujYaSIiG/nnfeB8EuVAxPVoMmIaDLZKolir3xW4dwWwfhqw/FXgwCLg482AJHFkfRUiqjSZfSLlAw4fPqxOXObn5yM1NbXErJSkpKRy11TR+Pj4qEtpchK0uidCL+dnXYW7fwb26L9HUb7Dfsb8+7t3/4nIRWakWJOSx30etqyhsvAJ4OBiYOmLlkFhoz4BQhvbpblUPb6+vnj22Wfxr3/9S83g7tu3L06fPo09e/aUKfd1//334/3331evnzhxIrZv365mhAvrGSilyT757bffjvHjx+O///2vSqzI75DkjQyAuvbaa6EXJlKI7CD9UBxMRh+17khwk4ZwSDLNr0l/y0VbdFIWOD68HDiyHEjcAWPSVoTLRZ4Pqgd0vw45jUYgIac5Eg6nI/5QCs6ezEJGYAN1OdZoOLzy0xG2aA/Cv3oS9WK8EDLiOpVU8dS5riERUY2QReCXv6JuFg2cjP3nGqOJPctryXpafR8Dmg4AfrnXMk1+zo1Az0mWMmDVXZuFyM1ICYEjR45g3Lhx6Nq1qzpxKQdrY8eOLa7xLAteyloqRC6noJJrOBIREV0qkVLZ8lFB0cCt3wPbvgEWPwfErQM+6QuM+BDocKNNm0qX54UXXoCnpydefPFFJCQkICoqCg888ECZ1zVu3Bg///wznnrqKbVAvexH/+c//8GkSZPKHXxkTRaVf+2119TPxsfHo06dOmqdwuuuuw56YiKFyA5S9scB8IdfQQqMoWUXVnJInj6WaZdyGfQSIGutHPkLOPgncGgJkB4PbPwMfhs/Q9OAumja6Tbg8YeRbQrB8d1ncXz3GcTtOYsCBOFUVG912VeQibo/bkPExxMR070xQm+9Bf49e1w0E01E5LBkkcTfn7LcvuoZmHo9BOhVYz6yPXDfSmD5ZGD9x8CGTywlv26cBdRS6W8isvL0009jxIgRqpyXHAC+9NJLqgbzrbfeiuDgYDVqTsp0hYaGqrJcjzzyiDr4q2iheSKnJgOoiIiIaqK016VmpFiTc0FdxgONrwLmPQgcXwP8eo8lqXLNm5bzUuRwDAaDSojIpTSzlL22cv3116uL5vXXX0f9+vXVzBZx1113qUtpMqhJ1h4sb/1BPTGRQmQHaXHJUgwSAUVnAF87rpFSk+REXMdbLBcZtXZ0BbD3N0spmazTwJoPVZ1L/y53onXfR9G6T3sUFZqQeDgVR7efweFNicjJqoWE6CvVZX9KEuq98A0a+LyLiJtHIWTsGBiquRArEZHdJe+z7OzDDHS/B7j6P0Bhob5t8vK1HHA07AvMfcByIPLZVcBN3wAx3fVtG5GDOXnypEqanD17FnXr1sUVV1yB9evXq9vigw8+UAeJMiMlLy8PQ4cOxccff6x3s4lso5AzUoiIqKZmpFTjVHPtRsCdCyzrpqx+F9g8A0jYCtz4FVDbQau6UKXI/nP37t0RFhaGNWvW4N1338XDDz8MZ8VECpEd5GQVqGs/ZMAlyMm6lsMsl6ICywyVv9+3LBS28TNg85dAp1thvOJJ1G/VGPVbheKKG5sh/mAqDm1KwuFNp5DjH4HDTcfgiKkQ4b9uQ6Mvx6HhjQMRevvtMAYH691DIqKK5aYDP/w/e3cBHcXVxQH8n5W4uyskBHeX4O7aUihUKBVaKsBHC7QFWkqNQqFUsUJxd3cI7hIgJMTdPSvfeW+SkECAJGxWsvd3+s5ONiszIc3svPvuva8BhdmATyeg13xhNZW2COwH2B8B1o8Gku4BK/oIKfIsc5AQwq1bt+6532er5JYsWcIHITWenDJSCCGEqKHZ/POw57Gm8x6tgC1vAzFXihaFrXxcgp7onPv37/MSXSkpKfD09OSluqZPnw5dVcHCdYSQl6EsXuVlUAP/l2P19+v0Bd46BIzZBnh3ABSFwOVVwOIWwJ6pQFYiRGIRPAJt0WVsIMb90AFBowPg4G4GpUiCeKcWOBfwPg4eB84NnIj4H3+GPC1N00dGCCFPY6nK294Fkh8IvaKGLRP6lGgbB3/g7SNAYH9AXiDs85FvhP0nhBBCCCGEEE00m3+R2t2Bd04Cbs2AvDTg3yHCYl2ikxYsWMDL6Obl5eHevXsl/VV0VQ2c1SVE+yhlBfzWoKJNt3QRW43t1xkYtwt4Y7/Q+JgFVFiGyqLGwLH5QH4Wf6ihsQT1OrhhxIxWGD69OWq3cISBgRKpNnVwpc7b2H/FFueGTUJhPCuJRgghWoQFie/uAsSGQsksM3toLSMLYPgqoENRH5cT3wNbJlAtfEIIIYQQQohqVbbZ/PNYewDj9gANRgiZLrs+Bvb+D5BruJQy0Xs1eFaXEG1SVPJFiyq/VCvP1sCYrcDY7YBLY6AgCzj2LbCoCXDhn8cnWACOXpbo8WZ9vDa3LRp2dodEDGRaeOJKrfGIOX1To4dBCCFlpEUA+4sa6nWZCbg3g9ZjFzJdZwEDfhVWh93YAPw7GMhN1fSeEUIIIYQQQvS52fyLSsoP+VMo98WcWwqsHVWyQJcQTaBACiFqoCwqpWLAmhLrE1bH8u2jQukbGx8gOwHY/QnwZxAQeb7MQy3tTNBhpD/Gzm8PC6Tz+1KjhFtCCNE49nd8xySgIFOo29vmfeiUpmOB1zYBRpZCE/oV/YAsyvojhBBShEo/EkIIUUlGiooCKcWVTzpOAUasAiQmwIODwKoBQHay6t6DkEqgQAoh6qDP1yVsNXT9ocD754WGzEZWQNx14J/uwNZ3n5rIMzE3hJWxUHYmOzlHQztNCCFPuLQceHhM+AA/8DfVXiCoCyu5OH4vYOYIxN8ElvUUsmwIIYSQwlxN7wEhhBBdpuqMlNLqDhTKyJvYANGXgOW9gLRI1b8PIS+gu91dCNHBQEo+FNh6fytEBiKIRWKIDcTCtoEYUpEUJhKTx0NqAlOJKd82EhvBgEXidZnEEGg9UQiqHP4KuLIauPYfcHc30OULoMVbJROTpuYSIA/IzijU9F4TQoiw4unQV8I2K5NlXws6y7k+8MY+YNUgIOUhsKwXMGab0JyeEEKIfmGTXcUTXwXZgKGppveIEEKIzmekVNNUs3tzoR8vK1OcdE9YFPbaFsCxTvW8HyHloEAKIWpMSIlV5OGPM7Mq/XwWbDGTmsHayJoPKyOrkls2bIxsYG9iDwdTBziaOPJtqVgKrWTuAAxcAjQdB+z5FIi9BuydCtzYKNzvEABzG2MgCcjJ0edUHkKI1jgyB8hLB5waAK3egc6z8xOCKf8OEi5C2IoudhHi2ljTe0YIIUStSn3WLswG4KDJnSGEEKLLlArVNZt/FocA4M0DwL9DgKQQYHlv4PUdgHOD6ntPQkqhQAohaqAsukhht5aGlmjg0AByhRwKpQJypXBbKC9Eriy3ZOTIcpAvF0pcse9nFmTyEZlZsfRFW2NbOJo6wsHEgd+6W7jz4WHuwW/Zfmg0y8WjhdA/hZXLOfgVEHUB+L090GkqzOybAfeB3EIdLJ1DCKlZWLD30gphu8/3ulnSqzxWbkKZr9VDgdirwMr+wOhNgGcrTe8ZIYQQdfVEKZ70YgqopC4hhBAVZKRUR2mv0qzchUVhq4cAMVeAlQOAsdsBl4bV+76kRFBQEBo3boxffvkF+oYCKYSog/JxwKK1S2v8FPRThZ7Ggi158jzkFOYgszAT6fnpSMtLQ1p+Gt9OzU8VbvNSkZSXhMScRCTmJkKmkCElL4WPu7hb7mtbSC14QMXVzBUFuQVQhCkQYBcAHysfXk5MLdiEJCvp5d8L2PUxcP8AcGQuLAp7A5iAPKWxevaDEEKeNcm0d5qwYpeVJfRqixrFzB54fSewdpTQgJ4FVcZsFQLdhBBC9GPCqxgr7UUIIYRUlUIm3Kpj4ZmprVCemAVTWM+UVcXBlEbV/94EW7ZsgVSqpVVwqhkFUghRI5aR4mnpWeHHsz4qZiIzXtbLoYKp9ix7hQVaWFAlISeBB1Zis2MRnRmNqKwoRGVG8ftYYOZOyh0+mJNnT/JbAxjwAIuflR9q2dRCoG0g6tnX4wGXastgYSsKXt0AXN8A7JsGy+xr/O58iQUUBQUQGRpWz/sSQsjz3NkBRJwFpKZA99mokYwthUyU/0YA4SeFixF2UeLeTNN7RgghpDoV90YpU9qLEEII0cJm8+UxsRYWgbEyX9EXH2emULniamdrawt9RYEUQtS0qJkzUMLTouKBlKpg/VRYWS82AmwDyn0MKx0WkxWD6KxohKeF48SNE5BZy/Aw/SHPcmHlw9g4FnWs5DmsJ0s9u3qoa1cXTRyboLFjY1gYWqhux1mQptFIwK8LLP7sDWQCcrERcmMSYebtprr3IYSQiq7UPfqtsN3mAyHgW1Ox5sKvrgfWjAAenRIaOI7dBrg11fSeEUIIqe6Vw8UoI4UQQohKms2rsRSysZUQTGGZ9VHnhUVh4/cBDv7QRUqlks/XqZJCoeCvKSmUQPSM/jWsKk1lFk4HlSrtlZ+fjy+++AJr165FWloa6tevj/nz5/PHFDt16hSmT5+Oixcvwt7eHoMHD8a8efNgZmbGv1+R19AWFEghRK19HJU820PT2B9JP2s/Pto4tYFVqBX6dOvDU/OSc5N5QOVB2gPcS72H28m3+S3Lcjkdc5qP4oBNgE0Amjk1Q3On5mju3Jw3vn9p5g4wdK4Fye1syCRmyAiPp0AKIUT9bm4GEu8CxtZAm/dR4xmaFQVThgMRZ4RG9GN30IouQgjRm9Je1COFEEKICjJS1N1TkmXYv7ZZKO/Feqaw65g39gPWHtA1LODR6j/196w89+o5mLIqDFXwwQcf4Pbt21i3bh1cXV2xdetW9OrVCzdu3EDt2rURGhrKv547dy6WLVuGxMRE/hw2li9fXqHX0Cblh6IIISqleBxJqfaMlJdlZ2KHFs4t8EqdV/Blmy+xvt96/kd1Xd91mNl6Jgb6DYSHhQcvIcbKgq2+sxqTj01Gp/Wd8Pre1/H3jb8RkhLCI+lVZu4AY1k638yMTlHdwRGdt3TpUjRs2BCWlpZ8tGnTBnv37i35PluxwFZSlB4TJ07U6D4THSQvfJyN0u5DIW1cHxiZA6M3AB6tgbx0YNVAIPa6pveKEEKIOkp7FWRpak8IIYTUBAqFekt7PVWueDNg7w9kRAsZ9tlJ6t8PPRMREcGDIRs3bkSHDh3g5+eHzz77DO3bty8JkrDMk9GjR2Py5Mk8KNK2bVssWrQIq1atQl5eXoVeQ5tQRgohalBQfEKBEg6mFet1ok0MxYa8TwobIwJG8Pvis+NxOeEyLsVfwvm48whLD+Nfs7Hw8kI4mTqhs0dn9PbpzcuAsQyWCjNzhLEiFVlwRVZiZvUdGNE57u7u+O677/gJmAXrVq5ciYEDB+LKlSuoV68ef8zbb7+N2bMf97MwNa3aygqix67+B6SGAab2QMt3oFeMLIDRG8umx7MVXXZ+mt4zQggh1ZmRUkgZKYQQQnQwI6WYmZ1Q5uufnkDyfeF65vWdgNgEuoJVj2ELmVVd2iszMxMWFhbPLe1VFTdu3IBcLoe/f9lSaqxUl52dHd++du0arl+/jjVr1pR8n83lsP0KCwvDw4cPX/ga2oQCKYSoQV7RCcXQQFS5gIIWczJz4kESNhjWb+VU1CmcjD6Jc7HnEJ8Tj3Uh6/hgQZVe3r34Y1mPlRfWXjR3hJkyHmz9QOi5KNj9/Dvcxg6DxN5ePQdHtFb//v3LfP3NN9/wLJXg4OCSQAoLnDg7O1f4NdkJmo1iGRkZ/LawsJCPyih+fGWfV1PUiONXyCA58SPYXyl524+gEBmxA9Kf42fYxcbIdZCsHgiD+BtQrhoI2dg9gKWLfhx/Fen78ev7sROi+6W9qEcKIYQQFfTe0kRGSjHW15L1elzWC4i9CmwcB4x4PIGv7dhcWVVLbD0LC1jIJDL+us8KpFRVVlYWxGIxLl26xG9LMzc3L3nMO++8gw8//PCp53t6evIgy4teQ5tQIIUQNSgoCqRIK9G8Sde4mbthZJ2RfOTJ8niWyoHwAzgccZgHVVbeXsmHt6U3hvkPwwC/AbAxtin/xcwc4GxxCo8U7ZFgVQ+778rh+M4K1PGVofbE4TDyo5XRBHzVAkv/zM7O5iW+irGVDqtXr+bBFBZ4mTlz5nOzUliq6ddff/3U/QcOHKhyNsvBgwehz3T5+N1SzqJ5egTyJRY4mOgM+Z49enX8pRk6vIMOaXNgnh6J3L964VTtL1AoMdeb468qfT9+QoiulvaiQAohhBAdazZfHvvawGubgOV9gNDDEB2cAaCjZvephmrSpAmfl0lISOBlucrTtGlT3v+kVq1aVX4NbUKBFELUQMHahRgAYr7GueYzlhijo3tHPmbKZ+JU9CnsC9uHY5HHEJ4Rjh8v/sjLf3Xz7MYDL00dm5bNUjF3RDOHHbCWGOBK3lgkJIsR79AU8ZnAlZnHEWC/GQ3eGwiTOgGaPEyiISx9lAVOWD1NtkKBNSKrW7cu/96rr74KLy8v3qCMrWyYNm0aQkJCsGXLlme+3vTp0/HJJ5+UyUjx8PBAjx49eB+Wyq7GZpOo3bt3h1Qqhb7R+eNXKiH5+3u+KWn7Pnp2GKxfx1+etLZQruwDy6xo9EpZBvmrm4XG9Ppy/JWg78df/DPYvn27pneDEFKZlcPFoi8BqY8AGy9N7REhhJCaEKDXZEZKMdcmwJA/gfVjIL74N3zcWQWKPpreqxrH39+f9z8ZO3YsfvrpJx4UYc3kDx8+zHvb9u3bl8/JtG7dmjeUf+utt2BmZsYDK+y6afHixRV6DZ0NpLBVu2wy6u7duzAxMeENYubPn4+AAGEyMyUlBV9++SVfxcuaxTg4OGDQoEGYM2cOrKysnvm648aN43XuS+vZsyf27dtX1eMiRCu9RPt1nWUkNkJXz658ZBdmY2/YXmy6twm3km9hb/hePurb1cfr9V5HN69ukIgkvEcKi6vUkhxDrW9WITEiE1c2X0NoSC4yLL1xocAbt7+5gDqWW9Hoo6Ew8a+t6cMkasTOOVevXkV6ejo2bdqE119/HcePH+fBlAkTJpQ8rkGDBnBxcUHXrl0RGhrKm5aVx8jIiI8nsYnQqk6GvsxzawKdPf4Hh4GEm4DUFOLW70BM//6Ag19Jerwo+iJE298BRv333JVmNer4q0Dfj58QoqOlvcJPAgsbAX5dgGbjgIA+gJjWXRJCCKmg4t7Ams5IKRbYH+j2FXDoSzSIWg15aD+gTi9N71WNs3z5csydOxeffvopoqOjYW9vzwMn/fr1499nwRA2X/PFF1/wjBPWH4XNzYwcObLCr6FNKvXJiB34+++/jxYtWkAmk+Hzzz/nK3ZZJIlFlGJiYvj48ccf+YTWo0ePMHHiRH4fm+x6nl69evEfXLHyJrUI0V1F2RYG+hhKecxMasbLerFxO/k2NoRswM7QnbiZfBNTTkyBq5krD6gM9egC/hcgPx0ozIODpwV6fNweORkFPKBy81wKss1ccUnuijtzL6Ke0140/nQEDCvRF4PoLkNDw5K00GbNmuHChQtYuHAh/vjjj6ce26pVK3774MGDZwZSCClxeqFw2/R1wNRW03ujPRwDhQb0K/sD9/YB+/4H9P6eFfHV9J4RQgipKmXRhJehBTBoCXBxOfDwKC+Dwoe1F9DmA6DJ6GdmIhJCCCFa02y+PO0+giIhBKLr/0G85U3grcOAYx1N75XOO3bsWMk2W0DGSqWXVy69GIsjsKSLZ6nIa+hkIOXJDJEVK1bA0dGRN4Tp2LEj6tevj82bN5d8n01asUbAr732Gg+8SCTPfjsWOKlMc2BCdImyqLQXeYw1nf+q7VeY1GQS1oesx7q76xCTHYN55+fh7xt/420ra4xKT4NBTpLQMIw1Ebc0RLvxLdB8ZCGubL6O66cTkWPqhAuZTrj72T40DSxE3cmvQmRGF3v6hDVPK90svjSWucKwzBRCnivmKhB2XEhFb/OepvdG+3i0BAb/AWx8HTj/J2DjQz8nQgipCaW9WNZJ3YHCSHkIXP4XuLwSSHsE7J0CHPsWaDkBaDWRFhkQQgh5caajNpT2KmZgAHmfH5Hy8BLss0KADWOBt48ARtrXxJzohpfK1WVlVRhbW9vnPobVmH9eEKU4msWCMjY2NujSpQtP6bGzsyv3sWzCrPSkGatnX1yXmY3KKn5OVZ5bE9Dxq+/4DaDQup+zpv/9LSWWeLve2xgTMAY7w3Zi+a3liMuJw7e2lgjMy0H9tBgoTZ3KPEckBZqNaogGA2W4vPYSbl3OQqa5J45HAjffWYPWfd3gOrR72b4rWnr8mqZrx836mfTu3Ruenp7IzMzEf//9x88f+/fv5+W72Nd9+vTh5w/WI+Xjjz/mgX6WTkrIc50rymiqPwSw9tT03mineoOAtDnAwZnA/s+Fn1Og9qVbE0IIqeKEl60v0O1LoOMU4Ooa4OxiIDUcOD4fCF4KtHkfaP0eYFy5HnKEEEL0gDZmpDBiQ1zwnoRe4XNhkBQC7PwIGPo3ZdcT9QZS2ArgyZMno127djwTpTxJSUm8P0rpmvXPKus1ZMgQ+Pj48IkwVjKMTZSdPXsWYrG43F4t5aX7sDQhU1PTqh4Sb3Sjz+j4q+/4ZTI5YAjI5Qrs2bMH2kgb/v3NYIaJ0on4W/w3ouRRiJRKkHd8L+KtYp/9JGfAsQuQeyEF6ZkOSDavhT1HZXDeuQBGHWwhc3XUmeMnL5aQkMCbkMXGxvLeWyxAwoIorLlzZGQkDh06hF9++QXZ2dm8YfzQoUMxY8YMTe820XY5KcDNoozalu9oem+0W9tJQGoYcHEZsPkt4I19gGtjTe8VIYQQVU54GZoCLd8Gmr8B3NkBHP8BSLgFHJsHnPsdaPuhkKVCK3oJIYQ8memoTRkpRQqklpAP+QeSfwcANzcBXm2AFm9pereIPgVSWK+Umzdv4tSpU+V+n2WJ9O3bl/dK+eqrr577WqNGjSrTHJhNjLGyYGyVMWsSXN6K5E8++aTMe7EJM9avhWW/VGVFNptEZRNx+tgclI6/+o9/w64b/FYsEfHV8tpEG//9L529hKiwKMSJJegd6AVl4wr8zIYAqVFpOLXkNGKzLBFr2QJG59PQyDMRDT4ZDvEzgqzaePzqxI5/+/bt0BX//PPPM7/HzgOslxchlXZlNSDPB5wbAu7NNb032o2t3Or9A5AWATw4BKx/DZhwDDCz1/SeEUIIqcqEl+g5UwIsyFJvMBA4ELi9TQikJN0DDn8NnF0CBP0PaDaemtITvXfixAn88MMPvOw9W/C1detWDBo0qNzHsj7CrLfjggUL+OJkQmpcpqNIBG2k9GgFdJ8NHPgC2DcdcG0CuDXT9G4RHVOlTzwffPABdu3axU8W7u5C74LSWLkVlmViYWHBTyCVnZz09fWFvb09bw5cXiCF9VMprxk9e5+XmQh92efrOjp+NRy/gfA+2kib/v1dLIR+FnESMSRRwUDjkYDU5IXPc/RxwJAfB+H+0bs4tf4+coyscT7eGg8mbUKHIT5wH9RFJ46fEKJGCgVwsShAx1bfUor3i7EJs6H/AH91AVJCgY3jgDFbNb1XhBBCKnv+q+jKYTYpxkpfsj4qNzYCx74TshP3fAac/wvoMReo3Z3OoURvsWz4Ro0a4Y033uDVVp6FzY8FBwfD1dVVrftHiFooK3Fe0RRWojLiLHB3F7BhHDDxBGBio+m9IjqkUmFCpVLJgyjsj/+RI0d4Ka4nsewQlhliaGiIHTt2wNjYuNI7FRUVheTkZGoOTGoO1myeVJizmTO/jWO9la6tBRY2Ela9FeRU6Pm1O9fBmEV90KgeIFIUIsXUBzv3FOLIe4uQHxldzXtPCNEpoYeF+u/GVkD9YZreG91hYg2M+g8wNAfCTwIHZmp6jwghhFSptFclpgRYhkqjUcAHF4A+PwKmdgCrN//fcODfwUD8rWrbXUK0GStNz/r8Dh48+JmPiY6OxqRJk7BmzRpawEdqeEaKFmcpsoD/oN8AGx8gPQLY9Qmb7Nb0XhEdIqlsOS/WyJeVgWHZJnFxcfx+VqfexMSkJIiSk5OD1atX86+LG8E7ODiU9DupU6cO73PCTjJZWVm83wmrY+/s7Mx7pEydOhW1atVCz549q+OYCdGA4tVZ9Ae6IpxNiwIpNh5AnolwgmONjU/9ArT7UKjXbGj23NeQGIrRflIX1I9MwaEFxxGfY4U7ivqI+OI46vgbwLtrAzg2C3j8T0MI0U8X/hZuG78m1IQnFedYBxj8B7B+NHBuKQycGgCgevmEEFJjSns9i1gqZHE2GA6c/Enom/LwKPB7e6HUV9eZtMKXkCd6DI8ZMwZTpkxBvXr1KvSc/Px8PooVz62x0sxsVEbx4yv7vJqCjl89xy+SF4LN+sqVgEKLftZPHb/YFAaD/oB4RW8Y3NoCWa3uUNYfrpH9YgkL7O8DG9WFvUfxbXW+jzZgx8eOk/1si2MQqv69r9SnpqVLl/LboKCgMvcvX74c48aNw+XLl3Hu3Dl+HwuElBYWFgZvb2++HRISgvT0dL7NDuz69etYuXIl0tLSeIojC8awJvXlle8iRJdRtnslM1KUBcCkS0JWyskfhZr8B2YApxcC7T4CWrwNSJ+f9WbtYYuhPw3Cze1XcXZvHLJNnXEpCri0MgHifyJgpUyBRJSGm1F74d7aH3aNakHEMmEIITVfejRwb7+w3eJNTe+NbgrsB3SaBhyfD/Huj2FZmzJTCCFEp1YOv0wJFpad2GOOcA49+KXQR4WVy7y9XahD3+gVra2VT4g6zZ8/HxKJBB9++GGFn8MWH7NFx086cOAATJ/R//NFWG9QfUbHX73H3zAiDKxu0b0HD3Evew+0/fj9nQchMHYzlDs/wdH7Ocg1clDr/rC/CSyhgCUYFBQUVPv7sTYcNV1BQQFyc3N5KxKZrGjBiIpJqhLFehYWYHnRY558HZbJsn9/0SQGIYSUCqRkFGQgRymDabPXgcavAtfWASdYk+NHQkAleCkQNF24SHtOk0sDAwM0GNQEtbrl48qfhxF+JwPpsIZcYowUsPq0rki4AeBGDKSy+7BGGuzsDOBYyw5urf1hXc8HIroIJKTmYUFalino1Q6w89P03uiuTv8DYq7A4P4BNA9jZRjHAFJrTe8VIYSQCpX2UkEtextvYMRKIOwEsPszodzX9veAy6uAvj8CzixjkRD9xBrQL1y4kC88ZtelFTV9+nR88sknZTJSPDw8+MJjS0vLSu0DW5HNJpG7d++ul2XF6PjVc/zi3QeAZMA/oA5qte8DrT9+RQ8o/o2ENOo8umVthnzQNsBAffM+eXl5iIyMhLm5eZXaYlQUm4NnQRRWWaoyf4N0UV5eHo8zdOzYseRnyv79WWUtVaFl14SogVJZs/9YqZqFoQXMpGbILsxGXE4cfK18hRICTccIdZlZQIU1ucyIAnZ8AJxZBHSZCQT2f27aj4m5Edp+0gdtWbppoQzxl0MRff4BHt6IRKHSGhkGtiiUmCERZkhMB+5eYp98H8Gw8CasRemwsTGAvZcNnBt5wr55ACTGlDVHiM5iizqurhG2G4/W9N7oNhZoHvQ7lEvbwiIrFooDnwODf9P0XhFCCKlQaS8VNgX26QhMPMXLPeLYfCAyGPijE9D6XaDzF1RCk+ilkydPIiEhAZ6eniX3yeVyfPrpp/jll18QHh5e7vNYhZbyqrSwieCqToa/zHNrAjr+6j5+YdG8WCKFWAt/zk8fvxQY8iewtB1EEWcguvYv0OItte0P+zvAAhts0W51LtwtLudV/F7V7dixY+jcuTNSU1NhbW2NFStWYPLkybwKVXVjx8eOszp/1ymQQgjR2j4poemhiMsuCqQUKw6osJrMrLcBK/mVdA/YMAZwawZ0+0q4iHsBsVQC11YBcGjqi5g9ezCkTx8YKIC48yGIvfwICY/SkZIhQabYBgVSCyTAAgkZQAjPXEmCaGUMLOQpsDYrhJ2zCRwCnOHS0h9mnkI2DSFEy0UEAykPAakZUHegpvdG95nZQT7od4hXD4bo2hqgVhegwTBN7xUhhJBnKa6T/jKlvcojMRRK8NYfBuyfLpT5OrsYuLsbGPAr4NNBte9HiJZjvVG6detW5j7WD5jdP378eI3tFyHV12xexeeV6mTrA3T7Etg7VShRWbsnqw+v6b0iWowCKYSohZAlYWBAzeYrU96LBVLis+PLfwDrjdL2AyGocuZX4OwSIPoSsLI/4NcF6PY14NKwUu8pMZLCvUN9PooVZuchJvgu4m9EIikyC6kZBsiEFeRiI6SLnZFeCDyKBBApAw7dhnHBGViIsmBlCdg4m8LW1xGODb1g7ucOUVGzK0KIFri6WritNxgwogbpqqD0ao8Q54GoE7cN2DkZcGsK2JYKhBNCCKmZpb3KY+UGjFgl9CLb9TGQGgas7Ac0Gyf0TzG2qp73JUQDWI+DBw8elOkRfPXqVdja2vJMFDs7uzKPZyulWW+EgIAADewtIdV9XtGxqWbWe/fmFiGLcudHwGubqcExeSYd++0mRDdR+KTqfVKW3VyGQkUh+vn2g6m0nHIA7CKsywyg5QShf8rF5UDoESD0qFCuh33P0qXK+yE1M4ZX18Z8FFPIFUi5E4m4y6FIDE1GSmIh0gpMkCexQp6hNfJgjcQcAA/ZYAGWUEhkN2CuSIelqQzWdoawdrWElY8DbP09YObpBAPqwUKI+hRkA7e2CdtNqKyXKt1zHgh/aRxE7EJk05vAmweETEJCCCFaWtqrmqcE/HsC7wUDh74ELi4DLq0A7h0A+i8E/HtU73sToiYXL17kpWyKFfc2ef3113lZG0L0KiNF1ZmO1Y3NxQxczEt8IfQwcH0D0GikRnaF9TNR5uaqvLSXIjcXColEONZyGJiYVKp/Sn5+PqZMmYJ169bx/k3NmzfHggUL0KJFixc+NzQ0lP+NDA4ORnZ2NgIDAzFv3rynMve0FQVSCFFjJIVapVRcd6/u2P1wN8IzwjEneA4WXFqAAX4DMLLOyLKlvoqZOwJ9fgBavwccng3c2iKsOGe3rLxA20mAoZlK9k0kFsG+vhcfpeWmZCLuwn0kP4hDalQm0tPkyCg0Rq7YEjKJKdJgijQZEMGSbNi4kgXgDiSySzBVZMJMWgBzcxEs7Ixgbm8Oc2drWHo6wMLHGYZWFirZd0IIgNs7gIIswMYH8Gyj6b2pUZQGYsgH/QHRX52AmMvAqQVAp6ma3i1CCCGanPAytgT6LQDqDwV2TBJKa/43XFgF3GMOIDWp/n0gpBoFBQXxCdCKelZfFEJ0WnVnOlYn+9pA0DRhLunAF8IiABNrte8GC6KENG1WLa/9jFovXMDlSzAwrXgfs6lTp2Lz5s1YuXIlvLy88P333/OShaUz856XwdenTx988803vA/UqlWr0L9/f4SEhJTpJaWtKJBCiBpRHKXi2rm1w6Hhh7D9wXasD1mPiMwI/Hf3Pz7aubbDuPrj0Mq51dNRc1bjcvhyIaCy/3Mg6jxwbJ6w+o01pG/0yjOj8C/LxNYCPj2bwqdn2fsLc/KReCMMSXdikBqRgrSkAmTliZGjMEWBxIwHWTLABoDsohHBvshjNcMA5SMYyrJhpMyBibgQRlIljI0BIzMJjM0NYWJlAhMbM5jaW8ChRSAMLVUTMCKkxrqxQbht/CqlbVcHSzchsL3lbeD4fMC/V6VLLRJCCKmBE17e7YGJp4WJKtaQ/sJfQNgJYOjfdJ4ghJAaE6DX0WobbSYB19YJPXiPfiNcz5CnZGdnY+nSpTzbrnfv3vy+v/76CwcPHsQ///zzwqyURo0a8VFszpw52Lp1K3bs2IEPPvgA2o4CKYSoRdFEHc3XVYqVkRXG1huL1+q+huCYYKwLWYfjUcdxOuY0H4G2gRhffzzPXpE8WZbAo4VQUubWVqGUQFoEsP094aKN1WX26aS2C0epqRFcW9Xh40kFWXlIuReFtAdxSItKRUZCDrKz5MgpECNPYYR8kSmUIglveF8AC2SyJ7HeoDlFI7H4ldgKqAwMMgqDW/vHPV4IIU/ISgQeHhe22cpYUj0aDBcaDN/dBWx7F3j7qNCAmBBCiH5PeBmaAr2/A2p3F84PSSHAX12ArrOANh9U24InQggh1UwXm82Xxq5V+vwIrBoAXPhbWHTn2kStu8BKbLHsEFWX9srIzISlhQVEzyntVVGhoaEoLCxEu3btyvR9atmyJe7cufPCQArLSPnqq6+we/duxMbGQiaTITc3FxERfDWx1qNACiFqZEDdUqpEZCBCW7e2fERmRuLf2/9i6/2tuJNyB1NPTIWbuRvG1B2DwbUGl+2jwlaa1x8CBPQBzv8BnPgRiLsB/DsYMLbmq+JE7q1gm5UHFHQCpOpP3TQ0N4Zz01p8lEepUCInMR0Z4fHIiEpGZlw68tLzkJddiLwcOfILlMgvFKFAIUEhjGDmZKP2YyBEp9zeJqzCZR+K7fw0vTc1F/v72+8XIOIsEH8TOPkj0PlzTe8VIYSQpya8NDQlUKsr8O5ZodRXyG7g4EyhNv3QfwAze83sEyGEkJfPdNS1Himl+XYC6g8Dbm4Cdn8KvHlIrQF+VnGlMiW2KkShgEgmg8jU9JmBFHX67LPPePbKjz/+iFq1asHExATDhg1DQUEBdAEFUghRh+LmKJSR8tI8LDzweavP8V6j93iGytq7axGdFY3vzn+HpdeWYly9cXilziswk5YqbyU1FvqksObzrMwMS9fMS+MrpcV3d6ED+yf6cR7gEAi4NQFcmwJuTQHHehpfQW0gMoCZkzUfLq00uiuE1Aw3Nwu37AMyqV7mDsKqrk3jgZM/Cz9zB39N7xUhhBBtqWVvZgeMWgNcXgnsmw48PAb80REYsQpwelz2gxBCiA7QdIBeVXp+A9zbB0RfEgIqDUdoeo+0ip+fHwwNDXH69GneH4VhGSoXLlzA5MmTX/h89rxx48Zh8ODBJRkqutQ3SvOhKEIIqQJrY2tMbDQR+4fux8zWM+Fp4Yn0/HQsvLwQPTf3xJ/X/0QWayZdGlvdxupcTg0TVhZ0mQlF7V7Ik1jDQKkAEm4BV1YDuz8B/gwC5rkBf3YWViJcWQMk3Hn84YAQonvSo4QMCRbVrid8cCPVjP2ca/cEFIXArsl8RRQhhBAtoJBpx8phlsHYbBzw9hHArjaQEQ0s6wXRxWVAJZp3E0II0TBtCNCrgoUz0OETYfvQV0ABq6lOipmZmeHdd9/FlClTsG/fPty+fRtvv/02cnJy8Oabb77w+bVr18aWLVtw9epVXLt2Da+++iovP6YrdDxMSIhueHwJQBcDqmYsMcaIgBEYWnso9obvxR/X/kB4Rjh+vfIrVt5aibF1x2J04GiYG5o/fpJYIvRQ8WgBeWEh9u/Zgz7tm0CacB2IuQLEXAaiLwtZK2ybjWLsdZzqAU71AecGwnAMBAypwTshWu/mFuHWqy1g5abpvdEPbIKMBbB/Owk8Og1cXQM0HaPpvSKEEKJttezZ52kWTNn+PnBnB8T7p6KJbXtA1o0VX9f03hFCCKnpzeZLa/0ecHE5kB4JBC8BOk7R9B5ple+++44HP8aMGYPMzEw0b94c+/fvh43Ni0vN//zzz3jjjTfQtm1b2NvbY9q0acjIyICuoEAKIWpBpb2qm1gkRj/ffujt3Rv7wvfh92u/84DK4quLser2Kt5DhQVULAwtyn8BSxfAzhMI7Cd8zVbApYYJARUeXGHjKusOD0SeE0YJA6HXAg+u1AecWHClDmDlSQ0zCdEmLDWboSbz6mXjBQRNF+rfH5gh9K1i5VwIIYRoDsvG1qZACmNsKZT1OrsEyoOz4JlyCoq1w4BR/wGmtpreO0IIIbp2XqkqqQnQ7Stg85vAyQVAkzFCpgrhjI2NsWjRIj6eFBQUBGWpjFJWxouNYt7e3jhy5EiZ57z//vvQFRRIIUQthAgKxVHUE1Dp69sXvbx7YX/4fvxx/Q88TH+IJVeX8Cb14+uPx6t1Xi3blP5Zq6htfYXRYNjjFRZJ94WG9fE3gLibQhPlrHgg+YEwWCPrYhITwL4WYO8P2AcA9rUBhwDA1k/o20IIUZ+Uh0DsNaGESd2Bmt4b/cNWdV1fL/zNPPoN0O9nTe8RIYToN20p7VXeZ/C2H0Bu5w/l+rGQspKcf3cFXt0ofK4mhBCi5RkpWnZeqSq2+C54KRB9ETg2D+i/UNN7RLQABVII0UDPeaKegEof3z7o6d0TBx8d5I3oWUCF9VBhJb/Y/S2cWyDAKqBMtPy52MoKlmnCBoY/vj8roSi4crMouHILSL4PyHKF+9kojaW6WnsBtj6AjbewzVZsF2+b2AgXkYQQ1bmzS7j1bi/0SyLqxUoq9p4PrOgLXFoONB8vlEYkhBCiGVreFFjp2xkn/Weic+xSGLDFECyY8spaoTwnIYQQ7Q3Q14SMFIbNyfSYAyzvDVz+F2j7oVCJhOg17fzUREhNUzRPT1Pjmgmo9PLphe5e3XkPlaVXlyIiMwLrQ9bzwZgYmGD3kd1o4NAA9ezqoZ59PTiZOsGgosEMc0egVldhlL44TQ0Hku4JI5Hdhgi3+elC2TA2ymNkBVh7CqmjfLgAFk5Ft86AORuOgJjqRRNSYXd2CreB/TW9J/qLBbHqDhIy9/ZNB17fSUFjQgjRFB1oCpxp4g7ZuP2QbhorrAj+dwgwajVQq5umd40QQsizzis1JSOFYcH7Wt2BBweB4/OBIX9qeo+IhlEghRC1oB4p2tJDhZX8Ohd7Dkcjj+Jm0k2EpIYgV5GL4LhgPorZGtuWBFXYbV27unA0daz4G7KLUrZagY2A3o/vZ9kvLIOFBVdYoCXtkXCb+kjYZmXCWKCFlQ5j43lYvxdTG8DEVqgbzW67zhKyWwghj2XEAlHnhe06RX2QiGawVV339gHhJ4Hb24F6gzS9R4QQop+0tbTXk9jioXG7gA1jgfsHgLWvAMOWP+5rSAghRDtoeaZjlbFejyyQcnsH0PdnwMhc03tENKiG/XYTop0qWDiKqIFEJEE7t3Z8MNl52Vi5eyVsAm0QkhaCW8m3cD/1PlLyUnAy+iQfxRxMHOBv6w9/G38E2ATwW28rb0hFlcgMYauveXaJE+DT4envF+QAaRHCyIoDMuOBzFggM67o66LBVnsUZAqDPbZY589f7gdESE0Uslu4dW8BWLpoem/0G8u2a/eRsKLr0FdC43mJoab3ihBC9I9CAUWhAQpis2GkVFY8E1tTTX9HrgG2vCUE4VlQZfDvQMMRmt4zQgghTzWbF6FGcWsK2PgIFUXu7xd6pxC9RYEUQtSCMlK0laHYEG4SN/Sp3QdSqRAQyZPl4V7qPR5UuZV0i9+y/iqJuYlIjE7E6ejTZQIzflZ+CLAVAiu1bWrzWztju6pdkBqalurD8gwKBZCXBuSkALkpZW/Nnar0cyCkRqOyXtqFBVIuLhcuRi6vBFq+rek9IoQQ/aOUI/ywPfLTzsE94CgsunSBVmNB96HLAOkk4Np/wJYJQlZN41c1vWeEEEJqYrP5Ymxep95g4NTPwK2tFEjRcxRIIUSNtHmhF3nMWGKMhg4N+SiWU5jDgytPjuzCbF4ejI3SrIys4G3pDR8rHz6Kt90t3CuXwVIetsKDlfJigxDyfCzAGFaUWUZlvbSDoRnQaSqw5zPg+PdAo1coRZ4QQtRNIUN+mvCZNG3zFu0PpDBiCTBwibDw6MLfwPb3hWwVNsFFCCFEs3Sg91aVFQdS7h8E8jMBIwtN7xHREAqkEKIWFEHRdaZSUzR2bMxHMaVSiZjsGISkhJQEVlhZsEcZj5Cen45ridf4KE1iIOHBFFYSzMPCA27mbny4mrvC3dydvw8hRIXu7Rc+1DvWE3oWEe3Q9HXg7GKhR9S5pUDHKZreI0II0c+Vw+wzbW4OdAZbUNTnR0BeAFxeBWx+C2Cfn/17anrPCCFEv+lK762qcG4A2PoBKaHC9WWDYZreI6IhFEghhJAqYqW7igMhXTwfr+LLleUiIiMCYRlhCEsXRnh6OMIzwvn32C0b5bE2si4JrNib2PO+LOyWNbrnX5s68MeIDGpY3VFCqsvdXcItNaXVvhItXWYCm98ETi8Cmr9JWXaEEKKJlcNs7isnFzqX5t/vF6AwF7ixUeiZ8vpOwKOlpveMEEL0llIuQ9INCyiXbYbVGAcY1aqFGlfe6+SPQnkvCqToLQqkEKLGjBQq7aUfTCQmvGcKG6WxDJb4nHghsJIRjujMaJ7REpUZxW9ZFktafhofrC/Ls7CsFhtjG14+jA9DK1gbW/Pb0YGj4WRGfVII4WT5QOhRYTugt6b3hjyp3hDg9C9A3A3g7BKg60xN7xEhhOhlRooiV8cCKcWlYwYtFUqs3NsH/DcSeOsQZZ8SQoiGyLIUSLplAdzajeT1u2HcqCGshwyFZZ/eEFvUgFJYxYEUKu+l1yiQQogaKKnZPCnKYHE2c+ajjWubp76fVZCF6KxoPmKzY5GUm4TEnEThNle4TclLgUwpExrf5yY+9RqDag9S09EQogPCTwGF2YC5M+DcSNN7Q8orz9JpGrD+NeD8n0DbDwATG03vFSGE6F8gJU8HAymMWAoMWwas6AvEXAFWDxWCKWb2mt4zQgjRO8pCBUpWEItEyLt2HXHXriN+3jxY9uwB65GjYNKkMZ8X0UlOrFR0LSD5ARCyD2g4XNN7pFUMDAywdetWDBpUs+ekKJBCCCFawtzQvNxMltIKFYVIzk1Gal4q0guEDJaM/Ax+yzJaWCkwQkgRVr+W8e8hTNoT7RPQF3CsCyTcBs79AQT9T9N7RAghelfaS6lrpb1KMzQDXlkP/NMNSA0TynyN3S4EWQghhKiNUs7OK2KILczgu2cv0nfsRNqWzSh4EIr07Tv4MAoIgM2okbDsPwBiczPoZHmvEz8I5b0okFKioKAA+oJmFQhRB6Vwo6uBd6I9pCIpz2gJtAtEa5fW6OXdCyMCRmBCwwmY0mIKLAwpvZQQTqkUSn0w/r00vTfkWViAq7jRfPBvQF6GpveIEEL0MCMlDzrNwgkYvQlgn4MfnQb2f67pPSKEEL2jlBdlpIjFkNjbw+6N8fDduRPe69fBasgQGBgZIT8kBHFfz8aDjh0R+9VXyAsJgU5hgRTmwcFquW5h5eAL8+UqH7KC53+fvW9lBAUF4YMPPsDkyZNhb28PIyMjfv/gwYN5Zoq3t3fJY7dv346mTZvC2NgYvr6++PrrryGTyaCrKCOFELWg0l6EqMLSpUv5CA8P51/Xq1cPs2bNQu/eQv+LvLw8fPrpp1i3bh3y8/PRs2dP/Pbbb3Byor4xeifpHpD2CBAbAT6dNL035HnqDgTs/YV/M1biq+Nnmt4jQgip+RQyxDs2Q6xza9S7vxo6zyEAGPInsO4V4Vzi0hhoMlrTe0UIIXoWoJfCQCwuuYtNqps0asSH07SpSN++Halr16EgLAxp69bzYdK4MWxeGQWLXr0gKpqQ11osk774uiVkL9BopEpfXlagwJ8fHYe6TVjYCVKjx/9uFbFy5Uq8++67OH36NNLS0tC6dWssX74cvXr1grjod+DkyZMYO3YsFi1ahA4dOiA0NBQTJkzg3/vyyy+hiygjhRBCiM5wd3fHd999h0uXLuHixYvo0qULBg4ciFu3bvHvf/zxx9i5cyc2btyI48ePIyYmBkOGDNH0bhNNKM5G8ekAGJlrem/IixoGl2SlLAUKdbjEDCGE6AqlHLfqvoEU27oI9eiDGqFOH6BTUYnIXR8Dsdc0vUeEEKJ/GSnPKKkstrKC7dix8N2zG54rVvDACSQS5F69iphp/8ODTkGI//4HFDx6BK0v78Xc3g59Vrt2bXz//fcICAhAq1at+H3W1tZwdnaGg4NQcp5ln/zvf//D66+/zrNRunfvjjlz5uCPP/6ArqKMFELUQkhFodJehLyc/v37l/n6m2++4RkqwcHBPMjyzz//4L///uMBFoatiAgMDOTfZyskiD72R6GyXjqh3hDg8BwgPQK4thZo/oam94gQQmo2RdGEF8voNbJBjdFpGhB7VVhQsXE88M5xwIhK3xJCSLUrCqQYSJ4/1cyyVMxat+KjMCEB6Vu2IHXDBshiYpGybBkfZu3awebVV2AeFFQmw0Ur1OkHHJ8PhB4BCnIAQ1OVvbTEUMSzQ1RJoVAgMzMDFhaWED0jyMXet7KaNWv2wsdcu3aNZ6yweZticrmcVxLJycmBqanqfnbqQoEUQtSJAimEqAw7AbPMk+zsbLRp04ZnqRQWFqJbt24lj6lTpw48PT1x9uzZZwZSWAkwNoplZAi1TtlrsVEZxY+v7PNqCq05/txUSCKC+Z/cQp8ubIf06/g15GWPX9TyHYgPfgHlmV8hazgaMNCtxGl9//fX92MnROcoHtcnl7MymDUFmyQatBT4vT2QEgqc+RXoTD1TCCGkuimLAvSVCXxIHR1hP3Ei7N5+G1nHTyB1/TpknziJ7NOn+ZC4usBmxEhYDxvK+65oBecGgJUHkB4JPDwmZEOqCAsyVbbE1osoFAaQ5Iv56z4rkFIVZmZmL3xMVlYWz0opr0oI65miiyiQQohaUASFEFW5ceMGD5ywVQzm5ubYunUr6tati6tXr8LQ0JCnk5bG+qPExcU98/XmzZvHT+5POnDgQJVXSBw8eBD6TNPH75twAA2UcqQbe+DYmZsA2NCf49e0qh6/WO6AniJjSFMe4vTmpUg39YEu0vd/f13FykZOnz4dH330EX755Rd+H/XdIjWaslSzebEhahRTW6DnN8DGccCFf4D2HwNSE03vFSGE1PjSXhkWXhCbukCpUMJAVPF5MBZ8sejSmY+CqCikrVuHtE2beZZK4i+/IHHJElj26MGzVEyaNuUBB41h7x3QW+jHFbJbpYEUXSaVSvli19JYk/mQkBDUqlULNUWlAilssmnLli24e/cuTExM0LZtW8yfP5/XQytWlQsOpVLJm8z89ddfvEFNu3bteKkWVm+NkJpASc3mCVEZds5hQZP09HRs2rSJ19tk/VCqik2cffLJJ2UyUjw8PNCjRw9YWlpWejU2m0RltT/ZBwl9oxXHr1RAslRoXGceNAl9mvXRr+PXIFUcvzhvG3BvDzq4FEDRTrcuSvT937/4Z7B9u+7Vi75w4QKv1dywYcMy97O+W7t37+bZj1ZWVvjggw/4ijpWooCQmtEUWCAXG0JRUACRYQ0KqNTpD1h5CiUjr28Amr2u6T0ihJAaLV9ugotNP+NZ5bdnnEXtlk7wb+kEO9fK9as0dHeH42efwX7SJGTu24fU/9Yi99o1ZOzezYdRQABsXnkFVv37QVSBrIhqEdCnKJCyTzifsp6Pes7b2xuHDx/mc/pGRkawsbHBrFmz0K9fP14lZNiwYTwjhpX7unnzJubOnYsaH0hhE1Xvv/8+WrRoAZlMhs8//5xPNN2+fbskpacqFxysOc2iRYuwcuVK+Pj4YObMmTwAw15XV1N9CCmPRqPmhNQQLOukeEUDq8vJJsAWLlyIkSNHoqCggAfkS2elxMfH84Znz8JO8mw8iU2EVnUy9GWeWxNo9PjvHQBSwwAjK4ibjIZYA/tB//4vcfy1u/JAijjsOMRBU6GL9P3fX9ewkgOjR4/mC7pKX9CxYD313SL6VNpLkZ1dswIpYgnQ6h3gwBdA8G9A07HUsJIQQqqLUok8pVlJad7MlDxc3veIDzt3cwS0cubD1LLi5xmRkRGsBg7kI/fWLZ6lkr5zF/JDQhD31VdI+OEHWA0aBJtXRsFI3RkP3u359SZykoCoC4AnfS786aef+AJV9pnazc0N4eHhfG5/165dmD17Nk/EYNdIrPz6W2+9BV1VqUDKvn37yny9YsUKODo68rr0HTt2rNIFB8tGYenzM2bMwMCBA/l9q1at4hks27Ztw6hRo17uCAnRCtRsnpDqwpqnsQxIFlRhJ2a2CmLo0KH8eyyNNCIigpcCI3ri/B/CbdMxgFHlVj8RLeAnfH5E5DkgP5MaBJNqxxaJ9e3bl/fXKh1IqUrfLeq5pVr6/jOo7uMXy0sFUkSGKEhNg9LcvGYdf4NXIDn2LQwS70IWcgDK4nOMDqDff/08bkJ0lkIOhVLMp74kinx0mdAU987HI+JWMpKjsnAm6gGCt4bCu5E96rZzhUddW4gqUfrLpF49mMyZwzNV0rdt41kqBY8eIXXNGj5MW7aEzauvwqJrFxioY0GTWArU7g7c3ASE7NG7QMqxY8eeuq9///58PIkFU9ioKV6qRwoLnDC2trZVvuAICwvjtetLP4dlsrRq1Yo/p7xAiiovUoqfV/pW39Dxq+/4lVBq3c+Z/v3p+HUJK8PVu3dvfl7JzMzkgXt2Et+/fz8/d7z55pt8FQQ7L7GyXJMmTeJBFFo5rCeS7gMPDgnB6xa6u8pFr9n6AjY+QlZR+Cmh/jAh1YSVIr58+TLPbHwSuz6pbN8t6rlVPfT9Z1Bdx98qPrZMaa8T+/ch39UVNe3461u1g1/iAaTsno2ztfKga/T9958QoiOUcigUYkDE/pOjdnMnPvKyCvHgcgLunIlFQngGHl5J5MPcxgh12rggsK0LLO0r3sNKbGUF29dfh82YMcgJDkbq2rXIPHwEOefP8yFxcID1iBGwHjEc0uruacd6o7BAyt09QPfZ1fteRPcDKWwF8OTJk3nts/r161f5gqP4/id7qKj7IoXR9w8pdPzVd/xKpXCbnZ2NPXv2QBvRv79+H7+uSEhIwNixYxEbG8sDJ6yePQuisJ4EzIIFC3jdTZaRUrpPF9ET5/8Sbv17Aba62aicFGWlXPwHCD1CgRRSbSIjI3ljeXb+V1UpYeq5pVr6/jOo7uMXr10B3BO2lSIp2jZuDJPmzVHjjj+tHpS/HYJj5k30aVUbsNONPqz0+6+bPbcIgb5npPAlbUUTYACMzaWo39GNj+ToLNw+HYOQc3HISs3HxT3hfLjXsUFgOxf4NnaARFqxXiMGIhHM2rblozA2FmkbNyJ1w0bIEhORtGQJkv74A1b9+sHu7bcg8vSsnmOu1R0QSYHk+8KCPnvdOL8QDQVSWBo8aw5z6tQpqJsqL1IY+pBCx1/dx796izC5Z25ujj59tKt5Lv370/Hr0kUKKx/5PGwybMmSJXwQPVOQA1xbJ2y3mqDpvSGqCqQQUk1YJj0Lzjdt2rTkPrlcjhMnTmDx4sU8SF/ZvlvUc6t66PvPoPqOX1HmK4O8PK38Ob/08TvUAmr3BO7thfTqv0CvedAl+v77TwjREUo5lBCCIKJSgZTS7NzM0WGEP9oM9kPYtSTcOR2DyDupiLorDCNTCfxbOaNee1f+2IqSurjA4cMPYT9xIjIPHULKf/8h9+IlXgIsfft2mHXpAqPAOlA5Y0vAp4NwzXJ3N9B+surfg9SMQAprIM+axbALDXd395L72UVFZS84iu9nj3FxcSnznMaNG6vtIkUVz9d1dPzVefxFPVJEBlr7M6Z/f/0+fkJ03p0dQH46YO0F+ARpem/Iy/DpCBiIgeQHQOojwMZL03tEaqCuXbvixo0bZe4bP348L0s8bdo0vkiL+m6RmkxZqkcKo8jOQY3V4k0eSMGVNUCXGYChmab3iBBCahaFHHLF0xkp5WFZJ8WlvzKScnHnbCzunonlWSo3jkbx4exribrt3VCruSOkhhXMUjE0hGWfPnzkXr+O5L/+QubBQ8g+fBhehw8j+sJFOH08GSbPmGuukoA+QiCF9UmhQIpeEFXmwawxPAuibN26FUeOHIGPT9myGaUb/RZ70QUHew0WTCn9HJZhcu7cObpIITWOAXWbJ4SQ6nFp5eMm86JKfbwh2oat7vJoKWxTVgqpJhYWFrw8celhZmYGOzs7vl2679bRo0d5BgsLtFDfLVJjyOVlvlRkZaHG8usqLLRgCy5ubtb03hBCSM2jVEBRlJFiYPD8QEpprD9Kq/6+GPNNW/Sb1Ai+TRx4E/q4hxk4suoOVkw7jRNrQ3hZsMowadgQ7r/+Ct/du2AxYACUIhFyz51D+KhXEDXpQ+Q/DINKFJchjjwPZCVU6SXYXDtRDXX8LEWVLee1evVq3tyXXXywHiZs5Obm8u9X9IKDrfRiwZjiiWXWa2Xu3LnYsWMHXxnG6t+7urpi0KBBqj5eQjRCWbn/1QghhFQGq0kbcYal/QGNR2t6b4iqynsxFEghGsT6bvXr149npHTs2JEv/tqyZYumd4sQ1VDIYaB4HEwpzKzBgRS2wIJlpTAX/n7cwJIQFWHVWvr378/nsdgc17Zt28qUUmaZjg0aNOABe/YYNucVExOj0X0mRKUUciiVwryXqBKBlGIseOJVzw6932mAsfPaovUgX1jaG6MgV4Ybx6Oxbs55bJp/EXfOxKAwv+xCgOcx8vOD0zdzETZ1CiwGD+bng8yDB/Gwf3/EfvkVZKmpeClW7oBLIz7rh3v7KvXU4oooOTk1OCNUzYp/ltVZbaZSpb2WLl3Kb4OCypbMWL58OcaNG1fhRr8sSyU9Pb3k66lTp/Im3BMmTOBlwdq3b499+/aprPEjIVqDElIIIUT1Lq8Sbmv3ACxdNb03RBV8g4Cj3wDhpwCFgrKMiFocO3aszNfUd4vUZEqZHCJFAeQiE/51foawOLLGavwacOQbIPYaEH0ZcG+m6T0iNQibz2rUqBHeeOMNDBky5KmJvcuXL2PmzJn8Mampqfjoo48wYMAAXLx4UWP7TIhKKWTlNpuvCjMrIzTr5Y2mPbx475Rbp6IRdjUJ8WEZfJzacB8BrZxRt4Mb7N0r1ktFZmMDp9lfw+GN8Uj4eQGyjh5F2vr1yNy/H45TPoPV4MG8gX2Vy3uxc8v9A0DTsRV+mlgs5m0xWM8+xtTUtFqq2CgUCt6GIy8vj8/X19RMlJycHP6zZD9T9rPVikBKRVJkKnLB8eTrsF+U2bNn80FIzVTUI4UCKYQQolqyAuDaWmG76eua3huiKq5NAKkZkJsCJNwCnBtoeo8IIaRmkReW+TLzZggKoqJgWKoHao1iZgfUGwxcXwdcXEaBFKJSvXv35qM8rHLLwYMHy9y3ePFitGzZkpfB9/T0LPd5bGEyG6VL4BdnuLBRGcWPr+zzago6fjUcf2E+5KUCKap6L+faFnCuXQc5GQW4FxyPO2fjkJmUx7NU2HD0tkCdts7wa+oAqZH4hccv9faG86KFyL14EYnfzkPB/fuI/WIGUrdug9PcOZC6uVV6Hw28O0OCeVCGHoUsLwcQVzwbgpWUlcvlvE94dWFz8CyIwubra3q7AUtLS/4zLf37p+rf+yo1myeEVFHN/ptFCCHqd38/kJ0ImDsLGSlahn1wrekfWKsFuwDxags8OAiEnaBACiGEqJiS9UhhJTGLZN24i9Bu3WHasiVfmWvZswdEpqaoUZqNEwIpt7YCvb8DjCw0vUdET7EKLezzIVs5/Szz5s3D119//dT9Bw4c4CvXq+LJgI6+oeOvvuM3yU+ES1GPFJmsAHv27KmW97FsDhgli5EdKUVuvAQJ4Zl8nNxwD6auhTDzKIShpaJixz9+HGxOn4bdwUPIu3gRDwcOQmL//sho3qxyq6CVCvSSWMCoIBPnNi1CskVgpY+L/T2oziwKfSCXs/Jy1V+6kwIphKg1I4Um0wghRKWurxduG44AxJr7WMPq62adPQuHnTsRtW495AkJkKWkQJmbCwMTEz4ZxVY4Gfn6wsjfH2atW8GoTp2qp5DrA5+OjwMpbd7X9N4QQkiNopQroCy1ykvSqDlwJho558/zET9nDix69YL1kMEwadasZlzHeLYG7GoDyfeBm1uAZpTJStSPrQxnPVNeeeUVvnr6WaZPn877D5fOSPHw8ECPHj2e+7zysBXZbBK5e/fu1do7QFvR8avh+FPDcHvndr5paChFnz59UN14lsr5eNw9HYeMpDxkRxjy4eBlgcB2zqjV3BESqej5x9+/Pwrfj0T8FzOQd+UKnDdtQu28PDjMmgmRiVD6siLEst3AzY1o45AFRZfqP/bKoN//QmzfLvxuqgIFUghRp5pwAUIIIdoiNw24t/9xIEXNlAoFsk+fRtqmzcg8coR9SoMNu0B+8nG5uZCzkZyMvOvXS+4X29jAPCgIVgP68xXABrQK6elAChN+GpDLNBooI4SQGkcug9Lg8XnH5sNP4D5nEtK3b0fa1m0ojIhA+pYtfEg9PWE9eBCsBg6E1NVVt6/FmrwGHPoSuPIvBVKIRib0RowYwVdNF/cgfhYjIyM+nsQmQqs6Gfoyz60J6Pir8fhFolLN5g3U8nO2spOiRW9fNO/pg6h7qbh9MgYPryYi8VEmHxd2hqNhZ3cEtHV67vFLfX3hvfpfJP+zDIkLFyJz1y5e8st90UIYenlVbGf8e/JAijj0CMQ950Ib6fvvv6rQFSkh6sxI0fRuEEJITXJ7OyAvABzrAk711frW2cHBSPj+B+Tdvl1yn2EtPyTYOyBgwAAYe3tDYm/HVzIp8vKgyMpCQUQk8kMfIO/adeRcuAB5airSt27lQ+LkBJtRI2E9ciQktrZqPRatxcp5GVsBeelCA0eqZ08IISqjVMihLLXIqyBXxoMk9u++C7uJE5F76RLStm5F5t59PKiSuHAREhf9CtMWLWDZuxcsuneHxN4eOqfRK8Dh2UDUBSDhLuBYR9N7RPREcRDl0aNHOHLkSKWzSgjRako5ZEWlvVLykzD//Hz08emD+vb1qz2j0UBkAI86tnywLJW7Z2Nx43gUslLycW5HGC7tewRjFyNktMyDnUv5gQS2oM1+wtswbdIYUR9/gvyQEISPGAn3pUth2rTJi3eiVldhxo/1dkyPAqxqaL8xAqonQYg6USSFEEJU58ZG4bbBcLVl/MkSExH53vuIGDeeB1FEZmawee01+GzbCs+tW5EweBAs+vfjH7gNPT0hcXCAoYcHjAMDeb15h/feg8cfv8M/+Cw8V67kgRORlRVk8fF8kupBUGfEzpyFwuhotRyPVhOJAe8OwnbYcU3vDSGE1ChKmaJMj5SCPHnJNpv0Mm3eHK7ffIPaJ0/A5bt5PHMSSiUv+xX39Wzc79gJj8aNR+q69byUpc6wcBJWDjMsK4UQNQZR7t+/j0OHDvFmyITUKAo5covW6iuUMqy+sxqv7nkVfbf2xdKrSxGfXX3N1EsztTRE055eeG1OG3R/oy7sPcwhK1Ag65Eh1s++gCOr7iAjOffZz2/RAj6bN8O4UUPI09MRMX48Mg8dqsAb2wLuzYXtBxV4PNFZFEghRC2oRwohhKhUejQQfkrYbjBMLW+ZdeIEb0KYxcp4SSSwGT0afgcPwHnGFzCuU7kVrQaGhjBr1RIuX3/FJ6lcf/gBxvXrQ1lQgLSNG/GgV2/EzZ6Nwnj1XHRofXkv1ieFEEKIyijkZRuy5ufKyn0cWzBgPWgQvFathN+hQ3Cc8hk/X0GhQE5wMOK++gr3O3TEo/HjkbJyJQoePYLWazJGuL22DpAVaHpvSA2QlZWFq1ev8sGEhYXx7YiICB5EGTZsGC5evIg1a9bwhshxcXF8FBTQ7x+pIRQyyIsyUmCg5NkoJhITRGZG4rdrv6HH5h748MiHOBl1EnLF48B9dRGLRfBv6YwRn7dA3w/qw8hextYC4M6ZWKz5Mhgn1t9Ddnp+uc+VOjnCa8UKXoJZmZ+PqA8/QtqWrS9+01rdhdv7TzS1JzUKBVIIUYOSRo4URyGEENW4uYn/dYVnW8Das1rfitWxTli4EJET3oE8JQVGAQHw3boFzjNnqKQMl8jQEFb9+8F74wZ4rVkN0zateb+V1P/WIrR7D8TP/x7yzEzodSAlIhiQlX+xQwghpPIUirKBlMK88gMppRm6u8HuzTfhs2kjX0jg+NmnMK5XD5DLkXM2GPHzvkNoz14I7dWbb2efPQtFvhb+7a7dAzB3AnKSaOUwUQkWJGnSpAkfDGsSz7ZnzZqF6Oho7NixA1FRUWjcuDFcXFxKxpkzZzS964SohlIOhVIIpBgYKDG/43wcG3EM37b/Fk0dm0KhVOBo5FG8d/g99NnSB3/f+Bvp+enVvltsMbNbgA0cWuRi4CeN+LZCpsSNo1FYPfMsLu9/BDnL0HwCK8/svvhXWA8fxhcOxH7xBdJ37Hj+m9UuCqQ8PE5B+hqMeqQQokaUkEIIISpyvaisV8Ph1fo2SpkMsV9+ifTNW/jXrIwXW40rKqf558vipVSaNYPX8uXIPn8eiYsWIffiJaQsX86b/zpM/gjWQ4fqV1N6hzqAmQOQnQhEXQS822l6jwghpEZQPBE3CQmOg1girOC1djJ94fNZ2Uq7t97ioyAiApmHjyDr+HHkXLyIgvBwpLCxciXPwDRp0gRmrVvBtFVrmDSoDwNNN7sVS4D6w4DgJcD1dUCdPprdH6LzgtjKdbbc/Rme9z1CagSFAoqijBSlgRCYMJWaor9ffz4epj3ExnsbsSN0B2KyY7Dw8kL8ef1PDPAbgNcCX4O3lXe176KTjyUGfdwEkXdTELztIRLCM3B2ayjuBseh0yv+cPO3KfN4A4kEzrNns/QWpK1bj5j/Tef3WfZ5xjnDpfHj65bI4McLwkiNQhkphKgFZaQQQojKJIcC8TcAkQSoO6ja3oatoo2a9KEQRBGJ4DxnNi/jVR1BlCeZtWwJr3//hceff8DQ15dnwsTN+hJhw4bzRvV6tQLBq62wHUGrNgkhRFWU8scrcOUGcmSnF+DC7nBe8mTjdxdx7Ugkb9pbEawnmN34cfBasZz3AHNbuBBWQ4bwPmGsZGXOuXO8D9ijV19FSKvWiHh7ApL//hu5165BWVgIjWg0UrgN2QfkpmlmHwghpCZlpBSX9mJVA57ga+2LaS2n4fDww/im/TcItA1EriwX60PWo/+2/vjg8Ac4H3teLUFH1pR+2NRm6DI2EMbmUqTGZmPbz1dwaMVt5OcUPrXQzXnWLFgNG8qDRdFTpyE7OLj8FxaJAD/WdJ7Ke9VklJFCiDp7pLA/rIQQQl7OnaK0ataInDX2qwZKuRwxn01B1tGjMDAygtvPP8Gia9EHYzVhH9zNO3aEWZs2SF27Fom/Lkb+nTt4NGYsLHr3gtO0aZA6O6PG82oH3N4OPDqr6T0hhJAaQ1GqksnK5l9gTb3tuH8hHpG3U/gqXTZOb3oAj0AbnqXi08gehsYvnj4Qm5vDsmcPPtiEWEFYOHLOBSM7+BxvVC9PTUX2yZN8MAampjBt2pQ3+GXDpH49nsVS7ZwbAg6BQOId4RzT7PXqf09CCKmpFKy0l6hMRkp5jCXGPAulv29/XIy/iFW3V+F45HEcjxJGgE0AxtQdw3usSMXVl71oIDJAYFsXfm4L3v4Qt05G88zM6JBUdBtft0x2CpvHc5k9G8qcXGTs2cN7pnivWwcjX5/yy3uxTEdWNrLHnGrbf6I5FEghRI0MKCWFEEJe3u2iQErdAdXy8mziJ+7r2cg8eJCXH/H4fSkPZmgK2wfbsWNh2a8fL/eVtmEjMvfuQ9ax47B/913YjXtdPZNOmlKckRJ5DpDLhJIshBBCXopC/niBV4E4F97NbVCntQvPQrl/MR73zsfzYErErRQ+JIYi+DRygH9LJ3jUteWNfCuyIIBNNLFh88orUCoUyL9/nzepz75wATkXLkKRno7sU6f44M8xMYFpk8YwatoMJrJCntGC6igFxjIeWVbKoa+A6+spkEIIIS9DKYeyVLP5ipwfWji34ONRxiOsvr0a20O3IyQ1BDNOz8CiK4swtu5YDPMfBjOpWbXttrGZFEGvBqBOa2ccXH4bGYm52LbgCpr39kbLfj484FISTJn3LQpjYpB79SoiJ06E9/p1kNiULQcGvy7swUDCbSA9CrByr7Z9J5pBy+MJUQsq7UUIISqRFgnEXBb+oNbpVy1vkbR4CdI2bOCTLK4//qjRIEpprLG9y1dfwWfzJpg0bQplbi4Sf/4ZDwcMRNap06ixHOsCRlZAQRYQd13Te0MIITWr2bxSwU+pWYVZ/EtTS0M06uKB4f9rjtFft0aLvt6wcjCBrEDBM1Z2L7mOFVNP4/DK23h4NRGFBfIKvyebiDIOCIDt66/DY/Fi+J89A5/t2+D0xRew6N4dYhsbfm7LPnMWKYsXw+P3P/CwbTs8en0cEhcvQe6Nm6ot+9KA9VkzAB6dBlIfqe51CSFE3yhkj0t7VSCQUpqXpRe+aP0FDg47iMlNJ8PRxBEJOQn48eKP6L6pOxZdXoTk3GRUJ2dfK4z8ogUC27nwymQX94Rj99LrZUp9sfLO7ksWQ+rmhsKICMR8+hlfIFAGq5bg1lzYfnC4WveZaAYFUghRIxZ1J4QQ8hLu7HycpWDuqPKXzzx8GElLlvBt5y+/5KVJtI1xYCC81qyG6/zvILa35019I996C1GTJqEwOho1jkgMeLYWtiOovBchhKiCsjiQUlTLPqMg46nHsKbzLfv7YvTs1hg2rTkadHaHiYUUedmFuHs2Dnt/v4Fln57EnqXXcedMLHKzKtZT5anAypjX4P7rItQ+fQo+O7bDaeYMmPfoAZmZGZT5+bzHStLixQgfPhwPunRF3DffIvv8+acnsCqLrRT2bi9s39jwcq9FCCH6rFRpL4iqFvC2MrLCmw3exN6he/F126/hbemNzIJM/HXjL/Tc3BNzg+ciKjMK1YWVr+wyJhDdxgVCLBXh0Y1k3jMsPTGn5DESOzu4L/0NBsbGyD5zBsl///P0C7GsFObh0WrbV6I5FEghRK0ZKRRIIYQQlfRHCVR9Wa+CR48Q87/pfNtm7BjYjCpqRFtFbNVsyYrfagjMWw0cCL+9e2D7+lhALEbmwUMI7dsPSUuXQpGfjxpZ3usRNZwnhBBVUMiLypUohYySLJb195xzjpOPJTqO9Me479ph0MdN0LCLOyxsjSErVCDsWhKOrLqD5VNOYdP8izi34yFi7qdCLlNUPrDi7w/b0aPh/NOPeDhzBjy3b4PzV1/CokcP3k9FFhuL1H//RcTY1/GgWzckLvr15RYRNBol3N7cUvXXIIQQfadUVKq01/MYig0xpPYQbB+0Hb8E/YIG9g2QL8/njen7be2HqSemIiQlBNUloLULhk5pBnNbI6Qn5GLzD5eRGJlZ8n12nnKe8QXfTly4EDmXr5R9Ab/Owu3D42UbkpEagYpME6IOFEchhJCXlxkPRAQL24H9VfrSitxc3jhQkZkJkyZN4PTZZ5V6fnZ6PiLuJCHtthG2372K7PQC5GYU8kkkkdgAEkMxzKyNYO1oAlsXM7jUsoZLLasKNe59HrGFBZymT4fV0KGInzMXORcuIHHhIqRt3Qanz6fDIigINS6Qwi5IRLQWiBBCXkZR/IRF/V8YSClNJBbBLcCGj/bDayM5OgsPryYh7FoikiKzEB+WwQcriyIxEsOttjU8Am35421dzSAqqjdfIQYGMPT1hVlAAGxGjYIiL4+vAGYLB1gGqSwmFkm//Yak33+HRc8esBs/HiYNG1buB1GnL7BzslDPPuEu4Fincs8nhBAiZKTg5TJSniQyEKGrV1d08eyCC3EXsOzmMpyOOY29YXv5aO/WHm/UfwPNnZqrvPqLg6cFz8Tc+es1JEdlYdtPl9H3/YZwrS30RGHXXtlng5GxezeiP/sUvtu38+syzq0ZYGgB5KYIZYldG6t034hmUSCFEDVQFp1QqLQXIYS8hLu7hBIkrO6slZtKXzrhp5+RHxICsZ0d3H5ZUKHm7SxIwurDs/ImkbeTi+aiDJGFxyuWGIVciYJcGR+psdl85S7wiDcvdPGzQq1mjvBt4gAzK6Mq7z9bGeW5aiUy9uxBwvzved3eqInvwrxzZx5QMfTwgE5zaQxITIQLkqR7NNFFCNFfCrnwdzDmKhB/E8iIAbISgPx04fusya2xFWDuBFi4AA51AKe6Qr8pSdF5hmVMKosyUiCsls0sLHvuqgh2bWPvbsEHa8qbmZKHqLspiLyTym9zMwvx6GYyH4yhiQTOvpZw8RMWEzh6W0JqWLSCuQJExsaw6NKFD5Z5mXnoENI2bULO2WBk7t3Hh1n79nD87FMY16ngecLERijDcn8/cHsb4Pi/Sv8cCCFE75VpNq/al2bnmpYuLfm4k3wHy28ux/5H+3Eq+hQfDR0a4t1G76KdazuVzrmxa7PBnzTBnqU3EHM/DTsXX8fAjxrzfirsfZy//gq5N27w666En37ivSw5sVQoG3lvr1DeiwIpNQoFUghRI4qjEELIS7i37/HqURViddZTV6/m267ffQepk9NzH8/KdbGGu+d3PkRGUl7J/XbuZsgXp6JlUAPYOJnzhr1SIzEPuBTmy5GZnIe0hBwkRmYh5l4qfy77UM7GyfX34NXAHvU7usGjrm3lVuyWLvfVty/MOwUhaelvSFm5CllHjyL79GnYvfUW7N5+CyITE+gkiSHg0QIIOyE0BaZACiFEn8jygfsHgLu7gXv7haByZYmNAI+WwuROrW6PVw4XpaawOvQvi5X6CmzrygfrwZIUnYXIOymIupuKuNB0vqAg4lYKHww71zl4WfBFBTxT088KJhYvXsjAn2tkxM95bOSFhCBl+Qqk79qF7FOnEHb6NKwGDIDj1Cm8nv0L1RssBFJubQWCKJBCCCGVpigVSFFRRkp5Au0C8X2n7zEpYxJW3l6Jrfe34nridbx76F0eUHmv0Xto69pWZQEVI1Mp+k9qxHuBsUUCLEOFlbdkGStic3O4zJ3DS02mrVsPq379YNq8+ePyXiyQEnoUaP+xSvaFaAcKpBCiFlTbixBCXkpBjjCJzvj3UtnLKrKzEfu5UOPWesQImHcoajr7DIkRmTi86g5P8WZMLA1Rr70rAlo5w8xWij179qBWc0dIpdKnnmvjbAbPeo8ndDKScnlGy4NLCbwMSvj1JD4sHUzQtIcn6rR24Y0OK0tsbganKVNgzcp9zZ2L7DNneemTtC1b4PDB+7AaNAgGEh38COjZtiiQcgZo8aam94YQQqqdUWEaRMe/A66sBLITH3/D0Bxwbgi4NASsvQBzR8DYWvieUgHkpQFZ8UBapFCyKv6WEHwJPymMY/MgV/oVXaJUrrRXRbGsSwcPCz6a9vCCQq5AcnQ2Yh6k8aAKu81JLygpBXb1UCR/no2zKQ+oOPpYQJZjwPuNvQhrWO/63TzYv/cuEn9ZyLMz07dvR9bx43D64nNY9uv3/Em1On0AsSGQeBdIuAM4BqryR0EIIXqSkSJSSY+UivCw9MCM1jMwsdFEnqGyIWQDD6hMPDQRjRwa8YBKG9c2KgmosBLNvSc2xM5fryL2QTp2LLrKe6hYO5nCrGVLWA8fjrSNGxE7cxZ8tm3lgX74FpVXZmWpC3MBqY4uZiNP0cGraEJ0F7ugIIQQUgVsAl2WB1h5qHSCg6VhF0ZFQerqCsepU5/5ODYBdPlABC7sCuOluoxMJWjSwxMNO3vwrBOmsLCwUu9taW+Cxt08+UiNy8atEzG4GxyLjMRcHFsTggu7w9GkuyfqdnCtVOmTYka+vvD45x9k7j+A+O/n81rysTNmInnZcjhM/ggW3bvrVslJrzbCbeQ5Te8JIYRUr7wMiE78hO63lkCsLDq3sDJd9YYIk/4erQFxJS7lWTAi+YEQRAk9Ajw4DLlSVBRIqXppr8pgvVXYCl42GnXx4AESlqkZWxRUYZNTrPxlalwOH7dPxwIwx5or5+HqL/RZ8apnx/uNPYuhpyfcfv4JtuPH8Qmt/Lt3ETNlKjIPHITLvG/56uFysVJotboBIXuErBQKpBBCSBV6pIhLKkyqi72JPaa0mILx9cfzHiosoHIt8RreOfQOGjs0xodNP0Rju5cvrcWu9/q93wjbf7mChEeZ2P3bdQyd2gzGZlI4TvkMmceOoiAsDMl//AGHDz8E7P0BC1cgMwaIOCuUkCQ1AgVSCFGLookqCqQQQkjVsJIbjH9PlWX3sZq2qWvX8W2Xb+byTI7y5OcUYt+fN3lpEsa3sQOCRgdUuPxIRbBslfYjaqPlAB/cPhWDqwcjkJ2Wj1Mb7+PygUe89nxgWxc+EVUZLFBi2asnzDsHIXXtWiT//gcKHj5E9IcfwbhhQzhO/gimbVSzWqvascaN7MosPVLoCWDpquk9IoQQ1WIBj2trgQMzIc5h/bQAhVtziNq8BwQOEOquVwX7G29fWxjN3+CrY2V//QNcZwuHhUDK2ZizaO3SGs2cmvEGv9WNn5/sTfhgWZ1MXlYhYh+mI/YBK3uZivjwDORkFODBxQQ+GDs3c3g1sEPt5o58u7zzl0mDBvDZuAHJ/yxD0pIlyDx4EPn378P910Uwql372eW9igMpQdOpkgAhhFS2f1dRRgqL06sbC6hMbTGVN5//58Y/2HhvI64mXsUb+99AkHsQGskbvfR7sD5ffd9vhI3fXUBafA72/3WTl/0SW1rCecZMRH/0EZL//gfWw4bxRXq8vNfVNUJ5Lwqk1Bga+PUmRH8ZqLrrFiGE6MvE0r0Dwnbtnqp5SYUCcXPn8te2GjgAZm2Ksh2ewMpvbf7hMg+iSIzE6Pp6IHq9U1+lQZTSDI0lPENlzNy2PFhjYWfMS5+wDJV1c84j7FpihcqcPImlmNuNGwe/Qwd56RMDU1PkXb+OiDfeRPjIUcg8coT/TLSakQXgWE/Yjjyv6b0hhBDVykoE1o0Gtr0L5CRBaVcL53wnQ/76XqD+0KoHUcojNYHCxrfoC+Fv/42kG3zCqc+WPlh8ZTEiMiKgbsbmUvg0tEfbIbUw8JPGcOuehf4fNUTzvt68MT27lEqOzsLlfY+wfu4FrP36HC7uCePn6icZSKWwn/gOvNashsTFBQXh4QgbMRJZJ0+W/+asbCjrI5N0TyiHRgghpErN5tWZkVJeQGVay2nYO2QvRviPgNhAjGNRx/Br5q+Yf3E+0vPTX+r1WQ/Mvu815NeF7Prw9KYH/H6LHt1h2rIllAUFSFjwi/Bg387C7cNjL31cRHtQIIUQtRACKFTaixBCqoDVds+IAiQmgE8Hlbxk+vYdyLt2HSJTUzh8+mm5j2GTNZvmX+SlRsysDDHks6ao08ZFLdkbrDdKvQ5uGP1Va7QfXpunjbNSJ3uW3sDWny4jLqxqFwGsrAlLN691YD9sxoyBgZERD6hEvfc+wgYOQvqu3VDKZNBarOE8E3VB03tCCCGqE34a+K01ELIbEEmBrrMge/sk4qyaVltmhLzkb70Cy3ouw9DaQ2EuNUd0VjT+uP4H+m7ti7F7x2LTvU0qaURfFQZiwKWWFVr198Xw/zXHGz+0R/c36vLMULFExM+L53aE4d+ZZ7F7yTVE3k55arGBScOG8Nm8CaatW0OZm4vI995Hxt69T7+ZsSVQu7uwzbJSCCGEVK3ZfOUrEqucg6kDZraZiS0DtqCDawcooMD6e+sxYNsA7Hm4p0oL04rZu1ug+/i6fPv60Sje85JdHzpOm8rP2Rk7d/LKB/DtJDwh7jqQLWSZEt1HgRRC1KDkTzSliBNCSNXLerEPoypo1CfPzOS9URj799+D1NHxqcewdO3tC68iN7MQdu7mGPa/5rxhrrqxgEqjrh54bW4bNO3lxb9mdeQ3z7+EA//cQkby06twK0Jibw/nLz5HrSOHYff22xCZmfGyJzGffYbQXr2RvHwF5BkZ0DoerYRbykghhNQUl1YAqwbwLBSedTfhKNDhU9VmoJRDLmNlWBglL+f1VduvcHTEUczvMB/tXNvx8l5XEq7g67Nfo/OGzph6YipOR5+GnJdv0QwTc0P4t3RG74kNMP6H9ugyNhDudWz4xVb4jWTeAHjjvIsIv5FUZpJMYmsLzz//gGWf3qyhGaI/+RRpmzeXX96LublFyIYtT+w14OraZ3+fEEL0vNm8JjNSnuRr7YuFQQsx3mw8fCx9kJKXgmknp+HdQ+8iMjOy6q/b2IH3smSO/HsHWal5MKlXD1YDBvD74ufPh9LMAXCqLzyBslJqDC369SakBisKoOhEDXpCCNE290r1R1GB5D//hDwpCYbe3rAdM+ap77MSIdsWXEFuRgEPogz6uAnMbYyhSUYmErQZ5IfXZrdGnbYuPNHx/oV4/PflOZzdFoqC3KplkUjs7OD46SeodfQIHD76EGJraxRGRSFh/nzc7xSE2C+/4gEWreFelJESexWQ5Wt6bwghpOrYRPz+L4CdHwEKmdBI/q1DgHMDtbx9SUaKUl7SE8VYYow+vn3we/ffcWDoAXzc7GP4WfkhX56PvWF7MfHQRPTY1AMLLi3Aw7SH0PR5kfUOGzi5CUZ/3RoNOrvzUiuJEZnYveQ6tvxwmW8XMzA0hOsPP8B6xAj+s2fN6DMOHiz7ouxzhsQYSAkF4m6U/8bb3ge2TQQiz1XzERJCiK5mpGjfvJef1A9re6/F+43fh6HIEKdjTmPI9iG8OX1Vs1NaDfSFo5cF8rNlOLT8NhQKJRwmf8Qz/nMvXkLW0WOAb5Dw4IdHVXtARGMokEKIWlAghRBCqiQn5XEZp9o9XvrlChMSkPLvar7tOHUqn1gpLS+7EDsWXuWN3m1czDDwo8a8rJa2YAGdrmMDMWJ6C7gFWEMuU/Ba8atnncWtk9FQyKvW54Q1SbR/910eUHGe/TWM/P15CZS09evxsP8APBo3Hhn79kNZWAiNsvUFTO0AeYGwKpgQQnQR60m1+xPg7GLh684zgGHLAENT9e1Cyfmi/AkkJzMn3rR368CtWNt3LUYFjIKVkRUSchOw7OYyDNw+EK/segVr76596ZrzL8vayRQdR/pj7Nw2fIWwRCpC3MN0bJx3ASfX3ytZbGAgFsP5669gPXw4/zeI+fQz5Fy6VLYXV3F5r9vbyn2vnPtxSAkxgzLshFqOjRBCdCeQon0ZKaUZig0xsdFEbB6wGS2dWyJPnoc5wXPw4ZEPkZybXOnXYyUmu79Rjwfxo++l4drhSEhdXGA75jX+/aSlS6H0KQqkhB6jTMYaQkt/vQmpaYoCKBRHIYSQygk/yTrDAw51ACv3l3655D/+hDIvDyaNGsG8c9EH21KTSgf+von0xFxY2Bpj4OTG1dZU/mU5eFrwVbh93m0AK0cTXoKMNaRf/80FRNyu/IVAMZGJCWxGjIDP9m3wXLkSFt27ASIRcoKDET15Mu536YKEhQtRGBMDjWALEqi8FyFEl7HSWDs+AC4uEy4OBi4BOk1RewlgRUlpr+cH4NlCsPr29fFF6y9wZPgRLAhagCD3IN7A92byTXx77lte+uuTY5/gWOQxFMo1F3Bn5+y2Q2vhtTltULu5I5+zYvXr139zHvFhGSXH4/zlLJh36cKbAke++x7yH5bKrgkcKNze3VPue8SdNkD8FStkHTmslmMihBCdoCgUGltpaUZKad5W3virx1+Y2mIqpCIpb0Y/YucIXEu8VqVAfocRtfn2+Z0PeWUD2/HjYWBsjLwbN5AdIwLEhkK/z+TQajgaom4USCFEjSgjhZCXM2/ePLRo0QIWFhZwdHTEoEGDEBISUuYxQUFB/P+10mPixIka22fykkKL0qB9O7/0SxVERSN1wwa+7fDxx0/9TT6zJRSRd1IhMRShz3sNYGZlBG3G9t+nkQNemdUK7UfUhpGpBCkx2di56Bp2/nqNb7/Ma5u1agn3X39FrYMHYPfOOxDb2UGemITkpb/jQbfufPIp6/hxKOVyzZT3iqJACiFEx7CZ/T1TgKtrhAmnIX8BTYSVq+omf0FGyrNW83bz6oZfu/6Kw8MP80moAJsAFCoKcfDRQUw6MglBG4Iw6/QsnIk+w+/XBDNrI/R4qz4GfNgYFnbGyEjKw5YfLuHKgQhewsVAIoHbTz/CpEkTKDIyEP3RZChyi3qOsYwUkQRIvPP0pJcsH7Jc4bND1pVQIbOIEEIIL1FZnJEi0vJACsNKWo6pO4ZnXPpY+fBsy3H7xmHjvY2Vfi1WZtK1tjVkBQocX3sPYltb2Iwcwb+X9NdyKN2Krl3CKZOxJqBACiFqUXQiEWn/CYUQbXb8+HG8//77CA4OxsGDB1FYWIgePXogO7vshPHbb7+N2NjYkvH9999rbJ/JSyquJ1tcX/YlJP32G28ya9a2DcxaF2U1FLl3IY6nYzPdxtWFvbtqGsuzCRtW8uRe6j3cTr6NO8l3EJoWisyCx3XbXxZLK2/UxYOvwGWN6UUiA0TcSsa6uedx/L8Q5GYWvNTrS93c4PjxZNQ+egRuC36GaatWfPIo6+hRRL4zEaE9eiLpjz8hS6p6JkyleLR8nJFCKfKEEF1y8ifg4j/CtcHQv4CGwzW2K4qSIHjVggF2JnZ8EmrTgE3Y1H8T37YztkNGQQa2PtiKdw69gy4buvBm9cGxwZCxPjBq5lHXFiO/aAG/pg68dv2ZLQ9wZOUdHkRiGZjuixZCbG/Pe4HFzZkrPMnEGvBqJ2yHlM1KUeZlQF4oTKFkRoigTLij9mMihBCtJC8s1SNFd6aaA2wDeDClm2c3fp6afXY25p+fDwWriFCJBWhBowMgkgjXYA8uJcD2jTdhIJUi99Il5BQKGSsIP1V9B0LURqK+tyJEnwkBFJGo6MRCCKmSffv2lfl6xYoVPDPl0qVL6NixY8n9pqamcHZ21sAeEpVKCQNSw4WVod5FkxpVVBARgfRtQr1zh8mTy3yPpWAfXyNkNjXr7QW/po5Vfx9lAY5EHsG15Gu4HH+ZB01Y/d3ymEnN4Gvli3p29dDQoSHauLaBvYl9ld+b9XJpP7w26nd045NFYdeScPNENO6dj0Oz3t5o2MUdEmnVz0Osn4xl7958sDIorH9K2tZtKIyORuKCBUj89Vc4162LXAdHSNq0rr4sTNemwkruzFggPQqw9qie9yGEEFW6sgY4MkfY7j0fqD9Uo7tT3CNFaaBQyUTUVNup+LTZp7gUfwn7w/fjUMQhpOSlYNO9TXzYGtuis0dndPfqjpYuLXk5FXUwMpWi59v1cfN4NE5uuI+7wXHITs9HrwkNYOjgALcff0TEG28gfcsWmLZoAevBg4A6fYGw40J5r7aTSl5LmZbAfmB8W54nRt7x7TAZWU8tx0EIITrTI0UHMlKevCb7Oehn/H3jbyy6sgir76xGYm4ivmn/DYzEFatQYONshma9vHFhVxg/13jNbg2rYUORtnYdko9FwiwAQBgrWa1UeylPoloUSCFEDYo+b1OPFEJULD1daG5qa2tb5v41a9Zg9erVPJjSv39/zJw5kwdXypOfn89HsYwMoYY2y3ZhozKKH1/Z59UUqj5+g/uH+QcVhVtzyEXGPJukqhL//ptnUZi2bw9JYGDJPrIVqgeX30JBnhxOPhZo0tOjSvt/Pek6Nt/bjAPpB5B/8vHvUzFrI2sYigyhhBJ5sjxkFmYiuzAbN5Ju8LEuZB1/XD3begjyCEIf7z5wMXOp0rGa2UrR/a1AxNxPw9ktD5EclY2zW0N5UKVlf2/4NrGHwUtmSIo8PGD72Wew/uADZO3fj/QNG5B//QYsr19H9BtvQOrrC+tXRsFi8GCIjFRcIs1ACrFTfYjirkH26CyUZtoRNNX3///1/dgJeS6WQbfzI2G73WSg1Tua3qMqlfZ6EbFIzIMkbExvNR0X4i6UCapsvr+ZDwtDi5KgCltEUNGJqqpigf0GQe68zNf+v27yMp7bf7nCe42xDFX7D95H0qJfETdnDsxatoA0oDewdyoQGQxkJwNmdvx15CnxZV438+hxmIz8vFr3nRBCdIKiEMqiLvMGEt2b+GLnibcbvg1Xc1fMOD2Dn7tS81Lxa5dfYSotfx7hSc16euHeuTjeb5OVkmz61ltI27AR2VfuIM/NDMZIAJLuAQ4sqkL0JpBy4sQJ/PDDD3z1LyuXsnXrVl6jvtizVh+ysipTpkwp93tfffUVvv766zL3BQQE4O7du5XdPUK0OyOFIs+EqIxCocDkyZPRrl071K9fv+T+V199FV5eXnB1dcX169cxbdo03kdly5Ytz+y78uQ5iDlw4MAzgy8vwsqO6TNVHX/zsPVwY5U1Cl1xb0/5TV8rQpyZCZ8tW/kaqZB6dXG11GtlhBoiI9QIBmIlDDxjsW9/5ZqoR8oicTjvMB7IHpTcZy2yhr/EH14SL7iJ3WAlsoLUoNTKWyMhcyVdkY5YeSyi5FEIl4UjRh6DWym3+Pjt2m/wkfigtWFr1JHW4XV8q8K4PmBjI0H6PSNkJufh8Iq7OL5JDstaBTBxlqlmQZRUCoweDaOgaFgFn4Pl1asofPgQid98i9hfFyMlqBPSW7aEkj1ORRrIHOAL4NGpjbgZrl29bPT9/39CyBOyEoANY4VGvIEDgG5fQRsoSwIp1dPnQyKS8CAJG6xR/cW4i7yPyuGIwzyosiN0Bx+mElN0cu/Ee6+0d2tf4QmrqvBuYI/BnzblfcQSHmVi15Jr6P9hY9hPnIjsM2eQe/ESYr/+Gh5//AED5wZA3A3g3j6gyWj+fEVqIqJd2iHVxh+Bd9cg63okqp7DSgghNQgv3yhkvovEuluJpa9vX166cvLRyTgfd573/lrcdTFMJCYvfK5YKkKbwX7Y9+dNXD0Ugfod28Cia1dkHjiA1GgPuATcBcJOUCBF3wIprA59o0aN8MYbb2DIkCFPfZ8FV0rbu3cv3nzzTQwd+vzU5Xr16uHQoUOPd0xCyTKk5qFm84SoDuuVcvPmTZw6VbbW6IQJE0q2GzRoABcXF3Tt2hWhoaHw8/N76nWmT5+OTz75pExGioeHB++9YmlpWenV2GwStXv37pCqcNJYV6j0+BVySH4RVu/W7vkWarkX9cWoguSFC5Eqk8GoYUMEvf9+yd/i1NhsbD5wha/G7fRKAPxbOVX4NdPy0/DjpR+xJ1wIykgMJOjp2RPOyc54q9dbMDKs/OQ+SyE/FX0Ke8P34mLCRTyUPeTDw9wDrwW+hn4+/Sr0Ib48hflyXD8ShRtHo1GQBaRcNYGNsyma9PKAbxMH3ldFJf/+bm5o8OMPyN2zF2nLlwPx8XDcsRMuwedg+84EWA4dCgMVXFwZ3MoFth2CjyQRnn36QBvo+///xT+D7du3a3o3CNEe8kJg4zihFKF9ADDoN60p6cEWpBRtVft7sTJeJUGVVl/gSsIVnqVy6NEhxOfE8/MeG8ZiY7Rza8eDKm2d2lbLvjh6WfIm9NsWXEHsg3Ts+/0G+rzbEC6zZyNs4CBknziJjN17YBXQVwiksD4pJYGUJDzy7IE8E3vYptyGa9w5FNy9CsM6jatlXwkhRKd6pJRkpOhOj5TytHZpjd+7/Y53Dr4jBFMOT8KvXX+t0HUYu65y9rVE3MMMnN/5EC1fG80DKem3cuDoYwAx65PS8m21HAepHpWOVvTu3ZuPZ3myJj27mOrcuTN8fX2fvyMSCdWzJzVY0QVTFVcUE0LK+uCDD7Br1y6eJenu7v7cx7ZijbEBPHjwoNxAipGRER9PYhOhVZ0MfZnn1gQqOf7oG0BuKmBoAYlnK9ZRvUovI8/MRPq69Xzb4Z0JMDQ05NtKhRKnNoRCIVfCu4Ed6rZzq3Cw+/Cjw5gdPJuvqGWZIgP8BmBCwwlwNnbGnj17eBClKsfvKnXFCMsRGBE4AlGZUbz8yYaQDYjMisS8C/Pw+/XfMb7+eLxS5xUYS4wr9dpsf1oPqIUm3bxw7UgUrh2ORGpcDo6sCMGVfZG8SX1AK2dIDF8+yGFkYwPzca/D7tVXeM153og+NhaJc+YiY+MmOM/4AqbNm7/cm3i14Tei+BsQQQZIqxZgqg76/v8/IaSUo98Cj07zcxlGrQGMLKAt2PmPM1Bdaa+Klv9q7tycj6ktpuJm0k2eqcJGdFY0z1hhgwVffEW+KAwtRDfvbrA2tlbZPjh4WqDfB42wY9FVRNxOwYn199D5tTqwf+9dJC5chPhvv4XZsvmQ4Dsg9AhQmMvPM/K0FMikXvw1Ujya8UBK1o7/YEuBFEKIvuM9UoTrCAMdajb/LI0dG+P37r9j4sGJOBd3DtNOTMOCoAX8HPY87Hqy7ZBa2PLjZdw5E4uGXVrCyN8f+ffuIe2hKeysT1GfFB1XrWkf8fHx2L17N1auXPnCx96/f5+XYTE2NkabNm14qRVPT89qr2df/LzSt/qGjl8dxy/8kVRAoXU/Z/r3p+PXJUqlEpMmTeJlJY8dOwYfH58XPufq1av8lmWmEB3y8Jhw69OhykEUJm3DBiiysmDo5wfzzp1L7r9zNpavRJUYitBhlH+FgihyhRy/XP4FK26t4F/7WflhdrvZvFG8qv9/crdwx0dNP8LbDd7G1gdb8e/tf/kE08+Xfsbq26vxTqN3MLj24Eo362VNd1v280GjLu64fvRxQOXYmhAEb3+I+p3c0KCTO0wthYDTyxAZGsJm1ChYDRmCtPUbeDP6/Lt38ei1MbAeNRJOU6ZAZGZWtRe39gTMnYCseCDmaklghRBCtMajM8CpBcL2wMWAfW1oE0U19EipLLYYgZ1D2fik2Se4m3K3JKgSnhGOEEUIvj73Neaen4sWzi0wqNYg9PDqAan45YPVLn5W6DWhPnYvvobbp2J4cKXem28iY89e5N+/j8S1h+Bi7QGkRwqfSQJ6Q56eCplYWMiQZFaHb2eeDIbtVBX8MAghROdLexWVtJfqfiCFaeLYBL91+w0TDkzA0cijmH9hPqa3nP7C60aXWtbwbeyAh1cTcX5XGFq/Nhpxs75E6gNz2PrHwyDhDuBUV23HQXQokMICKBYWFuWWAHtytfCKFSt4XxRWGozVqu/QoQMv2cKer4569oy+17Sm46++41cWnVAiIiOR/hJ1/qsT/fvr9/HrUjmv//77j2c7svNDXFwcv9/KygomJia8fBf7fp8+fWBnZ8d7pHz88cfo2LEjGjYUJruJjgg/Kdz6dKrySyhlMqSsWcO37d4YDwOR8KE+N7MAZ7YIPU1a9vOFpd2LsxkyCjIw9fhUnI45zb9mmSEfNP4AhuKXDzg8D6sVPzpwNEYGjMTuh7vx29XfEJMdgznBc3hA59Nmn6KLZ5dKl45kAZUWfVlAxQO3T8fwsl+ZKXm4uDscl/c/gn9LZ9Tv4AZHb4uXLkvJAiq2Y16DZd8+SFzwC9I2bkTauvXIPnMWrt99B9OmTSr/omyf3FsAd3cBUecpkEII0S55GcAW1lBeCTQeDdR73FNUWyiVRYEUg+ov7VUR7FwTaBfIx6QmkxCSFIKlR5Yi0jgS99PuIzg2mI8fLvyAof5DMdx/OJzNXq6ihVc9O7Qe5IezW0Nxcv092LmZw3nWTDwaMxZpmzbBdkoHGKX/B9zdzQMpeek5JRUGFBAjya4epA8vQZGbC5GJ9mRGEkKIZprNF/VI0fHSXqU1c2qGbzt8i8+Of4a1d9fC1cwV4+qPe+HzWg7w4YGUh1cS0WJaV4isfkZhejqyYo1gwa5zKZCis6o1kLJs2TKMHj2aZ5k8T+lSYWyiiwVWWKPgDRs28P4q1VnPntH3mtZ0/NV//Mt27Oa3Pt7eaK0ltdyL0b8/Hb8u1bNfunQpvw0KCipz//LlyzFu3Dheton12/rll194Ty92bmA9umbMmKGhPSZVIpcBEeeEbe/2VX6ZrGPHIIuJhdjaGpZ9+5bcH7zjIfKzZbBzN0fDrs8vDcck5ybj7YNv437qfV4bl2Wh9PLuBXViTXsH1hqI3j69seneJvx5/U9EZkZi8rHJaOXSCtNaTENtm8qvdjY0kaBxN0807OyOh1eTeGPE+LAM3D0Tywf7GdVr7wr/lk48+PJSx2BrC5c5s2HZpzdiPv8ChREReDR2LJy/+BzWo0ZVPmDj0bIokHLhpfaLEEJUbt//gPQIIXuu13fQRgo5NJ6R8izsfOBn7Ycuxl344piY3BjsebiHn/8SchP4OfCfG//wpsDvNHwHnpblV7KoiCY9PJHwKAOhlxOx/88bGDWrFc9gzTp6FIkn0uDOXpo1nFfIkZ9ZUOa5yc6N4JxwCTnnzsA8qKsKjpwQQnSUQlbSI0VUw3pe9/TuibjsOPx48UdeHYBdc7F+Xs9j52pekpVy5VgcGg4ZgpTly3l5Lx5IacUWWxBdVG2/3SdPnkRISAjWrxfqkleGtbU1/P39eT378lRHPXtVPF/X0fFX5/ELk0NisURrf8b076/fx69Lpb2ehwVOjh8/rrb9IdUk9hpQmA0YWwGOVV+tk/rff/zWevgwiIoWdSTHZOHOqRi+3XGUP8QvqOGblJuEt/a/hdD0UNib2GNpt6WoY1sHmsIyYF4NfJWXN/n7xt9YeWslzsWew/CdwzEiYATeb/w+rIysKv26IrEItZo58hH3MB03jkch9FIikqOycGLdPZzZ/IB/r24HN95A8WWyVMzatIHvju2I+/JLXkIl7uvZyLt9B84zZ8CgqIdNhbg1E26jr1R5XwghROXuHwKusmxIA2Dwn4Bx5Rf6qbXZvJp7pFSFl6UX3m38Lt5q+BaORBzhq4IvxV/CjtAd2PVwF/r79seHTT+Eo6ljpV+bnc+6jA1EcnQ20uJzcHLDPXT89BNkHT+OzDNXkWNlA1MkAlEXkZfFStcw7GdmgCTr+pCLpMg+tJMCKYQQ/cYWwqG42fzL91zUNmPrjkVYehjvYTnt5DRs6LcBruauz31Os95ePJBy/0ICGo3rx1Z/IivGGLK7pyBh5+CiaglEt1Tbv9o///yDZs2aoVGjRpV+blZWFi/PQvXsSY0jpoZShBDyQqwxL+PZtsofMPNDQ3npKPZ865GjSu5n5TtYPI6tEHKtZf3CTJQ39r/BgyhscmZ5z+UaDaI8WfKLTRptG7QN3Ty7Qa6U84mlvlv78gb1rJ9LVTn7WqH7+HoYN78d2o+oDVtXM8gKFbgbHIctP1zC2q/P4crBCORklF2ZWxliCwu4/vQTHD/7lJfpYuW+It//AIq8vIq/iAv7jGkAZEQBWQlV3hdCCFGZghxgd1HlhFYTtbvsoEIzzeZfBusLxlYGr+i1Amv6rEEHtw5QKBXYHrod/bb2w1/X/0K+/HEv1YoyNJag67hAXjXy3rl4RGdZwWrIYP69hNuO/HMDy0rJLzpFmRtkwNzWCHKREVJs6yI7mDIjCSF6jmekCAEUcQ0MpLCg+/RW01HXri7S89Px6bFPUSB//rWQo5clPOvaQqlQ4tZ9EYzr1QOUBsgIKQASbqlt34lqiaoS5GCNe4ub94aFhfHtiIiIMqW2Nm7ciLfeeqvc1+jatSsWL15c8vVnn33GVxCHh4fjzJkzGDx4MMRiMV555ZWqHRUhWkcIoLxsnXlCCNGbBr2M9/NTpp8n9b+1/JaV5zB0d+PbUSGpeHQjGSKRAdoM9nvu8/NkefjwyId85RGrwb6i5wp4W3lD23hYeGBB5wX4q8dfqGVdi3+wZ/1TXtn9Cq4mCJ/VqsrYTMp7qIya2RJDpzZDnTbOkEhFvDk9y1BZ+b/T2Pv7DYTfSCrVtLji2DnR7q234PH7UhgYGyP75ElETnwXipycir2AkQVg7y9sx1BWCiFEC5z4Hkh7BFi6AV2+gDYrTkjRpUBKaaxBPWsCzAIqbDtXlotFVxZh5M6RuJl0s9Kv5+xjhSY9vPj2sTV3YfHGuzAwMkLuo0zkJBgC9w8iP1+YPjGUyOHXWMh+SXBojPyoFMiSk1V8hIQQojuU8oLHpb2kNS+QwhiJjfBz0M+wNLTEzeSbWHBpwQuf06y3cP1492wspH2H8u20MBMgrKgfKKn5gZSLFy+iSZMmfDCsVwnbnjVrVslj1q1bx8uvPCsQwrJNkpKSSr6Oiorij2XN5keMGMEbBAcHB8PBwaFqR0WIljIQ1cwTCiGEqAzLpIgoCqR4ta3SS8izspG+bRvfth39Kr9lK4HY5D9Tr6MbrJ1Mn/18hRzTT07H9aTr/IPyn93/hIelB7RZa5fW2Nh/I/7X8n+wkFrgTsodjNk7BjNOzeDlyV4GC3iwLJWur9fFuO/bI2h0ABy9LaFQKHm6+u4l17Hq8zM4vzMcsuzKLxgw79QJnn/9CZGpKXKCgxExYULFM1Pcmgq30Zcr/b6EEKJS8beAM78K231+FIK9WoydF3U5kFKMBVFW916NeR3mwc7YjmeRvrbnNfx65VfIFMWluCqmZT8fnoWZm1mI8yfTYT1sGL8/+bYFEH8DBfnCz8rQUAnfJsJcRYpdXShhgOwzRZ9dCCFEH8nkjwMphjWrR0ppbuZu/HzDrL6zmpdYfh7X2tZw8bOCQqZElEUjQCxCfqoh8s4dVNMeE40HUliDXxYkeXKsWLGi5DETJkxATk4OrKzKr9HNMk+++uqrMoGXmJgY5Ofn86AK+9rP7/krRQnRJcqiTBQRZaQQQsjzJdwG8tIBQ3PAufLlQZmMvXugyM6Gobc3TNsIZVXCriUhMSITUmMxWvR9fmbJwssLcSjiEC8hsrDzQvhY+UAXsIb0owNHY+fgnbyHCsPKnfTf2h+rb6+u9IRSeYxMJKjXwQ3D/9ecZ6qwjBWWuZKdXoCrByIRd8IcOxdex/2L8ZXKUjFt0QKey/6ByMICuRcvIWbqNChLlks/h2tRICWGAimEEA1itZ/2TOWlTVCnH1CnD7QdC4bXFCzg38+3H7YN3Ibe3r15uUvWkP6dg+8gJS+lwq8jlorQ+TWhhOfds3GQ93yFNblEdrwRclOkKJAJ/RSNjEW8X5ihiRiFEnNkWHgh+9iBajs+ov1OnDiB/v37w9XVlf8+bita0FOMzZmxxcesfL2JiQm6deuG+/fva2x/CVE1pYxlpIhrZLP5J3V074jh/sP59szTM5FZkPncxzfo7M5v71xIgVnbFnw7/eQNYQEh0TnU2YYQtZb2ov/lCCGkQmW9PFqxArtVeon0zVv4rfWwofxill28XtgTxu9jE/8mFs9uaH444jCW31rOt+e0m4Pmzs2ha+xM7Pi+r+6zmtfxzSrMwvwL83lD+gtxqqvjbudmznuosF4qPd+uD49AG96AN/ZBOg78fQv/zjyLq4ciUJBbsQCOSePG8PhtCQykUmQeOICEH3968ZNcmzwu7cWL2BNCiAbc2Qk8OgVIjIFe30EnKGtGRkpp1sbW+L7T9/ih4w8wkZjgfNx5jNg5AreSKl6LnmVg+rdy4tvnjqfBoldvvp1y1xwFMOPbhqZSiMQieATa8q+T7ViflPP88wbRT9nZ2bw/8JIlS8r9/vfff49Fixbh999/x7lz52BmZoaePXsirzK94QjRZjLWI0WY75IaCkHnmuyz5p/B3dwdsdmx+OHCD899LOvNaWplyPtLprUdw+9LfyCCMua6mvaWqBLN6hKiTlVsmkwIIXoj/NRLlfXKf/gQuayPm1gMywEDhJe8noSkyCxIjcQ8kPIs0VnRfFURM7buWPT17Qtd1sihEf7r8x9mtZkFKyMrPEh7gDf2v4Gpx6ciLjtOZe8jlohQq5kjer9XH85B2WjayxPG5lJkpeTj9KYHWDn9NM7teIj8nMIKZaa4fPsN305ZtgypGzY8/wnODdiyNyA7EUiPUtUhEUJIxcnygYPCuQNtJwHW2l0KsphSUZQpL6p5k/+9fHphbd+18Lb0RnxOPMbvH4+zMWcr/Pw2g2pBYihCbGg60jsJJUIzIo2RJxMCKcZmRvzWs54dv2UN52XJGSgID6+W4yHar3fv3pg7dy7v9/skFmD75ZdfMGPGDAwcOBANGzbEqlWreFWWJzNXCNHtjJSaX9qrmKnUFHPbz4UBDLD1wVaciTnz3GslltHP3E+0gthUDHm+GNn7XnCdQ7RSzf/tJkSbMlIojkIIIc/GVnIWZ6R4Va3RfPoWIRvFvGNHSB0dhWyU3eEladVsgr88hfJCTDk+hadmN7RviMlNJ6MmEIvEPPW8u2d3LL66GBtCNmBv+F4cizqGdxq+wwNGUrHqVo1JTJRo3scLLfr4IORcHK4djuTN6S/uCceNY1Fo0sMTjbt68vIpz2LVvz8KIiORtOhXxM/9BiaNGsM4oKip/JOkxoBjXSDuulDeS0cmMAkhNci534HUcMDcGWinO+eOktJeNSgjpTQ/az/81/c/fHLsEwTHBuP9w+/juw7foYd3jxc+19zGCE17euH8zjBcPJuDjh06Ie/kccgkJvz7hlZCQMWzrhBIYaW9CqRmyDl3DkY+ulEOlKhPWFgY4uLieDmvYqwMfqtWrXD27FmMGjWq3Oex0vdsFMvIyOC3hYWFfFRG8eMr+7yago5fDccvKywp7cUqsWjTz7q6jr+hbUOM8h+FtffW4pvgb7ChzwYYisuvfBDQ2pFfD8U9zEBgszYwOHkKGYdOwuj16v850e9/oUpfjwIphKixR4oBZaQQQsizJd0HcpKE0ijFTcQrQSmTIW37dr5tPXQIv310I5n3RpEYidG427Mn2X+//jtuJN2AhaEFLwuiyuCCtpQ7mdF6BobUHoJvz32La4nX8MvlX7DtwTbeoL6dW9UCV88iMRTzlVd127ni4bVEnNsRhtTYbARve4g7p2PRcZR/yUre8thPnMgzi7JPnETMZ5/Ce+NGiIyNy38w+13hgZQrQN2BKj0OQgh5ruxk4MSPwnbXWYCROXRGcfykBrdwZOf0JV2X4H8n/4eDjw5iyokpUCgVPGPlRZp098TtUzHISs1HctvRMGOBFLEQSDG2tSoJuNg5GyI5rgApNnVgf/48bJ4xKU70FwuiME5OQsm4Yuzr4u+VZ968efj666+fuv/AgQMwNTWt0r4cPKjfDa7p+Kvv+Nsmp5RkpNy6fQuFUXl6cfx+Sj+YG5gjIjMCM7bPQJBx0DMfa+xkjNxYKa5btkMjnELm7SRcYNeuUvVcd+r777+qUCCFELUoCqTU5CsVQgh5WVHnH/e9kAhlMyoj6+RJyBOTILa1hXmnTvy+y/sf8dsGHd1gYl7+CqG7KXex7MYyvv1lmy/hZi6kXtdErGfKqt6rsOvhLvx88WeEZ4Rj4qGJ6OLRBZ82/xSelp4qfT8DkQH8mjjCp5ED7p2Pw9ktoUhPzMXOX6+hdgsndHrFH0amT188sIUHrvPm4eHAQci//wDx8+fD5csvy38T9vtyaQUQTQ3nCSFqdupnID8DcG4INHoFuqSknUcNzUgpxlYHs54ps4NnY8v9LZh+ajrMDc3R3q39CxcEsKyUE+vu4eY9EdrY25ZkpBjbCYEUxrOhM5LjIpBiWw85F3dX+/EQ/TF9+nR88sknZTJSPDw80KNHD1haWlZ6RTabRO3evTukapq01SZ0/NV//IoHP5YEUpo2a4qOtVW7SEubj98k3ARfnPkCJwtP4qMeHz3zWjLWPx07F15HhswbMJVAkSNDkKkcpt2rdyEY/f4XYnvRYktVoEAKIWpkIBZSHQkhhJQjqqgRunuLKj09fctWfms1YABvWB4Xls7rm4vEBmj0jGyUQkUhZp2eBZlShm6e3dDTuydqOpGBCAP8BqCzR2csvbYU/935D0cij+BE1AkM9R+KiY0mwt7EXrXvKTJAndYu8G3kgPO7w3D9SBTuX4hHbGgauo2rCzd/1qi+LImdHVznf4fIN99C2tp1sOjaDebty7kocy3KXoq5ymrVUD8yQoh6ZMQCF/5+nI2iY397eGUvA/0oPczKXM5qPQu5hbm8vOXHRz/Gnz3+RBPHJs99XmA7F1zaG47s1HykdHkTsgfCojgjSyGgwrDsyisHIpBsG4jCu/+iMCYGUlfXaj8mojucnZ35bXx8PFxcXEruZ183btz4mc8zMjLi40lsIrSqk6Ev89yagI6/+o6/QKYoOaEYGxlr5c+5uo6/f63+2P5wO87HnceCKwuwsMvCch/nUccOlvbGyEjKQ7J7M9jdOwdRUoTaflb6/vuvKnrwsYkQLcpIKSrxRQghpByRRYEUj5aVfqo8IwNZx47xbavBg/gt68/B+LdwgplV+RkuK2+txJ2UO7A0tMQXrb+APmElT6a2mIpN/TfxlbksmLQ+ZD36bOmDJVeXIKsgS+XvaWgiQfthtTHks6awdDDhDem3LbiCq4cieD+bJ5m3awebMWP4dvycOVAUFDz9oo6BQjm4/HQgNUzl+0wIIeU6+SMgywM8WgG1Hvc+0BmKols9uTxhwZRv2n/Dz3d58jx8eORDRGVGPfc5EqkYTXp68e17Bf6Qmdny7dKZlC5+VpBK5Cg0tESmuTtyLl2q5iMhusbHx4cHUw4fPlwmu+TcuXNo06aNRveNEFWRy4tPKoBYzxYQs3m+z1t9zherscVpVxKuPPNxAa2FYGq0VauS0tREt1AghRA1oh4phBDyDPmZQMLtKmekZB48CGVhIYxq14JxQAAyknMRejmRf+9Z2SjRWdFYenUp357WcprKszB0RS2bWljabSmW9VyGBvYNkCvLxe/XfucBlTV31qBAXk7w4iU5+1ph5BctUKe1M6/Tf3rTAxxbfRdytprtCQ4ffQiJgwMKHj1Cyj//PP1irJ+NcwNhm8p7EULUIfURcGmlsN1lJpsdga55XNoLeoP1P/s56GfUs6uHtPw0TD46GTmFOc99Tr32rjCxNERWWgFyxRb8PiOTx4U9xBIR3LyFScNUmwAKpOiprKwsXL16lY/iBvNsOyIigk+eTp48GXPnzsWOHTtw48YNjB07Fq6urhg0SFj8Q4iuUxQ+XhAllehf8SM/az8MrjWYb7PyyeUtEGMCWgkZakmmtZFnZA0oKJCia2hWlxA1oGbzhBDyAtFs4kEJWHkCFsIHzMrI2C3UJbfs25ff3jgaBaVCCfc6NrB3FyY+nvTTxZ9QoChAS+eW6O/bH/quhXMLrOmzBguCFsDb0hup+an47vx36L+1P7be3wqZij/oGxpL0OX1QLQbVovPQd4+HYvdS65BViAv8zixuTkcp03j20m//4GCSCHTqPzyXhRIIYSowYkf2KwR4NMJ8OkAnaQsiqDo2eWJicQEv3T+BbbGtghJDcGXZ7585oRXSa+UHp5PZVeW5t5AWLCRZu2P3PNF/d6IXrl48SKaNGnCB8N6m7DtWbNm8a+nTp2KSZMmYcKECWjRogUPvOzbtw/GxsYa3nNCVEMhe/z5XaJnGSnF3mv8HozFxriaeJVnppTHysEELrWseBm0OKcWlJGig/TsYxMhmmWgD0WICSHkZcp6uTev9FNliYnIDj7Hty379EFBngy3T8Xwrxt1LT8b5ULcBRx8dJCnYLNsFCq9KGA/h25e3bB14FbMajMLDiYOiMmOwawzszB4+2DsC9sHhVKh0vdr3M0Tfd5rCImRGJF3UrH7t+tPBVMs+/aBaevWUObnI/67+U+/kFtRIIUyUggh1S0tEri2VtjuMgO6ivdI4Qu9oHeczZx5ZorEQIJ94fvw393/nvv4uu1deb+1YkamZQMpbvWEBSBpVn7IDXsEWWpqNe050VZBQUE8IPfkWLFiRcnnndmzZyMuLg55eXk4dOgQ/P39Nb3bhKiMQv74b6REop+BFEdTR4ypK5QkXnh54TMXodVpI5T3inNqDWWpABTRDXr4sYkQTRBOKqU/gBNCCCmn0XwV+qNk7NvPm4wbN2wIQ09P3DsXh4I8OaydTOFVz+6px7MPtSzTghnuPxz+NnQh+ySJSMJ/NruH7ManzT6FtZE1wjPCMeXEFIzYOQLHIo89dwVvZXk3sEf/SY0gNRIj6u7TwRQ2AeE8cwZv5px1+DByr18v+wKuRQ2D464DclrZRQipRmcXC6U4vDtU6ZylNfQ0I6VYM6dm+KzFZ3x7waUFCE0LfW4GpV9Tx5Kv2bmqNDtXcxhJCyCXGCPT3BO5V8qvj08IIfrQI0Ui1r/SXsXG1x/Pr5vC0sOw6+Guch9Tq6kjRIoC5Jg5IyXbVO37SF6Onn5sIkQzpb30cskXIYS8CJuQLw6kuLesclkvq359+eT+zZNCNkr9jm4wED0dwN76YCvupd7jDeY/aPzBy+59jS+BMq7+OOwdspenq5tLzXkplElHJuG1Pa/hbMxZlQVUXGtZo1+pYMrhVXfKvLaRnx+sBgzg24mLfi37ZLvagKEFwGrdJ4WoZH8IIeQp2UmPe6N0+BS6rOSvaznnSX3xap1X0c61HfLl+Zh+cjoK5YXPfGyrAT4QSQwA+zy8tvc1pOWllXyPfdZwdRWC+GnWtalPCiFE7yiL1z8p5ZCKpNBXFoYWPJjC/H3jb8gVT2ecsPKQlrI4vp2Tr78/K11Fs7qEqDMjRaSfKY6EEPJcKQ+B3BRAbPS4aXgFFURFI5c19hSJYNGrF+LDMpAclQWxVIQA1sj8CXmyPPx+9Xe+/W6jd2FtbK2yw6jJzA3N+c9r39B9eLP+mzzAcj3pOiYcnIA3D7yJqwlCc1VVBFP6vteQZ3A+uJiAC7vDy3zf/v33WL0AZJ86hZzLpcp4sR5kro2FbSrvRQipLsFLAVmu0JfJNwg6rSQjRXXZhbqGl1tqNxtWRla4k3IHv1377ZmPtXIwxdhv2mJnvcW4nnj9qZXGboEO/DbVujZyL1IghRCiX+Qy4VxioJRDrOfzXiMDRvLzyqOMRzjw6EC5jzGAkMGjkOvvOVhXUSCFEDWiZvOEEFKOyKLGrGwiXGJYqadm7t/Pb01btIDU0RG3Tkbzr2s3c4Sx2dMrfDbe24iE3AReH31EwAhV7L1eYRcFk5tNxp4hezA6cDRfccb6zYzZOwYfHvsQMTIhG+hluAXYoNOrAXz7wq4w3L8YX/I9Qw8PWA8ZwrcTFy4q+0SXRsLt/9m7D/C2yqsP4H/tYXnvPZM4y9mbQAgZJGEFKKOUDaWUUaC0BT5KocwWSikbWmaBskMCJCGBbLL3shPb8d5be+t73vdKsh3biZ1YlmWdH8997pV0Jb9XEpF0z3vOqTlw1mMghJAuzFpg57+F7dkPsLPwCGQudyClu8zNYKtp/5cZf+Hb7x5+FwXNBT3uGxKuQLOzkW+vKl3V6bbkCcLnVlt4NgxH8+G0Wn06bkIIGUxcTvdnicsJiSi4AykhshD8auSv+PbbB9/utr+k2J0X2p+lksnAoLO6hAwEd0kvMQVSCCGkK29Zryl9vqtu7Vq+Dl24AGaDDYW76/nl0ecmd9nXaDPyFGvmN3m/gVzSt6ANaRejisFDUx/C90u/xxXDruA/mLZUb8Hr+tfxx81/RGlb50ySvho1Kwnj56fx7XUf5qO1ztj+t+/8DUQyGYw7dsCw0x2E6xhIYX1SCCGkv+39ALC0ATEjgBFLEOhc7oz5YA+kMPPT5/OFnex6avtT3Z70YqwOK0wsIwngWSlVemHyBhOdGg6FxCT0SVElwVLQc0CGEEKGGoejPdOC9VoMdr8c+UteErmotQjry9efIiOl+88bMnjRWV1CfKxjhJkyUgghpBtV7hIYKZP7dDdbXb1Q1osFUi64AMd21MJhcyI6WYP4zLAu+39S8Amazc1IDU3FJTlCrw1ydhI1iXh85uNYftlyLEpfBBFE+LHiR1y+4nK8uu9VXkrtTM1Yms2zU+xWJ9a+e8TbxFKWmIjwK4SslOYPPmy/Q0KesK49zH6VnOWREUJIBw47sONtYXvGXUI5wUDn/okS5BOHvf405U9QS9U40HAAywqXdbuP1qrtdPmHUiEr1hOQSo7Xt5f3OkBBfUJI8PCWqHI5KJAC8F6c1+Zey7ffPvR2l8wTkftDmH6yBJ4h8A2QkMHN5ewQYaZm84QQ0pndAtQdEbaTJvTprvp1P/G1atw4SOPikP+zUFZq9OwkXve8I4PNgPcOv8e3Wa+PYG6C6AvpYel4etbTuDv0bsxMnAmb04a3Dr6FpcuXYnPl5jN6TLFYhHk3jYRCLUV9mQ67O/RLibrhBr7Wr1sHa3m5cGXMMECqAmwGoe8OIafwxhtvIC8vD2FhYXyZMWMGVq1qL9VjNptx1113ITo6GhqNBldccQXq6trLzJEgU/Ad0FYOqKOBvKFRFtLlPhVAGSmC+JB43DX+Lr79z73/RIu5pcs+bSwjqYPVJas7XU7KCeXr1ojhMB2iQAohJEi4XHC4S3uxTItgL+3lcf2o66GQKHC06Sj21e/rdJtI5C7t5aTSXoGGzuoS4msdUvVEEvpAIYSQTuqPAk4boIoEItLPrKzXgvlorNCjqcoAiVSM4VPju+z75fEv+UzSjLAMLM5c3G/DJ53FS+LxypxX8OKcF3nd+Up9JX7702/xyOZHoLPq+vx4mkilt1/KnlWlqD0hnMRSZGUhZPZs/sOt5eOPhZ1ZY8v40cI2lfcip5GSkoLnnnsOe/bswe7duzF37lxceumlOHJECOzef//9+Pbbb/HFF19g48aNqK6uxuXu/jwkSJvMM5NvAWQqDA2eZvMUSOlYimV45HAeMGFZlT0FUiIVkfxEIWtQz5oJeyRPbO+TYjx4aABHTgghfuR0wOESt/dICfJm8x6RykhclHUR3/4o/6PuM1IokBJwKN+KkAHMSKEeKYQQcpJq9+ycxPF9atzraG2FYYfQHyN03jzs3F7LtzPHxUCh7pxtYnPY8OFRoQTUzWNupi/3PsaygVit+ZlJM/H6/tf5D4dvT3yLPXV78OzsZzExfmKfHm/Y5HiUHmrE8R112PDJMVz1yBSerRJ1w/UwbN6M1i+/Qsw990Ci0QCJeUDVbqDmIDDmCp8dIwl8F198cafLTz/9NM9S2b59Ow+yvPPOO/jkk094gIV57733MHLkSH779OnTu31Mi8XCFw+tVigDZLPZ+NIXnv37er+hZLA8B6LqvZBWbIdLLIN9/I1sQEPi+D3N5lkgxd/P8WB6/f8w6Q+4/cfb8VXhV7h2+LU849Kj2djM18maZOTKc7GtZhtWFq/EbWNu49eHZqRAJiqATaJCS6Md5sYmSMK7lhoNpPe/vwTrcRMSkJx22Lynl52QiuhUs8d1I6/jnyc/lf+Ean01kjRJ/HoxZaQELHp3E+JrHQIpIjp5RwghnVXvP6OyXroNG3hXQ8Xw4ZCkpOL4qz/z60dMT+iy73cnvkO9sR5xqjjvrCDieyGyEPxhyh94UOWhzQ/xpry3/HALfj/59/jVyF91Kb92Kuf8YhjKDjWhqVKPI5uqMHZOCkJmzYI8MxPWkhK0fb2MB1ba+6RQRgrpPYfDwTNPDAYDL/HFslTYSbx58+Z598nNzUVaWhq2bdvWYyDl2WefxRNPPNHl+jVr1kCtVp/R2Na6M++Cmb+fg0klryMFQGX4VOzdvHfIHL/nJ0prWwtWrlyJwcofr/8I6Qgcsx/Doz88imtDhBr3zF6r8Ppb2iwYJhvGt786/BWSyoUTY0ykqh71xmy0hWVi83vvwThc2C9Q3/+EEHJaThscLs+5LspI6WhY5DBMS5yGHTU78GnBp3hg8gMnZaT4eYCkzyiQQoiPuTqW9qKMFEII6azGE0gZ36e76db+yNeh8+ej4kgzTDobVKEypI2K6rSf0+XEe0eE3ii/GvUryCXy/ho56aXxcePx5cVf4qkdT+H7E9/j77v+joLmAvx5+p+hlCp79RgqjRzTLsnCpk+PY8eKE8iZHMevY8GT2if+yst7RV7/K4g8gRSWkcKaOvYhWEOCz6FDh3jghPVDYX1Qli1bhlGjRmH//v2Qy+WIiIjotH98fDxqa4Xst+48/PDDeOAB4QeyJyMlNTUVCxYs4H1Y+oIFctgJ1Pnz50MmC86eToPhORCVb4V033a+nbD0r1icOG7IHP//vnyXr6NiorF48eAreenP139463Bcs+oaHLEdQcrUFOTFCJ8tzQXNwF4gOzkb906+Fyu+XoE6Zx3Gzh6L1NBUvs+e0o9Rnw9owzJxjkqFqDN8bgfD+9+f2PEvX77c38MghPSG0w6HS9rebJ4yUjq5fuT1PJDyZeGX+M2430AtU3fokeLv0ZG+onc3IT7mQsfSXnRChxBCOjeaP9rnjBSn2QzDz0IGSui8C7Bns3Bic/jUBIglnQPWGyo2oKStBKGyUPxi+C/6c/SkDzRyDZ4951mMiR6DF3a/gBXFK1Chq8CrF7yKMHnvTjCPnp2EI5ur0VSlx47lJzDnulyEX3IJ6p5/AdayMpj27Yd67CjWkAwwNgK6GiCsfZYwIScbMWIED5q0tbXhyy+/xI033sj7oZwphULBl5Oxk6BneiL0bO47VPjtObCZgZXuwNikmyBLmzzEjl/4vBRLJYP6PeaP139k7Ehckn0Jvin6Bq8ceAXvLXyPZ1Hq7Xp+e4QyAjGaGEyOn4wdtTuwuWYzboy6kd+WmJsA5LM+KVmwHtl41mOnfwMIIYOegwVSPL/BnBCLaAJxR7NTZiMtNA3lunJeKeGqEVd5S3tRZa/AQ+9uQnyMMlIIIaQHdUfcjeajgHBhJmdvGHfsgMtshjQhAa7UbJQcbOixrNd/j/6Xr38x4hf8ZD7xH3YSimUFvTX/LYTKQ7Gvfh9uWX0LGk2Nvbo/C5Kde81wvn1kSzWaawwQh4QgbMECfl3bN98ITaBjhrdnpRByCizrJCcnB5MmTeJlucaNG4d//etfSEhIgNVqRWtra6f96+rq+G0kSGx6HmgqAjQJwLyuJdsCncvdbF4spYle3blr/F2Qi+W8vxcLljBai9D3KEwhTAA4P+18vl5Xvs57v4TxY/japIpF25FiuFh2JCGEDPWMFLSX9upL+d5gwAJL1+Rew7e/PP5lp9JelJESeOisLiG+1uFfRgqkEEJID2W9+vCFW++eMa457zyc2NcAp92F6OQQxKR0DpQcbzmO3XW7IRFJcG1ue41z4l+sTjCb3RutjMaxlmO4afVNvIdNbyQNi0DmuBh2BhC7V5by68Ivu5SvtatW8Wwl3nCeqT3ku4MgQ5LT6eTN4llghc0A/+mnn7y3HTt2DOXl5bwUGAmSQP/PLwnbS14AVJ3LvA0Nwueu6KRMTiJICEnAFcOv4Nv/Pvhvvm6ztvF1uDycr+emzuVrNjGgydTEtxXxKYiUVfPtZkc47DU1fhk/IYQMbGmv9kAK6erirIshE8uQ35yPI01HIBJTRkqgom9NhPiYy+7wboullJZNCCFe1fv6XNaLzezUb3AHUuach6I9wgn4YVPiu8x+Yg39mLlpc/kJETJ4jIgagQ8XfYhkTTLKtGW4Y+0daLMIJ6hOZ8qSTL4u3F2HlloD1FOnQpqUCKdOB/26dR0azh/w5SGQAMf6mWzatAmlpaW8Vwq7vGHDBlx33XUIDw/HrbfeyvudrF+/njefv/nmm3kQpadG82QIYRkEK//ITwwh9yJg5MUYilzuUwEUSOnZzaNvhlQsxc7andhfv9+bkRKuEAIpiZpEjIwaCRdc2FjZXhYwIVrYj5X3Mh2k7EhCSBA0m++QkUK6YiUh56fP92aliCkjJWDRtyZCfI0yUgghpHvV7oyUxN43mrcUFsJWXQ2RQgHR6EmoOtbCr8+ZFN9pP61Vy2vQMpSNMjilhaXhPwv+g1hVLIpai3DXT3fBaDOe9n6xaaHerJRd35fyz1bWK4VpZY1pPRkpVNqLnEJ9fT1uuOEG3iflggsuwK5du/DDDz/wxs7MP//5T1x00UW44oorcO655/KSXl9//bW/h00GwtFvgLItgFQFXPgchi4KpJwOC5SwXinM2wff5t8tmI69vS5Iu6Brea80oVcSazhvPnx4gEdNCCEDzOmgjJReuHL4lXy98sRKuDzN5ikjJeDQtyZCfMzlbM9IEVHTLULOCqthP2XKFISGhiIuLg6XXXYZL7fSkdlsxl133YXo6GhoNBp+EozVtSeDDGviW9/3RvOesl7qaVNRmq/lXz7j0kMRHqvqtN+KohUw2U3IicjhzWDJ4JQSmuLtmXKg4QD+uOmPcPZiatbJWSnhlwjlvQxbfoZd6m4w31oGmDr3uCDE45133uHZKKyUFwuq/Pjjj94gCqNUKvHaa6+hubkZBoOBB1GoP0oQsBqBNX8Wts+5D4joff+uQONyZ3Gy/lOkZ7eOuZXXt99ctRmHGg91ykjxZL0y26q3eScDJIwU3jfa0HQYjxb4ZdyEEDJgHDY43YEUl4gCKT1hv0nTw9JhtBuhdVn5dS4X9ZMJNPStiRAfczo6BFLEnig9IeRMbNy4kQdJtm/fjrVr18Jms2HBggX8JJfH/fffj2+//RZffPEF37+6uhqXX365X8dNulHPGs3bAXU0EJ5yRv1RPGW9sifFddqHnYj/9Nin3mwUang4uA2LHIbXL3gdComCl0Z588CbfcpK2bO6DIqsTKjGjQMcDrT9tAUITxN2pD4phJC+2Poy0FYBhKcCM+9FMJwKEEvp98npsicvzLiw03UdAylswkZqaCqsTit+rv6ZXxc5ehzk0MMpkaOhtJUazhNChjan3RtIoYyUnrHfpFcME3pvNbtMfE09UgIPBVII8TGXs/2DREylvQg5K6tXr8ZNN92E0aNHY9y4cXj//fd5819Wv55pa2vjs4xffPFFzJ07lzcMfu+997B161YefCGDiOcEd+K4Xjead7S1wbRPKAcmnngOqgqFbIOckwIpO2p28L4bGpkGF2Vd1N8jJz4wPm48/jxdmAX+xoE3sKFiw2nvM/HCdG9WilFrRdiSJfyybu2PHRrOU3kvQkgv6WqBLe4G8/P/CsjVGMo8PVLEEgqknM4tY27pMZDCToydl3Ie395cuVm4LiweCaoyvt0iioG9Xpj4QQghQ75HirtkFekeKxcpFUlhgI1fdjlpwl+gkfp7AIQEVUYK/VAhpF+xwAkTFRXF1yygwrJU5s2b590nNzcXaWlp2LZtW7dNgllZF7Z4aLVC/Wv2OGzpC8/+fb3fUNGX4xdXH+Rftx2xo+Ds5fOlY9koDgfkOdkoqeJngRCXEQpVmLTT3/z6uNDHYFHGIsggG7DXg17/szv+xemLcbD+ID4v/BwPb34YH1/4MZ/l25PoFDVi0zRoKNfj0KYKjJ1zHvDMMzDt3QvLL64Aq1DvrN4PB73+AyaYj50MARv/DthNQMpUYPRSvw7FodfDcuIENIcOoc1ghNhug8tqhUihhDgkBJLICMhTUyFLToZY1bm0Za+5JzGIpDTR63RGRI3A6OjRONJ0pEuPFObclHPxUf5HvPwXyz5hwZX4eAvKSwFdaBrMR49CFt+5lxshhAwZTgecnnn6VNrrlKJV0ZidMttbAo2erSAIpGzatAnPP/88P1lVU1ODZcuW8Rr1Hmym8AcffNDpPgsXLuSziE+F1SBmj1tbW8tnGb/yyiuYOnVqX4dHyKDjcrUHUsRU2ouQfuN0OnHfffdh1qxZGDNmDL+OfYbI5XJERER02jc+Pp7f1lPflSeeeKLL9WvWrIFafWazUVnZsWDWm+OfdXwLYgDsr7GhcuXKXj1u/OdfgM0BrU1KxtGfWG8cKSzKBqzscH+T04QftT/y7ZiamE63DRR6/c/8+Ee5RiFNkoZyWznuWXkPbtPcxmvT98QeIQXKVdi3tgQ1NgPSU1KgrKzE4Y2lmBQO6Aq3YcMAvweC/fUnJCA1nwD2un/DzvtLrzMl+4tDb4B+/XoYd+6AcdduWEtL+fWs41PDae4rS0+DavRoKPPyEDJzJhTDhvWqpKUnI0VCpb165fpR1+OhzQ/xbblE3um2SfGToJKq0GhqRH5zPkZFj0JcehjAAynpMOfnI/T88/00ckIIGbgeKXymGzmlS7MvxS4IvxeclJEy9AMprA49C3TccsstPdacv/DCC3kpFQ+Fgs0J7Nlnn32GBx54AG+++SamTZuGl156iQdfWANh1kyYkEDmcrTHmKlHCiH9h/VKOXz4MLZs2XJWj/Pwww/zz6COGSmpqam890pYWOcZh72Zjc1OorKGxTKZDMGm18fvckF69G6+mbfgOuTFjTrtY7MZnqX/eBEsNJ19xXXY/42dX7/k2tnQRCm9+312/DPYd9sxLGIYblt024D2R6HXv3+Of7J+Mq5eeTXK7eVozmrGDSNv6HFfh82Jjx/bCbPehpHJUxBx+VI0v/wKYlpY7RUgzFKNxQvmAtL294ivBPvr73kOli9f7u9hENJ3658V+nZlXwBknDMgf5J9rhm2bkXrF1/yIIqrQ3YsI4mKhF4TipisLEhCQiCSyeA0m+E0GGBvbIStshJOnQ62snK+aFeu4veTxsYiZNYsaOacB82550Lcw6QQlztITT1Semdx5mI0mZqQqEnschsLrExPnI71Fet5eS8WSIkdmQVsBAzqeBiO7kasX0ZNCCEDwGmHyyWcXnZRaa/TYlmMe0VreczJ7KKclCEfSFm0aBFfToUFThISEnr9mKyW/e23346bb76ZX2YBle+//x7vvvsuHnpImPVBSKByOjuW9qLUeUL6w913343vvvuOZ0mmpLQ3KmefPVarFa2trZ2yUurq6nr8XGKfWd0F/NmJ0DM9GXo29x0KTnv8reWARQuIZZDFjwSkp3+uLEVFcNTXQ6RQoFGRDriKecPxyPjQTvutOLGCry8fdjnPTvIHev3P7vjTI9Pxhyl/wOPbHsfrB17HnLQ5yI7I7uFvAaNnJ2HPqjIc3VyLxZct5IEU4579cOREQ2Jvgqy5EEieiIES7K8/IQGn7ghw6Ath+4LHBqR/om7NGjS9/W9e8slDnpkJzdzzoZ48GeoJE+AMCeFZlWMXL+7x3xR7czPMR/NhPnIExt27Ydy1C/aGBrR98w1fRCoVz4QIW7IYIbNnQ9zpc5ECKX3BJmbcMLrnwD4r1cIDKVWbcce4OxAybALUWA+jKAoNJc3IGNDREkLIAHLa4PT2SKHAwOnIJDIoWP9kB+BwUUZKoPFJj5QNGzbwTJLIyEje7Pepp55CdHR0t/uyE16sTBibEdyxITerb8/q2XenP+vZe+7XcR1s6Ph9e/xWi9W77XANvueZXn86/kDCZm/ec889vKwk+6zJzMzsdDtrLs9ONvz000+44oor+HUsu5E1pJ8xY4afRk26qD0srGNzAWnvgh2Gn3/ma3aC6dARocl81nhWHKxdQXMBL6khFUuxJEtoPE4CEwuE/Vj+I7ZUbcGjWx7Fx0s+7rHE15hzk7H3h3JUF7ZCrxrOT0ZaS0qg16UjXNUE1B4a0EAKISTAbHhOKEUy6jIgabxP/5TpyBHUPfkUTPv388ss0BFx+eUIv3wplKNGdcqi7E3/MGlUFDTnzOIL7vg1nBYL7xOl37yFB2tY1op25Uq+SMLDEXbpJYj8xS8gz86Gy/23JFJqm9ofZifP5uuDDQfRYm5BZEg04lRVKDVFocUSAodWC0kfM50JISRgeqR4SntRIKV3xC4eSHGBAimBpt+/NbGyXqzkFzu5VVxcjEceeYRnsLCgiKSbRtuNjY1wOBy8fn1H7HJBQcGA1bNngr2mNR2/b45fVF/NWhTy7R9/Wgel5AwbQvoYvf7BffyBVM7rk08+4aVjQkNDvX1PwsPDoVKp+PrWW2/lpbpYA3pWmosFXlgQpbtG88RP6tyBlASht01v6Ldu5Wv5tFmoOMjqNgGZ4zoXylhWuIyvz089H5HKyP4bLxlw7GTiEzOfwKXfXIrDTYfxTdE3PLjSHU2kEuljolF6sBHHd9Qie/58NL39NnRlEoTnAqhvn/FNCCGdNBwD8r8Vtuf4rhKC02RC/Qv/QMsnn/DyliK1GtE33YjI66+HNLL/Pq/ECgVCZszgS9wfHoT58GFov18J7apVsNfVoeXD//JFOS4PrpBrhfvIKCOlPySEJGB45HAcbzmOrdVb+YSOuAQ7SksArSYN5oIChFAPWELIUOS0d8hIodJeveJ+nlwuqlqDYA+kXHPNNd7tsWPHIi8vD9nZ2Xzm8AUXXNAvf6M/69kzwV7Tmo7ft8ffeOQAKvYIWVMXLrwQankIBhN6/en4A6me/RtvvMHXc+bM6XQ968t100038e1//vOfPLORZaSw7EXWc+v111/3y3jJaQIp8aN7tbvTaoVx5y6+3ZI4Ho69LQiLUSIqqf3fU5vThlUlQn34pTlLfTFqMsDi1HG4c9ydeH738/jX3n9hXvo8hMm7/543YlqCEEjZWYdx117AAyn6/Ho4hwFiVraHEEK6s+WfQjZK7kVA3Eif/AnzseOo+v0DsBYV88thF13EgxyykyYS+iIgrRo7li/s7xm2bEHrl19Ct249zAcOwjXrOr6fuJvJjuTMs1JYIIWV92KBlFjWcL6ENZxPgyU/nwIphJChyWGDy5ORwjItyOm54yeUkRJ4fJ7Hm5WVhZiYGBQVFXUbSGG3sUwVVr++o4GuZ98f9w90dPy+OX4Jq33o+Rty+aB9jun1D+7jD6TSXqejVCrx2muv8YUM8tJe8b3LSDHt2w+XyQRJTAzKGoRSYJnjYzuVQNlevR0tlhZEKaMwI4nKuA0V1468Fl8VfoUTbSfwxv438Kepf+p2v4y8aMhVUuhbLGiSjYQkNgaOhkaYGuUI0RzhM8DR4f1CCCFoKQMOfi5sz26fpNefWr/5BrWP/QUuq5V/hiU995xQhmuAiSQSaM47jy+sh0rrsm/g3CWc9BKHnHlFB9K1T8o7h9/Bz1U/w+lyIm5UNrABMKrjoDuyHlH+HiAhhPg4I8UlptJevUIZKQHL569YZWUlmpqakJiY2O3trBEsq2nP6tl7OJ1Ofpnq2ZOhgDWUdG/0WN+dEEKChtUANJ/oUyDF0x9FNX0myg438e2sk8p6rSxZydcLMxbyHilkaJCJZd7gyf8K/ofiVmFG98mkMglyJsXx7eO76qCZKZyoNNQqAVMzoO88YYcQQrD1ZcDlALLOB5In9fv3//p//Qs1Dz3Mgygh552LrOXf+CWIcjJpbCxifn07rHKJ999P0j/yYvMQIgtBq6WV92xTZ4+D2tUEiMRoKBa+vxBCyJDjtMNFpb36ROTO3KGMlMDT5zMNer2eZ5d4lJSUYP/+/bwWPVtY7xJWToVlk7AeKX/84x+Rk5PDS6t4sMyUpUuX4u677+aXWZmuG2+8EZMnT8bUqVPx0ksvwWAw4Oabb+6v4yTEb5wOh3vL1Wn2NCGEBKX6fKGMiiYe0HQOhvTE4O6PYhh5Diy77FBqZEjIDvfebrQZ8VO5MCFjceZiHw2c+MvMpJmYmzoX6yrW4ZV9r+Cl81/qdr8R0+JxdEs1ivfWY/ycWcDy5dA3hiEOWqGcXGj3mc6EkCCkrwf2/lfYPvfBfn1ol82G6ocfgfa77/jl6DvuQOzv7oWoQ5b6qRjaLGgo16GlTo/WfAXWNx6D0+6C3e6EVCaGTC6BIkSG0CglQqOViEoMQXisCiJx335niNyzYCViCqT0Fxb8n5IwBRsqNmBb9TaMHnsb4lQVKDVHo0krhdNi4X1sCCFkyAZSaO5w73g/sukc4ZAPpOzevRvnn3++97KnVwkLhLDa9QcPHsQHH3yA1tZWJCUl8b4lTz75ZKdSXCzAwprMe1x99dVoaGjAY489xhsHjx8/HqtXr+7SgJ6QQOSC0xuYF9E/koSQYFd7qE/9URytrTAfEXpc1EvTADQhY2w0xB1OGG2s3AiT3YRkTTLGxY7zzbiJX/1u4u+wvmI9D5gdbTqKUdGjuuyTmB3BTyzqms1oCBN6HVganLCbxZDWHQVy5vlh5ISQQWn3e4DDAiRPBtJn9WsQpeqB30O3di0glSLxiScQccXlp7yPw+ZERX4zivfVo7qwFdpGc4db5SgsrT/t35UqJIhN0SB5RCRfErLCTptpInIJn6MUSOlfMxJn8EAKKzl6GwukxFtRWgboNKmwlpRAmZvr7yESQkj/ctjgdLlPL1OPlN7xZqRQ5GnIB1JYg99T1aj/4YcfTvsYpaWlXa5j2SmeDBVChhKX3fP/C0vao0AKISTIeRp/97Ksl3H3bt7fQp6VhYoTJn5d+piYTvusPLHSm41CmX9DU1ZEFhZnLcb3J77nvVJeueCVLvuw2djDp8Vjz6oyFOUbMGrkSN7c11CrQDg1nCeEeNitwO53hO3pd/Zb/yRWwqvq9yyI8iNEMhlSXn2F9yTpSWudEQd+quDlCK0me/sNIghZJnFKNLTVYHTeCChUMkhkYh50sVkcMOms0DVboG00obnGALvFgZriNr7sXlkKiVSMpGHhyBofy3uKhYQreg6kSOgkTn/y9GnbW7+XT/KISw8FWCAlNBWWwkIKpBBChh4n+wwTPkuomn3veJ4nl/uzmAQOKiJOiI85We1ljqekEEJIcGMllpiEsb3a3bBzJ1+7Jp3LTzqxk+Wpo9rbtbaaW7GlagvfXpK1xBcjJoPEb/J+g1Ulq7ChcgOONB7B6JiuWU3DpgiBlMr8FkyYcU57IKWeAimEELcjy4S+SaGJwKhL+60nSvVDDwtBFLkcKa+9Cs3s2d3u21Slx/blJ1B6qJH/PGBCwuXInhSH9DHRSMgMh1wlhc1mw8qVpRg3LwUymazHv+10ONFab0LtiTZUHWtB5bEWGNusqMhv4cvGT48jMSucP/7wKfFQhcr5xEiR+6SXREIZKf0pIywDCSEJqDXUYk/dHkwakQZsYg3nE6DPP4jwi/09QkII8V2zec+K9DKQQpGngEOBFEJ8zOVydphgRpEUQkgQYxmt9UeF7Tih9NLpGHcIgZSWhPFAAyvfFA6Fqv3rCyv1ZHfZMSJyBLIjsn0zbjIoZIRn4KKsi7CieAVe2/8aXp/3epd9PL0C2hpMaE2dCjH+zQMprvpjEDlsgKTnk5GEkCD5HNrxhrA95dZ++zeh4cUXoV25kpfz6imIYtRasePbE8jfUs2HwWTkxWDc3BQkD4/sc48TD7FEzP/tY8uoWUk8SMImHpQcaMSJ/Q2oK9F6s1W2flmEtDHRGDGtvWeUlAIp/YplxrLyXsuKlvE+KefkXAWVcxdM4ig0FtUh2d8DJH7hcDjw+OOP46OPPuLl7FkZ/JtuugmPPvooZVOTwEc9UvrO+zzRExZoKJBCiI857UJGisjlgpiizYSQYMZmAJvbhCk40cNOu7u9pQWWY8f4dq2VZaHo+GzdjtaWreXrhRkLfTRoMpjckXcHL++1uWozCpoLkBvVuUQKOxnBytjsX1uOKkM40pRK2M1mWJqdUDYVA3FUUoWQoFaxE6jeB0gUwKSb++Uhmz/+GE3/EUqFJT39VJcgCgtsFO6uw6b/HYfFKJTwyp4Yh2mXZCIyIQT9jf07yB6XLRMXpkPfYkbxvgYc31GL+jIdSg828sWDAim+Ke/FAyk124DJDyJKugxVzig01Vn8PTTiJ3/72994T2HWT3j06NG89/DNN9+M8PBw3Hvvvf4eHiFnx2HzBlJE9JHSK+znMJtTQT1SAg+9YoT4WoeeQpSRQggJag0FwjoqC5Ape9cfhWWI54xA9QkD3+4YSGmztGFHzQ6+PT99vm/GTAaVtLA072v936P/7XafrHFCD52yIy1QTp3Kt1lWiresHCEkeO18W1iP/QUQ0rnf1pkwbNuGuqef4duxv7sX4Zd2LhVmNtjww7+PYO07R3kQJSZVg6UPTsSFvx7jkyBKdzSRSoybm4pfPDwF1zw2FRMWpEEdLue32cRWyGQ0t7K/TU+czn/3FbYUotHchNgYI7++zRUOh17v7+ERP9i6dSsuvfRSLFmyBBkZGbjyyiuxYMEC7HSXsCUkoDkd7RkpEjrn1Svu54kCKYGHvjUR4mMup8P9v5qL0nYJIcGtQcguQWxun8p6GfMugL3ZiZAIBaKS2k88bajYwMt6DYscxss+keBw/ajrsbp0Ne+Xcv+k+xGj6nwyND4rHKpQGUw6Gwyj5kC8aROM9QpEe8rKEUKCk6EJyF8hbE+97awfzlZTg6oHfg84nQhfuhTRv/lNp9ubqvVY+cYhaBtMEItFmLQ4A5MWpfu1uXt0kgYzL8/B9EuzcOVbN6DF1YRL5K/5bTxDVaQykmdM5jfn8/JeuekaoB7QhyTDWlQE1fjx/h4iGWAzZ87E22+/jePHj2P48OE4cOAAtmzZghdffLHH+1gsFr54aLVavmb9k9jSF579+3q/oYKO37fHL7az96nCfWHwPc+D8vX3nhoU+Xxcg/L4B1B/HzcFUgjxMaezvUcKIYQEtfp8YR07ole7G92z9JoicoFmIRulY0DaU9ZrfhplowSTvNg8jIsdhwMNB/Bpwae4e8LdnW5nJyxZ34H8n2tQJ8tAInsvNcjhqj1MeaGEBLODnwEOK5CQByRNOKuHclmtqLzvPjhaWqAYNRIJf3ms0+cT603y43tHYbM4EBqlxIV3jEFcehgGC9ZXpSaiGHqbHhKqw+IT05Om80DKztqdmJWdB+wCDJpkmI4XUiAlCD300EM8EJKbmwuJRMJ7pjz99NO47rrrerzPs88+iyeeeKLL9WvWrIFarT6jcaxdK3x3DlZ0/L45/pHVBXCJJvJtvVGPlaxn2CA0mF5/o9kAFTtfCPGAPV+D6fgDGQVSCBmg0l6iDk3nCSEkKPUhI8Xe3AzL8eN8u7qNfc20In10e1kvvVWPrdVb+TaV9QrOrJQDGw/g82Of47axt0Ep7VwqLmtcLA+klFc4kKRSwGmywJJ/FKcvKEcIGbLfx/d+KGxPuvGsH67u+RdgPnAQ4vBwpLz8MsTK9n9djmyuwoZPjvHi58kjIrDw9jFQaYRSWoOJwyX0caRAim9MTZiK9w6/h121uxAx4xqIXRVwSBRoPnoUrOsbCS6ff/45Pv74Y3zyySe8R8r+/ftx33338abzN97Y/b9JDz/8MB544AHvZRaISU1N5SXBwsLC+jwjm51EnT9/PmQyGYINHb9vj1+8bhd2bhayLcMiw7B48WIMJoPx9X8nfxsczWxL7PPnazAe/0Bix798+fJ+ezwKpBDiY5SRQggh7pNYDfm9DqQYdwn9URy5k6BtsvIsg5TcSO/tGys3wua0ISMsA9kR2b4bNxmULki7AEkhSag2VPPm81cMv6LT7ey9IlVIYGi1wjr+fMi2rYaxpAlKcxugDPfbuAkhflK5S/gMkqqE/ihnQf/zz2j5r9CjKelvz0GekuK9bf+P5fj5yyK+PeqcJJx77XC/lvI6FQcvP0yBFF+ZEDeBP7dV+irUhoQiwlWFZlEmGksakOPvwZEB94c//IFnpVxzzTX88tixY1FWVsazTnoKpCgUCr6cjJ0IPdOToWdz36GAjt9Hx+9yenukiGWSQfscD6bXXyIRgX8Ki8QDNqbBdPyBjAIphPiYyxtIaW86TwghQcfQCJhahIKwMcN6XdZLm3se0Mr6XoRBrmr/2vJj2Y/ebBTqPxV8pGIpfjnyl3hh9wv4/PjnXQIpUrkEaSOjeHmdlrTpiNu2GqYGhVBeLm2638ZNCPGTvR8I69FLzyqY6mhrQ80j/8e3I6+7DqFz5nhv27O6FNu/OcG3WUP3GUuzz+rzqd5Yj8PWw6g4VIEqQxWq9dXQWrXQWXWwO+3830GZWMb7cUQroxGnjkNmeCZfRkaPRJTy1HkPTne2vERMgRRfCJGFYHT0aBxsPIjdjfsRrWlGszETza2DM7BGfMtoNEIs7vzasxJfNOmSDAlOO+AOyrPSkeT0RFLheaJm84GHAimE+Bh9OSKEELRno0RmADJWquvUjHv38nWzOpMHUlJHtp8QMtvN2FK1hW9TWa/gdUn2JXhp70s42nQUBc0FvLFvR6kjI3kgpUEUjzhvn5RDEFEghZDgYtYCh78WtifecFYPVfvXJ2Gvq4M8MxNxD/7ee/3hjZXeIMq0S7J4U/m+BlFYcGRP3R7e/4t9xrFMBu7Qqe9Xqa/s9vr0sHTeT2p83HjMTJqJZE1y57/nsvO1WEQncXxlcsJkHkjZWbMTV6ZGofAYoJPFwd7UBGl0e7lSMvRdfPHFvCdKWloaL+21b98+3mj+lltu8ffQCDl7Tps3ICB2BwjIqYkkwncEF30GBxwKpBAyQD1SKCOFEBLU+tAfxaHTwXLsGFwQobaFpR87kJLbHkjZUbMDZocZiSGJXU6ek+DBZmHPTZ2LNWVr8HXh13hk2iOdbk8dJbxnGhpcsMuUgMkMW/4eyKfe7qcRE0L8In8FYDMC0cPOKiNNu2YNtN9/z6aRI+nvf4NYJUwKOL6rFhs/FXp6TV6cwZe+qDPU8cy6r45/hSZzk/d6FuCIF8djavpUZERkICU0BRGKCITKQnk2CguEWB1WtJhb+P1YxkppWymKWotQqi1FmbaMLyuKV/DHy4nIwXkp52FO6hyMiRnj/TtSEZ0S8JUpCVPw7uF3sbtuN+7Mvh44BuhDkmApLKRASpB55ZVX8Oc//xm//e1vUV9fz3uj3HHHHXjsscf8PTRCzp7TDpf7s0Qko8BAXwIprEcKCSz0rYmQgSrt5Q2oEEJIEGooENaxI067q2n/AZbOB3POFFhMDsiUEsRlhHpvX1+xnq/ZCSEq6xXcrhh2BQ+kfHfiOzww6YFOTefDY9UIi1FC22iGMXc6wg5tgPHAYQy+ls+EEJ86+LmwHnc1cIafGQ69HnVPP8O3o2+/DaqxY/l21fEW/PRePp+d2ENrAACiDElEQVQvNfa8ZEy9OLPXj8kCH6/vf533efJkh7BAydy0ubwP1Niosdi0dhMWT1/c55rmbZY2HGw4iP0N+7G7djcONBzgARa2vHP4HcSpWJ6e4ORyQ6T/TIyb6O2TYp0gBPfNqhjojhYiZDplRwaT0NBQvPTSS3whZMhx2Nt7pFBGSq+IpcLzxSYOksBCgRRCfMzlrj9M/zwSQoKaJyMlbuRpdzXu3cPX2pxZgBlIHh7pbdbLarpvqtzEt89PPd+XIyYBYHrSdJ6ZVGOowU/lP2FJ1pJOt6eMjMLRzdVoS50qBFIKaxHBJjZQAI6Q4KCtAUqEz4yzaTLf8K+XeUkvWVoaYn7zG+GhG01Y/dZhOJ0u5EyKw+yrh/cquK+36vHGgTfwv4L/wea0eU+4s75PLIjC+p4wNptw25kIV4RjdspsvngCK6xc2MbKjdhcuRn1pnrvvpSR4jtqmRqjY0bzoNZBuR4qhx4mSTQajpYjwd+DI4SQfu2R4i7tJaPPlN4QeQIp7t4yJHDQO5wQH6Nm84QQ0seMlN1CIKVJnc4DKazXhQfrh9FgauBNXFntcRLcWOmby3Iu4ycllxUu6xJISc0VAin10jSksvdWrQhoqwAi0vw2ZkLIADr8lfAdPGWq0KPrDJgOH0HLxx/z7YS/PAaxUgmr2Y6VbxyE2WBDbFoo5t44EiLx6YMobCLAE9ue4I3kPaWffjfxd7yXiS+xwAr795EtrBwYC6qwXiysQT072U98Z0r8FB5I2dV4AJOl8ahyRaOpxuTvYRFCSO/YrYCpBTC3AS6HMEVYIgNUkYAynHWXF3qkeJrNyygw0BueSYKeABQJHBRIIcTHqNc8ISToGZoAQ4OwHTP8lLu6rFaYDh6EQyxDQ5tQhKljfxRPWS/WOFcuoSJNBDyQ8uaBN7GjdgcqdZW8j4BHSm4k/73XphXBrIgAdK2wH9sJ6TQKpBASFA65y3rlXXXGE6Jqn3iCf6EPW7IEmlmz4HK5sP6/BWiqMkAVJsfiO8dCJj/1iSOjzYindzzt7VeSGprK+zrNSpo14CUq2Wcny3xhC/E9Fixj5dR21e7ChdHzUdUItJqF/jqEEDKoTlw15AMVO4CqPUBjEdBUBBgbT3EnERCaAFiNcGEhv4YCKX3MSKEeKQGHAimE+JiLR+35lp9HQgghfs5GYVkA8pBT7mo+ehQuiwW6lIlwOICQCAUiE9pny26o2MDXVNaLeCRpkjA1cSp21OzA6tLVuG3sbd7blCEyxKWHob5UC23aWCgLN8O0eytCp13p1zETQgZAw3Gg5gDr6AqMXnpGD6H99luYDx2COCQE8Q/9iV93dEs1ivbUQywWYdEdY6GJbO/N1J0TrSfwwIYHUNxWzLPobhx1I+4cfydUUjqZHgwmxE3g5dOqDdWQZqqARkAvj4O9pQXSyPaMW0II8Uu2SfE6oOBb4NgqwNjUw44iQBEmZJ8wDitg1QvnuHQ1/CqXO7NCQqW9+tYjhTJSAg69wwnxMZfTHUChZvOEEAR7Wa/c0+5q3LOXr7XDzuHfzVNzI72zdVlj3uMtx/mJqNnJQt13QphFGYuEQEpJ50AKw0rDsUBKa8I4xLFAypGjCPXbSAkhA+bQF8I65wIgJKbPd3eaTKh/8Z98O/o3d0AaG4umaj02f17Ir5t+WTYSs8NP+Rjry9fjT5v/BJPdhFhVLF447wVMjJ94JkdDArxPyoGGA6iIt/LrDCGJsBQXQzqZSpQSQvygpQzY8z6w77/tVQMYWQiQMhlInSr0tYzOAcJT20t4deSwAcZmoK0SruYTcL0o/F6TyIU+X+TUxFLhdDwFUgIPBVIIGaDaXiLKSCGEBKum4l6V9WKMe4VASos6AzAAyaw000nZKGx2Z4QywlejJQFoXvo8PLX9KRxrOcZnf2dFZHlvSx0ZhT2rytAoz8IwlvV0otavYyWEDAA2gYn3RznzJvNN770nNJhPSkLUDTfAbnVgzX+OwGFzIm1UFMbPY52Xevb5sc95OS+ny4mpCVPxt3P/hhhV3wM6ZGiU92KBlP3KaiS7xsAuVaP1cCFCKJBCCBlIzSeArS8BBz9z9zsBoIkHRl0K5F4EpM8U+p/0BtsvNF5YEsfDJVouXE2BlF5pL4Em5iVDB7rMJzlzFPoixMeclIlCCAl2rL4uE519yt3Yl0jTnj2wSxRoNir4dUnD2gMmP1f/zNeUjUK6a6Q8M3km32blvTqKzwyDWCqC2aGASRULc7WJ9z0ghAxh9UeB5mJAogBGLOrz3W319Wj6zzt8O+7B30OsUGDHtyVorhb6olxw06gem8uzz7LX9r+GJ7c/yYMolw+7HG/Nf4uCKEHecJ7Z1XoAGkc93248WuLnURFCgoaxCePK34P0zRnAgU+EIErWHODqj4D7jwCLnweyzut9EOUkLrvd22xeIqNASm9IpLL2jBT6XRJQKJBCiI+5XJ5/FCmgQggJUk1CGRSeHn4K1pJSOFpboY0ewScTh8UoERYt1JC3OCy8UStzTvI5vh8zCTgXZlzI16tKVvETmR5SmQTxGWF8uy0iCw6rGLajwnuJEDJE5X8rrLPnAoq+F/NrfOMNuIxGqMaNQ+iiRagtacOBH8v5bXN/lQt1mLzH+766/1W8eeBNvn3nuDvx+IzHIRVTIYhgNj5uPO+TUmOogVrezK9rrjP7e1iEkKGOnaDf9R9I35iGjKb1ELEAyrCFwO3rgBuWAyMvPuPgSScskOIu/SVR0Oddb4jlHUp7scagJGBQIIWQgeqRQgghwdrEkNXh7UUgxXTgAF/rsqd3yUbZW7fXW2N+eOTpS4SR4HN+6vlQSBQo1ZbyEl8dJWYL7yVdPCvuBZh2rPfLGAkhAxxIYSeJ+shWVYXWL4WyYLG/fwBOuwvrPsjnAf7h0+KRkddzZslbB97C2wff5tsPTX0Ivx3/WyrXQbx9UhhrBGvQDLSZhIkihBDiE60VwIeXAN//HiJzK9qUqbDf8B1w3edA8qR+/VMdM1Jkip4nGpB2Um+zeRFlygcYCqQQ4mOUkUIICWqtZUL6OGteGJp4yl1NB/bzdUuYUAIseXh7f5Sfq4SyXrOSZ9FJKdItjVyDc1PO9WaldJSYIzSEbg0TgnDm/fv8MEJCyID15ao7DLCTOmdQ1qvxzTcBmw3qGdMRMnUqdq0sQUutkZf0mn1Vz4H8j45+xLNRmAcnP4jrRl53VodBhpaJ8RP5uipOx9c6SSycZspKIYT4wKEvgTdmAaWbAZkajgXPYmPuX+FKFSar9TcWSHG6m6ZLZRRI6Q2x+3niASjKSAkoFEghZKAyUiiOQggJ9v4opwmAmA4e5P1RWqwhPfZHYYEUQnqyMGMhX68tW9upvFdCVjggAvTiaFhloTAVurOkCCFDT8F3wjpzNqCO6tNdreXlaP16Gd+OvedetNQasO8HoaTXedcMhzKk+xIoP5X/hL/v+jvfvmfCPbhx9I1ndwxkyJkYJwRS9oWX8rUhJBGWEuqTQgjpRw4bsPph4KtbAUsbkDIF+M0WOKfc7s0Y8QWX3dGekeIuWUVOTSJzP08iMZx2u7+HQ/qAAimE+Jr3RA5FUgghQaixd/1RnCYTLMeOoy0sEy6XCKFRSoTFCGUvag21KGotglgkxozEGQMxahKgZifPhkwsQ4WuAifaTnivZyc/o5OEAF1reBbMlVo+e44QMgQdXXHGZb0aX3+DzwwNmT0bqgnjsenT43A6XUgfG43siXHd3udI4xE8tOkhuODC1SOuxu1jbz/bIyBD0PjY8Xx9BEd5nwKHVIXWPZQdSQjpJ4Ym4L9Lge2vC5dnPwjcvFqYzOZjLpuVBwQYqYQCKb0hkSu8204bZaQEEgqkEDJgPVIokEIICeaMlFMHUsxHjvCTV9ok4URD8vCILmW9xsSMQbhCKNFESE916KclTuPb6yvWd9snpS0yGy67C5Yi93uTEDJ0tFUBVbvZFE8g96I+3dVaUYG2FUIQJvbee3BifwMqC1ogloow+yqhv9LJ6o31uHvd3TA7zDxjkvVFofKTpDsRyghkh2fDKXZA6Wjg1zUeFbJTCCHkrLSUAu8uEEp5yTXA1R8BF/wZGKCghsPaHgiQeTItyCl1LIHmstn8OhbSNxRIIWSAElJEFEghhARrrXompvuTUB6mAwf5ui1uFF8ndeyP4i7rdU7SOb4bJxlSTee7DaQME4Jw2ihhZp555yY/jI4Q4lPsJBKTMhkITejTXZvfew9wOhFyzjmQjhiFLV8IGZUTF6QjPFbdZX+7044/bPwDGk2NyInIwQvnvgCpmE4gkZ5NiJ/A1y6ZEEhprqEeKYSQs1R7CHhngTB5LTwVuO2nM8rIPBsOa3sgQCalz8HekMjaS4U6rFa/joX0DQVSCBmwZvOEEBLkPVJOwXTgABxiGVoR1Skjxea0YVv1Nr5N/VFIb8xJncPXhxoO8ROcJ2ekaJWpvBePae9Ov42REOIj+jph7Q6Y9pa9qQmtX33Nt6Nvvx3715ZD32yBJkqBiRemd3ufl/e9jL31exEiC8FL578EDZsFTEgv+qQ0hQiBlFZT1wAdIYT0WtUe4L0lwmdf3Gjg1rVAXO6AD8NhbS+XK5N230uMdNYx4EQZKYGFAimEDFgghTJSCDlbmzZtwsUXX4ykpCReOuObb77pdPtNN93Er++4XHjhhX4bb9AzawF9ba9OarFG86w/itMlgiZSgdBopfdkuN6m5yW9RkePHohRkwAXp47DmOgxvF/BxoqN3utZ3x22sGaY2rAMmAuO+3WchBAfMDYJa3V0n+7W/N//wmWxQJmXB9HIcdi3RmgwP3NpDmTyrg1615evx3uH3+PbT856Eulh3QdbCOlofJxQvjQ/rIKvteIYuBxUG58QcoZBlA+XCk3l02YAN68EwhL9MhRnp0AKZaT0NSPFSYGUgEKBFEJ8zEXN5gnpNwaDAePGjcNrr73W4z4scFJTU+Nd/ve//w3oGEkHze6yXiGxgKq958nJbHV1sNfWoi1CCLYkZod7a8x7ynrNTJwJibjrySxCunN+WvflvRKyhfJebWFZsFQ2UcN5QoZsIEXIbuwNh16Plk+E7wrRt9+G3avKYLM4EJsWipxJXRvMs0y3x7Y+xrd/NfJXmJ8+v79GT4a4FE0KYlWxOBFdxS8b1Imwlp7w97AIIYGmel/nIMp1X57yt5avOW3u79MuJ2QSykjpDWmH58lpodJegYQCKYQMWLN5QsjZWrRoEZ566iksXbq0x30UCgUSEhK8S2Rke68N4qf+KNGn649ygK91iWP5OsFdgqljo3kq60XOpLzX9prtMNqM3uvjM8P4WheeBpfdCWtZmd/GSAjxAWNznzNSWj//Ak6tFvLMTDjzZuLIJuEk98zLsyESi7pMkHpi6xNotbQiNyoXD0x6oH/HT4Y0NklkQtwEtKobIXI54JCq0Lprh7+HRQgJtN9XH13ZIYjyBaDwb2lJh03IrGP/rlGvsN6RShU88MQ47ZSREkikZ1JW5fnnn8eePXv4TN9ly5bhsssu47fZbDY8+uijWLlyJU6cOIHw8HDMmzcPzz33HC/D0pPHH38cTzzxRKfrRowYgYKCgjM5JkIGF08gxZuZQgjxpQ0bNiAuLo4HUObOncsDL9HRPZ9QsVgsfPHQarXezzS29IVn/77eb6g4+fjF9cfAckickZlwnOI5MezbBxdEaFUm8+S92PQQ/hjN5mYcaTrC95kSN2XQP6/0+g+e488IyUBySDKqDFX4ufJnzEkRAivRKUI9el1oOs8TNRw+DHFa2pA7fn8J5mMngVnai5VVavn4Y74ddcvN2PldKZwOF9JGRSElt2tWyzdF32BD5QbIxDI8fc7TNPOW9NnE+IlYU7YGUnsDbLIENOaXId7fgyKEBAZdHfDfpYCxEUgcB/zyc0AR6u9RtTebdzkpkNJLErEcIpcTLpEYLk9GDwkI0jMtq3LLLbfg8ssv73Sb0WjE3r178ec//5nv09LSgt/97ne45JJLsHv37lM+7ujRo/Hjjz+2D4zq6pEhV9qLEOJrrKwX+2zKzMxEcXExHnnkEZ7Fsm3bNkgk3ZeFevbZZ7sE85k1a9ZArT6zJqBr165FMPMc/8TSzUhltcAb7ChaubLH/VM2bIQzJBF2lxQiiQs7DmyC6BBwwCpkqiSIE7Br/S4ECnr9B8fxp9hSUIUqfLr9UxjVQlaKi02YE2lgkYXDoohA4Xdfw93FZ8gdPyFBqY+BFP2GDbBVVUESHg775Lko/JvwuTN9ade+XjX6Gvxt19/49l3j78LwyOH9OXISJFhGCmMW10GCBLTUmPw9JEJIILDogY+vAFrLgMhMoZyXUsi09jdPaS8RKCOltyQS9jwJGSmnmnBIBp8+v8PZCSm2dIdloJz84/HVV1/F1KlTUV5ejrRTzPhjgRNWgoWQIYd6pBAyYK655hrv9tixY5GXl4fs7GyepXLBBRd0e5+HH34YDzzwQKeMlNTUVCxYsABhYWF9no3NPgfnz58PWYcGcsHi5OOXvPMPfv2ImUswfMTibu/DelScePxxVEZM5peTsiOx5KJz+fbuHbuBYmD+iPlYPKH7+w8m9PoPruMPqQzBjk07UC2vxuLF7e+fr47uRVOlAdrQDGQYtJjY4bahdPz+wJ6D5cuX+3sYJJj1sUdK838/4uuIq67C3p9q+Hb2xFjEpnad4fvszmdhsBkwLnYcbhp9U3+OmgQRFoBTS9VoU9Qhyg60GRT+HhIhZLBzOoGvfw3UHhJ6T17/NaDp2sPLX2yeHh9U2qvX2PPEM1LY00YZKQHF5+/wtrY2Xgs0IuLUjY8KCwt5+S+lUokZM2bwGcI9BV76swyL534d18GGjt+3x+9wCFFmEVyD8jmm15+OfyjLyspCTEwMioqKegyksJ4qbDkZOxF6pidDz+a+QwE/fpZZ2iw0UJXGjWBXdruvuagILpMZbTkj+OXEYRHe525XnZCFMiNpRkA9n/T6D47jn5kyk/9IqdRXosZUg7Qw4XtlfEa4EEgJS4e1eG2/j3WwHD8hQcdhB0ytvc5IsRQWwrh9OyAWA/OWoujNEn795MWZXfZdX74e6yvWQyqS4vEZj0Mi7j7LlZDTYZ9LLBhXr6lHVCugdUULE+9EnfvxEEKI1/qngWPfAxIFcM3/gKgsDL5zCuy7r4N/TpLTE4vEHXqkUCAlkPj0HW42m/GnP/0J11577Sln9U6bNg3vv/8+74vC+q6wEiuzZ8/G4cOHERoaOiBlWJhgL8VAx++b4zfVstlteTwjhfUPGqzo9Q/u4x+qKisr0dTUhMTERH8PJThnBVt1PIyMyIwedzMdOMjX2iihIX1iVjhfV+oqUaWv4l/GJ8VPGqBBk6FELVPzEiq7anfh5+qfvYGUuPRQHN3C+qSkwX7CCHtzM6RRvZu9TggZxMyt7RngqsjT7t78kdAbJXTePOzfbeR3zRofi5iUzk17jTYjz0Zhbhx9I3Iic3wxehJEJsRPwA/R3yO3FTAo4uFqqYQoihVDJYSQkxz+Ctj8grB9yctA6hQMNkJpKhnPsKCMlN5hv3FF7tJeriE+uXWokfoyInnVVVfx/hBvvPHGKfftWCqMlWFhgZX09HR8/vnnuPXWW31ahsUz1mAuxUDH79vj31xajCZ3lYGOpUUGC3r96fgDqQyLXq/n2SUeJSUl2L9/P6KiovjCguxXXHEFLxXJeqT88Y9/RE5ODhYuXOjXcQelZmFmL8KSAJmyx91MBw7AIg+DURTKYy7x7kDKjpodfD02diw/IU7ImZiZNJMHUrZWbcW1udfy6+Iywjo0nBfBUlAA6cyZfh4pIaTfynopw4HTNIF3aLVoW7GCb4svvhZFX9fx7cmLuwb+3zz4JmoMNUjWJOOOcXf4YuQkyEyMm4j/RL7Lty2KSOj3bEbo/F/6e1iEkMGm4Riw/B5he+a9wLj2MtaDic3qyaig0l69xTNb3RkpDjtr4kgChdSXQZSysjKsW7euz8ENVgZs+PDhnU6W+boMS3/cP9DR8fvm+MXeLdegfn7p9Q/u4w8Uu3fvxvnnn++97Amq33jjjTxof/DgQXzwwQdobW3l5SJZgP3JJ5/s9jOD+FhLqbBmzRBPwXTwINrChH2ikzRQqISvJjtqhUDK1ISpvh4pGeKBlH/t/Rd21u6EzWGDTCJDVFIIpDLADhWMqliYCwoQQoEUQoKq0Xzbim/hMpmgGDYM+dVhcLmMyMiLQWxa52oI5dpy/Pfof/n2w1Mfhkqq8s3YSVAZGzMWDrkNYrsWTmkYmvYfQ+h8f4+KEDKoWA3A5zcANgOQeS4w73EMVg67J6PCIZSsIqclEbESoe6MFAqkBHcgxRNEYT1P1q9fj+jo03+R7W7GMZtJfP311/f38AgZcCwrixDSP+bMmXPK/6d++OGHAR0POYUWd0bKKcp6OfR6WIuL0ZZ9Ob+ckC1ko7DXeGfNTr49LXHaQIyWDFG5UbmIUkah2dyM/Q37MSVhCiQSMWJSQ1F7QgddWDrMh/b5e5iEkAEMpLDPmNYvvuDbikuvxvGdQjbKpAvTu+z7zz3/hN1pxznJ5+C81PN8MWoShFim7YioEXA52XsvDE3lOvT8bYkQEnTY793vHgAaCgBNAnDFO8Ag7s3l8DRLd2dYkN5lpLBSaIyTms0HFPGZBDlYGRW2dCyrUl5ezoMoV155JZ8x/PHHH8PhcKC2tpYvVqvV+xis4e+rr77qvfzggw9i48aNKC0txdatW7F06VJIJBLeW4WQQOc96UsBFUJIMGakRPV8asB85Chfa2PcjebdgZTi1mI0mZugkCh4Q1ZCzhSbFTcjaQbf3lq91Xt9XIbwXtOGpsOSn++38RFCBj6QYj50CJZjxyCSy1GmGQ+nw4XEnHAkuEtLeuyu3Y0fy3/ks0YfnPygL0dOghD7fmOW1PPt1jbKiieEdHDgU+DgpwDL7rjyXUATh8HMbvVkVFAgpS89UjzPl4OazQ/tQAoLkkyYMIEvnrIqbPuxxx5DVVUVVqxYwZv7jh8/njf39SwsQOLBsk0aGxu9l9n+LGjCms2zbBaWxbJ9+3bExsb213ES4j+eAIrI3wMhhBA/9Eg5RWkv85EjcIhl0KqSOgVSPGW9WKNwuUQ+EKMlQ7y8F/Nz1c/e6+LSw9oDKRU1cHaY8EMIGdqBFE82imrBYhzdKdxn/Ly0Tvs4XU48v/t5vn3l8CuRHZHtmzGToA6ktKiEbKg2ezQ7E+nvIRFCBstktJV/ELbnPAJkzMJg53C4AwEiKlHVW2Kx2BtIsVMgZWiX9jpdWZXelDFimScdffrpp30dBiEBo/1/CcpIIYQEY2mvUwdS2IlsF8RQh8sRGq3s1GieynqR/jAjUchIKWguQJulDeGKcMS7G87rNSlwOsFLzClHjvTzSAkhZ8XYLKzVUT3u4tAb0Pb9Sr5dP3oJLDusCI9TITMvptN+K0tW4mjTUWhkGtw57k7fjpsEbSDlm7APkNAI6KQJQOMxIGGsv4dFCPEnFpD4+g7AqgPSZgCzhX6gg53d2+ODMlL6lJHiaTZv8/SYIYGAugARMmClvfw9EkIIGSA2E6CrOW2PFBZIaQsXAi2JWeEQiURwOB28nAozLYECKeTsxapjkRGWARdc2Fu3l18XHquCTOaEUyKHURUPS2Ghv4dJCDlbhobTZqRoV34Pl9EIaUYm8ovE3mwUkbg9ddzmtOH1/a/z7VvH3opoVd97fhJyOsmaZLQmWfi2UREHR5lQOp0QEsR+/idQsR2QhwJL3xrUfVE6ctrcTdMpkNKnHimewJOTms0HFAqkEOJrlJFCCAk2reXCWhHW48xg3mi+tBRtYdmdGs3nN+dDZ9MhVBaKkdGUIUD6B2syz+ys3cnX7KRpdLyQmK3XJMNSVOzX8RFCzhKbuFTmLiUdm9vjbm1ffc3XxnnXQ9dkhjJEhtzpCZ32WVG0AhW6CkQpo/DL3F/6dtwkaLHJI0nD0yFy2nhQv3nfYX8PiRDiT/X5wIa/CdtLXgAi0xEoHO5AgEhEgZTeYv3XvKW9HBRICSQUSCHEx9rL3VEghRASHEStpe3ZKKLuG0SZjx7l/ypqI4VASmJ2RKeyXpMSJkEq7nMFUkJOGUjZXSdkOzExaZHtgZTCAr+NjfjHs88+iylTpiA0NBRxcXG47LLLcOzYsU77mM1m3HXXXbx/o0ajwRVXXIG6OqGnARlkag8CbRWATA1kzel2Fxa8Nx04wAqTo8SZxa8bdU4SpPL2Gb9WhxVvHnyTb9829jao2eMR4iPjEyZAYhMyqRqL3KXpCCHBx+kAlt/NUjuAEYuBvKsRSJysTi5lpJxxIMVJPVICCgVSCPExCqQQQoKNiDVJPG1Zr6MwqWJhk6ghkYoRk6rplDFAZb2ILwIpx5qP8T4pTHRGjLdPirXwuF/HRwbexo0beZBk+/btWLt2LWw2GxYsWACDweDd5/7778e3336LL774gu9fXV2Nyy+/3K/jJj0oEPqeIHsuIFN1u0vbihV87Zp1IapOGAARMHp2Uqd9vjz+JWoNtYhTx+GqEVf5ftwEwd4nxQEhONvSFBglfMiZq6qqwq9+9SsenFepVBg7dix2726f4EGC2I63gKrdQjb/kn/0OBFtsHLa3QEUykjpU1aiJ5Di8Dx/JCDQVE9CfI3iJ4SQYNNaJqyjTtdoXgi0sCAKC6awmcCeHhbUaJ70pxhVDDLDM1HSVsKzUi5IuwAxKULwTh+SDOuhOjgtFogVCn8PlQyQ1atXd7r8/vvv88yUPXv24Nxzz0VbWxveeecdfPLJJ5g7dy7f57333sPIkSN58GX69Ol+Gjnp1rHvhXXukh4nNrWt+JZvV2cvAEqBjLExCItpD7pYHBb859B/+PYdeXdAIaF/D4hvjYoehZ9kn4HlPTXaYgF9A6CJ9fewiA+0tLRg1qxZOP/887Fq1SrExsaisLAQkZFCdiwJYmwC2ronhe35TwBhnQP8gcDh8ARS6ORX37g6P38kIFAghRAfczmFfxxFFFEhhAQJUUtJrxrNa8Mm8e34jDC+PtR4CGaHmdelz4nIGZjBkqAxJX6KEEipFQIp0ckskOKCVREOqzSEl/1Rjhjh72ESP2GBEyYqSujrxAIqLEtl3rx53n1yc3ORlpaGbdu2dRtIsVgsfPHQarV8zR6HLX3h2b+v9xtKev0caKshqz0EF0SwZ85ld+iyi2nvXtgqK+HQROBErZKdtsDIcxI6PfbXhV+jwdSABHUCLkq/yO/PfbC/B4Lh+CWQwBFtA1qAFlE67NUH4co8N2iO/1SG2nH/7W9/Q2pqKg/Ie2Rm9jzhiAQJVr3k298BNiOQfg4w8SYEIpfDfa6LMlL6xiX0RnFQj5SAQoEUQnyOSnsRQoKLyJOREtn9D0SH3sBPWmvHCyVy4tyBlD11e/h6Uvwkd7ozIf1nSuIUfH78c2/5OJlCgvAwK9q0Cl7ey1JURIGUIMVqe9933318tvCYMWP4dbW1tZDL5YiIEPo3ecTHx/Pbeuq78sQTT3S5fs2aNVCrz6zXBis7FuxO9xykNW7ABDapV52FzRuEPlsni/vqa7BXsmTMYtjMDkjVThw8sQ2H3HF/h8uB13Wv8+1JrklY+8Pged6D/T0w1I+/McWM0BZAr87AwRVfoWKYPqiOP1isWLECCxcuxC9+8QteKjI5ORm//e1vcfvtt/d4HwrO95/BevyiA/+D9MQGuKRK2Bf/g51RF5YAO/72jBTnoHuOB/Pr7zlHaLfbfTq2wXv8A6O/j5sCKYQMWI8UQggJAi4n0FJ2yowUS/5ROCGCPjStU0ZKx0AKIf1tcvxkvj7echyt5lZEKCMQkyBHmxbQsT4pxcX+HiLxE9Yr5fDhw9iyZctZPc7DDz+MBx54oNNJLzYDmfVeCQsT/p3ry48+dgJ1/vz5kMlkCEa9fQ4kX37G1+GTr8Ti2Yu73M7K9pU+9TSvRK5LOgdodmHywmzkzU3x7vN9yfdo3daKSEUkHrn4Eaik3fdZGUjB/h4IluOXlEpQvasKNmUyRHWhWPy7xUF1/D1hx798+XIMFSdOnMAbb7zBPyMeeeQR7Nq1C/feey8P2N94443d3oeC8/1vMB2/zG7ABfmP8JOyR+MuQdH2Y6xOZUAev75ND8gAh9OOlSvdPcsGocH0+guEoFlTY/OAPG+D7/gDEwVSCPExiqMQQoKJ0tYKkcMCiCRAeGq3+5iOHIEhJBlOsRQKtRThcSrYnDbsq9/X6YQ3If3dJyU7PBvFbcW8T8q89HmISY9C8fEW6DXJPCOFBJ+7774b3333HTZt2oSUlPYT6wkJCbBarWhtbe2UlVJXV8dv645CoeDLydhJ0DM9EXo29x0qTvkc2K1AySa+KRlxISTd7Kddtx5OnQ7GjPFoaXZBLBVh9KwU72M6XU58kP8B375+1PUIU/Ut6OVrwf4eGOrHPzFxIo5LX4YCySitj8MYlxhSmThojj+YMh8nT56MZ555hl+eMGECD+C/+eabPQZSKDjff/p8/C4nxHvehzN9JhCb65MxiX94GBK7Dq6Y4Rh+w78wXOK718XXr/93a4vRagfvebl4cdcJDf42WN//737zNl+Hh4Vjtg+ft8F6/IEamKdACiEDFkmhiAohZOgLsdYLGxGp7Nt0t/uYjxyFNizdW9aLlfEqaCyAyW5CmDwMwyKHDeSQSRCZnDCZB1JY9hMLpERnJwFrW3jDecvxdf4eHhngjOF77rkHy5Ytw4YNG7rUqp80aRL/sfnTTz/hiiuu4NcdO3YM5eXlmDFjhp9GTbqo2A5YdUBILJA4vttdtKtW8XVD3qWAFsgaFwulpv1EwoaKDShqLYJGpsHVuVcP2NAJYRJDElGRXIqcOqBaNQFv37uRn8SVuGwQO4GPvvsOUrFTWCQuSKWATCqCVC7mJSr5opJCrpJDFiKHPEQJWYgC8lA15OFqKMJDINcoIVNKeYCGSqf6R2JiIkaNGtXpupEjR+Krr77q8T4UnO9/vT7+zS8CPz0BSWgi8PuC/h9I3RFgz7t8U7To75ApzyzDaLC8/t5TXmLhbwxWg+79zyo58LVrQMY16I4/QFEghRBf88ZPKJBCCBn6Qiz1p+yP4m00HzqzU1kvliHATIyfCLGofSYmIf1pfNx4fHbsM+yv388vx6SF87VRnQBzZR1cVitEcrmfR0kGqpzXJ598wmeohYaGevuehIeHQ6VS8fWtt97KZwOzBvRs9i8LvLAgSneN5omfFK4R1jnzAHHXzw6nwQD9hg1wiGWosMTz7+MjZyV22ueDI0I2ytUjrubBfEIGEgtsiGfGQ/VREUwhOe4rxXCIFHCIFbB1/Clpdy89srkXXfc3u1w8QCNx2SGGAxKRU1jELkhELkgkbAEkEhEkLFgjE7vXEkjlEkjkUkgVEkgVUohlEkikEmEtZ5elkPB9ZJDIpBDLpZAoZHyRqeUITxQ+b4MV68HFgvEdHT9+HOnpwsQiMshseUlY62rgk6jDyj8KjcZHXgJkn49A54kHQEznvPpEJDxxnhYzJDBQIIUQH3NSRgohJIiovYGUjJ4bzZeUQDv52m4bzVNZL+JLE+JYS2qgoFnIgNJEKqGQWmCxK2BQxsFaXg5FjvtEFhnSWK16Zs6cOZ2uf++993DTTTfx7X/+858Qi8U8I4U1/GWNgl9/XWhITgaJwh/bAynd0G3YAJfZjOaRC2G1uKCJUiA1N8p7+5HGI9hbvxdSsRS/HPnLgRo1IZ2MTZ6AF+e+gMWNVjxao4fVrhIWB1uUfG1zKoUFGtighg0qvthdCtjBFjnsIjnfdrC1WMYDMQ6JHE6JO6tBJOK3OXDShAGXe2En83rVk9fZl52hsrXglneEzL5gdf/992PmzJm8tNdVV12FnTt34u233+YLGWRYyUhLm+8e//BXQNkWgPXiWvg0BozTyb/nmsvLYT1RAltdLRyNTXC0tsBpsQqTicRiiNQqiFVqiFUqSKKjIEtIhCwpEbLERMgzMiAJ7xoUdTpdgIjFgOmcV98IERQnRVICCgVSCPE1+iwhhAQRtbVR2IjsfoadpSAfdrEcBrUwIzguPRQOpwN76/byyxRIIb6UFJKEOFUc6k31ONx4GFMSpiAmyoyqegX0mhRYioopkBJEpb1OR6lU4rXXXuMLGYRaK4CGfD57H9lzT1nWqy7zfMAIjJyRCJG4vbTRh0c/5OsLMy5EnDpugAZOSGfj4sbBJRZhW3I01LHDoLHo4LLoYNHWQyG2Q2Q1nNGPSjZL3OkQwW6TwGZXCMEZGwvKKGB3ymB3ymHn23LYXUrYRSrYoYTDxQIySh5wsbtY4EXWYZHC4ZLCBTGcIgmckHi3XZDAKRK3r8VSvpY5jAh2U6ZM4aUkWd+Tv/71r7yc5EsvvYTrrrvO30MjJyv7uX07rL13Wr+w6IE1fxa2z7kfiEiDL7/nWAoLod+wEYZdu5C9exfKTeazflxpXBwUw4bxRTlmDFR5Y+FyigCJUNqL9IWzc0YPCQgUSCHEx9p/p1NEhRAy9KmsTcJGD43mWVkvXWganxXJZgaHhCt4doDOpoNaqsaIqBEDO2ASdCVUWHmvNWVrsK9+Hw+kRCcoUFUPoU9KMWs4v9DfwySE9EbRWmGdMgVQt2eZeDj0ehg2bYZJGY16YyifLZs7s72sV52hDmtK13ibzBPiL6OiRyFUHopmqw5r5vyFB/bsNht+WLmSN26WscYoNiPAAipWvbBmJ2Q7XuaLrsO2HiKLHhKrgS8Kvp97X5sWsJsAh9Wnx8VODvLfwhGs3Cv9P3bRRRfxhQxyx1e3bzss/fvYa/8M6KqBiHRg1r3wBUtJCdq+Xgbt6tWwVVR4r2dxDpFCAXlmJhRZmZAlJUESEwNpZCRECqVQ2tbpgNNkgtNogtNkhKOxEbbqGthqa2Grroa9thb2+nq+GH5uDzgpcn4BsJgTBVLOqLRXexUbEggokEIIIYSQ/s9I6WGGlYn3R0nv1B/FU9aLlV1i5VUI8SX2PvMEUpjo9GjgoAGGkARYi4v9PTxCSG+d2HDKsl76n37ipUoaxgvB0ZQRkQiLVnlv/1/B/2B32TEpfhI/kU2IvygkCh7Me33/63yRiWSQi+Qot5ejsLUQYcowqGVqqJVhUITE9l/DeKcDsJsBm1kIrJxy7V5sJmHtsAFOm7Dmi7XDdWzbDpHDChG7zBp2ExJovbcY9t7vL/s+AnazBvMiYMmLgKz98+hsuZxO6NetQ/P7H8C4W+g7ybDgSMiMGVBOn4Y9RiPm3nwz5Oozb2zPJihYi4pgLiyEpeAYTIcPwXI0Hy53f0uHmn7H9Y0QQGHtckjgoHc5IQNWOoKizISQIc5ph9LWcuqMlKNHoQ07v1N/lN21whf+yQlU1osMXJ+UAw0H4HQ5EZnNAntHebk5S8dZiISQwcvpBEo2C9uZ53W7i3bVav7tuy5uMmAFRkxP8N7GeiR9cfwLvk3ZKGQwuG7kdfjv0f+ipK0E9224z3v92ys799AQi8Q8g5cvMjVUUlX72n1dd2uVTLid7ccWuUQOpUTJgzh8UUTzNXt8QoJWUzHQfKL9Mgsk9oeqvcB3Dwjbcx4GhnU/AeBMAija71ei8a03YS1yTwYSixEy+xxELF0KzezZEIeEwGazwbJyJUQy2Vn9PYlGA9X48XzxcFqt2PK3L4EqQJ8YeraHFGTcGSlU2iugUCCFEF+jND1CSLDQVrMq2XBJ5BBp4rvc7DSbeXND7dSbvBkpLNjsyUhhs4IJ8bXhUcP5SSSdVYfi1mKkpmbw6y3KSBir6viPUtZskxAyiNUdBkzNgFwDJE/svqzXzz/zUpI6qwJSmRhZ42O9t68qWQWtVYtkTTLmpMwZ4MET0lWYPAxPznwSnx//HAabgS9N2iZAJgT+zA5hZjybAKC36fmCfjrH25FcLBcCK1J3gMW9KKVKb/CFrWViGc8i7rg++TrPdrgiHBdnX9z/gyWkvxW6S0YmjAVqD/FJYiy7CpKzOHWqbwA+u14oEzZiMXDuH/plqIadO1H/t7/zssmMWKNB5C9/ichfXgtZQvvEAV8Ty+WwhAjZNWJJP2XLBVlpr9707SODBwVSCPEx6pFCCAkWojZ3Hd6wZD4b6mSWwiJYpBpYlFGsRQpi00L5zMsWSwv/kT4meszAD5oEHXZSZ2zMWOys3Yn9DfsxbPgwqGV6GG0a6KUxvP4zqxtNCBnESjYJ6/SZgKTrDFvDpk1w2WxoGCvM+s0cHwu5Uuo9YfFpwad8++oRV0MiZpXjCfG/C9Iv4AvDZpCv9PRIkcngcDp4MMVoM8JoN/a4ZkEXts3XPexncVjaF7uFl7jzsDqtfGG96/pLelg6BVJIYJX1GnmJEEhhWCk7iebMHo8FYb68GdBWAtE5wNI3u/2N1Bf2pibUPf0MtCtXegMo0bfdisjrroMk9PQZIQ6bE7pmM3RNZhi1FlhMdlhNdn7eipUNZElpIrEISrUMSo0MqlA5VKEyhEYrIZF0P3an08Xbo1AgpW9cIuEcoZNOFQYUCqQQ4mv0jyIhJFi0VfKVKzyVVf/twlyQ7+2PEpkYwk9q7S4TynqNix0HWTcnwwjxBdZwngdS6vfjF8N/gahwC4yNGqFPSlkZBVIIGexKNgrrzHO7vVm7di2cIjFqI/MABzB8anuW5OHGw8hvzucz7y/LuWygRkzIWWEBvxBxCEJkIf3+2HanHVaHlQdqWGDFE2Tp7jLfz27m92EBGLa2OW3C2mHr9rpoVXS/j5mQfmc1AqVbhO3ci4D1T7cHUhRnGEjZ+BxQulnInrzmE0AZfsbDY5MAtCtWoO6ZZ+Foa+MBmchrrkbM3XdDGhXV/X2cLjRVG1B+tBFN+5X4fO9utNWbzqhoCguuhEYpEB6rQkScGjGpoYhJ1SA6ScP/DkOBlL4RsS8o/HXy90hIX1AghRAf83xIiSiiQggJloyUHvqjsKaE2rD0zv1R6tz9UeKpPwoZ+D4pnobzkXFSVDYCRnUirKWlvDEnIWSQYg2ty7b2GEhxWiwwbNyElshcWBxsNq0MqaPaTzJ9duwzvl6YsRCRysiBGzchg5SnDBfrp0JI0GIBD1Z+i/2OiRsJSOSAwwrYzrCGHvuc2vwPYfuSl4HYEWc8NIdOh9q/PO7NQlGMHInEp56EavTorvs6nKgqaEHRnnqUHmqESWdz3yKDyV0PUKqQIDRKCU2EHHKVDAqVhAdK2LkrFrBx2l0wG20w620w6awwtllhtzmhbTTzpSLf3ROTt2QRQSwSAkTiHjJWSA/ccSeq7BVYKJBCiK9Rs3lCSJAFUlzhKd3ebi4ogDZUOEFN/VGIP+XF5vF1ha4CTaYmRKVEAEddQkZKaam/h0cIOZXqfYBVD6gigfixXW42bNsGp9GIuhFCkCVncry3HEmruRWrS1fz7atzrx7ggRNCCBn0/VFy5rEaV4BUJQRS7Ja+P5apFfj610KqwfjrgDFXnPGwTIePoOr++2GrqAAkEsTefReib7utS+N4baMJRzZXIX9rTYfgCSCVi5GYHY42Ry1mXTAR8RkRUIfJeRmv3mK/2YxaK89maWswornGiMYKHRor9DAbbBDxwl6ASC1kWJDecvdIoYyUgEKBFEJ8jMInhJCgoW0v7XUy1sCbBVJ044UTV3HpoajSV6HeWM9nQY6N7XoyjBBfNvXNDM/kPXpYmZ9h2ew9Ww5DSCKsJe4f0oSQwemEu6xXxuxua83r1q6FQyxDQ8Qo/kV8+JT2sl7Li5fzEkUjo0YiL0YIqBJCCAlybPKrpz/KsPnCWqYELG2A3dT3x/rufoBNMIvMBBb97YyH1fbd96j5v/+Dy2LhZWeT/vEC1BOErGqPhnIddq8sxYkDDd6TTywTM3tCHLInxiIxJwJOlwMrV5bz7EzWc6mvWNAlJFzBl6RhER0O1QV9iwWvrX0H2yt3YEEmZXT3hVUJiG2AtN7EJ4CI1ZQVGAgokEKIr1GzeUJIkDhVaS9bVRWMDgXsshBeP5fV011ZLpwMGxU1Cio264uQAcQazrNAyqHGQ5iWw374lcOsjIaxuNzfQyOE9KY/StZ5XW5y2e3Qr1uPpqjRcLiE0iXxmWHeEz5fHv+Sb1814qo+zcYlhBAyhDUVA61lgFgGZLo/W6RKYW0z9+2xDnwKHPkaEEmAK/4DKE7fAL67CWgN/3oZTW+9xS9rzjsPSc//HZIw4fOMaa42YNs3xSg92Oi9LnVkJMacm4KMvOhOZbacNt9kirDPUfY5a0qtR7F5H2TS2T75O0NVS6wY0dWAyAY0f/hfxPzmDn8PifQCBVII8bH2eocUSCGEDGFOJ9BW1WNGCs9G0aTx7ehkDSQyMW/07Wn8TchAY7PRVxSv4IEU5QQ5VBI9TA4NWtsAl83WpWQCIWQQYCe0KnYK256TXR2Y9u2Do6UFDeOu4pdzJsV5AyYHGg6gVFvKA/eLMhcN7LgJIYQMXifWC+u06e2N5T2BlL5kpLSUASsfFLbPfxhI6XsPSPYdtPr//g/aFd/yy9G33YrY+++HSCLhl1kprZ3fluDwpire5J19xLESlpMXZSAqKQT+YHfa+ZpVGSB9IBHOEbpEIjT95z+IuPoqSCOpd9tgR+9yQnyOAiiEkCBgqIfIYYGLdc0LTexysyW/ALpQIcASmyr8QNnXIDT6pkAK8YcxsWP4mgVS2Ez1yFAdTK0aGFTxPINKnpHh7yESQk5WvVdoBqyJB6JzutxsLjgGh1iOxshR/HLO5DjvbcuKlvH1gvQFCJH552QTIYSQQejEhq6Zjqy0V18yUtgM2m/vFXp4pc0Aznmgz8Ng5Z0q77sPhk2bAakUiU8+iYill7kf3sUbyG/+7Li3B0rmuBjMWJqNyIS+f6axx2uxtKBSV4kWcwvfZn3E9Da9dx82EUEuliNcEY4IRQRf4tRxSNYkQyZpn3BkcwrjoUBKH0mEAJQ2Kh2OIj2a3nwT8Q8/7O9RkdOgdzkhPkYZKYSQoNAqlPUyySI7fbH2MB87Bp1mBN+OTQuF1qpFUUsRvzwhrnOtX0IGwvDI4VBIFNBZdSjTliEqGqhuBe+TYiktpUAKIYNR+bb2WcPdlOay19ejKXo0HJAiLEbJP28Yo82I1SVCk/nLh10+sGMmhBAyeDkdQOlmYTtzTvv1nrLD9l4GUvZ9JARkWCbLpa8BYiGDpLccegMq7rgDpj17IFIqkfKvl3hJL4Y1et/wcQFKDghlvFjmyeyrhiElN6rXj6936rGmbA2Othzl/QGLWov477EzIRaJEa+OR2poKu85yB6LoUBK35ji82EvOwdadTYao8dC9Mn/EHXjjbwfDhm86F1OiK9R/IQQEgzahL4SJnkMuiuIZM7Phy5DaN4YmxaGgw0H4YILKZoUxKhiBniwhAAysYw3nN7fsJ9npWQkhgDFgFGdAGtpqb+HRwjpTvkOYc1m+3aDBVLqYid2Kev1Q+kPMNqNSA9Lp+A9IYSQdjX7AXMboAgDkiZ0zUjpTSBFWwP88H/C9vn/B0Rn92kIToMBFb8Rgiji0FCkvvUW1BOFsVQWNGPtu0d5MEUsFmHSonRMWpQBibS9B0pPjrcc55MINlduRoG2APi58+0iiBAfEo9oZTQilBGIVERCIxMqB7DfaYzFYUGrpZVnq7B1nbEOJrsJNYYavuys3dnpuzXpPZdKh4NJGzCxaj6KR/8S0ZsfRdM77yLhz4/6e2jkFCiQQshAEVFEhRAy9DNSjPIYtLdBFDi0WuibjLAND4VIzHqkhODzI0JZLzqhRfxpTMwYbyBlQvocYIuZZ6RYywr8PTRCSHe9uCq2C9up07rdxdzQjKZoYUZxzqR47/XfFH3D15flXEZN5gkhhLQ7sVFYZ8wGJB1OkXqbzfeiRwrri2JpA5ImAtN/2+dyXhW/uROm3UIQJe3dd6AaO5b3P9n5fQl2ryzlk3NZFsr8W0YjJsXdw6UHbZY2LCtchuXFy72ZIh7DI4ZjQvwE5MXmYUTkCKSFpfG+YX0tCdZkbkKFrgLl2nIUtxXzgI3VYcW5Kef26bGCnUQkxr7ktZjYMAtGaxgqk8+D5IsveNN5aWysv4dHekCBFEJ8jH3QEEL6x6ZNm/D8889jz549qKmpwbJly3DZZULdWM//b3/5y1/w73//G62trZg1axbeeOMNDBs2zK/jDgpt7YGU7hvNC/1RohJDIJVLcKD+AL9M/VGIP7EfksgHDjUcQtSUWwEcgUkZDdOJMn8PjRBysoYCYdYw62+SkNftLrVaNZwxcoSGihDj7sdV0laCvfV7IRFJcGn2pQM8aEIIIQHXH6VTs/nTZKQc/wEo+A5gZa0ufbVzMKYXjeUr778fxl27INZokPaff/MgitVsx4/vHfWW8hp1ThLOuWoYZPKey4Wxz7r3j7yP7098z7NIPBkis5NnY07yHBiPGnHV4qsgk51d1gibjMCqCbCFJsSdfSDFJrFAOmwn7EfmoDT7IiTW7kDTu+8h/k9/9PfwSA9OnwtGCDk7Ls+sNwqoEHK2DAYDxo0bh9dee63b2//+97/j5ZdfxptvvokdO3YgJCQECxcuhNncy9q25Ox7pMiju9xkKTjW3mg+LRR2px0HGw/yy/QFnPjT2JixfF3QUgBJdATkMIClTbVWt/l7aISQk3myUVIm93iiSmcWro9LUXkzTzzZKOckn4NYNc3wJIQQgvZsk3L3Z0tWh/4ojKwXPVLY/Vf+QdieficQP7rXf9rldKLm0T/DsHET74mS+vbbUI0bB22jCV/9fQ8PorDyXfNuGonzf5XbYxDlRNsJ/GnTn3DZ8svwdeHXPIjCsk0em/EYNly9Af+a+y9clHURNOJTZ7IQ/wRSGFdiAaJTNLCLFChLm4eWTz+FvaXF38MjPaCMFEIGCBURIOTsLVq0iC/dYdkoL730Eh599FFceqkw4/TDDz9EfHw8vvnmG1xzzTUDPNogc9qMlDRvIOVYyzFeWzdUHorsiL7VECakPyVrknk96BZLC39fRqhaUG8Kgc6sgNNshljpno1ICPE/z8muHvqjsP9nzRBOfIXGC0UmWeB+RfEKvr00Z+lAjZQQQkggqNgBsOyN0EQgZnjn27ylvU4RSNnyT6C1DAhNAs57qE9/uuHFF9G2fDkgkSD5pX/yniiNlXp8+8p+GNusUIfJsejOsUjIDO+xhNdr+1/D58c+h8Pl4NfNSZmDm8fczCeqURnLwY9lyjJO2DHtkiysfP0gqlLPR1rFOjR/8AHi7rvP30Mk/RFI8VVZFTa7mD1ubW0tn238yiuvYOrUqX0dHiGDuLQXZaQQ4kslJSX8M2TevHne68LDwzFt2jRs27atx0CKxWLhi4dWq+Vrm83Gl77w7N/X+wU8lwvS1jIeMGbN5k8+ft5oPmIS345MUmF9zXq+nRedB4fdAfbfUBC0r3+AH//o6NHYUr0FB+oOICHCinoTYFTFwVhcDMXwk35UD8Hj70/BfOxkAJRvE9Zp07u92d7QAIsigm9r4kL5ekvVFjSaGhGljKLa7YQQQrov65V5HqtZ1UNGSg89UpqKgS0vCdsXPgsoep/x0frll2j6zzt8O/GppxA6Zw6qC1vw/euHYDXZeT+Ui+8ZB02kstvzSyzz5MU9L0Jr1XoDKHeOvxOjokf1egzE/6TujBS7w4aMsdGIywhDfakWZWnzofrfp4i54w6IVX3rYUMGYSDFU1bllltuweWXX95jWZUPPvgAmZmZ+POf/8zLqhw9ehTKHmb1ffbZZ3jggQd4KRZ2wovNKGb3OXbsGOLi4s7syAgZJNrDKBRIIcSXWBCFYRkoHbHLntu68+yzz+KJJ57ocv2aNWugVqvPaCxr165FMJHZDVhsNfBtozy68/E7HEgtqYF1Oju55cLuwz9jlWUVv0nVosLKlSsx1ATb6x/oxy83y/n6h4M/4DpM5NtGdRx2LFsG/Vih9NdQPn5CAoK2Gmgt56X3eGmvbtjr62GRCzN3NZEKvvZko7CyJjLJ2dWFJ4QQMsSUbO6+PwojVZw6I2XtY0I2S9b5wKje999i/VBqnvgr3465+25ELL0M5UebsPKNQ3DYnEjMCcfiO/OgDOn6mcUavD+x9QnsqN3BLw+LHIY/TfkTpiVO6/XfJ4OHRB0D6AvhaCqEyG7BtEsy8e3LB1CVfC7SKn5C2/IViLzman8Pk5xtIMUXZVVefPFF3H777bj55pv5ZRZQ+f777/Huu+/ioYce8unsYc/9Oq6DDR2/j4/fHT8RDdLnmF5/Ov5g9/DDD/NgfsfPlNTUVCxYsABhYUJpkL48n+wk6vz588+6kV9AqTsCHAJc6mg4xfJOx28pLMQ+dTLfjohXY8nFs/HqNy8DNuCqWVdhcnz3J8QCUdC+/gF+/KFVoVi3cR20Ki2yxmbjRI2QkTI7xoHIxYuH/PH3J/YcLGdlKgjxVVmvhLGAQsg26TaQ4s5ICYlQQGfVYWPFRn754uyLB26shBBCBj+LHqjZL2xnnNP1dukpeqSUbhEazLPSTCwbpZdltKyVlai85172hQlhixch5q7fdgqisKyEhbePgfSkfijsXOvy4uV4ZsczvDyyUqLE3RPuxnUjr4OUNbknAUkSMwyo3wYHy3o6+ClSJ97IA2k1RW0oTV+I0A8/RMRVv4BITO3NBxOpv8uqWK1WXiaMncjyEIvF/DHYfQZq9jAT7DMI6fh9c/xmk9n74TeYZ17T6x/cxz8UJCQk8HVdXR0SExO917PL48eP7/F+CoWCLydjJ0LP9GTo2dw3IBnrhTWrD3zS8RuLiryN5uPSw9BobUS9qR5SkRTjE8ZDJh16z1PQvf4Bfvx58Xl8XaothXoUy4Q2waSOg6N6zxkdR6AdPyFDoT8KY62rh1UufA5pIhRYW7YKVqcVORE5vPEuIYQQ4lW5E3DagfBUIELo5diJTNl9IMXpBH54RNiedBMQN7JXf4718WJBFEdrK5RjxiDxmWdQWdDSHkTJi8GFvx7DG8x3ZLAZ8OT2J/H9ie+FPxk/CX+d+VekhXUzZhJQJBIhK54Xud76KkQTbsDUizKx/KX9qEmcicxtK2H4eSs0s7sJ9JGhEUg5k7IqjY2NcDgc3d6noKDA57OHmWCfQUjH79vjX7ZuD2ARJiks7sPM1oFCrz8d/1CZPczKSbJgyk8//eQNnLDPhx07duDOO+/09/CGNm0VX7nChBNYHZkLjkGvSfU2mt9Xv49v50blQuWZ6UWIH8WoYhCniuMBvtpooV+PTaaBoazS30MjhHhU7RbWKVN63EVf0wyXmH3euHiT3u92fsevX5K1hJruEkII6axsq7BOn9X97Z7fKbaTeqQc/AyoOQAowoA57RPCT6f2qadgyc+HJCoKKa++gvpqC1a+cfCUQZQybRnuXXcvTrSd4I3Jfzv+t7h1zK2QiDtnrJDApJAIkzmLlCq4qgshOr4aySMWIS49FPVlOlQmz0Hkhx9SIGWQCcgcMF/MHu6P+wc6On7fHH/Hn22D+fml1z+4jz9Q6PV6FBUVdcqE3L9/P6KiopCWlob77rsPTz31FIYNG+bt05WUlITLLrvMr+MOitr17NQVy0g5qR2UpaAA2tBF3kDKd+5Ayvi4nrOECBlorDlnfWU9jplLoRapYHRFopV1nSeE+J/DCtQeEraTJ/W4m66mja9VMgfqzfXYVbuLX16cOfgmMhFCCBksgZSZ3d/u6ZHSMSOF9UtZ96SwPfv3gCa2V3+q9auv0PblV6z8DpL/8QJ0zlB899oe2K1OpI6K6jaIsrV6Kx7c+CAvUxmnjsML572ACXETzuRIySC1MGMh3jr4FrYrgHVqFS7Y+gpEuYsxcWE6Vr99GJWsV8rWP8Ny4gQUWVn+Hi5xE/uqrEpH7LLntpPFxMRAIpH06T6EBBLvOUURNZsn5Gzt3r0bEyZM4AvDshPZ9mOPPcYv//GPf8Q999yDX//615gyZQoPvKxevRpKpTs1m/g0kIJuMlJ0J6pgUUbx7ZjUUOyvF2oRUyCFDLZACnO06Sgi1ELvPa1JBpfd7ueREUJErA8XC6aoooDIjG73cdlsaM0v5dsh4XKsKlkFF1yYGDcRSZqun02EEEKCGAuIVO4+dUaKrJseKbvfETLxw1KAab/p1Z9i/SJr/yoEX2LvvQeu3AlY8fJ+WAx2xGeGYdEdY7sEUb46/hXu/PFOHkTJi83Dp0s+pSDKEJQZnombRwu9wp+NjoKxYht/X2aOj0V4nAp2WQiqE2ei9bPP/D1U4qtASseyKh6esiozZnRfz1Yul2PSpEmd7uN0Ovnlnu5DSCBxuTw5KRRIIeRszZkzh/cbOnl5//33+e2sdMdf//pXXk7SbDbjxx9/xPDhw/097CAq7SU0lfewt7Sg1SL8CAmLUcAmMaOwtZBfph8DZDAGUvKb8xER5eTbJmUcbD2UpiWEDBxR9b72bJQeSnQZdu6E2SHUGg9NjvTWkr8o+6KBGyghhJDAULUHcFgATTwQnd39PlJle9CFseiAzf8Qtuf8qb2Hyik4LRZU/f5BuCwWhJxzDsJuuAXfv34QhlYLIhPUuOiucZAp2st0sd+1bx14C49vexxOlxOXZF+C9xa+h1h17zJfSOD5dd6vkaxJRp1Ugtcjw4GtL0MsFmHCfKEHTkXKBWhe/h1/L5EADaSw2b2sjApbOpZVKS8v5yewPGVVVqxYgUOHDuGGG27oUlblggsuwKuvvuq9zGYU//vf/8YHH3yA/Px8XsveYDDg5puFyBwhAY3iJ4SQIAmkIDSx09XWoiJoPY3mM8JxsOEg/1HAviyyFHVCBlsghdWgDokVyjwa1XGwVVT4eWSEEFHNXmEjeWKP++jWroVFEcG37SoLjrUcg1QsxYL0BQM1TEIIIYFY1qunHlrejBR3qdftbwLGJiAqGxj3y179mfp//AOW48d5X5SEZ57B2vcL0FihhypUhovuGQelRtYpiPK3XX/Dq/uFc6W3j70dT816CnJ3Q3IyNCmlSjwy7RG+/VFYKIqLVgHNJzBiegLv92ZRRqJWng3dmjX+Hio500BKf5RVKS4u5k3mPa6++mq88MIL/DFYg2AWmGH3ObkBPSGBiSIphJAhzOUC2rpvNm8uLIReI8ymiU0Nxb4G6o9CBic20y9WFcsDffpo4XPbqIqDlQIphPidqHrvKfujuJxO6H76CWZlNL9c6hAyH89NPhfhivCBGyghhJDAULbl1GW9OvZIYRkpxmaeKcDN/T9Acvp20/rNm9Hy4X/5duIzT2PXplaUHmyERCbG4jvzEBatas9ccTnx9I6n8XH+xxBBhIemPoR7J97LJ6uToe/clHMxN3UuHCIRXmBZKdteh1QmwZjzhGoPrFdK62ef+3uY5EwDKf1RVqW0tBSPP/54p+vuvvtulJWVwWKx8FJg06ZN6+vQCBmkqLQXIWQIs2gBm6HbjBRWE1ivEb4AxqRqvP1RJsRSWS8yeLNSKsMN3owUazkFUgjxJ6nDBDQKgREkdZ+RYj50CLbGZjRHCf8Pb7dv4OslWUsGbqCEEEICg8MGVOw8daN5RtohI2Xba8JvnvixwKilp/8TOh1qHv0z34687jrUhY7C/h+F75QX3DgSCVnhnYMo25/GZ8c+40GUv876K64bed3ZHSMJOA9MfgBSkQRb1Cr8nP8ZYGjCqHOSIJaIoA3PQm1BHSzFxf4eJunvHimEkG544ycUSCGEDOFG86pIQKbudJOx8ASMKqGmb0SSipf2YigjhQxGI6NH8vUxWSVELgecEgW0JZX+HhYhQS3CWAIR+w4dkQZouq8Rr1u3Hi0RI2CThUAaIsJhxU5oZBqcl3regI+XEELIIFdzALAZhd8uscJ3v5PZqqtx4vb/Q1NBCGBqBXa+3d4bRXz606j1f38e9ro6yNLTILvht1j3YT6/fsKCNAyb3F55h01Kf37X8/j8+Oc8iPLUOU/hspz2tggkeKSHpePaXKFk3Avhath3vo2QcAWyJwrlsCuTz0Pr51/4eZSEoUAKIT7mCZ9QViYhZEj3Rzmp0Tz7YdBcZQBEYihVYlQ5ymC0G/nJrZyIHP+MlZBTGOWezX60NR8acTPfbqvV+3lUhAS3COOJU2ajMPr161EfJ5T9EmXp4BI5MT1xOhQSd1kWQgghxKN8u7BOnd5jUKTliy9gKa2AtkwlZKKwJW4UMOL0mY6GbdvQ+oVwwjv2L0/ih/cLYbM4kDQsAtMvzeq071sH38JH+R/xbRZEYc3lSfC6Y9wdCJeoUCSX4+vDHwB2C/LOT+G31cdPRsN3a+GyWv09zKBHgRRCfI0SUQghwZCRclJ/FHtDA9ogpK3HpIVhX73QH2Vc7DhIxJKBHychfWg4H6rS8e02w+lrYBNCfCfScOKU/VGslVUwFRajIWYcv6xNEbLIUkKFEw+EEEJIJ5Xusl6pU3rcRbdmLV877R1Omc7+/WmzUZwGA2r+LPSPjrj2WuzID0FLjQHqcDkW3DYaYkn7/T8t+BSv7X+Nb7OeKBREIayv250T7uHbr4WIoT/4GeIzwxCbqoFTLEOlejT0W9z9fYjfUCCFkAFDERVCSPAEUlh/FEOIuz9KWpi3PwqV9SKDVZw6DtHKaF6rGtHCbC+DJBKOtjZ/D42QoBVpPHUghWWjtEQMg12mhipUhkrNcX59Ykjnnl2EEEIIV7FLWKd235eZ9aGwuntROG3usiJR2cDo0/dGqX/pX7BVVkKalIiGGb9C4a46iMQiLLx9DC/T5LGhYgOe2fEM375z3J3UE4V4XTXyGmTIwtAskeDf+17hHZfHnp/Kb6tKOgety5b7e4hBjwIphPiYi+InhJAgLO3FAik6jTAjOCY5BPsahIyUCXHUaJ4MTiKRCCOiRvBtbZSZr02qOFgrqU8KIX6hq4XK1gyXSAwkChknJ9OvX4eGWCFAnzk+FjWmGr6dpOkc3CeEEEL47xZdNSCSAEnd/ybRrVkDp0iK4syL0KzO6ZCNcuqMeuPefWj5SCjTpf79E9j2bTnfnrE0G0k5Ed798pvy8cdNf4QLLlw5/EoeSCHEQyaW4fdT/sS3PxKbUFu4GsMmx0GuEMGsikHFvio4Wlv9PcygRoEUQnzO0xyFIiqEkODJSDEfL4TBcyIr2oJaQy0kIgnGxoz1wyAJ6R1PIKUmRMhCMaliYKugQAoh/iCqPShsRA8DFJoutzt0Ouh37kaju6xXNguk6IVACmWkEEIGs+eee45P4Ljvvvv8PZSgIvKU9UoYA8hDut1Hu2YtCnMuR1n6Iuwe+wBc2fOAvKtO+bguux21TzzBZ9GGXnY5th5Uwm5zInVUFMZfIGQTMHWGOtz9090w2U2YkTgDj0x7hL8PCOnovJyLMUkSDqtYhLd3PQ+pXILh04Xf1VVxU6FdvdrfQwxqFEghZKAyUkQUSCGEBE8gpe1ELexSNcQiF4pF+fy64ZHDoZap/TFKQnplRKQQSCmSCcETkzIG1nJhRiEhZGCJ6g7ztSuh+wC8YcsWtIWkwSoPg1wlRVS2Ei2WFn5booYCKYSQwWnXrl146623kJeX5++hBB1R5e5TlvWyVlTAkp+PquTz3HcQw7n0Q0AiO+Xjtnz2GSzHjkEcHo7KSdehvkwHhVqKudeP5KW9+GM7rHhgwwOoN9UjOzwb/5jzD559QMjJWHDtnkm/49vLbPWoqN6NUbOE39qsJ1zDcgqk+BN10CRkgNA8A0JIsJT2cjmdaKq3ABFARIwc+5t28OuprBcZ7HKjcvn6kP0IJriccErk0BaXIcbfAyMkmAMp8d0HUnTr1nubzGfkRaPeUse3NTINwuRhAzhSQgjpHb1ej+uuuw7//ve/8dRTT51yX4vFwhcPrVbL1zabjS994dm/r/cbKrzH7c5IsSdOhKub56J11SqYFFHtV7icsLa1QqqQ9/jYjuZmNLz0L+HCTfdj7/pavnnOVTlQaMTev/3crudwsPEg/3z653n/hFKkHLDXg17/wDv+vJzLMHPH37BVZMHrW/6Cvy79BtGJCjTVAKX1KiQXFUGenj5kj78/9fdxUyCFEF+jRBRCyFBl0QPmti4ZKfbqauhksXw7JiMSy9yN5imQQga79LB0yMVyGJ0GqEQtMCEabdVUh5gQfxDVHeoxkMLKqOg2bULDyN/zy9nj41CjFxrNJ4QkDPBICSGkd+666y4sWbIE8+bNO20g5dlnn8UTrFzUSdasWQO1+swyvNeuXYtgJXZavSUj1xcaYCxf2WWf1C++RH3cJO9licOC9atWwRYr/K7pTvyXXyFcp4MhOQ17CqNY7AWqRBuO1e3CMfef2Gfdh6+MX0EEES6VXYqDmw6C/TfQgvn1D8Tjv0A0DVuxCd8by5C9/N9QRWYANUpUJ87Enn/+Cy0L5g3p4x+sKJBCCCGEkLMr66UIAxShbLoHv2gtKoIhRMhQCUtW4lj9Mb49Pk5oCEzIYCUVS5ETmYOjTUchVrQBlmho2xz+HhYhwceshailhG+64kd3udm4dy+0jjCYldGQysRIHR2FvaXUaJ4QMnh9+umn2Lt3Ly/t1RsPP/wwHnjggU4ZKampqViwYAHCwsL6PCObnUSdP38+ZLLgKyfFjn/PslchdjngConDnMtuYPWTOu1jr69HaUUF6if90nudQ6LAOZMmQTVmTLePaz50CJW7hXJhbZc9CvsRG0Ii5LjyvulQqIXn+XjLcTy1Rgia3TbmNtyZN/DN5en1D9Djdy7E1g8n4ye5CEfEP+LJGz/GRw9vhUGTDHWVEdMXLepVj52APf5+wo5/+fLl/fVwFEghxNdcnqJe1COFEDJky3p1PmllKSqCXiMEUlpDauF0OXnjX5olTAKlvBcLpBhDdYAF0NtC4HI4IJJI/D00QoJH3RG+MsmiIFVHd7lZv2496mOFsl5pY6Ihk0tQrReC+9RonhAy2FRUVOB3v/sdP5mpVCp7dR+FQsGXk7EToWd6MvRs7hvoogxFfC1KnQqZvGupLv3mzTAqY6ALTWu/kvVI0Vu6fc5YKePGZ5/jTXGdS67HsaPChLK5N4yEJlzIGNJatfjDlj/A7DBjVtIs3DXhLkjE/vs+Gcyvf2Aevwx3ZV+JdeVf4kddIX5tK0HW+BgU7m1CpSMFY0pLoRw+fAgf/+BEzeYJIYQQcpaN5tv7ozDG4yUwqoQU+GLJUb6mbBQSKIZHCj9I6sOFsnUmRQyfpUgIGUC1QlmvVlX39b/1GzagIUb4XMmeIHzelGnL+JoCKYSQwWbPnj2or6/HxIkTIZVK+bJx40a8/PLLfNvhoOxXX4t0B1KQOrXb23U/rUO9uwxxSm4k74/CWLTGbvdvW76CZ6RAE4pDoXNYPAXDp8YjbVR78P+p7U+hQleBpJAkPDf7Ob8GUUhgGjbjd1hkEnolvbrtSeSek8K3WQm61pWr/Dy64ESBFEJ8jRJRCCFDPpDSOSOlubyVz+BSKoD9eiHdnfqjkEBrOF+iEMoEmVQxsFW73+uEkIFRe4CvtOoOM4PdrBUVaKk3wRiSCLFEhPSxMTDajNhctZnfPim+vb49IYQMBhdccAEOHTqE/fv3e5fJkyfzxvNsW0JZrz4XaTwhbKR0DaQ49HoYtm9HQ+xEfjlnUhyksPcYSHGazWj4l9BgvumyP6Cp1gxFiBSzrhzm3ee7E99hVckqSEQS/P28vyNCGeGrQyNDmSoSv02aC7HLhU3Nh6GNqYVS4YJNpkHJhuNwsQgeGVAUSCFkwNA/cISQoVraq0NGisOBFnf/+agkFQ42Co0UKZBCAi0jpVxSztdmFkiprPTzqAgJzoyUNlXXQIphyxZvNkpKbhQUKinWV6yHyW5CiiYF49wlvwghZLAIDQ3FmDFjOi0hISGIjo7m28THdDVQ2VrgEomBxK6fEYZNm2CUhPOyXiKxCFnjYyETCYEUq07IBuio5aOPYK+thTVtJI7UCVmRs67IgTpMKBlWpa/C09uf5tt3jLuDPpfIWUmfcT8WGYSA3jv7X8HwaULmbaU4HZb8fD+PLvhQIIUQH3O5PD1S/D0SQgjpZzphxj5C23ufyBubYFAKl6XJYhhsBoTIQjAson2GFiGDWag8FMmaZGiVTfyyVR4G0wn3LEZCiO85bEC9cGKgrZvSXvpNm9EQI5yUYrXCPTN/mYuyL+pV41VCCCHBQ1S9T9iIzQXkQv+Snsp6JQ+PgCpUDqlYKO1lNXQOpDhaW9H49r/5NNniKb+B3ebk98mdIZzcdjgdeGTzI9Db9DyAcvvY231/gGRoi8vF7SE5fPPHmp+hzhMmaTdG56Hpux/8PLjgQ4EUQgaIiDJSCCFDNpDSXo9eXlcLnUao3docItyeF5NHNYFJQBkROQJWqQlil4Ffbi2t9feQCAkejccBhxUuRSiMcmGmr4fTakXz3qPQhQkBlsxxsWg0NWJb9TZ+eUnmEr8MmRBC+mrDhg146aWX/D2MoCCqEcpFuhK7Zsi7rFboN27sVNaLkUk8gRRrp/0b33obTq0WLXlLUNMkhUQqxpzrcr1B/HcPv4u99Xuhlqrx7OxnIRVLfX58ZOjLnvJbzHdnpXzW8B7CNU44JXIUbaug8l4DjAIphBBCCDkzurquGSk1dTBohJ4phWKhNAuV9SKBZkTUCL52SZr5Wtto8vOICAkiNUJJSFf8GOCk7BLT3r1oVGfz7biMUF5G5YfSH+BwOTA2ZiwywjP8MmRCCCGDl6hGyEhxdVfWa9cu6O1Kd1kvlukYC51VB529hd9uNdm8+1orq3hZL4dYhsKUxfy6iQvTEBEvZLkUNBfg9f2v8+2Hpz2M1NDUATk+EgRyl+DXFhnf/KF8DeKnhvPtSvkwWAoK/Dy44EKBFEJ8zRMcpioDhJChxOkADPVdAiloNMAuVUMscmG3ZSu/alwc1QUmgRlI0SvcgRSj8MOFEDJw/VFc8WO73KTfvBmN0UI/gcw8d1mvYqGs15IsykYhhBByEpcLopr9PWak6H/6qUNZr0he1uvTgk+hcwrfAa0Wh3ffhpf/BZfNhpoZN4ElB2iiFJiwUMiQtDvteOznx2B32TEvbR4uzb50gA6QBAWJDLnjb8R5RhOccOHn8DX86taIYahfud7fowsqFEghxOc8ERRKtyOEDCGGRsDlBJ+6FdJeesWmE0p4acJcqDJVQiwSU4NFEpClvZhqtRAsNDhDKW2ekIFS685IiRvd5Sbtpq1ojszl2+ljY1DSVoLDTYchEUmwKHPRgA+VEELIINdaBpGpGU6RBK64UZ1uYt/tWH+UjmW92HXLipbBLjbz62zuQIr52HFov/0OZkUEilXj+XUzL8+BTC789nn/yPvIb85HmDwM/zf9/6hfF+l/k27E7W06vrm87gtEhFn4b/HiXdX+HllQoUAKIYQQQs68PwoLorj7nzgtFpidoXzbFSvUEx4eOZw3myckkLBm8xqZBjWhjfyyUR4NR7MwM5EQ4mPuRvM46YSXrbYWdU1iOCUKhITLEJOi8TaZn5U8C1HKKH+MlhBCyGBWtZev2lRpgFTR6Sbz4SPQtjk6lfXaU7cHFboK2CRCk3mr1d3Y+7XXeHZL2aw74bADiTnh3n4qLKj/xv43+Pafpv4JMSohY5KQfhWWhHGZCzDdZILd5UBtRjm/uhqpsJaV+Xt0QYMCKYT4mGcCK01IIIQMKfqu/VFsJSXQhyTz7YYI4fbxscKMLUICCZtFyIKArWohkGJWxcBWTbO9CBmQbEej8P+dK2Z455u2bEFjtFDuK2OccPLq+xPf8/VFWRcN+FAJIYQEgGqhP0qrOrPLTbp1Xct6sWwUxiJxZ6TYAHNBAXRr1qA1PBtVzhRedGT2VcP590Wny4nHtz4Oq9PKg/oXZ108oIdHgsyU2/DrVi3fXC7/jK/Z+5LKew0cCqQQQgghpO90tcJa0x5IsRYWwaARAimFksN8TY3mSSD3SdEqm/i2SRkNy4nj/h4SIcGTjRKRDsg7ZzPqNrb3R8kYG439DftRpa+CWqrGnNQ5/hgtIYSQAA6k6Net71TWS2/VY23ZWn7ZInUHUhwino3igggnJt3Crxs1KwmxaUIW/mfHPsPe+r38s+ix6Y9RSS/iW5nnYnJIKsaaLWiRNUCmaOTlvQq3Vfp7ZEGDAimE+Jz7g5Q+TwkhQzGQEhrvvcpw/ASMKqFfygHHDr6mQAoJVLlRuTDIWwGXHS6xFNpjRf4eEiFDX0OBsD65jr3Nhrr9JbAooyCRAikjIr1N5uelz4NKqvLHaAkhhAxmTidQLTSab1FndbqJZRq3lDV1Kuv1Q+kPMNlNyAjLgEUulCm2mWzQrf0RdfGT0eqMgFwpwbRLhMeqNdTipT0v8e37Jt2HJE3SgB8iCTIiEURTbsfNbUJWyoEY4Td3lTUOtnqhtyPxLQqkEOJz1GyeEDIE6btmpDSdEGbEyKRW6GVtiFfHI1GT6L8xEnKWDeddIhdcLqE3SmsF9UghxOfqjwrrOKGhvIfp4EE0qIQTV6kjo+GSOLG6dDW/TGW9CCGEdKupCLDq4JKqoFd2DnLoN27ssazX5cMuh1MpnL+xi+S8UX3pqKv45YkXpkMdJufbz+96Hka7kZcyvnrE1QN8cCRojbsGc20ipNls2BMvBFLaInJQv2qDv0cWFCiQQoivUfyEEDIU6br2SGlpEGZuuTQ6vp4YJ6TKExKIsiOyIRaJYZII5b10LXZ/D4mQoa/enZESO7LT1frNm9EY4+6PkheDzVWbobVqEaeKw9SEqf4YKSGEkAAp6+VKyINLJOl0k27DBjTETPCW9TrRegIHGg5AIpLg4uyL4VQLE2IdEiWqkmbD6FJDHS5H3txUfv3Wqq1YU7aGf1d8dPqjfE3IgFBFQDL2F7ixTQeDog0OUSm/unCr0Hye+Bb9n06Ij1EchRAypDNS3IEUh14PrU2oZ18XLtw2Po4azZPApZQqkRaaBp1CyETRm4XZh4QQH3G5gIb8bjNSmrfthzY0nW9njI3BdyeEsl6LsxZDIu58cowQQgjhag96AykdOU0mNO89Bl2Y8LmSOS4W3xR/w7dnp8xGjCoGYo2MX7bIw1A2/BK+PWVJJmRyCawOK57Z+Qy/7pe5v+R99QgZUFNuwyV6A6IcDhRE7+VXVWnD4DQa/T2yIY8CKYT4nDCTQSSikAohZOg2m7cWFUGnSeHb+YojfD0xnjJSSGDLichBS0gL3zY4haaihBAf0dcDphZeIhIxw71XO7RaVNWL+fUxSUo41BZsqBDKV1BZL0IIIacPpAgZjR6G7dtRHyYE7BOzwyHTiLCiaAW/fFnOZcJO4e5AijIKVpcC4XEqjJwllCx+7/B7KNOWIVYVi7vG3zWQR0SIIDEPyqRJ+FWbDvtThPd5a1gWmjZs9/fIhjwKpBBCCBkyHn/8cYhYA7YOS25u51mtpJ8aN+rrOjWbNx0vhMHdYLFaWYIQWQiGRQzz5ygJOWs5kTmoCxUyUkyyKDh0Qtk6QogP+6NEZgKy9ubxpl270RQ1mm9nTkjA2tK1sDltPNA5PLI94EIIIYR0ynKscQdS4sd0ukm/YSMaY8bx7czxsfi56mc0mZsQpYzCuSnn8usVIcpO92EN5iUSMSp1lfj3oX/z6x6c/CA0cs0AHRAhJ5l8M67S6WBXtsDpqOATTorWuUukEp+hQAohA91znhDiU6NHj0ZNTY132bJli7+HNPSYmgGnu1+ERgiktBSUwS5VAy4HWlV1vOkilVshgY4FA1tChECKWRkFW2mRv4dE+smmTZtw8cUXIykpiQfdv/lGKOnh4XK58NhjjyExMREqlQrz5s1DYWGh38YbFBrcP/7jOvdHMWzfgZZIoWxK2phob1kvlo3CXjtCCCGki7ZKwNwKiKVAzIhOn+/Nm3egNSKHX84aH4tlhUKT+YuzLoZMLGSiqNUK731i00KRMzGOb/9t599gcVh4f65FmYsG+KAI6WD05QiXheFKrRaVYQf4VeU1IrjYpEfiMxRIIcTXXPQDj5CBJJVKkZCQ4F1iYmL8PaShR1cjrNUxgET4sdFY1sbXDkkTnGIH9UchQyYjxdMjxaKIhOXYfn8PifQTg8GAcePG4bXXXuv29r///e94+eWX8eabb2LHjh0ICQnBwoULYTabB3ysQaPe3R8ltnMmac3+Ch6ol8tdcEYbsLtuN0QQYUnWEv+MkxBCyOBXe6j9M0XaHhSxFBSgzhHPm89HJ6lh0xiwqXJT57JeAEJCVHDCwbdnXJYNkVjEM1c2VG6AVCTF/037PwrmE/+Sq4Fx1+D6Nh32Zgjv9+aQLOj2C2W2iW9I+/sBMzIyUFZW1uX63/72t93+UHn//fdx8803d7pOoVDQjxQy9NBnLCEDgs0YZjOMlUolZsyYgWeffRZpaWk97m+xWPjiodVq+dpms/GlLzz79/V+gUbUWsW/QLg08bC7j7WlyQkkAE2qKn45LzpvyD8Pwfr6B9PxJyoTYVeaAZcdLrEUrcdPQN3D8Q3F4++rQDr2RYsW8aU7bLbqSy+9hEcffRSXXnopv+7DDz9EfHw8z1y55pprBni0wZuRItFqUW8O59upuVFYXb6ab09OmIyEEKFHFyGEENJjIOWk/ij6DRvQECuU9cqaEIfvir+D3WVHXkwen0DjEaYOxbqszzElZhpSR82F3WnH87ue57ddk3sNsiKyBvJoCOne5JuRuPMtTBGdgMheD6c0DkWr9mHixM7vezKIAym7du2CwyFEbZnDhw9j/vz5+MUvftHjfcLCwnDs2DHvZYrqkqHE02Ke3tWE+N60adN4gH7EiBG8rNcTTzyB2bNn88+i0NDuG0WzQAvb72Rr1qyBWq0+o3GsXbsWQ1la0yZMYJOHTRJsX7kSEr0eRnEkv60sogxiiFG1uwoNogYEo6H++gfb8UeJo+B0tUAsikVVQSX2r1wZVMcfjEpKSlBbW8vLeXmEh4fzz5ht27b1GEihwPxZcLkgrT/Kvy/booaxA+fHri4qRlWUEFhJHhODt4uFsl4L0xYO+ecm6N4DJ6Hjp+MnpD8azSMhr9PVrRu2oDnyer6dOS4GT+39mm9fNqw9G4VhvU8K4rcjM0P4jfPl8S9R3FaMCEUEfjPuNwNzDIScDpt8kjYDN9XsxqeqA4i2zceJ43pM9Pe4hrB+D6TExsZ2uvzcc88hOzsb5513Xo/3YYETVn6lt/rzR4rnfh3XwYaO38fH7y7t5YJrUD7H9PrT8Q8lHWcX5+Xl8ZNe6enp+Pzzz3Hrrbd2e5+HH34YDzzwQKfPlNTUVCxYsIAH+vv6fLKTqGwCgUwmlLwaisQ/HwPKgdjMMVi8eDGMu3bha41QLbQurBq5kbm4bFHnHyPBIFhe/2A7/q1bt8IqboYSsRA5Nfw9H0zH3xfsOVi+fDkCHQuiMCwDpSN22XNbdygwf+aU1mYstOjghBirdxbCKS7l10cXlUEbeg7f3lq5BoW2QkgggavAhZXHTx3UHCqC5T3QEzr+4D5+Qs4+kNI+M9/e2ITqKgeckXKERshQqShGSVsJVFIVFmV0zlINlQuT8HQ2HdosbXhtv1Bh567xdyFcIWRKEjIoTLoZw5dtgzH5IKJL56NRlg7dwaMIzRvl75ENSf0eSOnIarXio48+4ieoTpVlotfr+Ykup9OJiRMn4plnnuHNggfyRwoT7F9S6Ph9c/xOp5CTYrNZsfI0s1j9iV7/4D7+oSoiIgLDhw9HUVHPDaJZOUm2nIydCD3Tk6Fnc9+AYKjnK3F4IsQyGSyFpTCqhAaMTepqnBd3ydA+/mB//YPs+IdHDUeVvBZKK6A3K097bEPt+EnvUWD+zImK1wFHAFF0Ni686FLvb8ntr38HhIoRHg7UD2sDjgKzU2bjinOvwFAXbO+Bk9Hx0/EPhcA88RNTK9BaLmwnjPFebdyyBQ0x7rJekxLwTfFHfHt++nyegdJtIMWqw5sH3kSrpRXZ4dm4cviVA3cchPTGqEuB1X/CJc7d2G+vh0Mahy0vr8GFbw6HSOrT0/5ByafPKKsh3NraiptuuqnHfVj5lXfffZfPHG5ra8MLL7yAmTNn4siRI0hJSfH5jxSGvqTQ8fvy+D/5Rqj3LJfLepzF6k/0+tPxD+UfKSxQX1xcjOuvF9K3ST/Ru2dka4Rs0oZjNYCIbetgkuuo0TwZUoZFDsNRVT6irYDB1ffvmSTweDLl6+rqkJiY6L2eXR4/vud/3ygwfxZaT/CVKHaE93itpaVoU6bz7fTxCfhv2Q98+6Lsi4LjOQm290AP6PiD+/gJOSN1h4V1eBqgiuTlIhndxk1ojF7At5PGhGL1XqHv1uXDLu/yEGFy4TtfqbYURxqF5t1/nPJHSMV0YpoMMjIlMP46zNj2Kr5M/w7ZVbegRDwSn1/7GlQiE9RKJ+ROPY7tLUd4ShRCU2OhSE6ELCEBkuhoiMRCZQnSOz79F+Cdd97hZVZY09+esEbAbPFgQZSRI0firbfewpNPPjlgP1L64/6Bjo7fV8cvZGOxrKzB/PzS6x/cxz9UPPjgg7j44ot5lmN1dTX+8pe//H97dwIlR1XvD/xbVb13T8++ZyaZZCYJJCEJhGCAsAgEwiKgoqDvgYDhiaAibg+PENH3l8dDfSh69Oh5iPoXWXwsf1EQwk5MAgFCErKHJJOZyexrd09vVfU/91bPZCaZCZmkZ5rp+n44l1tV3dN973Snf9P1q3svNE3DNddck+mmZZe+FqvOsU42djSFAQ8Q0qyF5hcUMZFC2aMurw5tgQ5M7wEijkKY8SgUlyfTzaJxVFNTI5MpL7744mDiRFy4tW7dOtx8882Zbl52at9p1UV1g4cia9ehM7U+SnJqCE07m+B3+nH2lNGnjCYiIsKB1LRe5UPWR0km0bS5FcnZPni8CjaoaxBJRjA1OBUnlxy+okTAaY1QEdN6CSL2nF55+gR1gGiMTvkClDW/wDmel7EDi+BVT0J74fAF5z8QX+FFWW/AHdsOT2wt3PEe+Bxx+H1AIM+JnKIAglPy4K8ohrOkGI6iImjFxVBdrox1zTaJlH379mHVqlV44glr4aajJU5kLly48IjTsBBN7mXniWi8NDQ0yKRJR0eHXLPrzDPPxNq1aw9bv4vSNCIlpwymaaKrV5WJlNZAIwrVQhR6CzPdQqK0KfOXoaegH2gEou4CJPdsgnPWqZluFqVhxOLQ7xtigfkNGzagoKAA1dXVuO222/Af//EfqKurk4mVO++8U14cdsUV9lv/aUJ0pF6LwoOJlJZ1WxBznw9VMbDaWCWPnVd9HjwOJjKJiOgImjcdtj6Kd+9etObMkts1C0vxu90Pyu0raq8YcSmCgam9BIfiwDcWfWP82010rMSFKNOWYvne1/GzM/4MT8dqnO86B4u0k9HbFkJrUw+g+NCvu2AqKmKeAlmG6Qew3yqqkYArvgOu2Ftwx3vhRhRelw6vT4Uv6IS/wIdASRD+8gK4RMKluAhafj603FwomoZsNm6JlN/97ncoKSnBJZdcMqaf03UdmzZt+khOgUR0PI60ThARpccjjzyS6SZkP9ME+gam9ipFsrUVfS5rfZT6giZUO6oz2z6icYjfhaW5wCYg6slHYudGJlKywPr163HuuecO7g9MG3zdddfhoYcewre//W2Ew2HcdNNNcqpikZh/7rnn4PHwJP64JlJSI1JMXUfTvjhQCZRWOPFww7Py+CU1Y/tuSURENjRCIsW/dSvqi6wF5X0zDWzYvgGaouHyGda6XEdKpFw9+2rU5NaMd6uJjs+i6+Hc+zq+3d2Lb+Vvx4PYhsecAZSWlkKtUTF36lyU+ctRinLkJorgiwSgthmItkTQ196PcG8C4aiKmOGCoToR9RTKcph+yAvMRFHe0eGMN8Id3wpnIiSLS0nA7dThdinw+FR4Ay54gx54C3zwFubAVZAHLRiEGghA9fsP1j7fpJhmbFwSKWLReJFIEV9EHIcsbHPttdeisrJSLhgv/OAHP8DHPvYx1NbWyi8p9913nxzN8sUvfnE8mkY04czU1F5ERFmhvwvQ49Z2oBTRNW8hHLCm8GzNacJZ2uLMto9oHEwtrxBndmGqTvTu2gtfphtEx+2cc86RI+qOlEAT31NEoXEWDwO91tSQKKyVVXTrNrR7rZNW+swEuqPdKPQUYnE5YwwRER2BngDarHVqUWotNC/ivbm3D7HafDgcJlbjeXl8aeVSFPuKR02k1ObVIpqM4kvzvzRx7Sc6VrMvA3xFuLCjCZH5X8f/qX8GoUQIoZ6QvHnn7tQ0qocIFARQVlWGUl+pHIlf4ipDEcqQqxfAEwvA0aXA6Eigv7Mf4Z4YImEd/TLh4oCpaIi782QZVThVDli7qh6DI9kCh74XWjIKR7IfDl3UUTiUBJyaCadmwOlS4XBpcDoVWTvcVpl642fgn16dXYkUMaVXfX09brjhhsNuE8fVIRmmrq4urFixAs3NzcjPz8cpp5yCf/7znzjxxBPHo2lEE2/gOzrzKUSUDUKp9VHEwo1OD7re34OkYwpgJtHtbcFUh7UwMFE2qS2oRbfRDWiF6GnshbU6EBGldTSKtwDwWdNM9K5ei548K6mywbMaiALLa5ZzkV8iIvrwNbeMBCBGlORZJ1sTe/ei2zlNbledmI979z0tt6+su3LUh1EVFY9f9jiSRpJTStLk4HABC/8FWH0/rty3ERde/RqaI81o7GnEC2tfQGltKdqibWiJtKA53CzrvnifTLbs6t4ly2gUTUF+VT4KZxaiyFOEIm8RCt2FKDBLEUwWwJ8IwhPzQeszYfToiPfG0N8XRzSSRCxqIhpXEDfE33AKDM2NuCjIPfq+JVIlBFy2pzP7EinLli0b9QqvV155Zdj+f//3f8tClL1SGRQmUogoGwyZ1kto29UOYAqSaEHQm4MitSiz7SMapwXn1+JdaChEb2cy080hyuppvYT9b+2F4aiBQ+nH873PyGMX13DqZyIi+hCtW6y65AQxvFRuhl97DW1F8+V2rKYLna2dcpTj0ilLj/hQInnPBD5NKqdcJxMp2P0SfG07ML1iAap8Veh0d+LieRfLdcmHiiQiMtnSEj6YXBlItLT3t8vSGe2EYRqy7ox2YidGHtkyyAH4SnzIq8pDrjsXQXcQee485DpzkYsC5CAXfjMIrxGAS3fDkXBB7VeAiAlEDBj9BuKRBBLRJJIxHcmEgUQS0JMmkroCb3lmzzfwE4FogihcbJ6IskG4zar91jD4ztYY4Ad63I1YULwASohZY8o+tfm1eNnxIgIm0BtxZ7o5RNmlffhC80Y8jqY2FSgH4nltiBpRVOdUY26RNUULERHRqFq3WnXpwVluWl97DxH/lVAVEy8rf5XHPjHjE3Cqw08qE016BdOBumXAzueBBy8Epp0JLVCOmS1hKBt7gfxqIHcKEKyUs0v4nD5Mz50uy2h0Q0dXrAsd/R2ytEetBIvcHlKL472xXpgwEUlGZGkKN42t/WKd+gDgybXa5nf64XP45Kgwj+aB2+HGuZUzMfKEfBODiRSicccRKUSURUKtVh0ogWkY6I56ZCLlQLAJi4oXyOG2RNmmwFOAuLcPiAC9RlBMtj14lSMRHaeO1JWNRdZUXv0bNqAjOFNuv1/6vqwvnn6xXLeGiIjo6EakWIkUvbcX+1scQA1QVO3Aq60vy+NX1F2RyVYSjZ8rfgU8+W/ArlWyiMU1ThDH//rE8Pv5ioDcSiA4xUquyO3K1PYUIFAGaA5oqian8hLlw4iki5gqrDvWjZ5YjyxiuzfeO7gtj8d7ZNJFjIgJJ8MIJ8JyWzd1+ThRPSqLGAFzqFsX3IpMYiKFaILwqx8RZYVwKpHiL0GioQEhr7VaxN6iRtxYdC0a96QWDCbKMmqhJhMp/WohEOkE/IWZbhJR9sxnP2Sh+bbX1iPiny0XGnw753V5jNN6ERHRmKf2El9dVq9GW+E8ud0+tQlGwsDCkoVHvAKfaFLzFwGfexzYvxbo2A29ax8a3l+HqlwVal8T0NMAJCJApN0qB94b5YEU67HElN6i5JTJiyllgiWndPhxl1/+hEi6iOm8RBkrsURI3IgPJlVkLUa2JCIyqRJLxhDTY6gIVCCTmEghmqAUislMChFlg3B7akRKMUJbdyLitQbW9gU7cELBCWgEEymUnQJTC4D9QNRZCLN9NxQmUoiOnxjd1bF72NRe9RtbAd9suL3diDrCMrbU5NZktp1ERPTRFw8DXXuHjUhpe2kN+oLnyHjzPP5XHruydvRF5omygqoCU0+XxUgksCH0d1RcfDFUsUaK+NurvwvobQR6RNl/cLt3YP8AYCSsab1Fadl85OdzBQBf4SGlIFWGHPMWAN48wJ1j/cyQ0cZi5LFbc8siZgP4qGIihWicDayMwtkIiCirpvbyl6Dtzf2AUg0YvZhRPhUuzZXp1hGNm/IZU9H2BhBz5yPxwSa4pi7OdJOIJr9QCxDvAxQVKKiBHgqhOZwD+ID9xdbaKcunLc90K4mIaDJo22bV/hJ5Jb2p69i7tReYAqjebuxKbJfrLVw47cJMt5Qoc8TJyYEkR5k1WuswhgFEOoBQs/W3Wl9LarsV6Bs4lqrF6JZ4yCrd+8bSEMAdtJIqnlQty5BtpzdVfAfrGedldGYAJlKIxpmSGpEyUBMRTWoDU3sFStC+TyzmWI2o2ohFZYsy3TKicVU7dTra0AlDcyO8azdc52a6RURZNK1X3lTA4UZo3Wp05c2Sh94Ivi7/fr6wmie8iIjoKLQMn9ar/72NaPFba27tKbPizfKa5XIRayL6kBEtgWKrYJRky4BYn5VgEYkXWTqHbI+wH+0B5FooJhDrsUovjt6Kl5lIIcpmYtRcaiuzDSEiSodQm1X7i9HZ+T4QADq9jbi09LJMt4xoXM0sqsU6/UUYWg5a6tuQn+kGEWXTQvOp9VEaX38fSeccqIiiLVCPGkcNin3WFJJERERH1Lp12LRenS++ju48K6myLm+VrK+s47ReRGnlTo0eKZxx9CdJE/1WAkYWkUzpA6K9Q471WiNcxP3EiBdZp7bFSJoMYiKFaKJwbi8imuzEHz1ijlSx6c5Hjx6Q200FLZhfPD/DjSMaXwExj6/RDWg5aG6PQyyFTUTHqd2avgtF1voo+3f0AUEg7PkApmJivpOxhYgmv3vuuQdPPPEEtm3bBq/Xi9NPPx333nsvZs2yRuBRmheaL7USKXvWN8LMnwunpw+d3hbU5dXhpKKTMttGIrtTFMDls4pYtH6SUTPdAKLsl0qgMI9CRJOdWJROLDonRvC2hRH2V8htV62PQ+TJFlRHWNbdYXemm0KUHTpSiZTCWiTb29Fqlsjd94o2wKW6MMc1J7PtIyJKg1dffRW33HIL1q5dixdeeAGJRALLli1DOGz9XUFpTqSUnIhEYyMOJK2TtLuKrYWyP133abmgNRHRseKIFKJxx0BNRFkiNRoFnlx0vl+PpMMHmEmcWGtdSUyU7Zx+HckI0J/MA5IxuaYDEaVnaq/O19ahNzhN7u4s2YallUvh6fNktn1ERGnw3HPPDdt/6KGHUFJSgrfffhtnnXVWxtqVVcJiYewWa7t4Froe+ys6CqyRKW/lvQEXXFg+bXlm20hEkx4TKUTjLrXYPPMpRDTZiUXkBH8JWreLLypTYerNOLWCC82TPfiKfOivB5JmPtC9Hyiy1nUgomOgJ4Huemu7cAb2rflfQJkH02xG2N2Di6ZdhNimWKZbSUSUdj09PbIuKBh9rv9YLCbLgN5eazVmMZpFlLEYuP9Yf24yUQ5skic4zbypSKoe7HltBwztLChqL9r9DTjVdSrccGf178DOr/+RsP/sfzoxkUI0QZhIIaJJL5xKpARK0PK+9QUw4mzCgpJPZ7ZdRBOkqLIYHfWAoRYAXXuYSCE6Hj37ASMJaG4gpwKNDTqQCzT7tiDoCmJpxVKs2mQtDkxElC0Mw8Btt92GM844A3Pnzj3iuip33333Yceff/55+HzHNqWumFYsW9W0vQCx+kmzUYC3nnoK8XYPUArsyXlXXtsqEinZ3P+jwf6z/3T8mEghGndcI4WIskQoNbWXvwhdfRqQAySLolwfhWyjelYdtq85gKQjH70tWxGsuyDTTSKavEQyUsifilhDA9rdU+XuxsptWF6zHC7Nldn2ERGNA7FWyubNm/HGG28c8X533HEHbr/99mEjUqqqquTaKsFgcMxXZIuTqBdccAGcTieykfrsS0ADUDL3LJyh5+IvBdYaW+9Vvoc5BXNQYVRkdf/t/vofCfvP/j/99NNpezwmUoiIiGhMa6QYrkJEtCK5nXuCVRPZQVmtONF7ADF3Hj7Y9SwWnJnpFhFNYp0DiZQaHFj1FmKefMCIo77gA/yfGSsz3ToiorS79dZb8cwzz+C1117DlClTjnhft9sty6HEidBjPRl6PD/7kdexS1Za6YnY/6dNSDoXAmYIzcEP8G8zVwLbsrz/R4H9Z//t3P90UdP2SEQ0Cq6RQkTZNbVXqNuDfm+x3D5h4bwMN4po4gTyPYBpwFQd2N/QnunmEGXHiJSCGux7t0luxrEbVfmVmFs0+nQ3RESTjWmaMony5JNP4qWXXkJNTU2mm5R92rfLyiyoxb691poILb6NCLgDuKCaI4iJKD04IoVonJkDG8ykEFGWTO31QYMGKCrUZC8Wzzg/060imjCqpsKp9yHhyEVHZ6ZbQ5QdI1LM3Gk40KEAQaA+fxsur70cCv9uJqIsm87r4YcfltPL5OTkoLm5WR7Pzc2F1+vNdPMmv0jn4Mj5/pYkWv0z5fa7VRtx+YzL4XXwd0xE6cERKUQTNSIl080gIkrTiJR667sfFLUVAVcgs20immAuNSzr/rBfXGKa6eYQTV5de2UV7vagyz9Nbm+o2oZLp1+a4YYREaXXr371K/T09OCcc85BeXn5YHn00Ucz3bTs0L7DqoNTUL9qE+LuPMDoR33+Dnxm1mcy3ToiyiIckUI0UXhlHRFlyYiUvl4/4APc+daweSI78XlMhONAMl5gXf0YKMl0k4gmH5GETI1I2fteHIbmgpLsQm3dNJT5yzLdOiKitE/tReOozZrWC8Uz8cHz3YAf6HFuwelVS1CTWyMXmyYiSgcmUog+hKnrMBMJmMmkrCHqgZIQdUIeN5I69FgSelzsJ6EnTZimAcVMLebEPAoRTWbiC2BqRErCKJR18QwuNE/2k5vnQVsr4NDzEWrbigATKURjJ5KQCTG6S8H+PbqcJ6HPuQ2fqP1EpltGRESTdERKXKtGs1IltzdO2YivnnBzhhtGRNmGiRTKqqs8zP5+6KEQjFAYiZ5exLpCiHaHEe+NINbXj1gojng4jnhMRyJuyGRHImEiGerHs0/WQzcUq5gadFOFDg2G6kwVB0xFhaFosjZlnSqqNnrDfLVWrTKTQkSTWKwPSEZxIOlAzFMhD809/dRMt4powuUV5QCtgNPIx54Db2NezdmZbhLR5F0fxV+B5mieHOW4t3Q3vlL99Uy3jIiIJumIlMbdAfT7SgAjgXhdP5ZULMl0y4goyzCRQh9JYoRHsqsLiY4u9Ld2I9LWg/6OPkS7+xHtiyIaiiPWbyAaMxFPqogbDiQUD5IOD5KaB7rDI5MfB9/mwVQZZaWgUW46XoqpW8vN671QF7jG50mIiCZCagHHd2M1SDp8UIwkqmZbc9oT2UlOeRDYEoWi5GN35zrMy3SDiCajLiuR0haaiYivDDANFJ1RBZ/Tl+mWERHRZNNuJVJ27wkCLiCqbMPV8z4DhdOrE1GaMZFCEzpixOjpQay5DaGGVoQOdCPc1odwZwT9fXH0R3REYyqiugNx1Ye4KwcJZ2DIWzU/VVJETPR8+PNqRgwOox9Oox8O9MNp9sOJKJyK2I/BocThUONwKDE41Tg01aqdWhxOF+CQRYHDrUF1OaG6XNCcTqgODaqmWsUham1I7YCiaVA0B/6tYzX+GWvBj+b9YNx+t0RE4y5kTevVGLFG2bmNTmgOkYkmspfcKjGlXQMMRz529+7LdHOIJvWIlJ1tdbJWEvtw+bzLMtwoIiKadOIRoHs/jKSCxni5TKTsLd+OL8+4KdMtI6IsxEQKHTUzHkd41x60b9yLnoZOVJ0zDwWL5lq3maYcQdK/rwk9e1vR29iBUGsIoe44ImEDkbgDUXgRdQWRHEyOeFMlRcyONcpFaA49ApcRhssIwY0Q3Eof3EoIXq0PHq0PXkcvvE5Rh+ByRuB2AS6/F84cP1RfHuAOAp5gqs61inuKPCaurH7jrY047eMXwenLBZxeQFwNpznH/jsyTeimjoSpQzd0JM0kEi/vB5pbAJX/3IhoEgu3ivF1SEQqADeQE4hlukVEGZE7QyyE3YC4K4iGns5MN4doUo9Iqe+rlIsCR4L1OKX0hky3ioiIJpuOnXIWkObO2QgFpsgRjjPOnw2vY8i5JiKiNOGZXTqMHo2id+sHaNu4D51729HVEkVvWEWfkouYpwCASDCUQtu2D6XmGkSTmkySxFx50DV36lHEQsTWYsTy7s7Dp7xyJXvhMXrhNbvhVXrgU7vhdXYj4OyC39WFgKcLPrUHHrUPqlOctSsFAqKUAP5iwFcI+Kal6gLAX5TaLrSSIQCSRhKhZATheBjhRBjhZKoeLN3oC+3HZmUn1u7pRxJJRJNRxPTYYBH7cT2OqG7V4ph4XH1IskTUcl9O5TUyDislokkt3Ia9TgdcyQrE3EB5lYgHRPbjL8yRU9uZqgORjoG/e4hoTDr3IBnX0OuaIXdLl1Tyb2UiIhq7Nmuh+U2hJfLCXEPfhasXfibTrSKiLMVEio0lQxF0btyFlk310N/dg2ef/QP6oi6EtDwknX4xcQuASuvOQ5L5rmSfnCor4ipBE2YcliRxJkPw6F3wmZ3wKx0IaJ3IcbYj6GlDjqcdOc4uOZpEUUzAm59KjpQCOWVAoAoILEptW8dMfzF6FKA73oOemFV6473WdrwHvdEP0NPzrrUd6x2sRaJEJD+OmjWt5rgo9hZjfvH88XsCIqLxFmrDWo8H0Ky4UH5CKj4Q2YyiKvAYIfSreVBD+YhEOuATF3EQ0dHr2oM3u+fI7xxqMoLll3wq0y0iIqLJqH07TBNo0efIXaO6C2V+MXqYiCj9mEjJcoZhILSvGZ3bGtD1QSu6GnrQ3ZVEX8yNsDMfplyQXcyndZL1AwNrjpgGfIl25OgHkKc2oMDVgOJgMwqrXPBVToUR7sKWNUn0xEuQ42pH0N2OoLcNOa4OOJW4NTVWsBLIrQSCU4Dg/NSIEitBkvQXodPhREeiD53RTnREO9DZn6qjB9DRvNk63i/2O+Woj+PhVJ3wO/3DiljM0u/ww6t50dLQglkzZsHn8sGtua3icMOjeeDSXLIW++K42HcoDvmYmqpBUzQ4VIesR9tXFa4jQESTXLgV7+lBVLmL5W7ZIusqYiI78mlx9AMoChdgT+NazKm7JNNNIpo8Yn1ylOOu8KXyYi23uh9FgUsz3SoiIpqM2rZjR08J+gI1cvfMq5ZlukVElMVsn0iJdvSi9b1dMHd3oHnNFjjkIuGqHFquqCoUTbGGmaeOqerBbXG7WBPDNAwYCQOmaQC6AUM3YIoijuumyGbA0HWYeuq+4rakDj2etEpCH1Lr0JO6fDw9aRVD1LopH0vWSRNJsZ0UU1cp0EUxRdFgQIUOB3TFAUNxQBeJksGT+L6Di5CkZqJQjTgCsWYEjSbkaY0o9IgvMvUoLIrBOWUOUD4fKD8LKJkD5E8DNIecxqor0oYTa/4MtW0rEFxwMGGSW4mILx8tRhyt/W1ojbSiJdKClnALWvs2obXlRXmsPdoOQ/y+xkAkP3Jduch15yLoDsrtgVockyV1LOgKIuAKyESJ+DnnEdY7SSQS+Pvf/46LF14Mp3Ps66IQEdlBsq8Foe5pMqa4kiEESnIz3SSijMnNU9DRA5T0VWJ3y7tMpBCNRddeRBQFcdNaa7F8phgJT0REdAzad+DNnqUiKw9XsgGnnPDxTLeIiLKY7RMpDa9txj/+IaZ/mobGHR0ZaoUy8kIiR/ujYpH2IzENeJK98OmdCBoNyFf3odDTgOKceuR5W6B4/GhzT0PhguXQplwmkycJfyHqw82o76tHfW899n/wv4PbDaEGuUbIjNwZOHfauWiLtKG16020Nj4jkyR9ib6jaroYqZHvyUeBpwCFnkIUeFO12PcerAeOiZEgRESUGVvC+1HSPVtuBx3hTDeHKKPKZhTgg3cArzENu7reyHRziCaXzj34h1GKmHea3P3Y5edlukVERDQZ6Qm0tu1BMnGDvFi4bBrX2iKi8WX7RIrmVOFK9MEUO3KBQ6uYsgZMZch+agHEgW1Ri/+LCRmH1eIW0xiyPeT4kCLGjqhyDIkBVRG1adWKAS1VW9viuA5NTR1TDTjUBByqDqcWh6Ym4FTjcGgxOJUYnFoUTqUfDiUEZ6wZfnMfHI4hU2P5ioCasxCacjl2Fk7FXs2BF9e/jByvicb6p1D//s/RFGo64sLpwu6e3di9afeIt4lRICW+EllKfaUj1iI5Iqa+IiJKt1/+8pe477770NzcjPnz5+OBBx7A4sWLM92sySvcgbWhfSgLXY6EDygu4eg9srcpp80A3tmLhLsa77XvzXRziCaX+jVorf+UvHrYFz+A/DpePUxEREcmZncxYzFZjFgcRiwK4+3H8NIHFyASqINiJHHmv1yU6WYSUZazfSKlZk4cK9Zfe/gNcjoskTBRU2XI9uBxkVixEigwdDnywypDtieYSJdETQVRRUE/FHR6VLS5PGgsqUVDXiUa3T40JPrQGN6Jnh3rh//wzuG7Yj2QqpwqVOdUozpYbW0Hq+W+SJQ8tv0xOW3XQGJkaJJETKtFRJQJjz76KG6//Xb8+te/xmmnnYb7778fF154IbZv346SkpJMN29S0rf9FWv1AizyzJP7J1xi1UR2VTh3GhzJrUg6vDD3+fBB5w5U5VhzcxOlw46//BOxN5rx6vqnoMoLuA4hvn8M3T3s9pEf95AfO4obRnpsE6Y58D0odfuQYwMPJaZAlhekyevJrIOmoSPWHYDuXiT3F55fNOrzEhHR8evb04htf3wBanMz3tvYBVXTUtcQiwuDU7U8vSXOc8kDUMSU9vImMdW9dR8xRb38zBfT1RviHJgpa2u6+1RJ3W6dDhu4Dalp6odMW2+kpq3X5cOI2fBhmIpVxKXG5uAlxzCgwVBEccDQnDBUp5zCXtRQTgZ8J8u2llU1I3+atZYjEdGkSaR8//vfx9133z3s2KxZs7Bt27ZRf+bxxx/HnXfeib1796Kurg733nsvLr74YkyEzlgv3vZ5kUqPyKLKESSp7YHj8pgYQaIPuZ/1xcFQAEMDjNQIFgMOuS3GpIjbxH3E2A4j9SVIbOuKgoQomhMJ1YG4qiGRKklNQ0LREFfFfdRUSd1fzCesAP0wISYki8KQpd/UETWTSIyavOkEujsPO5rnzkOlvxJKn4JFdYtQk1czmDwp9hUfcZH0FSetSOMrQUSUHj/96U+xYsUKXH/99XJfJFT+9re/4cEHH8S///u/j+tzr/u/v0V4bz1WN++TJ76yxe79r+PE5vNhak74k+0oW3xupptElFGqpiJP60Y7vFiwfwH+/qt7MLdoIcJNTVnz77989kzUnXVhppthWx+8uh5tWIi2NmQfb4WsfLFdOOnqL2a6NUREWa1x3Wq82VQNoBr1jfjoEJOTpGmCEoe+D5d+51/S82BERBM9ImXOnDlYtWrVwSdxjP40//znP3HNNdfgnnvuwaWXXoqHH34YV1xxBd555x3MnWstQDieduUU4vbSj1rWWqZaDj9szQ52VMS1BR6HBx7NI6fQmpIzBZWBSlkGtkUtRpYMLra+gIutE9HkFo/H8fbbb+OOO+4YPKaqKs4//3ysWbNmxJ+JxWKyDOjt7ZW1+GwUZSzef6MCSedsdLUgy8yBN/VFZ3o1kEwOmS5yiIHf11h/b9mC/bdX/4uKVbS3A27nMmA/8P5+cXRu1vz7r3/nVUxbMrYpl+zy2k+E1uAOmK1dR7yPeegXg8Pyd4eOWvmwLxJHGuVy+HNZj5caaaKkank5Weq2wfsM7JuD+y6HhnO/eaOM0URENH56vCEYyY7UWaKBQDFwebD4aD44xf3w2wbuPTDFvbyMOPW5b6Q+943B4+aw42Lv4H0M6DBUHYaShK5Y23pqW1eT0FUdSS1VqzoSahJJzTqW0HQktCRizgSijiSizgQSDnHfBJJqAmeUzsU9yx6Ay8VzWUQ0SRMpInFSVlZ2VPf92c9+hosuugjf+ta35P4Pf/hDvPDCC/jFL34hryIe75NeHocf84vmo6urC7l5ufLjXg4/FB/7qdEdohb/ibggt1LHdUOXIzbEcEdRyyL+G9gWt0GR64CIeuhxsdC6WDzdqTrhUB2yFsWluuDQDu4PK9rBba/DK5MkA8mSobW4TTyOHJr5IYb+zuz65Zf9Z/+H1naTbf1ub2+HrusoLS0ddlzsjzYyUiTyDx1JKTz//PPw+Xxjen5HsgOqIcYLZh8RUVxmDJ1TXTL5fiQijtsZ+2+T/lck4G9oQlJxHO11LpOK7ol86L91Gj/JT1Ti/+1+Fh63Z3CdxoMnwCwj/al/6H3wIT9z+P1Heh5lxNsHvutYs8GIOrUvf8b6jjTwnxylldov8ZXiKx/7d5T5j+77IhERHbvC00/FGuNO9PX1IhAIyLBgpM55YfDcl1UfPGadBxtMhptm6jyW+Gw/WIv/NFV89g85JosmP/etWoVTnPvSxLkuUbtlcWn+w85zDT03NvS4PFemueT5LlGLaehF7Xf4Ueof/r2PiGjSJVJ27tyJiooKeDweLFmyRJ6kqq4WQwkPJ64QFnPZDyXmsn/qqadGffx0nvQSrsJVQM7Ig0CGGZqgF0a7gOrQkSMf9rhjJIJZJPVfOtnmxMco2H/2n+xJjF4ZGodEcr6qqgrLli1DMBgc02MlLkjI99IFF1xgyxF+IjHH/rP/tur/imzu/6fG/BPid/D000+PS2vs5obT7kBZx3w53XF2vJ+IiCgTaovn4feXPm7NQsKYQkT00UqkiIV9H3roIbkuyoEDB2TCY+nSpdi8eTNyckS2Yrjm5uYRrxwWxyfipFd2fvEdG/af/Wf/7d3/bDrpVVRUBE3T0NIyfG4dsT/aSEm32y3LocT74VjfE8fzs9mA/Wf/2X/79p+IiIiIiCgbpT2Rsnz58sHtk046SSZWpk6disceeww33nhjWp5jPE56pePnJzv2n/1n/+3b/2zhcrlwyimn4MUXX5TrbQmGYcj9W2+9NdPNIyIiIiIiIiKiSWhcpvYaKi8vDzNnzsSuXbtGvF1cITyWK4eJiIiORIxYvO6667Bo0SIsXrwY999/P8LhMK6//vpMN42IiIiIiIiIiCah0Vb5SJtQKITdu3ejvLx8xNvFGiriSuGhxDQ74jgREdFYffazn8WPf/xj3HXXXViwYAE2bNiA55577rBpJImIiIiIiIiIiDIyIuWb3/wmLrvsMjmdV1NTE1auXCnnq7/mmmvk7ddeey0qKyvlgvHC1772NZx99tn4yU9+gksuuQSPPPII1q9fj9/85jfpbhoREdmEmMaLU3kREREREREREdFHMpHS0NAgkyYdHR0oLi7GmWeeibVr18ptob6+Hqp6cCDM6aefjocffhjf+9738N3vfhd1dXV46qmnMHfu3HQ3jYiIiIiIiIiIiIiIKLOJFDGi5EheeeWVw45dddVVshAREREREREREREREdlqjRQiIiIiIiIiIiIiIqLJiokUIiIiIiIiIiIiIiKiUTCRQkRERERERERERERENAomUoiIiIiIiIiIiIiIiEbBRAoREREREREREREREdEomEghIiIiIiIiIiIiIiIahQNZwDRNWff29h7TzycSCUQiEfnzTqcTdsP+s//sP/s/9LPU7o4npvD9xP6z/+y/XfsvMKYMx3hyfOz+O2D/2X/2n/FkKMaUY8f+s//sP/ufrniSFYmUvr4+WVdVVWW6KUREk/qzNDc3F3bHmEJEdPwYUxhPiIjSgfHEwphCRJT5eKKYWZDeNwwDTU1NyMnJgaIoY/55kZUTwWj//v0IBoOwG/af/Wf/2f8tW7Zg1qxZUFXO+Hg8MYXvJ/af/Wf/7dp/gTFlOMaT42P33wH7z/6z/4wnQzGmHDv2n/1n/9n/LWmKJ1kxIkX8EqZMmXLcjyPeUHZ8Uw1g/9l/9t++/a+srOQXlDTGFLu/n9h/9p/9t2//BcYUC+NJetj9d8D+s/927j/jyUGMKceP/Wf/2X/79r8yTfGEEYmIiIiIiIiIiIiIiGgUTKQQERERERERERERERGNgokUAG63GytXrpS1HbH/7D/7z/7btf/pZvffJ/vP/rP/9u2/wN9B+vB3yd8B+8/+s//27X+62f33yf6z/+w/++9OU/+zYrF5IiIiIiIiIiIiIiKi8cARKURERERERERERERERKNgIoWIiIiIiIiIiIiIiGgUTKQQERERERERERERERGNgokUIiIiIiIiIiIiIiKiUdg+kfLLX/4S06ZNg8fjwWmnnYY333wTdvH9738fiqIMK7Nnz0a2eu2113DZZZehoqJC9vWpp54adrtpmrjrrrtQXl4Or9eL888/Hzt37oRd+v+FL3zhsPfDRRddhGxwzz334NRTT0VOTg5KSkpwxRVXYPv27cPuE41Gccstt6CwsBCBQACf+tSn0NLSArv0/5xzzjns9f/Sl76UsTZPVnaNKYwnjCd2iScCYwpjykRgPGE8ERhPGE8YTxhPjpdd44nAmMKYYpeYYvd4MpExxdaJlEcffRS33347Vq5ciXfeeQfz58/HhRdeiNbWVtjFnDlzcODAgcHyxhtvIFuFw2H5Gos/JEbyX//1X/j5z3+OX//611i3bh38fr98P4gPGzv0XxBBZOj74c9//jOywauvvioDxtq1a/HCCy8gkUhg2bJl8ncy4Otf/zr++te/4vHHH5f3b2pqwic/+UnYpf/CihUrhr3+4t8EHT27xxTGk4MYT7I3ngiMKYwp443xhPFkAOMJ4wnjCePJ8bB7PBEYUw5iTMnemGL3eDKhMcW0scWLF5u33HLL4L6u62ZFRYV5zz33mHawcuVKc/78+aYdibf+k08+ObhvGIZZVlZm3nfffYPHuru7Tbfbbf75z382s73/wnXXXWdefvnlph20trbK38Grr746+Fo7nU7z8ccfH7zP1q1b5X3WrFljZnv/hbPPPtv82te+ltF2TXZ2jimMJ4wndo0nAmMKY0q6MZ4wngiMJ4wnjCeMJ8fLzvFEYExhTLFrTLF7PBnPmGLbESnxeBxvv/22HMo2QFVVub9mzRrYhRjGJ4a9TZ8+HZ///OdRX18PO9qzZw+am5uHvR9yc3Pl0Fc7vR9eeeUVOQRu1qxZuPnmm9HR0YFs1NPTI+uCggJZi88Cka0e+vqLIb/V1dVZ+fof2v8Bf/rTn1BUVIS5c+fijjvuQCQSyVALJx/GFMaTAYwn9oonAmMKY0o6MZ4wngxgPLEwnjCeMJ4cG8YTC2OKhTHFXjHF7vFkPGOKAzbV3t4OXddRWlo67LjY37ZtG+xAfGA+9NBD8gNEDGe6++67sXTpUmzevFnOKWcnIqAII70fBm7LdmKIoxjWV1NTg927d+O73/0uli9fLj9UNU1DtjAMA7fddhvOOOMM+cEpiNfY5XIhLy8v61//kfovfO5zn8PUqVPlH5kbN27Ed77zHTmf5BNPPJHR9k4Wdo8pjCcHMZ7YJ54IjCmMKenGeMJ4MoDxhPGE8YTx5HjYPZ4IjCkHMabYJ6bYPZ6Md0yxbSKFID8wBpx00kkyyIg31GOPPYYbb7wxo22jiXf11VcPbs+bN0++J2bMmCEz9ueddx6yhZgzUfzhlM1zox5L/2+66aZhr79YgE687uIPDPE+IDoSxhOyYzwRGFMYUyi9GE9oKMYT+2A8ofHAmEJ2jCl2jyfjHVNsO7WXGMYjMo4tLS3Djov9srIy2JHITM6cORO7du2C3Qy85nw/HCSGvop/J9n0frj11lvxzDPP4OWXX8aUKVMGj4vXWAx97u7uzurXf7T+j0T8kSlk0+s/nhhThmM8YTzJ9ngiMKYwpowHxpPhGE8YT4ZiPMnO9wDjyfhgPDkcYwpjSrbHFLvHk4mIKbZNpIghTaeccgpefPHFYUN/xP6SJUsy2rZMCYVCMgsnMnJ2I4b2iQ+Poe+H3t5erFu3zrbvh4aGBjlfZDa8H8RaY+LD9Mknn8RLL70kX++hxGeB0+kc9vqL4X1i/tRseP0/rP8j2bBhg6yz4fWfCIwpwzGeMJ5kazwRGFMYU8YT48lwjCeMJ0MxnjCeMJ4cPcaTwzGmMKZka0yxezyZ0Jhi2tgjjzxiut1u86GHHjK3bNli3nTTTWZeXp7Z3Nxs2sE3vvEN85VXXjH37Nljrl692jz//PPNoqIis7W11cxGfX195rvvviuLeOv/9Kc/ldv79u2Tt//nf/6nfP2ffvppc+PGjebll19u1tTUmP39/Wa291/c9s1vftNcs2aNfD+sWrXKPPnkk826ujozGo2ak93NN99s5ubmyvf7gQMHBkskEhm8z5e+9CWzurrafOmll8z169ebS5YskSUbfFj/d+3aZf7gBz+Q/Ravv/g3MH36dPOss87KdNMnFTvHFMYTxhO7xBOBMYUxZbwxnjCeMJ4wngxgPGE8OR52jicCYwpjil1iit3jyUTGFFsnUoQHHnhAvpFcLpe5ePFic+3ataZdfPaznzXLy8tl3ysrK+W+eGNlq5dffll+mB5arrvuOnm7YRjmnXfeaZaWlso/Ns477zxz+/btph36Lz5Yli1bZhYXF5tOp9OcOnWquWLFiqz5A2ukfovyu9/9bvA+4o+HL3/5y2Z+fr7p8/nMK6+8Un7o2qH/9fX1MngUFBTI935tba35rW99y+zp6cl00ycdu8YUxhPGE7vEE4ExhTFlIjCeMJ4IjCeMJ4wnjCfHy67xRGBMYUyxS0yxezyZyJiipJ6MiIiIiIiIiIiIiIiIDmHbNVKIiIiIiIiIiIiIiIg+DBMpREREREREREREREREo2AihYiIiIiIiIiIiIiIaBRMpBAREREREREREREREY2CiRQiIiIiIiIiIiIiIqJRMJFCREREREREREREREQ0CiZSiIiIiIiIiIiIiIiIRsFEChERERERERERERER0SiYSCHb+MIXvoArrrgiY8//r//6r/jRj340uD9t2jTcf//9GWlLe3s7SkpK0NDQkJHnJyKa7BhTDmJMISI6downBzGeEBEdO8aTgxhPaLw4xu2RiSaQoihHvH3lypX42c9+BtM0kQnvvfce/v73v+NXv/oVPgqKiopw7bXXyt/L//zP/2S6OUREHymMKWPDmEJENDLGk7FhPCEiGhnjydgwntB4YSKFssKBAwcGtx999FHcdddd2L59++CxQCAgS6Y88MADuOqqqzLahgHxeBwulwvXX389TjnlFNx3330oKCjIdLOIiD4yGFOOHmMKEdHoGE+OHuMJEdHoGE+OHuMJjSdO7UVZoaysbLDk5ubKbP3QY+LD/NBhjueccw6+8pWv4LbbbkN+fj5KS0vx29/+FuFwWH7g5uTkoLa2Fs8+++yw59q8eTOWL18uH1P8jBi+KIYNjkbXdfzlL3/BZZdddthtkUgEN9xwg3yu6upq/OY3vxl2+6ZNm/Dxj38cXq8XhYWFuOmmmxAKhYb1QbR/KNFH0dehwyl/+MMfymx8MBiUjyHMmTMHFRUVePLJJ8f0uyYiynaMKQcxphARHTvGk4MYT4iIjh3jyUGMJ5RJTKSQrf3+97+XQ/7efPNNGWBuvvlmmUU//fTT8c4772DZsmUyaIgPf6G7u1t+yC9cuBDr16/Hc889h5aWFnzmM58Z9Tk2btyInp4eLFq06LDbfvKTn8jj7777Lr785S/L5x+4qkAEtwsvvFAGvLfeeguPP/44Vq1ahVtvvXXM/fzxj3+M+fPny+e58847B48vXrwYr7/++pgfj4iIDseYwphCRJQOjCeMJ0RE6cB4wnhC6cVECtma+KD93ve+h7q6Otxxxx3weDwyyKxYsUIeE8MlOzo6ZGAQfvGLX8iAIhbQmj17ttx+8MEH8fLLL2PHjh0jPse+ffugaZpc6OpQF198sQwm4iqA73znO/K5xWMJDz/8MKLRKP7whz9g7ty5MpiJ5//jH/8oA9lYiJ/9xje+gRkzZsgyQGTnRfuIiOj4MaYwphARpQPjCeMJEVE6MJ4wnlB6cY0UsrWTTjppcFt88IuhhPPmzRs8JoYxCq2trYMLaIkP/ZHmfdy9ezdmzpx52PH+/n643e4RFwcb+vwDQzMHnmvr1q0y6Pn9/sH7nHHGGTAMQ2bwB9p2NEa6MkAQwycHrjwgIqLjw5jCmEJElA6MJ4wnRETpwHjCeELpxUQK2ZrT6Ry2Lz7Yhx4bCATig1wQczWKeR/vvffewx6rvLx8xOcQGXfxwT2w4NWHPf/Acx0NVVVhmuawY4lE4rD7DQ1MQ3V2dqK4uPion4+IiEbHmMKYQkSUDownjCdEROnAeMJ4QunFqb2IxuDkk0/G+++/LxezEkMTh5bRPrgXLFgg6y1btozpuU444QR5NYCYN3LA6tWrZSCZNWuW3BcB4cCBA8MW+RILgx0tcV8xVJOIiCYeYwoREaUD4wkREaUD4wnRkTGRQjQGt9xyi8xoX3PNNXIxLDG08R//+Aeuv/56+YE+EvHBL4LRG2+8Mabn+vznPy/nr7zuuuvkh78YXikWBxMLgQ0McRTzQP7tb3+TZdu2bXLhLrE42NEQVwy8/fbbcnExIiKaeIwpRESUDownRESUDownREfGRArRGIiFqkSGXAQQ8WEs5pa87bbbkJeXJ7Pmo/niF7+IP/3pT2N6Lp/PJwOWCGKnnnoqPv3pT+O8886Ti28NuOGGG2TQufbaa3H22Wdj+vTpOPfcc4/q8Z9++mlUV1dj6dKlY2oXERGlB2MKERGlA+MJERGlA+MJ0ZEp5qGTzRFR2onFt8TQxEcffRRLlizBR8HHPvYxfPWrX8XnPve5TDeFiIjGgDGFiIjSgfGEiIjSgfGE7IIjUogmgNfrxR/+8Ae0t7fjo0C045Of/KQcrklERJMLYwoREaUD4wkREaUD4wnZBUekEBERERERERERERERjYIjUoiIiIiIiIiIiIiIiEbBRAoREREREREREREREdEomEghIiIiIiIiIiIiIiIaBRMpREREREREREREREREo2AihYiIiIiIiIiIiIiIaBRMpBAREREREREREREREY2CiRQiIiIiIiIiIiIiIqJRMJFCREREREREREREREQ0CiZSiIiIiIiIiIiIiIiIMLL/D9nXIncxmx/oAAAAAElFTkSuQmCC",
-      "text/plain": [
-       "<Figure size 2000x1000 with 8 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
+    "{\n",
+    " \"cells\": [\n",
+    "  {\n",
+    "   \"cell_type\": \"code\",\n",
+    "   \"execution_count\": 2,\n",
+    "   \"id\": \"598e692d-d918-4a10-8f57-171c0da12624\",\n",
+    "   \"metadata\": {},\n",
+    "   \"outputs\": [],\n",
+    "   \"source\": [\n",
+    "    \"import numpy as np\\n\",\n",
+    "    \"import matplotlib.pyplot as plt\\n\",\n",
+    "    \"\\n\",\n",
+    "    \"from thermohl import solver\"\n",
+    "   ]\n",
+    "  },\n",
+    "  {\n",
+    "   \"metadata\": {},\n",
+    "   \"outputs\": [],\n",
+    "   \"source\": [\n",
+    "    \"def plot_all_params(dic):\\n\",\n",
+    "    \"    # using 1t heat equation on all power terms model sets, building solvers and\\n\",\n",
+    "    \"    # solving steady temperature\\n\",\n",
+    "    \"    models = [SolverType.SOLVER_CIGRE, SolverType.SOLVER_IEEE, SolverType.SOLVER_OLLA, SolverType.SOLVER_RTE]\\n\",\n",
+    "    \"    solvers = [solver._factory(dic, heat_equation=HeatEquationType.HEAT_EQUATION_ONE_TEMPERATURE, model=m) for m in models]\\n\",\n",
+    "    \"    results = [s.steady_temperature(return_power=True) for s in solvers]\\n\",\n",
+    "    \"\\n\",\n",
+    "    \"    # plot all\\n\",\n",
+    "    \"    fig, ax = plt.subplots(nrows=2, ncols=4, figsize=(20, 10))\\n\",\n",
+    "    \"    for i, key in enumerate([\\\"transit\\\", \\\"Ta\\\", \\\"ws\\\"]):\\n\",\n",
+    "    \"        ax[0, i].plot(dic[\\\"hour\\\"], dic[key])\\n\",\n",
+    "    \"        ax[0, i].set_title(f\\\"Input {key}\\\")\\n\",\n",
+    "    \"\\n\",\n",
+    "    \"    ax[0, 3].set_title(\\\"Conductor temperature\\\")\\n\",\n",
+    "    \"    for i, r in enumerate(results):\\n\",\n",
+    "    \"        ci = f\\\"C{1+i}\\\"\\n\",\n",
+    "    \"        ax[0, 3].plot(t, r['t'], c=ci, label=models[i])\\n\",\n",
+    "    \"        for j, p in enumerate(['P_joule', 'P_solar', 'P_convection', 'P_radiation']):\\n\",\n",
+    "    \"            ax[1, j].plot(t, r[p], c=ci, label=models[i])\\n\",\n",
+    "    \"            ax[1, j].set_title(f\\\"{p} (W/m)\\\")\\n\",\n",
+    "    \"\\n\",\n",
+    "    \"    for i in range(ax.shape[0]):\\n\",\n",
+    "    \"        for j in range(ax.shape[1]):\\n\",\n",
+    "    \"            ax[i, j].set_xlabel(\\\"Time (hour)\\\")\\n\",\n",
+    "    \"            ax[i, j].grid(True)\\n\",\n",
+    "    \"    ax[-1, -1].legend()\\n\",\n",
+    "    \"    %matplotlib inline\"\n",
+    "   ]\n",
+    "  },\n",
+    "  {\n",
+    "   \"cell_type\": \"markdown\",\n",
+    "   \"id\": \"ec9ffe0a-cc7a-482c-a8bb-303201de6705\",\n",
+    "   \"metadata\": {},\n",
+    "   \"source\": [\n",
+    "    \"We can modify the values of the dictionnary if we don't want to use the default values.\\n\",\n",
+    "    \"Missing or None values in the input dictionary are replaced with a default value, available using solver.default_values()\"\n",
+    "   ]\n",
+    "  },\n",
+    "  {\n",
+    "   \"cell_type\": \"code\",\n",
+    "   \"execution_count\": 10,\n",
+    "   \"id\": \"17464075-7c56-4879-9df3-0dc03661d585\",\n",
+    "   \"metadata\": {},\n",
+    "   \"outputs\": [],\n",
+    "   \"source\": [\n",
+    "    \"# time array (in hours)\\n\",\n",
+    "    \"t = np.linspace(0., 24, 241)[:-1]\\n\",\n",
+    "    \"\\n\",\n",
+    "    \"# input dict, with vrying transit, ambient temperature and wind speed\\n\",\n",
+    "    \"dic = dict(\\n\",\n",
+    "    \"    lat=45.2,\\n\",\n",
+    "    \"    lon=0.0,\\n\",\n",
+    "    \"    alt=543.,\\n\",\n",
+    "    \"    azm=21.,\\n\",\n",
+    "    \"    month=6,\\n\",\n",
+    "    \"    day=20,\\n\",\n",
+    "    \"    hour=t,\\n\",\n",
+    "    \"    transit=np.piecewise(t, [t < 12., t >= 12.], [300., 600.]),\\n\",\n",
+    "    \"    Ta=10. + 7.5*(1+np.sin(np.pi * (t-7.0)/12.0)),\\n\",\n",
+    "    \"    ws=np.piecewise(t, [t <= 6., t>6., t>12., t >= 18.], [1., 2., 1., 3.]),\\n\",\n",
+    "    \"    wa=69,\\n\",\n",
+    "    \"    al=0.21,\\n\",\n",
+    "    \"    tb=0.5,\\n\",\n",
+    "    \"    d=0.0,\\n\",\n",
+    "    \"    D=3.0e-02,\\n\",\n",
+    "    \"    a=0.0,\\n\",\n",
+    "    \"    A=5.69e-04,\\n\",\n",
+    "    \"    R=6.30e-02,\\n\",\n",
+    "    \"    alpha=0.9,\\n\",\n",
+    "    \"    epsilon=0.8,\\n\",\n",
+    "    \"    RDC20=5.84e-05,\\n\",\n",
+    "    \"    km=1.02,\\n\",\n",
+    "    \"    ki=0.01,\\n\",\n",
+    "    \"    kl=4.0e-03,\\n\",\n",
+    "    \"    kq=8.0e-07,\\n\",\n",
+    "    \"    RDCHigh=6.7744e-05,\\n\",\n",
+    "    \"    RDCLow=5.84e-05,\\n\",\n",
+    "    \"    THigh=60.0,\\n\",\n",
+    "    \"    TLow=20.0\\n\",\n",
+    "    \")\\n\"\n",
+    "   ]\n",
+    "  },\n",
+    "  {\n",
+    "   \"cell_type\": \"code\",\n",
+    "   \"execution_count\": 11,\n",
+    "   \"id\": \"2d04dd49-8468-4f1b-bf20-afba2974413f\",\n",
+    "   \"metadata\": {},\n",
+    "   \"outputs\": [\n",
+    "    {\n",
+    "     \"data\": {\n",
+    "      \"image/png\": \"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\",\n",
+    "      \"text/plain\": [\n",
+    "       \"<Figure size 2000x1000 with 8 Axes>\"\n",
+    "      ]\n",
+    "     },\n",
+    "     \"metadata\": {},\n",
+    "     \"output_type\": \"display_data\"\n",
+    "    }\n",
+    "   ],\n",
+    "   \"source\": [\n",
+    "    \"plot_all_params(dic)\"\n",
+    "   ]\n",
+    "  }\n",
+    " ],\n",
+    " \"metadata\": {\n",
+    "  \"kernelspec\": {\n",
+    "   \"display_name\": \"Python 3 (ipykernel)\",\n",
+    "   \"language\": \"python\",\n",
+    "   \"name\": \"python3\"\n",
+    "  },\n",
+    "  \"language_info\": {\n",
+    "   \"codemirror_mode\": {\n",
+    "    \"name\": \"ipython\",\n",
+    "    \"version\": 3\n",
+    "   },\n",
+    "   \"file_extension\": \".py\",\n",
+    "   \"mimetype\": \"text/x-python\",\n",
+    "   \"name\": \"python\",\n",
+    "   \"nbconvert_exporter\": \"python\",\n",
+    "   \"pygments_lexer\": \"ipython3\",\n",
+    "   \"version\": \"3.12.4\"\n",
+    "  }\n",
+    " },\n",
+    " \"nbformat\": 4,\n",
+    " \"nbformat_minor\": 5\n",
+    "}\n"
    ],
-   "source": [
-    "plot_all_params(dic)"
-   ]
+   "id": "cdb83d6de6584f49"
   }
  ],
  "metadata": {
diff --git a/thermohl-docs/docs/examples/ex_steady_1t.ipynb b/thermohl-docs/docs/examples/ex_steady_1t.ipynb
index be745c9..cd69a1d 100644
--- a/thermohl-docs/docs/examples/ex_steady_1t.ipynb
+++ b/thermohl-docs/docs/examples/ex_steady_1t.ipynb
@@ -10,7 +10,8 @@
     "import matplotlib.pyplot as plt\n",
     "import numpy as np\n",
     "\n",
-    "from thermohl import solver"
+    "from thermohl import solver\n",
+    "from thermohl.solver import HeatEquationType"
    ]
   },
   {
@@ -33,7 +34,7 @@
     "def example_solver1t(dic):\n",
     "    # create solver with ieee power terms and 1t heat equation; other options\n",
     "    # available are solver.cigre, solver.olla and solver.rte for power terms\n",
-    "    slvr = solver.ieee(dic, heateq=\"1t\")\n",
+    "    slvr = solver.ieee(dic, heat_equation=HeatEquationType.HEAT_EQUATION_ONE_TEMPERATURE)\n",
     "\n",
     "    # compute temperature\n",
     "    dtemp = slvr.steady_temperature()\n",
diff --git a/thermohl-docs/docs/examples/ex_steady_3t.ipynb b/thermohl-docs/docs/examples/ex_steady_3t.ipynb
index fdd766d..6af8a4f 100644
--- a/thermohl-docs/docs/examples/ex_steady_3t.ipynb
+++ b/thermohl-docs/docs/examples/ex_steady_3t.ipynb
@@ -1,123 +1,142 @@
 {
  "cells": [
   {
-   "cell_type": "code",
-   "execution_count": 1,
-   "id": "ada0d1a8-f449-4dba-8247-7d63a86db116",
    "metadata": {},
-   "outputs": [],
+   "cell_type": "raw",
    "source": [
-    "import matplotlib.pyplot as plt\n",
-    "import numpy as np\n",
-    "\n",
-    "from thermohl import solver"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "62b53960-1548-47f8-90aa-e048b9476e36",
-   "metadata": {},
-   "source": [
-    "This function plots all three temperatures (surface, core, average) of a conductor, its ampacity and solar heating during a day.\n",
-    "As excpected, we use the `3t` solver this time, but with CIGRE power terms.\n",
-    "We can observe that when the solar heating increases, all three temperatures of the conductor increase also while the ampacity of the conductor decreases.There are no huge differences between surface and core temperatures in this case."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 8,
-   "id": "e2c1e326-1f66-47b8-9bbe-756f19004ba1",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def example_solver3t(dic):\n",
-    "    # create solver with cigre power terms and 3t heat equation\n",
-    "    slvr = solver.cigre(dic, heateq=\"3t\")\n",
-    "\n",
-    "    # compute temperature\n",
-    "    dtemp = slvr.steady_temperature()\n",
-    "\n",
-    "    # compute max intensity\n",
-    "    Trep = 55.0\n",
-    "    damp = slvr.steady_intensity(Trep)\n",
-    "\n",
-    "    # plot results\n",
-    "    fig, ax = plt.subplots(nrows=3, ncols=1)\n",
-    "    ax[0].fill_between(\n",
-    "        slvr.args.hour, dtemp[\"t_surf\"], dtemp[\"t_core\"], fc=\"gray\", alpha=0.33, ec=None\n",
-    "    )\n",
-    "    ax[0].plot(\n",
-    "        slvr.args.hour,\n",
-    "        dtemp[\"t_surf\"],\n",
-    "        c=\"C0\",\n",
-    "        label=\"Surface Conductor temperature (C)\",\n",
-    "    )\n",
-    "    ax[0].plot(\n",
-    "        slvr.args.hour,\n",
-    "        dtemp[\"t_avg\"],\n",
-    "        c=\"C1\",\n",
-    "        label=\"average Conductor temperature (C)\",\n",
-    "    )\n",
-    "    ax[0].plot(\n",
-    "        slvr.args.hour, dtemp[\"t_core\"], c=\"C3\", label=\"Core Conductor temperature (C)\"\n",
-    "    )\n",
-    "    ax[0].axhline(Trep, ls=\"--\", c=\"C1\", label=\"Maximum temperature for ampacity\")\n",
-    "    ax[1].plot(slvr.args.hour, dic[\"transit\"], c=\"C0\", label=\"Transit (A)\")\n",
-    "    ax[1].plot(slvr.args.hour, damp[\"transit\"], c=\"C1\", label=\"Conductor ampacity (A)\")\n",
-    "    ax[2].plot(slvr.args.hour, dtemp[\"P_solar\"], label=\"Solar heating power (W/m)\")\n",
-    "    for i in range(3):\n",
-    "        ax[i].grid(True)\n",
-    "        ax[i].legend()\n",
-    "    ax[2].set_xlabel(\"Hour\")\n",
-    "    %matplotlib inline\n",
-    "    plt.show()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 9,
-   "id": "fb9189d8-315d-45ca-b69b-7ae29e884bb2",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import matplotlib\n",
-    "\n",
-    "matplotlib.use(\"TkAgg\")\n",
-    "plt.close(\"all\")\n",
-    "\n",
-    "# Generate input dict (for the sake of simplicity, only a few inputs are\n",
-    "# used, the rest is filled with default values).\n",
-    "dic = dict(\n",
-    "    lat=46.1,\n",
-    "    alt=123.0,\n",
-    "    azm=31.0,\n",
-    "    month=6,\n",
-    "    day=20,\n",
-    "    hour=np.linspace(0.0, 23.0, 24),\n",
-    "    transit=np.array([600.0 for i in range(12)] + [900.0 for i in range(12)]),\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 10,
-   "id": "a16ef744-0954-42bf-8435-af76ff54de62",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 640x480 with 3 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
+    "{\n",
+    " \"cells\": [\n",
+    "  {\n",
+    "   \"cell_type\": \"code\",\n",
+    "   \"execution_count\": 1,\n",
+    "   \"id\": \"ada0d1a8-f449-4dba-8247-7d63a86db116\",\n",
+    "   \"metadata\": {},\n",
+    "   \"outputs\": [],\n",
+    "   \"source\": [\n",
+    "    \"import matplotlib.pyplot as plt\\n\",\n",
+    "    \"import numpy as np\\n\",\n",
+    "    \"\\n\",\n",
+    "    \"from thermohl import solver\\n\",\n",
+    "    \"from thermohl.solver import HeatEquationType\\n\"\n",
+    "   ]\n",
+    "  },\n",
+    "  {\n",
+    "   \"cell_type\": \"markdown\",\n",
+    "   \"id\": \"62b53960-1548-47f8-90aa-e048b9476e36\",\n",
+    "   \"metadata\": {},\n",
+    "   \"source\": [\n",
+    "    \"This function plots all three temperatures (surface, core, average) of a conductor, its ampacity and solar heating during a day.\\n\",\n",
+    "    \"As excpected, we use the `3t` solver this time, but with CIGRE power terms.\\n\",\n",
+    "    \"We can observe that when the solar heating increases, all three temperatures of the conductor increase also while the ampacity of the conductor decreases.There are no huge differences between surface and core temperatures in this case.\"\n",
+    "   ]\n",
+    "  },\n",
+    "  {\n",
+    "   \"cell_type\": \"code\",\n",
+    "   \"execution_count\": 8,\n",
+    "   \"id\": \"e2c1e326-1f66-47b8-9bbe-756f19004ba1\",\n",
+    "   \"metadata\": {},\n",
+    "   \"outputs\": [],\n",
+    "   \"source\": [\n",
+    "    \"def example_solver3t(dic):\\n\",\n",
+    "    \"    # create solver with cigre power terms and 3t heat equation\\n\",\n",
+    "    \"    slvr = solver.cigre(dic, heat_equation=HeatEquationType.HEAT_EQUATION_THREE_TEMPERATURES)\\n\",\n",
+    "    \"\\n\",\n",
+    "    \"    # compute temperature\\n\",\n",
+    "    \"    dtemp = slvr.steady_temperature()\\n\",\n",
+    "    \"\\n\",\n",
+    "    \"    # compute max intensity\\n\",\n",
+    "    \"    Trep = 55.0\\n\",\n",
+    "    \"    damp = slvr.steady_intensity(Trep)\\n\",\n",
+    "    \"\\n\",\n",
+    "    \"    # plot results\\n\",\n",
+    "    \"    fig, ax = plt.subplots(nrows=3, ncols=1)\\n\",\n",
+    "    \"    ax[0].fill_between(slvr.args.hour, dtemp['t_surf'], dtemp['t_core'], fc='gray', alpha=0.33, ec=None)\\n\",\n",
+    "    \"    ax[0].plot(slvr.args.hour, dtemp['t_surf'], c='C0', label='Surface Conductor temperature (C)')\\n\",\n",
+    "    \"    ax[0].plot(slvr.args.hour, dtemp['t_avg'], c='C1', label='average Conductor temperature (C)')\\n\",\n",
+    "    \"    ax[0].plot(slvr.args.hour, dtemp['t_core'], c='C3', label='Core Conductor temperature (C)')\\n\",\n",
+    "    \"    ax[0].axhline(Trep, ls=\\\"--\\\", c='C1', label=\\\"Maximum temperature for ampacity\\\")\\n\",\n",
+    "    \"    ax[1].plot(slvr.args.hour, dic['I'], c='C0', label=\\\"Transit (A)\\\")\\n\",\n",
+    "    \"    ax[1].plot(slvr.args.hour, damp['I'], c='C1', label='Conductor ampacity (A)')\\n\",\n",
+    "    \"    ax[2].plot(slvr.args.hour, dtemp['P_solar'], label=\\\"Solar heating power (W/m)\\\")\\n\",\n",
+    "    \"    for i in range(3):\\n\",\n",
+    "    \"        ax[i].grid(True)\\n\",\n",
+    "    \"        ax[i].legend()\\n\",\n",
+    "    \"    ax[2].set_xlabel(\\\"Hour\\\")\\n\",\n",
+    "    \"    %matplotlib inline\\n\",\n",
+    "    \"    plt.show()\"\n",
+    "   ]\n",
+    "  },\n",
+    "  {\n",
+    "   \"cell_type\": \"code\",\n",
+    "   \"execution_count\": 9,\n",
+    "   \"id\": \"fb9189d8-315d-45ca-b69b-7ae29e884bb2\",\n",
+    "   \"metadata\": {},\n",
+    "   \"outputs\": [],\n",
+    "   \"source\": [\n",
+    "    \"import matplotlib\\n\",\n",
+    "    \"\\n\",\n",
+    "    \"matplotlib.use(\\\"TkAgg\\\")\\n\",\n",
+    "    \"plt.close(\\\"all\\\")\\n\",\n",
+    "    \"\\n\",\n",
+    "    \"# Generate input dict (for the sake of simplicity, only a few inputs are\\n\",\n",
+    "    \"# used, the rest is filled with default values).\\n\",\n",
+    "    \"dic = dict(\\n\",\n",
+    "    \"    lat=46.1,\\n\",\n",
+    "    \"    alt=123.0,\\n\",\n",
+    "    \"    azm=31.0,\\n\",\n",
+    "    \"    month=6,\\n\",\n",
+    "    \"    day=20,\\n\",\n",
+    "    \"    hour=np.linspace(0.0, 23.0, 24),\\n\",\n",
+    "    \"    transit=np.array([600.0 for i in range(12)] + [900.0 for i in range(12)]),\\n\",\n",
+    "    \")\"\n",
+    "   ]\n",
+    "  },\n",
+    "  {\n",
+    "   \"cell_type\": \"code\",\n",
+    "   \"execution_count\": 10,\n",
+    "   \"id\": \"a16ef744-0954-42bf-8435-af76ff54de62\",\n",
+    "   \"metadata\": {},\n",
+    "   \"outputs\": [\n",
+    "    {\n",
+    "     \"data\": {\n",
+    "      \"image/png\": \"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\",\n",
+    "      \"text/plain\": [\n",
+    "       \"<Figure size 640x480 with 3 Axes>\"\n",
+    "      ]\n",
+    "     },\n",
+    "     \"metadata\": {},\n",
+    "     \"output_type\": \"display_data\"\n",
+    "    }\n",
+    "   ],\n",
+    "   \"source\": [\n",
+    "    \"example_solver3t(dic)\"\n",
+    "   ]\n",
+    "  }\n",
+    " ],\n",
+    " \"metadata\": {\n",
+    "  \"kernelspec\": {\n",
+    "   \"display_name\": \"Python 3 (ipykernel)\",\n",
+    "   \"language\": \"python\",\n",
+    "   \"name\": \"python3\"\n",
+    "  },\n",
+    "  \"language_info\": {\n",
+    "   \"codemirror_mode\": {\n",
+    "    \"name\": \"ipython\",\n",
+    "    \"version\": 3\n",
+    "   },\n",
+    "   \"file_extension\": \".py\",\n",
+    "   \"mimetype\": \"text/x-python\",\n",
+    "   \"name\": \"python\",\n",
+    "   \"nbconvert_exporter\": \"python\",\n",
+    "   \"pygments_lexer\": \"ipython3\",\n",
+    "   \"version\": \"3.12.4\"\n",
+    "  }\n",
+    " },\n",
+    " \"nbformat\": 4,\n",
+    " \"nbformat_minor\": 5\n",
+    "}\n"
    ],
-   "source": [
-    "example_solver3t(dic)"
-   ]
+   "id": "b391797fa4e804bb"
   }
  ],
  "metadata": {
diff --git a/thermohl-docs/docs/examples/ex_transient_3t.ipynb b/thermohl-docs/docs/examples/ex_transient_3t.ipynb
index 86d6ee8..63dc18d 100644
--- a/thermohl-docs/docs/examples/ex_transient_3t.ipynb
+++ b/thermohl-docs/docs/examples/ex_transient_3t.ipynb
@@ -1,115 +1,147 @@
 {
  "cells": [
   {
-   "cell_type": "code",
-   "execution_count": 3,
-   "id": "756e1159-fcbe-4fda-8de9-1e4c1c87214d",
    "metadata": {},
-   "outputs": [],
+   "cell_type": "raw",
    "source": [
-    "import matplotlib.pyplot as plt\n",
-    "import numpy as np\n",
-    "\n",
-    "from thermohl import solver"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "454c9c02-11c1-49a7-800b-3cc28c8f5046",
-   "metadata": {},
-   "source": [
-    "This function plots conductor temperatures (surface, average and core) when a step of transit occurs. Simulation made with the 3t solver and RTE power terms. "
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 7,
-   "id": "54a4c33b-f71b-43b1-a9d0-a1ddf1230154",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def example_solver3t_transient(dic):\n",
-    "    # create solver with rte power terms and 3t heat equation\n",
-    "    slvr = solver.rte(dic, heateq=\"3t\")\n",
-    "\n",
-    "    # change solver args to get initial state, compute initial values of surface\n",
-    "    # and core temperature using steady temperature\n",
-    "    slvr.args[\"transit\"] = 400.0\n",
-    "    slvr.update()\n",
-    "    dtstdy = slvr.steady_temperature()\n",
-    "    T_surf = dtstdy[\"t_surf\"].values\n",
-    "    T_core = dtstdy[\"t_core\"].values\n",
-    "\n",
-    "    # restore initial transit in dic\n",
-    "    slvr.args[\"transit\"] = dic[\"transit\"]\n",
-    "    slvr.update()\n",
-    "\n",
-    "    # compute temperature\n",
-    "    dtemp = slvr.transient_temperature(t, Ts0=T_surf, Tc0=T_core, return_power=True)\n",
-    "\n",
-    "    # plot\n",
-    "    fig, ax = plt.subplots(nrows=1, ncols=1)\n",
-    "    tm = t / 60\n",
-    "    ax.fill_between(\n",
-    "        tm, dtemp[\"t_surf\"], dtemp[\"t_core\"], fc=\"gray\", alpha=0.33, ec=None\n",
-    "    )\n",
-    "    ax.plot(tm, dtemp[\"t_surf\"], c=\"C0\", label=\"Surface Conductor temperature (C)\")\n",
-    "    ax.plot(tm, dtemp[\"t_avg\"], c=\"C1\", label=\"average Conductor temperature (C)\")\n",
-    "    ax.plot(tm, dtemp[\"t_core\"], c=\"C3\", label=\"Core Conductor temperature (C)\")\n",
-    "    ax.set_xlabel(\"Time (hour)\")\n",
-    "    ax.set_ylabel(\"Temperature (C)\")\n",
-    "    ax.grid(True)\n",
-    "    ax.legend()\n",
-    "    %matplotlib inline\n",
-    "    plt.show()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 8,
-   "id": "65ce6328-af5c-43e6-b389-2ec8157c348a",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import matplotlib\n",
-    "\n",
-    "matplotlib.use(\"TkAgg\")\n",
-    "plt.close(\"all\")\n",
-    "\n",
-    "# Generate input dict (for the sake of simplicity, only a few inputs are\n",
-    "# used, the rest is filled with default values).\n",
-    "dic = dict(\n",
-    "    lat=46.1,\n",
-    "    alt=123.0,\n",
-    "    azm=31.0,\n",
-    "    month=6,\n",
-    "    day=20,\n",
-    "    hour=0.0,\n",
-    "    transit=700.0,\n",
-    ")\n",
-    "t = np.linspace(0, 3600, 901)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 9,
-   "id": "349c1e0c-af4e-4331-95da-4e0f353a651d",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 640x480 with 1 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
+    "{\n",
+    " \"cells\": [\n",
+    "  {\n",
+    "   \"metadata\": {},\n",
+    "   \"cell_type\": \"code\",\n",
+    "   \"outputs\": [],\n",
+    "   \"execution_count\": null,\n",
+    "   \"source\": [\n",
+    "    \"import matplotlib.pyplot as plt\\n\",\n",
+    "    \"import numpy as np\\n\",\n",
+    "    \"\\n\",\n",
+    "    \"from thermohl import solver\\n\",\n",
+    "    \"from thermohl.solver import HeatEquationType\"\n",
+    "   ],\n",
+    "  },\n",
+    "  {\n",
+    "   \"cell_type\": \"markdown\",\n",
+    "   \"id\": \"454c9c02-11c1-49a7-800b-3cc28c8f5046\",\n",
+    "   \"metadata\": {},\n",
+    "   \"source\": [\n",
+    "    \"This function plots conductor temperatures (surface, average and core) when a step of transit occurs. Simulation made with the 3t solver and RTE power terms. \"\n",
+    "   ]\n",
+    "  },\n",
+    "  {\n",
+    "   \"cell_type\": \"code\",\n",
+    "   \"execution_count\": 7,\n",
+    "   \"id\": \"54a4c33b-f71b-43b1-a9d0-a1ddf1230154\",\n",
+    "   \"metadata\": {},\n",
+    "   \"outputs\": [],\n",
+    "   \"source\": [\n",
+    "    \"def example_solver3t_transient(dic):\\n\",\n",
+    "    \"    # create solver with rte power terms and 3t heat equation\\n\",\n",
+    "    \"    slvr = solver.rte(dic, heat_equation=HeatEquationType.HEAT_EQUATION_THREE_TEMPERATURES)\\n\",\n",
+    "    \"\\n\",\n",
+    "    \"    # change solver args to get initial state, compute initial values of surface\\n\",\n",
+    "    \"    # and core temperature using steady temperature\\n\",\n",
+    "    \"    slvr.args[\\\"transit\\\"] = 400.0\\n\",\n",
+    "    \"    slvr.update()\\n\",\n",
+    "    \"    dtstdy = slvr.steady_temperature()\\n\",\n",
+    "    \"    T_surf = dtstdy['t_surf'].values\\n\",\n",
+    "    \"    T_core = dtstdy['t_core'].values\\n\",\n",
+    "    \"\\n\",\n",
+    "    \"    # restore initial transit in dic\\n\",\n",
+    "    \"    slvr.args[\\\"I\\\"] = dic[\\\"I\\\"]\\n\",\n",
+    "    \"    slvr.update()\\n\",\n",
+    "    \"\\n\",\n",
+    "    \"    # compute temperature\\n\",\n",
+    "    \"    dtemp = slvr.transient_temperature(t, Ts0=T_surf, Tc0=T_core, return_power=True)\\n\",\n",
+    "    \"\\n\",\n",
+    "    \"    # plot\\n\",\n",
+    "    \"    fig, ax = plt.subplots(nrows=1, ncols=1)\\n\",\n",
+    "    \"    tm = t / 60\\n\",\n",
+    "    \"    ax.fill_between(\\n\",\n",
+    "    \"        tm, dtemp[\\\"t_surf\\\"], dtemp[\\\"t_core\\\"], fc=\\\"gray\\\", alpha=0.33, ec=None\\n\",\n",
+    "    \"    )\\n\",\n",
+    "    \"    ax.plot(tm, dtemp[\\\"t_surf\\\"], c=\\\"C0\\\", label=\\\"Surface Conductor temperature (C)\\\")\\n\",\n",
+    "    \"    ax.plot(tm, dtemp[\\\"t_avg\\\"], c=\\\"C1\\\", label=\\\"average Conductor temperature (C)\\\")\\n\",\n",
+    "    \"    ax.plot(tm, dtemp[\\\"t_core\\\"], c=\\\"C3\\\", label=\\\"Core Conductor temperature (C)\\\")\\n\",\n",
+    "    \"    ax.set_xlabel(\\\"Time (hour)\\\")\\n\",\n",
+    "    \"    ax.set_ylabel(\\\"Temperature (C)\\\")\\n\",\n",
+    "    \"    ax.grid(True)\\n\",\n",
+    "    \"    ax.legend()\\n\",\n",
+    "    \"    %matplotlib inline\\n\",\n",
+    "    \"    plt.show()\"\n",
+    "   ]\n",
+    "  },\n",
+    "  {\n",
+    "   \"cell_type\": \"code\",\n",
+    "   \"execution_count\": 8,\n",
+    "   \"id\": \"65ce6328-af5c-43e6-b389-2ec8157c348a\",\n",
+    "   \"metadata\": {},\n",
+    "   \"outputs\": [],\n",
+    "   \"source\": [\n",
+    "    \"import matplotlib\\n\",\n",
+    "    \"\\n\",\n",
+    "    \"matplotlib.use(\\\"TkAgg\\\")\\n\",\n",
+    "    \"plt.close(\\\"all\\\")\\n\",\n",
+    "    \"\\n\",\n",
+    "    \"# Generate input dict (for the sake of simplicity, only a few inputs are\\n\",\n",
+    "    \"# used, the rest is filled with default values).\\n\",\n",
+    "    \"dic = dict(\\n\",\n",
+    "    \"    lat=46.1,\\n\",\n",
+    "    \"    alt=123.0,\\n\",\n",
+    "    \"    azm=31.0,\\n\",\n",
+    "    \"    month=6,\\n\",\n",
+    "    \"    day=20,\\n\",\n",
+    "    \"    hour=0.0,\\n\",\n",
+    "    \"    transit=700.0,\\n\",\n",
+    "    \")\\n\",\n",
+    "    \"t = np.linspace(0, 3600, 901)\"\n",
+    "   ]\n",
+    "  },\n",
+    "  {\n",
+    "   \"cell_type\": \"code\",\n",
+    "   \"execution_count\": 9,\n",
+    "   \"id\": \"349c1e0c-af4e-4331-95da-4e0f353a651d\",\n",
+    "   \"metadata\": {},\n",
+    "   \"outputs\": [\n",
+    "    {\n",
+    "     \"data\": {\n",
+    "      \"image/png\": \"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\",\n",
+    "      \"text/plain\": [\n",
+    "       \"<Figure size 640x480 with 1 Axes>\"\n",
+    "      ]\n",
+    "     },\n",
+    "     \"metadata\": {},\n",
+    "     \"output_type\": \"display_data\"\n",
+    "    }\n",
+    "   ],\n",
+    "   \"source\": [\n",
+    "    \"example_solver3t_transient(dic)\"\n",
+    "   ]\n",
+    "  }\n",
+    " ],\n",
+    " \"metadata\": {\n",
+    "  \"kernelspec\": {\n",
+    "   \"display_name\": \"Python 3 (ipykernel)\",\n",
+    "   \"language\": \"python\",\n",
+    "   \"name\": \"python3\"\n",
+    "  },\n",
+    "  \"language_info\": {\n",
+    "   \"codemirror_mode\": {\n",
+    "    \"name\": \"ipython\",\n",
+    "    \"version\": 3\n",
+    "   },\n",
+    "   \"file_extension\": \".py\",\n",
+    "   \"mimetype\": \"text/x-python\",\n",
+    "   \"name\": \"python\",\n",
+    "   \"nbconvert_exporter\": \"python\",\n",
+    "   \"pygments_lexer\": \"ipython3\",\n",
+    "   \"version\": \"3.12.4\"\n",
+    "  }\n",
+    " },\n",
+    " \"nbformat\": 4,\n",
+    " \"nbformat_minor\": 5\n",
+    "}\n"
    ],
-   "source": [
-    "example_solver3t_transient(dic)"
-   ]
+   "id": "4425a6fc34f3b87c"
   }
  ],
  "metadata": {
diff --git a/thermohl-docs/docs/getting-started.md b/thermohl-docs/docs/getting-started.md
index e07a795..26b613a 100644
--- a/thermohl-docs/docs/getting-started.md
+++ b/thermohl-docs/docs/getting-started.md
@@ -1,4 +1,4 @@
-<!--
+from thermohl.solver import HeatEquationTypefrom thermohl.solver import SolverType<!--
 SPDX-FileCopyrightText: 2025 RTE (https://www.rte-france.com)
 
 This Source Code Form is subject to the terms of the Mozilla Public
@@ -80,8 +80,9 @@ surface temperature (°C) of a conductor in steady-state regime along with the c
 
 ```python
 from thermohl import solver
+from thermohl.solver.heat_equation_enum import HeatEquationType
 
-slvr = solver.ieee(dic=None, heateq='1t')
+slvr = solver.ieee(dic=None, heat_equation=HeatEquationType.HEAT_EQUATION_ONE_TEMPERATURE)
 temp = slvr.steady_temperature() 
 ```
 
@@ -103,8 +104,9 @@ distinct ampacities (and the lower the ambient temperature, the higher the ampac
 ```python
 import numpy as np
 from thermohl import solver
+from thermohl.solver.heat_equation_enum import HeatEquationType
 
-slvr = solver.ieee(dict(Ta=np.array([0., 15., 30.])), heateq='1t')
+slvr = solver.ieee(dict(Ta=np.array([0., 15., 30.])), heat_equation=HeatEquationType.HEAT_EQUATION_ONE_TEMPERATURE)
 Tmax = 80.
 imax = slvr.steady_intensity(Tmax)
 ```

From 52659ffdb7c4f8292fae401c7ed68f28da9e04bd Mon Sep 17 00:00:00 2001
From: Olivier Pigeon <olivier.pigeon@rte-france.com>
Date: Fri, 28 Nov 2025 11:23:15 +0100
Subject: [PATCH 2/6] feat(#2): Refactor thermohl/solver/__init__.py

Signed-off-by: Olivier Pigeon <olivier.pigeon@rte-france.com>
---
 src/thermohl/solver/__init__.py | 80 +++++++++++++--------------------
 1 file changed, 32 insertions(+), 48 deletions(-)

diff --git a/src/thermohl/solver/__init__.py b/src/thermohl/solver/__init__.py
index eae3d06..2f5a692 100644
--- a/src/thermohl/solver/__init__.py
+++ b/src/thermohl/solver/__init__.py
@@ -36,58 +36,42 @@ def _factory(
     heat_equation: HeatEquationType = HeatEquationType.HEAT_EQUATION_ONE_TEMPERATURE,
     model: SolverType = SolverType.SOLVER_CIGRE,
 ) -> Solver:
-    solver: concreteSolverType
+
     solver = create_solver_from_heat_equation(heat_equation)
 
-    if model == SolverType.SOLVER_CIGRE:
-        return solver(
-            dic,
-            cigrep.JouleHeating,
-            cigrep.SolarHeating,
-            cigrep.ConvectiveCooling,
-            cigrep.RadiativeCooling,
-        )
-    elif model == SolverType.SOLVER_IEEE:
-        return solver(
-            dic,
-            ieeep.JouleHeating,
-            ieeep.SolarHeating,
-            ieeep.ConvectiveCooling,
-            ieeep.RadiativeCooling,
-        )
-    elif model == SolverType.SOLVER_OLLA:
-        return solver(
-            dic,
-            ollap.JouleHeating,
-            ollap.SolarHeating,
-            ollap.ConvectiveCooling,
-            ollap.RadiativeCooling,
-        )
-    elif model == SolverType.SOLVER_RTE:
-        return solver(
-            dic,
-            rtep.JouleHeating,
-            rtep.SolarHeating,
-            rtep.ConvectiveCooling,
-            rtep.RadiativeCooling,
-        )
-    else:
-        raise ValueError()
-
-
-def create_solver_from_heat_equation(heat_equation: HeatEquationType):
-    if heat_equation == HeatEquationType.HEAT_EQUATION_ONE_TEMPERATURE:
-        solver = Solver1T
-    elif heat_equation == HeatEquationType.HEAT_EQUATION_THREE_TEMPERATURES:
-        solver = Solver3T
-    elif heat_equation == HeatEquationType.HEAT_EQUATION_THREE_TEMPERATURES_LEGACY:
-        solver = Solver3TL
-    elif heat_equation == HeatEquationType.HEAT_EQUATION_1D:
-        solver = Solver1D
-    else:
+    solver_modules = {
+        SolverType.SOLVER_CIGRE: cigrep,
+        SolverType.SOLVER_IEEE: ieeep,
+        SolverType.SOLVER_OLLA: ollap,
+        SolverType.SOLVER_RTE: rtep,
+    }
+
+    if model not in solver_modules:
+        raise ValueError(f"Unsupported solver model: {model}")
+
+    module = solver_modules[model]
+    return solver(
+        dic,
+        module.JouleHeating,
+        module.SolarHeating,
+        module.ConvectiveCooling,
+        module.RadiativeCooling,
+    )
+
+
+
+def create_solver_from_heat_equation(heat_equation: HeatEquationType) -> concreteSolverType:
+    heat_equations_solvers = {
+        HeatEquationType.HEAT_EQUATION_ONE_TEMPERATURE: Solver1T,
+        HeatEquationType.HEAT_EQUATION_THREE_TEMPERATURES: Solver3T,
+        HeatEquationType.HEAT_EQUATION_THREE_TEMPERATURES_LEGACY: Solver3TL,
+        HeatEquationType.HEAT_EQUATION_1D: Solver1D
+    }
+
+    if heat_equation not in heat_equations_solvers:
         raise ValueError(f"Invalid HeatEquation value {heat_equation.value}")
 
-    return solver
+    return heat_equations_solvers[heat_equation]
 
 
 def __solver_model(dic: Optional[Dict[str, Any]] = None,

From d98222652d6b32061a00fd81a3991a39652d44ac Mon Sep 17 00:00:00 2001
From: Olivier Pigeon <olivier.pigeon@rte-france.com>
Date: Fri, 28 Nov 2025 17:14:20 +0100
Subject: [PATCH 3/6] feat(#2): Create enumeration to replace Solver.Names

Signed-off-by: Olivier Pigeon <olivier.pigeon@rte-france.com>
---
 README.md                                     |  4 +-
 examples/example_solver_intensity.py          |  5 +-
 examples/example_transient.py                 | 11 ++-
 examples/example_transient2.py                |  7 +-
 src/thermohl/solver/__init__.py               |  4 +-
 src/thermohl/solver/base.py                   | 38 +++----
 src/thermohl/solver/enums/__init__.py         |  0
 .../solver/enums/heat_equation_type.py        | 16 +++
 src/thermohl/solver/enums/solver_type.py      | 14 +++
 src/thermohl/solver/enums/variable_type.py    | 32 ++++++
 src/thermohl/solver/heat_equation_enum.py     |  9 --
 src/thermohl/solver/slv1t.py                  | 47 ++++-----
 src/thermohl/solver/slv3t.py                  | 99 ++++++++++---------
 src/thermohl/solver/slv3t_legacy.py           |  8 +-
 src/thermohl/solver/solver_type.py            |  7 --
 src/thermohl/uncertainties.py                 |  7 +-
 test/functional_test/functional_test.py       | 24 ++---
 test/test_shape.py                            | 19 ++--
 test/test_solver1t.py                         | 33 ++++---
 test/test_solver3t.py                         | 33 ++++---
 test/unit/solver/test_slv1t.py                | 98 +++++++++---------
 .../docs/examples/ex_transient_3t.ipynb       | 68 +++++--------
 thermohl-docs/docs/getting-started.md         |  4 +-
 23 files changed, 310 insertions(+), 277 deletions(-)
 create mode 100644 src/thermohl/solver/enums/__init__.py
 create mode 100644 src/thermohl/solver/enums/heat_equation_type.py
 create mode 100644 src/thermohl/solver/enums/solver_type.py
 create mode 100644 src/thermohl/solver/enums/variable_type.py
 delete mode 100644 src/thermohl/solver/heat_equation_enum.py
 delete mode 100644 src/thermohl/solver/solver_type.py

diff --git a/README.md b/README.md
index dab8f90..a3a5cd1 100644
--- a/README.md
+++ b/README.md
@@ -138,7 +138,7 @@ surface temperature (°C) of a conductor in steady-state regime along with the c
 
 ```python
 from thermohl import solver
-from thermohl.solver.heat_equation_enum import HeatEquationType
+from thermohl.solver.enums.heat_equation_type import HeatEquationType
 
 slvr = solver.ieee(dic=None, heat_equation=HeatEquationType.HEAT_EQUATION_ONE_TEMPERATURE)
 temp = slvr.steady_temperature() 
@@ -162,7 +162,7 @@ distinct ampacities (and the lower the ambient temperature, the higher the ampac
 ```python
 import numpy as np
 from thermohl import solver
-from thermohl.solver.heat_equation_enum import HeatEquationType
+from thermohl.solver.enums.heat_equation_type import HeatEquationType
 
 slvr = solver.ieee(dict(Ta=np.array([0., 15., 30.])), heat_equation=HeatEquationType.HEAT_EQUATION_ONE_TEMPERATURE)
 Tmax = 80.
diff --git a/examples/example_solver_intensity.py b/examples/example_solver_intensity.py
index 2531e58..8282da9 100644
--- a/examples/example_solver_intensity.py
+++ b/examples/example_solver_intensity.py
@@ -13,6 +13,7 @@
 import pandas as pd
 
 from thermohl import solver
+from thermohl.solver.enums.variable_type import VariableType
 
 
 def test_solve(dct, Trep, tol=1.0e-06, mxi=64):
@@ -83,9 +84,9 @@ def test_solve(dct, Trep, tol=1.0e-06, mxi=64):
         slv = d["model"]
         df = slv.steady_intensity(Trep, tol=tol, maxiter=mxi, return_power=True)
         df["pb"] = (
-            df["P_joule"] + df["P_solar"] - df["P_convection"] - df["P_radiation"]
+            df[VariableType.POWER_JOULE] + df[VariableType.POWER_SUN] - df[VariableType.POWER_CONVECTION] - df[VariableType.POWER_RADIATION]
         )
-        slv.dc["transit"] = df["I_max"].values
+        slv.dc[VariableType.TRANSIT] = df["I_max"].values
         df["TIrep"] = slv.steady_temperature(return_power=False)["T_surf"]
 
         ax[0, i].hist(df["pb"], bins=100)
diff --git a/examples/example_transient.py b/examples/example_transient.py
index 894ea7d..6bed3b0 100644
--- a/examples/example_transient.py
+++ b/examples/example_transient.py
@@ -11,7 +11,8 @@
 import numpy as np
 
 from thermohl import solver
-from thermohl.solver.solver_type import SolverType
+from thermohl.solver.enums.solver_type import SolverType
+from thermohl.solver.enums.variable_type import VariableType
 
 if __name__ == "__main__":
     import matplotlib
@@ -65,9 +66,9 @@
     plt.figure()
     for i, key in enumerate(slv):
         elm = slv[key]
-        elm.dc["transit"] = transit
+        elm.dc[VariableType.TRANSIT] = I
         df = elm.steady_temperature()
-        elm.dc["transit"] = np.nan
+        elm.dc[VariableType.TRANSIT] = np.nan
         cl = "C%d" % (i % 10,)
         T1 = df["T_surf"].values
         T2 = elm.transient_temperature(t, T0=np.array(T1[0]), transit=transit)["T_surf"]
@@ -83,9 +84,9 @@
     # only rte but with core temp
     plt.figure()
     elm = slv["rte"]
-    elm.dc["transit"] = transit
+    elm.dc[VariableType.TRANSIT] = I
     df = elm.steady_temperature(return_avg=True, return_core=True)
-    elm.dc["transit"] = np.nan
+    elm.dc[VariableType.TRANSIT] = np.nan
     cl = "C0"
     dg = elm.transient_temperature(
         t, T0=T1[0], transit=transit, return_avg=True, return_core=True
diff --git a/examples/example_transient2.py b/examples/example_transient2.py
index bd85789..9c10947 100644
--- a/examples/example_transient2.py
+++ b/examples/example_transient2.py
@@ -11,7 +11,8 @@
 import numpy as np
 
 from thermohl import solver
-from thermohl.solver.solver_type import SolverType
+from thermohl.solver.enums.solver_type import SolverType
+from thermohl.solver.enums.variable_type import VariableType
 
 if __name__ == "__main__":
     import matplotlib
@@ -66,10 +67,10 @@
     plt.figure()
     for i, key in enumerate(slv):
         elm = slv[key]
-        elm.dc["transit"] = transit[:, 1]
+        elm.dc[VariableType.TRANSIT] = I[:, 1]
         elm.dc["Ta"] = elm.dc["Ta"][1]
         df = elm.steady_temperature()
-        elm.dc["transit"] = np.nan
+        elm.dc[VariableType.TRANSIT] = np.nan
         elm.dc["Ta"] = dct["Ta"]
         cl = "C%d" % (i % 10,)
         T1 = df["T_surf"].values
diff --git a/src/thermohl/solver/__init__.py b/src/thermohl/solver/__init__.py
index 2f5a692..3b2cc4c 100644
--- a/src/thermohl/solver/__init__.py
+++ b/src/thermohl/solver/__init__.py
@@ -15,12 +15,12 @@
 from thermohl.power import olla as ollap
 
 from thermohl.solver.base import Args, Solver
-from thermohl.solver.heat_equation_enum import HeatEquationType
+from thermohl.solver.enums.heat_equation_type import HeatEquationType
 from thermohl.solver.slv1d import Solver1D
 from thermohl.solver.slv1t import Solver1T
 from thermohl.solver.slv3t import Solver3T
 from thermohl.solver.slv3t_legacy import Solver3TL
-from thermohl.solver.solver_type import SolverType
+from thermohl.solver.enums.solver_type import SolverType
 
 concreteSolverType = Union[
     Type[Solver1T], Type[Solver3T], Type[Solver3TL], Type[Solver1D]
diff --git a/src/thermohl/solver/base.py b/src/thermohl/solver/base.py
index aebce35..0d7d642 100644
--- a/src/thermohl/solver/base.py
+++ b/src/thermohl/solver/base.py
@@ -23,6 +23,7 @@
     numberArrayLike,
 )
 from thermohl.power import PowerTerm
+from thermohl.solver.enums.variable_type import VariableType
 
 
 class _DEFPARAM:
@@ -189,33 +190,6 @@ class Solver(ABC):
     __init__ function.
     """
 
-    class Names:
-        pjle = "P_joule"
-        psol = "P_solar"
-        pcnv = "P_convection"
-        prad = "P_radiation"
-        ppre = "P_precipitation"
-        err = "err"
-        surf = "surf"
-        avg = "avg"
-        core = "core"
-        time = "time"
-        transit = "transit"
-        temp = "t"
-        tsurf = "t_surf"
-        tavg = "t_avg"
-        tcore = "t_core"
-
-        @staticmethod
-        def powers() -> tuple[str, str, str, str, str]:
-            return (
-                Solver.Names.pjle,
-                Solver.Names.psol,
-                Solver.Names.pcnv,
-                Solver.Names.prad,
-                Solver.Names.ppre,
-            )
-
     def __init__(
         self,
         dic: Optional[dict[str, Any]] = None,
@@ -266,6 +240,16 @@ def balance(self, T: floatArrayLike) -> floatArrayLike:
             - self.pc.value(T)
         )
 
+    @staticmethod
+    def powers() -> tuple[VariableType, VariableType, VariableType, VariableType, VariableType]:
+        return (
+            VariableType.POWER_JOULE,
+            VariableType.POWER_SUN,
+            VariableType.POWER_CONVECTION,
+            VariableType.POWER_RADIATION,
+            VariableType.POWER_RAIN,
+        )
+
     @abstractmethod
     def steady_temperature(self) -> pd.DataFrame:
         raise NotImplementedError
diff --git a/src/thermohl/solver/enums/__init__.py b/src/thermohl/solver/enums/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/src/thermohl/solver/enums/heat_equation_type.py b/src/thermohl/solver/enums/heat_equation_type.py
new file mode 100644
index 0000000..3ec5a0a
--- /dev/null
+++ b/src/thermohl/solver/enums/heat_equation_type.py
@@ -0,0 +1,16 @@
+# SPDX-FileCopyrightText: 2025 RTE (https://www.rte-france.com)
+#
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+# SPDX-License-Identifier: MPL-2.0
+
+from enum import Enum
+
+class HeatEquationType(Enum):
+
+    HEAT_EQUATION_ONE_TEMPERATURE = "1t",
+    HEAT_EQUATION_THREE_TEMPERATURES = "3t",
+    HEAT_EQUATION_THREE_TEMPERATURES_LEGACY = "3tl",
+    HEAT_EQUATION_1D = "1d"
+
diff --git a/src/thermohl/solver/enums/solver_type.py b/src/thermohl/solver/enums/solver_type.py
new file mode 100644
index 0000000..9179b0b
--- /dev/null
+++ b/src/thermohl/solver/enums/solver_type.py
@@ -0,0 +1,14 @@
+# SPDX-FileCopyrightText: 2025 RTE (https://www.rte-france.com)
+#
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+# SPDX-License-Identifier: MPL-2.0
+
+from enum import Enum
+
+class SolverType(Enum):
+    SOLVER_CIGRE = "cigre",
+    SOLVER_IEEE = "ieee",
+    SOLVER_OLLA = "olla",
+    SOLVER_RTE = "rte"
\ No newline at end of file
diff --git a/src/thermohl/solver/enums/variable_type.py b/src/thermohl/solver/enums/variable_type.py
new file mode 100644
index 0000000..1101275
--- /dev/null
+++ b/src/thermohl/solver/enums/variable_type.py
@@ -0,0 +1,32 @@
+# SPDX-FileCopyrightText: 2025 RTE (https://www.rte-france.com)
+#
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+# SPDX-License-Identifier: MPL-2.0
+
+
+from enum import Enum
+from typing import Union, List
+
+
+class VariableType(Enum):
+
+    POWER_JOULE = "P_joule"
+    POWER_SUN = "P_solar"
+    POWER_CONVECTION = "P_convection"
+    POWER_RADIATION = "P_radiation"
+    POWER_RAIN = "P_precipitation"
+    ERROR = "err"
+    SURFACE = "surf"
+    AVERAGE = "avg"
+    CORE = "core"
+    TIME = "time"
+    TRANSIT = "I"
+    TEMPERATURE = "t"
+    TEMPERATURE_SURFACE = "t_surf"
+    TEMPERATURE_AVERAGE = "t_avg"
+    TEMPERATURE_CORE = "t_core"
+
+
+VariableTypeListLike = Union[VariableType, List[VariableType]]
\ No newline at end of file
diff --git a/src/thermohl/solver/heat_equation_enum.py b/src/thermohl/solver/heat_equation_enum.py
deleted file mode 100644
index 5627d6f..0000000
--- a/src/thermohl/solver/heat_equation_enum.py
+++ /dev/null
@@ -1,9 +0,0 @@
-from enum import Enum
-
-class HeatEquationType(Enum):
-
-    HEAT_EQUATION_ONE_TEMPERATURE = "1t",
-    HEAT_EQUATION_THREE_TEMPERATURES = "3t",
-    HEAT_EQUATION_THREE_TEMPERATURES_LEGACY = "3tl",
-    HEAT_EQUATION_1D = "1d"
-
diff --git a/src/thermohl/solver/slv1t.py b/src/thermohl/solver/slv1t.py
index adfdd39..3012074 100644
--- a/src/thermohl/solver/slv1t.py
+++ b/src/thermohl/solver/slv1t.py
@@ -15,6 +15,7 @@
 from thermohl.solver.base import Solver as Solver_
 from thermohl.solver.base import _DEFPARAM as DP
 from thermohl.solver.base import _set_dates, reshape
+from thermohl.solver.enums.variable_type import VariableType
 from thermohl.utils import bisect_v
 
 
@@ -50,17 +51,17 @@ def steady_temperature(
         )
 
         # format output
-        df = pd.DataFrame(data=T, columns=[Solver_.Names.temp])
+        df = pd.DataFrame(data=T, columns=[VariableType.TEMPERATURE])
 
         if return_err:
-            df[Solver_.Names.err] = err
+            df[VariableType.ERROR] = err
 
         if return_power:
-            df[Solver_.Names.pjle] = self.jh.value(T)
-            df[Solver_.Names.psol] = self.sh.value(T)
-            df[Solver_.Names.pcnv] = self.cc.value(T)
-            df[Solver_.Names.prad] = self.rc.value(T)
-            df[Solver_.Names.ppre] = self.pc.value(T)
+            df[VariableType.POWER_JOULE] = self.jh.value(T)
+            df[VariableType.POWER_SUN] = self.sh.value(T)
+            df[VariableType.POWER_CONVECTION] = self.cc.value(T)
+            df[VariableType.POWER_RADIATION] = self.rc.value(T)
+            df[VariableType.POWER_RAIN] = self.pc.value(T)
 
         return df
 
@@ -135,26 +136,26 @@ def transient_temperature(
             )
 
         # save results
-        dr = dict(time=time, T=T)
+        dr = {VariableType.TIME:time, VariableType.TEMPERATURE:T}
 
-        # manage return dict 2 : powers
+        # manage return dict 2: powers
         if return_power:
-            for c in Solver_.Names.powers():
+            for c in Solver_.powers():
                 dr[c] = np.zeros_like(T)
             for i in range(N):
                 for k in de.keys():
                     self.args[k] = de[k][i, :]
                 self.update()
-                dr[Solver_.Names.pjle][i, :] = self.jh.value(T[i, :])
-                dr[Solver_.Names.psol][i, :] = self.sh.value(T[i, :])
-                dr[Solver_.Names.pcnv][i, :] = self.cc.value(T[i, :])
-                dr[Solver_.Names.prad][i, :] = self.rc.value(T[i, :])
-                dr[Solver_.Names.ppre][i, :] = self.pc.value(T[i, :])
+                dr[VariableType.POWER_JOULE][i, :] = self.jh.value(T[i, :])
+                dr[VariableType.POWER_SUN][i, :] = self.sh.value(T[i, :])
+                dr[VariableType.POWER_CONVECTION][i, :] = self.cc.value(T[i, :])
+                dr[VariableType.POWER_RADIATION][i, :] = self.rc.value(T[i, :])
+                dr[VariableType.POWER_RAIN][i, :] = self.pc.value(T[i, :])
 
         # squeeze return values if n is 1
         if n == 1:
             keys = list(dr.keys())
-            keys.remove(Solver_.Names.time)
+            keys.remove(VariableType.TIME)
             for k in keys:
                 dr[k] = dr[k][:, 0]
 
@@ -213,16 +214,16 @@ def fun(i: floatArray) -> floatArrayLike:
         self.args.transit = transit
 
         # format output
-        df = pd.DataFrame(data=A, columns=[Solver_.Names.transit])
+        df = pd.DataFrame(data=A, columns=[VariableType.TRANSIT])
 
         if return_err:
-            df[Solver_.Names.err] = err
+            df[VariableType.ERROR] = err
 
         if return_power:
-            df[Solver_.Names.pjle] = self.jh.value(T)
-            df[Solver_.Names.psol] = self.sh.value(T)
-            df[Solver_.Names.pcnv] = self.cc.value(T)
-            df[Solver_.Names.prad] = self.rc.value(T)
-            df[Solver_.Names.ppre] = self.pc.value(T)
+            df[VariableType.POWER_JOULE] = self.jh.value(T)
+            df[VariableType.POWER_SUN] = self.sh.value(T)
+            df[VariableType.POWER_CONVECTION] = self.cc.value(T)
+            df[VariableType.POWER_RADIATION] = self.rc.value(T)
+            df[VariableType.POWER_RAIN] = self.pc.value(T)
 
         return df
diff --git a/src/thermohl/solver/slv3t.py b/src/thermohl/solver/slv3t.py
index 581882f..c98517f 100644
--- a/src/thermohl/solver/slv3t.py
+++ b/src/thermohl/solver/slv3t.py
@@ -13,6 +13,7 @@
 from thermohl import floatArrayLike, floatArray, strListLike, intArray
 from thermohl.power import PowerTerm
 from thermohl.solver.base import Solver as Solver_, _DEFPARAM as DP, _set_dates, reshape
+from thermohl.solver.enums.variable_type import VariableType, VariableTypeListLike
 from thermohl.solver.slv1t import Solver1T
 from thermohl.utils import quasi_newton_2d
 
@@ -230,18 +231,18 @@ def steady_temperature(
         # format output
         z = self.average(x, y)
         df = pd.DataFrame(
-            {Solver_.Names.tsurf: x, Solver_.Names.tavg: z, Solver_.Names.tcore: y}
+            {VariableType.TEMPERATURE_SURFACE: x, VariableType.TEMPERATURE_AVERAGE: z, VariableType.TEMPERATURE_CORE: y}
         )
 
         if return_err:
-            df[Solver_.Names.err] = err
+            df[VariableType.ERROR] = err
 
         if return_power:
-            df[Solver_.Names.pjle] = self.joule(x, y)
-            df[Solver_.Names.psol] = self.sh.value(x)
-            df[Solver_.Names.pcnv] = self.cc.value(x)
-            df[Solver_.Names.prad] = self.rc.value(x)
-            df[Solver_.Names.ppre] = self.pc.value(x)
+            df[VariableType.POWER_JOULE] = self.joule(x, y)
+            df[VariableType.POWER_SUN] = self.sh.value(x)
+            df[VariableType.POWER_CONVECTION] = self.cc.value(x)
+            df[VariableType.POWER_RADIATION] = self.rc.value(x)
+            df[VariableType.POWER_RAIN] = self.pc.value(x)
 
         return df
 
@@ -256,26 +257,26 @@ def _morgan_transient(self):
 
     def _transient_temperature_results(self, time, ts, ta, tc, return_power, n):
         dr = {
-            Solver_.Names.time: time,
-            Solver_.Names.tsurf: ts,
-            Solver_.Names.tavg: ta,
-            Solver_.Names.tcore: tc,
+            VariableType.TIME: time,
+            VariableType.TEMPERATURE_SURFACE: ts,
+            VariableType.TEMPERATURE_AVERAGE: ta,
+            VariableType.TEMPERATURE_CORE: tc,
         }
 
         if return_power:
-            for power in Solver_.Names.powers():
+            for power in Solver_.powers():
                 dr[power] = np.zeros_like(ts)
 
             for i in range(len(time)):
-                dr[Solver_.Names.pjle][i, :] = self.joule(ts[i, :], tc[i, :])
-                dr[Solver_.Names.psol][i, :] = self.sh.value(ts[i, :])
-                dr[Solver_.Names.pcnv][i, :] = self.cc.value(ts[i, :])
-                dr[Solver_.Names.prad][i, :] = self.rc.value(ts[i, :])
-                dr[Solver_.Names.ppre][i, :] = self.pc.value(ts[i, :])
+                dr[VariableType.POWER_JOULE][i, :] = self.joule(ts[i, :], tc[i, :])
+                dr[VariableType.POWER_SUN][i, :] = self.sh.value(ts[i, :])
+                dr[VariableType.POWER_CONVECTION][i, :] = self.cc.value(ts[i, :])
+                dr[VariableType.POWER_RADIATION][i, :] = self.rc.value(ts[i, :])
+                dr[VariableType.POWER_RAIN][i, :] = self.pc.value(ts[i, :])
 
         if n == 1:
             keys = list(dr.keys())
-            keys.remove(Solver_.Names.time)
+            keys.remove(VariableType.TIME)
             for k in keys:
                 dr[k] = dr[k][:, 0]
 
@@ -364,10 +365,10 @@ def _check_target(target, d, max_len):
         Validates and processes the target temperature input.
 
         Args:
-            target (str | list[str]): The target temperature(s) to be validated. It can be:
-                - "auto": which sets the target automatically.
-                - A string: must be one of Solver_.Names.surf, Solver_.Names.avg, or Solver_.Names.core.
-                - A list of strings: each string must be one of Solver_.Names.surf, Solver_.Names.avg, or Solver_.Names.core.
+            target (VariableType | list[VariableType]): The target temperature(s) to be validated. It can be:
+                - None: which sets the target automatically.
+                - A VariableType: must be one of VariableType.SURFACE, VariableType.AVERAGE, or VariableType.CORE.
+                - A list of VariableType: each string must be one of VariableType.SURFACE, VariableType.AVERAGE, or VariableType.CORE.
             max_len (int): The expected length of the target list if target is a list.
 
         Returns:
@@ -377,23 +378,23 @@ def _check_target(target, d, max_len):
             ValueError: If the target is invalid or its length doesn't match max_len.
         """
         # check target
-        if target == "auto":
+        if target is None:
             d_ = d * np.ones(max_len)
             target_ = np.array(
                 [
-                    Solver_.Names.core if d_[i] > 0.0 else Solver_.Names.avg
+                    VariableType.CORE if d_[i] > 0.0 else VariableType.AVERAGE
                     for i in range(max_len)
                 ]
             )
-        elif isinstance(target, str):
+        elif isinstance(target, VariableType):
             if target not in [
-                Solver_.Names.surf,
-                Solver_.Names.avg,
-                Solver_.Names.core,
+                VariableType.SURFACE,
+                VariableType.AVERAGE,
+                VariableType.CORE,
             ]:
                 raise ValueError(
                     f"Target temperature should be in "
-                    f"{[Solver_.Names.surf, Solver_.Names.avg, Solver_.Names.core]};"
+                    f"{[VariableType.SURFACE, VariableType.AVERAGE, VariableType.CORE]};"
                     f" got {target} instead."
                 )
             else:
@@ -403,16 +404,16 @@ def _check_target(target, d, max_len):
                 raise ValueError()
             for t in target:
                 if t not in [
-                    Solver_.Names.surf,
-                    Solver_.Names.avg,
-                    Solver_.Names.core,
+                    VariableType.SURFACE,
+                    VariableType.AVERAGE,
+                    VariableType.CORE,
                 ]:
                     raise ValueError()
             target_ = np.array(target)
         return target_
 
     def _steady_intensity_header(
-        self, T: floatArrayLike, target: strListLike
+        self, T: floatArrayLike, target: VariableTypeListLike
     ) -> Tuple[np.ndarray, Callable]:
         """Format input for ampacity solver."""
 
@@ -424,9 +425,9 @@ def _steady_intensity_header(
         c, D, d, ix = self.mgc
         a, b = _profile_bim_avg_coeffs(0.5 * d, 0.5 * D)
 
-        js = np.nonzero(target_ == Solver_.Names.surf)[0]
-        ja = np.nonzero(target_ == Solver_.Names.avg)[0]
-        jc = np.nonzero(target_ == Solver_.Names.core)[0]
+        js = np.nonzero(target_ == VariableType.SURFACE)[0]
+        ja = np.nonzero(target_ == VariableType.AVERAGE)[0]
+        jc = np.nonzero(target_ == VariableType.CORE)[0]
         jx = np.intersect1d(ix, ja)
 
         # get correct input for quasi-newton solver
@@ -453,7 +454,7 @@ def newtheader(i: floatArray, tg: floatArray) -> Tuple[floatArray, floatArray]:
     def steady_intensity(
         self,
         T: floatArrayLike = np.array([]),
-        target: strListLike = "auto",
+        target: VariableTypeListLike = None,
         tol: float = DP.tol,
         maxiter: int = DP.maxiter,
         return_err: bool = False,
@@ -465,7 +466,7 @@ def steady_intensity(
 
         Args:
             T (float | numpy.ndarray): Initial temperature profile. Default is an empty numpy array.
-            target (str | list[str]): Target specification for the solver. Default is "auto".
+            target (VariableType | list[VariableType]): Target specification for the solver. Default is None.
             tol (float): Tolerance for the solver. Default is DP.tol.
             maxiter (int): Maximum number of iterations for the solver. Default is DP.maxiter.
             return_err (bool): If True, return the error in the output DataFrame. Default is False.
@@ -499,7 +500,7 @@ def morgan(i: floatArray, tg: floatArray) -> floatArray:
         x, y, cnt, err = quasi_newton_2d(
             balance,
             morgan,
-            r[Solver_.Names.transit].values,
+            r[VariableType.TRANSIT].values,
             Tmax,
             relative_tolerance=tol,
             max_iterations=maxiter,
@@ -510,25 +511,25 @@ def morgan(i: floatArray, tg: floatArray) -> floatArray:
             print(f"rstat_analytic max err is {np.max(err):.3E} in {cnt:d} iterations")
 
         # format output
-        df = pd.DataFrame({Solver_.Names.transit: x})
+        df = pd.DataFrame({VariableType.TRANSIT: x})
 
         if return_err:
-            df["err"] = err
+            df[VariableType.ERROR] = err
 
         if return_temp or return_power:
             ts, tc = newtheader(x, y)
             ta = self.average(ts, tc)
 
             if return_temp:
-                df[Solver_.Names.tsurf] = ts
-                df[Solver_.Names.tavg] = ta
-                df[Solver_.Names.tcore] = tc
+                df[VariableType.TEMPERATURE_SURFACE] = ts
+                df[VariableType.TEMPERATURE_AVERAGE] = ta
+                df[VariableType.TEMPERATURE_CORE] = tc
 
             if return_power:
-                df[Solver_.Names.pjle] = self.jh.value(ta)
-                df[Solver_.Names.psol] = self.sh.value(ts)
-                df[Solver_.Names.pcnv] = self.cc.value(ts)
-                df[Solver_.Names.prad] = self.rc.value(ts)
-                df[Solver_.Names.ppre] = self.pc.value(ts)
+                df[VariableType.POWER_JOULE] = self.jh.value(ta)
+                df[VariableType.POWER_SUN] = self.sh.value(ts)
+                df[VariableType.POWER_CONVECTION] = self.cc.value(ts)
+                df[VariableType.POWER_RADIATION] = self.rc.value(ts)
+                df[VariableType.POWER_RAIN] = self.pc.value(ts)
 
         return df
diff --git a/src/thermohl/solver/slv3t_legacy.py b/src/thermohl/solver/slv3t_legacy.py
index fc207a5..2b781e8 100644
--- a/src/thermohl/solver/slv3t_legacy.py
+++ b/src/thermohl/solver/slv3t_legacy.py
@@ -12,10 +12,12 @@
 from thermohl import floatArrayLike, floatArray, strListLike, intArray
 from thermohl.power import PowerTerm
 from thermohl.solver.base import Solver as Solver_
+from thermohl.solver.enums.variable_type import VariableType
 from thermohl.solver.slv3t import Solver3T
 
 
 class Solver3TL(Solver3T):
+
     def __init__(
         self,
         dic: Optional[dict[str, Any]] = None,
@@ -91,9 +93,9 @@ def _steady_intensity_header(
         target_ = self._check_target(target, self.args.d, max_len)
 
         # pre-compute indexes
-        surface_indices = np.nonzero(target_ == Solver_.Names.surf)[0]
-        average_indices = np.nonzero(target_ == Solver_.Names.avg)[0]
-        core_indices = np.nonzero(target_ == Solver_.Names.core)[0]
+        surface_indices = np.nonzero(target_ == VariableType.SURFACE)[0]
+        average_indices = np.nonzero(target_ == VariableType.AVERAGE)[0]
+        core_indices = np.nonzero(target_ == VariableType.CORE)[0]
 
         def newtheader(i: floatArray, tg: floatArray) -> Tuple[floatArray, floatArray]:
             self.args.transit = i
diff --git a/src/thermohl/solver/solver_type.py b/src/thermohl/solver/solver_type.py
deleted file mode 100644
index 31ba770..0000000
--- a/src/thermohl/solver/solver_type.py
+++ /dev/null
@@ -1,7 +0,0 @@
-from enum import Enum
-
-class SolverType(Enum):
-    SOLVER_CIGRE = "cigre",
-    SOLVER_IEEE = "ieee",
-    SOLVER_OLLA = "olla",
-    SOLVER_RTE = "rte"
\ No newline at end of file
diff --git a/src/thermohl/uncertainties.py b/src/thermohl/uncertainties.py
index 4dce926..71f9151 100644
--- a/src/thermohl/uncertainties.py
+++ b/src/thermohl/uncertainties.py
@@ -14,6 +14,7 @@
 import numpy as np
 import pandas as pd
 
+from thermohl.solver.enums.variable_type import VariableType
 from thermohl.utils import depends_on_optional
 
 try:
@@ -152,7 +153,7 @@ def _generate_samples(
 
 
 def _rdict(
-    mode: str, target: str, return_surf: bool, return_core: bool, return_avg: bool
+    mode: str, target: VariableType, return_surf: bool, return_core: bool, return_avg: bool
 ) -> dict:
     """Code factorization"""
     if mode == "temperature":
@@ -184,7 +185,7 @@ def _compute(mode: str, s: solver.Solver, tmx: Union[float, np.ndarray], rdc: di
 def _steady_uncertainties(
     s: solver.Solver,
     tmax: Union[float, np.ndarray],
-    target: str,
+    target: VariableType,
     u: dict,
     ns: int,
     return_surf: bool,
@@ -269,7 +270,7 @@ def temperature(
 def intensity(
     s: solver.Solver,
     tmax: Union[float, np.ndarray],
-    target: str = "surf",
+    target: VariableType = VariableType.SURFACE,
     u: dict = {},
     ns: int = 4999,
     return_core: bool = False,
diff --git a/test/functional_test/functional_test.py b/test/functional_test/functional_test.py
index 5f969b1..ba26a70 100644
--- a/test/functional_test/functional_test.py
+++ b/test/functional_test/functional_test.py
@@ -14,6 +14,7 @@
 from typing import List, Dict
 
 from thermohl.solver import rte, HeatEquationType
+from thermohl.solver.enums.variable_type import VariableType
 
 
 def cable_data(s: str) -> dict:
@@ -58,7 +59,7 @@ def scn2dict(d: dict) -> dict:
         dt.hour + dt.minute / 60.0 + (dt.second + dt.microsecond * 1.0e-06) / 3600.0
     )
     if "iac" in d.keys():
-        dic["transit"] = d["iac"]
+        dic[VariableType.TRANSIT.value] = d["iac"]
 
     return dic
 
@@ -69,9 +70,9 @@ def test_steady_temperature():
             s = rte(scn2dict(e), heat_equation=HeatEquationType.HEAT_EQUATION_THREE_TEMPERATURES_LEGACY)
             r = s.steady_temperature()
 
-            assert np.allclose(r["t_surf"], e["T_surf"], atol=0.05)
-            assert np.allclose(r["t_avg"], e["T_mean"], atol=0.05)
-            assert np.allclose(r["t_core"], e["T_heart"], atol=0.05)
+            assert np.allclose(r[VariableType.TEMPERATURE_SURFACE], e["T_surf"], atol=0.05)
+            assert np.allclose(r[VariableType.TEMPERATURE_AVERAGE], e["T_mean"], atol=0.05)
+            assert np.allclose(r[VariableType.TEMPERATURE_CORE], e["T_heart"], atol=0.05)
 
 
 def test_steady_ampacity():
@@ -80,7 +81,7 @@ def test_steady_ampacity():
             s = rte(scn2dict(e), heat_equation=HeatEquationType.HEAT_EQUATION_THREE_TEMPERATURES_LEGACY)
             r = s.steady_intensity(T=e["Tmax_cable"])
 
-            assert np.allclose(r["transit"], e["I_max"], atol=0.05)
+            assert np.allclose(r[VariableType.TRANSIT], e["I_max"], atol=0.05)
 
 
 def test_transient_temperature():
@@ -93,16 +94,17 @@ def test_transient_temperature():
 
     for d in scenario("temperature", "transient"):
         for _, e in d.items():
+
             # solver
             s = rte(scn2dict(e), heat_equation=HeatEquationType.HEAT_EQUATION_THREE_TEMPERATURES_LEGACY)
 
             # initial steady state
-            s.args["transit"] = e["I0_cable"]
+            s.args[VariableType.TRANSIT.value] = e["I0_cable"]
             s.update()
             ri = s.steady_temperature()
 
             # final steady state
-            s.args["transit"] = e["iac"]
+            s.args[VariableType.TRANSIT.value] = e["iac"]
             s.update()
             rf = s.steady_temperature(Tsg=e["T_mean_final"], Tcg=e["T_mean_final"])
 
@@ -111,18 +113,18 @@ def test_transient_temperature():
 
             # transient temperature (linearized)
             rl = s.transient_temperature_legacy(
-                time=time, Ts0=ri["t_surf"], Tc0=ri["t_core"], tau=tau
+                time=time, Ts0=ri[VariableType.TEMPERATURE_SURFACE], Tc0=ri[VariableType.TEMPERATURE_CORE], tau=tau
             )
 
             # check final temp
-            assert np.isclose(e["T_mean_final"], rf["t_avg"][0], atol=atol)
+            assert np.isclose(e["T_mean_final"], rf[VariableType.TEMPERATURE_AVERAGE][0], atol=atol)
 
             # check transient temp
             for k1, k2 in zip(
                 ["T_surf_transient", "T_mean_transient", "T_heart_transient"],
-                ["t_surf", "t_avg", "t_core"],
+                [VariableType.TEMPERATURE_SURFACE, VariableType.TEMPERATURE_AVERAGE, VariableType.TEMPERATURE_CORE],
             ):
                 expected_time = np.array(list(e[k1].keys())) * minute
                 expected_temp = np.array(list(e[k1].values()))
-                estimated_temp = np.interp(expected_time, rl["time"], rl[k2])
+                estimated_temp = np.interp(expected_time, rl[VariableType.TIME], rl[k2])
                 assert np.allclose(expected_temp, estimated_temp, atol=atol)
diff --git a/test/test_shape.py b/test/test_shape.py
index a81828f..df6cd50 100644
--- a/test/test_shape.py
+++ b/test/test_shape.py
@@ -10,6 +10,7 @@
 
 from thermohl import solver
 from thermohl.solver import HeatEquationType, SolverType
+from thermohl.solver.enums.variable_type import VariableType
 
 
 def _solvers():
@@ -22,9 +23,9 @@ def _solvers():
 
 def _ampargs(s: solver.Solver, t: pd.DataFrame):
     if isinstance(s, solver.Solver1T):
-        a = dict(T=t[solver.Solver.Names.temp].values)
+        a = dict(T=t[VariableType.TEMPERATURE].values)
     elif isinstance(s, solver.Solver3T):
-        a = dict(T=t[solver.Solver.Names.tsurf].values, target=solver.Solver.Names.surf)
+        a = dict(T=t[VariableType.TEMPERATURE_SURFACE].values, target=VariableType.SURFACE)
     else:
         raise NotImplementedError
     return a
@@ -32,12 +33,12 @@ def _ampargs(s: solver.Solver, t: pd.DataFrame):
 
 def _traargs(s: solver.Solver, ds: pd.DataFrame, t):
     if isinstance(s, solver.Solver1T):
-        a = dict(time=t, T0=ds[solver.Solver.Names.temp].values)
+        a = dict(time=t, T0=ds[VariableType.TEMPERATURE].values)
     elif isinstance(s, solver.Solver3T):
         a = dict(
             time=t,
-            Ts0=ds[solver.Solver.Names.tsurf].values,
-            Tc0=ds[solver.Solver.Names.tcore].values,
+            Ts0=ds[VariableType.TEMPERATURE_SURFACE].values,
+            Tc0=ds[VariableType.TEMPERATURE_CORE].values,
         )
     else:
         raise NotImplementedError
@@ -113,13 +114,13 @@ def test_transient_0():
         a = _traargs(s, ds, t)
 
         r = s.transient_temperature(**a)
-        assert len(r.pop("time")) == len(t)
+        assert len(r.pop(VariableType.TIME)) == len(t)
         for k in r.keys():
             assert r[k].shape == (len(t),)
 
         r = s.transient_temperature(**{**a, "return_power": True})
 
-        assert len(r.pop("time")) == len(t)
+        assert len(r.pop(VariableType.TIME)) == len(t)
         for k in r.keys():
             assert r[k].shape == (len(t),)
 
@@ -136,11 +137,11 @@ def test_transient_1():
         a = _traargs(s, ds, t)
 
         r = s.transient_temperature(**a)
-        assert len(r.pop("time")) == len(t)
+        assert len(r.pop(VariableType.TIME)) == len(t)
         for k in r.keys():
             assert r[k].shape == (len(t), n)
 
         r = s.transient_temperature(**{**a, "return_power": True})
-        assert len(r.pop("time")) == len(t)
+        assert len(r.pop(VariableType.TIME)) == len(t)
         for k in r.keys():
             assert r[k].shape == (len(t), n)
diff --git a/test/test_solver1t.py b/test/test_solver1t.py
index 46f17bc..c047fd9 100644
--- a/test/test_solver1t.py
+++ b/test/test_solver1t.py
@@ -9,7 +9,8 @@
 
 from thermohl import solver
 from thermohl.solver import SolverType
-from thermohl.solver.heat_equation_enum import HeatEquationType
+from thermohl.solver.enums.heat_equation_type import HeatEquationType
+from thermohl.solver.enums.variable_type import VariableType
 
 _nprs = 123456
 
@@ -43,17 +44,17 @@ def test_balance():
         df = s.steady_temperature(
             return_err=True, return_power=True, tol=tol, maxiter=64
         )
-        assert np.all(df["err"] < tol)
+        assert np.all(df[VariableType.ERROR] < tol)
         bl = np.abs(
-            df["P_joule"]
-            + df["P_solar"]
-            - df["P_convection"]
-            - df["P_radiation"]
-            - df["P_precipitation"]
+            df[VariableType.POWER_JOULE]
+            + df[VariableType.POWER_SUN]
+            - df[VariableType.POWER_CONVECTION]
+            - df[VariableType.POWER_RADIATION]
+            - df[VariableType.POWER_RAIN]
         )
         atol = np.maximum(
-            np.abs(s.balance(df["t"] + 0.5 * df["err"])),
-            np.abs(s.balance(df["t"] - 0.5 * df["err"])),
+            np.abs(s.balance(df[VariableType.TEMPERATURE] + 0.5 * df[VariableType.ERROR])),
+            np.abs(s.balance(df[VariableType.TEMPERATURE] - 0.5 * df[VariableType.ERROR])),
         )
         assert np.allclose(bl, 0.0, atol=atol)
 
@@ -79,16 +80,16 @@ def test_consistency():
             T=100.0, return_err=True, return_power=True, tol=1.0e-09, maxiter=64
         )
         bl = (
-            df["P_joule"]
-            + df["P_solar"]
-            - df["P_convection"]
-            - df["P_radiation"]
-            - df["P_precipitation"]
+            df[VariableType.POWER_JOULE]
+            + df[VariableType.POWER_SUN]
+            - df[VariableType.POWER_CONVECTION]
+            - df[VariableType.POWER_RADIATION]
+            - df[VariableType.POWER_RAIN]
         )
         assert np.allclose(bl, 0.0, atol=1.0e-06)
-        s.args["transit"] = df["transit"].values
+        s.args[VariableType.TRANSIT.value] = df[VariableType.TRANSIT].values
         s.update()
         dg = s.steady_temperature(
             return_err=True, return_power=True, tol=1.0e-09, maxiter=64
         )
-        assert np.allclose(dg["t"].values, 100.0)
+        assert np.allclose(dg[VariableType.TEMPERATURE].values, 100.0)
diff --git a/test/test_solver3t.py b/test/test_solver3t.py
index 53845ea..e6bfb58 100644
--- a/test/test_solver3t.py
+++ b/test/test_solver3t.py
@@ -9,7 +9,8 @@
 
 from thermohl import solver
 from thermohl.solver import HeatEquationType
-from thermohl.solver.solver_type import SolverType
+from thermohl.solver.enums.solver_type import SolverType
+from thermohl.solver.enums.variable_type import VariableType
 
 _nprs = 123456
 
@@ -48,18 +49,18 @@ def test_balance():
         t1 = s1.steady_temperature(
             tol=2.0, maxiter=16, return_err=False, return_power=False
         )
-        t1 = t1["t"].values
+        t1 = t1[VariableType.TEMPERATURE].values
         # 3t solve
         df = s.steady_temperature(
             Tsg=t1, Tcg=t1, return_err=True, return_power=True, tol=tol, maxiter=64
         )
         # checks
-        assert np.all(df["err"] < tol)
+        assert np.all(df[VariableType.ERROR] < tol)
         assert np.allclose(
-            s.balance(ts=df["t_surf"], tc=df["t_core"]).values, 0.0, atol=tol
+            s.balance(ts=df[VariableType.TEMPERATURE_SURFACE], tc=df[VariableType.TEMPERATURE_CORE]).values, 0.0, atol=tol
         )
         assert np.allclose(
-            s.morgan(ts=df["t_surf"], tc=df["t_core"]).values, 0.0, atol=tol
+            s.morgan(ts=df[VariableType.TEMPERATURE_SURFACE], tc=df[VariableType.TEMPERATURE_CORE]).values, 0.0, atol=tol
         )
 
 
@@ -81,34 +82,38 @@ def test_consistency():
     )
 
     for s in _solvers(dic):
-        for t in ["surf", "avg", "core"]:
+        d = {VariableType.SURFACE: VariableType.TEMPERATURE_SURFACE,
+             VariableType.AVERAGE: VariableType.TEMPERATURE_AVERAGE,
+             VariableType.CORE: VariableType.TEMPERATURE_CORE}
+
+        for location,temperature_at_location in d.items():
             # solve intensity with different targets
             df = s.steady_intensity(
                 T=100.0,
-                target=t,
+                target=location,
                 return_err=True,
                 return_power=True,
                 tol=1.0e-09,
                 maxiter=64,
             )
-            assert np.all(df["err"] < tol)
+            assert np.all(df[VariableType.ERROR] < tol)
             # set args intensity to newly founds ampacities
-            s.args.transit = df["transit"].values
+            s.args.I = df[VariableType.TRANSIT].values
             s.update()
             assert np.allclose(
-                s.balance(ts=df["t_surf"], tc=df["t_core"]).values, 0.0, atol=tol
+                s.balance(ts=df[VariableType.TEMPERATURE_SURFACE], tc=df[VariableType.TEMPERATURE_CORE]).values, 0.0, atol=tol
             )
             assert np.allclose(
-                s.morgan(ts=df["t_surf"], tc=df["t_core"]).values, 0.0, atol=tol
+                s.morgan(ts=df[VariableType.TEMPERATURE_SURFACE], tc=df[VariableType.TEMPERATURE_CORE]).values, 0.0, atol=tol
             )
             # 3t solve
             dg = s.steady_temperature(
-                Tsg=df["t_surf"].round(1).values,
-                Tcg=df["t_core"].round(1).values,
+                Tsg=df[VariableType.TEMPERATURE_SURFACE].round(1).values,
+                Tcg=df[VariableType.TEMPERATURE_CORE].round(1).values,
                 return_err=True,
                 return_power=True,
                 tol=1.0e-09,
                 maxiter=64,
             )
             # check consistency
-            assert np.allclose(dg["t_" + t].values, 100.0)
+            assert np.allclose(dg[temperature_at_location].values, 100.0)
diff --git a/test/unit/solver/test_slv1t.py b/test/unit/solver/test_slv1t.py
index f39ed06..84cfde8 100644
--- a/test/unit/solver/test_slv1t.py
+++ b/test/unit/solver/test_slv1t.py
@@ -8,6 +8,8 @@
 import pytest
 import numpy as np
 import pandas as pd
+
+from thermohl.solver.enums.variable_type import VariableType
 from thermohl.solver.slv1t import Solver1T
 
 
@@ -35,32 +37,32 @@ def test_steady_temperature_default(solver):
     result = solver.steady_temperature()
 
     assert isinstance(result, pd.DataFrame)
-    assert Solver1T.Names.temp in result.columns
-    assert Solver1T.Names.pjle in result.columns
-    assert Solver1T.Names.psol in result.columns
-    assert Solver1T.Names.pcnv in result.columns
-    assert Solver1T.Names.prad in result.columns
-    assert Solver1T.Names.ppre in result.columns
+    assert VariableType.TEMPERATURE in result.columns
+    assert VariableType.POWER_JOULE in result.columns
+    assert VariableType.POWER_SUN in result.columns
+    assert VariableType.POWER_CONVECTION in result.columns
+    assert VariableType.POWER_RADIATION in result.columns
+    assert VariableType.POWER_RAIN in result.columns
 
 
 def test_steady_temperature_with_error(solver):
     result = solver.steady_temperature(return_err=True)
 
     assert isinstance(result, pd.DataFrame)
-    assert Solver1T.Names.temp in result.columns
-    assert Solver1T.Names.err in result.columns
+    assert VariableType.TEMPERATURE in result.columns
+    assert VariableType.ERROR in result.columns
 
 
 def test_steady_temperature_no_power(solver):
     result = solver.steady_temperature(return_power=False)
 
     assert isinstance(result, pd.DataFrame)
-    assert Solver1T.Names.temp in result.columns
-    assert Solver1T.Names.pjle not in result.columns
-    assert Solver1T.Names.psol not in result.columns
-    assert Solver1T.Names.pcnv not in result.columns
-    assert Solver1T.Names.prad not in result.columns
-    assert Solver1T.Names.ppre not in result.columns
+    assert VariableType.TEMPERATURE in result.columns
+    assert VariableType.POWER_JOULE not in result.columns
+    assert VariableType.POWER_SUN not in result.columns
+    assert VariableType.POWER_CONVECTION not in result.columns
+    assert VariableType.POWER_RADIATION not in result.columns
+    assert VariableType.POWER_RAIN not in result.columns
 
 
 def test_steady_temperature_custom_params(solver):
@@ -77,7 +79,7 @@ def test_steady_temperature_custom_params(solver):
     )
 
     assert isinstance(result, pd.DataFrame)
-    assert Solver1T.Names.temp in result.columns
+    assert VariableType.TEMPERATURE in result.columns
 
 
 def test_transient_temperature_default(solver):
@@ -86,10 +88,10 @@ def test_transient_temperature_default(solver):
     result = solver.transient_temperature(time)
 
     assert isinstance(result, dict)
-    assert "time" in result
-    assert "T" in result
-    assert len(result["time"]) == len(time)
-    assert len(result["T"]) == len(time)
+    assert VariableType.TIME in result
+    assert VariableType.TEMPERATURE in result
+    assert len(result[VariableType.TIME]) == len(time)
+    assert len(result[VariableType.TEMPERATURE]) == len(time)
 
 
 def test_transient_temperature_with_initial_temp(solver):
@@ -99,11 +101,11 @@ def test_transient_temperature_with_initial_temp(solver):
     result = solver.transient_temperature(time, T0=T0)
 
     assert isinstance(result, dict)
-    assert "time" in result
-    assert "T" in result
-    assert len(result["time"]) == len(time)
-    assert len(result["T"]) == len(time)
-    assert result["T"][0] == T0
+    assert VariableType.TIME in result
+    assert VariableType.TEMPERATURE in result
+    assert len(result[VariableType.TIME]) == len(time)
+    assert len(result[VariableType.TEMPERATURE]) == len(time)
+    assert result[VariableType.TEMPERATURE][0] == T0
 
 
 def test_transient_temperature_with_error(solver):
@@ -112,15 +114,15 @@ def test_transient_temperature_with_error(solver):
     result = solver.transient_temperature(time, return_power=True)
 
     assert isinstance(result, dict)
-    assert "time" in result
-    assert "T" in result
-    assert len(result["time"]) == len(time)
-    assert len(result["T"]) == len(time)
-    assert Solver1T.Names.pjle in result
-    assert Solver1T.Names.psol in result
-    assert Solver1T.Names.pcnv in result
-    assert Solver1T.Names.prad in result
-    assert Solver1T.Names.ppre in result
+    assert VariableType.TIME in result
+    assert VariableType.TEMPERATURE in result
+    assert len(result[VariableType.TIME]) == len(time)
+    assert len(result[VariableType.TEMPERATURE]) == len(time)
+    assert VariableType.POWER_JOULE in result
+    assert VariableType.POWER_SUN in result
+    assert VariableType.POWER_CONVECTION in result
+    assert VariableType.POWER_RADIATION in result
+    assert VariableType.POWER_RAIN in result
 
 
 def test_steady_intensity_default(solver):
@@ -129,12 +131,12 @@ def test_steady_intensity_default(solver):
     result = solver.steady_intensity(T)
 
     assert isinstance(result, pd.DataFrame)
-    assert Solver1T.Names.transit in result.columns
-    assert Solver1T.Names.pjle in result.columns
-    assert Solver1T.Names.psol in result.columns
-    assert Solver1T.Names.pcnv in result.columns
-    assert Solver1T.Names.prad in result.columns
-    assert Solver1T.Names.ppre in result.columns
+    assert VariableType.TRANSIT in result.columns
+    assert VariableType.POWER_JOULE in result.columns
+    assert VariableType.POWER_SUN in result.columns
+    assert VariableType.POWER_CONVECTION in result.columns
+    assert VariableType.POWER_RADIATION in result.columns
+    assert VariableType.POWER_RAIN in result.columns
 
 
 def test_steady_intensity_with_error(solver):
@@ -143,8 +145,8 @@ def test_steady_intensity_with_error(solver):
     result = solver.steady_intensity(T, return_err=True)
 
     assert isinstance(result, pd.DataFrame)
-    assert Solver1T.Names.transit in result.columns
-    assert Solver1T.Names.err in result.columns
+    assert VariableType.TRANSIT in result.columns
+    assert VariableType.ERROR in result.columns
 
 
 def test_steady_intensity_no_power(solver):
@@ -153,12 +155,12 @@ def test_steady_intensity_no_power(solver):
     result = solver.steady_intensity(T, return_power=False)
 
     assert isinstance(result, pd.DataFrame)
-    assert Solver1T.Names.transit in result.columns
-    assert Solver1T.Names.pjle not in result.columns
-    assert Solver1T.Names.psol not in result.columns
-    assert Solver1T.Names.pcnv not in result.columns
-    assert Solver1T.Names.prad not in result.columns
-    assert Solver1T.Names.ppre not in result.columns
+    assert VariableType.TRANSIT in result.columns
+    assert VariableType.POWER_JOULE not in result.columns
+    assert VariableType.POWER_SUN not in result.columns
+    assert VariableType.POWER_CONVECTION not in result.columns
+    assert VariableType.POWER_RADIATION not in result.columns
+    assert VariableType.POWER_RAIN not in result.columns
 
 
 def test_steady_intensity_custom_params(solver):
@@ -171,4 +173,4 @@ def test_steady_intensity_custom_params(solver):
     result = solver.steady_intensity(T, Imin=Imin, Imax=Imax, tol=tol, maxiter=maxiter)
 
     assert isinstance(result, pd.DataFrame)
-    assert Solver1T.Names.transit in result.columns
+    assert VariableType.TRANSIT in result.columns
diff --git a/thermohl-docs/docs/examples/ex_transient_3t.ipynb b/thermohl-docs/docs/examples/ex_transient_3t.ipynb
index 63dc18d..1a68f00 100644
--- a/thermohl-docs/docs/examples/ex_transient_3t.ipynb
+++ b/thermohl-docs/docs/examples/ex_transient_3t.ipynb
@@ -18,6 +18,7 @@
     "    \"from thermohl import solver\\n\",\n",
     "    \"from thermohl.solver import HeatEquationType\"\n",
     "   ],\n",
+    "   \"id\": \"a4ada52a0ef47853\"\n",
     "  },\n",
     "  {\n",
     "   \"cell_type\": \"markdown\",\n",
@@ -28,54 +29,56 @@
     "   ]\n",
     "  },\n",
     "  {\n",
-    "   \"cell_type\": \"code\",\n",
-    "   \"execution_count\": 7,\n",
-    "   \"id\": \"54a4c33b-f71b-43b1-a9d0-a1ddf1230154\",\n",
     "   \"metadata\": {},\n",
+    "   \"cell_type\": \"code\",\n",
     "   \"outputs\": [],\n",
+    "   \"execution_count\": null,\n",
     "   \"source\": [\n",
+    "    \"from thermohl.solver.enums.variable_type import VariableType\\n\",\n",
+    "    \"\\n\",\n",
+    "    \"\\n\",\n",
     "    \"def example_solver3t_transient(dic):\\n\",\n",
+    "    \"\\n\",\n",
     "    \"    # create solver with rte power terms and 3t heat equation\\n\",\n",
     "    \"    slvr = solver.rte(dic, heat_equation=HeatEquationType.HEAT_EQUATION_THREE_TEMPERATURES)\\n\",\n",
     "    \"\\n\",\n",
     "    \"    # change solver args to get initial state, compute initial values of surface\\n\",\n",
     "    \"    # and core temperature using steady temperature\\n\",\n",
-    "    \"    slvr.args[\\\"transit\\\"] = 400.0\\n\",\n",
+    "    \"    slvr.args[VariableType.TRANSIT] = 400.\\n\",\n",
     "    \"    slvr.update()\\n\",\n",
     "    \"    dtstdy = slvr.steady_temperature()\\n\",\n",
-    "    \"    T_surf = dtstdy['t_surf'].values\\n\",\n",
-    "    \"    T_core = dtstdy['t_core'].values\\n\",\n",
+    "    \"    T_surf = dtstdy[VariableType.TEMPERATURE_SURFACE].values\\n\",\n",
+    "    \"    T_core = dtstdy[VariableType.TEMPERATURE_CORE].values\\n\",\n",
     "    \"\\n\",\n",
     "    \"    # restore initial transit in dic\\n\",\n",
-    "    \"    slvr.args[\\\"I\\\"] = dic[\\\"I\\\"]\\n\",\n",
+    "    \"    slvr.args[VariableType.TRANSIT] = dic[VariableType.TRANSIT]\\n\",\n",
     "    \"    slvr.update()\\n\",\n",
     "    \"\\n\",\n",
+    "    \"\\n\",\n",
     "    \"    # compute temperature\\n\",\n",
     "    \"    dtemp = slvr.transient_temperature(t, Ts0=T_surf, Tc0=T_core, return_power=True)\\n\",\n",
     "    \"\\n\",\n",
     "    \"    # plot\\n\",\n",
     "    \"    fig, ax = plt.subplots(nrows=1, ncols=1)\\n\",\n",
     "    \"    tm = t / 60\\n\",\n",
-    "    \"    ax.fill_between(\\n\",\n",
-    "    \"        tm, dtemp[\\\"t_surf\\\"], dtemp[\\\"t_core\\\"], fc=\\\"gray\\\", alpha=0.33, ec=None\\n\",\n",
-    "    \"    )\\n\",\n",
-    "    \"    ax.plot(tm, dtemp[\\\"t_surf\\\"], c=\\\"C0\\\", label=\\\"Surface Conductor temperature (C)\\\")\\n\",\n",
-    "    \"    ax.plot(tm, dtemp[\\\"t_avg\\\"], c=\\\"C1\\\", label=\\\"average Conductor temperature (C)\\\")\\n\",\n",
-    "    \"    ax.plot(tm, dtemp[\\\"t_core\\\"], c=\\\"C3\\\", label=\\\"Core Conductor temperature (C)\\\")\\n\",\n",
+    "    \"    ax.fill_between(tm, dtemp[VariableType.TEMPERATURE_SURFACE], dtemp[VariableType.TEMPERATURE_CORE], fc='gray', alpha=0.33, ec=None)\\n\",\n",
+    "    \"    ax.plot(tm, dtemp[VariableType.TEMPERATURE_SURFACE], c='C0', label='Surface Conductor temperature (C)')\\n\",\n",
+    "    \"    ax.plot(tm, dtemp[VariableType.TEMPERATURE_AVERAGE], c='C1', label='average Conductor temperature (C)')\\n\",\n",
+    "    \"    ax.plot(tm, dtemp[VariableType.TEMPERATURE_CORE], c='C3', label='Core Conductor temperature (C)')\\n\",\n",
     "    \"    ax.set_xlabel(\\\"Time (hour)\\\")\\n\",\n",
     "    \"    ax.set_ylabel(\\\"Temperature (C)\\\")\\n\",\n",
     "    \"    ax.grid(True)\\n\",\n",
     "    \"    ax.legend()\\n\",\n",
     "    \"    %matplotlib inline\\n\",\n",
     "    \"    plt.show()\"\n",
-    "   ]\n",
+    "   ],\n",
+    "   \"id\": \"c5be7c1fcaa488ce\"\n",
     "  },\n",
     "  {\n",
-    "   \"cell_type\": \"code\",\n",
-    "   \"execution_count\": 8,\n",
-    "   \"id\": \"65ce6328-af5c-43e6-b389-2ec8157c348a\",\n",
     "   \"metadata\": {},\n",
+    "   \"cell_type\": \"code\",\n",
     "   \"outputs\": [],\n",
+    "   \"execution_count\": null,\n",
     "   \"source\": [\n",
     "    \"import matplotlib\\n\",\n",
     "    \"\\n\",\n",
@@ -90,32 +93,13 @@
     "    \"    azm=31.0,\\n\",\n",
     "    \"    month=6,\\n\",\n",
     "    \"    day=20,\\n\",\n",
-    "    \"    hour=0.0,\\n\",\n",
-    "    \"    transit=700.0,\\n\",\n",
+    "    \"    hour=0.,\\n\",\n",
+    "    \"    I=700.,\\n\",\n",
     "    \")\\n\",\n",
-    "    \"t = np.linspace(0, 3600, 901)\"\n",
-    "   ]\n",
-    "  },\n",
-    "  {\n",
-    "   \"cell_type\": \"code\",\n",
-    "   \"execution_count\": 9,\n",
-    "   \"id\": \"349c1e0c-af4e-4331-95da-4e0f353a651d\",\n",
-    "   \"metadata\": {},\n",
-    "   \"outputs\": [\n",
-    "    {\n",
-    "     \"data\": {\n",
-    "      \"image/png\": \"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\",\n",
-    "      \"text/plain\": [\n",
-    "       \"<Figure size 640x480 with 1 Axes>\"\n",
-    "      ]\n",
-    "     },\n",
-    "     \"metadata\": {},\n",
-    "     \"output_type\": \"display_data\"\n",
-    "    }\n",
+    "    \"t = np.linspace(0, 3600, 901)\\n\",\n",
+    "    \"\\n\"\n",
     "   ],\n",
-    "   \"source\": [\n",
-    "    \"example_solver3t_transient(dic)\"\n",
-    "   ]\n",
+    "   \"id\": \"4425a6fc34f3b87c\"\n",
     "  }\n",
     " ],\n",
     " \"metadata\": {\n",
@@ -141,7 +125,7 @@
     " \"nbformat_minor\": 5\n",
     "}\n"
    ],
-   "id": "4425a6fc34f3b87c"
+   "id": "4da701b2b28b0e37"
   }
  ],
  "metadata": {
diff --git a/thermohl-docs/docs/getting-started.md b/thermohl-docs/docs/getting-started.md
index 26b613a..c541292 100644
--- a/thermohl-docs/docs/getting-started.md
+++ b/thermohl-docs/docs/getting-started.md
@@ -80,7 +80,7 @@ surface temperature (°C) of a conductor in steady-state regime along with the c
 
 ```python
 from thermohl import solver
-from thermohl.solver.heat_equation_enum import HeatEquationType
+from thermohl.solver.enums.heat_equation_type import HeatEquationType
 
 slvr = solver.ieee(dic=None, heat_equation=HeatEquationType.HEAT_EQUATION_ONE_TEMPERATURE)
 temp = slvr.steady_temperature() 
@@ -104,7 +104,7 @@ distinct ampacities (and the lower the ambient temperature, the higher the ampac
 ```python
 import numpy as np
 from thermohl import solver
-from thermohl.solver.heat_equation_enum import HeatEquationType
+from thermohl.solver.enums.heat_equation_type import HeatEquationType
 
 slvr = solver.ieee(dict(Ta=np.array([0., 15., 30.])), heat_equation=HeatEquationType.HEAT_EQUATION_ONE_TEMPERATURE)
 Tmax = 80.

From 1eae4b7c82e59c9f970374b96af241b012590047 Mon Sep 17 00:00:00 2001
From: Olivier Pigeon <olivier.pigeon@rte-france.com>
Date: Wed, 3 Dec 2025 12:04:50 +0100
Subject: [PATCH 4/6] feat(#2): Split the VariableType enum into several ones
 for more consistency

Signed-off-by: Olivier Pigeon <olivier.pigeon@rte-france.com>
---
 examples/example_solver_intensity.py          | 11 +--
 src/thermohl/solver/base.py                   | 14 +--
 src/thermohl/solver/enums/cable_location.py   | 10 +++
 src/thermohl/solver/enums/power_type.py       |  8 ++
 .../solver/enums/temperature_location.py      |  6 ++
 src/thermohl/solver/enums/variable_type.py    | 13 ---
 src/thermohl/solver/slv1t.py                  | 31 +++----
 src/thermohl/solver/slv3t.py                  | 90 +++++++++----------
 src/thermohl/solver/slv3t_legacy.py           | 11 ++-
 src/thermohl/uncertainties.py                 |  8 +-
 test/functional_test/functional_test.py       | 13 +--
 test/test_shape.py                            |  8 +-
 test/test_solver1t.py                         | 21 ++---
 test/test_solver3t.py                         | 20 +++--
 test/unit/solver/test_slv1t.py                | 51 +++++------
 .../docs/examples/ex_transient_3t.ipynb       | 17 ++--
 16 files changed, 172 insertions(+), 160 deletions(-)
 create mode 100644 src/thermohl/solver/enums/cable_location.py
 create mode 100644 src/thermohl/solver/enums/power_type.py
 create mode 100644 src/thermohl/solver/enums/temperature_location.py

diff --git a/examples/example_solver_intensity.py b/examples/example_solver_intensity.py
index 8282da9..c049275 100644
--- a/examples/example_solver_intensity.py
+++ b/examples/example_solver_intensity.py
@@ -13,6 +13,7 @@
 import pandas as pd
 
 from thermohl import solver
+from thermohl.solver.enums.power_type import PowerType
 from thermohl.solver.enums.variable_type import VariableType
 
 
@@ -25,8 +26,8 @@ def test_solve(dct, Trep, tol=1.0e-06, mxi=64):
     mdl = [
         dict(label="cigr", model=solver.cigre(dct)),
         dict(label="ieee", model=solver.ieee(dct)),
-        dict(label="olla", model=solver.olla(dct, multi=False)),
-        dict(label="ollm", model=solver.olla(dct, multi=True)),
+        dict(label="olla", model=solver.olla(dct)),
+        #dict(label="ollm", model=solver.olla(dct, multi=True)),
         dict(label="rte", model=solver.rte(dct)),
     ]
     dfi = pd.DataFrame(dct)
@@ -74,8 +75,8 @@ def test_solve(dct, Trep, tol=1.0e-06, mxi=64):
     mdl = [
         dict(label="cigr", model=solver.cigre(dct)),
         dict(label="ieee", model=solver.ieee(dct)),
-        dict(label="olla", model=solver.olla(dct, multi=False)),
-        dict(label="ollm", model=solver.olla(dct, multi=True)),
+        dict(label="olla", model=solver.olla(dct)),
+        #dict(label="ollm", model=solver.olla(dct, multi=True)),
         dict(label="rte", model=solver.rte(dct)),
     ]
 
@@ -84,7 +85,7 @@ def test_solve(dct, Trep, tol=1.0e-06, mxi=64):
         slv = d["model"]
         df = slv.steady_intensity(Trep, tol=tol, maxiter=mxi, return_power=True)
         df["pb"] = (
-            df[VariableType.POWER_JOULE] + df[VariableType.POWER_SUN] - df[VariableType.POWER_CONVECTION] - df[VariableType.POWER_RADIATION]
+                df[PowerType.JOULE] + df[PowerType.SOLAR] - df[PowerType.CONVECTION] - df[PowerType.RADIATION]
         )
         slv.dc[VariableType.TRANSIT] = df["I_max"].values
         df["TIrep"] = slv.steady_temperature(return_power=False)["T_surf"]
diff --git a/src/thermohl/solver/base.py b/src/thermohl/solver/base.py
index 0d7d642..f8479f4 100644
--- a/src/thermohl/solver/base.py
+++ b/src/thermohl/solver/base.py
@@ -23,7 +23,7 @@
     numberArrayLike,
 )
 from thermohl.power import PowerTerm
-from thermohl.solver.enums.variable_type import VariableType
+from thermohl.solver.enums.power_type import PowerType
 
 
 class _DEFPARAM:
@@ -241,13 +241,13 @@ def balance(self, T: floatArrayLike) -> floatArrayLike:
         )
 
     @staticmethod
-    def powers() -> tuple[VariableType, VariableType, VariableType, VariableType, VariableType]:
+    def powers() -> tuple[PowerType, PowerType, PowerType, PowerType, PowerType]:
         return (
-            VariableType.POWER_JOULE,
-            VariableType.POWER_SUN,
-            VariableType.POWER_CONVECTION,
-            VariableType.POWER_RADIATION,
-            VariableType.POWER_RAIN,
+            PowerType.JOULE,
+            PowerType.SOLAR,
+            PowerType.CONVECTION,
+            PowerType.RADIATION,
+            PowerType.RAIN,
         )
 
     @abstractmethod
diff --git a/src/thermohl/solver/enums/cable_location.py b/src/thermohl/solver/enums/cable_location.py
new file mode 100644
index 0000000..b911ffe
--- /dev/null
+++ b/src/thermohl/solver/enums/cable_location.py
@@ -0,0 +1,10 @@
+from enum import Enum
+from typing import Union, List
+
+
+class CableLocation(Enum):
+    SURFACE = "surf"
+    AVERAGE = "avg"
+    CORE = "core"
+
+CableLocationListLike = Union[CableLocation, List[CableLocation]]
diff --git a/src/thermohl/solver/enums/power_type.py b/src/thermohl/solver/enums/power_type.py
new file mode 100644
index 0000000..ce8aff5
--- /dev/null
+++ b/src/thermohl/solver/enums/power_type.py
@@ -0,0 +1,8 @@
+from enum import Enum
+
+class PowerType(Enum):
+    JOULE = "P_joule"
+    SOLAR = "P_solar"
+    CONVECTION = "P_convection"
+    RADIATION = "P_radiation"
+    RAIN = "P_precipitation"
\ No newline at end of file
diff --git a/src/thermohl/solver/enums/temperature_location.py b/src/thermohl/solver/enums/temperature_location.py
new file mode 100644
index 0000000..d0f781f
--- /dev/null
+++ b/src/thermohl/solver/enums/temperature_location.py
@@ -0,0 +1,6 @@
+from enum import Enum
+
+class TemperatureLocation(Enum):
+    SURFACE = "t_surf"
+    AVERAGE = "t_avg"
+    CORE = "t_core"
\ No newline at end of file
diff --git a/src/thermohl/solver/enums/variable_type.py b/src/thermohl/solver/enums/variable_type.py
index 1101275..c45d0f4 100644
--- a/src/thermohl/solver/enums/variable_type.py
+++ b/src/thermohl/solver/enums/variable_type.py
@@ -11,22 +11,9 @@
 
 
 class VariableType(Enum):
-
-    POWER_JOULE = "P_joule"
-    POWER_SUN = "P_solar"
-    POWER_CONVECTION = "P_convection"
-    POWER_RADIATION = "P_radiation"
-    POWER_RAIN = "P_precipitation"
     ERROR = "err"
-    SURFACE = "surf"
-    AVERAGE = "avg"
-    CORE = "core"
     TIME = "time"
     TRANSIT = "I"
     TEMPERATURE = "t"
-    TEMPERATURE_SURFACE = "t_surf"
-    TEMPERATURE_AVERAGE = "t_avg"
-    TEMPERATURE_CORE = "t_core"
 
 
-VariableTypeListLike = Union[VariableType, List[VariableType]]
\ No newline at end of file
diff --git a/src/thermohl/solver/slv1t.py b/src/thermohl/solver/slv1t.py
index 3012074..4a44219 100644
--- a/src/thermohl/solver/slv1t.py
+++ b/src/thermohl/solver/slv1t.py
@@ -15,6 +15,7 @@
 from thermohl.solver.base import Solver as Solver_
 from thermohl.solver.base import _DEFPARAM as DP
 from thermohl.solver.base import _set_dates, reshape
+from thermohl.solver.enums.power_type import PowerType
 from thermohl.solver.enums.variable_type import VariableType
 from thermohl.utils import bisect_v
 
@@ -57,11 +58,11 @@ def steady_temperature(
             df[VariableType.ERROR] = err
 
         if return_power:
-            df[VariableType.POWER_JOULE] = self.jh.value(T)
-            df[VariableType.POWER_SUN] = self.sh.value(T)
-            df[VariableType.POWER_CONVECTION] = self.cc.value(T)
-            df[VariableType.POWER_RADIATION] = self.rc.value(T)
-            df[VariableType.POWER_RAIN] = self.pc.value(T)
+            df[PowerType.JOULE] = self.jh.value(T)
+            df[PowerType.SOLAR] = self.sh.value(T)
+            df[PowerType.CONVECTION] = self.cc.value(T)
+            df[PowerType.RADIATION] = self.rc.value(T)
+            df[PowerType.RAIN] = self.pc.value(T)
 
         return df
 
@@ -146,11 +147,11 @@ def transient_temperature(
                 for k in de.keys():
                     self.args[k] = de[k][i, :]
                 self.update()
-                dr[VariableType.POWER_JOULE][i, :] = self.jh.value(T[i, :])
-                dr[VariableType.POWER_SUN][i, :] = self.sh.value(T[i, :])
-                dr[VariableType.POWER_CONVECTION][i, :] = self.cc.value(T[i, :])
-                dr[VariableType.POWER_RADIATION][i, :] = self.rc.value(T[i, :])
-                dr[VariableType.POWER_RAIN][i, :] = self.pc.value(T[i, :])
+                dr[PowerType.JOULE][i, :] = self.jh.value(T[i, :])
+                dr[PowerType.SOLAR][i, :] = self.sh.value(T[i, :])
+                dr[PowerType.CONVECTION][i, :] = self.cc.value(T[i, :])
+                dr[PowerType.RADIATION][i, :] = self.rc.value(T[i, :])
+                dr[PowerType.RAIN][i, :] = self.pc.value(T[i, :])
 
         # squeeze return values if n is 1
         if n == 1:
@@ -220,10 +221,10 @@ def fun(i: floatArray) -> floatArrayLike:
             df[VariableType.ERROR] = err
 
         if return_power:
-            df[VariableType.POWER_JOULE] = self.jh.value(T)
-            df[VariableType.POWER_SUN] = self.sh.value(T)
-            df[VariableType.POWER_CONVECTION] = self.cc.value(T)
-            df[VariableType.POWER_RADIATION] = self.rc.value(T)
-            df[VariableType.POWER_RAIN] = self.pc.value(T)
+            df[PowerType.JOULE] = self.jh.value(T)
+            df[PowerType.SOLAR] = self.sh.value(T)
+            df[PowerType.CONVECTION] = self.cc.value(T)
+            df[PowerType.RADIATION] = self.rc.value(T)
+            df[PowerType.RAIN] = self.pc.value(T)
 
         return df
diff --git a/src/thermohl/solver/slv3t.py b/src/thermohl/solver/slv3t.py
index c98517f..5f979eb 100644
--- a/src/thermohl/solver/slv3t.py
+++ b/src/thermohl/solver/slv3t.py
@@ -13,7 +13,10 @@
 from thermohl import floatArrayLike, floatArray, strListLike, intArray
 from thermohl.power import PowerTerm
 from thermohl.solver.base import Solver as Solver_, _DEFPARAM as DP, _set_dates, reshape
-from thermohl.solver.enums.variable_type import VariableType, VariableTypeListLike
+from thermohl.solver.enums.cable_location import CableLocation, CableLocationListLike
+from thermohl.solver.enums.power_type import PowerType
+from thermohl.solver.enums.temperature_location import TemperatureLocation
+from thermohl.solver.enums.variable_type import VariableType
 from thermohl.solver.slv1t import Solver1T
 from thermohl.utils import quasi_newton_2d
 
@@ -231,18 +234,18 @@ def steady_temperature(
         # format output
         z = self.average(x, y)
         df = pd.DataFrame(
-            {VariableType.TEMPERATURE_SURFACE: x, VariableType.TEMPERATURE_AVERAGE: z, VariableType.TEMPERATURE_CORE: y}
+            {TemperatureLocation.SURFACE: x, TemperatureLocation.AVERAGE: z, TemperatureLocation.CORE: y}
         )
 
         if return_err:
             df[VariableType.ERROR] = err
 
         if return_power:
-            df[VariableType.POWER_JOULE] = self.joule(x, y)
-            df[VariableType.POWER_SUN] = self.sh.value(x)
-            df[VariableType.POWER_CONVECTION] = self.cc.value(x)
-            df[VariableType.POWER_RADIATION] = self.rc.value(x)
-            df[VariableType.POWER_RAIN] = self.pc.value(x)
+            df[PowerType.JOULE] = self.joule(x, y)
+            df[PowerType.SOLAR] = self.sh.value(x)
+            df[PowerType.CONVECTION] = self.cc.value(x)
+            df[PowerType.RADIATION] = self.rc.value(x)
+            df[PowerType.RAIN] = self.pc.value(x)
 
         return df
 
@@ -258,9 +261,9 @@ def _morgan_transient(self):
     def _transient_temperature_results(self, time, ts, ta, tc, return_power, n):
         dr = {
             VariableType.TIME: time,
-            VariableType.TEMPERATURE_SURFACE: ts,
-            VariableType.TEMPERATURE_AVERAGE: ta,
-            VariableType.TEMPERATURE_CORE: tc,
+            TemperatureLocation.SURFACE: ts,
+            TemperatureLocation.AVERAGE: ta,
+            TemperatureLocation.CORE: tc,
         }
 
         if return_power:
@@ -268,11 +271,11 @@ def _transient_temperature_results(self, time, ts, ta, tc, return_power, n):
                 dr[power] = np.zeros_like(ts)
 
             for i in range(len(time)):
-                dr[VariableType.POWER_JOULE][i, :] = self.joule(ts[i, :], tc[i, :])
-                dr[VariableType.POWER_SUN][i, :] = self.sh.value(ts[i, :])
-                dr[VariableType.POWER_CONVECTION][i, :] = self.cc.value(ts[i, :])
-                dr[VariableType.POWER_RADIATION][i, :] = self.rc.value(ts[i, :])
-                dr[VariableType.POWER_RAIN][i, :] = self.pc.value(ts[i, :])
+                dr[PowerType.JOULE][i, :] = self.joule(ts[i, :], tc[i, :])
+                dr[PowerType.SOLAR][i, :] = self.sh.value(ts[i, :])
+                dr[PowerType.CONVECTION][i, :] = self.cc.value(ts[i, :])
+                dr[PowerType.RADIATION][i, :] = self.rc.value(ts[i, :])
+                dr[PowerType.RAIN][i, :] = self.pc.value(ts[i, :])
 
         if n == 1:
             keys = list(dr.keys())
@@ -360,15 +363,15 @@ def transient_temperature(
         return self._transient_temperature_results(time, ts, ta, tc, return_power, n)
 
     @staticmethod
-    def _check_target(target, d, max_len):
+    def _check_target(target: CableLocationListLike, d, max_len):
         """
         Validates and processes the target temperature input.
 
         Args:
-            target (VariableType | list[VariableType]): The target temperature(s) to be validated. It can be:
+            target (CableLocation | list[CableLocation]): The target temperature(s) to be validated. It can be:
                 - None: which sets the target automatically.
-                - A VariableType: must be one of VariableType.SURFACE, VariableType.AVERAGE, or VariableType.CORE.
-                - A list of VariableType: each string must be one of VariableType.SURFACE, VariableType.AVERAGE, or VariableType.CORE.
+                - A CableLocation: must be one of CableLocation.SURFACE, CableLocation.AVERAGE, or CableLocation.CORE.
+                - A list of CableLocation: each element of the list must be one of CableLocation.SURFACE, CableLocation.AVERAGE, or CableLocation.CORE.
             max_len (int): The expected length of the target list if target is a list.
 
         Returns:
@@ -382,38 +385,27 @@ def _check_target(target, d, max_len):
             d_ = d * np.ones(max_len)
             target_ = np.array(
                 [
-                    VariableType.CORE if d_[i] > 0.0 else VariableType.AVERAGE
+                    CableLocation.CORE if d_[i] > 0.0 else CableLocation.AVERAGE
                     for i in range(max_len)
                 ]
             )
-        elif isinstance(target, VariableType):
-            if target not in [
-                VariableType.SURFACE,
-                VariableType.AVERAGE,
-                VariableType.CORE,
-            ]:
-                raise ValueError(
-                    f"Target temperature should be in "
-                    f"{[VariableType.SURFACE, VariableType.AVERAGE, VariableType.CORE]};"
-                    f" got {target} instead."
-                )
-            else:
+        elif isinstance(target, CableLocation):
                 target_ = np.array([target for _ in range(max_len)])
         else:
             if len(target) != max_len:
                 raise ValueError()
             for t in target:
                 if t not in [
-                    VariableType.SURFACE,
-                    VariableType.AVERAGE,
-                    VariableType.CORE,
+                    CableLocation.SURFACE,
+                    CableLocation.AVERAGE,
+                    CableLocation.CORE,
                 ]:
                     raise ValueError()
             target_ = np.array(target)
         return target_
 
     def _steady_intensity_header(
-        self, T: floatArrayLike, target: VariableTypeListLike
+        self, T: floatArrayLike, target: CableLocationListLike
     ) -> Tuple[np.ndarray, Callable]:
         """Format input for ampacity solver."""
 
@@ -425,9 +417,9 @@ def _steady_intensity_header(
         c, D, d, ix = self.mgc
         a, b = _profile_bim_avg_coeffs(0.5 * d, 0.5 * D)
 
-        js = np.nonzero(target_ == VariableType.SURFACE)[0]
-        ja = np.nonzero(target_ == VariableType.AVERAGE)[0]
-        jc = np.nonzero(target_ == VariableType.CORE)[0]
+        js = np.nonzero(target_ == CableLocation.SURFACE)[0]
+        ja = np.nonzero(target_ == CableLocation.AVERAGE)[0]
+        jc = np.nonzero(target_ == CableLocation.CORE)[0]
         jx = np.intersect1d(ix, ja)
 
         # get correct input for quasi-newton solver
@@ -454,7 +446,7 @@ def newtheader(i: floatArray, tg: floatArray) -> Tuple[floatArray, floatArray]:
     def steady_intensity(
         self,
         T: floatArrayLike = np.array([]),
-        target: VariableTypeListLike = None,
+        target: CableLocationListLike = None,
         tol: float = DP.tol,
         maxiter: int = DP.maxiter,
         return_err: bool = False,
@@ -466,7 +458,7 @@ def steady_intensity(
 
         Args:
             T (float | numpy.ndarray): Initial temperature profile. Default is an empty numpy array.
-            target (VariableType | list[VariableType]): Target specification for the solver. Default is None.
+            target (CableLocation | list[CableLocation]): Target specification for the solver. Default is None.
             tol (float): Tolerance for the solver. Default is DP.tol.
             maxiter (int): Maximum number of iterations for the solver. Default is DP.maxiter.
             return_err (bool): If True, return the error in the output DataFrame. Default is False.
@@ -521,15 +513,15 @@ def morgan(i: floatArray, tg: floatArray) -> floatArray:
             ta = self.average(ts, tc)
 
             if return_temp:
-                df[VariableType.TEMPERATURE_SURFACE] = ts
-                df[VariableType.TEMPERATURE_AVERAGE] = ta
-                df[VariableType.TEMPERATURE_CORE] = tc
+                df[TemperatureLocation.SURFACE] = ts
+                df[TemperatureLocation.AVERAGE] = ta
+                df[TemperatureLocation.CORE] = tc
 
             if return_power:
-                df[VariableType.POWER_JOULE] = self.jh.value(ta)
-                df[VariableType.POWER_SUN] = self.sh.value(ts)
-                df[VariableType.POWER_CONVECTION] = self.cc.value(ts)
-                df[VariableType.POWER_RADIATION] = self.rc.value(ts)
-                df[VariableType.POWER_RAIN] = self.pc.value(ts)
+                df[PowerType.JOULE] = self.jh.value(ta)
+                df[PowerType.SOLAR] = self.sh.value(ts)
+                df[PowerType.CONVECTION] = self.cc.value(ts)
+                df[PowerType.RADIATION] = self.rc.value(ts)
+                df[PowerType.RAIN] = self.pc.value(ts)
 
         return df
diff --git a/src/thermohl/solver/slv3t_legacy.py b/src/thermohl/solver/slv3t_legacy.py
index 2b781e8..3cb7027 100644
--- a/src/thermohl/solver/slv3t_legacy.py
+++ b/src/thermohl/solver/slv3t_legacy.py
@@ -11,8 +11,7 @@
 
 from thermohl import floatArrayLike, floatArray, strListLike, intArray
 from thermohl.power import PowerTerm
-from thermohl.solver.base import Solver as Solver_
-from thermohl.solver.enums.variable_type import VariableType
+from thermohl.solver.enums.cable_location import CableLocation, CableLocationListLike
 from thermohl.solver.slv3t import Solver3T
 
 
@@ -84,7 +83,7 @@ def morgan(self, ts: floatArray, tc: floatArray) -> floatArray:
         return (tc - ts) - morgan_coefficient * self.joule(ts, tc)
 
     def _steady_intensity_header(
-        self, T: floatArrayLike, target: strListLike
+        self, T: floatArrayLike, target: CableLocationListLike
     ) -> Tuple[np.ndarray, Callable]:
         """Format input for ampacity solver."""
 
@@ -93,9 +92,9 @@ def _steady_intensity_header(
         target_ = self._check_target(target, self.args.d, max_len)
 
         # pre-compute indexes
-        surface_indices = np.nonzero(target_ == VariableType.SURFACE)[0]
-        average_indices = np.nonzero(target_ == VariableType.AVERAGE)[0]
-        core_indices = np.nonzero(target_ == VariableType.CORE)[0]
+        surface_indices = np.nonzero(target_ == CableLocation.SURFACE)[0]
+        average_indices = np.nonzero(target_ == CableLocation.AVERAGE)[0]
+        core_indices = np.nonzero(target_ == CableLocation.CORE)[0]
 
         def newtheader(i: floatArray, tg: floatArray) -> Tuple[floatArray, floatArray]:
             self.args.transit = i
diff --git a/src/thermohl/uncertainties.py b/src/thermohl/uncertainties.py
index 71f9151..7828260 100644
--- a/src/thermohl/uncertainties.py
+++ b/src/thermohl/uncertainties.py
@@ -14,7 +14,7 @@
 import numpy as np
 import pandas as pd
 
-from thermohl.solver.enums.variable_type import VariableType
+from thermohl.solver.enums.cable_location import CableLocation
 from thermohl.utils import depends_on_optional
 
 try:
@@ -153,7 +153,7 @@ def _generate_samples(
 
 
 def _rdict(
-    mode: str, target: VariableType, return_surf: bool, return_core: bool, return_avg: bool
+    mode: str, target: CableLocation, return_surf: bool, return_core: bool, return_avg: bool
 ) -> dict:
     """Code factorization"""
     if mode == "temperature":
@@ -185,7 +185,7 @@ def _compute(mode: str, s: solver.Solver, tmx: Union[float, np.ndarray], rdc: di
 def _steady_uncertainties(
     s: solver.Solver,
     tmax: Union[float, np.ndarray],
-    target: VariableType,
+    target: CableLocation,
     u: dict,
     ns: int,
     return_surf: bool,
@@ -270,7 +270,7 @@ def temperature(
 def intensity(
     s: solver.Solver,
     tmax: Union[float, np.ndarray],
-    target: VariableType = VariableType.SURFACE,
+    target: CableLocation = CableLocation.SURFACE,
     u: dict = {},
     ns: int = 4999,
     return_core: bool = False,
diff --git a/test/functional_test/functional_test.py b/test/functional_test/functional_test.py
index ba26a70..eab42dc 100644
--- a/test/functional_test/functional_test.py
+++ b/test/functional_test/functional_test.py
@@ -14,6 +14,7 @@
 from typing import List, Dict
 
 from thermohl.solver import rte, HeatEquationType
+from thermohl.solver.enums.temperature_location import TemperatureLocation
 from thermohl.solver.enums.variable_type import VariableType
 
 
@@ -70,9 +71,9 @@ def test_steady_temperature():
             s = rte(scn2dict(e), heat_equation=HeatEquationType.HEAT_EQUATION_THREE_TEMPERATURES_LEGACY)
             r = s.steady_temperature()
 
-            assert np.allclose(r[VariableType.TEMPERATURE_SURFACE], e["T_surf"], atol=0.05)
-            assert np.allclose(r[VariableType.TEMPERATURE_AVERAGE], e["T_mean"], atol=0.05)
-            assert np.allclose(r[VariableType.TEMPERATURE_CORE], e["T_heart"], atol=0.05)
+            assert np.allclose(r[TemperatureLocation.SURFACE], e["T_surf"], atol=0.05)
+            assert np.allclose(r[TemperatureLocation.AVERAGE], e["T_mean"], atol=0.05)
+            assert np.allclose(r[TemperatureLocation.CORE], e["T_heart"], atol=0.05)
 
 
 def test_steady_ampacity():
@@ -113,16 +114,16 @@ def test_transient_temperature():
 
             # transient temperature (linearized)
             rl = s.transient_temperature_legacy(
-                time=time, Ts0=ri[VariableType.TEMPERATURE_SURFACE], Tc0=ri[VariableType.TEMPERATURE_CORE], tau=tau
+                time=time, Ts0=ri[TemperatureLocation.SURFACE], Tc0=ri[TemperatureLocation.CORE], tau=tau
             )
 
             # check final temp
-            assert np.isclose(e["T_mean_final"], rf[VariableType.TEMPERATURE_AVERAGE][0], atol=atol)
+            assert np.isclose(e["T_mean_final"], rf[TemperatureLocation.AVERAGE][0], atol=atol)
 
             # check transient temp
             for k1, k2 in zip(
                 ["T_surf_transient", "T_mean_transient", "T_heart_transient"],
-                [VariableType.TEMPERATURE_SURFACE, VariableType.TEMPERATURE_AVERAGE, VariableType.TEMPERATURE_CORE],
+                [TemperatureLocation.SURFACE, TemperatureLocation.AVERAGE, TemperatureLocation.CORE],
             ):
                 expected_time = np.array(list(e[k1].keys())) * minute
                 expected_temp = np.array(list(e[k1].values()))
diff --git a/test/test_shape.py b/test/test_shape.py
index df6cd50..e158e1e 100644
--- a/test/test_shape.py
+++ b/test/test_shape.py
@@ -10,6 +10,8 @@
 
 from thermohl import solver
 from thermohl.solver import HeatEquationType, SolverType
+from thermohl.solver.enums.cable_location import CableLocation
+from thermohl.solver.enums.temperature_location import TemperatureLocation
 from thermohl.solver.enums.variable_type import VariableType
 
 
@@ -25,7 +27,7 @@ def _ampargs(s: solver.Solver, t: pd.DataFrame):
     if isinstance(s, solver.Solver1T):
         a = dict(T=t[VariableType.TEMPERATURE].values)
     elif isinstance(s, solver.Solver3T):
-        a = dict(T=t[VariableType.TEMPERATURE_SURFACE].values, target=VariableType.SURFACE)
+        a = dict(T=t[TemperatureLocation.SURFACE].values, target=CableLocation.SURFACE)
     else:
         raise NotImplementedError
     return a
@@ -37,8 +39,8 @@ def _traargs(s: solver.Solver, ds: pd.DataFrame, t):
     elif isinstance(s, solver.Solver3T):
         a = dict(
             time=t,
-            Ts0=ds[VariableType.TEMPERATURE_SURFACE].values,
-            Tc0=ds[VariableType.TEMPERATURE_CORE].values,
+            Ts0=ds[TemperatureLocation.SURFACE].values,
+            Tc0=ds[TemperatureLocation.CORE].values,
         )
     else:
         raise NotImplementedError
diff --git a/test/test_solver1t.py b/test/test_solver1t.py
index c047fd9..8183197 100644
--- a/test/test_solver1t.py
+++ b/test/test_solver1t.py
@@ -11,6 +11,7 @@
 from thermohl.solver import SolverType
 from thermohl.solver.enums.heat_equation_type import HeatEquationType
 from thermohl.solver.enums.variable_type import VariableType
+from thermohl.solver.enums.power_type import PowerType
 
 _nprs = 123456
 
@@ -46,11 +47,11 @@ def test_balance():
         )
         assert np.all(df[VariableType.ERROR] < tol)
         bl = np.abs(
-            df[VariableType.POWER_JOULE]
-            + df[VariableType.POWER_SUN]
-            - df[VariableType.POWER_CONVECTION]
-            - df[VariableType.POWER_RADIATION]
-            - df[VariableType.POWER_RAIN]
+            df[PowerType.JOULE]
+            + df[PowerType.SOLAR]
+            - df[PowerType.CONVECTION]
+            - df[PowerType.RADIATION]
+            - df[PowerType.RAIN]
         )
         atol = np.maximum(
             np.abs(s.balance(df[VariableType.TEMPERATURE] + 0.5 * df[VariableType.ERROR])),
@@ -80,11 +81,11 @@ def test_consistency():
             T=100.0, return_err=True, return_power=True, tol=1.0e-09, maxiter=64
         )
         bl = (
-            df[VariableType.POWER_JOULE]
-            + df[VariableType.POWER_SUN]
-            - df[VariableType.POWER_CONVECTION]
-            - df[VariableType.POWER_RADIATION]
-            - df[VariableType.POWER_RAIN]
+            df[PowerType.JOULE]
+            + df[PowerType.SOLAR]
+            - df[PowerType.CONVECTION]
+            - df[PowerType.RADIATION]
+            - df[PowerType.RAIN]
         )
         assert np.allclose(bl, 0.0, atol=1.0e-06)
         s.args[VariableType.TRANSIT.value] = df[VariableType.TRANSIT].values
diff --git a/test/test_solver3t.py b/test/test_solver3t.py
index e6bfb58..b329194 100644
--- a/test/test_solver3t.py
+++ b/test/test_solver3t.py
@@ -11,6 +11,8 @@
 from thermohl.solver import HeatEquationType
 from thermohl.solver.enums.solver_type import SolverType
 from thermohl.solver.enums.variable_type import VariableType
+from thermohl.solver.enums.temperature_location import TemperatureLocation
+from thermohl.solver.enums.cable_location import CableLocation
 
 _nprs = 123456
 
@@ -57,10 +59,10 @@ def test_balance():
         # checks
         assert np.all(df[VariableType.ERROR] < tol)
         assert np.allclose(
-            s.balance(ts=df[VariableType.TEMPERATURE_SURFACE], tc=df[VariableType.TEMPERATURE_CORE]).values, 0.0, atol=tol
+            s.balance(ts=df[TemperatureLocation.SURFACE], tc=df[TemperatureLocation.CORE]).values, 0.0, atol=tol
         )
         assert np.allclose(
-            s.morgan(ts=df[VariableType.TEMPERATURE_SURFACE], tc=df[VariableType.TEMPERATURE_CORE]).values, 0.0, atol=tol
+            s.morgan(ts=df[TemperatureLocation.SURFACE], tc=df[TemperatureLocation.CORE]).values, 0.0, atol=tol
         )
 
 
@@ -82,9 +84,9 @@ def test_consistency():
     )
 
     for s in _solvers(dic):
-        d = {VariableType.SURFACE: VariableType.TEMPERATURE_SURFACE,
-             VariableType.AVERAGE: VariableType.TEMPERATURE_AVERAGE,
-             VariableType.CORE: VariableType.TEMPERATURE_CORE}
+        d = {CableLocation.SURFACE: TemperatureLocation.SURFACE,
+             CableLocation.AVERAGE: TemperatureLocation.AVERAGE,
+             CableLocation.CORE: TemperatureLocation.CORE}
 
         for location,temperature_at_location in d.items():
             # solve intensity with different targets
@@ -101,15 +103,15 @@ def test_consistency():
             s.args.I = df[VariableType.TRANSIT].values
             s.update()
             assert np.allclose(
-                s.balance(ts=df[VariableType.TEMPERATURE_SURFACE], tc=df[VariableType.TEMPERATURE_CORE]).values, 0.0, atol=tol
+                s.balance(ts=df[TemperatureLocation.SURFACE], tc=df[TemperatureLocation.CORE]).values, 0.0, atol=tol
             )
             assert np.allclose(
-                s.morgan(ts=df[VariableType.TEMPERATURE_SURFACE], tc=df[VariableType.TEMPERATURE_CORE]).values, 0.0, atol=tol
+                s.morgan(ts=df[TemperatureLocation.SURFACE], tc=df[TemperatureLocation.CORE]).values, 0.0, atol=tol
             )
             # 3t solve
             dg = s.steady_temperature(
-                Tsg=df[VariableType.TEMPERATURE_SURFACE].round(1).values,
-                Tcg=df[VariableType.TEMPERATURE_CORE].round(1).values,
+                Tsg=df[TemperatureLocation.SURFACE].round(1).values,
+                Tcg=df[TemperatureLocation.CORE].round(1).values,
                 return_err=True,
                 return_power=True,
                 tol=1.0e-09,
diff --git a/test/unit/solver/test_slv1t.py b/test/unit/solver/test_slv1t.py
index 84cfde8..f0ef3cb 100644
--- a/test/unit/solver/test_slv1t.py
+++ b/test/unit/solver/test_slv1t.py
@@ -9,6 +9,7 @@
 import numpy as np
 import pandas as pd
 
+from thermohl.solver.enums.power_type import PowerType
 from thermohl.solver.enums.variable_type import VariableType
 from thermohl.solver.slv1t import Solver1T
 
@@ -38,11 +39,11 @@ def test_steady_temperature_default(solver):
 
     assert isinstance(result, pd.DataFrame)
     assert VariableType.TEMPERATURE in result.columns
-    assert VariableType.POWER_JOULE in result.columns
-    assert VariableType.POWER_SUN in result.columns
-    assert VariableType.POWER_CONVECTION in result.columns
-    assert VariableType.POWER_RADIATION in result.columns
-    assert VariableType.POWER_RAIN in result.columns
+    assert PowerType.JOULE in result.columns
+    assert PowerType.SOLAR in result.columns
+    assert PowerType.CONVECTION in result.columns
+    assert PowerType.RADIATION in result.columns
+    assert PowerType.RAIN in result.columns
 
 
 def test_steady_temperature_with_error(solver):
@@ -58,11 +59,11 @@ def test_steady_temperature_no_power(solver):
 
     assert isinstance(result, pd.DataFrame)
     assert VariableType.TEMPERATURE in result.columns
-    assert VariableType.POWER_JOULE not in result.columns
-    assert VariableType.POWER_SUN not in result.columns
-    assert VariableType.POWER_CONVECTION not in result.columns
-    assert VariableType.POWER_RADIATION not in result.columns
-    assert VariableType.POWER_RAIN not in result.columns
+    assert PowerType.JOULE not in result.columns
+    assert PowerType.SOLAR not in result.columns
+    assert PowerType.CONVECTION not in result.columns
+    assert PowerType.RADIATION not in result.columns
+    assert PowerType.RAIN not in result.columns
 
 
 def test_steady_temperature_custom_params(solver):
@@ -118,11 +119,11 @@ def test_transient_temperature_with_error(solver):
     assert VariableType.TEMPERATURE in result
     assert len(result[VariableType.TIME]) == len(time)
     assert len(result[VariableType.TEMPERATURE]) == len(time)
-    assert VariableType.POWER_JOULE in result
-    assert VariableType.POWER_SUN in result
-    assert VariableType.POWER_CONVECTION in result
-    assert VariableType.POWER_RADIATION in result
-    assert VariableType.POWER_RAIN in result
+    assert PowerType.JOULE in result
+    assert PowerType.SOLAR in result
+    assert PowerType.CONVECTION in result
+    assert PowerType.RADIATION in result
+    assert PowerType.RAIN in result
 
 
 def test_steady_intensity_default(solver):
@@ -132,11 +133,11 @@ def test_steady_intensity_default(solver):
 
     assert isinstance(result, pd.DataFrame)
     assert VariableType.TRANSIT in result.columns
-    assert VariableType.POWER_JOULE in result.columns
-    assert VariableType.POWER_SUN in result.columns
-    assert VariableType.POWER_CONVECTION in result.columns
-    assert VariableType.POWER_RADIATION in result.columns
-    assert VariableType.POWER_RAIN in result.columns
+    assert PowerType.JOULE in result.columns
+    assert PowerType.SOLAR in result.columns
+    assert PowerType.CONVECTION in result.columns
+    assert PowerType.RADIATION in result.columns
+    assert PowerType.RAIN in result.columns
 
 
 def test_steady_intensity_with_error(solver):
@@ -156,11 +157,11 @@ def test_steady_intensity_no_power(solver):
 
     assert isinstance(result, pd.DataFrame)
     assert VariableType.TRANSIT in result.columns
-    assert VariableType.POWER_JOULE not in result.columns
-    assert VariableType.POWER_SUN not in result.columns
-    assert VariableType.POWER_CONVECTION not in result.columns
-    assert VariableType.POWER_RADIATION not in result.columns
-    assert VariableType.POWER_RAIN not in result.columns
+    assert PowerType.JOULE not in result.columns
+    assert PowerType.SOLAR not in result.columns
+    assert PowerType.CONVECTION not in result.columns
+    assert PowerType.RADIATION not in result.columns
+    assert PowerType.RAIN not in result.columns
 
 
 def test_steady_intensity_custom_params(solver):
diff --git a/thermohl-docs/docs/examples/ex_transient_3t.ipynb b/thermohl-docs/docs/examples/ex_transient_3t.ipynb
index 1a68f00..e9f705c 100644
--- a/thermohl-docs/docs/examples/ex_transient_3t.ipynb
+++ b/thermohl-docs/docs/examples/ex_transient_3t.ipynb
@@ -34,6 +34,7 @@
     "   \"outputs\": [],\n",
     "   \"execution_count\": null,\n",
     "   \"source\": [\n",
+    "    \"from thermohl.solver.enums.temperature_location import TemperatureLocation\\n\",\n",
     "    \"from thermohl.solver.enums.variable_type import VariableType\\n\",\n",
     "    \"\\n\",\n",
     "    \"\\n\",\n",
@@ -47,8 +48,8 @@
     "    \"    slvr.args[VariableType.TRANSIT] = 400.\\n\",\n",
     "    \"    slvr.update()\\n\",\n",
     "    \"    dtstdy = slvr.steady_temperature()\\n\",\n",
-    "    \"    T_surf = dtstdy[VariableType.TEMPERATURE_SURFACE].values\\n\",\n",
-    "    \"    T_core = dtstdy[VariableType.TEMPERATURE_CORE].values\\n\",\n",
+    "    \"    T_surf = dtstdy[TemperatureLocation.SURFACE].values\\n\",\n",
+    "    \"    T_core = dtstdy[TemperatureLocation.CORE].values\\n\",\n",
     "    \"\\n\",\n",
     "    \"    # restore initial transit in dic\\n\",\n",
     "    \"    slvr.args[VariableType.TRANSIT] = dic[VariableType.TRANSIT]\\n\",\n",
@@ -61,10 +62,10 @@
     "    \"    # plot\\n\",\n",
     "    \"    fig, ax = plt.subplots(nrows=1, ncols=1)\\n\",\n",
     "    \"    tm = t / 60\\n\",\n",
-    "    \"    ax.fill_between(tm, dtemp[VariableType.TEMPERATURE_SURFACE], dtemp[VariableType.TEMPERATURE_CORE], fc='gray', alpha=0.33, ec=None)\\n\",\n",
-    "    \"    ax.plot(tm, dtemp[VariableType.TEMPERATURE_SURFACE], c='C0', label='Surface Conductor temperature (C)')\\n\",\n",
-    "    \"    ax.plot(tm, dtemp[VariableType.TEMPERATURE_AVERAGE], c='C1', label='average Conductor temperature (C)')\\n\",\n",
-    "    \"    ax.plot(tm, dtemp[VariableType.TEMPERATURE_CORE], c='C3', label='Core Conductor temperature (C)')\\n\",\n",
+    "    \"    ax.fill_between(tm, dtemp[TemperatureLocation.SURFACE], dtemp[TemperatureLocation.CORE], fc='gray', alpha=0.33, ec=None)\\n\",\n",
+    "    \"    ax.plot(tm, dtemp[TemperatureLocation.SURFACE], c='C0', label='Surface Conductor temperature (C)')\\n\",\n",
+    "    \"    ax.plot(tm, dtemp[TemperatureLocation.AVERAGE], c='C1', label='average Conductor temperature (C)')\\n\",\n",
+    "    \"    ax.plot(tm, dtemp[TemperatureLocation.CORE], c='C3', label='Core Conductor temperature (C)')\\n\",\n",
     "    \"    ax.set_xlabel(\\\"Time (hour)\\\")\\n\",\n",
     "    \"    ax.set_ylabel(\\\"Temperature (C)\\\")\\n\",\n",
     "    \"    ax.grid(True)\\n\",\n",
@@ -99,7 +100,7 @@
     "    \"t = np.linspace(0, 3600, 901)\\n\",\n",
     "    \"\\n\"\n",
     "   ],\n",
-    "   \"id\": \"4425a6fc34f3b87c\"\n",
+    "   \"id\": \"4da701b2b28b0e37\"\n",
     "  }\n",
     " ],\n",
     " \"metadata\": {\n",
@@ -125,7 +126,7 @@
     " \"nbformat_minor\": 5\n",
     "}\n"
    ],
-   "id": "4da701b2b28b0e37"
+   "id": "db19dc60a813fdd7"
   }
  ],
  "metadata": {

From 2b92c3e3a2606d8126351ad145cd093124d273cd Mon Sep 17 00:00:00 2001
From: Olivier Pigeon <olivier.pigeon@rte-france.com>
Date: Wed, 3 Dec 2025 12:24:20 +0100
Subject: [PATCH 5/6] feat(#2): Refactor

Signed-off-by: Olivier Pigeon <olivier.pigeon@rte-france.com>
---
 README.md                                     |  4 +-
 examples/example_solver_intensity.py          |  8 ++--
 src/thermohl/solver/__init__.py               | 22 +++++-----
 src/thermohl/solver/enums/cable_location.py   |  7 ++++
 .../solver/enums/heat_equation_type.py        |  8 ++--
 src/thermohl/solver/enums/power_type.py       |  7 ++++
 .../solver/enums/temperature_location.py      |  7 ++++
 src/thermohl/solver/enums/variable_type.py    |  2 +-
 src/thermohl/solver/slv3t.py                  |  2 +-
 test/functional_test/functional_test.py       |  6 +--
 test/test_shape.py                            |  2 +-
 test/test_solver1t.py                         |  2 +-
 test/test_solver3t.py                         |  4 +-
 .../docs/examples/ex_all_params.ipynb         | 32 +++++++++------
 .../docs/examples/ex_steady_1t.ipynb          |  2 +-
 .../docs/examples/ex_steady_3t.ipynb          |  9 ++--
 .../docs/examples/ex_transient_3t.ipynb       | 41 ++++++++++++++-----
 thermohl-docs/docs/getting-started.md         |  4 +-
 18 files changed, 108 insertions(+), 61 deletions(-)

diff --git a/README.md b/README.md
index a3a5cd1..31d0ca5 100644
--- a/README.md
+++ b/README.md
@@ -140,7 +140,7 @@ surface temperature (°C) of a conductor in steady-state regime along with the c
 from thermohl import solver
 from thermohl.solver.enums.heat_equation_type import HeatEquationType
 
-slvr = solver.ieee(dic=None, heat_equation=HeatEquationType.HEAT_EQUATION_ONE_TEMPERATURE)
+slvr = solver.ieee(dic=None, heat_equation=HeatEquationType.WITH_ONE_TEMPERATURE)
 temp = slvr.steady_temperature() 
 ```
 
@@ -164,7 +164,7 @@ import numpy as np
 from thermohl import solver
 from thermohl.solver.enums.heat_equation_type import HeatEquationType
 
-slvr = solver.ieee(dict(Ta=np.array([0., 15., 30.])), heat_equation=HeatEquationType.HEAT_EQUATION_ONE_TEMPERATURE)
+slvr = solver.ieee(dict(Ta=np.array([0., 15., 30.])), heat_equation=HeatEquationType.WITH_ONE_TEMPERATURE)
 Tmax = 80.
 imax = slvr.steady_intensity(Tmax)
 ```
diff --git a/examples/example_solver_intensity.py b/examples/example_solver_intensity.py
index c049275..fe20741 100644
--- a/examples/example_solver_intensity.py
+++ b/examples/example_solver_intensity.py
@@ -26,8 +26,8 @@ def test_solve(dct, Trep, tol=1.0e-06, mxi=64):
     mdl = [
         dict(label="cigr", model=solver.cigre(dct)),
         dict(label="ieee", model=solver.ieee(dct)),
-        dict(label="olla", model=solver.olla(dct)),
-        #dict(label="ollm", model=solver.olla(dct, multi=True)),
+        dict(label="olla", model=solver.olla(dct, multi=False)),
+        dict(label="ollm", model=solver.olla(dct, multi=True)),
         dict(label="rte", model=solver.rte(dct)),
     ]
     dfi = pd.DataFrame(dct)
@@ -75,8 +75,8 @@ def test_solve(dct, Trep, tol=1.0e-06, mxi=64):
     mdl = [
         dict(label="cigr", model=solver.cigre(dct)),
         dict(label="ieee", model=solver.ieee(dct)),
-        dict(label="olla", model=solver.olla(dct)),
-        #dict(label="ollm", model=solver.olla(dct, multi=True)),
+        dict(label="olla", model=solver.olla(dct, multi=False)),
+        dict(label="ollm", model=solver.olla(dct, multi=True)),
         dict(label="rte", model=solver.rte(dct)),
     ]
 
diff --git a/src/thermohl/solver/__init__.py b/src/thermohl/solver/__init__.py
index 3b2cc4c..5006b85 100644
--- a/src/thermohl/solver/__init__.py
+++ b/src/thermohl/solver/__init__.py
@@ -33,8 +33,8 @@ def default_values() -> Dict[str, Any]:
 
 def _factory(
     dic: Optional[Dict[str, Any]] = None,
-    heat_equation: HeatEquationType = HeatEquationType.HEAT_EQUATION_ONE_TEMPERATURE,
-    model: SolverType = SolverType.SOLVER_CIGRE,
+    heat_equation: HeatEquationType = HeatEquationType.WITH_ONE_TEMPERATURE,
+    model: SolverType = SolverType.SOLVER_IEEE,
 ) -> Solver:
 
     solver = create_solver_from_heat_equation(heat_equation)
@@ -62,10 +62,10 @@ def _factory(
 
 def create_solver_from_heat_equation(heat_equation: HeatEquationType) -> concreteSolverType:
     heat_equations_solvers = {
-        HeatEquationType.HEAT_EQUATION_ONE_TEMPERATURE: Solver1T,
-        HeatEquationType.HEAT_EQUATION_THREE_TEMPERATURES: Solver3T,
-        HeatEquationType.HEAT_EQUATION_THREE_TEMPERATURES_LEGACY: Solver3TL,
-        HeatEquationType.HEAT_EQUATION_1D: Solver1D
+        HeatEquationType.WITH_ONE_TEMPERATURE: Solver1T,
+        HeatEquationType.WITH_THREE_TEMPERATURES: Solver3T,
+        HeatEquationType.WITH_THREE_TEMPERATURES_LEGACY: Solver3TL,
+        HeatEquationType.WITH_1D: Solver1D
     }
 
     if heat_equation not in heat_equations_solvers:
@@ -75,7 +75,7 @@ def create_solver_from_heat_equation(heat_equation: HeatEquationType) -> concret
 
 
 def __solver_model(dic: Optional[Dict[str, Any]] = None,
-                   heat_equation: HeatEquationType = HeatEquationType.HEAT_EQUATION_ONE_TEMPERATURE,
+                   heat_equation: HeatEquationType = HeatEquationType.WITH_ONE_TEMPERATURE,
                    model: SolverType = SolverType.SOLVER_CIGRE,
                    )\
         -> Solver:
@@ -91,7 +91,7 @@ def __solver_model(dic: Optional[Dict[str, Any]] = None,
 
 
 def cigre(dic: Optional[Dict[str, Any]] = None,
-          heat_equation: HeatEquationType = HeatEquationType.HEAT_EQUATION_ONE_TEMPERATURE)\
+          heat_equation: HeatEquationType = HeatEquationType.WITH_ONE_TEMPERATURE)\
         -> Solver:
     """Get a Solver using CIGRE models.
 
@@ -103,7 +103,7 @@ def cigre(dic: Optional[Dict[str, Any]] = None,
     return __solver_model(dic=dic, heat_equation=heat_equation, model=SolverType.SOLVER_CIGRE)
 
 
-def ieee(dic: Optional[Dict[str, Any]] = None, heat_equation: HeatEquationType = HeatEquationType.HEAT_EQUATION_ONE_TEMPERATURE) -> Solver:
+def ieee(dic: Optional[Dict[str, Any]] = None, heat_equation: HeatEquationType = HeatEquationType.WITH_ONE_TEMPERATURE) -> Solver:
     """Get a Solver using IEEE models.
 
     Args:
@@ -114,7 +114,7 @@ def ieee(dic: Optional[Dict[str, Any]] = None, heat_equation: HeatEquationType =
     return __solver_model(dic, heat_equation=heat_equation, model=SolverType.SOLVER_IEEE)
 
 
-def olla(dic: Optional[Dict[str, Any]] = None, heat_equation: HeatEquationType = HeatEquationType.HEAT_EQUATION_ONE_TEMPERATURE) -> Solver:
+def olla(dic: Optional[Dict[str, Any]] = None, heat_equation: HeatEquationType = HeatEquationType.WITH_ONE_TEMPERATURE) -> Solver:
     """Get a Solver using RTE-olla models.
 
     Args:
@@ -125,7 +125,7 @@ def olla(dic: Optional[Dict[str, Any]] = None, heat_equation: HeatEquationType =
     return __solver_model(dic, heat_equation=heat_equation, model=SolverType.SOLVER_OLLA)
 
 
-def rte(dic: Optional[Dict[str, Any]] = None, heat_equation: HeatEquationType = HeatEquationType.HEAT_EQUATION_ONE_TEMPERATURE) -> Solver:
+def rte(dic: Optional[Dict[str, Any]] = None, heat_equation: HeatEquationType = HeatEquationType.WITH_ONE_TEMPERATURE) -> Solver:
     """Get a Solver using RTE models.
 
     Args:
diff --git a/src/thermohl/solver/enums/cable_location.py b/src/thermohl/solver/enums/cable_location.py
index b911ffe..1af8743 100644
--- a/src/thermohl/solver/enums/cable_location.py
+++ b/src/thermohl/solver/enums/cable_location.py
@@ -1,3 +1,10 @@
+# SPDX-FileCopyrightText: 2025 RTE (https://www.rte-france.com)
+#
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+# SPDX-License-Identifier: MPL-2.0
+
 from enum import Enum
 from typing import Union, List
 
diff --git a/src/thermohl/solver/enums/heat_equation_type.py b/src/thermohl/solver/enums/heat_equation_type.py
index 3ec5a0a..62cfe3d 100644
--- a/src/thermohl/solver/enums/heat_equation_type.py
+++ b/src/thermohl/solver/enums/heat_equation_type.py
@@ -9,8 +9,8 @@
 
 class HeatEquationType(Enum):
 
-    HEAT_EQUATION_ONE_TEMPERATURE = "1t",
-    HEAT_EQUATION_THREE_TEMPERATURES = "3t",
-    HEAT_EQUATION_THREE_TEMPERATURES_LEGACY = "3tl",
-    HEAT_EQUATION_1D = "1d"
+    WITH_ONE_TEMPERATURE = "1t",
+    WITH_THREE_TEMPERATURES = "3t",
+    WITH_THREE_TEMPERATURES_LEGACY = "3tl",
+    WITH_1D = "1d"
 
diff --git a/src/thermohl/solver/enums/power_type.py b/src/thermohl/solver/enums/power_type.py
index ce8aff5..b3d60c6 100644
--- a/src/thermohl/solver/enums/power_type.py
+++ b/src/thermohl/solver/enums/power_type.py
@@ -1,3 +1,10 @@
+# SPDX-FileCopyrightText: 2025 RTE (https://www.rte-france.com)
+#
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+# SPDX-License-Identifier: MPL-2.0
+
 from enum import Enum
 
 class PowerType(Enum):
diff --git a/src/thermohl/solver/enums/temperature_location.py b/src/thermohl/solver/enums/temperature_location.py
index d0f781f..c7c820b 100644
--- a/src/thermohl/solver/enums/temperature_location.py
+++ b/src/thermohl/solver/enums/temperature_location.py
@@ -1,3 +1,10 @@
+# SPDX-FileCopyrightText: 2025 RTE (https://www.rte-france.com)
+#
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+# SPDX-License-Identifier: MPL-2.0
+
 from enum import Enum
 
 class TemperatureLocation(Enum):
diff --git a/src/thermohl/solver/enums/variable_type.py b/src/thermohl/solver/enums/variable_type.py
index c45d0f4..4146c83 100644
--- a/src/thermohl/solver/enums/variable_type.py
+++ b/src/thermohl/solver/enums/variable_type.py
@@ -13,7 +13,7 @@
 class VariableType(Enum):
     ERROR = "err"
     TIME = "time"
-    TRANSIT = "I"
+    TRANSIT = "transit"
     TEMPERATURE = "t"
 
 
diff --git a/src/thermohl/solver/slv3t.py b/src/thermohl/solver/slv3t.py
index 5f979eb..13eeab8 100644
--- a/src/thermohl/solver/slv3t.py
+++ b/src/thermohl/solver/slv3t.py
@@ -390,7 +390,7 @@ def _check_target(target: CableLocationListLike, d, max_len):
                 ]
             )
         elif isinstance(target, CableLocation):
-                target_ = np.array([target for _ in range(max_len)])
+            target_ = np.array([target for _ in range(max_len)])
         else:
             if len(target) != max_len:
                 raise ValueError()
diff --git a/test/functional_test/functional_test.py b/test/functional_test/functional_test.py
index eab42dc..e38f122 100644
--- a/test/functional_test/functional_test.py
+++ b/test/functional_test/functional_test.py
@@ -68,7 +68,7 @@ def scn2dict(d: dict) -> dict:
 def test_steady_temperature():
     for d in scenario("temperature", "steady"):
         for _, e in d.items():
-            s = rte(scn2dict(e), heat_equation=HeatEquationType.HEAT_EQUATION_THREE_TEMPERATURES_LEGACY)
+            s = rte(scn2dict(e), heat_equation=HeatEquationType.WITH_THREE_TEMPERATURES_LEGACY)
             r = s.steady_temperature()
 
             assert np.allclose(r[TemperatureLocation.SURFACE], e["T_surf"], atol=0.05)
@@ -79,7 +79,7 @@ def test_steady_temperature():
 def test_steady_ampacity():
     for d in scenario("ampacity", "steady"):
         for _, e in d.items():
-            s = rte(scn2dict(e), heat_equation=HeatEquationType.HEAT_EQUATION_THREE_TEMPERATURES_LEGACY)
+            s = rte(scn2dict(e), heat_equation=HeatEquationType.WITH_THREE_TEMPERATURES_LEGACY)
             r = s.steady_intensity(T=e["Tmax_cable"])
 
             assert np.allclose(r[VariableType.TRANSIT], e["I_max"], atol=0.05)
@@ -97,7 +97,7 @@ def test_transient_temperature():
         for _, e in d.items():
 
             # solver
-            s = rte(scn2dict(e), heat_equation=HeatEquationType.HEAT_EQUATION_THREE_TEMPERATURES_LEGACY)
+            s = rte(scn2dict(e), heat_equation=HeatEquationType.WITH_THREE_TEMPERATURES_LEGACY)
 
             # initial steady state
             s.args[VariableType.TRANSIT.value] = e["I0_cable"]
diff --git a/test/test_shape.py b/test/test_shape.py
index e158e1e..b8c77b0 100644
--- a/test/test_shape.py
+++ b/test/test_shape.py
@@ -17,7 +17,7 @@
 
 def _solvers():
     li = []
-    for heat_equation in [HeatEquationType.HEAT_EQUATION_ONE_TEMPERATURE, HeatEquationType.HEAT_EQUATION_THREE_TEMPERATURES]:
+    for heat_equation in [HeatEquationType.WITH_ONE_TEMPERATURE, HeatEquationType.WITH_THREE_TEMPERATURES]:
         for m in [SolverType.SOLVER_RTE, SolverType.SOLVER_CIGRE, SolverType.SOLVER_IEEE, SolverType.SOLVER_OLLA]:
             li.append(solver._factory(dic=None, heat_equation=heat_equation, model=m))
     return li
diff --git a/test/test_solver1t.py b/test/test_solver1t.py
index 8183197..044e7c1 100644
--- a/test/test_solver1t.py
+++ b/test/test_solver1t.py
@@ -18,7 +18,7 @@
 
 def _solvers(dic=None):
     return [
-        solver._factory(dic=dic, heat_equation=HeatEquationType.HEAT_EQUATION_ONE_TEMPERATURE, model=m)
+        solver._factory(dic=dic, heat_equation=HeatEquationType.WITH_ONE_TEMPERATURE, model=m)
         for m in [SolverType.SOLVER_RTE, SolverType.SOLVER_CIGRE, SolverType.SOLVER_IEEE, SolverType.SOLVER_OLLA]
     ]
 
diff --git a/test/test_solver3t.py b/test/test_solver3t.py
index b329194..498cdab 100644
--- a/test/test_solver3t.py
+++ b/test/test_solver3t.py
@@ -20,7 +20,7 @@
 def _solvers(dic=None):
     return [
         solver._factory(dic=dic, heat_equation=heat_equation, model=m)
-        for heat_equation in [HeatEquationType.HEAT_EQUATION_THREE_TEMPERATURES, HeatEquationType.HEAT_EQUATION_THREE_TEMPERATURES_LEGACY]
+        for heat_equation in [HeatEquationType.WITH_THREE_TEMPERATURES, HeatEquationType.WITH_THREE_TEMPERATURES_LEGACY]
         for m in [SolverType.SOLVER_RTE, SolverType.SOLVER_CIGRE, SolverType.SOLVER_IEEE, SolverType.SOLVER_OLLA]
     ]
 
@@ -47,7 +47,7 @@ def test_balance():
 
     for s in _solvers(dic):
         # compute guess with 1t solver
-        s1 = solver._factory(dic=dic, heat_equation=HeatEquationType.HEAT_EQUATION_ONE_TEMPERATURE, model=SolverType.SOLVER_IEEE)
+        s1 = solver._factory(dic=dic, heat_equation=HeatEquationType.WITH_ONE_TEMPERATURE, model=SolverType.SOLVER_IEEE)
         t1 = s1.steady_temperature(
             tol=2.0, maxiter=16, return_err=False, return_power=False
         )
diff --git a/thermohl-docs/docs/examples/ex_all_params.ipynb b/thermohl-docs/docs/examples/ex_all_params.ipynb
index 5436c86..939c36f 100644
--- a/thermohl-docs/docs/examples/ex_all_params.ipynb
+++ b/thermohl-docs/docs/examples/ex_all_params.ipynb
@@ -21,21 +21,26 @@
     "  },\n",
     "  {\n",
     "   \"metadata\": {},\n",
+    "   \"cell_type\": \"code\",\n",
     "   \"outputs\": [],\n",
+    "   \"execution_count\": null,\n",
     "   \"source\": [\n",
+    "    \"from thermohl.solver import SolverType, HeatEquationType\\n\",\n",
+    "    \"\\n\",\n",
+    "    \"\\n\",\n",
     "    \"def plot_all_params(dic):\\n\",\n",
-    "    \"    # using 1t heat equation on all power terms model sets, building solvers and\\n\",\n",
+    "    \"    # using 1t heat equation on all power terms model sets, building solvers and \\n\",\n",
     "    \"    # solving steady temperature\\n\",\n",
     "    \"    models = [SolverType.SOLVER_CIGRE, SolverType.SOLVER_IEEE, SolverType.SOLVER_OLLA, SolverType.SOLVER_RTE]\\n\",\n",
-    "    \"    solvers = [solver._factory(dic, heat_equation=HeatEquationType.HEAT_EQUATION_ONE_TEMPERATURE, model=m) for m in models]\\n\",\n",
+    "    \"    solvers = [solver._factory(dic, heat_equation=HeatEquationType.WITH_ONE_TEMPERATURE, model=m) for m in models]\\n\",\n",
     "    \"    results = [s.steady_temperature(return_power=True) for s in solvers]\\n\",\n",
-    "    \"\\n\",\n",
+    "    \"    \\n\",\n",
     "    \"    # plot all\\n\",\n",
-    "    \"    fig, ax = plt.subplots(nrows=2, ncols=4, figsize=(20, 10))\\n\",\n",
-    "    \"    for i, key in enumerate([\\\"transit\\\", \\\"Ta\\\", \\\"ws\\\"]):\\n\",\n",
+    "    \"    fig, ax = plt.subplots(nrows=2, ncols=4,figsize=(20, 10))\\n\",\n",
+    "    \"    for i, key in enumerate([\\\"I\\\", \\\"Ta\\\", \\\"ws\\\"]):\\n\",\n",
     "    \"        ax[0, i].plot(dic[\\\"hour\\\"], dic[key])\\n\",\n",
     "    \"        ax[0, i].set_title(f\\\"Input {key}\\\")\\n\",\n",
-    "    \"\\n\",\n",
+    "    \"    \\n\",\n",
     "    \"    ax[0, 3].set_title(\\\"Conductor temperature\\\")\\n\",\n",
     "    \"    for i, r in enumerate(results):\\n\",\n",
     "    \"        ci = f\\\"C{1+i}\\\"\\n\",\n",
@@ -43,14 +48,15 @@
     "    \"        for j, p in enumerate(['P_joule', 'P_solar', 'P_convection', 'P_radiation']):\\n\",\n",
     "    \"            ax[1, j].plot(t, r[p], c=ci, label=models[i])\\n\",\n",
     "    \"            ax[1, j].set_title(f\\\"{p} (W/m)\\\")\\n\",\n",
-    "    \"\\n\",\n",
+    "    \"    \\n\",\n",
     "    \"    for i in range(ax.shape[0]):\\n\",\n",
     "    \"        for j in range(ax.shape[1]):\\n\",\n",
-    "    \"            ax[i, j].set_xlabel(\\\"Time (hour)\\\")\\n\",\n",
-    "    \"            ax[i, j].grid(True)\\n\",\n",
-    "    \"    ax[-1, -1].legend()\\n\",\n",
+    "    \"            ax[i,j].set_xlabel(\\\"Time (hour)\\\")\\n\",\n",
+    "    \"            ax[i,j].grid(True)\\n\",\n",
+    "    \"    ax[-1,-1].legend()\\n\",\n",
     "    \"    %matplotlib inline\"\n",
-    "   ]\n",
+    "   ],\n",
+    "   \"id\": \"2eeb1c6a93f9cba8\"\n",
     "  },\n",
     "  {\n",
     "   \"cell_type\": \"markdown\",\n",
@@ -80,7 +86,7 @@
     "    \"    month=6,\\n\",\n",
     "    \"    day=20,\\n\",\n",
     "    \"    hour=t,\\n\",\n",
-    "    \"    transit=np.piecewise(t, [t < 12., t >= 12.], [300., 600.]),\\n\",\n",
+    "    \"    I=np.piecewise(t, [t < 12., t >= 12.], [300., 600.]),\\n\",\n",
     "    \"    Ta=10. + 7.5*(1+np.sin(np.pi * (t-7.0)/12.0)),\\n\",\n",
     "    \"    ws=np.piecewise(t, [t <= 6., t>6., t>12., t >= 18.], [1., 2., 1., 3.]),\\n\",\n",
     "    \"    wa=69,\\n\",\n",
@@ -150,7 +156,7 @@
     " \"nbformat_minor\": 5\n",
     "}\n"
    ],
-   "id": "cdb83d6de6584f49"
+   "id": "3c2e5f05334df27b"
   }
  ],
  "metadata": {
diff --git a/thermohl-docs/docs/examples/ex_steady_1t.ipynb b/thermohl-docs/docs/examples/ex_steady_1t.ipynb
index cd69a1d..d2f0dca 100644
--- a/thermohl-docs/docs/examples/ex_steady_1t.ipynb
+++ b/thermohl-docs/docs/examples/ex_steady_1t.ipynb
@@ -34,7 +34,7 @@
     "def example_solver1t(dic):\n",
     "    # create solver with ieee power terms and 1t heat equation; other options\n",
     "    # available are solver.cigre, solver.olla and solver.rte for power terms\n",
-    "    slvr = solver.ieee(dic, heat_equation=HeatEquationType.HEAT_EQUATION_ONE_TEMPERATURE)\n",
+    "    slvr = solver.ieee(dic, heat_equation=HeatEquationType.WITH_ONE_TEMPERATURE)\n",
     "\n",
     "    # compute temperature\n",
     "    dtemp = slvr.steady_temperature()\n",
diff --git a/thermohl-docs/docs/examples/ex_steady_3t.ipynb b/thermohl-docs/docs/examples/ex_steady_3t.ipynb
index 6af8a4f..eca5291 100644
--- a/thermohl-docs/docs/examples/ex_steady_3t.ipynb
+++ b/thermohl-docs/docs/examples/ex_steady_3t.ipynb
@@ -39,7 +39,7 @@
     "   \"source\": [\n",
     "    \"def example_solver3t(dic):\\n\",\n",
     "    \"    # create solver with cigre power terms and 3t heat equation\\n\",\n",
-    "    \"    slvr = solver.cigre(dic, heat_equation=HeatEquationType.HEAT_EQUATION_THREE_TEMPERATURES)\\n\",\n",
+    "    \"    slvr = solver.cigre(dic, heat_equation=HeatEquationType.WITH_THREE_TEMPERATURES)\\n\",\n",
     "    \"\\n\",\n",
     "    \"    # compute temperature\\n\",\n",
     "    \"    dtemp = slvr.steady_temperature()\\n\",\n",
@@ -63,7 +63,8 @@
     "    \"        ax[i].legend()\\n\",\n",
     "    \"    ax[2].set_xlabel(\\\"Hour\\\")\\n\",\n",
     "    \"    %matplotlib inline\\n\",\n",
-    "    \"    plt.show()\"\n",
+    "    \"    plt.show()\\n\",\n",
+    "    \"    \"\n",
     "   ]\n",
     "  },\n",
     "  {\n",
@@ -87,7 +88,7 @@
     "    \"    month=6,\\n\",\n",
     "    \"    day=20,\\n\",\n",
     "    \"    hour=np.linspace(0.0, 23.0, 24),\\n\",\n",
-    "    \"    transit=np.array([600.0 for i in range(12)] + [900.0 for i in range(12)]),\\n\",\n",
+    "    \"    I=np.array([600.0 for i in range(12)] + [900.0 for i in range(12)]),\\n\",\n",
     "    \")\"\n",
     "   ]\n",
     "  },\n",
@@ -136,7 +137,7 @@
     " \"nbformat_minor\": 5\n",
     "}\n"
    ],
-   "id": "b391797fa4e804bb"
+   "id": "7755d1db5aa5c212"
   }
  ],
  "metadata": {
diff --git a/thermohl-docs/docs/examples/ex_transient_3t.ipynb b/thermohl-docs/docs/examples/ex_transient_3t.ipynb
index e9f705c..fa31b4f 100644
--- a/thermohl-docs/docs/examples/ex_transient_3t.ipynb
+++ b/thermohl-docs/docs/examples/ex_transient_3t.ipynb
@@ -9,16 +9,18 @@
     "  {\n",
     "   \"metadata\": {},\n",
     "   \"cell_type\": \"code\",\n",
-    "   \"outputs\": [],\n",
-    "   \"execution_count\": null,\n",
     "   \"source\": [\n",
     "    \"import matplotlib.pyplot as plt\\n\",\n",
     "    \"import numpy as np\\n\",\n",
     "    \"\\n\",\n",
     "    \"from thermohl import solver\\n\",\n",
-    "    \"from thermohl.solver import HeatEquationType\"\n",
+    "    \"from thermohl.solver import HeatEquationType\\n\",\n",
+    "    \"from thermohl.solver.enums.temperature_location import TemperatureLocation\\n\",\n",
+    "    \"from thermohl.solver.enums.variable_type import VariableType\"\n",
     "   ],\n",
-    "   \"id\": \"a4ada52a0ef47853\"\n",
+    "   \"id\": \"a4ada52a0ef47853\",\n",
+    "   \"outputs\": [],\n",
+    "   \"execution_count\": null\n",
     "  },\n",
     "  {\n",
     "   \"cell_type\": \"markdown\",\n",
@@ -34,14 +36,10 @@
     "   \"outputs\": [],\n",
     "   \"execution_count\": null,\n",
     "   \"source\": [\n",
-    "    \"from thermohl.solver.enums.temperature_location import TemperatureLocation\\n\",\n",
-    "    \"from thermohl.solver.enums.variable_type import VariableType\\n\",\n",
-    "    \"\\n\",\n",
-    "    \"\\n\",\n",
     "    \"def example_solver3t_transient(dic):\\n\",\n",
     "    \"\\n\",\n",
     "    \"    # create solver with rte power terms and 3t heat equation\\n\",\n",
-    "    \"    slvr = solver.rte(dic, heat_equation=HeatEquationType.HEAT_EQUATION_THREE_TEMPERATURES)\\n\",\n",
+    "    \"    slvr = solver.rte(dic, heat_equation=HeatEquationType.WITH_THREE_TEMPERATURES)\\n\",\n",
     "    \"\\n\",\n",
     "    \"    # change solver args to get initial state, compute initial values of surface\\n\",\n",
     "    \"    # and core temperature using steady temperature\\n\",\n",
@@ -100,7 +98,28 @@
     "    \"t = np.linspace(0, 3600, 901)\\n\",\n",
     "    \"\\n\"\n",
     "   ],\n",
-    "   \"id\": \"4da701b2b28b0e37\"\n",
+    "   \"id\": \"fdeebd9cac8e97ee\"\n",
+    "  },\n",
+    "  {\n",
+    "   \"cell_type\": \"code\",\n",
+    "   \"execution_count\": 9,\n",
+    "   \"id\": \"349c1e0c-af4e-4331-95da-4e0f353a651d\",\n",
+    "   \"metadata\": {},\n",
+    "   \"outputs\": [\n",
+    "    {\n",
+    "     \"data\": {\n",
+    "      \"image/png\": \"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\",\n",
+    "      \"text/plain\": [\n",
+    "       \"<Figure size 640x480 with 1 Axes>\"\n",
+    "      ]\n",
+    "     },\n",
+    "     \"metadata\": {},\n",
+    "     \"output_type\": \"display_data\"\n",
+    "    }\n",
+    "   ],\n",
+    "   \"source\": [\n",
+    "    \"example_solver3t_transient(dic)\"\n",
+    "   ]\n",
     "  }\n",
     " ],\n",
     " \"metadata\": {\n",
@@ -126,7 +145,7 @@
     " \"nbformat_minor\": 5\n",
     "}\n"
    ],
-   "id": "db19dc60a813fdd7"
+   "id": "288aaea8fbc33b6e"
   }
  ],
  "metadata": {
diff --git a/thermohl-docs/docs/getting-started.md b/thermohl-docs/docs/getting-started.md
index c541292..949d016 100644
--- a/thermohl-docs/docs/getting-started.md
+++ b/thermohl-docs/docs/getting-started.md
@@ -82,7 +82,7 @@ surface temperature (°C) of a conductor in steady-state regime along with the c
 from thermohl import solver
 from thermohl.solver.enums.heat_equation_type import HeatEquationType
 
-slvr = solver.ieee(dic=None, heat_equation=HeatEquationType.HEAT_EQUATION_ONE_TEMPERATURE)
+slvr = solver.ieee(dic=None, heat_equation=HeatEquationType.WITH_ONE_TEMPERATURE)
 temp = slvr.steady_temperature() 
 ```
 
@@ -106,7 +106,7 @@ import numpy as np
 from thermohl import solver
 from thermohl.solver.enums.heat_equation_type import HeatEquationType
 
-slvr = solver.ieee(dict(Ta=np.array([0., 15., 30.])), heat_equation=HeatEquationType.HEAT_EQUATION_ONE_TEMPERATURE)
+slvr = solver.ieee(dict(Ta=np.array([0., 15., 30.])), heat_equation=HeatEquationType.WITH_ONE_TEMPERATURE)
 Tmax = 80.
 imax = slvr.steady_intensity(Tmax)
 ```

From 8493175ddb8230b42b9a455c26b453d183a0a0f1 Mon Sep 17 00:00:00 2001
From: Olivier Pigeon <olivier.pigeon@rte-france.com>
Date: Fri, 23 Jan 2026 13:53:36 +0100
Subject: [PATCH 6/6] feat(#2): Make the branch uv compliant

Signed-off-by: Olivier Pigeon <olivier.pigeon@rte-france.com>
---
 examples/example_solver_intensity.py          |  5 +-
 examples/example_transient.py                 | 11 +++-
 examples/example_transient2.py                |  9 ++-
 src/thermohl/solver/__init__.py               | 62 ++++++++++++-------
 src/thermohl/solver/enums/cable_location.py   |  1 +
 .../solver/enums/heat_equation_type.py        |  9 ++-
 src/thermohl/solver/enums/power_type.py       |  3 +-
 src/thermohl/solver/enums/solver_type.py      |  9 +--
 .../solver/enums/temperature_location.py      |  3 +-
 src/thermohl/solver/enums/variable_type.py    |  3 -
 src/thermohl/solver/slv1t.py                  |  2 +-
 src/thermohl/solver/slv3t.py                  |  8 ++-
 src/thermohl/solver/slv3t_legacy.py           |  3 +-
 src/thermohl/uncertainties.py                 |  6 +-
 test/functional_test/functional_test.py       | 31 +++++++---
 test/test_shape.py                            | 12 +++-
 test/test_solver1t.py                         | 19 ++++--
 test/test_solver3t.py                         | 52 ++++++++++++----
 18 files changed, 175 insertions(+), 73 deletions(-)

diff --git a/examples/example_solver_intensity.py b/examples/example_solver_intensity.py
index fe20741..b86a717 100644
--- a/examples/example_solver_intensity.py
+++ b/examples/example_solver_intensity.py
@@ -85,7 +85,10 @@ def test_solve(dct, Trep, tol=1.0e-06, mxi=64):
         slv = d["model"]
         df = slv.steady_intensity(Trep, tol=tol, maxiter=mxi, return_power=True)
         df["pb"] = (
-                df[PowerType.JOULE] + df[PowerType.SOLAR] - df[PowerType.CONVECTION] - df[PowerType.RADIATION]
+            df[PowerType.JOULE]
+            + df[PowerType.SOLAR]
+            - df[PowerType.CONVECTION]
+            - df[PowerType.RADIATION]
         )
         slv.dc[VariableType.TRANSIT] = df["I_max"].values
         df["TIrep"] = slv.steady_temperature(return_power=False)["T_surf"]
diff --git a/examples/example_transient.py b/examples/example_transient.py
index 6bed3b0..a37a645 100644
--- a/examples/example_transient.py
+++ b/examples/example_transient.py
@@ -55,7 +55,12 @@
     plt.show()
 
     # dict with all 4 solvers
-    kys = [SolverType.SOLVER_CIGRE, SolverType.SOLVER_IEEE, SolverType.SOLVER_RTE, SolverType.SOLVER_OLLA]
+    kys = [
+        SolverType.SOLVER_CIGRE,
+        SolverType.SOLVER_IEEE,
+        SolverType.SOLVER_RTE,
+        SolverType.SOLVER_OLLA,
+    ]
     slv = dict(
         cigre=solver.cigre(dct),
         ieee=solver.ieee(dct),
@@ -66,7 +71,7 @@
     plt.figure()
     for i, key in enumerate(slv):
         elm = slv[key]
-        elm.dc[VariableType.TRANSIT] = I
+        elm.dc[VariableType.TRANSIT] = transit
         df = elm.steady_temperature()
         elm.dc[VariableType.TRANSIT] = np.nan
         cl = "C%d" % (i % 10,)
@@ -84,7 +89,7 @@
     # only rte but with core temp
     plt.figure()
     elm = slv["rte"]
-    elm.dc[VariableType.TRANSIT] = I
+    elm.dc[VariableType.TRANSIT] = transit
     df = elm.steady_temperature(return_avg=True, return_core=True)
     elm.dc[VariableType.TRANSIT] = np.nan
     cl = "C0"
diff --git a/examples/example_transient2.py b/examples/example_transient2.py
index 9c10947..f6d171a 100644
--- a/examples/example_transient2.py
+++ b/examples/example_transient2.py
@@ -56,7 +56,12 @@
     plt.show()
 
     # dict with all 4 solvers
-    kys = [SolverType.SOLVER_CIGRE, SolverType.SOLVER_IEEE, SolverType.SOLVER_RTE, SolverType.SOLVER_OLLA]
+    kys = [
+        SolverType.SOLVER_CIGRE,
+        SolverType.SOLVER_IEEE,
+        SolverType.SOLVER_RTE,
+        SolverType.SOLVER_OLLA,
+    ]
     slv = dict(
         cigre=solver.cigre(dct),
         ieee=solver.ieee(dct),
@@ -67,7 +72,7 @@
     plt.figure()
     for i, key in enumerate(slv):
         elm = slv[key]
-        elm.dc[VariableType.TRANSIT] = I[:, 1]
+        elm.dc[VariableType.TRANSIT] = transit[:, 1]
         elm.dc["Ta"] = elm.dc["Ta"][1]
         df = elm.steady_temperature()
         elm.dc[VariableType.TRANSIT] = np.nan
diff --git a/src/thermohl/solver/__init__.py b/src/thermohl/solver/__init__.py
index 5006b85..217e96c 100644
--- a/src/thermohl/solver/__init__.py
+++ b/src/thermohl/solver/__init__.py
@@ -36,7 +36,6 @@ def _factory(
     heat_equation: HeatEquationType = HeatEquationType.WITH_ONE_TEMPERATURE,
     model: SolverType = SolverType.SOLVER_IEEE,
 ) -> Solver:
-
     solver = create_solver_from_heat_equation(heat_equation)
 
     solver_modules = {
@@ -59,13 +58,14 @@ def _factory(
     )
 
 
-
-def create_solver_from_heat_equation(heat_equation: HeatEquationType) -> concreteSolverType:
+def create_solver_from_heat_equation(
+    heat_equation: HeatEquationType,
+) -> concreteSolverType:
     heat_equations_solvers = {
         HeatEquationType.WITH_ONE_TEMPERATURE: Solver1T,
         HeatEquationType.WITH_THREE_TEMPERATURES: Solver3T,
         HeatEquationType.WITH_THREE_TEMPERATURES_LEGACY: Solver3TL,
-        HeatEquationType.WITH_1D: Solver1D
+        HeatEquationType.WITH_1D: Solver1D,
     }
 
     if heat_equation not in heat_equations_solvers:
@@ -74,25 +74,26 @@ def create_solver_from_heat_equation(heat_equation: HeatEquationType) -> concret
     return heat_equations_solvers[heat_equation]
 
 
-def __solver_model(dic: Optional[Dict[str, Any]] = None,
-                   heat_equation: HeatEquationType = HeatEquationType.WITH_ONE_TEMPERATURE,
-                   model: SolverType = SolverType.SOLVER_CIGRE,
-                   )\
-        -> Solver:
+def __solver_model(
+    dic: Optional[Dict[str, Any]] = None,
+    heat_equation: HeatEquationType = HeatEquationType.WITH_ONE_TEMPERATURE,
+    model: SolverType = SolverType.SOLVER_CIGRE,
+) -> Solver:
     """Get a Solver using a given model and heat equation.
 
-       Args:
-           dic (dict | None): Input values. The default is None.
-           heat_equation (HeatEquationType): Input heat equation.
-           model (SolverType): Solver model to use.
+    Args:
+        dic (dict | None): Input values. The default is None.
+        heat_equation (HeatEquationType): Input heat equation.
+        model (SolverType): Solver model to use.
 
-       """
+    """
     return _factory(dic, heat_equation=heat_equation, model=model)
 
 
-def cigre(dic: Optional[Dict[str, Any]] = None,
-          heat_equation: HeatEquationType = HeatEquationType.WITH_ONE_TEMPERATURE)\
-        -> Solver:
+def cigre(
+    dic: Optional[Dict[str, Any]] = None,
+    heat_equation: HeatEquationType = HeatEquationType.WITH_ONE_TEMPERATURE,
+) -> Solver:
     """Get a Solver using CIGRE models.
 
     Args:
@@ -100,10 +101,15 @@ def cigre(dic: Optional[Dict[str, Any]] = None,
         heat_equation (HeatEquationType): Input heat equation.
 
     """
-    return __solver_model(dic=dic, heat_equation=heat_equation, model=SolverType.SOLVER_CIGRE)
+    return __solver_model(
+        dic=dic, heat_equation=heat_equation, model=SolverType.SOLVER_CIGRE
+    )
 
 
-def ieee(dic: Optional[Dict[str, Any]] = None, heat_equation: HeatEquationType = HeatEquationType.WITH_ONE_TEMPERATURE) -> Solver:
+def ieee(
+    dic: Optional[Dict[str, Any]] = None,
+    heat_equation: HeatEquationType = HeatEquationType.WITH_ONE_TEMPERATURE,
+) -> Solver:
     """Get a Solver using IEEE models.
 
     Args:
@@ -111,10 +117,15 @@ def ieee(dic: Optional[Dict[str, Any]] = None, heat_equation: HeatEquationType =
         heat_equation (HeatEquationType): Input heat equation.
 
     """
-    return __solver_model(dic, heat_equation=heat_equation, model=SolverType.SOLVER_IEEE)
+    return __solver_model(
+        dic, heat_equation=heat_equation, model=SolverType.SOLVER_IEEE
+    )
 
 
-def olla(dic: Optional[Dict[str, Any]] = None, heat_equation: HeatEquationType = HeatEquationType.WITH_ONE_TEMPERATURE) -> Solver:
+def olla(
+    dic: Optional[Dict[str, Any]] = None,
+    heat_equation: HeatEquationType = HeatEquationType.WITH_ONE_TEMPERATURE,
+) -> Solver:
     """Get a Solver using RTE-olla models.
 
     Args:
@@ -122,10 +133,15 @@ def olla(dic: Optional[Dict[str, Any]] = None, heat_equation: HeatEquationType =
         heat_equation (HeatEquationType): Input heat equation.
 
     """
-    return __solver_model(dic, heat_equation=heat_equation, model=SolverType.SOLVER_OLLA)
+    return __solver_model(
+        dic, heat_equation=heat_equation, model=SolverType.SOLVER_OLLA
+    )
 
 
-def rte(dic: Optional[Dict[str, Any]] = None, heat_equation: HeatEquationType = HeatEquationType.WITH_ONE_TEMPERATURE) -> Solver:
+def rte(
+    dic: Optional[Dict[str, Any]] = None,
+    heat_equation: HeatEquationType = HeatEquationType.WITH_ONE_TEMPERATURE,
+) -> Solver:
     """Get a Solver using RTE models.
 
     Args:
diff --git a/src/thermohl/solver/enums/cable_location.py b/src/thermohl/solver/enums/cable_location.py
index 1af8743..b645c82 100644
--- a/src/thermohl/solver/enums/cable_location.py
+++ b/src/thermohl/solver/enums/cable_location.py
@@ -14,4 +14,5 @@ class CableLocation(Enum):
     AVERAGE = "avg"
     CORE = "core"
 
+
 CableLocationListLike = Union[CableLocation, List[CableLocation]]
diff --git a/src/thermohl/solver/enums/heat_equation_type.py b/src/thermohl/solver/enums/heat_equation_type.py
index 62cfe3d..614c6b3 100644
--- a/src/thermohl/solver/enums/heat_equation_type.py
+++ b/src/thermohl/solver/enums/heat_equation_type.py
@@ -7,10 +7,9 @@
 
 from enum import Enum
 
-class HeatEquationType(Enum):
 
-    WITH_ONE_TEMPERATURE = "1t",
-    WITH_THREE_TEMPERATURES = "3t",
-    WITH_THREE_TEMPERATURES_LEGACY = "3tl",
+class HeatEquationType(Enum):
+    WITH_ONE_TEMPERATURE = ("1t",)
+    WITH_THREE_TEMPERATURES = ("3t",)
+    WITH_THREE_TEMPERATURES_LEGACY = ("3tl",)
     WITH_1D = "1d"
-
diff --git a/src/thermohl/solver/enums/power_type.py b/src/thermohl/solver/enums/power_type.py
index b3d60c6..735de34 100644
--- a/src/thermohl/solver/enums/power_type.py
+++ b/src/thermohl/solver/enums/power_type.py
@@ -7,9 +7,10 @@
 
 from enum import Enum
 
+
 class PowerType(Enum):
     JOULE = "P_joule"
     SOLAR = "P_solar"
     CONVECTION = "P_convection"
     RADIATION = "P_radiation"
-    RAIN = "P_precipitation"
\ No newline at end of file
+    RAIN = "P_precipitation"
diff --git a/src/thermohl/solver/enums/solver_type.py b/src/thermohl/solver/enums/solver_type.py
index 9179b0b..cdd11cf 100644
--- a/src/thermohl/solver/enums/solver_type.py
+++ b/src/thermohl/solver/enums/solver_type.py
@@ -7,8 +7,9 @@
 
 from enum import Enum
 
+
 class SolverType(Enum):
-    SOLVER_CIGRE = "cigre",
-    SOLVER_IEEE = "ieee",
-    SOLVER_OLLA = "olla",
-    SOLVER_RTE = "rte"
\ No newline at end of file
+    SOLVER_CIGRE = ("cigre",)
+    SOLVER_IEEE = ("ieee",)
+    SOLVER_OLLA = ("olla",)
+    SOLVER_RTE = "rte"
diff --git a/src/thermohl/solver/enums/temperature_location.py b/src/thermohl/solver/enums/temperature_location.py
index c7c820b..ed14b0c 100644
--- a/src/thermohl/solver/enums/temperature_location.py
+++ b/src/thermohl/solver/enums/temperature_location.py
@@ -7,7 +7,8 @@
 
 from enum import Enum
 
+
 class TemperatureLocation(Enum):
     SURFACE = "t_surf"
     AVERAGE = "t_avg"
-    CORE = "t_core"
\ No newline at end of file
+    CORE = "t_core"
diff --git a/src/thermohl/solver/enums/variable_type.py b/src/thermohl/solver/enums/variable_type.py
index 4146c83..503349f 100644
--- a/src/thermohl/solver/enums/variable_type.py
+++ b/src/thermohl/solver/enums/variable_type.py
@@ -7,7 +7,6 @@
 
 
 from enum import Enum
-from typing import Union, List
 
 
 class VariableType(Enum):
@@ -15,5 +14,3 @@ class VariableType(Enum):
     TIME = "time"
     TRANSIT = "transit"
     TEMPERATURE = "t"
-
-
diff --git a/src/thermohl/solver/slv1t.py b/src/thermohl/solver/slv1t.py
index 4a44219..f9b1bb3 100644
--- a/src/thermohl/solver/slv1t.py
+++ b/src/thermohl/solver/slv1t.py
@@ -137,7 +137,7 @@ def transient_temperature(
             )
 
         # save results
-        dr = {VariableType.TIME:time, VariableType.TEMPERATURE:T}
+        dr = {VariableType.TIME: time, VariableType.TEMPERATURE: T}
 
         # manage return dict 2: powers
         if return_power:
diff --git a/src/thermohl/solver/slv3t.py b/src/thermohl/solver/slv3t.py
index 13eeab8..04f3c54 100644
--- a/src/thermohl/solver/slv3t.py
+++ b/src/thermohl/solver/slv3t.py
@@ -10,7 +10,7 @@
 import numpy as np
 import pandas as pd
 
-from thermohl import floatArrayLike, floatArray, strListLike, intArray
+from thermohl import floatArrayLike, floatArray, intArray
 from thermohl.power import PowerTerm
 from thermohl.solver.base import Solver as Solver_, _DEFPARAM as DP, _set_dates, reshape
 from thermohl.solver.enums.cable_location import CableLocation, CableLocationListLike
@@ -234,7 +234,11 @@ def steady_temperature(
         # format output
         z = self.average(x, y)
         df = pd.DataFrame(
-            {TemperatureLocation.SURFACE: x, TemperatureLocation.AVERAGE: z, TemperatureLocation.CORE: y}
+            {
+                TemperatureLocation.SURFACE: x,
+                TemperatureLocation.AVERAGE: z,
+                TemperatureLocation.CORE: y,
+            }
         )
 
         if return_err:
diff --git a/src/thermohl/solver/slv3t_legacy.py b/src/thermohl/solver/slv3t_legacy.py
index 3cb7027..902c0ef 100644
--- a/src/thermohl/solver/slv3t_legacy.py
+++ b/src/thermohl/solver/slv3t_legacy.py
@@ -9,14 +9,13 @@
 
 import numpy as np
 
-from thermohl import floatArrayLike, floatArray, strListLike, intArray
+from thermohl import floatArrayLike, floatArray, intArray
 from thermohl.power import PowerTerm
 from thermohl.solver.enums.cable_location import CableLocation, CableLocationListLike
 from thermohl.solver.slv3t import Solver3T
 
 
 class Solver3TL(Solver3T):
-
     def __init__(
         self,
         dic: Optional[dict[str, Any]] = None,
diff --git a/src/thermohl/uncertainties.py b/src/thermohl/uncertainties.py
index 7828260..f5a5ae6 100644
--- a/src/thermohl/uncertainties.py
+++ b/src/thermohl/uncertainties.py
@@ -153,7 +153,11 @@ def _generate_samples(
 
 
 def _rdict(
-    mode: str, target: CableLocation, return_surf: bool, return_core: bool, return_avg: bool
+    mode: str,
+    target: CableLocation,
+    return_surf: bool,
+    return_core: bool,
+    return_avg: bool,
 ) -> dict:
     """Code factorization"""
     if mode == "temperature":
diff --git a/test/functional_test/functional_test.py b/test/functional_test/functional_test.py
index e38f122..b1a0d40 100644
--- a/test/functional_test/functional_test.py
+++ b/test/functional_test/functional_test.py
@@ -68,7 +68,10 @@ def scn2dict(d: dict) -> dict:
 def test_steady_temperature():
     for d in scenario("temperature", "steady"):
         for _, e in d.items():
-            s = rte(scn2dict(e), heat_equation=HeatEquationType.WITH_THREE_TEMPERATURES_LEGACY)
+            s = rte(
+                scn2dict(e),
+                heat_equation=HeatEquationType.WITH_THREE_TEMPERATURES_LEGACY,
+            )
             r = s.steady_temperature()
 
             assert np.allclose(r[TemperatureLocation.SURFACE], e["T_surf"], atol=0.05)
@@ -79,7 +82,10 @@ def test_steady_temperature():
 def test_steady_ampacity():
     for d in scenario("ampacity", "steady"):
         for _, e in d.items():
-            s = rte(scn2dict(e), heat_equation=HeatEquationType.WITH_THREE_TEMPERATURES_LEGACY)
+            s = rte(
+                scn2dict(e),
+                heat_equation=HeatEquationType.WITH_THREE_TEMPERATURES_LEGACY,
+            )
             r = s.steady_intensity(T=e["Tmax_cable"])
 
             assert np.allclose(r[VariableType.TRANSIT], e["I_max"], atol=0.05)
@@ -95,9 +101,11 @@ def test_transient_temperature():
 
     for d in scenario("temperature", "transient"):
         for _, e in d.items():
-
             # solver
-            s = rte(scn2dict(e), heat_equation=HeatEquationType.WITH_THREE_TEMPERATURES_LEGACY)
+            s = rte(
+                scn2dict(e),
+                heat_equation=HeatEquationType.WITH_THREE_TEMPERATURES_LEGACY,
+            )
 
             # initial steady state
             s.args[VariableType.TRANSIT.value] = e["I0_cable"]
@@ -114,16 +122,25 @@ def test_transient_temperature():
 
             # transient temperature (linearized)
             rl = s.transient_temperature_legacy(
-                time=time, Ts0=ri[TemperatureLocation.SURFACE], Tc0=ri[TemperatureLocation.CORE], tau=tau
+                time=time,
+                Ts0=ri[TemperatureLocation.SURFACE],
+                Tc0=ri[TemperatureLocation.CORE],
+                tau=tau,
             )
 
             # check final temp
-            assert np.isclose(e["T_mean_final"], rf[TemperatureLocation.AVERAGE][0], atol=atol)
+            assert np.isclose(
+                e["T_mean_final"], rf[TemperatureLocation.AVERAGE][0], atol=atol
+            )
 
             # check transient temp
             for k1, k2 in zip(
                 ["T_surf_transient", "T_mean_transient", "T_heart_transient"],
-                [TemperatureLocation.SURFACE, TemperatureLocation.AVERAGE, TemperatureLocation.CORE],
+                [
+                    TemperatureLocation.SURFACE,
+                    TemperatureLocation.AVERAGE,
+                    TemperatureLocation.CORE,
+                ],
             ):
                 expected_time = np.array(list(e[k1].keys())) * minute
                 expected_temp = np.array(list(e[k1].values()))
diff --git a/test/test_shape.py b/test/test_shape.py
index b8c77b0..9a6fef0 100644
--- a/test/test_shape.py
+++ b/test/test_shape.py
@@ -17,8 +17,16 @@
 
 def _solvers():
     li = []
-    for heat_equation in [HeatEquationType.WITH_ONE_TEMPERATURE, HeatEquationType.WITH_THREE_TEMPERATURES]:
-        for m in [SolverType.SOLVER_RTE, SolverType.SOLVER_CIGRE, SolverType.SOLVER_IEEE, SolverType.SOLVER_OLLA]:
+    for heat_equation in [
+        HeatEquationType.WITH_ONE_TEMPERATURE,
+        HeatEquationType.WITH_THREE_TEMPERATURES,
+    ]:
+        for m in [
+            SolverType.SOLVER_RTE,
+            SolverType.SOLVER_CIGRE,
+            SolverType.SOLVER_IEEE,
+            SolverType.SOLVER_OLLA,
+        ]:
             li.append(solver._factory(dic=None, heat_equation=heat_equation, model=m))
     return li
 
diff --git a/test/test_solver1t.py b/test/test_solver1t.py
index 044e7c1..bdb1b83 100644
--- a/test/test_solver1t.py
+++ b/test/test_solver1t.py
@@ -18,8 +18,15 @@
 
 def _solvers(dic=None):
     return [
-        solver._factory(dic=dic, heat_equation=HeatEquationType.WITH_ONE_TEMPERATURE, model=m)
-        for m in [SolverType.SOLVER_RTE, SolverType.SOLVER_CIGRE, SolverType.SOLVER_IEEE, SolverType.SOLVER_OLLA]
+        solver._factory(
+            dic=dic, heat_equation=HeatEquationType.WITH_ONE_TEMPERATURE, model=m
+        )
+        for m in [
+            SolverType.SOLVER_RTE,
+            SolverType.SOLVER_CIGRE,
+            SolverType.SOLVER_IEEE,
+            SolverType.SOLVER_OLLA,
+        ]
     ]
 
 
@@ -54,8 +61,12 @@ def test_balance():
             - df[PowerType.RAIN]
         )
         atol = np.maximum(
-            np.abs(s.balance(df[VariableType.TEMPERATURE] + 0.5 * df[VariableType.ERROR])),
-            np.abs(s.balance(df[VariableType.TEMPERATURE] - 0.5 * df[VariableType.ERROR])),
+            np.abs(
+                s.balance(df[VariableType.TEMPERATURE] + 0.5 * df[VariableType.ERROR])
+            ),
+            np.abs(
+                s.balance(df[VariableType.TEMPERATURE] - 0.5 * df[VariableType.ERROR])
+            ),
         )
         assert np.allclose(bl, 0.0, atol=atol)
 
diff --git a/test/test_solver3t.py b/test/test_solver3t.py
index 498cdab..1776432 100644
--- a/test/test_solver3t.py
+++ b/test/test_solver3t.py
@@ -20,8 +20,16 @@
 def _solvers(dic=None):
     return [
         solver._factory(dic=dic, heat_equation=heat_equation, model=m)
-        for heat_equation in [HeatEquationType.WITH_THREE_TEMPERATURES, HeatEquationType.WITH_THREE_TEMPERATURES_LEGACY]
-        for m in [SolverType.SOLVER_RTE, SolverType.SOLVER_CIGRE, SolverType.SOLVER_IEEE, SolverType.SOLVER_OLLA]
+        for heat_equation in [
+            HeatEquationType.WITH_THREE_TEMPERATURES,
+            HeatEquationType.WITH_THREE_TEMPERATURES_LEGACY,
+        ]
+        for m in [
+            SolverType.SOLVER_RTE,
+            SolverType.SOLVER_CIGRE,
+            SolverType.SOLVER_IEEE,
+            SolverType.SOLVER_OLLA,
+        ]
     ]
 
 
@@ -47,7 +55,11 @@ def test_balance():
 
     for s in _solvers(dic):
         # compute guess with 1t solver
-        s1 = solver._factory(dic=dic, heat_equation=HeatEquationType.WITH_ONE_TEMPERATURE, model=SolverType.SOLVER_IEEE)
+        s1 = solver._factory(
+            dic=dic,
+            heat_equation=HeatEquationType.WITH_ONE_TEMPERATURE,
+            model=SolverType.SOLVER_IEEE,
+        )
         t1 = s1.steady_temperature(
             tol=2.0, maxiter=16, return_err=False, return_power=False
         )
@@ -59,10 +71,18 @@ def test_balance():
         # checks
         assert np.all(df[VariableType.ERROR] < tol)
         assert np.allclose(
-            s.balance(ts=df[TemperatureLocation.SURFACE], tc=df[TemperatureLocation.CORE]).values, 0.0, atol=tol
+            s.balance(
+                ts=df[TemperatureLocation.SURFACE], tc=df[TemperatureLocation.CORE]
+            ).values,
+            0.0,
+            atol=tol,
         )
         assert np.allclose(
-            s.morgan(ts=df[TemperatureLocation.SURFACE], tc=df[TemperatureLocation.CORE]).values, 0.0, atol=tol
+            s.morgan(
+                ts=df[TemperatureLocation.SURFACE], tc=df[TemperatureLocation.CORE]
+            ).values,
+            0.0,
+            atol=tol,
         )
 
 
@@ -84,11 +104,13 @@ def test_consistency():
     )
 
     for s in _solvers(dic):
-        d = {CableLocation.SURFACE: TemperatureLocation.SURFACE,
-             CableLocation.AVERAGE: TemperatureLocation.AVERAGE,
-             CableLocation.CORE: TemperatureLocation.CORE}
+        d = {
+            CableLocation.SURFACE: TemperatureLocation.SURFACE,
+            CableLocation.AVERAGE: TemperatureLocation.AVERAGE,
+            CableLocation.CORE: TemperatureLocation.CORE,
+        }
 
-        for location,temperature_at_location in d.items():
+        for location, temperature_at_location in d.items():
             # solve intensity with different targets
             df = s.steady_intensity(
                 T=100.0,
@@ -103,10 +125,18 @@ def test_consistency():
             s.args.I = df[VariableType.TRANSIT].values
             s.update()
             assert np.allclose(
-                s.balance(ts=df[TemperatureLocation.SURFACE], tc=df[TemperatureLocation.CORE]).values, 0.0, atol=tol
+                s.balance(
+                    ts=df[TemperatureLocation.SURFACE], tc=df[TemperatureLocation.CORE]
+                ).values,
+                0.0,
+                atol=tol,
             )
             assert np.allclose(
-                s.morgan(ts=df[TemperatureLocation.SURFACE], tc=df[TemperatureLocation.CORE]).values, 0.0, atol=tol
+                s.morgan(
+                    ts=df[TemperatureLocation.SURFACE], tc=df[TemperatureLocation.CORE]
+                ).values,
+                0.0,
+                atol=tol,
             )
             # 3t solve
             dg = s.steady_temperature(