From 98d4d16e8639e18a6d43201abd8e118c5a0a2206 Mon Sep 17 00:00:00 2001 From: David Lilien Date: Tue, 5 May 2026 12:28:13 -0400 Subject: [PATCH 1/8] Allow solving of the SSA on extruded meshes --- src/icepack2/model/minimization.py | 19 ++++++++++++++----- 1 file changed, 14 insertions(+), 5 deletions(-) diff --git a/src/icepack2/model/minimization.py b/src/icepack2/model/minimization.py index 6746fcc..cf6b24f 100644 --- a/src/icepack2/model/minimization.py +++ b/src/icepack2/model/minimization.py @@ -4,20 +4,19 @@ conditional, Constant, inner, - tr, sym, - grad, div, dx, ds, dS, + dS_v, avg, jump, FacetNormal, min_value, ) from ..constants import ice_density as ρ_I, water_density as ρ_W, gravity as g - +from icepack.calculus import grad, trace as tr, get_mesh_axes def viscous_power(**kwargs): r"""Return the symbolic form of the viscous power dissipation rate""" @@ -30,7 +29,11 @@ def viscous_power(**kwargs): A, n = map(kwargs.get, parameter_names) mesh = ufl.domain.extract_unique_domain(M) - d = mesh.geometric_dimension() + axes = get_mesh_axes(mesh) + if axes in ["xy", "x"]: + d = mesh.geometric_dimension() + else: + d = mesh.geometric_dimension() - 1 M_2 = (inner(M, M) - tr(M) ** 2 / (d + 1)) / 2 M_n = conditional(eq(n, 1), M_2, M_2 ** ((n + 1) / 2)) @@ -79,7 +82,13 @@ def momentum_balance(**kwargs): mesh = ufl.domain.extract_unique_domain(u) ν = FacetNormal(mesh) - facet_balance = ρ_I * g * avg(h) * inner(jump(s, ν), avg(u)) * dS + axes = get_mesh_axes(mesh) + if axes in ["xy", "x"]: + facet_balance = ρ_I * g * avg(h) * inner(jump(s, ν), avg(u)) * dS + else: + facet_balance = ρ_I * g * avg(h) * inner(jump(s, ν)[0], avg(u)[0]) * dS_v + for dim in range(1, mesh.geometric_dimension() - 1): + facet_balance += ρ_I * g * avg(h) * inner(jump(s, ν)[dim], avg(u)[dim]) * dS_v return cell_balance + facet_balance From d173c8ef21b6a0ead9af8faa0a02d64208a350b5 Mon Sep 17 00:00:00 2001 From: David Lilien Date: Wed, 13 May 2026 10:06:03 -0400 Subject: [PATCH 2/8] Blatter-Pattyn runs, not yet tested --- src/icepack2/model/__init__.py | 28 +++-- src/icepack2/model/hybrid.py | 162 +++++++++++++++++++++++++++++ src/icepack2/model/minimization.py | 3 +- 3 files changed, 184 insertions(+), 9 deletions(-) create mode 100644 src/icepack2/model/hybrid.py diff --git a/src/icepack2/model/__init__.py b/src/icepack2/model/__init__.py index 4f11fc8..28412e5 100644 --- a/src/icepack2/model/__init__.py +++ b/src/icepack2/model/__init__.py @@ -1,9 +1,10 @@ import ufl from firedrake import ( - max_value, min_value, jump, inner, grad, dx, ds, dS, FacetNormal, Constant + max_value, min_value, jump, inner, dx, ds, dS, ds_v, dS_v, FacetNormal, Constant ) from irksome import Dt from . import variational, minimization, utilities +from icepack.calculus import grad, get_mesh_axes def mass_balance(**kwargs): @@ -16,13 +17,26 @@ def mass_balance(**kwargs): cell_balance = (Dt(h) * φ - inner(h * u, grad(φ)) - a * φ) * dx mesh = ufl.domain.extract_unique_domain(h) + axes = get_mesh_axes(mesh) ν = FacetNormal(mesh) - f = h * max_value(0, inner(u, ν)) - outflow = f * φ * ds - inflow = h_inflow * min_value(0, inner(u, ν)) * φ * ds - boundary_balance = inflow + outflow - - facet_balance = jump(f) * jump(φ) * dS + if axes in ["xy", "x"]: + f = h * max_value(0, inner(u, ν)) + outflow = f * φ * ds + inflow = h_inflow * min_value(0, inner(u, ν)) * φ * ds + boundary_balance = inflow + outflow + facet_balance = jump(f) * jump(φ) * dS + elif axes == ["xz"]: + f = h * max_value(0, u * ν[0]) + outflow = f * φ * ds_v + inflow = h_inflow * min_value(0, u * ν[0]) * φ * ds_v + boundary_balance = inflow + outflow + facet_balance = jump(f) * jump(φ) * dS_v + else: + f = h * max_value(0, u[0] * ν[0] + u[1] * ν[1]) + outflow = f * φ * ds_v + inflow = h_inflow * min_value(0, u[0] * ν[0] + u[1] * ν[1]) * φ * ds_v + boundary_balance = inflow + outflow + facet_balance = jump(f) * jump(φ) * dS_v return cell_balance + facet_balance + boundary_balance diff --git a/src/icepack2/model/hybrid.py b/src/icepack2/model/hybrid.py new file mode 100644 index 0000000..e947562 --- /dev/null +++ b/src/icepack2/model/hybrid.py @@ -0,0 +1,162 @@ +import ufl +from operator import itemgetter +from firedrake import ( + eq, + conditional, + Constant, + inner, + sqrt, + tr, + dx, + ds_b, + ds_v, + dS, + dS_v, + avg, + jump, + FacetNormal, + Identity, + SpatialCoordinate, + outer, + min_value, +) +from ..constants import ice_density as ρ_I, water_density as ρ_W, gravity as g +from icepack.utilities import add_kwarg_wrapper +from icepack.calculus import grad, sym_grad, get_mesh_axes + + +def horizontal_strain_rate(**kwargs): + r"""Calculate the horizontal strain rate with corrections for terrain- + following coordinates""" + u, h, s = itemgetter("velocity", "surface", "thickness")(kwargs) + mesh = h.function_space().mesh() + dim = mesh.geometric_dimension() + ζ = SpatialCoordinate(mesh)[dim - 1] + b = s - h + v = -((1 - ζ) * grad(b) + ζ * grad(s)) / h + du_dζ = u.dx(dim - 1) + return sym_grad(u) + 0.5 * (outer(du_dζ, v) + outer(v, du_dζ)) + +def vertical_strain_rate(**kwargs): + r"""Calculate the vertical strain rate with corrections for terrain- + following coordinates""" + u, h, s = itemgetter("velocity", "thickness", "surface")(kwargs) + # Get the mesh from the surface elevation because sometimes h is a diff + mesh = s.function_space().mesh() + du_dζ = u.dx(mesh.geometric_dimension() - 1) + return 0.5 * du_dζ / h + + +def C_operator_1storder(tensor, vector): + r"""Apply the script C operator to a tensor for Blatter-Pattyn approximation. + + The tensor shoud be 2x3.""" + return 1. / 2. * (tensor + tr(tensor) * Identity(tensor.geometric_dimension() - 1)), 1. / 2. * vector + + +def C_norm_1storder(tensor, vector): + r"""Compute the C-norm of a tensor for Blatter-Pattyn approximation. + + The tensor shoud be 2x3.""" + t, v = C_operator_1storder(tensor, vector) + return sqrt(inner(tensor, t) + inner(vector, v)) + + +def viscous_power(**kwargs): + r"""Return the symbolic form of the viscous power dissipation rate""" + # Get all the dynamical fields + field_names = ("membrane_stress_x", "membrane_stress_z", "thickness") + Mx, Mz, h = map(kwargs.get, field_names) + + # Get the parameters for the constitutive relation + parameter_names = ("flow_law_coefficient", "flow_law_exponent") + A, n = map(kwargs.get, parameter_names) + + mesh = ufl.domain.extract_unique_domain(h) + axes = get_mesh_axes(mesh) + d = mesh.geometric_dimension() + + M_2 = (inner(Mx, Mx) + inner(Mz, Mz) - tr(Mx) ** 2 / d) / 2 + M_n = conditional(eq(n, 1), M_2, M_2 ** ((n + 1) / 2)) + return 2 * h * A / (n + 1) * M_n * dx + + +def bed_friction_power(**kwargs): + r"""Return the symbolic form of the frictional power dissipation rate""" + τ = kwargs["basal_stress"] + parameter_names = ("sliding_coefficient", "sliding_exponent", "velocity") + K, m, u = map(kwargs.get, parameter_names) + τ_2 = inner(τ, τ) + τ_m = conditional(eq(m, 1), τ_2, τ_2 ** ((m + 1) / 2)) + return (K / (m + 1) * τ_m + inner(τ, u)) * ds_b + + +def momentum_balance(**kwargs): + r"""Return the symbolic form of the momentum balance constraint""" + field_names = ( + "velocity", "membrane_stress_x", "membrane_stress_z", "basal_stress", "thickness", "surface" + ) + u, Mx, Mz, τ, h, s = map(kwargs.get, field_names) + ε_x = horizontal_strain_rate(velocity=u, thickness=h, surface=s) + ε_z = vertical_strain_rate(velocity=u, thickness=h, surface=s) + f = kwargs.get("floating", Constant(1.0)) + cell_balance = (-h * (inner(Mx, ε_x) + inner(Mz, ε_z)) - inner(ρ_I * g * h * grad(s), u)) * dx + + mesh = ufl.domain.extract_unique_domain(u) + ν = FacetNormal(mesh) + axes = get_mesh_axes(mesh) + if axes in ["xy", "x"]: + facet_balance = ρ_I * g * avg(h) * inner(jump(s, ν), avg(u)) * dS + else: + facet_balance = ρ_I * g * avg(h) * inner(jump(s, ν)[0], avg(u)[0]) * dS_v + for dim in range(1, mesh.geometric_dimension() - 1): + facet_balance += ρ_I * g * avg(h) * inner(jump(s, ν)[dim], avg(u)[dim]) * dS_v + + return cell_balance - facet_balance + + +def calving_terminus(**kwargs): + r"""Return the symbolic form of the power dissipation at the terminus + of a glacier that flows into a water body""" + # Get all the dynamical fields and boundary conditions + u, h, s = map(kwargs.get, ("velocity", "thickness", "surface")) + outflow_ids = kwargs["outflow_ids"] + + # Get the unit outward normal vector to the terminus + mesh = ufl.domain.extract_unique_domain(s) + ν = FacetNormal(mesh) + + # Compute the forces per unit length at the terminus from the glacier + # and from the ocean (assuming that sea level is at z = 0) + f_I = 0.5 * ρ_I * g * h**2 + d = min_value(0, s - h) + f_W = 0.5 * ρ_W * g * d**2 + + return (f_I - f_W) * sum([inner(u[i], ν[i]) for i in range(mesh.geometric_dimension() - 1)]) * ds_v(outflow_ids) + + +class HybridModel: + r"""Class for the dual form of the Blatter-Pattyn approximation. + """ + def __init__( + self, + viscous_power=viscous_power, + bed_friction_power=bed_friction_power, + momentum_balance=momentum_balance, + calving_terminus=calving_terminus, + ): + self.viscous_power = add_kwarg_wrapper(viscous_power) + self.momentum_balance = add_kwarg_wrapper(momentum_balance) + + self.terms = [self.viscous_power, self.momentum_balance] + if calving_terminus is not None: + self.calving_terminus = add_kwarg_wrapper(calving_terminus) + self.terms.append(self.calving_terminus) + + if bed_friction_power is not None: + self.bed_friction_power = add_kwarg_wrapper(bed_friction_power) + self.terms.append(self.bed_friction_power) + + def action(self, **kwargs): + r"""Return the dual form of the Blatter-Pattyn approximation""" + return sum(term(**kwargs) for term in self.terms) \ No newline at end of file diff --git a/src/icepack2/model/minimization.py b/src/icepack2/model/minimization.py index cf6b24f..ccc19c2 100644 --- a/src/icepack2/model/minimization.py +++ b/src/icepack2/model/minimization.py @@ -5,7 +5,6 @@ Constant, inner, sym, - div, dx, ds, dS, @@ -16,7 +15,7 @@ min_value, ) from ..constants import ice_density as ρ_I, water_density as ρ_W, gravity as g -from icepack.calculus import grad, trace as tr, get_mesh_axes +from icepack.calculus import grad, div, trace as tr, get_mesh_axes def viscous_power(**kwargs): r"""Return the symbolic form of the viscous power dissipation rate""" From 9ad4fb4f988775d23e3c700e8e826c26e18456d6 Mon Sep 17 00:00:00 2001 From: David Lilien Date: Thu, 14 May 2026 17:06:36 -0400 Subject: [PATCH 3/8] No tau in the momentum balance now --- src/icepack2/model/hybrid.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/icepack2/model/hybrid.py b/src/icepack2/model/hybrid.py index e947562..1da85f9 100644 --- a/src/icepack2/model/hybrid.py +++ b/src/icepack2/model/hybrid.py @@ -94,9 +94,9 @@ def bed_friction_power(**kwargs): def momentum_balance(**kwargs): r"""Return the symbolic form of the momentum balance constraint""" field_names = ( - "velocity", "membrane_stress_x", "membrane_stress_z", "basal_stress", "thickness", "surface" + "velocity", "membrane_stress_x", "membrane_stress_z", "thickness", "surface" ) - u, Mx, Mz, τ, h, s = map(kwargs.get, field_names) + u, Mx, Mz, h, s = map(kwargs.get, field_names) ε_x = horizontal_strain_rate(velocity=u, thickness=h, surface=s) ε_z = vertical_strain_rate(velocity=u, thickness=h, surface=s) f = kwargs.get("floating", Constant(1.0)) From f74d3d422d393f404e63c58b33691bcc8ef92eb0 Mon Sep 17 00:00:00 2001 From: David Lilien Date: Tue, 19 May 2026 16:54:02 -0400 Subject: [PATCH 4/8] 2 checks passing Match Gibbous SSA Match primal flowline Still need to check Kangerd, but do not want to lose this! --- src/icepack2/model/__init__.py | 2 +- src/icepack2/model/hybrid.py | 26 +++++++++++++++----------- 2 files changed, 16 insertions(+), 12 deletions(-) diff --git a/src/icepack2/model/__init__.py b/src/icepack2/model/__init__.py index 28412e5..5933b8e 100644 --- a/src/icepack2/model/__init__.py +++ b/src/icepack2/model/__init__.py @@ -26,7 +26,7 @@ def mass_balance(**kwargs): inflow = h_inflow * min_value(0, inner(u, ν)) * φ * ds boundary_balance = inflow + outflow facet_balance = jump(f) * jump(φ) * dS - elif axes == ["xz"]: + elif axes in ["xz"]: f = h * max_value(0, u * ν[0]) outflow = f * φ * ds_v inflow = h_inflow * min_value(0, u * ν[0]) * φ * ds_v diff --git a/src/icepack2/model/hybrid.py b/src/icepack2/model/hybrid.py index 1da85f9..f2f9bfd 100644 --- a/src/icepack2/model/hybrid.py +++ b/src/icepack2/model/hybrid.py @@ -6,7 +6,6 @@ Constant, inner, sqrt, - tr, dx, ds_b, ds_v, @@ -22,14 +21,14 @@ ) from ..constants import ice_density as ρ_I, water_density as ρ_W, gravity as g from icepack.utilities import add_kwarg_wrapper -from icepack.calculus import grad, sym_grad, get_mesh_axes +from icepack.calculus import grad, sym_grad, get_mesh_axes, trace as tr def horizontal_strain_rate(**kwargs): r"""Calculate the horizontal strain rate with corrections for terrain- following coordinates""" - u, h, s = itemgetter("velocity", "surface", "thickness")(kwargs) - mesh = h.function_space().mesh() + u, h, s = itemgetter("velocity", "thickness", "surface")(kwargs) + mesh = s.function_space().mesh() dim = mesh.geometric_dimension() ζ = SpatialCoordinate(mesh)[dim - 1] b = s - h @@ -37,6 +36,7 @@ def horizontal_strain_rate(**kwargs): du_dζ = u.dx(dim - 1) return sym_grad(u) + 0.5 * (outer(du_dζ, v) + outer(v, du_dζ)) + def vertical_strain_rate(**kwargs): r"""Calculate the vertical strain rate with corrections for terrain- following coordinates""" @@ -51,7 +51,7 @@ def C_operator_1storder(tensor, vector): r"""Apply the script C operator to a tensor for Blatter-Pattyn approximation. The tensor shoud be 2x3.""" - return 1. / 2. * (tensor + tr(tensor) * Identity(tensor.geometric_dimension() - 1)), 1. / 2. * vector + return 2. * (tensor + tr(tensor) * Identity(tensor.function_space().mesh().geometric_dimension() - 1)), 2. * vector def C_norm_1storder(tensor, vector): @@ -76,7 +76,7 @@ def viscous_power(**kwargs): axes = get_mesh_axes(mesh) d = mesh.geometric_dimension() - M_2 = (inner(Mx, Mx) + inner(Mz, Mz) - tr(Mx) ** 2 / d) / 2 + M_2 = (inner(Mx, Mx) + inner(Mz, Mz) / 2 - tr(Mx) ** 2 / d) / 2 M_n = conditional(eq(n, 1), M_2, M_2 ** ((n + 1) / 2)) return 2 * h * A / (n + 1) * M_n * dx @@ -86,9 +86,10 @@ def bed_friction_power(**kwargs): τ = kwargs["basal_stress"] parameter_names = ("sliding_coefficient", "sliding_exponent", "velocity") K, m, u = map(kwargs.get, parameter_names) + f = kwargs.get("floating", Constant(1.0)) τ_2 = inner(τ, τ) τ_m = conditional(eq(m, 1), τ_2, τ_2 ** ((m + 1) / 2)) - return (K / (m + 1) * τ_m + inner(τ, u)) * ds_b + return (K / (m + 1) * τ_m + inner(f * τ, u)) * ds_b def momentum_balance(**kwargs): @@ -99,7 +100,6 @@ def momentum_balance(**kwargs): u, Mx, Mz, h, s = map(kwargs.get, field_names) ε_x = horizontal_strain_rate(velocity=u, thickness=h, surface=s) ε_z = vertical_strain_rate(velocity=u, thickness=h, surface=s) - f = kwargs.get("floating", Constant(1.0)) cell_balance = (-h * (inner(Mx, ε_x) + inner(Mz, ε_z)) - inner(ρ_I * g * h * grad(s), u)) * dx mesh = ufl.domain.extract_unique_domain(u) @@ -107,12 +107,14 @@ def momentum_balance(**kwargs): axes = get_mesh_axes(mesh) if axes in ["xy", "x"]: facet_balance = ρ_I * g * avg(h) * inner(jump(s, ν), avg(u)) * dS + elif axes in ["xz"]: + facet_balance = ρ_I * g * avg(h) * inner(jump(s, ν)[0], avg(u)) * dS_v else: facet_balance = ρ_I * g * avg(h) * inner(jump(s, ν)[0], avg(u)[0]) * dS_v for dim in range(1, mesh.geometric_dimension() - 1): facet_balance += ρ_I * g * avg(h) * inner(jump(s, ν)[dim], avg(u)[dim]) * dS_v - return cell_balance - facet_balance + return cell_balance + facet_balance def calving_terminus(**kwargs): @@ -131,8 +133,10 @@ def calving_terminus(**kwargs): f_I = 0.5 * ρ_I * g * h**2 d = min_value(0, s - h) f_W = 0.5 * ρ_W * g * d**2 - - return (f_I - f_W) * sum([inner(u[i], ν[i]) for i in range(mesh.geometric_dimension() - 1)]) * ds_v(outflow_ids) + if mesh.geometric_dimension() == 2: + return (f_I - f_W) * inner(u, ν[0]) * ds_v(outflow_ids) + else: + return (f_I - f_W) * sum([inner(u[i], ν[i]) for i in range(mesh.geometric_dimension() - 1)]) * ds_v(outflow_ids) class HybridModel: From bd37b03c4c7ee459aea4e9c16ad44161225bdf3b Mon Sep 17 00:00:00 2001 From: David Lilien Date: Tue, 16 Jun 2026 13:38:33 -0400 Subject: [PATCH 5/8] Use modern geometric_dimension wrapper --- src/icepack2/model/hybrid.py | 18 +++++++++--------- src/icepack2/model/minimization.py | 7 ++++--- src/icepack2/model/variational.py | 3 ++- 3 files changed, 15 insertions(+), 13 deletions(-) diff --git a/src/icepack2/model/hybrid.py b/src/icepack2/model/hybrid.py index f2f9bfd..913a1f8 100644 --- a/src/icepack2/model/hybrid.py +++ b/src/icepack2/model/hybrid.py @@ -20,7 +20,7 @@ min_value, ) from ..constants import ice_density as ρ_I, water_density as ρ_W, gravity as g -from icepack.utilities import add_kwarg_wrapper +from icepack.utilities import add_kwarg_wrapper, geometric_dimension from icepack.calculus import grad, sym_grad, get_mesh_axes, trace as tr @@ -29,7 +29,7 @@ def horizontal_strain_rate(**kwargs): following coordinates""" u, h, s = itemgetter("velocity", "thickness", "surface")(kwargs) mesh = s.function_space().mesh() - dim = mesh.geometric_dimension() + dim = geometric_dimension(mesh) ζ = SpatialCoordinate(mesh)[dim - 1] b = s - h v = -((1 - ζ) * grad(b) + ζ * grad(s)) / h @@ -43,7 +43,7 @@ def vertical_strain_rate(**kwargs): u, h, s = itemgetter("velocity", "thickness", "surface")(kwargs) # Get the mesh from the surface elevation because sometimes h is a diff mesh = s.function_space().mesh() - du_dζ = u.dx(mesh.geometric_dimension() - 1) + du_dζ = u.dx(geometric_dimension(mesh) - 1) return 0.5 * du_dζ / h @@ -51,7 +51,7 @@ def C_operator_1storder(tensor, vector): r"""Apply the script C operator to a tensor for Blatter-Pattyn approximation. The tensor shoud be 2x3.""" - return 2. * (tensor + tr(tensor) * Identity(tensor.function_space().mesh().geometric_dimension() - 1)), 2. * vector + return 2. * (tensor + tr(tensor) * Identity(geometric_dimension(tensor.function_space().mesh()) - 1)), 2. * vector def C_norm_1storder(tensor, vector): @@ -74,7 +74,7 @@ def viscous_power(**kwargs): mesh = ufl.domain.extract_unique_domain(h) axes = get_mesh_axes(mesh) - d = mesh.geometric_dimension() + d = geometric_dimension(mesh) M_2 = (inner(Mx, Mx) + inner(Mz, Mz) / 2 - tr(Mx) ** 2 / d) / 2 M_n = conditional(eq(n, 1), M_2, M_2 ** ((n + 1) / 2)) @@ -111,7 +111,7 @@ def momentum_balance(**kwargs): facet_balance = ρ_I * g * avg(h) * inner(jump(s, ν)[0], avg(u)) * dS_v else: facet_balance = ρ_I * g * avg(h) * inner(jump(s, ν)[0], avg(u)[0]) * dS_v - for dim in range(1, mesh.geometric_dimension() - 1): + for dim in range(1, geometric_dimension(mesh) - 1): facet_balance += ρ_I * g * avg(h) * inner(jump(s, ν)[dim], avg(u)[dim]) * dS_v return cell_balance + facet_balance @@ -133,10 +133,10 @@ def calving_terminus(**kwargs): f_I = 0.5 * ρ_I * g * h**2 d = min_value(0, s - h) f_W = 0.5 * ρ_W * g * d**2 - if mesh.geometric_dimension() == 2: + if geometric_dimension(mesh) == 2: return (f_I - f_W) * inner(u, ν[0]) * ds_v(outflow_ids) else: - return (f_I - f_W) * sum([inner(u[i], ν[i]) for i in range(mesh.geometric_dimension() - 1)]) * ds_v(outflow_ids) + return (f_I - f_W) * sum([inner(u[i], ν[i]) for i in range(geometric_dimension(mesh) - 1)]) * ds_v(outflow_ids) class HybridModel: @@ -163,4 +163,4 @@ def __init__( def action(self, **kwargs): r"""Return the dual form of the Blatter-Pattyn approximation""" - return sum(term(**kwargs) for term in self.terms) \ No newline at end of file + return sum(term(**kwargs) for term in self.terms) diff --git a/src/icepack2/model/minimization.py b/src/icepack2/model/minimization.py index ccc19c2..d5e4e09 100644 --- a/src/icepack2/model/minimization.py +++ b/src/icepack2/model/minimization.py @@ -16,6 +16,7 @@ ) from ..constants import ice_density as ρ_I, water_density as ρ_W, gravity as g from icepack.calculus import grad, div, trace as tr, get_mesh_axes +from icepack.utilities import geometric_dimension def viscous_power(**kwargs): r"""Return the symbolic form of the viscous power dissipation rate""" @@ -30,9 +31,9 @@ def viscous_power(**kwargs): mesh = ufl.domain.extract_unique_domain(M) axes = get_mesh_axes(mesh) if axes in ["xy", "x"]: - d = mesh.geometric_dimension() + d = geometric_dimension(mesh) else: - d = mesh.geometric_dimension() - 1 + d = geometric_dimension(mesh) - 1 M_2 = (inner(M, M) - tr(M) ** 2 / (d + 1)) / 2 M_n = conditional(eq(n, 1), M_2, M_2 ** ((n + 1) / 2)) @@ -86,7 +87,7 @@ def momentum_balance(**kwargs): facet_balance = ρ_I * g * avg(h) * inner(jump(s, ν), avg(u)) * dS else: facet_balance = ρ_I * g * avg(h) * inner(jump(s, ν)[0], avg(u)[0]) * dS_v - for dim in range(1, mesh.geometric_dimension() - 1): + for dim in range(1, geometric_dimension(mesh) - 1): facet_balance += ρ_I * g * avg(h) * inner(jump(s, ν)[dim], avg(u)[dim]) * dS_v return cell_balance + facet_balance diff --git a/src/icepack2/model/variational.py b/src/icepack2/model/variational.py index 599e23a..8d9ce0a 100644 --- a/src/icepack2/model/variational.py +++ b/src/icepack2/model/variational.py @@ -18,6 +18,7 @@ ) from . import utilities from ..constants import ice_density as ρ_I, water_density as ρ_W, gravity as g +from icepack.utilities import geometric_dimension def flow_law(**kwargs): @@ -29,7 +30,7 @@ def flow_law(**kwargs): A, n = map(kwargs.get, ("flow_law_coefficient", "flow_law_exponent")) mesh = ufl.domain.extract_unique_domain(u) - d = mesh.geometric_dimension() + d = geometric_dimension(mesh) ε = sym(grad(u)) M_2 = (inner(M, M) - tr(M) ** 2 / (d + 1)) / 2 From ff4d7a75912d87c0c2aab76f568330a943d7f98b Mon Sep 17 00:00:00 2001 From: David Lilien Date: Tue, 16 Jun 2026 16:17:10 -0400 Subject: [PATCH 6/8] Partial notebook demo of BP --- notebooks/rainier_hybrid.ipynb | 940 +++++++++++++++++++++++++++++++++ 1 file changed, 940 insertions(+) create mode 100644 notebooks/rainier_hybrid.ipynb diff --git a/notebooks/rainier_hybrid.ipynb b/notebooks/rainier_hybrid.ipynb new file mode 100644 index 0000000..4fdc7af --- /dev/null +++ b/notebooks/rainier_hybrid.ipynb @@ -0,0 +1,940 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 20, + "id": "2bbcb16d-d444-46d3-810a-ab79194a91eb", + "metadata": {}, + "outputs": [], + "source": [ + "from tqdm.notebook import trange\n", + "import numpy as np\n", + "from numpy import pi as π\n", + "import matplotlib.pyplot as plt\n", + "import firedrake\n", + "from firedrake import inner, dx, exp, min_value, max_value, Constant, derivative\n", + "import irksome\n", + "import icepack\n", + "from icepack2 import model\n", + "from icepack.calculus import grad" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "205d8e57", + "metadata": {}, + "outputs": [], + "source": [ + "def extract_surface(q_in):\n", + " mesh_x = q_in.ufl_domain()._base_mesh\n", + " shape = q_in.ufl_shape\n", + " if len(shape) == 0:\n", + " VLin = firedrake.FunctionSpace(q_in.ufl_domain(), \"CG\", 2, vfamily=\"CG\", vdegree=1)\n", + " q_targ = firedrake.Function(VLin).interpolate(q_in)\n", + " element_xz = q_targ.ufl_element()\n", + " if hasattr(element_xz, \"factor_elements\"):\n", + " element_x = element_xz.factor_elements[0]\n", + " else:\n", + " element_x = element_xz.sub_elements[0]\n", + " else:\n", + " VLin = firedrake.VectorFunctionSpace(q_in.ufl_domain(), \"CG\", 2, dim=shape[0], vfamily=\"CG\", vdegree=1)\n", + " q_targ = firedrake.Function(VLin).interpolate(q_in)\n", + " element_xz = q_targ.ufl_element()\n", + " if hasattr(element_xz, \"factor_elements\"):\n", + " element_hor = element_xz.factor_elements[0]\n", + " else:\n", + " element_hor = element_xz.sub_elements[0]\n", + " if hasattr(element_hor, \"factor_elements\"):\n", + " element_xy = element_hor.factor_elements[0]\n", + " else:\n", + " element_xy = element_hor.sub_elements[0]\n", + " element_x = firedrake.VectorElement(element_xy, dim=shape[0])\n", + "\n", + " Q_x = firedrake.FunctionSpace(mesh_x, element_x)\n", + " q_x = firedrake.Function(Q_x)\n", + " if len(shape) > 0:\n", + " q_x.dat.data[:] = q_targ.dat.data[1::2, :]\n", + " else:\n", + " q_x.dat.data[:] = q_targ.dat.data[1::2]\n", + " return q_x\n", + "\n", + "\n", + "def extract_bed(q_in):\n", + " mesh_x = q_in.ufl_domain()._base_mesh\n", + " shape = q_in.ufl_shape\n", + " if len(shape) == 0:\n", + " VLin = firedrake.FunctionSpace(q_in.ufl_domain(), \"CG\", 2, vfamily=\"CG\", vdegree=1)\n", + " q_targ = firedrake.Function(VLin).interpolate(q_in)\n", + " element_xz = q_targ.ufl_element()\n", + " if hasattr(element_xz, \"factor_elements\"):\n", + " element_x = element_xz.factor_elements[0]\n", + " else:\n", + " element_x = element_xz.sub_elements[0]\n", + " else:\n", + " VLin = firedrake.VectorFunctionSpace(q_in.ufl_domain(), \"CG\", 2, dim=shape[0], vfamily=\"CG\", vdegree=1)\n", + " q_targ = firedrake.Function(VLin).interpolate(q_in)\n", + " element_xz = q_targ.ufl_element()\n", + " if hasattr(element_xz, \"factor_elements\"):\n", + " element_xy = element_xz.factor_elements[0].sub_elements[0]\n", + " elif hasattr(element_xz.sub_elements[0], \"factor_elements\"):\n", + " element_xy = element_xz.sub_elements[0].factor_elements[0]\n", + " else:\n", + " element_xy = element_xz.sub_elements[0].sub_elements[0]\n", + " element_x = firedrake.VectorElement(element_xy, dim=shape[0])\n", + "\n", + " Q_x = firedrake.FunctionSpace(mesh_x, element_x)\n", + " q_x = firedrake.Function(Q_x)\n", + " if len(shape) > 0:\n", + " q_x.dat.data[:] = q_targ.dat.data[::2, :]\n", + " else:\n", + " q_x.dat.data[:] = q_targ.dat.data[::2]\n", + " return q_x" + ] + }, + { + "cell_type": "markdown", + "id": "3ed26c06-ea87-4688-9761-e98e5b26684d", + "metadata": {}, + "source": [ + "This notebook will demonstrate how to use the dual momentum balance model to simulate the evolution of a synthetic mountain glacier.\n", + "We'll start with a completely artificial initial glacier thickness, and then we'll spin it up to steady state.\n", + "The overall bed geometry is meant to mimic some of the features of Mt. Rainier in Washington State, but we'll produce a smaller glacier.\n", + "For many measurements, see [this volume](http://npshistory.com/publications/mora/glaciers-1963.pdf) from 1963, edited by Mark Meier and featuring many contributions by Austin Post.\n", + "\n", + "Mt. Rainier has a circumference of about 150km, which works out to a radius of about 25km.\n", + "We'll use a computational domain about half that size." + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "id": "f4ed4de3-bfb5-4f7f-bfba-52fc0e913f8c", + "metadata": {}, + "outputs": [], + "source": [ + "radius = Constant(12e3)\n", + "mesh2d = firedrake.UnitDiskMesh(4)\n", + "mesh2d.coordinates.dat.data[:] *= float(radius)\n", + "mesh = firedrake.ExtrudedMesh(mesh2d, layers=1)" + ] + }, + { + "cell_type": "markdown", + "id": "55e5e816-7f40-435e-aa22-78051037a76b", + "metadata": {}, + "source": [ + "Next, we'll create some function spaces.\n", + "We'll use continuous linear finite elements for the basal elevation and discontinuous linear elements for the thickness.\n", + "In general, solving the mass balance equation for ice thickness tends to work much better with discontinuous elements." + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "id": "94cbe500-16ff-4824-b873-d94427a23278", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/dlilien/sw/firedrake/venv-firedrake/lib/python3.14/site-packages/finat/ufl/elementlist.py:433: UserWarning: Discontinuous Lagrange element requested on triangle * interval, creating DQ element.\n", + " warnings.warn(\"Discontinuous Lagrange element requested on %s, creating DQ element.\" % cell.cellname)\n" + ] + } + ], + "source": [ + "cg1 = firedrake.FiniteElement(\"CG\", \"triangle\", 1)\n", + "S = firedrake.FunctionSpace(mesh, cg1, vfamily=\"R\", vdegree=0)\n", + "dg1 = firedrake.FiniteElement(\"DG\", \"triangle\", 1)\n", + "Q = firedrake.FunctionSpace(mesh, dg1, vfamily=\"R\", vdegree=0)" + ] + }, + { + "cell_type": "markdown", + "id": "c3d0b834-dbca-4b2b-9533-44125ce72c71", + "metadata": {}, + "source": [ + "Mt. Rainier is about 4km high.\n", + "We'll use a bed topography of the form $B\\exp(-|x|^2/r^2)$, although this is actually a little unrealistic." + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "id": "58d11b38-22fb-4db3-bcf9-f989817715c2", + "metadata": {}, + "outputs": [], + "source": [ + "x = firedrake.SpatialCoordinate(mesh)\n", + "\n", + "B = Constant(4e3)\n", + "r_b = Constant(150e3 / (2 * π))\n", + "expr = B * exp(-(x[0]**2 + x[1]**2) / r_b**2)\n", + "b = firedrake.Function(S).interpolate(expr)" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "id": "24945f29-c8d5-4a0e-84f0-9253dd1d2067", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots()\n", + "ax.set_aspect(\"equal\")\n", + "ax.set_title(\"Bed elevation\")\n", + "colors = firedrake.tripcolor(extract_bed(b), axes=ax)\n", + "firedrake.tricontour(extract_bed(b), levels=[1600.0, 2100.0], colors=\"black\", axes=ax)\n", + "fig.colorbar(colors);" + ] + }, + { + "cell_type": "markdown", + "id": "799ff14c-f764-46eb-842c-8034f6c7476f", + "metadata": {}, + "source": [ + "According to Meier and Post, at 1600m elevation, the surface mass balance is about -8.7 m/yr of water equivalent, and the equilibrium line altitude (where surface mass balance is zero) is at about 2100m elevation, and that the SMB must average about 0.7 m/yr above the ELA for the glacier to be in balance.\n", + "We'll use these as rough guidelines; trying to be too exact about it gives an accumulation field with a really dramatic change near the ELA that results in generalized numerical mayhem.\n", + "When we define the SMB field, we clamp the values at the top and bottom in order to avoid producing unrealistic values.\n", + "Not also how we have to convert one of the SMB values from meters of water equivalent to meters of ice equivalent by multiplying by 0.917." + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "id": "eaeced4e-119f-4e85-a038-f7ef03964648", + "metadata": {}, + "outputs": [], + "source": [ + "z_measured = Constant(1600.0)\n", + "a_measured = Constant(-0.917 * 8.7)\n", + "a_top = Constant(0.7)\n", + "z_top = Constant(4e3)\n", + "δa_δz = (a_top - a_measured) / (z_top - z_measured)\n", + "a_max = Constant(0.7)\n", + "\n", + "def smb(z):\n", + " return min_value(a_max, a_measured + δa_δz * (z - z_measured))" + ] + }, + { + "cell_type": "markdown", + "id": "cf4ccb68-c028-4a97-9479-caf99ea467b9", + "metadata": {}, + "source": [ + "We'll start with a very artificial initial guess for the thickness and evolve it toward equilibrium." + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "id": "e49e504f-ac00-4c7e-a055-ffe1cd84b054", + "metadata": {}, + "outputs": [], + "source": [ + "r_h = Constant(5e3)\n", + "H = Constant(100.0)\n", + "expr = H * max_value(0, 1 - inner(x, x) / r_h**2)\n", + "h = firedrake.Function(Q).interpolate(expr)\n", + "h_0 = h.copy(deepcopy=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "id": "16e78f35-2127-467b-91ff-abfa23addde1", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots()\n", + "ax.set_aspect(\"equal\")\n", + "colors = firedrake.tripcolor(extract_surface(h), axes=ax)\n", + "fig.colorbar(colors);" + ] + }, + { + "cell_type": "markdown", + "id": "ea593b0b-c5f1-4d2a-a70a-f8537ab35167", + "metadata": {}, + "source": [ + "We can then compute the initial surface elevation and mass balance." + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "id": "0641ac14-e8e1-496b-9ffd-e376c7ae3974", + "metadata": {}, + "outputs": [], + "source": [ + "s = firedrake.Function(Q).interpolate(b + h)\n", + "a = firedrake.Function(Q).interpolate(smb(s))" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "id": "4ec0e6ba-bff9-4493-88cc-cd9a88505224", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAh0AAAGdCAYAAAC2OMGiAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjksIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvJkbTWQAAAAlwSFlzAAAPYQAAD2EBqD+naQABAABJREFUeJzsvQm8JGV1Nn6qerl3FhYVAREUFwRcUVDccIkoJn5+MTGJO8QYt4gbrqgR1xD3JS5E4/pXAi6fS9SgBMWoICC4gAKigiA7AjMwM/d2d1X9f89zznnrrb49OMy9M31v93u06NvVVdXVVTX1PvWc5zwnq6qqkhQpUqRIkSJFim0c+bb+ghQpUqRIkSJFigQ6UqRIkSJFihTbLRLTkSJFihQpUqTYLpFAR4oUKVKkSJFiu0QCHSlSpEiRIkWK7RIJdKRIkSJFihQptksk0JEiRYoUKVKk2C6RQEeKFClSpEiRYrtEe/t8zcqPsizliiuukB122EGyLBv37qRIkSJFilsZ8MK86aabZI899pA833bP3HNzc9Lr9Ra9nW63K7OzszJJkUDHFgYAx1577bVtz0aKFClSpNjmcdlll8mee+65zQDHXe68Vq66plj0tnbffXe5+OKLJwp4JNCxhQGGwy/WHXfccVuekxQpUqRIsQ1i/fr1fHj0+/m2CDAcABwXn31n2XGHrWdT1t9Uyl0O/D23l0DHFIanVAA4EuhIkSJFipUb2yNFDsCxGNAxqZGYjhQpUqRIkWKJo6hKKarFrT+JkUBHihQpUqRIscRRSsVpMetPYiTQkSJFihQpUixxlPzf4tafxEgJpxQpUqRIkSLFdonEdKRIkSJFihRLHEVVcVrM+pMYCXSkSJEiRYoUSxxJ0zE6UnolRYoUKVKkSLFdIjEdKVKkSJEixTZgOopUvbIgEuhIkSJFihQpljhSemV0pPRKihQpUqRIkWK7RGI6UqRIkSJFiiWOVL0yOhLoSJEiRYoUKZY4YO21OHOwyYyUXkmRIgWjLEspisW3406RIkWKzUViOlKkmICY3zQv1195o1xz2bWy/o8b5IarbpTrr7qBr7/43/Nl5912EvTV7M31pDfXl+suv17KspJOp8X3mD/oK+BotVvSne1wKgaYl8kue95WurNdzsvyTP54xQ1yv0feS267+85ym9135uvandfIbnvfnu9XrZkd9yFJkWKsUSyyeqVIvVdSpEgxrhj0B3L5b66SP1x4hVx2weXy63N+J7/84QWyau2s3HD1Otl406ZbXP8Pv75ii78LQGPTzZjmwrybb9ywYLkrfnPVZreB/QLQmdswL/s/eB/Z96C7y1773VHutN8ecoe77S7dmc4W70+KFCsx0GF2cV1mZSIjMR0pUiyj2HjzJvndz38vf/j1lQQXl114uVx09m/luitukJX04APA4qDltK+exSkOsCH7HnQ32WvfPQhG9tx3D9n73nvJDjuvHdMep0ixtJE0HaMjgY4UKcYUVVXJpRdcLuf/+CK54Me/lvPPuEh+d+7vVxS42NpA2ufH3zibU4hMZO977SX7H3wPsiP7HbyP3Pmee0qeJ+lZihSTEgl0pEixnWL99TcRYJz/41/LBWf+Rn75owuYfkhhUYlcct5lnP77E6dwVndVV+710H1l/4P3kf0ffA/Z7+C7y8633ykdshTLPkrJpKCSauvXn8RIoCNFim2ow/jljy6Us076qZz29bPkDxdeSXYjxZZHb1NPfnrKuZw89rj77vKwv3ygHPT4+8u9H75f0oekWJZRVjotZv1JjAQ6UqRYwrj699fKmf/9U/nqB78lV192ncwnJmPJAwLWL77nvzhBkHr7O91O/uolT5AHPv4A2eNuuy/9F6ZIkWLJIoGOFCkWEfC1+NFXz5SzTvoZq0kuu3DLq0RSLD568325/KKr5EMv/kRgQe5zyH7ygEPvK4/4m4dIu5NucSnGE8Ui0yvFhKZXkkIrRYpbGUiRnPfD8+XfjvwPedqez5e3/u175aRPfDcBjmXCgnz7U6fKsc/4oDz1js+T97/gY/LzU3+ZTM9SjA10LGbamvjwhz8se++9t8zOzsrBBx8sZ5555i0uf+ONN8qLXvQiucMd7iAzMzNyj3vcQ771rW/Jtor0GJAixRbGhT/5rXzvP38o3/zYyUkAugJi3XU38Vxhmlndlcc/+8/kz55xCEWpWTaZT5EppjtOPPFEOeqoo+S4444j4Hj/+98vhx12mFx44YWy6667Lli+1+vJYx/7WH72pS99Se54xzvK73//e9l555232T5mVVK2bVGsX79edtppJ1m3bp3suOOO2+yEpFhe8ZufXSzf+cypcsY3z7lFM6wUKyd23/v2cvATDpTHHv5I2feBdx/37qSYsPu4f8cPz9tD1u6w9cmEm28q5eH3vuJW7SuAxgMf+ED50Ic+FFob7LXXXvLiF79YXvva1y5YHuDkXe96l1xwwQXS6Wwfw77EdKRIMaLq5If/7wz5xr+fTGo+xWTFVZdcK1/78EmcUP3yf57/ODnkyQfT5j1FiuWm6Vi/fn1jPlIgmEaxFmeffbYcffTRYR48bg499FA5/fTTR37H17/+dXnIQx7C9MrXvvY1uf3tby9Pf/rT5TWveY20Wi3ZFpFAR4oUFlddco187FWflXNOOVc23LgxHZcpiPN+eAGnD/zTLHvJPP89R8ie+9xh3LuVIkUIMBVxHHPMMfKmN71JhuO6666jdmm33XZrzMd7MBmj4ne/+51897vflWc84xnUcfzmN7+Rf/qnf5J+v8/v2RaRQEeKqQ78Iz3jG+fIN/79O3L2d37OJmgppi823TQXHFIfcOh9yH485P8elKpfUmx1FJJz2vr1NS677LJGemUUy7G1gfQL9Bwf+9jHyGwceOCBcvnllzPlkkBHihRLGJs2zMl/f/wU+fQxJ3DASZHC45z/OZfT7JoZedYb/1ae8PzHypodV6cDlOJWRVVlUlbZotZHAHBsiaZjl112IXC4+uqrG/PxfvfdR/vXoGIFWo44lbL//vvLVVddxXRNt7v0KcdUMpti6qzIP/umL8gz9/4n+ehRn06AI8VmAxb1H3/N5+QZd36hfPL1x8v1V9+QjlaKZVsy2+12yVSccoq2EHAmA++h2xgVD3vYw5hSwXIev/71rwlGtgXgQCTQkWIq4prLrpOPvOxT8ne7/6P8f2/5oqz/403j3qUUKyQ2rNso/3nsV+Rpe75APvii/5ArL24+SaZIsVziqKOOko9//OPymc98Rs4//3x54QtfKBs2bJBnP/vZ/Pzwww9vCE3x+fXXXy8vfelLCTa++c1vyr/8y79QWLqtImk6Ukx0XPTT38mX3vsN+d8vnCaDvmdJU6S49VEWpfzXR79N34+H//WD5G+OeiI74qZIMSqKKue0tVFshbzsKU95ilx77bXyxje+kSmSAw44QE466aQgLr300ksbXZshUv32t78tL3/5y+W+970vfToAQFC9sq0i+XRsYSSfjpXHbHz2mC/Itz/9vXHvSooJjsc88xA54k1PkTvctVkxkGJ5xvb06fjmL+4qa3bY+rLTDTcV8oT7/m7ivKES05FiomLddevluFd+Vr5/4mnSn++Pe3dSTHic8rkf8Fp72F8fLC94zxGyyx63HfcupUixrCOBjhQTEZtu3sQ0yonv/KrMb+yNe3dSTFEgbQfgcdpXz5S/fcX/lb971f+VNTutGfdupRhzpIZvoyOBjhQrOopBwcqCb3/6VFl3bdO5L0WK7Rn9+YEc/y//T772kZNosf68dz5LOt3tYy2dYhI1HZVMYqTqlRQrNn7+/V/KCw98tXzhXV9PgCPFsgm42X71g/8tz7/fK+Un3/n5uHcnRYplFYnpSLHi4rrL/yjHPvOD8ovv/2rcu5IixWbjsguvkKMf/zbZ7+C7y9Gff6nscdfRBk0pJjNKyTgtZv1JjG3KdPzv//6vPPGJT5Q99tiDraS/+tWvNj5Hg1uU9sCIZNWqVWxMc9FFFzWWQQ0xfOGh3kW73ec85zly8803N5b5xS9+IYcccojMzs6yBOid73zngn354he/KPvttx+Xuc997kOf+RQrK/q9vpzwr1+Rv7/HSxLgSLFi4oIzfiP/eM+X0x9mftP8uHcnxXaK0mzQt3YqJzQRsU1/FUxJ7ne/+8mHP/zhkZ8DHHzwgx9ke90zzjhD1qxZI4cddpjMzdW21AAcv/zlL+Xkk0+Wb3zjGwQyz3ve8xrlSY973OPkzne+MzvswTMezXDgJe9x2mmnydOe9jQClp/+9KfypCc9idN55523LX9+iiWMkz//v/L3+7xEPvG642V+UxKKplhZ0e8N6IR7+N1fJN/8+P+Me3dSpBhbbDefDjAdX/nKVzjYI/C1YEBe8YpXyCtf+UrOQz0yTEw+/elPy1Of+lQ6qt3znveUs846Sw466CAuA6OTv/iLv5A//OEPXP+jH/2ovP71r6cRitu2vva1ryWr4p31YJgCAATQ4vHgBz+YxikAPFsSyadjPLFh3QY57qjPyEmfSn4bKSYnHvOMQ+Sf3v9s2fF2O4x7V6YqtqdPxwk/u6esXoRPx8abCnnqAb+aOJ+OsfE3F198MYECUioeOFEHH3ywnH766XyPV6RUHHAgsDwc1cCM+DKPeMQjGj7xYEsuvPBCueGGG8Iy8ff4Mv49o2J+fp4XTzyl2L7xjY+dLEfc48UJcKSYuDjl8z9gmvDL768fhFJMViA9sthpEmNsvwqAA+H2rB5475/hFW1342i323Lb2962scyobcTfsbll/PNRceyxxxIE+QStSIrtE+iLcuwzPyAfeMHHZN21qUdKismMm264mSzeW/723XL9VamZ3KRFUWWLniYxJhNKLUGgKQ5oLZ8uu+yyce/SVMRXPvgtefZ+L5HvHv/Dce9KihTbJX7w5TN4zZ/wzqbQPkWKSYyxlczuvruWj1199dWsXvHAe2gtfJlrrrmmsd5gMGBFi6+PV6wTh7//U8v456NiZmaGU4rtE5s2zMlHXvLJlEpJMZWxcf2cfOK1n5dLzr1UXvyh5yRH0wkIr0LZ+vUrmcQYG9Nxl7vchYP+KaecEuZBNwGtxkMe8hC+x+uNN97IqhSP7373u1KWJbUfvgwqWvr9us8GKl323Xdfuc1tbhOWib/Hl/HvSTHe+MnJv5B/vNfLE+BIMfUBrcdz7vky+dHXz5r6Y7HSo6zyRU+TGNv0V8FP42c/+xknF4/ib7TXRTXLy172Mnnb294mX//61+Xcc8+Vww8/nBUpXuGy//77y+Mf/3h57nOfK2eeeab86Ec/kiOPPJKVLVgO8fSnP50iUpTDorT2xBNPlA984ANy1FFHhf1Aq15UvbznPe9hRQtKan/yk59wWynGF6hg+sK7viav//O3yTWXXpdORYoUIvLHK2+UN//Vu+Rzb/2SFEWRjkmKiYptWjJ76qmnyqMf/egF84844giWxeKrjznmGHpqgNF4+MMfLh/5yEfkHve4R1gWqRSAg//6r/9i1cqTn/xkenusXbu2YQ72ohe9iKW1u+yyi7z4xS+W17zmNQvMwd7whjfIJZdcIvvssw89QlB6u6WRSmaXNq659Fp5y9++Vy486zdLvOUUKSYn7nbA3vKGE14me97jjuPelYmI7Vky+/FzDlx0yexzH3D2xJXMbjefjpUeCXQsXZz3owvkjX/5Trnp+lSZkiLFn4rVO66SY778KnnAY+6TDtYKAh3/fs6Bsmrt1ssmN908kOdPIOiYzKRRimUbcBR95aOPSYAjRYotjI3rN8lrHvsW+cjLPkV2OEWKlRyp4VuK7Vad8t7nHiennvCjdMRTpNjKcvJrLrtOXvXJf0rVLSsgFmvwVU4oJzCZvyrFsoqLzvmdvOD+r0qAI0WKRcaPvnKmPO9+r5Rfnn5hOpbLPIoqX/Q0iTGZvyrFsomffe88efkj/lmu+M3m3V9TpEix5YFKr1f92ZvlrJN+mg5bihUXCXSk2Gbxubd9SV572FtlfmPqCpsixVJGf74vr/uLf5FPHP35dGCXaZSSLXqaxEiajhRLHjBv+/irPydfeu9/paObIsU2jBPe8VXZeNMmdqxttbe+PDPF0sdiUyTFhKZXEuhIsaQxt3Ge7MYvf5RyzilSbI/4+ke+Leef8Wt51ylvkjU7rk4HfWJs0HOZxJjMX5VibN1hX/Vnb0qAI0WK7RwXnX2xHPWIN6ZutSmWfSTQkWJJ4g8XXSHPve9RcsGZyWE0RYpxxO9+8Xt53v1eIb/52e/SCVgGUVbZoqdJjAQ6Uiw6LvnlZfJyPGVdeWM6milSjDHWXXuTvOoxb5Ffn/3bdB7GHPDZKBYxlRM6PE/mr0qx3eJHXz1Djjz4aLnx6nXpqKdIsQzi5hs2yEsf/gY55fP/O+5dSZFiQSQhaYpFeXC8/Wnvl/78IB3FFCmWUQzmB/Kuf/iI7HDbHeRBf37/ce/OVMZi29OXE1q9Mpm/KsU2j29/+nvymse9NQGOFCmWaRT9Qt7wf46Vr37ov8e9K1MZhWSLniYxEuhIcavjtK+fJe973nFSFmU6eilSLONAg7iPvvzT8v0vnj7uXUmRgpFAR4pbFd/57Knypr9+lxSDBDhSpFgJgYeDtz3lvfL1j5w07l2ZyvTKYqZJjMn8VSm2SZz53z+V9z33OKnK1F47RYqVFh952aflh185Y9y7MTVRLDrFMpmRQEeKLYpzTjlX3vDEY2XQn9R/CilSTHYUg0Le8jfvkdO/cfa4dyXFFEcCHSn+ZJz7g/PlmL98R2I4UqSYAI3HW//2PXL2yT8f965MfKT0yuhIoCPFLQZMhl516JvZUyVFihST06H2l6el/kjbo+HbYqZJjMn8VSmWJC7/zZXy+iccy9K7FClSTJa49J//77/K73912bh3ZWKjWmRb+yqVzKaYprj+qhvkRQ98jdx4TXIaTZFiEuOm62+WIx/8OrnmsuvGvSsppigS05FiQWxYv5H064Z1m9LRSZFigmPu5jl53Z+/XdZff9O4d2XiIqVXRkcCHSkaMegP5J8OfI389meXpCOTIsUUxO9/9Qd54QNeLb253rh3ZaIidZkdHQl0pGjEB17wMbnit1elo5IixRTFNZdex14tKVJs60gN31KE+OhRn5aTPvW9dEQmLbJMp6HSyWxo3q2KMjnSTlqcesKPZPUOq+Tl//78ce/KRIS3qF/M+pMYk/mrUtzqOO1rZ8n/e/8305FbIVENAwqbKrzm+YIJACOecsz7U1Orpa9D6xKsDG+/1VqwL8NAJ8Xyj299/H/ku//5w3HvxkTEuNIrH/7wh2XvvfeW2dlZOfjgg+XMM8/covVOOOEE/tt+0pOeJNsyEuhIIb/52cVy7DM/kI7ECorMB3wf3H3w38wkAAXDYGQUSIi3N7TtBsgYAieb3ba/DzuegMhyj/c85yPyqx//ety7kWIr4sQTT5SjjjpKjjnmGDnnnHPkfve7nxx22GFyzTXX3OJ6l1xyibzyla+UQw45RLZ1JNAx5XHjtevk5Y94o8xtSOZfyy6igbvBYBirEJiIITZis4BieP4IMDESNPypbdjfDTbEwY4vZ8AkgKX4sxTLKnpzfXnVY94s111x/bh3ZUVHKfmip1sb733ve+W5z32uPPvZz5Z73vOectxxx8nq1avlk5/85GbXKYpCnvGMZ8ib3/xmuetd7yrbOhLomOLAxfb2p72fZXMplk9UIwb3ACzsNXwev8aDOYDKKGYCQAVTu12DljiNMsxixPMikBPAz5YyIgaSRgKWmAlJsSyit6knb/2797KaLcXWRVFli54Q69evb0zz86MfEHu9npx99tly6KGHhnlIo+L96aefLpuLt7zlLbLrrrvKc57zHNkekf61T3H86zM/KD/77nnj3o3piirq0AsNRvxZPFDHg/0IHcUwGAifdQxMdNqSdzuSdTqSdTuczwl/c+pKNjsrMtPV+Xidnak/92WxjK/bbom0cr6OAioLQNIw07E5RsQ/HwYxiQkZa/zqtAvlLX/z7vHuRArZa6+9ZKeddgrTscceO/KoXHfddXyQ3G233Rrz8f6qq0ZXJP7whz+UT3ziE/Lxj398ux3pVL0ypYEW16eeeNq4d2P6wtMJ9sqBmW+j+T4BoMTph+HPcvytgzTXx//b+k+6QnWJr4uBnTMN4gQAk0mGW0CxGZt7gADAorKt1SpYH/OqSrfv27P9zAZFvZx/BpAi0W+JP4vXjeeBpfHqmHi9FNs9Tv+vs+W7x/9A/uzp2z7XP2mxGDEowte97LLLZMcddxSPmZkZWYq46aab5FnPehYBxy677CLbKxLomML4w6+vkHc9+8Pj3o2pTZ00AIZH/FQ/Uo/hwCKqVAGY8EHZ1wXo8O9wAACGIn4vNejg/I4BDx/XMwccNuiXmMqahahKyYqyCSzwZ6eSalDT8QRU/b6uy6laWHkTAxcCqbwJtmLwlcp0xxLve96/y13ucye5y33uPJ4dWKFRVTk7zS5mfQQARww6NhcADq1WS66++urGfLzffffdFyz/29/+lgLSJz7xiWFeaf/G2u22XHjhhXK3u91NljoS6JiymN80Ly97+Btk4/pkcb7NYpih8PB0BP4eBh5DoKOuTrHPLJ0Bfw1fJjdWg4OxrwsAEbbXboIF3zcM/gAK8XdjWz6ou8YiBgS+HMEB9i1aNlou/Lah+TFTkRGIYB6Ai26Tn0brOAMUMx2VsSwL9uuWjnmKRQc6TB/1yGPk+Es/KqvWrkpHdAujkIzT1kZxK9ftdrty4IEHyimnnBLKXgEi8P7II49csPx+++0n5557bmPeG97wBjIgH/jAB5jW2RaRQMeUxb+/4rOy7rrUZ2GbxpAeYUtSJ7Eug0PwsLYhVH/gib+KWA1pAg9jOhrfBzDggzgYEi4b7Zcvi+1i+x4OBhwo8Q1SKxHzMQQCyORE8xtpHdt3ggcyK7ZuAebE3sf76Ptl2wisji0XAFhKvWzzuPnGDfJvL/6EvPpTCwevFMsnjjrqKDniiCPkoIMOkgc96EHy/ve/XzZs2MBqFsThhx8ud7zjHakLgY/Hve9978b6O++8M1+H5y9lJNAxRXHa18+S/zruO+PejcmPzaVK4lSIgwAACTIWddoja5kI04HEcKVIJ1NH0SDOtE2HefxiHbyZKrGSW5vNKKqF8xr5FRvL25lkAArRIvxupFewZOXgxLUZHWMwsOAQk2MsS9bQm2Qig1IqgA7Mj8FHHHFqxY+N72TM4qTYZnHyZ74vDzzs/vLopz4sHeUtCGLzRWk65FbHU57yFLn22mvljW98I8WjBxxwgJx00klBXHrppZeyomWckVXhcSHFLQVKlaAcXrdu3Rbl15ZboOb+8Lu9SPrzqQRuyWIUpY80iP8dD7iRVqFmNayaAymRDKkTDKSWSgmaiojBaLAfNvhSqOkpEbAQDnRsQAfwwKaU3LD9sU3j81v612+shwMMX9bgUX1XZLpGWYzAiDgoQMllBDj01TQezq6UhYEOIhjJcCzKQqTXJwvi21Kixb9zSMjqzMdmhKoplibanZZ8+tf/Jrvd+fYr8pBuj/u4f8cR33uqdNd2t3o7vZt78plHn7Bix5zNRWI6piBwM37nER9KgGPpDmgt5vQBOEpfbLbixFMfwZ/Cqk9aABQQf3Z0aI0MwLh9Vo0Y+2FiVIhIq44BHNd92N9l0I1YqgKAwPFL9DNKzDeGpPHz8B+uo2Ahj36PpltqwMGB3sHJAEDAFzRAg32xdEyWOWPSaoKQYkhcSzYEIAzHTAWoBCGojvGIUzvD1S2jmI8EPpYkBv2C7sXvOfXNFC2mSHFrI4GOKYjPvvkL8tNTmoKhFIuIEXqN4cqSABgsXUJwkUcsRizwxOeeKnHxqLEYznhgcCczkSvgIB5A2gTfgcHbgUdjvoGQdpTeiYAHwQj2E+kSJzOYjvFBWwfrkjkUwxNOrCA9gxncvYgxsXUwj+mbEhU2LmBVdiMn2LB5YDgGplnRH2pMiGlRIIbFdiA+BQAB8CiKoPmghsTWI3gycEHmJDEc2yR++aML5RNHHy/Pe+ezts0XTEiUknFazPqTGAl0THhcfN6l8rm3fmncuzFZMariJNZo2Pys3ZIqy5k+MQ2mAgyvMOEAqWZbEgMTT5sAYESpkpK+GsZeYGob+Chj9iUGE6a3aEeaDhVl6AtATRaxCwUYlZgpULCTg6HwdI2xH0VWqqjVBSW+dQcTBFB4NDb2w38r9gffQ+AB0Sl+S646D2c/XLMRV7CY4JTbgOkZPp+fjzQlFsMlt2GnUixlfPHdX5dH/t1DZd+Dlr6kclIidhXd2vUnMRLomOCAOx2aN91i3j7FLcdmDLoCs+HzWHVijAf1FyYKzc3B01Mj+I+lWfQpXQ23qGPAAEzHz1xfIyBBANLC0vV3ElxYakOFpEoQYH1lRIaqZLwyBbMdL8Qd6gsvefXfrhsuCERcDGpApG374ukZDuzq14FtN8Z8Py7GYlTcUQM+7iMCQMEqFvPzwDFzoAFfkHAsjBHhdjJjSiJTMj9NMfgAKEl6jyUP3Fs+8pN3SNtBdIoUWxDpapngOOHYr8qFZ/123LuxsmNYtzFUDuvLMI1izEajp0grEoGaMyj9NsxKHJ+jBJUAwapMCC4oEEXKwHqxYOxs1+BGjUJjfYjuCoGIZVv0QckqWGKq1kGHgxIvJiGQsO0YhggltzE4cRMh1X1K5qmQ3I5UID+QHuEP1hSOfRfTNfhOL7F1XQh+P4GCpm8C80FQASAS+ZL49+N4d7qSDfoiMCYz0WvN7MT+IpEINcWi4+JzL5XPvukL8g9vf3o6miOiXKQ5WLmIdZdzJNAxwa6jn33ziePejZUfkYPoKN0GP0ePEo6UBj46eK+hzIUxH5Y+AeAIZayY384o6gypEy6jYIKJAxNkEmRgPW4rAg5cT1+Qggl+GD7e8t6Fwb3+WZznYMSlEP6Zby/MiL4vc6BhzI2vZ9+ZExDUG0H6JDMDsLqEFiDDUjZY2/QXBCZM9URsSAYwE2tMTO+B78fyeMr2kl0AMGc+hkpp44qiRsFeSr0sKk54x1flUU95mNz1vsmtdKSmYzEls5LSKylWSOCm+p5//KiUeFpMsXXHcBTIQBiDUTcpU1AB1kKf0qP0io/d1GcYiwE2xKpOHHRwfifTqhMTjAYdBtMq9bK+0SoGE9E8YgFjLYJ8o9VkLFh8guUaRmBaVssIgMQCeg+M8dHgn0eO6ryvOjPCqpMaiLCihdUoqGJBCgcpJ9VmqB5DzT702LXI+mC5kiyJghMCqJk2NScZK3BxPqD56LoZgopMCzs33a6yHvM9BSTDRmPDbqkptjpwvnCv+eDpb0/VLCm2KBLTMYHxlQ98S8774QXj3o2VFcMOoQ4s+CaqSHHHTQccptlo2JSTpXBDLwMVrFDRV4AOT5Eoa1GnVJQkqES6vq5VoGBAt9SJ53tK11pAkOk/wwFGxEroNnSGahui1EnjEEQ25nFQqtEUZpZD3+ETh3drxUJwYroTkha+fJFJDvCAhentYaknikih4zBxaA4AAiGsriMt9QPhtrBeZT4gZSEZmtIRzFiPFt9dsB4AIFFqJXZiZSWQzd/ctZDiluPXP/mtfOGdX5OnHf3X6VDF/54WWb1SJaYjxUqI6y7/o3zs1Z8d926srPAyy2HtRuzcZ8wG+p2QdQDQQHi5q+k2Qjt3toI3dsPTICbuJABxQEFdA4AIdB4QkOoo7o3hguDTQIeztUFzYeyDZSIaoMOXDeyH/hATfw7rHuIDUpfAIs1RQxo/Xih7jZY2wGFkRWOeyT1cg6rzs1wFryZUzQBCrLwXqRjdb+3NwsoWPzG0ULfj2zedRwt6DmtW54AjdisFCzVoa8ktSm03p/WI2Y/omkixZfHpN57INMsd7tpsqz7NsVRdZictEtMxYfHvr/ysFKC0U9zqNEqs3aiG/TYweJmQkTbloPB9ZI5ZD4pE23XJq4EN6jGkrkLB56UzHBBwejoG2g13EbXhPqRNWk0wwTE7H2Ic/DOfZ4zIMHDgurZqHUPLeN5m6HJSaYUxDQ44QoWKAQtEYcZiEeDwlEzQtsK3Y1ApOWGpkgwpGDwjwqPD3E3BhpjxOitcaB4GQGRAhLoaZzhcnGoN4jR10xEZ1F1vXcAafjHOG/QgKbYqyqKUj7z8U/LWr702HUE/JklIOjIS6Jig+Pmpv5RTTzxt3Lux8mJYsxGVxIaqFGoFOnX1MZiO2JvDUillp8XJtxHSJyxjtYIMfI73xlw4oAheHljO7M3BCBBPGKsRmA9nP7xk1kGGMQYhxWHLBZYhCrINC6DGkJB0qAdc+Bz7Et5E3x2V7xI42TjugCOwFhEjUrLyxX+swaNBJi049kPHwfPgpbL2HXh1vUcr0zQOwAgYEGpBjMVANQtLclVrk890pYK/R39Qaz3iPjejHE5TbFH8+L/OljO+dY4c/BcPSEcsxWYjgY4JiWJQyNue+t5x78bKiIg6dw3DsGiUT8JMnVjaxHUb5vbpJZ7BcwNPyiyP1XJYgggfv/JcLccBXlqReZfpKuLUiYsyNU1Su4kHcafPowmY/Z640gRmpzGD4eDEqzYaFSyWyhlZuVLTKe5IWh+waPD3fYOu09mWYBIGQzP9TgpYTfOh1SyQYNh327HC3SiwJ2A2AJZMWOoaELVSx/JqKKZW7t7d1qqAnDVh2qVvpcnWVI/pl47+PvR2ia6HuDsutR5J53Gr41+f9UH5wpUflw4ruqY7UnpldCTQMSHxtQ+fJDdes37cu7H8YzhXbykRhoOOPFfthrEXWupqgtHY1nymU+s0vLokMvjC3wUGdQyqYDcsPaIaC2MouL4DkZqxQOmrMhmmvYgdRw2ABK1G/JMCKLFUR7xcpOfQ73ZdQ/RgHwMYLhTt6xD7EQCHUR6hisXWI2ljAENBiFIb9PUw7SYBRVRJG+8L0z+4Q5UtKdsAEZXk6NPCxUopBVVA1qUW7yGohagEbAfdVd0d1naSXWwBFgtWvjBdhgqXYa1HfG34NTPq2kmxIG6+YYN86T3fkKcd/VdTf3SSDfroSKBjAuKGa9bRpCfFLUfwgYg9NvxDdxSFaRf0GtYmPuuqriCIRw2UlJ225NYHRcWhABZ4OlbWgk/gYEXMg8MFovhGFFp4eoJpBwMdAXAw/eBMSF19EvVQazAY+tvsd4S0i4lLQ2pm6FjYso0ZzngMzQ9VJxEdUsSAh+tkNTHgKRTqKWoAQi1HyBeZdgb7aRWwjRQMogVWI2epLL+uk0nBCpZcWgMrwSUzAR2M9azBjzZjMdV7QLthvW5CGq2r39Xr0VJdtR49njvXpqgDqkjlHXZTbHEc/y9flkOf9Qi5/Z63S0ctxYJIoGMC4h1H/JtsWLdx3Lux/GOUm6g9zYbGbAAaYDlItZchfaIDq2o3qM/otqXAk7SnKdxbw8pDZQY6EK9YMVBBA61mJUoY0iL2AsJPpk48PROXzUbAIxh8RdvRSpkaZDSAShRh3WGR6LCUwZYJq7to1Jbj4G3LBfbD0zslek+4WNMYD8AI/14HJPDzoIBUwQe3wTSJdahVs3g9rm0FG4N2Ja2B9ouhhRr7t6iGgykwMxerWh3J26b1ACPiqTSAEIANfldLTcbm5hSojGoWl3QeWxxzG+blX57xAXnf998i0xwpvTI6EuhY4fHbn18iZ3/75+PejRURI/UbznC4fsOBB8CFp0xYEguWI5cSr1baCmZDDb28IVsuVRdgowYiQcjZstfOcFqlriTR9IyWqapeo7KUQaTncMGpZh0aWo+4siX+0QF4RLNDqsT0GCPVpM6ODLEV+uX2kYMWa5kSwIj9x7rL1GkdsBtGwah3h9bV0rnUgJZ6dzgQQbWKpW5wrG1d4hayT1gXtun2JUEPU/H4wCFVjy/KmJGesc628z095+ZoCrBCYWns6UGB6y3oPFJsNs77wfly/hkXyf4H7zO1RymBjtGRQMcKj0+94T/HvQsr13/DgEeOLrAoicVSeEoGg9GG54ZpOma6wbacQsVQ6mrMBm4wHdd8AHygT0pdkxqnT7g8mY663FU1GDqwKoNh6Rjbd8sgaMqkPQJgxHqOKO0RDkMkTQgZkti7A4N0PJaO0HUQXIwozQ3AxOfzYNTmYJoC0UKTkHXxDriOTAAqon0D0FAgpMBMC1EsneK/05rW6i5AqGsARamTcACqvqZoCFgALCgi8X4vBigw3zw96OuRzdN0LDjMxgEAGvuApNhsfOLoz8u7v/umdIRSNCKBjhUc5/3wfDnjm+eMezeWbwz1TAn+GxG7ofoN/G0N2DhCYqRT0SiYC22/HvlrUJ9h7qL4rOPMhw+WWvIa/DRCu/m66oRaAwckJvysoGEwoMIUS0O7YU/w0eAfqlciEBBEo3EJbQQwAB6CziMeT2PgMdxnKjiYRu8dWMTb8AqWGPgY6KA0wrWwkSu5az7C2B45rvrfBVw63NLfAEtDeGp2p/xNqBCaL9WctKxYPaO9W0zjQcCh54fMizWOI6MBcAmwQT+WrOnp4U6mVimTAMeWlfCf9e2fyQMPO0CmMRLTMToS6FjBcewzPzjuXVj+DMewcNRGt5xllMjld2rGAKJRcveg+lHeCqfQtpSu3SALkkmJFArem4uo2pgbQ2GVmbDw9lQIhaFeiQJhKT7Do79pReoSWCvHdYvzhpDUQIanIBpVKbX/RazzYKg/VpPVGCUYtXUbD/ZxhW00yAeQUBMK9T45yKmGymhjPQr8N6xyhV/XMSDhKRinRVxYylSJ925xUzIFItSARKJb6ECYdhlUIv1ScrdIBZtBsIgfiR1DKs19PbxJXql6Dkun0XBs0yZFTLFdetRILsUtx7ue/WE58fKPNaznpyUS6BgdCXSs0PjxN86Way69bty7sTzjFjw4aPJlgMM7tlI4yooR9eTQPilmS+46jShFo/NyKfJMK1jiFIoxF3yYb0VgRHWoIcXizIdlEdQu3AWk9j5UqcgIQMHBNmI9gihziOmI9RvhoAyVyHoM6TbYA8asyRvLWLoknhcmB0W+zy4YdSBifhxxGS31GFH1iveY8eob7cVivwMaDnh24HNvKGeaGoISq2DxjrzSVx0HfwOBA7w9Wroe2CrTiSD1IvN9YzzUTa2Cz0enK5n0lE2xg+YDaNJ4/Om44aob5ftfOI0W6SlSIBLoWIFRlqV88vXHj3s3lm00NByu40BAvwH6nX1SIg8OMBmWTqH3hqVGQvrE0iocG8FuoEssXUZh+2BshYtCHVSQ6o8Mv9B13ao6fVlqNJzliLQaQQfCAT8Sg0aGYfiXy2qOYWYjjsCU2GA59HE5qq9KdAz1o4juiHUisRe7VeSEShZuPNovAxy18VcERLyax1IwqGDh7DiFEoEkbiNKM7E2xgGHgaQK2g7ofkvWtWiKBR/D68OoH1Te0rhMcmn11KdDK2XsR5To7VJqSS223+spCImda/F5JDRNsfm+LIc8+cHS8n5FUxL6T2PrGZ5KJjMS6FiB8e1PnyoXn3vpuHdj2UYjpYJwDQf0G6DNMTYBXFhuX7vBqvcGn3TN8AsAg74azm6gWgVP0AATnsJBS3q7PZDWN7BQoNLWAYEzHHQL1X0KZbGB/YjYgOi9CzKHmY5G9Ql/dP37HWQMC05jsaYel7oSZuFB9HXq5m/RN9RgIF7FfdVjoOSa3dggzLcfb8PXAZgyB1LXg6h41wCHp1ecRcH5IXjCoUBlDM6z4Y9+GcCbA0lqPYoyeKUgvUJ9jaXPMt8B278sR8qlFOl0VIPSN7+XOM3iACSZiI2Myy+6Ur7+0W/LX734L2SaIqVXRkcCHSuQ5fj3V3x63LuxPCMaBFQUWo9xObQb1hhMJQHQcwCAQGiovVVQCluiasUGIACRAkADjEjX0y6R54aVZ3oFSxVXpbSgQ9CcQJxWCQJRK6FtDM6hVX0EQrwRKoWv9nt8fpzjiNMpsTIzTrU0XdCbaZf4g1hI6mLQBvthfiPhvSKasAkHFyQBIkdSF5AaU+GbCk6mERABKCB74Z5eAbTUdu6asrJWtmCS6Nmh1S+wWC9Risvfo0wIAV8foKWSrKtCUiyr7e3xReoam82D00LazRrEmcMsQeumOZH5+aaDaXIq3aJKlie+4HHSRonylEQCHaNjWKe+3eNNb3qTOgBG03777Rc+n5ubkxe96EVyu9vdTtauXStPfvKT5eqrr25s49JLL5UnPOEJsnr1atl1113lVa96lQxQbx/FqaeeKg94wANkZmZG7n73u8unP70yB+4ffOnHsmHdpnHvxrIKHfyip07vM2KVKt6MjUNQruLRzEpcq9kZ9kqBboNPw90WhaJ0FfUGbjMtdRWFANS9MvA5HDKzTAowHzNgQqxjLKwfrKSWy7QyGWACuYJima4OqiytdaBiIITmYPaZ/43lBevg+9sQqPpU60DUGyRK89gyHPhNuIr32Aamwl45teqJ6/ny/BwCTLAN0ffaOvH7xvebwVm8TNkqperY/uM3daLf2WoeDxfMch6OV0eZo3q7ekxxbPVc2LIzevx5zCnYtXl2vrg+vhfnytJuWjWEiiQFlbC+L1e1VVTcsetmBtcL0iwKRFnpNCRQXtA0MEUj5jf25JTP/yAdlRTLg+m4173uJf/zP/8T3rethTji5S9/uXzzm9+UL37xi7LTTjvJkUceKX/9138tP/rRj/h5URQEHLvvvrucdtppcuWVV8rhhx8unU5H/uVf/oXLXHzxxVzmBS94gXz+85+XU045Rf7xH/9R7nCHO8hhhx0mKylOfOdXx70Lyy7CLX7If4MP2/DgcLdRpEjwkbeiRzoFgMP9N9zSHAJSPEDDVdR6qGCwUgbCxKFBEGrlsC4ghX7ALcu9wsR9O8wlnTS9C0ZDU7ihahU8wcfvRwhCtQKmZgkolow0JMqSeFlIdLA4RetyZRVsNtkLS294na31aWn0p/dNg/kIbIrNtIyD4j9L5UQmXt6J1tmQwGZ4xQ++Iton2Hcg7aJN42wXo+Z4EJjyELjMAiXMvlPcHwUlSLYhBVWiusX1N9KS1nyp5w/LMbWCKhhDQIWlWXDdzMyIDPrNTrXhYvQSnhTD8YV3fU0ed8SjpqaSJTEdyxh0AGQANAzHunXr5BOf+IQcf/zx8md/9mec96lPfUr2339/+fGPfywPfvCD5Tvf+Y786le/ImjZbbfd5IADDpC3vvWt8prXvIYsSrfbleOOO07ucpe7yHve8x5uA+v/8Ic/lPe9730rCnSc/o2z5aJzLh73bizfXiqk7q3ShA6UHZHZmfom55UsfMrVp1otd9U289BrqAhUq1P43qoxgjjUOqV6m3k8gTPT4qwFmrx59QUZj6bPBoGIiyi9CpPpHNOIsC376CoUjLTBHh36hSERKde19XX5er0QfigMsGjKwpBPrPNjiYr/7XW93sWtblnvwEJTKdH27T9oW++bCEJSA0dakQLX1bqElukowzbQXwRjM0vLsEFs3wSnSJlAY+O9W8C4+AGl1kOBCLUeSL101N1UwZ+ed+JF6EMHJVkVrjk/CDb4tEdHpYsfQzwQ4bojWJ2XDA3jjFnjT3KtRxKWLohLz79cTj3xR/Lopz5cpiES6Fim6RXERRddJHvssYfc9a53lWc84xlMlyDOPvts6ff7cuihh4ZlkXq5053uJKeffjrf4/U+97kPAYcHgMT69evll7/8ZVgm3oYv49sYFfPz89xGPI07jjtqZaaEtgfgUAGoCUbxHoJRqyygdmOmKxlSKZ5uabcoFKWTKEcetTgnuAj6DWtVD4rfPDaKrtH5HACVti/aSEPUfhv4u+gOAY4obSBxqgBpgU6dEuFnPnnqpAFqTJDK1AmWt6kTvWJqRVM7muL5cPEM88toPoSTQ8vn9tq1V/8c72cqkVm8t20wDaWpm1AGPJR+4cA/fEyQekEKxo6HplJs+QjA8RUpF6RKooqe+DihK62muHB+NM2iKTJLzQBgdHIpZvU60HQZWDGlSphywblHioXXRa4AFhPTLW318QCwdeM5vzhj11u7VlNofOxV/186FFMeY2c6Dj74YOor9t13X6ZG3vzmN8shhxwi5513nlx11VVkKnbeeefGOgAY+AyB1xhw+Of+2S0tAyCxadMmWbVq1YL9OvbYY7kvyyUuPOs3csVv9PdMe4zqFtswAkNp3uystaR3qlxLYwkumFqxnH63XVeiUIMBUzAMGu5y6a3rMYiaXsNYjtrwy9xHUfaJQbATDa4yVKFir6i4CMJRm1iF4akZT52EVIexIL4Otx0t48vh8d9FqZ6X8G3ZKrpcPa9292xWvTTKVb1DvL8fXt5+pyKJyEDMqlDUxbOuwkXFT0jLeApG/c7rcltjVFy0SSMwE9lyjlU9o7qVWQ23Ssf8QVx2DErKgAsrUUz1S1KiIniBVToayDEFY+kyikzDSWypl4cdgAopp8o8XrBTg0G4/gLEcNAbX7NTHtddfj2dSu/3qHvJpAfShqG0fCvXn8QYO+j48z//8/D3fe97X4KQO9/5zvKFL3xhJBjYXnH00UfLUUcdFd4DoOy1115j258T3pG0HB4BXAyFVjNYJ9iqkpyCUNNvsOTVPDig0+A8N+9qqV/GLChzPOHqKNt4cnbAEXqoqKW2LxPMvTq+k0Nlr1HKxJuXua6iLn9V8aNXXIR0iWs8wCKEg2AAI6RQvDx4CIjEmo4ALoZszaMKlKDV8AMavDHq73ZH0OGDHxIp/n10JzUhC3Io9M2ICmUiUBMyEv6TArCJNBzu94HzwCqVCFhYBoQEgwETB4Z5Py7JdUrEjr01m8P7IqukxXJaPVj8yVaNxGuuV9QpFGyQLIgxYnMAHur3UYOxuFZ5MgeQrYkT3vGVqQAdSOEtxqejXMS6yznGDjqGA6zGPe5xD/nNb34jj33sY6XX68mNN97YYDtQveIaELyeeeaZjW14dUu8zHDFC97vuOOOmwU2qHLBtBzid+f+Xn74lTPGvRvLLzytEvlxZKtmtAV9zHBgAuAwFgOUOWl0AgtzHu0Yzc4B06pQaCClDpkAFRiM+Nxr2g1S+/TxsHRInALxcdlLZCO30FDtMdS+3vUc+jytqZYGo9GOBnPMs+oUXdyrdUawH/QjH2IwlBqKkIVtkzvo27T/8FhF8zhFYotoVQAh3yx/txtuMW1hyGSglqvaRM76mbi2NerXFjAQeqa45kMizw5nSPCn+6IMTGxqjq/UcBj4wDbovTKoJLfS2xw6j76mx9RBti3tTQU1HuokmyvDQUt8K8kl6wP2pJSq35cMXzwzI1U1J5kbiEW/i9dpSrGE+Mm3fy6/+vGFcs8H77vkt4QUyz+WhaYjjptvvll++9vfsrLkwAMPZBUKqk08LrzwQmo+HvKQh/A9Xs8991y55pprwjInn3wyAcU973nPsEy8DV/Gt7Hc4/i3f3ly7eluRYTceNyW3vPn3n6e/grIt3fVkyMCHM54cFtIpaA6xUpbnVlgySVABrQalibhgGSiUp+npa5a1ULBqIMNZ0e8WsU1GNR41KWuClwUONAZM5SLml4CWgkyGUO6CkydUgGIsx9tnxfrMmz9vJRWt5BWp5Q2pnYhHb4vpN3p829MXU6lvfq8gczODqSDddoF1223S8nbhWQtU3JC/8H9KqkPyaJ9oFgVn/v+2f6rdqWs99krdeKSW1tOS31d7+Haj1rrQlBnbq5+3FGaHLrxmgDYy2r1NZMBdB7Qe0B/AwwUyp2ttw5BpZdG56GZnMygnNa0HAC5KL+GXqiL15n6WozdcCN9RwqNz73ly1MjJF3MNIkxdqbjla98pTzxiU9kSuWKK66QY445RlqtljztaU9jiexznvMcpjlue9vbEki8+MUvJlhA5QricY97HMHFs571LHnnO99J/cYb3vAGens4U4FS2Q996EPy6le/Wv7hH/5Bvvvd7zJ9g1Lc5R6bNszJWSf9TKY9Nicc9cCN30UHWjapQAKlst6C3jUamms3m3MOMDELYX4O+Nu7x8YlqBiE3DML/3racXokGvxsGyr2jJq2SazbqIkFtlwH2IhLWmkuFjEYURmttUgN4EV/upWi8vgo45AjZQCvDcsROymE8TPL0NKdR28B+89n/Lik188DfzJ+hbajhwEXGQNWiqqQl7lsplTwhB+Xn0TsSVSmq7bmFe3Lg/lX2A9nPGxnYr0HDcq0a6x/BytWvHzZerSAlWCmB4ZhlqbJodcwdoeghaIaMCUKcsrZluTzRjL1tAlcZY5oTLegxBogVi9O1YrQ06Mr0uubgZnpOcTTTMZhJX2HnPu/v5Kbb9wga3deI5MaSdOxTEHHH/7wBwKMP/7xj3L7299eHv7wh7McFn8jUNaa5zlNwVBRgqqTj3zkI2F9AJRvfOMb8sIXvpBgZM2aNXLEEUfIW97ylrAMymUBMOD58YEPfED23HNP+Y//+I8VUS77vf/8kWxcn8zARgpHcYBCA7e2lje6ZTnBhT9xWkrFBZ9ZLgM81c7icx24qvjVm7eZoBAjVzmk3+BTs3l3eEVJKB2N7c8xuMcnlFbophlxtiNiPcIoi/33f53MLajLaa3FUBCiWlkAGS0ZzRxkGMDAkWq3ijBmQxhZZ6OKSLBWCzkIOKwE1g0/7RsJVIgVPP3Bh3kAkIy9U/B05mJPOITW5baaEwkpFc+/eH4ExwRaCghPBzUaQ8ltnAXyTBM3i9PnaRbbRPACMfdWb5rHBnGmB1HE6MyUsht2cBSwWCM4XEOtTWB0LDef2/qDTHJzsuV344drLs+Yl5LOp+Egum9HEpaGmNs4Lyd/9vvyVy+ZLmv0FPi3mOq5tiggJAXzAu8QMC7bK553v1dMfZ+VRmXKcKt6pFLgnQCLczBbeIS3LrIV+quYtTlLYPGKUlm6VuorXUQJKLQaATQ70iZ0wDRdAAdQZm40nRL0G55WwapIn+CEYRAis2HOmz7ohZJOrUBhtt/LRanliECHAw9L0eAJ26s1EGQx8orpDuUWACQMeAB0IKVBJgLAo5K26yzsKbs04JHnaP2u+wJBJbeUGeDgwqB4awYjB+CgJwXkDDqg6jiakfHAPH26s6e8rJSiyHV913AYmOC+VblUABmODgwMsGEbkA4/0wOiluXW34XLWbM64DGaD2vlCpeDj0dciDNvXhwuUh1U0hrUNuvsQgudx8C60QJ2gKXBd8wV0u6V9v2VSL9gvxZdp5Bsvi/Sh4iEiIulNNVcT6peD6hLRadenuNTqczTZJLnWx533Gd3+fSF/zZx93H/joP+38ukvWbrdYGDDfPyk79+/3Yfcyae6Uix+bjwJ7+ZesAh8c3ZgUb0nnQ2njiRKsFg4ekT2Fhbl1iOrCYiBWNRzBjD4WkDMg3WWZb+GWA50B69TgPgIZZ+D0GPUVdHkOUwbaWafEWiTXuvD/ieqjFAwVGwZlPq9IlXtVQ0xMpbcM5UwJDnNhEclNKG5qEqyGDkEdOBv72qtZUXQV6gQyqqMAA4NHfCIwcgQTBiJZ/uDEqmQ7fLFI4xBmRXsL8GMtDXxBkPMidI3UimoAZAxwb8okRlEcAMUhIODiLmIy6/bZnotKiridSEzNgPZysgr0B6Bl8GwBF16MV34FiT/LCvcQdYBVLGdnCbVkbrfWXwN0ArlgNzwf2ASZl2r+VGZrv0hBGADwAO9G2Bhwe2OTenjeEsQr+WJCxlXH7RVfKL7/9S7vvIyaxkSemV0ZFAxzKObxx38rh3YfmEezUER1Fr6mZGYDXDAcDRIaPBEcVHWwx8aOzWdVvz2n8jNGMLfUtqAaL7fEBwSNOqOHUSiR/LuNpkyHPDGQr0MQkVKBxUDWj4YBunT8Aq8Ofo4O6DfAuP+8Zs4LN2C+wDBsNCfSroZ1aQ7SA4AUvixBCPnw6cLSmlBY8KgASvCJGBmY4qw4E5ACT90qp8wo3UqjmsTIcgwr5AM0MKEsB8EMLQwVMbsEG1qSwHjm9J+KMHx6o9Qjmv53W00oeowfQePJ0+lnt1i+ePAAwdmLr4xiUhADno3wbGyo6/siRmFFYoA6Ksie43tSFgxKiPxXFqEdhwu6ypLXmtcXkAHpiOFZqSAf0VbNKx3wRaVt2SqlkY3/jYyRMNOhYjBq2SkDTF9owN6zbQMniao5FW8QZdPiYTZChmrmJhKYCFDRR0lvTyVgykdBONnuQdVOBzq2yghbkxAFwMGgyACgwmnqIA+PDq0giENHunmHbDrc1Z0VEzH67JCOkVDEjqzs73SKF0Otrt1AEHXqHPyPMBb2YADQo6SgUnTKUU/BufE3NB05EPzIrLgJsAvNg6IBOYWqkZJOMVlEUx/QYZCk+/SCW9si1FmcmgypmuQeM7TfHY2vzpysb4GFsAcEQ3YwdJxQDbVnpC00h1F1kO1jx+xghB70GgZCAvlP/asTPrdC+9DSW4AAoGHBEklfpDImAAJbBJSKvg67ombGXaRY9VjtSIKnTN+hzXHFIzdg1aCoU6D5Rud7ssq5XYIp1flYAH4odfPkNufP862fn2O22nu0qKcUdiOpZpfOez35e5DZDPT2csqFbBTH8PRiNKq2i5qwETa1GvbqNIqaA1vdRCUjAcEb3OTrKu3zBShCyIP4B7+atEr96wzbWQkd03n80deLCsE+xGVCLrQMMfwa2bq6cvqEVkOqSSDspTIWI1JgKaCqRa9Ofx0V9moOvwdAvBRCEdU1eCxWBmKR+ouaejIYATbAvfiW3kkDkMgxJLzxjrMQCzwsobTaF4pU9ItUgmvTKTXtGWomoRkBAsMHWhmg+r3QlMR7uqZJC3+HsLeF4wdZNT00HTLoKLqHma6U+8pMZ9z0KapTS/jrLSNvcEMeZSSp8T3QxYK5mPHFa9GAhBkAlvDv5oaj14XtDlF9cIKmzANKF6hfQXNCN9vebMkyTI5HBtEskWtWOpl377tQwQM8XVLP3eQL79qe/JU179JJm08PTmYtafxEigY5nG597yJZnmGHYdDcI7T6vgvs3+KJFwlP4JefBZYOioq+WvSvZbm/O6NJaDSWyehUEKYtPYD8JTKo0eH1E6xECFghVPq8T+GsageAqFwADLAEhUOgE4GPgAwECKBGyEDmRiQKSQLvwyAFQqBRwYWB1AdPKCgEIZBxWNdgFiXFuhtSnSznxdBRkzxnhwt10PYscL+osu9R61ZsOrQbCfymxgH7SBWiUD7k+/yGW+bMugRCt4t1p1FkTLbTGI4wXEFZgPeGsRCMadXmMjMFSGYBsQgprQ1MW8mqrS7+B1UtpnvcjFNDITc1Cm+hAcTwOfhnOQjgGuZZrMRKdlN5esD8BhqtXeQI3o8AOw7RKiU5xnZdxYRussh1eyDDmVqm54eoHH8f/y/yYSdPBhITmSLogEOpZhXHrB5bL+jzfJtMbmqlVI76NSJaRazCuBOo62VqfQRVKfMslyoBJlpvbboGjQRZ+afzCmwkUP+gQ8gDEVcvlR6iSsR6ajBhxxO3sFJmZ+5SkXplQMNoWUiuo2AuAwgSie+pmW4EBcsxhIm9CkKy9DagXLds2Dw9Mw7Qh0KMwahO25sbIPtgpUaq0H2tFEY7wCDAhOHawZYACQySvMV+aCQAbbpF8HJgUGOcBNXsmgLKRfZdIvAD4UJLn4VLeK/+YysF4nuj8w+TJfDiJDd2U1Maj1oiH4wN8wJsN4jm0AKLgbqFWy8lvohhpZwGOz0HhY2S4t6COJjdrAWCqHQljoh+pjo91nYSKmqCfHfkJYChDc65MJYWoFwKPTYUWLO5SOuOJlWgOWAL8++7dyjwPvNu5dSbEdIoGOZRinnjDdWg6VPJjPgbej90ZuYDMCw2FiRpbNunBUl8eAxioUjKQEC95nxRgOTBSG1mWxtMEm82ElsF7y6oNw1rQx9yoI12+EyhR2TTXNgT+Bc7CEHqDWbSBVAvdP/6nQP6DyBGADAQDR7ZQEGjT5QuoEQIQMBoBHKTN476kQpCwMdATWxPUbnBRcqI7DWKOg9lDRqa7hcyvpZAMpaQdmrEeplSf9yufV+gwILZGq4ZbMgwM91PDdq1DN0sllvmjJ/KAjfauUAeDS9IuyMi1IS6GFAOvSQcltS0roOLjvJjalltaqZ6Dd6YExUQgUwsAFK1HsPLBXCz4zTxWSLwAom0xI615zSKmQfoHBGCzT9arEeVftivqdMEuGdEsfgEPZDX4RUy0tZTfcEZe26UXDDj38xTTQpJLpW37PmzTQkapXRkcCHcswTv3CaePehfGHA45Q6wlWQy9XmjJ5WoXeG9BtmLjPjME4QJLtcJMMe8I0hoOGUG6PDfBhYIJApd0spw3sBt9HluVOzYeeJ5H3Rmz4Zbw+2BEOlMRMABda3qrCT01rsAwWYKSFCpRC9ZMEDJW0pZBuBqGosQxwSzdAouyCCiBZGorqFIpBC1mVzUuJgVw5hjqFI2XgMRx4IBRMAHAU/LtvrAEBBpmiSrplIQNpMXWi5bJIK6iwFKW3ABC0IjH2ozSRJr09OiLdEsAH6ZeOVKhyMetzbKfIcAwgg2hLnhV8D40HtluhhFabuoRUGHUcbEeL822VyLRINdbJSlzBRGQmArbDpQLXrmjVCuYVhLHehJZO76TJWX2CtIpXrigAg7Mp4VmgiCz9BN8Y13QwFDDHvh1kYzzdMuXVLN//4uny3Hc+a6JSTBRKL6ICpZzQ6pXUFGCZxXk/Ol8uu+BymcZY0FvFnwa9LJZ8t6cx6lb1HCRh+gXdhoEQlMZWSKt0VJsB9oIsPctlTavhNHtUiULAYQZgtUV57RvhzIa2tLe+KZ5uQb8U7yUS+24gTYAUSlv7n3Q7A+lQr1GQ1YDJ10xnQJAx2+3J6k6Puo1VrYGsavWoyYBWA0CEk/29utOXmVZfVrfmZYf2nOzUmZMdWptkTWuT7NjC+02yQ3teVrf7skNrTmbznszmfZnJBjKb9WV13pO1+SbO888wrcrnZad8k6zisn0uO5sN9G+s05qTNe0et43vuE17g+zU2iSrWz1Z29Z9WdOek5lW/Vu4z/wdpczkfVnb6cmabp/b6bb7CrAIwHAscFxc04Jj0pcWjl27ZA8ZOq92XHirQAXHGA3ZCO6MdSL75Nob9lyx8ltnrPxyM/O3sJ5pebTaxQzkuurxoteQAtVyxrRB9HUx8Mtr0DRFQ9coq1nAekTpwuHrfVrjmkuvkzP/+5xx78ZExIc//GHZe++9ZXZ2ll3bhxuixvHxj39cDjnkELnNbW7D6dBDD73F5ZciEtOxzOJ/v/RjmdoY5Tjqf7MtvbEbLIu1hm+gsjERHOjfZDhgABYqTezx34WjnlKJ2srzCd6Bhj3JBkt0ik/rASw8jQVPjlJkxh6bXb/h1t5WEpu5YNS0G502Hq0z03FggFUgMdsaKOOQZUyTzLTxXp962tnARKGm87D3gQ0BuwGmhDoOZTXAkHSzvgo8qz7ZCd11rK+pGDzJD6pWSLFgnleHQP/RDwJUkQ4NMzKBOkGralQv0itb0jODsSKD5kNTSoMK1SxqI9+qvNk3eAmrUjGx7GzVlw3SJXOiqg98Vpi/R67pC0MJJYBdnPdiu3q3QS8l64P5igzETFCqb9k3Nriva7WKnkd4hmjKxKzdzQxNBR4AHXB71euUKR78DjQ19rQaxKX0+cB+t1g2SzZD2+M2q1mQarFrPlSzTDnb8YMvnyEH/8WBMinhBrSLWf/WxoknnsheZccddxwBx/vf/362+0Cj1F133XXB8qeeeirbkDz0oQ8lSHnHO97Bfma//OUv5Y53vKNsi0igY5nF6V87S6YxRqn3HXBQmEcnyKibbKhWaVljNnxmWg6wHC4UtQZdbgAWqkxMJMonWwxGeFKmt0fNcARg4h4bFIiaEZgzIF6dQqMoYzbsb9d94PNOR12o+OCLtAqmrKAfx2x3QKtyAARWn9DbQu9YSHGon4YKElAOC4DRzQdkDFZlfQ7g+tM8DTOQLrUYCsawnOpksV996ikQWMb1H0gJYH7HvMJdNArQgRQJAYcNnvQAoZBUbdGxDH1EbHl+UonM5thmi54emAAIunlOPQjWhzYE3wQLFBwosCCbiq7MD1rSl0y6dFvFNswkjaBF9TID+tLrScJ3006d9vDW+2QeamBsVq8Fdbk3xsO1nKxwUddSjvk4t2UlkNQEo1RPlUHn4deQ98aB3gPXXBvHwwWuXnGj/X5QessEjFezEAyWUs2Z3gPVLs56uGZlSitZzvzWOVIUSCv6uV3ZMQ5Nx3vf+1557nOfK89+9rP5HuADfcc++clPymtf+9oFy3/+859vvEdPsi9/+cvsyn744YfLtogEOpZR/OrHv5arLrlWpjEWVKt4RC3Ctbunvbfmbq76d9BBAGItykPFCoY7sCIYcMI8L521brGhi+yQjsMAh5c/KpvhDElciRL5b7B0FuyG2piDxUC6ABMHbAMOACIY+OksSqEoRKOaggBjQYMu6BuQYoDXBputldLlPDAbmoLBYEyAQUKnJBsBUELBKUBH1idYUSbDXxVsALCESmEyGnogKHnIFDy0KxWi6pio3hwzthbW19w1fja8QdB/BeRDKXNVm+xLpzWQtblID6yH5NIvC5bSQs4ALxJ6oYJugFCzGki7M6DgtFd0tFKGDENBcScLRXh9DHg90LQMOo/obkbBKLZbmjS2rD1UPMeuT5EqyKWY1PUhSKPgt+Bcgs2wzrMEBki7uMgUYMGsOeDZgT+o70CpNXw+cIyrllSzAEWZVbNg7oAGZ2RC0LPF7dGd7fCM3xQCjxuuXic/P/VX8oDH3Gfcu7KsYv369Y336J7uHdTj6PV6cvbZZ8vRRx8d5qFZKlImp59++hZ918aNG6Xf77Or+7aKBDqWUfzPZ78v0xi8weYjUiqu5fC0Cp9WjfkI1Sp1CSJu9nWqpU6tBK2Gi0SDULSiA+lwlUoYhd3q3OfFdDiqU0KztuYrAEfe8XQKAITS9W5ZjoFqFbQOHQUa0FEATjjTQdBhYEMZDas+IZOBlIj6bgB0gMUggAht4SqyHzP5QFkSVquYO2ZUl4J1AXTwU5DA4f+yppCUPqFWGdq3Cha2jq8q6QHaABAo36ECUWNJvJQW3hYALO5SiqZrfWnZ77SmdJKrXbpTBYbt+PtyYaULO/wKSobRW60l7aqQzgz+1ioXTUCZWxtSKWAXADK7anPOBnLMCrkbqDW5o+TCBadWLm0eHuXAMK25k3qazauRAC74mZddm/KU1yeawrm4GBvGtQrzMxeR0mcGtumkYrSiJdZ4THGa5ZTP/e/EgI6lYjr22muvxvxjjjlG3vSmNy1Y/rrrriNTtNtuuzXm4/0FF1ywRd/5mte8RvbYYw8ClW0VCXQso/jO/zedoENLIYNhRNN5FBUrGG1arSAmBW3t9uUU8JkRGLvJmrV5cAt14GHgA+F+GyyN9SlqSc+USwAcWirppbI6vpXCnICbUfl8e3X9hlajeGt59eMgE9Hpy5oWGnXo/gBogNlQ3YaxGHjNSoo98zxj5YrOK2RWegbMKmVAMCAbGPEKlzJKuUDToexFXalCzsFsyzV507RBV2WFfkbZjH3SZsULUh7aNwVOptCD9LJcBtK2linKfoBlUCiQs6plAAYAbAjeZ5msaZUyV864SaqW6Oal9MtcWnlLOvjuzpxkWVvyosOBvbBjhRvyoMBvNFCAc4Jutprf0FSLWdCzmy3QEstza7t07f/iKuLaSsVBagaRiumAAF54uslkmFOp9WAhXPA0C9MpnoYxm1Qs34bLqZbPVmyXCzRX4PF0pIh02lgOj++d+CN5xSdeyCf0lR5LVb1y2WWXNbrMjmI5liL+9V//VU444QTqPKDv2FaRQMcyiYvPu1Tmp9j2PDAbjRJZujzp02QrqgbAYEiGwsEEKlLwZGvzWH4ZvVp5rE9k0jEgeb4+NgDz7rFxYzYyJ1Yq6wZVeKrn+j5a1WwHUgG0IufuOsMBrUYhs20dNAEsIBxVnQZSEJouUZMuMBioMBmwIsSdQAFClBmBBkQ9H1bl4BxUy0EvD7Af0Iq40NO0G5YBUP2HgQf38VB+RMEAAoxKbdtFNQmXx3xxDYdZjaE9SU5ZaSbzZUvmpaMAA8ZgLYAfLI+GaLnMwLFU/Uqli31odZgqQhqGVuu5az9QUqvCWnwRyoJvHojMDVrSBQKqcrIc6taKqpaM2sxQYkihqflfsK8Me8zqe+s8S2bH2QtLZXifHW95j5JYWqaYsLRR6weQwUKl0lJ2OP5gOfSaDNRZcJszTRK+i2XU6udRQZtiDEhoCGdaj2mM/lxffv2T38p+D9pHVnoslZB0xx133KLW9rvssgv1MFdffXVjPt7vvvvut7juu9/9boKO//mf/5H73ve+si0jgY5lEj856Wcy1eFlhEy1ePM2c48g+2zvmULR6hWWJuLmD7aja/3lqf2wPubeAdYrUFwkai6iIfUSpVXIjDjgsPbyYT8wEqFhGB/fbViPGr0BgKC0E1gJzdrcGgQD1mwXg+jAcJNWrJDVAAtCT4xSZls9S4moIRg+R3oF89wbFBUrABooZ8U6YDlosuUmYO7lQc+OMgIrdd8UDPodsyqPPTq0f61XETvdr6BDn7x1HvZGe85alQd8OcxtlXJR4rBKNlUdpmH63BewFFrVMiulAhc6o7ZkRvoqNq1Uw1JWHZk1rQyqWYo8IwDBb984mKXYk1+HFA13yy3W6Qtaq4M5tut3s5wWDd7Y00UBospIoAMyjxD0WrEMCI8B8YD5dkTXTuhB6DofD7A7Xs3CTnbmwTE/kAxOuujnQrpE+8xAOAJWzEvFUxWLxlkn/WwiQMf2jm63KwceeCBFoE96ktrKl2XJ90ceeeRm13vnO98pb3/72+Xb3/62HHTQQdt8PxPoWCZx1renEHS4eC4SixJw4J5N51FoN9p8QlQth6ZWCDKsyyfLZ/HEqHWjduPG8pHbKP7HVvY2HgGfkCUxZsMGuNjePHhzGEVPIAMw4o6jEImqdao+GuMnEHBoCSi1HHyirWSm26f3BBgI2pwjbRBVqiiQGIS+KSyFpW5DHUFn8jp1gnQL/tZtlBSJup7Dy2AJXMwEDECEbIABDK9UoTQhFOsos+GWJfarmBah8NRSMLolTcV0BJbmypwg4eLcSGn9YKD3AKiYkVJ6VS7zgCNkSJQVAcgoq77MVD0DlroHWLef57RkB2OiAldcBhXFpZX0yXiAfsfxILboa6oJAzgMQgsKS7U7rKIEFfQS0OJk4/yCUHDLdG8YZ+6oWXT+yRbBLRWbMVdTZTxIG+l+myaJIlPz7aDYFBfNAHkZYz9gGFaadbsZ2aneY6D6ED/2/m/CNSBTlmr5ybd/Js9649/KZDAdi9F0yK0OlMseccQRBA8PetCDWDK7YcOGUM2CihSUwh577LF8jxLZN77xjXL88cfT2+Oqq67i/LVr13LaFpFAxzKIjTdvkp9//5cydRFVqrhnAcOqUphesTJZFY92rEoFuXH9DAZQLJGlbsM6n1pOnSZObRtEtC+7ggxnK/yLQwO3pq7D0ysccLyXileqhHQMTL+qYPKldtrmDAohaLuQtd0eB38MeqtbgyDSdO0G0h/dvE9ggHlgMNZkcxx8kGYBqwGDLqZhWA7L0Y7Hy8teqZWAtwdKUDOtXFH2Q51Mo9Yyxk4Eg1azoWhqOlDJQjAChsJaoFgLOTIfKMjF/nlbewU9WuECtoGfB4CSydp2T1aVfdlUdVkyC0EEjwko9bIlnVzVvBiU17TmZFM5wySQ16Lie6D1QMfcbldbxfeLtsz324pXgygIrrKFlF6uAi8u3PwJCDDIl1INwLi4atRAqZ1rpvIse+bVTOg6TMdSj36djiHIrVy8aj3d2IG27s1CdEdbdeg6wI5Z6bdn5dhht68gA7oX6zw7bWDD4/wfXyTrrlsvO+3yp1MKyznGUTL7lKc8Ra699loCCQCIAw44QE466aQgLr300ksbepmPfvSjrHr5m7/5my0Sqy5FJNCxDOLc7/9KSjbDmN7W9Qu6yFpzNk2raH8VAA4+IUYuoRSVRg3cXKdBB1KWzkZCUZbO1oxHbA4WJjqeWlmsDUbMwQOouB8HxYrWkr6jjAYZfoCADlIoOkSD3UCvFAzJM2b6ldNNFIOKlscCQCBdsjbv8fcqu2HOnQZGZiGeNE0FAYpZoeNAKLOhlSNIrWDwZ/ktl8fn2kGWT8/xT6VMxq26op8fGu7hEKgYlM1cw6SDdVGVKFoVJJG0zQnYAE3dQFhaS1b1fID5YPqlqmS+7Esvb8nA9B8KnlRRgmqSVtaSdjYvG0tlUHpZR+YhoUHaqa3W7JXMy009bSIHmIOjjN8KAES4BZKB7AN0E0brkKki56x2+XbRxcLS+GAQp9r+MxWDvyNwwWsN+zVQJkzTSgCoWi3ToheMXstqo440ICAYSmh7oTSWIBrsjPt0DHdYNi+PaQkck3NO/oU8+mkPH/eurMg48sgjN5tOgUg0jksuuUS2dyTQsUxymNPeuj4AD9dy4BU3YPfmsBaodB31ahUXlkZ25Xz6Nk2HF8V4K3pNq8iCtAqZcHMcDcJR8+Nw+3NrJFJbm5vJF5q2uU7DNRMAHWA4wHRoyaoyGKqtAEgoZXW7Rz0GRJJ43231Kar0tAeAyBqIRJ3J4E/CsgY6kDKhlwfACRgQbehmZqbSps4DuwnDL7waAxQBDDL+ptHgKbBToetZ/xp7Xw2tC2dTABIcO3wOAy9NvwCMFDInEI3qkz77sXBkV5Ox2RyQoS2bqpKMRplpaTBKYXHON1Sz/PaZvCcbq1mCiUHZpWU6WRQ3N2sVUrT7NAprtzIZDJhUIttTFNDLYFk9J4GhMhMwL68dFpaWOKdW7kssYqAE2IFeHG4uZpcC3FDZe6antUF28TAFSMlJZO0PoAMzOLJ0aFDn6RPMR8oQYGhz/1amLM6eANBRF4Fv/fqTGAl0LIOYSj2Hh1eq2N8ZymMhumsjpQIa3t0c3WXUtRrWRdbeE2A4+xHmRyMpS1+HRlZPq3ibem/Shu2xe2oENBAYbWgk5rqPikwGmQ7TPlA02h5It60pDrIOEI5Krd9YbeJQZTrULTR4dAg+n5fVeZ+/hwAlgxRTnS0BLhx0MDVDvw3DR2RKrMmtDVQYCDvGaliH9gAe8L3toOrQcK8zv2Eq6KiZKCMFGjoSdfYE2FC3Vq9tIaAxkavKaisal2HwLcpMVmWwHS9ko8xwkMcu9qqWdMuBrG4XMld2pFPCtVXYTZcVLgARA00bYR6OwaZBR+YHba2UhS8IzdfgNJ5LUSBFY8JSgFYADDvnavrq156xWq4LItOlQMR9PFh261IkOoh52k7BB9k7+x1a3ZJJ7sZi3Ae7zmhI1pIMJbNg8HjAO/TtCJ10Y6Axhb4dP/nOyr8npi6zoyOBjjHHFb+9Sq74jYp3pi5iIzAXk1IHan+bfqM2+TLtBvUarKXUm72DDGMtOApHNDkFj1atElPnQbsRlc4qta03faRV6OMQC0i5XhlEo9gSK1HaKEGFgVUps52BrGqDC9CqE1ZasFeKMh009Mpq0SfMwVCSuipDVUqP4APlsirRxD9SgBT9LgzgmorAAI51ADR0gFLgoa8oT0VovxRNlSjNX5tgaYEPQIHCDO09YumrADrcxVS34fO0ma41QMOTvTErGFcxr0uGo5T5CukRLA8mAxUsbemX2HesDZFsJauzgdyUD5T1KEV2bG2CCoViU3a6rYQC2o1l16zWWzLbAhAbsEx2tt2X6zetViBE0KAltSgegQC1H3QXtR6Hv7iMhKULL00FF1bdyiMMlgNpE+vm28hL4Rq0NItfZwRlPffssLJvLlDUaUQXtzKF15Gq31fmg+KQurJl2uKPV9wgF5/7e7nLfe487l1JscSRQMeY41v/cYpMbXhKJfblMM1GXTbrlS24Ws1xlCWyWrSpIMFu7A0haT1xYERaJe4UG1erRCBE/9ZGZIHVMGtz/Z5SWm3tndLtWGdUpFjAOrTVh8OH7TZ6rpgeA3sFkLG6pRoOJWsUiGhFyoCGYe44CmBBLw0yGbouWA02ZGMfFGUzoBDocqA1Uy9Ld3RCeqV+z58YlXjW6RKrHNElohPk/iD6Wcx+dK3bL70/bIBVSwsDH7BlNpfVGfZZAfArZI4jeUu6ksss0zOqAelX8CrF7yV3Iz3XcOA3s8ldVzLoPKqurOnge1q0TseEhnDoZrsp69IWvV9oGgeVMOBjcIqVaTFxhhqWGOK0ihUXukSlsTQTQxmtM2gso6203b3LkezSBPMBEzcKU7mgClfLLliZ2N6/TqmENCLMznC43aOGh15/w7SKSRFf/+i35aUfeZ6s2Ej5lZGRQMeY4/JfXyFTGbFQzoGHAwwTLKrFtOs2lL4OLAdEpayeUFaiKQrV5YJ2g+Ch9u2IwUfsvxBy/gAYnUi/4cvA5KujzqIc0KyPihuArer0leGgf4YyHwQR7K2CFvQ9Wpoj5YK/ddCvCDrw5D7DBAUqUMrAbpAdETR2K0OahKQLUxMKJgAAzEpEm66S6dDPSe1vpo9HLRytn6aHl1JBafOzmA1B9ZDqRdT4S9vTqGOpd6rN8rbMVYUKTpH+oPdFDTi06VtGxgfzN7ESB2wJfn+PVSt0y4CgotWTDRTh6DmHsylLavNKZtp92dRXkMDWPPigb/oe8CKolqEq1gGYnVMauTjD5Qxcfa3EpcTsrULLd0NWxXC6zkporWKG12FwydUt8dvBxsGhlMDIqSe7/mEQNtx/aArNwq74bdPkasXFIqtXZDHrLuNIoGPM8btf/F6mKWJmI3YgpXlS23w5vK8KBq1O20zA3I3UqlICY6EDmz7Smx9C6JdiaRdPn3hEYEPZltqbo9E51qsdCD7USZKsBjUDDjywCWU5dOxQK2/6atjr2tY8K1HcEIzLQzgpA1mTz8nalvZe4TJWq6mpF3MgJUuigz0m/D1jqSAwHc5qsMDGUlbZNhQicpi07/C0SxhOmV7RgVRBD4AF9B7KlWA9CF+RolKIxTMqa+nngXSKciQshTYAelM1S8aD38fmbD25Gd3hcfuqcpYVd6GHwSDOk9CVQQExqWfscJ4A3pByMWEp7nxsScN8jeo13GOM+19Xs6jWo6aGmM5zI9rcK1qsUorltE5mKGKjwRi2TyxhJbTBedc7EUOzhJ4uLRWYxt1npzTFcsl5l8lKjnG0tl8JkUDHGAO16CsezS+iTLbZWXYopQLxKICIl7ha/xSKR80MLPRT8Zb2aNQV91LBwOX+HVHTLn9CDzd8DhKxmNRGDURUraIpExOOWpkqgMdsp8+SWAAKHXrVIAzAYU1bO7xCm7A2n+c812ns0Jpn9Qr0G1q8qs3aKLgks6GGYKsoKNV0ElIdGMyhmQD4QKwaATS2+hxtRjO/ua37fKZvTM+hZbg6aKKsVpuyeYd4MEMZG8HNVaX0CZjQi6VNQAAh7QyYoKwvN2aVbCg7BG8ADQAGOHYoZFpl5cJgjfro/YKutJkCEDBhg8GMFUBpGYpKg1W3UmsxjGuiqNSaxeHHBHBgrFf0xBlSLe5Wa9VCQcQcNYwNKRgwLX3r0gumzszDcvh2UM9hKRc7A2wEZ9Vb9OyIzMKmqfvs9VfeIFf//lrZ7c63H/eupFjCSKBjzCY4U51WoQGVW2NaezFvMcomWWp3Hoh9ddyKthUZfrEfSjSgeBrFqlFigUPMfoSKlmBMxjrHIU5dH2thAob53qYerEe7NWAFCyopvENscA+Frbm5iWq6H6wE/Dm0pwpAinaIhVupqiIwDwMvG7cF7UYus6yo8WZsqrOYdbZhiQDHqPCqmc2BkUYY04OKGLAKTAjYmA0WJjOw1KM1uaVYqkr6WSGbKpF5acmaDGkn7eaCdAvsa3pggGjvnssmcjvQ/xTW6LcnNw+6lPqszmA0pixUr9RmcLBeB9MwKFBN0qYep4BTKffN9EMAphzsw4/Q8mcDHhnc0ewIB4bMRaVeweIsCEto6X1Wg1p8zJ4xce1xRQaPZw6UDB1cjWGx8lmuFz/uOoUyRXH+j3+9YkFHql4ZHSu/ld8Kju98tmnUMukRntAawjowHOTMTeFgyXaWyVqpYdRenhbTUS8VrVhxoBLd5I3ZUGv0iOmwp1fS5f60GzQeUC9aWoUjmotIS2l1BjT+AtjgszxSHzDwagNQ6HdANMn+J6bzQJWKAggFIvpEXDHdAnaDZbPWrA1CUpiAdaUvq8GQtKBxgGkW+q0oyEBFCliN1TZR37ENAYce8oVbrzbzv3h5NR9TBsSnNQBP9nsAPtbCyjzPpJPjtxWyOutpMzsyP1qds0N7ILdpbbBuuwoo2q6Vge4lR9rKypJ5/DW9sRraGgOGYKS01UnFKiMwC7S29xwJAJ+l0Px6cKaM1xx6s7QBEsznZUiU7MA19OEBm+FMiXvFWNWVOYLVQJspGDB6oZuNalc2929lSlgOj29/egXfI2MHwq2dJjAS0zHGuOGqG2VqYsjWufHPyazOXRxai+pcoKcpF7pN+g3dHvq0AmWhwyhv9DQTi74sKpENvVW4jAkI/V9DzJZAx9GGfsPKXjmQqbPoqiitAgDiFSpkK1hxAUvvnvZHYTqm4AC6Yz5vQlPThrifh6CDLLQHmkIBYwA2gxIEaFsprsQT/HhvRpsDIqOWoqiTY6wCSqRXAEBmJafYtM1fr43ikGpiuxRbjwwRtBjZgOdoLuuS/ehUhayqMpnP2rK+mKWeg5oMpnP0e5GSQSntxj762VrPGYAPpL2QfmG1KpurBEEota+sbqn3gdcA5mN58+DwS5n6IbNLdx1IJHTh8pp+sWssCKRNGOr26LjW+7YcqZMWZC12FP341kzHNKVY1l27bty7kGKJI4GOMQW6/02ViDR+cvNXM/6qPTla4T09OZg6iSpTvLGbW2m670aj02vdL6UBRpzZttLX5r4Nazfq7UE86k/YHEhNQAr/B6YSADA8tWLVJmvbc/TcQKM2XwasBwy/MEDiyduZjlZVaFsOVqsUtCwHC4BwhgNgg6WxGUCZLLvwFEwcw0JW3Gh8sAaoYmO2UueTTIL9eVXKRniTVEizzLNAeJC1pG9W4mXWkvmqw14t82wYlxOoVFWPXWsBOLD1do6/crJOKKkFVQEn0GyAfWhrIz66fFhJrAn+NLUH7YgdZwN8QfcD4TBcTKM0i3uWNGqK4+uRVuja6bYsKsmxD36dRsuS7bMGgSreadMqPS6htYO5TZmt5Ra//9UfpN/rSwcNIFdYJCHp6EigY4z/mDau3yRTF1HFCk2QvKts3M6efTG87DVnPpydZZl7t5u/azm8F4u3sPfKFGo8IhvzyIEU0SiR5fJIqdSVKnxyBatBlqOeuK9wBYUbJssdMa5oGSxsz1H6ir/xM1CNAiYE1uXw5tihNceyUn36VWYDIlMAD5qEMUsEdkO/Rf8LcSkUEsvXsmFLmA/qMMwB1ckBL/nFKzrRYnBeg0/zUvpY3hxDtSsLUkowBFPNBJIrOK64s6NoZTX8RLAkdR1t6WeVbBoAlBQyQAt5cxOtq45w3A140LjL9rptGg4ziasN44auJ8cC6u+lfVdwWRumJabw8lkXnbIXkF2Afsgo3UB6x3RM5ttBLxoTk7KSBf8mrKplmqI315ff/uySldnqPvl0jIyk6RhTTKWI1KIhjvPcNu7arryzNvZm5VkLBMzYigIt/BEGAhUCetUKKljoEOkmYVF1gZdBqqbD0i+u5fCGbjbRgwNiT6tSccZjpqNt6Gn8xe6x+Dp1FsUgp5oDuIkidaJVKCiRRdknOsaiuVvXxKJt6fEziCDBZIDRgFZjVa6ajh3yFt+vJDr9T4lO2XuNHXCh5UD1jeo8tPw3lzVkdtwcTStOyBZlfVmbbaLmA2XGOJZeWgwQiEZ6YJRwLnBSWmG+tqzD+QPjgTQXJrIfQ+eezf0ASuLUOt/XADVcU7Hl/lA/H03b1Sk99WtwjZK78LqmKXYa8xLwuscQj2nEdExbTPO9chIjgY4xxXc+/T2ZuvCWyqFSxL0KzPVRPdCN4TABqYnu+NTnj5D+OOnN2lw8YIl4F+xxm1GXssBu0AI7sr4GwOGTsAsLa10IGrrB2pyt6619PQYypE4AMFC1gvcYxFTfoaBDdR7YuDqOduiNqTZaGAyhOYDr6GoISyF8xABsKZXc28FnSBGsvEFmmPlYKDfVlAtEsWBxWIocyoG9MscEo/AyyeZZbjyb94g919DjRFNX7AVodvJMTzF9he6+6p2Cc7MKVUTskaNdf9t+TqEFCeWz0bUR/FmGqpsiozgvJaKoOYAGt7aNNUaeTjSBqgtKvSzbbdN9G24eRkbQbdnsfSQonab49gq9V3r1ymKmSYyUXhmjpmPqDMEQSKk40KAhWDTRm6Ml0oUhWK3pYDfTTtRjxZ4iCzdkiqoIsGxDB2KDgz6tLmxlr+mWoRJZS6+gv4rutVZBIH0ClgOpEXxOC3Sb6NBOJgOdYevS17X5nKyBP4cxHnhyZ/kn/TcwUNa9U+Ai6kZf3RXGbmyp3iP+RXnkrgrdCkpG/XSwbwnb6wxkY1VJjxWtOdkOpKX6KJ/NOtKuIDLVNBS6+6IEt51DPGq+HgAyeS4znUKqfi4Fy1IrltFiZ1ptrGMuuDELhgoX7xtLkar7cJiI00tkI7Gpmp8NlWybJbte89G1GXnWsEoLIuo+m8PU5mHe8r6+jKcyCtRNr9SY1pN2C5FAx5himpq8ZSO6yboSvzYIc6tyT5Y7xaw3X9503bjLy2jV8rIGD7Go1H04AiBRE6jG0ysitKu3p1t+NbQcym4AbLB7LJ7G8ZRsKRV2lWWKQJkLikKtl8psC+3nBzKLBm4t9eKEpbc/jWOZVWxZj1SK/wwTjyKtEhs8rPCIAceotAt+9yz1GNqRFoZhrE6SSqDgQMxIQV0HXp102KGaE8CPftaWHkzGqrZUBQBGJZ1yoGZxvN5UsQlWqg/PDvRZMcDBNE+rkp47ksasGIi1gRuG1T4dWjXlmg/7EQGMWAk31kXWhp1mNXtHjZKarNSl3CyXVaMwCqhhzKLoxV1BpOr1N2sUNi1x1cVXT1XFzqRHSq+MIdb/8SZZd91NMg0x3CWT78NN29qIR3nuIDLlwp4uqTumhqoBy4kHBtKfPOMr2jfj1SnxfAcoiLgzGr5ebROC/wNd2c2TA14a8JSA86XS/wXTJ2vyTZzHJ25jNaA5oK23lcuq4FQnBASjM9563gZgvN+WZl/jjIUVLq5pUD2Lik2tXBgsh5UM63stR1a2SF1GtVGeHmtTZFLEi+PuwBChBU/Qdwy0dJZpGWVGVFhqyCACoNph2DQaBLCWegNo6ETzg8lcZEAXAReYhXk6JbAcVp2l6cYazDTt0a1njqckrVQ2jmnpQDu3YV6uvew6WWmR0iujIzEdY4hLL7hcpiqGymQb/Vf4cAfWIDIEi9gP74vS4Je9HNb+9vs2kyHxsjG4iCnvYBSGwSa2O8dA4z4cCozIcgB8QGTITZgbKf0eKmoG4ELayeCgiR4gWvo6m82blgMCUhVEsmMsn88hitSd95QKxq7ZfPweHNszYuYDTEHHwCj0LIARYDo2VtC+ZOzfgjOgZbFYBumyQgZoCFeRGzKL+Yxpt5myT8YBpbR67LVNXa9oS6edyaCAADiTAs2E2Wm4Yuol1FeDDWEJa8RoNKpYzPM9fFbrN8iCRaeRAMWICau8tuVr/YYyGDXoVjxhHh6oL471HMEoZDpAB+LSC66QXe+0wpxJU/XKyEhMxxjiZ989T6YlYkq0IaewNvZMnZjwMzg2xpoL3K+HDcFk6IkyFgLG6/oYYgJB34cw4HkprbevxyBgfVU8paJW7dpzBU/F2A/qMqz3CoSLfKq2bbAiBU/kWN6av0EwCnYErMfqrJQdrGIDwMN9KwA4VqJodCmD2osMZa45S2vJSJirKYSlAHw4Qqhs6Uif+g6ITAH0wG4os1SEFBdSW6wwsqojrA2BKf6mzbmZhrklu5/zgG7tmgrGXNE1GYSiQQfka9l/4+vYPMj8WvYy7wYwDqmaqKSW/z6sJtdaBsRXyDSlG37ynZ/KyotsCabJi8R0jCFuvuFmmZYI2fBhhsOaumm7cjMICxR0NEGhaYZg7K/iYtJggV4PAmz2FvtxeDFBo4W9GylE5bGm56DRk3eQNT8HZcC1Y6yWz+ogRLqeKRZrP+/mYewZArbDGspZtQq7xVLHYb1SrKeKGn+pqHJaYrSZmLEE9OcyABeqQdDqHrbp8NbosU9LblRXL2/LTDGQIlMmA1tyO3ScF2g5igruKK1gN+/CCjUENUBijFZhnXC1SVxFIadev1Yya34jfm1pEzfvKhv5vpj+NDifW2NC/xdB9mMQs3r1wmA7AMqZPqGpScQKRixHpDSZ+Nh0s1m0pljxkUDHGOLyKRSRNjrKujAu3GhtwmCDmzNGZpaDqIhUQYXdrG171vms7psSta+PfRSgF3DJXdxvq6HjsHXzVqZ5fvg3mD8HXqHlYGksPTj06RlgAuDCAQWqU+gPIZXMSF/f2zfTBIyOo+pNgeHRh1k80eNJfloGjy0xE0MX2i4En6QRSoEUt41BFh4pqFypBl4wq9bxWV82lW2pUM2SAWQAeKgjKc7ZXAHmSakIDOb99kAGRUv9Vyg4tappTkFNrC+tKI3ilS2m92S5rJMiICMAiNHmfijrURVmA2/pFFbPtHLJYUTWWLCpd3LwA1FR1TdjOgcf+HyK0itX/OZKWXGR0isjI4GOMcTUaTqGy2ZjoVxcvQKPDhp/6ROgi0X1Rj2cetH14/JY7XFhXxg9jWo3UU+91E6TC+htNgHDAFSyMVjoJgvtB6l4lMZaczE+CathFSpV4I4Jw681rTmmUzBPJ+3JMssGZard8IoVBJ7mp4km31JAguMD1sGdwtnmxEppkapCO3scU8hPgRNmy4H0K/IUdg1oIzdoQIBdWXYNxqRAI76BzLc7du0BPaAsE+1O/BqLrpWQftOLyVN1ATgNX29x11n8DRASX3Om5fEutoHpCEZhbGvbFFqbaZgDkmkRkMZx2Uq8ZybQMTKSpmM7B/oIXHXxNTKN4TfLUKHSKD/U9IpWS9Ze0nUDN3sW9nm8ctUqu0FNDw0CPojoOOTajcZONUzB2G/L7LJpVW4AQ79aqXjvJqsVj6rrABMCczAMhFhP3UbBgEDLob+7a/oENcLStAqASIrodHivVRuc3SxMe8/opKJRZZJ0QgWRNt+DlkNZKU15hVSZpcBUuwEgoqXQnkYrjWFRPY9/P5ZR0BEqp/ziGtYQeT/DmNFzMWjciDCIo4fMxgrzhOF1PCQmHeVMOmXxxytukI03TWHbiAmMBDq2c1z26yukhGR+WiLy5whP9GzupiWDgS6mZiNq6IYnU++v4jdzKyogDd5o5IacvM7jkbVBgEDFnSB9G6REDGRYH5QgIoX404SGWsmrAlIdvDy9rmkXenOwxkKTPgAYsEFHyaYPEZ56YfqFY4wOmhCNosX7av7+cZyU5R3uXTqTmx08SolzT0NZibEBP4p4vdcNKoOY6rKyWohOCT70HIJxwlws612A2cjPGr7SJj3YoNd5k4avi82LAXEo145Te5EY1a9Tf/KtUyS+flQ2HkQgJmq1dKSvE8qpp/DCuXilNchMre1HRkqvbOe44cobpzKlwhy06zmsVT1FpJzQawXlsrVXAX0MzDJagYjZRbtltGsxGm3q67JY6gyxPsshh7rQxh4LQReClIq2rkcJJRgOEPzwdmDvFPZPgS9HpVUTrXn2+WDXWMH8vswK3Eh1eepB7Clc+4jUtuwc9Ky5W4pbFpayisUyC304ltK/I5f5qqSuoxaPItU1EHi/or6IzIU11cN8pGNwsjGvYJoM16O6jvL6wyBfQc8jMhhEFSQEo17F4gxHnVoJTF1Y3n9PDTg87aLCUtV20EAMxmA9naepwcirxj07kNpD2jG6Vvi3KlenyiTsxuvWy0qK1GV2dCTQsZ3jhqvXyTTEsINgQ/SGrpkhl+09WOqHvlAZ0MiJNp8OM2M9gldHvFh4H1PRtYukP5zajlk6pVmRwPb11rzLTcI4iEHvQUCBIaxSl1GWxQJs4FVLZDHRu8O6x8KPA4aTBBtsOJoAR33KVHMTKliiE6rVLLX+BxgSyo1ucCxVYKcda0W65UDmsxaPf5UNeI108xYrjfpVLh2AWCulBtuBqhcKgPMWrdHzPKMb7aBqNQShJMicFzZHU28q2BCOuk7ItR3GonBZXs+RFwi2CRDtT8R0QTcRddHi9/DfDQXWBkqwCJxJb+Hf2qTGjVNy75z0SKBjO8cNV904laZgZDp8HrvKWr7cSgIoqnOxHh7emI/wMkGjqx2kRPf2kDave23p5xG74akVrWhR4aDul+fktTRWH2hdsKcupLYHVulglL4BELXZxtM00jDG5gQjMDUDU2JGf7tWVExOX5VtbZfu83DcoX9x3IrjDvCwuiqkLNXq3MXGSId1SpybkoyGSiIq6jz6sFjH+QJjgi607DqLvyGpUNCj5bO4XGoGQ4Gwl6rWe+wvwT9sWE8Ufk/zc/6+oGXWlBGrYbxihtdHnflW195aTFpNqUnY9Svt3pmEpCMjgY7tHCvuH85SRKS6d0aBs+1Gv/BmrRoLZx2Ct0EQ6kXL8sHRDa+HKlKizQbjptClthYBOn3uk+4VtABRyp77rt4PFJEasPBlVUeg77WpGwZKPIXrkOggA39ryWyKP3nZ2FkDaMMxQ6pEMSKOr1YCgWlC3xXtsAKRrgJEXBH4r2LP+txRSBqqYlQsXCdEzIDLRMS+BwQFjWt0oYmdUm+235G/iHt6+HreoyV8FhoO1p1tg/CE4NzKaDWXM7VC0hX5wBY6TC5i/QmMJCTdznH+Gb+WaYjGk3wsJPWeE6HbrIkchpT/Wk7oTIb5RPqTYOOLIsbC34cnU38SNTARlo2EpAQi8WBTEzTKbmCg8vEE6ZSyUcWi40ZUGWHLaRM4rXDxscR3L2k5bsV15GyHvVewoG3cqI3hsdbiWmWTKmlHTdNCBQvNxlRno9kRTZWp62wk1XBQEIs/HRSEK6/5CIvrq3a/bQpJwxqx8NnQdNhKyBFGUwAmUcdZY8iGxaTTwpqdf8ZF496FFEsQienYzjEtZV+xE2kjos6xeiO1Z08HGX7fdSU/8xNYzBu8GWsS38Rj8aj/3RgafD2zPqezaZ1+UbBhnWPNEAxt7ENfFf7tqRUViUJHoOkTrVqhgFTUq4OmYBWMxAxwRMAj/YO7tddRSEAEzw49phlTJHoK1ZwNx55ajazFc82qFRiFofMKls/UEAznkv4cAIswesvadt7dMVc1R7wWzVCFl3G/ma4LGRbfsXCN1yDDC6bsKjShqCEP6DzM/t+dTYPgmS/2byRc1BHQGfVvbcJj0wq7d4Znm0WsP4mR7oHbOWAWNA2hD2qx+VfkOhoYAaelobZr10CE5bSev671GC409Ztz6AIaHkvjG7aJExsMp39/tCy2gQajFI6q+RerV9BllIy39eewp04sSy+IHFMhXemFdItrPVA2q4Oce3GYySqnaRgetoXWA14dNYugIuKMvdBYfESLdJ1QrdJVQ3PqP9jTp8xkDnob651jFnT08+i3WAxtF1fJc9zDhRWTD+5OCqdUT4m4M+moc6r5noYNTDWwaziAEWhKHFy7QYw3k7N0C2UppnVi8zdjcSJb9Gm5ooqVZjWQNB0jI4GO7RxTpemI23M3gEeUSjG9A91F6atR25bzZsvaxzAjLBuXKQ6LSL1sMdz0o/lhcIkGE9pZR+l6POnSKiSWiHj6JIwNLiBFysWewk33Ues99IkcPVbwDw2t2lNq5U9HXMkS+12wfJanFcJj9ElBp1iwTgYObcKyYKfAObXLkt1jPU0Xp9FMKVQ3+MNlWtb9VWIdh8sqGgJRflV9HTaus2GdUgDgQyUxvv1Iz8TyXW8PYKkW6p/ICnq7WhVjT5OQdMVVryRNx8hImo7tGIP+QG66fnqavXkE8Vv05Fj5U0toCW4AwwGF2ZtzfV9uGIy49sO3HfPMzdR4TIFETyBmCkYmI1MSBPoOq3iocY0KYNVpVFus69AH3QbcIlRn4CJSnXQwdICi4GNankmXPrSyJPbPssZ7POZqBoa0lrJTACia+gLz5MAFfinuNOuKCiXVap0P9R5uFBYJSoMgVHemrq8ZBhhRBUoA1QFkxw67XMq600Yzzd0u8BcEHAYuYq+O8G9qeq6puY3zsmH9xnHvRopFRgId25nlmAb1+fAN0T06WAZoxmB8kvOqFusc69bmoXtseErUCYZKbrLEz4YYC68gCH1W4tw3KwKc6w51uFouCxdSNnpTWlsdLOH9oEJSXQz+G6rdQFMxByyY58ur2RS0ITAEQ5ol56Doz+1a2JniT8Uttb9jJVAAc5BFqK28cwAOGGnQ5ub5No8lstBrsArEBZkOEi2VEXoSelfZ+iJyoamnS6KaqZGgN9S/+LUYa6t9dsRweFV4AMyWjgwVXtR+2L+pKb2Mrr/yBlkxUS3BNIGRQMd2jJtv3CBTF66+96c/sz8PLe3Z1j7qPhv3UInEpBTbeZVL7D5qVSlBa8fJy2sjYZ7T2rEzKc2ZahYjaFxpf15JJ0za9E0ttbWCpQvtB5q4mRmYu5Yi1YKGZOizgvJNtq7n31M8UmxFxF1nR4W7c9TiXAUO3o8FjBQEpojgmUIwqMIKt7LXKiOYiEWsl4mKA0fi149dQxwPjKELgmZL4TQEzkyVRONHWFZfqTeJql+c9eNkxmN1XyGr6mochBHMx4THupXkSppAx8hIoGM7xqA3kKmJEU9ktbi0+UGdAqki3Ybe6OsUi30WbW/kbTaUGkYbDk+JQ8LA0Gpcv0/z+3rjV5a7Zkac8KZkNLQRNTliRLjEPy1ki9x2YckO7vSxHQ4BtEuv9mEBqMusURu7+LLHjU7akE8BYiekWeBICvFood2CzegNG601zF4+nVFM3Gjq5gxbqDCx1IsLmocBbVyRoqa7CqAjK3+ul+XqTGqVWvz9dCYFIDdmkDvn4qZan+J/T0uUUyLEn+RIoGM7Rm8ONXfTFRygGxbo9lTnEevwbJQODo+xWD3yNQjOjQ3AsnCbYT2CF3tqHRbAG6DAf0tDOOrdkAe3a9V01BoPPDOrl5OuByI/NOiyJ26lwe3JlMtOz8CwrcLTDHU2wpsJmkDUKlJwLtQYrL5QCo7+Lq3w6pWoDb1tVN9H4owYcAw1KObH1TD7EOk6GsuNZsyp9/Cg5fkocGogPO6zMqVGYSvqHpqYjpGRqle2Y6yofzBLFQYW6qcyvXmOvIFbCWLtqGQgxUtJPNxmwVMx8eCx2f2IKPLoyxvsBAaQqAQRIKRZtOD0u8gAT6cGNPCZKghqRkSflmt9bIoljNBBOMqahYtApLDSEz0jlZ4rFwc70+aXl6Vo/D3AprMU4ZLx0lheMNiGg5zImdTDrt/A8/Fa9SZB9bXIayUq3+Yl2QActTiE4GKosVtIvUwZ8OjN9WTFRKpeGRmJ6diO0V9J/2CWKOoBfejmyJto3WWDi9hHTfygHUAX5mm0RDU8mHosYFGirQ7nPmIBqo0wWi6pbdDZhyP023ILbhPGMi9f+z1gHXctHWa7A3OTYmki6nfSnFBG64APiuKKDEds0qTCUXUldWdSZThUXNq8+kxM2iQYoktsSHkSvXGhc7h2hy4AFVeHbw9AuGGQxwupXMBw2CEYIvSm4wrrT+OD24RFYjq2Y1x7+fUyFREL3PzmGOycVTyaIV8dLM+jUsJIQBpy33YDrxMYWsECY6hhYWnYxjB4Ye7e6im9pT3DqZWwZWmbaFRf1fDLy2BdZJhbbxV2mcWEv32ZBYNhAh1LGaF1vF9udrJxXnAO0NYNDd/cpj44zUY0GgXBuYKNEuZg/c1w4iyTiZCGybKq4WyKX4fDjIYxXfHTHQEONEY0G4s0RtF1omk59fbAv5UYmOiCkV/NFLEdV11yrayUSI6ko2PqmI4Pf/jDsvfee8vs7KwcfPDBcuaZZ2637161ZlamIQKBEPqruKrORXrRkgPjlF0w55Uu/l8TkzJv7yYMVnmrdtLDX2qpF4ouVOTX4M8jTwZm/WGTDWBhLqTQ69XajnpoQ1MxVEWwdT2cSGGfnZt2oMFkqBYERladaEqw49ZHzCPE5wLt3TqS02ytPr52jUSpEQALP1c4b6gqglcH2Y9wvdQ9W+rrALjYIEDMhvlrXD3F0lrVYkQ7PnJZvw6b+p7IkXTYkZfpl2GKpDba8z4s0xRrd14tKyaSpmNkTBXoOPHEE+Woo46SY445Rs455xy53/3uJ4cddphcc8012+X7V1Q+crGxGaFbMAWz4D0zqlwJafImj+1Lh4fPcF83BvqWlo3fL1D3IZEC2mToEbWIxIR+Xx9YvWMsGGUixsenUA1TP437uDNlY8OSR1TAGrFH+j+6owSwYV1kg8inToFhlmtvfDsInOt6XX1dcPkNXzueriHmGKq18WsymhmaF0apQr9aRhIV9OdobnJUmmWBUHvCYyp1cdv4wfqLX/yi7Lffflz+Pve5j3zrW9+SbRlTBTre+973ynOf+1x59rOfLfe85z3luOOOk9WrV8snP/nJ7fL9U/cPZhTwCG6kQ5K5WGwX6/MWrh4tZE+4gXIeWijc6UOOZwix1EpBmkVxW67JyKQovQJCBy24ig5YMutgIi65rVkc3x33Lk14Y2nCh/amhKduBOcnlnoN4xPi4z/w9b1iiZodM2+LOhWHbvK+bJzziOz39USPOLtmMlajaBOUxrbpEbBecBMuhnoTmQ368I+fNsAxlffQbfxgfdppp8nTnvY0ec5zniM//elP5UlPehKn8847T7ZVTA3o6PV6cvbZZ8uhhx4a5uV5zvenn376guXn5+dl/fr1jWnR+zBt/2CGH++j+zV6ZsSfcx4qVex9NRIg2J/OjHj4eDFUJrJgwHdUMKLSBaDDLbAdZJAFIRhx2l4HgzB4RRuh0sOeroMMxY1Qt+LQpdABOk6xxFcHsw+RC2kNUuvOLd7YDf8jmzGUCgNxYEm2cD1gmyoorRcM4/rw9expvPhCizXPDoQpKK1xr38WSzTCKnWddn0Fk/WwpYYxxpRRaCuJLQ7PNFs7ybZ/sP7ABz4gj3/84+VVr3qV7L///vLWt75VHvCAB8iHPvQh2VYxNffD6667ToqikN12260xH++vuuqqBcsfe+yxstNOO4Vpr732WvQ+XPP77ZPGWXbhd22nhP0prywaSktNlUR31civI1DT/hEBhtHgEaHRqDQY+mPh4FGXvNYAosm4aPpEBaL1PkXpl1BiC78OHcC8hbkR9VaKOV1PpEsVDWbA/iaYcw1mNMLjPGknnObtGhoOGL7VZbCoXlE5sJ93AEr36AjsBpm6+tvriHMvIVdSX+Y+WXl2o0W573jMcLgYNKRUomuRyCjaD9uv+rqbrrjyd1fLiolgT7uISWTBwy8eiJfiwRqB+fHyCDAjm1t+KWJqQMetjaOPPlrWrVsXpssuu2zR29xt711lKiNQ0jE9DgFda4HYilbnw/d2Bx9xVYz1aRl+VNS24/b30B/xAOVPknFFjGs8HGz4skirgK7Xtzr0wc3SkZInWVrOjmi+xkCNU/rTOEQsPkYxHTEDUg/02sFX6zzqrrJsAqd++REYyLWhW6S8QXl0YDjcjMuAin+DbXLomqsrUBqn2BHRMNaMrPwNN+viqGYJC0UbQhVXnDk0ofW0MRwee9xtd5m22GuvvRoPwHggXooHawTm35rllyKmpmR2l112kVarJVdf3UTKeL/77gsv5JmZGU5LGd3ZrkxVxC3o+d5ecDP3hm/xRw0TMBsQhqhrXR//rQHMgofR+IlzaF4sWI1DW9fbYOPVK6iyZZM4f7hUd1N4dji4cNEoqXwDIM6+aH+QERrXFIuyQydejQTFLvp0h9KWt7LnmA24CPeOTnh69HNJ4FHoslrRXUpV1ELTIBaNRaCxQcgorgEn3MxC3FK/UeIbA+TgN0IjmNrsbCj9B6ARrmP79xSYsylj0LqzHVkxMSKNe6vC1sUD74477hhmL/W4tL1japiObrcrBx54oJxyyilhXlmWfP+Qhzxk++zDSvoHsxQxqqRvmM3wf1s2L0qgRD0u6g9YaOIz4hvuqCu5wWs3Kweix96654ppOzwJxEEoPCGrZgNPzvXqCnnUv6NJ2tjD7KLvOylGh4pH66MbV5uwr6CqM6KSZu0WPGwOGhgPG9VrZ9PmNVrrRqrIObSpK4p2bGFub1S4xiim4vKRwg3JwAq6zin+dzVljMeKenCrlmASIeCIp82Bjlv7YI3A/Fuz/FLE1IAOBFS9H//4x+Uzn/mMnH/++fLCF75QNmzYQNHN9oipAh3+RBbNUjYjepKMAUeUevFmb+EmG7YZWYw31h++T/sI4V05bMkR9+e4WiXeq3YEWPwveDl4OkU9S/1rnOHQSS0ZIiOz6Xsg3eahEGII2BkOZXrLGqJ5QkazGvFaCjARaiJWAw+9Hqz2aBhJ6pq2nOt6hnbOgMcwAzcSh8To1L98ATtoVWBgPIYPxJRdWFN1D90OD9aYHy+POPnkk7fpg/jUpFcQT3nKU+Taa6+VN77xjcxZHXDAAXLSSSctyGltq5hfQcrrJYm4pM/cFfXvsIAaIeHxE2W0AVHEzl8OXjSJUY/0o1InNgY4904Bqn1oD4r1cnW1CUtji7i6wcWf3rANXU0Llsv2q1xamMoW8/CNB1Nuv+A2+nEPFslkVXPUSrHIywr/knpS8ThrFUvUxs1Aguo0RHplS3oVkixq3MZrKWawrGQWlyCuBS2Z9aY5Q7k4/xPXFoSfdd5j9L6Ww6a3MTtSpxj5X90Bq8BZSNRxb5GGmTKgEcdN198kKyXG4Uh61FFHyRFHHCEHHXSQPOhBD5L3v//9jQfrww8/XO54xzsGXchLX/pSeeQjHynvec975AlPeIKccMIJ8pOf/EQ+9rGPybaKqQIdiCOPPJLTOOK2u99GpiHoWTGitT2V+AUqVpC/BmVs3VmHKUXkxNHC2jht5N2lvbBPK7BFEdMJXgUzlNPgn/RNj74DjpO0Qtd9qH3Yc1Y79Eu4VoJKz6Rt4w+VG6iEsGqIQZVzMMuyllmjw/ESUkZ9oq4nHRSjxuQpFnN9jUhZ4Pj3AArjqWzJoML5wECtRva4pgAq+lUmgxLLZJzYhbZRNWAXEk0/smiKND8xJCHFYp9HQAPXqGcJw/ULsIILl8vZRcwKqeY2qQUpBvpvJkxWRWXVK9MGP3a/6+5Tp+lYygfrSy+9lBUtHg996EPl+OOPlze84Q3yute9TvbZZx/56le/Kve+971lW8XUgY5xxjRSgw0SIA5LqfjNNV4+PDv6UynBydBGiRMayZOFX8SZfmuOUzU2EsRiRNdoWNM3BSMFta3qSJ1H5bk1AxIoF+oIbOtDpMaChnUpFhV6eI2NcgyJ419pSqQGGZbyitIvAMNIndWwQYd6Wt+Hc2sVI3mmTqeNiyQ+kXGVifZlCaDBPTisR0pYEkyFiZMbHYntuom/K0MqkoxfseArm9nETKoSuqLJv8im8R66lA/Wp5566oJ5f/u3f8tpe8VUaTrGHStKBLVUMewnwHz36J4RQZ8Rf9QoJazvtjre6xNiGORv6Wpu5OZHlDJyNjrLun26tbEPFLzd3G24a4PNiN7XAtOoNDP8/thGLMViQ0+3piYC0WVunxD1Nq44gAxahHolic32bfFc6zlXHDzkMBcvHHYggrpDlh0LwG9AH0MbtNKVBoU+hK255FAJuS8Q2JUpixUFOqolmCYwEtOxHWNF/YNZoggN3zzQ1C2+izuI4Gcm/jTmmV4c/g+PaRjTd9ijoT1cxnx0Y5v+huu5IK8xgHj+36tQNFjxYK6XdSrevRu0MgKvDjPcn8OfW0MrGKaZtLmYZemX8tBObTgzxoQb2Q3PZqguR706Io0HzlmJSiTXcqh2R6uOXFOh504xb5QqkeHciFeN+NvaiyVmIZSxsGvKyTAnvJx4GyIxvHqlcaUYOzPMbHgFy7TpO1bSg1vqMjs6EtOxHaPVmaKsfiyQ81mejRj6oE5HGMtg6Yi49iS4UVrqfeH3xa+e/nCxnn5JuD/702IwH0N5bK3zC4Ajegp2Tw7oNkK1iu1V/b7JcHijt3pQTLH4y0qtz4NfR2A86uPvtUXag8VSJZlIOwPwiHqrZAAZWhkyTIRpX5aI1RgGtpxX+7I0lovSOfWyI+62Lh/BTwm1vJbm0TKc8D0N//YR/7amBc7G5n8pVmYkpmM7xo6320GmLqzpmxZ2mJAUI3xZSIWKkUFBkaiOBmVtxFFz5nwaxM1GKwEicyboAr2HRdRDjjdwFAHkUfMTrOc3ctumyjYyKVv4auTvNYePCoZBiQGpxQqIluTSznLplbnMSEv6NJzK2b6+n2fSQ/VLjjlYspCetKQlBQWo1HOweCaTrj62ju9cTEDg9PWqSvo+oYIFFSoQ/1aZ9CtUqoCLymW+xNTS6pWyRWHpPAWkLROR5nzFue/1cylxLeA6KA1I4LwGYbMLRGPBaM2iqa1/UBzXOzs0VYNKcrc8p4DUAAaFpREiAjODNgHQalhFC5fFvx+vCptCg7CddqlNspZ9RFbmW73+BEbCjdsxbrPrTlMh9qpLY6ObYfA0sBsqgIg6MfHmS9Dg7U1KVf0HUZ1tLi+HPpOhvLhSEZbvt21F8xs3gdCVLZOywMCjgw/2syhbUlQtK7H0lA4GtI4MpMVJn0gx0HUAL3R5VLIQdrSkz/4s+lTuWaIRaoEUWxlhHCfw8K6yKgjFeUBlEc4PBKU4NzxvPEddnkumx3DuecFoCgx/QzDMbZRDlFqoaHEJKq67ZvdYbtYNb8P12RSXNiRLvq5vE0CEk17nADKaQgEYr0FGI90ft8OdgrjdHreVFRNJ0zEyEujYjtFqt2TH262VqQm7ITb8OVyZT+rCb7z2R7gj+xOfruazavkeKlpc52EsioOTGID4JmIzjUado9tiqxhUUyr6lMuGYKEsUQczfAafDv9dGKDwZA0Kn+AClHwg99V8u16/ksEUPZFuqwCQ8yuhDASEMhs0sg/pLGU9vMoF5w9ltH4eFSZoCkWb91lHF7e7j/qwhAHdr1f+bcqS4YEluga18d/QdR9f0w42XOMRMjSWLLJ8n/ZbqUFHQ0Q6RdfU7OoZWbV2VlZKLKrDbLU4j4/lHAl0bOe4ze47yzQFAUeDDnaGw2+Y5rYYOoCCfva141acft/VFEXMbiy479qTZzxe+PxGP3EHJuZL5oOIPh1Hq1jppTZy023i7wGperyqJbeCD5ts1xVslDKgj4R2Qk2xdYFzP890SqksEo+tngtMRaSzAbhg6sR8WJglgaGbAUhlsHRZbAvnXK9X03cwHTcCTMTknb2JmTWb0Vg2wKSG6EdHpaD/CYyHG9vFF2jU6M2v/ym9d04DUzzpkTQdKbZJqCCvVtfXT2cu8jRTMI7OlgunIZgJNEqjvY158IoWYpi6watut2NIIL7ROxXdeBJdCDj0hq46jozfqdsqilyyjrEWBji4ei4yX7VVN8LSX5FB1dNBDyZTWBfakLziz+n7PtpXQ4Mwk26cWxVIowBkoGJpEDEdAH5gKzANDIAgvTIvXZmvOtLPWkyd8TMTBysbpRcRGKtBkXFCWgXSopFBNOOqYLseYg3HECiRkCbRS49ajlDZglcrpqamw91IzVwvxhzD+o3AskwZgF1peGP4etia9ScwEujYzrHjbXeYzvtDrPOgmNQcHqmD8JtpxFy4qI45Cu3uyps4lo9uyGQTaEldZ0w4lkSFQm73xf/6NqNQOh35f33i1TGgJb1Cu6jomrl0oOEoW9LJSikwkLFCAgLTjvTyQQBBeL7uSFsGlJQ2tYduirrS7p/LIVwjU8SXBoCdtKQnbeljqtrSq9oyV3YCsMA5gs4GB56i0kJFwRCS4u/BIHKa9bSKn6x4MrBhKp+6uio+wS7eKSua3gaq3DFCEIwO/ZCh9AsvaHchpcDaxKQWKkearqtoh9uskRUVi02RVDKRkdIr2zn2feDdZBpiuPW2Dui4yZr6vrT3CNdvRGkYajWi/LmWpja1HfyI/xkSk/KJtGY+1N/DBoiG1bVtFNUKAXw4/gF9bwORdTTFK56gdSDTJ2uOIxSNam8PXVYHOug/kAIoImN0/Z4JvZtsw8BxVILLe61YeoV1RE5A1GkW77PiwlLX2uj6fg4VZHjZayh99fb1jEjbEQBHLSL1CzMWkOpr01uD8028rEDErmnXNNk1HxhAYwn130wtJPV5gemYIq+OfR+4z7h3IcUSRAId2zluMyX9V0aFplui9yFPbTNC/jy6wXtlQGS41GBETAcS1l/QcbbWanAw8d4ZkWkIHipdPMgnXRo+QddRd5LFU6UPYDqI6cDlgxioe3eL8MEPwkV/QNad0D6nACEpbl0ocNNjiHAioh+dhyJKrVBUGuts7Lw5cvWUGXQ5ONeq5XBjt0hIOiwU5bkc0f1lWDAqQ+k9exOEpF754tfGUHqQV33DObeaGqvzzcVtV5oerlqCaQIjgY7tHCvuH85iIu4wO5STbghMcTPlk18tKA1sCP72O3X0D7Fx6w1gJfrcae5QemvMCRq5ec4+sCHoXeG7a8/D3C1vMlfrOgg6rBMpEixVNNAp3qF9mE0o0bTvhv+HCSB7McuT4k8Gy2JLaGRKVgCpUBQiUjvG1m6PwIPlslpRhHmAJFoCq+eIAlK7JigOtnRaqF4B6xVSKfH11RSLKithuo2hU6kpl/pNABaRl0yALX59xBc15xnE8rxMhF6cEWn8G5uCWHH3zgQ6RkbSdGzn2Hm3nWQawq2bw300Vty7rbM/EXLED2QAgw7RXn3ioj0DE36/Dw998X136GkxKhWoGZJGfsZSMy7qM0Eo9h/+IarvULq+gJYDrEau1D1MpvrkOXKqN3oQvuZqwq1bKmWOptyFZGUpXVjAQ4eSq6C0m5QdWxQAGvNgNdjSHqCtlE0VBL3o8pvJfNVieezADMLmyraZgSkAgT4TRmEQieJcunspACH0HGoIpiDEWZC6ZX18XdUpuZCB8XmNi72++vwKDOnCGDQ7AI/+XehnkSeHu5HG1zXN9WqNx7SwH9Ny75z0SKBjO8ft7rDC0PoiItxYmfOuWQ0Vz+ER0QSleaVOi7DwZAWLNeiCkJNqPLsh47OQwLdW9X6v5jbtpu1jg9XeBgzi67qBhu9kC9+fETjQZpmdZUFlQHTYNlZGRajoUDpfooeOWmhjFIE9GAzC5qRL+IFVITZV03QYUwFkFNJmCYMOeKjCaNMbZDoGjK0N1W3oQIwUC5giVrGQ4YBMV7vJAlwMIN6t2tIH6KCgtCPzZVs2VrOcD3ioYKRDkKIgBK6k9d/9AQZ0u2hcQFptxonUDLx43dWmITy5eSxAjbflLe19mz1zHA3VK1DGWgt7b2XvzJgDjfh1imLn268gN9LIp2Mx609ipPTKdo4977EHTcKmJqISv1o4WqvxdR5cSUvJBurIqPbnmeSRO6P6FqgbKW7otSupEuN5pc26iDPsqZMlicZkBD0IqZJI0+HUB6dcigKpFk2HsJSS7qSaTlF9qosVc1ZNKPutrpeomIA3hLI4rv9Qp1KAjMosvOf4pF7KBjqzju/ULPfAsdlgx2o+FHxU0qOhV31scd6Y4oLteYXnKNPf4BzZMq73cOzKEltLn9V42Lqw0bPDGYxaeKzXkbEgcMYl6KidSHltcqXIqRTzbFm7MupUH/fHXUhNPE2QYa0Eq7o0y9OTDRHplMVd7nOnce9CiiWIBDq2c7Q7bbnDXXeVaQyngSGIq6nluiFbEOh5e1fYozuw8PSMi+9qdaaV4UZtxofNv7ySQDt5NdMxTm3Ystg1VvMG+wRLt5hMlFS8iRKxXbyC3gelP1e0Za5q6XpkOXSwg/ZALD3Qtyd3Uvt8Yp++wWNLA8yGHyv+jWPG4wYQV1epYMIRxnnYVHQIPLSiCH1x2mYGVruR0siN51VZEk+p4DzXDQKxB2aF7vMDQnEQG11LUSPDWNjs12pMrPk17+mZUPrq7Ees8/B/F9G/mWkEHLff83ayau2qce9GiiWIBDrGEHvtd0eZtlhg3Rz1XgkiDbAdbEVvzqQEKC65q6tW/O5OIOLZGDdRskX9tfZUiER7w8LTMIColgNPzMj1g2rvD7Q5GKy2OZ+TDlBsKlZ1SOPDHwI+ERuKVRz05qq2bOKkPVzwCh2HM+xuFQIQkkSlCwPHBKyQuAEYwUbF8R+lyPPS4THWqSWbyrbcXM4yxQJ2A+eDKZeqPmd4pfmXVSbh3PYLm2fC4QUl1XHjHE+L+PtwTcX419i5+BqsFl67qhXV5m+x0BTanwXuvY6ArZ19+Dc0RbHnvnvIioskJB0ZSdMxhtjjbrvLtISL6IIzqeeiIcbjTbz2J5AWrEGxUJ2rzlpa0hjEpAFcRJoOI0dgAaJuXDU7zh5u6gvV9PfwHHy0o1yNosK8bm2PwW+QSw/7lrc1bQNtR15SL4B26UyfZLm0qpZI1ueACPkoBKYqI0FJLTQGgC7a4wWqEAw3eIIHA9KZUmvrUYFjrgDNrpnIlwPCUfT9VZlEK0w96RjhpToaT70A4GmXWWg9tANtr2jJfB+MFK7B2hiMuBbsGjQars8wLYan7cJZcrAbTzZP0y41nvYKlwVOpEilDGxS1FMDjODR4V4yUTpyCtmOlcgOJ03H6EigYwyxwxQ1fQsDaVwmi3BX0sA7s6e8ZBjcY5MwCup88DGW21uOWx7dMy2hU63ZVceMuFe9uK16eHKNHJ2UWal7cxCAcJchPiyllVXSNv8QdSJtyQzABiY8JUOQKjlTLV3pywys0DOkAjAXFRht6ZAP0a9G5QvpfuhXKohUE+xw9meTNcgDu6HGnarlALNBHw47j7Q+B/NRUpZLDoHMhjEcBTUeer7cY4W6G9Pp8JWt7F2HETEdId0SdTOOxYER0AjOo0PuoqGPkApJaidSgBtomIIRniV6UD4+GKCspnYkjdrZx/VY0xSrdlgtKzKm8WT9iUjplTHE/R99b5mWiFMHDbYxdlm0HhiB8WhMeHJUGjqI84ATRlpHN0sLQ6vxyJ1UX0xLEvwYXNcBjwY8/dpk6RYto/U292o4peJS1XOoWZgyF9AbYKBj91lrOoa/sRwGwo1VLjdxUC05iHLbACSlelBMe7A6xdxHe9RpAGiUcjNfcQzrElmWLeM9WAxWr5htfaZ+HX5uzNkjgEmIg9U31vxZyG7pOa+vodCu1gb6piGYy5DjVF4wnoufcqOVKDSlYNRfF17vbqAXWgFUpf5bsTLzsLkpciJFPOjxB4x7F1IsUSSmYwwxdZoOy0cHXwH4DDRutJbvKArJ8GRq1h1alooB31aNjQ+iRlpcFtkPPBVrj/mR+fbAhmibWF2JFSRWDknsA9+Giv3m6LhBCh4N4DLhrvFJWZ+pkQLIwV5khXTAcGQQLSLFU0ir6kqrqmQ2G0ghA1nNTi1IBWDwKaQnA+lmFQdUDK6og4H/xI45mJPpZDzAZqw38OUMBwDZHMEFetnA9EuNv+as1wrYppsKbezWs1LZPtIn6K9SqFcHBaPWW4elsYWBDHPuomNpEXlzBGFzXT7LS48gwMFIxNIFnYfqkDhriP3wFKNewsp4qPw1tut3RtDAuhnkDWuhwt9TFCvynjkEOrdq/QmMBDrGEDvcZq3svOtOcuM162TSY9i4qCGEczFpENq5Sh9Pq7YChXm482t5qufJwXxoU1otWTQSgqAi/Ft1xsOBiVcqB8pbBDKMOs1iY8DASmNzBRu637nMD1osceyYXfYqMwubK7uEH2uzOem0dKMYOOfQ9CsrpcsxStMsHOoy7cSCp/i2pWzwvW0TT85OkeFTo229DaSDSDgK99YeNTGWMnGLc6ZfcpmrcHR1vnpzQFA6QxBCgEKzMIAPsCG5zPVaMhiYLwe6ygKADHDOYQY3JBBlKqSuO9HUngKOYRaDSwxRIbUTriLmuholchV1TxlnNqxcVrspx6LSZtdmfz8NMbtmRna5421lpUXSdIyOBDrGFHe4y65TATpiMenw3yom1ae54M9hlLLm1JGCcYOlVt1W1AECBgRw1tRf2JfFRmFRbwtWxjrp4iw4AUfW1HZQK5rzyZdt6bNKchp6ofV5Swa5shwQftLynOCnqtMpSKHYANfLWpJnhcy2BhQxojSSTAedStvWsUW/G6wI3Ezx+XxVygz7gUzHoKJ6DQC4uoOrG4ExzUJw0THQoWkqiEWhnVlfrIr0G6rtQOWKeqNopQo9U1C9UrTqtvZuBlbgXAPQ2kVF0zkvlTWNR7hGNSWn12qUnsNyQEn4jJ/Xgmd974ZgXqVFO1u9vo3Gq+DF4doNmoF5CqUGHlr4Mo0i0t2m5t/CNEQCHeM68DPtqXQmZToDduCYNdB28PzYFswGuEtbCsYeFfJWJtWgUrabFuXq7NlCPw48oTpDQTGo5ukBMpyd1oqTuglGuGcHZsRpEn/CNdq9yKVCmQlSPHziVbYDbAYABPut4IkbAxKSKC0MhF3p0o4Svy2Tm4sZupPO5gPpVANZg+VYTqNftjoruI0KTEpZSi/LZIaAppIZZoqyiQcc+N0UjlqFio7PWtWDUuOqavOcMXUCNkNaMs+0CkpkUZGCearrwHwHHC4cxbnCGcK5A9ioO8sjrQLkOWQz7uk2VREHgzmmRNwkzDBqMKmrmmZ2NNsd1JUsagCmDB3+ziGaZqWMTrm5kFa4/htC0sjTZkqNweBttCIjpVdGRhKSjiked/ijZOrCbZtjZ9JY28GbvwpMg1+BpV/43p8qow609U3fvoNPl7UvQihOCdUtli6JMjhqyW7oJBKjkkwpWtKDn8OgTVoerxi8MI+ll4O29PC0bMZUeBIHq6E229h4LpvKLn0i2CAuswoK+ERULdlYZnJTJbKxAvuhlRtIvgwonpxscWnhv9He96zHCkS263lMkDLBsazFPEyzlGCTNKWljdzMj4PHPJNNg5bM8Ty1Zd7OH86R+nK0eE7d9K0pHI0AXmRM5xdXfB058AjXijnmxsvptek6jkiYava2oWolElUPpx9DD5a4XHbK4nF/vzLvleF6WcQ0ibFCIeTKj/0fvI9MazRurOFma+o7KDhBLwM4gGUo7e6tdZMiLaMjnLmgEYblzC1NwmZx7NOysDV5Rd7bxac6sMCrQRGCAw/37cgka2tX2jxD9QP+hm9HW9roCYP5HFl04JtnbxaU/VbSMq2JW3HDvKqbD/ikPS8tWZ33a11sWcocHos5IqEyhjyJuqBWhazNWxMnLkXq5GYwOyHlpUwHQBaaubGPChNQMFVry8YSGg2ADIASNWNzJ1IeL/hvlAApUNxodREbwBkAnO93rLGbdZYF4wEx6cBSKN4/ZeApFruevCLFAesowycwFY5b1bWcrEfDSMxTKyGFqAxb6IYcfDpw1ZmQNAIyIaYQdOz/4HuMexdSLGEk0DGmuNP+e8qanVbLhnUbZWrCKljoRYD0Ce6hqFjptBcYhYUmbsh9ux9HO5Osq+WtQRuCbEw7Yz+WxjiAMdyYc/0iT7NELpPBcKyikLDuxWKVlxiY4KXQqTvPom0OnrDBcrQyqBDUkAq0eV62ZCOMwbJCsJu046aIA793RvIyk1VZT9ZkPXPFVNeyeXSnJcNRyhqpZJMBjrZk9O5AZ9VOCbxlqaQVHOqtUUk/09JjVqpY2gDzN5qZl5Yeq8U5wR+1Lm3ZJF3ZUMyQ6XB2A5cJ0iqbBt2wPILOsQAe1HKoRobpFfNiAcDV0ukaaHBHkLKLvTmCAZhphSIthwKVpilYsD53rZIxHUwLIrXS1yZv2mcFfh21D0dgM6h3qnsUTaOWA9Gd7chd77tCe66k9MrISKBjTIEbIP4xnfuDC2QqIr5hxiZhFNMVId+B/DuZkLJtNLQjjkqyfinSUU0GGQqwHt45NgAJnUBEaPlsjSO07NEaupnmI5QqGsNCzYdvk51uM6kgJOV+aQktBq0BUiq5trnHIMQHVfyELJcNxSx1BjvInOzQKnRgLFVvkLVLmSHjkRFs5FlbZquBDCgugXh1QPEgjcJMe4CfXRgI6ULmukKRhwpGFWToA39tAKbVKkgvKcOxoZphQz32RMExZ5qqJTcMVgVg4V1kAULwivWYRgFo4UlEw9Zcz5WVyOIcEnQM1JPFhauNUthQOmsiZb947G9uOUq1ELoMW51bqWzdbdYMwXooC282eSMIB0rGvwMAEGo5UELVrF5pvK7Qa+DWxp3vuad0uhRWrbxIoGNkJNAxxrjtHreTqYn4JknhpGkr8B+OQBi5rVKA5l+lVK2WgQa98bYsbcJxPtJ1UMMBABLfm7N6fmwTEspnA0ipB5aSKZnYd0GfUFE6C5CCfiwEAtYxFE/d2DAs0WdpbY6Ki5ZqTiByzTMCkDmUzeaFdLKB3Ij9z0S6TCCU0qlKKXMFJtjnTWXOUlzN8qiYEimIWVbQII1QElDNgh1ZIQOPlsOWbElPUS5/pxq+EXDwdyGt4k3ytGmeGn4pgADLsY59bbqm80AvHO3sC38O7zpb+fLQ18D2HJqbflvN3dhnBaAR5xolssZwRHoLMmd1JWujvDqq4g5aIgIHm9/QfHhqxPsIOdDwbQ5dY1rFFVW0UJfUNCQLsULO+1LEbXbfedy7kGKJIwlJxxiPfdYjZJqi4aAYi+QAOLzBVcMoTEV2jRs4wIi5RMZiUi9JUFOxWuxHhsTSKvWg4H1fonw9yx2BZjLN62NixYrS8EW/TREpBi/VXaigcW6gAyS25eJEPrCWMPuC6bk2fFPrbtUPbCi7OmiyCZyX2ioTgh4iGylG1UqODRisjRGAkdhG0zxsjNISyzXqlImmTTbZb8DvwQQRKX4jfit+M347jgEYC3V3VXABkIFjxsHZ9BvUcKCKhcyGMk/D4lAIfvV8aTM3T7UUA7i8WVksC43qa8BLqPX6sMGdZa/NqhXXZ3i1StAJ2fxgfx4tzyoVrxbHde3pxFLTdDWzYS6kceVXJCidpjjs7x8tKzWSkHR0JKZjjDGVYtKIGg5P6rFyP/LrYPlgjp4a0bqxuM71GGAWUFILKiSuPvGBJNhEmlajDdpbjZaIcUhgeLrHm7CMKqFl1oeMByj6Vq6plnaOQQM9QUD557KapEUmG9lQrsfttbBMBhdTmFJ1uN01rR5txoqsJXNsuQ5tCAQC+vVzUvAf6BokE9iGXXUdqG6hzxkMxUr1DFHNgCyL0EyDMRgmDiVwMhAixtgAiID9QOUPhaNVS+YAwvhbwXigoqUl6/raPVZ9PDS9xhSKmX6B6ZgHwDO9Bj5D1cpcr2MmYNr4bQAzMLBVoRwWe+IiUWWxHJS6iFR9NizF4qkSBxym5WjQ6Jw/ZACGeUyvuLWuiUg9tRhd/+5bEyq9hg/slMV+B6/ge2RKr4yMBDrGGDvedge54z53kMsvulKmIYbbcgcxqM2DqJQ9WCjqKyRD3r3dMgGfctFsZw9xKUUZ7g5ZSd7J0OCVV7S7VyOPAXEf799e6dKwrvamX1Gli9/0/V8GQYz1oodDKft2+L4ojY7KCOgssChqLLzKAmZfG4uu5NkcxZGlzEq7KqWbDaSTV7JBPdF1nSyT1VmPpmIqtOxIF2mGrJT5Clbq8NdUJ1SmWYwQ6tvfGKbbzCaNB4A40MC+Wx0OgUbcT0Vb1KvxF5aBtwYrTHgelBHC64aqy3OKlMqGossyYxxH6D1wfAAucDw3Fh2mYlwQTCbDSpbn+rCkN+EoTMLMyj6YwTnLhfASGDBd3j3QDOcCwxGXX3vZtotFgY0jbw4uAwGymYXpwSgkH5iAFJ85sOhDuwHg4ewGNB6RsDQcXEs7LhdkuR3idnvcRm6/5wpOQSfQMTIS6Bhz3OXee00N6AgRiUgp0MxzshreXE0fQFUXkfVwF4dNKASdtP7izbtqwfQJGZC6SZY+UVr/Nva6t9QKbK75R5xHt4dTlM3aAJ5ZCS3y/eGJ1itgAGYGmRTcBwM/pWg1CzQEg7Z08gG1Juz3kUH0qbmfm4tV0s4GsqbqSdUCe1Hy6RyupBvKGRm0b2YJLQZdpAzQyWUVzb/1eGwkXAFYqdMp4EgwSHkpLX5yz3p2YJdXSa67vo0HKfYzEW3KpuDHy41RbaIgBPvg2g2wNGr6pfoNppjYCK8j4LRYkUJr+Y78cbCWglH21CGLhLLYFg3X0IuF8wyA+BgOZgOVRTgnLIAi6FTwQS9ZAgFnN4zFspRaHpfIOqD19EnMaBBg1PoMZ0EcTBB0WPVVbA5GISknAI+ColKt5qrMEMzMwJBCJEMy3ZUre99rr6kCWdMSCXSMOe58r73kh185U6Yuhm+injrhjdb7rFiiHDdiMB5GhQNPFLgxAwBk8Fywm3xAEpEtulugQ30JQaj7k0VdaGtjMROd0r8BbIeNMEZuMMXRB5OhIlYADuoxTPuxsQ/xYi6dVimr232p2OVUzceYKAFwydDyvs+BE+kWsB5zBUzPK2nlGGw69PqAiyl+2MAqWbCFflXILPq24PdXBQFHJxLJVqanpVu8pWDwD9x6rzLim7gXZWzu/ejTVrNUzlyoVbmCjzr7pSADTfGKEsdM+6nMw/CLYk/rFEtAgr87MkegoAyHMhuYD3Ch5wYplI2woi8jnQwrWXLZVLTJcGya1217WSwzdiASkE5DKawfCVYrOeCoW9rH7euD3XkMPOy6BKsW6zlid9KQmjEbc4AMOpkSiLhg1a5tAykKmp2Wiy7lKY49991DVnKk3iujI4GOMcfj/+HP5PNv+7JMZbiOw6lkpFQILqIbsFe0UEFo9IOVGsK4S91K6wIEZlHYGbZm0HlT7+s4E77a296zJNY7e9oAgg8IJCqpOq470Rd2oYV+BEimz4aygoo+sCsQmmIPuq2e6g7QvwU221lbVrd7HAyh82BxJ1IxuRZ/whb95nKWA+zqHK4cWrkBDQOSKqtMA8CmceVA8hzDbC7dClUzJYWUnj3COtq4veJPgEiTbWaGUlveekbTMc2sk78qeaTgYXgAdG2Gn54AOmwdX3cT2Ah6sZYq5sw0pYJfvqHqaDU0TeSVydhUdtTfJFM7cwpJyWRAIwNg0ZaNEPRarxv2UrHUBypVqOEoUSYL51GkVLRkloDDUytxtUrkUutlT7VQtGY6AsBACgXnvVGpYpVSXgbr1SuekgGjgZQgNR3Q5xTaZyU2BHMpkvdfceAxpSwH4okveJys6EjplZGRQMeYY/e9d5W99t1DLrvwCpnG8Cdn7SRr2g4rn+WNGYMiGAcVSegTIvqxoLoDBhYoHWVZrJp4BTdSv4tb7zgCEdzP4zYrETWuqZZImMoxpG4oxw1TNKHK02oAbUEhrZlShYplTndSDHaACoN2xg6z7byi0FRLOgkdWPbZsS9FGS3cSlv4glyrMFbl8CzVsuJOVjA1gcEK7AZ2YAZls7RUx36CJ9CW6tCVoHGcYjAFZhjQgZs87eH3QQUiNni6rMG60Cjf4IdPPTR82KMshmyKpklQCoq1XbOhbIfuA04DfomafHVk3hqqacddFY8CVGA/YfaFSRu51S3sAUS8isXBCo3CWCYL1iMju4SUyqZ5uI5aqsUAB4FgqGhRViNCR2oEZmWrIS/k6ZJwkdZuo67n4PXW8OWw1AnFpa7noNOZ5JhvYtKgT2IahRSMXu+h2ZuCkJBeGSUonYK4/V63o4FiismLBDqWQRx02AHTCTqiJzhqLkgPWOdVS3VI3tL8N3MZdRdZsBO4mZOhhq4jCEEh5qvorWGbsRHT9B60Ua8Hi0bDN4ZtB9sHAw9xYWim4YyHLg+Wpl9AsKipEXyIgR9P3Pg5HXqHaNkvuAk2FrXutGA0EGxYVnZkTWtO0zpVRzaWM9JrbZK1WCYDaLGBG+LSrM9BD9AGE8ZQDNXwCIEmIjTlJbdQ244QRNW/sGY6/JDaughrHm9jL/QUzYc2dYBX0IFXLK89Y+rMQc8AQxlAh/aaQct5NOpjWsVsyjeUHVlfrCbIw2nDfKSfyAKxQkVLZsF4QKsB0BK0M0jXoAdOH59pNZGyHfpaV6p4N2EHIDBeMX2HC4gb5dNRis40P9RnQLcRKlUitgPLu5uuMR1MtzA3FJVsW9qFwMKNwNjkrZCqD2O4Wlg9zXHQ4w5Y8XqOlF4ZHQl0LBPQ8ZUPfkumKbxcNS6zaKRVeIeHB6c98WHEhoaDugfNk+QlWAY8rnvfenviZK5+2IDMBuBBxIIgOwP/MfaZ00GW4wwf/618UWwUb0dVD+wBo2kBuJX6t1BcSrGnCkuzDGkUZSTYet1szbE87NIxrsyXq2VV3pNu1iYTkGdazTKHJ2DJZU0OMKLf5Y3ZsUPYTlW2pI0BGMCFoAPgA1yAyM1WgAPRqo659bGoQYemYvBNsZ6jCpoQpD1UDBo/1HM7rC7RHjEAPm0v0jC9hoIMs3rn6fDmbW2mXMCQzNN/Y0YNvuBEag3bAGJYnVKu4o17DukW6DgK3Yb/AheNzqMMljbnempoAGYVK6xADuctMgMj42HHhGyPMR4GNgKz4a3qDXDwsvTPeV1pZZMyPnaEnQUZxB4zZd3YDR1lef2rG6le83qdL9BymB36Sh+Ab23c/zH3lhUfKb0yMhLoWAZxv0fdU1rtXAoMrFMSw+WzfEr03ixQ96NgxSlmPv4O1F00p0NFcBalNTp6snAw8eESLIiz5TrI897vJbT0z6hHWddyBEYE26YzuzuVUmShgxTTLFZdY4M1yln5Lq+0k+kgl05bm5mVEIJ2CpkvtD37mnZfBjT+atNGvUVrdWVb8HcHoEoK6TLtgAfg1bIpG8hsPmCqRdubQ1Spx3CGcAN8glZ+bBIIURV4IC2DbUKEWnc7rSe1I8H3aWomBh1gb7gcRKxDoMOneZa4KpiaYx8Vqxihx4a+n6s6QehLfYY5hirQwHIKNphGMZdR+J3M0XujS0aDbqJcFt1jOzz5tJEvWtLvWwdg+mwoO6becgAc6Gmj5m6hv4qBBO+voqJPo3LIVkQsWDgYDjzQ4ycyBAOgQft6tzgnQPFtqW2/W55zU6xmAYBGOVWkaGaDw0jLEfdgiTvPTktkIg947P3GvRcptlEk0LEMYmbVjBzwZ/eRs7/zc5mq8KdDphziVvNWSkgdh2fb4cOBQd/cQs1fI8/bBARIsZBeB+Bo4SlXF4UgARkSLeuwckasa+kXT9k4le6iVN0/L6UFQwKHL6+1tVSQW1hn6oqJAbLdKqntgB8HBsv+PJxIK5npFNLNUIGi1D9+MSyvgILmpc1NQ1iKgRGdcPtZm31DUMnCHi/QfZQDWZ1Do6GNysBi5JZUQSoCQIYVMSyXhd06ut2W0kM6hngJy7luQx1PMcf1H7UDiR5vAiE8oasribuTWLM6LKNbpB8GgBBsyJki0e2qEFRNvTjWojQWJcKsPIGplwpF8VuYRiHbofNUs6FambkCaRocR/2eXtGR+V5LNtEfxfYZyyDlAuM2MwDT1EmUTnMTMOu5Ulee1J4bLh51VssrnLJ+XWUSBKXeXdb7rwBUGPCAl0wLDxHuzeGlsEgf8mAUen1b75VYu1EXANXN36Yp7v2w/WSn2+0gKz4S0zEyEuhYJvHAww6YPtARHEn1hqtiTqRQcql6fclQD8on8Y6KSdn0TcWl3hiON2w8cYIFwQDBEtrI3dTNxrCMNXnTapbIEIzN42yAwRMyhlv4b1AUgcHGrLFdUOruV6FeVal7MCKaatBKDVh04zvnYKCBBu2dUnoFBmGR2daAWgW1+1ZzrFXSly5b3FfUOQDSUPsBS3VCixnZUM4y5bIqRzGqgpcCAIepGWSGVA7KLRtDAeDiqRlTutQDqs3Dq+ozfAnzS2GbeH/adoEp5gFEaPpL5bGq4QAbQbdW8isAEJoSAbOBCh2wGYAq2BbmQzyKjbrdOdIqcwX0G6osAYNBp9KirZIa80QB4IBoV8dk9fHo97VlvVnMKnokqxHV+Fq6RMNScXG1in8eV630K1YpLSiRdXMwYyu8zFu9OPTYQ/CsItJSr10HGngN3hwDvY6Dg2kEQqYMcHi6eRIirgrb2vUnMRLoWCZx0OMPEHnFZ2Rqw6lk/ztoO2wYJOuBp0VzK+229IaNtvJIV+AfaastlZs2eXVKBv1A5K9kE9rMlxiM1NCyTtdwTU2V8C+reiH4QNM1sC3sM49PrTOtu1gaeMCwjzQCxgsM9hidMEDeVHVktl1IK0c5K0plkY7J2QwO8GETWXl0ms0lK7oEFmQqkFKqwHoUUmRgMdT3oyt9mdXWIgQc9PowGAGNAbfK5nJQWhhkYHZBt1EDER0gwUAgwJ04mHCAAW0GwJT6Zuk8eGuovEX1M15pws+tZBnpFXSDBcCCIZr3TcG5hI4G81AmqxkJ7T/DFIuZfrFShhUqqveYQ8dYlCHzElHWyFr1SDUwsbHrN5zlsKoZMhzGkmkaxc42wIY5iQYxcmSDjmvFdRphGkRmX14ya83iZL6QvF9YqsX8ZwA4ooZumkn069ykzFNsBBbHA3EvTDGxkRq+LZO48/57yqq1szK14V4dQVhX6tOg6w6i+UxqkLauyxDhUoryRDbVsnJFAAY+aWKACJ4MXs1h/TD4FN+sZuHTbN8GqCA2tMHKcvkcxOjl7eker5DQCgqADA6KhVqXI1VSlB3Z1NeneAyqGwcdmSt0QFb77rZs6HfZmXZT2ZX1xSyZALZuZ+VHW9mACnqHttxczsiN5VpZV66iIBMGWdBCYLqpmpF5UYGmT2wDX3UJBLAtn/BdWB9VNJhQKYJ58TJY56aqy22E7WGSjtxcYXn9XuzDzUWX+3RjuUZuLmZp6qXL62/A68Zihr8NvxHftbGYlZsHXemjh4pbmRcdHiNNt+Q8dgOYhgF4ANjg2NKHA8fa0COmPkxTsnpShWsNONzeHNcJfOQNOITyHQesXubqCY/oGqqrVizN4iWyfU2rOBDRbcCXIyqHdctzt/53liP+8imN7qqu3P3+d5GJiGoJpm0U119/vTzjGc+QHXfcUXbeeWd5znOeIzfffPMtLv/iF79Y9t13X1m1apXc6U53kpe85CWybt26W/3dielYZkZh01bFEipZUJ+qb+oPvJxQTGxn+e0M/Sq4vN/5czLqcQktRAxawojBBdu30lirgA3VLP4wjPkgLihgNXsO6yfCAQmf46maRiBwJjX7TzIieFU9BkWOKN/sWG8WOJYOnH8oqP/YMOhK0c1kplORvSDDUKKSpSUd8PioXDFjDQzMEJfif0yjwIsjQ3WHlsSuNt4CyRaYpeN7Zsz1FK6mSK1QWMtKE9WCMCVjKRjXYwwbhGnVsOpC6LpqDMY8e7yUtYEZ0yc5gQUABVIigATasA1OoWb2loG56HA76lmiPVTovWEde8FsAGzgO7Gvbg4238/YvI39bTyNYjog7a+SSdmHaDSqkSYIicBhLBwN4lDrq+LVKDjvljrTtIqnUOzzrOnBEYSmruOwChe9LLVaRdMvaotawdK/8JRKNMUMxxQDDsRjnnGI5H4vWOGxnEtmn/GMZ8iVV14pJ598svT7fXn2s58tz3ve8+T4448fufwVV1zB6d3vfrfc8573lN///vfyghe8gPO+9KUv3arvTqBjGcVjnvmIqQQdwZXUIi7LpEspR29tgKLmSirEU4WjAg4EKgNKPM22fQCyp1hPs3Bgthy+NiZhrt7IDNV1uMYjFpaaFoThzeC8Wsa1I+7xwPEVaRitaiHU6LWk08HTroouUeE716O7hcy2IBpFVQf0EXqnceEmOtJCQNrOBzKD6hWWC4ts4AAI0FBwIM6p6dCSURiScRCXNst1kRJpS599ZQA5tFct0jBaOaOJHQUi/nNct8HDxPbzAB3aLU+FpHhSx3dogW5dDgsxJ34jDi9KdVGlAg0LG9So9Tn2hgBDXwEy8KV0EaUORlM22HeIc+cGLen10S0WgET1G/iOXk+rmMh2AHDQk8MvIPsR3kMH4ILuZ3aePEVCJqIGInr8/TM1lCNzFrw7tFolVKm4/T6vC3xWanWKXc66jDnpMoViWg5LsdCnY7ipWwIdMjGxTIWk559/vpx00kly1llnyUEHHcR5//Zv/yZ/8Rd/QVCxxx4L7efvfe97y5e/XDtn3+1ud5O3v/3t8sxnPlMGg4G021sOJRLoWEax70F3kz3uvrtc8ZurZNoi+HZY1G3vPaWCEtLIGh1sRwuDjQom1WxJm7qxysWpcDAUXdV9VKxmgHEYv0EHITAeAB7IbNmTL7UdJixlzw73lOKjcE2vU1iKuWRH6Gpl/ebx31zKPvQgSq2gogU+E7QUIYMAjxHYfmMwzqTTsmoTUC1sZW8jaGsgJQZ3aCpK8AToPJvTyXQVH8tNo0HSpTQgoekH/D2HqpSsbc6jCixU4aFuqGBCdGlFWGRzQqUKmAiUvsI5BB10AQBrTQcGf8wAKHEPDmhSvLoFwAMMiPtw4Px5kzdnO1D2Sj9VWrZr8zetQmlrJQoqYqjZUN8NPywDcxqFLkTtzY3R0IsnmHwxTcYLLLigBWGwAoUoXRIBVfqyRT1X3BhMG7gpe8GKFm9bD80GUJF5c/AoMsXinWRrx93a4t/6rAwBD/5bmEIBKbrK3vvh+417N5ZdrF+/vvF+ZmaG09bG6aefzpSKAw7EoYceSobpjDPOkL/6q7/aou0gtYL0zK0BHIgEOpZZPOSJB8mX3/cNmbZgJcoCgyq9EZPtwOBDjUfUCaTXp0GWDyoVwQXmF1LNUPbIbrTqk+Dd3ZQd4WBjndDA5lY9rX4hIGkP2aQPIsBhnhbEG2wcgtEy6tClbls6qGGkt5QO/DuUNcagUkqrpboPFZ9W0i9L6bbAJ+hADy6im5XSY9krgANKUnPpoiQXwAJlulXObrJqga7CULzC9lz9KhRAwMVUzVHBrejx0t4sMCszwMEeK8pmsL7GzgeFrfAUodC1Y8BDQQcEolgPwlikRgAsyIQYoGCnWXhpUHCK+VoGTKDCMlkwHapTIQsA8AIDMLi8QgNDwIfvMm2Mt6hvdIitTb7Ce5qCGLiwiiQFk6btoRYoazIbDjyo8zAtUKPnipfH1n4c3sBN29qrQ662tNcustU80imaLvMqFZ5/Mh21L8fwA+00Ag7EA//8AdJqKSCemFgCtmKvvfZqvD/mmGPkTW9601Zv76qrrpJdd921MQ/A4ba3vS0/25K47rrr5K1vfStTMrc2EuhYZvGopzx0KkEHY0hMV3n1Cub3+pbWAAVh85Azx2AEESkaxZHKBsXN7iciqy0dEwBEJjmdRc2t1FMpHLQrVrNkqFRl2/haMgIgwVJa6P3o+aGpGK+UyNEEjj7ZGdMYqKDhVjDS2zLoOFu2bYDPMynQu6XKpNsZSGG6CaQM+u1cZjolB/I8H0hG9kA9OAAQMOKBwUDTNw7sFVgP9Hix+bQJR1UITLTMj0PHXqZramMw6EnUBwT754CDx4pFypomcNChZbFiwEOf0GFpTv8OHDdaoTvogEW5moDV87TSpGfz3cuDreytSRucRef7bcmRnqIpGPQbeG/aEwAOnAcAF/Pg0MomTalopZECjxy6G+8EZy616jYapVMcHLpNOUXHUUfeuFrF2uS6mZiafhl71BtIDiMwgA06j6pPhzqQRl4cLJnVKZiBjZqmFHQ88u8eIpMUS6XpuOyyy8goeGyO5Xjta18r73jHO/5kamUpmJcnPOEJ1HZsDfhJoGOZxX4P2kf2vtdecskvL5Npi4ZLqYtG7T1dSpEHAXPhFDUGGHMGxZNkhkZs2jpVsyCw7ezCK0NTHhSbsr+LmoiRZfCx1splWc3gjIVPrvHALuHh3tM2ECdaGw/oNfAkrQyI/cuyUluO+m0MvMo2tFpo995mqmUA8StBhepSYYWOJAQFpW0dbGFwjp9AIGW6DfeX6LRysiHQErDBHJkLbIGJGIKRVbmmPGo3UqX/23BErcpg0OVVGvh0E4BHpl6rYCM85VKZ+yhkoqg6QSkrllHxqLISABKq7VDmQvddP9MUirarJ9tivhvoxgs2CBU/A6bJMFAr6wNNDEt9od9BugQnzZkqL40daKpFG7hZ51nMNx0yyp7zyHFUdT523Rn4cOGo02zqs+EVKkaMhRJZAx99pGLcAMxSLWDmqOOwzrL4zMqSQ8nscInsFPtyIHbf+/Zy4KH3HfduLMvYcccdG6Bjc/GKV7xC/v7v//4Wl7nrXe8qu+++u1xzzTWN+dBloEIFn91S3HTTTfL4xz9edthhB/nKV74inQ6f0m5VJNCxDOORf/dQueSYE2WqIyqhVXYAnV0LyTodfUrkMrZsC6kLVDRE1SzoqQKxHpgQPulrZ1AVFWKwsOaxA9MJIKUCAOMdxw2MEGC4f4cJSDXnbjoP13g48wEdRzuTqgXhqJXTav92giJsvFB7UCnR2h4dV5l60SZ2bEvPVEjOB+NOG4yEpjBKeMPTzRSCUu1iW0GTgc/h+yGVgQWrOkEahk3RFLxx0ITfiAEPCDWRysAPoRUXqlKYVtH0B34nTMwKYzqo8wg9auC5gWZ3ymyAiQFAUOiiAIOgw5qyeU+avjEb2A6Ynj7AgqVftFuvmothwjqDfkt9OUAYMCXiduaWaXPGCuyH9VnxtEdwn43TJO7HYdcPj4VVrRCUmKuoV7CYC1pgR3jNmCGYdpWFFNerV+qpCsZflkohs1E2S2SHAccUx6Oe8rDJSyttZyHp7W9/e05/Kh7ykIfIjTfeKGeffbYceOCBnPfd735XyrKUgw8++BYZjsMOO4xMy9e//nWZnd06i4cEOpZhPOqpD5PPTDHoiPUcfPHqFjxBzveQgKyZEKALltAaCsCi7DGmOfYS4j7kia2KxbUXSLMAeJQY7LtGuaMMFoMKNBj4Ygx8ZnDpPmD4WnAGJUssvJTS+rI4UcMqB+8nb0GtAbZViwQBLJA1oqbEBYR4+ufDMOzUMRijukW72IL94NhXtbUtPUsp4ESKQUzZDFa4gO0A8HB7rwxlqHpkOajasa2yDjkKLOsH3sdwXSSjcZf+RtVosL8J0yX6eQ1QvGuslsy6wFTTLMpsYGksgy68NPWylAsABk3amT4xwSjTKaKW5pHws9ExlloOY5KMiQgpMTqyNn05EG5/HlIm1HBU0jbA4gZyZDjAYgTAokBV+6IApMBhFKm8WpcRGrqBySgj11Ev/YbzKPuupCqVUfe8SYvlWjK7//77k6147nOfK8cddxxLZo888kh56lOfGipXLr/8cnnMYx4jn/3sZ+VBD3oQAcfjHvc42bhxo3zuc5/jexe4AujcGi1OAh3LMPbc5w6y8647yo3XNFXL0xIx4GjMx1M4gAdHaROQQqSHP+CBQNCh2o4KOo+WDvD5fEmRKdvdw7qcT8v8Ev6NgYXfZswFxqqW2Zq77UNwK9Xx3Z7obZTmcrQfVWEhtoOSWC0Zqd0nsRZUnkGlqnUjVaskUCKrgt8Inw90VWmXFJHS4RSmWmgI1x5Ip1WyxwuZDzVAD14bVVVQ06FAQstL0dMFIEWPoQ6a+AyHsU63QA6j+wZmJS6b5bgKFiNkvxR0QJ8BwEPuJYAOerCGVA6WKd2HAzqWARrfmfbFdBsDdonVlIh2iMWxj7Ub9v3GJKn409Ip1HCgbLhGS6xo8csnalPvKZXwt5fGOnvVACORcDSsq8BDDedKyXvmOgo2zpxHmVYBCLZqLJ53K5MlUzecVpnyElnE2tuskbve987j3o2pis9//vMEGgAWYImf/OQnywc/+MHwOYDIhRdeSJCBOOecc1jZgrj73e/e2NbFF18se++99xZ/dwIdyzQOf9NT5IP/9HGZ1thsCa1Xs3iaJb5xI99PRqOSsoP8SptPmdBxcDyHZzjz/Jru8Lb2tEOHwNSds40VAOVOHwsQKwYoNNVjy5i4lN1obdP1NiwV4Ll8bzrHfjD+I3UwJduOn9Iu6KwJe3QHBGBGMAjj55PRYCEqBneITQsZkOGpbdA1NYS/dD1vL2OLmRkYdkWrYmLAQeBkJZztvAYeaoPuVTI6n87eJdIr9bZZXmsaDwUqul14jVBIWqBixxq3UQ+D9BnYDVicK/PDsXugZbLUbnhHYAeKQIUDXU+7wtZi3aDXcEYkBheeLjEbDzqIsuS13nzsSEswYU3eFHQY+CDw0NJYtqsP1SpwxB3oNclGb7h4IhFp3EV2CHhMa4msxzNe/+TJ/P3L1KcDgUqVzRmBIQAi9EFJ41GPelTj/WIigY5l7Mz38Vf/f7Lp5jmZxlhQQuu5bxeXzs1B8KCpk6yrHh6m9WDuv91S9gPVL2AcwH7kriaF7kIkR5M4G3TYpZaiUfNfwPe3qFuV0kpiWWaL6NYAxMEISQLvUBtPFDl6V1sTHATLT3sSJ70CH482wQsNwjAqsqEchJiq26iIRLQ6BloQCC8HTNdoZ1vVdmTSbymLEAMRtrgHs2CSUTihQifCqhamHpqt7bESgIe4rIFiUmhOapdSgg4DGGy6xnJW7fZK7QcZDgVMzl5QDOpsBjUglfTgMMp+KgbirB9KKIElu2RMBxEQetPYMhFYcOBBsa4JbSn49NPh58/8OcBwNIBHsD5XfQd+Z/DmcOEoQMbcQFrMgXkFFVItg6Z2g4JlOMQBhAylVfzm7SBkEgfcLYzOTEced8SjZBJjuaZXxh0JdCzTWL3DKvmzpx8i3/zYyTKtEdIsTKKrQMLt0ikwxY2/ZaZhzO8b9Y6yWuTcAS7YjEwFlEi5YPAvwExQJGounDDrok5D/RkqE3qC3adWwNIrFSrVbB73wcc8M/zivyZjKFznAXGr267TvMx/WOzCSi8QACV7DwyCao5cgQPSJRwAo8EKQIG/qQX9BnZWn/7xJxgQpF/wOQSmcPBQPxDtzCtugw5RK9gFNoZrOpIieigW4vogF3QbPR4rvZuy1NW8M8BgAHAo86NwkYwGMwtaOQNBK1gN12x4mqay9Iq3lWcJLpFK5CjqO8XqFGc1rEtspN/wJm3OcgRLc7+mAFZ6Znfu+h43AGP1Sd1zxZrhKtjwXip92JtFwlGCIK9SqStWmOLTbnUKTDZXrTLlgTLZHSehjX2KLY4EOpZxPPGFj5NvfvzkbUqzrZgwz45QzeJMSLsV7KR5c8+6ZDjIVIDtwGhBhkABRdkrVLhpAkg6adlTNNMy5tvhzEXouYHxY5BJgQoxk5F4OS2BCQAOHmYNeCjgiKga99Ag7WBGYwZ4vCdMGFlNYILBmqJYaD4AlGzAIvHCNvZau0tgZRUiwcbdvOFV26F26dadXucjSWMiB0+xDJuzcS6PiQIT/0DlC8FL3g69pla4i6wywblQI6/Qgp7Ngi29wpQSGA4rbfUv5eBuAARfb34cbgIG7YYO3po+oT6EglY7X17BEmlwnO0gsICRbdzgzcEWmY+4fb2l6igeNY8OAI7Qwt7dchV8QCjK3ioQAnk6hdVTxoAkwDEy/vwfHyMTG8s4vTLOSKBjGcfd7re37HP/u8pF5/xOpjnUhtyYAQjyYov0Xl8ZAjxNz3ZDCoZlIRxotduIthbPJeu0JJ8rpZxpmRFY3UyOxlGoZDEBKZ/PTVwKeQEFpz39V+MVLTpo0iM8lHGSAcGkelfLqigIUaZBdSUUj6pQolaouqMmBjPoTOyhmOXAOcSaKuAgy0ENiDZXI+DgRzqIQseSua4DKaag6TCAwvJZa0pnYEeBhLIrPO4c4JWpUF2IPfqHU6EmXwRwTK1omayOrxD6lpZygcOoMzv6m9S+3Hrk0HPDz6nrMQBIrGFfXLHC3+Y+HJHBV2zkNZxW8fcAFk6cxeCCZbLaqj5sKyKkCEggAg3C0ajaB6gK15odbwJgYz2QUmEFSxKLjow77X9Huc/D95eJjQQ6RkYCHcs8/vLIx8u7/+EjMs0R0ixDuW99ksUNfiBZe8YGg8KehDHa90UGOQfgogu9BPLsA608wWCwtsPPVOgJozCl6ZF24dO2m1s44zGAsRcajJkrqZfM2jKa2rGvBlDxeTZmcvc56tkM/InBltVmtZFVKKXhaGmCSq6i3XIViMABFMDGOthGoIPsCFgdsgWZtFomZrASVz+K2BX3GyGwsU9YbmxN7hRcaDkcOr+QUzCQAg0KjjUBkPls1KBDrdxpmIY8lf9e630SOsJaaqk+oW5nbkJR75XizqIGPhw8+N+B0XCGKjAZxn4Y4GA6JAInvp6/z03DYbXJ+vmmPktkVb9h7e4BLuYNVHjXWPNvqcB2WKrFGaRUrbIw/vJFfz7Repak6RgdY+0hDIUsDZmi6V//9V8by/ziF7+QQw45hEYk8KB/5zvfuWA7X/ziF2W//fbjMve5z33kW99qdmrFjfGNb3yj3OEOd5BVq1axuc1FF10kK8UWfYfbrJFpj+Eyw3CrwpM+O3YOpJrvSwUfD9pRg7kwK2oIL0GNzxd0j8RTLYSA7blCTaEiOj78zaoEe/L1gYn5fnOnhC5g3gY8r3BgCqAe9IIAcchOO2zLBn4+6aMUtI/KDBOTRAMv5qsTpxtj6VT1cyl7aqmuxlo5UxkQZm6aQ8O0FrUW/X6LduLwx4ARGfqfYD6Whcaih88LLKsT/p7v6Wc6D0ZlamKGbWBb2CbnD1oyN49t2/ag82DfFN03lP8GMy9qMzDPfqv/Pv5W++2Yj89NS0O2ITr2cRt6LXdtggxPryCwfjhPtn6s+dC/1VWU58sAjfdRwTq4RloojwUYwTXByhRnPax9vWs05ntkOvx6DA3d9AJuVKtMe8yumZHHPHOCOsqmWBmgA/GWt7xFrrzyyjC9+MUvDp+5Icmd73xnuqe9613votf7xz72sbDMaaedJk972tPkOc95jvz0pz+VJz3pSZzOO++8sAyACmqQYYSCWuM1a9bQWW0OFRDLPGZWzchBhx0g0x5MT8Q3boCNqHNnBYqbDbXMzpv5dqW68VSqDbxU4OclEhQCYvDwHL/VggJwUHbhwANP82aPzs8wlQAuap0dnC79iTkaAOlyiSd5TxFAHxHSBfXTPHqFSA+DsQ3EA1vPBuC6msMYkQBSYI7WkqrXknI+l6KXyWC+LSUARq8tvfkaHAAIUPAZgYm5ngIJdG110IG/+0Wbn8XgRNfVbWHitvttKfptGcy1+d3YB+yLYEJFSgARMXvhYArVIzG4Qlos47FQAFcfNz1mbhSmx0aPbSQWdUDhuo4+m/TaubLKExxrnjM9tzjHtFMBbWRN3Fw0CpDK60Xpi+DZwTQbwAWtzo3RcCaOTqRaqVL5dToMmCf46X5L436Pupes2XG1THRUSzBNYIw9vQIP9835vcPApNfrySc/+Unpdrtyr3vdS372s5/Je9/73tDd7gMf+ADd1V71qlfxPTrfnXzyyfKhD32IIAP/4N///vfLG97wBvnLv/xLLgOXtd12202++tWv0oVtucfhb/o7+d6JP5rYi3CrerP4q2s4XPsBYSkGEAwInbaacWEQAMromrAUBmJoQw+QAj8PY/mzNgZxrQZhZS02CldKWKnTplx1HqbRtEEqYzUEvTyiPi6h8iFoKZpajyAakGG9h8k7zORK0Y/pIeIyXKZ1TPUazzdDsngeQEjdxcxfsCLSI54jciFrbEmKahjdmVhI6vuoopXab0RFtZ4KseWt+qTeH1vGhaBWoRKSPpFuw78rsBuRdsNTKiH1FXeLje3OrbOsgwXuNkGjfkY2xbdDIbKxHWjgNj9QoOHH2B1HwXSUhVT9vgEP9exQ1s1SK+Z3Ekq9/ZpNgIPx9295ikx6kG1dBKuVTSgjNnamA+mU293udnL/+9+fTAYaz3icfvrp8ohHPIKAwwMMBZzSbrjhhrAM0iVxYBnMd7c0tOuNl9lpp53oMe/LjIr5+flg9Rpbvo4j9rzHHvKov3vo2L5/2YaxHf40iRt+NddrOEJazabIoK9VLf1CMqRVkG4ZRB1B57VTaI6nbXeXBOBw7wbvyTE02OV9HcDIePgTNhmOqH+Hp2TilIunWcKA1xw0QzdUsB3oT+J9XPr2GjEHIQUzcn4W2JB4ousp5ntqA7oRT++UdYqHyw2tywnr9hZ+H/fBUyfx/gzvu/2ukDbxV96oo5QUx3PzzrDjFx9bngN8ZowTzwEYDjIatblXADPcjg4Gecxw4D3Yk14pMtdX7w325sE1odcMrx1UqMB/g8SGiWEAMvqW3gMD4ixHch0dGQ/+PwfK3e9/1+18s0ixXGKsTMdLXvISecADHkB3NKRJjj76aKZYwGQgABbucpe7NNYBQ+Gf3eY2t+Grz4uXwXxfLl5v1DKj4thjj5U3v/nNslziKa95kpx64mnj3o3l5VY6LCy1QYAdaTvWdAsDArw8OugzUmjJLa96+GqoZTrTL/DvQL+QLjrJYgDWKhl2qPXutKD5YdhllRYY6LzhG9G7ttegeRgJBCcogIGwfyYw1eqP2pm01qdERavGPoRtoLwU7IxVzfiTN7YZut66L0RgYtx+M2I/9ADWNqK+A85W+PuggIyAVmCafJ7RC1467C6i/rcXrDAtUpcXa4lsDS4CW+G7M0Qxx0JP7bniXihN0CY9BRvhJ0QupI3W9XStrc3GCHRYNl0ypdKCQQmtVrXhDkWjAKahMqUky6GMhvdYScLRW3Mvm4pI1SvbB3S89rWvlXe84x23uMz5559P4edRRx0V5t33vvclo/H85z+fAz462Y0zAIDi/QPTASHruOLuB9xF9trvjnLZBZfLtIfrO7JRmg/S5wOpNqHktC3S7VgHWBt98ORKj49KylYu2Xxf0yktLZ1kEy/KB3J6bqiBmJWSotU8ntZRossn6EzYpLUotYzTxuACy6iFhT6peyYCkwtWzWfES3IVSGhVB8fkuCImgIMoBUGMoD4XXtmhmRErQw324TZwx5mpgGRiwGE7E1YY+swdPuPtmJOpN7OrUydWKeNlqw5mJAYYkTOrbUt/e2Ty5ekUL0v2ioAITOj51mWo23B2BH/AQA0g0NiT0DeF24MOQ78LDAcFx0ipsGGb26AbowEAauWvLhqlcogNaJT5qDsfRz1Xks35gtj1TrvIvR+2n0xDpOqV7QQ6XvGKV8jf//3f3+Iyd73raGoNKQ+kVy655BLZd999qfW4+uqrG8v4e9eBbG6Z+HOfh+qVeJkDDti8QBOgZ9zAZzhe9MF/kNc+7q3j3o1lCTwoKoUfhTMhoLdpqNW2NuPaEE57tigSYBmkumxJBc8K+E7Qwlqk6iDDAKGioQDz4aAVF7w6YKHO9vHWMMyBglXAuJxAe9VHOg/urM73p3WOYxjoHGDEDMTwew9nBrzni+kmGr1EPAy8uE1GAAj5CBbDV9Z2ugvARKhcjpmRGvMEcBIqa92kK5TDNlvLD7MZ4b0dx9owrNbHBDBirEeoYPHtWCUKfEcAOpQNifqoeDoMf9AwTMEmUyrcbyuN5fZVp4HPqp5Wp5jIxcSiUV+VuDolCUdHxgvfd8St+WeeYgJjyUEH2txi2pqASBRGRrvuuivfP+QhD5HXv/717HjX6aiTE0SiACRIrfgyp5xyirzsZS8L28EymI9AegbAA8s4yABrgSqWF77whbKS4sBD7yv7HbyPXHDGyij3HYewVNMWxiKgoqW0NAqaqOQtqdpaxcIBDIZhHXhJqLkGKlmkTamolGQvsHxOloIAwuj5qmNPubAch44BqQ0DFsp2mJMlPD1oC25OpSZXcodv7jKWp6NplDYZmkLWo2kX2kjPeOdb/naO+04N6Io14KjdUMlQOPPh2w04wgzMPAvjZa/mw9FkSFRgG9xQPXUiTaFnENnGutW45DgGKvEyMeth2ySDYR4drDCybcei00aXWGtVzzSUW5+zFBd6Hu3+SiEpgKj/TdbDhaK2Q6yIMpQI/QbZkKGusbHFeRKOhtj73nvJw550sExNpPTK8tJ0QMSJgf/Rj340K1jw/uUvf7k885nPDIDi6U9/OnUVKId9zWtewzJYVKu8733vC9t56UtfKo985CPlPe95jzzhCU+QE044QX7yk5+EsloMTAAkb3vb22SfffYhCPnnf/5n2WOPPVhau9LiKa/+S3nzk9897t1YnhFVssQaD/fKADuhqQcfSGwg67Qk4yOyjbAFGqJhkVLK2Y4UHTAeCka0hX09SHMwRLrF+rUAYABwOPNB0SMsGzBIdlTXEQZyG1Tj7EMwESOFYtqQmHGIOqXqb64rN8Iy7qZq+0gAEhgTY2UCbeA7MgQ6LAWi1uvZwgZUxG31D+FHASgMaT9cPxFHDCacDYlAR2A5eD4iMGFlytaLrvbxiCpdvLS5FqfGmg4vgQULAg0HjL+MuUByCsCT7egrqSAcjUpgea4ASiBYNgHpcColuY9uPp76mr+aqnLhlF5ZZqADqQsABPhuoFIEYACgI9ZRoMrkO9/5jrzoRS+SAw88UHbZZReafHm5LOKhD30oW/SiJPZ1r3sdgQVKYe9973uHZV796lfLhg0buN6NN94oD3/4w+Wkk06imdhKi4c96UGyw23Xyk3X3zzuXVle4bx/1LkzLldE6SztvzFgUFzaVqBhqZkcRlszqMywnh+0Ds+McodOQtM3NOd0V0sMZB1tUEbpBypT583dFKWr1ogMoAGDJDuymuiT//IizYa3gvfUhZmA6kCHcTCuMwvupiNSMbYSAYGDhGHBrRND8TqIODUTwEfUbC0c6wgg+PLedC363P8OHihDYtFYSEpwFgGr4XXcIIzVJ6bdoIDWtRvWBRZBwzdLj5DdiMppUf6MlAgrk8BmuUEYK6A0nQIxKQXH1ryNAANOto6MsCwYDrvuGsAjxchYtcMqGh2mSJFVyR5viwIpGYCgdevWyY477jjWK+e7x/9Ajn3mB8e6D8s6XBxhU9ZCQ3aRDKJSiEsxAK2aYVUL53eAFnIpux1tdw8RKYBDV9MrYDeqVi5VJyfrQVbDutFinntWkQWxvwdgNey9i0UBJLiOp1dM72GeYXXaQ1uPNNMtbq8epVyCL4g0XymidM2Fvx+ulLGikjhNMkRyhM9iliIMqwQNTeFp6PQaLxilTmL9Rvito5iNWOPhuo3AgsCcLQIlxJSVtL0xW1R2qyW0xnSRMamk1Y/1G1ouzZJYAx4lTMGYlgOwgGW+MmPV/LyyRhCUot+PGX/VaZfUY+WW4mX//nx5wnOb1gaTeh/373jAU98ure7WP9gWvTk554TXL4sxZ6LMwVLc+nj00x4uX3rfN+Sis6e7EdzmwoWk3l3We2DQphqDQ7utwkAISqn1sMqM+T6rXSAs9QEO+X7paLIC6Ra4ZVZdpGMyWlmoVbo1JgPrge/JM7qVsj+L6zyccLAnY+g9+NDsTEfEfERZi1oH0QAVti0fTF1MGqVQvDdbPC0ktm2UH3pAb3w3GAwXoMQESMxUWOVOADCe5oh1GNHyrC6xbBZjmNmwMmMyE/Y5S1sjjYfrPkLKJfipqKEbe9EQvZmw1/qlZLDBxzZx3uDnQjbLziGWwTUQ3GzVdVTTdEi39JXxiFm1lFbZosZuj3/2o2XaIqVXRkcCHSswcBP8h7c/XY5+/NvGvSvLMsIQ6YK+UBai9DlGJtqmY3RDhdIAnhzw72iLzGMeRMu55POoaoFaFINOwX8s8MooMAABeNCvQwc6sh3R0zufrsFMsNW9dUX1dEnkXBrIDMgGQMJ4qW2k32igBW8gp8aqYaAPVaieoolTJLEnRxwhRTJKSKoztIR14cqupWhsJ0oPOdBwwao3qlvAfDioiqtPrB9OvDsN3UYMMgYRIAmiUQMfVp0CHQe0Guy7AzYj7D90H6bhgFYDDIb1TfHtge2o4u6xkVg0sB0pbjGe/banSatt+cJpiiQkHRkJdKzQOOhx95M73G03ufK3zXLhFHVw0PIusi4s5QCjzbiQMsEgxLJHBEtIRDIAkgxVK9B5tGk6xbEUrAiUGUAN8PPAEz68PmAq5oMnAUSlglFjBKjPACuCAVKzOwQvGCo5Fpvmg2kcY0byoVTKsODT3LprFsO/f8hi3YWYC9Iw9iaWiizAHGxOvwCHhNdQOuvzPRUTp06iSpGQ4oma4MXAxFMoBAO2nhbXOJhA3so770a6DS9vjTrMKrvhlURWCmvN/1qm36ApHI3AyuZkQEP3T9/H6ZOGB8ctdEFOIXK7O96WOrQUKTwS6FjB8brPv1Re/ODXjXs3lm2EwcDDnkwJEvikmtclj0ir4GkWlpbwpKD2Q1vcw43UAQfrQqAT4JMw9BwVdR3eOyRUuNiITCEpnp6xvgEDGIqBfVATsih9Yg3HuMfm/RFYkdhl1EAFZzWEGENeHDa/of3weUaA1AfKAMPQujQbdeZiaBsNT5BYXBqDHGd9HFwwJRUxG8Fzoyn4DF15yfiocRsa7dVMkhp0Bf8NNnPTgd+rVGBrr43dFL0os6HzICL1ChQyGKxQMZCBHwxPDpxN66/Cn+hpulHdjhPgGBmv/eyLp6piZTgWiLBTJNCxkmO/B+0jD/urB8mPvnLmuHdleYc/oZqBWOj0iYFnbl6FpGzkNdBmcRCcelvyuT7TLXrbVJBBfw9+aDRFOSArknVBWeQqAvUBmdvRzrcqONXOqBkNyawyJE6H+E2qXadRArNhYtRghR5XfIT9WUBXLCyFxfaGgchwliCiQEKqZwiQBKZCNjPPWRlf31rNB/2GZ33wN46JrbOghb25hAaRqDd0s52q2Q31T1FhqIISAg50ErbrgNty/QYYLUuV8NpAesX7qWAebfTNhTS+hoaAbAIco+PAx91PDnh0XUU4dbHYiqZqMhFLYjomIF+aQMetvAHET15epYCKFbwHeMDIDuOnrOB8jnwQn6JrrQEWVKGwaZmUygbkrvXAJoylcGdssCEOCGgopt1VOR/OpL48ZCZWbaLrmkDVmQ0OurZsDFQcIAwDCf7WZlWIA5jAiPAYjFjPK0xsN6hFiQHSKNARAxTfbsRY1B4cyljoeK0b1W6uJuiNKlXqhnCeVol0G2RQrB09WQzVbrTIcMTaDXUYVebKOhAjZWLl00G/4f4b2GycUtmc8dfwtZSiEf/w9qelI5JiQSTQscLjzvvvKQ/9ywfKaV87a9y7srI0HvaEinJa/j2PbmFgMnItsaU6tBKZnbEutToI5aAI2iivRfql0B4qZCxKJVH6mTIdSMNYySxJedcx9A1oOJNv4MPH8sBmeElqBDBoFBbGOQMyZmgWhkIHIaNASVQWWzeNGz5A0ftIn8GB3jFGnI6JdRmRkyi/0kQtjV4r3ire3ES98kU9OKq6/bxtP7SWH9JtqP25pVvIUiFlYqkUTEjHAEhYx+AcPVIgFo3a0HOyNAp/krelZzqmXMhsxBqOFLcYD3jsfeUeB95tqo9Sql4ZHQl0TEC84j9eKOf+4PxkGHZr6MqhkkcVcaJra0sq7RJGAzHvq1EBOkCBT4WiluK2zM+DfVjASJD9KMh8wO+B82GjbsII3oTQzTbaBzx500fD/DsgTlXviSHgYBoODnvVQmaDXmTcZu354VYdvuyCwXJLRk8nh6JVVHNSp0a8rDVoPIbSOTq/FoAGHUekA2HFioEU/harSFFzMk2HkCGyA6NMhzmMGpOBFJZrOJQRUSAC/Y6KQS2VwuoUrUgKaTVjN5z5iIFGePUpsRu3GKt3WCWv/vSRW3BxTXik6pWRkUDHBMSOt9uBaZYP/tPHx70ryzpC9Uo9Q91JwW4EnYcaQbF8FqMj0iwOE7JuoA1gn03tR1xiwnSLupkyWYMBD1UuNBFraekt7Ldt0AKbQrBiAEGrUyuCFjxsh2Zxbs9ug7N/JQ04UdnRqC11d1NLy+BpnxqTuiw2OJKOEJj6NuJ5DiYaVTSurTCPE7IJ8U3W3dO9eiUqka3bzdOmlRNYiUbKxtMqKGU2IMbvsCZs0NVQLOr7SROwkqDOQYdup1SzL2c3cGAhDg19XMzW3JisLK5Q8VRKat52q+JZx/yt3O4O2soiRYrhSKBjQuIJzztUPvfWL8r1V9447l1Z3hEDj2Hmw8NFhLEOpJ1bhQNcTE3rgUEJOg8wIOZSioaFrE4xRgI9XKoip94D2yDzYWCAAzJW83SLe3CA+CBdYiDCUiQmCWEKhqwIjUMW9lBxEzKyD7F+I6Q67Gc60vFjEYOOaD4HeouQ0nGTLzANJpxtaDwcQAAUQfRp4CPIR/g+rkZRbUZdAQOWwozezGGV3WDxfWCTBpF1OcuCUd2igtAs1m4MXLthlScOPDAPDJZXrvwp/UZiOLYodtxlrTzpxX++ZQtPeARWbxHrT2Ik0DEhgcHujV98pbz8kH82CjrFZiMCGCN1HlbhEgajdouDa4YutaQg0DyoGzwd2PgryykgLdHRFqINml2qpXqWQwui31myugL/8hSogNkIeMHGYB3TTc8B4akABGVRCkYH2iLGBhHwoPa1GM6HNAEHlzNQMJIGduv0IRt0BUe6cNyEzVdZwKYALERt60PqxAWkrgWxcthQmmsaDu4jAASOcRCQohusaTUIPOzLICIFM0UwYyDC9B2oTAmEkJfKApREbMYt6jdSSmWL4vXHv1zaqAZLkdIrm4l0dUxQ3Ouh+8qhz3qEnPzZ7497V1ZWxFUtTq9jkINmA4NaT91KK7iEYRiC5wYACegIH7QATNgYDukTq0gheFG3L4AS/K0aU00XlBSyIo2C79HNAJyQ2bBBHwJL7pK1VY0NQtGDxFMkXuFC4iMGECZMdR+R5u+uX0fJO1z/OfzEpVhEmYiGENW/O5rAZsSgKohJaYPuA3xk6OUN+wAoqNdA2kYZCYpEYdpmfVK4HQce+BuaDJvP8+Pnll2FATJK3S1oOMx1NPZuWaDfSHGr4pC/ebA84ND7pqOW4hYjgY4Ji+e+45nyvf/8oQzcSyLFLUZDNGhBnUckNOUy0AEAiAB8YB6AgttiI8VCpac+ymdzNg//utjt1vQVfMKHuFSbstCcqwcGRdMuVVsdTolVHGw4RvHxMPK2CLbrkWBUmZKo6sV7oAzTHNwfc/msD0T9bO9Eh1XWjCqN9bSLgwkel+hzhluS23fEpbBBpGolr5pCURaDjdgAJgDMDIRgntqMAvSZWNQszOEuGoSh7KtjZbFc32zOmWaJvDfCCV/IcgQvlxRbFK12Li949+HpaA39G1mMOVg2obg3gY4Ji9vstrO86IP/IB94YRKVbnEMC0y9WVzcuyXWeqDCpecqSWsqx/VyfYKm2Ri0Ai3Te+Q60OFr6Gyqy+ugjkoMPIEriijxNI5lWgAqtV4jrvTwlb201rc13Ik2aCRijUb9I4d8zB00DFVnmBfGAi7E9SGx/we1FE1jMddiNFxNwQbFLqWmwaDPhqVENN2iLEYo0TWxaFWat0bhKTAFG+z+SoSmAmBlOHBsMzP6snTKcJO2pN9YdDzvnYfLrne6/eI3NEmRzMFGRgIdExj/5/mPk//90o/lp6ecO+5dWTkxNCjzyTduFBfrAZyyR3oFIgWvRqn0yZpP4mymostB66HzMikBKKoYcECnod+jWCdTVgXpGvP5wHKc36hyoRNI7VNhAICMSOTLwf0e7seCAXpIfNrQbrAJSpx+8a69EZ1iQtX6wNTVJSQjuB0TnBJMDG2PKRITu/K9MRhkRqwElr9LX8nw9AbGgKhmQ7Ub5jBqXipVVIUUPDe8qVv4+qZgNGZoRl0LKf7/9s4Eroqq/eMPuygCoiASKOCGmrmgoqRmiVtoZpZaZGqu5ZLL65bmUhlupWWaVn+zMnvL3rLeUnvNpU1zoTQ1MTVLc60UzRQBmf/nOXfOOPdygQv3cpfh9/18RrwzZ2bOPXfuzO8+51mKpmGbetRzdFcMkwWwdFgHosOgjHt1OA2qP4ZusFkZ2D/tIkNKVDFiqr7KosJk/hdVSEV+DHYi5aQTpiIj4gHn5ycrumll0U2/yFk5mCwawr9DHFImvlAtHZq/CVs2uCYM5xExhdmaplxUB0z5nBRhuTI0RfXz0BsqZJIvIURu+lTo/TpENlSz8Fg1UkVLyqELmZVDpPqp6LONyuPrs4iyBYJzZ9yMlDF1UEydCN8KaQmRYkIVPMJnQ7VoyDTluWracvF+VXEhU5rzYWSac8scGxahsJAYpYfF8PjXHyMfEW4FQPFAdBiUGnHVaci8/rRiwpuu7opno/+FLH09LESJkm1KKiYEgfB15Pwf6tNeiA+2cqh1X7zyyZt9C3x0Uy8sOFQHDFPEi+qMIYSA+qAU/htq4jCRNp0rxKq+JbppGJO/qelBqmUylaLj5kyF6bkrLBE3Q2slMuJWyxGiC5sVgsTbXHSIABgpMFRBYfqVxwJBTYqm1T1RLRViX1OlXZPDrBrmqnMk1aJPONcGWzFk5JC0bEjfDennIqdPOIKlMOuGpe8GsItHZvURWZGBtXuHlaiwkmDQyxOiw8D0HptK3360kw58k+nqrngu1op76Re5SYTPmrarUkQrLmcSDarlgzex5UM+UEVGUx/Tg5jFhI83ebFTqd6fROTpUDOeCquDqbCZyB3C/gyya4oiLCYiOQifT0zrSHFhKu8u+yx0jRou61VILgqTxUOXtEsTJKa+ygRcJksGP+zVSBPeph1ETdylCRy1DoqWDEw9sOooKiJU1LEwiYibUynCsiGPq8+voffbKMRnQxTck0KmkPcLSkbdxHjqN6UXhq0QML1iHYgOA8O/mjlF+qMNx5puuKA0g2j+Wp+xUgoPfaQDr8/hUqrqVIj0DZG/vNkiookQKSzYOZUFBBeb44cop043WUA0K4ao76J6lEpritj3ZvVVkZqdi8XJdqqjqKmdFEPyIcxOp9JZVdd3vQ+L9HdgkaAbC1NdFTktcXMKyBRdwvup71nWbRFTJ/zeZeSKtDqo/ZYWERGBom7L0VkqpIVC5OC4OV0oSs7zuXg/C5GhtdOth++G4+8tPmytA6AEQHQYnOh6UTRk7sP02qS3Xd0V4yAfzpa/mvX+HvyX83vImi6qI6lmWpC+CIwIoVXrurCfxw1VlLDVg31E1JhZLt1ucgI1JQor4JMgi7+ptWHECbhL3Fb3WusyH88sUkXtELfXvS9NdDCqv4nJUnPT/0T8K0SATpipfdIqvOaYLDtainIxTWISGsKRVOyrChRZ/VecU/XDEOGu6jY1eVu+fP+WfhuWUyjw3XAo/WfcT7WbxDr2oEYD0StWgegoB/T51z20b9sB2rX+B1d3xRhY+gLIGi4MZyBV25hCRDkaRQoFkzVDi/5QxYnmMCrCTNT1bBHhLKSiEprq9yFLsKiZTsnPx0JwqAnF5LFlXhCZxEP6dMiXMu+6WidG8xvlvFpiakb155CiQ/p/qs6kolidsN6YnEfE9Ig2j23y5RAzOlwnRU1PLn1fzfwrtAReqt+LRTSKNlZqKXpTFVhVyFj6bVimLteLD0ylOISmdzaih6b3dszBDAymV6wD0VFOmPjGSHo47nG6fpWzagK70E9H6P/KbZYZTuV0Ck8DqEXkhACROT7U7Up+riY4NP8Lfvizr4JsI4WKt5rgSpt+uVlG1pstJcIvQnTCZD3R+27IdiKERbVwWDiSCmGgWjyEn4W6Touklc6f/IovKamX5L5CUKgCSLViaAm45F8RSaJOr8gQVxYSMkeKnJKSlg+9E2hhDqGWvy7102DAbvwCfGnSm6MRrQJKDURHOSE0PIRm/mciTbv7OdRmcRTWHmTCqdFccJiZ//Xhtpx5Szqbmg54M6JE5sVg51SGLR8if4apjakWjBpNY7GIEu8yOxg/17kejNZnfV95ikIttCYwTwKmsJjwVadDdE2k8PAWvhQyCkXd1zJE1TLNuBZ5Ii1DqvCQooOnj6QrrkVtFMvpE80KIrfr/xb1GYFS8+SasRQeXRUjaAuIXrEKREc5omWXpnTfE3fTfxZ/5uquGJdCrB4Fpl+kg6ma5VSE3AoBYhIhpl/15scRFgD5f17v66urCGuKUJGOqprwYRHCvhGiCtzNh7ApjYZuCujm2pvd536IcjP6aJSblgZNPOkdONWaNab16jSTrIMixYKWU8MsJEYtzqZGo8jxkucU00Q3p0/M8qjYO3cObCJ1WCdq2ysJo2UjmF6xDkRHOWPw3DTa+t63dOFMlqu7YlwsfnWLhzOjT0yln3qRokS3TRMY0rdCDcE1RWWoScXkceRx+Xi+OkdVGTXDadv1fdAsKZzpQyc65DSKSNVuRWBYOmhyex8LgaETV5qlQ4SyqhEumlOoburEWrSJpeXCYrvJNwThr84iuGplGvHCAKedDxgXfZUEUA7w8/ejxd88S5WrVHJ1V8pXmK36K11UrVUfstpfvUOl7pe+qIbKlVO5LPv162IR/h0cxZF3cxHbOHW6bh3l5RJlZ5uKnunXczjv9RyTX4lYpxZG42Pn5poW8f888za8D++rP1auPEeu6Xyiv7mmRfZVLqLPuaRkZ5NyPUe8p3x+XyLp1w1zIaIbF8uxMnM+LWrMgcMIDKpAi75+hipUDMColgQ1o65dSxlx4cIFSktLo+DgYAoNDaXBgwfTlStXbNqXv4vdunUTU6br1q0r8blh6Sin2UqnrH6CpqU+5+qulDtkXgpLS4c+5FZD/2AVNVp026WzpX4KRlcaRVghtHAXmUdEtU5oeULU7dLCYYaaO8Qy0kRNOibyvmhhrqa24vQsMPR+HiKyxyJhl7VQX73oQsir2zmh10y4xdXd8Dzc2KcjLS2Nzpw5Q5s2baLc3FwaNGgQDRs2jNasWVPsvosXL7arAjNERzmlVbdm1PXRu2jjyi2u7kr5wlJw6H0+dALE3NfCSjZUMWXhXeD+JHJbaGnRb/qAiNPoRY2o36JO14iNFiJIlIOXbXShqCwwZKSMXkzkcjbUmwLG7JakFxLWrBTS+Va+T33Yq1ynHwPgNDr0TaZ2vVtjxEuBTPpbWrzKaNQPHTpEGzdupN27d1OLFi3EuiVLltDdd99NCxcupKioqEL33bt3Lz3//PO0Z88eqlGjRqnOD9FRjhn/2gi6cPYi8nc4k8IsGbrXZv4T+gyh8j/Sx8Ly4SwPo/lvqNtzVCdUi35ofhGFZCQVYsUyPFhu0gsYK5Ej+tYiE6hOeAiHUMv3bJFzwyoQHE6lSYdGNOXtMc49KSjA5cuXzV4HBASIpbTs2LFDTKlIwcGkpKSQt7c37dy5k3r1sp7a/urVq/TQQw/R0qVLKTIystTnh09HOYZ/EfNNpVJwoKu7AnSYqqpa5LSQvg7s62G53XLRT1WofhKaj4SaYEv4UvCiXyfXy/+rkTUF1slzSF8MC3+UAn2RPhk6nw2z96YmDgPuQ4VKATTt3bFIc24PVqYUqaQLEcXExFBISIi2pKen29Wts2fPUkREhNk6X19fCgsLE9sKY9y4cZScnEw9e/a06/ywdJRzKlcJohe3z6ExydPo6uVrru4OKCoKRr9NhpDqXmv/tfSLsDyeNQqLBLF2DMupkiIsGNr/Ld6DeXAucCfYYfSFL5+mKtVDXd0Vj8ZRIbMnT54UDp+SwqwcU6ZMoXnz5hU7tVIaPvnkE9qyZQv98IP9Wa0hOgDVahhD098bT092m4PR8BAKFC/TP+S10FoVfZ4NPXphYS0axDIPh/50Fuf0Kmq6x0rdEwgO92Xy26OpbvN4V3cDqLDg0IuOwpgwYQINHDiwyDbx8fFiauT8+fNm6/Py8kRES2HTJiw4jh07JqZl9PTu3ZvatWtH27ZtI1uB6ABa4rCHn3qAVj+zFiPiAZglx7LALLEWI/NxFGhoo+WjMPQVX4toBoHhOdw3tjsSgHlo9Ep4eLhYiqNNmzaUlZVFGRkZlJiYqImK/Px8SkpKKtSKMmTIELN1jRs3pkWLFlGPHj1K1E+IDqAxYHYfuvzXZfpk2ecYFSNRiAUCAD1dBt5JI55/BIPiIETGXzt8lbzKyM+pQYMG1LVrVxo6dCgtX75chMyOGjWK+vXrp0WunDp1ijp27EhvvfUWtWrVSlhArFlBatasSXFxcSU6PxxJgRmPvziIajWMxqgAUI6IqhNJTywfalf+BeA5vPPOO5SQkCCEBYfKtm3bll599VVtOwuRw4cPi4gVRwNLBzDDx8eHXt41lyZ2nE2ZO49gdAAwOLWbxtLzW2eJbMXAgbCB0R4jYz6VGRypUlQisNjY2GILgxa3vTBg6QBWvdfnfDqVKocFYXQAMDAVgwPpufVPUqUQlEUoq+kVexYjAtEBCi3wtPz7+VTtljCMEAAGJDQ8mJbunkdhkVVc3RVQjoDoAIUSUTOc0jdOJz9/zMIBYCR8/HxozvonKbpu6VJZgxJEr9izGBCIDlAksY1iRIVJNsMCAIyRbXTh5plUL7G2q7tibByUkdRoQHSAYqnfsg49t34aeXPVUQCAx+Ll7UWz102iW9s2cHVXyk1GUnsWI4KnCLCJRsn1af6mGeRfAR7uAHgivv6+NOezJ6l5x9tc3RVQjoHoACWqOjn5rdHk44vLBgBPgvNvjF0+VGQeBk4C0ytWgYcgKBHt729DQVWC6Knu6ZRzPRejB4Cb4+PrQ7M+nEitu5tSXgPn4MV1F+3IteFl0ETC+MkKSkzzjo1pyjtjhLkWAOC+sFVy3IphEBzAbYDoAKWi3X2tRfnrgIrWyywDAFyLX4AvzfvfDOoy6C58FK4A0ytWgegApaZBUl2a/dFECqxcAaMIgJtlFZ727jjhhwVcBPJ0WAWiA9hFYqcmtGz3PKoahayGALhLptElO9Pp9ntbuborABQAogPYTXS9KFr89TNUPTYcowmAC6kWHUYLt80WSf2Aa0HtFetAdACHEBlXnVb8sIAat0fSIQBcQf1WtWnFDwupVoNofADuAHw6rALRARwGV6qcu3G6mHIBADgPFvsLNs8ShRoBcGcgOoBD8a/gT+kbp1H/GQ9gZAFwAn0n9aSFW2ZRYCU4dLudI2m+HYtChgSJFkCZZD98ZFYfqhxWiV6dtJrycvIwygA4GG8fLxr07IPUb3IvjK0b+3TYs78RgegAZUavMalUv1VdmtL5Gbp2JRsjDYCDCKjoL+qoNLkDIbHuHTJrh3BQyJBgegWUKQ1b16Ml36VTXGN40wPgCKITomjxN89CcACPBKIDlDm1GkbTyzvnUtdHkRkRAHvomNaOXtkzn+o0jcNAujuIXrEKRAdwmoPphNcfo8HpD6FmCwAlxMvbix6ecb+o8szZRoEHkO+AxYBAdACnwk5vbBoOrR6CkQfABipXDaJFXz1DA2b1FU7aAHgyEB3A6dRvUZuWfz8fdSEAKIZGt9cXZQYaJdfHWHkYyEjqZNExZ84cSk5OpooVK1JoaKjVNidOnKDU1FTRJiIigiZOnEh5eebhldu2baPmzZtTQEAA1alTh1atWlXgOEuXLqXY2FiqUKECJSUl0a5du8y2Z2dn08iRI6lq1aoUFBREvXv3pnPnzjn4HYOSULVGGC3YPJNGvzyEvH2gfQGwnE4Z8fwAUck5MjYCg+OJwKfDKmV2t8/JyaEHHniAHnvsMavbb9y4IQQHt9u+fTu9+eabQlDMmDFDa3P8+HHR5s4776S9e/fS2LFjaciQIfT5559rbd577z0aP348zZw5k77//ntq0qQJdenShc6fP6+1GTduHP33v/+ltWvX0pdffkmnT5+m++67r6zeOrARNhXf83gXen7rLFG/BQBAFBkfQXM/f4p6j+tO3t4Q5MBYeClK2WYgYSHBYiErK8ts/YYNG6h79+5CAFSvXl2sW758OU2ePJn++OMP8vf3F///7LPP6MCBA9p+/fr1E8fauHGjeM2WjZYtW9LLL78sXufn51NMTAyNHj2apkyZQpcuXaLw8HBas2YN3X///aJNZmYmNWjQgHbs2EGtW7e26X1cvnyZQkJCxPGCg4MdNj7ARE52Dr02eTWtW7IBQwLKLalDU2j4CwOQXbSMcMZ9XJ6jY8N/ka9P6Z1+825cp80/LTTcM8dlMpof+I0bN9YEB8MWCv7ADh48qLVJSUkx24/b8HqGrSQZGRlmbfiXAb+WbXh7bm6uWZuEhASqWbOm1sYa169fF33RL6Bso1tGvvgo/Wvl41SluvXpOACMSnC1IBrzyjAau2I4BIdRwPSKe4mOs2fPmgkORr7mbUW1YQFw7do1+vPPP8U0jbU2+mOw1cTSr0Tfxhrp6elCrcqFrSeg7Oky8E56I3Mx3T2kI4YblAs6DbiD3sh8iXoM7+TqrgDgXqKDpyt4Hr6ohacujMDUqVOFWUsuJ0+edHWXylW12nGvjqApb4+mqreEubo7AJQJYZGhNP61ETTpjVEUHIbqsIYDeTrsr70yYcIEGjhwYJFt4uPjbTpWZGRkgSgTGVHC2+RfyygTfs3zW4GBgeTj4yMWa230x+BpGPYD0Vs79G2swdEyvADX0TGtPSX3bEkrp70LXw9gKFKHdaKh8x+mSsEVXd0VUEag4JsDLB3skMn+EEUtPJVhC23atKH9+/ebRZls2rRJCIqGDRtqbTZv3my2H7fh9QyfKzEx0awNO5Lya9mGt/v5+Zm1OXz4sAjXlW2A+xIYFCh8PWZ+NJGi69ZwdXcAsIvIuAia9u5YGrt8GASH0YFPh3OrzPJD/cKFC+Iv+11wyCvDuTY4V0bnzp2FuOjfvz/Nnz9f+FdMnz5d5NOQFoYRI0aIqJRJkybRo48+Slu2bKH3339fRLRIOFx2wIAB1KJFC2rVqhUtXryY/vnnHxo0aJDYzv4YgwcPFu3CwsKEqOHIFhYctkauANfTtmcrapOaSP9d/j9aOW0NXfsbVWuB5xBQMYAGPt2X7h3djXz9UNwblF/K7OrnfBuce0PSrFkz8Xfr1q3UoUMHMS3y6aefijweLAAqVaokxMPTTz+t7RMXFycEBufZePHFFyk6Oppef/11EcEi6du3rwix5fOxcGnatKkIp9U7ly5atEhEtXBSMI5K4f2XLVtWVm8dlBE+vj5076hu1KFvMi0YtIx2rf8eYw3cnuYpjWniqlFULQr+SeWKfIXnWOzb34CUeZ4Oo4A8He5H5q4jtGTU/9HPe465uisAFCC+SS0avWQw3dq2AUanHObpSIl/wu48HV/88iLydADgLiS0qktLvnuOBj3bD1EuwG0IjQgWFWGX7ZkHwQGABZhcBB4NT5s99GRvun98D/pk2ef09jMf0NVLV13dLVAOqRAUQGnT7hd+Gyg/D4gUkzNpqVEMOYhI7A8Mk9GUhcea314x3fQrIdwZOIeAQH/qMaITrT6+jPpNvheCA5hA9IpVIDqAoeC8Bxxi+9bRl4XTqZeXq3sEDIsXUffhnWjVkSU0ZtkwCqlqnPoYAJQVmF4BhoTrt4x86VG6Z2QX+nDxZ/S/N7dRTnauq7sFDICfvy+l9G9P941NpdhGNV3dHeCuiOgTRK9YAtEBDE1M/VvoiVeG0SOz+9K6l9bT2uc/odzrea7uFvBAOL8GCw1eqtao4uruAHdHyTct9uxvQCA6QLmgSkQIDXr2QeozqSetf/UL+s/iT+mv0xdd3S3gAYRGhNB9T6RS9xGdqHKVIFd3BwCPBqIDlDufjwf+dQ/1HN2NNq/+il6bvJr+vnDF1d0CbkilkIo0OD2NOg+4gwIC4ZgMSob0JNIAAA+qSURBVOlIWloURK8AYBj8A/yo2+CO9MH5/6N5m2ZQu/tbi4ynoHzj7e1Ft9/bkp7bMI0+/OsN6jGiMwQHKL1Ph71LGcElStLS0kSCNC6EyqVCrlwp/sfXjh076K677hIZxHnf9u3b07Vr10p0blg6AJX3PB/NOzYWy19nLtLKJ9fQzg3f06Xzl13dNeBEgqsFUWLnpjR07sMUHl0VYw8MbelIS0ujM2fOiAKqubm5olbZsGHDaM2aNUUKjq5du9LUqVNpyZIl5OvrS/v27RP30JKANOg2gjTo5QcuULhn4176dMUm+u7TDFd3B5QhLbs2pe7DO1NSanNYusoBTk2DHjWcfL3tSIOef52+OL3C4X09dOiQKLa6e/duUSiV4Xpld999N/3+++8UFRVldT8ukNqpUyd65pln7Do/LB0AWMDFCJNSE8Vy8ufTtHXN1/Ttx7vpl32/YawMQOytMZR8T0u686G2FNswxtXdAUZFRMzaY+kgTcTo4SrsshJ7aWCLBU+pSMHBpKSkCIvFzp07qVevXgX2OX/+vNjGFpLk5GQ6duwYJSQk0Jw5c6ht27YlOj9EBwBFEFMvih6Z1Vcsvx36nbb9+1v66KX19A9SrXsUFYMD6Z7Hu9JdD7WluFuRWwN4zvRKTIy5MJ45cybNmjWr1IflauwRERFm63iqJCwsTGyzxi+//CL+8nkXLlwoqrm/9dZb1LFjRzpw4ADVrVvX5vNDdABgI7UaRNOA2SxA+tCxfb8KAbLtve107rc/MIZuSHhMVerQJ5k69Lud6jaPJy+kpwUeyMmTJ82mVwqzckyZMoXmzZtX7NRKacjPN+UMGT58uPD/YJo1a0abN2+mlStXUnp6us3HgugAoITww6tO0zixcEhlxhc/0u4Ne2n/1z/RkQzTLwLgGmo3jaUmdzSkxM5NqEWXpiV2cgPAYYgHtR0JvvJN+7LgsMWnY8KECTRw4MAi28THx1NkZKSYLtGTl5cnIlp4mzVq1Kgh/rIviJ4GDRrQiRMnqCRAdABgpwBp0amJWJiL5y9Rxv/20X8WfSosIMgBUrZUCq1I1WuFU++x3YXQQKZQUF6jV8LDw8VSHG3atKGsrCzKyMigxMREsW7Lli3CmpGUlGR1n9jYWOFgevjwYbP1P//8M3Xr1q1E/YToAMDBmU9THm4vFv4SH/3hOO3euJe2f7yLjnx/nJQyjL0vF3gR1W5Si26/N0lEntRNjBeOvwAA22DrBIe+Dh06lJYvXy5CZkeNGkX9+vXTIldOnTol/DXYb6NVq1bix9XEiROFP0mTJk2ET8ebb75JmZmZ9MEHH1BJgOgAoIxg0369xNpiSZvWm7KvXhfTL4e++5kO7TxCe7cdoCsX/sH4F2PJaNqhESUk1aMGretSvcR4CgwKxJgB98eN83S88847QmiwsOD7VO/evemll17StrMQYavG1atXtXVjx46l7OxsGjdunJiKYfHBeT5q165donMjT4eNIE8HcDSKotD5E39S5q6jmhDJ3HmE8m8Ys9BTcXj7eFH9lnWogSow6reqQ5GxEXAABZ6ZpyNsEPl6+5f6OHn5OfTFhTfKtK+uAJYOAFwEmyzZH4GXOx5oI9blXM+h338+Q78fPk0nM0/TycOnKHP3UTpz9JzmQW6EVOPVY8MpIamuqAJcM+EWiq4fJZaACqW/SQMA3B+IDgDcCP8Af4pvXEssllaRP09doJOZp+hE5ik6knGMfvzykJh+uHjuEmWdy6J8N/EXYVHBlVmrRIbSlax/6Na2CVS/RR2KSWCBEUXVoqsiqgQYHkXJF4s9+xsRiA4APMQqwjVBeGmecpvV1O2X/7pCf5z8U/y9eDaLLpzNootnL9LebQepalQV0S4nO1csZ46fY59MUcwsJztHrMu+ki2SIAZWCiC/Cv7kX8FPrOebX4246uI1r2dR8cfvF4SvBQuLsMhQ8Te4ahBFxFSj4GqV4dwJAPtk2PNDQHGPHxGOBqIDAAPAERwcOcMLAMANEKIBosMSZM4BAAAAgFOApQMAAABwNOz47WWHX4YCnw4AAAAA2CQaML1iDUyvAAAAAMApYHoFAAAAcDBKfj4pdkyvKJheAQAAAICNqgHRK1bA9AoAAAAAnAKmVwAAAABHw4nBvJCnwxKIDgAAAKBMplfsCZlVyIhgegUAAAAATgGWDgAAAMDBKPkKKXZMrygGtXRAdAAAAACORoS8IiOpJRAdAAAAgIOBpcM68OkAAAAAgFOApaOE82uXL18uy88DAABAGSHv387wl8hTrttVtC2PcsmIQHTYyN9//y3+xsTElOXnAQAAwAn385CQkDI5tr+/P0VGRtI3Z9fbfazIyEhxPCPhpRjVRdbB5Ofn0+nTp6ly5crk5eVFnqLqWSSdPHmSgoODXd0dtwHjgnHB9VI+v0f8uGPBERUVRd7eZeddkJ2dTTk5OXYfx9/fnypUqEBGApYOG+ELNDo6mjwRviF4yk3BmWBcMC64Xsrf96isLBx6WCgYTSw4CjiSAgAAAMApQHQAAAAAwClAdBiYgIAAmjlzpvgLMC64XvA9wv0FuBo4kgIAAADAKcDSAQAAAACnANEBAAAAAKcA0QEAAAAApwDRAQAAAACnANHhAcyZM4eSk5OpYsWKFBoaarXNiRMnKDU1VbSJiIigiRMnUl5enlmbbdu2UfPmzUU0S506dWjVqlUFjrN06VKKjY0ViW2SkpJo165dBTLtjRw5kqpWrUpBQUHUu3dvOnfuHLkD3G/OFqtf5s6da9bmxx9/pHbt2on3x9kU58+fX+A4a9eupYSEBNGmcePGtH79+gJZDWfMmEE1atSgwMBASklJoSNHjpCnU9xn78nMmjWrwLXBn3FJrmtHfcdcyVdffUU9evQQGTl5DNatW1fia/vChQuUlpYmEoLx/Wjw4MF05coVh3/PgEHhNOjAvZkxY4bywgsvKOPHj1dCQkIKbM/Ly1NuvfVWJSUlRfnhhx+U9evXK9WqVVOmTp2qtfnll1+UihUrimP89NNPypIlSxQfHx9l48aNWpt///vfir+/v7Jy5Url4MGDytChQ5XQ0FDl3LlzWpsRI0YoMTExyubNm5U9e/YorVu3VpKTkxV3oFatWsrTTz+tnDlzRluuXLmibb906ZJSvXp1JS0tTTlw4IDy7rvvKoGBgcqKFSu0Nt9++60Yl/nz54txmj59uuLn56fs379fazN37lzxOaxbt07Zt2+fcs899yhxcXHKtWvXFE/Fls/ek5k5c6bSqFEjs2vjjz/+sPm6dtR3zNVwv6dNm6Z8+OGHXP5C+eijj8y223Jtd+3aVWnSpIny3XffKV9//bVSp04d5cEHH3T49wwYE4gOD+KNN96wKjr4RuLt7a2cPXtWW/fKK68owcHByvXr18XrSZMmiZuunr59+ypdunTRXrdq1UoZOXKk9vrGjRtKVFSUkp6eLl5nZWWJG8PatWu1NocOHRI3rx07dijuIDoWLVpU6PZly5YpVapU0caEmTx5slK/fn3tdZ8+fZTU1FSz/ZKSkpThw4eL/+fn5yuRkZHKggULtO08LgEBAeLm6qkU99kbQXTwg9IatlzXjvqOuROWosOWa5sFAu+3e/durc2GDRsULy8v5dSpUw77ngHjgukVA7Bjxw5hnqxevbq2rkuXLqIg08GDB7U2bCrVw214PcPFiTIyMszacL0Zfi3b8Pbc3FyzNmwerVmzptbG1fB0CpvImzVrRgsWLDAzf3Mf27dvb1a1kcfg8OHDdPHiRZvG6fjx43T27FmzNlzLgacj3GUMSootn70R4GkCnlaIj48X0wM8XWLrde2I75i7Y8u1zX95SqVFixZaG27P18vOnTsd9j0DxgUF3wwA3yj0N0NGvuZtRbXhm+a1a9fEzeDGjRtW22RmZmrH4BuJpV8Jt5HncSVjxowR8+lhYWG0fft2mjp1Kp05c4ZeeOEFsZ37GBcXV+g4ValSpdBx0o+jfj9rbTyNP//8s9jP3tPhByf7V9SvX19cE7NnzxY+BwcOHLDpunbEd4x9JNwZW65t/sv+LHp8fX3Fd07fxt7vGTAuEB0uYsqUKTRv3rwi2xw6dMjM2a08UpJxGj9+vLbutttuEw+S4cOHU3p6OlLBl3O6detmdm2wCKlVqxa9//77bi8GADASEB0uYsKECTRw4MAi27AZ2BYiIyMLRBpIz3veJv9aeuPza/ZA55uuj4+PWKy10R+DTfFZWVlmvwr1bdxpnPjBwtMrv/76q/iFW9gY2DJO+u1yHXv469s0bdqUPJFq1aoV+9kbDb5+69WrR0ePHqVOnToVe1074jvm7thybXOb8+fPm+3H3zGOaCluHEryPQPGBT4dLiI8PFz8Oi9q0c+JFkWbNm1o//79ZjeDTZs2iZtdw4YNtTabN28224/b8HqGz5WYmGjWJj8/X7yWbXi7n5+fWRuep+W5cdnGncZp7969Yq5ZmoO5jxwyyPP3+jFgQcImX1vGic3GfGPUt2HzOc9nl9UYlDW2fPZGg0M8jx07Jh6utlzXjviOuTu2XNv8l8UZ+8FItmzZIq4XFvmO+p4BA+NqT1ZQPL/99psI05s9e7YSFBQk/s/L33//bRbO17lzZ2Xv3r0iRC88PNxqON/EiROFZ/7SpUuthsyyp/qqVauEl/qwYcNE2KTeY59DC2vWrKls2bJFhBa2adNGLK5m+/btInKF3/+xY8eU1atXizF45JFHzDzxOZSvf//+IpSP3y+PiWUon6+vr7Jw4UIxThz1YC1klsfl448/Vn788UelZ8+ehgiZLe6z92QmTJigbNu2TTl+/Lj4jDn0lUNez58/b9N17ajvmKvhe4a8f/Dtn0Px+f98j7H12uaQ2WbNmik7d+5UvvnmG6Vu3bpmIbOO+p4BYwLR4QEMGDBA3CAsl61bt2ptfv31V6Vbt24iHp5vpnyTzc3NNTsOt2/atKnIxxAfHy9CcC3h3AJ88+U2HEbJsfh6+Obz+OOPi5A4vpH06tVL5DxwNRkZGSLkjkOKK1SooDRo0EB57rnnlOzsbLN2nHugbdu24gF7yy23iJusJe+//75Sr149MQYcAvnZZ5+ZbefQwqeeekrcWPk4HTt2VA4fPqx4OsV99p4Mh67WqFFDvDf+3Pn10aNHS3RdO+o75kq4f9buJXyPsfXa/uuvv4TI4B9AHDI8aNAg7QeQI79nwJigtD0AAAAAnAJ8OgAAAADgFCA6AAAAAOAUIDoAAAAA4BQgOgAAAADgFCA6AAAAAOAUIDoAAAAA4BQgOgAAAADgFCA6AAAAAOAUIDoAAAAA4BQgOgAAAADgFCA6AAAAAOAUIDoAAAAAQM7g/wG5QH0C4MdXhQAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots()\n", + "ax.set_aspect(\"equal\")\n", + "colors = firedrake.tripcolor(extract_surface(a), vmin=-0.7, axes=ax)\n", + "fig.colorbar(colors);" + ] + }, + { + "cell_type": "markdown", + "id": "4b97c83c-e389-43ab-bdad-c0e194c1380b", + "metadata": {}, + "source": [ + "In order to calculate the material properties of the glacier, we'll assume that it's roughly temperate, which isn't too far off from the truth." + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "id": "e3b0b711-e898-4760-b326-807afae85a56", + "metadata": {}, + "outputs": [], + "source": [ + "from icepack2.constants import gravity, ice_density, glen_flow_law\n", + "A = icepack.rate_factor(Constant(273.15))" + ] + }, + { + "cell_type": "markdown", + "id": "bec1a763-ab01-4f63-ae93-d92f0ce0ef2a", + "metadata": {}, + "source": [ + "We'll use the shallow ice approximation, which diagnoses the velocity at a point in a purely local fashion using the thickness and surface slope, to initialize the ice velocity." + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "id": "1ec09854-3b85-43d0-84f9-6959508d4865", + "metadata": {}, + "outputs": [], + "source": [ + "V = firedrake.VectorFunctionSpace(mesh, cg1, dim=2, vfamily=\"R\", vdegree=0)\n", + "\n", + "u = firedrake.Function(V)\n", + "v = firedrake.TestFunction(V)\n", + "\n", + "ρ_I = Constant(ice_density)\n", + "g = Constant(gravity)\n", + "n = Constant(glen_flow_law)\n", + "\n", + "P = ρ_I * g * h\n", + "S_n = inner(grad(s), grad(s))**((n - 1) / 2)\n", + "u_shear = -2 * A * P ** n / (n + 2) * h * S_n * grad(s)\n", + "F = inner(u - u_shear, v) * dx\n", + "\n", + "solver_params = {\"snes_type\": \"ksponly\", \"ksp_type\": \"gmres\"}\n", + "fc_params = {\"quadrature_degree\": 6}\n", + "params = {\"solver_parameters\": solver_params, \"form_compiler_parameters\": fc_params}\n", + "firedrake.solve(F == 0, u, **params)" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "id": "5a32887c-dcd3-4aae-844e-1a6c70b183db", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots()\n", + "ax.set_aspect(\"equal\")\n", + "colors = firedrake.tripcolor(extract_surface(u), axes=ax)\n", + "fig.colorbar(colors);" + ] + }, + { + "cell_type": "markdown", + "id": "9a900c91-a77f-4d7a-86e3-9c014512e3b9", + "metadata": {}, + "source": [ + "Now we'll get to the real modeling.\n", + "To proceed, we have to make function spaces to represent the membrane and basal stresses and create a variable that stores the velocity and stresses.\n", + "Here we use piecewise constant finite elements for the stresses.\n", + "In general, if you use $CG(k)$ elements for the velocity, you need to use $DG(k - 1)$ elements for the stresses." + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "id": "db935250-689e-4ca7-aee5-c5b0f212c4d4", + "metadata": {}, + "outputs": [], + "source": [ + "vfamily = \"DG\"\n", + "vdegree = 2\n", + "V = firedrake.VectorFunctionSpace(mesh, \"CG\", 2, dim=2, vfamily=vfamily, vdegree=vdegree)\n", + "Σx = firedrake.TensorFunctionSpace(mesh, \"DG\", 1, shape=(2, 2), symmetry=True, vfamily=vfamily, vdegree=max(0, vdegree - 1))\n", + "T = firedrake.VectorFunctionSpace(mesh, \"DG\", 1, dim=2, vfamily=vfamily, vdegree=max(0, vdegree - 1))\n", + "T0 = firedrake.VectorFunctionSpace(mesh, \"DG\", 1, dim=2, vfamily=\"R\", vdegree=0)\n", + "Z = V * Σx * T * T0\n", + "z = firedrake.Function(Z)\n", + "\n", + "u = firedrake.Function(V).interpolate(u)\n", + "z.sub(0).assign(u);" + ] + }, + { + "cell_type": "markdown", + "id": "1d649590-0970-42c5-9fa2-52d8bb325dbf", + "metadata": {}, + "source": [ + "This is a subtle but important point.\n", + "But we'll also want to regularize the momentum balance model a bit by pretending as if it were linear.\n", + "We chose some value of the ice fluidity $A$, which is fine, but remember that $A$ has units of strain rate $\\times$ stress${}^{-n}$ where $n \\approx 3$ is the Glen flow law exponent.\n", + "If we only change $n$ to 1 in the parts of the equation determining the constitutive relation but do nothing to $A$, the physical units that we use in the regularization will make no sense.\n", + "So what we do below is pick some arbitrary stress scale $\\tau_c$, which here I'm taking to be 0.1 MPa or 100 kPa.\n", + "We're then choosing a strain rate scale $\\dot\\varepsilon_c$ so that $A = \\dot\\varepsilon_c \\cdot\\tau_c^{-n}$.\n", + "If we want to pretend like ice flow were linear, we could produce the right constitutive relation by then using the flow law coefficient $A' = \\dot\\varepsilon_c\\cdot\\tau_c^{-1}$ and all the units would make sense." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "cc16a5dd-3c51-453f-938c-895dd0963051", + "metadata": {}, + "outputs": [], + "source": [ + "τ_c = Constant(0.1)\n", + "ε_c = Constant(A * τ_c ** n)" + ] + }, + { + "cell_type": "markdown", + "id": "b16d9a32-7b64-4ce9-aa1e-cf38e900765e", + "metadata": {}, + "source": [ + "Now we're at the really important part.\n", + "To make the SSA model effectively do SIA, what we need is that, in the sliding law\n", + "$$K|\\tau|^{m - 1}\\tau = -u,$$\n", + "we take\n", + "$$K = \\frac{hA}{n + 2}.$$\n", + "Now in order to make our regularization approach work, we also define the sliding coefficient as\n", + "$$K = u_c / \\tau_c^m$$\n", + "where $\\tau_c$ is a reference stress and $u_c$ a reference speed.\n", + "We're using the same reference stress for the flow and sliding laws of $\\tau_c = $ 100 kPa, so we can then compute the reference speed as $u_c = K\\tau_c^m$.\n", + "We can then add more sliding on top of the effective deformation that we use to mimic SIA.\n", + "To add some extra real sliding, we've increased the critical speed $u_c$ by a factor of 100 m/yr." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "1b9a1932-e82b-45ac-a353-07c6d0f2ab67", + "metadata": {}, + "outputs": [], + "source": [ + "K = h * A / (n + 2)\n", + "U_c = Constant(100.0)\n", + "u_c = K * τ_c ** n + U_c" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "f4bbe65a-e7ee-41e7-9742-9feda268c3cc", + "metadata": {}, + "outputs": [], + "source": [ + "rheology = {\n", + " \"flow_law_exponent\": n,\n", + " \"flow_law_coefficient\": ε_c / τ_c ** n,\n", + " \"sliding_exponent\": n,\n", + " \"sliding_coefficient\": u_c / τ_c ** n,\n", + "}\n", + "\n", + "u, M, τ = firedrake.split(z)\n", + "fields = {\n", + " \"velocity\": u,\n", + " \"membrane_stress\": M,\n", + " \"basal_stress\": τ,\n", + " \"thickness\": h,\n", + " \"surface\": s,\n", + "}\n", + "\n", + "L = sum(fn(**fields, **rheology) for fn in fns)\n", + "F = derivative(L, z)" + ] + }, + { + "cell_type": "markdown", + "id": "9b8cdb6d-1b52-4e65-abd6-968b5eaf545a", + "metadata": {}, + "source": [ + "For the solution procedure, we'll want to use a linearization of the problem where the thickness is clamped from below." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "46a2aff8-bee5-4d9d-8f16-b4424484bf14", + "metadata": {}, + "outputs": [], + "source": [ + "h_min = Constant(1e-5)\n", + "\n", + "rfields = {\n", + " \"velocity\": u,\n", + " \"membrane_stress\": M,\n", + " \"basal_stress\": τ,\n", + " \"thickness\": max_value(h_min, h),\n", + " \"surface\": s,\n", + "}\n", + "\n", + "L_r = sum(fn(**rfields, **rheology) for fn in fns)\n", + "F_r = derivative(L_r, z)\n", + "J_r = derivative(F_r, z)" + ] + }, + { + "cell_type": "markdown", + "id": "4d91d056-05ff-4abb-a702-c1683b6a3718", + "metadata": {}, + "source": [ + "Observe below that, when we create the momentum balance problem, we want to find a zero of $F$ using a Newton-type method, but we're using the perturbation of $dF$ defined above in order to do the search." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "a1042066-7992-4d32-8a1d-62a006a2de11", + "metadata": {}, + "outputs": [], + "source": [ + "degree = 1\n", + "qdegree = max(8, degree ** glen_flow_law)\n", + "pparams = {\"form_compiler_parameters\": {\"quadrature_degree\": qdegree}}\n", + "momentum_problem = firedrake.NonlinearVariationalProblem(F, z, J=J_r, **pparams)" + ] + }, + { + "cell_type": "markdown", + "id": "35f45cb5-f7b2-40d7-aced-514de7a1f8dc", + "metadata": {}, + "source": [ + "Now we can see our initial value of the velocity.\n", + "Note how it's a different magnitude but similar shape to the SIA velocity." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "4040c1bb-a861-4697-b91b-f3ffc7ef04d9", + "metadata": {}, + "outputs": [], + "source": [ + "sparams = {\n", + " \"snes_monitor\": \":rainier-output.log\",\n", + " \"snes_type\": \"newtonls\",\n", + " \"snes_max_it\": 200,\n", + " \"snes_linesearch_type\": \"nleqerr\",\n", + " \"ksp_type\": \"gmres\",\n", + " \"pc_type\": \"lu\",\n", + " \"pc_factor_mat_solver_type\": \"umfpack\",\n", + "}\n", + "momentum_solver = firedrake.NonlinearVariationalSolver(momentum_problem, solver_parameters=sparams)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e618ec87-b03f-44a8-8f0d-84b7ba2f58d9", + "metadata": {}, + "outputs": [], + "source": [ + "num_continuation_steps = 5\n", + "for exponent in np.linspace(1.0, 3.0, num_continuation_steps):\n", + " n.assign(exponent)\n", + " momentum_solver.solve()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "27dea728-7c56-4a3c-83fb-87e7b32cc881", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "u, M, τ = z.subfunctions\n", + "\n", + "fig, axes = plt.subplots()\n", + "axes.set_aspect(\"equal\")\n", + "colors = firedrake.tripcolor(u, axes=axes)\n", + "fig.colorbar(colors);" + ] + }, + { + "cell_type": "markdown", + "id": "ed3613d7-c669-41b3-ba8a-5ae1244a2f94", + "metadata": {}, + "source": [ + "Let's zoom in and look at where the ELA falls." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "f5010542-3587-4bb8-9063-853a07e37449", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "firedrake:WARNING Subdomain (1,) is empty. This is likely an error. Did you choose the right label?\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, axes = plt.subplots()\n", + "axes.set_aspect(\"equal\")\n", + "axes.set_xlim((0, 10e3))\n", + "axes.set_ylim((0, 10e3))\n", + "colors = firedrake.tripcolor(u, axes=axes)\n", + "firedrake.triplot(mesh, axes=axes)\n", + "firedrake.tricontour(a, levels=[0, 1], colors=\"tab:orange\", axes=axes)\n", + "fig.colorbar(colors);" + ] + }, + { + "cell_type": "markdown", + "id": "5ffc3b9c-aa85-4c85-b11f-a95db0bc5363", + "metadata": {}, + "source": [ + "Nowe we can form the mass balance equation.\n", + "We'll solve it using the backward Euler method." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "838cbb65-00dc-4b41-a5f1-ae7d669fbbce", + "metadata": {}, + "outputs": [], + "source": [ + "G = model.mass_balance(thickness=h, velocity=u, accumulation=a)\n", + "tableau = irksome.BackwardEuler()\n", + "t = Constant(0.0)\n", + "dt = Constant(1.0 / 6)\n", + "sparams = {\n", + " \"solver_parameters\": {\n", + " \"ksp_type\": \"gmres\",\n", + " \"pc_type\": \"ilu\",\n", + " },\n", + "}\n", + "mass_solver = irksome.TimeStepper(G, tableau, t, dt, h, **sparams)" + ] + }, + { + "cell_type": "markdown", + "id": "52525e1f-b2d0-41e2-9d10-4f49e33c2648", + "metadata": {}, + "source": [ + "The good part: run the model for 500 years of simulation time." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e4892bde-6369-453d-9503-12ee491a537c", + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "81dce65ed8bd45f0afc23683f163e532", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + " 0%| | 0/3000 [00:00 Date: Thu, 18 Jun 2026 16:45:31 -0400 Subject: [PATCH 7/8] Updating notebook, still some convergence issues though --- notebooks/rainier_hybrid.ipynb | 2416 ++++++++++++++++++++------------ 1 file changed, 1482 insertions(+), 934 deletions(-) diff --git a/notebooks/rainier_hybrid.ipynb b/notebooks/rainier_hybrid.ipynb index 4fdc7af..f54a3d6 100644 --- a/notebooks/rainier_hybrid.ipynb +++ b/notebooks/rainier_hybrid.ipynb @@ -1,940 +1,1488 @@ { - "cells": [ - { - "cell_type": "code", - "execution_count": 20, - "id": "2bbcb16d-d444-46d3-810a-ab79194a91eb", - "metadata": {}, - "outputs": [], - "source": [ - "from tqdm.notebook import trange\n", - "import numpy as np\n", - "from numpy import pi as π\n", - "import matplotlib.pyplot as plt\n", - "import firedrake\n", - "from firedrake import inner, dx, exp, min_value, max_value, Constant, derivative\n", - "import irksome\n", - "import icepack\n", - "from icepack2 import model\n", - "from icepack.calculus import grad" - ] - }, - { - "cell_type": "code", - "execution_count": 21, - "id": "205d8e57", - "metadata": {}, - "outputs": [], - "source": [ - "def extract_surface(q_in):\n", - " mesh_x = q_in.ufl_domain()._base_mesh\n", - " shape = q_in.ufl_shape\n", - " if len(shape) == 0:\n", - " VLin = firedrake.FunctionSpace(q_in.ufl_domain(), \"CG\", 2, vfamily=\"CG\", vdegree=1)\n", - " q_targ = firedrake.Function(VLin).interpolate(q_in)\n", - " element_xz = q_targ.ufl_element()\n", - " if hasattr(element_xz, \"factor_elements\"):\n", - " element_x = element_xz.factor_elements[0]\n", - " else:\n", - " element_x = element_xz.sub_elements[0]\n", - " else:\n", - " VLin = firedrake.VectorFunctionSpace(q_in.ufl_domain(), \"CG\", 2, dim=shape[0], vfamily=\"CG\", vdegree=1)\n", - " q_targ = firedrake.Function(VLin).interpolate(q_in)\n", - " element_xz = q_targ.ufl_element()\n", - " if hasattr(element_xz, \"factor_elements\"):\n", - " element_hor = element_xz.factor_elements[0]\n", - " else:\n", - " element_hor = element_xz.sub_elements[0]\n", - " if hasattr(element_hor, \"factor_elements\"):\n", - " element_xy = element_hor.factor_elements[0]\n", - " else:\n", - " element_xy = element_hor.sub_elements[0]\n", - " element_x = firedrake.VectorElement(element_xy, dim=shape[0])\n", - "\n", - " Q_x = firedrake.FunctionSpace(mesh_x, element_x)\n", - " q_x = firedrake.Function(Q_x)\n", - " if len(shape) > 0:\n", - " q_x.dat.data[:] = q_targ.dat.data[1::2, :]\n", - " else:\n", - " q_x.dat.data[:] = q_targ.dat.data[1::2]\n", - " return q_x\n", - "\n", - "\n", - "def extract_bed(q_in):\n", - " mesh_x = q_in.ufl_domain()._base_mesh\n", - " shape = q_in.ufl_shape\n", - " if len(shape) == 0:\n", - " VLin = firedrake.FunctionSpace(q_in.ufl_domain(), \"CG\", 2, vfamily=\"CG\", vdegree=1)\n", - " q_targ = firedrake.Function(VLin).interpolate(q_in)\n", - " element_xz = q_targ.ufl_element()\n", - " if hasattr(element_xz, \"factor_elements\"):\n", - " element_x = element_xz.factor_elements[0]\n", - " else:\n", - " element_x = element_xz.sub_elements[0]\n", - " else:\n", - " VLin = firedrake.VectorFunctionSpace(q_in.ufl_domain(), \"CG\", 2, dim=shape[0], vfamily=\"CG\", vdegree=1)\n", - " q_targ = firedrake.Function(VLin).interpolate(q_in)\n", - " element_xz = q_targ.ufl_element()\n", - " if hasattr(element_xz, \"factor_elements\"):\n", - " element_xy = element_xz.factor_elements[0].sub_elements[0]\n", - " elif hasattr(element_xz.sub_elements[0], \"factor_elements\"):\n", - " element_xy = element_xz.sub_elements[0].factor_elements[0]\n", - " else:\n", - " element_xy = element_xz.sub_elements[0].sub_elements[0]\n", - " element_x = firedrake.VectorElement(element_xy, dim=shape[0])\n", - "\n", - " Q_x = firedrake.FunctionSpace(mesh_x, element_x)\n", - " q_x = firedrake.Function(Q_x)\n", - " if len(shape) > 0:\n", - " q_x.dat.data[:] = q_targ.dat.data[::2, :]\n", - " else:\n", - " q_x.dat.data[:] = q_targ.dat.data[::2]\n", - " return q_x" - ] - }, - { - "cell_type": "markdown", - "id": "3ed26c06-ea87-4688-9761-e98e5b26684d", - "metadata": {}, - "source": [ - "This notebook will demonstrate how to use the dual momentum balance model to simulate the evolution of a synthetic mountain glacier.\n", - "We'll start with a completely artificial initial glacier thickness, and then we'll spin it up to steady state.\n", - "The overall bed geometry is meant to mimic some of the features of Mt. Rainier in Washington State, but we'll produce a smaller glacier.\n", - "For many measurements, see [this volume](http://npshistory.com/publications/mora/glaciers-1963.pdf) from 1963, edited by Mark Meier and featuring many contributions by Austin Post.\n", - "\n", - "Mt. Rainier has a circumference of about 150km, which works out to a radius of about 25km.\n", - "We'll use a computational domain about half that size." - ] - }, - { - "cell_type": "code", - "execution_count": 22, - "id": "f4ed4de3-bfb5-4f7f-bfba-52fc0e913f8c", - "metadata": {}, - "outputs": [], - "source": [ - "radius = Constant(12e3)\n", - "mesh2d = firedrake.UnitDiskMesh(4)\n", - "mesh2d.coordinates.dat.data[:] *= float(radius)\n", - "mesh = firedrake.ExtrudedMesh(mesh2d, layers=1)" - ] - }, - { - "cell_type": "markdown", - "id": "55e5e816-7f40-435e-aa22-78051037a76b", - "metadata": {}, - "source": [ - "Next, we'll create some function spaces.\n", - "We'll use continuous linear finite elements for the basal elevation and discontinuous linear elements for the thickness.\n", - "In general, solving the mass balance equation for ice thickness tends to work much better with discontinuous elements." - ] - }, - { - "cell_type": "code", - "execution_count": 23, - "id": "94cbe500-16ff-4824-b873-d94427a23278", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/dlilien/sw/firedrake/venv-firedrake/lib/python3.14/site-packages/finat/ufl/elementlist.py:433: UserWarning: Discontinuous Lagrange element requested on triangle * interval, creating DQ element.\n", - " warnings.warn(\"Discontinuous Lagrange element requested on %s, creating DQ element.\" % cell.cellname)\n" - ] - } - ], - "source": [ - "cg1 = firedrake.FiniteElement(\"CG\", \"triangle\", 1)\n", - "S = firedrake.FunctionSpace(mesh, cg1, vfamily=\"R\", vdegree=0)\n", - "dg1 = firedrake.FiniteElement(\"DG\", \"triangle\", 1)\n", - "Q = firedrake.FunctionSpace(mesh, dg1, vfamily=\"R\", vdegree=0)" - ] - }, - { - "cell_type": "markdown", - "id": "c3d0b834-dbca-4b2b-9533-44125ce72c71", - "metadata": {}, - "source": [ - "Mt. Rainier is about 4km high.\n", - "We'll use a bed topography of the form $B\\exp(-|x|^2/r^2)$, although this is actually a little unrealistic." - ] - }, - { - "cell_type": "code", - "execution_count": 24, - "id": "58d11b38-22fb-4db3-bcf9-f989817715c2", - "metadata": {}, - "outputs": [], - "source": [ - "x = firedrake.SpatialCoordinate(mesh)\n", - "\n", - "B = Constant(4e3)\n", - "r_b = Constant(150e3 / (2 * π))\n", - "expr = B * exp(-(x[0]**2 + x[1]**2) / r_b**2)\n", - "b = firedrake.Function(S).interpolate(expr)" - ] - }, - { - "cell_type": "code", - "execution_count": 25, - "id": "24945f29-c8d5-4a0e-84f0-9253dd1d2067", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "fig, ax = plt.subplots()\n", - "ax.set_aspect(\"equal\")\n", - "ax.set_title(\"Bed elevation\")\n", - "colors = firedrake.tripcolor(extract_bed(b), axes=ax)\n", - "firedrake.tricontour(extract_bed(b), levels=[1600.0, 2100.0], colors=\"black\", axes=ax)\n", - "fig.colorbar(colors);" - ] - }, - { - "cell_type": "markdown", - "id": "799ff14c-f764-46eb-842c-8034f6c7476f", - "metadata": {}, - "source": [ - "According to Meier and Post, at 1600m elevation, the surface mass balance is about -8.7 m/yr of water equivalent, and the equilibrium line altitude (where surface mass balance is zero) is at about 2100m elevation, and that the SMB must average about 0.7 m/yr above the ELA for the glacier to be in balance.\n", - "We'll use these as rough guidelines; trying to be too exact about it gives an accumulation field with a really dramatic change near the ELA that results in generalized numerical mayhem.\n", - "When we define the SMB field, we clamp the values at the top and bottom in order to avoid producing unrealistic values.\n", - "Not also how we have to convert one of the SMB values from meters of water equivalent to meters of ice equivalent by multiplying by 0.917." - ] - }, - { - "cell_type": "code", - "execution_count": 26, - "id": "eaeced4e-119f-4e85-a038-f7ef03964648", - "metadata": {}, - "outputs": [], - "source": [ - "z_measured = Constant(1600.0)\n", - "a_measured = Constant(-0.917 * 8.7)\n", - "a_top = Constant(0.7)\n", - "z_top = Constant(4e3)\n", - "δa_δz = (a_top - a_measured) / (z_top - z_measured)\n", - "a_max = Constant(0.7)\n", - "\n", - "def smb(z):\n", - " return min_value(a_max, a_measured + δa_δz * (z - z_measured))" - ] - }, - { - "cell_type": "markdown", - "id": "cf4ccb68-c028-4a97-9479-caf99ea467b9", - "metadata": {}, - "source": [ - "We'll start with a very artificial initial guess for the thickness and evolve it toward equilibrium." - ] - }, - { - "cell_type": "code", - "execution_count": 27, - "id": "e49e504f-ac00-4c7e-a055-ffe1cd84b054", - "metadata": {}, - "outputs": [], - "source": [ - "r_h = Constant(5e3)\n", - "H = Constant(100.0)\n", - "expr = H * max_value(0, 1 - inner(x, x) / r_h**2)\n", - "h = firedrake.Function(Q).interpolate(expr)\n", - "h_0 = h.copy(deepcopy=True)" - ] - }, - { - "cell_type": "code", - "execution_count": 28, - "id": "16e78f35-2127-467b-91ff-abfa23addde1", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "fig, ax = plt.subplots()\n", - "ax.set_aspect(\"equal\")\n", - "colors = firedrake.tripcolor(extract_surface(h), axes=ax)\n", - "fig.colorbar(colors);" - ] - }, - { - "cell_type": "markdown", - "id": "ea593b0b-c5f1-4d2a-a70a-f8537ab35167", - "metadata": {}, - "source": [ - "We can then compute the initial surface elevation and mass balance." - ] - }, - { - "cell_type": "code", - "execution_count": 29, - "id": "0641ac14-e8e1-496b-9ffd-e376c7ae3974", - "metadata": {}, - "outputs": [], - "source": [ - "s = firedrake.Function(Q).interpolate(b + h)\n", - "a = firedrake.Function(Q).interpolate(smb(s))" - ] - }, - { - "cell_type": "code", - "execution_count": 30, - "id": "4ec0e6ba-bff9-4493-88cc-cd9a88505224", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "fig, ax = plt.subplots()\n", - "ax.set_aspect(\"equal\")\n", - "colors = firedrake.tripcolor(extract_surface(a), vmin=-0.7, axes=ax)\n", - "fig.colorbar(colors);" - ] - }, - { - "cell_type": "markdown", - "id": "4b97c83c-e389-43ab-bdad-c0e194c1380b", - "metadata": {}, - "source": [ - "In order to calculate the material properties of the glacier, we'll assume that it's roughly temperate, which isn't too far off from the truth." - ] - }, - { - "cell_type": "code", - "execution_count": 31, - "id": "e3b0b711-e898-4760-b326-807afae85a56", - "metadata": {}, - "outputs": [], - "source": [ - "from icepack2.constants import gravity, ice_density, glen_flow_law\n", - "A = icepack.rate_factor(Constant(273.15))" - ] - }, - { - "cell_type": "markdown", - "id": "bec1a763-ab01-4f63-ae93-d92f0ce0ef2a", - "metadata": {}, - "source": [ - "We'll use the shallow ice approximation, which diagnoses the velocity at a point in a purely local fashion using the thickness and surface slope, to initialize the ice velocity." - ] - }, - { - "cell_type": "code", - "execution_count": 32, - "id": "1ec09854-3b85-43d0-84f9-6959508d4865", - "metadata": {}, - "outputs": [], - "source": [ - "V = firedrake.VectorFunctionSpace(mesh, cg1, dim=2, vfamily=\"R\", vdegree=0)\n", - "\n", - "u = firedrake.Function(V)\n", - "v = firedrake.TestFunction(V)\n", - "\n", - "ρ_I = Constant(ice_density)\n", - "g = Constant(gravity)\n", - "n = Constant(glen_flow_law)\n", - "\n", - "P = ρ_I * g * h\n", - "S_n = inner(grad(s), grad(s))**((n - 1) / 2)\n", - "u_shear = -2 * A * P ** n / (n + 2) * h * S_n * grad(s)\n", - "F = inner(u - u_shear, v) * dx\n", - "\n", - "solver_params = {\"snes_type\": \"ksponly\", \"ksp_type\": \"gmres\"}\n", - "fc_params = {\"quadrature_degree\": 6}\n", - "params = {\"solver_parameters\": solver_params, \"form_compiler_parameters\": fc_params}\n", - "firedrake.solve(F == 0, u, **params)" - ] - }, - { - "cell_type": "code", - "execution_count": 34, - "id": "5a32887c-dcd3-4aae-844e-1a6c70b183db", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAhoAAAGdCAYAAABU5NrbAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjksIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvJkbTWQAAAAlwSFlzAAAPYQAAD2EBqD+naQAAud5JREFUeJzsnQecXHW5/p9Tpm1NbxAIPdREAgQQrEjwYkFRAQuICOJFFCJVEVDxBlEQURDxiuhfEcTCVcQgRkClE3oJgrRAetsyO+2U/+d5f+fMzCYLJNnsTtn3i8fdmTkzc+bMZn7PvOV5rTAMQyiKoiiKogwB9lA8qKIoiqIoigoNRVEURVGGFI1oKIqiKIoyZKjQUBRFURRlyFChoSiKoijKkKFCQ1EURVGUIUOFhqIoiqIoQ4YKDUVRFEVRhgx36B66uQiCAEuWLEF7ezssy6r14SiKoiibCP0pe3p6MGXKFNj20H3PzufzKBaLg36cZDKJdDqNRkeFxkZCkTF16tShfTcURVGUIWfx4sXYeuuth0xkbLdtG5at8Af9WJMmTcKLL77Y8GJDhcZGwkhG/Afa0dExlO+JoiiKMgR0d3fLF8b483woYCSDIuPFhduio33zoybdPQG2m/WyPJ4KjRFCnC6hyFChoSiK0rgMR/qbImMwQqOZ0IiGoiiKomxh/DCAHw7u/s2CCg1FURRF2cIECGXbXAZz33pDhYaiKIqibGEC+W9w928WNIGkKIqiKMqQoRENRVEURdnC+GEo2+YymPvWGyo0FEVRFGULozUaFTR1oiiKoijKkKERDUVRFEUZgoiGr10nggoNRVEURdnCaOqkgqZOFEVRFEUZMjSioSiKoihbGO06qaBCQ1EURVG2MLTbGpxhV/OgqRNFUYQgCOD7gx9trSiKUo1GNBSlCSjkClizdB1WLF6J7tVZrF22DmuWrZWfj//jGYya2AnOqyzmiyjmS1j12hoEQYhEwpHLvN4rGZHhuA6S6YRsvsfrLIzbegyS6aRcZ9kWVi9Zixlv3x1jJo3C6Emj5GfbqFZMnDZeLmda07U+JYpSU/xBdp34OutEUZThxCt5eO35ZXj12SVYvOg1/PvhF/DUvxYh05bG2uVd6OvJveH9X/33ko1+LoqLXC+3fPm63nXZDfZb8vyy130MHhfFTT5bwK7774Rd9tkRU6dvhW2mT8HkHSYhmUps9PEoSiPCya2Dm96KpkEjGopSR/T15vDCYy/j1X8vFUGx+NnX8NzC/2DVkrVopC84FCmxULnn5gdlq4ZRj1322QFTd5kiAmTrXaZg2h5T0T6qrUZHrChbFq3RqKBCQ1FqRBiGeGXRa3jmvuew6L5/45n7n8MLT7zcUIJic2FK575bFspWxgKm7T4Vu87eWaIg02fvhG132xq2raVkitLIqNBQlGGie02PiIpn7vs3Fj3wPJ66e5GkFpSIEHjpycWy/eWnC+SqZCaJ3Q/cBbvO3gm77r8zps/eEaPGd+opU+qeABZ8qYza/Ps3Cyo0FGUI6yqeuvtZPDj/Edzzxwfx6rNLJYqhbDzFXBGPLHhCtpgpO07CWz+4L/Y57C3Y46DpWu+h1CVBaLbNZTD3rTdUaCjKFmT5yyvxwF8ewc1X3Irli1ehoBGLLQ6LUG+69E+ysah0/DZj8aEvHo59D5uJKTtM2vJPqCjKoFChoSiDgL4Td9/8AB6c/6h0gSx+duO7O5TBUyyU8Npzy/DDU39ajnbsefB07H3IXnjbRw6Am9CPOKU2+INMnfiaOlGUkQvTH6yvuOOGu/HP390n7aVK/UQ7uN32sztx1Zd+hoM+vD/eefRbscfB0+E4Tq0PTxlBqNCooHJfUTaSZx/6D+749b/w52tu1yLOBqBrVY+8V9xSLUkcdvy78K5PHCyFpZbVPIV2ilLvqNBQlDfg+UdfxF9/fifu//PDb2hQpdQ3hb4i/u/K+bJNmjYesw+fhfcc+3bssu+OtT40pUkJQku2zWUw9603VGgoygDdIv/6/f245ce347E7n9Lz02Qse2llWXSwa+V9nzsUBx85WyzWFWVLoamTCio0FCVi2UsrcM2Zv8DDC55Adl2fnpcRwJP/WiTb9/87LbNbPnfpcdh6p8m1PixFaSpUaCgY6V0j99/yMG758V+x8K+PyaAxZeSR68mXnUr3PmRPiXIc8IF9tGtF2Wx82LJtLs00R1mFhjIiyWXz+MtPFuC6C26QRUZRYh7+2xOypVtT+NT5H8Xhn3sPWjta9AQpm0Q4yBqNUGs0FKVxbcBvvuIvkp/vXt1T68NR6hjaw//k7F/i+v/5PT7w33NwxBffizETR9f6sJQGQWs0KmhEQxkRrFi8Cr+99E/441Xz4Xucq6goG0e2qw+/nvcH3HjJ/+Hwk96Dj57xfkzebqKePkXZSFRoKE3Nc4+8gN9edgv+8Zt74JWaKeupDDeBH+BPP7pNfDkO+vB++Mjc98ukWUUZCD+0Zdtc/CYqF1OhoTRtBOMXF/wGt113R60PRWlCwfGPm+6T7d2fPBjHXXgUJm+vEQ5lvb8TWAgGUQwacJxxk6BCQ2kqulZ14+ozfoG7brwHpUKp1oejNDkLfvlP+Vt764dn4+RLj8O4KWNqfUiKUneo0FCaglxvTlIkN15ys7hAKspwwZQcxcY9Nz+Aj375A/jYmR9Aa2ervgEjHC0GraBCQ2lofM/HtV+9Hrdddye6VnbX+nCUEUyp4EmHyv9dNV/szU+65FNIJBO1PiylYWs0QjQLm38WFKXGPHbXU/j8rLPwm+/8UUWGUjfQVZYt1J+bcQYe+utjtT4cRak5GtFQGo5Vr63GvE9egcfverrWh6Ior8viZ5fg3MMuwvTZO+LcX30JU7afpGdrxBWDDmKo2iDuO6IiGv/4xz/w/ve/H1OmTJGxzDfffHO/28MwxPnnn4/Jkycjk8ngkEMOwXPPPddvnzVr1uATn/gEOjo6MGrUKJxwwgno7e3tt8/jjz+Ogw8+GOl0GlOnTsUll1yywbHcdNNNmD59uuyz55574tZbbx2iV60MFaViCTdc/Ad8eucvqshQGoZF9z+Pz+52Ov7fN25CIVeo9eEowwQ7TvxBbEETJRyG9JVks1nMmDEDV1555YC3UxBcccUVuPrqq3H//fejtbUVc+bMQT5fsYSmyHjqqadw++2345ZbbhHxctJJJ5Vv7+7uxqGHHoptt90WCxcuxHe+8x1ceOGFuOaaa8r73HPPPTjmmGNEpDzyyCM44ogjZHvyySeH8uUrW5Dbf/UPfHqnL+KnX7kehZwWeyqNRano4RcX/gbH7ngK/vyTv9X6cBRlWLFChhWG44ksC3/4wx9kgSd8WkY6vvzlL+OMM86Q67q6ujBx4kRcd911OProo/HMM89gt912w4MPPoh99tlH9pk/fz7+67/+C6+++qrc/0c/+hG++tWvYtmyZUgmzZjnc845R6InixYtkstHHXWUiB4KlZj9998fM2fOFJGzMVDQdHZ2yjEyuqIMD9muLK6e+3PM/5n6YSjNw7s/cTD++/Lj0TG2vdaHMqIYjs/x+DlueHQ3tLQ7m/04fT0+jp75dFOsOTWLzbz44osiDpguieGbM3v2bNx7771ymT+ZLolFBuH+tm1LBCTe521ve1tZZBBGRZ599lmsXbu2vE/188T7xM8zEIVCQf5gqjdleLnlmttx3M6nqshQmo4Fv/qnpAB/d3nly4/SXDD1MditWajZK6HIIIxgVMPL8W38OWHChH63u66LMWPG9NtnoMeofo7X2ye+fSDmzZsnwifeWPuhDA8cdjbvk9/H90++Bl0rdfCZ0pz0rO2VaN03PvpdrFlmvhQpzYMfWoPemoXmkUxbmHPPPVdCVvG2ePHiWh/SiOAPV9yK46d/EX+//l+1PhRFGRb++bv75W/+hkv6F8srSrNQs/bWSZNMq9fy5cul6ySGl1k7Ee+zYsWKfvfzPE86UeL78yfvU018+c32iW8fiFQqJZsyPOSyeVz1xWs1TaKMSPq68/jpOb/CS0+8glN/eII6izYBcffI5uI30ayTmkU0tttuO1noFyxYUL6OdRCsvTjggAPkMn+uW7dOukli/v73vyMIAqnliPdhJ0qpVJlrwQ6VXXbZBaNHjy7vU/088T7x8yi15aHbH8dndz9dRYYy4mHtxgm7nYa7//jgiD8XjU4Q2oPemoUhfSX0u3j00UdliwtA+fsrr7wiXSinnXYaLrroIvzxj3/EE088gWOPPVY6SeLOlF133RWHHXYYTjzxRDzwwAO4++678YUvfEE6Urgf+fjHPy6FoGxdZRvsjTfeiO9///uYO3du+Ti+9KUvSbfKpZdeKp0obH996KGH5LGU2sHOo9985//w1fdehBWvrNK3QlEArF66Dl//0Hfwy2/+Fr7v6zlRGp4hbW+988478c53vnOD64877jhpYeVTX3DBBeJ5wcjFQQcdhKuuugo777xzeV+mSSgI/vSnP0m3yZFHHineG21tbf0Mu0455RRpgx03bhxOPfVUnH322RsYdp133nl46aWXsNNOO4mHB9tkNxZtb92yrHhlJb7x0cvw7IPPb+FHVpTmYYeZ03DeDadh6523qvWhNAXD2d76k4dnDbq99cS9FzZFe+uw+Wg0Oio0thxP3r0I53/wEvSs0Y4SRXkzWjoyuOB3Z2Lvd++pJ6uBhMaPH56FTNvml0Hmej18rkmERvMkgZSGgM6eZ7zzAhUZirKR9HXncPZ7voGrTvuZRIEVpdHQoWrKsHWVXHbi1bjzhrv1jCvKZrZ+r1i8Cmde+9/aldIADNZ0K2iiOEDzvBKlbnnu4Rdw8lvOVJGhKIPk7j88gJNmnIGn7n1Wz2Wd44f2oLdmoXleiVKXPHrHkzj9bV/Dkudf34VVUZSNhx1aZ77r63hw/iN62pSGQIWGMmT88qLf4pw530ShT6etKsqWpFQo4Sv/9T/46bm/0hNbpwSwBr01C1qjoWxxaKj2k7N+id9e9ic9u4oyhNzw7ZvR15OTSbCOu/mtlMqWZ7DpD7+JUicqNJQtSr6vIFGMp+7WHLKiDAd/vOo2PHP/v/GdBReitaNFT3rTWJDbaBaa55UodTF19cx3XagiQ1GGmecWvoi5bztfp8AqdYkKDWWL8OpzS3DiXnOx6AF1+lSUWvDC4y/jpBlfxvOPvqBvQB0QhNagt2ZBhYYyaF56ajFO57eppev0bCpKDela2YMz3/0N/Hvhf/R9qDH0wfAHsQVNtDw3zytRasLdN9+PL8w+F+uWd+k7oCh1QO/aLL500HlY8Kt/1PpQFEXQYlBlUB4Z3zrmcpQKnp5FRakjvIKH73zmKrSPacd+731LrQ9nRDLYUe9BE3WdNM8rUYaV2667A2cf+k0VGYpSp/glH+e9bx5u/uFfan0oIxIf1qC3ZkGFhrLJ3PPHB/G9k65G4Ad69hSljuEQth+dfh3uuuneWh+KMoJRoaFsEn/9xZ248MPfge+pyFCURoBfCC466jL88ar5tT6UEZk6CQaxNQvN80qUIeeBvzyC7514NcJAR1UrSqNx1WnX4V9/uL/WhzFi8AedPmkeVGgoG8XDC57Aee+fB6/UTH/+ijJy8D0f3/jIpbj3loW1PhRlhKFCQ3lTnvjnM7jgg9/WSIaiNEHNxjc/eikW3v5YrQ+l6dHUSQUVGsobQuOfMw/5uswwURSleSa/PnWPziMajqFq/iC2zeHKK6/EtGnTkE6nMXv2bDzwwAOvu+9PfvITHHzwwRg9erRshxxyyAb7U5yef/75mDx5MjKZjOzz3HPPbdIxqdBQXpfXnl+Krx4+T9rkFEVprgLRr33gYrz89OJaH0rTEg5yRHy4Ge2tN954I+bOnYsLLrgADz/8MGbMmIE5c+ZgxYoVA+5/55134phjjsEdd9yBe++9F1OnTsWhhx6K1157rbzPJZdcgiuuuAJXX3017r//frS2tspj5vP5jT4uK6RcUd6U7u5udHZ2oqurCx0dHU1/xtYsW4vP7PolZLtytT4URVGGiHRbGj996nuYMHXciDjHw/E5Hj/HOfe+F6m2xGY/TqG3hIsP+MsmHSsjGPvuuy9++MMfyuUgCEQ8nHrqqTjnnHPe9P6+70tkg/c/9thjJZoxZcoUfPnLX8YZZ5wh+/B4Jk6ciOuuuw5HH330Rh2XRjSUDch290loVUWGojQ3+d48vvLeb6F7TU+tD6Xp2FKpk+7u7n5boTBwGrtYLGLhwoWS2oixbVsuM1qxMfT19aFUKmHMmDFy+cUXX8SyZcv6PSZFFAXNxj6mHMdG76mMCLySh/+edTb+8+hLtT4URVGGgZeffhWf3/ssFPNFPd91OL116tSpsrjH27x58wZ8vlWrVklEgtGGaniZYmFjOPvssyWCEQuL+H6DeUyis06Ufnz/5Guw5D8b/wekKErjs+KVVTIb5avXn1brQ1HWY/Hixf1SJ6lUCkPBxRdfjBtuuEHqNlhIuiVRoaGU+dHc6zD/Z3foGVGUEcidN9yNlvYMTv/x52p9KE1BPO59c4nvS5GxMTUa48aNg+M4WL58eb/reXnSpElveN/vfve7IjT+9re/Ya+99ipfH9+Pj8Guk+rHnDlz5ka/Fk2dKMI9//cgfn/5n/VsKMoI5taf/A1///W/an0YTcGWSp1sLMlkErNmzcKCBQvK17EYlJcPOOCA170fu0q++c1vYv78+dhnn3363bbddtuJ2Kh+TNaJsPvkjR5zfTSioeD5R1/EvE9+X8+Eoii49ISrMGm7Cdht/531bDQYc+fOxXHHHSeCYb/99sPll1+ObDaL448/Xm5nJ8lWW21VrvP49re/LR4Z119/vXhvxHUXbW1tslmWhdNOOw0XXXQRdtppJxEeX/va16SO44gjjtjo41KhMcJZt7ILp7/tfOSzasilKApQzJdw5ru/jp8/9wOMm2K6D5RNJ4At2+ayOfc96qijsHLlShEPFA1MbzBSERdzvvLKK9KJEvOjH/1IulU+8pGP9Hsc+nBceOGF8vtZZ50lYuWkk07CunXrcNBBB8ljbkodh/pojGAfDVYonzPnIjz69ydrfSiKotQZux24Cy6940K4ieb5PjqcPhqf/+eHB+2j8aODf98Ua47WaIxgLv7kFSoyFEUZkKfveRbf+Mh39ewog0aFxgiF46LvvPGeWh+Goih1zL1/Woi/X//PWh9GQzLcxaD1jAqNEcir/16C7xx/Za0PQ1GUBuB7J/0YLz7xcq0Po+EIQ3tQE1zDzRyqVo80zytRNopCroDTDjoPfd06w0RRlDeHk5vnvv0C5Hr1M2NT8GENemsWVGiMMH785V+ga5XONVAUZePpXZfFD079qZ4yZbNQoTGCuOePD+JPV/+11oehKEoDcvvP78IdN9xd68NoGIJwsHUaaBpUaIwQVi1Zg4uOuqzWh6EoSgNzyXE/wPKXV9b6MBqCwdRnBNHWLDTPK1FelzAMcclxP0Sp4OlZUhRls/FKvrgI04NHUTYWFRojgF98/Td4ZMETtT4MRVGagKfufhY/Pff6Wh9G3RPAGvTWLKjQaHJefPIV/PKbv631YSiK0kTc9N0/4tmH/lPrw6hr/NAa9NYsqNBoYhje5IAkNFFRkaIo9QE/W7ySpmOVN0eFRhNzw7yb8eyD+q1DUZQtz4tPvIJfXPgbPbWvgxaDVlCh0cTun7/4+o21PgxFUZqYG759M154XF1DB0LqLAbT3gpNnSh13mVy6Wd/hMDXnImiKEP4WROYzxrtQlHeCI1oNCF/+P6tePJfi2p9GIqijAD+/dB/8JtL/q/Wh1F3hIPsOAk1oqHUK6teW41rzvpFrQ9DUZQRxHXn34ilLyyv9WHUFTq9tYJGNJqMH5/xC/heUOvDUBRlBBH4Aa46/We1Poy6QotBK6jQaCIeu/Mp3HnjPbU+DEVRRiD3/Wkh7r/14VofhlKHqNBoEnzPx0VH6ywTRVFqx8WfugKlYknfAk2d9EOFRpPwf1fOx7oV3bU+DEVRRjC9a7P47aW31Pow6gK1IK+gQqMJWLuiS41zFEWpC67/n99h5aura30YSh2hQqMJ+PZxP0C2q6/Wh6EoioJ8toD/+cT3R/yZ0K6TCio0Gpz/PPYSFt72WK0PQ1EUpcyT/3wGz9z/3Ig+Iyo0KqjQaHB+dt6va30IiqIoG/DTc3+lZ0URVGg0ME/+6xnc/2dtJ1MUpT7b7R+87VGMVDSiUUGFRgMz75NX1PoQFEVRXpfvHH+lzF4aiajQqKBCo0G575aFWPHKqlofhqIoyuuydtk63PUbNREc6ajQaECCIMC1X72+1oehKIqyUXNQaCg40mAcZ3BD1ZoHFRoNyG3X3YkXn3il1oehKIryprz23FL88Ue3jbgzpamTCio0GjCa8eMvX1frw1AURdmkDhSv5I2oM6ZCo46ExoUXXgjLsvpt06dPL9+ez+dxyimnYOzYsWhra8ORRx6J5cv7jyN+5ZVXcPjhh6OlpQUTJkzAmWeeCc/r/0d95513Yu+990YqlcKOO+6I665rzMX6n7+9D9muXK0PQ1EUZaMp9BWx4Ff/1DM2Qqm50CC77747li5dWt7+9a9/lW87/fTT8ac//Qk33XQT7rrrLixZsgQf/vCHy7f7vi8io1gs4p577sHPf/5zERHnn39+eZ8XX3xR9nnnO9+JRx99FKeddho++9nP4rbbGi+cd+MlN9f6EBRFUTaZ33zn/0ZUB4pGNCq4qANc18WkSZM2uL6rqws//elPcf311+Nd73qXXPezn/0Mu+66K+677z7sv//++Otf/4qnn34af/vb3zBx4kTMnDkT3/zmN3H22WdLtCSZTOLqq6/Gdttth0svvVQeg/enmPne976HOXPmoFG495aFeO7hF2t9GIqiKJvMK8+8hjtvvBvvPPqgESU0NpfB3LfeqIuIxnPPPYcpU6Zg++23xyc+8QlJhZCFCxeiVCrhkEMOKe/LtMo222yDe++9Vy7z55577ikiI4biobu7G0899VR5n+rHiPeJH2MgCoWCPEb1VmuuntuY6R5FURRyzZn/T0/ECKTmQmP27NmS6pg/fz5+9KMfSZrj4IMPRk9PD5YtWyYRiVGjRvW7D0UFbyP8WS0y4tvj295oH4qHXG7geod58+ahs7OzvE2dOhW15NkHn8eS583rURRFaURWvbZGHENHAmFoDXprFmqeOnnve99b/n2vvfYS4bHtttviN7/5DTKZTM2O69xzz8XcuXPLlylKaik2bvi21mYoitL43PDtP2DGO3ZHsxP7YWwug7lvvVHziMb6MHqx88474/nnn5e6DRZ5rlu3rt8+7DqJazr4c/0ulPjym+3T0dHxumKG3Sm8vXqrFS888TL+9Yf7a/b8iqIoW4qHbnsMT9/3rJ7QEUTdCY3e3l785z//weTJkzFr1iwkEgksWLCgfPuzzz4rNRwHHHCAXObPJ554AitWrCjvc/vtt4sw2G233cr7VD9GvE/8GPXO9d/6nbGZUxRFaQJ++Y3fodnRrpM6EhpnnHGGtK2+9NJL0p76oQ99CI7j4JhjjpHaiBNOOEFSGHfccYcUhx5//PEiENhxQg499FARFJ/61Kfw2GOPScvqeeedJ94bjEqQk08+GS+88ALOOussLFq0CFdddZWkZtg6W+/ksnk8OH/kTkBUGgAVwcom8sQ/nkbvumxTnzet0agjofHqq6+KqNhll13wsY99TIy52Lo6fvx4uZ0tqO973/vEqOttb3ubpEF+//vfl+9PUXLLLbfITwqQT37ykzj22GPxjW98o7wPW1v//Oc/SxRjxowZ0ub6v//7vw3R2nrHr+9GX7cadCmbgrXeNhREj82CNWson0dpRvJ9Bdz+i7tqfRjKMGGFI8lBZRCwGJQRFnp7DGe9xkkzvqxzTZTXRxb5Aej3r3oo/olHz/tm+kI/XpTXYaudJuG6Z3/QdJ/j8XPs8/vT4LaaqPrm4GULeOjDlw/7mtOUEQ3l9Xn2oedVZIxkNnKR3vC7QhRlKAcaXie6Ud4n+rlRxxA9Tny/13ls/f6ivBmvPbcMj9/VvK2umjqpo/ZW5fW55erb9fSMVLjADxCt4LLPeUAx8Xyg9e9q1v7oe4QIiSrxwf9zbeYdAd+LH9RsvHMQAmFgfrdtgHODgujJw9DsPsAhr39c8fFueHCKYrjlmtux19t3b1qhMRh3z1B9NJShJtuVFbteZYSKi/V/RphAgrXhoh1FGEKKB25BYEQCt4QL+JFSiCMRrkPvf/M7p2pWP3f8e8IxSsH3K/s4LmBbQLEEeL7ZAm7hgAKpWnyEA4knFR4jmn/97n6su7wLo8Z31vpQlCFEIxp1yl9/cRfy2UKtD0MZTgaKYIThgJECgQs+oxaMTkSiwqJ4SLgmkkCBwOuTiUpkIl7sRWg45vd00giGeNEXkeGay9z4OE60Px+HokJ+BmZzHHPohSJQKJn9JSrSP3rBY69OqchrG4rzqDQMpaKH2352B4466wg0G1EAcLNpptifCo065Zff+G2tD0GpA7FhD1TsGS/6VvQ793GM0AgTCSMSnCh14QWwKDR4e5g0kQ2mRShIYqERRzlKvvmd18efkrHQSFelViSlYiEMQlgUOdzV53WOETpxNIVRD4oPipjyy3sTaaERjhHH9f/z+6YUGnT25H+bSzM5g6rQqENeWfQaulf31PowlBqwfgSjjAgARisS5SgCkg7CVLKStoijFxQajHYwwsGfvHP8kz98HyFvo/ioqt8IUyEsPkYsJliPIREQGxaVRxSlsOT5GT1xIiHCyAbTKjYCxzKPy0OSfVwTSWHqJU6/RFGV9SMcysiE7fv/Xvgf7Dxrh1ofijJEqNCoQ+68QWszmpaqOoV4ie2XGtkgPcLUCCMU/OkAqSgNEgQIeTmdMpfjBTwRiRG7KsrB/RwboYgNY33BKIN822KQQlIwFkI7hCWRjErkIkhYsANeZi98dPx+CDtOtVB0VAkNK5MyvzMKIhEXD/AcoDVjrs8XzBZFOd6ohkNTKyPrM6/ZhMZgB6OFWgyqDCV3/uYePcEjAOuNohgUDxQKUtwZ/Uy6JoIR1UpI6iKZjG63EUaRCctxjJhghCFhw0vbRizEtZ78mbYRUIdELSRyXfmAzBawVpSZFq+iiig2RA8EFmwPsEsUGiFCCY6kTfrF82D5juwfsH4jrueIxIdEPKSQ1DM1HQOgImNkcddN9+LESz715qm1BoIdJ9YgxEKgQkMZKp68+xksXvSanuBmZYBuknIdRlT7IBEJLsbJpIlGSLdHlBZh4WYkPrhgsyYjTDgIE1H0Qh4DCHk3ER+An7Tgc4H3ojILeX4KCQseQthBfy8NCWa4RoFYDFw4vCK6mQKEOsdzRDtYoYO44dUpMa3CGo0ErFIgaRu5Txz1oNDg/SWlY2o4LLdQruNYv+i1X1pFUyxNzYpXVuGBvzyM2f81q9aHogwBmjqpM/7x2/tqfQjKcDCQGQXTHi3pihrgZaYi5HJgLldHMFwbQdKkVUKHqQ8jLnz+q7YraRE/YWo0KAjsUvRwIjRM1MMPQtjMZMj+fAxzYJIqYbSCdRdRJEOiHFJkygvRTqzhoMjgRZ9iI6r9QBqWFwkMERqm+FRu4vV8kSKiIjHVlzORjg1aYPVPciTwz9/d31RCI85mbi7NpK1VaNQZ9/7fg7U+BGW4lAUX3eouEqY8qoo55R68LKmSymWJVKQceEkbQdqW9Ibx0IiEhQkqmLCtBXiR0OA+fpr1FebpfddC6PI2idOa6IV8IhhhIVEMERrmE0+EiYRCQjaYmHQJbNmHURnfosjgZgQKO1XsUgi76MAu+iJ0LD8Jq1SCKJsgMFqFURqSSsDqzZkIx/q+HkrT88CtD8P3fZlb1QxojUYFFRp1xNP3/RvLXlpZ68NQhoR4AFnVVezqSLimeyNuN6WwiMSFpBJcFyFrM9IJU7TJcgcRCDZ8xxKhEcoCH0UweB39uZImbUKYOhFBwcvSjRoCLjtMGFmI0jUSpuDlKJoSO4H6Fmw+Hz/74yJWignxwLBEVFBoSLEHhQcjI/wmR22UN8KHx4tWx4gO7l90YOXptxG13srzRuon7RsfkEIBKMa+H3FhSazXVHg0I2uXd+GxO5/G3u/es9aHomxhVGjUEX/TaYbNHcWIHMFl7WR6IvK8CJkuYWqBQiNRERqhGwkMtrFKzYUlBZxcuFn/wFoJP8VuEq7DXN3Nc3lpIExbCBP8Fy6Vm1V+GdHCnWAqJkp/lOKIR9Vhs0OEt9uAz3rNAt1GzYIvwibPG0xgQl6LFUoxqiRQKDhk3yDy1zAiy82zAJSZFgdWwjEdtyIyaAgWiZioLRa9TA8VgRyjGzz+6nOqNCsLfvmPphEaGtGooEKjjvjr/9Oxyc2FNXDGhAtpW2vlerasSp1CIJ0lsjGN4jrwM1HahOu8S3HB9Ef02Cz0TBnxwWLQMMEICaMCoUQqJArBtEcm6vbwq8QGhYbUcphCTxTjce/Rah+JDDBSwmBDlN2Q5+B1eT6HBb9owSoCQZGeGXwII3iYQpH2PIcdLybq4fsURSZ1w2hK2JqEk2ebbVVxLEUWjb4oupj/YaQnmzN1HvE5VbHRtNxx49348k8/D5vFwg2Odp1UUKFRJ7z45CsoqOV482Gt9wsjFhK5oCdGtHrHUQyKC37NTyYQpBwEKRtei2lbZarCpEUsBEkWfEZCI2OJ4af8S6awcAMgE6UyuDbz8TJGVEjLqEQvuKDzunj2SbR2x52mFCsiMuKIQ5RiSTBlYiH0YuMv2pczDUONZCHMUoDYIjz4PGxtFR3DAlEWoSZ5wFHBaWjBYUomYcOWaAkFSAIW210pdFj0GqdV+LO71wiQ8rnUyEYzUsqX8O+H/oPp++2ERkeLQSuo0KgTHpr/aK0PQRlqqo23pIOkyi6c4iKTlIVXLCgStogKqbVIRIWg0lpqwctYCDK8DyMMoiZM5ILCIREglMWf3RyR2KCoEPEQtalSbIjQiNZsXi/CgfepqoWQ1pSoIJRhCYoMig8KDQqRuJVWoh6R3TKPibvS/KvHgZ+j34bpNPEDW0RHQI8x1nlIDYcNL2XDoR9HiRbmjIAEpvuG0E2UlynKKMh6+/TvtMl5cP6jTSE0lAoqNOqEB29TodGUcNVlWoSLJF08GcmIh5oxRcIaDanTSIq5Fos2KSZEXMTpkqS5TiwqWplqkQc2oqI1KpRgdEEEShTRoMiIxEdItcDF3aG3BasoQoQ+xUlsRUrDsABJx0MpdKMJ8VL4gbRdREnMwSwEvA8jF0W7klrh81J4+Gyv5c/oeeOoR8aCn7eAPmNL7lmW0Tv02eDzJE3njZXl7jwOByglYfN8UWSIQvGBzjYgVzDns48KpdZvrDJUPHTbo/jU+R9tkojGYJxB0TSo0KgD+npzeOyup2p9GMqWRr7x20Bri4lcsMCSv0vBY9Rh4joI0q6kSRhNMB0lFkqMWMCSYk+fhZ0ZRiZCIOUbIRF/CGWqohVc3CksWihuuOCbGo1ksiDT3RO2j4Tly08bvvEGs4PougCuxRZUC35owwtsJCwPthVgrdeKUuCYLXRQSFoolGg1zoJQkw7hT4tttITXseaD0Q8eAweyjfbh9dgS5TApGnp/GMtzdqNQWDEwIlqlLQGrj7UbcWonKpZlWoVRoVEdQFd3ZcaL0lQ8c99z6FrVjc5xHWhktBi0ggqNOuCJu55GIAZGStMQu3nGLp9ivBVZiaeTxk2TnhhJF37Ghtca+WHEdRhMoXBeWgpGZDCCwI0iQ8RFtMiyJoMRDoeLNU2xTOEmoxepRBGtiQKmpNbBDx0Elg3XCuDavvzscPsQGOMMc32V0EjbJSQdHz1eAinbhyfiw5GfVjJAPkigx0ujt5RCoZSQaEgxdBEUHFglI5rkHLRE4oPpGr5qpoNykFoO1nqwMDQMAzgUKdQm7FihSYdtwc7ZsMIAdt4x81EkCtQa5WbaTN2Gio2mg7VED9/+ON55zEG1PhRlC6FCo05ykkoTEZtNiRGXsQaPW1lNGsVF2JoyqZEkLxthwQFmphgjqsNoY6EnhURgmjLY8ZEOKkKD0QvHh5MOkEoVkXE9OKCI8OV3ioWU7WFcsgcZu4RckGQcQ25nBKPTzaHNLiBHNQNLIht8eu7L24uBjYydRJJCI7AlmuEgQNLysMZrxSg/h2LKRsbxsLrYKo9fTLvIeS5y2ZRYo4t6oMhg8SrNvUIfYRtdQG0EjG70maFtrEXxGYWxQiT7QvgWazcsJJhyoWV50YPVFokMplRo0kHxls3X+t1WhoCFTSA0Is+7zaaZ4nUqNOoArc9oMpFBccGuCREYUQEoF11GMOiN0WqKPmXgGTtGyt0klhSC+q0Wwvao+DIZwuqIXDUli8Biz6hjJBEinSkg6frIOCWz2UW0Onl0uHkEcERsjE/2oMUpiUgoBK4IBtcOMMrNocMtIIEu9AVJefx2pwCHIiO0UQwcZPykRDRKoQ0XvjweoxkJJ0DJd5BxihLJYFsrIxxym52EbfnIFloAj0KBosvYqIfpKN3i2SI4fIqn7spEN7towUsGCDMWnDyjNCECy4JD91AWhcaj5plCiYe2sHaDtylNw0N/bfwvX5o6qaBCo8Ys+c8yLHl+Wa0PQ9likQwbSKfNWHQuhmJWFY97N1bjrLvg9SzuZCqB01WZwfDSFgKmGigk2ky0ImQqJMXajAAhcyusa2BXiROgJV3Ati2rkHJ8k+4QoVFCi1PAlHSXHA+LO8enetDqlCSSwWgEJQuFwCi3gBamSFifgQA5PwnXCSWSQTEiEQ2fEQ1P6jXStgcvdJDzXXkOXi6ECeT8BLzAkuem0MgFCUxIhuhKZbG60I5sPi0tsmzLZZsrChRiUe9sa4igw0a42oGTtREEIUptttS30rac50g6dVsTcPuiDhRujGawE4W1Gy0ZYOUa/RtuIlYvWYsXn3gZ2+25ba0PRdkCNL4rSoNz6/8uqPUhKFsKignxxog9M6KhaB2tZsJqypUFk+2cIirE2ptCw0KxxUbQahlRwVoLio2WEBjlS/qEm9XpIzkqj1RrHpM712Gb1jWYkMpih5bV2LF1pUQuxqd6MT6ZxfhkL7ZpWYvd25ZgWnoVdmxZge0zq7BNZh22zazFtukujEnk0eowShEgaQNjE0W02yWMcgoY4/ZhXCKLrVPrsENmObbLrMaEZA8mJLsxObUOO7euwIR0j6RlxqV6ZeNzj0v2YoeWlZiaWYeJqawcw3ajVmDy6LVo7+yD1eIhTPoSlQlHe0BrlApq9+F1BhLNoSAREUYxlrAkhRKkHXhtCTNErr3VFNVKF08k5ig2JL/UPGPGRzp//NFtaIrcSTiIbTO48sorMW3aNKTTacyePRsPPPDA6+771FNP4cgjj5T9OfLg8ssv32CfCy+8UG6r3qZPn75Jx6QRjRrz2r+X1PoQlEGNXK26nEkDbRlTh0HREadOovoMP+PKwsnaDL/FaHyacQUZG2FrgLDNN4PQ6EUhtRkmPUKvjHRbER2pPFqcItqdnEQoWtwixieMuGAthsWoRJDEaLcbW2e6ZV/jDs6hZ2H5WwXXY/7O2xwzFg0c9s6KCl5v3MqN94WLUCIaEn+Iml0CWCgFNtKhhyTrQQIPxYQjz8coB1lbbJUzMzbRK7UfL+bGwrVDpB0Pa6wWmdMiKRT6cyFAyFpZngPHQdDtwPJMi6/HU0mzLxZ90vALCVjZaBgdIvtyuY3mXiGQp2X5+u/Zm72HSj2y5D/L0dAw9TmI9lZsxn1vvPFGzJ07F1dffbWIDAqHOXPm4Nlnn8WECRM22L+vrw/bb789PvrRj+L0009/3cfdfffd8be//a182WW0dhNQoVFjXnj85VofgrLRDPQPP+7+iP8pGfOtssBgV0lryswkcaKiSNZkiCEX4LVZErWQbpFMIDUJ0udJocF21kSIlpY8MkkPrU5Bai863By2S6+W9MaYJCMPvbLIdyb6pIbCieaZRJNHpH6CAqJ6nInNkfGRsIjFRpzlqfTviwSIBEo0tE2uDk07LCgsitKJkrBL8qEawJY6ECcM0eYWYCOQ2o01Xos8Bp+3mLawjnUd8YwVWpaPDoECIzoOwg6TCmKRKF9BopfnJfYPox+HCycbwqLIkM6WqP01dhLlQLboODfuPVTqkZeeXIxGphbOoJdddhlOPPFEHH/88XKZguPPf/4zrr32Wpxzzjkb7L/vvvvKRga6vVpYTJo0adMPKL7/Zt9TGTTsFW941T6iiVo4JUWSNgWfRAwqjBlXwO6SyIiLLawchMYFmd/ofYoMigumD9hxwWKENt98kZH0CZBIlrBV6zoRFIwktLsFtLt5jE1lRXCwy2S7ljUSNZBR8ZFzeNV3/khsGGdRRjbkENfbRGzQ5rx8j/h3I0pi028eQzXimG6Fkq7hqaBAYJ1Gi10UiUKRYdshxng5JKxQCks7nD6sThSxvK8TXpECzAZKNiyP6SUfVkuIsN1GaZkLq5cfchQw0WvhQSTYLpyAzcFsrHuhNTkjGfzZwn5gipbieqKimWr4RwZrlq7F8pdXYuK24zGS6e7u7nc5lUrJtj7FYhELFy7EueeeW76OM2MOOeQQ3HvvvYM6hueeew5TpkyRdMwBBxyAefPmYZttttno+6vQqLExjdKgxEPA+JN1A+yK4DdqDkijyHBd+O1GZMiYdK7IrGNMmTZWnw6f8YwSdpBkAlguazFCWKkATqqERNKTBbwjkcM2GSMmWIxJsdHp9sl1GasIh0PX5GAqIqJ6EGvlmKuiGRJYYcqkOrqx4b3oaSBu4/Thqnrp8aT2aOaq/Gce04/ERB5ZPyVRFS+0MDaRlYLSickuLCt0ILTo1VFEMUhgrdeCbE+LtLpao+kFYgO5EGFbIN0pHNxGgcZzJSNeeCpZdEuDMicFu5upE3qlZ4zYoHBZvX4KJRKFSkPxzH3/blihsaW6TqZOndrv+gsuuEDqJtZn1apV8H0fEydO7Hc9Ly9atGizj4MpmOuuuw677LILli5diq9//es4+OCD8eSTT6K9vX2jHkOFRg356y/urOXTK4MVGPHAL9ZkkEhgmGiGI0WNTJfEw9BkCisseG3sTAmlKJJ1GHTIZFeJdJakfHS05dCRKKCNtRhuUSIXY5NZtDt5qZcY7WYxOd0Nl9bhElUw0QdeiiMPsfQgcWusERNGOFQLDEYzzBavzdzbdIXII1sW2GDLgAsiwRHXeVSewzxnLHJ4mZEXdsLwkdiJwiLSYuAiH7hI2B5aW0p4PjteREfYCvT5GWONzsxHwYLF1NHoACWXHSmhtLuy24ZNJ3aUYaJVOkfOW2zbicfbFz2ELS2w+nIbepuo2GgobrvuTrzjqLeiIaFQ2AI1GosXL0ZHR8UldaBoxlDy3ve+t/z7XnvtJcJj2223xW9+8xuccMIJG/UYKjRqyNpl62r59MrGEC9QG4iM0HQ9sKtExEXVDBN6ZSTNJNYS0yVJS4o+OT6kNAoIx3nRSs9hZdFsEKnHYENFDhnXtKjS42KbzGrQjJsunmMSfZiY6kHK8kwdRmVUidRhVBeqr586iQWAKfQ0UFwkLCcqBjWbSY8YyeKHAQIrlPEl1emXOIpR/Ry8XH6OSHbwPzqOTkh0o8UuoC9IocdLSXfMtk4J60otIqRYa1JygVw6jbAYn3MYvxCamCVDMRpzioCformXGUNP6/IEVQcjShQY3EqsHKVIcblzlEKpimRUi43q91apS7pWdmGk09HR0U9ovB7jxo2D4zhYvrx/Op6XB1NfsT6jRo3CzjvvjOeff36j76PtrTUiCAItBG0Eqhei6m/DUllJYeGadAlFB9MnqQS89hQKHa6ZUcL3mvUZGRulUY4MGRNhwQ6L0T4wzrR7MvRvpzxMSa/D9i0rpSZjNLdEn7SSMhqwVXqd6S6JMjGsLY0Pw4iFSs1FvOBXRxmMKImGmMmXfxOxMJIgKggtX4qyDQPct/IcYXnb4Lnl2EIzmNaBRGjY+joq0Ytd2pZjbLJPoh2jEjmMTuawVUs3tmpfCztdEvEVjvKAsR5CFsq2+wjH+Sh20KrdgZ826ah4KJvX4pj2YVFCUSqLbcbsAKJ5WvX7WP0eaoSj7nn56VdRYjqsgYtBw0Fsm0IymcSsWbOwYMGCfusML7OuYkvR29uL//znP5g8efJG30cjGjX8B9TXXRXaVeoO1iewZ3x9wcF20ZAdJYxeyBTVKGUiA9KSUkjA+/Hbt3hC0AGUU8/H+KYegws4x64nokhGMoSTLmFcplfsvHfMrBInTkoEmmDRIyNllaJj4WLPksxKOsSUaJrjc6prKapeS/n3WEFUiwdZn8vywqQleEmERUWYxDmRDdwqoohKJW1TeSpGR8zvlkRhxiXz6PN9eT52yIxK9GGUm8XKQge8hA27LcDiYAyComtSKDzXDFIw302fjXW2HB8NvSQdJRWoFvwWF3bChsWWYkY1uDhlcyI4LM/8OwsHEBza7FrfFPMl/OfRlxpzbHwNPMjnzp2L4447Dvvssw/2228/aW/NZrPlLpRjjz0WW221lRRzxgWkTz/9dPn31157DY8++ija2tqw4447yvVnnHEG3v/+90u6ZMmSJVIjwsjJMcccs9HHpUKjRmghaANGM6LLIQUGoxjR9FXTeeIgzKQQitmUqctgcYIZ9c4Jpvz2bSIZUo8h7as0q/LhJH1Mae2S6EVnIo82t4ixyV6JOOzUukKcP2OBIfGH9QoxTRSi8rkk8me9tEA5ZVK1ssYO3vEFszvTPJFhRvSg5c/LaB8pDo2uqBYXlS3s1/0S129QF/A6vj7OT1njtmI7Z5XUWeR9DppjqiUEOoDFPWN4D2lblW4UduHEqaZVNvxWGygGRoCIlYY5C2FLElY2iIpC+T4lEdK2XFIoA73FmjpphM/KhhQaNeCoo47CypUrcf7552PZsmWYOXMm5s+fXy4QfeWVV6QTJYbC4S1veUv58ne/+13Z3v72t+POO00N4auvviqiYvXq1Rg/fjwOOugg3HffffL7xqJCo0b89bo7avXUykZSiQJULUb8ndEMFmTFXSacYWJznLsrbaxx8acUgvILN23Fab5FvcC0SdUk1o72PkxOdWHb9BqZVcJUCL/ps0tjYqpbWkJJ7GfBJZxFkNX1Fox9rF/dbqIUZqmXyExVyoT7MmLCGSW8Ji8/XanRyNi0KDcOGrEwkeiJtMbG4uHNSxuqa0F4Xzcy6YglUYvtYdeWpegOWrAs1yEiy+xipscWW9dhRdiJoOQiHE1jrhDI2VIBysGtYXckgCIrdz6HjDtJOrDznDCbME8uD8oC0Sj8Hsejo7SJRjTqn9uuuwMf+uJ/odGo1ayTL3zhC7INRCweYugIKl9K3oAbbrgBg0WFRo1g7kxpAKIVVb75xqPf43bSaHYJN8t1pQUznlsiQsO1UGy3EXayu8QYcMXzSni5ra1PWlUdyQUAW2W6MNrtQ8YuYOv0Olkj5bnjKEVZKKzfScIohBEB6x283MkXIy2OeHdkXDwXcg5RywYpaUVtly849Abl4ix9MZKA6ZMR7AFaLDqRsgCVKY9Aai55Gkg0bLZ8nOaRKh+Qpu3VxDh4jHHNiOznBkiGvVhXTMuAN7qQpu0CXKskusLtANamM+hl62uWdw5gZSjgQvhFF3Y+mhcTFehbtgU3DOG4VcWh/HfmOLBYs8GoRhyViiI+TIMp9Y3vNfBnpf55CSo0aoQOUmuQ2oxoQSqnIqJajChkUBYa7DIxnt6WKVakVwaLQTNx+yq7VPiT37oDtLZzcqqZsspx7axfKAWW/D41s0aERRxRMI6ela6S2MGTxFGKuAjTJFmiL/GBI50e6/ykpBYkdVElNPrClHS0JKwAnRRAlhEaCD10S8TDlmhJBpwIW5DUTW+QkIjLpESvtK9K90tVmiYuCA3L4qiS1JEW2XJMw5LUEEXJDplVIjS6/TRezI1Bl98iKSTu7bsWShkXhSI7fNjJE9W4jPbhlRyEJVu6T8JiCCdHC3NOvHVg0SnU5bTXyNGUQqNUkm6V8jc4FRkNwbIXl/f/N6k0HCo0akD36h50reqpxVMrG8PrtbMyTUK7a3Y1cAy8jIB34Lck4WXom8EWVvPNnRENP8Omd/MQIjZYZyDFn0bMTE2vkfZOM+K9KF0ak9PrxEiLqQunKt1hfqMYqCzU5SxAlD6JyfkOlpfaxf67BBdrSy1Y47cgCV8mtcZCIxcmJUHCbSlCjOIxIkRXYImtuClHDZFGEmk/iV4/KaeCfh5+6KLVL6DT6UOnQ8FhhEWlUNRYmpvvoqZSw45ej+lTMd0uQWT0yS6bnhwrZm0Zc889aOjFtt6eUgr5ZMpEJ3iInm1Mu9oAu8fi9PnIQYyhFg5hc5Ao0ezLzF2RWg2KDtZrcKR8/H5q10lDkM8WsHLxKkzYprGMu3RMfAUVGjXglUWv1eJplY1hgGiGEHVlsBaj7JuRcBGyy4S/M1VC188k55gAHievdkaD0Th5lTWjrhmQZicCjEv3yVJLYTGO7p8O3T/XygwRLtBclLl4mrZTHpMchEmTxPbg1UWdEsFw0Rsk0eMlsbzUgSzHvls+skESq0ttIh54OW37UUTDFGDGPSyrSxQm5rJJcRhJkAg5Ht4WIcT7c3w8fS26vDReCsdItGPH1GqMSRibcUn1RCKjPMgt0mtR1Yic2nKtCTWYHWBcsluSNuOTSfT4aawutuC57ESMSWbRm8gg8DkchhkUywRfMiF8Cgp2pfB4aVUu2R5GkxzYQQKW71cG3PHEMn0SvI7IUF+NuuWVRUsaTmjUouukXlGhUQMe/fuTtXhaZWNYv/AzTkXY0UwOfn3mosVvyY4tYfpARqSab+f8nbUZLHeoOH6GZix6EmjpyGPr9FpsnVmHUW4fEvDR5hSwVWYtWsRFMyrejCaoxs6d/eoxqlpYpWwztJDzE8iGKYk6dPtJrPZa0evzckLusc5rlRoNL0psuAiQh4loGENNRgYsWJH9J0UFn7Pg2SIyOHU1bflig14KHPQGKbmeU2TzYRKttodcmELG8jEp2VPVemuI/TmkmFXaZ+Ojj05zaKHFLWGy1Y01XiuCooWlQacUp3bSg6O1Cyu80WYiJo28bBjLdsqhQsKcEx57GMAusa3YnDUZvMYnpODIs6U4ASvqQCm3u1YXiCp1yUN/fQT7HDoDjcUGjeCbSPP8ParQqAG9a3tr8bTKm/B6eWDJ6bMWIx7/LkWhjkQzQtfYjFNgyJplG/dKpkikfMEJYbGNNRHAavXQliia6fFWgFFJWov3ySj1NpuxhGpr7TgdYISA6Q+JDLWiIkYusyWJYqSwuNBe7iTp9pJYWWpFn5+UeSMiPrw08n4CJd+RdlLXLslxyOJv3MbNiHpZ800dhBc48JmmoGCKulgSjo/xKYoXoNUpIh9wc9GCIlaWOtBG+07LwiQ3K66g3NFMjq1K9VhGbMjvUSAhboXlmPlWO481YcZ0ophKDeQZzejswqpEG8KeBCzakfNs5IAgHcLyI5EUpa341AGFUzpZERt2FIWi0Hid+gytBahPcr0DtycrjYEKjRrw2vPLavG0ypvQT2RU12dwRabzJwsKU5ETKNsqUyaaQa8M2SINwgJQqceQke/GYjxMhehM59HumOmrXGw5t4T1DpxjEld+lmeIRE/PhVYGiYE1E6x7MFEO/uz2XLxYHCWW5H1hAq8WOuVutPTmWPYc0yMUGcUkugtmTLtRMRQRLgLPEhEhxaYUWdFL5xJc9CkyHLiuB4cmY7KIOyj5Lpb6NlpTBXhwUISZXcLHS9kBpqbWosvPiACa4GbRmSiCJufhetFkFpFKAkiEVdz6amh3i5iU7kUiiq6sLbWiI5GX5yulXawrOqbIk+eW57jFR9jHeSemArX8XrA7SEy82F5c1e7KVtfqdlet1ah7ljy/FA2Hpk7KqNCoAVqjUb+YUH5/oy6LKRIpPGDKxK10mtiR+yc7TKQ2gwPTLGPKlYm3EKEboKU1h3Yx48pLqoQbO0HGJ7tk0Y2TNOzEiK0feBzxnDA3KgKV9d6yovbUBNb5GXT7Kdihj3V+i0QzWIS2utQqg8x6i2n09aVQyiVgu7E3hhEcgQ+UPBdOwjfHEKmBgucg8B0zUp51D2WhYdpVi1YC+UIK2UwBrRRNaEEf7dLdAsYFSawstqIQJrDM7cRMawVGS8dKPKKtSs5EZmCS8aga6MY9OEo+ayckpdPmFlAIXemiKboO+jIJlAopgOfaMWmUoNeCT+0g3gXRM1BAeRZs1tSwC0U238yniYVGVWGoRjPql8WNWNemQqOMCo1hhr79y15cMdxPq2wkZZOpKrEhtRlEajPi+gymUVgcGtmMJ43YCNPm2zkLP8Vu3GXqxBRVTkmtQ2eiT1pa2c45PtGNUW6h0p4aLfbrm0iZmowAiahawwtdFIIECiEjFhQbaXR7KXT5Saz1Mliab0PJS6DoJeAXHXglG14+ISkSy6WQ4ZNYEtEolVwU+hJwOGuFIoIunEHUcSJVmoBNUwvb1IKEngU3xVSEhT7PRjbIINNWlOMJ090Y76ewymuTqITjhxJZ4TGPobCKXg2TPiZ1UmVvLoKDER1jPmbbgdSDcHKtKU7l6/ekE2VdIYNSIsmwDEIGKhiZaQ/FttyYlEUzWHi7DIWpet/EFdFcJy2w5s02IkP/ldQtq5esRV9PDi3tbOVSGg0VGsPM4n8vQRB/wCl1S7zwiN14VPgpK7X0cdKUy1iNy8LJm9jOytoMhvJZ+0C9IekT+jmEyCTZvspJpr2SKhmT7MX2mdWyY1x4KcWL8nulVkQmTUfFn7x/IUiJ3wQLPbuDpLh6MqLR5aexvNiCVRQZJVc8Jkp5V0SDX3LgFYyACHPMgISy3jICUCwmEPi21DPYCR+hTHM1IkMWbTZt0P+KNQ8+BUAU2fBp/W3DTZfEPKsYAmutDP5jj0O7U5QBZ612QSIuvjS+Ap1ODkFk+BW/rmoXsniWSzxYZXK6R6zK20sFqQdhioivO5MoIpvIGLdQbjxOmTMT1WrQxMuLfEcSLM61xcYcthcZeNnG1ZWtrnENjlL3vPj4y9j9rdMx0sbENwMqNIaZtUt1NHxdUx3J4P9JXQatxpPGO8N2EKYSKLW6Jl3CzeJcrxBhK2eamFkmIUP6knoIkEoVMT7RK4smPztYlzEx2YOkQ7sss1tFbMTlGnHtQHxckLbV10rtMheEAqMUJpALE+hhGiVMYF0+I6Ii8BwjLoouvLz5J86fIih8W6ISFAqsc2A9g9SF8Hlo8c1CTSlu5UHZlSJXChFmXDgMjtPYAwtOIoTl+vBpmgUHfUihh+27Vgg78DFJakWY4rGxznOwTTKUAk95pdWLO9NF5UhzNCcl5BC2QAzMSqErHTOri63iA8J24LWJVvilRLkFWKJHmQBhnmkuExaSlmK+lqQDp+hFxSEUjX6lKDSuSo3fexUddcu6Vd1oJDZnAms1zfSnqEJjmFm7vGu4n1J5MwbyT6guBmVdBhco8cswI8mlfkK8MaSFBH7SRshW1nSlNoNmXcm2EiZlujA53Y0JyR6ZYdLi5DFGOiriL+8mZRIXgjKqEY0Ii4o/+YnFNEUC67w01vot6JIoRlL8NhjhWFtMI19IIp9LGYdQqbOwUcwlJEXi9dHcg8UMkbBhpIL+EwxacL0uG3hGTppMX5QoLPi6gCBBh1Nj8810jE1PkMCHk7KNHbh0liaxlt0qGQ5H8/FCsRMtdgadTlFMvfKhjZlOXmzPyx4gdAeNCmGNtboRGRQr/J3TbNuDAtYWW2S/FofRjQRGp3uxKj9KXkzIrh4KJ0ZdUhasgqkr8TkXJWDqirNPXNgsIqXJSQwjGoG38X8TSk1Zp5+dDYsKjWFm7TKNaNQ11QuMXTUVNc7vU2gwdSJf/s2kUzHx4mLNL/vG+MJ0P7ghUm5JZpnwYekASq+MUal8OUMwUMpEukuqIhv0q1jptSEfJKRlNOsnJIXA1lV6ZqzKZ5ArpCSVUcgnEZRMiiNg+iTnIsxyLkiU0okyDVyU3VL0Mw/4UvBpXjZvtxn1iIpHWD8p02hFBdjwWoGAhmQUB57DEgkU8zYyHUW4JQdZpLHSCo34ciw5HfTtGO9msazUjinJLiMkquoi+JrL4+3jqtTISCxt56WQdkLYJbUaPA8diSKKnX1YF7RFNSdRhw+dVxO2SRNxHL3017LrxwWKSQ5+MUWhvIUtypzsGkcymukrZBOyptE+O7UYtIwKjWGm4f6xjFSTLk72ZJrE5A3Kba4hQ+5cdM0Akqg9k4tbFI6QYgrT0soUCr+9s7aAj8Pv6CnHQ5ttOk64aMaD0+Q5o2W3PCFVLoUSvXit0Im17DDxUuLoucZLY51HoZFCNp+Cx7oM34FHg60ii0AtFLuTsPuY1gBc2lt4UVSCYsMHHOnSMJedfDTOnofPL/kUAvFBRCNQ7Cj6gYIl0QIKjlLeQTHnwk4GSJQ8sTynOOjqo1AxQoH/P87NohA48lrCQgemJNbBYm1L9Hksrzk6n3H3ibx60Q2h1GhkOd3WpnuImXDL82qzMLXAqJMx4+BAO2lrFdUXu5xF0aekC6tYNO8d3w3WbkTnXs276p+G+5KmNRplVGgMM8/c/+/hfkplM5CFp2xdzZQDcw30ZWBbK7/YmzHw0rEgnQ3RCHhT9yjRjESyhJRdkkWRRlScnJpASey2zSD2yL9iPSvxeDiaLPbRSHfeRivx3tAUfq7yMljR14lcH1s9E/BZBCkGmBaKeQdeNgE7ZyGRj4I0PuCy9jGKuoi4qBIaMiYkH8mCSGDEtWhWPB6EwoA/mXIpAWGfjUIpDavdR8Itwi+5YmEexWbQ1WvBaeOslAKWFVtFGLXaJUxOcEptLzLwxHSM02Xj11+JKcSpFNPiS1FhhYGYiPFcmq2EZKKEvGNSNxKxSbDGhMPaom4Sea+Y8omEhVTBMnXD94wTa5ssGd7EPHP/c7U+BGUzUaExzLBFS2mQyAbnmKSqNrEhN8IiXsDES4OzwFiIyPoMblzs7BAtblEWREYxKDhStoeORJ+0a8b23NJ/VFUMWj2VlZkApgkoMBgNKQW2OHyyhXV5rkM6S5i+YTFmoZBEiamSgo1SX0JsuKUUohRKiiT0KCzYlRGPeA1hs65BDoLXBxyWUp5AKy291FGFyEuDrbuREZakXvgwSSDIWfBYdek6KBQdyUo4ng3X88TjbBU6sC7Zgq0y6zDWzSHhsqAvxCqvFVPsLmPWNUCUmXUaJsNjRItjlyRaYs5ldD5pi+5SaHDQXVQMSuHEqblZc7wiMmiYFrUiM81lpaJJd4QeGxy+Vm1DrsKjLsk12GenRA4HoWGtJtK/KjSGmZA5YqU+yzLKBhbRCHixrY7TJCaywboCPx6elrLgMZXAcL1T8c0IE6G4XbfZeRkUxgLQMYle+RZPD43+S2o0AD5q+awWG6zNWFpqx5pSi5ld4rmyvZbvQLGUMB0m7PjgfUvsLHFQ7E0akcHSAxEXpujTKYawOEo9+mkmoYYyNl2iKjIPJE4RmSiCVfQRpBPSDmrnzWuWMlV2pjBVxMJPPgdTKWuTyJUcJJI+kkkPbmuIkiz0dAABllrtSKVLaLMcLOfcFTHlykqxZ7XIkN/Lfa+VaSmsTel0s2agG83GopKKvOegy26TCJJYpfP8twQIelz4UXWpkXUh7EJgXELj95MbJ/DKlNd+eRutBa1D/EazBdAajTIqNIYZrdGoP6qnhpfzF2LshCqjLlOjEc8ZiaMapuuE3/KNn4bE7OVniBIcZOySiItOt4AJ6V5w9/5ywtB/WTXX0NmTLa30opAtyKAnSCGXT0o0g5EMFnyyw4QqxetNwi1ykFhoxAVnfURCg6LD7Qtg+cbISiIYng+rQKVgy2sqC41IZEhKSApg2WFiPCp4HigyjOVFCIeCxgQ/4GVdafVFsgSPxl/S5MLuD97uojeZxLqgBY5HW/UALxdGYZfMqn7uZBLJiSy3+r9HlkyH9cKEGJax5bXPS4nder+0VexhQvHHVl6frcZGlcgxV09yNaGk/ipHRUbd0nBdJ1qjUUaFxjDilTz0rNGBavWIWV+r5l7IxLEoqiGdC2ZxMiZd0ZcVXo6ntEYLlvwebR1OQfwfONOEHSf0hDCxgvi5zM/qgsS4OJS1EsUwKSkVTmblosouE84vYS9FIZuEX3Dh0xvDs5HrSsLpNukRKeZk5IyHRdHhATajGV2csRI9tQiNAFauZKIZVEC8jguyZwRHkHBgMyQSGZSZ8xEAbQmEli3GWC6HmrENlk05fSFKroVSwoUf2HCKDhzXhZP0xQzMzF4pocUqIWcX4CVcFELWXFRm0canO7Ysj3pt5WfKqdS70DW0GDriQLrc8U0nEAfYSSewJZNyKa4sJ2oP5mO7NpxYZMQ+71GKyCjN2DhsOP/ylI0l31dAtrsPrR2c26M0Eio0hjmaoS6E9UxVaCOaZ2JCEGah8zkSnvUKJoAgra1Bkl0ZZoia2I7L4hWgI9WLVreADF0yQyBtFZGxi/1ERZyD5WOZ/gdTAGnF4iJIohgmRGz0BQmJcGS9JDz6QdihTFb1Cq60sCLnGivzSGgwfSLRjCLg5ALYfSXYjGDkeKOJnVhs/yx6sIvsX416PUrGOVMKXSVKY+o1rPLwzKTZl3kRjplnHQgjOsY7C8E6Dlqz4aQ8hEkKCA9OpiRdMT2llER4egMP49Ajr40j4Sfb3RU9EYksEySPxFvZqjyU88lz6QU2Uo6PtMOCUA8F2o/HqS8KPXpr5KP3LgoXmRoTM/2WIqucPqHoEGFWtikd3j87ZaNZs3Rt4wgNTZ2UUaExjPSuyw7n0ymbRVSf4SZMoSB/sqVVNk5rNWPIaW3tczFmIagYdbGd1Zh0OS0eOpNFjE7kMCaZw6hEHu1un8m+VJ5FKPtlVMFu2qXFDqwutWFVqRWrSm0y02Rprh292Qy8XEIEBjtMPJpT9TiSHrGZFuE6yw5OERsUGT7sbAl2yedIVjh5T7ou2Hoq9Qr5EpwcCzyi/LeIDI6Gj+Z/UGhENRwBi2MTnkQIZOGnK6jMXzEiQ7IYHF8vra222I3zfNCpNCiF0oabdQsY6waS8uBr6rYzGBtmwThN+fWXi2HNb3y+2DdVWoV5yh0PLXYBLXYKHck+rMymjCMoazWY6kmGksahgGOkQxxOKc4SNpw+Rjqq5p8kaGbGlhwNZdQ7Xau6MXWXrdAQqNAoo0JjGPFog6zUMVXfZOWremXtofaQOsnAki+/ch3/K5kAv7h7sirTNoPBSCFwYcOXeoSkbWy24+4Sc39zXTmdEXlO8P85TVXGosOVUex8LEYAuLO4frIGgmZZBVfaVt0iix2jiAZFRy6Em/Vh5UuwSr7ZGNEomsso+bBZn8GoRfUQucDsyyiLk3QRMr3CfVyTPuFzGG8rChDONEmZAW1cyPkailzrQ3i8zEFzJUYMaN4RwE646Cqk0O2kkLZaYCOQ1znBSyEt1uSV6IXMPZN6jVhkmOOkjXurW0KnnxehsqrYhhbHR7K1iFIpbVI7fOvoIiYGImYQXMj3hS+KESoWuLIA1GPPL49tvfdeqVsCLaZvSFRoDCPFfDSaWqlvuCCxXoGLVqQw2BYZjemStlDpaJDmBYbhI88JUQ0hXMeHawfSumnEBoVG9I09So3EqQCnbHVe+SFumJZvMhShI3UeeYoMFndSyziBzBLjYm+s0E3oXxw96afhh3Dz7DDxYGeLRmwwPcJmUaZQKDakHIOvMRI+ckBlX3CThqAwEddThnEcWKy1EDMsk9pghgK9JYSWC1sm3HKonDH28tJ056QNOueeSDWoKRj1k+gN0hiFAh1FpCZDTp1xEK8+FeWaifiLIV8vhQmFmwMTFeGxOHYg57wkJycqCPX6t7GYy/EjxaoxMmNTjdEwNNRnqEY0yqjQGEYa6h/JSCZedPuJjSq7Tl5kB4Z8hY8iETKzy3SeuDYFRCALIlMILFp0pd+0MjjNGItW/DQqT21JtwqX0oxUdZo2VxEa0QeXHE5ka85v64R+ES4PVbwzomLPqLqUwsOOCj/tAk01ooml1bbb8YqPajMPsxCH9N9gBIRigCmWUgCL4qOdXh0O3Fw0EVV8RQAGMUTIyKwR45QaN3kg8gbha6JRF18jh8PF52L9Nd+4i0aHKueMzhqB1IEwbUPhIedaokmRiBMjsjhPFU10jd6rssCIX3NVp41S/xTz5WKh+ke7Tsqo0BhGSo30j2SkEncfxBEKplBisbG++4W4QTGMEBVS+qwLCOHaPhyLm/nm7YM24Fwg4+kdvItZfKstyOPn94IEfHEDtZG2SlK9UPA5q90qb+XBrpEjqNRScJENmDqJDLhisRGJJkmVVAsMpkSqxAZbQSWFUv1ao5pJabxhh4rMJGFaxDGnigLGDWCXAgScbRKJMgoemZEST32Pjz20UAw4+cRCi+UhCB0UpBc1EgkbnI9ID8RD5sRvjCLFkfkpcp6jn3z97LIxJ1gUjhFeZZFR9b5SAfkUfxv0FSt1TEm/rDUkKjSGkZWvrRnOp1M2C3aQuECSRaAcDW8Mq4z9trHnNpslXg1SAMoOB/5k2sAKpWCRqZKE5SERtWKmGN6vjN6II/z91rh4je3hTJNo6w0yEibgHBPjNBgpDC6+nh0ZcoXSXSKOnTKVlat8UPbLkJgA0wey8lfNr66OaEi6JI71Vo7KiIT4KvE4l/nrsmZ7vml75XPQBCwd6S4ek2OsxTlQrvqYpTNFDLds9IZpdAceMnxMrImmuA6QyYjTSpHHidRqyDmubJwWy0FybIqRvBKDQewyidxFY4FnRB7FkwMkaW0amZf1Npbr5Ehl2Usr0SioM2iFEaflr7zySkybNg3pdBqzZ8/GAw88MGzPnWlli4JS30Qpk+jX8nxVumQyqJCwxbAq6DdELfraLqF7S9ICY5NZjE/2YVyiD+OSWTNzTbZ4OiunmlpIwkbKcmRLWvSUcJFiWkTqIKLl0bKQcYsoFl0Uiw5Ksrnwi2YqmRXVbojQ4O4s/CyYgk/pJomjGfGiykiGbCY1xCmnssnvlcuIr2OdRHxfiXpEnhsUMnFRaYmzSKJx9xQbTJvkWQBdOV7+5GugSJC6l8hVxBh0JeX1cyufD9hwo/MkG+sxaNzl9mEsz20yG53fPjmfxkQsfhtZwEqXVquyMeLiRmml8r5xLqx2f3HKxtM2qkFaW0m4BbYmYUQJjRtvvBFz587FBRdcgIcffhgzZszAnDlzsGLFimF5/obKL45kJNUQDd6KUwFsB5V6zqpFKraxjOsboj7PYshJqi4SVijdJqxDcFlLIOaVlYUzFhssF61sDjIWBYjf7/NGCh5dDiGTma8yC4SJBJN1iK2zI2OqBFMGPpyCBztXNKZcuWK/6EW8idhYL8IRX1f+nIujHVKd6sPqK0hRqZMvRSLDZzuIqQeJRr+bYXFMszBpZBJH3BwWyrpmAmvsAJqUFJOz3nmwy+eo3xZaIsSSdoBkdH5LgYMcVWB1yKK6sjTeQnbQVL3HUq8h3tba2togaJ1bYzKihMZll12GE088Eccffzx22203XH311WhpacG11147LM+v/0gaDLY/msrLstGTFIHGrp7svxTzp8hBNKoFYBEoCzqZOkhaPjJWqZwy4bxQM7fMfDuP0yj85u7SbVMe1EWLbZU7V2SDjQSnkjqMMDD1ENU88Gj4gFFaJY4oSEqD9RosBC365fZViU5Uv0ap1YiKXqPoRllUVImQcr+GuI0GxrODrYbcEoxwRNWaclwQjxHx1mBkQ1phLRnxnpDjj1xG2aRiBfJa/TAhr182ERmVCJA5VzxP7Dhh2sRnv4qcZy/gdFsW21YJQEkhRSe2ukWZ9SymVSiqQ7GksLVcx6LUPfoZ2piMGKFRLBaxcOFCHHLIIeXrbNuWy/fee+8G+xcKBXR3d/fbBn0MWsjUGFTH4CWyEX8Djn5QWMSLU7wrF7ao8pGFiVwUCyzqDGxkHBaGRuNSKC6iLkwZ0VH1zd01w1MQ0vkKLtosRjvMV3DWLlIAJBzWIgRiPV6uqWCagHeJp0UyvcFFnt4XAdMbUa8nhVJst03xsF6EQ/atumx+rcgSuU0iAIwMmDRKSJHBW9gmG7XKMrggfiII40wNLIoM2zy+DEST1x6iVU4ZRVnCRDLCyvkw56ZqfEwkzChOWANDscXoETtPWAdT9sOQjqDIDTTqWjFFoetFOCSSUdVto9Q9jRQVjo3srM3d0DyMGKGxatUq+L6PiRMn9ruel5ctW7bB/vPmzUNnZ2d5mzp16qCPYcXLw5OiUQZBxT3LEA0bk/HwcXKCmsKPFnhejr85S8dDIMWg7DixrQD5kMtmKF0mEs2IIxqygFbVa1i2LKTS5CltHg4sy0ErgwWykFcMvlzXeGxUZUuiRdUcgx2PNpWoi0w2qwwMi15YdXurqQ+tiI9y1KPqdvlZ9tkwasGIDHMbvTJ4PzbilPtU4/yIRDLYHmvOA+/LTpFWMTkzZ4LGZDZFhogJngUjOOQcRfPSyuePDxvEHiXmsaTuQ1I71WIiLoI156JSyGvEUvkcRe+pUv8sfWE5GobqP7hwM7cmYcQIjU3l3HPPRVdXV3lbvHjxoB9z4rQJW+TYlCEknndRjhZQFbDmodK1QGjRzQ+CsqkkN36TD+mbYdpT+Y2bxltSnyD1CtEm7ZrcQnG+lAmnbGvlQi3tEtGtoY8sLSr44NJBYeocSuxAibtQy+2jUZctp6uWh4aZ9tNysSofIZrlUm5jFXETOYNG18smL7Jyu1ysDCMxZl9Mz8QBjXiybdT5Egd7pAsmmjEiBa5ifW5aVHskBWReK0M2BTaL8BzIeWBbcGi2aBRJfP742EyXBNE55mNJi6xYx5eLP0yaxI26TOQ9ilNM/OSjI2jV5FZakVdFb5T6ZMoOk2p9CMpmMGLaW8eNGwfHcbB8eX9FzMuTJm34x5tKpWTbkiQ5K0Kpf8oLDkUGvz9XxIR8yY98M8o5ALHJjPaXxdJMA0nZnqQ58j5TA/FDxPPoDSyTZJxCvDZlUec9ubx6yAZcaM24tdgxtORx9LkttRp+3G7LVIzPiINZ0KUdNxYZTJ8kHWlFLdeMxq8uSiuUR8PT/TQq4ixfVyVIqgfByUItEZwoAhO1AItzamBJ7YR8IeP9Ssa4q/zc5XoRG1mpM/FgcYaJ5cNjlEOOk6+dYqNScmEEiLmctgvRPvTUsOHJpLvoRCWqUj8M6PDwpEg1iufEoSC+t3EqqXm+PDY1SdrHNwrqDDryIhrJZBKzZs3CggULytcFQSCXDzjggOE5hkb6R6KYORhRqJ81CZJSYOtIeS5ItEhxamssPhi9D5yyYVcptJELWboYRzKin9E3d/6UaAalRciFlbUHPvpowClpFwM9IoqBLTUfNKCiP0W0IotJlfmyzp/GnVSEBaMIMspeYiJCv2hF/FNGp5vNcoytd/n6WHBUzUMRbcW0SZSCEIHB1FJVxJfCJ1YmfBh6frA4lueBKSXTncLXbYnYCMJANp4D9tbE5yXepLuWciz6WUBC/DMksxWalmLzfkShFIkuRd0njKRIOidy/xLVE60C7nqRDaWuaagva9reOvIiGoStrccddxz22Wcf7Lfffrj88suRzWalC2U4UKHRQHBya3Udg4gM3mC8K8rGV3GlYtmUykKLU5RiRYqMUmBL6yW//BtDqnhFi9xEJa1SCZfw4fhdvRjK3FFZkFnX4HkWAhp0SVLB/CcLtseR8ZEdeuTzTZdOTpqVMgTbkjkkYcGDleWEUlMgaZ7cKkcxqokFRflLvkROKgIlTLkI21II6A5KK3KZ3EoB1F/AsGyCx2jcO0OEJcBP8zywh0aac+W1lUILeRFZdAqtFK0anWCiGHFkQwxGQ6DPd8FengTdwShGGNGITyt3KjuAxu0yJm0jkY1q0zKJRkX3Veoe/QxtTEaU0DjqqKOwcuVKnH/++VIAOnPmTMyfP3+DAtGhotBAFdMjFy7YFBPlXIdJeKRcWTgtzvngN3+2U3Jx6ycyTFTBsgKsKmZgWx5sdqBYPrbLrKo8fiQ4yqmUSukDSiEjFyalEs/14FKb9xNIJGmHzjQEu0ksOCwKtR0RKsxexHbmXPxZ+iALKldlx0aQcmGz60lGvsd5jChVIneK2llFLESBzupaDhEz5klCRuZ4jlwjNEL+jB3Go3knTC+JyHEDuIkAbtKHm4wm20bnSyIw0VkohhYKctBshY2eXlIlTCRV7Ep4maJtRbENK4utWO21SMGtCBQ5gMppFtXG18f3TGzZI6Oysi9IvGOURinnXpR6pWdNDxoFdQYdoUKDfOELX5CtFoyZNLomz6tsCqw0LAHFKFLALemawWQS2TALoamBAMJC1LfKzbUQZNgNkUAxSKAUuGYLXeQDB7ZjTLhk6mmVPometUybm0dHmEA+dNEXJGCXWuE6AYqR9XnsXW4nQpRY7EjXSy6g1LEctJp0xOsiZD0HoxkifmiZ7phW1/UmxpoXE0UtqmedxNfZVXUaUWpFJIK8ZpkiZwIJ4pwabTwXCYjI6OdnwaLYEOh0+zDKyWG0k8MoN4cONy+CAuvFeyQ1EguNaMtLqsRMtWVtBs+vCx9FBmzyVr/NKkXtxPHGh6WgKpaAQtXG91xFRt0zafsGKgbVGo2RKzRqiYb9GoA4Xx/3sUrBYBSvr8q5yoh2maAaFyaIBYaYZnHxiwsUWTvgSFljVHgZlXVK90VVcWW14IjHoFthgJxvWjjTjoc+ERimNqM8bNUxkQOpJZVCVbPASyqDra2xgRUFBwUTazeiY2Dbadkpk9cyXSQHE4cUjNCqFiCM7EjLbHR+QqZeeJlupNUCKjpWmUsn1aoVcwBeW6TwilqA7XgomgiL/hEFnzUn4oIad93w8RyZbcJ6FQ5Xk7oVdts4pi3WVKGan4ygmMesek1M98RRm/jkywnVaEa9o5+hjYkKjWGkoQqZRjJxSD0ukhxoFxaASo4gSgGwzjdyxWTHRdzeSpFBJ0uPX/cdU7woJQSy5kYdHlWYJVJ6KZCTxZhumIFMcTVTSM14+HiCq8Xj4O9SjxFtLC+JCzmZLqDI4IwWFpmUXNieJ/NRzByVauOxOPdS3Z7C4k1OZQWClIMg7cpjibjg4kwhIo8fWXlGxZdiB+KalI6ke6Sl1CirlF0Sp1PWr4jI4MZi0AFqMtfTd3KOWWxL0y6KExaCytmKXFIDipuqehkjAAOEjHaUazNMZ06st5TGoaGEhkY0yqjQGEYa6h/JiCX+th8VPUSLLusaJAbBzonYelwiGxzeVV1hbsmkVemC4KgwLoayqHKsulEY8TCxuDZ0fY8wPmc+cEWEyCIMmoCVTN0D1/JYZETCg46cXMRlar0ZqAIvw8XdgR0mYWdcBEXOPSmZ6amei5CXi+z5MFUS/QSPvGxTu0ERwa4VpFwErg2/PSk1GoyO+K6NIO3Az1jwmbLhc9OqnWkc8R+pjGg3E1tNZCNjFSXVId0iok9okc6unv7BJFOrWW5KLYsCnksKuYT4b4TwAlu8ReKOk8BhNCiOuhgBJMKQaa7q9EgsNioVo6o86pxG+rKmNRoVVGgMIw4/sJU6JlqEKDL6dSKYKIJsjolCmA+RuBMl+tbOb9V+FP4PQ6Tlm7uJbrA11UTo444Os7AZ2RGXMMS/myJJ9lVQYPBxuPH3QpiAw2/org+bNZkJC34qKZEMhzqWdQkS5DD1EzLzpK9oNFMpQJDi2PsAyCRNhiFXgsOBa/TcqF5qXQcehTH3k9fHVlAbAWs0ko7UgQRtSfgZR2ozGNHwU6arxJfUjY9EugQn4UnRqs2F3mIKqFB+LSLCAqY72NpqxIl55aaNVURd+R2IUk7UC4FrWmUtWx5LBIvvmPMvIowpnerukkgX8r2LWpX7pcbKLowqNuqd6oyX0jio0BhGOsa2D+fTKZuFsRyXYsFqf4mkB6vowmL3SSmqOeC/Hn5LTpZnwMu3eL/PxTonjbWJFiRsT4y7RrtpjAt7oxZXQ/yZKU7h1YdgA5OSPTLDgzqBi2y3n8akTA8cN8Q6y4zKDkoOEqkQpQ4fQa9rxrNbIfxkOYsDJ8Nv7fwWWIKd9BFE6Q55XpmJQttwtqLSuIPxBdYwUKAYQREyVcKDIHRHZdtsyoXHCAdFRrn4MzbHshAkAbs1hJMIkMj4cFKebJ3tOYxP9cnslzGJPkxM9mJcIou0U9ygDjPuyDF9NzEW8oGNJcVOrC61YHWxBWtLLegpJhHkHIDFsCwC5XvCeTT5EE6RQ+VCWNz48krR62Txp/xkRa+JjCj1T+e4DjQMg7URD5unZkiFxjAyekKn+balH2p1SvzVl2LDr2xRCsUp+Qg8tnRGhZysXyhaCErsvOB6HqUMfBs9xVb0er1od7nIh8iFKeSDpHhsEFm6q5o/ypENY1YhxZ8tQQlJ35PoRJtTlGhGPiggm0jByyYlUiCGWAkfeaYr8gkE7EARS/AASFmwevmYFEtJWHkPVgcFiRFTIjREeFAh0HuDTrjs1DCvmakSERpMMbAOIzo3flsSQcqGlw4RJFmjYTp9Q45W5f9aPKTaC9Layr91upgmUh7aEgW02EU5BxQQFGH8vcVmJ0z1PBaei8hZNApBx2KDiSTu1+en0eenkPXT6Cm0mrwR78WoRtEG+J7INFs6lUrdK2yfZTLxjBO+T2wXNo6pWqzRGIydMgYNg9ZolFGhMYw4roOOsW3oWtU4veAjBbP2xP4OHAcfjU6PPTWiMaR04Yz7Nji8zKa9tvhjRyUCTJ3IcA4ThdjGWisDw/JBAl2lDDJOqV8tRr/0STxixdyIlGUW5BanhL6giEyYQNpPSKQj1VZEmLLhlxx4RVciGd2eA79kwypxQbXB9TvIx3M+ICZb8jojkRFy3LsXROmQ6HXGZl0l38wmkVRLlIIRscH2WRZ/GiHAWpDqqEaQCNDRmTeRjKQPJ8EUj4eWVMGIiqqNh8UUiklNVU83iwpe15t4JpEdLwPafzHOwRRKj58SS3aZrxJNbTUTbC3W3kaPxXSJGW9fHieLuHjVvLdG2pj9lfok3ZJCpi2NRkFrNCqo0BhmRk8apUKjzqhaX6MhZfEAkdhqPF6gIhvyaHiYDFqTlAMX3ehrd2Ummkxx7QuS6CqlZYw5Z5SOS3YjEduVV1FdIRBfw2/6HU5e2mTZuikTS50E0immGoyRlal+9EXMJNtKKPQmZfqp6fYwtRPSCMLD7HBgFyFRGFmUWSTJHZLRnBAx7Io9MwCrGEgthtR6SGeJBZ8RDKZJ+MkRi4tkRWjwGPi4FBhuwogNOxGgzS5gjJPFGLcPY5w+8c/odPLI0NmzX94k6goZAPpvLCu0YV0pI22/rH3pKbEoxAi72HCD74XlRZuEQiIbeTp9xe8lhSThe0zhFVfkVrfCKnX32bl+l5bSGKjQUEY81SLDELd3SrtE9K03ds604BRk6TYJEH6rZ+SfxaCsC/BY72BJVL7HT2N1ie6gYVRv4YvoGJvK97Mij7Il/b6/y6NbASYlepEwXmCSLmh1PExNd+GVcBRKYUKiKh7dI1gPgQClwEOYc6Xo1GK9iLTdMptjIVE0AoFtqlbRloU3HMOCDiOaUGBuISoi5U/+L28Gs0lKhgKDHS1SkxI9thNHMkI4GQ9uOpBj4WMmXM8IjqSHUck8RrkFTEhkMdbNSm3GWLdXrNo5hTU661VRhf4LCq/pKSWxzmvDWq8Fa702Ob8lprI8SyJLUpdRikSUB7hFgJkq0TIiDOP3cr3IRvkZtPGkrmk0jaGpkzIqNIaZjjFaENoQoQ3+XjCRg7LPRIIeFGaIGtMjdOO0uDbnLfg5M7pdvhC7Iey0gz4vhbxbkFZVpk5oI97jtWB8Midtn+V5HwOIDOJIbQY7TUpYXbSQtAOJcPDza2K6B8vDDnhFWxbzlF1AIlWE5SRRsFPwOMiNkZaEZdxDJeUTR2KAMGVJ3YI8Z5xaSYndlTEAi19LyjZts3K9ERrsLKHzp7xeXpcIkWgpoaUjh2TKl4m1thNIZCGR8DA+3YPRbl78QFJWgDbWn9geWh0qAPacVJmURkGGuMPEzLXlDBgLPV6rRDLyfrJ8PqW9VxxBbdms6KfDlFEkEPl6Kcjk/eJ72m8rGdFR/Teg1CXto1vRUEQedZtNE/0pqtAYZnbZdwc8/o+nh/tplU1EFta4TiOu1ZDwO1dp27RJMlQfRwP4bZrfpCNjKt5WKrrIJ82CyE1sssOEDFtL0Tuin39FdTGo6UIxMRMusoFYPrS5BeM1ZXEAmSURkp50Gl3ZDPyig5KXQLHoymIvk2ORQIlLNI8xZ1IccS2JdHaa8oiy0KB4IKztKAsNvqzI/oXFlBQaIjYyxngMGR+pdraxmihEOl2UlImb8NDZ1ocOO48Otygpk1apywjFfKzNKcigNdagMHgS171URr9Uf32lSZeZgssUVMF3zUZ79xJbXKpnyUdRpSh6IXU00tJqUmJylHGEKnp/NVnSGOyy7061PgRlM1GhMcyM1nkn9R/JiGZ8yCLEuozyKFEO5/Jg+W5UD2C++YsTpRctdlz04nqBgo18hgtiQtIn7P7gDBSmQDJOb/8RIObJZXWvjnDwtzFODn5yHcYFSaz1M3ipMBo+CtL6ynoPP22jz0qJ22bCZV9GEVY6hJfxkF2bRpB1JLpBjNlYJDiiOWJSXiI+F/H5YLqBXhRR9ihKmcj1fmWmiZXx0DI2LykSKaZkJMf1kEp4aG0pYEwijw6ngA67ICmf7ZLrMMrtQ8YuoMVi901lSqyxKo9fcaUrx5RpQmpdeO54C1NK+TAhQiNkCojvg4i7OH0SvSd8H8tRDQ5Xk+pQ8xzRqPjQN0WvZaOUgf4mlLpgzKRRaCg0dVJGhcYw03D/WEYa1YtLVPgp8NsvN8+Pvi07xgCK0Q2ZEErH0KggVIpBTa1G0XdNi6dMYHVkvPnaYgZjE73lmkfpOom6XsyX80oPBI+HwmNiog+rPQurvDZJp7C0lNNBOu2CCAzHDlEsOUilirDTtIlwTQtp2pN5IR7/qUd1J/JcfmWMuqzfkQmZHE9sjlqqEhpufL0RJHarDzftS4utm/IlRcK6ENsO0dqSx+hkDqOiYk+25vKYWbDKtMlY5jVY41HlBMrXHDumiu24HIw5B4xmrC60os9jZIgdNsZfLFtMynkXcSGRGnbTmG4biVpIdMlMZZP3jMU0YtZlulqs9es0+rf9KHVGw312qtAoo0JjmBk1sXO4n1J5Mwb65hovOLGnBlMmjvlpFX1YSRZTsrvDpFXEM4L1AZG3lRh7c7RIbwKvhqORtD0UQ9qKh2h3C1hdasWYZF80WM0M/4ozAPGCzxqNSidmgFabKYgc0mIAloMfJLHEa0FnkBcPj95kUgpAPc4z4Xh634abZEcFvTYCBL6NgBNdPdPB4rPAkzbh5ZccCZzoCi9jJtRaTIvQaVMiFoGpwXBDcSi1nMC0sSYDpF1Pohtjk3l5jdslu6U2g226PGZaj7faJbk/3TwRCQwzKM34osYjSuRylInqLqWwtNCJ5cVOrCy2YXmhDUv7RokxGqMXyDE1FHlnsPgzb8bCs51Vjj8MYBU98x5yExESSnvv6woLjWbUHfrZ2bio0Bhmxk5uMFU+0qj2kuDFfCXEHxeEWoUSXLG5Zv7AjGt3fAtB1kwzlbU6GRg/jZINr5DAylQ7RidyIiJ6/RRWFNvQ6hSkwJNpFd7JFEWaVAFbVMvPGdHmFrG93SP+HFk/he4gwBo/gTa7KBNMx2T6sDLfZoa5SUTCgZsqwU2HKOUTCGmDzloFCgYu5h6kpsP3HQSRdTqjMzJ11TZCIplg/UXUrMHuDr48O0QiUxSTLO5DEcPiT9v10ZnJiilXm80hcB7GOHm0OyUpYuXm2AWJZFTUjRFTfO3xhNZqscFoxqpSu7wlfX5CXveqUhtKhSTgMSxiDNLEDbRggxkZx6O5Gh1B2XUSwu0z4lCiGXEBKJ1ffW/D916pW0aNbyBXUPXR6IcKjWFm652niHGXL+O6lXpEvtnL3I3IW0IiGg6Q5lfsqIDQD6JODqZOWHwIOIUQHvdJR6WdXAjZpeJZyBcTKKUdLCt2SFFjr5eSGoM925aWSzsMppujcjDmh3SdhjaSNhMQNhIUJ76PtJWROgguklaS3Sc+luTbEVpJcTKl9TdNvaS/JfBhURjI66LzJx+UdzVj7B2H6Q9bDLAkCsKuEdeDLaolijzQCIx3S5vWVS70bF9NJoqYzO6SRB86nSI6nCLSlideGZ2OSZ9kbE+8L3jWqusx4nRJPAGmvIXAs9nxWFoYJWZnTJv0egl05VvKrawSxYgrV0uWCIv4AaUQVPw0ovdQinojR1C5rMKikdhuz21qfQjKZqJCY5hxEy4mbz8Br/576XA/tbIRbDDJlAs4CwbjSa5xrYbvm9oMn9+co1YOjizP2wjbaOMt7SHiqMlaDi7vy4qdkj7hYssUBds913prMSphWlZNJMOkUCLTUDMHRUaocIE2xaJJu4gMQhSCUDo5GCEYk+zFy8XR5k6pEKvsFnSksmLT3deXkoFjTHvIaxPFYEkUg0KIkQxGJJIOqz6Akm9LlMMIDb8sNHhgFGFMwbjJElpai2hx8/JaxiX75HV0OgVMTXbJdazL4NCzFtZqWJ4xO5OOGhuBxUFq5hRHk+Thhf2FBl0/VxU70OW1YI3XijWlVnSXMkY40QHVM+krERx8xhxbjQMRG6YTKIRNz5PyexbVZFi2cUaNo1frF4Iqdcf4rcci05ap9WEom4kKjRowdfpWKjTqFGv9jgNGNuI2V3YtxIPW2G/qm6FdZVnCLpBsiGImMpiQzhTWNtjIZ9Po4URTy5eppTSqGpvoxspih6REKDq4zJYjG1KfUGn0jL0kTIMFJ8OywNIXh82JiR4sL7VilM9FH5K6yNh5ma+S80voskroclrNS+IDhBWhQdMuh8flUjiZp2ZQhmPXfc+B63hm8iqFhighc1TtFBaRrTjbVVmLwTQQIxjtTgGTklkZ595m5ySSUYlaUHRVT6mNCl7FiDWEJxEPnloLywtMmYTo8VLoKaXkJ4VTWLBhZ22EOQtgbUaBE2otJLKBpE0YxaD9uC3OrYxGeVWbiWzIe6rFnw3D1rtMQcOhxaBlVGjUgCk7TKrF0yobmTKJLvT/tstajfhLL69PurDppMmIhRhCUZBE7aI5E8mQQomWqCuiYKE7n0bS8URkjEGvOHvS3XJVsQ2Tkt3y3ByXHrthx+kbfjnngiuNIpFLth+GSNg+tk+tRk+QQreXlBqIFrsAO2RCZzSyPkVNCo7lw3UCFP0ESoGLgA5crIvwLWRaCkjY/HZvilLlpVshWrjoB/TmcKIR7wwEBFLUyvRNRyIvEYtWaV0tYpvEWoSWI9EXdpqw46QtkZdjLLFmJHotZgx8GHWcRL01VUPTeIEiY1WxBT1+xrQGg3Utaalt6S5kJCUlx1ti5SsLQG055yb6ZBmBIe8JKnUZ+ag2IzbqYuqk8sbrv406h1HgRkNnnVRQoVED2se21eJplTfh9eYoyILPb8Nu5Lcdz8coFmHRzttxjJ03p7qGca0GEHKaO4ssS7Zx0MwmpDNklJsVw6k1xYyImzS7MZwcOlgPEaVOovlugoiNyLyLUIzEC7Nt++i0+9DlJZG0StKd0u0nkUUCGTuFjF/EeBdY67bACx2JGIhTqe+KqVeKLqdR14cXmBkpUtFB3w9agdBOPbRlmizrPxiRYfRllJOV5+fANwqNsck+dLoF6WZJ2iE6nD5YTI9Ezp485tjlU7Rb1Rc+vlYKKFOaaWF1MY0X+8bJALUuL4M8Z70EIbqLafi9LizWZURiSVJURdrCm+OVJlmJZLDlmN0nJh0kraxxbQY7h5rLeLHpybTzH1MDon9kggqNGvCWd+6B62rxxMrmmXfxdzF9onlX5Kkh7a6cGeLD5iyQOLPg0wSKhQ5mZDnD/Cwgtbgw2j76utN4vjgRxfYEJgVdaE/k0Ruk8Wp+NKZm1kkKQrwroihG7FtpxAYXa1p2V9o2YrOvrZJrUQhdZAMOVQuQDfukLmJywkNvkITrheJISrFBUcH0TQEJiSqYpA1rWAMUor6X2JWUra1JlOR+PB7XotgIMMbtFddPOp0yfdLp5tDBos9EQYbJ8bzFj4vo2E2qJDqnYm9R8c0Qp9IwRI/vYHWpHaXQlZbWNaU28dB4uWcM/DxFhgWrj1GMyBSNKRLacvAnxUUUgJKoRjESFVExiHhp8D2sNmFTk66GYL/DZtb6EJRBoEKjRjUaSp0SCQtrIPMucQcNq2o1Ssa/wbVhJRwpPGTRJR1AnT4LvuMAmRBWioZX9HSg14OZJbK60IKJqS68lh+NNWx1dQuSQnnrqBfFm4J2W1Q1ZuK5qWGQZToqpIgX8NhRk0GWpOXBtTykrJypg0hQXLhYU8qIdIjrH9qdIvJBErkwGUUcTGFqJ70yEKIrsEWUxLNYWINBN89enx7mHPAWYLSbxdhEn4gKFnGOc3rR4vhlV1OT7qmkRCrdJTySqDqjbDduri8EFh7p3kbOQ6+XjmbDpLA034GgaCIZEs1gbUmWM00cIG/BYW1GgUW5sXdGABQ9WLkincvK3hny/omFfP8anLLYUO+MuqUhPzO1RqOMCo0a0D66DaMmdGLdiq5aPL3yJlSGuK4X96T3AhejVCJqlcwAHIWeK4kQQBtrM8y3dUYQ0Ad4bB9lsbxEOQCLRQyRv/Zr+TEYxXbQBB2ngDGJPiwrdGKbzBoTEYgdOiMjLy77rM2IZ52yWySoMvqKx30knBBT7C6UQgdZPymLuhEAobSZsqy0z0+iL0xKVIGDzjosfstPyD6TQg/dXPhD0+uSiWaT2PDRI49noUPGvOek8JR1G0wvRSUq8dEZvwyxAo9SPtHZNYakJo0Sn20zAn6UXJ/105IyWVdqEbOuQj5yAJUtsk+nn0cJcHJRqomFuSwELYZIZH1YucgFlKIjn694ZzAFFr+3WpvREKRbUxi31Rg0GlqjUUGFRo2YvN0EFRqNQGzeFX/zZTTDsREmE+YyvyHbflQ34Jh2V45WL1lIlCz4LAplQSgNpRhR4MJn28j2ZIAO02nBlAQXbaYkWADJbosp6Z7yvI/qWg1GA+Jpp4xuxPNSYqER78crWU8x2qKTaEEeP2OzZoJixUGfnUA2TIvXRZs8ESszuAhzqfcwyfLRGwC5wBVHTxmCZvmYjAB9voOMtK4yRWKeLJYM1REMEUeRGdn69Sbm+KOITWBhWaEdPV7GfCCFkPqMHo8FoGnTWZKNij6ZMuHGFEoOSPQwgmFqMkw7ayVlIqJCZprQ4TS6XJ02166ThmDy9hNft35KaQxUaNTqxKf01DcEcZ1G/O03mpVhREacQvEQOhZsLwkrH8qUVE48ZUQi0RugxCLSVhtI+0AnxQqjGjayvRk47QHanZws74tzo0VkbJ1OyWwSdqKwZRTR4sxgSLmIkZENWahNuyijG9WLOYnH1rOIM+OY1ldjeQ500OMj7EOax89BJjIv1giNaFgLxrse8jQno505qywi0ZPmBNf1TlE1IoQsM7tEUjNRxWe8VFAT8NlISURGBxZlJ2Kd1yImZmLqFQJdpbScIxmaxm5UCg7avLPuJWch0UOb9RB2KXICFaERtbD6VZbj4t8ReaC83kErde091JBo6qRMg76Djc+hx74DT/zjmVofhvIGlAP71Tl8/s72yGhsvOnTDKXzxMl7CCy3bFTJOSLstGB4n8IjbI2dqcxkUf7XE2awKJ+Wb+9jojTKuGQWa4stWFlowU6tK5Bxzdx2GoQZx8xQRIeUjJgD6zdUvfqQzY+4XyVumzX/8B2rhJTtSD2IY9kyVN7IjABeGMCjTLB8EQZS2Bm11lZ7YpTnrK13AKy5qNiKc403rcMm0mHSJgXfwbO9E2UCLYfOLS90SCRjdbEVr/Z2ICyyBiMq/IzqOiSFUmBdRhTNKbt/hlFbK1NWOZMm4XwT+cm21pIRifrNuOE49NPvQCOiqZMKFedjZVjZdf+d9IzXO9XfeqsWKOleiBew2I/BY/FhAVaR9uTRgkc9weYUZhhYhpG3YfXYsNY4Jh1AH4iCi7DgYnlfO1aW2sQNk/bk/+4bjxdyE/Boz9ZyWbo02IIqkQvpBylvcdqkn313uZsk8q+I6lirFUnsYSG/R9/6TZFmP5XS7w5xMGfA5yhPYo2Pp3KMPGYeO18D92HtyKPdW+OF3HiJZjBlxHqM1cUWvJbtRMBZJgUXiMSGtcaW8yfpkT5jyCUTaKvFBs99oWg6Skq+SXNF75OkTgYQGeVIlVK37Lr/zrU+hIbiyiuvxLRp05BOpzF79mw88MADr7vvU089hSOPPFL25xeByy+/fNCPORAqNGrENrtujdbOBu0NHyGsb0UeL8BmIfOMN0M8OyMK09t9edP1wMWvEMLJ0W8jgJsDbC6WvWZcKo2l5Js6t3U2vHwSK7IdMgr9ub7xeDk3ToohC0FSUgtdpaQYX8nzx4c0wIIed5FE2YZ+AqQiLKqssyTFYXw5xCI88uiodLhUbVX6o1pQmOeqFh0VAbR+OoevIVtysSzfKa+N9uKLc2Pw7+x46TJ5LTsKftaV1Ei5FiOOAGVt2L0O3L4Qbi+LcAM5x9J6TJHRVzDtrBSCLBal+JP3xjPv2Xrv4wbvsVJ3JNMJbL9Xg844CbfAtonceOONmDt3Li644AI8/PDDmDFjBubMmYMVK1YMuH9fXx+23357XHzxxZg0adIWecyBUKFRI/gB17D/gEYSrxPVkLy/RDY8IF8CcgWgUJBv0k5PEcluD04+SlywhiAXILHOh9UX1Wj0OrDWOsCqyICqaCMouFhVbMcruTFYV8pgnZdBzk/IaHR+8381P0qMtkx0o5y1KUcYyp0nG4iPqs8uERYVo6xYP8S1HlLvEfl2xE6hGOC+cUQj3sRtvVrYRMdVlV0SozC+huf6JmB5sU2msa4ttcjrXJwfI/UpQT5hZph0ucBqF9ZaF+hl9MeSVtbEWl86S6iBXE5mzYdIdvtwskVYjGDELqAlY3se8rrq4Wnri0elrtl2t62RYOF1I1IDoXHZZZfhxBNPxPHHH4/ddtsNV199NVpaWnDttdcOuP++++6L73znOzj66KORSqW2yGMOhNZo1JAxU8bW8umVjWH9hSmu0+BP5v35YcBitZYU4LsmXM9v39wCV+ZvsFA0SJgt7OKa6QJpOonSYyNAmA5FaDAXsKanFe1tOelGYd3CumIGy/LtmNa6BkHooKfEaa05TG1ZCzda+OPOlP4RjvVeRtzpEdVZELEEYVurRDEqKRCKDT/auE/5c69K0Gw4e9jUXfSb1RLtz3TJa7lOrPVa4cGRepSXsmOQcTxkvaRcZiqlO5uRllWZyCpW7pFvBiMbLP5c54u4kDRJydRlcIiaJQWgnjn38qJKAKMbvMzoUvzeVf9c/71V6pLRk0ZhpNPd3d3vMgXBQKKgWCxi4cKFOPfcc8vX2baNQw45BPfee+9mPfeWekyNaNSQ93zqbbV8emVz6LdgUSAUK9fFFteywHlwimaUvLS8+lGIn9/Es/x6b8GSdk1OErVgFUxqwMq56Oluxbpiiyy+z/ROxmq6YxbbJBrwbHYCnu2bhGd7J6DHS0aLual9YA2EFGFKBIHFm+ay6UipSqtIrUQl8lEdjYhFRLyv9J9Ej9cvPVL92NFzio15uQ7DXM/X8Hx2PBb1TZFIxiu50WLItdprw5M9k0VodBUz8pr52uUcFI2raiwweK54zqSUNKwUfjJSZGowiiayVNXCalqRi5Wvheqb0ZDM+fQ70ajExaDWIDYydepUdHZ2lrd58+YN+HyrVq2C7/uYOHFiv+t5edmyZZv1GrbUY2pEo4ZoQWiDUv5WHH1tzxdMuKAUpVE4l8FhPUEBaOM3Dxs++zlttsByRQ7ghGwYlfnvpgulz0JoO4BjpprQljzrJOGkQmzbthKv9I0WD4wONw8vdMXye0mBJl+9GO3mZG5J7GpqfDYq0zw26Eip2kdMteQ3igrWZRjBYCIaFWOtgaK4lehuVaFsNIuFc1PWehmsKbWjy0tLkScjF9zEfbSUxku94+AXbIRBJLiKFsI+Cq/I/VPqWACXqRGancVW4qx/kXZW1mgwXcIIRj4SeBR6UZdJbE+qNCzTZzdw0fwWam9dvHgxOjo6yle/XoqjnlGhUUM6xrRjq50m47XnltbyMJTNJhpwwigG7a65ELYno5HypsvB7gWCtpT4Ybqs6XAt+An2lzKCEcJjiqXXLLYYxUWTCy2/qYsBBrwgxDKnE11eK9rdvLh9FkMbYxIZEQFrii0Ylcgj4xTQ4ebESIsW4WLIWTH7rkp7GKdOtt3G6ZT4tcSD3GKRsX50o1LP0b/I09SXGotzFnTS1TPnp9BVSok4orhYW2qV62OxkfdceDnWY1iw8pGoiLe1jgx3YzRD2lh52vKBeGUgTpsU6P5ZNMIiPhDpMuHG62MzMa3DaFTGThmN8Vs3cHp5CwmNjo6OfkLj9Rg3bhwcx8Hy5cv7Xc/Lr1foOVyPqamTGrPdHlNrfQjKRjPQp0a0XMdtrvzJgkR6ObBAtOjB7Skg0VuqpFJotlUK4PYFSK0MTLsraxE8B+DAsDVs64yMqYo2ersz6C6mZIFm4SS9JtaUWvHv7AQsKYySttjlxQ48l52AB7qm4cneiegppaJW2ErqxNhwmWFmfjk1YopFRVyE0RZ1oWy4z4ZdLjTX6vWY4jHP/awUenbIMfHYeIw8VkY1ykKDr6U7Y16j+GTYCNdEr50tv+w0WePIuWGNi0SB2DLMotpCgCTPZV/R1GYwmsRoRmDmmYjAEPHRX0a98Xuo1CPTdp+qXUGbQDKZxKxZs7BgwYLydUEQyOUDDjigpo+pEY0as+3uU/GvP2xaT7JSK95k4YrD90kXaGuJZm2wupELJcsg0/CRgJVgzYFpjQ0SnNcRTRNN0hGTA9oCIzKksDGklziKvo3VmQTyrRyeAjzlTZbR7ROSPWUxUKJduFNE1ktJxCKeqtru5OHajC1Y0o0bt7gaaWQs0Ek0UD2q1WAhaFS/ERl2ofy7KfDs5TwSL40+P4XXCp3o89PIBQm4oJNoKO25FB0c8+4FnMraimw2jTDHqbcs9DQRDKnJoNjotSWSYeUs2GxdjRw/44pUGZqW96SThK2rIiri8e+9OZMyYUTjDcWEplIaha13mYJGphaGXXPnzsVxxx2HffbZB/vtt5/4YmSzWekYIcceeyy22mqrcp0Hiz2ffvrp8u+vvfYaHn30UbS1tWHHHXfcqMfcGFRo1JjDPvMu/Oqi39X6MJQtQlgRGlKMWBniZVF4lDxJBYROsiwyounx4g3hexYCzkXhB0yBrZkBQi7EHRUDi95SBn28v2Mhky5KxwhrISgjMjbnj5TQ4uSRFNvxoiz2HBvPDg+mVCgCKBToBkoX0jbHE4tyzlkxMiNEiaIltFEIOJTNlSgKx8RzQD2t0U2KxFiFF0NXWnBXFdpkLkk+SMhkWER1Gi/3jUFfnh05IQLfqUxgpbBYZ8FijYoUfhpDLjHj4iRWv2LEJUWfHJrWV4LF4s9eTqtjBCOoWMJTPxSj2SZal9EUvP/kQ9HQbKHUyaZw1FFHYeXKlTj//POlWHPmzJmYP39+uZjzlVdeka6RmCVLluAtb3lL+fJ3v/td2d7+9rfjzjvv3KjH3BisUK3xNrrFiBW/XV1dG5Uv2xQ+s+uXsPjZJVv0MZUawUWP/5A5y8ZxTetrIgGMamUcEqGbQNCaBBK2tLuWMjb8tCURjSBlI3BCeC0WQooLrqGpEFaHDyTZrmLiCmGGRQuMdIRoaelDwg1EYJhBZyW0unlMTvXI2HiKgDHJLFqcEhz4yAVJEQ0J28coN4cOt4ik5ctMlbzvSMssox+sAykGNrr9pIgV3of357RWX6a/utIJw+fkKPqlhXYz2l2ERkJqNUqejWwfBVZku84OEkS/l2yE3Y7UZ0jZSK/pLLGlAyeAHRjBkaDhmdRlBLB7i7AYIWJqqjtrRJ1sJfOTNTAqMpqC8VPH4lcv/WiLp06G8nN8/eeYfur/wEmlN/tx/EIei37wlSE91uFCIxp1wD5zZqrQaBb4wchv2awfoBiQmD9rDxhHoFMl/TFCBC1Mb5g0SbLbQolD16wATkATKgvFgo2gjX4cHHMe3Z9mXRQZ/OzlY/shssUW2GkfhVQCxUQRfXYSBd9FENiy4DNawQJSRjsoMhiFoMhgdKPgJ5DzCyIyStH+PGJOZWVEhEKjpyw0bJQCR6IjrXZB9l1RakfRd0Xc0GAsG6RRDBzkvAQKhQQCpkgYsomFBq3EWYchxx5PYmV3Tohkr7FuD9mZ49P5M0Bom7oM1rNY2YLYi5tUCVNSkb04IxuMZOgck6Zin0NnNnx9hs46qaBCo06Exh+uuLXWh6FsabHBrAlFBmsuuCiyEyWdkLSJ1ccdk0ixQSJjS/umQ9sHplRcwHWMWRbTD1K4wJbPRFWFQSIEcvxpIfRs5PMJ5BIp2CkPPXYKL3rjkHI9tCaK8hgUG4yaMEXCiIVr+SiELvJBSoab8XfpVokKPFOWh5TjoSdy72REwws4r8SWYtaE5eG1/GipBymUXGTcoogPuptKaoSpD9ZesNaERM6eyDnReWFNC7tKIJELJzbi8ikw6KYawMlJAzCsfAkWzx1FBYs/4xaaOJrBE9Xgi5LSn7e8e4/GPyU1SJ3UKyo06oAZ79gNjmvDj10MleYRG2y1ZM1GLm8+ONw20P7SCnwzK8V14ISusfumgyj/RbJONMlv84DVBQQ5C0FaDC6imR0ckx49DyfCsmLTDWG5FsJeB30J1nCEyDsu8g6FhA3bscRrgwLDCI1ALMFfCxwRFrH4iIUGRYW5zqsIDXp/iNhwEAYhenKtJlLhQ+zEWdwphyfXGQ8MZKOZ8ryepmQFY8Rl5aLx7jQxYx1GJDTiDhMWfXIabr+IBYVFltPpou6e2AlURUZzYQF7v2dGrY9C2YKo0KgDUpkUZr5rTyz862O1PhRlKMQGixdZp5FORYsjUysWEBV+2lwrHdZsMJlivrCz2yKkX4RjiY9EwLvlAZ/tn1zAJX1CRRJZfDr8acllK8MHiDY3RG+e9SEMjASwnBC2E8JxfKzua0XBZ2EqDzVAMqq3CAPTEssizZRThG9b8H0HgW+Z2xhdoQhi6IHPGQuLfPQzPhY23EjaxzwWhRN9RSR9JF4hnMJqRs2L2IjHvfOn2IpHYoIizViPmo2X444TFRlNxx5vnY7Ose1oeDSiUUaFRp2w75yZKjSaEaY9+IHD1AmHQzH0z2/jLfSR4KwULq4eLHZLZFIIU6zgCAGmVpg6ybBRlEGQUHRFkLXgtUYRjhSdRBlB4I4UGUylmNklUgdBEcIFXlI3DISY6wLOSAldeI4pxGQyObRtFOjjEV8nhhkWCmFGIgwSSYnEB8tG5PnogxE9By9LYSfTJtLWElbqMgoW7Hxoij09PleUv+ZrYrGnFQkMipeCD5tGXFKPEXXxUFRk8yYNJVGiqIVVRUbTppKbgddzctlYmikZqEKjTtjnsJnAl39e68NQhgxObM0BSRaJ0pTKMwsnxUaK4QZL1uyQKQjXFIb6aRuhw8iGDZuDz+gmyogC7c3ZZFFgfQZrL0zkQyIJEmkwgoKtsSI+MlKHCktCJ8Z1NJRUC/eLp61RDEUfbexwia9j5wvXdc+W65niYVRD6ixYb8GgghR3RhGNqD4jZI1GyBSJmbIqA9AiwzIWe7J/huKKtRk04aKAsHifaPKqsXOntTufK54fwzQKwyRKM7MvPwuVpkKFRp2w7a5bI9OWRq43X+tDUYaE6Bs4F0pGNNj2yoWTC3ocRWB0o1iCxdscihGGKxKS1gicyMAn4E0UEaaGQ8bLM2hCTw7adyS40IdGDFBEUHxIhMOMgheTLJJkfUiVyOBjxRECDn3jbeJxYUSKRC+4K4tQEQsNkzoR6wonNBGNItMgltRf0AfD4jwS3u4bwy2mTCg6XB5jGMLpKcGWYWiswYhERFzkSQO0yFzMRDiijhsd7960JDNJ7PiW7dAUaOqkjAqNOjPv0u6TJocZCD+A1ZM1dRssFOXCyg8lWpYzvYJIdHCtz9kIE44s1lzQKRw4dl7mlTAQkLHMXJAiL9CPAwjoj0VvDj4UN+YqKBpikSED4DhvJRYScQplvQ/IOOLhVY1uj8QGhYNEQEpR7UU+hE2jLeoa1olwX5aQMDUiGsWCQy8MRlYoNig82LYad5MwPUIxQSHGSE9sJS7zS+LOklq9acpw8e5PHNzPUKqR0fbWCio06oh3f/JtKjSaGTMy1ayXXDjZkcKrOGmUdQm2EQoSWaAYKbGt00OYcBGmEwiTpibDZS6DKQzHgm/TvpzRAyM+eJ188RdPCkY5LAQOaymix40FBcVKXEcRNbL0ExpRjYYUhsQFn5EAiaeo2oxcRKKB7blxFEPSLSI2LEmNyJA42Z81GqzN8GHlPXl95VQIBUfRg0WxxRdg2wgpNCg+sJ4AUsHR1EKjadCIRhkVGnXELvvsgCk7TsKS55fV+lCULc7638i5wDMiUAK6o1QKBQFTJlG9hExgzXBhZ/2Cj7DoSpuqiIykDY/FoNwn6jqh2ZUs8Ga+u4gO1j/wehlyIkWg0WLPQAXbYV2TYuFzyRoepVLiNA3TIJLmCFgjwjqPaIor7cElxMK6EdOeyk4ZmVZPscE6DZtRjgBuIYBVjA+K6aEoWsHXlCuUhYuIDkktRa2scVeJ3B7tU57IqmqjGae17nHQ9FofhjIEqNCoMw54/z743fduqfVhKFucARbGuNZA2l2LIjLY5ippAy7ItCyni5fvyGaxODJJjwyOkreRKPkIPNOeKiIjEhvSBWLUgPzO0SOyTywy4qgGIw1eFEXhVVHkQVIz8VAnaUWNHo7BBhaRRos/xYXJj3AomvHFiIUGIx3iB1KIzLYoHmjGFUcwxNDMg83LErWggGEtRlTDUn1+BjyXKjaajX3fu7eMJG8qmsh0azCo0Kgz3nHUgSo0RgQDLJQUGD1RdIOdKSxuoHBw+M0/gOWaya0S9XBtWJ4tCzprOJAwdt9Mo0jTSZGumrZEFThplVBkyHoeCw03FhUs0IzMtmR9D6UrRaIVNM+Ku0l5FS0toiJSOnpSWITSYkJ3U1ObYdI+frTFE1YpLHyxEQ/Zzhu1qoZMl8RzShjdGeiDuTxxdv0rlWbi7R/bvFHm9YrWaFRQoVFnTN9vJ0zbfSpeempxrQ9FGQpk0mh5RZcfAaMXVdfJwsvUgizujEqEZmGmRwYiocFIBKMHqYSJgjg2QooT15UR7VI8KtdZQMaFE9WHSBIiEhpWnN4QAVKV2okFBTtJKFpioRFHORjZ4MiSHMe1G9twXrakG8U3I9wpHCgk8kVYFEzxOPdCyUQxAlaD0syLtuJFed3V8x35+wZxi+pzpzQVk6aNx6xD9qr1YShDhAqNOuTtHzsQL11wY60PQxkKqhZKUxMhy/OGcFFlqoQFo4xkUEyENLeKHUc5vTXqeeWCzbSLRA/ysNjNEqVXJMXCTITUaJj7loUGCzjZrRLdJkZaiB5bajRCBElbREs5ohHNGaGvhx2nRIIAdlxXEbefUlSwtqRQNKkTRk6kALZq0qq4ew4cW64WXkrz846j3trwQ9Q2QItBy6jQqEPecfRb8XMVGk2P9ToLafU14sIZ1zVQWEhkgPbiTJU4lQiHVULoBUZk8HZJuYi3uDSUyEIfF6BycJtlwY0jKVHRhvhsSC9q5L1BMdFnXEHZtirPHd8WdZfIZREbxsUzZKcMDcfiFEohFhZMrzDiwXZVr/Ja13/9613uXz/bZAuR0u8zr9nQ1EkFFRp1yNY7TcaoCR1Yt6K71oeiDDdvtJiyc4PRgXgiLCMcxhTDLOosCKUYkLSEeRwRHykT4SgLDUYgeKPUgcRCgx0mUREHa0QioUGXUXa8iHAQf4OK0JC0CEWFREFMRMOkRSiEIi8ERmTEjCuq1VCU9Wgb3Yrt99pWz0sTo0KjTjn2wqNwxX//pNaHoQw3632j71e/Ycozoy4V6T01CzgiEWDbZiIsuzskfUHxIe0mlYVfuj3M1Nh+QkNMw+IW0v5iw0xK9aUA1YgN8zgc3y6Px8JUHldsHS5iJxIVUmvSv/ai+neNUSif+OqRzZc2IZo6KaNCo46Na35y1v9TS/KRxADFjut/AMviHF8nUYQqYcL6C9qWu7GTJtMkUSEm0yuMdIjtudVfaMQio7ouQsRG5OkRCw0RLDQNi1I4bEtlRWouaqulsFlPWKx/7AO+turrteBzRJFIJXDoce9AM6KpkwoqNOqUlvYM3vXxg/Hna26v9aEow0W1qIgX3PUXbYqJquv6yZBoEmwoc0tiJ1AjAIxvBqtCo6JQRiekeyVKi5RdQ6Pn5JaL0isiaKL9WMnByEm1QIkKRAf6UvpmNRj9Xuv650AZES2tHc0wEl55Q1Ro1DHv//yh+PNPblfTl5FIvOBvsPBGHSGVSwPdOQrbRrFbr9D//oRXlftHq56jWtzI86//JFVdMgNEWzbgzbpGNIIxonnvZ9+NpkVTJ2WaY3pNk7LDjGnY6S3b1/owlFoxYIhgUz7homhD9eWBHqsclWCRpzhwVYmNzXzsjUUjGCOWbXbdCnsetCualnALbE2CCo0654NfOKzWh6DUM9UioSqNUR6MNtREHa/lCMr6m6K8Dh885b3NWQS6Xo2GNYitWaip0Jg2bZoxLKraLr744n77PP744zj44IORTqcxdepUXHLJJRs8zk033YTp06fLPnvuuSduvfXWDUK6559/PiZPnoxMJoNDDjkEzz33HBrFkrx9dGutD0NpKKJF3jhsDe3zWNWRDUXZONKtKbz7k000qVWp74jGN77xDSxdurS8nXrqqeXburu7ceihh2LbbbfFwoUL8Z3vfAcXXnghrrnmmvI+99xzD4455hiccMIJeOSRR3DEEUfI9uSTT5b3oTi54oorcPXVV+P+++9Ha2sr5syZg3w+j3onlUlhnzkza30YSqMxnF8Um/dLqTJEzHjH7mjtaGnu86upk/oRGu3t7Zg0aVJ5owiI+dWvfoVisYhrr70Wu+++O44++mh88YtfxGWXXVbe5/vf/z4OO+wwnHnmmdh1113xzW9+E3vvvTd++MMflqMZl19+Oc477zx88IMfxF577YVf/OIXWLJkCW6++WY0Asde+DH9MFcUpWn49DeOQrMjZneD3JqFmgsNpkrGjh2Lt7zlLRKx8MSd0HDvvffibW97G5IcjR3BSMSzzz6LtWvXlvdhKqQa7sPryYsvvohly5b126ezsxOzZ88u7zMQhUJBIirVW63YeucpeMfHDqzZ8yuKomwp9n/fLOyoRe4jipoKDUYnbrjhBtxxxx343Oc+h//5n//BWWedVb6dAmHixIn97hNf5m1vtE/17dX3G2ifgZg3b54IknhjfUgtOersI2r6/IqiKFuCEfNZpqmToRMa55xzzgYFnutvixYtkn3nzp2Ld7zjHZLOOPnkk3HppZfiBz/4gUQTas25556Lrq6u8rZ4cW3Htu84cztMnb5VTY9BURRlMEzYZhz2eOv0EXEStetkCA27vvzlL+PTn/70G+6z/fYDe0MwncHUyUsvvYRddtlFajaWL1/eb5/4Mm+Lfw60T/Xt8XXsOqneZ+bM1y+yTKVSstUTp1zxGZxz6DdrfRiKoiibxee/d5yeuRHIFo9ojB8/XlpN32irrrmo5tFHH4Vt25gwYYJcPuCAA/CPf/wDpVI0JhvA7bffLiJk9OjR5X0WLFjQ73G4D68n2223nYiN6n1Yb8Huk3ifRmHWIXth+uydan0YiqIom8y0PabirUfMHjlnTlMnta/RYCEmu0Eee+wxvPDCC9Jhcvrpp+OTn/xkWUR8/OMfF1HC1tWnnnoKN954o3SZMOUS86UvfQnz58+XtAtTMmx/feihh/CFL3xBbmeq5rTTTsNFF12EP/7xj3jiiSdw7LHHYsqUKdIG22gcddYHa30IiqIom8zRZ3+oqQ261kdTJ3Uw64RpCRaCUhiwJoORBwqNahHBIsy//vWvOOWUUzBr1iyMGzdOjLdOOumk8j4HHnggrr/+emlf/cpXvoKddtpJ2lb32GOP8j4sMM1ms3K/devW4aCDDhJxQoOvRuOtR+yH9jFt6FnTW+tDURRF2Sgy7RkxH1RGJlY44CQkZX2YbqHwYWFoR0dHTU/Q36//J+Z98oqaHoOiKMrGctqPP4fDT+xvQ9Csn+Pxc+x99LfgJDf/y6xfzOPhG75aF2tOw/toKJvOO485CDvN0mFriqI0xvC0w45/J0YamjqpoEKjAWGe8zPf+nitD0NRFOVNOf6iY+C4zsg7U1oMWkaFRoOyz6EzMHmH/iZkiqIo9cTYrcZIXZkyslGh0cB85VdfqvUhKIqivC7n/OLUEdVpsj46It6gQqOBmb7fTnjrh/TbgqIo9cesQ2dg5jsr3X8jDvZZDHZrElRoNEH+U1EUpd74zLf0s0kxqNBocLbddWsc+MF9a30YiqIoZfZ+z17YedYOI/qMaNdJBRUaTcCX//fzYuKlKIpSa1raMzjrOuPMPKLRrpMyKjSagI6x7ZpCURSlLvjUBR/F2MlmjISiEBUaTcLhJx2CMZNH1fowFEUZwXSMa8MRp7631odRF1jB4LdmQYVGk8Cpt+ffdMaIbiVTFKW2fPX60+EmajZCq77Q1EkZFRpNxO4H7oJDPvW2Wh+GoigjkIM/sj/2PmSvWh+GUoeo0GgyTvz2J+EmRqDdr6IoNcNxbZz83WP1HahCu04qqNBoMkZPHIVTrvhMrQ9DUZQRxEmXHIsJ24yv9WHUF2rYVUaFRhPyvs8dire8e89aH4aiKCOA3Q7YGR889bBaH0bdoRGNCio0mpTTr/mchDMVRVGGCtu2MPd/Pw/H0XSt8vroStSkTN5uIj777U/V+jAURWlijr3wY+JOrAyAdp2UUaHRxBx52uHY46DptT4MRVGakJ1mbY+jz/lQrQ+jbtHUSQUVGk0MPTVoT27Z6q2hKMqW/2xxXE2ZKG+OCo0mZ+udp+CzF3+y1oehKEoT8anzP4IdZkyr9WHUN9p1UkaFxgjgY2d8APv911tqfRiKojQBM9+5Oz5+3pG1Poy6R1MnFVRojBDO/NkpSLUka30YiqI0MImUi7N+fqp2mSibhAqNEcKo8Z244Hdn6iwURVE2m69cfxrGbz1Wz+DGoF0nZVRojCD2nTMTH/7Sf9X6MBRFaUAOP+k9OOhDs2t9GA2Dpk4qqNAYYZxw8Sd0nLyiKJtEx9h2nHzZcXrWlM1ChcYII5FM4PJ/XYT20a21PhRFURqATFsa3/vnN5FuSdX6UBqLIBz81iSo0BihrqHn/PJLtT4MRVEapJB8m+lb1fowGg+t0SijQmOEst9734LDPvOuWh+Goih1zDuOOhAHH7l/rQ+jIbEGW6eB5kGFxghm7k9OVn8NRVEGZMY7dsc5/++LenaUQaNCY4TbCPODpLUjU+tDURSljki3pvDVX5+mFuODQZ1By6jQGOG0j27D9+/5FlpUbCiKQpHRksJld30DoyeO0vPRgO2tV155JaZNm4Z0Oo3Zs2fjgQceeMP9b7rpJkyfPl3233PPPXHrrbf2u/3Tn/60fCmt3g477LBNOiYVGgq23W0qzrtxrp4JRVFw9v87FTvtvb2eiQbkxhtvxNy5c3HBBRfg4YcfxowZMzBnzhysWLFiwP3vueceHHPMMTjhhBPwyCOP4IgjjpDtySef7LcfhcXSpUvL269//etNOi4VGkrZzOuTX/uong1FGcF8+LT3qSlXA3edXHbZZTjxxBNx/PHHY7fddsPVV1+NlpYWXHvttQPu//3vf19ExJlnnoldd90V3/zmN7H33nvjhz/8Yb/9UqkUJk2aVN5Gjx69ScelQkMpc9zXP4YP/PccPSOKMgKZ8+l34uRLj631YTQNVhgOeiPd3d39tkKhgIEoFotYuHAhDjnkkPJ1tm3L5XvvvXfA+/D66v0JIyDr73/nnXdiwoQJ2GWXXfD5z38eq1evxqagQkPpx39//3hsu9vWelYUZQQxZcdJ+NLVJ+ospDpk6tSp6OzsLG/z5s0bcL9Vq1bB931MnDix3/W8vGzZsgHvw+vfbH9GPH7xi19gwYIF+Pa3v4277roL733ve+W5NhZ3o/dURgSO4+CHD1yMM9/9dSy6/7laH46iKEPMDjOn4dI7LhTXYGULEkTb5hLdd/Hixejo6OiXxhhOjj766PLvLBbda6+9sMMOO0iU493vfvdGPYZGNJQBq86/dcu5aB/TpmdHUZoYdpv9z61fQWunjiSo19RJR0dHv+31hMa4cePki+Ly5cv7Xc/LrKsYCF6/KfuT7bffXp7r+eef3+hzoUJDed0hSlc/fAnGbTVGz5CiNCGjxnfgyge/jTGTNq2wT6lPkskkZs2aJSmOmCAI5PIBBxww4H14ffX+5Pbbb3/d/cmrr74qNRqTJ0/e6GNToaG8LhO2GY95889DIqkZNkVpJpyEg2/d+hVsvdPGLxZK/XedzJ07Fz/5yU/w85//HM8884wUbmazWelCIcceeyzOPffc8v5f+tKXMH/+fFx66aVYtGgRLrzwQjz00EP4whe+ILf39vZKR8p9992Hl156SUTJBz/4Qey4445SNLqxqNBQ3pBpu0+VyY1q6KUozeP6+d0FF2DnWTvU+lCamxo4gx511FH47ne/i/PPPx8zZ87Eo48+KkIiLvh85ZVXxAcj5sADD8T111+Pa665Rjw3fvvb3+Lmm2/GHnvsIbczFfP444/jAx/4AHbeeWfx22DU5J///Ocm1YpYYbgZr2YEwrYiVvx2dXX1K8wZKTx1z7OY+/bzEfiDqW5SFKWWWLaFi287D3u/e68R+UYMx+d4/BxvP/BrcN30Zj+O5+Vx1z3fbIo1RyMaykax+4G74JLbz0cyrZXpitKIuEkX3/rzV0asyFBqhwoNZZOmOZ79i1PhuPpnoyiNBOdTnHb1ieIArAwTOlStjFb5KZvE2z5yANpGt+Fr75uHYqGkZ09R6hzHdXDh78/E/u+bVetDGVFYgdk2l8Hct97Qr6bKJrP3u/fEOb/6ooRiFUWpXxh9PP3HJ6nIUGqKCg1lszj4w/vLKOlUy/C61CmKsnEkUi6+/dfzMef4d+kpqwWaOimjQkPZbHadvRO+/oczkWnf/MpqRVGGxt33q78+XeqqlJHjo1GvqNBQBsWs98zAVQ9+G2OnqLugotSL4+cP7p+Htx6xX60PRVEEFRrKoNl65ym4/J/fxMRp4/VsKkoNGbf1GHz3zq+L0Z7SHLNOmgEVGsoWYdJ2E/HjR76DPd+2q55RRakBu+y3A378yHex7a5b6/mvB7RGo4wKDWWLwQmQF88/T9IpiqIMHxT431lwoQxDVJR6Q4WGskVJppOYN/+r+NT5H9UzqyjDwFFnfRDf/fuFyLRqUXZdwcxHMIiteTInatilDI0L4bEXfgztY1pxzVm/hFf09DQryhbGdiwcf9ExOPrsD+m5rUMGW2dhNVGNhjouKUPGh754OHbZbyecc+g3kevN65lWlC1EqiUpc0tmvF3bV+sWaVEdhFhoHp2hqRNlaNlt/53xg/vmYbs9tQpeUbYEW0+fgsv/dZGKDKVh0BoNZcjZdret8cP7L8Zhn1GHQkUZDO/+xMH40UOXYMeZ2+mJrHe066SMCg1l2IpEv/y/n8cJ8z6uM1IUZROxbAufPP8jMj2Zrp9KAxBsga1JUKGhDCssXGPYd9TETj3zirIRtI9tw/f+8U0cd+FRUmitKI2GCg1l2Nllnx1w9cOX6BwGRXkTdn/rLmLxv/uBu+i5ajDUGXQYhMa3vvUtHHjggWhpacGoUaMG3OeVV17B4YcfLvtMmDABZ555JjyvfyvknXfeib333hupVAo77rgjrrvuug0e58orr8S0adOQTqcxe/ZsPPDAA/1uz+fzOOWUUzB27Fi0tbXhyCOPxPLly7fwK1Y2hbGTx+A7Cy7AqT/8LGxH9a6irJ8qOfnS42RC8qRpE/TkNCJao1FmyD7hi8UiPvrRj+Lzn//8gLf7vi8ig/vdc889+PnPfy4i4vzzzy/v8+KLL8o+73znO/Hoo4/itNNOw2c/+1ncdttt5X1uvPFGzJ07FxdccAEefvhhzJgxA3PmzMGKFSvK+5x++un405/+hJtuugl33XUXlixZgg9/+MND9dKVjYRh4A/89xxceseFMi9FURRg0vYTcPFtX8ORp78Ptq0iXGl8rDAcWlcQigcKhHXr1vW7/i9/+Qve9773yaI/ceJEue7qq6/G2WefjZUrVyKZTMrvf/7zn/Hkk0+W73f00UfLY82fP18uM4Kx77774oc//KFcDoIAU6dOxamnnopzzjkHXV1dGD9+PK6//np85CMfkX0WLVqEXXfdFffeey/233//jXod3d3d6OzslMfr6OjYYudHMRTzRfzk7F/i5h/8RU+JMmI5/MRD8LnLjlOXzyFiOD7H4+d4925nwHU2v3DX8wtY8PR3m2LNqZlc5iK/5557lkUGYSSCb9JTTz1V3ueQQw7pdz/uw+sJoyELFy7stw+/AfByvA9vL5VK/faZPn06ttlmm/I+A1EoFORYqjdlaLtSTvn+Z3DGtf+N0RMHTrUpSrPSMa4NX/zRSTjtx59TkdEsaOqk9kJj2bJl/UQGiS/ztjfah4t+LpfDqlWrJAUz0D7Vj8HoyPp1ItX7DMS8efNElcYboyTK0DPn0+/EzxZdjv/67Lv1dCsjgvcc93b8bNEVeP/n3lPrQ1GU2gsNpiKYV3+jjWmJZuDcc8+VkFW8LV68uNaHNKKmwJ5+zck45/+dirFbjan14SjKkDBm0ijM/cnJOOtnX0DHGJ262nSoj8bmzTr58pe/jE9/+tNvuM/222+/UY81adKkDbpD4k4Q3hb/XL87hJeZr8pkMnAcR7aB9ql+DKZYWNdRHdWo3mcg2OXCTakd7/7E23DgB/fFtV/9tdZuKE3F4Se9Byde8km0drTU+lCUIUKHqm1mRINFlaxveKONaYqN4YADDsATTzzRrzvk9ttvFxGx2267lfdZsGBBv/txH15P+FyzZs3qtw+LQXk53oe3JxKJfvs8++yz0lob76PUL5m2jNRuXPCHM7H1TpNrfTiKMigmbTcBX/31aTjt6pNUZDQ7WqMx9NNbuZCvWbNGfrKOgu2phF4Y9LI49NBDRVB86lOfwiWXXCL1Euedd574XcSRhJNPPlm6Sc466yx85jOfwd///nf85je/kU6UGLa2Hnfccdhnn32w33774fLLL0c2m8Xxxx8vt7O+4oQTTpD9xowZI0KGHSkUGRvbcaLUnoM+uB8OOHwW/nT1X3HtV69HrkenwSqNQ6olhU9/4ygccep74SZ0aLYyshiyv3j6YdAbI+Ytb3mL/Lzjjjvwjne8Q1Iet9xyi/hscNFvbW0VwfCNb3yjfJ/ttttORAV9ML7//e9j6623xv/+7/9K50nMUUcdJe2wfD6KlZkzZ0rra3WB6Pe+9z3pRqFRF7tJeP+rrrpqqF66MkQ4roMjvvBevOOoA/Gd46/CA7c+rOdaqXv2PmRPnHndFzBuitYbjSiCkPkTDOr+TcKQ+2g0C+qjUX8seuA5/OALP8W/H/pPrQ9FUTZg+xnb4tQfnIA9DtpVz84I9NE4ZPsvDdpH428vfF99NBSllkzfbyf84L7/wfEXHa3dKUrdMGpCh0xaveqhb6vIUJShTJ0oynDAlNjHv3IkPjL3/fjjVbfh/33zt+jr6tOTrww76bYUPvHVj0gdho5yV4DQFIRuNs2TbFAjfaVpnEUpNq5/+Ufmg75VW5OV4SGVSeL9J78Hv3zxKhx99hEqMhSDdp2UUaGhNBX0JWA77C+e/6EUjlpWrY9IaVos4H2few+ue+4H+OJVJ6FzbGPPo1CUoUJTJ0pTwnkpp1zxGXzglDn4/eV/xl9/fieK+VKtD0tpAhJJF4d86m348GmHY9ru29T6cJR6RbpGtOuEqNBQmpqpu2yFL/3oJBz79aNw8xW34qZL/4hSwav1YSkNCP0vKC64jZ08utaHo9Q7YWC2zWUw960zVGgoI4LREzpx/EXH4GNnfRC3XvM3/O7yW7B6ydpaH5bSAIya0IkPf+lwvO/k96B9dFutD0dRGg4VGsqIq+H46BkfwAdPfS8W/PIf+MnZv0TPmt5aH5ZSh7R2tuCEeZ/Aoce9HamMFhcrm1kMurk0kcWVCg1lRJJMJfDeE96NOce/E4/e8RRu+fFfcc/ND8L3/FofmlJDbNvCAR/YB4d/7lDMes9e0j6tKJuF1miUUaGhjGi4kOz97j1lW710La79yvW4/y8Po2tFd60PTRlGOsa1YdahM3HixZ/E+K3H6rlXBo9GNMqo0FCUCBb4nfmzU2QI4EPzH8UtP74d992yUM9PE7PvYTPxvs8ditmH7y2zdBRF2fKo0FCU9eDAv9mHz5Jt8b+X4I7r/4m7/+9BvPDYy3qumoBpe0zFgR/YF+/8+EGYttvUWh+O0qxId+tgajTQNKjQUJQ3YOrOU3DshUfJ9vIzr+LOG+7GH664FVm1OW8oWjoy+MB/H4Z3ffwgbLeHel8ow4CmTsqo0FCUjWTbXbfGcV+n6PgY/vPYSyI67rzxHix/eaWewzpk/NSxeMfHDsQ7jn4rdtp7e1hqE6soNUGFhqJsIlywdpy5nWxsf1z4t8fx4F8exRP/fBrPLXxBz2cN2WHmNMx4+26YdegM7DNnpnaNKLUjoOHWIEy35P7NgQoNRRmk6NjnPTNkI2tXdGHhXx/D7753i0Q61KNjaGkd1YKJ247Hkae9T8SFOnYqdYOmTsqo0FCULexAesgn3yZbEAR4/pEX8eD8R3HP/z2A5x5+EaH01iubjQXsMGNbvPWI2dIxstOs7aV4V1GU+kWFhqIMoUfHzrN2kO0TXz0S+b6CpFaeue/feOb+5/DonU+id01Wz/+bRCxmvmN3TJ+9M3bdfyfsPGt7ZNoyes6U+kcjGmVUaCjKMJFuSWHPg3eVjYRhiBWvrMKiB54vi49F9z+HwG+e3OymYDsWdtl3R+waiYpd9tsRk6ZN0CJOpTFRZ9AyKjQUpYb1Hawv4Pb2jx4g1xULRbz676V49dklWLxoCRY/+xoWPfg8lj6/XFIxzWLzPXHaeEyfvZNM191m+lbYepcpsqXSyVofnqIoWxgVGopSRyRTSWy/57ayVcPox6rX1mDxotfwyqLX8NzC/+Dxu56R1MLa5V1Yt3wdgjqp/6CQ4MTT0ZNGoXddFnscNB277LMjpk6nqJiCcVuP1W4QpekJw0C2zWUw9603VGgoSoNEPziDg9veh+y1we20Te9e3YuVi1fJz7XL1mHNsnVYu2wtHr3zKYydMlr2K+ZLsi19cTnrKmUqaTFflOvyvXkxI8y0ppBIJ5FMJ+R6fuBN3m6iXOb1FBIrX10jtRMUE2MmjZKfHWPbMGHqOHSMa9cCTUVhjcZgxH9YH18ctgQqNBSlCWDnBTteuCmKUgeIUFChQXQGsqIoiqIoQ4ZGNBRFURRlS8PibWsQdRZao6EoiqIoyusLBU2dxGjqRFEURVGUIUNTJ4qiKIqyhQmDAOEgUiehpk4URVEURXkDpaBdJxGaOlEURVEUZcjQ1ImiKIqibGlo1mWpj4YKDUVRFEUZstTJYNpbm8cZVFMniqIoiqIMGZo6URRFUZQtTBiECAeROgk1oqEoiqIoyhsojcFvm8GVV16JadOmIZ1OY/bs2XjggQfecP+bbroJ06dPl/333HNP3HrrrRsInvPPPx+TJ09GJpPBIYccgueee26TjklTJ4qiKIoyFBGNQW6byo033oi5c+figgsuwMMPP4wZM2Zgzpw5WLFixYD733PPPTjmmGNwwgkn4JFHHsERRxwh25NPPlne55JLLsEVV1yBq6++Gvfffz9aW1vlMfP5/EYflxU2U3xmCOnu7kZnZye6urrQ0dFR68NRFEVR6vBzPH6Od1gfgmslNvtxvLCEO8M/bNKxMoKx77774oc//KFcDoIAU6dOxamnnopzzjlng/2POuooZLNZ3HLLLeXr9t9/f8ycOVOEBeXBlClT8OUvfxlnnHGG3M7jmThxIq677jocffTRG3VcWqOxkcR6jH9EiqIoSuMRf34Px/drLywMajCah9KAa04qlZJtfYrFIhYuXIhzzz23fJ1t25LquPfeewd8Dl7PCEg1jFbcfPPN8vuLL76IZcuWyWPEUERR0PC+KjS2MD09PfKT6lBRFEVp7M9zLphDQTKZxKRJk/CvZf1rHTaHtra2DdYcpkUuvPDCDfZdtWoVfN+XaEM1vLxo0aIBH58iYqD9eX18e3zd6+2zMWhEYyNh+Gjx4sVob2+HZVloBKiE+UfK49Z0j54X/XvRf0cj/fOFkQyKDH6eDxUsqmQkgBGGLXG81nrrzUDRjHpHhcZGwhDU1ltvjUaEHwKN8kEwnOh50fOify8j79/RUEUy1hcb3IaTcePGwXEcLF++vN/1vMwIy0Dw+jfaP/7J69h1Ur0P6zg2Fu06URRFUZQGJ5lMYtasWViwYEH5OhaD8vIBBxww4H14ffX+5Pbbby/vv91224nYqN6HkSx2n7zeYw6ERjQURVEUpQmYO3cujjvuOOyzzz7Yb7/9cPnll0tXyfHHHy+3H3vssdhqq60wb948ufylL30Jb3/723HppZfi8MMPxw033ICHHnoI11xzjdzOtM1pp52Giy66CDvttJMIj6997WuSemIb7MaiQqOJYS6PhUONmNMbSvS86HnRvxf9d9SMHHXUUVi5cqUYbLFYk+mN+fPnl4s5X3nlFSkDiDnwwANx/fXX47zzzsNXvvIVERPsONljjz3K+5x11lkiVk466SSsW7cOBx10kDzmpqSG1EdDURRFUZQhQ2s0FEVRFEUZMlRoKIqiKIoyZKjQUBRFURRlyFChoSiKoijKkKFCowH41re+JdXBLS0tGDVq1ID7sJqY7UncZ8KECTjzzDPheV6/fe68807svffe0nWx4447ylCcTR0xzIl9p5xyCsaOHSv2uEceeeQGhi+1gsfNdqzq7eKLL+63z+OPP46DDz5YXh9dDTmZsBZjk+uRTR0v3UjQsnn9vw2+x5vyd72l/o3Vkn/84x94//vfL+2JPAfxTItN+dtes2YNPvGJT4hJFz+POPmzt7d3i/87U5oITm9V6pvzzz8/vOyyy8K5c+eGnZ2dG9zueV64xx57hIccckj4yCOPhLfeems4bty48Nxzzy3v88ILL4QtLS3yGE8//XT4gx/8IHQcJ5w/f355nxtuuCFMJpPhtddeGz711FPhiSeeGI4aNSpcvnx5eZ+TTz45nDp1arhgwYLwoYceCvfff//wwAMPDOuBbbfdNvzGN74RLl26tLz19vaWb+/q6gonTpwYfuITnwiffPLJ8Ne//nWYyWTCH//4x+V97r77bjkvl1xyiZyn8847L0wkEuETTzxR3ufiiy+W9+Hmm28OH3vssfADH/hAuN1224W5XC5sVDbmvW9kLrjggnD33Xfv97excuXKjf673lL/xmoNj/urX/1q+Pvf/55TxcI//OEP/W7fmL/tww47LJwxY0Z43333hf/85z/DHXfcMTzmmGO2+L8zpXlQodFA/OxnPxtQaPDDw7btcNmyZeXrfvSjH4UdHR1hoVCQy2eddZZ80FZz1FFHhXPmzClf3m+//cJTTjmlfNn3/XDKlCnhvHnz5PK6devkw+Cmm24q7/PMM8/IB9a9994b1oPQ+N73vve6t1911VXh6NGjy+eEnH322eEuu+xSvvyxj30sPPzww/vdb/bs2eHnPvc5+T34/+3dvUsrTRQG8BUiWtgoBBQhQsCIFmJKQWxEIZX4B/jVKFjYBEELizSCROzsLazSWYhdtJCAiBD8QAIJxkKEgFhYKATuvDwHNuyGmN3cd9fN7n1+EKJkDHEyM5nszJnz54/q7+9X6XS69jjqpaurSwZUv7J674Mw0cCHYyN22rVTfayd1E807LRtTArwdzc3N7Uy5+fnqqOjQ72+vjrWzyhYuHQSAEjXi0uPxgx7SPWLo2IfHx9rZYypfvUyevpgPcWwsUx9imE8Xq1WTWVw6TMSifyYhvi3YakEl7/j8biWTqdNl7bxGqenp+WoXmMdFAoF7ePjw1Y9WaVN9iM7730QYAkASwbRaFQu/WMpxG67dqKPtTs7bRv3WC7ByZM6lEd7wbHUTvUzChaeDBoAP6X61R9rVgYD5dfXlwwAVimG8RwYPOr3ibSaMtgtm5ubsj7e19en5XI5bWdnR3t7e9MODw/lcbxGHKH7Uz319vb+WtrkdvI36aX9Bh+W2C8xMjIibSKVSskegoeHB1vt2ok+hj0P7cxO28Y99qcYhUIh6XPGMv+3n1GwcKLhke3tbW1/f79pmaenJ9OGtX9RK/WEc/514+Pj8uGxvr4u5/rzGPZ/WyKRMLUNTDyGhoa0TCbT9hMAIr/jRMMjyWRSW1lZaVoGl3jtQHa9+ggBfce8Md1vo3TA2DmOgRbpha1SDOMel9lx3r3x21+zNMRe1hM+TLB0Ui6X5ZvsT3Vgp56cTpvcTv4mvbTfof3GYjGtWCxqs7Ozlu3aiT7W7uy0bZSpVCqmv0MfQySKVT200s8oWLhHwyPhcFi+hTe7Gdc4m0G63vv7e9MAgFS/GODGxsZspQO2k2IYj3d2dprKYN0Va92tpAz+rXrK5/Oydqxf6sVrRHgf1uONdYBJCC7n/mbaZL+nl/Y7hGOWSiX5QLXTrp3oY+3OTtvGPSZk2Neiy2az0l4wsXeqn1HAeL0blay9vLxISF0qlVI9PT3yM26fn5+m0Lu5uTmVz+clnC4cDjcMvdva2pId9UdHRw3DW7HD/Pj4WHaXr62tSYijcac9wgAjkYjKZrMSBjg5OSk3r+VyOYk4wf9fKpXUycmJ1MHS0pJpBz3C7hYXFyXsDv8v6qQ+7C4UCqmDgwOpJ0QrNApvRb2cnp6qu7s7NT8/H4jwVqv33s+SyaS6vLxUz8/P8h4jTBXhqZVKxVa7dqqPeQ1jhj5+YPhH2Dx+xhhjt20jvDUej6vr62t1dXWlhoeHTeGtTvUzCg5ONHxgeXlZBoX628XFRa1MuVxWiURC4tUxgGJgrVarpudB+YmJCTkvIRqNSrhsPcT+Y8BFGYQ8IlbeCAPOxsaGhK9h8FhYWJAzCbx2e3sr4XEI/+3u7lajo6Nqb29PfX9/m8rhbICpqSn5UB0cHJSBtV4mk1GxWEzqAOGKZ2dnpscRBri7uyuDKZ5nZmZGFQoF5XdW772fIcx0YGBA/je87/i9WCy21K6d6mNewutrNJZgjLHbtt/f32VigS89CO9dXV2tfelxsp9RcDBNPBEREbmGezSIiIjINZxoEBERkWs40SAiIiLXcKJBREREruFEg4iIiFzDiQYRERG5hhMNIiIicg0nGkREROQaTjSIiIjINZxoEBERkWs40SAiIiLXcKJBREREmlv+A1PzK3W+fCbeAAAAAElFTkSuQmCC", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "fig, ax = plt.subplots()\n", - "ax.set_aspect(\"equal\")\n", - "colors = firedrake.tripcolor(extract_surface(u), axes=ax)\n", - "fig.colorbar(colors);" - ] - }, - { - "cell_type": "markdown", - "id": "9a900c91-a77f-4d7a-86e3-9c014512e3b9", - "metadata": {}, - "source": [ - "Now we'll get to the real modeling.\n", - "To proceed, we have to make function spaces to represent the membrane and basal stresses and create a variable that stores the velocity and stresses.\n", - "Here we use piecewise constant finite elements for the stresses.\n", - "In general, if you use $CG(k)$ elements for the velocity, you need to use $DG(k - 1)$ elements for the stresses." - ] - }, - { - "cell_type": "code", - "execution_count": 36, - "id": "db935250-689e-4ca7-aee5-c5b0f212c4d4", - "metadata": {}, - "outputs": [], - "source": [ - "vfamily = \"DG\"\n", - "vdegree = 2\n", - "V = firedrake.VectorFunctionSpace(mesh, \"CG\", 2, dim=2, vfamily=vfamily, vdegree=vdegree)\n", - "Σx = firedrake.TensorFunctionSpace(mesh, \"DG\", 1, shape=(2, 2), symmetry=True, vfamily=vfamily, vdegree=max(0, vdegree - 1))\n", - "T = firedrake.VectorFunctionSpace(mesh, \"DG\", 1, dim=2, vfamily=vfamily, vdegree=max(0, vdegree - 1))\n", - "T0 = firedrake.VectorFunctionSpace(mesh, \"DG\", 1, dim=2, vfamily=\"R\", vdegree=0)\n", - "Z = V * Σx * T * T0\n", - "z = firedrake.Function(Z)\n", - "\n", - "u = firedrake.Function(V).interpolate(u)\n", - "z.sub(0).assign(u);" - ] - }, - { - "cell_type": "markdown", - "id": "1d649590-0970-42c5-9fa2-52d8bb325dbf", - "metadata": {}, - "source": [ - "This is a subtle but important point.\n", - "But we'll also want to regularize the momentum balance model a bit by pretending as if it were linear.\n", - "We chose some value of the ice fluidity $A$, which is fine, but remember that $A$ has units of strain rate $\\times$ stress${}^{-n}$ where $n \\approx 3$ is the Glen flow law exponent.\n", - "If we only change $n$ to 1 in the parts of the equation determining the constitutive relation but do nothing to $A$, the physical units that we use in the regularization will make no sense.\n", - "So what we do below is pick some arbitrary stress scale $\\tau_c$, which here I'm taking to be 0.1 MPa or 100 kPa.\n", - "We're then choosing a strain rate scale $\\dot\\varepsilon_c$ so that $A = \\dot\\varepsilon_c \\cdot\\tau_c^{-n}$.\n", - "If we want to pretend like ice flow were linear, we could produce the right constitutive relation by then using the flow law coefficient $A' = \\dot\\varepsilon_c\\cdot\\tau_c^{-1}$ and all the units would make sense." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "cc16a5dd-3c51-453f-938c-895dd0963051", - "metadata": {}, - "outputs": [], - "source": [ - "τ_c = Constant(0.1)\n", - "ε_c = Constant(A * τ_c ** n)" - ] - }, - { - "cell_type": "markdown", - "id": "b16d9a32-7b64-4ce9-aa1e-cf38e900765e", - "metadata": {}, - "source": [ - "Now we're at the really important part.\n", - "To make the SSA model effectively do SIA, what we need is that, in the sliding law\n", - "$$K|\\tau|^{m - 1}\\tau = -u,$$\n", - "we take\n", - "$$K = \\frac{hA}{n + 2}.$$\n", - "Now in order to make our regularization approach work, we also define the sliding coefficient as\n", - "$$K = u_c / \\tau_c^m$$\n", - "where $\\tau_c$ is a reference stress and $u_c$ a reference speed.\n", - "We're using the same reference stress for the flow and sliding laws of $\\tau_c = $ 100 kPa, so we can then compute the reference speed as $u_c = K\\tau_c^m$.\n", - "We can then add more sliding on top of the effective deformation that we use to mimic SIA.\n", - "To add some extra real sliding, we've increased the critical speed $u_c$ by a factor of 100 m/yr." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "1b9a1932-e82b-45ac-a353-07c6d0f2ab67", - "metadata": {}, - "outputs": [], - "source": [ - "K = h * A / (n + 2)\n", - "U_c = Constant(100.0)\n", - "u_c = K * τ_c ** n + U_c" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "f4bbe65a-e7ee-41e7-9742-9feda268c3cc", - "metadata": {}, - "outputs": [], - "source": [ - "rheology = {\n", - " \"flow_law_exponent\": n,\n", - " \"flow_law_coefficient\": ε_c / τ_c ** n,\n", - " \"sliding_exponent\": n,\n", - " \"sliding_coefficient\": u_c / τ_c ** n,\n", - "}\n", - "\n", - "u, M, τ = firedrake.split(z)\n", - "fields = {\n", - " \"velocity\": u,\n", - " \"membrane_stress\": M,\n", - " \"basal_stress\": τ,\n", - " \"thickness\": h,\n", - " \"surface\": s,\n", - "}\n", - "\n", - "L = sum(fn(**fields, **rheology) for fn in fns)\n", - "F = derivative(L, z)" - ] - }, - { - "cell_type": "markdown", - "id": "9b8cdb6d-1b52-4e65-abd6-968b5eaf545a", - "metadata": {}, - "source": [ - "For the solution procedure, we'll want to use a linearization of the problem where the thickness is clamped from below." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "46a2aff8-bee5-4d9d-8f16-b4424484bf14", - "metadata": {}, - "outputs": [], - "source": [ - "h_min = Constant(1e-5)\n", - "\n", - "rfields = {\n", - " \"velocity\": u,\n", - " \"membrane_stress\": M,\n", - " \"basal_stress\": τ,\n", - " \"thickness\": max_value(h_min, h),\n", - " \"surface\": s,\n", - "}\n", - "\n", - "L_r = sum(fn(**rfields, **rheology) for fn in fns)\n", - "F_r = derivative(L_r, z)\n", - "J_r = derivative(F_r, z)" - ] - }, - { - "cell_type": "markdown", - "id": "4d91d056-05ff-4abb-a702-c1683b6a3718", - "metadata": {}, - "source": [ - "Observe below that, when we create the momentum balance problem, we want to find a zero of $F$ using a Newton-type method, but we're using the perturbation of $dF$ defined above in order to do the search." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "a1042066-7992-4d32-8a1d-62a006a2de11", - "metadata": {}, - "outputs": [], - "source": [ - "degree = 1\n", - "qdegree = max(8, degree ** glen_flow_law)\n", - "pparams = {\"form_compiler_parameters\": {\"quadrature_degree\": qdegree}}\n", - "momentum_problem = firedrake.NonlinearVariationalProblem(F, z, J=J_r, **pparams)" - ] - }, - { - "cell_type": "markdown", - "id": "35f45cb5-f7b2-40d7-aced-514de7a1f8dc", - "metadata": {}, - "source": [ - "Now we can see our initial value of the velocity.\n", - "Note how it's a different magnitude but similar shape to the SIA velocity." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "4040c1bb-a861-4697-b91b-f3ffc7ef04d9", - "metadata": {}, - "outputs": [], - "source": [ - "sparams = {\n", - " \"snes_monitor\": \":rainier-output.log\",\n", - " \"snes_type\": \"newtonls\",\n", - " \"snes_max_it\": 200,\n", - " \"snes_linesearch_type\": \"nleqerr\",\n", - " \"ksp_type\": \"gmres\",\n", - " \"pc_type\": \"lu\",\n", - " \"pc_factor_mat_solver_type\": \"umfpack\",\n", - "}\n", - "momentum_solver = firedrake.NonlinearVariationalSolver(momentum_problem, solver_parameters=sparams)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "e618ec87-b03f-44a8-8f0d-84b7ba2f58d9", - "metadata": {}, - "outputs": [], - "source": [ - "num_continuation_steps = 5\n", - "for exponent in np.linspace(1.0, 3.0, num_continuation_steps):\n", - " n.assign(exponent)\n", - " momentum_solver.solve()" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "27dea728-7c56-4a3c-83fb-87e7b32cc881", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "u, M, τ = z.subfunctions\n", - "\n", - "fig, axes = plt.subplots()\n", - "axes.set_aspect(\"equal\")\n", - "colors = firedrake.tripcolor(u, axes=axes)\n", - "fig.colorbar(colors);" - ] - }, - { - "cell_type": "markdown", - "id": "ed3613d7-c669-41b3-ba8a-5ae1244a2f94", - "metadata": {}, - "source": [ - "Let's zoom in and look at where the ELA falls." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "f5010542-3587-4bb8-9063-853a07e37449", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "firedrake:WARNING Subdomain (1,) is empty. This is likely an error. Did you choose the right label?\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "2bbcb16d-d444-46d3-810a-ab79194a91eb", + "metadata": {}, + "outputs": [], + "source": [ + "from tqdm.notebook import trange\n", + "import numpy as np\n", + "from numpy import pi as π\n", + "import matplotlib.pyplot as plt\n", + "import firedrake\n", + "from firedrake import inner, dx, exp, min_value, max_value, Constant, derivative\n", + "import irksome\n", + "import icepack\n", + "from icepack2.model import hybrid, mass_balance\n", + "from icepack.calculus import grad" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "205d8e57", + "metadata": {}, + "outputs": [], + "source": [ + "def extract_surface(q_in):\n", + " mesh_x = q_in.ufl_domain()._base_mesh\n", + " shape = q_in.ufl_shape\n", + " if len(shape) == 0:\n", + " VLin = firedrake.FunctionSpace(q_in.ufl_domain(), \"CG\", 2, vfamily=\"CG\", vdegree=1)\n", + " q_targ = firedrake.Function(VLin).interpolate(q_in)\n", + " element_xz = q_targ.ufl_element()\n", + " if hasattr(element_xz, \"factor_elements\"):\n", + " element_x = element_xz.factor_elements[0]\n", + " else:\n", + " element_x = element_xz.sub_elements[0]\n", + " else:\n", + " VLin = firedrake.VectorFunctionSpace(q_in.ufl_domain(), \"CG\", 2, dim=shape[0], vfamily=\"CG\", vdegree=1)\n", + " q_targ = firedrake.Function(VLin).interpolate(q_in)\n", + " element_xz = q_targ.ufl_element()\n", + " if hasattr(element_xz, \"factor_elements\"):\n", + " element_hor = element_xz.factor_elements[0]\n", + " else:\n", + " element_hor = element_xz.sub_elements[0]\n", + " if hasattr(element_hor, \"factor_elements\"):\n", + " element_xy = element_hor.factor_elements[0]\n", + " else:\n", + " element_xy = element_hor.sub_elements[0]\n", + " element_x = firedrake.VectorElement(element_xy, dim=shape[0])\n", + "\n", + " Q_x = firedrake.FunctionSpace(mesh_x, element_x)\n", + " q_x = firedrake.Function(Q_x)\n", + " if len(shape) > 0:\n", + " q_x.dat.data[:] = q_targ.dat.data[1::2, :]\n", + " else:\n", + " q_x.dat.data[:] = q_targ.dat.data[1::2]\n", + " return q_x\n", + "\n", + "\n", + "def extract_bed(q_in):\n", + " mesh_x = q_in.ufl_domain()._base_mesh\n", + " shape = q_in.ufl_shape\n", + " if len(shape) == 0:\n", + " VLin = firedrake.FunctionSpace(q_in.ufl_domain(), \"CG\", 2, vfamily=\"CG\", vdegree=1)\n", + " q_targ = firedrake.Function(VLin).interpolate(q_in)\n", + " element_xz = q_targ.ufl_element()\n", + " if hasattr(element_xz, \"factor_elements\"):\n", + " element_x = element_xz.factor_elements[0]\n", + " else:\n", + " element_x = element_xz.sub_elements[0]\n", + " else:\n", + " VLin = firedrake.VectorFunctionSpace(q_in.ufl_domain(), \"CG\", 2, dim=shape[0], vfamily=\"CG\", vdegree=1)\n", + " q_targ = firedrake.Function(VLin).interpolate(q_in)\n", + " element_xz = q_targ.ufl_element()\n", + " if hasattr(element_xz, \"factor_elements\"):\n", + " element_xy = element_xz.factor_elements[0].sub_elements[0]\n", + " elif hasattr(element_xz.sub_elements[0], \"factor_elements\"):\n", + " element_xy = element_xz.sub_elements[0].factor_elements[0]\n", + " else:\n", + " element_xy = element_xz.sub_elements[0].sub_elements[0]\n", + " element_x = firedrake.VectorElement(element_xy, dim=shape[0])\n", + "\n", + " Q_x = firedrake.FunctionSpace(mesh_x, element_x)\n", + " q_x = firedrake.Function(Q_x)\n", + " if len(shape) > 0:\n", + " q_x.dat.data[:] = q_targ.dat.data[::2, :]\n", + " else:\n", + " q_x.dat.data[:] = q_targ.dat.data[::2]\n", + " return q_x" + ] + }, + { + "cell_type": "markdown", + "id": "3ed26c06-ea87-4688-9761-e98e5b26684d", + "metadata": {}, + "source": [ + "This notebook will demonstrate how to use the dual momentum balance model to simulate the evolution of a synthetic mountain glacier.\n", + "We'll start with a completely artificial initial glacier thickness, and then we'll spin it up to steady state.\n", + "The overall bed geometry is meant to mimic some of the features of Mt. Rainier in Washington State, but we'll produce a smaller glacier.\n", + "For many measurements, see [this volume](http://npshistory.com/publications/mora/glaciers-1963.pdf) from 1963, edited by Mark Meier and featuring many contributions by Austin Post.\n", + "\n", + "Mt. Rainier has a circumference of about 150km, which works out to a radius of about 25km.\n", + "We'll use a computational domain about half that size." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "f4ed4de3-bfb5-4f7f-bfba-52fc0e913f8c", + "metadata": {}, + "outputs": [], + "source": [ + "radius = Constant(12e3)\n", + "mesh2d = firedrake.UnitDiskMesh(4)\n", + "mesh2d.coordinates.dat.data[:] *= float(radius)\n", + "mesh = firedrake.ExtrudedMesh(mesh2d, layers=1)" + ] + }, + { + "cell_type": "markdown", + "id": "55e5e816-7f40-435e-aa22-78051037a76b", + "metadata": {}, + "source": [ + "Next, we'll create some function spaces.\n", + "We'll use continuous linear finite elements for the basal elevation and discontinuous linear elements for the thickness.\n", + "In general, solving the mass balance equation for ice thickness tends to work much better with discontinuous elements." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "94cbe500-16ff-4824-b873-d94427a23278", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/dlilien/sw/firedrake/venv-firedrake/lib/python3.14/site-packages/finat/ufl/elementlist.py:433: UserWarning: Discontinuous Lagrange element requested on triangle * interval, creating DQ element.\n", + " warnings.warn(\"Discontinuous Lagrange element requested on %s, creating DQ element.\" % cell.cellname)\n" + ] + } + ], + "source": [ + "cg1 = firedrake.FiniteElement(\"CG\", \"triangle\", 1)\n", + "S = firedrake.FunctionSpace(mesh, cg1, vfamily=\"R\", vdegree=0)\n", + "dg1 = firedrake.FiniteElement(\"DG\", \"triangle\", 1)\n", + "Q = firedrake.FunctionSpace(mesh, dg1, vfamily=\"R\", vdegree=0)" + ] + }, + { + "cell_type": "markdown", + "id": "c3d0b834-dbca-4b2b-9533-44125ce72c71", + "metadata": {}, + "source": [ + "Mt. Rainier is about 4km high.\n", + "We'll use a bed topography of the form $B\\exp(-|x|^2/r^2)$, although this is actually a little unrealistic." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "58d11b38-22fb-4db3-bcf9-f989817715c2", + "metadata": {}, + "outputs": [], + "source": [ + "x = firedrake.SpatialCoordinate(mesh)\n", + "\n", + "B = Constant(4e3)\n", + "r_b = Constant(150e3 / (2 * π))\n", + "expr = B * exp(-(x[0]**2 + x[1]**2) / r_b**2)\n", + "b = firedrake.Function(S).interpolate(expr)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "24945f29-c8d5-4a0e-84f0-9253dd1d2067", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots()\n", + "ax.set_aspect(\"equal\")\n", + "ax.set_title(\"Bed elevation\")\n", + "colors = firedrake.tripcolor(extract_bed(b), axes=ax)\n", + "firedrake.tricontour(extract_bed(b), levels=[1600.0, 2100.0], colors=\"black\", axes=ax)\n", + "fig.colorbar(colors);" + ] + }, + { + "cell_type": "markdown", + "id": "799ff14c-f764-46eb-842c-8034f6c7476f", + "metadata": {}, + "source": [ + "According to Meier and Post, at 1600m elevation, the surface mass balance is about -8.7 m/yr of water equivalent, and the equilibrium line altitude (where surface mass balance is zero) is at about 2100m elevation, and that the SMB must average about 0.7 m/yr above the ELA for the glacier to be in balance.\n", + "We'll use these as rough guidelines; trying to be too exact about it gives an accumulation field with a really dramatic change near the ELA that results in generalized numerical mayhem.\n", + "When we define the SMB field, we clamp the values at the top and bottom in order to avoid producing unrealistic values.\n", + "Not also how we have to convert one of the SMB values from meters of water equivalent to meters of ice equivalent by multiplying by 0.917." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "eaeced4e-119f-4e85-a038-f7ef03964648", + "metadata": {}, + "outputs": [], + "source": [ + "z_measured = Constant(1600.0)\n", + "a_measured = Constant(-0.917 * 8.7)\n", + "a_top = Constant(0.7)\n", + "z_top = Constant(4e3)\n", + "δa_δz = (a_top - a_measured) / (z_top - z_measured)\n", + "a_max = Constant(0.7)\n", + "\n", + "def smb(z):\n", + " return min_value(a_max, a_measured + δa_δz * (z - z_measured))" + ] + }, + { + "cell_type": "markdown", + "id": "cf4ccb68-c028-4a97-9479-caf99ea467b9", + "metadata": {}, + "source": [ + "We'll start with a very artificial initial guess for the thickness and evolve it toward equilibrium." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "e49e504f-ac00-4c7e-a055-ffe1cd84b054", + "metadata": {}, + "outputs": [], + "source": [ + "r_h = Constant(5e3)\n", + "H = Constant(100.0)\n", + "expr = H * max_value(0, 1 - inner(x, x) / r_h**2)\n", + "h = firedrake.Function(Q).interpolate(expr)\n", + "h_0 = h.copy(deepcopy=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "16e78f35-2127-467b-91ff-abfa23addde1", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAhYAAAGgCAYAAAD2PC4mAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjksIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvJkbTWQAAAAlwSFlzAAAPYQAAD2EBqD+naQAAyStJREFUeJztXQe8HGX1vTNb3ntJSEJCGhBCqKETQgvSiUREpPkXEBARBZUeutJElCZVmo2moIAKAkIEQxMJLYB0pAQIhCS0JCR5ZXdn/r9z7/1mZl8CJHkvOztv79Fh387Oznwzu9nvzL3nnuuFYRiSwWAwGAwGQzfA746dGAwGg8FgMBixMBgMBoPB0K2wiIXBYDAYDIZugxELg8FgMBgM3QYjFgaDwWAwGLoNRiwMBoPBYDB0G4xYGAwGg8Fg6DYYsTAYDAaDwdBtMGJhMBgMBoOh22DEwmAwGAwGQ7fBiIXBYDAYDBnHww8/TLvtthutuOKK5Hke3X777VWvo3vH6aefTsOGDaOWlhYaN24cvfbaa1XbfPzxx7T//vtT3759qX///nTIIYfQvHnzlngs+S6fTYMgCAKaPn06LbfccvyhGQwGgyFbwOT66aef8uTr+8vuvrqtrY06Ojq6vJ9isUjNzc2Lte38+fNpo402ou9+97u01157LfT6+eefT5dddhldf/31NHLkSDrttNNo/Pjx9NJLL0XHAKl4//336b777qNSqUQHH3wwHXrooXTTTTct2cDRhMzwxZg2bRqatdli18C+A/YdsO9Axr8D+D1fVmhtbQ2HDs51yziHDh3K+1tS4L233XZb9DwIAt7XBRdcEK2bPXt22NTUFP7pT3/i5y+99BK/78knn4y2ueeee0LP88L33ntviY5vEYvFBCIVwLRp0zhMZDAYDIZsYe7cuTR8+PDo93xZoKOjg2bMqtDUKSOo73JLHxWZ+2lAI8e8TR9++GHVnNPU1MTLkmDq1Kk0Y8YMTn849OvXj7bYYguaPHky7bvvvvyI9Memm24abYPtEdl5/PHHac8991zs4xmxWEy49Ac+YCMWBoPBkF3UIp3ddzm/S8TCAUQoiTPOOIPOPPPMJdoHSAUwZMiQqvV47l7D4+DBg6tez+fzNGDAgGibxYURC4PBYDAYuhmVMKBK2LX3LypKvqTRijRgVSEGg8FgMHQzAgq7vCSj5G5ZGmIxdOhQfpw5c2bVejx3r+Fx1qxZVa+Xy2WuFHHbLC6MWBgMBoPB0M0IuuF/3QVUgYAcTJo0qUpvAu3E2LFj+TkeZ8+eTVOmTIm2uf/++7kiElqMJYGlQgwGg8FgyDjmzZtHr7/+epVg89lnn2WNxCqrrELHHHMMnX322bTmmmtG5aYou91jjz14+3XWWYe+8pWv0Pe//326+uqrudz0iCOOYGEntlsSGLEwGAwGg6GbUQlDXrry/iXBU089RTvssEP0fMKECfx40EEH0XXXXUcnnngie13AlwKRia233pomTpxY5ZNx4403MpnYaaeduBpk7733Zu+LJYWnNa+GLwDCRijPmTNnjlWFGAwGQwZRi9/xuXqMt19ZscvlpiNGTc/knGMaC4PBYDAYDN0GS4UYDAaDwdDNCCikilZ2LO37swojFgaDwWAwdDOCRMno0r4/q7BUiMFgMBgMhm6DRSwMBoPBYMh4VUg9wYiFwWAwGAzdjECXrrw/q7BUiMFgYMBhr1LJ8s+ZwWCoB1jEwmDoAWhv7aCPZ82lWdNn07zZ8+mTWXPp4w8+pU8+mEsvPPYG9VuhD3nkUUd7iZcPZ8yhMAgpX8jx81J7mcqlCu8rl/ep2FSgQlOeKuWA0AhyhaH9+TnWez7Rx7M+pQ23XIOWH7QcLT+oLy0/eDnq06+FBq80kAYMXo6ae9V/oySDYVmi0sWqkK68N20YsTAYMgBM+tPf+oDefWMWvfvGTHrtuWn00lNTeQL/5MO51Dqv/XPf/+6b1c2FPg8gE63ldmqdH+9z3pzWhbabPvWDz9xHS+8m6r9CH2pb0EGjNlmV1tpoFRq+xhBaefUhNGzEClRssp8eQ89GJZSlK+/PKuxft8FQR2id30ZvvjSd3ntzFk0DiXh9Jr32wrv00fuzKUsAKXHEZPI/n+clCUQ61gTZWH0IDV9jMK202mAasfYwWq5fr5RGbDB0L4IG1lgYsTAYUgLc9Ke9PpNeefoteuWZt/lx6ivTKcMR0MXGJx98Sk/860Veklh17WEc4Ri1yQhae+MRtMpaQ7lngcFgyA6MWBgMNcKnn8ynl595i155+m169Zm36aUpb1Lb/A67/gm89er7vEz802R+Xmwu0LqbjqRRo5VsjF6V+g/sY9fMUPcIyKMKeV16f1ZhxMJgWIa6iJeeepOeevBlmnzv8/TeG7Mow6XpqaCjrUTPPvI/XhxWXHUQjR2/AY3ZfhStt9nqptcw1CWCUJauvD+rMGJhMHQjZr77MT31wEv092seplnTP6b2BSW7vt0MiFj/+uv7eSkU8zRopeVpj+9uR2O2X4dWXHUFu94GQ8owYmEwdAHwfXh04nM05cGX6cUn3+SqDUPtUOooc3XKlaf9hZ+DWKy3+Wo0eptRtM2uG3M5rcGQBipdTIV05b1pw4iFwbAUokuQiIfveIYeuftZFiIa6gPT3/qQl/tueYKuPuOvtPVXN6Ltvr4Jrbf56pTLmQjUUDtUjFgYDIYvwv/++w49+PcpdM+Nj7I/g6G+Mffj+XT3Hx/lpamlQDvvsyXtsOemNGr0CPLg+mUwGJYJLGJhMHwO3njhXbrvL0/Qk5Ne5DthQzbR3lqiO6/7Ny9Dhg+gzXdal3bae3MuaTUYlgWC0OOlK+/PKoxYGAyLqOb4zz3/pbv/+B96bvLrdn16GGZO+5juvO4RXtbbbDX66oFfoq132YhLWw2G7kLFUiEGg2HmtI/od2f/nZ555H80f+7CFtaGngdoZbBc3vsW2mDsGnTo6XvQSiMHpz0sgyHTsIiFgRq9qgPuj4hOPP3wKxRkuXjcsNSA/bhzAh29zVr01QO+RFt+eQOrKjEsNSrk87L0788ujFgYGhJtC9rpnpsm0x8uvPsLG3gZGgvP/Pt/vDT3KtL+x36Fdtn/S9R7uea0h2XIGMIuaizw/qzCiIWhoTD3k/l0x7UPs4gPfxsMnwVU/vz+53fQn391H33t21vT17+7LQ0Y1NcumGGxUDGNhcHQs/HB9E/or795gO66/t/cFtxgWFxAb3Pz5ffRrVdNoq/uvxXtfdiONHSVgXYBDYbPgEUsDD0ar78wjf72mwfo33c9y9UeBsPSIqgEdNcNj9DdNz5KW+2yIe39/e1p1CYj7YIaFolK6POytKhkWO5lxMLQYyMUf7jwHrrvlsfTHoqhBxKMR+56lpcd99qUDpiwCw0bYT1KDJ2+J+RR0AXxZkDZZRZGLAw9CnM+nke//dlt9PCdz1KpvZz2cAw9HPf/7Sl6+M5n6Eu7bETfO213WmFo/7SHZDCkDiMWhh5TLvi33z5At171L+soaqgpkGJ76I6n6dF//pf2PnQn+sYPdqTefVvsU2hwVEy8aTBkE5Vyha477y6679YnaM5H89IejqGBUWqv0J9/dS/def3DNO4bm9MhP9md27obGhOVLmssLBViMNQcsNu+6vS/0FuvvG9X31A3mD+3jf5+zcM05aFX6Ac/3ZvGbDcq7SEZDDWF0WlD5vDh+7PpvKNuoBceeyPtoRgMn4l335hFpx5wFTc6O+nyA2nYiEF2tRpOvOl16f1ZxdLHaQyGGqPUUaZbrriPvrft2UYqDJnBq8++TYftcA7deMlEam/tSHs4hhohUEvvpV26UlGSNpbpyB9++GHabbfdaMUVVyTP8+j222+vej0MQzr99NNp2LBh1NLSQuPGjaPXXnutapuPP/6Y9t9/f+rbty/179+fDjnkEJo3rzqX/txzz9E222xDzc3NNHz4cDr//PMXGsutt95Ko0aN4m022GADuvvuu5fRWRuWBSb97Sk6ZJuz6dpz76L2tpJdZEOmUCpV6I8X3kMHb30W3XPjo2kPx2DILrGYP38+bbTRRnTFFVcs8nUQgMsuu4yuvvpqevzxx6l37940fvx4amtri7YBqXjxxRfpvvvuo7vuuovJyqGHHhq9PnfuXNp5551pxIgRNGXKFLrgggvozDPPpN/85jfRNo8++ijtt99+TEqeeeYZ2mOPPXh54YUXluXpG7rJ9fDi42+iXx79B/amMBiyjE9mfUqXnXwznX/UDWYp3yDizUoXlqzCCxE2qMWBPI9uu+02ntABHBaRjOOOO46OP/54XjdnzhwaMmQIXXfddbTvvvvSyy+/TOuuuy49+eSTtOmmm/I2EydOpK9+9av07rvv8vuvuuoq+slPfkIzZsygYrHI25x88skcHXnllVf4+T777MMkB8TEYcstt6SNN96YSc2i0N7ezkuSwCAagjEiemJY9rj7xv/QDRfcbdUehh6J5fq10H7HjKc9v7dD2kNpGOB3vF+/fsv0d3yuHuOmZ9enXsvllno/Cz6t0Lc2fiGTc05qlGjq1KlMBpD+cMCHscUWW9DkyZP5OR6R/nCkAsD2vu9zhMNts+2220akAkDU49VXX6VPPvkk2iZ5HLeNO86icM455/B43AJSYagN0BzsvCNvoF+dfIuRCkOPxadzWuk3P72dzj7sGvp41ty0h2PoZlRCr8tLVpEasQCpABChSALP3Wt4HDx4cNXr+XyeBgwYULXNovaRPMZnbeNeXxROOeUUZopumTZtWhfO1rC4uP2ah+h72/2cHrx9il00Q0PgP3f/l7/zt1z5r7SHYjB0C6zc9DPQ1NTEi6E2aFvQTled/le692br7WFoPLTOa6Nrz7mT3nplOh1+9v+Zc2cPQEWrO5b+/dk1yEotYjF06FB+nDlzZtV6PHev4XHWrFlVr5fLZa4USW6zqH0kj/FZ27jXDeni6YdfoUN3PMdIhaHh8cBtU+jQHX9Bk+99ruGvRdYRhH6Xl6witZGPHDmSJ/ZJkyZViV6gnRg7diw/x+Ps2bO52sPh/vvvpyAIWIvhtkGlSKkUlyCigmTttdem5ZdfPtomeRy3jTuOIR1AwPuXqyfRqQdeTR+8ZxUfBgPw8cy59LPv/Z5uuuSfVKkEdlEMmcMyJRbwm3j22Wd5cYJN/P3OO+9wlcgxxxxDZ599Nt1xxx30/PPP07e//W2u9HCVI+ussw595Stfoe9///v0xBNP0H/+8x864ogjuGIE2wHf+ta3WLiJUlKUpd5888106aWX0oQJE6JxHH300VxNcuGFF3KlCMpRn3rqKd6XIR3Meu9jOubrF9Hvf34HhUF2Q34Gw7IAavX+cOHddPSuv6R336yO2hqygUoXDbK6kkZJG8t05Ji8R48ezQuAyR5/wxQLOPHEE+nII49kX4rNNtuMiQgIAEysHG688UY2ttppp524zHTrrbeu8qhAxca9997LpGXMmDFcvor9J70uttpqK7rpppv4ffDV+Mtf/sLlqOuvv/6yPH3DZ+DFJ9+kI3a5gP737Dt2jQyGz8EbL75HR3/tQnrmkVftOmUMQRcrQ7Icq6qZj0XWUYv650bAtefdRX+9ehJVyln+Z2Mw1B5f/+529IMz9+Ror6H+fSx+/fQYaumz9PURrfPKdNgmUzI551hViKFmVR+XnPBneuiOp+2KGwxLgTuueYg+nP4JTbjwW1Y1kgEEXez3keVeIUYsDMscrz0/jc790XU0/a0P7WobDF3AoxOfo9efn0YnX3EQrTNmpF3LOkali7bcWbb0zu7IDZnAfx99jU7Y+1IjFQZDN2HWe5/QSd+8nJ564GW7poa6hBELwzLDTZf+k36y/5XU3mrdSA2G7kSpo0ynfftquuacO+3C1ikC8rq8ZBWWCjF0O+AzgjLSv/3mAbu6BsMyxK1X/ova5rfTYWfuSbn80je8MnQ/Kg2cCjFiYehWtLV20E++dSW99NRUu7IGQw1w5/X/pleenkrn3Hwk9V4uLtU3ZN3S26esIrsjN9RlV9KT97ncSIXBUGO89vy7rGWyLqmGeoARC0O34L03Z9EPv3wuvfrM23ZFDYYUMPXl6fSjnc+jN16wTsz1gAAmV11csgojFoYu4+1X36fjcbc0c65dTYMhRcz5aB6dtO8V9NpzRi7SRtBFO+8s+1hkd+SGuqmrP3q3i2j2h/PSHorBYCCi+XNaacKel9ADtz1l18OQCky8aeiSR8W5h19HpY6KXUWDoY5Q7ijThRNupD79e9FmO6yb9nAaEkEXW59b23RDw+HeWx6jH3/rCiMVBkOdAv14zjjoN/T36x5OeygNiQp5XV6yCkuFGJYYj937PF160p8pqFj/OoOhnoEek78582/077ueSXsohgaCEQvDEuFff3mCzvre7ykoG6kwGLIA3AD84ofX0V3X/zvtoTRkKiTowpJVZHfkhprjyQdeoktO/BPfBRkMhmzh6jP/Rv+5579pD6NhUOlyOmQJj1ep0GmnnUYjR46klpYWWn311elnP/tZ1e81/j799NNp2LBhvM24cePotdde6/ZzN2JhWCw888irdMZ3fkOVUmBXzGDIqObi54ddQ4/964W0h2JYBjjvvPPoqquuossvv5xefvllfn7++efTr371q2gbPL/sssvo6quvpscff5x69+5N48ePp7a2tm4dixELwxfihcffoJ9+93cUBhapMBiyDNy8/uIH19LTD7+S9lB6PIJuSoXMnTu3amlvb1/k8R599FHafffdadddd6VVV12VvvGNb9DOO+9MTzzxRBStuOSSS+jUU0/l7TbccEO64YYbaPr06XT77bd367kbsTB8LmC0c/K+l1N7a4ddKYOhB6DUjs6ovzbr/Ro1Iat0YQGGDx9O/fr1i5ZzzjlnkcfbaqutaNKkSfS///2Pn//3v/+lRx55hHbZZRd+PnXqVJoxYwanPxywvy222IImT57creduPhaGz8T0qR/Q6QddzSFUg8HQcxBUAjrz4N/QBX89mkasNTTt4fRIhF1sfY73A9OmTaO+fftG65uamha5/cknn8wRjVGjRlEul2PNxc9//nPaf//9+XWQCmDIkCFV78Nz91p3wSIWhkUCzYyO2vWX5qhpMPRQfDp7AR2z24X0wfRP0h6K4XMAUpFcPotY3HLLLXTjjTfSTTfdRE8//TRdf/319Mtf/pIfaw0jFoaFMP/TNjrt21fzo8Fg6LloW9BBpx54NX36yfy0h9LjUOmmVMji4oQTTuCoxb777ksbbLABHXjggXTsscdGqZOhQyUyNXPmzKr34bl7rbtgxMJQhXKpQkd+9Xx688X37MoYDA2Ad/43gw7f5QLqaCulPZQehaDG3U0XLFhAvl89pSMlEgSSykYZKggEdBgOSJ2gOmTs2LHUnTBiYajCr065md5/6yO7KgZDA+GD9z6hi467Ke1hGLqA3XbbjTUV//jHP+itt96i2267jS666CLac889+XXP8+iYY46hs88+m+644w56/vnn6dvf/jatuOKKtMcee1B3wsSbhgi/PvNvdO/Nj9sVMRgaEA/d8TS19Gmio8/bN+2h9AhUtP15V96/JIBfBQyyfvSjH9GsWbOYMBx22GFsiOVw4okn0vz58+nQQw+l2bNn09Zbb00TJ06k5uZm6k54odkoLhYQMkJpzpw5c6oUuj0Fk//5PJ31vd+lPQyDwZAyTvrVt2n7PcZQT0Qtfsfn6jGOemR3aupTWOr9tM8r0WVb/z2Tc46lQgz0xovv0vlH3WBXwmAw0MXH/4lefvotuxKGpYYRiwbH7I/m0fF7XcrqcIPBYOhoL9HJ+1xOH82YYxejCwjI7/KSVWR35IYuo1IJ6NzDrzNSYTAYqoAKkV/88FquEjMs5e9r6HV5ySqMWDQwLjjqBvrvf7q/s53BYMg+XnpqKp192DVpD8OQQRixaFCgffJDdzyT9jAMBkMd4/H7XqAHbnsq7WFkEkGNfSzqCUYsGhDvvjnLatYNBsNi4dKTbqapL0+3q7WECLvY2RTvzyqyO3LDUgFdSo/b8xJaYHbdBoNhMX8zTvy/y6h1/qLbdRsWjQp5XV6yCiMWDYbf/ux2mvux9QUwGAyLj3lzWunKU/9il8ywWDBi0UB47N7n6R9/+E/awzAYDBnEv/7yBD3496fTHkZmEIRd1VlQZmHEokGAmvRf/PC6tIdhMBgyjAuP/SPNfPfjtIeRCQRd1FhgySqyO3LDYgOu7b889o9U6ijbVTMYDEsN+FrApRceOAbDZ8GIRQPgjxfdTc8+8r+0h2EwGHoAXnpyKl177h1pD6PuEZDX5SWrMGLRw/HWK9PppkvvTXsYBoOhB+GvVz9A//vvO2kPo65RMedNQ08EwpVoKEQZFgEZDIb6xMXH32SW34ZFwiIWPRi3XHGf3VUYDIZlgrdeeZ/+eNE9dnU/A4GJNw090V3zDxfaP3qDwbDscMsV/6KpL79nl3gRCKCT6Eq5qWksDPVWBXLJ8X+iMMuF0AaDIRO/NUi3WpWIIQlLhfRA3P77h+jFJ99MexgGg6EB8Npz0+gvV/0r7WHUHcIuVoTg/VmFEYsehg/fn02///nf0x6GwWBoINzwy7vp/bc/THsYdYXAupsaelIvkErZzGsMBkPtEFRC+vWZt9klT16T0Jw3DT0Az01+jR6+85m0h2EwGBoQj//rBXri/hfTHoahDmCpkB6CSrlC51gvEIPBkCIuOOoP1jpAYakQQ+Zx5/X/ptkfzUt7GAaDocHbq//tNw+kPYy6QGCW3oYsY/aHn9IfL5qY9jAMBoOB/vyre+mD92fblWhgWCqkB+CCo/9I8+e2pj0Mg8FgoLYFHXT+ETc0/JUIrCrEkFW8+dJ79PTDr6Q9DIPBYIjwwhNv0CvPvNXQVyQwYmHIKq4//660h2AwGAwL4dpz7rSr0qCwVEjG7wqemPRS2sMwGAyGhfDc5NdpyoMvN+yVCSxiYchqaZfBYDDUKy487ibuJ9KICIxYGLJoRjPrvU/SHoah3rCoH3GsW9RiMCxjfDJrrpn2NSAsFZJBBEFA151n2oqGx2eRBfd3EHzxYjAsY/zhl3ezgV+jIeyil0WWqb8Riwzivlsep7deeT/tYRjqCUlyUakIadDnYRBES3K7sFKRdQbDMsR7Uz+gf/zhkYa7xoGlQgxZilb85qzb0x6GodZYVDQCBKITiWDC8HlkAut0GwaeYx8GwzLENefcSeVSY33PAiMWhqzgkX/8lxZ82pb2MAy1jEA4cgAC0JlAJMmCIxOd39d5X0lCotsYuTAsS7S3luiB256yi9wgSD0VcuaZZ5LneVXLqFGjotfb2tro8MMPp4EDB1KfPn1o7733ppkzZ1bt45133qFdd92VevXqRYMHD6YTTjiByuVy1TYPPvggbbLJJtTU1ERrrLEGXXfddZRF3HrVv9IegqHWEQp9DBPpi86RiCTp8Bx5SD4mSAR5RJTzZfGxePyY5Zyuof5x69WTGqpCJLCIRbpYb7316P3334+WRx6J83HHHnss3XnnnXTrrbfSQw89RNOnT6e99torer1SqTCp6OjooEcffZSuv/56Jg2nn356tM3UqVN5mx122IGeffZZOuaYY+h73/se/fOf/6Qs4fFJL9Drz7+b9jAMy5pIOBLgyMJnkYjkdvw3HjXcrGSByUM+R1TIExWxFORvt66Q0218/jss5nkJCvLIi9uG9+lRiPeCnHj4j8GweJj22kx66I6nG+ZyBQ1MLPJUB8jn8zR06NCF1s+ZM4d+//vf00033UQ77rgjr7v22mtpnXXWoccee4y23HJLuvfee+mll16if/3rXzRkyBDaeOON6Wc/+xmddNJJHA0pFot09dVX08iRI+nCCy/kfeD9IC8XX3wxjR8/fpFjam9v58Vh7ty5lDZ+feZtaQ/BsKy1E/p3UgMRTeCdUxoOIBBuos9h0vfi13kdXvfi/XsehS5Sgffxeo883o+o0b3omG4MOC5RmENkIyTKYX/xe/lJqcJ/GQyfhd+d/XfafvcxdoF6OFJPhQCvvfYarbjiirTaaqvR/vvvz6kNYMqUKVQqlWjcuHHRtkiTrLLKKjR58mR+jscNNtiASYUDyAKIwIsvvhhtk9yH28btY1E455xzqF+/ftEyfPhwShOvPvs2vf/Wh6mOwbBsS0WrhJWfp7Egl8rIgZXHjxyF0KWpGK1DhCHkCERBHrFd3r0XUYuCbKfpEQ+vYZ8c8RBiAiKC6AW/jtdyur07Jtbhdd13mEtENgwGxUcz5tBzk19riOsRhl6Xl6widWKxxRZbcOpi4sSJdNVVV3HaYptttqFPP/2UZsyYwRGH/v37V70HJAKvAXhMkgr3unvt87YB+WhtXXRX0FNOOYUjJm6ZNm0apYlbrzRtRY/CZ5lWJclDklQgxcETvqY3MNlHZEGJApMGt+QobCry30wemEBoKgTrXBqEF1kfERAlGaEjFCAY2CZx7IiA4P0c/YgXJhy8Pz/eH1IoGuQwNDZuuaIxfsuCLnhYuCWrSD0Vsssuu0R/b7jhhkw0RowYQbfccgu1tLSkNi6IPLHUA958eTr9Z+JzaQ/D0F1wlRhJIduiIhSAS2NgweSeTHNo5AC/P7wvvMZRAs6LaLQgT6EXkueDABCFHvaHY0i6g4/C28n2fFgnAsVdE4Xk5RPbuXWOIgQqBvX00Q8lxeLOyQvl+DgPPkBABLMkvM/QkJjy0Cv08pSptM6YkWkPxdBTIxadgejEWmutRa+//jrrLiDKnD17dtU2qApxmgw8dq4Scc+/aJu+ffumSl4WFzdfdq/d6mUZnZ0wO5OIKCrh3DB1cgZJACHgVEdiKRYlfeGIRV4jEZrqiKIRnAbxKUDkoujSISrQbM5RuTlHQUtel1zVErbkqYK/exUoaMrJUsSjT0HRpwD7BklxugwnFOXIhowLKZMQj25MmlaJBKVO42FoONx0abaE80uDoIHFm3VHLObNm0dvvPEGDRs2jMaMGUOFQoEmTZoUvf7qq6+yBmPs2LH8HI/PP/88zZo1K9rmvvvuY9Kw7rrrRtsk9+G2cfuoZ7QtaKenHmrcDoE9VkeRJBTOV8IJLZG2QDrDpSd4yfMkHaU5XHUHSEJTgcKWIgW9hEAEBRAAEIO8EIMWnyogBgWkJnx+DFD50ZyjCv4G+XCPulRAHvB+3j5XvTThvUJIKthHk5KRZpCQvBAQbKcEQlIhmlbx9BFpFowbZKegmoy0Py9DzfD8Y2/QvDkLevQVDxtYY5F6KuT444+n3XbbjdMfKCU944wzKJfL0X777ceiyUMOOYQmTJhAAwYMYLJw5JFHMiFARQiw8847M4E48MAD6fzzz2c9xamnnsreFy6V8YMf/IAuv/xyOvHEE+m73/0u3X///Zxq+cc//kH1jgf//rQZYmUZrqpjUT09osoNUHzVK7h8BCIAiES4tEIyzaELJmOu5IB+AduxJsKjAOu1WIOLOvJSJkqVkHyQGo4UyHZ87ABpj/jQ/ATb4O9cSLlEAUqg4/ErIEeIsnhERSVRZakc4X3xOcgxPWznJw7gziNZBQMPG5CLclm2N/RotLd20KS/Pkm7f3e7tIdi6InE4t1332US8dFHH9GgQYNo66235lJS/A2gJNT3fTbGQvknqjmuvPLK6P0gIXfddRf98Ic/ZMLRu3dvOuigg+iss86KtkGpKUgEPDEuvfRSWnnllel3v/vdZ5aa1hPuuObhtIdgWBok3DEXaced1FC40k8QCUccsA2nFKSUFBMvJmSej/nu3+PoAx65EtR5TIBYQBOBpziMp8QCbyy6ytEwJhZMFELyKjIevklSUsEEIQgp0ImeSQUW1lXoufHxQ/LKAQVaksrUA39i83JAXhn7l3MCEWKNhiMfLLuABsMRqnyswTCC0aNxx3X/7tHEIuhiOiPLqRAvbCQrtC4AFSSIoKBCBJGTWuB//32Hjv6aeG8YMoJOUYmoyVfnKIUzsHKulxyh0AoLRy5UZ+EMqgLWXsQRihBiTBhb4R9yEEo6QYkFRy+wvpKIWLB4UyZwPOL9TrcpKRkiyCYiUsHjDyU6wdEN9asIlIiAVGDyx/blgLeTNynRwXtBLCqOJISU06iGHE/SQI6ICJkAEakwWeEoBhx0rU9aj8V5txxBG45ds0f9js/VY4z567GU7730BQDl+e00Ze+Lazrn9JiIheGzcfcf/2OXJyvoFJWoMrhKrOcIBAAy4fwi9HmSWKDuQgSY0CNI2gMaC05zaAVHAKJQcNvLRO0xscC+9X1crZEwwwLwXheZSKRB4nG6v2V9BSkU95xzvyEHFjhAoSSBCQlMPxEl0VMCoeAS05yShEpAngdtiRKXXEheKWHC5Y7hIjIctcGB4C6a5eI7w2fhnhsfrSmxqCXCLkYsTGNh6HbMn9vaUPa3mUfndEdnLYUTZrqSUSYZuWodBWsPlChARFn0yUdhpyMWmHAhptS0AU++IBAgGPg75x5VH8GRD0QstLwUx9BDgZQwW8A2ICTRichfPPKcm/QxyevpuKpRjjYgciGvg9CEXGoq+5B0S0jIgDAPAm/AWDi6ouWx+NHNeZTrQIRCiQ/Ov6CRER5KwIJPeGaw/sJFRQw9Ao/c81867KN51H9gn7SHYuhGWMSiTvGvvz5BbQs60h6GYXGQjFIk7bcX1fTLlYhKHjJyu+SUhnpNIOIg6zwq53Q2VsLA+gmQDg18hE1iPiU6DBAGsduOEpxOY8GTvUYKXLRDSQImchAESX9w7EPIiTzV7qdOf+FIgpACYQq6lAPKlSQtw2QDwyrmolQIl6eqNtRpMJAagXbDKyGSAaKiEQ2kRNgtwyMPv1KccgFzcs3W7KvZE1DuqNC9Nz9G3/xRtTNyT0DkeN+F92cVRizqFDdd3PPrvDOPRTlnuugEykoxLXbuIOoEmVgHcOmolmRqVILv+p0IMx8bWoFAcBloUay2XTqDAyA6ubPAEvOvm+wxT+NfeSIIwLtzxALASs044AmvT6ZDkP4AF9KhIHrBRAGPXBHiCAsiFxrCxf8rRH4JaRSkSoRNgCwETvQJYahjJvC7CELKlSQ64mGA6D2Ca6L6DFSWeDg3TvsEVj3SQ3Dz5ff1SGIR8Le9C+LNDCf/jFjUIaa9PpPmfjI/7WEYllZPAU8KTJysl9AeG5zi0MiFlluy7sD12VDzKCYTShbgIcHrEMVABUheKzkATX2452qKKZGMBLFgjYM2KONH6CEcb+hsUMUTfvWtUmSsqSSF/wbJQY4jIfR0vcj4GDg97ArRCBADbIu0SQ7RFNk5H7YSUCVERCInxKQUyPFcxIOJmu4cB+UUUY6vN0czTHvRI7Dg0zZ67blptOaG6fZjMnQfjFjUIUxbkQEku4t2jlq4LqNwx+QIRqytYNKgHUhZZNmck4le0yFMHkAoMO9iUmbHzFis6UpJxWMChCNhfYF5OLcwsYj1FIlW59BGuGyHi244oZnbv2YfmD+4xqhaveFrd/bYt0KjJ4UE0dCqFN5BUVIxlVJAeQg2kXrB602aooFAFFEQzgVJhAbj9ksB+Uh/YGuugAFJUUt0P0ceDMM6SkJCDJn+zetpxCLsosmViTcN3YqH73zGrmjdInbQjCZpLSt1/hBVzboKefLCQMtJRWPBJALkAemOItwo1YtCIxDsfln0qcKyC23ehfkWhCEvf7vfKxFsynM317tIBJMKfU8ERyIK8rorK+0cdeV5WsWbEYeKylAlXcERjEqsl/AKMMOSdW6/4ruhrUQ44uHxefFgKz5rLLhMlf0skN6RFAnrLzokqoPt4YXhg2mgfJXNweDpwSUr4oGh6RlDNvHvu56hQ37ydflMewgCROMa1MfCIhZ1hheefJNTIYY6RRSaTzQDA1Q3wBMeV0jEKQ8WBrCWIq9VHQkvChAHrNOoAyyy0ZeD7/LhFaUGWOxBwSRB/St0gaaCCYmLSrhJnss8VXfhyj+d0JKfqNCT11enRFjD4CIcAYy24rakLuURRSlcZAOxBt2OjwO9BKd6XJRDF+ETrM1g06xSSCFIQ0n9MfQ8EMEIQNa0+ZrfVpHgD7qqtpeV3GBwkm5iEkQV011kFLPe+4SefOAl2nzH9dIeiqEbYMSizvDIPyxaUZdINA8LF5H+4EZb+Bt9L6CrQImkS4moNkAst0V4CREmz9taAcI9O4pIg8TiSSYPyKY40aOLWGgUABM0RyNcCag+sgMmkwvZVwBdgyMOmoKQ7ZUMcSdTeVm0F4l0iB9yx/bodY1igERE2hJsi2IN3Y6JDaIx8LtQsSdLTJTYOJ0GV8XkcR4eVQqeBHnYApxDQFLNUshJRAMls+yLoQ6kHJ3Q8AtImzh/UKDkIrv3eo2LR+7+b48iFmEiJbi0788qjFjUGR6794W0h2DoDOei6f7u7E8BsgBiwaF/RCDyogaHuZP270AkQqofpJST9RWc5vAo6IWqEE15uKiESh4kQiEVIDxpQ4Oh20FfwRM9l6MmxJoq4BRCouTDpUBATFSEiQmd7/QdiQAxSD7nc/TERwt/R1EMrQjhE3bVJFp56rwuOLrgySWClhVBBhCcvMf6DCEPiQ7v4A24Ju2oDNHhwgyMq1CR7gBR06iGlyO/vRwbe4FoQHeBqhEfFyUU3YV9kzOFp+5/iSqVgHLORC7jCE1jYagHvPz0WzRz2sdpD8OQRMI5MznfVltzq2Om+0FElIKdNUVXId1DkQ7RGTrv8wSOrqAVaDq5zFRTG/mEjkJJQbQe0QXevxIQrhyJQw2u7FSsvhMVo7jbj8SbnQWbCeMsRB3c3wjQ8PlpBYojABxMSBTRuWiEq2N1mSK8D2QCkQ0lQRKlQJUIUh9KcHKJCAYe4d3B2hKfch0gEdJHhPuiqJNnvgPVI5L/yZUD1l0wYDbmqnK4GsUiF1nCJx98Ss9Nfo1Gb7122kMxdBEWsagjoNufob4QunbmVXfx0vrclZMyiYjSHjoRN0k78EBTH0wkUOGhaY5SM1qei2tmBXoDhCGcQJOdNtVrIh97SAhpQDVEnPqIohFOu8iaCkQGVHzJZAMTtI49+ehSLk57kUueeLwNmpBFUQnnmAl9BJOZTmZcToPheExC5OrD7039LioqI4lIhUu34FpgZTvG41HYDjtv1ZnAiRSkgolGnnJtZQo8EXFGoj8cj3ueSCgnNCvwTOH+vz3VY4hF2MARi54Rc+oh+NetT6Q9BIMCxAHiQQgEw7Z2Che0cXgdRAOTFRULIsZ0xlZRNQgIRZwCATFgUys2x5JS0tJyBQp6QVeh5ICjFyFHLzgSoZUeUl4Kd06XIpHIBe7+edHoBrapFEMKWkKqtIQU9oJ2AQREFiro85yuyyUWrMfrzmPCrS/E63kbfj/OmygshhQ2yRIUoIUIqIIx4Hzwup4HCE6FdSP6vNP5gVA5o67QnUuTrtPtys0+lSFoxZL3uQQXaSVcV7neKpTlLrCiWhVtia5j/YUhS2Wn+HfXk7qbBl1YlhTvvfceHXDAATRw4EBqaWmhDTbYgJ566qmq37XTTz+dhg0bxq+PGzeOXnvttW4+c4tY1A3eemU6tbeahXfdgFuBl7k/RQj1Ilp5lxG/x+SLEtKihN5VnMlvgWAThlYQcGo5KTtksiBTSkhR8SGTrkQjAGkmpk6aqqtIkgZEHDi4oBUTQjb0vUiFOF2EijZZMYmIhTOtSog3q8pLk7cViS7lTveQfI3bpGuL9cjGO9E7hOtC1DWTT4RTJJoy4bRKSLmoKZp6VLC7KFHIKZOQS2u9su4S2goNAHEapC0kvz0kHxUz+AzaYb7FnVR44YBPSQpuWSjLKZlErSw6pi7L74uhW1BqL9Nr/51Ga48ekfkrGtZYvPnJJ5/Ql770Jdphhx3onnvuoUGDBjFpWH755aNtzj//fLrsssvo+uuvp5EjR9Jpp51G48ePp5deeomam5upu2CpkDrBUw++kvYQDA6qp2DPCbaOFnvusL1E1FQQ2+pSBztGsmjTlZjmc0IqQAxacloNIQ26Ki2+VIK4NEbCk6JajKl6Bhe10JRGOWnFnU8SikTFh5KLiEhERlrxc+0NVkUsIk8MFkbq8ZMkhKs39M2d9BlJMy3u6cH5Gq2cKUulCKZ/sfJWHYjrjFqKy2H9igo9IcBsV+OvqHpEtBeogim0YVu5rtKATS3DnXjUiUm5ikcbpGk0ydIi2cBTD73cI4hFd7ZhT6KpqYmXzjjvvPNo+PDhdO2110brQB4cQLQvueQSOvXUU2n33XfndTfccAMNGTKEbr/9dtp33327bcyWCqkTTHno5bSHYNB/fMmFyYPTUjQVRahZLEgqhGd6dN8ECUCUAl4VKthEhKIlR+WCTx298izURFSijMgEJmncrWNBaB9EpAm6AS8iDZUo/RCTjjLSJS0BBc1KKpDWiLaLF0ounM4IZMkHRIUKhcUK/x1t76M9eUBeISDCNkh5+PI65StERayv8BK61yEIZXLTKYWC/RYTryNFU5BUCQgE0h8oocW2nEJBWgXb8Ps1coMSVKRQ1MIcS7kZpaceBc2ICImmhc3F4ErKqRMVeEIkq31ZxNArYVrmusga6hpTHuwZv4VhGOsslm6R/YAs9OvXL1rOOeecRR7vjjvuoE033ZT+7//+jwYPHkyjR4+m3/72t9HrU6dOpRkzZnD6wwH722KLLWjy5Mndeu4WsagDLJjfRs9Nfj3tYRiAMmIDCetrgO25VQDJJANiTNep1BeSUfCp0iwTXtRtFP4UvXyZDNX/IYSGwHlUONdM1R7wBOkakGm1B0SOmKQjvwomAnjFdU1NPFdhpDPGitIjORm7nJL8HYYB+VHoQqs4EuBoC0Sf8LEI/OiHjiMDiIpowzJhVa4qRTeId6vHl3rSABGKkq8eGB55EGpi2CjicBUvOOcmjw2zXNd2GZCkTHA9Kr2QcslRvoR0lXaI1ZQIp54QeQEp1PbzIjYNpBFa1P/dUK945em3aM7H86jfgGy3Ug+7Sbw5bdo06tu3b7R+UdEK4M0336SrrrqKJkyYQD/+8Y/pySefpKOOOoqKxSIddNBBTCoARCiSwHP3WnfBiEUd4IXH3qAAgkBDylCrbpCLhHcFT1K9Wjh6wcQBL4A8oE9Fc7OG5OUOOQSJwHNMkBAZquEVP0aVHDJJS8MxTYEUY7MpiVKIpoFLRbUfCEco1KNCnKdUPxHpHDT8rxM5pxV8aBuk1wYrHrCe+YezyBQGstDPXy4kH6RCPLTkR5IvCIiLRHMCEAReXJpFy2nVw1sqZ9SkAvke7sUWUlAWAsAEI2GUxeWuzkEU564t2EEQcuU4fcSeF7188udjjIis6OfE1wGpESF8HnIm3JdE9RXsHeITtZvHRT0D/zaeefhV2n6PMWkPpS7Qt2/fKmLxWYDoFRGLX/ziF/wcEYsXXniBrr76aiYWtYSlQuoAT/WQ0F+WAUIRdJR4EsIdb1gq80LtHTHZ4EhFjvxigTw0GGuSSAWH4Tm9IeQCKY5KSz7ymhCyINsgcsEpgRYRYQZoO470h6YJUBki1SAkKQ8QDqQemEAkUx4gK+41SXH4TSH5zQHlCmUqFCtUKARUyLulQvl8mXI+DIgqlMsl1utzWWS7YlHW5RPr8V68lud96fsLFWpqxjocNyC/CBfSilSQgDBxKoaq0y56Xjh/idLIdcG5o7KE3PNmJWRFIWAVRHs4XaRN2QoS3YBjadiCFImIZSPbcxAs12WWU1qaJoHeIu0vnOFz8fS/X838FQq7YVkSoNJj3XXXrVq3zjrr0DvvvMN/Dx06lB9nzqxuGYHn7rXugkUs6gA9JaeYWWjYnP0oOBggZaZBqUQetzxX74pyhXwQCi1lRJQCgkxuLqb22dw0C5EK9ahwEyeXeYJY4O9iwqdChZWRW6YzvQKhUEttJhCaX4AfRizOlDSHSEDETIoDBF7A0Qbe3kPEAmkP5xwqSQPe1o/XI/IAyPp420hwidSFM7PQ9VyJgfFpvCMMffa54KhO1IJdoxhOIJqoLIHYk+3HXdQEkRj0CFGHTnhbICrCaRw22EKUgyhAmgRjKnpU8iUlgl4i7BDqeyzm5CoctQhnew7pxy4RDBddQi+SdL5xhi/A0w9lX8we1tjHAhUhr75aTcj+97//0YgRIyIhJwjEpEmTaOONN46EoY8//jj98Ic/pO6EEYuUMf2tD3kx1Am5QHoDpli40+X+HjmJTnD1B0L3EDBqQzGQCogIVTTId9lNaCImfT+YTFB1+3LXpVTC/c7vIS4jlSoQEWSKXkHTHxxb1BIJTX14iCTky1y2yYfhG3Sch0QT5Og+RxpEY6HpCXWlkm2FZIhbtggxopSHKzpxhldKArh6IwwpjzE6oZlWgbKzZggyg+AP+oxI35So4oRzRCARUkbLbqSFkIIOj3xYbmpPFK4GCWLTLkQn4NaJaBLIAkd3dJxBxSPoTrklPSIkgU9eR8CBHFQFB+0YV0VbxUuVjjp/pfd9M3wuPpo5h6a+PJ1GrrOiXanFxLHHHktbbbUVp0K++c1v0hNPPEG/+c1veAHw7++YY46hs88+m9Zcc82o3HTFFVekPfbYg7oTRixSxsQ/PZr2EBoafGedXLibJtynAtFUOKMlFmrCljtPXlNBW5vnxZsC0QtULqDyo0n1Ba7PB6dDtL8Ht0lHyF+7eGqaBBEKDhhwGkD1E1icAFONrqSPB0SIEqHI5WQCRypDGoJJPw2OWHCUQhqAIDLB/lGILeij7wWU80KqKJkQPwi5BCyTCCHYFK0jeooIKZCt+Nia45HLJloMDlLwem2b5sF5NBCjMbwXmgoQDW3BKhO8nidHL7SbKV8M+SwcOXNlsLC7ClpkX+iAChkFSEu5xad8O8gJohKIRGj3WBZvEnkdckmdMyr7WoA4wp/EUJe464ZH6MhzvkmZRbgU+YzO718CbLbZZnTbbbfRKaecQmeddRYTB5SX7r///tE2J554Is2fP58OPfRQmj17Nm299dY0ceLEbvWwAIxYpIz3ps5KewiNDUQnHFSwySWKzU0cMkd+nudeRy6aixyh4Jmaqzu8uB8IqkLYTVImQdExunJIEj0F7sa1fNS1OOcohbpc8sSqEY5IpIkJt4BDqiCTkOqQNASTBpSKcjRCRJo5v0z5XMgLRyXQ8ZPNqmTC5upLT1IHRQqpwh3OYgGnRCxATMSOG6ShwkTDGWEQlSo5qgRIfch6aDHEYEvIQaUC94pAdJzYvqTuo35AZS1REQMrycXwuTsLcphkBXHVDA+jrOQDG4AkaIMTjmCApKjLJzdNYwIHskeUa0Ppq0rJ8B60aVebb3FLRcWI9RSpR7z/dsYjuWHXUiGRocwS4Gtf+xovnwX82wTpwLIsYcQiZUx96f20h9DQwN0udcSOpyjD5Bv9Xs3SCh2pENVTsEcCvCqcWJNNozTFgUgF7qZxp6y9PlgzoYRC0h0qVsSWTk8BLYXTUKjlttyaa8qDXTRjHQXrIjgCIekNkAv5G+vgXhlQEbfxDHQmDSnPWgqJTkhKIyYWICRFpC1wEvFV4H3xqNhaWPkN2qD7QkRYzxAGqOJkclHyOJagP6aiD+GICebtiicGpdiWIx6ur4fmWLiiQyZ4nugJJMWPjLzQY0R0JRIl4YAGXDiVEDhjMSknlXb0TMbKKuZUvQdvgzRM4BrCKbGpQHhhqDe8/Wq2fxtDa5tuSAOo1c48K894CkRcNeFfoZMLniPdgaoQVH+o2ZIjFxVUJWiPCkQmSF01eXKLnCzFcttZdXPkAYZQMIdSYsE9vJq00sPpKVyLc0zQfuysCb0EyAQgUQroG0SgCSKEygzclEt0QogEFt4fV1lWROwYuXF7lHMaC9VOgIxwWoSrVWNSwREVdggPYhEn/qeaDARvPK9ClaBMHZUclQOfoxuRHiNKmQhhcBEZ7hVWFu2FhClEnImIBg8W5lm47ig5RQRIBuQqWaX9u3aFZSdOCDgrEMYKgcqjiEf7rUgHVennkivjswTDcR3YcHI+hWUTctYbPp41l2a++zENWXlA2kMxLCEsYpGyEYwhJWBCQR+QChYuP5AqENxayyyG+D2LNh254IgFJijoKti6W6pC8MhlkK7BFkgFRyPESdOZXrmJkfuEIErhRJlc3RHrKaL0B1dISpQCpaMudyLkokJFjmSUlVTE2okCiAS20SoOEAhHOtyp8zrWW6j2gjWUap6lW2rgQX0qVGPhoeoCxMJtJboLjRNQAZ4ZaOVRyVEpyJMPcy2OqsSRBPRFR5qEXT4REcE2IBlc/RFbh0ORCSEm6zw4HSXRC1GECP9iWojoBa4pylHLQoY8CEH5Pagk8ZG7Ia9NXD9jgyxlWqyjAdszMWc9/kZmlViEDdzd1IhFivjXX6xNevq9QKA/wATmekrkRNSXRwqESxsoKBQobC5wxQdHKjTdwboKrOObXzW0isgFXCJj8uBanXMbC/amSKRGkqZXiCSAMCihcFoKpDu4hJTFmWVqgWcEEwqkPqQCBOMHYSh4jljEGgt+zsRD7tIDFno6WqDRDpTZ8mwskQZEXvIeDKigpWAqwCmKsudTQYWcvJ0jFhoBcX3T80FIJbCoMq5bBb3boh9bpG5QVVIuo+15SGWwB5A1nuzjJmYEG3NcYgSUOlSvoi6jTA9QDYyUBz8XzwyUqSI1hbHh+oQq5uTIBEdLfPIg8lTCxMeBVkSJRXZ/znse7rv1cdru65tQJhE6sVQX3p9RGLFIEZ98UN1cxlAbxDbREAyiWZiG6AtFSXNomSn+9tDBtDkfu0GyzkIqQcqw63atz9WSWtIjzqJbrLk5aqFdTCvNAVFT3OELk7cICV11hEQqxDUTRSiwnMTkJ+kQmFMV/ICKqATRNAZSHVIBokUtnPqIfS2KXokFjRKZ0PQHqkU4ouE6hArJkOuDv+D/EDCJKoeY8IUQgHrkqUIl1GfAt0LXs4Y1xPa+aCpULJrzSlTwytTmFSgIIfjEuQVUYPdOnyooQ9VqlTCRosDngYoSSZ2g6sSnHPzLQCTUAwMEwm93TqB89hRCp4H3gtQVPfLbnaZFiJFcoJxEXbjc1ClGUW2jeR9D3WDOR/PSHoJhKWDEIiWgBA912oYUy0sB9a5g22e2gRbfBY5WYOHGY2rZDXmiigBRdaAqyKooBUcqEJLntudaduqcNFFmyiRDIxaY/NRtQvwppIQUFRbYdyTU5LLSChXhW4HnuNvH35hhWSIAjYVGI0AIuGxTog0FL6CmXFlaizsSoWkR3o6PH5MLvkZMHsToCnoFnxuyIb2j0YZCSOWgAmrCEQm+ptg28KkcoNOrz8ZWIAaiyZToSAccTcseFUHOQo/KFZyfXNdCPuTupayjRFTDtX1XQQpGj/3DBpwZQlkrRaBdKagsBVoL7ZbKZI0rSnyuGkEjM68EbwsRiPJ5IBQSViR1whEnfLgQ7xq5qBe887+ZVOqAk2z2pqrQxJuGWuOd/82gBZ+22YWvNZwpErfV1rt8CDaLRY1UCKngSQaEw1WBQFCI10IJzYuttNwpi7OmWnGrJbW0L3ciQ0x2EqlwkQmmE651OUcqpKLDCTPdXTsLK2GjnYMRlugamVhoukPIAXQVoq0AwcDkiIgFv85izoqkNFhS4EiEvJfX8x6cl4W8R9wz4YKBNIf0SOHUAtIumJt9yDkDaoa6ElmKsEAVL6CyH1BbOSeWHEwqVOiZ88n3ylyM0VbGvnwWa3KKxwsocMYe6ISKiyLdzlTfwa4YYqRVUq8MNsTSj5BFshrsALNAtUjZo1wHSAe8LbSnevRZablr3hffCxGd6I5Qjmrlp/WCjvYSvfnie9lsox7W1seinpA9GthD8Mozb6c9hIZF2N6uf+i/XIg3W5ol7ZEkF/kctzTniYgrEIRcQLDJAkztBcIGUYhiaNljJNbkCVo1FJwy4fIKV7upxEIqQBCVEGIhqQJ4UGA2bC6CVAhRQOUGpjwhBEIMsBT8MhWwjZIFkJMClaVqlatiy0w8ODoRkQsETVA9UlEPDJl7+QdB3TdxVy8RC6kAyWFbJFFCn3x4ZqD8NAcdBbwssA6LlM1CO8mRChALFl+W2by0rZyn5nyZOoIcp0xg7gV0lIS0MJmikMoll6KA9sN1i5Vfak6LoM08skTMOzSJw5mMkIkHxzi0FKYMzghvDG106pxMudoVkQyEjzhHo5+JiTjrCq8881Y2iUUDw4hFSrjvlsfTOnRjg8kEnBdLcnfq3DbRcAwVINozRJWRIlxE7w8mDtBUoDoEi1hPS8tzrQJR0iCai6iKUnp/SK1mdaQCOoqC9PJAqoO5CGsjcPiAivkKNSFagTt6TnnI3b0jF7z4ATXnSkwgWKyp5AICTiwgEXn924k3JRUSRytcRQnbOqjagmmIB6IgFSAgIa4aA4QhT0ivCPGQzukgHSrjxDhhD4K0CDuCVaglHzAB4dQOEfXOlSkHrUZQoBKTCnEM5XQHZzgqkhYByUH4I6/pD41chFodIn1WXPmKSCaQUiFEKqDN4OvuUdAhtuX8lD9e0YD4EHaqeFPCIEIejVzUD+695XHa/bvbUdYQWlWIodawNum1hbg8opFYWR7ZSAFiwYpYeJOWnxaLKhgEkUDFgpRYckkpk4y8TqSJag8WWyZcNHU9d+REmSjnBURDoXEMTon46AjK2gjXhR322xKpQNdRSROEHI1gm278jXUkhALEoNkvU9GrxKZYmiopEDQZFcpJ33BqUg1GLNQUrwvXDp2nWScoVeWFcwYts0hThZrkIWvDJwmqAuIhXE20GAEIAdazH0ZAlbDMfhQoPRV5Q0jFQokjHMwUytBaFJi4iOgTBACalhx5xYD7gMDvAkJNqdoRYob10FiwT4Wr5MB15DSN5rfV8wLEA/1bnAUYRzhg6c0plBy3Z3ct56VaSHubmNaiLlDJcgQppIaERSxSwnQzxqoptPuEzjgyiTCR4NyD9sLAI9aBQKCZGHtUuLtiCDbRaExTHdrSgterNwXLBKCncLoKtupWPYW+xnfXKJ9EuSiXlEpZKZtKcgWskgp10mTNgwo22UXTq7AYE6SCUyLQZECgyWkKhPNlbEUqU7NfEiLi7LnV1Jv9LjhiIdELF6lwpt4i54w7l6LQosKVITiNgIlGmfLUESDCI11EwUBQLYJdtFOeJ294WuA97UFB+5IUqJffwakMLt4IfCZNQb5EpUqeK0lQfsrZFCg4kGJxFuvc6EwbmWGYRY1usJumXHuWe+hnwUEMRJLQ3ZSJYcgeFznuVyL9VphAwLQMz5UccSMzHADRKtNa1AVmvvORNs/Lbvllo8GIRQqY+8l8mvvx/DQO3dCIu5diYoE/g5QPRBUguoRNBXHazMWpD45WNDkdhVp0c+tzEQhWsD6f6GTqTLCcVMDrZIhFGqFwqQnmNwE1FUoy4TOZSKY3sJSZQKDSQ9IdZV6P53lf/kZ6AZqLJsy2mrwAGQH50D7sEbHgqhLVO4rGwrlQSBTF3WwhoVHR93BkAuaYBKGokAzPz1NO7+6RJkF6BMQAnK0VhEEJD/w2EM1AiSl6fDC50Y6k2La9hN7oQmhEvIrrgL4jzmDMGWPpJIOUSEkHitJTvKYCWu414oiBZjrgmooohw8Cgc8X5bHwL4HDGO/TtXLVEJL1J6sLtC3ooA+mf0KDV8qWUVZoqRBDLTHt9Zl2wdMqM0VUAuQCUQv2qcDtrebV3cJdTaWawUUruJzB5fS5NCOOSvBztuYWcgEfihCVHdoC3ekmJHLhxJoyqaMCRJqISaSiKVdRIaYSAZ7jXAVIyHoKTKogClha/BLPq02aEpHIRkBFrRZxPTtQMSJ9RVEiIc6XeL+LUXCZpvQkjaM7qqnASGCIGWsvZBsQjqJXpmYqUWuYZ70E9lMMyzx5l1H1ATMtRGRCohZqp9agSco7sR17S0gFCkgKIt6cJuLmZtLILCjlpAU7NywRnwmnreDPAM85UKKVOaqHZVMtkIZCyK6dGA+ff0mapoWsL5H3Rh1QQUSc/sV5m1g6pC4w7fVZmSMWZFUhhlri2Uf/Zxe8hpCW4gmAPCBvr03GpEOWijaht9CSRK7wkAyCVBhw9YROxVpeCsIhqZG4CoTXc8VI0nlTupfCVTMHkyvt/8FTNfcDKbNPhXbYkPQH6ymkbJRTICAPHMmQaAQiG6jqQMqDiQa7awqxwPaixZBUB8SbEqlw5AJDd/QBEAVFbJOlaQi+bRdCIToLhFZk37hcTADwLAD5wfMy5XwoPKCTQHoEBh4gPGXy0KKVOqgNlMQrMJGoRO8nPf+AKogowLsidG7bUhJa6VCFiLZ+5+vO5aGSpiGXDsHnpsZl2C8qbphXQpOR97h5GetktKtrXKHjWtLqdVBiYQH49DHloZdpzHajKFvwuujjmt1vnqVCUsD82a1pHLZxkTTFcgtHIYrVLpvaD8R5HfCdOfL+SBMogeDGVjypqTEWCIMrKlB9AqdJlGhIyEAnPS4p1ZQM0hYwvuIgCaom0PNDSkUxpXO3UtVZgCQweVDNBaIamNhxrBa/g5pYyFmu7hfiJn9239R9IUqh60A2nKW3DF3SH4CYT2rTMLaT4BExiSjziWD/jmhIJKCiVuJcYkohdYQQa+akIiVXojKLNxGtkT23gn1xZMCnQJ018VGAWLQz2UBHVEmh8LGRbmmqsBCUa1lBCvDB8OeghK/iCIFapUObC56olS3s5glDLacBdeWnyi+cNXs0H4BMZlg32NPSIYbswIhFCnjvrQ/SOGzjAkl6TtTrHa6aZMW+FdoXBDqKvJaRqikW+1M0o3eIpDki/wrMiVGDsXiRO+ogtuh2VSDOqyLqKqqGVNBM8J060gbSmdQRCkQmWjhKIaTBlZiCHEBT0eJ1UEuuFL0X3hUuS4CajVyi/BQpCy431ZqPgpacsnV43OFDxstBAY5NcIko9wjhslQhEUjloN5EJAl4d0BN7EPuUXvFU8FoSfbBxSXifcGeGVGjsxK1arsOJhVI1cDYS0Ynig7+yFDBk2dSxakSOHSC+XCGyaWmAgorqPqQaIbL3zARRLoKI8Cjy6aUPW5mBoLBegsW4IquQspQlSU6Twuz+U4d07P4mxmaQZahhnjXNBY1hbRFF0MnnuaRP2fVf0XSIU6sx7F90O2cRC7gVQHxJkpNOcXh7Lu1FboTaXLkQkPvEGxil0w6RLzJEzV6gLBXg7Y+59bkPuX8khIOJ610UQr4U4i2grUUcN5kCaUYXrWgBwfcNkFUpMenRDz0FpsjFgjKUJkKXomaUPqpZaAuJcLiSaqw14MjOoDEIiTNAYLkiIVQEewTJaUV6qCcRDC4xBOlpTluUAbgeM2+T/ODgForRRWPytg4NcMt3z02BcM1gRU4qjzaQiURuTKVwjzbbvO10lJdLmlFuAHCCdwWsS5CKjiYIDjvMbX1ZlEnW3irkRk+DKRJUPGj0QrlJ9KsDCEkUWrIlwefOes6DGni3ddnZe8DCI1YGGoE+N7PmPaxXe9aIRJtIscud8yIXoTQUoBsgGQgcuGqAZDywNSiTpuoCIE7o5MzssQimpCwjYo2XaUIZARuO9VW8FyrPT1ciSlXfUAfURBXTEQnQAw4RcK+E5IaQSpBquzEw8K9FvlfqAiTCUlUAYIIB/p9qLU3RyxArMqR66ZYd7v9gzw4QabzsoirRGJigeEFVPbQxMtFNULq8ArcnRQpDIwFpa7cjIy1HbDr7mDdBLbNQ6hJOWoL0PANnwfm7hIhOcjbqxMol7Vy51P4TTgPCiE/FbRG56iRuHLyx6tCWjEZ08+e+YFqYxIEgs8vpzoOjVYwGYFAt5TQXQBcjtzFpg+GLuOjmXNowbw26tWn2a5mBmCpkBrj3TdnmTlWLUWbmgaRqpCAAhhk8Z2EWlzjOapESFMhKEPkEgncGUu0wll0u8mJu5QqaeDjODEnnKNcWiRBQtgYi228xadCtBUVKhYqSjhEayFiTBAPkAw4U0oliIgspdV4b3bZ1HRJ5G0hgk3ED1BmKikQFXBycKXCUQYu4wzhxilTNCIgqB5hpYS6cEYdQ7TpGCBqDolyiJOlrCuyDBRNvirqZ1GSZl5KKqCTYE0HNLJBB7UFBWoP8oQkCcYunVFBPLT/iS/VKs6fG6W3EHnC+0u8zDxx84SmQkUioqWVstRIa6HVPKKbEM0LF+GozTqXpELECYLCqQ8VfCLtg8gSNByuj0xUemrEIm2gaeN6m61GmUFobdMNNcIns6xVeq0g7chVP4AJDxMRIhSqp4isu9lwCf4VMExCZYhELsSmWzQXke4CYXpoLRBO18oDZ5bFlpSOcGinUenxLX1AXE8OJgE5cb4Ul0ghBxJdEEMnpDI4/cGEQchGH7+NmrlFunTgjCIPTA5CiWRoDxCnxcB+4tSIajz4vU4kWkUnokiFS4+InDKuGEEVBwCLrEC7mGLsHG3gqhhJxvB5qp14JURapMJkoA3xCnQFQ9dRvI/zIAXq8PIUgNz4MLEKqQQbcYw3cgeFMyc6p0qVR6DCTU6F4KKLDzhXeqg9R2TfzYv2dBHiJyQEBJEjNNyiHWkZjyp5n3JIkbkdaLWQmGip4tWQCuZ+nK0W6qF1NzXUCrM//NQudhqmWMiTw5QpUQGCCcaLnDdF1ijtIkAgxOOCJyTM1lHZqBdPTtr+XHQX2s00F6/j7fIh5Qva5pzbnwvpQMdShP1dWSkmTkQxMOnCWRMiQgCGWHFJqRpguWgFG09pMzJoKUhSHqAB7nWkJdjXQgpAo1SBZGrcXbjz3UxEYDSuIRbdTl8htt8F7NmTqESJj61kQ6st2tmlM0dFTrHkqMLbIvJTojK1Uwdkpl6OyUO5XGBux+kTbINUC5qZ4WPj61KhNrY4RVpESBmnNNjDAkPEfvU8cM3LMnK4eHLhCQs+xbkdUQlx8RRnTqS7fI5K4TqKjTeeczqLu9+6nJezDDdSkSY++TBbxKKRYamQGuPjWUYsaoXIwptNsXJSDZLLCbnQEDeHwjG5SK2mTCB6Z8siTd0Rk42oM2acrI/THZqKd43EuEwTRMLNR9IinMWYIBia9pBFPChANFBK2uJJJYgrGW3yOqiZfSDEYpvFlWqQhdcLVIrIBt4HHQRewfTOPUM4VSKdSd3UKNoGJ0qUVIc7FYlb6Plhcua5OCYdZU6BSBQBUQpu2+6VqaQUgwkKB4IQ4ZDUBkcxvLwQHxAID03KhEAgwlLwUYFS4f1iXDgXrupA/QiTBKRcpNSDIzx56DdhE54QVnIDMZhewTVVgkXyeWgjs0BSJXi/7CrxHUBEIvnNSQSdHNm03iHp4pMPMhbtDU28aagRMvePI8tICu5wW5zPkcfkIi/pEJ79WPgQm2Kpbg/tt13+XpwaterA9fuIZ+G4YynAt8tKLnRi5IVJgTxyeJ/9FnCjLBUijiiAcIiAU0mHumiiyZgjElxCyo8gH2rpDW0FIhKhIxwlnsS5rJQLKNSy2pWWaimqOw1xrdBLFf0mOjrh0h+imxAeBSIhowGx4ZExExDvieagTG2qlpReJHkhDH5ATUGJSigxZfJQIi/IURDmqZk7nhK1cgYiz7vqQDolJyWmIARcaqrkhdM4IBJcNyoVIE5YG7VWc3bqqo3hj4zlNuqWqhzRaTWdKJc7nvIF0Rdi/a4hJWQujRyaxsJQI7zy9Ft2rdNw2+SoOTQU6raJ9AhSIq5vhN7ZukZUrr9EVAXidufaoSdSChKjT5ANvdPnu2flLi5qwVOskgl2dUSDMI5aSFUIEwYnSAxxJy8CzEiboQQE+gnubMqpEWlAFhOUCq+XKhE9jpILF3tIRizixmSJqgmdmh0VEc2mlF7KZXB6EJSx5jmtgTHp0PkNTYhthB6VyOPIiVSh5KjDz1FzWI4mb6RV2FWbIy3YG1IwWjgbSuQF4lI3Ur6mLqKgDqiuuStHmhIEKvqc9PNks023nVTKxoQh+vz0s1S/DPnwJPVlyZD08MrTb6d4dMOSwFIhNUbr/PZaH7IxoW3Sk4+cCinkI2Ms6RMSO21yl1LX/hyx+Zz+C+GeH66bqT4mFqkGEa+FiHhAfKhOmXxnrZEDRCsiJ0yNtUsqISneFG8GMbISsSYTHp3QWTvBhlfaKlyjGqjOgAajmDTHYl1FXNXhUh/cTCxh6Z2s0kxGK2SOFt0Cj5TLRtU0UzdGdASUCKWkIiqV8wVFaPaQIAmoVTukso8Eohx+hb0roG1x6RC8BiKEcylp+AHnEai1OZ6za2giCoTn7O6hLdV5K0SVSmq17izZtbjDtbl3wjquGNFCEudewWkvjnZoDxm8AubTYTacaaJ1QRtlCZ4jv114f1ZhxKLGCFA3Z1jmQHQi6OiIyQV3wJS23twPpKqLJbwoPDXFkm6m3NmUdRJa0sjhcU19cJMxFQU6UaezhFaCIWkQqf7AAkLBJaZoi86aCgg6oasQcylELCRawQ4Q/NiUgwmWlIpyuah01WBSEZWbRvfRIgJtSpAKEWvGbpucikhEKADhQa6duiCOVIj9NU+6WmLq0gxOkSD7YzUFB20qiEggURKKKVZZvS0QvUBqBAWlEJl6Xpm3Q0GqVKrE4k/2H/Nz/OPEzcI8j4q5MhMRjtwkfnCl3YdU68ROnLqEOkAH7mwae1swWUM5MT5LDUnxueNvzGFsmAYb8oTvt/lZpIYgayW/prEw1AqffGDizVqAJwf2owjiiAV3vYIJRVkcNzVGzm6Lju+5XLzzN9C0RjItwul2F5lwUo2kkNOlT3h/4mHB7pqaGuHIg5+w99ZqAxZsKpGAGJK7lXLqBCkEpBokOiF6Cqe10MZiIVER0QEmEq7dupTZOq0pJm0paomJhERGFo5YiKRAJlKXDRCPivhVzUTodfMoj1QGUhiavsBnIMRHWsDnPJAF1WGExFqLCrQUHH2Aw6aMuwP9RtQq3FWr8PWrqPW5q1thLws3uPgkJO2BKh3tUJuQwCTFtu7zls9XdBUcvWIRaCLfxY+6k4zNbT0JmfvtDE1jYagByqUKfTp7gV3rGgOEgv0rXPy7XBE7b3XcdJoKnkRdpQC3Qnc70MdkszFXARKHALR6xD2HSDN6m0TqVVvB0QKddEXbIF4VPFGrhgJlpi5EL+RASIgrVGFnTvG35Pc2+e1UdJWwLlWgOghn4y1UKiYSLqURVYokHiVBk3ThjPuCwEKC94N0T5KUcF8wFY/ymEEwUK6ao0pYUFIjAlOQG6nsRJlpbMoFAyzp4YbzdekaGQciPK55mhuXyB9is6xIXoGd4DLjBNUTzWl1qwiCKyHWVBNnnVik63MbdXcwadVuzCJNtLd20PxP26j3cua+We+wVEgN8fEHcxYpKjR0L/gaw1GTCYVoLMJySfLlXGeImD330KbQy2nnUiUY3ItC3DZdgzG58UD/CsnbO3IhREMSqVJ54OzD0RdE0hpCIqTpOFIhjiC4OCnKQDkCgRbq/H7RYThthYvCO20F9gNCwVF+dBnVUs8i14S6dEeStAgZYUsN1ihoJCIiF4gA6HXT5/K36xQqr8k2KO8U5SSqZjgg5OZ13SEIEWlKpMzsK8fiTRmTazIGQadET3Ce5TDPpaPsS6E6CghNWWXBl0nG7ZxGIfHkdRqZcQOISIX2aOF+Iglix0JPTeVEDVw79QuRaIdWhURCErdf2IDHBMxQe3w8a052iEVo5aaGGmD+HGuXXgtIqsIZX4nZlUz4CbdNF04oaKkpZl/0igCpSDQVE7GflJmqrWUk6mR9BYsCdCJLLNwTJAe/BfWyQBdT9qoQ34oC23oj0lDhZmNIe0C0yPoLLiPVlEikr4CFNtIj8KzAOiEZPqdMpEwzEmO61EfV4nqBRMkLhpye89iMIRGEuLoCAJmQ6yuupJHewKV9NNUCssMNxnhVTgSY6qnBRlkJESqOzR4bWqqKvxGpQOO0dtARLc/1KxByYv/ccUQrQ6CrkL4rYVkqe1z1iuhAEB2prvCRShBtrubCNvi8+GJIN1sfmhtuHqfpsIiZuFCJOXCmhbkfzSdanbKB0IiFoQYol0y4WStw2L6QpyCosIbCR3mps6nm/8cJeXfTGyRfi4QFuj/3Xw54JKZg1YXGt+3RCNSMSZ7JhIh7cGejHQsoI7Gkpkm4EEErHjQzE1WSyDwo/hasu+DeILIuaoseRS5UCMmm166aQ888obeIzy86pWSmQKWhMtHGwkmJhDDZiPiFXEvx3axwpIK9KrQ/CSImWKQ4Vs+eoxY+ldk8S3IR+F/Jy3M5rXRYFZcu8QHRwBMiS1r6mst5VEZXWRdeUe8R/vhUxCk239KVFq3Xxa9dLoL4ieiFZldWbSWPA6FRnRP6RkTDYhZpIYBeylD3sFRIDdHRjgCwYVkjeeftFQraIwKOm+pX4cypoly92jazOFCUmJyVgCmTToB8d+sIAWsP405XLGp0t+wJ06vopp5vcDW1gAlPSYWYZel2GiFwployTau2QuynRISp6QcJJmC06q8Q2XRHN+E88ecTpAJ7lPJTRAli7UB1XCKWIEjaREpNObuAxmR6xbRDB4tIueSWt5GyWGlwJj8uTsAJcDQD7dWRmmLC4TE5cHoQFmQywYN4U8WuskvtsyJkIfqQI+2mGpA5Dwps5wyvHIGTEEu1ns75g7i/cRwegHtzYl/8JZAUlNGK9NDRXqbMILSIhaEGMGJRY7g7zUJBHDfR/4PtvJ0moLqagJG4IZIJRcPejoS4bTlZH6s6pWJCWIcLn8vbXNRC3SHQ8EoHEB/akRD0q5AupMmqDG68lSgh9TqlHrh1eIJcCCGRQbjAi6RCkE5wxEbJlLsL7wQ/QXbYx4q9MOSgjnjgvHJag5tMm0Dz6HdqbOaqSiT1AgGoaEKcd0Sk7PCEVLgma6xT0WO7UtfIEZRTXTFJA1nBxYpiMI5oOFeshOhTmpLFuoxIuJmMRkUOnuqF0ln4aag5Slm6OQsbtyqkOuFqWKYoZYlt9yCI0VGOzbHguIlqEA6vu9vf6A5Wpi2OkieqDGP7yU4ljZQkDMnqkYRvpRMWRpUaYjXlhJYyKeoExnf+LoYQT8qIBCAy4BIIsm2nSIP2wEg6aLoohUvXsAAzUi1WRfijaIj7OyJG0SUSkacjKJxKiey9Zd8S4UjyNe1t0un8XbomvqzShA1nF/tvxO6eXK0TGW916umhFz3SQkRd1/WkI1Vmp3LgKIWjpGUhM6M4xRO3TI8+dENKyFTEooFhqZAa4sMZc2p5uMZFZKvozLFw149eIQV23HSum85hMRmxFFMlycVH+QQ3MSWmMm2sqR1N9W9XXqqijdhxU3pkRH4Uvps4HVGQu3IRM0K4KU6cTkchEQfRV7iJN8dtxV3f0Vi3wYmEKm8K1QtwFQeiAa46MxG56BS0+YyLKgQtRAojdvCsDvgINRCyEb8mRRoqpuTXgshinNcikoSAUnQtQFzEMlOLMcTyGyoVneST17aKEeCzcB8SC0LcSN1ZJKJVEN1q6CKKmKhXh/AOJTTQWvAGGrUwcpEaZkz7iLICz5w3DbVAc6+iXegagCtBXAqjqrw3ttx2xlhMKzBrwW1THyXHnkjmY1voLpuqSy1cOH2hYwce5Qpx8QmqPxyBiWc99MzypWSUy0vlEWWjcbIhHjcfXitFsDjnTeeo6e7yWd/AKZKYOESpkChHkxhvcuzx9BrrQxJj0VhFIgKBYzm9hUtdxB4fEmmp6HWKSzzbYYDVaXbG+Ve0fTyuXwgtBms6qg28nC4FnEADP/x3OTl+d1IJ++5kp9K47Yiem3qZ4PNnjYXbtlRhMha9gU9cS5YNqaBPv17ZufJh42osGi4VcsUVV9Cqq65Kzc3NtMUWW9ATTzxRs2NnKj+YcUh6vdO/TBf+TmorACfW0zfyarZjgMgzTjmE8EVIRMh5c81sxAdVcyltpOHiIZjoXQlmJDjkQ7togqY/nJ6gKvPixebZrucIV17EWofkCYSJMlL075D5NU5bxGJO0Wf4+j9HHNyzaJuIVCQFolLhweWiPJkL0YguK0dUdHFeGpFOI0rSRAQmWSkj8z2EnC4PoxEgl3JKxI64rJQDUwvHW5JrnCaleju9cGyE1emrAlFpIo0SD/Tzv3eGZQv7Dc0GGopY3HzzzTRhwgQ644wz6Omnn6aNNtqIxo8fT7NmzarJ8TvaLD+Y1o1CLNhzQkApY8RjtEHyTh4TWWQZ7XpScMlCdS5eb3pd9iWe5NUaOp5peS27Vnaar1g1EFanCbhiwu0/8sGUO3gRcLqJON5ZPDHrBK7DZ5qgopB46I4GxKdRvcTlldWkwlWZ6LsdV1vElU+Ox/UXiaIxShb4f0qU3Ksi6nQ0J06pSBZEzLKi9FQkGo0JGa9KGlsldJyOnLjqIP48k/tjAqhfCS5FTUpQDWnDNBbZQEMRi4suuoi+//3v08EHH0zrrrsuXX311dSrVy+65pprFtq2vb2d5s6dW7V0FVYVUmMs5DfgJSIUOlFEakW5S42JgE6mnaMZyfRHJGxMhNoTJIJ9LIK4V4erEnHRDNFhyB4Q9pdMjdNM6LTsiEgkCNWIRNQDxE3GC0cX3DDjKEmCSrgJtyplEiU7dJNOkR3dh0uz8KVcRETDBYWc/4b0C4lFlq4UV0hJovxWrlpEKqSPipbYKqlw2/BUz6JOHWsyc+X8qxJaS66E7fz9iLQV0VujD5evf3RBkx4ZhjTR0daRmQ/AS+gslmqh7KJhiEVHRwdNmTKFxo0bF63zfZ+fT548eaHtzznnHOrXr1+0DB8+vMtjmPXux13eh2EJkaz8cKFsyUHEzpoJAhJPLjrBRErNxC4pcUccGWTFe4h2F6U14klVeIQQBqn00Dtyz3MO1HHcPnEfniyDFCMvFaUmTtX1HI2ogqvSWCiO0FlYpooHLZtI1Fl0CkI4whG/5IhRZAUepTViS3GRaEb1t1rl4S5hcp/xGURMKTLCqvb/EC8Pt0/1EUmYdUVD1gMloxJ6EaPPTj5i9a9QYav0HlFC5Iig7s9iF+lhxjvZEW+SC411ZckoGoZYfPjhh1SpVGjIkCFV6/F8xowZC21/yimn0Jw5c6Jl2rRpXR7DkOEDu7wPwxIiimvrLBhFGzzxLVC3KZ4uIl1jPAPx1K3t0qNd4j+JfiFVUYDIt0L0Cy5K4e6eHV3gRleR5FHARQpV20p6hPeZmBnZcEon1eT740JV/W+iIWdMBmJPiPh3S/fidB7xWcYpggRBqroO+pdrWObSOI5aSNsy13RFJ/PIfyKxT36OipOEskNTSRJQiiiWPBfHMj18whEzwSN5F66go5qvRZ9fFG1BJ9SovNZRK034uP4yzvXR3B9Tw7ARg9I7uGGxYeWmn4GmpiZeuhPFJrvcNcWixJtANIO4W1ZpgxlZecvGManotIukQZV7iDwS5AD6ICmNoJP+gidGFRKK02QsTIxiGJ3C+WJtjXfLPX2g+3VVGG5MjgC4FIO8Q0+DRaKxNiI6S/Xv6HwrnlznCAqnH5KRkOiu39WSxOmiWOqQpDuOeGi6xF0bV23CjpyyrVw3uR4uRRQTw7gsNHE6VemPiFygkiThxqlvVzvvOIflzqt6j+7iYlyuQ24ggg94oxhqimJzPttiryVBhkNjDROxWGGFFSiXy9HMmTOr1uP50KFDazKGQlOhJsdpdHSSBXR60fXKUHdHLR1kA8kohaGTu/YoZzMonk+EaCwUoUxE+ZNJFeEubraSV7gyIhGCx4KqiYgYaH8R1iLwbmJnJxfjYPKhk3M8ncdnHtmGO1LinDGrshux7oFfT4wnej0iZonkiAomkxEKPdtIXOoySUKmJGyQjII44hSbV6kJViLdEdfTxI9xwCmucEnSiCimk2x3r9eeAxwaBakS34JcRB8g6oPj8SdTK46xhLD1xoLxVlAEbKglMvUbGnbDklE0DLEoFos0ZswYmjRpUlVDGzwfO3ZsbcZgEYuaQeaTTlMu2mEncxKJtEhynfQWWThn7yFXUW0D0SlS4Y4Fr4XEODCxqXNkpD5QdgIvCtFcyOJKLDtHIKJIRRTlcH07En6eauqE7TDlwTa7rCSgHCdIEv+Tu3nRQMj/4r/dUd2iugbsV1MfeKxoGimpcY0uuL6Pm465axt7j0ZRH9eroxL4fH6OXMR6ixhSsioRBo6+aOSpaisNpyQJIF/PqJKm08ba1CwigEw2khqURNgGx0qEoEAyDLWD/YZmAxmKK3UdKDU96KCDaNNNN6XNN9+cLrnkEpo/fz5XidQCVhVSG0R32gulQtzsK0I93HGimTeVpWSAO1zyrXCnfxZ4C6Legc7YLpOSrDSI5hoxcKoEi6i86FSlAvEm2oiX4JngYxrNUUdYpj6R82N8t47gSSXMxZER9Z9Au3W3jThbwpJc1BaOykjpatyzI/6jU9ogoXmIgiydDMaiaIuyAkc+IhLiSI+mMEphjspYyIetV0QchFy5CI2wqFLo8bal0OcqmbiE15ExHWuI6+vxxxb5WSUzF264auvtQRWLzy1wjeWS3wf9G2SiHJCHRXfqbMQjBqQH4fXaeyZqTOaYpGGZ4tPZCzJzhT1z3mwM7LPPPvTBBx/Q6aefzoLNjTfemCZOnLiQoHNZYfnBfWtynIaHm8D1hx/gO8tSSYV4OQorefKai3K/r3fNrFnAD0JFxJWiceBOW5F/hUvJR14JukSRC3Z6rFZ247lMhHFJJzhMJVk3gQZkXO2AiTUXu2mSTwWqiEun9tPgdAMPyRllu0gEnzRHR7hxWJRAESdO0Uw4rcbCcdYkyYjn6c5pkph4iB6k2j+iOoWBY0vTNyE38WsgSSAaOK+IdDglBa6FFslCyoDrxkvoR8vC6vkwQR5UlFtxTV86lfBJ2EW2d0sg4lneBpxBtSTMEJML2AxHtCL/drkeql8xLFsMWyVDAviwcTUWDRWxAI444ghe0kAxS/nBnhbBQD5cb8P5DrOoXs9uG00LSBv0qsalixRsuJv+SGjpJiJ+0Vso5aGxhKj1t4g63USqxkxqx53UFoio0+MJOC7e9EVIWFVponbiC2kmYsFm3EnU3XnLCbrXqs4tIgvVBfXRdkmzsWTqKfFjGJETJhVOfimPEkMBMZKdOVIXXzf1zIgiL+5aJfUl8QJ5BDqwOjVHrEvp9PscSVaq+5z4zsPEpTi0yRqPNQqdJM4qaRlvhKJmyJTGooHRcMQiTRixqDHchFAqcdqDJ2lW8xfkDjMpzovy6/HTqskyCsPrXMIMIJp+E6QCE6CSmIRthgvn61Hi1EkViajIBKmRAC4r1TbrrFPA306voSQIEz1ss5MGohwpiLqnyiSdTIU4S243kE42HQy3LkxqJQLpWZL05XD6ikjlEPUKUUtuJmoiBHW6ELdeOpHGUQysQ+yCzcqjyhJXXuuutyyuXXzkvcGPvGWnc/Hks0r6jEbK1rATiYxqYKN1ruts4ksSl/Aaqag5MqWxCC1iYagBMvWPIsNI+haE5bKkQyqBTMi+lAjKnJq8+xQLZ/dGmacSVtYIerg75UTXTL67jaIaMllxE61coulYVH0qk31VqoC3VQmmGmdFEQMlFYEHo2+kOOQ1Z2mNvzHRo7VdbDiVkFCoAlF6iriSTYkOyFhi4WRnuNQGizb1eiCrALGmE3OCAsCinDMJevw4SuEIkupMHLlgkgQNhZAAiQ4kqkk4uoLPKi/XRgmQE23KuJIN3RI6DV6XEF7G7DBKxwiR0PexSNN9B+Q/YvUu44LWQnxOEmGrpI5T2ZwlQGqHLN2ceaaxMNQCuYLVvdcKHKaHpqISUAhSUS6TV5BG3aLpi/tSOFIRRcLVwCqedqLkQVQV4jpmuopJ0VUkUisq/HPRiYBTF0oZolC+m5gk4oCJNPChx5AeJtBlQBshE7loEfJehSdhTMwSG8E9fsDbu0hEgbUaCTFIor4SZMBxIHdsNBOL/b7krHFMV0lSnQqR17AfBH84kqIGXmXtb8LjQ8Mo6ChYiCnEyIk5WdgZ6TGE6JS1IoQ1kSo+lehIpICVtIgKNuNokBPjVhMJTnU44yzHATTP5Lge91RR365khCmu/qjaaeRnsdB3zchFzcACa0Pdw26ha4i+/XvX8nANC3cn7JT9UR4c4jtMFhrB4A1LFW6VjmoAjlhghq3kWNwX36ei0sOjAIK/XKIyhLdNdLhy4Hy/kISy+nTDPr4UoBmYS3JA1uhRuyfxBNyR431oNV5WAaeb5fAASlSmArXxZNnB+8nrnX07edTklXkISItEpZ86NJe+KEgsoColgzEgkpMkOUkxKAiEm1pF7yCEA6QiqgbRv6NyWE8IBFe8UC46n7awyE3fcf5uPRZs1xEWqBTmeX1HkKP2Sp5KQY4/qo6Kx9cOos0SPrqyT5WKJ0sgjxJOSYoxPQorRD4+M7foa57U4hIume/CLR1xZIsJBTMrJ9qsyKL+FcloRfI7Z1PeskffARn6DQ27aMudYUtvIxY1RP8V+mi4O8Ny3wyArzFcEXMV8jDB4A44n9ecuHb6zBfIy+XkZr4cUphXzYXnUY5Jh199Z4xJWysOkuUTvH8XvYhyGL7eWTudhIT9oVEIfEz8TpaJSR3lmNAvVCj0VGPBE22Ocpx2QDRCIgOuqXmJfIInLCbV0MP7RczZy0f5qk726mrptApx99C4YyhXwkTkJTa9ciJKZ6wlglCZl7GzskYlkAaJTLFcIzWQpcCntqAgUQqcG6IZ3LeVe7fquUhqCecKciEdTYWYIGIDIhJicXJTjvpIA3hJd7j0EK61VomIWYVoLxKpi6giBJUfWiLsuKDwOY+Jo+8qfxAp4rbpTqCpXdB4nbMkd6ZaqiMxAWdNMHBIP8oMQtNYGGqAXD5Hyy3fi+Z+PN+ud62AuQEEwvfFKZFJRY57Q0jpqR/5Fkj/EBZTcMlplQBBZ1cmEhpGj2bb/MLiTkxGyUg6u0BXPApyHObQSgg1xeJ0hptsfXEEpRwVvDIVtPJEJlEVWnpE7UGeyl6O8mHA6ZEwLFI+bKOCagyEVOAYUj3i0hcyJVdXS8SWUwIZnYtYJKsvnElWsmxUx5YgG21BkcqUl9JQRCS4VDQvpCHa3p0vcYSC+4loaiUiITyXx4JNSZUkHDfc6+qD4TJNUVoD5b3uswPhcC5iiWwGk3zsU0uGcd2YUMDvwh2K+40kPNmtGiQVNLUUqaV397ZZWJbwTGNhqBUGDOprxKIGiCJDiFyoRzPfVOZ88nL5KpUhNBhJp00WagaJ9ECVB4LqDjT2j7C6WmPo/qrz9dGdvHpYoFMnSA1PkjyBxtbZIAs8QasTZzGosAGWhztyrQKBsgImUlLAEPC20FmAgJSoQH6oORw3Vm52JmdSjvqpueZmzkwsFqkmT8HpHNzpythiYaarWIl0FSGSNDI21lVAdOqIExtgifEVtBjiXeFJ2gNpkECMsUAcoLdwhCvR/5WJBpMzLBwpQrojbm4WkThsDQ5ZTq4XIWaVnbdDJZByUxV5JkpSIvoV+iB8cjWSAeoocmFY5lh+0HIWGcoILBVi6JGAwyLSHwn7RpkiqtYpmcj75JVAPMREmulAEUQAqRKpWnDVHo5MOLARlU5YnCbRzp2BL9N5UBFnBdYfYPKvVKjA4QRNTXBgxKdykCMUrPhsjiUGTW1hnoqYzPiAiGFIuqIjzEd9UVl/4ZV18g45TZK0BHV6izARWHFEw5WTJlMj/J4kudD3JyMVIAZSuxH3BwFhYOKgzeCxtoIoBRMhIUOS9sgzqWCHTSYVEsmQMlo1zQIJAcGoCMlgfYU+D1h3oSkQjvjI5+Jr1MEZmeGRUxu4fO5k9MQ4IsTb6XUQ9Sh5XOKCz9uxxk7fKQh6sU1nY6xl+UU2RMgcfwstFWKoEfr072XXuhbgmZKbQEQLUiIoPxVBJ5pJVYR8FPPk5X2eiKSCg8gvoZIE0sa4UgATP1ctQD/hWqnjedmjIB/3o5DQOe6+MQTtXap9QDApckoC+oswQIyBIwjQFCCtEdthix6ipFoL3H7L4SRCweTC6+DzwOQNO2xoGTjaQWUhJBql4CGptlHOx3VPVR8HXY9xiSlUdRCAbbgTdh7RGLViBaSiPRSS4Gy7JbURMIHAWBG9YJ8y1UpgHyJQdeslgiGpDyENrqJElhxVKm7fsVEWnw2TCnVH1b/xmSS1FcrlOIrBi0Y0eCkhYiGOqxy5YIJSISqraDP5iO8UlkSkwlw3a4M+fTP22xl+RoRsCd6fVZjBfY2x9sYjan3IhsSixHRs6w31PyaIUoUrQZhwoBIgMm5wTabkTtbd7Ua70/x8ZO3NO+5U7siiTqkYYU8LDdu7JATuvuN23zKZ4s4cC0iD0xUIgYCI0XlVyiTL24Y+tQYFWhA2U1tYoA7Kc1UF7yvMUSsmdI0kVFQ86qILZSycQokXXofj6d/J10R8GUcoWHvhYQwgFD4fC4QCY8YYOrh6RcbW7rQWiDIkXD6dQDN2HxUhJ68PcM4xGXOW6MLYwuprWuXulfSa0JbqCRv22E9EPp+YeCQ+90DJhUuHJHves2dJp++VCTdrhrVH22/nkuDcc8/l38FjjjkmWtfW1kaHH344DRw4kPr06UN77733Qh2/uwNGLFLIExpqhOQkwKWEFRFwImrBkQtELRAGRymhGiKp6p+9FFhQoBbcKv6T8kRXKVAdAWBoJIPnMvVckOoSbQquUQvn/iiVETKpssZA0y5MAEA0UGGBaECQp7YgrzoMpz8QXQIWTN5CBHzWLbSFTTQ/aKG2IL7LZ20DL7JfFw3AOo546HNpBpaIGCiRce93EQsch48RNvPf4qkh+wchYh0FyIMmbtqDAkcvQBJaUU6KbeDdwcRCGrd18DVwNSxxhIS9PaKKD22GxlU6sTJECITr66LCTWdwhaZtqt3VHrfyqL4ZzpxEBJ5KNhI6nCpjrGRVV+bi89nF8oMy1msp7IZlKfHkk0/Sr3/9a9pwww2r1h977LF055130q233koPPfQQTZ8+nfbaay/qbpjGosawRmS1g/MbQKRCHDgxy1fYj4K7UTKREF8LTCTJztkSVtdQhTNMUnLhtq1SO7pGZG5ycyWocYMO7XiKP7QpGRtX6A7YCTNHCzBp5ooUBmUKvTLl8wF1hE3khR3UjLgBdzMVMaRzqmSdRyiW5YhcSE2JeGNKKSfFTcidW2SCCynlSZyOsxgXSHpFLgyqTPAIAlDhUld10qQ8p3YCTYtwR1MXhVDnUNAFvK/EOgshSyVUt4Q+v2dBUKBKkGMthRN6cgQm8qzQa+i8MypKEZyttzPFSv4o++pZAa+LKMqkZyN5nqoqEXhY+IhgOZ+ThPgz3shdQyMVtcTygzN2Uxamo7GYN28e7b///vTb3/6Wzj777Gj9nDlz6Pe//z3ddNNNtOOOO/K6a6+9ltZZZx167LHHaMstt6TugkUsUvCyMNQOLO5TW29oKgKeMDA5SxqEIxb8mnNx0NQIk5GKhMqdftKRDa3B5IlJX8PE5R7ZXCsyZPKoXPKpBFMnFh7KRNhRLrBgE4s4bbrXC9RWwQQrLKW9kqPWco4+LTWziNFFJFqDPLXCcIoncF/NpTBBF2K3SxVT4rXWoInTEzKZI90A0ykXqZAF0QP3t4gxZZ1s6/N728MitQZF3qcTZLrjwQALVSFSaprjstPWEOeT5zGzaDPwaE6pmQ2wuAQ31H1XihQEeT4fuRbYNq9Ew+cFGgs852tZYhey+FqzbgLPofz0Ep+Xy72E5HMZsa7jzy4kHykxNsSKm49JP3Y1LXFpEO2S2/m7Zagdll8hY8SimzB37tyqpb29/XO3R6pj1113pXHjxlWtnzJlCpVKpar1o0aNolVWWYUmT55M3QmLWNQYAwZnyOAl44j0D9z/QYPfUgspCzteaVSiVJGQOBqUsdVzQH7Bl4nKifTU6juHSatDTajUOwm7KrNSMrY5YGipaIBqA79CMNrkybgSUsn3yUclCqdEtJem3nGzQVSlmfJ+hQocpQhoXlAUAy8v4IWdN9XeG7MlJv4mDqmIxTj2zakFGGp5+K+U3jrPDLyCluySVJEzFLtzFWiyxkNexTr+r/bSgAmWBHZcC3QtN+W/nYU3Lp+mSDRdMw9RCZAgrRTBY7uWmjKhUXIj3V+lZboYY2lPEDxnQywlFq4TKg9a0iC5ZEUI3DVL7JUm17Ycshsnp0UQsWJCIqQD60A0xJUVH6gKNpl4alv0ZJTC9SWp+Te7MZEp103qPh+L4cOHV60/44wz6Mwzz1zke/785z/T008/zamQzpgxYwYVi0Xq379/1fohQ4bwa90JIxY1xsqrDaZc3qcK7ooMyxTisJnXelB1SCwU1ChLhXcwz4IbJ96AyR99RWBixQ6cXPcoLp6+ulZyHt4TToLyx0Jcz8nVIeywpAaRLl3hxIaYaCs+l5Ly3BgSFVsqIuZUj3Bpcy4CRg/OoUo4xAQrT60Vj1r8EhMcSX6UpaU6+zzB7bJCTYgZeGgQJgJJ2HznMINyd1I5V2nC7tw8nZumTJNxq3LRSzg/iRIbb8m1RMQCBADbSvkoSIWLYmhViJIeJhehxxEMcdOEJbi8x2k4Skh1JPQc7CoKXUYHIhZSYiqBA1irK6mIfrhdZQgIg6Y8tEJE3Da1vBSP/FnJZ8jEQ6tmpBIEkarOwk8VdtLCjpucTjPUDCPXWakhr/a0adOob99YX9LU1PSZ2x199NF03333UXNzM6UJIxa1vuCFHA1dZQV6781ZtT50wyJS8udFb8BdS+GdrY6cSdU/u26ycFO8MBAWZxOmfKe7EOYPKvZTIyZwCi5Dzcf6Cr7zVnMuhPKVaaivhUdtpQqFeY9LTUO/zJEIhPsR7GQqgkPncACXtpDeIi0EciHVGaIbQFQCRMTj3iGVsEJtcObkHiElInW3jElFbJIldt7Jtu7yekwsxJvCdSsFuWCtRFjgahGcKzQT8KHANtBLSDRDCAkIxIKK9ALheVs1K5zGYSKR52gECISrIEGKqL2Ckt1CFKWI+oLotWXviqTjZkl6g7g0CFd4JNJWybtHjkBwVZB+JbBSSUUUbkI4yn0vqvQpZopVa6wwrH+mXDe7EyAVSWLxWUCqY9asWbTJJptE6yqVCj388MN0+eWX0z//+U/q6Oig2bNnV0UtUBUydOjQbh2zEYsUMHz1wUYsaggvMsbSu1Uu4Qw4WhHn0LUGEYC2gtMCiC4QeYWAvKLP4XKQAW4kpj7ZmLgivSYyKSWPKnmVB8I23HUuLaNHCZwy9W6ZXTSFRMDYCscRays4PMJcSlIEaE7WoQLHvJfntAh226rCw7yHEtE8RzTgd8E+GhCGen5kqCUdSMudSIUSC61M6RzQZ3KhUQ9HEGJDLHhTYNxSoSKyBInySCdTiV7gGNBPQNuBbdmGPCHqRNYBlS7SQl1SRnG1CszFJLrBvhdMLmRCR6SIIxOupFdTHrmy9vtwS0Ifg3QHHllnwX4WIfkdMMUSoSaIRg5pL1cN4spLmVxIusqBy38tWlFTrLz6YMocwtqKN3faaSd6/vnnq9YdfPDBrKM46aSTOKVSKBRo0qRJXGYKvPrqq/TOO+/Q2LFjqTthxCIFDBs5KI3DNi44ldHJLAspDog6XV8IhMFxp10pCIFA6gN5dz8kv61CITqguqwH5re8kIpA7BvUdRPHkokdkQNxcNRyVOgBIfDkComA98v7QhqgnKNiscyTKaIjkGoU2dALqQ9EBirUDKGAj5SGtkqHkFIjCUUfU31FXSuFXBRZewAthjiHukoRXrStOuIXEFVKkidh8+0cy7V5mSsXZQ2ElpQ6UuF6f3Rgb+pMypoL9tLwaW4FIVlJ8yBFwtoKbVLGwlU8r0jjspB7mAvZwjVhLYWOiP0sOA3ikjexGRaXoLoUhqY/pGTUpahUV5EwxvLby7G2gqtGooYunRatDtH0mFtMW1FbDF1lIGUNXo17hSy33HK0/vrrV63r3bs3e1a49YcccghNmDCBBgwYwFGQI488kklFd1aEAEYsUkDffi1pHLZx0bks0Nl7d3Qw6YCGwiuAfHjk4TYaFt8Io7O3AiZz6ClCCvgP16wsrgZR7SSFOZmihXAguc8Hj3y1WZMBouJrmgHv5f351FrOUyEXUs6vULNmbCpIjyQi89BOoMlYG1IqiFL4AbVyT5MS5XyUeorzp9z/i5rC9SIp+rDT1te4NBV34XivpC2cfVZs8O0mT2g7Et1ElWSgUgRRG9fTQ3QU0kAN6xDRgFdFGekStSmV96Etery9RDi4vyhHaEAqOso+lcvSvCzqCcKfBQSt6qjpPtqE+2mUolJyIZ+RbBy/JkRDjLGk+keiGXFlCGty3OLqW933yNIgqaBXn3Q1A0uNkOoKF198Mfm+zxELVJeMHz+errzyym4/jhGLFLDRl9YiuuDuNA7dkOjcqp7Fm0lvCw55Q7AQkFcqETXlxauC0yN61wtiwQyiuhcFqj3QVCzUCATf5eucJHfSIgQUYyfRe2ByxR14PudRrigTd6mMf4oBV4Ew6YCegCfkHDXlO8hjN0oRcaK0JO9J+L7I0QJYaRMVtVIEMQZWZbhIBSpPwkpV63RMl+J4waOKNBHOPMr5VoB4yNysjcB04SoOpGpwNDhzajoDqY8OruwQTwru+aElsbgOIEUoI2X9BJI1ziBMj9DBfhW4PshI5bjXCvtYaHkpkwaEdBKlpFzZ4dw0necIl6LCRVP1LkgDORFnWSy8+QxddQjrMeR7EbmaaSkyol0WoUgXm26/TsojyCYefPDBqucQdV5xxRW8LEsYsUgBK68+JI3DNjRcjpxtvfnuVMoJo3x58g4VGgvk1gtaPMJCP5dGQTWBtNTmnD3mOAQQwDk0s8LHK/lCNpwyENoKTNR6945WFGEuYE8GTJw5H70wyuR7eaqg22YOKQvINCpU4Lt7cdqCTgEVH9y7BH4PPrQKPjWx9bb0HynmStqlUzQaQmwkWiHlpmJWhZJaHqv6RFWJNxMGWuJrAc2GzNwiyHQNw6RSBhEKaEHcOtaHsKGWWpU7d9BEhKKDe39omammRNraC+JnoRWfTDognsV1c2kP8RSPFq9DfStAMLSVvZSVqrhWyUOY+CyjChFcS5DDciLt4QScCTIaRUgsapEKVl4jg7+ZoTUhM9QQy/XvxUZZsz+cZ9e9RuApApML6yrkbp+jGBWYZpXJx+SFBe2x20sUIqeOSQtmS2zf4JHfLnl2V4qIuczHDIw6TNcuRC29kQkJOjwKmlSVmUiJuNSMqxJBozKpHPGpo5ynIF+hPKcaQHrEzZL1F2Ge2sijphxcOdHV1KP5lQJrJsARKhqHgFFV0StRc65EBc7RxD9yEhkQ4ShcNLndmbY+VxNs6WiiTcpcLxNoJjp4vZAaVIGAoCBywQZYIUpJXYUJohZSjsraDN0OpliuZwgvGs1w/hU4d3bX0PJcaCzgDYL0h7PqTpSVaCRJSl4RocA1YC+KDtFT+HhPJaGvwNJW4QZzLNpEVQgWRCpcDxlHOvm74cIa1nAsTTT3KtIKQ7Pn/+PVWGNRT7CIRYpiJCMWNYabILg7Jcyq4FYl7ppSLYIW6nkpN+0QkwMu51RPCjZPymOdlCJyeSk3rZLWoVFhCYiGTnKsZ0TooQyrbpeekMnXlZ1iMoVVN1ePQMyJFu6IlmhnVL7L554WEgHBRNsUlnkCRpqjyS+z4yXrJRDlAE0Jpd1qGR1UvVLkC+HqP/BXXht8SZjfSSJjS2+xGRfhJDtiul5eiHpwP5CC2HGrqyZXd2j2CAQC5AKEAqJMV/3h+qGwUJNtzj2OuECsyesU3BpdIxQseuV0h6ZAuIRUCJ3fHmsqpDwFGhdNgeBRz0M+D02FMBFRcW45pFwpQb6cYBNlxtoRt/N3yNIitf+tNPv0bMGIRVoXHmJBQ83AP0yY4ANYSQeS/uCW3Qm1P0hFIgzOQs4miBulURkSCNRepgDbOZ8KcQiX1AhXICDFEc9TuZJPFVSKYJ7n+TDuOcJGT5zkFw+MUkkYDCpjxdwLOlKxvMZE25JH5YcwA3Q2zaFKBEJQlIVqaWoO/TpAhrBP3Ix7PlePIH0iMktERkQkUtBQP4Iuct5xDxGJVMi1E/2EE2pqFEKjEZzqgG24Rihcd1boMmAjzt4TSmqEePjUVsZYxYEUBASkAufOJlicLsJrIVUqPlfJiPsG0h3aHl2t0nMdWl4alZRSp/SHPmpjN7+jErdF13JdRC1Ef+P6x+OzkTyM05rwZ6Gt0q3MtPbI7G9laKkQQ40x7htb0AuPv2nXvdbAjIYpI1/QjqPSmExIhaYrnAoQVSLQO7SRVoroZA1fC49pBk+irF/wPQo7WEHpQgKsseDgBhw5c6LLcGpQvrPHhFuCtiBkkyw/pxUjPKlqe4owpEJeLLy5lFQ7gDax9aeE7UtegfUS8LGAkBLyT2fPjbt+jjpAwMmxEmgshCwhslHwcS4SP+EIipptyaFdV1OZ8KW4VUiHc81krwttgS5Nw7TDqTO0Ug0Fep44MoGlA70/AnHWlLiCdjDF+yDWZIGmpKOYwLlJXrvL+khR0cJVIHxhS5L+iHwrkArpwOcYsJsq62VAQBwJcT4m6mHhtBicFuvU0M5Qe3z5m1tk8rJbKsRQc4zaZFW76inBayrGTaU4l44744BCzETsZeBTyA1BCuSX8xwRQMoDkw0ecx0BEw2+EeYbWblzDlFkknP9NOIqEZce4eoRPp5EIwTinIlYhEtEhK4ixJP0AEyzm/Ml0SfAa4NJhPbIgrV32ePS0wL6inCKRogPJntMhVgvEQdX+SGEiruWslmX9hDRVARIjNOScHMyToN4XH3CCgnO7CCSko9SI5zi4CZj0iQNjxyliISbUuEhYlJx2WzrgFAVxmUirOTzZlKhlt2J9vRoLObuAD1cS632oCqLbtVTMDFQvYVGMnLcbEx0E1xe6jraVuBn0cm7QhvSJYWalv5ID6NG229l1mCpkJSwyppDqHffFpo/tzWtITQmnFGWe2TBpU/U1o4uYupr4ZNXLMg2JcxUBREy+urAySQipIqaJjFx0IZkaE5WURtN5imudQgqONpFOxHmJR3CE6paTrOBFO6gEQHgFInHok6ugq3AvTLHx0NEgxuesReGDA9kQlqaIwqAktUytcFTwvOlgRlu0LV1edKlAgQiwDkF0u8japvOmRsQLW3vrsRC5nVEdsRfA+6abLDFWgzIEqRdOrc65w6qGANFPUD4Ed1etaSUUytKokQrqaTCpTwSvUD4/4hiQENR8iQi4fQWrnspRJsJwiFlpCAiaIWu+hI2w4JwM+FdwQLOpDmWS5UlfCuMXKSCYlOBRq6zImUSoaVCDDUG7oZGjhpGLzxh6ZBaX/ckOIJQKotLJvp2QMzpNXEEg8tO20vcYwSyBebhKgr0YAddEFFh3PRK9p9v1/kJaZKi5vRLavfNpQzagwITpQQmxLmTKyXgQZFnUsG+l1yGibkOvhAB5fOITMgYSgmi4PwquHdH4LOchNMUniQwnI4CxMURC9xVcIQg8q+IxZvtmipxpaURsWBtRZ41EO3cVMxVjchrrvEYV3mwJbdcbyEaOSZNQiREwCkmWAnLbi4rBRmQFIiEhZwwkyjXplU62nBM0hyw41aCAeFrOVFeirQIPitHIpigCKnwUQnCQhJniqXpkM7fFysxTQ2rrDWECsWM3v+GRiwMKWDg0Or2tYbaw5WfcvSghGkZ5EHKOVgsiMm/XaMWEHDyHTgiCXkiDjZBDArdhdp8Y0JDFIPvpENu2Q0BIQs6QU7afPabkJlfzapYL6ERjJJPQd4F3qG18NiFsliQSb6jwyd4RbUUENEAeajIpM6ERNIXSIuwwyfKUDmNk2eRJw6P586noqxmXVLkIh4YzqeCKzdcGoWjEE7Q6XqDiBSUfSa0XBTkQfwvNHrCegqIMonaWJwp/ufszAnhpS9kwpWXhi7d4ZqdKclwgs1cu7Ss52ur15eJhUYt2ACLL5tcdyk9rXDqik2xXIkpIhLtyfJS1yteS01dtMKQOpZf4YubbxnqDxmlgj0DO+69KT10x9NpD6Px4Jw4XT7duW+qaRbi7OzW6fvkw+4bEy56SyAdgRRFAXoBkTiGXpkqvXKxlbfLbCD9AeFhPFdKRQgmzJJYbTvy4KoXuL16zqegFHXroPaOPOVy6J8hwwV8P0cLwhIV8iHbgEs0IqkDQFxESIU0QfNZ2CkRC5m2OX3hq2CVL4lWwmjIH2ACwFU0rsxSPTxcjxCNUMTEgi20InCUgktJfaqUYXylEkyQF2gxwJBwprhOqqtgMscHV9euivRoYT8RXR+Vl6qLJpMLTYuwpkKvBkeV1NJbXDdBOAJe+HOHFgW5JFxYeJuAcHT6qlRpLQw1x5f3yaZwEzDxpiEVrGOipNSAHHrIZaOus1hAueYmIReYmDCRFKRyJKoUQfQCk297wJ0w0TvEKyPCIJZT7HeBdUVM6h5ECFJHAX0ifmVQRsphfvWzKLpjawmlOHFx2iVA5IKblsmcBqdxjEuqRqAByHE1CROOQDqe8o12lM4QHQTW5HOVWEzqnDidCZauE+8JOR43LovSHrErJ5eiqjU5izq5Z4m2hNdUB0crMCaWLiDFkVcdRZzy4EgMNBcl6CyEUIlHhXYq5W00UoHr1R53LZX1TqwpFTfcZEwjQ+JPIbqKfGtZohQYjEthsWeFGmCJkWos6lRr9yp9hUUvUsWo0SMoswgtFWJIAcst35tWGjmI3pv6gV3/FIAJJGARJxfL61qpGACp8BKkgiMcvke5EgyjpDcoyAMm9lwbJnpoFTzWS8DxUQytiMIOtf/G20NNfzABUWfOojhCcjUI0ilOVyCmF7w9+zmwGFOstVAJ4sElVF0zQ6QzvEDSHWyqpW3MWVshJAHt2jEIaT0u5IHTIuyrIcLJ2Lha/TGUXIiGQsSu3JVVNRUcoWCiIbESNBdD5Qf7VqhQk6MTLNZ0aQ/RV6C6JiIUkdeERiS40Ym2pUfKhM3JEHXQbdm+GyQB5ChhQ+6iFiAarU6g6SIZqrPgvJUjFkrC2NNcohUSFVGbd4tUpIqBQ/rRCsMynC4OjVgYUsKItYcZsUgRHJlobtJnMskiNA69BQs42T4bhAEpEcxw6IHB3pb8P/QTYZ1le0AVZ5yl/giYw3xoIdqln0jAFSHYl0x4KBnFHXcZzW7Ba9wdOY6DEIR72uERqjJ99gmSCgoUpKA5KyZ66VSKCAKrIqjdK7P3RZ7TJJL2gObCkQeOMHgV3gd2FjVXi66CmH65slORIQgh4HQCWrdz+kM0Foh0IN2B6ETUIZUjGhKhYF2KkqNIpMl6itjwiiMVkTsXoj0e5Vu1Y6l0SFNRJrQWLn2E/YjOQoSeSiLa0WTMCTVRERJXgkCgy6U0zmHTLQBcNkEokikQQ2pYZa2h9hlkFKaxqIN/PI9OfC7tYTQuMJm4u1dtQMVzWzu8okXz4OXhZeFplUg7eX6z3M0i2qDliqxjaA34jt3Lh1RRcSXarWOSdd00uboUokudMPF3roT1MuFLSgT8QZuR4O4faRsQANZgQDgKG22uUGWnTRxb3CMlqhF4sCWHLgPboqxU0is88YJDaHkoz6nO5juWP2ikApWzOTYKZzmDc9/UlE3oiIVGJ1DtwZ4brlmKpkRALjjzgOfQUuhzaCmqohSuHwjAJaVqya3pEP5oOMWhTcPUt0IqRGDLLcTDX1AW3QVvE/mLC8FAhY/7nEHCtPKHSUYy5eEa1iViOIbaY+XVB2f6snvWK8SQFr6y75b058vutQ+gXspPMRtC0ABxX6VCHnQWYiYhswzKIP2SpN/b4UORI2pGNAH9RcrcU6MMvwmOrmtuH3NYk95N4yCY1UE6/NjiGxMjG2kWnPLTaTuhzVDNB0gK2ogjSuGJUVZY0IiDzoeS3nBRfIxb0h0s8GSNhEQhuKYDPhm8oVSMJCdS5kFwzORKTCEVIu6UiInoXbVwlXWwjliIGynvIwipgh4g/Jq2MqcEoYAuwjEZNcSC/gRkwv0oOy2FpEXUUZO3UQtyJknCirisNND+HzAx40qQCluzQ8gZRSmijmwJRWzy+2DlpXWBXQ/cmjKN0FIhhpQwZPhAZubvvjHLPoM0wS6UgZafqrAPd7PuZfzHz8UpkY4yBWj73Uc6oHLTKmgf8niEYFG9L5ACSQZFgrifCEND/C7mj8hGIP3DNHLh3EFlFLxVXvIWrGPw8tLoDOTAEZWoiAGRBZ+rSlxBBqdSNDqCUlVtKyL7Yw+HOLohbpggCiKyjOpF1IYDZELEpF4VsXDGV/w3tzxPaCn4zXF1hzPCAmFDWojJBKeS1CBLe35E5MJdFugrdB1HNjoCKswvMalwzIebkSFtgnVc/QNSkkyDRGU2FqWoMwxasT+bCBqyCUuF1AHGbL+OEYt6IBVaERLyzFqhXFOT3uGL0BMpEb7LdWkD36M8Kj+gycBkj7QJUhXIU3DViRIBTPYQUyJUzxMxsWhTJnGPvHaNVGiHdRhpwW4BYk7eyqVHuGpBK0h0hoXvBXqSgMDIsZieRMLLZEDGVYk44iHREtVJsp4xLj11xqRCLBxh4L1E+4R7JuZpTr9EpleSAhH3TGdwpX+7xmDJKAW3pifKt3uJPh3irunOnYkDpzq0gZtqPSLSAbFmu7SX5RQIpzmkwZg0FHO9QFAejJ4v5ajMeCGHTdNX1AXGbLdO5vUVnqVCDGlizHaj6O+/f8g+hBTBxKFYpCDskMmoCAGF85lAbxBpsc6STfSXAPkI8/w+iDmhwYBAErf7rJ9oLVPQkicq6J037poRJYCAkwmBzPS5sicEAhEMJRCswWA5gCeEIxqkNDxj8EyPtAz7hfPEjUZjIvqESFHstD0QGdYaOOFmXHYKrYa0fq9qtaWQChCZj4UwyGGdz6dYj7OxVZRDUdLDOR4XTVBVqOtK6iIUAIgBqj5c9UbCBITTRh3qFqomWFKqq16erlccfCkg1nSnqB1LhWCgY5uQCEl74FF7skDMmdBURARDxZuGdLHRl9bI/kcQWirEkCI23HINyuVhIpS0FzKkAUQQ4ioRyeGDSISt7aItBKEAyUAvETyH+6YHMSdSHjn2uECY3hPfbb7bZ9Kid9uIOOBTzsGhE5MsqjXkSJHugidNlKRqGSYEk2xaiXVuVnZGUvnk7ZFERTiCwY3QJL2hVEIiJ44saZOxkpKGzvMpB2aYfLhohOxDIhda6lpGmCSZ2og8v6IohYgy48qOyJuCu4+qqFWNsaIOpQj4lGKbbhFpwoAM0Y24cyuTirYK5dpFnCmVOCLKhH8FO6ZyeWmFXVNdCgTpLr4OEO5alKL+4BGN3mZU2qMwdAGWCqkDNLUUaaOt1qKnH34l7aEYkO6IBBFuEg+0n0hIHkgFupSqmJPvdDtK5FXylGfTK6QmiMoo9YR4EOWNlQJ5zT4LLVHyyWF8lynA/jlFEt/Is2umlquy74UKGOFFEebFiKuqcsTlQHhiF5+MyJSB0zwipOCyWV4n0RN4UwhJAE9xt1fO+dKlRbgONCILfEn072RVh1Ra6EEduXApEfe3ijOZJLDZhp6bizQ4R032qXCkwhmKqf5DPS289grlF3AeRiI/mgIB2cBr7KIJQuF6gWiLeUQsxCLEeY66/JF1MK0XrLfpatRvQB/KPEKLWBhSxqbbjzJiUQfonNcNWOynFKBUEs0F7pgxcRV6MyPgORn9RbTXRYhSU6Qw2qQm1KMylf08leGBgTturf5wegvmBFiN9+Qx6XoUdOh6R/0rJMQFBSuoBMF6dvxM+F/wCcQW4pEWhLuwJjIdOpGjVMT5cHE0gglPbGghWRMlWkouXBoiIhJRhEKjE9EAEuSC3THFypyjCq6is5IQbCb1Eqj64AhPLNxkZ00mWRLNyC+osFkZX3dEmUAo2DRLyQRrK6QXjMdVPkoQ+byRJnLEyapA6lFz1hPgdbFcOcsKE4tY1NM/prNuT3sYhmQvkbKK/LAOkxxKTxVeE+pHUfHApQ/qfgFSAKfNHOXadD/5gMsvuYoB2xUR8dCuqhWNRHAzMVcBKULMPPqJ6OHYrMpJF7RfWU5FkmE+MVEnAgbRhL8oosFjjEMkMVlwk21nuYVEWdjLozORSNaoJrwoWPOa6ELKbc0decD8rsSFCQdnLJQ0uH4f0rJFzgfbMUGB7iKgHNtyq/kVV4HEjcW4yVhk2a1iXEQ6kM6Cu2YnR02OQpltd11h0x5CLBoZRizqBKusOZSaezdR2/z2tIdiANgAC6UbHRKGB6lgZ0a2kZQJFcQDkx/WsesmO06JfgAkAZUiLJxAQ6wyFWCBDW+HIso0UaKqk3WT9sjABIo0AHdC1TRHk07mrgQUtt2JUsyQG52hWkQP5SZMsauoJhoACzk1gpGMLGhFintadbsV9fPQlu9unVZ+cEADb9bog3QaVWIB8sTH1XJTTXegoSvgt4Xyt1p582H5vULGnFgV2grpUqriTBiDqckVykrZBMulPTrgOKYEI9FgDqXC7rNlMsEDMLFmPaHYXKDV11+JegRCS4UY6gDj993SqkPqLSWCiQdiTs3lu3VhCboKhBqgeWALTBEGeriLJgqbm8j3fK7UQL8LaUfui710a4XKvXNETTmOVnA5KU+e6nnhxsB+Dep54SZsBEkiBgDCo+ZZUTmptmh3lSYYtrPj4A6nibSIS1W4AyaOGw8gIcxkIakrv4gjFk4HwREYfV9UuQFyoNuzuVW0rzj9wVoKFXQysdJr4iIY3PRtflkavIHboLSU358gFW3tEplQDxLoK8RsQ4zOIq+KpJ7CIhV1hx323JSrlXoCPCs3NdQDdtxzUyMWdYboLld1BuJ1ocTDeVrwHba0Yef+IloWGnqoLvFZWBg058nn0kcpD/UXIGDhUdjsS8ifXSj1UMphnH4CRMJpKvAiyjBdLwtuLqbbiUGWdiUVh28xz9JoRjTjJxd3HD7wwold7oqarPwIqyMWLMJ0IkuNUojoVDbz0Q7ddVHVqAzrKLTvB0cgXJQCKZ9SHJlxfT9cl1LYgEoDtpD8Nu7cJjbrC9rFmhtRjFy+2lVTW8FHZCj6YLOcwe7Zv4E9BqFFLAx1gLU2WoVWXHUFmv7Wh2kPxeDgnKI0H5+MWsQW0VKfyU6d5VJUiuq1dlA+n+N+IzDLYtOnHLcMY5KQg1vnAqKwCSWsUh4q3UjljtrN53xjzQUNjgV40tQMjcm4zlXIg0t/YFJ2/T4QSGFTreQ8qnyIG6Q6K8vO82yCSOQ08xPlSqi6vNRVcrCWgru4qk8Hxq0aCiYV6oDFhMFFKbjiI0E8lHwQWrV0VJiUCXFRbwqQC3RfhZ4CFudIR/HnUOGubGEebqK4ONKRlmMoyc/QCTetc2lddjNdb/PV0h6GoRtgGos6w5ZfXp/+9tsH0x6GIQlNg4itt7ha8kSlExYTirCD0yMgEZKvkFbqTpuQa5MyVQg5PXhb5NlEgvLMGHzWY1QKOulpdQanNNQwS0yzUG4qmgp3hw/zKh6eIxVY1J6Bu35y1CUpsExoLrgfeafyUD7HpB8FRJdxpUdkRc4RCyUBrK/QlI6Gf5lcMKlQ0aYjIty7RD0ropbmKqLUaAa0FCzK5MoQJRRsoiUaC0l/aKoDhldo86r+FWF7qxA7Z4ClS6SpSH6mhrrCmB3WpRy33O1BCKkhYcSizrDt10cbsahHuIkJhAFkAn8nJq2grU2alqH/OSa6fEH7YyAlAl1FG2s14NMZYLLkCocKBcW8+Faw9qJMleY8hc2IcqjHlOuHoRM4z/VajCLmUir2xITvzCPBCrSiggMarvrDEQdXTuoiFi46oS/w2UWpEjGv0heErERpjkS410UuOqVGkqSCoxR4j9NRJMtJsR3MrtoQcfBiA6yOMoXQVrj255wS6ZDupJzHVt2HIxdlqf7wm5urPz9HMnpI/r4nYtuvbUw9CZ5pLAz1grU3XpVGrDWU3v7fjLSHYlgUOAqh1pRukpK+4FyNwNUHhTx5edw1y101Cz0LCM+HRM1F8oo5ys2HTbhPIecZAiEJ0F60lcVuoehzS3OnYRBnT5eGictT2SJcrRyiCIcn73PRjiqBZiLtwZUpTiNSdQMfazT4WST+TGgyMEcjjaGkJyrsdKJM150UXhNaMhoLNLUpCLdkkUZhXEbaAS2FGF2xqJXtuUVPwcQKZmOtIBUVCktl8lxkgl1AsU7IhVdsisWZPG4VnFqUom4xZPgA2mTbtdMehqGbYBGLOsS2u21Cf7jw7rSHYVgkZDJOTlpRcy4WemqIgFMFFQrboLTUUAHmt1aE+aUVewD9Be7OwUvg5onmW3DD9N1k6RHBGpzTK6pJdENwEQxnHaHVHzyWHKIkse4iqh9Nija1AjRqcNYpM+CMOEFWmNzo+GNBWpziwPO8azLmxuaIBfavx3DPufKDdRRixR25ZrLBlaQ+8oj04LTbypQDoYBmwnUmRRqkVGbzMp+dUrWMFtEV/UyiUzIDrExgu69vkvmmYwshNPGmoY6w3e6jjVjUM1xI3Qk5EaUAFUCvEGgw1OsibK1QyM6QKE+VKhI22YJxA9/Bh5TjnhXSr4Pbj2PXaExW8ajA+8HdeyDdU7kqRH+sfNFgcP8w51eB3Tq/C0c2eH/CFJwY1Jlm5RARqTLKjEtDXWQigAiT5aTxusj924V63aMrH3Ulqpo6kfbmsoINsEoaiWBdhJIKkAHnUaHrOPUBMuGcNBGVQGUNGJQzL+M29zgZn3yvIOkonAPCPq4XSE+bsHoosehp8CwVYqgnrDRyMPVfoQ/N/nBe2kMxfBYSkxU3+kL6A3fTuRz5BZngwvZ2NWbyY4Mm3GEjFcDNQEScyEZc2hGUq0KgeoSzJvqOBD7l8AvVJimOAN4XWI8O7mxq5Sw7ZUgV9bxwVaHOPpy1IDxuWScRDa2UcJoLDoeo2ZZzxky4aFY5aEHUqZUfblsQC87sRNtCGyF9TyTlEVCuXSy3WTeh1R5Ig3CPE3bbhDBVIhdidKVhECcU4XSHlpKCaKDKo6lJrjlSTky42NpUPyYjFvWOPv1aaOQ6K6Y9DEM3wlIhdYoDJuxCl//41rSHYfg8qNESizIhHnTEweX0Mf9icsxpFYibIBHKB4+ATgBNzeDFAL1AIU8+KhsQRtD+HixM1L4emIxZ2xCEFOBvNCRjy3GtDOFmqdpO3d0tOYKRIAXOmqKq1NSlNRzRcKZcLiKhZCR28CTpPqr7kt4fKtLUihDu41rGdhWt8pCuo+yQ2a69SgIQFLXkZltvjVI4UlGqCGlj4qKNxKBl4b4tRH6TtrcHcYLNOnqDID2FyJAZYGUC+x01vuelQQBLhRjq0YHu9z+/g1rN4ruuwaWT3BMkL7oLlx6RV2ODLUyYTBIqXFqJiZHBJZPij4HW3r7ahgeIclA+8qHghfMeWukKPUZHhULoNEAq1AeD79jVI8qRDWEjToegQQuuCFHdBVIOnc6LfShAXqKS04TVtwpYXaMwaTyK8avgUstG5VFMM0RDgW6vmupQEhH4HvmtJSZUGB+7ZLqFBZkgGR1EhaJapsOeW06Orz0fOjF+jhYFch0NdY9CU57G/d/m1BPhWSrEUG/o1aeZdthzDN39x0fTHophMRARCAeNWiAiISZNOolDI4BJU5UNXNqJu3BEL3o1Rw0+WH/Bk7+UgDBhYLWlTuTtEtmQPlsehR0yUePvCkhGESWrQiiiAstERUfUBUzNsiSjEkdaeHNUdLjSUhWBulELkXCNw6SrKHcbBWnirqk6UPadwEYoW1ViwZoJGW8OKSKIM/k66LWAPTdHKMp8XRiIXLBmgsgDiQvQ8t2xp+qqD44CGTKBbb82mvou3zvtYRi6GZYKqWPseuDWdPeNjzasyUqm0CmUy1EJhPBZOInqjoJENqC9YMGh+lvgw8XEyttqWIBNuDQlUMhx+WqY94VccOJDzJ/gvBmSdF/NuRSKhikkiiCRDuYQSmx4G7a5Fs1GVSdTjTzEJ6HD4QlfIhVMCti2O5RMShRtcZ1G40gEh7dheAWHUR4QrLyVVOARURsQBh6ailtD9PYA0SrFWgrurIrz98krFqPOsx7SQEg9RR+B6SmyhvH7bUk9FqFVhRjqEKutuxKtsf7K9Prz76Y9FMOS6i4gKHRdUAv56jtrjgaUojt6JhWcRpHuqJwOwOu484Z3N2sx8hQW0I5dXTmhr2jKUcidPrVKhGOvSiyUCLB2ASWrruU522lL6IJ1Ggm7b25djj+SHUxBINR3grd3wg0Wb0JoIW5dHI1wxIJTNWjIpu/vqIj9NotW4W0RV3VEKQ8mXuoPolbp7KjJ4k0QiriJGF8rLO66WPVHJjF8jcG0/uarU49FaMTCUKf4+ne2pYuOuyntYRiWRnfhJsLOwjSOJKiNpk6+zARwZ48IBMSJLkWS08kbk2ilICkXtsSOowhRLxB9ZMtwl26gpDOmpC5iwSY8MpxJlvPjUO7j6lCZWEh5LDc/Y3txeQ3+EiEzFbUhL8VltLy9jsFHJIa1FyGF0IU4UsW6CjxHnw9EZxy5COMSXphxaPSDtRTJDqUQbvooM+2Bwr8G+W3rkaJNhWksDHWLbXcbTb8563aaN2dB2kMxLCH4RzNR+ph4hZ05WYwY9R4hCmFVDTLhmp25yZe1GiABqh3g6hKfPFROQMMBoaePx5gksCBTSQcmeNdBtKqvOZShQcLQK/Kw0PFif+onEQ8yqoyNvChYTAnXULcdizO1QRtXwOg1gJU5tkVFB0SdLFzVbThtAvtuaSDG54xIDkc+nFFHdfMwS31kF829irTDXpulPQzDMkKqxvmrrrpqdHfnlnPPPbdqm+eee4622WYbam5upuHDh9P555+/0H5uvfVWGjVqFG+zwQYb0N13V7tWIid7+umn07Bhw6ilpYXGjRtHr732GmUBTS1FGrPdqLSHYVhadHJ+5PkVpaVIc0AfkMuT19wsxln4riJFgBQALyWi9nYRMLJxlE7CbBTVziJHam0nWtBG3oJW8ua3suV1bl475eFY2Vrihf0j2lQ4yUuFFzz3W8uUa5fXkgs3AkO78sT2nnutDX4Uge6/LMdC9VJrB48BY6EFOj4IMTFWnJeOHefC54Rz6+ggDxEMdCbFa7hkxSJfE74+sEZHuqNYqOrPYsZX2caGY9eg3st16ufS0xB2w5JRpN6R56yzzqL3338/Wo488sjotblz59LOO+9MI0aMoClTptAFF1xAZ555Jv3mN7+Jtnn00Udpv/32o0MOOYSeeeYZ2mOPPXh54YUXom1ARi677DK6+uqr6fHHH6fevXvT+PHjqa2tjbKAAyZ8ZeG21obswJEKkGd4XhQK5EOIiNB/U1E0A87NU63CUWYZYmLGJOxsrLUME+vDBW3ikeEICCbmtg7yOkTU6HQKXMK6oJ28thIvfnuZ/PaKLAs6KLegzM3P/FasK7OFNv7GOrzmLyjF26NVue7Hwz7d2AJoKEBAMGZHimThtA7GinNJlpIiooHUD87FVX64zrCqo2CCAW8PpDv0Wrn0krlpZhsHHr8r9XR4rDfq2pJVpF4Vstxyy9HQoUMX+dqNN95IHR0ddM0111CxWKT11luPnn32Wbrooovo0EMP5W0uvfRS+spXvkInnHACP//Zz35G9913H11++eVMJBCtuOSSS+jUU0+l3Xffnbe54YYbaMiQIXT77bfTvvvuu8hjt7e385IkOWlh5dWHcFnWw3c+k9oYDF1HlE/O5SgAuVhkfll0BUw63ASqKQPXK4PFnQoWcXKbUvQqySsxcaIKiDjhdInUghhuJVMK3BjNaUBwmHK1pbcIMdXQS6s/XDqEqzcwTk7P6GtqbhWiTJR3KMZX8hYYhSFKk1NthZbjForsSsoCTeqkowBQEYP9mi9Fj8Hm49ZjUbqh5yL1iAVSHwMHDqTRo0dzRKKMkKli8uTJtO222zKpcECk4dVXX6VPPvkk2gapjSSwDdYDU6dOpRkzZlRt069fP9piiy2ibRaFc845h7dzC9IwaeKbh1efoyHbECOs+A496pSK+RSkA14N0E9AZwCSgX8D+LeBtIE+ctUEIgIc2UgaSwXVkY32RGQD7wdhdtoGt6jbJes8OPWSeA1EgFMy2I8s2GfYikhEmxyPl9jYStIcun1izCxCRSRCoxE4R0QjcM4iBNFrET068mLoKfjmjxrktyxs3FRIqhGLo446ijbZZBMaMGAApzROOeUUTocgIgGAEIwcObLqPYg0uNeWX355fnTrkttgvdsu+b5FbbMoYCwTJkyoilikSS5WX29lWnn1wfTuG7NSG4OhG5EUSrq/nd8F/63/AblwpAOaAxV3sh6BRZA5MYRyntpo1oHuphw5cI07tJKDox9q5oXOZFBh6jouH9WhcaWHK0/VLq2s6+DSz2q30LAMUWmZSYKIRp1oM6AAvTuwLZMkjabgkcWoeamMYV1FKK+7a5CM5PTgqoFGxKAV+9N6m61GjQDPnDe7DyeffDKdd955n7vNyy+/zGLL5MS94YYbcmTisMMO42hBE3z/UwSOn/YYOuOHP/sG/eRbV6Y9DEN3wvlagDAgUqF+Eq5jZ2ebcFchwV1UQULc3b2rIkE0wVWTIBXB5lLuMK5KRUy4ohyuVmFEQ+IDhbHew4lGXUTEOWe5ShK/LGkaLTt1ZMk1Y4vGmBBp83EcucA+USXDBmAito7IlKFH4bAz90p7CIYsRiyOO+44+s53vvO526y22qIZK9ITSIW89dZbtPbaa7P2YubMmVXbuOdOl/FZ2yRfd+tQFZLcZuONN6YsYZNt1qa1R4+gV595O+2hGLoZyYkUZaPoExKRCkcc+EW19/alYRlP5tgO1SXsAS7mWyHrG+DyiahFAK9O8tlwSyd+JgGJnumdDLzUUzsuXy07U6sKBSALvC2aq6FXCWzLMW5UuShR4W2FIIQgSEnb7Sr7bSEXbuzCfyxK0ROx6trDaKuvbEgNg7BxDbK6/bZg0KBBHI34vCWpmUgCwkwowAcPHszPx44dSw8//DCVXMMmIhZmgnQgDeK2mTRpUtV+sA3WA0ilgFwkt0FaA9Uhbpss4f9+uFPaQzDUAJGuIJkmca6TiFQUEiWrqleIJ22NdLgJO5cnn0tcC5JywHvxo8VaDF2cliKpq9CUhnMP5ffmC+QXihz5iI6RiEi4NAe3gufxQSdSkDEmt0ucm0UnGgP/d/i4Hm2I9VmpEK8LS1aRmsYCwklM7jvssANXhuD5scceSwcccEBEGr71rW/RT3/6Uy4lPemkk7iEFFUgF198cbSfo48+mrbbbju68MILadddd6U///nP9NRTT0UlqfgiH3PMMXT22WfTmmuuyUTjtNNOoxVXXJHLUrMGMP7l+veiT2ebYVaPR3ICdhELTNCkUQEA+oVOE7WUtvrkeehX4rO9NqdAHClx27l9fNEwXEoEJIJ7eGibdk6n8AbkOTLj3pPLqYaiLOQnmdqwctGGQ0vvJtput9FpD8PQ04kF9AsgAfClQFknJnwQi6TuAtUY9957Lx1++OE0ZswYWmGFFdjoypWaAltttRXddNNNXE764x//mMkDykjXX3/9aJsTTzyR5s+fz++bPXs2bb311jRx4kQ21MoaMCn88Ky96fyj/pD2UAy1RGdrcKQYXAQDSNa8s+W2R2FOhaDQMDjfjGT30k46BveaNAxbeD3blKMJGMgFjg3yoC3LRcdRLbrk9S6iYWhofP+03SnXaF1nw8ZNhXhh518RwyKB9AmIzpw5c6hv376pXiV8ZEfveiG99vy0VMdhSBmL+KfrhJvSujzR1KsTqVgoYtH5tSqi0okYcDUIxJqSCpGmqCL2XGSou4HC34aFMXzNIXTVvSfVBbGoxe/4XD3GmH1+Trni0t+8VjraaMrNP6mLOWdJYbcSGQR+vA866WtpD8OQNjqLIV3VBdwqoYHAwh4RnfQNbnE+GkvzGvQaICu5nBzLpWQWtRgaGgedsGtdkIqaI2xcHwsjFhkF+ocMHbFC2sMw1BsWMZGzgHNRk31nArGopZN4NCIwWsXxRcc2NDYGDu3XWJUgBoYRiwzj5F99O+0hGLKKxY0mWNTB0AWccOmBDVUJ0hleA1aEAEYsMgx4WtjdgMFgqEdssu0o2mirNalhEYZdXzIKIxYZx0En9vwugQaDIXv4junAGhZGLDKOVdYcSmPHx6W1BoPBkDZGb7sWrblhuo0b04bXwAZZRix6AI654FtsmmUwGAxpo6VPEx1/0QFpDyN9hFYVYsgw+i7f21IiBoOhLnDAsbvQgCH90h5Gw+Gcc86hzTbbjJ2s0RYDztKvvvpq1TZtbW1sODlw4EDq06cP7b333gv12uoOWMSih2CX/beiAYOzZaJiMBh63k3O1w/eNu1h1AW8oOvLkuChhx5i0vDYY49xvyz02Np5553ZddoB7tZ33nkn3Xrrrbz99OnTaa+99uo5lt6G7gWat/3k19+l4/e6dCFLZoPBYKgFTr7iIMoXGtAMqw4svSdOnFj1/LrrruPIxZQpU2jbbbdlB8/f//733AJjxx135G2uvfZaWmeddZiMbLnlltRdsIhFD8K6m46kHffeNO1hGAyGBsTWu25Mo7dZO+1h9DjMnTu3akFvrcUBiAQwYMAAfgTBQBRj3Lhx0TboNr7KKqtwE9DuhBGLHoZDfvx1u2MwGAw1RS7nc6MxQ4zuqgoZPnw49x5xC7QUX4QgCLir95e+9KWoIeeMGTOoWCxS//79q7YdMmQIv9adsFRID8Pyg/rSD87amy4/5Za0h2IwGBoEh5y6Ow1eSe6MDYqumlzpe6dNm1bVhAydwb8I0Fq88MIL9Mgjj1AasIhFD8SuB3yJNt56rbSHYTAYGgDrjFnVBJvLMGLRt2/fquWLiMURRxxBd911Fz3wwAO08sorR+uHDh1KHR0dNHv27KrtURWC17oTRix6KI4+b18OTxoMBsOygu97dMwF+9lvTR0gDEMmFbfddhvdf//9NHLkyKrXx4wZQ4VCgSZNmhStQznqO++8Q2PHju3WsdjM00MxdJWB9N2ffD3tYRgMhh6MA47bhd1/DekbZB1++OH0xz/+kas+4GUB3QSW1tZWfh36jEMOOYQmTJjA0QyIOQ8++GAmFd1ZEQIYsejB2PN729N6m62W9jAMBkMPxJobDKdv/iiuMDCka+l91VVXcSXI9ttvT8OGDYuWm2++Odrm4osvpq997WtsjIUSVKRA/va3v3X7R2fizR4MtCs+5pf70aHb/8K8LQwGQzf+thD/tuTy5llRLwgXQyja3NxMV1xxBS/LEhax6OFYebXB9N0fW0rEYDB0H/Y/9iu02ror2SX9PITWNt3Qg/GNH+xIm+24btrDMBgMPQAbbbUm7XvU+LSHUffwrLupoadjwkX7U1NzIe1hGAyGDKNQzNFxlxxgVSCGz4WlQhoE/Qf2odN+ewjrLgwGg2FpcNLlB9GgYdXOjYbPQGht0w0NgDHbr0N7HLJd2sMwGAwZxFcP2Iq+tMtGaQ8jM/AsFWJoFBx8ym60/ODl0h6GwWDIWDv075++Z9rDMGQElgppMBSKebrotmOpT79eaQ/FYDBkAC29m+iXfzuamluKaQ8lWwjCri8ZhRGLBnXlPPFXB6Y9DIPBkAFMuOhbNHyNIWkPI3sITWNhaDBstsO6tPM+W6Q9DIPBUMfY9uujaeuvbpz2MDIJr6s6C8ouLGLRwEDzIPO3MBgMi8KGY9egEy+1yKZhyWHEooGB0tMTLj2Qei3XnPZQDAZDHaG5V5FOvuIgs+zuCkJz3jQ0KJbr34suuv1YIxcGg4HR1FKkC/5yFC0/qK9dkS7As3JTQyNjxFpD6cdXfiftYRgMhjrACZceQGtsMDztYRgyDEuFGCLzrG8dbf7/BkMjY4/vbW8mWN2FsHGrQqxtuiHCgcd/lT6dvYDuvP7fdlUMhgbDl7+5BR16+h5pD6PHwAtDXrry/qzCIhaGKhz2071olTWtZt1gaCQMG7ECHXnON62XkKFbYMTCUIVczqdL/3E8rT16hF0Zg6EBsNp6K9Gv7j6eXXkN3YigG5aMwoiFYSHAuves6w/jihGDwdBz0atPM/3shh9Q774taQ+lx6ZCvC4sWYURC8NnNh26fOIJNHBoP7tCBkMPRL+Bfeiyu4+jAYOtrNTQvTBiYfhMDF5pAP38jz+kQjFnV8lg6EHI5X2OVKw0cnDaQ+m5CBu3KsSIheFzMWLtYXTBX482Ay2DoQe5ap578xG05obmVbFMEZrzpsHwmVh74xF8d+PnjIcaDFmG53t0+u+/R+tvvnraQ+nx8Mx502D4fKy76Ug6508/omKTKccNhiwiX8jRz64/jEZvvXbaQzH0cNgtqGGxseHYNen4Sw+0yIXBkDF4HtGR536THXYNNULYuKkQu/00LBG22XVj6tOvhc446DdU6ijb1TMYMiDUPO23h9AW49ZPeygNBS+QpSvvzyosYmFYYiCUeuKvvk15qxYxGOqeVBx17r5GKgw1hRELw1Jh669uxK2Vm3oV7QoaDHUIlIn/4qYf0c77bJH2UBoTYeOmQoxYGJYao0avSqf99nvU0qfJrqLBUEdobinQKVd+h3VRhpQQmo+FwbBUGLPt2nTZP443h06DoU7Qb2BvuuTO42js+A3THoqhQWERC0OXsfJqg+mXfz2aBq88wK6mwZAiVhjWn86/9Sg2tjOkC896hRgMXcPQVQbSlf88kdbfwox3DIY0sNbGw+mKf55Iq6w51D6AekBoGguDoctAh0T0FtlkWzPgMRhqCRD6824+kpsHGgxpw1Ihhm5FsblAZ//xh7T/sV+xK2sw1AD/96Od6LxbjqDmXiairjvxZtCFJbtFIWaQZeh+eJ5HB0zYhfr070W/P/vvVC5V7DIbDN0MP+fRQSfsSt88/Mt2betYY7G06Mp704Y5bxqWGfb47nbcwOwn37qSWue325U2GLoxMojGgBuOXcOuaV2Xm4Zde39GYakQwzLFOpusSpfcMYFWHWUqdYOhO7Dy6oPpotuOMVJhqFsYsTAsc6yy1lC69M7jaPy+W9rVNhi6gB32HEO/uucEWn39le061jvCxq0KsVSIoWah22Mu2I9WXHUF+sNF91C5w3QXBsPiwvOJ9jtqPGuXoGEyZAABPrguvj+jsIiFoaaA0OzCvx1D/VfoY1feYFgMLNe/F/3yr8fQgcd91UiFIRMwYmGoOdbaaBW6YuKJtOFWJjwzGD4P6266Gv3qnuNp3U1H2oXKGDxz3jQYaosBQ/rRuX8+gg4/+xvk54zfGgxVk5Lv0aGn70EX/PVIGrLyQLs4WUTYuBqLZfaL/vOf/5y22mor6tWrF/Xv33+R27zzzju066678jaDBw+mE044gcrlctU2Dz74IG2yySbU1NREa6yxBl133XUL7eeKK66gVVddlZqbm2mLLbagJ554our1trY2Ovzww2ngwIHUp08f2nvvvWnmzJndfMaGJQVyxV87aBs291lptUF2AQ0Gtcf/+Y0/oj2/vwP5vpFuQ/awzL61HR0d9H//93/0wx/+cJGvVyoVJhXY7tFHH6Xrr7+eScPpp58ebTN16lTeZocddqBnn32WjjnmGPre975H//znP6Ntbr75ZpowYQKdccYZ9PTTT9NGG21E48ePp1mzZkXbHHvssXTnnXfSrbfeSg899BBNnz6d9tprr2V16oYlxPqbr05X/vMk2v2729q1MzQ0dtl/K7rqvpNo9NZrpT0UQ1cRNm7EwgvDZTt6kAUQgtmzZ1etv+eee+hrX/saT/JDhgzhdVdffTWddNJJ9MEHH1CxWOS///GPf9ALL7wQvW/fffflfU2cOJGfI0Kx2Wab0eWXX87PgyCg4cOH05FHHkknn3wyzZkzhwYNGkQ33XQTfeMb3+BtXnnlFVpnnXVo8uTJtOWWiy6BbG9v58Vh7ty5vF/sr2/fvsvgShmA+255nK4990765INP7YIYGgZ9B/Smg074Kn31gK3THkqPBn7H+/Xrt0x/x+fqMXZa5zjK55beZr1caadJL1+YyTkntTgbJvUNNtggIhUAIg34UF588cVom3HjxlW9D9tgPYBox5QpU6q2QegQz902eL1UKlVtM2rUKFpllVWibRaFc845h78cbgGpMCx7fPmbW9BvH/wJfeVbY+1yGxoC476xOf3uwZ8YqTD0GKRGLGbMmFFFKgD3HK993jYgH62trfThhx9ySmVR2yT3gehHZ51HcptF4ZRTTmGm6JZp06Z18YwNS9Il9ejz9qUTLj2QBg7rZxfO0COx/KDl2NvluIv3p+WsK2nPQ9ANSyMQC6QWILj7vAVphp4AiEURfkouhtpix702pd8+8BPTXhh6HL56wFb024dONTfaHgyvgctNl8h587jjjqPvfOc7n7vNaquttlj7Gjp06ELVG65SA6+5x87VG3iOSb6lpYVyuRwvi9omuQ+kTKDLSEYtktsY6hctvZvoBz/dmzbcak265ud30HtTP0h7SAbDUmPIiAF08Im70XZf38SuYk9H2EUBZqMQC4ggsXQHxo4dyyWpqN5AqSlw3333MWlYd911o23uvvvuqvdhG6wHkOIYM2YMTZo0ifbYY49IvInnRxxxBD/H64VCgdehzBR49dVXudTV7cdQ/9hq/Ia0xU7r0T/++B+67ry7qHWedUs1ZAdNvQr07eN2pa8fvC3lC7m0h2MwZLNXCCbujz/+mB+hg0C5KAAvCnhJ7LzzzkwgDjzwQDr//PNZ73Dqqaey3wTSEMAPfvADrvY48cQT6bvf/S7df//9dMstt3CliANKTQ866CDadNNNafPNN6dLLrmE5s+fTwcffDC/DuHlIYccwtsNGDCAiQsqRkAqPqsixFCfyOVz9PXvbEvb7rYJXXTcjfTkpJfSHpLB8IUYvc3adNxF36KBQxft52PooQhC5EO69v6MYpkRC/hRwJvCYfTo0fz4wAMP0Pbbb88pjLvuuot9LjDJ9+7dmwnCWWedFb1n5MiRTCLgQ3HppZfSyiuvTL/73e+4MsRhn3324fJUHA/kZOONN+ZS1KSg8+KLL+ZqEUQsUEKK91955ZXL6tQNyxj9B/ahs647jF595m264tRb6bXnTFhrqD+stu5K9MOf7c0+LYYGRNi4qZBl7mPRU1CL+mfDkgOpr1suv4/u+sN/6KMZc+wSGlJHvxX60K4HfIm+dcxXKGd29Q3rYzFutaO77GPxrzcvzeScY23TDZkGIlH7HjWe9jp0R7rrhkfoxksm0oJP29IelqEB0dy7ifY7amfWUTS3FNMejiF1hF2MOmT3nt+IhaFHoNhcoL0O3YHG7zeWbjj/H3TvLY9R24KOtIdlaAA0NRdo3Dc3pwOP/yr1W75P2sMx1AvCxk2FGLEw9Cj0Xq6Z89r7HvVl+vOv7qM7r3s4y/8+DXWOryLlcfR4GjjUjNwMBgcjFoYeieUH9aUfnrU3fe3bW9Pfr3mI7rvlCepoL6U9LEMPQL6Yo5323oz2PGR7GrH2sLSHY6hXBLijsaoQg6HHYfgaQ+iIX3yTDpiwC/39mofpL7+eROWOStrDMmQQ8J/Y43vb056HbEcDhliEwvAFCANZlhZdeW+j9goxGGqJ/issRweduCv9+dmf0yE/2Z0G2sRgWOzvTh/6zklfo5ue/hkd8uOvG6kw1DWuuOIKWnXVVam5uZm7f3d2uK4FLBViaCj0Xq6FvvGDHVm5/8BtT9Lvzv47zZvTmvawDHWq1zn4lN24+2iTVXkYMiDevPnmm9kM8uqrr2ZSAcNI+DbBbdo5XNcC5mOxmDAfi57rg/HfR1+ju//4KE3+53NUKWc3/GjoOnzfoy2+vD77UIzedm0uZzb0HNTUx2KlH1De74KPRdBO/3rvau6snRwrnKmdO3VngExsttlm7Fjtft+GDx/ObtNoIlorWMTC0NDAxDF667V5+XjmHLrmvLvoqftfojkfzUt7aIYaAm3Lx2y3Nn33x7vToGFmvW2on4jF8OHDq1afccYZdOaZZy60OZptTpkyhU455ZSq37dx48bR5MmTqZYwYmEwKCDIO/6i/alSCWjKgy9zw7Mn/vWiXZ8ejE23X4dLRjffaV3uRWMw1BumLSJisSh8+OGH3Jcr2c4CwPNXXnmFagkjFgZDJ8CGefOd1uPl3Tdn0QO3TaHH7n2e3nzpPbtWPQCrrj2Mttx5A9p+jzE0Yq2haQ/H0FMRdtHkSt8KUmGW3gZDD8LKqw2mA4/bhZd3XptBD93xNPtizJ9rtuFZQkufZtrtoK1phz3G0KqjVkx7OIZGQFhb8eYKK6zAzT1nzpxZtR7Phw6tLYG2iIXBsJhYZc2hdOBxX2VPDEQvQDIeuuMZmvXux3YN6xCDVuxP2+62CW339U1ojQ1WJs/z0h6SwbDMUCwWacyYMTRp0iTaY489IvEmnh9xxBFUSxixMBiWEJigVl9vZV4OPnk3evrfr9KUB16mFx5/g1573lq4p4nV1luJNhy7Bm2y7do0Zrt1rKrDkB4CVJgFXXz/kgGlpgcddBBtuummtPnmm3O56fz58+nggw+mWsKIhcHQRZIxZttRvACzP/yUnn74Fbrttw/SzHc/pk9nL7DruwzRu28zDV5pAO35/R1ozLZrm3mVoaF9LPbZZx/64IMP6PTTT6cZM2bQxhtvTBMnTlxI0LmsYT4WiwnzsTAsKRCGfOOF9+ipB19mj4zXn3+XQuuI1jV4RKutsyJttctGtOl269AaGw5nsa3BUHc+FoMOobxfXOr9lIMO+tcHv1+mY11WsIiFwbCMgBryNTcczst+R+1Mba0d9Ppz0+iVZ96iV55+i/776Os0b45FND4Pvfu2cGpj1Car0qjRq/K1bOm99KZDBkPNEFrbdIPBsIzR3FKk9bdYnRf53Qlp1nuf0P+efZuJxivPvM1LUGlM90/P92jtjUfQqNEjmEisvfEqNGT4QBNdGrKJwLqbGgyGFPQZQ1YewMs2XxvN69Da/b2pH9C7b8yid1+fSdPemEn/e/Ydev/tDyngH6qeQSBwziAQK68xhIavPoRWXn0QrbTaYGpqXvrQscFgqA9YKsRgqCMUmwo0ctSKvCSB6MaHM+ZEZOP1596l5x57jVMFsz/4lEWj9UI80G+j3wrL0fKDlqP5c1ppvc1Wo7U2XoVWXn0IDV9jMK0wrL9Vaxh6PMIw4KUr788qjFgYDBmJbqCHBZbR26y90OuwIf/0k/k0a/rH9OknrfTJB3Ppkw8+pU9mzeUmawOH9osiIqX2MkdAoIRsainwc6xvnd/O2zT3aqJiU56KzQVeHwYhDV1lIJOeQlOeicOH02fThlutScsP7kvLD+pLAwYtR32W70WDV1ye+g7oY4JKgyEMNR2ylMiw0NuIhcHQA4DKiP4rLMeLwWCoA4Rd1FhkmFhYnZbBYDAYDIZug0UsDAaDwWDobgQBkdcFnYRpLAwGg8FgMESwVIjBYDAYDAZD12GpEIPBYDAYuhlhEFDYhVSIlZsaDAaDwWCIYakQg8FgMBgMhq7DUiEGg8FgMHQ3ghD9wxvSx8KIhcFgMBgM3Y0QxCBoSGJhBlkGg8FgMBi6DRaxMBgMBoOhmxEGIYVdSIWg8WBWYcTCYDAYDIbuRog0iDlvGgwGg8Fg6BZeETZsxMI0FgaDwWAwGLoNlgpZQvY4d+7c7rv6BoPBYKgZ3O93LaIB5bC9S43EylSirMKIxWLi008/5cfhw4cvy8/DYDAYDDX4Pe/Xr98y2XexWKShQ4fSIzPu7vK+sB/sL2vwwiwncmqIIAho+vTptNxyy5HneZQFgJ2DCE2bNo369u2b9nDqBnZd7LrY96Ux/x1hugOpWHHFFcn3l50SoK2tjTo6Orq8H5CK5uZmyhosYrGYwJdw5ZVXpiwC/+iz8g+/lrDrYtfFvi+N9+9oWUUqkmhubs4kIegumHjTYDAYDAZDt8GIhcFgMBgMhm6DEYsejKamJjrjjDP40WDXxb4v9u/Ifl8MtYCJNw0Gg8FgMHQbLGJhMBgMBoOh22DEwmAwGAwGQ7fBiIXBYDAYDIZugxELg8FgMBgM3QYjFgaDwWAwGLoNRiwygJ///Oe01VZbUa9evah///6L3Oadd96hXXfdlbcZPHgwnXDCCVQul6u2efDBB2mTTTbh8tM11liDrrvuuoX2c8UVV9Cqq67KrnFbbLEFPfHEEwtZ1R5++OE0cOBA6tOnD+299940c+ZMqgdg3LBbTy7nnntu1TbPPfccbbPNNnx+sCM+//zzF9rPrbfeSqNGjeJtNthgA7r77rsXsgU+/fTTadiwYdTS0kLjxo2j1157jbKOL/rss4wzzzxzoe8GPuMl+V5317+xNPHwww/TbrvtxpbWuAa33377En+3P/74Y9p///3ZbRO/R4cccgjNmzev2/+dGTIM9Aox1DdOP/308KKLLgonTJgQ9uvXb6HXy+VyuP7664fjxo0Ln3nmmfDuu+8OV1hhhfCUU06JtnnzzTfDXr168T5eeuml8Fe/+lWYy+XCiRMnRtv8+c9/DovFYnjNNdeEL774Yvj9738/7N+/fzhz5sxomx/84Afh8OHDw0mTJoVPPfVUuOWWW4ZbbbVVWA8YMWJEeNZZZ4Xvv/9+tMybNy96fc6cOeGQIUPC/fffP3zhhRfCP/3pT2FLS0v461//OtrmP//5D1+X888/n6/TqaeeGhYKhfD555+Ptjn33HP5c7j99tvD//73v+HXv/71cOTIkWFra2uYVSzOZ59lnHHGGeF6661X9d344IMPFvt73V3/xtIGxv2Tn/wk/Nvf/oYeUeFtt91W9frifLe/8pWvhBtttFH42GOPhf/+97/DNdZYI9xvv/26/d+ZIbswYpEhXHvttYskFvix8H0/nDFjRrTuqquuCvv27Ru2t7fz8xNPPJF/WJPYZ599wvHjx0fPN9988/Dwww+PnlcqlXDFFVcMzznnHH4+e/Zs/sd/6623Rtu8/PLL/AM1efLksB6IxcUXX/yZr1955ZXh8ssvH10T4KSTTgrXXnvt6Pk3v/nNcNddd6163xZbbBEedthh/HcQBOHQoUPDCy64IHod16WpqYl/QLOKL/rsewKxwGS4KCzO97q7/o3VEzoTi8X5boME4H1PPvlktM0999wTep4Xvvfee93278yQbVgqpAdg8uTJHEocMmRItG78+PHcffDFF1+MtkFYMwlsg/UAOvFNmTKlahs0XsNztw1eL5VKVdsglLnKKqtE26QNpD4Qzh49ejRdcMEFVaFqjHHbbbetakOMa/Dqq6/SJ598sljXaerUqTRjxoyqbdDUCKmDerkGS4rF+ex7AhDSRwpgtdVW41A+UhuL+73ujn9j9Y7F+W7jEemPTTfdNNoG2+P78vjjj3fbvzNDtmHdTXsA8GOQ/MED3HO89nnb4IextbWV/8FXKpVFbvPKK69E+8CPRWedB7Zxx0kTRx11FOe3BwwYQI8++iidcsop9P7779NFF13Er2OMI0eO/MzrtPzyy3/mdUpex+T7FrVN1vDhhx9+4WefdWByhN5h7bXX5u/ET3/6U9YAvPDCC4v1ve6Of2PQLNQzFue7jUfoS5LI5/P8by65TVf/nRmyDSMWKeHkk0+m884773O3efnll6sEZo2IJblOEyZMiNZtuOGGPFkcdthhdM4551i/lAbHLrvsUvXdANEYMWIE3XLLLXU/4RsMWYMRi5Rw3HHH0Xe+853P3QYh28XB0KFDF1LwO0U7XnOPnVXueA5lN35Yc7kcL4vaJrkPhM1nz55ddXeX3KaerhMmD6RC3nrrLb5T/axrsDjXKfm6WwflfHKbjTfemLKIFVZY4Qs/+54GfH/XWmstev311+nLX/7yF36vu+PfWL1jcb7b2GbWrFlV78O/MVSKfNF1WJJ/Z4ZswzQWKWHQoEF8l/15SzJH+XkYO3YsPf/881X/4O+77z7+QVt33XWjbSZNmlT1PmyD9QCONWbMmKptgiDg524bvF4oFKq2Qd4UuWq3TT1dp2effZZzvy50izGi3A759OQ1AOlAeHZxrhNCvPjxS26DUDfyy8vqGixrLM5n39OA8sg33niDJ9DF+V53x7+xesfifLfxCAIGXYrD/fffz98XEPnu+ndmyDjSVo8avhhvv/02l7j99Kc/Dfv06cN/Y/n000+rSuF23nnn8Nlnn+XytkGDBi2yFO6EE05gxfsVV1yxyHJTKMCvu+46Vn8feuihXHKYVMKjLG+VVVYJ77//fi7LGzt2LC9p49FHH+WKEJz/G2+8Ef7xj3/ka/Dtb3+7SuGOMrgDDzyQy+Bwvrgmncvg8vl8+Mtf/pKvE6oJFlVuiuvy97//PXzuuefC3XffvUeUm37RZ59lHHfcceGDDz4YTp06lT9jlI2iXHTWrFmL9b3urn9jaQO/Ge73Az//KGPH3/iNWdzvNspNR48eHT7++OPhI488Eq655ppV5abd9e/MkF0YscgADjroIP4R6Lw88MAD0TZvvfVWuMsuu3C9OH4w8UNaKpWq9oPtN954Y/YrWG211bh8tTNQe48fWGyDEkTUqieBH5gf/ehHXE6GH4s999yTPQHSxpQpU7hcDeW4zc3N4TrrrBP+4he/CNva2qq2Q23+1ltvzZPoSiutxD+knXHLLbeEa621Fl8DlA/+4x//qHodZXmnnXYa/3hiPzvttFP46quvhlnHF332WQbKPocNG8bnhs8dz19//fUl+l5317+xNIHxLeq3BL8xi/vd/uijj5hI4CYH5bYHH3xwdJPTnf/ODNmFh/+kHTUxGAwGg8HQM2AaC4PBYDAYDN0GIxYGg8FgMBi6DUYsDAaDwWAwdBuMWBgMBoPBYOg2GLEwGAwGg8HQbTBiYTAYDAaDodtgxMJgMBgMBkO3wYiFwWAwGAyGboMRC4PBYDAYDEYsDAaDwWAw1B8sYmEwGAwGg4G6C/8PkuF11PQu/KAAAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots()\n", + "ax.set_aspect(\"equal\")\n", + "colors = firedrake.tripcolor(extract_surface(h), axes=ax)\n", + "fig.colorbar(colors);" + ] + }, + { + "cell_type": "markdown", + "id": "ea593b0b-c5f1-4d2a-a70a-f8537ab35167", + "metadata": {}, + "source": [ + "We can then compute the initial surface elevation and mass balance." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "0641ac14-e8e1-496b-9ffd-e376c7ae3974", + "metadata": {}, + "outputs": [], + "source": [ + "s = firedrake.Function(Q).interpolate(b + h)\n", + "a = firedrake.Function(Q).interpolate(smb(s))" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "4ec0e6ba-bff9-4493-88cc-cd9a88505224", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots()\n", + "ax.set_aspect(\"equal\")\n", + "colors = firedrake.tripcolor(extract_surface(a), vmin=-0.7, axes=ax)\n", + "fig.colorbar(colors);" + ] + }, + { + "cell_type": "markdown", + "id": "4b97c83c-e389-43ab-bdad-c0e194c1380b", + "metadata": {}, + "source": [ + "In order to calculate the material properties of the glacier, we'll assume that it's roughly temperate, which isn't too far off from the truth." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "e3b0b711-e898-4760-b326-807afae85a56", + "metadata": {}, + "outputs": [], + "source": [ + "from icepack2.constants import gravity, ice_density, glen_flow_law\n", + "A = icepack.rate_factor(Constant(273.15))" + ] + }, + { + "cell_type": "markdown", + "id": "bec1a763-ab01-4f63-ae93-d92f0ce0ef2a", + "metadata": {}, + "source": [ + "We'll use the shallow ice approximation, which diagnoses the velocity at a point in a purely local fashion using the thickness and surface slope, to initialize the ice velocity." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "1ec09854-3b85-43d0-84f9-6959508d4865", + "metadata": {}, + "outputs": [], + "source": [ + "V = firedrake.VectorFunctionSpace(mesh, cg1, dim=2, vfamily=\"R\", vdegree=0)\n", + "\n", + "u = firedrake.Function(V)\n", + "v = firedrake.TestFunction(V)\n", + "\n", + "ρ_I = Constant(ice_density)\n", + "g = Constant(gravity)\n", + "n = Constant(glen_flow_law)\n", + "\n", + "P = ρ_I * g * h\n", + "S_n = inner(grad(s), grad(s))**((n - 1) / 2)\n", + "u_shear = -2 * A * P ** n / (n + 2) * h * S_n * grad(s)\n", + "F = inner(u - u_shear, v) * dx\n", + "\n", + "solver_params = {\"snes_type\": \"ksponly\", \"ksp_type\": \"gmres\"}\n", + "fc_params = {\"quadrature_degree\": 6}\n", + "params = {\"solver_parameters\": solver_params, \"form_compiler_parameters\": fc_params}\n", + "firedrake.solve(F == 0, u, **params)" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "5a32887c-dcd3-4aae-844e-1a6c70b183db", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots()\n", + "ax.set_aspect(\"equal\")\n", + "colors = firedrake.tripcolor(extract_surface(u), axes=ax)\n", + "fig.colorbar(colors);" + ] + }, + { + "cell_type": "markdown", + "id": "9a900c91-a77f-4d7a-86e3-9c014512e3b9", + "metadata": {}, + "source": [ + "Now we'll get to the real modeling.\n", + "To proceed, we have to make function spaces to represent the membrane and basal stresses and create a variable that stores the velocity and stresses.\n", + "Here we use piecewise constant finite elements for the stresses.\n", + "In general, if you use $CG(k)$ elements for the velocity, you need to use $DG(k - 1)$ elements for the stresses." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "db935250-689e-4ca7-aee5-c5b0f212c4d4", + "metadata": {}, + "outputs": [], + "source": [ + "vfamily = \"DG\"\n", + "vdegree = 2\n", + "V = firedrake.VectorFunctionSpace(mesh, \"CG\", 2, dim=2, vfamily=vfamily, vdegree=vdegree)\n", + "Σx = firedrake.TensorFunctionSpace(mesh, \"DG\", 1, shape=(2, 2), symmetry=True, vfamily=vfamily, vdegree=max(0, vdegree - 1))\n", + "T = firedrake.VectorFunctionSpace(mesh, \"DG\", 1, dim=2, vfamily=vfamily, vdegree=max(0, vdegree - 1))\n", + "T0 = firedrake.VectorFunctionSpace(mesh, \"DG\", 1, dim=2, vfamily=\"R\", vdegree=0)\n", + "Z = V * Σx * T * T0\n", + "z = firedrake.Function(Z)\n", + "\n", + "u = firedrake.Function(V).interpolate(u)\n", + "z.sub(0).assign(u);" + ] + }, + { + "cell_type": "markdown", + "id": "1d649590-0970-42c5-9fa2-52d8bb325dbf", + "metadata": {}, + "source": [ + "This is a subtle but important point.\n", + "But we'll also want to regularize the momentum balance model a bit by pretending as if it were linear.\n", + "We chose some value of the ice fluidity $A$, which is fine, but remember that $A$ has units of strain rate $\\times$ stress${}^{-n}$ where $n \\approx 3$ is the Glen flow law exponent.\n", + "If we only change $n$ to 1 in the parts of the equation determining the constitutive relation but do nothing to $A$, the physical units that we use in the regularization will make no sense.\n", + "So what we do below is pick some arbitrary stress scale $\\tau_c$, which here I'm taking to be 0.1 MPa or 100 kPa.\n", + "We're then choosing a strain rate scale $\\dot\\varepsilon_c$ so that $A = \\dot\\varepsilon_c \\cdot\\tau_c^{-n}$.\n", + "If we want to pretend like ice flow were linear, we could produce the right constitutive relation by then using the flow law coefficient $A' = \\dot\\varepsilon_c\\cdot\\tau_c^{-1}$ and all the units would make sense." + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "cc16a5dd-3c51-453f-938c-895dd0963051", + "metadata": {}, + "outputs": [], + "source": [ + "τ_c = Constant(0.1)\n", + "ε_c = Constant(A * τ_c ** n)" + ] + }, + { + "cell_type": "markdown", + "id": "b16d9a32-7b64-4ce9-aa1e-cf38e900765e", + "metadata": {}, + "source": [ + "Now we're at the really important part.\n", + "To make the SSA model effectively do SIA, what we need is that, in the sliding law\n", + "$$K|\\tau|^{m - 1}\\tau = -u,$$\n", + "we take\n", + "$$K = \\frac{hA}{n + 2}.$$\n", + "Now in order to make our regularization approach work, we also define the sliding coefficient as\n", + "$$K = u_c / \\tau_c^m$$\n", + "where $\\tau_c$ is a reference stress and $u_c$ a reference speed.\n", + "We're using the same reference stress for the flow and sliding laws of $\\tau_c = $ 100 kPa, so we can then compute the reference speed as $u_c = K\\tau_c^m$.\n", + "We can then add more sliding on top of the effective deformation that we use to mimic SIA.\n", + "To add some extra real sliding, we've increased the critical speed $u_c$ by a factor of 100 m/yr." + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "1b9a1932-e82b-45ac-a353-07c6d0f2ab67", + "metadata": {}, + "outputs": [], + "source": [ + "K = h * A / (n + 2)\n", + "U_c = Constant(100)\n", + "u_c = K * τ_c ** n + U_c" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "f4bbe65a-e7ee-41e7-9742-9feda268c3cc", + "metadata": {}, + "outputs": [], + "source": [ + "rheology = {\n", + " \"flow_law_exponent\": n,\n", + " \"flow_law_coefficient\": ε_c / τ_c ** n,\n", + " \"sliding_exponent\": n,\n", + " \"sliding_coefficient\": u_c / τ_c ** n,\n", + "}\n", + "\n", + "u, M_x, M_z, τ_b = firedrake.split(z)\n", + "\n", + "# Clamp the thickness from below in the momentum model. The hybrid strain-rate\n", + "# terms divide by thickness, so the raw (compact) initial thickness -- which is\n", + "# exactly zero outside the ice cap -- makes the residual non-finite (NaN/Inf) at\n", + "# the very first evaluation, giving DIVERGED_FUNCTION_NANORINF. simulate_bp.py\n", + "# avoids this only because its input thickness is strictly positive everywhere.\n", + "h_min = Constant(1.0e-8)\n", + "h_safe = max_value(h_min, h)\n", + "h_safer = max_value(10.0, h)\n", + "\n", + "fields = {\n", + " \"velocity\": u,\n", + " \"membrane_stress_x\": M_x,\n", + " \"membrane_stress_z\": M_z,\n", + " \"basal_stress\": τ_b,\n", + " \"thickness\": h_safe,\n", + " \"surface\": s,\n", + "}\n", + "\n", + "L = hybrid.HybridModel(calving_terminus=None).action(**fields, **rheology)\n", + "F = derivative(L, z)" + ] + }, + { + "cell_type": "markdown", + "id": "9b8cdb6d-1b52-4e65-abd6-968b5eaf545a", + "metadata": {}, + "source": [ + "For the solution procedure, we'll want to use a linearization of the problem where the thickness is clamped from below." + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "46a2aff8-bee5-4d9d-8f16-b4424484bf14", + "metadata": {}, + "outputs": [], + "source": [ + "rfields = {\n", + " \"velocity\": u,\n", + " \"membrane_stress_x\": M_x,\n", + " \"membrane_stress_z\": M_z,\n", + " \"basal_stress\": τ_b,\n", + " \"thickness\": h_safer,\n", + " \"surface\": s,\n", + "}\n", + "\n", + "L_r = hybrid.HybridModel(calving_terminus=None).action(**rfields, **rheology)\n", + "F_r = derivative(L_r, z)\n", + "J_r = derivative(F_r, z)\n", + "\n", + "# Add a small amount of a *linearized* rheology to the Jacobian. The power-law\n", + "# (n = m = 3) Jacobian is singular wherever strain rates or basal stresses\n", + "# approach zero, which stalls Newton's method. Mixing in a linear term keeps\n", + "# the Jacobian well-conditioned, as in demos/kangerd/simulate_bp.py.\n", + "linear_rheology = {\n", + " \"flow_law_exponent\": 1,\n", + " \"flow_law_coefficient\": ε_c / τ_c,\n", + " \"sliding_exponent\": 1,\n", + " \"sliding_coefficient\": u_c / τ_c,\n", + "}\n", + "\n", + "α = Constant(0.01)\n", + "L_1 = hybrid.HybridModel(calving_terminus=None).action(**fields, **linear_rheology)\n", + "F_1 = derivative(L_1, z)\n", + "J_1 = derivative(F_1, z)\n", + "J = J_r + α * J_1" + ] + }, + { + "cell_type": "markdown", + "id": "4d91d056-05ff-4abb-a702-c1683b6a3718", + "metadata": {}, + "source": [ + "Observe below that, when we create the momentum balance problem, we want to find a zero of $F$ using a Newton-type method, but we're using the perturbation of $dF$ defined above in order to do the search." + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "a1042066-7992-4d32-8a1d-62a006a2de11", + "metadata": {}, + "outputs": [], + "source": [ + "degree = 1\n", + "qdegree = max(5, degree ** glen_flow_law)\n", + "pparams = {\"form_compiler_parameters\": {\"quadrature_degree\": qdegree}}\n", + "momentum_problem = firedrake.NonlinearVariationalProblem(F, z, J=J, **pparams)" + ] + }, + { + "cell_type": "markdown", + "id": "35f45cb5-f7b2-40d7-aced-514de7a1f8dc", + "metadata": {}, + "source": [ + "Now we can see our initial value of the velocity.\n", + "Note how it's a different magnitude but similar shape to the SIA velocity." + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "4040c1bb-a861-4697-b91b-f3ffc7ef04d9", + "metadata": {}, + "outputs": [], + "source": [ + "sparams = {\n", + " \"snes_monitor\": \":rainier-output.log\",\n", + " \"snes_type\": \"newtonls\",\n", + " \"snes_stol\": 1.0e-4,\n", + " \"snes_atol\": 1.0e-4,\n", + " \"snes_rtol\": 1.0e-4,\n", + " \"snes_max_it\": 2500,\n", + " \"snes_divergence_tolerance\": -1,\n", + " \"snes_linesearch_type\": \"nleqerr\",\n", + " \"ksp_type\": \"preonly\",\n", + " \"pc_type\": \"lu\",\n", + " \"pc_factor_mat_solver_type\": \"mumps\",\n", + "}\n", + "momentum_solver = firedrake.NonlinearVariationalSolver(momentum_problem, solver_parameters=sparams)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e618ec87-b03f-44a8-8f0d-84b7ba2f58d9", + "metadata": {}, + "outputs": [], + "source": [ + "num_continuation_steps = 5\n", + "for exponent in np.linspace(1.0, 3.0, num_continuation_steps):\n", + " n.assign(exponent)\n", + " momentum_solver.solve()\n", + "\n", + "# Drop the linear Jacobian regularization now that we have a good starting\n", + "# guess. With α = 0 the Jacobian is exact. \n", + "α.assign(0.0)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "27dea728-7c56-4a3c-83fb-87e7b32cc881", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAhEAAAGdCAYAAACsBCEsAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjksIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvJkbTWQAAAAlwSFlzAAAPYQAAD2EBqD+naQAA1OxJREFUeJzsvQe8JFWdPX4qdnhhAjmMiILkIKAIoqIi6PpzdXVddVUwh8WAGFbQP7CgYkLFNWBGV1kQXdFFJCwKiCACggICgqKgMMSZlzpUuv/P+d57u6vfvIGZeTOvX793D5bdXV1ddav6Td9T3+/5nq+nlFJwcHBwcHBwcFhP+Ov7AQcHBwcHBwcHRyIcHBwcHBwcNhguEuHg4ODg4OCwQXAkwsHBwcHBwWGD4EiEg4ODg4ODwwbBkQgHBwcHBweHDYIjEQ4ODg4ODg4bBEciHBwcHBwcHDYI4YZ9bPGhKArce++9GBkZged5/R6Og4ODg8N6gt6KExMT2HbbbeH7m+4eutVqIUmSWe8njmNUq1XMZzgSsY4ggVixYsWm/TYcHBwcHDY57rnnHmy//fabjEDsuMMwVj6Qz3pfW2+9Ne666655TSQciVhHMAJh//hGR0c35Xfi4ODg4LAJMD4+LjeD9vd8UyBJEiEQd12/A0ZHNjzaMT5RYMf9/yr7cyRiAcCmMEggHIlwcHBwGFzMRUp6dMSfFYkYFCz8M3RwcHBwcJhj5KqY9TIbfPzjHxeydMwxxzzqdueeey523XVXiXbstddeuOCCC9brOI5EODg4ODg4bGQUULNeNhTXXnstvvKVr2Dvvfd+1O2uuuoqvOpVr8Ib3/hG3HDDDXjJS14iy80337zOx3IkwsHBwcHBYSOj2Aj/bQgmJyfx6le/Gl/72tewbNmyR9329NNPx/Of/3y8//3vx2677YZTTjkF++23H77whS+s8/EciXBwcHBwcJjHYtDx0tJutx91+6OPPhovfOELcdhhhz3mvq+++uo1tjviiCNk/brCVWc4ODg4ODhsZORKyTKbzxPTrQVOPPFEnHTSSTN+5uyzz8Zvf/tbSWesC1auXImtttqqZx1fc/26wpEIBwcHBweHjYxilroG+9nptgKVSmXG7bndu9/9blxyySVzWhLqSISDg4ODg8M8xeg62gpcf/31eOCBB0TTYJHnOa644grRODANEgTBGmZW999/f886vub6dYXTRDg4ODg4OGxkFFDIZ7GsbxTjuc99Lm666SbceOONneWAAw4QkSWfTycQxEEHHYRLL720Zx0jGVy/rnCRCAcHBwcHh3mazlhX0IVzzz337Fk3NDSEzTbbrLP+yCOPxHbbbYdTTz1VXjP98axnPQunnXaaiDGpqbjuuuvw1a9+dZ2P6yIRDg4ODg4OiwB333037rvvvs7rgw8+GGeddZaQhn322Qc/+MEPcN55561BRh4NnmJbM4fHBEtrlixZgrGxMWd77eDg4DCAmIvf8XFzjD/euhVGZmF7PTFR4Em73T/v5xyXznBwcHBwcNjIKMwym88PAlw6w8HBQVAUhai5HRwcHNYVLhLh4LAA0G628ch9q/HAPQ9i/OEprFq5Go+sXCWPv7/iVizdagnYtzBpJUhaKR76+yMoCoUoCuQ112epJhBBGCCuRrLkGdd52Hz75YirsazzfA8P37sK+zxrDyzfeimWbb1UHoeXDmGrx28hr2tDc1en7uAwH5GbKovZfH4Q4EiEg8MAIEsz/P3Olfjb7ffintv+jj/+9s+45crbUBuuYtX9Y2hMNB/183/7473rfCwSh+Ykl1Zn3eTqqTW2u/fOtbvacVwkLq2pNnZ72s7Y5YCdsGLX7fC4XbfFNk/cGnElWufxODgMInKll9l8fhDgSISDwzxCY7KJP//ur/jbH+8TsnDP7X/HHdf/CQ/duwoDcmMiIAGxJOSq866VpQxGK3Y54IlYscu2Qi6232VbPH7PFRhZOtynETs4bFwUi0QT4UiEg0OfwMKou2/7O2799R247dd/xK3X3IE/3/TXgSILGwqmWX59/vWydOABj99jBXY78EkSvdj1wJ2xw+7bw/eddMvBYb7CkQgHhznC+CMTQhhu/fUfcdtv7sQtv7pNwv0OBgr4y833yPKzb2gXvbgWY4+Dd8FuB+6M3Z72JOx64E5YusUSd8kc5j0KeMhFibThnx8EOBLh4LAJdQy3/Op2XHvhDbjqJ9fib7ffJ9EHh3VH0kxww6U3yWKx7U5b4+kvfgoOeP6Tsechuzp9hcO8RKH0MpvPDwIciXBw2Ii4/68P4jc/uwHnff4C3H/PQ2i7SMNGBwWd5572v7JQoLnF4zbDP73rhXjK8/fFtk9c98ZBDg4Os4cjEQ4OswB9FX513m9w7YU3SrXEPbevexWEw+yRtFP8/Y6V+MI7v9GJUuz1jF2x32F745n/fBDCyP3EOfQH+SzTGbP57FzC/QtzcFhPMCVBPcMvzv4VfvnDX0uJpcP8iVJwuehbl+FL7/4WDnnp0/DsVz4dez5j1xm7GDo4bCrkjkQ4ODiUcft1f8Iv/vtK/PSrlzhB5ABg7KEJ+a64VOoxnv/65+A5r36GiDQ9bzDu8hwc5jtcJMLB4VFw54134eJvX4ZrfvrbRzVXcpjfaDcS/PiLF8qy9eO3wIEv3B/PO/JZ2OUpO/V7aA4LFIXyZJnN5wcBjkQ4OMxQVXHl/1yD879yCX532S3u+iwwrPzLgx1CweqO//fWw/GMlx0ott4ODhsLuUtnODgsLqz8ywP46vu/g99eehOmVjf6PRyHOcDNV94my+n/VpVeIG897Shsv/M27to7OKwjXCTCAYu9uuKa83+L879yMa6/+HfSlMph8aE50eo4aO532F4SnTjoHw9w1R0OG4wcviwb/vnBgCMRDosSzakWfva1S3HmiWfLBOLgYPHb/7tJlupQBa894eV44Vufh6HRurtADusFNUtNBD8/CHAkwmHRWU+f9/mfST58/OGJfg/HYR6DluRf+/fv4qyP/Q/+8d+OwEve9QIs32pZv4flMCDInSbCwWHh4IF7HsIPTvtf/ORLFyLPBqU/nsN8wNRYA/996o9wzid/jBe+5Xl4+ftehG123Krfw3JwmBdwkQiHBY07bvgzfvCZ83HF969Clg5KltFhPqLIC/zvly8S34lDXvpU/POxL5KOow4OMyFXviwbinxA5FmORDgs2MjDd078Pi468xf9HorDAiQTV5z7a1me+5pn4KiTXoFtnuAiEw5rduEsZiGsLNjWdgDgSITDgsLYQ+M4433fweXnXIW0nfZ7OA4LHJd+95fyt/b0lx6It512FDbfdnm/h+TgMKdwJMJhQaA52ZS0xTmfPE/cCR0c5gpMk5FIXHXeb/Dy9/4j/uX9/4ihJUPuC1jkyJ2w0sFh/iPPcnzzQ2fhojMvw9iD4/0ejsMiRtrOpJLjx1+6UCy13/LJ1yKKo34Py2FgNREKg4ANP0MHhz7jd5ffgrfv/wF8/1M/cQTCYd6AbqcsI37rPu/DdRf/rt/DcXDYpHDpDIeBw0N/fxinvubz+P3lf+j3UBwc1op7br8Xxz3/I9j1wJ1w3PfejW2fsLW7WotOWOnN6vNY7JGIK664Ai960Yuw7bbbSuvd8847r+d9pRROOOEEbLPNNqjVajjssMNwxx139GzzyCOP4NWvfjVGR0exdOlSvPGNb8Tk5GTPNr///e/xjGc8A9VqFStWrMAnP/nJNcZy7rnnYtddd5Vt9tprL1xwwQWb6KwdNhXSJMXZH/8RXvekdzkC4TAwuO2aO/Gm3d+D/zr5XLSb7X4Px2GOUBjb6w1dZlPZMZfYpKOcmprCPvvsgy9+8Yszvs/J/vOf/zzOOOMMXHPNNRgaGsIRRxyBVqtrQ0wCccstt+CSSy7B+eefL8TkLW95S+f98fFxHH744dhhhx1w/fXX41Of+hROOukkfPWrX+1sc9VVV+FVr3qVEJAbbrgBL3nJS2S5+eabN+XpO2xEXPK9K/C6nd+Fbxx/FtpNJ5x0GCykSYbvnPR9HLnT0fjp1/6v38NxcNho8BTDAXMARiJ+9KMfyeRN8LCMULz3ve/F+973Plk3NjaGrbbaCmeeeSZe+cpX4tZbb8Xuu++Oa6+9FgcccIBsc+GFF+If/uEf8Le//U0+/+Uvfxkf+tCHsHLlSsSxbuX7wQ9+UKIet912m7x+xSteIYSGJMTiaU97Gvbdd18hMOsCkpUlS5bIGBkVcZgbTI1N4Yxjv40Lv+X8HhwWDp776mfg3z73eoxuNtLvoSwqzMXv+Lg5xtk37o76SLDB+2lM5Hjlvn+Y93NO3+Ild911l0z8TGFY8MIfeOCBuPrqq+U1H5nCsASC4Pa+70vkwm7zzGc+s0MgCEYzbr/9dqxataqzTfk4dht7nJnQbrflj6G8OMwtzv/qJTjqSe90BMJhweHS7/1S0nI//Fz3xsZhYaEwKYnZLIOAvo2SBIJg5KEMvrbv8XHLLbfseT8MQyxfvrxnm5n2UT7G2rax78+EU089VUiNXai1cJgbsDHWqa85Hae/7asYe9A1yXJYmJhYNSlRtpNf/mk8slLf8DgsHOTKm/UyCBgMqtMHHHfccRJGsss999zT7yEtCvzo8xfg9bu+Cz8/68p+D8XBYU7wyx9eI3/zZ3+yV3ju4DAI6FuJ59Zb63Kn+++/X6ozLPiaWgW7zQMPPNDzuSzLpGLDfp6P/EwZ9vVjbWPfnwmVSkUWh7lBc6qFL73rmy514bAo0Rhv4Rsf/B7+ctPdeOcX3ugcLxcAclNlseGfd2ZTj4odd9xRJvFLL720s466A2odDjroIHnNx9WrV0vVhcXPf/5zFEUh2gm7DSs20rTbJ4GVHLvssguWLVvW2aZ8HLuNPY5Df3HdJb/Hm/Z4jyMQDose1Eq8cfdj8KufXLvor8Wgo1D+rJdBwCYdJf0cbrzxRlmsmJLP7777bqnWOOaYY/CRj3wEP/nJT3DTTTfhyCOPlIoLW8Gx22674fnPfz7e/OY34ze/+Q1+9atf4R3veIdUbnA74l//9V9FVMnyTZaCnnPOOTj99NNx7LHHdsbx7ne/W6o6TjvtNKnYYAnoddddJ/ty6B9YofP9T/0YH3rBR/DA3Q+5r8LBAcDD963Gf/zTp/DdU36APHft6x3WDaxU3HvvvaWSgwtvkn/2s5+tdXtWQXIeLi/0UZpX6QxO1M9+9rM7r+3EftRRR8kJfOADH5DSS/o+MOJwyCGHyGRfPpHvfe97Mtk/97nPlaqMl73sZeItYUHR48UXX4yjjz4a+++/PzbffHMxsCp7SRx88ME466yz8OEPfxjHH388dt55ZykB3XPPPTfl6Ts8Ch64+0Gc/PLP4PZr73TXycFhBoL97RPPwZU/ugYfPvsYbP+k7dw1GjDkc5zO2H777fHxj39c5jf5+/n2t/HiF79YvJH22GOPGT9DssFKRgsSiXnrEzHocD4RGw83/+o2nPDiT2LiEVd54eDwWKiP1nDiD9+P/Z67l7tYA+QT8ZXf7o/a8IbfpzcnM7x1v+tnNVZWMtKAkZH66eCNPLMBvIGfDQYj6eKwYEDHyfc9+0RHIBwc1hGN8Sb+/Xkn40vHfEvuMB0WF8an+RXRw+ixwDTY2WefLZH+R9P+UXJAt2daGDBqQUnA+sKRCIc5q7746L9+Tnpf5FnhrrqDwwaUP//HP39aXFwdFo/Z1IoVK3o8i+hhtDZQWzg8PCyVhW9729vEJZquzzOBxQff/OY38eMf/xjf/e53pWCBqX+6Qa8PXDpjHeHSGRuOO377Z3zklZ/FvXeu3dzLwcFh3bDl4zbH8f99DPY4aBd3yeZxOuML1x8463TGO/a/RjyKymN9NPuBJEmkcIHn94Mf/ABf//rXcfnll6+VSJTBCkcWM7DP1CmnnLLO43SRCIdNiht/cTPe88z/zxEIB4eNBFYyvf85/4FrL7zBXdNFgFFTbWGXR/MvYqXiTjvtJEUGjFiwASarFdcFURThyU9+Mu68c/3E7o5EOGwyfPcjP8AHjzgF7YbruungsDGRtlMc/w8fwzeO+567sPMUBbxZL7MeQ1Gsk4bC6iiYDimbP85rx0qHhQv+4X7tA9/FDz7zv/0eioPDgsbZnzgPjYmmdAQNwg3vGOmw8ZErX5bZfH59WzW84AUvwOMe9zhMTEyIrcFll12Giy66SN6nD9N2223X0VScfPLJ0s2akQtWaLCK469//Sve9KY3rddxHYlw2KhoNdoSfbjlV93aYwcHh02Hn3zpItx6zR/xqUtPwtBo3V3qBeMT4a/X9mwRQaJw3333iSaDxlMkEM973vPkfWol6LVkwS7XNHJkI0q6OzMFctVVV62TfqIMJ6xcRzhh5Tpco4cn8KEXfgy3/cYZSDk4zDWesPcOOPXCD2H51tru36G/wspPX3fIrIWV7zvgyk061o0Bp4lw2Cj42x334s17H+sIhINDn/Dn3/8Vb9nnvbjzxj+772AeoFDerJdBgCMRDrPGX265B+955gl45L7ZOZ85ODjMDmMPTuD9zz0Zf7z+T+5S9hmFSWds6GJ9IuY7BmOUDvMWvzrvGrzjwOOw+v6xfg/FwcGBLoSrpvDuQz6MS793hbseDpscTljpMCsPiI++6nNI25m7ig4O8whZO8On3vAljCwfwVNf8OR+D2dRophlO2/XCtxhQeOiM3+Bfz/8FEcgHBzmKfI0x4f/36k47wtrbwftsAmvP7xZL4MAl85wWG9c9ZNr8dm3nIEidz0wHBzmM9iw68vvOROXn3t1v4fisEDhSITDeuHi71yGk176KddEy8FhQECy/5FXfAY/+dKF/R7KokxnFLNYBgGDMUqHeYHf/OwGfPbNZ0AVrh2xg8Og4UvHnIkrf3RNv4exaJDPOqUxGHAkwmGd8NtLb8KHX3QqsnRQ/rQdHBzKyLMcJ//zabj6/OvdhXHYaHAkwuExcdMvb8WJL/6Ei0A4OCwAjcQpLz8N11/yu34PZcGjcOkMBweIac37D/sP6Ynh4OCwcDqA3nKV628zFw248lksg4DBGKVDX/D3O+/Dh154qpSKOTg4LCyx5f/3jx/HX/9wT7+HsmChZtkGnJ8fBDgS4TAjHlm5Ckc/5d+x+gHnROngsBAx8cgk3vG04/HAPQ/1eygOAwxHIhzWwNR4Q8KdU2NNd3UcHBYwWpMtHP+Cj2L8kYl+D2XBIXfpDIfFiCzN8G/7/zv+dONf+j0UBweHOcBf//A3vH2/DyBpJe56b0QUrounw2LE6W/7Ku7908p+D8PBwWEO8cDdD0mvDQeH9YVrwOXQwZePPRMXfusX7oo4OCxCXHb2r1AfqeE9X3lrv4eyIJCblt6z+fwgYDBG6bDJcdWPr8X/fO6n7ko7OCxiXPC1/8PP//vKfg9jQaBw6QyHxYI7b7wLp77m9H4Pw8HBYR7gtDd+CX/49R/7PQyHAYGLRCxyrH5wDO955gloTTkzKQcHByBppXj/c/8DD937iLscs0ABf9bLIGAwRumwSZDnOT76qs9JmZeDg4ODRdJMcMq/fEaqtRw28PdVebNeBgGORCxifPw1n8eNP7+538NwcHCYh/jDVbfj5H/+dL+H4TDP4UjEIgVbAl92zlX9HoaDg8M8xtX/ez1+ftYv+z2MgUThhJUOCxV/++O9+NTrv9jvYTg4OAwAPvuWr+Cum/7a72EMHNQsu3jy84OAwRilw0ZDu9nGMYd8GI1xZ2nt4ODw2GAH32OfdSKak+43Y32Qw5v1MghwJGKR4Svv/Q7GHnI++Q4ODuuOydVT+M93fsNdMoc14EjEIsJVP7kW/3vGxf0ehoODwwDikm9fjl+c/at+D2NgUKjZ6iIwEHAkYpGANd8fecVn+j0MBweHAcYnj/pP3P/XB/s9jIFAMUtNBJdBwGCM0mFWUErhk0d9AWnb1Xw7ODhsOLI0F3dbesw4OBCORCwCfOc/vo8bLr2p38NwcHBYALjlV7fjG8ed1e9hzHsU8Ga9DAIciVjguOvmu/HdU37Q72E4ODgsIJz76Z/g9uv+1O9hzGvkzrHSYdDBkCOb6WBABDoODg6DA/62OFtsBxeJWMA4+9TzcPu17m7BwcFh4+Oum+7Gd076vru0a4ETVjoMvCvld/7jnH4Pw8HBYQHj7E+chz//3rlZzgTRNcymxNNpIhz6WY1x2pu+jCJ3eQwHB4dN+FtT6N8aV63Rf3z5y1/G3nvvjdHRUVkOOugg/OxnP3vUz5x77rnYddddUa1Wsddee+GCCy5Y7+O6dMYCxI9OvwA3X3lbv4fh4OCwCPDH6/6E73/yx/0exryDmmVlBj+/Pth+++3x8Y9/HNdffz2uu+46POc5z8GLX/xi3HLLLTNuf9VVV+FVr3oV3vjGN+KGG27AS17yElluvnn9Ojt7iretDo+J8fFxLFmyBGNjY8Ly5ise+vvDeM2O/4Y8K/o9FAcHh0UCP/Bx5u2fxzZP2AqL/Xd83BzjZf93FKKheIP3k04l+OFh357VWJcvX45PfepTQhSm4xWveAWmpqZw/vnnd9Y97WlPw7777oszzjhjnY/hIhELDF9533ccgXBwcJhTFHmBL73nW+6qbwJhJUlJeWm323gsML109tlnC0lgWmMmXH311TjssMN61h1xxBGyfn3gSMQCwu8uuwWXnXNVv4fh4OCwCPHr/70e11zw234PY8FhxYoVEtmwy6mnnrrWbW+66SYMDw+jUqngbW97G370ox9h9913n3HblStXYquteiNHfM3164NwvbZ2mLfIsxwfeaXrjeHg4NA/fPy1n8f37/saojha9F9DYaosNhT2s/fcc09POoMEYW3YZZddcOONN0oK5Ac/+AGOOuooXH755WslEhsDLhKxQPDjL16I1Q+M93sYDg4OixiTq6bwg9O6OfbFjGIj2V7bagu7PBqJiOMYO+20E/bff3+JWOyzzz44/fTTZ9x26623xv3339+zjq+5fn3gSMQCwKoHxpzpi4ODw7zAWR/7IR7828P9HoYDgKIo1qqhoFbi0ksv7Vl3ySWXrFVDsTY4ErEA8Imj/hNTY41+D8PBwcEBrak2Pvbqme9+FxOK2RhNbUAq5LjjjsMVV1yBv/zlL6KN4OvLLrsMr371q+X9I488UtZZvPvd78aFF16I0047DbfddhtOOukkKQ19xzvesV7HdZqIAceffvcXXH/R7/o9DAcHB4cObv7lrbj1mjuw24E7L9qrUmwkTcS64oEHHhCicN9994kAk8ZTF110EZ73vOfJ+3fffTd8vxs3OPjgg3HWWWfhwx/+MI4//njsvPPOOO+887Dnnnuu13EdiRhwfOvD/93vITg4ODisgW8c9z18+ucnuSszR/jGN77xqO8zKjEdL3/5y2WZDVw6Y4Bx85W34pqfupIqBweH+Vlyfu1FN2KxopjjdEa/4EjEAOPU13y+30NwcHBwWCs+9fovSi+fxYjCkQiH+Yxfn389Hrj7oX4Pw8HBwWGtWLVyNS7/vjPAW8hwkYgBLdv55ofO6vcwHBwcHB4TZ55wjpjhLTaoWXpFDEr8xpGIAcRFZ16Gu266u9/DcHAwP5UODmvH3++4Dz/58kWL7hIVLp3hMF+jEF9575n9HobDvICaB8cfDPGXQ/8rNbI0W1RfQ+FIxNyABhee5/Usu+66a+f9VquFo48+Gptttpk0FnnZy162hlUn619f+MIXol6vY8stt8T73/9+ZFm2RnnLfvvtJ5ahtAU988zBnIh/+YNfY2qs2e9hOMwLeCUe4ZWWOYCI5aYfa9oY+s1xHOYN2o0El37vl/0ehsNCTWfsscceYpBhlyuvvLLz3nve8x787//+L84991xpJHLvvffipS99aU/LUxKIJElw1VVX4dvf/rYQhBNOOKGzzV133SXbPPvZz5bmJMcccwze9KY3iRHHoOGcT57X7yE4zCeU5/H15hDlSd9bPwLhzbD99N10njs24QB8/1M/XlSVGsUiiUTMC7OpMAxnbPrBTmQ00KCr1nOe8xxZ961vfQu77bYbfv3rX+NpT3saLr74YvzhD3/A//3f/0kb03333RennHIK/v3f/12iHGxIcsYZZ2DHHXcUe0+CnydR+exnPyv90wcFV59/Pe747V39HobDvEwVKKDzo+P1frQo1pj0Ze8y6c8465c25H6n/fCvQSAeJfKwNsLhsOhw961/x2Xn/ArPfuUhWAwo5tixclFHIu644w5su+22eMITniA+30xPENdffz3SNMVhhx3W2Zapjsc97nG4+uqr5TUf99prr56+6CQG4+PjuOWWWzrblPdht7H7mAlsWsJ9lJd+44xjBzMF47CxUhWPsq1XWsTathRh4Ovy+yZt2P14bzpR3rPvlz/X89ovLaX314lAuJTHYsVX3/9f/R6Cw0IjEQceeKCkH9gI5Mtf/rKkHp7xjGdgYmICK1eulEjC0qVLez5DwsD3CD6WCYR93773aNuQGDSbM+sL2EaV/uN2WbFiBfqJ26+9E/feqc/HYZFgjSBBiRj0TOrTNy6tN9GGHtLQ2WQaaZhGMmQp7dfzfbPt9EzImp/vjKHnBOzYZzrHxRPmXsx46O+PiJPlYoBS3qyXQUDf0xkveMELOs/ZMISkYocddsD3v/991Gq1vo2L3c6OPfbYzmsSjn4SibM/4bQQizpdMaOO0UQrZogqmBcmzWHfMq+7G/c+ty9lk+52vQTE0IqeY5Q/Zg/G+5Ni5lTHGnzBVXksJpz9iR9hn0P3wEJHYfweZvP5QUDfIxHTwajDk570JNx5552ik6BgcvXq1T3bsDrDaij4OL1aw75+rG1GR0fXSlRYxcH3y0u/8Oeb/oorf3RN347vsAnAefPR0hUdHYK98592l2/f9Q0xWGvGY9rnbWqjc9hSZKMnNWEeA/MZu9jt1nZA+RiJjD1A6RQ5VhnvDB9a47VZXIBiweG6i36HP/z69n4Pw2GhkojJyUn86U9/wjbbbIP9998fURTh0ksv7bx/++23i2bioIMOktd8ZO90tkG1uOSSS2TS33333TvblPdht7H7mO8466M/dD+mCxHTAwOPuqF9nD7Zdyft7uQ9DVEEVGKgyqUC1KpQtYpZV5XX3aXWfV6vAUN1gNtW7RIDcTQjGbBjsMPtTZN0iYcqE5VHg2gq1uX6OAwavnvyD7HQUbjqjLnB+973PrzoRS+SFAbLN0888UQEQYBXvepVokV44xvfKGmF5cuXCzF45zvfKZM/KzOIww8/XMjCa1/7Wnzyk58U/QP7o9NbgtEE4m1vexu+8IUv4AMf+ADe8IY34Oc//7mkS376059ivqM51cK1Fy7eTngLHl45nN+dgDW3KKUmOoSh9EEbrShHCSwp6UQQAiA073cmZUM2uC4rulUadudK6Yk+CABVsI66m+Kw+88j/koCRa4fA9+8LnqW3tTHtLGX18+U4ujRSzg2sZBw0xV/wOTqKQwvHcJChZqlrsFpItYRf/vb34QwPPzww9hiiy1wyCGHSPkmnxMsw/R9X0ymWDHBqoovfelLnc+TcJx//vl4+9vfLuRiaGgIRx11FE4++eTONizvJGGg58Tpp5+O7bffHl//+tcHorzzF//9KzTGnbnUYOIxJr/O2/ZuvZzGsJxAlbQM0/ZlyQMn8GnPPU7ohhioKATCwBzTlHsKiQj0+0nWM9kr3xAIOWyJRMjEr8mIl2SaKCCE4jG5AR0J8xKJ4Otp5aHlLM2M8oyeFI/N+TgCsdDQarRxyXcuxz+96x/6PRSHWcJTi8n9YxagsJKREXpXzKU+4i37vNf1yRhklIlCZ0W5/FFP6KocdZA7fkseDMrhfxsliC05UL26hTDUN/JseuSXSIRNQdiIhBAFQwpkwjfrSApsUKNMIux48gJeO9W7suSEpIEusZ0oBKMSSq/L+Jr7sOfePcfeHx9DYjgeHndmNWnvdXQYWGy389Y48/b/XHC/4+PmGAf8zzEIh3Q0fEOQTbVx3Us/N+dzzsBVZzisHbdfd6cjEIOOtQQRetMLJY1j5xV6CYOkFkgWzGshCyQSUTeCUV7PR4kG5KKJ8OJQRxjCQDypFFMcgQfPNFeU6byVwfd0BMJGYZUq4JFEiKYB8Bhp8E3VRRhIr0GZznksSWkYEkGQPMh4iu7YOR6+z33mOe9iuue5phPWmkZXPdv0PHEYMPz9jpX4/eW3YO9nLcxKDeXSGQ79xvlnXNLvIThsDJQnu2kRBUlXmPVreDPZqAInZ0skQh9ebiIPJAQUTYrmwdN3/r6vIw9RgIK6CIGS1yr0JPWgAg9ZzZfXfquAL0RCAUsYwdC6B48/gEI2zDaZgkf9RF5A5QX8iASiN3KCwKQzLIFppzqawoiD1Ux4qSYQUqnhA6mOaPS25CgJQ8plqR0+YcmXIxCDjvO/esmCJhGF00Q49AtTY1NiEeswKFjLhGYbVZVDDWZiJXyTTlgDJAysipA7/hKJIEHg53mXz4mZJIIEISah8JHXQqjIg5dwUldQPpBUlczvnNBJIEgMsjrTHD7UqI+gVcDLpmkXQg951dfDThXCBiMHJCCFuD9EDcBPFYKE5ALwKKJMTbEXyQLJRCk9woiDEvttpkN8vZh0i2gnTPSiZG0F5Vkh50wpDEcgFgKu/OE1WP25MSzdYkm/h+KwgXDpjHmKi79zOVpT7X4Pw2Fd0REMTpvwelIUpYnP3mFbcsG3OKHyOYmCaB5iIQh6MjZEIqKQ0WgZihxquAoV+ygiD0XkI637KBhlgBJyQBKR1oCEu+SEDx2ByOr6kVUY6agPv6mjDUQR+iiqphqE+gTO8YGPIjAREG5HLkNOwMxERTtZBpM54vEcQSuHlxQ9aRshECQWRB7oaETMFEqiz4uveTEkzUECUnSiIWtXZpbhtBKDiDTJcNG3foFXfOAlWGhQvTrpDfr8IMCRiHmK7578g34PwWF9YbUJnZRFmTSY/ys7Stq7bElTBKJZ8MoCSQonGWmQ6gc9IatajKISQlV85JzBmbIINIFQsYd0yBMCwPRBslRHGdIaow4eUk9J9ICTM7cTXYQVUI4ECJos7YQmEJ2MgY56+HXt9cBDahKhNIFgtEJRW6GQc38RZwYfha8QToWIpgoEbeokdBRDpBVCGCKtj5DUTKE9K3jtWPXB9zOjmVjbj+oMTcWcr8Rg4qyP/c+CJBGFJPwWvmOlIxHzEHff9neMPzzR72E4rA/KLpAyA0sN5WN/hiJI0T0E8PicUQhj1KRCpiq0vkFVImTDEfKaL0RAhUBW8ZHVtbs0f6wYkUiHGEVg1ECLJ9VSX7dfDj29LtApiCLWaY2uL4WHtKa36wZRFAo5F5IHLcJkVIIRiyKG7EMIRKbg5x58EggGSAJNMEhqVC2Q8fotiLYiSIw2QqISnqRBlJhnkXxkvREZIRszXjhdntqjlXDGVIMKlrD/8fo/4Un7P7HfQ3HYADgSMQ9x2dlOCzHYKNlGm3imjT703E0zAkFXSK410QghFIw+8E6b5GG4iqIWyoSd1QOkw5ogBEkhfk8ZX0daVMmJW96v8q6faQlGJDjZK4ATflBo/SXn8UQHGTyP9EHBZ5TCK7SinGvkTaBSTZBnoV5feMgLD1nmwWsaAkFZQ250ERxPna812RBhJotHWJCxBQWhQDgWorI6hd80lRl+zdhRmFQHr0Vm7bGplzBCzE4wx9SD2CiOXGPbo2NQAsAOM/3mLTQSoVx1hkO/cNn3r3IXfyDRTV907SFK2gf7mnfeNuogHg6mKkLW6bLNohohDzn5BygqnugO0iEgG/KQxx7aFCtmSl6LCJJEgoSBk2/kQfmsyCjgRQr1ehtK+foG31d6qSv4fg5V6DJNY0htxq5FjVGcyefSpBCVOUmELPSVYjolC1Ckniwi4oQPP6G+gkJOXfqZVyEkh8RCIijw4fkRvLYPv+UhHiu0MRbFG50QiBGMem2drhGdBKMXufGb6O0ESl2H9pVwGFRcfu7VePMnXztjt9lBRUGSPYvqjNlUdswlXCRinuHmX92Ke277e7+H4bAB0MWaeoLTesk1tQ8eSULZjtp6PbD0kumDEUYeYrmDz2oQwkA+kFeoY/A7kYeCwYqQk7QH1ACvUiCQNILWNYRMW4QFAr9AXEkReDnyPOgSCa9AFGUyvCwLO0RCQAJR0S6Wee4jIdkQEsHUCD+fI0krKIoMOcMaKCjXRJrFKBityD2kbR85f118X9IfQaJJhLXUpjg0nPJQ1KidUAgaJjLBa0Z9RGJLQc31arVMRQfTJ9PSHPZzzjdvYPHA3Q/hNz/7LQ78h/37PRSH9YQjEfMMV/zg1/0egsMGQUuodARi2h2ENYwigWDUQSIOkS57lPRFAFQi5PUYyWY0hWI6QElqgJUT8pqGkEOeLExTkEhksUJQUwgiEogCYZDLYxSlWtTFiomgQByniMIcviqQkUjIzb4SEkGikTFFkYZCBDy/QBSbSgm5+fcR+oVEIBgwCMMcGaMaiWe0jQqBr5CmAfy23j73A2S+Qrac9aUeVMpoiYIvKQ6SoUB0GdqPgpEKAMtCxA8HCJtd62wvjqBIICQSwXIQ43rZQyKmV2u4lMag4pc/vGZBkQhl7FNm8/lBgCMR8wxX//jafg/BYV1RcodiVYXYNZfTGPZ9LuL5wH9xhkhUOEEGMtEXwxXk9RCFCCV5d+6jkI8XEnnIWcJJUSQj+yzNjBS8WoFaNUG9nkDlPnxfCWEQMhGliKIcKUsp4aFSSRCRYPhMJrSRZbokM44TIRckFNQ6pGkoBEIXmXRJBCMR3E8Q5BJzSHNWkZAXkaqwfNNHyMgC90MSwYURiaov5CJthciaRjxZDxE1FQqSCJEykEjpCE424qP6gI9oLIVH0kBHTEZW6EfFa1b22WhT1GGIiNVJCIyY1aU3Bg6/ueC3yHMSYWOlPuBQThPhMNf4w6//iJV/edBd+EFA2V5SJjFLJGzpoWlWxUXSFSFQjbr21MZMKqUIsmJ0D1VPSALdJPOK1jcwjZGzvHIYIoz0ggxxlCOMCoRhhlo1lcmdkQId8NCRCJKBuqckylCtpKhEmUQUmNbgY9VPEUChrUL5HKMQea6QSo2mSVBICwwPcRQKSSFlYPoizElMdCqEBIIpjNAPhKSQQDBC4QcKjVaMIAyF0HijCmkSIssCZG0fmKRo0kM2HEg0ImjrGIImTSHCCQ/ReK5NrFQBxXJXCi553egtYb8DMaqiVkJrKYRQGHLhMFhYdf8YfnfZH7Dfc/fq91Ac1gMuEjGP8H/fubzfQ3BYB0jEwRKHUhMt/WCIRaBNoaRs07o2ikV1IJ8vltZR1EPkTP+P6ioHEgl6OkjKoqLTFWrEQ1DNETLCEPIujSkIiiJ5iEyqJ/hewGgBhVyeQq3WQjVOEQeaOHCylbYZHkmEXob8NmKfqQkPrSLSww9KwkoAVS+V6EJSBBjPq8hUIKkM5jWm8irSIkBR8Hw8ZD7HpvQEzgxE4SNXnozNq+kITWMqRhCEyMJAhKJtL4RfePBZchpqA/A2XTF9HxWWmsYBwvEcPitPyG3iGKrZ6qR/kBgykRj/iR67bOsE6tjEIOHS716xYEiEcpEIh7nGxf/lSMQgwBKHjnCS1QHlsk6jgfDEeZKRiFhvayoymL5obRXqua5QontgyoJlkXnNk0V8HGKgMpzILhh1IIngY7WW2I4bqFS13qESJahGKWpBG0NBgoTEwFMIUWAoaAktIAkgkeBSFxKh0xGc7JsFxZUaHFfNzxAw1UD/CN+Xz7BAIvYy2c9U0ZbHtgrkWO0oQDuLZPu8CExaw4NfZ1TAk0qOPGNKhJUbBVI/QLFMIZ9kFYaEQvRnK4EYZIVTPjIoJEM+Kg/7iKa00NJrB1C1sKuNIPng2K1OYnpDL+sh4TAQ+MU5v8J7v/F2+GTJA47CVWc4zCXuuvlutJ3N9UCgp3zTpC46VYeMUMShjjrYjpq8a5b1EYqRWAyjsqqPfEjrKJi6SIcDZDRtZOUFqy3qOaq1DENDTfFw4N5JFnQKI0EY5TKO4VoLtTBFxc8R+RlqXoKRoI0gmETCQKPyMBQ0EXu6wiJVIUI/7yERYipFB+qCJAA61WHak/N1qgJEyGQfTHMkhS8EI1dMggAVP0OOAONpFWN5Dc08FkLhBVpLQQKRBTlydgUPCqRBKDqNMKwgjQskrVAyEmk7QDihSzXzukI2rIlaPhSgfq+HYDyBX6tozQarN0wbcrnupgeHxDyE1DEqYnQptAd3vT4HAmkrxR+v+xN2ferOGHQoJ6x0mEtcd+GN7oLPCzz2dGPLOPkrIREGT0+mOseghZOqVtVTsIlKqKEqshrLObXPg6Qr6lp8mFO7wBTGUg9BnIsIMo51+iKuZKjEbNGtKyRIHobqLQxV2zJ5V5DA83whEIwS1P0Ew0EbkZeL/oHRgthLUZHXnFiBRAUYCnpJBE8nKVoIxXTK+P6bd5jyWMLJHD4ou0y8QPbFSEeEHBmY5uB5KyEoOTt/xgUezkYxmVXFbjsgiaLQMlOoem2pEilY5UF9RrWNNImQVCKkcaC1D5uzP4iHsEV1pycmWmk1Qu0Bpn5YqpJpMy4hDDbywGhO1hVcCpHQ30Gn5fgsv3uHTY9rL7xxQZCIxQKniZgnuPYiRyLmB9Y+idgUQicCwRLNsiOl8XzwrAaCJYq8yx+tIR+ibbUWSnKWZvRBBJRVD1kFUEuVlGKSOERMXcSFTLBxlKFSYcqCgsoUS6tTqAYsV/AR+xmW+A3ROHCCj0yaYjhoCYlgCoKPVEhW/UzeDyUioYWTFEJ2SYTWMpRtsLkwHRKgEC1EBl/IQrMIUFeJEAm+TmlIpWhaZQWbBdoFS1UDjEQtTOUxJtNY9kt/zpxpkEQhyxNUxTETmJw02SC/QLI0hMqY1jA1oG2FxlYBKmNAO6dBVQafHUPpJ0FDLmuVLS6XRmxptCvrl8pwBGI+4LqLbsRrT3g5FkYkwpvV5wcBjkTMAzQmm/jd5bf0exgOj4aO7sG8NOs6HhCsHqhWtKDPpyujCBmg6jFaW8XS1MrLCrR4h82qB9pYG+0DhgshCmGoDaBYfTE01JA79biSoF5rY7ii0xYjflMiDfx9KVQghIH6Bd9EHWpeipGAEQVNGPjIFEfECIPYW+tKDG3s1BWCTncK5ATMZAFTKYxE5GAqg86VjHZQjJki9zSpsIJLpjzYB4OvW3mE3KNeIsCo34BfAR6q1PFwexQtmlIphZERTQDSJBCyZK+wWgokk8zteCg8XRUSJj6iRiHVK1NLKqj9DQjZLbSZQFF7wugFL0qkoGykovS9dUtA1WD9Qi9C3PrrOzD20DiWbD6KQYaaY2Hlqaeeiv/5n//BbbfdhlqthoMPPhif+MQnsMsuu6z1M2eeeSZe//rX96yrVCpo0dxtHeFIxDzATZf/AUXmbHvnXenmGk6UXe+HTmUGVY+sFuAjP1bj3TF7TUAIRD4civtkuoReDz4ylmwOsbiyEEdK1BUqQwlGhptyLAoPhUjEmThNVsIUw9VE7vBZLUECwaXipzIfMoVR81PRK8ReIpN53c+EPPC92CtQsXxHNwKH73mmWkNhbS2upDmo7u0Fxj04kVM3UdBfwitkLJymE+XLQpkoz69RRGgVMUJk4nXBUk9elzb1Fkx3AJgIY0wGVSR5jJyeFVBSMqqzQTm8IJLr0CI5YMloFMCbKLT196i20PaKGPV7M3jtTJM4+V7Mz1lFwaMbKCMSGVuI2e9UQha6L8lM5lQzfPcOcw8S2N9e8ns8+1WHuMu/Hrj88stx9NFH4ylPeQqyLMPxxx+Pww8/HH/4wx8wNDS01s+Njo7i9ttv77xeX+txRyLmSQ7QYZ6gbBJlV63RC8MYOrJ1t+nAKWZInAWpkwgCFCQQ1UD0D6yKZBpD0hchkNL3YZkPP2CqgtGHHJU4F7EhvRk4gQ7Vm1hSa0oUgakITvokEsN+CyO+0UN4okbAcJBINCJm6F90GtQg6OwEF66Xnpdm6CQSfM0qSj7Ppt2pMzHBHwbpfWH2wak4tyJSRg90M2+ttUCBlFEDKAz5OVLVxuo8Rq1IddmmihBzTyxtDXwsC6cwHlTxcDaMSa8KVShU4kBSNtKjY1ITi2qthcZUHWkUIGsCza1CIRBhs5Br314SIM4qCOg7QZLSbknqRkZvvjQlncZK1uPmOqyhkXAEYl7h+gVAItQs64LW97MXXnjhGlGGLbfcEtdffz2e+cxnrvVzJA1bb731Bo7SkYh5AaeHmGcoTZZaONltq0URY8+/chpJ8Y5ZbqN1KiMbrSAfCVEEWkBJm+qM6QvqH6oe1HLqH3IJ4Udxom0kKKKkqDJKsaQ+ic3ihlQ/VP0Em0dTnTmO5ZuMROgoQ4Yhv4UK3Spt9IARBpOGUCUSIV2/u0xI1nMdP1cpEQkWetom25pEcFsSBHvOJBOqQyysPUPADEKHdCgsCVoSHUkRIiyMNgNKhJ9cxzTH8mgKNT/BKn9Iczd4aLYqOoUzlCNpRcgkzaHQHo3EPjtoMhekm3qxuqUdRKis8uFPtHQqSdwOTYrJT+GxC2hJL0kzsG5aqpTicBGIeYXrLh78GyvVZ5+IsbExeVy+fPmjbjc5OYkddtgBRVFgv/32w8c+9jHsscce63wcF4noM+7900rce+fKfg9jEWMtivxpnSK7k5CZcGjJzDJOvhGG8CjyMxGIdFmEZFmgBZPSnFJ32qStdVFRqFfbwjmYtqgybVHVgkreeS+pUvPQwrKwgcjL0C4CDHlt0UNwKudkTKMoPnJCrrPXhSEGQiQMcahIUIRJE4CSRk0sKKfUhlScSPk5raXUJ8cjWMPhLomwRtJd4sBCSiZk9KmZ3p+GkHD7nI1EKbL0ErRUhoYXIS4SqSRpI0YzjzAVRAhVgc3CSWwZTeCecBnGkmFkeYrR0Uy6i+apL2JSIl8CZOMxPO58AkiWBvDYgjwPkC4NMHIH25zzoubiH6FoRJVk4tGBVrv73c3oG7G2H2tXrdEvPHzvKtx101+x4147YLFjfHx8Dc0Cl0cDCcExxxyDpz/96dhzzz3Xuh31Et/85jex9957C+n49Kc/LVqKW265Bdtvv/06jc+RiD7jgq9f2u8hLHKsZQKhIM9o9XoSG/yfbePNfhjiQkmXRQ+oR8hG2V5Tc5Ci2rWwZhuLvKZQGc2kNbd03OTEG+YYHmqI++SSWgt1ah/8DHWmKDx6KeQd3cMoqy6QIWLVBssrPYWYeoIO39ERBk7m1U6xgq6zqJhSSOniaaIL009dRyB6J1jqIHgcvqM1EZpAVEoEgkRFzteQCG6b2epW6idUW7bNggQTBUlBDSNMcXhTEpWgP8XyYkrKQz2PRCKU9uNBEIt9ty89OmK0PWowIiSbB8hbkOoNGlMFqYf2ZhGqD+vu4UpahjMvZK4GUx3UR4gluf3OtZGWnJoZ8zr/bTjMCX7y5Yvw7i+9BYs9n7FixYqe1SeeeCJOOumkR/0otRE333wzrrzyykfd7qCDDpLFggRit912w1e+8hWccsop6zRMRyL6jL//8d5+D8GhB2U769Kc0zE1sp04zT+d0NhZRyHayyK0N9M6iCJSyNnOu+pJZUZeA+JR7flAAjE83JQUBdMOI/UWhuMWRv2mhOQZ4q95LQwFJBSp3MEvDVuoGK1DYG2sqUsQIuFpfwdGHjxfEwtGC3Q/cqmEsMLK7lnq12vek/dOnGI6ZSIaulKCx/egmC4xxMGmA8RaShUiqGR1pjTXMi1E2qaCdKmXSLqDeg5LIPiZuh/L+fsosDodRpHHku4JgwxpGqGQZmKAWuIhnWAESI/cT0gc2FvDQzIaIH6YDcV8oFaFYlRCohBsGMaOotr10gotdXrHRidcF9D5hnv/dD8GGmp26QwrYrrnnntE/GjxWFGId7zjHTj//PNxxRVXrHM0wSKKIjz5yU/GnXfeuc6fcSSiz/jz7//a7yEsbqwhqCvFHspdI+kJQSElIxCdfhisCuCs6iMfrUjPBxFRShMtmkmxKyfgL89Rr1L7UCAO2eeiEDIRhSmWDk9ii3gSiQqxhM6SPic5TyIPjERwsh1lNYbRNejFQ4XlliYSwSpROlJErCqlrkEaf2mhowzPsyoHXWVi6RGJkhWNzhThn/7zx9cUXZJAdLplmg/SM4LH45hoj00iIeoEdh4taSq4jyGZ+VmxwR4g2mtjm3gcE3kVI0WKyJvAI6izA5lst3p1IB4aTMNYd3FeL0/KRhSSpT6yYSCgAF1VRCMhJZ60wraVG2ZRjFBoltj9rtfW8dOJLfuKv9x8DwYZaiM5VpJAlEnE2rdXeOc734kf/ehHuOyyy7Djjjuu9zHZRfWmm27CP/zDP6zzZxyJ6CNYCz3wbHshV2PY9eX3SSI6REIL+bJlNTFIKmhtwAmTlYmSymAVBqTjJsPyoyNN03FT98JYMtzAcJhgSdiSkkgegWJD3o2TROiURophlm+aOVtIhKQrtO8D/2Oxh67G6JIE+9idvE13y06vsE7T8lK0xf7iTS9xtS3Orby0u409JiMhGYqOsFI+Y6ITTG3kJu4hCQZKF1SCKZpls58HMjQVDaoicdJcHk5i82gCdwVbYKxZk+oVRYtt3tmZH9diVEn1SyMOEU8phBM5gqaPdJkRjT7IMg5DICxZ4HfIaIScRNcvwlVrzE88ct8q3P/XB7HVDlv0eygDgaOPPhpnnXUWfvzjH2NkZAQrV2qt3ZIlS8Q3gjjyyCOx3XbbiacEcfLJJ+NpT3sadtppJ6xevRqf+tSn8Ne//hVvetOb1vm4jkT02VTFYR5WY3STGuZtM6naFEYUiRslDaZUNUZWD5CNBGJjzSWtAimrMDZTQh4ipjCkTbaHei2TCoyRehO1wOob6P/AThepaCJYcaFLO3MTgVAgHxEho0zYmkxUzQitzqFLHbrP9YRu1pREHl0KMYMjZ8+63vhFVzPRPaKFL5RCl5hyrLpzhj4YxZ2+YkmoQtNEAob9DEMokPgZVucKY14F20SrxUabLpdLoiayzEMrrog2pFLx0GiaUC5bZQRA2w+R0mgqZ2VMgJyGVLGP4QYjPsbHI+OGKVSa6kgSiYT5ToXsdNIZrlpjvuHWX/9xYEmEmuPqjC9/+cvyeOihh/as/9a3voXXve518vzuu+/uaW62atUqvPnNbxbCsWzZMuy///646qqrsPvuu6/zcR2J6CMu/s5l/Ty8w9ri90ZLUBbgiZ212CybDpLGqbIYCmXSZOlgHrO1NzUQrMLwEMdtMY3qtPE2FRNLRxpyx029AyMN2q6apCHBkNfCUva+YJBDSi61KRQrKaSaQunnFE7qduSaGJhGmF0K0dFx8IesFEWQzQ2xMHIALY7Uegf7eRFeQiGlc6XnT6Mm3YjGtCsoCBBIJQi1G1IGKj+G1EEw3aEjE76JoDRMdGREtbB15ItOolnEaOUh6tRP1PQln2hVMTlVleyEjkwYHwilkFRiaUlORXrB6o0Gzb0C+GkhXVKRF/L9dCITbNQlhlNWDzEdTlA5X3DRmZfh0Fc8HQMJxX9ss9dErPPm65A7YZqjjM9+9rOyzAaORPQRq1au7ufhFydmzHPrSU5PytMd24yhlK3IIJkw6Yx0WSz5eGmiFTOFr3R3TpZ21pRUFbASo1ZNEfi5VGBsuWwM21VW6wZZ7EshYslcHCipfxgJdOtv6gkiz0PV0wkJtoig7oHkgc2sWM7YuYvueEB0p/lyhCAzE3WnksJ4QhSKfTEskSjHGDR0pYU2nuqSC/2BSDQVpcvavVrmKFpzoQ2veI5aK0FSQg0Hj5uyf4chOWwGVkcbLXpAiAq0JumcimJn0hbuU0vRaMaoVVuIogDVqo9WO0Y+XoOqC0+AV3jw6SNBY6yqh5RCy0fyjgFYJ7PBrqoisixseKcjjZieyHnsvx2HTYmxB7XXgcP8hSMRfQLvmpyosg+YcRLoTg5WGtAhEtIDw5gY2T4Z0qWzImZSon0YooCSjzSTopAyw8hQG3GFlQIKPj0gqgmG601Uo1R6WiwJm1KFUUUizbNqSE1VBomCnrwYcZB0BkWTQiBIHmyawkQhzLZcX54CdZMtXWqZcFItTMfRUuUZyYXtp2HX2w9nJUqgpZ6l+gVVSEUIHa0p8rRbdgmJTaLod0SvoXIxqWJsYpi6ERI2Egqzb4mi+FoXQvfLLcIJZKqBporRKGKpYmkvidBoV5CkoRCIosloT45iJEErq8BnnoSRDvYkYZOzMICfRPpHLswAMZ5i9EEoEEAvCYovzVh69bUz3NU5AjHn+Osf/oY0SRExfThgUK4VuMOm/sfRGNf9Ehz6he6k2qMGKEckrK216cwp24cB8uEIigYNjJazHwbLOCs+1FK269ZVB7VKgkqVrpSZ3EFvXRlH7KeS6wzYWVP8H6h7aKIetMUyWvQP3aGJjmDItOUw5plmiF1NAks4rYqDjgriDWlSCYUhEakJ/Vt/iMKQCP7HtAM1Flq02CUQVksRlkgEj8U0C8EoQlvxKDS3YhJDazDs1SSx6RITHZXg9M2URm5KRTk1MErRFicIYFSqU3TDsCb9HQofCdgpNBTRaVb4yIsAWepJWoMoaAsx4iGlRiUMEE15CBse/DQXrYrfLqSMVLy6+T2Kh4SoW6W6o2MgZstUeko+7V+IQz+QtFL86ca/DGZrcDXHvtd9gotE9AlOVNkn9ISky1ZSJQU/wQmQE7Ut52Q0gs/DQGytsxFGH0wnTmr3GD5f6iGuUDjJ8k39C0Cfg0qcYiSmkVQbo2FLHCepf6h6bemFwVTGMJ0npURTayA0P1EYZhDERhlMhKRX/mgTCLYSQjfVSlQhBIRpVT4niTAqAPisdDATeS7ljdQtaA0GJQW95Irb6LQJu3hqUmEzQLrDJiMNrGTR1tseQpISlrsaKmIJma7i6HYITT3aTmkio02x9eVfigRjZrTsINoqhlDxUkkP+XGOv+XLsGQUaLczNKaq4iGhVCYfTpaE8DOmNWjuxeZgnpSCxg9l+vsjgSj4nfKxkO+45+9ijXpX16BrPvxWDiSJWCRwJKJPuPjMX/Tr0Isb00s2JYxtxIdd+8LOexJ9YA7d6CFoo1zUA6TDphpjyEfOR2ouh3JEIftf8JGmUtL7EqO1hlRiMG1BK2s2z2LDLPbBoIiS6QtdsmkEksaNkukLTSBMdN0YJFmLA1tt0eZkLkZTnkz4mkSwl4VCUGib6qTges/0t2CTLIoYfSEsUj5pqEjVy021hz2OLt20fTK09TWbY2rBqfTqkCiDMaQypIPjZR8Oe73tFl5HK6Ew4ikhEo1CN/OyxIQT+4ivm3G1vABbxRPiCzGZVaTN+PJaA48wOpEEco1J2oqCERlfiAP7lPjDITJeLJIFjnEiElFqR93BcVlxZc8to61mcXqI+YKLzvwF/uld6+5bMF+g+tw7Y67gSEQfNREOfULZaKhTxWD+vzQ5i6U1Ia6LbOgUIK8xi6+nGqYvKKhkOoOpjSBMUK23EYc2GpFh6cgUtqqMSaUBiQNFlGyjzTLO5UFTog/SmptdwU05J30ixKbaRAV0CsI01DJj03OzErLAXpn0ZWQ3TL7BaESilKzPWLEASLqAE7As8NEsWAVRMeMhzSDdsSkSLb1ki2++ZgSF7cVZRUIxqLXWLpMKQvQRRWGiDbohl06VUECpSUa3jNQXvQjVjFKFIidEoam+FhzFcrZB91M8nGcYz2toeiGWRVOoBinaWYCWHyGMeJb6S/KDXLSS7UoVea7gZwoeoxLUrgyHCNKCDEeIoeKF41gCtlVlnsP4aMzo4+kElf1Eng3wb6XCgocjEX2Ca7rVb5QjEr2PMl2zqVasqzA6gsQoQFGDmEppB0slTbWk3XdN6aoKv0C1lkoKo1ZrY6jCllOFWFizjFOXdiZYFmoCEVnNgeUtHksfbedQWzWiLZ3sJCd9KIQg6PQDKx505KFLJJpKYaqgZqEihIEdQcX8SflCIhpFhHbBBt0URDICker0jZyoArt0cFttUZ1K1IQ6jrYKZfxLgyaGfBZkmmoKRj+KQs6jaowlOb3z84yoSFTC9PawVTDSUZMpDdOwi2OhNlI38GIKRbdRH1FtiUSMhm2EdLkEsF11DK08RhjFSKTPRoGiUZVy2lZNocg85Bm7fiop82TUKJzyJNVhKlShGEbhd5xRp2JX2sdpfysOfcPKu+43wlf3PcxHOBLRB4w/PIGxhyb6cehFirV0Y5yxpFPKBHQZJ9MXkspgky0aSkVIRnUVRjrs6d4YEaCWZqgPpahWmbfnj12BMMowUmuiyrtj0QJkRgehG2yJb4J05dQCRbmzNwRCRxtK/S46QRMdLRACoRh9oI2zTldQ88C9MrUxlXsYy4fEq4Eh/kYeY6KomlLLQqIRDRWhVZDeMA2g7745Pl4J+jRwqtZdP0kidOtuNr+iCHJISXEqJgtWlOhogW0PLpoOU9FBVD2/U2JKUaUWW2oxoxWGxr7WUTTMa8pJ+B7HygoQNt7iNSuQyFjbHo/vYWmliYdViJzahkRHh8KwQKWeImlHUC1ti60iyHeVDvuoNK1xGE07KKwsoPhds0HXtOjgo/fwdB0+5wqtqTYevOchbPm4wTKdUi6d4bCpcPdtf3cXd06xNlukksayo5EAvIipC1MSQYEgBXmVGIo9MmhpzegD23qzvHPYlzJDaetdTVGpsBwtx1Ctic3DSZMKYH1BgQgpKhRVMrXhaZEi/RdjX5dx1oyIUrs82khJd8yceJuKnS45MetKiSlOpwpoFQpTKkBTyEGIsaImjxFyuYufyOuig+AUzsm5OY1E8DHMqsg9XXuhSz91JCHiZOvVhUDQ30K3CCfJiJFmgfhbbBWOY0nAOhDtWCnBHM9DLJqKrmkXG4PpVK+pFDHTMYMCFSNqJLFiwCApNDGq+gUSlSD3fLQRSISk4ucYDtpohBHaiTb8oh5FFZk4gwrRSwP4I4xm+OBXqoIQ4aQmO0iZR0qFOHix7qehxMmy9FeyRii6vMLdFc8l7r7t3oEjEXDVGQ6bCjf+/GZ3cfuKbsWAoOR1oG+nTSUGqzKoMiSRqIWie2CAv2C375ieEB78IbpRFvB93mUXooNg98lamMpkXQuof0jE1priys2DpnhBUPMgLbal+yYnShIJTui2cRU1EdYJSfOJhCkDajFIJEw1Bv0fmAJoFgHapismUxVsZsVeFEw/kCJM5VVkTGUwitCp2tAkgpN7XnhIC1/suSVi4WtdRKbLNUQMyonbkgiWX1KYSSFmSqOsXJMVvr9Z0EAsZEgJGeAjUy6MSsCWdYoSwrpJaCEmrxeNqKQShMUTptojUh6G/AztgjGXim7gxe2DHF5UoBlXJPUR+vpschKbWi4Riyzx4XNfGeBPKORDoThZSl2ohDuMB0hYwMsZjehKK3tYxGw6KTnMGtddfAMOOHyfAbuS3izJ5mAQVZfO6AMmV03247CLE2u4DJZMpew/UlP5ICF2egdQRKkFDppABGymFYrqv5BOWExl6MqMmOZRrMgIMu1F5RcYqraFMBARmMZgBCIVHQFFhyQIesLUd92cym0VBgejO2BaXQQbT1HzUEjagv9RNGkrICZyD1OI8XBakzQM+0408wiTBUkESUUoZEI0EDntpHknT2KhTZYYhSCBKApfUh+6KoOkSKdCWPXAzqOMSgRehjjIkeiTEFJBAsE4S6QyjHtVxB6rKnwsDxuooxBdRKpyRL6PlJ4Scp19MdHSZZ/6PHR0woMvpal6EqdjpzRBI1nyPGwWtoXMPJhRvFnAy4BJvyrls+OFjyxjdMST7yPMAuRhjvZIiKClUyT87tIhhXDS1x1A7Xdsvmd+74pEwhpy2G5f5b8VV/LZFzQnSaEd5iMciegD/n6n7q7m0D+Hyp5mUyV3SqYuOt4QZoIpRipIl+jURcoGW8MkE4xC5AgD2lnrhc8Z6B+NGtqN0k9kcmRZJ3tisDpDN8/SE6hOD2jhof1PV2qYsYk/EkP5pfJJlleKHZPCWBHg/mxU7v4p31yVDgk5YaphMo9Fw5AUIaayEONpXfpL5DRrEuIQo81JV2L7uhSNhEHmT3bkLDxkeYhKkKIoWFVCA60AqfShAIbCRKSQTC2k3C8rMHyFZcEUGioWMyiSpqVBJufEKo2s0wBM+06YVlodawarkaDgVNIhovGg9wWjEXq7up9jyGsjYdrFq2qRZziJSY/ilEh/F5kvRIKkwqsGInylrwerQcLQQ9hUiBPjFWGXsIBioy6Wd7iow7zDvXfeh4GDcmZTDpsIThPRb4Mp6ytkFd/d6gxP3AxNnwwKKmOthWCVQBFp8sA7WiERATtLUgeRSKOtiKZSww2Mhk2MBm0MBy1ZWN1AkylGHTgxiimTUQVUeNdfFlCWQqD6rl2ThpaJRHAFXSLHi1AEk4w4UAjJlAWfM/LAEtGJvIZUBZjKKphoV6SBFTuGkjxp10cfSRYgyULt/CjVmZpEpLmPPA+EkEhbc0lzMFqiIxLNNMRkmGE4ZqVJG55X0ekalaHutTGW1dAuhvFwMILHRw9haZAgDrQ3hJxdya9BmoqZihPdrKvofBesxuS7UgEiVSD6UbQQRYSlISM7moiNxW0kSWwiKt3f7yQNoCoRCsof0kIeKY6Nx0k6StEGaiNsgqVUpdFpCf+of1MOmxr3DKKOTDkS4bAJQB/4lXc94K5tPw2miJJmsac6gwQiN44JpleGYvggUygChSIymoiIOXjACwoRVlYqGSrVFEOxTPWI/UxC+xQdskJDmkxB5/ypCeDCGghO//YOvNyqm5EBqcIwEy8hJlJQaCg6MUY0hxbSMFlUJIVB/UOjqGAVow6sauC6NBKiwJ4TJAkSLVFdEtHKIhRtIDSdMdM8FKtp6cLJ1EruIc9z0RuIg2Tho15JJKpBUWVeDGGklqARZFgeTaLuVbAqG5JIjOe1MK6q4okSeazg0OkGVmnUjOGUaBkMaaA2hCkZO5GLx4Txl7ATu1SPsFojyJHmGVI/Q6pSLI8amKpW9eelAsRHmhUSfWBlhhBALjQAoyQi8hF0IuQelDTjslJPs844da4BRyDmHA/fuwqNiSbqI2IK7zCP4NIZc4x7/ngvCv5gOcwtzESlf/97ow+dcLrkxcX9SSYVChs52Sgm1FmgQCIRcvGhYgYrKHDU4fkgLFCtpKIZ0M2wlOTvLZlghQHXRsbSOjblnJoz2FbbOhLAdUxjsALDEgmCpYyTRYBJFUv0gQvFjGxQxRTCeFrFWFqXNASjCa2UIkpGGwI0ksikMzhpa5LEdEYjjaUXBSsaSCRY1Kn1D9r0iiSiyCmm1ASCfgzSu0qqIKqoRSmiQCELAoniML1BPYiQJpUKwZFyUTSwNGRXTp67JkjdCZqdPTVpK3cDrXiMkGhyQR8MuS7Kk2vHayrXlnbXiCWVUo8SpHmEgOTBVIiQ4KXssEoiQbkLLyp5YhUIGmSBvm4LrgUtxsnSSj5n8oxwEYh+4a7f/xV7PH1XDAzU3LYC7xcciZhjrLrPtf/uH8ozQicOoR9IHqqxlHIylcEyT5m02NhpGEiHAGoXpXnUsEJ1tI1qLUFcSaVKwPcz0ULUqX3w2gikgiJHLOWcuqEUJzbjBSXNprREs8NgOmJPhs8pSGxIAy3V6XHxcB7iwWxEBJN0k8zARzpPxiKeXJ3UkeQhspzahRDNJEIrjeR4QhYyEz3IfBSpByW6gK7PVt6kzoARFyCj3wXv4gMf7ZSpBaZvFAIhFB7yZg0xdSB+IdEMTuaFqiAMrWCywKjvSzol9UI0vAipGsf2YSLnZrUdJFw1ab5lIjFGr0L3SimeKC0co2+uHYWqPHeWuHJ76k6YOpoMqvCol2BWKlQIswJ+NUPRJHNQUGyfQd+IqumNIgZZugxU/gYYeWLOYwY4w6P+YvVD4xgkKNfF02FTYNX9Y+7C9hHW1LjrD9Htn8GJXHeYMiWelUjn6kMTkTBaCI93sb5CFOSIIy6F6CKknDNIRR8gGgE/x7KgjbpXoGK6VPIuWltBd+51O6FzEXsay2qZ4Dq21oX0l2iZqAONo6aKiugCuAMxk8oqmEoqmGpXJNKQFoxGBJhoViWCMNWKUaQBvJwTJ9MzQNjmc06qxtjKaDLkBoq8JqWdQoCkzoErSd1woiUxiekQWWSoholM7CQbQRCKCVXKCpaowP1qVCyqWZLJJU19DPkPYIjXTu5gPFTN+TOzwFQPoa+FtshmNETcsc2XRvMpEooackzRxoulo0iReoGMtRa00fRD0aiowhMzrmrso8GeGizRrXOwegnrPqI01Dv3LZOi74aCohV2KQ3mCET/sdr9ds5LuEjEHGPVSheJmBPMmLc2ZZNWelD2iSBp6HSeYllnABXr2/SOqJJlnTUd0merb97t8k6cOoNqyHtr2jvTS4F9JhiFSGVCF6sJSWXoxZY36ioMljV2h8rJlBGItNDRCN73N3LgkbyGtjhGFqKDoB8EzaJIJB5JamikFSELjaQiVQmhn0taY6pVQdKK4LV03w2SBllSIEj0hWAJJNM0tlkoRQjsOcHzpgkUoyBKttXlptmwAmq672ZCTQWjIkWM0XoLnhdiXNX0vqKmHIsxHZptLfUVHsmHEXqTQuUoNZFyWeO4KZmSaZWUvD48Z+ooZK43X2Pue9jMa4nvhXxHTLsoD/UwQSOuijGEyn0kSSTRkaheIBsOECZKbMuLsBCBrBiJiSmFLnmVE2ZaIzMlIpZAPFprcKeRmBM8Mmi/ncoJKx02AQbuH8KCQne2tgRCCyht+0wT0iaoi6jwjto3PRyUCCxVlT4EhWggGC4npIlVmAqh4HRD4kASwbtvzknCTYyQkKyd+X+Z0Kf9p5tgqc7EajUREyrCqnxY9AVTUroZyiOjD4xMTCVVEU8yhZFkTD/ESFJf2mSrViDHp4iQBo3KN51ASSLaJvpAyUeTRMKceiZ8QQs85QadIghNPlguiRZNqNgxE4iCWFIdNNmqZvSm1OMfa5lLHerpd0nQQIoArTzCQ6qOraMpKflsmXQNzbd4SEZsbDdT22OTEQs7bTOIwvbeNsXBXiSNompMsDyxxw78XIgHP82IEUkfl7QaoAgpruR5+yhqChjTGhh94lojwdc6s6LrNToamtKfkcPcY+BuwJTTRDhsAtx6zR/ddZ0LzGAwZXs0dl/Y1IYVVJaElT4bawViKiUGU5x0OPlU6JdQ6MnJ1yWP9CSIxc2RE5j2GdBiyrQ3p08vBY8TnNY/sALDdurkg27TbW9gtPiwTSMoES7o5ldt0DiqgilVwSPpCMYaVUkvUEgpFR2FFlG2mzHQ9IUcyBFykgZdZcLGU53XJBRmtvabJrtjCYThU2Bkn5eA1tHSXtuD3waKyQhjSwJEQxn8oEA7o/rUtCz3FFY3q4hqOWpRW7pwMnpSD6pYhklpqsVyTmWMtbSVtl6Y6tD3/tqFikZcHKJcNeX3XNOaRH3IjirynVQUUywZ2l5szEZ11IiLJxEI/ePOqFJuS3UpgTDfuyYS2vZcKjZsozb7N1P6e+qGSwZDADfouPWaO/o9BIcZ4NIZcwyWKTn0wxtiepMtm8rg5OjDE9dCo4vgRFIJxVyKJkV8zKXhFtt95/pOVxZNJoYrLSzxmxjxmxj2W6gHLL5MpYSzO+Hp5+WSTp2G1xMuqxryjuCwayzFfhgkD1o3ARFVNopQRJTUPHCeT1nCmVakPXazHaLdiOClnjg6BqmeJAt2v2Q0gZoI8aJmq2xzafgeDyaTqR6wECbPRCx49x6zX5VCwcuT6wmdE3Ha4MdCuR4Je1dw/Ll2jyThesQbEovsrSrjGKFnhkrl/GnLXfUaQhDKBILNunT/kKJzbXR1h56wpaeHIRS2JTnTRrzmORqiZ5jwY0x4tU4EgsJXEb8GBfKQbcEpStXRHxJFvzkDiSy7Vtr8V08IYpoltiMSmxzNAfvt9LSr/aw+PwhwJGKOobSDjsOmxho/6tpjoBN5KG+TMR9ueyjohWF/KfWTxk26bbTHdEYB8YOwS1RpSyTCZyTC1xEJLqF089QCQr1ozwN6InBK7CRTzPykO3Hqck7+iZBEUAuxOq9jMq9oIymWayofqzISCF2FQU0AoyFse91mNUajIhO/T/JAB2cShxSISCpST6c1Et0em+cnUykfJSJhDJZMp02SEHbA5LkXbU64jAqY3hYRpCdFEANe05O24iQPlYiRhwRRPRdxZ5CzoiOUMbOigoSIzcFYeyFt0S1xInmQcladqpDeG143ImGJmPWNsEtKOQuFmqrQC3KMRC08HGfGVMs0GFMemk3dkVWJS6VWaBZ1H5hklQpDM/bR186VNtVlxZVSlur+/fYL+aCVxiuniXDYBHCaiDnEDHeI2j7A5Lnt+0IYdDdMvZF4U8NjSSAnK06icneuyxBp1CSFHCziCHnnzEmQYfYcoWcWbZEkREK0euINUXLKLEn1tMBS95lgZUZb7J4LNNiVk5EHFRsvCDpSRmgmFbRTlmvyjj+QFAanuMZUBR4bTqVKog8kAX6JUAQNHXHgeXHx+Sg9JDSRkCEbv20hELws0l8D2giKwQFeK5O1yFiGyf3LXXuAtOHDH0owFPMHP0CWF0hFWFpIM6x2GKLpVxAw8uEVeDCto+ZNyD51NYo+PqtYtIKkTPw0GbMRGhIK0wzUkDN93VlaK06YISMjCj4Fo/T34MkYkayUefKYorGwgtKuNsYaT4ng0pAG27p8Xf7GHDYNBq46QzlNhMNGRpZmmHjENd+aM3QEcToVUMpgmLfLgjpGGbQ3gQjqZGJT8BLm7XUTLk5AnJy4S/EnYmVGpEV8pAGZCuU5CYRMaKaMU/sn6slOasft2IzdNdfpvpyFCCs5aTMqQSrCyZIpDFZmiD8EYxqewmS7ikYSI021sdQjE3V4E9qF0WdlQabgFzqVIYQiUQimtDmWVINYItEyE3Xoy2spd2Wag3Oo5A08eIGnIzEcLxtd1YyWhMGbhidW0h5jmi0gCwMk7LuNWLqCtoIQtSJAJWKjLp4Dq1bY0yNH4fO8fIkgCDkw87g2oNbfj1xBQ/ysbbb11+ArkjNbDUNBK8kc36MRVcN4czB6JF1Cwxw5y1BJChlGYTdPPjeiTu1cqaNSYjxmTKg6BGKm1uCOQMwZWo02psYbGBplzbHDfIFLZ8xxFII/SA79NpiyE5MmENJwyzcThxgSUf9Ai2sdzue6Qvp1F4iiTNIXOlevELMvhOgfKKLMZd4Jg0wEf7pPBsPvNq6pJ0d9U29SCCJJ6Hbl5D6pLGjRVrpgwSibZheaQLC0M6eBFEWDhZCHZhphshUjbce6EiS3xMEX4uC3WJmh4LdpvAT4bZIi08OCqQaSDWk4qkcp2gjdsVsTg0QTCHnPZ9WILpsoEkYO2OWTqRF9DpxQ0/EQY2ENNXpIFClU3MaQp9DOIjRpSsXOml6OUV83CmOVSd1vmiCIVovoVAVTGJpg8bm9Nt0qVKuJoNGUJm669wfTIYWkTqiBkOHSKEusPxRa5DcUxTKlI3pZnbLSwgxNBiXaYio25N+r/Jud/u92Bp2NwybHI/etGhwSoVw6w2EjY3L1lLum/SYSphqi8/vP/DdJRGSbboVQkS+OhnlFL0VFlzZGVRpLZajEeqHZVD1IexYaTI0EbdMjgxbNOo3Bia2nR4dJaEiPC9o6m74YDAYkhcLqvCYVDRQgTuVV6WS5Kq3hkWZdDKXoRpkba+v2VKyjDeYU/cwQiYyRCYWgSV2CDusHKR/15CrbtgsEbaYldKWEXAeSBuMXoe/7NePKq4H4T5NcyFstHamQA/sUWuqIS9YIkEg7cV+MtsRBMwsxmVTEfGqEtMB0/2x5LFltgebYJAs6CMLeIECVk7y1Je9cM012SB6ED0j/EYnfyDjZep2RiaqXwGP1R6HEx4PELqAhVqyJXh4q5LTBDoGsCvjjJsVlqzQYeZLck7lWwqoM+bTmZA5zjrGHxrFil+0G48orRyIcNjKyRG75HPqAbmIDpWcmHy4bmDtQUQ76uuxRlwHoSYU6AN7V5lRZ6pJBiXiLyySLMPXCCIGtIJDdGjNECiq7/KXU5sms13fc+i6c99tSrqkCiW8kCHVKo4jk7p/W1WnGsk7qI0Ip1eTi04HSaCFoLhU0SBBstIFLIaJKPnokE+0MfspSCyPzlDxKpvUJrFiJ6XCpm2TRI4MGTXpTrS8IWqbsleNlr26Yag72xggDFFEqEQhWsPDMoiDCeFiRtujjHmmDxpDfQi1MhBjoqgtGF3TUo2MNLteNbp+686dEK8RHg43QPCxDG82CZCtEqkIkfoggUKjEORRTJ1kuRC2qFmiPhFAthSJR2kSLDqUkj3ZEJA6sLmGPlIShGfs3M82kzGHOUThh+ryDS2fMIZLWzJ78DpseHdpQvovsCBTMc0L6J/jwKQgQIaFZOFlyMqShVGGIA0sHfYXM08JGaVwlegjehZvdGpLAYkwJxZuBlItPu5RGT45SocA23KKz0BUY7NrJRlmkKHSjpPaP4XvO4nKTLHbWOgohHhAkEalC2CqM0JLdKxUCvk4yiUogz+Elqdyty0RqUhIyNhIO34NfrUBVNEUiGZG0jqQ7tCV10NSeGuK1QJ8JpkwKD+0K24mH0kkz9XPU2QBL+WjnFIhWUFU5UuSS0tAEqmsuNYPPaKfCkiJO0XQYIiPBAykL1dee142PhRfIdeJ3wu+KjcR48aUxl/1OyYjEisK4VPI77xzcJk5Kf0NrE1c6zBkG6jdUuUiEw2L+B7DA0HWoNK/t/5vukT2qy9AICeVHQGnTJcbOjZJfotw5jaNM9EF0DKQJnHjFGqoTwLC71c6VNuvfPVTv74yORLBTJSdXKiLoBkmxIKsyWBXCFAZTAdRakEgo8YowIlBDICQawEcRGmgBZSDlngX8dgaPH+TC0la6TJJEMH/AiZSguNCG9Rnd4DEkvE+3Ju7fRB7o3snunSzft97e1HQylsIW4oUvk7duZabbj3Np5jGyoIXMtCanz0SBxNazdMgUFytXEEGlmE6Vun8KgTDWFsIDcvhiF65JHR1E+Z2Q9OnTMULLgL1JdChDrlFYcq3sSXt1SZ9TQMwPJK1O//b5D+WqMxw2MtJB+gewUGFm9e5dZUkwZ/IK2qVSmyl1EhOB6kxCsvCm1fgSxKa0k5GDULEqw0x6tpKgRB6sxbU9cnnR79MvgtEHTR5YsshHpjNkEibBkLIJkhzWluoIhKRjRFipe2FId0pO+EbcQH+SMCk0gchy/Zhm8JjOkPLOAqptpnGZcW1TKludECJosuGV9ovwxA5cV3QISaEAk6Wd9I1gtIBRC4o8rY03/Rpkod6B56dJkj43tizvEr3yNenM5rYa15TndnqOlK6zVHko2o5r99BQsX+GqSqR70x/dzZKxDfYWK2ITcOz8t+BfZRK4JIzpRNG9xWpuxGbd3DpjDnEg39/ZC4P5zAd5Vx2x/La+gPYxRMBYV4LkNc9MSNihQaV/pyExEZZ2mQXYqw0FCbilqiXVFthd1wVu+WIOjrRpREWutV3d8kKhamiismihilVRQPM8wdiKS2ulkWgHzn5poHYT1MLwSoMpjJIKkTzUPKD0M55BYJEciBQEoHQUQh5pAaAd+UpcxG8pddNqSTcLykDzU48EoVI53asORU7guqGXkyPaD8K1dYtvnVPK8+Mm2Pm2HNx2hR77qAqE3+oKIuc7FStWL2DpDc69g2WYOjHNa4xOY+foxaw1XiADIEIXzuW18b+mo/cWJEo8jvOPGTMs9tIRCcy1Y1ACGPslPO46qp+YuVfHsSgwFskjpWWky8afPGLX8TjH/94VKtVHHjggfjNb34zZ8euDenGxw79g9zFlhZjINCzUEugbzi7E4tqBgjDTFpMs8yTVRq0bEyNL0H35tWXxllk59atMrZiyTVvcsUZwpZ4kkQUTJF4upGXdVrk5+IgQzMNZWnRmZL9MdjGmnMisw92MpfqDFpc51oHQW2DRApyIEmAJIWXprrVdZIKkVBpDtVOoPicGgk+53sUAst2+nP6s5Q7GnGmCDSpscj1c+N8Kf4UzJi0ArQ45iSSUlT29OBzSTEYEystJvXEL4KxnLx8LeSdXiEqr0vXBbS7mFZoXS6o6BWRI4r1d2a/N/p8qET7gnQ2lnIPcQ4zrpVc2CK8ZEJV+nNw6B+Glw5IeedMocYNWQYAi4pEnHPOOTj22GNx4okn4re//S322WcfHHHEEXjggQfm5PgDlc9boOgYPdkZRCZhPTHS0lgeKUBkaL8UupZqiYRh926ugnfbNFSihqH8L19PjGWlgxH0yf/slKgjEtKYy1AMHl8mSdFa6PSINl7SfTaY46c40UYiqI0gW9E3yDbiYJw1C090EGI+xchAS6c0KJhkHalOazCFYciE1UnQ6pvRCUYlqI2Q9cosBdDKpCyUfTi474DVIIVx+DStxq2oQRtwlcbL86VmJLDXSC8kFXJF7PU3i0na9FiWT88+iXMmoziSjui+SXGqeFqYNI99pMNnJ6gg+2NVi6mJMSkuHWUx0Zky4XToO5yubP5hUZGIz3zmM3jzm9+M17/+9dh9991xxhlnoF6v45vf/OacHN/9A5gf6AQZODnYMLa4Neo3pEiBlQ40cLD3wqadd5ZSJmibQemSR06Upu1EB1rSN03jb2wPjQOzCZeXiIQxsOLe6cDIclE70VIjQU0G0ym5ec2+2LJLigPktdEO8KWuRNUTIkkDt+TdtpRC6AlSz6YUHuoySDp2FnnGOjooSXGY7exzO8kb0aZtIy7CU0se2DSLm1JDIrzD75yDTSloTYe+IIEqEHsUkIrIpLNTbWtdcq4sRQPK11QLMKnPsG9bx0+adHWJHXUNJIGiEemQAg8+xablKk5jOiXXUcQTayhnHPoI9xs6/7BoSESSJLj++utx2GGHddbRDIevr7766jW2b7fbGB8f71lmPQYnCppfMERCWxdyNrL9Lvj/tI2m06NOLegAhL5TFSIhk4ydWnyxpWaUwoojCc5N1m6iZxKSiIMW7NmIeWiOKekLmTF9EWzaDhIUJOo7eU0kbBpFyIfIFLpEQiZ57ofsRMo+dbMtYzsppEDutBlxIPheTq2Eqdyw28r6XFdvkEgYwiWpDCEjSlpr6yZe+oR1JMQIT2XyNgRC0jTmupB0masSa1Wo6CXMxdHbGc2KtpsqleB2IjvdPhr2c5pAMDUSauGljQCZ70wzEbNXHoIRFbFuKRla2SZPZW2Ew7zBIEVzvZIuYoMWDAYWDYl46KGHkOc5ttpqq571fL1y5co1tj/11FOxZMmSzrJixYpZj+GBv85N2sRhLTATUTcywH4Ypfy4Lek0d91SlcAJmDoAivI6/8A95DQjMvvU0ySdJ/UteXeq8kxbb6vQ6xy4SyQ6w9LGSj3pUM9DjEyXeZJEmDdEMyFkw5Q7msoFoRs0kersVDcOkxSFjTqYjaVHRM6IgxmYRB24X563OX+xqdQRis6kzvUkHCQHTJuYc9HXhVEWTSA6ERGJeGidh3zcBDWEQPDqdLqY6v3opuf6XDvXwZxL52sU0qEJRKfGhpkaBbTkO7BbaW1Llmofb5si8UmixHSLZ6iviT5Xk8KaXvbr5BDzBvf9+X4MXImnmsWyHuCc9ZSnPAUjIyPYcsst8ZKXvAS33377Y37u3HPPxa677io6wb322gsXXHDBeh130ZCI9cVxxx2HsbGxznLPPffMep9bPX7LjTI2hw1EqYRQPzF35N2uWCbUbbLxUgJI/2pfvAakRbaJpbPxlp3ozXSFCkMAPQJK3cJa1vT8HnRNnawbo5ZYmlJE+xmlxK2Sd+Yhq0PMvCZNpuzdeqcMUVd/0FlSBzK8TjRFmmiZiIsJeMAzAsJOrp+pDrpU2vM3ZZSyjbbmNGM124gg1ZgzSbMyY6xFcmPCA3IdMh094eFs0Ie2DHyT0RtbastjUVvS0UCU0xadRmql69ehaebRmI1Wqeg073CcFKQWSic2bCypIHmknTl1HOY/VfF7IzCdnhndI5b/hhz6g22fuLW79GvB5ZdfjqOPPhq//vWvcckllyBNUxx++OGYmlp7u4WrrroKr3rVq/DGN74RN9xwgxAPLjfffDPWFYumxHPzzTdHEAS4//5eJsvXW2+95h9mpVKRZWMirlKn7zBvYJV6VjzAWagUBeCdtoq7TpMm5Y+QlRmSYtCpB36cBEIbIHYz9roB1wxGRR0LbDMZi25Rb8HpjtoHrkxKygDdKZQloIzj+5IGoGOzEBvyhNyQB0btRTtounHyPELm/k3vB23IoCMwnNlZ5ikD1w3JO23SLREJAr0tn4vlsHWs1IJU5YWaQNhaSz4UjBRo7wV2QKVfBCtQbPsxpjasJoQkSciOKS3hkONOKy65SJpWlDwaKGgNprlH2uvOIfC7sNoSIWDsPObFepylEHMR+8gDen0YdhYHupGJ/ZsoO5o6zAvEVdbiDAjULMU06/nZCy+8sOf1mWeeKREJpvGf+cxnzviZ008/Hc9//vPx/ve/X16fcsopQkC+8IUviGZwXbBoIhFxHGP//ffHpZde2llXFIW8Puigg+ZmDIP0D2ABoxwYl3C7TL72VtlMvLwx5d1pN9gtcwrLBHUIX6Y+mY0oDOwYHpp/+92sf4lYWPGfaeKkAxTaF0ELOs1dsRhI0sVRRxz0fM7SR07GvrbXNn4Hso/MRiT0uYhGUTwaTFRUGmoZAmFsvbWdpuliymiDLD58U+Yo0QhLHmTh56QlptmnHrPXuX7asVK6YsrxzfkyCsHmqHnQ1X9YLw0RkjICEeg+V0YPondpW6V3OV7JuMEIUu2vrFVPmEN6BSrCoDSR0VzIlM32fqMSgSBZtFEoaUBmSIT8bXS+J4f5gIG6EVMbp8RzujaPer11ASPoxPLly9e6DfWAZZ0gwYrFmXSCWOwkgmB559e+9jV8+9vfxq233oq3v/3tEuphtcZcwJGI/qEnGG70DrLIpGvD8WbOKBEIwqYXglg3ULPaBM4xdKzs5PtLk5s2Xu4eW6f1bbBe71W3/e5+zhYykqZwmpWJls2+6J8gEgbaXZtmX+zPwePqtpfdfhCcy1NpqSHukXkFKKp04CQhMUSA52t8EbxKTGakSZTRh3gkEjEdtgyREE9pTSRYzcJ9FVVf79tUgchjOZXLRXp7sU13Dra3kv4VEvChYNSacpFE+cgMIRO9g+lu2tGtdqI5HfFH5xpaItH7TZmSWI++E/rzYhLm57oopSfSASjdZlV/T7w2YdCjIZH/ZkptOMw5FuNv6IoVK3r0edQ+PBZ4g3zMMcfg6U9/Ovbcc8+1bkc94LrqBLHY0xnEK17xCjz44IM44YQT5CLtu+++EgKafhE3FdoDpCxeaOjcSVrhnBVZisjAuDcaXUAR1bupb5Mj92oF8ixEkuRyJ80+DSyxDMvNFSQYwAkeSKc5VtY7EkCbMjGVGSQLLN2Uf4weArFlYGrBFEZK6J9kI0Q9zsRq2s7UzShDK4ikKZbIGGyRScRxmLJTChnzAnkcIKhEnaiF6Bx4kgmfm/JPOl6KuEBHZcSxkmSCLdKlXTofQxRxoFM97KfBTpdGh8FxSF8KkjA+BkAlzFCN7KLLVnWwp3y7xbJVWnyzaRZ7kpRJgf0SukSCj/yXlFpBpqlg6W6pKUIk0RdWWoVI2hEK9h0p6yhKehVanYf8G6ANuFRodAW2axXmOsw5Jh6ZWHSOlffccw9GR0c769clzU5tBHUNV155JTY1FhWJIN7xjnfI0g8s33pZX47rYDCt74GtrtDvddcHrRzFFBs4+cg5QVOElwdaAyFVEgy7a9vpyTxmaylZaLY8xF4MJmxe7kypZZjdqU6XIJJAdJtISfWADwwFbdkbUxesyphCVQSCbS+Su2nfCySdQdfMZtxxrRYNBI0W2Q+CZZiSxpBUBu+w2SPCF+2EbGSSKDqM4Bubax190b0zdNRBWU2ECDFJsFjRYtQNfLQRENMOvKhQpKikjwaXKMy0wZTPjqcFQmkLrjDitzHKJWhhJGhjOGh3dZoSSTDExIyzlIDotEvvWFMYOjCZR5jKY/lOZMliJCnFm/o7Y5ms7jdSIJxSCKYK3S69obubdv8QDDHkeTMEtJa/H4e5x9ZP2HrRaSJGR0d7SMRjgfPb+eefjyuuuALbb7/9o25LPeC66gTXhkWVzug3FmMobr7Cmg2tcV/JHDqtnGnQxEZV0nCLt6pWRGkElbxJ9RiGJ3XQ+gWK+PhafKtMukNbLNhCQj0JdmFdGXtHEdmUBQrpm8GwfNVPJQLCyAcf7YSmQn3Hb6dS+jbknMRJHsxkL+H7QKchJKLAcL0soVn0c9QrQL0KFXXX8blEIAyxkH1It09DThiN4LEqVniqIxEi7hS/CH3W0qrbeEXI5VS63TkTB7x6TAt1voKuxZe87vTTMFdPCFn5GhsBJembbZ3OhT00clZiSOpKa01k3DJW9hfRJbxiE54Wa/x4k0yVLbcd+g/3G7p28O+cBOJHP/oRfv7zn2PHHXfEY4F6wLJOkKCwcn10gosuEtFPDJQoaIFBSglt061SgNxWR3RKPI3DI1McymdY39y0s0+VmYikGiJQHTtn6RwpNtWmyVQpAmFVgaxOsJoL2xLcjqXsiyjdKI3tNXUCvHNnZ9Cqn5nmX3oqpW6Aw/MDTql0YvS7UYEIyDl0IyogmShINpgmqQRiWd0p7WQEojB1l+UykpxpFAoLSCJ09CGvBMgrTF8YISU/TgdKpjTIj425lRZXKvhhLmPU9tO6TTrHS0LECAwJgCVLJEpSomoGYa+L/basMZdEIoQNGK8Ko5/Q2gfGdqxduFZdMPrAMWjrC0MEGU3idWSJr7H0Fj8Q+zegvwr9YGtwS2kw+7fkMPcYKBKh5rY6gymMs846Cz/+8Y/FK8LqGqijqNVq8vzII4/Edttt19FVvPvd78aznvUsnHbaaXjhC1+Is88+G9dddx2++tWvrvNxHYmYQwzUP4AFhs6kXY5AdEIARn7PyYGTKs2UvC6BkOpDaXbJCciT3g+c7llxIHfUyAyBsBbVPgrekcvEoycimeoNgTBH7BX3lQgFyxdJRrROgm3GaQ3NDqEiOdT9JoxzpUcSwVba3DkncVk85PzNMLWXQaSgUh1hkeoPRhNo98wOoDy4LS2xlRZ2jIygVAIUsSYSJAu5EWnSPyMPPWQVdj1VQlq0DkIbPPExDHUKgz4R4uZJcsTupzwX8dTQv7I8v0iuqC7RtN9Xj9WTuZ6aQJU0EKaJl7RIN94QFKMyDUR7bTHp4n6FRGki0XH0lL4jpo8ISZOYbZV9KeyvuHntNBF9xyDdiHlz3MXzy1/+sjweeuihPeu/9a1v4XWve508v/vuu8Wp2eLggw8W4vHhD38Yxx9/PHbeeWecd955jyrGnA5HIuYQgZSPOfQDa3g1WImdLSc0ra2tF4LtByGFF9KUSk9C7P/ACVH3o9LWylQ02noD6hjE0UFqFs08buyZbZVGx4tBhqEnJ+2mqBddeaEQeRliLkhR8UNU/AQNL5IW13GYIc09VMMAUySnvNumwJG6AmokKjocn5FcNKwxAvUSBQqShiiANxSI9XPY1h05ic70GfrIYg+q2i2k5DGK0JeFBEJapde0FoITslRr1Oi/QEJTYKjSRhymoucgoSCJqAdtKb+kWyVLY/VucxFB2vbe2mirW+apr1M3ItGJ9Ai30N8Ly0T19SeR0L4T7C8iHhXGz4Nlnnxe3oF19OxEJCQyY/42dClH96/H1ps69A3iA+cwI8oVRGvDZZddtsa6l7/85bJsKByJmEOMbjYyl4dz6GB6raDpMyFliIUxXLL21x68Vo6gpfP/eawQVIAwAbKWj7QSos07+qAQ06lGHqEaxAg9RgxyVLwEE3kFYdCUO2xJlxjnynK03KojSCaotdYeUCQgBSLfx5KgKVtJ8Qh8NFQFy+OWdns09+utNEItLpAPJ2hNVuCxo6bVSQjRKYCYjz5UuwA9snISA7pOyh25HldOjUNhQvqcPE00Q4hBbDQP1DKYfhwZoxCRJyJKpkmowyCR0KZQujqkUssQhyQSGWpxilqUYPN6A0sinkOBoSDBaNDGSNBC5JNQeKjQYdLzpbV3Rb4KqyDpRgU4/7elP4ZCQj8NaSPuYbKI0c5DTBUVTBUxEhVgsh2jlXAJ0U5CEVmmTQ9hi11NKaZkt1bzN9Bo6b8Ddi+Vah1bpWEreUrGUy6V0Tcs2XzdBYZ9h1p/6+o1Pj8AcCRiDrFsyyU6L+/uZvoag+jaW5sJghNGaHLktH5mK/DMBxtaskETJ1FxYSSJqIeIYm1vzThEO4+RqkSbQ4lJA22pQ7RUiKp4TtoQvbFz7qQtTIvpTktwNtXSDcSZyKj5OZoqQ8COmvAQc6JVKapBgGrcxkSrgijI4JHk+LlYTaeNqkzq/PFRJDCR7fJp2oNn9IBguN+YUZnOpRJ14eOQuTrakFPu0kmkdJWHVLQKsmGmNBh5KESkKB4RUhWiZ9mommJpvSmVGRQjcJy1OEEtTCSywkgEozVMaVT8DDX2ApErYkwy5T36Wujvz5fz0f05rNSRqQvpZkoyRSElP8Xz5HVQoSxSpsrvLQ+Q5QGSNICXBNoKXK4HEGS8HtpsS+WJbuwhxFKUHKWeIZ3/68gjHOYem227duOkxa6J6BcciZhDBGGA0c2GMfbQ4NQ6DzRKv/adH/2yuNK+X+iIgZQ2mrtOUe4XxqTJ3LXzdZbplJQ4RXOCSgNkFBsqbW7EPg1SsUGBpWnfbcsR6WvAVhwdxb9NbXSab+m24GKURJ8D5JImIYGoqAypHyIp2Krbw3C1jTjI0c4iNBOdirg/iYDUh2JzqZSTpEJOu2sT8cirge4aznPJlW6BTc1AZBwobXTGWGZLVCE29t+22kOEm0xhaAEl9RAs5WT0gSRCxQU2G55CvZKiGnFJEAY5hmOmMTRpkPPxMi0ORY7Y1+cvmgZeR/b6mBaeFaplnLeNr6eu2JDGW6EWtFL/YZtu8XUeaKdK6X7uI8tCrW9h1EVKUnVpq5ApnjoFool1q7QNQEoeFYZ0OgLRH1TrFdSGqxgUeHOsiegXHImYYyzbeqkjEXOFnl/7rsmTbrBVet/YQfd4EuZKJkvxcJAJ15NHiRRQKCh3uCQVpjrDYzVFILl5ivky0+xK0gqmLJEkQoR908SVOv5A0mDZjd6G0Yian+h0BCssCg+JH6AWpVLTwGqLvKD3gtZpDA230Zis6q6h2gASASd3ozXIRthDA3oxnlVMSehfga6FNdMdlkhIqiKkDThLIz1xwWS6hKSB/cuFONAfgusjhfpQIkcTTwimfEIlmgiKKYe8Foa8Nob8Nup+W85tyMtR9QJJZ8SGUJWVQ11po57A2dpCCilMpQWbdlHIyuvOhaSL1S0icSChyhnV4PcF6bwa5N0ojCUSIpq1gkqmdmztqP0bsZU9jFRNM8BymNvfTlcVM//gSITDwsQMMedO8WDZtZKbsIxRZhndHhu57lop3S9NZYYWXeqySTogUrgn3gd+gTTXlQtp4SP1fCQeIxG6UqPsXElakdLGWlwbTbsrIQz0hjBdQiVqwWoGoO4rLA2a+ji5QrsIEascy6MppEWgqw9oAKVihGGBCjKk1QSpOE34ks7g5M7IRhop0XWQqUgHS5Z5ph7UEi0ylFYcqY5ESGpCXLAAz3yGEQkhD9RExDwHEggdwdAEokBUS1GJtIhSLMGDTJY4ZAQiRU10EDSXamGYj34L9UDrMriERg8hluKS4tAvbGmndqj0O06VQsxo+qUCJIVvFpIJVs74SJIYSRIhTXVvDuk8bqIwne9U+CS/WwpG6ELKWtCyZ4St9bSt0HobfznMIQbtwiuXznDYBBhd7sSV/YpC9KBDJDixsGzB2D6aR7+dIpzQrap1RYCPIPYlr55HOlSe57lMVlOtKsajVO7gSQQYUq/5KRJFcaWuJsg7KQ3dNdLvEAj+0vhdLYD0ytAg6RjyMqRehgnd0VvSAJkfYGncRFqwI0WEOMrh+W1UQl0GOukrtJoVqIwCSIWcNtjapVu0Ex7LMGOtB5CrI1bbmizIJTHGFfJYoSW0aXZutQ9cJ9oL/ZoRiGo9wdJ6Q5OIwERHCk9IxNKoIVEVhj60+FSnM+oeYzf6bCWNI3pOndrodq2QL0seScC0/4P14eC2BabyKiaKOiaKameZbNfku9EL3UapElUIxwuEkwrhJB8LhBMKXjPt+e47+odOccZMUYeu24jD3GBkmRHtDArULFMSA/Ln5SIRc4xdnvJE/P6KP8z1YRd5JML4Nnbq/7teADoyYUkEZ9qgc0catHPpE5FTcyCtr32oFk2XODHpdAYnyjQL0C4CVHwdHaAhBEPrrSKUML4mEdrCmUJAVk3YJlEo3d/aO3IdtaCTI8A+YCQ53JSVH7n0tFAS9UBFoR61sapZRzsNkeSRVCjU4kwmcVZ0ZF6oo/RNUwHCubxiLkPb/MjZHhvm10DEpMa0QjwuKvqOndsIkSAxqZpmX5UMQ0NtRBG9NWh6maASsgQ1xbL6lKQuhpi28FuoeolEaCLo9IbNpOjSTq/UOl3/V45F0GCKqQumFLTJlyY+LUVKVugoUBFIVQYjNvxOdHDJEgnrwlEgSAsEiZJFyluFRJooBBedEOq6i5ZKO/WfzbRfd6e0nBPs8pSd5+ZADusFRyLmGMtc/4z+oeQd1HWwNJ4E1qNaJhFtp+iRPLBhle9LdQaFil5LoRgmgaAbog7/8y6XAsfcTyTdoasDAkwWFQz7qY4AGMdKkolEKZlAGYnoTFUl7yuOiv8wtcOlhyV+G3k4haGihUm/ivvTJVIiqStSFRLp0FkVQ6k4KODHCUYrOUZrLTw0Pox2M+5UXNgOmywH7URihEAYwaBuLQFfzlu/ZpmrOFLabSW9oRBXU2yxZBKhn2lRY6DEv4JNt0aqTemJUfcTWegJsXk4pUs6vQSjEo3wKaswP0LWbMqQByM6tdEIXjMbzbGOnTylRhFLczJeM1bIMDrTziPkJIOiY9CiSumb0TKpCEZ7aG3OUt2E5MGoU0rRiI6os9el3KGPWL710sG6/sqlMxw2AQbuH8KgYkYJvZ2cukr7jjZCog9iYWgU+7meYDi1cVJNOfEo8RjQBEJ3ixLVf+GjlYbw6NlgKjO00C9CyuoKRjqk9FPfCyeKJZtK8v7Sr9OE8CXaIFIMH20ZKPcH1KUzVROrUMXq3BfbaN3yi2SkLU2xIpKXzEe90tY9N/JADKQYGaBVdsurICcxYgqFrCawfhmaIAghsbYIUgWhhZVcQRMpzvRiZy2Sc6A6lKAWUfPACgymMHJNJPwCo5UGhsI26l5bqjE4XjtmRiCWhQkin/4Y1hdCe0SwcsX+7mp+pfUhHEuLlTGUNZjvj/M99Q9tXmNjNMWtGRGif0bG6AMrT3gujBpRVEkSQdMwU/khpDDJ5btmxYpAtC+mN4mNXKnHYBGuXGNOMHC/ncqRCIdNgKVbUcnm0C/YksqeJhrGu0OMoUzfDKnWaKdM/ktEwks8eLSJrnjImjShApKMfSjoR1AgCENMVWk6ZYR59EdAhtV+BYXfhkdvBHO8wNeCS06i8l858yIiS5ooGc8FCfHrluNNL8Ww30bk5aj7LSxTIVbldTRVIuLLRhSLwRMJRCoOmx6qMXUShUQHuJ4lqlJRknnIpDNn1/m7Ix40EQkZAUWIcS620SyXjCJaWeeIwhxRUIhoshpTPMkUin5vSczKiza2jMZlvOK66Wm7a/YAWcLog6mQ0ToIXfpqYTMG1k8jNaZSJF/UedJoaqIIMF7EaOUhJjJ27aygXURC5qaaWlDJFE+ahuIsqhpAIFbfjEAYl9A2+4Sn2hOCvVKEPND2nMKRbnt3+5fj0hb9hfvtnJ9w6Yw5xmbbDBibXlCYHpsutcFiGLtJkYCpUGCJZgTEk0o6YGpbaSAf8RBMeWj5Vd0AixNglKEoIkykdUTsGQGFIS9BwYiCitFSClXFoDu9KPQRxTPCpi9mqCLh3bl4O0hVAvtk+FjOfqHehDgyNlWEZhHLc5ZKck/LKlMYS+udlAhtsWnyNFzNMdmqoGCPjcgTUsHYR5L5aCSV7l27nSdNXw6SBPo8VCOt6KDuIDDvDVdbkjKgBTcFnSKmDDIsiZqoeilqbBjG68ByzoDlnak8HyUB8XVJJ5MQgXm0yhALnjt1ECJG1a0zTCRCk4qWoitljMLTnTqbiEUDwuudZ6GQiKQdod2O0ZyoImoqSUmFTSBqAFGTvUTI1lIoulSmqV6aSUnzMO3RRRz6iqVbDJBbJZxPhMMmwvZP2lZMp3Le7TrMHUx4ujsP2GiEnsA6t+MisiNx0CI8n3ev1rmSbo/mOUsfeZdbq9E32UOR+Wi3IiRRIGF/wuboEy+T8sNakIs4UA7D6IensERuyLXQ0g6TYwqN/ZStSCWRoB32sJdDeW1xXeQnqDWgcJFNp4IoQy1IsSobEo0GtQ21SqJFhgz5F+xRoXMWTMEEfqC7bJpyVJ/7lp4RrBbR7bsrQSrRBk08lJwHtQ9DlUTWZwWJSirbsQqD+gcKQOtiKJWLdoMkh+mMYT8vRSAYXTFEQoSn3bJKq4Pg+U0VCi36QJj3OMJmEYmAMqH+QVqK6mvKVEabhlskHyKq1C6V0mgspd+H+Q4ZaJLvsYDHludtQxzE5tr0NekUaZTJpkM/seNej3NfwDyEi0TM9QWPQmzzhC3xtz/eN9eHXryYST3f5RClKYuZCZPKsLflBUPdykw+XkcbwUlJSj/pR9BmwkFvP1WJsVnECS2StEPshQjZ4jIgEaD7pb5F4dEkRC8ln7bplOlCacYVGu98loUSnGxjeEIkOADelbOUlJ8e9Zt4OBuWtAdTKuNeBUsimjPFGG9VRbsRseySGgfT4TIIAjHQEmdNmkPRLEJaSXCbYA0SwWWYeosikAjHkqquuOA+R0OmMFKJQiwL6chK7YYp5fQTiUBUWCZbsv1ieSeJhN/pzNlb0snIQyrtubQWIpUOqTwnXYFBkkZdBB+5U+mRIamMUBpvZZmHtBUiIGFIFTx+b6yooeU1Lxu1EDwcnbfE+tK8NmMoZ70ch+gvtth+M9SGdTtrh/kFRyL6gBW7budIRL+dK4VX9DAJrY1gGoNEgs2YTFtsL4t13wZGJWJf59XZyVIIRGyqJLTF9eRUHasrLRER0vSIboo0XxrLaoiihqQ/rPkU21+32adDNJo6StIdqe2zQScIXyZ0qewQzQXgKxo6JRimNiKcwnheQ0u1EagCVUYDfG06lUj0gemG3DhcmkX58AOKL5W8Z10v9SnrVtrUUFToNhlmHRIhEQmvwEjUxEiUit7BajR4Tow40P9hadiQyV0TCLYy91EVEaVvyjp1aWe3F5ox2er0p6CYUl8HGktZUSUJSyOPsSobxgTTOXlVmm5NZBWMTQ4hoQ4iiZGmkUQiKKKQ74vfndiBF9KLg906mcqQFAa/bwpMexpuGadK6chq40QuItEvbL/Lthg4KCesdNhE2PaJW7trO1dYSw1/z5pyDw2K6oywUmZ3VmlMthCtDsXRUdIaVPvHHtIpH1kYIGD/jCAXoSIn4omkJhEBmk6N+i0p+WS+vlEkCEQrQK8ERgUUUs9Dq1CoUGugu3XL4KTc0SfR8BFKx0pzx86W1qbXxpacnMMxTEELDIdZUqnaQjweLkbQpiW2OGtqd01WMtBHIit0szDfzzFSbUsUIrdlkEKISBa0ayaJBCMRJEghyzJJKvwUQyHbkxu/Bz/Dcl/3g+HI+JppjC0xieWS2tEpI9/0xWAKQ3fp1JOy1j50qyb4mlEaRh5YmaFdyLU3RIMeEHL1GO2poEV9CElEWhPaRdGoXmgGxpIYIB4rEE0VCKdU59GfaGvyYF1KpbTXlPmuGbQaQLvEhQVGbwcNnuud4bCpMLLZsLu4c4U1CESpoVJ3o24uvDOpkEDohTbJYSODCilM5C5JHJRMRtkQIw266kFVEhEvTrUrqEZtDAeF9PFkDp8T+eq8hqo3iRAs3fTo9SQTpphBKSViQxlN90bYeDOyFJLVCfoOnnf0HCtD+yOc8Is2mkEotte+1QzQyRIhIpVh1CtQ92sSFWH5qZRB0u0yBkIKRiXF4Wm9g6/JDx9JRngppKRTGmcxqkFdQ4G615JrK+6TfqY9IQKev3bsHGVvDE8h9kNJWZAicOzSWMyQJPHOsN9Ax9eJ56nQMD0yJAohJEKnMXgNOfZC0e6bAssQzTzAVIslrDwykNoqlDRA2NRlqUGb5mF85HepqzFENNL5vnOpzpES1jX+VpzVdb9RG6ljIKGw4OHSGX3Ak5+9J87sx4EXK9aIRpg2Sj0Jb1MdIL0yaDJVAIFOHUiEopXCq2qzIz/xRKwXRkBrKpRoRMRul/SGyFhCGKKVxbKeEzpFj9wPSz4f8aoihBz1U/GE4ARLnwiWLYrLtPG8Fn0AS0VFM6BTHbG07+Bzpkq0goCFIzUf2CaYRJOERRwcFdqgqVOIZV4u+gE2npLmYCpAnSmasNDVDUwjUFjJTppMkXhatUA7aUYf/IDpFMYEdLqGttUkEiN+U/QSjLJQ3CniSS9FnREK8LVu5y09MYyIktegIloDRhi6wmKbUeKpS4MtoUJAS8o7qRvRJZ0076LWZCKriskUNSHUREwmNUlfUOiqpC85Iyg+ioaPqJXDF28IWpnn8Nu0uTYtvwl+1+b7VjYKUXakNF1DuyN16Aee+vx93YWfp3Akok+aCIc5xBqR6K4bYY/xlGzrQdE3IJSe1zLBeCwB5FSSczL2USS8q9XeVOzFkFU8pHGAZpNOidxJgcmwgoeDEYkIZH4LMXtpIESroLxQV1VUvAJMPqQFfRL0ZLmcVRZmIuO4ukWoeoLjp8XB2ZgzU3wp/SYCXTJaVQmmPEoxPfF1YIvshhSMmvbYSkcPWojQKlgToSsz+P81URtCiAjNm7QdNQ2tUtS8RAiDJRLUYjBlEXjaZGqp38QQ0yuSrghMy3PdC4PP+cg0jBWV6lqPbkUGnzHaMFbYzpy6ZoVUo1mQjDF1wRJOxnE8jBc1TBQ1NPIKxieqaLW0oFJKO9NQvDzYGyNoaW8IafdN/UmLJmLaG4Lfs1zc3HpDrPknsnbi0BvLcti0GMjfTOU0EQ6bCCPLhrF0yyVY/cCYu8ZzgrX92FvjqWmRChoOpWxqpSdVqdSgRfN4JjoJP/OlqqGIfYS8wx8P0FBV0EUpirXLZZ5FmGxVhTws9XOxZm4xrcHeDayukHSGDslTP8GjR4oTuAKz++ySaceoe2zY58agip05lULdY8zA9HUwd/1DoYcRv4EGrS8UVRUUQzLiwP4bufgqNAoaQOWd0s4aaIalScsy1UALoRAQSyKEMChGLwI5tm7lzWoMVl8o1KW3uHbx5J1J1TQUs0RCvCBsow45piYKnXoMpdA0d/1SjSGkR0dcGjSRop6DJZ0F4yIBRydRiKl2VfbFVEaSxmgnIabGqwgmPG0ulXmIJ7TfBz0iMNHWJmLiC5F1fSJsZGK6R8Ra+2I4AjFXqA5VsPl2yzFo8JwmwmFTYpsdt3Qkoq+YZhNZqtKQyATvUnlnzskx5BTIWc2Ew2PbT4OpDYUgVNKYqxiG+EW0mpF2hEx8xH6CZWGIySxG7tMlUt/hP4I6NgunzFzEiAK9KbQGoFWwwkIbWYmc0ggPCVvZwbmtZlqHt1EgZnSDkzKPwfd9VnQUqBVtNECvBk69xpYbvlRsMCJBQsNH8bowk77slULMgukP3USMhlGMAbDgkpO7Jg8sC+W+uJiIiLGaDE3URKIZ0oG01FTLVD0wTZN3bK21d4Z8M6KHsFoIDxN5BauzITQViViMZq5JxWQrxvgYUxkh8pTW1h7a7Qh+09P6B343wulY0qlTUByLpIkkhZHTdlTrI4xGo6c6o+dvxKFf2OYJW61hyOYwf+DSGf268BV36fuG8t2lnTc6KQOjjRAiwSm9otdp9yL4jRTeSCg9KEgogpC+A0o0BnnGlAadITnx6/2PTdYRxzlGwjaGFC2gc7T8WBOQrMBmIZUMSgyqprjO80Q4yTFWZf4zlQuW5BhI63Bjf8nSTWkt7utqhqCzjSeTfJXVF4q+EkwP8D9gyPOQBk0hGvy8llES2jtSFkmHsCyzQCTVJowu6HSLRBmoeZAogxILb3nfpxeGYiNTVIQF6cnZKiA6fSuMgFHEkQUwKaRBR0uk1JNW18rDI3kVmemPMZYNoVFUxKWTJZ2rJ4eEQNBgimmMlG3aG4GQBynnJGlIlO4VQtLSTLpEwXyfKkunpTFKriEuYzFvvHUGEsqlMxw2IQ4/8lDcdMWt7hrPNaaHp4U02FW2j6Z5bqs16GjISceEuoPJGGFE/wgucgstlRvtyRDeqCe20Zwkw5DTYYCxRh3hUIElQUNC8QzDa0/KiuTq6a0wAtpBM5qgJKrACTT1FIZZLWE7b5ZrSzyhDXKHFhvhom05zkV1IgBcrx0fdZUEIxk67cAogCYo9MMkSCi04ZX2i9BNrcQ9UyZ3HavQVRZGFGoeWT0iJMJEJDqXs+O6qdMFEo+QqIQOBkxqtyfZtE0iweqMAhg3FST0gWA6w3x58ryRRxhv1kXIytLULNM9MvjI8EX8cIGoWSBoMoWhEDQUgqmMblTGGyLTOggTgej8XdhiTo7PRqScmLLvOPx1h2IQ4bl0hsOmxG5P29ld4HliPNXzvNTZU6cwGB7IjWeEvnsNJtqoBB7S3Je7/3SY1soK4ZgSgaXPskuaO0m5If0lgPF2FcMBPSMCTHoVbB5NaC0Ed0mdAdoY5nQvplIemqJB9FDkRYdIaDWEnsht2aG+2dFttKVhlXG85Hp2xoQpmbTbWq2FOELKXTd3rD9BQaS0Au9cD31EkgT9Mfpg6H2RREikwcgjJZ1hDaQ61SXdVue6nNM8lxQGMFloXYi2l6bGg4uHiSKU6gtqSJi2YArj/nQYiaJ5lo+xZh1tGkrloRhVsRKD1t5pO0QwoaM67NgpnhANXYobjLdNOacp65RIRJcYdr77zrnP9NyhH9jtaU9yF34eY0DjRIOPx+22PYaW1DE11uj3UBYxuoLE6as7FRt0rhSbSd69M1QQiiGV38jgVRjID2TCkjbZQYFitY809BHGHlpt3ZKaU37Lq+IBfymWVKawdTQmxIGVBiwnnVBMBvBOP8EyP0WD5IIloUZbQD+JsFDS90ILKzX0vX23wkEmfBkRKyI0rcisD0WJQBhbJdnOTo+i+jDvVxRdItFLIowWw6YnpBxV3tMREcI+s3TBJgbKBZKFKrSFNSMkIg7Vi0QmlI5ATOaxKeHUrb4zqfYo8HBWw3hax1SjhqlGtWQq5SGl9fhq3ao9SAyxarE6Q0chpEsnByH+EJpMSNdWK5wt/T3oM3fEYT4grkZ4wt4D2jNDuXSGwyYEJyn+47jpl7e56zynmCnRzRy51UPYQETZxdLcvUaRjkx4Gbwm4NNoqmlC/5wZeafOqtBHAky2h5CPNjG6pIk09aGKWHpshMtTtMMIq3If43lFnCSXhQ20WYZJJ2afHUE1gbDdPOkhIe6NMnFrUqAdHm2NqhFbmrPR7bX1OTLNwP0yaiCTeOm3TUouS4+de2+aSJm0iIg+bXrD7Jvv8/qwnNNeP0Youp0nTPGmXEMSIh054TYtejsYY0imLhh5IInQfTJYzlmRiMND6YjYWXftw0M0kgirVg2JiyazI7Qcb7dDNMYrCCahCUSjQDSRSypD+nOQQNAXwppLccjm+xSdS8/fRbcluiZU04mEE0nMNXbYfXtEsU1nDRiUIxEOmxjLt93MXeM5x0wqb9tsyZR89qjyFZT00aDWQXd7pKERJ9JodSK6hjSlJoK2zJ5MZMJJKCMY9jE1WUUSxojjFHElw8NjI/B8D8NhS+yj2TJ7WLXFlIrRjFVZjGVB28xhtLsGWh4wxAoDhu5ZEqpYYsmyzXLfiXJ9Re/0p6s8uoF5u2hdg9ACUznR3c5eB0Yy9BbT9IedxmWla9iJP3gd7YOOsNBFU5MGahxJGCgipfgyM70x6JWxOmfbdHbmZFcRWlzztU5rTGYVPDg2gla7IiJKlnJSSNlqxvAbuhojbOt2337qIR4vEDcU/EYC1WoZEpEZfwi2/pYall6xic2rrLXjlqsQmGss23rpnB/TYf3g0hl9xPNe+0xcfs6v+jkEhw66d/UyQ5rJhOJCAX0FjDjQo1rcpDr8yQCo63oIafTEEk7m5H0259Jtqj0vg58FiCJOXD7GGzV4Q5y0jX114UvZYsrumQG9IwIsp6mBB0yaBly8W2e4n9MyUxw5G23JBE+9hE4kaHli7/Q3vTOmaXyu/RtYSdHZUmsp9LPuOmoduuH+kq+DqazokBZz+XS0wyRaTFUGnSepfSABYgqB7/J8GuZ8bBXGVFHFVB6JpwarQpqFTmu08hhjU3V40l3VE/0DK2HSJICieLKhDaVYjUF7a9M3Df6k9n+QyAlJRKpFsh6/Szk97s/oIiyBcJhXOOJ1z8agwnPCSodNDSeunCcw4esevylOjyUzJFupIfQiZbVGLv4RXBdOhlDs9t3yxCWxtZk2eUgf8ZAsp0qBPSpyUf2LpwGrOQoFb4TpihxJGGHcaCd8b0qkF7xZZqSi6hVY4mdixESQQHDyJm1hhIJ38zSvFn3DtBtlG13Qz81plAo5tUCz9xP23Kfvp0weyltrIWVHStn5j6WmnKpt7wtGVLSBlN4311FA2VQ+EhFQVoQ0rMrrQhQyhKKJaOURHlo9LLbW0iCMe5cGnLoiw5tSiCdyVMYK+E3jDUFL8skcmGpCiamU7o3Biyqv7XdeuiJOAzE/seuBAyxAVy6d4bCJMbp8BNvtvA3+fsd97lr3CzM4EnYy33Z9xxabSkC28ZRyBIjYICsQrm7CK6pIhwJkm/sIuEmrkLbiKb0blnloeSHybAhRmCOupggjhdWTNGygsVRNSj83DycwlcfICg8tP8CwSpH7qTS8ygraTWtNAxeSBkYmYCZqkgrpxWHSF7pHaG+NQffcepMea96EG6JhT7+jpShHJMr700RC6xx0qWZuqkL4rn7eJRSWVEgvDBVJ9IFEgq3D0yLEA9mI+GlMpDFWN0gqAkxOVnV/DEYgUh9p0wfGgKjVcaeSiARLOsNmjmB1W0cfrJ7FWlt3Uhhdq/OutbjDfMJm2y7DFtsPcMpXORLhMAfYcc8VjkTMy5LPNS2QxR+Jd7JWYShNMBiNKBBMJsjqFQSZJwl/v21mfC9AkYdoVULkSzKoaoYwzpEkAVqtOhqNKpLlEUYqLbF1HgfNlYawZTSmyQDLPDOFpWEb1Q4x0MZPfE88JEyKg7pBEpeIqQ6aQ3X8tEykZVqX68f6jTPmkyadUS7R7F4tqapgVKSgMFL7SujyUXbY1I6TPA8rniTxIclYlVWlrwi1INQ83J+OSgWGtbZ+KBnBgw8vkW6dYril6EZpemOMhQiaTF2wfLNANK6Vmh5bn7MiYyLRxME6j5pFBLISXbIW12v8MfR83w79xeP3WOGcKgcAThPRZ+ywxwpc+aPf9HsYDtNLPs2tqTyYkg15l6WBYontmWqNXHMNVis87IPay7ym0NpSd85kW0qKB8MESP1QN9Gqehgfr0nVKAWXk82aTL2xV4fKPbGobqoqVE5jqgyRF6GtYowELYz6iYgTKUSkdQWtrvUkreMBWqyoUxu0oKbDJN9hq3HdDbQbg+gVRpaFpeV10x5F08DR6ggDF6oQWHWhja50nYgyFSWJtBnXKRLtARFjvKigmccSeaANN70gqH1gZQbTI+NJFZONmiYMCZuaaaEmLa2zSV1SyzJOqcZgBW4OVB/WxlLeqhYUDaVsBEI6j2khpWJKo3NiZX8ISx8ceZhP2H6XbTHI8JwmwmEu8Pw3PAff+8gP3cXuG9YSyO7YHxv1fmlb7XSoW2hJeqNehRcEQJupBw/ZSEUyHXRK9FuZNNZqbxZCNXm3HqIRVQyByOAHOdIsxPjUMNIsxmitIeJDpjXanna33CKkvJKTtY9WHiL0SSyAOlLU2VBLbqytY6TWS3CoUlWhumWa3SoLXXHBKg9tYlUO6XdTHFY8SRWBLinlZeE42FPDbGeIFtMT1i2Tugfr+zCl2Owr1pEIRhlgTKSKCA+kw4h99uII0C5iOefxVh3NdowiD5DlHpI0ECJRsLvnOCMQCpWHcqnEYB8zLiQRokmZzOAzbWEaa8l3Q5JnScVMFZtlQe26/m04zAle9LbDB/tKK5fOcJgDbP34LbFil21xz+33uuvdF6xlktCqypJhoZ5tO42AbL59pK7vcnMTGkhTxJEHvxWiiHzkFQ95zUO6RIv+WPrJttVRrEs0WbHRaETwGUKgoDDzkdfZ84IttgOxxJ5SGfKcE22AwKtgmFOxl0kjLC9oSaSjQyBYAlqa3bWbpJ7ctV+DHj9JhPTDMHfhXGh+zWhFUPr9s6RAS0p1dQVLN7XHA6MdWpBqhZNCJIRQ2MhDVVIUjDrQRIrpCRIpkghGHh7JIunfsTqtYnVjCFkao9kKxc6anTmpg8hMJYbHXiXi3w1ED7Adu3am9FOmk3J441OaQNjvho+tdsdUShtlGTJRjkSslSc4AtEvbLFiMzHkc5j/cOmMeYADjtjXkYh5Xa1hFfylckeZeX14bCvNCYuVGnI77Is+wlM+8honWR8qghAIpXMNYp6ULue+2FwoQLM9jJHhJhJfSVlos1lFY6SKpfWG3PlP+hnaHqsVhjAaNPWE7wfIPBKLUNp01/0UsYkwSBVEoTP/pjWXTOzS6lsiFHo73dlDJzBsFEEMmkpEgtuQLGhBpyYhbB7GbVmayfdJJCzRKMz6ZkHSQLOoQAhE27wey+vSOTRXoegh2FBrvFnD2PiwRB5YmcLIzOQE0z2FrsJoB8BqD9FkodMXiSfNy2hpzbQGDab8ybZUvHTSGCR2TGPY76unGqPkB+IwL3HA4fsOvB7CWyTpDFsa7tBnEuEwANUa9n0JgTOcricrfefLmLpxvaQ3wVQLQSuHn+qwu/RyGMsQNnJpDuWtglQYrH54SJwsaZw0MV7TQst2hEazgocnRzCWVbEqq2NlOooJeinkFXmczKt4KBuSkshHsiE8kA3joYwdLn1MFR4eYJOqnD0o2Frcw5TSj+1CCxvbpkKCj1NmaSlfFm47Zd7rLvqz5X1x3zwGj8Vj8tgP0xQqG8bD2TBW5zU8lA3LeBmR4Ng57vvTJXgkq2M8q+LhqWFMNqoimmw1K3IN0oQCyhCrHxpGwiqM1UAklRc5orEcIa9f4elunRMZvMmWdp80DqPyfRQUUvI7YeSht9B1DfowID/WiwlPfu6eGHiojbCsB6644gq86EUvwrbbbisE7LzzznvU7S+77DLdbG/asnLlyvU6rotEzAPsc+juCOh4SHm9Q38xw92PxCGmGSR07pJk0jL9NYqg0ynSi2NxpiSx8OsVRGMUZBZobhWAt/Je6iGjHXbMyTnCBNMRgRKdBKMPYczkgod2ugRTlRqGqy3kQYLQy6E8D2OcH+FjSTAlltCRytD0YqzKFGqynULby6WNd4F2pzmWtAExLpT8a5MIhbGyLoN8SNtn60oLac9t7K35KA20lO5vIW26aQ4lDbEYlQiRSJVFiNX5kI5feAUaKtZLFmGyXZXeIoWkLALjQBmZbpwe2lMR/EkPHj0f2JEz1f4PlYd5rX34GcTS2m8lUM22MQPjQE0kIqHRlI1CdP6vSwDLX+hg3/AuPHjAfs/bp9+jGDhMTU1hn332wRve8Aa89KUvXefP3X777RgdHe283nLLLdfruI5EzANUahXs+5y9cP3Fv+v3UBzWCtsems/NFGRD5KzYIHngzFph7iKACkkUMkl3sKFVPhQhG2FFgS9kIggYuvclLVA0PLSjCFGkqx5IImJj7SztxMWlMcRUmCCrMQLAZuEeYp+tqShMzBEVWiPBdTRqItlgySRTB+MqRtXLEPl6HWsi6D1BoSYJgHZ45Ct9npK2YBpGdBNMSDCl4UsjLEnFFLp5GMtJqdvgcaU7aV4R8hCgEN8LtvKeKCryHi9VOw+xujmEJKPfQ4hWO0RGwyhqKiyJyAJNrqY8hHSgbEG6owZZAT9X8DOFaCJDMJnCH2MDE9sozUSDjKBSIhMdJ0p9XuXv0mH+Ys+n74olm41g4KHmVlj5ghe8QJb1BUnD0qUbbi/uSMQ8wVOO2NeRiHmBtSvyuxEJu40pmbSNu2QSU1As/cwjoNGSW3l/XFcQFHGIaLxAJQVarNZo6LC811LIEx/J0hBFTQfbJ6eqQh7q9ZbWOfiB6AempuoYGmpiqNpGNUglqtAqMtEekBjUVCJEhJM/yQIn84rHKEWOsGBdBckCQ/80r9J35HTS5FET0/hLfJhMJQaMQJJCTX6SJZy0pG6bDpvssUlykRkSwTGSVMixVYgpY1s91Ypl7Iw68HjcF/UfTN9wLBRPkjRlrQD+aoV4shCtBdNArMSoPpSjCKmHUIjGM2DSuFGykZax+CRpEzJRiqxYj4seIeUGfPcOc4eFkt71ZvnXZD87Pj7es75SqciysbDvvvui3W5jzz33xEknnYSnP/3p6/V5RyLmCQ54/r7Ae7/d72E4rMM/+453hOmMKTl3m4+nCpG5xWbLeEmE7OMtkYrKyhzhaIyiFkg+n17WwVSBrGaOWvhIRwPkkYemX0GlnuoS0JTJCE/cLjNab/sF0iySlEc7ZsVGgchXiPxMzJ2k3NPLJCrA50NBSxwgSTJ8xYbjIWp+IlEJSyL4OVZMEFVGOLyiRCJ0mSYJg44++EhUgKm8KiJFlmmSXJBENBXLOQMkeSD7nEyqSJMIWRqg2WKlBdMVjG0osbGm90O7SdKlUGQ+wnH6PVA0yYXaVa19kOZaq7WRlLT1lmtN0pDBy9kkjfqU1JCGrhul/l5sue5jwRGI+YCn8LfQoYMVK1Z0XwA48cQTZbKfLbbZZhucccYZOOCAA4REfP3rX8ehhx6Ka665Bvvtt98678eRiHmCHXbbHrXhKpqT9PF1mM/oGBOJaE/fupssh863S68GpQmElD5EUEUCr4gQjvPmOUY4zDbiutywtbmOaEjFQYsloT6KyJNSUNmtx+KPHHmeI8ozBEGBnFUI7QitqCJ9OapxikqYIAkCiQyQQJAchCikcqLic5pnV9BAMgB8jA2JEAKhws4USr0FoxeMVIhJJwlDUZVTIhnhp+hfwXXca5FB0iiNvIKpLEY7Yyomkpbd1DjwGuUZCUMsJEJSFiQSPPdHYl1tkSoRTwYZtQ9K/CCqD+vW3crXFRjBhPblUNQ78NqX3SilEsNU5lohpaQzTCM1l8EYCMS1GDs9eUcsCKiNk8645557ejQLGysKscsuu8hicfDBB+NPf/oTPvvZz+K//uu/1nk/jkTMM+OpH33+gn4Pw2Edwbte3bLbtuQ2JlXUSFDKaFIdNKES0GGKFQVJgmo+hGIoRF6hcDAQy+ZoQiEZ4T9JrXYUl0YKDGOFIvdQ5L48UoDZavNOHhgaSpEHObKE+oOaWERXq4kscZAh9DWJiIpCSi0DscNmLw5qKvR71DdYEyo5BfOsYqIXjERMFRXRP5BwRF4mfg8USbIDaUJb71YkpIfrPV+JxwNJBD0w5DJQJNo2kYicIuIAWULhJK+HtbBmM60MitEHEomkEE2EP5UhGJuSklrRPbTa5hpZEpHp0k5j790hD+ZsdDaD35WLNMx3PPfVz4DPfycLAN5GKvEkgSiTiE2Jpz71qbjyyivX6zOORMwjPPc1z3QkYlBgJ6VOgwm72qyXZk8GnOiqsXZO5F1yGMIfb8BPK8BIgLACROOACn0UoZ7CKSDk3ThFlxRTJiMR8qp2p+TEzeNRdEmjTLb0FnLBO/aABMGXaABbkjMdEpJMBLm8T8ElIwxs8EWCkZQIhJgyiR7C6yyxl0r6gqkO7pfaB9pQ09MhyyNxlqSbZJZoZ8mcRKeAmGdlRYBWuyJCSUZFGH2gkDJv+2A5Cn0exHmS2geKKJsK8ZiSdAULXYJGjnA8g9dqGxOprJs2EiJhLK3NtZZrP+076vmuHAaCRCwYqMFzrLzxxhslzbE+cCRiHmGXA56IbXfaGvfeuX51ug59QIdA6EfP87XZURnWOZHzVxgAWVM/ip5CG1WFSQafUYVaiKKiG0rRzIkTLMsps6UsZ/RRsPdG1UdWiekaBa+qENfZnYJVI54QBhIISyJy+iT4hTSu8lmVwfdIKpjeyALjlpmIzoI3+JzkxYRJCJGuEJGMQRYgSSN5HQRaxEgSkQpZYGqErbl96axpSYRePCESrWaEpBlBsW85b63Y84LNsxiRaVMkmQuJ4H9Bi+kcvd5vZPCnUonQKJY+W9GkSVugnUyLOFj9pCYMnb4gM/h+OMzfrp17HrJrv4cxsJicnMSdd97ZeX3XXXcJKVi+fDke97jH4bjjjsPf//53fOc735H3P/e5z2HHHXfEHnvsgVarJZqIn//857j44ovX67iORMwzHPSiA/DDz57f72E4rAtKk5MI/YzbtH6iRYH2OehlIATCTHxhAEVxJR0g6dvQLpAPxwirPlSLRkkKWV3/C2U6I088hBNAPhxIlUKR+mi1Y6TDoaQ3LIEQEiGTeCaTPdMLlYpOeXBqJSngsEgwotxHGBiSQ71EolMpcSwm2TJuEgK6RpIocNhBmOtmWrnWOIjuIijElppko0siAiESeYPkwBefB3o7+FMkDRANBFMWEbtwTtHsU1+rgK6UU4lOASX0yqDgtGzqZR5LzqFC3mzXNEMkOrdxjkAMDJ7ygv0QMLS2kKDm7lDXXXcdnv3sZ3deH3vssfJ41FFH4cwzz8R9992Hu+++u/N+kiR473vfK8SiXq9j7733xv/93//17GNd4EjEPMOhrzjYkYiBhJ7AGJEQBaJMXpZEyGzcs6k0gSDxYGTB5ID9h9qoNKtQQxGK2HyWu4uAiJqIGvtOKNAmoohIPICctgjVAFnFE8MyRiQ4zzZFlMkURwHFyAGjEhnTCiQQ2vyJfTqCUJMfIRCGATWaSnp66KyMLw6SOjKhiYQf6ggHSQR7XNgECH0emNrI2Q498QFWWTBNQY+HVBMH6j4okixIfFIaRhXS1pvv+VOJ2FfL9bCiyTZ3EGgSYfthlNxBO7mkzjV3hm2Dimf9y0FYSPDm2PaalRUdW/4ZQCJRxgc+8AFZZgtHIuYZdn3qznj8Hivwl1vu6fdQHNYbpmJjuhmVbXuV042SokvGHk1qQ+68UgnPe2GAYKolbouKplVZIJNjQAIR0+SJYgMPReohp24zo4mVh4KTeuQhr/hIq8wYMHXCnh0KfqRQG+JQDIGgJ4SQCIUoD6Q/ha2g6BVW6oiEGF0loZAGTSR0zw9+vjlVgUppaUkbzELcKn1aYzAdkRai62B6pgg9aYtOjweKJ6NJBS/RRILpC0lptEzXTSELhnBZW3GWy3JMNO8y7bwlXVEypNRpGEcgBhVbP34L7H/Y3v0ehsMGwJGIeYhn/cvB+MuJ5/R7GA7ri1LovLfXRmkT3k1T4EDkVDqyYiPVhMK6LDIAkReI6dY4FUPVAonow6NltoJqKVSY/iDPoDYh8qCY4mC2hCJLlogG9E7QhGOKRhT8l05NhN8lEWHmI2naMlJWbWh9hdQ5mHbelVqCPDMkgumRgsJG3a3La2v7aWnHndE0i66SXEhwdHSBfg8UTZIEsT26iCmbhaRvvGYGv0ndA3UV1D1023fLwuspTqDGQGqa/sFWY9hMhsPg4tBXPH3hiV/V4AkrNwSORMxDHPrKp+PbjkQMMMo9G+xT21rcTHoECUXDaCUYjg9NSF5aVjNvwI6Z9IMI4VciiTx41DSIKyaQVXTMg3f69FLwcw9pnXoJiG6COgPlm1B/6GmSwSX0kDOiUVDTQPcITRgyc0w7dvGVWB3LvkkApF8FradJInQfcO24KXbUEGJAjYNUmBSGREyxAoOkQkdLAqY4JlLd/ZREgboHm4qgvwY9IEgaLJEopYE60Z3yXNPRPwzIL67DWn/zFhq8RdLF05GIeYjtd94GS7ccxeoHeu1OHeYxOpUapcqNsrhPnk6705KeD6ZdtSwmHM91nFiZ0uBncob/E4RTAQKWilZYyaE9JzzqFMg7cpZbeDJ50/yJxIIhA07sKa20DdEQQsAmWlLvyc/qcXIf1CqQROSVLtFh5QSkb0Uh/g3cPyMP7MoVNZWkULg1UxdCIia1ayfbnnPXAdt1p4xaFIjaLNc0kQVeE6m6oO4hMQ3MVDedsYb2Ydp1Kz/qkZbrbJ2gcoAwvGwIT9h7h34Pw2ED4UjEPMWRJ70Cn/+3r/V7GA7ri7VNeNY2sachaFcrIROmlIFygpWWnt3mUvyENoEQAkBHTJ9VD/SVaFEcQf2DhyLSos4io2W1jgxIJCI1JIKbFmxNTldMpkC0joFgeSUjCjKqwENe1WJPOV6uxZDcF9/rkIiGQlwUKEg6RA/B9IXWQ3iMVKgCPvdrHTxJjqTfhem0SQiR0D0w5MLYVt4dfcZ00lDuX7LGxXcRiQHEqz/0soWXyiBcOsOh36YrX/vAfzkb7EFB50dQPVqzDfN6pgnQ3IXb3Uhagb4KDBEYASbLMSUSoHt18NFj3wlGFKIQfhTAS3yohi+pBJn0GXlgsMNEKSRiIVylEHMrplmYYmCHzDIKWmvXGGXQAk6SA0ZEFAWURtTJ0kzZJ7US3L8YZOXwktw0w9L+DrYlurJdNi2JsESCxlGmRHaNy1e+Vp2ITlc7MuN1X4gT0gJFVIlw+FGHYiHCc+kMh36iPlLDc/71GfjpVy9xX8QgY3r+vtNkw6zqmTWn6SUY+rfkQRZdQy+TMftFMDpBFD68NJWogT/BNuSBuGJysmcEw6PrNkkHRZGB3yEBKsrFJZJCSK3Z6E0DqPECeZ3kQAsiJVIhaQ094dOSWq9jBYkhDjZVocw5GNKgONZyuqJMJOxneqjATGRM9xrRl8pFHRZKWefoQmj7vYjh0hnzGC96++H46dcucZqxgUZJJ1EOyXded7ejxUQH1lvCpjl4p87ntoKDuw1Doy0wO6K/gk+jqlAEijqOAATKNAMjgZBtPAQTLMv0tOahc0ytieg6ZgFqTAszqXngIx0khQBI1MRO/IaAiJaD0RJd5irnRuGkdZmUsZptrO7BnqvZl/APcf5Ua08L2S6dLuIw8HjBm56LBQvlqjMc+own7vN47PzkJ+CO3/6530Nx2FCsrQc1J1JrlmSj9J15Uz/piUrwjp8TPEWIfId39rFpQkUIOTCLpDt01YW0zY6MU2an8qKAz2Ob7TsqcKYfRI+h2YwINi2ZkUmbZlNGk8BISJpLSsTuU0iBJRE2PSEVGMYoyo5hGkno6h660QjbzGytsIEIl7kYWDxut+2w1yG7YcFCORLhMA/w4nc8H59+w5f6PQyHDYJaN60EjZ46ts1GUNhz521+jfLSdpzwxXzKkgdDLIRE6AiFaCdk87CrP7B38B3xpnah5PsUXcomsi/mPAzZsaJHSwJsqoJ6B5abctueSIROe6xBKCQV09tdU+IYncZZM/g+PKr2oXMR3d/nAOLFR79gYQoqF5kmoq89Vx//+MfLH1F5+fjHP96zze9//3s84xnPQLVaxYoVK/DJT35yjf2ce+652HXXXWWbvfbaCxdc0NtOmz9SJ5xwgnQnq9VqOOyww3DHHXdgUGywR5YN9XsYDhuEx/iB7DpS6clyegOv0tszQhwd065JU2IWChUnpqDY/VLWJVpfwf4djGSUF65vNKVTpt2XPG809XvTt6evBdcniexb8fnElD6mPT51ENxXqcNm55RLPS5mBK/BevW+WLiT0EJGdaiC575mAXXsXMToe+P2k08+WRqD2OWd73xn573x8XEcfvjh2GGHHXD99dfjU5/6FE466SR89atf7Wxz1VVX4VWvehXe+MY34oYbbsBLXvISWW6++ebONiQen//853HGGWfgmmuuwdDQEI444gjpXDbfUalVcMAR+/Z7GA6bCj3+EdYvotTSulPe2H2pl5Ik00YLOHGz1wTJAkkFJ/1m0zy2eomDXaYaQgDYpry8CCmQ90rb2s/bfdl9izU1CYohIiXthg5gMNpQHnvvuWmN5DTy0MnxOCxE7HPoHhgaZYe5BQy1EZYBQN+FlSMjI9h6661nfO973/uedBr75je/iTiOpWUpW5t+5jOfwVve8hbZ5vTTT8fzn/98vP/975fXp5xyCi655BJ84QtfENLAHzC2PP3whz+MF7/4xbINW6FutdVWOO+88/DKV74S8x1HnvQv+MU5vxqYPyqHdURZcLnGe9PTGdPMlCxKAk09ZduURwlWR2F3Zz8n6Qqzb9FIGMGimkkAOt2Fc800gt5ElBgznEdJPFne0aPqHqxPhsNCw+tOfgUWOjzeDMzi73c2n11UkQimLzbbbDM8+clPlkhDxhCowdVXX41nPvOZQiAsGEG4/fbbsWrVqs42TE+UwW243vZUX7lyZc82S5YswYEHHtjZZia0222JhJSXfmH7J22LQ//l4L4d32EToNPkcy23HT2pjp4QRM9m3bv8mVME+n3jhqlKGgWpjrB+CzadYl6X10nnzFLVhdlPZ79rHHDamHoH001X9ChJ1zCH6C5ynVzKYiHhaf9vf+z05Cf0exgOC4FEvOtd78LZZ5+NX/ziF3jrW9+Kj33sYz2tSTn5M2JQhn3N9x5tm/L75c/NtM1MOPXUU4Vs2IV6jH7iFf/+kr4e32Fj49EmxhnEgiV95Rqiw/IkbCZ3vUgrrTX33iEA5ffKJKV3vU1JzDROHqNLVKbtb/oplYMrM56cw2LAovktU4sjnbHRScQHP/jBNcSS05fbbrtNtj322GOlB/ree++Nt73tbTjttNPwn//5nxIF6DeOO+44jI2NdZZ77ulva+6d9t0RK3bdrq9jcJgrTPeQ6NRBdpdOesEaMM1w19/ZvEQsypUSpfXTRQud98q7LKYRhtL+px1cr58e2eiMffp5lc7ZYUFjy8dtjj2fvisWAzw1+2VRaiLe+9734nWve92jbvOEJ8wcymKKgemMv/zlL9hll11EK3H//ff3bGNfWx3F2rYpv2/XsTqjvM2++65dsFipVGSZTzj682/ABw8/pd/DcJgP5aGy2m6jy0R7dAZrOGWW9AWGHEh5nSUZjzaOnhbcaxnXGpUlpWOukY4oazrsa0ciFgPe/tmj+j0Eh/lOIrbYYgtZNgQUTfq+jy233FJeH3TQQfjQhz6ENE0RRexoCBFNkmAsW7ass82ll16KY445prMfbsP1xI477ihEgttY0kB9A6s03v72t2OQsP9he2PXA3fGbdcMRnmqw2zwWJPqDJNzZ26fQR/RMbcqbbpG6mIdMW1f3Z3OEEHp2FM/2vk4ArEY8Pg9V+DpLzkQiwZqlimJAYlE9E0TQVEjqyZ+97vf4c9//rNUYrznPe/Ba17zmg5B+Nd//VcRVbJ885ZbbsE555wj1RhMg1i8+93vxoUXXiipEKZJWAJ63XXX4R3veIe8z7stEoyPfOQj+MlPfoKbbroJRx55JLbddlspBR00vOIDusLEYbFjLSmPGaULG9kiem1VEzPILHrG6rCo8cp//6cFbS41HS6dsYnBVAFFlZz0qYFgxIAkokwQKGi8+OKLcfTRR2P//ffH5ptvLqZRtryTOPjgg3HWWWdJCefxxx+PnXfeWUo399xzz842FGtOTU3J51avXo1DDjlEiAfNqQYNT3/JUzGyfBgTj0z2eygOg5DymClisTEwY4RhpgoTl6pwAGojNTHOc1h48NTMsmuHaWAKhKSGIsvR0dG+Xp+fn/VLnPqaz/d1DA6DgLmYwB1JcHhsHPOVt+KFb+4txV+ov+Pj5hj7vfKjCOINv1HNkxZ+e/aH5sWcM699IhzWH89+1SHYeX9XZ+3wWJiL0PHiCU87bHijree//tmL7vJ5i6Q6w5GIAQTzim/46L/2exgODg4Oj4nXf+RVCNjOfrFBOZ8Ih3mMAw7fB9s8sddAy8HBwWE+YbPtlouOy2HhwkUiBhjHf+/d/R6Cg4ODw1rxwe+8c1FVZEzHQk9lEI5EDDB2ferOePo/OZbv4OAw/7D/4ftg32d3q+QWHZSa/TIAcCRiAeQbHRwcHOYb3vBR99u0GOBIxIBjh922x8Evfkq/h+Hg4ODQwX7P2xtP2v+Ji/qKeK46w2FQ8N6vv10MqBwcHBz6jfpIDR84UzsGL2ooV53hMCAY3WzEpTUcHBzmBV574sux2Ta6dYHDwodLZywQvPAth2H5Nkv7PQwHB4dFjNHNh/GSd76g38OYF/CK2S+DAEciFgjY/fSEc9+3qMupHBwc+osPnfUehNFGbw49mFAuneEwYNjj4F1w2Guf2e9hODg4LEI845+fhv0O27vfw3CYY7hIxALDmz/xGoTRIrSYdXBw6BuC0MfbPn2k+wZKcNUZDgOJZVstxdGff0O/h+Hg4LCI8JZPHoktH7dFv4exqM2mrrjiCrzoRS/CtttuK2nt88477zE/c9lll2G//fZDpVLBTjvthDPPPHO9T9NFIhYg/t9bD8eTn7tXv4fh4OCwCLD7QU/Ci9/5/H4PA4s9EjE1NYV99tkHX/ziF9dp+7vuugsvfOEL8exnPxs33ngjjjnmGLzpTW/CRRddtF7HdQqYBYr3fPWteP0u70KeDYjE18HBYeDg+x6O/frbEQQuhdpvvOAFL5BlXXHGGWdgxx13xGmnnSavd9ttN1x55ZX47Gc/iyOOOGKd9+MiEQsU2+y4Fd70idf2exgODg4LGEee9C/imusweNUZV199NQ477LCedSQPXL8+cCRiAeNlx7wQex6ya7+H4eDgsACx8/5PwCs/+E/9HsaCT2eMj4/3LO12e6OMb+XKldhqq6161vE1j9FsNtd5P45ELGBQXENLbM933hEODg4b/7clCF0aY1NjxYoVWLJkSWc59dRTMZ/gNBELHNs/aVu86eOvwdc+8F/9HoqDg8MCwWtP+Gc8cZ/H93sY8xtqlu28zWfvuecejI6OdlazkmJjYOutt8b999/fs46veaxarbbO+3GRiEWAf3nfP+Kp//Dkfg/DwcFhAWDfZ++Bf/3wy/o9jEWTzhgdHe1ZNhaJOOigg3DppZf2rLvkkktk/frAkYhFgvd/62hU6nG/h+Hg4DDAiCohPvDtd7pqjHmIyclJKdXkYks4+fzuu++W18cddxyOPLJrCPa2t70Nf/7zn/GBD3wAt912G770pS/h+9//Pt7znves13EdiVgkWLrFEpz4w/e73hoODg4bjOPPOgZbbL+Zu4LzsDrjuuuuw5Of/GRZiGOPPVaen3DCCfL6vvvu6xAKguWdP/3pTyX6QH8Jlnp+/etfX6/yTsJpIhYRnnLEvnjpu/8BP/zcT/s9FAcHhwHDC9/yPBzyTwf2exgDA28DDKOmf359cOihh0I9igZjJjdKfuaGG27AbOAiEYsMb/z4q13LcAcHh/XC6GYjeNtnjnJXzWENOBKxyBDFET535Ucwsmyo30NxcHAYANSGq/jsL09Btb5xBH2LBoWa/TIAcCRikbpZfvC77+73MBwcHAZElP24Xbfr9zAGD2p+O1ZuLDgSsUjx1Bc8Gc9/w3P6PQwHB4d5jENfcTCe8bKn9XsYAwlvtmWeGAw4ErGIcezX3ub8IxwcHGbEPofugQ/+17vc1XF4VDgSscita/kjMTS67u5kDg4OCx/VoQo+9N/HOFvrjeFYqWaxDAAciVjkGFk2jNOv+ijqjkg4ODiQQNQr+MzlJ2PZVkvd9ZgHjpXzHY5EOGCH3Vfgw+cc666Eg4MD/v2/3omd93uCuxIO6wRHIhw6RlSv+f9e7q6Gg8MixkuP+X/OUGpjQbnqDIdFhqP+41/wj/+2fpanDg4OCwNHvO7ZeNtp3d4KDrODp9Ssl0GAi0Q49ODfTn89dth9e3dVHBwWEbbdaWu8+4w3u946DusNRyIcehAEAb7wm49j1wN3dlfGwWER4In7Ph5fuvbj4mbrsBFRbIRlAOBIhMOM6uyPnn8cRpYPu6vj4LCAwaqsj11wPIaWOBv8jQ3PpTMcFnvDnTN++0lsvt3yfg/FwcFhE2DpFqP44rWfwPKtl7nr67DBcJEIh7Viy8dtgVMv/DCi2HWMd3BYSAiiAB+94Hhsv/M2/R7KwoVy1RkODnj8Hiukg58zo3JwWDhulJ++9EQ8af8n9nsoCxvKOVY6OAh2ecpO+NgFH4IfuMCVg8Mgw/M9/Md5H8Ceh+zW76EseHjOsdLBoYs9/v/27gQ85mvvA/gvskdkkZAgEUkTsTYhJKSKXiH1RtFSoUqkammVEtdWams1iqK19/ZF7/Wq5b2WW1vrIt1iDamloqh9SShBXJHEnPv8TjvzzMSQmclMZv6T7+d5zjOZmTMz/znzX345a3wkzdo5mVzc0IMbQImcXJxoxtb3qHmHZ629KWBH8K8lGLWq37i/DydHJ+w2AEpbbG/k0kFyZlqoIKJyNGegxxwYpW3P1uTp60nvd0mnoofFKD0AG+fo5EhTN4yhVl1irL0plYqD6o9UntcrAf6lBKM179CUxv/fCFk9CgC2i2sNRy0bjAACLAZBBJjk+VdayeWCXT1cUYIANsjZ1Yk+/nYyJab+xdqbUjmJytGcgSACTNYwLoKmbRxD7tXcUIoANjbr7MSvRsl+TGAlAvNEAJQppmMULT74MfnVxqx3ALYyE+WC/en0XPdYa28KVAKoiYByC6pfm+b/8AEF1KuB0gSwIv+g6jQnY5qcJA6sywFrZwAYLjA0gJYdmU1N22ISGwBriIx9hpYdmUMhDYPwA9gCgT4RAEbhlQBn7pgkmzgAoOJw8D5711S5cB5ARUJzBpiVi5sLpe+YSP0mv4qSBagAyWO70ZzdU8m9Kjo421zHSlU5kjIGZ2CyKbDM7Hj9p/aiatWr0udjV1FJUQmKGcDMqjg6UOqHfaj3uJdRtjbcJ8JU5XltRcJsQWAxL49IosjYCBrf6QN6UFCIkgYwE1cPF7kORlQ7DOG07SGeonyvVwA0Z4BFNWpVnxbsS6fQpugtDmAOQQ1q0/wfP0QAATYBQQRYXEijIFq4fya9+AZmzgMojw59n6clh2ZReHQoCtLWCYzOADBrh8vRX7xFA9Nfw5obAEZyqOJAr0/uKVfR5dkoQQFUZkgKgJoIqFDcCYyrYn0CvFHyAAao5udJ877/gFKmJstOywC2BEEEVLjIFs/Q0sOzMK8/QBkaPxcpp5VvHB+JslIYB8xYWT4zZsyg+Ph48vDwIB8fH715Ll68SElJSTJPzZo1acyYMVRSojscMCMjg5o3b06urq4UHh5OK1eufOx9Fi1aRPXq1SM3NzeKi4ujAwcO6DxfWFhIw4YNIz8/P/L09KQePXpQbm5uOb8hlIdfreo0e9cUGr7wTariiFgWoHTzxdBPUuRKuYH1aqJwlEhYp09EWddDbXw95dot7cSvM4bFzt5FRUX06quv0ltvvaX3+UePHskAgvNlZmbSl19+Kb/Q5MmTNXnOnTsn87zwwguUnZ1NI0eOpDfffJO++eYbTZ61a9dSWloaTZkyhQ4fPkxRUVGUmJhIeXl5mjyjRo2ir7/+mtavX0/fffcdXb16lV555RVLfXUwEO+wXd9OpE/2TJXrbwAAUWBYTZr5zfvUY1QXqlIFATYYzpDrYWleXl507do1Tbpw4YKxNS6WndGCAwO++Ofn5+s8vn37durSpYu8oAcEBMjHli5dSuPGjaMbN26Qi4uL/Hvr1q10/Phxzet69+4t32vHjh3yPkdaLVu2pIULF8r7KpWKgoODafjw4TR+/Hi6c+cO1ahRg1avXk09e/aUeXJycqhhw4a0d+9eatWqlUHf4+7du+Tt7S3fjwsdzKuosIj+Nm4VbVqwHUULlVbSoAQaMjcFs09aSEWcx+/++RkdGv2VnBxN7wRb8ugh7fpljlHbWtb10NDrszGsFubyBbxp06aaAIJxxMQ/wIkTJzR5EhISdF7HefhxxrUYWVlZOnk4cuf76jz8fHFxsU6eBg0aUN26dTV59Hn48KHcFu0Elh29MezTN+ivy98m3wD9zV8A9srL35NGLBlMI5cNQQBhL4R5mjNKX4f42qSPIddDfQoKCigkJEQGG926ddNcf20+iLh+/bpOAMHU9/m5p+Xhgnzw4AHdvHlTNovoy6P9HlyrUbpfhnYefdLT02U0qU5cwGB5iQNeoBU58+l/3uyA4oZKoWNKO1qR8xm9NKSjtTcFbFBwcLDOtYivTfoYcj0sLTIykpYvX06bN2+mVatWyZoL7st4+fJlywQRXB1SuhNG6cRNBfZgwoQJshpJnS5dumTtTapUq4GO+nwojf/HcPKrU93amwNgEdUDfSjtb0Np7Ip3yKs6Vt+0OyrzzBPB1x7taxFfm8yldevW1L9/f4qOjqZ27drRhg0bZPP/smXLLLN2xujRo2nAgAFPzRMWFmbQewUGBj7Wa1Q9YoKfU9+WHkXB97l9yN3dnRwdHWXSl0f7Pbiah9t8tGsjtPPow6NBOIH1dOjbluK7taTlE79CXwmwK0mDO9KgWa9TVS8Pa28K2PgCXF5eXgb1ifD39y/zelgWZ2dnatasGZ05c8YyNREcoXB/gqclbjowNAI6duyYTq/RnTt3ysJq1KiRJs+uXbt0Xsd5+HHGnxUTE6OTh6tj+L46Dz/PBaOd59SpU3J4qToP2C53T3fZV2LKxjEUFFHL2psDUC6BoTVp4lcjaeTSwQgg7J2o2CGehlwPy8LNIXxdrlWrlvVX8eSL9K1bt+QtbxgP0WQ81wPP1dCpUycZLPTr149mzZol22wmTZok53NQ1wAMHTpU9jIdO3YsvfHGG7R7925at26dHLGhxsNZUlJSqEWLFhQbG0vz58+n+/fvU2pqqnye25AGDhwo81WvXl0GKdxTlQvV0JEZYH1tusVS66QY+nrpt7R84mp6cA+rgoJyuHq40oDpydR9eGdycsbiyWAZZV0PuemiTp06mn4V06dPl9dBvi5zbf3s2bPlEE+eSsFQFtubeb4HnvtBjatI2J49e6h9+/ay2mXLli1yHgm+oFetWlV+ef5SaqGhoTJg4HkePv30UwoKCqIvvvhCjtBQS05OlkNC+fM4EOG2HR7+qd25ZN68ebKXKk8yxT1b+fWLFy+21FcHC3F0cqTu73Sm9snxNDt1MR3YdhhlDTaveUJTGrPyHfKvjf49lYpKcJtE+V5vpLKuh/xPvfbcI7dv36ZBgwbJvL6+vrImg+dtUrcG2MQ8EfYC80TYnpwDp2nBO/9Lvx46a+1NAXhMWFQIDV8wkJq0aYjSqYTzRCSEvVvueSL+/dunNj83EaZDA8VqEBtBC/Z9RKkf9sYoDrAZPjW95Iqbiw99jAAC7B4a50DRuGrutfd6UM+0l+hfi7+hf3zw//SfO/+x9mZBJeTm6Up9J/aU/R6wXDcQmb7+xR+U0UiAmgiwmxkvOZBYfWHJHyfxqhieCxXD1d2FXhrakVadW0y9x3VHAAFWXYCroiGIALvC4+55SOjfzyyUnTAdHKy9RWC3HIi6DOlIK08voBGLB5O3n+22WwNYCpozwC7x+hvDPnuDug5LpA3zt9K3X2ZQUWGxtTcL7ICzixMl9GtLr4xMonqN61p7c8BWqbgmoWJHZ1gDggiwa8GRdejdJYOp/7Rk2vTZNlr/yb+o+GGJtTcLFIjnd+DAgZNfLV9rbw7YOqH6I5Xn9QqAIAIqBd+a3pT6YR/qNbYbbfv83/TP+Vvo96u3rb1ZoAA+Nb3plXeTqMvQjlTN19PamwNgUxBEQKXrM/HqX7tSt+Gdadeq7+lv41bRvVsF1t4ssEFVvT1oYHpf6pTSjlzd0VEXjCTK2TlSIR0rEURApeTi6kydB3agxNQXKHvPCdqy7FvK3HSQHpU8svamgRVVqeJArbu2oKQhnSim47M6s/sBGEWFPhEAdo8vEs07NJXp92u3afl7q2n/9sN0J++utTcNKpCXvyfFdIqmQTNfpxpBfih7KD+BmgiASoU7y41ZMUwuGHdoRzZtWbaT9m3JsvZmgQW1fDGaugzpRHFJzeXaLABgHDRnAJTCi8PFJcXIdOnXq7Rn9Q/00+aD9NvPF1BWdqBek2CK79qSXnitDdVrFGztzQF7JcrZr0EZXSIQRAA8TXD92tR/arJMF05epow1P9HGz7bRfUytrSgeXu7U9e0X6S+vtaHQJpjbASqAQHMGAGgJaRhEKdM4oOhFZ38+LwOKjLWZlHvhBsrJBtUI9qP2veKpfe/nKKJ5GDlg+lIAs0NzBoCR+GIUHh0qEw8BzPr3UTq4PZuO/fALnc76DeVpRc9E16Oodo0oplMUtUiMxugKsB4VTxalKufrbR+CCIByBhQtOkbJxG7n3aGsb3+mf87bImsoMAeFZVX18aCAkBrUY2QXGThgJkmwGQLNGQBgwsyYCa+3lUmlUtGZI+fo4I5sytx8gE4fPkdCIfPh2ywHomeiQui57nFyZEVETJjsCAsA1oGaCAALzkFRP+YZmfpO7EGF/3komztO7vuVTu4/TdkZx6ng1n2Ufxk1DdHtG1ODuPrUsFUE1Y8JI3dPd5QZ2D6BmggAMCM3D1dq+nxDmf44xwjKu3iTcg6c0QQWOftPk+qRMtpCza2KowNFtgynhn8GDJGx4RRYryY6RIIyqTBjJQBYuD8Ft+dzavdqa/lY0cMiuvzrNbp86ipdyrlKl05doZyDZ+jamVzZPGIvU0sH1KtBDeIi5CqrdRvUoaDI2jK5urlYe/MAwAhozgCwIS6uLhTWNEQmbVxrcfPKLbqUc4Uu5lyh01ln6eh3J2V1/+3cO5Sfm08qG+lvwUECr3zpG+hDBfn3qUmbBhTZIpyCG3DAUJv8g/wwagLsnhAqmcrzeiVAEAGgkFoLXtOBU/OEZx97nqfqvvt7Ad24dFPe3r6eT7eu59Pt67cpO+ME+dX2lfmKCotlunYul/soytUpiwqL5GOFBYVykjz3qq7k7OZCLm7O8nE+mdUKDZD3+XEOEm5cviX7KnCgUD3QR956+XlSzWB/8vKvhs6OAEL82aRhIqziCQAVhUco8MgQTgBgA0Q5+0QoJIjAOrcAAABgEjRnAAAAmJtKReRQjn4N6BMBAABQSQk0ZwAAAAA8EZozAAAAzEyoVCTK0ZyBIZ4AAACVlUBzBgAAAMAToTkDAADA3FSCyMH+54lAEAEAAGBugoMAld0HEZhsCgAAAEyCmggAAAAzEypBohzNGbzonhKgJgIAAMDchKr8yQSLFi2ievXqkZubG8XFxdGBAweemn/9+vXUoEEDmb9p06a0bds2oz4PQQQAAIAlaiJU5UvGWrt2LaWlpdGUKVPo8OHDFBUVRYmJiZSXl6c3f2ZmJvXp04cGDhxIR44coe7du8t0/Phxgz/TQSilzsTK7t69S97e3nTnzh3y8vKy9uYAAIANnsfv/vkZ7R1eJicHZ5Pfp0QUU4bYaNS2cs1Dy5YtaeHChfK+SqWi4OBgGj58OI0fP/6x/MnJyXT//n3asmWL5rFWrVpRdHQ0LV261KDPRJ8IA6ljLd5BAABAedTn74r437lEPCzXIlolVKz3muPq6ipTaUVFRZSVlUUTJkzQPFalShVKSEigvXv36v0MfpxrLrRxzcWmTZsM3k4EEQa6d++evOWoDgAAlH0+59oCS3BxcaHAwED68bpxfQv08fT0fOyaw00VU6dOfSzvzZs36dGjRxQQEKDzON/PycnR+/7Xr1/Xm58fNxSCCAPVrl2bLl26RNWqVSMHBwdSAo5geQfk7UYTDMoF+wuOo8p+fuEaCA4g+HxuKW5ubnTu3DlZM2CO7S19vdFXC2FNCCIMxNVCQUFBpER8gCvlIK9IKBeUC/aXynccWaoGonQgwaki+fv7k6OjI+Xm5uo8zve5ZkQfftyY/PpgdAYAAIDCubi4UExMDO3atUvzGHes5PutW7fW+xp+XDs/27lz5xPz64OaCAAAADuQlpZGKSkp1KJFC4qNjaX58+fL0Repqany+f79+1OdOnUoPT1d3n/33XepXbt29Mknn1BSUhKtWbOGDh06RJ9//rnBn4kgwo5x2xl3wrG1NjRrQ7mgXLC/4DiyR8nJyXTjxg2aPHmy7BzJQzV37Nih6Tx58eJF2TSvFh8fT6tXr6ZJkybRe++9RxEREXJkRpMmTQz+TMwTAQAAACZBnwgAAAAwCYIIAAAAMAmCCAAAADAJgggAAAAwCYIIBZgxY4bsRevh4UE+Pj5683CvWx6iw3lq1qxJY8aMoZKSEp08GRkZ1Lx5czk6ITw8nFauXGn0MrKFhYU0bNgw8vPzk1Oy9ujR47HJSqyFt5tnd9NOM2fO1Mlz9OhRev755+X349n2Zs2aZfTSuDyLHPd+rlWrFrm7u8u56U+fPk1KZ+wSwkrC0wSX3jf4NzZmvzbXMWZN33//Pb300ktyxkYug9JrJBiyb9+6dYv69u0rJ5ji8xGvAFlQUGD24wwUglfxBNs2efJkMXfuXJGWlia8vb0fe76kpEQ0adJEJCQkiCNHjoht27YJf39/MWHCBE2e3377TXh4eMj3+OWXX8SCBQuEo6Oj2LFjhybPmjVrhIuLi1i+fLk4ceKEGDRokPDx8RG5ubmaPEOHDhXBwcFi165d4tChQ6JVq1YiPj5e2IKQkBAxffp0ce3aNU0qKCjQPH/nzh0REBAg+vbtK44fPy6++uor4e7uLpYtW6bJ89NPP8lymTVrliynSZMmCWdnZ3Hs2DFNnpkzZ8rfYdOmTeLnn38WXbt2FaGhoeLBgwdCqQz57ZVsypQponHjxjr7xo0bNwzer811jFkbb/fEiRPFhg0beAUqsXHjRp3nDdm3X3zxRREVFSX27dsnfvjhBxEeHi769Olj9uMMlAFBhIKsWLFCbxDBJ4YqVaqI69evax5bsmSJ8PLyEg8fPpT3x44dK0+i2pKTk0ViYqLmfmxsrBg2bJjm/qNHj0Tt2rVFenq6vJ+fny8P9PXr12vynDx5Up6M9u7dK2whiJg3b94Tn1+8eLHw9fXVlAkbN26ciIyM1Nzv1auXSEpK0nldXFycGDJkiPxbpVKJwMBAMXv2bM3zXC6urq7yZKlUZf329hBE8IVPH0P2a3MdY7akdBBhyL7NF3x+3cGDBzV5tm/fLhwcHMSVK1fMdpyBcqA5ww7wcq5cHai9Ghsv58oL5Jw4cUKTh6smtXEe9RKx6mVktfOUXkaWny8uLtbJw9WRdevWfeJSsxWNmy+4SrpZs2Y0e/Zsnepm3sa2bdvK6WG1y+DUqVN0+/Ztg8qJF9bhSVy08/Bc/Fz9bytlYCxDfnt7wNXyXI0fFhYmq+O5ecLQ/docx5itM2Tf5ltuwuAZEdU4P+8v+/fvN9txBsqBGSvtwJOWc1U/97Q8fBJ88OCBPLjLWkaW34NPDKX7ZRi7dKyljBgxQrZHV69enTIzM2nChAl07do1mjt3rnyetzE0NPSJ5eTr61vm0rjq2/Iun2tLTFlCWGn4Qsj9EyIjI+U+MW3aNNlmf/z4cYP2a3McY9zHwJYZsm/zLfcH0ebk5CSPOe085T3OQDkQRFjJ+PHj6eOPP35qnpMnT+p0/qqMjCknnjde7dlnn5UXhiFDhsh54jH1d+XWuXNnnX2Dg4qQkBBat26dzV/cAWwZgggrGT16NA0YMOCpebja1RC8bGvpnvTqnuXqJV2ftOQr97DmkygvIVvWMrJ8y1Xf+fn5Ov+1Gbt0bEWVE18ouDnj/Pnz8j/QJ5WBIeWk/bz6Me7Brp2H56lXIlOWEFY63n/r169PZ86coY4dO5a5X5vjGLN1huzbnCcvL0/ndXyM8YiNsspB+zPMsQQ12Ab0ibCSGjVqyP+en5a02xSfhpdtPXbsmM7Bzcu58smrUaNGBi35asgysvy8s7OzTh5u5+S2ZWOWjq2ocsrOzpZtterqV95GHuLG7d/aZcABBlexGlJOXE3LJzrtPFxdze3BlioDW1xCWOl4SOLZs2flxdKQ/docx5itM2Tf5lsOtrgfidru3bvl/sJBu7mOM1AQa/fshLJduHBBDiubNm2a8PT0lH9zunfvns7ws06dOons7Gw5pKxGjRp6h5+NGTNG9jxftGiR3iGe3BN75cqVshf24MGD5TA/7R7pPBSubt26Yvfu3XIoXOvWrWWytszMTDkyg7//2bNnxapVq2QZ9O/fX6enOQ8969evnxx6xt+Xy6T00DMnJycxZ84cWU7cq1/fEE8ul82bN4ujR4+Kbt262cUQz7J+eyUbPXq0yMjIEOfOnZO/MQ/V5CGaeXl5Bu3X5jrGrI3PGerzB5/+eeg4/83nGEP3bR7i2axZM7F//37x448/ioiICJ0hnuY6zkAZEEQoQEpKijzgS6c9e/Zo8pw/f1507txZjsfmkyOfNIuLi3Xeh/NHR0fL+QDCwsLkkNHSeGw7n0w5Dw/747Hg2vhk8vbbb8shXHxiePnll+WYe2vLysqSQ8R4CKybm5to2LCh+Oijj0RhYaFOPh773qZNG3nBrFOnjjxplrZu3TpRv359WQY8ZG/r1q06z/NQuPfff1+eKPl9OnToIE6dOiWUrqzfXsl4qGWtWrXkd+Pfne+fOXPGqP3aXMeYNfH26TuX8DnG0H37999/l0ED/0PDQ1xTU1M1/9CY8zgDZcBS4AAAAGAS9IkAAAAAkyCIAAAAAJMgiAAAAACTIIgAAAAAkyCIAAAAAJMgiAAAAACTIIgAAAAAkyCIAAAAAJMgiAAAAACTIIgAAAAAkyCIAAAAAJMgiAAAAAAyxX8BEWVeCkYiM6UAAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "u, M_x, M_z, τ_b = z.subfunctions\n", + "\n", + "fig, axes = plt.subplots()\n", + "axes.set_aspect(\"equal\")\n", + "colors = firedrake.tripcolor(extract_surface(u), axes=axes)\n", + "fig.colorbar(colors, label=\"Velocity\");" + ] + }, + { + "cell_type": "markdown", + "id": "ed3613d7-c669-41b3-ba8a-5ae1244a2f94", + "metadata": {}, + "source": [ + "Let's zoom in and look at where the ELA falls." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "f5010542-3587-4bb8-9063-853a07e37449", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "firedrake:WARNING Subdomain (1,) is empty. This is likely an error. Did you choose the right label?\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, axes = plt.subplots()\n", + "axes.set_aspect(\"equal\")\n", + "axes.set_xlim((0, 10e3))\n", + "axes.set_ylim((0, 10e3))\n", + "colors = firedrake.tripcolor(extract_surface(u), axes=axes)\n", + "firedrake.triplot(mesh2d, axes=axes)\n", + "firedrake.tricontour(extract_surface(a), levels=[0, 1], colors=\"tab:orange\", axes=axes)\n", + "fig.colorbar(colors);" + ] + }, + { + "cell_type": "markdown", + "id": "5ffc3b9c-aa85-4c85-b11f-a95db0bc5363", + "metadata": {}, + "source": [ + "Nowe we can form the mass balance equation.\n", + "We'll solve it using the backward Euler method." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "838cbb65-00dc-4b41-a5f1-ae7d669fbbce", + "metadata": {}, + "outputs": [], + "source": [ + "G = mass_balance(thickness=h, velocity=u, accumulation=a)\n", + "tableau = irksome.BackwardEuler()\n", + "t = Constant(0.0)\n", + "dt = Constant(1.0 / 6)\n", + "sparams = {\n", + " \"solver_parameters\": {\n", + " \"ksp_type\": \"gmres\",\n", + " \"pc_type\": \"ilu\",\n", + " },\n", + "}\n", + "mass_solver = irksome.TimeStepper(G, tableau, t, dt, h, **sparams)" + ] + }, + { + "cell_type": "markdown", + "id": "52525e1f-b2d0-41e2-9d10-4f49e33c2648", + "metadata": {}, + "source": [ + "The good part: run the model for 500 years of simulation time." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e4892bde-6369-453d-9503-12ee491a537c", + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "de9d43339fcb47a5afee8d95887be88c", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + " 0%| | 0/3000 [00:00 \u001b[39m\u001b[32m21\u001b[39m momentum_solver.solve()\n\u001b[32m 22\u001b[39m α.assign(\u001b[32m0.0\u001b[39m)\n", + "\u001b[36mFile \u001b[39m\u001b[32mpetsc4py/PETSc/Log.pyx:250\u001b[39m, in \u001b[36mpetsc4py.PETSc.Log.EventDecorator.decorator.wrapped_func\u001b[39m\u001b[34m()\u001b[39m\n\u001b[32m--> \u001b[39m\u001b[32m250\u001b[39m \u001b[33m'Could not get source, probably due dynamically evaluated source code.'\u001b[39m\n", + "\u001b[36mFile \u001b[39m\u001b[32mpetsc4py/PETSc/Log.pyx:251\u001b[39m, in \u001b[36mpetsc4py.PETSc.Log.EventDecorator.decorator.wrapped_func\u001b[39m\u001b[34m()\u001b[39m\n\u001b[32m--> \u001b[39m\u001b[32m251\u001b[39m \u001b[33m'Could not get source, probably due dynamically evaluated source code.'\u001b[39m\n", + "\u001b[36mFile \u001b[39m\u001b[32m~/sw/firedrake/venv-firedrake/lib/python3.14/site-packages/firedrake/adjoint_utils/variational_solver.py:108\u001b[39m, in \u001b[36mNonlinearVariationalSolverMixin._ad_annotate_solve..wrapper\u001b[39m\u001b[34m(self, **kwargs)\u001b[39m\n\u001b[32m 107\u001b[39m \u001b[38;5;28;01mwith\u001b[39;00m stop_annotating():\n\u001b[32m--> \u001b[39m\u001b[32m108\u001b[39m out = \u001b[30;43msolve\u001b[39;49m\u001b[30;43m(\u001b[39;49m\u001b[30;43mself\u001b[39;49m\u001b[30;43m,\u001b[39;49m\u001b[30;43m \u001b[39;49m\u001b[30;43m*\u001b[39;49m\u001b[30;43m*\u001b[39;49m\u001b[30;43mkwargs\u001b[39;49m\u001b[30;43m)\u001b[39;49m\n\u001b[32m 110\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m annotate:\n", + "\u001b[36mFile \u001b[39m\u001b[32m~/sw/firedrake/venv-firedrake/lib/python3.14/site-packages/firedrake/variational_solver.py:403\u001b[39m, in \u001b[36mNonlinearVariationalSolver.solve\u001b[39m\u001b[34m(self, bounds)\u001b[39m\n\u001b[32m 402\u001b[39m problem.u.assign(problem.u_restrict)\n\u001b[32m--> \u001b[39m\u001b[32m403\u001b[39m \u001b[30;43msolving_utils\u001b[39;49m\u001b[30;43m.\u001b[39;49m\u001b[30;43mcheck_snes_convergence\u001b[39;49m\u001b[30;43m(\u001b[39;49m\u001b[30;43mself\u001b[39;49m\u001b[30;43m.\u001b[39;49m\u001b[30;43msnes\u001b[39;49m\u001b[30;43m)\u001b[39;49m\n\u001b[32m 405\u001b[39m \u001b[38;5;66;03m# Grab the comm associated with the `_problem` and call PETSc's garbage cleanup routine\u001b[39;00m\n", + "\u001b[36mFile \u001b[39m\u001b[32m~/sw/firedrake/venv-firedrake/lib/python3.14/site-packages/firedrake/solving_utils.py:129\u001b[39m, in \u001b[36mcheck_snes_convergence\u001b[39m\u001b[34m(snes)\u001b[39m\n\u001b[32m 128\u001b[39m msg = reason\n\u001b[32m--> \u001b[39m\u001b[32m129\u001b[39m \u001b[38;5;28;01mraise\u001b[39;00m ConvergenceError(\u001b[33mr\u001b[39m\u001b[33m\"\"\"\u001b[39m\u001b[33mNonlinear solve failed to converge after \u001b[39m\u001b[38;5;132;01m%d\u001b[39;00m\u001b[33m nonlinear iterations.\u001b[39m\n\u001b[32m 130\u001b[39m \u001b[33mReason:\u001b[39m\n\u001b[32m 131\u001b[39m \u001b[33m \u001b[39m\u001b[38;5;132;01m%s\u001b[39;00m\u001b[33m\"\"\"\u001b[39m % (snes.getIterationNumber(), msg))\n", + "\u001b[31mConvergenceError\u001b[39m: Nonlinear solve failed to converge after 13 nonlinear iterations.\nReason:\n DIVERGED_DTOL", + "\nDuring handling of the above exception, another exception occurred:\n", + "\u001b[31mConvergenceError\u001b[39m Traceback (most recent call last)", + "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[29]\u001b[39m\u001b[32m, line 21\u001b[39m\n\u001b[32m 17\u001b[39m \u001b[38;5;28;01mexcept\u001b[39;00m firedrake.ConvergenceError:\n\u001b[32m 18\u001b[39m α.assign(\u001b[32m0.01\u001b[39m)\n\u001b[32m 19\u001b[39m \u001b[38;5;28;01mfor\u001b[39;00m exponent \u001b[38;5;28;01min\u001b[39;00m np.linspace(\u001b[32m1.0\u001b[39m, \u001b[32m3.0\u001b[39m, num_continuation_steps):\n\u001b[32m 20\u001b[39m n.assign(exponent)\n\u001b[32m---> \u001b[39m\u001b[32m21\u001b[39m momentum_solver.solve()\n\u001b[32m 22\u001b[39m α.assign(\u001b[32m0.0\u001b[39m)\n\u001b[32m 23\u001b[39m \n\u001b[32m 24\u001b[39m hs.append(h.copy(deepcopy=\u001b[38;5;28;01mTrue\u001b[39;00m))\n", + "\u001b[36mFile \u001b[39m\u001b[32mpetsc4py/PETSc/Log.pyx:250\u001b[39m, in \u001b[36mpetsc4py.PETSc.Log.EventDecorator.decorator.wrapped_func\u001b[39m\u001b[34m()\u001b[39m\n\u001b[32m--> \u001b[39m\u001b[32m250\u001b[39m \u001b[33m'Could not get source, probably due dynamically evaluated source code.'\u001b[39m\n", + "\u001b[36mFile \u001b[39m\u001b[32mpetsc4py/PETSc/Log.pyx:251\u001b[39m, in \u001b[36mpetsc4py.PETSc.Log.EventDecorator.decorator.wrapped_func\u001b[39m\u001b[34m()\u001b[39m\n\u001b[32m--> \u001b[39m\u001b[32m251\u001b[39m \u001b[33m'Could not get source, probably due dynamically evaluated source code.'\u001b[39m\n", + "\u001b[36mFile \u001b[39m\u001b[32m~/sw/firedrake/venv-firedrake/lib/python3.14/site-packages/firedrake/adjoint_utils/variational_solver.py:108\u001b[39m, in \u001b[36mNonlinearVariationalSolverMixin._ad_annotate_solve..wrapper\u001b[39m\u001b[34m(self, **kwargs)\u001b[39m\n\u001b[32m 105\u001b[39m tape.add_block(block)\n\u001b[32m 107\u001b[39m \u001b[38;5;28;01mwith\u001b[39;00m stop_annotating():\n\u001b[32m--> \u001b[39m\u001b[32m108\u001b[39m out = \u001b[30;43msolve\u001b[39;49m\u001b[30;43m(\u001b[39;49m\u001b[30;43mself\u001b[39;49m\u001b[30;43m,\u001b[39;49m\u001b[30;43m \u001b[39;49m\u001b[30;43m*\u001b[39;49m\u001b[30;43m*\u001b[39;49m\u001b[30;43mkwargs\u001b[39;49m\u001b[30;43m)\u001b[39;49m\n\u001b[32m 110\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m annotate:\n\u001b[32m 111\u001b[39m block.add_output(\u001b[38;5;28mself\u001b[39m._ad_problem._ad_u.create_block_variable())\n", + "\u001b[36mFile \u001b[39m\u001b[32m~/sw/firedrake/venv-firedrake/lib/python3.14/site-packages/firedrake/variational_solver.py:403\u001b[39m, in \u001b[36mNonlinearVariationalSolver.solve\u001b[39m\u001b[34m(self, bounds)\u001b[39m\n\u001b[32m 401\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m problem.restrict:\n\u001b[32m 402\u001b[39m problem.u.assign(problem.u_restrict)\n\u001b[32m--> \u001b[39m\u001b[32m403\u001b[39m \u001b[30;43msolving_utils\u001b[39;49m\u001b[30;43m.\u001b[39;49m\u001b[30;43mcheck_snes_convergence\u001b[39;49m\u001b[30;43m(\u001b[39;49m\u001b[30;43mself\u001b[39;49m\u001b[30;43m.\u001b[39;49m\u001b[30;43msnes\u001b[39;49m\u001b[30;43m)\u001b[39;49m\n\u001b[32m 405\u001b[39m \u001b[38;5;66;03m# Grab the comm associated with the `_problem` and call PETSc's garbage cleanup routine\u001b[39;00m\n\u001b[32m 406\u001b[39m comm = \u001b[38;5;28mself\u001b[39m._problem.u_restrict.function_space().mesh().comm\n", + "\u001b[36mFile \u001b[39m\u001b[32m~/sw/firedrake/venv-firedrake/lib/python3.14/site-packages/firedrake/solving_utils.py:129\u001b[39m, in \u001b[36mcheck_snes_convergence\u001b[39m\u001b[34m(snes)\u001b[39m\n\u001b[32m 127\u001b[39m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[32m 128\u001b[39m msg = reason\n\u001b[32m--> \u001b[39m\u001b[32m129\u001b[39m \u001b[38;5;28;01mraise\u001b[39;00m ConvergenceError(\u001b[33mr\u001b[39m\u001b[33m\"\"\"\u001b[39m\u001b[33mNonlinear solve failed to converge after \u001b[39m\u001b[38;5;132;01m%d\u001b[39;00m\u001b[33m nonlinear iterations.\u001b[39m\n\u001b[32m 130\u001b[39m \u001b[33mReason:\u001b[39m\n\u001b[32m 131\u001b[39m \u001b[33m \u001b[39m\u001b[38;5;132;01m%s\u001b[39;00m\u001b[33m\"\"\"\u001b[39m % (snes.getIterationNumber(), msg))\n", + "\u001b[31mConvergenceError\u001b[39m: Nonlinear solve failed to converge after 41 nonlinear iterations.\nReason:\n DIVERGED_DTOL" + ] + } + ], + "source": [ + "hs = [h.copy(deepcopy=True)]\n", + "us = [u.copy(deepcopy=True)]\n", + "\n", + "final_time = 500.0\n", + "num_steps = int(final_time / float(dt))\n", + "for step in trange(num_steps):\n", + " mass_solver.advance()\n", + " h.interpolate(max_value(0, h))\n", + " s.interpolate(b + h)\n", + " a.interpolate(smb(s))\n", + "\n", + " # Fast path: exact Newton (α = 0). If a step fails, re-enable the linear\n", + " # Jacobian regularization and re-run the exponent continuation from n = 1,\n", + " # then turn the regularization back off.\n", + " try:\n", + " momentum_solver.solve()\n", + " except firedrake.ConvergenceError:\n", + " print(\"Convergence error\")\n", + " α.assign(0.01)\n", + " for exponent in np.linspace(1.0, 3.0, num_continuation_steps):\n", + " n.assign(exponent)\n", + " momentum_solver.solve()\n", + " α.assign(0.0)\n", + "\n", + " hs.append(h.copy(deepcopy=True))\n", + " us.append(z.subfunctions[0].copy(deepcopy=True))" + ] + }, + { + "cell_type": "markdown", + "id": "4f7d8b7f-7c77-42d1-9659-b82f8b5e36d7", + "metadata": {}, + "source": [ + "Now let's make a movie of the evolution towards steady state.\n", + "The contour shows the final value of the ELA." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "5fe150c8-9c1e-436f-92ff-bebbec068a25", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, axes = plt.subplots()\n", + "axes.set_aspect(\"equal\")\n", + "axes.set_xlim((0, 10e3))\n", + "axes.set_ylim((0, 10e3))\n", + "colors = firedrake.tripcolor(extract_surface(hs[-1]), num_sample_points=1, shading=\"flat\", axes=axes)\n", + "firedrake.tricontour(extract_surface(a), levels=[0, 1], colors=\"tab:orange\", axes=axes)\n", + "fig.colorbar(colors);" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "f01a49bf-f4c5-41b4-b5fc-3d76deaa55fe", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "u, M_x, M_z, τ_b = z.subfunctions\n", + "\n", + "fig, axes = plt.subplots()\n", + "axes.set_aspect(\"equal\")\n", + "axes.set_xlim((-10e3, 10e3))\n", + "axes.set_ylim((-10e3, 10e3))\n", + "colors = firedrake.tripcolor(extract_surface(u), num_sample_points=1, shading=\"flat\", axes=axes)\n", + "firedrake.tricontour(extract_surface(a), levels=[0, 1], colors=\"tab:orange\", axes=axes)\n", + "fig.colorbar(colors);" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "3c778fd1-203e-4a13-a532-19d0639d3da1", + "metadata": {}, + "outputs": [], + "source": [ + "%%capture\n", + "\n", + "from matplotlib.animation import FuncAnimation\n", + "\n", + "fig, axes = plt.subplots()\n", + "axes.set_aspect(\"equal\")\n", + "axes.set_xlim((0, 10e3))\n", + "axes.set_ylim((0, 10e3))\n", + "colors = firedrake.tripcolor(extract_surface(hs[0]), vmax=130.0, num_sample_points=4, axes=axes)\n", + "fig.colorbar(colors)\n", + "\n", + "fn_plotter = firedrake.FunctionPlotter(mesh2d, num_sample_points=4)\n", + "def animate(h):\n", + " colors.set_array(fn_plotter(extract_surface(h)))\n", + "\n", + "animation = FuncAnimation(fig, animate, hs, interval=1e3/60)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c639e838-6305-4dc7-9760-c4c92b193e0a", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 38, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from IPython.display import HTML\n", + "HTML(animation.to_html5_video())" + ] + }, + { + "cell_type": "markdown", + "id": "a1519ecf-2c80-4de1-9f54-33b861435322", + "metadata": {}, + "source": [ + "Finally, let's check that the solver was working right." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "6a0ec125-564b-4457-bd47-71eb911e7a8b", + "metadata": {}, + "outputs": [], + "source": [ + "junk = \"SNES Function norm\"\n", + "with open(\"rainier-output.log\", \"r\") as log_file:\n", + " raw_data = [\n", + " line.replace(junk, \"\").strip().split()\n", + " for line in log_file.readlines()\n", + " ]\n", + "\n", + "convergence_log = [\n", + " (int(iter_text), float(norm_text)) for iter_text, norm_text in raw_data\n", + "]\n", + "\n", + "reduced_log = []\n", + "current_entry = []\n", + "for count, error in convergence_log:\n", + " if count == 0:\n", + " reduced_log.append(current_entry)\n", + " current_entry = []\n", + "\n", + " current_entry.append(error)\n", + "\n", + "reduced_log.pop(0);" + ] + }, + { + "cell_type": "markdown", + "id": "a4d62643-ae8f-4a5f-9a22-d45166505a45", + "metadata": {}, + "source": [ + "First, we want to see that the number of Newton iterations was bounded.\n", + "If it starts reaching above 20 then you're probably in trouble." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "1768b1cc-a969-4baf-9b09-4d0e83cdafbb", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots()\n", + "ax.set_ylim((0, 100))\n", + "ax.set_xlabel(\"Time step\")\n", + "ax.set_ylabel(\"#Newton steps\")\n", + "ax.plot([len(entry) for entry in reduced_log]);" + ] + }, + { + "cell_type": "markdown", + "id": "a0448417-72b3-4e5c-abba-1ad4a20f319c", + "metadata": {}, + "source": [ + "Next, we'll have a look at the initial and final residual values.\n", + "We used a convergence criterion where the iteration stops if the residual is reduced by more than something like $10^4$.\n", + "It would be cause for concern if the final value of the residual were edging upward, but this isn't the case." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "eedac523-9bd0-4b48-8ba4-81d2622df72c", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots()\n", + "ax.set_yscale(\"log\")\n", + "ax.set_xlabel(\"Time step\")\n", + "ax.set_ylabel(\"Residual\")\n", + "ax.plot([entry[0] for entry in reduced_log], label=\"Initial\")\n", + "ax.plot([entry[-1] for entry in reduced_log], label=\"Final\")\n", + "ax.legend(loc=\"upper right\");" + ] } - ], - "source": [ - "fig, axes = plt.subplots()\n", - "axes.set_aspect(\"equal\")\n", - "axes.set_xlim((0, 10e3))\n", - "axes.set_ylim((0, 10e3))\n", - "colors = firedrake.tripcolor(u, axes=axes)\n", - "firedrake.triplot(mesh, axes=axes)\n", - "firedrake.tricontour(a, levels=[0, 1], colors=\"tab:orange\", axes=axes)\n", - "fig.colorbar(colors);" - ] - }, - { - "cell_type": "markdown", - "id": "5ffc3b9c-aa85-4c85-b11f-a95db0bc5363", - "metadata": {}, - "source": [ - "Nowe we can form the mass balance equation.\n", - "We'll solve it using the backward Euler method." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "838cbb65-00dc-4b41-a5f1-ae7d669fbbce", - "metadata": {}, - "outputs": [], - "source": [ - "G = model.mass_balance(thickness=h, velocity=u, accumulation=a)\n", - "tableau = irksome.BackwardEuler()\n", - "t = Constant(0.0)\n", - "dt = Constant(1.0 / 6)\n", - "sparams = {\n", - " \"solver_parameters\": {\n", - " \"ksp_type\": \"gmres\",\n", - " \"pc_type\": \"ilu\",\n", - " },\n", - "}\n", - "mass_solver = irksome.TimeStepper(G, tableau, t, dt, h, **sparams)" - ] - }, - { - "cell_type": "markdown", - "id": "52525e1f-b2d0-41e2-9d10-4f49e33c2648", - "metadata": {}, - "source": [ - "The good part: run the model for 500 years of simulation time." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "e4892bde-6369-453d-9503-12ee491a537c", - "metadata": {}, - "outputs": [ - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "81dce65ed8bd45f0afc23683f163e532", - "version_major": 2, - "version_minor": 0 + ], + "metadata": { + "kernelspec": { + "display_name": "firedrake", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 }, - "text/plain": [ - " 0%| | 0/3000 [00:00 Date: Fri, 19 Jun 2026 13:33:36 -0400 Subject: [PATCH 8/8] Working demo notebook showing how to use dual hybrid --- notebooks/rainier_hybrid.ipynb | 1099 ++++++++++++++++++++------------ 1 file changed, 691 insertions(+), 408 deletions(-) diff --git a/notebooks/rainier_hybrid.ipynb b/notebooks/rainier_hybrid.ipynb index f54a3d6..e523b09 100644 --- a/notebooks/rainier_hybrid.ipynb +++ b/notebooks/rainier_hybrid.ipynb @@ -2,12 +2,12 @@ "cells": [ { "cell_type": "code", - "execution_count": 1, + "execution_count": null, "id": "2bbcb16d-d444-46d3-810a-ab79194a91eb", "metadata": {}, "outputs": [], "source": [ - "from tqdm.notebook import trange\n", + "from tqdm.auto import trange\n", "import numpy as np\n", "from numpy import pi as π\n", "import matplotlib.pyplot as plt\n", @@ -139,7 +139,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "/Users/dlilien/sw/firedrake/venv-firedrake/lib/python3.14/site-packages/finat/ufl/elementlist.py:433: UserWarning: Discontinuous Lagrange element requested on triangle * interval, creating DQ element.\n", + "/Users/dlilien/sw/fd_3.14/venv-firedrake/lib/python3.14/site-packages/finat/ufl/elementlist.py:433: UserWarning: Discontinuous Lagrange element requested on triangle * interval, creating DQ element.\n", " warnings.warn(\"Discontinuous Lagrange element requested on %s, creating DQ element.\" % cell.cellname)\n" ] } @@ -410,12 +410,12 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 15, "id": "db935250-689e-4ca7-aee5-c5b0f212c4d4", "metadata": {}, "outputs": [], "source": [ - "vfamily = \"DG\"\n", + "vfamily = \"GL\"\n", "vdegree = 2\n", "V = firedrake.VectorFunctionSpace(mesh, \"CG\", 2, dim=2, vfamily=vfamily, vdegree=vdegree)\n", "Σx = firedrake.TensorFunctionSpace(mesh, \"DG\", 1, shape=(2, 2), symmetry=True, vfamily=vfamily, vdegree=max(0, vdegree - 1))\n", @@ -501,12 +501,10 @@ "\n", "# Clamp the thickness from below in the momentum model. The hybrid strain-rate\n", "# terms divide by thickness, so the raw (compact) initial thickness -- which is\n", - "# exactly zero outside the ice cap -- makes the residual non-finite (NaN/Inf) at\n", - "# the very first evaluation, giving DIVERGED_FUNCTION_NANORINF. simulate_bp.py\n", - "# avoids this only because its input thickness is strictly positive everywhere.\n", - "h_min = Constant(1.0e-8)\n", + "# exactly zero outside the glacier -- makes the residual non-finite (NaN/Inf) at\n", + "# the very first evaluation, giving DIVERGED_FUNCTION_NANORINF.\n", + "h_min = Constant(1.0e1)\n", "h_safe = max_value(h_min, h)\n", - "h_safer = max_value(10.0, h)\n", "\n", "fields = {\n", " \"velocity\": u,\n", @@ -541,7 +539,7 @@ " \"membrane_stress_x\": M_x,\n", " \"membrane_stress_z\": M_z,\n", " \"basal_stress\": τ_b,\n", - " \"thickness\": h_safer,\n", + " \"thickness\": h_safe,\n", " \"surface\": s,\n", "}\n", "\n", @@ -552,7 +550,7 @@ "# Add a small amount of a *linearized* rheology to the Jacobian. The power-law\n", "# (n = m = 3) Jacobian is singular wherever strain rates or basal stresses\n", "# approach zero, which stalls Newton's method. Mixing in a linear term keeps\n", - "# the Jacobian well-conditioned, as in demos/kangerd/simulate_bp.py.\n", + "# the Jacobian well-conditioned.\n", "linear_rheology = {\n", " \"flow_law_exponent\": 1,\n", " \"flow_law_coefficient\": ε_c / τ_c,\n", @@ -610,22 +608,61 @@ " \"snes_stol\": 1.0e-4,\n", " \"snes_atol\": 1.0e-4,\n", " \"snes_rtol\": 1.0e-4,\n", - " \"snes_max_it\": 2500,\n", + " \"snes_max_it\": 250,\n", " \"snes_divergence_tolerance\": -1,\n", " \"snes_linesearch_type\": \"nleqerr\",\n", " \"ksp_type\": \"preonly\",\n", " \"pc_type\": \"lu\",\n", " \"pc_factor_mat_solver_type\": \"mumps\",\n", "}\n", + "\n", + "# This works but is 2x slower than the above.\n", + "fieldsplit_params = {\n", + " \"snes_type\": \"newtonls\",\n", + " \"snes_linesearch_type\": \"nleqerr\", # or nleqerr or whatever doesn't break\n", + " \"snes_linesearch_max_it\": 10, # This is not the important knob for speed it seems\n", + " \"snes_stol\": 1.0e-4,\n", + " \"snes_atol\": 1.0e-4,\n", + " \"snes_rtol\": 1.0e-4,\n", + " \"snes_max_it\": 250,\n", + " \"snes_monitor\": \":rainier-output.log\",\n", + " \"ksp_type\": \"preonly\",\n", + " \"pc_type\": \"fieldsplit\",\n", + " \"pc_fieldsplit_type\": \"schur\",\n", + " \"pc_fieldsplit_schur_fact_type\": \"full\",\n", + " \"pc_fieldsplit_schur_precondition\": \"selfp\",\n", + " \"pc_fieldsplit_0_fields\": \"1,2,3\", # membrane and basal stresses\n", + " \"pc_fieldsplit_1_fields\": \"0\", # velocity\n", + " \"fieldsplit_0\": {\n", + " \"ksp_type\": \"preonly\",\n", + " \"pc_type\": \"bjacobi\",\n", + " },\n", + " \"fieldsplit_1\": {\n", + " \"ksp_type\": \"preonly\",\n", + " \"pc_type\": \"lu\",\n", + " \"pc_factor_mat_solver_type\": \"mumps\",\n", + " },\n", + "}\n", "momentum_solver = firedrake.NonlinearVariationalSolver(momentum_problem, solver_parameters=sparams)" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 22, "id": "e618ec87-b03f-44a8-8f0d-84b7ba2f58d9", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "Constant([0.], name='constant_128', count=128)" + ] + }, + "execution_count": 22, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "num_continuation_steps = 5\n", "for exponent in np.linspace(1.0, 3.0, num_continuation_steps):\n", @@ -639,13 +676,13 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 23, "id": "27dea728-7c56-4a3c-83fb-87e7b32cc881", "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -673,7 +710,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 24, "id": "f5010542-3587-4bb8-9063-853a07e37449", "metadata": {}, "outputs": [ @@ -686,7 +723,7 @@ }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAgYAAAGiCAYAAACcWg7FAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjksIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvJkbTWQAAAAlwSFlzAAAPYQAAD2EBqD+naQABAABJREFUeJzsvQe4XVd17T/3Ve+9995l9W65dxubR+BR8iDU/AMkISQQ4BE6oZOYkNASEsiDQCCYYtybZMuyLcuWJUuWLFuyJKtbvZd71//7zXXWOfvsu/s5V7bQHvq2r6V7yq5rjTXnmGN6xhgjBQoUKFCgQIECItJQnIUCBQoUKFCggENBDAoUKFCgQIECZRTEoECBAgUKFChQRkEMChQoUKBAgQJlFMSgQIECBQoUKFBGQQwKFChQoECBAmUUxKBAgQIFChQoUEZBDAoUKFCgQIECZRTEoECBAgUKFChQRkEMChQoUKBAgQL5icHSpUvlpptukoEDB4rnefLrX/+66vc4LH/qU5+SAQMGSIcOHeTKK6+UjRs3Vr1m//798ra3vU26du0q3bt3l3e/+91y9OjRqtesXr1aLr74Ymnfvr0MGTJEvvrVrzbbl1/84hcyfvx4fc2UKVPkjjvuyHo4BQoUKFCgQIFaiMGxY8fkoosukn/+538O/T0T+Le+9S357ne/K48//rh06tRJrrnmGjl58mT5NZCCtWvXyr333iu33367ko33ve995d8fPnxYrr76ahk2bJisXLlSvva1r8lnPvMZ+f73v19+zaOPPipvectblFQ8/fTTcsstt+j27LPPZj2kAgUKFChQoICDqQG8/bbbbiv/vampyfTv39987WtfK//bwYMHTbt27cx//dd/6d/XrVun71uxYkX5NXfeeafxPM9s375d//4v//IvpkePHubUqVPl1/zt3/6tGTduXPnvb3rTm8wNN9xQtT9z5841f/qnf1rLIRUoUKBAgQIXNFpLHbF582bZtWuXpg8cunXrJnPnzpXly5fLm9/8Zv1J+mDWrFnl1/D6hoYGjTC8/vWv19csXrxY2rZtW34NUYevfOUrcuDAAenRo4e+5sMf/nDV9/OaYGrDj1OnTunm0NTUpGmNXr16aVqkQIECBQqcP2B9euTIEU1tM4e0FE6ePCmnT5+u+XOY00h9v9ZRV2IAKQD9+vWr+nf+7n7Hz759+1bvROvW0rNnz6rXjBgxotlnuN9BDPgZ9z1h+NKXviSf/exnazrGAgUKFCjw2sK2bdtk8ODBLUYKRgzrLLv2NNb8Wf3799cF9GudHNSVGLzW8fGPf7wqynDo0CEZOnSoLJLrpbW0Kf/7aTktT8j9clZOy1AZIyNlYs3f/YwslwOyRy6Vm0N/3yRN8ow8IofkgHSR7jJdLpaGnEUjW+R52SzPyTRZKN2ld+Lr+e418rjuXzvpILPlcmmd8tZ4SH4j3aWXTJNFUgt2yTZZL0/p/0+SOdJHBpR/97jcJyflhFwiN2X6zIPyimyVF/Rnk9iHupW0lp7SV68r5xmskkfkoOyTITJatskLet5nyCXSWbpKrVgu98gZOS2L5cbE1x6W/fK0PCJGjIyUSTJURsee917SX6bI3Fz7xTXfKhtki7wgRpqqfjdYRspomZLrc/37x/mdKZfEvm69PC27ZKu0lfYyRy6T1lKJEoKt8rxskudkqszX65aEptae7Lq+oxy+srd4rRqk9cmz8pmFN8sbxs8uooJ/gECPhji9S5cuLfYdp0+fVlKweeUw6dolf1Ti8JEmGTFzi37eBUUMYENg9+7dWpXgwN+nTZtWfs2ePXuq3nf27FkN6bv385P3+OH+nvQa9/swtGvXTrcgIAWtPUsMTpuT8oTcJ2fljIySSTLCmyD1QIOxN5T7Hj+aTJM8IQ/IcTmig/10b1FdvquV77iiwHevkAflmByWbtJLB/IGL8PNb1Cwtkr8nji8YJ6Vl2S9fg6kpIvXLeQ7GjJ/R28ZoBs4Yg7IS7JB9slu2Ss7dIMk9JA+ckqsMBZS0E7ay1y5Wtp61RNUXhjTpCQrad93mW3yrDwuIp5MlQXS1xsY+VruUdBeOtR03kfLVBlpJuvkvEM2l/+dc1bL53JPgQ7SKfZzVpll8orslI7SRebJVaH33TFzRH/2lH7S2ksxXDWKDP3daTnxzCuy9V3dpWlIF/nUuvvkv9c/KT/6o/dLv061k70Crz2ci1Rw1y4NNRGD8wl1PUrC/0zM999/fxWjQzswf/58/Ts/Dx48qNUGDg888IDm+9EiuNdQqXDmzJnya6hgGDdunKYR3Gv83+Ne474nD06a47JM7lJSMFYuqhspiMNpc1oekTuUFAyU4TWTAj88iX9YmGD4bkhBfxkqs73LspGClN8Th2fMo0oKmJAXyXXNSYGubk1N3wG6eD1kijdPLvVulvlyjZ7rVtJKJ6YTcqx8HLPksrqRAtAojUp44rDZPKekgNfNlctjSQFw+9tOOta8f/tlj+yUl8p/5xyskmWy3NxTnpSzgvsJMOFHklHzgJ57yGgUKQDH5ajuUypS4EOHradl7Of3SPfbdok52yirj+2Wmbd+RH7zfGXcKVAgCxpNU81bLfjyl7+sBOhDH/pQ7OvqUcafeRbAb2DVqlW6AfIl/P/WrVvLO/2FL3xBfvvb38qaNWvk7W9/uwpDKCUEEyZMkGuvvVbe+973yhNPPCHLli2TD37wgypM5HXgrW99q4o0KEWkrPHnP/+53HrrrVVpgL/8y7+Uu+66S77xjW/I+vXrtZzxySef1M/KgxPmmCyXu6VRzsp4mS5DvTHS0oCIPCp3ymk5KcNlvEz0KoLMWkDZB4ibSo+aw/JI6btHygSZ7M2p4RuzT9pnzVmdfFi5d5UeslCul7ZeVHitqWZi4Ecnr4ue6zlyRVUKiRD+MrlTHjV3yctmU3nlWwv4TAhIFNaZJ+VFWSttpJ0sUGJkiW8cTsjxcsSgFmw3mzSNwvXTqJm0kcVyk0atmNx5HljVc62y4LAc1J+dJYTkmSZ5TO6VQ7JfIxNJZJQUUjC9kBZeo0iX3+2QvZ/9sZxcs0lkQA/5wLJfyJ/8z3fkxNnahWQFLiw0adKtti0vVqxYId/73vdk6tSpsa+rVxl/ZmLA5Dt9+nTdAJM1/4+pEfjoRz8qf/7nf66+BLNnz1YiwQTuz6n85Cc/UUZzxRVXyPXXXy+LFi2q8iigkuGee+5R0jFz5kz567/+a/18v9fBggUL5Kc//am+D1+FX/7yl1qRMHny5KyHJMfkqOaCWd1NlFky2BslLY0j5pA8KndrdGKcTJPRXvb9zot9Zpc8Lvdq3n2izJaR3qSaPi/rpH3SnNQJmMmnnwyROd4VsZMDk2se8hGHQ2afPFqKDrFSJ60wWy6THtJXV+ToHR6UX2tEI+/K2e57k3522AT5pHlIdshLurJeKNdJ+0hiFB4xIFSfFy+aZ+U5eUr3bb5crecYYtDGa6tRK1bxnaSLruqXyG9ko3k2NVE6Jof0J4TPDwgG191Fx6Z5CxM/C51PXgLENX5c7pcz2/fIgR/cLnLHBv33+w5vkZnf/5Q8+8r2XJ9b4MJEUx3+5AFzKN4/P/jBD8oR8yiwgGbh/ZGPfEQX4Z///OdlxowZ8u1vf7tlNQaXXnqplohEgajB5z73Od2iQAUCk3ocYEYPP/xw7Gve+MY36lYrnpQHdGCcLHOlvzdEWhr7zR55Wh7W75wq86SvV281bXTMgJUwk54nDTJTFksPr0/N35aFGBwyB2SlPKSkJK2Gg/PE/tYLO80WWSsrSvn8+Zpj5zu6eWgsFusEiIDzZXmxrEdoZzrKEBkpQ2VspnSLjRi0aTZBQsyY4HtJP7lIFmb6TKeJyEsM1poVslO2qOBvXklP0WQapa1U9DedvW6actljtss6WSlbZL1slxdlvJmR+IwQ/gftfakOyOBjco9O9MNknIzxksWNnCfOX0fpXMMzhmaiv7zSuEuG/PKYmHUvy8vv6SWHu3eQa2+7VT406RL58PzrcqXQChTIA9LrabRvDh/4wAfkhhtu0LJ+ovFxyFPGH4biaSgN3gi+zgUpQGT2lCzV/0foV39SEE0MNprVSgrcKrEepCDse+KOfYU8oMwZNX1aDUc9iQFCR0iBzedfIX29Qbo/Db5jYJIY4Y2Xi70bdOIk5E3K5QV5Vh6U2+Qps1QOmwOpv9Nf4UH66BH5vZIC1P/TvYszT0qn5YT+ZGLPAgjPSrNESQHRAKpxLCkgyGm0IiUIzg8VFaSbiKihhSDVcsTYdEEYTspxvV7uuI4bInJ3KikYI1NTkQJwSPbpT1c9khZ7zI7yMzZbLpWzcrZMdro8d0rGfHqXtH16n0jrBvnHDQ/Llf/xJdl7In9UqMCFgUZjat4AVRRExd1GGX0Ufvazn8lTTz0V+xo/8pTxy4Verhi34t0gT8lG84yq35k0bHjZhpjtxh/ysPxpo/9v/7TVHCj/x88kkZQTmc2Ry3WgatnjquAZs1z2ynYd/OfKVXUV2KWhBZvMOtkk6/TYZ8ml0jVFLt2BScs/cecBk98aeUxX/3alfGVZ00C4vyGwqnfo7HXVsk/ev102yVbZqII9ylnbmnYyUEaoPiTsurvcPPeIC22vlCVKRBC35tWxUP4IshAK9oV9JoxP2R/lpe79TORxEQhep+WTZpyskxWyR7ZrCWlP01cmy7xm99JpOVUmQxAoql44x6TpBnrDU+/zIXlFf1I5kjUaxFM8W65QMSvExK8laX20SUZ++6C8cskp2fvmvvJ82yMy+98/K9+79h1yzcjayjQL/OGiqUadgHsvngv0CXKIihbwOrR0iOrPdXljQQz0JLSVRmnSlYXx/amsvDPABEPs/Ncr19G73OvLskk6ma66GkKklVV1Hb8Ldie8cjniA3JEDur3orqvd9g0aTW/xjwmu+VlDVWTu44WGcZFDPITAyZFzgGahrBzYIlH/DHwenwO2Fj1b5TVslf1/Ot162Z6yWiZXBWFIcoAmJSylCMmgYk3i8cF1ScI/njfABkukwIi16MlsWBUFYED9yipFyZaSBYEaan8TgabkUp03DlFt0EaYZ/ZreJG7kbIVW+vUsKcBkdKWoUuAa1CFLaajfK8PKMUHvLb0bMpiDNyqpkQkrupz5IT0uX5HbLlT3vI2SFd5N1LfiI3rhkt/3jDO6R96/zlmgUKxAFS4CcGUaByj9J+NAIOjY2NWrGHZgAX31atqoXNecr4w1AQAxFZKNfG1lszuUIaCIWekTNyVk6VfrKd1koG/rifvJqwK2SAPy7n6iZRDHfYqmC8UnwCfXp7LUVjoO4sXXQy6yCdM0/o7Atir1NyQvrKIJnq5S/ljEPUpO0nJQzMVAHkJSV5UwlM4ipAk1NakhlWfWGJQXxJoR/tvY4yReaVV6j4IxD2JhrQ2rSRATJMRslEnYgBCnwiDdan4TLp4mULjQfBfZZ2fxFOEingPaQDwoSmR+VIZBVBGJhw58qVKmJdK0+qFgOKNNZcJIO8kXrfExUhx891myWXSHevV8ajtFoFjeCluGco+aS6g+cH8sk1ctoGrm9UOqL9zjMy5gt7ZfsfnZCjV/WV2/e/IMt+8Cn55Zv/Usb1yDaYFvjDRpMYaaxDxCAtEOdT2efHO9/5ThXu/+3f/m0zUuAv4/eXNOYp4y+IQQowMLUt/cmK58xKOaorHyZPI1d4/6s8YR2WA/o7BkByzqwwCRMzkfK7IDwlD5Y6QB4I/SLMYtCDPFRC4xa46DFID5OxMsaLL3PJA6dSDyMGdpV6nx5THxkoF3kLcn9P3oiBP3QfJ3S0AsF8j8IAb5gSAY4XDQKREYyS2JyaHtLANWMVm7byIA4Q0rgSSIcD5hXNtRMAnSCzZFBEGP9EibimJQYOvbz+qj/YYp6XF8VWObxo1unvTsqxUsrsCk3H5MGplKWKaGcQi3KOEUz6Uxv7ZEdiOqLhrJEhPzsih549Izve3UsOdG0vV/ziG/LxaVfJ+2dfVTgmFqhrKiEtcHMMVtnRrZjePu7fsQMYNGhQWYNA6uGSSy7RMn4Ei2gUqCT0V/2lQUEMWhDPmifU7pXJu710kv1SCfGwoiHcyko+atI9JkfkiBzQEDjkgVwwq1DEZwzmzaMO1iHQ3YCQAlbJI2R8ixxfJWVRPWkjTCOvzPfz3aNqLsVMDvUnVR4goov7/DQTbRwgZeTQ2faaHfKirCuH6AEWzHmIZRggOhDDOLjUBddmuizSSTwKTmOQN501zBsrQ8xoeU5WqrDRgagCnhF5QcSrW0J6A+K9XTardgZSEDyGA6VnpJfPYjsK3Z49KZ0+vUteeldXOTOlp3xp7QPyu+eekp/+7z+Xnu3zl4YWKNBSwD/I3zzKlfF/8pOflE984hMyZsyYXGX8BTFoIaw2y1Wk1Um66gD5jCzLHKXoosNit9jcOcSBCAMkgqgD/99UCmEDiAkbNskMnqwKEZ+xinfh1lqJgV9+SHnbanlMfztJZuuKuh7IkkqotlhOF7rPkkpIQg/prSkmByZnVtT0ryAfTx+CWnQeEAMnaAzDFrNBNsqaaIvpkPLHWo+f43FW3A7oGsabaZpeyOMIyj0Up3tw2hWIN9UjYeeUiBz3TlqxbevDjTLq1gOy94pT8sof9ZVn2xyUGf/2KfnR9e+WS0bU3jOlwPmLRl9lQd7314qHHnoo9u/1KuMviEEL4GnziOyTXRriZ2DWAav2e6IZWB0RInVhUsRX/qjETLlUow2IxBggWRlCHlDmb5BVmppAoU+zIJotQRayVEo4ww4XMdhs1usEyOqe78YXoB5Im0rAX2O1LA+tPEhKhwS9BvICYZ5twHVGUz2cb1wd6UWAzoCNNEM/M0TGyrSc1SFGw+ZhWG9WycvygobgOf405I/0Vd5USrDvAdeJ64VxFqWxpBe2mhc0apGFiB6UvaEmSQ5Pm4e170WSdoXz7/dnSAPPiPS977h0Wb9dXvzTLnLqxHF56/3/Ie8fM18+sfiWIrVwgaKptNXy/vMFBTGoI5hkEFwdkL3acZAOfefKOGWjWSNbZIMqEPrJYA2vMiD28EZqvbw/yrBPduqgio6BgZP/Z0O8BYFh0qHOndgCNfz42YcfR4UYONMcVrJESGqNRgSRlEpIqjyIfF9pZZ+2m2QcDpi98pSa6jTJOJmu94GbmEZ6E7VLJzbEpBlcJKeX6ScTZGbq83Xa2GhQ2GTnJmdSVKyg06YGECb6zYgyeyPIQyqw5H5BbMs1GOgNk75mkKyVJ5So0ZNjmBkvY1KmlZyHQfeANsB+3xL9PWR2hiyOvM68lmNjv/Jg07ZHZffntkvXN18h7UYNku9selyWbdkoP3/zX0iXtq/t7ngFCtSCghjUCf4BklD9DG+xnGstg82zXiWbZX3ka5kssCFm8+87kxhRDgZc9AyucgJRl77PtNEVcFfpqV76uMm5iAHfzQoZMkHteD1LL9MQA3/lAcc1xUvfipgW2/WIGDDhszr25/T3Gmu565+4CKsPkpHyitmlpXUQMibNrqaHjJcZif4OTijob6Dkr/5gEiRak4WQMn0maRaivRHu0/sFAonF8VLzu7JnAPfBRbJARZBEcnBP3GleUqfHbgnHebTUiIl7yn+cRGOIfnH/TUtoOMb5ANyzWbHaPCZ75GXxTnty6Md3y7AtveWVtw6Q1bJf5vzrp+W2N/+VjO9ZVC1cSGissSqhlveeaxTEoA6oHrDsAHnuIhSPyAHZU9YyMCG4VFZaJT/vwZqXzf/ZHA+rvYOyT1eB/J3BFqMf+/mVuvWWjpBEaQzSVh4kmQXVEjFwqnjC8RhXdSqp8DkvUdegt2fJFe2gn5OnNeHDPdTRdFZPgKiaf9dAybkUnjWntfqDNFGeklRnwpQ1YoAGAItjqk4weZrozdR/p4w3aGHcw+stF5sb1PuBNMoKuV/6msEyWebEpAAoVWxV/j33I02diMBElZ0GQWQM+O/rNHCRF1KB3B8Qzr5LT0nnrTtky/t7yZFeHeWqX35Dvrrgf8lbJrdMCXCB1x4ajd1qef/5goIY1AjXLQ5Huayr1Vq/F/c5Jmw0BtPFb61b+x3IZxGSD+Z4yaG7/gH+qgjIw0PyG+lsukofGaSr4nq6K4ZFDLJVHiSlEtrkugashJlEwhwlUdUniSbppgiZIOpBxIGoDW2P25r2mnoYHBDuuQZKHaWTvod7DwJC1cNY76LMx2BLaXE9TN+PwP+9/qoTa63cFOqgyP1EszCqFzg+VuNLZJdMMrNDrxuCSJcu0U6ccreWL3JfTfAqhi9xIHoHSIWlxUqzVIk278GyHAtsSDfo+NJpGfO53fLSn3aXMxN7yEdW/EaWblon37rxT6RNQ/3EqwVem2gqNAYF0sDfDIducfVqm5z8vadludyrA2Xc6qmerYr95jZdTHd5QSrGG+wDEzciR3QLbIgQST8wwPJ7dA95oglOHBhUzeepPIgjBlhaZ0GjadQVvtU09FSb5+DxWSOidMeMxoAUBNd2gzwju2SbiveIRjDpj5AJ+vnOTZFcPt0ha7VXdsQAN4y0XUFtv4tG1VEM8XUi5VyATjGVNNw/C+QaFcpSOQGx6m56yVRZWEWqOHes2NFUQApYuQ+T9BoFuz9HNIqT5r7zaxcg2mgXeK61uZaPWGCnPOqb+2XHLafl8I395Hf7NsrT//Y5+c3b/lr6dczn11CgwGsNRcQgJ/yrmMEySsZ7tg11S8O/Wos2Lgr3F6gH/Ll0JoYN8rSuEEeVHPUYYF+RHbJDtuggywqYDREaHQp7Sh8VQ6atWMBFErgJNk/lQRwIfYM0RjoOuOlBCOPcFN3kllXt39prq2WeE8xMFYNSYUCZI+6KA8ww/U7AqpvrnDdS4kCkC3RO0ajIiisxTDLq/Ngv0ACMqBHolsLCGCIz0AyTVfKoRp4elt/JaDNFPRG4x52OAudOzuMomayNrbIAEoV/SBL8Gg1/KnC32aY/+8rAZlULg247Kp03nZXt7+kjL3cUmfejz8lPXvf/yYJBozPtY4HzB03iSWMNYyrvP19QEIMcYFX3aCm/2lKugmE4ag7JE6XVWtwq0bRw5YPLpUNOgH9VzOqsrwzWzZ2r7fKSejow8FK5wEapJDXqvWWgtjOOUuW7znh4PuatPIiDO4a0EQOaAj2Zsm00q3labOUBxzVGpsgoM0kthxGUUvLoADGbVYeSUJeaSNIY7DYva38EvpcQe1hnTif2Q2+SlgRxDBhCPStPqAYB4olmQb9TmJiNjJfpMtgXmUgD7hXOf5Kboz8lF9RoEAEDPaRv6Hu7PXNS2n9up2z+YE85M7iLvOnO78tfTaSN8/VFSeMfIJqM3Wp5//mCghhkBKKr5XKXhjajvOdbAv7V2mSZe05aRPvxjHlUV+mo1+fK1Rr2ZZ8svNjBH/LE5jQKTHSvyC5draJUZ2tlWmvomJQDjX5cZYOrfGAiZvWYp/IgDo54RPkC+LHHvCyrtRFSumtAvr3WMkgIAqkENle7bz/bKOHqYnrURI6IeDHZx33GNvOC+l4kGSa56EPWCE4fb6BcYl4n6+RJrXCppKkwyZojA7yhkhVEqZzZVBSsoPEeFTr2l2Ey2ZvdrDKC8tu4c9Nu71kZ+8W9suXtp+Tk/N7yDxselkc2r5f/96YPSqc22fwTChR4raAgBhlACPkxuVtXmXTSG54xtJkXfnvbqNVauCNh7RUCcd0Z3fdkaYlMjploBxvYb4glbFZDG1ciySRES+Nu0rs8sLvVcp7Kgzg0liMG8amEavOmyxPL7dz5ySNqjHLSdKSACZrP5ZwQfRluxlIXkIsg2E6N0cI5p+UINicKA5UReY2S2HeqFHqY3pqqctckrweBW+0TkYqKKFBVwT6HCRq57yGheCUk7vtpI8P/9ZDs3XRGXvnf/WSF7NWSxt+85cMyunt4tKHA+YfGGlMJtbz3XKMgBilB3pPVBflOVVd75yaX6FrJ2oY0l2dyJqyVFvhL0sJK4SrOh/m/qafXV30f9PNMk+yUrbJbtqqAca9s180BgecwGSf1hIsYxE1oecybnGgyi3Yh6nOelAf1fBBRwTOA/VjkXa9h9+dltaYZWGePMVOyh9zlTCR5WWdWKvmwWg4bJYoDUbQkghWHV8xOLd30fx4Cy9EmOwnHKpw7s0PItYIU8Lnc11HVHK6iIS7i4AdDft8HjkvHLdtl2/t7y6HuHeTir/6N/Ou7Piw3jJ6Wad8LvDbReAERg3Njy3eeg/D3o3K3kgK61J0rUoAiHVLAwI2SOy0pqEQM8uOYOSzL5A4dPIfL+ND6eELltRKD4KqRDoCYQ13q3SxDpPo875CXtHxshXlAhWFu8q0FXFP33aHREvOgkgKMdrA2TutQ6KodstrxNtey3KWkALvqud6VmlJxky9mSZfI67SskWuxXp5WgyH6VWQ5/igXRUgBngQL5bpUpae1OChSeoqg0gpmPS0RpNqEe5+ulY+Ze0v9E9JrJ8JICp9BSsrd11ElnsSxQF+fEVgadH7xtHT8zONy4qnnxRvcS/50yU/lG8t+r6LZAgXOFxTEIAFHzWFdNTMgk1eOal1bb6wxj6tpDvXxizJMSPW4vPvMbq18cERodESJmCMGWVIJafGMWa5mOG4lT+phjEzVentWc2vkcXlQfi0rzRLZZ2w+OQ8o+4ublKmsoOASj4Isjo70v6yFGJwwx+QRuVND3axqXdtqSB8reAcIDXbLl8otGhJnlU3VxjJzl5o/xcH6DpiyWZL7tyfMA+rNQBifSEErL7lG/5Q52cypMC3QMOBH4UpPOUpEgwgrF8tNWilAWeXDcrum1dKA8xA0WqI19qMlnQpVDlH3NTikHh1eYgOqILQM8/Djsv87v5FTK54XaWiQf3j+YXnXr74nZ5rC77UC5weajFfzdr6gSCXEAFe6J+RBnQBrLQvL028hqUFMNPKvTl42m7R+nijADLlYQ/2R+1oui2xoERdJQudEDRClsfqjUyMiRkLBW2WDlkRyntgaTCsthaTeP4tSn3LIYFknESKU6hCjvMZBp0oOhf5JPC2Y0J+UJXrf+atP3Iq5vW8id+AemSAzZIyZqpMsKRhaX+M5AaENa3/sPBGcIVGYxXHqfS6ZXXHNsmCzeU7LMp2GgegIcNoCjmuaLNQoCDobNqILWC1HPRdcP7svPUJTgWl8H/BAyGoT7e9q2dTYKG3/41npubO37Htjf7n38Ety5b//vfz2j/9GurVrfv0KvPbRWKQSChw0+7Q0kBXVNFlUMylIM1W70ikmOvLu+UhB5buyvvN5s1pJAav0+XJ1LCmw31PdXbEe4s6H5fdKCqg8cKHzoAaAlTvVIOTZWVEyeTOxUOnAZPig+bV63VPemS5iUNl/xJD4UzCBUCaXhxQ4tT/IOrmQIuEYuO+Y/PwTmDMQigvXa38Cb75GmTDqQTTK8TxlluqKOay8kJX16VKEBFJAuWBWW+9D5Qk9PSl73jyjpICoygK5TqNi3PsAYuIHz99iuVEFsFQcLJHfag+GMBDtAE67QvSlck1nJJICCJI1WOqWieBACtCUDBGr81Bjr3uOy6Bvbxdz8oy82HBM5v/bZ2TTIVfNU6DAaxNFxCAETA50yWO6mCmLE6sAzqWbYUtRg0o5YnNr33MRMThkDmgTKojASJkkI0uVBy7U3ypCOd/Wa1eucmBViP0Sq2Usd9lam7ZqUEMkoYPX3OwGAaUjNpVoiafOd0nEKA5uNR62uk+z4pwtl6pdsh/HS8QgjX0xkywVLJAjPAJQ6S+V27XdM90cIRCuURHRGPQkTIZ+i+MsqLgepnP/c4LOYCfIMlnxOoeWvkKWrSB3td4vg8wINdryE+gDpegFxACtDA22uK8wjiLqlLbHQs+UPRY2mXWySdZpyet8uUZWySPl7wfdnjklbb+0U176y95yuGdHueynX5Gf3Pg+WTTElvAWOD/QKA265X//+YOCGARA1zse7HoZyGR3MxwnY7wpcq7gD91nNQ2qaAwa6lKOCcUIOuo5YpCm7I/JcKLQzGemTgiQBFaXiBbZ6D+ATwKTn6u1Z8LgWrN63SobS+ZNV4SG3rOWAQIaWKfBc+YpbU4VV/ngGihlyeMjWCVEj+cEKQZMgyBMg82ockXGWnmy3Crab3GcBYj9IIhp7h1HQjkOSKj/PUQskq41K35aOmM0RakrkaKZ5pIymTgmh/SexJ/ARv2aQp0ao7C35IGQRnjoyjlt1OMaJS/HzCEl2P7j6vDyGRn9hT2y+YM9pHFkN3nz3f8qn515vbx7+qWp9qnAqw9To06A958vKIhBMwMb3N0atDQwr/9+Fvi952vxvM8DQst05mN1y4Q5xZuX6f0uzF8LMXjRrFXL36hVsiMGDRlvVTocTpG55WjEZlmnq2YEjWztTUeNzLBKZoMUsHqdoxbLtTd/cl0bkz4LYvaMLFOPAiIBkIIokSNCRIBjZFYQ9SK9QKpivazSc+BgNTTzpG/KiTMM3ENJpYp+/UwUCeW8pSE+ECeO53mzSks1SYOMMtY2magbBA/Ca1OBCyO7VYaBTpfc0+0TjJpcV010JAvkWr1uPFPcs71CUiptDjXK6K/tky3vOisnZ/eST6+6S9bu3CZfv+5tLdaVtED90HgBaQwKYhDo1McENVdXjF3PScqCgTLKez4vKsZDDbHVFrS/ZRCjbCtOoZ30PXlTCZj2UBYW1/PAlFa1tTgIYkbE5ODOOSs8jJT46YAAjzBwvQZo14MhrR0vRjqkL+K+3+kW0lQJRKGfN0T1G2gwiBwAJvS0kY0oEO2Ksx/2R6Zogzzdu7j5Z5jTSlKSbIz9GOtNk35mGIWaakC1y2zVe9ppR/KkhE7KscSySxdhIjLAfePIHG6UoH9EtEHNkL53UHbuOiuHbuon/717rWz4f1+XX7z5Q9KxTf26kRYoUAsKmlqqj3ekgLDruSAFDGBYHANywfUiBWnTJTQBYvCcGFOO2FKpBG1Vbe5VUoCKnZVflI1uRWNQHwdBJgl8Eljh+R3/CIUvld/pgI/4rFbgYxBHmFhZPiK/V1KAHe8sr3l3xnCXwtof2S3m+TIpYPJklQ5JxLsgz7G7ssewdsvu95T8QgrooRFGCoBzdswiYNTXez1UhIrXg9M6AFKBWUkB1wXdCR0zo7DePF2OMPlJgV+fEBRPBpswDfz1Uen3/e1izjTKM2f3y4J/+6zsPJYsli3w6qHRNNS8nS84f/a0BYGJEKFHcoRhoqd6g4EZQZiNTlx1TsSNDi+bF0viKGuvPLAGX4Y8EYNTpQnRTRJUHsRNiM5dsdaeA8FyQNuyuLGsyh8so/V4GPAfkt+oij9NVUMUbMtlLzJaY012Tmm/jaBHfxzZiLMvTgOID82KyOOjregsXdXACNEgan7U/oj7sgCvh6gOjRANhI1oBwbJCJkak65yosHe0j/zcXEPDZBqYeHO0uo9C3aXCFPUxI4bJL0+IEEufeDHETmkEbA0kaeej5+UoV/bIXL4pLzSrlHm/8fn5JndWzLvc4FzgybxpEkaatjOn1RCQQxKpXAL5dqcJkJ5B+a2OrB0boHoRDmVEBic+G7c8Vw5Yq2EJCsxoDOhf0KMmySaaQzqFOInZUQ5IGtcvCmYHLkW471pcpl3izbt6SidVI+AIPQRc4dsN9knGIR9YZM4qQx/tCZLEy4+s5beC5hm2fB3RyUDXD9WvVRrzPeuVtU+ZAaivMzcqfqXtDl5gG4guPqGFJzSLqTjZYKHMDQariIhrHokCTvNVjV2cmDiRpj4qLk7k2Oii1qEEQMqKZwbZFjaie+BEGbp74BT4sgv7JLG7fvl2I49csOvviX3bV6b+v0FCrQECo1BaXVHKRfznFf+01D6bysN39o/rUp/Wldt9k+b0tZWc7ZuY/XgL7VzIUh/iVZLg1AugyYrQiaF+Spwqz2f2ZTB+RDR2xp5InVnwsp31K/IxynI/V0Csar1RyPo5DdAhqpJzvOySieK5+RJ2WCeVrEirZDbpCrlbGzWfwGCwWflLYf02yFnep9p0rQVugpnmuXaLfvdASnlo5zRdTmEwPQ1g7W5URwxY5UM/A2H/IZCaRuOsU95iA89I2i8xHX1SmknJm53HESopptFqYgw5ESf6cCzCamiooPICgLRsPOxS+xqHw1HFmx65QnZ/ffbpeef3SLSvo38yf0/kq/Ou0XeOtm6XRZ4baCxEB9eWLAd2Bh2G0sq9Ub9W1PpD8IqftoVMv+t3feccH4H00kHavLs5DRbgij4BW6sZGZKci673hGDTeY52SRrdeDm+9N0Jqx8R+39EPwlcmFCx7AGSqSUMLbi/FGj/rJs0tUiWzfTS8bK1NhSVu6Xdr7PfdE8q82ObDnk5bl0LEE75DSw+f17tSUyor+LZKFe/8PGrvKDQj/X5XCEGS/PyKOqRXhIdso4Mz3SDpyyQO4Cd/+SKkFoyDOEGyM9HdIAq+K0PgjBJmOcV/RBRKTQKLjj6GX6KUFYKUtkuEkW2VJdETwnTiSb5ETK/QVoOJYW68yTqnFCV3rgW7fJiPe8Q07O6SUfXfFb2XnogPz1whtSf1aBlkVjjTqBxvOoX0YRMRCRyTJbWnvZVyoMuoR3GdDsdlrzwCjSz5Y2/rDScCtfDG94HaVnrOCqYDyNLrAq1BCvQBy6qrVrFuLgJuzqcsQhMsWz5Xv1Qhrx4RrzmOZt0b3P0ba9GSe2GokBOW7KQSFGwRK5SgfE6GvPa1nxsiHafEHWaE6ddAS+CFg0Y9scnCw4N+5z3WozbZfCMLhwuL+vQZbumHSmnOjNKv8OjQeIEtlBXEh1YfrExEukAwMmqjuCOpyTcqIcdfHbOVMuShVE2n3lvs1iqey3U0Yf5FIROD76oyAQOTpUEi0ilUO0JuxZgtCwD/7IhyOU7BdRpvjIyUG9z9MSb0cKeM6JlnQ+21mGf/+gvHy4UY5e2Vd7LOw4fEC+fu3bxPPOn/x0gfMfBTGoAQwAbUt/cGaPKtGyYeVWGolY5N1QNRgekf1yWA7qxMXgQElaOuLQQeve44gDTXj4blz/RmXIZdejLFI7E8oDOljm7/lQMSDKa7FMOBzSFkaMnDth2vB1b6+/CuMIk+O8x4SBXoTufxjujJGLysSHc8Mqlu6MEIm4EHQaOLV9h5TdC7EBdo2wwspR6QUAgo2GghjsjZT+Zmi5/wKizQFmmLonumPhfuV+pPnW0yXXv+mySHp56UWEGFGB7ikrEjaaZ2WLrC+7DUK29hpbEYCo1Q+IzCJzg0ZA+B6aMc0yeGZUkxDIm3/F/7R5RF/Ps0WFQ9y1g4CyEIirRghzfsSTAsMtzi/3KBULg//riOw+1CQH3tBffr7rWdn1i3+WH/3Rn0nrhtqEpwXqIT70anr/+YKCGLQQ/CFczIMYPBG0+cFgRuc+tjBQ140HPY1lGMgJ2VYTh32hxMG1EmZSHSWTZETJXvhcEQN/pKKPDFLv/rywEQOvJovlqHNwquROmDVvj0gVQyCu8TbZKFtko04qbJ1NN+3cBzDy4RxxfeOa/qQB91FaO2REnqyQOXf0exgc4mbI/ZPWqVD7L8h8OWIO6uTKhEZofYKZqVoRzjF3Ap4cfOYsuSSzY+jBUo+EqGfBjw3GGjTRh2K+rzIAAgaJDHOt5DghKy71QHptrKk2FHN9GkhFUJXC8wpRmSGXJJ4nzknaNMKz5gnVPjjnRwyuAN0xpXS397/jmLQ+vEP2vKO/LDn2stzwn1+VX7/tr6VD68Lr4NVCU42WyM5C/nxAQQxaAKweCOEy+LoQLgNN5oujxKGfbmmJgwsROxBqfdGsk3bSTlfu+L9DVOpRgVHJ/zdUdaRcUZqQ8/ruN+9lkN9iOc7R70zGiEEQTBZYWLPRdGujPKMtod1ADykYLKNkvDddaoUTCya5ApLu4PsZgqbKAunroZ9pDipDspaAssLGc4JyW6IknGP6BNj9O6oaEiJDeSpt7H3rJd6XLvweJuClJDJJgwER6GH6qOYAgkDLbqe7ICrDveDcGUlJzPQuSbX/RFPCohXRpKASQTpk9msKIhjx6/3ICWlzZIds///6y9q2h+TSH35B7nrHx6RHu5avnipwYaMgBi1ACujkxsqe3PM4b5q0FILEgUHa1ZQDfAr2yA5tiQtxQGHPRvjbMw2ar+6qa6J+0kcGZ859ByMG1lKaCdlo2R8K//qQD69uFsth/QzytEYOorvXS3PQNpz+cPnfmQQ6ms41W107O+S4iEGl6qFBZies2gl7J7n7RWGYN1YGmZGyRh4rpwBYqVMCm6fU0BGfNgkEzelVCL8jNPSv4oneECnz6wNiCY65Qd0SeR6oWphpLtVIHMdhu5v2kxkRRkxhIGVG5ClOB+S0Jv7UGmkprkUUoaABU6uv75Stf9lPtncSWfTDz8m9/+djMrBzy9u1F6hGIT4skAtW7HW3TjjnuhkSxiso5sm5uta0lGf5hVgMnjSceUXJwn4djAkJs2m5l2mlOWxyqn1kgFZrxIVQ/cTACcFs5cHiujWf8nc/TIKz+Y2zWA7rZ5CnBDA+UiHlsDiTDCtTSBtaDybVPHB2yFETjzv/pJIITycZdTGN5iUGbj86m65lYsC9QEkkzYzyRKO4FnFWyLgyUm4bpVdx+8Gdm3b/IXKuWgQy744DHck0b1GmxQD7HxXZ89+bwf3fJpv05+BSGiHS6+BLu2Tzh/vIoZ4d5OIff1HufMvfyNge6bo/FqgPmkpGRfnfX6QSLjiQV39U7tGqBH/b4JaGbcJjRVUIyWgCtFb9ApqDwYgWxGz+dMRu2aHvPyIH5Lgc0+iCy5m2Mq31c7tJb30fKzI3qDli4Lr2QUroM1FPoyi+I4kY+IWOadTjzRodSbua99NPjHDgo1Mioj+0BZQ74l9BpAaCMFImZiYIcXbI681TWk5phXhXJRIiVqlphIepyuxK4Ji5ZxC8jjJoOpJ9C/zPTlRFgm289IgckD2x5baQhjSh/CBIdfUwfcv25OgWspACv1siepowPGOWa6oh7N58Rbbr/Z3kadF+5xkZ/aU98uJf9ZJTAzvLVT//mvz8dX8m8wbm64ZZIDsajadbXtTy3nONIpVQB/jNXMbI1NyrwqzwT4hVIimTLR0xSIbr5j8eogj7Zbea15D/5TteLnXka2Paaq6bMjXgjF8Y9OrtxWCJQXzPASd0RPg1NYPQkXWemwxqgVOYW2J0lRDQdxOvK3ccaSbWRBDY1zAnRVdOR8kb353m/DunQipa8sB9JyF96/HRKJO82TLIjJBVsqzczGi6LE5VnlrpkdC72f2NgJToVk+xPS6iwGuYYLOmMviODbKq/HdcGqkkIQ2XVizq+k5ggBVEXLkj340uIm23zDb7z8roL++VF//ijJwZ1FFe/4Mvyk/+5CNy+bBzswgpcOGgsESuETjkEYaEFKAAP1ekgPAlpWNM2EyIs7xKfX6tBkys+MmJs3K62LtBrvDeoEIvJjKbmvC0IsLlvV04frdsLXsD1AtoDKIiBggdWaFCCqzFcrbqB0cMcKvMA471SfNQuewMm2EmQiaXYIpCCYI3WS6VmzWSwDWCIDxofq1ivjT76hdJaimseUAnHVI/wWY+cXD1/nGNguKO130neX6iLs5bobvXW5sZsWpHyLdMfp+q74LrkeCvSHClvkz4lADGkQJAWiyLx4O/cqhSCtpJ9wGdziNyh5a7pgHiX3U9DZx/0h/2XPUIjWJR9cB9kMUQ6ezRo7Lj6z+SEyufl1ZD+8rb7/mh3PXi6tTvL5AfjaWqhFq28wVFxKAG+B3e8JnHTOVcgBU9AxqTBSa9Y72LWvw7UZp3lom+476vbD5ErhrPBTa0Cu1NR9UnDJXRNTelYuAMC6H7hY5ZLJbDiEGeMkJ/5YnfURDgmxD1uUkRBK5nmJmN3w6Z78afgcmQjoIXedmsc52HQZb2xn4HTSbP6d4i3Q+Im79SguOjEgQRJjbc6CvoT0H0IErcelSJileOLlSX+iYbc7EfEHO/nibN8UDo7TkcIHtlp0Yl6OfgrLMflTtlponXy/A5XO/gdztNRJwHAukmMERGZYhM3i2Npxvl4I/vlq6d+krj9H7yngf/n/zz2f8tN4+L70VRoDY0mQbd8r///NEYnD8U5jUGaroZKBmwp8i8c0YKaGzzqNytkxppi3NBCsJaNkMKnEJ+kXe9XCq3yDiZrnlgVvCkHYhosCJ+2jysvRLyRBMsMfCa5fNXy2NKGGbLFblIAXB+D1mBeRBKdkgBXRlpI+wf+FlFJ7VHjoog0NmRCELwXDk7ZNuY6E6d0BCsZSUFFQ8DLzUhctEp2yJ6qJIC4CpgMNgKopfXTy6R1+lqnwgFpkLbzebQzz8hx6tID98FKaDUN41b5/6y8DBd7wn3HZxDvAM6lgiSSwVwXdSnQkjVPai9GJL1BRXdDsZIkAL8EOKMkSDSRBqSNCFVpEDXnQ3ScFZkzHeOSvsV+0RaNcgHHv65/HztY6mOv8D5ge985zsydepU6dq1q27z58+XO++8M/L1//Ef/6GLCv/Wvn2+NGkRMcgBa/v6kA7WWMT29pLdzurBFbFzpRTOJKyS69HLIQzbzAuajyXnT+UBqyrrk29V3qx83OqHc7RNXtRwqSuTZFVI6R6hU0o526UYEIMaA1fy5fL5WS2Wg8Qgq6sifgXUwLNSHivVBjlJnRXDEBlBkHUy0kyQITJGP09fKw1KChprNK4i1RHWHyKq0oYJiVUx+zLOR0SdKVFUJQDHxvOx1+yQNfK4PCcrZYd5SabLwqomXgh2ycHbUt+7dP+ylPpSaQPShOT95cREtMZ60+Rxc5/em/5SR7wv5pkuSgyIgh02B2WCNyNGX2AXBpBg7nVIQZxOgfMKgUzTYhoiioaJRQjke4M8reWUXqOohfKWM0ZOLOgtf/3Yr+Tk2TPyjovSl1kWSI/GGtMB1gYsPQYPHixf/vKXZcyYMdrs7Uc/+pHcfPPN8vTTT8ukSeFOthCIDRs2lP+e10q7IAYZccDsLSuY83TIywvCsaj/mcgYcGptmZwVzm2OFQ7lVqQIaI4UBcKvDI6u8oGyLCZ0Vp0QCrbWpq30kN5qAsQKMy6VoPlteVDzubVYLDcnBg2ZWvtS8cE1iCOEjXIm9cQbRhA2yzp1U9woa4S+gf1L3fpck54JMiuyoVEaOAvjLKLaMCLitAphEQM/+ngDZbG5SatnqC6gk+lEM1uJLXl8rjEaDUgPBCTMwjkOVnjYkFgN4yIFRLTocTHGm1pOrXA+goNoZ6+bXGyul8flfg37HzUHm1VF8N1ca9IkT5mHVbALwWBsiLs/XRphoIxITQpIV7o0EKQGeE0iw354SLaeNXJ8cR/5xJO3y8kzp+VPZ12ReN4KZENTjZUFWeOlN910U9Xfv/jFL2oU4bHHHoskBtzD/funtyKPQkEMMobR6YrIxECIsF61+kl4yaxXp7n0znKmzuWQy3QVZN3mUL63ydT5kNUhLohsALc5yuuo8WeyY/OMp5UN5JSHyEjfitJ2s0QMZi2Ws+fUo8DKO23EYJNZq5O0v2Vz2s6KWcBkgqXyCB9B2C6VEDwdH+nZUAuYZJKEen79DKvUISG2yijqtS15Sltlokx4PayTFer3QIgeF04Xkud+0mPPUOpYER7GR44gp6TgTgeIB8SEY3Qktvl+t5X55hpZLY9qZIL7cI65UiNVPBvckxCBlWapkp60boku0hDXWyFICkhXLjN3Kgnyk1L6Kwz98WF5+azI0cv7yOfX3Csnz56Wv5x3XeJ+FDj3OHzYil0d2rVrp1scGhsb5Re/+IUcO3ZMUwpROHr0qAwbNkyamppkxowZ8vd///eRJCIOBTFICSt2e0wfyjlyWayjXj2x3qzSfD052LlydU2h86xghcXkQL43bBVkUxbZGTTNdZwCnYGZSAR13pRFslHuRudCcsZ8h1ONZ11JJoEBN03I39nY4ncAMUrKCUMM8lY6BAkCURVSCw6EkduaedI15/132pxKdFBM2yGRkH9WDwiiBL1N/5I3wd5yf4K41EzSPcp1jOvKaNMhd2mkJOgxsrPkxQAhjYJNiSzyiRLvkBnmknITLp4PCEcWC+WjcrhczpqWFHCskCB0PEFo86WfHJbtZ4wcuaavfO25JXLi9Gn52OKbU+1PgXNhcNSgP4cMqb7XPv3pT8tnPvOZ0PesWbNGicDJkyelc+fOctttt8nEiVYEHsS4cePkhz/8oeoSDh06JF//+tdlwYIFsnbtWk1LZEFBDDKE8Wvxgs8DVwMd5gsfh3poDAgjI65kMA227PV/T62WHRCdMTJZN1Zg+CdgnIOwjcnYgYE/zh0uD5jA40L+/jr6bN0RTV1Mkzaa1bJFKqWMTF6kYyBrPU0/1ZlktbFO8jCwUbFlel2ny8WRKR5nQRw2SSWBiNNsuUxTUZtkrf4bJX2klLLCpVeiXAet8ZgV64ZFI5xjYppcP6S0q+muegnSWtwT+h1yKtFnIUi8IEJR0YJqUlCxFq+kH8KfA67ZoP8+IjvOGDl8Yz/59ovL5cTZ0/LZy9+Yar8KtLQlcoP+3LZtm2oBHOKiBUz2q1at0on+l7/8pbzjHe+QJUuWhJIDCIQ/mgApmDBhgnzve9+Tz3/+85n2tahKSAD96CEFWM2yWsxPCkw246JyjXoPWeDrIHcuQGdCcrGQAgbTMFKQp49BEph0WVHiUU90IJjPJoz7iLlDNpv1dfFLsMSgVUzo+a5yHX1aUsDqFNRKDFab5UoKCPlDikh5oNDHK4G/k8t+WH6n5CHLuajoArqHaigqqbLLI0mBSyNkLXms2g9zUHtaOKAd4Xyn9Q4ITuxhwkM+y1/BE5aiIEJFtUdavQqiRESvEEoXycpCCqptkEelJgXAuZEOCDFSqiIHtx2V7r+y5+XftqyUv73rJypeK/DaQNdSlYHb4ohB27ZtZfTo0TJz5kz50pe+JBdddJHceuutqb6nTZs2Mn36dHnhBWtMlwUFMYgBZWPr5SkdBDCQqbUmPw2catpNSHO87CK7WoYAygpxU8TXe6rMj833tlT1A6F70gmuhI1Bn0gN6QfC1/zuAblNHepY4eaFFTa2CjWtehiDGzmuvgLTvIpHQRJclUZWs51qUvigRk6YvCECtvzR7ifOfnO9K1X8SLoC8rBUfqfXLQ2ceC0oGMSICGFlQ4kAd0tIVUBMQJqmRWErZqIeTqPCxErZIOd7mdwhe4ztVJgGEArEqcH0jhVO3qWkYFyE8RjPGr+HfGcBKQC/W2HaChSHA7Jbx5TgeGLN0sJJAfcF6QeiFGnuxQG/PyY9/nunmCYjP1xyh3zi3p9n2scCzYHVWq1brUA7cOqUTQcmAV0CqYgBA5Kr5oIoUgkJ3veo8BfINalqjWsFYc/lcq8qswmbjw8pj0oHU7PfP+LKpDx2PVIJfvgrDxgAZ8llskR+o4Mo+zJdFulrWDltlec13cAKl34OiBJRzmexxGX/gy2XbdUJJaFNkaK7NO2R2+VoUOQ3LoIUQkjsv+N6WJ0yQHx2idykxkg0ASK8TXttyFxcVMsSF68qAuWElZwLSEGaXhdcoyxNi/wlt5xf7pvRMkVekDVKLkZ6E6WPGaCmSGwDzDCZIDMTJ0HIRPBcs+rGfApx6QSZIYO88NC7S1VF9TiISy/RV8QRQDwLKHlM06ODawy5DRoiQQowdYIUhJUik0Lijo2LFgT3c9Ndt4mcGCk93nGt/Of2VdL+wTby6cvekPpYC7RMKiEtPv7xj8t1110nQ4cOlSNHjshPf/pTeeihh+Tuu23Dr7e//e0yaNAgjSSAz33uczJv3jyNMBw8eFC+9rWvyZYtW+Q973lP5n0tiEEInMjINqWBFNSn+14cjpVU4LXWqNfL7z+NyDGv+DCKFKFpYNBkksc0ivp24A/3M/AOkhG6EbZHuc8A7zZcF/kd3S2TV1amSmNAjf06bVvs5Vb/V9ojZyMGhL0fl3s0OhAkheTyoxoeMaEONWN1tU/qiQmxtxmgk0tY+sl6GFTO53rztLwsL5Y6Ul6d+l4njM558vsRJGGP2aHqflfVEzQHguwsMjcqOeReRJg4y1weeS9y/YPCQ/8EO1FmycCYsk6nT3CVEVmIK+SZ72B8oMqCCA+pkHkmXgvk0gHO9yC4z1H+JE5fgKFWmv10zpEDlxyWHh12yoE3DZAfvLRCOjzSVj66qLoMrsC58jFoyPT6PXv26OS/c+dO6datm4oKIQVXXXWV/n7r1q3S0FD5zAMHDsh73/te2bVrl/To0UPTD48++mikWDEOBTGIqNen/Gn+OcrtHzCvqDcCq9SkwSwNsoT47Qpoia6+sbbFSTD9MdcnYkC+GSMZBkZ/5cEZYy2LowSCTGLjZJpuh80BjXZgqMRPtm6mp7Y6DvMbcHn51qXPdmSQSZNzkFdL4tojZ+lceNQckic0fdOoXgbDfekb9pPrGZea4HrRxZESwzWyXFewS+S3MsKMV+LgB8TDpWjWmMd0cs7SgMlPgLK0q6ap0rPqAUFVzxVa7vm8sdUWXbzuVdeUCJ3rGElqYYqZo7n9aOFh/zK5xnMgLBSfpcdBUsMyiAz3GWSK9xKled48o+ZUOGLOM9FRF/qJALfyT0MKwCE5oNcpaV+rSIGMkIneTJG7j4tps0sOvr6/fGvjMmnXuo385bxrE4+5wKuLf/u3f4v9PdEDP/7hH/5Bt3qgIAYhrWSzVgHUpwzS01A5pXz1QfKUjcCOzoTW77+/Ti5Z9Az1iBiQT+b4+bRgvwnXyyCNWVB1qmFrKdWwXxX2rUwr7d3ApOtSDc4OmYkBoR8rvqyr5jC4EjY+K7ub5RzpH5jMKhGI5BQJZIYVLHoD3PpwT8StkvPqyBERqU7SXp4yS3Vyy2sWxbWJKxH0A78C9odVNiLOTp7NzzN5EaEKAxGT3magRhi4P8JSC84KmYnakitIQZPaGYcRiTQ9DpJJwSAZJxepENZfyYA1eTvTQUtLETzONuFeF4floKY+OI60pADfDxYNSS2lQ0lBCf1vPyZNbXZrtcLXnntIOrRpK++beXnisReooMl4uuVFLe891yiIQcBqF1ERedZaXfXSAMEXTWasaQ7eCOkG2mQkRwwYlAjdM0HmbcRkNQb5b3aqCxASIh6bGWIYlYUYVKcabBtpQs20QIYocG3ZGLwRurnwNStmvqdeboqUrrn9SII/dRHlZmkbDElVo6Ik4DvQxwzSc8sqFnLU2XTTVTRXDSU+kxGTIiWJWY+Z88q175SiIgEBL5OlFfBeXV5J24n5tLYLjwKpnLjUAhM1z84pOSZPyIM6eU6VBdLXq/QtiAK+GUkGQ24/IRycMybmqd482WjW6O+4j/xA4NjedFC9B03GpplFVZUdRHQ4772kb2pSALaW2p0PkzG5SAHgKR1421ExbTz1OfjsqruVHPyfqbbvRYF0PgSNdfAxOB9QEANIgTyuZU/1mhyy1KhnEXzVixbYVeojuQV29ahKcKZB1rjpytDjx1rYH+7PClb+mOaw0aKZ9MI+2aO1865+HlJQTzdFJrs0NstO6EnqgnuuU0TqAiV6nrJA7mFK9IaZ8bJW7+/dKmwETEasfC/K2KY6WJGQ5GGAMJKoRZiAl4nWfka8e2hYamGymSP9vMEaTUGUSRrG9i1Jrwtx+oYBMjwVKfB3eXwFp07xQu3QIWVtTQdNDRIJmmgqqUGMyhwZSUsKXE8KIlBRAugkUhD0OdjWRuTY5X3l4yt+J+3btJU3ToAwFihQQUEMSrXQDHJBH/SWjk6QN56vud36ixuj1vHbDWvoJ+uUusgeMQhWHqDkjkrZnCmF+1sFKgfyAKdKJg6+f4sQqVhX/h0rT6x683Zp9AOikdRZcZ1ZKTtkc0ncGu+k6PwC0qzOoyZWogJUW6AlsfA0opIXrqtiXDdDR3ytW2RzAW9lxZ68ug+mFtbIY7LbDNK0gU3deJn7lvh7HCS1mabr4mRvTtU18ZcrBtHD6y3zzJVKKogInTInVEzsmj2htbBdWaNdJR0gtKR/+kVUI6QlBQ48rUN+ekS2tvHk+MV95K+W/VLatWotrxubtwLqwkFTzW2Xi4jBeQUGrwEyQh/ctqadrmLbSTtpkNZ1JwpPmoe03WrLRifCV/KEQLfIBh0Q58jlkavUbN/i1VR5EHf8lYhB7cTAgbw6GW8HatjJ++Ldj0Kf5jpsea8LqZmo1Ie/7wTixDlyZaKOxWkMatG7UNNPAyMHrhjpBdwTEc5l/Wy32o/y9XjOrNT+Dpb4XhP6+QdL5CKLc6I/tYAmxB0NPRiyNBXjOiAS7Rrx3ZYU3KueD1QPTPZml3+3z+zW6IS/zXIYeLYWmuu0/JjIECWU7lqmJQXgpZLz5XAZVzMpqOqt8KPDsqW1Jyfm95b3L/kvFSReM3JKqvdfqGgUT7da3n++oIgYlPLC62Vl7BxLeJjVsfax1z+tShv0obVOBnZro39nMuNPa7FE43Sp9A5SQMtUDGpaKjphYuyVGaxRoNejBDOLxiCq8iAOfoFgPTUdXEFK1IjaUOeOtyBNqljFk5fHkQ+xG6H4rJMmq7v2IYI6/wo0Tfc9B1bEWQ10opohEXaHbF0sN8kqsZ0AMUci3J0lWnJcjkWSn4pWp7MKOaOOkUmX65r1GdBKFDNNw/TAPZFZwDMYZaPsn2xJM0wKuH66hlZp7LmJBEEOuO6Imh3SkgIAieQ8BUlYXlLgJwd0Zdzc2pNTs3vJu+/7sfznNe+Sy4ad2zLpAq9NFMRARNX4DOjUzZMjJhzMHwZRvNEaSxuDK38IYfJ3Xkee3vb/S59vPySvaM0zNfcMoKi7ybUSRagPWTCheVJWx5gG1Y+QpCMGcZUHceAM14sYPGee0lpw1zba9SBoVyoBGy/TZKyZqtUM/I7XMglgujNOZqRuXsX9ACEMivXwKCBS4s9VpwH3Y97jP2j2afqAfSKX/bysEg+a6rXVc0BaCWdPoiVUL0zHTTEFYTwjJ6V9SJXEKrNMSyXTRMMg411TVjX4sdfsKEc/uPd47oggjDfTZXBKrYwzNqIHSPPJ9h5NFUT1ByHfDylKqwnSUlKzQD8X8LynNVQiysCYFLR7rpUUONCyecj3X5HnWx+XhulD5M3//AW5/a++ILMHxLeCvlDRVKQSLiygznathGuFbcUKwTilGy526+Xpsv0r30VIkYGRn2714uCZBp1YWNlTosYgS8iTVWbW1Suhe8oRWXWyQp7izZN6Ik25YlLlQbqIQduaroft5Lenql7/TKnLoF/YyERGNIONkr+NsqbcFhpPhPEyI7FyhHPir++3Lnz36rEMk/EyJmN3SMhRloqE6gl0uV4dl3/HxMr/WYO84dLPDNb0Bor/JXK7jDfTIp0C3fnkj/9z7Dl+WD8jjVbnmMGW2USG8uMJ5vLSPcf7e8gEmaWlhDxj9PgIrvDDcEBe0fvR75LJMWBFzvOKQdaEkMkW10LbMCm6h0TYsULMHZGBdEBkZplkgk7aD5DaqicpYFx4STZoOuZk43GR77SSbm+7UjpfMk3+6Nf/LPe9+SMypkf6Y7xQ0FhjOoD3ny8oIgZ1Bg97+9IfHkAGMkgBqgUGlWBbVl5DvhUxHqt6BiYmcv4fUVwll8pY6OlExmcxySHeI9oA2fCvYFwE4xG5U2MbmPyM8rL35K41lZCm8iAO7HstVQl+i+FgaZ4rhYwanAn1srrH118nHdmvIeGOprNWOYSZJvF9fg8Df/vi8ZJ+ResH78VsKwucwJTJz5bB9igZJTU1M16CJFEqiZ/Gs7JC/QZoHIYwNUwU6YSHrteCX0yatpnQnpSlgmEGSRwTlTTPyUpNBeDdcLG5USdfWigfNQeVmMSR6JNyrEo86CcFcVbkpJpAWltiSAH3jLuPaZrEYgCiyb/PNfGNuXgdaSRHpmshBZg/EQkjolMuqS2lRJvONsqZnz0hDUNGSOPIbnLdf31dHn7HJ2VAp3yC1wLnPwpi0EKwTVzwaz+rEwkP+elS73k/GHwJFYZ1h2MgYEI6LPvkiJKGo3JSTujGyoP8YxnGNnMh1uDc96wt7GwZmDJ0nwdhxCBL5UGqVEKO97JSZ/CFAFBvPiEw2PPvadIgDMqQGj6PsDvnHOEeItURMlEnEs/zqhooQQwq6RObquqTorY+iFOlToNhYfukCA3hbvbb5aYrE3p4xANDoMWmvyr+qdJ5WH4vo82UZs2HWG2DHtK7SjeRpeTTRcniqhrC/B5cgycSIH5bYe4P3AYhDnvkZTUfmmMuDxVHovKH0Lrv5hi0q6Mc14l7vDc9scQRwpiOFFCS2KRRP4g+K3/IsSPMpBewUA4jB6SfiCm66EQeUkAqiagDkRy/JwjGTENlrHpDsGlL8VOXSdOt++WFj7WSkwM6y1U//rI88q6/k+7t6ldGfb6jqUglFKgFfvMS18SF0G5WMGAwALM1v0mbdIVDtIHIwnE5rHSB1ZBfY4CP+wtmjYZdWaH1l8F1LI9sHjHIWnkQB7fSygp/IyRI2VBvTCjpyCJaI+xMxAG3yOdltZombZCntQnQYDNS21O7Bkp4DzB5sR5D05HUjCqpRXLaVIKz5SVCg5mQf8XvJuM43wAmWCIFdKyEIGBMtN1slhlycTna45oHdZbu5VV2sJwvCUySTFBp7guiF7bDaSutcGA/DppX9Nr5J34+C8fDl8wGvSbsG7n9YGRnR6lXwUAZphEeJmdIwRAZLeO8aYnXA1fUpP221sxECjBcmq+khmviziHnqsE0qCAxqr8CWhcwREalJgW8jojANnlRiaB7fvhurhHExKXCXG8UJQWlluINR5tk5DdfkRf/bys52L2DXPfjr8gD7/ykdGhdv6qg8xmN57iJ0quJuu8prR7/7u/+TkaMGCEdOnSQUaNGyec///mqfuD8/6c+9SltB8lrrrzyStm4cWPV5+zfv1/e9ra3ab/q7t27y7vf/W45etSuyBxWr14tF198sbRv316GDBkiX/3qV+XVBtasDDbOvMTla+vdopgHGWtZ8sTjvWkawkVH4P8eUghMBEQtGDAYYB+S38qD5tfyhLlfa82PGFt6Vo9yRSoPSF9ACsjTs4KsReiI0DMrCKPben1reBNGCuxnn030GwgDpApR2mVyi55fQIj2QblNzXycAY419bk2NykAx0plgQzeSaAaAFLAxLVQrm+WBnAkI01en7LAS+R16vTHZMQ1pQOj3acjSga5x13oPQspAKTK0lg8U0Xib3vuJlYIcMeI9w/3kIqSzvA0soPJUrBclf2nEoWInmutnUQKnGthkr4gSAq4dqzWXT8HB+4hyAjfD4lxaSh/dALyw/viSAFkAPLE88w9SOoSPQ1kgIZLi+R6ucR7nV6jOFLg0HZ/owz/5l4xx0/Lttan5H/99Jtytul8yo63HEyNLZfr24v2PEslfOUrX5HvfOc78qMf/UgmTZokTz75pLzzne/U7lB/8Rd/oa9hAv/Wt76lr4FAQCSuueYaWbdunU7yAFJAV6l7771Xzpw5o5/xvve9T1tPgsOHD8vVV1+tpOK73/2u9p1+17vepSSC170aQPz0ZEZr1nrBhSfJR5NQIHKAroBOjYCBhzArKQ1C/NTu85NJzTOeqhYgEX1loKqm003olYhB3sqDONgVT/qHyZnqMJGQvohrhMRn11IGyPnh3LJBRjbJs+X6fs4JpXrtvejGR2lwrJSacPn8MDAx0Ho6qe8BqSfbDTHdI+9W4DT4ogoA74cdZouSPsgn6So6WI7xpmROsfF+IlhxcCv/oGsiEy/PF2LcKCC0XGiu1YZKkLXDZr8+jxwT6R7udSZjewxjZYw3NXG/nWvhkJgyxSAp6OsN0v4rQQGhA2SkwbTScP+jcqcsMHg+tNVnlf3kuoeRAn6PNJbnHaLmgH6kvwyRwTImshw5jhQ4dNh+RoZ+a7ds/euBskYOyLt+9T350Rv+rJwyK/CHj7oTA9o83nzzzXLDDTfo34cPHy7/9V//JU888UQ5WvCP//iP8slPflJfB3784x9Lv3795Ne//rW8+c1vlueee07uuusuWbFihcyaZVXG//RP/yTXX3+9fP3rX5eBAwfKT37yEzl9+rT88Ic/lLZt2yoJWbVqlXzzm998VYiBDV/TIVE05Oz3SG9JMDHwvYSK3cPO4BQEEwIlWP4SLcRxu2Sb5iCZOFw/AX29aaMTDQKvATIsVDhoaxK8mioPYo9NNcBeqnPASomoSFqfBj67bQ3VDn4gRtsuL+qkCZj4sO4dbEapF0LeqIlNC9na/aTmPkl9D9i3PNUduPgtNjfqyt1fi5+3NbjriBi38nZ20TYlcm3V8ZPCAYTG48D9erG5QaNHGJcRsp9qFuik7YyGshAbtCXc3wg505ICwHdDVKOqWfh+mnxBYJbJXTLfXK3PJOCZpGQaUjBSJmmqSCsJSvvPs4FmhOcTfUTSfZaGFDh03nhaBn53l+z4wAB54MhW+di9P5OvXP0WuZDReAGlEupODBYsWCDf//735fnnn5exY8fKM888I4888ohO2GDz5s3aL5qVvgPRhLlz58ry5cuVGPCTlb8jBYDX03v68ccfl9e//vX6msWLFyspcCDqQMSCvtT0ow7i1KlTujkQdagHyMkStmQKs81wolcz9QQrB9TYrCiqTJM0xp9OWOfPOaMPYFBiMKN5D2SDjUGanCgiOFZqpCxsVzqjKxtIQd7KgzgwyCYRA84BkyMCOMLks1LaWqPRJ29dK/wdKlXhLY260n5Ontb23XghjDITZZjX3LkuCUzmUekOf348TSkqhXZpUhJh4HyOMBN0UnZlt4S6B5lRmY2yiGzEVSS49tfWLrq5lXKlT0OvVPtNVQaOli/Li9rYyCGtyZZfzxMV5bAmUo4UVCKFPE+kTYJphCBojQ05oDyWzoyu4ySkACErqSlXEcH9wDMIEUCwnJZ0ErmwpKBLIilw6L7qpJz9z12y9x0D5Sfbn5GBj/W4oNs1NxXdFfPjYx/7mE6448ePl1atWqnm4Itf/KKmBgCkABAh8IO/u9/xs2/fasVy69atpWfPnlWvIQ0R/Az3uzBi8KUvfUk++9nPSj3haqvJBzII1ZJTzu5RcK+WHkWZsWQF4VryrWxuQGQgJwWByJHBERLiBqmK01/LtKm2xCAaJ1XoeK/6RWQVwDHB1Wqc5K984JxBqJioUfiTnydHjqMiAz6hccrssjgMclxhfSJQrBMK5/dpRHOQCKIYcf7+adwTHSmAgB2W/fKI/F6mmvmpGxfpZ8khJVBh90qlv0J71WeEvYbQOVGhLFEYKg06ma4qFgWIYtOSAn95ZVjlUBQpAM5Ea6iMTvwOiCNphQ2yqlxBACAWtpKAuNSYTP0ggu3kLSnI1jm299ITcqbrLjn4+v7ytbUPyoCuPeRNE9MbdBU4P1H3iMF///d/a5gfLYAL73/oQx/S8P873vEOeTXx8Y9/XD784Q+X/w6BQbSYFzvNFlkrK3SgI7cbl9O2qE+OzpmmIKAbKRN1xeFHvYSODCCUNvn7zlNxgSugG/QAk+HD8jvpbvroIFhbY6YKmIiiKgcOq57jIV2h5w1r+42IssLvUeAqH2jE5I9C8G+kE8iVEz3AYZAKEdofp4kqUTkB6fLDb5iU9riTShXT6mYgFhBDojJMltz76BsGGtbfM1JNOOT1w8ovN5hVeo7i+itAiDjutGWO/qjOZl/TLNIZkLYoYWoQrLTDbJDjSAHgHKmAMOXzQFktd4kz9oLAkELo4uX3E3CkoGMOUuDQ//ZjcqbbHu3I+OFlv5Q+nbpekNbJjTW2Xa7lvec9MfjIRz6iUQNSAmDKlCmyZcsWXa1DDPr3tw/J7t27tSrBgb9Pm2ZXPrxmzx4bcnQ4e/asViq49/OT9/jh/u5eE0S7du10qwf8ZVQ8cFENZeoNxGBWy9Ckrm9UJZxLMAgSlnVgsiHEuld2av07G+6N3aSHDJJRGubOX64YTgxwJVwjT2T2nXdwCvC8xMB+/+NK9PweBTb0Wy045NghDiPNJDUdIgS/Uh6SLqa7Vq1QWRIFSI/f3Mj2m3hAz4srg00DvDBA9xTh9+btuR8u6WYWqfkR9zvHhMitp+mj5IyJh8jSLHNpbCqJiZ19DxIU13QpKfK0u6QvCFu5x32ni67Y9w7WdAQ9M06Y4zLOuygVsSK87y/zpfoIcSPPYZhPhRUQHkt9zp0dM6SANAnfifYHolQPUoD/Q97n0HVk3NSlQU7P7i1//Kt/kXve/jGZ1Cv9dfhDQNMFlEqoO4U5fvy4agH8IKXQ1GTDkIT/mbjvv9/ahLqVO9qB+fNtf3h+Hjx4UFaurDQ2euCBB/Qz0CK41yxdulQrFhyoYBg3blxoGqGe2GKeryqjOlekgAmJSYW1NAN1NClomcIYtBSE7kkfQEoAAyb2sYu9G2Wx3KjqayYzUg9r5Ql5QG6Tx8y9ukJj8MsCBl1aVwWFaUzK5FrpEJmVFABnAJWHGLxk1pe+H0J4edWEwKQXJWhkskMHsEhuVH0GgkEmrKfNwzp5RZEXFzFgkrbNkKy4LS0p8JcqpsnLO+wxO5SAAiIErHoJa7fzRTBIPS3wri07+i2TO7VCIwrkyoF/xY8gDlKAoj4qfVB5/079mbbXgCUFdykpcPqKETJOFskNel5R9tNcLP4zTmpo3z/BJ5ECgBjVRQGSUN2jYYTM9i5TMsn3sv9EPF4tUkA3ydVmuSxt+p1s/sF/yImnnpezp07L637+j7L7eH00WgUuAGJw0003qabg97//vbz00kty2223qfAQwSCg5IXUwhe+8AX57W9/q2WGb3/72zXVcMstt+hrJkyYINdee628973v1WqGZcuWyQc/+EGNQvA68Na3vlWFh/gbrF27Vn7+85/LrbfeWpUqaAlsMs+p8QsK74VybV3FdklkxE1IpC3qFa5PCyZ2wsa2ze0lZVLin7iZKCj9WuRdL5fKLWr6Q16TvDIrtAfkV/KouUtr4tMMdsGIASWZVq3eThbIdbn1HI4YYC2dBaxsCfVCKCih8yvUreWwKdshR4FmTNhiM1hT9YHafan8VidIfy27m8yZMCGEbpLm3DvFe1ogENWeoCknB1Jkq+XREvm6Qrp7veSsOVN28QvL4eMdwHcQFXnaPBJKAp1Tp5vY15jHyir5uE6MDpTYogtJo2WBFFCJQBOq0TK5VJ5qqwp4v3pMaKRrh3oARJFWFx2jf0JaUlAxUvISXRKDpMCVJJLmYL/Z/0flnmY+By1FCtDtIABdbu6R+83/aMSIlIimN842yoEf3iGtmxrkVIdWcv1/flVOnK0szP7Q0SQNNW8XbCqBskJ8Cd7//vdrOoCJ/E//9E/V0Mjhox/9qBw7dkzLCokMLFq0SMsTnYcBQKcAGbjiiis0AvGGN7xBvQ/8lQz33HOPfOADH5CZM2dK79699TtaslSxIo5iYrI1x+cCG8wzurphUORBTyIjaZob5e1MiKLZ33wmSgPA4DtCxuvG4MdAhWiRCY+aeLZ2pqP0k0EyVMaFdi/kOBjMgxbLaVXVycQgXQ8C6xWwTEPQHaSzfn9wcmI1DYKagCh09rrptSQSQK6eCZKKkGFmrOpGnCcCLY61KkRaqTdDnnwzxxvs+BiFbeZFFek5+2EXDUNYCWw1SnMgiltsbpKnZEnJUvl2mWEuqdpfrj33C5UGrg14mk6M7hqw8o/6/uAqH3U/K27KRRFoQuj8KQy+j+91+xHlQLhHoxyeVv34SQEVQGH9Mty+IpLsLF1jjyuKFDgM93h2GvVZIbo0X30O4ofsrKTAuiXukO3ykqYvnPCRaiA+A50DwkdHTKccny7dbj0oL36yvezuLPLmn39LbnvrX7VYC/nXEhqNp1st779giUGXLl3Up4AtCkQNPve5z+kWBSoQnJlRFKZOnSoPP2z7src01pun5GXZFCuOagk8Y5bLXtneYsr/PJ0J/UjjHsiggXCLzQ1E1rZ1v7r1qY2vaSd9tCJ7rHQqiTgdwSFEzeRWq8Wyg2sikyZ/a8sh79eBnjIxVsZh30+5ZBZi4J9QL5YbtB8AURVK9RDhuZU5jYFsyurq3NEpBvuwlX4Qzo8ijIC6MkOuURS4N5hsnQ8BaadRpiKQJN3AOSeiAHnI0gbcEZMk50E/KXCiUNIiUdoE3Dmd8JEqC3ou+I+b607UBtFlGlJQaets9G7OSwocRnqTpNE06oKE1y8w10aer3VmZYkUdI4lBQiIOV7OqevvAYjEcY6IjvSQvtYQyhxTh0jn5ErFjew9K0O/vVe2/s0AWSl75eP3/vyC9zj4Q0PRRCkFnDEIkyOk4FywY7tKfkjLwrIMoPWqSojrTOj2D2TpNwD4DARgbM4YikEPoZWNKryk5koMTAzCDMggj8teFNzqPqlrob8klEF+kjc78rXOgS5Pi2Qw0Bsu/c1QdcHbLM+VKwnCTH6yIG2p4kbzrGxR/4Dw76NHAqvINOQEItDbDFRzIQgCfUIukoU6uXDuMW6KI1lhoGQ2qbNhGClw5Cou30+5ZwfTSYkZkYPZxnakpAkR9yCRhrSkAKCZiPu+tKTAgfRcI9bH8oLej5CX4HmzpMBqNYJpGb6Pc0BEivHEWY3z7HJsPIvsa/CaI870kwJ/qW3njaek3493y553WY+DKWuGyh9PWSh/yGi6gMSHBTFIuWKvRwg7z6RMGG+ad24fuKTOhIB8M8jTb8CPHl6fcniYvg1MjKwmOecOiOZISdQL5G2BX0gXBGFjpJMMimEloUE4N7q8XgFlIyGZoBMS58DtK3n7SWZOrmiRa57UNaZUMU00jHvRGe+kASkEHBOZal1qAXA+ud7B9uNJgCiR3ogiJuTGEeqRC8cvYoivxTXngChIWy96/yER7U0HtfV+XB6QaWZB2YEQUmJKvTfSeDaQ8mIREXYes5ICB/qhNJmzSpwRoc4xlfTLcyGkgC6SROXQdbjUmSPDEAGid3EOpbY77N16vbA4D/Pf6LXshJzsv1sOX99PPvbYb2RUz34yf1CyZ8P5ClNjd0Xef76gIAYxQDHOg5V1xV4LrGnPPToh0ASFASEP0lgJ5+1MCJpKtda1EoPgZDJZ5sgWs0FNgfyTwkPyG+lmespomaJkoh7EIGqi3VdysjQZ+j44YpA1leCHX0sBSCHwecRSlsrvZIKZLgMylqe6yENUbwHXY6NDKfzcymsVul+QxB4ZfRB4XqieoUPjc2IrjDierKTAnd8o50Z/i/PxMl0G+0gBIleud5L7ICBMTrQAfwquv7u3s5ACKnd4dlxErB6kwAETM9IK2JZzn8wyl6kehAgFRGSADNd/h9RWiHsrvfaUl9KmOg25DJKCuPt/4K+Oyqn+beTUjJ7ylt9+V5a87eMyrGt9LNFfa2gUT7da3n++4PyhMOcQOkCbh5QU8FDVhxQkh/d5oGmmwkA2RqbkJgV5EwlpOxOCRt/AU08gnoIUOFdCcp6Yx5AjR5PA/i0xv1XldNbyRwe/s1wQ280m1VW46ou0zaBsnwQv931ClIjBGFKAloIwL5PofO9qmSBMIEbWypNa+snAnRZOxBjWiGmVeURJAecWDUMYKfB/RprOjEFwjchn+yf4lWZppmuHfwOTc88Q4aGfFODt4CcF/rB+XL7fD1bRnAuupZtc05IC4I51WMk9tF6kwGGKN1fvD+6TpXJ7+fiI6KAP4d+J/FBCynFc7r1eZnmX6nlJTwo4n40yUWYl3v+eERn+g4PSsOWwnG3fWq7/ydfk8Gmbqitw/qIgBhGNaQg/ssrgoToXkQLU6bYJi83n5fHWr4UakGMmZO0Mm5IGQufOllVjEHvezYNl8RTlZACCgKPcPO8q9UlggGfQQqSHRwKTDBNHVmIQtt/2HFh/ClbPWSITKObzRk/IjSOwZHAndYPAklWna008yBshi+V1uu5jkn5E7pCNZk1VK/MoHA8pVXTEF/EZaZqkqgDnH+B3wEwDOxneWyYWHA9EGzErTaaIjmVxHuwXmNzdytaSAsy+muf0d8fYGcff25Vzy/6mxUHZq9Uu/rbX9SIFqhUwW8pmTfS/cOScZmeMG5fL/5KF3nXWBjrRiTWOZM1S3UsaNJw2MvJb+0UOnJBD7UVe/5Nv/EG2am4yFZ1Bvk3OGxSphMCDx+SMwlxXqp41XGppOGtlwv+2CVNtoXKLdGErJhd6PRCuJv84V65OJXSzLZHrk0qg5hxNBblQyBj14U4g2Np3izLYEtpkQ8UPOWDQ5pq1M7bPwxAZk0jkGPiCxkmrzWOaS85yDvw4I2eq9jUtUIiz/9beepKM9Cao1gL4Q+es9li54nzJ9UKLgaCMjoH4DMSXKrYN7cjIZDLduzh1OiKLQRLfw6QN2cG3AM1Id+kjk7xZSmpsq+E7ZJpZlOj/T0UEz0Y3n2+EXy0/MWYSg5QQeUlL7iGZaEscWH0jjm00Z2V8iNam+r0HlLT28wkkayUFRJIoFYYcHdXKl+azC71SIAK1wGo0KpGXrI6qbQ42yvBvvSKbPzZANrQ7Ih/43Q/leze/V/6Q0FSjxqCW955rnD972sJwAxmkgFXpuSIFlHZBClipZ12lRiOd86EjQpACdBQL5frUE6JTNteaSsBvntUjExgT+3RvkQ7irqQwqtEREwGuewvlOp14TstpTUE8KLfJKrNMJ9x4YtCqfA6eMA8oKSCknuUcBD8za1Mm+i34B2NIATgc09uAHguUN3KuOEfklDneKAMcPrt9qSzTTVKQAnLgaUgBOCpHNIqSdnJlX1D3QwoQubmuhH3FmgFRXYJ7I+kB6uMpk4wDk6q/tJRr60gBJDGSFJjD+pqkEkf/xA4pcM2iIGbcX0Q6EGdSnRQHCk7BcBlXEykggkT0apm5Ux6SX6uhGqSAihdHFtGEXCavL+3bi4nnMOn7nHCTnhdZXDX96LD1tAz8gTWx+v3+F+XWx+7KvU8FXl0UEYNSs5oVco9OTgxkSSuDPAiLIjmPeNti9qqq8GO9vyuuMyHubOQus6AeEYNXzE5VrTNBBL3/Xbg0rLugH5gtXSTzdRBmgNwiGzX0zUYJGoM0oiz/pAapYaLzt0yutfrD2iG3y3Tsq8Ta8QZL4I6UQu9RPvuu/8JQM0ZFchwr4sRxZnrVSo/jc6WKVsPAPX5c69SxsU4Lojekd9LAfs9dqrmAvIz1LpKVBt2KVAkAcW/EsIfoBblxSBJkIUg+TpmTeq+5aAWkgPREWAldlGvhkBS2xJYU2GZR7DfeGpRGsj/sJwSaVTuRg6hFAwZYkENMobKSAo7rJdmg19JFy0gBcdxcL7qHPi+rlKBACtAPsG9zzVVKrDmHVFWk1cQESzwrws18pMCh+9Mn5eQvd8mBP+ovX3v2AZnQZ5BcPao+ZcavNppUd1JDueJ5JD4siIFIaYI8reY61Ay3NBg0XBkXA+6cECe92uHFDoIrSp0J05TitQQxwOKZlRCD30xZ3CxSQmg+Sz8DBknXMhoRJ59NCBrNwAZ5RvqYgTJGLlKHRSbx1uLJI3Kn6g3StC6OgxXSJdsh+wWO7BfHPksuaVY25rwbkjwD+D1RJkSjqNPRiGwzG5Vo8LsDpVJFJhJErUQYst7jpHlcLX+WhkX0W3StjQnnQ36Dkz4T6MXmRvXrYEIkyjDHXFkVsdlV1hcM1q6iToeTpnkW4mGt1U+wzvaTAvw6qKEAVAUBOwFfqWWC2AMToQmSSPLzjCGkINOSAsgQaQruUyeIJXIIgeKe9Ot8XEmp9VKp+BQwbsw1V+v1JfLYznRI3ZrZ7/tAiWdQuJkVtvPqS7L/jl3SesBCaTNqoLzz59+WZR/8exn+B1Cp0Fg4H15Y4IHOO0FmhYau5X4dLFkRzpBLWkDcGB0z2GNeltXaGdAkrrjSEYPshMbZtoZZLAdLCvM0OsJumAGec40OgZUjJV5snUxX3XdXXhhXkpkWWUoV6bWxSdZqxIJjD2vAxedlSdEQJehnBmtbZyZYxIlDzdhyySr5/LztqV3joyQrYjvJ3KOCOP/3WCvj05Gtkq018eWy3rAatu6DM8zism7COR4yIULgXROppH4RfC+ufkmEppI+oDHZxdLL6yfPmGV6Lf1kXffTXKFVMZxjRK8zvcXl30PNABqXKFJgXT936XHSZMw9Q9zjRO2Gy9hQElNNCpobrEF22TfOD70NIDE8A3E4bU5VmUH5fR/SAgLuOmtCZl0Vh+JHd0mvD79R2owfJjf/9Bvy2Hs+Ix1anxsL+QK1o4gY6Eloq1UImBnhKc+ExcPKRniY1Q4/EabV1h/BlO19WQHRba8lENUpwVneMunMlEurxFxZUSlXTE9qGBgZWBGzJUVKnOI6b2tk3TevwRI+maimQS/Iah2Q/aKtWkmB3w7ZVREk9ZxISh2xss963FacuFAOlsSJW0v5bsAElJcA4UiZZIVMWuqxcm+CKVUVNa6iAaFjHCjNxaeCVS+6ibHG7i8EGvLpcv9pSIGfUMRVIxzWyNkDpbbSlhRQHcQEF/Y+7qfZcpmSAkSvVNEgFubf0em4JlJ+UuBcB0kZou1wrqRoJig7JIITRowd1punY0mBQ2evqxIqni/O1QJzXWj/EX+DqaBDZBIgUdtlixyQ3drDw2kx1BFTOkkP6a0aCI0EnjUy/AeHZdenTsq+bu3lT/7nu/KzN/252uGfr2i6gMSHBTEoTULOCz79YpzHgaHA/pfJVnvV61qwtf6X/LgjGgwWAFJwblIWXqitMxMOK9Vau0Ka0mqHY05feXCf5rhd5UFcpMSFVrO47cWBFWgv07+KGLDa2WO2axfIPCsmB3dt4/LwrllPVM8JP8j3ps3pB9Hd6y2LzA2yTp4sefbbagLq2vPANj7yIkmMv8RtnEyTId7okCZEzUsNwzDAGypdTHclBtgTQ3Jc5AjEdTMMomKDbLsixpOCRUoKANoCQGOvKBApIJ0A6SH6N90sLrsLci9gJNRBOsqj5u5yWghwTYkMEFVII3C1UZQXU1uxk47DIZN255ikLTTXN2/2VWpF7RpMxZECyDTnEXKIkNSRGsY79glfCYTaLhWGOdpKWar3yxy5TLoc7ChtvveKbP2bgbLs+A75zpP3yftnXyXntcbAFBqDCwaXys3S2mtTFk8h/mHVxk/ypSje+Vfy3vxkEOQPPxGysSKzPvD40tv2u3H9CsgrvmywoEUv3lnDnaQVKOeqj9agEjOwq/SH1BwIVfNsuaIu35GlKgF1OIMw58sJ0pJQb2LwrFmh+WoIG/vBRAmdY+AlP/+ieTY3QThRSiWEOfNV97zoKbMk3hfD9TbgvsgLTG5ImzgQoSFSNdNcEpq6iAMTQpR2wi8ExIQJv4VoK+N0+gtWvhAbyAH5fIcsJkPVNsjtY0nBDLm4KifPJMg9l7S/aAxciStllxV4ZV0EEyTPNpEp/CmypAxdakVNrjL0Z4FcnTYntEIn2HTJkQJnoDbMG1t1n3LOWDzw097TFSKAgJXqDmIcXbzuoXoJKkwYdWZpF1Abjey84ZT0/OVuOfCmAfL3z9wrswePltkDwslagdcOiohB8IR4rPc7516xBcGqh4nBgaoHSo948E7qf4+WffGBZzxNbUAamGjwuMcUBue6rFoEvz8A5jQ4CNZLz5BWfIhF7DMle+Fg5UEcIF4gjzdAVPoCYsQqCSU/A+5wb5yMNlPkBVkTIAiTmq1840AUBAQnUNvz4j7NdaeteqBZEaBlbx5wvjk+N6gzmHPcOPKRUx5jqieEpHMHieoW4nh4zBzWxkJJtrnoJbI+SzyDE80sXY0DyFyW8xFng3zIHJAnI0gBOXOON60Z0lRvXplwOvA8cL54zimjzfO8bfCRAoy+sn4GqZyT5oRecwgWBlZnfaRgNARYxmhlzE7Zqs+G08nYY2il55v0D6QmySjJnlM7xoWlKPvdfVyOj9wnp2b1kjff9i/y+Ds/Lb071Gd8PZcwNVYlpCsir+A73/mObi+9ZKNfkyZNkk996lNy3XXXRb7nF7/4hfzd3/2dvmfMmDHyla98Ra6//vrM+1oQgxYEpMBaDCNM66QTSLAUksGXPCorFcK25KshDPzk3/0rvwZDcqKthiktaeil4bxgjpJBj8gFZUxZVulZQFwkKZWQVHmQxlmxFiLjL0d06QsGQr9Q0JX+WYLwrA7IG2SVvGjWpiYIRJY0oeTbV1sbbstBs5QHElkArvY/C3aZbSpA5HyzgiedwOdQHdDfDFGrZ67HbrNNRa9JkSOiTGHGRhgwMWnbnP8824o3IqLAa6LKLiO/1+zXCQ1wXrkXIDWzzKXSNYUuBmV8mA1yHClwkTzXyTMNeHad54TTDeB7UMs961pA5yUFDlTZkOYhfUWba6JIkAI+l+ZK3Ot+IsB9YonAiFjNQ5juwJ1TnvEwsy2mw2H/fkg2DmonpwZ0ltf/9Jvy4Dv/r7RuqK+d+h9ad8XBgwfLl7/8ZZ3gMaL70Y9+JDfffLM8/fTTShKCePTRR+Utb3mLfOlLX5Ibb7xRfvrTn8ott9wiTz31lEyebCuE0qIgBi0EGvE8Lcv0oUCgxIPoVpZ+8ODzUIZNBKw4Cesdkle0tp3oApMQeXI255POU8mqyqUmnHAPZFml17MqwbWBjas8SEMM8sLvKOgvRzxV6jMAufLDEoSpMtpMVoHmNh9BQLwYl4sl7eRPqYS5GaaFdbdjMs7Wl2CbsREP9oPzvbvUpthVA5AHXmxuKpfJ4nswxcyNzdm7SJbfCtlOrg+makFcKTVMX/lCSJrVp0vFsf8QKyppENVdZOYn6gxci2b/yt+RjShS4I5XoxMprISrSxKH6/4ShidFMdtcnjtSUA9S4MCCAO2UPyIJSeYYub+IYkGe8uqNLEHknBptoR1H/FudNDL8n/fJpk+2k83tj8tH7/6pfPO6/yMXovjw8GH7jDu0a9dOtyBuuummqr9/8Ytf1AjCY489FkoMbr31Vrn22mvlIx/5iP7985//vNx7773y7W9/W7773e9m2teCGLQAELShDLd16oTWeubqbMSKjkE5zKOe1QBRBlZ1RBeIMbjUhB+UUTEoMgDUx1XRwimSgxEDBsynZIkSl1o8GtAw1KNDZLAFrxOJReXwGYxJN4zyEQSEcJvMukiCgB6CwTY4ceYhZfb6eZmqX3DPfLFUAkmNOwP9YbO/WVdF1+0QC+51slJJQl8zWDtahk1CzgrZNWBCjIZexa/ij8O+kqA3qrNjENg9c+8ANCCkdzD2sV0PO2jXQ/bZVSxE4UjABrlCNuyqNuw5oLICgsdkmZUU0PUQYH6ELoIoIdULWfC8eaZmUsAxbJcXVPCJ6DGoc+LYJsrMuhipkUpyUSP0H2m8E9rvPCsD/n2P7PqzQfLfu9bK4g0r5ZZx+fpGnM8YMqSaKH/605+Wz3zmM7HvaWxs1DTBsWPHZP78cIOt5cuXy4c//OGqf7vmmmvk17/+deZ9LIhBC/U9INeI0I9Wwhb17aDB4M9k7w+Xkh/fLNYataEkGGLwQn3PJsbTlXIPpyaWXrlXJWHlimganiiH7vvJRbKwhs8/m4sYYPZDyRjvtWrzalLlrJbbevGixiwEARLTQdrFuhmmBcQlbaWHm1BQ0tsSyGvKanfIItGDsPOPHqCX6acKclbXD8teLXWr3KsWTC5EfPgMyvggWzYCli4txD6gu0hzD1QU7azoL9Fz7o82EPFYUHIg5DpAjMPSYxUb5L6pSQHYVkojsMrOQwoAjoh0rKRU8imzVGb4fA7SXMOspIB9ITJEZIYFghPscu9TNUBJIePOUBkr2+VFlRaekBOpjbii4CJilahRelFojydPytG798jRa/rKnz/0M5nSb4iM6p7OkOkPJZWwbds26dq1EpUKixY4rFmzRonAyZMnpXPnznLbbbfJxInhfju7du2Sfv2qyTp/59+zoiAGdcTL5kVZXwrn4kiXVQFeC541T2h5Gg89kypaBDoSVjmSyS45JkcqRIEBxOQjCiaQSshTeRAHasmzdm6kFTOGRkyskLKwkLC//C0N0hAEK9E7q6K/KDfDtECTkHbgdkZR7VS5fnVVZAZLYn9/gSBYNfIeRyYRqY4w42VUya3QkSi0LFbQ+IhOODYClnxspMGYqHql0Bf4SYf7fJoZsf/++5F01CJzvVZCMJHSSOkib0HVZ1Hz7yIOaUkBYIKF5MatfONIgcM0b5FaQBPCD3NIrJUUEL5HB4Oro18wCDEkdULaBe0RvhI8pSPEXtMBZqiKRYn4LDLX5Y4aVCpRrKdEHvI7+H+OyAvD28rZcd3l5v/6pjz+ns9Kpzb1qT46HyyRu3btWkUM4jBu3DhZtWqVHDp0SH75y1/KO97xDlmyZEkkOagXCmJQJzihnT+cey5gQ/dLVYvAIE5+eYn8tmq1DUEZIwz4k8sPNxPKvhCigN+6IwqEgKMGKudyRtVA3sqD2OPKmEpYbZZrGDepOyLEII+NczVBWCvbZKMSBDQIlZV+tJthWhB9SOOg6HwRiApBQoNtlTl/VCMkgUmjrxlimxnJetljdugkak2ejR6TJQU4FF6WaC/swL6ladW8z+xWUaQrc0PRTjQAqoUBUBCUFVOCx4TPdzxu7pPZUsnpc0+zr6xm05ICSAyTbFzKIw0pcCDNwgTMCn2NeSzSyMxPCub5bI6r9+20knqIC2LkirYHwSA1J4OVDPjLrbGlhhhiS+2IHiWGk80cFadCEBaa7CJJrou/T0Uao6kweI0iI757UDZ+up0c7N5B/vgX/yy/estfndfmRy2Ftm3byujRVgA9c+ZMWbFihWoJvve97zV7bf/+/WX3btvEyoG/8+9ZURCDOmCTWSu431NmuEAnpfo0Q0oCgwChewarqtB9QtaCiYuSJbYwooCIii2OKDhiwAo6b+VBHPj8NBO4v40wNeP+SSIMrGJr6QhpCcIUGWUmKUHAbthhosyuiRRQyQDiPAw4Xmxv0ZcgWJ0llzU7XkhiFgEjKYSLzQ3yrDxRSi3coRNOxYcAUoDNbvqSQUcM/C2Ig6hEIqpJx7bSqj/KnMjZKDsfATwaaCYESUVrQ6QhLSkArMDjvi8LKXD7N9Ncqjl4JvRW5slm7wmSAhft4buINiAs5jq6ZmKA11JdQzQkmPapJgWYqI0r96pwwP6cKgKqLyCCRGfSwhlZufLUvFbqDq0PN8qQ77wiWz8ySFbIHvnm8jvkrxfcIK9lNJ3jqoTQz2hqklOnKveEH6Qc7r//fvnQhz5U/jfEh1GahDgUxKBGuAec8C+koDbL5PSIL4ejYjb9TRgkCoRoGZjiiIILY0IK8lYexIEVX1JnRfzeWcFQqUEYNU2rbFaiTihYK1jB+bEGK2LTS7s95iGHzpUxqmbf32cDIhjVNtmJ/sLq+OMmM0oP95odskYeL7sm5k2LUXbJe6MiN1aPYVMvTPJ+0xz6M3D/Jk3o+AhsNGuUnFGaC2HjzrHVP15qompLWL3Q6omspCDYW4H7E9JNqfF4b3rVmNGuRAqoItps1sle1QBQ4mmZPc8V1xlSTpvsOMLr9rPirBre0RDHVdI0kA+qINI0D0PUWGkPPitzB8codNx4Ujr+9wty4q1j5RtP3SuXjJggswbUv4LqfCUGH//4x9WzYOjQoXLkyBEtP3zooYfk7rtJE4m8/e1vl0GDBml5IvjLv/xLueSSS+Qb3/iG3HDDDfKzn/1MnnzySfn+97+feV8LYlADXElekPWHoZ7SQ4xYKN2Kaozj/Mryggk+SBQ4zld8RKECT30A4vLZ+SMG0St7q2m4X0Pv/k5+aT63XR1Mk9wETZSIgX26LJbNslYn96XyexliRutElSVc68yNuoWEtPlOBmcmDiYJJsXoz7EVCZ0lvpFOGCgFHGUmqnMegETlSb0wQYU5QQLSFavlUSUFc1ULEhQ9Hk3t/MgESHvt9fKU6nsApCKpfM5/XrmnIWPBa5WXFDjwefPMVbqKp8KilbH3M6RA3SClgzwst5dLc9lvzhkpFKIC7VKSS/aT3geQdfQ9SXbrVBHweqJ9WFAP9LXqDluAoFewpIA0YfRrk4A+Al+Wg7JXjsoRW1Z9n0i3AVdL+ykj5M23fUdWvvtz0q1dfceS8xV79uzRyX/nzp3SrVs3mTp1qpKCq66y2rGtW7dKQ0Plnl2wYIGSh09+8pPyiU98Qv0PqEjI6mEACmKQE2vM43qTU5IXlR9sCZCTJfzKqmKSzFEL1JYGRAG7YDZynnTRcz3joSEY6dBGuLvprWKntG1f48DxRU1Ifk3DRJkVO7AFYVsu54/qWAc56yZJuJ19IPBLA5le3mUqpCOPiwYBn3kc/NLmYhksQZfAhG6/k9XgyVRmSUxkOqHnuCe3mA1VpICI1DK5S/0D0grNmAA4L2EdGV0pb1R6AsEg0aIkbYIfg72RctacUQdLAFlOm9LapQZiRgYEUh61kgIH27L5Km2L7AyU9POlUdM0RBopI8QpMU8azhLGu5UU4NeRRvRroxlXyjL5vT67nUy30IZqttlSpS1zFu0QUYY9sk32y24tH+Xe9S+PEEuikSCydPgXD0mnSaPlZIdW8o5f/ovc9tYPvyb1Bk3nOGLwb//2b7G/J3oQxBvf+EbdakVBDHLANVBhRYbd6LkiBf5SPEyT4gaSvB4AcThmjuhK2VU9IOS7VG7RUC5RBDrOsRE2JQQ6UiakFqsF4YRvQWwz1ngov6bB5O7Y6MRXDJSuEdYT5v4q10NI0WK5Sdsrb5Z1Ogl2Nt3UdTEp1XJSjkU4KN6j5zptZATSlqfXgr8ltLMGJryOdwBh/2FmXGSI2g+XhugfCM3juEiawpowXRFqtftyybQrS9Mn/A8cKQCYiXU0nSMdGf2g2yUY5Pu+epEC9osul+hBXCkhgAyMkAmaIqilb0klinRMz1eatEB5H7y2MstcFlmp4G+2lNSWGW0D4yEbEz0kxd+CmfvJWbtjE432hf4zfD6YePIi6fb9g/LSxzvJk6f3yo9WPyx/clG6Us8LTWNwrlAQgwzwC7+4ufEFP1ekAPX7ZnlOHzLISCcvTnFeX8+EYKRivMxQIsAgwMDGCo2NSQxlO4IrxGdsrU0b6S0DlSRky1NDDFqFOsORe+UcZM17M9iBPHXch0vGRQx4/i6CQddDB9wOh5ox2soGrQYCuQFmmFoVR90zrKo4NgdSOBARJmnSOsO98Yn7ySDNPqapSPDD5erp0sHKE2ElIW1q1BeaazV1xe+x+XathqMAOYSa+ssanV1zkmZBiaW0Sn1t/aZIAGEc0avV8phMMtE9HBywCqbm3y/+y0sKeO9e2a4lk/gKuAoC/yrZNls7qabmtZKCx0qpJRo0Of1CFqDr4BzZboyVSgWiL0QhXLMlv2cH30ukgygZ4kjOk9+llEiQ7fJiey+icwnr8OhPT+g12nxaev56jxx4Q3/5u8d+J4uHT5CR3epnyFYgGwpikBK2S96DOpBgnpLWvKQek7VrmcyENk+uTCVsq2fEwL9Kd3ay241dafnBfjFpslHpAJGBHGDAwtbWtNMVKOmGNMfgIgace1IH1G5bPQduitlX/aysACWNWeA3LqJ2258aYPCMikAwIGKyBKkgcsA1hDSNM4Rlm6c/yLm6lb5fR5KlBHR/RrdBP+FCJ4JJEiJK4FwAKb3FP8BdA/Li2P5GTd7k7P3nuGL6FU8KuM6sNtNWU1iHy6X6/xAqCBGTDCktJk2+EzfCwRGrXWzLSVs46+Q8pID3oB/g2qI5ccJB7lOIFftEVMKdW0gBq3wiMIgTwzoVpvlOCCP7aVNL1f1XsoBU5FFzUNMcLHouMgs1fUAKCbLPPYBnB4sh7Lr9VRLajlvaa8qICCGptaTn+mwgEuG/r/vdeUyOTDooZ8d3lzf+7FZ57L2flTavoX4KxudFkPf95wsKYpDyQcTpCyc3Hvagqcq5iFA4j4I0EYp63oDrzdM68AVX6QyAceSD17F6A5RIUc5JvpEJSK1fjXVupKwquKLguAHfaUsy71cXPprx4IqXN0pzsmQXjegrLWiPjbAtyrgI8WPnBKJB459Fcr0SLKo4SAdtMeuVZDjhnfUeaNIJxd8vIK5JUfRqnYqEeLvioEmSX0CLRsA5HlbbKV9ctl9mRTnJzGlWtsb1YiXonAd3mJc0jw0pwN8jLp3i2iwjrszilIiYjufEaRr4jvnmGp2AESQ2msbQjpLch4C0UBZSwIqXFAGlkn4LcqI0WDjTuZDzSBTGT7hc51ZcJgnfr5AH1c0xi+dJhRQc0f1M25wrDqTEDpuDeu/ggQJZ4n7fJOv0WjtAgCGcnGcIfpbyVXdvoE9yHR6DttaeERn+rwdl42c6yO7OIh+7+6fyjddQP4WmIpVQICjuYbXJQz/Zm3NOTo5/QmSQZfDLMiHWGjHguEkdsAIl1DpXrqqawG0OMd13oDMgxw4Q5+FOeEBe0YgCW0fTRcVX5Ek5RmdbzMRIGRoDCSRikmeJRl7QSwKkMRCqdlIMNy6yBMZo2VkakH4YZEaW/QIY4PuYgSoidT0cwIpSC9s0/QiCwM8BJLXKjRLQckysaqNW7VTAsCLHlIjUABO0f8W6u6QvYKVJVImwPikhJsakCdBpE5jw0pICavH3y179d0LqDnwXKRAmIsgY5CDYzIp7kNQJYtQkUkAEjFQKJYVOeMvkyXniPQNkeNXzudE8q6/3kwKHHl5vmWzmlsyG7pOF5vpUaQW3QHGkIK/2wa+Zsf4lu8v3jeuBQkqA5x4iQEQlzuwsyzjKuSOtGJUWa3OgUQb86BXZ9YFB8vMdz8rrtq6XS4Ymp9DOBZoKYlAgaBjCoFNLyC6vR0G+ASCbj0HYcWORCxlidcAEFRwU7Koi+3eQhoDouHzsFtmo6RlcBNkon0Kg5J8owkoy8yCpgVKYxXSck6LzMWBizeoXQBOaZ2S5plpYpbmwvXPuy2urzOTm1ykkOScGBbSuZLJ7acUfBgSfi8wNaq5FmJwIB0ZLTG6UtLpIyvOyKpMTKLlrVqVtYtJEQVLAOaJsmGna300RENaGHPAMI6okreDEk0RFnLtiFCmgaRQhdlbSTjwIySEagw4jqkoDQrlF1uu9EyQFDkRa6PRJBQjPGhGOJJ8CF7WEJOchBaSnIAKQfY43qIHwo57urY4UOI+FkV7zzoB+9HjqpBxesleOX9JH3nn7v8rKd31WerSvn0dKgWQUqYQIOIEMq1fC3WnU2PWAvz4/a8veauQjBqyMiFQwEMaRoaYayQeDIMMrGwMHPgn0iWfl4lYvYLxMj8wRZ4UtmYqPGGRJ37hJNI9fACv6BXKN5t8Jd0OSQB6XQT8gk1H+AQ5PmYc1rRPmnOjaNeOvFweIEtbErHpJAaA7QOUOyQMVUkCkoEOq543IUFyZYhgpsD4Eh/UahF0nSMYCc51OTKzgiRyM96aVHSu5zkxYkAJEtZRTch9CUtzECVnhPmVSIy2UJspkScG1sZGAYd44OWGOa6qO1AKunXG+GRwnUcs0kTMnEsS8Cd8ASL7TP/Dc8gzYaMBgvVb8XsmO9NdoEGmOPLbJYftBZMxVTiR5LDgM+dkReX5sBzk9oLO87b+/Lb//Px991UsYm4qIwYUNVuyufre2yTkbCLMzKVmPgmRFdRy8GtsVIwyKa22bN2IQBgYfBg02V33hwKRJnpo6am1fXQOccCpqsMuavkFkB7Bizguu8XFzTEsbXYoG/wP6MmQFkyv3TtT++PtqMClgAhRup+ylEsXZ6Mf8sjiVla8DUQuIT1oHSI4Z9Pd1C01qtOSPKvm7jAbB5AyJITKA/XGTltfZyAakAFIBGX1QbitPnqQAiFwNl7GpV85ZSIED1QSE9Cn1o99H0L3TWX4TnYKcRKUyeR2fYQ2E9pfcHy2IQNFTo9wsrfQc2SiEnbQRMbpyR6ppMGGiosalAPPAERqX+shSOdFw2siw7x2QzZ/sIKvlgHxv5QPy/826Ql5NNBXE4MKF8wQnzJg0OdYTTqTlXNtqMQnK43zo8sF8PxNiUitVKz6sb6mmC9+7JjijZYoOdKxCGRwRLPJveX3aWZFGkRnr8Ia9cvr0jROekYvNC1cRADhuVqeEr3ebl/U+yFKSSRoCINKMq6qJs1MOVhSk1U50M710ErDwMpECgOYCBNMBzUmBbbTkgHV3UF8QhlZeKw3XMxHahmFhKSHEg0NkqIzOXPWShxQ40IGRZlBEXjaa1eVVtbtmkBZW9lO8uVUkFj0H6SCuqdPl6LFqg6Ue2mIJIhBW2lyJQjQXMWKSxCKBz0Z8i4FUVvD5REEsoRmcK/XRYdtp6fU/e2T//x4gX3jqLrl81GQZ2yOb5qZAPhSphNCWotlKxGoF5UAogHmgrUdBvjCyH1lW88673XokXJ7q+5m4XcvlWuGftAiDk28n1MsENtwbp2SNyAGrPELX681TOngPlwmZQp1RDZT8xk0Io5JyoA6sNoOGRHmIEGFdBnaqJRABapRENqttLc2a0uorCBmH9UhIW1XjKgrCHAuTQGqiAqMCy2kmvWAWdzzOQ/D1caQgzIcgjeMfkQEHJtCBMkInx7zX8cUSKWibgxQ4kEbA6wJSCAGG6LhngsjFeJmmrpQ8AxAFv2ES0RlrHjRAiUASIfNHIUhNhE3aeLSQHuJeRGyaNbVF5BMvB57lqO6SadD33uNyZNIBOTO5h7zx57fKE+/9nLRr9epMW8Z4utXy/vMF58ad5zwAjUUINbqWoueKFFAuBilAHb1QrqsLKUhbsKj5dPNIuaHLQrk+9fcnlStmCX9TeWAHwIGa028sDXpu5Uool1XVpXKz5kEJtxPfeFB+Lc+aFWXjoiSclbPNiAEGOc5EiAYxaUmB7ruczNWQSUP65mElBYSxycNz3yGKZHKa6M2U2Yj5pI2Wiz1q7laL2SRYbYZXFfp2ZXguPx1Xaus6ImZpvgQoYcRtEGjzI+mjAjd1iTQV85s4Qs7xBwlJEinAdMvvQ5AEFzoH7j7g/LMizk8KSH1ZUrAgJynQ/fEaZD6VP9JG0zJoIngmiCLtl12yVG7X4D6aCHQoXCMWLziPXurdLLO8S1WzkIYUUAproxCDIlMTHAeeJTzpvN6VEKcBYwr7qek4b6HUAkoYh/3wkMiRU7KvXZN8+I7/lFcLTeLVvJ0vKIhBqRMcK0YmHHJqtbYUTR1qM0s1rEkIc4FUW5LWiqRJmwGbgZvwczfpJQvl2shOeFl7GWRRSePXjihwmIzXSYsB8kyJGAR7GjBYkQeFIJDmIeyOcdJS+a2sNEtU6R+HJjmrrXn9bnyEOzkajIiyNohh1ZbVXtmt1lhhs8ojQoRxDPBrA8ihY61MGJYcLedpq9kY+9kn5HjV/ti68btKivsRiaW2dDUEYV0G46JdkBd3rTiGmd4lugK3+32HRnzigPgumA5g0nekgNV0mJe/34cgCUGfAu4hnjueP9I5eeD0MLWSAmf8s11eKjcjc2ZcEB/OrTbOknlyufwvWezdJNM97teRmb8Tjcnh0ko+qRsp96D2R5HTGgFIg2fMch1T1HMkswlcONocapSBP7TRsN+8skHu3lSxvy7QMihSCfqwPFyX3H4cnKgpKHKLKgdsSWJgPf/v0we+lnroWjQGtPfFDTCsEZILk0adE/6dLnJsNFSiTp0VCtoQPBEgDWEaCdtAyZbybTHP6/tYObI6z+NAR+VIlq6S9rpTh360KqR/wNgwPI2Ygsc5RebJILNH+xVQzkkVA50cw0gcGgo86d134TAH6SLKksZHnxVqXKvksBC6Wy1zzknzcFyAe4p+BUQSEPLOMpdGKvoJj3O/di8JCiEFTET8G6Qg6n1ccyJtaVbJYSWJdD50XQYbTGsZk7JDZz1IgRML4piI4JNrF/Z8LZYbY8s3s4CFCN9Fii7tSn6EN172m916rokMxaW1SI1RXQM5xIisXsAa/NAzG+XMfYekzZWT5N0/+Lqs/vS/SM9zXMLYVIgPLzz4lc4tB69K5FYP05647woDtdkrZYmuRPBBJ/yYB7VEDFwHP1ev392rnhAtMUgXdoMAUGJFtGC9rNKac4yZsF+mAM2ZJrl9xq/e33MBi9489douRJ7WLMmWv9qulMEOiYdj2i0DyOol5nVKpJhMyP1OMDOqyJRdlduKBNsAx9raEolJO+FhAJXWk6HSW8FOjOtkhf47x+aAiQ3kYLU8rvbOUw0ujs3D/vj9s3oPkgL0LlFNuIg2uUZPcYhzNLRtka8ulTKul9amVSo9x6acpIBSZKIjrKhdRABwH5IaIN2DJTQTN8eFGJjoEvtY68LhaUMJ7h7pIX0jhadRYOHCPUdkqKfpGzpOPmdWamoMjRBkLs/+8kwRSSMNRSnwcTlWIkylRdUv1krP7q2kw6zx8t5ffU/+560flnMJcwFpDIqIgcLT2l26AvKHVRMPq9vsn7Y6qTAYkPu2PztkWikwGSMwsh4FE2WkN7HFLmzYLeg86xl0p8oC6evZ1V0+5KtKcBa8hEfpeRA2KTPgN2TMx6GNoNsik+JGeUbb6bLCZsU60AxXkyTAgMPg47cAzgPnteAmtLRdGcM6JKIM51zG7QsD7TRZqHX2CPuoYKGShQoS3ucqEjpLd23xy3dlMYZiVcb9SVoprVjV7+oH4eSpCa7esXOebTrJSnlQic0YU01GUb9D2Aht07uA55BzMUejONGeAa6FMR4jUUhjc8y+U63AOWPiYwwIs0/2k4JNKUmBTQ9slt2yXYV+zhcBQg2BY/InfdLWaydPmaVKCnr6Ju5DZr8+K7WWDdINdl8pdTUzR3ife4+ID6ZrpCIuNjdVHTf3A8cJqUxj28514Xxwzx6UfUqIIMz+joyMYIy6iEOJgkES9p/ZLafvWC3tZ4yVx0/tkdtfWCWL+54bLdiFhoIYlMrNrFM9nc9O6QCJgU8qEV/pJUy2DGj2D+TC0gv7p0255h1SUE/TnrSpBGvRur4UOmcllt2Up5aIga2hX6IDAZMpufWoQRVikDdNQRgcD4gJZibZY/W0Z5Xm8tg23N7c2CcrjpaIQecEMyEqHqgI4N6KKn+luqFtSq0CK+7F5iZtaER4d6n8Tiab2XJA9unvaT/M+cMHIW6CCwIipZ+fsAKvNFzqqO54XENnoxxVzYA+AB8BzgORIsSGLmLiyg1ZaaYlBYBJhecrSi2fpfcBxzCvRA5IL7UyrUNL9Gz1UDQpcOkBJnOmPX96ACJKJAAiEEyNsJpnlcz58+fl2WdE0YhCN5v1GtbPCrwR2Ce6HZIqzQuI9wQzXaMYVEsQaXNlmpBER7SDzxQR0r1KAPYqmYb8+CsqAIsxOjLyLEFeIIn+Ml2OnY6VENE5L02XHXfvlSPX9ZO/uOcnsuSNfyPnCk1FKuHCAr3hW3vhNrI87OTiGbxP6Z+Tcka30+UNtTtKen4yAfCHf2ewZAL16wsAJUAbzDOaH4Vls3rACJjVQi0Cpmp45f1nxcHgYu1903VnTIO0xIBVPLl1Gybtr6ufuEmZ81ersJHP19JDmSDbzUvauMghyRkwDRzRg2REwTZDsmmbOMMqBsos+8Q9QutjIkDrZKW2GHZEClKQh3i6ckPX/CgMlIkyQDMJECnAGwDgrpdEKmzvgutLNsqblRwQoobcAFIRlhRcnqj3oEKDJ9LZSAeRp0uidXK8RpbJXdo0q5VpVXW9XEkxz6yfFJDSsOmB3c3SA6S4MGzivETd7yj4K6v55nl5SLwN4z8rXU136ZXgLxLM+eONwPhCqrTWdARix1fMbtURECUgiuq8G+ilwrVEj0BqDP2UXWSZQDfGdro/EBWIUlIPhm3mRT12vot7jtcO/M0xeX76UTndv7P8zR0/lnMFU6QSCjhwI7JCYMvW4b66D70DKzlWE0wsTJQ8TGywbuCZhroQBh5CcnbkKAnV1WOVHESYJ0AQ5P7JLzNhIRbEPCUJkKs8ZYBRIXJSCw4MMAi+WCGPMOMyeyGUP7c0CUTpE2xYfJn+f5xhlFPs57FVZuLqZQZoZQXXGIyQCbmiUVRGcG6izgX9CPBWILrmBmgHTKh0fxKaH9mV+dVly2nnnw/SkgJAkgggqqwHKXCAMM8vaQ5IuRE5IEKD6M6RgtlyhbonktLhnPnTAzxjiC8HyahUAk4b4i8p+CNW89Z74QoVSdL6m94PaTQxpOxqzfmHYYrMlUfkjvJ4BVgCLZHfVL0OYsR3M4ZxViBJWRckEN8N8nTJWrtCxhrOGBn87wdk6992kodP2Eqac0UMmgqNQYFa4dwEmUAJg0EEwsK7iJIYIDAEYYBnsIwiDAzMDEAwbZzN4sLx6BkQoFF+5ndNqxeSwv1MjvSdZ9WQxTCKRE7bOhAD/4odQ1j0BURM9ske9Yfn6myVF2ScmZbZftqaGzXEksE0zZDYlyi3wnT7cawcvQCI4tqYtpkcO5lMuU+4p+J0If4ujH5Q/ob+Jq3JENEORzRARWiYrjKEVTDnNth5shZS4MCkO9dcpZoQNBH9zZBymoVIFuWXwfQAnUGTUh9hTawI8dOdMamVOG2kLzILVVT7uNwvF5sbYl+PENCVQadt1R4FUgGcb9eBkYip68BY6bvAqNRF9SlEcRihaiUiVC1Bzly77iDR6vzCaenywF45vLC2lGiBcBQagxaCU9677nKUm0WBPGlYrhrCQIjXCXSYjCg3YqsmDG3VHMexc0DOsp6dCf1wZifkBqNAzT3iPwZwRIF05EsLW7td261ZidR4mrpgoIQYEPnBr2CAGar9CV6S53UAovyMcH/a/SRMGraP7rgZ0EhRJRlGQQlBD8lu9WorTKwPg6sIoAkS309IF4FpmgHa9kcgjdAn0p2RSYa8cvMcMqm0M5Fh/SgQXq8QA2sFnQZEwYjWBEWS9SAFDuzLABmqKQ9HCtx+svKlmgg3wryTH7X+pPYg+DgMpvkcIk64YCKQxHAIIhWlAWG/GQ/CrlccuJbsF4sUSwKOVwkCuacZz0itOnAMs73wfckLjK0YLznfcVVDg351VA6PS+4kWi8YjRrU9v7zBQUxaAG4GmeU9wuU7bYXk+OOcoSBEHwwPA+DJ8KAutdPGJzpC4DHE2Vg0KxnCsENFlE6gOfMU9qOl3AiIsMsfv+ACEMtqYSXzHqtRvB7FPBvfvtifmLeMsyM15wykx9lnLR9xjsgaZ+ZDIOlipXrnr4M0pob4VaYLcxqy/oQ61mnQgbzoTJWxshFqhzHG4CQ7xxzeeJ+uD4FQWOjNeZxTRPEdZncWZrccVVMi1fMTo0kAaYaVuJ4Hcw1V4b6+vvBfRUsi6wHKUDzgFB1r+wspzf84D5O6qyYBqsNeh+X98+W2oPgU6lApIGogL/kFdBngeffakDiSxwhWOwH4wiaAKKZ/jbMDSVBIBM/9xcpEhYpRFH4Hb0w0LfwbzTRol9GPXDIHKgqV417DhtOGRn404OyU84NmkoS81ref76gIAZ1hivlssplVNv1MSfxg1VomFjNfTfgBmZlRSqDrZ3poFoF6vpr7VKIyBIEeyX4WxZDShAk5RVTOiOirGDAZMXEqo/vdy1/yYOGaSLYv8kyR8aYqRphYN/J5/Y2A2SyzI68fgyi/mZDTpjHdSfcntYkiGuUNTqyR82hWFF5KipDzMr/u0mVAdU19SGdNNnMkX4xbp5EpOz7u1ap2Qkho31gUoyaZPaU3BLT2hL7SYHTJZDC4NwTviefHlcxgz7ET0RqIQWkmih7JLpWNtXC4EnalSJCbVXIyb5BthaZ62p6niFakDDOad68P90s0UBwj3c1vcpunVxvjoVkYzDdAwmgATNkERLAPVdNAhpU1URNQM8SCQjevxiJOVLgSO80s1CWyG9lgzwjfczAXH4gwQgpFQ8sobiv06SWumyoNI8qUD8UxKCOcLnYWmvk88C/SmeQ6ydDdVBjIHUdCvl/NtIPRCJsHXU6oZQfrpcBRZn+wce1cE3TsjjJOCiP1TA5WAZ5cuFz5Mqq80/4My4K0c5rr7lvysOYCFiVLZHfySAzQsbKtKpjOVPqzeC6KrpJNA8ZonqF/Gxa7DJb1ceAwRwhHJMoq10IiR94JWBGwzlZI4/LPrNHezCEAYMhv4Mj+W9CyqxqkyYwyjZ5b5prTd7YhYjRVEDChss4nVCoAuB3VC1QMx+my7D174fLOeyspMCWE+6QbbJJBcBucuSZgTIPkzGyX/aWVPD0LsGjoa1eb0Rwy+U+Ff/lua9JyfAcJhGtJPC+ueYKeVju0EqbLqab3quuOoBJm2cAAkYikucRvZED5x5NAH4X1kgJEhAfrcJrAjJnBaKVCKB6a5iFGmljo9dLXiDCxQ2WNCL25M4F87UEU1QlFMgKNzlE5WJbCgx21LQTEuRxZyCndwAGQUxQQ2SUbq6mntIq16GNjZwlYjVytgyu5IoTDUrKEQO7Amdi4qGGkBCRyNJ3PQhKPLMSgzQW04SrO6RoJ8wqBdU9AyuhUqIAO2SL5nedcNSZGxFqpUcDE1yaSTRsvxkI05gkBcWs3GMM0Fx/2xGxd6hj4iJzo1amkM8/aF7R8LWfCGLCw7npWSq7XGUe0fuDcrKkEjcGc97bJ0U3xkqUo0HTEqwMmZDdKrOPN1BmmMVqT04Ofbq5uJk9Oc8XiSaiBWlJAa/jnocQk3Zz5XOQGVbG9FlA3Ofq5V1pHKFyFx0Y4o2SE5pq2Kj7zeSYBWvNinKFQC2kwIH9gjwhROTaumOixwgreAeiQBwnzwRknYVA1lU9URWiJbZnxWXNfCPQ5GAgxoKIiGWaqqMwgSN25tzJVD1kKck8l2gynng1VCXUUtFwrlFEDOoADEqYmPNMDrXA306XcCwlT5UQYfObkFDzOJmmXnF+MxZCyfw/G+/raDppXpFysLAcXyWV0EqFQuS6meD47FpzjS6/G2ygFPn6ksU0qvrYCUIaNUScFr29AepTj5gQvQLGNy+ZDVpd4UoVidCwv3kjJE701y3GCyEoanRiVjfA22uGeDHcfwASQIMsJicmx0fk9zLdLCqLLHHl0+OVAeX7GJJI9CTpeCBNgPOehhQQ5SCSg64AEhlMP0AEmPAQVDIZsRrlOlS+z5pUUQUQRwoQ0aEXQIhJNMQBAgapGCqjmqUE0KBU6uWvbdafgAmP0lciKYgHL0poQOSPInLeO9WhQgAiuVu2qg7C2mhXO6Sw70QkEJESAXGEJy+OmENK0vgO7ocojcV4maFkEuLU3wzNpMXgWqEvsd1NZ8amvAqcOxTEoNYOibJEw5JuYj5XpCCq58JZY8P8SSIZ9pOB2Q3OPKDb5UVdlRGuRcTERoiXUj9oAmYtRCFYJQKOm8GU7yL8Vw+m7yIGwdB41MDFiolJP676wlVRZGl45EDZ32AzSokBExN5VteUFFJAsVrefvOVaoD4xl3U0dsOhm10JesP/TpiwH7EgfuD1AJWytyzI80EbTHt3k8wmv3Jch87IhnleAio97e5aUsKWHGix4jqikgIGZ0B3heEr6eYueXJgtA415BrHiQFRMOoemeCcvcQ0QmmSV6HliHqmJxY1ZGCqNQaTa8eN/epaA+h3xhvauz5qS4bzB5FhIhAKiBrRDv8KYEg8Q/236gVnE8b2qfz6MXSI9DPpFkJqlmsq340RhebG1Mdq+3weo+SRPxdBnkVQelrEcbUWJVwHpUlFMQgJ5hseHB4YClhmuYtknMFRDor5P7QnguuYiCrpTCDIeY4bC6EyIqQfKWreEDk1taQoaysVlnBEh5NUpOnBUQHtEtY3SOGIoXCwDVJ5sgAL1oV7+r80zY8CoJBjmjIKDNZ1ghtZXeXP4/vzgvKJ0GnGHMj16yInDcpjuCkRWWK5o1ThIjxauhmemk4nKTEfrO3vKLm+jLBh7nvxZ3XjtJJPM9LJAWslp24kRUv0aYofwfSOfPMlRoqRx9x1jTq93BvO8tyO9kPUz0EqRwnHuR+dNGuKFOpYFlxGlLgQEQQQSdCv/amk6YZwgD5cf0D0qQWGU+4lqy7uRZcF3+pIESZ69NHBigRRvAHUSR6xKqe70IA6I+w5AUpIiKRnGdKfYN+EWHg2o40k2STrFWNDiLJpON1TcVwJ81i3/1qwRQagwJx8Oc3W8o8KK5MDUGZnRCb2+w685GsTYiCYNB2teIcLytKaroJYTKAOZCnpdlJveCIQVzE4GXzYkmJb81y4lYzwLkCosGobd9OatrFgRIvcrpTzLxUk1AQ3D/aVyNi0lhvntYohb9ZURCkNfzVEUkgNbTI3KCrcWeDDDDLmpGh6x4iTe413peFFKBpINISF2UAvB4XQqJiiOyc0JPvJBXBBMpqHECaSBEQgcjSPtt5jaQlBZWOjFdpKSiCxA6mU7Nrb6/bJt3nMEMo90yR6iD6wPOEcZCrdOe+hnwTvSESRJrIfQZugOhMIEDz5BoVzc42l6kY8RlZLheb62uyPD/py/dPlrmq/UiLkd4E2W22adQRoWnUe20K9F59fijFJnJV4LWFImKQEbbPvbVyzRq+q1V64sRncaZBlYhB/YQuDEo0f+lnhqpqnAlN/700QKsBjumiCnMG6FrSKa7xDJZNYSCEy2qNgZEJJ41HglsVZ1H/B3HYHNCVNufXibpYldK0CKLWy/STKTI/U0UCRCNqUneagLhKB+5FBnC0LVng1OR48LvzjSI/Cyp+AiMTSMFVVdGkrT6dQBLIkc8318pjcndVHwIiZURrSIMxseQpk9tinldS0DoDKXBAf4DnAhMoUStbYtm9bDAEmXP9JNyzgBZml2wpCX8PVZkEcS9TKojJFcZKUY2hmHT9boDO+wIiQMqFc070gF4OeWBbg7t8/yzpnyPfz7gESSHSQ7OvsEZTPEdEm4j45BErvlowRcSgQNyDw5qH1UlSjrGecHXpSaH7il1pfbUO5DsJLxKyJWdKBYATO5L/Rm9A/hqzoF6mv+YMsxobVRODthGOcdtLtdpXNROIRe57aVLBGzIPKtbOoqFVyuoY+Al/4qDI70gv0Olwokk3oNpqAkLknSOP0wrWosPQvAZQdpYFfDd5eneuIToISLGGTisexcoZghr0HNhjXtamTtb5sblhEeI5vg/nwDTgPmBF71IFHGtWAhZOClaXDMiykQIH7u2Z5hKd5FbIg7LAXCdbZUPZYAh1PaQRcS5E2u8bQISDSItrspTm+xFwMtn6fQT8oKfDADNcI3uULk/wZmQ6HiI5y+UuPc90AXX+CFkBSZloZiqBQW9AJYMf3GdEHYk0Ol1UVkCID8krOuYcKqXjzgWaiqqEAkHA+IkU8OCMlEkaNjtXcA50totZvHlOJZVQP1DHTBkZn82gQdiTvDc5zs5eLxXPMdnQw/Bl2azKbe3maDrqyhASlTaKUDaa8b3eTWSUCeZpBlWudMgxARC6ZZBzfQ/IdfujDwyEELUdBtr2lOZXcYK7SBbGXieX3qCePG+Fi9M6pDUXCmpjbFTJ09Un/7ZBVqnoLKnclM+AbAVtvFnRuskrjBTwPlaKKOfTXD+XsuO7UA2w2uaYMQlKqoSIq+6wpKBNblLgF0pONnP1mi+T35drBAiRQxaAiy6RliMtkKYcOAhrLmSrOuKiZFTM0N6YaE4fMyC13oCJ9lG5R4kibqBZ+myEgfQmzw36JLojOh2G1YPQXrqvCjmTrj0EwrVr5r5h3CHSEuxWe65gCvFhAT9OmOM6QBFiY2LM8+DkuZlt1cNDmoNMa4ySV3yYnL7wyl0CyaEGSwptm+NJulEt8KKs0VUlVQsIkrqb3jJaJsc2FKqYJ3lVURrykUzurDLTlon5wYCS53y4HLS/7wGTH6BSw4+B3nDpawZraBkxHGH6seaiSHGa62Xh/Ae41pToZakMQKXPZJE2p+xyuwyypHwgm0QsnO6A3xEGP26OxJZf2lbJpqo/gp8UOI+FIFx7ZkLIafa1UpI4Qs2ZEMVBzolMtdbOh/GVGFEln5YUXFcTKThiDpTFuf7nm/sM0ghZ5hzXaqNMxIFUlTMXihP5cr1mmctU/0BaAQ+LpGP0iwBHyHgZ4Y2XegBiTASNZmWQFKKKrj8EFUzuu7kXmfwhAa7jLATF36gJMP4w3uAFwfl1nWe5f/meAvVFoTFIAH0JUEcTCiTvljfElhWulIcHhQF4mrcw1fuaygNU7RoDZ7Fs0xeXlwVkrmwqLNwPCC8zsfDgY6yzRTbqZMIqCjMlJgYIRGjeXM6W9x3jJNIXfF8tqRsGmriGT3HHzmA0z5fPtfXjdENsLnjkeBBDEvZdK4+rOA2hJANhMPRb+Zw+VRER1pXTU4oAT8qJ1JUW/omW808kB20I4Wy37/PNNRr+ZbIjf04ePewaOdGf0wmkIQX2fZsjdQlJpABwDmnbzL6RrphmottZx5OC7JECRHmU8zK5MYEFJy4HIht5Q+RBHDCvaKTO9g3AXCi5k2C7Kr3Bg1remnSenQhwlDdZ6oVWXiu5yCxQssv14hmGxEJwsBw/bU5VpVcsmPxbW7Kqib9uGmnpJr0jU0euPPvcRQy8mt5/vqAgBgmCMyYzBgFyhufKfIOVEWpswuoI3MZ501K/1w1YNTX78LkpMvFQf+4fSB0xSFrR8nucENk4phd01fCyTrhsNCyi3NKvXnYDiD99gYHK4JQtm8PAeczipOhSN2HW1rbpEWY50fqJvt5A6W1uljVCw5wd8ojcKaPMxCqfBVIJDJL8cat4UgJTU0ZEiKRY4WGPVNeTlTYheTfRYrwD+HuwJbLrN4EZEuQgaJRDVAOixUTtulgmkQJHhhBTxukDokiBA/uCJfBjcp+upMnzJ3XErCYFlHy2S0XMIU7OTrziIeBpOomeAkYa9TzZvijXajoGwWh37WGQ/36tOA4u0aeY1FmWts5WbzBM9yVKb+BSSpxnRNT1EAHyjJPuoXIHq2wIB3DnjmgmugAWGhQ9UyVEOorJH4JcSwTnXMAU4sMCdmJaqutvF0I/F2BAwICGhyhP2sLUmEqw9sK28gA39bBe8c2ZfjKYRGhKRCU4qnW6ELJCRsjXirCwdm2YooI8jp1z4E9f1AI+Lw0x8DeBikrdMLnGlRg68HuEitxHHCOhVHQImMUweZIaYXXkJmy/SVUaQLCAW/GniTyxwh9fmiQ4RkhJWGiaSptOpqtOprjSzTAXlydfzhH7zmCehRQQEufejNNDJJECByJXc8xlaoLEMxrVWyGcFLSP/G4iJWodLfvKJkmAiR9vBHQNpAi4ts50CjdNSAFkh+oEUkik3rqYHrnTCKQp/I6DeZqe4SJ4oKw3wN+gf7PKAHQmpDuyGiMRPaGbJwJAnmEb/mflXlkSO/2KH2hmam3gdiHhS1/6kvzqV7+S9evXS4cOHWTBggXyla98RcaNw7s2HP/xH/8h73znO6v+rV27dnLyZOV+ToMiYhAh9rFNQ2z5TdKKpF6wZV6P6f9PlQW68syKSq7Tq6nyIM5e2Dkf5gUrGiYIlNAoGFxzJ9c5DzDZkL5IEz5NAhNSkpOiX5SHOIrwf9jkz4SRJfrAvUPZFsJEQvCEUYeaMeWKAH7m6S/hhIdx6n5/aS2hYrcqtOLB4xqqjQKElBJUIkeQtAnGptFsvwI7WaYlBcB1/RwS4naYhRQ4sIKeaS7VCfRJWRLalTGJFBw1h1QnwLm0lSv22WFFyz3QXwZrM7JghMP2VFir1QWOFAB+2h4G96k2CN1G2soZ/z49oVFKozqTJI+OeL0BZkzoDR6t0htAfl1lwGRvTqy7qo0AvKLPBfeMvW+rCQDPA7beCGltX4Z+2qxKtSDSRruXMp4+Jyv1Xqkn3HNwLmCqjjzf+7NgyZIl8oEPfEBmz54tZ8+elU984hNy9dVXy7p166RTp2i7665du8qGDRvKf48yIItDQQwCcPlSVtyU2tSjB3sFXmIJFQMtzWvyfq8TH7IazAJ/6J5SwzgnMiIG9dAwUCVAVITtoNmnoeGKg10rrfdm5V4LCLkDQpfxE+g9ckqO6woqbrBEAxHW8jppkJ4os2SIGSVPy7LyJAmGyXgZkyO3y0qNeyU698ox3aXCy6A+w1oxG10Fx4FV5lxzleofMBk6bg6XXSRZi7p6+jSe/KxemUidVqMWUuCvCqDvAxMdTqDsq4uAUBkSJAVMdMSqIDekcvxCXUgSroIDZVToPvoFqa6ngu2+WG3uhZ8BJIrzxXlDE5G2CqFiQ2w7DAabSGUFxzHFzNHFhtMb0CSLa9HTVxnAM0IEABGgJQDHSgLAagKA3ga/BUsAeqseJiwCg8YGUsAzjAkT+0Ebc5xSt5uX6qbTIrpKuu4PNZVw1113NYsG9O3bV1auXCmLFy+OfB9EoH//2qKsBTHwgZuWB9qvQj8XwD6VlYsVul1ZU1/zPBqD7YbA/spS6L66cU10xKB+BkpMDBvlmTIpcK2j18oTstE8o0Ql6PCYFsfkULkTYlRY1Pq1n65aVUeTDJPbKIlV7hxzpTwit5f/Lcn6OU54GKVzIBJD+RnRjeEyXlsw+0G3yLQmQ5jtLDTXqw4CYymHLKQAAS95Zlao9SIFDtj1TjULdFXMSn2BuUZ1HZRech9h8U2bavRC7v4CaB2YHDkHafP3ttSxYooUVf7KxMekRVoijT2wX2gLWSFaWK8Og1RuOL3BI+YODfsTEeEZXmowuMJi2r+WJQLQRlX/kHKEfxDIOLIUTBlVSiuvKr8PF0WqBzbIU9LPDK65JT33FJGi8xGHD1udkj/Uz5aEQ4fsWNazZ3w65ujRozJs2DBpamqSGTNmyN///d/LpEnZ3CULYhDSvQ7BWYcaJud8LZOjHe4yfaavbCpr5QE5wCjXtervsO5/9YC/HJHqC1YV5K+nyDwlC4Tf8RHQpjU5CAJGTKBTyCTqrzhJipL4mx7ljWLYwf/e8t+ZuLjnaPGcpTsjIi8IIA2Cws4n6QMGfDzow+xmWRkysacloNqh0VwnyzQCYQVl1NOn7d7nCEWwaVKtpMCBlNtkM0cJAPvoyDFEgCgcIFoBMaGZErqMrF4CWasaOJbDBtXCdo0Gxt1bTmzs2g7nSSGGfSbfzR64NuF+MSAiQAgO9zIbeiJLAPKPe5AvojeMDYwl/vQS49oEM0OfZfqNoLWp5dh4brnOU2VeOf16vuQShgypFrF/+tOfls985jOxb2WS/9CHPiQLFy6UyZOjI4zoD374wx/K1KlTlUh8/etfV23C2rVrZfDg9OW9LdIKcPv27fLHf/zH0qtXLxVNTJkyRZ580qqggTFGPvWpT8mAAQP091deeaVs3FgJr4L9+/fL2972Ns2XdO/eXd797ncrE/Jj9erVcvHFF0v79u31ZH/1q1/Ntb8vyYbyQ0+L2nNFClghQAoofYvyws+KtOJDFdqZR5QUYMCyUK5PRQrcd9SDGBA6JQfqcuCsKgCCLh1IPKRXN6tqmtAmg8pS8zvZaWy5XBo4++aOgfA/qQuU7QzG9JxI08QF3wC/90DWxlcM/qzUuM9YUS2Wm/TaM3izmiK/nAYuzx8UHlpScJeSArpNhpECrjsTRNCcKAmo8x0pAMgSXdfKJJCnhnj6+xjUixRoSax5SbaVrJYrBl8Nem5pfnWp3CKXeDdp6JxJNyspoOS0Oi2RTjdANQHvgZxQehgG681wT/k+zFP5xH2DGPIp87A8bH4v95v/US8DJZ2ys2zw5QCxudL7I7nUe53M9a5U0StVFLWQAp5lW8ElKlgO61kBqScSwZhHZCG/+6wlUTQwi+rV0SIwNpWQd+P9YNu2bTppu+3jH/944lejNXj22WflZz/7Wezr5s+fL29/+9tl2rRpcskll6h4sU+fPvK9730v06HWnRgcOHBAWU2bNm3kzjvvVKHEN77xDenRoxKuYwL/1re+Jd/97nfl8ccfVyHFNddcU6WchBTAcu699165/fbbZenSpfK+972vKhyDEIOQCTmXr33ta8q6vv/972feZzzrrLr4upoakKQFuU4eXPKcWKLO8i6tW7vmNE2UrFL9Xs0rsjpfmNHspR4RA5pBOdMoHNsI4Z8sWRf7hYKOIDC4U/9uCcKTssT8TieEJLhVkj/sTg6UnCtni1xu2igE+dekbohhOGT2l8LEjRpW5vxBxlQg5l2qbnOsbrkmrC6T4Ex1KJnz31OPyp16fjCSimpB7RonhYX1o8B5hpQBrjsVFERiEFJyL8WB/SKl4fd9qJUU8J1MhMvNPfKA/Erz2ayA/SB1hHgPi+daCDcGXzTsgtjEVTWEge9Fp2Qtpx/Wc+EHf3c1/nikJN2H2oHR7FN79CfNQ0qS7zP/o/cNYkiuLfcRGhjOK/eai9JQejtapuj/QxjqCX83xmmyIFYwac2NPPVZSEssw9o0o0uK66jaks6HpoYNsNj1b0lphA9+8IM6Bz744IOZVv2AeXj69OnywgsvvLqpBMopWL3/+7//e/nfRowYURUt+Md//Ef55Cc/KTfffLP+249//GPp16+f/PrXv5Y3v/nN8txzz6nwYsWKFTJrllXG/9M//ZNcf/31GhoZOHCg/OQnP5HTp09r2KRt27aaQ1m1apV885vfrCIQaWC7q12TWUGcDaYcvn6i3DI5PNRb27fEpxL8HglxlQdxYGLLKm4M747o6eDtRFZuEg9rLIRhCgQCP3/c1BCRMSHQlniMTFHnwTDYrnUVzwXn5Mj+s6LLIvK0pYoNmUgcKyMmBVMaFMnZQhD86Qjc5nqbfrJSlurqktQCodao70GUyUTlJjyrk7B23Uklrk5fMMDnX5BECjjPHDfXnUmHFWZr00b7AkAOyOsHRXgOW8UOSENkVE2kgPuWyB76AbcC5v7hPDLpuRbgRPzQAZBTRwk/o4aQtdUc2U6GttFS9kUDOqVJmuZ4XMsrF5hr9bqy8qUUFFIwXqY3E+RxnrAPJtqC8ynny994CVgxYA9NKRE98ndhdNUTpHEg2s6PY5fZqucqrvthFtgolYt4zEnUJ3EOR5oJsknWqQEYZZVpYKuG7is7NNZq23w+wBgjf/7nfy633XabPPTQQ1XzaFo0NjbKmjVrdO58VYnBb3/7W139v/GNb9Ryi0GDBsn73/9+ee9736u/37x5s+zatUvTBw7dunWTuXPnyvLly5UY8JP0gSMFgNc3NDRohOH1r3+9vgZlJqTAge+FmBC18EcoHE6dOqVbUATCKov2uXZOZUplyFHNtyprdRBWSU7b8sbDxgTGyo+NwSnZrrhRJ2Umb1TqUZNZLYirSrBOaktTVR7Egfc35Lx1/JqGoO875VAgzs2Pc4zh0dgyQXipTBBYEQUHWBpecSXBJrNOBySrI7kqdY7cTzL8NtBJYPAl5M7dRKUJKnpKUkGw7TACOMoauT6oxkktUI4XLMGzx3SiXBnhQtFMMITNk5oglQ1mUkxyTozL6zGigrQ4O2NMt7Al3izrZZncqV0Qw6JO9DXgWWLCyEoKWB0zsREhKffQkFZ67ogeUfKKBmV9YPImJE/pLStohL3OuyELbHtje+z+ToZ5QFMtjgUixf1ApYC/YRFRQ+4LSADpKghoxVDJgogmURc2qicwtoobb+hR4Kon/CWVhPkflt9Fdj/MAlcOa++96alX8CO9iUo4IfeU7iaJvJ3vgjVjGllXh8bXclXCBz7wAfnpT38qv/nNb6RLly46b7r5khQ8IG3AHIvnAfjc5z4n8+bNk9GjR8vBgwc1kr5lyxZ5z3ve8+oSg02bNsl3vvMd+fCHP6x1l6z6/+Iv/kIn8He84x3lgyNC4Ad/d7/jJ2UZVTvaurWqMf2vCTIo95n8LowYcPI++9nPNvt3lMmUoUEQ+C8bNzureiYWqr6jLFCr0IxYWFLBdqyU64YUEOKjlr8lEOVj4Ab5tJUHSd+RNWJghZaPavrCOgpit1s9kbiVIELMJIQRBI7vhQBB4Fpy/l3lBwMsJVR5XNbo49AxZYtj13yJ84QQy+VcOX4QZvSjqQW5VF4y6+UFXWPeK2NMNYFDwMj5JwXkJwVEU5Lc9pw5EUKzLKSAiZG9CdoZM0BjTsW+ksaYZ6q7/vF9DOasatOQAl5DGSTXiVWyM9KClNsWy2OVXFWH+SukwD95E4li0uKz8GPIssLcabbqtePptaSgds0RRAoxItd/qdxeirq10nPnD+3zfLLo4PqiZYECpdX+VPaf2MrTet5s9URlmOe+H2+maySE6gHOUx5YN817ynqWqJ4gcb0UuL+J6pDKjAMCbeu7MChz18i6wlR0ArnfnwHMo+DSSy+t+nei8X/yJ3+i/79161ZdMDuwKGYR7ubAmTNnyqOPPioTJ058dYkB6klW+pRIAPIbiCbQE0AMXk0g8oCw+CMGpD2YSKJCoWEsGREWq0f3E/IAqeAhYSI6EyAWjb5e8oD8mmcadJJylqCsAshd16o1CBMfPm9Wy1Z5vlR5kM5zPZkYpO89wDmjzpwaeI4VSWGUeRDAKjUtqgnCM7oKqRAEm7vnnDBB1FL5wTFw3LScTpsqCTP/YYBj8I+bbIZ747V1NcZCwdTC7pLjIZMtoegsPTwIw6fRF7h0S2W13FEV5xC64LljX1uZNjoRMRHjJeCOF9c9wIo4ihRwXnkdoX80N47YEoXjmRgm40IjO9X7WE0KAOeKfcHWmfuig+mUKnSOmyNlsrYc85qaScERc1CtlYkCOTttF9XjWIk6IsgjCgL5qfX7iDysLXsIXBVKgCGQrNiJxHC8adqE+2FJHpVEtsdClJ4lDkTCXBklKY+o5k3PmifKAu08DdTO91RCEkgx+PEP//APutWKuhMDKg2C7GTChAnyP//zP/r/znhh9+7d+loH/o6S0r1mz55q1SrOT1QquPfzk/f44f4eZe6Qtl40DgyMrbXDVzoWv8msVXc/wIRACsGVEBEy5KZnI8Stn2/aqhd7V+mpiltqrbNMZG5g1Zywb5XOQMukWA8/8iwRA1daBGlKsv2FRIE8E7clCNO1o2GFIKws/z5Pu+awUsU4t8CKK96zVZOqH1xzCGESiDAQ6nUWzS61QN4ZUKfvlOxpxZNMUEn6gjBSgPlVU4ydMatF0gqssiEAuBBCPp2T5cvyQqBL4knZJs8ryXG6EoA/BAZT6BHiWmQ338fwMD/3EVEMShifkeXaYyFMLe+wx7xcdnPMEymA5LiW46QEiM5EdVXlO6hKqUclUnV75uUlH5bq6E0Q6F2WyO2yTlao+VDa/aiE9Y+oRqmWHgvoCzhXdF8dZIY303CQduSeZTTMG9moJ0zRdjk/qEjw2zGC559/XqsHAOF/Ju7777+/TARYuaMd+LM/+7NyyQX5EaoNCIWABx54QKMRaBHca/7v//2/cubMGVVeAioYqOMMSyO8GthgVmlekdAgDJ7oAoO4v+2sKo1lnwqCrMjoiByWg7qypAUuaDCtdLWG0IqVBSupqIfeDUT4GcDq+TzESej661f5kC5icMgcUGtYJjDCjUkrC2u3Wlu1gyMIo8wk9a13qzN+EpFI240wqlQR8WAUUIuT8bZi1qubDXRcayIYkJS0x0J0xbV/JvTqIkGcU8o7s6z2uL8IL0eRw5erQvOVidE5NbI6jAL3NWkFJiaIICTGdZCEFPSWgbrPVJNAEgHHQgQJwjBAhqa6P6sFgcmTN7+fZS7RUjq2Bea6UCLh7MhdlCeN/oS0DuQHok+0w2+gxOdYek8kYLCu4k/IUT2H3IOQV5w+SR3VA+iHrI27bc+cZFEN8ZpoZml0ZJU8rKQ5DdhnZ6ecR7jsB9d7spmrn8kChpSbA1Un3HecK7RI9Rq7zitP5FcRdY8Y/NVf/ZUaKpBKeNOb3iRPPPGElhC6MkLsGjFq+MIXviBjxoxRovB3f/d3Wmlwyy23lCMM1157reZKSEEw+VOygTCR14G3vvWtqhfA3+Bv//ZvNV1x66231iWMUg+sNSt00HAd+qhECAM3PJN9UIzGoAObdj7llPIxySPmImzrGXKR7XTwYXDFHIiQpEslkJcjnZG1OU86mMQ2xtZa+gn9f0xIcGBLAsSglmqH6jIwap2bynbInENKRIeY0Sq8zDrQOJOYqEl9vXlaiRyh4WBeNxh1CGvZHIdh3jjpafppXwAnSsMAql+Kc+onJRCj4H0WTH+ETbjWzrht4iSMbsZaFC+TJ+WBqt/hnQ/4fO5VJsislr9B3UPaFT0NlpiAiAZArjBr8l8fRKJ2pd3QTBDrP3+QdzwkIFhEOvy6I9toieewv/ZXcOTL+pXcq6QAfYZbYfOdnFeMk2pV2JPm8XdiTKtJQCy4w2y2zZZSWBWvNsuVBHEPOTvlWoHtdg/TVyNhjBn4OBARcr0oGDtfE6TgAkPdiQENHyivIJ+PQpKJn/JEfAkcPvrRj8qxY8e0rJDIwKJFi7Q8EaMiB8oRIQNXXHGFiive8IY3qPeBA8rMe+65R5WbRBV69+6tpklZSxVbAs+YR3VSJx/N6kNv7IxskcGJGmS/WxyhSgYn1NawdgYnHlQ2Aud+MIFQHx+Vu6sVcRED13kua98H13K5FvjLQUnDcG5QfreVDjr4E8GBsDFRZOnaSApA2ySHDFLPmhWyS7Ykahi4dlk9BCowVUp10hXoENKGgDEoivrualJQna+HoLIS7ifpSAhWvjPMYp2o/JMmEybiwaxCulpJgQORlRPmqN6X9DCgnTTXkvA7q1XuO9qLu14LpMB2ylZ91iCVrukV4L4mfgfB47zwM+y+cI250NZA0P3COTQjVEIROeA6hnW5TGuc5YyFaPjWLWOPFUSApKmIFNGFMSqaRCtuSBGLj1pcC8P3YYGeC6IqCPQqESH7LHEesTZnzONcEoFi7HParnMFcwG1XfZMGoXDHyhIYUAwLpWbU4sPk9v20qRkT7Oc9qPmLvW3v9x7fR32vPo7eWCYdMjH+XO2gMmqrwyRYTK6buZN95lfSj8ZIlM8m9YJmyRh+/SbyDKAP2R+owPCxd4NNbbKtuWgLh2zSK4v78eLZq2G+3kNAzq+9Gl0F4TAeawXezdV/fsqs0zPPZGbpJDnCvOgpo1wncsCSt1sG177qJLrZ5AmLZAmbGz38xEth8Moyk8mKGsjAhUl4nvOPKXiwLQtc50wzVlRA/axlmZkzkshLykIi+Rh/ztURuvzCuEbJxfp/ULLZaJzLtoEuJfRltA0qJ8MS1W6aHPxD2kKCvIwxZsXel2Z1In8LZIbMq+MKcl0HgK1tCe3aZTlOmbN8a5o9ntKgbfIBiVDLbGCZ8Hzgqwpp04dmeS4IMNhOg2uGWovyoeJxuAgiFlQS84TQ7//KWnokH8MbTpxUra+73Mtuq/1QtEroU5wohwGF1aqWbzvawHfQfnZfrO7ihSgyLciqIOyRTA6WS9tjV25EYXI2yDKOd0FUwkcP3oCwqyIyGbLFZmFVdYRMB9BQ11NqBiBJysamusQmgT+iWSUN0mGmDFaqkVon5ruEWZ8otEU5jJ+UyJLAq0wMK2Gg5VOlpbNFe+JJTo08l4GyqnefO0eiACRSoBpZmFi051DckCJRDUpsJ/hjIHCiCOkhxVyVlJgdQPDtLKCyY8Vep5oAWWfrlNfPUoHSasRBUGQ60pHSQkQMXETTgfpWKIBg1UAnOc5hqBCCojQhJECl+IYbsYrUU3bbMnBmlpZa2BSdXlJgUsBEbXgfHBP+L0wKJ2FFCBeroUUEIGBdB3RVf9hjcCd0oqtM6ETP/c5kz5khHQs0VeeP8iL3zPmrDkjD8lvch97gXAUxKAO8A+IDARR+beWCiRR0kO0gJUHwxkhUBTDlJIBwqWE0JkIMYRhQyhGrjBrrte5rzGZOJzRRkj3KTGBeLAKzzOAQAyYvLLCifOYwOZoIyg7gbM/YakJIgSkODgvDMho3F82m3Vg9tfJB0sVXRllNQnsJzO8dKFVRHdMOFlcE2mF7ZXCxEw2rhqGwbuT6aorXjaqMaJy1ew/3+33lXekwN+WuPn7CNaeiNQlxJECV5IIaUFcRkh9vknXjTHoBdGqxtJB54/AcwFxdeJHAJHkmnBu+suQVNGXJNCzgGeNZzEpF0/nS8pRiQClLR20/QKssRClqmn0O2nD+aQ26H7I/YAYFZ8F5wwb90xzjkm5OE2UC/dzrm031mrwXNqJv7uOW0SzHFhYzPeukdcazAWUSiiIQY1w/t08BHRum1SjUjcL7Cp9iYanXSibXCHwOxOymnANd6irxk2OEklWg7oiNA2qn6ZZESmCuAEAjwY/MXA95BmkktoWJ8NkXlG7yg/bsrq6dO20nI4lGpwXSgLxCuAzmOxZOSHs86+sXUUC4eRqEjgodW015x2EdUQMwz6zS0V8VlBmleuQEyYbBwgdky3nnwGdZjphSvHdpTLFfqVyw+pOgdH+/64xUVJ75ihS4M7xVDNfQ9U8J/MjqgLqTQpIK1GySkTH30QoSBRZq2IOVa8W66SW0CVApqanJIy4EdKKm+PtafrEpvyc2yBUD6fLNP4VacAzP9XMU5KJNTe2xf4KFZ4HCMlh2afkisnfrvpPlr1CguC9pATcir+rdFcSxv+7McZaQ9+p/09nScibijzN9hYzgcsNU1QlFEgBy9xt3/shMkbG1TQp5ick/lW6k4xEifio454sc8rhPUqCWK3A9NkQAHU2XXX1NFiaN6DxRwwqfQCMlggOzuh+Vn08p5s1UEor8nSVH833FafC+BUg54wBdpgZq+VehFNZOY0xU8orcNegBxtaegNwzrP2mXDmQijyk8AK0pWeYUhFfh7xF+B7/WCFu8jcoOSASBDiy2Baw5kioZZPSwoAcSbW1BCgPKTAgQF+kpbGPakrXUoG43QdFdfI9KQAUoSJFZMyE1bFz6NVyUBsoBI7e16tRTWvgAyS6uAc1uopsNo8Vmob3jOTQI9zAXli39AlYGEcTQpc98zJifbXWUE6yqUUKI4F3Cf4QDQaVv0mJM/fRlf4aJlYnLDA6C49U+mZ+EzXFIlnkIqEXmaALJHfyDpZqf4Kr62KBK/GuG8RMfiDh+1mZ5l7mmZIzqi4HkB0ROie78a3EbvVZr0SUjxQDLgo9tkYdDCiYTLAoY0QIlt707FkRztOV3quVptVNMr4YCOkvDhecodsl8L8xx/KjzIu4jWsYsgXpwHnggoSwrkYIzF5Em4nxErTIsBkxaCcJzKStlTRCcFcPbrrlcDKl38LW9k6Ix/ex8REK2ty+m5w5jwhoNshm1OTAqsEP6LOnFH3UhpS4DDAG673mNNFBEsGg3bESSZDkFpEkXtlp36/u+/1HElX6SUDZLCMKKcu8NRwJZQQJ/L7AAJIGgodB+e7FlEjpcTkwfN4hmBR7pwA15tVMt73TANnKc0KfbiMr6nayKn8qdhBe8L5g+xiCx+c/FH9c+901iepi5IriE9Sr4Y0+8AYdrp0PI7kcE8MNWNV10Adykipb5O5AulQpBJyTswMiITPk7rZ1RsHzT5NHzDphX13qp4OIeCB5AFl46GlvI1QLASAqAJbG9NOXRndCpioAYNp3lIrPyqdFTumjpTE6Tkq7Zaz7Rs53r5mkJIDBmmusyvNhBTk7YiJ4IoJOW4wdQJKVzrnF+uxCo47Fj6XHhhOQf6I3CmzzaW6koPM4eWQlhRUyhuNOg7USgocGPy5fhBKVr40XvKTg2o74mo9AhEl+mGQIICoVUo3PT1GBL8QAZpRBXGkRApcSZ9fR4JHBAJPCBVOe3lSYURzuFcgJDwPeSdMnAD3y14l6H3NwDLZdl4I3NNE8dAlpAHn+qDs1Zol67R6VImF60HhAJkihddJOuh96oCoeZaXzvgoKxAqu3sneDyYoUH6NssGGWrG1dUdsiaYIpVQIKZumLBtFo/6yl1VG+xq6onYRkj+Mqu8YGBDUe4cGkkZQAxYtbLOcKD9aZqGR2ngJvI4Z8KT5oQOkKxigpGSINx+0n8iz/FjNTzcjNOcq9s3NBh522Qj4/NXNcSFz4P9FVjtBvUFURjjTdFUEJ/1uDxQ9h+gVNaSgvgwvgOkEAwqtUuulRQ4sNJtNGdVic9n0LKZ810hRZYUoILfYbYoQeFa+lsO8ztSMqRVyOXHTcRoO54o1fnTgrmH11xIieiUDpHc491NH+mboR0xZIJzRcqqVoc+3guZY18wKLvY3KQkEd8F54UQjCSAEwY/E9uemWifFf2dbrZIQK+BAZdd+Xcvd2tk4iUCQwQUUFHFap0qArQuSRUveXQY7CvXMOzeUfdSM0PvByybs1RrtChMQQwKRNaT29V6Wje/esG1DGbgtN36wieZKG/2WsDKpavpqYSoUp/uaaoBRf8AQ3D9opqYfaWzYjgxOGIO6QAJIRsjU3SlFwfEUSCt/XDUuXT9GwATAM2vxnvTM30Ogy6fFbUvFe9/SEFz5f7O0iQd1BfE2RN3NF11VeaMjbKQAkCkKKxpUi2kwIEVIuQAwSdEb7iZoISXe4qJipy/a6gFWM0yiaB7IS6QdvJFd/CERgqatDdAVLrLNly6Qh6WO2SNLNc0Rxpdw0bzbNm2t171/XzveDNTzZyoQoEYsNonOoZzIuZhpIZQ/fPM+G2YLTxtEE/e37qi9pQe0lf/HrV/Vit1b9lmG8FoV9NdHpbfq3vpYnNj3XL9RFeIzqBFmOYtjI3c0WcG/RPlpfWoFimQHq+RGM1rHxWhnW1AUm8WnbYc0XZMiw4DtwQxYGJj4LAh6Y66ImFVx6TD4M6EydbD9FERUZ7ujdQ0R6US/CLHtP0BHIFhQMyfsqk2FXKGSayi6GGQVinP4AYw1Qmi2mAoPKdOeJlwb5bzigMeve5Zmdv9H5yaFLimSUHRYT1IgQPRHiJApAYsKQBGxYOcC+cqSKVPHsLpHDAhBdNSPK88U5RWcp/xPsSIcZMhRB1vEFbg9TT94Rxzz5L6cdUwwDVncoAw2Nx/N90QWPaSvplNzGxqrlLl4J4tPoeI2WahBfgaTVvWCiZ6F11J0yOCKgX6bqyRxzQa86rDnNu2y68mCmKQAnvUS/3Rspo5rNb9XJUjJg1AeTUG8QY7uAk26UqdkCbqd8K5I72JMlImqu87gwepBiaODqaz5gmzNPhxteXBScCF2Dn3TMZhoeAwQF54T54BG38Dq16nVG+UkgFWbJASjHAQ8RHuZWWXJpXEeQF+HwHgKgSiXAer9QXZUjZ0eXSkgEmEfTamKVXfjK3ygv4c5muaVC9SAOGiBTjCN/9qF+IzQsbJQBmVqpwxDqwwEbZBbhCPpjX/wRRrhJmg9uIQBO63MGD6Q/QOoh7VFyMNWKnvU4vzSrdVv+21g2ugRrlfd+kTacGcFU7QSFSM5zhY5TDKmyzbzWaNiiAIbO91yP1d2G4TF6PqCP1Mmv1HL9LTWFvzlkhpZIUpuisWaJ77pXSsohJ/tcoRk2BXuPVhps6fngmWAZZ+9jRSAf7BkH9n4mRAZvW7T/ZofnC9eUpz1KNkYuK+Qwz4nrCeC4TYrcgxfa05Iiu/CVN2B8UGrXbYVuosiMqdY5goM9UABn99zs0es0395mPz3HJIU0D+c8bkQiomSQyIcA5SFiQVaVo/O3DfPiuPqUAOp7gk0x0svf1Nk2ohBVbI+rKKyYi4OOGb6xLJT0gPhJM6knqQAhsWJ903X+/NLMAZ86B5RckcUQHIb5DMOdMfrlsaUuCqAPaqDuAVPVbuTz+J595n0iT0f0KOq1CQ6NkpOa73f1zYPQ9cHwfGF/Q6weN0wNODxQkLo7xVG1TauF4cYWXFcZgs87SXA6Wui+XGXN9fIDuKiEEMKis629+8ljxXlhB/XDli8vc01YUWbDSr1QipVUnT4MLYtqQpHJwf6red8pzIAuHWrbJBa5IJVUaF3zlWN1m4XCRhR8KlNFPJHCItKfGzwIX1bT97S0TWmYO6X/4wPCtLjJGIpGAUxcBF46CofgDkgv0izU3mOe1Bbx3lro0N8e+QLZn0BY5Mcd7s3dCkZHauuUpLPAlHrzRLNR0WRma49/xNk/KQAq4/KSbSX0yCTnjLypf2y52li04UTmjJv9P5kghHJ9NFNRK1VAtBPghD5zXI4R4mv05UoLvpXdYmoAVxlR02UtD8urlGZ5AriBBRgKAOgAmSGAACwB7SW0m1u7957lghu74EkFRSUVvM8zLMqzRUqxXcu+hwMDSLG1+I0LlVex7TIdJSrnOlbUWezcCM1w82IzVqV+9zkBmmEB9e8HADLIOADl41erTXqxwxCbVqDJgIWB1gUUq6AELkf5gJdQZX9kGwIoAEsBF12CzryjnSzqabHldQCAbhgITw/azGMVlhcCTsmCdUy+TA/qdFJTpRnetnRUXIOOwYsV92K39WX/jeB0uvCBdzLZkEwAvmWZ0A+Uy74owfKBmQOd8YU2UhBRgjYcbkdA2QgFnmMrUn5jMhCfw9SA4ggwA5aRZSwKTMe7nGFadBT30QmHwguJwz59NgyVelxfE8c6WWWBKd62g6l30GsulgbEOhSTJHzXLygnMyx1yu54/ztchcrwTQdf2zEZ62WqGEyTjqfcr8OG5/VRDXjWuB3x+RAK5FXBqASA/n0N+XgC6gGG6RqkPkW49GaBiDOcvmsEZoQSC0XqKr9hWZTIcQf0JAOA8sLvKOoYwXO+UlXWzQNv1VMz0yhcbggoZbLdvVqh0EzgXSlCO2ZCqB1Y6rPEDMRI41+BCmIQZ+kIMfJMO15O55WaV6CQaLtqadDJNxOmHwHbZpShv9flYy1FBjFZtnEMB8CrjeBmlKztSnIXC9mRjZr7jKBvpR0K4WMseEj94Cgxv3GU4wRirA3VeEjHG3S0N4UJ+nOY5KFKKdLJRryhP8EF+5IecSMyrnGElUyrUfduDfmbQxsEkiBWF6Ad5LCSEKegSb/s+ukIIGJQV+/wsmvNnmct0nzuUCc23qiQRSQJdBPPkpMx3ghXsvZAGVIVPMPN1fPtu19yXyo38vOXU6cNztpZMSIY6fKECWiRAzLSY+dw+688ZP9gOCQulsrSK8dWalXmP2khRYGkBeR5pJun9E1PBbSHNNbEWI0XsuDbGNAueAXiAQM/xFuMYFWhZFKiEAF8KGtfOAnitzjbTliEngQcxDC3iQGZQZAKmXjhKpMfj6Q/5ZVPKsYllBE46looEeBQw2/cwQ/VwmYVZdKOinRnSkSwNCuIBBOm0b3jBb5UrJY3x/A1IOqNiJG+B+97DcLlOMDWUTUgbklp1oM+19xYrL6gv6JKq9rbCrEoXYbbYrgQurhEBj4Npj40JImoH9gRhy/lnVhpGCoPGVWx3jiM81Q6wYtdK3At5wUuDAPW/7Kjwqj8l9ulJPOk90GbSkwDYUypuGcOAY6QCILsK5VTpSAPAJIAUEcWZy5fxirlTLKhYdk2toFXZv9PZZFZPOGOTF966IK6/cUa4KaB4tSvKfQEDItScyFtcMK1j+WKsrKuCYiajwrI4yk8qkKy61WW94xm61vP98QUEMAl7nDOwt1Xe8HuWISbCCJi93+oJ2za4rYxiaNGKQ/7ywkp4ss2WimVlyVHxeH3YHGvaM92ZILUDhDVz4Ps5ohXww5WGkTILX23V8S2MspE1oZJ6uivGZZxLsawar6AxACqJ6OkSB94ABMiLyNS+ataqi90chmNyY1Dl+zwu/FyZ7s6W1aaMue4TMF5irZZtsKhMiIgCQAsK4pCiwyg7qBVgV08I7aWVMFIXJvkIKogkb5kKjzeRyegar5+j6e0jBXSVSMCNXQyGIBU2mKJNEJOr3TwhirEyToXXuTwBhcs2i7LPfNlIEiJZlvaxS8WtSCioI8vO2vDJ/+2QE0Cvkfq3YId0WV+nA/cO9k6UyKQmQDFJgPF8sMvguvE3OGUyhMbig0LZ1o6w8u1zV9JQF1WJrGodgCD5dOWLaSd7k0hjsMC9pv3v2jQc/yfWNVWJUg6Ys4DiHyzjpYayhTdBEaIxMzX0N7ARmmx6FgfNOOoMVIbnfKG971zwpqb+BH0QJLjY3qgcCJNOBEHRS69ogyGtrW+AIUeOL5lmtMw+mJuhQB5xzZRRw0WttWmsKhEY5rhMlgzoTCCvUh0rmSk4vgEUylSZpyQ2k4JmUpMABYkp1AcSI9yKUjOpVAikYJ9NTraK57hBBQuk4752UY1WaAI6f+6G79NV+gBQt2l4gF2v76xdktQw0QzNPylHAn6NCmOJ1TJxvGlExKa6SR1P5ADig8yE6R2QHIW/e54r7EI0B55AoRzA64zQprv9Bva3iKRPvZnrpc0kZNalJf+fMFocpNAYXFH7xN0ukXSuRAye6yskTHeXIySflyIk2uh0u/fT/v/t59EQbOX4aH33vnJUjhsMEUgleTZUHcWAgbRvTyjgLdptt5S5uAHc7QtQo2gl5klfMEzZFCc41CZu8XJkWq2IiAXGtcRGUcW6yXhdWfayolpm7tOwMjJYpmT/H6gvCQ7YVEWNzvQLnDrDiTwJiScgBK3R/yJwB1+kFiOKgGsi6/3SJZGK3DaHSkQIHOlceN0eUnAR7GNhWvXeXV6VDIrp6Yoe8S1MCe5Qs+qsDmIyJetBuqa8M1HvPHZ9ruGRbXl+mE+IkM1srBGhJXA+zHVxU8UqwwrwrUlU8IaikcgZCS1ltmtU4EQnKaq1o8uqaSQ2rdsSQtGQmBei/J1jk2PTT8NT9HLJiiszXFtU0vWKsc4ZrBeqLIpVQQrvWnvQn7dnFdvlLi7ONXpk4HDnZRg4fL5GHk6Wfpb+3PeHJiwc8aTjUJMeaTuQuRwx13fDxgDQRA1t5YDvxhVUexH6dRgxsU6Fa4Grt+SwaEzEx9ZEBWq+9xWyQF2Wdio0Q1dEmOq2xkZvUmNDDyBgWvBAHlPJJimyMX7KWPDog8HOkgAuEe9tRM0Hr5NM693GumZizkAJAjjzMzjgKQ2WsRh6cuQ6TJH0wslYGRLWOpvTT3xAqLRCfkuYg5dTRdJHB3khtpkT6gGeHqJJblUIW0D9AJEgl4RPgJ8ycq17SU0WgXPsosx6stwlX24ZLl5SjNUzCu8wWTS9RiRKXbkujHbHW6nhMXJpJT4SLIxMzUT5W73HX2JYKVqI19aho4PvGmqmqiWAfXAt37ndW8rb/Qfp25GFaJ0g7Wg6eHyZ9+nxAWhvljDSWIjxunDunpMAUqYQLCiO+cUYmdRgpfTq0kX4dWkvvDq2lewcjXTs2StcOp6VLh7PSpcMZ6drhjHTpcFq66t9PS9vWRlq3MtKj82nd4tFKTpxpEE/ul6d2nZWndraSrduHyJ7tY2TH/jySQWy4mgcrkiIGTI7kCVlBxYXRo7/VSOsa+STKaFa1iLggJZQiAdZvgD4IQ8wYXZUQTmYlQq8GcvhplN62VWw10WFCeVRd3k6qm2FSvwPOE+KpPE2YnjaP6ATFdeB8kUJYKQ+qFoBVLMY7See8oi8Y3kxA5qx4w1z3nJ0xFQFp4MK/tvqip0ZsbGorv5FXxTnSkYJ8n8U5ooyRHgbcC+1MB52MuL79Zajew8vNPUr0/B0DWR3THhhShSgSkWCae/yYOaLPhu2tQMOl6hQSUT3y/JBY9CN5fE1IkTzh+46s5IvrTYMhogD0deAzwsB95i8VrGevARwS8XhBFzXCjFenTFfpEGXExPOE3oZJn6mfawaBh8BB8pAeR7m2ch8x5rSVDtpMy0W2+PeLZL7ea+cEpiAGFxT2nzkpD59Zh5y9Gbj5+MNgw0aDEm7RNki72rSXPu3bSN8ObaVPxzbSu0Mr6dFBpFuJSFTIxBnp0X2/9O4k0qGNkQVDWumGvI3tyInWsmFHN1m/vbIdOl6a2LyIKEHU72KIQdrKgzgw0eVxFHSTEOFTXOX8HgXUwIMuvioC6zI4S0aZybraJnyKCQ7CK9TncSslBhn6x/sFZs4PnpUwVq9JoAQPUDaZBZgHUYnA+47JUR3sOnmdtWrhSXlIozSo6CkTjDsGpy/w22+71E9cZQOra+dDkIQwnwIXyQlri5yeFDxSMylwIPSNeRQiMzoOOjApAb6HqA6TEqtVUh55KomcqZizUcbEKgjuyelmkWpi0JAsNNdnItXch+47IIdh35EGiCy3mxf1HuF8By2fORbOF88qUY9aSgWjwDni3uFc8FwxJnL+15kndRXPhI+bKVUDwTbPDmpZXhpViXBxHSn5ZGxwPSDaeu2audBS0onwlcUFLpEF6o8ilSCiExRMlJsMFsv/0dTHsVPHaPl3BEsujLX7jMgG0pau4WAooeBPGw2LMV2P7tkgbxo4WaYPapLxgw7L6P6HNSIxa9Q+3Rx2Hmgv67d3l/U7usmG7d1k466ucvpsqwopyOhjgM0rK4imFJUHSchDDKxHwn26WmAlx0rHDaqECkFY/rOd116FVuR9sfWljGyP7NAGLyNkQrOBme/hLLjcvPXNZ0XcmMkwypUZMtilgV9ISjc7BHMPyK/KqQA1zZHLy9ESShqp248KsTNZM0hmIQV2v/dW2RnH7W9YSaK/LTLnbX6pLXIa7PORgjk1kAKuIaWUu2W7pkWCzoH0C0AZQEqgHithvzkSOfQ4G2VW+DSngoARxYC8poEt4bNiSd6T15XRAZ8T2/3wMbnEvK58jRBl+i2hs6Tgoss3D8kRbenMav9Yqa2z7W3irg1jJeXWDnbssxM+1Vb8xPqaqCDRHLw5spAqhJquLTkCSogI1UwYep0zmCJicEGBwaW1l0JQ55uUeWAgEYTELEO2YTFC1WfKhOKsDgQu18y7N+5vki/uXy0Nz7bSyat3Q0+Z37eXzB3cSiYOOizjBh2SYX2OyYAeJ2VAj11y2eRdZS3D5j2dLVkoRRW2vdKpmaLA0oJqYrDTvKRe42krD6LAMQOnXs+2UrImMQiTgjlIzllSCSS53oVyXbnmm7A8IsUJZkaVy50rVaTnPOFU26q5SQfjgRnK2ZwXQli9fdh5IS/NexCSTvMWqbAyjFgwAdPSFktgJl7Ma4KTBGSGfWYN7DdgSiIFzs6Y8HnS/saZFyEco6cCNrRhJkhRpODpMinI5sPB/lBJQRUHqQy/CNKfEqLKBKJAQm6EN0HqAVvyaM2RiESlEfQhhKTagnRPfzM0sU7f38EQcprlPowCeoExZqp6giDgJaTO9/g9HdKQD97DOeW5YeK34xk5/VP6OWGapTCNkXZVlW466derasOvyXBCTQin00oMNMO1B8c5gymqEgqEwdWEG6MDJRN7lGo8aKDjVtrUQtNRzfZUPyJbmg7Lll0vyc92ibR+sq2WhA1tN0AWD+wh0wefUaIwfuAh6dXllIwZcES3m2bZSefYydby/M6uShKee7mbpiPMEaMDp8NGs0aYSolbzKrBOAkQMQGw9bSwk/ODuhobJZN1RRoEE0GYWDAMlEihhmZ1wnExKFLLT503IVMGOcAZsLlck4sMQeaCOoUw+KscCGNf5M3Xf2e1q/srzV34BnujpJPpJk/LUhWBkqf1pze2l/UFw3ykoKNWOsSFybeU0gj+rohh+5vG5hgNBuSAkD1hc/LUUdhndgdIQXzomn3A/5/Phggg8nTgnFMt0leGqE4C8sT9gV/CGG+qPGke0jRPrQLASnXDPb6Sx/QTNiF6OmxSdUF5atR1qe5gOKmuJXx8Ft0PaV3tVtScK7qgumPBoZFzfFgOqiaD+/pUWcxHiD984uc6ENJnpY/PB54YaFCIRFFRsUIe0qgAGhgmZ0hPrdGJqEWFc1DknPsjbGq5fi6JwQWEIpWg870XaQQDTDB8H/NaP1Y1YaCzQz0KeBBZBQ5qGCGDfGVkx5uOlgxW9qgSl1z6wVOvyOrNIt5m23GNh3JS1/6yeFBnmTz4mIwfdEjGDDgsndqflekj9uvmsPVQW7lro8jOTTvl3194UbacoedBe5kb28Ak6Xj+f/a+A06yssr+vEqdw3Se6ck55wwTiEMWQVHBhIrZNcuy5rC66qKyq4KKoKAIIjkOMDAzDJNzznmm40znXFXf/3fu976qV9VV3VXdPaz+6TsUVV1d8b3X757v3HPP1d+/zV7JUWeReA87pzEqoWjjrcZ4UkkkCZsgKJNyiBovJ0OeGLmyHaAK5bsySDEmO6rZGdxf3RkkOZMsxXCTLa3QZrBPnmAnnhKcwraF6hopr7AjQIsSdcsqgSP3CQVdBAWJGiPxWONJPZ6gLdmBSPw+BAfURWxVqzHTWhwHFLxpg4JLYoIC7R9QLuUBzhVwmgiRfWLppRilKMGw0Hfkc+jKaKb/ERQwaK+7Gs+LAJD7u6edE+FVPBPp1Lgtj/GCCXKcmiHlBJZPYvkKGFDA70DNx8g+YjmcwWOGehCWCRkU6VEMSCdVnfijw7KLm1yEsKqfGZH4nTX9WEE2ix0VsFs5yRIQ4PEYHqbG9an/i+4iCs+/iP475nsNVMND4uULHVa/8+E7Lay4yVGoNAdTkEgEgzTQWWUb6HDmwFK8hRdjPjbdlclTtFzMc1mnJq1ag2pB+Dwxr6rnBXDtYwkiHXlWHuYV5WF+qc9RgmjE0BwXPkmmfvYufLlN4dVDOdi2ayq2HPHAH1v0m3D3Q4d9Qk8kiZvJlHp88dIuT+D8w481qKi7YBIhhcqTFWutrK+bCCeq+HMOuqo5c79ndgEMTOIi9RpdHtFlpuYuZywwOGKYtr9ckTNxanviy0SHwSMuGVDAkygTUDwzpp6OTqbKfItaJcCVLWnOkc1cpWqmwIrY1nwvajRYHuAxzG1hgqwZPyPFY1xtxgKrJqFy29JDwdnOy2QwRy3FOrwqpkNdrda72lZMpmYV39OJfWyfLFcn5e/8tDoqPzu/A8tY3JfiIOnwYUg2+Hm56ieoIuVvVv0E1NFUvwYDekHB0hNX/VyYmMTfG4t3ll0IwCmoZdukmSY6Wk2RGQr8ex+Prrt9Eg1uPyOUJtMYb/4F2ZG3CxigX2PwDos4uEDjACucHM3tLoKJnatAbaBTghkuu50oaBoSu16du1w0lSnCAKNYDgblxMBVMQECTxAUALG16lTFCfyjAvBs9QrqL/WVYMiQY7h0hAvvm+TFsFwXbp6scPPkHeKnsGpvMVbsGoi9p3ITbI+M7H4wlK8e6Rs/DqjtUv/napD90135qvMEwJMbT2S90YjwffaozaGTBN+ba6OehLFCjuUhwDC1XCa8WBbOxjGRPfPdhSQ6XIp9aqvQoqvxQkjFTVBAn4JEVmFncESunWxUb0GBCQpFzchmbuNJ1mwBBUzMPDRYPqCahop0AggtJtXHDlenbIul1oKfrbteepMQTEKNZY9No6QJaob4XPBz0Uo40TCgg3ogDvHq7SqeCfJNPCeJsUCVhESfXMEziVPvkcj25uficUOQQbEf95Vu5eN0zshzDkEvWTuu1qPHOi/CtX3iVxD7mH81pF9wdkKQbTmm9srxS5DQF/NluLAiAOIxE6v8aKIvXFj7o3P0lxLiIAPNFES1BnbDGPiDmvoKGei4woOAQs9MqArheJBFBz+vrK50T7tt7BFsFgqPHu8sQZC6rms/j71HgOVHgO+85sItAyfiXVObsXRSOfKz2nH97NNyKa9NxRu7BwpIOFGV2XVLpCOMKCweY+A0TtIrXbbkdc0uGFrZqcDvSVC1b0AB6XSKp5gAhqnxGJOkC5sZnhNrABFPkDTd4ecmPRxrJZioJbEzJlgzRZTIZGe2caKgwPmePO76EhQ4RzbzdbiN6QlhpkZSd25qwPJYmcyYEwICyUwYNHoNOk5y23X1WemIyTIGtQoEoomYhDmpfV2emILehrBW6iIBAuxKoUCWMzjMWGPnMDC+P7VFtahyJH/W+7nyj6TzyMJQy8PVPoW0XPGzBZYMpDkmCMQIPnjfKEySz7AT65OyS05u9a4ZllhajPGYKX/7e7FJuiF6E7vUBmFH+Pc3oQfHa3/0PvqBQSxcIJjAvsNJEoQqCp2Tpj+obVpDBjrunh7QiekXeMKlHznnDThHNpvgCefhso14pMyD4ldK8N4Ro3HNlFpcNKECJbmt+MDFx+RypDwLK3YPFKBQ3WCvNOIAIAMMYq3unSK8ZIyTCGoYlDj1NIzAk5+L259UNevGFPfRDKhSnRKtQaJJiidbrsqiaW6K1Uj38wTJbR/P9pVJgc9PpKMh+n2d25osUXSijxXc9kymTCLObd4XoMAZTPT03DegwHxOvi9P4vx9T9sHDfXO44ffORGPDepWCNLITuWpoi7bDM3xqZmI4b1zG40KdiVQIc8uBWODTVaNl41qRci5L3by12wfKX8mfz21sXvKn+6XfD+CBjMePUflaY2SOhfhf9HbYKnLrN7jMSzsgEhTGQLUKBhkmawnQbE0HSzJhtAr4Z8uTajePf9fJfqBQSdk4LAYjsMWRAsV24OtMoSGtB/bqEa7piStZUg8DGAJo5WjwT2hkc0UOGbZf1Qcxcs/1LPqNO45ehr3Hk3F0BcG47axhbhyaiXmjK7GqJIGuXzisoPYeWIAXt81EKv3lqCpzQgMw9+b34+RElVK0D3a2lUwEathZzChMXiC60kYl0EmJ85p58mf35/dFzQVMu6Ja/ASxqgpCdWTuaKM1jzooT2cGsea56Qu2+XIGCULdMy4bwY7XUgjs+OC4r/u5kWQoeGK3Qki+gIU8AR/CgflGNLzJyKD4Kun9flY7Z6aei9N+PgRbwh1qTgjcqVMw6FYCcm8vgEdvbHsdb4mO2CoBqrHuRDANa3JBI9k9Jj8KfVj4tfJP0eSPzmVnlLu1O/QZ4JCW5ZRDBhkZw5NwKi3YUmhL0JbHZ8XBqi71ftEzBEQsQcbBKwkG5wDwU4jaiMu1CC7f6V2xZ/85Cd48sknsX//fqSlpWHhwoX46U9/inHj9GIwXjz++OP49re/jePHj2PMmDHynGuuuSap9+4HBs583aWmILa+gF0F65VueSKtPMzV9U5LNmLbFYU/x+7gBsfI5ivFOEcGxLgypHefl4ZgLY5ijzilHfYfxvf3HsbP9mZgYtow3DYxC5dNKcfUYTWYPlxfPn/1Pmw4VCggYcOhAnQE3BGzz53tivT0ZzKm6KmrVXS8MAmHbZrJhNM7gBQrffW5cmQYAZ5xT6Ryma55XO3SB4HT8uLVYfm6xh44lnMixU60bI4XjV3MOOgOFFBRzm1M3QITGHUMLC2wfNFVAqbfAGMoRvUaFLAVjap2lqic1rNMalxtMwg6mXwOYxfyVXGv3A2NMRT3IwWJU+12z0SD+3Ga0ra4ZBwuUp3LL6TYzesnA1qd+5Tgk/Q2gSzZODNXIlYQDHAb8bjs655+MoMU+ZFpYPuq87uSETPMBcFDb1sj96vt3VodR3faZKlcEQFzmyUzH4PDnqjToDg11gj0d2KsWrUKn/vc5zBnzhz4/X78x3/8B6688krs3bsXGRmxFx5r167FBz7wAQEV1113HR555BHceOON2Lp1KyZPTvzc3A8MJBxlg+hs3AUuaAzUhixOuQopdXU/CTC60zHBRofoVxGRIyfAUYxIX3sZ2exygR5E0WZBWa5cTIP+wz4XLJPWIgqdtrTsxZYtQNaWXMzNGYX3TbZw+ZRyjChuxKIJlXJpbPXgTYoWdw/EjmM6UZg/2vN2/zpXqxQkJdMHbsIMQeEqoScuijzZG6V8vdIeBhRvRp+wFqvrJZnxRMcVJv3mY31e1n4ZLIfI51PNIdMY9k3TJ76rMDoHtt4lEqwTa0o4U0ohpILNWGMmObIUBDTsR48HurgvuXpkEkoWFPDxdJOkGyNXhkb4yMTDbctaPI8nisGY8EyHyUy1RICZTsYUvPUsAbLVUQ/fKYnoeEgmCqyBITdCTkB01ri3qTdlm1II2t3rc1+TfSEAILvAYzPadZGgm/tJr/oHyOtyuxEk6UFNxVLWIvvBz9WXQRMplgvJDJIpiAU6WOsvF4i8G4PVqB4nWFpjn8ZhYa/YlphocKgS/164HxIVhdLVlPoEbls+p6fH0v9vXQkvv/xyxM9/+tOfUFRUhC1btmDx4s6tw4x77rkHV111Fb7+9a/Lzz/84Q/x6quv4te//jXuu+++hN+7HxiEIgZT0EUnQk2gWgbjMCnyhFPkcrrNxVTzxbiX/gkJ76vQ67QH27EBy2XlIqsgDuVxmRMADY7inwzyXQORj4ECLChYO4VDchJbUbcNr7/lQu5b+biiaBxumtqGSyaXoSinDVfPPCOXr9QD929LwcHtLdhaW4592GLPq1/crftbvNCuh137SMQrW5RyLqNDtc7VnAxciUHR8gTJVRyn/pF25hAaOkJSVe58vPYQoPCwWNogtb0sXfEIJEYmOGMhcsZB96AgS06IK/GMACTzebgavtgGB6SOWVaIHv5E/wOyNcUYmjAooHjwFI5IAqHpjTm+aaLECZcUVRqtAOvVpIcZsxxtp/x+E9Rs2Y4Ex7FW6t0FvRG4umRypVtkb4JsHTslWPYwrYOkwcmSkUGa6Riv3a7ahAGQla3t9kcBoPPvXDQm0uufIyvmPBSJFXP0sXVGHRdQQCDFscYc90PwydJeqRrZrS9AosHk6RxMFU8vw33AceUsofHvk+W1ZOOsOi7zMsyQs2T2KztG6C/BbVujqjsNooqOFtUs51HGLFzSZQfT/y/AoL4+cihPSkqKXLqLujq9aMnLC7OZ0bFu3Tp85Stfibhv2bJlePrpp5P6qP3AILqUEMpPUWUEGW+sf1kdKLNNXYCZrqXId3Xflha2Ku6NxkChKViPjeo1WcGy3WqMa1qno7XbschKt0VSTFSqhssKnACBq0b+Qf+9sgpPvOZG/mvFuHnYSFw7pR6LJ1ZgULYf31mSgsCiN/HIrnb8Yq0XaZWXyMmgp9+HLZCJjnHWnvav2sOQOo8wJlDqzmOBqziyBywt8LtyWt5kNTdkH8vVH4PCMQMKeHKl42IiwUSbyKhmI5g0oIBMBd8r2kKZq8KF6ipxAGTJgODAaaRkhiZxZd8VKGB7K0loroj1SGJ9PLKEU4IhGIzRnZJeXRQoiAY7ZFyaVJ18BtL1yajhqQ0hiGLJxZm0exNc2bKURrtpmmsx+RNokVHbpN6wAUBbRPufUf9z9U/fCn4eApVEVq2V6owAI9LfC8WqWj9nsponpkc8xrpyjEw0tKmQHgU9B0u6/XsjKKIzJI+vUWpSUp0hZCU4wZJtpt05bXYlCuV+YIcCuzTiBQHqhtBch4WhEdf/v8eQIZGC4u9+97v43ve+1+VzuJD70pe+hIsuuqjLkkB5eTmKiyPzEX/m/clEPzAIJX77WiK+xqA8cBK71DpB7nNclyLH1Xfq31jhhBHVwQpsV6s1de8sXUQbM3bX2+tyvqpuh9QmSxNESEnRIpXBHFZ074mzuP+ED4NfGoSLxlfjQzOCuHKUBx+a5sOHpgFv7juKv6wehaMVscSDVjemSZY9mc2bkF862+KYPONR+lz18QTfXfBkR3EU9QZ7sUVoTM62JwWtWQdLShU8YU3BvIhZDF0FtQj8fKSZu4rdaqPoQiiYlBKQ5cIpZeyMx8b8vBxmxJU5n8cTqllhM/kRWLFMEg0KeJInM0AAZGrifCxXv9QxFGBQ3NUgQQGnQTKo34jHgHClznoyNQn0YnAyOPGC7Xz83KzBz7KSF6nFCopDebwS6BDc8fUNWDQeDzzOzNQ+PYippMfqebITkfR3+HXY429WzQQPvRmYFGkqdFHCTo88bmlFzs9IIV8i0eBgJThYrqd+CBx8xrHUNGmrVKdRZA2OYxCmQT7/nns6v+XtDKuPnA9PnTqF7OwwuEuELaDWYPfu3VizZg3ejugHBrIVXACRsSn4B+22IvnZTm5BhVOBw9ivNusan2cZMlxO0ZUBE72km6LDfvtTwUPYr7bKH+0saynyXIa6dzgz2iEr8E7UfGwZY/Sb+Vyp4l42Xs0QYSEpUa4yjwWO49ge4C97gDnF6fjpxaVYMqkipEVYs68If1k9EkcqshMEBfon0uD0POgqSEmyxk1AFC9RtymugpUk20SDLEC+GihtjeIuiWdDCVRKRFjYZQtcPH1BVy2GsUABg5Q3V57x2v34OA4zolCPBkycGcBtYUynNCgYLi1vbJEjA2Ha48yYWs5QSMQJ0oAC7qZZWNwtHcyExTZOGtxkqpwu7YV3Ku1zQXEnAUdPImz4VS6dAdQCEMRFB5mAkZggLExfTGE0QS2LGeozB5fFpL/pyLkKz4llN0FnT2r90UORktEsEEAYcEK/h+5GPJONI5DgcU/mJ9lW2+ig6Jf7aB+2dRrqZVpHCdoIhLvT7fz/VkrIzs6OAAbdxec//3k8//zzWL16NQYP7npAWklJCSoqKiLu48+8P5nol37KVnDpi9utrz0efdtcu90ixtkfJMXmxcLU65HhG6ABhdtc+Hh3+Npc7Of3PCzsD2zD/uBWXce0rnKAgsgIBrVwzB1zt1pxLvGDlCVV3BfhmohOhE0Vzbj2ibO45d5xeGN3CTETLp5Qifs+tR7fvWU7RhVH1tDigQJ9TzA03yBWcMVl6GxqGeKt3nVtPywaTDRIGc+zLpepd06lOccmJwMKGGaVSiFdPOOWWKCAq0JS3N11MohLonWJ6B8oqKNvhgkmKeoVqOymAp9muMMwHotxHZZY10v5ITFQUBMFCrrvrhDQgisE2PD9uZqO9/2pASB4YfJJJFkyOXLVST3GOvUKXldPYSWeloRLVoseATTH4qwKY0hlBv+wtVQ8AvoQFLAkoxOoLq/EG0rGssJoTJFjitR8smHMmNgZwrkgPRH2EjjyyOC26l63Ex7V3BceCGS5qAHicX1K6W4hEzuxVrQdBAxmBkZ/dA765RAUPPXUU3j99dcxYkRnV9PoWLBgAVasWBFxH8WHvD+Z6GcMGEzsPEkZhiDq+lDrZhz374HXSsHCjHd3rj/GQpHR97XZGgOCBb6uoM/u7ZW3B1fjnKKTYAYWWFfC43K+d+TzTTthbCvgRLUNdvnEfnhjsB6b7HZEBmu2FGNRYPVE1Sa8+EQGrl41AZ9fUo8lk8px8fhKubx1oAgPrx6FI+XZnT0hHCck85qx4oxiUWOr0LVzupl7UNeFW2EiQXrZGWRKBqiipFZ6PNmxbTTWc3ap9aL+5/tE92izPZBBY6xEYoa1CDvVeqFqw2FJGYXumGQOerJC1aDg9aRAgTMRzFWXSTJjp8pCtSxiJb1b6UTO78+6e6zPx2RIgMdji50K1AQ4wRrZMuo3CCwIjgoxOPS3yJo6lfjsDGDbbhB+vIkXhEpfot7VJ+1vXFU7ZwV0l0DZYnpaUeR5UgYMJTrZ1DgNmuFLPZ0iyVLAEDVKehS4sIllLazf6xUHpd/zskd0EGwTrHK/UIjJfcByE5keltucrpD/EqHe3q4Elg/YbvjMM88gKysrpBPIyckRXwPGhz/8YZSWlkp7IuOLX/wilixZgrvvvhvXXnstHn30UWzevBm///3vk3rvfmDAE47LBcucOEwCs6/3NK3BmY6DSHFlYGH2TVKP75TQQz+a53axxckeRL2HLLn5JLl22CsHlqMZ9aKqnuW61O48cL5HZE+lOYm6LXfUb3omeKwOcjri2lA7IpXOPPFOc10knRH7ZLLhWTxZvdkGCBPx+cV1WDq5HBeNq5TL2gOFeHjVaBw2AMGxcZrs1sBYo6uPqX0yIZGrUNZwu1MrG4OZZIRWoe+pyqS2aoI1eCYoCqjmKs56SE9oZcuTayy2wCTxWKCAwd8RNDr957sKnswJQkwkM1OhK3rcgAL6PPRkIiXpZ9oDU3jHxEaDKQIGrvY5WZFMifn+ZjYAjx+yH2w9dbYGcnv4kGaLAYvE+CjevqUxDpOPtpE2gjkPxqrpwmBQBMh5D70J7XqpJ/1RXJfovtJlllfkM1yMxExmWKag1oUsSG+GLxkTKiZnAt0hKlJgarpYKEalB0lfU/rczxwpzr9jvr9beaTcxL/3RA2QuN1b0CDzYQiU+Fl5D5kUltF0Nwn+v5yueO+998r10qWRot4HH3wQH/3oR+X2yZMnHR1pEBMkgolvfetb4ntAgyN2JCTjYcDoBwYMF0sInRP2jvpXUdFxHOnuHCzIvRkul61DiLfS74oBkNxs6VJFSI9gqHX7ebJ/FVr9TVgfeFFouIGukZjsne/QPXR609CtsMDMPlA4TrqbA6BTE6XNkpwMHsRBbNeaBo4udhViX3BzaOSyz+UTbwQNEDZLPfGp6k146cl0XLVqIj63pAGXTCrDwnFVcllHgLB6FA6VhWtrulUOQvc644DaJqI51sYXRAm74n0Lri4TETFGB2lqti9KmyM8QqdyvLABJmvxEqaphd3Wdzk6m8FafnRN3dDnsVbKPDkzKXY34tn5eGf3AZMpgUWyXQHRorNNDlDQ09ZTBhPmGDVVvBdYR2adm4mJ5SKCJmpFSMcb8yQdBAEpyEOeAIFiDE6Y/mdrnTHG0Sr6MKNGrQNbUqnfiCeCS7zWv9z2spgRd3x4vHKcMR3iMdWVY6Y5XqgLICPi7D7pafB4o16I5YToOQYEIDyOOJciWWOyRIOdUydwUBwNucDgfiII4X3UBTHJ6wTfLoxnAB3yN6g1I11nUp7nuhVa/wuHSsDkZuVKXWZ1xnvf+1659Cb6gYFTY2Anatbqt9a9gPMdZ5HlKcTcvJvgYrlB7y2Ii1Bo70XvzRhb2bmDI4BBFEOhgLpANTZ3vCwrk9HeGRjhm6x/x+c5QQmBQpTYMWAF5DZbjXpgkKDDAvYFNguy19MRr0CaK0PKGrEmK2qAsFAAwn5skST19LnNePnJdCwTBqFB/BAWjKuSy7qDBfjLqlE4WMbJcNpJL90hGDSUe6Ljhs2H5smFJkHJBLsSeMKkWJO94VRJ07KWwRN4tsoTJoGXEapze6QzzPwA+gmYYB89748HCpIduBTPp2CrelO6Aqj2T8ShLtoHYaMtOpvRS1BggrVl0uf0x+BnZXClx2RgjiGyYAQBrDMnSrFHh2gPHK11sQDkdCwS5mc3NmGxKkm6/U6r51nrbxMr7K6ElfGCpkMEh9rbYFTcVsj9alsIRBpDsr4IimwJSvjabH0k6KLeQ3tIFCU0lyLetqGfCAE+9zPBOTUfvI9/jwStTPSmDMkguKK/Qqwkz79DAocUOfP45DghYKS/BktIZBp4IWtp/pbYvkv/j/8fLZH/L6MfGDCY9O3EK2OTa59Gvb8Keb5SzMi/QVM1zvkJ0Tu4K2Bnawk082/p9zLAIErLUN52DLtaV8nTpqZfimKPnWQMIAg9h0DBivw5qBAI6D9Arn17EgRE29QqOWGkgaOMr4CHLIljCmL0DAEnQOBqxAkQnjm3GcufSsey1Q6AMLZaLusPFuC7q1pw4iyBQaacZLiC4XvHo9y7Ht0cTGreAmu/7HfnqYjf0xjc8ERpgkpuGvewTfIY9olan7XlWJ+Lgj+ezkziMaCAegz218f7LvShZDDRd/cd4/kU0Adgk3pd1P6s5U9O8ESvQQGZgqCAgu6U6/GC7ZMEOPy+3A7RboE8kdM2ieWALAzok3p/tSoXpkeDuivilhmYhCeqWQIAWeJIhlUJU+261t/daj9e8PvSK4MAU3sbdHYSPKr2ik8FE188ENmboAkaPQOouaCNtdF78HiOnezrhcnSyb5ZEr0z2XNFHz0OOuI7y18W07wPARnDrYMt0SbB8xwTT5PzTxnq7dUY/F9GPzBwMAbBYAfWVj+K5kAtitJGYVqhPYgkYvJijFJCTHrfTvhRQIJ6hojXsq+PNm/D4dYt8gc1O+d65HgKAXYZhEoOjtcK3TavrYtffhUAGThqDBIN88n8wQ6sV8vlRMDkON1arAGR/RlbbOviWJMVneFzp4hZiT/QJsLBCgdAuNJmEC6dUob5Y6uxfCzwxN40vLCyEY9XbZC6Oe2M2RGQzMnCjElmEk4kTqiDQnUb+plJ5aDaIb+j2Y8z+LuL1TVC1VN38BZewjx1WcTqVJ9M20IzGrhy1y15XYMCBhMp2ZGuVrKJOBpSIa99Dk7Aq7zdTg9ssH0hNCi4OClQwLov34dAgKyAEwiYqYJcYfOazBe3DT93b1vgTNSoKke//WXdlh24YmbJgaCTToWJKPzNLA7TBtrbWj9LUbmqQI7VaG8DglSyCUySF2pOABMxj0ceb/w7Y5GR5xoxDFPtspJPLNkz1afKvmV5iMJhk+j5DrwOd9u04y28KLe5DVlO4blqUA86LP4ZwnqbNQb/l9EPDBhuGu34sbbiL2gNNKI0cxImFl4RCQicaj4nMOhUSnCIA50rfeN86CxJ2OBhV/0bKGs7DK+Vivn570Wq2179kADoBAwczEEIpNglkIB+IxepSiZ1o0voKiw9CGqD0spkOuBNCI2MDnskcA3B6NLVz1G+8LhSZJUyQTQIWwQgPHt+M155Oh1XrJ6Azy9uxJXTynDzRC+uH7cOEze047crB2OUP3mlco3dqpiXwOAiox3QFrbLQgmeSYP7J1bnA090XGkeUjuFDucEuxkqLNAjCDAdEQYUJDJ6mnbDPBlH6xKckajNsfE5MGOIPcobt/ShQcGKkLo+vxshHU/w9GgwQMDZKcBkRp8A6gLo30DrZp3kUkUQSYEp2/vYArlIXdvrpMfOCYI0HmlceSc6qIfUPF0uKaAtVIO6dTYk8DCDl/piGiODgPnNKG8DlkM0c0WRLd0Tkz8ls92V+4UCXE3pU6SnBXr8mzbzL5xBAMDvpwl8Jvs0sYD2RST7TNH/OJN9omG6HbQHw0zpluE5gB04o3Bh9Az90XfRDwzkD6sDG84+go5gC4blzsbYgiWdhfwRpYQugIG5rxP9b7+GYQzsssWmmmdQ569AhmcA5ha816buo18/DiBw/kwc4bJ9DNxeuy2S4MDudogjZDkfrMDWIM2DghhnzcRQV+yJbO1Wq7xfCrsDIvQLXRsneVxeGQerAYJmEJ47v0UAwsg32/HDS70CDr62MAUfmtiOe16swqbD0Qm+a7MknhQZpKm7ikNqN05gvy1qXBaRHHhC7W6QE3uuOfOe45BpNESRHVvS+J0YFLnVokpasSjY7O5kauyMY7kdMpIdiMT3m6+uFHDA0gfBQfRUxsYoUBBLXc9Ew9UdAQ6NkiKBQKrdJUAgMDjiO7Jl0Kx8CQqY5LgtRqqJcj87XMhO9DT42Y01MLdvdhIWuvwstCpmDz0NregjES/YRULNBjUQPR3sFCt4vI1WU4StIlimKNGUQ7RGwtdp/5PGb5Skzzp+owB0Uv1M+maVHytMwicbpX1CrBCAZvR06FmioQ2MWsVLw8wY4VAnihDNLIt/uVD9pYR3VKw78xACqgOjCxZjZP78iFykugMGJpxiwnjAQBgD0vwK7YFWrD/3qDAUBanDMS3/moi2k9DjE2EM7GpCoEOfJNz0OjBlAAEjTsFi+POfDhzBvuAmWSnPcC1FgaskRjuk/tn469M4p9NnjDkY2vQ76Neg/8IUNR8TlF80CDTr3XdO4T2P+3HbqAL8/No2DBzQih/fug0rdpXg3uXjUdfc1aoubJZEQRVPg10l4gNqu6ykeZJcYCct54qYAqn8BEoRVLYvULly4uMJnqt+uu8xCArMCOhEVlg8UZO5iFUf7+noZH6vhepKrMFL8vk8yhdKALQu3hACBReFQAGtnKl1YH95Y0wgUIwSDEYhSuN+L475DbcMRq58R1oTRRNAAyjS5oN7IODjPjaAhnqI7twYYwVtd7lSJ+CJN5aYI7BNa2lvWxy78jbgHAMKNOVzoVRGKbepFvk703V8f1xaX6d8r6zoyeAx+VNfQztoChejRZjcdhRQmumYZG+OYCA8K5EAAQAASURBVBdKcWGAAVmzsIFRmB2geJNgmCCRltx9Eca75W0J1ctyQH8p4V8rCArGlyzD0LwZka58iZQSzH1y3cWq3jzfZaGpvRbrKx5DQLVjaPYMjMszIzTjAY4ugIHJ3WQgLBsYuD2RXQwhHYIr9NgD7ZtxMnhAzz93X2kPZol/5HIVyeBJqDceCR7LLaYrBAYm/nrkFDbdOwo/uqQIN807icumlGP2qHO4b/k4vLaLbYIx7J0dRAVPpvFEkc4phvE6HSjEYnRF6TuDNW326NORkW2aJmSKHxYnBApalaZ6Y71nT0FB5OClZXgLL0srKTUHTByc/8DESrta0shH1T6h+p2qcbImbJVjDz1LBIl8FzrbMbExWWnQ1RnQcbvoAUfbxTgqGb2BGZ5lnPl6KpJk8Pm0viZoop9/qhVmiQ6r3TiDY5JwkxG/xgqz2qdXAxktKvf1al+35jFM4jcAwdT9ddLPkH1BYS73HbtlOAwq2VIDQa/TlIlWyWQq+D3ZlZPocLBEgwDclNKiDYy4PUvUEAFFHHKVrLNorG3MslJ/9H30lxKE7k5Fef1e1LScQIonC6m+bKT5cpGWMgBpKfma3o9gDOKBAv07K14Sd1k4134GW8ufkj/UCQWXY0jOlE4vFQ5DWzj1BFGsheP1Azat6HalhI2UoroZgoEgdrS9gergGaRaGZjnuxY+Y9oUaoF0AA47KCZjGFYj1hDp8BdRcd0UK4Nnhc41wVVoPc7hYMcRfPCVFLx/9zR85/rTGFXSiDvfvRuXTS3Dr16YhIq6tJgOijw5cHUVzwqZbVlM/GaKYayTvRm1zM+SaPAETTr6DfV0aIU9FfMTTiacZmmmIvYlKDDBVeN8dYWsFKlEZ9Ixichp0cvkUyAOA0NEI5FsMqQ75QFsd2g2fHG310y1KGm9AQGpMRaahPAUzJ6GjN9WCyWh8MLPbMog1EeQUYp3nHT+bO3iuEnGiPV9Cnf1ir89JsWv6f1Irw2unEsxSmr5fS06NLbKps5vGKIxtiPhIexKqE020SALQ1aOAJz6mlgxDtMEGBCYJQrE4wVLU6Yd9m0J1V9KeEdFINiB2ubTXa6YLYtUtUfq9x53KnzuNPi8GQIkUrxZSPPlIN2bh4yUXG1bHKOU0BFowZbyJ7RpUOktyM8I97x3pQaODwzsDgVbQ2BERm63o5TgaI30BzqwofVZNAfrkOMuwuzUZXBRLxBiHxy3nYZKFoFBuz02unvjJIKG8O/DkyqNaRJPkDQ5IaXIVek010IcCu4QYd9DZzfitT+U4vsLR+PDS44Kc/CHT7+FP60cjac3DLNPt2HUYk4M0ZbGzpbB7tof61Eb0WqYaGxRqyJod67QKQBMxJyHPeU8Dpy+AX0FCoxy31gtO48vnrTJbJARoFagN8mIK07qRoxwrjsjKq5WR6oJMr2T4DC6VS5W4uU8CG5jegEMtMJ/L70JbvNiNUQAI8WoZJtMGYS1ftPVo90Zz4OzI0mN03eDffqmvh8dPOqZ+FNDKn3S+zmiszDunhSuMsZgirxnBc5gfAITKZMNLf57VfQIIxx1fgaP875mDSrV2RBrRFYu3nFFNilflUhZiULSno5a3q+2y2twQWBGpV/wUP3A4B0Vi+Z9HR5PCoJBhfb2ejS1nENr63m0ttWhra0ebR1N6Ohogj/QKm14rW21aFbnugYSTH8uD9wuryj02RLEILhYMOJ2ZKREr3BjvJYzUaNzl0MIFLDwJaUEDQwITCx2PziASWugAesan0KHasNA31hMzlpMRBSlVTC3g9onQYSLOhWz7ikuY0kbJ+kkfihIRf/+0InjpG12Y1r8xrimYXBwtHgZnA2ewafXVODZvdPxw+urMG14DT5z5QFxUvzFc5NxrDKr0/AkjtF1xlal2ws5xa+rgT2mb7u7UcnRwemGpk2Smm5az5K25wptjrqsS9MevidXl/xsfQUK+Hx2DnAlSKBjJis6QyfwRE2juo5ydUrU9cZcKNHxxSOtSaI3oJ6hKxEa3QbXY7kcd9y2fS1Wm4Q5kljYoWKC7XY0eyJLEa/Gr4l+n9TySfPrxJ/XrT+D2b881giKh1njpJzEFXY8vUNvgp4NLF+UYBhGxXA17EvWgHbazhHU3R1fZC8IkA5ga8IjoZ3B7XXaZiZMt0l/9G30lxL4R+sDgh4tovOlDoAv24lidSKUU4TX0okxqGB1kJYPoKOtHi3N59DSch5trbVobatHe3sjOjqa0RFoRSDQhub2MKINKj/WHv2jMAwDMoZhUO4U5GaQHo2RcB36gUhTJHu+Quh+wxjYpQRvSngolAJq28uxufY57aaYMQ8jMqZ3BhsOgCGaBPnZBggsU/j92lEx6VDYFVwnqzPS1uwGIHBpCuqVPuu55runuTKxEFcLs3AIO/Dc+c14688F+PcZ4/GZKw9jfGk9fnvHOvx97XAZ8dwRcEutnJFnAwyegNkxwNouVeUUkHV1wubj9POLkqprEhSY1QrfhwI/1vJ5gmQtf6ZaElcgp/u5w26HPQUFFA2ewkFU4mzIRZLBFStFkFrHoaSuzvY1Uv4U8LHE0BumgH34u7FBjx+3fSCSCYoztd5gG/JUUSeGRbsNLpd6/EhM6tRZkWzw9bi/KA4laOJ2JuUfvernYzTZT01Gpr3qz5H+f+5rbzctjl0Fj5lo+2ECHq7aj2C3KPb7qpSwR20WUMzjMp7ZVSRrcLLHbAz1H+wUgd0pksixwMewu4d/Oy2qqds5KM6oimIm3k5Fn9XvY/DOioDPgmUDg8iwQQGvmBPNatk2HrSUG76UXPgyc5GrRupjlKDBrNSDCjv2/g3nazWl6/NmojhvMmrqj6K59RzO1GyXi0yN8+UgL2MYBuZNxYCMIbEZA3nvqCQeSubUGNiMgTsMDMqaD2JXrR7DOW3A1ShKGxElXOz8Ovpnsgk2uKCrIgIJzyIwW5HtmFtkZW27GVpXhDQKXDFLJ0GnTgxgqGssSoLDsQO0+q3GndvO47lDU/Cjq5uxeGIFbl10DIsmVOBXL0zE+uParIUUJRMAPf8p9mK9fIbVfWucEUGSWu8unKCDAj2uMHlyG2JPRWT9e6ZaLKwHHzc9zowFruwZpRiRNCig+yIrtOxoMCI2Hj9MXkw6tCOm6I2vqUHB/FBdnk6HBCW7sF5srHsSHDjlXB0mc1KPpTfgxak3MKCAQIZtnCOTcBvkSv8cKmX/aOq/SbQx0fV+48rn7O4fhSkYYY3DhQjafBN0sLvDaT/M7zxKTZRV+2HskmmEvY0jao8cX9TUdNdVEWYNdoozZbKhWZ2wKJSlokSDpSGKIukrkWj3B49frZfhmO/L5TiiJXJ/9H30MwY8GXktucQCBhoUEAU47g469HQy60Ovsi1ZxesWQ+UPYPvOB9FQfwbZOUPQ1Fghtf9RY67UL6WApqZqlFdsx/naIxFAgS9O8eOAjKEYNGAKcjIGw8UhT0FHEu+CMXB5qHEADteuw9GGTVK+mFv0HmT5CiOZAgM8ItgCu3wQ9TuyDR4mATFO6g6lKz0dUr0iCS8PJZhuLYqYDsnVICnZeEGL5Tm4DBXBk0JZv9m4A9c+noMvjJ+Ar15zFEMKmnH3RzZj/BY//uNVH4JtuqZK+pTtX1OtxOaP84TNE013KnkNClYKEGCFfrp1Md5SL3XSCfD2HHWpJDya5ExSczrVcLlqNTXn7kCBLhGclJM92RGjIyFIoz6DVr3O92drmj5Z6ymAzsFBNOrhyZW6i0QG+kTHOVUechzkiTnRQUexgkmE8yfot8CTPdsnzbhhJnSK8ugbEWt7cB/TZ4Dbg9a92sxHW1o7w7T0cfVP4ERWiJQ/gRMFjfw7Y1LagTU4hr0Ypsb0uQCQjppm3Da/Y3SwpHBcHZCSwkg1qVdlHro6cnvq0dPds0J8r4Ey4Cl51sBoGEypJ1lRaJaVi3SVJd4f1JJ0ZzhF0Me/KZZ3WBrsCSDtj8SjHxhIKSEWMNCgQAmTEBUhYGADAiNKYT5lgg4EsG39fWhpqsaAonGYOOv9WPfKT/Tr+axQbk/PKcTI7CswSl0hr8OSRFn5NpyrPYzmlmqcrdkhFw0UcpCbMRQDB0zBgLQhcBsNgSOhc10v4XZhR8ULqGg+BJ87AwsG3gafJz0MJBhOxsBlgIbdlRAqQ9i/46/pRcA/Xo8nDB6cg5wc0a7asE69LPVUJrxJbueUOL096beezuQYU7IQvrPYNRSFwVLswjpJaD/ZvxEvHBuL/7zcjetmn8YdszxYNsqDTz+7HE3HmmTVnMxQGCYh1iq7t8ddKSI0JmMOKoqlEzBB4x3S9UxyBDUdbEu1a8gUBRJm5WNgXFDAkyCFg+ynp6mNCX7OAgzCMIyJeWIkLesEBbGmANKH/028ILX1TJWTcMvYeVWJbQ4bYt3e2rugMyPBBtvb2NvP1aseNzwMozFVtAgEbmYYE48nZ2slg5+HADMHA4TBIeXPlXm8xMFta9r3yJrkW0ViOkR6mqtXtnL2VZxQB6Rvn/utK/ErJzayNEPToymY16P34raixsXoSBIFOGQpynrAGnBKpgFwPS318L2phaAgeTLmdjPd8tVQZ0puEsxEn4bqFx++44BBQIBBVPkgFiiQJ+iHWaG5BWG2wN/Rhh1v/BrtLfUoHDYDo2bcaC+w9Qrdz7KFfYAZ5kC/DpDiK8Cw3CswzLpSahWtjedRfnozas4fRlNzFcpqdsqFz0z1ZmNA+hAMypmMAelDQzPuGevOPIKG9kpkpRRhXukHQuOi9ceIxxgEHdqCqC4I+QIKXivFYZxkj5AWgBD+i2kONmB9UCvJKTQb5baFTw4AQTaBnyZNhh51L2YkWzINF6MmWClq9p1tB/DeF9LxwV0T8B83HsCIAS48easLv11TjJdXz0646kjxF0828VodnZ75xh7XOOGZckC8kykZCHoJMFEz6ZDypNGPcTusxllZuRpQQAEXf8cVlGkNFYtm5ArY4eO6Wk2y1mva+niSjTcaWFsnXyYdFFypL1DLul3516hqbMWbIRvink5DjBXcr2/hBdEbmKAehbMYIj433NJKSAaAPf2sn1NwmswKmwLgtaH2vdkhUETQRkEbgQldGpPVTMQKqv1ZIiBo6S5Rc18dVrvke49R0xIWcpogC7TDweR0t/ruLWuwW21ErZTTSnrVUcH2yRSVKt97opodcxuZ8mCHrTfpq86UnoTVrzF4ZwXZAssXZgyCpnzgiIifjLmOop7ABgoK6Ghpwq5X/xf+tmaUjL8YQ6ddGSkRcFkIpjiAgVyHf5aHifDfBgq5eRiefgVGBi+XvN3SfB7lZVtxjkChtRpldbvlooFCFvx+XXMmKCjOGodpg94VemGBBQagyJckveFyAAGH4NDpkRAMwq90ovK5U/WshwgtAgGCZhDq/FXYFNDudBNdc1HqcijJHZZhDdZ5ee3MBBJM2MdIYYCrEIuC14uamaKp+09uwSP3Av97dSo+NsOHryxtwcWl2/BfT01BQ6vRQ8QBHkqhwuE8F/O4cGgW6HEwzVGeYC82gx7w8YIJZqG6WtT1bM0kc2C6KAgKyDZQNPi6eircagqPlCo4syKWXXF8ULDcXlHNQUk3J09+rhnqYhHEUYxIs6Z4CZaaBq4OuRVJ4SZjQxwdpIzJ+rAMwG3KbRDt4y9OkLaTH9M/h2qRhu8txa+1C6S+26VVMNoOmHM9NmGFlEpIw/cmzqkKxzjvxLpAuN+oS9mDDSLiSzS47w3Fzuf1pLyTDGtwRO0WQyayMz3VqThjJCYL0xFPY0GvAsMiJaM3uWCh8I6I/lKCLT6EDQyotxNlYbfZKqwnYC5tbajB3hd+g6C/DaUzr0TJ5EXhhbTDEZnsBGIAA8nFsjf0zwZwCJPPHB5USMnKw/CMyzA8cKm8Z1tzLcoqdOmhoaUCitMVbc+F9JR8BF1B0ReEdAjRBkGdWhT5nmaWgw0e4EJLhx6g5HPZGgNnJ4N8QIXKwGnsCOiR0TO8l2jRnSk1RG3OWqW7NGLR8JHbubONEhMEV3slapjU/Js7gE8+68fZY1PxtesPYu6YavzmjnX4/uPTcaQ8Dt1tl1F4AmewPBArkTBpamvXzpoF6gS6m4oo20xcCAkOXpE6cuRrnHeYDGm9QLITCA0oIMXO5JJoTzp1CWPVNGEz4nUqNKgaKaHo2QSLkxKX8XPRq4HDqbgN2f/vbKHk6pYMALUBLCsREHElz21AZqUvIzw+mYLGcVLXjw7203McMRmb6OmHya7eSY+T7WH5INHVPwdyZalcvb1UXUKgOSz+C0gJoic20cmwBlrDsF80DGQm+kKPQYB2SO3AaRyVko7zNemiyJZSdtgkOkq8P/om+oGBXUqAz2WDgs4bqRNMkPObK9R90FxdgYPP/BYq4MeQxTeiYNzsECgI6Q/kKS4EfK5OpQTJ2zRXdACN6GtzER1DQN/2enIxLPMSpFeVYM/+x8Of13LhWPVaHKteh7zM4RhXchkyU9jn72ACTBlBgIGjjCD6QFNe0ACoxW4tTHETGPB5zucqnGrdh/3tehjM7NSrkOPKs5/P1zQMRHgrMlEwcq0CYUdUJ6fEOGE/rFU1ycnXBBPKd3dtwZ7Kmbj7lpMYlNeCe27fiHtemIBXdw6Oeo2wPTUHBJHqjT7BOUEBJwZOseZ1WkXzZMx6f6InXg43WomnQ/dxFUy3QTIDPRWcmfIBQcHEJECBCVLoTGRkP1jjprI8cgKjXonSzthMkowVRtBIPQBXdxSWOj0AeFxQbMmyCOv/LMkQMO1TZH6OyrYw2geaH7GNri/ofBMCIO3xyWOssNNodDC5rsJz4gxpph8mE3r1/rq9el+a8ORHE9SFEOTtxsZuWQvjamjEf8VxSkd9xRpQY9ITDUMiMRRjcRR7BDibgWJOF0W2t/5ThOrXGLyjgvoClUpKvPPvJPfFZQyAxjMncPTp+yXhDLvmNuSMnAhOPw4x56EygU5IBCERYIE3XbZToAEBBjhITlVwRQMDt61pCAAnj67BiaMrREfg9aaLf8LS+XehrGI7jp9eg/ONx7Du8P1I9eZgeOF8lObN0N0BdjtlqC0xBApMmUEUh3IHEzEj1ZOljZNCnRgKB5s24njbThEmzs++CWkqLbIkYQBIIEwZtygCDUsmL8o2jmOaFKGJ0KIOGRHNE6KmoC2pOo/GFOzBRjxasQn7/zAe9747E/PHVuEbN+7BhMH1uPeV8egIOIZK2SdW1i1Zq3aGUcZr+nIoJludRVHGUXBolJ1xvNBA4zX7W7hFJEqF/HBrPHoaYVCg6+WDeuheR6EmV6hc3R9T+zHCGo8mVe8YWHRxqOvB+AFQLMjuDAojjR7CWQpgomcXAGvQBAKxgM8htUtAgXMuwTS1QOj0bVgjpkl9EdvUGruTZGC345N5DLNTgmWfZNsHWSbRGg/duteT1TvZIsNaMBE7u02ig7oXlmJoqd1bn4fuWAMO32ILrmZBLk1Kw5BIDMc4HMc+saQmMGBLbCIuim93WP0ag3dWBAgKeIkVsVaztviw/vB+nHzmYUl+w2/5BDIGj+xUPnCCAAIA8Uxw5DquwM2iXV9r3UL4PqIJ5lnbWMlmDHjfod1PoerMDnh86Zh+0aexe/2fhC3gexSXzkDxoBloaTqPI8dewbnaQ9h/djkOlr2GopzxGDPwcqRKp4IV0X1gygfh763QFmyRW2neHIBtkzZTsKtuBcraDiPFlYH5A27Wg4wMqAgBDwf7YDsp8oTmSZSsEtBgj1cO1kodmCffCZglKm6uQktcQ5EdzJPV2vbW/bj2bwW4e/FIfHjpUVw/+xRGl9TjB49PQ3UD5y3o70WKksHEFd2CpR3jYoMCBnUCXDklUs81KzsmUQoIx2OGjEWm0JCTD3tSN40EBbN6PT5Xr9afF6Mdr/LJSZmggCdpAgYOF6ICnatTZ3B8NR0jKd5k4qWLZSIncQIQjt/VhlfhEz9ZiUJVKoOp+sINcI/aZNvm5ksnSSLBMgY7JAj+hqtx3do8R88kGIfpvZrnQNU9nfyoUViEa2M+hlbfRgw7zpqOvopYrIFuE1wRYo76ohslOrj/CUoIFDmzgh0zTq+C/nj7o3+ri8bApV0No4JjZ2KK14JAze4tKH/+cVhuD4Z99LNILR4UCQqiSgXyeqTNUyz9OAco0G2Odk2dACCOxoC/IzAIWh3Yu/IBNJ0/jbTsQkxZ8mm4XR5xVbRcbs1K2GWIVE8+Jk/7gPgqnDq1FqfPbkB57R65ZKYWYtTAJSjKHhe2P2YilmQear1Ah3IAA3Y/BALYUvscatrPItOTh3l5N8NFf/mQfoEfkipKp0eCjZJcFjr87d22CEbvidpgFbbY1DaV7BSRMbgqZaS7MrEoeB22gVbIVfjk6gbsPjsD373pICYMrsNvP7ke//nEVOw4rnUNTHgMcwJ0Gg111fLIEyVXyRQIJgsKTEsiywpr8ZLQp3RLHGIlxjwYt8MwKJiJUmsE+iIIWHZhg7TsmeDsCgZXigR9ZAGY/JmQ2Ifek+AkRgEgSBEXzGggoel8Pf2QOpKerk4PqZ1SImEBIxkxn6H0Kcxk18ZsXNLlY6OtjpPZl7HCZ6VgoBomn/2sOo5BUaCPdXeWbbgvTIdMX4VmDYZJdwYtr6mtWY/X7FLV7C4ZjJ6EsSOn9oM6AgIDzo9gEMyxU4XdPDzWeSFLyH/asYVngt5y+0mG6i8lvKNC0RI56vyj16mxWYSaN99E9UvPwfL5MOzTX4IvPz/cfRCLLXAwBmxXFMqeg4iMhsABDqLvi9YY+JubseflX6OjuR65peMw+uJb5dPqUn5AAwN2WYQYCPu5bg+GjlyMocMXo672FI4cXY76hlPYcewfMsthUN40jCparBG6nKvtukIwiPagHrns8aYiGOjAunOPoclfg7yUIZiRf70+uUcMXrLBhaFBpJVTfhEa9sTJjonGuWCZTWUCM62lyHMVYVdgvfyOM98NeGNb4yxcgqPBPZJ0f3F4A/b8fgb+95YKjB7YgJ9+cDP+uGIMHl83XNzx6N7HWnZkAh/eJeVsBISDbbfDZEFBWHOwTMCBTCZUvoTasPSkwZcdoKBn8wP42dguSeMd0uwUBkafYMkAsNzB5NBX9X628JlJjGKNHWM1yGNpsporanQaD5HNSDY0I3FQGIl5CU5KdAYTYI7Kl5a87ij9sNXx8JDVcW+DvgZ05CRzU6J0KzLjhDoYqrt3B1h6GmMxXUAJvQVolsTEPRITOgEUcxwRoLegBW1oFptp/mRGS1NYyt/zeOU//t3rlK7TelfBqZUIwVKZPGNPp/SIa6UZT83f0AX07Qirv5TwDosUBZVi2vrsrgFnK4Ejzr38IupWvAFXejoGf+2rcGVkiaZAEns0GIgQH+rVciCNK+nOWgLd+miXDSKAgV0+CFpoOVeBg8/ei6C/HcVTFqF01jLJvZKPg0osiN0eny5XOIBGhJiRwrdBwzC95JMItLTixMHXUFa1HSerN+Jk9Sbkpg/G2IGXIjd1oP0CQIcAAwvtwXasLX8Y7YEmDMqYiEkFtkDKabFsfna2Rwo40F+62V8vD8lwZYf1B3GCL1cZPI0dSvdoz7YuQY5LK+PpfceTg8/Vmeod6ZqE3GAhtuNNvFy7FVc9MAK/vW4Qrpx2Fp+84pDMXLjumWaktWfYbWyvSNtgd6CAwWl4PFE5SxDJgAITXAmzE4DTA6mPIIXfVXsiQYFz0mAyoIDqdbaYcaVJCtqpC+BJlq1nTbYglJoLKuMpyuzLwT5U+puhSxTWdcUE0F+AMxRYskl2+h/HQB8JTUrszEgkGtOwAKvxgggBF+O6mI/ZaVsd0x57UjfHTTJBwDRMjZWaO6HUCExAheKg7p0XpO5OfQSPfz02ulmEojx2meD5N1aO09KRoFftiSV2Ezql8//c8x6kSBHRa198wkRxXxHwGItv+lPM7GbGiQkyCivxTK+3QX+8zaWE//qv/8Jdd92FL37xi/jVr34l97W2tuKrX/0qHn30UbS1tWHZsmX47W9/i+Li8Mn25MmT+MxnPoM33ngDmZmZ+MhHPoKf/OQn8NB5z46VK1fiK1/5Cvbs2YMhQ4bgW9/6Fj760Y8m/Rm9vgBcKVocF66sa4dCcx9vVzz6JBrWboQ7JxvDvvVVuFNTbX8A2/9AEnC4HTF0sbv2lNtCINrHIAoIRIIFvq8l4sO6o/tx4sWH5YMMueRm5I+bqZl/u8zAxCuMgdsTKiU4gYFpDGA5w3Q1sGFs1MRrMDpwNarK9+L4yTdQ23wKG4/8GSmeTAzNm41hA+bAH9SJ5M0zDyCg2jFywHyMzlsYaZoUokuMN4KznGDa1Fyo66iSW1nuAsDt0b9zCBPDoVAWPI7disN6XJhrXYlMF1u49E6hToHDgmKGZSHPXYyLA9dhE17DEf8x3PR0Nn54eiw+f9UhmbewriANn/57LtadWy4nRM4tmNDNnAImfK4Ou+qrTwQUmOBKnGZDpGvZPz9bLY3p6mZAAWv8XE12N2mQGgSu+lhfZ+eFc1gQT8hM/iyF6CFOLmEuTDlhsDUKa9XL8nyOJk7US6Gr4KrbzFfgCj4RBmIqFmI1npWxztQdJFJrJvgwY6CpXehNfZragiFqlCSsWPbRpPTpTMljgRP++jpGYqJ+b+xDriqQMo8eWhV/eqEW1LbLsdeKJvkb4SqeF4JB/o4rd7aHMsFrC/WuEzxBAF/HrNZ9kth1cmdCZ0mIyZ0tjGw/pRg4BRlJlYComeBnYwcQW3jDbME/Waj+UkKfxKZNm/C73/0OU6dGep5/+ctfxgsvvIDHH38cOTk5+PznP4+bbroJb731lvw+EAjg2muvRUlJCdauXYuysjJ8+MMfhtfrxY9//GN5zLFjx+Qxn/70p/HXv/4VK1aswCc+8QkMHDhQgEYy4fYE5GL2vb52TFUkhfy7v6Jh2174ivIx4tv/BpfHqy2IlRUmBGz/Aw0obGBhWAh9V7grwbZPDoMA3q9ilBIsVG16ExUrX4DldmPYzXcgc9BwmZisdQfakYm3lQrC8hAYuMLlBwNM7MGQuqygBBy4zGd3AYWDJqGoeCLamupw+NhyVNUcwKHKlThcuTpUyyMomFC8DENyptqgxXxBM/nR8G3BqHKCbYKklDj8MXK9xdpgyfhKhWY/6DgZOIQDaoteYVpXiYbAbMS2YKuc1LI5KrmLMdA+VwoWBK8W0xi6q31983bsLp+F/3zvAUwqAp79eC1u+nsrDh8fmZCDm9ElsM2wt6DABMVcs9Ul2IzXpa1unro8ooc9EhRMxxCrcwmDrYUUjXGFzfd2mgbxhE0gQIOmYgyOSCp0AqQDIl+bwjOCAsZMLBU3Qibzxeo6eKzEhmfFN0jSinbOvkjUgIefc4KaJSwDPwdXkF0FrabD4IPuf8m5B8YKtgESILFLYYgaE9p2FMgZSr8rq+PeBF+TLoxkCdipwWBph6UYWo77Q0k+TNF3+5p2eg+v3PWKnReWXVKQLiU2diaYmIvL+9TpMlZ3itZM5ElbMDUo/I7kR+g58U8Vqh8Y9DoaGxtx22234Q9/+AN+9KMfhe6vq6vDH//4RzzyyCO49FJdP3zwwQcxYcIErF+/HvPnz8crr7yCvXv34rXXXhMWYfr06fjhD3+IO++8E9/73vfg8/lw3333YcSIEbj77rvlNfj8NWvW4Je//GVcYEB2ghcT9fWa1vZ6AnBFAAM7YdoTAo/+4k9o2n8c6cMHYvS37oASw4OArOadQCDMnjvYBvsx8ggXhJlQXN0HrFDXgbYEYGKP0h0ooOyFf6Bu+0a4UtMw/PZ/Q0rOALt0ENXCKKxAEC6vN1xKMAsCe+FuOUWMZoIy8zd/71Jy7cvKwaRJ74XqCODM2Y04dmYV/AG9zXLSBqF0wBR7lkIUU2DQkdO/wJQQbFDA3zUFNGWdZkoJ2upRP4ZoJxjEscBeHA7qdqUFrquR6jJzHnQYx8Iuff7txxOsTVHzhZpmF8MDpzfg1d+n4JFb3Lh4qAfLP5iBnz01CKv2dndEQ9wWGfQe6AtQ4DTXmaEW2U6Er2OBulK8/knxGlDAxE1hm2kZZGmA12Q7DK3L5MsTPAWCBC8sd8RLWiwv0B6YK7VRmBxRNqApDy1qmZT5mZj8ehJsg6RBEmzXxGQTDEsIp9QRcUpkC1usSZUGGPFzavBxaa+GOzmD247bgYCDEynZusnSBgVyiVgdx9vuLNuw80XT96zJs0bfKvuZFyb6WFQ920R1OGvuXLOnyeeJXLmnC6PGAVKxvDpiBbcxQQH/7ujDwA4d6hxobnUhguUJ053C44PB6aAHsRMnceSfDxi8g+KClRI+97nPyYr+8ssvjwAGW7ZsQUdHh9xvYvz48Rg6dCjWrVsnwIDXU6ZMiSgtMNmztMCywYwZM+Qxztcwj/nSl74U9zOxFPH973+/0/1uD2vznYFB0B/EwR/9AS0ny5E9eSTGfO0DsDhpMGg/1kxSlB8McxBmEIxewbKL+5bLgtcbtBfYtmCQICHI25b4EhiTIxUI4swf7kPb8aPw5hdg2Ke+JEnflA9066IBEqabQVEhqMWHhnEwi3LetksIofKCY2ZS54sbflcgBAr4KnUtZ/H6gV9hTPESDMufG2mNLInYUTpw2i0z7PICzZJk3DJLQsY50ZQa3C4c6tiG48G9crpb6LomTEk6iAHTashBRN2HZi54wuEMeCaqU01tuPwh4O83FuKGyW34j5t3IjO1Ay9s7dokph7n5KQbTeX2BhSYoMBtqpqPnVgvKve56jJpv2Si4Eq/BtUiPqOC2wQTA62DaRs8EEMSdibUQ2mWh4Rl9C6IlZQr1GlJRj2ZxMgpjxsdbW7JuCY6Yzouxpt4Tqj0JeqGTgmOg6NMOx27D3raLREv2HrIYVM85sxqNtrqmNuzBQ1otJO9pvB1sjfOjkZNHy/Cad5nJ/lUAUQGIFBkS21JX3sIOMEVBZ+mTZDAlNMPKezj9+vrtkEyPMYwySkQ5XW+KhLo26QaknYCvZBh9YsPexfUDmzdulVKCdFRXl4uK/7c3Mg/YIIA/s48xgkKzO/N77p6DFmAlpYWpKWxZz0yqHWgJsEEH0ttgsftLCXYeoF2P3b/x31oq6xFwcKJGPuFG3VNXQVkYdsZEMQGBwQSyu7F522+DwGFWAe4eG0uzI/6dqC5Dafv/gX852uQOnYsSj7+cQRZrxfgEFk+CJUhbCre5fOFbJdJbMjBbACBKwwmtBeCFgzGAgaHDjyHijNb4fGmwd/RgrycESjKm4RDJ17GgfIVOF69EVOG3IgBGUPCHQkENRREIJY3gtYctAdb9DAmGiUZO2bbnnlf8zqcDuoVxMKU62XlEtYfWBFOe6JJdnviahfDjabhB3AFxRMfoy0AfOxJhQdaS3HD7DP40nX7kJ3egb+tYfufFfPEyZM766B9DQpMcETyeDVTWgaZuE2we4DB70zKlWI36gN6sjI2n9fYA3PQVbygUc9q8TfYg0I1KCGbXqNx4GrTmP30ps2NiXCMmior12h3RpZZtCWwMRWK787Yk2BC1HMyBokLJkGB2Q+cfxFQXSd7I7ljuucKnqCSxzaPQwr8OA6Kg8RiJd316lUBBWyBPI0jAtAS9v5IMrRXweudRhpT58Btzg6fZMyeEgGN4fJSZ8MkGpYRGNBkqi/mMfRZqP5SQo/j1KlTIjR89dVXkZra+zpfX0ZKSopcooPJ2uMABv7GVmz72u/RUduEQVfNxOiPcyyyYQnspBrRweAoGdiCwZCRgVj+IsQY8H0MEAiDAvMYC20V1Tj5k98g2NqG3CULUfSed9mPVTarYIFaMsuvRCOgywg2Zc9XSPGJwDECFLjDnQ0CJuQ+/X6yyA+YiyUlhH0b/4z66mNIzcjHlDkfxqaVv0RKWi4GDp6JkpLpOHj4BZyt2obNxx5GbsYQTBt2M3xuAjHbRVHQihVpmCQRFJ1CuqdAz1yQjaV/v6txJcr9R5BmZWF++g3SlKSZB7cuMTgQAFe6mcjtqqHBEXpfmFWyUeRTNHZOVeO2F9rx2+YR+NDiY/jYpYeRndaB3706thM4YM2TQS//vgYFLBnw9Slma3KMWWaQDSjEQBki09vVovm8XNHStbEre2CzepulFosT5BasxiJ1bbeUNL8Lk7WZ3dAbsx8TLHOcUcf07AVVLa6CZhSvad1M9n24LSjMbESN0PpasNdsi/Q0nR/3uQgIaNV1+VT4kGb/yxTfBF5kRHkPY7t6y7bjHiwtkC7lluRMgOA8/voijA9DrJHGnPq4T22RElpfAQPuN6erZizbaAJQTl0kOODn+2dxPkQ/MOh5sFRQWVmJmTPDYi6KCVevXo1f//rXWL58Odrb21FbWxvBGlRUVIjYkMHrjRs3Rrwuf29+Z67Nfc7HZGdnx2QLugoma0nYsNB6vgGbv/wA/E1tGP6+BRj5PiqOtf2u0dmZGUvOhB6pKbB5B1k4O9gDF+B2s5RgXisMCnhdv+8Ijt/zkCTCQbfdgAGL5glDEcEouC0oWjgHLb2YZkL3W1DtWnlupfrgTw9rDLTQ0PGzzfKbEoT4KdgsQSDYhj2v/xZtjeeQXTQC4xd8GI1VeopgSkaeWEdTADl2wg0YNnwp9uz9O2qbTmHV3nswJH8WxhbbQiyT9B3zFnjNkwJXJemeHFghYGBhW/1yVHUcR6Z7AOZlvRsuYT+iHBhtA6bGQK28Rq5VGNdK2d4REWOeqbwnoOAajiel+dYV2KW0KPGTbxxCXfME6Vh4z4ITyErrwC+em4igaEl0kErm2s+smnsLCijKo7seBYPh9kEbUFKUKC2E9ZJ4+qJt0Fg98/OyA2Nsgo55pOZpE0x1POl8tvHFCwO+jFAy2dkNXQWTyBq8JGO3OQ2S257bjfqI6NZN0z3C1X4j6uU76z57LdojaImlxucKVgvzdMLnKj8N6TiOgyFmgBT/Yit2+2JfBLsdyA7QTXKKNT/CMpgDjPoSGJhjgm2JZAdieWnwWKFLJ9slezuPwTnfgcdHfhcdL/QJIVNFUS3LgP3x9kafc1OXXXYZdu3aFXHf7bffLjoCigdJ3bO7gF0EN998s/z+wIED0p64YIE+6fD6P//zPwVgFBVpGpIMBJP+xIkTQ4958cUXI96HjzGv0RNg0HSmBhu/8jCCbX5M+NRSDL1uhs0UONkAJtBIz4PQdQRT4Ej89pOZCw1jEA0MKldswqmHX5RZBKPv/DAyx40ULYN5DBfPkaUHC8oTBhUdtdqECOkpYYOjgF06cEUJD0PAQNff+XNHaz32PvdrBNqaUTB6NkbMfZeAjuZmbR6SmlOoOyrssoTPnYOZs+5A7bkj2HvwSZw6txlna3ZiQunVGJg7KdyyaN7M5UJDh36tTK9mDIIqgK21z+N8xxlke4swJ/dGzS34AyHfg5BNpLyWhYqAptW7WiFKt4QNGvyB9hAoGIbxInbKhF6lUAXtUymiMP/qht2ob52GO284gGXTzyIj1Y8fPzEFHQG39EqzXkxVeE9BAZ9DhTtPdJzMGD1mmYyAOL3ZYkDW/depV0RkSLOdWN0IiYYZCkWgwRJEd22Z0THKmoQqdVasiuMlCO0HoRkZfv7eOgBGB1scR6jxAlBoGUymgPuRK+tN6g0pjTDh8P5Ywj1tkqNr+Jl20qcwL8Oe68CfYw3Ton01QQE7FLj9jCsgV9N9Hc7BQRT/meDnogskhYG9mfwYHRRVmpkg8SZajsQkAQZHsLdTGS3ZoECUrAyTfnfHB8tcfE9aLf2zAAOrX2PQ88jKysLkyZEOYBkZGcjPzw/d//GPf1xq/Xl5eZLsv/CFL0hCp/CQceWVVwoA+NCHPoSf/exnoiegRwEFjaYUwDZFMhDf+MY38LGPfQyvv/46/v73v0sbZLLBUkLTsbNY/43HEfQHMP0by1B6ybhQ+SBEi4dKCXaqN54FiF0+0F4I4Q4H/s7jCUaVEoBjf16Oylc2wZ2egsk//DhSi/IkaVLjGORjghZc9hRCAQlOcEDhIl+kTU9AtNJSBDA4Wf1O0xk57kDYeUuwQfO5Mzjy9O9kOuSgOVehZMoiBAkqXAQGejRwWv5ADTjMaxIguIDswtGYX/wNnDq2GsePv4Hdp57B0co1mDb0ZmT62E5o5iQEUdum9SE5KSWy/tp4/knUd1SKg+LMvOs1/CINYvQH9hCnkCcCgiGXM5qgdBf0X9CggCuiSTYgUPYJTgMHes0THHB18p0dW9HQOgvff88BXDy+Ev9561Z877EZ2NN2RB5LEJAMKGCtnSf6SpwVUZoJnvg5mZF0PnUCukPgJRsUTAqJAc0MgwPYhmyV2yMBHz8vBZd6fPTguFbP3QUn3K3B89iNTRigCiPaAY1JlNEtxBIzJvuZSe+z66IBNbL6pzsj9yPD+DKQDeBFj6bSTnhM9lzx66SfLdJMUvs9oaNZd9dllzEyqIj7ieDuEB0Je5kko6NSne1ycBCpfAIDti/SjbK3cVDtCDET8WaCMKh/4P6m6RW1AT3t+NirNsv+ZKfMeGtGt4/n9x+gCuR9+XfUl9M2exyqX2NwQYMthZzwR8bAaXBkwu124/nnn5cuBAIGAgsaHP3gBz8IPYatigQB9ES45557MHjwYNx///1JexgwavecxJYfapOXBT++HsWzSKk5Og9MOEsJnVoTo0CBAAJ7tW8/nfOH3O4wCxAIBLHvJ4+hbtdxpBTlYMZPPwY3yyAqKMlfNxrojoVYugS5X1gEtmJqYODJSgFSgwj4LUcJIawxCA1isrsU6o7uxann/yLPHXr1rcgdMVmDAk5wDABtzbX26+YgCAcwcNubKEV/7SFjl6C0dAEO7P0Hqs7vw7pDv0dh1hhMGXxDaIpiU8c5uc5OG4h1ZY+iyX8OhWmjML3wWkd3g9EkGLbBARDsFjhWd2VCZBdBl8Z16iW9grUmY4RrIrYFdD/4kCg7YyruvSpFRH8/O7AZ9X+dhZ+9/xBmjKjBzz+8Gcv+Wg80WyJC6w4U0MyHYIAnNDN0iGtVrkq5MuPzIr0ECApeDoEXp/qfj5ujLpUaMGv8pNCT1RlwlUbTGFocT7Wp6Z4E33eydE2slc9iph8aNoLAhyu77nQL0TV+mtkQAujk3xy3vs+07xT6keqnCRK1Iu5Q723fBev8WnhYirHWtE6zBPqCWjdBbw+u3nmcxDMw4n0cBS2TLVWNtLj2NNgCShYgmpmIFwQlLDkQuEzvgZkTu2m4zQjWknn+aEzGJrwh7aGTER+89Me/6BAlOhQ6g6LE3/zmN3KJF8OGDetUKoiOpUuXYtu2bb3+fJu//yJcHheW3PMu5E8ojg0K5A6HAD9CW8COA/2zLt1rlsAkcFcEY6CBQUdLO7Z/9SG0lNUgd/IQTPve+2QyIjUFekQBgYEWHIZLCJFAwdwv79/eLG/hzUiB1xsQ1iDA1/C7oAgSHCJFAwzOrVuDqtefF7fE4R/4NNKLBgsooI5ByhAuoL21QT4XUt3CYBi2IQQKbIGjNCSkeDFp6vvRXFeJPfv/jqqGQ3hj/68wsvAijCpYiOYObW60vuwRtPjrMDBzIqYULguBAqXrJeE+S2lnDAMF/shEn0uVu5uixNgCsQ4BBS/oHn1rCka4dLKl9z1rxB6XnVyN/wRrmq5R8AZ90q9+7/FNqPvzbPz6tqMYO6geL90ewA0PZ2BD/audQAETO1dypPyZ6EzyonkMkwpBSDxVfhgU6LbBWJMWKc6apOaIbTJHNy9UVyW8+t2q3gxZ9iY6XbCrKLIGiRsidRk0piEIoPkO2QiCnglRJlFM/jTM4YXbRrfytch+6azmt0R1r+v6VOznyGqWw3XITrD2TsDFaZoECfxeBBAXAhTsV9tCq+lp1oI4swR29JpaZ3A1rL0edEdAVytjOlOuQRkOYGuPvSWqVbkwUNyG83F5QscSdSapKl10NsmKAcmEaCtnn5glJfNcMmQE7MZY7P86rP5SwjsrXD43lv3x3cgZRhTuSDZRbIFcUWNgP0TbDJuWA7sFMcQU2F4FTmdEty4lNJXXY8OXHoa/sQ2lV03BxM9eoevittBQgIHLkiQdlNd1sAQOQKBBgd0B0Kb7270ZvlC5wiViRYWAh69FkGCFgEHV00+gfsM6uNLSMfyTX4QvIxdB6VgwoIDsgIK/tQmWxxehLxDDRwEF+j6XbY5k+fnyFtJyizB39udQWb4L+488jyOVq3Hy3OaQ/wNBwZCcGZhQdFmED0JodELIotExldECagNabDrAXaLLDYwwSpPgwKe31ItCy4+xpmG4S9PazcFGoaC56o8IoxJlu6s1RGYWcGDTX8s2oeHBWfjdh45hfAGw/KNBXPLnJnTUjRAxmEkeXOWaoCq9CIMwBKO7pT61UE+DAg5j7qptkKKwOnUep3FYVpaJrLq44mUfPF0PZ1hduwYmE+w0IBtCrUaNqpTZC0zipOt3qnW20E+b9UQnf9b5Dd3PC0s7emxzPrxdMCH0UTC1d5ZXuG/ZRkkDpotxDfoy6GpI9T/BSazVNFfuHGxEcNBb1oDHAO2wCXCmYn63pSIeU9lqgGzzntDrZNt24C3HSOPE2Sceo7SbpgiSzFYiwbZi40ZJENITLwTOL+GxdqF0HUmF6i8lvKOCuoIVn30W3kwfUnNTkVaQjoySTGSVZiNnWC4GjBqA1Dy674WE/OGEJREJBkKreycwsFmFun0nsPGup6D8QUz41GKMuHGGOBaG3YVtYKDCjEFkW2O4jMD3D5UrWnWC8mSmSLmCv6dq31zLnAa3Bb8fOHvfH9F68BA8BQUY8rkvw+326fKBCBNtUGB3MwTaW+FOSdUdCWYxHwIFWlAZdNvtk34LQT7fLqkUDpyCgoKJOHrsFZwqZ5eJ3hLD8+dhbNHSkBti2CCJnLGgInuz2mUEfk+XC1VN2vGw2DdCMwt8I+PHoJQGBUENCqi6H+amTkS/1EmlRwgPEVU390n4c+rdo8FHnlWMucFLhcJ89twW7HsgAy9+xMLoPBdWfjQDSx44jbUN2gGRYja6DHKyHsc3J7oaMup9JlD2qbPU0V2Mt6ajXp1PyHCICdqseGd0YyWcaPAzE2hwpDVd8glomKAYZAx4YTDpMPkTKOjknyufg8m/J4mB7njUfzidBsn6MDmTpYk1mrinUa5OhlwNu5rKqKcfnuwVa6A7Al7VABZTxMMikaDJEUs3LHvR/KknXgV0MkxWK8Bj/AB24BSOJAQM9Pu9IX/zBFg91QhwgBSBAUWnfa3r+FeI1atX4+c//7l0+3E0wFNPPYUbb7yxS3b+kks6T97kc01H3z9NKeGfPQaMyEV7Qzva69vQXNkEtS/2EA+WGzypHgEQKTkpSC9IR3pxJjIHZSN72ADkEEDkZ0ht3ACD0DwCrpTL67DhG09I4p1HLcOcYREsgbP9UWYLIZ4JEpkHu6xgfteqGQNflk+cHJnkDWtgBIzK34EzP/012iuqkTZ6JAZ+7g5Zw/k7AFc7HxsJCsgEcJJjSm6+bpHke4rGwIKLAkyyGsYHgSc7r237TGJCAAJFk26UDl6A0xVboJQWjZ2u2YGBOZOQlVoUNjmSWQ8qspQgntFubdykFGoDFC9ayKKoMdTSSFSi0O5vwluB53UrlGsGhrpsO1UbvHHMMFcuOe58xzDXMCNkwBsjyxqA+epKqaseqm/C4gctrPpoOsbku/Hyh1LwngeLkdEyFjlWXtLHWhgUaKFeMqN6STVTjMhEma3ykG91nvC4W20S6pWUO0/IyYrudO2/BudQISOZqVonCIjnxc8kTRFlDgoEAPRlzzkteo07XvRQJCZIGj9FjybujRMfJylGuxrGir5gDaj90MO7RmKYlbj1b7Y1AGkqA9WoSNiRUAtmX5M2zYmY3SMjKN0ZMUS0AudURcxjL/r9jDdCT10vGfx+dCzlsUiPjAvl/PjPyhg0NTVh2rRpIrDnPKFEg51+FPabMN19iUY/MABwyx8vhS+TAjmdKALBIJoqW3HuSB3OH61D3elGNFY0o6m6Ba21bWhrbENLdRPOH9BiuuiwCCBS3ELr+3JTQ2xDS0UDPGleXHLfTcgeOkCGMGmmwAxcCg9eIiUv1LqDMZCSu71QNqDAUgQhFpQ9AyIlO0WcHE0Jgtcu5UJrfSMOf+/XCDQ2Y8BFM1Fy23tsoBEUMMDE7++w4CJIsDsOAtINEIQ7Mxv+FIoIdBmCoICljvCMBZ1ig167HKAfKk6PDU0V2LH1DyFQMCB7BGrqj2Pd0QcxpngpRhTMt1frHDvtMEMSwGDXFmyjpKZAPVKsNBt92J0KriBag81Y28EWtg6Mc8/GULZChagdgixa1jbJqjW0j2J6INjvZ1lIVRniPc8muLJGhfc+nI5XPqYwobAdT9wGfOPhbLToKbEJB53ywq6DYxMW6jlPzrRKpi6B0xgvUldFrMRoRlOOE6LGJ+XeXbIkHU0TGZYGuOJnWcQ5iZHBpEynPtL+ZEfYBUBNBcsmPPHzu3DVbNzy+iro87DdYdEbPRSJCWO4Giu9/VxNspujp9Gk6kOzFubiUpkV0V30hjUgeDPaj2hdRiLB1klS9Hzviei+9ZQMQ7vNTvWGXRmNqQIMqBnIxxXdvh9X+7G8EZINMhQs7x3BLkxI4PteqLBieqIm93znjJ7ujPcYV199tVySDQKBaHfhZKIfGMgUPj98xrXIdgNMHeRD/qBCYFGRba+rxBpH5gNRBKeokrbQUNmK6sO1OH+sHrWnG9FQ1oxmG0C0N7aj9XwLag+GAUSgI4DNP16BYVeOxsgbJsKb4g2JCiNKCaT1WcuPYgzMZ5RSg92qqEsJ2sfAl8NSgp3spTRgoen4WRz40QNigjToPZei6OrFCPgJSly6XMGVv4gcXdKSKAChHQg02EOm8vLgT3NJLmb5gJ+JgEBAin3RIw80mJHyggU01J7Cng0PCBOQPWAY6mtOYOzoa6A6/Ni69yEcqngDVQ2HMXv4B3QSo6BQtAUOdE3qJBhEMKBdE2Uqo1soCWEWWgOtWNvyjICC8d55GOIZo3cQhSB2kj8LbdJEwx2BMJ1AgQPKs/wSYALX45jZ4ncOZdhRV4XPPDwLD9x+HONL6/G9W7bjW3+biY5AYitV0+dv2t/GWJETRxMNJuBpaqEAAw5culhdI9uO4jw61JG+ZyJ1ggJdBqiUVk/S/xQBagFg+HszARMIcdVvbJcJpJyvo9Xlx6QjgOp5sglMAvwspkuhL4JtcZvtiYJkSeLR3iNkNPERHMcBDFPjelSqIOXtnOmQqO2zkzWoVKcTLgUcVXtC4K2n45rpY0BRHl9nvJrRJQDkSGPTqpoMOxUruFonU8Uul1bVGhNAmfejayP9L/oiyE54lJfTKjoBA9om/6vFkCGRQPK73/2uDAfsy+DgQXb80SKAr33RRckda/3AgIjN8sNnry7DY5cZJoEoeEJ6gpDcTxLygCIvcosKEVxAAGFF6Ar8QYUXPv8GzmzSormMkgy4U9yoOViNmgPV2P6/65FelIGBC4Zg3C1TkTUkNwQOzIo7JDIMTTbmzxyrrJO+TGckQGjXjEFqlheWrTFgAq/efBAHf/mEPHn0F25C3txJkviYIEVs6LLLDZZL6H+57bYQ9LrQfEj7DniKCqB8VkQboyR/BzAwdgNSRqBQsPwgDq5lG6SFiRd9BCf3vCq3U3MK5HEXzfsadu7+C2rqj2Hl/nswa8StyPFxFLMepmSjI7t2AVS16eSenzI45KzYGmzE2oYntC1u2kUY7BltGyLZJQYBB0BZUGsCxCEvBlMQmo7JZ9qgINR94JqN5mCD9Ok/Wb0VmX+dg3s/fAgzR57HXTftxI/+MU32d1ehjXI0KKDGwbS/9TQ4ZVCb/bDSvFqoViPOm4g5kii54o5XBmANnaUG1v9p2sTe8u4oWtb6jbqcIIDdAGzB5AwFjs3l1MG+cDpkomYJh8JF1tC7KtcwIY5V07AXm8UcajKS82gI2yprij3ZmQ6GNeAMBSbe7oJ6iKPYJwAsGrwlGxQDkjHgvmZHS6w4pHbaI40H9KpV1RnUQ7AThV4OUzAv6v12h97PuDb2VVBfcBpHpauiwHZMPK2Oyn3/aqWEU6dORdD88diCnsTAgQNl8vDs2bMFGLCFn917GzZsiHAj7i76gQFPlA5g4Nh/WiOAINw2KAgNWDINdKZjwHGbvf4cmuTvCOLxj6xA1YFaDJlTiFObqlAwOgfX/HIpAn6Fg8uPY/+zR1G1txpHntkvF0+6F4VTizD6hokYuGAovB4OCdLLZ3kPu2wQSujKwRy0aV7bm6rHLxM4nH5+M47+aQUsrxtTvnsrskYP1kOg7PY/0umWDQo4AVLf1qtxfhN/jQY0nkEltn7ALiW4nKUEY26oQnn8/LEdOP7W4zKhccLldyArpxStGx+D15euTZIILCw3pk/7CE6fWo9Dx5djw5EHMbpoMUYWXeSYsRDe2lWtOrmXpI2R9smWQB3W1v5DQMHEzCUo9Y7WMxUc7Y0GHHCVLM527tiHu0nrGhS8bIOCkZjo0quTdFcW5gQvEfHWw2c3I/uxObj71v1YNKESX7p2L37xPF3jrG6YgiYZ1zyul6DAuVrmSZiUNC8MAo/NIvjSQdMflgG4OmXbH2WSPZlWR7c9U+tfKPX3MIhgDXk1nhXFOlsZe5PsdKJ+Re9TzA4lgK6C1PhRtVdWz2PVlE4lh3ih/Rdes50aJ/WIYk+GNaC/BQEM9wnZlt5qIugeSKEkixmxgMEZdVSaKvVI485itJ4G9Qk+lSo6FmfrIkHPCewXNqkv38/ESEwWEMCZEXQK5fYkLKYmpKu5Fv+M7YrZ2dkRwKAvY9y4cXIxsXDhQhw5ckS8gx5++OGEX6cfGEgpIQBflGFONCgw9zHMtGDNDji6DwgOOG+h2Y8/v/d11J1txoRlpXjXT+bgv2Y+DY9bsxOs50+9bhgmXzdMHl95oBY7HtmPU+vLUbb+jFy4MmdHxNDLRmLsTRPgzUiTsoHoCswqn8wBfyb93dYR8kkgUDh0/wqceXG7dCnMufujSCnIEZ8Awz5I/pdxz7QmpoeAKU24BHjwduCcTjjeYYMQ9JDF0F0CWv+gyypmNEKAw50UULV3Lc6ufR4ujxfj3/V5pGXkC0jihMasvGHy3WGzCny9wUPnY8CAUdi26wEcrlyNqsYjmDX8NngEbZg3CKKuvUL87VJ92WjuICj4O6ELJuZcitLUsZB2C3lhh3gRQdQFa+TEUWCxTTH+yp5ai3XKMAUjMdE927E6UMi28jBdXSy1zt8e24ysJ2bhh+/dj6tnnkF9qxf3vza282vajoAsSQzGSOks6GmQuq3ASeklpydAeL6C+UP2isufLgMUiR6gL4SAPAGHW86uiFnr56qdK3a2D0avIhMN4ygp3hOYnFSiZgslV7Gc5cDRy4kEmRYzNyLZkdLJsgYcH7wtNE3wsoTBS1fBfTtYjRSjomi2hvuMQC16pHFfBcWmBCVmqBMHWxnQQ+HmhRh6REaL468J8jnpdBvWyPakwJZjt9+WUP+a7Ypz587FmjVrknpOPzCQg84wBuH956KmIAYoiCglGEMjmyUgW9B4vh2/u3kVms63Y/6tw3HVNyZztp88jyV06hmEVbBLEbw9aHwWBv5griT9lvp27Pr7IRx+9SRqjtVi5x+2yCU1Pw0D5w7G2PdMQc6YAl3nD+oJi6IRaCcwYML2Y/sPnsG5LSeQVpKDBfd8EO60FD13wdYdGF2e7hog2KDWQAMMGessDAIQqLHtkAekiEtjoMOSgU3at8BmDIy5kVehcsNrqNywAq6UNIx73xfhS82W8kPLec08ZOYPEYCh871tIUmwVFSM+Yu/jj1b/4rztUewav+vMJulhdQS2zjBhRZ/PVI9mWgO1mNt1d8QVH5MzrsCA9PGanZBgJ3xdTB7ETgVtKcimi6FTsHvH8S64EvivjfIIiiYEx4HbV7KYq2zBJOD82QU7c/3b0POc9Nx57sO4H0Lj6Oh2YvH1o7olOiMI+D4JERmxhiIRkI1qBZg4VwVsRTAbgCWCXjy5wqbJ0kOGurLkzId+ZwJLZ7AcLA1Snz++XlZ4ki0Tm/CuCfqUsvopC2VuYrNUrkiomTSyOrm/Tk8S4v/SpKeG9E1a9B5jgGV9EbDwNbRWNMEexocT8wSEpM0Z2AYIaXZZzRBuhAq/qEYa88xOCClJCPcjDVCuS+DzMhOrBemh9uTo7bdYfu4/ogT27dvlxJDMtEPDGzxYYocX7q/XUCBvYGc8qyQHs5ej2pgYOsKiNRPt+B/3rsWbU0BXPmF0bjkjlFQikYvOsN43EpAiNYiOEsRpgQBpOUCSz81Bos/ORZtAQsH3yjHniePoGJnFY69dEgu7lQP8icWYsQ14zH4stFwu9wIcrqiBaz93F/QeOI88qYMwryf3iSrbE352e9lGzFxxc9WSDIGYplMkGD/HBQ6HvDXN8DyuLWY0X58wO1CsMMV2ZHgAspffga1W9fBk5GFUR/5MtzeNAT5kVxA7Zn98no5Q8Yh4GOroz3imaCCekMpLXgxdeqHcPbURhw89hI2HPkTRhYtwuiCi9AebBEgwKmMa8sfkdtTCq9GSbotNIxoc+S2Dt8+HyiT5JnhoX6jM2SnqHFdwAkK5hqXJcfe1ywH7y9xDRVnRbrHfWf7TmSnTcJnrjyMT1x+CPUtXry0bXBolK1ZkXanPGfyoJEyvQc4YIkJP3zUWVIGoRCQHvksB3AQE1eEZAkW4mpZuZFi7c2KPdYql33oyhYAdpdsKaRjyWQH1uIiJKeipumOEaxxdkVPYgrmS7cGQVtXQkjW3QlgaMo0DQvRFxHJGpR2AodmNHRXLX49CYJAJmY9jrpKBkJRkGqElD0pGyX+vgPlfXmcGz2Ic/IomR990WOs6dfAVmJz4TbhP16zuBkMXfOfuQ7KayvHP4a5JpP1tod6e9+usbERhw8fDv187NgxSfScMzR06FDcddddOHPmDB566CH5/a9+9SsZFzBp0iS0traKxoBzhF555ZWk3rcfGNiMAbvxuM/ZeSCUeRRLELOUYLcD8v5T++vxq1u3wt8exPu/Nw7z3lMqLXqaudfPcxMYuGxgEKVNMO8tbDiBgjAYbky8bCDGXVYqbMK54w3Y9tcDOLn2LCq3lsllw49XImtwNlrON7MfTkDB0CvHYuadl0OxJKAC2gHRZgvILrBLQJsnkRkwfgMsKRAcaFBAgWOgqRmuFJ8YJmng4BK2IODmLAa3tlp2ARX/+Asad26Hd0AeRtzxZUny7E7ke/B5ZnRzeskwLdQzuTvVtmf2a47O5bVQOnQu8nJGYMvuB3G08k1UNxzGoGytbj7Xqg2OphZfj5KMMaE2R22lbF5U7ylTs2Y7XZ57oKZr7A6HiPJB4EUBBRQmTvQQFDgML80N48CoN4yskDtUG45iL7667gBy0kfh1ouP44vX7kVDixs/37dLAw0Mj7ki5UqciUQG06DBHgNs/iC90hlAUSBthjOiVphl6mSIJp6PZbJC40qqQp2UhDdIDe91AmIbY1gAeBFyE+hDZxLiHAGunMkeJDoqmq175EZY+uiNYI2dCwWqRNovnQI1Z5xSh0N1d66m+4pdicUaGBbEtAlGj4buq6BNMhO0nszZEQIhiQgp+RmZnPkZmcD1tUno7V0k8UBoDohpb2VnSizgnWjohmftLcKylZ6FyVve0C22yhpQQLYnFWny+LdLgGj9H1gib968OcKwiMMHGZwd9Kc//UmMiziZ2ER7ezu++tWvClhIT0/H1KlT8dprr8U0Peoq+oGBzRh42S2HYAQx5QQGMUsJLB8oC/s31OJ/7tgtCffT/zsB0y4tFARsuhTM8RDSGJjSQwgc6PcmhS+gwC4x8D/+2Wl5jQtFIzJw+Tdny+9bW4PY849DOLT8OGoO1UDZEx/TijIw5ZOz9bAmW6AY8kKgbkAmM4VzZEi8GNTtmLrvnzoDINDcCm9Ollgs68fo8oMGCUCHS+HMbx8QF0XfwIEY/Ml/E0MiMgVETrRI5uPaaqvg8nK4E8EEEKBnkds2VOJjxK8BUmYwI54vmvNV7Nr7KM7VcSVeFtr200pvRLEBBXwSv7fQF/zojlkLlhsn2w7Ic0q9Y21jBb13WS4RUOB/wQEK7JW2NpSMMDwKsQe2noQ/cUxtu2qT1fqnV5xAdloprpt1Bv9+0y689nATjpwchonWbAEnHFfMCYs0DuKsAOfr8uSWL8bFg2S2Qlctd0w6nJnAEyVXxc52sRlYgrfwgqyilqgbepz0yF5wFWjMadgBkWiwlYxJ6hB2YZCKHBYVKzhvwbTucYXb25goQsjnpN69GNd18uznil5PL+z7uns0a8D9oFmQIb1uE4xO5kzgBLx0zuSFgj92oDBYYirDSVHsmyQeuQI3K+9ks5RJ2vr/Tr8LM7+CGgMem9zG+mevzL+gUya7WfQtX+jCxyS6H/arrTLUip00jaiVvxuCbo5Ef1s7E97mYEeBGL/FCYIDZ3DaMC+9jX5gIF0JAaRb8UFB9M9SShA/Awsbllfjvq8chstt4c4/T8CYmbmiKdB+RfYURXuV6nGRMdClBcM2wE78Slbs/NPVoECAAdsHmcRgIUAdAF/LXtm701yY/aGxyBmUjlfveiv02Voqm/DCex5B0cxBmHPXUqQVZmvWQkSDNkVOwCACQC1mFNZCaie2aZJMYFQIdvjhyU63WQS7c0GAAbsj/Dj7y/vQeuK0uCiWfPZTgN+FYLvWZ4ixkq0F7GhuQOqAIkn87FqgDwHLBxydoLs7ZHkPF2c62Ot+lkCmTb4VR46uwIkyLZwZkjcbxdnjw6BA+iWV9jUwQkVBL6xPWKiUcckWimih7DAvCnT4sa7jeQ0KXKNsUGASv60tMBoDM+iCv7HJDvuAkPGxZA7owPfRF7x4IB24YQLw7PvTsfT39Xij9umIEyhPnFnIERhANoAudonGOVUeIQKMtpglSBirpkuJg9R8T6yQtXf/cu0eielJm9PwJD9BzRI6n8OoqHmIF2QVWKPm6r23rXsmyJ6UqhE4g6PCDgyh0ZVtluTcdl3NZehpEAQVi03zCWxRq8UzgszPFGtepxV6G5rspK5HSevVeudVOhM6/znp9O6CoIGX8NrbrL51Ktb/mLR1yub/mbSZsnXCThFwwZZKGTgWA9xxTggBMQEJvweFtReKEWFwXzL5c34FDahW4RlUoSxOk+YFDPWvKT7sSfQDA6Eh25HKCUcJgAJTSmA+Wv5IJR78wSn4Ui386B8TMHhMui4f6GbAUE2/w6+BgdejIhgDoc+NVoGgwBYwmgv5BLux0D49RF6v++M+rP3tHnFZ5EkjLS8Nl/9kEVb9aD0qt57FC+99BEUzBgpASC/O1kLF0GgAezZC0ILbQ78EsgT8mQCA9X+hE5CSn2VbLOtOBcvlgmrvwLEf/gZt5eeQNX0CSu/4sGYf3ApBtwuqDXD5NRMfaKyTZJ1aXCr6AgMKRMAoyVxfM5cHPWF+hR+zvqEMJ8rWhrb7qfObkebLxfA8dgxoUKCnUTpKCKa7JKjQGKhBuisbLvpH21oEzsVY1/6cDQpGY6J3XoSmQPgA87ON1A1gj9XTMAbTpCRwTlXjlieAlR9Nx/zBHjz8/nYs+aMHno5Caa8qwpAkhFnm8+hg/XibPfyGFHg8w58h1iiUqeNCzSdr1Wvq4Wb8s0mqyQYH3XAQEbsnmJBj2eFyIA578JmYFvTx6p2AhpQ+jW9K1UhJvmGzpEt67NnvDL9qRzOapAW1Bc2hBK/ZIAgoYJD6fl09FUrsiUV4VR5O5yaJ6wuTtk7gKbKd2bZqnnsp3n1BugIik7QeMsXZFW/gKTGZosD2QgTtlw3TYzosclWhfG96XnAbvV1h9U9XfGcFk3WKDCQyYcUVHjKY5h/7nzL8/deVSM9y4Z4XxiK/xGtrChydCkaY6A+ESgmiMWD+MqyDKR0YUBC6rUWBYWDgirh+8ptbsPelM0jP8+H2Ry/Dfdcvhy/dg9JJuXj/365B+b7zWPXDDajcVoYXbvkbCqeXYN5dS5BeTIGQLguYHKq9EfRER+IBgoWmCrsjoTgHHrcNWghyWtqx/99/g46aehQsmYlBH3wXAjRMkgSvNQtBlwsBMgcuCw1H9srrZIwci0CGS89VoEDDWD7b9smc1SBeCbadREP9Gezadn+oy2DkkEtw8uw6HCx/DW3+RowrvkQoB4uIwugizPkwqFDdclxOyEUp9sAl/hQIYF3zU2hW9Sj1jMEk73yoiFGZna/DNF5YjHguWC4nRwICU2tltAWAjzyWgrc+ZWFqMfCP60vxX09N6YGRamhKF+pUja36Bubgkm4V/zOxCKvsyYP5qjihCXp6oM9rIVfGWOOfkwnqEtbgRezAuk6UPlvpyCjwhM7VezIT/hIJJo5RaqKUM5hQSO/zOKDQMJqhMbQ8RaImweskH661h1fv+l+iyz4npa7/6aSuE7pemZMt4YW0OFfnySZ0AiyCAgIEmnEdx37RmZgOhQudpGlyxRZClkySHcecqAPmdmlL1IDYsBdslyQwoF6Etsv90ffRzxiEgEEwrqYg+udffqscLzxah7xCN363fCQysjW1roWIjm4FW0PQxlVtiDHosF0Nw6BA6w1sfYGtPZCigqWbcQwgCPD1O4D7P7weZ/fUoXhsFu74yyK4vKzrK6RlesSTgX+kgyfm4v2PXIXyA7UCEKq2l+P59z2GwqnFmH3nJcgYmKMXxXxtUvJcUdvUPBN880nbrXHwgJD4sKO+Gbu+/nv4G1sw6PqFGHzLZeho1/CHcxVMC6T2SKKDogtNJ0jnA+lTJoijolgpC8jQPggaHKmQvoDft/b8SexZ/0fZkqnp+WhtPofBQxdicMkcbNh+H05Ur0e7vxFTSq/TKlApj7j1HrKdD8807ZbXG5IxTYAB5yWsa3hCgwLfWExMXah1GXpghDMXh64FFFDnEWyXVRFX4U2oC63+uHbTvI5CAQbJSvFgYw2+9fg8/OYj+3HZlHLsO52LZzb1xC/ektY7Ghbx3difn0jpgYl2kpojyZe93mwh6y7oAcAaNRNKb10ZGVyVD1GjpZWOFsBmpDTH8Dpb6fpi9R5dCmlCgyRZJhOWFMx+omvjPrU1lOSjR0LHCk3Ea/Kdr2lq47xNGp0JnR0jnBtBAKGnFzKUuP/NtjqPbe6rIBvjBFicaUlgwGR5IYABu1RiJekhGCViWO5rzv/oqyArowWw7LBYFMGSsW2Y819YwntbgYHqLyW8o8LnCsLHYX72z9HXzhXftz5dhtXLmzF4uAcPvDgE3hSeZjrEPdA5etk4IPLnFn8YGGRwCAGc7IAGBDxROcsIwhjYGoMANQWWC3XnO/CLmzegvqodky8rxAd/OUO6DoSoDCikZXukw0LrEDSCLx2fjff9dRkqD9biDQKEnRV46bZHUTClCHPvWorM0lzd/S/JOnzdclYzBlnD8qVdsa2qHtu/+gACre0Y8cGlKL1ugXgbSLIXQKDnLvC9nexBe0UZLDo4ZqRrS2XDEtj+RUQC4ptkz7CqrzqB/W9qUDB+8cdwcM1D8KVkAyleuNxezJ/9BWze/geU1e5GW0cjZg5+ry4VMETLofdaTdsZeK0UpHkzNFNQ9ziag3Uo9Y3DxIxFtvdBuPFURIyOnV4bOIdT6pCMGg63D1oyi4AiQa6sWcunbzx/nmYtlG4D9ljff3Irprw6FZ9bdgifvvIADpdnY88pk9RVEu2C7H8Pil5ggFWQFJ1/Vh2T+Qin1RHpoogX29Qa8UxgG+QkKzlL4e4G/ZDSp23zYDVGxLjhsb9LEu7n53Gs1/T1aEGDeDqQste19DZ7Ra8LbPHCPIYJ3hshguOqnfV0pngm+Ay5JGtAREpbt+0pKVfswxbxSUh0+mFPukYI5ng8zsHS0OfNVgPEAIhJtS+ZGL5eeJ5EZJLmOGZ2RHBOR18Bg/A0SL+IOmN1WNDIS7axg7G70GH1lxLeWcHFKg354p24JWkHg/jM+yqwfVMbJk3z4Y9PlmhK3D4paQdELTjkJALdcaAZACugBWhczafS4MjuOghGCQ5VNDCw7TvIFJzcV4+7P7gd7S1BLPvUUFzzhVEICEvhQnubfv30HI+wH8Iu2K8RsNmIQeMy8aGHL0XVkQa88v1NqNpViRdv/TvyJxdhzr8vQeaQPPvI1xORWirr5DWzRw5A0+lybP76XxFsD2D855eh5JKpsj1ky4gmwV5xC0IwVVKddP21tXDn5AjNL6w8hYJyitHXIlKkTMCjUFt2FIdff0BOeOOWfQIeKxXBQAdyB06GEmEi2QYvZs/4NHbs+jPONxzH+hN/xvxRH5N31DuLg5Wa0BFsRVHaSPkUa889huZAHUpTJ2Bi1iK7k8EIFjVKCXIkdfAoyoLH0YDzofkCpII5UIhuiIXWYNvrIYgt6g0BBWQKprl0PzxX9GOD03EQ23HX+iOYWFqCSyaX49vv2Y7P/mEhzjcmdrJuUU2yWgraFHhP2g+nYiHexHNaJa9KYya73WqjULK0S55u9WygT7wgKJ2s5skqczvelJU8vw9NaWhIxO4Hsi+8nyZQTP5toWRPCl+v7OMBKV2F13Q9V+2k00nLM8Fz2A6hhHwOuLAUN16wunvkiOE50to5Uk0QF8Zj2CsAqS+DYMMcG9yWHBFuYrgYAK0VMNZX7+tM0uNjJGluVwISjkXuKyBEVonHAy3EqZuJFSwnEBiwpNcffR/9pQQBBpFDknSEf25vD+LWa87i2CE/Lr4kFf/zYEmIVbL16qExvqSfRQpo0/T8vTeoUa3Pq30MQmUDp+DQYXSkgYPRGChsXnEev/3iQUmsH//ZaMy9rlhAgdtO+jWVekWbne+V1xdgYL+GdDNYAbhUEMrlwqAxGfjAQ5ej4kgTXv/BBlTtrsTLH3xcDJNm37UUWUPyRWTYWlUvSb75eDk2/fsT4okw/ZvXoXDeOO2P4OIa0IJb6vyaHdBsga3IIOjpaIXq6EDKoGIEUxRA3wO/NkUSpsC4HvuDqK04jGPLH5Q7xlz/KWTkDcbJNU/L9xo4ar4wClKCkOe5MHXu7di/8x+orNqNNQfvxcLRd+iTksuFU3Xb5XmlGVOwtuoRNAdqUZo+EROzl9gmFLrhtMlfj5Nte1DtP4VW1RTa35wvwBX0UNdYmZPgtEZmbFUrZZWdj4GY7opMqENdY1ATrJTa72eezcdLRZkYUdSIb968Hd94eLYu23QRraol1C44GXNRKFbOPfjDtjyYohZIYt6C1Z1MfziNkfV33SqYmI1wIsFjmomeK1fWnpm6eVuHJd0KXbVfaeqeo57TQit6Q9dnIAvpyO5yLDK/F0EBOwJoUcwSArsfLhTlHDliWFP4FH3uVVtkFd2XwIDbliySsY2OdlkssgbBpdzC1PTV+zqTdDzmiewZgRC3c2/GX5u2RGp3uPe6shAnICc4ZDnhbQvVX0p4RwV1rZHa1vCJq6khiHdfcQYVZQG86z0Z+OHdBXa5wHmcGG2Bpsmj7+OoYobPreAlqWmRYXCFbJRDOoOI21yFKzx//1k8+t9n4E2x8M2HxmHktBwEWD6wWw0DlkJThU5qOfkeGQhFnsHoErS9sy4RkNsQfsNloWR0Bm758+WoPt6A17+/AVW7qrD8Q48jb0IhZv/7UrTVNEuS3nDnPyR5L/jZjRgweShUkO+tZzWwxRKc5GhAga2/5vuSRWg8eFA+V8a4kfD6AvCzo4GPE/GhvVi3gLqDB3HquT8JUhj13s8gPX+QaCbqzx6C5fYgLX+QlEoknbsUVApBEzBh8nuRsi8Lp8rX4c2Dv8HCMXcgxZWOyibaIFs4ULsazf5alGZMwsTcSxD0+1HZegRnWvairqNSRjWbZJTjKsRAF9uuhkv3RmRjQFiAuDnwRshOd4YrdkvgFCzEW3gRBzqO4IuPzcbfPnkEU4fV4pOXH8S9r0QnqLB5EhNM2ClvFkp6OcueJj9kC+gtcEztC80EYN3fTGNMtlWQyYl+DDrx19ur/RZpueMqvytKXyd7ru1Zo0+zBzwx4WdL4u/tqp4tkOZ70UOfcQR7cAKHLggw6GrEMKcBEhiwzZQ18b4IsgFkWKghiGcbTUBbidMJWUN3F/vUloSSNEtp5G8ISHoDDJxtiXRS7Cp4rNAGOww634ZQ/cDgHQ4MdFRX+nHjFWdRWxvEJz6Tja/clRdhD+I8TvTsgxhAgRe7DOYVgyOtJlBWUBjtQKikoDUKzrLCPXeexMqna5Gd58Z/PzMOucWpYgesOxN0CYK3Gyp1m9SAQmoMtJkJE7WbroechAjb1VC55A+KJke6vK9QPDwTtzxwBapPNuKN769H5c4qvPKRx0PbgMLGJb95N7JHFut5C7bBkQEHUn6QVgZbeChdDboY17hPW3nmzByvWx5dtDpQUO1mNgPQeGAPzj71Z1npj/zQ55GWVyKggB0H7U21yCgYCuW1BzfJVEeXvC/BlqtdYfSYZfD5MnDk5GvCHMwdcTua2rU+otlfg+KMcfC60/BWxV8FJJg9RABR6B2OoamT9Ghfac8MuT6FRjbbhmwSWwIrRWDIE+UMd5Qhj2MRTIfIecHL8Saex/Pnt+A/n5qLH79/H26afxL7z+TijT1RiYICR9UuA5eMh0CpFZ670JuYjHli+sMEyemHtF3Wo39Tpd0sOhmT4meJhGYybOnUiV8745HFiNV2Zyh9ruiZlKnDoOUwB/wwcZp+d1LRyRgmJRNV6myoBdJpYDRIDZNkU6FOo7iL6YfJhnOkcSzHxlGYIsCAcwwIInsbB9UOcXUkE9KVFmQ0JgswOILd0h3SG5DFz0/AlkiSzlX5AiKot+jJkKhYbYndBe3G305gYPVrDN55GgNbFB86wx8/1o6bri5Dc7PCv397AD52R04nQBABCkJsQbjVUXvjKCjbx8DjoWpArIK0BbI8XoXcyQxIaO9Q+PL7T2PftlYMHePDPU+NgjuFYEAPYDImRwYYNFbpUkLhQF1K0CDDr/1+aG1sOyfS6pklBT6PtzW3oAsehcMycNMfr8D5k0147tOvoKVKg41hy8Ygf1yB1NV1NwGfa7dNuviJtaaAzIUpKYhtQNBC87EzkvDTi7Ll+Uwrlkc/1t/hRvOe3aj420Ow3G4M/eQX4aMJEksNFlC7R5cD8kZOQ9Bjt0GKW2LYGIm6BXYzDB12MXzeTOw78jTWHfl9xL6taNLuh/yMWd4CcU0ckjFFTkCS/DmVUcY1O09E4ZHNxhRpa2AlzqsKDEARZrpj2YsaswPtf+BzpWJa8GJsx2rcfWAHJr85FrcuOo4vX78HxyozcbwqLOBibXatPVmQJ/aeegjECp5gZ6iLZe4BxX98D26LEgyWlkaWULTJTnvc8bW65U6v9FnDJwCgAx2TYrzOAuoXCAoIoqZiPlbiORGpXYy+BwYNqkZaI/m9mFQ8FpWsOkZjKk5Lgt4lK/u+iERGGtOzgitaAiyCrd4MF+L7EWSlOJiQeEFhYIpKEy+LnrYQ0lLagKxEGaXhGCfA4DgOYCym9UnHQ3dB4SM7Ivqj76NfY2BT7U7GYMf2Vnzg5nLJGXffU4Abb8p0WuXHAAhGTGdu24tN0/YWDDMGTMjRgEJsiwlOoFBb24aPXH0GleUBXHxFOn54b7FoBNrFAZHgQE8g122NmjloPMdOB6CoxK0NlOyRxtQXEETItVD8GiAQfBjGwG83ZVGzzZ/3/31vCBRQC3Ds+f2o2n4WS+65Hmn5mXb3gRUhPDRtikz42kuIfgUutFXWwJtF50TdQkgTJZNAG7ZtQ8XDj0jHwuDPfxm+vEI9X8G0LO7fJo/LmzALAQIAe9Q0HRIFVolgUbcKEugUD5oOrycNOw/8LXxwu1KRlzYEg3OmIz99qN2S6WAERAthxRjAFAkOtgVWCyWci0LMigkKbEAQdTvfVYJhwfEyp/5Lb1RgXGk+Zo08h+/esh2fu38emtu89mjm5VJG4MyD4UlOFowVBBosd3AyYyNqQkI8Jn993AVxEprNIXfExG/66UnjktqnzS2V3z0Rkx1Wu0P6Ba42mViKVanUg6tVWZ+yBlTob8JK+VYc9pQWBVT4+QtUsay2CSCcYr2eRDIjjQny2DJ6BLukNNT790ssSZdiuLBC3N4DkVw5itMZ2W2jQdblCe9/3ULoFuFnMsCgq46H7oLbIkNlh+ygL3io/lLCOyo4XtmMWF71RjM+cbt2LvvTQ0VYsjR8onFqCCIvkSxBaGKv/dhgh35tJk13LLbBBgtHDrbj9hvPoqVZ4cOfycFnvlFgPzYAn9KMQodywS+AQOCB3NdUo2sVAwe54LE6NOUeAgNhQKAvNh3P3CgMAgGEvjz39Q049PpZpOb40FrXjpl3TEbd6WYcfuEIXrzlEcz4twUYfeMUSdIiPFQB7ZTINkSXZkNk+JI9vCnQ1Ir0CcPs6YxUDdJBEahbtwPlDz4Oy+vF0Du/BE9+EQJtemtoN0SgufIMPBnZQJoPHeJhZEH5NQiQU6NfQRGEyM8EKQEcOumcIObC/JG3I92bY9sna3AiiV+xJBIPFETe3t7+JqrVWeSgADNdl0QCgC5EdOIsybY91xTUBqtQpSrwmX9MwHOfTMXg/GZ841278d3Hpkr5gKY6bPUy/f7JJEW2JFIIqev9TZL8o+v8unAUDpYq2InAaXx9rdZneyT76ckuOBMZB/swUfUlaxBW6AdkumIsl0XGeMwUw6X92C4mUT0NrmzDPgzdjxhmsvQoryTLngADGvwQWCT6fiaGYpwAA4oBkwEGekS0aSldHHfMdrwgO8RSFY/LRDwqEmlL7C44i4KTRd+OsPg33ZtBUb147tsd/cOsbdqEl2efaMDHPlIpg/iefroEly5ND+kPDKtAG53OF0RcSGSyNGEAh9gLi49B58eay5oVjbjt6jNobVX4wd2F+MI38iN+z9fzWQpprgAyXB1Ic7XBZ3WIpqCxVgODrBQ/0tztInCkCDF8CcDrCshjedsT8Ts/3Kodf/noGwIKBk3Kxaz36fr28DmFuPJ7c3HdvZfBk+LB1l+uxYrPPgXV2gK3FYTHFdAXjx8+r1+GLbncQbhdCk1H9eCjrDGlcLkDcqFRUt36LTjzwONw+bwY9e1/Q9rAPHkOy5KBFEuSfWtNFVRHOzKHjUFHhgvK59btimQI7GsmaP0zdQsBbN50L1pazmFgyQxMHfcBSerrjv4R7apFJ3/phOA1IkGB3O9oXXRcdrStQpU6IyOPZ7kuFe1AImFAgf6B5kRLhZbd1LIP33h8ONr9Fi4aX4WLLn5Nkjm95sdYU+OePOmPcEIdwE61DuvUK1ipnsFr6h+S7DgwiLVgtosxQZLmpxp/jAxgvkzq7UYoYYRh51ElK+e+BgWs8zPx69VtpH6BffX8XFS4kzXobRi3RlN+6Uo/wCRFBoQAijXwnkS7Y2VLFiR66mVXdXAmProUJgt69PvpCZeJvh+Dq3yWeVjK4esksz3NdEa2lCYbI6DZLoKSvmpL7C44wbQ/+j76Swl2rf/+39fhBz+sQXq6hVeXD8TIERqdd2piJBsdgzUwv5Nw/J4h0wZtS2QBClHPe/B3tfjFj2vh8wEP/K0E02eniTAxlqaBOY15jC2RPrdf2hZbGvw0/kOa/Gw0CLqWL2yAKSGYsoHdocAygr81iN++ZwOqTzZj/OJC3Po/c/Dwv22RzzVkygAoV1AAwkdfezde/MqbOLO+DE/f8BfM/86lKFkwGi63PfshSKbAnk5Ig6Gtur84f84osVQmcV+9ajtO/vF5uFK8mPijz8DKyUXQBk3S7piiP9v5zXooVM78i6B8Lpsp0NoM8TLgPhB6gp4Cfuxc81u0NFejpHQWxo69AS6/woSOd2Hf0Wfw1qE/YNG4z8Lj8ghzINtcvBrE1snecVbkzy4XdjSsQGXwFLKtfMz2XJHwyNQIUGAHE+QcdamwA385uwWTX5yBr99wEN9YBOw4OQhNp2ba9H+V0P+sS1P0R8FedN2f/AiV/TnIRiayZeVP3UOsFRpXbmux3DZJulhWsGXqhEx75Go0Gdq2u6hz1PkJRmKtbidipgjj+oI1YFLhNmLiTaT8MhbTsQUr5b3Z/59M6KT5aihpJuMrMQITRY9ATwN2KiT6fusdQtSedDVw1DMHRyXqpbAVq9BmW2L3dCASGRu38sjxRTjcVdCFMpGOh+6C6pe3LVR/KeEdFf/98xrc/0ADBgxw4c0Vg1BcxGp/ZISSv2Msb3RJIAIUUHQYBQzIGDjG/cjlm1+rwlOPNyF3gAtPvDAIJaXeEBGs6+dRwECmOkb+3NzAVbulV/+iKdAlBF1wMDoDDQ5EKMhZBkqhuaYNP3vXJjSc68DC9w7Cu78zUVohz59ohCfFhVSvnrwuwkWfCzf+egn2v3xSuhfe+tarKL34AC764RVQLo8IAvXClOUAhbr9PDkAuePo+aBQvmITjv9xOVypPkz/+afgys6F3xZl6kxqzzNIAZoPHRDtQcqwwaFtFwIFfBQHNHksBAId2L3iN2htqkbR0FkYPeldoXJDSekMtHc04sipFVh36A+4aMyn5XNFlA9kZ+rBTvqFLVjKhZ01r6Gy4xiyXPmYk3K1Nk+i4CSaCnSWFQwosPUXjg5HCdbbJ6lZ2IPNuHPbFgwekYoPTPHiZ9c3YObvn0RTRyT9z25+0vFU+GdhAHJRIJdEa77+qPHJJrmQcufKkH4CpPr7ImjItAVvyG1d549NQQtroAYLOKDAje2UPYk9anMoqXD0biJB50iK8thJkKwobzNWSrmnJ0mT+ytXFYjmI1GKPXIl3TMhKj0OEvU02Ks2o1Z8OUp6bYnN1+D+pVYhHsuhOx4Sa0v8ZwrrHdSV0F9KAAQUlA5yY/vawRhU5HGUDaLLCPbFirqYcoS9kpdLRCnB9jHwaCMlfV8At918VkDByNEerFw3GIMHe0Ov6Yl3cXRRmEtLcxBeH0sNdB5jqUCXDLwRt4Ohn/m4mlP1+MGyDQIKrv/CUNz63TH24/xorG5FRl6KfjzMa+iSxISrBuOO5dcjf9wAnFlzEk/d8DDO7y2D5Q7KeGYKDXlpOn0enowUeLxA+SsbcfT+5XCn+zD3njuQUZQBl8WSQ1D0B+ZaxjsHO+CvOQ/foFLpQuA4aF6TIQiVEzjsyRXArpd/jdbGahSOmIVRs27UmgO7vBD0Whg6YhEGF89DS0cdNhz9k07cLj09Uq69Hn3xuMUvwXK5savudZS3HUaWOw9zM66DizQP2QRedxFh054wKKDuoTJ4GnuCm7BWvYx90IJKAqVPPd+Csw1BjC2w8OOlmVIr5QmcgrZLcRMusd6Ni6yrMcNahNHWZEminUFB7DONFjS+KitOCsGc45OzrFxJqGQl2CLW22gPARDtxCetn10EV9yM/T1Uk9OPoQzHweJAskmFUyO57dnKl2iwu0I7XA7scdJkWYdBs6W+8g5IJDjVkx0n9DSIFyxRnbW3J102exsU0HZVTjgX0fHQt5M1+6Pvon+vUKwz2IVtawYhN5stfTESfwwgEL5oIGASvtsJDuzHBO3VoJQSKGKqC+Lyi89i2+Z2XHpZKpa/NghZ6a6I58S82FMZI7QHHNLUrJCa6gKnGqdaAaRaHfC6/KIpYPsikzqvzeXkrlp894YdaG0O4GM/HIEbP0PLXPvxVgBtzQHkD0nTryGv4xeNAl8n09WGnFwXPvTIZZj3hRnwN3VgxWeexbZfroZFxsLWErTXNiOtJAdnXtiIw/evEJBw0W8/jvRCdikQDEC0CB65rS+83bRVtylmzJjeSVcQZDWAIEF1YO/T/4O2+moUjJ6NEfNuinhswL5NzcKIydegIH8CGlorsO3Mk/aISy/pG36ACJ3B7poVKGs5iEyCgqwb4aLYJGTPyB3rjgsK2I5ZE6zCgcA2bAy+ijeCT+F1PCF0LhMZtQROUWBDO/CLZyfL7c/NB24uHY9h1lgxpenNyVLT0K/agsbxGGqN6fQYOiqSytiLTT1+H/NeG2xDJorH6LzXXXhFa1Bqaw3Kk3o/lkHox0BHRLa1JbudaF5F/QN9DRKJo2pvqLsi2fJDNMVO3wjDVsSLE+qg6EXIEvXFSpruiIx4QIiaEE6hZJLuyfaMFZz+yVIXRYix2xLD48MvxByJCxqqDy7/IvEvtmcuTJw8HUTRyFNISQGyM10oLHRjSKkHY0Z6MWmCFzOnp2DcGI+Izwx9bzwKJGw/gkg/A32fPMwwBl4LRw+34YbrK9DUpPDJT2XhW9+iaVJ4rLNo51lDN6WCKJ8E0/Anpxe7/aGtTSGvQE8mN+Oc3eKLwFM2b+kyAssKm1+vw48/c1Ked9fvR2HKogG6WKB07f7U0UZ5g9JxmQISRItAwCP0K9eF7IrQKW7OR8Zi1BVD8OynVuDI0/twdu1JLL3nesDlke+sOvw4eP8qeLNSsfh3H4YnK1USKNscKUYUEWCAbogyckIPUdq4WbZD3qJZ4qiIUAlBT18IdnTg2N//B+111cgbNwdDF7xbvA9k+7GlkcpPAqiAJVoDWjBPnP5+7Nz4R5xrOIrdZ17A5NJrw/Od7aS/+9yrONu8DxnuAZg34GZdPpB5ENFtjNw5Co3BOlSokzgfrJB2KRoAhcOSMgDr/3kolv55JjQCBJYFmEQ343Xce3gPrto5CJdPLcNXrtuDz90/v1vL5MhwjoTUweE6NCaiKGuMpRNDdNCAplQNlyREt7me0NVGrEYdBAFIMuKx8ZglboxkDS7GNQk9p0ZVie8Cj+IF4lXQs1PXYIwStT69AboqC5SpkziKveLekKw7ZKzgFEIeA1ydU2waHRRkklHQSbr378fIsLKQolJlEFh0NKo6Aa1GE9KXSboQg+R7UneSY7eH9qYt8Z8lrHdQKaEfGAD41EezcOKUH6fO+FFZHcCRYx3Yu78Dy1fofn4TXGhmZblQkO/G4FI3Ro3wYtJ4L6ZPS8GkCR64PRy/7PQ20CH1d9Kne9vwH3edlxb6u3+eh/e/P0vuj9Yq2B17oZRkWiDN40SIZ4MC3ubo44xMlzAWzjSmxzAxuXPCnBvP/u0cfvXtKni9Fn766AiMmJwhojeebCkhJOw5uE67Bo6ZnS2lA97HxkiXgARqE9iHoT0SWJ7IH5SGDz37Lqz67y3Y+9gBvHTbYyiapT3cG0+ehy8nFZc+8EFhDAgKRGTo5+KbSoAQHpBrjyeAluNn4MnJgi/dg0AgAL9MnzQTEAM4+cCv0F5bjQET52Dw0pu0e6QMSnTBRTDiV3D56QthCxb5wkFg2pSPYvPW3+Js7S6keLIwpmixLTh0YU/FqzjbuAfpngGYn/++MCiw9QitwWZUdhzFOf8ZNARrpNPB6QDIFSw9DqjkZkkg05Vr70z9mAPBbQIK2DHAMci6r38IKnAK31zuxZzRXowqacR7F5zAo285k0YiZ5IwKNiu3gpNSpxoze7yWQQnZWKbswulamTSiYi97gREJay8xwEg8YLCRGPVnIjWgELJrXabILdfT5z1TLAz4yQOCtVdGiNBm5HGe7AxPNK4D5L0MGkh3CugJBoYMEnvwNoLkqQHYQSOYZ90RXDqpin/OCdd9vX4a9pPExhQ+MiOir5oS+yPtzf6gQGAH9yVh+ysyD9+JrFjJ/zYvK0NO/d14ODhDpw87UdFVUBABH9esTKy9Yk+BVmZLuTnuUSzMGK4FxPGeVB9XtOHDzzYJJ0HTz5WhHlz0zoZHZnbzo56J1ugf+bqXbv+Gb8EAg0CFj7HAAqn9o3578FfVuHB/6lFRqaF3784FHmDfPDTh0C8DLSJM0HA8V0N8rxJ87OllODmyGeEmQLdg+DWnQ+2PQ6fu/RrMzH26pF48d9eR+UmPdjEl5uKKx/+ADzpPgRtHwFFa2YXpXUaGJggg9BSWYNgWztyZk6U0oL5/NQfBvxBnL73F+g4X4Wc6XNRcvXN8r0tP4QZEBtlAVQGStmggBdWBLwuzJnxKazb/D84Vr0WKZ4MDB0wE/sqX8WZhp0CChYU34pgsB0VLcdQ3XIc9f4qtAb0VEATHNybaQ0QXwMKvCgsk5KD2eKhXK4/z5HgbpzCIZkLIC18dsvjJDVX6NZNzXvwvy/Pxbdu2ocPLTmCN/cV48x5iveSWF4ohb3YKq9HU6JEJiUy2Y1Wk6Xey2mQ7PVPNChWo7MexZCTLZYlko8wa8AOhavjPo5JjMyEbtu7uNf+//zehQJKTgsLEd2WR4Hg5tBI40t6BUKi3zdPFcs0S1LqXM2/HUmagITAgN4S7IoId1gEMAGzkxrnnWhQfOoTpqKyz9oS/ylC9XclvKPCYYcfCrfLhdEjfHJ5v+ORlqPj4PRZPzZsa8GuPe04cLgDJ04FUFHpx9kysg5+rFrjpJd1fPS2TMya5rMNlawYzomd2YJQWcFuhdOlCo4sth8bBHJzNTCIeL7dGvmjO6vwzGONyC9y46/LByMz14OA6kCbUuhQ2vFQZigoF84ebobbYyE7i6/RIQ6KBhQIk0GaXkGeF+6f0NuGHggT3jUSOx7WwiNR6AcDkuT1NuYHp3DQtAna29rNDG/h2PKN8nPRpbPF28A8xmX5ceJ/7kFHdRWyZ81F8fXv1d0HLH/QFZH6QGH4OQ9CaXbFHwYF8jMJAK8H82Z8Fmu33IP95a+iquEQzjUdt8dEu7Dy7O9lu5jgijHVnY0cTxEKfENQ4B4CT8BmE+wLRaThoygymR8P7scxtTc8l8Dhg8DbU4IcS/wW/nvXISybmo85o8/hy9ftwdcfmh06HhKJw0JR69o0uwISDeoPjqsDYhk8Uk1OyECHdXcjVpuJqHkRPWQN4g0acrYJErj0tIshOsZjugADevNrnwcdZM+oz+ARTyEehZp9GRSXEhiwZGBW0lqjEcDEC5SkxdNADZCZAvx+27A6ZKhFzcWFCpbPONBqq3qzz8SU/9dh9ZcS3mkRCxrEfpTz9uBBHgwelImbrtX32YqCELCsrO7ATR+swo5dOtlwYfn7Bxtx/58aMWWyF1/6bDbedX2GnQQcpQfJaeFBTDrh269u3BRttqChTicmtlpSABl02Cz7g0F88WOVeGtlC4aP8uKh5wfBlypDoe3Jhh3wqADag57Q3ITz5e3IzNXWyi6HYyKZASZdcTBUfC8txNOMgYY4b/5iJ3Y8wsmGQGpeKlrPt+Dl9z+CK+6/CRml2lBHBd1ihCT51NZC8EYg4ELt1iOwvG4xRQqKLiMoExGP/9ev0VFZjaz5c1F44y0RDojGQlmmKRMAGFDAO2xQIGSF/fvG9mrkZA/DuZoDAgr0HgvKwKUUTybyfUORlzIUxemjZd5BCASwXtHBIQ0GsmmQw+4GrUUwR4XeT6eDR3FY7RQh1kJcBY+IH0zoxxS4BmFAsEgGM33r+eF4+rO1mDa8BlfPPIMXt8bqeVcxW7+4GiT46EltehJmi7vebqzvNtGfUcdDdfe+EKs5WYOLYrAGm/FGKIkN7mFvfawgC5Cj8qXswlZLrnANCNGdHFN7PO66q8i0spGq0gUc8P3099MajUEXMElzjsFOrJfvRxEsS03xDLVihYyHl9mZ+h+nkmr9Em9zfguv9T38P88axn6b+gbL/rdVrbZbsKka0mPg9KIoGPF/s1Ry/nOeWc1Pb3uofsbgHRWJwYJEInywcjzxrR+vFlBQmO9C1bkg/vHnAtTUBfHL3zZg5+4O3P6Zc0j98jlcujgN37ozFxPGp0S8Vvg41P83SV/SkJ7Vg/KzutE/v4CJPZya2tkOeUM59u9px8y5Kbj/sRIoiwR+mFXQZknsBmhHu/KgHR401QcwcmI6MlxttqZAU/lmtoKZ/0B9gXO7vfpf27Ht78fgTXOjoyWAOZ+cIsr/N3+0Dss/8g8sveda5E8eCMvPUoJ+locCRBsUcNBUa1UdMkYMDDEMQX8Qh390L9orqjHgojkofv9N8HfosobYIBs75NBgKraBOkABc3lHG6qOb0b1mV1oqq+AkgdE7v2FIz+OTF+eTvBkHMw8BUn4GgBIyOcOg4LQz2an2D+WBU9gn9osZYcFFkGBYyWuHZZCP07DRViFZ/Ba3Q788fXp+PxVh3DH5Qex4WAhzjU6aezOJ0LWjcMTBa/sUW2aK3UO+yHt26Bq466SuarfB34nT5/VwckakNavisEacKQxV7nsYEgmiSUanPTIEgUFkDOwyDZMahLdwVBrLC5UEOSQqSAzQZEohXrdaTSYmJlo/XLpiLiEEzRvhxO0tkvX18Yki9+PwfbLVeq5UCqOTLlOdVTfBF+PpafOJt1W1K3wP81/8v/he8z9+v/6mq9uShb90XfRrzHoJroDDM7OAR64/CNoaw1i/hXlOHTUj6suT8XCuan4zo9rkZHuxhWXZOCWG7PQ3BzEf/+6Fg8/1owXX2mRS2GBC++7KRNf/WIOcnJskyUmKltfoM2NNL9gSgoV5RoYFBVq8SGf09CgcMOyMzh7OoCrr0vH3b8p1gJEm2UI5TDbLEmzB340VLWJUHLEOK/oC2iQIqZAHIpkswb8hrRN4u8t/l4Bz3xnB7Y+fRp5Q9KRWZSGk1vOYfJ1Q2Gl+pBVlIaXvvQGXv/C81jwnUswcNE4+QQUGlJvYFT4Z9cekO9aeNEEKSMQFOz/7n1oKz8nHQqlt71LdB+MDnuypOZUzKlFD1Yiq9Fw7hSq96xDQ9kR+Fsbw50C6Zq1aGmqRkpKNoYUzcHhUyuwt3w55g6/TW8VIzqU+dGOvSxuiVE73nmbgEMpVKoz2B1cr9Xz1lXwudJiHDGOP0CXF+ODMyXp/nDjWVw2JQcTSuvwuav34QePz4j5HDNcZzc2hARyvZneR9OjtXgZu7ABC7Gs0+8JGEybGRX6fVV3Z3CGQFUUa+AcaTzV6nmbYFdBAJSmMiVh7VGbHIZJiWstmLCZrPmPXSlM3h2SsE0S5z/+bFbV+h4GQQGDxkK0uO68Qu6b5GzOSSZ0UzTPIdybnk7JNnybCw3zz2P/xP+77X+8T/9M90H9GN7iAqNNgJaJBVgW0lT0dfhVB1biGbxdYf0LdRb0JvqBQRcRPXzG8Qs79B+YUQvwuqYmgFlLz6KiKoiPfTAT//uzfPzkl3pmeGqaFgXw6RkZLnz3zjx87858HDnWju//tBYvvdaCX/++Hr/5fT3GjvHis5/IwodvzZSkZNwWTaskf2aarKrQJ5riYv6ZAmUVflx3ZRlqa4K4/Y4s3PXtfFkXEEU4F7ZO8tvc3r6uWa4nz0yBzxXUQIJ1fGlZ1FS8tCoGLXFS5HMfvWsXtr5QjqKR6fj84xfhR4vfQEZBKtLS+JgARi4ows0PX4Wnbn8F6773OqZ+phnj3zc1AhTwu5xdsVdul145VWoBu7/5B7SWn0fBkhkY9uHrEbBBAVkSj4+TAt3hEkxrK+o3rEfDnh1oqy4Xtobh8qYga+AoFIycgbzBk1C+czXO7HsDvpQszJnzOfjgw7naI6hpOI5j5zZgRP68iNWMbDODoOKyBea2C+c7yrAjuEZOofOtZUh1JSYkK3WNxKngYVSqMnzv2bn46yfrsWhCJS4eX4E1+zvb73JKoHOYT28Fa2wdK1SDJBkT2FBUGTm98A05uqlf6Os2s0jWoEJsjrsbadyTYH2dEyxJ3XfIdZtYSvP96A5oEugm9XqIDjer7TD13dsVdaQOhYlUHzlMrM5kbBKwScomEYeTr7722j/x2gevfe0s8dDciMyIeV+6N9Iw60IF2xLpFMmgnTPZEbocJjuKOdFwCoMveCi7Vtmb5/+LRD8wcNBYyYTexWE0ziR17EQ75l9xFg2NCt/6eg7u+rLu4W21mxfSUjUdpp8ZjlEjfHj4Pt3Cs/y1JvzknnrphvjinefxtW+dx8J5qfj3r+Zi3hxdagiVAggMKvUfxpCBHhw51IZ3XVeBlhaFb357AD5+R44NBDQacUd1vgvYsIEKL7s26w86b1GqOB6KvbHdraDLDvpnqg/YyvjAV3Zj2yvVGDQ2A199fA7OV7aivcmP0YuK5fcCRRRQPDYHtz11LR57/8vYee96tFbVY8a/XRyxOqo9WA7fgAx4fS5s+PIf0FJ2HkWXTMfI26+TaY2mFmk2XtPJY6hZtR6th48g0GizApYFX04eMkdOQOG0hUhNy4XLz84FhbKtb+DsvjfgTcnEzEVfgEv5xG556uTb8NbGu3GoYiUKMkciK7XQXhawpGCXDzQ66AQEQgIQtrgFq7E1uFK31LmuRLoryg425HkR4zhTHMyzCGvwPJ6s3I5H35qADy4+hs9fvQ/bjuWhqc0T0bq3URI17YeXiKFMXwRtk1nS2IctQt87xXhMjlMxH7lxphf2FWuwGxtl5W3KFUxw4YTeYif1NlmR6tV5mFrXNHq4xm2SeaJJnI8ja6D/PsN0Nv/vXB3ra/0zE3I4QTMtmwRNyMnrFLm4bT0Oh2FxeqF5R3pNjLuAgjx2PNAvg+9FkMVZEdR0cOjUhQhnWyLFotSFHFQ7ZeT1hQIGtPbuj76PfmAQQ2TQLUSIONfoVLtlRysuu7EM7e3Ab36eh9tvCyeG9nb9hMz0MPxwwgPn+119eZZc2tsD+J8/1OEPDzdi1ZpWrFpTjpxsC++6Nh13fT0HhUV6tXGuWjMG5eUd+Oxnz4mo73//twA33JgRamc0Pgjogi3g7aP724UxHzLYjaCSwcoaFIQ2kQYGHZYb93x2F3asrMWwSRm489FpYka0/rGT8lpz3jNEAwN7rLNHARklbtzxwjX40/tew8F/7EVzRSMu+s+r5HXryuoQaGlH4Zzh2PiVB9BytgYll03FmDuuRiAQlFzc0dyKyhVbULNpD1rPVOoeTX6m1FSkjRmLrBlzkD1uCjxBC64ObWwkcxZI729/E2XbX4MnJQPTL/83uK1U3d4oed2LmZM/io07fodNx/+KpeP/TYsk5ZcOIGDmKoRu2zaUykJjsBab2l7Rydp1KbKMj0EiYXe4pLpSMTI4QcR931ldhyUT0zGkoBmfuPwg7nlhoj6OVGuodW8aFiC3D1Xs1AwMVWNktX5U7RPBmhnkw5N6URfTC7sLJvdWNEmNm21rTPBM9jrB80JxrhUyiWJiWYVnk2DTw4lcr7eZnsPJO5y4dbJm0iaEOIQdoVfgBMwL0RVggvtOr6QV5uCyUJLmqvpChLPjYRLmCKjLUNkynjvZWRGJxlaslv07BKNDYlF6d9Dv4kLEAbVdwNzbFVZ/V8I7K3onPlR4+bUm3Hy7FsD8409FuOaKyCEyBAuM9LQwY2DeN/JzhO/xel34ymcH4CufzUVZpR8/+FkNnnqhGQ/9rUkuw4a6cfuHsnDunE7tn/70OWnd+8ejRZi/UHsk0ORHp/KwGa8Vhy3gE86e8iOTRkk8ycrvKGkK2qyB/tehXPj5x49g19oGjJmRgW/+ZaJMcaQnwp43quDyWBg7Z4D2SBBzJN2uGGDrX4YHH3zqWjzxsRU4/eZJvPrJJ3HZb2/E0ae1h3zNrtNoq2nGoCumYNynl+HczuM4s3wb6veeREe9LnMwOacU5SFz6njkLrkYnpwBIl4Mtluw2uiMqFkK06lQtXUNyje+DHdKOqZe9yW4Xakcx6BzuiRlC+m5JRg17HIcOfEqthx/DLOHf0BbJTsYgU5g0OLMBheaA7XY0PKCnmDouwy5wcKkQYHZ6yNdk3A2eBzHAsfxk+fn4bcf3YfrZp3GG7tLsPV4tsw/0BP+ZqHQQff3VdBCl3bB7Htn0uJJntSzsVVmQuF9pN91gter+MgVvFGqBxJcsRu2Lvw4agvMSlwnc6Z5pvNUpEhiT0Uq0jrR5smspN/CC3KbVsd0ADyOfRiARbiQK2luk8mYJ26A7IpgNwo/S2/0IV0PftIdDwOtYaEWwkbsQTXOygjsvoy9aosMiqLTp5MFYQcExz9TE9OXxkan1BFph2TJicfh2xKqvyvhHRbJQwNzKnvo0Xp86qvV8HqBFU8NxJwZnYVZtCxmpKfaNfWo14m+5Qw+s6TIg9/8dwF+/d/Auk0t+PHddVizrg3f+8/a0ONonLT8+WLpbBAgoCI9EpzaAvNtDVgQwyQLqDkfwNDh3rCDItvxOOyILAELEcEg7vzgKeze2ILJ8zLwrT+NRtAK2iAAqDzRgqLh6TJTgWyDgAJLgwK/4oqQo6KBW/58BV74+hocf+MUXrz1Ud1OyO1U04yMwQPQcLgcK2+5G8oeyexOT8GA6SNRtHQacmeOhz/gQ4efEx1dCNDtkP981CzY34XfVwE1W95CxZoX4E5Jw6SbvgyXJ12Ag3gemI1rb4shIy5G9fmDqGk4gZPnNmNY3iwbOXFWgl0CoIcBAQPfyLLQ1taADfVPygl/WsolKHCXCpMR9jZIHBSYz8KSwnosx4MnduGaLcMFGHzp2r2Ycl89OgJt4txXao1AX4RJ9FxFNqNeVvQ80VIY1wh9bLE+TNvkRCh5s17nP7Y0eiNW6WmS1Gn0lGZfyFLwM6zBi8Ig8HFkDWZiyQXz0Y9eSVNPwamLF3LlSQMjfj86Ahr3QVokExjQ/Ir7tC9jt9oUGvzk7HgotW2ZaYXdl8CALbPGR4P+DM6gyyPbafmeFHf2RVCLcgDbBDzOwVKswUt98rr9EY7+UkIPGQOeJn/yq/P43s9qkJVhYcMrpaIVML+LxRhkSCmhc/kgmfdeOCcNzz2aKmK8y26owOZt2iOhowN4+eVWTBJgYHcc2NoH3b1nqqfhDge9atb5r7k1iI52YMQo1k3tx1FTQNMgQUEd+MItZdi7rQ2zFqfj+w8MRwedEClCVMCetXVCz09Zmq8HI5GulJTJzgX9DZk0pMSgFK792cVYdfc27H50f8T3azpdI3R9xqBcFM0biaHXzYB3QI6AAH/AhfZ2lzQMGEtlZwRS2V6p763fvA4VK56FKyUV42/9CtyeDPE3kJHVzPUkBDhsiRbK0i6pMHXuR7Bu5c9woHwF8jJHICulINyyKGOabTcpl4X2QCvW1jwmq+PJaUtQ5B1uP5ZCUdPq6NzJkZ82BAqitAcUxNGimAn5m68GMH+sT0oKX7jIj4dWj8YIS0+v6y75NaFOEj5X9y1oRitaJDlxVa9b25z+mLGDyb0zDc/0niYr9lRkSoLvzYrXJM3hGI9M5EinxTHsx5gLVAd3egeYlTRtnWlVXKnOJjQIKpnYqdbLJEvqNkZZYQDApM2/SNpi9yUwOKb2oxwnYg5+4n7yqRTphOiroKW1aZmN5aNBYaxbefoMeFFjsx1rZNuxQ4as0dsVFtcDvdA69ua5b3f0A4MexhfuqsLv/lyPogIXtr8xGAX58TdlO+lt200xMrqTPEasKUM2SLQXvuH9VSFQkJ5GxsDCT/67Dn/+ayP+8sdCTJuaEhYamk6GkB+BzSTYSZLJctsmLTycPDUl5IdgQATbBO+44SwO7GnHxVek44e/G4jWIKni8Adb/Q9dSrnkA8VIsdqFdaAPgmmRJG2vmQij7bZw8Ren48CLh9FRb3dWzBmMEddNQvGCEZxXqRmBIFmBoAgBFdsmZchh2BUxZBlt/0xwULNpI6pffEpAweiPfQ1WaiY44JLWyXq4EkSHAGoRiHrs/eMKeDBt8kewZcfvsPnYX7Bk/BfhcuoK5Forr9+qfESux6dfhIEpYxxtjvbjggmOaI7Y1zrG2c58O9sO4qsv5+LP7wW+uSgVB3eOwJHaKjShIZTw2yXh6zq9ofDjRbj+nioJnqv4NKQjDZlSC2bCOIo94r9A8DBQBjHpkcEXInaqdaGkaZTytFsuw7ELAgz0COWaTt4BIzBOgMFJHEAR+g4YHFV7ZD8S8ES3XTKBZokj4fk+q/mzo4STFAnizEyO6CDVz4mRTLC97TBpUvUyM8O0scZjeVgaIjDo7ffk35vW2CjxnuDnZ7vi2xaqv5Twjopkm0huur0Mzy1vxugRHmxbMURGHjtfKzrZG/Fhsp0PnbuQgeZmhQVXluHwMT+WXJSCTVvbZS7D5pUD8bVv1eD+hxpx6TXluP6aNPzhNwXwkrvXfj+OXGUbJtk+BowtG3Sdbv5FqbYNsu2eGAjgg9eexZEDHbjsmgz86Dcl+neuDrQEbWGiUti3qQGpmW4UD3TDbXFVqlssTX8miwtioRzUZQcaGj36/lcFFBRMyEP1vvNoPFOHIUuGCGAhGAj5EyiXzGYgrjKgwDlUyrmB6jZuQfWTj8NKScGwz38NrrRsBAgIOsIiTOVSGhC5LbjY8WDLCejmlJUzEKOGXIYjp1Zg64nHMHvY+8MJ37Ik9b5V9hd0BFsxOmM+hqRPjjRCsgcvSU3DLoXEBQWOz03wRQqfbnwNqJHEzdX9Q3tr8KGj6bh8pAfLFr+Jjz8bOZ+D76ub2jxIRbqQ9XpFny7ULleOvHRHzXMEL0EBV34X41q8ieeFtRiDCwMMDqvdomPIQm5E0izEQFTgtLRkZtmT+foijql9oRHK9G1whsfyIV1lshLeZ0ma5lMc1GRcImNFKYYLMDiNI6Ll6E2wLZHuhq5ukjRLGNwOrM/3RvhIbcTG0IyHxeIeGS+obSAwYFtoKXpWBosexJRvdW7j7Y++i37GQOcDuUSXFSLofsuSk/fC605j07Y2zJuZgtXPlUb43+vndIYZHfaK1Lxg4vAgsg59usyPuZedRU1tELfbHglZpScwkB4GLhd++eN8/NunsnHLRyvx3IstGDHxNH75kzy85z1ZIf8E6gXgsFQ2tMKe3breMXmK1072Ftr9QbzvyjM4ftSPa9+dge/9othe7/NkCqS7OtCqgLYmF2or/Zi0IBOZbg0K9Fe2U7ttR0zNgZg1+YP48y1voPZEIya/eySWfHMe3vjpVux9/ABe/+wzuPzed9ucAlkNMgYy7xAuF4cwhduJdRmEIkCWPBTqN29DxV/+DivFh8Ff+TrcGTnSmaCtkvlallxri2THXAV2ZnLB7+HvgaHDF6G65iDONx7DyfNbMDR3piR8mkutO/0Q2gJNGJ45CyMyZ3RmCkItjdRkRPY9twfaUIdqWbU2qlpZ9ZPWZkNeV/3Y31sBXD4S+Mg0H/721lBUnsuTBMeVfl8kMSbhHfYI3nm2q+EgNULq386pfH0VZepEyMaZK1tnjMYUAQaHsVtWhX0ReiW9R0oh8VbSbB3ke3LiJBN2b4JtiWy9JD8zt4vpjGRk9mGrzJ7oDTBwtiXOxNIufS1yrHy4lEvSdE+BAZP0RjtJT8DMToOooqMEw8TAimWTngIDM4hpyP/hICbrHdSV0Pc9K/+CwWRnNNS89juuzaW+yY9xF50QUHDDVRlY/cJQWC5jsuMMq9OlvSM8Sjl5iaOOTdtaMXnhaQEFP/7OAPz6ZwWoq9OJcvgwTyg3jRzuxeaVpfjN3XmSBD/9pXNYfMUZlJ3tIDkP+inqoUn6mt+AFP/xY34xJfK6tBmpvyOAGy/ToODm92fix78qgps0vn3hY3idanVg5VO6Znnp9RzV7BcPBJLRctvidUCsl8VGOdCB37/ndZw/0YhpNw3Hsm/PlMdccudMDF1UinN7q7D2u69IJwOBgNkMdEPkfXJxm0sAHm8HvN4ONO3YjrMP/h2Wz4th//FleApyREOgSJh4AOW2EPTogUsR9xv5APM477Mv06Z8GG5XCvaXvYrGdq4kFdafeggt/joMzpqKMbkLNDMgFw0K+JjGQC1O+w9hX8cGbA68jjX+5/GG/wm86n8Mq9RT2K7exFFZLZ8WtTaPOiZ41pw5CY+qdYrUGEycjO1nPVh7oBBuF3DnYktaBzOs7CRAQfwzUqtqwSa7jY6+CGl2UtF1b0uo6b6MGlWNPdhkOzZ2rklz5Um2gza3TEB9AXr0StodAj2xYii0DTLBUF+1JbIFMrULl0h+dwI800LYV22J3QVZGraP9vQ9TVsiwUxpAjMsuM3JnJCR6UnsU1tCzpQX0veh21Cq95d/kegHBtI3HQYFwRi3K6o7MHbeCRw97scnP5KNRx8YiIBSjotmHMRe33kM2Bd/CBh0/hcLSDghBB/z+DONWHp9Ofx+4O8PFOHLn86V327fqVf5Y0d5Oz33ox/Ixpm9Q3HtsjTs3deBGfNP41vfOS8rXO1Cbucz+3ZVVQAFhW4BDB2tQVy79AxOnfDjto9k4Uc/K5RVd+h5emihXMgcrHq+Xt728huzJPl75BKwr/l+ujsBgQ78+uY3ce5EE2beNBTXf3uagAgBLFYA1/9yMfLH5+HUyuPY/tt1stHI1LhdSi4uNy/aTtnn88OX4ofPF0D9jr04du8/YPk8GP2dzyO1MAcebxDKrWwwoEGBJH8KDuVal1JkH/F39u/Nxe31YMbED8kDNh1/GBtP/kUGMBVnjEVh2ggcqd+Enedfxvrqx7Gq+iGsqH4AK+oexLqmp7GvbR1O+w+iJlghwjrS8znIx0BrBMZY0zHHugyXWu/BZe5bsMR9Ixa4r8J01yKMcU0VKpjtgnwO7YnzUSJ94Pet0j32l0wuQ2lec9zjJXZYcf0FOFiHuoQp0kaXH3Eyz0exdCo0qro+OdlwYBGTinFsjGetzIRDrowUe2+T9KYkkjS1AARrvUnSxhDKtCV2FwMxVD4fV9N91ZbYXVBsySC1n2xQA8K2RB6XY63ETYs4opsMQ6uKLoV13/FwJtTxcDH+L8NSvb8kG6tXr8b111+PQYMGybnw6aef7vY5K1euxMyZM5GSkoLRo0fjT3/6U9Lv2w8MbFrdXAJRtw8ebcPEBadkCNJ3/j0P//2TQpF36QmIiV23dwRDAsDoiA8J9G//654afOgzVUjxWVj70iBcf5Wp5VnYuVcDg2mTtNAw+kKnxccfLMGq50pQXOjGfQ80YOy0M1jzVksosUsHAuvbTQrDh3vQ2hTEFUvO4OyZAD7xyWx8/4f5YRBhLs6f6W2/pw2FJW6kpZBFcIACmzkgI2EF/PjFu9eh+ngz5t5cipu+OynEJngcl1v+dDkyS9Jx4LHdOPzELrhdAXjcfmEFUlLakZraIaDA7QnA7Vao2XYIB3/5BCyPB+O+/xmkFudpIMGuBR/Bgc0OCDiIYgpUmCmIvrT6G1HfUoa0lAHoCLSgvrVMtnVF00Fsq3wGR+s3oKL1CBr954WZSXNno8A3FMNTp2FKxqVYlP0+XJH5EVya/gEsSnk35nguxyT3PAxzj0eOqwAulhoijgCgJlgtPfV6dcuhSD5MwBz53ZNl+7DOZg1uXXQ0xpHU3VlHxaSDqWOgf0FxjHKBoZppa9vb0CDEmDMt7NKxcTBGCXg42YvVeyzvgO6C9ffesAYbsUKEoCMdbYndxWCMlmv6R/RVW2J3wRJGT4DBCXXQHrmdKfswmRhklxDOJgH2uut4eCdEU1MTpk2bht/85jcJPf7YsWO49tprcckll2D79u340pe+hE984hNYvnx5Uu/brzGwGQOHxj6UmDdtbcG1N5dLK+Cvf1GAW9+XLQxBLB1CvGtGO+vcbIO3V92mLb6r4K8/9m8V+Ms/GmU64+YVg1FcxN0V/pwHD2lF7sypvi6FjXNmpuLw1iH44c/P4+f/W48b31eJJRen4E9/KERmlgsHD+jXGTPag0sWnUF1dRCf/3w2vvaNvFDl20gBzWc36PfM6Xa0NCssuSrN9i9gOC0XgUCbCz++cTMqj7dgwXsG4ubvTpA2R60iMGOiWWoICAC6/R9X4ndXv4jtv34L6SWpKF00CoGAW09hFHtm7UVQteUo9vz0SVgeNyb96BPwFechSMGfzdh43BY6vEEEqS5k+UTut6AE/dmuxi6gqa4MdSf2o7HyBFrqK9HR1ggVY9WY4ctHTupAZPoKkJsyENneAj3nke/pnMhIHwMRHnKwkkZQluLI6XBpxGwmc6NJNWArVsl+nI1LkcY5C4qlmlTkq2IZ9nPvqglYMK4Kl005i0feHIkz5w1ITGQpYnWq2dLBgLX1Edb4mM+g6jtDZQmNS0U4gUpPInKk8TQUWAO7fDwTwABVJCN7zVjkniXp1qSSNBMma+FcobKsk2yHBdkGdliMdLQldhdkZtJUhuhO+qotMZH3pHdDMu9ZrcpwCDt7nKS1h4GFSpzFyATaMxsT7Hh4W0O9/V0JV199tVwSjfvuuw8jRozA3XffLT9PmDABa9aswS9/+UssW9Z5QFq8eOdBsBhhSgfOksILrzZi2bvK5Rz/6MPFeN/7soQBSObCJrwOW3zIv6MI3YKj7NDp8wSDWHzDaQEFE8d6cWTTMJQUeSPKD/x3/KRfknTegNh/NNEMwne+PgCHt5ZizkwfVq1pw9ipp3Hf7+qx+k3dkfDII00CCr7+tRz8+52cREj9gRZUOssIAm5sxuCJP2u705tvzYbPUpLcWU4wF9Y/vn3DTlQca8HF7y3GB78/Vh7jszqQ7mpDprsVWZ42ZHjakUJmwBVEyv9j7yvg5Sivt5+Z1evuEnd3I0AISXCXQopLKdJipUApXooWKE6xChQp7hJISIgRd71JrrvLyuzM9zvvO+/M7N699+6V9IN/7wnDyM7O7MzunXPec57zPNESzvn3cbC5bFh557eo21nO8AaslEAlBVlD7ZaD2Hzfe5BsMsY/cAliclN5ucE6EQ7BrkKzayxjQKJOTft2oeybj7Hv3Wex9R/3Y8Ord2DHp8+gZNsSNFTuQ0DxIiouDWm5ExGXyB1KTBQHVwU0BWNzT8LA1OlIjM6BbHNCY6qLFqyBETnp5EiyFZho/WZM86kerNW+1kfTRyBeptGtCUoZhalm1mCPJWsgKCsjNf3HRulgcvZJSMNoiR+7IyMwINlebEVPLVjSODKQneDz39eD85pOOrdbTpqcXTySWcBEgVD32hJLwrYlRmLpyGPfPY2Q+6otsStLBXUXBZhyZmROeiVz0j2V3KbPSJwX1GobCZiS+C1oEDAZc3sUGP6USwmNjY1Bk9fLqcD7wlatWoVjjz02aBsFBLS9O/YTCMP+/xuBxmgS9o/Xm/C7W2sZm+DHH2Rh/DiX3rWgy/zqz2yycHMxWObIeh4YUD88HcN01Dq7oEToeJFJkNDUFMDE+YU4VKzg+GOi8ME/MiEZnQ/BTqCkPAC3O1IBKP7e9FQ7vvs4Ex993oJfXV+LP95Xz66TzOPRcOcfEnH1VQntmBJZOSDkI9g1CSu+a2OsjxOmunXyZJNjgFodrz/xIMoPeDHv7FRcfO8AENcejeB55wIxItoYURIvaogyjgNJmS6c+vJCvH/RF0yyedE/zkZ0ZjKjea7eWoR1f/wAkk3C5Id+iai81KBMAR3N39SCho170LyzAJ6iMvhr66EJpin2RUmwuaMRnZWPmPR8JOQMR1xKPuwBG+M7KN70NaqKN8EdlYwpk67Cnt0forxmCwrrNiIvaZKFscTyUGbiFCGaCpSSYKkKiX+PBvER/5UoqoJV2pc6wnsaUuX2o2lSaUxWM9gI+vmlozBrOGUNyvD694NRWtcNZUVJYiNNkQ6OBPWfJmXDoTkZWn+ENqnbTkgAx5K6KWkcLyUxMh5Cz3fH9utOmrdBBrclRmIDMFynSN4TkdhQJG2JkZzzEHaxEgY57L5oS+zK8jCMZUaobXG0Hnh25aSpLbE3Sp6EWSHcSGetqCK7xP8epnbZ8fBztLy84AzWXXfdhbvvvrtPjl1eXo6MjOBWTlqnAKStrQ1RUaEy8OGtPzCwjPDJHn2sDo893oi4OAlff5WNvDyHrqCuBwW60mBngYGlfZ8HBgFBvW917GY+WTAUHjzkxYxFRWho1PCbyxPwl3vTjACD/1+k8/mRamoDSIjjrXxdWWj3xMnHx+L4BVG46KoafPQ5zxicdnIUfvPreJY1oSsVtMFBZ9AXqU1f1QIoOujHkOFO3T0SLRGnUQ4oKn59XBFKD/ix6NwkXHV/NiMj4cEA997WUgIdmFgLA3AaREhZIxOx6LGj8cUN3+Hry97DiW+fj7qCBqz6/YcsoJr28HmIGZSOxoNVqF67Dw07itFaXA1/QzM0xST6oVKDLT4ejvQhiBowCPFDx8CdmMpIjvjEyY8kvwbNr6F050qU7PkeDlccpsz8NSsDjBh+KirX7MSe8iXISZpoaVMN4TAInWQRHOiBg2oGEOwhqH3JaIAHS2ORI4e0cuksjmT08F6BT/Fu2U78ek8aZg6vwuK5BXjko3A8A1qHTkyMNLuTDiYnQhwHxGtA7WLdqUmT86Gui0k9AI5lYRBzmJG2TNJ+BNwM1wYZqRFFMrXzUf29q8Ag0rbErowzErpRh+pO9/NpXuakI2lL7MpipXjYNBtq0HGWoq+dNNEjU2BAeArS+whnJC5F2gcULOVIvWsb/anKLhcVFSE+3hTZI5DgT836AwO9lEDT726pYen09HQZ3yzJQmISwee41oCwUIBg+0yB7uYswYOiiFJCcMaAjfX1/VasbsEpvyiDXwEe/1Mqrr4k0aJrwB2oqN/zdwJNzSpGDhX4guAfbOjPV+xhDQ8Ki1UsWWaihD/4uA1DBtfh9t8lGeem/9lCDiq0FZauaGOllnmLorn/0wfMRDN88XHFKD7gxwnnJuDaP2Wx8gm/yyIYCL6LpO2gEv2uJIo5/HiD52TiiNtmYMUDa/D54jfhb/JBUzVE5yZg4z3vwd/oCfpjld1OuDOTET0wE3GjBiN2zAhorgQDo6D4JNg8utiSYAUWaQYVqNmzEUUbP4fNEYVJR18HSXISGzRkp4RhAxdid8Gn2FH6GcbmnGRx/hT10fFE+UAAJwSJgwgciPiIolAetKxTv2Npa0qxk4BS8BcY/A265Rgkq1R3r2RYAwoM5o8vw+vLKWvQdaq1QathdMMmsDHyP31SWiSHS9wDkQYGRJgkatI0su2J0xyEkSwwoHNnIi/i6wvXBtkdS0Qay84Qgr6jTgaP0ZZI8teddzxEYsTGSIEXXYe1OyTUSavdaEvsyqhswvEjStjfw3osY06atyX23kkT4FRmwUhF2Ne3az+ylkYOphyPn5pJfcRjQEGBNTDoS8vMzERFRfD9pXU6X6TZArJ+jAFDTKv45YWVLCgYPMSOZT9kIy7RxoCGhAVo15rYAaaARIKUkG3ke5QA1bxDj2PiGv7xVgOOP6uMpdHf/Vcmrrgksd0xYHHUrMNBU5kGQ262+IO2hhzhLHjrjt0+zDimFC2tfPuF50UjM0PGY0824dKrqnUsAQ9cRHsi+TeqOlCNm7b9581m9t7zfhln7EMj9V8uLEZRgR+n/CIOt/w5zehQoLZE3rVgtjTSOtNU0OiRTrwKqjlJKiq3VqJyUwVklwxfg5cFBWStJQ3sahNHZmLAaZMw6Z4zcPQ7N2Luv67H1Mcuw4irT0baEeNgj43h+AQxOTQEnHpnAutSMKf6ol04tPxdyHYnxh13HWxRbv6azoOQnTMNbmciyuq3ok1pMrEF4osRrRoiUyCCBrEutkkStig/MLKjFGRhlI13HnRlozGdzd8t3YW1ezmmon2HQvtvnwB867CMfcZpPXBi5GSJKpja4oiHoCvj6e5VvapJk9H7yHlRuyaltDsyj9bKnBi/vnkdtkF2JyAhO4gdYV/nHR2iLXE6K3v01ij4IiPZ675qS+zKCHhKRgFJqBEOhVg4U7vZltiVkRYIcSCEtoRSiYuyNETN3V0wZb+ZNmvWLCxZssSyBfj666/Z9u5Yf2AA4JyzKvHdtx5Mne7EF99mwOGWLI6ZnLfV2XOnTulw69yvkcpgiOMXk0JUvnRMMxhgx9I03PNgDa6+sRrR0RKWf5OLo4+ONlodrW2PRoDA6tYSikr4qHPoIEeYDLYUNCFoGdiwxYcjFpUx4qUjZ/M01jWXJ2DH6hxMGOfAh5+04pjjS6EqgSCfRuBC1gqoEyT9uMaD+HgZaWl2PSjgTImHCvw47bw43PZgOgsACGjIQYnUvqjoy5z8yCaCAgZ0VNFa04rvn9uJV89dgidmvIv/XLoEez47CNVrPkiG/2I8zvz2Kpzw3qWY++RZGPOrI5E+ZQAcTgpaeABA5Qy6WB4QUGDGt9Pnlxyc28DgLbADTeUHcfCLf0Gy2THq5GvgjI3ngUNI8DBm5FnsM2wpfNcEG4qgIDQACJ3ry7sDnAUuFomYIM81X7NamG0Ma4B0JpD07FKe1j12fBmyknRJ6k755QnYOLPHNMOidXEvNkfAHSBq0kf1Kt1NNhij2ZxKGR23QS5hpafx7PoS0VujlDlpSlSgpM/aErsyAtgRDRBlhPqqLbEry9CzMKEcCoe03ToOhZx099oSu7I0cLnwagt2JBhMOf+n25ao9cHUTWtubmZthzSJdkRaLiwsZOu33XYbLrzwQmP/q666CgUFBbjllluwa9cuPPvss3j77bdxww03dOu8P9Fv4L9rO3coWHRiFF5/NwOaLAd1FRCzf7jsgJWngDMldtKdoGMMzG38mBf/qgKPP9WAzAwb1q/OxZChTp0sKUxwEXLudZs4knXU8OBuBbLOMAcrVnsw76Qy1k33wesZKCsPgEpcY0Y54XTJ+OHLbJx2UhQ2b/Vj/IxS1NUqLBBwaoQf4Dg6+tG0NauoqVYxYZKTawYpAZy5sJgFBWecF4c7/kwPVw12SYJd0vTsQKBdpsDj17D+kzK8+KsNuGvOt3ho/nf4/sW9qCpoQnJeDMaemMOVj2XguCePhiPGgb3vbIWnpjEoE8ADAt6NILGcnawTIoVMjDlRg+qSECCyI7uE1upyHPzP35gjHnbqVQx/wEiRdO4DPnFypLikPCTFD2IcB9VN1BnQQSDQQVBwyL8Theouxu43XV7YjlI7yMLUMwWvAcsa7NOzBkcUdNrLL9oE0yT+UO6J0SicxHCoxa0jkhord0BfpbtTpUzmpInfP9z5KAghjAYxNRI+oK+MgHJ0XGoj7YuOh0jPSd+V9Zy9aUuMrFMglil0BJeAtrIgZfphcNJUNrNyKFBXRF+AKf+vEhytW7cOkyZNYhPZjTfeyJbvvPNOtl5WVmYECWTUqvjpp5+yLAHxH1Db4ksvvdStVkWy/sCARt0jbLjo8liGojeZDHmnghrioBXL1GWmQEwBItwxux98/gAWHF+MTz5txdixTqxalYv4JEq086AyXPARurx1Fw8MJo8z06ahDXG8i0D8GiV8/V0rjj+rnL3w1XuZOPaoKBw4pDDmRCsb4+svZuD3v41HeUUAk2eWYP8eUksMZkt86y3+8Dr9zFhWPjhtAadPPuu8ONz1YJqltZEHFE6D+CiAgq0teO62Qlw7bxt+PWENXrt1D3atrIPDKWHiglRc9cIEPLh+Hi56aiJ2fVPGLuHkx+dgyOwsLPrL0YyHYNn1HxsUyXaDIlnPFui6Cvx1ynKIwEFveaR9iRnRCXgbanDo70+z+zTotMsQlZHDswlGtkAnR6KMj51PI8eey9Lk24o+ClsmMEoIspgTlaKMcqUQe/zr2EN3pu349kFBKIFhO9YrjfEbEMKfnNMLetZgwYRSZCa2tBuSEJBL8MtH2ibYmQ3XswZ7OiA8EtwBg/ow3S1EeMhh1mrBo+mtWM3KDMTkF4kcdXdskJ6pIHxD+LbE7nc8dGUDdVpmUnrsq7bESLANlE2q06oYw6VZAjo8TpqAloQ7ISVPnl36Tmem7H126f+iHX300brOS/Ak2AxpTkyHoe/ZuHEja4Pcv38/Lr744m6f96cbnv0Xbd/uAM4/neuFu6MkpKbJyB9kx+hxTkyb5caUGS44nPyP0vqc5lA6dDnR6Nzu4FmChjoFCxeWo6I8gONPiMILL2TwY9EXzioFHCMQhF9j0aoWtG33Pk5KNGak0wD98c/XHmNAW97/tBnnX1kJuwNY+nE2Jo1zYvnqNpbNWDQ/ul2W4a7fJ2PYUCeu/G015i4oxRuvpuHY+TEGgvGTT1rYOekaTji2FAcKFJx9XizufiiVt36KLLsmoaFewX9eb8LSL1pQsMcPv6426YqSMHxSDGYel4QjzkiHLdpltDBWlnrw17NWQ/GpOP2RaRh8RCYULYD8yakYfvIQ7Pl4P7a+sArjfsVHUQw/yCIrUmHUYCMCJSaaZAov2YLWJfg9LSh87gloioKc0y9A1OChTImRqS3qDIiyXZ8cEpdqtgN2ewxycmeiuHgl9lf+gCFpR+ghtt7gKekhHPtCSe9ZQ523Eltbv2PguFnuk+DQXNB0EGJ70zrNHtBonDoU3i7Zhav2pWDa0BqcP/cA/vKxOYLdqq3RgVyZfcYvTxkAIsapQkk7FcLN2kpjJD2kD9PdZNQdQKltKidwohxgr7YVVShlGISxEsde9KXFSQmwa052jr5qS+z6nEmwaXaWZu+rtsSuLB9DUYg9DNtQh0pWAuJgysPnpBOQzACI1uxSOMDlT85UnXymN+//mVh/YADgsVfSsX2TF7u3eVFYoKC6MoDiQi9WLvPipaf5yNjpApJTbMjNt2PkWBcmTXNgxpwoxOntgqHdCUEBREBjLHy79nhw5imVaGnRcNU1cbjl1mSGN7AWAlhEaOkgYJ3yhA8IcReFJQrLQhBano5BEskdCTX9850mXH59FVwuCau/zMHIYaStAPzzTRplApf9Mq7du2ht8ZlxGJRvw/FnV+Dci6rw53sUXHkpR9Nu3+5HVpaMExeVsaDg3PNice9DaTr5n4qvP2/Dh/9pwuYNXjTWc3wADZCz8x2YcXQ0TlichIxBMVBU4jGgiXgN+H71lV48dNp6ptlw1oMTMWp+lv4aD3rm3TEVRatKsevfW5C/YBjiB6UxUCIBRSkoEM6f7ompX8KDAtZRQXLSba0oeugRaF4v0k8/G7HjxjElRuttYPQD5N8ZQ6IeMMhczXHQkAUoL9uAA1UrMCB1BuwUPRjBQDCXQYu/AesbP2GHnh59EtxSrM6USPuHPCzCtUO161CIRpKaxhDlLywbyQKDBeOJDXEQyuujmaQxxzAk9HmNeCBGYjc24iB2Ggx2e7VtzIH2lDsgkjIGMTDSKJMCEior0KiaJKbJiR0uI8AlBSQlGl3tOr3joedtiZFYElJRjfI+a0sMNbp/5j8SESegLw9GhJgUOWsiWxJqMfR/65wvi14u62videvc+o9vIxAlGWWXKNCiskKpdpBtE3uaS6JVO3jZ/H/vhbZ+ysyH/79M0kyB+P85I9KHhIQEfLZ5MGLizIwA+9FpKvbt8OHHFa3YtdmLQ/v9qCpX0NLMpXqF0Qg8MUlGTq4dw0c5MGmaC7PmupCaSh39/HjTxxQzEqDmJiorAH96JBlnn0POWAcKWtoSuWqhuU1QKItHkdh/0sxDqKsPoGz3YIMcycpKKOy51+pw3W01iImRsHFJLgbk86CA/qxGzChEVbWKmv3BrUgmwwL/4ztU5MeshWWob1Bx2YWxuOLSWMw8upxdE9FFn3d+LC64JB7/+nsjln/vQXGxwkfv9KBLljFxqhunnBOLWfOiWXTAcBka4FEd8Gl2PTDgmYKa6gB+d9wWeJoDOPdPozHh5HzjdetUub8Zb537KVwJbpz8/mIoAScCip21JIpJ0VsUAwqt26AESDpbht+nYtdtT0Cpb0TSSSciec68dpwGxrI/zLJHhcOjobpkO7bteRupcUMxecDZPDXE6JF1SuSACq+vGSsq/omA5sfk2OORYsvU9+HUye2yBu0CBWuDqvk6dRr8gM+Y8/92cTILDj7fkIObPo5hTox6+Y/ACX3uxMixLMWHzEkeLZ1iOM3DdT5h5Dh2YB0rG1BgYIMNc3AiS00fDqPrJJY+ahEURhLDbsQwJUPVmNSQZbFO35q5zXSmwo2ajtV0q+SqfewfGd1jO9NDtTpDq3O0LrX//8/TQunaglvFQ//P71oADQ0Nh60FsFH3E3OOvQd2e887XhTFgx++ueuwfta+sv6MAQCv5oBdEzQ+Og+BBAwY48TAMbFsnYkq6VQ/ZQfasHF5M3ZsasPBvT5UlAawdZMPmzf48M7rfBROo/n4BBlZOTYmUETPc3Kkr72Zhukzoxj2gJ3HEhSw8TDvRTQzCHogYHAg6CWF+voAkhJsRgmClRl0oSaWPYCEx56rxa331SAhXsLmpfnIzqSHDD+vqmqss2HKBOJBsFpovkHDgDw7dv+Yw4KDl//RjA8/5ddIQQFJNb//XjP+/QZvXSQmxvHjnTjuhGicfV48YuJtnBqa8RSY/D5Msln280GzfqbmegW3nrCDBQXn3T0M00/JhF/TOQ1CprTBsZh82VhseGkb1j6wDNNuOxYgmWaLuiUTxZZkNhGuQKbshD+AHbc/z4KClEVHIXHBkdC8emZAlVjmgWcJeGaAlxUooOC8BxIpZdJ1yEBa5mjEFKWhumkfmjxViHOm6lEZzxgQodPKyn+zoGB07NFIcebwgMCCQ5AYY2M44iuePeJbpLAo9iQtJGswoQRty5tgq6eR7cLD4qTpmFnaANbiVqDtQAF2MCfdFyNpcsbkGP3wsznhCsRE/8gECJFwFoR1IJpr7lrDOWHTGYcbxYZ3tB3bTmxAX5r5vZrspXQdwui+Clo1/uQR2clgdVb+OmsuNtY6Wjb348uU6SEcClkqslman+9B/+d7MyCvsRZ6DJvl7HLQP/4+/Z/+26BsFvFhkFEweaR0Uq/uIf2NUaDab31r/YEB46q3w0FPepGsZiJBZuxNcDbC0HNSIiBjYBROHOTGyRfytj2uJaChusyPdStasG19Gwp2+1FWomDHVv5AI0tN507SKB8YuACT8EicU2QJyDmIMoIA/9Ey8Q8MH0bNfpYyhoXB6N5HqvHA43VITZaxdVk+UlOsan4avlzSxnzUSQtjOuxmYLdAb8eLjZWxeUUWTjinEstXmtzeRKOcl2fHvKPcuPCiOAwf4TKBkpSyZweSuOaCiYM0LjKKhuKqhOZGBb89bh9aGgM4/w8DceTZFBSYhEjiu6F8A3U0OLQAjv71CBR8U4jCr/dh4HHDkD4pn9EO02SzUYaAMgU8y0IA0ICqYOc9/4C3ogZJc6cg4/RFDFPgJy0Fa1CgL7OSIIu2NBZzkG+i34WBQQgAY0eeizUbn8bmwvdwxNAr9S+TBxKryv4Nv9qGobEzkBM9gmcK2jEjUrtKe6xBcCJPXzY2aQYb4g/4HG8V78IV+xIwY2gDbprlwuufz+3TkTQ5bEr7UoseTVQyIKOggCwZGUwFj7QkrKNp+iecczhHbXXM3TVru5tp4i/IdJvmsunUrE6ML9ksr3BnR1MVitk1CBVEKl3Iltf5El/mc/pHrbviNVq2RxwwES6ESkDiEx8lnYLDaRTYUVBAbYmtaGKfuiNBrb4wyi5RUEABAZUQCDj6szKtb5gPfw7WHxhQxoASdkyBj5vhiliboAgKhPMGAhLdOL4sk+OWeGAQn2nHsWe5seBsvn73taVY+hkfXbujgPLSAC47twp5A2y4/b4kHHFUNHuv+QgLZii0/oyMT6eBpcLJl+Tm2HW1R55S48kGCbfcXYmn/9bI2iC3LRuAhHjZclyemCaBJrJLF8cF4RLCjV0NvIMKVFSaTmzkcDuWL8kEJB6gcPZCM2vBswO8xCGOE6r6YCfVyVYvfr2wEE11ASy+JRvH/TINAabmJ8PJsAcUUNngV+3w6doKfi4YjTOePwqvnvQJVt7xNU79+ELYbE7D4cgWFC9lVnY++A5aCsqQMGUk8i8+FYGAypy8jboNFBvvQFDN7ICsWrIG+qfm+wAaCSfagKjYFKQnj0Zl7Q6UNmxDdhzV3SX8WPYW2pR65EaPxaC4KXqmwBrxiWXq9Qy+8YazDP1SQtYpa5CopaIe1bj9h1YsGRqFyye58NVSG6rbGpkTp5Y7PqeRuDkKJ5pb+kfz0NS4dWQdiQmAnvWXEzyylY3JQY7ScKLCoQrnyp0qpc+FUyUEuw0O7MFGdh3CSRMg0ToS7WvbrK1i90W0aDrhOKxOk5y0wIVQ4EV1dyJuOlwgwDKtkAV25KAp20Oj7kZ0LajUU6OuByo50XdK2SzqtiCwak/VM3/OzIf/k4HBn//8Z7z33nuMXIEoGGfPno2HHnoII0aYMqYejwc33XQT3nzzTdZSQT2WRMRgFX+g3sxf//rX+O677xAbG4uLLrqIHdtuNz8ytWlQX+f27duZMMUdd9zRo9YMr2YGBiwoYF8gsRiSezczBYLIl7Uz6qJCLGPA0vt65kDSWN345nMPYefGNgwZ7UbBTg9GT4rCvU+l45Hbq7D861b8+sJqVma45e5EHLMwxiglWH2HgNUIPyJKBTt38xrkoMEONp5hYsQkxgTgN7+rwN/faEZ+rh0bl+UhOoo7aDmoNKFh5VoP4uMkZKRyzIFpltSqJaPhVzRMO6YMe/YpuGRxLHbv82HlGh/+eFcDHrgvmf/RWBwXiR3xTIFFfMl43VSh8rSouGhBEeprArjgxlScdUUK/LqmAtGn+sk5M8yHBpUxKPK7RHec2kRjUqNwxO+mYvmff8Ty33+Bo/5yEiQqpWiq/ofMl3c8+gnqtxxA/Kh8DPvNOSyDQJ+RHD+1OQYcMgtsKE3AKhLWDIKiZ5B0mWYThMiXRw4/HVVrdmNn2VfIjBuNLWUfosFbhtSoQRidPM9SPpD5fQnVUggSV6JMhMqoaOmh6UUrPFobfGgzHD138Nypk5Mn+/agH5vKnZiYacOg8d/i4zWRqANak83cUZMDNJ00OWbunGmif9RqSQ5FnJf477mTjnxk3F3bqK1g105MfeQwCT1/OPvdKd1NnRfkoKdiHr7FewwQGIlccE+MdzzsMDoeiI6ZrpOEqwQLY18a0S5v1zUeRAnIrUUzBczDYa1aMzZgOfuVTccxLJuVomWychS1f5IuQr/9tKzP/7qWLVuGa665BtOmTYOiKLj99tuxcOFC7NixAzExPDIkFiYiYXjnnXcYqOPaa6/FGWecgR9++IG9HggEcOKJJzLe55UrVzISB2J3cjgceOCBBwwGKNqHmJ5ef/11RgN5+eWXIysrq9tkDj7VBjv1phmOiwcFohfAHFHzZaLEZ50ARs3fzBp4WwK4/uS9qCjyYeq8eNzxwgCcNnwrouLscCe6cfezuWhp8uHxP1bhu89acMMVNUjLqMNNdyTj+FMI2MSduMAUGC2KAntGJCvb+Mhp5EgHG9uRkb+5/OoKvP9RK4YOseOHr3PhctMn4m2VYhRHSHt/QEN5ZQBHzHQHARXNvUzQG21RlACmHlNqBAXPPJKCgKpi7OxSPP9KE4YMseOyi+P195gMjUZ2QCdFEpkEESN421T8YkERqisCuPDaRPzyGgoKaNRKwYyunyDROkImqt/zq6LAY9yZQ7Hns0OoWF+KQ1/uRv7CUbCxTAFPyW9/bgkqV+xCzMB0jPrD4nY9wZQhsNkCUGTKGlBAgOCgQA0NCniXAmd70mCz2zAk52jsK16CVQUvo8VXgzhnOsanHY8mXw3a/A3w+JvgDTTDp7TAp7bBr3qhaDT5WQpeIMQjGaWbiXDivjAzOK+vd2PiiX78amIMPlwzSHfl5Op56pZP7l451Q3achYUZGMQc17E1Gc/TABAsj3aZib0k4AUJhHdoNWytPfhsjLtkJHuFtwB5DSbD1Pa26rxIISYkjU+QKIAoa8DA8pCrAtDH83lppvg1Txw9ZJS2mo+C/MmCWnFSBx0J1QkCSPzswkMtP+droQ+Dwy++OKLoHUiYEhPT8f69etx5JFHMkTmyy+/jDfeeAPHHMMV0F599VWMGjUKq1evxsyZM/HVV1+xQOKbb75hWYSJEyfivvvuw+9//3smT+l0OvH8888zlididiKj969YsQKPP/54h4EBZSes2teENmXbNTvrH4buTBQpNCgIyRgwyWFLxkBPW1Ob3S2n7EBzfQALF6fjsjvz0NLGH9xRsTaGwCdX7YqTcfsTubjxTwqeursCX3/UjFuvq8Yj99bi+tuScPKZse2DAt3p0rY9e/hobew4B6uDUxbgoovL8dU3bRg7xoFvPs+GQ5YswERe4BdO/z8ftbDrPOOEWGsfRth7RiqJU4KCglS2nch5Vn+VjRHTi3HLHXWMmvnII0Xak+MnrBpC7ByckIEHBV4V5y0qYcDNX/4qAVfelAwvtVJpEnN37K4yTofQiWcKKDhgNMpQYddUnPz00Xh1wbtY9/ByZM4cAHtcDPtOdv19FYo+2YyozERMevAiTiAVoNKCyCjQtUicDdGhYw2E8xdYE0v5gJx4a2Ml2mrK4Wmshq+5Dr62Bvh8fLRFQQFZk68S3xY+28lfilnxppG5A9H62JwIYFzs4UzOyaW54ZZiEKVFs3UrKdJWdTVLPxMrHtVrv92WBv9xZRidGcCC9IE4WMU7X/rKdmubmLNKRCpGS1MYIQ5R9YZyGvSVlWgFKMReuBDFCHAEQI6ElYjsKFninAZ9O5L+sZ0QE10vgR77OrUfrPFgaljQeYnnglLtfWlEH70aX+v02LOD6KPTkMkYFun3RKJJfWFWdcaRmIwUyZSUpmskdce+vsbDaRI983uBE+jNe//PYQwoECBLTk5mcwoQ/H4/jj32WGOfkSNHIj8/H6tWrWKBAc3HjRsXVFogZ0+lBSobECUk7WM9htjn+uuv7/CzUCninnvuabfdr9lZcKCJTAGTu7WSFwl0uCVjIFkyBpKG4l3NuP+8bfB5VJxzcz5OvCwbXlVDdSVP6UbFO1h6nEkKsxS7CleMHbc8ms0DhHuq8Pm7TfjjjTV47L46XHNzAs75pdnSYq3PHzjIA4PsPEq1B3DeeZVYudKLqVNc+PD9TAa+EwDAoFG7jk789/t8xHXROfFh8O4mRoaAeZP1oOBSS1DATUJCvA2rvszCpCNLcfaFlVjxTTYGD3UZgYwwURYRnRNev4qzFpWgpFDBLy6Ow3W3JbMAhwojFAzwWrcUduKZAk6zTCNsKgFRicEdZcf8B+biqxuXYtkNn2DBK2dj37tbsff1tXAlx2D6UxdDIvZCIjCi78yaNZCpjTQAtbYGLYcqoJRVwV9VjUBtPQLNjQi0tUL1eaGS6EXYP25dh0I3u+RGUnQuHLIbLjkaLls03HIsU0iMkmNhpyCUtSvylkU+8fUOSY9Czlugbjdq0iSh/B3ew05PEdbuzcSckVU4Zlw5Xvm2O4GBtdbT3oq1AhRhH6Nynowj2bYcDGSBAUnp9pUzCa5Jb2BB0wxLx0MeBrPAgKR7BdlRX1hnQkxZeotkKQ70WTmBazx8o2s8zGqnYRGHBJaN6augiws/cXrsYRiPNCk76HUS8yKjc/bVd8mFn0idcThyJU6FbDX6LbUepvJFv/2EAwMiuiFHPWfOHIwdy9nQysvL2Yg/MTFY7ISCAHpN7GMNCsTr4rXO9qEsQFtbW1iJSRKcIEyCMNqXsAnUT68G7AiwTIE1ELBmCyzgQ3bj9IwBNOxYXoNnr97OnMxlj47EtBPS4GUBg4rqKs0IDLwq1WG5WJBMZDssuFABhw1X3Z+PK+9S8MqDZfjk34340x/q8NTD9bjq+gRccGl8UMqfQIzU+kjO9vRTK7Bpkw9z57rx+hsZ7FMRINFGGQOLd+bv5x577UYPkhNlxMVbHzhWp6BBUVRMOqYEe/b5WVDw7COcftfaIUA2aIATn7yVgUVnVmD+iWXYuDqHyVWz0rmuRMyCFL207ldVnH58GQ4eUHDm+bG45e5UIxnOMwCkwkhH570b1inAAI08qKI2NWqUCpDugkYkTwEMmZuNAcfk49C3hVh5x5coXX4QjlgXpj14Jhp3FKLpUC1aShrQVtkIX10z/I1tCLR6oPqUoBq/1UhUSXY6YY9NgMMdC2d0PFzRSYiKTUVMbDpi3Knw1FZi88oXIUk2yBK1mKmYNOBMk69ADwI0EQyIc7FaBwFHdHQjrROyNWz2xvx+ylVek3awmjQf2RIIkdKyX21N44HB2DK8+u2wIMlw8d2Gt46DAhqd79KdtHUknYWBzHlTSaEvAwPCVoiaNKXzrR0WNGKn7F49OFPp4XHSwc8mao0k6yucAdd4WMKwIkMwNqzGQwoymZOuRiljk+ytbcIKXeJ7EAZI7VP3VF6i+9rURwDErdpqQ/hpeAcSynFIYlwRVG44XHwUfWqqBfjV0/f/TOywBgaENdi2bRtL8f8UzOVysSnU2lQi13Hx1HJIdiB4WXQlaAb4cO37xXjrrl0M2X7Ny1MwdHICfARg04GItTV6KSHJyUoJppogjYs5xSYdidZtDglX35mFq/+QhpcfrsL7/2zEw/fU49m/NOCyq+Nx6VVxsMsyIwEiNcYTFpVj9y4/Fix044WX0vXfnQBIWmr8upOm11paVVTXqFhwdJQxCBWMicJlKAEzKLhMDwqCOw0tAQckzJ0ZjeceS8FVN9bg6IVl2LQ6BzbSZraUEChQoC6A008sx749fpxyZgzu+nMqCxh4JoFojCU49EwA73Aw8QUKrRPfhN70Rjh2MacHe+W2Ohz8scpwuhQUkPmbvVhx5T/afeeS3QbZ5YA9LpqVHRyJ8bCnJMOekgZ7RjYcKVnM8co+DTYiNfLp5EZiri8rTY3YuvpldsyJEy5GTfkOFJavQlnDDmTFj2rHgsjTKTqK1LijJveBZJOhUfAQZCYQtEGlmvQqlu6eQVwFVFrQiJFwFAsM3thThVu8NmQkejAmvx7bCq0jUa3bWQMCjm3ECh04Nj8IT0ABQrQWx9LBfTWyFU6avuWJmINYvSZtNeq1J6dJ+/YWhBiJk+5rnMEWrGQOMQsDOux0oCzFXmxhCo+9DQx2ahvY/UpCGkZJUzrcLxqxfZLa38+YN4tZNotKFh0ZZXwoE0NdLZR9+qmb1F9K6L0RoPCTTz7B999/j9xc84dNgEKfz4f6+vqgrEFFRQV7Teyzdu3aoOPR6+I1MRfbrPsQo1S4bEFn1ka89Rofp6KD8kEQ+FDnIljyzB58+8J+OGNsuO7t2UjLi2blAwoIeD+DytD2ZFGJLiMwoO0y64LgD2JWXtD/MdEhm4wrbsvClbem4bUnavD2yw148qEGvPhUIy6+Mg4NjSq8HirT+HHK6dF47MlU5nMEyJCn7k1XzmtbHN3/+ru8jHDmKbE6gFJiQYMIDlimYF6xHhTE4Tk9KDCRCBzFbg0OaOmCc+OwZ78Pf3mmCcefVo6vP84yBsEMTKmqOPO0CuzY7sMJJ0fjwb9QSyL/rAZBEyN1MUsKoZkCpdWP7WtqsWd9M4p2NqO6qA3NNT74PeHT75JDRvqUXESlxzOMQUxeKqIHpMMRF69zHJjMiIpig1+xQxEsiX4ZaivrxORNBQJnIOY0+Nd82LzkWaiqgpHjzkZ8Yi7i3BkoLF+N/VUrkZkwJlimzCCGoC/LEixYp1D5ZYt51Fas10gwRcIUzINb1tPdEpAiZcCm2lCoFGPFzkFYNLEU88eWWgKDCOqbIXEBOV4SRjKBY+1LE5nIY9kL4hVI1yV1+yrdnSrx9Hb7c+YzR0ep/d5mKkg0qCsn3Zc4AwJTVutgyjESV8oMZ1TKoK4cGnX3xgq1vQz9H4UYTMLcTvelz0QZA1J3DPddR8pQeUAHb1IgaS2xhRrhRcgIt9LTwKASxT16X7/9lzMGlE6/7rrr8P7777N2QgIIWm3KlCmsu4C6CM4880y2bffu3aw9cdYsLohD8z/96U+orKxkwEUykpEkpz969Ghjn88++yzo2LSPOEZ3zKs6IKmcwtjAFuhNpx2BDz/+w3ps+aQEsakuXPWfoxGbRPS+elDAgIl6YFDHnVZ0SpQRGFD7nHgAs/Q5lRUoQCBHKVFvPXeEJFl88Q3puOT6ZLzxXC1ef74Bzz1hjlrOXRyNux9ICQYZ0mNcZ0tEkNPl+3zwCa/pnXlajJFhYMEEZbEDKibMK2ICTTwo4Pfe/NO25hX0O8JAkbwR/77bk1lA8cmXHlxxbRVeeDrNIGQ65+xKVvJYsCgKTzxDQQHHPIhOBXYsvcWxptyPVSuasHW9DwW7fago8aOpPoAAiRhZzBVtQ3y6C8n5McgclYiE/Fh8du8mBhKMzohGS1kLpt48F87keJ0mWQQCXDNB9H9ybitiSKRRL3VCkAqjBNUpBXEWWOeUy9j55XNQfK3IG3ksUnPGElgFNqcDSXH5qGs6hFalAdF2GvGKLIEeJQjVK6YnrbeUsBtFo3+NZQ046ZGZs1JUBWu0r1kWhdLdCXJyO4efjEzWZvfplkQWGBw5ugLPfDkKCl1gJLgny0OcA8dMyWYrcCxUhIcCgyLs73VgsBk/sHQ3tSWGS3dbAwOiR6ZRaW8Cg73aFhbQUAaiMyctzslxBgcxWFde7DmYMtoAU3ZmNILvDQkQSSgT8RRBWq04jc6UFgkvQvd1MEb1CBdC3wtnwjRLTh0ZlQ9ogNTT8gWBRXdgPf5rpvV3JfSqfEAdBx9++CHi4uIMTAC1JdJInuaXXXYZq/UTIJGcPQUS5NAJeEhG7Y0UAFxwwQV4+OGH2TGIo4COLUoB1Kb49NNP45ZbbsGll16Kb7/9Fm+//TZrg+yuUbsi0eVy9LzZdx9aTmCbVRXvXrUSxeurkTIkHhe/cQzsTomXD/SggHcq0OhfZh0KZO6UKHjpHJQT0FkAWfmAYQ0kHhjwV5lOg/hHCH2bJOP8a9Jx4jkJOPvIQ/DrjRU6Dw/zH2LELbhymMIhG91TtZ4bXd/mLT6kp9ngcsnMP/H3a4ynYMoxPCi4fHEcnn+E8AriryE4HDAImPTyhKBnIjf/xktpmL2oHO9+0IphQ+pw0/WJOPe8CqxZ68W8eW688Ld0ViagDMLunX6s+sGDLZt92L/Xh8ryAJqb1KByP2XKo+NtyB3iQvbgKAwcH4uRM5OQOiQOAcnUWqivVfHEid9BVTSc8OhcOJJj8OElX2DdQ0sx99GT9bYOXXHRptP36K2K9BJTR9aBiAKYqNolqLLUPmtgBwo+/Qe8jdVIHTQZuSOOhObXWIBBz8Khgxbhxy0vYm/5t5iQf0YwlSWjUwwpL1izBdbJwmuwVvuGcRiwdLctz7xBFoc/BGNYYPCfg8W4q8mFlDgvpg2txqrdHB8SkelBC9Wk2/SadGeSzVRaIMXFBvBujN61JVLHA29L7MxEar839XBi4SNFQd7x0LUQkwA6UiDRk8CAcBommLJrp0mWiDSW2qfuj1gpoVvnawqSUF4QUcmFSg1kxBNByhA95SrguJDIWh7p/gtK5p61Xf4XTetnPuyxPffcc4YmtNWoJVGQD1FLIdVGKWNgJTgSRnS2VIagLgQKGIj/gAiO7r33XmMfykRQEECcCE8++SQrV7z00kvd5jAga1McCPgd+vPYwktgLPP9Ah4Fby3+Eg2HmpA3IxOnPT2XOY6goIBhC2i8T6xsGloaRGBAZQYKCmh0zvfhfG+qZSJAnY05LwoUKIfBMgeQUHjAj2tOLTKCgrQMG955oxU7t/vxz/+kweUi0BuB93ifPzdTe4xGwrV1CitDnHhctNExT76JygfTDEwBDwo6MuGHeKZA0Nqa2+l7XfZpBkZNK8WDjzXi48/asH2nHykpnFNh3twSVFUF0NoaPIQlMGVisg0Dh7owdKQTYya5MXVuNOLTHGhTncz5M9ZDlQcCpNxMlMn0z+/V8OxZK+BtUbDgDxMx9KgsFjAkDk5ExboSeGqa4UqKg0pOX1V1P8wzAyx4YgN1Ku9Qq6I+V9tnDRjVRQAo+v4DNJXsQ2zGIAyecToLCljAoZcYYhOz4XLGo6ppL7vPshVXYIhadBAMiICBU0my9S34AS1oYKPWQbYxHdIhxsoJcKhOVGrl+G77KJw18xArJ3QrMJAkvS2xkqXPO6tJC0tDFusSoBFcT+RzxUiadzx0PZIWjppG781aY1gcQqQsfJGMpHuLMwjGaQSDKTszKtMUYx/KUIRhiDww8Gkeps7YXQllukaSmu5ulkKxcBVMxBHdCmIIh0DESt3Bi1jbLsdgOiNr+m+Y1M982HOLRKzR7XbjmWeeYVNHNmDAgHalglCj4GPjxo3orbGasmoP1krQX6P0Mpmnrg0fLf4InjoPhp0yDEf8YTZaVX3EL/NeetZlwJgQ+cifptYmRSAf0UrbqWOABQUEsONsfuY/vQ1PJdyBjsCHhF1b2nDbeQUslZ6YYkNjfQD/+WEA/nh1Gb7/qg3HzCjHmx+lIy+PBzcCa8CyBno2gTb9+y1Og3zWGbyMQNeq+FXMmk8tiX5csjgOz+iZAhOQaM0HcLCh4CPQ75CZVdCo00PFP99uRm6uDZXVKgsKyGpqVCz9zsNEl9LSbBgw0I7RY5yYNtONKTPccEVR4YVrKxDQkMIpKjcweRzJz+8NIzzi94ndP/o0AQWPn70OTdVezL1iGKacORA+PWA46o7p+PDSr7DuwaWY+8iJsHENa/ZBqWOGB2+6VLMe3LGMAekk6JkDljWw8awBOf3KDd+jdttaOONTMGzRpdAUk/fA4DtQNeTlzMK+A1+isOZHDEydrt8iE2TIywjhSgp62l/mB9sb2MRSwkRAM9ZmLZPx6whaZ1LBeSjBfnywJQpnzQRmDq9CtDOAVl/oQzf832mxtr9dW2JXNgAjWGBAI3Aqc/S0LVF0WERieRjCAgNKfY/EpD7peOjKeoIzsDpNqvELgp9IjOiYyepAWCre1dWVUQloNeuwCDCnmdjNQC0GcSz7EymYVJyPuApGYBJSOyg5dZalIPAh4QwiKUUJbgRR4qKgtN/63vq1Egi5HrABAXLBwTTAPECQUX+wDl9d8SECbQrGXT4ZEy6ZBCXAlfsUCgSIV58FBVzghyZWApA1phRIx2nRXCxQ4JkBUTqwLtMExtjHSHtY4KBi2/I6PHzVPvYcv/WFoXj8+v1IzaDWSjvufz4Hrz9bjRcerceJ88rxzMspOOoo7vTJMULU7/XB6hdftDI/tGhhFC9DBFTMOaYUe/f7cfH5cXj64XRdgy4YkIgw5QMRMrR5Anjrgxa882ELNmz2oa6+fU9OcpKEt/+VhjFjnczxcf0J4fjNZR5vmIBE4bqcUgAKMSKykgvnOBDzpy7dgsoDrZhyeg7mXzOc4TxEBiZnXAoSBiWg/MdieGpb4EyMNaiSKSBgWSE9Q0CZH2ohpaBMDs0aOCSWMWjcvg2Vyz6DzR2FEWdfpxdqRIaRB3SijSI7dyb2H/wGhdVrMTBtup4JQCeZAhG0mNtK1AIc1HaxdOtUaX5Ef9CDMJoFBp+XHUBhdQzyU1twxKgKfLW564cub0vc2K4tsSsjrnu75mBZhu6Y1Ul3ZyRNRn3/VJ8mVsSedTwc0e1Mg4kzOBRRDT7UaRJAtDtG95/KNASOjNQILEqCV/T5sqR8dNeofEGBQRPqGBixK1uPpawUQFiPPGlIt89HwQDhIOh7jCQwIK4JyjCQXgaVuIg59L9m2v9OKeHwkJv/DAMDJWBjc79iXZZR/GMFvrj4fVZGmHLbMRh1wVSGaKd9xESANv4eO7yKA22KE80BFxoVFzwtAUiyxKSdScWRUtxsri+z1LhlIryDSJt//1EtHrpyL0tF//HfozFwfBw8pKo4IVo/jg3n/ToNj/89g/mVX11Yg+eermfMgIqOHxAZaXL4O3f6kZVlg2yX4VMCmH1MCQsKLjo/Fk8+kqbL5/CMg5BHJjP6MzQJfkXFe58045xLK5A/vhBJgwtZm+KSZR7YbcAJC9yYM5M/4EcNt+PERW7U1mnYsUth3RaEUuaCrLy8wTUcBEEQZ0wU5XjmvPW5U1b0gMsMnF68cRf2rWvEyDnJOPeeMbDT6xLxINDrAbb/0Xfw0fq6h5axQI0m1nakl3p45l4vBbFAwVyWaJkiJDvQWl6C0nf/Bclux+DFv4XkdnH6ZDGRdgIN8vV16ohITR4Br78JDW3lHZcMrJPltTq1EjvUtTzdLR8HmXS8QxHeIVgEMrccxUb7dajBkq189HbMuFAlQq3LdHd3aY4ptU+jOHL23XXSEzCnWyPp0DQ0OeDudDzQSLO7I9tQnEEktgHfM6eZh6E9cpoia8A0MYibuwvbrK1kmIQMooGSesa3kKE7Z9IwiEQNssHgKpjQo/NR5oV+cyRU1ZVt09ayoIU4HkZKE/HfNknt/fRzsf7AQA8MxKSoYllGwZf7sfzGj9lzdObDpyFn/ii23a9SICDpAYJ1ndDjMps4Cl6Gt1Vho07iLlDExHrviTuBAgCZBQFcNZAmqqHb8fkrZXjxln1wuGXc+dFk5I1Lwvcf89alGQsS+fvZuFnG5LlxePPbfCQmy3jykUZcfXkVH2HrOnkqMTOW+dHSomHGDBcLCo6cX4p9+xVccH4s/hImKBAYBAIJfr20BRdcXY5BUw4gdsABnHdlJT76ohU+v4Zj5rrx9EPJqNmXj0Nb8zFquBM/rPZh8AA7Vn2dideeTUWUG7jlD7WMFZJlRfQOCj43Sx1GwGDB6omJnD61MdrI8Usq3nioEGs/r0XeqBhc9dxYM1NDXR4yz9bQfrkTUpEwMB5la4rgq6dSCu8IkWSVTXLQXAua8yBBhdpcj9IXedkr75e/hiMpkZUYAmwCLzc4JAScEgIOcxo84nj2nj2lS8IEAxbHzttgjNcJmb/et4Snu+UFcMrtuTc6MyIeom/x7a08aJg4sAbJsSYVeKhZ2xInYnaPnLTguz+E3T1oS+y+kyYTI0wCXHZlm/SOh67AlF3iDBDN8B5d2Q5tHVO9TEEGRvTCiYmWvgoUdrrfXm0rS8lTIDFOmtHj88XrDIz02TuzAm27Qcfd3fJRqJGGR1cCTnQ+ytbQ+TrjRui3vrH+wIAR+sjc4VsChJ3/2oiNf/4GNpcdc547H0njBwRlCSiAMDMG+rrKl411OpYnANluQ4vfCY81Y6DTMLN1FhiIuQ3vPlaA9x4pQHSCHXd8PgtJ+XEsaNj4HUdhT1mQogcS+nFUO6IzY/H6iqEYPcGJ77724ISjK1i9X2QM3nqD/+Gddno05s0vY0HB4vNj8ejDqRzrIIICDVizvg2/vrkSI2YdRHReAU44rwxvvt/MgIuzprnx0J3JqNiZj4qdA/HZW1m4/IIEREfb8PCT9XjsmUbkZNmw9tss2O02RLllPPanJHg8wK+urTHAnAKDwaSiGWCTp/aFQqUIDkQGnoIIp+xnGYFPXqvAp69WIiXbidvfHkfEkSxgYIySNBdgTj1YOOp2njVY++D3PGMhm9kAPkfIuj4nzIHiReFDj0NTFGT84gK4B+RDc8rQCJTIJpkFBTQxDWkxt0twxSYiJioV9S1FXI2QnUgEADa9FUIOWmYj6eaPuZO2H8UAhd21fHAl05V1B7CjOAHU/Xj0mLKIarYpHXAHdGUEOiQobVUEo2mzLTE8C1+kRsqOZJTaj1TjIRIwZWdG6XVi2SScQUd2SNvN8A/UbkjZkN5Yhk5u1Nl95R0Wu3nJCfPQWyMOgs7KFyQ0VYCdzKFH2mHRmZGzp99fR5mfvj5fr0sJWi+mn4n1BwZsxESjfjNbsPkv32Lvq6vgSIjC7Jcvhzs3Tc8OUJudJTgQGQNLwMADDJmVITx+OwIUGDh4mcGjONHqdzLeBOHYxcQDAzv+fft2LH3lEBIy3fjdF0fDnRJjvF60qxUxCXZoDjvLGPgp26DaWNmC9pEcDjz/Xh5OPz8WRQcDmDejDDu3e5nD/25JG/NH99xTj/37FZx/fgweeTiFlxj2+HDbH6sx46hipAwowDEnl+K1N5pQXhHAhLFO/PGmJBRuGIi6vUOw7IMc3HBVEpISuFwzZ0yQ8MxLDbj7oXqkpcrYuCwHUVE23QdKuPC8eIwe4cAnX7SxdklRRmDvZZkCU/kxXLZArJO/XfFpPV55oByxiTY89PEYuO2U6ecdHVQ+oKyCQwrAKfnhgAIn/Bg4ORnxA+JQuroI3oZWfdAuOk84ykGWA2yy0WQLwG6jEpAPBx54CmpLK5JOPhGx48fr5YIQ6WVRQghdlwhES0JhGvaXL9dBhvqk3z0D6UpgU6pJN34ABT4Md05Fqj2Yz976FtN0XIzR+KDBIdvZw5bSs99s4aPx+ayc0L4Rm7cltiAHg3s8khZGrYbEjU+Au45sj7ZJb0vkQky9MSp3EDtlZ62SRT0AU3ZmRITUWTBSqZViL7YyeerugCk7MkZVDKIqruukDbJ7HRZdWWwnjrpOq7YITfXN+ei30FGWgsCpfX2+HpvWB9PPxPoDA4ExUGzw+iWsu/19lH6xDe7sJMx4+SrIcXHBmQI9GLDiDDjGgLPnKeJYxKKn2hHwq5BdImDggQe1R1KA4KF18CyBT5XwxjVrsOnjEtajf81Hx8IW7daxBza0+SQ01fqROzxaDxRs8AZsaFJd8IELNPEyhQ033J+J2x9KgadNw1knVuKDd1uwd4+fBawF+xWceFIUklNsWLCoFAOGHMKRx5TixVeacPCQH0OHOHDNVfH4cXkuKvcPxoov8vCHm1KQmSkIoKy0O9xefb0BN99Zi6REGVuW5yA2llMtCaPl//wzjQ2KF19aZWAH2A+QRvCSXl6wZNnbLZMTW92GB24ohytKwl8/HoLEWBUuyQ+X7EOUrMAt07ICl+yHUw4wXIKYz799CvvDXP/Id7DZFTbZ7QHYHQE4nAHY7RrsdpWpLMo2XkYo+Ms/4KusQcKc6UiefxTvPDBkly0qjNaAwLJONzwjcwxsshOltZtCIAY6noLdC/5vY8PnaFMbkesYgQHO0Wa3QtgnS/snDQEgxX2lujbZG9tbEVAlDM9uRG5KcLp2l96WyKlyJ/f6YZILXkcvxL4OhZgK+9BJi2CEnBi16IVajVaB3T0AU/YUZ0DcAVsN7oBje03XLIyCPC887Rx1T9sguzKhDREKJuVg0e+7zVXQlRGxUrh7auVG4NfXd3LQ/da59QcGrJRgg9ejYd11/0T9xoOIG5OHCU9dAdXm5JiBkGAgYAkSAqEBgiLzoCBAkwzVH4DNaTf2twIdPX4nWnxOtPll/GvxdzjwQwVyJqfi4rfnQ3NSJkGGHzJz+ttXcHzBqLkpHJxImQLNrWcceIBBOAaOU7DhuLOT8NKH2XC5Jdx2Qx18lhLzp5+04emnGrFrlx/Z2XZccEEsvvg8E4cODMSyJTm4+44UDB3k5B0KDMQoSg0iQyAcu4R3PmzC1b+rQVyshM3LcpCYwAMIHUqo/wMG5Dpw5cWxKCsP4KHH6nRQoRRcbg8BHYqJSg4H9npx/QVlLC3+9Hv5yMiycxwBtYoaHSG6QJUux8zbR/k8b2oa4vPiULqyCP6mNhCWjwUBLLsvyge8dZG2HXjlYzTvPIiYkYOR88vTGOaAWhkNx29kDswAgTobOPhQcBDwJoPM9AlQAl5UNuwNgyvgF7mz4XvU+kuQZM/CqOjZxn6klBmJWYMCMkrT053f2noI6/dzdDkJK1nbEot1J90VVW6kRiA0Omc5ijoVYuqLkbQwwgyQUdtiqFOhbAh9Hko/dxdM2WmnQBicQTB3wFF9Ks8sghEC+oXnDugZeLPr8oWJ3SD0vwkWJcnm7pe4OjIhWmW9PhJWCtbM6Lvz9VYrQerF9HOx/sCAIuEGL9Zf+QLaDlUh+cixGH7PhQhojiDMgQFOFJOle8HMEtjgUexB+6uKCtntMPEHrBQhszlNnhYNb5zxKap21mLgvHyc8sJCKJQEN8CIfNryJdeFmHxSFg8KVLfO+qcHBpoNAUnSl3mAMGRMNN5dHizAkp1jw2lnRuNfb6dh94FcfPt9Nu5/IBljxrmMAEDQE4cDIwouA/r/p18TKLGKcRNs/DYP6WkOSyhgzsXyI/cms6zCo082orZW4cySBn20mHhJgeia7PpUW6Hg4lNLmTDhE//KxJARzmBiKJ0XoqNJZ2MysAY/PkyjHs5WIoWZSj5aiaqlm+DKTMGgGy9i2yiIYFwG1kyBFCZrwMQ0dF4HPTAYPIi3Gu6r4LK+oVNh0xYUtW5DlByHybHH650G7RkQDQt5wPCgwEKixNoxZcZ9QLV8Ulw0uxO0HrcldvkwkWTWKdCKpqDRLY00D8fIliwZ1AIoMeWE9k5TY22J0VIs+tISDZyBJwx3wLQekTx1ZiSoREZgP+v5qFuBOBw6oqvuqdH9ou9KOGp+PhOH0pGGRW+MSkL0W7XiXvj1Te7z6+uxaf0Yg/8p23bDS/DXNSP99LnIu/oMS8mAHL7ICFjn5iTKCD6FJpEpMAMIIruxuXnmgUoC1s6H5nof3jv7P2guacKIM0bi6AeOYUDCloALbQyHYGIPCjfXsw6F6NQYXj4ICQpYYEDnYCUFvp0yEb86m/d5O3Vg+01/iMefH09mxEKcuNlsaWSDXNGiqPMKmH36ljZGAEt/aMWZl5CEtoQfv85FXi4FBWYmoX1YIDFlyH8+l8ZkABZfUsXKBwynp4MLOWaPuglo5M/Bf20tAZy1qISVRe5/Ig1TZkRzhshOsgNMqEp/XfBR2CQgf1o64nLjULLiEHzNbTxLYGQL+HLV6p04+MZS2OOiMPruK2G36WBFOp5dDQ4EjLYKUfOw6BAJwiPKTDjdSIjJRbOnEh4/f/iJO1XdVohd9d+zEe3M5LPMtkQRELCSg2ywrnEFUEsuRl8PZwPBRYHe2FWDNp+MnOQ2DMwuN5z0jBC1xL4w0jkgK8PBPmtL7MyYwiPTFGjqE+6A7jjqMhxgc8oUEHfAIIxElsQxCH1pdM/o+yL1TNHLL7gDcnvYBtmVEZCRKLGt56PyVG9xKB0ZfYdE+U22Dt8xrAp1uuRKHGDab/9d688YkKPz+JF52SlIPevYoFbD4GDAnFuzBzT3+ilbEJxhEPuSt7VFOc1ggpx3QEZjWQs+OfcteGrbMOriqZh6wxzm2Nl5KZMQcKItQNwHHIPQUN7GxIIoKPBTNoPRA8tBkzXL0OaXcPnxB1FU4MdJv4jH+yvz4aK2wevqsGePL2x7IiMwMjl6wuzDl1eua8Nxvyhl6fjVn+dg2GBnu9JB6Do3CcccFY0jZ7vw43ovPv+yJQhPEDqWJrGjUxeWoKFexU1/TMLCU2gkw4OHoCyBFH6isEewEDNFS6iY+/tpnNfgEepQ4N0Iggq7aV8ptv/lE8hOO8b/+QrYox1GwCC6FTQ7lRMsmQK9dMCW2Y9JayeYSNOQQQvYHSD9BAE4bPbXYmPFh6wmPSP1bNipLdEK4Aijm9AdltE0KZuBtgr8xVi5m6ejJ4zbaKRno3uooNeZEYiRrAQH2wkx9bQtsStLRSa7JgLGbcRy5sRye8EdEFmWgtfEt2irmGYDtU4OkSJjJ+yJUcmHQKLbtB+NXv6ecgdEYnFIZFmRrdpq43y9abvsykjIimy9toyBZgl3MEwaj5+UacZDsGfTz6eS0M98SObIz4TmdMHn1WBzEAehRUCJtdDxdYaeJ+Y8fTRL/ACM7c54fltT0vTg5joJMoEIAyTSxJUUmwqqser6d6D6Ahj326Mx5GRSwFO4hoJMKosk9kPHpxKEjOYD1UwcKGdKOnyag6UshTgg/Y/T9WgMeEgvkPbB707ah5IDPhx3biKu/1MGHJKKp9/IwpVnlmHx6VX4dk0W4mJF7ptfGwsKrHTH+msElOOiQxI27/Di2DN47fH7D3IxbiRlHtjOxv/bsSVaiZM1DW+9ko78cUX49fXVKNjuZnV0g/hPZ1zUAirOPLEcZSUBXHRFPH55GT2odEVGpiVBWQOuNUFcDixA0IhVkYtSEYshFSIM9UqJaKpVDJiZgdicWJQsPwR/Syts0TFQZRXeymb8eOvb7HOPv3cx3CmxUBSehaBAgGiSGV0ywxno4EI213EHghbSyCiYQQFtS0jMh9Meg4rG3RiTdSIUxYs1RW8whzYl9XREOxK5omIQBkGALCQu6WkxQ/bauNnh16k+TQ7s8y1JmD+uHKeNkvHslxPYg/5wGBvBa7HMWUYqxNRbo5EsaS1sw2oG0qNrPpwEOIKRsIF1CtQyJzpe6l0vfyRtktTHX45DHfbyi/KNYD1F0Fr713QpsRDNE/7/aPCgkZQWKXtA2ScKvMy/c+s8WIRdHNGirGLZFqyuYm7nP1zKilBbIv0+qaPE+n6riXUKXv5bJvUSJ/Bzwhj0UyJTV0JhOSqee4dNcmw0XPmZiJkwAvFHTIIjNsoIDNj4U5OMESRTAWSpXp0pTw8IRHDgb+C9ztRdQNkD2qdmczE23vEeKzFMuOMkZM8ZDFVT+OuCn58FB9wJEQ3wtk84ucnw4wexbIBpdDIeJFCrHssWKBr+eMoulB3w4thzknHN/TmM7IiuYcTEGPzuvmQ8fEctzj25Eh9/kw6Jhv36oawyzMKRs206z8G+Ah+OOrGY1fo/fzsbUydZUcLBksyhmoy8JMEBefHxNtxzWyJuv7ce199SiycfTW2XLbjsoirs2unHCadE4+Y7krlMsyXIoKwBCwJYkKDrJzC1Sk4mxYIlykQIKWxiTGQ6FRrm/n46Pv/Nt1j/6HLMuGsRVK8Xy69+gwFFx952CuKHZiJAlNeCJVHVlyn7Y1fhJ32EANEoc8Aiu0odbGgNDIzygl4DyM2cjoLi71BcvwkHq1choPkwOuVYpETl6vKNOn11aLbAGjUJC4rAtE4pkikweKZgA+70upEbL2NRfiq2dc6XE9bpmP8UfU7fgBqyHGBOherFhGonp0KO7JC2R/8LEv9Mh8XXzP8jZN10PuZ7Qx0aGQUFYr5aI5GdYCcW7M46ei38/sHbySGZTIQkrPSt9n67d5umRbwWiZHI0bd47782AqW0PlEf/7fMBy8Dqv7kTOslrfHPJy7oDwzIch+4Fa1bdqJ1yw74ikrRtqOATdX//hySywlndjqiRw9BwhGTEJ2dzIMEJVymIDhr0FbLH1RyTBQrI9Ss2oldj3zCKJInPnAuksdlQyGxEpXoeYlymCPf+ZtU7pVlCaU/lrP3pI1ORYAyFkGtanw5IMmsfPCn07ag/IAH885OwxX35cOvZy2EnXR+MrZv8uLT/7Tgpmvr8MSzqXoPvX40feQr/I7wSSVFCo5aWAKfH3jn7xk4cnZU0D5mCBCSIRAfUXxmffk3v0rAC6824Y23WvCbq+MxeDB1QfD7+bsbq/H9Mg+mzXDhsafTOKWznimQOswa8EwL3Ucuj4R2IETKS7CswaxMxGbFonjZQUxqacN3V74Pf5MXwy8/Ehkzh7NMgTUrZF1mAaCdqy0yxUVdLdMICELLCBZgYn7OHBwoXoZd5V+ze5AdOwYJ7gzUecuhqj4EFB8CNA/Q3I+ApkAN+KBqAQQCfsMhBzQKBk1HzJ2s+X++ZHWegEf144NdNlw4wYnkQT/g20P+MI7P/H9fOhXiwj98FvRLY+sUlFjLV8FL1vVwy9a+G/q9mKgZa1Ag/qqIr4BGuMG9OsHHDXfs9vu3f03MCb8gKIMJpEftpR29PxhvEu6Y4c9ifY3uXyWKjesjLEPonTILhuHOFO7Ohr7LXGpEDYr0rhI632hM6fC45nb+f/r9b8ZKyzX3W19Yf8aAboIjColzZyNhLk/PqQEFLVt2oHXjVngPFMJ7sATeA8Wo+3QZJLsN9rRkRA0fhPjZE+Aemgcb0wBAu+DAW9vGjifFxKDok00ofPkrSFS/fvgixA5IQSBAJQP6Eoh/gHrnufoiOUKbSiNSLubTUNiI6PRoxpxIffm8ek7hQcAAEMo+DX85Yz0qD7Zh7tkZuOjewUamwDrRM/SWh7KxZ8dBfPlpG155sRGXXxlvYAtocMucnYVgqKpSwZHHlsDj1fDKc+lYND9Wb10M7rrrTIkx6BXm4DW8/VoaZswvx/kXVWHN8mx27kcercfbb7dg6FA7Xn8rncsZiwDF0r0flDVgQYHMZZRVvXxA95PULFm2gJZ5OYGXHFTMvmUqvrphKb4499/wN/sw4ORxyD9hLLw1DWhr8MHbSJMX/iYf/E1+KK1eKK0KFI8PgVYfAm1+aF4fn3w+wK8wdkQtEIAWUKCpASbCRMEeC7TYjQh2uqXN29nUewt+8FuX6cEpbMVBGRdOABYNceChpQ5jHyqyiCUTF2Ju46+LvcQ6/SOR8OB9CARYggJ2Pup6IIW/4PeZa2Ib/aNv1/qPLJJuiUatDmvxrXFv5+A4Jup0uIxkngkxLywTuRjZBxwQHVmL1sg6AvhfjIYoRGO8NPOwna9Jq2f02OK7t8OOwVLXglE9tXqthskm82+d/5rSpa7FlIT1iygdHusPDOjxSDiBgBnl2uBA3IQJbIKuF+AtOIiW9Rvh2VsAf1Ut/GVVaFy2lnlFe1I83EPzETttDGInj4DNQb38GryMmx+o33QAzZv3wxbtwujHfgVnaiwUqlnrUsKKTZdaZnTA3NFphLiHBG+dB0qbguxZefAG7MxRwqanMZmPpbS2gmfOXoOqg22YfVYWzr97mB4U0A4qVMkGRZLgk2yMOtihqXji7UE474i9ePSBBowa78DMmVG6ExUpa/L2GurrFMw9uozpLPz1sVScdjIFBZRiJwlk3iYn2AmND2VZCq1fWoWZRo904ZzTo/H2+6146ZVG2JwSnniyERkZMj79MpMFSuJcPAAxl4OyBsT10BZAYYmCstI2VFcEUFsVQF2VH411AbQ0KGhpVOBtDjDtCtpX8fFENgUFZIc+3sqm7hlHTTIBKOocIKyEZIMk22CzOyHLdsiSnc1tkh2e1jp4vbz/PdaZhpToAZDpO9FoPxk2zcaCGXKodE02lUJGG+z02wjIsNNvVKEuiQ4cZkias1ot03v5qZCi4tAhIj06iImZMuba5jP8Sl9as9aAvdjCzueCm41006Uw7I19ZERLTAh2ssEYjQLsYCp9gmipr41zFZCmhMYImojsh8oIh8vofGst59uCVfCADzYO1/38Ed+x803BUdiBdSytfziDHup44IRJ87ANPxqdED9JU4MedD17/8/E+gMD+q4VQFYsLs0YAes3SZVhHzAEMQOH8HqxDHgrq9C8dh08u/fCX16J5rVb2UQmx8XAlZ8F2cVpgykosCfGYujD10COc7FAg6V8NRmSTWOdCCzdTKNafc5S4gHg4Fc8xZZz5CDGg+AlhwwJbpvCRvmE3H/pnKWoOdiK6Wfm4Iw7R8GjavDRaI6JCjnhkBSdJpjogsmRBeB2BfDie9n45cIS/OqCany5IhOZmY6gQkBzs4qj55UxzYU/3ZeM886N07sXpKC5kHYOTeqSoxLZAzOfELz+whPJ+PSrNtxxbz0CCuB2Ab/7XQLe+GcLKioDqK4JoLZWRUODiuYmFc0tGtpaNXi9KvxeDYrCy/NdGQlZyXYJdqcNNreNMVIKix2QiITBqbC5nJCjXJDZ3A3Z5YYcFQU5KhoSTe4YqO5YqFIUVNUBxWeDrU2D7FNZxsbmo2UNst+yrG+vK96JnRvehN1GeBMvZNmGEVnzKeqkFJU+VxnoMmgbARJpYiN/+s1Yf6jB99pqzWoj0yQgJ00sdSRatKmuGg2tDiRE+zE4swl7SvuONMZK8ENOhciTCLhGIzq7xP8O+tKoDZJzB6hMxIfkgikwqEfNYQkM+Pmot55zFSRL6Syga0PHmgm9Pd8q/XyjMZWdz6m54elCbKjn5/Ox66MM0zjMQJKUxgCWXYkb9T7oUTEJRzAZbS4xffgCrX6L3PoDAzKFBwfMpBBsFxPjM1HiYpDlSkuD66TjgZOPZw5aaWlGy9oNaN2+E/6iMrRtN2lhJZcDAx65ARIjOqKHO6W+qe7M2+oIf0DAOFaTJrCcKA/IGspX837w7DmDWDujgSzQJDbyf+cXX6PuUAsmnjEAC+6YgGZVZUEAm5gzYdV3NqpXRAqethMj34BoPPB8Om65vBJnn1iJb1dnwmm3seCnzaNhwdGlqK1RcdutibjskniT00Dw6OjLdBab3k0QBDTU3T85i6KSANZv8WDrDh/27ffjULHCHH9tvYrWVjOT4PECN9/cnheeBsl2O+BwSozNMTHRhqhYGTGxEmITbIhNtCM2yYG4VBfi0lyIS3cjPisKUanRjMGSC1dxsaodS6vw7vWr4YxzwNfkhyvBhZl3HYsAI62SLXNqHzW3kf6F4iduCwreiPCIcAeULOA8BtYOBRNfADQ3VWDnxrdYNmHqxKuwaeuraPZWh9RirHLMOtgj6HWiaKQSFXFjcIVI85dq+eFCg0/14Ued4IdGmqSYJ2s2NKIBu0syMH1YNUblNGBPKWeca2/dwxmY3AHcaSZJqWw0SIEBAR8z9b7/vjJT+MnH1BlF6pmySSQ73NfG1SCXsNHzYIwxuAooK3I4RvBCfZL6+odgDLIlzg1BME5BHtWXmgF0PApCRFtphpRncAuQfoFf88HRh3wXPOj5yvi9CAIjuj4yIo5y/wTpj6X+roT/LZMoRauXEtgjkWfRg1NH+kOaaWqLljqxjUT13DFIPGouEo+ei0BAQelDf4VSxtkKNa8fh259Crl/uBzutHijHZCcu8KEurmADrUqyipH2JMjpHp40/5qOOLd0GxOlmkQH8WvqHj3gs/QeKgJY04fjPl3TGZ/aLxay91x0KTXuCn1zgIZChY0YMa8BFz6Gy9e+WsDLjq3Gq+/m8HaHY8/thwVFSquuS4eV1+TaGTBJMtt4R0LQFNTAJu3erFlhxe79vpQcEhBaZmC6roAmppUeMNo6lAzRHSUhOhoCY2NpiP6w+8TkJpmQ2YWTXakZ9pZAED3hDoTKMxh4Q7dO8u6TwNadeInzv0gVCwl+KgbQWdWrN7XiPdvWgObQ8bZb5yAD69cgvrd1XobIu8KYXPWnkiVGK78yDIjoiovAKbUNUKsTEqIRoIFiOjztWDb939j92n8lIvhjo5HYtwAlNdsQau/CVH2OL3NUf9BGUEAq3EFgbRMtGvQr1ef83uoqhrW6A/d0TSyldPZS8Kp7CxJYIHBiOzGbgYF1jaIcE7Tg8EYZThNLhe8gXUm9HVgQCl8GsmSuqJVnZGAecRh0NdG3Ah074i8yVpvj0IsA+r1taOm6xMS0YMs5yNxIyqV0Gu03Bcmvj8CiRLI0NpWSt0kZMSASFwRfXW+1fiK1C0wBGODCKFi9BbJJtTCresn/KRM66VCYg/f+8wzz+CRRx5BeXk5JkyYgKeeegrTp08Pu+9rr72GSy65JGiby+WCh+Rtu2H9GQN6jlsyBgaq3vJMFsGCXlLm37EUGhxwHgClrRUlDz6GQGMTG+ZKdjtiZk1B87JVOHjzX5B64clImTcVKmUNJFLxoxEpLyGoLCiwMQ0AhixXAF9DG1Im5LB6sICvBRQNX1z8AZoKGzHslGE48vZpDFMQaqHAQ5IspqCEOhgUIXsMDRdfn4adW7xYtdSDP91Vi9UrvCguDOCiS2Jx/Q0J2L7di+3bfEyI6cBBBaWlCqqqAmhsUuHx6G2b1vNKVBKQEB8vY9gQB3Kz7Rg8wI6Rw52YOMaBMaOdcLsltLSqGDWDcyIsmu/Gl0s8GDLQjpMIx8CcPnf8rCuBHVeoMBK+QVwXBT2c2ZBYDBiIiTgLjDZFDjyUJBWeegUvX7iCOfuz/nYUErOikT83Bzve3o26XRVIGJbJSziE72Dfh9mmSHP2PbN1sxtFs1EZiGd7jPZEfU5dBNu/fAZqwI+hE05HfFIeNL+GzPTxLDAoqd+CoWlzzKBAoCuD2h8pKglpXWxn+r6MNY4/5AdgJLLlgcbxSMGO0rRbSjgF5sic+vDH6aZR3ZtG6eT8B0tjjO004qMRvEDT95URwQ+NYqnPPRT0R8FPZ0qLPbHt2o+st564EUZLU4NeI/4CctR0/fFI6pPzbdXWGNcXKhEdp5+jAdV9FhhQuYk+P+kjhBImiWsiZce+CAwoy0blJsGiOEjizJzW+0lGn0cIK/2v21tvvYUbb7wRzz//PGbMmIEnnngCixYtwu7du5GezknLQi0+Pp69LoxhoLpp/YGBDj6UKT2sD4PZgD4kU2Ashyrmsmc6fzD7KqtQ/OSTDKWeuGA+GpZ+D1tiAlLPPh3Rk8ej6tlXUf3ah2hZsxU5N10IyUWpak6YQ22ImiaCAuq5l1D74152qtSpA1kZgYy0F5Zc9g6aixow5OQRmHnrbHioFi0CmHBGjlPmgQNB9WikLS5FONeb/5SOCxYW4Y3XeE2Rrutf/2jG319tDwZyOIDYGBlZGTZkZdoxIN+OkUPI6bswdbwLqSn0swruMg8lOKHsxxHHl6GmVmWcBlddGovM4cV48tlGnHIypRRFUyYHaXKfyQGHBp+E5euh1wlDQeLLnNCIMx3yzgSVdQz89ezV8LUGcOI9k5A3MQV+VcXE80ewwGDvO1sx/Q8ZRksin6sM3MkKO5qQkTazBSxAoHICARAN/gIhtATs+fxv8Lc1IWfEkcjImwhQh2AASEgi4R8JNc37MTSdBIxEHYaXC4IiUaOMFTIP82VvCazSWeNyMEzWWeP07FSalsO6BZaV8FR7XmorYt1+NHsckQUFYRIGe7TNrFRArHVjpfYjGCfcfVqjLtC2d0rwQ46FAgPSZuiLzgQ6Xxk7XxzTXAinmUBGgUNfBAZ7tS1MD4H0JsJdnzhfI+oROW6/Y9uhrTMksMeF6XQQgYigm+6tbcIPjPiKfp/hWBTN8/1EAYjafz9j8Je//AVXXHGFkQWgAOHTTz/FK6+8gltvvTXseygQyMzsXSDXHxjo4EO6E1KYoECUeg2MgaC2FNkEPVvQWrAPJa/8je2QftY5iJ00CfVfL4EzI504iBA9eAjyHrwT5c+8hLadBdh/3YPIu/kCyCNydLpBTnBEmQIqIWiyjOqVe9jHSJ83mknnEjhv+a/eQktRAwaeOApTbz6CtTzS5/FJdibyI3WUKQgJCvZubMLKT2qwfW0zyg75GOuj1TKzbUhLsyEn14aBA+0YNdKFceMdGDzAwbIcXCaAkwhRD4ZdIiQD1zwwWxc5QNHSvGiwnJ22uBJ79im44BcxuOlaDoIbN9qBrdv88HlUONw29l2Icju9jwbtNHjmJFNCN0D3lSxrQIFAwMwYWISZnr5wIxoqvDji4kGYdEoeKy9Qs2diTiwcsQ6Urytpx1dATp4RHbHSDi8vMDiBWKY5BQY8XaHjCng54eCSN9FaXYLEvNHIHXcsND/xHlCGAbDZZbid8Wj2VJsXKCI7dqFiWfSQBgcFTHFRsCSSaRL2qVtRyZxKIibIczpU6Ctoq0ZJTTRyUloxIqcB6wtSI3tghYw6SJ2R2AaJqncKjg77FnKoVEroi1R7qXYQBdjJgg1SSwx3PHJwpLLYF50JJUHnW9DB+bg4FTm73lqRtg+HsIcRQk3H/LDnY4qNVDLrA0e9X9uOUhxkZFQdSWAz2WhN6pNOAR6ElDMGxwkdsETy8+GwASx/KoFBY2Nju1Q/TaHm8/mwfv163HbbbcY26kg69thjsWrVqg5P09zcjAEDBrAM9OTJk/HAAw9gzBgzmxeJ9QcG9Mzzc3BbEGOPpVwQmiEIXa/fuA4V77/NHug5l1yJmKHD0LSPp3Lc+QN4WYLV1Z3Ivv5q1C9bgfr/fIzC+/6GpOPmIO0Xx3FMAet5578fRp28qxSyyw57Yjx8PgWrr34DrcX1yD9hNCbdeBTHHOhO0c98PwfEWbEFBDQkBP7ab6uw7ZtKHNzaiPoKn5H+t9mBtGwn2poDaKgNIClFQl2NhsuvicMvFsfpKXrefU7LbCTPmBB5rV1ETrSNtU6GITsKXb7+tiosWebB7BkuPP8Yf7hSyHDD1fG45Joa/PXZJvzuxkT9CnTfyTIF/Euh9SAeBT1AoM/HxJRYGcHUUfj7bbtwcEsjRh+diuNuGMmCAhYwEE+EqiJzYjqKVpTA19gGR1w07wxRdaZL9uH1q9JrCKykYaW+pueZ30zBVK5Zgvp9WxCVlImhR53PABCMoEkXhKDAISEuHxU1W+HxN8FtjzWDg9ApFJgYqp+gAWXqQRzQdjAnNl2ab4EdaEEPFLvqZO11u0oHssBgJAUGuiRzd6xaK49InZFGuBQY0CieSHl6aqQGSa1zFI52dj6hYVCP2l4FBnS+nRGcjxwZlUt6i6Sv1EqwG5tghwOzOghChNFn6i2OokQrwAEW9Lg6DEKs5xOMkn0RhFDHSmfGz3f4WjJ/CpaXx8Gdwu666y7cfffd7farrq5GIBBARkawEBit79q1K+yxR4wYwbIJ48ePR0NDAx599FHMnj0b27dvR25usNJuZ9YfGLCMAY0ITRS4AUDU5+yZLbbpzIQCX1D13ZeoWf4NJIcTA6/8LZxU9wkAbXt5GSB6xEiWMWAOX8eUJc49AtGjRqL8yedR98UPaN68B7m3XwZXYowRGNDBvdWNiM5Lgd+vYf21/0BbSR1yjhuLsb+dxxgT2X66gxfNgDTSbalpxb7PD+DQihIGtmtrJK/FzRUtI29ULEbNSsARp6Rg0HAX/v3QIXzyaiUGjXThpQ+zcdy4A3j60Uacuzhed8DcQbNgQMzZYJaCBTMYsDpra7ncmjV49uV6vPj3ZgzMt+OrdzP4fdQ//VmnRuOqG2rwzzebccuNiRygb82s6xl3kUlgpXfLNpEd8UucD4Cc/2cvlWDVh1XIGhKNS54cD0WoMVK5gVgCJA1jzxrKAoN9723D6IunG06f3089Q8CyBDyADMIe0L4MZ8C/3/rdm1G5+hvYo2Iw4pRfG987i1r0jAH9PjIzx7PAgHAGQwhnIG5aUMRjnUJKCboRf/02bQ3jO5gpLWKcCeE6FchiEcfa+XYWx2P+uDKMzO7mSFfTWGAh2iBp5N6ZOiMBEGnUXY2KHgcGLVoTA/9xyeb5cHaCVic5Z96ZUN8rLoZIzyeY+nrTmdCg1WALVjNszEws6FLtkgCWveEWqNbKsBMb9KBuER+ld2LOXp6v2AhC3F0GIeJ+EjDx/zKPQVFREcMBCAuXLeipzZo1i03CKCgYNWoUXnjhBdx3330RH6c/MBDgQz0HLmh5O8oayOSN9IFyyYdvoHHHBthj4jDoyhthj41lNLm0n7eYa6e70jI5gZI+8GQ6JxrgTkxD7t23o/rNt9G6ZgMOXP8IMq88Ewmzx7F0fNuhUtbHHjc6H+uufQ2ekjpkLRqHUb85luEReBslB+jV7KhA8ZK9qNpUiqbiRgS8OhBRAqKTnBgyOw0jjkrD1OMzkZBkY7wGnNMggI/+VsSCgrQcB57+YCBkh4pTzovDu39vwvv/acLpZ8XpTpITH/HWTU40xOn7uZ4DH7mHZg2CywdffNOMm++sRWKCjB+/yeHBmL4X+x5kGfOOdOOLbzwoKlKQm+fg5RsqHRhyw+2DD6svtesqipQxWP91Ld56rBixSXb87u3JDAfA0tqsBMJBibTvwNkZkGwSCr87gLGXTOMSVXStYdgsw67bOK6grbwYpR/9G5LdgaHn/gaS0wGNsgWyRVeBPoMsISGZyIYkVDfu44GB+MLaZQZ03EHoNqhoU1uwQf2OE8RIx8Ipu8MGBGI9CRksMFjH8Z4YkSNGuqFPu/DpUuo8MLkKjkS0FNvpw4Vq5YLytifm03xBBD+RSDbzzoS2XvTWm1wMkZyPWhZ7mjFo1ZqxDsvY8lTM46WCLoxKNz3NGDRoddiElUZQR4FUZPLLPUvtV2qlTPOAByELuwxCRCDS3MsMxU+9XTE+Pj4oMOjIUlNTYbP7m/3RAABUIklEQVTZUFHBu9uE0XqkGAKHw4FJkyZh3z6zfT4S6w8M9A4Eke7vEHRo2Ua1mwP/fhZtpQfhSs3C4At/y6iODaIAGfDX1EB2u2EL6LTAeg2aPeN1B0FUyhkX/ALNU8ej6sV/ofy5t9G0eiuyfnMOapdzsqTaVbvhr2tGxsIJGHbNQvg9PlSs2YPKVXvRuKscnuoWlvZmH88mIyYjBunj0zBkwQCMmJMGt5PzGvBAQGEs75zXQMPqD8rx1mOFiEuy4a+fDINkJxCkgqtuS8OHbzThiQcbcNpZRGpkXj7vBiCgpsgimGWCzrIG23d5cOYlFQy4uObLbKbsGMyRyM9w1y2J+OKbctz/cD1eeDqNMz3qgBpeUrBkCvQgTmAPWCaBWkclFft2t+HR3xxkvAd3vTceUW7etsjElCyCSrTskGUkD0lE7b56aKRySSPPoHJB18GBt7UJxa88xz7rwF9cBUdcPOtA4JgDq+oiX6fvnnAGLZ4qSyYg3GR5zfKjpO9xtfolI/iZIM1FnBzCSRDmAZaBPBzADvxQXgt/QEJSjA8ZCR5UNERF2Ga2xMJV0HUGgEaHds3RI/CaaGsjXYJROsFPJNbTzgRBKKR24/rICAhJKHp6fySOzxr0kCQ1FawIaEhcE5EYpeOpa4GCmK6yGVYjQKZgiZyKo7oM6szzcS4DIkDqKpvRPhOyysiERBKEiMCHMBt93QL6cwQfOp1OTJkyBUuWLMFpp53GtpHvofVrr702omNQKWLr1q044YQTunXu/sBAxxiIjIEFz8UsCFNAf9CKF/ve+Av8DTWIGzQKeadeooPBdMdPD3+SPm5thiuVAw+FxxTPePH7YskHFYgdNQpRD/4RZU++gJaNO1Fw3SOQo3l6iYICd14qWkvrsPL8p6A0m9G0ze1A3JA0pEzKRf6xw5E6LBFOO7VABmAnKWGbApvmY+UF0mJg3PTMOarY8n0tXvvDHlZaeOSTMXDGyEych1oZHU47jj8zDh+/2YTPP27B8SfHmvdCT+MbXQeMg4FLM3eUNaiu8WPuSaXsmr98OwsD8p2W4kewxsKEsW6kJMv4/KtWQ6tBtbQlBmfcRSYhOAvfXOfF784uZOe745/DkZrphF/nMqASAmtq1BUXeXZBxrBFA7B6Tx2KvzuAnKOG84wCBSM6ELH9uj6R0/f5UfLE49AUP7JOX4yozBweFNB90LsUWFMJ617Q1200cshHZTXhDJrhtsVYUK5iHhwMiECB7vdq5XNO8CNNRJrNglE35Jeldg+jWDmBZa8qAjXYXx6HkTmNrG0xODDQOuUqGGThKojUsXQXnBd8vpHI0Ql+IjHKUnS3MyGUUKg71xePRNZJQM4z0pY+TtDEg56RmIy0btBGi5Y+yvykR9ib4NNZDSkIGY/ZSJAix5VYuQwileqm8g9lQiQ9E9KdDhH6vZAR4FGc+3/ZbrzxRlx00UWYOnUq4y6gdsWWlhajS+HCCy9ETk4O/vznP7P1e++9FzNnzsTQoUNRX1/P+A8OHTqEyy+/vFvn/YmFZP9/zKbo9LVeDRIx5VCgoFiIj/TJ39CAPa/cz4KClHFHYNDJl3N+e/Y6QB2BNA+0tDLUuCs9iz2I2fsJ4EgZhYCZoWCTvm5zuZF762+RcMoCqC2tUCrN/m9PUTWaSCfXJiN+wiAMvOxYTP/ndZj79m8x7YnFGHbJXMQP4n/slHZXVZlpL6g60Y+ikdO3MTliWj6wuRF/u3YL7A4Jd783AXEpbv46iTnp+137x3QGTHz0/jrmcCmIodCCmQ6WpxKCaNKwTuw1fdnvVzFpfjFaWjW88mQa5kyP1l2dVe5HTHzLOafFMOrjpcvauNMP7djrZBtRRF9+QjE8rRp++3AuRk2MYpkSO/SJuCNoPWibgonnUAshsO+T3aZ6FEtBcMlkI/oI3SapKHz0KajNzUg6dhHiJkyE5pKhOWWoTgmqky+LyVh3yEjP5i1bpXVbLKyH+hSKKbDMN/qXsAdnjjQEA2wjuzUioVovEeTsLuFp/pG5DRFzFVDGYYiFqyASoxY0CiHJUUdqwecb263zCSwDteF1l1AoO4RQKBKjTgjBLRB5UPANA/QNxEjkSoO7eb5k/Xx13c68jMSkbmtXiDZMapGMvBwjMiFzIs6ECBPBQKT8F33RERKxqVrvp27aueeeywCEd955JyZOnIhNmzbhiy++MACJhYWFKCsrM/avq6tj7Y2EK6AsAXVArFy5EqNHj+7WefszBvSs1Z06K6MLiUGWLteJaySgpboIez9+mgkWZc86FekTj2R4ApEhYARHejm4ZT/vSIjOHcTpllmKW+LAM2H0HuIRpkYE0ZouAQkLjkLzD+sQqOF/GNEThyP5mMlImDQMDidYJsCmT/RHL5Hoji56RAFBQBc2YiN4lQsnUWcCtdVRWq/uYCNeuGQt8zM3/mMSUvOjGDkSjYgpaKARNAUI1C644JRYfPFeM779qgXzF8YYbYMiQ8A6EbrIGsw6vphRH99+QyIWn8lplQXHpNnEqN8QZhLuuCkRz73ShIeeqMeRR0abYMOQMXS4bb86sxTVlQGcd3USjj0tAT4CaRINtcyVDjWSLCY6arZNX9ZUxMTYEZ0WhZodlZClAO8SsfFuCPreWJbHyCaa2w4+9zZ8JeWImTQRKfOPZUGloEQWXQoMfGi0T5hkSEmpQwycweCMOXqtgX4Tso66lC0n5fOdLStRGyhHkpSOUbZp3X7QkKOuRim2l8ThVAoMsjsPDKxcBeOkGd0+XwoyGH9CFUoZs15XtkvbpJ8vpUfnMzsTSDOha6e7TVvLRvv0vtEhhEKRmOi9b4qQipl6+QmTQIRQQ7sZ9JDF6LiNlgjOJ6ijfUYQ0v1ODZNboLFb+g5U/knVqY57cr5IxKko2KSg7v868+G1117bYelg6dKlQeuPP/44m3pr/RkDFhhoxiTTpOjLisayCY37tmDPh08yKd3Bx1yCrFFHQvLpJQiWWbCM/gNAayEXPoodMAqyH7CFvM7wDIRoD8lIaB4FZfc9yYIC93g+EvQeKEPUhFHQZDsjORKTasx5rZtlCFi2QEw8a6CpMrwk+KNKqK/y4YVfLGfMiZc+Owm54xJ4loBlCmRzWecQvO7uDMg24OG764L4baylgqDlkOmsS0uxeYcP55wai3t/l9pOjz0YTGiupyTZMXyIHWvXexmhkxhEM+4EnSBQUD/boWMFJA1//G0Fdm7x4chF0bjspjSDx0Cylg0MboP2U/6cbKZk2XiwhgUFFBzwjgSxbOlQkIGy95egccMOuAfkIOPCxRw/YAkKeCkhRDvBso1AkC5nHJo9lRYBilBgi7jpwKHWbSj27UKUFIfJ9vnt/5qtbYyh2/TviRw12coSDtAbltXIgkzjJN3kKojUURMJUFdWqO1l4ktuxHTZ1tZpZwKkiBznfm0bylHIRqkT0Z77IRJjnBmwsYxDJL38tXqHRjhCqEjPRyXBSACB1F1B+I4sDOhREELGcRNSl+cTQQgvx4ztVvnHaoIWuav7aZZHeuGo+61D6w8MWDaYBwRGgEBtaWyuoWLrMuxf+ncmXjPquN8gOXcMaztjBDekykgBgggSdMfvqSxlqQRXVKJRPrCWENiysU7nJD0FBSUPPgF/ZRXiZk9H1lWXIH7R0Qg0NKHs+fd0Rx8aFFDNW+LBgqZv0/hEWgJsmz41NWl45ayvmeTwWQ9MwLDZacZrij75VXMivQFHjB1HHReDspIAfvi+LahEwDJjevYgwHgN6LbwZbrk2+6rwsdftGLqRBfeeI6PHMzCgdXtWYsK5trVl8YzDp8XX2sM4mUQjl5k18Wx/vZUHb74sAVDRzjwwHPpFgxByHuCjsWDCyZKrAETzxvBjrfrne1meBPkp0X5AKhesRXlHy+HPTEOA26+incmWFIZFAAY1JI66DAoqtEPlRCfh4Dqh9fXZPl87edVvoPY07aatXPNdJ8I2W5NP0VgrKOEAxDJ1tfUoKnNDpdDxaB0AgdqPeIqiMSxkOPsagRIvfx7sJn18hNYrTfAMwecXaoe8l7+XZ0SJnXnfDQq74pFUfTyTwKxXeKwno8yIYLKeYzU/cxSd7kFCNjI9SuGtKM67n7gI8HbyffHlS55eWQYgmmcD69pZtagJ9PPKIjpDwxCMgbcuRNRv4ZDq99D0YaPYXNGYcKJtyA2KVcPHMz9RGaBMgMStfv6Sd+gBjZ3NGyKng0gnIE1Y2BkDTiOgYKCosceh7+qCnEzpyPt3DNZ8JB86vGwZ6WjedVmNKzb3S5TwFj6qBTBMgOUJYCRMWDbWAYB8HkDePPcz+Bp8GPezWMx4vgB8Kh2eEg2VrPDqzng0Rxs7hNz8OVr789mo+MH7qjVnb4GRWcNpMmMezghEF3W319vwF+fa0BOtg1LP8qJ4M8hOO6ntSsuimVqii+91mS27lsCAe7oucP/+vNmPP1oPZJSZLzyYTZsbBTHWxaDAgTrusT1E5jegU6QkDo0HvYoO8pWFxtpfzGZnQhA495i7H/hQyarPezOa2Bz2NhxRdlABAVauHXW2qGXW4hhMm2ciTMwrs46B5r8Ndjc8BVvM4s9BXYbAVM70k0Id3tNMmqn7GKOmmrUQnaZiI5Ce/lNroL53UKjhzM3ojp1LI1aXUgvf+8qnNSZQEqBHVmNVm7p5V/Ya/R7FKI7PZ+VRTGSXv5IWiQ7O99ebaslE9KeyrkngUhn3AKbtB90Ku5sjJQm9fp89L10RKokgKJCtCsHPctM9Mi0XgYGvSlD/JetPzDQMQYMZ8DKAho0XwB7lr6Myn2r4IpJxqQTboXLRYhurYNJzzqoVHoAAt5WuOKSgwGGAWuQwNPGPFPgR+GTPCiInz4dGWedpe/HX8+84VeA3YbyZ9+Et8nDqZEpKGB/JDxQYBkCVkqgZb2koJcVFAX46KJP0VLRikkXj8KkxSMZNTKnR7YZoENKstPcXCbVQhnR8XbMOTYaxYcU/Li6TS9369gC9jvXI2H9N7/8h1bc+PtqxMVKWPtNLmykPmgx61poRyhf1omFZBmzp7tQcFBBdbXSDqMvsH87tnlx4zVVTIr5zc9z4HbxkbQtKCAIKRtIZraA/qP7JrII6WNT0VbdCqXNH0wyqE+emgZsu/d1tjz8jsvgiI/hpQpdnRGhQYAe1RjZBDJSbtQvOimZqwNWNXFCrFDzKW1YU/Me762PPR7RNp5q5R00Yf58Qx8+egAS6sio15+UFkMDAwKPCa6CyTgC0ZJ+vl4YdQoQcoVGeqHm0VqNNropEfbyd30+Qu5r7Nih1qQ1sDo/BT2cwKj3csICMBfufJR54SyK9j4JeoSqIyNPZ4CocNTKu1nw0NtMiDAqJdHoPJzt1NYbmJAJUnt9h54GIh0FPuux1FCetIp29VvfWn9gYMkYsAe234+tXz+B+vLdiEsZiEnzb4ZDcvHSgR4I8O4DUX4g0iOBTwD8DbXsYRyVQhoIwR0IPEMgwI4kxRjAoWceh7+6CglTpyPzdAoKxP48gHBExyHlol9A81Op4RUWAHDQHQ8GAtaggAKBgAx/QIbPb4PHb8dX132OhgP1GHLCEMy4dlJQmYFJGdNxmISxuZ3cMC8x8HbAmx7gDIX33V5rBgXGPxEaaNh/wIdfLC6nOAZLP89BfAI1CIZLoIWGASJpbsHZAbjjZu64HniUkMc6QbJBT6yhutqP884sZ6uvvpOJtHS7jifQpafDZQuMjAE/DsVotCz2HXMGB2jtfX97O66CgNeLdTf9HZo/gGHXn42YPLov4gpMAiMTZ6BjDsQ22pF+M/rl0z0jkieXg3QT2tfgVVXBqso3oWoKxsYejSSHDubqAIYQzqzYEP2k7CFOuZ2txe6gwIAj2L/RuQqmMoBjX5jZKWCip82UMHEHUBvdTCR0E8HeVadANcqDtnuCgh4iTOp90EMWbxFTslqTVh/EEumU+obhThBHhfI1WKmVZ/RBJsSagSEjLgOrFWg7UIIDrMWwp5iQcEZBDf0Gw2UmuAR0Vjvlyf+rXQn/v6w/MLAEBkpLMzZ88RDamiqQljMJ42dfBRuNJg3woLXkIPAIvOzA+AoCGhoKd7IbG5sxNAh3EDqpAQUHnnsMvpoqJEyejsxTzgYoWCBPRXM6no5HiJs0AVETx8JXWIaa97/lDp1lDiQGKqRAwKvY0Oa3w6s44FPs8Kl2rL7rS9RsKUfmjFzMueNI+AO2YJChBWMQCLNMnAeUBo9LdmLm0VE4tF/B5vUesxuBOXK+XN8QwHHHl1Ksg7dfz8SQwTQS4+ROApcQbMFb2HFE4kE/+JwZ0YiPk/DBx61GOUGU7f0+FSctKoOnTcNDT6Zi7Dh3SAaCHse8VEBNlQKfIECIkkbuSOKdh7RNz0AMOSYPkiyh8Jv9hjKhILVac+PrUJraMGDxPCRPGWHpINTLDEwEy4x7hOqm8aEo+BRARAN7QLoJuQioPniVYIDXmvJ34FVbMShmMrKiRgSnL/R5u0yKoeUgdSi5mqr3vy8r4XX/vNQWRDl9QdwBWT0Ej4UzIaFLugmhYDUaGQ7DeKRLfaEXyE0ALK2Ok4IQ4g6gzMVYzECSxIOHvrBkPfAhpyWMsgc/4juDRTFSQqFILMGQXzavr76HhEKRmJB4tl4fYTQKsEPXW+ibzIQwAp/SA8CaYRKZiXgkY6LUM6Bor01Tez/9TKw/MKCbQNoG9ZVYv+Rh+L1NyB86HyPHn2M4fsoM8C6C4IBABAtGBkFR0VxxgN3YxKxhrKOBeBGMzgU9wFAVPwpe4kFB4sTpyD7pbEPZ0cgw0Hv8+uQD0i/8JeTYGNR8+B2a9leyjICXAgC/A/6AHUrABlWzsawBOfXtTy1F+Q8FSByRhqMeOV4PJGT4RbbAAk7kWQR9mWUQZL3lUIAZJfzuwUzmi+65VfQXm7kARQlg4YJSNDdrePShZMydE2XJKlgQBME+zVw2XtNH05ag4eTjo1FXr2L9Bk8QHvD0U8tRVaXimt/E48RTYs2RvYE/oFqlpXRgvM4PwkiOghwrf81mk5AwMB4NB+pYG6M47oZ7PkJrcS0yjxmHvFNm8kxBCAuigTOwlBGMZWumQL9WcQczUjlivLSOs13STpvKP0GTvwoZ7qEYGqe37RlBgfjr7ThlQIGWvtDuNUHEs7e1BmV1bq6Qmb26x9wBXRmVB+hOW3vTN2CZAVYbIPFySl8ZjczpfHQ9wYh5H0PMZ0rBIja9NUHgI1r6zExIgGVCErtBKBSJJegZEQHoJGrl9YxQSMK0PirHhGshFFwGVVppt/QWumsE0CQT3x8BN0VmYmoPu2P6rXvWHxhQJFxZgI0rnoQa8GHE6LMwcPD88NkBa1DAllV9XYXkV/UAowySbIPDHsW7G5iTFyUHUuFTsP+fj8FXW4Wk8TOQvegcwE8ESBIkH03U6SBBJmGngD6pJFZkQ/pvrmKOoeih1+DzEfDQZjh8AUqkqeCN1Sj6dAuisxNw1NNnGB0NtL8SsPMgwMAU8HKCUVYQ+gbU7aCZU2KaA1PnuLF/jx/bt3mNTAABDs86vQJlZQFcdVU8Fp/PuQq4AmNw+2I4s2IW0G5/DXfewpne/vxogzFC//XVVdi2zY/jT4zGb29OsuAOQrQUWLm/fVsihQAsUGAAxeDggZYHzx/AJJLLVxeyA217YQWqfjyIhFHZGHnt8e01FPTShokzMMsI7C9MV0g2yglGqyf/oMk6zqCymfOZ761ejsrWvYhzpGF88qIw5YPQzEHoPdW6piqGgz14dxsAxPoecxVEYqRhIFreOHdADWPS6wuwWvjzkbgRr/lTrzudm+rSvUHMd2bkJOkcglDIzIRErmgXqTFVR0hMfpkwIRT0CEKhuD4qx1iNRuki8CGq481Y1S29hZ5mKIi8iESYOHCz7zMT3TatH3z4P2U7Nv+TzSdMugyZWZOCMgUCe2BlKRTdC7ztkGcFRNbA11oPhyvWaHekiXgMZKLI9SrY88aj8NZVIWn0DOTOOweyn4IAKx+CoBUMnuhh787KQMLJixgzYunTbzKHzUf45NQ54LD0y004+MZKOBOjccQL50OT7AbHAcMSBGysHTGgUnbBZEQUmQPuUwSQUc8kUOCgSfj9g7zmfPctHGtAduO11di8yYcFC6Pwxz8ktwsErGyIwf7KymjQvlwu1nOy7MjPtWHFSg9UNYBHH6/DRx+3YvQYB55+TuezD8kUWLsWgrAFEpFCWfYRmQLR4aBP487lRDz7PtyBg5/tRMF/NsGdFoepfzrXzBSI94UGCUIPwehAsGAj2Osma6I4Fsk8uxycz6CkfhsO1K2ByxaDGRl0PqldV0YwYlPqICiwoqC1duvUL05lg7UlHOQ1LcvZY66CSIzOR87Syh1AGgGHy6gu7ocfW7U1jMCIgpDDWZemujipEBKQkgISInPq60xIaCBCANLeEgp1h8uASJysok99WR4Jx7ZYiWKLCFPfZya6ber/Dsagn/mQIeAdmDb5GkTHpEJTzLowA25ZvZZQBdKVe9jImkapOsCM6tABvwcxidm6KJM+7mUOQsGuD/8Cb2MVkkfNRN68s03Z5HbQfEv/PK3RufQ2t6SFx6B18za0btqFuhVbkDx3PPscBEuoX7MTBc9/BVu0EzOeuwiy3cmcKekfEF6A5IJVSeZZA5kzHArtAJo0iWCHInNA23ngwQIEyEjJdmHSDBc2rvFi9y4flnzehk8+asXIUQ688GIqyx7QqN1kSOTOjzEFCoVGy6WSkzY0F9q1LJrTJb+MxT0PNuCGW2rx+putSEuV8dFHGcbXwY4fWmtnX5eOM9AdPhNkYn3SvF2QZQ1YoBA8RSW44E52o2pDKcpXF8Ee7cCcZ8+HzSFxtsuwokr6NsZnoGcL9AsxCI6sHEZsnWtP0np8TA6q6ndhe/lnsEkOzMr+JWQS8FB1Ss4QbEG7soL4tQlBC0GnKZatvymNAHpprGb8WWkRbkEMZmZF49nDOBojwCOB8/qKOyAyzQSiEypiy4czCBGdAoSWF217QzEubNdAOCO0S88yMJwEaCBGIAPZQeDAnnXNd/wukl0TpFEkMsVaUDVPR4ihDpa7Z/R7oefRJBwBFQo8YbpaOmvb/L/CfPj/wyStq7zj/2EjHumEhAQkJw7HyKGnwu3mKSxra5nxELfrD3uduQ4iKLD0qTc3lmPT939F1vCjMGDiCQbLHf2ot376OAsKUofPQN6R50B1gNPq0iSLudZum2rXoLF9zddUXxsKb72fIhEMevx3cCdHwbvnIAruew2Sw4Ypz1yOuMwYJqbksKm6qBKJK/FlhxxAlMMHl8wVF52SArfkR7TND6fM1/lEqowKXJZt1cWtOPeoYmRk2VBRFkBqmozlq7IR5aLueHLEVPagBwmfs3XLNi2gorUVaGoJoLUtgFavhpYWFW1eDR6PyjQVPF4VHq+GNpp7gJbWAB54jCv00a0+99xouFxURtHgp/ZQVWNtmYrKGj0YMVKAwKRsXYMSoEwJgTR1wKbC+R4C+v6stZPew3gg+NRQ0oyAhyOj3akxkElCWQdI8gyO4CzRAw4BnjRSJNa0o85bYPZ4cgluCw4gEKAHHHcQTP0yyGnq77WsB5u53vkfs3U/vpzoBup+H48mr4bsx5rR3Olz9n/2UdFvP3FraGiISMq4N37i2OxfwS73vLNEUb34pvSFw/pZ+8r6MwaElq7fg5XrHkFMVDoG589HWqoupKIPuoi6npUOWGZALyOQEyRHbggdAHXlXCMhMXUo30emUbqCbV88AW9TFVKHTsfAWWexkTtxFbRr6rfORaYAIYIAdFinG2lXXoCqZ15B8Z/+hqzfnIfCP/2d1bXH/PliuFLj2WiFcxnoYkdMz0AnQpJk+AJ2ToWrAG21raipbYW3jiYPvPVetDV44Wn0wdOowNOswNsSgKctAG9bgAVDFBSQtTSrmDK+hBMtsayExR/Sch8HynSsN9/svh59qEomT82bK3xR5xygrJ9fH8XJEvwtPoCm4DebBww5uKkWyV/jc/EV6hwWYg92n1QEAl4jKHDb44J/CmHiAMmaCbBgO8MvWf9PFTDFkEJu9NjQ6AXiXRKGxyVhf2349wbdy7B9kuH25mtUshBAMmJuJCxD+HeHX+v63MF7tKLRuD5CuJMCYrhjh7uy7p9TYiNbwdRHrZKiva/n1xD+XcIoxS5GyiT8FPnRIr1i8xXKZpThoBFI5mJoN47e/U/kg4+VmvhrMkFhO30/5TWLUYD/imm9fJj9jOLq/sCAiFWG/hL7y5ehvrkYW3f/G/Z9bmSlTcTgvGNgdxDCWTdJJyWiP209KGA1Y13Np6me/6ATUgZyToSAgq1LnoSnqQppQ6Zj0IyzmLMUqewgTt8Qs5YPTCU/fdKAmNEj0DJrClpXrUfhHc+wH2zc5GEo/WgNSto8UNu8UD00+aH6/Aj4FNZ/Tw5PDXBhoYgzmDTyZ6JCuuPU3xcVDaSk2mC3SYyl0G6X4KDJQXOwucshwekgbXEJbiety3A5AZdLhtOpb3dLcLn4NrdTg8stw+2S4I6SWFviRVdXw8v9Jn74LgPRsTam/CjZJMh2GTYnILGMjgBT8s5AP+NjII4GoFXVGR1VYnrkk1i2zptagOdP+hJt9TwtO/T00Rh/7ZFQFBkBavdUbAgoVI7R57TOtsvw+23w+/UOkVYJdg+pdqqwEQbFp+lzFTavrubp06C1tmLd0r8atzopOg9T888x0xf6nDItQWkNIzVC+wT46/yXY3kAWfs/+cyjtWAlvgyq57a0yoh3eTAnejKS66xOtPfWpNVhLb4VkFYkIuWwtptRLz+17ZFTIUAe9byPlLiK5eEwQsyXo5XVwSngysZAZPdhq2eobdJWsKCAAiyS3R6KMXBKnI+ir40GFyvxBfveCKzKFBoP470kUaRV+IotU88QlUuGS51THiua/78YGGj/M6WE/sCAHo7R2Zg27GIoig/7yr9Dac1mFJWvRlH5GiTG5WHIgIVISMgznDkrJdB3bBS5ufNsba5keAX2kFAUbP7uSXiaq5A+aDoGTz2TPc/JWGsbjeb9enBgDDj5MtXq2bIICjQJvuoatO7ZibZDB+ErL4dSXw/N4w36wTVtsLDn0UhVliDZZOY8ZYcN9mgn7G47o/11RtvhjLEjKs6GmEQ7YuLtiEu2Iz7JjsQUG1JSbEjNsCEhXoPbpsIlKfA0enDF0bvh9/LzzZzjxtMvpYUtGYRuIxy1XaJ1LoYUjC7QMQa6ExPrbR4VY2aVsKBg/lEuLFnmRX2dhmHDqLNCBAD6XF8W3QkIAhfS7eDcBQT+MHAFAmOgz7VAAC+f/R0LCqZfMwFrn9mM1opmvRWRU0y0BxyK70ivO1nxKGwSJSihpWACE6kLZuPy56AoHgwZsAAFhd/CF2gNjyEI7UYwPpD4wi0oC/F5xLKepfBpXqONbjSmYSfWMyfT1BaHrCQP4qL7tl7bojVhraWXfz2+P6w1YaI65r38NoZhWIUvmfM8XHZI221QHY/CFEZmRCJCh8u2aKsZaRPhNYg06iB2McAjnf9wBAXkpAWQkjoEIhHC6qkR7wN1c4gWT9Lp6An2ot/6xvoDAzImUajCLtsxMmchmyobdmNf2VLUNxVi/baX4HTEIi9rJvKzZkG22dsHB7IEn6cRTnccY0/cvPyv8LRUI33ANAyZdAYHrbGTiUwBtcZJCFjxNBLg9zShqXg3Wor2w1tZCl99LVRPW3C0abfDFhuDgNdnbE9dfCISpg6DOzmG0QNb8QWEKWA4A5sKB9uuwGnX1+0KYm1eC65AgYuwBTqugNolqFzu9QPXnbAXbS0qbvlzGp68pwoHCkg5Qcgmm9B57thNx6arQvMafbv2Oj0FYowp+TqVW2YvKkNFpYpbb4jHtMlOFhhs3uLD9OlRlu4DkVDhINBQrB0HIepMiNZgwZj0T6CqeOG8H9BY1oZJi4dj8sVj8OMLW+CpaeFjT9HloC/zJJEeVLCWC0u5wMplIC4xZKIH77alz8FHvBn5RyA/dyYOFn0PRfUEiTFxGUYpeC5umfUWit9WuJEJaVyo1Fv/BXPMwzEB2dIA7NY26oGBg+0W7/b36YN+Db7R2+hmI0lKY8Hw4QoM6rVqbLRQHTNWQ5Y1OjyBASlP7sVWNnKfjYWsQ4CMOiEOh5EyI5UQ4pDIgixSvSSjwKCvjfM+fMPAjdTiSaN2Yh08XEYtlxSEcMbNaazFc7e2Bep/E1gYiamiTaw37/95WH9gQMbSsEy/2HDc6XHD2eT1NmJP+RJUNO7G/sJvUFD0LVISh2P4oOPgjtJrpURUGFCgqn5ERaVg4/d/RVtrNTLyp2HohDN46p3D8I1RXEDxo6FiHxor9qG1thjexhoonubgH48swxYVDXduPlzZOYgaMhQxw4ZCinGj6JmnEahvQMz0SWhZuxHeogo4Fs2AZAswYh4moqQj3wlfwJD7VPOn09sNgmGD6IjS8GanP3N5hlBxQFVw2xk7UVelYPG1KTjh3ET885laVFUEgtoRmYMWfovq9GwkzhUgTcS86dOk0GWBogew6MwK7Nmn4OLzYvCHmxNRW8cxDbt2U4GAFXMsTp4HFSJTEK6WZ1Aka5a5nr2hbMHLV/yIyr1NGH1CHo66cSJ8KmB32eGt91gcvt5mqLcf8p+LHsxYswdG8GcGAtbGwYCmYveSF+BpqUVm7hQMGjKfno6w25xQVJ8lAAgziaMIVsYIjLplVuNL5kQGYwzyJd6OKdLfjXpgEBfl79MHPY3+xmA60iTOfEhO+3AEBlSu4AQ/vI0uVhLALsom9f35yrRDhvIkBQUkMuXU62uHIxDZpW0ylBmn4RgGTHUQIvkwnI+CAmq5JM6CTOQbLZ6ksChe78tuEpJPptIWK1NgMrKkAfr56LfyE3OkWn8p4X8yY8DMMqKlZ6/bHotxeadijCShuG4DDlasRHXdLjZFu1MwMO9oZGVMQF0Dxxc01B1kAUJm7jQMG3s6AgEVDbVFaKjag6b6YrQ1VbGsgKYGpwpsLjfcyVlwp2UhOm8w4gaPhD0hnnc1WDoSqDuh7PU34D1UiKgxI5F20S/QsmErPLsPcOfPJuH4LfoDoqWPuh2M/XQFRjFReyIFEjonAg+XJDxy5W4U7/Vg3mmJuOD6DMbdnzvAgR9LiFtAhWyTO2h60ul5221vb9b3LL6yAivXerHwGDeeeTSVbU9JsjN/SaJK4TIFRjek3j4aCssQVMrBEw8Q/n7TVhxYV4fBM1Nxyv1T4KOHH1Q4Yh3wN/t4dkBoMOglAc5bRDdWaCibeRLrScJlDfYt+Tta68qQnDUaQ8edDM1HOBXK8rjhV9rM6Cp0MloexAbz99PhTzsQYAQ4lBLOwzAMlkZZRgW8F76pDwMDYv3joz8FIzAJWVK+8Ro5FwoWDme5wqq3QL8NpQPxn95gGLbjR1aumIWFRn2fMgdkfR347NW2oRj7GKDRKkdN9ffDERgQGRRvuczBWGm6sd0G/huhDitZv9a++a18aWSxcqXBxmscI/Lzqcn/X7P+jIE1MGA5YN098SZ84yEt22zIT5mC/NSpaGqrwJ7Sb1DbdBA79r6L3fs/ZuqL/FB+2B3RaKg9gB++vJvVka0m211wxSQhKiETsakDEZ83Eu6UDGg2CQFqS7SbAYDINLCRsN72Vv31l2jevAnOrCykX34x22ZPT4G/otoMBiwOnwcEPAugd1mawYP+umLt9tdEcMCzBf+4cye2/9CAUdPj8NuH85nQMt2hYWOc+PEHD/bt8WPkSJdO8Uvvt4yWBXreWNcxGkYFxiwj6JBO3HxnFd7/pBUTxznx7t/TLSUGICpKQmm5aA+xsBwamQKBMWjvUxnBkc5dYJ2/9ae92PxVJbJHxeGXz05nj3Xh3N0JLtTXejg+gQUgJqUym1iN38QasIwCgUap68QSK5m8BcCBb99CU3kB4tIGYeT0c1mmgOMONMaW2eKp1r90EXBYMgUiIooUC65pWK+P/rIwACNkHTim/8YJUKbRq6KU0MvAgD/ovzCoh/OkYEQ5OdO+dGTWcsVEzGHliuDzERhVOQwYBq5HYKUeZg6bZFP6MDA4oO0E5SZciMIMS1AgmB3J+vJ+btSWG2RQE6RZQa9RECm6BkQQ1NvfCgEbCZMxxJLFsgaRP7nAQOvPGPxPGaM2FqM+McQ2Rm1CSpf1/bHlOHc6pgxdDEUL4ED5chRXrUNrmwnMUfytLCBwuuIQFT0QsUl5SEofjpjkXEh2G+cikCWoNgkakeaIXndqYTSReUET7VK/fi1qly6BLS4eOb+9jrtMymoMG4zm0gp4iqsQk5fM+ROE42clBU7Xy9y0NSjQ3TFnUNTZEy3Zgi9ePIgf3q1A5iA3/vj3YQwMJAKG8dOj8caLjVi1woPhIzk3vXDv9F5GIyQIfUIm08wEO733sWfr8PRLTRiQZ8PyTzNhY5kI8x1JiTJqagI8024JKcShgpgP242peQmBLp7PgY+fK8Kyf5chJc+NX78+C6qNyiZmhiEmNQq1e+rakRkxaKQI2vjB2+dC2EF4oCAileJlH6G+YCuikrIw8uiLQHwtxJLIXpclOJxcPIana0VaJNTxW85jeSn4I/BvYoP6va5Gl40x8vR2+ANyLvTw7YuMgdAj8MJDIUhY6mEKRKh1sa/LFSSKlCpltduHBwZ9k6GoC8EwhGf967sMRaG2F/uxnWUGZoVh/SOK4L7MUGzWVqIGFazdcpJ0RNjvjoyDK3vHeChoo+m3MBAjMciSxbIGkT+5wEDtGW1U8Pt/HtafMSCjpzyr7esCAEYuWgwFxegw2OPYJRuGZByFyrqdUAL8gZeeMhYjR54Om91lBACUDWCEReSejEwEgs8n4hLuVUO8qYbWgr2o+OgdSE4X8m+4CTabSbgTM20KmpetQuOKDYj+xYKQkoIoWVucPqM7JudG2AIC09mgSgpzUszxSzLWfVyGz58qQFyyA/e+N4FlVLgGPB/5TpzJR0tbNpr9/WI8LWr+BhDRmkUI+tMyMwVvvNuI2++vQ0qyjPXf5sJmN3Pw4gGRkS6jvDL4QS+uM8zBmVkxolbA4bdvVeL9p4oRl+LALe9OZ5kaKiHod4lNsZn8Gr0NHthjSQjI1ITmX6GVHpkHkUYAwkoO5m+mYuXXqN22Bs74ZIw68UrIisxbKVjwwH9jLievjXsCTYi2xwdlXkzrqIRgRWxo2BJYZTzoJ8rh2wNFOrqxzdarwIAe9KTMyPUIBmOYNC7sfjTqZB03vTTFUpcehckdiiKRc+mLjAFhGDYEYRh4djDUOGto789HyoV7sJk543BBAZlD70Toi64L0q6oQilrXSU56nBmBgb+Pu12GNqBYBfhN/rt/5/1iyiRCQo8P9Hg6f3iggKvk0lVFKza9TxavTXITp4IWbKjruEA7BLVBHSNBRqhBs25ozdGtyaNfrAegyrpE+CtqkThv1+iegYGXvUbOIhAQDgoDYgemM+Aim079luyAoJIhz+Ig7EH5sheBAssa6BnCvavrcY7d2yFM8qGP3wwBXY31YaFeDGfu6JtcDiBgn0cIhQqrRyUIdDLB+GyBnQPlixvxSW/qUJMtIT1S3IQG8N1D02AIf83MN/BWAv9pFhpvDuo4hO8HHIerp0ArPmqDi/ffQhRsTbc+dEUuKPtLFGjdxcanYaJOXxk1LC/2riPZhugZZgeii8wYz021a77AVWrv4U9OhajzriOtbQS2FO0HnLwIvE5cIfT6q8NgzHooKRgXdYjpJ2B9ToVcCIm4yjLl6KFHXVWt6q9CgzIaQplxlHS5A734ylorQ9S0KZIUY6lLh1qHNPQOwBbi9ZoYBjIaVoxDIcjMCjTCg3lwtlY1KFIkUjt9zZDQXLGQruCgp6OgIUOIzDw9VG3w+BOOQoE2PGnZBqBuns5/VysPzAgY6JIAe68rRMTQVJ1NUWamxOpJK7a8yILCnKSJ2LMgJOQkTQGfqUF9fUH9GNY6lL6ZNDgCliDMQnhJp1lkXlbDUpzMwr+/iRbzvvlFXCmppuKRKIdQANsSQnwlVWZJQLj+WtKJ5tzC/6A7S8UFmVUFTTjX79eA9km4YY3pyI+xRWMXbDME5OIFjnkwWQ4rOAMQag7EOubd3hx8uIyRpC06oscZGbwB5AFAmosjxjGX9u2Xc9SWLEEHS0bGAPugretbcYjvzkEh1PCfR+MQ1yiw5JJCM4YJA3kgUHjoQb+GViZwcQaGBwJFlyCdZmmxi0bUfH1x5BdURhx3vWQidWJfxjeNaJHIrTscnOn0+atD3PnQsOqkGX9Ju1Vt6AY+xl3P6W8ZWKm6sCodk1W1ab0GGOwUVvBlBJJyrkrZUZRFw9Q724vU9CDMapLkSJyrr1JRxPhzhos0TEMR7TDMPR16aJSK8V2rG0HbAx7Lt2B9yYQ2aNtNuSMu9KuMMGVvh5/dz/iWwPv0lkAac0YRKo38V8xrZcCSj8jgqP+wICe35ww35INCLdsfsGqEsDK/S+j1VeLnKSJGJ17Ans2D89dwG7qvoNfG87bdPrCsYRkCIxAxOx0Y/vR78ivYN8/HoPm9yH7pHMQO3Co2Q1HQDs28XXXoAHQfH7461sYroA7LREkhGAL9GXVso1aFptrPfj7L79jksOXPj8VGUPirLGHkWFgLlSTkJ1vR0uTLn8kfBNr3wsZnerLoqwgXikq9eOIkzid8lf/ycLIoZxlMjhbINaBiWN4YLB+Mz2cLKA/MaBG58uHdntw+4WHGIvjfW+PRGqO23TyFnyC7reROpSzADYVN+gloA6iDh2UYLQrMtZKDc17dqH8vTchOZwYctFvWeupSXCk8xIIMSVJYiJeZB4fpw82ogfDQvMgwS8dVHfhoLaTKf3NkBYywGzwPsGYBRLCsQYG3c0YkHJhDcp5uSJMXbqj0oVX7/nvflDwtZGCHiyN6fI9HFzZM8fi0TwGGdQ4hmHoWrlQ7kWGokarwBasDAts7Mx6GhiQyiVxIbgRjZlY2GULoqOXmAbKKhFJUjpyMEaa1uX+IjA4XDwUPTKtX3b5f8valQ/ClBI0s3yw8uArLN2bkzAeY7IWGZkFl+xGXFQmGpuL4fe36sQ3OnhQNPqTGUN6s2ZtlgZ4EKEqKva++QSU1iakzV6AxHHTwiP5RDlh8nh26IYfNhqwPBIKYuDDoIBATCSxzLMINPe2afjXOV/C3xbAafdPwqDpqXppQWQcOMeBaGskNzpklIvdmpIiJjnIP06YskG4jEFdg4JJxxTB69Hw5t8yMGcafxAGu0GrI5QwbTJ3ZLt2iYeFVbWo86m8xI+rzyhmn/fu1wZj4AiOGWBXZUg0By8nZPPzNZc3h6evbgc+1LEGNNosOIiK116FZLNh0CXXwhWfYEYceiAhmBBF7SIqmvNiePxNYVoWraUDcXKT+bAkUIC92MJGdrOk4xhZV1izBGzkFMiq2vj9jItS2HVHmoIWyoUd1aVDzamPOrsbGIjRZiuaGOVwVzS5va1TU2/9agPDMBUZHWAYQo2cek/aMTmwcUUXwMa+K10c0HYZKpeRBAXWbE9PAoMN2vdGVml8SLdDRybaI39SgcH/kPVnDMjCpX0C7ddVfwAri/6OVn8dcuLHYUzmwnZR5NAsrmlfcPBrLu0r8AU62Y+JNxAZA5E9sCjxqcDBz16Gt7YcCSMnI33OIjOYsGYWLJnkmFEcBd66Zbde39YJjNolyINxBjRXVA0fXPAx2uq8OOLaMRh9Qj7LIHCdAY4/MJdlKPo0dip3LKuXW5gZLdmB0NSZ+Mhen4qJ84rQ0KjiyT+l4PTjuWgQN5EfEGvmlqx0O7u2/cRl0I1MQWO9gsXHlbAg5I6nsjFxejQcTDkywBjg2RRm2Ukjf5sET3VrGByDfveMsoIZNHjLKlDy1xfZjrlXXA1nZgZUuwTVDqgOiU+k7UDbHDCWJTd/+PqUlk6KL+2tQinEjsBaXpdmQYFel+4idSnEfqoEtTbhzSNgP9yrbTVS0KxcESHhjShd0Ki/u731fLSZi9HS1IjfJ5xZd9LRob31Od3QPehJi11jhMDGcCb1oHTBux22sQzAbBwXFtjYlxkDYkysRSWjcI4kqxSKofhJBQaq2vvpZ2L9gQEZyxCElA+09kDDlaX/5EFB3FiMSV8Q1DUg5mnxQ2G3RaG8eqsuzyvkdk0uAiM3L97LzmeWF4pWvYemol2IyRqE/IWLWRsjAyUqRLFIE2Mq5lgE2qbQYNQOOS4W3uJy/VwIO2fqisbE5Ye/vvZzNBY2YtTpQzDt0tEMb8CcP6G6NRubs2XGRkYBAz2QZIyfw0c2m9Z5Q8bnmqX0oFnmGgKqilkLixgfwa2/ScLVl/C6ejiwoGmWUa5bQkmpwsH86GTSX/d5VJx9bCmamzTceG8K5h4Xx4SvROeAWJbCLNPo2e6ywdPQxpQoZTnAJhub07qqbzeXlbpaHPzzM+w3k3n55XDn5hngQp5VMSMMTg+tb9czApJkg19pNSmZjPS/HHa5JlCGLf7lLI09U1oIp2ypS4drd7SwKNr1h32r6kOLN7LOBBptHsJu5uQjHW2GBgbdaVnkGAbeWz9emonumKObGQqTh4F668e2663vyjimIfKHf7PWiB8ZsBFdAhvDGYXL3clQRNLt0JWj7k4gspVpO5QxNc1JmBvx+/j5eMbgcGpddNu0/lLC/5QRTz4J6HAFu/Y4AxYUlL+OVqUOOTFjMCZlfgcAE559yE2ehIDqQ3nVFrO1zYIjMHEGOkCRfQj+3vLtS1G18wc441Iw+NSrg/ezdjAYGAVz2ZmXA7WlDd42BX5VtkySMRejfZoCqg2r7/8OVZvKkT0zG/P+MN2obhj3xjIXvQAizohLsjOVw317fMzpG/8YjkBgD0TJhB/p5HPLsHOPHxecHYv7b01h24I6DIwzmzgDM2cgITFeRnWN2nWmgIkUqThzYSlqqlVccUMCTv1lYkhxopNl/SM7YhzwNfn0IMLir8k3hywHWlqx+65nGTYk/eLzEDNUdyzGRVlFj3RtBytWk4IZ2Q4/tb4GUTWGv9iGQBU2tH7DU9C2hYiyxYWhT+4gQLAA2GhUFgmXQZG23xhtkmPpLjWuGRh4I3YsHMOQEra3PtLAQOgYRAJs9Bq99e15GLqy7oAdW7VmrO2EnCkS6w7Y0drtMKuTbocOz6V/15FmDEjboQLFrNQ0BUd3+7diBgY/Mb2E/xHrzxhYI0Fd3lZTAmwygIbVb6E1UI+c6NEYkzTPzCi0m0iTWcXgTIqOJRwoXsrvcmiGwJDU5SUKSaGuBw31h7aheP0nsDmjMOKMG2GTGE2QochjBhSmR7GC9aLH857gph+3GxgCPrcum5iDHa+tQeHXe5EwOAnz/zI/SFaIdx+EZKT1dkfxeWyaivhEGeUlRI1kmrU0zlQe9eUrrqnA8pUeHHNkFF56MiOCn6f5mBWliYx0G5pb1LD4P3NHrg/wi1PLUXRIwdkXxOLy3yZ1mJEIfa+4ZsqKuBNdUAicZy3xh/hceqPi8WLrrc8yuevMxacgbtIEUwzJ6HK0lFkMFUk9w8JKV4BNdiIQ8FoiMovQArv3fKlZqcePjZ+y5WmuBYizhZFL7ihAsGguUFBBgUFja+fsh6QPsFvXB+juaLN9YOCLEMPAHUtQy2U3TLRj+rvIUAhyJipx5GJoh731fYVp4EqCBGxUMR6zIgI2doxpUCOkcTa7HVy9kGmOJBDZpW00tB26U2oK1x7ZVWDw31Rg1Mg/9HL6uVh/YNBJmijg9+OHurfRqjYgxz0KY+KPMjMKzKnT3LrMHb1dk5EUk49WTw08bbV6u6M+Udo/FF9A/dK1xdi78p+QZDvGnHIj7A7zj1cfp4cM5a1ARu5c4qZyAGLzhh0mENCCejfQ8JKEwi+2Y++/1sGdGo2FL58KSaZUsslWaKDlKUAw5mZ8I0ucgTArx47GBv6DD621mx8QuOu+Grz7QQvGjXbiozcieRCGjL0YSRIwIM8Ovx/wK2rQ57H6TrIrL67C9q0+HHt8FG69LzWopY8dLtyy7sjpVIrOMxCd7GZAUCvmL9To9c23vAilsRUZp89H8twZVjxi8IlCnXxIh4rD7kZA9RsBoBkMmpkjAieuqXuPjTYnuY9Fgo2oo8M3S3CJ6ZAAyvIZyLkwhUVPxxmDKtZGZ9UH6BklrggmupImtrbR9dSxkAk5Ym8n5zPb6JqQRbkCSaeN7oFFgmkIFpgiJcGcHp+PswOqPaZx7q7x0kXnYMe9mmiXDdZ26K5Foj1B95nEs/5rpvWXEv63zMAVmP2mrHzQ+B4PCpwjMCbuSAuWAF0uj8g6lh1634EvWSAg2HEZM7Gl1ZAcgq+5Htu/e47tP2rh1XDGJAWXGKw+LUyen9gLKcST3W5IUW54DhSbHyVo4lmAqh8PYfsTS2CPdmDhq2fD7mByizrUIYSzQM8QWDUYhIQxnWPwSBrhArXV/rCdAuSYXvhbPZ55oRG5OTYs/zzb6K1vD03kZvXT/CWTOXHEEO7Adu7SnWcYZ3jz9VVYvrQNU2a48NjzGWGzAx2VEehjmPkPjbMfkux0s9cIIEy/SvLQAWz8/avwVTcifdEsZJyoj271D2fITAenUYJPakhyk6J2FFSjz799T4cv0IqVtW/zNrroo5HqyLZELF1P1pwFzYXCYkelhDqtCpuxkoUQvXUs4kZ09rAv0HZ0q42uM3PqGYrOAhET2EhtdJEDGztLf3eEoehISfBwBQb03XVN49wdkzrNGBRo23EIe1hmqCelpvAZA6WToGAp40Xot763/owBWYgXJUW6lc0foFWjoGA4xsQcEWG0yNCGrMYeF50BlyMe1fV7WK3b+nw3uwokKIoHm797kqktDp19AWJS8gyAYlD3gQVbwPgRrN0JwjQJjuwMBBqaEFBFqtpsHyRrPlCFzfe8D8km48jnz4EzXmQmLEqM7bAFYpkHBbyljQcM4ybz969c7m0XtZAr+vDjFtx5Tx0SE2WsYVTH4YICfn5LbsSafzCdK4BxY/hIYsPm8A/7B+6vxQfvtWDYCAdefZOXK5iCsT7eCb4j+rIlkKHuCyuHQkIuf5jWF9SZn9Ti4Dfe8RZai6qRcsQ45P5ioeW7Cs3wGNyJQTeWgUgtm50OXS9BpB1F+oYekgEffqj8NwKaH6Oij0Cmc7D5YcLJR4qIUmRCgu41n3Oa4kDYwKCBIea/Z3djOo7pA8fCv4eOAgNCzBdgBysB9DYoIHN1oUBoAhszIm6ji8SZhctQELCRWiAFY6NVSbCn1lkXhPndAdO62e3QE7DjQW0XCrCTZWl6GxQEkWF18FvZiOVMByQZkZQk+8jUXhIc/Yy0EvoDAzLdofOgQMHKFj0ocAzDmGgd9MS4DKwBRLhl3cfohegB6TMZDWZR+Sp+DMvu/OEfwKalf4Xib0P++JOQkjc22D2K4CBs7lt3NBY5B3pP1OgR7K2t2/aHCCZJ8NQ2YePNr7PLnfHoGYjLSeQOy8KAGIwxMB01vyyOvDdMAqYfyVveNv5oeRjqA+KVq9pwzbXVTBVx+TfZiInVg4IO2+iCtwtXanXk0ybxB8b2Xf52QIEXXmjAiy80IjvHhvc+y+KZCR0PYdy/TtIHAVUoKpjBYuIA3krZcLCuXSlh4/0foGFXCZImDcHQq04NKuETuVSH+ALdSbNOk5Doz+Xk5/MpzUH3hVQ7fyh/HX7Ng2ExM5AXNSqE+jlMjaNdpqD9ddMol+q0RmDgVgzE/DoDMX8U4qQwGIYeWEeKhyXaAQMxP7OHGIaOSgnhAoMtQcDG7iHmu0p/h2IauD7Alwx0ORhjumRs7C3YsUlrCPru4rvZ7dBdTAMFdPsYKNWJ2VjYJ9+dWUoIhA3o6lCFZKRjPLrXqdIr0zrClkU69QcGPyvjzlNDgICGbR+hVWvkQUHUnDBZgY7LB9aggNbzUqex9rPC0lVhRv3AttUvwttWh8zBs5E9gj+cBBhNpOpDR5kmINDS3qAbrcbNnMKWm9ZsMfEF9LBq9WPzb1+F6lMw7rYTkDQ6OyhRzZIUIhCwnJQHB1T24GRAIcLDSM20MybBveSoLaPw3bt9WHx+JUgg8ctPM5GTxR0P/6BWQJwZ3AQtG4+84D+mAXn8OPsPKEGD43feacL999chKUnGp1/nwO7QgxCrcw6XtdEtYIhkWYSQ6PqG8JFWU1FTUJlky+NfoWptAeKGZ2P0788xT6J/vyLi1u+exX3rVM6KoMi2fD4a5Tr5+Vo8NcZGyh6sLHkd3kAzBkZPwqBoIZ9s3gEzOLDUKNplCszfkZjbwygsEjiORJFMxDxnZOwLCydsVKEVYSfWd6kP0O1zGUh6XzvEfCWKEReqJdFLE73+1q4LERRQy+QADMfgMEqCPbVwYMcWrQk/6t/dJEbj3HffHeULQzMGJdpBSwsk8SL07XcXmjHgKpCcbXOyFBmxVr913/ozBmR6pmCV92MeFNiGYrRrdjCpHt8xeLKUD3gdXKfp1ddlSUJ6wgj4/E1obCyxjOk07N76NhrrC5GYPgKDJpwS5FSMZRGctysZmK1yxuv63JGUCMlhR9ueQ0bGgMoKO276G5SmNgy+7ChkzKU2Out1iMsJyRgYjpUHBWwUzAn+jVICzePiZRQXCUetoaJCwaknlbMky9tvpmPkcNJbMFH4ptMPb9xZmsPa0BS42wUUl5jO5ZslLbj+xhrExEj4comembAOzUNxBCEmsBVsP8sHoy2JeTx93lLeZGzc9uIPKP56J6LzkjHpvvOD21DbHT0obcCXqQvF+qrlq4hy8ZF5m5/0Euh3qWJN8RtoVagrZgyGJ8zsAD4QeubOMwViLpD7Da3cycRFmeC4SKmAu5v+ttapq7VybMWaiPQBembBUsi7tU0GYn4ajul1yttqREVtzVCIbgdSncxlqpMcHNxXJjANAuzItR2+YaP6CZiNFKlv0+yhGQPeArmuzwM6q1kDkUhUIA+naVSe7eX0c7H+wIChygNY5f3EDArcs8IHAYK1UNT4DXciRrrcEVm//uG5C9l838EvDMd/YP8SVJZtRnRcJkZOuzDkVJZMhLVzQffSrFVRtjqc9o7HnpEKpabeKA3su/M1+CrrkXnSZOSdNi0ovS7KBQiLL+CvUSXTqhYYOmVk21Bfxx8YRCR0/PxyeDzAM0+nYOZMAoCZI2NxHuMjG+fSP78lCAv1Y8ISGJcBf2Cs3+jBBZdWweEAPv8iC6mp9rDVgvbrJqZAJX3soM9hLkuyDEmW0FrVwt68+98bsf8/m+BOi8PMxy6ATCkRwzmHEk3oZ7HW/AMUZIVet8gTaYiK5twObaSXoElYX/IOmnyVyIgaijHJ84LTK+3m4XAG7U4WdJEiMKhp0ztLomoMOeNIqYB7SgJE4LhNOjhuBub3AbCxc0wD6QMUYZ8ObOw5Yr6rjAEFBsHdDgMwsgvRoJ6YqbDoC9J2GIsZSJOy+/x8FBiIkD60BbLvA7pgsOOOCFUgD6tpau+nn4n97AODZ555BgMHDoTb7caMGTOwdu3abh9jrfIl42HPsQ3BaOfM9qN3YWGwBYbDC+s5NbgdcYhxp6G+qRCK4kNZ2QYUHvwODmccJs25BjbZ1u4ZHoozMLbTMYmdT6TsRXBizPlncg8fwton2w6VoeiJt9C2txgJ04Zh8BULgsFoQQ5EH2EGQSao9ZK36onzmz5QT19rwOBhDih+oL5ewYkLytHQoOGuuxNwyskcSBds5rr1FX6s4PJBqB8T8/Q0GxqbVOzb78OJZ5Szbe+/l4UBA53BQYY1bjIIB01VRK75IOssiObXaFyvvmxz2eCt92D/xzux7W9r4ExwY+4zF8DmpO8uJFi0BnKhRkBDNcx1W5ajXLwe7PU3YVPxu6hrK0SyOx8T0k+01lnCjP7bRwVGtclC+hR6UjHKrfLwUW5ilNalnHFvjGMaNJ0KmIPjpmMeYqT4w3I+QQIk9AHoevsC2NgV2DG426Fr0aCemE2vw7egOUjbIfMwBHTWLojqPmyB7Mzot0GBDs/yRKYC+X8xY/BMN33cO++8g5EjR7L9x40bh88+++x/KzB46623cOONN+Kuu+7Chg0bMGHCBCxatAiVlZXdOg7TB5eHYLRjRvgxsVU22QJC5HV+UVDWuf4stQDx/8HZVMfUsGP3O9i15z3YbE5MmfNbxllgdROhAzz9sObHsHobo2gebHSMmFl8dFL+7NtoWrsD7sFZGH7b2cbb+Mc3MwaGVLNFgJheJry6CCCCXgtRWhwziTuXUxdUoqw0gCuuisVll8XrTtkESVo/cbtwIYyugrir5jr/f36uHT4fcORxZVAU4I1/ZGDCBP5QbjdUNjASRqjFjClLGkgOM+gJ910Q+2FrVSt+fGQFa/E8+sXFsEfTQ9kyYg8zSg/6PlmmIFToIjTypHZF/rCvbNqDyqa9iHdlYnLm6cEHDMNiaHwMC0bDwB2IDE2Y55JLF1Ja37adzVPcjj4Dx3WM3NcsVMAEbOwbcFw4I+dF9X3O2OjU6+C9B8d1BpgjcSmTxrn33Q4dmUPPGGzCcpYVGYGJ3dJ26EkZiEoJIsszHcf2SadKR0bnoIyLmeU5PAHd/yUft3LlSpx33nm47LLLsHHjRpx22mls2rZtW7fOK2kdQ8R/8kbR07Rp0/D0008bIK28vDxcd911uPXWW9vt7/V62SSsoaEB+fn5TMkrCekGSx+3kF5zsW4dtTG1vBC6WraLHNLDLqG6Ybdx5ITEQbA53Ka6XkitWIzkuTSvXtJHcHmfHIx1xM+3695NBlo37TDOHTd5KEiBlzsNlSsI6qq/VDVkugBsV+o6IGyEyh4BNtqXet2Z6iBf5qzA9LrYT0Nrs4L1q/h9TUwCpk13h4xddfid5f52lO22WvgfpoYt2704WMRTKSOG2TBoMAHoRPBixkyhhJM0J44CCgpI84FfEW9i5AqSkvE6U5Vko24ZB1eWQvXxT5M6KQd2t0snvxTy1ZxRkr4Qvl1XoSRAI9O5INEsEtQS2BFTREvQaFu3Vdf9v/bOPaim7o3ji+79QimkkCihhsIkuc7USDUYDDGpZMYlGdcJjS5/GGrK3Y+SGTIjmswo5NI03cgkQlckKkyjGpJb8UvWb54ne7/7dHvVe05vp/N8Zvacs9dZnd1+zro8e631XU/p73vtz4x0Rv+eomq92FW6PkTivIqGa2s92XEYJmr8P7EPzFiPsdLNA9jPX4xZRfznb36Z7gMSM2FfAT2mL4Z+VhSwV78ASNvAUeiJ60GnBjJIRdLAvrGG3zp+cPAGsH8uSeyMj6xWHNqH+AfC1ElP/HbgZElbZwFwVOpYDauvr2eDBinm/j9//ozfPYu5ies6ugM4b9nsJnv79i0bOPCvETItLS085NHHeXh4sG/fvrHk5GQxzcHBgdna2rLo6Og//2e5kvLjxw+upqbGExMTZdK9vb35okWL2v2b0NDQjqbJ6SAbUBmgMkBlQEnLwKtXrxTW1zQ2NnJjY2O5/J96enpt0qBfklcfN3LkSH7kyBGZtJCQED5p0qQu3bNixtR6gPfv37Pm5mY2bJisVw7nz58/b/dvAgMDcVhGALxMMzMz9ubNG4V5m30B8JjBS23t6RJkIypLVOf+TYRR38GDByvsGtra2qyiooL9D+Yv/yEwQI8jgBI6Gi3oTh9XXV3dbn5I7wpK6xh0h46GbMApoA7v7wEbkZ3IRvKAyhLZSZ4I26wr0jnQ1laE8qJ3orQrOYyMjJiamhqrqamRSYdzY2P5aq8JgiAIorf3cZAujz5RaR0DTU1NNnXqVJaWliamwcIMOJ8xQ3ErgQmCIAiiN/ZxkC7ND6Smpna5T1TqqQRYL+Dj48OmTZvG7O3t2dGjR3FFpq+v7x/9PUwrgAykozkeguz0p1BZIjvJEypPZKc/6eO8vb2ZqakpCwsLw/OtW7eyuXPnskOHDjF3d3cWHx/P8vLyWExMDFMZuSIAMo7IyEhcXAGSjOPHj6PEgyAIgiCUnf920sfNmzcPNz+KjY2V2eAoKCiIVVZWMktLSxYREcHc3NxUyzEgCIIgCEJ+KO0aA4IgCIIg5A85BgRBEARBiJBjQBAEQRCECDkGBEEQBEGIqKxjII9wzcoCSFkgEMeAAQPY0KFDMdpWaelfQZ2A79+/M39/f2ZoaMj09PTYsmXL2myUAVtHgwRGV1cXvycgIID9hPCGEjIzM9mUKVNQbmVhYSGzWlbZCA8Px+1Lt23bJqaRnVqoqqpiq1evxvKio6OD4V1BFiUAa5pDQkLY8OHD8XNnZ2dWVlYmY9+6ujrm6emJuyDq6+tjRLivX7/K5CksLGSzZ8/GegrbcsMKa2UBtrMNDg5m5ubmaIOxY8eyffv2yUQSVUU73blzhy1cuJCZmJhg/UpKSpL5vCdtIo8QxX0SroLEx8dzTU1NfvbsWV5SUsLXrVvH9fX1eU1NDe+LuLi48HPnzvHi4mKen5/P3dzc+KhRo/jXr1/FPBs3bsQAHGlpaTwvL487ODhwR0dH8fOfP39yGxsb7uzszJ88ecJv3rzJjYyMeGBgoJinvLyc6+rq8h07dvCnT5/yEydOYBCQ27dvc2XjwYMHfPTo0Rh8ZOvWrWI62Ynzuro6bmZmxtesWcNzc3Pxd09JSeEvX74U7RQeHs4HDRrEk5KSeEFBAQZ9MTc3x4A0AgsWLOCTJ0/m9+/f53fv3uUWFhZ81apV4uefPn3iw4YN456enlh2L126xHV0dPjp06e5MrB//35uaGjIk5OTeUVFBb98+TIG0Tl27JhK2wnajr179/IrV65gEKHWQYJ6yib37t3D9ikiIgLbq6CgIK6hocGLioq4qqOSjoG9vT339/cXz5ubm7mJiQkPCwvjqkBtbS1WyKysLDyvr6/HCgENl8CzZ88wT05OjliZ+/fvz6urq8U8UVFRfODAgRgFDNi1axe3traWuZaHhwc6JsrEly9fuKWlJU9NTeVz584VHQOyUwu7d+/ms2bN6tB+v379wmh0kZGRYhrYTktLCxtoABpiKF8PHz4U89y6dYv369ePV1VV4fmpU6e4gYGBWL6Ea1tZWXFlwN3dna9du1YmbenSpdhZAWQn3sYx6EmbrFixAn8jKdOnT+cbNmzgqo7KTSVAhKxHjx7h8JQ0AAec5+TkMFWJSAYIEcnAHk1NTTI2geE1iFom2AReYahNGrnLxcUFIy+WlJSIeaTfIeRRNrvClApMmbS+F7JTC9euXcOd2JYvX45TSnZ2duzMmTOinSASHWzGIrUfBCqDKTtpeYIhYPgeAcgPdTE3N1fMM2fOHNwaVlqeYBrs48ePrLfj6OiI29O+ePECzwsKClh2djZzdXXFc7JTW3rSJn2lvVIEKucYdBbKsquhKZUR2Gsb5sxnzpzJbGxsMA3uGyoQVLaObNJROE/hs87ygPPQ2NjIlAHYQvTx48fiFqNSyE4tlJeXs6ioKNxVLSUlhfn5+bEtW7aw8+fPi3YCOqtj8ApOhRR1dXV0VrtS5noze/bsYStXrkQnW0NDAx0oqHswNw6QndrSkzaRV4jivohSx0oguvc0XFxcjE8uhCxv377FvcYh6IgqhVjtjnMJT2sHDhzAc+jwoExFR0fjvu5ECwkJCSwuLo5dvHiRWVtbs/z8fHQMYNEd2YnozajciIEqh2vevHkzS05OZhkZGWzEiBFiOtw3TLHU19d3aJOOwnkKn3WWB1YOw+ri3g5MFdTW1qKqAp5A4MjKysK9yeE9PE2QnRiuFp84caKM7SZMmICqFWl56KyOwSvYWgooXGC1eVfKXG8GVDvCqAFMw3l5ebHt27eLo1Fkp7b0pE3kFaK4L6JyjoEqhmuGNT7gFCQmJrL09HSUT0kBe8BQp9QmMBcHDb1gE3gtKiqSqZDwZA2dvtBJyCvk57+Fk5MT3iM82QkHPBnD0K/wnuzEcBqqtdwV5tHNzMzwPZQvaFylZQGmk2D+V1qewBEFZ0wAyibURSFADOQBaRusf5GWJysrK2ZgYMB6Ow0NDTjvLQUeSuAeAbJTW3rSJsreXikUrqJyRVjlGhsbiytc169fj3JF6Yr7voSfnx/KfzIzM/m7d+/Eo6GhQUaGBxLG9PR0lCvOmDEDj9Zyxfnz56PkESSIQ4YMaVeuGBAQgKqGkydPKq1cUUCqSgDITi1STnV1dZTjlZWV8bi4OPzdL1y4ICM5gzp19epVXlhYyBcvXtyu5MzOzg4lj9nZ2agEkUrOYDU6SM68vLxQcgb1Fq7TW2V4rfHx8eGmpqaiXBHkeSDxBfWOKtsJVD8geYYDuqDDhw/j+9evX/eoTUCuCOX44MGD2F6FhoaSXPE3KukYAKCxh44Q9jMA+SLoYfsqUPnaO2BvAwGodJs2bUKJD1SgJUuWoPMgpbKykru6uqIeGBq4nTt38qamJpk8GRkZ3NbWFu06ZswYmWv0BceA7NTC9evX0VEEB3v8+PE8JiZGxm4gOwsODsbGGfI4OTnx0tJSmTwfPnzAxhy0/SB79fX1xU5DCujYQRoJ3wGdLHQaysLnz5+x7EA7o62tjfUB9PtSCZ0q2gnaiPbaI3CketomCQkJfNy4cdhegdT6xo0bCr575YDCLhMEQRAEobprDAiCIAiC6BhyDAiCIAiCECHHgCAIgiAIEXIMCIIgCIIQIceAIAiCIAgRcgwIgiAIghAhx4AgCIIgCBFyDAiCIAiCECHHgCAIgiAIEXIMCIIgCIIQIceAIAiCIAgm8H9F7f5jl6tKqQAAAABJRU5ErkJggg==", + "image/png": "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", "text/plain": [ "
" ] @@ -717,7 +754,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 25, "id": "838cbb65-00dc-4b41-a5f1-ae7d669fbbce", "metadata": {}, "outputs": [], @@ -740,7 +777,7 @@ "id": "52525e1f-b2d0-41e2-9d10-4f49e33c2648", "metadata": {}, "source": [ - "The good part: run the model for 500 years of simulation time." + "The good part: run the model for 50 years of simulation time. Note that the run is much shorter than SSA since it is significantly more expensive" ] }, { @@ -752,48 +789,23 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "de9d43339fcb47a5afee8d95887be88c", + "model_id": "320837fece934b43be16f4fd2c223bf1", "version_major": 2, "version_minor": 0 }, "text/plain": [ - " 0%| | 0/3000 [00:00 \u001b[39m\u001b[32m21\u001b[39m momentum_solver.solve()\n\u001b[32m 22\u001b[39m α.assign(\u001b[32m0.0\u001b[39m)\n", - "\u001b[36mFile \u001b[39m\u001b[32mpetsc4py/PETSc/Log.pyx:250\u001b[39m, in \u001b[36mpetsc4py.PETSc.Log.EventDecorator.decorator.wrapped_func\u001b[39m\u001b[34m()\u001b[39m\n\u001b[32m--> \u001b[39m\u001b[32m250\u001b[39m \u001b[33m'Could not get source, probably due dynamically evaluated source code.'\u001b[39m\n", - "\u001b[36mFile \u001b[39m\u001b[32mpetsc4py/PETSc/Log.pyx:251\u001b[39m, in \u001b[36mpetsc4py.PETSc.Log.EventDecorator.decorator.wrapped_func\u001b[39m\u001b[34m()\u001b[39m\n\u001b[32m--> \u001b[39m\u001b[32m251\u001b[39m \u001b[33m'Could not get source, probably due dynamically evaluated source code.'\u001b[39m\n", - "\u001b[36mFile \u001b[39m\u001b[32m~/sw/firedrake/venv-firedrake/lib/python3.14/site-packages/firedrake/adjoint_utils/variational_solver.py:108\u001b[39m, in \u001b[36mNonlinearVariationalSolverMixin._ad_annotate_solve..wrapper\u001b[39m\u001b[34m(self, **kwargs)\u001b[39m\n\u001b[32m 107\u001b[39m \u001b[38;5;28;01mwith\u001b[39;00m stop_annotating():\n\u001b[32m--> \u001b[39m\u001b[32m108\u001b[39m out = \u001b[30;43msolve\u001b[39;49m\u001b[30;43m(\u001b[39;49m\u001b[30;43mself\u001b[39;49m\u001b[30;43m,\u001b[39;49m\u001b[30;43m \u001b[39;49m\u001b[30;43m*\u001b[39;49m\u001b[30;43m*\u001b[39;49m\u001b[30;43mkwargs\u001b[39;49m\u001b[30;43m)\u001b[39;49m\n\u001b[32m 110\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m annotate:\n", - "\u001b[36mFile \u001b[39m\u001b[32m~/sw/firedrake/venv-firedrake/lib/python3.14/site-packages/firedrake/variational_solver.py:403\u001b[39m, in \u001b[36mNonlinearVariationalSolver.solve\u001b[39m\u001b[34m(self, bounds)\u001b[39m\n\u001b[32m 402\u001b[39m problem.u.assign(problem.u_restrict)\n\u001b[32m--> \u001b[39m\u001b[32m403\u001b[39m \u001b[30;43msolving_utils\u001b[39;49m\u001b[30;43m.\u001b[39;49m\u001b[30;43mcheck_snes_convergence\u001b[39;49m\u001b[30;43m(\u001b[39;49m\u001b[30;43mself\u001b[39;49m\u001b[30;43m.\u001b[39;49m\u001b[30;43msnes\u001b[39;49m\u001b[30;43m)\u001b[39;49m\n\u001b[32m 405\u001b[39m \u001b[38;5;66;03m# Grab the comm associated with the `_problem` and call PETSc's garbage cleanup routine\u001b[39;00m\n", - "\u001b[36mFile \u001b[39m\u001b[32m~/sw/firedrake/venv-firedrake/lib/python3.14/site-packages/firedrake/solving_utils.py:129\u001b[39m, in \u001b[36mcheck_snes_convergence\u001b[39m\u001b[34m(snes)\u001b[39m\n\u001b[32m 128\u001b[39m msg = reason\n\u001b[32m--> \u001b[39m\u001b[32m129\u001b[39m \u001b[38;5;28;01mraise\u001b[39;00m ConvergenceError(\u001b[33mr\u001b[39m\u001b[33m\"\"\"\u001b[39m\u001b[33mNonlinear solve failed to converge after \u001b[39m\u001b[38;5;132;01m%d\u001b[39;00m\u001b[33m nonlinear iterations.\u001b[39m\n\u001b[32m 130\u001b[39m \u001b[33mReason:\u001b[39m\n\u001b[32m 131\u001b[39m \u001b[33m \u001b[39m\u001b[38;5;132;01m%s\u001b[39;00m\u001b[33m\"\"\"\u001b[39m % (snes.getIterationNumber(), msg))\n", - "\u001b[31mConvergenceError\u001b[39m: Nonlinear solve failed to converge after 13 nonlinear iterations.\nReason:\n DIVERGED_DTOL", - "\nDuring handling of the above exception, another exception occurred:\n", - "\u001b[31mConvergenceError\u001b[39m Traceback (most recent call last)", - "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[29]\u001b[39m\u001b[32m, line 21\u001b[39m\n\u001b[32m 17\u001b[39m \u001b[38;5;28;01mexcept\u001b[39;00m firedrake.ConvergenceError:\n\u001b[32m 18\u001b[39m α.assign(\u001b[32m0.01\u001b[39m)\n\u001b[32m 19\u001b[39m \u001b[38;5;28;01mfor\u001b[39;00m exponent \u001b[38;5;28;01min\u001b[39;00m np.linspace(\u001b[32m1.0\u001b[39m, \u001b[32m3.0\u001b[39m, num_continuation_steps):\n\u001b[32m 20\u001b[39m n.assign(exponent)\n\u001b[32m---> \u001b[39m\u001b[32m21\u001b[39m momentum_solver.solve()\n\u001b[32m 22\u001b[39m α.assign(\u001b[32m0.0\u001b[39m)\n\u001b[32m 23\u001b[39m \n\u001b[32m 24\u001b[39m hs.append(h.copy(deepcopy=\u001b[38;5;28;01mTrue\u001b[39;00m))\n", - "\u001b[36mFile \u001b[39m\u001b[32mpetsc4py/PETSc/Log.pyx:250\u001b[39m, in \u001b[36mpetsc4py.PETSc.Log.EventDecorator.decorator.wrapped_func\u001b[39m\u001b[34m()\u001b[39m\n\u001b[32m--> \u001b[39m\u001b[32m250\u001b[39m \u001b[33m'Could not get source, probably due dynamically evaluated source code.'\u001b[39m\n", - "\u001b[36mFile \u001b[39m\u001b[32mpetsc4py/PETSc/Log.pyx:251\u001b[39m, in \u001b[36mpetsc4py.PETSc.Log.EventDecorator.decorator.wrapped_func\u001b[39m\u001b[34m()\u001b[39m\n\u001b[32m--> \u001b[39m\u001b[32m251\u001b[39m \u001b[33m'Could not get source, probably due dynamically evaluated source code.'\u001b[39m\n", - "\u001b[36mFile \u001b[39m\u001b[32m~/sw/firedrake/venv-firedrake/lib/python3.14/site-packages/firedrake/adjoint_utils/variational_solver.py:108\u001b[39m, in \u001b[36mNonlinearVariationalSolverMixin._ad_annotate_solve..wrapper\u001b[39m\u001b[34m(self, **kwargs)\u001b[39m\n\u001b[32m 105\u001b[39m tape.add_block(block)\n\u001b[32m 107\u001b[39m \u001b[38;5;28;01mwith\u001b[39;00m stop_annotating():\n\u001b[32m--> \u001b[39m\u001b[32m108\u001b[39m out = \u001b[30;43msolve\u001b[39;49m\u001b[30;43m(\u001b[39;49m\u001b[30;43mself\u001b[39;49m\u001b[30;43m,\u001b[39;49m\u001b[30;43m \u001b[39;49m\u001b[30;43m*\u001b[39;49m\u001b[30;43m*\u001b[39;49m\u001b[30;43mkwargs\u001b[39;49m\u001b[30;43m)\u001b[39;49m\n\u001b[32m 110\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m annotate:\n\u001b[32m 111\u001b[39m block.add_output(\u001b[38;5;28mself\u001b[39m._ad_problem._ad_u.create_block_variable())\n", - "\u001b[36mFile \u001b[39m\u001b[32m~/sw/firedrake/venv-firedrake/lib/python3.14/site-packages/firedrake/variational_solver.py:403\u001b[39m, in \u001b[36mNonlinearVariationalSolver.solve\u001b[39m\u001b[34m(self, bounds)\u001b[39m\n\u001b[32m 401\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m problem.restrict:\n\u001b[32m 402\u001b[39m problem.u.assign(problem.u_restrict)\n\u001b[32m--> \u001b[39m\u001b[32m403\u001b[39m \u001b[30;43msolving_utils\u001b[39;49m\u001b[30;43m.\u001b[39;49m\u001b[30;43mcheck_snes_convergence\u001b[39;49m\u001b[30;43m(\u001b[39;49m\u001b[30;43mself\u001b[39;49m\u001b[30;43m.\u001b[39;49m\u001b[30;43msnes\u001b[39;49m\u001b[30;43m)\u001b[39;49m\n\u001b[32m 405\u001b[39m \u001b[38;5;66;03m# Grab the comm associated with the `_problem` and call PETSc's garbage cleanup routine\u001b[39;00m\n\u001b[32m 406\u001b[39m comm = \u001b[38;5;28mself\u001b[39m._problem.u_restrict.function_space().mesh().comm\n", - "\u001b[36mFile \u001b[39m\u001b[32m~/sw/firedrake/venv-firedrake/lib/python3.14/site-packages/firedrake/solving_utils.py:129\u001b[39m, in \u001b[36mcheck_snes_convergence\u001b[39m\u001b[34m(snes)\u001b[39m\n\u001b[32m 127\u001b[39m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[32m 128\u001b[39m msg = reason\n\u001b[32m--> \u001b[39m\u001b[32m129\u001b[39m \u001b[38;5;28;01mraise\u001b[39;00m ConvergenceError(\u001b[33mr\u001b[39m\u001b[33m\"\"\"\u001b[39m\u001b[33mNonlinear solve failed to converge after \u001b[39m\u001b[38;5;132;01m%d\u001b[39;00m\u001b[33m nonlinear iterations.\u001b[39m\n\u001b[32m 130\u001b[39m \u001b[33mReason:\u001b[39m\n\u001b[32m 131\u001b[39m \u001b[33m \u001b[39m\u001b[38;5;132;01m%s\u001b[39;00m\u001b[33m\"\"\"\u001b[39m % (snes.getIterationNumber(), msg))\n", - "\u001b[31mConvergenceError\u001b[39m: Nonlinear solve failed to converge after 41 nonlinear iterations.\nReason:\n DIVERGED_DTOL" - ] } ], "source": [ "hs = [h.copy(deepcopy=True)]\n", "us = [u.copy(deepcopy=True)]\n", "\n", - "final_time = 500.0\n", + "final_time = 50.0\n", "num_steps = int(final_time / float(dt))\n", "for step in trange(num_steps):\n", " mass_solver.advance()\n", @@ -835,7 +847,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -862,7 +874,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAg0AAAGiCAYAAABkuvUyAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjksIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvJkbTWQAAAAlwSFlzAAAPYQAAD2EBqD+naQAAlWhJREFUeJztnQeUFFXWx//dPXmGGeLADAw55yAiiiJKUsSw6q45i+uiq+KnyC5iXDGsObGuec3uKiYkKioSRHLOOaeZYfJMd33nvaGa6p7q6krdXeH+zqkz092V6713/3Xvfe95BEEQQBAEQRAEEQVvtBUIgiAIgiBINBAEQRAEoRryNBAEQRAEoQoSDQRBEARBqIJEA0EQBEEQqiDRQBAEQRCEKkg0EARBEAShChINBEEQBEGogkQDQRAEQRCqINFAEARBEETiRcPPP/+M0aNHIz8/Hx6PB1OnTg35nY1gPWnSJOTl5SE9PR1Dhw7Fpk2bQtY5evQorr76amRnZ6N+/fq4+eabUVJSErLOypUrceaZZyItLQ0FBQV4+umn65zL559/js6dO/N1evTogWnTpsXoqgmCIAjCmcRUNJSWlqJXr1549dVXZX9nxv2ll17ClClTsGjRImRmZmLEiBGoqKgIrsMEw5o1azBr1ix8++23XIiMGTMm+HtxcTGGDx+OVq1aYcmSJXjmmWfw8MMP44033giuM3/+fFx55ZVccCxbtgwXX3wxX1avXh3LyycIgiAIZyHECXaoL7/8Mvg5EAgIzZo1E5555pngd4WFhUJqaqrw8ccf889r167l2y1evDi4zvfffy94PB5hz549/PNrr70mNGjQQKisrAyuM378eKFTp07Bz3/84x+FUaNGhZzPgAEDhNtuuy1GV0sQBEEQziMpUWJl27Zt2L9/Pw9JiOTk5GDAgAFYsGABrrjiCv6XhSROOeWU4Dpsfa/Xyz0Tl1xyCV/nrLPOQkpKSnAd5q146qmncOzYMTRo0ICvM27cuJDjs3XCwyVSKisr+SISCAR4qKRRo0Y81EIQBEHYC/b+evz4cR4yZ3YkVlRUVKCqqsrwfphdYyF1K5Ew0cAEA6Np06Yh37PP4m/sb25ubsjvSUlJaNiwYcg6bdq0qbMP8TcmGthfpePIMXnyZDzyyCOGrpEgCIKwHrt27UKLFi1iJhjatMrC/oN+w/tq1qwZf8G2knBImGiwOhMmTAjxThQVFaFly5a8sLGkTKdzccMbE30KBEHEkalH33H8/WY5cCxZvl69ejE7RlVVFRcM25a0QnY9/d6M4uMBtOm3g++PRMMJBcU4cOAA7z0hwj737t07uM7BgwdDbmRNTQ0PE4jbs79sGyni52jriL/LkZqaypdwmGBwsmgYnnwF/5vkSU70qRAEEUcuazQGM6s/ccU9j0eIObue15BosCoJuyIWUmBGe86cOSEqkOUqDBw4kH9mfwsLC3mvCJEffviB5xew3AdxHdajorq6OrgO62nRqVMnHpoQ15EeR1xHPA4RKhgIgnAn1AaYh18IGF6sSEzDE2w8hc2bNwc/s9jM8uXLeU4Cc/XffffdePzxx9GhQwcuIh588EGeoMK6QzK6dOmCkSNH4tZbb+XdMpkwuOOOO3iSJFuPcdVVV/HcA9adcvz48bwb5Ysvvojnn38+eNy77roLgwcPxrPPPotRo0bhk08+we+//x7SLdPNUEPhHISAAI/Xw/9qhW1HEGJ74BavQ6wIQOCLke2tiId1oYjVzufOnYshQ4bU+f7666/Hu+++yzNZH3roIW68mUdh0KBBeO2119CxY8fguiwUwYTCN998w7NdL730Uj62Q1ZWVsjgTmPHjsXixYvRuHFj3HnnnVxAhA/uNHHiRGzfvp2LFDZGxPnnn6/6WpgXhPXuYLkNTgpPkGCwF3rEQLwg0eE8nCYc4tGOF584xt4NLQznNOR32m05mxNT0eAknCgaSDBYEysLA6OQsLAfThIOJBqMQ70nXAiJBevgZIGg5XpJTFgXClfowy8IfNGLkW1jifNSOwlFSDAk1mCGLwTdG7tAbYc2xJwGI4sVIdHgIqjSxxcSCObePxJaiYfaEILCEy6BKnvsIc9B/O8zhTXiD4Ur1ME8BX4H9p4g0eBwSCzEFhIK1rr/JCLi27Y4KUnSbAIO7XJJ4QkHQ4IhtoaKBIP1oHBGfKE2xn2QaHAoVJnNJTymToLBPlAuRGyhtka594SRxYqQaHAgVInNgZLvnAU9z9hBbU5dAiYsVoRyGhwEVVzjkAfBHVAypflQgqQ7IE+DQyDBoB96A3U3FL4wF2qLamE9J4wuVoREgwOgSqoPMhaEXHkgbxO1SWbgF4wvVoREg80hwaAdMgwElZHY4/a2KeDQnAYSDTbG7ZVSC/QWSVC5iT/URsWPn3/+GaNHj0Z+fj48Hg+mTp0a8jubm3LSpEnIy8tDeno6hg4dik2bNmk+DokGm0KVUR3kVSDMgsqSPtzaVgXggd/AwrbXQmlpKXr16oVXX31V9venn34aL730EqZMmYJFixYhMzMTI0aMQEVFhabjUO8JG+LWSqgFiksTsS5bNPqketw4emRAqF2MbC9O5y0lNTWVL+Gcd955fJGDeRleeOEFTJw4ERdddBH/7v3330fTpk25R+KKK9TbFPI02AwSDMrQ2yARL6isaW+7qP3STkFBAXJycoLL5MmTNe9j27Zt2L9/Pw9JiLB9DRgwAAsWLNC0L/I02AiqcJEhzwKRKMjzoA23eB38J8IMRrZn7Nq1C9nZ2cHv5bwM0WCCgcE8C1LYZ/E3tZBosAEkFiJDYoGwCiQe1OMG4eA3STQwwSAVDYmGwhMWhwSDPOQaJqwKlU11UNsWP5o1a8b/HjhwIOR79ln8TS0kGiwMVaq6UINM2AUqq+5u4wKCx/BiFm3atOHiYM6cOcHvWIIl60UxcOBATfui8IRFcXJl0gOFIQi7QmELd4Yq/CaFJ9RSUlKCzZs3hyQ/Ll++HA0bNkTLli1x99134/HHH0eHDh24iHjwwQf5mA4XX3yxpuOQaCAsDwkGwgmQeHCfcIgnv//+O4YMGRL8PG7cOP73+uuvx7vvvov777+fj+UwZswYFBYWYtCgQZg+fTrS0tI0HYdEgwUhL0MtJBYIJ0LiwR344eWL/u21cfbZZ/PxGCLBRol89NFH+WIEymmwGCQYKBZMuAMSxc5u+wSD+QxseytCosFCOK3S6IEaUsJNULKkc9tAv8FhpI3kQ8QSEg0WwUmVRQ/UeBJuhsr/SdzeFlodEg0WwO2VhLwLNkaw6gS+9oTqgnPaRL/gNbxYEWuelYtwQuXQC71dxfTmOuMYLoTqhTPaxgCfqdJrYKHwBOGwSmEEeqNSfaMSs20s9822JcGh4jYZmCLRIbi5jbQq5GlIEG6tDPQWpeumJWbbWOyTxILG2yW4XjzYta30UyIk4fZKYBRXvzkZNZZWMdRWOQ+X4eq6Y9M20085DYRbC79RXPm2JLrgpa54uwuHRB5f7n66DNfVoTDc2HZaEQpPxBE3FnpXNXRqjJpdhUOiBYPcdy4UEK4U4DZtQwM8EdLYYkVoGGkiZriicdNjtMRtPDo1u5Ht2bZat7OaYFBaR+89tWHd8nitaVSIWgIGh5EOwJrtpztqmAWwk0I2A8cLhkS7+41sr+UNPR7HMHN7F3kg3Op1cFtbajUSLhpat27NJ9IIX8aOHRuchCP8tz//+c8h+9i5cydGjRqFjIwM5Obm4r777kNNTU3IOnPnzkXfvn2RmpqK9u3b81m/4oWbCrmjGzKzcxTM2EcsvQBGBIMRzDL4LhEQjq1vNm9T/Q5NhEx4eGLx4sXw+0/O57V69WoMGzYMl19+efC7W2+9NWRmLiYORNi2TDA0a9YM8+fPx759+3DdddchOTkZTzzxRHBecbYOExsffvgh5syZg1tuuQV5eXkYMWIE3F64zcKxjVesjY6ekIFZ20fa1u6CIdJ+HRq+cGO4wurTaQdODNKkf3trtqcJFw1NmjQJ+fzkk0+iXbt2GDx4cIhIYKJAjpkzZ2Lt2rWYPXs2mjZtit69e+Oxxx7D+PHj8fDDDyMlJQVTpkxBmzZt8Oyzz/JtunTpgnnz5uH555+PqWggwWBj4v12aiXh4DTBEOkYDhMQJByshV/w8MXI9lbEUrWmqqoKH3zwAW666SYehhBh3oHGjRuje/fumDBhAsrKyoK/LViwAD169OCCQYQJgeLiYqxZsya4ztChQ0OOxdZh30eisrKS70O6aMEtgsGR4YhEubOtEKpwsmCQO6bDQheOrI9RcEtbaxUS7mmQMnXqVBQWFuKGG24IfnfVVVehVatWyM/Px8qVK7kHYcOGDfjiiy/47/v37w8RDAzxM/tNaR0mBMrLy5Genl7nXCZPnoxHHnkkJtfpFBzZOCXaiCTa4xDP7cza3igODF240etgNfwGe0/4KTwRnbfeegvnnXceFwgiY8aMCf7PPAosD+Hcc8/Fli1beBgjVjCPxrhx44KfmcAoKChQta0blK8jBYNoOOxuxBJ9/nY8TwcJBjcKByvmNwQEL1/0b2/NNtYyNWXHjh08L4ElKCoxYMAA/nfz5s38L8t1OHDgQMg64mcxDyLSOtnZ2bJeBgbrZcF+ly5qIMFAONKoErbEseLepW2vFbCMaHjnnXd4d0nWy0GJ5cuX87/M48AYOHAgVq1ahYMHDwbXmTVrFjfyXbt2Da7DekxIYeuw783EDYXWTY0QQTgBN9VZK7XB/hPhCSOLFbHEWQUCAS4arr/+eiQlnUyzYCEI1hNiyZIl2L59O77++mvenfKss85Cz549+TrDhw/n4uDaa6/FihUrMGPGDEycOJGP88C8BQzW1XLr1q24//77sX79erz22mv47LPPcM899yTsmu2ImxofgnASbqq7VhEOAUkPCj2LVf2MlhANLCzBBmhivSaksO6S7DcmDDp37ox7770Xl156Kb755pvgOj6fD99++y3/yzwH11xzDRcW0nEdWHfL7777jnsXevXqxbtevvnmm6Z2t7RKQY0FbszIJginhYuoHhNm4BEEi2ZbWAyWCJmTk4OioqI6+Q1OFwyOQW3PApsbB0IH0cqFw3pYuCFBUi4xUqkdN4viE8d4fWl/pGfp76BYXlKD2/sujum56sEZNSCBkGCwGSQICCozznoZsGjb7HfoMNLWPCsi4Ti6USHhQFBZcXYdJ2IGiQYbK9lY4YrGhIQDQWXE8XU9kW10AB7DixUh0aATEgwOwIHDCBMmkajRMRMACYfY4KfwBCFCgsGCxHKKaMI9GBGSNi5HJBzMx0/jNBBOxhGNBgkHgsqPu9sAIuZQeEIjFze8EU7DUY0FCQciVuUmUndLG3sYHN0WJNhDHGADNBlcrIilZrkk4o8jG4lI4zGomYxK3NZBhoCIIQ4sJ06e6CqeL30Bg0NBs+2tiDXPiogLjhQMIuRxIBJRxtQOEmVxHN02EIYgT4NLsV2jEG00RznvgNoRIAlCT3mMxzYJxMkeh3hgfGpsa7ZdJBoI+6BHBNhdODgxVCI+D7telwsEgwgJB/344eGLke2tiI1bU8I1XgYzGmybNtocO4sep12LUcFg9+snXA95GlyGbQWD9I1br/fA7sLBzufvBIPpIg+DFPI26CNA4QnC7thWMDgh7GCGS97OwsHgs/L4fBD8ftgKuz4rGUg4aMdvMMRg1dJuo1aXcLxg0NrIWr1RZoZSXMSvfD5j12gnoWSiYAjux8rXLz03B3olbNGGEDGHwhMuwFaVXasHQbq+Vd7Eo5y/4bdmOyUSmiUYIu3TivdAr2CwsiA6AXkc1EPhCcKW2EowiEbfiHBIFBqPLxpDw+LBikbTpPEKVHllrCaglM7DISNKknDQNmGVXoxsG0vI00BYEzkhoGQkEykcDBzXFK+D1YxOLLwLWo6ZqPvhwJBEJEg4REcwOL01296KWFPKEO7zMtgtx0GSr2B0ABxdRjL8XNwsGOT2YaV74jDBQLgb8jQ4FNsLBiuFHqREOBcmHIzcc0d4HBIsGOqIN6uFLvQmuFqtDpyAvA3KUHiCsA2WFwxKjaBVh4NWcXy7CIdIxtmU5EyrCIbQH60jHvR4zxJd9hUg4RAZozNV0iyXRFywvGCQGjc7JDtqTXBMoHDwZWbwv/6SEl1GWGkbxXOysmAIXTFx4kGPJ8gKIkcFJBzcBYUniMShVzjEqzHVaQzjIRxEgSD7W1YWAuXluo8f6Zzk8GZkAMLJa/WXlpmyX9Xb68knSYR4cKhgECHhUBe/wamxjWwbS0g0OAhbeBnMEA5xwojxN0M4MJh4UBIIkWDGPFCmzYDrOUY4kc41XEyYkvBoIAG1dluLjDIZXv5prgpHEKDwBGFlbCcYlOaSsEJSXwKFgzcrK/QLnYZNNOqxEA9ygkEJqZjwZGZAqKhEoKQkgYLBolik3OuBvA3ugDwNhDWwcMKXUeHAiLZ9HaEg3Qczshrd/rH0OmgVDOHXInfNagWE4e6tJBhiCgmHkwTg5YtejGwbS0g0OADbeRlcJhyk20sbVSWhYEXhYEQshAuGOvuOIiC0GKNIz4kEQ3wg4VCLX/DwRS9Gto0lJBpsjq0Fg1W7V2oUDmobSXF7LWLBKsIhloKhzrHC7o+RMEbw+DLPxzL5DJFCEhatB4S7IdFgYywnGMwy+PHoJaFi/8yohCfsmZanoJNECId4CgY5fE1z+TXrFQ+6PQzxyK2xcQ6DEuRtACVCEoTK1uLk/0YERDwaa51GQa1wiCQUjBp+0Qjr3YcW4ZBowZCwHAh6yzeM24WDIHj5TJdGtrci5GmwKZbzMjDCjbAduo7FQDio8SoYFQ5G96FGOJiV8BiLfYj3WEk82FowaD0HsQxb4dwJjh8evujFyLaxhESDDbGkYIhmhCONtW+F7pUGhIP0eWgNQRj1GMRSOCRSMOjJfwgXD7YWDGqQK68WPHe3exucCIkGIjFG2GpvRgbEiy8rE/AamB7bhHCFEeHQNnsfuhccQ/92h1Bd44Xfk4zjFSknFun/tUvxib/Vfl9CBYOcePBkpMN/8JDOg1ukLEZCqXxa+NzdKhwCgrH5I6z6bkiiwWZY2sugxwgn2stgQDhI38aZsRLKym0jHLJSq3Bau30Y3m07erY4rOuYFdU+Lh72F2WgsCwVm47lYtOhRth4qBHKqlI078+w4MhI199LxKpGV015tOq5u5yAwZwGI9vGEhINNsJSgkFNTwkrhB60ouKcI7nurSAcUiqL0bZJEXKzy9GkXhkyU2uQmVoV/JvcMgWNPSVo5Tsa3K5a8OLnmo7Y/BNQ4s9EekoNslKrUS+tKrhkn/ibdeKvzwukJfuRlsyOU3vNZ2Iv/8uK6e7CHKw/2AgbDzbmf7cfbQB/wBtzwaBrNMxI5TiRZVftsW0iGNzqbXAiCRcNDz/8MB555JGQ7zp16oT169fz/ysqKnDvvffik08+QWVlJUaMGIHXXnsNTZs2Da6/c+dO3H777fjxxx+RlZWF66+/HpMnT0ZS0snLmzt3LsaNG4c1a9agoKAAEydOxA033BDHK3UgkfIU7CIcIgmfCOesJs4fT+GQ5PWjTcNCdGhyBB1zj6B1xxK08xxEkkfgQiDZo3zfl9S0xBJ/K3xa1R8HhWzgVOXjNX9rVe05QuDCQhQUuY39yM8pRofGR/l55GWXoGWDIr4M77SVb1NZ48Pmww2x4YSQWLczGweOs/vpMV0wqBEPwTEabGJ0ZbHZubtNOATg4YuR7bXg9/u5Pf3ggw+wf/9+5OfncxvHbJ3H43GOaGB069YNs2fPDn6WGvt77rkH3333HT7//HPk5OTgjjvuwB/+8Af8+uuvwRs1atQoNGvWDPPnz8e+fftw3XXXITk5GU888QRfZ9u2bXydP//5z/jwww8xZ84c3HLLLcjLy+MixA5YysugNDCT9Helda3OiXMWx2rQkhgYG+EgoElWGTrnHkbnpof433ZNjyHVU3eAosNCJvYG6mO7vxGOC2koQRqOC6m1/wtpKBLSsSHQFIVCpqbz2nNzjzrfNb5gN36c0SL4ueX7m5GTVoGO7DxzmZg5jE5NjnBx0a3ZIb6IoY3DJen4dUdrzN3SFtuPNYDZgiGqeLCZ0Q0h2rnboeeSw/HHeUTIp556Cq+//jree+89blN///133Hjjjdxu/vWvf4WjRAMTCczoh1NUVIS33noLH330Ec455xz+3TvvvIMuXbpg4cKFOO200zBz5kysXbuWiw7mfejduzcee+wxjB8/nquulJQUTJkyBW3atMGzzz7L98G2nzdvHp5//nnbiAZLoiQG5LwQNhUOenoSmCEcMpKrcHreZvRodQS9Ox5Erqdu98IiIQ2rA82xOpDPlzWBfBxANnJH7OG/H/72pEE3GyYYwtl5XXv+t9YnUUvL9zahec7xk0KiCRM+R9CiQQn+1GA1/tR7NbYdbYAfN7fB3C1tcKg0y1TBIEV8lv6SUtgWORFgk1El3eZtiCfspfmiiy7iL8iM1q1b4+OPP8Zvv/1m6nEsIRo2bdrEXSlpaWkYOHAgDy20bNkSS5YsQXV1NYYOHRpct3Pnzvy3BQsWcNHA/vbo0SMkXMGEAAtXsFBEnz59+DrSfYjr3H333RHPiYVC2CJSXFyMRGE5L4PdEx5VomdKajmjpkU8pPhqcGrL3Ti73Tac0mpPiCeBhRw2CE2xMtACywMF/O8ugb2hexQNeyyEg5xgiMTO6zpgJ4AFEm9EWmqAX+dZbbfj1ILdaNPwGNqcegw3nboUq/bl4sfN7fDL9lYoqUzVJBgEFWLAk54GnyDUma7bFogiwIb1yW3CIWBSImS47UlNTeVLOKeffjreeOMNbNy4ER07dsSKFSv4y/Fzzz0HR4mGAQMG4N133+V5DCy0wPIbzjzzTKxevZrHZZinoH79+iHbMIHAfmOwv1LBIP4u/qa0DnsY5eXlSE+v2wAx4RKea5EILC0Y7OxF0CAWmJFhCOUVEbdhxsrDul7q8Dp4PQH0zt+HIe234rT2u5HlqQr+tiXQGL+1zMe0Lf2wNpCHCmjvlWCmcNAiFuTIHbEbFSPSsHNmC2xER3wAoOuH63FGmx0Y0m4beuTtR4+8g3y5/fRFWLyrOX7c0haL1jVCld+ny7sg9yylz9lW4kFLPbOYl8FtBFhOg5EulydeBlgOnpSHHnqIe9HDeeCBB7hNYy/WPp+Ph+7/8Y9/4Oqrr4ajRMN5550X/L9nz55cRLRq1QqfffaZrDGPFxMmTOCJkyLsYYQ/PMIBwiEsGVLJu8AMjpJwUKKucBDQvtFRnNN+C87svhONPSffkPcIOfje3x3T/D24ZyG37R6gLVAxQ7tgMFM4mCEY5Fj7x85Yi86Y8cE2NM4sxeC227iAatfoGE5vvYsvR09Lw+xN7fDVmi44WpZhWDBIYc+8jnCwY1m2kWBwi7fBDHbt2oXs7OzgZzkvA4PZTJazx8L5LKdh+fLl3JvOvPisc4BjREM4zKvAXCubN2/GsGHDUFVVhcLCwhBvw4EDB4I5EOxveMyG/S7+Jv4Vv5Ouwx5EJGESyQXkOi+DlkGY7CocNIQijAqH9JpinNNlPc4buAXtvCfHRzgqZGC6vxsXCsuFFhDglTW6ByVJh/EUDrESDFJ2XtOGhzGWojv+98E2tKx/DEPab8PQDlvQOLMMf+y9Bhd3X4fv13fE5yu644hK8RBJLEixpdfBpoLBLQgGe0+w7RnMTklFQyTuu+8+7m244oor+GcWtt+xYwf3mjtaNJSUlGDLli249tpr0a9fP94LgvV2uPTSS/nvGzZs4F0sWe4Dg/1lLpiDBw8iNzeXfzdr1ix+k7t27RpcZ9q0aSHHYeuI+yBMHLbWhsJBa+6CHuGQmVKFC7utx0X91iMLlfB5BFQISfgh0Anf+nvi10B71KDuCItWEA7xEAzyAqIN5qEv3v9gK04t2IXLe63mvS8u6r4e53XeiOkbOuCz5T0UxYOcYFAKFcl6HeyEjQSD070NAcFgeELjtmVlZfCGjUzLwhSBgLntccJFw//93/9h9OjRPCSxd+9eHq9hF3rllVfyriI333wzDxM0bNiQC4E777yTG3uWBMkYPnw4FwdMZDz99NM8f4H1Sx07dmzQU8C6Wr7yyiu4//77cdNNN+GHH37grhzWldOqWMLLoLWHhLi+jYSDNzX6WygzMuGxdLXCISulkr8dj+67Adme2sTaHen18WHxaZjq741SRD9+JCOsVzxoEQ6JEAxSmgzbg7Jhqfh85mAs+qAFeufvx9X9VqB7s4O4sNsGnNd5E75f34F7Hg6XZmr2MMjha5AD/9FjcJRgsMlcFU4iEOcRIZkdZS/QrKMAC08sW7aMJ0Eym+co0bB7924uEI4cOYImTZpg0KBBvDsl+5/BukUy9cQ8DdLBnUSYwPj22295bwkmJjIzM7kr5tFHHw2uw7pbMoHAxnx48cUX0aJFC7z55puW7W5pGcEgokUE2FEspCQDVdWa96EkHLJSK/GHHmsxuveGYGLjpkATTKkZjGWDchDweFE6S59RM8ProEY4GBEMRsWCKBik7LymHXaiHZZ/0Ay9mHjou4InTIriYfr6Dvh0flscLsnQLRh4WZCUj0ClvlBU3JEKABsNPe10b0M8efnll/Hggw/iL3/5C/e8s1yG2267DZMmTTL1OB5BECxmoawJS4Rkno8hvj8gyVPbsLhGNNhMEGj1LngyT3gRFISDUta+KBxY7wk5scAGUnq9ejBmBzrzXIUmw0ON4aFZzRXPN3e4sgGWEw5qjXYk4aBFMIQfX82xD85soVowHJopf39afrAFPfMO4Jp+TDzU5iyVVSVh6qrO+GxZN1TWyL8TRQxPnBAMQmno77YRDmqxiGCQEi/hUCNU40f/F3wMIDV5AkZsxUUzb0Jypv7k5erSKnw1/O2YnqstPQ2ETQQDw0ZhBy3hCGYkuHAw4HFIqirFhT3W4MoBq4JiYX2gKV6tPhs/BjqFJDYyIygVDsxARhMO8fQ4JNLDEO5dUEL0PKz8oBnvqnn9Kct4zsNV/VZjSIftePnnU7Fsd566nZ0QDJHKjGOEgwUFg1MJxHkY6XhBooFwjXBQk7+gRzh0zzuAv4xehlaeI2AvTJHEghJWEQ52EQxSdl7TFjvRFqs+aIrTW27Hbacv4fNfPHHBD5i1oS3+Pb8vjkcYJCqaYHCUcLCwYKAwhX0g0WAhLO1lsLtw0NJgikYkinhgPSJuOm0Zzu+6mX8+nJKBZ0uG4xt/T9ViId7CYU7Xb+R/6Ar0evp2Q8dOhGAQaTR8L3YF2uFTtMOyT/Jw3akrcGH3DRjWaSv6t9yDKfNOwU9bWkEoq9AsGEKEQ1WV/cq+xQWDUwnEufdEvCDRQOib5MYuwkF6HcwNoEWYSbwOoT0oBAxquwtjhi5DE2/tfBCfVffD86VDkTzyGISZ+htoo8JhxT2votfzYyOLA6Vt73896jrnrh1tScEgZeMVXTERXfHT1Pm4a/AitG5YhAeG/YohHbfhlZk9cYjPrikvGMLzGUIQ4+52Kfs2EwxO8zYESDQQrvIyqJkAx+qNp1xjGUE4BPMaooQr2CBDfxm0GAPb1BrKbYFGeLhyNJYEWvPPDXEsaMSOzMyPuXCY1fUrWeEAHZ4ONciJkQBOloFhay9KqGCQMmv46dj8YUP8sc9aXNF3NQa02ovu1x3EGz/1xIyNtRNrqSbcmFm97OsRDJGmiicICeRpILQ1hHZoKBlKjZ8uj0MVRnTejFsGL+OJjmzyqDerB+Hf1WeiCskRDZrZwkFOJFiJ8PNTEhFGBIOSWJCy7erOeAqd8cvnLbnXoVveIdx57jL0bXMIz//QHxXVyaoFQ6Di5AR2thAOWmbDtAhO8jYEyNNAuMLLYPWG0IBgYI2+Ny1Vs3BIT67GuJGLMbDdHiR5BCz3t8BDlRdii1A7AqkSRoXDjK5fwGfjt79IIiIegkHK/NGnYPd/snF5r1W49tTVGNxhF1o3KsJj087A7kKF7mzRDJiV64vW87JxObMiARINhGuwckNoZsOnQji0qF+MCVcuRjvfYVR5vHipcgj3MAQ0uP/1CAcmFpyIKCL8QgAj1v4hLoKBUX/EPhSPqIfnpl2KlV/m4u8j56NVw2K8+MdZeHb2AMzfKpNAqvaN1871xYKCwUneBidinZLiUizlZbBoIxLTc5Y0TuFJcGe03Y0Xrp7DBcOBQD3c2eNCfHZOB02CQauxY2LBqYLB6LUaEQyMomm1YzbMHn4m7vxsGFbuaYLMlBpMOv9X3DhwJTxlpREFQ53QhBPqixPO3cIIkrEa9CwWtQyU00A45A1KZcMXEqKI4HHweQPciFzWZwP//HtNK/xf+eU4Mi8LOefv40aocIbKQYNUeBzcIhIiIb3+SN6HaILh6PR8RcEQzurL+mLCB6m4aeAKXNpnI/7Ubx06NjqEJ77uh+LKNOfXF4sLBid4GwIODU9Ys8S4BMt6GWzQqJh+jicaqIYZ5XjyorlBwfBu5UDcWnYdjghZqoxRJOMlZ/zc5FVQi9w9MephiMTOa7rh37/2wRPTB6K8Kgl9Wh/GP6/6Ffn1a7vR6sIO9cWO52pj0RAwsFgR6j1BOPMNSgfNG5ViwvWr0MF3CCVCCiaWX4w5NbXTq8uh1+Ow9O6XDZ6p8xGFA0sCPWfNJaYLBpE913XBx+iCHf/Nxj9G/4RWjUvw7FXz8PfPB2LroRw4tr7YQDA4wdvgRKxfcojYwBq18MWGjYw3PZ2HG+qEHDTSosFxPHnTInTwHcThQCauKB2jKBi0GifGrK7/4wvDzj0i4oV4j8R7phYtz0Rk4XkDMfb9wdh8IAcNMyvxzBXz0K35EXX5DHJY+fla+dwcRMChngYqPQnCkqEJOSGhVlQkai4JyX0UxUM0ARFuBAoaHsfkm35DrrcEm/y5uP60y7Aj0Ng0IyUVCyKs9wAziiQe6iK9L+w+RbqHWp6FmAQpR/Z5+/nf9VcNxH2fnIFVuxohK60GT1y+AP3b1M6eqRWjIjahgsEGdd8OBEg0EI7C5m8bIZNPyQgwtQKibW4Rnr5xIRcMG2tycevx61GYnB40JGqNTyRjpcbQRRMOouF0CkrXE+1eKIkHPR6G8Oe89bpT8ff/noZFW5oiLdmPhy9ZhCHd1OVUhJS5gKBugjQ7vBwksK2w5MuVy7G35bAplqkINhUOso2xwj2VNuZSEdE57yieunYhGnrLsKYmD7eWXI9jQmbw90jCIRJSo6X2zViEPA7a7kH4/TUiGEq+bRby/Y4b+uORqadiztoWSPIJ+L8LV+HcHntVl6sQ75fVhAMN+BS/Wy14DC9WhBIh3U68k7YMDm2r2AizxlpF4hRr4Ds33o9Hr1qBbG8Flla3xJ0lV6EEaUEjknXB/qBhKf4+1KgowYyX1hi81GjG0quwvEp5aufeKYkzcHpFE7vXw9ZeqmkbNWJwz0398MybHlRUAKP67sZ9F65EZbUX87e3Ut5Qzutl12m1LfJSYdeEyMCJ8RaMbG9FSDQQic/2NnOMfBXCoUPTY3j82uWo56nE4upWuLPkapQjJeL6aoXDrG6f154Cd+F5EiIcVlZVoWdKSlSBIIeabWIhLIx6WWZ0/S//O2zN5VHX1eI92ndLX7z0JuBN8uK8njsx4ZKVePB/GVi+s4n8BkreLr3CIfzexKueWkQwENaDSoZbQxOJaiTUNnrsfKQLMy4NG6jbVuEet25cjMevWRwUDGNLrlEUDHLGRi6vQRQMiTCiTCiIi/h5aUWUN2KdMGEhXd4ubhpybK2YGZaJ9AzE56U13MTYz4TDzN74ZUMeUpICPMehU7NjdVc0Wq/Dy7uk3AdxsWCwbLupACVCEs7HasJBgi+rdnAlNn21dImITCNTL60KD1+/BPW95VhZ0xx/LbkKlRFmqJQjktExUzCoNabhQkGOWAmHSPtXc06xzuOI9CwiPbvwfAY59t7cF0991w9LtzdBeoofj1+2AC0bFZ9cQaVBY94GHl6LJg7kcFgyrBsQHJrTYD1J6WBsoZYtKBx8mRm1/1RV1/ktXESECImQ+y1gzG07kOctxg5/Q/yl5BqUIXLPikjGRGp8mIGKhWCQ63ooNcha3upjIRzYPqPtV+l8Y93VNPy56PEwhLPrxlN4cuT6vfWRnV7Nu2M2yiqPKhjqlM9kHRHhROccEYQEKiFE4tDTGMoIh3BCGun02hj8GX8JYHjKWlQLXjxQeimOCwpeiigwIxRLsSBlWVUNVlYbMxpmCge9+xLFw7vF2kfQ1IvZz2j79f0x8X8DseNwFprUq8AjlyxCalJNyDqKnrATZTcogtVAgsFeL10SKDxB2JNofbLl+mbH820jSqMo28CqEA5S2o7NwqTMb1Ht8eLfrftjrb85jPBD9891JzpqEQtsMcvwmyEczDqH8GuLhJqE0IDCXIDsGc3pVpskqTc0Ec6mawbgwS9OQ1FZCjo0K8Jdo9bAk5kWPVymscxySDDYGoHCE4SjVXIiR4CLcDzFNzKVjfCprffixfRP+P/Tm3TEx8178e6U4qKEnFFhgkFESTgoGTMlo6hkUBMpHGJxbLXiQQ/SZyN9ZkZhZWbLe+3x+PQz4A94cG7nHRjdY7PyRjJlNaq3wQqCwWYjxFpRNAQMLJTTQLgOj8+X0FDFaW324MFRvyLF48fM6i6YtPlyBMIaSKmAiCYi5IyPWR4HtQY0EcIh1sc0WzzIPRO9wkGufLDut6v25uKt+b3459sGLUOXZoc1l9GIwiERot0mosDyL18ugHIanIwFxl5gwkFpiXS+quO+ERrlggbF+Nv5C5DsCWB6dTeML78MNfBFHW8hkoBQMjpGhIMegxlP4RDPY5khHpSeBXuGasSDkogUyw+bHfOL5R3x06YCPmrk30fOR4OM8riHJDQJcyKuCNzbYGCx6PMi0RAHXKeOTwgGNdddR0h4PVwweDLS+aKKOo2zgBv+tJF7GObVtMcD5X/ggkFE7QiPzGioNTR6hIORBEc1PRiibW/GOrHYngmHt4q0552ofQbseUpDT2q9TeHlZs91XfH8D/2x40g2GmeVY8KIBfB5A5oEQ4g4lhEMmkR3vLGoN8JqI0IGDCxWhESDU7FzhfacrCyieAhf6iBppNvf5MMZSVtQJfjwj/Lz4ZcIBhEtQ0ObbbSYWBAFw9Jya+YpGN2voe1P3BPpfYqWN6JVtP32wMuqQlLRysuWK3vise/PQGlVEno2P4Rr+q/R5GFgZTmpSSMulvWIAi7MXdZN0nUvYRbDXaWNiD1hDZjWCu7NqH3zEsqVh9yVFRNJSUjx1eDhtK/5Ou9XDcRuoWHEfUQTDnri4FLjJZcMKWcErSYcEpowKXMvonlk9IaH1D7faOVk0YUD8NzsAfz/y/uuQ/fmdfMblMRvtLJuaeNp55eTGCNQ7wnCthXbpvdAe2MqYMytG9HYW4ptGQ3w6eAOyDl/H1+0GgQjGfdyRizaW7NVhIPVBEO0+xfrrq9qPVK/bm2BGWvb8PyGu0csQ0q9FGXPWFgZF8Wy7jpF3gbLETDYe4ItVoQmrHIiiVL/Cg2Xmpnq5BpO1qiKAzRFY+hNh3BB0irUCB78s90glCednFNCTjiIcxIwwyAdNdCMLnrMmImeBrW5C8xo9k3fYcho901T3v7jPf3lv0ft91c2X6z72GYKhkj3gd3Lnsle0wQDe9bnrL5cl2CQlqmS8+vjjZtOwSmt9qNF/eO4qt8qvPdbb8QCehEhEgmJhhhClducKW7VCIf+LffgnuS5/P+nqkZiRU5+1P1KG32xT7SZffqZUYsmGJhxlBpMs4RDJHEQjWjbyYmKWHoYogkHM5ATDuGCQclbxSickYfCP+Xh1V8OYNLIn3FZr7X4eUsrbDvSQLUnjYnmQFmZ/jYlUbPVsmO6zNOhBrEXhF6MbBtLSDQ4DQt6GdQIB63uWSn5OcW477wFfEbsz6r74eOaU4EZHtQfodzQS/F4hBPDDpvjEpQmOmoVAaIR1bqdaPCZ12D3sfpo0aBQ0/ZajiEiHke3h0JHWKZ2m9p7Y5Z4kAoHVhaiiYRwwSCyYHsB5m0pwKB2u3D34IW458sRCAhe1aE3JeFALyHmvITEC8HgAE00uBNBRHhbUiMYlPIbLr98K5/qeom/JZ6oOi9o+KWNeTznKZB6F8I9CVqQbtcrbVdEIy4u4TCDHkuk+1c6DynidbBr0y8YTmJ0Xo5w4cAEgxbCy9iuazvgtV/7o6QyGR1zj+LCHhvqbKMn8VG1YEjUGz8lRLoG8ikRxvF4a7uMnVjUoOetSa6xbZ5TjOG+Nfz/f1Sej5ow55kW4aB2+GclIhkxM4SDVgMdK+HA9qm032jnZua9MFM4sGevRTxGKlsrL+2JNxf05f9f338FmtYr0SQYwkU0eRjsiUC9JwjL95qwiNqXCgilheHLbQJPVqbqfYc3uhdctpOHJX6o6YSNgnziWjThEG4o9AqHaMbLqLFUKxRiKRy07EtO3JgtGMwSDlqfebQyNWN9O6zY0xRpyX6MPfM33rMnph6GE4jjPRCJJ+DQ3hMJ9zRMnjwZ/fv3R7169ZCbm4uLL74YGzaEuvTOPvtseDyekOXPf/5zyDo7d+7EqFGjkJGRwfdz3333oaYmdEjauXPnom/fvkhNTUX79u3x7rvvxuUa3YDubpVltUPvMuGgZuHbnGh8m9U7jguSVvL/36g+U1cjH+nN0qjHQYo0N0GP0fxkzym4f/Olhs7BDOFgZB9MODyzehi/lmiE53Jo6Vmhh/BnHc3boMZ7tevajnjp51P5/32a78epeds0nRMT01oEuFSIJ8wzkYCXFit7YQQjQ0gbTKJ0tGj46aefMHbsWCxcuBCzZs1CdXU1hg8fjtLS0pD1br31Vuzbty+4PP3008Hf/H4/FwxVVVWYP38+3nvvPS4IJk2aFFxn27ZtfJ0hQ4Zg+fLluPvuu3HLLbdgxowZcb1exyGJoWoeyCkrS/vhRPHg8+Gmv65AkkfArw1bYu9wLxqO3MsXtY19NOOgVjhEG4MhHLVGkBlYqZE1aviNbG/msdUIByM9K7QQ6RlHKhtawl2LLuyHz5d15WM33HjGGnggaBLHBGFFEt57Yvr06SGfmbFnnoIlS5bgrLPOCn7PPAjNmsm7n2fOnIm1a9di9uzZaNq0KXr37o3HHnsM48ePx8MPP4yUlBRMmTIFbdq0wbPPPsu36dKlC+bNm4fnn38eI0aMqLPPyspKvogUFxfD0lgkNKHX26B6nokTtLzOjzOP7EC1x4u3WoUaISXhcHR6vqZeFcyoKI0HoPftNlqvikiG1WivCD3bx0KsiNd3RfPfI26nN5ShtktmNFHIhMOwNZdrEgzhZe+z//bA+d02oXXjYgzqcQTztmWprhNMVAdKTuZDqNpOFO6J6n5JBKn1FhjpPQFLknBPQzhFRUX8b8OGocP/fvjhh2jcuDG6d++OCRMmoEzSLWnBggXo0aMHFwwiTAgwQ79mzZrgOkOHDg3ZJ1uHfR8pbJKTkxNcCgoKHOEys3qYQg1pSdV4KPlb/v+HVQOwOaux6m1Zo+71CJjT7b9cDEgXrcbFaBxdziiGexfkiKfHIdbHinStkQSD2m6o0Z6N3hwG0ZsVaZFyZGY+1v6xC6au6sI/X9VnBfc2mFkXLNfukFAJQomQcSAQCPCwwRlnnMHFgchVV12FDz74AD/++CMXDP/5z39wzTXXBH/fv39/iGBgiJ/Zb0rrMGFRXl63krLjMAEjLrt2yXd5czURunepabzkQhNqG8tLrt2GfG8Rdgfq45WaIbxx1sKsrv+TP6cwEaE0j4RWwRDJ2EmNoxa3fbQeDGq2N2MdM7YPF0pGh9SO9ozUCAbx+XNx6RGihr7CkZbJqau7oLQqGW0aFeL01jvjJxhcMuCSJcSSi0h4eEIKy21YvXo1DxtIGTNmTPB/5lHIy8vDueeeiy1btqBdu3YxOReWLMkWIs6jP0YJVXRsfBjX+Bby/x+tvgDlSAk20o2Gq2/U1RLruQ0YRpIcjYQrlLZNRP4DEw57C3MwrtscmEV4qEJOMER7xkxkDlur/hmFi1jmbfhqdRdc1XclX+Zvb8myG1QJBjUhCjKa1oSVNCNyxqpSyDJS9I477sC3337LvQktWrRQXHfAgNoZ5TZv3sz/slyHAwcOhKwjfhbzICKtk52djfR0bfF0JVzT1VLFW0ykexEtAVLpbeuCC7fyLpbf1vTAr4H2Ib+p8ThE8jJoNUTi4ERG34rFN2xmLPVi1MCHbx8rwZBfvzb0GAl2D9g6WjwuWlHyJsWSL1d3QVlVMto2OoaBMt4GW4ckwqEQBYfCEzFCEAQuGL788kv88MMPPFkxGqz3A4N5HBgDBw7EqlWrcPDgweA6rCcGEwRdu3YNrjNnTugbDFuHfU/YI8chJ60CZ3s38v/frBmERBBpams9IkJqHJmxjCYclIyuWaGERPWwCL92OeGgZ04O9jzeLVafj2RUbEYSrmsv74Kpqzvz/5m3QZrbEE0wRBLZquoWhSgIp3kaWEiC5St89NFHfKwGlnvAFjHPgIUgWE8I1pti+/bt+Prrr3HdddfxnhU9e/bk67AumkwcXHvttVixYgXvRjlx4kS+bzHEwMZ12Lp1K+6//36sX78er732Gj777DPcc889Cb1+NyBt3LR0swxvTHv+qRjJngBWB/KwSQjNT1HjbTDqZQgfHjoSkQSEdJtIb9Px8Dj4t2TJLjt+bxHzY2u5Zj0eBzkBx+67mcNNRyKap+vL1V25t6Ed9zZQjpRr4hOCgcWCJFw0vP766zzRkA3gxDwH4vLpp5/y31l3SdaVkgmDzp07495778Wll16Kb775JrgPn8/HQxvsL/McsCRJJiweffTR4DrMg/Hdd99x70KvXr1418s333xTtrulrbBoaCIWXJxU62H6qqa35sbbjLCEnjdfOQERzRiaJRwiiQMlIm2jtF0sBIPaexXNyyN9RkaFg1IZUhMaY96Gr9bUehv+1HtV7SiRKsMS4WLbkmEJIhSDw0iz7a1IkhXCE0qwro5sAKhotGrVCtOmTVNchwmTZcuWwVEkoD+2kZnlPJnqZrMUSstCEiMzrk1HV+9+VAtefOfvEXV7sxMjIxkcLRNSsfWUjKA0RCHG9/WwY3EBoHHiJTXICYeUYx74TzluimCIdL3snknHc1B7v41MMa4lKVJL750vV3XBZT3XoF2jo+jeYBdWldWO/KgFzYIhEWM20HTZoKmxCRX1JEHqP86NguD36xrfXktoIlxc3Nh6LrAf+KVJa6R0OYYmOKa4/aGZzYPCwcywhBHhoNXdrkU4+DfXq2PMGVUNYlcmxWOIx/a1Vy8etHpT+L1rrn59paGmzZpOm6G1u++ay7ti9qa2OK/zZozqsQWr9jRRL6hP9KLQ1SvJj/jiklwKN5JwTwPhLuHAPAhqvQ3SBMhz921BwANMza9NbI1Gk+F7gv/7ojRgfhPuWzThoLdHgGhcI4mHcLEgZ9jNFg6iWIh0LtHEg97wS7jHQa+HwahwEL0N4YJBWuaU+P7eTlw0nNZuLzLqJ6O8OlnVdnpGiBTrqhsEg95u3rFCEMMMBra3IiQHnUScK6vexkgMPahl8BX7kO6pwdpAPlZmyw8lHokZXb+IKgqYqJBbGCzz3qg73IwuhOGGlhloJcFQVT+6kddD+L6kx1FzbpEEg1qPSrR7aXZIIlLZ8ELgIkG6qOHQrObYdLgRdhdmIy3Jj4GtlAd70ltn3CYYLIngMb5YEHrCTsOiwqFOIpfKRjA9uRpX+X4LdrM8NFtfhr8eb4LUQxGecKcm8U6PYFAynqLBjeZdkMMM4aB1H+HiwUiCp5p7qkUwMG9DJEEQLhzlyhITo1phgoGx85q2+HFLW/7/kHZbnSMYCFdA4QnC0qGKkZ02IsdTge2BhpgT6BxsfJsMU/dmF97YRwtVSFlWVRM17BCLkEQkmAFOPQb4G+jb3kiowojoSFpcD5UNtOU8aA1VqBmmuy470CclPk2gKBhEftzSBtf2W44+zfehfno5CsvTYxqiiAvkZXBFIiR5GkzCUl2gHFJ5vZ4ARg+oHczpHf8ZCEiKa3gjLIeet0EzXd7szVq6GEF8Y2fGlwkHvegx/kYEg/Rc9XhIlBBFmSjs1HiCjD5TM/JfGPuKs7H+YGP4vALOarvd/l4Gh7Q5piLQOA2EnbBQmEKp14RSo9ixyWHkeYpRJKTha3/tQF5GUdvoMy+DESPDDFp4qEGviJAztvESDmYJBqVr0dO1VHoPtQ7lLX2W4c9ZS9lRK0rlBO7Oa9pEDVGQYLD5y5tDIXnoZCwkHBS3iyAceufXzlC6KNAGVaibYa7kbVBq0PW+LaoVDuHDQ0cikoiQbqP0dh5r4WC2YDDicZC7V3rmqYi3h0GpjP68tTX8AQ865x5GfnaxasGgKMLJw2AZBIODO1HvCSIx2Fg4dOpTGBQNkVATptBqBJTePvUYHbVv0lKDGK13hFnCIZIwMFMwsJBKONGuL5pXRnpP1QqHSM8umrdBqawoidNoZZPlMSzbUzt/ztkSbwN5GByE4KwhpBnkaXADCRQOmuaakAiHZJ8ffbw7o4qGWAkHJZSEQyQDpsUFvyvKHBDhRtiIcAgXCEpCQg1az0UUDlpCN3rCGVbyMMiGKNpvqx1WmnIYCItDosEtcTSbeRy65B5EqsePg0IWtgmNNTXSWhIgw42C2hh3LD0OejBTOMT7HKKJJLVDTRt5VnLPXa1gCC9vWkTsgh0tUVXjRV6942iXoX7Yc6kYp66V1kRwaHiCulzalXiPJa9DdPAR2tJqZxnVhN+PbrcfAnYCK3ObIrdL3e6VB2fWNTTx6oopEt4dU42bPNoU2EZ6GDCjLRcKkCNnm0z5YS+7EFDUxht30ZJo0RVPD4OUDX/qiGV78zGg5W70bXUAmw/p7E8bTyzeU8IyI0MKBsMMFn0XJdFAWJLTju6EHx783kC+Ec4dvlv2+1ldv9LtQHu3uDa+LKVXmropjLUk5EUSDmZ0SYwkHGRFQgTC140mIpQEg1oRw65daRwHNYJBbpjpWExapYdI5ZXx+xN5XDT0aXUIn6/upXqfQvFxfUbc6AuHnu0tLjRig+fEYmR7bezZswfjx4/H999/j7KyMrRv3x7vvPMOTjnFvDFjSDTYlXjPXKdz1jo9c000SC9H++NHwF4WlkQQDfFiRUWB4u8+TwB+wRux94Na4aBVMCiN1yAKBy1CQa+IMNPDEEk4aPEwSIWDGsEgfb4rKoAbsvfx/7V6nmZ3m4phay9SFAeRWLMvl//t2OQIPCyvwZChsSCuFAzx59ixYzjjjDMwZMgQLhqaNGmCTZs2oUEDc71XJBrsjMWFg++EWNAqHPq33MMFw+pAPg6nZiJe9E3bgaUV2vr8Mz7b2y/ks5oxGJghFIWD2YMeZW8PANuZQa9BZQPzq7goItj+D/VJMXXf4cJBi2AQ77uvRUCV4LMCB2e0QMaxMlRU+5CZWo0W9YuxS0X5YXWK1S+/1sRJG4Q1HYNgTniiuDi0O25qaipfwnnqqadQUFDAPQsibdooJ5HrwcVP1CHEu1LqbHS0ZIX3OrP29fVHfyfeqMaDlVVVQeGghxYNaruHqkXaS4C9rYuLKYJBAjPsZsP2Ke6XHS/8mEaRE1HhvSvkFpGP9/TXdVz27MVyEA/Esh0QvHwSK0an3MNRt9Pbw4IEgz1HhCwoKEBOTk5wmTx5suzhvv76ax6GuPzyy5Gbm4s+ffrg3//+t+mXRaLBCThIOKQm1WCgdwv//wd/J/5XrXCozWcwTryEg2ggpXF/qYDQKiTCjbfoZTBTOEj3JfVimCUcwq9Z6+iZep6BkWeuF2mZ3nlde2w4WCsa2EBPSpBgcB+7du1CUVFRcJkwYYLselu3bsXrr7+ODh06YMaMGbj99tvx17/+Fe+9956p50OiwSk4RDj0br6fT4O9J5CDjULT4Pfx8jhoNSLhb7V6jZYS0USEmrd9M4RDtH2En4eaJMhI16YnZJNowaBWtMqV5Q0Ha7sVd8w9EnE7EgzunBo7Ozs7ZJELTTACgQD69u2LJ554gnsZxowZg1tvvRVTpkwx9bJINDgJBwiHHnkH+N9fAh3qZA/HSjhEcknH2uMgNYxqexkwRAPLttHyhm9EOGjZVumc1HhRtNyLSPdcbYgikR4GOdHQpuExpPjq3msSDPad5VIwsGghLy8PXbt2DfmuS5cu2LmzdpA8syDR4LSBnSwiHMQkSK3CoX732v1tCtRmlIdjVY+DGW+9Wo1lk2XaRZse4aBnGyYc9IRapPdArbfBbA9DPPMaRA6VZOBoaRqSfALaNY7DoBcOx3LtchxgPSc2bNgQ8t3GjRvRqpX25G4lSDQQlqKl5yj/u1NoqGk7s/IZtBDtbVbJmEUyiGqFg5EcAi0iwIh3Qus56vEw2Aklwbvzug7YcKixbDKkkpdBUZxTTwlXTY19zz33YOHChTw8sXnzZnz00Ud44403MHbsWFMvi0SDE7GItyHqZmGNIeujXuCpfcvapSAazPQ2qHmrjLcLOx7GU9oDQmmdSKjtyqlWOES65mjeBiVhpiTqYvVMI4lXNWVWDFFIRQOFJWyMYE5Og1r69++PL7/8Eh9//DG6d++Oxx57DC+88AKuvvpqUy+LRINTsaFwaJRZhjRPDarZYEmCcsZ8osMUamPmckZNjdtdSThoeYOPZtzlhIEaQWEFkRTLxEczQxRqy6rYg6JTk9pkSBIMhFYuuOACrFq1ChUVFVi3bh1PhDQbEg1OxmbCIS+7dlCfvUJ9+OGLul2ihUOsjZucMTV7TASGVCDEQiwonbMawSAnstTe03BxZ5XERzk2HqoVDbn1SlHPrzOvgUISlsEjGF+sCI0IaTfi3ShoRQjA4/MBHm2uNaGsHN6R9cCu7miDVOT22q3JJezVoX8DCGgaAZIZHL2jRjIjt/tYfVOHizaTWI0eKRUOxa29lvcwmIlWUVtWlYLC8lRkJFejRcMSrN2rcbI3EgzWQqAJqwgiprQWjnDTvzOjvqbt9AgGPS5oqVhgAkAPKTrsHQttsreOWHgZ0recHBcg/cTf8na1b7yxFA5aBYM4vLRRwaBF8PVOqe3+q5U5Xb/BuWtHI3eEtnkoKkakYdsH2ejT8hBys8uwdl/0KeEZvqxM+I9HnuwrZmgVKW4bUlrQnpdQZ3sLQp4GuxHv+SZ0EigrgzdD20RVuZ7ahu9IirbtjKDHc8Bc3qLnQCtVDQSkHPPoaj8ihQ70eAikYiHSb7ESD6Jg0Cqg/HrFWnNtYkFkeVUFeqekIV4c/rYFSipq5/Kol1alqa4RRLxwmfRzCDZR7Fobs3xvrRXZtL4lnJyrwISDnkmiIokDMXExfJETA+KihkjrahEp4efUZFkVFwtaBYOee2Z0Lop4wgQD43hQNFQ7SzDYpM2yc5fLeOHCJ+kQbFIJtTRqomjYF8gJNqJOEg7+LVmGjaAeg822USsU5FAjNtQKl1jmTdg5/0HkuAZPAwkGiyOQaCCshoOEAxujIc9TOw3ynkCtCzrewsGp1P9dX2xeDiYc1IgDOfQKBlFgSUWXkwSDtJwXnxAN2enxH5XSzW0UoR56onbHIcKhYWYFkj0B1AgeHBK0T1bkljBFIt7Ww9HjtTAqGLRiR8EQ6mmotL+XwSZtU8wQyNNAWBWbVE6lho5lizMOCNkhYzQ4MUyh1SiyfAa9RthIWMIsSDDII1e2j1ckR81pIMFgE4T4jggZL+xhbQjHCIdI5KTXvlkdEeq6oEk4WM/joFaMyJ2jnAhyu4ehjqchVT48QYKBSDT2tjSE7YRDpEYvM7X2zeq4IN/FjYSDNUMVSpCHAZrLsigasmQSIUkw2AuPQ0eEtL6VsTCWnH7VpsIhK4poYJBw0GacYx2aUNo/CQZ9ZVjae4IlB4uQYLBh+yxQToMjePXVV9G6dWukpaVhwIAB+O233+A4bCgcRE9DiaA8dK5ZwoEN3BPPiarUZv6Hu+XVuPKt5nGIpWCQu49qQhJyz80qIQkp4uBOPi+QnlLbK4UEA2ElrG9dTOTTTz/FuHHj8NBDD2Hp0qXo1asXRowYgYMHD8Jx2Ew4ZKTUioZiBU+DXOPLhux1Y3JkNGNthQRIJcLFkFVzGNSKy2ioFbtVfh8qqn1BbwMJBsJqWN+ymMhzzz3Hpwq98cYb0bVrV0yZMgUZGRl4++2366xbWVmJ4uLikMV22Eg4iOGJEhWigUGhCmsQLk7i6fGwctKjVMxqLasllbU9KLI8NmxziCCs74OhnAZYE+tbFZOoqqrCkiVLMHTo0OB3Xq+Xf16wYEGd9SdPnoycnJzgUlBQAFtiE+Hg19G9yOnCQQ+JDFPEO49BD1YMSUjZc3MPeD0CKqu98HmsP8eMHdqXhCFQl0tbc/jwYfj9fjRt2jTke/Z5//79ddafMGECioqKgsuuXbtgS2wwuRWb2Io1lAxp8lc0Gl+gbRZBo+iZ9MjIjJh6UDs6o9neBj2CgYUo9AgGltegR4hZXTAwklGDhpmVOFaaGkyKVAOfjj7ekGBwJSQTI5Camors7OyQxXbYRDAwSoMuWeWR8NwiGPTMhJlI9IqVeF7nfVsu07Wd3ryGFfe/rnmbkcmr+V+fN4B9x8TJyi2KDdqXhPagEKj3hK1p3LgxfD4fDhwIHYeffW7WrBkchw0qtHTqbFE01PNUaBIM564djVhjF8EgNdyxmtZaDvFY8fRy6L23ep+lHljZ1CZuBVyTspD/983KDggINnins0E7kzAEEg22JiUlBf369cOcOXOC3wUCAf554MCBcBQ2EwyM0ip1osEsD0PvlDRdRubK5ot1GTVfuxJdgqGojdeyYQmjiNemVyTFSzioLStGy2x770G09h5BVY0X369qXaeOEIQVsIGUNQ/W3fLf//433nvvPaxbtw633347SktLeW8KPXi8FnQh21AwqA1PUEhCm2CIp7ch2rlEQ4twkAowLcJBKvji6XFQW3YHJ21EhqcaGw80wPGK2vFKbCEcbNDmJAKPQ0eEtM6IMHHgT3/6Ew4dOoRJkybx5MfevXtj+vTpdZIjbYsNKm+kRjBaeIIEgzU9DHLChJ2TnsRIJhz0JEYy4aAnMZIJh3gmR7IyrJQc2cO3h/+dvzm/Tp2x/HgNrO2xYGJkQl/shBOLke0tiPWecoy54447sGPHDj4Ow6JFi/iokI7AxoKBUVRe+2bV2FPXjU+CwZqCwUqJkXbIcYhWlvO8tcJn19G6U8OTx4GwCq4TDY7EBoIhGgeKawVFrqcYPviD35NgkM9rUGuUYxmiiLZvpXNUytVwq3CodyI0V1Ip39WShIPNECgRkrAiNhEM0Rq8Y6VpqBJ8SPIIaJqgkfDs2EvC6pDHQb1wqIeKkFCdHCQc7IPHoTkN5GmwMw4RDAwBHuwN5PD/871FcfcyOFkwxMLboGWfJBzkCS3fArI80UUDg4QDkUhINNgVBwkGkX1CrQHO9xbGPSwRD9R2uzQDlogoLqKRN0M8iPuR7l9N0qNZwkHtPbRbqCIdVdzLJp17wvbYpI2KGQINI01YBZtURq1vRHsCtQ19+847EU+0Ggqx6148vQwsByCS4Q034EpGXK94CN8u/FzUnAN5HCILBzGfoUbwoLIm+pDQtvA22KitigmCM3MaXNXl0hHYpBLqadQOCbVZ4w2r4te9zA5hiar6zOCaOxmVKACiTaFtxDshd76H+px0bqbEbx4v1YNyJYr6ntoyf5zP8qqujNiiK6aFu2PGGo/BvASr5jSQaCAsw85AQ/63dVl8rAkb6W9phAEolfrvM6GhZ1wAJjSYANAKEwyM4tZeZG83VzRKRYEoIGLZ46LJskBQOGi6F4IHrfrrmzTumXb/1SwexTEcjI4GqZbu/TcB64DNgVxN25FwIOINiQa7oVWxx9sz4fHWThIjaJPJnswM+GcdAC4EGhyrxMEZ6mYIzB2xm4/xP6vrV7pOV+vgPkY9E772x+HfXLcffjTBEA/iMYIkEz61XhPEbRAnNlFVNOEQqRwEoK/+9Hp+rKb185I2sikucXQ9NNcdb3o6/CXxy5fhuNBzoBmBBnci7EYCBIOuzTJrQxl7i2qNab6nEEmSsRqUBEM8kQoGLe5uvaEMOcHAjG6sUJvUqBfpuesVQ3ZJcNRaNrt59/K/m45p8zQkzIjbJEyaUASD3S0tGp4guehUbCYYGEfL0lEuJPEsciYcrCoYjBo55m2IhpJR1SIc1CQfhouFWPSIkDtnLcJBes+0CgdR4FlXOAjo7q0dQnrToUYhdUITJByIOECiwYnYUDCIYzXsEmrzGlp6jsZFMPRMkR99L5HJkvEMSSiJg1h6HezgcVBTNqKhpqwygdzAU45qwYttR2rjNiQcHIDgzN4TJBoISwgGkcM7UhVFQ6RGeNjaixBvjGTkR/I2qDWiZoQp1IgCM4RDtHONds2R7pUa4SD3jGLtcQgvi9GEQ3dPbWhio9AU1YGT3S1JONgcgUQDYYfpsS0Sa/SX6usKtudEXkMH70FYgXh6GbS+dRsRDlrEgBHhoPYcrexxMAMl4dD9RD7DjvWZdX5TIxxk6xqFKogYQZ4GJ2HTsISUVXtrpyk/y7exjn8uVnkMkdzQsRYM0jdoLUaT9TwQex/oEQ56RICebdi5ieeqpreE3D1Qk/8RC8wITailh7e2XK8/2ET2d9t4HCxGol/oPDT3BGFpHCAYGMv3NkOZkIxmnuPo4tln+cTHcPe33jffSEiNbiTjy4yzWvFgxGugdpRH6flIhYCaa9HjcYh0z6OFj6zgbWAzuoqehvUHGsPWWMTLScQWd0tRp+AQwcCo9vvwa6Ad/3+Ib4MmwWBWXkM8QxLsTVrJsGohXDjIDfVslGj70Or5kLte8X5o8TJYJUwRrQyGl+UOnoPI8FSjWEjF7sLsiNvZxttAwsHxkGiwOw4SDCIrf24QFA3x8jCI7uh4CYb8+kV8YegVCVqMtpk9ISLty5zkzJP3QbxH4n2yi3CIhrRM9zoRmti0uyHvPaQECQebITgzEZJGhLQzFhcMLEHLl5mhubFbvLM5/IIHXb370aSiBIfSshAP9BoP5gZ/5tiw4Ge1Rm5vYY6uUSKjIRrvJibPVyFF3C/zZsRiwCl2T9j9Ee+lmnvK1hdHjdTas0UcNjpe+QxMOLBRT0XRsP6gutAEq0uCniRjVnfj2V64dL4JKTT3BGEtLC4YjLhViyrSsDG7MTodP4T+x/ZgWl4nJIJeadHnOlha3kqTUAgXDCKxGF76YN+Txi9nm7nlhc26yWmTEnViHa3DRutNfhSfQUDwqHp2IisqCuoIh3jAhMOgnzZpzmeQCgdNvZRIOMQfAY6DPA2EJVnYsABdjh9C38JQ0XBwpvKcFEOFizGj6xeaj+fzeHFD9j4sq1I/yqGUK5r/jk/2nKJLMATPwUSPAzPS0lkkg0ZeglohIbdt+LHMGpAqXDBIvQ1angUTc33T1QkAqcBgXga/TkHe98U7o66TO/xkaKJV6TE08pThmJCONfu1DR9NHgciUZBosCt63vyNeCd0bOvx+SBUVGrfLjMDa19tAlwA9Dp4AAd3NVc1XXCTYbVD8eoRDHoQvQxahEMkwWCmcFD7Vh8uBkQREU0kxEo4RPIwaBEO7BmIaBEO8UIqev/EJqlKAjbsbISy4+zea6wrPp9tPI5u627JoQmrCEsX0GjEuXFhgsFIOGPDwSZ8HorGnlK08xzSJBhGrP2DbsHQJyVJl2BQQzTBYAZGkimZWNAjGMw4thXunfjs9YhIVua0iVYB53tX8f/mbmkD20C9I1RD4zQQ9iWBgiGgYcpeaf4DG053aaAl/3+Ad5ulPQyR3nT1Gr1oMf1Ib/RGjHZVAyFk0Uukc9A7VLSWeyh37/WIOyNlQ21Z7OHZg5beY3xMkoU7C3Tl/rC6pVecE4Re7OFrIlzjYZCyYUltF7pTFURDLASDkrchlh4GaRdDZkS1JAQaFQxqvovFuYjXqbZ7pR6Pg5pnJvfMYykczvet5n9/29oclTXJhrpUxl04kLfB1V0uSTQ4GRsLBsaKfc2CnoZUVGtqnJVCFLHwMER641UyclJDKTWW0m3UCAezBYOa38w4J+m1Sa850n2RWzeahyceHge5sqZUNr0IYIRvjWxogoSDc/DQMNKErbCQYFAKUSg1kpsPN8IeIQfZnkpc4lsW15BE+JunVqPDjFi4cYtmDCOhJBxiJRi0rKPn3LR4UeTum/TeRhMM0Z5htDwWsz0O/b3b0dRzHEVCGpbuZkm+0Cwc5OoUeRyIeECeBicmQ1pIMBghIHjx1YLa7pY3+Obzcfq1oCUhMhZvqXpFgpKRDR9yWi9axIBZwkHP8NBySO/n0+3/p6mHhNkeh2hlTE44jPau5H/nrW8ZMhW2FPI46McybbFA4QnCDtgo3qimYZy5oQOOChko8BZihHdtXBMf2RtoNCPDDFb4ovUNWC1SYxsvwWBkG7mhoc2etVJ8PnLPIZKYSGRyZBqqMMxXW45/3NxWcTsSDjZHcKZooHEaiLh4GZg71ZuVpblBrPQn4cOaAbgz+UfcnDQPi89i1scTtwZfRO3brJ6xG7Qk+tX0P2F0dY7lYMT4s21TjtW992wQqaoo0z4wsRBt2CytAzmJokxpPAYl4cB+U9vF1izO9m5ElqcKuwP1sfaAtgGd9PRIihs0bLRroPCEk7BJWELrG9TPnzTlXdM6eg+gb2HtNMJqYe5jJcHARv9TWm7I3qVbMJjtcZAaVLHXQaQ3d+lokGYIBr37CD9Ho2GaSPdUq/eAPdOeyd6ozz8caVnSEv4SvQ2jfbWhiV9WFESdoMpW3gabeTnjgcehiZDkaXAKDhUMjJLKVMzKa4+L9q/DRfvWYmmDusljUg7NPPl7o+F7dQ8LrIVoRkurxyEcJWMrGmWlkSTNEAzh+5LzOkjPR+lajAzWFEmExWIEyEhlp+8LdYeMbjJcOWzW48z1OHvxRpQIKfhhc+3077EcMpqPyOrXlgdEmIhgMMRAosH5sAQcIZCAJ20TwcDcqmzWy2iEN5CejHS8tX0ILkpbhzMO70BgZg6OIPrMl0wwMIatvRSzuv4PemFvpCurA6Z0xdQjHNS+ncuJBzPFQrRwhdYeEXLCIVqIQk3XSjXCgT1TI7CydWRmfkSxKsdfkr/hr2nrdzTArr1sbIawcq5QN0ThoDU0EXfhkOAwhWWSIB0sGig8QWiGCSOtS3Db0rKoS7hgYFT/pwQrA82R5BEwylc7/K4awWAWkYyMnq6YkZAzonrc+Xz+ilOOx1QwiLBjsGPpSXDUem2sp4Qaoj0To4JBTxnL8xQGuw1/vLKP7Dpq6oWuuhdvI05hCkdDooGwTaPwVU0v/vfipOWaG3PmbTAbNYJBLptfbY6D4W6a7UpkF6vsj6FlIirRixCtd4SRHhJqkJYltcLh5qRfkewJYKG/DU+AFMWwrd+kLdZGWO3eeBya00CigYhrZdY0F0VYw7ryk3qoEnzo5D2Azp59stsoNeJGhYP0DVXJKEUyatJtogkHI4KhRQOZLEgNxl+POIh2TCPXGj5zpRQlASH3jIx6GeTKUDTh0BRFuNS3lP//xbQOwe+1Cgex7ljNOFqFhISGXdjlMmGiYfv27bj55pvRpk0bpKeno127dnjooYdQVVUVso7H46mzLFy4MGRfn3/+OTp37oy0tDT06NED06ZNC/ldEARMmjQJeXl5/FhDhw7Fpk2b4natbkZvAyfXoLKEyB/8tYM93Zb8MxKBnNFR+/ardrjpSEZUTfKgEePd6pTdfNGLmmNHuoZIw2hr6Xki9xykwsGssIQcSsLhxuT5SPH4sdjfCqv21w6NThCx5sknn+T28u6773aGaFi/fj0CgQD+9a9/Yc2aNXj++ecxZcoU/O1vf6uz7uzZs7Fv377g0q9fv+Bv8+fPx5VXXskFyLJly3DxxRfzZfXq2glhGE8//TReeuklvv9FixYhMzMTI0aMQEVFhenXlZC3gEQkHqlwP0a6F9G8DUpvYF9/1RY1ggfDfeswxLs+5Dc1rmIzwhTM+OgRCXKEG8VYehjUbmvWfrQSfu1Gu6pKn0/3ZOP1MlrZkSt/TVCMP/pqr+OL6Se9DFq9DeF1RlM745IcA6t5YDwJDE8sXryY29aePXvCbBImGkaOHIl33nkHw4cPR9u2bXHhhRfi//7v//DFF1/UWbdRo0Zo1qxZcElOrp0VjvHiiy/yfd13333o0qULHnvsMfTt2xevvPJK0MvwwgsvYOLEibjooov4TXz//fexd+9eTJ06Na7X7CbM9DBI2Xa0Id6tOZ3/PzHlO2SiIiaJjyIBCMFFiplvrcw4jus2xxKCwaz96d2e3QN2L8weTdMLT8izlHumZhBeDm9O/hWpHj+W+Fti+d482W0cmd+QwB4Ubg9PlJSU4Oqrr8a///1vNGhgYOjYCFjqyRYVFaFhw4Z1vmeCIjc3F4MGDcLXX38d8tuCBQt4uEEK8yKw7xnbtm3D/v37Q9bJycnBgAEDguvIUVlZieLi4pCFUPcGo6Yxk51wR2Xj+c1/WmFnoAGaeY7jnuQ5mgWD3BujnEGRGhVmdIygJjFPj6E0YqDF7fX8ZnTfRu6B1iRHUeDJPcNoz92Ih0rqZfjvdBZWi1yGlMq+4oRvVhYOhCmE2yFmm5QYO3YsRo0aVccuOk40bN68GS+//DJuu+224HdZWVl49tlnec7Cd999x0UDCz1IhQMTBE2bNg3ZF/vMvhd/F7+LtI4ckydP5uJCXAoKClRfi5srcqw8DFKq/El4uHo0///y5N/R5fhB1dsenZ6PgODBuWsuU/3GGUkwmOVtCJ+vQq14iIdRj5dwCL9uswZpCn9GasWftGz0e+5OXm7YogZRxI5J/kXiZYieyxATjwOFJmzvaSgoKAixRcw2ReKTTz7B0qVLFdex3IiQDzzwAJ566inFddatW8cTF0X27NnDQwyXX345br311uD3jRs3xrhx44Kf+/fvz8MKzzzzDPc+xJIJEyaEHJspPC3CISHuwAQ3EPEQDCL73gd+mNAW5xzeiht3LMH93c8L/qbUuNcfId/rIhLRjEy0gZ+iEck4igY00mBQ8fQCsHV3H4syuYSB7SOJJHZvjHSdjCTqxFCFWliZKZyRF7VsNRx50uPV74zVuGrpYpQKKVG9DOF1QSgrV31uCR9YTg4KTXDYEzfy+ihuu2vXLmRnZwe/T01NlV2frXfXXXdh1qxZvFOAbUTDvffeixtuuEFxHZbDIMJEwJAhQ3D66afjjTfeiLp/FlZgN0WE5TgcOHAgZB32mX0v/i5+x3pPSNfp3bt3xOOwBxPp4RDmjADHR4jMbaJpG6GklP/1pKfhned74sxrtuO0Y7vQamY1lgWUDUy4YBi25nLM6vZ5xPXVvpXqHTFSLsNfzSiSiQgbxEI4KHlUpGMyyN2faCM/RvMCqRUOrIyEC4dIiILCiwDGpU0DfMDKrY2wbCNr8E+U26xMTcJBUxflcOHgEi+D08nOzg4RDZFYsmQJDh48yHP6RPx+P37++Wee48fCGj4T5iQxXTQ0adKEL2pgHgYmGFhvCJYU6fVGNz7Lly8PMf4DBw7EnDlzQrqVMFHBvmewLp1MOLB1RJHAvAasF8Xtt9+u4wqJWIRkRDGgBiYYGIdLMzG1pjcuT17KXcG3V7bS7GGIJBy05jBo9Tjo6Zr5XOG5CREMZgsHrbkbWj0OasNG0YSDKBhE1AgHxp+SFqO3bzefY+K1+afpKudMXNje4+B2hPgOI33uuedi1arQ0XJvvPFG7tUfP368KYIhoRNWMcFw9tlno1WrVvjnP/+JQ4cOBX8TvQPvvfceUlJS0KdP7bCrrGfF22+/jTfffDO4LnPHDB48mOc+sOQPFtP5/fffg14LsZ/q448/jg4dOnAR8eCDDyI/P5/nR8SKhFReC4QotFwzu0f+g4fgzcjQLBhEvv+8Bf5w5TKcmbQZXav3Ym0gX3NIIlw46E16VCsc9Mbr7+te62H7eE9/XdsbFRxGhcOVzRcDzdkkUNo9U2qFg9Y8k0jCIVwwqBUOzTxFuDtlDv//3Xm9cLg0A550QCjX1r2biYtAWZnmNiTh+VQJCE0k/JojYLTbpNZt69Wrh+7du4d8x4YXYL0Pw7+3pWhg3gCW/MiWFi1ahPzGukmKsC6UO3bsQFJSEldMn376KS677LLg7yys8dFHH/EulWyMByYMWFdK6U26//77UVpaijFjxqCwsJAnVE6fPj2mcR9XIQQgBLwxr+jhgoGxr7gepvl7YHTSSt4F84aKG1CF5JjlMBgVDnoFA9tuRUXBSeN7ArUCwgzBoEc4SM/VaK5CtO30JqYayXEIRcDfWTdgTxWW+QswbY1k9Mf0NM3CQQ9BkUGhicQjOHPCKo8gtdBERFhIg2WuDvH9AUmek0ZJCTfMeKnnDUNOMETzNsgJBpHceiV46aoZyPFU4Ovqnvhb1SU8jUirYGDeBqOiQQoTD1IjF0kwRBuSmiEKBiWkAkI06maKBTnkjiMnFMLplbZL9bWHE35PzerFIgqHSF6GcMKFw3DfGjyX9jmqBS/u+Ow87JQRVmqFA/MyGGpHEtEOJCgBUssLSI1QjR/9X/Du/WryBIzYim63PQFfqv4XU39lBdb8628xPVdbd7kkbJ65rLKRijhKpKSR1CIYGAePZ2HyN2fwkSIvTF7Jh+3VKhgYQ1f/EWYiNWZ6PAxat2HGWlziIRjCjyE9tlqM3hczB9ligvHUZ/6qen1pGctGOf6WUjt8/WdLuskKBjVlWa4uaPbKucjLYNXQRBCHzTuR0PCEG6CkpLr3I1as2NsMT1adh4mp03BPyizsOjYKvzcIDXtJKZp28i0x+7yT43Wcs/py/NA9co8KrdyQvctQzwq9iPkP4ejNhxCRFQXNDe1SVw8JMz0M0mfPyoK0bIjknL9PMVQxLmUWGntLsTXQGJ8u7aZ4HD2hCmpL7IcnzjkN8YJEgxNJVEKkQvdLVaNElpXVCVOoeTMT+fWd+vjfzX1wafIy3LtlHm7tfQlKkmq7zcoZgnDBECvhEMueFbLbp+3A0gp5MaLVE2DGMRPZQ0It7JlLy0Tx96GDMSkJiQtOWYDL1i3lnq7Xvu6D6kD0LPVIwkHR46YmudoG4UnC3tCTdrv7zMqDPmkQDCe2wLvvdMK+QDYKKopw1U/reWOvRTDIGRG9SJPrmJFTY+jMEAxGtjW6vRHUXHv4fTRj/gi5Z61UNkRYuWowPRkT1/7IP3++qCPW7M9FLKH2xEYINDU2QaioKAFDjZz4phVNMLA+7HWWmhpUVwl4uLx2tNArU35DG+/JrrxaMSIcmDGTS6pUEg6JFgxm70fX9hoHbNLa80HLM44mHDJQiefTP0WWpwpLalrig6U95ctlhPEWwsu4kpdBVZ1yUS6DHQSUJ4GzXMYS8jQ4FYe4C1U3wikne7TseKcaP1Z3RLIngL+nfYck1Oh6k9RLNCMm53WwimCI1f40bR92L9R4aWIxY6VyORHwaPpXaO87hAOBevjn+73hZ92OJeVQTTnW7k2zoMF0SFtDqINyGuKA65KYTuQ2qGnYBL8/9AuPF/6SUvi09ASWaaj/80l7DLxmKwYkbcfz6Z9hXPkfUX2iuKsVDCXfNsM5qH0TVZvjoMV41RrCxImFaNsbyVMQ96t7+xPCQUvuQiTvTiQPA3u+jKwLlMuDXI7D1SmLMCJ5Le9e+eQXp+JYmb7JpkQB7I8wXLRHYRS/kHaFvAzWQ3DmOA0kEZ2MBd4AmChQWiKdr79Unas20pvd3qJ6ePTrM1AhJOHs5I14Mf0TpKA6qmBghkRctIYq9Lzt9klJ4ovVBEM8j2HmfVHzDMRnKYqFSM9cirTc9PbtxL2pM/n/b/7SC+v2N1ZVJiPBy3qEuhqt/iTc42CBNsaqeCg8QRAaR4kMFwVmNz5RGuelu5rh4a8GoVxIwpnJm/FEu8/gC3sjkxoMJaMRTTgYdY9rNZLxNObxPJYREaXmWUQTf0rlgQmHfM8xPJv+GQ99zd1YgK9Wnhz10Yhw0FsHeB1zmZeBSCwkE+NEwt8IojVW4Uu8jy+DordBZaO8fHdT/KXsav7/uYe34LpdS1WLBDm3tZzRkTNSatzkPpnrVmM0E/H2H+tjRrpuuXuk5l7LPRO5ZxctNCEtK/WryjEl933kekuw0Z+LF35kY154DJXROmU8EXUv0mJRLN2WSqHeE4QtUWoUIjUO8XxzidI4yQoHjW9xe18rxN9KL0GSEMCNO5dw97IRpMYnVgl4kYxoosIFsTq2GZ6FSEifjdEutA08pXhh4fdoU34MBwP18Oi/eqGiWkU5VCirEUVxPA22Ul3X03YQJyHRQLgCCwkGWVQIBqG0/ORyYgCdJa8F8G1lT/g8Ap7I/B8aeuQTz9Ry7prLYiYY5IzqDdn7EioYzNoH255dSyzFghT2jIwKhnqecvwr63108B3EwUAWHnj7VBwqzQgtZyeWRIYqdEPhjZjgoZwGwjVutXigoVEMvpHJNL6KDXfY/X5rSgvs8jdAc18RXs/6DzcGkYjmthYnNlI7uZER/Cca9Z4pKcElEYLByL7Cz128plgiPh9PlA7vSs+ajcXwWtYH6JR0AIcCWZjw9qnYcyyr9keZ+hyxLIaVXVWJviQcZG4JtaGJhvxLRPzfOHQ0hryRrapW92bHkGlcyqqS8dA7fXE4kInOSQe4MWBGQSvh3e9iKRwiGVe1AsLoKI9G9hvtHGMpHMKfSTThIEcaqvBy1kfombQHxwLp+Pt7/bH7WL3QlaIYsZDyWl2jrWcQP3HyONgWgUaEJJyslK0mGNj5hC2R+rLXQeEes7fEv793KgoD6dwY/Lvee8hChSbBIDd5USyEg1qjKjXOUgMdC7EQjvQYkc5DCbOEgzQZMtKzCBd7SqSjEq9mfYhTknfguJCKiR+cih2HI0xPrKFO8zIsU7YVodwBa7edEfAIguHFitDgTkRiY5pmH1tFw7L9cDb+/sGpeOyaxeietBdv1HsPt5dciyIhdLIsrUZHNFZzuv0XRjFiTJnB7p1ygL8rh7O8StvsiuH0Tqm7T3asALSHTKTXqqaXRDTUCDf2DKON1cHCVszD0CdpF4oDaXjo4/7YfEB+quuQcmdkALdIz1u8L/GahE5h0jmCYJBocDvxFgwGjxeorIA3NcLQuyrfRAIVldwI/P0/p+If1/6Gbkn78Fa9d3FXyZXYE2ggG+PW8pY6bO2lmNX1f9BLLN32ckbfChgVDiwxVS1ywoE9c9atsqmnCC9kfYKuSfu4YJj4UX+s25YJoBLetNoZU/UKB1Z2NWOx2WoJDdCIkITj3Gw2zZqWbXwV7ikTCdJFZOvBHNz/zmm8Cx3LjP8s+3Wcn7LSkGCQCge2aCUeCYJWQE4g6Ll28T57NeYsyD3Toclr8N/s17lgOBrIwPj3T8OGfQ2DYiFSOVKDLsGQSCxWDi3TZmqAek8QzkJPo2Cht4+QRlimQVHbuO86Wg/j3jgNy2oK+GyFkzO/wLgtvyAp4Jc1LnL5DFIKZ+TpFg+RjKYZrnu7IHcPIl1/+H0Nv/fhhD878dmyUULv2DYfz2Z9jmxvBVbX5GPcW6dj66Ecxf3JljG5smgVwaB1bAWLCQfCGrinNbIYllTO0QZysVgjwhtjyX1UKxTC3cyHjmfgby/0xmvlZ/PPF+1fiyfXTUfF9400nY+S0Qo3cFJDyAylWzwMaoh2P5SEWDThEE7Z900w6aefcfm+1fzzv8vPxP0v9sO+QhaSOEm00ERI2ZOWSasIBilaBmyyQLm0ZFupBuo9QTgKraO7WaDxkCNQXq7LXVxnP4IXX72Sg/GdR6LG68PAwl14js0xIDOttl5jJWfsSCxEJvzeqPXaqBUOSfDjqfT/YmjyevgDHjzYaSj++0rD2imuDcDLY1WV9QSD2jpMoz6agocGdyJcq6AtKhhiwYo7cvDQ/wbx2TEHJ2/ikxOx/vpKaH27ZYZv6JqLSTCoFA7nrLlEc35ItGfCZjx9Iv0LDE9ehyrBh8e/PR2L79TmWbIlLqrLRGyg8ARh/0bGrHM8kfm+Yk9TPPL1GagUfBiSvBHfZL2C85JWyU5wH26cGo7cq/pwI9b+gS+E8v3xqhyuO/zeywsHAUOT1uKrrFdxXvIaVAtePP7d6Vi8I7/2ZyPdJu1Sb6x8bmEvVbZ5sXJReIK6XBK2b1y0dBOLGJsOMxbLdjXDg1PPxF8vWo4W3kI8nfE/XJP9KyaXDcaujPq6PAwiR2bmo8nwPcHPUuEwo+sXcDORRBS7Z42GqxdkIuwZ1R9RmwCZX1GMlwq+Qd+i2v3sD2Tj5W97Y8nOk8/Rk5leO9KojLFiZUdVGMwO9cYG3SqFgGBr0eA5EZ4wsr0VsXapcQGWrRR2aPjMOucTgoEZDCkr9zTFX/51Ll6qOAdlQjJ6Fu/H6yu/wsgDGwwJBiXc6n1Qc93R7l0k2LM659Bm/Gv5l1wwsNDT65WDcdsbw0IEQwh6PQ52qjcWP1fLto1qIU8D4Ros3piY+gYVxThU+ZMw7c0mWJQ5EuP/+ht6Hj+AiZvmokVKJZ6rGoaABt2txeiJBtTpngetAkmrx8GDAO5I/hG3bfiFf16X1QRPvjoAB46H9o6IWDbUGi671hkbeBwIa0HhCYsoauaKswR2bfxUNIR1QhMa7vmR0gw88My5GH3Tbtye8jNuSF6Adp5DuL/yUhxHevTtdb4lM6MqnWxpVtevYGeGrb0o+L8g6HuTVCsc2GRkk1O/wLlJG/jnt6tOx/+ebQV/tYYyHiYcVIcoEonW7tEWFA629zJYPMRgBBINxEnUNDQW7MetqyHUKtLYDJtJSfj67QIcazcI9wxdiDOTNuMb7yt4r+Z0fFp9CsqQaqpgYBya1Ry5w3fLGl07iIjw8w2/tibDTuZ2aEG8p3LiIR1VuDRpCW5Mno+m3uM8ofWlH07FD5va1K5QVSk7zbpuj4PV6oBS2Y90rhYUDrZHEGoXI9tbEBINFsFS3gaGmgbEao1lpPMLvxaZ+xyezxBCVXXIx1+2tMLewnoYf+lCFHiP4d6UWbgl+Rf8p/o0TKtuhZLkVMNiQTSq0bCaiFASCWYLh3CvQ0ZNFf6Q/AuuS16Ahp7a6af3BnLw9NTTsOFg47rPNIJwCCZDRhMOVi7/kUSAkpiwiHBwipfBqZBoIE7i1CFmpY2hDg8Dw5MRKiq2HGmI298ciSEdtuHSwRvR2nsUd6TMxaXL6uHDgl54d9U5MRcMeoz2nK7fwAjnrh0NszEuHPJwda+5uG7nMrRIKebf7QrUx5e/dMTsDW1RHfCFrM+epVBWrigcZDkhHHiIojxMVFgRLSLAAmLBaXgc2nuCRIOFsJy3wQmCQXrOOgVDJNjIgbM3tMMPG9ugy/XVGFd/BvIrjuP/Ns/D2Sk78XD1aGwTmsRNMIgcnNECuSNOhjRibfSjHTOWwqHAcxQPJX+DgRu31Z5HSiaeKx6OVe+l8VE+o6JDOFhupEclLOI9cKWXQTA41oJFTYF9ShNhDewoGE6gqbGPIhhC9it4sebdVNz6ykWYXDWSd888xbcTX6ROwZ+TflI9FLVZgkEvh79twZdEHFvrtfvgx01J8zA19TUM9G3j3SifrR6Km18ZjRXvZqgTDHqetZ0EgwPqLGE9SDRYDEsrbQc0PnKNfp18Bg1GJGTfghc/v5eL2z8ZjZ/8HZDi8ePO5B8xLfVljE36kb8VM6QDO1lJMMj9H89zEO+B3H0Q71mep5ALsW9TX8G9ybOR5qnBAn8b/OXT0Zj9bj5qPCn6Dhz2zOVyXGwpGGxSd20/+qMMnoDxxYpQeMKCWDJMYfFGRwus8fempsn/qFMwCOUV8GTV9v0/WJKFJ98+DQvaNsMt5yxFvrcIf/H+hL8k/4Tf/S0xZ39rzG3SFuW+ZFPEgpmCQfpd4wt2JyRUER6uSPXXYPDhrTg3ZRYG+LYH1ykU0vHWT30we1M7PiJDyLNIj/B8dYYqbC0YbBCqsPvoj24KT5BoIMwVDBacQlvJCISIBwOCoS4e/LS1DRbsKMDA1rtw5uC9GOjdwsMWp2zaiVu3L8as3PaYsmUYrCYYzBIODCPiQZiVjTHtZ2PkgY1oVF3OYhKchf42+OXnfPy6vSUqa+SNvFnCwRZiQUs3aIsKB8cJBgeT0NLTunVreDyekOXJJ58MWWflypU488wzkZaWhoKCAjz99NN19vP555+jc+fOfJ0ePXpg2rRpIb8LgoBJkyYhLy8P6enpGDp0KDZt2gQrY5lKpNQAyU2vbQPBICVoFBQEQ3jPieiCIXREyZ+2tMHjb5+B6z++FM9Xn4u9afXQsLocf9qzCjNTX8CjSV+hjeeQLsMcK8GgZR0l9JxfS88RPJT0Db83V+9ewQXDgdRMvFw9BNd//Ac88vaZ+GFzu4iCQc2zUXqmYlmwhWBghNe5aFNbW6yOWqatMxmPQ6fGTrin4dFHH8Wtt94a/FyvXr3g/8XFxRg+fDg38lOmTMGqVatw0003oX79+hgzZgxfZ/78+bjyyisxefJkXHDBBfjoo49w8cUXY+nSpejevTtfhwmNl156Ce+99x7atGmDBx98ECNGjMDatWu50CBUYMG3E7PwHyuCLzND83bRBEM4h0szMfPdTMz0XIJW19Xg5qRf0d+7A5cmLcMlvmX4IdAZX/l74fdAaxRHGWXSaO6AFjFgxOOgNlyRhQqc4t2B0b4VGOZdB9+JFnNZoAXeqhmEbW8maUtuNOhxYGXCVih5ECIJBwfXaUsg0OBOMYGJhGbNmsn+9uGHH6Kqqgpvv/02UlJS0K1bNyxfvhzPPfdcUDS8+OKLGDlyJO677z7++bHHHsOsWbPwyiuvcKHBvAwvvPACJk6ciIsuqu3D/v7776Np06aYOnUqrrjiClgVS+Q2OHXshrDr85fWDgakVjxoFQxhB8WO95MxCWejc+5BXDBqK871bcBQ33q+sEe+TsjDokAbvuyq8aE8KSUhgiFWwiHNX43TvZsxwLuNL109+4JCgTHX3wHfTmuHNQdyJfkK+uqCFuEglgOO3TxnNhyXwaleBgaN0xAjWDiCGfqWLVviqquuwj333IOkpFoHyIIFC3DWWWdxwSDCPARPPfUUjh07hgYNGvB1xo0bF7JPtg4TBIxt27Zh//793FshkpOTgwEDBvBtI4mGyspKvki9HoQCdmpcoxgNJeFgTCyADyrkkex//cFcrH8nF5/W74xRXTage5fDaOc9jG6efejm3YebMB/++R4sr5+H3xs0xzfrTj1hPPU1tkbCDUaFQ9rMdIzuugj9j+1Bn8K9SEoJFQHbAo2wZn1jfLe+I7YfbSh/75TCCgqIz01JPIQIBrtCHgTCyeGJv/71r+jbty8aNmzIwwwTJkzAvn37uCeBwYw9CydIYR4C8TcmGthf8TvpOux7cT3pdnLryMHCHY888ggSjSW8DS4RDCKRvA6KMfITPSciwUcgVGBXYX1MWTAAWAA0SC9Dr/z9aHdmCX8LL/AWol/hXr7clrYY2wMN8aO/E34MdMKKQAFqxAzBGOcnaBUObCyFHt49OMe7AWf7NnAxhK0nf98nZGOhvy02z8vCyr3NcLgs+syT4n1UEg/sWQglpaq9Do4QCzYUDk72MnCo94Q6HnjgAe4JUGLdunU8cVHqIejZsyf3KNx2223cYKemyk/+Ey+YgJGeH/M0sETMRGBp4aBWMNjN1RvmdTDiYYgmGMI5Vp6BuVvaYu4W4C30RF5mIVpfWoNzfOu5iGBDVt/oXYAbsQDVghd7hfrYKTSsXQINsUtogIrSShxIzUJZUoopYkGKuD8mHtJrqtC0shSdvGVo6TmKlt6jKPAc4/+38BxDsqSzOTvXxYHWXPBsm5qKPcXZuj0mRr0OonCwlWCQCoFodcniwsHxggEUnlDNvffeixtuuEFxnbZt28p+z0IGNTU12L59Ozp16sRzHQ4cOBCyjvhZzIOItI70d/E71ntCuk7v3r0jniMTLYkWLpYnWs8KtetaGGZUPOXl8GZoT5TUIxjqbF9ahn3+etj3DnNCDERGcj/0bbEPA1rvxikd9qO+pxytPEfRCrUDRwVZArA7XiKkYm9mfewNnFiE+tgfyEaRkI4SIQ3FQhpKkMr/Fz0WzEOQ5alEPVSgnqeC/5/jKUczbxHyPYV83Il8byHyfypEjueEmIpQVYqENCzd3AwLd7TA77vyUVZ1MtQoVISGauIpHPxHjlpXiKsRAmrql0WFgxsEg5MxPTzRpEkTvuiBJTl6vV7k5rLkJ2DgwIH4+9//jurqaiQn13avYkmOTFCw0IS4zpw5c3D33XcH98PWYd8zWHiDCQe2jigSmNdg0aJFuP3222EXLOdtkOvmpXZdGyE2cIGy2jdSLeLBDMEQTll1CuZta8UXz48CGmWWIS/7OPJzjiM/uwT1ewb4W35eSiFyaiqR7alEtu8AOvtChbUcbArpVI9f83kWJaVif1Wtt6NwlQd7i+phb3E9/vdIaQYEBW8Cu8Z4CwfxWVquTpk5e6VY5ywqHFyBQL0nTIUlITLDPWTIEN6Dgn1mSZDXXHNNUBCwxEiWV3DzzTdj/PjxWL16Ne8t8fzzzwf3c9ddd2Hw4MF49tlnMWrUKHzyySf4/fff8cYbb/Df2dgPTFA8/vjj6NChQ7DLZX5+Pu+aSehEbUNkZcEQ7Rr4ufvqGBw1wiEWgqHOOvDwbpxsWbXvRA+k304ePzWpBk2zy9A0uxS5/G/tkt3Owz0I4pLhqR2XIBl+PocDG5qZwebQOM48EUIq/3t8q4D9xZk4WJyBA3zJ5H8rqpN0v/HHUziIYiF04yhG1YphNTVCgIRCwvHQLJfmwlz/zMA//PDDvJcCM+ZMNEjzCFgvh5kzZ2Ls2LHo168fGjduzAdpErtbMk4//XQ+NgPrUvm3v/2NCwPWc0Ico4Fx//33o7S0lG9XWFiIQYMGYfr06bYbo8F2b0ZWa2xNOvdoXod4CIao23s8qKxJws6j2XxRwusJICOlBpmp1fzlqLw6CWVVyXwWz7gZ/hgKB1mxELKxDd/G7XjOFJpwBB6BDWRARIWFNJiIGeL7A5I8GqbSjQG2EA52EAyRGl3JuXt80XsmMPEg9p5QIxiUjKOcYPCkqc+tCW7v0R431hOCOXng2jKpxfALFSe7NOu9N3W2PyEcWO+JqGKBref3ayoPcUOth8NGwsEKuQw1QjV+9H+BoqIiZGcri2mjtmLgyEeRlKz/xbSmugILpk+K6bnackRIwoFEa+ysnCSp41y4cWJhi6ysxHsYdCI1sGpDMFb1OARKSuz/9i53LjZKdiTg2PAElTYbYgXFrtnoRhoL3+aCoXaz2trNjJUeg8UMpVUEg9J38TgXcXs9+5Def93eOCuXRzvUITu2WYQmyNNgUyyZ36ClR4XVMCgYpIiGS43nwaiBNboPJXFg1OPAiIfXIZJQ0z3dsh3e3sPHbLDwObtWMASE2sXI9haERANhHhZttAwPlBOBaKJNaszkBEQivQtqvQlGhEMswxVqPTqmCAcr9qCwa71zE4Lu6VJObm9BqLTZGNcqeDNRMAZKSZBavTzhoQs7CAY968ph5rXqCQEpPSvFRFcrCAUrnIMB3NxGeYxOjw1rQp4Gm2PJMIUdGkQDxw6/31oaRm7wNIQvEi0YrOBxkN4zvfXCkMeB0IWbBYOTIdHgAGwtHOSwsDvYzPscLXxhFcEQvm08elbo7gGhdHy9wsHlZV4Plr3P8USgESEJwtXxWSOCQdw2UmOqRkDEKuFRz75iIRzUCIVo91HN9pY1aA4TDm7H49Aul+RpcAi28zbINY6iYLBgw2mGYFBLuPH0paVaRjCYKRyMeBOMGH9LCgcx8VJOOFi4Z4Qclru3hKmQaHAQthMOUizcKMZTMMhRc/Bwne/EKbsTIRj0CIc6U1Czz0JA1YibsRIOljVwNvY4WPJ+JgrBmb0nSDQQiceigoEPMWzg3IwKhuAQxzLnUMcIywiJWAoGJeEgd25K15go4SAe35LYWDgQtXgEgS96MbJtLCHR4DBs4W2QNoYWFQx1zlXjeZomGDQQYqyjGBythlrpfPzHjxsTV4kQDnYwyFLhYIMQBXkZ3AGJBgdiC+HAkGsElRrzRL59aRAPiRAMYScQ+2PIHdMOwiHRYkGpDMvdQ5t4HEgwyMAem5FHZ9HHbm3pSji3Ems1MFZ5yxKH7LWxYIgZBo9t9NoV732U5xZX7Fr27drWJDg84TGwaGHy5Mno378/6tWrh9zcXFx88cXYsGGD6ddl7dJIOLMyO6HRDDNCzGC5WjBYSDiEPAcriQUpchNPRVvfgli2jXEhP/30E8aOHYuFCxdi1qxZqK6uxvDhw1FaWmrqcSg8QTh+joiYIgQg+I036o4QDFpDFRFc7+K9MBSusGqCY/i9sUn4gbB+74np06eHfH733Xe5x2HJkiU466yzYBYkGhyObfIbzEiQtELOg3ge8TRuVjQ6OhNIDeU5WOE+6CmDNkt4FCEvQ3xGhCwuLg75OjU1lS/RKCoq4n8bNmwIM7FH6STcVbntJhjCEV3iUc7HFO+CVa45keEKK90HvUbfJkJBbE9s16YkAI+Ryaoko0kWFBQgJycnuLDchWgEAgHcfffdOOOMM9C9e3dTr4s8DS7BNh4HpzW4Ed64VQuGSNdmFSOZqJ4VVr9+ox4HgjjBrl27kJ2dLX5U5WVguQ2rV6/GvHnzYDYkGlyE5YWD0wSDlBPGgOc/mLQvW2GCcLAdeoWDhSEPQ/zDE0wwSEVDNO644w58++23+Pnnn9GiRQuYDYkGl2F54aBnrgo3YUfBIGKjeL1pOGAuCRESDBrvF3vMBqqr1m0FQcCdd96JL7/8EnPnzkWbNm0QC0g0uBDbCgcn5T3owc7nbnOD6fawAwkG6zN27Fh89NFH+Oqrr/hYDfv37+ffszyI9PR0045j49pLuLYRcHIYIxI2NzqOuhY3lj9Cf3hCMLBo4PXXX+c9Js4++2zk5eUFl08//dTUp0eeBsJe6EkMtHODbXcD69Tr0jocdLRtLIqtXy5cNk6DEKcJrmzcmhKuahC0jqAn3Y4gYoHe8khlkrAx1KK6HFsJB62EN842e8sjLEh4GXKwAHBi2zD16DuOnXsiXji3xDug0MULJzYOTm7MCYvhwLLmxDZhZvUnjs5piBfOK+2ELhzVSBhpxB1oAAiVULlxXltAmA61kHZQrHHCEY0FNfwElR+dVce5w0MnpM0W2HjOBhZrOhpINOiFhIODBAMlpxFmlQfyVFmORLXVHsppIMIh4WAhqJEnqEwZqD7kYYhNl0vBwAJLQuEJwlWNSAj0VkhQGXFHXSdMg0SDQZzqbXB8Y0KCgaCy4ug6nvC2WaDeE4RVC2cMcWRyFAkGwuVlxpH12mptcsCExYI4qya4vZDGEMc0MA5r/IkElB2bDxLmmLpMJISEtaBs6k6PxyO7LF68mK+zfft22d8XLlwYsq/PP/8cnTt3RlpaGnr06IFp06bVGZN70qRJfPIONtvX0KFDsWnTprherxOwfWNDgoEwowzZuBzZvg7b6AXOQ70nzOX000/Hvn37QpZbbrmFzwF+yimnhKw7e/bskPX69esX/G3+/Pm48sorcfPNN2PZsmW4+OKL+bJ69ergOk8//TReeuklTJkyBYsWLUJmZiZGjBiBiooKRxbWWOKGRocgnIgb6q6l2mCBchpMJSUlBc2aNQsujRo14vOA33jjjdybIIX9Jl03OTk5+NuLL76IkSNH4r777kOXLl3w2GOPoW/fvnjllVdOPDcBL7zwAiZOnIiLLroIPXv2xPvvv4+9e/di6tSpzi60McINjQ/hQmwednB7nXVD22sFLONn+/rrr3HkyBEuGsK58MILkZubi0GDBvH1pCxYsICHG6QwLwL7nrFt2zbs378/ZJ2cnBwMGDAguI4clZWVKC4uDlnU4obC69hGyEqGw8ZucNW44RoTjGPrqtXbXIE8DTHlrbfe4sa+RYsWwe+ysrLw7LPP8pyF7777josGFnqQCgcmCJo2bRqyL/aZfS/+Ln4XaR05Jk+ezMWFuBQUFJh2rU7BDY1RwnCTMXXTtcYZqqMJRCDRoIoHHnggYoKjuKxfvz5km927d2PGjBk8L0FK48aNMW7cOO4V6N+/P5588klcc801eOaZZxBrJkyYgKKiouCya9cu+yvfGOC4rltWSHQzevxEnL8dzzn8+Ik+BxNxXL1UwC1trVVIMnuH9957L2644QbFddq2bRvy+Z133uF5CywMEQ0mIGbNmhX8zHIcDhw4ELIO+8y+F38Xv2O9J6Tr9O7dO+JxUlNT+WK0MA9PvgJugDVQQsCi457qQWpA4hmySKTxNXrNbHsj98ro9nqO50DcIhYsLxgC7GEY3N4NoqFJkyZ8UQtLVGSi4brrrgtJcIzE8uXLQ4z/wIEDMWfOHNx9993B75ioYN8zWG8MJhzYOqJIYPkJrBfF7bffjlhDwsEBxKt/fqIEg9x2eg24HYSDQ8UCgwSDdfCc6HJpZHtXiAat/PDDDzxZkXW3DOe9997jvSz69OnDP3/xxRd4++238eabbwbXueuuuzB48GCe+zBq1Ch88skn+P333/HGG2/w31k4hAmKxx9/HB06dOAi4sEHH0R+fj7Pj4gHJBwcQiy9D1YSDE4UDg4WCiIkGCya06AXEg2REyDZmA1scCY5WBfKHTt2ICkpia/z6aef4rLLLgv+zrb96KOPeJfKv/3tb1wYsK6U3bt3D65z//33o7S0FGPGjEFhYSFPqJw+fTofDCpeuE04MBwVroil98GskEIstjUiHIzcH7PuL4kFgjAVj8DiA0RUWEiD9aJgSZHZ2dm67phbRIMURwuHcLQaODUGTWmfSttHOxetxtTI/vReg9pj69mnQ3CTd8GMPAYz2nG1xxja7m4k+fTnxdX4KzF7ywsxPVc9uKd2WQBLJ+3ECFc1amIGvppMfKskPFr1eFq213LfHYSr6pYd21CBulwSbiv0JuGm7l8hRDJkdhMMid5WbnsXigS31yc3tp1WxH01zgK4tfC7saEz3cgl0nAn+vguFgpur0P2bDMFY94Gtr0FcW/tSzD2rATGcetbkikkWjBY7TxchJvrjW3bSoHCE4TJ2LYymIBbG0DHGGqrnY+DcXNdcXMbaVWo9iYYN1cKN789qcaoOz6WBtroeZF4iHKL3F0/bN82BgTjiwUh0WABbF85DOLmhjGmxMMok+GP0W11d51wRJsoBIwvFoREg0VwRCUxgNvfqmxtzEk4mHgrqR64vS20OiQaLARVFnrDItwLiWaHtYECJUISccBRlUYn9LZFuAkq7w5t+wKU00DECcdVHp1QY0o4GSrfDm/zBPI0EHHEkZVIJ9S4Ek6DQhGEXaGcBgtDwiEUamgJu0MC2EXtnGDU2wBLQqLB4ji2QumEGl3CjlC5dWH7JlB4gkgQjq5YOqFGmLADVE4jQ+2aPUlK9AkQ6ivY8OQr6HZFCFkIFh09jXAnFEqLjGvEQoANzhQwuL31oPCEjXBNZdMBvdERVoDKoTKuasMECk8QFsBVlU4H1GgTVO6sCbVdzoA8DTaEKl90SDwQ8YDKmTpc2WYJ5GkgLIQrK6EOqFEnqFwlFte2VQEaEZKwGK6tjAbEAyWoEVSG4ge1Uc6DwhM2hyqldkg8EFReYo/b2yZBCBherAiJBgfg9sqpFxIPBJWP2EBtEmpzGoyEKNj2FoREg0OgSqofCl0QVBbMg9oiZydC0uBODqysNAiUfqQ5DzRglDugPBdzILHgDsjT4ECo8poDeSCcCz1bc6E2J8KIjkYXC0KiwaFQJTYXMjL2h55hbKC2xl3hCRINDoYqc2wg42Mf6FnFFmpj3AeJBodDlTp+Roli44mHnkf8oLZFGSEQMLxYEUqEdAGUIBk/KJEy/pBYiy8kFlTCwwsGQgwUniASDVX2+EJvvXRfnQa1IQSFJ1wGVXrriAh6Q6Z7Zieo7dCIQ+eeoPCEC6FwhXWQEw5uHR+CRJQ1IbFgJLwQ0H/jKTxBWA1qDOzjkXCKZ8LJ1+ZEqI0gwqHwhMuhRsE5RjfRxtfK50Zoh9oGYwgBwfBiRSg8QVC4wmGQcSaMQGLBJISAwfBEwF2ehn/84x84/fTTkZGRgfr168uus3PnTowaNYqvk5ubi/vuuw81NTUh68ydOxd9+/ZFamoq2rdvj3fffbfOfl599VW0bt0aaWlpGDBgAH777beQ3ysqKjB27Fg0atQIWVlZuPTSS3HgwAGTr9j+UGNBEO6G2gDzEBzqaYiZaKiqqsLll1+O22+/XfZ3v9/PBQNbb/78+Xjvvfe4IJg0aVJwnW3btvF1hgwZguXLl+Puu+/GLbfcghkzZgTX+fTTTzFu3Dg89NBDWLp0KXr16oURI0bg4MGDwXXuuecefPPNN/j888/x008/Ye/evfjDH/4Qq0u3faNBDQdBuAuq94RaPIIQ2xRNJgSYsS8sLAz5/vvvv8cFF1zADXjTpk35d1OmTMH48eNx6NAhpKSk8P+/++47rF69OrjdFVdcwfc1ffp0/pl5Fvr3749XXnmFfw4EAigoKMCdd96JBx54AEVFRWjSpAk++ugjXHbZZXyd9evXo0uXLliwYAFOO+002fOurKzkiwjbT8uWLbFr1y5kZ2fDDVzc8MZEnwJBEDFm6tF3XHOPi4uLuX1gNiQnJydmx8jJycEgnI8kJOveTw2qMQ/TuO2xlM0RYsw777wj5OTk1Pn+wQcfFHr16hXy3datW/kQWkuXLuWfzzzzTOGuu+4KWeftt98WsrOz+f+VlZWCz+cTvvzyy5B1rrvuOuHCCy/k/8+ZM4fv89ixYyHrtGzZUnjuuecinvdDDz0kDudFC90DKgNUBqgMOKgMbNmyRYgV5eXlQrNmzUw5T7Yftj8rkbBEyP379wc9DCLiZ/ab0jpMyZWXl+PYsWM8zCG3DvMmiPtgXovwvAq2jngcOSZMmMDDHiJMmbZq1YrnYcRKocZSWdvRQ2LXc6fzpvvt5HJi53MXPcYNGzaM2THS0tJ4aJ2F3o3CbBfbn5XQJBqYu/+pp55SXGfdunXo3Lkz7A5LvGRLOEww2KmSiLBztuN52/nc6bzpfju5nNj53L3e2I42kJaWZjljnxDRcO+99+KGG25QXKdt27aq9tWsWbM6vRzEHg3sN/FveC8H9pkV0vT0dPh8Pr7IrSPdB1N8zFMg9TZI1yEIgiAIIjqa5BZLKGReBKWFuVPUMHDgQKxatSqkl8OsWbO4IOjatWtwnTlz5oRsx9Zh3zPYsfr16xeyDkuEZJ/FddjvycnJIets2LCBhxnEdQiCIAiCiE7MchqYUT569Cj/y/IOWJdJBhtrgY2VMHz4cC4Orr32Wjz99NM8v2DixIl8PAUxLPDnP/+Z94q4//77cdNNN+GHH37AZ599xntUiLC8g+uvvx6nnHIKTj31VLzwwgsoLS3FjTfeGAwn3HzzzXw9FsdiooT1rGCCIVLPCTnYObFunXIhCytj1/O287nTedP9dnI5sfO52/W8LUWsMiyvv/562WzQH3/8MbjO9u3bhfPOO09IT08XGjduLNx7771CdXV1yH7Y+r179xZSUlKEtm3b8t4Y4bz88su8NwRb59RTTxUWLlwY8jvLPv3LX/4iNGjQQMjIyBAuueQSYd++fbG6dIIgCIJwJDEfp4EgCIIgCGdAE1YRBEEQBKEKEg0EQRAEQaiCRANBEARBEKog0UAQBEEQhCpcJxqcMmU3O77H45FdFi9ezNfZvn277O8LFy4M2Reb/ZONscHOs0ePHpg2bVrI7yxXls0+mpeXxwfVGjp0KDZt2gS9sHsSfk5PPvlkyDorV67EmWeeyc+JDVfLuuWGE8/zZveSdd1t06YN31e7du141y3pULFWvd9qiVZeY8nkyZP5xHP16tXjde7iiy/m46lIOfvss+vcW9YtOxZ1Vy0PP/xwnXOSjoirpo7H+5wj1UG2sHO10r3++eefMXr0aOTn5/NzmDp1qua6wrr+X3311by7PWvzWT0uKSkxvb1xDYLLmDRpEp+oaty4cbITadXU1Ajdu3cXhg4dKixbtkyYNm0a7w46YcKEkIm1WNdNto+1a9fyLp9s4qzp06cH1/nkk094F1A2wdaaNWuEW2+9Vahfv75w4MCB4Dp//vOfhYKCAj6p1u+//y6cdtppwumnn67qOthkXazbqHS55ZZbhDZt2giBQICvs23bNt7Ndfbs2SHrVVVVBffz66+/8nN/+umn+bVMnDhRSE5OFlatWhVc58knn+T3aurUqcKKFSv4ZGDsOHonUmnVqpXw6KOPhpxTSUlJ8PeioiKhadOmwtVXXy2sXr1a+Pjjj3m33H/9618JO+/vv/9euOGGG4QZM2bwyW6++uorITc3l3cTFrHq/VaDmvIaS0aMGMG7U7PnvXz5cuH888/n3ail5WLw4MH8vKT3lpUVs+uuFtjEdt26dQs5p0OHDqmu44k4Z8bBgwdDznnWrFkhXeKtcq/Zfv/+978LX3zxBT+/8MkJ1dSVkSNH8skRWVf8X375RWjfvr1w5ZVXmt7euAXXiYZos2+yQur1eoX9+/cHv3v99df5zJrMUDPuv/9+3lBI+dOf/sQbPhE2XsTYsWODn/1+v5Cfny9MnjyZfy4sLOSF7vPPPw+us27dOl4xFixYoPl6mGFq0qQJN8bhRoxV6kj88Y9/FEaNGhXy3YABA4TbbruN/88ECJtp7Zlnngn+zs49NTWVVy69ouH555+P+Ptrr73Gx9QQ7zdj/PjxQqdOnRJ63uGwBoQ1UFa/32qIVl7jDTNq7F7+9NNPwe+YIQuf9TYWdVeraAifrVdETR1PxDnLwe5ru3btgi8cVrzX4aJBTV1hBp5tt3jx4pAXAI/HI+zZs8e09sZNuC48EY0FCxZw15N05swRI0bwWd3WrFkTXIe5waSwddj3DOayXrJkScg6bIIU9llch/1eXV0dsg5zfbEZ2MR1tPD111/jyJEjwZEwpVx44YXcfTho0CC+Xvj1Kl0Lm62NjdYpXYeNssnc13rOU4SFI5jLtk+fPnjmmWdC3Jpsv2eddVbIkOTsnJi7ms1smsjzDp8xT262PCvebyXUlNd4w+4tI/z+fvjhh2jcuDG6d+/OZ6ItKyszte7qgbnDmfuczbvD3ODMba+2jifqnMOf/wcffMBH3WUhACvfaylq6gr7y0ISbMRgEbY+K9+LFi0yrb1xEwmbGtuqWH3K7ki89dZbvBC3aNEi+B2LoT777LM444wzeCX53//+x2PFLC7IDJvStUivVXoPjJ4n469//SuPczKDMH/+fN4g7du3D88991zwmCx3IPx44m8NGjRIyHlL2bx5M15++WX885//tPz9jsbhw4ejltd4wuaPufvuu/l9ZAZL5KqrruLT0zMDzWLQ48eP5w37F198YVrdZXFxLTADxeL0nTp14mX4kUce4bHx1atXq6rjiTjncFj5ZBP6SScjtOK9DkdNXWF/mYCXkpSUxNse6TpG2xs34QjR4KQpu9n89CwJRy4RJ9K17N69GzNmzODzckhhbwlszg0Rlmi2d+9e/mYvGrFEPAPpOfXs2ZM3rLfddhtPhov3mPB6ys6ePXswcuRIXH755bj11lsTcr+dDEvGY0Z33rx5Id+PGTMm+D97y2XJb+eeey62bNnCE1MTwXnnnRdSlpmIYMaW1UWjRjFesBcOdh1MIFj5XhPWwBGiwUlTdrPtmKpXup7wa3nnnXe4q1+NYWKNGpspVHq90c5T/I41HNJ1evfubcozYOfEwhOs9wF7Y4t0TtLzSdR5MxEwZMgQ3gPnjTfeUNwulvfbTJjYiVZe48Udd9yBb7/9lmfNS71mke6t6PVhhsyMumsUVpc7duzIz2nYsGGydTz8eSfynHfs2IHZs2cHPQh2utdq6gpbRzqTMoO1NaxHRbTzVHMtzeJcPyyB4FKiJUJKs8ZZFi1L8KmoqAgm+LDMYSksGzc8EfKOO+4ISSxr3rx5nUTI//73v8F11q9frzkRkiUDsWQ8aRa/EqyHRZ8+fUISfC644IKQdQYOHFgnMe+f//xnSLaxmYl5H3zwAb/nR48eDUlMkvY6YFnZ4YlJ8T7v3bt3Cx06dBCuuOIKnj1u1/stR7TyGmvYdbNETJZ8uXHjRlXbzJs3j9cXljVvZt01wvHjx3nZffHFF1XV8USfM0vkZOUtfKJAK97rSImQSnVFTIRkPVdEWA8ouURII+2Nm3CdaNixYwfPbn/kkUeErKws/j9bWGWXdiUaPnw47/rFugexXglyXYnuu+8+ng396quvyna5ZIX33Xff5QV3zJgxvAubNNuYdcdi3cp++OEHXqhZIWSLFlj3PlYp2HmEw4790Ucf8d/Y8o9//INXdNatTtqVKCkpiVc8tg5rROS6ALJzZ90MV65cKVx00UW6uwDOnz+f95xg95Z1XWSCgd3f6667LrgOa2xZF6hrr72Wd4Fi95Ld7/AuUPE8byYYWFetc889l/8v7Ypm5futFjXlNZbcfvvtXMTPnTs35N6WlZXx3zdv3sx7BrF6wnqpsHvDZr0966yzgvswq+5qgYl1ds7snNizZV0QWddD1vtDTR1PxDlLhSE7N9ZTQIqV7jVrl8U2mrVzrLs8+5+142rrCutyyYT7okWLuPhhwl/a5dKs9sYtuE40OG3Kblb4I43twAxAly5d+L7ZGwA7B2n3L5HPPvtM6NixIz9P1kXqu+++C/mdKfoHH3yQVyxmWJjh3LBhg6CHJUuW8K5KzECkpaXx83viiSeCbyci7I1m0KBB/HjsjZc1Dok8b/Z85cqN1FlnxfuthWjlNZZEurdivdq5cyc3Wg0bNuT3hAk4ZoykYweYWXfVwroQ5uXl8X2xcso+M6OrpY7H+5ylb9zsHoeXLSvda7a9XLlg7bjaunLkyBHeTrKXRFYvb7zxxuBLopntjVugqbEJgiAIglAFjdNAEARBEIQqSDQQBEEQBKEKEg0EQRAEQaiCRANBEARBEKog0UAQBEEQhCpINBAEQRAEoQoSDQRBEARBqIJEA0EQBEEQqiDRQBAEQRCEKkg0EARBEAShChINBEEQBEFADf8PZ61cunWllK0AAAAASUVORK5CYII=", "text/plain": [ "
" ] @@ -918,7 +930,7 @@ "data": { "text/html": [ "" @@ -1344,7 +1627,7 @@ "" ] }, - "execution_count": 38, + "execution_count": 30, "metadata": {}, "output_type": "execute_result" } @@ -1409,7 +1692,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1420,7 +1703,7 @@ ], "source": [ "fig, ax = plt.subplots()\n", - "ax.set_ylim((0, 100))\n", + "ax.set_ylim((0, 10))\n", "ax.set_xlabel(\"Time step\")\n", "ax.set_ylabel(\"#Newton steps\")\n", "ax.plot([len(entry) for entry in reduced_log]);" @@ -1444,7 +1727,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1466,7 +1749,7 @@ ], "metadata": { "kernelspec": { - "display_name": "firedrake", + "display_name": "venv-firedrake", "language": "python", "name": "python3" },