diff --git a/mira/metamodel/template_model.py b/mira/metamodel/template_model.py
index 91aeccf9..40ff4f3f 100644
--- a/mira/metamodel/template_model.py
+++ b/mira/metamodel/template_model.py
@@ -12,7 +12,7 @@
 
 import datetime
 import sys
-from typing import List, Dict, Set, Optional, Mapping, Tuple, Any
+from typing import List, Dict, Set, Optional, Mapping, Tuple, Any, Union
 
 import networkx as nx
 import sympy
@@ -603,6 +603,14 @@ def generate_model_graph(self, use_display_name: bool = False) -> nx.DiGraph:
 
         return graph
 
+    def set_rate_law(self, template_name: str,
+                     rate_law: Union[str, sympy.Expr, SympyExprStr],
+                     local_dict=None):
+        """Set the rate law of a template with a given name."""
+        for template in self.templates:
+            if template.name == template_name:
+                template.set_rate_law(rate_law, local_dict=local_dict)
+
     def draw_graph(
         self,
         path: str,
diff --git a/mira/metamodel/templates.py b/mira/metamodel/templates.py
index 4c987805..3d14c740 100644
--- a/mira/metamodel/templates.py
+++ b/mira/metamodel/templates.py
@@ -739,6 +739,30 @@ def with_mass_action_rate_law(self, parameter, independent=False) -> "Template":
         template.set_mass_action_rate_law(parameter, independent=independent)
         return template
 
+    def set_rate_law(self, rate_law: Union[str, sympy.Expr, SympyExprStr],
+                     local_dict=None):
+        """Set the rate law of this template to the given rate law."""
+        if isinstance(rate_law, SympyExprStr):
+            self.rate_law = rate_law
+        elif isinstance(rate_law, sympy.Expr):
+            self.rate_law = SympyExprStr(rate_law)
+        elif isinstance(rate_law, str):
+            try:
+                rate = SympyExprStr(safe_parse_expr(rate_law,
+                                                    local_dict=local_dict))
+            except Exception as e:
+                logger.warning(f"Could not parse rate law into "
+                               f"symbolic expression: {rate_law}. "
+                               f"Not setting rate law.")
+                return
+            self.rate_law = rate
+
+    def with_rate_law(self, rate_law: Union[str, sympy.Expr, SympyExprStr],
+                      local_dict=None) -> "Template":
+        template = self.copy(deep=True)
+        template.set_rate_law(rate_law, local_dict=local_dict)
+        return template
+
     def get_parameter_names(self) -> Set[str]:
         """Get the set of parameter names.
 
diff --git a/mira/modeling/ode.py b/mira/modeling/ode.py
index 5f632b2e..ce505ca3 100644
--- a/mira/modeling/ode.py
+++ b/mira/modeling/ode.py
@@ -17,6 +17,8 @@ def __init__(self, model: Model, initialized: bool):
         self.y = sympy.MatrixSymbol('y', len(model.variables), 1)
         self.vmap = {variable.key: idx for idx, variable
                      in enumerate(model.variables.values())}
+        self.observable_map = {obs_key: idx for idx, obs_key
+                               in enumerate(model.observables)}
         real_params = {k: v for k, v in model.parameters.items()
                        if not v.placeholder}
         self.p = sympy.MatrixSymbol('p', len(real_params), 1)
@@ -27,9 +29,9 @@ def __init__(self, model: Model, initialized: bool):
         parameter_map = {parameter.concept.name: parameter.key
                          for parameter in real_params.values()}
 
-        '''
-        Following code block is agnostic towards the case if the ODE model was created with parameter and agent
-        values initialized when creating parameters or when calling the simulate_ode method.'''
+        """Following code block is agnostic towards the case if the ODE model
+        was created with parameter and initial values initialized when
+        creating parameters or when calling the simulate_ode method."""
         if initialized:
             self.parameter_values = []
             self.variable_values = []
@@ -73,11 +75,42 @@ def __init__(self, model: Model, initialized: bool):
         self.kinetics = sympy.Matrix(self.kinetics)
         self.kinetics_lmbd = sympy.lambdify([self.y], self.kinetics)
 
+        observables = []
+        for obs_name, model_obs in model.observables.items():
+            expr = deepcopy(model_obs.observable.expression).args[0]
+            for symbol in expr.free_symbols:
+                sym_str = str(symbol)
+                if sym_str in concept_map:
+                    expr = expr.subs(symbol,
+                                     self.y[self.vmap[concept_map[sym_str]]])
+                elif sym_str in self.pmap:
+                    expr = expr.subs(symbol,
+                                     self.p[self.pmap[parameter_map[sym_str]]])
+                elif model.template_model.time and \
+                        sym_str == model.template_model.time.name:
+                    expr = expr.subs(symbol, 't')
+                else:
+                    assert False, sym_str
+            observables.append(expr)
+        self.observables = sympy.Matrix(observables)
+        self.observables_lmbd = sympy.lambdify([self.y], self.observables)
+
+    def get_interpretable_kinetics(self):
+        # Return kinetics but with y and p substituted
+        # based on vmap and pmap
+        subs = {self.y[v]: sympy.Symbol(k) for k, v in self.vmap.items()}
+        subs.update({self.p[p]: sympy.Symbol(k) for k, p in self.pmap.items()})
+        return sympy.Matrix([
+            k.subs(subs) for k in self.kinetics
+        ])
+
     def set_parameters(self, params):
         """Set the parameters of the model."""
         for p, v in params.items():
             self.kinetics = self.kinetics.subs(self.p[self.pmap[p]], v)
+            self.observables = self.observables.subs(self.p[self.pmap[p]], v)
         self.kinetics_lmbd = sympy.lambdify([self.y], self.kinetics)
+        self.observables_lmbd = sympy.lambdify([self.y], self.observables)
 
     def get_rhs(self):
         """Return the right-hand side of the ODE system."""
@@ -96,7 +129,7 @@ def rhs(t, y):
 # ode_model: OdeModel, times, initials=None,
 #                        parameters=None
 def simulate_ode_model(ode_model: OdeModel, times, initials=None,
-                       parameters=None):
+                       parameters=None, with_observables=False):
     """Simulate an ODE model given initial conditions, parameters and a
     time span.
 
@@ -112,6 +145,9 @@ def simulate_ode_model(ode_model: OdeModel, times, initials=None,
     times:
         A one-dimensional array of time values, typically from
         a linear space like ``numpy.linspace(0, 25, 100)``
+    with_observables:
+        A boolean indicating whether to return the observables
+        as well as the variables.
 
     Returns
     -------
@@ -130,14 +166,27 @@ def simulate_ode_model(ode_model: OdeModel, times, initials=None,
 
         initials = ode_model.variable_values
         for index, expression in enumerate(initials):
-            initials[index] = float(expression.subs(parameters).args[0])
+            # Only substitute if this is an expression. Once the model has been
+            # simulated, this is actually a float.
+            if isinstance(expression, sympy.Expr):
+                initials[index] = float(expression.subs(parameters).args[0])
 
     ode_model.set_parameters(parameters)
     solver = scipy.integrate.ode(f=rhs)
 
     solver.set_initial_value(initials)
-    res = numpy.zeros((len(times), ode_model.y.shape[0]))
-    res[0, :] = initials
+    num_vars = ode_model.y.shape[0]
+    num_obs = len(ode_model.observable_map)
+    num_cols = num_vars + (num_obs if with_observables else 0)
+    res = numpy.zeros((len(times), num_cols))
+    res[0, :num_vars] = initials
     for idx, time in enumerate(times[1:]):
-        res[idx + 1, :] = solver.integrate(time)
+        res[idx + 1, :num_vars] = solver.integrate(time)
+
+    if with_observables:
+            for tidx, t in enumerate(times):
+                obs_res = \
+                    ode_model.observables_lmbd(res[tidx, :num_vars][:, None])
+                for idx, val in enumerate(obs_res):
+                    res[tidx, num_vars + idx] = obs_res[idx]
     return res
diff --git a/notebooks/evaluation_2024.03/climate_scenario4/climate_scenario5_petri.json b/notebooks/evaluation_2024.03/climate_scenario4/climate_scenario5_petri.json
new file mode 100644
index 00000000..a1183d74
--- /dev/null
+++ b/notebooks/evaluation_2024.03/climate_scenario4/climate_scenario5_petri.json
@@ -0,0 +1,344 @@
+{
+ "header": {
+  "name": "Model",
+  "schema": "https://raw.githubusercontent.com/DARPA-ASKEM/Model-Representations/petrinet_v0.6/petrinet/petrinet_schema.json",
+  "schema_name": "petrinet",
+  "description": "Model",
+  "model_version": "0.1"
+ },
+ "properties": {},
+ "model": {
+  "states": [
+   {
+    "id": "E_PSII",
+    "name": "E_PSII",
+    "grounding": {
+     "identifiers": {},
+     "modifiers": {}
+    }
+   },
+   {
+    "id": "NADPp",
+    "name": "NADPp",
+    "grounding": {
+     "identifiers": {},
+     "modifiers": {}
+    }
+   },
+   {
+    "id": "P_NPQ",
+    "name": "P_NPQ",
+    "grounding": {
+     "identifiers": {},
+     "modifiers": {}
+    }
+   },
+   {
+    "id": "Q",
+    "name": "Q",
+    "grounding": {
+     "identifiers": {},
+     "modifiers": {}
+    }
+   },
+   {
+    "id": "NADPH",
+    "name": "NADPH",
+    "grounding": {
+     "identifiers": {},
+     "modifiers": {}
+    }
+   },
+   {
+    "id": "R",
+    "name": "R",
+    "grounding": {
+     "identifiers": {},
+     "modifiers": {}
+    }
+   }
+  ],
+  "transitions": [
+   {
+    "id": "t1",
+    "input": [],
+    "output": [
+     "E_PSII"
+    ],
+    "properties": {
+     "name": "t1"
+    }
+   },
+   {
+    "id": "t2",
+    "input": [
+     "NADPp",
+     "E_PSII"
+    ],
+    "output": [
+     "NADPp"
+    ],
+    "properties": {
+     "name": "t2"
+    }
+   },
+   {
+    "id": "t3",
+    "input": [
+     "P_NPQ",
+     "Q",
+     "E_PSII"
+    ],
+    "output": [
+     "P_NPQ",
+     "Q"
+    ],
+    "properties": {
+     "name": "t3"
+    }
+   },
+   {
+    "id": "t4",
+    "input": [
+     "P_NPQ",
+     "E_PSII"
+    ],
+    "output": [
+     "P_NPQ",
+     "E_PSII",
+     "Q"
+    ],
+    "properties": {
+     "name": "t4"
+    }
+   },
+   {
+    "id": "t5",
+    "input": [
+     "Q"
+    ],
+    "output": [],
+    "properties": {
+     "name": "t5"
+    }
+   },
+   {
+    "id": "t6",
+    "input": [],
+    "output": [
+     "P_NPQ"
+    ],
+    "properties": {
+     "name": "t6"
+    }
+   },
+   {
+    "id": "t7",
+    "input": [
+     "NADPp"
+    ],
+    "output": [
+     "NADPH"
+    ],
+    "properties": {
+     "name": "t7"
+    }
+   },
+   {
+    "id": "t8",
+    "input": [
+     "R",
+     "NADPH"
+    ],
+    "output": [
+     "R",
+     "NADPp"
+    ],
+    "properties": {
+     "name": "t8"
+    }
+   },
+   {
+    "id": "t9",
+    "input": [],
+    "output": [
+     "R"
+    ],
+    "properties": {
+     "name": "t9"
+    }
+   }
+  ]
+ },
+ "semantics": {
+  "ode": {
+   "rates": [
+    {
+     "target": "t1",
+     "expression": "PAR*alpha*c_in*(-E_PSII/E_PSII_star + 1)",
+     "expression_mathml": "<apply><times/><ci>PAR</ci><ci>alpha</ci><ci>c_in</ci><apply><minus/><cn>1</cn><apply><divide/><ci>E_PSII</ci><ci>E_PSII_star</ci></apply></apply></apply>"
+    },
+    {
+     "target": "t2",
+     "expression": "E_PSII*NADPp*v_ETR",
+     "expression_mathml": "<apply><times/><ci>E_PSII</ci><ci>NADPp</ci><ci>v_ETR</ci></apply>"
+    },
+    {
+     "target": "t3",
+     "expression": "E_PSII*P_NPQ*v_d*(-Q/Q_star + 1)",
+     "expression_mathml": "<apply><times/><ci>E_PSII</ci><ci>P_NPQ</ci><ci>v_d</ci><apply><minus/><cn>1</cn><apply><divide/><ci>Q</ci><ci>Q_star</ci></apply></apply></apply>"
+    },
+    {
+     "target": "t4",
+     "expression": "E_PSII*P_NPQ*v_d*(-Q/Q_star + 1)",
+     "expression_mathml": "<apply><times/><ci>E_PSII</ci><ci>P_NPQ</ci><ci>v_d</ci><apply><minus/><cn>1</cn><apply><divide/><ci>Q</ci><ci>Q_star</ci></apply></apply></apply>"
+    },
+    {
+     "target": "t5",
+     "expression": "Q*v_NPQ",
+     "expression_mathml": "<apply><times/><ci>Q</ci><ci>v_NPQ</ci></apply>"
+    },
+    {
+     "target": "t6",
+     "expression": "Piecewise((v_p*(1 - P_NPQ), c_y < -E_PSII*NADPp*v_ETR + PAR*alpha*c_in*(-E_PSII/E_PSII_star + 1)), (0, True))",
+     "expression_mathml": "<piecewise><piece><apply><times/><ci>v_p</ci><apply><minus/><cn>1</cn><ci>P_NPQ</ci></apply></apply><apply><lt/><ci>c_y</ci><apply><plus/><apply><minus/><apply><times/><ci>E_PSII</ci><ci>NADPp</ci><ci>v_ETR</ci></apply></apply><apply><times/><ci>PAR</ci><ci>alpha</ci><ci>c_in</ci><apply><minus/><cn>1</cn><apply><divide/><ci>E_PSII</ci><ci>E_PSII_star</ci></apply></apply></apply></apply></apply></piece><otherwise><cn>0</cn></otherwise></piecewise>"
+    },
+    {
+     "target": "t7",
+     "expression": "E_PSII*NADPp*eta_NADPp*v_ETR",
+     "expression_mathml": "<apply><times/><ci>E_PSII</ci><ci>NADPp</ci><ci>eta_NADPp</ci><ci>v_ETR</ci></apply>"
+    },
+    {
+     "target": "t8",
+     "expression": "NADPH*R*eta_NADPH*v_C",
+     "expression_mathml": "<apply><times/><ci>NADPH</ci><ci>R</ci><ci>eta_NADPH</ci><ci>v_C</ci></apply>"
+    },
+    {
+     "target": "t9",
+     "expression": "v_R*(1 - R)*Min(d, NADPH/NADPp)",
+     "expression_mathml": "<apply><times/><ci>v_R</ci><apply><minus/><cn>1</cn><ci>R</ci></apply><apply><min/><ci>d</ci><apply><divide/><ci>NADPH</ci><ci>NADPp</ci></apply></apply></apply>"
+    }
+   ],
+   "initials": [
+    {
+     "target": "E_PSII",
+     "expression": "0.0",
+     "expression_mathml": "<cn>0.0</cn>"
+    },
+    {
+     "target": "NADPp",
+     "expression": "5.0",
+     "expression_mathml": "<cn>5.0</cn>"
+    },
+    {
+     "target": "P_NPQ",
+     "expression": "0.0",
+     "expression_mathml": "<cn>0.0</cn>"
+    },
+    {
+     "target": "Q",
+     "expression": "0.0",
+     "expression_mathml": "<cn>0.0</cn>"
+    },
+    {
+     "target": "NADPH",
+     "expression": "5.0",
+     "expression_mathml": "<cn>5.0</cn>"
+    },
+    {
+     "target": "R",
+     "expression": "0.001",
+     "expression_mathml": "<cn>0.001</cn>"
+    }
+   ],
+   "parameters": [
+    {
+     "id": "v_ETR",
+     "value": 0.78
+    },
+    {
+     "id": "v_NPQ",
+     "value": 70.58
+    },
+    {
+     "id": "v_C",
+     "value": 11.75
+    },
+    {
+     "id": "E_PSII_star",
+     "value": 157.56
+    },
+    {
+     "id": "PAR",
+     "value": 520.0
+    },
+    {
+     "id": "alpha",
+     "value": 0.78
+    },
+    {
+     "id": "c_in",
+     "value": 0.23
+    },
+    {
+     "id": "Q_star",
+     "value": 0.07
+    },
+    {
+     "id": "v_d",
+     "value": 0.08
+    },
+    {
+     "id": "c_y",
+     "value": -4.0
+    },
+    {
+     "id": "v_p",
+     "value": 0.07
+    },
+    {
+     "id": "eta_NADPp",
+     "value": 0.89
+    },
+    {
+     "id": "eta_NADPH",
+     "value": 5.07
+    },
+    {
+     "id": "d",
+     "value": 8.4
+    },
+    {
+     "id": "v_R",
+     "value": 0.00089
+    }
+   ],
+   "observables": [
+    {
+     "id": "ETR",
+     "name": "ETR",
+     "expression": "E_PSII*NADPp*v_ETR",
+     "expression_mathml": "<apply><times/><ci>E_PSII</ci><ci>NADPp</ci><ci>v_ETR</ci></apply>"
+    },
+    {
+     "id": "NPQ",
+     "name": "NPQ",
+     "expression": "Q*v_NPQ",
+     "expression_mathml": "<apply><times/><ci>Q</ci><ci>v_NPQ</ci></apply>"
+    },
+    {
+     "id": "A",
+     "name": "A",
+     "expression": "NADPH*R*v_C",
+     "expression_mathml": "<apply><times/><ci>NADPH</ci><ci>R</ci><ci>v_C</ci></apply>"
+    }
+   ],
+   "time": {
+    "id": "t"
+   }
+  }
+ },
+ "metadata": {
+  "annotations": {}
+ }
+}
\ No newline at end of file
diff --git a/notebooks/evaluation_2024.03/climate_scenario4/photosynthesis.ipynb b/notebooks/evaluation_2024.03/climate_scenario4/photosynthesis.ipynb
new file mode 100644
index 00000000..8df674c3
--- /dev/null
+++ b/notebooks/evaluation_2024.03/climate_scenario4/photosynthesis.ipynb
@@ -0,0 +1,337 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "8223e482",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import json\n",
+    "import sympy\n",
+    "import numpy\n",
+    "from mira.metamodel import *\n",
+    "from mira.modeling.amr.petrinet import template_model_to_petrinet_json\n",
+    "from mira.modeling import Model\n",
+    "from mira.modeling.ode import OdeModel, simulate_ode_model"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "e4c5e2dd",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "E_PSII = Concept(name='E_PSII')\n",
+    "Q = Concept(name='Q')\n",
+    "P_NPQ = Concept(name='P_NPQ')\n",
+    "NADPp = Concept(name='NADPp')\n",
+    "NADPH = Concept(name='NADPH')\n",
+    "R = Concept(name='R')\n",
+    "\n",
+    "concepts = [E_PSII, Q, P_NPQ, NADPp, NADPH, R]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "2a4b5195",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "inits = {\n",
+    "    'E_PSII': 0.0,\n",
+    "    'Q': 0.0,\n",
+    "    'P_NPQ': 0.0,\n",
+    "    'NADPp': 5.0,\n",
+    "    'NADPH': 5.0,\n",
+    "    'R': 0.001,\n",
+    "}\n",
+    "\n",
+    "params = {\n",
+    "    'PAR': 520,\n",
+    "    'alpha': 0.78,\n",
+    "    'c_in': 0.23,\n",
+    "    'E_PSII_star': 157.56,\n",
+    "    'v_ETR': 0.78,\n",
+    "    'v_d': 0.08,\n",
+    "    'Q_star': 0.07,\n",
+    "    'v_NPQ': 70.58,\n",
+    "    'v_p': 0.07,\n",
+    "    'v_C': 11.75,\n",
+    "    'eta_NADPH': 5.07,\n",
+    "    'eta_NADPp': 0.89,\n",
+    "    'v_R': 8.9e-4,\n",
+    "    'd': 8.40,\n",
+    "    'c_y': -4\n",
+    "}"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "03bbe6b8",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "symbols = {c.name: sympy.Symbol(c.name) for c in concepts}\n",
+    "symbols.update({k: sympy.Symbol(k) for k in params})"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "eeace5b6",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "energy_input = safe_parse_expr('alpha*c_in*PAR*(1-E_PSII/E_PSII_star)', local_dict=symbols)\n",
+    "ETR = safe_parse_expr('v_ETR*E_PSII*NADPp', local_dict=symbols)\n",
+    "CEF = energy_input - ETR\n",
+    "energy_dissipation = safe_parse_expr('v_d*E_PSII*P_NPQ*(1-Q/Q_star)', local_dict=symbols)\n",
+    "\n",
+    "templates = [\n",
+    "    NaturalProduction(\n",
+    "        outcome=E_PSII,\n",
+    "        rate_law=energy_input),\n",
+    "    ControlledDegradation(\n",
+    "        subject=E_PSII,\n",
+    "        controller=NADPp).with_mass_action_rate_law('v_ETR'),\n",
+    "    GroupedControlledDegradation(\n",
+    "        subject=E_PSII,\n",
+    "        controllers=[P_NPQ, Q],\n",
+    "        rate_law=energy_dissipation),\n",
+    "    GroupedControlledProduction(\n",
+    "        outcome=Q,\n",
+    "        controllers=[P_NPQ, E_PSII],\n",
+    "        rate_law=energy_dissipation),\n",
+    "    NaturalDegradation(\n",
+    "        subject=Q).with_mass_action_rate_law('v_NPQ'),\n",
+    "    NaturalProduction(\n",
+    "        outcome=P_NPQ,\n",
+    "        rate_law=sympy.Piecewise((safe_parse_expr('v_p*(1-P_NPQ)', local_dict=symbols),\n",
+    "                                  CEF > sympy.Symbol('c_y')),\n",
+    "                                 (0, True))),\n",
+    "    NaturalConversion(\n",
+    "        outcome=NADPH,\n",
+    "        subject=NADPp,\n",
+    "        rate_law=ETR*sympy.Symbol('eta_NADPp')),\n",
+    "    ControlledConversion(\n",
+    "        subject=NADPH,\n",
+    "        outcome=NADPp,\n",
+    "        controller=R,\n",
+    "        rate_law=safe_parse_expr('v_C*R*NADPH*eta_NADPH', local_dict=symbols)),\n",
+    "    NaturalProduction(\n",
+    "        outcome=R,\n",
+    "        rate_law=safe_parse_expr('v_R*(1-R)*min(d, NADPH/NADPp)', local_dict=symbols))\n",
+    "]\n",
+    "\n",
+    "observables = {\n",
+    "    'ETR': Observable(name='ETR', expression=ETR),\n",
+    "    'NPQ': Observable(name='NPQ', expression=sympy.Symbol('v_NPQ') * sympy.Symbol('Q')),\n",
+    "    'A': Observable(name='A', expression=sympy.Symbol('v_C')*sympy.Symbol('R')*sympy.Symbol('NADPH'))\n",
+    "}"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "ad2de988",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "parameters = {p: Parameter(name=p, value=v) for p, v in params.items()}\n",
+    "initials = {i: Initial(concept=Concept(name=i), expression=v) for i, v in inits.items()}"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "596994c4",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "tm = TemplateModel(templates=templates,\n",
+    "                   parameters=parameters,\n",
+    "                   initials=initials,\n",
+    "                   observables=observables)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "9141c4a4",
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [],
+   "source": [
+    "om = OdeModel(Model(tm), initialized=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "43e14dfe",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/latex": [
+       "$\\displaystyle \\left[\\begin{matrix}\\left(1 - \\frac{y_{0, 0}}{p_{3, 0}}\\right) p_{4, 0} p_{5, 0} p_{6, 0} - \\left(1 - \\frac{y_{3, 0}}{p_{7, 0}}\\right) p_{8, 0} y_{0, 0} y_{2, 0} - p_{0, 0} y_{0, 0} y_{1, 0}\\\\- p_{0, 0} p_{11, 0} y_{0, 0} y_{1, 0} + p_{2, 0} p_{12, 0} y_{4, 0} y_{5, 0}\\\\\\begin{cases} \\left(1 - y_{2, 0}\\right) p_{10, 0} & \\text{for}\\: p_{9, 0} < \\left(1 - \\frac{y_{0, 0}}{p_{3, 0}}\\right) p_{4, 0} p_{5, 0} p_{6, 0} - p_{0, 0} y_{0, 0} y_{1, 0} \\\\0 & \\text{otherwise} \\end{cases}\\\\\\left(1 - \\frac{y_{3, 0}}{p_{7, 0}}\\right) p_{8, 0} y_{0, 0} y_{2, 0} - p_{1, 0} y_{3, 0}\\\\p_{0, 0} p_{11, 0} y_{0, 0} y_{1, 0} - p_{2, 0} p_{12, 0} y_{4, 0} y_{5, 0}\\\\\\left(1 - y_{5, 0}\\right) p_{14, 0} \\min\\left(\\frac{y_{4, 0}}{y_{1, 0}}, p_{13, 0}\\right)\\end{matrix}\\right]$"
+      ],
+      "text/plain": [
+       "Matrix([\n",
+       "[          (1 - y[0, 0]/p[3, 0])*p[4, 0]*p[5, 0]*p[6, 0] - (1 - y[3, 0]/p[7, 0])*p[8, 0]*y[0, 0]*y[2, 0] - p[0, 0]*y[0, 0]*y[1, 0]],\n",
+       "[                                                             -p[0, 0]*p[11, 0]*y[0, 0]*y[1, 0] + p[2, 0]*p[12, 0]*y[4, 0]*y[5, 0]],\n",
+       "[Piecewise(((1 - y[2, 0])*p[10, 0], p[9, 0] < (1 - y[0, 0]/p[3, 0])*p[4, 0]*p[5, 0]*p[6, 0] - p[0, 0]*y[0, 0]*y[1, 0]), (0, True))],\n",
+       "[                                                                  (1 - y[3, 0]/p[7, 0])*p[8, 0]*y[0, 0]*y[2, 0] - p[1, 0]*y[3, 0]],\n",
+       "[                                                              p[0, 0]*p[11, 0]*y[0, 0]*y[1, 0] - p[2, 0]*p[12, 0]*y[4, 0]*y[5, 0]],\n",
+       "[                                                                            (1 - y[5, 0])*p[14, 0]*Min(y[4, 0]/y[1, 0], p[13, 0])]])"
+      ]
+     },
+     "execution_count": 9,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "om.kinetics"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "372acdf7",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/latex": [
+       "$\\displaystyle \\left[\\begin{matrix}- E_{PSII} NADPp v_{ETR} - E_{PSII} P_{NPQ} v_{d} \\left(- \\frac{Q}{Q_{star}} + 1\\right) + PAR \\alpha c_{in} \\left(- \\frac{E_{PSII}}{E_{PSII star}} + 1\\right)\\\\- E_{PSII} NADPp \\eta_{NADPp} v_{ETR} + NADPH R \\eta_{NADPH} v_{C}\\\\\\begin{cases} v_{p} \\left(1 - P_{NPQ}\\right) & \\text{for}\\: c_{y} < - E_{PSII} NADPp v_{ETR} + PAR \\alpha c_{in} \\left(- \\frac{E_{PSII}}{E_{PSII star}} + 1\\right) \\\\0 & \\text{otherwise} \\end{cases}\\\\E_{PSII} P_{NPQ} v_{d} \\left(- \\frac{Q}{Q_{star}} + 1\\right) - Q v_{NPQ}\\\\E_{PSII} NADPp \\eta_{NADPp} v_{ETR} - NADPH R \\eta_{NADPH} v_{C}\\\\v_{R} \\left(1 - R\\right) \\min\\left(d, \\frac{NADPH}{NADPp}\\right)\\end{matrix}\\right]$"
+      ],
+      "text/plain": [
+       "Matrix([\n",
+       "[            -E_PSII*NADPp*v_ETR - E_PSII*P_NPQ*v_d*(-Q/Q_star + 1) + PAR*alpha*c_in*(-E_PSII/E_PSII_star + 1)],\n",
+       "[                                                        -E_PSII*NADPp*eta_NADPp*v_ETR + NADPH*R*eta_NADPH*v_C],\n",
+       "[Piecewise((v_p*(1 - P_NPQ), c_y < -E_PSII*NADPp*v_ETR + PAR*alpha*c_in*(-E_PSII/E_PSII_star + 1)), (0, True))],\n",
+       "[                                                                   E_PSII*P_NPQ*v_d*(-Q/Q_star + 1) - Q*v_NPQ],\n",
+       "[                                                         E_PSII*NADPp*eta_NADPp*v_ETR - NADPH*R*eta_NADPH*v_C],\n",
+       "[                                                                              v_R*(1 - R)*Min(d, NADPH/NADPp)]])"
+      ]
+     },
+     "execution_count": 10,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "om.get_interpretable_kinetics()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "852ab828",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "({'E_PSII': 0, 'NADPp': 1, 'P_NPQ': 2, 'Q': 3, 'NADPH': 4, 'R': 5},\n",
+       " {'ETR': 0, 'NPQ': 1, 'A': 2})"
+      ]
+     },
+     "execution_count": 11,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "om.vmap, om.observable_map"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "id": "5cbe26d2",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "ts = numpy.linspace(0,60,1000)\n",
+    "res = simulate_ode_model(om, times=ts, with_observables=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "id": "85d7a9dd",
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<matplotlib.legend.Legend at 0x12db71150>"
+      ]
+     },
+     "execution_count": 13,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1000x300 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "import matplotlib.pyplot as plt\n",
+    "plt.figure(figsize=(10, 3))\n",
+    "plt.plot(ts, res[:, 6:], label=list(om.observable_map.keys()))\n",
+    "plt.ylim([0, 100])\n",
+    "plt.legend()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "id": "9bd0d939",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "pj = template_model_to_petrinet_json(tm)\n",
+    "with open('climate_scenario5_petri.json', 'w') as fh:\n",
+    "    json.dump(pj, fh, indent=1)"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.10.13"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/notebooks/evaluation_2024.03/scenario5/p53_model.ipynb b/notebooks/evaluation_2024.03/scenario5/p53_model.ipynb
index 5f9ba771..4cfd780f 100644
--- a/notebooks/evaluation_2024.03/scenario5/p53_model.ipynb
+++ b/notebooks/evaluation_2024.03/scenario5/p53_model.ipynb
@@ -32,13 +32,13 @@
     "templates = [\n",
     "    ControlledConversion(controller=c('ATMa'), subject=c('TP53i'), outcome=c('TP53a')).with_mass_action_rate_law('kf_at_act_1'),\n",
     "    ControlledConversion(controller=c('TP53a'), subject=c('PPM1Di'), outcome=c('PPM1Da')).with_mass_action_rate_law('kf_tp_act_1'),\n",
