From 3d7aca9fe8705ca8544d046134f0d761953af242 Mon Sep 17 00:00:00 2001
From: Valentin Sulzer <valentinsulzer@hotmail.com>
Date: Fri, 29 Oct 2021 10:48:06 -0400
Subject: [PATCH 1/9] fix finite volume discretization in spherical domain

---
 pybamm/spatial_methods/finite_volume.py       | 52 +++++++++----------
 .../test_models/standard_output_tests.py      | 20 +++----
 .../test_lithium_ion/test_mpm.py              |  4 +-
 3 files changed, 35 insertions(+), 41 deletions(-)

diff --git a/pybamm/spatial_methods/finite_volume.py b/pybamm/spatial_methods/finite_volume.py
index 65e6fad18d..dee7285f78 100644
--- a/pybamm/spatial_methods/finite_volume.py
+++ b/pybamm/spatial_methods/finite_volume.py
@@ -171,18 +171,12 @@ def divergence(self, symbol, discretised_symbol, boundary_conditions):
         # check for particle domain
         if submesh.coord_sys == "spherical polar":
             second_dim_repeats = self._get_auxiliary_domain_repeats(symbol.domains)
-            edges = submesh.edges
 
-            # create np.array of repeated submesh.nodes
-            r_numpy = np.kron(np.ones(second_dim_repeats), submesh.nodes)
-            r_edges_numpy = np.kron(np.ones(second_dim_repeats), edges)
-
-            r = pybamm.Vector(r_numpy)
+            # create np.array of repeated submesh.edges
+            r_edges_numpy = np.kron(np.ones(second_dim_repeats), submesh.edges)
             r_edges = pybamm.Vector(r_edges_numpy)
 
-            out = (1 / (r ** 2)) * (
-                divergence_matrix @ ((r_edges ** 2) * discretised_symbol)
-            )
+            out = divergence_matrix @ ((r_edges ** 2) * discretised_symbol)
         else:
             out = divergence_matrix @ discretised_symbol
 
@@ -205,7 +199,14 @@ def divergence_matrix(self, domains):
         """
         # Create appropriate submesh by combining submeshes in domain
         submesh = self.mesh.combine_submeshes(*domains["primary"])
-        e = 1 / submesh.d_edges
+        if submesh.coord_sys == "spherical polar":
+            r_edges_left = submesh.edges[:-1]
+            r_edges_right = submesh.edges[1:]
+            d_edges = (r_edges_right ** 3 - r_edges_left ** 3) / 3
+        else:
+            d_edges = submesh.d_edges
+
+        e = 1 / d_edges
 
         # Create matrix using submesh
         n = submesh.npts + 1
@@ -234,17 +235,7 @@ def integral(self, child, discretised_child, integration_dimension):
         integration_vector = self.definite_integral_matrix(
             child, integration_dimension=integration_dimension
         )
-
-        # Check for spherical domains
-        domain = child.domains[integration_dimension]
-        submesh = self.mesh.combine_submeshes(*domain)
-        if submesh.coord_sys == "spherical polar":
-            second_dim_repeats = self._get_auxiliary_domain_repeats(child.domains)
-            r_numpy = np.kron(np.ones(second_dim_repeats), submesh.nodes)
-            r = pybamm.Vector(r_numpy)
-            out = 4 * np.pi * integration_vector @ (discretised_child * r ** 2)
-        else:
-            out = integration_vector @ discretised_child
+        out = integration_vector @ discretised_child
 
         return out
 
@@ -277,22 +268,31 @@ def definite_integral_matrix(
             The finite volume integral matrix for the domain
         """
         domains = child.domains
+
+        domain = child.domains[integration_dimension]
+        submesh = self.mesh.combine_submeshes(*domain)
+        if submesh.coord_sys == "spherical polar":
+            r_edges_left = submesh.edges[:-1]
+            r_edges_right = submesh.edges[1:]
+            d_edges = 4 * np.pi * (r_edges_right ** 3 - r_edges_left ** 3) / 3
+        else:
+            d_edges = submesh.d_edges
+
         if integration_dimension == "primary":
             # Create appropriate submesh by combining submeshes in domain
             submesh = self.mesh.combine_submeshes(*domains["primary"])
 
             # Create vector of ones for primary domain submesh
-            vector = submesh.d_edges
 
             if vector_type == "row":
-                vector = vector[np.newaxis, :]
+                d_edges = d_edges[np.newaxis, :]
             elif vector_type == "column":
-                vector = vector[:, np.newaxis]
+                d_edges = d_edges[:, np.newaxis]
 
             # repeat matrix for each node in secondary dimensions
             second_dim_repeats = self._get_auxiliary_domain_repeats(domains)
             # generate full matrix from the submatrix
