From 2b1332f7d6b615fda79fc7fff041b81be5767e35 Mon Sep 17 00:00:00 2001 From: mhostetter Date: Mon, 10 Jul 2023 20:58:19 -0400 Subject: [PATCH 01/20] Add a time-domain plot in `sdr.plot.time_domain()` --- docs/api.rst | 5 ++++ docs/conf.py | 2 +- src/sdr/__init__.py | 1 + src/sdr/plot/__init__.py | 4 +++ src/sdr/plot/_time_domain.py | 47 ++++++++++++++++++++++++++++++++++++ 5 files changed, 58 insertions(+), 1 deletion(-) create mode 100644 src/sdr/plot/__init__.py create mode 100644 src/sdr/plot/_time_domain.py diff --git a/docs/api.rst b/docs/api.rst index f1ade367b..39f7b9085 100644 --- a/docs/api.rst +++ b/docs/api.rst @@ -17,3 +17,8 @@ Phase/time-locked loops ----------------------- .. python-apigen-group:: pll + +Plotting +-------- + +.. python-apigen-group:: plotting diff --git a/docs/conf.py b/docs/conf.py index 2093cc268..f70bc2466 100644 --- a/docs/conf.py +++ b/docs/conf.py @@ -239,7 +239,7 @@ # Python apigen configuration python_apigen_modules = { "sdr": "api/sdr.", - # "sdr.typing": "api/sdr.typing.", + "sdr.plot": "api/sdr.plot.", } python_apigen_default_groups = [ ("class:.*", "Classes"), diff --git a/src/sdr/__init__.py b/src/sdr/__init__.py index 387b4c74f..c87b430ff 100644 --- a/src/sdr/__init__.py +++ b/src/sdr/__init__.py @@ -13,6 +13,7 @@ "Defaulting version to 0.0.0." ) +from . import plot from ._farrow import * from ._iir_filter import * from ._loop_filter import * diff --git a/src/sdr/plot/__init__.py b/src/sdr/plot/__init__.py new file mode 100644 index 000000000..2cdcbc436 --- /dev/null +++ b/src/sdr/plot/__init__.py @@ -0,0 +1,4 @@ +""" +A subpackage for various plotting functions using :obj:`matplotlib`. +""" +from ._time_domain import * diff --git a/src/sdr/plot/_time_domain.py b/src/sdr/plot/_time_domain.py new file mode 100644 index 000000000..020ce0e84 --- /dev/null +++ b/src/sdr/plot/_time_domain.py @@ -0,0 +1,47 @@ +""" +A module containing time-domain plotting functions. +""" +import matplotlib.pyplot as plt +import numpy as np + +from .._helper import export + + +@export +def time_domain(x: np.ndarray, sample_rate: float = 1.0, **kwargs): + """ + Plots a time-domain signal. + + Arguments: + x: The time-domain signal $x[n]$ to plot. + sample_rate: The sample rate of the signal in samples/s. If the sample rate is 1, the x-axis will + be label as "Samples". + **kwargs: Additional keyword arguments to pass to :func:`matplotlib.pyplot.plot()`. + + Group: + plotting + """ + x = np.asarray(x) + t = np.arange(x.size) / sample_rate + + label = kwargs.pop("label", None) + + if np.iscomplexobj(x): + x_label = y_label = label + if x_label is not None: + x_label += " (real)" + y_label += " (imag)" + plt.plot(t, x.real, label=x_label, **kwargs) + plt.plot(t, x.imag, label=y_label, **kwargs) + else: + plt.plot(t, x, label=label, **kwargs) + + if sample_rate == 1: + plt.xlabel("Samples") + else: + plt.xlabel("Time (s)") + plt.ylabel("Amplitude") + if label: + plt.legend() + plt.grid() + plt.tight_layout() From b28784759686b7c088d416889a33725f20db8df6 Mon Sep 17 00:00:00 2001 From: mhostetter Date: Tue, 11 Jul 2023 19:15:32 -0400 Subject: [PATCH 02/20] Add `matplotlib` rc params --- src/sdr/plot/_rc_params.py | 16 ++++++++++++++++ 1 file changed, 16 insertions(+) create mode 100644 src/sdr/plot/_rc_params.py diff --git a/src/sdr/plot/_rc_params.py b/src/sdr/plot/_rc_params.py new file mode 100644 index 000000000..ca0c4805b --- /dev/null +++ b/src/sdr/plot/_rc_params.py @@ -0,0 +1,16 @@ +""" +A module containing :obj:`sdr`'s default matplotlib rcParams. +""" + +RC_PARAMS = { + "figure.figsize": (8, 4), + "axes.grid": True, + "grid.linestyle": "--", + "grid.alpha": 0.8, + "figure.max_open_warning": 0, + "figure.autolayout": True, + "axes.xmargin": 0, + "axes.ymargin": 0, + "axes.zmargin": 0, + "figure.titleweight": "bold", +} From 439d1b2dbabac96c608f448b7079de19a6f0d615 Mon Sep 17 00:00:00 2001 From: mhostetter Date: Tue, 11 Jul 2023 19:16:40 -0400 Subject: [PATCH 03/20] Use rc params for time-domain plot --- src/sdr/plot/_time_domain.py | 41 ++++++++++++++++++------------------ 1 file changed, 21 insertions(+), 20 deletions(-) diff --git a/src/sdr/plot/_time_domain.py b/src/sdr/plot/_time_domain.py index 020ce0e84..aa54af398 100644 --- a/src/sdr/plot/_time_domain.py +++ b/src/sdr/plot/_time_domain.py @@ -5,12 +5,13 @@ import numpy as np from .._helper import export +from ._rc_params import RC_PARAMS @export def time_domain(x: np.ndarray, sample_rate: float = 1.0, **kwargs): """ - Plots a time-domain signal. + Plots a time-domain signal $x[n]$. Arguments: x: The time-domain signal $x[n]$ to plot. @@ -26,22 +27,22 @@ def time_domain(x: np.ndarray, sample_rate: float = 1.0, **kwargs): label = kwargs.pop("label", None) - if np.iscomplexobj(x): - x_label = y_label = label - if x_label is not None: - x_label += " (real)" - y_label += " (imag)" - plt.plot(t, x.real, label=x_label, **kwargs) - plt.plot(t, x.imag, label=y_label, **kwargs) - else: - plt.plot(t, x, label=label, **kwargs) - - if sample_rate == 1: - plt.xlabel("Samples") - else: - plt.xlabel("Time (s)") - plt.ylabel("Amplitude") - if label: - plt.legend() - plt.grid() - plt.tight_layout() + # with plt.style.context(Path(__file__).parent / ".." / "presentation.mplstyle"): + with plt.rc_context(RC_PARAMS): + if np.iscomplexobj(x): + x_label = y_label = label + if x_label is not None: + x_label += " (real)" + y_label += " (imag)" + plt.plot(t, x.real, label=x_label, **kwargs) + plt.plot(t, x.imag, label=y_label, **kwargs) + else: + plt.plot(t, x, label=label, **kwargs) + + if sample_rate == 1: + plt.xlabel("Samples") + else: + plt.xlabel("Time (s)") + plt.ylabel("Amplitude") + if label: + plt.legend() From 0d277a6315b76e711d76faee6c5d2f295f266354 Mon Sep 17 00:00:00 2001 From: mhostetter Date: Wed, 12 Jul 2023 18:41:12 -0400 Subject: [PATCH 04/20] Add `sdr.plot.use_style()` function --- src/sdr/plot/__init__.py | 1 + src/sdr/plot/_rc_params.py | 33 ++++++++++++++++++++++++++++----- 2 files changed, 29 insertions(+), 5 deletions(-) diff --git a/src/sdr/plot/__init__.py b/src/sdr/plot/__init__.py index 2cdcbc436..631183f70 100644 --- a/src/sdr/plot/__init__.py +++ b/src/sdr/plot/__init__.py @@ -1,4 +1,5 @@ """ A subpackage for various plotting functions using :obj:`matplotlib`. """ +from ._rc_params import * from ._time_domain import * diff --git a/src/sdr/plot/_rc_params.py b/src/sdr/plot/_rc_params.py index ca0c4805b..95c969067 100644 --- a/src/sdr/plot/_rc_params.py +++ b/src/sdr/plot/_rc_params.py @@ -1,16 +1,39 @@ """ A module containing :obj:`sdr`'s default matplotlib rcParams. """ +import matplotlib.pyplot as plt + +from .._helper import export RC_PARAMS = { - "figure.figsize": (8, 4), "axes.grid": True, - "grid.linestyle": "--", - "grid.alpha": 0.8, - "figure.max_open_warning": 0, - "figure.autolayout": True, "axes.xmargin": 0, "axes.ymargin": 0, "axes.zmargin": 0, + "figure.autolayout": True, + "figure.figsize": (8, 4), + "figure.max_open_warning": 0, "figure.titleweight": "bold", + "grid.alpha": 0.8, + "grid.linestyle": "--", } + + +@export +def use_style(): + """ + Applies :obj:`sdr`'s default :obj:`matplotlib` rcParams. + + These style settings may be reverted with :func:`matplotlib.pyplot.rcdefaults()`. + + Examples: + The following rcParams are applied. + + .. ipython:: python + + sdr.plot._rc_params.RC_PARAMS + + Group: + plotting + """ + plt.rcParams.update(RC_PARAMS) From 55c4df9f85973f1cce1a7b2f87182c9d196be4af Mon Sep 17 00:00:00 2001 From: mhostetter Date: Wed, 12 Jul 2023 18:55:39 -0400 Subject: [PATCH 05/20] Fix exported module for subpackages --- src/sdr/_helper.py | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/src/sdr/_helper.py b/src/sdr/_helper.py index a1f36865a..8a5447b37 100644 --- a/src/sdr/_helper.py +++ b/src/sdr/_helper.py @@ -19,9 +19,10 @@ def export(obj): module = sys.modules[obj.__module__] if not SPHINX_BUILD: - # Set the object's module to the package name. This way the REPL will display the object - # as sdr.obj and not sdr._private_module.obj - obj.__module__ = "sdr" + # Set the object's module to the first non-private module. This way the REPL will display the object + # as sdr.obj and not sdr._private_module.obj. + idx = obj.__module__.find("._") + obj.__module__ = obj.__module__[:idx] # Append this object to the private module's "all" list public_members = getattr(module, "__all__", []) From 2d585c51c598b5dd066c9c8cb5fecee824cecdd2 Mon Sep 17 00:00:00 2001 From: mhostetter Date: Wed, 12 Jul 2023 19:20:21 -0400 Subject: [PATCH 06/20] Remove disabling plot margins --- src/sdr/plot/_rc_params.py | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/src/sdr/plot/_rc_params.py b/src/sdr/plot/_rc_params.py index 95c969067..5709ec27a 100644 --- a/src/sdr/plot/_rc_params.py +++ b/src/sdr/plot/_rc_params.py @@ -7,9 +7,9 @@ RC_PARAMS = { "axes.grid": True, - "axes.xmargin": 0, - "axes.ymargin": 0, - "axes.zmargin": 0, + # "axes.xmargin": 0, + # "axes.ymargin": 0, + # "axes.zmargin": 0, "figure.autolayout": True, "figure.figsize": (8, 4), "figure.max_open_warning": 0, From 6308cf7c2573206af5c211484f82e910ea382ad8 Mon Sep 17 00:00:00 2001 From: mhostetter Date: Wed, 12 Jul 2023 19:22:57 -0400 Subject: [PATCH 07/20] Add labels for complex data by default --- src/sdr/plot/_time_domain.py | 22 ++++++++++++---------- 1 file changed, 12 insertions(+), 10 deletions(-) diff --git a/src/sdr/plot/_time_domain.py b/src/sdr/plot/_time_domain.py index aa54af398..c7892900e 100644 --- a/src/sdr/plot/_time_domain.py +++ b/src/sdr/plot/_time_domain.py @@ -25,24 +25,26 @@ def time_domain(x: np.ndarray, sample_rate: float = 1.0, **kwargs): x = np.asarray(x) t = np.arange(x.size) / sample_rate - label = kwargs.pop("label", None) - # with plt.style.context(Path(__file__).parent / ".." / "presentation.mplstyle"): with plt.rc_context(RC_PARAMS): + label = kwargs.pop("label", None) if np.iscomplexobj(x): - x_label = y_label = label - if x_label is not None: - x_label += " (real)" - y_label += " (imag)" - plt.plot(t, x.real, label=x_label, **kwargs) - plt.plot(t, x.imag, label=y_label, **kwargs) + if label is None: + label = "real" + label2 = "imag" + else: + label = label + " (real)" + label2 = label + " (imag)" + plt.plot(t, x.real, label=label, **kwargs) + plt.plot(t, x.imag, label=label2, **kwargs) else: plt.plot(t, x, label=label, **kwargs) + if label: + plt.legend() + if sample_rate == 1: plt.xlabel("Samples") else: plt.xlabel("Time (s)") plt.ylabel("Amplitude") - if label: - plt.legend() From 98400779dcdce22795de7fc1c559fbcf4e9d85c1 Mon Sep 17 00:00:00 2001 From: mhostetter Date: Wed, 12 Jul 2023 19:23:19 -0400 Subject: [PATCH 08/20] Add function to plot impulse response in `sdr.plot.impulse_response()` --- src/sdr/plot/__init__.py | 1 + src/sdr/plot/_filter.py | 72 ++++++++++++++++++++++++++++++++++++++++ 2 files changed, 73 insertions(+) create mode 100644 src/sdr/plot/_filter.py diff --git a/src/sdr/plot/__init__.py b/src/sdr/plot/__init__.py index 631183f70..98d2e1be7 100644 --- a/src/sdr/plot/__init__.py +++ b/src/sdr/plot/__init__.py @@ -1,5 +1,6 @@ """ A subpackage for various plotting functions using :obj:`matplotlib`. """ +from ._filter import * from ._rc_params import * from ._time_domain import * diff --git a/src/sdr/plot/_filter.py b/src/sdr/plot/_filter.py new file mode 100644 index 000000000..8553ba469 --- /dev/null +++ b/src/sdr/plot/_filter.py @@ -0,0 +1,72 @@ +""" +A module containing filter-related plotting functions. +""" +from typing import Optional + +import matplotlib.pyplot as plt +import numpy as np +import scipy.signal + +from .._helper import export +from ._rc_params import RC_PARAMS + + +@export +def impulse_response(b: np.ndarray, a: np.ndarray = 1, N: Optional[int] = None, **kwargs): + """ + Plots the impulse response of a filter. + + Arguments: + b: The feedforward coefficients, $b_i$. + a: The feedback coefficients, $a_j$. For FIR filters, this is set to 1. + N: The number of samples to plot. If `None`, the length of `b` is used for FIR filters and + 100 for IIR filters. + **kwargs: Additional keyword arguments to pass to :func:`matplotlib.pyplot.plot()`. + + See Also: + sdr.IIR + + Examples: + See the :ref:`iir-filter` example. + + Group: + plotting + """ + b = np.atleast_1d(b) + a = np.atleast_1d(a) + + if N is None: + if a.size == 1 and a[0] == 1: + # FIR filter + N = b.size + else: + N = 100 + + # Delta impulse function + d = np.zeros(N, dtype=np.float32) + d[0] = 1 + + # Filter the impulse + zi = scipy.signal.lfiltic(b, a, y=[], x=[]) + h, zi = scipy.signal.lfilter(b, a, d, zi=zi) + + with plt.rc_context(RC_PARAMS): + label = kwargs.pop("label", None) + if np.iscomplexobj(h): + if label is None: + label = "real" + label2 = "imag" + else: + label = label + " (real)" + label2 = label + " (imag)" + plt.plot(np.arange(h.size), h.real, label=label, **kwargs) + plt.plot(np.arange(h.size), h.imag, label=label2, **kwargs) + else: + plt.plot(np.arange(h.size), h, label=label, **kwargs) + + if label: + plt.legend() + + plt.xlabel("Sample") + plt.ylabel("Amplitude") + plt.title("Impulse Response, $h[n]$") From ea0afde0fc4d00207388ab6c771044546ed2b8a8 Mon Sep 17 00:00:00 2001 From: mhostetter Date: Wed, 12 Jul 2023 19:29:03 -0400 Subject: [PATCH 09/20] Add function to plot the step response in `sdr.plot.step_response()` --- src/sdr/plot/_filter.py | 72 ++++++++++++++++++++++++++++++++++++++--- 1 file changed, 67 insertions(+), 5 deletions(-) diff --git a/src/sdr/plot/_filter.py b/src/sdr/plot/_filter.py index 8553ba469..b35dd48cc 100644 --- a/src/sdr/plot/_filter.py +++ b/src/sdr/plot/_filter.py @@ -13,8 +13,10 @@ @export def impulse_response(b: np.ndarray, a: np.ndarray = 1, N: Optional[int] = None, **kwargs): - """ - Plots the impulse response of a filter. + r""" + Plots the impulse response $h[n]$ of a filter. + + The impulse response $h[n]$ is the filter output when the input is an impulse $\delta[n]$. Arguments: b: The feedforward coefficients, $b_i$. @@ -37,10 +39,9 @@ def impulse_response(b: np.ndarray, a: np.ndarray = 1, N: Optional[int] = None, if N is None: if a.size == 1 and a[0] == 1: - # FIR filter - N = b.size + N = b.size # FIR filter else: - N = 100 + N = 100 # IIR filter # Delta impulse function d = np.zeros(N, dtype=np.float32) @@ -70,3 +71,64 @@ def impulse_response(b: np.ndarray, a: np.ndarray = 1, N: Optional[int] = None, plt.xlabel("Sample") plt.ylabel("Amplitude") plt.title("Impulse Response, $h[n]$") + + +@export +def step_response(b: np.ndarray, a: np.ndarray = 1, N: Optional[int] = None, **kwargs): + r""" + Plots the step response $s[n]$ of a filter. + + The step response $s[n]$ is the filter output when the input is a unit step $u[n]$. + + Arguments: + b: The feedforward coefficients, $b_i$. + a: The feedback coefficients, $a_j$. For FIR filters, this is set to 1. + N: The number of samples to plot. If `None`, the length of `b` is used for FIR filters and + 100 for IIR filters. + **kwargs: Additional keyword arguments to pass to :func:`matplotlib.pyplot.plot()`. + + See Also: + sdr.IIR + + Examples: + See the :ref:`iir-filter` example. + + Group: + plotting + """ + b = np.atleast_1d(b) + a = np.atleast_1d(a) + + if N is None: + if a.size == 1 and a[0] == 1: + N = b.size # FIR filter + else: + N = 100 # IIR filter + + # Unit step function + u = np.ones(N, dtype=np.float32) + + # Filter the impulse + zi = scipy.signal.lfiltic(b, a, y=[], x=[]) + s, zi = scipy.signal.lfilter(b, a, u, zi=zi) + + with plt.rc_context(RC_PARAMS): + label = kwargs.pop("label", None) + if np.iscomplexobj(s): + if label is None: + label = "real" + label2 = "imag" + else: + label = label + " (real)" + label2 = label + " (imag)" + plt.plot(np.arange(s.size), s.real, label=label, **kwargs) + plt.plot(np.arange(s.size), s.imag, label=label2, **kwargs) + else: + plt.plot(np.arange(s.size), s, label=label, **kwargs) + + if label: + plt.legend() + + plt.xlabel("Sample") + plt.ylabel("Amplitude") + plt.title("Step Response, $s[n]$") From d07919a4329cae68e9fc6be4dd1f63ffef6057eb Mon Sep 17 00:00:00 2001 From: mhostetter Date: Wed, 12 Jul 2023 19:53:02 -0400 Subject: [PATCH 10/20] Add zeros and poles plot in `sdr.plot.zeros_and_poles()` --- src/sdr/plot/_filter.py | 41 +++++++++++++++++++++++++++++++++++++++++ 1 file changed, 41 insertions(+) diff --git a/src/sdr/plot/_filter.py b/src/sdr/plot/_filter.py index b35dd48cc..dbb701324 100644 --- a/src/sdr/plot/_filter.py +++ b/src/sdr/plot/_filter.py @@ -132,3 +132,44 @@ def step_response(b: np.ndarray, a: np.ndarray = 1, N: Optional[int] = None, **k plt.xlabel("Sample") plt.ylabel("Amplitude") plt.title("Step Response, $s[n]$") + + +@export +def zeros_and_poles(b: np.ndarray, a: np.ndarray = 1, **kwargs): + r""" + Plots the zeros and poles of the filter. + + Arguments: + b: The feedforward coefficients, $b_i$. + a: The feedback coefficients, $a_j$. For FIR filters, this is set to 1. + **kwargs: Additional keyword arguments to pass to :func:`matplotlib.pyplot.plot()`. + + See Also: + sdr.IIR + + Examples: + See the :ref:`iir-filter` example. + + Group: + plotting + """ + z, p, _ = scipy.signal.tf2zpk(b, a) + unit_circle = np.exp(1j * np.linspace(0, 2 * np.pi, 100)) + + label = kwargs.pop("label", None) + if label is None: + z_label = "Zeros" + p_label = "Poles" + else: + z_label = label + " (zeros)" + p_label = label + " (poles)" + + with plt.rc_context(RC_PARAMS): + plt.plot(unit_circle.real, unit_circle.imag, color="k", linestyle="--", label="Unit circle") + plt.scatter(z.real, z.imag, marker="o", label=z_label) + plt.scatter(p.real, p.imag, marker="x", label=p_label) + plt.axis("equal") + plt.legend() + plt.xlabel("Real") + plt.ylabel("Imaginary") + plt.title("Zeros and Poles of $H(z)$") From 9b10378f4058523870d3dbead1f3d987b01e5445 Mon Sep 17 00:00:00 2001 From: mhostetter Date: Wed, 12 Jul 2023 20:22:17 -0400 Subject: [PATCH 11/20] Add frequency response plot in `sdr.plot.frequency_response()` --- src/sdr/plot/_filter.py | 60 +++++++++++++++++++++++++++++++++++++++++ 1 file changed, 60 insertions(+) diff --git a/src/sdr/plot/_filter.py b/src/sdr/plot/_filter.py index dbb701324..4d526e903 100644 --- a/src/sdr/plot/_filter.py +++ b/src/sdr/plot/_filter.py @@ -6,6 +6,7 @@ import matplotlib.pyplot as plt import numpy as np import scipy.signal +from typing_extensions import Literal from .._helper import export from ._rc_params import RC_PARAMS @@ -173,3 +174,62 @@ def zeros_and_poles(b: np.ndarray, a: np.ndarray = 1, **kwargs): plt.xlabel("Real") plt.ylabel("Imaginary") plt.title("Zeros and Poles of $H(z)$") + + +@export +def frequency_response( + b: np.ndarray, + a: np.ndarray = 1, + sample_rate: float = 1.0, + N: int = 1024, + x_axis: Literal["one-sided", "two-sided", "log"] = "two-sided", + decades: int = 4, + **kwargs, +): + r""" + Plots the frequency response $H(e^{j\omega})$ of the filter. + + Arguments: + b: The feedforward coefficients, $b_i$. + a: The feedback coefficients, $a_j$. For FIR filters, this is set to 1. + sample_rate: The sample rate of the filter in samples/s. + N: The number of samples in the frequency response. + x_axis: The x-axis scaling. Options are to display a one-sided spectrum, a two-sided spectrum, or + one-sided spectrum with a logarithmic frequency axis. + decades: The number of decades to plot when `x_axis="log"`. + **kwargs: Additional keyword arguments to pass to :func:`matplotlib.pyplot.plot()`. + + See Also: + sdr.IIR + + Examples: + See the :ref:`iir-filter` example. + + Group: + plotting + """ + if x_axis == "log": + w = np.logspace(np.log10(sample_rate / 2 / 10**decades), np.log10(sample_rate / 2), N) + w, H = scipy.signal.freqz(b, a, worN=w, whole=False, fs=sample_rate) + else: + w, H = scipy.signal.freqz(b, a, worN=N, whole=x_axis == "two-sided", fs=sample_rate) + + if x_axis == "two-sided": + w[w >= 0.5 * sample_rate] -= sample_rate # Wrap frequencies from [0, 1) to [-0.5, 0.5) + w = np.fft.fftshift(w) + H = np.fft.fftshift(H) + + with plt.rc_context(RC_PARAMS): + if x_axis == "log": + plt.semilogx(w, 10 * np.log10(np.abs(H) ** 2), **kwargs) + else: + plt.plot(w, 10 * np.log10(np.abs(H) ** 2), **kwargs) + + plt.grid(True, which="both") + + if sample_rate == 1.0: + plt.xlabel("Normalized Frequency, $f /f_s$") + else: + plt.xlabel("Frequency (Hz), $f$") + plt.ylabel(r"Power (dB), $|H(\omega)|^2$") + plt.title(r"Frequency Response, $H(\omega)$") From 8f90733413b998f9c29ef712c05e9366dfa62fbc Mon Sep 17 00:00:00 2001 From: mhostetter Date: Wed, 12 Jul 2023 20:33:34 -0400 Subject: [PATCH 12/20] Add group delay plot in `sdr.plot.group_delay()` --- src/sdr/plot/_filter.py | 59 +++++++++++++++++++++++++++++++++++++++++ 1 file changed, 59 insertions(+) diff --git a/src/sdr/plot/_filter.py b/src/sdr/plot/_filter.py index 4d526e903..cfbc6a2e1 100644 --- a/src/sdr/plot/_filter.py +++ b/src/sdr/plot/_filter.py @@ -233,3 +233,62 @@ def frequency_response( plt.xlabel("Frequency (Hz), $f$") plt.ylabel(r"Power (dB), $|H(\omega)|^2$") plt.title(r"Frequency Response, $H(\omega)$") + + +@export +def group_delay( + b: np.ndarray, + a: np.ndarray = 1, + sample_rate: float = 1.0, + N: int = 1024, + x_axis: Literal["one-sided", "two-sided", "log"] = "two-sided", + decades: int = 4, + **kwargs, +): + r""" + Plots the group delay $\tau_g(\omega)$ of the IIR filter. + + Arguments: + b: The feedforward coefficients, $b_i$. + a: The feedback coefficients, $a_j$. For FIR filters, this is set to 1. + sample_rate: The sample rate of the filter in samples/s. + N: The number of samples in the frequency response. + x_axis: The x-axis scaling. Options are to display a one-sided spectrum, a two-sided spectrum, or + one-sided spectrum with a logarithmic frequency axis. + decades: The number of decades to plot when `x_axis="log"`. + **kwargs: Additional keyword arguments to pass to :func:`matplotlib.pyplot.plot()`. + + See Also: + sdr.IIR + + Examples: + See the :ref:`iir-filter` example. + + Group: + plotting + """ + if x_axis == "log": + w = np.logspace(np.log10(sample_rate / 2 / 10**decades), np.log10(sample_rate / 2), N) + w, tau_g = scipy.signal.group_delay((b, a), w=w, whole=False, fs=sample_rate) + else: + w, tau_g = scipy.signal.group_delay((b, a), w=N, whole=x_axis == "two-sided", fs=sample_rate) + + if x_axis == "two-sided": + w[w >= 0.5 * sample_rate] -= sample_rate # Wrap frequencies from [0, 1) to [-0.5, 0.5) + w = np.fft.fftshift(w) + tau_g = np.fft.fftshift(tau_g) + + with plt.rc_context(RC_PARAMS): + if x_axis == "log": + plt.semilogx(w, tau_g, **kwargs) + else: + plt.plot(w, tau_g, **kwargs) + + plt.grid(True, which="both") + + if sample_rate == 1.0: + plt.xlabel("Normalized Frequency, $f /f_s$") + else: + plt.xlabel("Frequency (Hz), $f$") + plt.ylabel(r"Group Delay (samples), $\tau_g(\omega)$") + plt.title(r"Group Delay, $\tau_g(\omega)$") From 1f1914fafacdb5c3360a913fcd65f3c5072cf40b Mon Sep 17 00:00:00 2001 From: mhostetter Date: Wed, 12 Jul 2023 20:37:31 -0400 Subject: [PATCH 13/20] Rename `sdr.plot.zeros_and_poles()` to `sdr.plot.zeros_poles()` --- src/sdr/plot/_filter.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/sdr/plot/_filter.py b/src/sdr/plot/_filter.py index cfbc6a2e1..fcea74905 100644 --- a/src/sdr/plot/_filter.py +++ b/src/sdr/plot/_filter.py @@ -136,7 +136,7 @@ def step_response(b: np.ndarray, a: np.ndarray = 1, N: Optional[int] = None, **k @export -def zeros_and_poles(b: np.ndarray, a: np.ndarray = 1, **kwargs): +def zeros_poles(b: np.ndarray, a: np.ndarray = 1, **kwargs): r""" Plots the zeros and poles of the filter. From 03e72370e066d7fb6cf303cde6712aca7ed9957c Mon Sep 17 00:00:00 2001 From: mhostetter Date: Wed, 12 Jul 2023 20:47:49 -0400 Subject: [PATCH 14/20] Add generic filter plot in `sdr.plot.filter()` --- src/sdr/plot/_filter.py | 52 +++++++++++++++++++++++++++++++++++++++++ 1 file changed, 52 insertions(+) diff --git a/src/sdr/plot/_filter.py b/src/sdr/plot/_filter.py index fcea74905..8459fd228 100644 --- a/src/sdr/plot/_filter.py +++ b/src/sdr/plot/_filter.py @@ -292,3 +292,55 @@ def group_delay( plt.xlabel("Frequency (Hz), $f$") plt.ylabel(r"Group Delay (samples), $\tau_g(\omega)$") plt.title(r"Group Delay, $\tau_g(\omega)$") + + +@export +def filter( + b: np.ndarray, + a: np.ndarray = 1, + sample_rate: float = 1.0, + N_time: Optional[int] = None, + N_freq: int = 1024, + x_axis: Literal["one-sided", "two-sided", "log"] = "two-sided", + decades: int = 4, + **kwargs, +): + r""" + Plots the frequency response $H(e^{j\omega})$, impulse response $h[n]$, step response $s[n]$, + and zeros and poles of the filter. + + Arguments: + b: The feedforward coefficients, $b_i$. + a: The feedback coefficients, $a_j$. For FIR filters, this is set to 1. + sample_rate: The sample rate of the filter in samples/s. + N_time: The number of samples in the time domain. If `None`, the length of `b` is used + for FIR filters and 100 for IIR filters. + N_freq: The number of samples in the frequency response. + x_axis: The x-axis scaling. Options are to display a one-sided spectrum, a two-sided spectrum, or + one-sided spectrum with a logarithmic frequency axis. + decades: The number of decades to plot when `x_axis="log"`. + **kwargs: Additional keyword arguments to pass to :func:`matplotlib.pyplot.plot()`. + + See Also: + sdr.IIR + + Examples: + See the :ref:`iir-filter` example. + + Group: + plotting + """ + with plt.rc_context(RC_PARAMS): + plt.subplot2grid((4, 3), (0, 0), 2, 3) + frequency_response(b, a, sample_rate=sample_rate, N=N_freq, x_axis=x_axis, decades=decades) + + plt.subplot2grid((4, 3), (2, 0), 2, 1) + zeros_poles(b, a) + + plt.subplot2grid((4, 3), (2, 1), 1, 2) + impulse_response(b, a, N=N_time) + + plt.subplot2grid((4, 3), (3, 1), 1, 2) + step_response(b, a, N=N_time) + + plt.tight_layout() From 95f44ddfba2690b75c6334e1891b36cb1e42e316 Mon Sep 17 00:00:00 2001 From: mhostetter Date: Wed, 12 Jul 2023 20:50:24 -0400 Subject: [PATCH 15/20] Remove the plot methods from the IIR class Will use the function in `sdr.plot` instead --- src/sdr/_iir_filter.py | 184 +---------------------------------------- 1 file changed, 2 insertions(+), 182 deletions(-) diff --git a/src/sdr/_iir_filter.py b/src/sdr/_iir_filter.py index db4e34316..60344c3f3 100644 --- a/src/sdr/_iir_filter.py +++ b/src/sdr/_iir_filter.py @@ -41,8 +41,8 @@ def __init__(self, b: np.ndarray, a: np.ndarray, streaming: bool = False): Creates an IIR filter with feedforward coefficients $b_i$ and feedback coefficients $a_j$. Arguments: - b: Feedforward coefficients, $b_i$. - a: Feedback coefficients, $a_j$. + b: The feedforward coefficients, $b_i$. + a: The feedback coefficients, $a_j$. streaming: Indicates whether to use streaming mode. In streaming mode, previous inputs are preserved between calls to :meth:`filter()`. @@ -204,186 +204,6 @@ def frequency_response_log( return w, H - def plot_impulse_response(self, N: int = 100): - """ - Plots the impulse response $h[n]$ of the IIR filter. - - Arguments: - N: The number of samples in the impulse response. - - Examples: - See the :ref:`iir-filter` example. - """ - h = self.impulse_response(N) - - # plt.stem(np.arange(h.size), h.real, linefmt="b-", markerfmt="bo") - plt.plot(np.arange(h.size), h.real, color="b", marker=".", label="Real") - plt.plot(np.arange(h.size), h.imag, color="r", marker=".", label="Imaginary") - plt.legend(loc="upper right") - plt.xlabel("Sample") - plt.ylabel("Amplitude") - plt.title("Impulse Response, $h[n]$") - - def plot_step_response(self, N: int = 100): - """ - Plots the step response $s[n]$ of the IIR filter. - - Arguments: - N: The number of samples in the step response. - - Examples: - See the :ref:`iir-filter` example. - """ - u = self.step_response(N) - - # plt.stem(np.arange(u.size), u.real, linefmt="b-", markerfmt="bo") - plt.plot(np.arange(u.size), u.real, color="b", marker=".", label="Real") - plt.plot(np.arange(u.size), u.imag, color="r", marker=".", label="Imaginary") - plt.legend(loc="lower right") - plt.xlabel("Sample") - plt.ylabel("Amplitude") - plt.title("Step Response, $s[n]$") - - def plot_zeros_poles(self): - """ - Plots the zeros and poles of the IIR filter. - - Examples: - See the :ref:`iir-filter` example. - """ - unit_circle = np.exp(1j * np.linspace(0, 2 * np.pi, 100)) - z = self.zeros - p = self.poles - - plt.plot(unit_circle.real, unit_circle.imag, color="k", linestyle="--", label="Unit circle") - plt.scatter(z.real, z.imag, color="b", marker="o", facecolor="none", label="Zeros") - plt.scatter(p.real, p.imag, color="r", marker="x", label="Poles") - plt.axis("equal") - plt.legend(loc="upper left") - plt.xlabel("Real") - plt.ylabel("Imaginary") - plt.title("Zeros and Poles of $H(z)$") - - def plot_frequency_response(self, sample_rate: float = 1.0, N: int = 1024, phase: bool = True): - r""" - Plots the frequency response $H(\omega)$ of the IIR filter. - - Arguments: - sample_rate: The sample rate of the filter in samples/s. - N: The number of samples in the frequency response. - phase: Indicates whether to plot the phase of $H(\omega)$. - - Examples: - See the :ref:`iir-filter` example. - """ - w, H = self.frequency_response(sample_rate, N) - - ax1 = plt.gca() - ax1.plot(w, 10 * np.log10(np.abs(H) ** 2), color="b", label="Power") - ax1.set_ylabel(r"Power (dB), $|H(\omega)|^2$") - ax1.tick_params(axis="y", labelcolor="b") - ax1.grid(which="both", linestyle="--") - if sample_rate == 1.0: - ax1.set_xlabel("Normalized Frequency, $f /f_s$") - else: - ax1.set_xlabel("Frequency (Hz), $f$") - - if phase: - ax2 = ax1.twinx() - ax2.plot(w, np.rad2deg(np.angle(H)), color="r", linestyle="--", label="Phase") - ax2.set_ylabel(r"Phase (degrees), $\angle H(\omega)$") - ax2.tick_params(axis="y", labelcolor="r") - ax2.set_ylim(-180, 180) - - plt.title(r"Frequency Response, $H(\omega)$") - plt.tight_layout() - - def plot_frequency_response_log( - self, sample_rate: float = 1.0, N: int = 1024, phase: bool = True, decades: int = 4 - ): - r""" - Plots the frequency response $H(\omega)$ of the IIR filter on a logarithmic frequency axis. - - Arguments: - sample_rate: The sample rate of the filter in samples/s. - N: The number of samples in the frequency response. - phase: Indicates whether to plot the phase of $H(\omega)$. - decades: The number of frequency decades to plot. - - Examples: - See the :ref:`iir-filter` example. - """ - w, H = self.frequency_response_log(sample_rate, N, decades) - - ax1 = plt.gca() - ax1.semilogx(w, 10 * np.log10(np.abs(H) ** 2), color="b", label="Power") - ax1.set_ylabel(r"Power (dB), $|H(\omega)|^2$") - ax1.tick_params(axis="y", labelcolor="b") - ax1.grid(which="both", linestyle="--") - if sample_rate == 1.0: - ax1.set_xlabel("Normalized Frequency, $f /f_s$") - else: - ax1.set_xlabel("Frequency (Hz), $f$") - - if phase: - ax2 = ax1.twinx() - ax2.semilogx(w, np.rad2deg(np.angle(H)), color="r", linestyle="--", label="Phase") - ax2.set_ylabel(r"Phase (degrees), $\angle H(\omega)$") - ax2.tick_params(axis="y", labelcolor="r") - ax2.set_ylim(-180, 180) - - plt.title(r"Frequency Response, $H(\omega)$") - plt.tight_layout() - - def plot_group_delay(self, sample_rate: float = 1.0, N: int = 1024): - r""" - Plots the group delay $\tau_g(\omega)$ of the IIR filter. - - Arguments: - sample_rate: The sample rate of the filter in samples/s. - N: The number of samples in the frequency response. - - Examples: - See the :ref:`iir-filter` example. - """ - w, tau_g = scipy.signal.group_delay((self.b_taps, self.a_taps), w=N, whole=True, fs=sample_rate) - - w[w >= 0.5 * sample_rate] -= sample_rate - w = np.fft.fftshift(w) - tau_g = np.fft.fftshift(tau_g) - - plt.plot(w, tau_g, color="b") - if sample_rate == 1.0: - plt.xlabel("Normalized Frequency, $f /f_s$") - else: - plt.xlabel("Frequency (Hz), $f$") - plt.ylabel(r"Group Delay (samples), $\tau_g(\omega)$") - plt.title(r"Group Delay, $\tau_g(\omega)$") - plt.grid(which="both", linestyle="--") - plt.tight_layout() - - def plot_all(self, sample_rate: float = 1.0, N_time: int = 100, N_freq: int = 1024): - """ - Plots the zeros and poles, impulse response, step response, and frequency response of the IIR filter - in a single figure. - - Arguments: - sample_rate: The sample rate of the filter in samples/s. - N_time: The number of samples in the impulse and step responses. - N_freq: The number of samples in the frequency response. - - Examples: - See the :ref:`iir-filter` example. - """ - plt.subplot2grid((4, 3), (0, 0), 2, 1) - self.plot_zeros_poles() - plt.subplot2grid((4, 3), (0, 1), 1, 2) - self.plot_impulse_response(N=N_time) - plt.subplot2grid((4, 3), (1, 1), 1, 2) - self.plot_step_response(N=N_time) - plt.subplot2grid((4, 3), (2, 0), 2, 3) - self.plot_frequency_response(sample_rate=sample_rate, N=N_freq) - @property def b_taps(self) -> np.ndarray: """ From 7110b039e921eebf98b60e9be3eb95f8bfc7c6c2 Mon Sep 17 00:00:00 2001 From: mhostetter Date: Wed, 12 Jul 2023 20:52:40 -0400 Subject: [PATCH 16/20] Fix pylint errors --- src/sdr/_iir_filter.py | 1 - src/sdr/plot/__init__.py | 2 +- src/sdr/plot/_filter.py | 4 +--- 3 files changed, 2 insertions(+), 5 deletions(-) diff --git a/src/sdr/_iir_filter.py b/src/sdr/_iir_filter.py index 60344c3f3..c7e5d9739 100644 --- a/src/sdr/_iir_filter.py +++ b/src/sdr/_iir_filter.py @@ -3,7 +3,6 @@ """ from typing import Tuple -import matplotlib.pyplot as plt import numpy as np import scipy.signal from typing_extensions import Self diff --git a/src/sdr/plot/__init__.py b/src/sdr/plot/__init__.py index 98d2e1be7..789f76965 100644 --- a/src/sdr/plot/__init__.py +++ b/src/sdr/plot/__init__.py @@ -1,6 +1,6 @@ """ A subpackage for various plotting functions using :obj:`matplotlib`. """ -from ._filter import * +from ._filter import * # pylint: disable=redefined-builtin from ._rc_params import * from ._time_domain import * diff --git a/src/sdr/plot/_filter.py b/src/sdr/plot/_filter.py index 8459fd228..aa85cc726 100644 --- a/src/sdr/plot/_filter.py +++ b/src/sdr/plot/_filter.py @@ -295,7 +295,7 @@ def group_delay( @export -def filter( +def filter( # pylint: disable=redefined-builtin b: np.ndarray, a: np.ndarray = 1, sample_rate: float = 1.0, @@ -303,7 +303,6 @@ def filter( N_freq: int = 1024, x_axis: Literal["one-sided", "two-sided", "log"] = "two-sided", decades: int = 4, - **kwargs, ): r""" Plots the frequency response $H(e^{j\omega})$, impulse response $h[n]$, step response $s[n]$, @@ -319,7 +318,6 @@ def filter( x_axis: The x-axis scaling. Options are to display a one-sided spectrum, a two-sided spectrum, or one-sided spectrum with a logarithmic frequency axis. decades: The number of decades to plot when `x_axis="log"`. - **kwargs: Additional keyword arguments to pass to :func:`matplotlib.pyplot.plot()`. See Also: sdr.IIR From c37ad4cbd57e3c1647ce10a4ab8a598c66968b08 Mon Sep 17 00:00:00 2001 From: mhostetter Date: Wed, 12 Jul 2023 21:15:59 -0400 Subject: [PATCH 17/20] Update notebooks with new plot functions --- docs/examples/iir-filter.ipynb | 146 ++++++++++++++++---------- docs/examples/phase-locked-loop.ipynb | 104 +++++++++++++----- 2 files changed, 168 insertions(+), 82 deletions(-) diff --git a/docs/examples/iir-filter.ipynb b/docs/examples/iir-filter.ipynb index 936328926..24264a0d1 100644 --- a/docs/examples/iir-filter.ipynb +++ b/docs/examples/iir-filter.ipynb @@ -21,8 +21,7 @@ "import sdr\n", "\n", "%config InlineBackend.print_figure_kwargs = {\"facecolor\" : \"w\"}\n", - "# %matplotlib widget\n", - "colors = plt.rcParams[\"axes.prop_cycle\"].by_key()[\"color\"]" + "# %matplotlib widget" ] }, { @@ -52,7 +51,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "\n" + "\n" ] } ], @@ -121,7 +120,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "The impulse response is conveniently plotted using the {obj}`sdr.IIR.plot_impulse_response()` method." + "The impulse response is conveniently plotted using the {obj}`sdr.plot.impulse_response()` function." ] }, { @@ -131,7 +130,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -144,7 +143,7 @@ ], "source": [ "plt.figure(figsize=(10, 5))\n", - "iir.plot_impulse_response(30)\n", + "sdr.plot.impulse_response(iir.b_taps, iir.a_taps, 30, marker=\".\")\n", "plt.show()" ] }, @@ -180,6 +179,13 @@ "print(s)" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The step response is conveniently plotted using the {obj}`sdr.plot.step_response()` function." + ] + }, { "cell_type": "code", "execution_count": 7, @@ -187,7 +193,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -200,7 +206,7 @@ ], "source": [ "plt.figure(figsize=(10, 5))\n", - "iir.plot_step_response(30)\n", + "sdr.plot.step_response(iir.b_taps, iir.a_taps, 30, marker=\".\")\n", "plt.show()" ] }, @@ -259,7 +265,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "The zeros and poles are conveniently plotted in the complex plane using the {obj}`sdr.IIR.plot_zeros_poles()` method." + "The zeros and poles are conveniently plotted in the complex plane using the {obj}`sdr.plot.zeros_poles()` function." ] }, { @@ -269,7 +275,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -282,7 +288,7 @@ ], "source": [ "plt.figure(figsize=(5, 5))\n", - "iir.plot_zeros_poles()\n", + "sdr.plot.zeros_poles(iir.b_taps, iir.a_taps)\n", "plt.show()" ] }, @@ -295,7 +301,7 @@ "The frequency response is the transfer function $H(z)$ evaluated at the complex exponential\n", "$e^{j \\omega}$, where $\\omega = 2 \\pi f / f_s$.\n", "\n", - "The frequency response is conveniently plotted using the {obj}`sdr.IIR.plot_frequency_response()` method." + "The two-sided frequency response is conveniently plotted using the {obj}`sdr.plot.frequency_response()` function." ] }, { @@ -305,9 +311,9 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, "metadata": { @@ -318,7 +324,7 @@ ], "source": [ "plt.figure(figsize=(10, 5))\n", - "iir.plot_frequency_response()\n", + "sdr.plot.frequency_response(iir.b_taps, iir.a_taps)\n", "plt.show()" ] }, @@ -326,7 +332,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "The frequency response may also be plotted with a logarithmic frequency scale using the {obj}`sdr.IIR.plot_frequency_response_log()` method." + "The one-sided frequency response, with logarithmic scale, can be plotted using the `x_axis=\"log\"` keyword argument." ] }, { @@ -336,9 +342,9 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, "metadata": { @@ -349,7 +355,7 @@ ], "source": [ "plt.figure(figsize=(10, 5))\n", - "iir.plot_frequency_response_log()\n", + "sdr.plot.frequency_response(iir.b_taps, iir.a_taps, x_axis=\"log\")\n", "plt.show()" ] }, @@ -362,7 +368,7 @@ "The group delay $\\tau_g(\\omega)$ is the time shift of the envelope of a signal passed through the filter\n", "as a function of its frequency $\\omega$.\n", "\n", - "The group delay is conveniently plotted using the {obj}`sdr.IIR.plot_group_delay()` method." + "The group delay is conveniently plotted using the {obj}`sdr.plot.group_delay()` function." ] }, { @@ -372,7 +378,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -385,7 +391,31 @@ ], "source": [ "plt.figure(figsize=(10, 5))\n", - "iir.plot_group_delay()\n", + "sdr.plot.group_delay(iir.b_taps, iir.a_taps)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(10, 5))\n", + "sdr.plot.group_delay(iir.b_taps, iir.a_taps, x_axis=\"log\")\n", "plt.show()" ] }, @@ -395,21 +425,21 @@ "source": [ "## Fully analyze an IIR filter\n", "\n", - "The user can easily analyze the perform of a given IIR filter using the {meth}`sdr.IIR.plot_all()` method.\n", + "The user can easily analyze the perform of a given IIR filter using the {obj}`sdr.plot.filter()` function.\n", "\n", "Here is an IIR filter with one real zero and 8 complex poles." ] }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 15, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "\n" + "\n" ] } ], @@ -423,14 +453,14 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 16, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, "metadata": { @@ -441,7 +471,7 @@ ], "source": [ "plt.figure(figsize=(10, 8))\n", - "iir.plot_all(N_time=30)\n", + "sdr.plot.filter(iir.b_taps, iir.a_taps, N_time=30)\n", "plt.show()" ] }, @@ -464,14 +494,14 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 17, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, "metadata": { @@ -486,7 +516,7 @@ "iir = sdr.IIR.ZerosPoles(zeros, poles)\n", "\n", "plt.figure(figsize=(10, 8))\n", - "iir.plot_all(N_time=30)\n", + "sdr.plot.filter(iir.b_taps, iir.a_taps, N_time=30)\n", "plt.show()" ] }, @@ -499,14 +529,14 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 18, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, "metadata": { @@ -522,7 +552,7 @@ "iir = sdr.IIR.ZerosPoles(zeros, poles)\n", "\n", "plt.figure(figsize=(10, 8))\n", - "iir.plot_all(N_time=30)\n", + "sdr.plot.filter(iir.b_taps, iir.a_taps, N_time=30)\n", "plt.show()" ] }, @@ -536,7 +566,7 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 19, "metadata": {}, "outputs": [ { @@ -551,9 +581,9 @@ }, { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAsgAAAI4CAYAAAB3OR9vAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/NK7nSAAAACXBIWXMAAAsTAAALEwEAmpwYAADrnUlEQVR4nOzdd3wUdfrA8c+m915II4EklCQkIVQrIIKKiKh4gAWwexbkTk/x9Gc9z3rYsBzKCVjw1EMEVCwUu5RACCEQIKaHdFJIz+78/gi7JkJI281sJs/79eJFdnd25tnnyWyenf3Od3SKoigIIYQQQgghALBROwAhhBBCCCGsiTTIQgghhBBCtCENshBCCCGEEG1IgyyEEEIIIUQb0iALIYQQQgjRhjTIQgghhBBCtCENshBCCCGEEG1IgyyEEEIIIUQb0iALIYTQrAcffJCXXnqp288bP348Bw4cMH9AQoh+QRpkIUS/EBERgbOzM25ubqZ/hYWFaofV59rmYdCgQSxatIgTJ06oHVafO378ODqdjqysrHb3L168mFtuuQWA0tJS1qxZw2233dbt9d9333088sgjZolVCNH/SIMshOg3Nm7cyIkTJ0z/goOD2z3e0tKiUmR9y5iHlJQU9u7dy9NPP612SH0uJSUFNzc3IiIi2t2/f/9+EhMTAVi1ahUzZszA2dm52+ufNWsW27Zto6ioyAzRCiH6G2mQhRD9WkREBM8++yzx8fG4urrS0tJCYWEhV111Ff7+/gwZMoRXXnml3XP27t1LUlIS7u7uzJ07l3nz5vHwww8DoNPpOHr0qGnZRYsWmR4DzrjuiIgIXnjhBeLj4/H09GTu3Lk0NDSYHs/Ly+PKK6/E398fX19f7rrrLgCef/55rrrqqnYxLl68mHvuueeMr33QoEFcdNFFpKSktLv/TDE+++yzhISE4O7uzvDhw9myZYsp9qeffpqYmBi8vb254YYb2sV+8OBBJk+ejJeXF7GxsWzYsKHLr7ujbXZWpzNJSUkhJiYGnU7X7v4DBw4wevRoAL788ksmTZrU7vGamhpCQ0PZvn17u/vz8/PR6XSUl5cD4OTkxJgxY/jqq6+6HJMQQjukQRZC9Htr167l888/p7KyEhsbGy677DISEhIoKChgy5YtvPTSS6ZGp6mpidmzZ3P99ddTUVHB1Vdfzf/+978ubcdgMJxx3QAfffQRmzdvJisri9TUVFatWgWAXq9n5syZhIeHk52dTUFBAfPmzQPguuuuY/PmzVRWVgKtR8I//PBDFixYcMZ48vPz+fLLL4mKiupSjBkZGSxfvpxdu3ZRU1PDV1991e4I7Pvvv89XX31FZmYmhw8f5h//+AcAzc3NXHbZZUyfPp2SkhJeffVVrr32WjIyMjp93R1tsyu5PJO9e/cSFxfX7r7i4mLKy8uJj48HWo8mDx8+vN0y//rXv4iNjWXy5Mnt7g8JCcHV1ZX9+/eb7hs5ciT79u3rUjxCCG2RBlkI0W/Mnj0bLy8vvLy8mD17tun+xYsXExYWhrOzM7t27aK0tJRHHnkEBwcHhg4dyi233MKHH34IwK+//kpzczNLlizB3t6eOXPmMG7cuC5tv7N1G2MJDg7Gx8eHyy67zHR0d+fOnRQWFvL888/j6uqKk5MT5557LgBBQUGcf/75fPzxxwBs3rwZPz8/xowZ02Ee3N3dCQsLIyAggMcff7xLMdra2tLY2Eh6ejrNzc1EREQQGRlpeu5dd91FWFgYPj4+PPTQQ6xdu9aUsxMnTrB06VIcHBy44IILmDlzpunxM73ujrbZlVyeSUpKCmvXrsXPz8/0b8SIEURFReHm5gZAZWUl7u7upufo9XreeOMNbr75ZqB1jPJvv/0GtH5zYGdnR319vWl5d3d304cWIcTAYqd2AEII0VXr16/nwgsvPOX+sLAw0885OTkUFhbi5eVluk+v13PeeecBrV/rh4SEtPtqPjw8vEvb72zd0DrswcjFxcV0ImFeXh7h4eHY2Z3+bXfhwoW88cYb3HLLLbz33ntcf/31HcZhzMN3333HNddcQ1lZmSmmM8UYFRXFSy+9xGOPPcaBAwe46KKLWLZsmWksd9s8hoeHm2IvLCwkLCwMGxubdo8XFBR0+ro72mZXctmRxsZGDh48yEcffdTuw83rr79OZmam6ba3tzc1NTWm22lpaZSUlHDRRRcBsGzZMhRF4ZlnnqG+vp6amhoCAgJMy9fU1LSLTwgxcMgRZCFEv9e22Q0LC2PIkCFUVlaa/tXU1PDFF18ArUdrCwoKUBTF9Jzc3FzTzy4uLtTV1Zlutz1Jq7N1n0lYWBi5ubkdnkg4e/ZsUlNTSUtLY9OmTVx77bWdrnPSpEksWrSI++67r8sxXnPNNfz444/k5OSg0+l44IEHTM/Ny8trlxNj4xwcHExeXh4Gg6Hd4yEhIZ3G2NE2e5PLtLQ0DAYD06ZNIzQ01PTvyJEjpvHHAPHx8Rw+fNh0u6CgAG9vbzw8PIDWI/XGhvi7777D29u73fMPHjxIQkJCl16jEEJbpEEWQmjK+PHjcXd359lnn6W+vh69Xk9aWhq7du0C4KyzzsLOzo5XXnmF5uZm1q1bx86dO03PT0xM5IMPPkCv17N582a+++67Lq+7s7iCgoJYunQptbW1NDQ08NNPP5ked3JyYs6cOVxzzTWMHz+ewYMHd+n1LlmyhG+++cY0VvZMMWZkZLB161YaGxtxcnLC2dm53VHh1157jfz8fCoqKnjqqaeYO3cuABMmTMDFxYXnnnuO5uZmtm/fzsaNG01jqM+ko212JZeLFi1i0aJFp6xz7969xMTEmIZSGO3atcs0gwXAjBkz2tXPx8eH6upqsrKyWLt2LU1NTaSnp1NZWcljjz3GkiVLTPloaGggOTmZadOmdV4EIYTmSIMshNAUW1tbNm3aREpKCkOGDMHPz4+bb76ZqqoqABwcHFi3bh2rVq3Cx8eH//73v1x55ZWm57/88sts3LgRLy8v3n///XZjnTtbd2dxbdy4kaNHjzJ48GBCQ0P573//226ZhQsXsn///jMOr/gjf39/FixYwBNPPNFpjI2NjSxduhQ/Pz8GDRpESUlJuynirrnmGqZPn87QoUOJjIw0zd7h4ODAxo0b+fLLL/Hz8+OOO+5gzZo1jBgxotP4OtpmV3KZl5fHOeecc8o6U1JSThk3XlpaSk5OTrsGecGCBXzxxRemccXjxo1j3rx5JCYmsnLlSjZs2MDPP/9MdHQ0EyZMaHc0fePGjUyePPmUqQSFEAODTmn7PaMQQgxAixYtIjQ01DRrg1pyc3MZMWIERUVFpmEAfSUiIoK33377tGO81dDU1ERCQgKpqanY29v3eD1///vfCQgIYMmSJd163oQJE1i5cuUpM2UIIQYGOUlPCCGsgMFgYNmyZcybN6/Pm2Nr5ODgwMGDB3u9nn/+8589et6OHTt6vW0hRP8lDbIQQqistraWwMBAwsPD2bx5s9rhCCHEgCdDLIQQQgghhGhDTtITQgghhBCiDc0NsfDz82t36VRhfs3Nzb06aUZYL6mtdklttUnqql1SW8vKzs6mrKysw8c11yBHRESwe/dutcPQNEVR2l2YQWiH1Fa7pLbaJHXVLqmtZY0dO/aMj8sQC9FtbS/lKrRFaqtdUlttkrpql9RWXdIgi27rykURRP8ktdUuqa02SV21S2qrLmmQhRBCCCGEaEMaZNFt0dHRaocgLERqq11SW22SumqX1FZd0iCLbqurq1M7BGEhUlvtktpqk9RVu6S26pIGWXRbQUGB2iEIC5HaapfUVpukrtoltVWXNMhCCCGEEEK0obl5kIXlBQUFqR2CsBCprfakFVSRnHMc+xZn4vUG7G3luIiWyD6rXVJbdUmDLLrNw8ND7RCEhUhttef9Hbms3ZkLwKVjo/F0kQZZS2Sf1S6prbrknVJ0W0ZGhtohCAuR2mpPs95g+rmpzc9CG2Sf1S6prbqkQRZCCA1r2yA3S4MshBBdIg2y6DZ3d3e1QxAWIrXVHmmQtU32We2S2qpLGmTRbcOGDVM7BGEhUlvtaWpRTD9Lg6w9ss9ql9RWXdIgi27bs2eP2iEIC5Haak/bcceNLdIga43ss9oltVWXNMii2xRF6Xwh0S9JbbWnuaXtEAupr9bIPqtdUlt1SYMsuk2n06kdgrAQqa32yBhkbZN9VruktuqSBll0W1JSktohCAuR2mpPs96Ai4Nt688yxEJzZJ/VLqmtuqRBFt12+PBhtUMQFiK11Z4mvYKLg93Jn6VB1hrZZ7VLaqsuaZBFt9XU1KgdgrAQqa32NOsNuDqePIIsY5A1R/ZZ7ZLaqksaZCGE0LCmFsPvR5BliIUQQnSJNMii24YPH652CMJCpLba06w34GY6giwNstbIPqtdUlt1SYMsuq26ulrtEISFSG21p3WIhYxB1irZZ7VLaqsuq2qQ9Xo9o0ePZubMmQBkZWUxYcIEoqKimDt3Lk1NTSpHKACOHTumdgjCQqS22tPUYsD15BALOYKsPbLPapfUVl1W1SC//PLLjBw50nT7gQce4C9/+QtHjx7F29ublStXqhidEEL0P816RaZ5E0KIbrKaBjk/P5/PP/+cm2++GWi9gszWrVuZM2cOAAsXLmT9+vUqRiiMQkJC1A5BWIjUVnvaDrGQWSy0R/ZZ7ZLaqstO7QCMlixZwnPPPWea1qS8vBwvLy/s7FpDDA0NpaCg4LTPXbFiBStWrACgqKiI5ORkoPWXy8XFhSNHjgDg6elJZGSk6frmtra2JCYmcujQIWprawEYOXIkFRUVFBcXAxAWFoaDgwOZmZkAeHt7M3jwYPbt2weAvb098fHxpKenU19fD0BsbCwlJSWUlpYCEB4ejo2NDVlZWQD4+voSHBzM/v37AXB0dCQuLo60tDQaGxsBGDVqFIWFhZSXlwMwZMgQDAYDOTk5APj7+xMQEMCBAwcAcHZ2JiYmhtTUVJqbmwFISEggNzeX48ePAxAZGUlTUxN5eXkABAYG4uPjw8GDBwFwdXVlxIgRpKSkoNfrgdaJyjMzM6mqqgIgOjqauro6U46DgoLw8PAgIyMDAHd3d4YNG8aePXtQFAWdTkdSUhKHDx821Xb48OFUV1ebvj6SOlmuTsZ9pqt1Ki0tNT1H6mS9derq/mRQFFoMvx9BzsrNIyWlWupkZXWCnu9Per3e9H4sdbLeOvVkf6qurja9FqmT+evUGZ1iBRf73rRpE1988QWvv/4627dv54UXXmDVqlVMnDiRo0ePApCXl8cll1xCWlraGdc1duxYdu/e3RdhD1jJycmMGTNG7TCEBUhttaWhWc+I/9vM3y4azvNfZXDP1Gj+Mm2Y2mEJM5J9VruktpbVWb9oFUeQf/rpJzZs2MAXX3xBQ0MD1dXV3HPPPVRWVtLS0oKdnR35+fnydYMQQnSD8aQ8Rzsb7HRykp4QQnSVVYxBfvrpp8nPzyc7O5sPP/yQCy64gPfff58pU6bwySefALB69Wouv/xylSMV0PrVhdAmqa22GMcc29vaYGerkwZZg2Sf1S6prbqsokHuyLPPPsuyZcuIioqivLycm266Se2QBK1jkIQ2SW21xdgQ29va4GhvJyfpaZDss9oltVWX1TXIkydPZtOmTQAMHTqUnTt3cvToUT7++GMcHR1Vjk4ApkHvQnukttpivLS0va0OnUFPo0zzpjmyz2qX1FZdVtcgCyGEMA/jlfMc7Gyws5ExyEII0VXSIItus7W1VTsEYSFSW235/QiyDfa2OtNtoR2yz2qX1FZd0iCLbktMTFQ7BGEhUlttqW9unYfU2cEWTzcX022hHbLPapfUVl3SIItuO3TokNohCAuR2mpLQ9PJBtneFvRNNEiDrDmyz2qX1FZd0iCLbuvqVWhE/yO11Za6kw2yi4Mt9jrFdFtoh+yz2iW1VZc0yEIIoVHGIRUuDrY42emolwZZCCG6RBpk0W0jR45UOwRhIVJbbTE2xE72tvh7e8oYZA2SfVa7pLbqkgZZdFtFRYXaIQgLkdpqy+9HkO2wUVrkCLIGyT6rXVJbdUmDLLqtuLhY7RCEhUhttaWuzUl6hqYG6ppaVI5ImJvss9oltVWXNMhCCKFRxiPITvY2ONrpaGiWeZCFEKIrpEEW3RYWFqZ2CMJCpLbaUt/UgrO9LTqdjgAfL5r0BlrkanqaIvusdklt1SUNsug2BwcHtUMQFiK11Za6Jj0uDq1X43Jzsm+9T07U0xTZZ7VLaqsuaZBFt2VmZqodgrAQqa221DfrcT7ZIJ+obD3hp0FO1NMU2We1S2qrLmmQhRBCo+qb9K1X0QMc7HQAcrEQIYToAmmQRbd5e3urHYKwEKmtttQ3/z7EwtfTzXSf0A7ZZ7VLaqsuaZBFtw0ePFjtEISFSG21pa5Jj9PJI8iDgwedvE+metMS2We1S2qrLmmQRbft27dP7RCEhUhttaWmoQX3kyfnFeVlme4T2iH7rHZJbdUlDbIQQmhUTUMzHk52ALjY25y8TxpkIYTojDTIotvs7e3VDkFYiNRWW040tuB2skH2cLY33Se0Q/ZZ7ZLaqksaZNFt8fHxaocgLERqqx2KopwcYtHaII8f3VrbmoZmNcMSZib7rHZJbdUlDbLotvT0dLVDEBYitdWO+mY9eoNiGoOcczQDG50MsdAa2We1S2qrLmmQRbfV19erHYKwEKmtdhgbYeMR5IaGBtwc7aRB1hjZZ7VLaqsuaZCFEEKDjEMpjEeQjT9XyxALIYTolDTIottiY2PVDkFYiNRWO6qNR5AdW48gx8bG4u4kR5C1RvZZ7ZLaqksaZNFtJSUlaocgLERqqx0n/jDEoqSk5GSDLEeQtUT2We2S2qpLGmTRbaWlpWqHICxEaqsd1X8YYlFaWoqHkz3V9XIEWUtkn9Uuqa26pEEWQggNOl7X2iB7u/w+Btnb1YHjdU1qhSSEEP2GNMii28LDw9UOQViI1FY7KmtbG2EvFwegtba+rg6U1zahKIqaoQkzkn1Wu6S26pIGWXSbjY382miV1FY7jtc14+pgi4Nda01tbGzwcXWgqcVAbZNe5eiEucg+q11SW3VJ9kW3ZWVlqR2CsBCprXZU1jXh7epgup2VlYXPydsVJ2SYhVbIPqtdUlt1SYMshBAadLyuCW8Xh3b3+bq13i6vbVQjJCGE6DespkFuaGhg/PjxJCQkEBsby6OPPgq0foKaMGECUVFRzJ07l6YmOfKhNl9fX7VDEBYitdWO43XNeLU5Qc/X1xcfV0cAKmrlfVQrZJ/VLqmtunrcIH/zzTfccsstpKSkALBixYpeBeLo6MjWrVvZt28fKSkpbN68mV9//ZUHHniAv/zlLxw9ehRvb29WrlzZq+2I3gsODlY7BGEhUlvt+OMR5ODgYHxPDrEolyEWmiH7rHZJbdXV4wb5P//5D88//zzvvfceW7duNTXKPaXT6XBzcwOgubmZ5uZmdDodW7duZc6cOQAsXLiQ9evX92o7ovf279+vdgjCQqS22lFxosk05hhaa2u8XS5HkDVD9lntktqqy66nT3R3d8fLy4sXXniBpUuXsmvXrl4Ho9frGTNmDEePHuXOO+8kMjISLy8v7OxawwwNDaWgoOCU561YscJ0BLuoqIjk5GQAQkJCcHFx4ciRIwB4enoSGRnJnj17ALC1tSUxMZFDhw5RW1sLwMiRI6moqKC4uBiAsLAwHBwcyMzMBMDb25vBgwezb98+AOzt7YmPjyc9PZ36+nqg9fKQJSUlpkm+w8PDsbGxMQ249/X1JTg42PTL7+joSFxcHGlpaTQ2to4NHDVqFIWFhZSXlwMwZMgQDAYDOTk5APj7+xMQEMCBAwcAcHZ2JiYmhtTUVJqbW+c/TUhIIDc3l+PHjwMQGRlJU1MTeXl5AAQGBuLj48PBgwcBcHV1ZcSIEaSkpKDXt57lnpSURGZmJlVVVQBER0dTX19vynFQUBAeHh5kZGQArb8Xw4YNY8+ePSiKgk6nIykpicOHD1NTUwPA8OHDqa6u5tixY1InC9aprq7OtL90tU7V1dWm2kqdrLdOne1POntHahpbaK4p4+jRo0RGRlJRUcHB/Sk42EJFbaPUyQrqZI79qampybTPSp2st0492Z9qa2tNtZU6mb9OndEpPZwQ87PPPuPyyy833X711Ve5++67e7KqU1RWVnLFFVfw5JNPsmjRIo4ePQpAXl4el1xyCWlpaR0+d+zYsezevdsscYjTS0tLIy4uTu0whAVIbbUhp7yWSc9v54WrE5gzJhT4vbZnP72FiZG+LPtTorpBCrOQfVa7pLaW1Vm/2OMjyJdffjm5ubkd3m7Ly8sLDw+PLq/by8uLKVOm8Msvv1BZWUlLSwt2dnbk5+cTEhLS05CFmcgOq11SW20orm49ghTo4Wi6z1hbHzcHOUlPQ2Sf1S6prbp63CBD65hgnU53xqsy6XQ6Fi1axIIFC864rtLSUuzt7fHy8qK+vp5vvvmGBx54gClTpvDJJ58wb948Vq9e3e6otVCHfKrVLqmtNpTUNAAQ4O5kus9YWx9XR2mQNUT2We2S2qqrVw3ytm3bzBUHx44dY+HChej1egwGA3/605+YOXMmMTExzJs3j4cffpjRo0dz0003mW2bomeM45uE9khtteF0R5CNtfVzdSCz5IQqcQnzk31Wu6S26upVg/xHtbW1ODk5YWtr2+3nxsfHs3fv3lPuHzp0KDt37jRHeEIIMSCU1DTgYGeDp7P9KY/5ujlQdqLRdPKLEEKIU/XqQiEGg4EPPviASy+9lICAAIYPH86gQYOIiYnhb3/7m+nkOqEto0aNUjsEYSFSW20oqW7E382xXQNsrG2ghxONLQYq65rVCk+Ykeyz2iW1VVevGuQpU6aQmZnJ008/TVFREfn5+ZSWlvLjjz8yceJEHnjgAd577z1zxSqsRGFhodohCAuR2mpDSU1Du+EV8HttQ7ycASiorO/zuIT5yT6rXVJbdfVqiMW3336Lvf2pX+H5+Phw1VVXcdVVV5nm0hPaUV5eTkREhNphCAuQ2mpDcXUjUf5u7e4z1jb4ZIN8rKqBuBBPNcITZiT7rHZJbdXVqyPIp2uOe7KMEEII8ympPvUIspGxQS6UI8hCCNEhs5ykt3jxYg4dOoROpyMhIYFrrrmGxMREc6xaWKEhQ4aoHYKwEKlt/9fQrKe6oYUAD6d29xtr6+vqgIOdjTTIGiH7rHZJbdVllgY5JiaGyy67jObmZtLT07nuuuu4/fbbueuuu8yxemFlDAaD2iEIC5Ha9n/5x1sb3yDP9g2ysbY2NjqCPJ0orGro89iE+ck+q11SW3X1aoiF0e233860adOYMWMG9913H7t37+bf//63OVYtrJDxOu5Ce6S2/V9eRR0A4b4u7e5vW9tgT2c5gqwRss9ql9RWXWadB/nNN9/k6NGj1NTUdOvS0kIIIcwj92SDHObj0uEywV7O/JJZ1lchCSFEv2OWI8hGM2bMYOTIkeTn5/Pggw+ac9XCivj7+6sdgrAQqW3/l1tRh5O9Df5u7U/Sa1vbEC8niqobaNHLV7j9neyz2iW1VZdZGuSrr76agwcPMnjwYG666SY2btzIQw89ZI5VCysUEBCgdgjCQqS2/V9uRR2DfVxOuUpe29oGezljUFqnehP9m+yz2iW1VZdZGuTrr7+euXPnMmrUKBYtWsSf/vQnbGzMenBaWJEDBw6oHYKwEKlt/5d3skH+o7a1Dfd1BSCnvK7P4hKWIfusdklt1dWrMciKoqDT6Zg1axazZs1i37597Nu3D4PBwIwZM9otI4QQwrIURSGvoo6zIn3PuFykf2uD/FvZCc6N9uuL0IQQol/p9aWmX331VXJzcwFISEhgwYIFXHPNNaSlpbFw4UJWr15tlkCF9XB2dlY7BGEhUtv+raK2idomPeGnOYLctrb+7o64OtjyW2ltX4YnLED2We2S2qqrV0eQN2/ezH/+8x/mz59PVlYWXl5eNDQ0oNfrmT59OkuWLGH06NHmilVYiZiYGLVDEBYite3fcs4wg0Xb2up0Oob4u/JbmTTI/Z3ss9oltVVXr44gOzk5cccdd/DTTz+Rk5PDli1b2LNnDzk5Obz11lvSHGtUamqq2iEIC5Ha9m9Hi08AEBXgdspjf6ztED83sspO9ElcwnJkn9Uuqa26etUgZ2RkoCgKAPb29gQFBeHl5WWOuIQVa25uVjsEYSFS2/7tcHENjnY2hHqfegT5j7Ud6udK/vF6Glv0fRWesADZZ7VLaquuXg2xmDNnDjk5OQwbNoz4+HhGjRpl+l+mJxFCiL51pOQEUQFu2Np0fmL0UH9XFKV1Jothge59EJ0QQvQfvWqQ9+/fT2NjI6mpqcyYMQNXV1c2bdpkmpqkqKjILEEK65KQkKB2CMJCpLb925HiGsYP8TntY3+s7VC/1mEYR0tOSIPcj8k+q11SW3X1erJiR0dHxo0bh5ubG6+++ipbtmyhqKiIgwcPmiM+YYWMs5YI7ZHa9l81Dc0UVjUQ3UGz+8faRge6YaODg8eq+yI8YSGyz2qX1FZdZruaxx/nOvb29jbXqoWVOX78uNohCAuR2vZfR0taT7iLPs0JenBqbZ3sbRnq7yYNcj8n+6x2SW3V1ashFnfeeSdJSUkkJSWZTtYTQgjR9w4X1wB0a7jEyCAP9uTIH2EhhPijXjXICQkJpKSksGbNGmpqaoiJiSE2NpaYmBhiYmKYO3euueIUViQyMlLtEISFSG37r7SCatwc7U57mWk4fW1HBrmzcV8hVXXNeLrYWzpEYQGyz2qX1FZdvWqQb7311na38/Pz2b9/P6mpqWzatEkaZI1qampSOwRhIVLb/iu1oIrYYA9sOpjB4nS1HRnkAcDBomomDj3z5amFdZJ9VrukturqVYN8ugHksbGxxMbGtnvcy8sLDw+P3mxKWJG8vDyZxk+jpLb9U7PewMFj1SyYGN7hMqerbezJBvlAoTTI/ZXss9oltVVXrxrkhQsXnvZ+4wl7iqKg0+lYtGgRCxYs6M2mhBBCdOBI8QmaWgyMCvXs1vMCPJwY5OHEvrxKywQmhBD9VK8a5G3btpkrDtGPBAYGqh2CsBCpbf+UVlAFwKiQjhvkjmqbGOZFijTI/Zbss9oltVWX2aZ5EwOHj8/pL0Qg+j+pbf+Ukl+Ju6MdEb6uHS7TUW1HD/Yit6KO8hONlgpPWJDss9oltVWXNMii2+QiMNolte2fkrOPkxTu3eEJetBxbRPDvADkKHI/Jfusdklt1SUNshBC9GNVdc1kFNcwNrxnF2caFeqJrY2OvbmV5g1MCCH6MWmQRbe5unb8Na7o36S2/U9ybgUAYyPO/HVsR7V1cbAjNtiDnVkVZo9NWJ7ss9oltVWXRRrkY8eO0dgo49m0asSIEWqHICxEatv/7M4+jp2NzjRUoiNnqu1Zkb7szTtOXVOLmaMTlib7rHZJbdVlkQb5+uuvZ8SIEdx3331dfk5eXh5TpkwxXY3v5ZdfBqCiooJp06YRHR3NtGnT5NrkViAlJUXtEISFSG37n19/KycuxBNnB9szLnem2p4d6UezXmFXtry/9jeyz2qX1FZdFmmQv/32W3777TduuOGGLj/Hzs6Of/3rX6Snp/Prr7/y2muvkZ6ezjPPPMPUqVM5cuQIU6dO5ZlnnrFEyKIb9Hq92iEIC5Ha9i9V9c2k5FVyfrRfp8ueqbbjIryxt9Xxc2aZOcMTfUD2We2S2qrLrA1ybW2tqaA6nc50Rb2uCAoKIikpCQB3d3dGjhxJQUEBn332memCJAsXLmT9+vXmDFkIIfqtn4+WYVDgvGH+vVqPi4Mdo8O8+SWz3EyRCSFE/9arC4UYDAY+/PBD3n//fXbt2oWjoyMNDQ34+/tz6aWXcttttxEVFdXt9WZnZ7N3714mTJhAcXExQUFBAAwaNIji4uJTll+xYgUrVqwAoKioiOTkZABCQkJwcXHhyJEjAHh6ehIZGcmePXsAsLW1JTExkUOHDlFbWwvAyJEjqaioMG0nLCwMBwcHMjMzAfD29mbw4MHs27cPAHt7e+Lj40lPT6e+vh5ovdx2SUkJpaWlAISHh2NjY0NWVhYAvr6+BAcHs3//fgAcHR2Ji4sjLS3NNHZ71KhRFBYWUl7e+gdryJAhGAwGcnJyAPD39ycgIIADBw4A4OzsTExMDKmpqTQ3NwOQkJBAbm6uaVhKZGQkTU1N5OXlAa2TkPv4+JimknF1dWXEiBGkpKSYPugkJSWRmZlJVVXrhQiio6MJDg425TgoKAgPDw8yMjKA1g83w4YNY8+ePaYrKSYlJXH48GFqamoAGD58ONXV1Rw7dkzqZME61dXVUVBQ0K06ubu7m2ordbLeOhn3p3XJVbg62BJoW9/p+x5AcnJyh3WK9bdn9a4KvvtlFyMjw6VOZqwTWG5/Gjp0qKn2UifrrVNP9id/f39TbaVO5q9TZ3SKoihdWvI0Jk2axIUXXsjll19OXFwcNjatB6QrKirYtm0bH3zwAVdccQXXXXddl9d54sQJJk2axEMPPcSVV16Jl5cXlZWVpse9vb3POA557Nix7N69u6cvSXTB0aNHe/TBR1g/qW3/oSgK5z67jdhgD1YsGNvp8p3Vdsdv5cxd8StvXpfExXFB5gxVWJDss9oltbWszvrFXh1B/vbbb7G3t293X1lZGb6+vlx11VVcddVVpk8hXdHc3MxVV13Ftddey5VXXgm0fjo5duwYQUFBHDt2jICAgN6ELMzA+ClQaI/Utv/IKquloLKe2ydHdmn5zmqbFO6Nu5Md3x4skQa5H5F9Vrukturq1Rjk5ORkJk+ezJVXXsnevXuJi4sjLi6OwMBANm/eDHBKA90RRVG46aabGDlyJH/9619N98+aNYvVq1cDsHr1ai6//PLehCyEEJrw3eHWr8i7coJeV9jb2jBleABbD5WgN/T4i0UhhNCEXjXId911F3//+9+ZP38+F1xwAW+//TZFRUV8//33PPjgg91a108//cS7777L1q1bSUxMJDExkS+++IKlS5fyzTffEB0dzbfffsvSpUt7E7Iwg+joaLVDEBYite0/NqcVMSzQjXDfrl1MoCu1nR4bSEVtE3tyZbq3/kL2We2S2qqrV0MsWlpamD59OgCPPPIIEydOBHo2ufW5555LR8Oht2zZ0vMghdnV1dXh4eGhdhjCAqS2/UNpTSM7syu4+4Ku/wHtSm0nDfPH3lbHN+nFjOvkynzCOsg+q11SW3X16giy8aQ8aD37sS2dTtebVQsrZjzzVGiP1LZ/+Dq9CEWBGaMGdfk5Xamtu5M9Z0X68U16cYcHLIR1kX1Wu6S26urVEeR9+/bh4eGBoijU19ebPukoikJDQ4NZAhRCCNHel/uLGOLnyvBAd7Ove3pMIA+vT+PgsRpiguXolRBiYOrVEWS9Xk91dTU1NTW0tLRQXV1tut2d2StE/2Kcl1poj9TW+h2vbeKX38q5OG5Qt76p62ptZ4wKws5Gx2cpcvSqP5B9VruktuqyyKWmhbbJmCjtktpav42phegNCjPju/fHs6u19XF1YPJwfz5LKZTZLPoB2We1S2qrrl4NsVi2bNkZH287XZvQjoyMDMaMGaN2GMICpLbW75PkfEYGeRAb7Nmt53WntrNHh/DtwRJ2/FbO2VHmmUZOWIbss9oltVVXrxpk4yX/MjIy2LVrF7NmzQJg48aNjB8/vvfRCSGEMMkoqiE1v4r/mxlj0e1cODIQN0c71u0tkAZZCDEg9apBfvTRRwE4//zz2bNnD+7urSeMPPbYY1x66aW9j05YJWOdhfZIba3bJ8l52NnomJ0Y3O3ndqe2Tva2XDoqiI2phTx6WQzuTl274JPoe7LPapfUVl1mGYNcXFyMg4OD6baDgwPFxcXmWLWwQsOGDVM7BGEhUlvr1dRi4NO9BUwZEYCvm2O3n9/d2l4zYTB1TXo+3Ssn61kz2We1S2qrLrM0yAsWLGD8+PE89thjPPbYY0yYMIFFixaZY9XCCu3Zs0ftEISFSG2t1xf7j1F2oolrJwzu0fO7W9uEMC9GhXjy3q85MieyFZN9VruktuoyS4P80EMP8c477+Dt7Y23tzfvvPNOty81LfoP+WOpXVJb67Xq52yG+LlyfrR/j57fk9peN3Ewh4tPsCtbLj1trWSf1S6prbp6NQZZURTTPJxJSUkkJSWdcRmhDVJP7ZLaWqd9eZWk5FXy6GUx2Nj0rEY9qe1lCcE89flB3vkpi/FD5NLT1kj2We2S2qqrV0eQp0yZwquvvkpubm67+5uamti6dSsLFy5k9erVvQpQWJ/TfRAS2iC1tU6rfs7G1cGWOWNCe7yOntTWxcGO688KZ/OBIn4rPdHjbQvLkX1Wu6S26upVg7x582ZsbW2ZP38+wcHBxMTEMGTIEKKjo1m7di1LliyRscgadPjwYbVDEBYitbU+ueV1bNhXyLzxg3s1m0RPa7vo7CHY29rw1g+/9XjbwnJkn9Uuqa26ejXEwsnJiTvuuIM77riD5uZmysrKcHZ2xsvLy0zhCWtknP9aaI/U1vr8+/tMbHU6bjlvaK/W09Pa+rs78qexoXy0K58lFw4j0MOpV3EI85J9Vruktuoy26Wm7e3tCQoKkuZYCCHMpKS6gY9353PVmFAGearXmN56XiQtBgP/+TFLtRiEEKIvma1BFgPH8OHD1Q5BWIjU1rq8tu0oekXh9km9O3oMvavtYF8XLksI5t1fcyitaex1LMJ8ZJ/VLqmtunrdICuKQl5enjliEf1EdXW12iEIC5HaWo/c8jo+2JnLn8aGEe7r2uv19ba290yNprHFwPKtR3odizAf2We1S2qrrl43yDqdjhkzZpgjFtFPHDt2TO0QhIVIba3Hsm8ysLXRseTCaLOsr7e1HervxtxxYby/I5ec8lqzxCR6T/ZZ7ZLaqsssQyySkpLYtWuXOVYlhBADXnphNZ/tK+SGc4ZY1Ulx90yNxs5Wx7++lrPrhRDaZpYGeceOHUycOJHIyEji4+MZNWoU8fHx5li1sEIhISFqhyAsRGqrPkVRePrLg3g42XP7pEizrdcctQ30cOLGc4awYV8h+/Iqex+U6DXZZ7VLaquuXk3zZvTVV1+ZYzWin3BxcVE7BGEhUlv1fZlWxA9Hynjsshg8nXs+7/Efmau2f54cycfJ+fzfZ2l8esc52Pbwyn7CPGSf1S6prbrMcgR58ODB/PDDD6xevZrw8HB0Oh3FxcXmWLWwQkeOyEk6WiW1VVdtYwtPbkonJsiD6yaGm3Xd5qqtu5M9D186ktT8Kj7cldv5E4RFyT6rXVJbdZmlQb7jjjv45ZdfWLt2LQDu7u7ceeed5li1EEIMGK9sPcKxqgaenB2Hna31zsI5KyGYiUN9eG5zBhW1TWqHI4QQZme2McivvfYaTk6tJ5N4e3vT1CRvmlrl6empdgjCQqS26jlQWMXKH7K4ekwoY8K9zb5+c9ZWp9Px5OVx1Da28I9N6WZbr+g+2We1S2qrLrM0yPb29uj1enS61rFopaWl2NhY79EP0TuRkeY7cUhYF6mtOppaDNz3cSrerg78fcZIi2zD3LWNDnTnjilRrNtbwDfpMqROLbLPapfUVl1m6WIXL17MFVdcQUlJCQ899BDnnnsuf//7382xamGF9uzZo3YIwkKktupYvu0oB49V888rRuHt6mCRbViitndNiWJkkAd//3Q/x2WohSpkn9Uuqa26zDKLxbXXXsuYMWPYsmULiqKwfv16Ro60zFEQIYTQktT8Sl7bdpQrR4cwLSZQ7XC6xcHOhheujufy5T/xyIYDvDIv0fRNohBC9GdmaZCvu+46Jk2axNSpUxkxYoQ5VimsmK2trdohCAuR2vat6oZm7vpgLwHujjxyWYxFt2Wp2sYGe3LP1Gj+9c1hzo3yZe64wRbZjjg92We1S2qrLrMMsbjppps4duwYd999N0OHDuWqq67i5ZdfNseqhRVKTExUOwRhIVLbvqMoCg/+bz8FlfW8On80Xi6WGVphZMna3jElinOifHnkswMcKqq22HbEqWSf1S6prbrM0iBPmTKFhx56iCeffJJbbrmF3bt388Ybb5hj1cIKHTp0SO0QhIVIbfvOe7/m8Pn+Y9w3fThjI3wsvj1L1tbWRsdLc0fj7mTPne/vobaxxWLbEu3JPqtdUlt1maVBnjp1Kueccw7//e9/GT58OLt27ZLCalhtba3aIQgLkdr2jX15lTy56SCTh/tz2/lD+2Sblq6tv7sjr8xL5LeyWv7+6X4URbHo9kQr2We1S2qrLrM0yPHx8Tg4OJCWlkZqaippaWnU19d3ax033ngjAQEBxMXFme6rqKhg2rRpREdHM23aNI4fP26OcIUQQjVFVQ3csmY3AR6OLPtTIjYaulTz2VF+3DttGJ+lFPL69ky1wxFCiB4zS4P84osv8v3337Nu3Tp8fX254YYb8PLy6tY6Fi1axObNm9vd98wzzzB16lSOHDnC1KlTeeaZZ8wRruglmaFEu6S2llXfpOeWNbupbWxh5cJx+FhoSrfT6ava3jklilkJwTz/VQZfHyjqk20OZLLPapfUVl1maZCXL1/O3LlzGT16NJ999hk33ngjX375ZbfWcf755+Pj034c3meffcbChQsBWLhwIevXrzdHuKKXKioq1A5BWIjU1nIMBoX7PtlHWmEVr8wfzfBB7n26/b6qrU6n47k58SSEerLkvymkF8pJe5Yk+6x2SW3VZZZp3hoaGvjrX//KmDFjsLMzyyoBKC4uJigoCIBBgwZRXHz6qzWtWLGCFStWAFBUVERycjIAISEhuLi4cOTIEaD1so2RkZGmybdtbW1JTEzk0KFDprE+I0eOpKKiwrStsLAwHBwcyMxs/brQ29ubwYMHs2/fPqD1KoLx8fGkp6ebhpXExsZSUlJCaWkpAOHh4djY2JCVlQWAr68vwcHB7N+/HwBHR0fi4uJIS0ujsbERgFGjRlFYWEh5eTkAQ4YMwWAwkJOTA4C/vz8BAQEcOHAAAGdnZ2JiYkhNTaW5uRmAhIQEcnNzTUNTIiMjaWpqIi8vD4DAwEB8fHw4ePAgAK6urowYMYKUlBT0ej0ASUlJZGZmUlVVBUB0dDTZ2dmm/AQFBeHh4UFGRgYA7u7uDBs2jD179qAoCjqdjqSkJA4fPkxNTQ0Aw4cPp7q6mmPHjkmdLFinuro6CgoKulWnI0eOmHIqdTJfnVpaWli1r4bPj9Rxy3h/vOrySU7O73GderI/HTx4kOLi4j6r07Mzh7Lw/QNcu+InnrrAh5jBgVZfJ3PvT33xvpeXl2e6PVD2p/5Yp57sT7/99ptpHVIn89epMzrFTGdS7Nu3jx9++AGA8847j4SEhG6vIzs7m5kzZ5KWlgaAl5cXlZWVpse9vb07HYc8duxYdu/e3e1ti65LTk5mzJgxaochLEBqaxmvbTvK819lsOjsCB69LEaVi2moUdvDxTVc/eYveLvY8/HtZ+Pv7tin2x8IZJ/VLqmtZXXWL5pliMUrr7zCtddeS0lJCSUlJVx33XW8+uqrvV5vYGCg6dPBsWPHCAgI6PU6Re+FhYWpHYKwEKmt+a3dmcvzX2UwOzGYR2aq0xyDOrUdFujOfxaNo7i6kUXv7KS6obnPY9A62We1S2qrLrM0yG+//TY7duzgiSee4IknnuDXX3/lrbfe6vV6Z82axerVqwFYvXo1l19+ea/XKXrPwaHvTiwSfUtqa16fJOfz90/3M3m4P89fnaDqjBVq1XZMuDdvXJdERlENi/4jTbK5yT6rXVJbdZmlQVYUpd0lEW1tbbs9B+b8+fM566yzyMjIIDQ0lJUrV7J06VK++eYboqOj+fbbb1m6dKk5whW9ZBxHJbRHams+H+3K42+f7OOcSD/euHYM9rZmebvtMTVrO3l4AMuvSSI1v4oFK3dSVS9NsrnIPqtdUlt1meWMuhtuuIEJEyZwxRVXALB+/Xpuuummbq1j7dq1p71/y5YtvY5PCCH60tqduTy4bj/nRfvx1oKxONnbdv4kjbs4bhCvX5vEnR/s4fqVO3j3xgl4utirHZYQQpyWWQ5p/PWvf+Wdd97Bx8cHHx8f3nnnHZYsWWKOVQsr5O3trXYIwkKktr236qcsHlzXOqzCmppja6jt9NhBvHHtGA4dq+Gat3+ltKZR7ZD6PWuoq7AMqa26ejWLRUNDA2+++SZHjx5l1KhR3HTTTWad5q0nZBYLy2tpaVG9zsIypLY9pygKz32VwRvbM7lwZCCvXTsaRzvraI7Bumq7LaOEP7+XTKCHE6tvGE+En6vaIfVb1lRXYV5SW8uy6CwWCxcuZPfu3YwaNYovv/yS++67rzerE/2Ece5GoT1S255p1hu49+N9vLE9k/njB/PmdUlW1RyDddV2yvAAPrhlItX1zVz1xs+k5leqHVK/ZU11FeYltVVXrz6apKenmyapvummmxg/frxZghJCiP6iuqGZuz7Yy/eHS/nLhcNYPDVKtanc+pOkwd588uezWbByJ/NW/Mrya0ZzwYhAtcMSQgigl0eQ7e1/P8FCvgYYONrWXWiL1LZ7MktPMPu1n/j5aBnPXDmKey6Mttrm2BprG+nvxqd3nM1Qf1duWr2b17cf7fYMSAOdNdZVmIfUVl29GoNsa2uLq2vr2DFFUaivr8fFxcV0acDq6mqzBdpVMgZZCNEXtmWUsHjtXuxtbXjj2iQmDPVVO6R+q75Jz/3/S2XjvkJmxgfx/JwEnB2sa4iKEEJbLDoGWa/XU11dTXV1NTU1NbS0tJh+VqM5Fn0jPT1d7RCEhUhtO6coCm9sz+TGVbsI83Zhw13n9Ivm2Jpr6+xgyyvzEnng4hF8vv8Yc978mbyKOrXD6hesua6id6S26lJ35nrRL9XX16sdgrAQqe2ZVdQ2cdPq3Ty7+RAzRgXxyZ/PItTbRe2wusTaa6vT6fjz5Ej+s3AcueV1XPrKD3x1oEjtsKyetddV9JzUVl3SIAshRBfs+K2cGS//wI9Hynh8VizL54/GxUHOvTC3KSMC2LT4XCL8XLnt3WQe/SyNhma92mEJIQaYXo1BtkYyBtnyGhoacHJyUjsMYQFS21O16A28vj2Tl749zGAfF5Zfk0RciKfaYXVbf6ttU4uBZzcfYuWPWcQEefDqNaOJ9HdTOyyr09/qKrpOamtZFh2DLAamkpIStUMQFiK1be9oSQ1XvfkLy745zKyEYDYtPq9fNsfQ/2rrYGfD/82MYeXCsRRW1TPj5R94+4ff0Bs0dUyn1/pbXUXXSW3VJQ2y6LbS0lK1QxAWIrVtpTcorPg+kxmv/EhOeS2vzh/Ni3MTcXPsv0Mq+mttp44M5Osl53NulB//+Pwg81b8QnZZrdphWY3+WlfROamtuqRBFkKINn4rPcHVb/7MP784xKRh/nz9l/O5LCHYauc3HggCPJx4e+FY/nV1AoeKarj45e9Z9VMWBjmaLISwkP57OESoJjw8XO0QhIUM5No2NOt5fXsmb27PxNnBlpfmJnJ5onYa4/5eW51Ox1VjQjknyo+l61J5bGM6n6YU8tTsuH477MUc+ntdRcektuqSBll0m42NfPGgVQO1tt8dLuWRz9LIKa/j8sRgHpoxkgAPbZ0co5XaDvJ04p1F41ifUsBTnx9k1vIfWXBWBPdOH4a708C78phW6ipOJbVVl2RfdFtWVpbaIQgLGWi1Lays587397DwPzux1el4/+YJvDxvtOaaY9BWbXU6HVeMDmXLXydz7YRwVv+SzdR/fcdnKQUD7lLVWqqraE9qqy45giyEGHBONLbwxvajvP1D6x+ge6cN49ZJQ3G0k8sb9yeeLvY8OTuOOWNCeXh9Gvd8mMKqn7N5+NIYxoR7qx2eEKIfkwZZdJuvr/VfVlf0jNZr26I38NHufJZ9k0HZiSZmJwbzt4tHEOLlrHZoFqfl2iaEebH+znP43558Xvgqg6ve+JlL44NYevEIwnz6x5UOe0rLdR3opLbqkguFiG5ramrCwcFB7TCEBWi1toqisPVQCc9uPsTh4hOMj/DhoUtHkhDmpXZofUartf2juqYWVnz/G//+rnXO5IVnh/PnyVH4uGrztQ+Uug5EUlvLkguFCLPbv3+/2iEIC9FabRVF4fvDpVzx+s/ctHo3TS0G3rwuif/eNnFANcegvdp2xMXBjiUXDmP73yZzeWIwb/+YxXnPbuWFrzKoqmtWOzyzGyh1HYiktuqSIRZCCE36ObOMF785zK7s44R4OfPMlaO4akwo9rZyXGAgCPRw4vmrE7ht0lBe/PYIy7cdZfUv2dx87lBuPDdiQM54IYToOmmQRbc5OjqqHYKwkP5eW0VR+P5IGa9vO8qOrAoCPRx58vJY/jQubMCfgNffa9tTUQHuvHZNEndNqebFbw7z4reHeefnLBadHcHCsyLw7udDLwZqXQcCqa26ZAyyEKLfa9Eb+CKtiDe3Z5J+rJpBHk7ccv5Qrp0wGCf7gd0Yi/b251fx8pbDfHuwBGd7W+aND+Pm84YOiBM1hRC/kzHIwuzS0tLUDkFYSH+rbUOznvd+zeGCf33H4rV7aWjR89yceL6/fwo3nTtEmuM2+lttLWVUqCdvLxzH1385n0tGDeLdX3KY9Nw27v1oH0eKa9QOr9ukrtoltVWXDLEQ3dbY2Kh2CMJC+kttCyrree/XHD7cmcvxumYSwrz4+4yRTI8JxMZGG5eGNrf+Utu+MizQnWV/SuTe6cN5+4ff+HBnHv/bk8950X4sPCuCKSMCsO0Hv0tSV+2S2qpLGmQhRL+gKAo7sipY/XM2Xx0oAmBaTCCLzh7CxKE+6HTW38wI6xPi5cyjl8Wy+IJo3t+Rw3u/5nLzmt0M9nFhwVnhXD02DE9nOaFPiIFGxiCLbpO5GbXLGmt7orGFjfsKWf1zNoeKavBysWfuuDCunxhOqLe2LwJhTtZYW2vUrDfw9YFiVv2cxa7s4zjb23JFUgjXTQgnJthD7fBOIXXVLqmtZXXWL8oRZNFthYWFREREqB2GsABrqa2iKOzJPc6HO/P4fP8x6pr0jBjkzrNXjWJWQgjODjK2uLuspbbWzt7Whkvjg7g0Poi0girW/JLNJ8n5fLAjl/hQT+aOC+OyhGA8rGSaOKmrdklt1SUNsui28vJy2Wk1Su3alp1o5NM9BXy4K5fM0lpcHGy5LD6YP40LI2mwlwyj6AW1a9sfxYV48tycBP4+YyTr9xbw4a48Hvo0jSc3pXPpqGDmjQ9jbLi3qr+XUlftktqqSxpkIYSqGpr1bM8o4dO9BWw5WEKLQSFpsBfPXjWKS+ODcXOUtymhLi8XBxadM4SFZ0eQml/Fh7vy2LivkP/tyWeInyuXJwYzOzGECD9XtUMVQpiJjEEW3VZRUYGPj4/aYQgL6Kva6g0KO34rZ31KAV+mFVHT0IKfmwOzE0OYOy6M6EB3i8cw0Mh+a151TS1sSj3Gp3sK+DWrHEWBxDAvrhgdwsz4IHzd+uYiD1JX7ZLaWpYmxiBv3ryZe+65B71ez80338zSpUvVDmlAMxgMaocgLMSStVUUhbSCaj5LKWBjaiHF1Y24OthyUdwgZieGcHakL3ZyGWiLkf3WvFwc7PjT2DD+NDaMY1X1bEgp5NO9BTy64QBPbErn/Gg/ZiUGM3VkoEXHK0tdtUtqqy6rb5D1ej133nkn33zzDaGhoYwbN45Zs2YRExOjdmgDVk5ODn5+fmqHISzA3LU1GFpPttucVsTmA0XkH6/H3lbHpGEB/N/MYC4cGSgX8+gjst9aTpCnM7dNiuS2SZFkFNWwPqWAz/YW8Jf/7sPeVse5UX5cEhfEtJhAs1/aWuqqXVJbdVl9g7xz506ioqIYOnQoAPPmzeOzzz6TBlkIK9WiN7Azq4Iv04r46kARJTWNONjacG60H4sviGZ6bCBeLjJ1kdCm4YPceeDiEfxt+nBS8iv5cv8xvkwrYtv/UrH9VMdZQ325OG4QF8UOwt+9b4ZhCCG6z+ob5IKCAsLCwky3Q0ND2bFjR7tlVqxYwYoVKwAoKioiOTkZgJCQEFxcXDhy5AgAnp6eREZGsmfPHgBsbW1JTEzk0KFD1NbWAjBy5EgqKiooLi4GICwsDAcHBzIzMwHw9vZm8ODB7Nu3DwB7e3vi4+NJT0+nvr4egNjYWEpKSigtLQUgPDwcGxsbsrKyAPD19SU4OJj9+/cD4OjoSFxcHGlpaaYr54waNYrCwkLKy8sBGDJkCAaDgZycHAD8/f0JCAjgwIEDADg7OxMTE0NqairNzc0AJCQkkJuby/HjxwGIjIykqamJvLw8AAIDA/Hx8eHgwYMAuLq6MmLECFJSUtDr9QAkJSWRmZlJVVUVANHR0Tg4OJhyHBQUhIeHBxkZGQC4u7szbNgw9uzZg6Io6HQ6kpKSOHz4MDU1rZdxHT58ONXV1Rw7dkzqZME61dXVUVBQ0K066fV6U227U6faJgOppc381uDCtweOUd1owMEWJg/zZ2KoM1GuDbja2xAW5ghNdSQf3C916kWderI/1dbWkpycLPtTH9bJraGUiwfVc1GgB3rPkXy+r4BvDpXx8NEy/m99GvEh7sR6K4wJciR+sC9RUVHdft9zdXU17bNSp77bn/ri75ONjY2ptlIn89epM1Z/kt4nn3zC5s2befvttwF499132bFjB8uXLz/t8nKSnuU1NDTg5OSkdhjCArpaW0VRyCw9wdZDJWw5WMLunOPoDQpeLvZMHubPxXGDmDQsQOYrtiKy31oHRVHIKK5hc1oR2w6VsC+/tWkI8nTighEBTB0ZwNmRfl0eeiR11S6prWX1+5P0QkJCTJ9UAPLz8wkJCVExInHgwAHGjBmjdhjCAs5U29rGFnZklfP94TK2HComr6L1SMeIQe7cdv5QLhgRwOjB3tjayFzF1kj2W+ug0+kYMciDEYM8WHLhMEqqG9ieUcqWQ8V8ureA93fk4mRvw9mRfkwa5s85UX5E+rt2ONey1FW7pLbqsvoGedy4cRw5coSsrCxCQkL48MMP+eCDD9QOSwjNa9Eb2JdfxY9HyvjpaBl7co/TYlBwsrfhnEg/bjs/kikjAgjxclY7VCH6rQAPJ/40Low/jQujsUXPzqwKthwsYeuh1n8AwZ5OnBPlx7nRfpwT5YdfH00hJ8RAZvUNsp2dHcuXL+eiiy5Cr9dz4403Ehsbq3ZYA5qzszREWqQoCmVNtqz+OZsfjpSx47dyahpb0OkgLtiTm88bynnRfowJ95aZJ/oh2W+tn6OdLedF+3NetD+PzYolt7yOH4+W8ePRUr5OL+bj5HwARgZ5cN7JZtnNTpplrZJ9Vl1WPwa5u2QMshBdozcoZBTVsDOrnJ3ZFezMqqDsRBMAg31cWo9YRflxdqSv2aemEkJ0j96gkFZQ1dowHykjOec4TXoDtjY64kI8mTDEh/ERPoyL8MHTxXLzLguhFZ31i9Igi25LTU0lPj5e7TBENzXrDewvqGJnVmszvCu7gpqGFgBCvJyZMMSHIPs65k5KZLCvi8rRCnOT/VZb6ppa2J19nE07DpFda0dKXiVNegM6HYwY5NHaMA9pbZhlOrn+SfZZy+r3J+kJ62Oc/kVYt5LqBvbkVpKSV8ne3OOk5ldR39w67U6kvysz44MZP8SbcRE+hHq3NsTJycnSHGuU7Lfa4uJgx/nD/HGtyWXMmDE0NOvZl1fJjpMfgP+7K49VP2cDEO7rwugwL5LCvRkd5s2IIHfs5aqVVk/2WXVJgyyEBjQ06zlQWMXe3Er2nmyKCypbZ5mwt9URE+zJ3HFhTBjiw1g5oiSE5jjZ2zJhqC8ThvoCrd8YpZ38xmhvbiU/Z5azPqUQAEc7G+JDPRk92JvRYV6MHuzNIE+ZTkyItmSIhei2lpYW7Ozks5VaGlv0HC46QVphFWkFVewvqOLgsWqa9a27cqi3M4kn/+iNHuxFTJBHl0+qk9pql9RWm7paV0VRKKxqYG/u8ZMfpI+TVlBNk94AtM7DHBfiyagQT+JCPIgL9iTAQ5pmNck+a1kyxEKYXW5urunS38Ky6ppaOHishgMnm+G0gmoOF9fQYmhtht2d7EwzTIwO8yJxsBcB7j3/oya11S6prTZ1ta46nY4QL2dCvJyZGR8MtH7YPnishj05x0nJqyStsIpvDxZjPGwW4O5IXIgnccEerf+HeBLk6dThnMzCvGSfVZc0yKLbjJecFOajKAoFlfVkFNWQUVxDRlEN6YXVZJae4GQvjI+rA3Ehnkwe7n/yj5YnYT7OZv1jJbXVLqmtNvWmro52tiSGeZEY5mW670RjCwePVbM/v4q0wioOFFSzPaPE9D7k6+rAyCAPhg9yZ/ggd0YMcic6wF2ummkBss+qSxpkIfrY8domDhXVcLi4hkNFNWQUVXO4+AQnGltMywR7OjEiyINLRgWZjt7IkRshhKW5Odox7uR0cUb1TXoOFlVz4OSQrkNFNby/I4eG5tbhGTodhPu4nGyaPRhxsnmO8HWVK2uKfksaZNFtkZGRaodg9QwGhaLqBjJLT/BbaS2ZpSfILD3BkeITlNQ0mpbzdLZn+CB3rkwKYVhg69GYYYPc8XBSZx5Tqa12SW21qS/q6uxgS9Jgb5IGe5vu0xsUcivqyCiqPvlBv/XfN+nFpqPNjnY2RPq7ERngRqS/K0P9T/7v5yZHnLtA9ll1SYMsuq2pqUntEKxGfZOe38raNsG1/HayKTZOqQbg7mjHUH9Xzo32O3l0pfUoS4C7o1UdFZbaapfUVpvUqqutjY4hfq4M8XPl4rgg0/0NzXqOFJ/gUFE1GUU1HC09QUrecTalFtJ2SoAQL+dTGudIfzere09Uk+yz6pIGWXRbXl4eAQEBaofRJxRF4XhdMznlteRW1JFbXkeO6f9aiqt/Pxqs05180/d3Y8IQX4aefMOP9HfFv5+86Q+k2g40Ulttsra6OtnbMirUk1Ghnu3ub2jWk11eS2bJ79+oZZaeYHd2BXVNvx9McLa3ZbCPC4N9XQj3cSHc14XBvq6E+7gQ4u08oOZvtrbaDjTSIIsBr75JT2FVPYWV9eRV1JNTUUteRR055a2NcE2bscEAgR6ODPZx4dwof8J9XYj0d2Oof+uRlK5OpyaEEAOJk70tIwZ5MGKQR7v7FeXkcLSTjXNOeR25FbVkl9Xy/eFSGlsMpmVtbXQEezkR7uNqaqBDvV0I9nIixNsZP1dHbGTMszATaZBFtwUGBqodQpcpikLZiSYKK+spqKw/zf8NVNS2/xrL3lZHmHfrEYyx4d6E+bgQ7utKuK8LYd4umh47159qK7pHaqtN/b2uOp2OIE9ngjydOTfar91jBoNCSU0jOeW1bb65qyO3vJYv9h+jsq79leYcbG0I8nIixMuZ4JNT2pl+9nYmyNOpXx3E6O+17e+kQRbd5uPj0/lCfaC2sYXi6gaKqxspqWmgpLqx9XZNIyXVDRRXN1BY1UBTmyMQAK4OtoR4t75pxod6nXwDdSLEq/VIRJCn84A989paaivMT2qrTVquq42NjkGeTgzydDJdIbCtqvpmCtsc8CiorKfgeOvtH4+UUVzTwB8vhebn5kCgh9PJf44EuP/+c6CHEwEejvi6OlrF3wAt17Y/kAZZdNvBgwcZM2aMRdbd0KynvLaJ8hONJ/9voqK2kbITTSeb4dZGuKSmsd20aEbO9ratb3oeTowK9eKiuJNHEzx/P6Lg4WzXL8YDq8GStRXqktpq00Cuq6ezPZ7O9owM8jjt400tBoqrG8g/2TQXVtZTWFVP8cmDKan5VZTXNp7SRNva6PB3cyTA1EA74ufmiJ+bA75ujvi6OuDr5oCvqyOezvYWG9YxkGtrDaRBFhbTrDdQVd/8+7+6ZirrW5teYxNcUdtE2YkmymsbqTjRRG2bkzXacrSzMX3KHxnsweSTb1oBHo4EujsRcPIxN0dpfoUQQoCDnQ1hPi6E+bh0uEyz3kDZiUZT01xy8ltJ47eR+cfr2J1TccpwDiNbGx0+rg7tmmYfVwdTM+3lbI+niz1ezg4n/7fHxcFW/k71A9Igiw41tRg40dhCbWMLNQ0t1Da1cKKxhcMlCod25FBZ10x1fTOVdb83wZX1xvs6bnahdZxv65uKI75uDkT4uuBz8mc/NwfTz61vOo64yhtKn3B1dVU7BGEhUlttkrr2jr2tjWkM9Jk06w0crzt5gOfkQZ32/7ce9Nl3vJKKE02nnNzdfps609FvT2d7vFwc8HK2x8PZHi+X1vvcneypKlOoP1KGm5Mdbo52uDvZ4epoh4u9rZyM2Ad0ivLHLxf6t7Fjx7J79261w7A4RVFoMSg0tRhoaNZT36ynobn157a360/eNt3fZKChRU99U+vtmpMNcLsmuKGF2kY9TXpDp3E42Nm0fkJus2N7OJ/8tNzmPs+T/3s52+Pr5oiHkxzpFUIIoU0NzXoqapuoPPnNqfFgUqXxYFJdM1X1TaafjQecztRYG+l04OZgh9vJhtnYPLs52uHiYIezgw1OdrY4O9jiZG+Ls33rz872J2872OJkZ9PuPid7WxzsbHCwtcHBzsYqxmBbWmf9ohxBNoO1O3PZX1CFoigoChgUBcPJ/5UO/jcuoyigNxhMzW6z3kCzXjn5f+vPLXoDTW3ua9ErXWpeO2JvqzPtNG6Ov+9god4uJz+h2uLqaId7m8dMyznZkZ91lPGJo/Byse9XZwSLzqWkpJCYmKh2GMICpLbaJHW1Tk72tgSfnEGjO5r1Bqrrm6lt1LM7NY2Q8Ehqm1oPYJ1oNB7AaqHm5M8nGn//V1TVQF3T7wfJ6pv1p4yv7iobXevRdQdbG+ztbLC31f1++2QTbbzP3tYGGxsdtjqw0enQ6XTY2rT+bKPTYWOjw0bX5rbx55P363RwdqQfM0YFdR5YH5IG2QxScivZcqgEnY52vwQ60y9L+/+Ny0Dr/7Y2OtMvmouD3e+/dHY22Nt0/rPzyWbX0d7mD58QbXF2sMGxzSdJJzsb7Ho50bpSasMgTydzpE5YGb2+42Exon+T2mqT1FVb7G1tWk8EdINSD1vGnGb2jq5SFIXGNt8yt35z/Ps3y/VNvzfSDc36kwfpfj8Y16Q30NzS5nbLyfvaHMhrajFQ19SCXmndnkFR0Bva/vz7gUG9omA4+ZjeeCDx5HXJfVwcpEHWomfnxKsdghBCCCGEiU6nMw2f8FI7mH5IxiCLblMURcYPa5TUVrukttokddUuqa1lddYvDpyLmguzyczMVDsEYSFSW+2S2mqT1FW7pLbqkgZZdFtVVZXaIQgLkdpql9RWm6Su2iW1VZc0yEIIIYQQQrQhDbLotujoaLVDEBYitdUuqa02SV21S2qrLmmQRbfV1dWpHYKwEKmtdklttUnqql1SW3VJgyy6raCgQO0QhIVIbbVLaqtNUlftktqqSxpkIYQQQggh2tDcPMh+fn5ERESoHYamlZaW4u/vr3YYwgKkttoltdUmqat2SW0tKzs7m7Kysg4f11yDLCxPLsaiXVJb7ZLaapPUVbuktuqSIRZCCCGEEEK0IQ2yEEIIIYQQbUiDLLrt1ltvVTsEYSFSW+2S2mqT1FW7pLbqkjHIQgghhBBCtCFHkIUQQgghhGhDGmQhhBBCCCHakAZZdKqiooJp06YRHR3NtGnTOH78eIfLVldXExoayl133dWHEYqe6kptU1JSOOuss4iNjSU+Pp7//ve/KkQqumLz5s0MHz6cqKgonnnmmVMeb2xsZO7cuURFRTFhwgSys7P7PkjRI53VdtmyZcTExBAfH8/UqVPJyclRIUrRE53V1uh///sfOp1Opn7rI9Igi04988wzTJ06lSNHjjB16tQz7sD/93//x/nnn9+H0Yne6EptXVxcWLNmDQcOHGDz5s0sWbKEysrKvg9WnJFer+fOO+/kyy+/JD09nbVr15Kent5umZUrV+Lt7c3Ro0f5y1/+wgMPPKBStKI7ulLb0aNHs3v3blJTU5kzZw7333+/StGK7uhKbQFqamp4+eWXmTBhggpRDkzSIItOffbZZyxcuBCAhQsXsn79+tMul5ycTHFxMdOnT+/D6ERvdKW2w4YNIzo6GoDg4GACAgIoLS3tyzBFF+zcuZOoqCiGDh2Kg4MD8+bN47PPPmu3TNt6z5kzhy1btiDnaVu/rtR2ypQpuLi4ADBx4kTy8/PVCFV0U1dqC60Hnx544AGcnJxUiHJgkgZZdKq4uJigoCAABg0aRHFx8SnLGAwG7r33Xl544YW+Dk/0Qldq29bOnTtpamoiMjKyL8IT3VBQUEBYWJjpdmhoKAUFBR0uY2dnh6enJ+Xl5X0ap+i+rtS2rZUrV3LJJZf0RWiil7pS2z179pCXl8ell17a1+ENaHZqByCsw4UXXkhRUdEp9z/11FPtbut0OnQ63SnLvf7668yYMYPQ0FCLxSh6pre1NTp27BjXX389q1evxsZGPlsLYY3ee+89du/ezXfffad2KMIMDAYDf/3rX1m1apXaoQw40iALAL799tsOHwsMDOTYsWMEBQVx7NgxAgICTlnml19+4YcffuD111/nxIkTNDU14ebmdsbxyqJv9La20Hry5aWXXspTTz3FxIkTLRWq6IWQkBDy8vJMt/Pz8wkJCTntMqGhobS0tFBVVYWvr29fhyq6qSu1hdZ9/amnnuK7777D0dGxL0MUPdRZbWtqakhLS2Py5MkAFBUVMWvWLDZs2MDYsWP7OtwBRQ4DiU7NmjWL1atXA7B69Wouv/zyU5Z5//33yc3NJTs7mxdeeIEFCxZIc9wPdKW2TU1NXHHFFSxYsIA5c+b0dYiii8aNG8eRI0fIysqiqamJDz/8kFmzZrVbpm29P/nkEy644IIzfmsgrENXart3715uu+02NmzY0OEHXWF9Oqutp6cnZWVlZGdnk52dzcSJE6U57iPSIItOLV26lG+++Ybo6Gi+/fZbli5dCsDu3bu5+eabVY5O9EZXavvRRx/x/fffs2rVKhITE0lMTCQlJUXFqMXp2NnZsXz5ci666CJGjhzJn/70J2JjY3nkkUfYsGEDADfddBPl5eVERUWxbNky+RDbT3Sltn/72984ceIEV199NYmJiac00MI6daW2Qh1yqWkhhBBCCCHakCPIQgghhBBCtCENshBCCCGEEG1IgyyEEEIIIUQb0iALIYQQQgjRhjTIQgghhBBCtCENshBCCCGEEG1IgyyEEEIIIUQb0iALITRNp9Nx7733mm6/8MILPPbYY30ag5ubm+nns88+u9fre+yxx3jhhRdO+5itra3pgi6JiYlkZ2f3envW7N577yUhIYG7776b22+/nZ9++umU+4UQorvs1A5ACCEsydHRkXXr1vHggw/i5+fXrecqioKiKNjYmO9Yws8//2y2dZ2Os7Nzh1c6tMTrUVNmZiY//fQT+/btAyAxMZHXXnvtlPuFEKK7tPEuKYQQHbCzs+PWW2/lxRdfPOWxZcuWERcXR1xcHC+99BIA2dnZDB8+nAULFhAXF8cPP/zAiBEjWLRoEcOGDePaa6/l22+/5ZxzziE6OpqdO3ea1jd79mzGjBlDbGwsK1asOG08xqPJb775puko75AhQ5gyZQoA7733HuPHjycxMZHbbrsNvV4PwFNPPcWwYcM499xzycjI6PLr/+PrycvL63Abf9zO/PnzeeGFF8jOziYuLs60TNuj8KdbV3Z2NiNHjuSWW24hNjaW6dOnU19fb3r+mjVriI+PJyEhgeuvv55HHnnElH+Ahx56iJdffvmMrysjI4PJkyeTk5PD6NGjOXDgAMOGDePo0aPt7q+tre1yroQQwkQRQggNc3V1VaqqqpTw8HClsrJSef7555VHH31U2b17txIXF6ecOHFCqampUWJiYpQ9e/YoWVlZik6nU3755RdFURQlKytLsbW1VVJTUxW9Xq8kJSUpN9xwg2IwGJT169crl19+uWlb5eXliqIoSl1dnRIbG6uUlZWZYmgbT1tNTU3Kueeeq2zYsEFJT09XZs6cqTQ1NSmKoih//vOfldWrV5tira2tVaqqqpTIyEjl+eefP+3rtbGxURISEpSEhARl9uzZp7yejrahKEqH28nKylJiY2NN2zDmsKN1GXO2d+9eRVEU5eqrr1beffddRVEUJS0tTYmOjlZKS0tNOcvKylJGjx6tKIqi6PV6ZejQoabcnclDDz2kvPXWW4qiKMq//vUvZeXKlafcL4QQPSFDLIQQmufh4cGCBQt45ZVXcHZ2BuDHH3/kiiuuwNXVFYArr7ySH374gVmzZhEeHs7EiRNNzx8yZAijRo0CIDY2lqlTp6LT6Rg1alS7Mb6vvPIKn376KQB5eXkcOXIEX1/fM8Z2zz33cMEFF3DZZZexfPlykpOTGTduHAD19fUEBARQUVHBFVdcgYuLCwCzZs3qcH1/HGKRnZ3d7vVs2bLltNsA+OGHH7q8nTOt6/zzz2fIkCEkJiYCMGbMGFOetm7dytVXX20a7uLj44OPjw++vr7s3buX4uJiRo8e3WneAPbv38/ll18OwFdffcU777xzyv1CCNET0iALIQaEJUuWkJSUxA033NDpssam2cjR0dH0s42Njem2jY0NLS0tAGzfvp1vv/2WX375BRcXFyZPnkxDQ8MZt7Nq1SpycnJYvnw50DpGeOHChTz99NPtlms7/KAn2r6ejrZxJnZ2dhgMBtNt4+vqaF3Z2dntcmZra9tuiMXp3HzzzaxatYqioiJuvPHGLsV14MAB4uLiqKuro7KykuDg4Hb3Q+sHlSeeeAJPT08uvvhiLrzwwi6tWwgxsMkYZCHEgODj48Of/vQnVq5cCcB5553H+vXrqauro7a2lk8//ZTzzjuvx+uvqqrC29sbFxcXDh06xK+//nrG5ZOTk3nhhRd47733TCfNTZ06lU8++YSSkhIAKioqyMnJ4fzzz2f9+vXU19dTU1PDxo0bexxnR9sAOtxOYGAgJSUllJeX09jYyKZNmzpdV0cuuOACPv74Y8rLy03PAbjiiivYvHkzu3bt4qKLLmoXb0FBwSnrqampwd7eHmdnZ7Zt22Yaw932foBDhw7h4ODA4sWLpTkWQnSZHEEWQgwY9957r+lobVJSEosWLWL8+PFA6xHM0aNH93hatIsvvpg333yTkSNHMnz48HZDNE5n+fLlVFRUmBq7sWPH8vbbb/OPf/yD6dOnYzAYsLe357XXXmPixInMnTuXhIQEAgICTEMaeiImJua02wgPDycpKem027G3t+eRRx5h/PjxhISEMGLEiDOua9CgQR1uPzY2loceeohJkyZha2vL6NGjWbVqFQ4ODkyZMgUvLy9sbW0BMBgMHD16FB8fn1PWk5aWZjpK/OWXXzJnzpxT7geYNm0aYWFh3HXXXbzxxhuEhIT0OHdCiIFDpyiKonYQQgghrM9jjz2Gm5sb9913n8W3ZTAYSEpK4uOPPyY6OhpobXb/85//sGzZsjM+NykpiR07dmBvb3/KYw888AB6vZ6GhgZefPHF0y4jhBB/JEeQhRBCqCo9PZ2ZM2dyxRVXmJpjgLi4uE6bY4A9e/Z0+Nizzz5rlhiFEAOLHEEWQgghhBCiDTlJTwghhBBCiDakQRZCCCGEEKINaZCFEEIIIYRoQxpkIYQQQggh2pAGWQghhBBCiDakQRZCCCGEEKINaZCFEEIIIYRoQxpkIYQQQggh2pAGWQghhBBCiDakQRZCCCGEEKINaZCFEEIIIYRoQxpkIYQQQggh2pAGWQghhBBCiDakQRZCCCGEEKINaZCFyaJFi3j44YfNvt6IiAi+/fZbs6/3TDIyMkhMTMTd3Z1XXnmlx+t58MEHeemllzpdbvz48Rw4cKDH2xFCWCc13r8GirCwMPbs2XPax3Q6Ha6urjz00ENdWtcFF1yAk5MT5557rjlDFAOYNMhd9P777+Pm5nbKP51OxxNPPKF2eH0iIiICZ2dn3NzcCAwMZNGiRZw4cULtsE7rueeeY8qUKdTU1LB48eJTHj9+/Dg6nY6srKx29y9evJhbbrkFgNLSUtasWcNtt93W6fbuu+8+HnnkEfMEL4Q4hVYa1bbvo4MGDbLq91FLOn78OIWFhYwcObLDZfbt28dTTz3VpfVt3bqVN99801zhCSENcldde+21nDhxot2/l156icDAQFND1VUtLS0WitLyNm7cyIkTJ9izZw+7d+/mH//4h9ohnVZOTg6xsbEdPp6SkoKbmxsRERHt7t+/fz+JiYkArFq1ihkzZuDs7Nzp9mbNmsW2bdsoKirqTdhCiAHA+D6akpLC3r17efrpp9UOqc/t37/f9GFBCGskDXIP7d27lyVLlvDhhx8SFBQEQGFhIVdddRX+/v4MGTKk3Vf7ERERPPvss8THx+Pq6kpLSwsHDx5k8uTJeHl5ERsby4YNG0zLP/vss4SEhODu7s7w4cPZsmXLaeN45plniIyMxN3dnZiYGD799NN2j0dERPDCCy8QHx+Pp6cnc+fOpaGhwfQakpKScHd3b3d/V4SEhHDJJZeQlpYGcMbX8kdnylNXX/eZtnfBBRewbds27rrrLtzc3Dh8+PApz09JSSEmJgadTtfu/gMHDjB69GgAvvzySyZNmmR6bO7cuad8e/Dqq68C4OTkxJgxY/jqq686S50QopciIiJ4/vnnTe+nN910E8XFxVxyySW4u7tz4YUXcvz4cdOyTz/9NDExMXh7e3PDDTe0e6/T6XQcPXrUdPtMQ806en8603vamQwaNIiLLrqIlJSUdvf35D2ys9d5pvfMM/2dsMTrBkhNTSUqKorFixfj7+9PcHAw33zzTYfL//vf/2bGjBnceeed+Pn5dbq8EL2miG47fvy4MnToUOWZZ54x3afX65WkpCTl8ccfVxobG5XMzExlyJAhyubNmxVFUZTw8HAlISFByc3NVerq6pSmpiYlMjJSeeqpp5TGxkZly5Ytipubm3Lo0CHl0KFDSmhoqFJQUKAoiqJkZWUpR48ePW0sH330kVJQUKDo9Xrlww8/VFxcXJTCwkLT4+Hh4cq4ceOUgoICpby8XBkxYoTyxhtvKI2NjcrgwYOVZcuWKU1NTcrHH3+s2NnZKQ899FCHrzs8PFz55ptvFEVRlNzcXCUmJkZ5+OGHz/ha/vi8M+Wpq6+7s+0piqJMmjRJeeuttzp8Lddff71y4403truvqKhIsbGxUWpqahRFURQ/Pz9l586dp33+v/71LyUxMVEpLy833Xf33Xcrf/nLXzrcphCi59q+j4SHhysTJkxQioqKlPz8fMXf318ZPXq0smfPHqW+vl6ZMmWK8thjj5mWjY2NVXJzc5Xy8nLl7LPPbvc+ByhHjhwx3V64cGG7x43b7ej9qbP3/jO9jry8PCUuLk5ZvHix6fGevkee6XV25T36dH8nFEUx2+v+o1tvvVXx8fFRNm/erOj1euWxxx5Tpk6d2mFd/vznPyve3t4dLq8oivLOO+8o55xzTpe2L0Rn5AhyNymKwoIFC4iLi+P+++833b9r1y5KS0t55JFHcHBwYOjQodxyyy18+OGHpmUWL15MWFgYzs7O/Prrr5w4cYKlS5fi4ODABRdcwMyZM1m7di22trY0NjaSnp5Oc3MzERERREZGnjaeq6++muDgYGxsbJg7dy7R0dHs3Lmz3TKLFy8mODgYHx8fLrvsMlJSUvj1119pbm5myZIl2NvbM2fOHMaNG9fp6589ezZeXl6ce+65TJo0ib///e9nfC1/dKY8dfV1d2d7HUlJSWHt2rX4+fmZ/o0YMYKoqCjc3NwAqKysxN3d/ZTnvvzyy6xZs4Zvv/0WHx8f0/3u7u5UVlZ2OQYhRM/dfffdBAYGEhISwnnnnceECRMYPXo0Tk5OXHHFFezdu9e07F133UVYWBg+Pj489NBD3XqvMOro/akr7/1/NHv2bNzd3QkLCyMgIIDHH3/c9Fhv3iM7ep1dec883d8Jc7/utlJTU3nooYe46KKLsLGxISYmptPlly5d2uXlhegtO7UD6G+effZZDhw4QHJycruv53NycigsLMTLy8t0n16v57zzzjPdDgsLM/1cWFhIWFgYNja/f0YJDw+noKCAqKgoXnrpJR577DEOHDjARRddxLJlywgODj4lnjVr1rBs2TKys7MBOHHiBGVlZe2WGTRokOlnFxcXCgsLKSwsJCQkpN1rCA8P7/T1r1+/ngsvvLDdfWd6LX90pjx19XV3Z3un09jYyMGDB/noo4/afSh4/fXXyczMNN329vampqam3XOXL1/OypUr2bp1K76+vu0eq6mpafe6hBCWExgYaPrZ2dn5lNttT3xr+94bHh5OYWFht7fX0ftTV977/8j4Pvrdd99xzTXXUFZWZnp+b94jO3qdXXnPPN3fCXO/biNFUUhLS2PNmjWm+9LS0jpsehVFYf/+/bz11ltdWl4Ic5AjyN2wfft2nnrqKT755JNTGqGwsDCGDBlCZWWl6V9NTQ1ffPGFaZm2zWhwcDB5eXkYDAbTfbm5uYSEhABwzTXX8OOPP5KTk4NOp+OBBx44JZ6cnBxuueUWli9fTnl5OZWVlcTFxaEoSqevJSgoiIKCgnbL5ubmdjkXbXX2WtrqLE9ded3d2d7ppKWlYTAYmDZtGqGhoaZ/R44cMY0/BoiPj283fvn111/nzTffZMuWLfj5+Z2y3oMHD5KQkNClGIQQfScvL8/0c25ubrsP3S4uLtTV1Zlun+lE29O9P3Xlvb8jkyZNYtGiRdx3332m+3rzHtnR6+zte6a5X7dx9qCoqCjTfXv37jWdIP1H2dnZtLS0MHz48C4tL4Q5SIPcRceOHWPevHm89NJL7Zooo/Hjx+Pu7s6zzz5LfX09er2etLQ0du3addr1TZgwARcXF5577jmam5vZvn07GzduZN68eWRkZLB161YaGxtxcnLC2dm53Sd/o9raWnQ6Hf7+/gC88847ppPmOnPWWWdhZ2fHK6+8QnNzM+vWrTtlaEZXnem1/NGZ8tTV192d7Z3O3r17iYmJMQ2lMNq1a1e7N9wZM2bw3XffAbBixQpee+01tmzZYsp3Ww0NDSQnJzNt2rQuxSCE6DuvvfYa+fn5VFRU8NRTTzF37lzTY4mJiXzwwQfo9Xo2b95s2uf/qKP3p+6+9//RkiVL+Oabb9i3bx/Qu/fIjl5nb94ze/O6Fy1axKJFi05ZZ2pqKqNGjWp30Gjv3r0dHmAwLt/2tZ5peSHMQRrkLnrrrbcoLi7mnnvuOWUu5Ntvvx1bW1s2bdpESkoKQ4YMwc/Pj5tvvpmqqqrTrs/BwYGNGzfy5Zdf4ufnxx133MGaNWsYMWIEjY2NLF26FD8/PwYNGkRJSclppwGKiYnh3nvv5ayzziIwMJD9+/dzzjnndOn1ODg4sG7dOlatWoWPjw///e9/ufLKK3uUmzO9lj86U566+rq7s73TSUlJOWW8dWlpKTk5Oe0a5AULFvDFF19QX1/P/fffT2ZmJpGRkaa6v/vuu6ZlN27cyOTJk087DEYIoa5rrrmG6dOnM3ToUCIjI9vNUvHyyy+zceNGvLy8eP/995k9e/Zp19HR+1N33/v/yN/fnwULFpjm0+/Ne2RHr7M375m9ed15eXmn/Zu0f//+ds1tWVkZRUVFxMXFnTaG1NTUdu/NnS0vhDnolK58Hy/EAPX3v/+dgIAAlixZcsblJkyYwMqVK+UNWwgrExERwdtvv33KuRNaY22vs6mpiYSEBFJTU7G3t+/2852cnHB0dGTx4sU8+eSTnS4/bdo0fv31V8aPH9/h9KBCdIecpCfEGfzzn//s0nI7duywcCRCCNF/ODg4cPDgwR4/vzvz8gMyJ7IwOxliIYQQQgghRBsyxEIIIYQQQog25AiyEEIIIYQQbWhuDLKfnx8RERFnXKa5ublHJw30JYnRPLQQY3Z29ikXf7GUG2+8kU2bNhEQEHDaKQMVReGee+7hiy++wMXFhVWrVpGUlAS0nn0/atQoAAYPHsyGDRs63V5X9teu6g+1tjTJgeTASPIgOQDJgdHp8tDZ31bNNcgRERHs3r37jMsoitJu/kVrJDGahxZiHDt2bJ/FsmjRIu666y4WLFhw2se//PJLjhw5wpEjR9ixYwd//vOfTScoOjs7my5P21Vd2V+7Kjk5mTFjxphlXf2V5EByYCR5kByA5MDodHno7G/rgBxi0fZywtZKYjQPibF7zj//fHx8fDp8/LPPPmPBggXodDomTpxIZWUlx44d68MIhRBCCMsbkA1yVydwV5PEaB4So3kVFBQQFhZmuh0aGkpBQQHQOi3T2LFjmThxIuvXr+/z2EaOHNnn27Q2kgPJgZHkQXIAkgOjnuRBc0MshBDqyMnJISQkhN9++40LLriAUaNGERkZecpyK1asYMWKFQAUFRWRnJwMQEhICC4uLhw5cgQAT09PIiMj2bNnD9A6xjkxMZFDhw5RW1sLtL7pVVRUUFxcTF1dHcOHD8fBwcF0VN7b25vBgwebLuNrb29PfHw86enp1NfXAxAbG0tJSQmlpaUAhIeHY2NjQ1ZWFgC+vr4EBwezf/9+ABwdHYmLiyMtLY3GxkYARo0aRWFhIeXl5QAMGTIEg8FATk4O0Hq1tICAAA4cOAC0DkeJiYkhNTWV5uZmABISEsjNzeX48eMAREZG0tTURF5eHgCBgYH4+PiY5pZ1dXVlxIgRpKSkoNfrAQgICKCwsND0oSs6Opq6ujrTh5igoCA8PDzIyMgAwN3dnWHDhrFnzx7TUJ+kpCQOHz5MTU0NAMOHD6e6utr0TUFv6wQQFhZmsTolJyfj4uJi1XVKSkoiMzPTonVydHRk8ODBVlunvtifDh06hHGiLmutk6X3p7q6Ojw9Pa26Tn2xP9XV1ZkeN9apM5qb5m3s2LGdjmmsrq7Gw8OjjyLqGYnRPLQQY1d+p80pOzubmTNnnvYkvdtuu43Jkyczf/58oPXNfvv27QQFBbVbbtGiRcycOZM5c+accVvmfG0y1k5yAJIDI8mD5AAkB0YdjUE+09+fATnEoq6uTu0QOiUxmofEaF6zZs1izZo1KIrCr7/+iqenJ0FBQRw/ftx0VKGsrIyffvqJmJgYlaMVQgghemZADrEoKChg0KBBaodxRhKjeUiM3TN//ny2b99OWVkZoaGhPP7446avwm6//XZmzJjBF198QVRUFC4uLrzzzjsAHDx4kNtuuw0bGxsMBgNLly7t8wa57djogUpyIDkwkjxIDkByYNSTPAzIBlkIcXpr16494+M6nY7XXnvtlPvPPvts01g1tTg4OKi6fWsgOZAcGEkeJAcgOTDqSR4G5BCLP46XtEYSo3lIjAOHNU2XpxbJgeTASPIgOQDJgVFP8jAgG2RrP2kLJEZzkRiFEEII0V0DskE2TslizSRG85AYBw5vb2+1Q1Cd5EByYCR5kByA5MCoJ3kYkA2yEEJ7Bg8erHYIqpMcSA6MJA+SA5AcGPUkDwOyQXZ3d1c7hE5JjOYhMQ4cxosXDGSSA8mBkeRBcgCSA6Oe5GFANshduYKK2iRG85AYhRBCCNFdA7JBNl7C0ZpJjOYhMQ4c9vb2aoegOsmB5MBI8iA5AMmBUU/yMCAb5P5wdW2J0TwkxoEjPj5e7RBUJzmQHBhJHiQHIDkw6kkeBmSDrNPp1A6hUxKjeQzUGOvq6njyySe55ZZbADhy5AibNm0y+3asSXp6utohqE5yIDkwkjxIDkByYNSTPAzIBjkpKUntEDolMZrHQI3xhhtuwNHRkV9++QWAkJAQHn74YbNvx5rU19erHYLqJAeSAyPJg+QAJAdGPcnDgGyQDx8+rHYInZIYzWOgxpiZmcn9999vGnfl4uIiQzmEEEKILhqQDXJNTY3aIXRKYjSPgRqjg4MD9fX1puEbmZmZODo6mn071iQ2NlbtEFQnOZAcGEkeJAcgOTDqSR4GZIMshNY9/vjjXHzxxeTl5XHttdcydepUnnvuObXDsqiSkhK1Q1Cd5EByYCR5kByA5MCoJ3kYkA3y8OHD1Q6hUxKjeQzUGKdNm8a6detYtWoV8+fPZ/fu3UyePNns27EmpaWlaoegOsmB5MBI8iA5AMmBUU/yYGeBOKxedXU1bm5uaodxRhKjeQy0GP84p3JQUBAAubm55Obm9ouTFoUQQgi1DcgG+dixYwQHB6sdxhlJjOYx0GK89957AWhoaGD37t0kJCSgKAqpqamMHTvWNKuFFoWHh6sdguokB5IDI8mD5AAkB0Y9yYOqQyxuvPFGAgICiIuLO+3jiqKwePFioqKiiI+PlyuOCdGJbdu2sW3bNoKCgtizZw+7d+8mOTmZvXv3EhISonZ4FmVjMyBHjLUjOZAcGEkeJAcgOTDqSR5UzdyiRYvYvHlzh49/+eWXHDlyhCNHjrBixQr+/Oc/m2W7/aFRkBjNY6DGmJGRwahRo0y34+LiOHjwoNm3Y02ysrLUDkF1kgPJgZHkQXIAkgOjnuRB1SEW559/PtnZ2R0+/tlnn7FgwQJ0Oh0TJ06ksrKSY8eOmcZV9pSLi0uvnt8X1IpRURSqqqrIz88nLy+PkpISFi5cCMDHH3/M999/T21tLTqdDoPBgLe3N8uWLQPg888/Jzc3Fz8/P/z8/PD39yc4OBgfHx9VXgsM3FrHx8dz8803c9111wHw/vvvyyVHhRBCiC6y6jHIBQUFhIWFmW6HhoZSUFBwSoO8YsUKVqxYAUBRURHJyclA65E5FxcXjhw5AoCnpyeRkZHs2LEDHx8fbG1tSUxM5NChQ9TW1gIwcuRIKioqKC4uBiAsLAwHBwcyMzMB8Pb2ZvDgwezbtw8Ae3t74uPjSU9PN12pJTY2lpKSEtNZk+Hh4djY2Jg+wfj6+hIcHMz+/fsBcHR0JC4ujrS0NBobGwEwGAz4+/tTXl4OwJAhQzAYDOTk5ADg7+9PQEAABw4cAMDZ2ZmYmBhSU1Npbm4GICEhgdzcXI4fPw5AZGQkTU1N5OXl0dLSQl1dHfn5+QwfPhxbW1veffddVq5cyYkTJ9rld+LEiZw4cYL//e9/fPXVV7i4uKDX62lqasLNzY0nnniCjIwM/vWvf7Ft27Z2z/X19aWsrIzDhw/z1ltvUV1dzTnnnEN0dDT29vbodLoO62QcUtObOhlrbak6jRo1isLCwl7VyWAw4Ovre9o69dQ777zDG2+8wcsvvwy0fhg11zcw1srX11ftEFQnOZAcGEkeJAcgOTDqSR50isqX18rOzmbmzJmkpaWd8tjMmTNZunQp5557LgBTp07l2WefZezYsR2ub+zYsezevfuM20xOTmbMmDG9C9zCLBFjeno6q1ev5vvvv2fv3r2mJi8jI4Nhw4axYcMGtm7dSlhYGKGhoYSFhREUFERERITpghNnirG5uZmKigpKS0spKyujtLQUvV7PvHnzALj44ov5+uuvTVd08/X1Ze7cubz22msAtLS0YGdn3s9sWqh1V36n+ytzvrampiYcHBzMsq7+SnIgOTCSPEgOQHJgdLo8dPb3x6qPIIeEhLQ7ipafn2+W8Zqenp69Xoel9TZGvV7PL7/8wmeffcY111zD6NGjyczM5MUXX2T8+PHcddddxMfHExcXR0REBACzZs1i1qxZPY7R3t6ewMBAAgMDT7v85s2baWhoID09nV27drFr1y78/f2B1qOoERERDBs2jIsuuojp06eTkJDQ6xMMBkKtT2fIkCGn/VDz22+/mX1b1mL//v1W/2HI0iQHkgMjyYPkACQHRj3Jg1U3yLNmzWL58uXMmzePHTt24Onp2evxx9D6Fba160mMzc3NbN68mc8++4wNGzZQWlqKvb09CQkJjB49munTp1NZWWm2Ma89idHJyYmkpCSSkpK47bbbTPfX1dUxf/58vv76a5YuXcrSpUsZNGgQL774oukIdF/F2NcsEWPbT8UNDQ18/PHHVFRUmH07QgghhBapOovF/PnzOeuss8jIyCA0NJSVK1fy5ptv8uabbwIwY8YMhg4dSlRUFLfccguvv/66WbbbH6aL62qMiqKYxr82Nzczd+5cPvnkEy688EL++9//UlZWZjpRy9HR0awnhJkzj25ubjz//PPs27ePwsJCVq9ezTnnnGP6QLRv3z4eeOAB09hvNWK0FEvE6Ovra/oXEhLCkiVL+Pzzz82+HWvi6OiodgiqkxxIDowkD5IDkBwY9SQPqh5BXrt27Rkf1+l0pvGpor3y8nLWrFnDf/7zH+zs7Ni7dy8uLi78/PPPxMTE9OsxR0FBQSxYsIAFCxaY7tuxYwfLli3jueee46yzzuLOO+9kzpw5svN3oG3TbTAY2L17Ny0tLSpGZHkdzac+kEgOJAdGkgfJAUgOjHqShwE5g7Stra3aIXSqoxizsrK48847CQsL469//Suurq78+c9/xmAwAJCYmNhnzXFf5vHWW2/l2LFjvPjii6aj4jExMej1+jM+rz/Xujfuvfde078HH3yQPXv28NFHH5l9O9bkdCf6DjSSA8mBkeRBcgCSA6Oe5MGqxyBbSmJiotohdOqPMRoMBmxsbPj+++956623uP766/nLX/6i6qfDvs6jn58fS5YsYfHixXz77bdkZWVha2uLoig8++yzzJ8//5TLSfbHWpvDypUrGTp0aLv7tD5hvHFWloFMciA5MJI8SA5AcmDUkzwMyCPIhw4dUjuEThlj3LdvHzNmzOCll14CWsdtZ2dns3LlStW/OlErjzY2NkyfPt10kl9GRgaPPvoo0dHR3Hrrre0uPtOfam1Oc+bM6dJ9f9Sby7+vXr2a6OhooqOjWb16dc+DF0IIIVQ2IBtk48UmrNnhw4e57rrrGD16NL/88gvu7u4AODg4EBwcrHJ0rawljyNGjCAzM5Nbb73V1KTdeeedVFVVWU2MZ2LOGA8dOsT//vc/qqqqWLdunenfqlWraGho6PT5Pb38e0VFBY8//jg7duxg586dPP7446YLn/SVtpfWHqgkB5IDI8mD5AAkB0Y9ycOAHGJh7V588UXuv/9+7OzsuP/++3nggQfw9vZWOyyrFhoayvLly3nwwQf55z//yeeff85zzz2ndlh9LiMjg02bNlFZWcnGjRtN97u7u/PWW291+vyeXv59+/btTJs2zXRZ8WnTprF582bmz5/f69fUFY9vPMCe30pwcnLqk+1Zq4aGBsmB5ACQPIDkALSZg5hgDx69LLZbzyksLDRd86GrBmSDPHLkSLVDOIWiKLS0tGBvb8+4ceO47rrr+Mc//mGWC6NYijXmMSQkhNdee43nn38eFxcXIiMjufzyy7nrrruYNm2a2uGdljnzePnll3P55Zfzyy+/cNZZZ5ltvUYdXf69o/tPp7uXhu/KJcdLSkqor6/H1tYWnU5HQ0Pr5cTt7OxxdHSktrb18uk6nQ2urq7U1dVhMLSe4Oni4kpzczPNzU0AODo6dWkdtbW1KErrybGurm40NjbS0tJ6+XAnJ2cURaGxsfWovb29A/b29tTVtcZtY2OLi4uLWdbRemn41qtTKkrre4le3zpjibOz8bLwrePvHBwcsbW1pb6+7mRO7XB2dm6zDh1ubm7U19f3YB01Jyvcug5z5Lgn66ivr6elpdmq6+Tm5t7DHHe9Tnq9AXt7e6utU9/sTw1WXydL70/NzS3o9Xorr1P31gEepKSkmE7ST0pKIjMzk6qqKgCio6Opq6sz/Q0KCgqiuLjYNCWuu7s7w4YNozMDskGuqKgw63zAvZWVlcUdd9zBsGHDePnllzn33HOJiIiw6uYYrC+PbRnj2r9/PwcOHGD69OksWrSIF198ES8vL3WD+wNz5vG5557j/vvv54MPPjjtNIqvvPKKWbbTG7feeiu33nor0Hqpzz9e3aiz2yNGjGh328XFhdduCu0XlxW3NMmB5MBI8iA5gIGTg6ioqHa3PTw8GDRokOn2sWPHup2HATkGubi4WO0QgNaZKV5++WViY2P58ccf2xXYWmI8k/4Qo4uLCwcOHODhhx/m3XffJTY21uoumGHOPBqPRhsbzz/+662OLv9uqcvCd8eQIUP6dHvWSHIgOTCSPEgOQHJg1JM8DMgjyNagqKiIRYsW8dVXXzFz5kzefPNNqz9i3F85Ojry5JNPMnv2bBYtWsSjjz7KJZdcgo2N9j4fXnbZZQAsXLjQIuvv6PLvF110EX//+99NJ+Z9/fXXPP300xaJoSPGucAHMsmB5MBI8iA5AMmBUU/yMCAb5LZjJdVSVVVFcnIyr7/+Orfffjs6na7d49YQY2f6W4xjxoxh9+7dlJWVYWNjQ1VVFVlZWarPlWzOPF522WWn/C61tWHDhjM+f/78+Wzfvp2ysjJCQ0N5/PHHaW5uHRt2++23M2PGDL744guioqJwcXHhnXfeAcDHx4f/+7//Y9y4cQA88sgjphP2+kpOTg5+fn59uk1rIzmQHBhJHiQHIDkw6kkeBmSDrNZlmJubm/n444+ZP38+w4cPJzs7G1dX19Mu2x8uFd0fY3R0dDQdqV+6dCnvvPMOL7/8MrfeeusZG0tLMmce77vvvl49vzeXf7/xxhu58cYbe7V9IYQQwhpo7zvmLsjMzOzzbZaVlTF9+nSuvfZafvzxR4AOm2NQJ8bu6u8xPvHEE0yePJnbb7+d66+//uSZx33PnHmcNGmS6d9ZZ52Ft7c3Pj4+nHXWWUyaNMls27FG/v7+aoegOsmB5MBI8iA5AMmBUU/yMCAb5L6WmprKuHHj+OWXX1izZg3nnXee2iEJWneYL774gieffJK1a9dy3nnnUVhYqHZYZvH5558TGRnJ4sWLueuuu4iKiuLLL79UOyyLCggIUDsE1UkOJAdGkgfJAUgOjHqShwHZIPflRTfWr1/PWWedRVNTEz/88APXX399l57XHy4MooUYbWxsePjhh/n888+pq6ujpaWljyL7nSXyeO+997Jt2za2b9/Od999x7Zt2/jLX/5i9u1YkwMHDqgdguokB5IDI8mD5AAkB0Y9ycOAbJAHDx7cZ9uysbFh9OjR7N6923QCU1f0ZYw9paUYL774Yg4cOMDgwYMxGAymi1P0BUvk0d3dvd20gUOHDjVdrlwIIYQQZzYgG+R9+/ZZdP2KorB//36gdVqsH374gaCgoG6tw9IxmoPWYrSzaz1n9aWXXmL8+PGsWbPGUmG1Y4k8jh07lhkzZrBq1SpWr17NZZddxrhx41i3bh3r1q0z+/asgbOzs9ohqE5yIDkwkjxIDkByYNSTPAzIBtmSFEXhb3/7G4mJiezcuRNAtdkRRM/cfPPNTJ48mUWLFvGf//xH7XB6pKGhgcDAQL777ju2b9+Ov78/9fX1bNy4kU2bNqkdnkXExMSoHYLqJAeSAyPJg+QAJAdGPcnDgJzmzd7e3iLrVRSFO+64gzfffJO77rqLsWPH9nhdlorRnLQao4eHBxs3buSKK67gpptuoqWlxXRpZEuwRB6N8xMPJKmpqcTHx6sdhqokB5IDI8mD5AAkB0Y9ycOAbJAt8cuiKAr33Xcfb775Jvfffz/PPPNMr44c94dfaC3H6OzszPr167nqqqu45557uPTSSy12pUNL5DErK4tXX32V7OzsdicednahkP7MeEGTgUxyIDkwkjxIDkByYNSTPAzIBjk9Pd3sXzt8/fXXLFu2jLvvvrvXzTFYJkZz03qMTk5OrFu3jr1791r0MuCWyOPs2bO56aabuOyyyzR5SW0hhBDCkgZkg1xfX2/2dU6fPp3169d3eqnfrrJEjOY2EGJ0dHRk4sSJALz//vv4+PhwySWXmCM0E0vk0cnJicWLF5t9vdYsISFB7RBUJzmQHBhJHiQHIDkw6kke5NBSL61bt4709HR0Oh2XX365HK3TqJaWFl588UXmzJnDrl271A6nU/fccw+PP/44v/zyC3v27DH907Lc3Fy1Q1Cd5EByYCR5kByA5MCoJ3kYkEeQY2NjzbKen3/+mfnz53PJJZewfv16s6zTyFwxWtJAitHOzo5NmzZx9tlnc+mll/Lzzz+3m2e4NyyRx/379/Puu++ydetW04c2nU7H1q1bzb4ta3H8+HG1Q1Cd5EByYCR5kByA5MCoJ3kYkIc7S0pKer2O7OxsZs+ezeDBgy0yFZg5YrS0gRbjoEGD2Lx5M4qicOmll1JdXW2W9Voijx9//DG//fab6Sp627Zt03RzLIQQQpjTgGyQS0tLe/X86upqLrvsMpqbm9m0aRM+Pj5miux3vY2xLwzEGIcNG8Ynn3xCZmam2S64YYk8xsXFUVlZafb1WrPIyEi1Q1Cd5EByYCR5kByA5MCoJ3kYkEMseuvZZ5/l4MGDbN68meHDh6sdjuhjkyZNIj09nWHDhqkdSocqKysZMWIE48aNw9HREWgdYvHZZ5+pHJnlNDU1qR2C6iQHkgMjyYPkACQHRj3Jw4BskMPDw3v1/EcffZSpU6dywQUXmCmiU/U2xr4wkGM0Nse7du3ixIkTTJkypcfrskSMjz/+uOlnRVH44Ycf+PDDD82+HWuSl5dHQECA2mGoSnIgOTCSPEgOQHJg1JM8DMghFj2daeLo0aMcP34cBwcHizbH0PMY+9JAj9F45cSrr76aoqKiHq/HEjFOmjQJDw8PNm3axKJFi9i6dSu333672bcjhBBCaJH1dzgWkJWV1e3n1NbWMmvWLGbMmIGiKBaIqr2exNjXBnqMOp2ONWvWcOLECW655ZYe/16YM8bDhw/z+OOPM2LECO6++24GDx6Moihs27aNu+++22zbsUaBgYFqh6A6yYHkwEjyIDkAyYFRT/IwIBvknrjvvvs4dOgQ//jHP8xyIRChDSNHjuSZZ55h06ZNFpnNpLtGjBjB1q1b2bRpEz/++CN33303tra2aofVJyxxsmx/IzmQHBhJHiQHIDkw6kkeBmSD7Ovr263lv//+e958803++te/MnXqVAtF1V53Y1SDxNhq8eLFTJkyhSVLlpCTk9Pt55szxnXr1hEUFMSUKVO45ZZb2LJlS59842ENDh48qHYIqpMcSA6MJA+SA5AcGPUkDwOyQQ4ODu7ysg0NDdxyyy0MHTqUJ554woJRtdedGNUiMbaysbFh1apVLF26tEfbM2eMs2fP5sMPP+TQoUNMmTKFl156iZKSEv785z/z9ddfm207QgghhJap2iAbp0mLiorimWeeOeXxVatW4e/vT2JiIomJibz99ttm2e7+/fu7vGx1dTVDhw7l3//+Ny4uLmbZfld0J0a1SIy/Gzx4MA899BD29vbdPmJriRhdXV255ppr2LhxI/n5+YwePZpnn33W7NuxJq6urmqHoDrJgeTASPIgOQDJgVFP8qBag6zX67nzzjv58ssvSU9PZ+3ataSnp5+y3Ny5c0lJSSElJYWbb765z+MMCAjgyy+/5MILL+zzbYv+Z8uWLYwfP56qqiq1QzHx9vbm1ltvZcuWLWqHYlEjRoxQOwTVSQ4kB0aSB8kBSA6MepIH1RrknTt3EhUVxdChQ3FwcGDevHl9dhED44UTzkRRFB5//HGOHj3aBxGdqisxqk1iPJWXlxfJyck8+uijXX5Of8hjf5CSkqJ2CKqTHEgOjCQPkgOQHBj1JA+qXSikoKCAsLAw0+3Q0FB27NhxynL/+9//+P777xk2bBgvvvhiu+cYrVixghUrVgBQVFREcnIyACEhIbi4uHDkyBEAPD09iYyMpLGxkeTkZGxtbUlMTOTQoUPU1tYCrbMSVFRU8PHHH/PYY4/h6OjI7bffTmZmJtB6NG7w4MHs27cPAHt7e+Lj40lPT6e+vh6A2NhYSkpKTJcQDg8Px8bGxjSdl6+vL8HBwaav1h0dHYmLiyMtLY3GxkYARo0aRXZ2NuXl5QAMGTIEg8FgOgnM39+fgIAADhw4AICzszMxMTGkpqbS3NwMQEJCArm5uRw/fhxovdRiU1MTeXl5QOu0Jz4+PqbB666urowYMYKUlBT0ej0ASUlJZGZmmo6IRkdHU1dXR0FBAQCFhYV4eHiQkZEBgLu7O8OGDWPPnj0oioJOpyMpKYnDhw9TU1MDwPDhw6murubYsWNnrNOePXsAzlin4uJiAMLCwnBwcDilTsZaW7JOhYWF7eq0cOFCXn31VSZOnMjZZ5/dpTr99ttvHdZJdI3xd3YgkxxIDowkD5IDkBwY9SgPiko+/vhj5aabbjLdXrNmjXLnnXe2W6asrExpaGhQFEVR3nzzTWXKlCmdrnfMmDGdLrN///4zPt7U1KQMHz5cGT58uNLU1NTp+iyhsxitgcR4euXl5Yqvr68yffr0Li3fWYxd+Z3ur8z52nbv3m22dfVXkgPJgZHkQXKgKJIDo9PlobO/P6oNsQgJCWl3hCw/P5+QkJB2y/j6+pq+fr755ptNR4Z7y3j0ryNvvfUWGRkZPPfcc9jb25tlm93VWYzWQGI8PR8fH5YuXcrXX3/Nzp07O12+P+SxP0hKSlI7BNVJDiQHRpIHyQFIDox6kgfVGuRx48Zx5MgRsrKyaGpq4sMPP2TWrFntljF+BQ+wYcMGRo4cafG4amtreeyxx5g0aRKXXXaZxbcntOmOO+7g008/Zdy4cWqH0i2dzSyTk5PD1KlTiY+PZ/LkyeTn55seMw6FSUxMPGVf7gvG4TUDmeRAcmAkeZAcgOTAqCd5UG0Msp2dHcuXL+eiiy5Cr9dz4403EhsbyyOPPMLYsWOZNWsWr7zyChs2bMDOzg4fHx9WrVpllm2PGjWqw8eampq49tprufrqq1W9Yt6ZYrQWEmPHXFxcmD17NoBpLHZHrCWPxpllvvnmG0JDQxk3bhyzZs0iJibGtMx9993HggULWLhwIVu3buXBBx/k3XffBVrHV6t5Qog1zRyiFsmB5MBI8iA5AMmBUU/yoFqDDDBjxgxmzJjR7r62F+N4+umnefrpp82+3cLCQiIiIk77mLe3Ny+++KLZt9ldZ4rRWkiMnXvttdfYsGEDmzdv7rBJVjtGo7YzywCmmWXaNsjp6eksW7YMgClTppg+BAghhBBaomqDrJby8vLTNiSbN2/G3t6eCy64QNWjx9BxjNZEYuycra0tX3/9NT/++CPnnXfeaZdRO0ajrswsk5CQwLp167jnnnv49NNPqampoby8HF9fXxoaGhg7dix2dnYsXbq0w+a5u7POdHU2k+bmZkpKSk47m0lfzDrzx9lM1Jh1JioqiqNHj3Y460xQUJBVzzpjjjo1NzeTnJxs1XXqbHYgc9TJ29ub6upqq61TX+xPzs7OpvcXa62Tpfen5uZmUlNTrbpOfbE/hYSEmH4XjHXqlCXOFlRTV86KP93ZjC0tLUp0dLSSlJSkGAwGS4TWLf3hzFOJsXO1tbWKj4+PcuWVV3a4TGcx9tUsFl2ZWaagoEC54oorlMTERGXx4sVKSEiIcvz4cUVRFCU/P19RFEXJzMxUwsPDlaNHj3a6TXO+tmPHjpltXf2V5EByYCR5kBwoiuTA6HR5sNpZLNQ0ZMiQU+7btGkTR44cYenSpaofPYbTx2htJMbOubi4cNttt7F+/XrTJ/M/UjtGo67MLBMcHMy6devYu3cvTz31FNB6cRTj8wGGDh3K5MmT2bt3b98EfpLxaMFAJjmQHBhJHiQHIDkw6kkeBmSDbDAYTrnv3//+N8HBwVxxxRUqRHSq08VobSTGrrnjjjuwsbFh+fLlp33cGmKErs0sU1ZWZor36aef5sYbbwTg+PHjpq/dysrK+Omnn9qNXe6In5+fmV+FEEII0bnO/v4MyDHIOTk57RKTk5PD5s2befjhh7Gzs46U/DFGayQxdk1oaCjLli1jwoQJp33cGmKErs0ss337dh588EF0Oh3nn38+r732GgAHDx7ktttuw8bGBoPBwNKlS7vUIAOMHTvWLPGXlpbi7+9vlnX1V5IDyYGR5EFyAJIDo9PlQRrkLsjMzCQ0NJSbbrpJ7VCERt19991qh9Alnc0sM2fOHObMmXPK884++2zTyRzdsXnz5u4H2YGxY8eye/dus62vP5IcSA6MJA+SA5AcGPUkDwNyiMUfP0VccMEFZGdnEx4erlJEp+oPn/gkxu7Zt28fb7zxxin3W1OMQgghhBigDXJAQIDp5+PHj9PS0oKNjXWlom2M1kpi7J6PP/6Yu+66q90VIsG6YhRCCCHEAG2QjXPyATzwwAMMHz7cak6UMmobo7WSGLvn+uuvx2AwsHbt2nb3W1OM/dmtt96qdgiqkxxIDowkD5IDkBwY9SQPOkVRFAvEopqujDNJTk5mzJgxtLS0EBQUxLRp0/jggw/6KMKuMcZozSTG7hs/fjwtLS2mSeCh8xhlDJkQQgjRtwbkEWRnZ2cAvvvuO8rKyk570pHajDFaM4mx++bMmcPevXvJz8833WdtMQohhBAD3YCcxcI4/dQnn3yCi4sLF198scoR/a65uZn8/Hx0Op3p0orWqr/EmJWVRWhoKPb29mqHw6WXXspTTz3FwYMHCQ0NBejydGji9DZv3sw999yDXq/n5ptvZunSpWqHpIqIiAjc3d2xtbXFzs5uQHzrcOONN7Jp0yYCAgJIS0sDoKKigrlz55KdnU1ERAQfffQR3t7eKkdqOafLwWOPPcZbb71lOgH4n//85ymz02hJXl4eCxYsoLi4GJ1Ox6233so999wz4H4XOsrDQPp9aGho4Pzzz6exsZGWlhbmzJnD448/TlZWFvPmzaO8vJwxY8b8f3tnHhdltf/x97DviyI7AgKyLyq4XCvNcskUzb2stLQs2/Nmduv+0parWd1b3aybbVr3qpUtprZa2mKaguIGKiIoAgIKyL4Nz++PcZ4gthGYeWaY8369fMk8c+Y5n/k8Z2a+c+Z7zpcPP/wQGxubjk+mS4m+xsbGrlT2UwRdStceOnRIampqkgICAjosAawEp0+floqLi6XKykqlpXRKVVWV0hI6pbKyUiouLpZOnz6ttBRJkiSpqalJqq+vb3Hs0KFDHT7GUKWmTZHGxkZpwIABUlZWllRXVyfFxcVJx44dU1qWIgQGBkrFxcVKyzAoP/30k5SamipFR0fLxx577DFp5cqVkiRJ0sqVK6WlS5cqJc8gtOXB008/Lb344osKqjIs+fn5UmpqqiRJklReXi6FhYVJx44dM7ux0J4P5jQempqapIqKCkmSJKm+vl4aOnSotGfPHmnmzJnSxo0bJUmSpEWLFklvvPFGp+fSKcUiLCyMxx57jPT09J4I8BWnoaEBgHfffZfHHntMYTUtqa2tpW/fvkrL0AnJRNLX+/btS21trdIyAM2MtnYmW+ufdjwKrpx9+/YRGhrKgAEDsLGxYc6cOWzZskVpWQIDcc0119CnT58Wx7Zs2cK8efMAmDdvHl988YUCygxHWx6YGz4+PgwePBgAZ2dnIiMjycvLM7ux0J4P5oRKpcLJyQnQfLY2NDSgUqn48ccf5XRaXceCTgHyoUOHGDhwIAsXLmT48OGsXbuW8vLyrj8DI0ClUjF27FiGDx+utJRWqFQqpSX0KozNz5MnTxIVFcX333+vtBSTJy8vj4CAAPm2v7+/2X0gaFGpVIwbN44hQ4awdu1apeUoRmFhIT4+PgB4e3tTWFiosCJleP3114mLi+POO++ktLRUaTkGIycnh4MHDzJs2DCzHgvNfQDzGg9qtZqEhAQ8PT0ZO3YsISEhuLm5yZWSdf2c0ClAdnZ25q677uK3337jhRdeYMWKFfj4+DBv3jxOnTrVvWeiAPHx8Xz00Ufs2bNHaSnt4uDgoLSEThEau4avry8nTpzg119/BTTjUSDoLr/++isHDhzg66+/Zs2aNfz8889KS1IclUpldF+QDcG9995LVlYWaWlp+Pj4sGTJEqUlGYTKykqmT5/OK6+8gouLS4v7zGks/NkHcxsPlpaWpKWlce7cOfbt28fx48e7dB6dAmS1Ws2XX37JTTfdxMMPP8ySJUs4ffo0kydPNslE75ycHB544AH+85//KC2lXerr6xXpNycnh5iYmBbHli9fzksvvdSqbXONKSkpPPjggwDs2rWL33777Yr6nThxImVlZTq3nz9/Pps3b+60nVI+doSTkxPx8fHyF7SzZ88qrMh08fPzIzc3V7597tw5/Pz8FFSkHNrn7enpyU033cS+ffsUVqQMXl5ecjGegoICsyzE4+XlhaWlJRYWFtx1111mMRYaGhqYPn06c+fOZdq0aYB5joX2fDC38QDg5ubGtddey549eygrK6OxsRHQ/XNC5xzkLVu28Nhjj3Hw4EEeffRRvLy8mDFjhlHtAKErhw4dori4mFGjRiktpV20F9KYaa4xMTGR1157DehagPzVV1/h5ubW4pgkSd0u4GKsPv7lL39h7969qNXqXv9zlz5JSkoiMzOT7Oxs6uvr2bRpE8nJyUrLMjhVVVVUVFTIf3/33XetvuiaC8nJyaxfvx6A9evXM2XKFIUVGZ7m1To///zzXj8WJEliwYIFREZG8uijj8rHzW0stOeDOY2H4uJiebKtpqaG77//nsjISK699lp5Uk3nsdDZKr7GxkZpxYoVXV9SaGB0WfH/3HPPSUCnuwcoQXp6uiRJkmK7WGRnZ7dYDS1JLVdEjxo1Slq6dKmUlJQkhYaGSj///LMkSZK0c+dO6cYbb5Sys7MlLy8vydfXV4qPj5fv11JRUSHNnz9fiomJkWJjY6XNmzdLkvTHCvzs7Gxp4MCB0m233SZFRUVJOTk50qpVq6SYmBgpLi5OevzxxyVJkqR58+ZJn3zyiSRJkpSSkiJdc8010uDBg6Vx48ZJ+fn5cn9aH7W+Ggv//e9/JUBKS0uTUlJSOmwrdrHomO3bt0thYWHSgAEDpOeee05pOYqQlZUlxcXFSXFxcVJUVJTZ+DBnzhzJ29tbsrKykvz8/KR33nlHunDhgjRmzBgpNDRUuu6666SLFy8qLVOvtOXBrbfeKr/HTp48ucV7Ym/kl19+kQApNjZWio+Pl+Lj46Xt27eb3VhozwdzGg+HDh2SEhISpNjYWCk6OlqOX7OysqSkpCQpJCREmjFjhlRbW9vpuTrdB9nS0pJt27bxf//3f12O6I2NwsJCbG1tiYyMVFpKu9ja2gIwevToVvfNmjWLxYsXU11d3WaKy/z585k/f36bRVB27drVbW2NjY3s27ePrVu3smLFCnbs2CHfFxQUxD333IOTkxN//etfWz322WefxdXVlSNHjgC0OXuamZnJ+vXrGT58OF9//TVbtmzh999/x8HBgZKSkhZtGxoaeOCBB9iyZQv9+vXjo48+4sknn+S9994D/vDR2Lj66qu57bbbsLKyIjAwUGk5Js3EiRNNMtWrJxkwYACHDh1SWobB+XPZdi0//PCDgZUoR1seLFiwQAElynHVVVe1u6uSOY2F9nwwp/fHuLg4Dh482Or4gAEDrji1RKdCISNHjuT+++9n9uzZODo6yse124mYGkePHiUmJsYoCke0R3svdn3T3iKG5se1eU2DBg0iJyfnis6/Y8cONm3aJN9ua9P2wMBAeXeRHTt2cMcdd8iL7f68ndGJEyc4evQoY8eOBTT58tpVy2C8W9H179+fDz74AICioiKF1QgEAoFAIGiOTgFyWloaQItZZO2+cqbIypUrW2wNZYzU19djbW3d4Yyvg4NDh/d7eHhc8Yxx3759W83qlpSUEBwcLN/Wzsqq1Wq95Pg2/xLWGZIkER0d3e6OJFofjRFJkigpKSE3N9csFo8IBAKBQGAq6LRIb+fOna3+mWpwDGBlZYWvr6/SMowSJycnfHx85OtbUlLCN998w1VXXaXzOZydneUFQ39m7NixrFmzRr7d2QK1sWPH8v7771NdXS3raU54eDjFxcVygNzQ0MCxY8d01qok99xzT69eLCEQCAQCgamiU4AMsH37dlavXs0zzzwj/zNF0tPTef311684NcDQKDnr+cEHH/Dss8+SkJDAmDFjePrppwkJCWnVrj2NkydP5vPPPychIYFffvmlxX1PPfUUpaWlxMTEEB8fz86dOzvUMmHCBJKTk0lMTCQhIaHVdnM2NjZs3ryZxx9/nPj4eBISElrsoGGss8cAISEhnD9/Hjs7O6WlCAQCgUAgaIZK0iFJ85577qG6upqdO3eycOFCNm/ezNChQ3n33XcNofGKSExMJCUlpd37//vf/3LbbbeRkZFBRESEAZXpRkZGBpGRkajVaiwtLZWW0yGmpFHrqzGxdetWkpOT+fHHH7n22mvbbdfZmBYIBAKBQNCz6DSD/Ntvv/HBBx/g7u7O008/zZ49ezh58qS+tekF7cyxse8cUFtbq7SEThEau8eAAQMAjLqio0Ag0A/PP/880dHRxMXFkZCQwO+//663vkaPHi2+ZAsEV4hOi/Ts7e0BzaKw/Px8+vbt22LjaVMiOzubvn37ys9JIFAK7W4bFy9eVFiJQCAwJHv27GHbtm0cOHAAW1tbLly4YJRVPwUCc0anGeRJkyZRVlbGY489xuDBgwkKCuLmm2/Wtza9cObMGfz9/ZWW0SkWFjqnhyuG0Ng93N3deeaZZxg6dKjSUgQCgQEpKCjAw8ND3hHIw8MDX19fnnnmGZKSkoiJieHuu++Wt6kcPXo0jzzyCImJiURGRrJ//36mTZtGWFgYTz31FKD5dTQiIoK5c+cSGRnJjBkz5MXNzfnuu+8YMWIEgwcPZubMmVRWVhruiQsEJoRO0cPf//533NzcmD59OmfOnOH48eM8++yz+tamF9RqdYsty4wVU5jhFhq7h0ql4u9//zuzZ89WWopAIDAg48aNIzc3l4EDB7J48WJ++uknAO6//37279/P0aNHqampYdu2bfJjbGxsSElJ4Z577mHKlCmsWbOGo0ePsm7dOvlXqBMnTrB48WIyMjJwcXHhjTfeaNHvhQsXeO6559ixYwcHDhwgMTGRf/7zn4Z74gKBCaFTigVo8pBzcnJa7Ht7++2360WUPtm5c6e8r7MxU11dLRfHMFaExu5TVFTE3r17SU5OVlqKQCAwEE5OTqSmpvLLL7+wc+dOZs+ezapVq3B2dmb16tVUV1dTUlJCdHQ0kydPBpDfI2JjY4mOjpZTtAYMGEBubi5ubm4EBAQwcuRIAG699VZee+21FhVN9+7dS3p6utymvr6eESNGGPKpCwQmg04B8m233UZWVhYJCQnyrgUqlcokA2TQzCIbO8ZaAa45QmP3ueOOO8jOzhYBskBgZlhaWjJ69GhGjx5NbGwsb731FocPHyYlJYWAgACWL1/eYpGxNh3DwsJC/lt7Wztx9edKqH++LUkSY8eObbdEt0Ag+AOdAuSUlBTS09PbLUNsKjQ1NTFr1ixGjBjBkCFDlJZjlHz++eesWLGixbHDhw+zfft2brjhBoVU9VIkCXt7e+rq6uTbmPhrTCAQdM6JEyewsLAgLCwM0FSrDQ8P5/Dhw3h4eFBZWcnmzZuZMWPGFZ337Nmz7NmzhxEjRrBhw4ZWBZ6GDx/Offfdx6lTpwgNDaWqqoq8vDwGDhzYY89NIOgt6JSDHBMTw/nz53u882+++Ybw8HBCQ0NZtWpVq/vr6uqYPXs2oaGhDBs2rNvFPSoqKvj000+NflYRUCwt4KabbiItLU3+t3jxYq6++mrGjx/fqu2fNUqSRFNTk6Gk6oTRplfsXAnfPIGdnZ3mi6ckwTdPaI4LBIJeTWVlJfPmzSMqKoq4uDjS09NZvnw5d911FzExMYwfP56kpKQrPm94eDhr1qwhMjKS0tJS7r333hb39+vXj3Xr1nHzzTcTFxfHiBEjOH78eE89LYGgV6HTDPKFCxeIiopi6NChLX7a+fLLL7vcsVqt5r777uP777/H39+fpKQkkpOTiYqKktu8++67uLu7c+rUKTZt2sTjjz/ORx991OU+tT9DlZeXd/kchqKurk6nCmtfHMzjxW9PkF9Wg6+bPY+ND2fqIL8e0XDy5EmeeeYZfvvtNywsLHjxxRf5+OOPqaur46abbuKJJ57g/PnzjB8/nmHDhpGamspXX33F66+/ztdff41KpeKpp55i9uzZFBQUMHv2bMrLy2lsbOTNN9/k6quv7hGdHaGrjwZFkqD2Evz+JnbFQZpV5N88Ab+/CcPuFTPJAkEvZ8iQIS0qfmp57rnneO6551od37Vrl/y3Ni3jz/fl5ORgZWXFf//73w4fP2bMGPbv399l7QKBuaBTgLx8+fIe73jfvn2EhobKxRLmzJnDli1bWgTIW7ZskfueMWMG999/P5IkdTvVo6ampluPNwS65El/cTCPJz47Qk2Dpm1eWQ1PfHYEoNtBckNDA7fccgsvv/wy/fv357vvviMzM5N9+/YhSRLJycn89NNPhIeHk5mZyfr16xk+fDiffvopaWlpHDp0iAsXLpCUlMQ111zDhg0bGD9+PE8++SRqtbrN7Yf0gVHmm6tUMEEzU2z31T+prbL6IziesFIExwKBQCAQKIxOAfKoUaN6vOO8vDwCAgLk2/7+/q0qCTVvY2VlhaurKxcvXsTDw6NFu7Vr17J27VoAzp8/T2pqKgB+fn44ODiQmZkJIP/8X11dTWpqKpaWliQkJHD8+HGqqqoAiIyMpKSkhMLCQgACAgKwsbEhKysL0Oxd279/fw4dOgSAtbW1/BOZNvCOjo6mqKiI4uJiQFO1z8LCguzsbAD69u2Lr68vR45ogllbW1tiYmI4evQoarVa1lJXVyfPetva2iJJkryZvJWVFau/PS4Hx1pqGtS88E0GYwe64eDgQH19fbvnsLa2xtLSUl4IYmFhgb29PdXV1fz9738nPDycWbNmUVtby/bt2/n2228ZNGgQkiRRWVlJZmYmwcHBBAYGEhsbS1VVFbt27eLmm2+mtrYWJycnRo4cyf79+4mPj2fRokVUVVUxffp0uT1oti+ysLCQdVhaWmJraysH0SqVCgcHB2pqauRraGdnh1qtpqGhQT6HSqWS83mtrKywsbGR/dQ+5566Ttp+YmNjyc/Pl7dZCg4OpqmpiTNnzgCanzQ9PT05duwYoNl2LioqisNHjtDgOZP+SRlM8SjktIcfpZ4z4cABQkJCqK+vJzc3F4FAINCFoKAgjh49qrQMgaDX0GGAfNVVV/Hrr7/i7OzcYtZWO4trLKkKd999N3fffTcAiYmJrRbgaW+Xlpbi5+dHVFRUizYREREt2js4OLQqJtLeObU0n/kG6N+/P/37929xrE+fPh2eIyYmhoyMDBwdHVGr1XKg2Bxra2v574Kytsson79Uh6OjI6AJ6jo6ByC31bJv3z6+/PJLDhw4gEqlws7ODisrK/72t7+xaNEiuZ1arSY3NxdHR0f5HFZWVi3Oqb19/fXX88svv7B9+3YWLFjAo48+2moXlD/r+PPtP+9pbGlpiY2NTYtj2v6an6N5u566Ts0JCgoiKCioxbE/f4n78zniYmPhmycY0m8X5QF+uFzIgKKwFjPInp6eCAQCgUAgMDwdLtL79ddfAc3itvLycvmf9nZ38PPzazFDdu7cOfz8/Npt09jYyKVLl+jbt2+X+3R3d+fcuXNMnz69y+cwFLosdvN1a7sIRnvHdaG0tJQ77riDDz74AGdnZ/n4+PHjee+99+SqS3l5eW0u3Lz66qv56KOPUKvVFBcX8/PPPzN06FDOnDmDl5cXd911FwsXLuTAgQNd1nglGNuiQeCPBXm/v0ntoLu4dMs3mvSK39/UHDeBRaQCgUAgEPRmdEqxKCkpaXXM2dm51UzklZCUlERmZibZ2dn4+fmxadMmNmzY0KJNcnIy69evZ8SIEWzevJkxY8b0yFZzeXl5eHt7d/s8+qS+vr5Tfx8bH94iBxnA3tqSx8aHd7nf//znPxQVFbVa/fzEE09wyy23yJvKOzk5sXbt2hZBNGh2wdizZw/x8fGoVCpWr16Nt7c369ev58UXX8Ta2honJyc++OCDLmu8EnTx0eCoVGDnCsPu5c4Pz7L7was5o92hxc5V5CALBAKBQKAwKkmHPc+CgoLIzc3F3d0dSZIoKyvD29sbLy8v3n777S7vKfzVV1/x8MMPo1arufPOO3nyySf5v//7PxITE0lOTqa2tpbbbruNgwcP0qdPHzZt2iQv6muPxMREUlJS2r1/2rRpREZG8vzzz3dJs77JyMggMjKSqqqqVikGbaHPXSw6Q1eNSqLVqPXVqJAkpk2fzpEjRzR58u3sXtHZmBYIBAKBQNCz6DSDPHbsWGbMmCHvhfvdd9/x6aefcscdd7B48eJWi+t0ZeLEiUycOLHFsWeeeUb+287Ojk8++aRL526Pn3/+udWspzGi66zn1EF+BguI/4zRzcy2gVFrVKmorq7GyclJvi0QCAQCgUB5dCoUsnfv3haFIsaNG8eePXsYPnz4H1XATAR3d3eT2OZNW9LbmBEau09xcTFeXl5KyxAIBAKBQNAMnQJkHx8fXnjhBc6cOcOZM2dYvXo1Xl5eqNVqLCx0OoXR4ObmRl5entIyOkW75ZkxIzR2n4KCAuMrZCIQCAQCgZmjU3S7YcMGzp07x9SpU5k6dSpnz55lw4YNqNVqPv74Y31r7FH69evX5qJDgUAJHnrooRZVsQQCgUAgECiPTjnIHh4e/Pvf/27zvtDQ0B4VpG8GDRokF6gwZow9NQCExp7g8ccf5+TJk0rLEAgEAoFA0AydAuTi4mJWr17NsWPHWvxk/eOPP+pNmL4w1t0r/owp/OwuNHaPiooKSktLCQsLU1qKQCAQCASCZuiUYjF37lwiIiLIzs7m6aefJigoiKSkJH1r0xuGKlLRHZSc5daW4I6JiWHmzJlyyec/U1VVxbp167j//vsNrFB3jPnXgm+++YbAwEA2btyotBSBQCAQCATN0ClAvnjxIgsWLMDa2ppRo0bx3nvvmeTsMUBWVha33HIL33zzjdJSeoY/b2PdA1XY7O3tSUtL4+jRo9jY2PCf//yn2+cUtCYjIwOVSkVgYKDSUgQCgUAgEDRDpwBZu5esj48P27dv5+DBgya70M3NzY0TJ05w5MgRpaV0n50rW5Ym1pYw3rmyx7q4+uqrOXXqFCUlJUydOpW4uDiGDx/O4cOHW7UtLi5m+vTpJCUlkZSUxO7duwH46aefSEhIICEhgUGDBlFRUdFj+kyZjIwMAgMDsbfvemlwgUAgEAgEPY9OOchPPfUUly5d4uWXX+aBBx6gvLycf/3rX/rWphf69u2Lv78/aWlpSkvpkE4r1EkS1F6C39/U3J5wOVj+/U0Ydm+7VdmuhMbGRr7++msmTJjA008/zaBBg/jiiy/48ccfuf3221t5+NBDD/HII49w1VVXcfbsWcaPH09GRgYvvfQSa9asYeTIkVRWVho0L9iYK/0dP36cyMhIBg8erLQUgUAgEAgEzdApQJ40aRIArq6u7Ny5U6+CDEFYWBgHDx5UWkaH1NbWdhxIqlSaoBg0QbE2UB52r+Z4N4LjmpoaEhISAM0M8oIFCxg2bBiffvopAGPGjOHixYsUFRW1eNyOHTtIT0+Xb5eXl1NZWcnIkSN59NFHmTt3LtOmTcPf37/L2q6UTn1UiKamJk6cOMGYMWM4efIkAwcOVFqSQCAQCASCy+gUIGdnZ/Pvf/+bnJwcGhsb5eNffvml3oTpk9DQUHbt2kVVVZXRzjCq1erOG2mDZG1wDN0OjuGPHOTO+LPGpqYm9u7d2yogXbZsGTfeeCNfffUVI0eO5NtvvyUiIqJbGnVFJx8VQK1W8/777xMcHCxSTgQCgUAgMDJ0ykGeOnUqQUFBPPDAAyxZskT+Z6oMGTKEWbNmUV5errSU7qHNOW5O85zkHuTqq6/mf//7HwC7du3Cw8MDFxeXFm3GjRvXYr9sbZCdlZVFbGwsjz/+OElJSRw/frzH9Zka1tbWzJ49m6FDhyotRSAQCAyGSqXC0dGRJ598Uqf2Y8aMwc7OjquuukrPygSClugUINvZ2fHggw9y7bXXMmrUKPmfqTJ37lw2bdqEj4+P0lLapdO0AG1wrM05frpM8//vb+olSF6+fDmpqanExcWxbNky1q9f30rja6+9RkpKCnFxcURFRcm7X7zyyivExMQQFxeHtbU1N9xwQ49q6whjTK8A+P777zl06BAA4eHhCqsRCHoXv/76K3/5y19wdXWlT58+jBw5kv379wMQFBTEjh079NZ3UFAQ9vb2ODk54e3tzfz586msrNRbf6bIoUOHdK5J8OOPP4qdlASKoFOKxUMPPcSKFSsYN24ctra28nFTXVxUXl6Ok5MTFy5cwMPDQ2k5baJWqzuuAqdSgZ1ry5xjbU6ynWu30izaejPv06cPX3zxRYtj9fX1zJ8/n/nz5wOaiosfffRRq8e2V4XREHTqo0Lcd999REVF8cUXX8jjUSAQdJ/y8nImTZrEm2++yaxZs6ivr+eXX35p8dmlb7Zu3cr111/P+fPnGT9+PCtXrjSZIlUCgUCDTjPIR44c4e2332bZsmVyesVf//pXfWvTGwUFBSxdupSwsDCjzVFtaGjovNG1T7TMOdYGydc+0fHjegidNCqMMWosLi4mMzOTv/zlL4BmPAoEgp5BW7r95ptvxtLSEnt7e8aNG0dcXBy33XYbZ8+eZfLkyTg5ObF69WoA8vPzmT59Ov369SM4OJjXXntNPl9QUBArV64kKioKd3d37rjjjhYVZTvC29ub8ePHt1jT0VFfL7zwAn5+fjg7OxMeHs4PP/ygk46MjAxGjx6Nm5sb0dHRrdYHBQUF8dJLLxEXF4erqyuzZ8+WH9tenx3p7IzTp09z4403yql4Y8eObbftW2+9xcSJE7nvvvvw8PDA19eX77//Xue+BAJ9oVOA/Mknn3D69Gl++ukndu7cyc6dO022UIiWQYMGUVZWZvTbvXXKn2eKu7lAT6B/tD/vXnPNNQorEQh6HwMHDsTS0pJ58+bx9ddfU1paKt/34Ycf0r9/f7Zu3UplZSVLly6lqamJyZMnEx8fT15eHj/88AOvvPIK3377rfy4//3vf3z77bdkZWVx8uRJnnvuOZ20nDt3jq+//prQ0FCADvs6ceIEr7/+Ovv376eiooJvv/2WoKCgFudrS0dDQwOTJ09m3LhxFBUV8e9//5u5c+dy4sSJFo/9+OOP+eabb8jOzubw4cOsW7eu3T518aQjbr/9diZOnEhhYSFFRUUsX7683baHDh1i7969JCcnU1RUxKJFi3jhhRd06kcg0Cc6BcgxMTGUlZXpWYrh8PPz49prrwVo8Q3dWJAkCRsbG6VldIqpaJT0sGixO2zfvh0PDw+5XLufn5/CigSC3oOLiwu//vorKpWKu+66i379+pGcnExhYWGb7ffv309xcTH/93//h42NDQMGDOCuu+5i06ZNcpv777+fgIAA+vTpw5NPPtlpefipU6fi7OxMQEAAnp6erFixotO+LC0tqaurIz09nYaGBoKCgggJCWlx3rZ07N27l8rKSpYtW4aNjQ1jxoxh0qRJrTQ++OCD+Pr60qdPHyZPnkxaWlq7feriSUdkZWWhVqtRq9XY2dkxcuTIdtsePnyYZcuWMX78eCwsLIiKitKpD4FA3+gUIJeVlREREcH48eNJTk6W/5kqDg4OeHt7ExUVpfM3YkNhZ2fHxYsXUZnATLCFhU7DR1FUKhUXL140msV6kiSxc+dObrjhBjk32sHBQWFVAkHvIjIyknXr1nHu3DmOHj1Kfn4+Dz/8cJttz5w5Q35+Pm5ubvK/f/zjHy0C6oCAAPnvwMBA8vPzO+z/iy++oKKigl27dnH8+HEuXLjQaV+hoaG88sorLF++HE9PT+bMmdOqn7Z05OfnExAQ0OL9ODAwkLy8vBaP9fb2lv92cHCgsrKy3T518aQj/ve//7FlyxZ8fX1ZsGBBu5V3JUniyJEjTJ48WT529OhRESQLjAKdFulpv/32FjIzMxkyZAhTpkxh9erVRrVYz9/fn3PnznHu3DmDLirpCvX19UY/i1xXV4erq6tBi5N0hEql4sSJE1y6dEk+ph2PAoGg54mIiGD+/Pm89dZbAK0mHwICAggODiYzM7Pdc+Tm5sp/nz17Fl9fX536HjVqFPPnz+evf/0rX3zxRad93XLLLdxyyy2Ul5ezaNEiHn/8cT788MMOdfj6+pKbm0tTU5McJJ89e1bn4kNt9bl48eJOPemIMWPGMGbMGIqKipg4cSLr1q3j0UcfbdVOW1uh+U4+Bw8eZOrUqV3qVyDoSXQKkE15S7eOuOOOO4iNjTWqYiHW1tYEBweTmppKZGSk0nI6JDU1lfj4eKVldEhqairBwcFKy2iBk5OT2LVCINATx48fZ/v27cyePRt/f39yc3PZuHEjw4cPB8DLy4vTp0/L7YcOHYqzszMvvPACDz74IDY2NmRkZFBTUyOnQa1Zs4ZJkybh4ODA888/z+zZs3XW8/DDDxMUFMShQ4c67MvFxYW8vDxGjhyJnZ0d9vb2rRaRt6Vj2LBhODg4sHr1apYsWcLu3bvZunWrvK1dR5w4caLNPnXxRLt70bp161qc87PPPiM2NpbQ0FAqKiooLS2VK7P+mcOHDxMbG9ti9vvgwYM8/fTTOvsrEOiLDn8jd3Z2xsXFpdU/7XFTxdXVFdCUnL755puxt7dXWFFrtBqNGaHxypAkialTp8olu7UYk0aBwNRxdnbm999/Z9iwYTg6OjJ8+HBiYmJ4+eWXAXjiiSd47rnncHNz46WXXsLS0pJt27aRlpZGcHAwHh4eLFy4sMWvPLfccgvjxo1jwIABhISE8NRTT+msp1+/ftx+++0888wzHfZVV1fHsmXL8PDwwNvbm6KiIlauXNniXG3psLGxYevWrXz99dd4eHiwePFiPvjgA52qlbbXpy6e5Obmtplb/OuvvzJq1CicnZ2ZOHEiy5YtY8yYMW32f/jw4RbB84ULFzh//jwxMTE6uisQ6A+VZGwrmLpJYmIiKSkpHbaRJEn+me38+fN8+OGHLFy4EHd3d0NI1InmGo0VofHK+O233xg5ciTr1q1j3rx58vHONOoypgUCgX4ICgrinXfe4frrrxc6LlNfX098fDyHDx/G2tr6ih5rZ2eHra0tDz74IM8++2yn7ceOHcvevXsZOnSoUS6qF/RejH+VlR44cOCA/PfZs2dZunRpq1k9pWmu0VgRGq+MDz/8EHt7e6ZNm9biuDFpFAgEgs7QplxcaXAMUFtby6VLl3QKjkFTdbSiokIExwKDY5YBcnOSkpKIiori7bffVlqKoBdTV1fHRx99xE033YSzs7PScgQCgUAgEHSATov0ehvNSw+rVCoWLVrEQw89RFpaWruLCQyNMZZH/jNCo+5s376d0tJSbrvttlb3GYtGgUDQmpycHKUlAMajQyAwF8xyBvnPQfBtt92GnZ0da9euVUZQGxhLoN4RQqPu9O3bl2nTprWZP2gsGgUCgUAgEGgwyxnk48ePt1jh6+7uzs0332xU1QL/rNEYERp1Z9SoUe1ul2gsGpXAw8OjVTndrtLQ0NClnMjehPBAeKBF+CA8AOGBlrZ8yMnJkYv4tIVZBshVVVWtjr3zzjtGVRmuLY3GhtCoG19++SXDhw/H09OzzfuNQaNSBAUF9dgOHampqWZfcEV4IDzQInwQHoDwQEtbPiQmJnb4GOOJCBVGGxyfOnWKhoYGhdUIegtFRUXMmjWr11WjFAgEAoFACQy1O7FZBsjtVag7ePAg4eHhbNiwwcCKWmPsVfRAaNSFN954g7q6Oh544IF22yitsbcgfBQegPBAi/BBeACm7UFTk0TOhSq+OlLAi98e54739zHsHzs4knep8wf/ia74YJYpFiUlJTg4OLQ6npCQQGxsLCtXruTWW29VdHeB9jQaE0Jj533/61//YurUqR3mGJuCj6aA8FF4AMIDLcIH4QGYjge1DWoyCytJL7hEen45x/LLySgop6peU27d0kJFmKcTI0M9sLG68rndrvhglgFyYWEh/v7+rY6rVCqeeOIJ5syZw+eff86MGTMUUKehPY3GhNDYMS+99BIVFRU888wzHbYzBR9NAeGj8ACEB1qED8IDME4PyqrrSS8oJz3/8r+Cck4VVdLYpEmdcLSxJMrXhRlD/InydSHa15VQTyfsrLs+adkVHxQJkEtKSpg9ezY5OTkEBQXx8ccft1nm2dLSktjYWAD69+/Pl19+qXdtM2bMIDw8nKeeeoopU6aI1Z+CLpOXl8fNN98sj2GBQCAQCMwFSZI4V1ojB8PaWeG8shq5jZeLLVE+Llwf6UWUrwtRPi707+OAhYVKQeUaFAmQV61axXXXXceyZctYtWoVq1at4oUXXmjVzt7enrS0tB7vPyAgoN37LC0tWb16NbNmzSIlJYURI0b0eP+60JFGY0Fo7Jj169fT2NjYaTtT8NEUED4KD0B4oEX4IDwAw3nQoG7iVFElx+RZYU2qRHmt5jPQQgUD+jkxJNCd20YEEu3rQqSPCx5OtgbR1xUfFAmQt2zZwq5duwCYN28eo0ePbjNA1hc2NjYd3j958mSys7Px8fExkKLWdKbRGBAa2yY7O5vq6mqio6Oxsur8JWYKPpoCwkfhAQgPtAgfhAegHw/Kaxs4XlDBsfxLcopEZmEl9eomAOysLYj0cWFyvK88Kxzh7YK9jXLrurrigyIBcmFhoRx8ent7U1hY2Ga72tpaEhMTsbKyYtmyZUydOrVH+s/KyupwX0CVSoWPjw+SJJGVlUVoaGiP9HsldKbRGBAaWyNJEvfddx+///47ubm5Oi0KMAUfTQHho/AAhAdahA/CA+ieB5Ikcb68Vk6P0AbDZ0uq5TZ9HW2I8nXhjquCiPZ1JcrHhWAPRyyNIEWiOV3xQW8B8vXXX8/58+dbHX/++edb3FapVKhUbRt55swZ/Pz8OH36NGPGjCE2NpaQkJBW7dauXSuXiT5//jypqakA+Pn54eDgQGZmJgCurq6EhIRQUlJCamoqlpaWJCQkcPz4cblYQ2RkJCUlJRQWFrJ+/XrWrl3L7t275b7c3d3p378/hw4dAsDa2pq4uDjS09OpqdHk1URHR1NUVERxcTEAgYGBWFhYkJ2dDWjKDvv6+nLkyBEAbG1tiYmJ4ejRo9TV1QHQ1NRETk4OFy9eBCA4OJimpibOnDkDQL9+/fD09OTYsWOAJh0lKiqKw4cPy/s4x8fHc/bsWUpLSwEICQmhvr6e3NxcALy8vOjTpw8ZGRkAODo6EhERQVpaGmq1ZuXo4MGDycrK4tIlzbYqYWFhVFdXk5eXR0lJCfn5+bi4uHDixAkAnJ2dGThwIAcOHECSJFQqFYMHD+bkyZNUVFQAEB4eTnl5OQUFBR1epwMHDgB0ep1A8/OJjY0NWVlZLa6T9lrr6zrFxsaSn58vX6eMjAy+/vprHnnkETIyMnS6Tk1NTZw+fbrd6yQQCAQCgT5pVDdx+kJVi1nh9PxySqv/qAsR7OFIrJ8rs5MCiPJxIdrXhX7Otu3GcKaOSjLUjsvNCA8PZ9euXfj4+FBQUMDo0aPlAKs95s+fz6RJkzrdWSIxMbHTylynT59mwIABnerMz88nMjKSwYMH8+OPPxp0EOiqUUmExpZUV1cTFRWFk5MTBw8e1HmBZ2cadRnTpkpPPjdTGI/6RnggPNAifBAeQNseVNU1cvz8Hwvn0gvKOX6+gvpGTYqEjZUF4V7ORPu6/JEi4eOCk63pbnzWlg+dff4o8myTk5NZv349y5YtY/369UyZMqVVm9LSUhwcHLC1teXChQvs3r2bpUuX9kj//fv316mdr68vL774IosWLeK9995jwYIFPdK/LuiqUUmExpY8//zznDlzhl27dl3R7iem4KMpIHwUHoDwQIvwQXgAYOfuxc4TRS1mhXMuVqGdGnVzsCbKx4XbhwcS7edClI8rA/o5Ym3Zu+rIdWUsKBIgL1u2jFmzZvHuu+8SGBjIxx9/DEBKSgr/+c9/eOedd8jIyGDRokVYWFjQ1NTEsmXLiIqK6pH+Dx06pHMuysKFC9mwYQNLlixh4sSJBlu4dyUalUJobImNjQ133nkno0aNuqLHmYKPpoDwUXgAwgMtwgfz8kDdJJFzsapFrnB6fjkXKuvkNgF97InycWFqgp88O+zjatdrUySa05WxoEiA3LdvX3744YdWxxMTE3nnnXcA+Mtf/iLnfiqJhYUFb7/9NmPHjuXUqVOK7mwhMG6efvppg9WIFwgEAoF5UlOv5kRhxeUUiUuaFImCCmoaNGuHrCxUhHk5Mzq8H86Nlxg/LJpIHxdc7UVdhyvBdBNKusGVFv8ICwvj1KlTOm3Z1VOYQoESoVHDs88+y/Dhwxk7dmyXvombgo+mgPBReADCAy3Ch97hwcXKuj+qzhVocoZPF1dyuegczrZWRPq6MDspQJ4VDvV0wtZKs6Xa4cOHiRvQV8FnYBx0ZSwoskhPn+hzQVNTUxOrV69m0qRJxMTE6KUPgWnx/fffM27cOB588EFeffVVvfQhFukJBAJB76apSSK3tLpVisT58lq5jY+rnSYI9nGRSzD7u9ubRYqEPjDKRXpKk56e3qV85pKSEl555RU+/PBD9u/fr9Met12lqxoNiblrzM3NZe7cuURGRrJq1aoun0cpH6urq3n55Zc5e/Ysb7/9NpmZmZw4cYJJkyYZXEtPYArjUd8ID4QHWoQPxutBXaOazMLKZrPCl8goqKCyTlN1ztJCRUg/R0aE9JWD4SgfF9wdr7zYhbF6YGi64oNZBsjafXCvFA8PD/773//KM4bafGl90FWNhsScNdbV1TFjxgxqa2v57LPPsLe37/K5lPLxjjvuYMiQIezZswfQ7Ec9c+ZMkw2QTWE86hvhgfBAi/DBODy4VN3AsYKWewufKqqk8XKOhIONJZE+Ltw06I+FcwO9nLGz7pmqc8bggTHQFR/MMkDuDtdffz1/+9vfeP755xk8eDCLFy9WWpJAAT744AP27dvHZ599RkREhNJyukRWVhYfffQRGzduBMDBwUEsMhQIBIIuIEkSeWU1rVIk8sr+CMw8nW2J8nVhTISnnCIR2McBCyOrOifQYJYBcnR0dLcev2LFCg4dOsSSJUuYNm0a3t7ePaTsD7qr0RCYs8aFCxcSERHB1Vdf3e1zKeWjjY0NNTU1cv5aVlYWtra2imjpCUxhPOob4YHwQIvwQX8eNKibOFXUMkUiPb+c8lpNioRKpak6NzjQnVuHB8opEv2cDf/+KsaBhq74YJYBclFRUbc2ELe0tGTDhg0cOXJEL8ExdF+jITBHjbt27cLX15eBAwf2SHAMyvm4YsUKJkyYIOdS7969m3Xr1hlcR09hCuNR3wgPhAdahA8940FFbQMZBRWkX95O7Vh+OZmFldSrNVXnbK0siPB25sY4XzlFIsLbGQcb4wivxDjQ0BUfjOMKGpji4uJuDxhnZ2f+8pe/ALB161ZGjBiBh4dHT8gDekajvjE3jQcOHGDy5MkMGzaMHTt29Mg5QTkfx44dy+DBg9m7dy+SJPHqq6/26Bg2NKYwHvWN8EB4oEX4cGUeSJJEYXkd6QWXOJZ3OUWioJwzF6vlNn0cbYj2deGOkUGXUyRcCOrriJURV50T40BDV3wwywC5JykoKGD27NlERkby448/4urqqrQkgR44ffo0EydOpE+fPnzwwQdKy+kWBw4caHFbW/zm7NmznD17lsGDByshSyAQCAxCo7qJ7AtVcp7wscupEiVV9XKbwL4ORPu6MHOI/+UUCVe8XGzFlmpmhFkGyIGBgT12Lh8fHzZv3szUqVOZOHEi3333HY6Ojt0+b09q1BfmorGoqIgJEyZQX1/Pzp078fX17QFlf2BoH5csWQJAbW0tKSkpxMfHI0kShw8fJjExUd7VwtQwhfGob4QHwgMtwgeNB9X1jZoUiWbFNo4XlFPXqEmRsLG0YKC3E9dHel7eUs2VSB9nnO1Mv8gIiHGgpSs+mGWAbGHRsz+HTJw4kQ0bNjB79mymTJnCtm3bsLOz69Y5e1qjPjAXjX//+985d+4c33//PZGRkT2gqiWG9nHnzp0ATJs2jQMHDhAbGwvA0aNHWb58eaePz83N5fbbb6ewsBCVSsXdd9/NQw89RElJCbNnzyYnJ4egoCA+/vhj3N3d9flUWmAK41HfCA+EB1rM0Yfiirpms8KXOHqulDOltWg353GxsyLa11WzcM7HhWg/F0L6OWFtxCkS3cUcx0FbdMUHswyQs7Oz6dOnT4+ec8aMGbz//vvMnz+fTz/9lLlz53brfPrQ2NOYi8Z//vOfLFy4kKSkpB5S1RKlfDxx4oQcHAPExMSQkZHR6eOsrKx4+eWXGTx4MBUVFQwZMoSxY8eybt06rrvuOpYtW8aqVatYtWoVL7zwgj6fQgtMYTzqG+GB8EBLb/ahqUki52LrFIniijq5jZ+bPb4OElOvC5OLbfi5mV/Vud48Dq6ErvhglgGyvrj99tuJjY1l0KBBSksRdJO8vDyWLVvGG2+8gbOzs96CYyWJi4tj4cKF3HrrrQD873//Iy4urtPH+fj4yHnLzs7OREZGkpeXx5YtW9i1axcA8+bNY/To0QYNkAUCQe+jtkHNifMtUyQyCsqprlcDYGWhItTTiavDPDSzwr6uRPm44OpgTWpqKkOGDFT4GQhMFbMMkPv27au3c2uD47S0NJYsWcLGjRvx9PS84vPoU2NP0Vs1ZmZmMmHCBIqLi3n00Uf1/oVHKR/ff/993nzzTV599VUArrnmGu69994rOkdOTg4HDx5k2LBhFBYWyoGzt7c3hYWFbT5m7dq1rF27FoDz58+TmpoKaCr5OTg4kJmZCYCrqyshISHyokJLS0sSEhI4fvw4VVVVAERGRlJSUkJhYSFVVVUUFRVhY2NDVlYWAO7u7vTv359Dhw4BYG1tTVxcHOnp6XJlpejoaIqKiiguLgY0uWoWFhZkZ2cDmuvj6+vLkSNHALC1tSUmJoajR49SV6eZsYqNjSU/P5+LFy8CEBwcTFNTE2fOnAGgX79+eHp6cuzYMQDs7e2Jiori8OHDNDQ0ABAfH8/Zs2cpLS0FICQkhPr6enJzcwHw8vKiT58+8iy/o6MjERERpKWloVZrgoU+ffpw6tQpLl26BEBYWBjV1dXk5eUBmi83Li4unDhxAtB8wRk4cCAHDhxAkiRUKhWDBw/m5MmTVFRUABAeHk55eTkFBQU9cp0AAgIC9HadqqqqSE1NNerrNHjwYLKysvR6naytrSkvLzfa69TW6+lCeQ3ZZQ3U2nmQml3EicIq8ioauVx0DnsrFUFuVtwQ7sbgYE9sqosIcLHCxcnhj+tUVsqpMuS1Fdr3F2O9Tvp+PVVVVXH48OFe/b6ny3VycnKSx4L2OnWGSuplpbMSExNJSUnpsE19fT02Nlde0/xK+Pbbb7npppsICAjgu+++u+IEcUNo7C69UeOvv/7K1KlTUalUbN++naFDh+pRnYbONOoyppWgsrKSUaNG8eSTTzJt2jTc3NwoKyuT73d3d5ff9NqjJ5+bKYxHfSM8EB5oMWYfJEkit6SG9MslmLUpEgWXauU23i528lZq2hSJAPcrqzpnzB4YCuGBhrZ86OzzxyxnkI8cOcKQIUP02sf48eP57rvvmDRpEsOHD+fzzz9n+PDhOj/eEBq7S2/TuG3bNqZPn05QUBBfffUVISEhelanQSkfg4OD28zHO336dKePbWhoYPr06cydO5dp06YBmm/6BQUF+Pj4UFBQ0KVfTrqDKYxHfSM8EB5oMRYf6hubyCyqaFGCOSO/nIo6TdU5CxWE9HNiaHAfOUUi0seZvk7drzpnLB4oifBAQ1d8MMsA2VBcddVV7N69m+TkZEaNGsXOnTvl4iIC4yM6OprJkyezdu1as1jU0Pybc21tLZ988gklJSWdPk6SJBYsWEBkZCSPPvqofDw5OZn169ezbNky1q9fz5QpU/SiWyAQGCeXahrI+NPCuVNFFTSoNT9U21tbEunjTHKCryZX+HLVOTtrS4WVCwStMcsA2dbWcPXQo6Oj2b9/P6tXr76ihV6G1NhVeoPGsrIy/vOf/7B06VKCg4PZvHmzgZT9gVI+/jn3+eGHH2bIkCE888wzHT5u9+7dfPjhh8TGxpKQkADAP/7xD5YtW8asWbN49913CQwM5OOPP9aX9DYxhfGob4QHwgMt+vRBkiTyL9VqZoTzyzXV5/LLOVdaI7fxcLIhyteV0eH95BSJoL6OWF5BikR3EWNBeKClKz6YZQ6ykhQXF/PII4+watUq/P39lZZj1qSmpjJz5kxyc3PZs2cPiYmJSktqE32N6eYV9ZqamkhJSeHNN9+UF+AYAmN/vQoE5k6Duoms4spmwbDmX1m1ZpGVSgXBfR2JvJwrHO2rCYY9nbtXC0Ag0DciB7kNjh49SkxMjCJ9HzhwgC+++IKvvvqKt99+m+nTp7fZTkmNumKqGiVJ4q233uKhhx7C09OTn3/+WdHgWCkftRX1QLO3cXBwsMFnfXsSUxiP+kZ4IDzQ0hUfKusaOV5Q3iJf+ERhBfWXq87ZWlkQ4e3MDTHeRPm4EHn5n6OtcYYSYiwID7R0xQfjHNV6RrtFiRKMHz+egwcPMnfuXGbMmMGdd97Jq6++ipOTU4t2SmrUFVPVeM8997B27VomTJjAhx9+iIeHhwLK/kApH999910GDBjQ4ph2ix9TxBTGo74RHggPtHTkgyRJFFXU/TEjfLnyXM7FarmNu4M1Ub4uzP9LkJwiMcDDESsTqjonxoLwQEtXfDDLAFlpwsLC2L17NytWrOAf//gHjo6OvPbaa0rL6tVIkoRarcbKyopZs2YRExPDfffdZ9ZlOGfMmNEizUJ7TLtXpEAgMH3UTRLZF6o4ln9JDoYzCsq5UFkvt+nfx4FIH2emDfaXUyS8XezMruqcQNAcswyQm5fXVQpra2uee+45xo0bR2hoKKCZvXN0dMTT09MoNHaGqWjMycnh3nvvZdCgQfzjH//guuuu47rrrlNamoyhfTx+/DjHjh3j0qVLfPbZZ/Lx8vJyamtrO3ikcWMK41HfCA/M24OaejXHz2tmhY/kWvLs3t0cP19ObYMmRcLaUsVAL2euDfe8vMewKxE+zrjYWSusXD+Y81jQIjzQ0BUfzDJAzs/PJygoSGkZgKZ6mZZFixaRkpLCCy+8wHXXXdfq529jw5h8bIuqqiqWLVvG22+/jaWlJcnJyUpLahND+3jixAm2bdtGWVkZW7dulY87Ozvz9ttvG0xHT2Ps49EQCA/Mx4MLla1TJLIvVMlV55xsLIjxd+OWoYHyrHBIPydsrMznVzNzGQsdITzQ0BUfzDJAvnjxolEOmNdee4177rmHu+++m4iICF577TXGjh2rtKx2MVYfAX744QfmzZtHXl4et9xyC6tWrSIgIEBpWW1iaB+nTJnClClT2LNnDyNGjDBYv/rGmMejoRAe9D4PmpokzpZUX95X+JIcFBeW/5FT6edmT5SvC5PifIm6vJtE4el0o92Zx1D0trHQFYQHGrrig1kGyMZKREQEO3fuZMOGDTz22GOMGzeOdevWMW/ePKWlmQSSJFFdXY2joyPe3t74+/uzYsUKFixYoLQ0o2L16tUsXbqUDRs2sHHjxlb3i3x4gUAZahvUZBZWtijBnFFQTlW9GgBLCxVhnk6MDPWQF85F+bjg5tC6lHBRtsgfFgi6g1kGyMHBwUpLaBeVSsXcuXMZM2YMn332mbwN3G+//Ya9vT2DBg1SWOEfGIuPkiTxzTffsGLFCgIDA/noo4+Ijo5mz549lJaWKi2vUwztY2RkJECvm10ylvGoJMID0/GgrLr+TykS5ZwqrkR9OUfCydaKSB9nZgzxl6vOhXo66Vx1zlR80CfCA+GBlq74YJYBclNTk9ISOsXa2pr77rsP0ASADz30ECkpKVx33XXy7LLSK4yV9rGxsZGtW7eycuVK9u/fT//+/VvMFqtUKsU16oKhNU6ePBmg1/0yYQrXWt8ID4zPA0mSOFdaI5de1u4ikVf2R9U5bxc7onxdGBvldXnxnAsB7g5YdKPqnLH5oATCA+GBlq74YJYB8pkzZxTf+7YzmmtUqVR8//33rF27lldffZUJEyYQFxfHCy+8wIQJE4xCoxK8+OKL/O1vfyM4OJi3336b22+/HRublj81Kq1RFwytcfLkyR1+ufryyy8NpqUnMYVrrW+EB8p6UN/YxKmiStILNIvmtDPEFbWNAFioYEA/JxKD3LndJ5AoX02hDQ+nni8HLMaC8ACEB1q64oNZBsimiJubG0uXLuXhhx9mw4YNvPTSSxQXFwNw4cIFMjMzGT58uOKzyvpCrVbz008/8d5773HzzTdz4403Mm/ePCIjI5k0aRJWVmIo68pf//pXpSUIBCZPeW0DGc1mhdMLysksrKRerZmpsre2JMLHmeR4XzlFItzLGXsb3VIkBAKBsphlVNGvXz+lJXRKexptbGyYP38+8+bNQ63WLNz44IMPWLJkCREREdx2221MnTqVyMhIvQfL+vZRkiR+//13Nm7cyMcff8z58+dxcXHh6quvBsDX15epU6cqqrEnMLTGUaNGyX/X19dz/PhxVCoV4eHhrWbgTQlTuNb6RnjQ8x5IksT58lqO5bUMhs+W/FF1zsPJhihfV64O6yenSAT1dcSyGykS3UWMBeEBCA+0dMUHswyQPT09lZbQKZ1pVKlU8qzpXXfdhZubG++99x5PPvkkTz75JBEREaSlpWFr2/M/3emqsStUVlZy4sQJhgwZAsBtt91Gbm4ukyZNYs6cOdx4443Y29srqrGnUUrj9u3bueeeewgJCUGSJLKzs3nrrbe44YYbFNHTXUzhWusb4UH3PGhUN3H6QpW8r7A2IC6tbpDbBHs4EuvvyuykAE0w7OOCp4tdT0jvUcRYEB6A8EBLV3xQJED+5JNPWL58ORkZGezbt6/d1fTffPMNDz30EGq1moULF7Js2bIe6f/YsWNyAGasXIlGZ2dn7rzzTu68807y8/P58ssvycrKkoPjqVOnolarueaaaxg1ahSDBg3C2rr7lZN6wsfq6moOHDjA7t27+fbbb/n1119xcHDgwoULWFlZsXnzZoKDg3FxcVFMo75RSuOSJUvYuXOnXMkxKyuLG2+80WQDZFO41vpGeKC7B1V1jZqqc5dnhI/ll3PifAV1jZoUCRsrCyK8nRkf7S3PCod7u+BkaxrzSmIsCA9AeKClKz4o8kqPiYnhs88+Y9GiRe22UavV3HfffXz//ff4+/uTlJREcnIyUVFRBlRqevj6+nLPPfe0ONa/f3++++47tm3bBoCjoyOPPPIIzz77LAApKSlERETg5OSkN12SJMm50seOHePmm2/GycmJf/zjHzz//PMAxMXF8fDDDzN+/Hg5PSQ+Pl5vmswdZ2dnOTgGGDBgAM7OzgoqEgj0Q1FFrbyVWnpBORn55WRfrEK6XHXOzcGaaF8Xbh8ReHlvYVdC+jliZWk+VecEAkFLFAmQtfuwdsS+ffsIDQ2Vyy3PmTOHLVu29EiAfCU/0StFT2rUFn4oLCzk559/5qeffpIrypSWlpKUlARoAumAgAD8/f25/fbbmThxIlVVVfz66684OTnh5OSEs7Mzjo6OuLi4YG9vT21tLefOnaOhoYFLly5x4cIFLly4wJgxY+jfvz+7du3iscceIzMzk0uXLsmawsPDueaaa5g7dy7Dhg1j6NCheHl59dhz1mJu1/pKSExMZOLEicyaNQuVSsUnn3xCUlISn332GQDTpk1TRFdXMYVrrW/M3QN1k8TFeku2HsqXZ4XT88u5UPlH1bmAPvZE+7gydZCfXGzDx9Wu1y1wNvexAMIDEB5o6YoPRvtbUV5eXovSwP7+/vz+++89cm5TmIXWh0YvLy9mzpzJzJkz5WN2dnZ88cUXHDlyhJMnT5Kbm0tqairXX389ADk5OW1uJff+++8zf/58fvvtN0aOHNnq/o8//pj+/fvj5OSEu7s7c+fOJSwsjLCwMCIiIuQvPpGRkTp9Yeoq5nqtdaG2thYvLy9++uknQLOIoaamhq1bt6JSqUwuQDaFa61vzMmD2gY1x89XXE6R0Gypdvx8BdX1aiAPa0sVYZ7OjA7vR/TlinMRPi642nc/vcwUMKex0B7CA+GBlq74oLcA+frrr+f8+fOtjj///PNMmTKlR/tau3Yta9euBeD8+fOkpqYC4Ofnh4ODA5mZmQC4uroSEhLCDz/8gLu7O5aWliQkJHD8+HGqqqoATcBWUlJCYWEhAAEBAdjY2JCVlQWAu7s7/fv359ChQ4CmoEdcXBzp6enU1Gg2fo+OjqaoqEjehi0wMBALCwuys7MB6Nu3L76+vhw5cgQAW1tbYmJiOHr0KHV1mpkOCwsL3N3duXjxIqCpAtPU1MSZM2cATTDj6enJsWPHAM23o6ioKA4fPkxDg2ZBSXx8PGfPnpWryYWEhFBfX09ubi6gCZj79OmDv78//v7+zJgxQ17cp1arSU1NJSIigo8++oiioiKqq6txcXGhrKwMJycnduzYgZeXF2vXrqWoqAgnJyf8/PwYMmSIfB0sLCz47rvvOHnyJBUVFXK/BQUFFBQUdHidDhw4ANCt67Rr1y7c3d31dp1iY2PJz8/v1nWytLTExcWl3eukL95//329nt/QHD58mLi4OKVlKEpv9aCkqr7Vwrms4kouF53D2c6KKB8XZicF4Nx4ifHDognzdMbGynxTJHrrWLgShAfCAy1d8UElSdosLMMzevRoXnrppTYX6e3Zs4fly5fz7bffArBy5UoAnnjiiQ7PmZiYSEpKSodtUlNTjT5pXWjsGXqDRl3GdFfIzs7m3//+Nzk5OTQ2NsrHDVkopCefmylca31j6h40NUnklla3WDiXnl/O+fJauY2vq6bqXJSvK1E+msVz/u72coqEqXvQUwgfhAcgPNDSlg+dff4YbYpFUlISmZmZZGdn4+fnx6ZNm9iwYYPSsgSCXsPUqVNZsGABkydPxsLCfGfaBMpQ16gms7BSDoa1/1fWab6sWVqoCOnnyIiQvnIgHOnjgruj6e7VLRAITAdFZpA///xzHnjgAYqLi3FzcyMhIYFvv/2W/Px8Fi5cyFdffQXAV199xcMPP4xarebOO+/kySef7PTcusxINTY2Gn3lNaGxZ+gNGvU1gzxs2LAey+vvKj353EzhWusbY/XgUnXDH+WXLwfDp4oqabycI+FoY0nk5QVzmmDYlTAvJ+ysr7zqnLF6YGiED8IDEB5oacuHzj5/FE2x0Ae6fOCePn1aXiRmrAiNPUNv0KivAHnDhg1kZmYybty4FgVlBg8e3ON9tUdPPjdTuNb6RmkPJEkir6ymVYpEXlmN3MbT2VbeVzjKR1OCObCPAxY9VHVOaQ+MBeGD8ACEB1ra8sFkUyz0iXYxlDEjNPYMQmP7HDlyhA8//JAff/xRTrFQqVT8+OOPiujpLqZwrfWNIT1oUDeRVVzZqgTzpRrN4lOVCgZ4ODI40J1bhwfKs8P9nPVX3RPEONAifBAegPBAS1d8MMsAWSAQaCpanj59GhsbkdMp6JiK2gZ5SzVtmsTJ85XUqzVV5+ysLYjwduHGOB95b+EIb2ccbMRHjEAgME3M8t0rJCREaQmdIjT2DEJj+8TExFBWVtalGvXGiClca33TXQ8kSaKwvE7eV1ibJnHmYrXcpo+jDdG+LtxxVZC8eC6or/FUnRPjQIPwQXgAwgMtXfHBLAPk+vp6pSV0itDYMwiN7VNWVkZERARJSUlyDrJKpWLLli2K6OkupnCt9c2VeKBuksi+UCnnCWvTJC5W/XGOoL4ORPu6MHOIP9G+mnxhT2dbo646J8aBBuGD8ACEB1q64oNZBsi5ublGP2smNPYMQmP7rFixQv5bkiR++eUXNm3aZHAdPYUpXGt9054H1fWNzVIkNMHwifPl1DZoUiRsLC0I93bm+kivy3sMa7ZUc7I1vY8IMQ40CB+EByA80NIVH0zv3U8gEPQIo0aN4uDBg2zYsIFPPvmE4OBg7rnnHqVlCbpJcUVdi0Vzx/IvkX2hCu1+Ra721kT5uHDrsEA5EA71dMLaSFIkBAKBwBgwywDZy8tLaQmdIjT2DEJja06ePMnGjRvZuHEjHh4ezJ49G0mS2Llzp0F19DSmcK17kqYmiZyLVS2C4SO5pVz8ZIfcxt/dnigfF5LjfeUUCV9XO6NOkegu5jYO2kP4IDwA4YGWrvhglgFynz59lJbQKUJjzyA0tiYiIoKrr76abdu2ERoaCsC//vUvg2rQB6ZwrbtKbYOak4UVLfKFMwrKqa5XA2BloSLU04mrQj2I699Hs5OEjwuuDtYKKzc8vXkcXAnCB+EBCA+0dMUHswyQMzIyjL42udDYMwiNrfnss8/YtGkT1157LRMmTGDOnDn0hnpBpnCtdaG0qr5VikRWcRXqy1XnnGytiPJxYVZigLy3cJiXE7ZWlqSmpjJkSLDCz0BZess46C7CB+EBCA+0dMUHswyQBQJzZurUqUydOpWqqiq2bNnCK6+8QlFREffeey833XQT48aNU1qiWSBJEudKazT7CjfbRSL/Uq3cxsfVjigfF8ZHe8uV5/zd7Xus6pxAIBAI2sYsA2RHR0elJXSK0NgzCI0d93vLLbdwyy23UFpayieffMILL7xgsgGyMV/r+sYmMota7iKRkV9ORV0jABYqCPV0Ymhwn8uzwq5E+jjT1+nKqs4ZsweGQnigQfggPADhgZau+KCSesNvq83orLa2QGBq9OYx3Ruf26WaBjIKWu4tnFlUQYNa81Zrb21JpI+zvGguyseFcG9n7KwtFVYuEAgE5kNnnz9mOYOclpZGQkKC0jI6RGjsGYRG88HQPkqSRMGl2mYL5zQlmHNLauQ2/ZxtifJx4ZqB/Yj21VSdC+zriKWeUiTEWBIeaBE+CA9AeKClKz6YZYCsVquVltApQmPPIDSaD/r0sUHdxOniKtILLnEs7/LMcEE5ZdUNAKhUENzXkXh/N24e2l+zi4SvC57OdnrT1BZiLAkPtAgfhAcgPNDSFR/MMkAWCASC9qisa+R4wR/pEcfyyzlRWEF9o6bqnK2VBRHeztwQ402UrytRPi5EeDvjaIJV5wQCgUDQNmaZgyxJktFvlC809gy9QWNvzNPV0pPP7UqvtSRJFFfUyYvmtDnDORf/qDrn7mDdIlc4yteFAR6OWBlp1TlTGO/6RnigQfggPADhgZa2fBA5yG2QlZUlF0gwVoTGnkFoNB868lHdJJF9oUreVzg9X1No40Jlvdymfx8Hon1dmDbITxMQ+7rg7WJaVefEWBIeaBE+CA9AeKClKz6YZYB86dIlpSV0itDYMwiN5oPWx5p6NcfPt0yROH6+nNoGTYqEtaWKgV7OXBvuSZSvC9G+rkT4OONiZ/pV58RYEh5oET4ID0B4oKUrPphlgCwQCPTDN998w0MPPYRarWbhwoUsW7bMIP2+88tpdh0uo2DXLrIvVHG56BwudlZE+bpwy9DAy8GwCyH9nLCxMs4UCYFAIBAYB2YZIIeFhSktoVOExp5BaDQcarWa++67j++//x5/f3+SkpJITk4mKipK731/nJJLRY1EtJ8Tk+J85Zxhf3d7k0qR6C69ZSx1B+GBBuGD8ACEB1q64oNZBsjV1dW4uLgoLaNDhMaeQWg0HPv27SM0NJQBAwYAMGfOHLZs2WKQAPnL+6+i7GIx3t7eeu/LmOktY6k7CA80CB+EByA80NIVH8zyd8a8vDylJXSK0NgzCI2GIy8vj4CAAPm2v7+/wZ6bnbVlr/GxOwgPhAdahA/CAxAeaOmKD2Y5gywQCJRj7dq1rF27FoDz58+TmpoKgJ+fHw4ODmRmZgLg6upKSEgIBw4cAMDS0pKEhASOHz9OVVUVAJGRkZSUlFBYWEhJSQlFRUXY2NiQlZUFgLu7O/379+fQoUMAWFtbExcXR3p6OjU1mop30dHRFBUVUVxcDEBgYCAWFhZkZ2cD0LdvX3x9fTly5AgAtra2xMTEcPToUerq6gCIjY0lPz+fixcvAhAcHExTUxNnzpwBoF+/fnh6enLs2DEA7O3tiYqK4vDhwzQ0aIqNxMfHc/bsWUpLSwEICQmhvr6e3NxcALy8vOjTpw8ZGRkAODo6EhERQVpamrwJviRJnDp1Sl6QEhYWRnV1tfzh4OPjg4uLCydOnADA2dmZgQMHcuDAAXkbpMGDB3Py5EkqKioACA8Pp7y8nIKCgh65TgABAQF6u04lJSWkpqYa9XUaPHgwWVlZer1ONTU1lJeXG+11MsTrqbKyUn5/MdbrpO/XU0lJCYcPHzbq62SI11NjY6M8FrTXqTN6XYCck5NDYmJih22Ki4vp16+fgRR1DaGxZ+gNGnNycgwnphv4+fnJb2oA586dw8/Pr1W7u+++m7vvvhsADw8PFi1a1CP9m8K11jfCA+GBFuGD8ACEB1ra8qGzz9ZeVyhEF0yh8ILQ2DMIjYajsbGRgQMH8sMPP+Dn50dSUhIbNmwgOjraIP33Fh+7g/BAeKBF+CA8AOGBlq740OtmkAUCgTJYWVnx+uuvM378eNRqNXfeeafBgmOBQCAQCHoSESALBIIeY+LEiUycOFFpGQKBQCAQdAuz3MVCm/9ozAiNPYPQaD4IH4UHIDzQInwQHoDwQEtXfDDLHGSBQCAQCAQCgaA9zHIGWSAQCAQCgUAgaA8RIAsEAoFAIBAIBM0wiwD5k08+ITo6GgsLiw63+fjmm28IDw8nNDSUVatWGVAhlJSUMHbsWMLCwhg7dqy8afaf0W4anpCQQHJyskG0deZLXV0ds2fPJjQ0lGHDhimyb29nGtetW0e/fv1k79555x2D6rvzzjvx9PQkJiamzfslSeLBBx8kNDSUuLg4eZN4Qeco+bo1JoKCgoiNjSUhIaHTveB7C229rnR9L+0ttOXB8uXL8fPzk9/vvvrqKwUV6p/c3FyuvfZaoqKiiI6O5tVXXwXMbyy054M5jYfa2lqGDh1KfHw80dHRPP300wBkZ2czbNgwQkNDmT17NvX19Z2fTDID0tPTpePHj0ujRo2S9u/f32abxsZGacCAAVJWVpZUV1cnxcXFSceOHTOYxscee0xauXKlJEmStHLlSmnp0qVttnN0dDSYJknSzZc1a9ZIixYtkiRJkjZu3CjNmjXL6DS+//770n333WdQXc356aefpNTUVCk6OrrN+7dv3y5NmDBBampqkvbs2SMNHTrUwApNE6Vft8ZEYGCgVFxcrLQMg9LW60rX99LeQlsePP3009KLL76ooCrDkp+fL6WmpkqSJEnl5eVSWFiYdOzYMbMbC+35YE7joampSaqoqJAkSZLq6+uloUOHSnv27JFmzpwpbdy4UZIkSVq0aJH0xhtvdHous5hBjoyMJDw8vMM2+/btIzQ0lAEDBmBjY8OcOXPYsmWLgRTCli1bmDdvHgDz5s3jiy++MFjfHaGLL821z5gxgx9++AHJgGs/lb52unDNNdfQp0+fdu/fsmULt99+OyqViuHDh1NWViaXIhW0jylce4H+aOt1Zazvpfqis/cWc8DHx4fBgwcDmjLCkZGR5OXlmd1YaM8Hc0KlUuHk5ARAQ0MDDQ0NqFQqfvzxR2bMmAHoPhbMIkDWhby8PAICAuTb/v7+Bh1YhYWF+Pj4AODt7S3XWP8ztbW1JCYmMnz4cIO82HXxpXkbKysrXF1d5drshkDXa/fpp58SFxfHjBkzWpRENgaUHn+mivDtD1QqFePGjWPIkCGsXbtWaTmKoet7aW/n9ddfJy4ujjvvvLPXpxY0Jycnh4MHDzJs2DCzHgvNfQDzGg9qtZqEhAQ8PT0ZO3YsISEhuLm5YWWlKf2h6+dErwmQr7/+emJiYlr9M6bZJF01qlQqVCpVm+c4c+YMKSkpbNiwgYcffpisrCxDSDd5Jk+eTE5ODocPH2bs2LHyrIJA0Fv49ddfOXDgAF9//TVr1qzh559/VlqS4nT0Xtqbuffee8nKyiItLQ0fHx+WLFmitCSDUFlZyfTp03nllVdwcXFpcZ85jYU/+2Bu48HS0pK0tDTOnTvHvn37OH78eJfO02sq6e3YsaNbj/fz82sxq3ju3Dn8/Py6K6sFHWn08vKioKAAHx8fCgoK8PT0bFcnwIABAxg9ejQHDx4kJCSkR3X+ub/OfNG28ff3p7GxkUuXLtG3b1+9aeqKxuZ6Fi5cyNKlSw2mTxcMMf56I8K3P9A+b09PT2666Sb27dvHNddco7Aqw6Pre2lvxsvLS/77rrvuYtKkSQqqMQwNDQ1Mnz6duXPnMm3aNMA8x0J7Pmgxl/EA4ObmxrXXXsuePXsoKyujsbERKysrnT8nes0McndJSkoiMzOT7Oxs6uvr2bRpk8F2iQBITk5m/fr1AKxfv54pU6a0alNaWkpdXR0AFy5cYPfu3URFRelVly6+NNe+efNmxowZY9Bv6rpobJ7P++WXXxIZGWkwfbqQnJzMBx98gCRJ7N27F1dXV/mnQUH7KP26NRaqqqqoqKiQ//7uu+/a3TGlt6PLe2lvp/n73eeff97rx4IkSSxYsIDIyEgeffRR+bi5jYX2fDCn8VBcXExZWRkANTU1fP/990RGRnLttdeyefNm4ArGgt6WEhoRn332meTn5yfZ2NhInp6e0rhx4yRJkqS8vDzphhtukNtt375dCgsLkwYMGCA999xzBtV44cIFacyYMVJoaKh03XXXSRcvXpQkSZL2798vLViwQJIkSdq9e7cUExMjxcXFSTExMdI777xjEG1t+fL3v/9d2rJliyRJklRTUyPNmDFDCgkJkZKSkqSsrCyD6LoSjcuWLZOioqKkuLg4afTo0VJGRoZB9c2ZM0fy9vaWrKysJD8/P+mdd96R3nzzTenNN9+UJEmz8nbx4sXSgAEDpJiYmHZ3WxG0RsnXrbGQlZUlxcXFSXFxcVJUVJTZ+NDW66q999LeSlse3HrrrVJMTIwUGxsrTZ48WcrPz1dapl755ZdfJECKjY2V4uPjpfj4eGn79u1mNxba88GcxsOhQ4ekhIQEKTY2VoqOjpZWrFghSZLmPTIpKUkKCQmRZsyYIdXW1nZ6LlFqWiAQCAQCgUAgaIZIsRAIBAKBQCAQCJohAmSBQCAQCAQCgaAZIkAWCAQCgUAgEAiaIQJkgUAgEAgEAoGgGSJAFggEAoFAIBAImiECZEErLC0tSUhIICYmhsmTJ8t7Cl4p69at4/777+9ZcQKBQNALeP7554mOjiYuLo6EhAR+//13vfU1evRoUlJS9HZ+gaA3IgJkQSvs7e1JS0vj6NGj9OnThzVr1igtSSAQCHoNe/bsYdu2bRw4cIDDhw+zY8cOAgIClJYlEAiaIQJkQYeMGDGCvLw8ALKyspgwYQJDhgzh6quvluubb926lWHDhjFo0CCuv/56CgsLlZQsEAgERk1BQQEeHh7Y2toC4OHhga+vL8888wxJSUnExMRw9913oy1TMHr0aB555BESExOJjIxk//79TJs2jbCwMJ566ikAcnJyiIiIYO7cuURGRjJjxgyqq6tb9f3dd98xYsQIBg8ezMyZM6msrDTcExcITAgRIAvaRa1W88MPP8ile++++27+/e9/k5qayksvvcTixYsBuOqqq9i7dy8HDx5kzpw5rF69WknZAoFAYNSMGzeO3NxcBg4cyOLFi/npp58AuP/++9m/fz9Hjx6lpqaGbdu2yY+xsbEhJSWFe+65hylTprBmzRqOHj3KunXruHjxIgAnTpxg8eLFZGRk4OLiwhtvvNGi3wsXLvDcc8+xY8cODhw4QGJiIv/85z8N98QFAhPCSmkBAuOjpqaGhIQE8vLyiIyMZOzYsVRWVvLbb78xc+ZMuV1dXR0A586dY/bs2RQUFFBfX09wcLBS0gUCgcDocXJyIjU1lV9++YWdO3cye/ZsVq1ahbOzM6tXr6a6upqSkhKio6OZPHkygDxRERsbS3R0ND4+PgAMGDCA3Nxc3NzcCAgIYOTIkQDceuutvPbaa/z1r3+V+927dy/p6elym/r6ekaMGGHIpy4QmAwiQBa0QpuDXF1dzfjx41mzZg3z58/Hzc2NtLS0Vu0feOABHn30UZKTk9m1axfLly83uGaBQCAwJSwtLRk9ejSjR48mNjaWt956i8OHD5OSkkJAQADLly+ntrZWbq9Nx7CwsJD/1t5ubGwEQKVStejjz7clSWLs2LFs3LhRX09LIOg1iBQLQbs4ODjw2muv8fLLL+Pg4EBwcDCffPIJoHmjPXToEACXLl3Cz88PgPXr1yumVyAQCEyBEydOkJmZKd9OS0sjPDwc0OQjV1ZWsnnz5is+79mzZ9mzZw8AGzZs4Kqrrmpx//Dhw9m9ezenTp0CoKqqipMnT3b1aQgEvRoRIAs6ZNCgQcTFxbFx40b+97//8e677xIfH090dDRbtmwBYPny5cycOZMhQ4bg4eGhsGKBQCAwbiorK5k3bx5RUVHExcWRnp7O8uXLueuuu4iJiWH8+PEkJSVd8XnDw8NZs2YNkZGRlJaWcu+997a4v1+/fqxbt46bb76ZuLg4RowYIS+2FggELVFJ2mWyAoFAIBAITJKcnBwmTZrE0aNHlZYiEPQKxAyyQCAQCAQCgUDQDDGDLBAIBAKBQCAQNEPMIAsEAoFAIBAIBM0QAbJAIBAIBAKBQNAMESALBAKBQCAQCATNEAGyQCAQCAQCgUDQDBEgCwQCgUAgEAgEzfh/hIrkce4AnN0AAAAASUVORK5CYII=", "text/plain": [ - "
" + "
" ] }, "metadata": { @@ -568,7 +598,7 @@ "iir = sdr.IIR.ZerosPoles(zeros, poles)\n", "\n", "plt.figure(figsize=(10, 8))\n", - "iir.plot_all(N_time=30)\n", + "sdr.plot.filter(iir.b_taps, iir.a_taps, N_time=30)\n", "plt.show()" ] }, @@ -581,14 +611,24 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 20, "metadata": {}, "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "C:\\Users\\matth\\AppData\\Local\\Packages\\PythonSoftwareFoundation.Python.3.7_qbz5n2kfra8p0\\LocalCache\\local-packages\\Python37\\site-packages\\scipy\\signal\\filter_design.py:476: RuntimeWarning: divide by zero encountered in true_divide\n", + " npp_polyval(zm1, a, tensor=False))\n", + "C:\\Users\\matth\\AppData\\Local\\Packages\\PythonSoftwareFoundation.Python.3.7_qbz5n2kfra8p0\\LocalCache\\local-packages\\Python37\\site-packages\\scipy\\signal\\filter_design.py:476: RuntimeWarning: invalid value encountered in true_divide\n", + " npp_polyval(zm1, a, tensor=False))\n" + ] + }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, "metadata": { @@ -604,7 +644,7 @@ "iir = sdr.IIR.ZerosPoles(zeros, poles)\n", "\n", "plt.figure(figsize=(10, 8))\n", - "iir.plot_all(N_time=30)\n", + "sdr.plot.filter(iir.b_taps, iir.a_taps, N_time=30)\n", "plt.show()" ] }, @@ -618,14 +658,14 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 21, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, "metadata": { @@ -640,7 +680,7 @@ "iir = sdr.IIR.ZerosPoles(zeros, poles)\n", "\n", "plt.figure(figsize=(10, 8))\n", - "iir.plot_all(N_time=30)\n", + "sdr.plot.filter(iir.b_taps, iir.a_taps, N_time=30)\n", "plt.show()" ] }, @@ -655,14 +695,14 @@ }, { "cell_type": "code", - "execution_count": 21, + "execution_count": 22, "metadata": {}, "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAsgAAAI4CAYAAAB3OR9vAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/NK7nSAAAACXBIWXMAAAsTAAALEwEAmpwYAAEAAElEQVR4nOzdd1xV5R/A8c8FBESQIU5AATFligoquXAgZkrmSLM0c5Vbs2FZiZVplqWmv8o0V+5RpKk5qUwcqLg1UlHBkRMn63J+f5y4ggxBxmF836/X1Tuee873ufdy+PLc73kenaIoCkIIIYQQQggAjLQOQAghhBBCiOJEEmQhhBBCCCHSkQRZCCGEEEKIdCRBFkIIIYQQIh1JkIUQQgghhEhHEmQhhBBCCCHSkQRZCCGEEEKIdCRBFkIIIYQQIh1JkMuAfv368f777xf4dp2dndm6dWuBbzcnp06dwtfXFysrK2bOnPnE23n33XeZPn36Y9s1btyYY8eOPfF+hBD5p8WxpqxwcnLiwIEDWT6m0+moUKEC48ePz9W22rRpg7m5Oc2bNy/IEIXQRJlPkJcsWYKlpWWmi06n46OPPtI6vCLh7OxM+fLlsbS0pGrVqvTr14+7d+9qHVaWpk6dSuvWrblz5w4jR47M9PjNmzfR6XScPXs2w/0jR45k0KBBAFy9epVFixbx2muvPXZ/b775Jh9++GHBBC9ECVdaEtX0x7xq1aoV62NeYbp58yYXL17E3d092zaHDh1i0qRJudre9u3b+fbbbwsqPCE0VeYT5Jdeeom7d+9muEyfPp2qVasaEqrcSklJKaQoC9+6deu4e/cuBw4cIDIykk8++UTrkLJ07tw5PD09s308KioKS0tLnJ2dM9x/5MgRfH19AViwYAEdO3akfPnyj91fSEgIO3bs4PLly/kJWwhRzKQd86Kiojh48CCTJ0/WOqQid+TIEcMfC0KIjMp8gvyogwcPMnr0aJYvX0716tUBuHjxIt26daNy5cq4uLhk+Grf2dmZzz77DB8fHypUqEBKSgonTpwgMDAQGxsbPD09+eWXXwztP/vsMxwcHLCysqJu3bps27YtyzimTJlC7dq1sbKywsPDg59++inD487OznzxxRf4+PhgbW1Nz549SUhIMPShYcOGWFlZZbg/NxwcHHjmmWc4evQoQI59eVROr1Nu+53T/tq0acOOHTsYPnw4lpaW/P3335meHxUVhYeHBzqdLsP9x44do0GDBgBs3LiRVq1aGR7r2bNnpm8Pvv76awDMzc1p1KgRv/322+NeOiHKFGdnZz7//HPDsW/AgAFcuXKFZ555BisrK9q1a8fNmzcNbSdPnoyHhwe2tra8+uqrGY5LOp2Of/75x3A7p7Kw7I4lOR1/clKtWjWCg4OJiorKcP+THM8e18+cjm85HdMLo98Ahw8fxs3NjZEjR1K5cmVq1KjBli1bsm3/3Xff0bFjR4YNG4a9vf1j2wtRoinC4ObNm4qrq6syZcoUw316vV5p2LChMnHiRCUxMVE5ffq04uLiomzatElRFEWpVauWUr9+feX8+fPK/fv3laSkJKV27drKpEmTlMTERGXbtm2KpaWlcvLkSeXkyZOKo6OjEhcXpyiKopw9e1b5559/soxl5cqVSlxcnKLX65Xly5crFhYWysWLFw2P16pVS/H391fi4uKU69evK/Xq1VO++eYbJTExUalZs6by5ZdfKklJScqqVasUExMTZfz48dn2u1atWsqWLVsURVGU8+fPKx4eHsr777+fY18efV5Or1Nu+/24/SmKorRq1Ur5/vvvs+1Lnz59lP79+2e47/Lly4qRkZFy584dRVEUxd7eXtm7d2+Wz582bZri6+urXL9+3XDfiBEjlDFjxmS7TyHKivQ/87Vq1VKaNGmiXL58WYmNjVUqV66sNGjQQDlw4IDy4MEDpXXr1kpoaKihraenp3L+/Hnl+vXrytNPP53hmAQo0dHRhtuvvPJKhsfT9pvdseRxx+mc+nHhwgXFy8tLGTlypOHxJz2e5dTP3BxPszqmK4pSYP1+1ODBgxU7Oztl06ZNil6vV0JDQ5W2bdtm+74MGTJEsbW1zba9oijK/PnzlWbNmuVq/0IUZzKC/B9FUejbty9eXl68/fbbhvv37dvH1atX+fDDDzE1NcXV1ZVBgwaxfPlyQ5uRI0fi5ORE+fLl2b17N3fv3mXcuHGYmprSpk0bOnXqxLJlyzA2NiYxMZHjx4+TnJyMs7MztWvXzjKeHj16UKNGDYyMjOjZsyd16tRh7969GdqMHDmSGjVqYGdnR+fOnYmKimL37t0kJyczevRoypUrR/fu3fH3939s/7t06YKNjQ3NmzenVatWvPfeezn25VE5vU657Xde9pedqKgoli1bhr29veFSr1493NzcsLS0BODWrVtYWVlleu6MGTNYtGgRW7duxc7OznC/lZUVt27dynUMQpQVI0aMoGrVqjg4ONCiRQuaNGlCgwYNMDc35/nnn+fgwYOGtsOHD8fJyQk7OzvGjx+fp5/rNNkdS3JznH5Uly5dsLKywsnJiSpVqjBx4kTDY/k5nmXXz9wc37I6phd0v9M7fPgw48ePJzg4GCMjIzw8PB7bfty4cbluL0RJZqJ1AMXFZ599xrFjx9i/f3+Gr+fPnTvHxYsXsbGxMdyn1+tp0aKF4baTk5Ph+sWLF3FycsLI6OHfHrVq1SIuLg43NzemT59OaGgox44dIzg4mC+//JIaNWpkimfRokV8+eWXxMTEAHD37l2uXbuWoU21atUM1y0sLLh48SIXL17EwcEhQx9q1ar12P7//PPPtGvXLsN9OfXlUTm9Trntd172l5XExEROnDjBypUrM/xR8L///Y/Tp08bbtva2nLnzp0Mz501axbz5s1j+/btVKpUKcNjd+7cydAvIYSqatWqhuvly5fPdDv9iW/pj5O1atXi4sWLed5fdseS3BynH5V2zPv999/p3bs3165dMzw/P8ez7PqZm+NbVsf0gu53GkVROHr0KIsWLTLcd/To0WyTXkVROHLkCN9//32u2gtR0skIMhAeHs6kSZNYvXp1pkTIyckJFxcXbt26ZbjcuXOHDRs2GNqkT0Zr1KjBhQsXSE1NNdx3/vx5HBwcAOjduzc7d+7k3Llz6HQ63nnnnUzxnDt3jkGDBjFr1iyuX7/OrVu38PLyQlGUx/alevXqxMXFZWh7/vz5XL8W6T2uL+k97nXKTb/zsr+sHD16lNTUVIKCgnB0dDRcoqOjDfXHAD4+Phnql//3v//x7bffsm3bNuzt7TNt98SJE9SvXz9XMQghsnbhwgXD9fPnz2f4A9nCwoL79+8bbud0UmxWx5LcHKez06pVK/r168ebb75puC8/x7Ps+pnf41tB9zttph83NzfDfQcPHjSczPyomJgYUlJSqFu3bq7aC1HSlfkE+dKlS/Tq1Yvp06dnSKLSNG7cGCsrKz777DMePHiAXq/n6NGj7Nu3L8vtNWnSBAsLC6ZOnUpycjLh4eGsW7eOXr16cerUKbZv305iYiLm5uaUL18+w2hCmnv37qHT6ahcuTIA8+fPN5w09zgBAQGYmJgwc+ZMkpOTWbt2babSjNzKqS+Pyul1ym2/87K/rBw8eBAPDw9DKUWaffv2ZTiId+zYkd9//x2AOXPmMHv2bLZt22Z4vdNLSEhg//79BAUF5SoGIUTWZs+eTWxsLDdu3GDSpEn07NnT8Jivry9Lly5Fr9ezadMmw8/no7I7luT1OP2o0aNHs2XLFg4dOgTk73iWXT/zc3zLT7/79etHv379Mm3z8OHDeHt7ZxjgOXjwYLaDAWnt0/c1p/ZClHRlPkH+/vvvuXLlCqNGjco0F/Lrr7+OsbEx69evJyoqChcXF+zt7Rk4cCDx8fFZbs/U1JR169axceNG7O3tGTp0KIsWLaJevXokJiYybtw47O3tqVatGv/++2+WUwt5eHgwduxYAgICqFq1KkeOHKFZs2a56o+pqSlr165lwYIF2NnZsWLFCrp27fpEr01OfXlUTq9Tbvudl/1lJSoqKlO99dWrVzl37lyGBLlv375s2LCBBw8e8Pbbb3P69Glq165teN8XL15saLtu3ToCAwOzLIMRQuRe7969ad++Pa6urtSuXTvDLBUzZsxg3bp12NjYsGTJErp06ZLlNrI7luT1OP2oypUr07dvX8Pc9/k5nmXXz/wc3/LT7wsXLmT5++PIkSMZkttr165x+fJlvLy8sozh8OHDGY6jj2svREmnU3Lzvb0Qpcx7771HlSpVGD16dI7tmjRpwrx58+SXgBD54OzszNy5czOd51DaFLd+JiUlUb9+fQ4fPky5cuXy/Hxzc3PMzMwYOXIkH3/88WPbBwUFsXv3bho3bpztVJ5ClBRykp4okz799NNctduzZ08hRyKEEIXD1NSUEydOPPHz8zKHPiBzIotSpcyXWAghhBBCCJGelFgIIYQQQgiRjowgCyGEEEIIkU6prkG2t7fH2dlZ6zBEGRETE5NpMZeyRn7mhBCi9CpLv+dKdYLs7OxMZGSk1mGIMsLPz0/rEDQnP3NCCFF6laXfc1JiIYQQQognEhEBkyer/wtRmpTqEWQhhBBC5F5EBISHQ2AgBAQ8vF+vhytX4Px5uHBBvezZA2vWqI+ZmMDw4epzqlWD6tXV/62scrd9IYobSZCFEEIIwfbt0LEjJCWBsTG0bg0JCWpSHBcHKSkZ25crpybHoD42fbp6Sa9CBTVRrlYNTE3hzz8hNRXMzGDbNkmSRfFV5hLk5ORkYmNj8zwBusieubk5jo6OT7RSkxBCCG3cvAl//QV//KFe9u1Tk1dQE97ISPD2hhYtwMlJvdSs+fD6iRPQrp2aUJuaqqPJTk5w+TJcupTx/8uX4ejRh0n2gwfw/vswdy64uOSvH/J7veDJ7/UymCDHxsZiZWWFs7MzOp1O63BKPEVRuH79OrGxsbjk9ygnhBCiQKUvaXB1VUdw0xLiw4dBUdTktnFjePllWLFCTWJNTeHXX3Me4X36aXUU+NGSCS+v7GNp2xYSE9Xb27erMQUGQr9+0K0bWFrmvY/ye71gye91VbFIkPv378/69eupUqUKR48ezfR4eHg4zz33nOGN6tq1Kx9++OET7SshIUF+iAqQTqejUqVKXL16VetQhBBCpLN5M3TuDMnJ6u20ZcEsLNTkduJEaNlSTY7Ll1cfe/31vNUIBwTkvkwiICBjQu3oCIsWwYIFaoI8bBj06AGvvqqOWuf217T8Xi9Y8ntdVSwS5H79+jF8+HD69u2bbZsWLVqwfv36Atmf/BAVLHk9hRBCe4qilj38+qt6+eOPh0kxQIcOEBoKDRuq9cNZyUvC+yQe3f748fDee7BrF8yfDytXqgmzqyu0aQO2tvD884+PSX4PFSx5PYvJNG8tW7bEzs5O6zCEEEKIEiUhATZtUmeQcHUFT094+221vrhPH/VkOGNjdYT4ww+hSZPsk2Ot6HTQrJlaj3zpEixerCbGc+fC55+ro9x//ql1lKKsKRYJcm5ERERQv359nnnmGY4dO5Ztuzlz5uDn54efn1+x/HogJiYGr0cKtEJDQ/niiy9yfF5kZCQjR44E1JKTXbt25Wm/HTt25NatW7lu369fP1avXp2nfQghhChcEREwbhy88w6EhEClSvDMM/DDD+oJdd9+q846cegQLFwIO3bAxx+XnBkjKlRQa6G7dQOj/zKUlBT1vtOntY0tJ8bGxvj6+uLl5UXnzp3z9Ps2vQULFjB8+PCCDU48kWJRYvE4DRs25Ny5c1haWrJhwwa6dOlCdHR0lm0HDx7M4MGDgdK14kta0g9qgmxpacnTTz+d6+dv2LAh032KoqAoCkZGJebvJCGEKHOSktQShLlzYenSh2UT1aqp9bqdOqk1vebmmZ9b2CUThSUwUB39Tpty7vp1qF9fnUZuwIDc1ycXlfLlyxMVFQXAK6+8wuzZsxk/fry2QYl8KRGZUcWKFbH879TWjh07kpycXGrXAg8MDOSdd96hcePGPPXUU/z53/dK4eHhdOrUiZiYGL799lu++uorfH19DY+nuXv3Lq+++ire3t74+PiwZs0aQF0C+Nq1a8TExFC3bl369u2Ll5cXFy5c4LPPPsPb25v69eszbty4TDHt37+fVq1a0ahRI4KDg7l06VLhvxBCCFGGXbgAc+ao9bf29uqcxMuWPUyOjY1hxAiYNUutLc4qOS7J0k7o+/hj9aS+EyfU8pBBg6BLF/j33/xtvzBXAAwICCAuLg6A06dP06FDBxo1akSLFi04efIkAOvWraNJkyY0aNCAdu3aceXKlYIPRORLiRhBvnz5MlWrVkWn07F3715SU1OpVKlSgWw7MDAw030vvPACQ4cO5f79+3Ts2DHT4/369aNfv35cu3aN7t27Z3gsPDw83zGlpKSwd+9eNmzYwMSJE9m6davhMWdnZ15//XUsLS158803Mz33448/xtramiNHjgBw8+bNTG2io6NZuHAhTZs2ZePGjYSFhbFnzx4sLCy4ceNGhrbJycmMGDGCsLAwKleuzIoVKxg/fjw//PBDvvsphBBlXdo0bE8/rZYSbNyoXo4fVx+vWRN691aTYEtLtawibd7h1q01Db3QPTr6vWULzJgB776rTiU3b546S0d6o0fDfwO52YqPV6e4S01Vyzh8fMDaOvv2vr6ZF0DJjl6vZ9u2bQwYMABQv9X+9ttvqVOnDnv27GHo0KFs376d5s2bs3v3bnQ6HXPnzmXq1KlMmzYtdzsRRaJYJMgvvvgi4eHhXLt2DUdHRyZOnEjyf/PSvP7666xevZpvvvkGExMTypcvz/Lly0vsGZbZxZ3+/q5duwLQqFEjYmJi8rT9rVu3snz5csNtW1vbTG1q1apF06ZNDe1fffVVLCwsADKdLHnq1CmOHj1KUFAQoP7wV69ePU8xCSGEyCgpSZ3ibOjQh9OwgZr4tmwJ/furtcXu7hnLCbKad7isMDKCMWMgKEitSQ4JUUeUR43K23bi4x8uiJKaqt7OKUHOjQcPHuDr60tcXBzu7u4EBQVx9+5ddu3aRY8ePQztEv+bBDo2NpaePXty6dIlkpKSyvR8w8VVsUiQly1bluPjw4cPL7Si9ZxGfC0sLHJ83N7ePs8jxpUqVco0qnvjxo0MPxxmZmaAWvSf8ujangWgQoUKuW6rKAqenp5EFMb3UKJE2LRpE6NGjUKv1zNw4MAsy3BKivSLJuQmuSjM9oUdiyhe4uPV9/Cvv2DnTtizR11NLo1OpyZ9//tfzotllNSa4oLk5aW+fhMmwNSp8MILUKuW+rrlZqQ3bcGStJH4JUvy/5qm1SDfv3+f4OBgZs+eTb9+/bCxsTHUJqc3YsQI3njjDUJCQggPDyc0NDR/AYgCVywS5LLE0tKS6tWrs337dtq0acONGzcMCUhuWVlZcfv27SwfCwoKYvbs2Uz/7yhx8+bNLEeR07f/6KOPeOmllwwlFulHkevWrcvVq1eJiIggICCA5ORk/v77bzw9PXMdryi59Ho9w4YNY8uWLTg6OuLv709ISAgeHh6Fsr9D30ZwbXU4FUMCcesTQEoKOV5iV0Wg3xZOastAbDtm3T45Wf3/5En4c2oELfThvG0cSKPhATg6gl7/8JKS8vD6+fNwfsXD9lW7BFC1qloDmpqqXtKuK4q6lO7t3yJokRrOW0aB2Dyjttfp1JEvne7h5d9/4d+wh9t2fjEAZ2d1+i1TU/X/tIupKZw7B+GTI2iuD+cd40B6zQjA31+dusvCQr2kXU+bwuvInAiurwmnUrdAvAdr/NdAXtsXp1ieoP2RORHELgnn0lOBHDALYOfOh6vWGRurX9kPHgyVK8OWjyJolhzOX+UCGTIk4PEryRWzvmr1OTAzgylT4Nln1ZX5Tp6EGtZ3sVTuYGJrhUXl7F9Iw4IlvyUS2OgOAd7mQC6W8Lt7F+7cASurbP+KsbCwYObMmXTp0oWhffvi4uDAqsWL6dGnD4qicPjwYerXr098fDwODg4ALFy4UD3oXLqkztuXG7mIJV/thSTIWli0aBHDhg3jjTfeAGDChAnUrl0718/v3Lkz3bt3JywsjK+//poWLVoYHnv//fcZNmwYXl5eGBsbM2HCBEPJRlY6dOhAVFQUfn5+mJqa0rFjRz799FPD46ampqxevZqRI0cSHx9PSkoKo0ePlgS5jNi7dy9ubm64uroC0KtXL8LCwgolQT4yJwKPIS0xIYXUbUYcGuXDbbL/3rMi8XTkMEakkrrXiENfqO2zm+LVi3g+TmuvN+LQjOy3r9NBRSUen3TtD6/14b6xNejA8I132nUdWCTH45X6X/tUI45s9OGBiTWGdRoUDNctUuLxUdJt+0cf4nPoawPimZAWS4oRh4apsd/LKnagoi7d9jcbcWKUDykW1hibgIkxmf43S4rHOuYwOiUVdEbovXwwtrXOfqaA+HiUQ4fhv/a6+o8p4sxL0WdeC0Q1bp+cAvfvw/17cO8+6G/E43H/MF6kkvqHEQ10Pgyytsa6pvq0ihXVJJkoddvvJf/3OiYboRtavPtapO1z2bYFcHzCBFyNFMzi76t33gb9FQuMyxlnG0qAtZ6ATv+1P4n616Vx9u3R69U3Os2j7RUFTp0CoIGFBT4uLiybOZMlH3zAkClT+OSTT0jW6+nVsSP1hw0jdNAgenTpgm3FirRp0oSz9+9DXJyaJN+4YdjWE8WSU3sjI3jqKUmSc0ESZA14eHiwY8eOLB9LX7Jhb29vqEEODAw0nFD41FNPcfjw4Syfb2lpqf41+oi07djb22daznvcuHGZvjZfsGCB4bqvry9//PFHDj0SBen+/ftMmzaN8+fP8/333xMdHc2pU6fo1KlTkccSFxeHk5OT4bajoyN79uzJ0GbOnDnMmTMHIF9zj19fE44xenSAjlRqlI+nqoN1hpHX9BflXDxG91IN7Z2s4jGtnX17fUw8Rv8+bF+vWjymbv+15786z3TJb8Lf8RhdetjevVo85k9l/8v/0fb1qmbfPtO2q6ttFQVSFfV3rZI2Qq1AypmMsde2iyelhjX6VEjVqzlE2nV9Kphdicco8WH7Cinx/Jtkjf4+pOhBn6JuN01N4rFBbZ+qpHL+SDznscbEGExM/ruUU/8vZwI2d+Kpojxsf/t8PEbO1hnaZcit4+NRUtX2SmoqupyKPvNaIFoE7dPHfvt8PFfMrQ1JcVK6+mEjHdQyiseIh6+9s3U8tvWz76tO+S8WpXj0tdi0z0NbHWCi0xuuK4CSrIccEmT0+sy3H5dk5tD+7oEDGR5e9/XX6tA2sOnrr9Uhb1NTw+PPtW3Lc23bqjeSkgxt+3XuTL//yiwLJfbUVHUkWRLkx5IEWYhi5tVXX6VRo0aGum8HBwd69OihSYKcGwU193ilboEkbDanHEkkY8rV6UtyLA04MicCy9faGtpf/iLn9kREoG/9sPDQYm3OhYfmj7Q3X1Nw7bNrqwOy/DX3SHvr9TnHcmROBLbpXpv42Uvwe+S1SUpSf0/evg0/vR3B66sftv/f00uwDArg5k2yvNROiOA3HrbvcGMJu2883L5Op+Yydnbqimj1zSP4Ol37GV5LsGgbYBhRTf9/pb8jsOn+sK/GjysQfeS1yWv7C5OWEFM9QC17+ReuXCHDdfs7ESx/pK/HKwbg4aGeQJf2v7u7Wgd7fF4ED9K99rGfLcE2u89lXothy1L7vLQ9cYIkeyfMzv2NjlQUjDhv7ELN2paYZJfl3L0Lf//9cITaxSXnpLEw2xd1LFZW2bcVBpIgC1HMnD59mhUrVhhOXrWwsEBRlMc8q3A4ODhw4cIFw+3Y2FhD3VxB8x4cwBG25bpuNq/tCQjAeEcepgAozPaFHEtuXhtTU3UVtkqVIOCNADr+ss1QCzv5i4DH5DkBdAx82P6VGQG856B+M3zzZub/Nx8JoC3bCCSccALZvS4A1mXbWZqmtU0M5FhwABYW6gBc+oupqfr/gwcBGCdto6USzh9JgSSPUtsnJ6u5VVJSxut37wZQN/Hh9nf3zthRIyN13uGqVaFKFThXI4B217bRinD+0AUS+E4Auz7NfqGKPH0uDcWw4bn+HJSZ9nnctkVlS+7zFPqbd0gyt+LmVUsSo6FOHbJOki0t1VKD3NblFmb74hSLMNApWv3mLQJ+fn5ERkZmuO/EiRO4u7trFFHpJa9r1p+3J/H000+zbds2mjVrxoEDBzh9+jQvvvgie/fuLYAo8yYlJYWnnnqKbdu24eDggL+/P0uXLs22Br2gXgNR9Ar7XKv0g4G//aaOvN6+rV7i4x9eX7EC1q1Ty0t0OmjaVF1COTHx4TfR6S9nz0Js7MN91awJzs7qftJOeEz//7FjEBmpbt/ICHr0UKcKS0uIK1XK+G31o7GXlCWby5Ksfv/cuqUuTW1hkUOSLHKU1etalo7x8pERopiZOHEiHTp04MKFC7z00kv89ddfGWrCi5KJiQmzZs0iODgYvV5P//795QTNUiqv04flpX12g4FZrffk4qIuCJGWkE6blrdv7Zcvz1v7UaMKdCBTFBM2NlC7tpokR+c0kixENuTjIkQxExQURMOGDdm9ezeKojBjxgzs7e01i6djx45ZrigpRF7kNqEuTt/y5zV2UbxIkizyQz4qQhQTBx45CzptxcLz589z/vx5GjZsqEVYQhS5whzNfpL2ouSSJFk8KfmYFLGffvqJiRMnZrjv8OHD/PrrrzzzzDMaRSWKg7FjxwKQkJBAZGQk9evXN0ws7+fnJ6sZCiHEE3g0SX7qqZxnRXsSlpaW3L17t2A3+oinn36aXbt2Feo+xENGWgdQnOn1sHQpdO2qXpYufTgt45N6/vnniYqKMlyGDh1KixYtCA4OfuxzFUUhNb8BiGJrx44d7Nixg+rVq3PgwAEiIyPZv38/Bw8eLLSZI4QQoiywsQFXV3W9jL//zjyVcElQUMlxSkpKgWyntJMEORuKAq++qq7rnpYgT58O/fqpjxWEv//+m48++ojFixdjZGTE559/jr+/Pz4+PkyYMAFQF/ioW7cuffv2xcvLiwsXLvDWW2/h5eWFt7c3K1asAODSpUu0bNkSX19fvLy8+PPPPwsmSFHkTp06hbe3t+G2l5cXJ06c0DAiIYQo+WxtHybJF1ZGkDppsnrWZgEKDw+nVatWPPfcc7i6ujJu3DiWLFlC48aN8fb25vTp0wCsW7eOJk2a0KBBA9q1a8eVK1cAdbGloKAgPD09GThwILVq1eLatWuAOkqdto/AwEC6d+9OvXr1eOmllwxTgX700Uf4+/vj5eXF4MGDDfcHBgYyevRo/Pz8mDRpEi4uLiQnq6vc3L59O8NtoZISi2zs2QN//QVHj0L58up93bqBl5f6WNOm+dt+cnIyvXv3Ztq0adSsWZPNmzcTHR3N3r17URSFkJAQ/vjjD2rWrEl0dDQLFy6kadOmrFmzhqioKA4dOsS1a9fw9/enZcuWLF26lODgYMaPH49er+d++mUoRYni4+PDwIEDefnllwFYsmQJPj4+GkclhBAlwOjREBWV7cO2QP0b8RgfVZf4VoyMSP1vafVs+fqqI2S5dOjQIU6cOIGdnR2urq4MHDiQvXv3MmPGDL7++mumT59O8+bN2b17Nzqdjrlz5zJ16lSmTZvGxIkTadOmDe+++y6bNm1i3rx5We7j4MGDHDt2jBo1atCsWTP++usvmjdvzvDhw/nwww8B6NOnD+vXr6dz584AJCUlGaZoi4mJ4ddff6VLly4sX76crl27Uq5cuVz3sSyQEeRsbNumJsRpyTGo17t1Ux/Lrw8++ABPT0969uwJwObNm9m8eTMNGjSgYcOGnDx5kujoaABq1apF0/8y8p07d/Liiy9ibGxM1apVadWqFfv27cPf35/58+cTGhrKkSNHsJKVckqs+fPn4+npyYwZM5gxYwYeHh7Mnz9f67CEEKJUMLkbD/8tlU5qKinX4gu05MLf35/q1atjZmZG7dq1ad++PQDe3t7ExMQA6qJLwcHBeHt78/nnn3Ps2DFA/R3fq1cvADp06ICtrW2W+2jcuDGOjo4YGRnh6+tr2O6OHTto0qQJ3t7ebN++3bBdwJBvAAwcONDwe2X+/Pm8+uqrBfcClBIygpwNOzs4fjzz/bGx6lc0+REeHs6aNWsyzFqgKArvvvsur732Woa2MTExVKhQ4bHbbNmyJX/88Qe//vor/fr144033qBv3775C1RowtzcnDFjxjBmzBitQxFCiJIlNyO9EREobdpCchKpJqac+XgJNs8E8N/EQflmZmZmuG5kZGS4bWRkZKj/HTFiBG+88QYhISGEh4cTGhr6xPswNjYmJSWFhIQEhg4dSmRkJE5OToSGhpKQkGBolz6XaNasGTExMYSHh6PX6/Hy8nqSrpZqMoKcjZ49YfNm9ZJm82Z1AvsXXnjy7d68eZNXX32VRYsWZRjlDQ4O5ocffjCcBRsXF8e///6b6fktWrRgxYoV6PV6rl69yh9//EHjxo05d+4cVatWZdCgQQwcODDTlGGi5HBxccHV1TXTRQghRAEICCBh/TYuvv4xf/9vG/d8Aor8pL34+HjDydcLFy403N+sWTNWrlwJqN8s37x5M9fbTEuG7e3tuXv3LqtXr86xfd++fendu7eMHmdDRpCzYWcHq1fDyy9D2hoN166p99nZPfl2v/32W/7991+GDBmS4f53332X3r17E/Df5JyWlpb8+OOPGD8yF83zzz9PREQE9evXR6fTMXXqVKpVq8bChQv5/PPPKVeuHJaWlixatOjJgxSaSr+MZ0JCAqtWreLGjRsaRiSEEKWLRdsAUpsEYHQHuAVXroC1NRRVdWJoaCg9evTA1taWNm3acPbsWQAmTJjAiy++yOLFiwkICKBatWq5Lpm0sbFh0KBBeHl5Ua1aNfz9/XNs/9JLL/H+++/z4osv5rs/pZFOUQpqTobiJ6s1w7NaWzwnKSnqSXkATZrIBOPZyevrWhoV5hr1jRo1Yv/+/YWy7YJUmK+BEEJkJb+/f1JS4ORJ9X93d0hXvVDkEhMTMTY2xsTEhIiICIYMGUJUDicd5sfq1asJCwtj8eLFWT6e1etalo7xku49hokJNGumdRSiLElfHpOamkpkZKTMWymEEIXExATc3ODECfjnH6hXr+AXEsmt8+fP88ILL5CamoqpqSnff/99oexnxIgRbNy4kQ0bNhTK9ksDSZCFKGbSVtQDMDExwcXFxVCTJoQQouCZm6sn4EdHw9mz6sp7Ol3Rx1GnTh0OHjxY6Pv5+uuvC30fJZ0kyEIUM/Pmzct0Ul5afZoQQojMFEVBl8+M1toanJzgwgW4dAlq1Cig4EqgUlx9m2syi4UQxUz37t1zdZ8QQgh1aszr168XSFJXpQpUqgQXL0IeJpAoVRRF4fr165ibm2sdiqZkBFmIYuLkyZMcO3aM+Ph41q5da7j/9u3bGeayFEII8ZCjoyOxsbFcvXq1QLanKHDnDuzdC9WqgalpgWy2RDE3N8fR0VHrMDQlCbIQxcSpU6dYv349t27dYt26dYb7raysCu1EDSGEKOnKlSuHi4tLgW7T1hb8/dUT+Pbtg8qVC3TzogQoFgly//79Wb9+PVWqVOHo0aOZHlcUhVGjRrFhwwYsLCxYsGABDRs21CDSgmFsbIy3tzcpKSm4u7uzcOFCLCwssmy7YMECIiMjmTVrVhFHKYrac889x3PPPUdERIRhPmwhhBBFr3p1+PlnaNECundXFwkriyPJZVmxqEHu168fmzZtyvbxjRs3Eh0dTXR0NHPmzMm0yEaherSmqQBqnMqXL09UVBRHjx7F1NSUb7/9Nt/bFCXf1KlTAVi6dCkjR47MdBFCCFF0/Pxg3jz44w+QQ3DZUyxGkFu2bElMTEy2j4eFhdG3b190Oh1Nmzbl1q1bXLp0ieoFtXB6dkJD4dYt+Oordb4XRYExY8DGRn2sALRo0YLDhw9z48YN+vfvz5kzZ7CwsGDOnDn4+PhkaHv16lVef/11zp8/D8D06dNp1qwZv//+O6NGjQJAp9Pxxx9/5LjyjqIopKSkkJqaSmpqKjqdDp1OZ5icXGgjbUJ2Pz8/jSMRQggB0Ls3HDkCU6aoq+zZ2UFgIMiXfKVficiG4uLicHJyMtx2dHQkLi6ucBNkRVGT4xkz1NtffaUmxzNmwKhR6uP5nFImJSWFjRs30qFDByZMmECDBg34+eef2b59O3379s20es6oUaMYM2YMzZs35/z58wQHB3PixAm++OILZs+eTbNmzbh79y5mZmbEx8fz4MEDkpKSDBc7OzuqVauGXq/n0KFDmeKpUaMGNWrUICkpiWPHjmFiYoKJiQlmZmaYmZlha2ubbSmIyL/OnTsD8Morr2gciRBCiDSffKKOIn/xBRgZqSvtbdsmSXJpVyIS5LyYM2cOc+bMAcjfGa06nZoUg5oUpyXKo0Y9HFF+Qg8ePMDX1xdQR5AHDBhAkyZNWLNmDQBt2rTh+vXr3L59O8Pztm7dyvHjxw23b9++TXx8PI0aNWL48OF0796dV155BQcHB06fPk1qairGxsaYmppiampqGB02MjKiZs2aGBkZGeaNVBTFkPzqdDoqVapESkoKycnJ3Lt3jxs3bmBmZoaFhQX379/nzJkzVKhQgQoVKmBpaSlzJhaAzp075ziP5y+//FKE0QghhAB1Vb127WDXLkhNhaQkCA+XBLm0KxEJsoODAxcuXDDcjo2NxcHBIcu2gwcPZvDgwUABfFWdliSnJceQ7+QYHtYg51Vqaiq7d+/G3Nycy5cvc+PGDaKjo+nUqRPu7u4cPHiQZs2a8dtvv1G3bl3MzMyyLJkwMjKiSpUq2e6nXLly1KxZM9O+0zMzM+P27dtcv34dgBs3bvDgwQMaNWpUIBO2l0VvvvlmoW37rbfeYt26dZiamlK7dm3mz5+PjY0NAJMnT2bevHkYGxszc+ZMgoODAdi0aROjRo1Cr9czcOBAxo0bV2jxCSFEcdahA0ydCgkJapIsyXHpVyxO0nuckJAQFi1ahKIo7N69G2tr68KvP4aHNcfpjRlTICfqPapFixYsWbIEgPDwcOzt7alYseJ/YSjcvXuXFi1aGJaHvH//PqdOnaJ69eqYmJjQvXt3pkyZgr+/PydPnqRChQoFWk9sZGSEkZH6cbGwsKBOnTr4+Pjg7e2Ni4sL5cuXp06dOgB88cUXtGnThu+//96QQIvHa9WqleESEBCAra0tdnZ2BAQE0KpVq3xtOygoiKNHj3L48GGeeuopJk+eDMDx48dZvnw5x44dY9OmTQwdOhS9Xo9er2fYsGFs3LiR48ePs2zZsgzfXgghRFkSEADbt8PLL6spwI8/FkoqIIqRYpEgv/jiiwQEBHDq1CkcHR2ZN28e3377rWF2h44dO+Lq6oqbmxuDBg3if//7X+EHlZYcp9Ucp6aq/8+YUShJcmhoKPv378fHx4dx48axcOFCkpKSiI+P58aNG5w8eZLhw4ezd+9efHx86NSpE7/99hsODg7MmzeP+vXr4+PjQ7ly5XjmmWcKNLbs6HQ6zMzMqFSpUoaE3sbGhtjYWAYPHky1atUICQnJcZYSkdGvv/5K7dq1GTlyJMOHD8fNzY2NGzfma5vt27c3/MHUtGlTYmNjAfUE2F69emFmZoaLiwtubm7s3buXvXv34ubmhqurK6ampvTq1YuwsLB8900IIUqqgABYvBjGj1dnt/ivmlOUUsWixGLZsmU5Pq7T6Zg9e3YRRWPYqTpbRfqa47SaZBubfJVZ3L17N9N9dnZ2/Pzzz4bb8fHxHD58mGbNmhEcHIy9vT22tra0bds203PTRpWLi0GDBjFw4EAOHjzIsmXLWLx4MYmJiXTo0AFQR7/lZL/sjR07lh07duDm5gbA6dOnefbZZwvsD58ffviBnj17AuoJsE2bNjU8lnYCLJDpxNg9e/Zkub0Cq/sXQogSYOJE2L8fRoyA+vUh3SFUlCLFIkEutkJDM85WkZYkF0J9raIo3L59G0VRsLGxwdLSkurVq1OpUqUSuR66TqejYcOGNGzYkEmTJhkSp/Pnz+Pj48Nrr73Gm2++SWVZnigTKysrQ3IM4OrqmuO0fWnatWvH5cuXM90/adIknnvuOcN1ExMTXnrppQKLt0Dr/oUQopgzNoYlS9SV9rp1U5PlatW0jkoUNEmQH+fRZLgQkuPbt28TFxfHvXv3sLKywsbGBmNj42xPRCxpTE1NDX3R6XR07NiRzz//nFmzZjF06FDeeuutHE8aLGv8/Pzo2LEjL7zwAjqdjlWrVuHv78/atWsB6Nq1a5bP27p1a47bXbBgAevXr2fbtm2GkyhzOgE2tyfGCiFEWWNnB2vXqmUXL7ygTvtWrpzWUYmCVCxqkItacZmS7P79+/z999/8/fffJCcnU6tWLcOJbiVJXl5PJycnli5dyvHjx+natStffvkl9erVIz4+vhAjLFkSEhKoWrUqv//+O+Hh4VSuXJkHDx6wbt061q9f/0Tb3LRpE1OnTuWXX37JUN4SEhLC8uXLSUxM5OzZs0RHR9O4cWP8/f2Jjo7m7NmzJCUlsXz5ckJCQgqqi0IIUeLVrw9z58Kff0IhTkIkNFLmRpDNzc25fv06lSpV0nwqsoSEBO7du4ejoyNVqlQxzBJRkiiKwvXr1/NcBlKvXj0WL17M+++/z59//om1tTUAkZGRNGrUSPP3Rkvz588v8G0OHz6cxMREgoKCAPVEvW+//RZPT09eeOEFPDw8MDExYfbs2RgbGwMwa9YsgoOD0ev19O/fH09PzwKPSwghSrLevWHfPpg+XS25ePllrSMSBUWnFJfh1ELg5+dHZGRkhvuSk5OJjY0lISFBk5ju3btHamqqoaY0NTW1RCbG6Zmbm+Po6Ei5fH6/tHv3bgICAggJCeHbb78tmqn8ClBWn7cncfbsWb7++mtiYmJISUkx3F8SFgopqNdACCFKiuRkCAqCPXvUxUQaNNA6osJTlo7xZW4EuVy5cri4uBT5fv/9918GDBjA+vXradGiBeHh4SU+MS5ojRo14vPPP+eDDz7A09OTmTNn8tJLL5W50eQuXbowYMAAOnfuLJ8RIYQo5sqVg5UroWFD6NoVIiOhUiWtoxL5Jb99i8DGjRvx9vZmy5YtfPnll+zYsUMSnyyUK1eON998k0OHDuHu7k6fPn148cUXi03NeFExNzdn5MiRtG7dOsPiIUIIIYqnKlXUk/YuXlTLLvR6rSMS+VXmRpCL2unTp+nUqROenp5s27YNLy8vrUMq9p566in++OMPZs6ciY2NTZkbQR41ahQTJ06kffv2mJmZGe5v2LChhlEJIYTISePGMHs2DBoEH3wAn36qdUQiPyRBLiSJiYmYmZlRu3ZtfvnlF9q2bVsi5zPWirGxMWPSLfO9dOlSrl69ysiRI0t9wnzkyBEWL17M9u3bDd806HQ6tm/frnFkQgghcjJwoHrS3uTJkDZ9fWCgOh2cKFkkQS4E+/bto3v37sydO5egoCCeffZZrUMq8davX8+yZcs4cOAA33//PaamplqHVGhWrVrFmTNnSnUfhRCitJo5E3buhPfeAyMjMDNT50mWJLlkkULYArZy5UpatGiBTqeTxS8K0JIlS5g4cSKLFi2iQ4cO3Lp1S+uQCo2Xl1ep7p8QQpRmZmbQubN6PTUVkpIgPFzTkMQTkBHkAvTNN98wbNgwmjVrxk8//YS9vb3WIZUaOp2ODz/8EBcXFwYMGMDTTz/N3r17sbS01Dq0Anfr1i3q1auHv7+/oQZZp9MRFhamcWRCCCFy47nnYMYMSEhQk+S6dbWOSOSVJMgFJDw8nKFDh9K5c2dWrFhB+fLltQ6pVOrTpw9OTk78/vvvpTI5Bpg4caLhuqIo/PnnnyxfvlzDiIQQQuRFQABs3w7LlsGCBepKe02agIOD1pGJ3JISiwLSqlUrFi5cyJo1ayQ5LmSBgYFMmDABgMOHD3Pq1CmNIypYrVq1omLFiqxfv55+/fqxfft2Xn/9da3DEkIIkQcBAWo98rZtcO0atG0LV65oHZXILUmQ8+mrr77i1KlT6HQ6+vbtm+/V5ETupaam0rt3bwIDAzl58qTW4eTb33//zcSJE6lXrx4jRoygZs2aKIrCjh07GDFihNbhCSGEeAL+/rBhA1y4oK64d+OG1hGJ3JAEOR8+//xz3njjDebMmaN1KGWSkZERK1euRFEU2rVrx4ULF7QOKV/q1avH9u3bWb9+PTt37mTEiBEYGxtrHZYQQoh8at4cwsLg778hOBji47WOSDyOJMhP6Pvvv+ftt9+mZ8+eTJ06VetwyiwPDw82b97MnTt3eOaZZ7h586bWIT2xtWvXUr16dVq3bs2gQYPYtm1bmVtFUAghSqt27WD1aoiKgmefhXv3tI5I5EQS5CewdetWhgwZQocOHVi8eLGM8mnMx8eHn3/+mb///ptJkyZpHc4T69KlC8uXL+fkyZO0bt2a6dOn8++//zJkyBA2b96sdXhCCCHyqVMnWLoUIiLUmS4SErSOSGRHEuQnMH36dNzd3VmxYoXUHBcTrVu3Ztu2bXzyySdah5JvFSpUoHfv3qxbt47Y2FgaNGjAZ599pnVYQgghCkCPHurMFtu3Q/fu6jzJoviRBPkJrF69mt9++42KFStqHYpIp0WLFpibm3Pjxg1++eUXrcMpELa2tgwePJht27ZpHYoQQogC0qcPfPMN/Por9O4NKSlaRyQeJQlyLimKwtSpU7lx4wbm5ubUqFFD65BENt5//326devGzp07tQ5FCCGEyNJrr8FXX8GaNWrpxaefqqUXoniQBDmXZs+ezTvvvMOKFSu0DkU8xuTJk3FxcaFHjx78+++/WocjhBBCZGn0aBg8GH77Dd5/X50ruTCS5IgImDxZEvC8kAQ5Fw4ePMjYsWN59tlnZcGGEsDa2po1a9Zw8+ZNBg8eLDNBCCGEKLacnUGnA0WBBw9g6lRITCy47UdEQJs2hZuAl0aSID9GQkICL774IpUrV2bBggXodDqtQxK54O3tzaeffkpYWBiLFy/WOhwhhBAiS4GBYG4ORkbq5eefwc0NZs/O3ywXiYmwZAm8+KK6ndRU9YTA8PACCryUM9E6gOLus88+49SpU/z222/Y29trHY7Ig9GjR3P9+nWCgoK0DkUIIYTIUkCAuhx1eDi0agX378PEiTB8OEyaBO+8A4MGgYVF7rZ3+jTMmQM//KAuce3gAOXKqQmyqamakIvHKzYjyJs2baJu3bq4ubkxZcqUTI8vWLCAypUr4+vri6+vL3Pnzi2SuF577TX+97//0b59+yLZnyg4RkZGTJo0ierVq6MoipRaANOmTUOn03Ht2jVAPfl05MiRuLm54ePjw4EDBwxtFy5cSJ06dahTpw4LFy7UKmQhhCj1AgLg3Xfh6afVBUX++EOdBq5uXbVO2dUVpk3LfnGRlBR1pb4OHdTR52nToGVL2LwZzp+H33+Hjz9WE/GAgCLtWolVLEaQ9Xo9w4YNY8uWLTg6OuLv709ISAgeHh4Z2vXs2ZNZs2YVSUypqanodDqqVavGkCFDimSfonD8+++/9OrVi5EjR9KlSxetw9HMhQsX2Lx5MzVr1jTct3HjRqKjo4mOjmbPnj0MGTKEPXv2cOPGDSZOnEhkZCQ6nY5GjRoREhKCra2thj0QQoiyQaeD1q3Vyx9/qMntm2/ClCnq/40awb594OkJhw6pI8axsepocWgoDByoXk8TECCJcV4VixHkvXv34ubmhqurK6ampvTq1YuwsDBNY/rhhx9o1aoVN27c0DQOkX92dnZcvXqV0aNHc//+/SfbyKOjzyVwNHrMmDFMnTo1Qx19WFgYffv2RafT0bRpU27dusWlS5f47bffCAoKws7ODltbW4KCgti0aZOG0QshRNnUsiVs2QJ//QV+fjBuHAQFwXvvqavxffgheHjA2rUQEwMTJmRMjsWTKRYJclxcHE5OTobbjo6OxMXFZWq3Zs0afHx86N69OxcuXMhyW3PmzMHPzw8/Pz+uXr36RPHcvXuXDz74AL1eLyNmpYCJiQmzZ8/m3LlzTJ48Oe8bCA2FMWMeJsWKot4ODS3IMAtVWFgYDg4O1K9fP8P92f3s5fZnUgghRNF4+mnYuBHSf6mt08HYseo0cc8/DybFoi6gdCgWCXJudO7cmZiYGA4fPkxQUBCvvPJKlu0GDx5MZGQkkZGRVK5c+Yn29fnnn3P58mVDvaYo+Vq2bEmvXr2YNm0aly9fzv0TFQVu3YIZMx4myWPGqLdv3SpWI8nt2rXDy8sr0yUsLIxPP/2Ujz76qFD2WxB/lAohhMidPn2gfHkwNlZnv+jWTeuISqdikSA7ODhkGBGOjY3F4ZHvBypVqoSZmRkAAwcOZP/+/YUSy6VLl/jiiy944YUXaNq0aaHsQ2jjo48+IikpienTp+f+STqdutTRqFFqUmxkpP4/apR6fzH6A2rr1q0cPXo008XV1ZWzZ89Sv359nJ2diY2NpWHDhly+fDnbn73c/EymKYg/SoUQQuRO2qwXctJd4SoWCbK/vz/R0dGcPXuWpKQkli9fTkhISIY2ly5dMlz/5ZdfcHd3L5RYZs2aRWJiIp9++mmhbF9op06dOvz888+8//77eXtiWpKcXjFLjnPi7e3Nv//+S0xMDDExMTg6OnLgwAGqVatGSEgIixYtQlEUdu/ejbW1NdWrVyc4OJjNmzdz8+ZNbt68yebNmwkODta6K0IIIXg464Ukx4WnWFSrmJiYMGvWLIKDg9Hr9fTv3x9PT08+/PBD/Pz8CAkJYebMmfzyyy+YmJhgZ2fHggULCiWW9957j+bNm1O7du1C2b7QVqdOnfL+pLSyivTGjClRSXJ2OnbsyIYNG3Bzc8PCwoL58+cD6omNH3zwAf7+/gB8+OGH2NnZPXZ7MTEx+Pn55Sumq1evlpmR6LLUVyhb/ZW+lk5lva8xMTHaBKMBnVKKJ4f18/MjMjJS6zBEMfPnn38yduxYNmzY8PjFX9LXHKeVVTx6+78kWT5vBaMsvY5lqa9QtvorfS2dpK9lR7EosSgO7t27R9OmTdm6davWoYhCZmdnx759+/j+++8f31inAxubjMlwWk2yjU2JH0EWQgghRGbFosSiOFi5ciV79uzB1NRU61BEIfP09CQoKIhZs2bx5ptvUq5cuZyfEBqqjiSnJcNpSbIkx0IIIUSpJCPI//nuu+9wd3enRYsWWociisDo0aO5ePEia9asyd0THk2GJTkuNIMHD9Y6hCJTlvoKZau/0tfSSfpadkgNMnDo0CF8fX356quvGD16dOEHJjSXmpqKq6sr9erVK7AV4sp6vZYQQghRWkiJBTB37lzMzMzo27ev1qGIImJkZMTEiRMxNjbWOhQhhBBCFDN5TpD1en2pSyoCAwNxdHTM1TRWovTIbjVGIYQQQpRtea5BrlOnDm+99RbHjx8vjHg00a1bN9555x2twxAauHz5MgsXLtQ6DPGfTZs2UbduXdzc3JgyZYrW4RQqZ2dnvL298fX1zffc0cVN//79qVKlCl5eXob7bty4QVBQEHXq1CEoKIibN29qGGHByaqvoaGhODg44Ovri6+vLxs2bNAwwoJz4cIFWrdujYeHB56ensyYMQMone9tdn0tje9tQkICjRs3pn79+nh6ejJhwgQAzp49S5MmTXBzc6Nnz54kJSVpHGnRynOCfOjQIZ566ikGDhxI06ZNmTNnDrdv3y6M2IrE77//TmxsrNZhCI0sXryYfv36ZVhWWWhDr9czbNgwNm7cyPHjx1m2bFmp+kM8Kzt27CAqKqrU1a7369cvU23/lClTaNu2LdHR0bRt27bU/AGUVV8BxowZQ1RUFFFRUXTs2FGDyAqeiYkJ06ZN4/jx4+zevZvZs2dz/PjxUvneZtdXKH3vrZmZGdu3b+fQoUNERUWxadMmdu/ezTvvvMOYMWP4559/sLW1Zd68eVqHWqTynCBbWVkxaNAgdu3axWeffcbEiROpXr06r7zyCv/8809hxFhoFEXhpZdeYsSIEVqHIjTy7LPPApSKUYCSbu/evbi5ueHq6oqpqSm9evUiLCxM67DEE2jZsmWmkrWwsDBDWdMrr7zCzz//rEFkBS+rvpZW1atXp2HDhoCaC7i7uxMXF1cq39vs+loa6XQ6LC0tAUhOTiY5ORmdTsf27dvp3r07UHre17zIc4Ks1+v55ZdfeP755xk9ejRjx47lzJkzdO7cucT9JXX8+HHi4uKebPlhUSq4u7vj7OzM+vXrtQ6lzIuLi8PJyclw29HRsdT+QgL1l1L79u1p1KgRc+bM0TqcQnflyhWqV68OQLVq1bhy5YrGERWuWbNm4ePjQ//+/UtFycGjYmJiOHjwIE2aNCn17236vkLpfG/1ej2+vr5UqVKFoKAgateujY2NDSYm6qlqpf14nJUnqkEOCwvjrbfe4uDBg7zxxhtUrVqV7t2706FDh8KIsdBs374dgLZt22ocidCKTqejU6dObNu2jYSEBK3DEWXIzp07OXDgABs3bmT27Nn88ccfWodUZHQ6HbpSPJf4kCFDOH36NFFRUVSvXp2xY8dqHVKBunv3Lt26dWP69OlUrFgxw2Ol7b19tK+l9b01NjYmKiqK2NhY9u7dy8mTJ7UOSXN5SpD1ej39+vVj3rx5PP3005kenzlzZoEFVhS2bduGq6srzs7OWociNNSuXTsePHjAkSNHtA6lTHNwcMhQCx4bG4uDg4OGERWutL5VqVKF559/nr1792ocUeGqWrUqly5dAuDSpUtUqVJF44gKT9WqVTE2NsbIyIhBgwaVqvc2OTmZbt268dJLL9G1a1eg9L632fW1tL63ADY2NrRu3ZqIiAhu3bpFSkoKUPqPx1nJU4JsbGxcar6K1uv1hIeH06ZNG61DERpr3749165dw9/fX+tQyjR/f3+io6M5e/YsSUlJLF++nJCQEK3DKhT37t3jzp07huubN2/OMAtCaRQSEmKYMWbhwoU899xzGkdUeNKSRYCffvqp1Ly3iqIwYMAA3N3deeONNwz3l8b3Nru+lsb39urVq9y6dQuABw8esGXLFtzd3WndujWrV68GSs/7mhd5XklvzJgxJCcn07NnTypUqGC4P62YvTjJaWUzRVG4fPkyqampZe6vIlE4ZCW9/NuwYQOjR49Gr9fTv39/xo8fr3VIheLMmTM8//zzAKSkpNC7d+9S1dcXX3yR8PBwrl27RtWqVZk4cSJdunThhRde4Pz589SqVYuVK1eWipPbsupreHg4UVFR6HQ6nJ2d+e677ww1uiXZzp07adGiBd7e3hgZqeNrn376KU2aNCl17212fV22bFmpe28PHz7MK6+8gl6vJzU1lRdeeIEPP/yQM2fO0KtXL27cuEGDBg348ccfMTMz0zrcIpPnBLl169aZN/Lf2Y7FjSQsIrd+/fVXli5dyo8//vjE9XPyeRNCCCFKhzyvpLdjx47CiKPILVmyhOvXrzNy5EitQxHFwJkzZ1i6dClffPFFiR8NEEIIIUT+5DlBBnW07dixYxnO+v/www8LLKii8MMPP3Dnzh1JkAWgTvcGcOLECUmQhRBCiDIuz9O8vf7666xYsYKvv/4aRVFYtWoV586dK4zYCtXx48fx9vbWOgxRTKRPkIUQQghRtuU5Qd61axeLFi3C1taWCRMmEBERwd9//10YsRWaBw8ecPnyZVxcXLQORRQTNWrUwMrKShJkIYQQQuQ9QS5fvjwAFhYWXLx4kXLlymWY9qQkiImJAZAEWRjodDqaNm1qmPNRCCGEEGVXnhPkTp06cevWLd566y0aNmyIs7MzL774YmHEVmguX76MiYmJJMgig82bN/Ptt99qHYYQoohMmjQJT09PfHx88PX1Zc+ePYW2r8DAQJnlRogSJM8n6X3wwQcAdOvWjU6dOpGQkIC1tXWBB1aYWrduLcsKCyFEGRYREcH69es5cOAAZmZmXLt2jaSkJK3DEkIUE3keQQa1Dnnp0qWsWLGCsLAwFi1aVNBxFTpjY2OMjY21DkMUI8uXL6dZs2ZSZiFEGXDp0iXs7e0NCx/Y29tTo0YNPvroI/z9/fHy8mLw4MGkLRUQGBjImDFj8PPzw93dnX379tG1a1fq1KnD+++/D6jle/Xq1eOll17C3d2d7t27c//+/Uz73rx5MwEBATRs2JAePXpw9+7douu4ECJX8pwg9+nThzfffJOdO3eyb98+9u3bV+K+Nvrxxx95/fXXtQ5DFDM3btxg165dXLt2TetQhBCFrH379ly4cIGnnnqKoUOH8vvvvwMwfPhw9u3bx9GjR3nw4AHr1683PMfU1JTIyEhef/11nnvuOWbPns3Ro0dZsGAB169fB+DUqVMMHTqUEydOULFiRf73v/9l2O+1a9f45JNP2Lp1KwcOHMDPz48vv/yy6DouhMiVPJdYREZGcvz48Sdebaw42LlzJz/99JPUm4oM0pZOz2rERwhRulhaWrJ//37+/PNPduzYQc+ePZkyZQpWVlZMnTqV+/fvc+PGDTw9PencuTMAISEhAHh7e+Pp6WmYM93V1ZULFy5gY2ODk5MTzZo1A+Dll19m5syZvPnmm4b97t69m+PHjxvaJCUlERAQUJRdF0LkQp4TZC8vLy5fvlzgiyls2rSJUaNGodfrGThwIOPGjcvweGJiIn379mX//v1UqlSJFStW4Ozs/ET7io+PL3F106LwmZubA+pnTQhR+hkbGxMYGEhgYCDe3t589913HD58mMjISJycnAgNDc1wvkpaOYaRkZHhetrttNKsRwePHr2tKApBQUEsW7assLolhCgAeS6xuHbtGh4eHgQHBxMSEmK45Ider2fYsGFs3LiR48ePs2zZMo4fP56hzbx587C1teWff/5hzJgxvPPOO/nan4nJEy0iKEqxtARZTuAUovQ7deoU0dHRhttRUVHUrVsXUOuR7969y+rVq/O83fPnzxMREQHA0qVLad68eYbHmzZtyl9//cU///wDwL1790rcWgJClAV5zhJDQ0MLPIi9e/fi5uaGq6srAL169SIsLAwPDw9Dm7CwMMO+u3fvzvDhw1EUpUSXeojixdTUFEDOZBeiDLh79y4jRozg1q1bmJiY4Obmxpw5c7CxscHLy4tq1arh7++f5+3WrVuX2bNn079/fzw8PBgyZEiGxytXrsyCBQt48cUXDd9WffLJJzz11FMF0i8hRMHIc4LcqlWrAg8iLi4OJycnw21HR8dM81Gmb2NiYoK1tTXXr1/H3t4+Q7s5c+YwZ84cAK5evZrl/ipWrIidnV1BdkGUAlWqVCE4OJiKFStqHYoQopA1atSIXbt2Zbr/k08+4ZNPPsl0f3h4uOF6WlnGo4/FxMRgYmLCjz/+mOPz27Rpw759+544diFE4ct1gty8eXN27tyJlZVVhlHbtFHc27dvF0qAeTV48GAGDx4MgJ+fX5Zt5s6dW5QhiRKiUaNGbNq0SeswhBBCCKGxXCfIO3fuBODOnTsFHoSDgwMXLlww3I6NjcXBwSHLNo6OjqSkpBAfH0+lSpUKPBYhhBDiSTg7O3P06FGtwxBCFIA8n6R348aNTJfk5OR8BeHv7090dDRnz54lKSmJ5cuXZzrxLyQkhIULFwKwevVq2rRp88T1x4sWLaJHjx75ilmUPsuWLaNmzZpcvHhR61CEEEIIoaE81yA3bNiQCxcuYGtri6Io3Lp1i2rVqlG1alW+//57GjVqlPcgTEyYNWsWwcHB6PV6+vfvj6enJx9++CF+fn6EhIQwYMAA+vTpg5ubG3Z2dixfvjzP+0lz+vRp1qxZQ2pqKkZGT7SYoCiFLl68yIULFyhfvrzWoQghhBBCQ3lOkIOCgujevTvBwcGAumTmmjVrePXVVxk6dGimk+tyq2PHjnTs2DHDfR999JHhurm5OatWrXqibT/KxsYGRVG4ffs2NjY2BbJNUfJdvnwZMzMz+UwIIYQQZVyeh093795tSI5BXa4zIiKCpk2blpgFFipXrgzAlStXNI5EFCeXLl2ievXqMnWgEEIIUcblOUGuXr06n332GefOnePcuXNMnTqVqlWrotfrS0y5QtoKfDExMZrGIYqXy5cvU61aNa3DEEIIIYTG8lxisXTpUiZOnEiXLl0AaNasGUuXLkWv17Ny5cqCjq9QuLi4ULt2bVkQQmQQGBhIamqq1mEIIYQQQmM6RVEUrYMoLH5+fkRGRmodhigj5PMmhBBClA55HkG+evUqU6dO5dixYyQkJBju3759e4EGJkRRSkpKwsjICBOTPP9ICCGEEKKUyXPR8EsvvUS9evU4e/YsEyZMwNnZ+YnWq9faF198QcuWLbUOQxQTv/zyCxYWFhw7dkzrUIQQQgihsTwnyNevX2fAgAGUK1eOVq1a8cMPP5TI0eOUlBT+/PNPbt26pXUoohg4evQoKSkphhM4hRBCCFF25TlBLleuHKDOZvHrr79y8OBBbty4UeCBFbYGDRoAEBUVpW0goljYvXs33t7eVKhQQetQhBBCCKGxPCfI77//PvHx8UybNo0vvviCgQMH8tVXXxVGbIWqYcOGAOzbt0/jSITWUlNTiYiIICAgQOtQhBBCCFEM5DlB7tSpE9bW1nh5ebFjxw72799PSEhIYcRWqCpXrkzdunUJDw/XOhShsePHj3P79m2efvpprUMRQohCpdPpqFChAuPHj89V+zZt2mBubk7z5s0LOTIhipc8J8hnz57ljTfeoGvXroSEhBguJdGrr75qGEkWZZetrS2TJ0+mdevWWociRKmwc+dOnn76aaytrbGzs6NZs2aGb+ucnZ3ZunVroe3b2dmZ8uXLY2lpSbVq1ejXrx93794ttP2VRIcOHWLSpEm5art9+3a+/fbbQo5IiOInz3NadenShQEDBtC5c+cSs3Jedt555x2tQxDFgIODA+PGjdM6DCFKhdu3b9OpUye++eYbXnjhBZKSkvjzzz8xMzMrshjWrVtHu3btuHz5MsHBwUyePDnXCaEQQsATjCCbm5szcuRIWrduTatWrQyXkio5OVmWnC7DEhISWLt2rYwwCVFA/v77bwBefPFFjI2NKV++PO3bt8fHx4c+ffpw/vx5OnfujKWlJVOnTgXg4sWLdOvWjcqVK+Pi4sLMmTMN23N2dmby5Ml4eHhga2vLq6++mmEO/pxUq1aN4ODgDCdj57Svzz77DAcHB6ysrKhbty7btm3LVRwnTpwgMDAQGxsbPD09+eWXXzLE4ezszBdffIGPjw/W1tb07NnT8Nzs9plTnI9z5swZnn32Wezt7alYsSJBQUHZtv3uu+/o2LEjw4YNw97enho1arBly5Zc70uIUkvJoyVLliihoaHKrl27lP379xsuxVGjRo0e26ZDhw5K/fr1Cz8YUSxt3LhRAZQNGzbke1u5+bwJUdrFx8crdnZ2St++fZUNGzYoN27cyPB4rVq1lC1bthhu6/V6pWHDhsrEiROVxMRE5fTp04qLi4uyadMmQ3tPT0/l/PnzyvXr15Wnn35aGT9+fLb7T7/9CxcuKF5eXsrIkSMfu6+TJ08qjo6OSlxcnKIoinL27Fnln3/+ybDdrOJISkpSateurUyaNElJTExUtm3bplhaWionT57M8Fx/f38lLi5OuX79ulKvXj3lm2++yXafj3tNHqdZs2bKrFmzlJSUFOXBgwfKzp07DY8BSnR0tOH2kCFDFFtbW2XTpk2KXq9XQkNDlbZt22bY3vz585VmzZrlat9ClBZ5HkE+cuQI33//PePGjWPs2LGMHTuWN998s+Az9yLSvn17Dh06RHR0tNahCA2sW7eO8uXLExgYqHUoQpQKFStWZOfOneh0OgYNGkTlypUJCQnhypUrWbbft28fV69e5cMPP8TU1BRXV1cGDRrE8uXLDW2GDx+Ok5MTdnZ2jB8/nmXLluUYQ5cuXbCyssLJyYkqVaowceLEx+7L2NiYxMREjh8/TnJyMs7OztSuXTvDdrOKY/fu3dy9e5dx48ZhampKmzZt6NSpU6YYR44cSY0aNbCzs6Nz585ERUVlu8/cvCY5OX36NHq9Hr1ej7m5Oc2aNcu27eHDhxk3bhzBwcEYGRnh4eGRq30IUdrlOUFetWoVZ86c4ffff2fHjh3s2LGjRC4UkqZbt24ArFmzRuNIRFFLTk5m5cqVdOrUifLly2sdjhClhru7OwsWLCA2NpajR49y8eJFRo8enWXbc+fOcfHiRWxsbAyXTz/9NENC7eTkZLheq1YtLl68mOP+f/75Z+7cuUN4eDgnT57k2rVrj92Xm5sb06dPJzQ0lCpVqtCrV69M+8kqjosXL+Lk5JThnJxatWoRFxeX4bnVqlUzXLewsODu3bvZ7jM3r0lOlixZQlhYGDVq1GDAgAHZrlWgKApHjhyhc+fOhvuOHj0qSbIQPEGC7OXlVapWn6tZsyaNGzdmxYoVWociitimTZu4du0affr00ToUIUqtevXq0a9fP44ePQqo04yl5+TkhIuLC7du3TJc7ty5w4YNGwxtLly4YLh+/vx5atSokat9t2rVin79+hm+5Xzcvnr37s3OnTs5d+4cOp0u04ncWcVRo0YNLly4QGpqaobHHBwcchVjVvvMzWuSkzZt2rBt2zaOHz/OoUOHWLBgQZbtYmJiSElJoW7duob7Dh48iK+vb672I0RplucE+datW9SrV4/g4OASP81bmj59+hAVFcWhQ4e0DkUUoa1bt2Jvb0+HDh20DkWIUuPkyZNMmzaN2NhYQE0qly1bRtOmTQGoWrUqZ86cMbRv3LgxVlZWfPbZZzx48AC9Xs/Ro0czLOI0e/ZsYmNjuXHjBpMmTaJnz565jmf06NFs2bKFQ4cO5bivU6dOsX37dhITEzE3N6d8+fKZZmrKKo4mTZpgYWHB1KlTSU5OJjw8nHXr1tGrV6/HxpbdPnPzmvTr149+/fpl2ubatWuJjo5GURTu3LnDzZs3s014Dx8+jLe3d4Z+Hjx4kPr16+fuxRWiFMtzgjxx4kR++ukn3nvvPUMN8tixYwsjtiLz8ssvs337dnx8fLQORRSh6dOnc/DgQcPy6UKI/LOysmLPnj00adKEChUq0LRpU7y8vJg2bRoA7777Lp988gk2NjZ88cUXGBsbs379eqKionBxccHe3p6BAwcSHx9v2Gbv3r1p3749rq6u1K5dm/fffz/X8VSuXJm+ffvy0Ucf5bivxMRExo0bh729PdWqVePff/9l8uTJGbaVVRympqasW7eOjRs3Ym9vz9ChQ1m0aBH16tV7bGzZ7TM3r8mFCxeyrC3euXMnrVq1wsrKio4dOzJu3DjatGmT5f4PHz6cIXm+du0aly9fxsvLK5evrhCll05RFEXrIAqLn58fkZGRWochiqHU1NQCn8dbPm9CFDxnZ2fmzp1Lu3btJI7/JCUlUb9+fQ4fPpznP/DNzc0xMzNj5MiRfPzxx49tHxQUxO7du2ncuHGGae+EKO1yvVCIlZVVptoxUIv8dTodt2/fLtDAilpCQgLjxo2jYcOG9O3bV+twRCFKTk6mfv36DB8+nKFDh2odjhBC5ImpqSknTpx4oufmdg7pNDInsiircp0g37lzpzDj0JyZmRkRERH88ssv9O7dGxOTPC8yKEqItWvXcuLEiQxnpD+WokD6PxAfvS2EEEKIUqNkrxVdgHQ6He+99x5nz55l5cqVWocjComiKEybNo3atWvz7LPP5u5JoaEwZoyaFKsbUW+HhhZWmEKI/8TExBSLsobiEocQomhIgpxO586d8fDwYPLkyRmm7BGlx/r169m3bx/jxo3LXQ2yosCtWzBjxsMkecwY9fatWw+TZiGEEEKUGpqfpHfjxg169uxJTEwMzs7OrFy5Eltb20ztjI2N8fb2BtS5ix9d6z4rT3LS1I8//kifPn1YtWoV3bt3z9NzRfGmKAp+fn7cvn2b48eP5/7klvRJcZpRo+CrrzKUWchJemBvb4+zs7PWYQghhCgEMTExhoV3SjvNE+S3334bOzs7xo0bx5QpU7h58yafffZZpnaWlpbcvXs3T9t+koQlJSWFt99+m6FDh+Lm5pan54ri79ixY1y7do1WrVrl7YmKAulHnFNTM9UgS4Isr4EQouBEREB4OAQGQkBAwbcXeVeWjvGan4kWFhZGeHg4AK+88gqBgYFZJshFxcTEhC+//FKz/YvCkTbbiqen55M8WR1BTm/MmEwjyEIIIQrG9u3QsSMkJYGJCYwdC7VrZ9/+9GmYNg30ejAzg23bJEkW+aN5gnzlyhWqV68OqGvVZ7fWfEJCAn5+fpiYmDBu3Di6dOmSZbs5c+YwZ84cAK5evfrEcZ0+fZoPPviAWbNmYWdn98TbEcXDp59+yqFDh/jxxx8xNTXN/RPTl1eklVWkL7eQJFkIIfIlKQkOH4Z9+9RLZCQcPfrwFI/kZJgyJffbe/AA+vSBESOgU6ecE2shslMkCXK7du24fPlypvsnTZqU4bZOp8tyrmWAc+fO4eDgwJkzZ2jTpg3e3t7UzuJTP3jwYAYPHgyoXwU8qXv37rFixQqsrKz47rvvnng7Qnvnzp1j0qRJPPvss3lLjkFNfm1sMtYcf/WV+piNjSTHQgiRBzt3wurVYGkJN2+qCfGhQ2qSDFCpEvj7g58fLFmijgiXKwfLl0OjRtlvd/9+6NVL3Y6REaSkwOjR6qVePTVR7tQJmjVTR6SFeJwi+Zhs3bo128eqVq3KpUuXqF69OpcuXaJKlSpZtnNwcADA1dWVwMBADh48mGWCXFB8fHwYM2YM06ZNo3fv3nmvWRXFxujRo9HpdE9eOhMamnHe47QkWZJjIYR4rNu3YcMG+P57tXQijYUFNG6sjj/4+6uXWrUeHloHDcp9TbGjo7rt9O1Pn4Zff4X169Uv/b74Qh3XeOYZNVmuVAkOHJCaZZE1zU/Se+utt6hUqZLhJL0bN24wderUDG1u3ryJhYUFZmZmXLt2jYCAAMLCwvDw8Mhx2/ktJr9//z7e3t4YGxtz6NAhypcv/8TbEtpYvnw5L774IlOmTOGdd94p1H2VpZMXsiOvgRAC4N9/4Zdf4KefYOtWdWTX0hLu3VPHG4yN4aOP4L33iiaeO3dgyxZYt05NmtNXYJqbq8m1JMmPV5aO8ZrPgzxu3Di2bNlCnTp12Lp1K+PGjQMgMjKSgQMHAnDixAn8/PyoX78+rVu3Zty4cY9NjguChYUF3333HdHR0UyfPr3Q9ycKll6vZ8KECTRt2pSxY8dqHY4QQpRq587B9OnQqhVUr66OAJ84AcOHq6UVGzeqyaixMZiaQuvWRReblRV07Qrz58PlyzBkyMOR6oQE+PJLmdZeZKT5CHJhKqi/dBYsWEC3bt2wsrIqgKhEUbpy5QoPHjwokrl5y9Jf1tmR10CIsmXZMjXpPHcO/v5bvc/LS01Gn38e6tfPWI1WXKZii4iAtm3VkW1FUWfu7NgRvvtOLdcQWStLx3gpVc+Ffv36AfDgwQPu379PpUqVtA1IPNbOnTsJCAigatWqWocihBClytmz6klzc+fCmTPqfUZGMHSoelJcnTrZPzcgoHiUMgQEqFPBhYdDixbqSX7vvguenupocv/+cppJWad5iUVJkZqaSuvWrenZsyd6vV7rcEQOfv/9dwIDA5k8ebLWoQghRKlw6ZJ6olvTpuDqqtYOp6RkPHfZ0THn5Li4CQhQk+LmzdUTBY8cgQYNYOBA6NBBHRUXZZckyLlkZGTEwIED2bZtG+8V1VkFIs9iY2N54YUXqF27NiNHjtQ6HCGEKLGuX1dnnmjTBhwc1NHhhAR1TuK0UeT0NcWBgVpHnD+1a6sn682eDX/9pZaKfPONWn4hyh4psciDAQMGcODAAaZOnYq7u7uh9EIUDw8ePKB79+7cu3ePHTt2ULFiRa1DEkKIEmXrVjUpjo2FvXvVUeI6deCDD9R5ht3dH7Z1dn5YpqB1TXFBSSsV6dhRPclw6FBYtUotJ3F11To6UZQkQc4DnU7HjBkziI6OZvDgwdSuXZsWLVpoHZb4z6BBg9i7dy+rV68ukllOhBCiNPj3X3X6s/nz1ZFTUEsmXnxRXeK5QYPs63GLS01xQXN2hs2bYd489TXw9obBg6FyZXX2jdLYZ5GRJMh5VK5cOVauXMnAgQNxcnLSOhyRzqhRo2jZsiVdu3bVOhQhhCjW/vkHwsLg55/VpFhRHi4OqijqSKqXFzRsqHWk2tHp1Hrk4GB44QV1CjuA8uXVkXNJkks3SZCfgK2tLWvWrAHUuXavXLlCjRo1NI6q7IqMjMTPzw9/f3/8/f21DkcIIYqNtGnVWrUCMzM1If75Zzh6VH3c1xcmTIAuXdRFPNq1U6c+Kw01xQXFyQk6d4Y9e9Q/HhISZGGRskBO0sunUaNG0aRJE2JiYrQOpUz69NNP8ff3Z+3atVqHUmpt2rSJunXr4ubmxpQpU7QOp9SIiIDJk9X/S2J7Ufxt2aImuePHqzM1+PnBp5+Cvb06Gnr2LBw8qCbI9evD00+rI6MffywjpI9q3Vo9ITFthD0iQk7eK+1kBDmfBg4cyJIlS2jTpg1btmyhdu3aWodUZnz00UdMmDCBl19+mZCQEK3DybP79+8zbdo0zp8/z/fff090dDSnTp2iU6dOWodmoNfrGTZsGFu2bMHR0RF/f39CQkIKrcb7yJwIrq8Jp1K3QLwHP/63s1bt9Xr15KXk5IyX6EUR3N8Qjkm7QKp3DSAl5WG79P8fOQK/vBtBc3047xgH0vb9AFxd1e3q9eov3rTrej2cPg0HZkfQQh/O28aB1H89gFq1so/73Dk49O3D9o1HBfDUU2BikvlSrhxER6vxNEsJZ5xJIIN+CKBpU/Wr5LRLWnLwpK9lnlaIyOtqEiW5fQFu+8oV+PNP9fLHHxAVBU2JIJBwwgnEsXsA33yjJsjZCSCCAMKBQKD0vDb5bR8QAHumq5/5v8oF8v6vAQwfrs54ke18ySW0r0IlK+kVgH379tGhQwdMTU357bff8PHxKfR9lmWKovDBBx8wadIkXnnlFebNm4exsbHWYeX589azZ08aNWrEokWLOHr0KPfv3+fpp58mKiqq8ILMo4iICEJDQ/ntt98ADHNLv/vuu1m2z8/P3JE5EdR7rSUmpJCKEXGVfFAqWoMCCqj/p7tudDcep5uHMSKVVIyIsfZBb2GttvmvnaI8fJ7Jg3jc7j1s/3d5HxLKpWv/3yX1v/8tkuPx1D9sfxgfbuuss12OtiLx1Odh+0P4cBvrfLctTu2NjNRLRSXja/OPhQ+pVtaYGIOxCRn+NzEB08R4LP85DEoq6Iygvg8662ziiY9HOfSwra6+D2TX9r/2HD6s/lVhZAQ+Jaj9E2w7/WuT5O7DzVRr4m/BrXh48EBtZmQE1hXBxigexxsP36cHT/lgWb30vjZF1V4xMiLO3od//rXG0VGdHi5Tjlwc+6oo6l+6+fh6QFbSE3ni7+/Pzp07CQoK4tlnn+Wff/7BzMxM67BKrb179zJp0iQGDBjAnDlzMDIqmZVCp0+fZsWKFSxbtgwACwsLitvfq3FxcRlORnV0dGTPnj0Z2syZM4c5c+YAcPXq1Sfe1/U14RijRwfoSCXlejznr2c+6Ov++8dJiceIVEN7o9vxXL5vjU6njujowHAdHVRNyNi+QlI8iWbWGP3XJu3/tIvVrXiM9A/bVzWLx7rKf9s3etgu7XnGF+Mxuv+wvUOFeGo6p4sn3XN0F+Ixuvaw7VOV4zF2sYZ0sae/nnwmHqPLD9u7V4vH1C37X4hJ/2RsX7dqPCaumf8YMFzOZYzHxSaexGrWpKZCqh70qRiup6aCxbWMr415QjyX9Nak6EGf8t8fMenUJB7L/177VCWVmKh4LptaU+6/EWyTchiuW92Kx1552PZeXDxmFtaYlMsiCQE1aUxV2yupqeji4x+fLKR9N56aqt7Wqn0u26YqkPAAks7FY53utYk7Hs951D9MrG2genWwsQZLK/Vzyfl4lBtqeyNSsUyOhxz+UCqJr40W7XWp6s/3AwdrYmPVHNXF5ZHPZ3Hta1KSOpIso8iPp5RijRo1KtL9xcTEKL///nuR7rMs0ev1hus7d+5UUlNTNYwms7x+3gICApT79+8rDRo0UBRFUf755x/F39+/MEJ7YqtWrVIGDBhguL1o0SJl2LBh2bbPz8/c4e92KfcoryRhrNyjvLJ/1i4lMVFRkpMVRa9XlEff7kfbH/5uV562r2n7XbuUFLPySorOWEkxK68ou3LednFrn1NfU1MV5d49Rbl0SVFOnVKUvXsVZVKnjO2H+O5SBgxQlC5dFKVlS0Xx9FSUatUUpVw5RWlKxrZN2aWAohgZKUrlyori4aE+p1s3RXn9dUX5uGPG9r+8u0s5fVpRbt3K/Jl50tdGKV9eUYyN1f8Lsv0jsdzauEvZuVNR5s1TlLffVpSQEEWpW1dRTEzUP2UefW3ebLZLOXxY/fko8tgLu31xiiWb9qmpijJokPrefPRRKeprDoo6r9KSlFgUkq+++oqLFy8yZcqUYvH1f0l36tQpevbsyZdffkmbNm20DidLef28bdmyhU8++YTjx4/Tvn17/vrrLxYsWEBgMTp1vChLLKDk1CAXSPviVnOYx/Z56WtEBLwbGEGzZLV+c3J4QJa7UBR1doCPO6ptd5oE0vq9AGxt4epVuHYt8//XrkET5WGd7e50dbMmJmBnB5UqPbzo9XBro1qf/adxIC3fCcDXFywtwcpK/T/9dQsLOPp93j8H19aEU75DIFWeC+DGDbhxA27eJMP1kyfh5oYIWiqZYzc1VRfoqFv34SU5GX4c9vjXMdOLX4w+NyW6LjeL9qmp0K8fLF4MU6fCW2894faLW1+zUZZKLCRBLiSjRo1i5syZBAcHs2TJEipVqqRJHKXBihUrGDhwIGZmZqxevbpYJZDpPcnn7fr16+zevRtFUWjatCn2OZ09o4GUlBSeeuoptm3bhoODA/7+/ixduhRPT88s25elg6fIm8LKFXbuhKAgNXk0MYGPPoIqVdRlkrO6xMTAnTtP3g8rK3U/2UlJyd32LSzU7dy+rd7W6eCZZ2DYMDUZdnZWl3B+lJxrVfykpMBLL8HKlTBzJowYoXVEhacsHeOlBrmQzJgxAy8vL4YNG0b9+vVZtGhRsR35LK4SExMZO3Yss2fP5umnn2b58uWlYnGWAwcOZLhdvXp1AM6fP8/58+dpWIxm5jcxMWHWrFkEBwej1+vp379/tsmxEDnJy4preWnbvLk66pyX5LttW7UUs1w5WLIEnnoK7t5VL3fuZLy+aZO6bUVRk1gvL3W6tOxERsLu3Q/bd+sGffuCra06mm1np143M8sYi6kpvP/+4+MvrSvXlWQmJvDjj5CYCCNHqufBDRqkdVQiv2QEuZAdOHCA3r17c/r0aU6fPk3NmjU1jackWbhwIf369eONN95gypQplCtXTuuQcpTbz1vr1q0BSEhIIDIykvr166MoCocPH8bPz4+IEjwRbXH4mRPicfI6mp0+iX3cBABP0l5GhEuHxER4/nn1j6qFC6FPH60jKnhl6RgvI8iFrGHDhhw4cIDt27cbkuMzZ87g6uqqcWTFU2JiIsePH6dBgwb06dMHV1dXWrRooXVYBWrHjh0AdO3alQMHDuDt7Q3A0aNHCQ0N1TAyIcqGvI5mb9uW+yT2SdpLYlw6mJnBmjXQqZNal3zunFomI3/8lEySIBcBCwsLw+IPf/zxB61bt2bw4MF8+umn2Nraahxd8bF9+3ZGjhzJxYsXOXv2LNbW1qUuOU7v1KlThuQYwMvLixMnTmgYkRAiK3lNYiXpLbvKl4dfflFXJfzgA3UKODMzWZmwJCqZE8iWYA0aNGDUqFHMmTOHevXqMXfuXFJSUrQOS1Nnzpyha9eutG3blnv37rF48WKsc5rTsZTw8fFh4MCBhIeHEx4ezqBBg2SRGSGEKOEqVIAuXdTrqakPpx4WJYskyEXMysqKL7/8ksjISGrXrs2gQYNo2bJlsVsgoqjExMTg4eHB5s2bmTRpEidOnODZZ5/VOqwiMX/+fDw9PZkxYwYzZszAw8OD+fPnax2WEEKIfOrQQT1ZD9QTNkvxl6GllpRYaKRBgwb89ddfhIWFER8fj06nIyUlhc2bN9OhQ4cSuzpcbly5coU//viDHj164OzszOeff063bt2oUaOG1qEVKXNzc8aMGcOYMWO0DkUIIUQBCghQZ1f58ktYvRq2blVnXBElhyTIGtLpdHRJ+x4GWLduHV27dqVu3bqMHTuWPn36YJ72J2gpcPz4cWbPns38+fNRFIW2bdtiZ2fHiNI8aWQOXFxc0OkyL5575swZDaIRQghRkAICYNUqeOUVdX7uli1BZnstOUrvMGUJ1LlzZ5YtW0aFChUYPHgwNWvW5M033+T+/ftah5Yvhw8fpnXr1nh6ejJv3jx69erFoUOHsLOz0zo0TUVGRrJv3z727dvHn3/+yciRI3n55Ze1DksIIUQBmj1bXfzlpZfgyhWtoxG5JQlyMWJiYkKvXr2IjIxk27ZtNG/enI0bN1K+fHkA/vzzTy5fvqxxlI+n1+sJDw9n7969AFhbW3P+/HmmTJlCbGwsP/zwA0899ZTGUWqvUqVKhouDgwOjR4/m119/1TosIYQQBcjSUl1l79YtdW7k1FStIxK5ISUWxZBOp6NNmza0adOG5ORkdDodiYmJPPfcc9y8eZOmTZvy3HPPERISgru7e5Zf0xe1+Ph4tm3bxubNm1m3bh0XL16kW7durF69mlq1avHPP/8UiziLk/Qr6qWmphIZGVnmZzQRQojSyNtbXYZ68GCYMgXee0/riMTjaD6CvGrVKjw9PTEyMspxdZZNmzZRt25d3NzcmDJlShFGqK201eNMTU35/fff+fjjj0lJSeHdd9/F09PTsLBEYmIihw4dIjk5uUjiunTpEn/88Yfhdps2bejWrRtLly6lSZMmLF++nIULFxoel+Q4s7Fjxxou7777LgcOHGDlypVahyWEEKIQDBwIL76ozo/8559aRyMeR/MRZC8vL9auXctrr72WbRu9Xs+wYcPYsmULjo6O+Pv7ExISgoeHRxFGqi2dToe3tzfe3t68//77xMbGsmnTJho1agTA3r17admyJeXKlaNevXqGtr1796ZmzZokJSVhZGSEiUnu3nJFUbhz5w6WlpYYGRmxdetWfv31V6Kjo4mKiiIuLo7y5ctz+/ZtTExM+PTTT7GwsKBp06bFfkno4mLevHmZVlQ8e/asRtEIIYQoTDodfPst7NunJspRUWBvr3VUIjuajyC7u7tTt27dHNvs3bsXNzc3XF1dMTU1pVevXoSFhRVRhMWTo6MjAwcOpEGDBoD6Oi5ZsoQ33ngDJycn/vzzT959910uXLgAqCP1ZmZmVK5cGRcXF7y9vQkICOCff/4BYPny5fj5+eHt7Y2DgwPm5uZYW1tz9epVAP766y/mzJnDhQsXaNWqFdOnT2fr1q2GkeHg4GBatGghyXEedO/ePVf3CSGEKB0qVlTrka9eVWe3kHrk4kvzEeTciIuLw8nJyXDb0dGRPXv2ZNl2zpw5zJkzB8CQ3JUF9vb29O7dm969exvui4+PN5zg5+npyXvvvceNGze4e/cud+7c4e7du5iamgJQvnx5qlatiqmpKZUqVcLe3p7KlStjZmYGwLhx4/jwww+lVKIAnDx5kmPHjhEfH8/atWsN99++fZuEhAQNIxNCCFHYGjRQ50cePhymTYO33tI6IpGVIkmQ27Vrl+XsC5MmTeK5554r0H0NHjyYwYMHA+Dn51eg2y5p0i/X7Ovri6+vb7Ztn3vuuRzfi7REWeTfqVOnWL9+Pbdu3WLdunWG+62srPj+++8LZZ+hoaF8//33VK5cGYBPP/2Ujh07AjB58mTmzZuHsbExM2fOJDg4GFDr/keNGoVer2fgwIGMGzeuUGITQoiyZuhQdfnp995TFxAJCNA6IvGoIkmQt27dmq/nOzg4GEoFAGJjY3FwcMhvWEJoIu2PkYiICAKK8Kg4ZswY3nzzzQz3HT9+nOXLl3Ps2DEuXrxIu3bt+PvvvwHKfN2/EEIUFp0Ovv8e9u+HXr3g4EEo40sDFDslosTC39+f6Ohozp49i4ODA8uXL2fp0qVahyXEE5k6dSpvv/02S5cuZdmyZZkenzlzZpHFEhYWRq9evTAzM8PFxQU3NzfD/NVpdf+Aoe5fEmQhhCgYNjawYgU0awb9+8NPP6mJsygeND9J76effsLR0ZGIiAieffZZw9e7Fy9eNHwFbGJiwqxZswgODsbd3Z0XXngBT09PLcMW4om5u7sDaglQo0aNMl0Ky6xZs/Dx8aF///7cvHkTyLq+Py4uLtv7szJnzhz8/Pzw8/MrU3X/QgiRX/7+MHUqhIVB584QEaF1RCKN5iPIzz//PM8//3ym+2vUqMGGDRsMtzt27GhImIUoyTp37gzAK6+8UqDbzanWf8iQIXzwwQfodDo++OADxo4dyw8//FAg+5W6fyGElpKTk4mNjS2xJzkHBsLGjer127fV6d+0Pu3H3NwcR0fHMj0zleYJshBlTefOnXOcDeSXX355ou3mttZ/0KBBdOrUCci5vl/q/oUQJUFsbCxWVlY4OzuXyJmWLl2C9IuoVqkCNWpoF4+iKFy/fp3Y2FhcXFy0C0RjkiALUcQePVGuKFy6dInq1asDalmTl5cXACEhIfTu3Zs33niDixcvEh0dTePGjVEURer+hRAlQkJCQolNjgGsrMDI6OGcyElJ2saj0+moVKlSmS+ZkwRZiCLWqlUrw/WkpCROnjyJTqejbt26hnmpC9rbb79NVFQUOp0OZ2dnvvvuO0CdH/uFF17Aw8MDExMTZs+ejbGxMYCh7l+v19O/f3+p+xdCFFslNTkGsLSEp56CO3fg7l24dg0qV4YKFbSLqSS/ngVFEmQhNPLrr7/y+uuvU7t2bRRF4ezZs3z33Xc888wzBb6vxYsXZ/vY+PHjGT9+fKb7pe5fCCGKhqWleklJgWPHICYG3N3VkWWhDUmQhdDI2LFj2bFjB25ubgCcPn2aZ599tlASZCGEEIXH2NgYb29vUlJScHFxYfHixdjY2OR5Oz/+uIBduyIZPHgWFy+Co2PBxypyR/42EUIjVlZWhuQYwNXVFSsrKw0jEkII8STKly9PVFQUR48exc7OjtmzZz/xtkxNwd4eLl+Ge/cKMEiRJ5IgC6ERPz8/OnbsyIIFC1i4cCGdO3fG39+ftWvXsnbtWq3DE0KIUisiAiZPLpx5hwMCAgzzxp8+fZoOHTrQqFEjWrRowcmTJwFYt24dTZo0oUGDBrRr144rV65k2Iajo5oonz378OQ9UbSkxEIIjSQkJFC1alV+//13ACpXrsyDBw9Yt24dOp2Orl27ahyhEEKULKNHq/MI5yQ+Hg4fVhNPIyPw8QFr6+zb+/rC9Om5279er2fbtm0MGDAAUOeJ//bbb6lTpw579uxh6NChbN++nebNm7N79250Oh1z585l6tSpTJs2zbAdExOoVQuio5FSC41IgiyERubPn691CEIIUebExz8clU1NVW/nlCDnxoMHD/D19SUuLg53d3eCgoK4e/cuu3btokePHoZ2iYmJgDp3c8+ePbl06RJJSUlZzjdsba3OZnH5srostaVl/mIUeSMJshAaOXv2LF9//TUxMTGkpJsl/kkXChFCiLIuNyO9ERHQtq0637CpKSxZAgEB+dtvWg3y/fv3CQ4OZvbs2fTr1w8bGxuishjSHjFiBG+88QYhISGEh4cTGhqa5XYdHdUEPiYGPDxkVouiJAmyEBrp0qULAwYMoHPnzhjJUU8IIYpEQABs2wbh4eoyz/lNjtOzsLBg5syZdOnShaFDh+Li4sKqVavo0aMHiqJw+PBh6tevT3x8vGF10oULF2a7PWNjcHaGv/+GuDhwciq4WEXOJEEWQiPm5uaMHDlS6zCEEKLMCQgo2MQ4vQYNGuDj48OyZctYsmQJQ4YM4ZNPPiE5OZlevXpRv359QkND6dGjB7a2trRp04azZ89mu72KFdVSiytX1FILmeyoaOgURVG0DqKw+Pn5ERkZqXUYoozI6+dt6dKlREdH0759e8zMzAz3N2zYsDDCKxLyMyeEKGonTpzA3d1d6zAKlV4Px4+r1z081JHlwpbV61qWjvEygiyERo4cOcLixYvZvn27ocRCp9Oxfft2jSMTQghRnKSVWpw6pZZa1KypdUSlnyTIQmhk1apVnDlzBlNTU61DEUIIUcxZWUGVKvDvv2BrK6UWhU3ODBJCI15eXty6dUvrMIQQQpQQDg5gZgZnzqjzI9+9q3VEpZeMIAuhkVu3blGvXj38/f0NNcg6nY6wsDCNIxNCCFEcGRtD1apw/ryaIF++DE89JXMkFwYZQRZCIxMnTuSnn37ivffe44033sDf359//vknX9tctWoVnp6eGBkZZTqRYvLkybi5uVG3bl1+++03w/2bNm2ibt26uLm5MWXKFMP9Z8+epUmTJri5udGzZ0+SkpLyFZsQQoj80+sfXk9NhTt3tIulNJMEWQiNtGrViooVK7J+/Xr69evH9u3bef311/O1TS8vL9auXUvLli0z3H/8+HGWL1/OsWPH2LRpE0OHDkWv16PX6xk2bBgbN27k+PHjLFu2jOP/nSr9zjvvMGbMGP755x9sbW2ZN29evmITQgiRf1ZWGRcMKV9eu1hKM0mQhShif//9NxMnTqRevXqMGDGCmjVroigKO3bsYMSIEfnatru7O3Xr1s10f1hYGL169cLMzAwXFxfc3NzYu3cve/fuxc3NDVdXV0xNTenVqxdhYWEoisL27dvp3r07AK+88go///xzvmITQojSyrIIahyefvrp//alllVUrQo6nTo/cumdsFc7kiALUcTq1avH9u3bWb9+PTt37mTEiBEYF/KklnFxcTilW4LJ0dGRuLi4bO+/fv06NjY2mJiYZLhfCCGENnbt2mW4bmmprqpXq5ZaYnH5cu63k5KSUgjRlT6SIAtRxNauXUv16tVp3bo1gwYNYtu2beRlvZ527drh5eWV6aLVyX1z5szBz88PPz8/rl69qkkMQgiRJxERMHmy+n8BCg8Pp1WrVjz33HO4uroybtw4lixZQuPGjfH29ub06dMArFu3jiZNmtCgQQPatWvHlStXALh69SpBQUF4enoycOBAatWqxbVr14CHo9Th4eEEBgbSvXt3mjevx8cfv0RsrMLdu/DRRx/h7++Pl5cXgwcPNvxuCQwMZPTo0fj5+TFp0iRcXFxITk4G4Pbt2xluC5XMYiFEEevSpQtdunTh3r17hIWFMX36dP7991+GDBnC888/T/v27XN8/tatW/O8TwcHBy5cuGC4HRsbi4ODA0CW91eqVIlbt26RkpKCiYlJhvaPGjx4MIMHDwbUVZaEEEIzo0dDVFTObeLj4fBh9Qw3IyPw8QFr6+zb+/rC9Om5DuHQoUOcOHECOzs7XF1dGThwIHv37mXGjBl8/fXXTJ8+nebNm7N79250Oh1z585l6tSpTJs2jYkTJ9KmTRveffddNm3alO25HwcPHuTYsWPUqFGDp59uxvHjf2Fm1pzXXx/Ohx9+CECfPn1Yv349nTt3BiApKclw8nZMTAy//vorXbp0Yfny5XTt2pVy5crluo9lgYwgC6GRChUq0Lt3b9atW0dsbCwNGjTgs88+K5R9hYSEsHz5chITEzl79izR0dE0btwYf39/oqOjOXv2LElJSSxfvpyQkBB0Oh2tW7dm9erVACxcuJDnnnuuUGITQogiFR+vJseg/h8fX6Cb9/f3p3r16piZmVG7dm3DoIe3tzcxMTGAOhgRHByMt7c3n3/+OceOHQNg586d9OrVC4AOHTpga2ub5T4aN26Mo6MjRkZGNGjgS0pKDMnJsHLlDpo0aYK3tzfbt283bBegZ8+ehusDBw5k/vz5AMyfP59XX321QF+D0kDzEeRVq1YRGhrKiRMn2Lt3b7YjUM7OzlhZWWFsbIyJiUmZWQtclA22trYZRmKf1E8//cSIESO4evUqzz77LL6+vvz22294enrywgsv4OHhgYmJCbNnzzbUPc+aNYvg4GD0ej39+/fH09MTgM8++4xevXrx/vvv06BBAwYMGJDvfgohRKHKzUhvRAS0bQtJSWBqCkuWQEBAgYWQNq89gJGRkeG2kZGRof53xIgRvPHGG4SEhBAeHk5oaOgT78PY2Bhj4xQqVUpgwoShbN0aSYMGToSGhpKQkGBoV6FCBcP1Zs2aERMTQ3h4OHq9Hi8vryfpaqmmeYKcNi3Va6+99ti2O3bswN7evgiiEqJkev7553n++eezfGz8+PGMHz8+0/0dO3akY8eOme53dXVl7969BR6jEEJoKiAAtm2D8HAIDCzQ5Di34uPjDWVrCxcuNNzfrFkzVq5cyTvvvMPmzZu5efNmrrdpbZ2ATgf379tz9epdVq9ebZiJKCt9+/ald+/efPDBB0/ekVJM8xKL7KalEkIIIYQoFAEB8O67miTHAKGhofTo0YNGjRplGPibMGECmzdvxsvLi1WrVlGtWjWsrKxytU1bWxsGDRpEr15etG8fjJ+ff47tX3rpJW7evMmLL76Yr76UVjolL6fPF6LAwEC++OKLbEssXFxcsLW1RafT8dprr+Xqq2g/Pz8pxRBFRj5v8hoIIYreiRMncHd31zqMApGYmGgoJY2IiGDIkCFEPe6kw0fEx0N0NFSurE4Dl53Vq1cTFhbG4sWLs3w8q9e1LB3ji6TEol27dlzOYpK+SZMm5frEn507d+Lg4MC///5LUFAQ9erVy7RaGKhTTs2ZMwdAppwSQgghRIlx/vx5XnjhBVJTUzE1NeX777/P8zasraFaNXVuZCsrsLPL3GbEiBFs3LiRDRs2FEDUpVORJMhPMi3Vo9JqdapUqcLzzz/P3r17s0yQZcopIYQQQpREderU4eDBg/neTo0a6gIi585BhQqQ7pw+AL7++ut876O007wGOTfu3bvHnTt3DNfT6nOEEEIIIYpJtWixYWQErq7q9TNnHs5ql1vyehaDBPmnn37C0dGRiIgInn32WYKDgwG4ePGi4cz6K1eu0Lx5c+rXr0/jxo159tln6dChg5ZhCyGEEKIYMDc35/r165LUPcLMTK1BvncPLl7M/fMUReH69euYm5sXXnAlgObTvGU3LVWNGjUMtTGurq4cOnSoqEMTQgghRDHn6OhIbGysnHeUjYQEOHoUYmLA0jJzuUVWzM3NcXR0LPTYijPNE2QhhBBCiCdVrlw5XFxctA6j2Nq+HTp2BEWB8uXVKaA1mt2uRNG8xEIIIYQQQhSOPXtAp1OvJyWp66OIx5MEWQghhBCilAoMVMsqjI3VlbUDA7WOqGSQEgshhBBCiFKqGKysXSIVm5X0CoO9vT3Ozs5ZPnb16lUqV65ctAEV0ziKQwzFJY78xBATE8O1a9cKOKKSJaefudwqDp+DolKW+gplq7/S19KprPe1LP2eK9UJck6Ky3KJxSGO4hBDcYmjOMRQ1pWl96As9RXKVn+lr6WT9LXskBpkIYQQQggh0pEEWQghhBBCiHTKbII8ePBgrUMAikccxSEGKB5xFIcYyrqy9B6Upb5C2eqv9LV0kr6WHWW2BlkIIYQQQoislNkRZCGEEEIIIbIiCbIQQgghhBDplJkEedWqVXh6emJkZJTjtCWbNm2ibt26uLm5MWXKlAKP48aNGwQFBVGnTh2CgoK4efNmlu2MjY3x9fXF19eXkJCQAtn34/qWmJhIz549cXNzo0mTJsTExBTIfvMax4IFC6hcubKh/3Pnzi3wGPr370+VKlXw8vLK8nFFURg5ciRubm74+Phw4MCBAo9BZFbYP3/FibOzM97e3vj6+uLn56d1OAUqq5+v3B77Spqs+hoaGoqDg4PhGLZhwwYNIyw4Fy5coHXr1nh4eODp6cmMGTOA0vneZtfX0vjeJiQk0LhxY+rXr4+npycTJkwA4OzZszRp0gQ3Nzd69uxJUlKSxpEWMaWMOH78uHLy5EmlVatWyr59+7Jsk5KSori6uiqnT59WEhMTFR8fH+XYsWMFGsdbb72lTJ48WVEURZk8ebLy9ttvZ9muQoUKBbrf3PRt9uzZymuvvaYoiqIsW7ZMeeGFFwo0htzGMX/+fGXYsGEFvu/0fv/9d2X//v2Kp6dnlo//+uuvSocOHZTU1FQlIiJCady4caHGI4rm5684qVWrlnL16lWtwygUWf185fbYV9Jk1dcJEyYon3/+uYZRFY6LFy8q+/fvVxRFUW7fvq3UqVNHOXbsWKl8b7Pra2l8b1NTU5U7d+4oiqIoSUlJSuPGjZWIiAilR48eyrJlyxRFUZTXXntN+d///qdlmEWuzIwgu7u7U7du3Rzb7N27Fzc3N1xdXTE1NaVXr16EhYUVaBxhYWG88sorALzyyiv8/PPPBbr97OSmb+lj6969O9u2bUMp4HM4i+I1zo2WLVtiZ2eX7eNhYWH07dsXnU5H06ZNuXXrFpcuXSrCCMue4vLZEPmX1c+XVse+wva4Y0lpUr16dRo2bAiAlZUV7u7uxMXFlcr3Nru+lkY6nQ5LS0sAkpOTSU5ORqfTsX37drp37w6Unvc1L8pMgpwbcXFxODk5GW47OjoW+A/ElStXqF69OgDVqlXjypUrWbZLSEjAz8+Ppk2bFsiHMjd9S9/GxMQEa2trrl+/nu995zUOgDVr1uDj40P37t25cOFCgcaQG0XxWRAZlbXXXKfT0b59exo1asScOXO0DqfQ5fbYV1rMmjULHx8f+vfvXypKDh4VExPDwYMHadKkSal/b9P3FUrne6vX6/H19aVKlSoEBQVRu3ZtbGxsMDExAUr/8TgrpSpBbteuHV5eXpkuRT0Klds4dDodOp0uy22cO3eOyMhIli5dyujRozl9+nRRhF4sdO7cmZiYGA4fPkxQUJBhZEKI0mTnzp0cOHCAjRs3Mnv2bP744w+tQyoyOR37SoMhQ4Zw+vRpoqKiqF69OmPHjtU6pAJ19+5dunXrxvTp06lYsWKGx0rbe/toX0vre2tsbExUVBSxsbHs3buXkydPah2S5ky0DqAgbd26NV/Pd3BwyDBaGRsbi4ODQ4HGUbVqVS5dukT16tW5dOkSVapUyTYWAFdXVwIDAzl48CC1a9fOcyzpt/e4vqW1cXR0JCUlhfj4eCpVqvTE+3zSONLvc+DAgbz99tsFGkNuFNRnQeReWXvN0/pWpUoVnn/+efbu3UvLli01jqrw5PbYVxpUrVrVcH3QoEF06tRJw2gKVnJyMt26deOll16ia9euQOl9b7Pra5rS9t4C2NjY0Lp1ayIiIrh16xYpKSmYmJiU+uNxVkrVCHJ++fv7Ex0dzdmzZ0lKSmL58uUFNoNEmpCQEBYuXAjAwoULee655zK1uXnzJomJiQBcu3aNv/76Cw8Pj3ztNzd9Sx/b6tWradOmTYGPBOQmjvS1vr/88gvu7u4FGkNuhISEsGjRIhRFYffu3VhbWxu+QhSFoyh+/oqLe/fucefOHcP1zZs3ZzujSmmRm2NfaZH+GPbTTz+VmvdWURQGDBiAu7s7b7zxhuH+0vjeZtfX0vjeXr16lVu3bgHw4MEDtmzZgru7O61bt2b16tVA6Xlf80TbcwSLztq1axUHBwfF1NRUqVKlitK+fXtFURQlLi5OeeaZZwztfv31V6VOnTqKq6ur8sknnxR4HNeuXVPatGmjuLm5KW3btlWuX7+uKIqi7Nu3TxkwYICiKIry119/KV5eXoqPj4/i5eWlzJ07t0D2nVXfPvjgAyUsLExRFEV58OCB0r17d6V27dqKv7+/cvr06QLZb17jGDdunOLh4aH4+PgogYGByokTJwo8hl69einVqlVTTExMFAcHB2Xu3LnKN998o3zzzTeKoqhn9Q4dOlRxdXVVvLy8sp35RBSswv75Ky5Onz6t+Pj4KD4+PoqHh0ep62tWP1/ZHftKuqz6+vLLLyteXl6Kt7e30rlzZ+XixYtah1kg/vzzTwVQvL29lfr16yv169dXfv3111L53mbX19L43h46dEjx9fVVvL29FU9PT2XixImKoqjHKX9/f6V27dpK9+7dlYSEBI0jLVqy1LQQQgghhBDpSImFEEIIIYQQ6UiCLIQQQgghRDqSIAshhBBCCJGOJMhCCCGEEEKkIwmyEEIIIYQQ6UiCXIYYGxvj6+uLl5cXnTt3Nsx7mFcLFixg+PDhBRucEEIUsUmTJuHp6YmPjw++vr7s2bOn0PYVGBhIZGRkoW1fCFGwJEEuQ8qXL09UVBRHjx7Fzs6O2bNnax2SEEJoIiIigvXr13PgwAEOHz7M1q1bcXJy0josIUQxIQlyGRUQEEBcXBwAp0+fpkOHDjRq1IgWLVoY1mBft24dTZo0oUGDBrRr144rV65oGbIQQhSYS5cuYW9vj5mZGQD29vbUqFGDjz76CH9/f7y8vBg8eDBpSwUEBgYyZswY/Pz8cHd3Z9++fXTt2pU6derw/vvvAxATE0O9evV46aWXcHd3p3v37ty/fz/Tvjdv3kxAQAANGzakR48e3L17t+g6LoTIFUmQyyC9Xs+2bdsMy/gOHjyYr7/+mv379/PFF18wdOhQAJo3b87u3bs5ePAgvXr1YurUqVqGLYQQBaZ9+/ZcuHCBp556iqFDh/L7778DMHz4cPbt28fRo0d58OAB69evNzzH1NSUyMhIXn/9dZ577jlmz57N0aNHWbBgAdevXwfg1KlTDB06lBMnTlCxYkX+97//ZdjvtWvX+OSTT9i6dSsHDhzAz8+PL7/8sug6LoTIFROtAxBF58GDB/j6+hIXF4e7uztBQUHcvXuXXbt20aNHD0O7xMREAGJjY+nZsyeXLl0iKSkJFxcXrUIXQogCZWlpyf79+/nzzz/ZsWMHPXv2ZMqUKVhZWTF16lTu37/PjRs38PT0pHPnzgCGQQVvb288PT2pXr06AK6urly4cAEbGxucnJxo1qwZAC+//DIzZ87kzTffNOx39+7dHD9+3NAmKSmJgICAouy6ECIXJEEuQ9JqkO/fv09wcDCzZ8+mX79+2NjYEBUVlan9iBEjeOONNwgJCSE8PJzQ0NAij1kIIQqLsbExgYGBBAYG4u3tzXfffcfhw4eJjIzEycmJ0NBQEhISDO3TyjGMjIwM19Nup6SkAKDT6TLs49HbiqIQFBTEsmXLCqtbQogCICUWZZCFhQUzZ85k2rRpWFhY4OLy//bOPa6n+4/jr1QqKsRyKcSkVEQibcmdud9vc90Mcxk2jM1mZgw/xhhjNhvmMsMwNswtNC0SFbmEQlGhUCRdzu+Pt74VXb7nezvnfL/v5+PxfVTfyznvvq/v53zf533elzrYvn07ADp4R0REAAAePXoEJycnAMCGDRsks5dhGEbXXLlyBTExMaq/z58/Dzc3NwCUj5yeno4dO3aI3u6tW7cQEhICANiyZQsCAgIKPd6iRQv8+++/uHbtGgDgyZMnuHr1qqb/BsMweoIdZBOlSZMmaNSoEbZu3YrNmzdj3bp18Pb2hqenJ/bs2QMAmDNnDvr374+mTZuiSpUqElvMMAyjO9LT0zFixAh4eHigUaNGiI6Oxpw5czB69Gh4eXmhU6dOaNasmejturm5YdWqVWjQoAFSU1Mxbty4Qo+/9tprWL9+PQYPHoxGjRrB399fVRjNMIx8MBPySnQZhmEYhtGYuLg4dOvWDRcuXJDaFIZhtIQjyAzDMAzDMAxTAI4gMwzDMAzDMEwBOILMMAzDMAzDMAVgB5lhGIZhGIZhCsAOMsMwDMMwDMMUgB1khmEYhmEYhikAO8gMwzAMwzAMUwB2kBmGYRiGYRimAOwgMwzDMAzDMEwB2EFmGIZhGIZhmAKwg8wwDMMwDMMwBWAHmWEYhmEYhmEKwA4ywzAMwzAMwxSAHWSGYRiGYRiGKQA7yAzDMIxkfPLJJ/j2229Fv6558+a4ePGi7g1iGIYBO8gMw+gIFxcX2NjYwNbWVnW7c+eO1GYZnILvQ7Vq1TBy5Eikp6dLbZbBSU1NhZmZGWJjYwvdP2nSJIwePRoAcO/ePWzcuBFjx44Vvf1p06Zh9uzZOrGVYRjmZdhBZhhGZ+zduxfp6emqW40aNQo9np2dLZFlhiXvfTh//jzOnTuHBQsWSG2SwTl//jxsbW3h4uJS6P6oqCg0btwYALB+/Xp06dIFNjY2orffo0cPHDt2DImJiTqwlmEYpjDsIDMMo1dcXFywaNEiNGrUCOXLl0d2djbu3LmDvn374rXXXkOdOnWwYsWKQq85d+4cfHx8YGdnh4EDB2LQoEH47LPPAABmZma4du2a6rkjR45UPQagxG27uLhgyZIlaNSoESpUqICBAwfi2bNnqsdv376NPn364LXXXkPlypUxceJEAMDixYvRt2/fQjZOmjQJkydPLvF/r1atGjp16oTz588Xur8kGxctWgQnJyfY2dnBzc0NR44cUdm+YMECeHh4oFKlSnjnnXcK2X7p0iW0bt0aFStWhKenJ/7880+1/+/i9lmaTiVx/vx5eHh4wMzMrND9Fy9eRJMmTQAA+/fvR6tWrQo9npaWBmdnZwQFBRW6Pz4+HmZmZnjw4AEAwNraGk2bNsXBgwfVtolhGEZd2EFmGEbvbN26FX/99RcePnyIMmXKoHv37vD29kZCQgKOHDmCb7/9VuXoPH/+HL169cKwYcOQkpKC/v37Y+fOnWrtJzc3t8RtA8Dvv/+OAwcOIDY2FpGRkVi/fj0AICcnB926dUPt2rURFxeHhIQEDBo0CAAwdOhQHDhwAA8fPgRAkfDffvsNw4cPL9Ge+Ph47N+/H/Xq1VPLxitXrmDlypU4c+YM0tLScPDgwUIR2M2bN+PgwYO4fv06rl69innz5gEAsrKy0L17d3Ts2BHJycn47rvvMGTIEFy5cqXU/7u4farzXpbEuXPn4OXlVei+pKQkPHjwAI0aNQJA0WQ3N7dCz/nmm2/g6emJ1q1bF7rfyckJ5cuXR1RUlOq+Bg0aICIiQi17GIZhxMAOMsMwOqNXr16oWLEiKlasiF69eqnunzRpEmrWrAkbGxucOXMG9+7dw+zZs1G2bFnUrVsXo0ePxm+//QYA+O+//5CVlYUpU6bA0tIS/fr1Q7NmzdTaf2nbzrOlRo0acHBwQPfu3VXR3dOnT+POnTtYvHgxypcvD2trawQEBAAAqlevjsDAQGzfvh0AcODAAVSpUgVNmzYt9n2ws7NDzZo14ejoiC+//FItG83NzZGZmYno6GhkZWXBxcUFr7/+uuq1EydORM2aNeHg4IBZs2Zh69atqvcsPT0dM2fORNmyZdG2bVt069ZN9XhJ/3dx+1TnvSyJ8+fPY+vWrahSpYrq5u7ujnr16sHW1hYA8PDhQ9jZ2alek5OTg9WrV+O9994DQDnKN27cAEBXDiwsLJCRkaF6vp2dneqkhWEYRpdYSG0AwzDGw+7du9G+fftX7q9Zs6bq95s3b+LOnTuoWLGi6r6cnBy0bNkSAF3Wd3JyKnRpvnbt2mrtv7RtA5T2kEe5cuVUhYS3b99G7dq1YWFR9GFxxIgRWL16NUaPHo1NmzZh2LBhxdqR9z4cP34cb7/9Nu7fv6+yqSQb69Wrh2+//RZz5szBxYsX0alTJyxdulSVy13wfaxdu7bK9jt37qBmzZooU6ZMoccTEhJK/b+L26c672VxZGZm4tKlS/j9998Lndx8//33uH79uurvSpUqIS0tTfX3hQsXkJycjE6dOgEAli5dCkEQsHDhQmRkZCAtLQ2Ojo6q56elpRWyj2EYRldwBJlhGL1T0NmtWbMm6tSpg4cPH6puaWlp+PvvvwFQtDYhIQGCIKhec+vWLdXv5cqVw9OnT1V/FyzSKm3bJVGzZk3cunWr2ELCXr16ITIyEhcuXMC+ffswZMiQUrfZqlUrjBw5EtOmTVPbxrfffhvBwcG4efMmzMzMMGPGDNVrb9++Xeg9yXOca9Sogdu3byM3N7fQ405OTqXaWNw+tXkvL1y4gNzcXHTo0AHOzs6qW0xMjCr/GAAaNWqEq1evqv5OSEhApUqVYG9vD4Ai9XkO8fHjx1GpUqVCr7906RK8vb3V+h8ZhmHEwA4ywzAGpXnz5rCzs8OiRYuQkZGBnJwcXLhwAWfOnAEA+Pv7w8LCAitWrEBWVhb++OMPnD59WvX6xo0bY8uWLcjJycGBAwdw/Phxtbddml3Vq1fHzJkz8eTJEzx79gz//vuv6nFra2v069cPb7/9Npo3b45atWqp9f9OmTIFhw4dUuXKlmTjlStXcPToUWRmZsLa2ho2NjaFosKrVq1CfHw8UlJSMH/+fAwcOBAA4Ofnh3LlyuF///sfsrKyEBQUhL1796pyqEuiuH2q816OHDkSI0eOfGWb586dg4eHhyqVIo8zZ86oOlgAQJcuXQrp5+DggMePHyM2NhZbt27F8+fPER0djYcPH2LOnDmYMmWK6v149uwZzp49iw4dOpQuAsMwjEjYQWYYxqCYm5tj3759OH/+POrUqYMqVargvffew6NHjwAAZcuWxR9//IH169fDwcEB27ZtQ58+fVSvX758Ofbu3YuKFSti8+bNhXKdS9t2aXbt3bsX165dQ61ateDs7Ixt27YVes6IESMQFRVVYnrFy7z22msYPnw45s6dW6qNmZmZmDlzJqpUqYJq1aohOTm5UIu4t99+Gx07dkTdunXx+uuvq7p3lC1bFnv37sX+/ftRpUoVjB8/Hhs3boS7u3up9hW3T3Xey9u3b+PNN998ZZvnz59/JW/83r17uHnzZiEHefjw4fj7779VecXNmjXDoEGD0LhxY6xbtw5//vknTp06BVdXV/j5+RWKpu/duxetW7d+pZUgwzCMLjATCl7HZBiGkSEjR46Es7OzqmuDVNy6dQvu7u5ITExUpQEYChcXF/z0009F5nhLwfPnz+Ht7Y3IyEhYWlpqvJ1PP/0Ujo6OmDJliqjX+fn5Yd26da90ymAYhtEFXKTHMAyjBrm5uVi6dCkGDRpkcOdYjpQtWxaXLl3Sejtff/21Rq8LDQ3Vet8MwzDFwQ4ywzBMKTx58gRVq1ZF7dq1ceDAAanNYRiGYfQMp1gwDMMwDMMwTAG4SI9hGIZhGIZhCmDUKRZlypSBjY2N1GYoHkEQCvWxZeSPUjWzEAS4vuhocMXGBrkK/B80Qal6icUqNxd1nz1Dmrk54q2spDZHK0xFM2OCNdOejIyMQv3WjRmjdpBtbGzw5MkTqc1QPLm5uYV6sTLyR7GaCQJQsyaQkADcvQtUqCC1RQZBsXqJIT4eaNGCtN24EXj7bakt0gqT0MzIYM20p3z58lKbYDD4k8KUysWLF6U2gRGJ4jSLigIiIgAzM2DqVLrPhMojFKeXWNLTga5dgcePSWeFO8eACWhmhLBmjBjYQWZK5cGDB1KbwIhEUZqdPw+0aQOMHElOsQleAlWUXprw00/AhQvA9u1AdjYQHS21RVpj9JoZIawZIwajTrFgGEbmhIRQZNHODtixg5zjUaOAfv0A7jVsPEyeDPj7A35+QMOGQP36wM6dUlvFMAxTLBxBZkrF29tbahMYkShCs717gXbtgMqVgePHgddfp/vt7ABnZ8CEcgUVoZcmHDsGxMbSiY+fX/79RpA+Y7SaGTGsGSMG0/kGYjQmLS1NahMYkcheM0Ggy+5eXsC//wIuLvmPnT4NzJ0LvOhmYQrIXi9NiI+nKwFjxhS+38zMKBxko9TMyGHNGDGwg8yUyo0bN6Q2gRGJbDUTBCA1lZykLVsowujoWPg5//0HfPEF8PSpNDZKgGz10pScHGDoUCAzE/j++8KPGYmDbHSamQCsGSMGdpAZhjEMT54AAwYA7dsDz54B5cvT7WVMsEjP6FiwgNJmvv8ecHUt/BjryzCMAuAiPaZUXApe/mYUgew0u3kT6NmT2rktWgSoMyTCQFHG69eBrVuByEgKfLq7k6nNmxtk9wAMq1dWFnDgAHDoEHDrFmBrC7zxBjBkiI7aTp8+DcyZQxscNuzVx5ctA4xggJPs1hhTKqwZIwbZRZDffZeuuHp55d83Zw7g5AQ0bky3v/+WyDgTxcHBQWoTGJHISrOTJ4FmzYC4OOCvv4Bp00qOIuY9pmcH+flzarns5gbMnk3teaOjgf/9j+rJAgOBU6f0aoIKQ+glCJTVUr8+0KMH8PPPwI0bFOidMAGoVYvu0/ptd3cnjb//vmid27ShgSEKR1ZrjFEL1owRg+wc5JEjKbrxMh9+SO1Sz58HunQxsFEmTnh4uNQmMCKRjWa5udTiy8EBCA0F3nqr9NcY4BJ8WhpleixdCrz3HnD7NnDlCnDpEnD/PrB8OTmPAQF07MnM1K89+tbr7l2gc2cK6laqBOzeTangkZH0v589CzRpQh32pk7VwkkWBGrPt3Bh8W36goOBsDBN/xXZIJs1xqgNa8aIQXYOcmAgfZcyDKNgUlNpelqZMtTf+L//KFSrDu+9Bzx8SO3f9EBWFqVQnDpFEdU1a+gKVR4VKgCTJpGzPG4c8O23QKtW1JRBiYSG0pW3EycoqBsWRv+/pWX+c3x8gKNH6f9etowi6qKJigJ8fYHLl0t+3qRJ1KWEYRhGxigmB3nlSmDjRjr+fvMNRUGKYu3atVi7di0AICsrC0FBQQCAunXrws7ODhEREQCAypUrw9PTEydOnAAAWFhYICAgAOHh4Xj8+DEAwNfXF0lJSbh9+zYAwNXVFVZWVrhw4QIAwNHREfXr10dwcDAAwMrKCv7+/ggLC0N6ejoAwM/PD/Hx8UhISAAAuLm5wdzcHNEvJklVq1YNderUQUhICADAxsYGfn5+CA0NRcaLNlf+/v6IjY1FYmIiAMDDwwM5OTm4cuUKAMDJyQnOzs4IDQ0FANja2sLX1xchISHIfBH6CggIwNWrV5GcnAwA8PLyQmZmJmJiYgAANWvWRNWqVRH2IrJjb28PHx8fBAcHIyMjA0FBQQgMDMTFixdV04i8vb2Rlpamqgx2cXGBg4OD6iy9UqVK8Pb2xvHjxyEIAszMzNCqVStEREQgNTUVAODj44OUlBTExcWxTlrqlJ2dDQAIDAyEIAiqz76hdbKLjobnV1/B+q23EP7BB6TTrVvq6/TiPdaXTnv3BuDYMQvMnHkJ1asnITm5aJ3Ong1F//5A7drO+OqremjU6Dm+/PICGjZ8rDOd8tZTRkYGUlNTda7T5cue+PDDKnBweIbVq6Pg42MDwBNBQUWvp169gIcP38S8eZawsLiAVq3uq7ee/PyQPngwyiYk4MyVK/CpXbtYnZqmp8MsLQ2WmZmKWU9FHffyjot83JO3TgXXU/ny5VXHRdZJM51MCTNBkF+/nbg4oFs3mkwKAElJQJUqdOX188/pcuHPP5e+nfLly+PJkyd6tZVhmBfk5lJuwowZFJLdtk2zSreQEOCPPyiMaWenUxP//psG940b92r3sZKIjqao661bdOwZMkSnZukcQaD0kenTKZ/6zz+B115T77VZWVS0FxtLQeHq1dV40fr1wDvvAL/+Su3dSqJpU9rovn3qGcQwjGwwJb9KdikWRVG1KmBuTldrR4+mImnGcBw/flxqExiRGFyzhASgY0fgo4/IAw0P17wNxPnzwJIl1BZOh6SnA2PHUgHw0qXiXuvhQVki/v7k/82eTecDukKXemVnU9HdtGlA376UOqGucwxQ6sWvv9LbP3asGi9ISwM++YTeHHXOHIykDzIfF5UHa2YAxHZaWLAAqFePUvAOHjSwsSWjCAf57t3833ftKvy+M/pHhhcZmFIwuGa5uZR7unYtRX+Ly4FSBz0V6c2bR3nEa9YA1tbiX1+5MvDPP3T8/+orYPBg3Q3705Ve6ekU6V69Gvj4Ywria9JRzd2d3q+9e4H9+0t58po1QGIiXT1QRzsj6YPMx0XlwZoZADGdFqKjgd9+Ay5epNeMH0+9NmWC7HKQBw8GgoKoktzZGfjyS/r7/Hk6rrq4AD/8IK2NpoaZkXyhmRIG0SwlhRzijz8GatakhsLq9DdWFx1+mcXEUO3CyJHAm29qvp2yZWlCtrs7ZZLExQF79gDVqmlnny70io8HunentIg1a9SM/pbABx/Qsfajj6jjR8GivkJMmQJ4e1MrP3VYtYreSIXDx0XlwZoZgMBAOjCqw549wKBB9L1Rpw5Fkk+fpqtRMkCWOci6wpRyZRjGoOzbRx5YcjLlHjRtqrtt//AD8P77lLZRo4ZONjlsGLBzJ7Vu09aZzWP3bsooqFyZIq3e3rrZriacPUvOcXo6RY07d9bNdvfupZ7Jq1ZRcOcVsrJK8JwZhjE2rKys0LBhQ9XfY8aMwZgxYwo/6eVCsjlzqE7B3r5wp4WJE6knel7dwqhRdPDq188Q/0qpKCLFgpGWvIpdRjnoTbPkZDrj796d+jGePq1b5xjQ+SX4y5epndvEibpzjgGgVy+agZKTQ/2Stak500avP/4AWrakoOypU7pzjgH6jgsIAL7+uohe0BERQO3aVFQphsOHaTqJwuHjovJgzbTHwsICYWFhqtsrznFRjBtHVxjPn6cC3alT9W6nLmAHmSmVvJY3jHLQi2aCQN7Xrl2UhJs3XULXjB5NXqda7RNKZ+5cysOdPl0nmyuEjw+dI+RNp1u2TLPMEE30ysrKL8Rr1Ij6Heu6PsPMjII/CQnAunUvPTh7NiVhN2ggbqOzZtEgEYXDx0XlwZpJRHGdFpycaFJRHvHxhZvSSww7yAzDlMzNm8CzZ+QtffcdRQE++0x/eaRmZnQg1UEkOa8GZNIkcZ0cxODkREM4evemfN1Ro4AXLVD1RmwsRY2/+YZSH4KC6DtIH7RtS3nbhaLIp09T77hp04CKFcVv1Hgz+xiGeZniOi306EEH6MxMOqjFxGje/UgPsIPMlIqPj4/UJjAi0Ylm2dkUEvX0pFY8ADXIFRsxFEtwMOUg6yDas3Qpdaz46CMd2FUC5csD27fTecOGDfSWFexkVBrq6pWTQ5P9GjakSX/bt1N+sCZdOdTFzIz+r4QEym8GQGHlKlXozEOTDRqBg8zHReXBmhmAwYOpyO7KFeq0sG4dFXI3bEiXuo4do+8VgA6UAwZQH8233qKDmbm5tPYXgIv0mFKJi4uDi4uL1GYwItBas5MnqZluVBS15Fm9GqhVS2f2lchPP9FluFu3qDuGhiQnk8nvvEPmG4rQUGoFlzdc5Ouv6fhfEqXpJQjUIvSTT/K7JBlSEkGgoI+lJXBuyyWYeXoA8+cDn34qfmP+/jQA5p9/dG+oAeHjovJgzbTHlPwqjiAzpRKnbssWRjZopdmiRdSq59EjqgDbt89wnhigsyK9NWvoyt2UKTrZnNr4+dGclHnzaEhHw4bAwIF0zlFcOKI4vZ4/p6htQAClfz98SFckpZDko4+oLu/YXXfg0CEqvNF0Y0YAHxeVB2vGiEF2fZAZhpGA7GwquLKzo0tdjx5RMVX58tLZpMXFrcxMGiXdpQsNaDI0Vlb09o0dC/zvf8CPPwK//w64ulIDkI4daaDUy3nDubnUIensWUrR2LePesLXrQusXEmBdalaCA8ZQgHjpcvM0HZfe8039OOPsrqMyjAMUxTsIDOlUrduXalNYEQiSrNTpyidomFDYONGaugrZVPfvAijFg7y1q1AUhINb5KSKlXIQf7iC7Jpxw5ydPNGXVeoQN3yLCzewLNn5AznTeerWJEc/CFD6JyljMTX+6ytgR1us3Dqr2xcubwQbu4aRoI9PXVrmETwcVF5sGaMGNhBZkrFzs5OahMYkail2c2bNA5u2zZqxdC9u/4NUwdLS6BcOY1fLghUyOblBbRrpzuztKF8eeC99+iWlgaEhQGRkcC1a5Q28fAhOdMODlQD2agRddCT1QyOBw8QEPYtYs36Y80PZqo6G9Hs3UsR5LxxswqFj4vKgzVjxMBFekypBAUFoXXr1lKbwYigVM127aJq4zJlqMJ4+nRp0yl0yKlT1Jbshx8AdXrYywFFrLGvvwZmzcK0ty5g3X+eSEjQ8DwmIIDC0YcP69xEQ6IIzZhCsGbaY0p+FRfpMYypkJMD3LtHv7doAbz9NrXimTPHaJxjgBxjOzv69xgdkZNDVY/t2qH7TE88fEg51RpjvHEZhmGMBHaQmVKpXLmy1CYwInlFs+PHgWbNgD59yDmpXh34+Wet2qjpjZMngaFDqU+bSFJTyXEbMgSwtdWDbXpC9mts3z6aeDVhAgIDKQ1E49Z5RtLFQvaaMa/AmjFiYAeZKRVPIymqMSVUml29SrOIW7emCrDx4yW1Sy1u3AA2bwY0uIz366809E8pqRV5yH6NuboCkycD3bvDzIzmuJw+Te3sNMIIIsiy14x5BdaMEQM7yEypnDhxQmoTGJGcOHECOHCAJlQcPAjMnUvpFIMHKyeCJ9KJEgRKr2jWjArclITs15iHB1U+WlBd9/DhlH+sURRZKZ+/UpC9ZswrsGaMGNhBZhhj4vFjmuYA0LCPadOA69eBzz8HbGyktU1dNHSgTp2i6XVjx+rYHlNn2zZqzFyAihXpXGvLFmqZLYqNG4FfftGZeQzDMPqAHWSmVCwsuBug7MnMBJYvB15/HejXDxZmZhTiW7jw1WkUSkFkBDmvOG/gQD3Zo0dku8YyMiifYsmSVx4aNw54+pTSWkTh4gLUrq0T86REtpoxxcKaMWJgB5kplYCAAKlNYIojNxfYtAlwd6eZyt7ewG+/IaBVK6kt0xwbG3LqRUzGSEmh4ryhQ5VVnJeHbNfY7t3UpHn06FceatqUbmvXijyX2bFDyxYY8kC2mjHFwpoxYmAHmSmVcI0rcRi9s28fMGwYUKkS8M8/1Fu2aVNla9a/P5CYCNSpo/ZLfv2VguhKTa+QrV4bNgC1alGRZxGMGQNERQH//Sdim6tW0U3hyFYzplhYM0YM7CAzpfL48WOpTWAKEhREXR4AoFs3YM8eGs3WoYPqKaakWV5xXvPm0k7I1gZZ6nXnDnDoEJ2AFRPNHzyYIvZr14rcthF0sZClZkyJsGaMGNhBZhilEBICtG8PtGlDucW5ueS49OghKh1B9hw/DvTsCSQkqPX04GDg0iXlRo9ly4ULgL09tawohryBLNu2USaGWhhJFwuGYYwbI/pWZfSFr6+v1CaYNtHRFCl+4w26nv3tt8CZMyU6xYrWLCEB+PNPtfsgr11LfpwSi/PykKVeHTsCSUlA/folPm3sWKrl27RJxLaNIIIsS82YEmHNGDGwg8yUSlJSktQmmCa5ufTz4UOKHi9cSEM0Jk8GrK1LfKlRaKaGE5WSAmzfTpPzlDwtW3Z6PX1K73/ZsqU+1ceHivV++EFNv9dIIsiy04wpFdaMEQM7yEyp3L59W2oTTIurV8njmziR/n7jDRrzO2OG2l6gojUT4UBt2qTs4rw8ZKfXjBlA48ZATo5aTx87ljIy1CrW++03YOdOrcyTA7LTjCkV1owRAzvIDCMXbtwARo2iqWW7dwNVquQ/Vq6cZGZJRinhSEGg9IpmzZRbnCdLMjNpAkiDBoC5uVovGTSIivV++EGNJ7/2GuDoqJ2NDMMweoYdZKZUXF1dpTbB+NmwgXI9N28GPviAnOW5czXenKI1s7OjgSeWliU+LSQEuHiRWo0pHVnp9ddflLsyYoTaL7Gzo4se27YBqamlPHnzZqOYpCcrzRi1YM0YMbCDzJSKlZWV1CYYJzExwOXL9HtgIDBhAjnGy5ZpPf1O0Zp16wZcu0ZOcgn8+CNFLQcNMpBdekRWem3YAFSrVqhtoDqMHQs8e6ZGsd6GDSSewpGVZoxasGaMGGTnIL/7Ll198/LKvy8lhY7Vrq70s9QIBaNTLly4ILUJxsWVK9Rb1t0dmDmT7qtTh0ZF16ihk10Yu2YPH1K08u23lTk572Vko9e9e8Dff9NIQpFjeZs0AXx91ZysZwRdLGSjGaM2rBkjBtk5yCNHAgcOFL5v4UKgXTsKuLVrR38zjOK4dIk8ugYNgD/+AD76SM2kTRPj+HGgbVsgLq7Yp2zZQq3FjCG9QlbY2wNbt2pc9ZhXrBcSUsKTjKSLBcMwRSAmyikIwKRJQL16QKNGgMwmHcrOQQ4MBBwcCt+3Z09+OtyIEVS/xBgORy6o0Q2//079fadPB2JjgcWLtU6lKA5Fa5acDBw7Vmwf5LzJeXntxYwB2ehlZQX060dfWBowaBDlI5c6Wc8IIsiy0YxRG9bMAIiJcu7fT/fFxNBBY9w4g5tbEuKuoUlEUhJQvTr9Xq0a/V0ca9euxdoXR+esrCwEBQUBAOrWrQs7OztEREQAACpXrgxPT0+cOHECAGBhYYGAgACEh4erxlH6+voiKSlJ1RrG1dUVVlZWqss0jo6OqF+/PoKDgwFQfpO/vz/CwsKQnp4OAPDz80N8fDwSXkwFc3Nzg7m5OaKjo1/8P9VQp04dhLwIudjY2MDPzw+hoaHIyMgAAPj7+yM2NhaJiYkAAA8PD+Tk5ODKlSsAACcnJzg7OyM0NBQAYGtrC19fX4SEhCAzMxMAEBAQgKtXryI5ORkA4OXlhczMTMTExAAAatasiapVqyIsLAwAYG9vDx8fHwQHByM7OxvJyckIDAzExYsX8eDBAwCAt7c30tLScOPGDQCAi4sLHBwcVPPuK1WqBG9vbxw/fhyCIMDMzAytWrVCREQEUl+cQfr4+CAlJQVxL6KFxqRTQ0FAuaVLcb1ZM9wPDETNHj1Q4913EXr9OhAdDdtbt3SuEwAEBgYiOztb9dlXmk5XLl6EJ4Dz586hsafnKzr99dc9REbWwocfXsXdu3aKXE95OhVcT9WrV5dUp+yoKLx24gRe++ILJGVlabye2rRxxbZtNTBx4g2kp9M2Cq6nRqmpsMnMRJnMTEXqlLeekpOTkZycLPv1ZArfTyXpVHA9VatWTXVcZJ0006lUAgNfvfq3Zw/w4n3HiBFA69bAokV0//DhdFWpRQvKnbt7N9/hkxpBhsTGCoKnZ/7fFSoUfrxiRfW2U65cOV2ZZNIcO3ZMahOURXi4IPTuLQiAINjbC8IPPxjcBEVrtn07vXeRkUU+/N57glCunCA8emRgu/SILPSaOlUQLC0F4d49rTYTHk7yrVhRzBPS0uimcGShGSMK1kx7ypYtKzRt2lR1+6Go77eSnLjc3Py/u3YVhJMn8x9r21YQzpzRg9WaoYgIctWq+ScVd+9yC01GxkyYAHz/PVChAvDFFzT1rlIlqa1SFiXkqKalUYrs4MGULsvoiOxsaj/RtWvh/tsa0KQJ9ab+4QeadfOKnMZQVckwJoqFhYUqkq8RZmaKqUOQXQ5yUfToQZ2BAPrZs6e09pga3BqnBAQBOHSIRvMCQMuWwPz5dIlpzhzJnGNFa1axIk1xK2Kc9tatlJo8erTBrdIrkut18CDlronofVwSY8ZQj+oii/V+/hlYsUIn+5ESyTVjRMOaSURelBMoHOV0cqIpsXnEx9N9MsFMEORVLTF4MKWq3L9P7+mXXwK9egEDBgC3bgG1a1Ot08uFfEVRvnx5PCmm0IdhtCI3l6pFv/4aOHsWWL0aeP99qa0yenx9gaws4Px5xQQhlMGAAcDRo8CdO0DZslpvLj2dOhb27p0f3FDRtSsVYp45o/V+GIYxLGr5VXFx1M8+r63e9OlA5crU1nThQupq8b//0VCilSuptWRoKHW0OH1ap/Y+efIE1tbWMFdzKmhBZBdB3rqVTjCysuhkYtQoel+PHKFCx8OH1XOOGd2h1eUUY0MQgF9/pRY2ffsCjx4BP/1ErW1khDFqFhZG5yJjxhifcyypXnkxkhEjdOIcA5RFMWQIBTOK7Fsvr7iMRhjjGjN2WDMDMHgw4O9P/f6dnYF168gxPnSI2rwdPpzf/79LF6BuXeqaM3o0pSdqSW5uLrZs2YKuXbvC0dER7u7uqF69Ojw8PDB9+nRcu3ZN7W0pIgeZkZa8SlqTJjcXKPPifHLNGhqisHUrtcQSOVDBEChas6Agijhs2gS4uanuXrWKHK9hw6QzTV9IqpeZGXmyOnZax46lpfLrrxQYKrQ/I0DRa8xEYc0MwNatRd9/5Mir95mZ0YFdh7Rp0wbt27fHggUL4OXlhTIvvrdTUlJw7NgxzJgxA71798bQoUNL3Zb8vtkZRk6kpVG10erVwKlTlPezezdd1igjuwswxsHDhxQuftGeCAAePAB++w145x0uztM5d+5QPoSOHdfGjalYb+1a4IMPXtq8EUSQGYaRH4cPH4alpeUr9zs4OKBv377o27cvsrKy1NoWf8MzpeLn5ye1CYYnJYUS4GvXpmhmnTrkuAHAa6/J3jk2Cs0KOFE//ww8ewaMHy+hPXpEMr0uXaLLoNu26WXzY8dSsd6pUwXuNJIIslGsMRODNTN+8pzjSZMmoWPHjujUqRM+/vhjnD9//pXnlIa8v+UZWRAfHy+1CYYlNZUc4jlzqCtFSAjlTRW43C93FK1ZngP1wkHOyaEAfmBg4emlxoRkev3yC2BuDrRpo5fNDxxIk/UKTVTfvVvnhThSoOg1ZqKwZqZDXs7x5MmT4ejoiKFDh2LlypWitsEOMlMqedN7jJpr1/K/xStVAubOBSIiaNJPixbS2qYBitbspQjjgQM0mXvCBInsMQCS6JWdTQnCXbrorbm8rS0wdCilOKekvLjT3JxuCkfRa8xEYc1Mh/fffx8dOnRAly5dMG3aNISFheGHQmfqpcM5yIxpc/YsjbzcuROwsgL69KEUismTpbbMdKlcmSL35csDoBqO6tWpZRijQw4eBBITKbFbj4wZQ1cANm4EpkwBVe49eADMmqXX/TIMw6xZswbXrl1DWloa7EUWsHAEmSkVNwWlFqjN1atA+/bUWPfgQeDjj4EbN8g5NgIUrdmbbwInTgBubrh+nSLIY8YAaqaNKRJJ9NqwgT7vXbvqdTeNG1PXp5UrKV0GBw4A27frdZ+GQNFrzERhzUyPLl26oEGDBoiPj8cnn3wi6rXsIDOlokmDbVmSnU0V+wBNa4uLo2blt28DCxYA1apJaZ1OMRbNVq+mq/FjxkhtiX6RRK9Vq8hRNcCZx+TJwPXrNA8AgFF0sTCWNWZKsGamQ//+/XHp0iXUqlULo0aNwt69ezFL5FUrdpCZUomOjpbaBO3IyKAG5G5u1LdYECjn8upV6lBhhH3DFK1ZUBDg7o6M01H4+WdKrahRQ2qj9Isker32GtCqlUF21acPTZBdvhxG08VC0WvMRGHNTIdhw4Zh4MCBaNiwIUaOHIkBAwaoeiKrCzvIjPGSmgrMm0et2iZMIIdg+vT8x2Xeqs1kefIEuHIFB/c8Q2qqcRfnSYIgUN7x/v0G26WlJel45Ajw+DGMIoLMMIx86dGjByIjI7F582a0bdsW3bp1w8GDB0Vtg4v0mFKpptTUgy1bgM8/Bzp3BmbMoD5hRhK9Kg3FalaA37YKaNyYZDN2DKpXSAiwfj3wxhuG2ycoTWbuXOBKnBWaOVgZdN/6wBjWmKnBmhk/giDArMD3fKNGjdCoUaMSn1McpYbQDh06hNGjR6uaLK9du1akuYzSqVOnjtQmqEd0NEXGfv6Z/n7nHWrV9vffdCnZRJxjQEGaFcULnWJjBXz0kWnIZlC9Vq+mtKK33zbcPkHNSYYOBVrd/Q0PDpwx6L71gaLXmInCmhk/bdq0wXfffYdbt24Vuv/58+c4evQoRowYgQ0bNqi1rVId5J9//hmLFy/Gpk2bcPTo0ULTSBjTICQkRGoTSubff4EePQBPT5oIdu8e3V+uHPDSmaOpIHvNSuKFR1ylMg2aMAUMptf9+9SUePhwVRs9QzJpEpUE/PSTwXetcxS9xkwU1sz4OXDgAMzNzTF48GDUqFEDHh4eqFOnDlxdXbF161ZMmTIFI0eOVGtbpaZY2NnZoWLFiliyZAlmzpyJM2eUf+bPGBHjxlFf1cqVafLdhAlAlSpSW8VowbXHr+EKuqDHsAooW1Zqa4yM9euB58+B99+XZPcNGwIrXFfAYn4CsqcuggUn+TEMo0Osra0xfvx4jB8/HllZWbh//z5sbGxQsWJF0dsqNYLctUCPzIULF2L48OGid8IoGxsbG6lNyCczk77kHzygv3v2BFasAG7eBL74gp3jF8hKM5EsPOSL/jZ/od9n7lKbYjAMpletWsB779HVFono+9pJBKbtU3wrZCWvMVOFNTN+rly5AuFFEbClpSWqV6+ukXMMAGaCUHo58cu5HMVRsWJF0ZNK9En58uXx5MkTqc1gdMHDhxQpXrECuHsX+O47YOJEqa1idExyMvlw77xDqbKM8SH064/rey9igGc0zp41jRxzhjEW5O5XNWzYEDdv3kT9+vXRqFEjNGzYUPXT0dFR1LbUusA1YsQImJmZoSRf2szMDCNHjuQIsxESGhoKPz8/aXaemwtMmwb8+COQng506EAR5A4dpLFHIUiqmRasXg34ZR7Hil1DgFG7adKhCWAQvXbuBDp1Amxt9bufUjArY4bKlYFz56jtW/v2kpqjMUpdY6YMa2b8REVFITMzE5GRkejSpQvKly+Pffv24eLFiwCAxMREtbelloN87NgxzSxljIKMjAzD7zQ2FqhTh3oVx8YCvXoBU6fS3FqmVCTRTEsyMmi42/t+mbAMTaB0GhNB73pFRtKQnEWLaKy6xFSwF1BNoEGWSnWQlbjGTB3WzDSwsrJCs2bNYGtri++++051f2pqqqjtaDQp4cmTJ8jJydHkpQxTPLm51JKtbVugXj3gxg26f+dO4Ndf2Tk2cn75hRqQ9OvP19x1ztKl1LXivfektgSoWBFlKjtgyhTg0CGKJDMMw+ial3sdV6pUSdTr1XKQc3NzsWXLFnTt2hWOjo5wc3NDtWrV4OHhgenTp+PatWuidsooC39/f/3uIDOTehc3bAh07UojoBctyi+444l3otG7ZjomKwtYvBjw96ePAQCTmramV73u3KGhOe++Czg46G8/6rJ2LfDvvxg7FrCzA5YskdogzVDaGmNYM1NgwoQJWLduHc6dO1diWrA6qOV5tGnTBtevX8eCBQuQmJiI+Ph43Lt3D8HBwWjRogVmzJiBTZs2aWUII19iY2P1s+G8D29KCrVrs7SkSPGNG5R3LKOCT6WhN830xG+/AXFxwCefUI6qqaFXvVauBHJygClT9LcPDahYERg7llqXx8VJbY14lLbGGNbMFPD29sb58+cxZcoUpKWlwcPDA/3798cXX3yBbdu2idqWWl0ssrKyYGlpqfVzDI3cqy2VQlBQEFq3bq27DcbGAt9+C1y/DuzbR/dFRwMNGnBJu47QuWZ6JDeXosbm5sD580CZi1HA/PnU19rdNFq96VWv3r3pzd2xQz/bF8s33wDXrgGrVyM+Hqhbl86Ply+X2jBxKGmNMQRrpj1K86vi4+MRFRWFyMhIREVFiQrmqlWkp47jKzfnmJEhYWF0PXX7dkqbePttGlpQtizg4SG1dYxE/PknnR9t3vwim6ZhQwopM7ph1y5ATl9oZ8/SsQCAszMwZAg1qZk1CxDZhYlhGKZEnJ2d4ezsjM6dO4t+rajkzkmTJqFjx47o1KkTPv74Yx47bSJ46MJ53bYNaNYM2L+f0idiY4ENG8Cj0vSDTjQzAIIALFhAUcQBA6S2Rjr0oldaGuUfA5KMlS6RAhcuZ86kMoSlSyW0RwOUssaYfFgzA+HiQoGOxo3zW3WmpFB7VldX+imyo4QuEKu/KAc5ryhv8uTJcHR0xNChQ7Fy5UpRO2SUh0YdS549A9atA/bsob+7dAGWLQNu36YCPGdn3RrJFEIpXWaOHQNOn6bOY6qxw8ePAxUqAP/+K6lthkQvei1fDrz+er6TLBdeSqNycwMGDaJU6fv3JbJJA5Syxph8WDMDcuwY5cy9uFqEhQuBdu2AmBj6uXChXnZ78eJFREREFPlYTEyMqG2JcpDff/99dOjQAV26dMG0adMQFhaGH374QdQOGeVx5coV9Z+ckkL5oy4u1FIq71K5nR0VCXHhnUEQpZmEzJ8PVKsGjBhR4M6cHODxYyA7WzK7DI3O9Xr0iEKyHTsCNWrodtu64KXSl1mzgKdPqTRBKShljTH5sGYSsmdP/oF+xAhg92697apz586YMWMGnj17Vuj+l9u+lYZG/bPWrFmDadOmYfLkyQYdLV1U1J6REd9+C9SsCXz2GdCkCXD4MLWXYpgiOH4cOHoUmD4dsLYu8EDeQcyE2rzpnOXL6RLmnDlSW/Iq1arRPPECeHgA/fvTJHkJrrwyDKMm2dnZ8PX1Vd3Wrl376pPMzOjkvGlTausIAElJQPXq9Hu1avS3HvD09ERUVBQSExPh5eWFQ4cOabwttYr0XqZLly44dOgQ/vjjD3zyySca71wTjh3Lb4/LGAYnJ6fiHzxzhnKKKlakSFX//jTxTtXMlpGCEjWTCV98QcfJceNeesAEO5noVK+kJGoq3acPnajKjW++KfLuzz4Dfv+dfHs5+vUvo4Q1xhSGNdMeCwsLhOWlTRRHcDDg5AQkJ1O+8cvdiMzM9Hqcr1y5MjZs2IBDhw5h3LhxeOONN7Bs2TLR2xEVQe7fvz8uXbqEWrVqYdSoUdi7dy9mzZoleqeMsnB+OV84J4cujwQGAs2bUwk6QFVW69ezcywDXtFMZhw7RhHkTz4BbGyKeZIJRZB1qtehQzR5RU85fvqiYUPy6b/9ljJE5I7c1xjzKqyZgcg7EXF0pDaTp08DVasCd+/S/XfvGqRlTYcOHRAVFYWqVavC09MTubm5ol4vKoI8bNgwDBw4EIIgoGnTpkhPT0cZA045y4vam5lRg/kxY159ztq1a1Uh/6ysLAQFBQEA6tatCzs7O1XyduXKleHp6YkTJ04AoLOigIAAhIeH4/HjxwAAX19fJCUl4fbt2wAAV1dXWFlZ4cKFCwAAR0dH1K9fH8HBwQBo/re/vz/CwsKQnp4OAPDz80N8fDwSEhIAAG5ubjA3N0d0dDQAoFq1aqhTpw5CQkIAADY2NvDz80NoaKhqbry/vz9iY2ORmJgIgIolc3JyVPlUTk5OcHZ2RmhoKADA1tYWvr6+CAkJQWZmJgAgICAAV69eRXJyMgDAy8sLmZmZqqT1mjVromrVqqozQ3t7e/j4+CA4OBgPHz6Era0tAlu2ROLnn6PShg2wuXMHOTVr4vHnn+OCpydygoLg4uICBwcHhIeHA6Cxjt7e3jh+/DgEQYCZmRlatWqFiIgI1Ux0Hx8fpKSkIO7FpADWSXOdsl/k7AYGBiIoKAg2LzxPb29vpKWl4caL0d1S63Tr1m1MntwYVavaoU+fVAQFFdbp7K1bqNWlCxITE9EEMGqdLl68iAcPHiA9PR1vvvmmbnQKCEDC1q3ISkhAXSsr2a2nWlu2oHJiIqy3b39Fp169ovDHHw3x4YexWL26hux0KrieIiMjYWtrK/l64uNeyToVXE/Xr1+Hubk566SFTqXy5Ak1t7ezo9//+QeYPRvo0YM6V82cST979ix9WzrAxsYGixcvxuDBgzF69GhRr1VrUEjehyePiIgIREREIDc3F126dIGjo+Mrz9EHCQmFo/bffUdBzOJQWkNruXJy3z607NaN/ujUicI7U6fSmaGFRlk6jJ6Rc0P8w4dp/a5aBYwfL7U18kBnel2+LP/hKsOHAydPUqvHIujVCwgKooGacpiMXRxyXmNM0bBm2lOqX3XjBvkGABVav/02VeE+eEBXmW/dAmrXpnwqAy/w3NxcUUFdtbybNm3aoG/fvujZsydq1aoFb29veHt74/nz5wgODsaGDRvQpk0bjBw5UlO71aKoqH1JDjKjJeHhwLJleGP7duDqVSqs2bkTsLWV2jKmFGxlqpEgUDChZk1g1CiprZEPOtHr4EHgrbdo8kr37tpvT1+UEkiZNw9o1Aj43//knSUi1zXGFA9rZgDq1gWKarNWuTJw5Ijh7SmA2IwHtZ594MABmJubY/DgwahRowY8PDxQt25duLq6YuvWrZgyZYreneMnT6jvfd7v//wDeHnpdZemSW4usHcv0KYNVaDu3g3zcePyB3rwAUYR+Mq0zcvBg0BICAUUrKyKedLJkzRST+KDqSHRWq9nz4CJE6lgtmNH3RilT0q4cOnlRdP1VqzIT1mUI3JdY0zxsGaMGNRykK2trTF+/Hj8+++/uHnzJo4cOYLw8HDcvHkTP/74I5oYoFI6KQkICAC8vakurGtXCpYwOubuXaqUuX6dxkLHxyNkwABqN8AohrxcNDmRmwt8+im1a3znnVKeLAgmVaSntV4LFwLXrgHff1/CmYdMMDMrVds5c6jOcN48w5ikCXJcY0zJsGaMGNRKsbhy5Qrq168PMzMzWFpaonpeLzsDUlzUntGSu3cpGfT6dWDrVspjOXGCGk1bWgKAKkGfUQ5y1Oy334Bz54BNm0qZMG6CfZC10ismhuZ1Dx4MtG+vO6P0Re3a1Pi4BF5/HRg9mlqoTp1Kx3+5Icc1xpQMa2a63L17Fw4ODrASEUBQK4Lcr18/VKhQAb6+vnj33XexbNkyHDlyRFVxyiiQiAhg5Ej6svr6ayAzE3j+nB7z91c5xwyjCzIzKa2icWPy40rEBPsga8WFC8Brr9HkPCXw5ZfA/v2lPu3zz+kwpISeyAzDyJthw4bB3d0d06ZNU/s1anWxAOjMKzIyEl26dMGgQYMQHR2NixcvAoCqbYjc4C4WxbB1K1WWli8PvPsuMGkSUK9esU/Pzs6GBXerUBRy02z5cpo0fvCgGimy//5L+VRqPdk40Fqv589LCcsrkxkzaOZJZKT8ak7ktsaY0mHNtEfJfpUgCIiOjoanp6daz1fbQc6jTp06iC3Qnic1NRWVKlUSZ6WBULKQOiUjg65rV68OdOsGPHxI1y5HjwbU0C46OhoepVwSZeSFnDR79IgumTduTDMsSg0Qx8ZShdbYsfJvWaYjNNLr5k2atjJsmLKi7vPmAf/9B+zbV+pTU1Los+PvD/z9twFsE4Gc1hijHqyZ9ijNr3ry5Amsra1V/a/FIHrKx8u9juXqHDOgysYvvqD2bGPGUN9BgMZCf/yxWs4xAE6lUSBy0mzxYmqBuWiRmn5cnTrAsmUm4xwDGuiVm0tXfyZMoHWuJGJjgfPn1XqqgwOlWuzfTxcU5ISc1hijHqyZ8ZObm4stW7aga9eucHR0hLu7O6pXrw4PDw9Mnz4d165dU3tbajnIEyZMwLp163Du3DmIDDgzUjF/PjnGX30FvPEGdd7fsEFqqxgT484dSo0dNIi6BqpFTg71cnwxIYspgjVrgKNHgW++UV6HGTW6WBRkwgQq0ps2jT4aDMMwxdGmTRtcv34dCxYsQGJiIm7fvo3k5GQEBwejRYsWmDFjBjZt2qTWttRKsVi7di2ioqIQGRmJixcvwtHREZ6envDw8ICHhwcGDhyo9T+lD5R2KUArBIGuX7doAdjbA1u2AMHBlPhZv75Wm75//z6qVKmiGzsZgyAXzUaMoO4Vly6J6ETw3390TX3/fpPp5ShKr6tXgSZNKE/7wAFlpVcAlNr19980GlVNdu4E+vXLzwyTA3JZY4z6sGbaI3e/KisrC5alNBlQ5zmAmhHkMWPG4LvvvsPx48dx//59/PPPP3j33XdRrlw57FMjj4zRI8+eAT//DDRsSGOgN26k+99+m3qiaukcA9waR4nIQbPQUPo4fvSRhm26TOhqldp65eRQON7aGli3TnnOcR4ite3Th84HPvssf2CU1MhhjTHiYM2MnzzHd/v27Uh7cbD46quv0KdPH4SHhxd6Tmmo5SDfunWr0C03Nxeenp4YPHgw5s+fr7r/8ePHmvw/jCbk5gJz51KbtlGjAHNzSqHQQ3glJiZG59tk9IvUmuXmApMn09X/Tz8V+WIT7IOstl7m5lRX8OuvgLOzfo3SF66uNO1JBGZmlKqTnEy57HJA6jXGiIc1Mx2++uor2NnZITg4GEeOHMGoUaMwbtw4UdtQq9/JiBEjirw/r2BPEASYmZlh5MiRGD58uCgDGJEkJQFVq9Io3qAgGujx0UdA27bKjSYxRseWLRRB/uUXwM5O5Iv5c1w06ek06r1nT6kt0Y6PP9boZc2a0Qjqb74B3nuPJjIyDMMURV7Xir/++gtjxoxB165d8dlnn4nahloO8rFjx8Rbx+gOQaCCnKVLgcOHqQq8Rg3K0TTAWNmaNWvqfR+MbpFSs/R06l/r6wtodb5sQhHkUvW6eZOirkuXkpdooixcCOzaBXz4If2UEj4uKg/WzHRwcnLC2LFj8c8//2DGjBnIzMxEbm6uqG2IbvPGGJDMTEqbaNyYRsiGhVESno0NPW4A5xgAqlatapD9MLpDSs0WLaLuFcuX04UO0Tg5UW+vEobXGBsl6pWZSeMHMzIAPz/DGaUv5swBWrbU6KXOzvTR2L2b6hOlhI+LyoM1Mx1+//13dOrUCf/88w8qVqyIlJQULF68WNQ22EGWI3mRs7t3qddpbi4V4t28Sd8OBu49HRYWZtD9MdojlWbXrlHf48GDqbugRjg5UX69m5tObZMzxeolCMDEiUBICBXlGcNJQ2IideLQkI8+otrjDz6gcwep4OOi8mDNTAcbGxs8efIEW7duBUCdKypWrChqG+wgy4mrV4Hx44EBA+hvFxcgPJzmrL7zDlWuM4xMyfPlypYFlizRYkNZWeREPXumM9sUy+rVwE8/UaVj//5SW6MbRPZBfpmyZYHvvqOTsW++0aFdDMMYDePHj8d///2ncpDt7OwwYcIEUdtgB1lqBIGK7Xr0oIjZunVAhQr5HfG9vSUvWrK3t5d0/4x4pNBsxw6adjZvHqXIa0xkJI1FP3RIZ7bJnWL1SkujY8NXXxnWIH2ig+NZx47U+m3ePODWLR3YpAF8XFQerJnpEBoailWrVsH6RWCxUqVKeP78uahtaOUg3717l/sKasvatUCbNnQJdfZsOtr/9BO1c5IJPj4+UpvAiMTQmj1+TDNpmjShiyA6wYSK9F7RK+9/nzGDqtE0SuaWMTrQdulS+vnhh1pvSiP4uKg8WDPTwdLSEjk5Oapua/fu3UMZkcdRrY66w4YNg7u7O6ZNm6bNZkyL1FSqYsobsJI3HurWLeDLL6mFm8wIDg6W2gRGJIbW7IsvKGV+zRrAQq3eOCVggn2QC+n15AnQoQN1rgGMzzn28gLatdN6M7VrU0nGH38Ae/bowC6R8HFRebBmpsOkSZPQu3dvJCcnY9asWQgICMCnIpvya/VVdvjwYQiCgOjoaG02Yxpcu0Zl/T//DDx9SlMUunUDKleWz+zUYsjOzpbaBEYkhtTs/HlgxQpg7FjR8x+KxgT7IKv0EgSqNzh2DDDWwMP48Tq7zDBtGrB1K22udWvKTjMUfFxUHqyZ6TBkyBA0bdoUR44cgSAI2L17Nxo0aCBqGxo5yE+ePIG1tTXMzc1hZmYGT09PTTZjOkydCixbRqG1IUPommCjRlJbxTBak50NjBkDVKkCfP21jjduQhFkFQsWANu3A//7H/DWW1JbI3ssLSkjrUUL4JNPgO+/l9oihmHkgru7O9zd3TV+vVrX7nJzc7FlyxZ07doVjo6OcHd3R7Vq1eDh4YHp06fj2rVrGhtglGRlAb/9RhMTAMDHh6rQb96k0WIKc44DAwOlNoERiaE0W7YMOHOGugrorPugkxM5iCZ04h0YGAjs3Ut9zt9+23ijxwDlRXh56WxzzZvTBbnVq4F//9XZZkuFj4vKgzUzEAcOUNOBevVouo8ECIKATZs2Ye7cuQCAW7du4fTp06K2YSYIpYdpWrVqhfbt26Nnz57w8vJSJTqnpKTg2LFj2LJlC3r37o2hQ4dq8G/oj/Lly+PJkyeG2+HDhxTOWLECuH2bOlK8+67h9q8noqKi0LBhQ6nNYERgCM2uXqUmK507Azt3mmRmhM6IiopCwxUrqK1jcHD+MCBj5IMPgM2bgZQUnW0yPZ18bhsbSvkxxAwlPi4qD9ZMe0r1q3JyqFH5oUM02adZM8qD8vAwnJEAxo0bhzJlyuDo0aO4dOkSUlNT0bFjR5w5c0btbaiVYnH48GFYWloWuu/+/fuoXLky+vbti759+yIrK0uc9cZEVhYwfTo5xOnp1JXi+++BLl2ktkwnPHjwQGoTGJHoW7PcXGDUKHJIVq3SsXOcmUknmNWqAba2OtywfHnw4AEV6z56ZNzOMaB1H+SisLWlCHKXLpSlMmeOTjdfJHxcVB5GqZkgyCs6cfo0RY7r1qW/Bw2iKloDO8ihoaEIDw9HkyZNAOixzdvZs2fRunVr9OnTB+fOnYOXlxe8vLxQtWpVHHgx7/NlB9qksLQEIiKAXr2As2ep+rxbN+OrPmeYF3z/PQU6ly2jlsU65coVwNUV+OcfHW9YhuTkAJMmwTohgb7kRE56UiR6+jLv3JmyU77+mlppM4xRk5hIrWHd3anzjYHIzs6Gr6+v6rZ27drCT0hIAGrWzP/b2ZnuMzC6aPOmVgR54sSJ+Prrr/Ho0SO0bdsW+/fvR4sWLXD58mUMHjwYb3ExCXD4sKx6F+sSb29vqU1gRKJPzWJjgZkzqYZs+HC97cY0ivQ+/RT47js0NIYR0mLQk7bLlwNHjtDn8vRpmrqnL/i4qDyMRrP794E6dehqW/fulK5UvrxBdm1hYaGIkd0vt3nbsWMH5s2bJ2obajnI2dnZ6NixIwBg9uzZaNGiBQBoVR1odBipcwwAaWlpqKSzCizGEOhLs9xc6kpYpgzwww96CgaaSh/kLVuoGHHcODzo1QuG+XqTAU2a0GQZPVClCvDjjzR88Msvgfnz9bIbAHxcVCKK1Sw3l8aUhoVRkWuVKnT5rm1byveVE05OlCKXR3w83WdABEFAYGCg1m3e1Io3FwxL27yUH2cmp9wXRi/cuHFDahMYkehLs+++owjdkiVArVp62YW88un0xdmzlMQdGAh8+61prbGRI6mbj57o3p1aSS9cCPz3n952Y1qaGQmK0ywjg2oTPD0pwf7HH/PTKd5/X37OMUBFeTExdKnx+XPq6NWjh0FNMDMzQ5cuXeDu7o4JEyZg4sSJop1jQE0HOSIiAvb29rCzs0NkZCTs7e1Vf0dFRYneKcMwyuPiRZp83K2bgWbbGHME+auvgNdeo57H+swDMFG+/ZZSH0eMoLlMDKM4jh6lKMTYsUC5csCmTTRwzECpFBpjYQGsXAl06gQ0aAAMGCBJy04fHx9RHSuKQq02b3LhwAHqd5mTA7z3HuVBloTB27wZKXFxcXBxcZHaDEYEutbs+XPAz49qLaKi9DwRPSUF+P13Grf8+ut63JGEPH1Kb6arKwATW2Offgps3EiXXvXI0aM00fqDD6jzpq4xKc2MBNlrFhlJecXNmgFJScC4ceT0BAbK5sqaUvwqd3d3xMTEwMXFBeXLl4cgCDAzM0OkiAperUZNG5KcHGDChMKt9Xr0MHjnEJPEwcFBahMYkehas9mzqb/sn3/q2TkGAAcHunxojKxfD/TpA9jbq5xjwMTW2LNn1M5Oz7RtS87xd99R2kWHDrrdvklpZiTIUrPcXIr+LV1K+WsdOlAHn6pVgT/+kNo6xXLw4EGtt6GWg7x06dISH//oo4+0NqQ0ZNJazyQJDw9H69atpTaDEYEuNTtxgmrJRo8mR0PvPHsGXLoEuLjocDyfDPj1V0qOvXuX5iIXwKTWmB76IBfHwoXUYGj4cOrE6eiou22blGZGguw0276dog+XL1Mh28KFwJgxUltlFOzcufOV+ypUqICmTZuicePGam1DLQc5LS0NAHDlyhWcOXMGPV4kXO/duxfNmzdX01ztKKq1Xmjoq89bu3atqi9fVlYWgoKCAAB169aFnZ0dIiIiAACVK1eGp6cnTpw4AYBalwQEBCA8PByPX1RY+/r6IikpCbdfVGS6urrCysoKFy5cAAA4Ojqifv36CA4OBgBYWVnB398fYWFhSH8xZtrPzw/x8fFIeNEH0M3NDebm5oiOjgYAVKtWDXXq1EFISAgAKoL08/NDaGgoMjIyAAD+/v6IjY1FYmIiAMDDwwM5OTm4cuUKAMDJyQnOzs4IffGG2NrawtfXFyEhIcjMzAQABAQE4OrVq0hOTgYAeHl5ITMzEzExMQCAmjVromrVqqr2Lfb29vDx8UFwcDDS09MRFBSEwMBAXLx4UdVs3dvbG2lpaarCBxcXFzg4OCA8PBwANeb29vbG8ePHVZc3WrVqhYiICKSmpgKgPKGUlBTExcWxTlrqlJ2dDYDGqWZkZKg++9rodPt2Gt57zxd16lhi8uR4BAXF6l2n8G3b0HzkSFydOxf1P//cKHSqmpCABmPG4GGTJoho1gzCS+spPT0dqampJrGeXo+Ph5MgICsz0yA6ff31TQwYUAfdu6di714BWVni11NRx72846Kx6gTIdz2J0angesrJyVEdF6XSya1CBVhWqYIL16/D6eRJOJcpg7IbNyK4enUIFhawunxZ1jophbCwMISFhaH7i6jOvn370KhRI6xZswb9+/fHxx9/XPpGBBG0bNlSePz4servx48fCy1bthSzCY3Zvl0QRo3K/3vjRkGYMKHk15QrV06/RpkI58+fl9oERiS60Cw3VxD69BEECwtB+O8/HRilLtHRggAIwtatBtypHklOFoSaNQWhVi36vQhMao1NnSoIBj42r1pFH6lvvtHdNk1KMyNBUs0iIgRh5EhBKFtWENaupfuys+lAqyCU4le1bNlSSEtLU/2dlpYmBAYGCk+fPhUaNGig1jZE5SAnJSWhbIGK67JlyyIpKUmcW68hMmitZ7IYTXN1E0IXmq1aRSlwixdTgZ7BkEkxis6YNAlITgZOnaLOFUVgUmvMz8/grSXGjaP6lZkzgVatgKZNtd+mSWlmJBhcM0HIzy8+fJi6UYweTQnygFHPT5Ca5ORkWFlZqf62tLREUlISbGxsCt1fEqLm7g0fPhzNmzfHnDlzMGfOHPj5+WHkyJGijNYUGbTWM1mOHz8utQmMSLTV7OxZYOpUoGtXwAAlBkWjnAY7JbN4MbBtG+DjU+xTTGqN9e9Ps8oNiJkZsG4d1T0NGgS8yBrUCpPSzEgwmGa5ufm/z55NNRULF1Jkb+VK4+3OIyOGDBkCPz8/fPnll/jyyy/x5ptv4u2338aTJ0/goWbxmqgI8qxZs9C5c2ecPHkSAPDLL7+gSZMm4i3XgIKt9XJygHfflaS1nkkiGIujYkJoo9mjR9S60tER2LCBpuYZFGOJIN+6RcUSebcS4DWmfxwcaHhh69bUWnbzZu0+aqyZ8tC7ZklJdPK3YQMQHk4fuh07gBo1AEtL/e6bKcTnn3+Ozp07499//wUArFmzBr6+vgCAzZs3q7UNtRxk4UUCO0BJ6z5FREIKPkdfdOlCN8aw8LRE5aGpZoJAVwBv3gSOHwcqV9axYepQvTp1fHgx0l6RPHgAvPkmheDXrCn16Sa1xmbOpN5rEvRSbdkSmDsX+OwzwN+f2sBpiklpZiToTbOLF2n086ZN1Me4e3fg4UNykGvX1s8+mRIRBAGXL1/Go0ePMHv2bNy6dQunT58W1VhCrUEhrVu3Rt++fdGzZ0/UKjBf9vnz5wgODsaGDRvQpk0bg6VbqItSGlozjFz47jtKmV24kKbmMRogCJT/9c8/QEhIiakVJsmMGcDy5dTOTwJyc4FevYD9++kk8I03JDGDMRZu3aKWlNbWNLpxyhTAzU1qq/SGUvyqcePGoUyZMjh69CguXbqE1NRUdOzYUdR0PbUunh44cADm5uYYPHgwatSoAQ8PD9SpUweurq7YunUrpkyZIjvnmNEdeS1tGOWgiWYnTlC+cbduwPTpejBKXTIyyBgDFQDrnB9+APbtA5YsUds5Nqk1JnHktUwZGuRXqxalQ2v6MTMpzYwEnWiWmUkpFLNm0d+1atEVr1u3gNWrjdo5VhKhoaFYtWoVrK2tAVBbv+fPn4vahlopFtbW1hg/fjzGjx+PrKws3L9/HzY2NqhYsaJooxnlkdcTklEOYjWLjydnoW5dukpo8LzjgiQkUKuBX38Fhg6V0BANuHaNqhs7dQImTlT7ZSa3xiTO361YEdi5k9IsBg2iDhcWIufKmpxmRoBWmj14QOlSK1cCiYlA48bAF18AZcsCQ4bozEZGN1haWiInJ0eVVnPv3j2UEfnFJvpr0NLSEtWrV2fnmGGMhMxMoG9f6ry1axdQoYLUFr1AiUVQDx7QCOl16ySPlMoWmbwvjRuTvxMUBHz6qdTWMLJmzx6aVPbZZ0CjRsDBg1SEV6DtLSMvJk2ahN69eyM5ORmzZs1CQEAAPhW50EWeMzOmSFFFmYy8UVczQQAmTKBR7jt3ymR0u0wcKI3w8wPOnRP9P5jUGnvzTSArS2orAFDKaGgodeLz9hYXCDQpzYwEtTUTBODkScorbt4c8PUFBg8GPvwQ8PLSr5GMThgyZAiaNm2KI0eOQBAE7N69Gw0aNBC1DbUdZEEQEB8fj5oF5z0zJkFKSgrs7e2lNoMRgbqa/fADBTs//RTo08cAholBSRHkixepb9gXXwBqNqEviEmtsW7d6CYTli+nNrWjRgH16qk/FMekNDMSStUsK4vasi1dCoSFUTXnrl00lWzdOoPZyegGd3d3uLu7a/x6tR1kMzMzdOnSBVFRURrvjFEmcXFxcHFxkdoMRgTqaHbkCLW56tyZWl/JBqVFkHNzgTFjgCtXKMJUzLS8kjCpNZaVRbdy5aS2BAC1p92xgwKFPXsCZ87Q1fTSMCnNjIQSNfvlFzrBvX2bCu1++AEYNsyg9jHas3Tp0hIf/0jE5CtROcg+Pj6iWmQwDCNPLl+mvGN3d5pKKauJp1WrArt300QHJfDTTzRG+ptvNHKOTY4vvwRkFnmtXBn480/Kw+/ZU5IWzYwUxMVREQYApKTQJYR9+4DoaDrptbGR1DxGPGlpaUhLS0NYWBhWr16NhIQEJCQkYM2aNQgPDxe1LbX6IOfh7u6OmJgYuLi4oHz58qrhIJGRkaL/CUOglH59cufWrVuF+l8z8qckze7fp8vI6emUe8x97LUgMRFo0IAqvo4e1Tj6bVJr7LPPgAULaCSqzPj7b8r+6NuXpoOXVPRuUpoZCSrN/vuP0ih27gR+/pmS0XNzJW7fowyU4lcFBgbir7/+gp2dHQBynLt27YoTJ06ovQ1RRXoHDx4UZyFjFOR9wBjlUJxmmZlA797USS0oSKbO8dOnwLFjVC0u95qHqVPJ3jVrtEoNMak1JuMUmi5dqGBv2jS62v7VV8U/16Q0MwZyc+Fw7Biwdi1d8alYkRq+t29Pj7NzbFQkJSWhbIEuI2XLlkWSyKbnoj4RtWrVwsmTJ7FhwwbUrl0bZmZmonfIKA9uiK88itIsb4x0cDD1uZftJOd79yiMd/iw1JaUzowZlGKh5XAAk1tjMi7A/OgjKtibNw/48cfin2dymimVvCsVZmZUbJGYCKxYQbnGCxdSAR5jdAwfPhzNmzfHnDlzMGfOHPj5+WHEiBGitiEqgjx+/HjV6L7Zs2fDzs4Offv25bxkhlEAc+fS7I25c4GBA6W2Rg1k7ESpaNSIboz6yDiCDJB5q1cDd+4A48YBNWoAXbtKbRUjmvh4coR/+w2IigIqVEDUggXw79tXZkUXjC7JS/2dNWsW3nrrLQQHBwMAfvnlFzRp0qTQc0pDlIMcGhqK8PBw1U40Gd3HKI/KlStLbQIjkpc1++EHYM4cYORISgGVNTJ3oADQmcaBA/TG2tpqvTmTWmOtWsn+5MfSEvj9d6oTHTCA0pGaNSv8HJPSTEmEh1PB7O+/U15xv37A48dAhQqwbdCAnWMjp02bNujbty969uyJpk2bomnTpgCA58+f4+jRo9iwYQPatGmDkSNHlrotUQ6yLkb3McrD09NTahMYkRTU7I8/gPHjKWvhxx+V4X8CkK8TlZ4OzJwJODvrrFWZSa2xdu3oJnNsbYG//gLeeIMiyKdOUZODPExKM6UQEwM0bUriTZwITJ4MFGjrxpoZPwcOHMDPP/+MwYMHIzY2FhUrVsSzZ8+Qk5ODjh07YsqUKaogb2mI8m51MbqPUR5iqj4ZeZCn2fHjwNtvU9eKbdsACyXMzpS7B79kCV1/X7ZMZ4U9JrXG0tOBpCT5ngAVoGpVYP9+CkS+9RaQnJz/mElpJlcyMqjoLu+ymKsrsHUrpVcsW1bIOQZYM8mZM4dyvhs3ptvff+c/tmABnYG6udEobw2xtrbG+PHj8e+//+LmzZs4cuQIwsPDcfPmTfz4449qO8eAyAiyLkb3MQxjGCIigB49gLp1qbWnTOYylM5rr9EUEy0mIOmNBw+oPVSfPhRaZMTzzTf0RZmbK7UlalG/Pq2ftm2BTp2owUrFilJbZeLcvw98/z2wciUV9bZoQZ8pCwtg0CCprWNK4sMPqU1MQaKjKVf84kUKPrRvD1y9qnU6jKWlJapXr67x60U5yEOHDkWrVq3Qrl07rcb3McrCQhFhR6YgSUm2GDyY5jEcPAg4OEhtkQisrckbkSNLl1IEVMejB01yjQmC/K8WvKBFC5o43L07tYL75x8T1UwO7NxJE+4yMij3Zdo0ymtXp+iKNZMne/bQiY2VFVCnDkWST58G/P0lNUvU9cFRo0bh7t27+OCDD1C3bl307dsXy5cv15dtjEwICAiQ2gRGBLduAR9/7IusLHKO5d5K+BUyMiiacO2a1Ja8ysSJNJJWx7mMJrXGFOIUv0ynTvSxDA0FevUCfH1NSDOpCQkBzp2j3319gcGDgQsXKLTfurXanymTWmd6Ijs7G76+vqrb2rVrxW1g5Urq/PPuu0BqKt2XkFD4i8rZme6TGFGT9AAgJycHZ86cwbFjx7BmzRrY2Njg8uXL+rJPK5Qy8UXuhIeHw8fHR2ozGDW4cwcIDASSkrJx/LgFFCnbnTuUp/bDDzTu1QQwqTU2dy5N4cjOVmRHgY0bafBaq1YPcehQRVhaSm2RkZKTA+zdS5NbTp2itKadO7XapEmtMz1Rql/Vvj31mn6Z+fPpUkyVKnRC8/nnwN27NMlw4kR6bOhQeu6oUUDnztSBREJEXW9o164dnjx5An9/f7Rs2RJnzpyBo6OjvmxjZMLjx4+lNoFRg+Rkag6QlAQsWhQBH5+mUpukHXIq4rp7l7yipUsBLy+db96k1phCI8h5DB8OpKUBEydWxIgR1PFPgX6+vNmyhXKKY2Ko0G75coo4aolJrTOpUHfA0+jR1FoJoIDI7dv5j8XHaz3ARRAEbN68GTdu3MDs2bNx69YtJCYmonnz5mpvQ1SKRaNGjVC2bFlcuHABkZGRuHDhAjIyMkQbzjCMbnnwgE7cb92iwmAPjzSpTdIcOTpQy5dT4aC1tdSWKJ927YBFi+Sps5pMmACMHn0DW7cC77yTP6yN0YJ794CsLPr91i2gQgVqvRMTA0yapJN+44zE3L2b//uuXfnBhh49KH8pMxOIjSXNRTiyRTF+/HiEhIRg69atAGg0/IQJE0RtQ1QEedmyZQCAtLQ0rF+/Hu+88w4SExORmZkpaqeMsvD19ZXaBKYEUlIoP/LqVerb2rIlkJ5uBJrJJYL8+DGNVuvXr3AjXB1iUmvsjTeMogPI0qWOqFkTmD2bPqrr13MkWSNiYujKzPr1wLp11Jdy2jQa467jkyiTWmdy5OOPgfPnSVcXF0qjA6imY8AAwMODOpGsWqX1YtLFYDtRDvLKlStx8uRJnD17Fi4uLnj33XfRsmVLUTtklEdSUhJs+exdlty7B3ToAFy6RCfkefMXFK2Z3CKLa9eSkzx9ut52oWi9xJKaSpc8Xn9dflqLICkpCZ9/bosyZagNb24usGGDQnqNy4FTp6in+O7dNLpw+HAqwAP09iaa1DqTI7/+Wvxjs2bRTUfoYrCdqE/hs2fP8NFHH6Fp06bcLsWEuH37Nl5//XWpzWBeIjGR0iquX6dalo4d8x9TtGaVK1OLn9q1pbYEeP4c+PZbajunx+iTovUSy+rV9EWYmQmULSu1NRqTp9msWTQv5tNPKZK8cSM7yaUiCJSDmphIn4UJE4Bq1fS+W5NaZybOy4PtduzYgXnz5onahqhlPG3aNERERGDNmjUAgJYtW8Lb21vUDhmG0Z6EBIoW375NOcdt2khtkQ6xtASaNZPaCiI3lxrbN1V4waMckUsKjQ745BMKhn/yCX1kfv0V3N2iIE+fUnj9l18ol9/ODti+nU6Cy5eX2jrGCCk42A4A9uzZI3p+h6h484oVKzBkyBAkJycjOTkZQ4cOxXfffSdqh5pQ0nRCRv+4urpKbQJTgFu3qC/+nTvU57go51jRmmVkAD/9RNOVpMbaGpg6lXqt6hFF6yUWBadVFORlzWbOBP73P6or692bfEKTJzmZWvrVqgWMH0/a5xVqeXgY3Dk2qXVm4mzfvh1OTk6YMGECUlJS8OmnnyI8PFzUNkQ5yD/99BNCQ0Mxd+5czJ07F//99x9+/PFHUTvUlA8/pNzu8+dpkhFjOKysrKQ2gXnB5ctUhHf/PnDoEFBc33tFa5aeTpdfjx2T1o6wMIp6iSzs0ARF66UpCo8gF6XZ9OnAmjUUxHnrLeDRIwkMkwu3b1OEeO5c4M03gRMngP/+o9ndEmGS68xE+eqrr2BnZ4fg4GAcPXoUo0aNwrhx40RtQ5SDLAgCzAtUFpqbm0PknBFGgVy4cEFqExhQWm5AAPDsGfmOfn7FP9coNJP62PK//9GZeXa23ndlFHqpi5FEkIvTbOxYYOtWGv7Wpg0FUU2GsDAqagVoMtqXX1IF8Z49dGYvsfYmtc5MnDxf9a+//sLo0aPRtWtX/XaxeOedd+Dn54fevXsDAHbv3o1Ro0aJ2qGmrFxJxQ++vsA33wCVKhlktwwjC/75hwZJVa1KaRV66jYmD+TgQN25Q21BJk8GypWT2hrjomNH6nFrxJVsAwcC9vZA377kFx46RFkGRokg0AFq0SI6c3d0BIYNA2xsqK0Xw0iAk5MTxo4di0OHDmHGjBnIzMxEbm6uqG2IHjUdHh6O4OBgAFSkl9djTls0mU5YFGvXrlXNBo+MjMQ///wDAKhbty7s7OwQEREBAKhcuTI8PT1x4sQJAICFhQUCAgIQHh6umrbj6+uLpKQk3H4x4cXV1RVWVlaqs1BHR0fUr19f9X5YWVnB398fYWFhSE9PBwD4+fkhPj4eCS/miru5ucHc3BzRL/Irq1Wrhjp16iAkJAQAYGNjAz8/P4SGhqqGsPj7+yM2NhaJL94gDw8P5OTk4MqVKwDog+Ds7IzQ0FAAgK2tLXx9fRESEqLqUR0QEICrV68i+UU4w8vLC5mZmYiJiQEA1KxZE1WrVkVYWBgAwN7eHj4+PggODkZ6ejqsra0RGBiIixcv4sGDBwAAb29vpKWl4caNGwAAFxcXODg4qPJ8KlWqBG9vbxw/fhyCIMDMzAytWrVCREQEUl/MYPfx8UFKSgri4uJYp2J02ratDCZPrggXl6f49df7aNiwSpE6Zb+IdAYGBuLkyZOqqztK0yn0r7/wZq9eiP3wQ9RZulQSnVw2bIDl/Pn4b9MmWLi56XQ9FdQpbz09e/YMfn5+itJJqetJG52A/PUUHR0Na2vrEnWKjLTHJ580RKVKFli+/DIcHBKNSie7S5fQZM0alImMRGaVKojv1w/206Yhu1w52ehUcD2lpqbi0Yu8F15Pmq2nChUqlDxqWiY8ffoUBw4cQMOGDeHq6oq7d+8iKioKHQu2eyoFtRzkZ8+eYc2aNbh27RoaNmyIUaNGSdbmLS6OphOqc6Wk1JnhjFpkZ2dzWz+JWLGCgpiBgcCff1LgTR0UrdmDB3RGvGIF8MEHht9/VhblTnp7A/v3G2SXitZLLElJFKFv1EjRkzXU1ez8ecpHfvaMLkoovuPM06c0ncjZGbhxA+jZE/joIxrwIfMcX5NaZ3pCSX5VamoqYmJi8OzZM9V9gYGBar9erRzkESNGICwsDA0bNsT+/fsxbdo08ZZqQXHTCRnDkHdmyxiOnBz6zpk8GejVi9Iq1HWOAYVrVrEi5S0OGSLN/hMS6DKxyLGk2qBovcSycSPg40Meo4JRV7PGjYHQUOrE1KlTybMSZM2DB5RTXKsWkFfsVLcuEBlJ87Zl7hwDJrbOTJyffvoJgYGB6NSpE7744gt06tQJc+bMEbUNtU6loqOjERUVBQAYNWoUmms5I1ssxU0nZBhjJD2dfMM//6QA6tKlRp2u+Srm5oDIfpU6xcUFOHdOuv2bClIXYRqQ2rWBf/+lOoLhw+lK6GefySPdvlRu3qTCn3XrKHrcvXvh3GJF/BOMqbF8+XKcOXMGLVq0wLFjx3D58mV8+umnorah1teuZYGO51JcnlDsGbeRwK1xDEdCAn3/REQA330HTJyo2XYUrdmzZzRtrVUrijQakocPaSyavb1Bd6tovcRiJA6VWM0qVgQOHADeew+YPRuIjaVgj+wHimzcSOtxyBDqY+fpKbVFGmNS68zEsba2hrW1NQAgMzMT7u7uqnxrdVErxSIiIgL29vawt7eHnZ0dIiMjVb/bG/iLhDE8/v7+UptgEpw7BzRvDsTE0OhoTZ1jQOGaPXtG+SUvCl8Mynff0bXwlBSD7lbRemmKwiPImmhWtiy11p49m4bKdexIPc1lgyAAQUE0bGDnTrrvgw8o13j9ekU7x4CJrjMTxdnZGQ8fPkSvXr3QoUMH9OzZE7Vr1xa1DbUc5JycHDx+/BiPHz9GWloasrOzVb/nVWoyxkte5TCjP3bvpnZQ5uZ0KVbbYThGoZmhHajcXHICmjUDHBwMumuj0EtdjCSCrKlmZmaUyrtxI/VKbtYMeJHBKB05OcAff1DLqDZtgLNn80cBVqxIPY2NAJNaZybOrl27ULFiRcyZMwdfffUVRo0ahT179ojahillNjIaktdqhtE9ubk0Sv2rr+iLcs8eoHp17beraM2kcqBOnqRImchCDl2gaL3E0rkzNfR+cflTqWir2bBhNFSud2/A358c5j59dGScWHr0oPF/r79O6RQjRlAfYyPDpNaZiZOZmYmdO3ciLi5O1Qrw/PnzmD17ttrbEDVJj2EY3fHwIX0vffUVFYGfOKEb59hoMHQE+ZdfADs7mu7A6A8PD2DoUAUk3+ofPz8aPuflRR+7OXPopFnvPHlC07fyosRjxwLbtgFXrgDvv2+UzjFjWvTs2RN79uyBhYUFypcvr7qJQfSgECWhpH59ciYjIwM2fMDUKdHR1L4tNhZYvpy6JukycKpozR4/pp5233xDuciG4OlT4LXXqJfrjz8aZp8FULReYklIoEi9v7+i27PoUrNnz8gv3bCBjgvr14tr66g2qanAqlXAt99S27Zt24ABA/SwI3liUutMTyjFr/Ly8tJ6tDhHkJlSiY+Pl9oEo+KPPyhy9PgxTWYdP173WQWK1szWFrh9Gxg92nD7LFeOmtXOmGG4fRZA0XqJZft2mnyj8MvdutTM2pouYCxbRgW6TZtSa1OdkZUFzJxJ/eY+/5xyjYODTco5BkxsnZk4b7zxhqo9saawg8yUSt54S0Y7nj8HpkyhS6keHnRpNSBAP/tStGZlytCULjs7w+7XywuoV8+w+3yBovXSFIVfvNS1ZmZmdHwICgIyMsiH/eknLd+mvCJ6Cwvg1Cmq/j13Dti3D3jzTR1YrSxMcp2ZGA0bNkSjRo0QHBwMHx8fuLm5oVGjRqr7xaDc61sMoyBu3AAGDiSneMoUYNEiavnEFMHz58DChUD79sAbb+h/f1evUluBefOAOnX0vz9Tx0i6WOiLgADyYYcMoYsowcHA99/TRQ61uXSJ1tCuXcC1azQZ8sgRzvtmjJ59+/bpbFscQWZKxc3NTWoTFM0ff9C8i2vX6Ptq2TL9O8eK1iwrC/jiC+p3Zwg2bgR++03SrgqK1ktTFB5B1qdmjo40VOSLL+jj6edHdQulEhZGl6g8PSmVZdSo/BMSdo5Nc52ZGFWrVsWuXbuwePFiHDhwAE5OTqhdu7bqJgZ2kJlSMTc3l9oERfLsGTBpEn1fublRVKhXL8Ps2yg0M4QDlZtLozo7dJC0hYhR6KUuRhJB1rdm5ubU1eLAASApifKSv/++hGVx6xZNGjpyBJg1i0ZEL1tGxacMABNbZybKiBEjEBYWhoYNG2L//v2YOnWqxttiB5kplWi1QhdMQSIiAF9fGsw2ZQq12HVxMdz+Fa2ZIR2oEyfIsRg+3HD7LAJF6yWWrl1pMo6trdSWaIWhNOvYkQaJtGkDTJhArSGTk0Ge8v79+X27a9UCduygz/NXX7FjXAQmtc5MlOjoaGzatAljx47Fjh07cPLkSY23xQ4yw+iQnBzgf/+joR8PHlD0xxApFUaJISLIv/5KjpqhQvsMDaPo2ZMXhQiqVgX++otaQh76R8C0+n/ikVtzKrrbuDG/I0ifPoC9vbTGMkxxbN9O6T9lylA6UEEWLKAiaTc34ODB/PsPHKD76tWjvPpSsCyQSmShZRtJdpCZUqlWrZrUJiiCmzeBtm2pU1j37hT16dRJGlsUrZkhI8guLhSWE1UBpXsUrZdY4uJoatvz51JbohWG1szMDJjUOhKpdX2w8VFP3I9JwZZ26/D03BXFR+MNhUmtMzni5UVFOYGBhe+PjqY6kIsXySEeP56iTTk5dHzev5+es3Vrqcn4ERERsLe3h729Pezs7BAZGan63V7kySN3sWBKpQ5X9peIIFAg8oMP6PdffqFJrVKmWipaM2trGjNoZaX/fX3+uf73oQaK1kss+/bRYrl3D6hSRWprNMZgmuXk0HtVrRpQtSpsrIHnP27Ad+ffxvJVFnBtBvz8s/5aRhoTJrXO5EiDBkXfv2cPMGgQHfPr1KFo8enT9Fi9ekDduvT7oEH0XA+PYneRk5OjM3M5gsyUSkhIiNQmyJbbt4Fu3cghbtiQco9HjpS+DknRmpmZ0RgxfXeVCAsj50MGKFovTVF4Fwu9a5adDWzeTFG33r3p/apaFQgPR9n3huPblRY4coSavgQGAh9+mD85mikak1xnOiY7Oxu+vr6q29q1a7XfaEICULNm/t/OznRfcfcbCHaQGUYDcnOBH36gdKqgIMozPn6c2+jqhOxsYPp04OhR/e0jMZF6Z82fr799MEWTd/aocAdZb2Rl0azpBg2AoUOpPVvBkesFzr7btqVUrnHjaHq0tzcVBDOMvrCwsEBYWJjqNmbMmMJPaN+eTupevu3ZI43BWsApFkyp8Oz6wly7Rg38g4LoC+rHH/OvAMkFRWuWkwMsWQJUqkRvsD7YsoXOcvr318/2RaJovcRiJA6y3jRbvx4YMwZo0oQap/foQUVNxWBrC6xaBfTrR22PW7UCJk6kcz9DD6OUOya1zqTi8GHxr3FyosuxecTH031A8fcbAI4gM6Xi5+cntQmyICuL/LZGjYDwcHKMDx+Wn3MMKFwzQ+Sn/PortRopLifOwChaL7FInX+kI3Sm2fPnwNq1VOEPUNR43z7g7FnqrlKCc1yQNm2AyEiqaVq5kj7aO3cq/jxEp5jUOlMSPXpQkV5mJhAbC8TEUE/vZs3o99hYWie//UbPNRDsIDOlEhoaKrUJknPiBAV0pk+nK0jR0cB778n3u94oNNPXN3tUFHD+vOS9jwtiFHqpS/fudGZZsaLUlmiF1pplZ1NFr5sbMHYsVfcDgI0N9YrW4OBia0u910+dovrHfv3o7Y6L085UY8Gk1pkc2bWL8ohDQugzntfmydMTGDCAiu/eeosuiZibAxYWdLbXqROd8Q0YQM81EOwgM6WSkZEhtQmSkZREflSrVtRqdPduSqUy4FUejVC0Zvq+BL9jBx14Bw3Sz/Y1QNF6icXZGWjXzjBdSvSIVpr9/Td94b/7Lnmyf/9NaT86okULqkFdupRSwTw8gEWL6CqYKWNS60yO9O5NaRKZmfTlWrDf8axZwPXrwJUrQOfO+fd36QJcvUqPzZplUHPZQWaYIsjJobGubm50VefTTylq3LOnfKPGRoO+3+DZs6mFkIJbjCma69eBbdsAU3NWcnPJMQBoDn358nS2ffo0OQQ6/txbWFBni0uXKCg3cyYV8f3zj053wzBGi5kgGG+GUvny5fHkyROpzVA8mZmZsFJ4tEcMx45R0fj58xToWrkScHeX2ipxKFozQaCbmZnJnI0oWi+x/PAD8P77wJ07QPXqUlujMWprlptLl5bnzKGchy++yP+Mq5lfrAv27aOx99evU2vKb74B6tc32O5lgUmtMz1hSn4VR5CZUomNjZXaBINw9SpFiNu2BVJSKHJ86JDynGNA4ZqZmZHjoA/n+MMPgXnzdL9dLVG0Xpqi8NhMqZoJAvDnn0DTpuQYZ2VRhS+Q/xk3IN260aCy//2PWlJ6eQHTpgGPHhnUDEkxyXXGaAw7yEypJCYmSm2CXklJociKpye13v36a+DyZWDgQOUGMBWtWW4uRRj/+ku3201NBVavph7IMkPReonFSNq8larZhx/SGXdaGrBxI3mnvXsbxrhisLKiQuOYGKqtWLoUcHUF1qwxjfxkk1pnjNawg8yYLBkZdJmxXj2q/H7nHepx/MknVEjOSMgPP1CVkS7ZvJlyQN97T7fbZcRhJA5ykYSF5fdtHTkSWLeOzraHDaOqfJlQtSrw009krrs7DRrx9AR+/53OTxmGYQeZUQOPEuaeK5GsLGo76upKlxibNQPOnaP7qlaV2jrdoGjN9BG2FwTyCHx8gMaNdb99LVG0XmJR6mWZlyik2ZUrNHSmWTNgwQK6r3Fj6lJhId95XD4+lG6xdy9FlwcOpPazhw5JbZl+MKl1xmiNrBzk7dvpLLZMmVeDRwsWUKTPza1wZxBG/+Tk5Ehtgk7IzaVOSg0aUNvRWrWoIO/gwfzUQGPBKDTTZYQxPByIiJBt9Ngo9FKXHj2A0FDgtdektkQrcnJyqGXVmDH0xXXgABXgLVwotWmiMDOj/OTz54ENG4D794GOHanf+5kzUlunW0xqnTFaIysH2cuLeqUHBha+PzqaCqYuXqRj0Pjx1IaLMQxXrlyR2gStyM2l/sWNGwNDhlAz/X37gH//BVq3ltg4PaFozfRxCd7GhpIuBw/W3TZ1iKL1EoujI4UpFd5N4MqVKzTPef16mu18/Tp1qrC3l9o0jTA3pyVy5QqwbBmdTzZvTs7z6dNSW6cbTGqdMVojKwe5QQOKEL/Mnj3U09/KCqhThyLJxrJgGf2Rk0MnVo0bU21MRgawdSsFEzUcVMUYinLlAEtL3W3Pw4PCYwqf3mYUXLlC6S7p6VJbIp6MDLqcmfcF9MUX1P7m22/J8TcCrKzy28HNm0dDz/z8qFVzSIjU1jGM4ZBvclQBEhJoMlAezs50X1GsXbsWa9euBQBkZWUhKCgIAFC3bl3Y2dkhIiICAFC5cmV4enrixIkTAAALCwsEBAQgPDwcjx8/BgD4+voiKSkJt18UXbi6usLKygoXLlwAADg6OqJ+/foIDg4GAFhZWcHf3x9hYWFIf3Hw9/PzQ3x8PBJeGOzm5gZzc3NER0cDAKpVq4Y6deog5MWRx8bGBn5+fggNDVVN/fH390dsbKyqAtfDwwM5OTmqs2EnJyc4Ozurxmja2trC19cXISEhyHzRmD4gIABXr15FcnIyAMDLywuZmZmIiYkBANSsWRNVq1ZF2IvcFnt7e/j4+CA4OBiZmZkICgpCYGAgLl68iAcPHgAAvL29kZaWhhs3bgAAXFxc4ODggPDwcABApUqV4O3tjePHj0MQBJiZmaFVq1aIiIhAamoqAMDHxwcpKSmIezELVRc6ubi4Yu9eeyxebI7bt8uhbt1MrF9vAWfnYJibCwgNNU6dsrOzAQCBgYEwNzdXffblqlOJ6+mvv2g9AdrrlJ2NyFu3kPKi566cdMpbT5mZmUhNTVWeThB/3Kv2999wX7wYmYGBCLlzJ18nGa+ni1FRsNi2DXV++gnW9+7h0eTJyOzcGUGXL5NOjx8bnU4A0LdvNYwdWwezZsVj27aaeOONsmjfHujX7yLc3O7JT6dSvp8qV66sOi4ak06G/H4yJQw+KKR9+6K7LM2fTx1xALrsvWQJ4OtLf0+cSA7y0KH096hRdDbbr1/J+zKlhtb6JCMjAzYKaOuQkUFXOxctAm7epMjxrFlAnz4GbzkqOUrRTO8IAlUi5eTQNWOZXjYwKb1+/pkO4nFxQO3aUltTOidPUsu2s2epp/E33wCtWpmWZgCePKEuiYsXA8nJQEAAFTl3766c46upaaYPTMmvMvjH+vBh4MKFV295znFRODnld84BqC7CyUn/tjJE3hmlXElMpOnBtWpRfnr16pRjHB5OJ1FKOXjrErlrVirDhgE7dmi/nVOnqPpo4kTZOseAEeglBqW1eTtxAkhKAn79lVIrWrUCYGKagSZjT5sGxMYCy5fT93CvXpQa+cMPypgcbmqaMdqhCNehRw/KJc3MpMUZE0PFA4xpExlJvYtr16ZcuTfeoK4Up05xjrHi2bKFHFtt+e47yjseMkT7bTG6Qe4O8oMHwOTJVDEOAFOnUt700KGmebb9EuXKAZMm0ffwb78BdnY016d2bWDuXODePaktZBjdIKvVvmsX5ReHhJCD06kT3e/pCQwYQHU2b70FrFolq57rRo+tra3UJqjIyaGenR06AN7e1Nh+9Gj6/tqzh9Jz2DGWl2YaoQsR79wBdu6kXrTly2u/PT2ieL3EINcFmpVFxXb16gErV9KlTQCwtiav8CVMSrMisLCgvslnzgBBQVTI98UXQM2a1A0jNFR+50CmrhkjDoPnIBsSU8qVMXbu3qWhVGvXUrpNjRrABx9QC1IHB6mtY3SOhQUwYwYVJ2jK3r3A229T7nHdurqzjdGOhw9pQb/+OlC2rNTWECdP0ji5ixepCfA331DfUUYUly5RAGvDBmpS0rQppb0NHszTSY0FU/KrZBVBZuRJiES9fQQBOHqUBlTVqgV8/jm1Adyxg+p7Zs5k57g4pNJMZ5iZaR9+6t6dckcV4BwrXi8xVKxIiatycY4BOut++pQaph84oJZzbFKaqUmDBhR8v3OHHOWMDKrHdHKiTJUXTRckgzVjxMAOMlMqeS1eDMWtWxQ4dHMD2rUjJ3nyZEqjOHQI6NtXty1yjRFDa6ZzqlWjiS6akpREDnYRl8bliOL1EsOlSzSJ4uFD6Wx49gz4+mvy5gAKcUZHU7W4mikgJqWZSOzsKHJ84QKlX7RvD6xYQemS/v50JfDRI8PbxZoxYmAHmZEFT54AGzeSQ+ziAnz2GXWj2LiRel4vWQLUry+1lYzBuH0b+PRTzV6bnU3fwu+/r1ubGN0QFgZ89BHNNJaCv/6iCPGsWdS6DSCn2NpaGnuMGDMzavrx++90HP/mGyAtDRg7lo7vw4ZRYXVurtSWMsyrcA4yUyrZ2dmwsND9TJmcHOD4cXKCd+wgJ7luXSrwGD6cpiYymqEvzRTB1q2Ue7x7d8n9I2WESem1aRN5RjExVBBnKO7epfYLO3YA7u7U4aR9e403Z1Ka6RBBoHOkn3+mZjWPH1Nh38CBzSCWwAAAF5RJREFUFMhv0kR/dZysmfaYkl/FEWSmVK5evaqzbeXk0CW38eOp0K5dO+qmNGgQtRu9do0qodk51g5daiYJ/ftTpY9YBIEmxTRoQDnICkHxemmCoWMz169T9Hj+fCrc1MI5BkxUMx1gZgY0a0ZDRxITgc2bqSPRt99SUZ+7O30HXL6s+32zZowY2EFmSiVv/Kem5EWKJ06kYo02bcj3adUK2L6dDpI//QS0bCnfDlBKQ1vNJGfvXs0qenbvJudn5kxF9axVvF5iMGQf5AsX8vOMAwKowOHTT3VSIGhSmukJGxu62LN3L5UNrF1LrV6/+orOcRs3ph73UVG6+biwZowYlPMNwiiK9HTqa/3uuxQpbt2aLqm1bEn5aMnJ9LNfP8XUUTGGRNMzpTVrqLrz7bd1aw+jOwxxFvzsGeUYN2lC3lZeRViVKvrfN6MRDg7U0/7IEcpX/vZb+m74/HOgUSPKxpk6lTry5eRIbS2jEdu3U6VmmTKUZ5NHXBydLTVuTLeC9SNnzwING9IHYNIkg1554hxkplTu37+PKmp8sdy6RSOe9+6lzhPPnwMVKgCdO9NI0q5dtWtMwKiPuprJFhsbanT9v/+Je11GBnDzJl2nVRCK10sMT58CKSlA1ar6aUdz+jQwYgRdox8xgip89fDempRmEnL3Ln2n7N5NzvPz5yRn9+703dK+PVCpknrbYs20Ryu/6tIlco7HjqV16etL98fFAd265Q/nKUjz5tQCxc8P6NKFnOTOnTW2Xwycrc6USnGtcdLTKW/40CHg8OH8z3a9esCECXQACwjglmxSoPh2RmL7IGdnUym8jY3inGPACPQSQ7ly+rtslJoKtG1LHtOBA/njWPWASWkmIdWr00CoMWOoA8aBAzQ1ddcu4JdfyN9q3pyk7tSJ8puLq8NjzSSmQQNxz797l6o4W7Sgv4cPpzMlAznInGLBlEpMTAwA8kFCQuiKZWAgfQd17UrFFtWqUbDv0iXg6lVg6VLKNWbnWBryNFMsr78OVK6s/vN//JFSKxIS9GeTHlG8XmK4eJEOIrps83bjBv2sVInGi0dF6dU5BkxMM5lgZ0f1u5s2AffuAf/+Sy1BBQGYOxd44w3gtdcodW/VKvoYFGwhx5ppT3Z2Nnx9fVW3tWvX6mbDsbGUEtWqFeXRAHQ8d3bOf46zs0GP8RxBZoolPR347z9g0yYXzJtHvz95QsE9Hx/KB2vfHnjzTR4jyuiYqCj1n/vwITB7NuW21aihN5MYHREVRXr166d96kNODg38mDsX+O03miKkZ8eYkQcWFuQQv/EG8OWXlLVz+DBw8CBd1dy5k57n4EC1L61aAeXK2aJlS8DcXFrblYyFhQXCCuYPv0z79lR5/zLz5xffdrN6dcrRrFyZco579aITaYlhB5kBQGfg169T3vx//wHBwcD58/T9U6ZMbTRqBLzzDh1o2rblWhe5U7NmTalNMBzz5gEPHtB0NoW2QTEpvXSl0e3bwNChlOc1eDBdsjIgJqWZAnBwAAYMoJsgUFrriRPUQen4cUrLAHwxfTqlYTRvTmmtzZvzebVOOXxY/GusrOgGUK+/11+nS9FOTkB8fP7z4uPpPgPBDrIJknfwOHuWHOKwMPo9b/KrjQ0dOD75hHKIvbyewMmJq+uURNWqVaU2QTu6daP8nXHjSn5eTAwVcLz7Ll2eUyiK10sTtKkP//NPYORIICuLJg0NG6Yzs9TFJDVTCGZm1Eu/Th2q0wTIt/rnn2cIC7NGaCjViGVn02POzuQoN2tGTRQaNaKgpkLPt5XHvXt0hmNuTulSMTE0NczBAbC3p6idnx+t9Q8+MJhZ7CAbOcnJVDxX8HbxIuW9A5Qj7O1Ngzp8fenkzdOzcO5wUFAYnJxaS2I/oxlhYWFo3bq11GZozvHj6s0WX7uWCr7mzdO/TXpE8XqJQRd9kDMzKcq0dathp/EVwKQ0MwKcnYG6df/Du++2BkANb86fB0JDqfHJ6dM0tCqPKlXIUfb2plvDhnRI4k5MWrBrFzm49+5RAKRxY8qJOXGC0q4sLanqcs0aco4B4Pvv6WQ4I4OK8wxUoAewg2wUPHxIE+hevl29Sp/DPBwcaJEPG0Y/fX0BL6/8KxsMIxvUDd0sWgSMGkVVoowy0DQsd/06cO4c5S737w/06cPJpIzG2NgA/v50yyM1FYiMpFtEBP1cs4Z8szxq1CBH2c2t8M/atXUyf8a46d2bbi/Tty/disLXt+j2bwaAHWSZ8+wZFW3Gx+ffCv4dG/tqMbiTEwVVevQgBzjvVrWqZt9N9vb2uvlnGINhFJqVFGG8d4+uj1avrsi2bi9jFHqpS8+edFYvJhT399/AkCF0Nt+5M1C+vOTOsUlpZiSUplmlSlTM16pV/n05ORRwunCBgk55tx07qPQhDzMzOk+vVSv/Vrs2/XRyAhwd6WZtrad/jtE5PChERwgCtZPJzqYFlZ2df8vKot746emFb0+e0M+HD8nJvX+fFlze7/fv0+MvU6ECXS5ydqYF6OpKDnG9epS2w5PpGMVToQJVhX77bdGPv/02FYPExpKzxBgnubnUoWLuXLrOvXMnHeQYRgY8eJDvMN+8SY0Ybt3K//3Zs1dfY2+f7yw7OlJbuooV6X57ezr05f1ub0/f51ZWFJ0ueLOyok4ehs6TNqUBbBxB1gEffUQF9Npgb085T5Ur04Jp0ID+rlKFzj7zHGInJ8PnQAUHByMgIMCwO2W0QvGaNWpUfLXy779T7umcOUbjHCteLzFERQG//gp8+CFdASiOnBxKo/jzTxoQsHq1rM7+TUozI0HXmlWu/GqaRh6CQEGuW7foau+9e1QTVPB2/TrNFnj0qGhnWl38/YFTpzR/PVM07CDrgPbtqYG5uTmd0RV1K1+ebra2r97s7eWdu5SdV+rLKAbFa5bXKP5lbt+mMaV+fsCnnxrWJj2ieL3EcPUqsHgxFUOU5CCbm1PVcIcONJpTZi0FTEozI8GQmpmZUbDrtdfoY1waz5/TpMDHj8lhzvuZkUGP5d0yMwv/LQgG7XxmUrCDrAO6dKEbwzB6JCeHnKrsbGDzZh7TqHSKy+47e5a++f39qbKdYUyAsmUpIi1mgCijX3jUNFMqgYGBUpvAiETxmrVrR41KC5KZSRUv331HLb6MCMXrJYaSIsH79tE0okmTtGsDZwBMSjMjgTVjxMAOMlMqF2Uw8pERh+I1O3eOkvcKUq4cNYrP6/xvRCheL0142QHevJlGzHp6kqMss5SKlzFJzRQOa8aIgR1kplQeFOxlwygCo9Asz4GKjQUCAyl3FZC946QJRqGXuhSl36pVNDY6MBA4epR6Usock9LMSGDNGDFwDjLDMPLDzIwc5KdPqZNBbCxNWGKUT69elEeep6cgAEeOUH/k337jRrEMw8gC7oPMlEpqaioqVaoktRmMCBSvWZUqNC0tKQnYvRvYu5dGkxopitdLUzIyaKRZZmZ+GyCFYLKaKRjWTHtMya/ikAxTKmlpaVKbwIhE8Zr5+9OM1127qMm4ETvHgBHoJYbISGDcOOCDD4DmzYGUlPypBwrCpDQzElgzRgzsIDOlcuPGDalNYESieM22bQOaNQMmT6abkaN4vcQQF0cnPytX0nS8ChWktkgjTEozI4E1Y8SgrFN2hmFMg3LlgKAgiiwyxkXeVKT+/YH16ym1gmEYRmYYdQ5ymTJlYGNjI7UZiic7OxsWCrv8aeqwZsqC9VIerJnyYM20JyMjA7m5uVKbYRCM2kFmdIOvry/CwsKkNoMRAWumLFgv5cGaKQ/WjBED5yAzDMMwDMMwTAHYQWYYhmEYhmGYArCDzJTKmDFjpDaBEQlrpixYL+XBmikP1owRA+cgMwzDMAzDMEwBOILMMAzDMAzDMAVgB5lhGIZhGIZhCsAOMvMKKSkp6NChA1xdXdGhQwekpqYW+9zHjx/D2dkZEydONKCFTEHU0ev8+fPw9/eHp6cnGjVqhG3btklgKXPgwAG4ubmhXr16WLhw4SuPZ2ZmYuDAgahXrx78/PwQFxdneCOZQpSm2dKlS+Hh4YFGjRqhXbt2uHnzpgRWMgUpTbM8du7cCTMzM279xhQJO8jMKyxcuBDt2rVDTEwM2rVrV+IB5vPPP0dgYKABrWNeRh29ypUrh40bN+LixYs4cOAApkyZgocPHxreWBMmJycHEyZMwP79+xEdHY2tW7ciOjq60HPWrVuHSpUq4dq1a/jwww8xY8YMiaxlAPU0a9KkCcLCwhAZGYl+/frh448/lshaBlBPMwBIS0vD8uXL4efnJ4GVjBJgB5l5hT179mDEiBEAgBEjRmD37t1FPu/s2bNISkpCx44dDWgd8zLq6FW/fn24uroCAGrUqAFHR0fcu3fPkGaaPKdPn0a9evVQt25dlC1bFoMGDcKePXsKPaeglv369cORI0fAddTSoY5mbdq0Qbly5QAALVq0QHx8vBSmMi9QRzOAgjszZsyAtbW1BFYySoAdZOYVkpKSUL16dQBAtWrVkJSU9MpzcnNzMXXqVCxZssTQ5jEvoY5eBTl9+jSeP3+O119/3RDmMS9ISEhAzZo1VX87OzsjISGh2OdYWFigQoUKePDggUHtZPJRR7OCrFu3Dp07dzaEaUwxqKNZeHg4bt++ja5duxraPEZB8FByE6V9+/ZITEx85f758+cX+tvMzAxmZmavPO/7779Hly5d4OzsrDcbmXy01SuPu3fvYtiwYdiwYQPKlOHzY4bRFZs2bUJYWBiOHz8utSlMCeTm5uKjjz7C+vXrpTaFkTnsIJsohw8fLvaxqlWr4u7du6hevTru3r0LR0fHV54TEhKCkydP4vvvv0d6ejqeP38OW1vbEvOVGc3RVi+ACiq7du2K+fPno0WLFvoylSkGJycn3L59W/V3fHw8nJycinyOs7MzsrOz8ejRI1SuXNnQpjIvUEczgNbn/Pnzcfz4cVhZWRnSROYlStMsLS0NFy5cQOvWrQEAiYmJ6NGjB/7880/4+voa2lxGxnAIiXmFHj16YMOGDQCADRs2oGfPnq88Z/Pmzbh16xbi4uKwZMkSDB8+nJ1jiVBHr+fPn6N3794YPnw4+vXrZ2gTGQDNmjVDTEwMYmNj8fz5c/z222/o0aNHoecU1HLHjh1o27ZtiVcEGP2ijmbnzp3D2LFj8eeffxZ7csoYjtI0q1ChAu7fv4+4uDjExcWhRYsW7BwzRcIOMvMKM2fOxKFDh+Dq6orDhw9j5syZAICwsDC89957ElvHvIw6ev3+++84ceIE1q9fj8aNG6Nx48Y4f/68hFabHhYWFli5ciU6deqEBg0aYMCAAfD09MTs2bPx559/AgBGjRqFBw8eoF69eli6dCmfdEqMOppNnz4d6enp6N+/Pxo3bvyKA80YFnU0Yxh14FHTDMMwDMMwDFMAjiAzDMMwDMMwTAHYQWYYhmEYhmGYArCDzDAMwzAMwzAFYAeZYRiGYRiGYQrADjLDMAzDMAzDFIAdZIZhGIZhGIYpADvIDMMwDMMwDFMAdpAZhpEUMzMzTJ06VfX3kiVLMGfOHIPaYGtrq/r9jTfe0Hp7c+bMwZIlS4p8zNzcXDWspXHjxoiLi9N6f3Jm6tSp8Pb2xgcffID3338f//777yv3MwzDyA0LqQ1gGMa0sbKywh9//IFPPvkEVapUEfVaQRAgCALKlNHduf6pU6d0tq2isLGxKXaKoT7+Hym5fv06/v33X0RERAAAGjdujFWrVr1yP8MwjNwwjqMwwzCKxcLCAmPGjMGyZcteeWzp0qXw8vKCl5cXvv32WwBAXFwc3NzcMHz4cHh5eeHkyZNwd3fHyJEjUb9+fQwZMgSHDx/Gm2++CVdXV5w+fVq1vV69eqFp06bw9PTE2rVri7QnL5q8Zs0aVZS3Tp06aNOmDQBg06ZNaN68ORo3boyxY8ciJycHADB//nzUr18fAQEBuHLlitr//8v/z+3bt4vdx8v7GTx4MJYsWYK4uDh4eXmpnlMwCl/UtuLi4tCgQQOMHj0anp6e6NixIzIyMlSv37hxIxo1agRvb28MGzYMs2fPVr3/ADBr1iwsX768xP/rypUraN26NW7evIkmTZrg4sWLqF+/Pq5du1bo/idPnqj9XjEMwxgMgWEYRkLKly8vPHr0SKhdu7bw8OFDYfHixcIXX3whhIWFCV5eXkJ6erqQlpYmeHh4COHh4UJsbKxgZmYmhISECIIgCLGxsYK5ubkQGRkp5OTkCD4+PsI777wj5ObmCrt37xZ69uyp2teDBw8EQRCEp0+fCp6ensL9+/dVNhS0pyDPnz8XAgIChD///FOIjo4WunXrJjx//lwQBEEYN26csGHDBpWtT548ER49eiS8/vrrwuLFi4v8f8uUKSN4e3sL3t7eQq9evV75f4rbhyAIxe4nNjZW8PT0VO0j7z0sblt579m5c+cEQRCE/v37C7/++qsgCIJw4cIFwdXVVbh3757qPYuNjRWaNGkiCIIg5OTkCHXr1lW9dyUxa9Ys4ccffxQEQRC++eYbYd26da/czzAMI0c4xYJhGMmxt7fH8OHDsWLFCtjY2AAAgoOD0bt3b5QvXx4A0KdPH5w8eRI9evRA7dq10aJFC9Xr69Spg4YNGwIAPD090a5dO5iZmaFhw4aFcnxXrFiBXbt2AQBu376NmJgYVK5cuUTbJk+ejLZt26J79+5YuXIlzp49i2bNmgEAMjIy4OjoiJSUFPTu3RvlypUDAPTo0aPY7b2cYhEXF1fo/zly5EiR+wCAkydPqr2fkrYVGBiIOnXqoHHjxgCApk2bqt6no0ePon///qp0FwcHBzg4OKBy5co4d+4ckpKS0KRJk1LfNwCIiopCz549AQAHDx7EL7/88sr9DMMwcoQdZIZhZMGUKVPg4+ODd955p9Tn5jnNeVhZWal+L1OmjOrvMmXKIDs7GwAQFBSEw4cPIyQkBOXKlUPr1q3x7NmzEvezfv163Lx5EytXrgRAOcIjRozAggULCj2vYPqBJhT8f4rbR0lYWFggNzdX9Xfe/1XctuLi4gq9Z+bm5oVSLIrivffew/r165GYmIh3331XLbsuXrwILy8vPH36FA8fPkSNGjUK3Q/QicrcuXNRoUIFvPXWW2jfvr1a22YYhtEnnIPMMIwscHBwwIABA7Bu3ToAQMuWLbF79248ffoUT548wa5du9CyZUuNt//o0SNUqlQJ5cqVw+XLl/Hff/+V+PyzZ89iyZIl2LRpk6porl27dtixYweSk5MBACkpKbh58yYCAwOxe/duZGRkIC0tDXv37tXYzuL2AaDY/VStWhXJycl48OABMjMzsW/fvlK3VRxt27bF9u3b8eDBA9VrAKB37944cOAAzpw5g06dOhWyNyEh4ZXtpKWlwdLSEjY2Njh27Jgqh7vg/QBw+fJllC1bFpMmTWLnmGEY2cARZIZhZMPUqVNV0VofHx+MHDkSzZs3B0ARzCZNmmjcFu2tt97CmjVr0KBBA7i5uRVK0SiKlStXIiUlReXY+fr64qeffsK8efPQsWNH5ObmwtLSEqtWrUKLFi0wcOBAeHt7w9HRUZXSoAkeHh5F7qN27drw8fEpcj+WlpaYPXs2mjdvDicnJ7i7u5e4rWrVqhW7f09PT8yaNQutWrWCubk5mjRpgvXr16Ns2bJo06YNKlasCHNzcwBAbm4url27BgcHh1e2c+HCBVWUeP/+/ejXr98r9wNAhw4dULNmTUycOBGrV6+Gk5OTxu8dwzCMrjATBEGQ2giGYRhGPHPmzIGtrS2mTZum933l5ubCx8cH27dvh6urKwBydn/++WcsXbq0xNf6+PggNDQUlpaWrzw2Y8YM5OTk4NmzZ1i2bFmRz2EYhjE0HEFmGIZhSiQ6OhrdunVD7969Vc4xAHh5eZXqHANAeHh4sY8tWrRIJzYyDMPoEo4gMwzDMAzDMEwBuEiPYRiGYRiGYQrADjLDMAzDMAzDFIAdZIZhGIZhGIYpADvIDMMwDMMwDFMAdpAZhmEYhmEYpgDsIDMMwzAMwzBMAdhBZhiGYRiGYZgC/B/sHB5FPdQZLgAAAABJRU5ErkJggg==", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, "metadata": { @@ -678,7 +718,7 @@ "iir = sdr.IIR.ZerosPoles(zeros, poles)\n", "\n", "plt.figure(figsize=(10, 8))\n", - "iir.plot_all(N_time=30)\n", + "sdr.plot.filter(iir.b_taps, iir.a_taps, N_time=30)\n", "plt.show()" ] } diff --git a/docs/examples/phase-locked-loop.ipynb b/docs/examples/phase-locked-loop.ipynb index a243d2239..4cc0f4893 100644 --- a/docs/examples/phase-locked-loop.ipynb +++ b/docs/examples/phase-locked-loop.ipynb @@ -72,7 +72,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "\n" + "\n" ] } ], @@ -88,9 +88,9 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, "metadata": { @@ -101,7 +101,7 @@ ], "source": [ "plt.figure(figsize=(10, 5))\n", - "lf.iir.plot_frequency_response_log(decades=6)\n", + "sdr.plot.frequency_response(lf.iir.b_taps, lf.iir.a_taps, x_axis=\"log\", decades=6)\n", "plt.show()" ] }, @@ -234,7 +234,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 7, "metadata": {}, "outputs": [ { @@ -340,13 +340,19 @@ "name": "stderr", "output_type": "stream", "text": [ + "C:\\Users\\matth\\AppData\\Local\\Packages\\PythonSoftwareFoundation.Python.3.7_qbz5n2kfra8p0\\LocalCache\\local-packages\\Python37\\site-packages\\scipy\\signal\\filter_design.py:1632: BadCoefficients: Badly conditioned filter coefficients (numerator): the results may be meaningless\n", + " \"results may be meaningless\", BadCoefficients)\n", + "C:\\Users\\matth\\AppData\\Local\\Packages\\PythonSoftwareFoundation.Python.3.7_qbz5n2kfra8p0\\LocalCache\\local-packages\\Python37\\site-packages\\scipy\\signal\\filter_design.py:1632: BadCoefficients: Badly conditioned filter coefficients (numerator): the results may be meaningless\n", + " \"results may be meaningless\", BadCoefficients)\n", + "C:\\Users\\matth\\AppData\\Local\\Packages\\PythonSoftwareFoundation.Python.3.7_qbz5n2kfra8p0\\LocalCache\\local-packages\\Python37\\site-packages\\scipy\\signal\\filter_design.py:1632: BadCoefficients: Badly conditioned filter coefficients (numerator): the results may be meaningless\n", + " \"results may be meaningless\", BadCoefficients)\n", "C:\\Users\\matth\\AppData\\Local\\Packages\\PythonSoftwareFoundation.Python.3.7_qbz5n2kfra8p0\\LocalCache\\local-packages\\Python37\\site-packages\\scipy\\signal\\filter_design.py:1632: BadCoefficients: Badly conditioned filter coefficients (numerator): the results may be meaningless\n", " \"results may be meaningless\", BadCoefficients)\n" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -361,12 +367,8 @@ "plt.figure(figsize=(10, 5))\n", "for zeta in [1 / 2, 1 / np.sqrt(2), 1, 2]:\n", " pll = sdr.ClosedLoopPLL(0.01, zeta)\n", - " h = pll.iir.step_response(500)\n", - " plt.plot(h, label=rf\"$\\zeta = {zeta}$\")\n", - "plt.grid(which=\"both\", linestyle=\"--\")\n", + " sdr.plot.step_response(pll.iir.b_taps, pll.iir.a_taps, N=500, label=rf\"$\\zeta = {zeta}$\")\n", "plt.legend()\n", - "plt.xlabel(\"Sample\")\n", - "plt.ylabel(\"Amplitude\")\n", "plt.title(\"Step response of the closed-loop PLL across damping factor\")\n", "plt.show()" ] @@ -376,9 +378,23 @@ "execution_count": 9, "metadata": {}, "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "C:\\Users\\matth\\AppData\\Local\\Packages\\PythonSoftwareFoundation.Python.3.7_qbz5n2kfra8p0\\LocalCache\\local-packages\\Python37\\site-packages\\scipy\\signal\\filter_design.py:1632: BadCoefficients: Badly conditioned filter coefficients (numerator): the results may be meaningless\n", + " \"results may be meaningless\", BadCoefficients)\n", + "C:\\Users\\matth\\AppData\\Local\\Packages\\PythonSoftwareFoundation.Python.3.7_qbz5n2kfra8p0\\LocalCache\\local-packages\\Python37\\site-packages\\scipy\\signal\\filter_design.py:1632: BadCoefficients: Badly conditioned filter coefficients (numerator): the results may be meaningless\n", + " \"results may be meaningless\", BadCoefficients)\n", + "C:\\Users\\matth\\AppData\\Local\\Packages\\PythonSoftwareFoundation.Python.3.7_qbz5n2kfra8p0\\LocalCache\\local-packages\\Python37\\site-packages\\scipy\\signal\\filter_design.py:1632: BadCoefficients: Badly conditioned filter coefficients (numerator): the results may be meaningless\n", + " \"results may be meaningless\", BadCoefficients)\n", + "C:\\Users\\matth\\AppData\\Local\\Packages\\PythonSoftwareFoundation.Python.3.7_qbz5n2kfra8p0\\LocalCache\\local-packages\\Python37\\site-packages\\scipy\\signal\\filter_design.py:1632: BadCoefficients: Badly conditioned filter coefficients (numerator): the results may be meaningless\n", + " \"results may be meaningless\", BadCoefficients)\n" + ] + }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -393,15 +409,13 @@ "plt.figure(figsize=(10, 5))\n", "for zeta in [1 / 2, 1 / np.sqrt(2), 1, 2]:\n", " pll = sdr.ClosedLoopPLL(0.01, zeta)\n", - " omega, H = pll.iir.frequency_response_log(sample_rate=2 * np.pi)\n", - " omega /= pll.omega_n\n", - " plt.semilogx(omega, 20 * np.log10(np.abs(H)), label=rf\"$\\zeta = {zeta}$\")\n", - "plt.grid(which=\"both\", linestyle=\"--\")\n", + " sdr.plot.frequency_response(\n", + " pll.iir.b_taps, pll.iir.a_taps, sample_rate=2 * np.pi / pll.omega_n, x_axis=\"log\", label=rf\"$\\zeta = {zeta}$\"\n", + " )\n", "plt.legend()\n", "plt.xlim([10**-2, 10**2])\n", "plt.ylim([-25, 5])\n", "plt.xlabel(r\"Normalized Frequency ($\\omega / \\omega_n$)\")\n", - "plt.ylabel(\"Power (dB)\")\n", "plt.title(\"Frequency response of the closed-loop PLL across damping factor\")\n", "plt.show()" ] @@ -418,9 +432,25 @@ "execution_count": 10, "metadata": {}, "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "C:\\Users\\matth\\AppData\\Local\\Packages\\PythonSoftwareFoundation.Python.3.7_qbz5n2kfra8p0\\LocalCache\\local-packages\\Python37\\site-packages\\scipy\\signal\\filter_design.py:1632: BadCoefficients: Badly conditioned filter coefficients (numerator): the results may be meaningless\n", + " \"results may be meaningless\", BadCoefficients)\n", + "C:\\Users\\matth\\AppData\\Local\\Packages\\PythonSoftwareFoundation.Python.3.7_qbz5n2kfra8p0\\LocalCache\\local-packages\\Python37\\site-packages\\scipy\\signal\\filter_design.py:1632: BadCoefficients: Badly conditioned filter coefficients (numerator): the results may be meaningless\n", + " \"results may be meaningless\", BadCoefficients)\n", + "C:\\Users\\matth\\AppData\\Local\\Packages\\PythonSoftwareFoundation.Python.3.7_qbz5n2kfra8p0\\LocalCache\\local-packages\\Python37\\site-packages\\scipy\\signal\\filter_design.py:1632: BadCoefficients: Badly conditioned filter coefficients (numerator): the results may be meaningless\n", + " \"results may be meaningless\", BadCoefficients)\n", + "C:\\Users\\matth\\AppData\\Local\\Packages\\PythonSoftwareFoundation.Python.3.7_qbz5n2kfra8p0\\LocalCache\\local-packages\\Python37\\site-packages\\scipy\\signal\\filter_design.py:1632: BadCoefficients: Badly conditioned filter coefficients (numerator): the results may be meaningless\n", + " \"results may be meaningless\", BadCoefficients)\n", + "C:\\Users\\matth\\AppData\\Local\\Packages\\PythonSoftwareFoundation.Python.3.7_qbz5n2kfra8p0\\LocalCache\\local-packages\\Python37\\site-packages\\scipy\\signal\\filter_design.py:1632: BadCoefficients: Badly conditioned filter coefficients (numerator): the results may be meaningless\n", + " \"results may be meaningless\", BadCoefficients)\n" + ] + }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -435,12 +465,8 @@ "plt.figure(figsize=(10, 5))\n", "for BnT in [0.001, 0.005, 0.01, 0.05, 0.1]:\n", " pll = sdr.ClosedLoopPLL(BnT, 1)\n", - " h = pll.iir.step_response(500)\n", - " plt.plot(h, label=f\"$B_nT = {BnT}$\")\n", - "plt.grid(which=\"both\", linestyle=\"--\")\n", + " sdr.plot.step_response(pll.iir.b_taps, pll.iir.a_taps, N=500, label=f\"$B_nT = {BnT}$\")\n", "plt.legend()\n", - "plt.xlabel(\"Sample\")\n", - "plt.ylabel(\"Amplitude\")\n", "plt.title(\"Step response of the closed-loop PLL across normalized noise bandwidth\")\n", "plt.show()" ] @@ -450,9 +476,25 @@ "execution_count": 11, "metadata": {}, "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "C:\\Users\\matth\\AppData\\Local\\Packages\\PythonSoftwareFoundation.Python.3.7_qbz5n2kfra8p0\\LocalCache\\local-packages\\Python37\\site-packages\\scipy\\signal\\filter_design.py:1632: BadCoefficients: Badly conditioned filter coefficients (numerator): the results may be meaningless\n", + " \"results may be meaningless\", BadCoefficients)\n", + "C:\\Users\\matth\\AppData\\Local\\Packages\\PythonSoftwareFoundation.Python.3.7_qbz5n2kfra8p0\\LocalCache\\local-packages\\Python37\\site-packages\\scipy\\signal\\filter_design.py:1632: BadCoefficients: Badly conditioned filter coefficients (numerator): the results may be meaningless\n", + " \"results may be meaningless\", BadCoefficients)\n", + "C:\\Users\\matth\\AppData\\Local\\Packages\\PythonSoftwareFoundation.Python.3.7_qbz5n2kfra8p0\\LocalCache\\local-packages\\Python37\\site-packages\\scipy\\signal\\filter_design.py:1632: BadCoefficients: Badly conditioned filter coefficients (numerator): the results may be meaningless\n", + " \"results may be meaningless\", BadCoefficients)\n", + "C:\\Users\\matth\\AppData\\Local\\Packages\\PythonSoftwareFoundation.Python.3.7_qbz5n2kfra8p0\\LocalCache\\local-packages\\Python37\\site-packages\\scipy\\signal\\filter_design.py:1632: BadCoefficients: Badly conditioned filter coefficients (numerator): the results may be meaningless\n", + " \"results may be meaningless\", BadCoefficients)\n", + "C:\\Users\\matth\\AppData\\Local\\Packages\\PythonSoftwareFoundation.Python.3.7_qbz5n2kfra8p0\\LocalCache\\local-packages\\Python37\\site-packages\\scipy\\signal\\filter_design.py:1632: BadCoefficients: Badly conditioned filter coefficients (numerator): the results may be meaningless\n", + " \"results may be meaningless\", BadCoefficients)\n" + ] + }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -467,13 +509,9 @@ "plt.figure(figsize=(10, 5))\n", "for BnT in [0.001, 0.005, 0.01, 0.05, 0.1]:\n", " pll = sdr.ClosedLoopPLL(BnT, 1)\n", - " f, H = pll.iir.frequency_response_log(sample_rate=1)\n", - " plt.semilogx(f, 20 * np.log10(np.abs(H)), label=f\"$B_nT = {BnT}$\")\n", - "plt.grid(which=\"both\", linestyle=\"--\")\n", + " sdr.plot.frequency_response(pll.iir.b_taps, pll.iir.a_taps, x_axis=\"log\", label=f\"$B_nT = {BnT}$\")\n", "plt.legend()\n", "plt.ylim([-25, 5])\n", - "plt.xlabel(\"Normalized Frequency ($f / f_s$)\")\n", - "plt.ylabel(\"Power (dB)\")\n", "plt.title(\"Frequency response of the closed-loop PLL across normalized noise bandwidth\")\n", "plt.show()" ] @@ -490,6 +528,14 @@ "execution_count": 12, "metadata": {}, "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "C:\\Users\\matth\\AppData\\Local\\Packages\\PythonSoftwareFoundation.Python.3.7_qbz5n2kfra8p0\\LocalCache\\local-packages\\Python37\\site-packages\\scipy\\signal\\filter_design.py:1632: BadCoefficients: Badly conditioned filter coefficients (numerator): the results may be meaningless\n", + " \"results may be meaningless\", BadCoefficients)\n" + ] + }, { "data": { "image/png": "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", From 508f98be3496874d3e7b30e2352487ee69152ea2 Mon Sep 17 00:00:00 2001 From: mhostetter Date: Wed, 12 Jul 2023 21:23:07 -0400 Subject: [PATCH 18/20] Suppress `scipy` warning about leading zeros in the numerator `BadCoefficients: Badly conditioned filter coefficients (numerator): the results may be meaningless "results may be meaningless", BadCoefficients)` --- src/sdr/_pll.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/src/sdr/_pll.py b/src/sdr/_pll.py index 4ce0c8550..05c7b8f7b 100644 --- a/src/sdr/_pll.py +++ b/src/sdr/_pll.py @@ -92,7 +92,8 @@ def __init__( a2 = 1 - Kp * K0 * K1 # Create an IIR filter that represents the closed-loop transfer function of the PLL - self._iir = IIR([b0, b1, b2], [a0, a1, a2]) + # self._iir = IIR([b0, b1, b2], [a0, a1, a2]) + self._iir = IIR([b1, b2], [a0, a1, a2]) # Suppress warning about leading zero self._sample_rate = sample_rate self._BnT = noise_bandwidth From 2bbaf51c76d706b9b5614e168fca4772dd703bb7 Mon Sep 17 00:00:00 2001 From: mhostetter Date: Wed, 12 Jul 2023 21:23:37 -0400 Subject: [PATCH 19/20] Update examples --- docs/examples/iir-filter.ipynb | 4 +- docs/examples/phase-locked-loop.ipynb | 74 ++------------------------- 2 files changed, 5 insertions(+), 73 deletions(-) diff --git a/docs/examples/iir-filter.ipynb b/docs/examples/iir-filter.ipynb index 24264a0d1..27d8140f4 100644 --- a/docs/examples/iir-filter.ipynb +++ b/docs/examples/iir-filter.ipynb @@ -51,7 +51,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "\n" + "\n" ] } ], @@ -439,7 +439,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "\n" + "\n" ] } ], diff --git a/docs/examples/phase-locked-loop.ipynb b/docs/examples/phase-locked-loop.ipynb index 4cc0f4893..e8614ccb9 100644 --- a/docs/examples/phase-locked-loop.ipynb +++ b/docs/examples/phase-locked-loop.ipynb @@ -72,7 +72,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "\n" + "\n" ] } ], @@ -336,23 +336,9 @@ "execution_count": 8, "metadata": {}, "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "C:\\Users\\matth\\AppData\\Local\\Packages\\PythonSoftwareFoundation.Python.3.7_qbz5n2kfra8p0\\LocalCache\\local-packages\\Python37\\site-packages\\scipy\\signal\\filter_design.py:1632: BadCoefficients: Badly conditioned filter coefficients (numerator): the results may be meaningless\n", - " \"results may be meaningless\", BadCoefficients)\n", - "C:\\Users\\matth\\AppData\\Local\\Packages\\PythonSoftwareFoundation.Python.3.7_qbz5n2kfra8p0\\LocalCache\\local-packages\\Python37\\site-packages\\scipy\\signal\\filter_design.py:1632: BadCoefficients: Badly conditioned filter coefficients (numerator): the results may be meaningless\n", - " \"results may be meaningless\", BadCoefficients)\n", - "C:\\Users\\matth\\AppData\\Local\\Packages\\PythonSoftwareFoundation.Python.3.7_qbz5n2kfra8p0\\LocalCache\\local-packages\\Python37\\site-packages\\scipy\\signal\\filter_design.py:1632: BadCoefficients: Badly conditioned filter coefficients (numerator): the results may be meaningless\n", - " \"results may be meaningless\", BadCoefficients)\n", - "C:\\Users\\matth\\AppData\\Local\\Packages\\PythonSoftwareFoundation.Python.3.7_qbz5n2kfra8p0\\LocalCache\\local-packages\\Python37\\site-packages\\scipy\\signal\\filter_design.py:1632: BadCoefficients: Badly conditioned filter coefficients (numerator): the results may be meaningless\n", - " \"results may be meaningless\", BadCoefficients)\n" - ] - }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -378,20 +364,6 @@ "execution_count": 9, "metadata": {}, "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "C:\\Users\\matth\\AppData\\Local\\Packages\\PythonSoftwareFoundation.Python.3.7_qbz5n2kfra8p0\\LocalCache\\local-packages\\Python37\\site-packages\\scipy\\signal\\filter_design.py:1632: BadCoefficients: Badly conditioned filter coefficients (numerator): the results may be meaningless\n", - " \"results may be meaningless\", BadCoefficients)\n", - "C:\\Users\\matth\\AppData\\Local\\Packages\\PythonSoftwareFoundation.Python.3.7_qbz5n2kfra8p0\\LocalCache\\local-packages\\Python37\\site-packages\\scipy\\signal\\filter_design.py:1632: BadCoefficients: Badly conditioned filter coefficients (numerator): the results may be meaningless\n", - " \"results may be meaningless\", BadCoefficients)\n", - "C:\\Users\\matth\\AppData\\Local\\Packages\\PythonSoftwareFoundation.Python.3.7_qbz5n2kfra8p0\\LocalCache\\local-packages\\Python37\\site-packages\\scipy\\signal\\filter_design.py:1632: BadCoefficients: Badly conditioned filter coefficients (numerator): the results may be meaningless\n", - " \"results may be meaningless\", BadCoefficients)\n", - "C:\\Users\\matth\\AppData\\Local\\Packages\\PythonSoftwareFoundation.Python.3.7_qbz5n2kfra8p0\\LocalCache\\local-packages\\Python37\\site-packages\\scipy\\signal\\filter_design.py:1632: BadCoefficients: Badly conditioned filter coefficients (numerator): the results may be meaningless\n", - " \"results may be meaningless\", BadCoefficients)\n" - ] - }, { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAnUAAAFVCAYAAACJsxn/AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/NK7nSAAAACXBIWXMAAAsTAAALEwEAmpwYAADONUlEQVR4nOydd3wU1deHn93NpvdAIAkhQGgh9I7SBfRFxAKCWABB7Aoq/lSKYMGCICgWxIIVUOwFUUFEEBTpJdQQCCkkhJBed/e+f8SsgWx2Z2Znk02c52M+mD3nfs/ZvWfv3MzcuaMTQgg0NDQ0NDQ0NDTqNfq6TkBDQ0NDQ0NDQ8N5tEmdhoaGhoaGhkYDQJvUaWhoaGhoaGg0ALRJnYaGhoaGhoZGA0Cb1GloaGhoaGhoNAC0SZ2GhoaGhoaGRgNAm9RpaGjI5s0336RJkyb4+/tz/vx5h/7vv/8+/fv3d3leOp2OEydOuDxOJY7e1+TJk5kzZ06t5aNhn1OnTqHT6TCZTLUeOz4+nt9++80l2nPmzKFRo0Y0bdrUJfoa9QdtUqchiRYtWuDj44O/v7/1Jy0tra7T0qgDysvLefjhh/n5558pKCggLCzsIntdHjg14LfffkOv1+Pv709AQADt2rVj5cqVgP2+mT9/Prfeemttp/uf4dChQwwePFh13eTkZBYvXkxCQgJnz55VrKN9bxsGHnWdgEb94bvvvmPYsGE12k0mEx4e/52S+q+930oyMjIoKSkhPj6+rlPRqIHIyEhSUlIQQvDNN98wduxY+vTpg6+vb12nZuW/+v1Rm+TkZMLCwggPD6/TPLT+dA+0M3UaTqHT6Xj99ddp06YNbdq0AeD777+na9euBAcHc9lll7F//36r/549e+jevTsBAQGMHz+em266yXp5ytalrKqX00pLS5k5cybNmzenSZMm3H333RQXFwMVZyeaNWvG4sWLCQ8PJyIiwnp2AqC4uJhHHnmEmJgYgoKC6N+/P8XFxVx99dUsW7bsopidO3fmq6++qvZeK/+Sfffdd2nevDlDhw4F4L333iMuLo6QkBCuvPJKTp8+DYAQgoceeojw8HACAwPp1KkTBw8eBCouy919990MHz6cgIAABg0aZG0HsG3bNnr16kVQUBC9evVi27ZtVtvgwYOZO3cul19+OQEBAYwYMYKsrCwASkpKuPXWWwkLCyM4OJhevXqRkZEBQG5uLlOnTiUiIoKoqCjmzJmD2Wy22a+lpaXMmDGDyMhIIiMjmTFjBqWlpRw7dox27doBEBwcbP0MqjJw4ECr3d/fn+3bt1ttM2fOJCQkhJYtW/Ljjz9aX5eTm9ls5rnnniM2NpaAgAB69OjBmTNnqvnl5uYyceJEGjduTExMDM8++ywWiwWAEydOMGjQIIKCgmjUqBHjx4+3tjty5AjDhw8nNDSUdu3a8dlnn1lt58+fZ/To0QQGBtK7d28SExNt5lgTb7/9Nq1btyY0NJTRo0dfdLbbUZ8/8cQT9O7dm8DAQK699lqys7MdxtPpdFx33XWEhISQkJAgK1d7TJ8+nejoaAIDA+nRowdbtmyx2uz1j63xoqbPxN73Z926dXTo0IGAgACioqJYtGiRzTzNZjMzZ86kUaNGtGrVih9++OEi+8qVK4mLiyMgIIBWrVrx1ltvWW2VY8rChQutY8rXX3/NunXraNu2LaGhoTz33HNW//nz5zN27FjGjx9PQEAA3bt3Z9++fVZ7ixYt2LBhg9V33LhxTJw4kYCAAOLj49m5c6fVd/fu3XTr1o2AgABuvPFGxo8fb/My/oYNGxg+fDhpaWn4+/szefJkAG688UaaNm1KUFAQAwcO5NChQ9Y2NY2Ftr63FouFZ599lpiYGMLDw5k4cSK5ublAzeOhRh0jNDQkEBMTI3755ZdqrwNi2LBh4vz586KoqEjs3r1bNG7cWPz555/CZDKJ999/X8TExIiSkhJRWloqmjdvLl5++WVRVlYm1q5dKzw8PMTs2bOFEEKsXLlSXH755dX0jx8/LoQQYsaMGeKaa64R58+fF3l5eWLUqFHi8ccfF0IIsWnTJmEwGMTcuXNFWVmZ+OGHH4SPj4/Izs4WQghx7733ikGDBomUlBRhMpnEH3/8IUpKSsSnn34qevfubY23d+9eERoaKkpLS6u916SkJAGI2267TRQUFIiioiLx9ddfi9jYWJGQkCDKy8vFM888I/r16yeEEGL9+vWie/fu4sKFC8JisYiEhASRlpYmhBBi0qRJwt/fX2zevFmUlJSIBx980Prez58/L4KDg8WHH34oysvLxapVq0RwcLDIysoSQggxaNAg0apVK3H06FFRVFQkBg0aJB577DEhhBDLly8Xo0aNEoWFhcJkMomdO3eK3NxcIYQQ1113nbjzzjtFQUGByMjIEL169RLLly+32d9z584Vffr0ERkZGSIzM1P069dPzJkz56LPoby83GZbW/aVK1cKDw8PsWLFCmEymcQbb7whIiIihMVikZ3bwoULRceOHcWRI0eExWIRe/futX42VevltttuE6NHjxZ5eXkiKSlJtGnTRrzzzjtCCCFuuukm8eyzzwqz2SyKi4vFli1bhBBCFBQUiGbNmon33ntPlJeXi927d4uwsDBx6NAhIYQQ48ePFzfeeKMoKCgQBw4cEJGRkdVqtiqTJk2y1vfGjRtFWFiY2LVrlygpKRH333+/GDBggOQ+j4yMFAcOHBAFBQXihhtuELfccovNmJs2bRJRUVFCCCHMZrP48ssvhYeHhzhy5Ijdvps3b16Nmpfy0UcfiaysLFFeXi4WLVokmjRpIoqLiyX1T9Xxwt5nYu/707RpU/H7778LIYTIzs4Wu3btspnnm2++Kdq1ayeSk5PF+fPnxeDBgy96/99//704ceKEsFgs4rfffhM+Pj5Wrcox5amnnhJlZWVixYoVolGjRmLChAkiLy9PHDx4UHh7e4uTJ09aPz8PDw+xdu1aUVZWJl566SXRokULUVZWJoS4eAydN2+e8PLyEj/88IMwmUzi8ccfF3369BFCCOs4uXTpUlFWVia++OILYTQarXVkr78reffdd0VeXp4oKSkR06dPF126dLHaahoLbdXGu+++K2JjY0ViYqLIz88X119/vbj11luFELbHQ426R5vUaUgiJiZG+Pn5iaCgIBEUFCSuvfZaIUTFIL1x40ar39133209+FfStm1b8dtvv4nNmzdfdCAXQoh+/fpJmtRZLBbh6+srTpw4YbVt27ZNtGjRQghRMbB5e3tfNCA1btxYbN++XZjNZuHt7S327t1b7X0VFxeL4OBgcezYMSGEEI888oi45557bH4GlYNYYmKi9bWrrrrKOlEQouIg6uPjI06dOiU2btwo2rRpY82hKpMmTRLjx4+3/p6fny/0er1ITk4WH374oejVq9dF/n379hUrV64UQlQc4J955hmr7fXXXxdXXnmlEKJiEO7Xr5/Yt2/fRe3Pnj0rPD09Lxp4V61aJQYPHmzzvbZq1Ur88MMP1t/Xr18vYmJiLvoc5E7qYmNjrb8XFhYKQKSnp8vOrW3btuLrr7+2aausF5PJJIxGo3UyJkTFhHfQoEFCiIoJ37Rp08SZM2cuar9mzRrRv3//i1678847xfz584XJZBIeHh7i8OHDVtsTTzwheVI3ZcoU8eijj1pt+fn5wsPDQyQlJUnq88qJuxBCHDp0SBiNRmEymarF3LRpk9DpdCIoKEiEhISILl26iNWrVwsh7PednEndpQQHB1u/X476p+p4Ye8zsff9iY6OFsuXL7f+wVITQ4YMEW+++ab1959++slu7V577bVi6dKlQoh/x5TKzzgvL08A4s8//7T6d+/eXXz11VdCiIrPr3JiJkTFWFB18nnppO6KK66w+h46dEh4e3sLIYTYvHmziIyMvGicvPzyy2VN6qpy4cIFAYicnBy7Y6Gt2hg6dKh4/fXXrb8fOXJEeHh4iPLycpvjoUbdo11+1ZDM119/TU5ODjk5OXz99dfW16Ojo63/f/r0aRYvXkxwcLD158yZM6SlpZGWlkZUVBQ6nc7qHxMTIyn2uXPnKCoqokePHlbdq666inPnzll9wsLCLlrT4evrS0FBAVlZWZSUlBAbG1tN19vbm/Hjx/Pxxx9jsVhYvXo1t912m91cLn2/06dPt+YUGhqKEILU1FSGDh3K/fffz3333Ud4eDh33nkneXl5NnX8/f0JDQ21fk6Xfi4xMTGkpqZaf696l1vl+wS47bbbuPLKK7npppuIjIzkf//7H+Xl5Zw+fZry8nIiIiKsud51111kZmbafI+X5hATE+P0jTGX5gxQUFAgO7czZ87Y7MuqZGVlUV5eXu09VH6GCxcuRAhB7969iY+P57333gMq+vOvv/66qH4/+eQTzp49y7lz5zCZTBf1W1X95557znoT0d13310tp0s/U39/f8LCwkhNTZXU55fGLS8vt152v5TIyEhycnLIzs5m79693HTTTXY/L7ksWrSIuLg4goKCCA4OJjc315qLo/6p+j7sfSb2vj9ffPEF69atIyYmhkGDBl10ib8qaWlpNfYXwI8//kjfvn0JDQ0lODiYdevWXfSZhoWFYTAYAPDx8QGgSZMmVruPj4/1u3fpe9Pr9TRr1qzG782l34eSkhJMJpPNcbKqriPMZjOPP/44sbGxBAYG0qJFC6DiO2FvLLSFrXHAZDJZl3TIzU3D9WiTOg2nuXTwmT17tnXyl5OTQ1FRERMmTCAiIoLU1FSEEFb/5ORk6//7+flRVFRk/b3qnVyNGjXCx8eHQ4cOWXVzc3MvGlBrolGjRnh7e9e4/mnSpEl88sknbNy4EV9fX/r16yfr/b711lsXvd/i4mIuu+wyAB588EF27dpFQkICx44d46WXXrK2rboOrKCggOzsbOsatqrr66Dic4qKinL4Xo1GI/PmzSMhIYFt27bx/fff8+GHHxIdHY2XlxdZWVnWPPPy8i5aa1OVS3NITk4mMjLSYfxLPx8pyM0tOjra4Vq2Ro0aYTQaq72Hys+wadOmvP3226SlpfHWW29x7733cuLECaKjoxk0aNBF/VlQUMCbb75J48aN8fDwuKjfqtbvrFmzKCgooKCggOXLl1fL6dLPtLCwkPPnzxMVFSWpzy+NazQaadSokd3PwRVs2bKFhQsX8tlnn3HhwgVycnIICgqyfq8d9U/V+rD3mUDN359evXrxzTffkJmZyXXXXce4ceNsxoqIiKixv0pLSxkzZgwzZ84kIyODnJwcRo4cedH4JJeqsSwWCykpKZK/N1VzvnSctLVmtCZWrVrFN998w4YNG8jNzeXUqVNAxRpFe2Ohre+trXHAw8Pjoomt3O+7hmvRJnUaqjJt2jSWL1/OX3/9hRCCwsJCfvjhB/Lz8+nXrx8eHh68+uqrlJeX8+WXX7Jjxw5r2y5dunDo0CH27t1LSUkJ8+fPt9r0ej3Tpk3joYcesp7BSU1N5aeffnKYk16vZ8qUKTz88MOkpaVhNpvZvn07paWlAPTr1w+9Xs8jjzzi8Czdpdx99908//zz1glIbm4ua9euBeDvv//mr7/+ory8HD8/P7y9vdHr//3KrVu3jq1bt1JWVsbcuXPp27cv0dHRjBw5kmPHjrFq1SpMJhOffvopCQkJjBo1ymE+mzZt4sCBA5jNZgIDAzEajej1eiIiIhgxYgSPPPIIeXl5WCwWEhMT2bx5s02dCRMm8Oyzz3Lu3DmysrJ4+umnJW930bhxY/R6PSdPnpTkLze3O+64g7lz53L8+HGEEOzfv7/aXnkGg4Fx48Yxe/Zs8vPzOX36NC+//LL1Paxdu5aUlBQAQkJC0Ol06PV6Ro0axbFjx/joo48oLy+nvLycv//+m8OHD2MwGLjhhhuYP38+RUVFJCQk8MEHH0h6j1Dxma5cuZK9e/dSWlrKrFmz6NOnDy1atJDU5x9//DEJCQkUFRXx5JNPMnbsWOtZJLmUlpZSUlJi/am8gcRisVz0euV3pCr5+fl4eHjQuHFjTCYTTz/99EVnoKX0j5TPpKbvT1lZGZ988gm5ubkYjUYCAwMv+l5VZdy4cbz66qukpKRw4cIFXnjhBautrKyM0tJS62T9xx9/5Oeff1b0eVaya9cuvvzyS0wmE0uXLsXLy4u+ffvK0ujXrx8Gg4HXXnsNk8nEN998c9E46Yj8/Hy8vLwICwujqKiIWbNmWW32xkJb39sJEyawZMkSkpKSKCgoYNasWYwfP167y9WN0SZ1GqrSs2dP3n77be6//35CQkJo3bo177//PgCenp58+eWXvP/++4SGhvLpp59yww03WNu2bduWJ598kmHDhtGmTZtqd8K++OKLtG7dmr59+xIYGMiwYcM4evSopLwWLVpEp06d6NWrF6GhoTz22GPWAxnAxIkTOXDggOx9uq6//noee+wxbrrpJgIDA+nYsaP1rs68vDymTZtGSEgIMTExhIWF8eijj1rb3nzzzTz11FOEhoaya9cuPv74Y6Diks/333/P4sWLCQsLY+HChXz//feSzsqcPXuWsWPHEhgYSFxcHIMGDbJOVD/88EPKysro0KEDISEhjB07lvT0dJs6c+bMoWfPnnTu3JlOnTrRvXt3yZvo+vr6Mnv2bC6//HKCg4P5888/HbaRk9vDDz/MuHHjGDFiBIGBgUydOtV6F3RVli1bhp+fH61ataJ///7cfPPNTJkyBaiYcPfp0wd/f39Gjx7NK6+8QqtWrQgICODnn39mzZo1REZG0rRpUx577DHr5Oa1116joKCApk2bMnnyZG6//XZJnwnAsGHDeOaZZxgzZgwREREkJiayZs0aQFqf33bbbUyePJmmTZtSUlLCq6++Kjn2pfj7++Pj42P9+fXXXwFYvXr1Ra/bukx35ZVXctVVV9G2bVtiYmLw9va+6BKc1P5x9JnY+/589NFHtGjRgsDAQJYvX84nn3xiU3/atGlceeWVdOnShe7du1803gQEBPDqq68ybtw4QkJCWLVqFaNHj1b2gf7Dtddey6effkpISAgfffQRX375JUajUZZG5Tj57rvvEhwczMcff8yoUaPw8vKS1H7ixInExMQQFRVFhw4dqk0qaxoLbX1vp0yZwm233cbAgQNp2bIl3t7e1XYL0HAvdMKZc80aGk4yefJkmjVrxrPPPluneXz44YesWLGCrVu31ko8d3nfGvWDwYMHc+utt3LHHXfUdSoaNTB//nxOnDhh/eNMTfr06cPdd98t648Ijf8m2pk6jf88RUVFvPHGG9x55511nYqGhoYGmzdv5uzZs5hMJj744AP279/PVVddVddpadQD6t2F8RYtWhAQEIDBYMDDw+OiDRs1NOTy008/ccMNNzBs2DBuvvnmuk5HQ0NDg6NHjzJu3DgKCwtp1aoVn3/+OREREXWdlkY9oN5dfm3RogU7d+6sk7u+NDQ0NDQ0NDTcFe3yq4aGhoaGhoZGA6DeTep0Oh0jRoygR48erFixoq7T0dDQ0NDQ0NBwC+rdmrqtW7cSFRVFZmYmw4cPp3379tYHEQOsWLHCOtlLSEiw7qZduV9X5dYEBoMBLy+viza7rdzVu3KrC29vb0wmEyaTCai41Vyn012k4enpab1dX6fT4ePjc5GGj48P5eXlF2lAxR5JgHW/n0p7pUZxcbF180kpGkaj0ZqHXq/H29v7Ig0PDw+EENaHpHt5eSGEuEjDw8ODkpKSizSqfj5GoxGLxXKRhsVioby83Go3GAzVNAoKCqz7SNn6jM1ms1VDr9djNBrt9pPRaMRsNtfYT7Y0KvvJYrFgMBhs9lNJSYn183L0Gbuqn3x8fCgrK7PbT1X70VY/+fr6UlpaKrufKjUsFgv+/v52+0nK98lRP9n6Pul0umrfhZq+TxaLBW9vb4f95OHhgclkqrGf9Ho9Hh4eNjUsFgseHh4u+T4520+VGs5+n5wd94QQ+Pn5yR73qvZTpYbc7xNwUT/a+z5ZLBZ8fHzs9lNlHjX1U6WGrX4qKipCr9fXOHZe+l2Q+32qjeOTve9CVQ2l415N3ycp456cfqrUqNpPOp0OLy8vSd8nk8lktdvrp8o2NfVT5VYxtvqpuLgYvV5frZ8yMzNrfFKMFOrdmrqqzJ8/H39/f2bOnGnT3qNHD3bt2lXLWcmnpKTEenBy5xhKNeS0k+LryMeeXanNnXB1nmrpK9FRu1ak+CmpCa1W1I2hjS3ugTa2yPN1Rb307NnTqRtA69Xl18LCQvLz863///PPP9OxY8ca/Stn1+5OTc+4dLcYSjXktJPi68jHnl2pzZ1wdZ5q6SvRUbtWpPgpqQmtVtSNoY0t7oE2tsjzdVW9OEO9mtRlZGTQv39/unTpQu/evbn66qvt7t1TebrT3an6UHp3jqFUQ047Kb6OfOzZldrcCVfnqZa+Eh21a0WKn5Ka0GpF3Rja2OIeaGOLPF9X1Ysz1Ks1da1atWLfvn11nYaGhoaGhoaGhttRr9fUOaJr167s3bu3rtNwSFZWlsv33VMjhlINOe2k+DrysWdXanMnXJ2nWvpKdNSuFSl+SmpCqxV1Y9TG2JKRkUFRUZF1obwtzGYzBoNBkV2pzZ1wdZ5q6SvRkdNGqq8z9aLX62nVqlW1ZwM7u6auXp2pa6hU3hnq7jGUashpJ8XXkY89u1KbO+HqPNXSV6Kjdq1I8VNSE1qtqBujNsaW3NxcQkNDadGiBTqdzqaPyWSy3lUr167U5k64Ok+19JXoyGkj1VdpvQghyMzMJCUlhZYtW0rKSSr1Y2RSSOXt0O5OUlJSvYihVENOOym+jnzs2ZXa3AlX56mWvhIdtWtFip+SmtBqRd0YtTG2FBUVERYWVuOEDrhoqwq5dqU2d8LVeaqlr0RHThupvkrrRafTWbcBUpsGPanT0NDQ0NCAigOpvQmdhkZt4qpabNCTuvpwuhsgLCysXsRQqiGnnRRfRz727Ept7oSr81RLX4mO2rUixU9JTWi1om6M2hhbpFyqdXTMsGdXanMnXJ2nWvpKdOS0kerrqnpxhgY9qbt0AaK7EhkZWS9iKNWQ006KryMfe3alNnfC1Xmqpa9ER+1akeKnpCa0WlE3Rm2MLVIWvjs6ZtizK7W5E67OUy19JTpy2kj1dVW9OEODntRVPnbD3Tlw4EC9iKFUQ047Kb6OfOzZldrcCVfnqZa+Eh21a0WKn5Ka0GpF3Ri1MbZI2Yze0THDnl2qbfXq1XTt2pVOnTqh0+no1q2bw7wuZf369bRr147WrVvzwgsv1OjXokULOnXqRNeuXenZs6dDXVcfM9XSV6Ijp41UX1fVizM06EmdhoaGhoaGOzFhwgTWrl1LQEAAU6dO5YcffpDV3mw2c9999/Hjjz+SkJDA6tWrSUhIqNF/06ZN7N2716ltMjTqD/XjQr9C6suiWC8vr3oRQ6mGnHZSfB352LMrtbkTrs5TLX0lOmrXihQ/JTWh1Yq6MWpjbJFCbWyXdOjQIcaOHcuSJUvsPhGpJnbs2EHr1q1p1aoVADfddBPffPMNHTp0kK1lL09XoG2XpCwfOTTozYed3cRPQ0Oj4VJSbmbvmRwOpuaSlFVIak4xxWVmys0WQnw9aRzgRZsmAfSMCaFTVBB6ff34I1HDNocPHyYuLq5OcygvL6dv374sXbqUAQMGVLMPGDDA+nzzqixatIhhw4YB8Pnnn7N+/XreeecdAD766CP++usvXnvttWrtWrZsSUhICDqdjrvuuos777xT5Xek4Qy2alLbfNgO9WVN3cGDB+nYsaPbx1CqIaedFF9HPvbsSm3uhKvzVEtfiY7atXKp3/mCUn46lMG6A+nsSMqmzGwBIMjHSHSoD36eHvh6enA2r4R9KTms+fsMAE0DvbmuWxSTLoshIshHqxWVY9TG2FJ139KnvjtEQlpeNR+LxWL3DIo9e9twX565votNW3FxMT4+Pqxfv574+HibEzqALVu22HsLstm6dStRUVFkZmYyfPhw2rdvz8CBA2v0r8zTVailr0RHThupvo787NldNT9p0JO6+nISsjY2plQjhlINtTd91DYI1TYIleNbXFLCb0cz+fjP02w6eg6zRdAizJfb+sXQt1UYhpxkhl7Wy2bbX7buoMAvkh/2p7Pi90Te2XKSW/o0Z0jj+vEHoza2yMXRMaNmu73jjcVS8cfDjh07GDJkSI1+Us7URUVFcebMGastJSWFqKgom3qVr4eHh3P99dezY8cOu5O6yjxdhVr6SnTktJHq68jPnt1Vn3WDntRpaGj8dykpN7Pqr2Te2pRFRmEGjfw9uXNgK67pHElcRIB1ze2uXSk1aoT6GBjerRnXd2vGmewilm9O5KM/T/OFUccL/mmM6lw/tjbRuJh518TbfL2wsBA/P78a29mzFxYWOowbEBDA9u3buf32223apZyp69WrF8ePHycpKYmoqCjWrFnDqlWrbOZjsVgICAigsLCQn3/+mSeffNKhvkb9pkGvqevRowe7du2q6zQcUlZWhqenp9vHUKohp50UX0c+9uxKbe6Eq/NUS1+Jjhq1UlJu5pO/klm+OZFz+aX0aB7MpMtbclV8Uzw9ql86k1sTR8/mM3PtXg6k5jGuZzOeua4jXh7u+bB2bWz5l4SEBIc3Ezhz+VWK7cKFC0yZMoUjR44QGxvLJ598QlBQkKT8q7Ju3TpmzJiB2WxmypQpzJ4922obOXIk77zzDiUlJVx//fVAxTNIb7755ov85L4HNVBLX4mOnDZSfZ2tl6NHj6q+pq5Bb2kiZV8idyAtLa1exFCqIaedFF9HPvbsSm3uhKvzVEtfiY4ztVJSbua9rUkMWLiJZ75PoHVjfz69sy+LR0YxukukzQmdo5i2bO2aBrDk6mbcP6Q1n+1M4dZ3/uJ8gXteutfGln8xm80OfRwdM+zZpdhCQkL46quvOHz4MEIIjhw54jAnW4wcOZJjx46RmJhYbaK2bt06IiMjadWqFfv27WPfvn0cOnTI4YTO0XtQA7X0lejIaSPV11X14gwNelJnMpnqOgVJnD9/vl7EUKohp50UX0c+9uxKbe6Eq/NUS1+JjpJaKSk38/4fSQxcuImnv0+gVSM/1tzZl9V39qVPqzCX1EvuhWxmXtmOVyd0Y39KLje8uY20HPdbZ6eNLf8iZQ2To2OGPbsc2yeffEJYWBi9etley1lXuPqYqZa+Eh05baT6uqpenEFbU6ehoVEvKTMLPth2ijd+O0FGXim9W4byyk3d6Bdbe89lHd0lkqhgHya/t4ObVvzJ6jv7EhXsursHNRoGt9xyC7fccktdp6HRAGnQZ+rqw/ooqNhLqD7EUKohp50UX0c+9uxKbe6Eq/NUS1+JjpQ2pSYzH20/xfSfLzDv20M0D/Vl1R19+PTOvjYndK6ol6qv94gJ4aM7+nChqIybVmwnM7/E4XuoLbSx5V+kPEBd29hc29hcjq+r6sUZtDN1boCrbyNXK4ZSDbVvJXfVbeS10Q9q8F/ddqDUZOaznSm8sekE6bkldInyZ8lN3bgsNszu02NcUS+Xvt41OpiPpvZhwoo/mfL+33x6Zz/8vOp+eNXGln+Rck+gIx97dqU2d8LVeaqlr0RHThupvq6qF2do0Gfqqm426c6cPn26XsRQqiGnnRRfRz727Ept7oSr81RLX4mOrTaVZ+aGvPQbc78+SGSwDx9P7cPcfn5c3rqRw8cBuqJebL3eNTqY12/pRkJaHvet2o3JXPd/JGhjy79IuVHC0THDnl2pzZ1wdZ5q6SvRkdNGqq+r6sUZ6v5PSQ0NDQ0blJSbWbMjmeWbT3I2r4TuzYN5YUxnBrSpmMjt2iXxgC7MkJcGuamQnwal+VBWBOVFgCA8/RyIfeDXGPybQlAUBESAgmdHD23fhGev68Ssrw7w0s9HeeL/6vaxVBoaGv8tGvSkTsoaCnegcePG9SKGUg057aT4OvKxZ1dqcydcnada+kp0GjdubN00ePnmRDLzS+ndIpTF47pUu8xaTd9igexEyDgIGQmQcQgyE+iecwa+r/lOs2iAQ5e86B0E4fG0CYgF/3PQ4nLwCpD03m7u05xDabm8tfkk3aJDuKpjUxmfgLpoY8u/SNl3zNExw55dqc2dcHWeaukr0ZHTRqqvq+rFGepHpSnEaDTWdQqSCA8PrxcxlGrIaSfF15GPPbtSmzvh6jzV0perk11YxueHC1n14a9kFZTRt1UoS2/qSr9WttfMhYf4Q9IWOPPXPz87oCSnwqjTQ1gbiOyKuf1oPEJjIDAKAiMrJmyefmD0AXSUFObibRBQeA7yMyDnNGQehoyDBBxdC4c+Ar0HtBgAnW6EuFEO39uT13TgYGouj67dR7umAbRsVPNTClyJNrb8i8HgeINoR8cMe3alNnfC1Xmqpa9ER04bqb6uqhdnaNBr6lz1wFy1OXTo0tME7hlDqYacdlJ8HfnYsyu1uROuzlMtfak6p7IKmfv1QS57YSOvbjpJp6ggPr2zL2vu7MdlsVXWzFkskLYHtiyGlVfj+XIb+GAU/PoMXDgNHUbD6Nfgrt9hVjrcvwNufJ99ja6FXlOh3VUQ0RlCYsCvUcXEztOXQyfTKiZ7EV2g7QjoPQ1GvQxTf2bPiK9h4rdw2QNwIQm+uRdeakPBJ5MrzgbWgJeHgTdu7YGHQcc9H++ipNzxei5XoI0t/yJls1dHxwx7dqU2d8LVeaqlr0RHThupvq6qF2do0GfqNDQ03BMhBH+ezOaDbaf4KeEsRr2e67pF0i+0mOuH9v7XMS8dEn+t+Dm5CYr+2Wy2aScyW42hae8bILo3+Ia6Jk+DJ7TqB60GwRXzIHUX7PmY0D2r4M0fIfYKGDobonpUaxsV7MPL47ty+8q/WfTTUeaMsv+IKg0NDQ1nadBn6lz5DDs18fFx/WalasRQqiGnnRRfRz727Ept7oSr81RL35ZOblE5721NYtjLm5nw9p9sP3meewfHsvWxISwc24X2jTzhxEb4aTa80Q9ebl9xdizpd2g9HK5fAY8cg7u3kt1jRsXZNwcTOtXqRaeDZj3hmqUcv+YbuOJJSN8Hbw+FzyZC1olq7Ye0C+e2vjG8szWJP05k2c3DFWhjy784uksaHB8z7Nml2lavXk3Xrl3p1KkTOp2Obt26OczrUtavX0+7du1o3bo1L7zwQjX70aNH6dq1q/UnMDCQpUuX2m179OhR+vXrZ7PNlClTCA8Pp2PHjpLzyMnJYezYsbRv3564uDi2b9/OiRMnaswLYMmSJcTHx9OxY0cmTJhASUmJzfiVn2dNednSqrzb1FZeAC1atKBTp0507dqVAQMGVNMzm81069aNUaNGOfy8KrX69etHz549q3cgLpyfiAZMjx496joFDY3/PGazRfyZmCUe+WyvaDdnnYh57Htx7WtbxdqdZ0RxabkQZw8J8cerQnx4nRDPhAsxL1CIpxsJ8f41QmxZIkT6fiHM5rp+G7YpyRNi0/NCLIisyHnjs0KUFV/kUlRqEkNe2iT6LNggcgrL6ihRjYSEhLpOwcqxY8dEv379xNSpU0VqaqqstiaTSbRq1UokJiaK0tJS0blzZ3Ho0CG7/k2aNBGnTp2S3LZqGyGE2Lx5s9i1a5eIj4+XnMfEiRPF22+/LYQQorS0VFy4cMFujJSUFNGiRQtRVFQkhBDixhtvFCtXrqwxvr3X7WnVlFdMTIw4d+5cjZ/j4sWLxYQJE8TVV1/t8PNypFWJrZp0dt5SP05lKaS+rGPYv39/vYihVENOOym+jnzs2ZXa3AlX56mW/o9bd7H456MMWLiJ8Sv+ZN2BdK7v1owf72jP1wPSGJu8AO9X4+HNfvDzHMhN5VzMNXDL5/DYKZj0LfSfAU07gY2/aqXm6Yp6sb7uFQCDH4cH90CH6+D3hfDmZXB6m9XXx9PAkvFdySooZf53tbtuUxtb/kXKvmBFRUWK7VJthw4dYvTo0Tz55JO88847REZGOsyrKjt27KB169a0atUKT09PbrrpJr755psa/Tdu3EhsbCwxMTEO21bmWbUNwMCBAwkNvfiMuD2t3Nxcfv/9d6ZOnQpUPN0pODj4os/h0hhQ8TzU4uJiTCYTRUVF1s/m0viVOrbyqkkrNDS0xrwu5dK+TElJ4YcffuCOO+6w6WfrvdjSkWpzhga9pk7Uk128pSzgdYcYSjXktJPi68jHnl2pzZ1wdZ7O6J/KKuSnQ2dZd/As+87koNfBoNhAXuieTV+xD2PSb/DxPwdinxBoNQRih0LsEAhqRvKuXTRuU319WiWl5lLOF58nqziLv87/xZGjR8gvy6ewvJCC8oKKf8sKKDYVYxEWzMJMXn4evim+6HQ6vAxeeBu88fao+AnxCqHofBGn/E4R6h1KU9+mNAtohreHt93Potrr/uEw5m3oOgG+fwhWjoQBD8PgJ8BgpEt0MPcOjuXVX09wbddIBrernTuttbFFHo6OGfbsUmzl5eVMnDiRFStW2LzEN2DAAPLz86u9vmjRIoYNGwZAamoq0dHRVluzZs3466+/aoy9Zs0aJkyYIKltZZ5V29SEPa2kpCQaN27M7bffzr59++jRowevvPJKjXkBREVFMXPmTJo3b46Pjw8jRoxgxIgRNmM76idbWldccQXHjx+3mZefnx86nY4RI0ag0+mYPHkyDzzwgFVvxowZLFy4sFrf1PR5VWoJIbjnnnu48847Zb8HpTToSZ2GhoZrEUJw5Gw+6w+e5adDZzlyNh8jJq4LP8sDUQcY4H8Gr7QdkFJUsS1IdF8YOrdiIhfRBfQXbzNhEiZO5Z4iOT+ZM/lnSM5L5nT+adIK0sgqziK/7JIDXnLFPwadAT+jH/5Gf/w8/fDx8MGgM6DX6THoDHh5eIGAYlMxF0ouUGoupchURE5JDmWWMj49++lFsuG+4TQPaI5fmR8n/E4QFxZH25C21slejcQOhbv/gPWPVdylm7gJbnwfQmK4b2hrfjiQzuyvDvLzQwPd4jFi/1l+fBzOHqj2srfFXK0mpdo9G7WHaxbbDbt+/Xri4+NtTugAtmzZYre9XMrKyvj22295/vnnXdrmUkwmE7t372bZsmX06dOH6dOn88ILL/D444/XGOPChQt88803JCUlERwczI033sjHH3/MrbfeKju+La01a9bQpUsXm3k988wzbN26laioKDIzM7niiivo0qULAwcO5Pvvvyc8PJwePXrw22+/Sfq8KrWSkpK47rrraN++PQMHDpT/QSqgQY8q9WXhe5cuXepFDKUactpJ8XXkY8+u1OZOuDpPR/q5ReX8kZjFluPn+P1YFudy8uimP8HtoafoH3mMiLx96PP+eai9oQN0u7XiLtF/NvAtM5eRUpDCmdStJOcnk5yXbP03vTAd86F/t//wM/rRPKA5rYNb0y+iH418GhHmE0Yjn0YEG4MJ9w8n2CsYL4NXjQvhTSZTjRt9CiHILcklrzyP8yXnSS9It04oz+SfYW/hXjb/tbniregMtA5uTa+mvejeuDu5pbkEeQVVF/Xyh2tfhzYj4JsHYMVguHElXq0G8+KYzoxdvp3FPx/jyWtcfzesNrb8i5R9wZy5UcLeZrK+vr5AxSXLIUOG1Ogn5UxdVFQUZ86csdpSUlKIioqyqffjjz/SvXt3mjRpIqmtr68v33777UVtasKeVrNmzWjWrBl9+vQBYOzYsbzwwgvWz+HSvAA2bNhAy5YtrRtK33DDDWzbts3mpK5SpyZsaW3fvp2rr77aZl6V7wcq9j684YYb2LFjBwMHDuSPP/7g22+/Zd26dZSUlJCXl8ett97Kxx9/XOPnVanVokULrr/+equWnPeglAY9qasvz9tLTk6mVatWbh9DqYacdlJ8HfnYsyu1uROuzvNS/cJSE3uSc9hxKpstxzI5n3KcLroT9Dae5A7vU7TwPYHBUgYFOmjSEXpMprR5H/4q8cDcOKBiknRhJ6dPf8GZ/DOkF6ZjEf8+FzXAGEDzwOZ0atSJy0Iuo0tMF5oHNKd5YHNCvEJqnKydPHmSpk0cP63B3uel0+nITs+mVatWNA9sTrfwi+9ETExMxKeJD4fPH+bQ+UPsz9rP2mNr+fjwx+jQER8Wz+DowQyOHkzbkLYX59rh2orPY83N8NH1MPwZeva7j9v6xrByWxLXdImgW/MQh/k7gza2/MtFz379v+p3jAKUlZbi5eVVo4Y9e1lpKTW1LCsrw8vLi4CAALZv387tt99u00/KmbpevXpx/PhxkpKSiIqKYs2aNaxatcqm7+rVqy+6LOiobVlZWbU2SvJo2rQp0dHRHD16lHbt2rFx40Y6dOhg/RxsxWjevDl//vknRUVF+Pj4sHHjxhrvHK3UqQlbWl27dq0xr8LCQiwWCwEBARQWFvLzzz8zb948AJ5//nnrWbjffvuNRYsW8fHHH9f4eVXVunDhAj///DNPPvmkzffgChr0pE7KA5zdgQsXLtSLGEo15LST4uvIx55dqc2dcHWeJ9OyOFrow46k85w8eQKPc4eII4lu+hNM8ThJsFcuAMVGH1KaxPNb2DWcCWxMsocHyUUZJOfv4ezOHxH8u2YkyCuI5gHN6dK4C6NjRxMdEE3zwOY0D2hOsFewdTK0a9cuesTWvKauKlI/B2fqJScnh9jYWCL9I7ki5goAysxlfPHHF+QG5bIldQuv7X2N1/a+RpR/FCNiRjAqdhRtQ9pWCITFwh0b4Ot74OfZkHmY/w1/iQ2HM3jiywN890B/jAbX3a+mjS3/YrFYHPqYTCa7kwV7dim2adOmMWXKFOLi4oiNjeWTTz4hKMjG2V47eHh48Nprr3HllVdiNpuZMmUK8fHxVvvIkSN55513CAoK4pdffuGtt96S3DY3N7daG4AJEybw22+/kZWVRbNmzXjqqaeYOnWqXa1ly5Zxyy23UFZWRqtWrVi5ciUmkwmTyWQzRp8+fRg7dizdu3fHw8ODbt26WdeiXRp/1qxZ3HvvvTXmZUtr0qRJNeaVkZHB9ddfb+2rsWPHctVVVznsC1ufV1WtsrIybr31VptaJlPNjy50hgY9qdPQ0KgZIQRn80o4mJpHwplzZJ8+hC7jAJGlJ+mgO8UD+mQMhgJS/IycMXpwIrAJmwPacsbowRlzMRml2UAm5GRCDoR4hRAdGE2PJj1oHtAc83kzgzoPonlgc9uXKespngZP2vq1pUeXHtzd5W6yirPYfGYzv575lY8SPmLloZW0C2nHNbHXMDp2NCHeITDuI/jtedj8IgEFGTwz8kXuWH2ED7efZmr/lnX9ljRqiZCQEL766isArr76ao4cOWK9FCiHkSNHMnLkSJu2devWWf///Pnzstr6+fnZbLN69WrZeXTt2pWdO3de9FphYWGNMQCeeuopnnrqKYfxCwsL7eZlS6uyja28QkJC2LdvXzXfSxk8eDCDBw+2/m7rvbRq1cqqVfl+a5MGPamz9xeXOxEbG1svYijVkNNOiq8jH3t2pTZ3Qm6eQggy8ko5kZFPcmoyBSmHEVnH8Mk7Sbj5DIEe6fQ25pJuNHAm0IOjRk9+8fYn1dCYfKpeHjTTyMNMtH8kfQKiiQ6IJiYwhuYBzWkW0KzaxC0nJ8fmdgFqvTepvq6ol6qvN/JpxJi2YxjTdgzZJdmsT1rP9ye/Z9HORby6+1X+r+X/MSFuAvFDZlU8juz7h7iiaCrXtH6Cpb8c45rOEYQHOrgBQyHa2PIvUh6g7uiYYc8ux/bJJ58QFhZGr169HOZUm7j6mKmWvhIdOW2k+rqqXpyhQU/q6suWJrWx9k+NGEo15LST4uvIx55dqc2dsJVnudlCWk4xaRnnuJB2gpLMk5TnnKKsMInS8jQwXMBkLCDXw0y6hwfpfgbOBnmQbTAAXkDFFhseOgPh3uG0CGlJl38mbs0CmlX8698MX6P0xb1KPk+1a0WKn5KaqOn1UO9Qbo67mZvjbubEhROsObqGbxO/5ZvEb+jSuAtTOk5h8PiP0X8+lZf9Hmeo6RGe//EIS8Z3lfRe5KKNLf8i5Xjg6i1NKrnlllu45ZZbHOZT27j6mKmWvhIdOW2k+rqqXpyh3k3q1q9fz/Tp0zGbzdxxxx3WW6RtUV8O0mfOnCE83LX7VqkRQ6mGnHZSfB352LMrtdUVQgjySkxkXbjAhcxUcrNOkXRiNwZjIQUl6ZSUZ1EicinRF1FiKCPPw0KWwcB5g4ELfga46My/H746IxHeoTT1jyIuqCUR/hE09WtKhG9TmhrDaGII4dDOXXRs0xZLaSmiuBhLWimiNB1TcRK5pSVYSkoRJcUV/5aWYCkuqfi3pBRRVoYwmRCmcnKzzlPi51fxu9kE5aZ/bBU/mC75XQhMJhM5BkPlm6/6QVT8U+XdmM1mcry80BkM6Dw8wMMDnYcHOoPhov8vKCmhODgYvZcXOh8f9N7e6Hy80Xv7oPfxJv38eTxiY9F5e6P38UHv54chIAB9YCApp04Rdvnl6H190VW581FKrbQOac2cvnOY3n063yZ+y0cJHzF903RaB7fmzitnMeKXhXzn/xxX7/kfO3o3p3dL9Z9fq40t/yJljXVZWZndu2Tt2ZXa3AlX56mWvhIdOW2k+jpbL66gXk3qzGYz9913H7/88gvNmjWjV69ejB49mg4dtAdla7g3QgiKS0spyL3AhdwMLuRlcD4vg9zCLAoKz1Fckk1J2QWKTbmUiCJKKKbMUkqZ2YRJCEotOootOiwWPZ4m8CwX//wLXibwLYfQch9aWowE4kOQ3hd/fPERnvhaPPAq1+FpAn2ZCVFSgijJwFKaXDFpKy1FlJRQCJwEfIBEGe9N5+NTMWHy9kbn6VkxmfLwQFdWhllY0HkYKyZefl5g9Kj4vdLHo3ICZgS9jnPnzhHSuHGVu0ir3E1a+do//2ZmZBASFvrPBNH87+TRZEKYzNb/p7QUUVqKKS/v34lqSQmWkhJEcTGeQpBRw3vzAY4B6PXoAwL+mewF4KXTkRrTAkNYGB5hYRjCQvEIa4RHozAMoWF4NApD711xSTXAM4Bb4m5hfLvx/Jj0I+8ceIf/JbzNG23iuD8lkbWlz/LEl750nzEWDxfeNKGhodHwqVeTuqqPJQGsjyWpaVInZQ2FO+BoPyB3iaFUQ047Kb6OfOzZL7WZTWZKyosoKSkCYzmJZw5RVFxAUX4uZYU5lBTmUlqUR2lRDmUlRZSXFmAqLcZcVoylvBRLWSkWcxnCVF4xmTBXnHXSmy1gNoNZoDMLdGbQmUBv0mE0V0zGPE3gaxIEm/793fpTDgbraanKiY0A7J1tKKv48ShF71WMzqfIOtnSe3tX/Ovnh65Ro+qve3uh8/ZB7+1FTnEJYRFN0Xl5o/fxrvi3ir1qO52nZ41bjqSkpNCsWTO7fXUp5pQUIiS2MUn0tZeHEIKUpCQiQ0MrJnrFxVgKCrEU5GPOyycr+TRBBg/M+XlY8vKt/xrPZVJ86CDmrPNYalhUbQgOxiMyAmPTCIwRERgjIxgUEcHQ5k/yJ0m8lvwxM0P9iPc3MSlrFl//2oSxwwdJeu9S0caWf5HyAHVHZ2fs2ZXa3AlX56mWvhIdOW2k+rqqXpyhfsx6/kHu41Fqc1K39XgW5n8uEXkUZ+F/IaHCUHnZSFjQIf75teLffHMRSeVpmEzlGPYYsAgBiH/+s1RcahKVG0NYEFXbV/n/Cr2K1/71F1XaCyxmMzq9/p9XK9rqzGbCD2eiE+IfmX/aC/HPaxWv6yq1zQKdrkJZV8W/0sf6O4BFgLBUtLVUvq8KbYSlSlthzREhKtr98xlUttFZKuJZ/zVX5Ff5mt5SEV9nAf0/Pgeq+FfY//33hAUMVV7Ti4rfPcxQbAIPAYEq1oZZD2YPHSYPPRajHounB8JoROfliT7QGw9ffzz9A/D0C8LTLwAv34CKS4PeXui8vNF5e6Gv/NfbmzLAJyjI5iRL7+WFzsnBwruoSJWNMWt6JqNabaT62vPT6XSENW2KwdcXW88J8Kjhsyiq8rqlpATz+fOYsrMxZWVhzs7GdC6L8rPplKenU56SQtHff2OpsqlsJPC8jw/FkeEc8j7PzmAdPmfv5lD5LNoPuA5DQICk9+YIJX1QFzGUashpJ2VSZzDYqgJpdqU2d8LVeaqlr0RHThupvq6qF2eoV5M6uZSUlNRarKkf/E2pqWIfpKH63bznuchhm+3eXiyKcP1f0jXhWS74eG3d7OVnAdCB5Z+TPEL3z88//1/1NYu+wq/yX6G/5P91IPQ6q4+o/N1Dj9DpEHpAp0MYdFjQoTPoQa9H6PUV66QMeoTegAmBh7c3eBjQGT3ReXqh9/TEw8sXD29fPL398PQNwMsvCF+/QHwDQvALCMHLNxCDZ8VkSu/pCUYjOqMRndGzYtKl8h8Xu3btokcPaXu5KeHw4cOq6CvRkdNGqq8jP3v2mmxVX9d7e6OPisJYw67+lZjz8ylPT8eUnk7ZmRTKTp/G99Qp+iTp6Z6QWvGH0k/PcYznMEQ0xad9HF7t2+Hdrj1e7dri2bx5xXpBGajVl66OoVRDTjsp+4KVlJTY3YLCnl2pzZ1wdZ5q6SvRkdNGqq+z9eIK6tWkTsrjUVasWMGKFSsAyM7OZteuXda2vr6+HD9+HICgoCBiY2PZvXs3UDFr7tq1K0eOHLHuURMXF0d2djYZGRUrbqKjo/H09CQxsWLFUUhICM2bN2ffvn3MGxiMweBB69atST3uxy85kQBERkWRl59PQUE+oCcsLAy9Xs+5c1kUU8rjXsUUFRWh0+kBHUYPI02bNiEjIxOzqWLCFRkZSV5eHkVFxYCORmFhIATZF3LQoSMgIICAgEDOpqcjdDq8PL2IiowkJSUFi9mCQAcI/P0DKCosRqeDpk2aYi4v58SjJ0CvIzAwCN8AfzIzMhA6Pd7e3kRERZKcnAIIhK7iYOLnH0BxcTFCryMqqhmlZeVkZ2eDTk9Yo8b4+/tzJiUFvcGAX0AgrVrFsv3PPwkNa4zBYKRnz94knTxFUUEBAO3atSMvL4/09HQAiouL6dy5s91+MpvN+Pn51dhPJSUlxMfH2+yn7OxsmjRpQufOnUlISKC4uBiA+Ph4duzYYf0CxsTEoNfrSUpKAiAsLIzIyEgOHDiABSj38iK6Y0cOHjxIaWkplJbRqVMnUtPSOH/2LAAtW7bEUlLM6dOnAWjcuDHh4eEcOnQIqHiMXYcOHdi/f7/1weRdunQhOTnZuqlqbGwsZWVl1rpv0qQJJpPJWtd+fn60b9+evXv3WheCd+/encTERHJzKzYJbtOmDUVFRaSmpgIQERFBYGAgR48eBSAgIIC2bduye/duhBAV/QkcO3bM+siiS/tJyvcJkP19slgs1vdmNBpt9lNmZibnzp0jOzubrKysGvsJ/t02wNpPQKdOnUhLS7PuL1VaWkpWVpbNfsrOziYhIaFaP1ksFk6ePGm3n0JDQzl8+PBF/XQgMRGzvz/Etaf7LTeTmJhIXm4ulJfz1x8bMKV9QGahJ23PXaDT8UN4//57xWX8ijeDT8eO5DVtiqV1LJY2beg+bJjdfiouLiYvL89l4x78uwFwTf0E9r9PULH9jaN+atmyJRaL5aJ+MpvN1npx9H3S6XSYTCaEENZF6kajEYPBYD3AVn6HioqKrHcn+vr6Ulpaitlstv5YLJZqGmazmcLCQgwGA97e3tX2OispKbHqe3t7YzabrXl6enqi1+uteRgMBry8vCgqKgIqzij7+vpSXFxs3UTZloZOp7N+fh4eHnh6etrV8PHxoby83DrhFf/crFRVw2g0WvtVr9fj4+NjV8PLy+uiz7iqhtlspri4GB8fn2qfcVlZWY0acvup8vOp2k8WiwWz2XzRZ3xpP/n5+Vn7qbCw0GE/WSwWhBA1fsZVa+bSfjKbzZSVlXHy5MmLvk9OI+oR5eXlomXLluLkyZOitLRUdO7cWRw8eLBG//j4+FrMTjmHDx+uFzGUashpJ8XXkY89u1KbO+HqPNXSV6Kjdq1I8VNSE67og6z8EjFt3kKx/fkIcd3KLqLj+x3Foz9PF+k7t4oLn38u0p9dIJLGjReHO3YSCe3ai4R27cWxQYPFmekzxPkPPxIlx44Ji8Xi8jwvpb6MLfv27XPoU1RUpNiu1OZOuDpPtfSV6MhpI9XX2XpJSEio9nqPHj0kxa4JnRD1ZDO3f1i3bh0zZsywPpZk9uzZNfr27Nmz2s7RGhoaGu7K27+fZOf6D1nm9SoftuzCG7pc/I3+zOo7iytjrkSn02EpK6P08GGK9+2jeO8+ivbuwZRWcWbO0KgRfr1749uvL359+2Js1qzGG1n+axw+fJi4uLi6TkNDw4qtmnR23lLv7p8fOXIkx44dIzEx0e6EDrCeEnV39u7dWy9iKNWQ006KryMfe3alNnfC1Xmqpa9ER+1akeKnpCZc1QeTLmvB0ZBBvOZ1N3ec3M1nfp2J8o/i0c2P8vBvD3O++Dx6T098unQhdOJEol5eTJtffyV2wy9ELHgWv379KPx7B2fnPkni8BEkDBlKxvMvUPjnX4h/Lv+oTX0ZW6TsC+bomGHPLtW2evVqunbtSqdOndDpdHTr1s1hXpcyZcoUwsPD6dixo+y29nD1MVMtfSU6ctpI9XVVvThDvZvUNUSkbIrpDjGUashpJ8XXkY89u1KbO+HqPNXSV6Kjdq1I8VNSE67qA08PPU+MjOPVnMvZ1+pOWu//io/8OjGj+ww2p2xmzLdj2Ja6rXq7Zs0IHjOGqJcW0ub332n1w/c0mTMHER7OhVWrSJ48mWOX9yf1kZnkrVuHRcUDSn0ZW6Tg6MKVPbtU24QJE1i7di0BAQFMnTqVH374QXaekydPZv369bLbOcLVF+7U0leiI6eNVF9X1Ysz1KsbJTQ0NDQaOiM6NKFvq1AmJw3jr475eG5+kamjX2PgqE/53+//464NdzGpwySmd5+O0VB9+xqdTodXbCxesbEkxbUnrl17Crf9QcGm3yjYvJm8H35A5+NDwJDBBF59NX4DBlTcta1RKxw6dIixY8eyZMkSrrrqKkUaAwcO5NSpU+omptEgqHdr6uRQX9bUCSFcvu5FjRhKNeS0k+LryMeeXanNnXB1nmrpK9FRu1ak+CmpCVf3waG0XEYt28od/aKZnTsPTm6Gmz+lpOUAFu1cxKdHPyUuNI6FAxfSIqhFjTqX5inMZop27SLvxx/JX/8T5gsX0AcEEDBsGEHXXYdv714u7TO1NeS0k7KmztVjS3l5OX379mXp0qUMGDCgmt+AAQOsdzJXZdGiRQwbNuyi106dOsWoUaM4ePCgvbckC21skefrbL0cOXJE9TV1DfpMXeVt2e5OYmIirVu3dvsYSjXktJPi68jHnl2pzZ1wdZ5q6SvRUbtWpPgpqQlX90F8ZBDjekSz8s8Ubrl/OS0Kx8La2/G+4xfm9J3DZZGX8eS2Jxn//XieufwZRrQYISl/ncGAX+/e+PXuTdNZsyj88y/y1q0j/5dfyP3qK4wxzQkeM5ag667FKPGZqvVlbCmvsqbwxR0vciT7SDUfi8Vid5Nie/bWga2ZfZntdd6lpaV4e3uzfv164uPjbU7oALZs2WLvLbicyjzdXV+Jjpw2Un0d+dmzu2p+0qDX1NWXNVKV+4m5ewylGnLaSfF15GPPrtTmTrg6T7X0leioXStS/JTURG3UyiNXtsXLQ89zG87AhDXg6QerxkNhFkObD+Xzaz6ndUhrHtn8CC/vfBmTpfrmuvby1BmN+A/oT+Tzz9Fm6xYiF76IMbwJ515+mRNDhnLmvvsp3LbN4dqf+jK2SLko5ao1UpXHoh07djBkyJAa/QYMGEDXrl2r/WzYsMFB5uqgrdeV5+uq9d3O0KDP1GloaGjUV8IDvLlncCyLfj7Gn/1b0nfCKlg5Ej69DSZ+Q1O/pqy8ciUL/17IykMrOXj+IC8NfIkwnzDZsfTe3gSNHk3Q6NGUJiWR++WX5Hz5FckbN+LVpjUht91G0OjR6F14Fqc2eaz3YzZfLywstPuEAHv2SzcbtkVAQADbt2/n9ttvt2mv6zN1GvWfBn2mrnI3eXenTZs29SKGUg057aT4OvKxZ1dqcydcnada+kp01K4VKX5KaqK2amVq/1ZEBHnz7A8JWCK6w3VvQPI2+P4hEAJPgydz+s5hQf8F7D+3n3Hfj2P/uf1O5enVsiXhjzxC602/EvHC8+Bh5OyT8zgxeAiZS5Ziysq6yL++jC1SngXu6JKbPbsU27Rp0zh37hxxcXGMGjVK8RnKCRMm0K9fP44ePUqzZs149913FenUlKerUEtfiY6cNlJ9XVUvztCgJ3WVjzFxd2pjPz01YijVUHt/oNrYS8qd0faSkufrinqprVrx8TTwv6vacTA1j6/3pkLHMTDoMdj7MWx/zeo3OnY0H4/8GKPeyOT1k/n+5PdO56n39CT4uuto+eUXxHz0Ib69enJ+xQpOXDGMswueo/yfx+HVl7FFyuVXR8cMe3YptpCQEL766isOHz5sXSivhNWrV5Oenk55eTkpKSlMnTpVkU5NeboKtfSV6MhpI9XXVfXiDA16Ulfuos021abymZzuHkOphpx2Unwd+dizK7W5E67OUy19JTpq14oUPyU1UZu1cm2XKDo3C2Lh+qMUl5lh0OPQ4Tr4eS4c/Xevsvah7Vlz9Rq6NO7CE1ue4LU9r3Em5UzNwhLR6XT49upFs2XLaLXuBwKvvpoLq1eTOHwE6fPmk7Znj9MxamNskbKGydEGxfbscmyffPIJYWFh9OrVy2FOtYmUDZrdQV+Jjpw2Un1dVS/O0KAndRoaGhr1Hb1ex5yrO3A2r4S3t5wEvR6uexMiusAXUyHz37M9wd7BrBi+gutbX89b+9/izTNvUmwqVi0Xr5YtiXxuAbHr1xM05gZyv/wS75mPkj5/PuWZmarFaejccsstfPjhh3bvtNXQUEKDriijsfrGnO5IREREvYihVENOOym+jnzs2ZXa3AlX56mWvhIdtWtFip+SmqjtWundMpSr4puyfHMimXkl4OkLE1aD0RfW3Awl/67NMhqMPHXZUzzS4xF25u1kyvopnCs6p2o+ns2iiJg/n9gNv+A16mpyPv+CxCuvInPpUsw29llzRG2MLQaDwaGPo2OGPbtSmzvh6jzV0leiI6eNVF9X1YszNOhJnZQvsTsQGBhYL2Io1ZDTToqvIx97dqU2d8LVeaqlr0RH7VqR4qekJuqiVh7/v/aUmy0s/vnYP0lEwrgPIec0fHknVFmjo9PpmNxxMi/2e5HE3ERuWXcLJ3NPqp6TsUkTmsydS+wP3xMwZAjnl79F4vARnH//fYSMy0u1MbZI2UzW0THDnl2pzZ1wdZ5q6SvRkdNGqq+r6sUZGvSkrqSkpK5TkMTRo0frRQylGnLaSfF15GPPrtTmTrg6T7X0leioXStS/JTURF3USotGfkzs14LPdp0hIS2v4sWYfnDVC3BsPWx+sVqb8Pxw3r/qfUrNpUz8cSJ7M/eqntfRo0fxjIkh6uXFtPj8c7w7dCDzhRc5OfpaCiRu0VEbY4vJVH0fv0txdMywZ1dqcydcnada+kp05LSR6uuqenGGBj2p09DQ0GhIPDi0DUE+RhasS/j3bs5ed0DXW2DzC3BkXbU2HcI68PH/fUyQZxDTfp7G5jObXZafT8d4mr/3LtFvLQchODPtTs7cex9lyckui6mhofEvDXpSV18WoQYEBNSLGEo15LST4uvIx55dqc2dcHWeaukr0VG7VqT4KamJuqqVIF8jDw5twx8nzrPp6D83Juh0cPXLENkNvroLso5XyzM6MJoP/+9DYoNjmb5pOl8d/0q1nGx9Fv6DBtHyu28Jn/kIRX/+yclR15C5dCmWGs5O1MbYol1+dYx2+VWerzteftUJKZv31FOcfTCuhoaGhrtRZrJw5dLf0etg/YyBGA3//PGamwJvDQLfULhjI3hXX29WVF7Ew789zB9pf/BAtweY1mmaSx/gDlCekUnm4kXkffsdnjExNH36afz69HZpTFscPny42sPTNTTqEls16ey8pX6cylJIfdlMdvfu3fUihlINOe2k+DrysWdXanMnXJ2nWvpKdNSuFSl+SmqiLmvF00PPE//XnsRzhazZUeWyZlAzuPF9OJ8IX98DFku1PH2NviwbuoxrWl3Dsj3LWLRzkaRNee3h6LMwNgknauFCmq98D2GxkDxpEulz52Ku8jSF2hhbpOwL5uhRX/bsSm3uhKvzVEtfiY6cNlJ9XVUvztCgJ3X1hdo4WapGDKUactrV5UO368tJa1fnqZa+Eh21a0WKn5KaqOtaGd6hCX1ahrJkw3HySqpsst5yAIx4Fo58D1sX28zTaDDybP9nubn9zXyY8CHP/PkMFqF8d3upn4Vfv360+vYbQqdOIeeLL0kcNYq8n3+WpaE0tobGfwVtUucGuPryh1oxlGrIaSfF15GPPbtSmzvh6jzV0leio3atSPFTUhN1XSs6nY65ozpwoaiM1zeduNjY9x7odCP8uoDALNtnsvQ6PY/3fpypHaey9tha5mydg8ni+O7QmnKRit7HhyaPPkqLtZ/h0bgxqQ9OJ/V//0On8KpKXfeDElavXk3Xrl3p1KkTOp2Obt26yWp/5swZhgwZQocOHYiPj+eVV15xUaYa9RFtTZ2GhoZGPeXhz/by/b50Nj4yiOhQ338NZYXw9hVQmAl3bYGgqBo13t7/Nq/ueZVhzYfx4sAX8TR41kLmIMrLyXprBVlvvolHeDiRzz+HX9++LovnTmvqjh8/zqRJk+jQoQNPP/00kZGRktump6eTnp5O9+7dyc/Pp0ePHnz99dd06NDBhRlruAJtTZ1M6sveQMeOHasXMZRqyGknxdeRjz27Ups74eo81dJXoqN2rUjxU1IT7lIrj17ZDr0eXlx/yYPhPf1g3IdYyoph7WQw1/wc7Gmdp/G/Xv9jQ/IGHtz0ICUmeeOm0s9CZzTS+P77aLF6FSa9juTJt5Px/PM13iHrbGwpzwKvjX3qDh06xOjRo3nyySd55513ZE3ooOIpGt27dwcq7v6Ni4tT7VnE2j518ny1fepqGYtF+TqR2iRfwWN16iKGUg057aT4OvKxZ1dqcydcnada+kp01K4VKX5KasJdaiUiyIc7B8by/f50dp2+cLGxcVtOdZkJKTvglyft6tzW4Tbm9ZvHttRt3L/xflnPi3X2s/Dp3JmiZ54h5Oabyf7gQ07deCOlJ044bigztpSLUmazWbFdiq28vJyJEyeyYsUKrrrqqmp+AwYMoGvXrtV+NmzYYFP31KlT7Nmzhz59+tjNWyqO3r+76CvRkdNGqq+r6sUZPFyiqqGhoaFRK9w1sBWrdyTz7A8JfHnPZRetM7sQORg8MuHPNyC6N8RfX6PO2LZj8TJ4MXvrbB749QGWDV2Gj4dPLbwDwMuLpk/OxX/IENIee4ykG8fRdO5cgm+oOV9nOPvcc5QePlLtdbPFjEFf8/5h9uyG1q3xm2d/8rx+/Xri4+MZMGCATfsWiU/gACgoKGDMmDEsXbq03jziUMP1NOgzdd7e3nWdgiTatWtXL2Io1ZDTToqvIx97dqU2d8LVeaqlr0RH7VqR4qekJtypVvy8PHh0RDv2JOfw/f70i2zt2rWD4c9As97wzf0XbUxsi2tir2FB/wXsSN/Bg79KuxSr5tjiP6A/Lb/+Cp/OnUmfNYu0xx7HYmfrBzmxPTwcn8NwtGG9Pbu9zWQrj0U7duxgyJAhNfpJPVNXXl7OmDFjuOWWW7jhhhvs5iwHVx8z1dJXoiOnjVRfR3727K76rBv0mTpXn0pWi7y8PPz9/d0+hlINOe2k+DrysWdXanMnXJ2nWvpKdNSuFSl+SmrC3WplTI9mrNx2ihd+PMLwDk3wNlZMMCryjKzYv+6tAfDpbTBtY8Wauxq4JvYaBII5W+dYz9h5e9R8AFJ7bDGGh9P8vXfJenM5Wa+/TvGBA0QtWYJ3u7ZOxa56+bXprFk2fcrKyvD0rPlGEXt2e/vgmc1mDAYDAQEBbN++ndtvv92mn5QzdUIIpk6dSlxcHA8//LBDfzlU5ukq1NJXoiOnjVRfR3727K6anzToM3VSFsa6A+np6Y6d3CCGUg057aT4OvKxZ1dqcydcnada+kp01K4VKX5KasLdasWg1zHn6jhSc4p5f9sp6+vWPIOiYMw7cO4IfP8wOFhfNjp2NM9c/gx/pf/l8IydK8YWncFA4/vvo/nKlZjz8zh1003k/vCDU7GlHEQdHTPs2aXYpk2bxrlz54iLi2PUqFHkVtmAWSp//PEHH330Eb/++qv1TN66ddWf+asEVx8z1dJXoiOnjVRfV9WLMzToSZ2GhobGf4XLWzfiivbhvP7rCc4XlFZ3iB0KQ2bB/jWwa6VDvWtbX8vTlz/Nn+l/Mn3TdNl3xaqBX98+tPryS7w7dCDtkZlkLHwJYVK2n547EBISwldffcXhw4cRQnDkSPV1fY7o378/Qgj279/P3r172bt3LyNHjnRBthr1kQY9qTMajXWdgiSiomreQ8qdYijVkNNOiq8jH3t2pTZ3wtV5qqWvREftWpHip6Qm3LVWnhgZR1G5maUbKtbOVctzwExoPQx+fAxSHT9i67rW1/HUZU+xPW07D/32EOU2tkZx9dji0bgxMSvfI+TmCWS/9x5n7rwT04ULsmNLuZxm79KrI7sc2yeffEJYWBi9evVymFNt4uj9u4u+Eh05baT6uqpenKFBT+ocLXp1F3x9fR07uUEMpRpy2knxdeRjz67U5k64Ok+19JXoqF0rUvyU1IS71krrcH9u6dOcVTuSOZ6RXz1PvR5ueBv8m8Bnk6Ao26Hm9W2u58l+T7I1dSuPbXms2pMnamNs0Xl60vTJJ4lY8CxFf+/k1NgbKTl8WFZsKU+fcOZGCTm2W265hQ8//NDtjlGuzkctfSU6ctpI9XVVvTiDe1WUypSW2rgE4YYcP27/jjR3iaFUQ047Kb6OfOzZldrcCVfnqZa+Eh21a0WKn5KacOdamX5FG3w9DTy37rDtPH1DYdwHUHAWvr7H4fo6qNju5NGej/LL6V+Yt23eRc+Krc2xJXjMGGI++RhhMnFqws2c/OQTyTFMEi7b1sbmw+6MtvmwPF9t82ENDQ0NDZcS5u/F/UNas+noOfZl1PCHbVQPGLEAjq2Hbcsk6U6Mn8i9Xe/l28Rvee6v5yRt5usKfDp3puUXn+Pdvj1er7zK+XfeqbNcNDTcjQY9qXPlrdlqEhQUVC9iKNWQ006KryMfe3alNnfC1Xmqpa9ER+1akeKnpCbcvVYmXdaC6FAfPjpQiNlSw4Sn9zTocC1smA/Jf0nSvbvz3UyOn8ynRz9l6e6lCCHqZGzxaNSI5u+vRDdgAJmLFpM+dy7CzpYiIO3yq6Njhj27Ups74eo81dJXoiOnjVRfV9WLM+hEA/4Tx9kH49YWQghJA05dx1CqIaedFF9HPvbsSm3uhKvzVEtfiY7atSLFT0lN1Ida+WF/Ovet2s2LYzoxvldz204lufDWQDCb4O4tFZdmHSCE4Nk/n+WzY5/xQLcHmNZpWp2NLRazmfOvv07WG2/i27cvzV5ZiqGGCeLhw4dp37694lpwZNfGltrTbwhji8Vi4ejRo8TFxV30urPzlgZ9pq6oqKiuU5DE7t2O70JzhxhKNeS0k+LryMeeXanNnXB1nmrpK9FRu1ak+CmpifpQKyM7NaVdmJFFPx+joLSG9WTeQXDjB1CYCV/dBRKel63T6ZjddzajWo1i2Z5lPP/z807nqvTz3LN3L40ffJCIF56naNcuTt00gbLkZJu+JSUlnD9/3u6lWkfHDHt2pTZ3wtV5qqWvREdOG6m+SutFCEF6erpLnirRoJ8ooaGhofFfRafTMblLAE/8ms1bmxN5ZEQNj9SK7ApXPgfrZsK2V6H/DIfaep2eZy5/hmJTMauTVxN/Ip5rW1+rav5yCL7uOjyjoki5/wFOTbiZ6BVv4RMff5GPxWIhPz+fc+fO1ajj7BMllNjcCVfnqZa+Eh05baT6OlMvJSUldOzYUVI+ctAmdW5Abay3UCOGUg211zJo6160dS9yfF1RL/WlVuLCfRjdJZK3t5xkQu/mRAb72HbsdQec2gobn4boPhDTz6G2h96DhQMXMvHriczbNo9gr2AGRQ9SlKcaY4tvr17ErF5N8h1TSb5tIs1eW4bfZZdd5NuyZUu7env37q12OUyqXanNnXB1nmrpK9GR00aqr7P14oq9dLU1dRoaGhoNmJQLRQxdvJlRnSJ4eXzXmh1L8mDFICgvqVhf59dIkn5heSFTfprCyZyTvD3ibbqG24lRC5RnZHJm2jRKk5KIfOF5gq6+uk7z0dCQw39iTd38+fOJioqS/Zy7+rI3kJJHxdRFDKUactpJ8XXkY8+u1OZOuDpPtfSV6KhdK1L8lNREfaqVZiG+TO3fki/3pLI/JadmZ+9AuPF9KDoveX0dwJnEM7xxxRs08WvCfRvv48SFE4ryVIKtdsYm4cR8/BG+XbqQ9shMsj/4QHIMbWzRxhY5vq6qF2eoF5M6gIceekj2c+4sEgeluqawsLBexFCqIaedFF9HPvbsSm3uhKvzVEtfiY7atSLFT0lN1LdauXdwLGF+njz7/WH7e7pFdIGrnocTG+CPJZJjhPmEsXzYcrwMXty14S7SCtIU5SmXmtoZAgOJfvcdAoYPJ+P5F8hctIjCggKn89DGFvfQb8hji7PUm0mdhoaGhoYyAryNPDKiHTtOZfPtPgcTrp5ToOMY+PVZOPWH5BjNAprx5rA3KS4v5q5f7uJCyQUns3YOvZcXUUuXEHzTeM6/8y7G91Yi6skf+hoaihEO+Pnnn8Udd9wh9uzZI4QQ4q233nLURHXmzZsnYmJiRKdOncTtt98usrOzJbXr1q2bizNTh8LCwnoRQ6mGnHZSfB352LMrtbkTrs5TLX0lOmrXihQ/JTVRH2vFZLaIq1/9XfRe8IsoKCm337A4V4hXugmxqJ0Q+ZmSYwghxM6zO0WPj3qIm767SRSWqdNHzrSzWCwiY9FikdCuvUj93/+Epbzm966NLdrYIsfXFfXSo0cPSbFrwuGNEhMmTODNN9/k2WefZeTIkXz++ee88cYbqk8uhw0bxtmzZ6u9vmDBAvr27UujRo3Q6XTMnTuX9PR03nvvPZs6K1asYMWKFQCkpaXx3XffARAVFYWvr6/1GYNBQUHExsZa90cyGAx07dqVI0eOWE+LxsXFkZ2dTUZGBgDR0dF4enqSmJgIQEhICM2bN2ffvn0AGI1GOnfuTEJCAsXFxQDEx8eTmZlpvY0+JiYGvV5PUlISAGFhYQCcP38eAC8vLzp27MjBgwetz67t1KkTaWlpVp+WLVtisVg4ffo0AI0bNyY8PJxDhw4B4OPjQ4cOHdi/fz/l5eVWH5PJxIULFX89x8bGUlZWxpkzZwBo0qQJoaGhHD58GAA/Pz/at2/P3r17MZvNAISHh1NaWkpubi4Abdq0oaioiNTUVAAiIiIIDAzk6NGjAAQEBNC2bVu2bNmCr68vOp2O7t27c+zYMfLz8wFo164deXl5pKenW99/8+bN7fZTo0aNKCgoqLGffHx8iIyMtNlPRUVFBAUF2eyno0ePWp8PaaufIiMjOXDggEv7qUuXLiQnJ9vtp7KyMqvdVj91796dxMRE2f20e/duhBAUFRUxYMAAu/0k5fvkqJ9sfZ88PDys3xVH36eioiLi4uIc9lNwcDA5OTk19pOfnx+NGjWy2U9FRUWEhYW55PvkbD8p+T6llnjy4HfJXN/ej1s7Bdgd9/KObaP91vsoj+pN8Q0fkXgyydpPVce90tJSLrvssov6KSs4i//98T86+HVgRvMZxLaMtdtPZWVl9OvXT/b3yWw2k52dDTj+Pom1n+P39dd4DhpEzpTbwcOjWj+ZzWZ69+5dYz8VFRXRpUsXm/20Z88efH19bfZTeHg4RUVFTn2fauP45OvrS5MmTVw27tX0fZIy7snpJ1vfJ09PT1q2bCnp+5SRkYGvr6/DfqqMW1M/FRUV0aNHD5v9dODAAXx9fav101133eXcDZ6OZn3Tpk2z/v9jjz0mevbs6dQs0lmSkpJEfHy8JN+4uDgXZ6MOO3furBcxlGrIaSfF15GPPbtSmzvh6jzV0leio3atSPFTUhP1uVYe/nSvaD3rB3HyXIEEgZVCzAsUYvNCWTGEEOLLY1+Kju93FLO2zBIWi0V2nlKQWy/n339fJLRrL05PmybMxcWy9bSxxT30G/LY4uyZOodr6q6ucjv4Cy+8wMSJE5XPIBVSOUsG+Oqrr1yyYZ+GhobGf4HH/q8dXh4GnvrukP2bJgC6T4JON8Km5yBpi6w417e5nvu63se3id/y2t7XnMhYPUInTaLpM09TuGUrZ+68C3NB/biBQUNDKg43H7722mtJrvLYlUt/r0pwcDCBgYHqZfcP//vf/9i7dy86nY4WLVrw1ltvSWpXH3bwhorTsfUhhlINOe2k+DrysWdXanMnXJ2nWvpKdNSuFSl+SmqiPtdKeIA3M4a14dkfDrPxcCbDOjSpWUCng1FLIW0vfDEV7t4K/uEOY1RyV+e7OFt4lhX7VxDhF8HYtmMl5ykFJfUScuON6L19SHv8cc5MnUr0O29jCAiQpKeNLe6h35DHFmeR9ESJSZMmodPp7P5Vp9PpmDx5skvO5H300UeK2tWHByhD7Uw+1YihVENOOym+jnzs2ZXa3AlX56mWvhIdtWtFip+SmqjvtTLpshas+fsMT3+fQP82jfA22nmig5d/xf5171wBX06DW78E/b/+9j6LyufEni06y7N/PksT3yYMaDZAcp6OUFovQdeMQu/jTcpDD5N8xx00f+cdDAEB2tiijS2yfF1VL84gaUuTTZs28euvv7Jp06Yaf3799dc6uTRrj8qFnO5O5cJWd4+hVENOOym+jnzs2ZXa3AlX56mWvhIdtWtFip+SmqjvtWI06Jl/TTzJ2UW8s+WkY6GmHWHkS3DyN/h9kaQY1lh6I4sHLaZtSFse2fwIh84fkpynI5ypl4Bhw2i2dAklCYc5c8c0zPn52tiijS2yfF1VL86gaJ+6wsJC6x0nGhoaGhr1j/5tGnFVfFNe35RIWk6x4wbdboPO4+G35+HkZlmx/Ix+vH7F64R4hXDfhvtILUhVmLW6BFxxBc2WLqH40CHO3DENiorqOiUNDaeQNKmzWCysWrWKq6++mvDwcNq1a0fTpk3p0KEDjz76KCdOyH8sTG1QXx66HRISUi9iKNWQ006KryMfe3alNnfC1Xmqpa9ER+1akeKnpCYaSq3MvjoOixAsWHfYsZhOB1e/DI3awBd3QH6GpBiVNPZtzJvD3qTMUsY9G+4htzRXcp41oUa9VJ3Y+S1+GbOdJ09oY4t76DfkscVZHO5TBzBo0CCGDRvGtddeS8eOHdHrK+aC2dnZbNq0iVWrVnH99ddz6623uiRJpfTo0YNdu3bVdRoOMZlMeHhIWt5YpzGUashpJ8XXkY89u1KbO+HqPNXSV6Kjdq1I8VNSEw2pVpZuOMbSDcdZNa0Pl8U2ciyakQBvD4VmPWHiN5gsQtZnsfPsTu785U46N+7MiuEr8DR4usXYkvfLL6Q+9DA+HTtW3Dzh7y9LQxtbak+/IY8tPXv2dGqfOkln6jZs2MDcuXPp3LmzdUIHEBoaypgxY/jiiy8YP3684iRcReUGi+5O5aaD7h5DqYacdlJ8HfnYsyu1uROuzlMtfSU6ateKFD8lNdGQauXuQbE0C/Fh/reHKDdLeIxWkw5w9SI4tQU2vyj7s+jZtCcL+i9gV8YuZm+djUVY3GJsCRw+nNL776P44EHOTLvT5hk7bWxxD/2GPLY4i6RJndFoVMVHQ0NDQ8O98DYamHdNPMcyCnhva5K0Rt1uhS43w+aFBJyTfzXk/1r+Hw/3eJj1p9bzyu5XZLd3FeZevYh6eTHFBw5w5q67sWhr7DTqGbJulHjwwQcZMWIEV155pXXvOHemvmxpUhsTYjViKNWQ006NPyDs2ZXa3AlX56mWvhIdtWtFip+SmmhotTK8QxOGxYWzdMNxUqXcNAEVZ+sat6Plnucgv/ojHh0xOX4y49qO472D7/FH3h+y24NrxpbAESOIWvQSxXv2kHL/A1jKyiRpaGNL7ek35LHFWSStqatk+fLlxMbGUl5eTkJCAu+//z533303999/v0uScxZnr01raGho/Fc4k13E8CWbGdimMSsm9pTWKPMIvD0EIrvDxG/AIG+dU7mlnPs33s+O9B28Nfwtekf0VpC5a8j58ivSZ83C/58bKXT1ZGKmUb+plTV1ldx9990MHz6ckSNHMnPmTHbu3Cn56Q51QUlJSV2nIImEhIR6EUOphpx2Unwd+dizK7W5E67OUy19JTpq14oUPyU10RBrJTrUlwevaMPPCRlsPJwhrVF4e1K7PQKnt1ZsdSITo97IokGLaOrVlBm/zSApV+Ll339w5dgSfMP1NJk7h4KNG0l7/AmE2ayNLW6i35DHFmdRdBvK8uXLOXHiBPn5+S55LJhaWCwSFv26AbVxQ4caMZRqyGknxdeRjz27Ups74eo81dJXoqN2rUjxU1ITDbVW7ujfiq92pzLv20NcFtsIH0/H20KdbTKEqG5JsGUxxPSD1sNkxQzwDGB68+k8n/w89228j09GfkKIt7TtHlw9toTecguWoiLOLX4Zva8Pxddeq0i/odZLXek35LHFWRRtPjxy5Eji4uJISUnhiSeeUDsnDQ0NDY06wNNDzzPXdSTlQjGvbTouveH/vQThcfDlnZCXJjtuY8/GvDLkFTIKM5ixaQZl5jLHjWqJRtOmEXbP3eSs/Rzjx5/YfVymhkadI2QwduxYkZCQYP3dbDaLzp07y5GoVbp3717XKUiiuLi4XsRQqiGnnRRfRz727Ept7oSr81RLX4mO2rUixU9JTTT0Wnno0z2i9awfxPGMPOkxMo8K8WyEEO9eJYSpXFa8So0fT/4oOr7fUTzx+xPCYrFIjy0jhhIfi8Ui0hcsEAnt2ovMV16Rrd/Q66W29Rvy2NKjRw9JsWtC1pm62267jfHjx9OpUycmT57MuHHjLtq3zt0oLy+v6xQkkZmZWS9iKNWQ006KryMfe3alNnfC1Xmqpa9ER+1akeKnpCYaeq3MGhmHr6cHc74+6PDMlDVG47ZwzVJI3gabFijK86qWV3F/1/v57uR3rNi/QnI7OTGU+Oh0Opo88QQe/3cVWW+8yfl33pGl39Drpbb1G/LY4iySZmSVX+rRo0ezf/9+Pv74Y4YOHcqoUaP46aefLvJxJ0wmU12nIIlz587VixhKNeS0k+LryMeeXanNnXB1nmrpK9FRu1ak+CmpiYZeK438vfjfVe3482Q2X++1/5zWi2J0HgfdJ8HWl+H4L4ryvLPznVzT6hpe2/sa65PWS48tI4YSH51OR97NNxM4ciSZixaT88UXkts29Hqpbf2GPLY4i6RJ3ZAhQ1i2bBnJyckAdOnShYkTJ3LzzTdz8OBBJk2axAcffOCSBDU0NDQ0ap8JvZrTJTqYBT8cJrdIxlWP/3sRmnSsWF+XmyI7rk6nY/5l8+ke3p3ZW2ezN3OvbA2XodcT+cLz+PXvT/rcJ8n/9de6zkhD4yIkTerWr1+PwWBgwoQJREZG0qFDB1q1akWbNm1YvXo1M2bMYPLkyS5OVT6enp51nYIkYmJi6kUMpRpy2knxdeRjz67U5k64Ok+19JXoqF0rUvyU1MR/oVb0eh0LrutIdmEZL/18RHoMow/c+AGYy+DzKWB2PCG8VMPT4MnSIUtp4teE6Zumk5Jve3JYF2OLztOTZq8sxbtjR1Ifepiif/YU08aW2tNvyGOLs0ia1Hl7e3Pvvffyxx9/cPr0aTZu3Mju3bs5ffo0b7/9Nt26dXNJcv8VamNdohoxlGrIaSfF15GPPbtSmzvh6jzV0leio3atSPFTUhP/lVrpGBXExH4t+OSvZHadviA9RqPWcM0rcOYv+PUZRXmGeIfw+hWvU24p54FfH6CgrPqzWOtqbNH7+RH91nKMkZGcuedeSo4e1caWWtRvyGOLs0hSPXr0qHXNnNFoJCIiguDgYJckpCZlVR7v4s4kJcnbcLOuYijVkNNOiq8jH3t2pTZ3wtV5qqWvREftWpHip6Qm/ku1MvPKdjQN9OaJL/dTZqq+92eNMTqNhR63wx+vwFH7a+Nq0mgZ1JKXB79MUm4Sj295HLPFLC22jBhyfKraPUJCaP7uO+h9fTlzxzRO/fWXU7HdAW1skefrqmORM0ia1I0dO5agoCB69uzJlClTWLJkCRs3bqw3d/RoaGhoaCjD38uDZ67tyLGMAt7anCiv8VUvQNNO8PXdkHNGUfy+EX15rPdjbE7ZzKt7XlWk4SqMkZE0f/cdLGVleL3wIqbz5+s6JY3/OJImdQcOHODcuXO8+eabfPfdd5w8eZLnnnuOzp0707RpU1fnqBgPD0UPzKh1wsLC6kUMpRpy2knxdeRjz67U5k64Ok+19JXoqF0rUvyU1MR/rVaGdWjC1Z0iWPbrCRLPXXwZ1G4Mo/c/6+tM8PntNa6vc5TnTe1uYlzbcbx38D2+S/xOcjs5MaT42LJ7tW5N9PI30efkcGbanZgLql8m/q/Vi6v1G/LY4iw6IXMvkpYtW1502vDChQuEhEh7pEtt06NHD3bt2lXXaTikrKzM5Td1qBFDqYacdlJ8HfnYsyu1uROuzlMtfSU6ateKFD8lNfFfrJXM/BKGLd5MXEQgq6f1Ra/XSY9x8MuKSV2/++HK6nvYSdEot5Rz1y93sS9zH+9d9R5dGndxq7HlwsaNnH1wOr69ehG94i30Vfz+i/XiSv2GPLb07NmTnf/cfKME2Sv1dDrdRb+764QO6s/z9g4cOFAvYijVkNNOiq8jH3t2pTZ3wtV5qqWvREftWpHip6Qm/ou1Eh7gzayRcfyVlM1nO/+9lCopRscboNcdsP01OLJOUZ5GvZGXB71MuG8403+dztnCs241tpwMDibyuQUU/fkn6Y8/gajy7PH/Yr24Ur8hjy3OImlSd9999/Huu++yZ88et9xkWENDQ0PD9YzrGU3vlqE8t+4wmfkl8hpf+RxEdKlYX3fhtKL4wd7BvHbFa5SYS3jw1wcptZQq0nEVQddeS/jMR8hbt47MxYvrOh2N/yCSJnVdunRh7969zJgxg/z8fDp06MCNN97IvHnz+PTTT12do2IuPavornh5edWLGEo15LST4uvIx55dqc2dcHWeaukr0VG7VqT4KamJ/2qt6PU6nr+hEyUmC099lyAvhocX3Pg+CFFxKdb07+4EcvKMDY5l4cCFHMk+wntp72ER1e/ItUVtjS2hU6cScvMEst99j+xPPpEc2x3QxhZ5vq46FjmD7DV1ACkpKRw4cID9+/dz8OBBPvroI1fk5jTOXpvW0NDQ0KjOso3HWfzLMd6d1JMr4prIa5zwDXw2EfreC1c9rziH9w++z+Jdi7m3y73c0/UexTquQJjNpDzwIAW//UazZa8ScMUVdZ2SRj2hVtbUJScnX/RjsViIj49nwoQJLFiwwPp6Xl6e4kRcQX1ZU3fw4MF6EUOphpx2Unwd+dizK7W5E67OUy19JTpq14oUPyU18V+vlbsGxdKuSQBzvj7Ijj375TXucC30vgv+fAMOV9zJqiTPSfGTGBg2kDf2vcFPp35y6F+bY4vOYCBq8aKKp048MpODX37pMLY7oI0t8nxddSxyBkl7fkyaNMnm65WXN4UQ6HQ6Jk+ezMSJE9XLzknqy/q/0lLXrwtRI4ZSDTntpPg68rFnV2pzJ1ydp1r6SnTUrhUpfkpq4r9eK54eep4f04kxb27j/V3n6S33oUIjnoGUv+Hr+6BpJ0V56nQ6bmtyG7n6XOZsnUPzgObEhcXV6F/bY4vex4foN9/g1E0TsDz/AmU9euDp5o8L08YWeb6uOhY5g6RJ3aZNm1wSXENDQ0OjftK9eQgT+8bw4fbT7E6+QPfmMnZC8PCCG1fC8oGwdjK6rsouwxr1RpYOWcqEHybwwK8PsGbUGhr5NFKk5Qo8wsJo/vYKToy9keRpd9JizWo8QkPrOi2NBoyiNXX1BW2fOnVjaPvUuQfaXlLyfLV96lyXZ35JOcNf3kygj5HvHuiPl4dBnsDh7+DTWzH3vAPDKPl3i1a+v8PnDzNp/STahLThvSvfw8tQfRF6XY4teX/vJO2OO/Bq346Y999H7+NjN4+6Qhtb5Pk2iH3q6hPl5bZ3L3c30tLS6kUMpRpy2knxdeRjz67U5k64Ok+19JXoqF0rUvyU1IRWKxUEeBuZcXkTjmUU8NqvJ+QLxF0Dfe/FsPOdihsoZFL5/uLC4ljQfwH7z+3n6e1P21x6U5djS3bjRkQueomS/QdInfkowmyu0bcu0cYWeb6uqhdnaNCTOpPJVNcpSOJ8LTwvUI0YSjXktJPi68jHnl2pzZ1wdZ5q6SvRUbtWpPgpqQmtVv6ljX8ZN3SP4o3fEjmYmitfYNhTFAa3h2/uh+yTsppWfX/DY4Zzb5d7+TbxWz4+/LFdXyl6cu2ObIHDh9Nk1iwKNm4k4/kXHOZSF2hjizxfV9WLMzToSZ2GhoaGhut5clQHQv08+d/n+yk3S9s3zoqHJyd7PAk6HaydDOUyNzWuwl1d7mJo9FAW71zMn+l/KtZxFaG33Uro5Mlc+Phjsj+qPvHU0HAWpyZ16enpbn0XWH1Y8wIVz9OtDzGUashpJ8XXkY89u1KbO+HqPNXSV6Kjdq1I8VNSE1qtXBwj2NeTZ6/rSEJ6Hst/S5StERXfD65bDun74OfZsmJXRa/T89yA52gZ1JKZm2dyJv9Mjb5S9OTYpdrCH52J/9ChZDz/PAWbNzvMqTbRxhZ5vq6qF2dwalJ322230b59e2bOnKlWPv9JLBaZf9nWUQylGnLaSfF15GPPrtTmTrg6T7X0leioXStS/JTUhFYr1WNcGd+UUZ0jePXX4xw9my9fo/1I6Hc//P0OHJS2r5ut9+dn9OOVIa9gERamb5pOUXlRjb5S9KTapdp0BgNRLy3Eq307Uh96mJIjRxzmVVtoY4s8X1fVizM4NanbsGEDJ0+e5Pbbb1crH1UpKytz7OQGnD6t7DmItR1DqYacdlJ8HfnYsyu1uROuzlMtfSU6ateKFD8lNaHViu0YT42OJ8DbyKOf78Mk4zKsVWPYfGjWC759EM47PuNX0/trHticRQMXkZiTyJw/5iCEcKuxRe/nR/Sbb6IPCODM3fdQnpnpMLfaQBtb5Pm6ql6cQdGkrrCwEPM/d+/odDri4+NVTUpDQ0NDo/4R5u/FU6Pj2Z+Syztbk+QLGIwwdiUYPGDtJKfW110WdRkPdX+IX07/wtsH3las4yqMTZoQ/eYbmPPySLnnXixFRXWdkkYDQNKkzmKxsGrVKq6++mrCw8Np3749TZs2pUOHDjz66KOcOKHgVnYbrF27lvj4ePR6fbV9Wp5//nlat25Nu3bt+Oknx4+EAfDwkLS3cp3TuHHjehFDqYacdlJ8HfnYsyu1uROuzlMtfSU6ateKFD8lNaHVSs0xRnWO4Mr4Jrz8yzFOZBbI1wiOhuvfgrMH4KcnZMW+lEnxk7i61dW8tuc1knSOJ5m1PbZ4d+hA1KJFlBw+TNpjjyHq+LK+NrbI83VVvTiFkMDAgQPF008/Lfbt2yfMZrP19fPnz4vPP/9c3HDDDeKjjz6SImWXhIQEceTIETFo0CDx999/W18/dOiQ6Ny5sygpKREnT54UrVq1EiaTyaFe9+7dnc6pNiguLq4XMZRqyGknxdeRjz27Ups74eo81dJXoqN2rUjxU1ITWq3Yj5GRVyw6z/9JXP/6VmEyWxRpiJ/nCjEvUIj9a+W1u9SnvFjc+O2Nos/HfURiTqL8PCTanRlbzn/wgUho116cXbjQrp+r0cYWeb6uqJcePXpIil0Tks7Ubdiwgblz59K5c2f0+oomWVlZhISEMGbMGL744gvGjx/v9AQzLi6Odu3aVXv9m2++4aabbsLLy4uWLVvSunVrduzY4VCvuLjY6Zxqg0OHDtWLGEo15LST4uvIx55dqc2dcHWeaukr0VG7VqT4KakJrVbsxwgP8GbeNR3YnZzD+9tOKdJg6FyI7gPfTYes49LbXYK3hzevDHkFvdAz/dfp5JXlyctDot2ZsSXkttsIuXkC2e++x4XPPrPr60q0sUWer6vqxRkkTep27drF4MGDueGGG9izZw8dO3akY8eONGnShPXr1wNgNBpdkiBAamoq0dHR1t+bNWtGamqqy+JpaGhoaDjH9d2iGNKuMS/9dIRTWYXyBazr6zz/2b9O+R/pEf4R3N/8flLyU3j898cxW9zriQ46nY4ms2bhN2AAZ59+hsJt2+o6JY16iqRFZ/fffz/PPfccubm5DB06lB9//JG+ffty5MgRJkyYwFVXXSU54LBhwzh79my11xcsWMC1114rPfMaWLFiBStWrADgwoUL1me/RkVF4evry/HjFX/xBQUFERsby+7duwEwGAx07dqVI0eOUFhYMQDFxcWRnZ1NRkYGANHR0Xh6epKYWHFXVkhICM2bN2ffvn1AxcS2c+fOJCQkWM8SxsfHk5mZyblz5wCIiYlBr9eTlFSxviMsLAxPT09rnl5eXnTs2JGDBw9a9wDs1KkTaWlp1h2oW7ZsicVisd4907hxY8LDw60zfx8fHzp06MD+/futj0rz8vLi5MmTXLhwAYDY2FjKyso4c6ZiH6cmTZoQGhrK4cOHAfDz86N9+/bs3bvXelOMt7c3J06cIDe3Ytf4Nm3aUFRUZJ1gR0REEBgYyNGjRwEICAigbdu25ObmsmvXLnQ6Hd27d+fYsWPk51dsedCuXTvy8vJIT08HwGw2k5eXZ7effHx87PaTxWIhJyfHZj/l5uayf/9+m/1UXl5u7Qdb/RQZGcmBAwdc2k9dunQhOTnZbj95eHhY87TVT927dycxMVF2P+3evRshhLWdvX6S8n1y1E+2vk9eXl7W9+bo+5Sbm0tWVpbDfvLx8bHbT1Bx5cFWP+Xm5pKQkOCS75Oz/aTW98nZca8ytq1+mtAa/jopmL56J+9M6Ejy6VM2+6mgoGLtXbV+ulBOeadHabPjCUq+nkHBkAUX9ZPRaLTWi6PvU1NTUx7s9CAv73+ZOT/OYWzTsdX6qeifmxVq6qfc3Fzy8vJs9lPlOGern3x8fCR9n85NvA3vpCSSH3iQlp+u4dA/tVFbxyeA7Oxsl417NX2fpIx7cvoJqn+fzGYzBQUFkr5PlX3paNwrKSlBCFHj9yk3N5eioiKb/VQZ49J+chadEDYekncJXbt2Ze/evUBFIVV+sADdunVjz549qiRTyeDBg1m0aBE9e/YEKm6SAHjiiYpFs1deeSXz58+nX79+dnWcfTCuhoaGhoZzfLErhUfW7mPWyPbcOTBWmciGp2Dry3DD29B5nOJchBA8tf0pvjj+BS8NeomrWkg/IVFblKemkjT+JvTe3rRY+xkeISF1nZJGLeLsvEXS5dfKdXRQ8ddQVXQ6neLgUhk9ejRr1qyhtLSUpKQkjh8/Tu/evR22qy9r6vbv318vYijVkNNOiq8jH3t2pTZ3wtV5qqWvREftWpHip6QmtFqRHuOG7lEM79CERT8d41iG7U2JHeY5ZDY0vwy+mwHnjklvd0kMnU7H7D6z6dq4K0/+8SRHs4/KyqM2xhZjVBTRr7+GKTOT1AenI2pxv1VtbJHn66p6cQZJk7p9+/YRGBhIQEAA+/fvJzAw0Pp75WlZNfjqq69o1qwZ27dv5+qrr+bKK68EKk4Rjxs3jg4dOnDVVVfx+uuvYzAYHOpJOAnpFlSegnb3GEo15LST4uvIx55dqc2dcHWeaukr0VG7VqT4KakJrVakx9DpdDx3fSf8vAw88tk+m8+GdZinwQPGvgtGn4r968qKpLWzEcNoMLJkyBICPAN48NcHuVByQXIetTW2+HTpQsSCBRT9/Tdnn3m21o5l2tgiz9dV9eIMkiZ1lesy8vPzMZlM5OXlWX9XM7Hrr7+elJQUSktLycjIuGg/utmzZ5OYmMjRo0f5v//7P9ViamhoaGi4lsYBXiy4vhMHUnN5U8GzYQEIjIQbVkDmYfjxUafyaeTTiFeGvEJWcRYzN8+k3OJ+k/Sga0YRdtdd5Kxdy4WPPq7rdDTqCZLW1NVXevToYV1E686YTCaXb5SsRgylGnLaSfF15GPPrtTmTrg6T7X0leioXStS/JTUhFYrymI8uHoP6w6k8/V9l9MxKkiRBhufgS2L4Lo3MXUc51S9fJv4LbO3zubWuFt5rPdjbje2CIuFlAcfpODXTUS/9Rb+A/rL1pCDNrbI83VFvdTKmrqXX37Z7o+7Ul+e/ZqcnFwvYijVkNNOiq8jH3t2pTZ3wtV5qqWvREftWpHip6QmtFpRFuPpa+MJ8fPkkc/2UWr6d1sRWXkOfgJaDIDvHyZ9369O5Tk6djS3xt3Kx4c/5rvE79xubNHp9US9+CJebdqQ+vDDlJ48qUhHKtrYIs/XVfXiDJImdfn5+eTn57Nz507efPNNUlNTSU1NZfny5dZbed2Rylud3Z3K27jdPYZSDTntpPg68rFnV2pzJ1ydp1r6SnTUrhUpfkpqQqsVZTGCfT15cUwnjmbks3TDvxsKy8rT4AFj3gXvQBr/+jCU2r75QmqeD/d8mJ5NevLU9qfYm7ZXkYYzNkfo/fyIfuN1dJ6enLnnHsw5OYq1HKGNLfJ8XXUscgZJk7p58+Yxb948UlJS2L17N4sXL2bx4sXs2rWr3vzFqqGhoaFR9wxt34TxPaN5a3Miu04rPLAFNIEx7+JVmFrxxAknVhEZ9UYWDVpEsFcwy5KXkVOSo1jLVRijomi2bBmmtHRSZjyEqCc36mjUPpImdZVkZGTg6elp/d3T09O6oZ474uXlVdcpSCI2VuHeTbUcQ6mGnHZSfB352LMrtbkTrs5TLX0lOmrXihQ/JTWh1YpzMeaMiiMiyIeZa/dRXGZWlmfLAZRcNhMOfgF/v+NUnmE+YSwdspQ8cx6P/v4oJotJtoarxxbf7t1o+vTTFP35Jxn/7N2qNtrYIs/XVcciZ5A1qZs4cSK9e/dm/vz5zJ8/nz59+jB58mSXJKYG9eUekNpY+6dGDKUactpJ8XXkY8+u1OZOuDpPtfSV6KhdK1L8lNSEVivOxQjwNvLS2M4kZRXy4vojivPM7zIV2oyAn2ZBqv2lQI5idGzUkQc7PMif6X/y6p5XZWvUxtgSfP11hE6dwoVVq8letUoVzapoY4s8X1cdi5xB1qRu9uzZrFy5kpCQEEJCQli5cqX1KQ/uSH0ZeCsfheLuMZRqyGknxdeRjz27Ups74eo81dJXoqN2rUjxU1ITWq04H+Oy1o2YfFkL3t92inW7TiiLnZIK178F/k0q9q8rrvlyrpQ8O9KR8e3Gs/LgSn469VM1uzuMLeEPP4z/4MFkLHiOwu3bVdMFbWyR6+uqY5EzSJrUVT3j1b17d6ZPn8706dPp1q2bTR8NDQ0NDQ1HPHZVe1o28uP1v3PJK1G4Tsw3FG78APLS4at7wFJ9c2NZOfV6jK6NuzL3j7kcv3DccYNaRmcwELnoJbxatSRlxkOUnTpV1ylpuBGSJnVDhgxh2bJl1W6KKCsr49dff2XSpEl88MEHLknQGerDPlJQ8bDi+hBDqYacdlJ8HfnYsyu1uROuzlMtfSU6ateKFD8lNaHVijoxfDwNLB7XhfPFFuZ/e0h57GY94MoFcOxH2Gb70qnUscVoMLJ48GL8jH7M2DSDvLI8SRq1ObYY/P1p9sYb6HQ6ztxzL+a8PMeNJKCNLfJ8XXUscgZJk7r169djMBiYMGECkZGRdOjQgZYtW9KmTRtWr17NjBkz3HJtXX2Z1IWGhtaLGEo15LST4uvIx55dqc2dcHWeaukr0VG7VqT4KakJrVbUi9G9eQh39Y/hy92prDuQrjx27zuhw3Ww8Wk49YeiPCt9wn3DeXnwy6QVpvH4749jERaHGrU9tnhGR9Ns2auUpaSQ+tDDCJPtmzvkoI0t8nxddSxyBkmTOm9vb+69917++OMPTp8+zcaNG9mzZw+nT5/m7bffvugyrDtRUlJS1ylI4vDhw/UihlINOe2k+DrysWdXanMnXJ2nWvpKdNSuFSl+SmpCqxV1YwwOL6FLsyBmfXWAjDzp4/ZFsXU6GL0MQlrA51OgIFN2nlV9uoV34/Fej7MldQtv7nvToUZdjC2+vXrRdO4cCv/4g8yXlzitp40t8nxddSxyBlk3SgAYjUYiIiIIDg52QToaGhoaGv81PPQ6lozvSmm5hZlr92GxKFyj7R0I4z6Ekhz4YipYnNuAfly7cVzX+jqW71vOr8nSn15Rm4SMG0fIzRPIfu89cr/7rq7T0ahjZE/q6hN6ff14e35+fvUihlINOe2k+DrysWdXanMnXJ2nWvpKdNSuFSl+SmpCqxV1Y/j5+dGqsT+zr45jy/EsPth+Snnsph1h5CJI+h1+e0FWnpf66HQ65vSdQ3xYPLO2ziJHnyMvFxmxnaHJE0/g27Mn6XPmUnzgoGIdbWyR5+uqY5Ez6ITE21aFEKSkpBAdHe2SRFyBsw/G1dDQ0NCoPYQQTP1gJ3+cyOL7B/rTpkmAcrGv74W9q+DWz6H1MKfyOlt4lvHfjyfIK4hVI1fh7+nvlJ4rMGVnkzR2LFgELT9fi0ejRnWdkoYCnJ23SD6VpdPpGDlypOJAdUFRUVFdpyCJvXv31osYSjXktJPi68jHnl2pzZ1wdZ5q6SvRUbtWpPgpqQmtVtSNUamh0+l4cUxn/L08mL5mL2Um+9uT2I09chGEd4AvpkFuilNjS1O/piwatIjTuaeZ88cc640TUnOpjX7wCA0l+vXXMefkkPLgdISCfVq1sUWer6uORc4g6/pk9+7d+fvvv12SyH8Zs9m5dR+1FUOphpx2Unwd+dizK7W5E67OUy19JTpq14oUPyU1odWKujGqajQO8OKFMZ1JSM9jyYZjymN7+sK4D8BcBmtvx1xeKiuPS+nVtBfjm45nY/JG3j3wrqy2tVUv3nFxRD63gOLduzn77ALZ7bWxRZ6vq45FziBrUvfXX3/Rt29fYmNj6dy5M506daJz584uSUxDQ0ND47/J8A5NuKlXNMs3J7IjKVu5UKM2FXfEpuyg2eEVTuc1ImwEI1uOZNmeZWxN3eq0nisIHDmSsDvvJOezz7iwZk1dp6NRy0heUwdw+vRpm6/HxMSolpCa1Jc1dUIIdDqd28dQqiGnnRRfRz727Ept7oSr81RLX4mO2rUixU9JTWi1om4MWxqFpSZGvroFk1nw44wBBHoblcde9yjsWAHjPoIOo2Xlcam9xFzCbetuI60wjU+v/pTowGiHbWu7XoTZzJl776Xwj23ErHwP3169pLXTxhZZvq4YW2ptTR1A8+bN2bJlCx988AExMTHodDoyMjIUB3c1paWOT7e7A4mJifUihlINOe2k+DrysWdXanMnXJ2nWvpKdNSuFSl+SmpCqxV1Y9jS8PPyYMn4rpzNK6nxaROSY494lpKwePjmPjivfAxITEzEx8OHJUOWoEPH9N+mU1Re5LBtbdeLzmAgatEiPKOjSZk+g/K0NEnttLFFnq+rjkXOIGtSd++997J9+3ZWr14NQEBAAPfdd59LElOD+rLuJTc3t17EUKohp50UX0c+9uxKbe6Eq/NUS1+Jjtq1IsVPSU1otaJujJo0ujcP4b4hrWt82oTk2B5eHO86G3R6WDsJyotl5XGpPTogmpcGvkRiTiLzt81HCOF2Y4shIIBmr7+OKCvjzP33Yym2/Z6roo0t8nxddSxyBtlr6l5//XW8vb0BCAkJoUzBHTYaGhoaGhpSeGBoa+vTJs7mKn9KUJlvU7hhBZw9AD8+5nRel0VdxgPdHuDHUz/yYcKHTuu5Aq9WLYlavIjSw0dInz0HGautNOopsiZ1RqMRs9lsvQ587tw5t97g18vLq65TkESbNm3qRQylGnLaSfF15GPPrtTmTrg6T7X0leioXStS/JTUhFYr6sawp2E06Gt82oTseml7JfR/CHZ/APuq30Qgt1amdpzK8JjhvLzrZfKC8yS3q038Bw2i8UMPkbduHeffeceurza2yPN11bHIGWTNyB588EGuv/56MjMzmT17Nv3792fWrFkuSUwNLBb7exy5C7Wxn54aMZRqyGknxdeRjz27Ups74eo81dJXoqN2rUjxU1ITWq2oG8ORRqvG/swd1YGtJ7J4d2uSothW3yFzIKY/fP8QZB627SMxT51OxzOXP0PLwJbM/WsuZwvPSmpX24RNu4PAkf/HuZeXULB5c41+2tgiz9dVxyJnkDWpu+WWW1i4cCFPPPEEERERfP3119x4440uSUwNysvL6zoFSaSmptaLGEo15LST4uvIx55dqc2dcHWeaukr0VG7VqT4KakJrVbUjSFFY0LvaK6Mb8LCn45wMDVXdmyrr8EDxr4Lnv7w2UQoLZCchy27n9GPJUOWUGou5eHfHqbMXH1JUl3Xi06nI2LBArzi2pM681FKk5Js+mljizxfVx2LnEHWpO7WW29ly5YtXHHFFdx///3ExcW5JCkNDQ0NDY2q6HQ6XrihM2F+Xjy4Zg9FZSblYgFNKyZ250/Ad9PBybVmLYNaMq3ZNA5kHeCFHS84blAH6H18iF62DJ2HByn33Y85P7+uU9JwAbImdVOnTiU9PZ0HHniAVq1aMWbMGF555RVX5eY0RmP1fY3ckYiIiHoRQ6mGnHZSfB352LMrtbkTrs5TLX0lOmrXihQ/JTWh1Yq6MaRqhPh58vL4LiRlFfLM9wnO1UvLgTBkFhz8HHa+KykPe/ZR7UYxteNU1h5by1fHv5LcrjYxRkUR9cpSypKTSXv0f4hLlihpY4s8X1cdi5xB1qRuyJAhzJ49m2eeeYZp06axc+dO3nzzTZckpgYGg6GuU5BEYGBgvYihVENOOym+jnzs2ZXa3AlX56mWvhIdtWtFip+SmtBqRd0YcjQui23E3YNiWb3jDH+lSt+L1GaM/o9A6+Gw/glI3e10rdzf7X76RPTh2T+f5dD5Q5La1TZ+vXvTZNYTFPz2G1mvvX6RTRtb5Pm66ljkDLImdVdccQWXX345n376Ke3atePvv//myJEjLklMDUpKlN/+XpscPXq0XsRQqiGnnRRfRz727Ept7oSr81RLX4mO2rUixU9JTWi1om4MuRoPD29Ll2ZBzP32MGk5jvdfqzGGXl+xzYlfOKydxIkD9nfyd1QrHnoPFg5cSKhPKA9vepickhyH7eqCkAkTCLrhBrLeeIP8jRutr2tjizxfVx2LnEHWpK5z5854enpy8OBB9u/fz8GDBymWsKGhhoaGhoaGWhgNel65qRsmCzz06V7MFifWxPmGwo3vQ146Lfa+6PT6ulDvUJYMXsK54nM8tuUxzBb32wRfp9PRdN6TeHfsSNr/HqP05Mm6TklDJWRN6pYsWcLvv//Ol19+SVhYGLfffjvBwcEuSs153HkPvaoEBATUixhKNeS0k+LryMeeXanNnXB1nmrpK9FRu1ak+CmpCa1W1I2hRKNFIz/uvyycv5KyWb7Z8SOX7MaI7gUjniE4Yxtse1WRRlVbx0YdmdVnFtvStvH63tfdsl70Xl40W/YqOi+vihsnCgq0sUWmr6uORc6gEzK2mH7ttdfYsmULu3btokWLFgwYMIABAwYwdOhQlyTnLM4+GFdDQ0NDw30RQvDgmr2sO5DO53f3o1vzEGfEKrY4OfIDTP4eYi5zOr952+bx5fEveWXIKwxt7p7HycIdO0i+fQr+gwdXTPLqycmQhoqz8xZZvVdSUsLDDz/MkSNH2LBhA/PmzXPbCR3U/YaPUtm9e3e9iKFUQ047Kb6OfOzZldrcCVfnqZa+Eh21a0WKn5Ka0GpF3RhKNfbs2cOz13WkaaA309fsJb+k5r1JHcbQ6djbYhqExMDnU6DgnCwNW7ZZfWbRIawDj29+nNN5p+3HryP8evemyWOPUbBxIweenOfSWNrYoiwfOcia1M2cORNvb2+WL1/Oa6+9xr59+1yS1H+N2ngenxoxlGrIaSfF15GPPbtSmzvh6jzV0leio3atSPFTUhNaragbw5mxJcjHyCs3dSXlQhHzvjlk19cRZg8/GPchFF+AL6bCJevh5NaKl8GLJYOXYNAZmLFpBkXl7nmiIeS2Wwm6djQeX3xB/qZNLoujjS3K8pGDrEndq6++yi233EJmZiaZmZnceuutLFu2zCWJ/ZeofJauu8dQqiGnnRRfRz727Ept7oSr81RLX4mO2rUixU9JTWi1om4MZ8eWni1CefCKNny5J5Wv99jeqV/y2NK0E4x8CZI2w+YXJWvUZIv0j+Se6Hs4mXuS+dvmu+UfBDqdjqZPPYWIiSHt0f/V+MQJNeLUlU59GVucRdaaus6dO7N9+3b8/PwAKCwspF+/fuzfv98lyTmLtqZOQ0ND47+ByWzhphV/cuRsPuseHEDzMF/lYkLA1/fCvtVw6xfQ+gqn83vnwDu8svsVHuv1GLd2uNVpPVdQnppK0pixGBqF0WLNpxj8/eo6pf8ctbqmTghx0Ya+BoPBLf/qqKS+7FN37NixehFDqYacdlJ8HfnYsyu1uROuzlMtfSU6ateKFD8lNaHVirox1BhbPAx6lozvig6Y/ukeTGZLjb4O9XQ6uHoxhMfBl9MgN8WhhiPblI5TGBI9hMU7F7MrY5fDXOqCpMJCopYuoexkEulPPKH68V0bW5TlIwdZk7rbb7+dPn36MH/+fObPn0/fvn2ZOnWqasmsXbuW+Ph49Hr9RTPVU6dO4ePjQ9euXenatSt33323JD3LJY9AcVfya+EZfGrEUKohp50UX0c+9uxKbe6Eq/NUS1+Jjtq1IsVPSU1otaJuDLXGluhQXxbc0Ik9yTm8svG47BgX+Xj6VqyvM5XC2slgKnNqbNHr9Czov4CogCge+e0RMosyHeZT2+Tn5+PXty/hjz5K/i+/cH7F26rr15VOfRlbnEXWpO7hhx9m5cqVhIaGEhoaysqVK5kxY4ZqyXTs2JEvv/ySgQMHVrPFxsayd+9e9u7dy/Lly1WLqaGhoaHRcBjdJZIx3Zvx2qYTbEvMck6sURu49jVI+Rt+edLp3AI8A1gyeAlFpiIe+e0Rys01361bl4ROnkTgqFGcW7qUgi1b6jodDTkICRQXF4slS5aI++67TyxfvlyUl5dLaaaYQYMGib///tv6e1JSkoiPj5et061bNzXTchn5+fn1IoZSDTntpPg68rFnV2pzJ1ydp1r6SnTUrhUpfkpqQqsVdWOoPbYUlJSLIS9tEr0X/CKy8kskx6jRZ91jQswLFMV/fyK/rQ3bjyd/FB3f7yie+/M5hznVJlXzNBcVicRrrxNHevUWpadPq65f2zr1ZWzp0aOHpNg1IelM3aRJk9i5cyedOnXixx9/ZObMma6ea1YjKSmJbt26MWjQILZI/MvBbHa/x7PYIi8vr17EUKohp50UX0c+9uxKbe6Eq/NUS1+Jjtq1IsVPSU1otaJuDLXHFj8vD5bd3I0LheXMXLsPIYRzY8vwp6FZbzx/egTO2V4LJaeOrmp5Fbd1uI1VR1bxXeJ3DvOqLarmqffxodlry9DpdKTcdz+WwkJV9Wtbp76MLc7iIcUpISGBAwcOADB16lR69+6tOOCwYcM4e/ZstdcXLFjAtddea7NNREQEycnJhIWFsWvXLq677joOHTpEYGBgNd8VK1awYsUKADIyMti1q2JBalRUFL6+vhw/XrHOIigoiNjYWOsGgAaDga5du3LkyBEK/yneuLg4srOzycjIACA6OhpPT08SEyseSRMSEkLz5s2t+/UZjUY6d+5MQkKC9Zm48fHxZGZmcu5cxUaWMTEx6PV6kv65ZTwsLIxz586Rnp4OgJeXFx07duTgwYOUlpYC0KlTJ9LS0jh//jwALVu2xGKxcPp0xWaWjRs3Jjw8nEOHKvZo8vHxoUOHDuzfv5/y8orT+xaLhZKSEi5cuABUXM4uKyvjzJkzADRp0oTQ0FAOHz4MgJ+fH+3bt2fv3r3WybEQgqKiInJzcwFo06YNRUVFpKamWvspMDDQ+qDigIAA2rZty6FDh0hPT0en09G9e3eOHTtmXU/Qrl078vLyrO+/uLgYf39/u/1kNpvJy8ursZ9KSkrw9fW12U/Z2dlkZWXZ7KcTJ05Y87DVT5GRkdbvgav6qUuXLiQnJ9vtp9TUVGuetvqpe/fuJCYmyu6n3bt3I4QgOzubyMhIu/0k5fvkqJ9sfZ/Onz9vjeHo+5SdnY2np6fDfiotLSU7O7vGfiotLcXT09NmP2VnZ5OTk+OS75Oz/aTW98nZce/ChQtERkbKHveq9lNOTg6RkZGyv09nz561vldb36fH/68tT39/hKfWbOHyRqX4+vra7afc3FwiIyOr99OpZIraP0L7s9MwrLmFrOs+JSXzwkX9VDnO2eonIQQFBQUX9dNNETex49QO5v8xnzBLGB2bdKzz41NpaSne3t4X9VP4whdJu/seDt17H7qZj9CxUyfF415N3ycp456kfrLzfSouLpb8fTp9+jTp6ekOx738/HwiIiJq7Kfs7GyCg4Nt9lNlvVzaT04j5XTepZcxXX1Z89LLr3LtlcTFxamZlsvYuXNnvYihVENOOym+jnzs2ZXa3AlX56mWvhIdtWtFip+SmtBqRd0YrhpbLBaLuOODv0XrWT+INT9vd1rv6I/LhZgXJMQX04SwWCS3rcl2ruicGPrpUPF/X/yfyC3NdZifq6kpz6x33hEJ7dqLrHfecYl+bejUl7GlVi6/7tu3j8DAQAIDAwkICGD//v3W/7d1tkxtzp07Z52Nnzx5kuPHj9OqVSuH7YxGo6tTU4WoqKh6EUOphpx2Unwd+dizK7W5E67OUy19JTpq14oUPyU1odWKujFcNbbodDpeGtuZxv5eLNtZYPcxYlL0ArteC0Nmwf5PYed7ktvWZGvk04jFgxeTXpDOrP9v78zjoiq/P/6ZYV9kEREV0FREEQSENMo9cyv3NZfUds19yTTLNNfMBZfKr+aWmbnlkpWmpqWmmSKS4i4oIAqCIPs29/cHOT8NmLn3uc9l7ozn/Xr1eoXnPJ9zYD4cH2fufe6xD6ETTHtiQ0V9Vn3jDVTp0hkpi5cg+8QJ7vqVoWMus0UuojZ1jz5GefjwIbKyslBcXKz/f56fC+/atQs+Pj44efIkXnnlFXTq1AkA8McffyA4OBihoaHo27cvVq1ahapVqxrV05rJg4kdHWUcklmJNVg1pKwTk2ssx1CcNaYmlO6Tlz6LDm+viMlj8QR5hW8NJWeLm6Mtlg1sijsPCzB91wWDZ6+J8kqryYBfB2D/VCAp6skYg25o9VC83+x9/J74O1bHrDZYX2kq6lOj0aDW3Lmw8/PDnYmTUJiYyFW/MnTMZbbIRVW7nl69eiExMREFBQW4d+8eDhw4AADo06cPLl68iOjoaERFRaFbt26i9B595q92Hn0+r/YarBpS1onJNZZjKM4aUxNK98lLn0WHt1fE5LF4grzCt4bSs6XZM1UxoLEz9p6/g+1nK96QiPKKVgv0Xg04ewHbhgG56UbXGtMd2Gggutbrii+jv8SxRNMdIWKoT62jI3xWroAgCEgcPQa6f6/L46WvtI65zBa5qGpTRxAEQRBK0CvACc/X88Aney7ieorMg18dqwL9NgJZycCudwGZB91rNBrMeH4GGrg3wNRjU5GQlSCvP4WwrV0b3osXoeDKFSR/PEPVT5R6WrHoTd3jjzRTM66urmZRg1VDyjoxucZyDMVZY2pC6T556bPo8PaKmDwWT5BX+NaojNlS1c0Nka+GwsHWCqO/O4f8orJHXknyik840Hk+cO1X4Phi2bPFwdoBkW0jIUDAxKMTkV9c+Y+5FNOnc6tW8Bw/Hg/37UP6ho3c9ZXSMZfZIheNYMFbbbkPxq0shH9vp1Z7DVYNKevE5BrLMRRnjakJpfvkpc+iw9srYvJYPEFe4VujMmfLkcspeH3D33gtog5m9wySpFcmLgilz4a9sBPCkF3Q1G8ru88/Ev/AqMOj0L1+d8xpMadSfSbldypp7Dhk/fYbaq9bB6fnxB1zRrPFeEzuvsWi36nLzc01dQuieHTGjdprsGpIWScm11iOoThrTE0o3ScvfRYd3l4Rk8fiCfIK3xqVOVvaNaqOt1vVxaZTt7D/QrIkvTJxjQboGgl4NEDx1mHAwzuy+2zt0xojQ0Zi74292HZlm+h1PBDbp0ajQc3582Fbpw6SJkxAUTlnz8rRV0LHXGaLXCx6U0cQBEEQ/+X9To0Q7OOKKTtikPhA5j/+7ZyBAZugLckHtr8OcHie64iQEWjp3RIL/l6A86mcDqXljJWzU+mNEwUFSBw7DrrCQlO3RIA2daqgMq7941GDVUPKOjG5xnIMxVljakLpPnnps+jw9oqYPBZPkFf41qjs2WJrrcWKgU2hE4CxW86hqEQnSq/CuGdDJDT9AEg4BRz8RFafAKDVaLGg1QJ4OXph4tGJuJ93X9J6VqT2aVevHmrOn4f8mBjcmzuPuz5PHXOZLXKha+oIgiCIp5K95+9g7JZzGNWuPt7v1Ei+4M9TgNP/A/p/AzQu/7GXUriUdgmv/fIagj2DsbrDalhrRT3Zs9JJWbwEaWvWoObcOXDr08fU7Zg1dE2dAfLzK//uIRYuX75sFjVYNaSsE5NrLMdQnDWmJpTuk5c+iw5vr4jJY/EEeYVvDVPNlu4htTDgWV98efQGjl+7L98rHecA3s8Cu0cB968z9fk4AR4BmPH8DPx9929Eno1k0pACa5+e48fB6YXncXfWp8j75wJ3fR465jJb5GLRmzqdzLODKotHD2hWew1WDSnrxOQayzEUZ42pCaX75KXPosPbK2LyWDxBXuFbw5Sz5ZPujVHf0xkTtkUjKc3wE5KMesXaFui3AbCyAbYNBQpzJff5X7rX744BDQdgY+xGHIg/wKwjBtY+NVZWqLV4MayqeSBx7FgUp6dz1eehYy6zRS4WvakjCIIgCEM42lpj5aCmyMwrwvLTmdDpZF6R5OYL9FkDpMQCP00sPfZEJh80+wDBnsH4+MTHuJlxU7aeEli7u8Nn+QqUpKUhadIkCMXFpm7pqcSir6kLCwszi6MHcnNzFX9GI48arBpS1onJNZZjKM4aUxNK98lLn0WHt1fE5LF4grzCt4YaZsu3p27ho90X8H6nhhjVzk+yRpnYkfnA7wuAbsuQG9Bf9s/obs5dDNg3AC62LtjyyhY42zrL0isPHq9lxs4fkDx9OjzefgvVJ03irs+qYy6zha6pM0CxmfxLIb2Ct6rVVoNVQ8o6MbnGcgzFWWNqQuk+eemz6PD2ipg8Fk+QV/jWUMNsGfxcbbRv4IYlB6/idJz0171MrM0UoP6LwM9TkHX1uOg+K6KGUw0sarMICVkJmPGnMo/o4vFauvXpDbdXByBtzdd4eOBX7vqsOuYyW+RCmzoVcO/ePbOowaohZZ2YXGM5huKsMTWhdJ+89Fl0eHtFTB6LJ8grfGuoYbZoNBoMD7SFr7sDxm45h/ScsueuSfKK1gro/TXg5Am3A2OAvAeie62IZjWaYXzYeBy8dRAbLm6QrfdfePnF68MP4RASguRp01Bw4wZ3fUueLXKx6E0dQRAEQYjF0UaLlYPCkJ5TiInbouVfX+fkAfTbAJv8+8CuEQCHm/eGBQ5DhzodEBkVib+S/5KtpwRaW1t4L18GjYMDEkePQUl2tqlbemqw6E2dra2tqVsQha+vr1nUYNWQsk5MrrEcQ3HWmJpQuk9e+iw6vL0iJo/FE+QVvjXUNFuCvF3xcdcAHL2Siv/9cbNMXLK+bzPktJgGXN0PnIgU3W9FaDQazG4xG3Vc6mDKH1NwN0fcI7rEwNMvNl5e8F66BIW3byN52jQIgkCzhbEfKVj0ps4cHrgNVM7mk0cNVg0p68TkGssxFGeNqQml++Slz6LD2yti8lg8QV7hW0Nts2VIRB280qQmFv16BWfi08vEpeqXhL8JBPUBfpsNxP0huueKcLJxQmTbSOQX52PS0UkoLOHziC7efnFq3hzV35+MrIOHkLbma5otjP1IwaI3dQUFBaZuQRQ3HrvmQM01WDWkrBOTayzHUJw1piaU7pOXPosOb6+IyWPxBHmFbw21zRaNRoP5fZrA280BY7acw4N/r69jni03bwLdlgEefsCON4CHyaL7roh6bvUwu8VsxNyPwcK/F8rWA5TxS9Vhw+Dy8stIjYxE3O7dXDQtebbIxaI3dQRBEATBgou9Db4YFIa07EJM2n5e/vV1dlVKHx9WmAPseB0oKZLdY8dnOmJ44HBsvbIVe67vka2nBBqNBjXnzIZd/fqwW/kFChOTTN2SRWPRmzpzeei2u7u7WdRg1ZCyTkyusRxDcdaYmlC6T176LDq8vSImj8UT5BW+NdQ6W5r4uOKjrgH47XIK1hy7KX+2VA8Aui0Hbp8EDs8S17gRxoWNQ7MazTD71GxcTpf36Cml/KJ1dITPiuXQCAKSxo6FTuYjPC15tsjFog8fDg8Px9mzZ03dhlGKi4thba3sg5p51GDVkLJOTK6xHENx1piaULpPXvosOry9IiaPxRPkFb411DxbBEHAqO+icODiPWx5qxma1/OUrF8m9tMk4O+vgQHfAgHdRPVviPt59zFg3wDYaG2wtetWuNq5Muko7ZeMQ4eRPHo0XHv1Qs15c5mve7fk2UKHDxsgLy/P1C2I4vz582ZRg1VDyjoxucZyDMVZY2pC6T556bPo8PaKmDwWT5BX+NZQ82zRaDRY0CcY3m4OeG/TGf31dVL0y8Q6zQNqhQG73wPS5F9bVc2hGpa0XYJ7ufcw7dg06AS2o1OU9ssNdzdUe+89ZO7ahYytW5l1LHm2yMWiN3UEQRAEIRcXexusHNQUGfk6TN5+Xv7THKztgP4bSw8o3jYUKJL/BkSIZwimNpuKY0nH8L/z/5OtpxTVRo+CU5vWuDt3HnLPnTN1OxaHRW/qzOVIExsbG7OowaohZZ2YXGM5huKsMTWhdJ+89Fl0eHtFTB6LJ8grfGuYw2wJ9nHDG2FuOHw5BV8fi5O0ttyYW22g9xrg3kXgp8lGexND/4b90b1+d3x1/iv8kSj96JTKmC0arRbeCxfCpkYNJI0bj+L795l0lFxjytkiF4u+pk7uZ9MEQRAE8QhBEDDy2ygcunQP20Y8j7DaHC52/20u8MdCoPsKIGyobLm84jy89vNruJNzB1u7boVvFXUelJ1/+TLiXx0Ih6Ag1F6/Dhoz+YeS0tA1dQbIl3mHTWURGxtrFjVYNaSsE5NrLMdQnDWmJpTuk5c+iw5vr4jJY/EEeYVvDXOZLZcuXcJnfYNRw9UeY747h4zc/7++jnm2tJ0K1Gtb+m5dsvzrrBysHbC07VIAwIQjE5BXLP6j3cqcLfaNGqHm7E+Re+YMUhYtZtZRYo0pZ4tcLHpTp+PwnL3KoDJu6OBRg1VDyjoxucZyDMVZY2pC6T556bPo8PaKmDwWT5BX+NYwp9ni6lB6fl1KVj4mb4/RX1/HPFu0VkCftYCjR+n1dXkZRvs0hq+LLxa0WoArD65gzqk5oq8BrOzZ4tqtG9xfew3pGzcic99PzDq815hytsjFojd1BEEQBMGbEF83TOsSgEOX7mHt8bLX10nGqVrpjROZiaV3xHK4Kqq1T2uMDBmJvTf2YvvV7fJ7VAivKe/D4dlwJH/8MfKvXDV1O2aPRV9TZy7n1OXn58Pe3l71NVg1pKwTk2ssx1CcNaYmlO6Tlz6LDm+viMlj8QR5hW8Nc5wtgiDg3U1nceRKCraPeAGNPO3lz5ZTXwH7pwIvzQJajjeebwSdoMOow6NwKvkUNnTegBDPEIP5ppotxampiOvdBxoHB9TdsR1WLi5MOrzWmHK20DV1Bigqkv8YlsogJSXFLGqwakhZJybXWI6hOGtMTSjdJy99Fh3eXhGTx+IJ8grfGuY4WzQaDT7vGwIvF3uM2hyFG7crfp6r6D6fGwE07ln6tIn44+LWGECr0WJBqwXwcvTCxKMTkZaXZjDfVLPF2tMT3suWoSg5GXemfADByKVTljxb5GLRm7ri4mJTtyCK1NRUs6jBqiFlnZhcYzmG4qwxNaF0n7z0WXR4e0VMHosnyCt8a5jrbHF1tMHKf6+vm7X/RoXXronuU6MpvQu2aj1g++tA1l1x6wzgaueKpW2XIrMgE1P+mIJiXcV/L5pytjiGNYXXtKnIPnoU97/6ilmHxxpTzha5WPSmjiAIgiCUJNTXDR90boTTdwqw/kS8fEF7F6D/JqAgC9jxBlAi/82JAI8AfBzxMU7fPY3l55bL71Eh3AcOhGuPHri/8gtkHT1q6nbMEove1Nna2pq6BVHUqVPHLGqwakhZJybXWI6hOGtMTSjdJy99Fh3eXhGTx+IJ8grfGuY+W95sWRdt/Nwx/5dLOHf7AVPtJ/BqDHSLBG6dAH77VNraCujh1wP9/ftj/YX1OHjrYLk5pp4tGo0GNWbNhF2jRrgz5QMU3r7NpCN3jSlni1wselNnLmi1yr8MPGqwakhZJybXWI6hOGtMTSjdJy99Fh3eXhGTx+IJ8grfGuY+WzQaDWa97AcvF3uM/u5cmefDMn1/Ia8C4a8DJ5YBl8Uf92GID5p/gOBqwfjo+Ee4mXmzTFwNs0Vrbw+fFcsBjQaJo8dAl5vLpCNnjSlni1zMYzIxUlhY/oOX1UZcHIdb4iuhBquGlHVico3lGIqzxtSE0n3y0mfR4e0VMXksniCv8K1hCbMlLTkBXw4OQ2pWASZui4ZOJ4haZ5DOC4CaocCukUDaDTaNx7C1ssXitothb22PCUcmIKco54m4WmaLrY8PvBctQsG1a0ie8UmZaxUtebbIxaI3dQRBEARRWQT7uOHjrgE4ciUVq/6QvwmDjT3Q/5vSGyi2DQUKy75rJZUaTjWwsPVCxD+Mx8cnPhZ9MHFl49yqJTzHjcXDffvwYNO3pm7HbLDoTZ21tbWpWxCFh4eHWdRg1ZCyTkyusRxDcdaYmlC6T176LDq8vSImj8UT5BW+NSxptgyJqINuIbWw6MAVnLqZJrnPMrjXAfp8Ddy7CPw0icvBxM/VfA7jw8bj4K2D+Cb2G/2fq222eLzzDpzbt8e9hQuR+9jZbZY8W+RChw+rgMLCQsVv6uBRg1VDyjoxucZyDMVZY2pC6T556bPo8PaKmDwWT5BX+NawtNmSXVCM7iuOI7ugGD+NbQVXO4381+HIfOD3BUDXSODZ1+VpofTw5IlHJ+JIwhGs6bgGzWo0U+VsKcnKQny//ijJzkbdnTtg4+Vl0bPFog4ffv/999GoUSMEBwejV69eyMjI0Mfmz58PPz8/NGzYEAcOHBClZy7PZ/znn3/MogarhpR1YnKN5RiKs8bUhNJ98tJn0eHtFTF5LJ4gr/CtYWmzxdnOGl8OCUNmXhHGfX8O0TExovuskDZTgPrtgV+mAEny36zQaDSY3WI2fKv4YvLvk3Ev554qZ4tVlSrwWbkCutxcJI0bD6Gw0KJni1xUtanr0KEDLly4gJiYGPj7+2P+/PkAgNjYWHz//fe4ePEi9u/fj/feew8lJSUm7pYgCIIgyqdRDRfM7hmEP2+kYdvFbPmCWqvSj2GdvYBtw4DcdNmSzrbOiGwXibziPEz8faLBg4lNiZ2fH2rNm4u86GjcW7DA1O2oGlVt6jp27Ki/Di4iIgKJiYkAgD179uDVV1+FnZ0d6tatCz8/P5w+fdqonkajUbRfXtjZ2ZlFDVYNKevE5BrLMRRnjakJpfvkpc+iw9srYvJYPEFe4VvDUmdL/2d90S/cBzsv5eD3qxyeIOBYFei/Eci+B+x8C9DJf3Ojvlt9zG4xGzGpMdiWuk1+jwaQ4xWXzp1R9c038OC7LbD/809Fa5tytshFtdfUdevWDQMGDMCQIUMwevRoREREYMiQIQCAN998E126dEHfvn0Nasj9bJogCIIg5JBXWIJeX55ASlYBfhrbEjVdHeSLnlkH7JsAtJkKtJsmXw/Aor8XYWPsRsxrOQ/d6nfjoskbobgYt996G3lRUaiz5Ts4BAaauiXuyN23VPrtoS+99BLu3i37PLu5c+eiR48e+v+3trbG4MGDJeuvXr0aq1evBgAkJSXpb5Tw9vaGo6Mjrl27BgBwdXVF/fr1ERUVBQCwsrJCaGgoLl++jJyc0rN7AgICkJ6ejnv37gEAfH19YWtrixs3Sm9Vd3d3R+3atXH+/HkAgI2NDYKDgxEbG6u/ni8wMBApKSn657zVqVMHWq1Wf0aNh4cHMjMz9c+ptbOzQ1BQEC5cuICCggIAQJMmTXDnzh2kpZXeSVW3bl3odDrcunULAODp6Ynq1avj4sWLAAAHBwc0btwYMTExKCoq0vfm7OyMBw9KTzuvX78+CgsLkZCQAADw8vJC1apVcenSJQCAk5MTGjVqhOjoaP1H3ba2tnBwcEBmZiYAoEGDBsjNzUVSUhIAoGbNmnBxccGVK1cAAFWqVIG/vz8OHz4MNzc3aDQahIWF4erVq8jKygIANGzYEA8fPkRycunDsIuLixEQEGDwdbK2toa1tXWFr1NJSQn8/f3LfZ0yMjLg6elZ7ut07tw5/YWr5b1OtWrV0l8HodTrFBISgtu3bxt8nVJTU6H794HX5b1OYWFhuHHjhuTXKSoqCoIgICMjA+3btzf4Oon5fTL2OpX3+5Sdnf2EZw39PmVkZCAkJMTo6/SIil4nQRDwzDPPlPs6ZWRkoGbNmor8Psl9nXj9Psmdew8fPkS7du0kz73HX6esrCy0bdtW8u9Tenq6/udp7PcpIyMD4eHhBl+nnJwctG7dusLXKSMjA82aNSv3dfrrr7/g5uZW7us0vlkVTPglG8NXH8OnbasiMKCR5N+nJ1+nYIQE9YfV75/hep4rHno9J/vvp9aa1jjleAqz/pyF4uRi1HaozX3uVfT7JGbu6V+nYUNhd/UqEseMQc7MmShxchL1+1RUVISgoCBRv08JCQlwc3MzOvfy8vLQokWLCl+njIwMPP/88+X+Pp09exZubm5lXifZCCpj/fr1QkREhJCTk6P/s3nz5gnz5s3Tf92xY0fhzz//NKoVEBCgSI+8OXPmjFnUYNWQsk5MrrEcQ3HWmJpQuk9e+iw6vL0iJo/FE+QVvjWehtmyNzpJqPPBPmHuT7FG+xBFQY4gfPmCIMyvLQjp8VwkD586LLy49UWh847OQkZ+BhfNx+Hlx6ht24RLTYKF+OHDBV1REffappwt4eHhompXhKquqdu/fz8WLlyIvXv3wtHRUf/n3bt3x/fff4+CggLExcXh2rVraN68uQk7JQiCIAjxdAuphdci6mD1Hzfx68Wyn1ZJxtax9GBiQSg9mLgoX7akq7UrFrddjLu5d/Hh8Q+hE3Ty+1QAXb16qPHJJ8g9eQqpy5aZuh1Voapr6vz8/FBQUKA/lC8iIgKrVq0CUPqR7Lp162BtbY3IyEh06dLFqB6dU8e3hqWdJSWnT1OixrOkeOmYy1lS5BW+NZ6W2VJQXIK+X51EfFoOfhrTCrU9HMvNl8Tln4HvBwJhw4Duy2VJPepzy+UtmPfXPIwKHYURISPk9/gffV46yTNnIuP7rfBetgwunTpyq03n1HHi+vXrSEhIQHR0NKKjo/UbOgCYPn06bty4gStXroja0AHQf16vdu7cuWMWNVg1pKwTk2ssx1CcNaYmlO6Tlz6LDm+viMlj8QR5hW+Np2W22Flb4cvBYQCAUd9FIb+Iw9FcjV4GWk4EojYC5+Q9TutRn682fBVd63XFl9Ff4ljiMfk9/kefl47Xhx/CISQEydOmoeD6dW61TTlb5KKqTR1vHt18oHYeXWCq9hqsGlLWick1lmMozhpTE0r3yUufRYe3V8TksXiCvMK3xtM0W3yrOmJxvxD8k5SJuT9dMtqTKNpNB+q2Ln2MWDL7QceP+tRoNJjx/Aw0cG+AqcemIjErkUubvGeL1tYW3suXQePggMTRY1Dy7w1DcmubcrbIxaI3dQRBEAShNjoG1sA7reth06lb2Huewzs2VtZAn3WAQ1Vg22tA3gPZkg7WDohsG6l/nFh+sfxr9pTAxssLPpFLUZiQgDtTp0HQqfM6wMrCojd15nDNC1B6C7g51GDVkLJOTK6xHENx1piaULpPXvosOry9IiaPxRPkFb41nsbZ8n6nhni2jjum7ozB9RQOT5xw9iw9mDgzEdg1EmDY3Py3T18XX8xvNR+X0i9hzqk5kHsJvlKzxbFZM3h9MAXZhw8jbfUa2bVNOVvkYtGbOnNBVwn/suBRg1VDyjoxucZyDMVZY2pC6T556bPo8PaKmDwWT5BX+NZ4GmeLjZUWKwY1hb2NFUZtjkJeIYfr63ybA53mAVd/AY4vkby8vD7b+LbBiJAR2HNjD7Zf3S6rPSVni/trr8Gla1ekLluG7GPHZdU25WyRi0Vv6goLC03dgigeHdKo9hqsGlLWick1lmMozhpTE0r3yUufRYe3V8TksXiCvMK3xtM6W2q6OiByQCiupmTh4z0XjPYniubvAEF9gSNzgRtHJC2tqM8RwSPQwrsF5p+ej5hU9mv2lJwtGo0GNT+dBTt/fyRNnozCxESja6Tos+SZ4u8bi97UEQRBEISaae3viTHt/LDjbCK2nUmQL6jRAN2WAdX8gZ1vln4cKxMrrRU+a/UZvBy9MPHoRKTnp8vvUwG0jo7wWbEcEAQkjhkL3b9PzniasOhNnbV1pT8FjQlPT0+zqMGqIWWdmFxjOYbirDE1oXSfvPRZdHh7RUweiyfIK3xrPO2zZdxL/nihvgc+3n0Bl5IfGm5SDHbOwIBvgeICYNswoFjcp1aG+nS1c8WStkuQUZCBKb9PQbFO+ukSlTFbbGvXhveiz1Fw+TLuzpypvw7QXGaLXCx6U2djY2PqFkRRvXp1s6jBqiFlnZhcYzmG4qwxNaF0n7z0WXR4e0VMHosnyCt8azzts8VKq8GyV5vCxcEG722OQlY+hzNWqzUAenwBJJ0Bfp0uaomxPht7NMZHER/hr7t/YcW5FZJbqqzZ4ty6NaqNGY3MPXvx4NvNkmubcrbIxaI3dXlm8tbrowe8q70Gq4aUdWJyjeUYirPG1ITSffLSZ9Hh7RUxeSyeIK/wrUGzBfCsYocVA5viVloOpv7wj+w7TQEAgT2B50cDp1cDMduMpovps6dfT/Tz74d1F9bh0K1DktqpzNlSbcQIOLdrh3uffYbcM2fMZrbIxaI3dQRBEARhLkTU88DkTg3xU0wyNp3idCH9SzOB2i8AP44D7sVykZzafCqaVGuCj058hLjMOC6avNFotai18DPYensjcfwEaB7IP7vPHLDoTZ1Wax7fnoODg1nUYNWQsk5MrrEcQ3HWmJpQuk9e+iw6vL0iJo/FE+QVvjVotvw/I1rXR7uGnpi9LxbnEzJEr6sQKxug33rArkrpwcT5FV+zJ7ZPWytbLGm7BLZaW0w4MgG5Rbmi1lX2bLGqUgXeK5ZDl5sL+xUrIYg8EcOUs0UuGoHLe7zqRO6DcQmCIAiisnmQU4iuK0rPWts3piXcnTgcpB9/AtjYrfRZsf03ld4lK5NTyafw7sF30aFOB3ze+nNoOGgqwcNffkHShIlwHzQQNWbMMHU7BpG7bzGPt7IYMZdr6mJi2M/9qcwarBpS1onJNZZjKM4aUxNK98lLn0WHt1fE5LF4grzCtwbNlidxd7LFl4PDkJKVjwnboqHTcXjv5ZkWQIdZwKUfgT/Lv8lBap8RNSMwtulYHIg/gE2xm4zmm2q2uHTpgpLu3fDguy3I+GEXN32l/CIHi97UmcubkEVFHO50qoQarBpS1onJNZZjKM4aUxNK98lLn0WHt1fE5LF4grzCtwbNlrKE+LphRtfGOHolFV8cuS55fbk8PxoI6A4cmgnEl33qAkufbwS9gfa122PJ2SU4c9fwO0ymnC0FffvCMSICd2fORJ6RmxRMOVvkYtGbOoIgCIIwV4ZE1EGP0FpYcugqjl+7L19Qoyk95qRqXWD760DWXQ6SGsxpMQe+VXwx+ffJSMlNkd+nElhZwXvJYlh5eCBpzFgUW+iNExZ9TV14eDjOnj1r6jaMUlxcrPhByTxqsGpIWScm11iOoThrTE0o3ScvfRYd3l4Rk8fiCfIK3xo0Wyomt7AYPVaeQFpOIX4a2xI1XTlcYJ9yCVjzIlAzBBj2Y+nNFDL7vP7gOgb9PAgN3RtiXad1sLEqe06sGmZL3j8XcGvwYDg+Gw7fNWugsbJi1lfCL3RNnQHM5dmvt2/fNosarBpS1onJNZZjKM4aUxNK98lLn0WHt1fE5LF4grzCtwbNlopxtLXGV0PCUVBUglGbo1BYzOFB8NUDgG7LgdsnSz+K5dCnn7sfPm3xKaJTo7HozKJyc9QwWxyaBKHGJzOQ8+dJpEYuk6WvlF/kYNGbupKSElO3IIoHlfA2MI8arBpS1onJNZZjKM4aUxNK98lLn0WHt1fE5LF4grzCtwbNFsP4VXfGZ32DEXU7A/N/uSRLS09wP6D5O8DJlcDF0psH5PbZ+ZnOGNp4KL67/B323dxXJq6W2eLWpw/cBgxA2po1eHjgV2Z9pfwiB4ve1BEEQRCEJdA1uBaGv/AM1p+Ix76YO3xEO84FfJoBe0YDqVe5SI4PH49wr3DM+nMWrqRf4aKpBF7TP4R9SDCSp01DwY0bpm6HGxa9qbOzszN1C6KoX7++WdRg1ZCyTkyusRxDcdaYmlC6T176LDq8vSImj8UT5BW+NWi2iOPDlwMQVtsNH+yIwY3UbPmC1rZAv42AtT2wdQjq+9aQLWmjtcGiNotQxbYKJhydgIeF/3/YsZpmi9bWFj7LlkHj4IDE0WNQkp1dYS5rH6b4+8aiN3Xmcg9IZVz7x6MGq4aUdWJyjeUYirPG1ITSffLSZ9Hh7RUxeSyeIK/wrUGzRRy21lp8MTgMdjZWGPntWeQWFssXdfUG+q4F0q7B/tf3AQ5/b1ZzqIYlbZcgOTsZ049Nh04ovQ5QbbPFpkYNeC9dgsLbt3Hng6kQdNL6VMovcrDoTZ25DN6EhASzqMGqIWWdmFxjOYbirDE1oXSfvPRZdHh7RUweiyfIK3xr0GwRT01XByx7NRTXUrIxfdcFPm9e1GsLvPgR7K//BJxeLV8PQGj1ULzf7H0cTTyKr//5GoA6Z4tT8+bwmvI+sg8fRtrqNZL0lfKLHCx6U0cQBEEQlkarBp4Y394fu84lYfNfnO6ibDEBGV4vAAc+BG7/xUVyYKOBeKXeK1h5biVOJJ3goqkE7kOHwuWVV5C6bBmyj5U9lNmcsOhNnTmcIwUAXl5eZlGDVUPKOjG5xnIMxVljakLpPnnps+jw9oqYPBZPkFf41qDZIp0xL/qhjb8nPv0xFjGJGfIFtVrkdFwMuPoA24cB2amyJTUaDWZEzICfux8+OPYB4CK/TYD/bNFoNKg5+1PYNWiApMmT4akTd2yMUn6RA23qVEDVqlXNogarhpR1YnKN5RiKs8bUhNJ98tJn0eHtFTF5LJ4gr/CtQbNFOlqtBpEDQuFZxQ4jv43Cgxz5lxu513wG6L8JyHsA7HgdKJF/zZ6jjSMi20ZCp9Nhfux8FJQUyNZUYrZoHR3hs3IFIAgonDMXOhHPjlfKL3Kw6E1dfn6+qVsQxaVLnM4dUrgGq4aUdWJyjeUYirPG1ITSffLSZ9Hh7RUxeSyeIK/wrUGzhQ13J1t8MTgMKVn5mLAtGjqdvOvrLl26BNQMBrouBeKPAb/N5tJnbZfamNdqHq5kXMHcU3NlXweo1GyxrV0b3p8vROHVq7g7c6bRPpXyixwselNHEARBEJZMqK8bZnRtjKNXUvHl0eucRAcB4cOBE5HApR+5SLb1bYtunt2w6/ou7Ly2k4umEji3aYOi3r2RuWcvHmz+ztTtSMaiN3VarXl8e05OTmZRg1VDyjoxucZyDMVZY2pC6T556bPo8PaKmDwWT5BX+Nag2SKPIRF10CO0FpYcvIoT1+8z6zzRZ5eFgHc4sGskt4OJB9cdjBa1WmDeX/Nw4f4FZh2lZ4vt4EFwbtcO9xYsQK6B58cr5Rc5aARzOcyNAbkPxiUIgiAIcyC3sBg9Vp5Aek4hfhrbCjVc7eWLZiYC/2sNOFYD3j4M2FWRLZmRn4EB+wZABx22dd0Gd3t3+X0qQElWFuL79kNJbg7q7tgJG6/qlVJX7r7FPN7KYiQ3N9fULYgiOjraLGqwakhZJybXWI6hOGtMTSjdJy99Fh3eXhGTx+IJ8grfGjRb5ONoa42vhoQjv6gEo76LQlGJuDs4H6dMn64+QN/1QNo1YM8o2QcTR0dHw83eDUvaLUF6Xjqm/DEFJTrpz2ivjNliVaUKvFcshy4nF0njxkFXzrm3SvlFDha9qTMXSkqkm9oUNVg1pKwTk2ssx1CcNaYmlO6Tlz6LDm+viMlj8QR5hW8Nmi188KvujAV9gnH21gPM//my5PXl9lmvDdD+EyB2D3Bypaz+HukHegTio4iPcCr5FFZGS9esrNli7++PWvPmIS86Gvdmz5GsaQpP0KaOIAiCICyEbiG1MPyFZ7DuRBx+iknmI9piHBDQHTj4CRB3jItkrwa90Ne/L77+52scvn2Yi6YSuHTuBI933kHG9u148P1WU7djFLqmTgUIggCNRqP6GqwaUtaJyTWWYyjOGlMTSvfJS59Fh7dXxOSxeIK8wrcGzRa+FBbrMGD1SVy9m4W9Y1qivqezqHUG+yzIAta8COSmA+/+UfrMWIn8V7+wpBDDfhmG+Ifx2PLKFjzj+oz8Pjms+W+uUFKChJEjkXPyFOpsWA/H8HBRmiyeoGvqDFBQIP+Qw8rgxo0bZlGDVUPKOjG5xnIMxVljakLpPnnps+jw9oqYPBZPkFf41qDZwhdbay2+GBQGOxsrjPz2LHILxR0ibLBPuyrAgM1AcT6wbShQLP3v1//q21rZYknbJbDWWmPC0QnILRJ3HXxlzxaNlRW8Fy2Cba1aSBw3HkV374rSNIUnLHpTZy7XvWRmZppFDVYNKevE5BrLMRRnjakJpfvkpc+iw9srYvJYPEFe4VuDZgt/ark5YNmrobiWko2Pdl0QdeCv0T49/YGeXwJJZ4D9UyX3VJ5+TeeaWNh6IW5m3sQnf37Cp0+Za8rLtXJxgc8XKyHk5iJx7DjoCgoU84scLHpTRxAEQRBPK60aeGJ8e3/8cC4J352+zUe0cY/Sa+zOrAPObeYi+Xyt5zGm6Rjsj9+PzZf4aCqBnZ8fan62APkxMbg761PZdwMrgqAiJk+eLDRs2FBo0qSJ0LNnT+HBgweCIAhCXFycYG9vL4SEhAghISHCu+++K0ovNDRUwW75kZmZaRY1WDWkrBOTayzHUJw1piaU7pOXPosOb6+IyWPxBHmFbw2aLcpRUqIThq79S2jw4c/C+YQHBnNF91lcJAgbugrCp56CkHROdC+G9HU6nTD28FghdGOocObuGT59Mq4xlpuybLkQ27CRkPT118w6FcXCw8ONN2gAVb1T16FDB1y4cAExMTHw9/fH/Pnz9bH69esjOjoa0dHRWLVqlSg9nU76OT2moDLO0+NRg1VDyjoxucZyDMVZY2pC6T556bPo8PaKmDwWT5BX+Nag2aIcWq0GkQNC4VnFDiO/jUJGbtnz1h4huk8r69Lz65w8ga2vld48IQJD+hqNBnNazoFPFR9MOjoJKbkp8vtkXGMst9roUXBu1w6ZS5Yi9++/mXSU8oSqNnUdO3aEtbU1ACAiIgKJiYmy9IqKini0pThJSUlmUYNVQ8o6MbnGcgzFWWNqQuk+eemz6PD2ipg8Fk+QV/jWoNmiLO5OtvhicBhSsvIxYWs0dLryPzaU1KdTNWDAN0D2XWDnm4CIQ4SN6VexrYKlbZcitzgXE45OQGFJ+RtQU88WjVaLWgs/g6569dIbJ5LLPzrGFJ5Q1abucdatW4cuXbrov46Li0PTpk3Rpk0bHDvG55wcgiAIgngaCPV1w4yujXHkSiq+PHqdj6h3OPDy58CN34Aj87hI+rn7YW7LuYhJjcG8v+aJunHCFFhVqYKCiRMgFBYicfQY6PLzTd0SABOcU/fSSy/h7r+3Az/O3Llz0aNHD/3/nzlzBj/88AM0Gg0KCgqQnZ0NDw8PnD17Fj179sTFixfh4uJSRmf16tVYvXo1AODChQsICgpS9hviQGZmJlxdXVVfg1VDyjoxucZyDMUNxVJTU+Hp6SmqT1OitF946bPo8PaKmDwWv5BX+Nag2aIOaLZIy1XCL5cvX0Z2draoPstF1hV5CrB+/XohIiJCyMnJqTCnTZs2wt9//21US+4Fh5XF22+/bRY1WDWkrBOTayzHUNxQjPzCV59Fh7dXxOSx+IW8wrcGzRZ1QLNFWq4aZ4uqPn7dv38/Fi5ciL1798LR0VH/56mpqfoz527evIlr166hXr16pmqTO926dTOLGqwaUtaJyTWWYyheGT9rpVH6e+Clz6LD2yti8izZLzRbpOU+zV4BaLZIzVWjX1T1mDA/Pz8UFBTAw8MDQOnNEqtWrcLOnTsxY8YM2NjYQKvVYtasWaJ+IObymDBCHZBfCLGQVwgpkF8Iscj1ijXHXmRz/Xr5F2/26dMHffr0kaz3zjvvyG2JeIogvxBiIa8QUiC/EGKR6xVVvVNHEARBEARBsKGqa+oIgiAIgiAINmhTRxAEQRAEYQHQpo4gCIIgCMICeGo3dbt378bbb7+NAQMG4NdffzV1O4SKuXnzJt5880307dvX1K0QKiUnJwfDhg3D22+/jc2bN5u6HULF0DwhpCB1r2KWm7o33ngD1atXL/O0iP3796Nhw4bw8/PDggULDGr07NkTa9aswapVq7B161Yl2yVMCA+v1KtXD2vXrlWyTUKFSPHODz/8gL59+2LNmjXYu3evKdolTIgUr9A8IaT4RepexSw3dcOHD8f+/fuf+LOSkhKMGjUKv/zyC2JjY7FlyxbExsbin3/+QdeuXZ/4LyUlRb9uzpw5GDVqVGV/C0QlwdMrxNOFFO8kJibC19cXAGBlZWWKdgkTIsUrBMHiF7F7FVWdUyeW1q1bIz4+/ok/O336NPz8/PRPmnj11VexZ88eTJs2Dfv27SujIQgCpk6dii5duiAsLKwy2iZMAA+vEE8nUrzj4+ODxMREhIaGQqfTmaBbwpRI8Urjxo1N0CGhJqT4JSAgQNJexSzfqSuPpKQk/b+UAcDHxwdJSUkV5q9YsQKHDh3Cjh07sGrVqspokVAJUr2SlpaGESNG4Ny5c5g/f35ltEiolIq807t3b+zcuRMjR460iMdFEfKpyCs0T4jyqMgvUvcqZvlOHQ/Gjh2LsWPHmroNwgzw8PCgjT9hECcnJ6xfv97UbRBmAM0TQgpS9yoW806dt7c3EhIS9F8nJibC29vbhB0RaoW8QrBC3iHEQl4hpMDLLxazqWvWrBmuXbuGuLg4FBYW4vvvv0f37t1N3RahQsgrBCvkHUIs5BVCCrz8YpabuoEDB+L555/HlStX4OPjg7Vr18La2horV65Ep06dEBAQgP79+yMwMNDUrRImhrxCsELeIcRCXiGkoKRfNIIgCAr0TBAEQRAEQVQiZvlOHUEQBEEQBPEktKkjCIIgCIKwAGhTRxAEQRAEYQHQpo4gCIIgCMICoE0dQRAEQRCEBUCbOoIgCIIgCAuANnUEQRAEQRAWAG3qCIIgCIIgLADa1BEE8QQajQaTJk3Sf71o0SLMnDmzUntwdnbW//8LL7wgW2/mzJlYtGhRuTErKyuEhobq/4uPj5ddTy3k5eWhTZs2KCkpkbRuxIgROHHihOR6hYWFaN26NYqLiyWvJQhCPrSpIwjiCezs7PDDDz/g/v37ktcKggCdTse1nz///JOr3n9xcHBAdHS0/r9nnnlGH1Pi+6lM1q1bh969e8PKykrSulOnTiEiIkJyPVtbW7Rv3x5bt26VvJYgCPnQpo4giCewtrbGO++8g6VLl5aJLVmyBEFBQQgKCkJkZCQAID4+Hg0bNsTQoUMRFBSEY8eOoVGjRhg+fDj8/f0xePBgHDp0CC1atECDBg1w+vRpvV7Pnj0RHh6OwMBArF69utx+Hr1rt2rVKv27aXXr1kW7du0AAN9++y2aN2+O0NBQvPvuu/p3pebOnQt/f3+0bNkSV65cEf39//f7SUhIqLDGf+sMHDgQixYtQnx8PIKCgvQ5j7/bWZ5WfHw8AgIC8PbbbyMwMBAdO3ZEXl6efv0333yD4OBghISE4LXXXsOMGTP0P38AmD59OpYtW1bme9m8eTN69Oih/3rv3r3o06fPEzlfffUVxowZo//60qVL8Pf3h5WVlaj8/9KzZ09s3ry5wjhBEAoiEARBPIaTk5OQmZkp1KlTR8jIyBA+//xz4ZNPPhHOnDkjBAUFCdnZ2UJWVpbQuHFjISoqSoiLixM0Go1w8uRJQRAEIS4uTrCyshJiYmKEkpISISwsTHj99dcFnU4n7N69W+jRo4e+VlpamiAIgpCbmysEBgYK9+/f1/fweD+PU1hYKLRs2VLYu3evEBsbK3Tt2lUoLCwUBEEQRo4cKWzcuFHfa05OjpCZmSnUr19f+Pzzz8v9frVarRASEiKEhIQIPXv2LPP9VFRDEIQK68TFxQmBgYH6Go9+hhVpPfqZnTt3ThAEQejXr5+wadMmQRAE4cKFC0KDBg2E1NRU/c8sLi5OaNq0qSAIglBSUiLUq1dP/7N7REFBgeDl5fXEnwUFBQn//PPPE3924MABoX379vqvFy9eLKxdu1Z0/n8pLi4WqlWrVmGcIAjlsDb1ppIgCPXh4uKCoUOHYvny5XBwcAAAHD9+HL169YKTkxMAoHfv3jh27Bi6d++OOnXqPPFxXd26ddGkSRMAQGBgINq3bw+NRoMmTZo8cc3a8uXLsWvXLgBAQkICrl27Bg8PD4O9jRs3Di+++CK6deuGlStX4uzZs2jWrBmA0mvIqlevjvT0dPTq1QuOjo4AgO7du1eo9+jj10fEx8c/8f0cPny43BoAcOzYMdF1DGm1bt0adevWRWhoKAAgPDxc/3P67bff0K9fP1SrVg0AULVqVVStWhUeHh44d+4c7t27h6ZNm5b5ud2/fx9ubm76r8+fPw+dToegoCDcunULP//8M0aOHImioiJoNBp93oEDB7B+/XrR+f/FysoKtra2yMrKQpUqVQz+PAiC4Att6giCKJfx48cjLCwMr7/+utHcRxu9R9jZ2en/X6vV6r/WarX6i+iPHj2KQ4cO4eTJk3B0dETbtm2Rn59vsM6GDRtw69YtrFy5EkDpNW/Dhg3D/Pnzn8h7/KNJFh7/fiqqYQhra+snrsV79H1VpBUfH//Ez8zKyuqJj1/L46233sKGDRtw9+5dvPHGG2XiDg4OT/w8o6OjER4eDgA4ePAgrl27BgCIjY1FSEgIACA3NxcZGRmoVasWDh48aDA/KSkJQ4YMQffu3XHq1KknrqMrKCiAvb29kZ8SQRC8oWvqCIIol6pVq6J///5Yu3YtAKBVq1bYvXs3cnNzkZOTg127dqFVq1bM+pmZmXB3d4ejoyMuX76MU6dOGcw/e/YsFi1ahG+//RZabenoat++PXbs2IGUlBQAQHp6Om7duoXWrVtj9+7dyMvLQ1ZWFn788UfmPiuqAaDCOl5eXkhJSUFaWhoKCgqwb98+o1oV8eKLL2L79u1IS0vTrwGAXr16Yf/+/fj777/RqVOnMuvc3d1RUlKi39jpdDpkZ2ejpKQEP/zwA7KyspCXl4cNGzZg0KBBAIAjR47or1U0ln/+/HkMGjQIEyZMgLX1/78/kJaWhmrVqsHGxobhp00QhBxoU0cQRIVMmjRJfxdsWFgYhg8fjubNm+O5557DW2+9haZNmzJrd+7cGcXFxQgICMDUqVON3m25cuVKpKeno127dggNDcVbb72Fxo0bY86cOejYsSOCg4PRoUMHJCcnIywsDAMGDEBISAi6dOmi/7iThYpqAKiwjo2NDWbMmIHmzZujQ4cOaNSokVGtiggMDMT06dPRpk0bhISEYOLEiQBK7zRt164d+vfvX+HdrR07dsTx48cBAC+//DJu3ryJ0NBQjBgxAhcvXsSzzz6Ld955B2FhYQCAX375BZ07dxaVf/78ef2m/vGPY48cOYJXXnmF6WdNEIQ8NIIgCKZugiAIwhKYOXMmnJ2dMXnyZMVr6XQ6hIWFYfv27WjQoEG5OVFRUVi6dCk2bdokSjMsLAx//fWXqHfZ3nzzTaxZswbp6elYsGCB/hzA3r17Y8GCBfD39xf/zRAEwQV6p44gCMLMiI2NhZ+fH9q3b1/hhg4o3aS1a9dO9OHDUVFRoj82Xbt2LbRaLapVq6bf0BUWFqJnz560oSMIE0Hv1BEEQRAEQVgA9E4dQRAEQRCEBUCbOoIgCIIgCAuANnUEQRAEQRAWAG3qCIIgCIIgLADa1BEEQRAEQVgAtKkjCIIgCIKwAGhTRxAEQRAEYQHQpo4gCIIgCMIC+D/yCoRpfA4wWwAAAABJRU5ErkJggg==", @@ -432,25 +404,9 @@ "execution_count": 10, "metadata": {}, "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "C:\\Users\\matth\\AppData\\Local\\Packages\\PythonSoftwareFoundation.Python.3.7_qbz5n2kfra8p0\\LocalCache\\local-packages\\Python37\\site-packages\\scipy\\signal\\filter_design.py:1632: BadCoefficients: Badly conditioned filter coefficients (numerator): the results may be meaningless\n", - " \"results may be meaningless\", BadCoefficients)\n", - "C:\\Users\\matth\\AppData\\Local\\Packages\\PythonSoftwareFoundation.Python.3.7_qbz5n2kfra8p0\\LocalCache\\local-packages\\Python37\\site-packages\\scipy\\signal\\filter_design.py:1632: BadCoefficients: Badly conditioned filter coefficients (numerator): the results may be meaningless\n", - " \"results may be meaningless\", BadCoefficients)\n", - "C:\\Users\\matth\\AppData\\Local\\Packages\\PythonSoftwareFoundation.Python.3.7_qbz5n2kfra8p0\\LocalCache\\local-packages\\Python37\\site-packages\\scipy\\signal\\filter_design.py:1632: BadCoefficients: Badly conditioned filter coefficients (numerator): the results may be meaningless\n", - " \"results may be meaningless\", BadCoefficients)\n", - "C:\\Users\\matth\\AppData\\Local\\Packages\\PythonSoftwareFoundation.Python.3.7_qbz5n2kfra8p0\\LocalCache\\local-packages\\Python37\\site-packages\\scipy\\signal\\filter_design.py:1632: BadCoefficients: Badly conditioned filter coefficients (numerator): the results may be meaningless\n", - " \"results may be meaningless\", BadCoefficients)\n", - "C:\\Users\\matth\\AppData\\Local\\Packages\\PythonSoftwareFoundation.Python.3.7_qbz5n2kfra8p0\\LocalCache\\local-packages\\Python37\\site-packages\\scipy\\signal\\filter_design.py:1632: BadCoefficients: Badly conditioned filter coefficients (numerator): the results may be meaningless\n", - " \"results may be meaningless\", BadCoefficients)\n" - ] - }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -476,22 +432,6 @@ "execution_count": 11, "metadata": {}, "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "C:\\Users\\matth\\AppData\\Local\\Packages\\PythonSoftwareFoundation.Python.3.7_qbz5n2kfra8p0\\LocalCache\\local-packages\\Python37\\site-packages\\scipy\\signal\\filter_design.py:1632: BadCoefficients: Badly conditioned filter coefficients (numerator): the results may be meaningless\n", - " \"results may be meaningless\", BadCoefficients)\n", - "C:\\Users\\matth\\AppData\\Local\\Packages\\PythonSoftwareFoundation.Python.3.7_qbz5n2kfra8p0\\LocalCache\\local-packages\\Python37\\site-packages\\scipy\\signal\\filter_design.py:1632: BadCoefficients: Badly conditioned filter coefficients (numerator): the results may be meaningless\n", - " \"results may be meaningless\", BadCoefficients)\n", - "C:\\Users\\matth\\AppData\\Local\\Packages\\PythonSoftwareFoundation.Python.3.7_qbz5n2kfra8p0\\LocalCache\\local-packages\\Python37\\site-packages\\scipy\\signal\\filter_design.py:1632: BadCoefficients: Badly conditioned filter coefficients (numerator): the results may be meaningless\n", - " \"results may be meaningless\", BadCoefficients)\n", - "C:\\Users\\matth\\AppData\\Local\\Packages\\PythonSoftwareFoundation.Python.3.7_qbz5n2kfra8p0\\LocalCache\\local-packages\\Python37\\site-packages\\scipy\\signal\\filter_design.py:1632: BadCoefficients: Badly conditioned filter coefficients (numerator): the results may be meaningless\n", - " \"results may be meaningless\", BadCoefficients)\n", - "C:\\Users\\matth\\AppData\\Local\\Packages\\PythonSoftwareFoundation.Python.3.7_qbz5n2kfra8p0\\LocalCache\\local-packages\\Python37\\site-packages\\scipy\\signal\\filter_design.py:1632: BadCoefficients: Badly conditioned filter coefficients (numerator): the results may be meaningless\n", - " \"results may be meaningless\", BadCoefficients)\n" - ] - }, { "data": { "image/png": "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", @@ -528,14 +468,6 @@ "execution_count": 12, "metadata": {}, "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "C:\\Users\\matth\\AppData\\Local\\Packages\\PythonSoftwareFoundation.Python.3.7_qbz5n2kfra8p0\\LocalCache\\local-packages\\Python37\\site-packages\\scipy\\signal\\filter_design.py:1632: BadCoefficients: Badly conditioned filter coefficients (numerator): the results may be meaningless\n", - " \"results may be meaningless\", BadCoefficients)\n" - ] - }, { "data": { "image/png": "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", From 33420cc16e06da9ecfdc1b6d9e47dd41031f41b1 Mon Sep 17 00:00:00 2001 From: mhostetter Date: Wed, 12 Jul 2023 21:29:53 -0400 Subject: [PATCH 20/20] Fix linter errors --- src/sdr/_pll.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/sdr/_pll.py b/src/sdr/_pll.py index 05c7b8f7b..17edc8824 100644 --- a/src/sdr/_pll.py +++ b/src/sdr/_pll.py @@ -83,7 +83,7 @@ def __init__( K1 = lf.K1 K2 = lf.K2 - b0 = 0 + # b0 = 0 b1 = Kp * K0 * (K1 + K2) b2 = -Kp * K0 * K1