-    "    ControlledConversion(controller=c('TP53a'), subject=c('MDM2i'), outcome=c('MDM2a')).with_mass_action_rate_law('kf_tm_act_1'),\n",
+    "    #ControlledConversion(controller=c('TP53a'), subject=c('MDM2i'), outcome=c('MDM2a')).with_mass_action_rate_law('kf_tm_act_1'),\n",
     "    ControlledConversion(controller=c('ATMa'), subject=c('ATMi'), outcome=c('ATMa')).with_mass_action_rate_law('kf_aa_act_1'),\n",
     "    ControlledConversion(controller=c('PPM1Da'), subject=c('TP53a'), outcome=c('TP53i')).with_mass_action_rate_law('kf_pt_act_1'),\n",
     "    ControlledConversion(controller=c('PPM1Da'), subject=c('ATMa'), outcome=c('ATMi')).with_mass_action_rate_law('kf_pa_act_1'),\n",
-    "    ControlledConversion(controller=c('MDM2a'), subject=c('TP53a'), outcome=c('TP53i')).with_mass_action_rate_law('kf_mt_act_1'),\n",
+    "    #ControlledConversion(controller=c('MDM2a'), subject=c('TP53a'), outcome=c('TP53i')).with_mass_action_rate_law('kf_mt_act_1'),\n",
     "    ControlledConversion(controller=c('HIPK2'), subject=c('PPM1Da'), outcome=c('PPM1Di')).with_mass_action_rate_law('kf_hp_act_1'),\n",
-    "    ControlledConversion(controller=c('CDKN2A'), subject=c('MDM2a'), outcome=c('MDM2i')).with_mass_action_rate_law('kf_cm_act_1'),\n",
+    "    #ControlledConversion(controller=c('CDKN2A'), subject=c('MDM2a'), outcome=c('MDM2i')).with_mass_action_rate_law('kf_cm_act_1'),\n",
     "]"
    ]
   },