-            matrix = kron(eye(second_dim_repeats), vector)
+            matrix = kron(eye(second_dim_repeats), d_edges)
         elif integration_dimension == "secondary":
             if vector_type != "row":
                 raise NotImplementedError(
@@ -300,10 +300,8 @@ def definite_integral_matrix(
                 )
             # Create appropriate submesh by combining submeshes in domain
             primary_submesh = self.mesh.combine_submeshes(*domains["primary"])
-            secondary_submesh = self.mesh.combine_submeshes(*domains["secondary"])
 
             # Create matrix which integrates in the secondary dimension
-            d_edges = secondary_submesh.d_edges
             # Different number of edges depending on whether child evaluates on edges
             # in the primary dimensions
             if child.evaluates_on_edges("primary"):
diff --git a/tests/integration/test_models/standard_output_tests.py b/tests/integration/test_models/standard_output_tests.py
index c318244635..9226c63272 100644
--- a/tests/integration/test_models/standard_output_tests.py
+++ b/tests/integration/test_models/standard_output_tests.py
@@ -377,23 +377,19 @@ def test_concentration_limits(self):
     def test_conservation(self):
         """Test amount of lithium stored across all particles and in SEI layers is
         constant."""
-        self.c_s_tot = (
+        c_s_tot = (
             self.c_s_n_tot(self.solution.t)
             + self.c_s_p_tot(self.solution.t)
             + self.c_SEI_tot(self.solution.t)
             + self.c_Li_tot(self.solution.t)
         )
-        diff = (self.c_s_tot[1:] - self.c_s_tot[:-1]) / self.c_s_tot[:-1]
-        if "profile" in self.model.options["particle"]:
-            np.testing.assert_array_almost_equal(diff, 0, decimal=10)
-        elif self.model.options["particle size"] == "distribution":
+        diff = (c_s_tot[1:] - c_s_tot[:-1]) / c_s_tot[:-1]
+        if self.model.options["particle"] == "quartic profile":
             np.testing.assert_array_almost_equal(diff, 0, decimal=10)
+        # elif self.model.options["particle size"] == "distribution":
+        #     np.testing.assert_array_almost_equal(diff, 0, decimal=10)
         elif self.model.options["surface form"] == "differential":
             np.testing.assert_array_almost_equal(diff, 0, decimal=10)
-        elif self.model.options["SEI"] == "ec reaction limited":
-            np.testing.assert_array_almost_equal(diff, 0, decimal=11)
-        elif self.model.options["lithium plating"] == "irreversible":
-            np.testing.assert_array_almost_equal(diff, 0, decimal=13)
         else:
             np.testing.assert_array_almost_equal(diff, 0, decimal=15)
 
@@ -779,9 +775,9 @@ def __init__(self, model, param, disc, solution, operating_condition):
 
     def test_degradation_modes(self):
         """Test degradation modes are between 0 and 100%"""
-        np.testing.assert_array_less(-1e-3, self.LLI(self.t))
-        np.testing.assert_array_less(-1e-3, self.LAM_ne(self.t))
-        np.testing.assert_array_less(-1e-3, self.LAM_pe(self.t))
+        np.testing.assert_array_less(-1.1e-3, self.LLI(self.t))
+        np.testing.assert_array_less(-1e-13, self.LAM_ne(self.t))
+        np.testing.assert_array_less(-1e-13, self.LAM_pe(self.t))
         np.testing.assert_array_less(self.LLI(self.t), 100)
         np.testing.assert_array_less(self.LAM_ne(self.t), 100)
         np.testing.assert_array_less(self.LAM_pe(self.t), 100)
diff --git a/tests/integration/test_models/test_full_battery_models/test_lithium_ion/test_mpm.py b/tests/integration/test_models/test_full_battery_models/test_lithium_ion/test_mpm.py
index b39a9cf315..f538965b52 100644
--- a/tests/integration/test_models/test_full_battery_models/test_lithium_ion/test_mpm.py
+++ b/tests/integration/test_models/test_full_battery_models/test_lithium_ion/test_mpm.py
@@ -81,8 +81,8 @@ def test_conservation_each_electrode(self):
             pos_Li.append(pos)
 
         # compare
-        np.testing.assert_array_almost_equal(neg_Li[0], neg_Li[1], decimal=14)
-        np.testing.assert_array_almost_equal(pos_Li[0], pos_Li[1], decimal=14)
+        np.testing.assert_array_almost_equal(neg_Li[0], neg_Li[1], decimal=13)
+        np.testing.assert_array_almost_equal(pos_Li[0], pos_Li[1], decimal=13)
 
 
 if __name__ == "__main__":

From 8b7b18cb430778b2e144bcc22aa7d7771574c574 Mon Sep 17 00:00:00 2001
From: Valentin Sulzer <valentinsulzer@hotmail.com>
Date: Wed, 3 Nov 2021 14:03:06 -0400
Subject: [PATCH 2/9] update test

---
 pybamm/spatial_methods/finite_volume.py                   | 8 ++++----
 .../test_finite_volume/test_finite_volume.py              | 8 ++++----
 2 files changed, 8 insertions(+), 8 deletions(-)

diff --git a/pybamm/spatial_methods/finite_volume.py b/pybamm/spatial_methods/finite_volume.py
index dee7285f78..2308be05ac 100644
--- a/pybamm/spatial_methods/finite_volume.py
+++ b/pybamm/spatial_methods/finite_volume.py
@@ -268,6 +268,10 @@ def definite_integral_matrix(
             The finite volume integral matrix for the domain
         """
         domains = child.domains
+        if vector_type != "row" and integration_dimension == "secondary":
+            raise NotImplementedError(
+                "Integral in secondary vector only implemented in 'row' form"
+            )
 
         domain = child.domains[integration_dimension]
         submesh = self.mesh.combine_submeshes(*domain)
@@ -294,10 +298,6 @@ def definite_integral_matrix(
             # generate full matrix from the submatrix
             matrix = kron(eye(second_dim_repeats), d_edges)
         elif integration_dimension == "secondary":
-            if vector_type != "row":
-                raise NotImplementedError(
-                    "Integral in secondary vector only implemented in 'row' form"
-                )
             # Create appropriate submesh by combining submeshes in domain
             primary_submesh = self.mesh.combine_submeshes(*domains["primary"])
 
diff --git a/tests/unit/test_spatial_methods/test_finite_volume/test_finite_volume.py b/tests/unit/test_spatial_methods/test_finite_volume/test_finite_volume.py
index cde2f70e8a..25de1905e9 100644
--- a/tests/unit/test_spatial_methods/test_finite_volume/test_finite_volume.py
+++ b/tests/unit/test_spatial_methods/test_finite_volume/test_finite_volume.py
@@ -725,15 +725,15 @@ def test_definite_integral(self):
 
         constant_y = np.ones_like(mesh["negative particle"].nodes[:, np.newaxis])
         np.testing.assert_array_almost_equal(
-            integral_eqn_disc.evaluate(None, constant_y), 4 * np.pi / 3, decimal=4
+            integral_eqn_disc.evaluate(None, constant_y), 4 * np.pi / 3
         )
         linear_y = mesh["negative particle"].nodes
         np.testing.assert_array_almost_equal(
-            integral_eqn_disc.evaluate(None, linear_y), np.pi, decimal=3
+            integral_eqn_disc.evaluate(None, linear_y), np.pi, decimal=4
         )
-        one_over_y_squared = 1 / mesh["negative particle"].nodes ** 2
+        one_over_y = 1 / mesh["negative particle"].nodes
         np.testing.assert_array_almost_equal(
-            integral_eqn_disc.evaluate(None, one_over_y_squared), 4 * np.pi
+            integral_eqn_disc.evaluate(None, one_over_y), 2 * np.pi, decimal=3
         )
 
         # test failure for secondary dimension column form

From 626f45805f88f98a08517767aa93ff945d275bf1 Mon Sep 17 00:00:00 2001
From: Valentin Sulzer <valentinsulzer@hotmail.com>
Date: Wed, 3 Nov 2021 14:34:47 -0400
Subject: [PATCH 3/9] fix integration tests

---
 .../test_finite_volume.py                     | 24 +++++++++----------
 .../test_spectral_volume.py                   | 24 +++++++++----------
 2 files changed, 22 insertions(+), 26 deletions(-)

diff --git a/tests/integration/test_spatial_methods/test_finite_volume.py b/tests/integration/test_spatial_methods/test_finite_volume.py
index f0729c59fe..0b830f40a7 100644
--- a/tests/integration/test_spatial_methods/test_finite_volume.py
+++ b/tests/integration/test_spatial_methods/test_finite_volume.py
@@ -126,11 +126,10 @@ def get_error(n):
             r_edge = pybamm.SpatialVariableEdge("r_n", domain=["negative particle"])
 
             # Define flux and bcs
-            N = r_edge ** 2 * pybamm.sin(r_edge)
+            N = pybamm.sin(r_edge)
             div_eqn = pybamm.div(N)
             # Define exact solutions
-            # N = r**3 --> div(N) = 5 * r**2
-            div_exact = 4 * r * np.sin(r) + r ** 2 * np.cos(r)
+            div_exact = 2 / r * np.sin(r) + np.cos(r)
 
             # Discretise and evaluate
             div_eqn_disc = disc.process_symbol(div_eqn)
@@ -140,7 +139,7 @@ def get_error(n):
             return div_approx[:, 0] - div_exact
 
         # Get errors
-        ns = 10 * 2 ** np.arange(6)
+        ns = 10 * 2 ** np.arange(1, 7)
         errs = {n: get_error(int(n)) for n in ns}
         # expect quadratic convergence everywhere
         err_norm = np.array([np.linalg.norm(errs[n], np.inf) for n in ns])
@@ -195,11 +194,12 @@ def get_error(m):
             r = submesh.nodes
             r_edge = pybamm.standard_spatial_vars.r_n_edge
 
-            N = r_edge ** 2 * pybamm.sin(r_edge)
+            # N = r_edge ** 2 * pybamm.sin(r_edge)
+            N = pybamm.sin(r_edge)
             div_eqn = pybamm.div(N)
             # Define exact solutions
-            # N = r**2*sin(r) --> div(N) = 4*r*sin(r) - r**2*cos(r)
-            div_exact = 4 * r * np.sin(r) + r ** 2 * np.cos(r)
+            # N = sin(r) --> div(N) = 1/r2 * d/dr(r2*N) = 2/r*sin(r) + cos(r)
+            div_exact = 2 / r * np.sin(r) + np.cos(r)
             div_exact = np.kron(np.ones(mesh["negative electrode"].npts), div_exact)
 
             # Discretise and evaluate
@@ -209,7 +209,7 @@ def get_error(m):
             return div_approx[:, 0] - div_exact
 
         # Get errors
-        ns = 10 * 2 ** np.arange(6)
+        ns = 10 * 2 ** np.arange(1, 7)
         errs = {n: get_error(int(n)) for n in ns}
         # expect quadratic convergence everywhere
         err_norm = np.array([np.linalg.norm(errs[n], np.inf) for n in ns])
@@ -233,13 +233,11 @@ def get_error(m):
             r_edge = pybamm.standard_spatial_vars.r_n_edge
             x = pybamm.standard_spatial_vars.x_n
 
-            N = pybamm.PrimaryBroadcast(x, "negative particle") * (
-                r_edge ** 2 * pybamm.sin(r_edge)
-            )
+            N = pybamm.PrimaryBroadcast(x, "negative particle") * pybamm.sin(r_edge)
             div_eqn = pybamm.div(N)
             # Define exact solutions
             # N = r**2*sin(r) --> div(N) = 4*r*sin(r) - r**2*cos(r)
-            div_exact = 4 * r * np.sin(r) + r ** 2 * np.cos(r)
+            div_exact = 2 / r * np.sin(r) + np.cos(r)
             div_exact = np.kron(mesh["negative electrode"].nodes, div_exact)
 
             # Discretise and evaluate
@@ -249,7 +247,7 @@ def get_error(m):
             return div_approx[:, 0] - div_exact
 
         # Get errors
-        ns = 10 * 2 ** np.arange(6)
+        ns = 10 * 2 ** np.arange(1, 7)
         errs = {n: get_error(int(n)) for n in ns}
         # expect quadratic convergence everywhere
         err_norm = np.array([np.linalg.norm(errs[n], np.inf) for n in ns])
diff --git a/tests/integration/test_spatial_methods/test_spectral_volume.py b/tests/integration/test_spatial_methods/test_spectral_volume.py
index 09b10d6426..a8bc1e9e02 100644
--- a/tests/integration/test_spatial_methods/test_spectral_volume.py
+++ b/tests/integration/test_spatial_methods/test_spectral_volume.py
@@ -182,7 +182,7 @@ def get_error(n):
         np.testing.assert_array_less(1.99 * np.ones_like(rates), rates)
 
     def test_spherical_div_convergence_quadratic(self):
-        # test div( r**2 * sin(r) ) == 4*r*sin(r) - r**2*cos(r)
+        # test div( r**2 * sin(r) ) == 2/r*sin(r) + cos(r)
         spatial_methods = {"negative particle": pybamm.SpectralVolume()}
 
         # Function for convergence testing
@@ -195,11 +195,11 @@ def get_error(n):
             r_edge = pybamm.SpatialVariableEdge("r_n", domain=["negative particle"])
 
             # Define flux and bcs
-            N = r_edge ** 2 * pybamm.sin(r_edge)
+            N = pybamm.sin(r_edge)
             div_eqn = pybamm.div(N)
             # Define exact solutions
             # N = r**3 --> div(N) = 5 * r**2
-            div_exact = 4 * r * np.sin(r) + r ** 2 * np.cos(r)
+            div_exact = 2 / r * np.sin(r) + np.cos(r)
 
             # Discretise and evaluate
             div_eqn_disc = disc.process_symbol(div_eqn)
@@ -252,7 +252,7 @@ def get_error(n):
         np.testing.assert_array_less(0.99 * np.ones_like(rates), rates)
 
     def test_p2d_spherical_convergence_quadratic(self):
-        # test div( r**2 * sin(r) ) == 4*r*sin(r) - r**2*cos(r)
+        # test div( r**2 * sin(r) ) == 2/r*sin(r) + cos(r)
         spatial_methods = {"negative particle": pybamm.SpectralVolume()}
 
         # Function for convergence testing
@@ -264,11 +264,11 @@ def get_error(m):
             r = submesh.nodes
             r_edge = pybamm.standard_spatial_vars.r_n_edge
 
-            N = r_edge ** 2 * pybamm.sin(r_edge)
+            N = pybamm.sin(r_edge)
             div_eqn = pybamm.div(N)
             # Define exact solutions
-            # N = r**2*sin(r) --> div(N) = 4*r*sin(r) - r**2*cos(r)
-            div_exact = 4 * r * np.sin(r) + r ** 2 * np.cos(r)
+            # N = r**2*sin(r) --> div(N) = 2/r*sin(r) + cos(r)
+            div_exact = 2 / r * np.sin(r) + np.cos(r)
             div_exact = np.kron(np.ones(mesh["negative electrode"].npts), div_exact)
 
             # Discretise and evaluate
@@ -286,7 +286,7 @@ def get_error(m):
         np.testing.assert_array_less(1.99 * np.ones_like(rates), rates)
 
     def test_p2d_with_x_dep_bcs_spherical_convergence(self):
-        # test div_r( (r**2 * sin(r)) * x ) == (4*r*sin(r) - r**2*cos(r)) * x
+        # test div_r( sin(r) * x ) == (2/r*sin(r) + cos(r)) * x
         spatial_methods = {
             "negative particle": pybamm.SpectralVolume(),
             "negative electrode": pybamm.SpectralVolume(),
@@ -302,13 +302,11 @@ def get_error(m):
             r_edge = pybamm.standard_spatial_vars.r_n_edge
             x = pybamm.standard_spatial_vars.x_n
 
-            N = pybamm.PrimaryBroadcast(x, "negative particle") * (
-                r_edge ** 2 * pybamm.sin(r_edge)
-            )
+            N = pybamm.PrimaryBroadcast(x, "negative particle") * (pybamm.sin(r_edge))
             div_eqn = pybamm.div(N)
             # Define exact solutions
-            # N = r**2*sin(r) --> div(N) = 4*r*sin(r) - r**2*cos(r)
-            div_exact = 4 * r * np.sin(r) + r ** 2 * np.cos(r)
+            # N = sin(r) --> div(N) = 2/r*sin(r) + cos(r)
+            div_exact = 2 / r * np.sin(r) + np.cos(r)
             div_exact = np.kron(mesh["negative electrode"].nodes, div_exact)
 
             # Discretise and evaluate

From ad837bea5da4a8198f1190d1f6032c5004af730c Mon Sep 17 00:00:00 2001
From: Valentin Sulzer <valentinsulzer@hotmail.com>
Date: Thu, 4 Nov 2021 15:25:45 -0400
Subject: [PATCH 4/9] fix param import issue

---
 CHANGELOG.md                                               | 6 ++++++
 .../models/simulating-ORegan-2021-parameter-set.ipynb      | 4 ++--
 pybamm/parameters/parameter_values.py                      | 7 ++++++-
 3 files changed, 14 insertions(+), 3 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 73d03dc9f1..a059b3a9c9 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,3 +1,9 @@
+# [Unreleased](https://github.com/pybamm-team/PyBaMM/)
+
+## Bug fixes
+
+-   Fixed finite volume discretization in spherical polar coordinates ([#1782](https://github.com/pybamm-team/PyBaMM/pull/1782))
+
 # [v21.10](https://github.com/pybamm-team/PyBaMM/tree/v21.9) - 2021-10-31
 
 ## Features
diff --git a/examples/notebooks/models/simulating-ORegan-2021-parameter-set.ipynb b/examples/notebooks/models/simulating-ORegan-2021-parameter-set.ipynb
index dd27d4f27e..bbd117d28d 100644
--- a/examples/notebooks/models/simulating-ORegan-2021-parameter-set.ipynb
+++ b/examples/notebooks/models/simulating-ORegan-2021-parameter-set.ipynb
@@ -178,7 +178,7 @@
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "Python 3",
+   "display_name": "Python 3 (ipykernel)",
    "language": "python",
    "name": "python3"
   },
@@ -192,7 +192,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.7.4"
+   "version": "3.8.12"
   }
  },
  "nbformat": 4,
diff --git a/pybamm/parameters/parameter_values.py b/pybamm/parameters/parameter_values.py
index 24d74e7bdb..1814e1a2a7 100644
--- a/pybamm/parameters/parameter_values.py
+++ b/pybamm/parameters/parameter_values.py
@@ -206,7 +206,12 @@ def update_from_chemistry(self, chemistry):
                 )
             # Create path to component and load values
             component_path = os.path.join(
-                base_chemistry, component_group.replace(" ", "_") + "s", component
+                "pybamm",
+                "input",
+                "parameters",
+                base_chemistry,
+                component_group.replace(" ", "_") + "s",
+                component,
             )
             file_path = self.find_parameter(
                 os.path.join(component_path, "parameters.csv")

From 778a9cb37dbecc5a6694d38a53460c0f50ea99e4 Mon Sep 17 00:00:00 2001
From: Valentin Sulzer <valentinsulzer@hotmail.com>
Date: Thu, 4 Nov 2021 15:32:09 -0400
Subject: [PATCH 5/9] change default number of points

---
 ...simulating-ORegan-2021-parameter-set.ipynb | 22 ++++---------------
 .../full_battery_models/base_battery_model.py |  4 ++--
 2 files changed, 6 insertions(+), 20 deletions(-)

diff --git a/examples/notebooks/models/simulating-ORegan-2021-parameter-set.ipynb b/examples/notebooks/models/simulating-ORegan-2021-parameter-set.ipynb
index bbd117d28d..977caf7c8f 100644
--- a/examples/notebooks/models/simulating-ORegan-2021-parameter-set.ipynb
+++ b/examples/notebooks/models/simulating-ORegan-2021-parameter-set.ipynb
@@ -20,8 +20,6 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "\u001b[33mWARNING: You are using pip version 21.0.1; however, version 21.2.4 is available.\n",
-      "You should consider upgrading via the '/home/ferranbrosa/PyBaMM/.tox/dev/bin/python -m pip install --upgrade pip' command.\u001b[0m\n",
       "Note: you may need to restart the kernel to use updated packages.\n"
      ]
     }
@@ -62,7 +60,7 @@
    "id": "occasional-skill",
    "metadata": {},
    "source": [
-    "Now we define the new mesh. Because the particle diffusivity depends on concentration and get drop very abruptly, we set a very fine mesh (150 points in each particle). Additionally, given that the larger gradients occur towards the particle surface, we choose an exponential mesh weighted towards the `right` (i.e. the particle surface). This generates a non-uniform mesh with a finer grid towards the particle surface and a coarser grid towards the particle centre."
+    "Now we define the new mesh. Because the particle diffusivity depends on concentration and get drop very abruptly, we set a fine mesh (40 points in each particle). Additionally, given that the larger gradients occur towards the particle surface, we choose an exponential mesh weighted towards the `right` (i.e. the particle surface). This generates a non-uniform mesh with a finer grid towards the particle surface and a coarser grid towards the particle centre."
    ]
   },
   {
@@ -73,7 +71,7 @@
    "outputs": [],
    "source": [
     "var = pybamm.standard_spatial_vars\n",
-    "var_pts = {var.x_n: 30, var.x_s: 30, var.x_p: 30, var.r_n: 150, var.r_p: 150}\n",
+    "var_pts = {var.x_n: 30, var.x_s: 30, var.x_p: 30, var.r_n: 40, var.r_p: 40}\n",
     "\n",
     "submesh_types = model.default_submesh_types\n",
     "submesh_types[\"negative particle\"] = pybamm.MeshGenerator(\n",
@@ -111,7 +109,7 @@
     {
      "data": {
       "application/vnd.jupyter.widget-view+json": {
-       "model_id": "c951627d2a634463be1a6ec9e7181536",
+       "model_id": "f3b237091d394796927a29926d0a67ac",
        "version_major": 2,
        "version_minor": 0
       },
@@ -125,24 +123,12 @@
     {
      "data": {
       "text/plain": [
-       "<pybamm.plotting.quick_plot.QuickPlot at 0x7f945b798e10>"
+       "<pybamm.plotting.quick_plot.QuickPlot at 0x7fc821bbfac0>"
       ]
      },
      "execution_count": 4,
      "metadata": {},
      "output_type": "execute_result"
-    },
-    {
-     "data": {
-      "image/png": "iVBORw0KGgoAAAANSUhEUgAABDQAAAHwCAYAAABZrz9/AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/MnkTPAAAACXBIWXMAAAsTAAALEwEAmpwYAAC2/0lEQVR4nOzdd7gcVf3H8fcnHUJICIQSIAldEKkRlBoRpIlgRQUxiIIN8KeAgiggRUBUFESq0qSJiNIRMSQUwaCAIiCd0NMuhBLSvr8/zlnuZLN7y969d2/5vJ5nnp05c3bmzOzM2Zkz55xRRGBmZmZmZmZm1pP0a3QCzMzMzMzMzMzaywUaZmZmZmZmZtbjuEDDzMzMzMzMzHocF2iYmZmZmZmZWY/jAg0zMzMzMzMz63FcoGFmZmZmZmZmPU6PK9CQdJOkLzY6He0laYykNyT1byXeBEnPd1W6WkjHUpKuk/SapN83Oj19haRtJT3WCcudIGlRPgZ36YTlT5R0Z72X28Z1H5C3KyStXadlNmx7umM6+op8HK3ZCcsNSW9KOrETlj0uL39AvZfdhnWvm/fZQklf7ur1t0TSUZLOb2H+PpJu7co01Utbr4MkPSNpx65IUyvp+JqkV/Kxsnyj09NXSHpY0oROWO4zkt6WdEm9l52XX7f/8naud3A+RudLOqGr129mtWu1QCNnXK9KGloI+7KkSZ2asrSeYyVdWgyLiF0j4qLOXndHlV9IRMRzEbFMRCxsZLra4VPASsDyEfHpRiemu6lXwVP5H3dETImI9Tq63CpezMfgzZ20/E4haQVJd0maKalJ0j2Sti7Nj4gLImKZGpZbuih7ozCcWcd0d+mNZne5eekK9bjglTSp/CY8nx9PdSx1VW0cEd/vpGV3GkmXSnpJ0uuS/lfcZxHxv3zuTanDeorn4yuSLpTU7vO6kLaTIuLLedlLnIsR8buI+EhH093ZevJ1EICkgcDPgI/k82tmo9PU3dQj787ny2I34RHx3oiY1KHEVbdHRHyhk5bdaSSdKmlazs+elXRUaV5EvJPzs981MInWg9RSuJfP1be7w8Pr3qStNTT6A4d2ZkJ6i0Y8Jau3XItkLPC/iFjQ6PT0VL3hWOgm3gC+BIwClgNOAa6r0/7dI19kl4Zv1mGZbeZjpHN4v9bVj4FxEbEs8DHgBEmbd9K69sg3FJsB44GjO2k9PUJPP45z+lcChgAPNzg5PVZPPw66mQuA9+T8bCtgH0mfaHCa+ixJn5c0NRdkv5Rrn23T6HRBu2rILlG4p+QpSf8tjxwRE4Fd65RMy9paoPET4DBJIyrNlPQeSX+RNEvSY5I+U5i3vFLThdcl/UPSCcUDRNIvCqWl90vaNofvAhwF7J0P9Adz+KRcQ2Rwflq7YWFZo3Kp14p5+qOSHsjx7pa0UbUNzE9vDskH4AxJP5HUL89bS9Lt+QnxDEm/K+6LXEL3XUkPAW9KuhwYQ7rpekPSEeVPiCSNlPRbSS9Kmi3p2irpGi3pD5KmS3pa0iEtbMNukv4raY6kFyQdlsOXOClVeMKZSwt/LelGSW8Ck4EfFvb9AW3YB6tLuianc6YKT7olfUnSI3k7b5E0toVt2Cb/Vk35uJiYw4dLujgv/1lJRxd+n4mS7pR0Wl7H05J2LSyz6r5u6RjJv+thkh5SanpzpaQhSrWVbgJGq/nJ/milJ2lXKz3RfB2YKGkLpRoFTUqZ9ZmSBuXlT86rejAvY2+V1fyQtL7SMd+kVH30Y4V5F0r6laQb8m9+r6S1qu3bCvt6olLNh5/n5T8laascPk2pZtYXC/Gr/gatrGeCpOeVzoNX837YKx+v/1PKN46q9v2ImBsRj0XEIkDAQlLBxsi2bmtHqeU8bilJP8375LV8LC5FOo8AmvLv+8GyfT4TOLat+zX/1j8tC/uzpP9TejqwWJ6T53+gcD49qBaqH6vKOSypX07Ts/n3u1jS8DyvlK99UdJzSnnD9wvL7K9U9f/JfIzeL2n1NuzTqsd2S+eNUj78MvBbSctJuj5vz+w8vlpexonAtsCZKtTM0eL5Ys15TmsK+21/pXNttqSvSnq/Un7TpMXz0Kq/QRvWFZK+LunxvC+PV8rP71b6371KOU+qJCIejoh3SpN5aHM+U4uIeIGUx26Yt+FjSvlfk1J+uH4pbv7NX8jb9pikD+fwYs2GaufinTnuryWdVkyDpD9J+nYeb8//8IWSzs7H9hxJd6jwn6cq1zyFNBf/Q75KC9dBhe99Rek/do7SNcBmFdLVT9L3lM7Fmfl3r5iHKtWKuz7v71mSphSO/cVqR6lQM6DCeXgJUGpC2STp9jbsg5ryjArb0NL//lckPZGX82dJowvzIp+Lj+ft/5UktbavWzpG8u96ldJ5Oycfy+PzvCXybjXnDwdIeg4o7bffS3pZ6X9msqT35vADgX2AI/IyrsvhzyjX/FC6Zj49748X8/jgst/tO2r+j96/2r6tsr/blc+09Bu0sp5nJB2ulE++KekCSSsp3QjPkXSbpOWqfT9fS7xZCFoEdHnzFgOl/PV04CRSwecY4CxgzxqWtUShX6WwLrQdsCKwpqT3NzAdfUdEtDgAzwA7AtcAJ+SwLwOT8vhQYBqwPzAA2BSYAWyQ51+Rh6WBDXLcOwvL3xdYPn/3O8DLwJA871jg0rL0TAK+nMd/A5xYmPcN4OY8vinwKrAlqYbJF/O2DK6ynQH8jXSTNAb4X2E9awM7AYNJT4knA6eX7aMHgNWBpYr7rRBnXF7HgDx9A3Al6cZsILB9Dp8APJ/H+wH3kwoXBgFrAk8BO1fZhpeAbfP4csBmeXxicZ8XtnftPH4h8BqwdV7nkPJ939I+yPv3QeDn+XgYAmyT5+0JPAGsn3/jo4G7q6R/LDAH+FzeJ8sDm+R5FwN/Aoblffk/4IDC9s0HvpLT8jXgRUCt7OsWj5E8fh8wmnRcPAJ8tfx3KqT/2JyOvfJ+XArYHPhA3vZxeRnfqvQ7VPj9B+Z9d1T+/XfI+2e9wu82E9giL/93wBVV9m2l9E4EFpDO3f7ACcBzwK/y7/yRvL5l2vgb3NnCuheQjuOB+XeaDlyWl/Ve4G1gjVbyooeAeXmfnVflHF67pWVUytuqzHt3e2g9j/sVKV9aNe/HrfL+G0fhnC/b5wfnZS3V1v2af+cXgX55egXgLWClKnnOqvn42I10PO6Up0dV2N6WzuEvkY7DNYFlSP8Fl5Tla+flbdkYeAdYP88/HPg3sB6pMGpj0nnd2j69kBaO7fLfmuZj7JS875fK6/kk6b9nGPB74NpK/yVV8sWa85zWjs3Cfjs77+uPAHOBa0kXQauS8qbt2/EbDGhh3X8CliWda+8Af83LGg78F/hiK+fKWaRjLYB/kvOElvZlewcKxy/pv/Rh4HhgXeBN0vE7EDgi74tB+biaBowu7Iu1CvnxpdX2EYufW9vl5ZT+M5Yj5Umjaf//8IWkfHM70rH4C9p3zVP+H/LudlTa38CngReA95POsbWBsRX26aHA34HVcrrOAS6vsg0/Jh2bA/OwbWHflB/LF9J8bTiBJc/DSvu+pX1QU55RYRuq/e/vkL+3WU7jGcDksvPlemAE6VpwOrBLS/uaVo6R/BvOJeXF/fP+/Xu1/6LCPrs4b3fpuvJLpPxoMOlG8IFKv0OVc+pH+fdfkXQNdzdwfNnv9qO8r3Yjne/LtXau1pLPtPE3qPhfntf9d9INcCmf/Gc+HoaQCn+OaSWv+R6p5mfk32m1CufwCS0tw0PHhnxMvAF8uoU4i/0OlF3H5mPhu6Rrw3fy+RjAAaRr2ck53pdI196zgVvI+WPhWPsq8DjQRLqeE+meZS7pAdobQFMLx+MS15Gk+9Pfkf6rz6wwf7Ft8VCHY6oNB90zpAKNDUk3vaNYvEBjb2BK2XfOAY4hZdzzyTdged4JVLnxyfNnk9oaQ+t/5DsCTxbm3QXsl8d/Tc6sC/MfI/+pVVhvkP+08vTXgb9WibsX8K+yffSlSvutMD0ur2MAsAqpVHiJPwsWv6HdEniubP6RwG+rpOs54CBg2bLwieX7nCULNC4um7/Evq+2D4APkv70l7igJj1lO6Aw3Y/0Rzm2QtwjgT9WCO9PupHdoBB2UOEYnAg8UZi3dN6+lVvZ1y0eI/k33Lcw71Tg7PLfqWyfTS5fT1mcbxW3kZYLNLYlXej1K8y/HDi28LudX5i3G/BolfVWSu9E4PHC9PtyelYqhM0ENmnjb9BSgcbbQP88PSyvZ8tCnPuBvVradzneEFKB1xcrzKt6EVRlWc+Q/6gKw1fKt4eW87h+eds2rrD8cVS+iXquMN2u/Ur6U94pj38TuLFse4p5znfJN72FsFuq7LuWzuG/Al8vTK9HytdLhXRB4YKQVAj42cL5tGeFZVbdp205tst/63yMzSPfFFX5vTcBZhemJ1GlQKONv0vFPKfKusvTW9pvq5ada3sXpv9ALvxs42/QUoHG1mXn2ncL0z+lUEDfwv7rD2xDKpQeWDZviX3Z3oHFz8dnSYUoSwE/AK4qxOtHuqmckH+rV0nXAuVpOpa2F2iI9P+5XZ7+CnB7Hm/v//CFLF74tgzponj1KvHLr3kmV9uOSvubdE4f2sI+Ld3QPgJ8uDBvldIxVOF7PyLdnC6Rn9J6gcZi52Frx2eFfVBTnlEW3tL//gXAqWW/z3xSs6rS9m1TmH8V8L2W9nVrx0j+DW8rzNsAeLvS71S2z9ZsYZ+NyHGGl/8OVX7/J4HdCvN2Bp4p/G5vs/j58SrwgdaOq7Ljok35TBt/g5YKNPYpTP8B+HVh+mAKBdct7D+RCkGOA4aVzVtiX3qo7wDsQipEaylfWOx3oHKBxgPkh8lUKAiklYeqtFyAOZEW7lcLaSg/F5YGXiddt3ySVHg3qCzOYtvioeNDm99yEhH/yT/698pmjQW2zFXzmiQ1kaq+rUwq/BhAKlUvKY6jVKX/kVyFrolUardCG5P1N2BpSVtKGke6YP1jIV3fKUvX6qQnLtUU0/ZsKW6uznaFUrXW14FLK6RxGm23OjArIma3Em8sqVlDcRuOIpVMV/JJ0gn0rFI11w+2I00tpr+VfbA68GxU7m9jLPCLQvpnkf5IVq0Qd3XSn265FUhPDZ4thD1btoyXSyMR8VYeXYaW93VbjpGXC+Nv5WW2pPz4Xlep6u7Leb+dRNuP79HAtEhNLUqqbncb01fulcL42wARUR62DG37DVoyM5o7xH27yrqXAdDinXSOKS4kUvOTy4HvSdq4jetuyV4RMaIwnFchTkt53AqkQpZKx201xWOkvfv1ItLTTfJnSx1RjQU+XZbubUgX++VaOodHV0hfqW18SbXjsNo53dI+bW2Z1UyPiLmlCUlLSzpHqZnG66RaZSPUypumso7kOe1Rfg5UPCdo22/Q4fXkatulc2+f4gIiYmFE3El6wv+1Nq63vUrn49iI+HpElGpJvLvtOT+cRioMeoJUSHws8Gr+j2pT1fWiSFeYV5AKSwE+T3PHgO39H4bCOR4Rb5D+90rXE61d87TnWgKqn2PlxgJ/LGzDI6SClkrb8RPSTcCtSk0Ry6/7WrLYeVhJK/ugI3lGSUv/++XH0xukwsS2/K+2lLbWjpHyZQ5pQ5X4d48FpaY4Jys1xXmddCMF7bueKM9DiufKzLL8vx7XE23Kz6r8Bh1ej1LTr1J+tliz1kj+leMf18b1Wv0sD8yocs3RHr+MiGn5v6Lk2Ih4M4d9FfhxRDyS13USsIkWb/p+ckQ0RcRzpPvKTTqYpk+QaozcSqopNhDYvYPLtFa097Wtx5CeXBQznWnAHWU3BctExNdIJV0LSBdAJauXRpTaTR4BfIZUkj6CVAuk1F4xWkpMvkG6inQR8jng+oiYU0jXiWXpWjrfDFWzemF8DKkKMaQTIID3RepIaN9CGt9NTivTRdOAkarSJ0lZvKfLtmFYROxWKXJE/CMi9iRVKbyWtG8gVddduhRPUqULgBb3NS3vg2nAmCp/ztOAg8q2YamIuLtK3Epts2eQSu+LGdAY0lO61rS0r2s5Rkqq7a/y8F8DjwLr5P12FEseO9W8CKyuxftTaOt211tHfoN2icU76XyuSrSBpKqsXaGlPG4GqVpipeO2LcdIe/frpcCeuTBnfdJ5Xm1900g1NIrpHhoRJ1fZxmrn8IsV0reAxS8iq6l2Tre0T2tVvv3fIdVk2DKfe9vl8Lb8v3TZ8d5GHfkN2izS2zNK5161nv4H0Ml9aJRZbNslifRf/QJARFwWEdvkOEFq7lCutf83SLXfPpUvdLckPfmFdv4PZ8XrnGVITRZfbMM1T6W0tpb2audYpXi7lm3HkEj9lSy+wog5EfGdiFiT1BHst5X7JiHd6C5diF5+PdFietuwD+qRZ7T0v19+PA0l3Vy19XqiWtrae4wUteW/4vOkp807kgqAxuXwNl0vUzkPebFK3M7Wkd+gzSLiq4X87KQq0bo6P7NkJrBCHfq5qFQAXAxry0PVjj4YLPdFUq3CBblw9w85zDpRuwo08tOQK4Fih1jXA+tK+oKkgXl4v6T1c4HDNaSO75aW9B5gv8J3h5EuyqYDAyT9kNT+ruQVYJxa7njwMlJVxH3yeMl5wFdz7Q1JGippd0nDWljW4Uodya1Oam96ZSGdbwCvSVqV1MazNa9Q5YYrIl4iNcU4K69voKTtKkS9D5ij1MHWUrmEfkNV6GBG0iBJ+0gaHhHzSdWdSk/2HwTeK2kTSaX+MdqrpX1wH6n/jpPzfh6i5tdqng0cqebOq4ZLqvYa2N8BO0r6jKQBSh3KblIouDpR0rB8wflt0s1di1rZ17UcIyWvAMur9Y75hpF+izfy8V9+8VX1OAHuJWWuR+R0TwD2ID1J7FId+Q06Sqljy23yMb6UpO+Snnzd29nrzlrK4xaR2kr+TKlTuP5KHQ4OJuVri2ih4KW9+zUingf+QaqZ8YeypxLlx9KlwB6Sds7pGqLU+VuxgLmkpXP4cuD/JK2Rb85OAq5s45OV84HjJa2Tz7GNJC1PC/u0DcustK2VDCM9fWtS6vzwmLYuo5HHexUd+Q1qJmlFSZ+VtEw+hnYmPTz4a2eut8xVwO6SPqz0CtDvkJ5+3S1pPUk75PNtLun3XlRhGW05F/9FKsg6H7glIpryrDb/DxfsVsqzSP2A/D0iptH6NU8lrV0HnU/qtH3zfI6trcodb59NOp7HAih1or5npQUqdZa9tiSRChsW0rxfHwA+n/fDLsD2raS/XGv7oMN5Riv/+5cD+ytdDw0mnUv3RsQzbUh7tX1dyzFS1Nb87B3SjeDSOd3tWcblwNH5d1+B1N9HI/OzWn+Dmil1jHtQPiYkaQtS33tdmZ9Zcg/peN6rhTiLPYylcm2sSgV5xbD2PFRty7JblK+vdgD2VaqZ/TLwKdJ/QltrU1kN2ltDA1LbyqGliVwj4iPAZ0mlri/T3CEUpHbew3P4JaSMrNRj+i3AzaTO1p4lXZAUS9Z+nz9nSvpnpcRExL2kg3406Q+sFD6VVJvkTFL7zCdI7aFa8idSu78HSNWELsjhx5E6L3oth1/TynIgdfp0tFKp4GEV5n+B9ATwUVJbxW9V2LaFwEdJ1Z+epvliq9pN9BeAZ9TcO/o+eTn/I/1ut5E6vmnLa4jKVd0HOZ17kNozPwc8TypkIiL+SDoersjp+g9VXleUn8bvRrpgnUX6HUrNCg4m/c5P5fRfRrqRbIuK+7rGY6SU1kdJx/JT+TeuVs35MNKTlTmkApQry+YfC1yUl7FYj+0RMY+0X3cl/fZnkfqIebQtaewEbf4NlHpx36fSvBoMJnXUNJP0BGc3YPeIqMfTpVLP8qXhj+UR2pDHHUbqxO4fpOP2FFK/J28BJwJ35d/3A1XS0N5j+yJSfyflzU0Wy3PyDdSepFpB00l56+FUyPdbOodzWi4hNdl4mpRPH9xC+op+RrohvZVUsHcBqYO71vZpa46lynlTcDqpDe0MUidyN5fN/wXpifxsSb+s8P2O5Dn11ubfQKma9dl1Wm+QCmGfJ+WRp5H69fhznZbfegIiHiPVCDyD9FvuQXpN3jzS8XJyDn+ZVDvxyArLaOu5eBnpCfhlhe+293+4tJxjSPnB5jQ3E2vtmqeSFq+DIuL3edsuI/3PXEvlN0D9AvgzqRnJHNI5sWWVda5Dul54g3TjcVZE/C3PO5T0GzSRrjGubSX95VrbB/XKM6r9799G6pflD6RC3LXyMltVbV/XeIwUtXa9CKlfgGdJ/4H/Jf1+RRcAG+RlXFvh+ycAU0kdKP6b1JHmCW1MX1215zdQeuPNTZXm1ejjpGZDc0gFOmfkwbpQRLxGKlT7ldJb75bOBY+7Sjo1R3uAVBAwUqlm+bdqWFV7HqqWewVYTS28BayCL5DytvVI+cEmpI6tn6e5SaN1glKv1V23QukUUsdp3ar6jaQgNQt4otFpMau3/HTqFlJh4t4RcUuDk1Q3Sq+X+zmpL4sNIuKpBiepU+Xf8lJSx7pdm4FbTSTNJZ17v4yIHzQ6PfUiaR1SQd4gUqelFzY2RY0n6UJSZ29HNzotZp1B0mOkvpj+2N2u5Tsi1xZ5hdSk9dSIcN8anSw/+Po/UhPaOaSHyidGxN1KNcovIj3Uewb4LfCdiCi9fv0ZUufIt+XpcaQCxYHF2ouSvkBq5jaW9FD2LxHxpTxvsXu/Yv6dCzL+SOo0fVFELFHDokIaHgV+FRFnlMU7AvhMRJRe1zyB1NlzpRqzVoNOL9BQqmY/iFQi/H7gRtKPf22nrridXKBhZt2dUpX7K4AHI+JHjU6PmS3OBRpmZn1DLYV7ki4gvQL61YhYuzPT15d0tDOWthhGqpo/mlTy+VNS0w4zM2uj3FZ8KqlPnP0bnBwzMzOzPisi1qvhOwcAB3RCcvq0Lm9yYmZmZmZm1hkkbU7qm2Qg8I+IOKIwbwipz5ExpD6jDoiIubnJwm9I/bLc0MKbUcysm6mlU1AzMzMzM7NuJfd9cDLwyYj4ULEwI5sIPBoR2wKP0dwZ/MnAMRGxNbBDbjJvZj1AVzQ56XQrrLBCjBs3rtHJMOv17r///hkRMarR6aiV84qe5cUXX2T06GovEOq871rHOa8ws7bohLzig6Q39FwmaSipkGJKYf72QOlNGteROow8G9ikEO+GHK/qW+UkHQgcCNCvX7/NN9100zpugplVUi2/6BUFGuPGjWPq1KmNToZZryfp2UanoSOcV/Qsxx13HMccc0yXf9c6znmFmbVFJ+QVo4GNSa/MHAb8VdL6hbeCLU96DTWk1w+XXnNcrLXeBKzc0koi4lzgXICNNtoonF+Ydb5q+YWbnJiZmZmZWW8wC7g7Il6PiBeAGcCosvkj8vjwPA2wqBCnGN6qQYMG1ZxYM+s4F2iYmZmZmVlvcC+wrqQBkoYBKwIzC/PvAHbL47vlaYAHJW2Vx3cFJrd1hbNnz249kpl1GhdomFmXknSLpOmSjs7Ta0m6X9IbkrYpxDtW0iOSJuWhfw7fTNJdku6WNLFBm2FmZmbdTEQ0AWcAk4DbgO8C75N0eI5yYZ6eArwvTwMcCZwo6S5gSkQ80tZ1vvrqq/VIupnVqFf0oWFmPcoBwI7Aann6JWAn4GcV4p4YEZeWhZ0B7Au8APxd0p8iwo9HzMzMjIi4BLikLPiBPO9t4HMVvvMU8KFOT5yZ1Z1raJhZl4qI58um34qIam1Vj5B0p6RDACQNBoZGxNMRMQ+YAmzRuSk2MzMzM7PuyAUaZtZdnUHqqXwn4GOStiX1Tt5UiNNEcw/lFUk6UNJUSVOnT5/eSUk1MzMzM7Ou1iuanNz00EMwenSjk2FmdRQRpU683pZ0DTAe+AfNvZNDG3oiL75abfz48dFSXDMzMzMz6zlcQ8PMuiVJI/KngAnAYxExF3hT0hhJA4FtgPsalkgzMzPr09Zaa61GJ8GsT+sVNTR23Wgjpk6d2uhkmPV+Uh0WofOArYDBksYD+wHXABsA75V0Y0QcA5wuaT1AwKSIuDEv4lDg8hx+ljsENTMzs0YZMKBX3E6Z9Vg+A82sS0XEVyoE71gh3sQq358KbF3nZJmZmZm128yZM1uPZGadxk1OzMzMzMzMajBjxoxGJ8GsT3OBhpmZmZmZmZn1OC7QMDMzs4aSdIuk6ZKOLgvfX9L8wvSukv4haYqk30kakMN3kXRPHnYuxD9K0l2Sbpc0rss2yMzMzLqECzTMzMys0Q4ADi8GSBoCfBJ4rhB8PPCpiNgWmA/sJKk/cCqwax5OldRf0nuAHSJia+BY4ORO3wozMzPrUi7QMDMzs4aKiOcrBB8CnA1EIexhYER+nfNwYDqwNvB0RDRFRBPwTA7bHrghL38ysHFLaZB0oKSpkqZOnz69YxtkZmZmXcIFGmZmZtatSFoO2C4iri+bdTFwM/AoMD+/9Wh5oPj65iZgZIXw/i2tMyLOjYjxETF+1KhRHdwCM+sr1llnnUYnwaxPc4GGmZmZdTdHkpqRlDsH2CIi1gNmSfo0MAsYUYgzPIeVhy/slJSaWZ/Wr59vp8wayWegmZmZdTfrAkdJuhlYRdKVOXwhzbUuppNqYjwOrCFpWUnLAmsATwB3kPrUQNJWwINdmH4z6yPcRM2ssQY0OgFmZmbWt0k6D9gKGCxpfETsVZj3RETsnSePBm6XNJfUtOSUiFgo6UjglhznyIhYCDwi6U5JdwHzSB2PmpnV1axZsxqdBLM+zQUaZmZm1lAR8ZUW5q1dGP898PsKcW4EbqwQfjzpzShm1kdIehu4N09eEhEXFOZ9G/hYnhwLXBMR35F0Ianj4NeA6RHx6S5Mspl1gAs0zMzMzMyst3ghIiZUmhERPwN+BiDpRhYvID04Iu7s/OSZWT25Dw0zMzMzM+stVpZ0h6RrJI2rFEHSisAaEfH3QvDPJE2RtHel75R9/93XPM+fP79OyTazWrS7QEPSppLukjRZ0u2S1szDZEmTJP1N0mo57q6S/pEzh99JGpDDd5F0Tx52Liz7qLzs26tlQGZmZmZmZlWMi4jtSW9FuqBKnM8CVxWmD4uILYA9ge9JWrOlFRRf8zxw4MC6JNrMalNLDY2XgF0iYjvgNOA44OvABbl610XAwTnu8cCnImJbYD6wk6T+pFex7ZqHUyX1l/QeYIeI2Bo4Fji55q0yMzMzM7M+JyJm5M9bSP1kVLIPcGmF78wC/kLqT6NN1ltvvZrTamYd1+4CjYh4OSLm5Ml3gAXAwzS/63054NU8/jAwQpJI74WfDqwNPB0RTRHRBDyTw7YHbsjrmEwrGUmxqpdfl2RmZmZm1rdJWiY/PEXSRsCMCnHWBSIiHi+Ejcifg4Ctgf91SYLNrMNq7hRU0lDgBNJr0OYAt0g6ABgMbJGjXQzcDLwOPBgRU/O74GcXFtVEeo/88sCLhfD+La0/Is4FzgUYP3581LodZmZmZmbWK2wAnCNpDhDAQZI2AXaKiJ/kOPsCvyv73pWSlgEGApdGxMNtXeErr7zS8VSbWc1qKtCQNBC4kvT+9/9Kugw4OiKukfQ54CTgG6S2a1tExDRJZ0v6NPBvmmtzQKq5MSsPxfCFtaTNzMzMzMz6noi4D9i0wqwHCnF+WOF7O5eHtVVTU1OtXzWzOqilU9B+pDZn10bEtaVgmqt0vUqqcQGpUKJUG2N6Dn8cWEPSspKWBdYAngDuIPWpQa7F8WB702ZmZmZmZmZmfUMtNTQ+AewOrCRpX1KNixNI1bsWkKpqHZTjHg3cLmkuqWnJKRGxUNKRwC05zpERsRB4RNKdku4C5pGaspiZmZmZmZmZLaHdBRoRcTVwdYVZ21SI+3vg9xXCbwRurBB+POnNKGZmZmZmZmZmVdXy2lYzMzMzM7M+r18/306ZNZLPQDMzMzMzsxqss846jU6CWZ/mAg0zMzMzMzMz63FcoGFmXUrSLZKmSzo6T68l6X5Jb0japhBvpKTrJU2RdIYk5fDNJN0l6W5JExu0GWZmZma89NJLjU6CWZ/mAg0z62oHAIcXpl8CdmLJzoaPAK6MiG2BoUDpHfFnAPsCE4BDJC3Xqak1MzMzq+L1119vdBLM+jQXaJhZl4qI58um34qIWRWibg9cn8evA7aXNBgYGhFPR8Q8YAqwRUvrk3SgpKmSpk6fPr0OW2BmZmZmZt2BCzTMrLsaCTTl8aY8vXwhrBheVUScGxHjI2L8qFGj6p5IMzMzMzNrDBdomFl3NRsYnseHA7PyMKIQpxRuZmZmZmZ9jAs0zKy7ugPYLY/vBtwREXOBNyWNkTQQ2Aa4r1EJNDMzs75twIABjU6CWZ/mM9DMupSk84CtgMGSxgP7AdcAGwDvlXRjRBwDnApcLOlrwEPArXkRhwKXAwLOiojZXb0NZmZmZgBrrbVWo5Ng1qe5QMPMulREfKVC8I4V4s0Edq8QPhXYuhOSZmZmZmZmPYibnJiZmZmZmdXghRdeaHQSzPo0F2iYmZmZmVmvIOltSZPycEDZvImSni7MXzWHj5N0u6S7JB3VnvW98cYb9Uy+mbWTm5yYmZmZmVlv8UJETGhh/gURcUJZ2MnAMRExRdJtkq6JiEc7L4lmVi+uoWFmZmZmZr3FypLukHSNpHEV5u8n6U5Jx0sq3QttEhFT8vgNwPYtrUDSgZKmSpo6f/78OibdzNrLBRpmZmZmZtZbjIuI7YFzgAvK5v0JWJ9UYDEW2CeHF++JmoCRLa0gIs6NiPERMX7gwIF1SbSZ1cYFGmZmZmZm1itExIz8eQup0KI4b3ZELIyIhcAVwPg8a1Eh2nBgVlvXN2jQoI4l2Mw6xAUaZmZmZmbW40laRlL/PL4RMKNs/ojC5A7AY3n8QUlb5fFdgcltXecaa6xRc3rNrOPaXaAhadPcA/Dk3BvwmnmYnHsL/puk1XLciwu9CM+WtEcO30XSPXnYubDso/Kyb6/S5s3MzMzMzKySDYCpkiYDZwAHSdpE0uF5/uGS7pV0F6lZyXk5/EjgxBw+JSIe6fKUm1lNannLyUvALhExR9JuwHHAK6Qegy+SNBE4GPhuROwHIGkw8Chway41PRXYLi/vDkm3AesAO0TE1pK2I/U2/NkObJuZmZmZmfUREXEfsGmFWQ/k+d8Hvl/he08BH6plndOmTavla2ZWJ+2uoRERL0fEnDz5DrAAeBgYkcOWA14t+9ruwF8j4h1gbeDpiGiKiCbgmRy2PalXYSJiMrBxe9NmZmZmPY+kWyRNl3R0Wfj+kuYXppeWdL6kv+ban8vlcNf8NLOGeOuttxqdBLM+rZYaGgBIGgqcABwAzAFukXQAMBjYoiz6vqRqXwDLA7ML85pIVb6WB14shPdvZf0HAgcCjBkzpqZtMDMzs27hAGBHYLVSgKQhwCeB5wrxjgGuiohbC/Fc89PMzKyPqqlTUEkDgSuBUyLiv8ApwNERsRFwLHBSIe4I4H3ApBw0i+baHNDck3B5+MKW0lB8XdKoUaNq2QwzMzPrBiLi+QrBhwBnA1EI2xHYJdfOOC6HueanmZlZH1VLp6D9gEuBayPi2lIwzb0Iv8ri727+DHBNRJQuSB4H1pC0rKRlgTWAJ4A7SL0Kk3sZfrC9aTMzM7OeLzcl2S4iri+btSFwO6mt+waSdqHlmp/F8FZrfkqaKmnq9OnTO7gFZmZm1hVqaXLyCVKfGCtJ2hf4N6npyTmSFgADgYMK8fcFvlGaiIiFko4EbslBR+Z3QT8i6c7cu/A8UvVTMzMz63uOJDUjKTcLuDkiQtItwEbAn6lTzU/gXIDx48dHS3HNzEqGDBnS6CSY9WntLtCIiKuBqyvM2qZK/O0qhN0I3Fgh/Hjg+PamyczMzHqVdYGjJB0FrCLpyojYm9R8dTzw9/x5K4Wan/m7pZqf/YDTgdNd89PMOsvYsWMbnQSzPq3mTkHNzMzM6kHSecBWwGBJ4yNir8K8J3JhBsD3gPNyh6GPk5q/LnLNTzMzs77JBRpmZmbWUBHxlRbmrV0Yfxb4SIU4rvlpZg3x7LPPNjoJZn1aTW85MTMzMzMz6+vmzp3b6CSY9Wku0DAzMzMzMzOzHscFGmZmZmZmZmbW47hAw8zMzMzMzMx6HBdomJmZmZmZ1WDppZdudBLM+jQXaJhZl5J0i6Tpko7O05J0hqQpkq6XNDKHHyvpEUmT8tA/h28m6S5Jd0ua2MBNMTMzsz5u9dVXb3QSzPo0F2iYWVc7ADi8ML0zsHREbAtcBRxRmHdiREzIw8IcdgawLzABOETScl2QZjMzMzMz62ZcoGFmXSoini8L2h64Po9fl6dLjpB0p6RDACQNBoZGxNMRMQ+YAmzR2Wk2MzOznkHS24XanQeUzTtC0r25pucZkpTDJ0m6J3+e0Z71Pf300/VMvpm104BGJ8DM+rzlgdl5vAko1bg4AzgOGAJcJ+lfwJM5DoX4I1tauKQDgQMBxowZU6ckm5mZWTf1QkRMqDLvjxFxKoCkq4AdgL/meZ+u8NClVfPmzaspkWZWH66hYWaNNgsYkceHkws3ImJmJG8D1wDjy+KW4s9qaeERcW5EjI+I8aNGjapz0s3MzKybWVnSHZKukTSuOCMiHi9MvgMsKM0CrpB0u6QdWluBpAMlTZU0df78+XVLuJm1nws0zKzR7gB2y+O75WkkjcifIvWX8VhEzAXelDRG0kBgG+C+rk6wmZmZdVvjImJ74BzggkoRJG0PrAJMzkGfjohtgC8Cv5Y0rKUVFB+WDBw4sI5JN7P2cpMTM+tSks4DtgIGSxoPfAL4qKQpwOvAfjnq6ZLWAwRMiogbc/ihwOU5/KyImI2ZmZkZEBEz8uctkn5VPl/SRsDJwB4REWXfmSbpQWBt4F9dl2ozq5ULNMysS0XEVyoEf6NCvIlVvj8V2LrOyTIzM7MeTtIywNsRsTAXXMwom7828Bvgk6VCjFwTdFhEvJ5rZrwPeLat61xmmWXqln4zaz8XaJiZmZmZWW+wAXCOpDmkfjEOkrQJsFNE/AQ4ndQX10X5BSc/AW4F/ibpbWAgcGxEtNg/V9Gqq65az/SbWTu5QMPMzMzMzHq8iLgP2LTCrAfy/I9W+ermnZUmM+tc7hTUzMzMzMysBk8++WSjk2DWp7lAw8zMzMzMrAYLFixoPZKZdZp2F2hI2lTSXZIm53c1r5mHyZImSfqbpNVy3KUlnS/pr3necjl8F0n35GHnwrKPysu+vfy90WZmZmZmZmZmJbX0ofESsEtEzJG0G3Ac8ApwQURcJGkicDDwXeAY4KqIuLX0ZUn9gVOB7XLQHZJuA9YBdoiIrSVtR3qd0mdr3C4zMzMzMzMz68XaXUMjIl6OiDl58h1gAfAwqcdggOWAV/P4jsAuuXbGcTlsbeDpiGiKiCbgmRy2PXBDXsdkYOP2ps3MzMzMzMzM+oaa33IiaShwAnAAMAe4RdIBwGBgixxtQ1Itje8AV0naBXgdmF1YVBMwElgeeLEQ3r+V9R8IHAgwZsyYWjfDzMzMzMysJssuu2yjk2DWp9XUKaikgcCVwCkR8V/gFODoiNgIOBY4KUedBdwcEQHcAmyUw0YUFjc8h5WHL2wpDRFxbkSMj4jxo0aNqmUzzMzMzMzMarbKKqs0OglmfVotnYL2Ay4Fro2Ia0vBwIw8/iqpxgXAJGB8Hh8PPAE8DqwhaVlJywJr5PA7gF3zOrYCHmxv2szMzMzMzMysb6ilyckngN2BlSTtC/yb1PTkHEkLgIHAQTnu94DzJA0hFWRcGxGLJB1JqrEBcGRELAQekXSnpLuAeaSmLGZmZmZmZt3S448/3ugkmPVp7S7QiIirgasrzNqmQtxngY9UCL8RuLFC+PHA8e1Nk5mZmZmZWVdbtGhRo5Ng1qfV1IeGmZmZmZmZmVkjuUDDzMzMzMzMzHocF2iYmZmZmZmZWY/jAg0zMzMzM7MajBgxotFJMOvTXKBhZmZmZmZWg5VWWqnRSTDr01ygYWZmZmZmvYKktyVNysMBZfOGSPqdpCn5c0gOHyfpdkl3STqqMSk3s1q0+7WtZmZmZvUk6RZgM+AXEXFCIXx/4NyIGFgWfxLwRER8OU9PBA4EAjg4Iv4pScAvgU2A14D9ImJW52+NmTXYCxExocq8icCjEbGPpB/m6bOBk4FjImKKpNskXRMRj7ZlZY/9858wenQdkm1mtXANDTMzM2u0A4DDiwH5yekngefKwj8KzClMLwccAkwA9iUVYgDsDCwdEdsCVwFHdFLazax7WVnSHZKukTSubN72wPV5/Lo8DbBJREzJ4zcUwiuSdKCkqZKmElGvdJtZDVxDw8zMzBoqIp5PFSoWcwjpyenppQBJ/YBvAL8APpWDtwCmRMQ84GlJwyQNZskbl6912gaYWXcyLiJmSNoZuAD4cGHe8sDsPN4EjMzjxYe8TcDKLa0gIs4FzgUYNmxY8OKLHU+1mbVsyesEwDU0zMzMrJvJtS62i4jry2Z9EbgGmFsIK96gQPNNSvmNy3KtrPPdJ67Tp0+vPfFm1lARMSN/3gKMLZs9CxiRx4fnaYBFhTjFcDPr5lygYWZmZt3NkcCpxYDcBGUf4LdlcYs3KNB8M1J+4zKbFkTEuRExPiLGjxo1quaEm1njSFpGUv88vhEwoyzKHcBueXy3PA3woKSt8viuwOTOTquZ1YcLNMysS0m6RdJ0SUfnaUk6I/c4fr2kkTl8ZJ6ekucrh2+WeyG/O3cEaGa9z7rAUZJuBlaRdCWwBqmA4npSYcfOkr4M3AtsI2mgpDHAGxHxDtVvXMys99oAmCppMnAGcJCkTSSV+ui5EHifpCnA+/I0pELUEyXdRWrC9khbVzhy5MjWI5lZp3EfGmbW1Q4AdgRWy9PvdtwnaT9Sx33fy59XRsQlkn6T491MukDZF3gB+LukP0VEi09eS2566CH3RN6DfHvOHDjnnC7/rnU9SecBWwGDJY2PiL0K856IiL3z5PgcNgHYNyLOz9NnkQosAjg0x70F+Gi+cXkd2K/zt8TMGiki7gM2rTDrgTz/beBzFb73FPChWtbpGl1mjeUCDTPrUhU6/6vWcd/2wCmF8O0l/Q0YGhFPA+QblS1INy4VSTqQ9DpHXu7fv05bYWb1FBFfaWHe2hXCJgGTCtO/AX5TFmcRqQNRM7NOs2jRotYjmVmncYGGmTVatY77RubpUnipk78mmpXCqyr2RD5+/PiYOnVqhxNsXeNnxx3HMccc0+XftTqo0hO5mVlv8/jjjzc6CWZ9mvvQMLNGq9Zx3+w8XQov7+SvGG5mZmZmZn2MCzTMrNGqddy3RHhEzAXelDRG0kBgG+C+rkysmZmZmZl1D25yYmZdqrzzP+ATVO6471TgYklfAx4Cbs3hhwKXAwLOamuHoGZmZmZm1ru4QMPMulSVzv+W6LgvImYCu1cInwps3QlJMzMzMzOzHqTdTU4kbSrpLkmTJd0uac08TJY0SdLfJK2W414o6V85/PeFZewi6Z487FwIPyov+3ZJ4+qyhWZmZmZmZp1ghRVWaHQSzPq0WmpovATsEhFzJO0GHAe8AlwQERdJmggcDHw3xz84Iu4sfVlSf1JV8u1y0B2SbgPWAXaIiK0lbQecDHy2lo0yMzMzMzPrbMsvv3yjk2DWp7W7hkZEvBwRc/LkO8AC4GGa3zywHPBq4Ss/kzRF0t55em3g6Yhoiogm4Jkctj1wQ17HZGDjltIh6UBJUyVNnT59ens3w8zMzMzMrEMWLFjQ6CSY9Wk196EhaShwAnAAMAe4RdIBwGBgixztsIiYIWkk8FdJ/wCWp/m1jABNwMgc/mIhvH9L64+Ic4FzAcaPHx+1boeZmZmZmVktnnzyyUYnwaxPq+m1rfl1iVcCp0TEf4FTgKMjYiPgWOAkgIiYkT9nAX8h1bqYRXNtDoDhOaw8fGEtaTMzMzMzMzOz3q+WTkH7AZcC10bEtaVgYEYef5VU4wJJI/LnINJbCf4HPA6sIWlZScsCawBPAHcAu+b4WwEP1rRFZmZmZmZmZtbr1dLk5BOkVymuJGlf4N+kpifnSFoADAQOynGvlLRMDrs0Ih4GkHQkcEuOc2RELAQekXSnpLuAeaSmLGZmZmZmZmZmS2h3gUZEXA1cXWHWNhXi7lwhHhFxI3BjhfDjgePbmyYzMzMzMzMz61tq6kPDzMzMzMysr1txxRUbnQSzPs0FGmZmZmZm1mtIWlfSfEnblIWfKmlSHl6SdHAOnyTpnvx5RnvWtdxyy9Uz6WbWTjW/ttXMzMzMzKwb+gHphQOLiYgjSuOS/g38oTD70xHxfHtXNG/evJoSaGb14QINMzMzMzPrFSRtCbwMLGwhzmbAKxHxYg4K4ApJ84ATIuL2VtZxIHAgwODBg+uSbjOrjZucmJmZmZlZb/F94ORW4uwL/K4w/emI2Ab4IvBrScNa+nJEnBsR4yNi/MCBAzuWWjPrEBdomJmZmZlZjydpd2BqRMxsIU5/YE8KzU0iYkb+nAY8CKzdyUk1szpxkxMzMzMzM+sNNgEmSNoKeB/wHkl7R8SzhTgfJhV6vA4gScCwiHg918x4H/AsZtYjuEDDzMzMzMx6vIg4ETgRQNKFwPnA+pK2i4hLcrR9gUsLXxsA/E3S28BA4NiImNV1qTazjnCBhpmZmZmZ9SoRMbFK+H5l0/OBzWtdz8orr1zrV82sDtyHhpmZmZmZWQ2GDx/e6CSY9Wku0DAzMzMzM6vB3LlzG50Esz7NBRpmZmZmZmY1ePZZ9x9q1kgu0DAzMzMzMzOzHscFGmZmZmZmZmbW47hAw8y6BUnHSbpb0iRJG0maIOmlPD1J0uY53khJ10uaIumM/P54MzMzMzPrY1ygYWYNJ2kTYIuI2Ar4AvCLPOuGiJiQh/tz2BHAlRGxLTAU2LnLE2xmZmZmZg3nAg0z6w7WBe4HiIhpwBrAYGDnQk2MpXLc7YHr8/h1edrMzMysy62yyiqNToJZn+YCDTPrDv4DTJA0SNLGwGrAf4F1ck2M14HDctyRQFMeb8rTVUk6UNJUSVOnT5/eGWk3MzOzPmrZZZdtdBLM+rR2F2hI2lTSXZImS7pd0pp5mJzbuf9N0mpl35kk6fzC9MTcVv4uSZvlMOWnsFNy+/gWb1LMrPeIiP8ClwF/AQ4FHgZejIjSy91/B4zP47OB4Xl8ODCrlWWfGxHjI2L8qFGj6p52M+s4SbdImi7p6LLw/SXNL0z/Pl8/3CtpYiHc1xVm1hBvvfVWo5Ng1qfVUkPjJWCXiNgOOA04Dvg6cEFETAAuAg4uRZb0UWBOYXo54BBgArAv8Ms8a2dg6fw09ipSO3kz6yMi4qyI2B74GfBvYJnC7B2Ax/L4HcBueXy3PG1mPdsBwOHFAElDgE8CzxWCj8p97WwPHC1piK8rzKyRpk2b1ugkmPVp7S7QiIiXI6JUQPEOsID0NHVEDlsOeBVAUj/gG8CvCovYApgSEfMi4mlgmKTBuF28WZ8m6VZJtwPHAN8G9slNRSaTCjROylFPzfOmAPOBWxuSYDOrm4h4vkLwIcDZQBTiPZ5H5wEL87y6XFe4eZqZmVnPM6DWL0oaCpxAeqoyB7hF0gGkjvy2yNG+CFwDzC18dXlSlfGSJlIb+GJ4E6lgpKX1HwgcCDBmzJhaN8PMuomI+EhZ0Fl5KI83E9i9SxJlZg2Ra11sFxGnSjq9QpQjgSsi4h1JdbmuiIhzgXMBxo8fHy3FNTMzs+6hpk5BJQ0ErgROyW3fTwGOjoiNgGOBk3JV0X2A35Z9fRbNtTmguQ18MXw4i1+cLMHt4s3MzHqtI0m1sZYgaT9gI1KTV6jTdYWZmZn1PLV0CtoPuBS4NiKuLQUDM/L4q6QnI2uQLiSuJ12U7Czpy8C9wDaSBkoaA7wREe/gdvFmZmaWrAscJelmYBVJVwJI2hP4PPCFiFiU4/q6wswWI2ldSfMlbVMWfqykR/ILCyZJ6p/DN8udCt9d7HDYzLq/WpqcfIJU3XslSfuSOu87AThH0gJgIHBQRDxCfiuBpAnAvhFxfp4+i3RhEaQ3GgDcAnw0t4t/Hdivxm0yMzOzHkTSecBWwGBJ4yNir8K8JyJi7zz5O+BR4FZJAPtExAu+rjCzMj+geiHmiRFxaVnYGaROhV8A/i7pTxHRplpdq666au2pNLMOa3eBRkRcDVxdYdY2FcJK35kETCpM/wb4TVmcRaQORM3MzKwPiYivtDBv7cL4MlXi+LrCzACQtCXwMqnj4EqOkPRV4KqI+GXuRHho7lSYXAi6BalQtFXLLFMxWzKzLlJTHxpmZmZmZmbd0PeBk6vMOwPYGNgJ+JikbUkdCDcV4jSRms9XVXwr0vPPV3pJk5l1FRdomJmZmZlZjydpd2BqfiPaEiJiZiRvk97EOJ7qHQtXVXw5wZtvvlmfxJtZTVygYWZmZmZmvcEmwITcofBOwGmSxpZmShqRPwVMAB6LiLnAm5LG5Dc5bgPc18XpNrMa1dIpqJmZmZmZWbcSEScCJwJIuhA4H1hf0nYRcQlwuqT1SG9onBQRN+avHgpcnsPPamuHoGbWeC7QMDMzMzOzXiUiJrYlLIdPBbbu5CSZWSdwkxMzMzMzMzMz63FcoGFmZmZmZlaD1VdfvdFJMOvTXKBhZmZmZmZWg6WXXrrRSTDr01ygYWZmZmZmVoPXX3+90Ukw69NcoGFmZmZmZlaDl156qdFJMOvTXKBhZmZmZmZmZj2OCzTMzMzMzMzMrMdxgYaZmZmZmZmZ9Tgu0DAzMzMzMzOzHscFGmZmZmZmZjUYO3Zso5Ng1qe5QMPMzMzMzKwGQ4YMaXQSzPo0F2iYmZmZmZnV4LXXXmt0Esz6NBdomJmZmZmZ1eDll19udBLM+jQXaJiZmZmZmZlZj9PuAg1Jm0q6S9JkSbdLWjMPkyVNkvQ3SavluD+RdIek+yT9pLCMXSTdk4edC+FH5WXfLmlcXbbQzHoEScdJujvnIxspOUPSFEnXSxqZ443M01PyfDU67WZmZmZm1vVqqaHxErBLRGwHnAYcB3wduCAiJgAXAQfnuN+PiO0jYgtgC0nvldQfOBXYNQ+nSuov6T3ADhGxNXAscHIHtsvMehBJmwBbRMRWwBeAXwA7A0tHxLbAVcAROfoRwJU5fGiOZ2ZmZgaApHUlzZe0TVn46ZL+nofvFcKfzg9UJkn6ften2Mxq1e4CjYh4OSLm5Ml3gAXAw8CIHLYc8GqOOw9A0kDgDeBFYG3g6Yhoiogm4Jkctj1wQ/7eZGDjWjbIzHqkdYH7ASJiGrAGKU+4Ps+/Lk/TQnhFkg6UNFXS1OnTp9c73WZmZtb9/AC4o0L4ryLiA8BWwJ6S1srhCyNiQh5O7LJUmlmH1dyHhqShwAnAT4DbgIMkPQR8FTi/EO8M4CngZeA1YHlgdmFRTcDICuH9W1m/b1LMeo//ABMkDZK0MbAai+cJTaTCUkj5RVMhfGRLC46IcyNifESMHzVqVJ2TbWZmZt2JpC1J9x3Pl8+LiMfz5yLSQ9mFzV/T3yTdnGuNttkaa6zRsQSbWYfUVKCRa1xcCZwSEf8FTgGOjoiNSM1FTirFjYiDSU9bVwB2AWbRXJsDYHgOKw9fSAt8k2LWe+R85DLgL8ChpFpfr9GcJwynuXBjdp4uhc/qsoSamZlZd/d9Wmm6Lmkf4KmIeCYHbRkRHwK+C1za2gqKD1b92lazxqqlU9B+pBP92oi4thQMzMjjr5KfmEoaAhARC4A3gbeAx4E1JC0raVlSYccTpGphu+bvbQU8WNsmmVlPFBFnRcT2wM+AfwO3A7vl2bvRXHX0jirhZmZm1odJ2h2YGhEzW4izI7A/qVY5ABExI38+CLwlabkqXy/Ff/fB6oABA+qTeDOrSS1n4CeA3YGVJO1LuvE4AThH0gJgIHBQjvs7ScvnsCkRMQlA0pHALTnOkRGxEHhE0p2S7gLmAQfUuE1m1gNJupWUJ80EvkEqJP2opCnA68B+OeqpwMWSvgY8BNzagOSamZlZ97MJqQnrVsD7gPdI2jsinoV3m6McD+waEW/nsMGAImKupFVJtUOb2rrCV199ta4bYGbt0+4CjYi4Gri6wqxtKsT9ZJVl3AjcWCH8eFImY2Z9TER8pELwNyrEm0kqVDUzMzN7V+7Q80QASReS+vVbX9J2EXEJcEGOem1+6/t3SLXL/yTpTVIffgdFRHR12s2sNq4jZWZmZmZmvUpETKwQtmGV6Jt1bmrMrLPU/JYTMzMzMzMzM7NGcYGGmZmZmZmZmfU4LtAwMzOzhpJ0i6Tpko4uC99f0vzC9DhJt0u6S9JRhfBdJN2Th50L4UfluLdLGtclG2Nmfcpaa63V6CSY9Wku0DAzM7NGOwA4vBiQX/3+SeC5QvDJwDERsTWwg6T3SOpPevvRrnk4VVJ/Se8Bdshxj83fNTOrK7+21ayxXKBhZmZmDRURz1cIPgQ4Gyi+bWCTiJiSx28AtgfWBp6OiKaIaAKeyWHb5zhExGRg405JvJn1aTNnzmx0Esz6NBdomJmZWbciaTlgu4i4vmxW8bqlCRgJLA/MbkN4/1bWeaCkqZKmTp8+vcaUm1lfM2PGjEYnwaxPc4GGmZmZdTdHkpqRlFtUGB8OzMrDiDaEL2xphRFxbkSMj4jxo0aNqiHJZmZm1tVcoGFmZmbdzbrAUZJuBlaRdGUOf1DSVnl8V2Ay8DiwhqRlJS0LrAE8AdyR45C/82BXboCZmZl1PvdiY2ZmZg0l6TxgK2CwpPERsVdh3hMRsXeePBK4QNIg4KaIeCTHORK4pRQnIhYCj0i6U9JdwDxSx6NmZmbWi7hAw8zMzBoqIr7Swry1C+NPAR+qEOdG4MYK4ccDx7c3PTc99BCMHt3er5mZmVkXc5MTMzMzMzOzGqyzzjqNToJZn+YaGmZmZmYFu260EVOnTm10Msx6P6nRKeiwfv38fNiskXwGmpmZmZmZ1cCveTZrLBdomJmZmZmZ1WDWrFmNToJZn+YCDTMzMzMzMzPrcVygYWZmZmZmvYakdSXNl7RNWfhISddLmiLpDCl14iFpM0l3Sbpb0sSGJNrMauICDTMzMzMz601+ANxRIfwI4MqI2BYYCuycw88A9gUmAIdIWq4rEmlmHecCDTMzMzMz6xUkbQm8DDxfYfb2wPV5/Dpge0mDgaER8XREzAOmAFt0SWLNrMMUEY1OQ4dJmgM81uh09DArADManYgexvsMxkbEqEYnolbOK9rNx3z7eH816+l5xXTg2UanoxvwMd15vG+TuucVkv4M7A/8FDg/Iu4szHsMeE9EhKQPAZ8FjgMui4gJOc5xwKMRcXkL6zgQODBPbgj8p57bYO/yedK5etr+rZhfDGhESjrBYxExvtGJ6EkkTfU+ax/vs17BeUU7+JhvH++v3qMnF8bUk4/pzuN92zkk7Q5MjYiZuXuMcrOB4UBT/pyVhxGFOKXwqiLiXODcvE7/lp3E+7Zz9Zb96yYnZmZmZmbWG2wCTJB0M7ATcJqksYX5dwC75fHdgDsiYi7wpqQxkgYC2wD3dWGazawDXKBhZmZmZmY9XkScGBE7RMQuwF+Aw4D1JX0hRzkV2EfSFGA+cGsOPxS4nFTgcVZEzO7ipJtZjXpLk5NzG52AHsj7rP28z3o+/4bt4/3VPt5f1tv4mO483redLCImVgibCexeIXwqsHWNq/Jv2Xm8bztXr9i/vaJTUDMzMzMzMzPrW9zkxMzMzMzMzMx6HBdomJmZmZmZmVmP4wINMzMzMzMzM+txXKBhZmZmZmZmZj1Ojy/QkDRR0t2S7pK0WaPT0x1JWjbvo0mS7pP0YSVnSJoi6XpJIxudzu5G0uaSbpX0N0mnep/1bM4rWudjvnWSbpE0XdLReXq/nK9OlnSFpME5fJyk2/PxdlRjU21WnY/pzlNh306Q9FK+HpskafMcPjLnsVNynqvGptzaytcWnUvSupLmS9qm0WnpTfL13ZmS7pH0D0mfa3SaOqJHF2hIWg44BJgA7Av8sqEJ6r7eALaLiAnAZ4GTgZ2BpSNiW+Aq4IjGJa/7kTSItJ8+GREfiogj8D7rsZxXtM7HfJsdABxemL4T+GBEbAc8Rzq+IO3LYyJia2AHSe/p2mSatZmP6c5Tvm8BboiICXm4P4cdAVyZ89qhpLzXujlfW3SJHwB3NDoRvdB7gfdGxAeBHYATGpyeDunRBRrAFsCUiJgXEU8Dw0pPEqxZRCyKiAV5clngIWB74Pocdl2etmYfJBUEXZafSG2L91lP5ryidT7m2yAini+bfioiFubJd4BSXrtJREzJ4zfgfWfdlI/pzlO+b7OdCzUxlsphzmt7Jl9bdCJJWwIvA5XOI+uYF4F5kgYCw4BZDU5Ph/T0Ao3lgdmF6Sagz1eJrkTSqpLuBG4F/sji+64JWK5BSeuuRgMbA/sAXwDOA1bA+6yncl7ROh/zHZCfVu8CXJmDiv+vTfh4sx7Gx3SnuB9YJ9fEeB04LIePJO1T8L7tSXxt0bm+T6oZZvU3G3gc+B/wAK6h0VCzgBGF6eH08BKmzhIRL0TENqTS5DNZfN8NZ/EM2dL+uTsiXo+IF4AZQH+8z3oq5xWt8zFfI0mrARcBn42IuTl4USGKjzfrUXxMd46ImFPYn78Dxufx2aR9Ct63PYmvLTqJpN2BqRExs9Fp6aV2AlYF1gbeA5zUk2sX9fQCjXuBbSQNlDQGeCMi3ml0orqbsgP0dWAOqT3abjlsN9w+rdy9wLqSBkgaBqwI/AHvs57KeUXrfMzXQNIKpP301Yh4sjDrQUlb5fFdgcldnjizGviY7jyShhcmdwAey+O+JuuZfG3ReTYBJki6mXTzfZqksY1NUq8iYHZuXjgHGER6iNUjKSIanYYOkfQl4MtAAIdGxNQGJ6nbyb1o/xxYCAwAjgX+BpwBbEQq5NjPpaCLk/QF4CBgIKnK25/wPuuxnFe0zsd86ySdB2wFDAb+Q2rbuxfwRI5ySURcIGlN4ALSRcJNEdGjq3Na7+VjuvNU2Le3Al8C3iLVgvtSRDRJWh64mOZ+zg6OiEWVl2rdia8tOp+kC4HzI+LORqelt5DUn5Sfr03Kny6JiB7bqW2PL9AwMzMzMzMzs76npzc5MTMzMzMzM7M+yAUaZmZmZmZmZtbjuEDDzMzMzMzMzHocF2iYmZmZmZmZWY/jAg0zMzMzMzMz63FcoGFmZmZmZmZmPY4LNMzMzMzMzKxbkXSvpAck/VfSgjz+gKTfSvqRpL07cd0TJTVJuruVeONymuZJ2rCz0mPVuUDDOpWkkPSQpB3rvNzbJM2S9M16LtfMGsN5hZm1hfMKs74jIraMiE2A3YCmiNgkD/tHxA8j4spOTsJtEbFVK2l8JqfxxU5Oi1XhAg3rCltFxG31XGBE7Aj8uZ7LNLOGc15hZm3hvMKsj5N0YakAUtKxkq6QdKOkJyRdKWlTSbdLelLSTwrfW0XS1ZLuk/RvSUe1cX1LS/p9ri3yoKSrOmvbrH1coGHtJuk9kqZJGpunj5F0RRu/e7Gk/QrTv5L09Tx+iqRLJN0k6VlJF0iakJ+aPC/pmM7ZIjPrDM4rzKwtnFeYWR1sDnwOWA94D3AysCuwEfBFSevkeBcDv4yILfJ3dpW0UxuWvzOwbERsEBEbAwfVewOsNgManQDreSLi0VyaeaWkHwKfB97fxq9vTspgitMX5fHNgNnAnsBg4FVgBvARYCxwP3BchzfAzLqE8wozawvnFWZWB7dExGsAkh4CHoyId4B3JD0GrCXpRWACMEpS6XvDgPWBv7Sy/AeB9SX9CpgE3FD3LbCauEDDahIRl0j6MHAtsG1EvN7adyQNBVYDHs3T/UkZyEM5yqbAphExL89bCPwoIhblTGdW3TfEzDqV8wozawvnFWbWQXML4wsrTA8gtU4I4P0RMb89C4+IpyS9F/gwqebHSZLeFxFzW/mqdTI3ObGaSBoEvBdoAlZq49c2Bf4dEYvy9CbA0xExN1cznRMR0/K8jYGHIuLNPL0Z8M96pN3Muo7zCjNrC+cVZtbZImIOMAX4XilM0uqSVm7tu5JWAxZGxLXA/wGjgJGdlFRrBxdoWK1+QqqquRNwdj7JWzMeGCypn6TBwFHAA3neZnl5JZsDUwvT5fPNrGdwXmFmbeG8wsy6wj7ABrlD0H8DVwIj2vC99wH3SHoQuA/4cUT4zSbdgJucWLtJ2ovU/mzL/BTkOOBySR+KiAUtfHVzYBrpYuMN4C5gb0lrUvnCY1JhejPgZ3XaBDPrAs4rzKwtnFeYWUsi4hlghbKwiYXxY6vNy9MTCuMvkzoPbW8abgJuau/3rPMpIhqdBuvFJAUwLCLekPQI8PGIeLROy74QmBoRZ9ZjeWbWOM4rzKwtnFeYWVeQtDdwCvBiRGzVQrxxpL5/RgE7RMRjXZJAe5ebnFhnewW4S9JHSW1i63KSS7oN2B54s7W4ZtYjOK8ws7ZwXmFmnS4iroyIcS0VZuR4z0TEJhGxqgszGsM1NMzMzMzMzMysx3ENDTMzMzMzMzPrcVygYWZmZmZmZmY9jgs0zMzMzMzMzKzHcYGGmZmZmZmZmfU4LtAwMzMzMzMzsx7HBRpmZmZmZmZm1uO4QMPMzMzMzMzMehwXaJiZmZmZmZlZj+MCDTMzMzMzMzPrcVygYWZmZmZmZmY9jgs0zMzMzMzMzKzHcYGGmZmZmZmZmfU4LtDoRiTdJOmLXbzOCyWd0JXrbAtJEyXd2eh01JukfSTd2sa4x0q6tMq8iZIWSnpD0vptXN66Of5CSV9uT7qtsbrL+dBd0tFoko6SdH4b41bNY/M5Pj+fl0PbuLwdc/xFknZsT7qt52vt2GvPf0wd0zRB0vNduc62khSS1m50Ouot5wFrtiHeuLwPBlSZH5LelHRiO9Z9u6S5/i+wjpJ0tqQf1GE5LR7nHVhu1evwrlTYvjckHdiO7z0paV532IbO1qcLNCQ9I+nV4oWkpC9LmtQF617iJImIXSPios5ed731ppucfEzU5SahUgYbEb+LiI/UY/nAPRGxTEQ8IumzOe0qS8OAfIx/NCL+FxHLAFPqtH6ro/z7vZ3/sErDmXVcfqf84bewvrqdSzWsu243MZVu1iLipIioV6Hglfk8flPS9yRNrpCGFfJFyYYRcVs+j5+r0/qtE5Wd16/kAq5lal1e8djrgv+YLtVbCh/qfRMkaVL5Q4icZzxVp1VsHBHflzREUpOkHSqk4eeSrs7r3gH4ap3Wbd1A2XXHorJrkX06a70R8dWIOL6zll9PXX0NVcWIiDhX0qqSFkhaqzyCpD9KOg0gItYCTuryVDZAny7QyPoDhzY6Eb2dpP6NTkMvdy0wAti+LHwXIICbuzg9Vps98oVqafhmV668wX/UBpcCW0laoyz8s8C/I+I/DUiTddweuRBqM2A8cHSD09MjOX/qXBExF7gS2K8Ynq/fPgf0uAdu1jbF6w5SYXnxWuR3bVmGz8+uExEvAH8FvlAMlzQS2I0+eK66QAN+AhwmaUSlmZLeI+kvkmZJekzSZwrzlpd0naTXJf1D0gnFmgqSfiFpWp5/v6Rtc/guwFHA3rn088EcPinXEBmcS8k3LCxrVC4xXTFPf1TSAzne3ZI2qraBLW1DhbhVlytpdUnXSJouaaakM5WaO5wNfDBvS1OOe6GkX0u6UdKbwIckrZ+3sUnSw5I+VrYv/5z31X3AWmXpas82TJL0Y0n35eX9KZ/kpfkfy+tvynHXz+GXAGOA6/K2HJHDP5D3RZOkByVNKFvX8ZLukjRH0q2SVsizS09am/LyPqiy2izVjpH2yhciV1F2IZKnL4uIBbUs17qnVvKlpST9VNKzkl6TdKekpah+PN6l9PRtJnCspOGSLs7n+bOSjpa0xH+FpF9J+mlZ2J8l/V8t51KF5T8j6UhJ/5U0W9JvJQ0pzP+KpCfyPvizpNE5vLSdD+Z1753DW8rbnpF0mKSH8j67Uulp5VDgJmC0mp9WjVbZE1hJv5f0cv7uZEnvbcvvWC4ingdup+wihXQeX1zLMq37yBehNwEbQvX/ojzvu5JeyP8rj0n6cA4vHnst/sco/QefVkyD0v/ht/P4aEl/yOf605IOqZZ2peuS0yQ9p1TT5Oycr1SKW3W5kvorNZt5Mm/b/UrXFkuct8q1o/K+eBn4bU7H6ZJezMPpkgYXln+4pJfyvC91YBtKeeOZ+bx+tPQbFLbxzzn/eULSV3J4teu74ZIuyGl7Qel6sX9hXXfmtM3O+2zXPO9EYFvgTBVq7alQm0XS7pL+pXQdMU3SsdV+xza4CPikpKULYTuT7hdu6sByrQeS1E+p5uCTStf9VylfT6u5xsIBkp4Dbtfi1xRNkp6StFUOn6ZUY/iLheVfqNwks3C+fyfHe0nS/oW4NR3nOf+4uizsF5J+mccrnssVVMpv11JqgjVT0gxJv1PhflLSZjnNc5SuE65UoQmq2nEvV8FFLHmt8FngvxHx73Ysp3eIiD47AM8AOwLXACfksC8Dk/L4UGAasD8wANgUmAFskOdfkYelgQ1y3DsLy98XWD5/9zvAy8CQPO9Y4NKy9EwCvpzHfwOcWJj3DeDmPL4p8CqwJamGyRfztgyusI2tbcOFhW2vutw8/SDw87zMIcA2+XsTi9tdWO5rwNakP8JhwBOkP/pBwA7AHGC9wr68Ki97Q+CF0jJb24YK2zwpf3/D/N0/lPY1sC7wJrATMBA4IqdrUPGYKCxrVWAmqcSzX/7eTGBUYV1P5uUuladPzvPGkWpHDCgsb7F9RTuPkWrLyWFbA68DS+Xp4cDbwCbVjjMP3WcoP/aq/d6tnQ/Ar/JvvCrpvN2KdA5XOx4XAAfnZS1FunH+E+mcHQf8DzigQjq2AF4E+uXpFYC3gJUqbU9r51KV/fEfYHVgJHAXzXnVDnmbN8vbdgYwufDdANYuTLeYZ+bx+4DReV2PAF/N8yYAz5elbbFzE/hS3l+DgdOBBwrzLiylu8I2LracHLYP8Hhhej1gXvl+Kt+/HrrnUPyd8rH8MHA8LfwX5d98GjA6f28csFb5MUMr/zHAdnk5ytPLkf4TRudz8H7gh3mdawJPATtX2Y6fA3/O58cw4Drgx3neu+dIa8sFDgf+nbdRwMbA8nle+Xk7gZQ/nZLPraWAHwF/B1YERgF3A8fn+LsAr9D8339ZcZktbUOF7Z2Y1/1/+ffZm3RNMzLPnwycRboW2gSYDuxQ/hsVlvdH4JycrhVJ+c1BhXXNB75Cyp++RspbS7/bJMr+s8u2awLwvrzvN8r7YK9qx0i15RTC/gfsW5i+HDi9wv65s9IyPfTsgcXzrEPz+bZaPgfPAS7P80rH1sX5uF6qcN7sn4/lE0g1Pn6Vv/8R0rX/MnkZF9L8vz4hf/dH+ZzbjXRNsVxhfruPc2BsXs6wPN0feAn4QJ5u07lcaR3A2qQ8fDApP5pcOldI+d+zeR8OBD5B+i9v9Z6rwjZUWvdSpDxpm0LYPcC3yr777jb05qHhCWjoxjcXaGyYD4pRLF6gsTcwpew75wDH5INvPvmGPM87gRYyeGA2qa1ixQOMxQs0dgSeLMy7C9gvj/+a/AdemP8YsH2FdVbdhjx+YeHkqrpc4IP5JK+UWUws3+683IsL09uSbtb7FcIuz/uhtC/fU5h3Es0XZS1uQ4X0TCIXKuTpDXIm0h/4AXBVYV4/UuHHhOIxUZj/XeCSsuXfAnyxsK6jC/O+TnPB0zhaKdBo7zHS2nKAx4HP5/GvAA9W2T8u0OhmQz723gCaCsNXyn/vls6HfDy/XTqGyuJUOx6fK0z3z+fKBoWwg2jOExc77kg3/jvl8W8CN5ZtT5vPpSr746uF6d3IeSJwAXBqYd4ypDxkXJ4uvzFqMc/M6ypewJ8KnJ3HJ9BKgUbZvBF5/cPz9IW0r0BjaVLB5FZ5+kTgT1X2jws0uvlQdl4/S7pwXooW/otIF8mvkq4DBlY7Zlo4p0t5hUg3E9vl6a8At+fxLSmc+znsSOC3FbZBpMKXtQphHwSezuPvniOtLTefd3tW2Vfl5+0EUn40pBD2JLBbYXpn4Jk8/hsW/+9ft7TM1rahQlomUihUyGH3kZ6Irg4sJN8g5Xk/Bi4s/43y9ErAO+SHDTnsc8DfCut6ojBv6ZzulfP0JFoo0KiQ9tOBn1c7RlpbDqlJ1K15fFnSzeCmFfaPCzR64cDiBRqPAB8uzFuF9F87oHBsrVl2XBQL5N+X46xUCJtJftDGkgUab7N4fvYqueChQjrbc5zfSfM91E40X0u0+VxubR05zl7Av/L4dqQ8XWXpaPWeq8JyK64bOB84N4+vQ8ovVyyL8+429Oah17R3knQL6WndLyKiXW/tiIj/SLqedBP9eWC+UsegTwFbKjejyAYAl5AKPwaQnn6UFMeRdBhwAOlpSJD+GFagbf4GLC1pS1Ip5CakEn5IpY1flHRwIf6gvJ5yY1vYhkpxqy13IfBstK/pQnF/jAamRcSiQtizpKe2lfblszVuQ6V1P0sqHV0hp+PdZUfEIknTcjoqGQt8WtIehbCBpN+n5OXC+Fukm6s26eAxUsnF5GYmpAsvV1PvWfaKiNtaidPS+bAC6SnDk+1YZ/FcWYF0fBfPv9J5WslFpFpGf8mfv2gl3a2dSy2l7Vma87jRwD9LMyLiDaUmM6uSLsYqrbu1PLP8PK6Uny4hVxs/Efg0KS8r5XErkArK2yUi3pL0e2A/SfeQamx8p73LsW5lifNaqYlUxf+iiJgk6VukC9H35uubb0fEi+1ZaUSEpCtIN8+TSdc3peYqY0lNqZoKX+lP5U6jR5Fusu9Xc7/TyvHLtbbc1Wlf/jQ9UpPKksX2G0vmC/eXzStpzzaUvBD5jqBsXaOBWRExp2ze+CrLGUvK614qrLsfi+dv7+Y/OQ+ANl5L5OvEk0kP5waRnhb/vi3freIS4Jh8jO5Cuvn7VweWZz3XWOCPkorX7gtJhXQl0xb/Cq8Uxt8GiIjysGrH9syy+4x3r6k7eJxfRsoHLyblg5fl8Paey4uRtBLpumdbUq2vfqQHk6Vll+chxX3Vnnu5ai4C/qzUrO8LwC0R8Wo7vt9r9JoCDdJN4Y6kalG1OAb4F+lPZVpETJD0OWD1iNipPHK+iF2Q1/e/HLx6Yf62pCqkHwYezhcrs0l/oJBuXquKiIWSriKdgK8A1xdOuGmk5ihtec3WNOCOSttQJW7F5Ur6IDBG0oAKhRrVtqUY/iKwuqR+hUKNMaR9N520L1cHHi3Mq2UbSlYvjI8hlSjPyOl4X2mG0lXD6qRS1ErbMo30VLlam7qWtPgbt+EYqcUlwA/z7/UBoGpfI9ZjVT0flPq6mEvqg+bBstltOU9nkM6VscB/c9gYms+PcpcC/5G0MbA+qXPaauur5VwqP49LN3Qv5jQCoNTXxfItpLM9eWa5Fs9j0sXRnqT/n2dITb06eh5fRNqX19BcNd56lxb/iyLiMuAyScuSamCdwpLtpVs7NiHVhLxV0smk2hMfz+HTSLUT1mnDMmaQbkLeG6kfkJa0ttxppPyprR3clm9j6dx/OE8X84WXWDLPKGnPNpSsKkmFG5IxpCYrLwIjJQ0rXJcV88lKed87wArtfChU0trvfBlwJrBrRMyVdDodeDASEc9KmkIqpN6VPtjBoL1rGvCliLirfIakcXm0LflQPXTkOP898FNJq5HywA/m8NbO5aJK23lSDn9fRMyStFdOI6T8qDwPKRboduS6pOROYBbpGmRf0j1Fn9RrOgWN1Jnau5Q6YLpK0l9zhy0tvgosIp4ArgfWADaRdDGpbea6kr4gaWAe3i9p/YhYSLrYPFbS0pLew+IdMg4j3aRPBwZI+iHp6XvJK8A4Vehsr+AyUvXyfWguTQQ4D/iqpC2VDM2d5QyrsIzrq21DhbgtLfc+0sl5cg4fImnrwrasJmlQC9tyL6mk9YichgnAHsAVFfblBqS2ZLVsQ8m+kjZQ6tjqR8DVeT1XAbtL+rCkgaQnn++QfuvSthTf7X4psIeknZU6Mxui1HFRWwrOppOe1lZ7V3xrx0i7RcQzpAzucuAvEfFyy9+wHqjq+ZALC38D/Eypo6v+Sh1XDab145HCOXKipGGSxgLfpvmpbnn854F/kArS/hARbxdm1+Nc+oak1ZQ6Ifs+qQd+SMf3/pI2ydt2EnBvPv4rrbs9eWa5V4DlJQ2vMn8YKQ+ZSXoCXI9XpE0hNVE4l5RHzqvDMq17qfpfJGk9STvkY3su6UZ8UYVltOWc/hfpZv580tO7pjzrPmCOUod5S+VzckNJ76+wjEWkc+jnau6YfFVJO1dYZWvLPR84XtI6+VzcSNLyeV75eVvJ5cDRSh2lr0Dqq6OUP10FTCz89x9T4zaUrAgckvPYT5MKbW+MiGmka4Yf53xsI9JDtVI6Fru+i4iXgFtJN1TLKnW0uJak7VvZ1pLW9ssw0lPmuZK2IBWydtRFpGaEWwNtesuF9Upnk64HxsK7LyjYs0Fpqfk4j4jppKZbvyUVuD6Sw1s7l4sq5bfDSE0KX5O0KqmPoJJ7SLVZvilpQN5vWxTmd+S6pLRdQap1cgqpuWufffjRawo0KjgSuCYiPkzq1OnkNnznaFL7owdIN4U/JHVg81lSKd7LNHdOBSmzH57DLyH90b6T591CelXm/0jVl+ayeFWjUjWpmZL+SQURcS+pzedoCr1LR8RUUlvYM0lPAp8gtVurtIw5rWxDMW7V5eYbnT1IbVGfA54nFbZA6pX/YeBlSTOqpGNe/v6upIurs0jt2Uo1Mr5Jqlb2MqlN3W9r2YaCS/JyXiZVwT8kL+sxUinmGTkde5BeT1W6Yfgx6WKpSdJhObPbk9SZ6XTSb3g4bTh3IuItUlX0u/LyPlAWpbVjpFYXkZ5gublJz1N6K0hp+GN5hDacD4eROt37B6nk/hRS3zWtHY8lB5PynadI+eBlpEKSai4iPWkubwJWj3PpMtKNwFOkpxon5H1wG6kPgj+QClrXyvuj5Fjgorzuz7QnzyyX86jLgafy8sqrg15MOn9fINVq+XtbltvKOksXKT6Pe6lW/osGk65ZZpDO7xVJ1zTly2jrOX0ZqQbRZYXvLgQ+SmrO+jTNhR7VCu6+Szpv/i7pdeA2Usee5Wlqbbk/IxU83ErqK+YCUp8iUHbeVknHCcBU4CFSPvdPmvOFm0jt6m/Pab29lm0ouJfULn0GaT9/KiJm5nmfI7Vrf5HUHPiYQrOiStd3+5Gqk/+XlAddTeqPoC1+AXxK6Q0ov6ww/+vAjyTNIV23XtXG5bbkD6TOU/+aC2Ssb/oFqVbSrfn4+jupplcjdPQ4XyIfzFo6l99VJb89jtTdwWvADaSHs6X480gdgR5AekCxL+mB1Dt5fs3XJWUuJtUquTIi3mktcm9V6kG5V5A0EVgtIk6QdAMpMy79uAsiYkel1/zsUv7diFjsQiCX7t8TERu3Y/2nkDpx+mKrka3TKPV/cmlEnN/otHQWSV8gVUOeB3ywVNrcynfWId3kDgK+HhEXdmoirU+QtB3pacbYqOMfiqRnSB3htdanSI8l6WjSjep8Ut8Jb7bhOx8m3WwMJnWO2FIfJGZWg3w9+eWI2KbRaelMkuaSrpN/GRE/aON3/kJq0npffmhoZm0g6V5Sh+O/bTXy4t8bS+owdC5weESc18bvPUbqW+yqiPhSa/F7st7Uh0a5h0kFEn8EUG4OERHHkp4CLEHS8IgodeK2A+ngqUqpmckg0lOC95NK4b5ch7SbtSgiLqHlTlErfedxUpU0s7rIVeUPBc6vZ2FGXxGpA+v2dmL9V3wem1kdRMSQGr7Tnv7MzPqs3KzsMVItr31Ir5u9ub3LiYhnSbXN2/u9lmqg9Sq9pkBD0nnAVsBgSeNJfTCcrdR7rEhVgU5rZTEfUurHYA6pFKy1zuuGkaoijya1cfwp8KeaN8LMrIdQ6sNmKqnz0f0bnBwzMzOz7mQ9UtOYoaSms59yE67O0auanJiZmZmZmZlZ39CbOwU1s25M0khJ10uaIukMSUu85lLSbyS9JOn8QtgwSffkTpn27dpUm5mZmZlZd9ErmpyssMIKMW7cuEYnw6zXu//++2dExKg6Le4IUq/Ml0j6DbAzS7Yt/AGpB+diwcXbpPeIf7W9K3Re0bO8+OKLjB5d/lKRzv+udVyd84ou57zCrGv09LwCYODAgbHxxm1+h4CZ1ahaftErCjTGjRvH1KlTG50Ms15P0rN1XNz2pFeKQnp39vaUFWhExAv57SzFsAWkVwS3e4XOK3qW4447jmOOOabLv2sdV+e8oss5rzDrGj09rwBYf/31nV+YdYFq+YWbnJhZo4wkvZub/DmyM1Yi6UBJUyVNnT59emeswszMzPqoQYMGNToJZn1ar6ihYWbdk6T+wF0VZt0AzAaGkwozhgOzOiMNEXEucC7A+PHj3QuymZmZ1c3s2bMbnQSzPs0FGmbWaSJiIfCBSvMkLQPsBlyWP6/pwqSZmZmZddirr77a6CSY9WlucmJmjXIqsI+kKcB84FYASadLGpXHTwB+Cuwq6TZJQ3P4dcB+wPcknd2Q1JuZmZmZWUN1Sg0NSROBA4EADo6IfxbmDQEuAMYAzwEHRMRcSeOA3wCDgRsi4qTOSJuZdQ8RMRPYvUL4twrjRwNHV4izR6cmzszMzMzMur26F2hIWg44hFTNfFXgEmCbQpSJwKMRsY+kH+bps4GTgWMiYkp+EntNRDzalnXuNKtTmt6bmZlZH/StadPgsMNAWnzo12/Jz+JQCuvfv/owYMDiw8CBS04PHAiDBjWPl6bLhwFuOWzWcPPnNzoFZn1aZ/wTbgFMiYh5wNOShkkaHBHv5Pnbk6qaQ3pV4xGkAo1NImJKDr8hx6taoCHpQFItEN6U4D//gQ03rP/WmJmZWZ+y76uvwk9/2uhktK5fv+bCjcGDlxyGDGn+HDIEllqqebw4vdRSaVh66ebx0nSlYciQtG4zgwULGp0Csz6tMwo0lie9vaCkifQ6xpcqzC/Ng8X782gCVm5pJcU3FyAFH/84/OMfMGJEzQk3MzMzO2jddTnn7LMhIg2LFi05XvwsHxYubHlYsGDJYf789DlvXhovDcXpefMqD++8k4a5c+G119L4vHmdu5OWWgqGDq08LLNM81A+XRqGDVtyGDw41XIx60HWgpQX+Ng1a4jOKNCYBYwoTJe/jrE4vzhvUQvfadHVK6zAp554AvbdF/78Zz81MDMzs5rdP2wYfOhDjU5GxyxalAo15s5tLuwoH95+O32+9VYaLw5vvdUcXhp/880lx19/HV56qT4FKAMGpIKNZZdNQ3G8OAwf3vxZPj5iRKpBYn2apHWBh4EPRcSdhfCPAycBa0TEkEL48aTOxh+PiB3bs64BCxfCc8/B2LH1SbyZtUtnFGjcC5wgaSCwCvBGobkJwB2kVzQ+kD/vyOEPStoqIu4GdgW+1dYVnrb66nxq7bXhhhvg+OPhmGPqsBlmZmZmPVS/fs1NS7rC/PnNBR1vvNH8WT7MmdP8WW14/XV4/vlUm6UWgwalgo1SAUfpc8QIWG656uMjR6bPgQPrs0+skX5A8z1G0WRgU+A/ZeFnAb+lVPu7HWYCTJ3qAg2zBql7gUZEzJZ0FikTCeBQSZsAO0XET4ALgd/kVzU+D+yfv3okcIGkQcBNEfFIW9e5oF8/uPpq2HxzOPbY9PnRj9Zvo8zMzMysuoEDm2tJ1ENEqh1SKuAoDq+9lobieGm6qSmNNzXBiy/C44+3f91Dhy5ewDFy5JLD8ssvPr788qkZjjWcpC2Bl4ElSsTyG9ZQWfOQiHgpv3Gx3WYA3H8/fPKTtXzdzDqoU7rHjojfkF7BWvRAnvc28LkK33kKqL1+56qrwu9/DzvskJqe/OMfsM46NS/OzMzMzBpEau6EdKWVal/O/PmpoGP27FTIURqK07NnNw+zZjWP/+c/qelOWw0Z0ly4URpWWKF5KJ9eYYVUeOK+F+rt+6QHpp3Ws2/x5QTLQCrQMLOG6F3v+9p2W/jZz+CQQ+ATn4B77kkdT5mZmZlZ3zNwYHPhQnstWpRqiJQKOsqHmTObP4tDewpChgxJBRujRi35ueKK6bM4PmKEC0BaIGl3YGpEzCyvhVFPxZcTDOvXL7j/fncMatYgvatAA+Cb34T77oNLL4Uvfxkuv9yZi5mZmZm1T79+zc1oxo1r+/cWLUrNXkoFHDNmpKE4Pn16mp4+PQ0PPJBuiFszcGAq8FhppVTIseKKS46XhhVX7Iv9gWwCTJC0FfA+4D2S9o6IZzttjf36pd/y2Wfbd5yYWV30vgINCc45J5WOX3klbLEFfPvbjU6VmZmZmfUF/fqlvjeWWw7WXrtt31m4MNX2KBV2TJ8Or75a+fOVV+DBB9tWADJyZHMBx8orVx9WWAH69+/YdncDEXEicCKApAuB84H1JW0XEZdI2hY4Bhgt6TbgrIi4RtI3gc/muLcBB0XEk21aaf/+6fe7/34XaJg1QO8r0IDU3vKaa1LnoIcfDptskvrWMDMzMzPrbvr3b25esv76rcdfuDDVCnjllVTQURpeeWXx4eWX4Ykn4JFW+trv1y/V6Fh5ZVhlleahOD16dPocPLg+29zJImJihbApwBKvZY2IM4Eza1nPOqutBk895Y5BzRqkdxZoAKyxBlxxBey6K3zmM+l1Si41NTMzM7Oern//5mYmrYlInZ++/PLiBR3F4aWXUvhDD6XmLy0ZObK5cGP06OZh1VWbP1deGQb03tuMon5Dh6YRdwxq1hC9O6f5yEfgxz+G734XPv5xuOuuVHvDzMzMzKwvkJqbwLRW+2PBgtSs5aWXmoeXX06vwH3ppfT54ovw6KOpeXdL61xppcULOcqH1Var73Y2yPSmplS4c+edqe+Uer262MzapHcXaEBqcvLPf6b+NL78Zfjd79xJqJmZmZlZuQEDmpuYtGTRotTfx4svwgsvpMKOF15IQynshRdSrYVeXnNh1uzZcPDB6SHqRRelty2aWZfp/QUaElxwQWo7ePnlqV+N73yn0akyMzMzM+uZSn1urLhi6quumnnzFi/sKB8mT+6yJHeqr34VTjkFfvWr9MbFfv0anSKzPqP3F2gADB0Kf/wjjB8PRxwBG28MOy7RH5CZ9XJj585Nr1UbPBiGDElN0AYNanSyzKyNJK0LPAx8KCLuLIR/HDgJWCMihhTCjwf2Ax6PCP/xm3W1QYNg7Ng0VNJbak2PGQN77pnuN267LTV7N7Mu0TcKNADWXDM1O9llF9h779RJ6BprNDpVZtaF/vDww0t2DjxgACyzDAwbljo6W3759Pq6FVdcvK3vGmvA6qv3mU7OzLqpHwB3VAifDGwKlDfqPwv4LXBuJ6fLzPq6b34zFWiceaYLNMy6UN+6Mt9pJzj55FRLY6+94O67U+0NM+sTblluOXaeMAHeeQfefhveegvefDMNr7+eqr8uWlR9AQMGpAKRddaBDTZIw3vfCxtu6LzErJNJ2hJ4GVhYPi8iZuY45eEvSRrXFekzsz7uQx9Kna5ef31q6t6W1++aWYf1rQINgMMOS52EXnEFHHBA6lejt1R3M7MWfX/NNdn5mmuqR1i0KL3absaM5l7dX3gBpk2Dp5+GJ59M75p/4gm46abm7/XrB+utl/ro2Xxz+OAHYdNN3ZzFrL6+D+wP/LQzFi7pQOBAgDFjxnTGKsysF1pvvfXSiARHHgn77Qc/+AFcfXVjE2bWR/S9Ag0Jzj8f/vvf1ARl003Ta13NzPr1S81ORo6EddetHCciFXA88gg8/HAa/vWv9Pq6Rx6BSy9N8YYMSf32bLcd7LADbLUVLLVU122LWS8iaXdgakTMLK+FUS8RcS65acr48eOjU1ZiZr3b5z+fOgf9wx9S8/bx4xudIrNer+8VaECqGn7ttfD+96eS1A02gD32aHSqzKwnkFLnX2PGwM47N4e/804q1LjvPrjnntSk7c4703DSSam2xlZbpX58dt89NVVx7TCzttoEmCBpK+B9wHsk7R0RzzY2WWbW173yyivNE/37wwknwMc/DkcfDTff3LiEmfURffedQmuskUpP+/dPpakPP9zoFJlZTzZ4cGpu8rWvwcUXp2YpL72UmrcdeGDqUHTSJPje9+B970t9cXzjG/DXv8KCBY1OvVm3FhEnRsQOEbEL8BfgMGB9SV8AkLStpNuA0ZJuk/SJHP5N4FJg0xy+VqO2wcx6p6ampsUD9twzPTS95Zb0H29mnaruBRqSRkq6XtIUSWeorG6opNUk3ZHn3yVpfA6fIOklSZPysHm907aE7bdP74t+4w342Mdg5sxOX6WZ9SErr5zeqnTOOamA46mnUp6z++4wfTqcdVZ6hfRKK8GXvpSe5Lhww6xFETExIu6MiJsj4pIcNiUidoyIpfPnNTn8zIjYJiKWz+FPNjb1ZtbrSXDqqWn8kENg/vzGpsesl+uMGhpHAFdGxLbAUGDnsvlzgE/n+V8Bfl6Yd0NETMjD/Z2QtiUdeGB6zdJTT8GnPuVMx8w6zxprwNe/nnpAnzkT/vSn1HnYokXw29/CrrumV8QeckhquhJuxm9mZtbjTJgAn/1s6rPvl79sdGrMerXOKNDYHrg+j1+Xp98VEa9FxKt58h2g+Dhy50LNjq7rPe/nP4cPfzhVBz/00C5brZn1YUstlWqGXXQRvPpqemvKF76QXiV7xhmw5ZbpdbA//3l664qZmZn1HKedBsssA8cem96aZmadojMKNEYCTXm8KU8vQVJ/4JfAiTnofmCdXHPjdVL72KokHShpqqSp06dP71iKBwyAq66CtdeGX/86DWbW6Vpropbj/CY3Rzu/ELazpL/n5ms3Slq+a1NeZwMHps5CL74YXnklvU56l13SW1O+/W0YPTo96bnzTtfaMDMz60b69atyO7XqqnDMMalp+ze/6f9vs05SU4GGpP75ZqJ8+AEwGxieow4HZlVZzDnATRFxG0BEzImIuXne74AW33MUEedGxPiIGD9q1KhaNmNxI0fCn/8Myy4LBx8Mf/tbx5dpZq1prYkawA+Az5WFPQJsHxGlGmHf6sxEdqmll06FFzfdBM88A8cdlwo0rrwStt02vWr6/PPh7bcbnVIzM7M+b5111qk+89BD0//2H/8Iv/991yXKrA+pqUAjIhZGxAcqDMcDdwC75ai75enFSDoNeCkiziyEDS9E2QF4rJa0dcj666cno4sWpf40nnTfYWadrMUmagAR8UKFsOci4p08Wd50rfcYMwZ++MOUF113XXpN7IMPwle+AmPHwo9+5OYoZmZm3dXAgamPrAED0pvNOlqr3MyW0BlNTk4F9pE0BZgP3Aog6XRJo/JbTQ4Fts1vMykVV+6Tm5BMJhVonNQJaWvdbrulnolnzYI99oDyVzGZWT21qYlaNZJWAr4JVG0nVtfmaY3Svz989KPpLSiPPZYuit54I1VlHTMm1SqbNq3RqTQzM+tzXnrppZYjbLwxHHVUegDxta+56YlZndW9QCMiZkbE7hGxbUR8IyIW5fBvRcT0iJgaEQMLbzP5dJ5/Vm5Csl1EfCIimuqdtjb7zndg//1T+/VPf9pvPjHrgDo1Uau03GWBq4GvFjoaXkLdm6c12rrrwplnwnPPpeYoQ4em6bXWgq9+NTVTMTMzsy7x+uuvtx7p+9+HTTaBP/wBLryws5Nk1qd0Rg2Nnk+Cs89Or1y67bb09NOlqWY16WgTtUryW5D+CJwYEfd2Tsq7uRVWSM1Rnn0WfvELGDUKzjkH1lknvY76+ecbnUIzMzMDGDQILrssveHs4IPhiScanSKzXsMFGtUMGpRKUddZJ90knH56o1Nk1hu12EQtj58A/BTYVdJtkoYC3wA2Br6Xm659vzHJ7waWXhoOOST1s/GrX8HKK8N556W86/DDYebMRqfQzMzM1l8ffvYzePNN+PznYd68RqfIrFdwgUZLRo6EG25In9/5TnoLipnVTWtN1PL40RGxeUSsGhE7RsSbEXFaRKxQaLp2Ystr6gOGDIGvfx0efzxdMC2zDJx2Gqy5JpxyCsyd2/oyzMzMrPMcdBDsuSf84x/poYOZdZgLNFqzzjpwzTWpd+LPfx7+9a9Gp8jMrLohQ+D//g+eeir1sbFoEXzve+nJ0FVXufmcmZlZHQ0YMKDtkaX01pNx4+CXv4Srr+60dJn1FS7QaIvtt4dzz01VxPbYA15Y4i2SZmbdy7BhqY+Nxx+HL3859bWx996w3Xbw0EONTp2ZmVmvsNZaa7XvC8stB7//fWre/qUvpbeXmVnNXKDRVhMnwpFHpsKMj30sFW6YmXV3pT41/vUv+NCH4M47YbPN4Fvfgtdea3TqzMzM6k7SupLmS9qmLPzjkh6RNLcsfDNJd0m6W9LETk/g+PGpQ+85c2CvvaAtb0oxs4pcoNEeJ5wAn/oU/POfsO++sHBho1NkZtY2G28Mf/0rXHEFrLRSupBabz248ko3QzEzs97mB1R+c9pkYFOg/FVgZwD7AhOAQyQt19YVvVBrze2DDko1NB59FL7whdRE1MzazQUa7dGvH1x0Ebz//XDttamjUDOznkJKzU4efbT5DSif/WxqSvfcc41OnZmZWYdJ2hJ4mSULLUqdkZfXzhgMDI2IpyNiHjAF2KKt63vjjTdqTWh6O9kWW6QXD/zwh7Utx6yPc4FGey29NFx3HayxRnrC+fOfNzpFZmbtM2wYnHoq3H9/KqC94QZ473vhzDP9hMjMzHq67wMntyP+8kBTYboJGNnSFyQdKGmqpKnz589vdwLfNWRIevnA6NFw4olw6aW1L8usj3KBRi1WWgluuqn5da7uodjMeqKNNoJ77kkFsxFw8MHw4Q/DM880OmVmZmbtJml3YGpEzGzH12YBIwrTw3NYVRFxbkSMj4jxAwcObH9Ci1ZdNdXQWGopOOAAuPvuji3PrI9xgUat1lsP/vSn1EPxvvs68zGznql//9RB6H/+kzoNnTQJ3ve+1JGo+9YwM7OeZRNggqSbgZ2A0ySNbekLuQnKm5LGSBoIbAPc1+kpLdp8c7j4Ypg3L7184PHHu3T1Zj2ZCzQ6YpttUubzzjsp8/nf/xqdIjOz2owbB7fdBr/8Zerw+MADU98a06c3OmVmZmZtEhEnRsQOEbEL8BfgMGB9SV8AkLStpNuA0ZJuk/SJ/NVDgctJHYmeFRGz27rOQYMG1Sfxn/pUag46cybstpv/f83ayAUaHfWZz8BPfpIyn113hVdfbXSKzMxq069fanbywAOw5Zapb42NNoK//KXRKTMzM2uXiJgYEXdGxM0RcUkOmxIRO0bE0vnzmhw+NSK2joitIuI37VnPGmusUb9EH3YYfP3r8MQT6aHCm2/Wb9lmvZQLNOrhO9+Bb3wDnnoqZT5vvdXoFJmZ1W7ddWHKFPj+9+GVV+AjH0kXWfPmNTplZmZmvZeUakp+7GNw773pwWlHOh016wNcoFEPUnrjyR57wH33wec/n6psm5n1VAMHwgknwN/+BqutBj/9KWy3nV/vamZmVjBt2rT6LrB/f7jiitS0/cYb4ctf9hvIzFrgAo166d8fLr88vQLxT3+Cb37THeqZWc+3/fbw4IPw0Y+mp0WbbpousMwaQNK6kuZL2qYs/OOSHpE0tyx8M0l3Sbpb0sQuTayZ9QlvdUbN7KWWSm8+2XDD1F/f//2f7yvMqqh7gYakkZKulzRF0hmSVCHO05Im5eH7hfCj8oXH7ZLG1TttnW7oULj+elh7bTj7bDj++EanyMys40aOTAW1p5wCr70Gu+8ORx/tmmjWCD8gddpXbjKwKfB8WfgZwL7ABOAQSct1aurMzOplueXglltgjTVSM5Rjj210isy6pc6ooXEEcGVEbAsMBXauEGdhREzIw4kAkt4D7BARWwPHAid3Qto634orpsxnpZXgmGPg3HMbnSIzs47r1w+OOCI1QVllFTjxxNTMrqmp0SmzPkLSlsDLLFloQUTMzK9eLMYfDAyNiKcjYh4wBdiiSxJrZlYPo0enN5Ctsgr86Edw2mmNTpFZt9MZBRrbA9fn8evydDlJ+pukmyVtUvjeDQARMRnYuBPS1jXWXBNuugmGDYOvfQ2uvbbRKTIzq49tt4X774ettkr53BZbwH//2+hUWd/wfdr3sGN5oKkw3QSMrBZZ0oGSpkqaOt2vSzSz7mLNNVOhxgorwOGHw5lnNjpFZt1KZxRojKT5AqKJyhcPW0bEh4DvApfmsOWB4juf+7e0km5/4bHppqkgY8AA+Oxn0xsDzMx6g1VWSTU1DjoIHn88veL1uusanSrrxSTtDkyNiJnt+NosYERhengOqygizo2I8RExftSoUbUl1Mz6nCFDhnT+SjbYIL1CfcSI9Hp11wA3e1dNBRqS+kv6e4XhB6RCieE5asWLh4iYkT8fBN7KbVrLLzxabJzdIy48dtgBLr00verwYx+D//yn0SkyM6uPQYNSX0HnnANz58Kee8LPfuZOy6yzbAJMkHQzsBNwmqSxLX0hN0F5U9IYSQOBbYD7Oj2lZtanjB3bYlZUP5tsArfeCssumx4onHde16zXrJurqUAjIhZGxAcqDMeTOuvaLUfdjbLOuyQNljQkj69KKsRoyvF2zeFbAQ/WkrZu59OfTh35NDXBLrv4lYdm1rsceGB6arTccvCd78BXvwrz5zc6VdbLRMSJEbFDROwC/AU4DFhf0hcAJG0r6TZgtKTbJH0if/VQ4HLSNcZZETG70vLNzHqE978/FWoMG5b+f12oYcaATljmqcDFkr4GPATcCiDpdOBEYAjwJ0lvkpqVHBQRATwi6U5JdwHzgAM6IW2N8c1vwssvp070dt4Z7rwTll++0akyM6uPCRPg739Pr3Y991x48kn4wx9g+PBWv2rWXhExsULYFGDHCuFTga27IFlm1kc9++yzXbvCLbdMhRof+Ugq1FiwIPXZZ9ZH1b1AI7dv3b1C+LcKk5tV+e7xQO981+nxx6dCjQsugN12S537DBvW6FSZmdXHOuvAPffApz4Ff/0rbLdd6jR09OhGp8zMzKzTzJ07t/VI9faBD6TakTvvDF//emrefuihXZ8Os26gMzoFtUqk1N784x+H++6DvfZK7c7NzHqLkSPh5pvhc5+Dhx6CD34QHnmk0akyMzPrfbbcMj1AWG45+Na34Mc/bnSKzBrCBRpdacAAuOwy+PCH4fbb00X/ggWNTpWZWf0MGpQ6Qz7ssNRn0NZbw913NzpVZmZmvc/mm6e3jo0aBUcdBT/4gTvntj7HBRpdbciQ9DrXLbdMnwccAIsWNTpVZmb1068f/OQn8POfpw6Rd9opVY01MzOz+tp4Y5g8OTXxPOGE1PTE9xbWh7hAoxGWWQZuvBE23BAuvjhVE3Npqpn1Nt/6Vsrj3nkHdt89dRRqZmbWiyy99NKNTgK85z0wZQqsuSaccQbsv79rgVuf4QKNRhk5MvVQXMp4jj220Sky61KSRkq6XtIUSWdIUoU4v5H0kqTzC2HrSrpb0iRJd0nauGtTbu2y775wzTWp1sZnPgO//W2jU2RmZlY3q6++eqOTkKy5ZirUeO9708OET34S3n670aky63Qu0GikVVZJbztZZRX40Y/g9NMbnSKzrnQEcGVEbAsMBXauEOcHwOfKwp4Cto6ICXn+0Z2ZSKuDj30s1Upbain40pfg179udIrMzMx6n9H/396dx+lcr38cf13GqBDCKFuk0ipCtohEQvteVKpzWlWUNvGrU0eLNiWdjtNOp7QXSlLZikoLKknSwqmTMEqFiev3x+c7x9A9ZnHf85175v18PL6P+W73Pdfc3b7d9/X9fK6rHkybFrqgvPxy6IKSnR13VCIppYRG3HbbLcwtr1kTBg7U3UspTzoDE6L18dH2Ztx9WYJ9f7j/b45WNWBeyiKU5OnaNVRjr149tJi77764IxIREdlmS5YsiTuEzdWqFW6Y9ugRRmx06gTL/vRxSqTMUEKjNNhvP3j11VBb4y9/gaeeijsikZJQE8iO1rOj7UIxs1ZmNgsYBUwu4NzzzGyOmc1Zvnx5MUOVpGjbNiRwa9SASy7RqDQREUl769evjzuEP6tSJYzQ6NsXPvlEbdSlTFNCo7Ro0wYmTIDttgsXnxdeiDsikW1mZhlmNjvBMhRYBVSPTq0OrCzs87r7B+7eHjgOGFnAuaPdvbW7t87KyirunyLJctBBYaTGTjuFUWl33RV3RCIiImVPpUrw2GNw5ZXw3XehjfqMGXFHJZJ0SmiUJp07h1auGRlwyilhzrlIGnP3De7eLsFyEzAN6BWd2ivaLpCZbZ9nMxv4LalBS+q1bAlvvhmGxV5xBYwaFXdEIiIiZU+FCjB8ONxzT6il0a0bjBsXd1QiSaWERmlz+OGhtaE7HH98mAMnUjYNB/qY2Qwgh2jqiJmNMLOsaP3vwJ1ATzObYmZVgMPMbLqZvQX8ExgQS/SybVq0CJ2eqleH/v3hoYfijkhERKRsuvRSeOaZkOA49dSQ5PhfOTKR9KaERml05JGhjsYff4TuANOnxx2RSNK5+wp37+3undz9YnffGO0f4O7Lo/Uh7t7K3eu7ezd3/9XdJ7r7Ie5+aLR8HOsfIsXXsiW89lqoH/TXv8ITT8QdkYiISJFUrVo17hAK54QTwpTP2rXh6qvhggsgJyfuqES2mRIapdUJJ4Qe0mvXQu/eMHt23BGJiCRf27abWrqeeSY8+GDcEYmIiBRa/fr14w6h8Dp0CN8pmjaF0aPDdwy1dZU0p4RGaXb66WEY9po1cMQR8OGHcUckIpJ8nTrB+PFQuXIYqTFoEGzYEHdUIiKSpsysqZnlmFnHLfbXNLMJZjbDzEaamUX7jzazd6P9feKJuoTsvjvMmgVduoTOYx06wFdfxR2VSLEpoVHanX023H8/rF4N3bvD3LlxRyQiknxdu8Lbb8Ouu8Kdd8Kxx1Jp3bq4oxIRkfQ0lMTFxq8Cxrl7J6AK0MPMKgC3A92ArkB/M6ue4LEJLV68OAnhlrCaNcOUz7PPDu1c27TRFHdJW0popIMLL4S774aVK8OHfiU1RKQsOuAAeO89aN8eJkzgvH/+Ex55JEy9ExERKQQzawv8ACxNcLgzMCFaHx9t1waWu/sv7p4DfAG0Lezv++OPP7Yt4LhUqhRGgg8fHr5jdOumAt2SlpKe0MhvKNcWx6fmWXLMbCcza2xmq/Ls753s2NLagAFw112bkhoffxx3RCIiybfzzqGl67nnUmvlSjjnHGjYEIYMgWXL4o5ORERKv+uAW/M5VpPQ8p3oZ01gOVDbzOqbWTWgY7Q/X2Z2npnNMbM5OelcWNMMrrwSXnwxJDj+8pfwnSNdkzRSLqVihMafhnLlPejuK929i7t3ic59w91XRYc/yD3m7hNTEFt6GzhwU1LjsMPgo4/ijkhEJPm23x4efJBRF18cRqj99hsMGwaNG8Npp4WCZmo3JyIiW4huiM5x9xX5nLIKyJ1OUh1Y6e4OnAeMAZ4A5gP/2drvcffR7t7a3VtnZmYmJ/g4HX10qKvRuDHccw/07Bm+b4ikgVQkNBIN5cpPX2Bsnu3m0ciOx82sVgpiS38DB26aftKtm5IaIlJm/ZSVFWoILVsGd9wBDRqEltbt24fuKGPHwvr1cYcpIiKlRwugi5lNAroDd5hZozzHpwG9ovVe0TbuPt3duwKnA1WB8tdesFkzeP996NwZpkyBgw6C+fPjjkqkQKlIaCQayvUnZlYROBJ4Mdr1PdAkGtkxExi+tV+Sd6jX8uXLtz3qdDJgwKakhkZqiEhZV6MGXHEFfPklvPACHHpo+NB1xhnQqBH87W/w3//GHaWIiMTM3Ye5e1d3PwJ4HRgE7GNmZ0SnDAf6mNkMIAeYDGBmw83sLeB54Fp3L3S2vFq1akn9G2JVu3bofNK/f+h80r49PPts3FGJbFWxEhpmlmFmsxMsQ0kwlCufpzkcmOXuawDcfZ27/xIdGwu03loMeYd6ZWVlFefPSG8DBsCIEbBqlZIaIlI+ZGTAsceGGhvz5oW5vtnZcMMNoTvKmWfCBx/EHKSIiJQG7t7P3We6+yR3HxPtW+Huvd29k7tf7O4bo/1Xufuh7t7d3d8vyu+pW7duKsKPT2YmjBwZCoTm5MBJJ8G116qdupRaxUpouPsGd2+XYLmJfIZyJbDZdJMt2iN1BRYWJ7Zy5bLLwjy33KSGPsiLSHnRrBn861+wdCnccgvUqQNjxkDr1tCxI3t9/rnqbJRBZtY0KibecYv9CQuSm9nRZvZutL9PPFGLiKShc86BGTOgfn249dZQV+Onn+KOSuRPUjHlJL+hXCPMLCtarwq0IwwFy3WomX1oZtOASwhDxKQgl166KanRtSu8807cEYmIlJxateCaa2DJEnj6aTj4YHj7bU596ik44ogwTUXKkqEkvlHyp4LkZlYBuB3oRrhR0n+LmyciItts0aJFcYeQOm3ahBumhxwSpqK0bg1z5sQdlchmkp7Q2MpQrgHuvjxaX+PuTdz9jzyPe9HdW7p7Z3fv4e7fJju2MuvSS+GBB+Dnn+Hww2Hq1LgjEhEpWRUrhmGxM2fCu+/yXYMGMHky7L9/mJKybl3cEco2MrO2wA/A0gSHExUkrw0sd/df3D0H+AJoWxKxikj5sXHjxrhDSK2ddw5FQgcOhG++CTcOHnww7qhE/icVIzQkDuefD48+Cr//HoaETZoUd0QiIvFo04aHzzknTEmpUiUUDW3dGj78MO7IZNtcB9yaz7FEBcmXA7XNrL6ZVQM6kk+hcijnxcZFRLYmMxPuuit0GsvMhL/+Fc4+O7RVF4mZEhplyVlnwZNPwh9/hH7SL74Yd0QiIvGoUCEUDf38czjtNPjkkzB09vrr1eo1DZlZb2COu6/I55Q/FSR3dwfOA8YATwDzgf/k9zvKfbFxEZGCnHJK6DK2997hRmq7dvDFF3FHJeWcEhplzcknw3PPgRmceGLIpIqIlFdZWfDvf4e2czVrwo03QqtW8O67cUcmRdMC6GJmk4DuwB1m1ijP8YQFyd19urt3BU4HqgKzSyxiEZGyaJ99QlLj1FNh/vwwAvLpp+OOSsoxJTTKoqOPhvHjoVIlOP10eOSRuCMSEYnXCSfAp5+Gu0uffALt24f212vWxB2ZFIK7D3P3ru5+BKGg+CBgHzM7Izolv4Lkw83sLeB54Fp31/AcEUmqGjVqxB1CyataNdwsGDUq1Kg65RTo3x/Wro07MimHlNAoqw4/HF59NcwfP+eccMERESnPsrLCqLXx40MbunvugX33hZdeijsyKQJ37+fuM919kruPifblV5D8Knc/1N27u/v78UYuImXRzjvvHHcI8TCDiy4KHRabNAnfNTp0UHcxKXFKaJRlnTuHFks1aoSs6Y03gnvcUYmIxOvII8Nojf79YelSOPbYMLLt66/jjkxERCS9tGoVWruecAJ89BG0bBlq+omUECU0yrp27WDaNNhll1AMb8AAKOvtpUREClKtGowcCe+9Fz6MjR8f5gXfcIOqtouISKEtXLgw7hDiV6MGPPMM3HdfmIJy+umhMLf+fyolQAmN8uCAA2DmzDAc7N57QzeUnJy4oxIRiV/r1qFA6KhRsMMOocXrPvuED2Ya0SYiIlI4ZnDxxTB7Nuy5Jzz0UPh/7Lx5cUcmZZwSGuXF7ruHpEazZjB2LBx3nLKmIiIAGRlhHvAXX8AFF8B334WOUYccEkZwiIiISOEceGCYgnLWWbBgQWiZPmqUbhJIyiihUZ7UrRumn3ToABMnQo8ekJ0dd1QiIqVD7drwj3/Ahx9C164hCdy2LfTpA0uWxB2diIhIethxR3j00XATNTMz1Kw65hhYvjzuyKQMUkKjvNlpJ5g8GY44InxY79IFfvgh7qhEREqPFi1gyhR4+WXYa6/Qmm6vveDSS+HHH+OOTkREJD306QMffxxGaYwfH6bBT54cd1RSxiihUR5VqRLaFJ52GsydCwcfrBZLIiJ5mcFRR8H8+fDAA2H0xsiRoRbRddfBypVxRygiIqVAzZo14w6hdMud9j54MPz3v2GE+OWXw9q1cUcmZYQSGuVVpUphGFj//vDVV9C+fSiMJyIim2Rmwvnnw6JFcPPNULFi+LnbbqFz1KpVcUcoIiIxysrKijuE0i8zE4YNg7fegoYN4e67w6iN+fPjjkzKACU0yrMKFULXk1tvhZ9+gkMPDUOsRUqImdU0swlmNsPMRpqZJTjnYTP73sweTHDsUDNzM2tQMhFLuVWlClx7LXz9Nfzf/4V9N94IjRqFu06aFywiUi5t3Lgx7hDSR+fOYXT4qaeGZEbr1nDXXaDXULaBEhrlnRlcfXUYrfHHH6H7yQMPxB2VlB9XAePcvRNQBeiR4JyhwGlb7oySH5cDc1IaoUheNWqE1q5LlsCQIeEaesstIbExYAB8803cEYqISAlatGhR3CGkl512giefDN89dtgBrrgCunWDb7+NOzJJU0poSNCnD7z6KlStChdeGOaIq72SpF5nYEK0Pj7a3oy7L8vnsScBrwG/piY0ka2oWRNuuil8ABs2DCpXhnvuCXOFTz89dEoRERGRxPr0gXnzQoOCt96CZs1gzBh9/5AiS3pCw8yOM7MFZpZvpRczO8LMZkVLjzz7B5vZ22b2ppk1TnZsUoDDDoMZM6B+/TBHvF8/WL8+7qikbKsJZEfr2dF2gcwsE/gLMLoQ555nZnPMbM5yTQuQZKtePUw5+eabUDR0113DnadWreCQQ+C558LoNxEREdncrrvCG2/AnXfCunVw5plw4omaxilFkooRGtOBA4GliQ6aWQYwHOgZLcPNLMPM9ga6uvvBwA3ArSmITQpywAEwaxbstx88/jgceSSsXh13VJLGon/fsxMsQ4FVQPXo1OpAYVtHnAeMdfcCM27uPtrdW7t7axXukpSpUiUUWf7iCxg3Dtq1CwniE08MozZuvjlUdxcREZFNKlQIXU8++AAOPBCefz58D3nhhbgjkzSR9ISGu69w96314dkDWOLu2e6eDXwd7esMTIyeYzrQPNmxSSE1bBjaK3XuDK+/Htq6fv113FFJmnL3De7eLsFyEzAN6BWd2ivaLoz9gb5mNgk4ABhjZtsnP3qRIqpYEU4+OSSG3303TD/5/vswja9hw1AI7Y03VABNREQkr/32g9mzQ+HtlSvh+OPhjDPUTUwKFEcNjVqEu7K5sgnDzLfcn7G1J9Ew8hSrUQNeey1cSD79NLRWmjUr7qik7BkO9DGzGUAOMBnAzEaYWVa0/nfgTqCnmU0xsyrufqG7H+7uRwDzgDMKSKSKlLw2beCJJ+C778IIjXr1wuiNbt1gjz021eAQEZG0Vbt27bhDKDsqVQqFt2fPhn33DYVD998fJk6MOzIpxYqV0ChgCHlBVgI18mznDjPfcv+GrT2JhpGXgO22g8ceCwXvli8PbV2ffDLuqKQMiUZ09Xb3Tu5+sbtvjPYPcPfl0foQd2/l7vXdvZu7/7rFc3Rx94RT3ERKhZ13Di1fFy+GV16BE06ApUvDXahGjcK19eGHNb1PRCQN1apVK+4Qyp7WrcMUlKuugh9+CFPgzz5bozUkoWIlNAoYQl6QRcBuZlbNzKoBuwFfEoaa9wQwsw7A3OLEJklmFgrePfNMWD/99JA5VQViEZGiyciAnj3h2Wdh2bJQBK1FC5g6Fc49NyQ+jjsOnnoK1qyJO1oRESmEP1T4OTW23x5uuw3efhv22gsefTSM1pgwocCHSvmSii4nncxsClAvGh5+fLR/hJllufsG4FpCu8XXgGujBMkCYKaZvQ0MAwYnOzbZBieeCNOnwy67wA03hFZLazXCX0SkWLKyQhG0jz6C+fPDXaidd4YXX4TTTgvHjz02FGdeWdhauSIiAmBmTc0sx8w6brG/pplNMLMZZjbSzCza3y+ayj7LzO4oyu9avHhxMkOXLbVrF/5feeWVYbTGUUeFKfH6f6NEUlEUdEY0LLxy9PP5aH/eIeSvuHv7aHklz2NvcveD3f1Qd/8q2bHJNjrooFDk7oADwtSTrl1VtV9EZFvtv3+4C/X11/DOO3DZZVC7Nrz0Epx1FtSpA126wB13wIIFGiEnIlKwoSQuNH4VMM7dOwFVgB7R/huALu7eHmhtZvuUSJRSODvsAMOHh9Eae+8damvsu29ojS7lXhxFQSWd7bpr6IBy5JGhSOhBB4U5biIism3MoH17GDEiFAt9771Qe6NpU5g2Ldyd2ndfaNwYzjsvTF1ZsSLuqEVEShUzawv8ACSqr9UZyJ2zMD7aBvgc2NHMKgGVCE0LtvY7/tecICcnJylxSyHkjtYYPBh++imMID/xxDByQ8otJTSk6HbcMQyLvvLKUL2/Y8dQyV9ERJLDLCSMb74ZPvssFBS9917o0QN+/BH+9S846aQwNaVFCxg4EF54IRwTESnfrgNuzedYTTYlK7KjbYCxwEfAF8BMd/9+a78gb3OCzMzMbQ5YimD77UPDgvfeC///e+65kOx/5BGNYCynlNCQ4snICEO/chMZffvCoEGgwkgiIsnXpAlccglMmhSqvL/+ekgqt2oVanCMGAHHHx/qcDRtCv36wf33w5w5sH593NGLiJQIM+sNzHH3/IavrSJ0WCT6udLMdiRMOdkL2B3Y18zapDpW2UYtW4akxrBh8NtvcM45cPjh4QaAlCtKaMi2Of30MJ9t111Dxf5evVSkR0QklbbfHrp1C0nl998P005efjkUFj34YPjmm9By++KLwyiPqlXhwANDy7t77oEpU+D779PyTlZJFvoTkbTUAuhiZpOA7sAdZtYoz/FpQK9ovVe0vRFYD6yJmhesAnYq7C+sU6dOEsKWYsnMDNNP5s4NI8anTIFmzeD223WTtRypGHcAUga0bBk+VJ90UrhreNBBoZjd/vvHHZmISNlXo0ao+n7UUWF73Tr4+ONwXX7vvfBz3rywL6+ddgqjOfbcMyxNmoT6HI0aQb16YSRe6VNQob8xZvYwodDfJMJd1/3dfY2ZTTWzfaKuaiJSBrn7MEK3RMzsUeBBYB8zO8TdxwDDgcfN7EJgHjDZ3Tea2T+AWWaWAywCphT2d+60U6FzH5Iqe+0Vak2NHg1XXx0S/E8+GbZbt447OkkxJTQkOerUCVnRgQNh1KhQtOexx+CEE+KOTESkfNluO2jbNiy5fvsNPvkkJDU++ww+/TT8fPfdsGypQoXQprtePahbN3RdyV2qV4dq1cJSuXKoPr/DDuH3VqoUlhTIU+hvQ4LDnYHbovXcQn+T2FTobz0FFPozs/OA8wB23XXXpMUtIvFw934J9q0AeifYPxIYWZzfs17T+kqHChXgggtCcv+SS0JdqbZt4dJL4aabwmhFKZOU0JDkycyE++4LQ5svuihUHb7iCrjllnBMRETiUbkytGkTlrzWrIEvv4RFi0Lb2Nxl2bKwzJkTQ7D5ug44G7gzwbGCCv2tBZ7eWqE/dx8NjAZo3bp1+s3HEZFYLFmyJO4QJK/69eH550MDg/79Q42p554L31GOPjru6CQFlNCQ5Dv33DDd5KSTQl2N2bNh3LhwgRERkdKjatVQJb5Fi8TH160LnVN++mnT8vPPsHp1+Pn775uW9es3LS+/nNQw8xb6i8pjbCm30F82iQv9rQFeMrM27v5eUoMTEZHS59hjoWtXGDIkJDOOOSbsu/deaNgw7ugkiZTQkNRo2zb0ie7bN1Tlb9kS/v1vOOywuCMTEZHC2m678MGvqB/+EicdtkULQqG/DkAzYG8zO8Xdv4mO5xb6+3f083m2KPRnZkUq9CciImmuWrWQwOjbF84/P4zamDIFbrwxTEupqK/CZYG6nEjq1KoFEyeGi8by5aGV0rBhsHFj3JGJiEgacfdh7t7V3Y8AXgcGEQr9nRGdMhzoY2YzgBxCob9fgdxCf28Tam8UutCfiIiUEW3ahALZd90VOnxdfnkoFjp7dtyRSRIooSGpVaECDB0Kr70GNWuGYV9HHaXWriIiUizu3s/dZ7r7pKhrAe6+wt17u3snd7/Y3TdG+0e6ext3Pzh6XKKCoiIiUtZVrBiaFyxYAMcdF1q9dugQRm7oe0laU0JDSkb37mEKSvv28MoroXDoO+/EHZWIiIiISLHtsssucYcgRdGwYSgaOmFCaFU+enRo+/rwwxpFnqaU0JCS06BB6BE9cCB8+y0cckiYgrJBN8xEREREJP1Ur1497hCkOHr3Di3MhwwJRa7PPRc6dgztzSWtKKEhJSszM8xfGz8eatQIF5Fu3WDp0rgjExEREREpkrVr18YdghTXDjvATTfB/Pmh1t+sWdCqVSgYmp0dd3RSSEpoSDyOPBLmzQvtlKZOhebN4aWX4o5KRERERKTQvvnmm4JPktKtadPQlfHZZ6FevdDmtWlTTUNJE0poSHzq1YPJk+GWW2D16tAbun9/+P33uCMTEREREZHywgxOOAE+/xyuvTaM0Dj33FA49P33445OtiLpCQ0zO87MFphZwvFXZtbAzKaZ2Qwze9vMWkf7u5jZ92Y2NVpaJTs2KYUyMuCaa2DmzFCYZ9QoaNsWPvkk7shERERERKQ8qVIFbr45fBc54gh4993w3eSvf4Uff4w7OkkgFSM0pgMHAvkVRfgFOMndOwF/Be7Oc2yiu3eJlg9SEJuUVu3ahSI8p54a5rG1agW3366CoSIiIiIiUrKaNg2dGV98Mdx0ffDBsO+eeyAnJ+7oJI+kJzSiXvD5Vsdx99XunpveWgf8kedwj2jkxkgz2yHZsUkpV706/PvfMGZMKNJz1VXQpQssXhx3ZCIiIiIiUp6YwTHHwGefheKh69fDgAHQogVMmRJ3dBKJrYaGmWUA9wLDol0fAHtGIzd+BgYV8PjzzGyOmc1Zvnx5aoOVkmMGffuGYV7du4epKM2bwz//Ce5xRyciIiIi8j9169aNOwRJte23D50ZFy4Mo8k/+yx8Tzn2WN14LQWKldAwswwzm51gGVqEp/kn8Kq7TwFw91/yjOx4Ami9tQe7+2h3b+3urbOysorzZ0hp1qABvPYa3H9/SGRccAH06gXLlsUdmYiIiIgIANWqVYs7BCkpDRvCk0/C9Olw4IGhQ+O++8LVV8PPP8cdXblVrISGu29w93YJlpsK83gzuwP43t3vy7Ovep5TugILixOblCFmcOGFMHduqDA8aRI0awZjx2q0hoiIiIjE7rfffos7BClpnTqFziejR4cp88OHh/oaDz6o+n8xSEWXk05mNgWoZ2ZTzOz4aP8IM8uKuppcBnSKupk8Ez20TzSFZDohoXFzsmOTNLXHHiETeuut8OuvcMYZ0Ls3qO93WjOzmmY2IU/dHEtwzsNR96MH8+xrbGar8nRE6l2ykYuIiIgE3333XdwhSBwyMkLnk0WLYNAgWLkybLdqBW+9FXd05UoqioLOcPdu7l45+vl8tH+Auy939znunpmnm8lJ0fH7oykkh7j78e6enezYJI1lZIThXB9+GDqivPoq7Lcf3HuvMqHp6ypgXFQ3pwrQI8E5Q4HTEuz/IM81ZGIqgxQRERERSah69dCZ8bPPQgHRuXOha9dQX2PRorijKxdiKwoqUiz77RcKhd57b9i+7DLo2BE+/TTeuKQ4OgMTovXx0fZm3D2/oinNo5Edj5tZrVQFKCIiIiJSoD32CC1e33gjNDTIra8xcGAYvSEpo4SGpJ+MDLjkkpDE6NkTZs8OhXmuvx7WrYs7Oim8mkB2tJ4dbRfG90CTaGTHTGD41k5WRyQRERERKRFdu8IHH8BDD0Ht2jBiREh23H13aPsqSaeEhqSvRo1g4kR44okw3OvGG0Nf6DfeiDsyiRTQEWkVkFsMuDpQqPS1u69z91+izbGoI5KIiIiIlBYZGXDOOWHKydChsHYtXH55GLHx7LNqbpBkSmhIejOD00+HBQugb1/4/HPo1g1OPhmWLo07unKvgI5I04Be0am9ou0CqSOSiIiIlBb169ePOwQprapWDTdcv/gCzjoLvvoKTjoJDj4Y3nkn7ujKDCU0pGyoXRvGjIGpU2H//eGZZ2DvveG22zS8q/QaTuhuNAPIASbDpo5I0frfgTuBnlHXpCrAoWb2oZlNAy4BBsUTvoiIiJR3VatWjTsEKe0aNIBHHw3NDQ47DGbNCkmNE09U4dAkUEJDypbOncPF4u67oUIFuOYaOOAAeP31uCOTLbj7Cnfv7e6d3P1id98Y7R/g7suj9SHu3srd60ddk3519xfdvaW7d3b3Hu7+bbx/iYiIiJRXa9asiTsESRctWoTvJK+8EhodPPdcmIbSvz/8+GPc0aUtJTSk7MnMhAEDYOHCMA1l4UI4/PCQBV2yJO7oRERERCSFzKypmeWYWcct9tc0swlRp7SRZmbR/slmNjVafjezZoX9XcuW5deQTSQBs9DUYO7cUDi0Th0YNQp23z1MT1GCrMiU0JCyq27dMA1l+nRo1ixkQffeGwYNglWr4o5ORERERFJjKIlrc10FjIs6pVUBegC4++Hu3gU4DVjs7vNLKlApp/IWDr355jCy/PrrQ0eUBx6AnJy4I0wbSmhI2depU5iG8o9/QI0acOedIQt6991q8yoikkZK8q6riKQnM2sL/AAkqg7fGZgQrY+PtvM6DXgqddGJbKFyZbj2Wli8OIwwX7kSLrwwTEl5+mnYuDHuCEs9JTSkfKhYES64AL78EoYM2bx90jPPqH2SiEh60F1XESnIdcCt+RyrCWRH69nRdl59gCcK+gVmdp6ZzTGzOTm6ky7JULt2uNm6cCH06RO+s5xyCrRpo1qABVBCQ8qXHXeEm24K7ZP69Qs1NU4+OVQanj497uhERCQfuusqIgUxs97AHHdfkc8pq4Dc9u/VgZV5HrsP8Lu7F1hwzd1Hu3trd2+dmZm5rWGLbLLbbjB2LHz0Uai18cEHoRZgt27w/vtxR1cqKaEh5VODBvDII+Fi0a1baJ/UuTN0766+0CIipVNK77rmveO6fPnybQhTRGLUAuhiZpOA7sAdZtYoz/FpQK9ovRebj/g6g0KMzthSw4YNixepyNY0bx66oUydCu3bwxtvhNEaJ5wACxbEHV2pooSGlG/Nm8PkyWFp2xamTAmjNXr2hPfeizs6ERGhZO665r3jmpWVlYywRaSEufswd+/q7kcArwODgH3M7IzolOFAHzObAeQAkwGiujsnAk8X9XdWrlw5KbGLJNS5M7z9Nrz0Euy/Pzz/fPjZrx98/XXc0ZUKSmiImIWRGbNmwcSJ0KoVTJoUEhxHHRUKioqISJxaUMJ3XUUkvbl7P3ef6e6T3H1MtG+Fu/d2907ufrG7b4z2u7s33UrSNF8///xzskMX2ZwZHH00fPxx6ODYqBE89hg0bQr9+8P338cdYayU0BDJZQa9eoX5aS+9FEZvTJgQEhzHHKOpKCIiMYnjrquISGF8X86/TEoJysiAvn3h88/h/vtDIdFRo0L3xquughVFzseVCUpoiGwpNwv64Yfw3HNhWNfLL4epKB07hnW1UBIRiUVJ3XUVEREplSpVCq1dv/wSbr89tH69/fZQUPT66yE7O+4IS1TSExpmdpyZLTCztVs5Z0mevvDX5dk/2MzeNrM3zaxxsmMTKZIKFeD442HuXBg/Hjp1CnPYjjkm9IZ++GFYty7uKEVEREREpLypXBkGDYKvvoK//S3clL3xxpDYGDYMfvkl7ghLRCpGaEwHDiRxW7VcG9y9S7QMAzCzvYGu7n4wcAP5VzIXKVkVKsCRR4a2ru+8A8cdF3pEn3tuuGDcdhv89FPcUYqIiIiISHlTrRr83//BkiUweDDk5MCQIdCkSRi58dtvcUeYUklPaETDPvMdnRExM3vLzCaZWYtoX2dgYvQc04HmyY5NZJu1bx+qCy9YAH/9a5irds01oQ3sWWfB7NngHneUIiIiIiJSntSsGUZmfPUVXHEFrFkTamvsthvcfTf8/nvcEaZEXDU02rr7ocDVwNhoXy1C27VcGVt7AvWLl1jttReMHg3ffAM33AC1asHjj4eER6tW8OCD8OuvcUcpIiIiIinUqFGjgk8SKUl16sAdd4TExqWXwurVcPnloXjovffC2oLGHqSXYiU0zCzDzGYnWIYW5vHu/lP0cy7wm5ntROgZXyPPaRsKeA71i5f47bJLKL7z9dehgOhhh8FHH4XRG/Xrw2WXhRocIiIiIlLmbL/99nGHIJJY3bpwzz2weDFcfHEYWX7ZZSGxMXJkmUlsFCuh4e4b3L1dguWmgh5rZtuZ2fbRen1CEiOb0DO+Z7S/A6BvgZI+MjNDAdEpU0IrpQEDwv5774UWLeCAA8IctmXL4oxSRERERJJo9erVcYcgsnX168N994WuKBdeCMuXh5EbuSM20nwqSiq6nHQysylAPTObYmbHR/tHmFkWUAd4J+oV/wxwftRWbQEw08zeBoYBg5Mdm0iJ2GuvME/tP/+BRx6Brl3hk0/CHLaGDaF79zA9Zc2auCMVERERkW3www8/xB2CSOE0bAj33795YiN3xMaIEWmb2EhFUdAZ7t7N3StHP5+P9g9w9+Xu/p27t4x6xXdw97fyPPYmdz/Y3Q9196+SHZtIiapcGfr1gzfegG+/hVtvhX33DaM4zjoLdt4ZTjkFnnoqzG0TERERERFJpV133TyxsWIFDBwYiofeeWfa1QGMqyioSPnSoAFcfTXMnx9qbFx+eWix9PTTcNppkJUFPXrAP/6haSkiIiIiIpJauYmNxYuhf3/IzoZBg6BxY7jlFvj557gjLBQlNERKklmoqXHnnbB0KcycGS4cjRrB5Mlw0UUh+dG2Lfz976EN7B9/xB21iIiIiIiURQ0ahCKhS5aEOoC//gqDB4fExt/+BqtWFfQMsVJCQyQuGRlw8MGhWOgXX8Cnn4be0QcdBO+9B0OHhjawNWvCUUeFuhzz5sHGjXFHLiIiIiIiZUnduuH7xpIlcOWVsH493HBDuPE6eHCouVEKKaEhUhqYhfoagweHZMZ338FDD0GfPlClCkyYEKapNG8eam+cdFIY5TF9OvzyS9zRi4iIiJRLu+22W9whiCTXzjvD8OHwzTcwZEj4nnLLLWHExsCBpW56vBIaIqVRgwZwzjkwdmzolvLZZ6Hd0nHHhSkozz4bpqp07gzVq4dkyFlnheFis2crySEiIiJSAipVqhR3CCKpUasW3HRTaG4wbBjssEPohtKkCVxwAXxVOnp4VIw7ABEpgBnss09YLr4YNmwIbWDffx/mzAk/582DBQtCO9hcdetC06ahjWzTppuWxo1hu+1i+3NEREREyopVpby+gMg2q149jCK/7DIYPRruuAP++U948EE49VS45hrYf//YwlNCQyTdZGSEqSfNm8Nf/hL2rV0bkhpz5oTl889DXY5p08KypRo1wnCyvMsuu0CdOuFYjRrh4pX3p5IgIiIiIpv58ccf4w5BpGRUqRKmnFx0ETz6KNx2GzzxRFiOPhquvRbatSvxsJTQECkLtt8e2rQJS14rVsCiRSG58cUXsHBhqM/xww9hXtzChUX7HUlkZjWBx4HqwMfApe7uW5zzMNATmOjuf8mzvwdwFWHa3Hh3vyupwYmIiIiIyJ9ttx2cfz6cey6MGwc33wwvvxyWQw8NIza6dw+jzEuAEhoiZVmtWmFJlC11D7U2/vvfsPzwQ6henJ0Nq1eHn1uuf/55MqO7Chjn7mOixEUPYNIW5wwlJD365u4ws9rAJUBPd1+fzIBERERERKQQKlYMDQxOOw3Gjw+FQ996KywtW4bExvHHh9HlqQwjpc8uIqWXGVSrFpY99yz8Y5KnM3BbtD4+2t4soeHuy8xsy+B6AyuBly3Ec4W7f5rMwEREREREpBAqVIBjjgnTTqZODVNRXnsNTj4Z9tgjtIA988ykj/b+369PybOKiBSsJpAdrWdH24VRD9gDOBq4Ghi9tZPN7Dwzm2Nmc5aX0v7ZIiIiIiJpzSxMOZk0CT78EE45JXRCOf/80JTgllvCiO8kU0JDRFLGzDLMbHaCZSiwilA/g+jnykI+7UrgTXdf7+5zgTpbO9ndR7t7a3dvnZWVVey/RURERGRLu+++e9whiJQ+Bx4ITz0V6vVdcEFIZAweDA0bwqBBsHRp0n6VEhoikjLuvsHd2yVYbgKmAb2iU3tF24UxFWgJYGYNgdXJjltERESkMCpW1Ax+kXztsQf84x+hGcF114W6G3feCbvtBmedBfPnb/OvUEJDROIyHOhjZjOAHGAygJmNMLOsaP3vwJ1ATzObYmZV3H0hMNXMpgNPA5fFE76IiIiUdytWrIg7BJHSb+ed4e9/h2+/hbvvhnr14PHH4YADoGdPePPN0LCgGJTQEJFYuPsKd+/t7p3c/WJ33xjtH+Duy6P1Ie7eyt3ru3s3d/812j/c3Q9x9/bu/nacf4eIlBwza2pmOWbWcYv9Nc1sgpnNMLORFlUMNrPaZjbOzN40s8nxRC0iJa0krxU//fRTMkMXKdt23BEGDIAvv4SxY6F581Bz47DDoFUreOIJyMkp0lMqoSEiIiLpYiiJp6fltoHuBFQhtIEGGAHc6O5d3f3wkglRREoBXStESrPMzNDy9aOP4PXXoUePsN63LzRpAnfcAasLN6s86QkNMzvOzBaY2dp8jtc0s6l5lhwz28nMGpvZqjz7eyc7NhEREUlPZtYW+AFIVEmsMzAhWh8PdDazDGB/4Aozm2ZmF5VMpCISJ10rRNKIGXTrFkZpzJsX6mr897+h1WvDhnD55aH+xlakYoTGdOBAEl9EcPeV7t7F3bsQsqRvuPuq6PAHucfcfWIKYhMREZH0dB1waz7HErWBrgM0A+4BugOnm9k++T25WjyLlBkpvVbA5teLnCIOjxeRfDRrBo8+Cl9/DddcAxkZod7G7ruHFrD5SHpCI5oXn3B0RgJ9gbF5tptHc9oeN7NayY5NRERE0k80anOOu+dXfS9RG+hVwH/cfa67ryd0SGqW3+9Qi2eR9FcS1wrY/HqRmZmZnOBFJKhXD265Bb77DkaOhMaN4emn8z09thoaZlYROBJ4Mdr1PdAkmtM2k9ABYWuP150UERGR8qEF0MXMJhHuoN5hZo3yHP9TG+jo5spXUXtngFbAlyUUr4jEowUlfK3Yc889tzloEUmgalXo3x8WLoQXXsj3tGIlNMwsw8xmJ1iGFuFpDgdmufsaAHdf5+6/RMfGAq239mDdSRERESkf3H1YVKzvCOB1YBCwj5mdEZ2SsA00oa3zWDN7hzCt9cOSjl1ESk4c14oKFdRjQSSlMjLg2GPzPVyxOM/p7huAdsUMKVdfYEzuhplVd/fcUqZdgYXb+PwiIiJSxrh7vwT7VgB/Kibu7h8TigCKSDlTUtcKjRQXiVcqupx0MrMpQD0zm2Jmx0f7R5hZVrRelZAQeT3PQw81sw/NbBpwCSGjKiIiIiIiUiqtXLky7hBEyrVijdDYGnefAXRLsH9AnvU1QJMtjr/IpnoaIiIiIiIiIiL50qQvEREREREREUk7SmiIiIiIiIiISNpRQkNERERERERE0o65e9wxbDMz+wV1RSmq2sBPcQeRZvSaQSN3T9s+ybpWFJne80Wj12uTdL9WLAe+iTuOUkDv6dTRaxuk9bUC9NkixfTvJLXS7fVNeL1IelHQmCx099ZxB5FOzGyOXrOi0WtWJuhaUQR6zxeNXq+yI92/YCWL3tOpo9e2TNFnixTRv5PUKiuvr6aciIiIiIiIiEjaUUJDRERERERERNJOWUlojI47gDSk16zo9JqlP/03LBq9XkWj10vKGr2nU0evbdmh/5apo9c2tcrE61smioKKiIiIiIiISPlSVkZoiIiIiIiIiEg5ooSGiIiIiIiIiKQdJTREREREREREJO0ooSEiIiIiIiIiaSftExpm1s/M3jGzt82sZdzxlEZmVi16jaaa2XtmdpgFI81shplNMLOaccdZ2phZKzObbGZvmdlwvWbpTdeKguk9XzAze83MlpvZkGj7zOi6Ot3MnjKz7aL9jc3szej9NjjeqEXyp/d06iR4bbuY2ffR57GpZtYq2l8zusbOiK65Fm/kUlj6bJFaZtbUzHLMrGPcsZQl0ee7+8xslpm9b2anxR3TtkjrhIaZ7QRcCnQB+gL3xhpQ6bUGOMTduwCnArcCPYDK7t4JeBq4Kr7wSh8zq0R4nU5w90Pd/Sr0mqUtXSsKpvd8oZ0LXJlneybQ3t0PAb4lvL8gvJbXu/vBQFcz27tkwxQpNL2nU2fL1xZgort3iZYPon1XAeOia20VwrVXSjl9tigRQ4FpcQdRBu0H7Ofu7YGuwN9jjmebpHVCA2gDzHD39e6+BNgx906CbOLuG939j2izGjAP6AxMiPaNj7Zlk/aERNC/oztSndBrls50rSiY3vOF4O5Lt9j+yt03RJvrgNxrbQt3nxGtT0SvnZRSek+nzpavbaRHnpEYO0T7dK1NT/pskUJm1hb4AUj070i2zX+A9WaWCewIrIw5nm2S7gmNWsCqPNvZQLkfEp2ImdU3s5nAZOAFNn/tsoGdYgqttKoHNAf6AGcA/wJqo9csXelaUTC957dBdLf6CGBctCvv/1+z0ftN0oze0ynxAbBnNBLjZ2BQtL8m4TUFvbbpRJ8tUus6wsgwSb5VwCLgC+BjNEIjViuBGnm2q5PmGaZUcfdl7t6RkE2+j81fu+psfkGW8Pq84+4/u/sy4CcgA71m6UrXioLpPV9MZtYAeAw41d3XRrs35jlF7zdJK3pPp4a7/5Ln9XwCaB2tryK8pqDXNp3os0WKmFlvYI67r4g7ljKqO1Af2APYG7g5nUcXpXtC412go5llmtmuwBp3Xxd3UKXNFm/Qn4FfCPPRekX7eqH5aVt6F2hqZhXNbEegDvAces3Sla4VBdN7vhjMrDbhdbrA3RfnOTTXzDpE6z2B6SUenEgx6D2dOmZWPc9mV2BhtK7PZOlJny1SpwXQxcwmEb5832FmjeINqUwxYFU0vfAXoBLhJlZaMnePO4ZtYmbnAH8BHLjM3efEHFKpE1XRvhvYAFQEbgDeAkYCBxCSHGcqC7o5MzsDOB/IJAx5ewm9ZmlL14qC6T1fMDP7F9AB2A74hDC391jgy+iUMe7+kJk1AR4ifEh41d3TejinlF16T6dOgtd2MnAO8BthFNw57p5tZrWAx9lU5+wSd9+Y+FmlNNFni9Qzs0eBB919ZtyxlBVmlkG4nu9BuD6Ncfe0LWqb9gkNERERERERESl/0n3KiYiIiIiIiIiUQ0poiIiIiIiIiEjaUUJDRERERERERNKOEhoiIiIiIiIiknaU0BARERERERGRtKOEhoiIiIiIiIikHSU0REREREREpFQxs3fN7GMz+8zM/ojWPzazR8zsRjM7JYW/u5+ZZZvZOwWc1ziKab2Z7Z+qeCR/SmhISpmZm9k8M+uW5OedYmYrzax/Mp9XROKha4WIFIauFSLlh7u3dfcWQC8g291bRMvZ7v5/7j4uxSFMcfcOBcT4dRTjf1Ici+RDCQ0pCR3cfUoyn9DduwEvJ/M5RSR2ulaISGHoWiFSzpnZo7kJSDO7wcyeMrNXzOxLMxtnZgea2ZtmttjMbs/zuLpm9qyZvWdm881scCF/X2UzeyYaLTLXzJ5O1d8mRaOEhhSZme1tZt+ZWaNo+3oze6qQj33czM7Msz3KzC6K1m8zszFm9qqZfWNmD5lZl+iuyVIzuz41f5GIpIKuFSJSGLpWiEgStAJOA/YC9gZuBXoCBwBnmdme0XmPA/e6e5voMT3NrHshnr8HUM3d93X35sD5yf4DpHgqxh2ApB93/zzKZo4zs/8DTgcOKuTDWxEuMHm3H4vWWwKrgGOA7YAfgZ+Aw4FGwAfA37b5DxCREqFrhYgUhq4VIpIEr7n7agAzmwfMdfd1wDozWwjsbmb/AboAWWaW+7gdgX2A1wt4/rnAPmY2CpgKTEz6XyDFooSGFIu7jzGzw4AXgU7u/nNBjzGzKkAD4PNoO4NwAZkXnXIgcKC7r4+ObQBudPeN0UVnZdL/EBFJKV0rRKQwdK0QkW20Ns/6hgTbFQmzExw4yN1zivLk7v6Vme0HHEYY+XGzmTVz97UFPFRSTFNOpFjMrBKwH5AN7FzIhx0IzHf3jdF2C2CJu6+Nhpn+4u7fRceaA/Pc/ddouyXwYTJiF5GSo2uFiBSGrhUikmru/gswA7gmd5+ZNTSzXQp6rJk1ADa4+4vAQCALqJmiUKUIlNCQ4rqdMFSzO/BA9I+8IK2B7cysgpltBwwGPo6OtYyeL1crYE6e7S2Pi0h60LVCRApD1woRKQl9gH2jgqDzgXFAjUI8rhkwy8zmAu8Bt7i7OpuUAppyIkVmZscS5p+1je6C/A140swOdfc/tvLQVsB3hA8ba4C3gVPMrAmJP3hMzbPdErgrSX+CiJQAXStEpDB0rRCRrXH3r4HaW+zrl2f9hvyORdtd8qz/QCgeWtQYXgVeLerjJPXM3eOOQcowM3NgR3dfY2YLgOPc/fMkPfejwBx3vy8Zzyci8dG1QkQKQ9cKESkJZnYKcBvwH3fvsJXzGhNq/2QBXd19YYkEKP+jKSeSav8F3jazIwlzYpPyj9zMpgCdgV8LOldE0oKuFSJSGLpWiEjKufs4d2+8tWRGdN7X7t7C3esrmREPjdAQERERERERkbSjERoiIiIiIiIiknaU0BARERERERGRtKOEhoiIiIiIiIikHSU0RERERERERCTtKKEhIiIiIiIiImlHCQ0RERERERERSTtKaIiIiIiIiIhI2vl/H2xMgknWQnoAAAAASUVORK5CYII=\n",
-      "text/plain": [
-       "<Figure size 1080x504 with 8 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
     }
    ],
    "source": [
diff --git a/pybamm/models/full_battery_models/base_battery_model.py b/pybamm/models/full_battery_models/base_battery_model.py
index 99aa87de2c..457a3afba4 100644
--- a/pybamm/models/full_battery_models/base_battery_model.py
+++ b/pybamm/models/full_battery_models/base_battery_model.py
@@ -414,8 +414,8 @@ def default_var_pts(self):
             var.x_n: 20,
             var.x_s: 20,
             var.x_p: 20,
-            var.r_n: 30,
-            var.r_p: 30,
+            var.r_n: 20,
+            var.r_p: 20,
             var.y: 10,
             var.z: 10,
             var.R_n: 30,

From 0fa7865c37382fdcb3473ddf3e5a42b4450b0a4f Mon Sep 17 00:00:00 2001
From: Valentin Sulzer <valentinsulzer@hotmail.com>
Date: Thu, 4 Nov 2021 17:59:56 -0400
Subject: [PATCH 6/9] fix tests

---
 tests/integration/test_models/standard_output_tests.py        | 2 +-
 .../test_full_battery_models/test_base_battery_model.py       | 4 ++--
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/tests/integration/test_models/standard_output_tests.py b/tests/integration/test_models/standard_output_tests.py
index 9226c63272..0a9cc7b409 100644
--- a/tests/integration/test_models/standard_output_tests.py
+++ b/tests/integration/test_models/standard_output_tests.py
@@ -775,7 +775,7 @@ def __init__(self, model, param, disc, solution, operating_condition):
 
     def test_degradation_modes(self):
         """Test degradation modes are between 0 and 100%"""
-        np.testing.assert_array_less(-1.1e-3, self.LLI(self.t))
+        np.testing.assert_array_less(-3e-3, self.LLI(self.t))
         np.testing.assert_array_less(-1e-13, self.LAM_ne(self.t))
         np.testing.assert_array_less(-1e-13, self.LAM_pe(self.t))
         np.testing.assert_array_less(self.LLI(self.t), 100)
diff --git a/tests/unit/test_models/test_full_battery_models/test_base_battery_model.py b/tests/unit/test_models/test_full_battery_models/test_base_battery_model.py
index be19240854..ac7e735b75 100644
--- a/tests/unit/test_models/test_full_battery_models/test_base_battery_model.py
+++ b/tests/unit/test_models/test_full_battery_models/test_base_battery_model.py
@@ -124,8 +124,8 @@ def test_default_var_pts(self):
             var.x_n: 20,
             var.x_s: 20,
             var.x_p: 20,
-            var.r_n: 30,
-            var.r_p: 30,
+            var.r_n: 20,
+            var.r_p: 20,
             var.y: 10,
             var.z: 10,
             var.R_n: 30,

From d03808d79b4eda7777a758db955b70077129d5b1 Mon Sep 17 00:00:00 2001
From: Valentin Sulzer <valentinsulzer@hotmail.com>
Date: Fri, 5 Nov 2021 10:41:45 -0400
Subject: [PATCH 7/9] coverage

---
 pybamm/util.py | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/pybamm/util.py b/pybamm/util.py
index 84df34e45a..ba2053638b 100644
--- a/pybamm/util.py
+++ b/pybamm/util.py
@@ -276,9 +276,10 @@ def load_function(filename):
     # Strip absolute path to pybamm/input/example.py
     if "pybamm" in filename:
         root_path = filename[filename.rfind("pybamm") :]
-    elif os.getcwd() in filename:
-        root_path = filename.replace(os.getcwd(), "")
-        root_path = root_path[1:]
+    # Commenting not removing these lines in case we get problems later
+    # elif os.getcwd() in filename:
+    #     root_path = filename.replace(os.getcwd(), "")
+    #     root_path = root_path[1:]
     else:
         root_path = filename
 

From 310d9f7c7000ddc3e027caf9aeeb3ccc8479741e Mon Sep 17 00:00:00 2001
From: Valentin Sulzer <valentinsulzer@hotmail.com>
Date: Fri, 5 Nov 2021 10:50:44 -0400
Subject: [PATCH 8/9] revert parameter changes

---
 pybamm/parameters/parameter_values.py | 7 +------
 pybamm/util.py                        | 6 +++---
 2 files changed, 4 insertions(+), 9 deletions(-)

diff --git a/pybamm/parameters/parameter_values.py b/pybamm/parameters/parameter_values.py
index 1814e1a2a7..24d74e7bdb 100644
--- a/pybamm/parameters/parameter_values.py
+++ b/pybamm/parameters/parameter_values.py
@@ -206,12 +206,7 @@ def update_from_chemistry(self, chemistry):
                 )
             # Create path to component and load values
             component_path = os.path.join(
-                "pybamm",
-                "input",
-                "parameters",
-                base_chemistry,
-                component_group.replace(" ", "_") + "s",
-                component,
+                base_chemistry, component_group.replace(" ", "_") + "s", component
             )
             file_path = self.find_parameter(
                 os.path.join(component_path, "parameters.csv")
diff --git a/pybamm/util.py b/pybamm/util.py
index ba2053638b..cab5d995b3 100644
--- a/pybamm/util.py
+++ b/pybamm/util.py
@@ -277,9 +277,9 @@ def load_function(filename):
     if "pybamm" in filename:
         root_path = filename[filename.rfind("pybamm") :]
     # Commenting not removing these lines in case we get problems later
-    # elif os.getcwd() in filename:
-    #     root_path = filename.replace(os.getcwd(), "")
-    #     root_path = root_path[1:]
+    elif os.getcwd() in filename:
+        root_path = filename.replace(os.getcwd(), "")
+        root_path = root_path[1:]
     else:
         root_path = filename
 

From c67c3db788959bdc0d97f62f265786faa6190c87 Mon Sep 17 00:00:00 2001
From: Valentin Sulzer <valentinsulzer@hotmail.com>
Date: Sat, 6 Nov 2021 16:08:23 -0400
Subject: [PATCH 9/9] update changelog

---
 CHANGELOG.md | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 1ad7b2de27..1198b50d2d 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,8 @@
 # [Unreleased](https://github.com/pybamm-team/PyBaMM/)
 
+## Features
+
+-   Half-cell SPM and SPMe have been implemented (  [#1731](https://github.com/pybamm-team/PyBaMM/pull/1731))
 ## Bug fixes
 
 -   Fixed finite volume discretization in spherical polar coordinates ([#1782](https://github.com/pybamm-team/PyBaMM/pull/1782))