@@ -121,20 +121,17 @@
     {
      "data": {
       "text/latex": [
-       "$\\displaystyle \\left[\\begin{matrix}- p_{0, 0} y_{0, 0} y_{1, 0} + p_{4, 0} y_{2, 0} y_{4, 0} + p_{6, 0} y_{2, 0} y_{6, 0}\\\\p_{3, 0} y_{1, 0} y_{7, 0} - p_{5, 0} y_{1, 0} y_{4, 0}\\\\p_{0, 0} y_{0, 0} y_{1, 0} - p_{4, 0} y_{2, 0} y_{4, 0} - p_{6, 0} y_{2, 0} y_{6, 0}\\\\- p_{1, 0} y_{2, 0} y_{3, 0} + p_{7, 0} y_{4, 0} y_{8, 0}\\\\p_{1, 0} y_{2, 0} y_{3, 0} - p_{7, 0} y_{4, 0} y_{8, 0}\\\\- p_{2, 0} y_{2, 0} y_{5, 0} + p_{8, 0} y_{6, 0} y_{9, 0}\\\\p_{2, 0} y_{2, 0} y_{5, 0} - p_{8, 0} y_{6, 0} y_{9, 0}\\\\- p_{3, 0} y_{1, 0} y_{7, 0} + p_{5, 0} y_{1, 0} y_{4, 0}\\\\0\\\\0\\end{matrix}\\right]$"
+       "$\\displaystyle \\left[\\begin{matrix}- p_{0, 0} y_{0, 0} y_{1, 0} + p_{3, 0} y_{2, 0} y_{4, 0}\\\\p_{2, 0} y_{1, 0} y_{5, 0} - p_{4, 0} y_{1, 0} y_{4, 0}\\\\p_{0, 0} y_{0, 0} y_{1, 0} - p_{3, 0} y_{2, 0} y_{4, 0}\\\\- p_{1, 0} y_{2, 0} y_{3, 0} + p_{5, 0} y_{4, 0} y_{6, 0}\\\\p_{1, 0} y_{2, 0} y_{3, 0} - p_{5, 0} y_{4, 0} y_{6, 0}\\\\- p_{2, 0} y_{1, 0} y_{5, 0} + p_{4, 0} y_{1, 0} y_{4, 0}\\\\0\\end{matrix}\\right]$"
       ],
       "text/plain": [
        "Matrix([\n",
-       "[-p[0, 0]*y[0, 0]*y[1, 0] + p[4, 0]*y[2, 0]*y[4, 0] + p[6, 0]*y[2, 0]*y[6, 0]],\n",
-       "[                           p[3, 0]*y[1, 0]*y[7, 0] - p[5, 0]*y[1, 0]*y[4, 0]],\n",
-       "[ p[0, 0]*y[0, 0]*y[1, 0] - p[4, 0]*y[2, 0]*y[4, 0] - p[6, 0]*y[2, 0]*y[6, 0]],\n",
-       "[                          -p[1, 0]*y[2, 0]*y[3, 0] + p[7, 0]*y[4, 0]*y[8, 0]],\n",
-       "[                           p[1, 0]*y[2, 0]*y[3, 0] - p[7, 0]*y[4, 0]*y[8, 0]],\n",
-       "[                          -p[2, 0]*y[2, 0]*y[5, 0] + p[8, 0]*y[6, 0]*y[9, 0]],\n",
-       "[                           p[2, 0]*y[2, 0]*y[5, 0] - p[8, 0]*y[6, 0]*y[9, 0]],\n",
-       "[                          -p[3, 0]*y[1, 0]*y[7, 0] + p[5, 0]*y[1, 0]*y[4, 0]],\n",
-       "[                                                                           0],\n",
-       "[                                                                           0]])"
+       "[-p[0, 0]*y[0, 0]*y[1, 0] + p[3, 0]*y[2, 0]*y[4, 0]],\n",
+       "[ p[2, 0]*y[1, 0]*y[5, 0] - p[4, 0]*y[1, 0]*y[4, 0]],\n",
+       "[ p[0, 0]*y[0, 0]*y[1, 0] - p[3, 0]*y[2, 0]*y[4, 0]],\n",
+       "[-p[1, 0]*y[2, 0]*y[3, 0] + p[5, 0]*y[4, 0]*y[6, 0]],\n",
+       "[ p[1, 0]*y[2, 0]*y[3, 0] - p[5, 0]*y[4, 0]*y[6, 0]],\n",
+       "[-p[2, 0]*y[1, 0]*y[5, 0] + p[4, 0]*y[1, 0]*y[4, 0]],\n",
+       "[                                                 0]])"
       ]
      },
      "execution_count": 7,
@@ -176,7 +173,7 @@
     },
     {
      "data": {
-      "image/png": "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",
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAArYAAAG2CAYAAACK68VxAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8o6BhiAAAACXBIWXMAAA9hAAAPYQGoP6dpAAD2aUlEQVR4nOz9eZxU9ZX/jz9vrV1d1dUb9AbNIiiCgguJ2onJoDKAIUZHnNGIRgYSPzpoBlxjYhzUZEzUJDKjE5NfVPQbTVwSMxETkeiARhERRRAQZLOBXqDpvaq7tnt/f9ylqnqj0eqqC5zn48GDrlu3bp37vlV1X+/zPouiaZqGIAiCIAiCIBzlOHJtgCAIgiAIgiBkAhG2giAIgiAIwjGBCFtBEARBEAThmECErSAIgiAIgnBMIMJWEARBEARBOCYQYSsIgiAIgiAcE4iwFQRBEARBEI4JRNgKgiAIgiAIxwQibAVBEARBEIRjAhG2giAIgiAIwjGBbYTtT37yExRFYdGiRda27u5uFi5cSGlpKYFAgDlz5tDY2Jj2utraWmbPnk1+fj5lZWXceuutxOPxtH1WrVrFmWeeidfrZfz48SxbtiwLZyQIgiAIgiBkE1sI23Xr1vGrX/2KKVOmpG1fvHgxL730Es8//zyrV6+mrq6OSy+91Ho+kUgwe/ZsotEob7/9Nk8++STLli3jrrvusvbZvXs3s2fP5rzzzmPDhg0sWrSIb3/726xYsSJr5ycIgiAIgiAMPYqmaVouDejs7OTMM8/kf/7nf/jRj37E6aefzkMPPURbWxvDhw/nmWee4bLLLgPg448/ZuLEiaxZs4ZzzjmHv/71r3z961+nrq6O8vJyAB599FFuv/12Dh48iMfj4fbbb+fll1/mo48+st7ziiuuoLW1lVdeeSUn5ywIgiAIgiBkHleuDVi4cCGzZ89m+vTp/OhHP7K2r1+/nlgsxvTp061tJ598MqNGjbKE7Zo1a5g8ebIlagFmzpzJ9ddfz+bNmznjjDNYs2ZN2jHMfVJDHnoSiUSIRCLWY1VVaW5uprS0FEVRMnDWgiAIgiAMNZqm0dHRQVVVFQ6HLRaphSEmp8L297//Pe+//z7r1q3r9VxDQwMej4eioqK07eXl5TQ0NFj7pIpa83nzuYH2aW9vp6urC5/P1+u977vvPu6+++7PfF6CIAiCINiHvXv3MnLkyFybIWSBnAnbvXv38u///u+sXLmSvLy8XJnRJ3fccQc33XST9bitrY1Ro0bx6aefEgwGM/peqqrS2tpKUVGRzCaHEBnn7CDjnB1knLOHjHV2GKpxbm9vZ/To0RQUFGTsmIK9yZmwXb9+PQcOHODMM8+0tiUSCd544w0efvhhVqxYQTQatT7oJo2NjVRUVABQUVHBu+++m3Zcs2pC6j49Kyk0NjYSDAb79NYCeL1evF5vr+1FRUVDImxVVZUfzSFGxjk7yDhnBxnn7CFjnR2GapzNY0kY4fFDzr6lF1xwAZs2bWLDhg3Wvy984QvMnTvX+tvtdvPaa69Zr9m2bRu1tbXU1NQAUFNTw6ZNmzhw4IC1z8qVKwkGg0yaNMnaJ/UY5j7mMQRBEARBEIRjg5x5bAsKCjj11FPTtvn9fkpLS63tCxYs4KabbqKkpIRgMMiNN95ITU0N55xzDgAzZsxg0qRJXH311dx///00NDRw5513snDhQsvjet111/Hwww9z2223MX/+fF5//XWee+45Xn755eyesCAIgiAIgjCk5LwqwkD84he/wOFwMGfOHCKRCDNnzuR//ud/rOedTifLly/n+uuvp6amBr/fzzXXXMM999xj7TN27FhefvllFi9ezNKlSxk5ciS/+c1vmDlzZi5OSRAEQRAEQRgicl7H9migvb2dwsJC2trahiTGtrm5mZKSEonfGkJknLODjHN2kHHOHjLW2WGoxnko79+CPZFvqSAIgiAIgnBMIMJWEARBEARBOCYQYSsIgiAIgiAcE4iwFQRBEARBEI4JRNgKgiAIgiAIxwQibAVBEARBEIRjAhG2giAIgiAIwjGBCFtBEARBEAThmECErSAIgiAIgnBMIMJWEARBEARBOCYQYSsIgiAIgiAcE4iwFQRBEARBEI4JRNgKgiAIgiAIxwQibAVBEARBEIRjAhG2giAIgiAIwjGBCFtBEARBEAThmECErSAIgiAIgnBMIMJWEARBEARBOCYQYSsIgiAIgiAcE4iwFQRBEARBEI4JRNgKgiAIgiAIxwQibAVBEARBEIRjAhG2giAIgiAIwjGBCFtBEARBEAThmECErSAIgiAIgnBMIMJWEARBEARBOCYQYSsIgiAIgiAcE4iwFQRBEARBEI4JRNgKgiAIgiAIxwQibAVBEARBEIRjAhG2giAIgiAIwjGBCFtBEARBEAThmECErSAIgiAIgnBMIMJWEARBEARBOCYQYSsIgiAIgiAcE+RU2P7yl79kypQpBINBgsEgNTU1/PWvf7WenzZtGoqipP277rrr0o5RW1vL7Nmzyc/Pp6ysjFtvvZV4PJ62z6pVqzjzzDPxer2MHz+eZcuWZeP0BEEQBEEQhCziyuWbjxw5kp/85CeceOKJaJrGk08+ycUXX8wHH3zAKaecAsB3vvMd7rnnHus1+fn51t+JRILZs2dTUVHB22+/TX19Pd/61rdwu93853/+JwC7d+9m9uzZXHfddTz99NO89tprfPvb36ayspKZM2dm94QFQRAEQRCEISOnwvaiiy5Ke/zjH/+YX/7yl7zzzjuWsM3Pz6eioqLP17/66qts2bKFv/3tb5SXl3P66adz7733cvvtt7NkyRI8Hg+PPvooY8eO5Wc/+xkAEydO5O9//zu/+MUvRNgKgiAIgiAcQ+RU2KaSSCR4/vnnCYVC1NTUWNuffvppfvvb31JRUcFFF13ED3/4Q8tru2bNGiZPnkx5ebm1/8yZM7n++uvZvHkzZ5xxBmvWrGH69Olp7zVz5kwWLVrUry2RSIRIJGI9bm9vB0BVVVRVzcTpWqiqiqZpGT+ukI6Mc3aQcc4OMs7ZQ8Y6OwzVOMt1O/7IubDdtGkTNTU1dHd3EwgEePHFF5k0aRIAV155JaNHj6aqqoqNGzdy++23s23bNv74xz8C0NDQkCZqAetxQ0PDgPu0t7fT1dWFz+frZdN9993H3Xff3Wt7S0tLr/jdz4uqqnR0dKBpGg6H5PINFTLO2UHGOTvIOGcPGevsMFTj3NHRkbFjCUcHORe2EyZMYMOGDbS1tfHCCy9wzTXXsHr1aiZNmsS1115r7Td58mQqKyu54IIL2LlzJ+PGjRsym+644w5uuukm63F7ezvV1dUUFxcTDAYz+l6qqqIoCsXFxfKjOYTIOGcHGefsIOOcPWSss8NQjbPLlXOZI2SZnF9xj8fD+PHjAZg6dSrr1q1j6dKl/OpXv+q179lnnw3Ajh07GDduHBUVFbz77rtp+zQ2NgJYcbkVFRXWttR9gsFgn95aAK/Xi9fr7bXd4XAMyQ+boij9H3v/enj5FvjSDXDqnIy/9/HEgOMsZAwZ5+wg45w9ZKyzw1CMs1yz4w/bXXFVVdPiW1PZsGEDAJWVlQDU1NSwadMmDhw4YO2zcuVKgsGgFc5QU1PDa6+9lnaclStXpsXx2pqNz0Pd+/DCfFATubZGEARBEATBtuTUY3vHHXdw4YUXMmrUKDo6OnjmmWdYtWoVK1asYOfOnTzzzDN87Wtfo7S0lI0bN7J48WK++tWvMmXKFABmzJjBpEmTuPrqq7n//vtpaGjgzjvvZOHChZbH9brrruPhhx/mtttuY/78+bz++us899xzvPzyy7k89cETCyf/VuPgcObOFkEQBEEQBBuTU2F74MABvvWtb1FfX09hYSFTpkxhxYoV/OM//iN79+7lb3/7Gw899BChUIjq6mrmzJnDnXfeab3e6XSyfPlyrr/+empqavD7/VxzzTVpdW/Hjh3Lyy+/zOLFi1m6dCkjR47kN7/5zdFT6ktJcaqrcaB3iIQgCIIgCIKQY2H72GOP9ftcdXU1q1evPuwxRo8ezV/+8pcB95k2bRoffPDBEdtnO9TMVmQQBEEQBEE4lrBdjK0wABJjKwiCIAiC0C8ibO2OllJcWoStIAiCIAhCv4iwtTtaipiVUARBEARBEIR+EWFrd1QRtoIgCIIgCINBhK3dSRWzImwFQRAEQRD6RYSt3UkTthJjKwiCIAiC0B8ibO2OeGwFQRAEQRAGhQhbu5PqpdXEYysIgiAIgtAfImztjiSPCYIgCIIgDAoRtnZHQhEEQRAEQRAGhQhbuyPJY4IgCIIgCINChK3dkVAEQRAEQRCEQSHC1u5IKIIgCIIgCMKgEGFrdyQUQRAEQRAEYVCIsLU7ImwFQRAEQRAGhQhbuyMxtoIgCIIgCINChK3d0UTYCoIgCIIgDAYRtnZHkscEQRAEQRAGhQhbu5MqZqWlriAIgiAIQr+IsLU7kjwmCIIgCIIwKETY2h1JHhMEQRAEQRgUImztjsTYCoIgCIIgDAoRtnZHhK0gCIIgCMKgEGFrd9JCESTGVhAEQRAEoT9E2NodEbaCIAiCIAiDQoSt3ZFQBEEQBEEQhEEhwtbupHUei+XODkEQBEEQBJsjwtbupIYfaGru7BAEQRAEQbA5ImztTqqYVUXYCoIgCIIg9IcIWzujaYCW8liErSAIgiAIQn+IsLUzmtbjsQhbQRAEQRCE/hBha2d6CllNyn0JgiAIgiD0hwhbO9NL2IrHVhAEQRAEoT9E2NoZEbaCIAiCIAiDRoStnekZeiCdxwRBEARBEPolp8L2l7/8JVOmTCEYDBIMBqmpqeGvf/2r9Xx3dzcLFy6ktLSUQCDAnDlzaGxsTDtGbW0ts2fPJj8/n7KyMm699Vbi8fQOXatWreLMM8/E6/Uyfvx4li1blo3T+/yIx1YQBEEQBGHQ5FTYjhw5kp/85CesX7+e9957j/PPP5+LL76YzZs3A7B48WJeeuklnn/+eVavXk1dXR2XXnqp9fpEIsHs2bOJRqO8/fbbPPnkkyxbtoy77rrL2mf37t3Mnj2b8847jw0bNrBo0SK+/e1vs2LFiqyf7xEjwlYQBEEQBGHQKJrWs6ZUbikpKeGBBx7gsssuY/jw4TzzzDNcdtllAHz88cdMnDiRNWvWcM455/DXv/6Vr3/969TV1VFeXg7Ao48+yu23387BgwfxeDzcfvvtvPzyy3z00UfWe1xxxRW0trbyyiuvDMqm9vZ2CgsLaWtrIxgMZvR8VVWlubmZkpISHI4e84yuFvjpmOTjs6+DC3+a0fc/XhhwnIWMIeOcHWScs4eMdXYYqnEeyvu3YE9s8y1NJBL8/ve/JxQKUVNTw/r164nFYkyfPt3a5+STT2bUqFGsWbMGgDVr1jB58mRL1ALMnDmT9vZ2y+u7Zs2atGOY+5jHsDVSx1YQBEEQBGHQuHJtwKZNm6ipqaG7u5tAIMCLL77IpEmT2LBhAx6Ph6KiorT9y8vLaWhoAKChoSFN1JrPm88NtE97eztdXV34fL5eNkUiESKRiPW4vb0d0GeUaobb2qqqiqZpfR83EU+beWhqHE3a6n4mBhxnIWPIOGcHGefsIWOdHYZqnOW6HX/kXNhOmDCBDRs20NbWxgsvvMA111zD6tWrc2rTfffdx913391re0tLS6/EtM+Lqqp0dHSgaVqv5Rcl3ExpyuPuri5Czc0Zff/jhYHGWcgcMs7ZQcY5e8hYZ4ehGueOjo6MHUs4Osi5sPV4PIwfPx6AqVOnsm7dOpYuXcrll19ONBqltbU1zWvb2NhIRUUFABUVFbz77rtpxzOrJqTu07OSQmNjI8FgsE9vLcAdd9zBTTfdZD1ub2+nurqa4uLiIYmxVRSF4uLi3l9mdzTtYZ7Xg7ekJKPvf7ww4DgLGUPGOTvIOGcPGevsMFTj7HLlXOYIWcZ2V1xVVSKRCFOnTsXtdvPaa68xZ84cALZt20ZtbS01NTUA1NTU8OMf/5gDBw5QVlYGwMqVKwkGg0yaNMna5y9/+Uvae6xcudI6Rl94vV68Xm+v7Q6HY0h+2BRF6efY6TG2ipZAkR/Wz0z/4yxkEhnn7CDjnD1krLPDUIyzXLPjj5wK2zvuuIMLL7yQUaNG0dHRwTPPPMOqVatYsWIFhYWFLFiwgJtuuomSkhKCwSA33ngjNTU1nHPOOQDMmDGDSZMmcfXVV3P//ffT0NDAnXfeycKFCy1het111/Hwww9z2223MX/+fF5//XWee+45Xn755Vye+uDoVe7LVgUsBEEQBEEQbEVOhe2BAwf41re+RX19PYWFhUyZMoUVK1bwj//4jwD84he/wOFwMGfOHCKRCDNnzuR//ud/rNc7nU6WL1/O9ddfT01NDX6/n2uuuYZ77rnH2mfs2LG8/PLLLF68mKVLlzJy5Eh+85vfMHPmzKyf7xHTU9hK5zFBEARBEIR+sV0dWzuSszq2zbvhv05PPp78LzDn/5fR9z9ekFqU2UHGOTvIOGcPGevsIHVshUwh31I7I53HBEEQBEEQBo0IWzvTq0GDhCIIgiAIgiD0hwhbOyMeW0EQBEEQhEEjwtbO9PTQSvKYIAiCIAhCv4iwtTNS7ksQBEEQBGHQiLC1MxKKIAiCIAiCMGhE2NqZXsJWQhEEQRAEQRD6Q4StnRGPrSAIgiAIwqARYWtnRNgKgiAIgiAMGhG2dqZnsphURRAEQRAEQegXV64NEAagp5AVj60gCIIgZBRN04jH4yQS4jyyK263G6fTOah9RdjaGQlFEARBEIQhIxqNUl9fTzgczrUpwgAoisLIkSMJBAKH3VeErZ0RYSsIgiAIQ4KqquzevRun00lVVRUejwdFUXJtltADTdM4ePAg+/bt48QTTzys51aErZ0RYSsIgiAIQ0I0GkVVVaqrq8nPz8+1OcIADB8+nD179hCLxQ4rbCV5zM70FLKSPCYIgiAIGcXhEClkd47Eky5X086Ix1YQBEEQBGHQiLC1MyJsBUEQBEGwKcuWLaOoqCjXZqQhwtbO9KxjKy11BUEQBOG4RlGUAf8tWbKEPXv2pG0rLS1lxowZfPDBB9Zx5s2b1+u1s2bNSnuvb3zjG4waNYq8vDwqKyu5+uqrqaurs56//PLL2b59e9bOfTCIsLUzPYVsT6ErCIIgCMJxRX19vfXvoYceIhgMpm275ZZbrH3/9re/UV9fz4oVK+js7OTCCy+ktbXVen7WrFlpr/3d736X9l7nnXcezz33HNu2beMPf/gDO3fu5LLLLrOe9/l8lJWVDfk5HwlSFcHOSPKYIAiCIAgpVFRUWH8XFhaiKEraNoCmpiYASktLqaiooKKiggcffJAvf/nLrF27lpkzZwLg9Xp7vTaVxYsXW3+PHj2a733ve1xyySXEYjHcbjfLli1j0aJFaWI514iwtTMSYysIgiAIWUPTNLpiuXEi+dzOIa2j6/P5AL3MmcmqVasoKyujuLiY888/nx/96EeUlpb2+frm5maefvppvvSlL+F2u4fMzs+LCFs7I8JWEARBELJGVyzBpLtW5OS9t9wzk3zP0Miy1tZW7r33XgKBAGeddRaghyFceumljB07lp07d/L973+fCy+8kDVr1qTVir399tt5+OGHCYfDnHPOOSxfvnxIbMwUEmNrZ0whqxiXSZLHBEEQBEEYJF/60pcIBAIUFxfz4Ycf8uyzz1JeXg7AFVdcwTe+8Q0mT57MJZdcwvLly1m3bh2rVq1KO8att97KBx98wKuvvorT6eRb3/oWmo1zfsRja2dMYetwQyIiHltBEARBGEJ8bidb7pmZs/fONM8++yyTJk2itLT0sGW5TjjhBIYNG8aOHTu44IILrO3Dhg1j2LBhnHTSSUycOJHq6mreeecdampqMm5vJhBha2csYevSha0qwlYQBEEQhgpFUYYsHCAXVFdXM27cuEHtu2/fPg4dOkRlZWW/+6iGDolEIhmxbyg4dq7esYiaImxBPLaCIAiCIHxuOjs7ufvuu5kzZw4VFRXs3LmT2267jfHjx1sVE9auXcu6des499xzKS4uZufOnfzwhz9k3LhxtvXWgsTY2htTyDpF2AqCIAiCkBmcTicbN27kG9/4BieddBILFixg6tSpvPnmm3i9XgDy8/P54x//yAUXXMCECRNYsGABU6ZMYfXq1dY+dkQ8tnZG6+mxleQxQRAEQRB05s2bx7x583ptHzNmzIAJXj6fjxUrBq7+MHnyZF5//fXP9P65RDy2diY1eSz1sSAIgiAIgtALEbZ2RkIRBEEQBEEQBo0IWzvTMxRBWuoKgiAIgiD0iwhbO9MrFMG+BZEFQRAEQRByjQhbO2Mmi0nymCAIgiAIwmERYWtnTA+tw+hGIjG2giAIgiAI/SLC1s5YyWNSFUEQBEEQBOFwiLC1M5I8JgiCIAiCMGhyKmzvu+8+vvjFL1JQUEBZWRmXXHIJ27ZtS9tn2rRpKIqS9u+6665L26e2tpbZs2eTn59PWVkZt956K/F4PG2fVatWceaZZ+L1ehk/fjzLli0b6tP7/PRq0CAeW0EQBEEQhP7IqbBdvXo1Cxcu5J133mHlypXEYjFmzJhBKBRK2+873/kO9fX11r/777/fei6RSDB79myi0Shvv/02Tz75JMuWLeOuu+6y9tm9ezezZ8/mvPPOY8OGDSxatIhvf/vbh+26kXMkFEEQBEEQBGHQ5FTYvvLKK8ybN49TTjmF0047jWXLllFbW8v69evT9svPz6eiosL6FwwGredeffVVtmzZwm9/+1tOP/10LrzwQu69914eeeQRotEoAI8++ihjx47lZz/7GRMnTuSGG27gsssu4xe/+EVWz/eI6emxRZOSX4IgCIIgALBmzRqcTiezZ88G9Ba3PVe5U/+NGTMGSK6G/+QnP+l1zNmzZ6MoCkuWLMnimWQO1+F3yR5tbW0AlJSUpG1/+umn+e1vf0tFRQUXXXQRP/zhD8nPzwf0izp58mTKy8ut/WfOnMn111/P5s2bOeOMM1izZg3Tp09PO+bMmTNZtGhRn3ZEIhEikYj1uL29HQBVVVHVzHpNVVVF07S+j6smcACaw4VibYonqyQIg2bAcRYyhoxzdpBxzh4y1tlhqMb5WL9ujz32GDfeeCOPPfYYdXV1LF26NE2sVlZW8sQTTzBr1iwAnM6kfqiurmbZsmV873vfs7bt37+f1157jcrKyuydRIaxjbBVVZVFixbx5S9/mVNPPdXafuWVVzJ69GiqqqrYuHEjt99+O9u2beOPf/wjAA0NDWmiFrAeNzQ0DLhPe3s7XV1d+Hy+tOfuu+8+7r777l42trS09Ird/byoqkpHRweapuFwpDvQfaFO/EA0ruI1tjUfOghOT0ZtOB4YaJyFzCHjnB1knLOHjHV2GKpx7ujoyNix7EZnZyfPPvss7733Hg0NDSxbtozvf//7FBYWpu1XVFRERUVFr9d//etf57nnnuOtt97iy1/+MgBPPvkkM2bMoLa2Nm3f/+//+/9YunQp27Ztw+/3c/755/PQQw9RVlY2dCf4GbGNsF24cCEfffQRf//739O2X3vttdbfkydPprKykgsuuICdO3cybty4IbHljjvu4KabbrIet7e3U11dTXFxcVoYRCZQVRVFUSguLu79Zc7LA8CTlxTeJcVF4MrLqA3HAwOOs5AxZJyzg4xz9pCxzg5DNc4u1xHKHE2DWDhj739EuPNBUQ6/n8Fzzz3HySefzIQJE7jqqqtYtGgRd9xxB8ogj+HxeJg7dy5PPPGEJWyXLVvG/fff3ysMIRaLce+99zJhwgQOHDjATTfdxLx58/jLX/4yaHuzhS2E7Q033MDy5ct54403GDly5ID7nn322QDs2LGDcePGUVFRwbvvvpu2T2NjI4A1Q6moqLC2pe4TDAZ7eWsBvF4vXq+313aHwzEkP2yKovRzbD2eVknx0Dp0QzJuw/FA/+MsZBIZ5+wg45w9ZKyzw1CM8xEfKxaG/6zK2PsfEd+vA49/0Ls/9thjXHXVVQDMmjWLtrY2Vq9ezbRp0wZ9jPnz5/OVr3yFpUuXsn79etra2vj617/eS9jOnz/f+vuEE07gv/7rv/jiF79IZ2cngUBg0O+XDXL6LdU0jRtuuIEXX3yR119/nbFjxx72NRs2bACw4j9qamrYtGkTBw4csPZZuXIlwWCQSZMmWfu89tpracdZuXIlNTU1GTqTIaJX8hjSVlcQBEEQjnO2bdvGu+++yze/+U1A90xffvnlPPbYY0d0nNNOO40TTzyRF154gccff5yrr766Ty/3+vXrueiiixg1ahQFBQX8wz/8A0CvkAU7kFOP7cKFC3nmmWf43//9XwoKCqyY2MLCQnw+Hzt37uSZZ57ha1/7GqWlpWzcuJHFixfz1a9+lSlTpgAwY8YMJk2axNVXX839999PQ0MDd955JwsXLrS8rtdddx0PP/wwt912G/Pnz+f111/nueee4+WXX87ZuQ+KPoXtsR0ILwiCIAg5w52ve05z9d6D5LHHHiMej1NVlfQua5qG1+vl4Ycf7hVnOxDz58/nkUceYcuWLb1WwAFCoRAzZ85k5syZPP300wwfPpza2lpmzpxpVZ+yE59b2CYSCTZt2sTo0aMpLi4+otf+8pe/BOjlNn/iiSeYN28eHo+Hv/3tbzz00EOEQiGqq6uZM2cOd955p7Wv0+lk+fLlXH/99dTU1OD3+7nmmmu45557rH3Gjh3Lyy+/zOLFi1m6dCkjR47kN7/5DTNnzvzsJ54NetaxBek+JgiCIAhDhaIcUThALojH4zz11FP87Gc/Y8aMGWnPXXLJJfzud7/r1chqIK688kpuueUWTjvtNGulO5WPP/6YQ4cO8ZOf/ITq6moA3nvvvc93EkPIEQvbRYsWMXnyZBYsWEAikeAf/uEfePvtt8nPz2f58uVHFNuhHaYma3V1NatXrz7scUaPHn3YAOZp06bxwQcfDNo2W9Cnx1bq2AqCIAjC8cry5ctpaWlhwYIFvTyzc+bM4bHHHjsiYVtcXEx9fT1ut7vP50eNGoXH4+G///u/ue666/joo4+49957P9c5DCVHHGP7wgsvcNpppwHw0ksvsXv3bj7++GMWL17MD37wg4wbeFxjxtNKKIIgCIIgCOhhCNOnT+8z3GDOnDm89957bNy48YiOWVRUhN/ft6d6+PDhLFu2jOeff55Jkybxk5/8hAcffPAz2Z4Njthj29TUZFUb+Mtf/sI///M/c9JJJzF//nyWLl2acQOPa0wRqyigOPTHkjwmCIIgCMctL730Ur/PnXXWWWmr4f2tjK9atWrA9zAT9U2++c1vWolqhzt2rjlij215eTlbtmwhkUjwyiuv8I//+I8AhMPhtI4WQgYwPzSKQ/8H4rEVBEEQBEHohyP22P7rv/4r//Iv/0JlZSWKolitateuXcvJJ5+ccQOPayyPrQMUJxAXYSsIgiAIgtAPRyxslyxZwqmnnsrevXv553/+Z6ukltPpTOs3LGSANGFreGylKoIgCIIgCEKffKZyX5dddhkA3d3d1rZrrrkmMxYJSSxh65RQBEEQBEEQhMNwxDG2iUSCe++9lxEjRhAIBNi1axcAP/zhD4+444VwGFI9tg5n+jZBEARBEAQhjSMWtj/+8Y9ZtmwZ999/Px6Px9p+6qmn8pvf/Cajxh33mGEHikOvjAAibAVBEARBEPrhiIXtU089xa9//Wvmzp2bVgXhtNNO4+OPP86occc9vZLHEGErCIIgCILQD0csbPfv38/48eN7bVdVlVgslhGjBIOedWxBkscEQRAEQRD64YiF7aRJk3jzzTd7bX/hhRc444wzMmKUYCB1bAVBEARBEAbNEVdFuOuuu7jmmmvYv38/qqryxz/+kW3btvHUU0+xfPnyobDx+KXP5DHx2AqCIAiCIPTFEXtsL774Yl566SX+9re/4ff7ueuuu9i6dSsvvfSS1YVMyBCmsHVIuS9BEARBEEBRlAH/LVmyhD179qRtKy0tZcaMGXzwwQfWcebNm9frtbNmzUp7r2984xuMGjWKvLw8Kisrufrqq6mrq8v2KR8Rn6mO7Ve+8hVWrlyZaVuEnvTVoEGErSAIgiAct9TX11t/P/vss9x1111s27bN2hYIBGhqagLgb3/7G6eccgr79u3ju9/9LhdeeCEff/wxRUVFAMyaNYsnnnjCeq3ZdMvkvPPO4/vf/z6VlZXs37+fW265hcsuu4y33357CM/w83HEHlshi/TZeUyErSAIgiAcr1RUVFj/CgsLURQlbVsgELD2LS0tpaKigi984Qs8+OCDNDY2snbtWut5r9eb9tri4uK091q8eDHnnHMOo0eP5ktf+hLf+973eOedd6xiAYcOHeKb3/wmI0aMID8/n8mTJ/O73/0uOwPRD4Py2BYXF6OYdVQPQ3Nz8+cySEhBS61jKx5bQRAEQRhKNE2jK96Vk/f2uXyD1lqf6fg+HwDRaNTatmrVKsrKyiguLub888/nRz/6EaWlpX2+vrm5maeffpovfelLuN1uQO9AO3XqVG6//XaCwSAvv/wyV199NePGjeOss84asnMZiEEJ24ceemiIzRD6RDqPCYIgCELW6Ip3cfYzZ+fkvddeuZZ8d/6QHLu1tZV7772XQCBgCc5Zs2Zx6aWXMnbsWHbu3Mn3v/99LrzwQtasWZPWp+D222/n4YcfJhwOc84556QVChgxYgS33HKL9fjGG29kxYoVPPfcc/YWttdcc81Q2yH0RV91bKUqgiAIgiAIg+BLX/oSDoeDUCjECSecwLPPPkt5eTkAV1xxhbXf5MmTmTJlCuPGjWPVqlVccMEF1nO33norCxYs4NNPP+Xuu+/mW9/6FsuXL0dRFBKJBP/5n//Jc889x/79+4lGo0QiEfLzh0agD4YjTh6rra0d8PlRo0Z9ZmOEHkgdW0EQBEHIGj6Xj7VXrj38jkP03pnm2WefZdKkSZSWlloJY/1xwgknMGzYMHbs2JEmbIcNG8awYcM46aSTmDhxItXV1bzzzjvU1NTwwAMPsHTpUh566CEmT56M3+9n0aJFaeEO2eaIhe2YMWMGjAFJJMSjmDH6aqkrnccEQRAEYUhQFGXIwgFyQXV1NePGjRvUvvv27ePQoUNUVlb2u49qJLBHIhEA3nrrLS6++GKuuuoq6/nt27czadKkz2n5Z+eIhW1qDTSAWCzGBx98wM9//nN+/OMfZ8wwgRRhK3VsBUEQBEHIDJ2dndx9993MmTOHiooKdu7cyW233cb48eOZOXMmAGvXrmXdunWce+65FBcXs3PnTn74wx8ybtw4ampqADjxxBN54YUXePvttykuLubnP/85jY2NR5ewPe2003pt+8IXvkBVVRUPPPAAl156aUYME+iRPGYKWy139giCIAiCcNTjdDrZuHEjTz75JK2trVRVVTFjxgzuvfdeq5Ztfn4+f/zjH/mP//gPQqEQlZWVzJo1izvvvNPa584772TXrl3MnDmT/Px8rr32Wi655BLa2tpydm6fqUFDX0yYMIF169Zl6nACJMMO0mJsJRRBEARBEAS9e9i8efN6bR8zZgzaAI4wn8/HihUrBjz25MmTef311wfcp6SkhD/96U+DMTVrHLGwbW9vT3usaRr19fUsWbKEE088MWOGCUjnMUEQBEEQhCPgiIVtUVFRr+QxTdOorq7m97//fcYME+g7eUyErSAIgiAIQp8csbB9/fXX04Stw+Fg+PDhjB8/HpcrY5ENAvRdx1aqIgiCIAiCIPTJESvRadOmDYEZQp9IHVtBEARBEIRB4zjSF9x33308/vjjvbY//vjj/PSnP82IUYJBny11xWMrCIIgCILQF0csbH/1q19x8skn99p+yimn8Oijj2bEKMHAFLYOpx6OAFLuSxAEQRAEoR+OWNg2NDT02ZVi+PDh1NfXZ8QowUBLlvsKo/CdiuE83vD33NokCIIgCIJgU45Y2FZXV/PWW2/12v7WW29RVVWVEaMEg5RQhHeUbt7x+fhF3WvsaNmRW7sEQRAEQRBsyBEnj33nO99h0aJFxGIxzj//fABee+01brvtNm6++eaMG3hckyJsm0gmjX3S+gnji8fnyChBEARBEAR7csTC9tZbb+XQoUP827/9G9FoFIC8vDxuv/127rjjjowbeFyTImwPKgkwwmsPhA/kziZBEARBEITPyLJly1i0aBGtra1DcvwjDkVQFIWf/vSnHDx4kHfeeYcPP/yQ5uZm7rrrrqGw7/gmpY7tQZLVEJq6mnJkkCAIgiAIuWbevHkoioKiKHg8HsaPH88999xDPB5n1apV1nOKolBeXs6cOXPYtWuX9foxY8agKEqfjbVOOeUUFEVh2bJl1rZf//rXTJs2jWAwiKIofYrS1Pf0+/2ceOKJzJs3j/Xr16ftd/nll7N9+/aMjUVPjljYmjQ0NNDc3My4cePwer0D9iQWPiMpdWwPErc2i8dWEARBEI5vZs2aRX19PZ988gk333wzS5Ys4YEHHrCe37ZtG3V1dTz//PNs3ryZiy66iEQi6SSrrq7miSeeSDvmO++8Q0NDA36/P217OBxm1qxZfP/73x/QpieeeIL6+no2b97MI488QmdnJ2effTZPPfWUtY/P56OsrOzznPqAHLGwPXToEBdccAEnnXQSX/va16xKCAsWLDjiGNv77ruPL37xixQUFFBWVsYll1zCtm3b0vbp7u5m4cKFlJaWEggEmDNnDo2NjWn71NbWMnv2bPLz8ykrK+PWW28lHo+n7bNq1SrOPPNMvF4v48ePT5uJ2BbLY+sklNKY4VD3oRwZJAiCIAiCHfB6vVRUVDB69Giuv/56pk+fzp///Gfr+bKyMiorK/nqV7/KXXfdxZYtW9ixI5l8PnfuXFavXs3evXutbY8//jhz587t1Ul20aJFfO973+Occ84Z0KaioiIqKioYM2YMM2bM4IUXXmDu3LnccMMNtLS0AHooQlFRUQZGoG+OWNguXrwYt9tNbW0t+fn51vbLL7+cV1555YiOtXr1ahYuXMg777zDypUricVizJgxg1AolPZ+L730Es8//zyrV6+mrq6OSy+91Ho+kUgwe/ZsotEob7/9Nk8++STLli1LC43YvXs3s2fP5rzzzmPDhg0sWrSIb3/726xYseJITz+7pMTYdpH0iHdGO3NkkCAIgiAcu2iahhoO5+Tf51359vl8Vu5TX88Bac+Xl5czc+ZMnnzySUD3yj777LPMnz//c9nRk8WLF9PR0cHKlSszetz+OOLksVdffZUVK1YwcuTItO0nnngin3766REdq6cQXrZsGWVlZaxfv56vfvWrtLW18dhjj/HMM89YFRieeOIJJk6cyDvvvMM555zDq6++ypYtW/jb3/5GeXk5p59+Ovfeey+33347S5YswePx8OijjzJ27Fh+9rOfATBx4kT+/ve/84tf/IKZM2ce6RBkDzVZx7YrpSpCZ0yErSAIgiBkGq2ri21nTs3Je094fz1KisNwsGiaxmuvvcaKFSu48cYbez1fX1/Pgw8+yIgRI5gwYULac/Pnz+fmm2/mBz/4AS+88ALjxo3j9NNP/6yn0CdmU689e/Zk9Lj9ccTCNhQKpXlqTZqbm/F6vZ/LmLa2NgBKSkoAWL9+PbFYjOnTp1v7nHzyyYwaNYo1a9ZwzjnnsGbNGiZPnkx5ebm1z8yZM7n++uvZvHkzZ5xxBmvWrEk7hrnPokWL+rQjEokQiUSsx+3t7QCoqoqqqn2+5rOiqqo+Q+zjuIqmogAqpAnbjmhHxu041hlonIXMIeOcHWScs4eMdXYYqnE+lq/b8uXLCQQCxGIxVFXlyiuvZMmSJaxbtw6AkSNHomka4XCY0047jT/84Q94PJ60Y8yePZv/9//+H2+88QaPP/54xr21gOWJVswOqkPMEQvbr3zlKzz11FPce++9gG6oqqrcf//9nHfeeZ/ZEFVVWbRoEV/+8pc59dRTAT1BzePx9IrFKC8vp6GhwdonVdSaz5vPDbRPe3s7XV1dlove5L777uPuu+/uZWNLS0uv2N3Pi6qqdHR0oGkaDkd6ZEhxIoYTaO/opEtLBnx3RDtobm7OqB3HOgONs5A5ZJyzg4xz9pCxzg5DNc4dHR1HtL/i8zHh/fWH33EIUHpokcNx3nnn8ctf/hKPx0NVVVWvuNg333yTYDBIWVkZBQUFfR7D5XJx9dVX8x//8R+sXbuWF1988TPb3x9bt24FYOzYsRk/dl8csbC9//77ueCCC3jvvfeIRqPcdtttbN68mebm5j47kg2WhQsX8tFHH/H3v+e+Zewdd9zBTTfdZD1ub2+nurqa4uJigsFgRt9LVVUURaG4uLjXl9mc3QQLi9I8tjE1RqAwgMeZPvMS+megcRYyh4xzdpBxzh4y1tlhqMa5p9g7HIqifKZwgFzg9/sZP77/Zk1jx44dVJLW/PnzefDBB7n88sspLi7OoIU6Dz30EMFgsNfK+VBxxML21FNPZfv27Tz88MMUFBTQ2dnJpZdeysKFC6msrPxMRtxwww0sX76cN954Iy12t6Kigmg0Smtra9rFaWxspKKiwtrn3XffTTueWTUhdZ+elRQaGxsJBoO9vLWgZxr2FVbhcDiG5IdNUZS+j2247zXFQZT0oPJQPESeOy/jthzL9DvOQkaRcc4OMs7ZQ8Y6OwzFOMs1OzwTJ06kqampzzBTk4aGBhoaGqyqCps2baKgoIBRo0ZZ4aMAra2tNDQ0EIlE2L59O7/61a/405/+xFNPPTWklRBSOWJhC1BYWMgPfvCDz/3mmqZx44038uKLL7Jq1apebuqpU6fidrt57bXXmDNnDqDXZautraWmpgaAmpoafvzjH3PgwAGrLtrKlSsJBoNMmjTJ2ucvf/lL2rFXrlxpHcO2GFURutRkFqMLhTganbFOSn2lubJMEARBEIRjhNLSgfXEo48+mhai+dWvfhXQE/rnzZtnbf/Xf/1XQO9IO2LECM4991zeffddzjzzzMwb3Q+DErYbN24c9AGnTJky6H0XLlzIM888w//+7/9SUFBgxcQWFhbi8/koLCxkwYIF3HTTTZSUlBAMBrnxxhupqamxaqnNmDGDSZMmcfXVV3P//ffT0NDAnXfeycKFCy2v63XXXcfDDz/Mbbfdxvz583n99dd57rnnePnllwdta04whG23psf1KppGiSufA4mwVEYQBEEQhOOUgWrxT5s27bClww5XoaBnZ7ElS5awZMmSAV8z2HJl8+bNSxPDmWZQwvb0009HUZTDGq0oSlpXi8Pxy1/+EtAvQiqpM4Bf/OIXOBwO5syZQyQSYebMmfzP//yPta/T6WT58uVcf/311NTU4Pf7ueaaa7jnnnusfcaOHcvLL7/M4sWLWbp0KSNHjuQ3v/mNvUt9ARgJY11qDACfplHgcHMgIbVsBUEQBEEQejIoYbt79+4hefPBqPu8vDweeeQRHnnkkX73GT16dK9Qg55MmzaNDz744IhtzClWKIIubPM0jYDiBkTYCoIgCIIg9GRQwnb06NFDbYfQF4awjRmeW7emEVD0S9YRO7ISJoIgCIIgCMc6nyl5bOfOnTz00ENWbbJJkybx7//+74wbNy6jxh339BC2Hk2jwKFfMvHYCoIgCIIgpHPEdTBWrFjBpEmTePfdd5kyZQpTpkxh7dq1nHLKKVnrA3zcYAjbqJoUtuKxFQRBEARB6Jsj9th+73vfY/HixfzkJz/ptf3222/nH//xHzNm3HGPEYMctTy2UKCIx1YQBEEQBKEvjthju3XrVhYsWNBr+/z589myZUtGjBIMTI+tUe4rNcZWyn0JgiAIgiCkc8TCdvjw4WzYsKHX9g0bNlgNEoQMYYQgmKEIbk3Db1yyUCyUM7MEQRAEQRDsyBGHInznO9/h2muvZdeuXXzpS18C4K233uKnP/0pN910U8YNPK7pmTyGhl9xAiJsBUEQBEEQenLEwvaHP/whBQUF/OxnP+OOO+4AoKqqiiVLlvDd73434wYe15jCVtVDETwalsc2HAvnzCxBEARBEAQ7csShCIqisHjxYvbt20dbWxttbW3s27ePf//3f0dRlKGw8filR4ytR0IRBEEQBOG4Z968eSiKgqIoeDwexo8fzz333EM8HmfVqlXWc4qiUF5ezpw5c9i1a5f1+jFjxqAoCr///e97HfuUU05BUZS0tr2//vWvmTZtGsFgEEVRerXcBdLe0+/3c+KJJzJv3jzWr18/FEPQL0csbFMpKCigoKAgU7YIPbHKfenC1qVp5IuwFQRBEITjnlmzZlFfX88nn3zCzTffzJIlS3jggQes57dt20ZdXR3PP/88mzdv5qKLLiKRSFjPV1dX88QTT6Qd85133qGhoQG/35+2PRwOM2vWLL7//e8PaNMTTzxBfX09mzdv5pFHHqGzs5Ozzz6bp556KgNnPDgGHYpw/vnnD2q/119//TMbI6SgaYBe7iu1QYMf3SsejksogiAIgiAcr3i9XioqKgC4/vrrefHFF/nzn/9MTU0NAGVlZRQVFVFZWcldd93F3Llz2bFjBxMmTABg7ty5/OIXv2Dv3r1UV1cD8PjjjzN37txeQnTRokUArFq1akCbioqKLJvGjBnDjBkzuOaaa7jhhhu46KKLKC4u5tChQ9xwww288cYbtLS0MG7cOL7//e/zzW9+MyPjMmhhu2rVKkaPHs3s2bNxu90ZeXNhAIwatpD02HrEYysIgiAIQ4amacSjak7e2+VxfK6QTp/Px6FDh/p9DiAajVrbysvLmTlzJk8++SR33nkn4XCYZ599ltWrV2fUw7p48WKeeuopVq5cyb/8y7/Q3d3N1KlTuf322wkGg7z88stcffXVjBs3jrPOOutzv9+ghe1Pf/pTnnjiCZ5//nnmzp3L/PnzOfXUUz+3AUI/aMkvVkxLSR7T9A99JBEhrsZxOT5TV2RBEARBEHoQj6r8+t9X5+S9r136D7i9ziN+naZpvPbaa6xYsYIbb7yx1/P19fU8+OCDjBgxwvLWmsyfP5+bb76ZH/zgB7zwwguMGzeO008//bOeQp+cfPLJAOzZsweAESNGcMstt1jP33jjjaxYsYLnnnsuI8J20DG2t956K1u2bOFPf/oTHR0dfPnLX+ass87i0Ucfpb29/XMbIvRAS8bBRNUYYIYiJBGvrSAIgiAcnyxfvpxAIEBeXh4XXnghl19+OUuWLLGeHzlyJH6/n6qqKkKhEH/4wx/weDxpx5g9ezadnZ288cYbPP7448yfPz/jdmrGCrTpjU4kEtx7771MnjyZkpISAoEAK1asoLa2NiPvd8TuvpqaGmpqali6dCnPP/88jzzyCLfccgt1dXUEg8GMGCWQ7rE1k8fQcANuh5uYGiMcC1PoLcyRgYIgCIJwbOHyOLh26T/k7L2PhPPOO49f/vKXeDweqqqqcLnSJd2bb75JMBikrKys30R/l8vF1VdfzX/8x3+wdu1aXnzxxc9sf39s3boVgLFjxwLwwAMPsHTpUh566CEmT56M3+9n0aJFaWESn4fPvI79/vvvs3r1arZu3cqpp54qcbeZJkXYpsbYoibwu/20RlrFYysIgiAIGURRlM8UDpAL/H4/48eP7/f5sWPHUlRUdNjjzJ8/nwcffJDLL7+c4uLiDFqo89BDDxEMBpk+fTqgN/W6+OKLueqqqwBQVZXt27czadKkjLzfEQnburo6li1bxrJly2hvb+eqq65i7dq1GTNGSKGPGFu3poGmJoVtXIStIAiCIAifnYkTJ9LU1ER+fn6/+zQ0NNDQ0MCOHTsA2LRpEwUFBYwaNYqSkhJrv9bWVhoaGohEImzfvp1f/epX/OlPf+Kpp56yRPaJJ57ICy+8wNtvv01xcTE///nPaWxszL6w/drXvsb//d//MWPGDB544AFmz57dy+0tZJAUYRtX9Xhbl6Zvz3frHz7x2AqCIAiC8HkpLS0d8PlHH32Uu+++23r81a9+FdDr1s6bN8/a/q//+q8A5OXlMWLECM4991zeffddzjzzTGufO++8k127djFz5kzy8/O59tprueSSS2hra8vIuQxamb7yyitUVlZSW1vL3XffnXaCqbz//vsZMey4J1XYaskYWzQVv0tPIZO2uoIgCIJw/JHaFawn06ZNsxK2+sOsUNAfPTuLLVmyJC0xrS8O954mJSUl/OlPfxrUvp+FQQvb//iP/xgyI4Q+SPmAJAyRa3ps/W49CFw8toIgCIIgCElE2NoVNVnuK57SUldCEQRBEARBEPrmyGpLCNnDCkVQrOQxF1hVEUDa6gqCIAiCIKQiwtaumMJWcZAwvLfOlKoIIB5bQRAEQRCEVETY2pUUYWuFIgBoCfJdeijCUZ88tuIH8NhMiHXl2hJBEARBEI4BRNjalVSPrdFe132seWzXPAx734FNL+TaEkEQBEEQjgFE2NqVPjy2Tg3QtGMjxjYRS/7dsjt3dgiCIAiCcMzwmYTtDTfcQHNzc6ZtEVLpMxRBS0seO6o9tl0tyb87GnNnhyAIgiAIxwyDFrb79u2z/n7mmWfo7OwEYPLkyezduzfzlh3vpApb7Rgs9xU+lPw72pE7OwRBEARBOGYYtLA9+eSTGT16NFdeeSXd3d2WmN2zZw+xWOwwrxaOGFPYOlJCEQC0Y8RjmyZsj+KQCkEQBEE4xhkzZgwPPfRQrs0YFIMWtq2trTz//PNMnToVVVX52te+xkknnUQkEmHFihU0NspyckbpIxTBSh47FlrqhlNCWY7m8xAEQRCEHLFmzRqcTiezZ88GYN68eSiK0u+/MWPGAHrbXUVR+MlPftLrmLNnz0ZRlLQWuuvWrePaa6/Nxil9bgYtbGOxGGeddRY333wzPp+PDz74gCeeeAKn08njjz/O2LFjmTBhwlDaenzRRx3bZEtdw2MbP4o9tpGU8IPoUXwegiAIgpAjHnvsMW688UbeeOMN6urqWLp0KfX19dY/gCeeeMJ6vG7dOuu11dXVLFu2LO14+/fv57XXXqOysjJt+/Dhw8nPzx/y88kEgxa2RUVFnH322dx0001Eo1G6urr48pe/jMvl4tlnn6WlpYXHHntsKG09vuirKoKRPHZMxNjGU2rXisdWEARBEI6Izs5Onn32Wa6//npmz57NsmXLKCwspKKiwvoHun4zHw8fPtx6/de//nWampp46623rG1PPvkkM2bMoKysLO29jslQhP3793PnnXfi9XqJx+NMnTqVr3zlK0SjUd5//30UReHcc88dSluPL/pMHiOt3FdcjRNNRHNk4Ock1p38W2JsBUEQBBugaRqx7u6c/NM07Yhsfe655zj55JOZMGECV111FY8//vgRHcPj8TB37lyeeOIJa9uyZcuYP3/+EdlhN1yD3XHYsGFcdNFFXHTRRTz66KO88cYbbN26lW9961vccsstXH311Zx11lmsXr16KO09fujPY6upVucx0L22HqcnFxZ+PtI8tkex51kQBEE4ZohHIvzXNZfl5L2/++QLuPPyBr3/Y489xlVXXQXArFmzaGtrY/Xq1UybNm3Qx5g/fz5f+cpXWLp0KevXr6etrY2vf/3rafG1RxufuUFDYWEh//Iv/4Lb7eb1119n9+7d/Nu//VsmbTu+6TN5DNASOB1OfC4fcBSHI6R6bKWlriAIgiAMmm3btvHuu+/yzW9+EwCXy8Xll19+xCGhp512GieeeCIvvPACjz/+OFdffTUu16B9nrbkM1m/ceNGRowYAcDo0aNxu91UVFRw+eWXH9Fx3njjDR544AHWr19PfX09L774Ipdccon1/Lx583jyySfTXjNz5kxeeeUV63FzczM33ngjL730Eg6Hgzlz5rB06VICgUCavQsXLmTdunUMHz6cG2+8kdtuu+0znHkWUU1h60w2aDCqIgDku/LpincdvcI23p3+t5oAhzN39giCIAjHPS6vl+8+mZs27y6vd9D7PvbYY8Tjcaqqqqxtmqbh9Xp5+OGHKSwsHPSx5s+fzyOPPMKWLVt49913j8hmO/KZhG11dbX190cfffSZ3zwUCnHaaacxf/58Lr300j73mTVrVlr8h7fHhZ87dy719fWsXLmSWCzGv/7rv3LttdfyzDPPANDe3s6MGTOYPn06jz76KJs2bWL+/PkUFRXZu3SF5bFVSGh6VQQn6AIQ8Lv9HOo+dPS21e3ppY2FwVuQG1sEQRAEAVAU5YjCAXJBPB7nqaee4mc/+xkzZsxIe+6SSy7hd7/7Hdddd92gj3fllVdyyy23cNpppzFp0qRMm5t1cupvvvDCC7nwwgsH3Mfr9VqZfT3ZunUrr7zyCuvWreMLX/gCAP/93//N1772NR588EGqqqp4+umniUajPP7443g8Hk455RQ2bNjAz3/+86NC2GopwjbVY3vUN2lI9diCLnRF2AqCIAjCgCxfvpyWlhYWLFjQyzM7Z84cHnvssSMStsXFxdTX1+N2uzNtak6wfSDFqlWrKCsro7i4mPPPP58f/ehHlJaWAnph4qKiIkvUAkyfPh2Hw8HatWv5p3/6J9asWcNXv/pVPJ5kgtXMmTP56U9/SktLC8XFxb3eMxKJEIlErMft7e0AqKqKaoYIZAhVVdE0rfdx1TgOIKY4AP05FxqapqKpqhVj2xntzLhN2UCJhVFSHqux7mT4xRDQ7zgLGUXGOTvIOGcPGevsMFTjfCxet8cee4zp06f3GW4wZ84c7r//fjZu3MiUKVMGfcyioqIMWphbbC1sZ82axaWXXsrYsWPZuXMn3//+97nwwgutThsNDQ29aq25XC5KSkpoaGgAoKGhgbFjx6btU15ebj3Xl7C97777uPvuu3ttb2lpIR6PZ+r0AP1L19HRgaZpOBzJXD5XWxtFQERNlu5waaAmYrQ0N+PW9JnVgdYDNBc0c7RREO4gNaiktfkgamLoij/3N85CZpFxzg4yztlDxjo7DNU4d3R0HH6no4yXXnqp3+fOOuustJJf/ZX/WrVq1YDvsWHDhrTHe/bsGax5OcfWwvaKK66w/p48eTJTpkxh3LhxrFq1igsuuGDI3veOO+7gpptush63t7dTXV1NcXExwWAwo++lqiqKolBcXJz+ZW7Xk980lxtIhiI4FCgpKaEovwgAxaNQUlKSUZuygaIk0h4XBfJhCM+j33EWMoqMc3aQcc4eMtbZYajG+WjP8BeOnKPqip9wwgkMGzaMHTt2cMEFF1BRUcGBAwfS9onH4zQ3N1txuRUVFTQ2NqbtYz7uL3bX6/X2SlIDcDgcQ/LDpihKH8fWZ1kJJcWLCyiahuJwEPDowjccDx+dP7Y9YmwdWhyG+Dz6Hmch08g4ZwcZ5+whY50dhmKc5ZodfxxVV3zfvn0cOnTI6mFcU1NDa2sr69evt/Z5/fXXUVWVs88+29rnjTfeIBaLWfusXLmSCRMm9BmGYBuMhLGEQ49EVVD0i2VURbDa6saPkeSxo7WDmiAIgiAItiGnwrazs5MNGzZYsRy7d+9mw4YN1NbW0tnZya233so777zDnj17eO2117j44osZP348M2fOBGDixInMmjWL73znO7z77ru89dZb3HDDDVxxxRVWbbcrr7wSj8fDggUL2Lx5M88++yxLly5NCzWwJUb1g7gx23QpzrTtZlWEcOwoLfcV7yFkE7G+9xMEQRAEQRgkORW27733HmeccQZnnHEGADfddBNnnHEGd911F06nk40bN/KNb3yDk046iQULFjB16lTefPPNtDCBp59+mpNPPpkLLriAr33ta5x77rn8+te/tp4vLCzk1VdfZffu3UydOpWbb76Zu+66y96lvgCMgO+YontsXQ4jasTw5PpdR3m5r0Qk7eFf699m08FNOTJGEARBEIRjgZzG2E6bNq3fjD2AFStWHPYYJSUlVjOG/pgyZQpvvvnmEduXUwzPrBlj6zJjbc3OY2YowlErbJMe23fzvNz28RPw8ROs+pdVlPpKc2iYIAiCIAhHK0dVjO1xhRmK0Mtjq08EjvpQBDP0wOnl5YDf2vx/e/8vRwYJgiAIgnC0I8LWrpgeW6ONgUsxhG1KS104Bjy2Hj973MmFg4+bP86RQYIgCIIgHO2IsLUrPTy2TkffyWNHb1UEU9gG2JdSZ3Bb87YcGSQIgiAIwtGOCFu7YnhmreQxqyrCseWxjXjyOZAibOs663JlkSAIgiAIRzkibO2KWcfWTB6zYmx1j22BuwCAzmhn9m37vGiaJWwPetPb6B7sOkhMSn8JgiAIQr/MmzePSy65pNf2VatWoSgKra2taX+nPmf+Ky8vZ86cOezatct6/ZgxY3jooYesx5qmccsttxAMBlm1ahXNzc3ceOONTJgwAZ/Px6hRo/jud79LW1vbEJ/x4BFha1eMJLG47rDtLWw9urANx8PE1XjWzftcqAnMzmqtbr10W5nLj8fhQUPjQNeBAV5sAyKd0LIn11YIgiAIwhGzbds26urqeP7559m8eTMXXXQRiUSi136JRIIFCxbw1FNP8X//939MmzaNuro66urqePDBB/noo49YtmwZr7zyCgsWLMjBmfTNUdVS97jCCEWIW+W+UoStplktdUH32hblFWXbws9OSqmvVrcHYlDizCPPV0ptRy31nfWMCIzIoYGH4beXwt61cMN6GDY+19YIgiAIwqApKyujqKiIyspK7rrrLubOncuOHTuYMGGCtU8kEuGb3/wm7733Hm+++ab13Kmnnsof/vAHa79x48bx4x//mKuuuop4PI7LlXtZmXsLhL5JDUXQUjy2AJqGy+Ei35VPOB6mI9pxlAnbZHOGVqcLYlDo8FDor9SFbag+h8YdBk3TRS3Ah7+DC36YW3sEQRCEjKFpGlpMzcl7K24HipFXky18Ph8A0WjS4dTZ2cns2bPZt28fb731FtXV1QMeo62tjWAwaAtRCyJs7YsRchBTFNBSqiJYzzko8BQQjodpj7XnxsbPSkoMbasRDFOsePD6KwBoCDXkwqrB0dmY/Dt0MHd2CIIgCBlHi6nU3fV2Tt676p4voXich9/RYPny5QQCgbRtfYUU9Ed9fT0PPvggI0aMSPPW3nvvvRQUFLB161aGDx8+4DGampq49957bdXNVWJs7YoVimA2aHAnnzO8uWacbUe0I7u2fV7MUASnl1Yj1rZQcVEZqARsLmxbPk3+nSpyBUEQBCGLnHfeeWzYsCHt329+85vDvm7kyJH4/X6qqqoIhUL84Q9/wOPxWM/PmDGDUCjEf/7nfw54nPb2dmbPns2kSZNYsmTJ5z2djCEeW7tihiLQo9wXWN7coCcIHM3C1kM7+nkGFScV+brH1tahCB0ptkWOsnEXBEEQBkRxO6i650s5e+8jwe/3M358ep7Hvn37Dvu6N998k2AwSFlZGQUFBb2ev+CCC7jxxhu5+OKLUVWVpUuX9tqno6ODWbNmUVBQwIsvvojb7e61T64QYWtXTI+tA0j08NiqR7nH1mzO4HQTwqjyoDkYnq8veTR1NeXKssOTKma723l518t4nV6mj56eO5sEQRCEjKAoyhGFAxyNjB07lqKiogH3mTFjBi+99BLf+MY30DSN//qv/7Kea29vZ+bMmXi9Xv785z+Tl5c3xBYfGSJs7YpZ7sv02KYlj+li0KyMcNQJ2xSPbafZSQ0Y5hsGHD3CdkO8je+9+T0A/vv8/2Za9bQcGSUIgiAImWX69OksX76ciy66CFVVefjhh2lvb2fGjBmEw2F++9vf0t7eTnu7nuczfPhwnM7cTwpE2NoVLT3G1tmHsDWbNLRHj9LkMaeHkKbX4A1oMNyne2wPdR8ioSbSE+bsQkpDjJWOCKDX4V2xZ4UIW0EQBOGY4vzzz+fll1/m61//Opqmcdlll7F2rV4ZqGcYxO7duxkzZkwOrExHhK1dMUMRjIcuZ2rymEp7UxfBzSdQFCs7ej22Lg+dKcK2OK8YBQVVU2mJtFgeXFsRSU4iPnFq1t/vN76fC2sEQRCE45Bly5b1uX3atGloxopv6t99Pe6LPXv29HnMzs6kU+dwx8g1UhXBrmj9V0XQEgn++qtNONaV80+bFhNqi/R5CNuSEooQ0nTvrV9VcTlclOSVADYOR4gkv9y1KTX76kJ19mxvHI/Cr6fBkxeBptHa3SotiwVBEIRjFhG2dsUIN0govWNsD+wN0bRXF1HeRD6u7Tb0bA5EIpk81qkawjahn6+ZQHYwbNMasUaMbRSoc+mhEmZXuB2tO3JlVf8c3Ap1H8DuN1i3Yzn/8Nw/MPvF2Udf+IogCIIgDAIRtnbFCkXQXf4uhwuMkl97t6eHHvj3VmTXts9LqsfW+NtvnK/tE8gMr2yTy4mmKLgdLqaWTwVgb8feXFrWN02fWH8+v/UZVE2lPlTPa5++lkOjDk9CTfDqnlclxEMQBEE4IkTY2hXDY2vF2CouUPTL1bS/C4Cyc3RPYX5bCZGueK9D2BZDzCacHrqsUARd2JoJZAe77O2xbTIyP4d5ihhRMAKAfZ2Hrx+YdVKE7fr2Xdbfb9W9lQtrDk/tWmj5lN9u/S03r76ZBa8usHfDDuCNfW9w9V+u5oMDH+TalMPy2qevsa5hXa7NOCxtkTberX+XuGr/37Vtzdto7W7NtRmHpbm7mT1te3JthiAMOSJs7YopbK2qCE5L2DY36jG15ScFaPMeREGhYWdbbuz8LBgxnt0p4RW+hH4DMz22tg1FiIUBOGQI21JPASMCurDd37E/Z2b1S1j3fIcUhQOJsLV566GtubKof5p2wOMzYOkUXq99HYC4GuelnS/l2LD+iakxvvfm99hwcAP/b+X/Q9Vy02N+MKypW8OiVYuYv2K+7cXt4lWLWfDqAu59595cmzIgq/au4rKXLuPi/72YQ12Hcm1Ov8TUGN/667e46E8X8Yftf8i1OYIwpIiwtSs9qyI4XOBwomoO2pp0YVg2Ikh9cCcAdZ+05sDIz0hcF+ZdTl3YKppGniF2TWF7qNumNwnD9ian/tUZ5k4Rtp02FLbd+oRnj1sfa6cRzlLbUUsoFsqZWX1Sp4cdxIFNBzdam23pCW2vg6cuZufaR6yqJF3xLrY1b8uxYX1waCd8+nbaBOF/d/xvDg0agHAzu1t2WcL7j5/80dZVX37/8e8B3Rv6yp5XcmxN//x939/5tF1vB/7klidzbE0/dLXk7K1V1b4TUkHnSCoxSLkvu2K11NXRY2wdhNRiVBUcDoVhw4tpKNjNyQfPoWFXa85MPWKMUIQupwMSkKdpKIawtX3yWEwPA7E8tq58S9jWddblzKx+MYRtnVHB4dRhp1LbXktLpIXa9lomlk7MpXXptOvj1+ByEtOSS9CbmjahaRqKsXphC569Gva/x5YD62B4qbX5/QPv22tMVRX++0wAPp5yrrXZlh7brcvh2blsrpmXtnl943p71YhOxOGJWWiKwkf5Xdbmt/a/xdyJc3NoWB9s+V9Y8QM+mnqxtWl3224aQg1U+G2Um9HVivKLSRSWTYarnof84qy8rcfjweFwUFdXx/Dhw/F4PPb6nREAXdQePHgQRVEG1bpXhK1d6Zk8pujJY50JXfj5i70UeoM0+fW4zqb9nfa7+feHIWK7jAYMPk2zttk+xjbeDUCHUVc46PBYwrYh3EBMjeF22KdntilsDxgVHMryy9DQaDnYQm2HzYRtyx4Aao0frip/FXWhOlojrbRGWinOy87NblDsXw/ATk/6td7VuquvvXNH40cAxIDdHckY8LpQHa3drRTlFeXGrr54VheFn3z8IhQVWpu3HNpiL2G7fz3sW8dBp5O2USOszVsObbHfb/Bz3wJg+85X09ZnNx/abC9hu/XPKPFulO5W8Aaz9rYOh4OxY8dSX19PXZ0NHROChaIojBw5clCdzUTY2pWeyWMOFygKnQl9qT5Q7MXtdNMVbEMlQTQMnS0RCkrs1bO5TwyPrRlj61M1a1upT/d+NXU12e8mAZawDbn1jmN+xckw3zC8Ti+RRISGUAPVBdW5tDAdQ9hayW6GrRsPbrRfFYeQPpnZZ3iXTyw+ERWVhlADn7Z/ai9h6/ZBLEy9YevkYZPZ1LTJfiXfDGFb53IRRyXPmcfw/OHs7djLxy0fc07lOTk2sDd7jInNmOAY9rTvYWuzzeLBa9cAsMsI76nwV3AwfJBD3Yc42HWQsvyyXFqXpDtZ0m+PojsOzMni1kNbuWDUBbmyrDe73wAgMn42viz/5ns8HkaNGkU8HieRSBz+BUJOcLvdg27XK8LWrljJY/pDMxShU9WFX6BYF7B+r49W3wFKuio5tK/zqBK2XQ795PI01dpmemwjiQgdsQ6CnuzN3gdFzBC2Lg+g4seJoihU+ivZ077HtsL2oPGDMNw3nGKvLhBtJ2x72FqWX2ZNFna37eb0stNzaFwKqmrFWjcYtp474lw2NW1iZ9tOe03IwnqseqPhsa/wVzA6OJq9HXv5tO1T+wjblBhH09aaqhr2tO+htr02V1b1TYdepaPRmNSMCY7B4/BQ21HLp+2f2kfYGhNFDWg0gtrOHXEuz21/jj3te3JnV190HgBALczNb6e5xD2YZW7B/kjymF3pEYrgVJzgcNKt6kIvv8ADQNAb5JBfT1pq2mfDzld9YXls9Y+fHoqgb8tz5VHgLgBsWMtW05IeWyMUwa/pAsZc1qsP1efGtv7ow2NbHdRvHrYTDEbJJDMxb7hvOKODowGsxBdb0NVixcCbHtuaqhocioO2SJu9Eh97CNtyfzmjgqMA+LTDRmOaUi6r0UgqPbvibECfgCVUG3nSjDE94ExOFqwxtdPn1LCz3eGgy5hnfbHyi4ANv/uGrarReVIQPg8ibO2K1iPG1vDYdqu66MsL6D/+Rd4iDuXrsUHNdUeXsO0yvFp5KaEIAMPyjSYNYZsJ20QUjOsRMkR5PunC1lY1V9WEVZ6sw7C30FvIqAL9JlzbYbObm7F0aorwUl8pYwvHAtjLw2R4whLAIUOEVxdUMzIwErBZnK0hGBoMsVieX87oAn2yYCtxY2TEx0iO6Wllp+F2uImpMXtNGLuagZTJQn65PSdg1rXX7Sz2FnFS0UmAbueRZJkPOSH9t171ibAVPj8ibO2K2VLXeGgK2y5L2Ooe2+K8Ylp8jQC0NIZ7HcaWmMljhhchNXkMbJxAZnhrAcJGGEXAuDlU+isBm3lsY8mM7U5D2AbcfkYW6ALsQPgA0ZQJRc4xvcuuZNiELQWDIWzaHQ40Y3JW6C20QlBsVfYtrNuaGt5hT++ibmeTU+/o51KclOaVJidhdhLhphc8dUwLbDimhlg8aCaO5g1jZMFIHIqDcDxsn5UFTbPqbWsibIUMIMLWrvRTFcHy2Pr1pfAibxGthrBtbQijqTaahfeH6bE1HvpSYhYhPYHMVsRMYavQaVwXvyFsbemxTRHinaYQd+ZR7C0mz6nHYttGiGsaRHSPbYtRLaM4rzhNLNrGwxTVJ5Cthmcx4PDgdrjtWc/YEGEthq0leSXWZGFf5z77dPYy7Gw27XT5URTFEuG28thbthorC3mljAmOAWwmbHtc+2K3H4/TY03CbWNrdxsYn0PVV3qYnQXh8IiwtSv9hiLoMbZ5/mQoQnveITSHSjym0tHc3ffx7ITZoMHw2OZpGqgxXdyQ9NjaTtiaQtGVR9jwpecbWbS2FLYx04OvJD22RrJbVaAKsFHt3WintUrRYYjwoCdIpb8SBYWueJd9PExGY4s2M7zDoa+emGNqK2FrhHe0OJOThQp/BR6Hh7gap77TJhMbIxTBstOYeJmC0VZhM12tQHJiU5RXZAlwW8UDG3HLzeZE0ZUPYE1sbOMFN9qUa04PuLw5NkY4FhBha1fMqghairB1OOjWeociaIpKrEC/2R4V4QhmS11DtPtMT5wxa7d9KII7j5Bx8wqoNvbYGh7mRF6QsClsjRJrlQGbhU4YAkwjGb8c8ATwOD1WlrltBKMR4tFqCgZFXz2xZaMOQ4S3OEyvXRCH4mBEgeFdDtllTHvYaUwWzLAZ27Sr1jR9Ekb6ykKFvwKX4iKmxuzzu2WsLFjeeocuGs1VENtURTEn4O783NohHDOIsLUrqlnH1qiK4HCi4egzFAEg5Dc8HvU2a5PaF1Yogn6OPjN8wmyra9fkMUPYxlx5RAyPrT+hi/GKfF3YdsY67dMC1LhhhDx+a1PAqOJQ5beZd9EQi12KQkIxwyb0G521xG8XcRPVv2Omx67Q+Bm1pcfWGFdrObqnd9k2Y2qKMEMsGmNqXvt9nfv6fl22iUdAU4kBHaZg9Jbgcrisye2+DpvYak4WzDFV9Emt7UJmjO8THhG2QmYQYWtX+ghFiGr5aOg/UmZVBLNofVu+Xgfw6PDYGuW+TGFremyN7cN8urC1jefDxPCAht3J5bJ8Q4znu/Mp9OrdkmzjtTVEjdlMwqNqeAxPsylsbLMUbYjwzjw91MapafiMpyyvnV1uxMa4mqEIRcbH1xzTA+EDxFKSIXNKNIxGqrjRJ8RmBQf7jGm6d7HY+J1LFWG2iLGOpQtwh6YRNDplWV5w24yp/jltdvQ/prbATHIVj62QIUTY2hVDgCS0ZPJYd0L31rrc4HKbJVx0YXvQq3sJjg6PrVEVwQi3yDP+t38ogiEUXUmh6E6pKmC7ygiGvR1uPV4xoKnWTcT02NaFbLJsbtjV6dMnB35VRTFEhP1uxOkizBS2pXmleJ1eNDR7TG40DWJhuhSFuFm9wWj3bDvvsjGmVtyyubIQqLJirJu7m3NmnkUPO4OqisO4/uZkwTbeZcML3m58ToNGaULbhcxIKIKQYUTY2hWrpa7+v8vhoksNAODzJXcze73XufYA0HpUeGyN5DHDK+0zbmI9PbYd0Q4iiUjv1+cKI+kt5NaXc3WhmEzWM8MRbCFqIOmxdRnNJFTVErt29dh2GMuRBWoyltF2y9GGra0e/YtYaITSpCbl2cLWRBS0hJU46NQ0vQIJNpwsGCKs02h8UmCMqe1irM0JmPGdCqR8p2wXD2yEInQascBBLV3YHuw6SHfcBsnGZiiCCFshQ+RU2L7xxhtcdNFFVFVVoSgKf/rTn9Ke1zSNu+66i8rKSnw+H9OnT+eTTz5J26e5uZm5c+cSDAYpKipiwYIFdHamNyrYuHEjX/nKV8jLy6O6upr7779/qE/t82OGIqQkj3UndGGblyJskx5b/ce0qyNGd6dNlkH7w/LYGsJWcaZtD3qCeIxYQFtVRjCFonHzzVfVtJJatksgM+ztcBlCXNWSHltDgDWGG+1R8qkvwWDc8OwXY2t47YwQj6JEsh2srbxhUVPY6ILGr6ooxufV9C7awk5IflaNMQ2ovcfUFsLWGNMOY2WhIOU7ZSs7IfmdMppzmImuhd5C/G497t4WKzYSiiBkmJwK21AoxGmnncYjjzzS5/P3338///Vf/8Wjjz7K2rVr8fv9zJw5k+7upJiYO3cumzdvZuXKlSxfvpw33niDa6+91nq+vb2dGTNmMHr0aNavX88DDzzAkiVL+PWvfz3k5/e56KOlbkTVv/jevGSsmc/lw+v0EndG8RXpP2AtDTYPRzDLfWm6oMojXdgqisLwfCMcIWyjcATTY2u201W1tPq7dhW2IevGlgxFGOYbhtvhJqElOBA+kDMTLUyPreld1pLC1vSENYQa7FFKyfTYGrYWxZMTSVuJG1MsOvWJjS7CdNvNiY1tvHamd9H4rBYkkpMt8/rbIinLjAU3w3tU1dpmu5WFqNl10EjGNL47tiv3F5PkMSGz5FTYXnjhhfzoRz/in/7pn3o9p2kaDz30EHfeeScXX3wxU6ZM4amnnqKurs7y7G7dupVXXnmF3/zmN5x99tmce+65/Pd//ze///3vqavTv7BPP/000WiUxx9/nFNOOYUrrriC7373u/z85z/P5qkeOX2EIsQ0/cfU404KW0VRrMoIecP0y9nSYPNwBDN5zPAU5ivGx1BNCgRbNmmwYmz1m69fSy5Dgg1jbC2PjT5xCKR4mB2KwxLi9ri5pYvwVE/YcN9w3A43cS1OY7gxZyZamMLWEAxFKSLMVrGrpggzQiZSJzZF3iLyjbqmtvDaWaEIRqm3hF0nC4adqSsLsfRQhIPhg/YIoYqFUIGQEelVkEhOCm21ChKVGFshs7hybUB/7N69m4aGBqZPn25tKyws5Oyzz2bNmjVcccUVrFmzhqKiIr7whS9Y+0yfPh2Hw8HatWv5p3/6J9asWcNXv/pVPB6Ptc/MmTP56U9/SktLC8XFxb3eOxKJEIkkf5ja2/Uam6qqoqYskWUCVVXRNK3XcRU1gQLEDYHrxElU1ZfpXO70/Yu8RTSGG3EW6zfY5vrOjNuZSZREFAXoUnWB6zVqq6qxiFXmbFieHmd7IHwgI+fS3zgfEbFuHEDIEOJ+VUNTI2jGMc1YwIZQgz3GPxbGAXSYdWFVDTUassa4yl/F3o697O/Yz5llZ2bkLT/zOEdDhq1OUHXBoEbDoKooKFT6K6ntqGVv+14rljlXKNEQCtBurKYEYxHrfCvz9clNXWfdkH4GBjXOEWNMU5b3U6//iMAIPmn9hP3t+xlTMGbIbB0MSiyMAnQogAaBeMw6txF+wxPasS8n36u0sTbH1JqAqagRfUwL3YX4XD664l36mBaOybqtqSixLsKKgjlifhuNaRpR/XdKc/k+/290H+T8/ISsY1th29CgL+eWl5enbS8vL7eea2hooKysLO15l8tFSUlJ2j5jx47tdQzzub6E7X333cfdd9/da3tLSwvxeGbjEVVVpaOjA03TcDiSDvRgtBsPEDOWj0KdIdxx3UuAFqG5OZkhHHDqsbfhvFYgyIF9bWnP242iaBcuIGx4br2aft7tLU3Evc0k4iolLVW4Eh72Ne/LyLn0N85Hgq/9EH6g1fih9Bs3tRbDPl9M94w1hBpoOtSEQ8ltbqavvRk/0JYwm0mohNsO0W3YW+LS+7LvbNpJc3FmPi+fdZytsTUmcgFVpbP1IFHD1jJvGbUdtWxv3M44z7iM2PpZCYbb8QCdRox4INplfUYDRoLnvo7MfG77YzDj7DrUQBHQ7nQDGgWqSqi1iYhh13DPcD7hE7Yf2M5E38Qhs3UwFHa14wY6jevvi4St8SswmtLsbd+bk9+11LH2tRygAGgzvtsFqkZ7cyPxPN2uCl8Fuzt283H9xwQTwazbmkpJJGQlDro0DSXUbo1fkaMIgN3Nu3N+r8jvOEQ+0K06aG9v/1y/0X3R0WGTuuJC1rCtsM0ld9xxBzfddJP1uL29nerqaoqLiwkGM/tjpaoqiqJQXFyc9mVWjOXjhOEVKikqoRU9FMGXr4t3k+GB4dAE2jAjBrQ5lva83VCM5gYRI8Y234gBDAZ8JIJFvPjg+wyr/SL/7B1LaNS2jJxLf+N8RBgl1qIeF3SBX9NwqMmxDqp6V6e4FkfzaZTk5/YaGPXY6Xa7IK5Xcch3K+Qb9o4pHQP7oFVtzdjn5bOOs+LS10u73C5I6J6wgNcFpq3FY3iv6T1atczZ+llRtBgJsNoqB2IRig2bTvadDMCh7kMUFBbgNuKxM82gxrlF/wDoVTwiBDQNv8eB3xzTkjG8feBtm4xplAQQMsa0MJH8Xk306qL7QNcBgkVBvQtjFkkba68+1mGXy1pZCOYlP6ejCkexu2M37Up7bsdU01DiXXS4TAGukudQ8Ro2nRg6EbZAU6wp99feaZR9LCghGAx+vt/oPnC5ROYcb9j2ildU6MuNjY2NVFZWWtsbGxs5/fTTrX0OHEhPfInH4zQ3N1uvr6iooLExPS7PfGzu0xOv14vX27tntcPhyOgXzkRRlD6OrX/ZE8b/HqeHuGbUT3Wlz2jNJg2d/kM4GU5HUzdqQrNq3doOs6WuEYqQb9TWdKhxtq5t5GCtXtWiMDKM5vXtOKZnZsz7HucjIKHHpyZDEfQsc8U4nsfhYbhvOI3hRg50HaA8UN7vobKCEU/bacTYBVQVRyIChr1mTGBdqC6jn+vPNM5m/LJhq1/VcCS6h9zWz0S8i5ARXwtQEA1bNg3LH4bX6SWSiHCg6wDVweohM+Ow4xxPrTQR0a9/vI8x7bTBmEbDaWMajHZbNpUHynE73Hq72u6DVnxoNrHG2kzIcyig6oIx9XNqtqvN+ec0HjFKvSXj65V4l/Vbldr0JOfX3iyZ6Mn//L/RfZDz8xOyjm2v+NixY6moqOC1116ztrW3t7N27VpqamoAqKmpobW1lfXr11v7vP7666iqytlnn23t88YbbxCLJZMRVq5cyYQJE/oMQ7ANZlUEM8bW4SSm6p5Ntzs9Zsgs+dXiOIg334WmQduBLmxLPIIGdBuhCHmmB0aN8ck6fdJRcJJRUP7TUUS7bFCOCpKdxxTdi65XRUjPKDcTsmyRQGYmupiexZSseEhJdrNDLVsz0c1YoShQ02sEm12dbJEZHw1Zkxu9m1s8raKHlUAWynFijpmQZYibgpREJ7BfopsZC+5RNTwpdjoUh31aAJuf05TJYtrn1C6VEcyyZCnx9anX3rSzNdJKKJbjKjrm+7v9A+8nCIMkp8K2s7OTDRs2sGHDBkBPGNuwYQO1tbUoisKiRYv40Y9+xJ///Gc2bdrEt771LaqqqrjkkksAmDhxIrNmzeI73/kO7777Lm+99RY33HADV1xxBVVV+g/hlVdeicfjYcGCBWzevJlnn32WpUuXpoUa2BKzKoLxv1txJ4WtK13YDsvXE62aupooKtczS21dGSERI6qAZoiYPCMUIdYdo35HGwCnXFRKs68Bp+pix/s2KEcFSQ8oyRhb4t16hycDUyzaouSXYW9IS7E35SZsNWkI1aNqau/XZxNTMGjJeODUihO2agEb67JiFwPmuPUhGHNebcKc2FjlntS0iY2tatn2HNNY+u+XbSojmGXJSMaCp9pqCdtcT8CsutBmqbd0OwOegNUCPOdjalZFkHJfQobIqbB97733OOOMMzjjjDMAuOmmmzjjjDO46667ALjtttu48cYbufbaa/niF79IZ2cnr7zyCnl5edYxnn76aU4++WQuuOACvva1r3Huueem1agtLCzk1VdfZffu3UydOpWbb76Zu+66K63WrS3py2Ob6FvYmi1oD3QdoLjCFLY2rmWbiNKdkljldeohFgfrE6iqhr/QQ3VVBduHrwNg+7s2EInQSyjmm6Kmj1q29vDYmmJR93j39NiV55fjVJzE1BiHug7lxEQLs45tmq29PWG2qLsaC6eLRUj3hvlt0qTBHFPFtFXrU4C3RFoIx3I4EdY0iIYs72KBquql/1JKftmmXa1ZG9YQtgVaD09ogV0EuGFnasOLWPoqnm1KfklLXSHD5DTGdtq0aWgp3q6eKIrCPffcwz333NPvPiUlJTzzzDMDvs+UKVN48803P7OdOcHy2OoC1+1wE1f1WFRXT2FrNDNoCjdRXKEv59jWY6tpkIjQZSTHuRwu3Jp+XgcM/Vo+tpBSXyl7SjdyTu1F1O9oI9odx5OX45BwQ1CFU5f2QW8R7M4j2h2npG4MhV1lNqm3aghboz6wHjqRvLm5HC7K8suoD9Wzv3O/9TnKCZYI123tKcLMuqvheJi6UB0nFJ6QEzMBXdh6zVrGxpp03MYeWyN0JthD3BR4Cgh6grRH29nXuY+Tik/KiZn6xFCjUzGXzVMmC0bynW1CUcwxNWpwFyT69oK3R9vpiHZQ4CnIvo2QDEWwug72LWy3HNpiCxEeAxrVbuKxTkqwb+KzcHRg2xjb4x5Vb82gkmypG7VCEdK7L5X59JJnTd1NFJbr3mzbemyNG0K34UXyOX1ghCI0H9K3lYzw43Q4cRYmaPM2oSY09m9vzYm5acRMj61+Dn416bFNJFT+9PMPCP+lmH/58HbCu5X+jpI9LGGrxzL3dXOzTVMJSzCYIjw9FEFRlKQ3LJcepngU1Hhy2RzjOtsxdtWMse1n2Rxs0gLY9C46UjzL0GdMaM7H1PycmhMwLf07le/OpyRPF2Y5tdVqzqJPDIIDXPucj2k0TK3bxYUf3s/c/5ubW1uEYwIRtnZFjZOaMuVyuIgndC9Rz1CEkrwSHIoDVVNxGE0aWhvDaGr/3vCcYXYdM25iea48yyvT3Kx/HEsqda/zcP9w9hZtBaB2c46XyiEZimCIL7OaA/EI295p4GCtXi/RqbkY++GXUBO5jls1bsJGNYeeN+FIOMYJbVPwxH028C4aN2KjY1OBlh6KADa5EZsxlqYIM39C+4qxzXVHL+P6t6fFLdtwTA3vohUPanrB+/CE2kGEqSQniz1jV8Emcbbm59RlttPW+vTYgg3GNJast+t3SQKZ8PkRYWtXNJWYkvT66eVudCHldqZXCXA6nJTm6S1oQ75WHE6FeFSls9UGbR17YsSjmh7bVGHb3q7/CJsJcBX+CvYVbgeg7pPWLBvaBz2EbcCM5IlH2L5Wj6M4ZUY5Xa5OAt3FfLIhx7HB8W5iJOsFpwqbUFuE393zLsNWncHlG+6goSHXMbZdRIFomq3JG/HB2g7G7vwipaEqW3jCzNa/AZxp2wGGOyvwRwo5ED5ALKVNdNbp4V3sU4Tl20Dc9Ex0UnqPqSnCmrqachtjHQsTVhRMl4FtBaMZC5xS7otYOC3R1RZ2AsS6CBnCNl/ibIUMIMLWrqhx4inC1uVwEUsYMbbORK/dh/n0ygiHIk0UDtc7YLXU2zAcwUgI6TLi6fJceeBwE9M8dHUbZYlK9HCKEYERNAR3AtBcF6K7M4ciAZKi0PA6+40QimgoTJ1RzeGMr4xle8VaADa8/mkOjEwhFrY8IWDE2BrCZv1f9hAyJj7+WCGOt6tyYqJFSrknMG3Vx/vg3g7+cP96vOtH8k+bbqLp085cWZkUDC4jKccsVWeI8L1bm3lpyVaufv8epn46i8ZQDmOto2E0kuEdqSJM0zTeeHY7vifP4Bsf3UjDwYO5s9PwLna4jXhQs7OIYWvTvg7+ev82rn7/bkY3n5LzsAmrmxcOvCnJY6qqsfp32xj9p+l8Zdc/s68t95MFM7yjQE1PdN27tZmdv9K4dOPNdDbGBsx1GXKiYTqNe514bIVMIMLWrqhxUmWcA4clbHvG2AKU5etxtge7DlJcaeMEMmOpudvwzpgxtp0JPXHJnefEm6/f2Kr8VXS7Q0SDupCp39mafXtTiXWjAmFVP4d8h34OjbV62EdBaR6Fw/NpPmEXAE07uwi3R3NlLcS6rSVzn8Oj+5fjERIxle1GveCRs9xoqATrqzi0P4eCMaXck9/h0f2ghlh896XdJOL6jdmluSl4b3zubsTGxCBkrDIEzHCUWBeJhMrrT20lHtVtnbp/Jls/rM2JmaZNXYpidS9M9dju+uAgm/5vH6gKVR3jCa6dkFM7AToNL3iBJWzDqKrGq7/ZTHNdCH+kiOmfzGNn7d5cWQqxrmT1BqdHj7A2xnTzG/v5aPV+lC43pzSeS3RdDlvqmqEIqfV2AWJhukMxVvz/PiJ0ME5ZaBTTPrqK5s7W3Nip6ZNty2PrEo+t8PkRYWtXUjy2bocbNa6BkajidvVuWGB6bA+GD1Js1rJttKOwNbqOGcJAD0Vw0WEI24KSPBTjvM1YxeYiPVbN9IrmjHg34RQvuumxPVini9eKsfqNrGiYn8bAHgB2bcilJyy5xBdw+axtjZ+2EwnH8RW4OW1aNbtKPgRg4//lMiYwWULL7zTK+cW66eqM8ulHepjE1G8PI65EKWypZN/HLTmzE6DDiF30G5MbYt18uukQnS0RfAVumsfok5s9q3I5WUjGLjpx4EvxLprXethJeagkGN54ghUjnnV6NJIIWGPaRe3mQ7Q0hHHnOYkE23GrHvaszpGdANFQMr7a+px2oWkaH76mC25fpZEEu3083aEcrTKZKwtGRYyClJCZj9fUEwnHyS/00O3uJBgZxvo3duTGzng3oFmfUxG2QiYQYWtX1AQxQ0O5HC5ikaSX1uU4jMfWqGXbasfKCGbymOGd0YWtJ03YmpjCttb/MQD1O1qzaGgfxLstoehSXHhduq3NjfpEo6RK95RX5FdYYnF3ToVtcnnfb94w4hEadukThMpxRVQWVLK54i0AdrzfaHlGs06Kx7bAEuFh9m9rRVM1Skf4mXLaeLaWvwPAh6tzFOZhemzNbl6OPGv77g/1a33SFytwfOEQCSVBdJ+LA5+258RUfUzNJV6f4V3UVxHMmPXzr5rIzmEfAPDuKzkSN2YogtOYhBl1rYmF2bOxCYCTz65A/aq+tB/ZmkeoLUf5AynfqdTPaXN9iLaDXbjcDs77txNoyt+PK+Fh06ocTRat8nlGvd2UycJOo+HNFy4cQ93JGwHYvbodNRfJxtakRkIRhMwhwtauqAnLY5sqbF1EcNBb2Jo1SA+GD1Jk1LJttmMoghHj1WUKW6ceY9uXsDWTGz7J00XiwU870gR+1ol1Wf3s8935KMYNuLlJv3mUVAUAqAxUUlu8GYD9n7QSj+bA5kQMtITV+rXAo9tGvIuGnbqwLT8hiNfpJVbeRsjdRjScYO/W5uzbqiYgEUmW0DITSOLdNO5OivB8dz71I/QqGXs/aiGSi1bL1o3YnDDkWbaaJelGn1rKyMoKdpVsAGDb2hwlEUZTRJjZrjQWZt82/RqXjgwwvKyYPWPeB6B2Y0tu2leb8aDG711BiifUFOAjJ5ZQOa6IhsBuFNVhtd7OOqmhCOZkMdZFvWFnxbhCRpZWsalqFQBb3t6fm7AZq0OaURHDWF2KdHTSuFufaI09bRiuiZ10O0PE2xX2b8/BKohhpxnaIx5bIROIsLUrapwYyVAEU9C5Hd1W84ZU+uo+1tUezd1SWH+YoQiGx8usimAJ29KksA16guS78unwNpNX6ERVNRp25zAcIR6xhKLf7QdXHqrmoKXZWHqsTHpsW3yNxHxhEjGVulx4mnvUBvUbwkaLRWgwbmyVJ+gtNSsLKthVaniYP2zKtqUpiS6msDVEeKybhl26reUn6GEe/konzb561HiOvOGmJ8z45TRDPLo7I3Qc0pPdysYUMKpgFDuGrQdgx/oDufGGpYQiBCxh282BT/Wl/Kpx+vX3Vzhp8TWgxmHnBzkYU7Pcl7FsHjAmC+H2LitPoGp8EdUF1Xwy/D0Atr+bA2FrdEjrPaZJAV51YhFuh5vwyEZijgidh6I07smBxz6qt5Exuw6aYRMH94bRNAgOyyNQnMeIoip2lW4A4JNcjKlVZUQXtuKxFTKBCFu7osaJp4YiGF4/l9KPsE3x2HryXASKDW9inc3CEaxQBF3Y+lx68lhI1cuVmXaDXpS/KlAFCvhG6je9+lyV/dL0rl2hVKHo8tKeKCMeV3C6HQSNahSVgUpQoLFEj7PcuyUHXlDzhmEumXt0YdgV9dLVHgUFho/SuyJV+av41PAwf/rRoex7mCyxaHoXdWGbiEWtuM+KsboIG1EwwhLh5jJ1VjE9TMbDgOFhOnhAH+fgcB/efDejg6PZW/QxEVeYcFuUhlwkPqZ4FwNmB6x4F03GmA4zr39BFZ+kiPBc2AnQYSa5GWNav18f05IqP3kBNyMCI9hZ+gGqkuBgbQdtB7O8IpWIgpboYwIWTgrb8UUAVBSXsaf4IyBXYxq2fqsgOaYH6/TJ17Bq/dqPCIzgk+H6td/5wUES2a69bdUw1lfwfGZ4hyB8DkTY2pWUUIQ0j63SDVrvpe3y/HJAr/MYS8QoHan/6OY0070vzKoIpsfWqXtsw6ouXHxBT9ruZjhCrEL3etTvzJHH1hDkZoytKWxbE3occFFZPg7jRjI6OBqA7X49drE2h8K20yih5DeEjWlvQUkeLo9+DaoCVdQHd6A5E4RaIxzan+XJkFlv1WXaqn92W8IlJOIq3nwXhWX6DW9EYIQlwmu3NGc/JthKyjG6eRleu4NNuu1lhlgcUTACzaHyaZFu655NOagTHA0TMpf3jYmNpkHTXl3YDk8RN7tLNgGwf1tL9sN9zLhls5GEIcKaDumfz/Ixuu1VAb1KSl2BXgJwz8Ysj6k1WTTHVB+/roiTUJv++1Bm2DoiMILdxgTs01xc+1jYWl1yO9x43fr352C9Psbmta8KVFFfsIuIJ0y0K059thN0zZUlw9ERcAWy+/7CMYkIW7uixomnhCLE04Rt75t5aV4pec48NDTqQ/WUjrCrsDXq2PboPNZtCttAurA1E8hai/SWr42723PT0cu4qYV7eGw7+wihqMivwOPw8GlwCyi61zzryS5W0XujLJVXH9/WuCHEy5OxbKMKRpFwxOkYri9FfvpRlj2hPWwt8Bi2RvTWpEXl+ValjBEFIzjo30ssr4tYJJH9xh2WCDOErSFuDrbowsH0gnudXir9lWme8KyTUnPVvP4dieFEuhI4nIqV7DiiYAQtvnqi+SEScZV927IcaxkNkQBCZjyoMbFpbdV/C4qNnAGfy0dpXqkVv75nU7Y/p2aSm9Gcw5gstISLAX2y6PbqAm1kYCR7Cz9GU1RaG8O0ZrtCTWp8tacADE9ok+E8HlYdsOxE0ag1JmCfZn1MjclCaoiXIHxORNjaFTXeZ1UEt9INam9hZy3bo3eSKR2h/0DYT9gaoQgpDRo0xU23qv/Q+grcabtb3XFcO/H49HHIukcRrKS3TqMrkhlj21dssNPhpLqgmog7jK9cv4hZL08VT+8VH/AUgOKgLcXDbDKmcAwAe4r0pdOsizDTY+tMF+FtMb3SR6qtIwIjQNFoHGZ67bJ9Iw4TA/SKxsnl6JYO3UZTLAJUB6vZW/QxKBrNdSHaD3X1OtyQkYiBGktWxfAEwOHiUHwMAMWVfpwu/bnqgmpQoL70EyAXgrErbdncGtN2r2FryvUvSHrs6z5pzW6yW6zHd8prCNtu/TfAzG0w7Yy5InQM0yeL2R/TcHrYlDuPhOaitVW/5qbHtiJQgUtxsatok2Fnlr/7ZiiCmZQryWNCBhBha1e0fqoiKJE+PbaQ3iLR8tjWhdBykbjSHz1a6vpcPiLxPDSjzmKeP13YVhdUA/Bp6FMqjASinDRqMIRiyPAq+t3+9DJlxXlpu5vhCOoIfdk3614w6yZsLPF5CsCVl+KxTcayjQmOAWCTTy+l1bCrPSeCwVqOzCsCkmETqbaODIwEYHtAz+T/dHP2l6NDKR3S8r0FaBq0hXVBa3b9AxhdMJqoqwutXBfuWV2StsqSpSybu3y0JSqA9MnC2OBYALYE3rXszGqcdSyUvmzuCaBqDlo7dRtTBePIwEjafAdRimKoCS27VTyiZnMOw2PrLQKgJVpm2Jmc1Jif09riLUBuhG1aLLDbR3uiHE1TcHmd5Bfq3nC3w83IgpHsK/wYxUH2vcvmpNZsJCGhCEIGEGFrRzTNCEXQ6R1j27ewTfXYFpXn43ApxLoTdDTnsLd6T8yqCIawzXPm0RXTRaHHFbW8SCam6NrTtocKI4s763FgYLV3DZtxoAN4bCEpbJtL9TqW+z5uzrJYMOMBU25urry0mGCTkrwSgp4gHXmHyC91oqladoV4D1sL8vSlXVOEF6bYWumvREFhd8FHKA5oO9BF28EsekJTCvT7XD7cbj9daiHxhBsUCJYmhe2o4CgAWsr1z0BtNkW4GQvsSFlhcOfRbgjbVAFell+G3+1nX3AbDrdCqDWS3aTT1BJaxgSsIzGchOrE6XJQkDKm5uS9q0pfU8/qxKZnvV3jc9oS10VsUUWPlQXgI78+Wazf0Ua0O7uTRSsMxRPQJzXx5LVXUhrNjC0cS8wVwVmlOx2yO6aGsDVWQCQUQcgEImztiCFcYykeW7MWan/JY5D0Euzv2I/T6bA8CE37bBSOYIQidBm/q3muPLqi+pKjz91boFQXVONQHITjYfL106N+R2v2M/etpX3dW5Pvyk+PsS3pW9ju9m3G4VTobI5kV4D1KKHl9/jRnHm0J3TvUjBF2CiKYoUjuEfr1yernrCepcnMG3EfItztdFPuLyfmilBQrV+LvVuyeSPuSk8gdOfTlqgEdK+90538SR1VoAvbnUE9iWjf9tbsJbuZHlszbtldAO50cWOiKApjg2NJOOL4Run2ZVXcRHsum+fTktCFYVG5z0rKhOT3am+R3rSldnMWJ4w9qneYwrbVsDXVszzMN4x8Vz6teQfIL3WhJjT2Z3OymFaWLADuPMtbn3rtAU4oPAGA9go9j6F2c3a94CoQMoSthCIImUCErR1R9Zl9X6EIA3lsRxQYoQghvUPPMCMcobnOfsK2O0XYdkfN9rq9hZ/b6ba8Hx1FB3E4FEJtUatmaNYwPLYhZ9IDlnDkEVL1m1ugxJu2u+mt2xPeRYVRLzarcbZWUob+sMBdQNRZRFzTBXigKN1e0zPeUa7HBGa1RJkpGHrY2mUkFJoVEUzMz4Myyljiz+aNuNcSb1IwBHsIhnFF4wD4SH2P/KCHeCSRvaoeVra5meikTxbaE+V92npCkS5uuir1JfOsiptYqNeYJpMy+x7TD11rcLkd2fUuW8vmRkvdvEI0xU1nQi9VGByWPlkwBaM5Wcz257SznzCUwmF9X/s9hXqMfd32luw1lYmFCSsK5tREQhGETCDC1o4YwtZsreBSXMQiupgdVChChy5szTjbpn02qmVrClvjp8zn9NEV0Zf3fa6+7TRF197uT63am1kv+xU3qyIYcaDuAKFoARpOnI4E+QXp1RxMm+tCdVSepMcGZ1XYxtNrg/rdfkKaLha8eVilvkzGFupxlnsLPsbhUGg7mMUlfms50ijQ7wnQqVUatip48lxpu5uC4dBwva3u/m0tWfWEmiW09PAOH21x3da+BLjX6SWiRig5Uf98ZC0coUeHtIA7gOryJT32w9JXGMzrX1e8HdBXRbK2dJ7aTtkQYaGEXhEjta41JK99U+wgw8frv29ZE+E9G0m4A3Q5ylDRw1DMuFUTU4S3l9cZdmYxdjllTHuGofSc1Fgx1uoH+Iu8xLPZVCalcofL4cLtcB/mBYJweETY2pEeHlu3000som9zKRG9BWkfmKEIh7oP0RXvsmdlBCN5LGKImDxXHl0Rszh330kL5vLjnrY9VI7XvXgN2Ra2psc2paVuKKovm/m9XSgpy6WQXIpUNRVXtX7O+7e1ZC+Rz/TYmkXvPQWE1GG6vf7eItAU4rvDO61Y5qyFI1gF+o2+9u4CQugCzN+HA+fE4hMB2OH4CF+BHn+etc9DNHkj9ntMwaDb2tMT5nQ4LSGmjtSTCLNW07hH8ljAE6BT1UWYw6ERKO5b2H6ibiY4LE9fOjdaBA85qWNqiLDOPhq2gP69Mz327tH696o2W6EosS40kvGgAXeATkWf1OT7HTid6bfT8UXjAdjt34zDpdBxqDs7iVlmhzQlNb6+7zAUSF77pu4mKifqjoPsTRbCKY1ZCtJifwXhsyLC1o4YwtWKsU3z2Hb167ENeoJWqZy6zjqru0zrgXB2ExcGwqxja9wc8lx5dHXrwjbP2bcAN394P23/lEozgSzblRHMqghKMhYwbAjbfE/vm5WiKNaN7WBgLy6vk+5QjKZsTTJiYeMmnLDsNb1gAwrb9t2MnKiHV2QtHCGmt/80PxO6CDNEeKD3RMAc10/aPmHUJF0AZU/c9IhddPmsrnn+HuEdkPTaHSjZDQoc2teZnZrGZihCine5M6GPaSCgpsWtQvI7trt9N9WT9M9J1rzLfSybm8v7PUNmIOm17SjXY0LrsuVdjoXpVhRMt0KBp4BOTZ/UBIK9dzev/Y7QdqsjWVYEo9EhLdULrrny+qy5Dfr3rcynn4drdLdhZ/avvSSOCZlChK0dMYSt+VOdHmPbf7kvRVEsb8a+jn3kBz26x0ODg0Z/+JxjhiIY55DnzKM7on8MfY6+bbQ8tu17qBxXBOhlzCLhWJ/7Dwmmx9YsS+MOEI7oN918d98hFKZn8ZP25I0ta+EIsW4iikKc5LJpZ0K3wZ/fe9xGF47G7XATioXIG5MwbG3OTjOMWJd1czNtDamGCM/vLVhMYbu/cz/lE4zl6KyJ8KStyXjQvr2LkBQ3OyPbra5kWfGEWzHWKeEd5vK+v/f1ry6oxqW4CMfDFIzTv49ZWzqP9fbYhgwR7u/hWYYUTyjbdO9yXKMuG97lFBHmUBz4XD5Cqi4WAwNMwPa072HExCIgSxMwM7QnRTBGtABx9M9nX5OFsUX6xKa1dD+KQ6GlIUx7UxZCkVKbiHgkvlbIDCJs7YgZY2vEc7qd7mRVBEf/MbaQLLa/u203kGxH2fhp+1BZe2SYLXWNyg55rjy6ugYWtqY3cV/HPlx+YylN0+utZo14+tK+3+0n3G0K2769sJawbf2EkSfrXtCsZUbHwlaSi4Kih07EdW+3Py/aa3e3w530LubX4vW7iHYnaNyThQlRSjyg1+nF7XQTShhJeX2I8OK8Yob5dOETrWoBBZr2ZskTGk2/EWvOvKQI70MwnFhkhE207kjxhGZB2EZDRiOJ5MTGuv6+vq9/qrhxOBXam7ppO5AFcRMNpy2ba848OtT+PbbWZKF9Z9JjnwUPo5LSzcvv9qMoihUy4c/vHR5W4a8g35VPXI1bYRP7t7cOfWKWGV9tJLoWeAoIRXRvaJ6ru1d8PSQ/p590bbPqhWdlspj6fXKLsBUygwhbO2LG2BrCVg9FMBs0DCxsxxUaP/ptemcms3f5gWwIlMGQiKECkdRQhC6zpm3fcZJl+WUUeApIaAl2te2y4myzGo5gemzNsjTufELdRrMGZ98C27pZtCSFbd0nrSSy4QWNd6d5wRyKg1BM9xgGfH0LwJOKTwJge9s2qk/WRVhWSmnFet/cOmP9izBIesNqY7uSntBs3Ih7eBcjcW+/lSYgKcL2tCW9dnu3Ng99rHUsnNZIwu/2E4rpvwWBvL4rikwsmQjAJ6Ft1ndsyD2MmpY2pgWeAqKql7imx4H6+/CCm9d+Z+tORp2if04/zdK1NxtJFLj1z1xn3JiA9eEFVxTFuv4N3lr8RV4SMXXo20Bbnfz0EC+/209nxBhPT9/3gYml+rX/uPnjrE4W9CojKSsggpABRNjaESt5LJktagpbj9Ldb/IYJEu37GrbBUDZaP0H+MAeu3hso1ZzBjBCEYwQVZ/St7BVFIUJxRMA2Na8zQpHyGqjhrieOBJKiVkNdxk1bfsR5KbHdn/nfnxlCnkBPdHpwO4sXIuUeqvmEl8oov/fV0wwJIXtJy2fWN7FbC2bpxXoB0uE+/P69hhacbatSVuz4mFKETcBd4BQWP8MeJUOXK7eiS9VgSp8Lh8xNUZ3aQuePCfdnTEO7h3iiWaKYPC5fLgcLjqj+vX3e/u+/qnfsaS4GeIxteJBk8vmnSF9wuh1dOLuw7s4tnAsDsVBc3cz3uqE7l0+2EXrgSFOzEr5nPo9ugc0ZEzAAnl9TxbN34BtLR9bInzIxzSWXhGjwFNAKKxPEPzuvn97Uq999SRdrO/LRrWR1O+ThCIIGUKErR0xGzQ4km0mj9Rju6t1F5qmMXy07qXpaO6mq6Nv71dWiacLW6/TS1eXUfpLae33ZRNKjB/elqQ36cCe9iyWeeqmW1Ew3y3gDhAO69cn39F3eEHqkvnO9p2MOCl5wxhy+vCEhKK61ybg7Tsm2BS225q3UT1Rvwk37m4f+ljmniW0gE5j6TTQjwg3BcP25u2MOkUXYXu3NKMOpSc0EYdENDmungAhIwol4DwE8d6eUIfi4OSSkwH4uHUrI0/OkrjpY4k3FNGTHQPevkNnLDubP7bGdP+2FuKxIVw670uEhYySeo6+PYb57nyrRFWad3nIBWOy65zlsY0aXnBf3xOwSSWTANjSvCV7iY5m69/UxMEuvRRZwNX3b88JRSfgdrjpjHUSKW7Tq410J2jYNcTOgx7hHYKQCUTY2pE+PLbpncf6F3Ojg6NxKk46Y50cCB/A63NZHXEa7eC1jXfRbdwcvE4viahGwsgPytP6/8E3PQrbm7dTVJ6Pr8BNPKbSmA3vJ0C827pRKCj4XD7CRiZZvqP/G2pf4QhZSSCLdae101VVzUp287v79haak4e9HXtxFqgUV+SjaVkQ4j08YYmESldUX973e/u2dVKpIRgObaFsTACPz0V3KDa0SZJWCa3kuHYaGtHvaLYStnpySukplq1J7/IQi5ueLVWBULcxpq6Br/++zn14hqvkF3qIx9ShXRmx6u0m60N3Gp06/I6mflenThmmj+nmQ5uzJxh7rIJomkZnVBdj/XnBzc/p1kNbGXlyUXYSs8zWvymJrqGw0VjG2fd32e1wW6sg21u3Zy8ePBZKttI2JguC8HkRYWtHrBjbFI9td2pVhP49KG6n2+p6ZcXZGl7bA3aojGB4PsHoOtapewOdRHGr/dt3UonhTWzZBmB5vvZ+nL2SVOYPcL47HzQIG47PfGUAQW6IhY+bP7aEbcOuNssDP5T2ptZb7eqIomkOFBL4+hE2JXklDPMNQ0Nje8v27C3xpxbodxcQbosCCg5i/SYUjisah9fppSPWwb7QPmtsh1Tc9PAu+t1+Qm3659fvPGQlGPbEFDe6CNPHtGFXO5GuISxR1aMsmaZqhLrMiU3fQrXQW0ilX6/Lur0l6Qkf0lhLKx40KRg7O4yEN+ehficLqRObrHmXe3gXI6E4CdWIY+0ndvWkkpNwKS6au5tppZmKsVlIzIp1EVEgZgpbT4DOTmPioDT1+7I0j70xWRjy1srR5MqSeGyFTCHC1o6YVRFMj63mtpZY9Tq2Ay+3poYjAJSN0WfCWfNuDkS8iy5T2Drz6DKErc/RjpLov03u+KLxOBUnrZFWDoQPJL2fW7NXPiu1n31XZ8y4DCo++r9ZmJ6lTU2bKBzuI1DiRU1o1A91Z594d1pZqlCrHgOY72jF0Y8Ag3QRZoYj7N3cPLRln3qU/DFt9TtaUPpY3gd9smdOGj469JElGIfUwxTrnW3eadgacByyEgx7YnpsP27+GH+Jh6LyfDRVY/9Qeu5jXcnWr+4AXZ0xVE0BVPIdrf2+LHUiNiobE5sek4WAO0Co3ahn3E94B6QL29IRft27HB1i73IsZP0GFLgL6GzVbfM52nCpfX+nvE6vlUC2+dDmlDjbIRSMKVUmAPJd+VbIjN9xoN+Xmdd+a/NW/dqbdZdbh7DaSB+5AILweRFha0d6dB5zJZKtGgfqPGZiJpCZHlsz2aphZ+vQxiAOhlg33caPrs/ls+J+8xxteiKJ2neYhdfptcp+bWvZZgnbxj3tRIfS82UST/4A+91+wu263T5HB85E/0krU4ZNAfQQiqgatTzNQx6OEA3Tnhq3aIpFZ7PV/W0gezce3MiIk4pxOBU6moe47FOsKy0euLPFtLV/LyjAqaWnArC5abPltWvc3UZ3aIhigqPpoQh+t7/HuPZt6+jgaP2zHu9iT/ueFME4lOIm1OdkId/RijPRf4ttc0w3HtxI9cQSFAWa60J0NPc/6fx8dhrCVkk2aOi0Jjb9e2wnFE/AoTg42HWQpq6mLHmXkyEzAU/K59TRZAn0vrAmiymf0yFNzErx1vvdfpwOJ6EOY7KgNfb7MnMCtungJvICbqvayJBNbHpWxJBQBCFDiLC1I2aDBkvY6lnCDoeKU0kMGGMLySSgrYe2AlA6MoA7z0m0O8GhfTlurxvvJpySrd2d4rEFrAYOfWGWpPmo6SOCpT4Kh/t0z9dQl88BiHWnCcVwmykUWiDev82V/kpK8kqIa3E9zm5ClhLIYiHrJhz0BFO8oM39esEApgxPClu312kl5gxpdYR4elWENLHYjxcU4NRhhrA9tJmCkrxkTPBQTRoMkZXqCU3a2r/H1ulwWqW0Nh/anBa/OGSe8B4l1DoHef1PLzsdgA8Pfkie3025sXQ+ZKXUYuG0ZXO/228JxoCzqV9bUxPIUkM8htq7nDamlp39e5Yh3bs8vLpAr44ylIlZPZqIxKMJusP6PcNP/YB2uh1uWiIt1HbUJicLQzUBi3UBmoQiCBlHhK0d6RmKYHhs3S7jJngYYWvOvLe1bCOaiOJwKJbXdshrKB6OeHdarGpXhy5s80xhO8AN4rThpwGw4cAGAEYaS+X7slGSKt6Vlrltemx1Ydu/zYqiMHnYZEAX5Kan+eDeDusYQ0JPj22b/l66Z3FgsaigsK9zH4e6DlnhCEMqGFJsLfQWWmIx4BjYY2t+zrce2kpcjWfhRhwiCkRTYxdbBmerKcI/PPCh7gl36Z7w1sYhKlGVKm5SwzsOM1mYPGwyDsVBXaiOxlDj0HtCY2E6jN85BSXNC67H2A6wGmJMwj448EHWvMt9ecEDA3iWASYP17//Gw9uREUd+rCZHhUxzMYlLiJ4tVarrXlPPE6P9Z3acGDD0FcbMbvjSSiCkGFE2NoRw2tpJo85DI+t220I2gGSxwBGBEZQ5C0irsbZ3rIdgKoTdc9b3VDHdh6OWBdhJTlD7w6ZS/qH99ia3qRNTZtQNZVqQyRmp9Zqd9Kr6E4Vtq369Uj0Hw5hCttNTZvwF3oZPqoANNizqf/Y3M9vbzjNYztYj12Bp8CKCdzUtMlKItm/rWXoGkvEwrQ7+7B1AC8o6F32CtwFdCe6jRJVQ+wJTUlyA8jTkisOAWf/VREAziw/E4D3D7yP2+u0WiwPnbhJTx4b7GQh351vrfh8ePBD6/rv3do8NNc/Gk4L7YhHVCLheNLWAa6/NaaN72fNu5zqCU37nA7wnZpQPIF8Vz4dsQ52tO7IygSsz5h15yEUhQE/p6ke+/IxBXjzXUTC8aGpg25Wb5DOY0KGEWFrR4wZtRmK4IzrmbeD9dgqimIlLX3U9BEAVScmO19lpf97f/ToiGV6bH2usPV8f4wvGo/P5aMz1snO1p2MPLkYh1E+Z8iLs8e70uuXmqEIZvmcRP9xq6aw/fDghwCMPU2vbbtn4xAJW02DaGeasA2nxS0O7NEyPWEfHvyQYSMDek3LSGJoEnNUFaIhy2ObGjYRcDQP6LFzKA6mlk8F4L2G96gaX4TT7SDUGqG5rv840s9Milj0uXx0d+gCzKnE8SodAwvbMl2E7WjdQUt3C6NP1cXN7o0HM28npJf7ShNhA3tsIWVl5OAGho8uIM/v1tsrD0XyaY9Obua1dzu68Ti6BhThU8v0a//RoY/ojndnxbuc2vo31KKP40DVG0Av12gKxvca37MSs4asDXTPa58aMgEDh6IM1+3ccHADDqcjpe7yEIxptHf5PEHIBCJs7YghbM1QBEfCELamx/YwyWOQTAIxhW3Z6AJcHgfdnTEO7R+Cm/5giXX1qi4AkOcybgwDxKu6HC5LJG44uAFvvpvKE4uAIRSJJrHuPkMR/GZzhgESsk4rOw2n4mR/5372d+63hO3eLc3EhqJvfDwCmpoWimBl7x8mFAGSN7f3Gt5DcSiWCNv1wRCIsLgeZ2cJW29w0J4wgC9UfAGAdY3rcHmcjDipCBgiT2isi1bDs1zkLUra6QnpnrABbC3OK7bqhL5/4H1OOH04AHXbW4emcUo/lSYCh0nIg6TX7oPGD3A4FCsmePeHQ/Ad69FIxPqcmuWzBhDhIwtGMtw3nLga11cXLE9os1X3O2MkYihqvM/kMd0LPvDn1JyAvd/4Pr4Cj5WYNSS/W9FQup3m59RlTEwHEOGnlemTmh0tO2iPtlurILuHws5YmG5FIZKSOCgImUCErR0xluPNhAqH4bF1uYznB+FxNWOlNh/aDIDT5bA6Xw15IfOBiEcIG4Ld7/LT3WmEIriNG8NhbhA942zHThli76dJaoKTVWsV8l1mbHD/wtbv9lsxlu/Wv0vpiAAFJXnEY+rQJDoZXs6+ErLyDxOKAHBW5VmAPikKxUKMO7MMgF0fHEDLdKyd4bVpSxnbtES3AW7CAF8o14Xt+43vk1ATSRG+of+yRp+ZWNiys9BbSMgUNnmGV/kwtpriZn3jeoLDfAwfVYCmDZ1gbE2xNZnBf3iPvTmmW5q30BZpY9wZugjfuf5A5ld7eo6pJWyNyfcAIlxRlLQxLRtdQKDESyySyPjERjHsMENmCr2FKZPFw4+p6bF//8D7aJrGCcaY7lg/FJ/TLuvaF3mLkt8ns53uAN//Yb5hjAmOQUNjXcM6xp42DMWh0LS3M/OrYinX3qW4xGMrZAxbC9slS5agKErav5NPPtl6vru7m4ULF1JaWkogEGDOnDk0NqaXM6mtrWX27Nnk5+dTVlbGrbfeSjyehfJQn4ce5b6UuF430+0eXCgCJBMWdrbupD2q/6BlrVd5f2iaUTbL8Nh6UkIRPMaP7QBL+pCMq1vXsA5N0yzvZ92OISzzBP16bPNd5g34MGKxQheL6xrWoSgKYwy7d384BF7QqG6TeRP2K4Fk3OIgvKAjAiMYGRhJXIuzvnE91SeX4MlzEmqL0pDp5ehoJypJEe5LBEjEjAzuQXiXJ5RM0D19sU62tWxj3BlloOgNEDKeRBQNpYtFUzDkDW5SZoqb9xreA7DEzc73h0DcRMO0OfsQNwOUJTOp8FcwtnAsqqayrmEdo04txeVx0NHcnfkmL9EwbUZd4CJvUVKAW5OFw4xpyu+BoijWJGxHhsdUiYVRSU7A/FqB1TTHf5i4ZdB/j90ON01dTexu3834qbqd+4fCYx8Lp60sWBMwj1ER5zATsHMqzwFgTd0afAEPIycUAUPwOY0mJ19BbxAlpdW6IHwebC1sAU455RTq6+utf3//+9+t5xYvXsxLL73E888/z+rVq6mrq+PSSy+1nk8kEsyePZtoNMrbb7/Nk08+ybJly7jrrrtycSqDx0weoz9he/hlttSZ9/qG9QBWIkj9zlai3TkQ94ZX04qpcyVDEXzeaNo+/TG1fCpuh5v6UD172vcQHOajdIQfTdX49KMh9ETHk+W+Ap5AstyXx4wNHthu0wu6tmFtmiDfvaEp80k5sTAJkuPs7NJbqbpc4FHCh7UV4Jyq5M3N6XYwxvCM7/wg0ze3EJ0OBc2MJw/r3bHyfAouJXZYYeNyuCxxs7Z+Lf4ir5WYlXFvWDRkTRbSBEO+8dk9jGAwPwNbm7fS1NVkeUL3fdyS2UmZmoBEhBbz86oErVrPh0vIMqmprAH06+/2OK3rn/ExTfUu5qWMqTVZGHhMv1T1JUD3hIZiIUsw7t7YlNlwBCPGPmGWYAz7APDmgdsROey19zq9lnf57/v+TuHwfN1jr2rs2pDhyW00ZAnwtJAZ7+HzGCA5pmvq1gAwfmo5MBTXPn3yJQiZwvbC1uVyUVFRYf0bNkz/gW1ra+Oxxx7j5z//Oeeffz5Tp07liSee4O233+add94B4NVXX2XLli389re/5fTTT+fCCy/k3nvv5ZFHHiEaHcJSS5+XHqEIlrA1+zQMwmMLSS/huw3vAlBY5qOgNA81rlG3vTVj5g4a4yYVNst9OfzWDTfPYwjtw4gun8tneb7ernsbwLrp7s70DSKV1PJJSgFRw1uT7x2cp/n04afjdrg5ED7A7vbdjDixCF+Bm+5QLPNZ3IZYNHGE9Q+OP+g8bFa0ydmVZwPwTr3+XRp3hhGO8P7BzC5HpySO5TnziBiF5P1B/TN/OGED8OWqLwPwxr43ACxxs+O9/ovRf1ZbWx26XYWeQqvzlD/f+OweZlyH+YZZNU3/vv/vFFf4Kanyo6paZj33xsTG9IJ7uvIBcHsdyYSsw1zDmipD2Nab4kYf04yHI8RCtPS1vG9NFgYWYaODo6kuqCauxnmn/h3KxwQJlHiJZzgcQYl10WZce5/LR6Rd//4HCozv2SC+U18Z8RVAv/aQ8jkdAsHYmjqm1mShy3p+IL5Y8UWcipPajlr2duzlhNOHJ8MRMlmeLtqZFjIhCJnC9sL2k08+oaqqihNOOIG5c+dSW1sLwPr164nFYkyfPv3/3955x7dVXv//fbUlL3k7Tmxnb2dPIAmEQAghLZRCmwKFsAo/oFDa0tKW/aWElpZSZhtKGaWEHVYgZJEQsvd2hhM7cWI7HvK2JEv398ejeyXHji1vN3ner5dfsuWrq6Nzr+79POc55zz6toMHDyY9PZ1168TFeN26dWRmZpKcnKxvM3PmTMrLy9mzZ0/nfpCWoHVF0P4OKFyTOfB3GMVjAON7jAdElBBETlqwGruDc1IbI3CT0qpgbXURAbvAZg18pjCiidpNd/2J+qLr6K5i3B2xCpnfB35vUCjUCqFgMhuwWAI3+WbstplsesRm9bHVGIwGBowT5+XBTe0vwDSxGHoTjog2h2UrwMSUiSgoHHIdIr8qn/RhcZitRipKajl5uB27I3gq9ehStCVaj9hFxAQSysOILk7tNRUQ/UzL3GX0G5OEokBhTgVlp9pxxTRPRb18UE0wREVq52744ubb498CMGC8OAf2r8tvPzvdlZQbDHoUXB/YxARXMGwuajc+ZTwmxcSximPklueSMSweU+D4t2t3BE+VLhhjrbFUBjoNRES03Kdr8tagKAr9A+kIB9rxe6WEiEVh52nnaTP+BLig1wWA6IxQ7a3W0ybyskrbtzuCu1L3aYw5Rp9dinQEbGzmOxVpidRrGdadWIct0qy3VjzYnoNFdyWuQBpKjDWm/fYrOefp1sJ24sSJvP7663z11Ve8/PLLHDlyhClTplBRUUF+fj4WiwWn01nvNcnJyeTni5tEfn5+PVGr/V/735lwu92Ul5fX+wHw+/0d8qOqav3nAp0B6gLBANUbSLAP6BLV5w1rv2MThZA6WHqQU1Wn8Pv99BmpFdecoq7O12GfqdEfvb1LIALtDkznRZjBJG66/rraZvej5YBtzN+I2+smrqeD2BQHvjo/h7cWhO/ncH/cIq8wOLUvpsvt0RYwi2l+v6em2f1c2OtCAFYcW4Hf76f/uEAUdMcp3DXhHdPw7K2s1xtSiyw6nMLHal0Nfl/Txz7GEqNXxy/LWYbBpNBvjJg637f2RMvO5ybPiap63RsqNGHjtAbO/epm95EakUrfmL74VB9rjq/BFmkiNdAdIWvDyXbzq+qu1MVNtCVaFzeOSDVga/PnwAWpQtysO7EOd52bgeNFTvCJgy5chVUts+dMfq4t1+2MNEdS4/LW86k4X5v2q91o11M8lucsx2BS6BtIn9n7XdPHv2U+rWjUpxGBwYIaxvdKi9ivOb4Gn89H//FaOsIpqivc7WKn4q44rRgvcJ4GhG04xz4jMoOekT3x+r2sP7GeqHgryX2iUVXYv74dz1NPhR4Ft7kjUVUwGBXsNuFTfxjfKe08XZazDL8/eK3av+4kvva6b7jLgwNFS0zT53QbfyTnFqbmN+k6Zs2apf8+YsQIJk6cSEZGBu+99x52u73D3vepp57isccea/B8aWlpuxee+f1+KioqUFUVgxZlqywjAvAEpvy81XWAgkpgqV1PDWUlzU+zKSj0jepLdkU2Kw6t4OKeF2OLV7HYjdRWejmw7RhJfTqvEtVYXEAswYitxyU+j8VuwIsRC1DlKsbdzGdLVBOJt8ZT7C5m2cFlTEyaSK/hUZTmV7P3uzySBlkbvKYxP4eLoVLYrQmwmmJxDlgcBnwYMQEVriK8zdg9KmoUIFafyj6ZTUx0DJFxFipLPOxee5SMkbEtsutMWEoLdWHrMDooyhcRVqPQ4Ciqn+KiQjCaz7QLACbFT2Jb4Ta+zv6ay5IuI3VYBPvXianTYTMSMFka+rGlfraWFOh+dRgclBSUn2arj+JTBc3aOiF+Atll2SzNXsrEmIn0yowiL8vFnjV59JkQhWJoe2FKdGWJbqvRY6KiXIgwY6Cjh7uyjMpmzoEehh7EWGIo85TxzaFvGJswluQ+kRRkV7Ljm6MMm57c5Os1mvKz6VResMuEKYpTJ1zieYeCWmFEUX24Tp3EH9lMOkL8ZDbmb2RJ9hLm9JhDz+ERHNgoonZDL45v9Pi3lJiqUl0wGqqN+oIXRpPwaU1lKdXN+LSfpR9Wg5X86nzWH1nPIOcgnD1suE7WsmPVEQZMSmiTjX6/H3/5KT0fNMIQQfGJ+ucp3hpKwrgmj48fT15lHl8e+pIRESNIGxFFwZFy9qzJI31MRLsUUMXVVlDmFK2z3IVC1NmjTNTp19iiZq+x42JEZ4yN+RvJKcghtncEJquB8qJasrYeI6lv2+8bjrIifVBjVa2UlJS0+hrdFBUV7VzwKOn2dGthezpOp5OBAwdy6NAhLrnkEjweDy6Xq17UtqCggJSUFABSUlLYuHFjvX1oXRO0bRrjwQcf5P7779f/Li8vJy0tjdjYWKKjo9vxE4mLpqIoxMbGBr/MVnFYfAqgggkL4CUiUgg2k6ISFxcX1v6npk8le082m0o3cU3mNQD0GZlI1vp8ig67GTw2vV0/T5PUCvu1rghRBifgIiLGhtkm0hIibGYiwvhsM3rP4N2sd1lfsp5Zg2cxYqqdXcsKKDhSidUQUS86BWfwc7j4i3Erit6lIoJowEV0vAOjSaQlRNkt0IzdccQxKHYQWaVZ7KzayZU9rmTQxB5s+TKHvN2VjL6oX8vsOhNWgy7AYu2x+EuE3fEpTjgasCXaDtamz+UrzFfw8r6X2VmyE0OEgYGje7E5IY/yolpcOXUMnNjwO9RiP1uC3RviI+L1mef41Hg4EL6tlw24jIXZC1l/aj2OaAcjLohh2xcnqXZ5qT6l6EsDtwVFdes34mRrKuV+MBgUYhOEbVajH0s45276DD489CFri9dyycBLGDbFQ0H2fnJ3lXHB1YPDEjdN+rnMoOcCxzni8JUH/JsSDSV28FTijLQ1e75eYbuC5/Y8xx7XHrw2L4PGpLHl0xOUF9VSerSOQZPOfA0NF8Vfi8sk7Esyp3KCSkwWA85YIZzsJrCF4dNpadP4Oudr1pWuY3LfyQy/oBdr3j9E7o5yJl4+sE02+v1+akx+SgM+TYhMwFsjBgWJPWPhMCg+N3GxsSKvqgm+N+h7LMpZxHcF3xEZE8nIqdFs//IkFafceF0mUvq1cUpeVfF4K6kxiP1EG+KBcqLiHZgd4jyNsBqbvcbGxcXR39mfQ65D7KzcyZx+cxg4Ppm9a06St7uKwePaft9QDHX6oCY5Jpm4uLjWX6ObwGT6n5I5knagW6cinE5lZSWHDx+mR48ejB07FrPZzPLly/X/Z2VlkZuby+TJIgdz8uTJ7Nq1i8LCYHL+0qVLiY6OZujQoWd8H6vVSnR0dL0fAIPB0CE/iqLUfy7Q7kuvkw7k2Fps4guq+L1h7/uSjEsA+DbvW7yqeJ2Wg3Z46ylQO+5zNfgJFFhpS+oaPCIK54iyoJhE6MPgc4e1r5m9ZwKw8vhKfPhwJkWQ0jcGVDi4uTA8P4f7UxdcStOgGKgLdPiKiLG22O6L0y8G4OucrzEYDAw9PxUUOLavlPKi2vbxs7eG0kDuWqwtlspSkdoSlRBsgG7wNX8OpcekMzB2ID7VxzfHv8FoNDJ4cg8A9q/PD/98btLWaj0fMNoaTZVLszUSAl1BDD5Ps/sZnTya1IhUqrxVrDmxBovNzKAJgfzVtWe2tSU/SkjxmL1WXBMcTgsmm5g9UurCOwcu73s5AMtyl+FTffQfk4zZaqT8VC0nDpaFb8+Z/BxSkBXavSE63t6i8zUlMkVfrGPFsRUYTUaGnJcqfLqunXzqrtR9aqkVg9vIWBsGa8Cn3vC+E7P6iNm9JTlLQIFBk3pgMImCp+LjVe1z7EMX5yhxN/xO+Zs/T8emjCXJnkSFt4L1+euxRVj063FT36mwf/weygLa2qgY8VcGIvdxNhSzGIQbwjxPZ2TM0M9Tg8HAkPPFsc/edgqv298uPg22eovVW3q2x3l1+o/k3KJbH/Ff/epXrFq1iqNHj7J27VquuuoqjEYjc+fOJSYmhltuuYX777+flStXsmXLFubNm8fkyZOZNEnkYF566aUMHTqUG264gR07drBkyRL+8Ic/cNddd2G1Npyu7jYEisc8ge4H/oCwNVuN9f4fDsMThpNkT6K6rpoNJ0URWdrQOGyRZqrLPeR21LrqjeGtwQfUBC68/upA6kWUBQI33HAKm0D0BI2zxVHmLmPTyU0ADJ4sIkh7Vue170IC7ko9WhNlidJ77zqiLWCytsju2X1nA6LavLC6kOgEOxmBFZP2rM5rH3u9VRRrUVB7vJ5jGxlnA6Nmb3hFVZf3ESLsk0OfADB4cg8UBfKyXBSfqGy7rZ6grQn2BL33bFS8PXhOhFFxblCC4uaL7C8AGHJB4Ea8/VT79Ap1VwRTEQIt1CKdNjDZw7YTRMu6BHsC5Z5y1p5Yi9lq1KOfu1Yebwc7gwV5TpuTioAIi4y1QUDchFOUB3Bp70sB+OzwZ4D4jimBnODivLYf/zp3BRWB469UiXMzKs4a9GmY5+kFPS8gwhxBflU+O07twBZh1ld3272q7T5VvKEttGKp0AoHE0NmEsI8TzWfLj6yGIAh54vB4sFNBW1v++aubHRhjkinVa8HCNenMzNE8GBN3hqKa4pJ7h1NXGoEdV4/+9edbJudUK8rQqTbyav3f8uSFw907ZLvkrOCbi1sjx8/zty5cxk0aBDXXnst8fHxrF+/nsREccF69tlnueKKK7j66quZOnUqKSkpfPTRR/rrjUYjn3/+OUajkcmTJ3P99dfz05/+lMcff7yrPlJ4BNp9uRHCVg1c60zWQJ5hC4StQTFwUfpFACzNWQqIVcgGBqqxs9a3YzV2c9TV6mkIAL5A5NMebdGLx5prm6VhNBj1aPSiw4sAGDghBavDRHlRLTntuba5p4oSTSja4oPL6cZYwayJmvDa4KRHpzMqcRR+1c/ibHFjGz61JwD71p1sn96bnmqKA5GQeEu8HgUVwkYTi+EJmyv6XoFBMbC1cCu55blExdl0wbBzRTuIME8VRZqthsRgv9XY0BtxeLZqg4Zv876lzF1GYloUSRlR+H0qu1a1fdBQ56kKEWHmhnaGKWyNBqM+4/DJYTFgGHFRL0B0K2lzJwd3ef3oYqk2sGm5uJnddzYmg4k9xXvIKskiMjZ4/HesONY2O4GywPSHgoKvPNBOL67l56nNZNNnQxYdWgTAiAuFT7M2FLR5YKOEiLBonNS5A+2+4h1g0Dp4tGywuDJ3JWXuMnr0dxLfM5I6j58937bxPPVU1F+YQxO2oYOFMO3sH9ufzIRM6tQ6Ps/+HEVRyAz4dOeKY/jbGjwIKR6z1kRQ5/bjrfXLhRokbaZbC9uFCxdy4sQJ3G43x48fZ+HChfTrF8xDtNlsvPjii5SUlFBVVcVHH33UIHc2IyODxYsXU11dzalTp3jmmWe6f85NQLi6AxHbgM7FHEhFaImwBfSb6NKcpVQHBJg2pXxkR1HHrtgVSl2tvpyuyWDCXRnoBRvd8ogtwFUDrgJE5a6r1oXZamTweeJz7fqmnaKfAJ5KSjTxZY8PLqcbbQFLoIgiTGELMKffHECIGlVVSR8eT1ScDXdVXfu00/FU6cI2Vk1E9asoBgVHjAXMES2yNzkiWW+vpguGi9MAyNqQT01lGyOhIcI2xiuKfKwRJpF2o0cXw7sRD4gdwJC4IXj9Xt3WUZeIXMBd3xzH28ZBQ7FP+MyoGPBVBAqJYlseXQT4wQCxkMzK3JWcqj5FbEoE6UPjQIVdbY0weoJtlKINTn3VuahYW0gUPDzBGGeL46I0MTDWfDpyhvDpgQ0F+iCvVfi8lAVG7VHmSKoD3RsiY22t8unVA64G4MsjX1LuKSelXwxJvaPx1fnbPLAxhPg00u0EwB5lxmQxhtgank+HJwxnYOxAan21umAcNUN8p3atPI6vrg1V/O4K/VrltDr1yHJrBrUAV/a/EoCPD36MqqoMmpSCLcJMeVFt2/uGuyv165S5WnzXI5xNF4lKJOHQrYXtOYvfix+oQxO24lEXtv6WCdGxyWNJi0qjylvF1zlfA5CQFklCWiS+Oj97vzvRbqY3SciytJHmyOCytFGWkCny8IXtsPhhupD5LFtMlWrRz9y9xe3XTNwTvADH2eL05UmFUAyIr8AytuFwWZ/LsJvsHHIdYnPBZgwGheEXCru3LslteyQkJBUh0i06LUTEWDAYFLBEtNjeq/qLAcSHBz/E7XPTo18MielR+Lx+9qxu47kTImwdtaLgJSoucANuQSqCxo8G/QiAhfsX4lf99BudSFS8jdpKb9tmJ3x1FKpCICbY4ql2NTLF2wLBMDB2IKOTRlOn1vHRQTHLNGK6EDf71pxo22DTXUmhNhDzipkZi92ExW5q8QwDBMXNJ4c/odpbTUrfaJL7aIKxDSLcXaHbmehIpFJLQ4lrnU9HJ42mv7M/NXU1fH64vmDcveo4dd7WD2wUb5Vua0TgOxUZG7CxhRF7RVG4duC1ALyX9R6qqjJgfDKOGAtVZZ62LSwScuyTHElUadH6Vg7AZvWZhc1o43DZYbYUbMFsMTJ8mrhWbV/Wtoh9tSeYhmKsEj7UWhJKJG1BCtvuiM+DJ2Q6xucRQieYitCyKIlBMeji5OODHwPi4qpNf+765jj+9l7WtTHqauo1uNemB+2tyFXV0KI072W9h8/vw5nkICMzHlTYuiSnfex2V+qpCHGmYCpCVLwNLC0XttGWaL7X73sAvLX3LUAIcqvDhKuguu1rsoekItjdIgdQvwm3QthOT59OsiOZktoSFmcvRlEURgaitjuWH2vb8swh0WVzjb2+reaW34gv73s5UZYojlceZ03eGgxGg27rtqW5rT/PPRUUmoSdyY7kYL9VZ+sEA8A1A0WXkvcOvIfX5yV9aBzxPSPw1PrYsbwNosFdQUHAp1Fekb8dGRv4fplbNh0NYmW39Kh0KjwVfHzo43rHf9fK461fFMVTSUFg9iw5IkXPrxbRRW1mIfzzVFEU3afv7H8Hn99Hv9GJRMZZqanwsndNGwZhnkoKAsffWqMVuWk+1WYWwh8szO47G7vJTnZZtli22mTQp/m3fJXT+sFtiJ3JtmSqykPTkFp+7KMsUfoM0xt73wBg+LSeGEwK+dll5GWVts5OoDBwbB1GG26X+LwyYitpD6Sw7Y746nCHpBlp+Vxmm1X/f0v5fv/v67mS+0v2A2LVI1ukmcoSN9nbO2ElMm+tnv8VY4kJRmyjzUFhG2aOrcYV/a4gyhLF0fKjrDy2EoBxs3oDIn+4XVae8lTp03uxPlHBbDIbsEWYW5WKAPCTIT8B4Jtj35BTnoPFZtIjdlu+zGlbAYU3KGxN1YEip7iAfzV7PeEX/pgNZq4bch0Ab+59U0SYxiXhTHZQW+VlZxtyLWs95cG81UqteOj0iG34UTu7ya4P4l7d9SqqqjLkvB5i+vRUTetX+AqNhEWk4AqcVzGJ9hDBEL6dIFKEkuxJFFYX8unhT1EMCuNn9wFE/mqro7ahIqxaHO+oeG1g0/LjbzQY+enQnwJiIFbnr6PfmCRiUxy4q+vYviy3dXaGCPBke3KwcDDOBtaAne6WFah9v//39evB8tzlGIwGxl7WG4DNX+bgdbcualvlraBGq64vF1FF3afWKP3zhEukJVIflL+6+1UAMi/shdVhojS/moMbW3uehkTBfamggtFswB5pDhnUtsynNwy9AQWFb459w5GyI0TEWBkW6JCw/pPsVl+rCv3ieCfZ4ikvEt+niFgZsZW0HSlsuyMhEVsTZnx14sJhtrcuYgtiWkqrcn1t92ti32ajPnW/efHR9u0k0BghEdtYYxx1Hq15eOsjthHmCOYOngvAv3b9C1VVSekbQ9rQOPx+lS1fHW273Z4KirXCEY/o/xgVbxNFDq1IRQDoG9OXKT2noKLyz53/BEQBkdlqpDivUrRiayW1bpe+CAYVWpFT6yO2AFcPvBqHycEh1yFdMIy/ojcgpiTd1a0TYUWBm6xVMeF2ifNBF+GtiNgC3DjsRiwGC9sKt7EpfxMWm4mxszIA2Pj5kdYV6Hkq9YhtojmZmsCgLCbJ0WqfWowWbhx2IwD/2v0v6vx19B2VSHyvSLy1PrYtbZ1grK0t09soKS4hFJxJgfNUE7YtEGEA3+v/PWKtseRV5rH4yGIMBoWJ3+sLwI5lx1pXnOUOiS7SkzqPH8WgEJVga5UAB3E90AZhoQOb6AQbNeUedq5s3SCssE7Y4TRFUFkkPmsDn7bQ1huH3YjJYGJT/ia2F27HajcxZmbwPG1Vrq27QvdpVI3IWY9JtIsFSnQB3jI7+8T04cK0CwFYsHMBAGMv743JbCA/u4yc3a0o1FVVClThx2RHop42FpXQjbsVSf5nkMK2O+Lz4A4IWwcR+tNme+BL38IcW415w+cBsOToEo5ViAv8yIvTsNgCYmpbG4sBmsNbG2yZ4xeV1SaLQRQKtSLHVuO6IddhM9rYXbyb1cdXA+iRr6x1+ZTmt0xwNCAkYmurEVP7elSxFakIGv9v1P8D4PPsz8kuy8YWYdZzAtd+dKjVOYHFtWJ60KKYqCoW54ozKSASWxm1ibZEc/3Q6wF4YdsL+Pw+BoxNJi41And1HZu/bF3aR1FAMCRYoikrFDc3Z2LAp62I2IIYxGnFWS9ufxFVVRk+rSeRcVaqXG52tqallieYY5ngEdEqe5QZq91UX9i0MHr1w4E/JNYay7GKY3xy6BMUg8KEKwJR2+XH9EhWSyj0uIR9BjPVxeIc0o+/Jm5aePztJrsuwl/a/hJen5e+oxNJTI/C6/axefHRFtuJp0JPRXDWipmQ6AQbRqOh1RFbgOsGX4fdZGdfyT6W5izFaDIwYY4Q4du+zm1VwWOhXxyHZFts8DzVhG0rbU2JSOH7/b4PwHNbn0NVVTIv7IUj2kJ5UW3rOiR4Kik0Cp/aqsS1ypncNgEO8LMRPwPEtepg6UEiYqyMmC5SJ9YvOtzyFB9vNYVGcY9LtvYMtiWLl8JW0naksO2O1Ln1iK1DFTcig0HBaAlM0/jrWnwDBRgSP4TzU8/Hr/p5ZccrANgizHq+3MbPj7S9cKkpPFV6KkK0T0Q+HdGBz6RHbFsmYkAUdGlT+89ueZY6fx09+sXQOzMev19lzXsH2za1H1q9WxXIA407bWq3hakIIKqjL0y7EL/q529b/gbA6EsziIixUFFc2+p2WsUeEY2Lt0RTVhCYMtejS60TtiAiTFGWKA6XHdanzidfJbqU7Fx+jJITLRf3xV5hR7w1jtJA1Ea/EbcyYgtwS+YtWI1WthZuZVnuMkxmIxMD4mbzl0f1G2nYuIM5tjG1wUgYEBSLqC0e4DjMDm7NvBWAF7a/QJW3ij4jE+g5yInP6+e7Dw+1zE6gwCuOf7IlhrLCwPFPbpsIA5E+k2hPJK8yj3ez3kVRgsd/1zfHOXWshUuXhqQiOKpEQVZQhAV86q0Cf8tEk9Pm1EX4s1uexevzMmB8MvE9I3FX17Huo8Mts5PgtHmyLUlPb4pJ1gaLbROMFoOFzQWb+ebYN5itRsYHBjYbPj1CVVnLzlN/bTBiq5SJa2qDQU0rjv2whGFcmnEpKip/2/o3QFyrrA4TxXlVLe9C466gICDAk/wiSm2xG7E6jC22TSI5HSlsuyN1tXrENkIVF02z3YhiCsk/amHLL417Rt8DiIbre4v3AiJqa3WYKD1Z1T6Nt8+EpyLYkLtOVMDbo04Ttq1IswAhZGKsMRwuO8yHBz4E4PxrBmAwKeTuLeHorjb0tQ3pY0ulmNrXI7atTEXQuHf0vZgUEyuPrWTVsVWYrUYmBcTC5sVH9bzDlpAfaEuVYkumvFi8Phix1W7CLbc32hLN7Zm3A/DXLX+ltLaU3pkJ9B6RgN+vsvrdrBYPIPIDgiHVkI631oeihAjGVhS7aKREpHDTsJsA+Mvmv1BbV8ugiSkk94nGW+vj2/cOtGyHIZEwS6UQCDGJIQI80MaupVP8AHMHzyUtKo2imiL+ufOfKIrClGsHohgUsredIreFPZnz68TxTzYHcxcbTpu33E67yc6do+4EhAgvqCogbUgc/cYkoaqw6r9ZLUtnCklFMFUI+/RovSbAoVWCcd6weSTYEzheeZw39r6BwaAwba5YWnff2pOcPORq0f60jhg91Az8PhWjySDap4Xa2opj3yOyBzcMvQGAZzY/Q21dLUMvSCUpIwpPTR1rWziwKaktpk5RUABPiTgWMQ0iyy23E8S9w6SYWH18NctzlmOLMOsDmw2fZrdssOgOpvY43aJzR0yiQ/awlbQLUth2R7w1urC1B4StxWoCY6iwbZ0AHJYwjMv7XI6KytMbn8av+rE6zIy7vDcgpsDb3Jv0TIRM6TsC1foRzoCg1fvYtlzIgRBdd44UN91ntz5LflU+ziQHowI9N7977yDe2lYWjnjK9MIRb2C9yii9GEsTtq1rLdY/tr9+Y3tq41PU1NUwaEIKKX1j8Lp9rHxrX8vEot/PiUDuWprSH9WvYjIbxGIS0Op8UI3rhl7HgNgBuNwunt3yLABTrh2A0WwgL8vFvrUtGBh5azluEJ8t1T8AgOgEO0Zz4LLUylQEjZuH30ySI4m8yjye3/Y8ikHhwusG64IxuwV9ONXQSFi58GWMNlhQlFYVEGmYjWZ+Ne5XALyx5w32FO0hvmckmYEWcCv/s79FnQe06GIPNV2IMLNBtCWDNkXtAH7Q/weMSBhBlbeK+RvnA3DBNQMwW40UHClvUb9Yd61LX/rZ5wqIHC0KarKBEojetULYOswOfjH2FwC8vP1lssuy6dHfqa/ytfLtrPBzrX1eCgOmxNeJ60lMUiBvFYLR5VbYCXBr5q0k2hPJrcjlxe0vChH+k0GgwIGNBS1abKagVmwbb7RTfkob1J4WBW/FoAagd0xvPZ3tjxv/SKWnkqHnp5LSNxqv28eqd1owsPUEv0/2KhHk0L9PEkkbkcK2O1JXq6ci2P1CiFjsRjCGtEJpZZ4twL1j7sVusrO1cCsfHPgAEIVL8T0jcVfVsbYVU3Vh4a7Ue5ZaTq/W1kR7XetF9Y8H/ZgRieKm+8T6J1BVlbGXZRAVb6OixM22xa1r93MiMLUbbbRTUShuFjGnR8Ba0JbodO4YeQcpESnkVebxty1/QzEoTP/pYIxmA8f2lbasTZGnkjytIMfXR7dVvwlbWx+xBdEh4eFJDwPw8aGPWZO3hugEOxPmiPf67oNDVBSFGbmpdXE8kGMZ6xH5es4UR/D/uggrb5WtDrODRyY/Aohq/i0FW0joFannMa/8z369J3FzFFedpMpgwAC4A93YYlOC+e9YA0urtlI0TE+fzmW9L8On+vjDd3/A4/Mw8Xt9iU6wUVnq5tuF4UeYjyGuDclecUyc9URY66fNQXRIeHjyw5gUE8tyl/HV0a+IjLUy6UoRuVv70aGwl9o9XiUGQQ6MVOSL46CnTChKm9ImAOb0ncP5Pc/H4/fw0HcP4fP7mHxVP+zRFkpPVoV/nfNUkhs4T6NrhDDWUyagzXZGWiJ5eLL4Tr259012nNpBUka03o5x+et7w14I45hb5NenK4nB2ZrG0lBamZp1+4jbSY9Kp7C6kGc2P4NiUJj2k8EYjApHdxax59vwrlVqbQU5JnE/M5WK71Fs6HdfImkDUth2R0JSEWx+8WW32EzBpRuh1akIAKmRqdw75l5ATCnnlOdgMBpElADYv/YkR3d2QPuvkIUODJVCyEZrwrYVjeNPx2gw8vh5j2M2mFl9fDXvZb2HxWZixk1DQYEjW0vJbkWB3ImAaE039aQqsOpYXI+AqGljKgIIAaaJxf/u/y8rclcQmxLBpO+LnNA17x8MWyxQW6aLxZhasQqfMzQS0kZhAzAqaZTeieJ33/6OgqoCRs1Ip+dAJ3VuP+s/yMXnDSMvssbFMbOw1V55Wo4lBMViK4UtwNReU7mq/1WoqPx+ze8pc5cxYU4f4ntFUlvpZem/94aVV54TKLbsSSQleeJYJ2VEBTdoZbeBUB6c+CBxtjgOuQ7xl81/EefuvGEoiljlLWtDGC2g/H6OBqLgzioRXUxMD7GzjSIMYFDcID1y9+jaR8ktzyXzwp6kD4vH5/Xz9b/2hBUNPVotPs8ANYnyIiHCEtNCbW3bYEFRFB6d/CgR5gh2ntrJSztewh5p4eIbhwAiL/jIjjCuB7XlHA2cp+YSJ3CGY9+G79SFaRcyu+9s/Kqf36z+DWXuMiZf1Y+41AhqKrwsf2NfWGkeR7wuAPp5BoMqeu3qdQzaQFH1tXpmzGay8cjkR1BQ+PDgh3yR/QUJvSL1lITv3j8YVq59ScUxKowGFBWqT4rPlRjqU4mkDUhh2x3xBiO2Vr8QJWabSUQxDFrLr7Ytgzt38FzGJI2hylvF/d/cT01dDT36xTAy0Et12Rt79TXm2wvVXaGviFVXJh4b5Kq2QdgC9HP200X7/E3z2V64ndQBTkZfIj7Xirf2U3KyZSL0RGBqN8PbHxA3C4s9MMjQp/bbZveUXlO4cagoeHnou4c4Vn6MEdPTSBsq2qJ9+cqu8Fpq1ZZxxCzOEUuxmOJLCBU2bUxF0PjluF8yOG4wpe5SHlj9AD61jotvGorFbqLkeA2rFx5odlrSW11ETsBWX754rCcYbAFhU9t6YQvwwPgH6BnZk7zKPH696tdgVJl56zBMViN5WaWsX9R85E4TYQO9/fH7VKwRpuBsA7R5ih9EEeRj5z0GiAHOp4c/pUe/GMYG0oRW/mc/hTnN+KLWxdHAwMZQKgYLyb2jg/9vBxEGcOeoO/Xrxy9X/ZJaXy0X3zgEe5SZkhNVYQmxIzVCVPZ3DwbEVLQtImRWytJ2EZ4SkcJDkx4C4J87/8ny3OVkDIvXC2aX/Xtvs0KssiKPUwGf1gQCkkkZIT5tY+6qxoMTHtTP0998+xsUI1x6yzCMZgO5e4pZ/2l2s/s4EugyklQrrlX1jr05ZIahDbZO6DGB20eIXPvH1j3GodJDjNSuVV4/X7y8k9rKpq9VR1zis6T7ovQC16R0KWwl7YMUtt2RuhpqGkRsA0le2pR9K3NsNQyKgT9P+zNxtjgOlB7gsXWPoaoqk6/qR2J6FO6qOpYs2NOmZShPp8pTSW0gV7W2TOw32Di+fQQiwE+H/pRLMi6hzl/H/d/cz4nKE4y/og+JGRF4a30sfmlni5rf5+hTu72BkGhtqN3eqlZP72ncO+ZeRiSMoNxTzp3L76TM4+LSm4cRFWej7FQNX/1zd7OR0NqqU5wIpCK4Twpf1xc27SNsrUYrz0x7hghzBFsLt/KH7/5ARKyFS24ZiqLA/nX5za6elVt6mDpFIcpnpixPTEWn9IkJeZO2R2xBTPU+d9Fz2E121p1cx582/QlnsoOLrhMzFNu+zm22tVJWrRBhGbWiACkpI7p+oUs7iZsL0y7kjpF3APDY2sfYUrCFCbP70DtTREMXv7yryYLCotJsik1GFL9KtSbCQo9/G3KBQzEbzPxp6p+Is8Wxv2Q/v171ayyRBmbeNhyDUeHQlkI2fn6kyX1keUoASKkR+dX1zlNoN5/O7jub64eIVnW/+/Z37Cnaw+Sr+pE6wImn1scXL+1ocqr/QNFuANLckVQWi/O0fsS2bTm2GjHWGJ676DlsRhvf5X3HM5ufIS41gouuF8J/61c5zRb3Hgjk10dWiPzsesfeYGiXmQWAO0feyYSUCdTU1XDn8jsprClkxk1DiYq3UX6qhi//savJa1VWxVEAhtWKYx8VZwsWEkskbUQK2+6It5YagxaxPV3YBiKF/jYsYxogyZHEM9OewagY+SL7C/665a8YTAqX3joMi81IfnZZ2FNg4XAyUK0fqzhxVwr7g/1g20dwgZiCfOL8J+jv7M+pmlPc9vVtuLylnDc3g8g4K2WnavjixR3hLQXr95FtFBdoZ624WcSmhghbLdKs+ls9vafvymjmuenPkRqRSk55Dncvv5s6i5tZd2Risho5vr+UZa83PXV+uPQgqqKQ7ImkqkTc5JIaFbZtuwkDZERn8Ndpf8WkmFh8ZDHPbH6GtCGxjJwl8hC/++BQk/nB+1wHARhR1Re/X8URbakfBW2niC2I6fMnL3gSEMutPr/teQZOSGH87N4ArHrnAIe2nHkp4/11wobYSpG3mnh6dKmV/WEb486Rd3Jh2oV4/B7uWn4Xe0v3csnNw4hNcVDlcvPJ37ZRfYY2UPtO7QBgWE0S7uo6DCaF+J4hHQbaKWILkByRzHMXPYfVaGXV8VU8tu4xegyI4cLAgGHz4qNNrkq21x9YUrVCRE/rRUHb2db7x93PxJSJVNdVc8eyOzhaeYTLfjac6AQb5UW1fPrc9jNGGfeVZgEwsloMapzJDqyOkMhyO6R3aAyKG8Tj5z8OwH/2/YdXdrzCoIkpjL1MtMRa8db+My65Xe2t5ohRFV3nTonzMen06f128qnRYOSZac/QO7o3+VX53LHsDjyWambfNQKzzciJgy6+WrD7jItM7KsWAj29Woj2pN4yWitpP6Sw7Y7U1VITaB9k8YkbvVmb+taLrFq+kEFjjE8ZrxfYvL7ndV7Z8QoxiXZm3ZEpIi+bC/n2/Tb2gQ1w0i9s7qOIaTKL3RS8QeipCG2PfIJYgejlGS+TGpFKbkUuty29jUqTi8vvzMTqMJGfXc7il3Y2v8RmbRnZgelyk8sJQHxqIxFbaJdoc4I9gZdnvEy0JZqdRTu5fentWJL9XP6zTD0Stuzfe/GdoSH6noBYHFUpbsKxKQ6xiIBub9uKx07nvJ7n6Tfit/a+xfxN8+k/KY6RF4vCl5Vv72fvd42L253lYjpyYKXIeUzpG3NaFLR9IrYal2Rcwu8m/g6ABbsW8Petf2fc7N4MnpyC6lf5+l97OLi5oMHrPD4Pe9VaUBXqCkVrol6DY+tvZGlboVsoBsXAn6f+mXHJ46jyVnH717ezt2I3c34+SkTvC2v49LkdVLkaRhm3F+0CYLhrOAA9+sVgNIVc5ttRhIHIt/7z1D9jUAwsOrSI3635Hf0nJeq9WL/74FCjK6gV1xSTq/gw+cxUFwjfNfBpO0VsQUSYn5v+HMPjh+Nyu7hlyS0cdR9mzj2jsEdbKM6r5JPntjUaud1eLiLPaWWZAPQcdPqxbz8BDjCrzyx+O+G3ALy04yWe3/Y8E+b0YdDEwHn66p5GB2G7CrbiVxT6VyRRUyG6YaT0jam/UTse/1hbLP+45B8k2hM55DrEvCXz8DtrmHVHJkazgaM7i1iyYHejs37b3GIGxFEqIrZpQ+LabI9EoiGFbXfD5wXVp0dsNWFrsQXEiUlrWt8+whbgqgFX6e2GXtrxEk9veprUQU6m/zRQZLHyOKvfOdC2yG2dhxOKuMCl+sVNLzohJDqnCUR/XZvTLDRSIlJYcOkCEu2JHC47zN1r76Yisog594zCbDOSd8DFor9ubXIasqjsKAUmE0afkcoT4vP36OcMbmAwBldNa0NnhFD6Ovuy4NIFOK1OdhXt4qavboK0Ki65eRgGg8LBTQV8+cquRiPO2yvETTgjcBNOHeCsv0E7RsY15vSbw8OTH0ZBYWHWQp7c/iQj5/Rg+LSeoMLKt/az8fMjDQZHm6pEqkJUiRBh6cNOu7m1Y8RWY+7gufxy7C8BIW4fXvswF/ykP4MmBcXt1iU59WzdcWoHbgUGuTJwVxux2Iykhp4D0C45tqHYTDaen/48IxJFasptX9/Gpsq1fP8Xo4hwWinNr2b5Pw5RdNqiCBtL9wOQWDIOgN6ZCfV3rIkwn7vNefoaF6VfxNNTnsakmPgi+wt+vuLnDLokLthC8MNDrH4nq97qVJvyNwEwuXAIvjqFqHgbcaEDRmi3KX4NbbA7KHYQxbXFzFsyj72+7Vz5i9HYo8wUHavkg6c3U3wi+H4+v49N1ccx+A0Yi4cC0Dszvv6O23mwAGI1Ra1W4J87/8njGx5nyvX9GTghGb9fZcmC3Q3O0w3HxKqLEwpHA0IsmiynLXjQjjMLIAqRX730VZIcSRxyHeKGL2+gJrmIy+/MxGgycGRHEYv+Wn/AcLLyJLn+WmJqYqkuiQMFMobHN/EuEknLkMK2uxFoRl8diFyZ6oRo0lMRzFq/15Y3rW+KG4fdyG/G/waAt/e9zb0r7qXHaAcX3TAYFNi9Oo8lC3aHN33fGLUujgcqixM9Ylqt0VxVaFfRlR6dzpuz3iQ9Kp2CmgKu+/I69hg3872fj8IWYaYwp4IP/7T5jAVlewq2ATDa1Rd/nYo92tKw32IHiMWh8UN5beZrejRk7hdzKUrNZtadIhqSs6uYD57eUm+5YFVVWVeVg8FvxBK4CfcZmdjhtgJcM/AanrzgSbHYxMmVzPt6Hn0vdzAmMIW66fMjfPnKLmoqxA3uROUJDnldJFek4alIxGBUGtrazhFbjZuG38Qjkx/BoBj45PAn3Lx0HkN/4NSF+LqPD/P1q3v0POwVuSsAmHRiGgD9xiQFe+3qtrZfdFEj0hLJgksWMKXnFGp9tdy78l7eOPYq3//VSGJ7OKipqOOjP29l58pjqKpKYXUhO6rzSK7ojbeyF4pBYcD45NPsDJnybUdbL+tzGX+76G9YjVbW5K3h+sXX47zAG1yZbFUei/66DVdgdbllOUtBVRiSPx2AQZNSGjbn7wDB6LQ5+fdl/9aj4Xcuu5MPTr3N9+8fTXSinYriWj58egu7V+ehqipbC7dS6nczomA8dR4bjmgL6UNPG4C1sT/smbg181YenvwwBsXAhwc/5Oal8xj2wzgyp4mUqHUfH+arf+6mptKDqqoszVuFpc6Os2QqAIMnpzTcaTvl2IbS19mXNy57g7SoNPIq87h+8fXssW/kintGYnWYKDhSznt/3MSxvSKnelnuMgCmH78QgLTBsUTG2s60e4mkxUhh290IRGK1VARTXaDCXY/Ytq1pfVNcP/R65k+Zj8Vg4Zvj3/Cjz34Eg11cMm8oBqPC4W2n+OjPW/UlJVtEyJR+dJUQMPUiNEZzMM2inUVXr6hevD7zdYbHDqfSW8m9K+/l7ZJXmfPLTD3H7v2nNrH3uxMNoorrC4WwHVY6BoDew+Mb3oDbsfAtlAGxA1h4xUKGxw+nzF3G7V/fzvu1/2bWPcNwxIhenO89tZnty3Lx+/xsLdxKka+WkQWTqPPaiHBaSRvSxLRpC5cqbY45/eaw4JIFxFpiySrN4povriFv6DYuvG4QBpPCkR1FvPPERnavzmPR/k8x+Sxckv0D8VnHJQfbEmnYYkJsbb8iRoAfDvwhz09/nihzFDtP7eSaL66heNwepv5YrPh1aEsh/310PRu/Osyq3WsZln8B9vIxoMDIQB/cerRzJEzDYXbw3PTn+MlgsWT0gl0LuGvD7WTeEk2PgVH46lS+ffcgH8zfzPtfLCG1bCCXHRTbDp6UElyYQ8NoDs4wtLOt09Km8casN0iJSOFo+VHmfjGXLT2+5pLbhmC2Gjl5uIyF/7eRr97aTtbOE0w5cg2G2j6YLAYyp/VquMN2nuLXiLJE8colr3BV/6vwq36e3/Y892+/i/F3iqWMvW4fq/6bxYd/2sLnX37LwMLxTMi9EoDRl6ZjMJ5pUNP6/rBn4pqB14jz1CLO0x9+fjUFY3dywY/6YwgsNPKfh9bz0X+/xX/cycwDN+L3RRKb4mg4UIR2Kx48nV5Rvfjv5f9lUo9J1NTV8MDqB/hb/pNcfG9/nMkiN/zTv2/nsxe2s3rVdkaeuIjkIiHAx1zWu11tkUiksO1uBCKxNYEiMUNA2Jr1iG37tMU6E7P7zubNy9+kZ2RPjlce57ovruMr03vMvm+4nov27pMbGxWBTVLj0oWtckp8hoRepxUMdOBni7fH8+ykZ7l+sKiOfn3P69yy4QYGzrPQa3AsdR4/K9/az+KXd+nC3a/6+aZ4J1avg4gSIWwbRMDq2d2+ghxEgd/rs17nBwN+gIrKm3vf5O49N9PrRi+pA53UuX1898Eh3n50A59/sJ7ReTMYn/N9AMbMzGh4Ew6NjHeAvWOSx/DKBa8wKnEUVd4qHlv3GH+seIDBt1iJTXFQU+5h1X+z8L7Wm59ufoLI6r5YLH4mBnr21sMaUkzUzlFbED1u35vzHsPjh1PuKeeRtY/wdPVv6XuTAWeKg5oKL5sW5TB7471MOXKN+HyXpBGfGtlwZx0kGEDkhz448UH+PPXPRJoj2VW0i5+uuI4NIz9g4BXRmKxGCnMqYHlP5uy9C7s7mUiHm8k/6Nf4Dts5bSKUYfHDWDh7IdN6TcPr9/L3bX/n50fn4byhhJSBUfi8fg5/V8Jle29jWMH5AEybO6jhoAY6JGKr79po5fHzH+fx8x7XF6uZu/xadk78nAGzozGZDRQcKSdpwyimH74eg99Bjx4eMi9qQoC3oT9sU0ztNZX3rniPzIRMKrwVPL7ucZ6s/BWpN3iI6+nAU1NH/rd1XL7/Z/QsG4LJ4GX6jUMwGJSGO+ugwQKIaPjLM17mZyN+hlExsuToEn605kqKLt9I7/NjUBTI3V3CqB2zmZxzJWAgc4KDXqfnLEskbcTU/CaSTiUQrawJrMpi8JrwQbBvqp6K0P4XUI1h8cN494p3eWzdYyzNWcqCXQtYGr2Uu3/6CyoXR5OfXc7Kt/ZzeOspplw7oH5T/TPgqsgjz2zC5o2gtlhECpP7NFIFXevqkIsugMlg4tfjf82EHhN4Yv0THC0/yq1r5nHpyEu5vO8NHPiqlKM7izi2t4Qh5/fAPaCA4so6pmdfi99nI75nROMXYU0otGMuaL3dG608dt5jXJx+MY+ufZSj5Ue5f9PPyRyYyayMH1O9JoryUzUknBpCAiIvOiO9Vkytn47ZIZYqVX3CXmv7VyMn2ZN47dLXeCdLdB/YeWonPz/1MzKG92Z86iU49qThcItobKShkEu/HxHsjhGKySJmKOpqha329r8B9orqxZuXv8nbe9/mpR0vsePUDnacupuo/tEMcI4j4/hI4qt6YjNUMDZ6JWOvfKHxHVk6TthqXNbnMsYkj+GpDU+xLHcZi48vZjGLcY5KYODxiaSXDiPKZ2e4spvJV6RjjzxD+yRrJFQXddj3LN4ez/PTn+ez7M94dsuz5FXm8cSehyEOeg0ZxJDCycRXp9JXLWBiwhb6Tn6r8R110BR/KFcNuIqJPSby5IYnWX18Ne8ffJ/3eR/7iCiGFpxPmmswiX4T45UNjPnhVRhPHyhCUCyCEOHm9l8atldUL96a9RZv73ubF7a/wL6Sffyh5FeQptDPMZL+RWOJ9SQy3HeM84adILHPzMZ31IGDGhDX2LtH381FaRfxxPon2FO8h1f3LwAWEDMykeH5U0iu6EMvXy0TzavIvPrZDrFDcm4jhW13I3BjrNFWGfMGuiNYAxFbrXjM2745tqcTY43hrxf+lWU5y/i/9f/H0fKj/GrLvYzNHMfV/W7j+Eo3uXuKeeexEjIv7MW42b3rN1c/jZ0lewEY7RK5n3GpEQ2316KJHXTR1bgo/SLGJI/h2S3P8tHBj/g692uWK8uZOfN7DN1/EZVH/OxelQer4Eb+DwCD4mfq3EHBpUlDsTvFY62rQ+2e2msqi65cxGu7XuPtfW+zq3gXu9iFKdPCgKKx9CwbSH+fhSm+dQy76qbGIzaKIgRidZGwN6YR8dsOGA1Gfjrsp8zqM4sFuxbw0cGPyKk6So51AYyGIaaRPHqikMFVmzAM+PLMO7JGC2HbARFbDbPBzE3Db+Lyvpfz+p7X+ezwZ7jcLrbGriAraQP397mSa5c8BXH9oDGfQodGbENJciTx7EXPsjV/K69uf5VNRZtwUcTmjC+JmeLhF0f2Ep2zDpJeO/NOtEh4javD7FQUhe/1+x6XZFzCu/vf5ZPDn3DIdYjjzixM6W5+lDqDiV8+Ainjz7wT7XtVU9phdoIogHrx4hfZnL+Z/+z7D2tPrKWGCvb3/ZYRg3pw5zcLMFecwB9za+M7MBjAGgPuMvGdimwkBaAd0L5Tc/rN4a29b7Hk6BJyK3I5nLCd2GEm7jb3ove3f4ekG868E70gs6xDbNQYljCMd2a/w8pjK3ln/ztsLthMmf0UB4euYcbQvvzwA1HPQcQbHWqH5NxECtvuRuAGXm00Aj7wBIStHrHVuiJ0XMQ2lBkZM5jYYyKv7X6Nt/a+xZbCzWxhM5OmTOOCYz+g8pDKjhXH2PvdCYZP7cnIGWkN8/qA7wLCdpCWq3p6ZTEEcyo7UMRoxFhjePS8R5k7eC5/3/Z3Vh9fzWLXxyxO/phU+wCG50+hl2sQFr+NGNMxpp5fRWr/GY3vzOYUjx0oFDSiLdHcN/Y+rh96PZ8e/pQVuSvIq8yDRBfnD+rN1Z89hFJxAqJ/feadaMK2gwUDQKIjkd9N/B33jbmPdSfXcbLyJD0je3Je6mSsT/cBxQ+RSWfegS0aqgo7LBoeSpIjiQfGP8Avx/6Sg66D1NbVMihuEPYDX4sNHE1UbuuCwdXhdoJos/X4uMdxRDsoqCkgzhZHjDUG9kwSGzRlq/a/mpIOt9NusnPT8Ju4afhNlNaW4vV7SbQnomx9s3k77YEireqOP08BxqWMY1zKODw+Dy63C6fVicVgRl08X2zgaKIllSNWCNvqYmBAh9oZa4vl52N+zj2j78HldmFQDOLYf/Vg83ZqPu2EY68oCtPTpzM9fTo1dTVUeauIs8VhKA6s9GeJErMyEkk7I4VtdyMQrawyGAAffreIEAVzbLWIbcfk2DZGlCWKe8fcy48G/YhXdrzCp4c/ZX3tKtYnrmJM9BQm5szBW2xl29Jcdq48Tt/RiQy7IJXUgU4URcHr87K0/AAxNYnYSkRD7oETGqnY1YRtB0cTQhkUN4gXL36RrJIs3j/wPquPr+aEcpCTMYe4IPUCflNYRMbBJdDvmTPvpJMitqEk2BO4efjN3Dz85uCTqgpVYtUqIpqIGmlT+p0gbDUcZgcXp18cfMJdETyHI5oQth3UGaEpjAYjg+MGB5+oEMvpEt3jzC/SBFp1xwuGUGwmG31i+gSfqAz04W3q+GvCp5NtjbWFpJJUBfqwOhIa3xiEWIROEWGhWIwWkhyBc7LGheILtFaMaMJWexyUHu1UnyqKUt+n2nka2UgdgIZ+7Is7zrBGsJvs2LXZxorA6mlRjdwDJJJ2QArb7kZgKrNCAZPPjBooBten7TuwK0JzpESk8Oh5j3LXqLt4e9/bvJf1Hlv5lq0DvqV34nCmFv4AR0k8BzcVcHBTAVHxNjKGx3PQvJOY/KFMOH4JqAYyhsfXXw1JQxeInSdsNQbFDeIPk/4AQLmnHLPBLC7E/wrkqjUlFDoxYtskNaXgD/Qm7WbCtgGVAWFjjggWCTVGB/SybTHlgQUmopoStgHRU+sCX11whcDOxFsTFIHRqWferhOjdmdE82k4dnayAK9HwE6/1RksEm0Mx/+IT7toAFaP8oCwbWqgKJG0ASlsuxsBYVuOH1uduKkbTApm62kR23buY9sSEh2J3Df2Pm4fcTtLji7h40Mfs03ZxlHnbhKr0hhScB4Di8dRUYzIVSWeGfwUAIe9jmk/GdT4jrWIbRcLxGhLSFFbpRYFaSKqqAnFTozYNkp5nnh0JASLDBujk3IXm0Sztbmbm71ronb10CJhTUWY7E5AAVRha1PnS0ehCRuzIzjYaowuitrVQxc3TYmwgJ11NUK0d0BRVrNUBIRtZHLTLYR0wdiFPq3QBmDdfFATjp0SSRuQwra74a7AD1TgI94riqnsEeZg71Rz5xSPhYPD7OCqAVdx1YCryC7LZlnOMlbmrmR15Lus7f0xPcsGkOYagrM2iR4+G6P9Oxnzo2lENFYBD12SitAkfn9IFKSJIqvuIBQByjSx2MwNw94NhE3ZcfEY00hP2FC0NIXKhkuIdhrh3IgNRiHCa0qEX7tC2FaEiMXTey2H0i0iodq52sT3yhoNBpNYjbC6pMMKHZtEi9hGpjQtbLv6O6Wq3Tplph4yYivpYKSw7W54Kqg0KKiArU4IW1to2x49FaHrhW0ofWP6cvuI27l9xO0U1RSxr3gfR8qOYDKYmNhjIv3evAZKDkPy1WfeSXcTttVFgeV9lWYiS4Fp6KqiTjHrjGhiIaaRXpuhaKKr8lTH2tMUurBtztZASkVVFwrb0hzx6ExvejtHvBC2XXUeuMQSxc0ObHSfduXxD8NWRREDm4oTIne4K4RtwKf+iGbyQTWfdtV3qiJfXKsUY9MpMxEBYesuF+lsTc3sdBSuwPepuUGtRNJKpLDtbtS4KDeI2ECUzwmALTLkMHVSW6G2kGBPYEqvKUzpNUU8oarh5SnquapdHPnU0MRXZLJYselMRHaDqCKEiIVmBIBWXKKlWXQFrlzxGHbEtosEg68ueB7E9m5628gkKD4YLODqbEqPiMfYPk1vp30HtQhvZ1NTGvyON+fTqGQhbCu66FwN+NTnzGh6O82nXfWd0o59TK+mr1U2Z7A3dMVJiGvmXOkISo+Kx+aOvUTSSuTKY92NqiJd2DpVEQm0RYREbDXx19X5nC2huiSYE9xUhE4TiF0ZnQtFE1/OZsSXJhSrCtt9mdoWobXRiWtkFa9QojRh24V+LskWj83Z2tXnRPlxsZiF0dp0tTkEo49dJRhLAuKmObGi5QpX5Lf7ErBhodkZmdx04SB0vWAM2OqLbk7Yhvi0Kwj32CtK19qqqkFh2xWiWnJOIIVtd6PqFKVGUSgWUyeEbaQzpC+sns/p6ly72oIWSYxMBlPDHrc63SXyqVF8SDzG9296O60Dgb+ua6PNmrCNP8NSqhqaQOuqmzBA0UHx2Jyt2k1Yi/h3NpqdcX1FI/6m0ERYV9laEubAJjLgU291p7ZR09EGNc1FlqHrRVjgGhB2xLarBjXataq5Yw9da2vZcREtNphkKoKkw5DCtrtRdYrCgLB11ol8qIhQYdvd8lDDQZ92bi6fMiSS2BWRpNPRI6DNiC+TJVg80lWRJb8vKBiaE+JaEVR1Udfkate4ghHY5mzVBEVlQZe0uKNwn3hMGtz0dhCM2HaFsPX7g7YmDml6W0tI1wSt4LAzKdgjHsPxqXauaukgnUnFSah1oSpGfM7mZkECYrGmVF8WvVMJ99hDyACsC459oVioh4SBTadMSCRtQArb7kZVEacCwtbhFiI2MjZU2DrF4/9SKkLRAfEY38yKPHrk09s98mxP7RePCc2ILwimK2iFRp1N8WGR7mF2NJ+75ogTq/5AcNDRmeTvEo/O9GCf2jNhjwVLYLq6K8SNdiMORzBoEShXF5wDpUdEBNZoDS9qp50jWm5mZ6L5NHl489tqdpZ0gZ0FATvj+zc90wRiJk1rTadNtXcmhYHBQvLQ5rftUp9qg5ow7JRIWokUtt0JdwV4qyg0CWFrrhUNwSMaS0WoLevafM6WcCpLPCaeoX+thskabEfTFdGEUHze4EU4ZUTz22vTql1xUwPI3ykek4eJ1lNNoSgQ11v83hX2ntwhHnuMbH5bRQl2I+gKW/O2iMfUUc1vq0Wfiw51/ozDiW3iMXlYeItDaOJXi/J3Fqoa9GlKZvPba3Z2hQDX7QxDgEPwGtDZPq0sDA5QwxksaOk/nW0nBH3aI4xrqkTSSqSw7U4EbtwFVjsGvxGlQkzVxCSFNCbXIraqv2vy41pDwW7xmBjG1KN2I9PSALqKwn3gc4temuHkAnZlBAwgd514TB0T3vaavVpuXmfSUlsTApH+U/s6xp4zUV0SnG3oNb757eP6gGIAT0Xnd0bIXS8e0yaGt70mbrQc4s6iJFu0GTNaoMeo5rfXCowqTnZ+J5hjwqdquD7Vrl2d7dNjG8Rj4pBg4KMptNSqzv7uqyoc2yh+7zWhc99bck4hhW13IjCCzrZYialNBFXBYjPiiA7pimC2BcVtVxWptITa8mD+V8+xzW+vR5K6WNge/VY8pk1svmgIRM4YBKcvO5sjAXt7XxDe9lpkR0sL6Cx83qBv+0wN7zVJw8RjZ/v28IrA+w8NroLVFKaQNID83R1n1+moKhxaJn7vfX54r0kO+FSL9HcWmk97jguvh6ojLti+7mQn2uqphpy14vf088J7jRbZ1WYkOotDy8VjuMc+KZBWU3ascxdqyN8lcuvNDkgd3XnvKznnkMK2O1F0ELcCxxUfcdWiGtiZ7AiuOqYRGyio6YpcvpaSsxZQxXSy1maqKbTpXC19oas4sEQ89p0W3vbatPrJHZ2fIlJ0EIqyRKVxuGJRS684sb3DzGqUo9+KNBpHfHgROwhOWedt7jCzGmXfp+Kx/4zwX6MN3jrT1oI9YqbAYIa+F4b3Gs33+bs7tyhP8+nAS8N/jSaCTmxtf3vOxKGlono/Ji38fFDNp51pp68OshaL3wfMDO81dmcwapvXibZqx77PtK5ZGEJyziCFbXfi+Gb2WSz4gfRqMapO7hPTcDutUryrCpVawr7PxOOAMG9k2vT08U0dY084uI4Fo4pD5oT3msTBYI4Q09CdHQXb8rp47Dc9vKlIgLQJgCKm9zuzldKmf4nHoVeGlwsKkD4JUERaQHkntSgqPwlZX4rfM38Y/uvSAlOs2d+0u0lnZHPAp4NmBRdwaY7Y3qI63u+FnO86zLR6nDoAR1YDCgxvYgXC00mfLB4Pr+wQsxpFO08zf9j08sSh9BonBheu3M5Lpdr/uUh7ccSHP6iBEJ+u6BCzGuCthW3/Eb+35PskkbSCc0rYvvjii/Tu3RubzcbEiRPZuHFjV5sUxOeB3LWss9tAhT7lYlqrR/9GhK2Wd1bYRdPe4VJ5CvZ8JH4f9oPwXtNrrMhTLMnumqpdgFXzRQ5zn2nhr45jNAVvLPs/7yjLGlJ6NHgTHn9r+K+LSAhGwvYsam+rGufwioBvFJhwW/ivc8QJ0QCw+4MOMa0eqgpLHxLfyfTJ4RW5aQy8TDzmru+cgWfeVtj6pvh94s/Cf52iBAebuzrBp34ffHG/+H3w7OaXJw5Fs/PIqs4ZhO3+SLyXwQTjbg7/ddYoyAikLex8r2NsC6W2TJynAONuEW0Hw2VgILq752ORHtTRrHpa5ElH9ww/WCCRtJJzRti+++673H///TzyyCNs3bqVkSNHMnPmTAoLu8liAHs+wu0u45PoGHqWDcRSEYnJbCBjWHzDbbXR9pFV3aPfa2N4quGTu0QLotTRwQt+c9hjg9Ppm17tOPsaw++DVX8ORhYu+l3LXp8ZiEJt+lfn9AfN3w1vXinafGVcEH5UXGPUT8Tjd891bCRUVeHgUnj/JvH3hNuDeX7hMvp68fjdcx3rW3cFfPFL2PW+GGBd8njLXh/TKzDAUWHJ7zpUNJiPr0N59zqxMMjQ74efX60x+gbxuOs9yFnX/gZqVBXDxz8TsyDmCJjxWMtenzgQ0iaJz/nVg+J72hH4/ULkf3K3+Pv8+1omwAHG/FQ8rn+5Y4vISo7A29eK6LAzHc67u2WvHzhTtFesOAHf/qVjbASoc8PqZ2DNs+Lvy55qvnWaRNJGFFXtrsqofZk4cSLjx4/nhRdeAMDv95OWlsY999zDb3/72yZfW15eTkxMDGVlZURHN9N3swVUlJxk5VcfUV50nNrSHPaZbJT5UhhWeAGWOhuZF/Zi6o8HNnxhbTn8ZZAQjWNvEgVOZru4EXcUqj/wo4b83shPdYmIIh78WkyRGa1wy5KWFQsc+Br+e434feiVYnrXGi0uiKc39W709FUbbONXVSorK4mMjMSgKEJweKvFAgXuCig+CLkbxBKqANMfgqm/Ct9mEPlu/5giIumOeBj+QxFdNztEFbjRLCJlp9us/62e+e+6GjFY8FaLm1nBnmAunzMDbvqi+aV/T8dbAy+fJ6Ljjnjha81es11Mq4Y7Dauq4HPj99ZSXVGKw2LC4KkQth7bGMwH7zUBbvi4+aVUT6fOA69cIHKJbTFCyDkzhN1Gs4iuGUxB/2rnKWr98/b0v7XV4qqLRZV47gbwBhrsX/E3GDevZXaCaGn06iViKd7EwSJHN7qnyCs02YWdjXG6r1W/EAY+j/ipc4soXXke6vFNKFq7pqShMO/L8NNQQnn3epEuZDCLSGrycOFfsz0gQEJsOtO5oKoBG93ie+XziKnnihNC3B3bKP6nGOHqBS1LQ9DIWQevXy58kjRUpN1Epwo7zQ6x79NpzF7NvtCf6pLAebohuBpXv+nwk/fBaMLv91NSUkJcXByG5gpJ/T54dYb4bpojRHQycaC4fpnt4jpAI3adbqvf19BOT7Vog1iwJ9DeTQVrjPg+9QqjMPd0trwBn/1c/J4+WfxEJgWO/RnuJw3OUVWks9SFHHufW8zWlR4Rx80dWExo8t0w88kzmtMiP7eAjrp/S7ov54Sw9Xg8OBwOPvjgA6688kr9+RtvvBGXy8Unn3xSb3u3243b7db/LisrIz09nZycnHb9Yhw9uJllLze+8lNieiSzfpaJxX6Gm+D6lzCsmt9utnQEakwv1Mv+HH61bgjKiv9D2fTPDrCqaVRrDOq034poZriiLpTSoygf3opSfKD9jWsEddBs1IsfDa8wrzFcOSjvz0Mp6djWP6rBAmNuQJ3yK7BEtG4nrhyUj+9A0ZrRdxBqbF/U6Q9B/4tbv5ODX6N8dh+Kt7L9DDsNVTGhjrgWLvp9+Lm1p+OpQvnsXpRDX7evcaehJg1DvfiRQL50K8lajPL5L1DqOm61PNUSCeNuRT3vHn0Q7ff7cblcOJ3O8ARXVTHKR7egdHARmdp7Kuolj4e3IEejO1Bhwysoq55GoeMKXtXIFPG9z7ymyWtqi/0cJuXl5WRkZOByuYiJaSS1T3LWcU4I2xMnTtCzZ0/Wrl3L5MmT9ecfeOABVq1axYYNG+pt/+ijj/LYYy2cLpNIJBKJRNItOXbsGL16NbOsu+SsIMyy5HOLBx98kPvvv1//W5siiY+Pb9h6q42Ul5eTlpbGsWPH5DRJByL93DlIP3cO0s+dh/R159BRflZVlYqKClJTU9ttn5LuzTkhbBMSEjAajRQU1F8NqKCggJSUlAbbW61WrNb6Ce5Op7MjTSQ6OlpeNDsB6efOQfq5c5B+7jykrzuHjvCzTEE4tzgnuiJYLBbGjh3L8uXL9ef8fj/Lly+vl5ogkUgkEolEIvnf5ZyI2ALcf//93HjjjYwbN44JEybwt7/9jaqqKubNa0XVs0QikUgkEomk23HOCNsf/ehHnDp1iocffpj8/HxGjRrFV199RXJyK6vJ2wmr1cojjzzSIPVB0r5IP3cO0s+dg/Rz5yF93TlIP0vai3OiK4JEIpFIJBKJ5OznnMixlUgkEolEIpGc/UhhK5FIJBKJRCI5K5DCViKRSCQSiURyViCFrUQikUgkEonkrEAK2y7kxRdfpHfv3thsNiZOnMjGjRu72qRuw1NPPcX48eOJiooiKSmJK6+8kqysrHrb1NbWctdddxEfH09kZCRXX311g0U4cnNzmT17Ng6Hg6SkJH79619TV1dXb5tvvvmGMWPGYLVa6d+/P6+//noDe86VYzV//nwUReG+++7Tn5N+bj/y8vK4/vrriY+Px263k5mZyebNm/X/q6rKww8/TI8ePbDb7cyYMYODBw/W20dJSQnXXXcd0dHROJ1ObrnlFiorK+tts3PnTqZMmYLNZiMtLY0//elPDWx5//33GTx4MDabjczMTBYvXtwxH7qT8fl8PPTQQ/Tp0we73U6/fv144oknCK2Tln5uOatXr2bOnDmkpqaiKAqLFi2q9//u5NNwbJGcxaiSLmHhwoWqxWJRX3vtNXXPnj3qbbfdpjqdTrWgoKCrTesWzJw5U/33v/+t7t69W92+fbt6+eWXq+np6WplZaW+zR133KGmpaWpy5cvVzdv3qxOmjRJPe+88/T/19XVqcOHD1dnzJihbtu2TV28eLGakJCgPvjgg/o22dnZqsPhUO+//35179696vPPP68ajUb1q6++0rc5V47Vxo0b1d69e6sjRoxQ7733Xv156ef2oaSkRM3IyFBvuukmdcOGDWp2dra6ZMkS9dChQ/o28+fPV2NiYtRFixapO3bsUL/3ve+pffr0UWtqavRtLrvsMnXkyJHq+vXr1W+//Vbt37+/OnfuXP3/ZWVlanJysnrdddepu3fvVt955x3Vbrer//jHP/RtvvvuO9VoNKp/+tOf1L1796p/+MMfVLPZrO7atatznNGBPPnkk2p8fLz6+eefq0eOHFHff/99NTIyUn3uuef0baSfW87ixYvV3//+9+pHH32kAurHH39c7//dyafh2CI5e5HCtouYMGGCetddd+l/+3w+NTU1VX3qqae60KruS2FhoQqoq1atUlVVVV0ul2o2m9X3339f32bfvn0qoK5bt05VVXEhNhgMan5+vr7Nyy+/rEZHR6tut1tVVVV94IEH1GHDhtV7rx/96EfqzJkz9b/PhWNVUVGhDhgwQF26dKk6bdo0XdhKP7cfv/nNb9QLLrjgjP/3+/1qSkqK+uc//1l/zuVyqVarVX3nnXdUVVXVvXv3qoC6adMmfZsvv/xSVRRFzcvLU1VVVV966SU1NjZW97323oMGDdL/vvbaa9XZs2fXe/+JEyeqP/vZz9r2IbsBs2fPVm+++eZ6z/3gBz9Qr7vuOlVVpZ/bg9OFbXfyaTi2SM5uZCpCF+DxeNiyZQszZszQnzMYDMyYMYN169Z1oWXdl7KyMgDi4uIA2LJlC16vt54PBw8eTHp6uu7DdevWkZmZWW8RjpkzZ1JeXs6ePXv0bUL3oW2j7eNcOVZ33XUXs2fPbuAL6ef249NPP2XcuHFcc801JCUlMXr0aBYsWKD//8iRI+Tn59fzQUxMDBMnTqzna6fTybhx4/RtZsyYgcFgYMOGDfo2U6dOxWKx6NvMnDmTrKwsSktL9W2aOh7/y5x33nksX76cAwcOALBjxw7WrFnDrFmzAOnnjqA7+TQcWyRnN1LYdgFFRUX4fL4Gq54lJyeTn5/fRVZ1X/x+P/fddx/nn38+w4cPByA/Px+LxYLT6ay3bagP8/PzG/Wx9r+mtikvL6empuacOFYLFy5k69atPPXUUw3+J/3cfmRnZ/Pyyy8zYMAAlixZwp133snPf/5z3njjDSDoq6Z8kJ+fT1JSUr3/m0wm4uLi2uV4nA2+/u1vf8uPf/xjBg8ejNlsZvTo0dx3331cd911gPRzR9CdfBqOLZKzm3NmSV3J/y533XUXu3fvZs2aNV1tylnHsWPHuPfee1m6dCk2m62rzTmr8fv9jBs3jj/+8Y8AjB49mt27d/PKK69w4403drF1Zw/vvfceb7/9Nv/9738ZNmwY27dv57777iM1NVX6WSI5B5AR2y4gISEBo9HYoLK8oKCAlJSULrKqe3L33Xfz+eefs3LlSnr16qU/n5KSgsfjweVy1ds+1IcpKSmN+lj7X1PbREdHY7fbz/pjtWXLFgoLCxkzZgwmkwmTycSqVav4+9//jslkIjk5Wfq5nejRowdDhw6t99yQIUPIzc0Fgr5qygcpKSkUFhbW+39dXR0lJSXtcjzOBl//+te/1qO2mZmZ3HDDDfziF7/QZySkn9uf7uTTcGyRnN1IYdsFWCwWxo4dy/Lly/Xn/H4/y5cvZ/LkyV1oWfdBVVXuvvtuPv74Y1asWEGfPn3q/X/s2LGYzeZ6PszKyiI3N1f34eTJk9m1a1e9i+nSpUuJjo7WBcbkyZPr7UPbRtvH2X6sLr74Ynbt2sX27dv1n3HjxnHdddfpv0s/tw/nn39+g5Z1Bw4cICMjA4A+ffqQkpJSzwfl5eVs2LChnq9dLhdbtmzRt1mxYgV+v5+JEyfq26xevRqv16tvs3TpUgYNGkRsbKy+TVPH43+Z6upqDIb6tzaj0Yjf7weknzuC7uTTcGyRnOV0dfXaucrChQtVq9Wqvv766+revXvV22+/XXU6nfUqy89l7rzzTjUmJkb95ptv1JMnT+o/1dXV+jZ33HGHmp6erq5YsULdvHmzOnnyZHXy5Mn6/7U2VJdeeqm6fft29auvvlITExMbbUP161//Wt23b5/64osvNtqG6lw6VqFdEVRV+rm92Lhxo2oymdQnn3xSPXjwoPr222+rDodD/c9//qNvM3/+fNXpdKqffPKJunPnTvX73/9+oy2TRo8erW7YsEFds2aNOmDAgHotk1wul5qcnKzecMMN6u7du9WFCxeqDoejQcskk8mkPvPMM+q+ffvURx555H+2DdXp3HjjjWrPnj31dl8fffSRmpCQoD7wwAP6NtLPLaeiokLdtm2bum3bNhVQ//rXv6rbtm1Tc3JyVFXtXj4NxxbJ2YsUtl3I888/r6anp6sWi0WdMGGCun79+q42qdsANPrz73//W9+mpqZG/X//7/+psbGxqsPhUK+66ir15MmT9fZz9OhRddasWardblcTEhLUX/7yl6rX6623zcqVK9VRo0apFotF7du3b7330DiXjtXpwlb6uf347LPP1OHDh6tWq1UdPHiw+s9//rPe//1+v/rQQw+pycnJqtVqVS+++GI1Kyur3jbFxcXq3Llz1cjISDU6OlqdN2+eWlFRUW+bHTt2qBdccIFqtVrVnj17qvPnz29gy3vvvacOHDhQtVgs6rBhw9Qvvvii/T9wF1BeXq7ee++9anp6umqz2dS+ffuqv//97+u1kJJ+bjkrV65s9Jp84403qqravXwaji2SsxdFVUOWY5FIJBKJRCKRSP5HkTm2EolEIpFIJJKzAilsJRKJRCKRSCRnBVLYSiQSiUQikUjOCqSwlUgkEolEIpGcFUhhK5FIJBKJRCI5K5DCViKRSCQSiURyViCFrUQikUgkEonkrEAKW4lEIpFIJBLJWYEUthKJpNtx0003ceWVV3bZ+99www388Y9/7PT3/fGPf8xf/vKXTn9fiUQiOVuQK49JJJJORVGUJv//yCOP8Itf/AJVVXE6nZ1jVAg7duxg+vTp5OTkEBkZ2anvvXv3bqZOncqRI0eIiYnp1PeWSCSSswEpbCUSSaeSn5+v//7uu+/y8MMPk5WVpT8XGRnZ6YIylFtvvRWTycQrr7zSJe8/fvx4brrpJu66664ueX+JRCL5X0amIkgkkk4lJSVF/4mJiUFRlHrPRUZGNkhFuPDCC7nnnnu47777iI2NJTk5mQULFlBVVcW8efOIioqif//+fPnll/Xea/fu3cyaNYvIyEiSk5O54YYbKCoqOqNtPp+PDz74gDlz5tR7/q233mLcuHFERUWRkpLCT37yEwoLC5v8nIqisGjRonrPOZ1OXn/99SZfN2fOHBYuXNjkNhKJRCJpHClsJRLJ/wRvvPEGCQkJbNy4kXvuuYc777yTa665hvPOO4+tW7dy6aWXcsMNN1BdXQ2Ay+Vi+vTpjB49ms2bN/PVV19RUFDAtddee8b32LlzJ2VlZYwbN67e816vlyeeeIIdO3awaNEijh49yk033dQhn3PChAls3LgRt9vdIfuXSCSSsxlTVxsgkUgk4TBy5Ej+8Ic/APDggw8yf/58EhISuO222wB4+OGHefnll9m5cyeTJk3ihRdeYPTo0fWKwF577TXS0tI4cOAAAwcObPAeOTk5GI1GkpKS6j1/880367/37duXv//974wfP57Kysp2T5tITU3F4/GQn59PRkZGu+5bIpFIznZkxFYikfxPMGLECP13o9FIfHw8mZmZ+nPJyckAeorAjh07WLlypZ6zGxkZyeDBgwE4fPhwo+9RU1OD1WptUOC2ZcsW5syZQ3p6OlFRUUybNg2A3Nzc9vuAAex2O4AeeZZIJBJJ+MiIrUQi+Z/AbDbX+1tRlHrPaWLU7/cDUFlZyZw5c3j66acb7KtHjx6NvkdCQgLV1dV4PB4sFgsAVVVVzJw5k5kzZ/L222+TmJhIbm4uM2fOxOPxnNFeRVE4vTbX6/U2+zlLSkoASExMbHZbiUQikdRHCluJRHJWMmbMGD788EN69+6NyRTepW7UqFEA7N27V/99//79FBcXM3/+fNLS0gDYvHlzs/tKTEzk5MmT+t8HDx4MKwq7e/duevXqRUJCQlg2SyQSiSSITEWQSCRnJXfddRclJSXMnTuXTZs2cfjwYZYsWcK8efPw+XyNviYxMZExY8awZs0a/bn09HQsFgvPP/882dnZfPrppzzxxBMNXjt48GA+/vhj/e/p06fzwgsvsG3bNjZv3swdd9zRIOp88cUX88ILL9R77ttvv+XSSy9ty0eXSCSScxYpbCUSyVlJamoq3333HT6fj0svvZTMzEzuu+8+nE4nBsOZL3233norb7/9tv53YmIir7/+Ou+//z5Dhw5l/vz5PPPMMw1el5WVRVlZmf73X/7yF9LS0pgyZQo/+clP+NWvfoXD4aj3msOHD9drP1ZbW8uiRYv0gjiJRCKRtAy5QINEIpGEUFNTw6BBg3j33XeZPHlyp773yy+/zMcff8zXX3/dqe8rkUgkZwsyYiuRSCQh2O123nzzzSYXcugozGYzzz//fKe/r0QikZwtyIitRCKRSCQSieSsQEZsJRKJRCKRSCRnBVLYSiQSiUQikUjOCqSwlUgkEolEIpGcFUhhK5FIJBKJRCI5K5DCViKRSCQSiURyViCFrUQikUgkEonkrEAKW4lEIpFIJBLJWYEUthKJRCKRSCSSswIpbCUSiUQikUgkZwX/HzAeOGrHghBGAAAAAElFTkSuQmCC",
       "text/plain": [
        "<Figure size 640x480 with 1 Axes>"
       ]
diff --git a/tests/test_modeling/test_ode.py b/tests/test_modeling/test_ode.py
index c79f172e..6169c3cf 100644
--- a/tests/test_modeling/test_ode.py
+++ b/tests/test_modeling/test_ode.py
@@ -5,9 +5,7 @@
 import numpy
 import sympy
 
-from mira.metamodel import NaturalConversion, ControlledConversion, Concept, \
-    NaturalDegradation, SympyExprStr
-from mira.metamodel.template_model import TemplateModel, Initial, Parameter
+from mira.metamodel import *
 from mira.modeling import Model
 from mira.modeling.ode import OdeModel, simulate_ode_model
 
@@ -20,22 +18,30 @@ def test_minimal_ode(self):
         templates[0].set_mass_action_rate_law('k')
 
         # parameter
-        parameters = {'k': Parameter(name='k', value=.01)}
+        parameters = {'k': Parameter(name='k', value=0.01)}
         # agent (initials)
-        initial_value = {'X': Initial(concept=Concept(name='X'), expression=sympy.Integer('100'))}
+        initial_value = {'X': Initial(concept=Concept(name='X'),
+                                      expression=100)}
+
+        observables = {'X2': Observable(name='X2',
+                                        concept=Concept(name='X2'),
+                                        expression=sympy.Symbol('X') * 2)}
 
         tm = TemplateModel(templates=templates,
                            parameters=parameters,
-                           initials=initial_value)
+                           initials=initial_value,
+                           observables=observables)
 
-        # initialized flag when creating an ODE models signifies whether parameter and agent symbols already have
-        # values or not
+        # initialized flag when creating an ODE models signifies whether parameter
+        # and variable symbols already have values or not
         om = OdeModel(model=Model(tm), initialized=True)
 
         times_test = numpy.linspace(0, 25, 100)
 
-        simulate_ode_model(ode_model=om,
-                           times=times_test)
+        res = simulate_ode_model(ode_model=om, times=times_test,
+                                 with_observables=True)
+        assert res[0, 0] == 100
+        assert res[0, 1] == 200
 
     def test_simulate_ode(self):
         c = {
diff --git a/tests/test_template.py b/tests/test_template.py
index 050cd812..aafe7fda 100644
--- a/tests/test_template.py
+++ b/tests/test_template.py
@@ -1,8 +1,6 @@
 import json
 import sympy
-from mira.metamodel import ControlledConversion, Concept, NaturalConversion, \
-    NaturalDegradation, Template, GroupedControlledConversion, \
-    GroupedControlledProduction, TemplateModel, Initial, Parameter
+from mira.metamodel import *
 from mira.metamodel.templates import Config
 from mira.dkg.web_client import is_ontological_child_web
 
@@ -352,3 +350,36 @@ def test_extend_template_model():
                           initial_mapping=initial_mapping,
                           parameter_mapping=parameter_mapping)
     assert tm2.templates == [t1, t2, t3, t4]
+
+
+def test_set_rate_law():
+    s = Concept(name='s')
+    o = Concept(name='o')
+    t = NaturalConversion(subject=s, outcome=o, name='tx')
+
+    # String rate
+    t.set_rate_law('beta * s * o', local_dict={'beta': sympy.Symbol('beta'),
+                                               's': sympy.Symbol('s'),
+                                               'o': sympy.Symbol('o')})
+    assert isinstance(t.rate_law, SympyExprStr)
+    assert sorted(t.rate_law.args[0].args[0].free_symbols)[0].name == 'beta'
+
+    rate = sympy.Symbol('beta') * sympy.Symbol('s') * sympy.Symbol('o')
+    t.set_rate_law(rate)
+    assert isinstance(t.rate_law, SympyExprStr)
+    assert sorted(t.rate_law.args[0].args[0].free_symbols)[0].name == 'beta'
+
+    rate_s = SympyExprStr(rate)
+    t.set_rate_law(rate)
+    assert isinstance(t.rate_law, SympyExprStr)
+    assert sorted(t.rate_law.args[0].args[0].free_symbols)[0].name == 'beta'
+
+    tm = TemplateModel(templates=[t])
+    tm.set_rate_law('tx', rate_law='beta * s * o',
+                    local_dict={'beta': sympy.Symbol('beta'),
+                                's': sympy.Symbol('s'),
+                                'o': sympy.Symbol('o')})
+
+    assert isinstance(tm.templates[0].rate_law, SympyExprStr)
+    assert sorted(tm.templates[0].rate_law.args[0].args[0].
+                  free_symbols)[0].name == 'beta'